diff --git a/.circleci/README.md b/.circleci/README.md
deleted file mode 100644
index 31e80ebd3450c..0000000000000
--- a/.circleci/README.md
+++ /dev/null
@@ -1,89 +0,0 @@
-CircleCi integration is controlled by the `./circleci/config.yml` file.  Our
-config currently contains two workflows.  One is triggered on every pull request update.
-The other workflow runs nightly to verify our compatibility with prestodb internal protocol.
-
-The PR workflow is named `dist-compile` and has 4 jobs, 2 to build and run unit tests on linux and macos
-and 2 to check code formatting and license headers:
-* linux-build
-* macos-build
-* format-check
-* header-check
-
-## Running locally
-
-The linux container based jobs can be run locally using the `circleci` cli:
-
-```
-    circleci local execute --job JOB_NAME
-```
-
-For example to run unit tests use:
-
-```
-    circleci local execute --job linux-build
-```
-
-A Nightly build with prestodb/master sync checks that the presto_protocol library
-remains in sync with Presto Java.
-
-Run the nightly sync job locally:
-```
-    circleci local execute --job presto-sync
-```
-
-## Install CircleCi cli
-```
-    curl -fLSs https://circle.ci/cli | bash
-```
-
-To use containers Docker must be installed.  Here are instructions to [Install
-Docker on macos](https://docs.docker.com/docker-for-mac/install/).  Docker deamon
-must be running before issuing the `circleci` commands.
-
-### Macos testing
-
-Macos testing is done by using the CircleCi macos executor and installing
-dependencies each time the job is run.  This executor cannot be run locally.
-The script `scripts/setup-macos.sh` contains commands that are run as part of
-this job to install these dependencies.
-
-### Linux testing
-
-Linux testing uses a Docker container. The container build depends on the Velox CircleCi container. Check
-velox/.circleci/config.yml to see that the base container in circleci-container.dockfile is using the latest.
-The container build uses Docker and should be run on your macos or linux laptop with Docker installed and
-running.
-
-#### Build the base container:
-
-* In an up-to-date clone of velox (maybe you have one?)
-
-```
-git clone git@github.com:facebookincubator/velox.git
-cd velox
-make base-container
-```
-* Wait - This step takes rather a long time.  It is building clang-format v8 to be compatible with fbcode
-* When the base container is finished the new container name will be printed on the console.
-* Push the container to DockerHub
-```
-docker push prestocpp/base-container:$USER-YYYYMMDD
-```
-* After the push, update `scripts/velox-container.dockfile` with the newly build base container name
-
-#### Build the dependencies container
-
-* If you have a new base-container update scripts/velox-container.dockfile to refer to it
-* Build the velox container
-```
-make velox-container.dockfile
-```
-* Wait - This takes a few minutes, but not nearly as long as the base container.
-* When the velox container is finished the new container name will be printed on the console.
-* Push the container to DockerHub
-```
-docker push prestocpp/velox-container:$USER-YYYYMMDD
-```
-* Update `.circleci/config.yml` with the newly built circleci container name.
-  There are two places in the config.yml file that refer to the container, update
-  both.
diff --git a/.circleci/config.yml b/.circleci/config.yml
index 303f1356521e7..b121fa7dfd36b 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -17,28 +17,17 @@ version: 2.1
 # This allows us to use CircleCI's dynamic configuration feature
 setup: true
 
-
-# Path-filtering orb is required to continue a pipeline based on
-# the path of an updated fileset
-orbs:
-  path-filtering: circleci/path-filtering@0.1.1
+jobs:
+  noop-build:
+    docker:
+      - image: cimg/base:2024.02
+    steps:
+      - run: circleci-agent step halt
 
 workflows:
   version: 2
 
   path-filtering-workflow:
     jobs:
+      - noop-build
 
-      - path-filtering/filter:
-          name: check-sensitive-paths
-
-          # Format is: <regex path-to-test> <parameter-to-set> <value-of-pipeline-parameter>
-          # Regex below will filter out paths with test in them.
-          mapping: |
-            velox/expression/((?!.*test).*).*  run-longer-expression-fuzzer true
-            velox/exec/((?!.*test).*).*  run-longer-expression-fuzzer true
-            velox/common/((?!.*test).*).*  run-longer-expression-fuzzer true
-            velox/core/((?!.*test).*).* run-longer-expression-fuzzer true
-            velox/vector/((?!.*test).*).* run-longer-expression-fuzzer true
-
-          config-path: .circleci/dist_compile.yml
diff --git a/.circleci/dist_compile.yml b/.circleci/dist_compile.yml
deleted file mode 100644
index a853ed985e11f..0000000000000
--- a/.circleci/dist_compile.yml
+++ /dev/null
@@ -1,703 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-version: 2.1
-
-
-# Default pipeline parameters, which will be updated according to
-# the results of the path-filtering orb
-parameters:
-  run-longer-expression-fuzzer:
-    type: boolean
-    default: false
-
-commands:
-  update-submodules:
-    steps:
-      - run:
-          name: "Update Submodules"
-          command: |
-            git submodule sync --recursive
-            git submodule update --init --recursive
-
-  setup-environment:
-    steps:
-      - run:
-          name: "Setup Environment"
-          command: |
-            # Calculate ccache key.
-            git show -s --format=%cd --date="format:%Y%m%d" $(git merge-base origin/main HEAD) | tee merge-base-date
-
-            # Set up xml gtest output.
-            mkdir -p /tmp/test_xml_output/
-            echo "export XML_OUTPUT_FILE=\"/tmp/test_xml_output/\"" >> $BASH_ENV
-
-            # Set up ccache configs.
-            mkdir -p .ccache
-            echo "export CCACHE_DIR=$(realpath .ccache)" >> $BASH_ENV
-            ccache -sz -M 5Gi
-            if [ -e /opt/rh/gcc-toolset-9/enable ]; then
-              source /opt/rh/gcc-toolset-9/enable
-            fi
-      - restore_cache:
-          name: "Restore CCache Cache"
-          keys:
-            - velox-ccache-debug-{{ arch }}-{{ checksum "merge-base-date" }}
-
-  pre-steps:
-    steps:
-      - checkout
-      - update-submodules
-      - setup-environment
-
-  post-steps:
-    steps:
-      - save_cache:
-          name: "Save CCache Cache"
-          key: velox-ccache-debug-{{ arch }}-{{ checksum "merge-base-date" }}
-          paths:
-            - .ccache/
-      - store_artifacts:
-          path: '_build/debug/.ninja_log'
-      - store_test_results:
-          path: '/tmp/test_xml_output/'
-
-  build-benchmarks:
-    parameters:
-      binary_output:
-        type: string
-      benchmark_class:
-        type: string
-    steps:
-      - run:
-          name: "Build Benchmarks - << parameters.benchmark_class >>"
-          command: |
-            make benchmarks-basic-build NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=8
-            ccache -s
-            mkdir -p << parameters.binary_output >>
-            cp -r --verbose _build/release/velox/benchmarks/basic/* << parameters.binary_output >>
-
-  fuzzer-run:
-    parameters:
-      fuzzer_repro:
-        type: string
-      fuzzer_output:
-        type: string
-      fuzzer_name:
-        type: string
-      fuzzer_exe:
-        type: string
-      fuzzer_args:
-        type: string
-    steps:
-      - pre-steps
-      - run:
-          name: Build
-          command: |
-            make debug NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=4
-            ccache -s
-          no_output_timeout: 1h
-      - run:
-          name: "Run << parameters.fuzzer_name >> Fuzzer"
-          command: |
-            eval ' << parameters.fuzzer_exe >> << parameters.fuzzer_args >> ' \
-                  2>&1 | tee "<< parameters.fuzzer_output >>" || ( \
-                    tail -n 1000 "<< parameters.fuzzer_output >>" ; \
-                    echo "FAIL: << parameters.fuzzer_name >> run failed"; \
-                    exit 1; \
-                  )
-                echo -e "\n << parameters.fuzzer_name >> run finished successfully."
-          no_output_timeout: 120m
-      - store_artifacts:
-          path: << parameters.fuzzer_output >>
-      - store_artifacts:
-          path: << parameters.fuzzer_repro >>
-      - post-steps
-
-executors:
-  build:
-    docker:
-      - image : ghcr.io/facebookincubator/velox-dev:circleci-avx
-    resource_class: 2xlarge
-    environment:
-      CC:  /opt/rh/gcc-toolset-9/root/bin/gcc
-      CXX: /opt/rh/gcc-toolset-9/root/bin/g++
-      VELOX_DEPENDENCY_SOURCE: BUNDLED
-      simdjson_SOURCE: BUNDLED
-  check:
-    docker:
-      - image : ghcr.io/facebookincubator/velox-dev:check-avx
-  macos-intel:
-    macos:
-      xcode: "14.3.0"
-    resource_class: macos.x86.medium.gen2
-  macos-m1:
-    macos:
-      xcode: "14.2.0"
-    resource_class: macos.m1.large.gen1
-
-jobs:
-  macos-build:
-    parameters:
-      os:
-        type: executor
-    executor: << parameters.os >>
-    environment:
-      ICU_SOURCE: BUNDLED
-      simdjson_SOURCE: BUNDLED
-    steps:
-      - checkout
-      - update-submodules
-      - restore_cache:
-          name: "Restore Dependency Cache"
-          # The version number in the key can be incremented
-          # to manually avoid the case where bad dependencies
-          # are cached, and has no other meaning.
-          # If you update it, be sure to update save_cache too.
-          key: velox-circleci-macos-{{ arch }}-deps-v1-{{ checksum ".circleci/config.yml" }}-{{ checksum "scripts/setup-macos.sh" }}
-      - run:
-          name: "Install dependencies"
-          command: |
-            set -xu
-            mkdir -p ~/deps ~/deps-src
-            curl -L https://github.com/Homebrew/brew/tarball/master | tar xz --strip 1 -C ~/deps
-            PATH=~/deps/bin:${PATH} DEPENDENCY_DIR=~/deps-src INSTALL_PREFIX=~/deps PROMPT_ALWAYS_RESPOND=n ./scripts/setup-macos.sh
-            rm -rf ~/deps/.git ~/deps/Library/Taps/  # Reduce cache size by 70%.
-          no_output_timeout: 20m
-      - save_cache:
-          name: "Save Dependency Cache"
-          # The version number in the key can be incremented
-          # to manually avoid the case where bad dependencies
-          # are cached, and has no other meaning.
-          # If you update it, be sure to update restore_cache too.
-          key: velox-circleci-macos-{{ arch }}-deps-v1-{{ checksum ".circleci/config.yml" }}-{{ checksum "scripts/setup-macos.sh" }}
-          paths:
-            - ~/deps
-      - run:
-          name: "Calculate merge-base date for CCache"
-          command: git show -s --format=%cd --date="format:%Y%m%d" $(git merge-base origin/main HEAD) | tee merge-base-date
-      - restore_cache:
-          name: "Restore CCache cache"
-          keys:
-            - velox-ccache-debug-{{ arch }}-{{ checksum "merge-base-date" }}
-      - run:
-          name: "Build on MacOS"
-          command: |
-            export PATH=~/deps/bin:~/deps/opt/bison/bin:~/deps/opt/flex/bin:${PATH}
-            mkdir -p .ccache
-            export CCACHE_DIR=$(pwd)/.ccache
-            ccache -sz -M 5Gi
-            brew install openssl@1.1
-            brew link --overwrite --force openssl@1.1
-            export PATH="/Users/distiller/deps/opt/openssl@1.1/bin:$PATH"
-            export OPENSSL_ROOT_DIR=$(brew --prefix openssl@1.1)
-            cmake \
-                -B _build/debug \
-                -GNinja \
-                -DTREAT_WARNINGS_AS_ERRORS=1 \
-                -DENABLE_ALL_WARNINGS=1 \
-                -DVELOX_ENABLE_PARQUET=ON \
-                -DCMAKE_BUILD_TYPE=Debug \
-                -DCMAKE_PREFIX_PATH=~/deps \
-                -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-                -DFLEX_INCLUDE_DIR=~/deps/opt/flex/include
-            ninja -C _build/debug
-            ccache -s
-          no_output_timeout: 1h
-      - save_cache:
-          name: "Save CCache cache"
-          key: velox-ccache-debug-{{ arch }}-{{ checksum "merge-base-date" }}
-          paths:
-            - .ccache/
-
-  linux-build:
-    executor: build
-    steps:
-      - pre-steps
-      - run:
-          name: "Build"
-          command: |
-            make debug NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=5 EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON"
-            ccache -s
-          no_output_timeout: 1h
-      - run:
-          name: "Run Unit Tests"
-          command: |
-            cd _build/debug && ctest -j 16 -VV --output-on-failure
-          no_output_timeout: 1h
-      - store_test_results:
-          path: /tmp/test_xml_output/
-      - run:
-          name: "Run Fuzzer Tests"
-          # Run fuzzer using the built executable - we do this instead of make
-          # since currently make fuzzertest tends to rebuild the project.
-          command: |
-            mkdir -p /tmp/fuzzer_repro/
-            chmod -R 777 /tmp/fuzzer_repro
-            _build/debug/velox/expression/tests/velox_expression_fuzzer_test \
-                --seed ${RANDOM} \
-                --enable_variadic_signatures \
-                --velox_fuzzer_enable_complex_types \
-                --lazy_vector_generation_ratio 0.2 \
-                --velox_fuzzer_enable_column_reuse \
-                --velox_fuzzer_enable_expression_reuse \
-                --max_expression_trees_per_step 2 \
-                --retry_with_try \
-                --enable_dereference \
-                --duration_sec 60 \
-                --logtostderr=1 \
-                --minloglevel=0 \
-                --repro_persist_path=/tmp/fuzzer_repro \
-            && echo -e "\n\nFuzzer run finished successfully."
-          no_output_timeout: 5m
-      - store_artifacts:
-          path: '/tmp/fuzzer_repro'
-      - run:
-          name: "Run Spark Fuzzer Tests"
-          command: |
-            mkdir -p /tmp/spark_fuzzer_repro/
-            chmod -R 777 /tmp/spark_fuzzer_repro
-            _build/debug/velox/expression/tests/spark_expression_fuzzer_test \
-                --seed ${RANDOM} \
-                --duration_sec 60 \
-                --enable_variadic_signatures \
-                --lazy_vector_generation_ratio 0.2 \
-                --velox_fuzzer_enable_column_reuse \
-                --velox_fuzzer_enable_expression_reuse \
-                --max_expression_trees_per_step 2 \
-                --retry_with_try \
-                --logtostderr=1 \
-                --minloglevel=0 \
-                --repro_persist_path=/tmp/spark_fuzzer_repro \
-            && echo -e "\n\nSpark Fuzzer run finished successfully."
-          no_output_timeout: 5m
-      - store_artifacts:
-          path: '/tmp/spark_fuzzer_repro'
-      - run:
-          name: "Run Spark Aggregate Fuzzer Tests"
-          command: |
-            mkdir -p /tmp/spark_aggregate_fuzzer_repro/
-            chmod -R 777 /tmp/spark_aggregate_fuzzer_repro
-            _build/debug/velox/exec/tests/spark_aggregation_fuzzer_test \
-                --seed ${RANDOM} \
-                --duration_sec 60 \
-                --logtostderr=1 \
-                --minloglevel=0 \
-                --repro_persist_path=/tmp/spark_aggregate_fuzzer_repro \
-            && echo -e "\n\nSpark Aggregation Fuzzer run finished successfully."
-          no_output_timeout: 5m
-      - store_artifacts:
-          path: '/tmp/spark_aggregate_fuzzer_repro'
-      - run:
-          name: "Run Aggregate Fuzzer Tests"
-          # Run aggregation fuzzer using the built executable.
-          command: |
-            mkdir -p /tmp/aggregate_fuzzer_repro/
-            rm -rfv /tmp/aggregate_fuzzer_repro/*
-            chmod -R 777 /tmp/aggregate_fuzzer_repro
-            _build/debug/velox/exec/tests/velox_aggregation_fuzzer_test \
-                --seed ${RANDOM} \
-                --duration_sec 60 \
-                --logtostderr=1 \
-                --minloglevel=0 \
-                --repro_persist_path=/tmp/aggregate_fuzzer_repro \
-            && echo -e "\n\nAggregation fuzzer run finished successfully."
-          no_output_timeout: 5m
-      - store_artifacts:
-          path: '/tmp/aggregate_fuzzer_repro'
-      - run:
-          name: "Run Example Binaries"
-          command: |
-            find _build/debug/velox/examples/ -maxdepth 1 -type f -executable -exec "{}" \;
-      - post-steps
-
-  linux-build-release:
-    executor: build
-    steps:
-      - pre-steps
-      - run:
-          name: Build
-          command: |
-            make release NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=8
-            ccache -s
-          no_output_timeout: 1h
-      - run:
-          name: "Run Unit Tests"
-          command: |
-            cd _build/release && ctest -j 16 -VV --output-on-failure
-          no_output_timeout: 1h
-      - post-steps
-
-  # Build with different options
-  linux-build-options:
-    executor: build
-    steps:
-      - pre-steps
-      - run:
-          name: "Build Velox Minimal"
-          command: |
-            make min_debug NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=16
-            ccache -s
-          no_output_timeout: 1h
-      - run:
-          name: "Build Velox Without Testing"
-          command: |
-            make clean
-            make debug EXTRA_CMAKE_FLAGS="-DVELOX_BUILD_TESTING=OFF" NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=16
-            ccache -s
-          no_output_timeout: 1h
-      - post-steps
-
-  linux-adapters:
-    executor: build
-    environment:
-      VELOX_DEPENDENCY_SOURCE: SYSTEM
-      ICU_SOURCE: BUNDLED
-      simdjson_SOURCE: BUNDLED
-    steps:
-      - pre-steps
-      - run:
-          name: "Install Adapter Dependencies"
-          command: |
-            mkdir -p ~/adapter-deps/install/bin
-            source /opt/rh/gcc-toolset-9/enable
-            set -xu
-            DEPENDENCY_DIR=~/adapter-deps PROMPT_ALWAYS_RESPOND=n ./scripts/setup-adapters.sh
-      - run:
-          name: "Install Minio Server"
-          command: |
-            set -xu
-            cd ~/adapter-deps/install/bin/
-            wget https://dl.min.io/server/minio/release/linux-amd64/archive/minio-20220526054841.0.0.x86_64.rpm
-            rpm -i minio-20220526054841.0.0.x86_64.rpm
-            rm minio-20220526054841.0.0.x86_64.rpm
-      - run:
-          name: "Install Hadoop Dependency"
-          command: |
-            set -xu
-            yum -y install java-1.8.0-openjdk
-      - run:
-          name: Build including all Benchmarks
-          command: |
-            EXTRA_CMAKE_FLAGS=(
-              "-DVELOX_ENABLE_BENCHMARKS=ON"
-              "-DVELOX_ENABLE_ARROW=ON"
-              "-DVELOX_ENABLE_PARQUET=ON"
-              "-DVELOX_ENABLE_HDFS=ON"
-              "-DVELOX_ENABLE_S3=ON"
-              "-DVELOX_ENABLE_GCS=ON"
-              "-DVELOX_ENABLE_SUBSTRAIT=ON"
-              "-DVELOX_ENABLE_REMOTE_FUNCTIONS=ON"
-            )
-            make release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS[*]}" AWSSDK_ROOT_DIR=~/adapter-deps/install GCSSDK_ROOT_DIR=~/adapter-deps/install NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=8
-            ccache -s
-          no_output_timeout: 1h
-      - run:
-          name: "Run Unit Tests"
-          command: |
-            conda init bash
-            source ~/.bashrc
-            conda create -y --name testbench python=3.7
-            conda activate testbench
-            pip install https://github.com/googleapis/storage-testbench/archive/refs/tags/v0.36.0.tar.gz
-            export LC_ALL=C
-            export JAVA_HOME=/usr/lib/jvm/jre-1.8.0-openjdk
-            export HADOOP_ROOT_LOGGER="WARN,DRFA"
-            export LIBHDFS3_CONF=$(pwd)/.circleci/hdfs-client.xml
-            export HADOOP_HOME='/usr/local/hadoop'
-            export PATH=~/adapter-deps/install/bin:/usr/local/hadoop/bin:${PATH}
-            cd _build/release && ctest -j 16 -VV --output-on-failure
-          no_output_timeout: 1h
-      - post-steps
-
-  linux-presto-fuzzer-run:
-    executor: build
-    environment:
-      VELOX_DEPENDENCY_SOURCE: SYSTEM
-      simdjson_SOURCE: BUNDLED
-    steps:
-      - fuzzer-run:
-          fuzzer_output: "/tmp/fuzzer.log"
-          fuzzer_repro: "/tmp/fuzzer_repro"
-          fuzzer_name: "Expression"
-          fuzzer_exe: "_build/debug/velox/expression/tests/velox_expression_fuzzer_test"
-          fuzzer_args: " --seed ${RANDOM} --lazy_vector_generation_ratio 0.2 \
-          --duration_sec 1800 --enable_variadic_signatures \
-          --velox_fuzzer_enable_complex_types \
-          --velox_fuzzer_enable_column_reuse \
-          --velox_fuzzer_enable_expression_reuse \
-          --max_expression_trees_per_step 2 \
-          --retry_with_try \
-          --enable_dereference \
-          --logtostderr=1 --minloglevel=0 \
-          --repro_persist_path=/tmp/fuzzer_repro"
-
-  linux-spark-fuzzer-run:
-    executor: build
-    environment:
-      VELOX_DEPENDENCY_SOURCE: SYSTEM
-      simdjson_SOURCE: BUNDLED
-    steps:
-      - fuzzer-run:
-          fuzzer_output: "/tmp/spark_fuzzer.log"
-          fuzzer_repro: "/tmp/spark_fuzzer_repro"
-          fuzzer_name: "Spark"
-          fuzzer_exe: "_build/debug/velox/expression/tests/spark_expression_fuzzer_test"
-          fuzzer_args: " --seed ${RANDOM} --duration_sec 600 --logtostderr=1 --minloglevel=0 \
-          --repro_persist_path=/tmp/spark_fuzzer_repro"
-
-  linux-spark-aggregate-fuzzer-run:
-    executor: build
-    environment:
-      VELOX_DEPENDENCY_SOURCE: SYSTEM
-      simdjson_SOURCE: BUNDLED
-    steps:
-      - fuzzer-run:
-          fuzzer_output: "/tmp/spark_aggregate_fuzzer.log"
-          fuzzer_repro: "/tmp/spark_aggregate_fuzzer_repro"
-          fuzzer_name: "SparkAggregate"
-          fuzzer_exe: "_build/debug/velox/exec/tests/spark_aggregation_fuzzer_test"
-          fuzzer_args: " --seed ${RANDOM} --duration_sec 600 --logtostderr=1 --minloglevel=0 \
-          --repro_persist_path=/tmp/spark_aggregate_fuzzer_repro"
-
-
-  linux-aggregate-fuzzer-run:
-    executor: build
-    environment:
-      VELOX_DEPENDENCY_SOURCE: SYSTEM
-      simdjson_SOURCE: BUNDLED
-    steps:
-      - fuzzer-run:
-          fuzzer_output: "/tmp/aggregate_fuzzer.log"
-          fuzzer_repro: "/tmp/aggregate_fuzzer_repro"
-          fuzzer_name: "Aggregate"
-          fuzzer_exe: "_build/debug/velox/exec/tests/velox_aggregation_fuzzer_test"
-          fuzzer_args: " --seed ${RANDOM} --duration_sec 3600 --logtostderr=1 --minloglevel=0 \
-          --repro_persist_path=/tmp/aggregate_fuzzer_repro"
-
-  linux-join-fuzzer-run:
-    executor: build
-    environment:
-      VELOX_DEPENDENCY_SOURCE: SYSTEM
-      simdjson_SOURCE: BUNDLED
-    steps:
-      - fuzzer-run:
-          fuzzer_output: "/tmp/join_fuzzer.log"
-          fuzzer_repro: "/tmp/join_fuzzer_repro"
-          fuzzer_name: "Join"
-          fuzzer_exe: "_build/debug/velox/exec/tests/velox_join_fuzzer_test"
-          fuzzer_args: " --seed ${RANDOM} --duration_sec 3600 --logtostderr=1 --minloglevel=0 --v=1"
-
-  format-check:
-    executor: check
-    steps:
-      - checkout
-      - run:
-          name: Check formatting
-          command: |
-            if ! make format-check; then
-              make format-fix
-              echo -e "\n==== Apply using:"
-              echo "patch -p1 \<<EOF"
-              git --no-pager diff
-              echo "EOF"
-              false
-            fi
-
-  header-check:
-    executor: check
-    steps:
-      - checkout
-      - run:
-          name: Check license headers
-          command: |
-            if ! make header-check; then
-              make header-fix
-              echo -e "\n==== Apply using:"
-              echo "patch -p1 \<<EOF"
-              git --no-pager diff
-              echo "EOF"
-              false
-            fi
-
-  doc-gen-job:
-    executor: build
-    steps:
-      - checkout
-      - update-submodules
-      - add_ssh_keys:
-          fingerprints:
-            - "7b:24:f3:1a:b1:15:97:c6:fe:06:46:27:3e:b7:6b:96"
-      - run:
-          name: "Build docs and update gh-pages"
-          command: |
-            git config --global user.email "velox@users.noreply.github.com"
-            git config --global user.name "velox"
-            git checkout main
-            conda init bash
-            source ~/.bashrc
-            conda create -y --name docgenenv python=3.7
-            conda activate docgenenv
-            pip install sphinx sphinx-tabs breathe sphinx_rtd_theme chardet
-            source /opt/rh/gcc-toolset-9/enable
-            ./scripts/gen-docs.sh docgenenv
-            git checkout gh-pages
-            cp -R velox/docs/_build/html/* docs
-            git add docs
-            if [ -n "$(git status --porcelain --untracked-files=no)" ]
-            then
-              git commit -m "Update documentation"
-              git push
-            fi
-
-
-
-  linux-pr-fuzzer-run:
-    executor: build
-    steps:
-      - pre-steps
-      - run:
-          name: "Get merge base function signatures"
-          command: |
-            source ~/.bashrc
-            conda create -y --name pyveloxenv python=3.7
-            conda activate pyveloxenv
-            cp ./scripts/signature.py /tmp/signature.py
-            pip install deepdiff
-            git remote add upstream https://github.com/facebookincubator/velox
-            git fetch upstream
-            merge_base=$(git merge-base  'upstream/main' `git rev-parse HEAD`) || \
-            { echo "::error::Failed to find merge_base"; exit 1; }
-            echo "Merge Base: $merge_base"
-            git checkout $merge_base
-            git submodule update --init --recursive
-            LD_LIBRARY_PATH=/usr/local/lib make python-clean
-            LD_LIBRARY_PATH=/usr/local/lib make python-build
-            python /tmp/signature.py export --spark spark_merge_base_signatures.json
-            python /tmp/signature.py export --presto presto_merge_base_signatures.json
-      - checkout
-      - run:
-          name: "Build"
-          command: |
-            make debug NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=4 EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON"
-            ccache -s
-          no_output_timeout: 1h
-      - run:
-          name: "Build and test PyVelox"
-          command: |
-            conda init bash
-            source ~/.bashrc
-            conda activate pyveloxenv
-            LD_LIBRARY_PATH=/usr/local/lib make python-test
-      - run:
-          name: "Check and create bias function signatures"
-          command: |
-            source ~/.bashrc
-            conda activate pyveloxenv
-            pip install deepdiff
-            python ./scripts/signature.py export --presto presto_pr_signatures.json
-            python ./scripts/signature.py export --spark spark_pr_signatures.json
-            python ./scripts/signature.py bias presto_merge_base_signatures.json presto_pr_signatures.json /tmp/presto_bias_functions
-            python ./scripts/signature.py bias spark_merge_base_signatures.json spark_pr_signatures.json /tmp/spark_bias_functions
-      - store_artifacts:
-          path: 'presto_merge_base_signatures.json'
-      - store_artifacts:
-          path: 'presto_pr_signatures.json'
-      - store_artifacts:
-          path: 'spark_merge_base_signatures.json'
-      - store_artifacts:
-          path: 'spark_pr_signatures.json'
-      - fuzzer-run:
-          fuzzer_output: "/tmp/fuzzer.log"
-          fuzzer_repro: "/tmp/fuzzer_repro"
-          fuzzer_name: "Expression Bias Run"
-          fuzzer_exe: "if [ -f /tmp/presto_bias_functions ]; then _build/debug/velox/expression/tests/velox_expression_fuzzer_test"
-          fuzzer_args: " --seed ${RANDOM} --lazy_vector_generation_ratio 0.2 \
-          --assign_function_tickets  $(cat /tmp/presto_bias_functions) \
-          --duration_sec 3600 --enable_variadic_signatures \
-          --velox_fuzzer_enable_complex_types \
-          --velox_fuzzer_enable_column_reuse \
-          --velox_fuzzer_enable_expression_reuse \
-          --max_expression_trees_per_step 2 \
-          --retry_with_try \
-          --enable_dereference \
-          --logtostderr=1 --minloglevel=0 \
-          --repro_persist_path=/tmp/fuzzer_repro ; fi"
-
-      - fuzzer-run:
-          fuzzer_output: "/tmp/spark_fuzzer.log"
-          fuzzer_repro: "/tmp/spark_fuzzer_repro"
-          fuzzer_name: "Spark Bias Run"
-          fuzzer_exe: "if [ -f /tmp/spark_bias_functions ];  then _build/debug/velox/expression/tests/spark_expression_fuzzer_test"
-          fuzzer_args: " --seed ${RANDOM} --duration_sec 3600 --logtostderr=1 --minloglevel=0 \
-          --assign_function_tickets  $(cat /tmp/spark_bias_functions) \
-          --repro_persist_path=/tmp/spark_fuzzer_repro ; fi"
-
-
-workflows:
-
-  longer-fuzzer:
-    when: << pipeline.parameters.run-longer-expression-fuzzer >>
-    jobs:
-      - linux-build
-      - linux-pr-fuzzer-run
-      - linux-build-options
-      - linux-adapters
-      - linux-presto-fuzzer-run
-      - macos-build:
-          matrix:
-            parameters:
-              os: [macos-intel]
-      - format-check
-      - header-check
-      - doc-gen-job:
-          filters:
-            branches:
-              only:
-                - main
-      - macos-build:
-          matrix:
-            parameters:
-              os: [ macos-m1 ]
-          filters:
-            branches:
-              only:
-                - main
-
-  shorter-fuzzer:
-    unless: << pipeline.parameters.run-longer-expression-fuzzer >>
-    jobs:
-      - linux-build
-      - linux-pr-fuzzer-run
-      - linux-build-options
-      - linux-adapters
-      - macos-build:
-          matrix:
-            parameters:
-              os: [ macos-intel ]
-      - format-check
-      - header-check
-      - doc-gen-job:
-          filters:
-            branches:
-              only:
-                - main
-      - macos-build:
-          matrix:
-            parameters:
-              os: [ macos-m1 ]
-          filters:
-            branches:
-              only:
-                - main
diff --git a/.clang-format b/.clang-format
index eab4576fe09a5..2211eaceb3164 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,20 +1,26 @@
 ---
 AccessModifierOffset: -1
 AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveMacros: false
 AlignConsecutiveAssignments: false
+AlignConsecutiveBitFields: false
 AlignConsecutiveDeclarations: false
-AlignEscapedNewlinesLeft: true
-AlignOperands:   false
+AlignEscapedNewlines: Left
+AlignOperands: DontAlign
 AlignTrailingComments: false
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
 AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: false
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: true
-AlwaysBreakTemplateDeclarations: true
+AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: false
 BinPackParameters: false
 BraceWrapping:
@@ -31,19 +37,27 @@ BraceWrapping:
   IndentBraces:    false
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Attach
+BreakInheritanceList: BeforeColon
 BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
 BreakAfterJavaFieldAnnotations: false
 BreakStringLiterals: false
-ColumnLimit:     80
-CommentPragmas:  '^ IWYU pragma:'
+ColumnLimit: 80
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
+DeriveLineEnding: true
 DerivePointerAlignment: false
-DisableFormat:   false
-ForEachMacros:   [ FOR_EACH, FOR_EACH_R, FOR_EACH_RANGE, ]
+DisableFormat: false
+FixNamespaceComments: true
+ForEachMacros:
+  - FOR_EACH
+  - FOR_EACH_R
+  - FOR_EACH_RANGE
+IncludeBlocks: Preserve
 IncludeCategories:
   - Regex:           '^<.*\.h(pp)?>'
     Priority:        1
@@ -52,36 +66,59 @@ IncludeCategories:
   - Regex:           '.*'
     Priority:        3
 IndentCaseLabels: true
-IndentWidth:     2
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentWidth: 2
 IndentWrappedFunctionNames: false
+InsertNewlineAtEOF: true
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
 KeepEmptyLinesAtTheStartOfBlocks: false
 MacroBlockBegin: ''
-MacroBlockEnd:   ''
+MacroBlockEnd: ''
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
 ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
 ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: false
+PenaltyBreakAssignment: 2
 PenaltyBreakBeforeFirstCallParameter: 1
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 200
 PointerAlignment: Left
-ReflowComments:  true
-SortIncludes:    true
+ReflowComments: true
+SortIncludes: true
+SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
 SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
+SpacesInAngles: false
+SpacesInConditionalStatement: false
 SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp11
-TabWidth:        8
-UseTab:          Never
+SpaceBeforeSquareBrackets: false
+Standard: Cpp11
+TabWidth: 8
+UseCRLF: false
+UseTab: Never
 ...
diff --git a/.cmake-format.yaml b/.cmake-format.yaml
new file mode 100644
index 0000000000000..91c373bf6b3b4
--- /dev/null
+++ b/.cmake-format.yaml
@@ -0,0 +1,84 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Currently this config mostly mirrors the default with the addition of custom functions
+format:
+  line_width: 80
+  tab_size: 2
+  use_tabchars: false
+  max_pargs_hwrap: 4
+  max_subgroups_hwrap: 2
+  min_prefix_chars: 4
+  max_prefix_chars: 6
+  separate_ctrl_name_with_space: false
+  separate_fn_name_with_space: false
+  dangle_parens: false
+  command_case: "canonical"
+  keyword_case: "unchanged"
+  always_wrap:
+    - set_target_properties
+    - target_sources
+    - target_link_libraries
+
+parse:
+  # We define these for our custom 
+  # functions so they get formatted correctly
+  additional_commands:
+    velox_add_library:
+      pargs:
+        nargs: 1+
+        flags:
+        - OBJECT
+        - STATIC
+        - SHARED
+        - INTERFACE
+      kwargs: {}
+
+    velox_base_add_library:
+      pargs:
+        nargs: 1+
+        flags:
+        - OBJECT
+        - STATIC
+        - SHARED
+        - INTERFACE
+      kwargs: {}
+
+    velox_compile_definitions:
+      pargs: 1 
+      kwargs:
+        PRIVATE: '*'
+        PUBLIC: '*'
+        INTERFACE: '*'
+
+    velox_include_directories:
+      pargs: '1+'
+      flags:
+        - SYSTEM
+        - BEFORE
+        - AFTER
+      kwargs:
+        PRIVATE: '*'
+        PUBLIC: '*'
+        INTERFACE: '*'
+
+    velox_link_libraries:
+      pargs: '1+'
+      kwargs:
+        PRIVATE: '*'
+        PUBLIC: '*'
+        INTERFACE: '*'
+        
+markup:
+  first_comment_is_literal: true
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000000..62d6bf44b67c1
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,21 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index 4bbd3d0c66db8..6b9c96d0426f9 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -22,6 +22,8 @@ on:
       - 'third_party/**'
       - 'pyvelox/**'
       - '.github/workflows/benchmark.yml'
+      - 'scripts/benchmark-requirements.txt'
+
   push:
     branches: [main]
 
@@ -35,11 +37,11 @@ concurrency:
 defaults:
   run:
     shell: bash
-#TODO  concurrency groups?
+
 jobs:
   benchmark:
     if: github.repository == 'facebookincubator/velox'
-    runs-on: 8-core
+    runs-on: 8-core-ubuntu
     env:
       CCACHE_DIR: "${{ github.workspace }}/.ccache/"
       CCACHE_BASEDIR: "${{ github.workspace }}"
@@ -69,10 +71,6 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
 
-      - name: "Install dependencies"
-        if: ${{ github.event_name == 'pull_request' }}
-        run: source velox/scripts/setup-ubuntu.sh
-
       - name: "Checkout Merge Base"
         if: ${{ github.event_name == 'pull_request' }}
         working-directory: velox
@@ -90,6 +88,10 @@ jobs:
           git submodule update --init --recursive
           echo $(git log -n 1)
 
+      - name: "Install dependencies"
+        if: ${{ github.event_name == 'pull_request' }}
+        run: source velox/scripts/setup-ubuntu.sh && install_apt_deps && install_duckdb
+
       - name: Build Baseline Benchmarks
         if: ${{ github.event_name == 'pull_request' }}
         working-directory: velox
@@ -115,7 +117,7 @@ jobs:
           submodules: 'recursive'
 
       - name: "Install dependencies"
-        run: source velox/scripts/setup-ubuntu.sh
+        run: source velox/scripts/setup-ubuntu.sh && install_apt_deps
 
       - name: Build Contender Benchmarks
         working-directory: velox
@@ -198,7 +200,7 @@ jobs:
           echo "::endgroup::"
 
       - name: "Save PR number"
-        run: echo "${{ github.event.pull_request.number }}" > pr_number.txt
+        run: echo "${{ github.event.pull_request.number || 0 }}" > pr_number.txt
 
       - name: "Upload PR number"
         uses: actions/upload-artifact@v3
diff --git a/.github/workflows/build-metrics.yml b/.github/workflows/build-metrics.yml
new file mode 100644
index 0000000000000..2a3285e2f6ac2
--- /dev/null
+++ b/.github/workflows/build-metrics.yml
@@ -0,0 +1,173 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Collect Build Metrics
+
+on:
+  pull_request:
+      paths:
+        - ".github/workflows/build-metrics.yml"
+        - "script/bm-report/**"
+
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: "ref to check"
+        required: true
+
+  schedule:
+    # Run every day at 04:05
+    - cron: "5 4 * * *"
+
+permissions:
+  contents: read
+
+jobs:
+  metrics:
+    name: Linux ${{ matrix.type }} with adapters
+    if: ${{ github.repository == 'facebookincubator/velox' }}
+    runs-on: ${{ matrix.runner }}
+    container: ghcr.io/facebookincubator/velox-dev:adapters
+    strategy:
+      fail-fast: false
+      matrix:
+        runner: ["16-core-ubuntu"]
+        type: ["debug", "release"]
+    defaults:
+      run:
+        shell: bash
+    env:
+      VELOX_DEPENDENCY_SOURCE: SYSTEM
+      simdjson_SOURCE: BUNDLED
+      xsimd_SOURCE: BUNDLED
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.sha }}
+
+      - name: Fix git permissions
+        # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
+
+      - name: Make ${{ matrix.type }} Build
+        env:
+          MAKEFLAGS: 'MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=4'
+        run: |
+          EXTRA_CMAKE_FLAGS=(
+            "-DVELOX_ENABLE_BENCHMARKS=ON"
+            "-DVELOX_ENABLE_ARROW=ON"
+            "-DVELOX_ENABLE_PARQUET=ON"
+            "-DVELOX_ENABLE_HDFS=ON"
+            "-DVELOX_ENABLE_S3=ON"
+            "-DVELOX_ENABLE_GCS=ON"
+            "-DVELOX_ENABLE_ABFS=ON"
+            "-DVELOX_ENABLE_REMOTE_FUNCTIONS=ON"
+          )
+          make '${{ matrix.type }}'
+
+      - name: Log binary sizes
+        run: |
+          mkdir -p /tmp/metrics
+          sizes_file=/tmp/metrics/object_sizes
+          pushd '_build/${{ matrix.type }}'
+
+          find velox -type f -name '*.so' -o -name '*.a' -exec ls -l -BB {} \; |
+            awk '{print $5, $9; total += $5} END {print total," total_lib_size"}' > $sizes_file
+
+          find velox -type f -name '*.o' -exec ls -l -BB {} \; |
+            awk '{print $5, $9; total += $5} END {print total," total_obj_size"}' >> $sizes_file
+
+          find velox -type f -name 'velox_*' -exec ls -l -BB {} \; |
+            awk '{print $5, $9; total += $5} END {print total," total_exec_size"}' >> $sizes_file
+
+      - name: Copy ninja_log
+        run: cp _build/${{ matrix.type }}/.ninja_log /tmp/metrics/.ninja_log
+
+      - name: "Install dependencies"
+        run: |
+          python3 -m pip install setuptools
+          python3 -m pip install -r scripts/benchmark-requirements.txt
+
+      - name: "Upload Metrics"
+        # This disables the upload and report generation on fork PRs but allows it for forks from within the main repo.
+        if: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == 'facebookincubator/velox' }}
+        env:
+          CONBENCH_URL: "https://velox-conbench.voltrondata.run/"
+          CONBENCH_MACHINE_INFO_NAME: "GitHub-runner-${{ matrix.runner }}"
+          CONBENCH_EMAIL: "${{ secrets.CONBENCH_EMAIL }}"
+          CONBENCH_PASSWORD: "${{ secrets.CONBENCH_PASSWORD }}"
+          # These don't actually work https://github.com/conbench/conbench/issues/1484
+          # but have to be there to work regardless??
+          CONBENCH_PROJECT_REPOSITORY: "${{ github.repository }}"
+          CONBENCH_PROJECT_COMMIT: "${{ inputs.ref || github.sha }}"
+        run: |
+          ./scripts/build-metrics.py upload \
+            --build_type "${{ matrix.type }}" \
+            --run_id "BM-${{ matrix.type }}-${{ github.run_id }}-${{ github.run_attempt }}" \
+            --pr_number "${{ github.event.number }}" \
+            --sha "${{ inputs.ref || github.sha }}" \
+            "/tmp/metrics"
+
+  upload-report:
+    if: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == 'facebookincubator/velox' }}
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    name: Generate and Upload Build Metric Report
+    needs: metrics
+    steps:
+      - name: Checkout
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          fetch-depth: 0
+
+      - name: Setup Git User
+        run: |
+          git config --global user.email "velox@users.noreply.github.com"
+          git config --global user.name "velox"
+
+      - uses: cachix/install-nix-action@8887e596b4ee1134dae06b98d573bd674693f47c # v26
+        with:
+          nix_path: nixpkgs=channel:nixos-unstable
+
+      - name: Build Environment
+        run: |
+          cd scripts/bm-report
+          nix-build
+
+      - name: Build Documentation
+        env:
+          CONBENCH_URL: "https://velox-conbench.voltrondata.run/"
+          CONBENCH_EMAIL: "${{ secrets.CONBENCH_EMAIL }}"
+          CONBENCH_PASSWORD: "${{ secrets.CONBENCH_PASSWORD }}"
+        run: |
+          cd scripts/bm-report
+          nix-shell --run "quarto render report.qmd"
+
+      - name: Push Report
+        # The report only uses conbench data from 'main'
+        # so any data generated in a PR won't be included
+        if: ${{ github.event_name != 'pull_request' && github.repository == 'facebookincubator/velox'}}
+        run: |
+          git checkout gh-pages
+          mkdir -p docs/bm-report
+          cp -R scripts/bm-report/report.html docs/bm-report/index.html
+          git add docs
+
+          if [ -n "$(git status --porcelain --untracked-files=no)" ]
+          then
+            git commit -m "Update build metrics"
+            git push
+          fi
diff --git a/.github/workflows/build_pyvelox.yml b/.github/workflows/build_pyvelox.yml
index bb01d8e804ce4..4ebd5dd17319f 100644
--- a/.github/workflows/build_pyvelox.yml
+++ b/.github/workflows/build_pyvelox.yml
@@ -46,13 +46,15 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  # TODO: https://github.com/facebookincubator/velox/issues/9014
+  if: false
   build_wheels:
     name: Build wheels on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-22.04, macos-11]
+        os: [ubuntu-22.04]
     steps:
       - uses: actions/checkout@v3
         with:
diff --git a/.github/workflows/conbench_upload.yml b/.github/workflows/conbench_upload.yml
index b59a30c142cd1..bc1fc42f03f11 100644
--- a/.github/workflows/conbench_upload.yml
+++ b/.github/workflows/conbench_upload.yml
@@ -94,7 +94,18 @@ jobs:
       run: |
         unzip benchmark-results.zip -d benchmark-results
         unzip pr_number.zip
-        echo "pr_number=$(cat pr_number.txt)" >> $GITHUB_OUTPUT
+
+        pr_number=$(grep -ox '[[:digit:]]*' pr_number.txt | head -1)
+
+        if [ "$pr_number" -ge 0 ]; then
+          echo "Found PR number: $pr_number"
+        else
+          echo '::error :: Malformed input, aborting!'
+          exit 1
+        fi
+
+        echo "pr_number=$pr_number" >> $GITHUB_OUTPUT
+
     - uses: actions/checkout@v3
       with:
         path: velox
@@ -134,7 +145,7 @@ jobs:
 
     - name: "Create a GitHub Status on the contender commit (whether the upload was successful)"
       uses: actions/github-script@v6
-      if: always()
+      if: ${{ !cancelled() && steps.extract.conclusion != 'failure' }}
       with:
         script: |
           let url = 'https://github.com/${{github.repository}}/actions/runs/${{ github.run_id }}'
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index 9a9988910e495..932fd41d13399 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -20,6 +20,7 @@ on:
       - scripts/*.dockerfile
       - scripts/setup-*.sh
       - .github/workflows/docker.yml
+      - docker-compose.yml
   push:
     branches: [main]
     paths:
@@ -38,7 +39,23 @@ permissions:
 
 jobs:
   linux:
+    name: "Build and Push ${{ matrix.name }}"
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Check
+            file: "scripts/check-container.dockfile"
+            tags: "ghcr.io/facebookincubator/velox-dev:check"
+          - name: Centos 9
+            file: "scripts/centos.dockerfile"
+            tags: "ghcr.io/facebookincubator/velox-dev:centos9"
+          - name: Dev
+            file: "scripts/ubuntu-22.04-cpp.dockerfile"
+            args: ""
+            tags: "ghcr.io/facebookincubator/velox-dev:ubuntu-22.04"
+
     steps:
       - name: Login to GitHub Container Registry
         uses: docker/login-action@v2
@@ -53,38 +70,52 @@ jobs:
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
 
-      - uses: actions/checkout@v3
-
-      - name: Build and Push check
+      - name: Build and Push
         uses: docker/build-push-action@v3
         with:
-          context: scripts
-          file: scripts/check-container.dockfile
-          build-args: cpu_target=avx
+          file: "${{ matrix.file }}"
+          build-args: "${{ matrix.args }}"
           push: ${{ github.repository == 'facebookincubator/velox' && github.event_name != 'pull_request'}}
-          tags: ghcr.io/facebookincubator/velox-dev:check-avx
+          tags: "${{ matrix.tags }}"
 
-      - name: Build and Push circle-ci
-        uses: docker/build-push-action@v3
-        with:
-          context: scripts
-          file: scripts/circleci-container.dockfile
-          build-args: cpu_target=avx
-          push: ${{ github.repository == 'facebookincubator/velox' && github.event_name != 'pull_request'}}
-          tags: ghcr.io/facebookincubator/velox-dev:circleci-avx
+  linux-needs:
+    name: "Build and Push ${{ matrix.name }}"
+    needs: linux
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Adapters
+            file: "scripts/adapters.dockerfile"
+            tags: "ghcr.io/facebookincubator/velox-dev:adapters"
+          - name: Presto Java
+            file: "scripts/prestojava-container.dockerfile"
+            args: "PRESTO_VERSION=0.288"
+            tags: "ghcr.io/facebookincubator/velox-dev:presto-java"
+          - name: Spark server
+            file: "scripts/spark-container.dockerfile"
+            args: "SPARK_VERSION=3.5.1"
+            tags: "ghcr.io/facebookincubator/velox-dev:spark-server"
 
-      - name: Build and Push velox-torcharrow
-        uses: docker/build-push-action@v3
+    steps:
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
         with:
-          context: scripts
-          file: scripts/velox-torcharrow-container.dockfile
-          build-args: cpu_target=avx
-          push: ${{ github.repository == 'facebookincubator/velox' && github.event_name != 'pull_request'}}
-          tags: ghcr.io/facebookincubator/velox-dev:torcharrow-avx
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
 
-      - name: Build and Push dev-image
+      - name: Build and Push
         uses: docker/build-push-action@v3
         with:
-          file: scripts/ubuntu-22.04-cpp.dockerfile
+          file: "${{ matrix.file }}"
+          build-args: "${{ matrix.args }}"
           push: ${{ github.repository == 'facebookincubator/velox' && github.event_name != 'pull_request'}}
-          tags: ghcr.io/facebookincubator/velox-dev:amd64-ubuntu-22.04-avx
+          tags: "${{ matrix.tags }}"
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000000000..471cdaebc9285
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,85 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Update Documentation
+
+on:
+  push:
+    paths:
+      - "velox/docs/**"
+      - ".github/workflows/docs.yml"
+
+  pull_request:
+    paths:
+      - "velox/docs/**"
+      - ".github/workflows/docs.yml"
+
+permissions:
+  contents: write
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.repository }}-${{ github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  build_docs:
+    name: Build and Push
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Checkout
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          fetch-depth: 0
+
+      - name: Setup Git User
+        run: |
+          git config --global user.email "velox@users.noreply.github.com"
+          git config --global user.name "velox"
+
+      - name: Install Dependencies
+        run: |
+          sudo apt update
+          sudo apt install -y pandoc
+          pip install sphinx sphinx-tabs breathe sphinx_rtd_theme chardet
+
+      - name: Build Documentation
+        run: |
+          cd velox/docs
+          make clean
+          # pyvelox
+          mkdir -p bindings/python
+          pandoc ../../pyvelox/README.md --from markdown --to rst -s -o bindings/python/README_generated_pyvelox.rst
+          # velox
+          make html
+
+      - name: Push Documentation
+        if: ${{ github.event_name == 'push' && github.repository == 'facebookincubator/velox'}}
+        run: |
+          git checkout gh-pages
+          cp -R velox/docs/_build/html/* docs
+          git add docs
+
+          if [ -n "$(git status --porcelain --untracked-files=no)" ]
+          then
+            git commit -m "Update documentation"
+            git push
+          fi
+
+      - name: Upload Documentation
+        if: github.event_name == 'pull_request'
+        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+        with:
+          path: velox/docs/_build/html
+          retention-days: 3
diff --git a/.github/workflows/experimental.yml b/.github/workflows/experimental.yml
new file mode 100644
index 0000000000000..9c55c338f678d
--- /dev/null
+++ b/.github/workflows/experimental.yml
@@ -0,0 +1,251 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: "Experimental Fuzzer Jobs"
+
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/experimental.yml"
+
+
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: 'Ref to checkout out'
+        default: 'main'
+      numThreads:
+        description: 'Number of threads'
+        default: 16
+      maxHighMemJobs:
+        description: 'Number of high memory jobs'
+        default: 8
+      maxLinkJobs:
+        description: 'Maximum number of link jobs'
+        default: 4
+      extraCMakeFlags:
+        description: 'Additional CMake flags'
+        default: ''
+
+defaults:
+  run:
+    shell: bash
+
+permissions:
+  contents: read
+
+jobs:
+  compile:
+    runs-on: 8-core-ubuntu
+    timeout-minutes: 120
+    env:
+      CCACHE_DIR: "${{ github.workspace }}/.ccache/"
+      LINUX_DISTRO: "ubuntu"
+    steps:
+
+      - name: "Restore ccache"
+        uses: actions/cache@v3
+        with:
+          path: "${{ env.CCACHE_DIR }}"
+          # We are using the benchmark ccache as it has all
+          # required features enabled, so no need to create a new one
+          key: ccache-benchmark-${{ github.sha }}
+          restore-keys: |
+            ccache-benchmark-
+      - name: "Checkout Repo"
+        uses: actions/checkout@v3
+        with:
+          path: velox
+          submodules: 'recursive'
+          ref: "${{ inputs.ref || 'main' }}"
+
+      - name: "Install dependencies"
+        run: cd  velox && source ./scripts/setup-ubuntu.sh && install_apt_deps
+
+      - name: "Build"
+        run: |
+          cd velox
+          make debug NUM_THREADS="${{ inputs.numThreads || 8 }}" MAX_HIGH_MEM_JOBS="${{ inputs.maxHighMemJobs || 8 }}" MAX_LINK_JOBS="${{ inputs.maxLinkJobs || 4 }}" EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON ${{ inputs.extraCMakeFlags }}"
+          ccache -s
+
+      - name: Upload aggregation fuzzer
+        uses: actions/upload-artifact@v3
+        with:
+          name: aggregation
+          path: velox/_build/debug/velox/functions/prestosql/fuzzer/velox_aggregation_fuzzer_test
+
+      - name: Upload spark aggregation fuzzer
+        uses: actions/upload-artifact@v3
+        with:
+          name: spark_aggregation_fuzzer
+          path: velox/_build/debug/velox/functions/sparksql/fuzzer/spark_aggregation_fuzzer_test
+
+      - name: Upload aggregation fuzzer
+        uses: actions/upload-artifact@v3
+        with:
+          name: aggregation
+          path: velox/_build/debug/velox/functions/prestosql/fuzzer/velox_aggregation_fuzzer_test
+
+      - name: Upload join fuzzer
+        uses: actions/upload-artifact@v3
+        with:
+          name: join
+          path: velox/_build/debug/velox/exec/tests/velox_join_fuzzer_test
+
+  presto-java-aggregation-fuzzer-run:
+    runs-on: 8-core-ubuntu
+    container: ghcr.io/facebookincubator/velox-dev:presto-java
+    timeout-minutes: 120
+    env:
+      CCACHE_DIR: "${{ github.workspace }}/.ccache/"
+      LINUX_DISTRO: "centos"
+    steps:
+
+      - name: "Restore ccache"
+        uses: actions/cache@v3
+        with:
+          path: "${{ env.CCACHE_DIR }}"
+          # We are using the benchmark ccache as it has all
+          # required features enabled, so no need to create a new one
+          key: ccache-presto-${{ github.sha }}
+          restore-keys: |
+            ccache-presto-
+
+      - name: "Checkout Repo"
+        uses: actions/checkout@v3
+        with:
+          path: velox
+          submodules: 'recursive'
+          ref: "${{ inputs.ref || 'main' }}"
+
+
+      - name: "Build"
+        run: |
+          cd velox
+          source /opt/rh/gcc-toolset-12/enable
+          make debug NUM_THREADS="${{ inputs.numThreads || 8 }}" MAX_HIGH_MEM_JOBS="${{ inputs.maxHighMemJobs || 8 }}" MAX_LINK_JOBS="${{ inputs.maxLinkJobs || 4 }}" EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON ${{ inputs.extraCMakeFlags }}"
+          ccache -s
+
+      - name: "Run Aggregate Fuzzer"
+        run: |
+          cd  velox
+          cp ./scripts/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
+          ls -lR $PRESTO_HOME/etc
+          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          # Sleep for 60 seconds to allow Presto server to start.
+          sleep 60
+          /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA hive.tpch;'
+          mkdir -p /tmp/aggregate_fuzzer_repro/
+          rm -rfv /tmp/aggregate_fuzzer_repro/*
+          chmod -R 777 /tmp/aggregate_fuzzer_repro
+          _build/debug/velox/functions/prestosql/fuzzer/velox_aggregation_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec 3600 \
+                --logtostderr=1 \
+                --minloglevel=0 \
+                --repro_persist_path=/tmp/aggregate_fuzzer_repro \
+                --enable_sorted_aggregations=true \
+                --presto_url=http://127.0.0.1:8080 \
+          && echo -e "\n\nAggregation fuzzer run finished successfully."
+
+      - name: Archive aggregate production artifacts
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: aggregate-fuzzer-failure-artifacts
+          path: |
+            /tmp/aggregate_fuzzer_repro
+            /tmp/server.log
+
+  linux-spark-fuzzer-run:
+    runs-on: ubuntu-latest
+    needs: compile
+    timeout-minutes: 120
+    steps:
+
+      - name: "Checkout Repo"
+        uses: actions/checkout@v3
+        with:
+          ref: "${{ inputs.ref || 'main' }}"
+
+      - name: "Install dependencies"
+        run: source ./scripts/setup-ubuntu.sh && install_apt_deps
+
+      - name: Download spark aggregation fuzzer
+        uses: actions/download-artifact@v3
+        with:
+          name: spark_aggregation_fuzzer
+
+      - name: "Run Spark Aggregate Fuzzer"
+        run: |
+          mkdir -p /tmp/spark_aggregate_fuzzer_repro/
+          chmod -R 777 /tmp/spark_aggregate_fuzzer_repro
+          chmod +x spark_aggregation_fuzzer_test
+          ./spark_aggregation_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec 1800 \
+                --logtostderr=1 \
+                --minloglevel=0 \
+                --repro_persist_path=/tmp/spark_aggregate_fuzzer_repro \
+                --enable_sorted_aggregations=true \
+          && echo -e "\n\nSpark Aggregation Fuzzer run finished successfully."
+
+      - name: Archive Spark aggregate production artifacts
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: spark-agg-fuzzer-failure-artifacts
+          path: |
+            /tmp/spark_aggregate_fuzzer_repro
+
+  linux-join-fuzzer-run:
+    runs-on: ubuntu-latest
+    needs: compile
+    timeout-minutes: 120
+    steps:
+
+      - name: "Checkout Repo"
+        uses: actions/checkout@v3
+        with:
+          ref: "${{ inputs.ref || 'main' }}"
+
+      - name: "Install dependencies"
+        run: source ./scripts/setup-ubuntu.sh && install_apt_deps
+
+      - name: Download join fuzzer
+        uses: actions/download-artifact@v3
+        with:
+          name: join
+
+      - name: "Run Join Fuzzer"
+        run: |
+          ls /lib64
+          mkdir -p /tmp/join_fuzzer_repro/
+          rm -rfv /tmp/join_fuzzer_repro/*
+          chmod -R 777 /tmp/join_fuzzer_repro
+          chmod +x velox_join_fuzzer_test
+          ./velox_join_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec 1800 \
+                --logtostderr=1 \
+                --minloglevel=0 \
+            && echo -e "\n\nAggregation fuzzer run finished successfully."
+
+      - name: Archive aggregate production artifacts
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: join-fuzzer-failure-artifacts
+          path: |
+            /tmp/join_fuzzer_repro
diff --git a/.github/workflows/linux-build.yml b/.github/workflows/linux-build.yml
new file mode 100644
index 0000000000000..1ca5cce9c7ecf
--- /dev/null
+++ b/.github/workflows/linux-build.yml
@@ -0,0 +1,194 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Linux Build
+
+on:
+  push:
+    branches:
+      - "main"
+    paths:
+      - "velox/**"
+      - "!velox/docs/**"
+      - "CMakeLists.txt"
+      - "CMake/**"
+      - "third_party/**"
+      - "scripts/setup-ubuntu.sh"
+      - "scripts/setup-helper-functions.sh"
+      - ".github/workflows/linux-build.yml"
+
+  pull_request:
+    paths:
+      - "velox/**"
+      - "!velox/docs/**"
+      - "CMakeLists.txt"
+      - "CMake/**"
+      - "third_party/**"
+      - "scripts/setup-ubuntu.sh"
+      - "scripts/setup-helper-functions.sh"
+      - ".github/workflows/linux-build.yml"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.repository }}-${{ github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  adapters:
+    name: Linux release with adapters
+    # prevent errors when forks ff their main branch
+    if: ${{ github.repository == 'facebookincubator/velox' }}
+    runs-on: 8-core-ubuntu
+    container: ghcr.io/facebookincubator/velox-dev:adapters
+    defaults:
+      run:
+        shell: bash
+    env:
+      CCACHE_DIR: "${{ github.workspace }}/.ccache"
+      VELOX_DEPENDENCY_SOURCE: SYSTEM
+      simdjson_SOURCE: BUNDLED
+      xsimd_SOURCE: BUNDLED
+      CUDA_VERSION: "12.4"
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Fix git permissions
+        # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
+
+      - name: Install Dependencies
+        run: |
+          # Allows to install arbitrary cuda-version whithout needing to update
+          # docker container before. It simplifies testing new/different versions
+          if ! yum list installed cuda-nvcc-$(echo ${CUDA_VERSION} | tr '.' '-') 1>/dev/null; then
+            source scripts/setup-centos9.sh
+            install_cuda ${CUDA_VERSION}
+          fi
+
+      - name: Install Minio
+        run: |
+          MINIO_BINARY="minio-2022-05-26"
+          if [ ! -f /usr/local/bin/${MINIO_BINARY} ]; then
+            wget https://dl.min.io/server/minio/release/linux-amd64/archive/minio.RELEASE.2022-05-26T05-48-41Z -O ${MINIO_BINARY}
+            chmod +x ./${MINIO_BINARY}
+            mv ./${MINIO_BINARY} /usr/local/bin/
+          fi
+
+      - uses: assignUser/stash/restore@v1
+        with:
+          path: '${{ env.CCACHE_DIR }}'
+          key: ccache-linux-adapters
+
+      - name: "Zero Ccache Statistics"
+        run: |
+          ccache -sz
+
+      - name: Make Release Build
+        env:
+          MAKEFLAGS: 'NUM_THREADS=8 MAX_HIGH_MEM_JOBS=4 MAX_LINK_JOBS=4'
+          CUDA_ARCHITECTURES: 70
+          CUDA_COMPILER: /usr/local/cuda-${CUDA_VERSION}/bin/nvcc
+          # Set compiler to GCC 12
+          CUDA_FLAGS: "-ccbin /opt/rh/gcc-toolset-12/root/usr/bin"
+        run: |
+          EXTRA_CMAKE_FLAGS=(
+            "-DVELOX_ENABLE_BENCHMARKS=ON"
+            "-DVELOX_ENABLE_ARROW=ON"
+            "-DVELOX_ENABLE_PARQUET=ON"
+            "-DVELOX_ENABLE_HDFS=ON"
+            "-DVELOX_ENABLE_S3=ON"
+            "-DVELOX_ENABLE_GCS=ON"
+            "-DVELOX_ENABLE_ABFS=ON"
+            "-DVELOX_ENABLE_REMOTE_FUNCTIONS=ON"
+            "-DVELOX_ENABLE_GPU=ON"
+            "-DVELOX_MONO_LIBRARY=ON"
+          )
+          make release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS[*]}"
+
+      - name: Ccache after
+        run: ccache -s
+
+      - uses: assignUser/stash/save@v1
+        with:
+          path: '${{ env.CCACHE_DIR }}'
+          key: ccache-linux-adapters
+
+      - name: Run Tests
+        # Some of the adapters dependencies are in the 'adapters' conda env
+        shell: mamba run --no-capture-output -n adapters /usr/bin/bash -e {0}
+        env:
+          LIBHDFS3_CONF: "${{ github.workspace }}/scripts/hdfs-client.xml"
+        working-directory: _build/release
+        run: |
+          ctest -j 8 --output-on-failure --no-tests=error
+
+  ubuntu-debug:
+    runs-on: 8-core-ubuntu
+    # prevent errors when forks ff their main branch
+    if: ${{ github.repository == 'facebookincubator/velox' }}
+    name: "Ubuntu debug with resolve_dependency"
+    env:
+      CCACHE_DIR: "${{ github.workspace }}/.ccache"
+    defaults:
+      run:
+        shell: bash
+        working-directory: velox
+    steps:
+
+      - name: Get Ccache Stash
+        uses: assignUser/stash/restore@v1
+        with:
+          path: '${{ env.CCACHE_DIR }}'
+          key: ccache-ubuntu-debug-default
+
+      - name: Ensure Stash Dirs Exists
+        working-directory: ${{ github.workspace }}
+        run: |
+          mkdir -p '${{ env.CCACHE_DIR }}'
+
+      - uses: actions/checkout@v4
+        with:
+          path: velox
+
+      - name: Install Dependencies
+        run: |
+          source scripts/setup-ubuntu.sh && install_apt_deps
+
+      - name: Clear CCache Statistics
+        run: |
+          ccache -sz
+
+      - name: Make Debug Build
+        env:
+          VELOX_DEPENDENCY_SOURCE: BUNDLED
+          MAKEFLAGS: "NUM_THREADS=8 MAX_HIGH_MEM_JOBS=4 MAX_LINK_JOBS=3"
+          EXTRA_CMAKE_FLAGS: "-DVELOX_ENABLE_ARROW=ON -DVELOX_ENABLE_PARQUET=ON"
+        run: |
+          make debug 
+
+      - name: CCache after
+        run: |
+          ccache -vs
+
+      - uses: assignUser/stash/save@v1
+        with:
+          path: '${{ env.CCACHE_DIR }}'
+          key: ccache-ubuntu-debug-default
+
+      - name: Run Tests
+        run: |
+          cd _build/debug && ctest -j 8 --output-on-failure --no-tests=error
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
new file mode 100644
index 0000000000000..63672ec7aa87a
--- /dev/null
+++ b/.github/workflows/macos.yml
@@ -0,0 +1,109 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+name: macOS Build
+
+on:
+  push:
+    paths:
+      - "velox/**"
+      - "!velox/docs/**"
+      - "CMakeLists.txt"
+      - "CMake/**"
+      - "third_party/**"
+      - ".github/workflows/macos.yml"
+
+  pull_request:
+    paths:
+      - "velox/**"
+      - "!velox/docs/**"
+      - "CMakeLists.txt"
+      - "CMake/**"
+      - "third_party/**"
+      - ".github/workflows/macos.yml"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.repository }}-${{ github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  macos-build:
+    name: "${{ matrix.os }}"
+    strategy:
+      fail-fast: false
+      matrix:
+        # macos-13 = x86_64 Mac
+        # macos-14 = arm64 Mac
+        os: [macos-13, macos-14]
+    runs-on: ${{ matrix.os }}
+    env:
+      CCACHE_DIR: '${{ github.workspace }}/.ccache'
+      # The arm runners have only 7GB RAM
+      BUILD_TYPE: "${{ matrix.os ==  'macos-14' && 'Release' || 'Debug' }}"
+      INSTALL_PREFIX: "/tmp/deps-install"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install Dependencies
+        env:
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: "TRUE"
+        run: |
+          source scripts/setup-macos.sh
+          install_build_prerequisites
+          install_velox_deps_from_brew
+          install_double_conversion
+
+          echo "NJOBS=`sysctl -n hw.ncpu`" >> $GITHUB_ENV
+          brew unlink protobuf || echo "protobuf not installed"
+          brew link --force protobuf@21
+
+      - name: Cache ccache
+        uses: assignUser/stash/restore@v1
+        with:
+          path: '${{ env.CCACHE_DIR }}'
+          key: ccache-macos-1-${{ matrix.os }}
+
+      - name: Configure Build
+        env:
+          folly_SOURCE: BUNDLED #brew folly does not have int128
+          fmt_SOURCE: BUNDLED #brew fmt11 is not supported
+        run: |
+            ccache -sz -M 5Gi
+            cmake \
+                -B _build/$BUILD_TYPE \
+                -GNinja \
+                -DTREAT_WARNINGS_AS_ERRORS=1 \
+                -DENABLE_ALL_WARNINGS=1 \
+                -DVELOX_ENABLE_PARQUET=ON \
+                -DVELOX_MONO_LIBRARY=ON \
+                -DCMAKE_BUILD_TYPE=$BUILD_TYPE
+
+      - name: Build
+        run: |
+            cmake --build _build/$BUILD_TYPE -j $NJOBS
+            ccache -s
+
+      - uses: assignUser/stash/save@v1
+        with:
+          path: '${{ env.CCACHE_DIR }}'
+          key: ccache-macos-1-${{ matrix.os }}
+
+      - name: Run Tests
+        if: false
+        run: ctest -j $NJOBS --test-dir _build/debug --output-on-failure
diff --git a/.github/workflows/preliminary_checks.yml b/.github/workflows/preliminary_checks.yml
new file mode 100644
index 0000000000000..cba762d02cb0e
--- /dev/null
+++ b/.github/workflows/preliminary_checks.yml
@@ -0,0 +1,72 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+name: Run Checks
+
+on:
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.repository }}-${{ github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  check-matrix:
+    name: ${{ matrix.config.name }}
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:check
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+          - { name: "License Header",
+              command: "header-fix",
+              message: "Found missing License Header(s)",
+            }
+          - { name: "Code Format",
+              command: "format-fix",
+              message: "Found format issues"
+            }
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Fix git permissions
+        # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}
+
+      - name: Check ${{ matrix.config.name }}
+        run: |
+          make ${{ matrix.config.command }}
+
+          if ! git diff --quiet; then
+            diff=`git --no-pager diff`
+            echo "${{ matrix.command.message }} in the following files:"
+            git --no-pager diff --name-only
+            echo "Check the Job summary for a copy-pasteable patch."
+
+            echo "> [!IMPORTANT]" >> $GITHUB_STEP_SUMMARY
+            echo "${{ matrix.config.message }}" >> $GITHUB_STEP_SUMMARY
+            echo "> Please apply fix using:"  >> $GITHUB_STEP_SUMMARY
+            echo "\`\`\`sh" >> $GITHUB_STEP_SUMMARY
+            echo "patch -p1 <<EOF" >> $GITHUB_STEP_SUMMARY
+            echo "$diff" >> $GITHUB_STEP_SUMMARY
+            echo "EOF" >> $GITHUB_STEP_SUMMARY
+            echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
+            exit 1
+          fi
diff --git a/.github/workflows/scheduled.yml b/.github/workflows/scheduled.yml
index a514f7e6fc61e..a487dd4bbb4c6 100644
--- a/.github/workflows/scheduled.yml
+++ b/.github/workflows/scheduled.yml
@@ -12,44 +12,369 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-name: "Scheduled Fuzzer Jobs"
+name: "Fuzzer Jobs"
 
 on:
+  pull_request:
+    paths:
+      - "velox/**"
+      - "!velox/docs/**"
+      - "CMakeLists.txt"
+      - "CMake/**"
+      - "third_party/**"
+      - "scripts/setup-ubuntu.sh"
+      - "scripts/setup-helper-functions.sh"
+      - ".github/workflows/scheduled.yml"
+
+  push:
+    branches:
+      - "main"
+    paths:
+      - "velox/**"
+      - "!velox/docs/**"
+      - "CMakeLists.txt"
+      - "CMake/**"
+      - "third_party/**"
+      - "scripts/setup-ubuntu.sh"
+      - "scripts/setup-helper-functions.sh"
+      - ".github/workflows/scheduled.yml"
+
   schedule:
     - cron: '0 3 * * *'
 
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: 'Ref to checkout out'
+        default: 'main'
+      numThreads:
+        description: 'Number of threads'
+        default: 16
+      maxHighMemJobs:
+        description: 'Number of high memory jobs'
+        default: 8
+      maxLinkJobs:
+        description: 'Maximum number of link jobs'
+        default: 4
+      extraCMakeFlags:
+        description: 'Additional CMake flags'
+        default: ''
+      duration:
+        description: 'Duration of fuzzer run in seconds'
+        default: 1800
+
 defaults:
   run:
     shell: bash
 
+permissions:
+  contents: read
+
+concurrency:
+  # This will not cancel fuzzer runs on main (regardless of which trigger)
+  # by making the commit sha part of the group but will use the branch
+  # name in PRs to cancel on going runs on a new commit.
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.event_name == 'pull_request' && github.head_ref || github.sha  }}
+  cancel-in-progress: true
+
+env:
+  # Run for 15 minute on PRs
+  DURATION: "${{ inputs.duration || ( github.event_name != 'schedule' && 900 || 1800 )}}"
+  # minimize artifact duration for PRs, keep them a bit longer for nightly runs
+  RETENTION: "${{ github.event_name == 'pull_request' && 1 || 3 }}"
+
 jobs:
-  linux-presto-fuzzer-run:
-    runs-on: 8-core
+  compile:
+    name: Build
+    # prevent errors when forks ff their main branch
+    if: ${{ github.repository == 'facebookincubator/velox' }}
+    runs-on: 16-core-ubuntu
+    container: ghcr.io/facebookincubator/velox-dev:centos9
     timeout-minutes: 120
     env:
-      CCACHE_DIR: "${{ github.workspace }}/.ccache/"
-      CCACHE_BASEDIR: "${{ github.workspace }}"
+      CCACHE_DIR: "${{ github.workspace }}/.ccache"
       LINUX_DISTRO: "ubuntu"
+      MAKEFLAGS: "NUM_THREADS=${{ inputs.numThreads || 16 }} MAX_HIGH_MEM_JOBS=${{ inputs.maxHighMemJobs || 8 }} MAX_LINK_JOBS=${{ inputs.maxLinkJobs || 4 }}"
+
+    defaults:
+      run:
+        shell: bash
+        working-directory: velox
+    outputs:
+      presto_bias: ${{ steps.sig-check.outputs.presto_functions }}
+      presto_error: ${{ steps.sig-check.outputs.presto_error }}
+      spark_bias: ${{ steps.sig-check.outputs.spark_functions }}
+      spark_error: ${{ steps.sig-check.outputs.spark_error }}
+      presto_aggregate_bias: ${{ steps.sig-check.outputs.presto_aggregate_functions }}
+      presto_aggregate_error: ${{ steps.sig-check.outputs.presto_aggregate_error }}
+
     steps:
 
-      - name: "Checkout Repo"
-        uses: actions/checkout@v3
+      - name: Get latest commit from main
+        if: ${{ github.event_name != 'schedule' }}
+        working-directory: ${{ github.workspace }}
+        env:
+          GH_TOKEN: ${{ github.token }}
+        id: get-head
+        run: |
+          if [ '${{ github.event_name == 'push' }}' == "true" ]; then
+            # get the parent commit of the current one to get the relevant function signatures
+            head_main=$(gh api -q '.parents.[0].sha' '/repos/facebookincubator/velox/commits/${{ github.sha }}')
+          else
+            head_main=$(gh api -H "Accept: application/vnd.github.sha" /repos/facebookincubator/velox/commits/heads/main)
+          fi
+          echo "head_main=$head_main" >> $GITHUB_OUTPUT
+
+      - name: Get Function Signature Stash
+        uses: assignUser/stash/restore@v1
+        id: get-sig
+        with:
+          path: /tmp/signatures
+          key: function-signatures-${{ steps.get-head.outputs.head_main || github.sha }}
+
+      - name: Restore ccache
+        uses: assignUser/stash/restore@v1
+        with:
+          path: "${{ env.CCACHE_DIR }}"
+          key: ccache-fuzzer-centos
+
+      - name: Fix git permissions
+        working-directory: ${{ github.workspace }}
+          # Usually actions/checkout does this but as we run in a container
+          # it doesn't work
+        run: |
+          git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox
+          git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox_main
+
+      - name: Ensure Stash Dirs Exists
+        working-directory: ${{ github.workspace }}
+        run: |
+          mkdir -p '${{ env.CCACHE_DIR }}'
+          mkdir -p /tmp/signatures
+
+      - name: Checkout Main
+        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' }}
+        uses: actions/checkout@v4
         with:
+          ref: ${{ steps.get-head.outputs.head_main || 'main' }}
+          path: velox_main
+
+      - name: Build PyVelox
+        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' }}
+        working-directory: velox_main
+        run: |
+          python3 -m venv .venv
+          source .venv/bin/activate
+
+          make python-build
+
+      - name: Create Baseline Signatures
+        if: ${{ github.event_name != 'schedule' && steps.get-sig.outputs.stash-hit != 'true' }}
+        working-directory: velox_main
+        run: |
+          source .venv/bin/activate
+          python3 -m pip install deepdiff
+          python3 scripts/signature.py export --spark /tmp/signatures/spark_signatures_main.json
+          python3 scripts/signature.py export --presto /tmp/signatures/presto_signatures_main.json
+          python3 scripts/signature.py export_aggregates --presto /tmp/signatures/presto_aggregate_signatures_main.json
+
+      - name: Save Function Signature Stash
+        if: ${{ github.event_name == 'pull_request' && steps.get-sig.outputs.stash-hit != 'true' }}
+        uses: assignUser/stash/save@v1
+        with:
+          path: /tmp/signatures
+          key: function-signatures-${{ steps.get-head.outputs.head_main }}
+
+      - name: Checkout Contender
+        uses: actions/checkout@v4
+        with:
+          path: velox
           submodules: 'recursive'
+          ref: "${{ inputs.ref }}"
 
-      - name: "Install dependencies"
-        run: source ./scripts/setup-ubuntu.sh
+      - name: Zero Ccache Statistics
+        run: |
+          ccache -sz
 
-      - name: "Build"
+      - name: Build
+        env:
+          EXTRA_CMAKE_FLAGS: "-DVELOX_ENABLE_ARROW=ON -DVELOX_BUILD_PYTHON_PACKAGE=ON ${{ inputs.extraCMakeFlags }}"
         run: |
-          make debug NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=6 EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON"
-          ccache -s
+          EXTRA_CMAKE_FLAGS="-DPYTHON_EXECUTABLE=$(which python3) $EXTRA_CMAKE_FLAGS"
+          make debug
 
-      - name: "Run Presto Fuzzer"
+      - name: Ccache after
+        run: ccache -s
+
+      - name: Save ccache
+        # see https://github.com/actions/upload-artifact/issues/543
+        continue-on-error: true
+        if: ${{ github.event_name != 'schedule' }}
+        uses: assignUser/stash/save@v1
+        with:
+          path: "${{ env.CCACHE_DIR }}"
+          key: ccache-fuzzer-centos
+
+      - name: Build PyVelox
+        if: ${{ github.event_name != 'schedule' }}
+        env:
+          VELOX_BUILD_DIR: "_build/debug"
+        run: |
+          python3 -m venv .venv
+          source .venv/bin/activate
+          python3 -m pip install -e .
+
+      - name: Create and test new function signatures
+        if: ${{ github.event_name != 'schedule' }}
+        id: sig-check
         run: |
-          mkdir -p /tmp/fuzzer_repro/
+          source .venv/bin/activate
+          python3 -m pip install deepdiff
+          python3 scripts/signature.py gh_bias_check presto spark
+          python3 scripts/signature.py export_aggregates --presto /tmp/signatures/presto_aggregate_signatures_contender.json
+          python3 scripts/signature.py bias_aggregates  /tmp/signatures/presto_aggregate_signatures_main.json \
+           /tmp/signatures/presto_aggregate_signatures_contender.json /tmp/signatures/presto_aggregate_bias_functions \
+           /tmp/signatures/presto_aggregate_errors
+
+      - name: Upload Signature Artifacts
+        if: ${{ github.event_name != 'schedule' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: signatures
+          path: /tmp/signatures
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Prepare signatures
+        working-directory: /tmp/signatures
+        if: ${{ github.event_name == 'push' }}
+        run: |
+          # Remove irrelevant artifacts
+          rm -f *_bias_functions
+          rm -f *_signatures_main.json
+          # Rename signature files as 'main' files
+          for f in *_signatures_contender.json; do
+            mv "$f" "${f/_contender.json/_main.json}"
+          done
+
+      - name: Save Function Signature Stash
+        if: ${{ github.event_name == 'push' }}
+        uses: assignUser/stash/save@v1
+        with:
+          path: /tmp/signatures
+          key: function-signatures-${{ github.sha }}
+
+      - name: Upload presto fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: presto
+          path: velox/_build/debug/velox/expression/fuzzer/velox_expression_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Upload spark expression fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: spark_expression_fuzzer
+          path: velox/_build/debug/velox/expression/fuzzer/spark_expression_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Upload spark aggregation fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: spark_aggregation_fuzzer
+          path: velox/_build/debug/velox/functions/sparksql/fuzzer/spark_aggregation_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Upload aggregation fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: aggregation
+          path: velox/_build/debug/velox/functions/prestosql/fuzzer/velox_aggregation_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Upload join fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: join
+          path: velox/_build/debug/velox/exec/tests/velox_join_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Upload exchange fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: exchange
+          path: velox/_build/debug//velox/exec/tests/velox_exchange_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Upload window fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: window
+          path: velox/_build/debug/velox/functions/prestosql/fuzzer/velox_window_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Upload row number fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: row_number
+          path: velox/_build/debug//velox/exec/tests/velox_row_number_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+      - name: Upload writer fuzzer
+        uses: actions/upload-artifact@v4
+        with:
+          name: writer
+          path: velox/_build/debug/velox/functions/prestosql/fuzzer/velox_writer_fuzzer_test
+          retention-days: "${{ env.RETENTION }}"
+
+  presto-fuzzer-run:
+    name: Presto Fuzzer
+    if: ${{ needs.compile.outputs.presto_bias  != 'true' }}
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:centos9
+    needs: compile
+    timeout-minutes: 120
+    steps:
+
+      - uses: dorny/paths-filter@v3
+        if: github.event_name == 'pull_request'
+        id: changes
+        with:
+          filters: |
+            presto:
+              - 'velox/expression/!(test)**'
+              - 'velox/exec/!(test)**'
+              - 'velox/common/!(test)**'
+              - 'velox/core/!(test)**'
+              - 'velox/vector/!(test)**'
+
+      - name: Set presto specific fuzzer duration
+        env:
+          # Run for 30 minutes instead of 15, when files relevant to presto are touched
+          pr_duration: "${{ steps.changes.outputs.presto == 'true' && 1800 || 900 }}"
+          # Run for 60 minutes if its a scheduled run
+          other_duration: "${{ inputs.duration || (github.event_name == 'push' && 1800 || 3600) }}"
+          is_pr: "${{ github.event_name == 'pull_request' }}"
+        run: |
+
+          if [ "$is_pr" == "true" ]; then
+            duration=$pr_duration
+          else
+            duration=$other_duration
+          fi
+
+          echo "DURATION=$duration" >> $GITHUB_ENV
+
+      - name: Download presto fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: presto
+
+      - name: Run Presto Fuzzer
+        run: |
+          mkdir -p /tmp/fuzzer_repro/logs/
           chmod -R 777 /tmp/fuzzer_repro
-          _build/debug/velox/expression/tests/velox_expression_fuzzer_test \
+          chmod +x velox_expression_fuzzer_test
+          ./velox_expression_fuzzer_test \
                 --seed ${RANDOM} \
                 --enable_variadic_signatures \
                 --velox_fuzzer_enable_complex_types \
@@ -59,49 +384,172 @@ jobs:
                 --max_expression_trees_per_step 2 \
                 --retry_with_try \
                 --enable_dereference \
-                --duration_sec 3600 \
-                --logtostderr=1 \
+                --duration_sec $DURATION \
                 --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/fuzzer_repro/logs \
                 --repro_persist_path=/tmp/fuzzer_repro \
           && echo -e "\n\nFuzzer run finished successfully."
 
       - name: Archive production artifacts
-        if: always()
-        uses: actions/upload-artifact@v3
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
         with:
           name: presto-fuzzer-failure-artifacts
           path: |
             /tmp/fuzzer_repro
-            
-  
 
-  linux-spark-fuzzer-run:
-    runs-on: 8-core
+  presto-bias-fuzzer:
+    name: Presto Bias Fuzzer
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:centos9
+    needs: compile
+    if: ${{ needs.compile.outputs.presto_bias  == 'true' }}
     timeout-minutes: 120
-    env:
-      CCACHE_DIR: "${{ github.workspace }}/.ccache/"
-      CCACHE_BASEDIR: "${{ github.workspace }}"
-      LINUX_DISTRO: "ubuntu"
     steps:
 
-      - name: "Checkout Repo"
-        uses: actions/checkout@v3
+      - name: Download presto expression fuzzer
+        uses: actions/download-artifact@v4
         with:
-          submodules: 'recursive'
+          name: presto
+
+      - name: Download Signatures
+        uses: actions/download-artifact@v4
+        with:
+          name: signatures
+          path: /tmp/signatures
+
+      - name: Run Presto Expression Fuzzer
+        run: |
+          ls /tmp/signatures
+          mkdir -p /tmp/presto_bias_fuzzer_repro/logs/
+            chmod -R 777 /tmp/presto_bias_fuzzer_repro
+            chmod +x velox_expression_fuzzer_test
+            ./velox_expression_fuzzer_test \
+                --seed ${RANDOM} \
+                --lazy_vector_generation_ratio 0.2 \
+                --assign_function_tickets  $(cat /tmp/signatures/presto_bias_functions) \
+                --duration_sec 3600 \
+                --enable_variadic_signatures \
+                --velox_fuzzer_enable_complex_types \
+                --velox_fuzzer_enable_column_reuse \
+                --velox_fuzzer_enable_expression_reuse \
+                --max_expression_trees_per_step 2 \
+                --retry_with_try \
+                --enable_dereference \
+                --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/presto_bias_fuzzer_repro/logs \
+                --repro_persist_path=/tmp/presto_bias_fuzzer_repro \
+            && echo -e "\n\nPresto Fuzzer run finished successfully."
 
-      - name: "Install dependencies"
-        run: source ./scripts/setup-ubuntu.sh
+      - name: Archive Spark expression production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: presto-bias-fuzzer-failure-artifacts
+          path: |
+            /tmp/presto_bias_fuzzer_repro
 
-      - name: "Build"
+  spark-aggregate-fuzzer-run:
+    name: Spark Aggregate Fuzzer
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:centos9
+    needs: compile
+    timeout-minutes: 60
+    steps:
+
+      - name: Download spark aggregation fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: spark_aggregation_fuzzer
+
+      - name: Run Spark Aggregate Fuzzer
         run: |
-          make debug NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=6 EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON"
-          ccache -s
+          mkdir -p /tmp/spark_aggregate_fuzzer_repro/logs/
+          chmod -R 777 /tmp/spark_aggregate_fuzzer_repro
+          chmod +x spark_aggregation_fuzzer_test
+          ./spark_aggregation_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec $DURATION \
+                --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/spark_aggregate_fuzzer_repro/logs \
+                --repro_persist_path=/tmp/spark_aggregate_fuzzer_repro \
+          && echo -e "\n\nSpark Aggregation Fuzzer run finished successfully."
+
+      - name: Archive Spark aggregate production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: spark-agg-fuzzer-failure-artifacts
+          path: |
+            /tmp/spark_aggregate_fuzzer_repro
+
+  spark-bias-fuzzer:
+    name: Spark Bias Fuzzer
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:centos9
+    needs: compile
+    if: ${{ needs.compile.outputs.spark_bias  == 'true' }}
+    timeout-minutes: 120
+    steps:
+
+      - name: Download spark expression fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: spark_expression_fuzzer
+
+      - name: Download Signatures
+        uses: actions/download-artifact@v4
+        with:
+          name: signatures
+          path: /tmp/signatures
 
-      - name: "Run Spark Fuzzer"
+      - name: Run Spark Expression Fuzzer
         run: |
-          mkdir -p /tmp/spark_fuzzer_repro/
+          ls /tmp/signatures
+          mkdir -p /tmp/spark_bias_fuzzer_repro/logs/
+            chmod -R 777 /tmp/spark_bias_fuzzer_repro
+            chmod +x spark_expression_fuzzer_test
+            ./spark_expression_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec $DURATION \
+                --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/spark_bias_fuzzer_repro/logs \
+                --assign_function_tickets  $(cat /tmp/signatures/spark_bias_functions) \
+                --repro_persist_path=/tmp/spark_bias_fuzzer_repro \
+            && echo -e "\n\nSpark Fuzzer run finished successfully."
+
+      - name: Archive Spark expression production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: spark-fuzzer-failure-artifacts
+          path: |
+            /tmp/spark_bias_fuzzer_repro
+
+  spark-fuzzer:
+    name: Spark Fuzzer
+    if: ${{ needs.compile.outputs.spark_bias  != 'true' }}
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:centos9
+    needs: compile
+    timeout-minutes: 120
+    steps:
+
+      - name: Download spark expression fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: spark_expression_fuzzer
+
+      - name: Run Spark Expression Fuzzer
+        run: |
+          mkdir -p /tmp/spark_fuzzer_repro/logs/
             chmod -R 777 /tmp/spark_fuzzer_repro
-            _build/debug/velox/expression/tests/spark_expression_fuzzer_test \
+            chmod +x spark_expression_fuzzer_test
+            ./spark_expression_fuzzer_test \
                 --seed ${RANDOM} \
                 --enable_variadic_signatures \
                 --lazy_vector_generation_ratio 0.2 \
@@ -109,122 +557,436 @@ jobs:
                 --velox_fuzzer_enable_expression_reuse \
                 --max_expression_trees_per_step 2 \
                 --retry_with_try \
-                --duration_sec 1800 \
-                --logtostderr=1 \
+                --enable_dereference \
+                --duration_sec $DURATION \
                 --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/spark_fuzzer_repro/logs \
                 --repro_persist_path=/tmp/spark_fuzzer_repro \
             && echo -e "\n\nSpark Fuzzer run finished successfully."
 
-      - name: Archive Spark production artifacts
-        if: always()
-        uses: actions/upload-artifact@v3
+      - name: Archive Spark expression production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
         with:
           name: spark-fuzzer-failure-artifacts
           path: |
             /tmp/spark_fuzzer_repro
 
-      - name: "Run Spark Aggregate Fuzzer"
+  presto-java-join-fuzzer-run:
+    name: Join Fuzzer
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:presto-java
+    needs: compile
+    timeout-minutes: 120
+    env:
+      CCACHE_DIR: "${{ github.workspace }}/.ccache/"
+      LINUX_DISTRO: "centos"
+    steps:
+
+      - name: Download join fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: join
+
+      - name: "Checkout Repo"
+        uses: actions/checkout@v4
+        with:
+          path: velox
+          submodules: 'recursive'
+          ref: "${{ inputs.ref }}"
+
+      - name: Fix git permissions
+          # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox
+
+      - name: Run Join Fuzzer
         run: |
-          mkdir -p /tmp/spark_aggregate_fuzzer_repro/
-          chmod -R 777 /tmp/spark_aggregate_fuzzer_repro
-          _build/debug/velox/exec/tests/spark_aggregation_fuzzer_test \
+          cd  velox
+          cp ./scripts/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
+          ls -lR $PRESTO_HOME/etc
+          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          # Sleep for 60 seconds to allow Presto server to start.
+          sleep 60
+          /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA hive.tpch;'
+          cd -
+          mkdir -p /tmp/join_fuzzer_repro/logs/
+          chmod -R 777 /tmp/join_fuzzer_repro
+          chmod +x velox_join_fuzzer_test
+          ./velox_join_fuzzer_test \
                 --seed ${RANDOM} \
-                --duration_sec 1800 \
-                --logtostderr=1 \
+                --duration_sec $DURATION \
                 --minloglevel=0 \
-                --repro_persist_path=/tmp/spark_aggregate_fuzzer_repro \
-          && echo -e "\n\nSpark Aggregation Fuzzer run finished successfully."
-        
-      - name: Archive Spark aggregate production artifacts
-        if: always()
-        uses: actions/upload-artifact@v3
+                --stderrthreshold=2 \
+                --log_dir=/tmp/join_fuzzer_repro/logs \
+                --presto_url=http://127.0.0.1:8080 \
+                --req_timeout_ms=2000 \
+            && echo -e "\n\nJoin fuzzer run finished successfully."
+
+      - name: Archive join production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
         with:
-          name: spark-agg-fuzzer-failure-artifacts
+          name: presto-sot-join-fuzzer-failure-artifacts
           path: |
-            /tmp/spark_aggregate_fuzzer_repro
+            /tmp/join_fuzzer_repro
+            /tmp/server.log
 
+  exchange-fuzzer-run:
+    name: Exchange Fuzzer
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:centos9
+    needs: compile
+    timeout-minutes: 120
+    steps:
+
+      - name: Download exchange fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: exchange
+
+      - name: Run exchange Fuzzer
+        run: |
+          cat /proc/sys/vm/max_map_count
+          mkdir -p /tmp/exchange_fuzzer_repro/logs/
+          chmod -R 777 /tmp/exchange_fuzzer_repro
+          chmod +x velox_exchange_fuzzer_test
+          ./velox_exchange_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec $DURATION \
+                --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/exchange_fuzzer_repro/logs \
+                --repro_path=/tmp/exchange_fuzzer_repro \
+            && echo -e "\n\Exchange fuzzer run finished successfully."
 
-  linux-aggregate-fuzzer-run:
-    runs-on: 8-core
+      - name: Archive Exchange production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+            name: exchange-fuzzer-failure-artifacts
+            path: |
+              /tmp/exchange_fuzzer_repro
+
+  row-number-fuzzer-run:
+    name: RowNumber Fuzzer
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:centos9
+    needs: compile
+    timeout-minutes: 120
+    steps:
+
+      - name: Download row number fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: row_number
+
+      - name: Run RowNumber Fuzzer
+        run: |
+          cat /proc/sys/vm/max_map_count
+          mkdir -p /tmp/row_fuzzer_repro/logs/
+          chmod -R 777 /tmp/row_fuzzer_repro
+          chmod +x velox_row_number_fuzzer_test
+          ./velox_row_number_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec $DURATION \
+                --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/row_fuzzer_repro/logs \
+            && echo -e "\n\Row number fuzzer run finished successfully."
+
+      - name: Archive row number production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+            name: row-fuzzer-failure-artifacts
+            path: |
+              /tmp/row_fuzzer_repro
+  presto-java-aggregation-fuzzer-run:
+    name: Aggregation Fuzzer with Presto as source of truth
+    needs: compile
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:presto-java
     timeout-minutes: 120
     env:
       CCACHE_DIR: "${{ github.workspace }}/.ccache/"
-      CCACHE_BASEDIR: "${{ github.workspace }}"
-      LINUX_DISTRO: "ubuntu"
+      LINUX_DISTRO: "centos"
     steps:
 
+      - name: Download aggregation fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: aggregation
+
       - name: "Checkout Repo"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
+          path: velox
           submodules: 'recursive'
+          ref: "${{ inputs.ref }}"
 
-      - name: "Install dependencies"
-        run: source ./scripts/setup-ubuntu.sh
+      - name: Fix git permissions
+          # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox
 
-      - name: "Build"
-        run: |
-          make debug NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=6 EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON"
-          ccache -s
 
       - name: "Run Aggregate Fuzzer"
         run: |
-          mkdir -p /tmp/aggregate_fuzzer_repro/
-            rm -rfv /tmp/aggregate_fuzzer_repro/*
-            chmod -R 777 /tmp/aggregate_fuzzer_repro
-            _build/debug/velox/exec/tests/velox_aggregation_fuzzer_test \
+          cd  velox
+          cp ./scripts/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
+          ls -lR $PRESTO_HOME/etc
+          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          # Sleep for 60 seconds to allow Presto server to start.
+          sleep 60
+          /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA hive.tpch;'
+          cd -
+          mkdir -p /tmp/aggregate_fuzzer_repro/logs/
+          chmod -R 777 /tmp/aggregate_fuzzer_repro
+          chmod +x velox_aggregation_fuzzer_test
+          ./velox_aggregation_fuzzer_test \
                 --seed ${RANDOM} \
-                --duration_sec 1800 \
-                --logtostderr=1 \
+                --duration_sec $DURATION \
                 --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/aggregate_fuzzer_repro/logs \
                 --repro_persist_path=/tmp/aggregate_fuzzer_repro \
-            && echo -e "\n\nAggregation fuzzer run finished successfully."
+                --enable_sorted_aggregations=true \
+                --presto_url=http://127.0.0.1:8080 \
+          && echo -e "\n\nAggregation fuzzer run finished successfully."
 
       - name: Archive aggregate production artifacts
-        if: always()
-        uses: actions/upload-artifact@v3
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
         with:
-          name: aggregate-fuzzer-failure-artifacts
+          name: presto-sot-aggregate-fuzzer-failure-artifacts
           path: |
             /tmp/aggregate_fuzzer_repro
+            /tmp/server.log
 
-  linux-join-fuzzer-run:
-    runs-on: 8-core
+
+  presto-bias-java-aggregation-fuzzer-run:
+    name: Biased Aggregation Fuzzer with Presto as source of truth
+    needs: compile
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:presto-java
     timeout-minutes: 120
+    if: ${{ needs.compile.outputs.presto_aggregate_bias  == 'true' }}
     env:
       CCACHE_DIR: "${{ github.workspace }}/.ccache/"
-      CCACHE_BASEDIR: "${{ github.workspace }}"
-      LINUX_DISTRO: "ubuntu"
+      LINUX_DISTRO: "centos"
     steps:
 
+      - name: Download aggregation fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: aggregation
+
       - name: "Checkout Repo"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
+          path: velox
           submodules: 'recursive'
+          ref: "${{ inputs.ref }}"
 
-      - name: "Install dependencies"
-        run: source ./scripts/setup-ubuntu.sh
+      - name: Fix git permissions
+        # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox
+
+      - name: Download Signatures
+        uses: actions/download-artifact@v4
+        with:
+          name: signatures
+          path: /tmp/signatures
 
-      - name: "Build"
+      - name: "Run Bias Aggregate Fuzzer"
         run: |
-          make debug NUM_THREADS=16 MAX_HIGH_MEM_JOBS=8 MAX_LINK_JOBS=6 EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON"
-          ccache -s
+          cd  velox
+          cp ./scripts/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
+          ls -lR $PRESTO_HOME/etc
+          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          # Sleep for 60 seconds to allow Presto server to start.
+          sleep 60
+          /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA hive.tpch;'
+          cd -
+          mkdir -p /tmp/aggregate_fuzzer_repro/logs/
+          chmod -R 777 /tmp/aggregate_fuzzer_repro
+          chmod +x velox_aggregation_fuzzer_test
+          echo "signatures folder"
+          ls /tmp/signatures/
+          echo "Biased functions:"
+          cat /tmp/signatures/presto_aggregate_bias_functions
+          echo "Running Fuzzer for $DURATION"
+          ./velox_aggregation_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec $DURATION \
+                --minloglevel=0 \
+                --stderrthreshold=2 \
+                --log_dir=/tmp/aggregate_fuzzer_repro/logs \
+                --repro_persist_path=/tmp/aggregate_fuzzer_repro \
+                --enable_sorted_aggregations=true \
+                --only=$(cat /tmp/signatures/presto_aggregate_bias_functions) \
+                --presto_url=http://127.0.0.1:8080 \
+          && echo -e "\n\nAggregation fuzzer run finished successfully."
 
-      - name: "Run Aggregate Fuzzer"
+      - name: Archive bias aggregate production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: presto-bias-sot-aggregate-fuzzer-failure-artifacts
+          path: |
+            /tmp/aggregate_fuzzer_repro
+            /tmp/server.log
+
+  surface-signature-errors:
+    name: Signature Changes
+    if: ${{ github.event_name != 'schedule' }}
+    needs: compile
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Signatures
+        uses: actions/download-artifact@v4
+        with:
+          name: signatures
+          path: /tmp/signatures
+
+      - name: Surface Presto function signature errors
+        if: ${{ needs.compile.outputs.presto_error == 'true' }}
         run: |
-          mkdir -p /tmp/join_fuzzer_repro/
-          rm -rfv /tmp/join_fuzzer_repro/*
-          chmod -R 777 /tmp/join_fuzzer_repro
-          _build/debug/velox/exec/tests/velox_join_fuzzer_test \
+          cat /tmp/signatures/presto_errors
+          exit 1
+
+      - name: Surface Aggregate function signature errors
+        if: ${{ needs.compile.outputs.presto_aggregate_error == 'true' }}
+        run: |
+          cat /tmp/signatures/presto_aggregate_errors
+          exit 1
+
+  presto-java-window-fuzzer-run:
+    name: Window Fuzzer with Presto as source of truth
+    needs: compile
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:presto-java
+    timeout-minutes: 120
+    env:
+      CCACHE_DIR: "${{ github.workspace }}/.ccache/"
+      LINUX_DISTRO: "centos"
+    steps:
+
+      - name: Download window fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: window
+
+      - name: "Checkout Repo"
+        uses: actions/checkout@v4
+        with:
+          path: velox
+          submodules: 'recursive'
+          ref: "${{ inputs.ref }}"
+
+      - name: Fix git permissions
+          # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox
+
+
+      - name: "Run Window Fuzzer"
+        run: |
+          cd  velox
+          cp ./scripts/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
+          ls -lR $PRESTO_HOME/etc
+          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          # Sleep for 60 seconds to allow Presto server to start.
+          sleep 60
+          /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA hive.tpch;'
+          cd -
+          mkdir -p /tmp/window_fuzzer_repro/logs/
+          chmod -R 777 /tmp/window_fuzzer_repro
+          chmod +x velox_window_fuzzer_test
+          ./velox_window_fuzzer_test \
                 --seed ${RANDOM} \
-                --duration_sec 1800 \
-                --logtostderr=1 \
+                --duration_sec $DURATION \
                 --minloglevel=0 \
-            && echo -e "\n\nAggregation fuzzer run finished successfully."
+                --stderrthreshold=2 \
+                --log_dir=/tmp/window_fuzzer_repro/logs \
+                --repro_persist_path=/tmp/window_fuzzer_repro \
+                --enable_window_reference_verification \
+                --presto_url=http://127.0.0.1:8080 \
+          && echo -e "\n\nWindow fuzzer run finished successfully."
 
-      - name: Archive aggregate production artifacts
-        if: always()
-        uses: actions/upload-artifact@v3
+      - name: Archive window production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
         with:
-          name: join-fuzzer-failure-artifacts
+          name: presto-sot-window-fuzzer-failure-artifacts
           path: |
-            /tmp/join_fuzzer_repro
+            /tmp/window_fuzzer_repro
+            /tmp/server.log
+
+  presto-java-writer-fuzzer-run:
+    name: Writer Fuzzer with Presto as source of truth
+    needs: compile
+    runs-on: ubuntu-latest
+    container: ghcr.io/facebookincubator/velox-dev:presto-java
+    timeout-minutes: 120
+    env:
+      CCACHE_DIR: "${{ github.workspace }}/.ccache/"
+      LINUX_DISTRO: "centos"
+    steps:
+
+      - name: Download writer fuzzer
+        uses: actions/download-artifact@v4
+        with:
+          name: writer
+
+      - name: "Checkout Repo"
+        uses: actions/checkout@v4
+        with:
+          path: velox
+          submodules: 'recursive'
+          ref: "${{ inputs.ref }}"
+
+      - name: Fix git permissions
+        # Usually actions/checkout does this but as we run in a container
+        # it doesn't work
+        run: git config --global --add safe.directory ${GITHUB_WORKSPACE}/velox
+
+      - name: "Run Writer Fuzzer"
+        run: |
+          cd  velox
+          cp ./scripts/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
+          ls -lR $PRESTO_HOME/etc
+          echo "jvm config content:"
+          cat $PRESTO_HOME/etc/jvm.config
+          $PRESTO_HOME/bin/launcher run -v > /tmp/server.log 2>&1 &
+          ls -lR /var/log
+          # Sleep for 60 seconds to allow Presto server to start.
+          sleep 60
+          /opt/presto-cli --version
+          /opt/presto-cli --server 127.0.0.1:8080 --execute 'CREATE SCHEMA hive.tpch;'
+          cd -
+          mkdir -p /tmp/writer_fuzzer_repro/logs/
+          chmod -R 777 /tmp/writer_fuzzer_repro
+          chmod +x velox_writer_fuzzer_test
+          ./velox_writer_fuzzer_test \
+                --seed ${RANDOM} \
+                --duration_sec $DURATION \
+                --minloglevel=0 \
+                --stderrthreshold=2 \
+                --req_timeout_ms 60000 \
+                --log_dir=/tmp/writer_fuzzer_repro/logs \
+                --presto_url=http://127.0.0.1:8080 \
+          && echo -e "\n\Writer fuzzer run finished successfully."
+
+      - name: Archive writer production artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: presto-sot-writer-fuzzer-failure-artifacts
+          path: |
+            /tmp/writer_fuzzer_repro
+            /tmp/server.log
+            /var/log
diff --git a/.gitignore b/.gitignore
index 6c37c57b563b5..f2b64bee7a554 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,7 +48,9 @@ autoconf/autom4te.cache
 projects/*
 !projects/*.*
 !projects/Makefile
-
+.venv
+deps-install
+deps-download
 
 #==============================================================================#
 # Autotools artifacts
@@ -88,7 +90,8 @@ _build/
 *.pdf
 *.swp
 a.out
-CMake/resolve_dependency_module/boost/FindBoost.cmake
+CMake/resolve_dependency_modules/boost/FindBoost.cmake
+__cmake_systeminformation/
 
 #==============================================================================#
 # Kate Swap Files
@@ -278,6 +281,7 @@ settings.json
 
 # User's build configuration
 Makefile.config
+CMakeUserPresets.json
 
 # build, distribute, and bins (+ python proto bindings)
 build
@@ -319,3 +323,4 @@ src/amalgamation/
 #docs
 velox/docs/sphinx/source/README_generated_*
 velox/docs/bindings/python/_generate/*
+scripts/bm-report/report.html
diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index c4d716cbc4f56..0000000000000
--- a/.gitmodules
+++ /dev/null
@@ -1,6 +0,0 @@
-[submodule "third_party/googletest"]
-	path = third_party/googletest
-	url = https://github.com/google/googletest.git
-[submodule "third_party/xsimd"]
-	path = third_party/xsimd
-	url = https://github.com/xtensor-stack/xsimd.git
diff --git a/CMake/FindArrow.cmake b/CMake/FindArrow.cmake
new file mode 100644
index 0000000000000..8c73a29e39137
--- /dev/null
+++ b/CMake/FindArrow.cmake
@@ -0,0 +1,48 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+find_library(ARROW_LIB libarrow.a)
+find_library(PARQUET_LIB libparquet.a)
+find_library(ARROW_TESTING_LIB libarrow_testing.a)
+if("${ARROW_LIB}" STREQUAL "ARROW_LIB-NOTFOUND"
+   OR "${ARROW_TESTING_LIB}" STREQUAL "ARROW_TESTING_LIB-NOTFOUND")
+  set(Arrow_FOUND false)
+  return()
+endif()
+find_package(Thrift)
+if(NOT Thrift_FOUND)
+  # Requires building arrow from source with thrift bundled.
+  set(Arrow_FOUND false)
+  return()
+endif()
+add_library(thrift ALIAS thrift::thrift)
+
+set(Arrow_FOUND true)
+
+# Only add the libraries once.
+if(NOT TARGET arrow)
+  add_library(arrow STATIC IMPORTED GLOBAL)
+  add_library(parquet STATIC IMPORTED GLOBAL)
+  add_library(arrow_testing STATIC IMPORTED GLOBAL)
+
+  find_path(ARROW_INCLUDE_PATH arrow/api.h)
+  set_target_properties(
+    arrow arrow_testing parquet PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                                           ${ARROW_INCLUDE_PATH})
+  set_target_properties(arrow PROPERTIES IMPORTED_LOCATION ${ARROW_LIB}
+                                         INTERFACE_LINK_LIBRARIES thrift)
+  set_target_properties(parquet PROPERTIES IMPORTED_LOCATION ${PARQUET_LIB})
+  set_target_properties(arrow_testing PROPERTIES IMPORTED_LOCATION
+                                                 ${ARROW_TESTING_LIB})
+endif()
diff --git a/CMake/FindThrift.cmake b/CMake/FindThrift.cmake
new file mode 100644
index 0000000000000..273500a6ae369
--- /dev/null
+++ b/CMake/FindThrift.cmake
@@ -0,0 +1,167 @@
+# Copyright 2012 Cloudera Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# * Find Thrift (a cross platform RPC lib/tool)
+#
+# Variables used by this module, they can change the default behaviour and need
+# to be set before calling find_package:
+#
+# Thrift_ROOT - When set, this path is inspected instead of standard library
+# locations as the root of the Thrift installation. The environment variable
+# THRIFT_HOME overrides this variable.
+#
+# This module defines Thrift_FOUND, whether Thrift is found or not
+# Thrift_COMPILER_FOUND, whether Thrift compiler is found or not
+#
+# thrift::thrift, a library target to use Thrift thrift::compiler, a executable
+# target to use Thrift compiler
+
+function(EXTRACT_THRIFT_VERSION)
+  if(THRIFT_INCLUDE_DIR)
+    file(READ "${THRIFT_INCLUDE_DIR}/thrift/config.h" THRIFT_CONFIG_H_CONTENT)
+    string(REGEX MATCH "#define PACKAGE_VERSION \"[0-9.]+\""
+                 THRIFT_VERSION_DEFINITION "${THRIFT_CONFIG_H_CONTENT}")
+    string(REGEX MATCH "[0-9.]+" Thrift_VERSION "${THRIFT_VERSION_DEFINITION}")
+    set(Thrift_VERSION
+        "${Thrift_VERSION}"
+        PARENT_SCOPE)
+  else()
+    set(Thrift_VERSION
+        ""
+        PARENT_SCOPE)
+  endif()
+endfunction(EXTRACT_THRIFT_VERSION)
+
+if(MSVC_TOOLCHAIN AND NOT DEFINED THRIFT_MSVC_LIB_SUFFIX)
+  if(NOT ARROW_THRIFT_USE_SHARED)
+    if(ARROW_USE_STATIC_CRT)
+      if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
+        set(THRIFT_MSVC_LIB_SUFFIX "mtd")
+      else()
+        set(THRIFT_MSVC_LIB_SUFFIX "mt")
+      endif()
+    else()
+      if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
+        set(THRIFT_MSVC_LIB_SUFFIX "mdd")
+      else()
+        set(THRIFT_MSVC_LIB_SUFFIX "md")
+      endif()
+    endif()
+  endif()
+endif()
+set(THRIFT_LIB_NAME_BASE "thrift${THRIFT_MSVC_LIB_SUFFIX}")
+
+if(ARROW_THRIFT_USE_SHARED)
+  set(THRIFT_LIB_NAMES thrift)
+  if(CMAKE_IMPORT_LIBRARY_SUFFIX)
+    list(
+      APPEND
+      THRIFT_LIB_NAMES
+      "${CMAKE_IMPORT_LIBRARY_PREFIX}${THRIFT_LIB_NAME_BASE}${CMAKE_IMPORT_LIBRARY_SUFFIX}"
+    )
+  endif()
+  list(
+    APPEND
+    THRIFT_LIB_NAMES
+    "${CMAKE_SHARED_LIBRARY_PREFIX}${THRIFT_LIB_NAME_BASE}${CMAKE_SHARED_LIBRARY_SUFFIX}"
+  )
+else()
+  set(THRIFT_LIB_NAMES
+      "${CMAKE_STATIC_LIBRARY_PREFIX}${THRIFT_LIB_NAME_BASE}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+  )
+endif()
+
+if(Thrift_ROOT)
+  find_library(
+    THRIFT_LIB
+    NAMES ${THRIFT_LIB_NAMES}
+    PATHS ${Thrift_ROOT}
+    PATH_SUFFIXES "lib/${CMAKE_LIBRARY_ARCHITECTURE}" "lib")
+  find_path(
+    THRIFT_INCLUDE_DIR thrift/Thrift.h
+    PATHS ${Thrift_ROOT}
+    PATH_SUFFIXES "include")
+  find_program(
+    THRIFT_COMPILER thrift
+    PATHS ${Thrift_ROOT}
+    PATH_SUFFIXES "bin")
+  extract_thrift_version()
+else()
+  # THRIFT-4760: The pkgconfig files are currently only installed when using
+  # autotools. Starting with 0.13, they are also installed for the CMake-based
+  # installations of Thrift.
+  find_package(PkgConfig QUIET)
+  pkg_check_modules(THRIFT_PC thrift)
+  if(THRIFT_PC_FOUND)
+    set(THRIFT_INCLUDE_DIR "${THRIFT_PC_INCLUDEDIR}")
+
+    list(APPEND THRIFT_PC_LIBRARY_DIRS "${THRIFT_PC_LIBDIR}")
+
+    find_library(
+      THRIFT_LIB
+      NAMES ${THRIFT_LIB_NAMES}
+      PATHS ${THRIFT_PC_LIBRARY_DIRS}
+      NO_DEFAULT_PATH)
+    find_program(
+      THRIFT_COMPILER thrift
+      HINTS ${THRIFT_PC_PREFIX}
+      NO_DEFAULT_PATH
+      PATH_SUFFIXES "bin")
+    set(Thrift_VERSION ${THRIFT_PC_VERSION})
+  else()
+    find_library(
+      THRIFT_LIB
+      NAMES ${THRIFT_LIB_NAMES}
+      PATH_SUFFIXES "lib/${CMAKE_LIBRARY_ARCHITECTURE}" "lib")
+    find_path(THRIFT_INCLUDE_DIR thrift/Thrift.h PATH_SUFFIXES "include")
+    find_program(THRIFT_COMPILER thrift PATH_SUFFIXES "bin")
+    extract_thrift_version()
+  endif()
+endif()
+
+if(THRIFT_COMPILER)
+  set(Thrift_COMPILER_FOUND TRUE)
+else()
+  set(Thrift_COMPILER_FOUND FALSE)
+endif()
+
+find_package_handle_standard_args(
+  Thrift
+  REQUIRED_VARS THRIFT_LIB THRIFT_INCLUDE_DIR
+  VERSION_VAR Thrift_VERSION
+  HANDLE_COMPONENTS)
+
+if(Thrift_FOUND)
+  if(ARROW_THRIFT_USE_SHARED)
+    add_library(thrift::thrift SHARED IMPORTED)
+  else()
+    add_library(thrift::thrift STATIC IMPORTED)
+  endif()
+  set_target_properties(
+    thrift::thrift
+    PROPERTIES IMPORTED_LOCATION "${THRIFT_LIB}" INTERFACE_INCLUDE_DIRECTORIES
+                                                 "${THRIFT_INCLUDE_DIR}")
+  if(WIN32 AND NOT MSVC_TOOLCHAIN)
+    # We don't need this for Visual C++ because Thrift uses "#pragma
+    # comment(lib, "Ws2_32.lib")" in thrift/windows/config.h for Visual C++.
+    set_target_properties(thrift::thrift PROPERTIES INTERFACE_LINK_LIBRARIES
+                                                    "ws2_32")
+  endif()
+
+  if(Thrift_COMPILER_FOUND)
+    add_executable(thrift::compiler IMPORTED)
+    set_target_properties(thrift::compiler PROPERTIES IMPORTED_LOCATION
+                                                      "${THRIFT_COMPILER}")
+  endif()
+endif()
diff --git a/CMake/Findc-ares.cmake b/CMake/Findc-ares.cmake
new file mode 100644
index 0000000000000..0e3f1fe0938a6
--- /dev/null
+++ b/CMake/Findc-ares.cmake
@@ -0,0 +1,40 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+find_package(c-ares CONFIG)
+if(c-ares_FOUND)
+  if(TARGET c-ares::cares)
+    return()
+  endif()
+endif()
+
+find_path(
+  C_ARES_INCLUDE_DIR
+  NAMES ares.h
+  PATH_SUFFIXES c-ares)
+find_library(C_ARES_LIBRARY NAMES c-ares)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(c-ares DEFAULT_MSG C_ARES_LIBRARY
+                                  C_ARES_INCLUDE_DIR)
+
+if(c-ares_FOUND AND NOT TARGET c-ares::cares)
+  add_library(c-ares::cares UNKNOWN IMPORTED)
+  set_target_properties(
+    c-ares::cares
+    PROPERTIES IMPORTED_LOCATION "${C_ARES_LIBRARY}"
+               INTERFACE_INCLUDE_DIRECTORIES "${C_ARES_INCLUDE_DIR}")
+endif()
+
+mark_as_advanced(C_ARES_INCLUDE_DIR C_ARES_LIBRARY)
diff --git a/CMake/Finddouble-conversion.cmake b/CMake/Finddouble-conversion.cmake
new file mode 100644
index 0000000000000..457bd88e26c17
--- /dev/null
+++ b/CMake/Finddouble-conversion.cmake
@@ -0,0 +1,34 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Fallback find module for double-conversion if double-conversion is built with
+# CMake it'll install a config module, which we prefer if it's built with Scons
+# (their default), we search ourselves
+
+find_package(double-conversion CONFIG)
+if(double-conversion_FOUND)
+  if(TARGET double-conversion::double-conversion)
+    return()
+  endif()
+endif()
+
+find_path(
+  DOUBLE_CONVERSION_INCLUDE_DIR
+  NAMES double-conversion.h
+  PATH_SUFFIXES double-conversion)
+find_library(DOUBLE_CONVERSION_LIBRARY NAMES double-conversion)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+  double-conversion DEFAULT_MSG DOUBLE_CONVERSION_LIBRARY
+  DOUBLE_CONVERSION_INCLUDE_DIR)
+
+if(double-conversion_FOUND AND NOT TARGET double-conversion::double-conversion)
+  add_library(double-conversion::double-conversion UNKNOWN IMPORTED)
+  set_target_properties(
+    double-conversion::double-conversion
+    PROPERTIES IMPORTED_LOCATION "${DOUBLE_CONVERSION_LIBRARY}"
+               INTERFACE_INCLUDE_DIRECTORIES "${DOUBLE_CONVERSION_INCLUDE_DIR}")
+endif()
+
+mark_as_advanced(DOUBLE_CONVERSION_INCLUDE_DIR DOUBLE_CONVERSION_LIBRARY)
diff --git a/CMake/Findre2.cmake b/CMake/Findre2.cmake
index 8791e612ed536..1a438cce0e0ab 100644
--- a/CMake/Findre2.cmake
+++ b/CMake/Findre2.cmake
@@ -11,19 +11,55 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-find_library(re2_lib re2)
-find_path(re2_include re2/re2.h)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(re2 REQUIRED_VARS re2_lib re2_include)
 
+find_package(re2 QUIET CONFIG)
 if(re2_FOUND)
-  set(re2_LIBRARIES ${re2_lib})
-  set(re2_INCLUDE_DIRS ${re2_include})
+  message(STATUS "Found RE2 via CMake.")
+  return()
+endif()
+
+# As per https://github.com/grpc/grpc/issues/25434, idempotence is necessary
+# because CMake fails when another target with the same name already exists.
+if(TARGET re2::re2)
+  message(STATUS "Found RE2 via pkg-config already?")
+  return()
+endif()
+
+find_package(PkgConfig REQUIRED)
+# TODO(junyer): Use the IMPORTED_TARGET option whenever CMake 3.6 (or newer)
+# becomes the minimum required: that will take care of the add_library() and
+# set_property() calls; then we can simply alias PkgConfig::RE2 as re2::re2. For
+# now, we can only set INTERFACE_* properties that existed in CMake 3.5.
+pkg_check_modules(RE2 QUIET re2)
+if(RE2_FOUND)
+  set(re2_FOUND "${RE2_FOUND}")
+  add_library(re2::re2 INTERFACE IMPORTED)
+  if(RE2_INCLUDE_DIRS)
+    set_property(TARGET re2::re2 PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+                                          "${RE2_INCLUDE_DIRS}")
+  endif()
+  if(RE2_CFLAGS_OTHER)
+    # Filter out the -std flag, which is handled by CMAKE_CXX_STANDARD.
+    # TODO(junyer): Use the FILTER option whenever CMake 3.6 (or newer) becomes
+    # the minimum required: that will allow this to be concise.
+    foreach(flag IN LISTS RE2_CFLAGS_OTHER)
+      if("${flag}" MATCHES "^-std=")
+        list(REMOVE_ITEM RE2_CFLAGS_OTHER "${flag}")
+      endif()
+    endforeach()
+    set_property(TARGET re2::re2 PROPERTY INTERFACE_COMPILE_OPTIONS
+                                          "${RE2_CFLAGS_OTHER}")
+  endif()
+  if(RE2_LDFLAGS)
+    set_property(TARGET re2::re2 PROPERTY INTERFACE_LINK_LIBRARIES
+                                          "${RE2_LDFLAGS}")
+  endif()
+  message(STATUS "Found RE2 via pkg-config.")
+  return()
+endif()
 
-  add_library(re2::re2 UNKNOWN IMPORTED)
-  target_include_directories(re2::re2 INTERFACE ${re2_INCLUDE_DIRS})
-  target_link_libraries(re2::re2 INTERFACE ${re2_LIBRARIES})
-  set_target_properties(re2::re2 PROPERTIES IMPORTED_LOCATION
-                                            "${re2_LIBRARIES}")
+if(re2_FIND_REQUIRED)
+  message(FATAL_ERROR "Failed to find RE2.")
+elseif(NOT re2_FIND_QUIETLY)
+  message(WARNING "Failed to find RE2.")
 endif()
diff --git a/CMake/ResolveDependency.cmake b/CMake/ResolveDependency.cmake
index ecd861472afb8..ad8a8fd31bca0 100644
--- a/CMake/ResolveDependency.cmake
+++ b/CMake/ResolveDependency.cmake
@@ -43,7 +43,7 @@ macro(build_dependency dependency_name)
   include(${dependency_name_lower})
 endmacro()
 
-# * Macro to resolve thirparty dependencies.
+# * Macro to resolve third-party dependencies.
 #
 # Provides the macro resolve_dependency(). This macro will allow us to find the
 # dependency via the usage of find_package or use the custom
@@ -52,9 +52,9 @@ endmacro()
 #
 # resolve_dependency(dependency_name [...] )
 #
-# [...]: the macro will pass all arguments after DELPENDENCY_NAME on to
+# [...]: the macro will pass all arguments after DEPENDENCY_NAME on to
 # find_package. ${dependency_name}_SOURCE is expected to be set to either AUTO,
-# SYSTEM or BUNDLED. If ${dependency_name}_SOURCE is SYSTEM it will try to find
+# SYSTEM or BUNDLED. If ${dependency_name}_SOURCE is AUTO it will try to find
 # the corresponding package via find_package and if not found it will call the
 # build_dependency macro to download and build the third party dependency. If
 # ${dependency_name}_SOURCE is SYSTEM it will force to find via find_package. If
@@ -94,10 +94,14 @@ macro(set_source dependency_name)
     STATUS "Setting ${dependency_name} source to ${${dependency_name}_SOURCE}")
 endmacro()
 
-# Set a variable to the value of $ENV{envvar_name} if defined, set to ${DEFAULT}
-# if not defined. If called from within a nested scope the variable will not
+# If the var_name is not defined then set var_name to the value of
+# $ENV{envvar_name} if it is defined. If neither is defined then set var_name to
+# ${DEFAULT}. If called from within a nested scope the variable will not
 # propagate into outer scopes automatically! Use PARENT_SCOPE.
 function(set_with_default var_name envvar_name default)
+  if(DEFINED ${var_name})
+    return()
+  endif()
   if(DEFINED ENV{${envvar_name}})
     set(${var_name}
         $ENV{${envvar_name}}
diff --git a/CMake/VeloxUtils.cmake b/CMake/VeloxUtils.cmake
new file mode 100644
index 0000000000000..fa8f9456d7e2a
--- /dev/null
+++ b/CMake/VeloxUtils.cmake
@@ -0,0 +1,132 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+# TODO use file sets
+function(velox_install_library_headers)
+  # Find any headers and install them relative to the source tree in include.
+  file(GLOB _hdrs "*.h")
+  if(NOT "${_hdrs}" STREQUAL "")
+    cmake_path(
+      RELATIVE_PATH
+      CMAKE_CURRENT_SOURCE_DIR
+      BASE_DIRECTORY
+      "${CMAKE_SOURCE_DIR}"
+      OUTPUT_VARIABLE
+      _hdr_dir)
+    install(FILES ${_hdrs} DESTINATION include/${_hdr_dir})
+  endif()
+endfunction()
+
+# Base add velox library call to add a library and install it.
+function(velox_base_add_library TARGET)
+  add_library(${TARGET} ${ARGN})
+  install(TARGETS ${TARGET} DESTINATION lib/velox)
+  velox_install_library_headers()
+endfunction()
+
+# This is extremely hackish but presents an easy path to installation.
+function(velox_add_library TARGET)
+  set(options OBJECT STATIC SHARED INTERFACE)
+  set(oneValueArgs)
+  set(multiValueArgs)
+  cmake_parse_arguments(
+    VELOX
+    "${options}"
+    "${oneValueArgs}"
+    "${multiValueArgs}"
+    ${ARGN})
+
+  # Remove library type specifiers from ARGN
+  set(library_type)
+  if(VELOX_OBJECT)
+    set(library_type OBJECT)
+  elseif(VELOX_STATIC)
+    set(library_type STATIC)
+  elseif(VELOX_SHARED)
+    set(library_type SHARED)
+  elseif(VELOX_INTERFACE)
+    set(library_type INTERFACE)
+  endif()
+
+  list(REMOVE_ITEM ARGN OBJECT)
+  list(REMOVE_ITEM ARGN STATIC)
+  list(REMOVE_ITEM ARGN SHARED)
+  list(REMOVE_ITEM ARGN INTERFACE)
+  # Propagate to the underlying add_library and then install the target.
+  if(VELOX_MONO_LIBRARY)
+    if(TARGET velox)
+      # Target already exists, append sources to it.
+      target_sources(velox PRIVATE ${ARGN})
+    else()
+      # Create the target if this is the first invocation.
+      add_library(velox ${ARGN})
+      set_target_properties(velox PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                             ${CMAKE_BINARY_DIR}/lib)
+      set_target_properties(velox PROPERTIES ARCHIVE_OUTPUT_DIRECTORY
+                                             ${CMAKE_BINARY_DIR}/lib)
+      install(TARGETS velox DESTINATION lib/velox)
+    endif()
+    # create alias for compatability
+    if(NOT TARGET ${TARGET})
+      add_library(${TARGET} ALIAS velox)
+    endif()
+  else()
+    # Create a library for each invocation.
+    velox_base_add_library(${TARGET} ${library_type} ${ARGN})
+  endif()
+  velox_install_library_headers()
+endfunction()
+
+function(velox_link_libraries TARGET)
+  # TODO(assignUser): Handle scope keywords (they currently are empty calls ala
+  # target_link_libraries(target PRIVATE))
+  if(VELOX_MONO_LIBRARY)
+    message(DEBUG "${TARGET}: ${ARGN}")
+    foreach(_lib ${ARGN})
+      if("${_lib}" MATCHES "^velox_*")
+        message(DEBUG "\t\tDROP: ${_lib}")
+      else()
+        message(DEBUG "\t\tADDING: ${_lib}")
+        target_link_libraries(velox ${_lib})
+      endif()
+    endforeach()
+  else()
+    target_link_libraries(${TARGET} ${ARGN})
+  endif()
+endfunction()
+
+function(velox_include_directories TARGET)
+  if(VELOX_MONO_LIBRARY)
+    target_include_directories(velox ${ARGN})
+  else()
+    target_include_directories(${TARGET} ${ARGN})
+  endif()
+endfunction()
+
+function(velox_compile_definitions TARGET)
+  if(VELOX_MONO_LIBRARY)
+    target_compile_definitions(velox ${ARGN})
+  else()
+    target_compile_definitions(${TARGET} ${ARGN})
+  endif()
+endfunction()
+
+function(velox_sources TARGET)
+  if(VELOX_MONO_LIBRARY)
+    target_sources(velox ${ARGN})
+  else()
+    target_sources(${TARGET} ${ARGN})
+  endif()
+endfunction()
diff --git a/CMake/resolve_dependency_modules/README.md b/CMake/resolve_dependency_modules/README.md
index e5c3346c9d2aa..a164e50ad3325 100644
--- a/CMake/resolve_dependency_modules/README.md
+++ b/CMake/resolve_dependency_modules/README.md
@@ -1,7 +1,51 @@
+# Dependency List
+Following is the list of libraries and their minimum version
+that Velox requires. Some of these libraries can be installed
+via a platform's package manager (eg. `brew` on MacOS).
+The versions of certain libraries is the default provided by
+the platform's package manager. Some libraries can be bundled
+by Velox. See details on bundling below.
+
+| Library Name      | Minimum Version | Bundled? |
+|-------------------|-----------------|----------|
+| ninja             | default         | No       |
+| ccache            | default         | No       |
+| icu4c             | default         | Yes      |
+| gflags            | default         | Yes      |
+| glog              | default         | Yes      |
+| gtest (testing)   | default         | Yes      |
+| libevent          | default         | No       |
+| libsodium         | default         | No       |
+| lz4               | default         | No       |
+| snappy            | default         | No       |
+| lzo               | default         | No       |
+| xz                | default         | No       |
+| zstd              | default         | No       |
+| openssl           | default         | No       |
+| protobuf          | 21.7 >= x < 22  | Yes      |
+| boost             | 1.77.0          | Yes      |
+| flex              | 2.5.13          | No       |
+| bison             | 3.0.4           | No       |
+| cmake             | 3.28            | No       |
+| double-conversion | 3.1.5           | No       |
+| xsimd             | 10.0.0          | Yes      |
+| re2               | 2021-04-01      | Yes      |
+| fmt               | 10.1.1          | Yes      |
+| simdjson          | 3.9.3           | Yes      |
+| fast_float        | v6.1.6          | Yes      |
+| folly             | v2024.09.16.00  | Yes      |
+| fizz              | v2024.09.16.00  | No       |
+| wangle            | v2024.09.16.00  | No       |
+| mvfst             | v2024.09.16.00  | No       |
+| fbthrift          | v2024.09.16.00  | No       |
+| libstemmer        | 2.2.0           | Yes      |
+| DuckDB (testing)  | 0.8.1           | Yes      |
+| cpr (testing)     | 1.10.15         | Yes      |
+
 # Bundled Dependency Management
 This module provides a dependency management system that allows us to automatically fetch and build dependencies from source if needed.
 
-By default the system will use dependencies installed on the host and fallback to building from source. This behaviour can be changed by setting environment variables:
+By default, the system will use dependencies installed on the host and fallback to building from source. This behaviour can be changed by setting environment variables:
 
 - `VELOX_DEPENDENCY_SOURCE=AUTO|BUNDLED|SYSTEM` for all dependencies or
 - `<package>_SOURCE=AUTO|BUNDLED|SYSTEM`  for each dependency individually "package" has to use the same spelling as used in `CMakelists.txt`.
diff --git a/CMake/resolve_dependency_modules/absl.cmake b/CMake/resolve_dependency_modules/absl.cmake
new file mode 100644
index 0000000000000..11c267b688e80
--- /dev/null
+++ b/CMake/resolve_dependency_modules/absl.cmake
@@ -0,0 +1,36 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set(VELOX_ABSL_BUILD_VERSION 20240116.2)
+set(VELOX_ABSL_BUILD_SHA256_CHECKSUM
+    733726b8c3a6d39a4120d7e45ea8b41a434cdacde401cba500f14236c49b39dc)
+string(CONCAT VELOX_ABSL_SOURCE_URL
+              "https://github.com/abseil/abseil-cpp/archive/refs/tags/"
+              "${VELOX_ABSL_BUILD_VERSION}.tar.gz")
+
+resolve_dependency_url(ABSL)
+
+message(STATUS "Building Abseil from source")
+
+FetchContent_Declare(
+  absl
+  URL ${VELOX_ABSL_SOURCE_URL}
+  URL_HASH ${VELOX_ABSL_BUILD_SHA256_CHECKSUM}
+  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+
+set(ABSL_BUILD_TESTING OFF)
+set(ABSL_PROPAGATE_CXX_STD ON)
+set(ABSL_ENABLE_INSTALL ON)
+FetchContent_MakeAvailable(absl)
diff --git a/CMake/resolve_dependency_modules/arrow.cmake b/CMake/resolve_dependency_modules/arrow.cmake
new file mode 100644
index 0000000000000..b9d04683d69d4
--- /dev/null
+++ b/CMake/resolve_dependency_modules/arrow.cmake
@@ -0,0 +1,16 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/arrow)
diff --git a/CMake/resolve_dependency_modules/arrow/CMakeLists.txt b/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
new file mode 100644
index 0000000000000..ddf1fac71b86c
--- /dev/null
+++ b/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
@@ -0,0 +1,96 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+project(Arrow)
+
+if(VELOX_ENABLE_ARROW)
+  find_package(Thrift)
+  if(Thrift_FOUND)
+    set(THRIFT_SOURCE "SYSTEM")
+  else()
+    set(THRIFT_SOURCE "BUNDLED")
+  endif()
+
+  set(ARROW_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/arrow_ep")
+  set(ARROW_CMAKE_ARGS
+      -DARROW_PARQUET=OFF
+      -DARROW_DEPENDENCY_SOURCE=AUTO
+      -DARROW_WITH_THRIFT=ON
+      -DARROW_WITH_LZ4=ON
+      -DARROW_WITH_SNAPPY=ON
+      -DARROW_WITH_ZLIB=ON
+      -DARROW_WITH_ZSTD=ON
+      -DARROW_JEMALLOC=OFF
+      -DARROW_SIMD_LEVEL=NONE
+      -DARROW_RUNTIME_SIMD_LEVEL=NONE
+      -DARROW_WITH_UTF8PROC=OFF
+      -DARROW_TESTING=ON
+      -DCMAKE_INSTALL_PREFIX=${ARROW_PREFIX}/install
+      -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+      -DARROW_BUILD_STATIC=ON
+      -DThrift_SOURCE=${THRIFT_SOURCE}
+      -DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH})
+  set(ARROW_LIBDIR ${ARROW_PREFIX}/install/${CMAKE_INSTALL_LIBDIR})
+
+  add_library(thrift STATIC IMPORTED GLOBAL)
+  if(NOT Thrift_FOUND)
+    set(THRIFT_ROOT ${ARROW_PREFIX}/src/arrow_ep-build/thrift_ep-install)
+    set(THRIFT_LIB ${THRIFT_ROOT}/lib/libthrift.a)
+
+    file(MAKE_DIRECTORY ${THRIFT_ROOT}/include)
+    set(THRIFT_INCLUDE_DIR ${THRIFT_ROOT}/include)
+  endif()
+
+  set_property(TARGET thrift PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+                                      ${THRIFT_INCLUDE_DIR})
+  set_property(TARGET thrift PROPERTY IMPORTED_LOCATION ${THRIFT_LIB})
+
+  set(VELOX_ARROW_BUILD_VERSION 15.0.0)
+  set(VELOX_ARROW_BUILD_SHA256_CHECKSUM
+      01dd3f70e85d9b5b933ec92c0db8a4ef504a5105f78d2d8622e84279fb45c25d)
+  set(VELOX_ARROW_SOURCE_URL
+      "https://archive.apache.org/dist/arrow/arrow-${VELOX_ARROW_BUILD_VERSION}/apache-arrow-${VELOX_ARROW_BUILD_VERSION}.tar.gz"
+  )
+
+  resolve_dependency_url(ARROW)
+
+  ExternalProject_Add(
+    arrow_ep
+    PREFIX ${ARROW_PREFIX}
+    URL ${VELOX_ARROW_SOURCE_URL}
+    URL_HASH ${VELOX_ARROW_BUILD_SHA256_CHECKSUM}
+    SOURCE_SUBDIR cpp
+    CMAKE_ARGS ${ARROW_CMAKE_ARGS}
+    BUILD_BYPRODUCTS ${ARROW_LIBDIR}/libarrow.a ${ARROW_LIBDIR}/libparquet.a
+                     ${ARROW_LIBDIR}/libarrow_testing.a ${THRIFT_LIB})
+
+  add_library(arrow STATIC IMPORTED GLOBAL)
+  add_library(arrow_testing STATIC IMPORTED GLOBAL)
+  add_library(parquet STATIC IMPORTED GLOBAL)
+  add_dependencies(arrow arrow_ep)
+  add_dependencies(arrow_testing arrow)
+  add_dependencies(parquet arrow)
+  file(MAKE_DIRECTORY ${ARROW_PREFIX}/install/include)
+  set_target_properties(
+    arrow arrow_testing parquet PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                                           ${ARROW_PREFIX}/install/include)
+  set_target_properties(arrow PROPERTIES IMPORTED_LOCATION
+                                         ${ARROW_LIBDIR}/libarrow.a)
+  set_property(TARGET arrow PROPERTY INTERFACE_LINK_LIBRARIES ${RE2} thrift)
+  set_target_properties(
+    arrow_testing PROPERTIES IMPORTED_LOCATION
+                             ${ARROW_LIBDIR}/libarrow_testing.a)
+  set_target_properties(parquet PROPERTIES IMPORTED_LOCATION
+                                           ${ARROW_LIBDIR}/libparquet.a)
+
+endif()
diff --git a/CMake/resolve_dependency_modules/boost/CMakeLists.txt b/CMake/resolve_dependency_modules/boost/CMakeLists.txt
index 8f9bf06ed44b7..c6d32b88c2b4d 100644
--- a/CMake/resolve_dependency_modules/boost/CMakeLists.txt
+++ b/CMake/resolve_dependency_modules/boost/CMakeLists.txt
@@ -21,14 +21,14 @@ add_compile_options(-w)
 # We need to use boost > 1.70 to build it with CMake 1.81 was the first to be
 # released as a github release INCLUDING the cmake files (which are not in the
 # officale releases for some reason)
-set(VELOX_BOOST_BUILD_VERSION 1.81.0)
+set(VELOX_BOOST_BUILD_VERSION 1.84.0)
 string(
   CONCAT VELOX_BOOST_SOURCE_URL
          "https://github.com/boostorg/boost/releases/download/"
          "boost-${VELOX_BOOST_BUILD_VERSION}/"
          "boost-${VELOX_BOOST_BUILD_VERSION}.tar.gz")
 set(VELOX_BOOST_BUILD_SHA256_CHECKSUM
-    121da556b718fd7bd700b5f2e734f8004f1cfa78b7d30145471c526ba75a151c)
+    4d27e9efed0f6f152dc28db6430b9d3dfb40c0345da7342eaa5a987dde57bd95)
 
 resolve_dependency_url(BOOST)
 message(STATUS "Building boost from source")
@@ -53,6 +53,7 @@ set(BOOST_HEADER_ONLY
     circular_buffer
     math
     multi_index
+    multiprecision
     numeric_conversion
     random
     uuid
@@ -61,11 +62,9 @@ list(APPEND BOOST_INCLUDE_LIBRARIES ${BOOST_HEADER_ONLY})
 
 # The `headers` target is not created by Boost cmake and leads to a warning
 list(REMOVE_ITEM BOOST_INCLUDE_LIBRARIES headers)
-set(BUILD_SHARED_LIBS ON)
+set(BUILD_SHARED_LIBS OFF)
 FetchContent_MakeAvailable(Boost)
 
-# To aling with Boost system install we create Boost::headers target
-add_library(boost_headers INTERFACE)
-add_library(Boost::headers ALIAS boost_headers)
 list(TRANSFORM BOOST_HEADER_ONLY PREPEND Boost::)
 target_link_libraries(boost_headers INTERFACE ${BOOST_HEADER_ONLY})
+add_library(Boost::headers ALIAS boost_headers)
diff --git a/CMake/resolve_dependency_modules/boost/FindBoost.cmake.in b/CMake/resolve_dependency_modules/boost/FindBoost.cmake.in
index ab59b0238e7c6..7a1a5d81d6ae8 100644
--- a/CMake/resolve_dependency_modules/boost/FindBoost.cmake.in
+++ b/CMake/resolve_dependency_modules/boost/FindBoost.cmake.in
@@ -14,5 +14,6 @@
 message(STATUS "Using Boost - Bundled")
 set(Boost_FOUND TRUE)
 set(Boost_LIBRARIES @BOOST_INCLUDE_LIBRARIES@)
+list(APPEND Boost_LIBRARIES headers)
 list(TRANSFORM Boost_LIBRARIES PREPEND Boost::)
 message(STATUS "Boost targets: ${Boost_LIBRARIES}")
diff --git a/CMake/resolve_dependency_modules/c-ares.cmake b/CMake/resolve_dependency_modules/c-ares.cmake
new file mode 100644
index 0000000000000..3dc5b27addeda
--- /dev/null
+++ b/CMake/resolve_dependency_modules/c-ares.cmake
@@ -0,0 +1,43 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set(VELOX_CARES_BUILD_VERSION cares-1_13_0)
+set(VELOX_CARES_BUILD_SHA256_CHECKSUM
+    7c48c57706a38691041920e705d2a04426ad9c68d40edd600685323f214b2d57)
+string(
+  CONCAT VELOX_CARES_SOURCE_URL
+         "https://github.com/c-ares/c-ares/archive/refs/tags/"
+         "${VELOX_CARES_BUILD_VERSION}.tar.gz")
+
+resolve_dependency_url(CARES)
+
+message(STATUS "Building C-ARES from source")
+
+FetchContent_Declare(
+  c-ares
+  URL ${VELOX_CARES_SOURCE_URL}
+  URL_HASH ${VELOX_CARES_BUILD_SHA256_CHECKSUM}
+  PATCH_COMMAND
+    git init && git apply
+    ${CMAKE_CURRENT_LIST_DIR}/c-ares/c-ares-random-file.patch
+    OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+
+set(CARES_STATIC ON)
+set(CARES_INSTALL ON)
+set(CARES_SHARED OFF)
+FetchContent_MakeAvailable(c-ares)
+if(NOT TARGET c-ares::cares)
+  add_library(c-ares::cares ALIAS c-ares)
+endif()
diff --git a/CMake/resolve_dependency_modules/c-ares/c-ares-random-file.patch b/CMake/resolve_dependency_modules/c-ares/c-ares-random-file.patch
new file mode 100644
index 0000000000000..49f5dadeb3434
--- /dev/null
+++ b/CMake/resolve_dependency_modules/c-ares/c-ares-random-file.patch
@@ -0,0 +1,73 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 364b6c7c..c96a5b6c 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -333,6 +333,8 @@ SET (CMAKE_EXTRA_INCLUDE_FILES)
+ SET (CMAKE_REQUIRED_DEFINITIONS)
+ SET (CMAKE_REQUIRED_LIBRARIES)
+ 
++find_file(CARES_RANDOM_FILE urandom /dev)
++mark_as_advanced(CARES_RANDOM_FILE)
+ 
+ ################################################################################
+ # recv, recvfrom, send, getnameinfo, gethostname
+diff --git a/ares_config.h.cmake b/ares_config.h.cmake
+index 0cb2f6ae..b5da36d3 100644
+--- a/ares_config.h.cmake
++++ b/ares_config.h.cmake
+@@ -338,7 +338,7 @@
+ #cmakedefine NEED_MEMORY_H
+ 
+ /* a suitable file/device to read random data from */
+-#cmakedefine RANDOM_FILE
++#cmakedefine CARES_RANDOM_FILE "@CARES_RANDOM_FILE@"
+ 
+ /* Define to the type qualifier pointed by arg 5 for recvfrom. */
+ #define RECVFROM_QUAL_ARG5 @RECVFROM_QUAL_ARG5@
+diff --git a/ares_init.c b/ares_init.c
+index f7b700bf..29bb9784 100644
+--- a/ares_init.c
++++ b/ares_init.c
+@@ -2376,8 +2376,8 @@ static void randomize_key(unsigned char* key,int key_data_len)
+         randomized = 1;
+     }
+ #else /* !WIN32 */
+-#ifdef RANDOM_FILE
+-  FILE *f = fopen(RANDOM_FILE, "rb");
++#ifdef CARES_RANDOM_FILE
++  FILE *f = fopen(CARES_RANDOM_FILE, "rb");
+   if(f) {
+     counter = aresx_uztosi(fread(key, 1, key_data_len, f));
+     fclose(f);
+diff --git a/configure.ac b/configure.ac
+index 7e86ad67..ffdcfdf7 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -829,22 +829,22 @@ dnl Check for user-specified random device
+ AC_ARG_WITH(random,
+ AC_HELP_STRING([--with-random=FILE],
+                [read randomness from FILE (default=/dev/urandom)]),
+-    [ RANDOM_FILE="$withval" ],
++    [ CARES_RANDOM_FILE="$withval" ],
+     [
+         dnl Check for random device.  If we're cross compiling, we can't
+         dnl check, and it's better to assume it doesn't exist than it is
+         dnl to fail on AC_CHECK_FILE or later.
+         if test "$cross_compiling" = "no"; then
+-          AC_CHECK_FILE("/dev/urandom", [ RANDOM_FILE="/dev/urandom"] )
++          AC_CHECK_FILE("/dev/urandom", [ CARES_RANDOM_FILE="/dev/urandom"] )
+         else
+           AC_MSG_WARN([cannot check for /dev/urandom while cross compiling; assuming none])
+         fi
+         
+     ]
+ )
+-if test -n "$RANDOM_FILE" && test X"$RANDOM_FILE" != Xno ; then
+-        AC_SUBST(RANDOM_FILE)
+-        AC_DEFINE_UNQUOTED(RANDOM_FILE, "$RANDOM_FILE",
++if test -n "$CARES_RANDOM_FILE" && test X"$CARES_RANDOM_FILE" != Xno ; then
++        AC_SUBST(CARES_RANDOM_FILE)
++        AC_DEFINE_UNQUOTED(CARES_RANDOM_FILE, "$CARES_RANDOM_FILE",
+         [a suitable file/device to read random data from])
+ fi
+ 
diff --git a/CMake/resolve_dependency_modules/cpr.cmake b/CMake/resolve_dependency_modules/cpr.cmake
new file mode 100644
index 0000000000000..45e0d16375a81
--- /dev/null
+++ b/CMake/resolve_dependency_modules/cpr.cmake
@@ -0,0 +1,46 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set(VELOX_CPR_VERSION 1.10.5)
+set(VELOX_CPR_BUILD_SHA256_CHECKSUM
+    c8590568996cea918d7cf7ec6845d954b9b95ab2c4980b365f582a665dea08d8)
+set(VELOX_CPR_SOURCE_URL
+    "https://github.com/libcpr/cpr/archive/refs/tags/${VELOX_CPR_VERSION}.tar.gz"
+)
+
+# Add the dependency for curl, so that we can define the source URL for curl in
+# curl.cmake. This will override the curl version declared by cpr.
+set(curl_SOURCE BUNDLED)
+resolve_dependency(curl)
+
+resolve_dependency_url(CPR)
+
+message(STATUS "Building cpr from source")
+FetchContent_Declare(
+  cpr
+  URL ${VELOX_CPR_SOURCE_URL}
+  URL_HASH ${VELOX_CPR_BUILD_SHA256_CHECKSUM}
+  PATCH_COMMAND
+    git apply ${CMAKE_CURRENT_LIST_DIR}/cpr/cpr-libcurl-compatible.patch && git
+    apply ${CMAKE_CURRENT_LIST_DIR}/cpr/cpr-remove-sancheck.patch)
+set(BUILD_SHARED_LIBS OFF)
+set(CPR_USE_SYSTEM_CURL OFF)
+# ZLIB has already been found by find_package(ZLIB, REQUIRED), set CURL_ZLIB=OFF
+# to save compile time.
+set(CURL_ZLIB OFF)
+FetchContent_MakeAvailable(cpr)
+# libcpr in its CMakeLists.txt file disables the BUILD_TESTING globally when
+# CPR_USE_SYSTEM_CURL=OFF. unset BUILD_TESTING here.
+unset(BUILD_TESTING)
diff --git a/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch b/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch
new file mode 100644
index 0000000000000..49821889f2bfd
--- /dev/null
+++ b/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch
@@ -0,0 +1,41 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# This can be removed once we upgrade to curl >= 7.68.0
+--- a/cpr/multiperform.cpp
++++ b/cpr/multiperform.cpp
+@@ -97,9 +97,9 @@ void MultiPerform::DoMultiPerform() {
+
+         if (still_running) {
+             const int timeout_ms{250};
+-            error_code = curl_multi_poll(multicurl_->handle, nullptr, 0, timeout_ms, nullptr);
++            error_code = curl_multi_wait(multicurl_->handle, nullptr, 0, timeout_ms, nullptr);
+             if (error_code) {
+-                std::cerr << "curl_multi_poll() failed, code " << static_cast<int>(error_code) << std::endl;
++                std::cerr << "curl_multi_wait() failed, code " << static_cast<int>(error_code) << std::endl;
+                 break;
+             }
+         }
+
+--- a/include/cpr/util.h
++++ b/include/cpr/util.h
+@@ -23,7 +23,7 @@ size_t writeUserFunction(char* ptr, size_t size, size_t nmemb, const WriteCallba
+ template <typename T = ProgressCallback>
+ int progressUserFunction(const T* progress, cpr_pf_arg_t dltotal, cpr_pf_arg_t dlnow, cpr_pf_arg_t ultotal, cpr_pf_arg_t ulnow) {
+     const int cancel_retval{1};
+-    static_assert(cancel_retval != CURL_PROGRESSFUNC_CONTINUE);
++    static_assert(cancel_retval != 0x10000001);
+     return (*progress)(dltotal, dlnow, ultotal, ulnow) ? 0 : cancel_retval;
+ }
+ int debugUserFunction(CURL* handle, curl_infotype type, char* data, size_t size, const DebugCallback* debug);
diff --git a/CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch b/CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch
new file mode 100644
index 0000000000000..4fca92831a206
--- /dev/null
+++ b/CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch
@@ -0,0 +1,24 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# This hangs on CI and is not needed #9116
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -84,7 +84,6 @@ endif()
+ include(GNUInstallDirs)
+ include(FetchContent)
+ include(cmake/code_coverage.cmake)
+-include(cmake/sanitizer.cmake)
+ include(cmake/clear_variable.cmake)
+
+ # So CMake can find FindMbedTLS.cmake
diff --git a/CMake/resolve_dependency_modules/curl.cmake b/CMake/resolve_dependency_modules/curl.cmake
new file mode 100644
index 0000000000000..114aa30c9fcf3
--- /dev/null
+++ b/CMake/resolve_dependency_modules/curl.cmake
@@ -0,0 +1,30 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set(VELOX_CURL_VERSION 8.4.0)
+string(REPLACE "." "_" VELOX_CURL_VERSION_UNDERSCORES ${VELOX_CURL_VERSION})
+set(VELOX_CURL_BUILD_SHA256_CHECKSUM
+    16c62a9c4af0f703d28bda6d7bbf37ba47055ad3414d70dec63e2e6336f2a82d)
+string(
+  CONCAT
+    VELOX_CURL_SOURCE_URL "https://github.com/curl/curl/releases/download/"
+    "curl-${VELOX_CURL_VERSION_UNDERSCORES}/curl-${VELOX_CURL_VERSION}.tar.xz")
+
+resolve_dependency_url(CURL)
+
+FetchContent_Declare(
+  curl
+  URL ${VELOX_CURL_SOURCE_URL}
+  URL_HASH ${VELOX_CURL_BUILD_SHA256_CHECKSUM})
diff --git a/CMake/resolve_dependency_modules/duckdb.cmake b/CMake/resolve_dependency_modules/duckdb.cmake
new file mode 100644
index 0000000000000..f606ab48ef5b9
--- /dev/null
+++ b/CMake/resolve_dependency_modules/duckdb.cmake
@@ -0,0 +1,56 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set(VELOX_DUCKDB_VERSION 0.8.1)
+set(VELOX_DUCKDB_BUILD_SHA256_CHECKSUM
+    a0674f7e320dc7ebcf51990d7fc1c0e7f7b2c335c08f5953702b5285e6c30694)
+set(VELOX_DUCKDB_SOURCE_URL
+    "https://github.com/duckdb/duckdb/archive/refs/tags/v${VELOX_DUCKDB_VERSION}.tar.gz"
+)
+
+resolve_dependency_url(DUCKDB)
+
+message(STATUS "Building DuckDB from source")
+# We need remove-ccache.patch to remove adding ccache to the build command
+# twice. Velox already does this. We need fix-duckdbversion.patch as DuckDB
+# tries to infer the version via a git commit hash or git tag. This inference
+# can lead to errors when building in another git project such as Prestissimo.
+FetchContent_Declare(
+  duckdb
+  URL ${VELOX_DUCKDB_SOURCE_URL}
+  URL_HASH ${VELOX_DUCKDB_BUILD_SHA256_CHECKSUM}
+  PATCH_COMMAND
+    git apply ${CMAKE_CURRENT_LIST_DIR}/duckdb/remove-ccache.patch && git apply
+    ${CMAKE_CURRENT_LIST_DIR}/duckdb/fix-duckdbversion.patch && git apply
+    ${CMAKE_CURRENT_LIST_DIR}/duckdb/re2.patch)
+
+set(BUILD_UNITTESTS OFF)
+set(ENABLE_SANITIZER OFF)
+set(ENABLE_UBSAN OFF)
+set(BUILD_SHELL OFF)
+set(EXPORT_DLL_SYMBOLS OFF)
+set(PREVIOUS_BUILD_TYPE ${CMAKE_BUILD_TYPE})
+set(CMAKE_BUILD_TYPE Release)
+set(PREVIOUS_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-non-virtual-dtor")
+
+FetchContent_MakeAvailable(duckdb)
+
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+  target_compile_options(duckdb_catalog PRIVATE -Wno-nonnull-compare)
+endif()
+
+set(CMAKE_CXX_FLAGS ${PREVIOUS_CMAKE_CXX_FLAGS})
+set(CMAKE_BUILD_TYPE ${PREVIOUS_BUILD_TYPE})
diff --git a/CMake/resolve_dependency_modules/duckdb/fix-duckdbversion.patch b/CMake/resolve_dependency_modules/duckdb/fix-duckdbversion.patch
new file mode 100644
index 0000000000000..d990646800f55
--- /dev/null
+++ b/CMake/resolve_dependency_modules/duckdb/fix-duckdbversion.patch
@@ -0,0 +1,59 @@
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -210,56 +210,8 @@
+   set(CXX_EXTRA "${CXX_EXTRA} -mimpure-text")
+   add_definitions(-DSUN=1)
+   set(SUN TRUE)
+-endif()
+-
+-find_package(Git)
+-if(Git_FOUND)
+-  if (NOT DEFINED GIT_COMMIT_HASH)
+-    execute_process(
+-            COMMAND ${GIT_EXECUTABLE} log -1 --format=%h
+-            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+-            RESULT_VARIABLE GIT_RESULT
+-            OUTPUT_VARIABLE GIT_COMMIT_HASH
+-            OUTPUT_STRIP_TRAILING_WHITESPACE)
+-  endif()
+-  execute_process(
+-          COMMAND ${GIT_EXECUTABLE} describe --tags --abbrev=0
+-          WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+-          OUTPUT_VARIABLE GIT_LAST_TAG
+-          OUTPUT_STRIP_TRAILING_WHITESPACE)
+-  execute_process(
+-          COMMAND ${GIT_EXECUTABLE} describe --tags --long
+-          WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+-          OUTPUT_VARIABLE GIT_ITERATION
+-          OUTPUT_STRIP_TRAILING_WHITESPACE)
+-else()
+-  message("Git NOT FOUND")
+-endif()
+-
+-if(GIT_RESULT EQUAL "0")
+-  string(REGEX REPLACE "v([0-9]+).[0-9]+.[0-9]+" "\\1" DUCKDB_MAJOR_VERSION "${GIT_LAST_TAG}")
+-  string(REGEX REPLACE "v[0-9]+.([0-9]+).[0-9]+" "\\1" DUCKDB_MINOR_VERSION "${GIT_LAST_TAG}")
+-  string(REGEX REPLACE "v[0-9]+.[0-9]+.([0-9]+)" "\\1" DUCKDB_PATCH_VERSION "${GIT_LAST_TAG}")
+-  string(REGEX REPLACE ".*-([0-9]+)-.*" "\\1" DUCKDB_DEV_ITERATION "${GIT_ITERATION}")
+-
+-  if(DUCKDB_DEV_ITERATION EQUAL 0)
+-    # on a tag; directly use the version
+-    set(DUCKDB_VERSION "${GIT_LAST_TAG}")
+-  else()
+-    # not on a tag, increment the patch version by one and add a -devX suffix
+-    math(EXPR DUCKDB_PATCH_VERSION "${DUCKDB_PATCH_VERSION}+1")
+-    set(DUCKDB_VERSION "v${DUCKDB_MAJOR_VERSION}.${DUCKDB_MINOR_VERSION}.${DUCKDB_PATCH_VERSION}-dev${DUCKDB_DEV_ITERATION}")
+-  endif()
+-else()
+-  # fallback for when building from tarball
+-  set(DUCKDB_MAJOR_VERSION 0)
+-  set(DUCKDB_MINOR_VERSION 0)
+-  set(DUCKDB_PATCH_VERSION 1)
+-  set(DUCKDB_DEV_ITERATION 0)
+-  set(DUCKDB_VERSION "v${DUCKDB_MAJOR_VERSION}.${DUCKDB_MINOR_VERSION}.${DUCKDB_PATCH_VERSION}-dev${DUCKDB_DEV_ITERATION}")
+ endif()
+ 
+-message(STATUS "git hash ${GIT_COMMIT_HASH}, version ${DUCKDB_VERSION}")
+ 
+ option(AMALGAMATION_BUILD
+        "Build from the amalgamation files, rather than from the normal sources."
diff --git a/CMake/resolve_dependency_modules/duckdb/re2.patch b/CMake/resolve_dependency_modules/duckdb/re2.patch
new file mode 100644
index 0000000000000..43ec173ee7838
--- /dev/null
+++ b/CMake/resolve_dependency_modules/duckdb/re2.patch
@@ -0,0 +1,11 @@
+--- a/third_party/re2/CMakeLists.txt
++++ b/third_party/re2/CMakeLists.txt
+@@ -90,7 +90,7 @@
+ 
+ target_include_directories(
+   duckdb_re2
+-  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
++  PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+ 
+ install(TARGETS duckdb_re2
+         EXPORT "${DUCKDB_EXPORT_SET}"
diff --git a/CMake/resolve_dependency_modules/duckdb/remove-ccache.patch b/CMake/resolve_dependency_modules/duckdb/remove-ccache.patch
new file mode 100644
index 0000000000000..4d5097f0adca8
--- /dev/null
+++ b/CMake/resolve_dependency_modules/duckdb/remove-ccache.patch
@@ -0,0 +1,19 @@
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -32,16 +32,6 @@ set(CMAKE_VERBOSE_MAKEFILE OFF)
+ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+ set(CMAKE_MACOSX_RPATH 1)
+
+-find_program(CCACHE_PROGRAM ccache)
+-if(CCACHE_PROGRAM)
+-  set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
+-else()
+-  find_program(CCACHE_PROGRAM sccache)
+-  if(CCACHE_PROGRAM)
+-    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
+-  endif()
+-endif()
+-
+ # Determine install paths
+ set(INSTALL_LIB_DIR
+     lib
diff --git a/CMake/resolve_dependency_modules/fast_float.cmake b/CMake/resolve_dependency_modules/fast_float.cmake
new file mode 100644
index 0000000000000..a9f75c774d038
--- /dev/null
+++ b/CMake/resolve_dependency_modules/fast_float.cmake
@@ -0,0 +1,34 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set(VELOX_FAST_FLOAT_VERSION 6.1.6)
+set(VELOX_FAST_FLOAT_BUILD_SHA256_CHECKSUM
+    4458aae4b0eb55717968edda42987cabf5f7fc737aee8fede87a70035dba9ab0)
+set(VELOX_FAST_FLOAT_SOURCE_URL
+    "https://github.com/fastfloat/fast_float/archive/v${VELOX_FAST_FLOAT_VERSION}.tar.gz"
+)
+
+resolve_dependency_url(FAST_FLOAT)
+
+message(STATUS "Building fast_float from source")
+FetchContent_Declare(
+  fast_float
+  URL ${VELOX_FAST_FLOAT_SOURCE_URL}
+  URL_HASH ${VELOX_FAST_FLOAT_BUILD_SHA256_CHECKSUM})
+
+FetchContent_MakeAvailable(fast_float)
+# Folly searches for the header path directly so need to make sure to search in
+# the dependency path.
+list(APPEND CMAKE_PREFIX_PATH "${fast_float_SOURCE_DIR}")
diff --git a/CMake/resolve_dependency_modules/fmt.cmake b/CMake/resolve_dependency_modules/fmt.cmake
index 55be2629962ed..88d8d674d3a3d 100644
--- a/CMake/resolve_dependency_modules/fmt.cmake
+++ b/CMake/resolve_dependency_modules/fmt.cmake
@@ -13,9 +13,9 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_FMT_VERSION 8.0.1)
+set(VELOX_FMT_VERSION 10.1.1)
 set(VELOX_FMT_BUILD_SHA256_CHECKSUM
-    b06ca3130158c625848f3fb7418f235155a4d389b2abc3a6245fb01cb0eb1e01)
+    78b8c0a72b1c35e4443a7e308df52498252d1cefc2b08c9a97bc9ee6cfe61f8b)
 set(VELOX_FMT_SOURCE_URL
     "https://github.com/fmtlib/fmt/archive/${VELOX_FMT_VERSION}.tar.gz")
 
@@ -25,9 +25,7 @@ message(STATUS "Building fmt from source")
 FetchContent_Declare(
   fmt
   URL ${VELOX_FMT_SOURCE_URL}
-  URL_HASH ${VELOX_FMT_BUILD_SHA256_CHECKSUM}
-  PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/fmt/no-targets.patch)
-
+  URL_HASH ${VELOX_FMT_BUILD_SHA256_CHECKSUM})
 # Force fmt to create fmt-config.cmake which can be found by other dependecies
 # (e.g. folly)
 set(FMT_INSTALL ON)
diff --git a/CMake/resolve_dependency_modules/fmt/no-targets.patch b/CMake/resolve_dependency_modules/fmt/no-targets.patch
deleted file mode 100644
index 5ec962d32973c..0000000000000
--- a/CMake/resolve_dependency_modules/fmt/no-targets.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-This can be removed once we upgrade to fmt >= 9
---- a/support/cmake/fmt-config.cmake.in
-+++ b/support/cmake/fmt-config.cmake.in
-@@ -1,4 +1,7 @@
- @PACKAGE_INIT@
- 
--include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake)
-+if (NOT TARGET fmt::fmt)
-+  include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake)
-+endif ()
-+
- check_required_components(fmt)
diff --git a/CMake/resolve_dependency_modules/folly/CMakeLists.txt b/CMake/resolve_dependency_modules/folly/CMakeLists.txt
index a017409c1bd37..6479e3613bea6 100644
--- a/CMake/resolve_dependency_modules/folly/CMakeLists.txt
+++ b/CMake/resolve_dependency_modules/folly/CMakeLists.txt
@@ -14,13 +14,15 @@
 project(Folly)
 cmake_minimum_required(VERSION 3.14)
 
-set(VELOX_FOLLY_BUILD_VERSION v2022.11.14.00)
+set(VELOX_FOLLY_BUILD_VERSION v2024.09.16.00)
 set(VELOX_FOLLY_BUILD_SHA256_CHECKSUM
-    b249436cb61b6dfd5288093565438d8da642b07ae021191a4042b221bc1bdc0e)
+    0a375f2f3e15a2679b4d21fa1064986830a52f59c74d82b3bda1aeeea4e77da0)
 set(VELOX_FOLLY_SOURCE_URL
-    "https://github.com/facebook/folly/archive/${VELOX_FOLLY_BUILD_VERSION}.tar.gz"
+    "https://github.com/facebook/folly/releases/download/${VELOX_FOLLY_BUILD_VERSION}/folly-${VELOX_FOLLY_BUILD_VERSION}.tar.gz"
 )
 
+set(fast_float_SOURCE BUNDLED)
+resolve_dependency(fast_float)
 resolve_dependency_url(FOLLY)
 
 message(STATUS "Building Folly from source")
@@ -52,11 +54,17 @@ add_library(Folly::folly ALIAS folly)
 # The folly target does not contain any include directories, they are propagated
 # from folly_base. This marks them as system headers which should suppress
 # warnigs generated by them when they are included else where.
-get_target_property(_inc folly_base INTERFACE_INCLUDE_DIRECTORIES)
-target_include_directories(folly_base SYSTEM INTERFACE ${_inc})
+set_target_properties(
+  folly_deps
+  PROPERTIES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES
+             $<TARGET_PROPERTY:folly_deps,INTERFACE_INCLUDE_DIRECTORIES>)
+set_target_properties(
+  folly_base
+  PROPERTIES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES
+             $<TARGET_PROPERTY:folly_base,INTERFACE_INCLUDE_DIRECTORIES>)
 
 if(${gflags_SOURCE} STREQUAL "BUNDLED")
-  add_dependencies(folly glog gflags)
+  add_dependencies(folly glog gflags_static fmt::fmt)
 endif()
 
 set(FOLLY_BENCHMARK_STATIC_LIB
diff --git a/CMake/resolve_dependency_modules/folly/folly-gflags-glog.patch b/CMake/resolve_dependency_modules/folly/folly-gflags-glog.patch
index 6ef25f5ac2317..a330989000423 100644
--- a/CMake/resolve_dependency_modules/folly/folly-gflags-glog.patch
+++ b/CMake/resolve_dependency_modules/folly/folly-gflags-glog.patch
@@ -13,10 +13,10 @@
 # limitations under the License.
 --- a/CMake/folly-deps.cmake
 +++ b/CMake/folly-deps.cmake
-@@ -52,19 +52,20 @@ find_package(DoubleConversion MODULE REQUIRED)
- list(APPEND FOLLY_LINK_LIBRARIES ${DOUBLE_CONVERSION_LIBRARY})
- list(APPEND FOLLY_INCLUDE_DIRECTORIES ${DOUBLE_CONVERSION_INCLUDE_DIR})
- 
+@@ -55,19 +55,23 @@ list(APPEND FOLLY_INCLUDE_DIRECTORIES ${DOUBLE_CONVERSION_INCLUDE_DIR})
+ find_package(FastFloat MODULE REQUIRED)
+ list(APPEND FOLLY_INCLUDE_DIRECTORIES ${FASTFLOAT_INCLUDE_DIR})
+
 -find_package(Gflags MODULE)
 -set(FOLLY_HAVE_LIBGFLAGS ${LIBGFLAGS_FOUND})
 -if(LIBGFLAGS_FOUND)
@@ -27,12 +27,14 @@
 +find_package(gflags)
 +set(FOLLY_HAVE_LIBGFLAGS ${gflags_FOUND})
 +if(gflags_FOUND)
-+  list(APPEND FOLLY_LINK_LIBRARIES ${gflags_LIBRARY})
-+  list(APPEND FOLLY_INCLUDE_DIRECTORIES ${gflags_INCLUDE_DIR})
-+  set(FOLLY_LIBGFLAGS_LIBRARY ${gflags_LIBRARY})
-+  set(FOLLY_LIBGFLAGS_INCLUDE ${gflags_INCLUDE_DIR})
++ list(APPEND FOLLY_LINK_LIBRARIES ${gflags_LIBRARY})
++ list(APPEND FOLLY_INCLUDE_DIRECTORIES ${gflags_INCLUDE_DIR})
++ set(FOLLY_LIBGFLAGS_LIBRARY ${gflags_LIBRARY})
++ set(FOLLY_LIBGFLAGS_INCLUDE ${gflags_INCLUDE_DIR})
++ message(STATUS "gflags_INCLUDE_DIR: ${gflags_INCLUDE_DIR}")
++ message(STATUS "gflags_LIBRARY: ${gflags_LIBRARY}")
  endif()
- 
+
 -find_package(Glog MODULE)
 -set(FOLLY_HAVE_LIBGLOG ${GLOG_FOUND})
 -list(APPEND FOLLY_LINK_LIBRARIES ${GLOG_LIBRARY})
@@ -41,7 +43,8 @@
 +set(FOLLY_HAVE_LIBGLOG ${glog_FOUND})
 +list(APPEND FOLLY_LINK_LIBRARIES ${glog_LIBRARY})
 +list(APPEND FOLLY_INCLUDE_DIRECTORIES ${glog_INCLUDE_DIR})
-+message(STATUS "glog_INCLUDE_DIR: ${gflags_LINRARY}")
- 
++message(STATUS "glog_INCLUDE_DIR: ${glog_INCLUDE_DIR}")
++message(STATUS "glog_LIBRARY: ${glog_LIBRARY}")
+
  find_package(LibEvent MODULE REQUIRED)
  list(APPEND FOLLY_LINK_LIBRARIES ${LIBEVENT_LIB})
diff --git a/CMake/resolve_dependency_modules/glog.cmake b/CMake/resolve_dependency_modules/glog.cmake
index 2b77c8f7e9a7a..54836009ed7c8 100644
--- a/CMake/resolve_dependency_modules/glog.cmake
+++ b/CMake/resolve_dependency_modules/glog.cmake
@@ -37,7 +37,7 @@ set(BUILD_TESTING OFF)
 FetchContent_MakeAvailable(glog)
 unset(BUILD_TESTING)
 unset(BUILD_SHARED_LIBS)
-add_dependencies(glog gflags)
+add_dependencies(glog gflags_static)
 
 list(PREPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/glog)
 set(glog_INCLUDE_DIR ${glog_BINARY_DIR})
diff --git a/CMake/resolve_dependency_modules/google_cloud_cpp_storage.cmake b/CMake/resolve_dependency_modules/google_cloud_cpp_storage.cmake
new file mode 100644
index 0000000000000..8106234925e7b
--- /dev/null
+++ b/CMake/resolve_dependency_modules/google_cloud_cpp_storage.cmake
@@ -0,0 +1,41 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set_source(gRPC)
+resolve_dependency(gRPC CONFIG 1.48.1 REQUIRED)
+
+set(VELOX_GOOGLE_CLOUD_CPP_BUILD_VERSION 2.22.0)
+set(VELOX_GOOGLE_CLOUD_CPP_BUILD_SHA256_CHECKSUM
+    0c68782e57959c82e0c81def805c01460a042c1aae0c2feee905acaa2a2dc9bf)
+string(
+  CONCAT VELOX_GOOGLE_CLOUD_CPP_SOURCE_URL
+         "https://github.com/googleapis/google-cloud-cpp/archive/refs/tags/"
+         "v${VELOX_GOOGLE_CLOUD_CPP_BUILD_VERSION}.tar.gz")
+
+resolve_dependency_url(GOOGLE_CLOUD_CPP)
+
+message(STATUS "Building Google Cloud CPP storage from source")
+
+FetchContent_Declare(
+  google_cloud_cpp
+  URL ${VELOX_GOOGLE_CLOUD_CPP_SOURCE_URL}
+  URL_HASH ${VELOX_GOOGLE_CLOUD_CPP_BUILD_SHA256_CHECKSUM}
+  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+
+set(GOOGLE_CLOUD_CPP_ENABLE_EXAMPLES OFF)
+set(GOOGLE_CLOUD_CPP_ENABLE
+    "storage"
+    CACHE STRING "The list of libraries to build.")
+FetchContent_MakeAvailable(google_cloud_cpp)
diff --git a/CMake/resolve_dependency_modules/grpc.cmake b/CMake/resolve_dependency_modules/grpc.cmake
new file mode 100644
index 0000000000000..a2e1a48672bf5
--- /dev/null
+++ b/CMake/resolve_dependency_modules/grpc.cmake
@@ -0,0 +1,61 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set_source(absl)
+resolve_dependency(absl CONFIG REQUIRED)
+
+set(VELOX_GRPC_BUILD_VERSION 1.48.1)
+set(VELOX_GRPC_BUILD_SHA256_CHECKSUM
+    320366665d19027cda87b2368c03939006a37e0388bfd1091c8d2a96fbc93bd8)
+string(
+  CONCAT VELOX_GRPC_SOURCE_URL
+         "https://github.com/grpc/grpc/archive/refs/tags/"
+         "v${VELOX_GRPC_BUILD_VERSION}.tar.gz")
+
+resolve_dependency_url(GRPC)
+
+message(STATUS "Building gRPC from source")
+
+FetchContent_Declare(
+  gRPC
+  URL ${VELOX_GRPC_SOURCE_URL}
+  URL_HASH ${VELOX_GRPC_BUILD_SHA256_CHECKSUM}
+  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL)
+
+set(gRPC_ABSL_PROVIDER
+    "package"
+    CACHE STRING "Provider of absl library")
+set(gRPC_ZLIB_PROVIDER
+    "package"
+    CACHE STRING "Provider of zlib library")
+set(gRPC_CARES_PROVIDER
+    "package"
+    CACHE STRING "Provider of c-ares library")
+set(gRPC_RE2_PROVIDER
+    "package"
+    CACHE STRING "Provider of re2 library")
+set(gRPC_SSL_PROVIDER
+    "package"
+    CACHE STRING "Provider of ssl library")
+set(gRPC_PROTOBUF_PROVIDER
+    "package"
+    CACHE STRING "Provider of protobuf library")
+set(gRPC_INSTALL
+    ON
+    CACHE BOOL "Generate installation target")
+FetchContent_MakeAvailable(gRPC)
+add_library(gRPC::grpc ALIAS grpc)
+add_library(gRPC::grpc++ ALIAS grpc++)
+add_executable(gRPC::grpc_cpp_plugin ALIAS grpc_cpp_plugin)
diff --git a/CMake/resolve_dependency_modules/gtest.cmake b/CMake/resolve_dependency_modules/gtest.cmake
index 5f0c29553c5da..8f35b9e954b95 100644
--- a/CMake/resolve_dependency_modules/gtest.cmake
+++ b/CMake/resolve_dependency_modules/gtest.cmake
@@ -29,3 +29,6 @@ FetchContent_Declare(
   URL_HASH ${VELOX_GTEST_BUILD_SHA256_CHECKSUM})
 
 FetchContent_MakeAvailable(gtest)
+
+# Mask compilation warning in clang 16.
+target_compile_options(gtest PRIVATE -Wno-implicit-int-float-conversion)
diff --git a/CMake/resolve_dependency_modules/libstemmer/Makefile.patch b/CMake/resolve_dependency_modules/libstemmer/Makefile.patch
new file mode 100644
index 0000000000000..e7d6910521115
--- /dev/null
+++ b/CMake/resolve_dependency_modules/libstemmer/Makefile.patch
@@ -0,0 +1,24 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+--- a/Makefile
++++ b/Makefile
+@@ -3,7 +3,7 @@
+ EXEEXT=.exe
+ endif
+ CFLAGS=-O2
+-CPPFLAGS=-Iinclude
++CPPFLAGS=-Iinclude -fPIC
+ all: libstemmer.a stemwords$(EXEEXT)
+ libstemmer.a: $(snowball_sources:.c=.o)
+ 	$(AR) -cru $@ $^
diff --git a/CMake/resolve_dependency_modules/protobuf.cmake b/CMake/resolve_dependency_modules/protobuf.cmake
index 78f896fd655c2..e79d9871b9da5 100644
--- a/CMake/resolve_dependency_modules/protobuf.cmake
+++ b/CMake/resolve_dependency_modules/protobuf.cmake
@@ -13,15 +13,23 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_PROTOBUF_BUILD_VERSION 21.4)
+set(VELOX_PROTOBUF_BUILD_VERSION 21.8)
 set(VELOX_PROTOBUF_BUILD_SHA256_CHECKSUM
-    6c5e1b0788afba4569aeebb2cfe205cb154aa01deacaba0cd26442f3b761a836)
-string(
-  CONCAT
-    VELOX_PROTOBUF_SOURCE_URL
-    "https://github.com/protocolbuffers/protobuf/releases/download/"
-    "v${VELOX_PROTOBUF_BUILD_VERSION}/protobuf-all-${VELOX_PROTOBUF_BUILD_VERSION}.tar.gz"
-)
+    83ad4faf95ff9cbece7cb9c56eb3ca9e42c3497b77001840ab616982c6269fb6)
+if(${VELOX_PROTOBUF_BUILD_VERSION} LESS 22.0)
+  string(
+    CONCAT
+      VELOX_PROTOBUF_SOURCE_URL
+      "https://github.com/protocolbuffers/protobuf/releases/download/"
+      "v${VELOX_PROTOBUF_BUILD_VERSION}/protobuf-all-${VELOX_PROTOBUF_BUILD_VERSION}.tar.gz"
+  )
+else()
+  set_source(absl)
+  resolve_dependency(absl CONFIG REQUIRED)
+  string(CONCAT VELOX_PROTOBUF_SOURCE_URL
+                "https://github.com/protocolbuffers/protobuf/archive/"
+                "v${VELOX_PROTOBUF_BUILD_VERSION}.tar.gz")
+endif()
 
 resolve_dependency_url(PROTOBUF)
 
@@ -30,44 +38,12 @@ message(STATUS "Building Protobuf from source")
 FetchContent_Declare(
   protobuf
   URL ${VELOX_PROTOBUF_SOURCE_URL}
-  URL_HASH ${VELOX_PROTOBUF_BUILD_SHA256_CHECKSUM})
-
-if(NOT protobuf_POPULATED)
-  # We don't want to build tests.
-  set(protobuf_BUILD_TESTS
-      OFF
-      CACHE BOOL "Disable protobuf tests" FORCE)
-  set(CMAKE_CXX_FLAGS_BKP "${CMAKE_CXX_FLAGS}")
-
-  # Disable warnings that would fail protobuf compilation.
-  string(APPEND CMAKE_CXX_FLAGS " -Wno-missing-field-initializers")
-
-  check_cxx_compiler_flag("-Wstringop-overflow"
-                          COMPILER_HAS_W_STRINGOP_OVERFLOW)
-  if(COMPILER_HAS_W_STRINGOP_OVERFLOW)
-    string(APPEND CMAKE_CXX_FLAGS " -Wno-stringop-overflow")
-  endif()
-
-  check_cxx_compiler_flag("-Winvalid-noreturn" COMPILER_HAS_W_INVALID_NORETURN)
-
-  if(COMPILER_HAS_W_INVALID_NORETURN)
-    string(APPEND CMAKE_CXX_FLAGS " -Wno-invalid-noreturn")
-  else()
-    # Currently reproduced on Ubuntu 22.04 with clang 14
-    string(APPEND CMAKE_CXX_FLAGS " -Wno-error")
-  endif()
-
-  # Fetch the content using previously declared details
-  FetchContent_Populate(protobuf)
-
-  # Set right path to libprotobuf-dev include files.
-  set(Protobuf_INCLUDE_DIRS "${protobuf_SOURCE_DIR}/src/")
-  set(Protobuf_PROTOC_EXECUTABLE "${protobuf_BINARY_DIR}/protoc")
-  if(CMAKE_BUILD_TYPE MATCHES Debug)
-    set(Protobuf_LIBRARIES "${protobuf_BINARY_DIR}/libprotobufd.a")
-  else()
-    set(Protobuf_LIBRARIES "${protobuf_BINARY_DIR}/libprotobuf.a")
-  endif()
-  add_subdirectory(${protobuf_SOURCE_DIR} ${protobuf_BINARY_DIR})
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_BKP}")
-endif()
+  URL_HASH ${VELOX_PROTOBUF_BUILD_SHA256_CHECKSUM}
+  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+
+set(protobuf_BUILD_TESTS OFF)
+set(protobuf_ABSL_PROVIDER
+    "package"
+    CACHE STRING "Provider of absl library")
+FetchContent_MakeAvailable(protobuf)
+set(Protobuf_INCLUDE_DIRS ${protobuf_SOURCE_DIR}/src)
diff --git a/CMake/resolve_dependency_modules/re2.cmake b/CMake/resolve_dependency_modules/re2.cmake
index a5dc4baed89b9..6bc00c66c0197 100644
--- a/CMake/resolve_dependency_modules/re2.cmake
+++ b/CMake/resolve_dependency_modules/re2.cmake
@@ -44,7 +44,6 @@ endif()
 
 set(re2_LIBRARIES ${re2_BINARY_DIR}/libre2.a)
 set(re2_INCLUDE_DIRS ${re2_SOURCE_DIR})
-add_library(re2::re2 ALIAS re2)
 
 set(RE2_ROOT ${re2_BINARY_DIR})
 set(re2_ROOT ${re2_BINARY_DIR})
diff --git a/CMake/resolve_dependency_modules/simdjson.cmake b/CMake/resolve_dependency_modules/simdjson.cmake
index 050a5df4cde51..69e7f204494b2 100644
--- a/CMake/resolve_dependency_modules/simdjson.cmake
+++ b/CMake/resolve_dependency_modules/simdjson.cmake
@@ -13,9 +13,9 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_SIMDJSON_VERSION 3.1.5)
+set(VELOX_SIMDJSON_VERSION 3.9.3)
 set(VELOX_SIMDJSON_BUILD_SHA256_CHECKSUM
-    5b916be17343324426fc467a4041a30151e481700d60790acfd89716ecc37076)
+    2e3d10abcde543d3dd8eba9297522cafdcebdd1db4f51b28f3bc95bf1d6ad23c)
 set(VELOX_SIMDJSON_SOURCE_URL
     "https://github.com/simdjson/simdjson/archive/refs/tags/v${VELOX_SIMDJSON_VERSION}.tar.gz"
 )
diff --git a/CMake/resolve_dependency_modules/stemmer.cmake b/CMake/resolve_dependency_modules/stemmer.cmake
new file mode 100644
index 0000000000000..dbaca146341bc
--- /dev/null
+++ b/CMake/resolve_dependency_modules/stemmer.cmake
@@ -0,0 +1,57 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include_guard(GLOBAL)
+
+set(VELOX_STEMMER_VERSION 2.2.0)
+set(VELOX_STEMMER_BUILD_SHA256_CHECKSUM
+    b941d9fe9cf36b4e2f8d3873cd4d8b8775bd94867a1df8d8c001bb8b688377c3)
+set(VELOX_STEMMER_SOURCE_URL
+    "https://snowballstem.org/dist/libstemmer_c-${VELOX_STEMMER_VERSION}.tar.gz"
+)
+
+resolve_dependency_url(STEMMER)
+
+message(STATUS "Building stemmer from source")
+find_program(MAKE_PROGRAM make REQUIRED)
+
+set(STEMMER_PREFIX "${CMAKE_BINARY_DIR}/_deps/libstemmer")
+set(STEMMER_INCLUDE_PATH ${STEMMER_PREFIX}/src/libstemmer/include)
+
+# We can not use FetchContent as libstemmer does not use cmake
+ExternalProject_Add(
+  libstemmer
+  PREFIX ${STEMMER_PREFIX}
+  SOURCE_DIR ${STEMMER_PREFIX}/src/libstemmer
+  URL ${VELOX_STEMMER_SOURCE_URL}
+  URL_HASH ${VELOX_STEMMER_BUILD_SHA256_CHECKSUM}
+  BUILD_IN_SOURCE TRUE
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ${MAKE_PROGRAM}
+  INSTALL_COMMAND ""
+  PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/libstemmer/Makefile.patch
+  BUILD_BYPRODUCTS
+    ${STEMMER_PREFIX}/src/libstemmer/${CMAKE_STATIC_LIBRARY_PREFIX}stemmer${CMAKE_STATIC_LIBRARY_SUFFIX}
+)
+
+add_library(stemmer STATIC IMPORTED GLOBAL)
+add_library(stemmer::stemmer ALIAS stemmer)
+file(MAKE_DIRECTORY ${STEMMER_INCLUDE_PATH})
+set_target_properties(
+  stemmer
+  PROPERTIES
+    IMPORTED_LOCATION
+    ${STEMMER_PREFIX}/src/libstemmer/${CMAKE_STATIC_LIBRARY_PREFIX}stemmer${CMAKE_STATIC_LIBRARY_SUFFIX}
+    INTERFACE_INCLUDE_DIRECTORIES ${STEMMER_INCLUDE_PATH})
+
+add_dependencies(stemmer libstemmer)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 31df59045c044..8b0d3a67c21c1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,9 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-cmake_minimum_required(VERSION 3.14)
+cmake_minimum_required(VERSION 3.28)
+message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
 
-# the policy allows us to change options without caching
+# The policy allows us to change options without caching.
 cmake_policy(SET CMP0077 NEW)
 set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
 
@@ -25,14 +26,39 @@ if(POLICY CMP0135)
   set(CMAKE_POLICY_DEFAULT_CMP0135 NEW)
 endif()
 
-# set the project name
+# Set the project name.
 project(velox)
 
+# If we are in an active conda env disable search in system paths and add env to
+# prefix path
+if(DEFINED ENV{CONDA_PREFIX})
+  if(NOT DEFINED ENV{VELOX_DEPENDENCY_SOURCE} OR "$ENV{VELOX_DEPENDENCY_SOURCE}"
+                                                 STREQUAL "CONDA")
+    message(STATUS "Using Conda environment: $ENV{CONDA_PREFIX}")
+    set(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH FALSE)
+    list(APPEND CMAKE_PREFIX_PATH "$ENV{CONDA_PREFIX}")
+    # Override in case it was set to CONDA
+    set(ENV{VELOX_DEPENDENCY_SOURCE} AUTO)
+  elseif(DEFINED ENV{VELOX_DEPENDENCY_SOURCE}
+         AND NOT "$ENV{VELOX_DEPENDENCY_SOURCE}" STREQUAL "CONDA")
+    message(STATUS "Overriding Conda environment: $ENV{CONDA_PREFIX}")
+  endif()
+endif()
+
+if(DEFINED ENV{INSTALL_PREFIX})
+  message(STATUS "Dependency install directory set to: $ENV{INSTALL_PREFIX}")
+  list(APPEND CMAKE_PREFIX_PATH "$ENV{INSTALL_PREFIX}")
+  # Allow installed package headers to be picked up before brew/system package
+  # headers
+  include_directories(BEFORE "$ENV{INSTALL_PREFIX}/include")
+endif()
+
 list(PREPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMake"
      "${PROJECT_SOURCE_DIR}/CMake/third-party")
 
 # Include our ThirdPartyToolchain dependencies macros
 include(ResolveDependency)
+include(VeloxUtils)
 
 set_with_default(VELOX_DEPENDENCY_SOURCE_DEFAULT VELOX_DEPENDENCY_SOURCE AUTO)
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
@@ -46,6 +72,13 @@ option(
   VELOX_BUILD_MINIMAL
   "Build a minimal set of components only. This will override other build options."
   OFF)
+option(
+  VELOX_BUILD_MINIMAL_WITH_DWIO
+  "Build a minimal set of components, including DWIO (file format readers/writers).
+   This will override other build options."
+  OFF)
+option(VELOX_MONO_LIBRARY "Build single unified library." OFF)
+
 # option() always creates a BOOL variable so we have to use a normal cache
 # variable with STRING type for this option.
 #
@@ -58,7 +91,12 @@ set(VELOX_DEPENDENCY_SOURCE
       STRING
       "Default source for all dependencies with source builds enabled: AUTO SYSTEM BUNDLED."
 )
-option(VELOX_ENABLE_DUCKDB "Build duckDB to enable differential testing." ON)
+set(VELOX_GFLAGS_TYPE
+    "shared"
+    CACHE
+      STRING
+      "Specify whether to find the gflags package as a shared or static package"
+)
 option(VELOX_ENABLE_EXEC "Build exec." ON)
 option(VELOX_ENABLE_AGGREGATES "Build aggregates." ON)
 option(VELOX_ENABLE_HIVE_CONNECTOR "Build Hive connector." ON)
@@ -66,10 +104,9 @@ option(VELOX_ENABLE_TPCH_CONNECTOR "Build TPC-H connector." ON)
 option(VELOX_ENABLE_PRESTO_FUNCTIONS "Build Presto SQL functions." ON)
 option(VELOX_ENABLE_SPARK_FUNCTIONS "Build Spark SQL functions." ON)
 option(VELOX_ENABLE_EXPRESSION "Build expression." ON)
-option(VELOX_ENABLE_PARSE "Build parser used for unit tests." ON)
-option(VELOX_ENABLE_EXAMPLES
-       "Build examples. This will enable VELOX_ENABLE_EXPRESSION automatically."
-       OFF)
+option(
+  VELOX_ENABLE_EXAMPLES
+  "Build examples. This will enable VELOX_ENABLE_EXPRESSION automatically." OFF)
 option(VELOX_ENABLE_SUBSTRAIT "Build Substrait-to-Velox converter." OFF)
 option(VELOX_ENABLE_BENCHMARKS "Enable Velox top level benchmarks." OFF)
 option(VELOX_ENABLE_BENCHMARKS_BASIC "Enable Velox basic benchmarks." OFF)
@@ -83,20 +120,24 @@ option(VELOX_ENABLE_REMOTE_FUNCTIONS "Enable remote function support" OFF)
 option(VELOX_ENABLE_CCACHE "Use ccache if installed." ON)
 
 option(VELOX_BUILD_TEST_UTILS "Builds Velox test utilities" OFF)
+option(VELOX_BUILD_VECTOR_TEST_UTILS "Builds Velox vector test utilities" OFF)
 option(VELOX_BUILD_PYTHON_PACKAGE "Builds Velox Python bindings" OFF)
-option(VELOX_BUILD_BENCHMARKS "Builds Velox benchmarks" OFF)
 option(
   VELOX_ENABLE_INT64_BUILD_PARTITION_BOUND
   "make buildPartitionBounds_ a vector int64 instead of int32 to avoid integer overflow when the hashtable has billions of records"
   OFF)
 
-if(${VELOX_BUILD_MINIMAL})
+# Explicitly force compilers to generate colored output. Compilers usually do
+# this by default if they detect the output is a terminal, but this assumption
+# is broken if you use ninja.
+option(VELOX_FORCE_COLORED_OUTPUT
+       "Always produce ANSI-colored output (GNU/Clang only)." OFF)
+
+if(${VELOX_BUILD_MINIMAL} OR ${VELOX_BUILD_MINIMAL_WITH_DWIO})
   # Enable and disable components for velox base build
   set(VELOX_BUILD_TESTING OFF)
   set(VELOX_ENABLE_PRESTO_FUNCTIONS ON)
-  set(VELOX_ENABLE_DUCKDB OFF)
   set(VELOX_ENABLE_EXPRESSION ON)
-  set(VELOX_ENABLE_PARSE OFF)
   set(VELOX_ENABLE_EXEC OFF)
   set(VELOX_ENABLE_AGGREGATES OFF)
   set(VELOX_ENABLE_HIVE_CONNECTOR OFF)
@@ -107,64 +148,54 @@ if(${VELOX_BUILD_MINIMAL})
   set(VELOX_ENABLE_GCS OFF)
   set(VELOX_ENABLE_ABFS OFF)
   set(VELOX_ENABLE_SUBSTRAIT OFF)
-  set(VELOX_CODEGEN_SUPPORT OFF)
 endif()
 
 if(${VELOX_BUILD_TESTING})
   # Enable all components to build testing binaries
   set(VELOX_ENABLE_PRESTO_FUNCTIONS ON)
-  set(VELOX_ENABLE_DUCKDB ON)
   set(VELOX_ENABLE_EXPRESSION ON)
-  set(VELOX_ENABLE_PARSE ON)
   set(VELOX_ENABLE_EXEC ON)
   set(VELOX_ENABLE_AGGREGATES ON)
   set(VELOX_ENABLE_HIVE_CONNECTOR ON)
   set(VELOX_ENABLE_TPCH_CONNECTOR ON)
   set(VELOX_ENABLE_SPARK_FUNCTIONS ON)
-  set(VELOX_ENABLE_TEST_UTILS OFF)
   set(VELOX_ENABLE_EXAMPLES ON)
+  set(VELOX_ENABLE_PARQUET ON)
 endif()
 
-if(${VELOX_ENABLE_EXAMPLES})
-  set(VELOX_ENABLE_EXPRESSION ON)
-  set(VELOX_ENABLE_TEST_UTILS ON)
+if(${VELOX_ENABLE_BENCHMARKS})
+  set(VELOX_ENABLE_BENCHMARKS_BASIC ON)
 endif()
 
-if(${VELOX_BUILD_BENCHMARKS})
-  set(VELOX_ENABLE_BENCHMARKS ON)
-  set(VELOX_ENABLE_BENCHMARKS_BASIC ON)
+if(VELOX_ENABLE_BENCHMARKS_BASIC)
+  set(VELOX_BUILD_TEST_UTILS ON)
+endif()
+
+if(VELOX_BUILD_TESTING OR VELOX_BUILD_TEST_UTILS)
+  set(cpr_SOURCE BUNDLED)
+  resolve_dependency(cpr)
   set(VELOX_ENABLE_DUCKDB ON)
   set(VELOX_ENABLE_PARSE ON)
-  set(VELOX_ENABLE_PARQUET ON)
-  set(VELOX_BUILD_TEST_UTILS ON)
-  set(VELOX_BUILD_TESTING OFF)
-  set(VELOX_ENABLE_EXAMPLES OFF)
-  set(VELOX_ENABLE_GCS OFF)
-  set(VELOX_ENABLE_ABFS OFF)
-  set(VELOX_ENABLE_SUBSTRAIT OFF)
-  set(VELOX_CODEGEN_SUPPORT OFF)
+endif()
+
+if(${VELOX_ENABLE_EXAMPLES})
+  set(VELOX_ENABLE_EXPRESSION ON)
 endif()
 
 if(${VELOX_BUILD_PYTHON_PACKAGE})
-  set(VELOX_BUILD_TESTING OFF)
   set(VELOX_ENABLE_PRESTO_FUNCTIONS ON)
   set(VELOX_ENABLE_DUCKDB ON)
   set(VELOX_ENABLE_EXPRESSION ON)
   set(VELOX_ENABLE_PARSE ON)
   set(VELOX_ENABLE_EXEC ON)
-  set(VELOX_ENABLE_AGGREGATES OFF)
-  set(VELOX_ENABLE_HIVE_CONNECTOR OFF)
-  set(VELOX_ENABLE_TPCH_CONNECTOR OFF)
+  set(VELOX_ENABLE_AGGREGATES ON)
   set(VELOX_ENABLE_SPARK_FUNCTIONS ON)
-  set(VELOX_ENABLE_EXAMPLES OFF)
-  set(VELOX_ENABLE_S3 OFF)
-  set(VELOX_ENABLE_GCS OFF)
-  set(VELOX_ENABLE_ABFS OFF)
-  set(VELOX_ENABLE_SUBSTRAIT OFF)
-  set(VELOX_CODEGEN_SUPPORT OFF)
-  set(VELOX_ENABLE_BENCHMARKS_BASIC OFF)
 endif()
 
+# We look for OpenSSL here to cache the result enforce the version across our
+# dependencies.
+find_package(OpenSSL REQUIRED)
+
 if(VELOX_ENABLE_CCACHE
    AND NOT CMAKE_C_COMPILER_LAUNCHER
    AND NOT CMAKE_CXX_COMPILER_LAUNCHER)
@@ -180,6 +211,20 @@ if(VELOX_ENABLE_CCACHE
   endif()
 endif()
 
+if(${VELOX_FORCE_COLORED_OUTPUT})
+  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    add_compile_options(-fdiagnostics-color=always)
+  elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+         OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
+    add_compile_options(-fcolor-diagnostics)
+  endif()
+endif()
+
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+   AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_GREATER_EQUAL 15)
+  set(CMAKE_EXE_LINKER_FLAGS "-latomic")
+endif()
+
 # At the moment we prefer static linking but by default cmake looks for shared
 # libs first. This will still fallback to shared libs when static ones are not
 # found
@@ -193,22 +238,14 @@ if(VELOX_ENABLE_S3)
   add_definitions(-DVELOX_ENABLE_S3)
 endif()
 
-if(VELOX_ENABLE_GCS)
-  # Set GCS_ROOT_DIR if you have a custom install location of GCS SDK CPP.
-  if(GCSSDK_ROOT_DIR)
-    list(APPEND CMAKE_PREFIX_PATH ${GCSSDK_ROOT_DIR})
-  endif()
-  find_package(google_cloud_cpp_storage REQUIRED)
-  add_definitions(-DVELOX_ENABLE_GCS)
-endif()
-
 if(VELOX_ENABLE_ABFS)
   # Set AZURESDK_ROOT_DIR if you have a custom install location of Azure Storage
   # SDK CPP.
   if(AZURESDK_ROOT_DIR)
     list(APPEND CMAKE_PREFIX_PATH ${AZURESDK_ROOT_DIR})
   endif()
-  find_package(azure-storage-blobs-cpp CONFIG REQUIRED)
+  # files-datalake is built on blobs
+  find_package(azure-storage-files-datalake-cpp CONFIG REQUIRED)
   add_definitions(-DVELOX_ENABLE_ABFS)
 endif()
 
@@ -227,30 +264,6 @@ if(VELOX_ENABLE_PARQUET)
   set(VELOX_ENABLE_ARROW ON)
 endif()
 
-if(VELOX_ENABLE_REMOTE_FUNCTIONS)
-  # TODO: Move this to use resolve_dependency(). For some reason, FBThrift
-  # requires clients to explicitly install fizz and wangle.
-  find_package(fizz CONFIG REQUIRED)
-  find_package(wangle CONFIG REQUIRED)
-  find_package(FBThrift CONFIG REQUIRED)
-endif()
-
-# Turn on Codegen only for Clang and non Mac systems.
-if((NOT DEFINED VELOX_CODEGEN_SUPPORT)
-   AND (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-   AND NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin"))
-  message(STATUS "Enabling Codegen")
-  set(VELOX_CODEGEN_SUPPORT True)
-else()
-  message(STATUS "Disabling Codegen")
-  set(VELOX_CODEGEN_SUPPORT False)
-endif()
-
-# define processor variable for conditional compilation
-if(${VELOX_CODEGEN_SUPPORT})
-  add_compile_definitions(CODEGEN_ENABLED=1)
-endif()
-
 # make buildPartitionBounds_ a vector int64 instead of int32 to avoid integer
 # overflow
 if(${VELOX_ENABLE_INT64_BUILD_PARTITION_BOUND})
@@ -265,7 +278,7 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 endif()
 
 if(UNIX AND NOT APPLE)
-  # codegen linker flags, -export-dynamic for rtti
+  # linker flags, -export-dynamic for rtti
   add_link_options("-Wl,-export-dynamic")
 endif()
 
@@ -324,7 +337,6 @@ if("${ENABLE_ALL_WARNINGS}")
   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(KNOWN_COMPILER_SPECIFIC_WARNINGS
         "-Wno-implicit-fallthrough \
-         -Wno-empty-body \
          -Wno-class-memaccess \
          -Wno-comment \
          -Wno-int-in-bool-context \
@@ -333,11 +345,7 @@ if("${ENABLE_ALL_WARNINGS}")
          -Wno-maybe-uninitialized \
          -Wno-unused-result \
          -Wno-format-overflow \
-         -Wno-strict-aliasing \
-         -Wno-type-limits \
-         -Wno-stringop-overflow \
-         -Wno-stringop-overread \
-         -Wno-return-type")
+         -Wno-strict-aliasing")
   endif()
 
   set(KNOWN_WARNINGS
@@ -356,6 +364,10 @@ if(${VELOX_ENABLE_GPU})
   enable_language(CUDA)
   # Determine CUDA_ARCHITECTURES automatically.
   cmake_policy(SET CMP0104 NEW)
+  if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+    # it will fail later in the build otherwise
+    message(FATAL_ERROR "-DCMAKE_CUDA_ARCHITECTURES= must be set")
+  endif()
   if(CMAKE_BUILD_TYPE MATCHES Debug)
     add_compile_options("$<$<COMPILE_LANGUAGE:CUDA>:-G>")
   endif()
@@ -365,7 +377,6 @@ endif()
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 set(BOOST_INCLUDE_LIBRARIES
-    headers
     atomic
     context
     date_time
@@ -376,13 +387,13 @@ set(BOOST_INCLUDE_LIBRARIES
     thread)
 
 set_source(Boost)
-resolve_dependency(Boost 1.66.0 COMPONENTS ${BOOST_INCLUDE_LIBRARIES})
+resolve_dependency(Boost 1.77.0 COMPONENTS ${BOOST_INCLUDE_LIBRARIES})
 
 # Range-v3 will be enable when the codegen code actually lands keeping it here
 # for reference. find_package(range-v3)
 
 set_source(gflags)
-resolve_dependency(gflags COMPONENTS shared)
+resolve_dependency(gflags COMPONENTS ${VELOX_GFLAGS_TYPE})
 if(NOT TARGET gflags::gflags)
   # This is a bit convoluted, but we want to be able to use gflags::gflags as a
   # target even when velox is built as a subproject which uses
@@ -402,10 +413,18 @@ else()
 endif()
 resolve_dependency(glog)
 
+if(${VELOX_ENABLE_DUCKDB})
+  set_source(DuckDB)
+  resolve_dependency(DuckDB)
+endif()
+
 set_source(fmt)
-resolve_dependency(fmt)
+resolve_dependency(fmt 9.0.0)
 
-if(NOT ${VELOX_BUILD_MINIMAL})
+if(${VELOX_BUILD_MINIMAL_WITH_DWIO} OR ${VELOX_ENABLE_HIVE_CONNECTOR})
+  # DWIO needs all sorts of stream compression libraries.
+  #
+  # TODO: make these optional and pluggable.
   find_package(ZLIB REQUIRED)
   find_package(lz4 REQUIRED)
   find_package(lzo2 REQUIRED)
@@ -430,36 +449,72 @@ if(${VELOX_BUILD_PYTHON_PACKAGE})
   add_subdirectory(pyvelox)
 endif()
 
+# DWIO (ORC/DWRF) and Substrait depend on protobuf.
+if(${VELOX_BUILD_MINIMAL_WITH_DWIO}
+   OR ${VELOX_ENABLE_HIVE_CONNECTOR}
+   OR ${VELOX_ENABLE_SUBSTRAIT}
+   OR VELOX_ENABLE_GCS)
+
+  # Locate or build protobuf.
+  set_source(Protobuf)
+  resolve_dependency(Protobuf CONFIG 3.21.7 REQUIRED)
+  include_directories(${Protobuf_INCLUDE_DIRS})
+endif()
+
 set_source(simdjson)
-resolve_dependency(simdjson 3.1.5)
+resolve_dependency(simdjson 3.9.3)
 
 # Locate or build folly.
 add_compile_definitions(FOLLY_HAVE_INT128_T=1)
 set_source(folly)
 resolve_dependency(folly)
 
+if(${VELOX_BUILD_TESTING})
+  # Spark qury runner depends on absl, gRPC.
+  set_source(absl)
+  resolve_dependency(absl)
+
+  # 'gRPC_CARES_PROVIDER' is set as 'package', which means c-ares library needs
+  # to be installed on the system, instead of being built by gRPC.
+  set_source(c-ares)
+  resolve_dependency(c-ares)
+
+  set_source(gRPC)
+  resolve_dependency(gRPC)
+endif()
+
+if(VELOX_ENABLE_REMOTE_FUNCTIONS)
+  # TODO: Move this to use resolve_dependency(). For some reason, FBThrift
+  # requires clients to explicitly install fizz and wangle.
+  find_package(fizz CONFIG REQUIRED)
+  find_package(wangle CONFIG REQUIRED)
+  find_package(FBThrift CONFIG REQUIRED)
+endif()
+
 if(DEFINED FOLLY_BENCHMARK_STATIC_LIB)
   set(FOLLY_BENCHMARK ${FOLLY_BENCHMARK_STATIC_LIB})
 else()
   set(FOLLY_BENCHMARK Folly::follybenchmark)
 endif()
 
-if(NOT ${VELOX_BUILD_MINIMAL})
-  # Locate or build protobuf.
-  set_source(Protobuf)
-  resolve_dependency(Protobuf 3.21 EXACT)
-  include_directories(${Protobuf_INCLUDE_DIRS})
+if(VELOX_ENABLE_GCS)
+  set_source(google_cloud_cpp_storage)
+  resolve_dependency(google_cloud_cpp_storage CONFIG 2.22.0 REQUIRED)
+  add_definitions(-DVELOX_ENABLE_GCS)
 endif()
 
 # GCC needs to link a library to enable std::filesystem.
 if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
   set(FILESYSTEM "stdc++fs")
 
-  # Ensure we have gcc at least 8+.
-  if(CMAKE_CXX_COMPILER_VERSION LESS 8.0)
+  # Ensure we have gcc at least 9+.
+  if(CMAKE_CXX_COMPILER_VERSION LESS 9.0)
     message(
-      FATAL_ERROR "VELOX requires gcc > 8. Found ${CMAKE_CXX_COMPILER_VERSION}")
+      FATAL_ERROR "VELOX requires gcc > 9. Found ${CMAKE_CXX_COMPILER_VERSION}")
   endif()
+
+  # Find Threads library
+  find_package(Threads REQUIRED)
 else()
   set(FILESYSTEM "")
 endif()
@@ -505,25 +560,30 @@ if(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
 endif()
 find_package(BISON 3.0.4 REQUIRED)
 find_package(FLEX 2.5.13 REQUIRED)
+find_package(double-conversion 3.1.5 REQUIRED)
 
 include_directories(SYSTEM velox)
 include_directories(SYSTEM velox/external)
-include_directories(SYSTEM velox/external/duckdb)
-include_directories(SYSTEM velox/external/duckdb/tpch/dbgen/include)
 
 # these were previously vendored in third-party/
 if(NOT VELOX_DISABLE_GOOGLETEST)
-  set(gtest_SOURCE BUNDLED)
-  resolve_dependency(gtest)
+  set(GTest_SOURCE AUTO)
+  resolve_dependency(GTest)
   set(VELOX_GTEST_INCUDE_DIR
       "${gtest_SOURCE_DIR}/googletest/include"
       PARENT_SCOPE)
 endif()
 
-set(xsimd_SOURCE BUNDLED)
-resolve_dependency(xsimd)
+set_source(xsimd)
+resolve_dependency(xsimd 10.0.0)
+
+set(stemmer_SOURCE BUNDLED)
+resolve_dependency(stemmer)
 
-include(CTest) # include after project() but before add_subdirectory()
+if(VELOX_BUILD_TESTING)
+  set(BUILD_TESTING ON)
+  include(CTest) # include after project() but before add_subdirectory()
+endif()
 
 include_directories(.)
 
@@ -537,5 +597,9 @@ if("${TREAT_WARNINGS_AS_ERRORS}")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
 endif()
 
-add_subdirectory(third_party)
+if(VELOX_ENABLE_ARROW)
+  set_source(Arrow)
+  resolve_dependency(Arrow)
+endif()
+
 add_subdirectory(velox)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0be82b463ad19..6c8d4f75ca513 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -9,7 +9,8 @@ make contributions to the project and community.
 
 ## Code of Conduct
 
-First and foremost, the Velox project and all its contributors and maintainers
+First and foremost, the Velox project and all its contributors and
+[maintainers]((https://velox-lib.io/docs/community/components-and-maintainers))
 are governed by a [Code of Conduct](CODE_OF_CONDUCT.md). When participating,
 you are expected to uphold this code.
 
@@ -21,6 +22,12 @@ and [Discussions](https://github.com/facebookincubator/velox/discussions), and j
 [the Velox-OSS Slack workspace](http://velox-oss.slack.com) - please reach out to 
 **velox@meta.com** to get access.
 
+## Components and Maintainers
+
+Velox is logically organized into components, each maintained by a group of
+individuals.  The list of components and their respective maintainers [can be
+found here](https://velox-lib.io/docs/community/components-and-maintainers).
+
 ## Documentation
 
 Help the community understand how to use the Velox library by proposing
@@ -166,7 +173,8 @@ Velox and the code review process. In addition to the general contribution
 guidelines presented above, here are specific guidelines for contributing
 functions:
 
-1. Read [How to add a scalar function?](https://facebookincubator.github.io/velox/develop/scalar-functions.html) guide.
+1. Read [How to add a scalar function?](https://facebookincubator.github.io/velox/develop/scalar-functions.html) guide. When implementing a function, simple function is preferred unless the implementation of vector function provides a significant performance gain which can be demonstrated
+with a benchmark.
 
 2. Use the following template for the PR title: Add xxx [Presto|Spark] function (replace xxx with the function name).
    * Ensure the PR description contains a link to the function documentation
@@ -174,6 +182,7 @@ functions:
    * Describe the function semantics and edge cases clearly.
 
 3. Use Presto or Spark to check the function semantics. 
+   * When implementing a Spark function, check the function semantics using Spark 3.5 with ANSI OFF.
    * Try different edge cases to check whether the function returns null, or
    throws, etc. 
    * Make sure to replicate the exact semantics.
@@ -197,11 +206,11 @@ functions:
    ```
    # Test the new function in isolation. Use --only flag to restrict the set of functions
    # and run for 60 seconds or longer.
-   velox_expression_fuzzer_test --only <my-new-function-name> --duration_sec 60 --logtostderr=1 --enable_variadic_signatures --velox_fuzzer_enable_complex_types --lazy_vector_generation_ratio 0.2 --velox_fuzzer_enable_column_reuse --velox_fuzzer_enable_expression_reuse
+   velox_expression_fuzzer_test --only <my-new-function-name> --duration_sec 60 --logtostderr=1 --enable_variadic_signatures --velox_fuzzer_enable_complex_types --velox_fuzzer_enable_decimal_type --lazy_vector_generation_ratio 0.2 --velox_fuzzer_enable_column_reuse --velox_fuzzer_enable_expression_reuse
 
    # Test the new function in combination with other functions. Do not restrict the set
    # of functions and run for 10 minutes (600 seconds) or longer.
-   velox_expression_fuzzer_test --duration_sec 600 --logtostderr=1 --enable_variadic_signatures --velox_fuzzer_enable_complex_types --lazy_vector_generation_ratio 0.2 --velox_fuzzer_enable_column_reuse --velox_fuzzer_enable_expression_reuse
+   velox_expression_fuzzer_test --duration_sec 600 --logtostderr=1 --enable_variadic_signatures --velox_fuzzer_enable_complex_types --velox_fuzzer_enable_decimal_type --lazy_vector_generation_ratio 0.2 --velox_fuzzer_enable_column_reuse --velox_fuzzer_enable_expression_reuse
    ```
 
 Here are example PRs:
diff --git a/Makefile b/Makefile
index c6cdc3a714554..2e6144c844c53 100644
--- a/Makefile
+++ b/Makefile
@@ -13,6 +13,7 @@
 # limitations under the License.
 .PHONY: all cmake build clean debug release unit
 
+SHELL=/bin/bash
 BUILD_BASE_DIR=_build
 BUILD_DIR=release
 BUILD_TYPE=Release
@@ -20,6 +21,7 @@ BENCHMARKS_BASIC_DIR=$(BUILD_BASE_DIR)/$(BUILD_DIR)/velox/benchmarks/basic/
 BENCHMARKS_DUMP_DIR=dumps
 TREAT_WARNINGS_AS_ERRORS ?= 1
 ENABLE_WALL ?= 1
+PYTHON_VENV ?= .venv
 
 # Option to make a minimal build. By default set to "OFF"; set to
 # "ON" to only build a minimal set of components. This may override
@@ -50,17 +52,28 @@ ifdef AZURESDK_ROOT_DIR
 CMAKE_FLAGS += -DAZURESDK_ROOT_DIR=$(AZURESDK_ROOT_DIR)
 endif
 
+ifdef CUDA_ARCHITECTURES
+CMAKE_FLAGS += -DCMAKE_CUDA_ARCHITECTURES="$(CUDA_ARCHITECTURES)"
+endif
+
+ifdef CUDA_COMPILER
+CMAKE_FLAGS += -DCMAKE_CUDA_COMPILER="$(CUDA_COMPILER)"
+endif
+
+ifdef CUDA_FLAGS
+CMAKE_FLAGS += -DCMAKE_CUDA_FLAGS="$(CUDA_FLAGS)"
+endif
+
 # Use Ninja if available. If Ninja is used, pass through parallelism control flags.
 USE_NINJA ?= 1
 ifeq ($(USE_NINJA), 1)
 ifneq ($(shell which ninja), )
-GENERATOR=-GNinja -DMAX_LINK_JOBS=$(MAX_LINK_JOBS) -DMAX_HIGH_MEM_JOBS=$(MAX_HIGH_MEM_JOBS)
-endif
-endif
+GENERATOR := -GNinja
+GENERATOR += -DMAX_LINK_JOBS=$(MAX_LINK_JOBS)
+GENERATOR += -DMAX_HIGH_MEM_JOBS=$(MAX_HIGH_MEM_JOBS)
 
-ifndef USE_CCACHE
-ifneq ($(shell which ccache), )
-USE_CCACHE=-DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+# Ninja makes compilers disable colored output by default.
+GENERATOR += -DVELOX_FORCE_COLORED_OUTPUT=ON
 endif
 endif
 
@@ -79,16 +92,14 @@ clean:					#: Delete all build artifacts
 
 cmake:					#: Use CMake to create a Makefile build system
 	mkdir -p $(BUILD_BASE_DIR)/$(BUILD_DIR) && \
-	cmake -B \
+	cmake  -B \
 		"$(BUILD_BASE_DIR)/$(BUILD_DIR)" \
 		${CMAKE_FLAGS} \
 		$(GENERATOR) \
-		$(USE_CCACHE) \
-		$(FORCE_COLOR) \
 		${EXTRA_CMAKE_FLAGS}
 
 cmake-gpu:
-	$(MAKE) EXTRA_CMAKE_FLAGS=-DVELOX_ENABLE_GPU=ON cmake
+	$(MAKE) EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_GPU=ON" cmake
 
 build:					#: Build the software based in BUILD_DIR and BUILD_TYPE variables
 	cmake --build $(BUILD_BASE_DIR)/$(BUILD_DIR) -j $(NUM_THREADS)
@@ -101,12 +112,43 @@ release:				#: Build the release version
 	$(MAKE) cmake BUILD_DIR=release BUILD_TYPE=Release && \
 	$(MAKE) build BUILD_DIR=release
 
-min_debug:				#: Minimal build with debugging symbols
-	$(MAKE) cmake BUILD_DIR=debug BUILD_TYPE=debug EXTRA_CMAKE_FLAGS=-DVELOX_BUILD_MINIMAL=ON
+minimal_debug:			#: Minimal build with debugging symbols
+	$(MAKE) cmake BUILD_DIR=debug BUILD_TYPE=debug EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_BUILD_MINIMAL=ON"
+	$(MAKE) build BUILD_DIR=debug
+
+min_debug: minimal_debug
+
+minimal:				 #: Minimal build
+	$(MAKE) cmake BUILD_DIR=release BUILD_TYPE=release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_BUILD_MINIMAL=ON"
+	$(MAKE) build BUILD_DIR=release
+
+gpu:						 #: Build with GPU support
+	$(MAKE) cmake BUILD_DIR=release BUILD_TYPE=release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_GPU=ON"
+	$(MAKE) build BUILD_DIR=release
+
+gpu_debug:			 #: Build with debugging symbols and GPU support
+	$(MAKE) cmake BUILD_DIR=debug BUILD_TYPE=debug EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_GPU=ON"
+	$(MAKE) build BUILD_DIR=debug
+
+dwio:						#: Minimal build with dwio enabled.
+	$(MAKE) cmake BUILD_DIR=release BUILD_TYPE=release EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} \
+																										    							  -DVELOX_BUILD_MINIMAL_WITH_DWIO=ON"
+	$(MAKE) build BUILD_DIR=release
+
+dwio_debug:			#: Minimal build with dwio debugging symbols.
+	$(MAKE) cmake BUILD_DIR=debug BUILD_TYPE=debug EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} \
+																																	  -DVELOX_BUILD_MINIMAL_WITH_DWIO=ON"
 	$(MAKE) build BUILD_DIR=debug
 
 benchmarks-basic-build:
-	$(MAKE) release EXTRA_CMAKE_FLAGS="-DVELOX_BUILD_BENCHMARKS=ON"
+	$(MAKE) release EXTRA_CMAKE_FLAGS=" ${EXTRA_CMAKE_FLAGS} \
+                                            -DVELOX_BUILD_TESTING=OFF \
+                                            -DVELOX_ENABLE_BENCHMARKS_BASIC=ON"
+
+benchmarks-build:
+	$(MAKE) release EXTRA_CMAKE_FLAGS=" ${EXTRA_CMAKE_FLAGS} \
+                                            -DVELOX_BUILD_TESTING=OFF \
+                                            -DVELOX_ENABLE_BENCHMARKS=ON"
 
 benchmarks-basic-run:
 	scripts/benchmark-runner.py run \
@@ -121,7 +163,7 @@ unittest: debug			#: Build with debugging and run unit tests
 # Build with debugging and run expression fuzzer test. Use a fixed seed to
 # ensure the tests are reproducible.
 fuzzertest: debug
-	$(BUILD_BASE_DIR)/debug/velox/expression/tests/velox_expression_fuzzer_test \
+	$(BUILD_BASE_DIR)/debug/velox/expression/fuzzer/velox_expression_fuzzer_test \
 			--seed $(FUZZER_SEED) \
 			--duration_sec $(FUZZER_DURATION_SEC) \
 			--repro_persist_path $(FUZZER_REPRO_PERSIST_PATH) \
@@ -129,17 +171,33 @@ fuzzertest: debug
 			--minloglevel=0
 
 format-fix: 			#: Fix formatting issues in the main branch
+ifneq ("$(wildcard ${PYTHON_VENV}/pyvenv.cfg)","")
+	source ${PYTHON_VENV}/bin/activate; scripts/check.py format main --fix
+else
 	scripts/check.py format main --fix
+endif
 
 format-check: 			#: Check for formatting issues on the main branch
 	clang-format --version
+ifneq ("$(wildcard ${PYTHON_VENV}/pyvenv.cfg)","")
+	source ${PYTHON_VENV}/bin/activate; scripts/check.py format main
+else
 	scripts/check.py format main
+endif
 
-header-fix:				#: Fix license header issues in the current branch
+header-fix:			#: Fix license header issues in the current branch
+ifneq ("$(wildcard ${PYTHON_VENV}/pyvenv.cfg)","")
+	source ${PYTHON_VENV}/bin/activate; scripts/check.py header main --fix
+else
 	scripts/check.py header main --fix
+endif
 
 header-check:			#: Check for license header issues on the main branch
+ifneq ("$(wildcard ${PYTHON_VENV}/pyvenv.cfg)","")
+	source ${PYTHON_VENV}/bin/activate; scripts/check.py header main
+else
 	scripts/check.py header main
+endif
 
 circleci-container:			#: Build the linux container for CircleCi
 	$(MAKE) linux-container CONTAINER_NAME=circleci
@@ -147,9 +205,6 @@ circleci-container:			#: Build the linux container for CircleCi
 check-container:
 	$(MAKE) linux-container CONTAINER_NAME=check
 
-velox-torcharrow-container:
-	$(MAKE) linux-container CONTAINER_NAME=velox-torcharrow
-
 linux-container:
 	rm -rf /tmp/docker && \
 	mkdir -p /tmp/docker && \
@@ -166,8 +221,8 @@ python-clean:
 	DEBUG=1 ${PYTHON_EXECUTABLE} setup.py clean
 
 python-build:
-	DEBUG=1 CMAKE_BUILD_PARALLEL_LEVEL=4 ${PYTHON_EXECUTABLE} -m pip install -e .$(extras) --verbose
+	DEBUG=1 CMAKE_BUILD_PARALLEL_LEVEL=${NUM_THREADS} ${PYTHON_EXECUTABLE} -m pip install -e .$(extras) --verbose
 
-python-test: 
+python-test:
 	$(MAKE) python-build extras="[tests]"
 	DEBUG=1 ${PYTHON_EXECUTABLE} -m unittest -v
diff --git a/NOTICE.txt b/NOTICE.txt
new file mode 100644
index 0000000000000..58655beb3ca76
--- /dev/null
+++ b/NOTICE.txt
@@ -0,0 +1,11 @@
+The Velox Project
+Copyright © 2024 Meta Platforms, Inc.
+
+This product includes software from the The gRPC project (Apache 2.0).
+* https://github.com/grpc/grpc/blob/v1.64.2/cmake/re2.cmake
+
+This product includes software from the QT project (BSD, 3-clause).
+* https://github.com/qt/qtbase/blob/6.6.3/cmake/FindWrapSystemDoubleConversion.cmake
+
+This product includes software from HowardHinnant's date library (MIT License).
+* https://github.com/HowardHinnant/date/tree/master
diff --git a/README.md b/README.md
index 03ff41fefef81..20d55392a2f99 100644
--- a/README.md
+++ b/README.md
@@ -4,8 +4,8 @@ Velox is a C++ database acceleration library which provides reusable,
 extensible, and high-performance data processing components. These components
 can be reused to build compute engines focused on different analytical
 workloads, including batch, interactive, stream processing, and AI/ML.
-Velox was created by Facebook and it is currently developed in partnership with
-Intel, ByteDance, and Ahana.
+Velox was created by Meta and it is currently developed in partnership with
+IBM/Ahana, Intel, Voltron Data, Microsoft, ByteDance and many other companies.
 
 In common usage scenarios, Velox takes a fully optimized query plan as input
 and performs the described computation. Considering Velox does not provide a
@@ -70,50 +70,95 @@ Blog posts are available [here](https://velox-lib.io/blog).
 
 ## Getting Started
 
-We provide scripts to help developers setup and install Velox dependencies.
-
 ### Get the Velox Source
 ```
-git clone --recursive https://github.com/facebookincubator/velox.git
+git clone https://github.com/facebookincubator/velox.git
 cd velox
-# if you are updating an existing checkout
-git submodule sync --recursive
-git submodule update --init --recursive
 ```
+Once Velox is checked out, the first step is to install the dependencies.
+Details on the dependencies and how Velox manages some of them for you
+[can be found here](CMake/resolve_dependency_modules/README.md).
+
+Velox also provides the following scripts to help developers setup and install Velox
+dependencies for a given platform.
+
+### Setting up dependencies
+
+The following setup scripts use the `DEPENDENCY_DIR` environment variable to set the
+location to download and build packages. This defaults to `deps-download` in the current
+working directory.
+
+Use `INSTALL_PREFIX` to set the install directory of the packages. This defaults to
+`deps-install` in the current working directory on macOS and to the default install
+location (eg. `/usr/local`) on linux.
+Using the default install location `/usr/local` on macOS is discouraged since this
+location is used by certain Homebrew versions.
+
+Manually add the `INSTALL_PREFIX` value in the IDE or bash environment,
+say `export INSTALL_PREFIX=/Users/$USERNAME/velox/deps-install` to `~/.zshrc` so that
+subsequent Velox builds can use the installed packages.
+
+*You can reuse `DEPENDENCY_INSTALL` and `INSTALL_PREFIX` for Velox clients such as Prestissimo
+by specifying a common shared directory.`*
 
 ### Setting up on macOS
 
-Once you have checked out Velox, on an Intel MacOS machine you can setup and then build like so:
+On a macOS machine (either Intel or Apple silicon) you can setup and then build like so:
 
 ```shell
-$ ./scripts/setup-macos.sh 
+$ ./scripts/setup-macos.sh
 $ make
 ```
 
-On an M1 MacOS machine you can build like so:
+With macOS 14.4 and XCode 15.3 where `m4` is missing, you can either
+1. install `m4` via `brew`:
+```shell
+$ brew install m4
+$ export PATH=/opt/homebrew/opt/m4/bin:$PATH
+```
 
+2. or use `gm4` instead:
 ```shell
-$ CPU_TARGET="arm64" ./scripts/setup-macos.sh
-$ CPU_TARGET="arm64" make
+$ M4=/usr/bin/gm4 make
 ```
 
-You can also produce intel binaries on an M1, use `CPU_TARGET="sse"` for the above.
+### Setting up on Ubuntu (20.04 or later)
 
-### Setting up on aarch64 Linux (Ubuntu 20.04 or later)
+The supported architectures are x86_64 (avx, sse), and AArch64 (apple-m1+crc, neoverse-n1).
+You can build like so:
 
-On an aarch64 based machine, you can build like so:
+```shell
+$ ./scripts/setup-ubuntu.sh
+$ make
+```
+
+### Setting up on Centos 9 Stream with adapters
+
+Velox adapters include file-systems such as AWS S3, Google Cloud Storage,
+and Azure Blob File System. These adapters require installation of additional
+libraries. Once you have checked out Velox, you can setup and build like so:
 
 ```shell
-$ CPU_TARGET="aarch64" ./scripts/setup-ubuntu.sh
-$ CPU_TARGET="aarch64" make
+$ ./scripts/setup-centos9.sh
+$ ./scripts/setup-adapters.sh
+$ make
 ```
 
-### Setting up on x86_64 Linux (Ubuntu 20.04 or later)
+Note that `setup-adapters.sh` supports macOS and Ubuntu 20.04 or later.
+
+### Using Clang on Linux
 
-Once you have checked out Velox, you can setup and build like so:
+Clang 15 can be additionally installed during the setup step for Ubuntu 22.04/24.04
+and CentOS 9 by setting the `USE_CLANG` environment variable prior to running the platform specific setup script.
+```shell
+$ export USE_CLANG=true
+```
+This will install and use Clang 15 to build the dependencies instead of using the default GCC compiler.
 
+Once completed, and before running any `make` command, set the compiler to be used:
 ```shell
-$ ./scripts/setup-ubuntu.sh 
+$ export CC=/usr/bin/clang-15
+$ export CXX=/usr/bin/clang++-15
 $ make
 ```
 
@@ -124,20 +169,22 @@ Run `make` in the root directory to compile the sources. For development, use
 an optimized version.  Use `make unittest` to build and run tests.
 
 Note that,
-* Velox requires C++17 , thus minimum supported compiler is GCC 5.0 and Clang 5.0.
+* Velox requires a compiler at the minimum GCC 11.0 or Clang 15.0.
 * Velox requires the CPU to support instruction sets:
   * bmi
   * bmi2
   * f16c
 * Velox tries to use the following (or equivalent) instruction sets where available:
   * On Intel CPUs
-    * avx  
+    * avx
     * avx2
     * sse
   * On ARM
     * Neon
     * Neon64
 
+Build metrics for Velox are published at <https://facebookincubator.github.io/velox/bm-report/>
+
 ### Building Velox with docker-compose
 
 If you don't want to install the system dependencies required to build Velox,
@@ -162,11 +209,15 @@ contribute to the project.
 
 ## Community
 
+Velox's technical governance mechanics is described [in this
+document.](https://velox-lib.io/docs/community/technical-governance).
+Components and maintainers [are listed
+here](https://velox-lib.io/docs/community/components-and-maintainers).
+
 The main communication channel with the Velox OSS community is through the
-[the Velox-OSS Slack workspace](http://velox-oss.slack.com). 
+[the Velox-OSS Slack workspace](http://velox-oss.slack.com).
 Please reach out to **velox@meta.com** to get access to Velox Slack Channel.
 
-
 ## License
 
 Velox is licensed under the Apache 2.0 License. A copy of the license
diff --git a/build/deps/github_hashes/facebook/folly-rev.txt b/build/deps/github_hashes/facebook/folly-rev.txt
deleted file mode 100644
index 890b8aa6943c5..0000000000000
--- a/build/deps/github_hashes/facebook/folly-rev.txt
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 338aee2892ad2d4f480776a01f900c1b366e84df
diff --git a/build/fbcode_builder/.gitignore b/build/fbcode_builder/.gitignore
deleted file mode 100644
index b98f3edfa6f9b..0000000000000
--- a/build/fbcode_builder/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-# Facebook-internal CI builds don't have write permission outside of the
-# source tree, so we install all projects into this directory.
-/facebook_ci
-__pycache__/
-*.pyc
diff --git a/build/fbcode_builder/CMake/FBBuildOptions.cmake b/build/fbcode_builder/CMake/FBBuildOptions.cmake
deleted file mode 100644
index dbaa29933a05b..0000000000000
--- a/build/fbcode_builder/CMake/FBBuildOptions.cmake
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-function (fb_activate_static_library_option)
-  option(USE_STATIC_DEPS_ON_UNIX
-    "If enabled, use static dependencies on unix systems. This is generally discouraged."
-    OFF
-  )
-  # Mark USE_STATIC_DEPS_ON_UNIX as an "advanced" option, since enabling it
-  # is generally discouraged.
-  mark_as_advanced(USE_STATIC_DEPS_ON_UNIX)
-
-  if(UNIX AND USE_STATIC_DEPS_ON_UNIX)
-    SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a" PARENT_SCOPE)
-  endif()
-endfunction()
diff --git a/build/fbcode_builder/CMake/FBCMakeParseArgs.cmake b/build/fbcode_builder/CMake/FBCMakeParseArgs.cmake
deleted file mode 100644
index 933180189d076..0000000000000
--- a/build/fbcode_builder/CMake/FBCMakeParseArgs.cmake
+++ /dev/null
@@ -1,141 +0,0 @@
-#
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Helper function for parsing arguments to a CMake function.
-#
-# This function is very similar to CMake's built-in cmake_parse_arguments()
-# function, with some improvements:
-# - This function correctly handles empty arguments.  (cmake_parse_arguments()
-#   ignores empty arguments.)
-# - If a multi-value argument is specified more than once, the subsequent
-#   arguments are appended to the original list rather than replacing it.  e.g.
-#   if "SOURCES" is a multi-value argument, and the argument list contains
-#   "SOURCES a b c SOURCES x y z" then the resulting value for SOURCES will be
-#   "a;b;c;x;y;z" rather than "x;y;z"
-# - This function errors out by default on unrecognized arguments.  You can
-#   pass in an extra "ALLOW_UNPARSED_ARGS" argument to make it behave like
-#   cmake_parse_arguments(), and return the unparsed arguments in a
-#   <prefix>_UNPARSED_ARGUMENTS variable instead.
-#
-# It does look like cmake_parse_arguments() handled empty arguments correctly
-# from CMake 3.0 through 3.3, but it seems like this was probably broken when
-# it was turned into a built-in function in CMake 3.4.  Here is discussion and
-# patches that fixed this behavior prior to CMake 3.0:
-# https://cmake.org/pipermail/cmake-developers/2013-November/020607.html
-#
-# The one downside to this function over the built-in cmake_parse_arguments()
-# is that I don't think we can achieve the PARSE_ARGV behavior in a non-builtin
-# function, so we can't properly handle arguments that contain ";".  CMake will
-# treat the ";" characters as list element separators, and treat it as multiple
-# separate arguments.
-#
-function(fb_cmake_parse_args PREFIX OPTIONS ONE_VALUE_ARGS MULTI_VALUE_ARGS ARGS)
-  foreach(option IN LISTS ARGN)
-    if ("${option}" STREQUAL "ALLOW_UNPARSED_ARGS")
-      set(ALLOW_UNPARSED_ARGS TRUE)
-    else()
-      message(
-        FATAL_ERROR
-        "unknown optional argument for fb_cmake_parse_args(): ${option}"
-      )
-    endif()
-  endforeach()
-
-  # Define all options as FALSE in the parent scope to start with
-  foreach(var_name IN LISTS OPTIONS)
-    set("${PREFIX}_${var_name}" "FALSE" PARENT_SCOPE)
-  endforeach()
-
-  # TODO: We aren't extremely strict about error checking for one-value
-  # arguments here.  e.g., we don't complain if a one-value argument is
-  # followed by another option/one-value/multi-value name rather than an
-  # argument.  We also don't complain if a one-value argument is the last
-  # argument and isn't followed by a value.
-
-  list(APPEND all_args ${ONE_VALUE_ARGS})
-  list(APPEND all_args ${MULTI_VALUE_ARGS})
-  set(current_variable)
-  set(unparsed_args)
-  foreach(arg IN LISTS ARGS)
-    list(FIND OPTIONS "${arg}" opt_index)
-    if("${opt_index}" EQUAL -1)
-      list(FIND all_args "${arg}" arg_index)
-      if("${arg_index}" EQUAL -1)
-        # This argument does not match an argument name,
-        # must be an argument value
-        if("${current_variable}" STREQUAL "")
-          list(APPEND unparsed_args "${arg}")
-        else()
-          # Ugh, CMake lists have a pretty fundamental flaw: they cannot
-          # distinguish between an empty list and a list with a single empty
-          # element.  We track our own SEEN_VALUES_arg setting to help
-          # distinguish this and behave properly here.
-          if ("${SEEN_${current_variable}}" AND "${${current_variable}}" STREQUAL "")
-            set("${current_variable}" ";${arg}")
-          else()
-            list(APPEND "${current_variable}" "${arg}")
-          endif()
-          set("SEEN_${current_variable}" TRUE)
-        endif()
-      else()
-        # We found a single- or multi-value argument name
-        set(current_variable "VALUES_${arg}")
-        set("SEEN_${arg}" TRUE)
-      endif()
-    else()
-      # We found an option variable
-      set("${PREFIX}_${arg}" "TRUE" PARENT_SCOPE)
-      set(current_variable)
-    endif()
-  endforeach()
-
-  foreach(arg_name IN LISTS ONE_VALUE_ARGS)
-    if(NOT "${SEEN_${arg_name}}")
-      unset("${PREFIX}_${arg_name}" PARENT_SCOPE)
-    elseif(NOT "${SEEN_VALUES_${arg_name}}")
-      # If the argument was seen but a value wasn't specified, error out.
-      # We require exactly one value to be specified.
-      message(
-        FATAL_ERROR "argument ${arg_name} was specified without a value"
-      )
-    else()
-      list(LENGTH "VALUES_${arg_name}" num_args)
-      if("${num_args}" EQUAL 0)
-        # We know an argument was specified and that we called list(APPEND).
-        # If CMake thinks the list is empty that means there is really a single
-        # empty element in the list.
-        set("${PREFIX}_${arg_name}" "" PARENT_SCOPE)
-      elseif("${num_args}" EQUAL 1)
-        list(GET "VALUES_${arg_name}" 0 arg_value)
-        set("${PREFIX}_${arg_name}" "${arg_value}" PARENT_SCOPE)
-      else()
-        message(
-          FATAL_ERROR "too many arguments specified for ${arg_name}: "
-          "${VALUES_${arg_name}}"
-        )
-      endif()
-    endif()
-  endforeach()
-
-  foreach(arg_name IN LISTS MULTI_VALUE_ARGS)
-    # If this argument name was never seen, then unset the parent scope
-    if (NOT "${SEEN_${arg_name}}")
-      unset("${PREFIX}_${arg_name}" PARENT_SCOPE)
-    else()
-      # TODO: Our caller still won't be able to distinguish between an empty
-      # list and a list with a single empty element.  We can tell which is
-      # which, but CMake lists don't make it easy to show this to our caller.
-      set("${PREFIX}_${arg_name}" "${VALUES_${arg_name}}" PARENT_SCOPE)
-    endif()
-  endforeach()
-
-  # By default we fatal out on unparsed arguments, but return them to the
-  # caller if ALLOW_UNPARSED_ARGS was specified.
-  if (DEFINED unparsed_args)
-    if ("${ALLOW_UNPARSED_ARGS}")
-      set("${PREFIX}_UNPARSED_ARGUMENTS" "${unparsed_args}" PARENT_SCOPE)
-    else()
-      message(FATAL_ERROR "unrecognized arguments: ${unparsed_args}")
-    endif()
-  endif()
-endfunction()
diff --git a/build/fbcode_builder/CMake/FBCompilerSettings.cmake b/build/fbcode_builder/CMake/FBCompilerSettings.cmake
deleted file mode 100644
index 585c953203c8f..0000000000000
--- a/build/fbcode_builder/CMake/FBCompilerSettings.cmake
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-# This file applies common compiler settings that are shared across
-# a number of Facebook opensource projects.
-# Please use caution and your best judgement before making changes
-# to these shared compiler settings in order to avoid accidentally
-# breaking a build in another project!
-
-if (WIN32)
-  include(FBCompilerSettingsMSVC)
-else()
-  include(FBCompilerSettingsUnix)
-endif()
diff --git a/build/fbcode_builder/CMake/FBCompilerSettingsMSVC.cmake b/build/fbcode_builder/CMake/FBCompilerSettingsMSVC.cmake
deleted file mode 100644
index 4efd7e9668f08..0000000000000
--- a/build/fbcode_builder/CMake/FBCompilerSettingsMSVC.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-# This file applies common compiler settings that are shared across
-# a number of Facebook opensource projects.
-# Please use caution and your best judgement before making changes
-# to these shared compiler settings in order to avoid accidentally
-# breaking a build in another project!
-
-add_compile_options(
-  /wd4250 # 'class1' : inherits 'class2::member' via dominance
-)
diff --git a/build/fbcode_builder/CMake/FBCompilerSettingsUnix.cmake b/build/fbcode_builder/CMake/FBCompilerSettingsUnix.cmake
deleted file mode 100644
index c26ce78b1d20e..0000000000000
--- a/build/fbcode_builder/CMake/FBCompilerSettingsUnix.cmake
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-# This file applies common compiler settings that are shared across
-# a number of Facebook opensource projects.
-# Please use caution and your best judgement before making changes
-# to these shared compiler settings in order to avoid accidentally
-# breaking a build in another project!
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -Wno-deprecated -Wno-deprecated-declarations")
diff --git a/build/fbcode_builder/CMake/FBPythonBinary.cmake b/build/fbcode_builder/CMake/FBPythonBinary.cmake
deleted file mode 100644
index f91ebaf326452..0000000000000
--- a/build/fbcode_builder/CMake/FBPythonBinary.cmake
+++ /dev/null
@@ -1,697 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-include(FBCMakeParseArgs)
-
-#
-# This file contains helper functions for building self-executing Python
-# binaries.
-#
-# This is somewhat different than typical python installation with
-# distutils/pip/virtualenv/etc.  We primarily want to build a standalone
-# executable, isolated from other Python packages on the system.  We don't want
-# to install files into the standard library python paths.  This is more
-# similar to PEX (https://github.com/pantsbuild/pex) and XAR
-# (https://github.com/facebookincubator/xar).  (In the future it would be nice
-# to update this code to also support directly generating XAR files if XAR is
-# available.)
-#
-# We also want to be able to easily define "libraries" of python files that can
-# be shared and re-used between these standalone python executables, and can be
-# shared across projects in different repositories.  This means that we do need
-# a way to "install" libraries so that they are visible to CMake builds in
-# other repositories, without actually installing them in the standard python
-# library paths.
-#
-
-# If the caller has not already found Python, do so now.
-# If we fail to find python now we won't fail immediately, but
-# add_fb_python_executable() or add_fb_python_library() will fatal out if they
-# are used.
-if(NOT TARGET Python3::Interpreter)
-  # CMake 3.12+ ships with a FindPython3.cmake module.  Try using it first.
-  # We find with QUIET here, since otherwise this generates some noisy warnings
-  # on versions of CMake before 3.12
-  if (WIN32)
-    # On Windows we need both the Interpreter as well as the Development
-    # libraries.
-    find_package(Python3 COMPONENTS Interpreter Development QUIET)
-  else()
-    find_package(Python3 COMPONENTS Interpreter QUIET)
-  endif()
-  if(Python3_Interpreter_FOUND)
-    message(STATUS "Found Python 3: ${Python3_EXECUTABLE}")
-  else()
-    # Try with the FindPythonInterp.cmake module available in older CMake
-    # versions.  Check to see if the caller has already searched for this
-    # themselves first.
-    if(NOT PYTHONINTERP_FOUND)
-      set(Python_ADDITIONAL_VERSIONS 3 3.6 3.5 3.4 3.3 3.2 3.1)
-      find_package(PythonInterp)
-      # TODO: On Windows we require the Python libraries as well.
-      # We currently do not search for them on this code path.
-      # For now we require building with CMake 3.12+ on Windows, so that the
-      # FindPython3 code path above is available.
-    endif()
-    if(PYTHONINTERP_FOUND)
-      if("${PYTHON_VERSION_MAJOR}" GREATER_EQUAL 3)
-        set(Python3_EXECUTABLE "${PYTHON_EXECUTABLE}")
-        add_custom_target(Python3::Interpreter)
-      else()
-        string(
-          CONCAT FBPY_FIND_PYTHON_ERR
-          "found Python ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}, "
-          "but need Python 3"
-        )
-      endif()
-    endif()
-  endif()
-endif()
-
-# Find our helper program.
-# We typically install this in the same directory as this .cmake file.
-find_program(
-  FB_MAKE_PYTHON_ARCHIVE "make_fbpy_archive.py"
-  PATHS ${CMAKE_MODULE_PATH}
-)
-set(FB_PY_TEST_MAIN "${CMAKE_CURRENT_LIST_DIR}/fb_py_test_main.py")
-set(
-  FB_PY_TEST_DISCOVER_SCRIPT
-  "${CMAKE_CURRENT_LIST_DIR}/FBPythonTestAddTests.cmake"
-)
-set(
-  FB_PY_WIN_MAIN_C
-  "${CMAKE_CURRENT_LIST_DIR}/fb_py_win_main.c"
-)
-
-# An option to control the default installation location for
-# install_fb_python_library().  This is relative to ${CMAKE_INSTALL_PREFIX}
-set(
-  FBPY_LIB_INSTALL_DIR "lib/fb-py-libs" CACHE STRING
-  "The subdirectory where FB python libraries should be installed"
-)
-
-#
-# Build a self-executing python binary.
-#
-# This accepts the same arguments as add_fb_python_library().
-#
-# In addition, a MAIN_MODULE argument is accepted.  This argument specifies
-# which module should be started as the __main__ module when the executable is
-# run.  If left unspecified, a __main__.py script must be present in the
-# manifest.
-#
-function(add_fb_python_executable TARGET)
-  fb_py_check_available()
-
-  # Parse the arguments
-  set(one_value_args BASE_DIR NAMESPACE MAIN_MODULE TYPE)
-  set(multi_value_args SOURCES DEPENDS)
-  fb_cmake_parse_args(
-    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
-  )
-  fb_py_process_default_args(ARG_NAMESPACE ARG_BASE_DIR)
-
-  # Use add_fb_python_library() to perform most of our source handling
-  add_fb_python_library(
-    "${TARGET}.main_lib"
-    BASE_DIR "${ARG_BASE_DIR}"
-    NAMESPACE "${ARG_NAMESPACE}"
-    SOURCES ${ARG_SOURCES}
-    DEPENDS ${ARG_DEPENDS}
-  )
-
-  set(
-    manifest_files
-    "$<TARGET_PROPERTY:${TARGET}.main_lib.py_lib,INTERFACE_INCLUDE_DIRECTORIES>"
-  )
-  set(
-    source_files
-    "$<TARGET_PROPERTY:${TARGET}.main_lib.py_lib,INTERFACE_SOURCES>"
-  )
-
-  # The command to build the executable archive.
-  #
-  # If we are using CMake 3.8+ we can use COMMAND_EXPAND_LISTS.
-  # CMP0067 isn't really the policy we care about, but seems like the best way
-  # to check if we are running 3.8+.
-  if (POLICY CMP0067)
-    set(extra_cmd_params COMMAND_EXPAND_LISTS)
-    set(make_py_args "${manifest_files}")
-  else()
-    set(extra_cmd_params)
-    set(make_py_args --manifest-separator "::" "$<JOIN:${manifest_files},::>")
-  endif()
-
-  set(output_file "${TARGET}${CMAKE_EXECUTABLE_SUFFIX}")
-  if(WIN32)
-    set(zipapp_output "${TARGET}.py_zipapp")
-  else()
-    set(zipapp_output "${output_file}")
-  endif()
-  set(zipapp_output_file "${zipapp_output}")
-
-  set(is_dir_output FALSE)
-  if(DEFINED ARG_TYPE)
-    list(APPEND make_py_args "--type" "${ARG_TYPE}")
-    if ("${ARG_TYPE}" STREQUAL "dir")
-      set(is_dir_output TRUE)
-      # CMake doesn't really seem to like having a directory specified as an
-      # output; specify the __main__.py file as the output instead.
-      set(zipapp_output_file "${zipapp_output}/__main__.py")
-      list(APPEND
-        extra_cmd_params
-        COMMAND "${CMAKE_COMMAND}" -E remove_directory "${zipapp_output}"
-      )
-    endif()
-  endif()
-
-  if(DEFINED ARG_MAIN_MODULE)
-    list(APPEND make_py_args "--main" "${ARG_MAIN_MODULE}")
-  endif()
-
-  add_custom_command(
-    OUTPUT "${zipapp_output_file}"
-    ${extra_cmd_params}
-    COMMAND
-      "${Python3_EXECUTABLE}" "${FB_MAKE_PYTHON_ARCHIVE}"
-      -o "${zipapp_output}"
-      ${make_py_args}
-    DEPENDS
-      ${source_files}
-      "${TARGET}.main_lib.py_sources_built"
-      "${FB_MAKE_PYTHON_ARCHIVE}"
-  )
-
-  if(WIN32)
-    if(is_dir_output)
-      # TODO: generate a main executable that will invoke Python3
-      # with the correct main module inside the output directory
-    else()
-      add_executable("${TARGET}.winmain" "${FB_PY_WIN_MAIN_C}")
-      target_link_libraries("${TARGET}.winmain" Python3::Python)
-      # The Python3::Python target doesn't seem to be set up completely
-      # correctly on Windows for some reason, and we have to explicitly add
-      # ${Python3_LIBRARY_DIRS} to the target link directories.
-      target_link_directories(
-        "${TARGET}.winmain"
-        PUBLIC ${Python3_LIBRARY_DIRS}
-      )
-      add_custom_command(
-        OUTPUT "${output_file}"
-        DEPENDS "${TARGET}.winmain" "${zipapp_output_file}"
-        COMMAND
-          "cmd.exe" "/c" "copy" "/b"
-          "${TARGET}.winmain${CMAKE_EXECUTABLE_SUFFIX}+${zipapp_output}"
-          "${output_file}"
-      )
-    endif()
-  endif()
-
-  # Add an "ALL" target that depends on force ${TARGET},
-  # so that ${TARGET} will be included in the default list of build targets.
-  add_custom_target("${TARGET}.GEN_PY_EXE" ALL DEPENDS "${output_file}")
-
-  # Allow resolving the executable path for the target that we generate
-  # via a generator expression like:
-  # "WATCHMAN_WAIT_PATH=$<TARGET_PROPERTY:watchman-wait.GEN_PY_EXE,EXECUTABLE>"
-  set_property(TARGET "${TARGET}.GEN_PY_EXE"
-      PROPERTY EXECUTABLE "${CMAKE_CURRENT_BINARY_DIR}/${output_file}")
-endfunction()
-
-# Define a python unittest executable.
-# The executable is built using add_fb_python_executable and has the
-# following differences:
-#
-# Each of the source files specified in SOURCES will be imported
-# and have unittest discovery performed upon them.
-# Those sources will be imported in the top level namespace.
-#
-# The ENV argument allows specifying a list of "KEY=VALUE"
-# pairs that will be used by the test runner to set up the environment
-# in the child process prior to running the test.  This is useful for
-# passing additional configuration to the test.
-function(add_fb_python_unittest TARGET)
-  # Parse the arguments
-  set(multi_value_args SOURCES DEPENDS ENV PROPERTIES)
-  set(
-    one_value_args
-    WORKING_DIRECTORY BASE_DIR NAMESPACE TEST_LIST DISCOVERY_TIMEOUT
-  )
-  fb_cmake_parse_args(
-    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
-  )
-  fb_py_process_default_args(ARG_NAMESPACE ARG_BASE_DIR)
-  if(NOT ARG_WORKING_DIRECTORY)
-    # Default the working directory to the current binary directory.
-    # This matches the default behavior of add_test() and other standard
-    # test functions like gtest_discover_tests()
-    set(ARG_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-  endif()
-  if(NOT ARG_TEST_LIST)
-    set(ARG_TEST_LIST "${TARGET}_TESTS")
-  endif()
-  if(NOT ARG_DISCOVERY_TIMEOUT)
-    set(ARG_DISCOVERY_TIMEOUT 5)
-  endif()
-
-  # Tell our test program the list of modules to scan for tests.
-  # We scan all modules directly listed in our SOURCES argument, and skip
-  # modules that came from dependencies in the DEPENDS list.
-  #
-  # This is written into a __test_modules__.py module that the test runner
-  # will look at.
-  set(
-    test_modules_path
-    "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_test_modules.py"
-  )
-  file(WRITE "${test_modules_path}" "TEST_MODULES = [\n")
-  string(REPLACE "." "/" namespace_dir "${ARG_NAMESPACE}")
-  if (NOT "${namespace_dir}" STREQUAL "")
-    set(namespace_dir "${namespace_dir}/")
-  endif()
-  set(test_modules)
-  foreach(src_path IN LISTS ARG_SOURCES)
-    fb_py_compute_dest_path(
-      abs_source dest_path
-      "${src_path}" "${namespace_dir}" "${ARG_BASE_DIR}"
-    )
-    string(REPLACE "/" "." module_name "${dest_path}")
-    string(REGEX REPLACE "\\.py$" "" module_name "${module_name}")
-    list(APPEND test_modules "${module_name}")
-    file(APPEND "${test_modules_path}" "  '${module_name}',\n")
-  endforeach()
-  file(APPEND "${test_modules_path}" "]\n")
-
-  # The __main__ is provided by our runner wrapper/bootstrap
-  list(APPEND ARG_SOURCES "${FB_PY_TEST_MAIN}=__main__.py")
-  list(APPEND ARG_SOURCES "${test_modules_path}=__test_modules__.py")
-
-  add_fb_python_executable(
-    "${TARGET}"
-    NAMESPACE "${ARG_NAMESPACE}"
-    BASE_DIR "${ARG_BASE_DIR}"
-    SOURCES ${ARG_SOURCES}
-    DEPENDS ${ARG_DEPENDS}
-  )
-
-  # Run test discovery after the test executable is built.
-  # This logic is based on the code for gtest_discover_tests()
-  set(ctest_file_base "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}")
-  set(ctest_include_file "${ctest_file_base}_include.cmake")
-  set(ctest_tests_file "${ctest_file_base}_tests.cmake")
-  add_custom_command(
-    TARGET "${TARGET}.GEN_PY_EXE" POST_BUILD
-    BYPRODUCTS "${ctest_tests_file}"
-    COMMAND
-      "${CMAKE_COMMAND}"
-      -D "TEST_TARGET=${TARGET}"
-      -D "TEST_INTERPRETER=${Python3_EXECUTABLE}"
-      -D "TEST_ENV=${ARG_ENV}"
-      -D "TEST_EXECUTABLE=$<TARGET_PROPERTY:${TARGET}.GEN_PY_EXE,EXECUTABLE>"
-      -D "TEST_WORKING_DIR=${ARG_WORKING_DIRECTORY}"
-      -D "TEST_LIST=${ARG_TEST_LIST}"
-      -D "TEST_PREFIX=${TARGET}::"
-      -D "TEST_PROPERTIES=${ARG_PROPERTIES}"
-      -D "CTEST_FILE=${ctest_tests_file}"
-      -P "${FB_PY_TEST_DISCOVER_SCRIPT}"
-    VERBATIM
-  )
-
-  file(
-    WRITE "${ctest_include_file}"
-    "if(EXISTS \"${ctest_tests_file}\")\n"
-    "  include(\"${ctest_tests_file}\")\n"
-    "else()\n"
-    "  add_test(\"${TARGET}_NOT_BUILT\" \"${TARGET}_NOT_BUILT\")\n"
-    "endif()\n"
-  )
-  set_property(
-    DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES
-    "${ctest_include_file}"
-  )
-endfunction()
-
-#
-# Define a python library.
-#
-# If you want to install a python library generated from this rule note that
-# you need to use install_fb_python_library() rather than CMake's built-in
-# install() function.  This will make it available for other downstream
-# projects to use in their add_fb_python_executable() and
-# add_fb_python_library() calls.  (You do still need to use `install(EXPORT)`
-# later to install the CMake exports.)
-#
-# Parameters:
-# - BASE_DIR <dir>:
-#   The base directory path to strip off from each source path.  All source
-#   files must be inside this directory.  If not specified it defaults to
-#   ${CMAKE_CURRENT_SOURCE_DIR}.
-# - NAMESPACE <namespace>:
-#   The destination namespace where these files should be installed in python
-#   binaries.  If not specified, this defaults to the current relative path of
-#   ${CMAKE_CURRENT_SOURCE_DIR} inside ${CMAKE_SOURCE_DIR}.  e.g., a python
-#   library defined in the directory repo_root/foo/bar will use a default
-#   namespace of "foo.bar"
-# - SOURCES <src1> <...>:
-#   The python source files.
-#   You may optionally specify as source using the form: PATH=ALIAS where
-#   PATH is a relative path in the source tree and ALIAS is the relative
-#   path into which PATH should be rewritten.  This is useful for mapping
-#   an executable script to the main module in a python executable.
-#   e.g.: `python/bin/watchman-wait=__main__.py`
-# - DEPENDS <target1> <...>:
-#   Other python libraries that this one depends on.
-# - INSTALL_DIR <dir>:
-#   The directory where this library should be installed.
-#   install_fb_python_library() must still be called later to perform the
-#   installation.  If a relative path is given it will be treated relative to
-#   ${CMAKE_INSTALL_PREFIX}
-#
-# CMake is unfortunately pretty crappy at being able to define custom build
-# rules & behaviors.  It doesn't support transitive property propagation
-# between custom targets; only the built-in add_executable() and add_library()
-# targets support transitive properties.
-#
-# We hack around this janky CMake behavior by (ab)using interface libraries to
-# propagate some of the data we want between targets, without actually
-# generating a C library.
-#
-# add_fb_python_library(SOMELIB) generates the following things:
-# - An INTERFACE library rule named SOMELIB.py_lib which tracks some
-#   information about transitive dependencies:
-#   - the transitive set of source files in the INTERFACE_SOURCES property
-#   - the transitive set of manifest files that this library depends on in
-#     the INTERFACE_INCLUDE_DIRECTORIES property.
-# - A custom command that generates a SOMELIB.manifest file.
-#   This file contains the mapping of source files to desired destination
-#   locations in executables that depend on this library.  This manifest file
-#   will then be read at build-time in order to build executables.
-#
-function(add_fb_python_library LIB_NAME)
-  fb_py_check_available()
-
-  # Parse the arguments
-  # We use fb_cmake_parse_args() rather than cmake_parse_arguments() since
-  # cmake_parse_arguments() does not handle empty arguments, and it is common
-  # for callers to want to specify an empty NAMESPACE parameter.
-  set(one_value_args BASE_DIR NAMESPACE INSTALL_DIR)
-  set(multi_value_args SOURCES DEPENDS)
-  fb_cmake_parse_args(
-    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
-  )
-  fb_py_process_default_args(ARG_NAMESPACE ARG_BASE_DIR)
-
-  string(REPLACE "." "/" namespace_dir "${ARG_NAMESPACE}")
-  if (NOT "${namespace_dir}" STREQUAL "")
-    set(namespace_dir "${namespace_dir}/")
-  endif()
-
-  if(NOT DEFINED ARG_INSTALL_DIR)
-    set(install_dir "${FBPY_LIB_INSTALL_DIR}/")
-  elseif("${ARG_INSTALL_DIR}" STREQUAL "")
-    set(install_dir "")
-  else()
-    set(install_dir "${ARG_INSTALL_DIR}/")
-  endif()
-
-  # message(STATUS "fb py library ${LIB_NAME}: "
-  #         "NS=${namespace_dir} BASE=${ARG_BASE_DIR}")
-
-  # TODO: In the future it would be nice to support pre-compiling the source
-  # files.  We could emit a rule to compile each source file and emit a
-  # .pyc/.pyo file here, and then have the manifest reference the pyc/pyo
-  # files.
-
-  # Define a library target to help pass around information about the library,
-  # and propagate dependency information.
-  #
-  # CMake make a lot of assumptions that libraries are C++ libraries.  To help
-  # avoid confusion we name our target "${LIB_NAME}.py_lib" rather than just
-  # "${LIB_NAME}".  This helps avoid confusion if callers try to use
-  # "${LIB_NAME}" on their own as a target name.  (e.g., attempting to install
-  # it directly with install(TARGETS) won't work.  Callers must use
-  # install_fb_python_library() instead.)
-  add_library("${LIB_NAME}.py_lib" INTERFACE)
-
-  # Emit the manifest file.
-  #
-  # We write the manifest file to a temporary path first, then copy it with
-  # configure_file(COPYONLY).  This is necessary to get CMake to understand
-  # that "${manifest_path}" is generated by the CMake configure phase,
-  # and allow using it as a dependency for add_custom_command().
-  # (https://gitlab.kitware.com/cmake/cmake/issues/16367)
-  set(manifest_path "${CMAKE_CURRENT_BINARY_DIR}/${LIB_NAME}.manifest") 
-  set(tmp_manifest "${manifest_path}.tmp")
-  file(WRITE "${tmp_manifest}" "FBPY_MANIFEST 1\n")
-  set(abs_sources)
-  foreach(src_path IN LISTS ARG_SOURCES)
-    fb_py_compute_dest_path(
-      abs_source dest_path
-      "${src_path}" "${namespace_dir}" "${ARG_BASE_DIR}"
-    )
-    list(APPEND abs_sources "${abs_source}")
-    target_sources(
-      "${LIB_NAME}.py_lib" INTERFACE
-      "$<BUILD_INTERFACE:${abs_source}>"
-      "$<INSTALL_INTERFACE:${install_dir}${LIB_NAME}/${dest_path}>"
-    )
-    file(
-      APPEND "${tmp_manifest}"
-      "${abs_source} :: ${dest_path}\n"
-    )
-  endforeach()
-  configure_file("${tmp_manifest}" "${manifest_path}" COPYONLY)
-
-  target_include_directories(
-    "${LIB_NAME}.py_lib" INTERFACE
-    "$<BUILD_INTERFACE:${manifest_path}>"
-    "$<INSTALL_INTERFACE:${install_dir}${LIB_NAME}.manifest>"
-  )
-
-  # Add a target that depends on all of the source files.
-  # This is needed in case some of the source files are generated.  This will
-  # ensure that these source files are brought up-to-date before we build
-  # any python binaries that depend on this library.
-  add_custom_target("${LIB_NAME}.py_sources_built" DEPENDS ${abs_sources})
-  add_dependencies("${LIB_NAME}.py_lib" "${LIB_NAME}.py_sources_built")
-
-  # Hook up library dependencies, and also make the *.py_sources_built target
-  # depend on the sources for all of our dependencies also being up-to-date.
-  foreach(dep IN LISTS ARG_DEPENDS)
-    target_link_libraries("${LIB_NAME}.py_lib" INTERFACE "${dep}.py_lib")
-
-    # Mark that our .py_sources_built target depends on each our our dependent
-    # libraries.  This serves two functions:
-    # - This causes CMake to generate an error message if one of the
-    #   dependencies is never defined.  The target_link_libraries() call above
-    #   won't complain if one of the dependencies doesn't exist (since it is
-    #   intended to allow passing in file names for plain library files rather
-    #   than just targets).
-    # - It ensures that sources for our dependencies are built before any
-    #   executable that depends on us.  Note that we depend on "${dep}.py_lib"
-    #   rather than "${dep}.py_sources_built" for this purpose because the
-    #   ".py_sources_built" target won't be available for imported targets.
-    add_dependencies("${LIB_NAME}.py_sources_built" "${dep}.py_lib")
-  endforeach()
-
-  # Add a custom command to help with library installation, in case
-  # install_fb_python_library() is called later for this library.
-  # add_custom_command() only works with file dependencies defined in the same
-  # CMakeLists.txt file, so we want to make sure this is defined here, rather
-  # then where install_fb_python_library() is called.
-  # This command won't be run by default, but will only be run if it is needed
-  # by a subsequent install_fb_python_library() call.
-  #
-  # This command copies the library contents into the build directory.
-  # It would be nicer if we could skip this intermediate copy, and just run
-  # make_fbpy_archive.py at install time to copy them directly to the desired
-  # installation directory.  Unfortunately this is difficult to do, and seems
-  # to interfere with some of the CMake code that wants to generate a manifest
-  # of installed files.
-  set(build_install_dir "${CMAKE_CURRENT_BINARY_DIR}/${LIB_NAME}.lib_install")
-  add_custom_command(
-    OUTPUT
-      "${build_install_dir}/${LIB_NAME}.manifest"
-    COMMAND "${CMAKE_COMMAND}" -E remove_directory "${build_install_dir}"
-    COMMAND
-      "${Python3_EXECUTABLE}" "${FB_MAKE_PYTHON_ARCHIVE}" --type lib-install
-      --install-dir "${LIB_NAME}"
-      -o "${build_install_dir}/${LIB_NAME}" "${manifest_path}"
-    DEPENDS
-      "${abs_sources}"
-      "${manifest_path}"
-      "${FB_MAKE_PYTHON_ARCHIVE}"
-  )
-  add_custom_target(
-    "${LIB_NAME}.py_lib_install"
-    DEPENDS "${build_install_dir}/${LIB_NAME}.manifest"
-  )
-
-  # Set some properties to pass through the install paths to
-  # install_fb_python_library()
-  #
-  # Passing through ${build_install_dir} allows install_fb_python_library()
-  # to work even if used from a different CMakeLists.txt file than where
-  # add_fb_python_library() was called (i.e. such that
-  # ${CMAKE_CURRENT_BINARY_DIR} is different between the two calls).
-  set(abs_install_dir "${install_dir}")
-  if(NOT IS_ABSOLUTE "${abs_install_dir}")
-    set(abs_install_dir "${CMAKE_INSTALL_PREFIX}/${abs_install_dir}")
-  endif()
-  string(REGEX REPLACE "/$" "" abs_install_dir "${abs_install_dir}")
-  set_target_properties(
-    "${LIB_NAME}.py_lib_install"
-    PROPERTIES
-    INSTALL_DIR "${abs_install_dir}"
-    BUILD_INSTALL_DIR "${build_install_dir}"
-  )
-endfunction()
-
-#
-# Install an FB-style packaged python binary.
-#
-# - DESTINATION <export-name>:
-#   Associate the installed target files with the given export-name.
-#
-function(install_fb_python_executable TARGET)
-  # Parse the arguments
-  set(one_value_args DESTINATION)
-  set(multi_value_args)
-  fb_cmake_parse_args(
-    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
-  )
-
-  if(NOT DEFINED ARG_DESTINATION)
-    set(ARG_DESTINATION bin)
-  endif()
-
-  install(
-    PROGRAMS "$<TARGET_PROPERTY:${TARGET}.GEN_PY_EXE,EXECUTABLE>"
-    DESTINATION "${ARG_DESTINATION}"
-  )
-endfunction()
-
-#
-# Install a python library.
-#
-# - EXPORT <export-name>:
-#   Associate the installed target files with the given export-name.
-#
-# Note that unlike the built-in CMake install() function we do not accept a
-# DESTINATION parameter.  Instead, use the INSTALL_DIR parameter to
-# add_fb_python_library() to set the installation location.
-#
-function(install_fb_python_library LIB_NAME)
-  set(one_value_args EXPORT)
-  fb_cmake_parse_args(ARG "" "${one_value_args}" "" "${ARGN}")
-
-  # Export our "${LIB_NAME}.py_lib" target so that it will be available to
-  # downstream projects in our installed CMake config files.
-  if(DEFINED ARG_EXPORT)
-    install(TARGETS "${LIB_NAME}.py_lib" EXPORT "${ARG_EXPORT}")
-  endif()
-
-  # add_fb_python_library() emits a .py_lib_install target that will prepare
-  # the installation directory.  However, it isn't part of the "ALL" target and
-  # therefore isn't built by default.
-  #
-  # Make sure the ALL target depends on it now.  We have to do this by
-  # introducing yet another custom target.
-  # Add it as a dependency to the ALL target now.
-  add_custom_target("${LIB_NAME}.py_lib_install_all" ALL)
-  add_dependencies(
-    "${LIB_NAME}.py_lib_install_all" "${LIB_NAME}.py_lib_install"
-  )
-
-  # Copy the intermediate install directory generated at build time into
-  # the desired install location.
-  get_target_property(dest_dir "${LIB_NAME}.py_lib_install" "INSTALL_DIR")
-  get_target_property(
-    build_install_dir "${LIB_NAME}.py_lib_install" "BUILD_INSTALL_DIR"
-  )
-  install(
-    DIRECTORY "${build_install_dir}/${LIB_NAME}"
-    DESTINATION "${dest_dir}"
-  )
-  install(
-    FILES "${build_install_dir}/${LIB_NAME}.manifest"
-    DESTINATION "${dest_dir}"
-  )
-endfunction()
-
-# Helper macro to process the BASE_DIR and NAMESPACE arguments for
-# add_fb_python_executable() and add_fb_python_executable()
-macro(fb_py_process_default_args NAMESPACE_VAR BASE_DIR_VAR)
-  # If the namespace was not specified, default to the relative path to the
-  # current directory (starting from the repository root).
-  if(NOT DEFINED "${NAMESPACE_VAR}")
-    file(
-      RELATIVE_PATH "${NAMESPACE_VAR}"
-      "${CMAKE_SOURCE_DIR}"
-      "${CMAKE_CURRENT_SOURCE_DIR}"
-    )
-  endif()
-
-  if(NOT DEFINED "${BASE_DIR_VAR}")
-    # If the base directory was not specified, default to the current directory
-    set("${BASE_DIR_VAR}" "${CMAKE_CURRENT_SOURCE_DIR}")
-  else()
-    # If the base directory was specified, always convert it to an
-    # absolute path.
-    get_filename_component("${BASE_DIR_VAR}" "${${BASE_DIR_VAR}}" ABSOLUTE)
-  endif()
-endmacro()
-
-function(fb_py_check_available)
-  # Make sure that Python 3 and our make_fbpy_archive.py helper script are
-  # available.
-  if(NOT Python3_EXECUTABLE)
-    if(FBPY_FIND_PYTHON_ERR)
-      message(FATAL_ERROR "Unable to find Python 3: ${FBPY_FIND_PYTHON_ERR}")
-    else()
-      message(FATAL_ERROR "Unable to find Python 3")
-    endif()
-  endif()
-
-  if (NOT FB_MAKE_PYTHON_ARCHIVE)
-    message(
-      FATAL_ERROR "unable to find make_fbpy_archive.py helper program (it "
-      "should be located in the same directory as FBPythonBinary.cmake)"
-    )
-  endif()
-endfunction()
-
-function(
-    fb_py_compute_dest_path
-    src_path_output dest_path_output src_path namespace_dir base_dir
-)
-  if("${src_path}" MATCHES "=")
-    # We want to split the string on the `=` sign, but cmake doesn't
-    # provide much in the way of helpers for this, so we rewrite the
-    # `=` sign to `;` so that we can treat it as a cmake list and
-    # then index into the components
-    string(REPLACE "=" ";" src_path_list "${src_path}")
-    list(GET src_path_list 0 src_path)
-    # Note that we ignore the `namespace_dir` in the alias case
-    # in order to allow aliasing a source to the top level `__main__.py`
-    # filename.
-    list(GET src_path_list 1 dest_path)
-  else()
-    unset(dest_path)
-  endif()
-
-  get_filename_component(abs_source "${src_path}" ABSOLUTE)
-  if(NOT DEFINED dest_path)
-    file(RELATIVE_PATH rel_src "${ARG_BASE_DIR}" "${abs_source}")
-    if("${rel_src}" MATCHES "^../")
-      message(
-        FATAL_ERROR "${LIB_NAME}: source file \"${abs_source}\" is not inside "
-        "the base directory ${ARG_BASE_DIR}"
-      )
-    endif()
-    set(dest_path "${namespace_dir}${rel_src}")
-  endif()
-
-  set("${src_path_output}" "${abs_source}" PARENT_SCOPE)
-  set("${dest_path_output}" "${dest_path}" PARENT_SCOPE)
-endfunction()
diff --git a/build/fbcode_builder/CMake/FBPythonTestAddTests.cmake b/build/fbcode_builder/CMake/FBPythonTestAddTests.cmake
deleted file mode 100644
index d73c055d8245a..0000000000000
--- a/build/fbcode_builder/CMake/FBPythonTestAddTests.cmake
+++ /dev/null
@@ -1,59 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-# Add a command to be emitted to the CTest file
-set(ctest_script)
-function(add_command CMD)
-  set(escaped_args "")
-  foreach(arg ${ARGN})
-    # Escape all arguments using "Bracket Argument" syntax
-    # We could skip this for argument that don't contain any special
-    # characters if we wanted to make the output slightly more human-friendly.
-    set(escaped_args "${escaped_args} [==[${arg}]==]")
-  endforeach()
-  set(ctest_script "${ctest_script}${CMD}(${escaped_args})\n" PARENT_SCOPE)
-endfunction()
-
-if(NOT EXISTS "${TEST_EXECUTABLE}")
-  message(FATAL_ERROR "Test executable does not exist: ${TEST_EXECUTABLE}")
-endif()
-execute_process(
-  COMMAND ${CMAKE_COMMAND} -E env ${TEST_ENV} "${TEST_INTERPRETER}" "${TEST_EXECUTABLE}" --list-tests
-  WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-  OUTPUT_VARIABLE output
-  RESULT_VARIABLE result
-)
-if(NOT "${result}" EQUAL 0)
-  string(REPLACE "\n" "\n  " output "${output}")
-  message(
-    FATAL_ERROR
-    "Error running test executable: ${TEST_EXECUTABLE}\n"
-    "Output:\n"
-    "  ${output}\n"
-  )
-endif()
-
-# Parse output
-string(REPLACE "\n" ";" tests_list "${output}")
-foreach(test_name ${tests_list})
-  add_command(
-    add_test
-    "${TEST_PREFIX}${test_name}"
-    ${CMAKE_COMMAND} -E env ${TEST_ENV}
-    "${TEST_INTERPRETER}" "${TEST_EXECUTABLE}" "${test_name}"
-  )
-  add_command(
-    set_tests_properties
-    "${TEST_PREFIX}${test_name}"
-    PROPERTIES
-    WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-    ${TEST_PROPERTIES}
-  )
-endforeach()
-
-# Set a list of discovered tests in the parent scope, in case users
-# want access to this list as a CMake variable
-if(TEST_LIST)
-  add_command(set ${TEST_LIST} ${tests_list})
-endif()
-
-file(WRITE "${CTEST_FILE}" "${ctest_script}")
diff --git a/build/fbcode_builder/CMake/FBThriftCppLibrary.cmake b/build/fbcode_builder/CMake/FBThriftCppLibrary.cmake
deleted file mode 100644
index 7688d80960dfd..0000000000000
--- a/build/fbcode_builder/CMake/FBThriftCppLibrary.cmake
+++ /dev/null
@@ -1,197 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-include(FBCMakeParseArgs)
-
-# Generate a C++ library from a thrift file
-#
-# Parameters:
-# - SERVICES <svc1> [<svc2> ...]
-#   The names of the services defined in the thrift file.
-# - DEPENDS <dep1> [<dep2> ...]
-#   A list of other thrift C++ libraries that this library depends on.
-# - OPTIONS <opt1> [<opt2> ...]
-#   A list of options to pass to the thrift compiler.
-# - INCLUDE_DIR <path>
-#   The sub-directory where generated headers will be installed.
-#   Defaults to "include" if not specified.  The caller must still call
-#   install() to install the thrift library if desired.
-# - THRIFT_INCLUDE_DIR <path>
-#   The sub-directory where generated headers will be installed.
-#   Defaults to "${INCLUDE_DIR}/thrift-files" if not specified.
-#   The caller must still call install() to install the thrift library if
-#   desired.
-function(add_fbthrift_cpp_library LIB_NAME THRIFT_FILE)
-  # Parse the arguments
-  set(one_value_args INCLUDE_DIR THRIFT_INCLUDE_DIR)
-  set(multi_value_args SERVICES DEPENDS OPTIONS)
-  fb_cmake_parse_args(
-    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
-  )
-  if(NOT DEFINED ARG_INCLUDE_DIR)
-    set(ARG_INCLUDE_DIR "include")
-  endif()
-  if(NOT DEFINED ARG_THRIFT_INCLUDE_DIR)
-    set(ARG_THRIFT_INCLUDE_DIR "${ARG_INCLUDE_DIR}/thrift-files")
-  endif()
-
-  get_filename_component(base ${THRIFT_FILE} NAME_WE)
-  get_filename_component(
-    output_dir
-    ${CMAKE_CURRENT_BINARY_DIR}/${THRIFT_FILE}
-    DIRECTORY
-  )
-
-  # Generate relative paths in #includes
-  file(
-    RELATIVE_PATH include_prefix
-    "${CMAKE_SOURCE_DIR}"
-    "${CMAKE_CURRENT_SOURCE_DIR}/${THRIFT_FILE}"
-  )
-  get_filename_component(include_prefix ${include_prefix} DIRECTORY)
-
-  if (NOT "${include_prefix}" STREQUAL "")
-    list(APPEND ARG_OPTIONS "include_prefix=${include_prefix}")
-  endif()
-  # CMake 3.12 is finally getting a list(JOIN) function, but until then
-  # treating the list as a string and replacing the semicolons is good enough.
-  string(REPLACE ";" "," GEN_ARG_STR "${ARG_OPTIONS}")
-
-  # Compute the list of generated files
-  list(APPEND generated_headers
-    "${output_dir}/gen-cpp2/${base}_constants.h"
-    "${output_dir}/gen-cpp2/${base}_types.h"
-    "${output_dir}/gen-cpp2/${base}_types.tcc"
-    "${output_dir}/gen-cpp2/${base}_types_custom_protocol.h"
-    "${output_dir}/gen-cpp2/${base}_metadata.h"
-  )
-  list(APPEND generated_sources
-    "${output_dir}/gen-cpp2/${base}_constants.cpp"
-    "${output_dir}/gen-cpp2/${base}_data.h"
-    "${output_dir}/gen-cpp2/${base}_data.cpp"
-    "${output_dir}/gen-cpp2/${base}_types.cpp"
-    "${output_dir}/gen-cpp2/${base}_metadata.cpp"
-  )
-  foreach(service IN LISTS ARG_SERVICES)
-    list(APPEND generated_headers
-      "${output_dir}/gen-cpp2/${service}.h"
-      "${output_dir}/gen-cpp2/${service}.tcc"
-      "${output_dir}/gen-cpp2/${service}AsyncClient.h"
-      "${output_dir}/gen-cpp2/${service}_custom_protocol.h"
-    )
-    list(APPEND generated_sources
-      "${output_dir}/gen-cpp2/${service}.cpp"
-      "${output_dir}/gen-cpp2/${service}AsyncClient.cpp"
-      "${output_dir}/gen-cpp2/${service}_processmap_binary.cpp"
-      "${output_dir}/gen-cpp2/${service}_processmap_compact.cpp"
-    )
-  endforeach()
-
-  # This generator expression gets the list of include directories required
-  # for all of our dependencies.
-  # It requires using COMMAND_EXPAND_LISTS in the add_custom_command() call
-  # below.  COMMAND_EXPAND_LISTS is only available in CMake 3.8+
-  # If we really had to support older versions of CMake we would probably need
-  # to use a wrapper script around the thrift compiler that could take the
-  # include list as a single argument and split it up before invoking the
-  # thrift compiler.
-  if (NOT POLICY CMP0067)
-    message(FATAL_ERROR "add_fbthrift_cpp_library() requires CMake 3.8+")
-  endif()
-  set(
-    thrift_include_options
-    "-I;$<JOIN:$<TARGET_PROPERTY:${LIB_NAME}.thrift_includes,INTERFACE_INCLUDE_DIRECTORIES>,;-I;>"
-  )
-
-  # Emit the rule to run the thrift compiler
-  add_custom_command(
-    OUTPUT
-      ${generated_headers}
-      ${generated_sources}
-    COMMAND_EXPAND_LISTS
-    COMMAND
-      "${CMAKE_COMMAND}" -E make_directory "${output_dir}"
-    COMMAND
-      "${FBTHRIFT_COMPILER}"
-      --legacy-strict
-      --gen "mstch_cpp2:${GEN_ARG_STR}"
-      "${thrift_include_options}"
-      -I "${FBTHRIFT_INCLUDE_DIR}"
-      -o "${output_dir}"
-      "${CMAKE_CURRENT_SOURCE_DIR}/${THRIFT_FILE}"
-    WORKING_DIRECTORY
-      "${CMAKE_BINARY_DIR}"
-    MAIN_DEPENDENCY
-      "${THRIFT_FILE}"
-    DEPENDS
-      ${ARG_DEPENDS}
-      "${FBTHRIFT_COMPILER}"
-  )
-
-  # Now emit the library rule to compile the sources
-  if (BUILD_SHARED_LIBS)
-    set(LIB_TYPE SHARED)
-  else ()
-    set(LIB_TYPE STATIC)
-  endif ()
-
-  add_library(
-    "${LIB_NAME}" ${LIB_TYPE}
-    ${generated_sources}
-  )
-
-  target_include_directories(
-    "${LIB_NAME}"
-    PUBLIC
-      "$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>"
-      "$<INSTALL_INTERFACE:${ARG_INCLUDE_DIR}>"
-  )
-  target_link_libraries(
-    "${LIB_NAME}"
-    PUBLIC
-      ${ARG_DEPENDS}
-      FBThrift::thriftcpp2
-      Folly::folly
-      mvfst::mvfst_server_async_tran
-      mvfst::mvfst_server
-  )
-
-  # Add ${generated_headers} to the PUBLIC_HEADER property for ${LIB_NAME}
-  #
-  # This allows callers to install it using
-  # "install(TARGETS ${LIB_NAME} PUBLIC_HEADER)"
-  # However, note that CMake's PUBLIC_HEADER behavior is rather inflexible,
-  # and does have any way to preserve header directory structure.  Callers
-  # must be careful to use the correct PUBLIC_HEADER DESTINATION parameter
-  # when doing this, to put the files the correct directory themselves.
-  # We define a HEADER_INSTALL_DIR property with the include directory prefix,
-  # so typically callers should specify the PUBLIC_HEADER DESTINATION as
-  # "$<TARGET_PROPERTY:${LIB_NAME},HEADER_INSTALL_DIR>"
-  set_property(
-    TARGET "${LIB_NAME}"
-    PROPERTY PUBLIC_HEADER ${generated_headers}
-  )
-
-  # Define a dummy interface library to help propagate the thrift include
-  # directories between dependencies.
-  add_library("${LIB_NAME}.thrift_includes" INTERFACE)
-  target_include_directories(
-    "${LIB_NAME}.thrift_includes"
-    INTERFACE
-      "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>"
-      "$<INSTALL_INTERFACE:${ARG_THRIFT_INCLUDE_DIR}>"
-  )
-  foreach(dep IN LISTS ARG_DEPENDS)
-    target_link_libraries(
-      "${LIB_NAME}.thrift_includes"
-      INTERFACE "${dep}.thrift_includes"
-    )
-  endforeach()
-
-  set_target_properties(
-    "${LIB_NAME}"
-    PROPERTIES
-      EXPORT_PROPERTIES "THRIFT_INSTALL_DIR"
-      THRIFT_INSTALL_DIR "${ARG_THRIFT_INCLUDE_DIR}/${include_prefix}"
-      HEADER_INSTALL_DIR "${ARG_INCLUDE_DIR}/${include_prefix}/gen-cpp2"
-  )
-endfunction()
diff --git a/build/fbcode_builder/CMake/FBThriftLibrary.cmake b/build/fbcode_builder/CMake/FBThriftLibrary.cmake
deleted file mode 100644
index e4280e2a4092b..0000000000000
--- a/build/fbcode_builder/CMake/FBThriftLibrary.cmake
+++ /dev/null
@@ -1,77 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-include(FBCMakeParseArgs)
-include(FBThriftPyLibrary)
-include(FBThriftCppLibrary)
-
-#
-# add_fbthrift_library()
-#
-# This is a convenience function that generates thrift libraries for multiple
-# languages.
-#
-# For example:
-#   add_fbthrift_library(
-#     foo foo.thrift
-#     LANGUAGES cpp py
-#     SERVICES Foo
-#     DEPENDS bar)
-#
-# will be expanded into two separate calls:
-#
-# add_fbthrift_cpp_library(foo_cpp foo.thrift SERVICES Foo DEPENDS bar_cpp)
-# add_fbthrift_py_library(foo_py foo.thrift SERVICES Foo DEPENDS bar_py)
-#
-function(add_fbthrift_library LIB_NAME THRIFT_FILE)
-  # Parse the arguments
-  set(one_value_args PY_NAMESPACE INCLUDE_DIR THRIFT_INCLUDE_DIR)
-  set(multi_value_args SERVICES DEPENDS LANGUAGES CPP_OPTIONS PY_OPTIONS)
-  fb_cmake_parse_args(
-    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
-  )
-
-  if(NOT DEFINED ARG_INCLUDE_DIR)
-    set(ARG_INCLUDE_DIR "include")
-  endif()
-  if(NOT DEFINED ARG_THRIFT_INCLUDE_DIR)
-    set(ARG_THRIFT_INCLUDE_DIR "${ARG_INCLUDE_DIR}/thrift-files")
-  endif()
-
-  # CMake 3.12+ adds list(TRANSFORM) which would be nice to use here, but for
-  # now we still want to support older versions of CMake.
-  set(CPP_DEPENDS)
-  set(PY_DEPENDS)
-  foreach(dep IN LISTS ARG_DEPENDS)
-    list(APPEND CPP_DEPENDS "${dep}_cpp")
-    list(APPEND PY_DEPENDS "${dep}_py")
-  endforeach()
-
-  foreach(lang IN LISTS ARG_LANGUAGES)
-    if ("${lang}" STREQUAL "cpp")
-      add_fbthrift_cpp_library(
-        "${LIB_NAME}_cpp" "${THRIFT_FILE}"
-        SERVICES ${ARG_SERVICES}
-        DEPENDS ${CPP_DEPENDS}
-        OPTIONS ${ARG_CPP_OPTIONS}
-        INCLUDE_DIR "${ARG_INCLUDE_DIR}"
-        THRIFT_INCLUDE_DIR "${ARG_THRIFT_INCLUDE_DIR}"
-      )
-    elseif ("${lang}" STREQUAL "py" OR "${lang}" STREQUAL "python")
-      if (DEFINED ARG_PY_NAMESPACE)
-        set(namespace_args NAMESPACE "${ARG_PY_NAMESPACE}")
-      endif()
-      add_fbthrift_py_library(
-        "${LIB_NAME}_py" "${THRIFT_FILE}"
-        SERVICES ${ARG_SERVICES}
-        ${namespace_args}
-        DEPENDS ${PY_DEPENDS}
-        OPTIONS ${ARG_PY_OPTIONS}
-        THRIFT_INCLUDE_DIR "${ARG_THRIFT_INCLUDE_DIR}"
-      )
-    else()
-      message(
-        FATAL_ERROR "unknown language for thrift library ${LIB_NAME}: ${lang}"
-      )
-    endif()
-  endforeach()
-endfunction()
diff --git a/build/fbcode_builder/CMake/FBThriftPyLibrary.cmake b/build/fbcode_builder/CMake/FBThriftPyLibrary.cmake
deleted file mode 100644
index fa77cde715533..0000000000000
--- a/build/fbcode_builder/CMake/FBThriftPyLibrary.cmake
+++ /dev/null
@@ -1,111 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-include(FBCMakeParseArgs)
-include(FBPythonBinary)
-
-# Generate a Python library from a thrift file
-function(add_fbthrift_py_library LIB_NAME THRIFT_FILE)
-  # Parse the arguments
-  set(one_value_args NAMESPACE THRIFT_INCLUDE_DIR)
-  set(multi_value_args SERVICES DEPENDS OPTIONS)
-  fb_cmake_parse_args(
-    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
-  )
-
-  if(NOT DEFINED ARG_THRIFT_INCLUDE_DIR)
-    set(ARG_THRIFT_INCLUDE_DIR "include/thrift-files")
-  endif()
-
-  get_filename_component(base ${THRIFT_FILE} NAME_WE)
-  set(output_dir "${CMAKE_CURRENT_BINARY_DIR}/${THRIFT_FILE}-py")
-
-  # Parse the namespace value
-  if (NOT DEFINED ARG_NAMESPACE)
-    set(ARG_NAMESPACE "${base}")
-  endif()
-
-  string(REPLACE "." "/" namespace_dir "${ARG_NAMESPACE}")
-  set(py_output_dir "${output_dir}/gen-py/${namespace_dir}")
-  list(APPEND generated_sources
-    "${py_output_dir}/__init__.py"
-    "${py_output_dir}/ttypes.py"
-    "${py_output_dir}/constants.py"
-  )
-  foreach(service IN LISTS ARG_SERVICES)
-    list(APPEND generated_sources
-      ${py_output_dir}/${service}.py
-    )
-  endforeach()
-
-  # Define a dummy interface library to help propagate the thrift include
-  # directories between dependencies.
-  add_library("${LIB_NAME}.thrift_includes" INTERFACE)
-  target_include_directories(
-    "${LIB_NAME}.thrift_includes"
-    INTERFACE
-      "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>"
-      "$<INSTALL_INTERFACE:${ARG_THRIFT_INCLUDE_DIR}>"
-  )
-  foreach(dep IN LISTS ARG_DEPENDS)
-    target_link_libraries(
-      "${LIB_NAME}.thrift_includes"
-      INTERFACE "${dep}.thrift_includes"
-    )
-  endforeach()
-
-  # This generator expression gets the list of include directories required
-  # for all of our dependencies.
-  # It requires using COMMAND_EXPAND_LISTS in the add_custom_command() call
-  # below.  COMMAND_EXPAND_LISTS is only available in CMake 3.8+
-  # If we really had to support older versions of CMake we would probably need
-  # to use a wrapper script around the thrift compiler that could take the
-  # include list as a single argument and split it up before invoking the
-  # thrift compiler.
-  if (NOT POLICY CMP0067)
-    message(FATAL_ERROR "add_fbthrift_py_library() requires CMake 3.8+")
-  endif()
-  set(
-    thrift_include_options
-    "-I;$<JOIN:$<TARGET_PROPERTY:${LIB_NAME}.thrift_includes,INTERFACE_INCLUDE_DIRECTORIES>,;-I;>"
-  )
-
-  # Always force generation of "new-style" python classes for Python 2
-  list(APPEND ARG_OPTIONS "new_style")
-  # CMake 3.12 is finally getting a list(JOIN) function, but until then
-  # treating the list as a string and replacing the semicolons is good enough.
-  string(REPLACE ";" "," GEN_ARG_STR "${ARG_OPTIONS}")
-
-  # Emit the rule to run the thrift compiler
-  add_custom_command(
-    OUTPUT
-      ${generated_sources}
-    COMMAND_EXPAND_LISTS
-    COMMAND
-      "${CMAKE_COMMAND}" -E make_directory "${output_dir}"
-    COMMAND
-      "${FBTHRIFT_COMPILER}"
-      --legacy-strict
-      --gen "py:${GEN_ARG_STR}"
-      "${thrift_include_options}"
-      -o "${output_dir}"
-      "${CMAKE_CURRENT_SOURCE_DIR}/${THRIFT_FILE}"
-    WORKING_DIRECTORY
-      "${CMAKE_BINARY_DIR}"
-    MAIN_DEPENDENCY
-      "${THRIFT_FILE}"
-    DEPENDS
-      "${FBTHRIFT_COMPILER}"
-  )
-
-  # We always want to pass the namespace as "" to this call:
-  # thrift will already emit the files with the desired namespace prefix under
-  # gen-py.  We don't want add_fb_python_library() to prepend the namespace a
-  # second time.
-  add_fb_python_library(
-    "${LIB_NAME}"
-    BASE_DIR "${output_dir}/gen-py"
-    NAMESPACE ""
-    SOURCES ${generated_sources}
-    DEPENDS ${ARG_DEPENDS} FBThrift::thrift_py
-  )
-endfunction()
diff --git a/build/fbcode_builder/CMake/FindDoubleConversion.cmake b/build/fbcode_builder/CMake/FindDoubleConversion.cmake
deleted file mode 100644
index 12a423bc15103..0000000000000
--- a/build/fbcode_builder/CMake/FindDoubleConversion.cmake
+++ /dev/null
@@ -1,19 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-
-# Finds libdouble-conversion.
-#
-# This module defines:
-# DOUBLE_CONVERSION_INCLUDE_DIR
-# DOUBLE_CONVERSION_LIBRARY
-#
-
-find_path(DOUBLE_CONVERSION_INCLUDE_DIR double-conversion/double-conversion.h)
-find_library(DOUBLE_CONVERSION_LIBRARY NAMES double-conversion)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(
-  DoubleConversion
-  DEFAULT_MSG
-  DOUBLE_CONVERSION_LIBRARY DOUBLE_CONVERSION_INCLUDE_DIR)
-
-mark_as_advanced(DOUBLE_CONVERSION_INCLUDE_DIR DOUBLE_CONVERSION_LIBRARY)
diff --git a/build/fbcode_builder/CMake/FindGMock.cmake b/build/fbcode_builder/CMake/FindGMock.cmake
deleted file mode 100644
index cd042dd9c4fa6..0000000000000
--- a/build/fbcode_builder/CMake/FindGMock.cmake
+++ /dev/null
@@ -1,80 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# Find libgmock
-#
-#  LIBGMOCK_DEFINES     - List of defines when using libgmock.
-#  LIBGMOCK_INCLUDE_DIR - where to find gmock/gmock.h, etc.
-#  LIBGMOCK_LIBRARIES   - List of libraries when using libgmock.
-#  LIBGMOCK_FOUND       - True if libgmock found.
-
-IF (LIBGMOCK_INCLUDE_DIR)
-  # Already in cache, be silent
-  SET(LIBGMOCK_FIND_QUIETLY TRUE)
-ENDIF ()
-
-find_package(GTest CONFIG QUIET)
-if (TARGET GTest::gmock)
-  get_target_property(LIBGMOCK_DEFINES GTest::gtest INTERFACE_COMPILE_DEFINITIONS)
-  if (NOT ${LIBGMOCK_DEFINES})
-    # Explicitly set to empty string if not found to avoid it being
-    # set to NOTFOUND and breaking compilation
-    set(LIBGMOCK_DEFINES "")
-  endif()
-  get_target_property(LIBGMOCK_INCLUDE_DIR GTest::gtest INTERFACE_INCLUDE_DIRECTORIES)
-  set(LIBGMOCK_LIBRARIES GTest::gmock_main GTest::gmock GTest::gtest)
-  set(LIBGMOCK_FOUND ON)
-  message(STATUS "Found gmock via config, defines=${LIBGMOCK_DEFINES}, include=${LIBGMOCK_INCLUDE_DIR}, libs=${LIBGMOCK_LIBRARIES}")
-else()
-
-  FIND_PATH(LIBGMOCK_INCLUDE_DIR gmock/gmock.h)
-
-  FIND_LIBRARY(LIBGMOCK_MAIN_LIBRARY_DEBUG NAMES gmock_maind)
-  FIND_LIBRARY(LIBGMOCK_MAIN_LIBRARY_RELEASE NAMES gmock_main)
-  FIND_LIBRARY(LIBGMOCK_LIBRARY_DEBUG NAMES gmockd)
-  FIND_LIBRARY(LIBGMOCK_LIBRARY_RELEASE NAMES gmock)
-  FIND_LIBRARY(LIBGTEST_LIBRARY_DEBUG NAMES gtestd)
-  FIND_LIBRARY(LIBGTEST_LIBRARY_RELEASE NAMES gtest)
-
-  find_package(Threads REQUIRED)
-  INCLUDE(SelectLibraryConfigurations)
-  SELECT_LIBRARY_CONFIGURATIONS(LIBGMOCK_MAIN)
-  SELECT_LIBRARY_CONFIGURATIONS(LIBGMOCK)
-  SELECT_LIBRARY_CONFIGURATIONS(LIBGTEST)
-
-  set(LIBGMOCK_LIBRARIES
-    ${LIBGMOCK_MAIN_LIBRARY}
-    ${LIBGMOCK_LIBRARY}
-    ${LIBGTEST_LIBRARY}
-    Threads::Threads
-  )
-
-  if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-    # The GTEST_LINKED_AS_SHARED_LIBRARY macro must be set properly on Windows.
-    #
-    # There isn't currently an easy way to determine if a library was compiled as
-    # a shared library on Windows, so just assume we've been built against a
-    # shared build of gmock for now.
-    SET(LIBGMOCK_DEFINES "GTEST_LINKED_AS_SHARED_LIBRARY=1" CACHE STRING "")
-  endif()
-
-  # handle the QUIETLY and REQUIRED arguments and set LIBGMOCK_FOUND to TRUE if
-  # all listed variables are TRUE
-  INCLUDE(FindPackageHandleStandardArgs)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(
-    GMock
-    DEFAULT_MSG
-    LIBGMOCK_MAIN_LIBRARY
-    LIBGMOCK_LIBRARY
-    LIBGTEST_LIBRARY
-    LIBGMOCK_LIBRARIES
-    LIBGMOCK_INCLUDE_DIR
-  )
-
-  MARK_AS_ADVANCED(
-    LIBGMOCK_DEFINES
-    LIBGMOCK_MAIN_LIBRARY
-    LIBGMOCK_LIBRARY
-    LIBGTEST_LIBRARY
-    LIBGMOCK_LIBRARIES
-    LIBGMOCK_INCLUDE_DIR
-  )
-endif()
diff --git a/build/fbcode_builder/CMake/FindGflags.cmake b/build/fbcode_builder/CMake/FindGflags.cmake
deleted file mode 100644
index 0101203e03635..0000000000000
--- a/build/fbcode_builder/CMake/FindGflags.cmake
+++ /dev/null
@@ -1,106 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# Find libgflags.
-# There's a lot of compatibility cruft going on in here, both
-# to deal with changes across the FB consumers of this and also
-# to deal with variances in behavior of cmake itself.
-#
-# Since this file is named FindGflags.cmake the cmake convention
-# is for the module to export both GFLAGS_FOUND and Gflags_FOUND.
-# The convention expected by consumers is that we export the
-# following variables, even though these do not match the cmake
-# conventions:
-#
-#  LIBGFLAGS_INCLUDE_DIR - where to find gflags/gflags.h, etc.
-#  LIBGFLAGS_LIBRARY     - List of libraries when using libgflags.
-#  LIBGFLAGS_FOUND       - True if libgflags found.
-#
-# We need to be able to locate gflags both from an installed
-# cmake config file and just from the raw headers and libs, so
-# test for the former and then the latter, and then stick
-# the results together and export them into the variables
-# listed above.
-#
-# For forwards compatibility, we export the following variables:
-#
-#  gflags_INCLUDE_DIR - where to find gflags/gflags.h, etc.
-#  gflags_TARGET / GFLAGS_TARGET / gflags_LIBRARIES
-#                     - List of libraries when using libgflags.
-#  gflags_FOUND       - True if libgflags found.
-#
-
-IF (LIBGFLAGS_INCLUDE_DIR)
-  # Already in cache, be silent
-  SET(Gflags_FIND_QUIETLY TRUE)
-ENDIF ()
-
-find_package(gflags CONFIG QUIET)
-if (gflags_FOUND)
-  if (NOT Gflags_FIND_QUIETLY)
-    message(STATUS "Found gflags from package config ${gflags_CONFIG}")
-  endif()
-  # Re-export the config-specified libs with our local names
-  set(LIBGFLAGS_LIBRARY ${gflags_LIBRARIES})
-  set(LIBGFLAGS_INCLUDE_DIR ${gflags_INCLUDE_DIR})
-  if(NOT EXISTS "${gflags_INCLUDE_DIR}")
-    # The gflags-devel RPM on recent RedHat-based systems is somewhat broken.
-    # RedHat symlinks /lib64 to /usr/lib64, and this breaks some of the
-    # relative path computation performed in gflags-config.cmake.  The package
-    # config file ends up being found via /lib64, but the relative path
-    # computation it does only works if it was found in /usr/lib64.
-    # If gflags_INCLUDE_DIR does not actually exist, simply default it to
-    # /usr/include on these systems.
-    set(LIBGFLAGS_INCLUDE_DIR "/usr/include")
-    set(GFLAGS_INCLUDE_DIR "/usr/include")
-  endif()
-  set(LIBGFLAGS_FOUND ${gflags_FOUND})
-  # cmake module compat
-  set(GFLAGS_FOUND ${gflags_FOUND})
-  set(Gflags_FOUND ${gflags_FOUND})
-else()
-  FIND_PATH(LIBGFLAGS_INCLUDE_DIR gflags/gflags.h)
-
-  FIND_LIBRARY(LIBGFLAGS_LIBRARY_DEBUG NAMES gflagsd gflags_staticd)
-  FIND_LIBRARY(LIBGFLAGS_LIBRARY_RELEASE NAMES gflags gflags_static)
-
-  INCLUDE(SelectLibraryConfigurations)
-  SELECT_LIBRARY_CONFIGURATIONS(LIBGFLAGS)
-
-  # handle the QUIETLY and REQUIRED arguments and set LIBGFLAGS_FOUND to TRUE if
-  # all listed variables are TRUE
-  INCLUDE(FindPackageHandleStandardArgs)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(gflags DEFAULT_MSG LIBGFLAGS_LIBRARY LIBGFLAGS_INCLUDE_DIR)
-  # cmake module compat
-  set(Gflags_FOUND ${GFLAGS_FOUND})
-  # compat with some existing FindGflags consumers
-  set(LIBGFLAGS_FOUND ${GFLAGS_FOUND})
-
-  # Compat with the gflags CONFIG based detection
-  set(gflags_FOUND ${GFLAGS_FOUND})
-  set(gflags_INCLUDE_DIR ${LIBGFLAGS_INCLUDE_DIR})
-  set(gflags_LIBRARIES ${LIBGFLAGS_LIBRARY})
-  set(GFLAGS_TARGET ${LIBGFLAGS_LIBRARY})
-  set(gflags_TARGET ${LIBGFLAGS_LIBRARY})
-
-  MARK_AS_ADVANCED(LIBGFLAGS_LIBRARY LIBGFLAGS_INCLUDE_DIR)
-endif()
-
-# Compat with the gflags CONFIG based detection
-if (LIBGFLAGS_FOUND AND NOT TARGET gflags)
-  add_library(gflags UNKNOWN IMPORTED)
-  if(TARGET gflags-shared)
-    # If the installed gflags CMake package config defines a gflags-shared
-    # target but not gflags, just make the gflags target that we define
-    # depend on the gflags-shared target.
-    target_link_libraries(gflags INTERFACE gflags-shared)
-    # Export LIBGFLAGS_LIBRARY as the gflags-shared target in this case.
-    set(LIBGFLAGS_LIBRARY gflags-shared)
-  else()
-    set_target_properties(
-      gflags
-      PROPERTIES
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION "${LIBGFLAGS_LIBRARY}"
-        INTERFACE_INCLUDE_DIRECTORIES "${LIBGFLAGS_INCLUDE_DIR}"
-    )
-  endif()
-endif()
diff --git a/build/fbcode_builder/CMake/FindGlog.cmake b/build/fbcode_builder/CMake/FindGlog.cmake
deleted file mode 100644
index 38ee54a7cf899..0000000000000
--- a/build/fbcode_builder/CMake/FindGlog.cmake
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# - Try to find Glog
-# Once done, this will define
-#
-# GLOG_FOUND - system has Glog
-# GLOG_INCLUDE_DIRS - the Glog include directories
-# GLOG_LIBRARIES - link these to use Glog
-
-include(FindPackageHandleStandardArgs)
-include(SelectLibraryConfigurations)
-
-find_library(GLOG_LIBRARY_RELEASE glog
-  PATHS ${GLOG_LIBRARYDIR})
-find_library(GLOG_LIBRARY_DEBUG glogd
-  PATHS ${GLOG_LIBRARYDIR})
-
-find_path(GLOG_INCLUDE_DIR glog/logging.h
-  PATHS ${GLOG_INCLUDEDIR})
-
-select_library_configurations(GLOG)
-
-find_package_handle_standard_args(Glog DEFAULT_MSG
-  GLOG_LIBRARY
-  GLOG_INCLUDE_DIR)
-
-mark_as_advanced(
-  GLOG_LIBRARY
-  GLOG_INCLUDE_DIR)
-
-set(GLOG_LIBRARIES ${GLOG_LIBRARY})
-set(GLOG_INCLUDE_DIRS ${GLOG_INCLUDE_DIR})
-
-if (NOT TARGET glog::glog)
-  add_library(glog::glog UNKNOWN IMPORTED)
-  set_target_properties(glog::glog PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIRS}")
-  set_target_properties(glog::glog PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" IMPORTED_LOCATION "${GLOG_LIBRARIES}")
-
-  find_package(Gflags)
-  if(GFLAGS_FOUND)
-    message(STATUS "Found gflags as a dependency of glog::glog, include=${LIBGFLAGS_INCLUDE_DIR}, libs=${LIBGFLAGS_LIBRARY}")
-    set_target_properties(glog::glog PROPERTIES IMPORTED_LINK_INTERFACE_LIBRARIES ${LIBGFLAGS_LIBRARY})
-  endif()
-endif()
diff --git a/build/fbcode_builder/CMake/FindLibEvent.cmake b/build/fbcode_builder/CMake/FindLibEvent.cmake
deleted file mode 100644
index dd11ebd8435d7..0000000000000
--- a/build/fbcode_builder/CMake/FindLibEvent.cmake
+++ /dev/null
@@ -1,77 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# - Find LibEvent (a cross event library)
-# This module defines
-# LIBEVENT_INCLUDE_DIR, where to find LibEvent headers
-# LIBEVENT_LIB, LibEvent libraries
-# LibEvent_FOUND, If false, do not try to use libevent
-
-set(LibEvent_EXTRA_PREFIXES /usr/local /opt/local "$ENV{HOME}")
-foreach(prefix ${LibEvent_EXTRA_PREFIXES})
-  list(APPEND LibEvent_INCLUDE_PATHS "${prefix}/include")
-  list(APPEND LibEvent_LIB_PATHS "${prefix}/lib")
-endforeach()
-
-find_package(Libevent CONFIG QUIET)
-if (TARGET event)
-  # Re-export the config under our own names
-
-  # Somewhat gross, but some vcpkg installed libevents have a relative
-  # `include` path exported into LIBEVENT_INCLUDE_DIRS, which triggers
-  # a cmake error because it resolves to the `include` dir within the
-  # folly repo, which is not something cmake allows to be in the
-  # INTERFACE_INCLUDE_DIRECTORIES.  Thankfully on such a system the
-  # actual include directory is already part of the global include
-  # directories, so we can just skip it.
-  if (NOT "${LIBEVENT_INCLUDE_DIRS}" STREQUAL "include")
-    set(LIBEVENT_INCLUDE_DIR ${LIBEVENT_INCLUDE_DIRS})
-  else()
-    set(LIBEVENT_INCLUDE_DIR)
-  endif()
-
-  # Unfortunately, with a bare target name `event`, downstream consumers
-  # of the package that depends on `Libevent` located via CONFIG end
-  # up exporting just a bare `event` in their libraries.  This is problematic
-  # because this in interpreted as just `-levent` with no library path.
-  # When libevent is not installed in the default installation prefix
-  # this results in linker errors.
-  # To resolve this, we ask cmake to lookup the full path to the library
-  # and use that instead.
-  cmake_policy(PUSH)
-  if(POLICY CMP0026)
-    # Allow reading the LOCATION property
-    cmake_policy(SET CMP0026 OLD)
-  endif()
-  get_target_property(LIBEVENT_LIB event LOCATION)
-  cmake_policy(POP)
-
-  set(LibEvent_FOUND ${Libevent_FOUND})
-  if (NOT LibEvent_FIND_QUIETLY)
-    message(STATUS "Found libevent from package config include=${LIBEVENT_INCLUDE_DIRS} lib=${LIBEVENT_LIB}")
-  endif()
-else()
-  find_path(LIBEVENT_INCLUDE_DIR event.h PATHS ${LibEvent_INCLUDE_PATHS})
-  find_library(LIBEVENT_LIB NAMES event PATHS ${LibEvent_LIB_PATHS})
-
-  if (LIBEVENT_LIB AND LIBEVENT_INCLUDE_DIR)
-    set(LibEvent_FOUND TRUE)
-    set(LIBEVENT_LIB ${LIBEVENT_LIB})
-  else ()
-    set(LibEvent_FOUND FALSE)
-  endif ()
-
-  if (LibEvent_FOUND)
-    if (NOT LibEvent_FIND_QUIETLY)
-      message(STATUS "Found libevent: ${LIBEVENT_LIB}")
-    endif ()
-  else ()
-    if (LibEvent_FIND_REQUIRED)
-      message(FATAL_ERROR "Could NOT find libevent.")
-    endif ()
-    message(STATUS "libevent NOT found.")
-  endif ()
-
-  mark_as_advanced(
-    LIBEVENT_LIB
-    LIBEVENT_INCLUDE_DIR
-  )
-endif()
diff --git a/build/fbcode_builder/CMake/FindLibUnwind.cmake b/build/fbcode_builder/CMake/FindLibUnwind.cmake
deleted file mode 100644
index b01a674a5ba0f..0000000000000
--- a/build/fbcode_builder/CMake/FindLibUnwind.cmake
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-find_path(LIBUNWIND_INCLUDE_DIR NAMES libunwind.h)
-mark_as_advanced(LIBUNWIND_INCLUDE_DIR)
-
-find_library(LIBUNWIND_LIBRARY NAMES unwind)
-mark_as_advanced(LIBUNWIND_LIBRARY)
-
-include(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(
-  LIBUNWIND
-  REQUIRED_VARS LIBUNWIND_LIBRARY LIBUNWIND_INCLUDE_DIR)
-
-if(LIBUNWIND_FOUND)
-  set(LIBUNWIND_LIBRARIES ${LIBUNWIND_LIBRARY})
-  set(LIBUNWIND_INCLUDE_DIRS ${LIBUNWIND_INCLUDE_DIR})
-endif()
diff --git a/build/fbcode_builder/CMake/FindPCRE.cmake b/build/fbcode_builder/CMake/FindPCRE.cmake
deleted file mode 100644
index 32ccb372536f9..0000000000000
--- a/build/fbcode_builder/CMake/FindPCRE.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-include(FindPackageHandleStandardArgs)
-find_path(PCRE_INCLUDE_DIR NAMES pcre.h)
-find_library(PCRE_LIBRARY NAMES pcre)
-find_package_handle_standard_args(
-  PCRE
-  DEFAULT_MSG
-  PCRE_LIBRARY
-  PCRE_INCLUDE_DIR
-)
-mark_as_advanced(PCRE_INCLUDE_DIR PCRE_LIBRARY)
diff --git a/build/fbcode_builder/CMake/FindPCRE2.cmake b/build/fbcode_builder/CMake/FindPCRE2.cmake
deleted file mode 100644
index c2c64a29bb4ee..0000000000000
--- a/build/fbcode_builder/CMake/FindPCRE2.cmake
+++ /dev/null
@@ -1,12 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-include(FindPackageHandleStandardArgs)
-find_path(PCRE2_INCLUDE_DIR NAMES pcre2.h)
-find_library(PCRE2_LIBRARY NAMES pcre2-8)
-find_package_handle_standard_args(
-  PCRE2
-  DEFAULT_MSG
-  PCRE2_LIBRARY
-  PCRE2_INCLUDE_DIR
-)
-set(PCRE2_DEFINES "PCRE2_CODE_UNIT_WIDTH=8")
-mark_as_advanced(PCRE2_INCLUDE_DIR PCRE2_LIBRARY PCRE2_DEFINES)
diff --git a/build/fbcode_builder/CMake/FindRe2.cmake b/build/fbcode_builder/CMake/FindRe2.cmake
deleted file mode 100644
index 013ae7761e9c7..0000000000000
--- a/build/fbcode_builder/CMake/FindRe2.cmake
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This software may be used and distributed according to the terms of the
-# GNU General Public License version 2.
-
-find_library(RE2_LIBRARY re2)
-mark_as_advanced(RE2_LIBRARY)
-
-find_path(RE2_INCLUDE_DIR NAMES re2/re2.h)
-mark_as_advanced(RE2_INCLUDE_DIR)
-
-include(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(
-     RE2
-     REQUIRED_VARS RE2_LIBRARY RE2_INCLUDE_DIR)
-
-if(RE2_FOUND)
-  set(RE2_LIBRARY ${RE2_LIBRARY})
-  set(RE2_INCLUDE_DIR, ${RE2_INCLUDE_DIR})
-endif()
diff --git a/build/fbcode_builder/CMake/FindSodium.cmake b/build/fbcode_builder/CMake/FindSodium.cmake
deleted file mode 100644
index 3c3f1245c1dcc..0000000000000
--- a/build/fbcode_builder/CMake/FindSodium.cmake
+++ /dev/null
@@ -1,297 +0,0 @@
-# Written in 2016 by Henrik Steffen Gaßmann <henrik@gassmann.onl>
-#
-# To the extent possible under law, the author(s) have dedicated all
-# copyright and related and neighboring rights to this software to the
-# public domain worldwide. This software is distributed without any warranty.
-#
-# You should have received a copy of the CC0 Public Domain Dedication
-# along with this software. If not, see
-#
-#     http://creativecommons.org/publicdomain/zero/1.0/
-#
-########################################################################
-# Tries to find the local libsodium installation.
-#
-# On Windows the sodium_DIR environment variable is used as a default
-# hint which can be overridden by setting the corresponding cmake variable.
-#
-# Once done the following variables will be defined:
-#
-#   sodium_FOUND
-#   sodium_INCLUDE_DIR
-#   sodium_LIBRARY_DEBUG
-#   sodium_LIBRARY_RELEASE
-#
-#
-# Furthermore an imported "sodium" target is created.
-#
-
-if (CMAKE_C_COMPILER_ID STREQUAL "GNU"
-    OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
-    set(_GCC_COMPATIBLE 1)
-endif()
-
-# static library option
-if (NOT DEFINED sodium_USE_STATIC_LIBS)
-    option(sodium_USE_STATIC_LIBS "enable to statically link against sodium" OFF)
-endif()
-if(NOT (sodium_USE_STATIC_LIBS EQUAL sodium_USE_STATIC_LIBS_LAST))
-    unset(sodium_LIBRARY CACHE)
-    unset(sodium_LIBRARY_DEBUG CACHE)
-    unset(sodium_LIBRARY_RELEASE CACHE)
-    unset(sodium_DLL_DEBUG CACHE)
-    unset(sodium_DLL_RELEASE CACHE)
-    set(sodium_USE_STATIC_LIBS_LAST ${sodium_USE_STATIC_LIBS} CACHE INTERNAL "internal change tracking variable")
-endif()
-
-
-########################################################################
-# UNIX
-if (UNIX)
-    # import pkg-config
-    find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_check_modules(sodium_PKG QUIET libsodium)
-    endif()
-
-    if(sodium_USE_STATIC_LIBS)
-        foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
-            if (NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending with .a
-                list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
-            endif()
-        endforeach()
-        list(REMOVE_DUPLICATES sodium_PKG_STATIC_LIBRARIES)
-
-        # if pkgconfig for libsodium doesn't provide
-        # static lib info, then override PKG_STATIC here..
-        if (NOT sodium_PKG_STATIC_FOUND)
-            set(sodium_PKG_STATIC_LIBRARIES libsodium.a)
-        endif()
-
-        set(XPREFIX sodium_PKG_STATIC)
-    else()
-        if (NOT sodium_PKG_FOUND)
-            set(sodium_PKG_LIBRARIES sodium)
-        endif()
-
-        set(XPREFIX sodium_PKG)
-    endif()
-
-    find_path(sodium_INCLUDE_DIR sodium.h
-        HINTS ${${XPREFIX}_INCLUDE_DIRS}
-    )
-    find_library(sodium_LIBRARY_DEBUG NAMES ${${XPREFIX}_LIBRARIES}
-        HINTS ${${XPREFIX}_LIBRARY_DIRS}
-    )
-    find_library(sodium_LIBRARY_RELEASE NAMES ${${XPREFIX}_LIBRARIES}
-        HINTS ${${XPREFIX}_LIBRARY_DIRS}
-    )
-
-
-########################################################################
-# Windows
-elseif (WIN32)
-    set(sodium_DIR "$ENV{sodium_DIR}" CACHE FILEPATH "sodium install directory")
-    mark_as_advanced(sodium_DIR)
-
-    find_path(sodium_INCLUDE_DIR sodium.h
-        HINTS ${sodium_DIR}
-        PATH_SUFFIXES include
-    )
-
-    if (MSVC)
-        # detect target architecture
-        file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp" [=[
-            #if defined _M_IX86
-            #error ARCH_VALUE x86_32
-            #elif defined _M_X64
-            #error ARCH_VALUE x86_64
-            #endif
-            #error ARCH_VALUE unknown
-        ]=])
-        try_compile(_UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp"
-            OUTPUT_VARIABLE _COMPILATION_LOG
-        )
-        string(REGEX REPLACE ".*ARCH_VALUE ([a-zA-Z0-9_]+).*" "\\1" _TARGET_ARCH "${_COMPILATION_LOG}")
-
-        # construct library path
-        if (_TARGET_ARCH STREQUAL "x86_32")
-            string(APPEND _PLATFORM_PATH "Win32")
-        elseif(_TARGET_ARCH STREQUAL "x86_64")
-            string(APPEND _PLATFORM_PATH "x64")
-        else()
-            message(FATAL_ERROR "the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake.")
-        endif()
-        string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
-
-        if (MSVC_VERSION LESS 1900)
-            math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")
-        else()
-            math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 50")
-        endif()
-        string(APPEND _PLATFORM_PATH "/v${_VS_VERSION}")
-
-        if (sodium_USE_STATIC_LIBS)
-            string(APPEND _PLATFORM_PATH "/static")
-        else()
-            string(APPEND _PLATFORM_PATH "/dynamic")
-        endif()
-
-        string(REPLACE "$$CONFIG$$" "Debug" _DEBUG_PATH_SUFFIX "${_PLATFORM_PATH}")
-        string(REPLACE "$$CONFIG$$" "Release" _RELEASE_PATH_SUFFIX "${_PLATFORM_PATH}")
-
-        find_library(sodium_LIBRARY_DEBUG libsodium.lib
-            HINTS ${sodium_DIR}
-            PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
-        )
-        find_library(sodium_LIBRARY_RELEASE libsodium.lib
-            HINTS ${sodium_DIR}
-            PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX}
-        )
-        if (NOT sodium_USE_STATIC_LIBS)
-            set(CMAKE_FIND_LIBRARY_SUFFIXES_BCK ${CMAKE_FIND_LIBRARY_SUFFIXES})
-            set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
-            find_library(sodium_DLL_DEBUG libsodium
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
-            )
-            find_library(sodium_DLL_RELEASE libsodium
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX}
-            )
-            set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BCK})
-        endif()
-
-    elseif(_GCC_COMPATIBLE)
-        if (sodium_USE_STATIC_LIBS)
-            find_library(sodium_LIBRARY_DEBUG libsodium.a
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES lib
-            )
-            find_library(sodium_LIBRARY_RELEASE libsodium.a
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES lib
-            )
-        else()
-            find_library(sodium_LIBRARY_DEBUG libsodium.dll.a
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES lib
-            )
-            find_library(sodium_LIBRARY_RELEASE libsodium.dll.a
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES lib
-            )
-
-            file(GLOB _DLL
-                LIST_DIRECTORIES false
-                RELATIVE "${sodium_DIR}/bin"
-                "${sodium_DIR}/bin/libsodium*.dll"
-            )
-            find_library(sodium_DLL_DEBUG ${_DLL} libsodium
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES bin
-            )
-            find_library(sodium_DLL_RELEASE ${_DLL} libsodium
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES bin
-            )
-        endif()
-    else()
-        message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
-    endif()
-
-
-########################################################################
-# unsupported
-else()
-    message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
-endif()
-
-
-########################################################################
-# common stuff
-
-# extract sodium version
-if (sodium_INCLUDE_DIR)
-    set(_VERSION_HEADER "${_INCLUDE_DIR}/sodium/version.h")
-    if (EXISTS _VERSION_HEADER)
-        file(READ "${_VERSION_HEADER}" _VERSION_HEADER_CONTENT)
-        string(REGEX REPLACE ".*#[ \t]*define[ \t]*SODIUM_VERSION_STRING[ \t]*\"([^\n]*)\".*" "\\1"
-            sodium_VERSION "${_VERSION_HEADER_CONTENT}")
-        set(sodium_VERSION "${sodium_VERSION}" PARENT_SCOPE)
-    endif()
-endif()
-
-# communicate results
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(
-    Sodium # The name must be either uppercase or match the filename case.
-    REQUIRED_VARS
-        sodium_LIBRARY_RELEASE
-        sodium_LIBRARY_DEBUG
-        sodium_INCLUDE_DIR
-    VERSION_VAR
-        sodium_VERSION
-)
-
-if(Sodium_FOUND)
-    set(sodium_LIBRARIES
-        optimized ${sodium_LIBRARY_RELEASE} debug ${sodium_LIBRARY_DEBUG})
-endif()
-
-# mark file paths as advanced
-mark_as_advanced(sodium_INCLUDE_DIR)
-mark_as_advanced(sodium_LIBRARY_DEBUG)
-mark_as_advanced(sodium_LIBRARY_RELEASE)
-if (WIN32)
-    mark_as_advanced(sodium_DLL_DEBUG)
-    mark_as_advanced(sodium_DLL_RELEASE)
-endif()
-
-# create imported target
-if(sodium_USE_STATIC_LIBS)
-    set(_LIB_TYPE STATIC)
-else()
-    set(_LIB_TYPE SHARED)
-endif()
-
-if(NOT TARGET sodium)
-    add_library(sodium ${_LIB_TYPE} IMPORTED)
-endif()
-
-set_target_properties(sodium PROPERTIES
-    INTERFACE_INCLUDE_DIRECTORIES "${sodium_INCLUDE_DIR}"
-    IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-)
-
-if (sodium_USE_STATIC_LIBS)
-    set_target_properties(sodium PROPERTIES
-        INTERFACE_COMPILE_DEFINITIONS "SODIUM_STATIC"
-        IMPORTED_LOCATION "${sodium_LIBRARY_RELEASE}"
-        IMPORTED_LOCATION_DEBUG "${sodium_LIBRARY_DEBUG}"
-    )
-else()
-    if (UNIX)
-        set_target_properties(sodium PROPERTIES
-            IMPORTED_LOCATION "${sodium_LIBRARY_RELEASE}"
-            IMPORTED_LOCATION_DEBUG "${sodium_LIBRARY_DEBUG}"
-        )
-    elseif (WIN32)
-        set_target_properties(sodium PROPERTIES
-            IMPORTED_IMPLIB "${sodium_LIBRARY_RELEASE}"
-            IMPORTED_IMPLIB_DEBUG "${sodium_LIBRARY_DEBUG}"
-        )
-        if (NOT (sodium_DLL_DEBUG MATCHES ".*-NOTFOUND"))
-            set_target_properties(sodium PROPERTIES
-                IMPORTED_LOCATION_DEBUG "${sodium_DLL_DEBUG}"
-            )
-        endif()
-        if (NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
-            set_target_properties(sodium PROPERTIES
-                IMPORTED_LOCATION_RELWITHDEBINFO "${sodium_DLL_RELEASE}"
-                IMPORTED_LOCATION_MINSIZEREL "${sodium_DLL_RELEASE}"
-                IMPORTED_LOCATION_RELEASE "${sodium_DLL_RELEASE}"
-            )
-        endif()
-    endif()
-endif()
diff --git a/build/fbcode_builder/CMake/FindZstd.cmake b/build/fbcode_builder/CMake/FindZstd.cmake
deleted file mode 100644
index 89300ddfd3987..0000000000000
--- a/build/fbcode_builder/CMake/FindZstd.cmake
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-#
-# - Try to find Facebook zstd library
-# This will define
-# ZSTD_FOUND
-# ZSTD_INCLUDE_DIR
-# ZSTD_LIBRARY
-#
-
-find_path(ZSTD_INCLUDE_DIR NAMES zstd.h)
-
-find_library(ZSTD_LIBRARY_DEBUG NAMES zstdd zstd_staticd)
-find_library(ZSTD_LIBRARY_RELEASE NAMES zstd zstd_static)
-
-include(SelectLibraryConfigurations)
-SELECT_LIBRARY_CONFIGURATIONS(ZSTD)
-
-include(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(
-    ZSTD DEFAULT_MSG
-    ZSTD_LIBRARY ZSTD_INCLUDE_DIR
-)
-
-if (ZSTD_FOUND)
-    message(STATUS "Found Zstd: ${ZSTD_LIBRARY}")
-endif()
-
-mark_as_advanced(ZSTD_INCLUDE_DIR ZSTD_LIBRARY)
diff --git a/build/fbcode_builder/CMake/RustStaticLibrary.cmake b/build/fbcode_builder/CMake/RustStaticLibrary.cmake
deleted file mode 100644
index dd57b2b3dcaa5..0000000000000
--- a/build/fbcode_builder/CMake/RustStaticLibrary.cmake
+++ /dev/null
@@ -1,316 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-
-include(FBCMakeParseArgs)
-
-set(
-  USE_CARGO_VENDOR AUTO CACHE STRING
-  "Download Rust Crates from an internally vendored location"
-)
-set_property(CACHE USE_CARGO_VENDOR PROPERTY STRINGS AUTO ON OFF)
-
-set(
-  GENERATE_CARGO_VENDOR_CONFIG AUTO CACHE STRING
-  "Whether to generate Rust cargo vendor config or use existing"
-)
-set_property(CACHE GENERATE_CARGO_VENDOR_CONFIG PROPERTY STRINGS AUTO ON OFF)
-
-set(RUST_VENDORED_CRATES_DIR "$ENV{RUST_VENDORED_CRATES_DIR}")
-
-if("${USE_CARGO_VENDOR}" STREQUAL "AUTO")
-  if(EXISTS "${RUST_VENDORED_CRATES_DIR}")
-    set(USE_CARGO_VENDOR ON)
-  else()
-    set(USE_CARGO_VENDOR OFF)
-  endif()
-endif()
-
-if("${GENERATE_CARGO_VENDOR_CONFIG}" STREQUAL "AUTO")
-  set(GENERATE_CARGO_VENDOR_CONFIG "${USE_CARGO_VENDOR}")
-endif()
-
-if(GENERATE_CARGO_VENDOR_CONFIG)
-  if(NOT EXISTS "${RUST_VENDORED_CRATES_DIR}")
-    message(
-      FATAL "vendored rust crates not present: "
-      "${RUST_VENDORED_CRATES_DIR}"
-    )
-  endif()
-
-  set(RUST_CARGO_HOME "${CMAKE_BINARY_DIR}/_cargo_home")
-  file(MAKE_DIRECTORY "${RUST_CARGO_HOME}")
-
-  file(
-    TO_NATIVE_PATH "${RUST_VENDORED_CRATES_DIR}"
-    ESCAPED_RUST_VENDORED_CRATES_DIR
-  )
-  string(
-    REPLACE "\\" "\\\\"
-    ESCAPED_RUST_VENDORED_CRATES_DIR
-    "${ESCAPED_RUST_VENDORED_CRATES_DIR}"
-  )
-  file(
-    WRITE "${RUST_CARGO_HOME}/config"
-    "[source.crates-io]\n"
-    "replace-with = \"vendored-sources\"\n"
-    "\n"
-    "[source.vendored-sources]\n"
-    "directory = \"${ESCAPED_RUST_VENDORED_CRATES_DIR}\"\n"
-  )
-endif()
-
-find_program(CARGO_COMMAND cargo REQUIRED)
-
-# Cargo is a build system in itself, and thus will try to take advantage of all
-# the cores on the system. Unfortunately, this conflicts with Ninja, since it
-# also tries to utilize all the cores. This can lead to a system that is
-# completely overloaded with compile jobs to the point where nothing else can
-# be achieved on the system.
-#
-# Let's inform Ninja of this fact so it won't try to spawn other jobs while
-# Rust being compiled.
-set_property(GLOBAL APPEND PROPERTY JOB_POOLS rust_job_pool=1)
-
-# This function creates an interface library target based on the static library
-# built by Cargo. It will call Cargo to build a staticlib and generate a CMake
-# interface library with it.
-#
-# This function requires `find_package(Python COMPONENTS Interpreter)`.
-#
-# You need to set `lib:crate-type = ["staticlib"]` in your Cargo.toml to make
-# Cargo build static library.
-#
-# ```cmake
-# rust_static_library(<TARGET> [CRATE <CRATE_NAME>] [FEATURES <FEATURE_NAME>])
-# ```
-#
-# Parameters:
-# - TARGET:
-#   Name of the target name. This function will create an interface library
-#   target with this name.
-# - CRATE_NAME:
-#   Name of the crate. This parameter is optional. If unspecified, it will
-#   fallback to `${TARGET}`.
-# - FEATURE_NAME:
-#   Name of the Rust feature to enable.
-#
-# This function creates two targets:
-# - "${TARGET}": an interface library target contains the static library built
-#   from Cargo.
-# - "${TARGET}.cargo": an internal custom target that invokes Cargo.
-#
-# If you are going to use this static library from C/C++, you will need to
-# write header files for the library (or generate with cbindgen) and bind these
-# headers with the interface library.
-#
-function(rust_static_library TARGET)
-  fb_cmake_parse_args(ARG "" "CRATE;FEATURES" "" "${ARGN}")
-
-  if(DEFINED ARG_CRATE)
-    set(crate_name "${ARG_CRATE}")
-  else()
-    set(crate_name "${TARGET}")
-  endif()
-  if(DEFINED ARG_FEATURES)
-    set(features --features ${ARG_FEATURES})
-  else()
-    set(features )
-  endif()
-
-  set(cargo_target "${TARGET}.cargo")
-  set(target_dir $<IF:$<CONFIG:Debug>,debug,release>)
-  set(staticlib_name "${CMAKE_STATIC_LIBRARY_PREFIX}${crate_name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
-  set(rust_staticlib "${CMAKE_CURRENT_BINARY_DIR}/${target_dir}/${staticlib_name}")
-
-  if(DEFINED ARG_FEATURES)
-    set(cargo_flags build $<IF:$<CONFIG:Debug>,,--release> -p ${crate_name} --features ${ARG_FEATURES})
-  else()
-    set(cargo_flags build $<IF:$<CONFIG:Debug>,,--release> -p ${crate_name})
-  endif()
-  if(USE_CARGO_VENDOR)
-    set(extra_cargo_env "CARGO_HOME=${RUST_CARGO_HOME}")
-    set(cargo_flags ${cargo_flags})
-  endif()
-
-  add_custom_target(
-    ${cargo_target}
-    COMMAND
-      "${CMAKE_COMMAND}" -E remove -f "${CMAKE_CURRENT_SOURCE_DIR}/Cargo.lock"
-    COMMAND
-      "${CMAKE_COMMAND}" -E env
-      "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}"
-      ${extra_cargo_env}
-      ${CARGO_COMMAND}
-      ${cargo_flags}
-    COMMENT "Building Rust crate '${crate_name}'..."
-    JOB_POOL rust_job_pool
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    BYPRODUCTS
-      "${CMAKE_CURRENT_BINARY_DIR}/debug/${staticlib_name}"
-      "${CMAKE_CURRENT_BINARY_DIR}/release/${staticlib_name}"
-  )
-
-  add_library(${TARGET} INTERFACE)
-  add_dependencies(${TARGET} ${cargo_target})
-  set_target_properties(
-    ${TARGET}
-    PROPERTIES
-      INTERFACE_STATICLIB_OUTPUT_PATH "${rust_staticlib}"
-      INTERFACE_INSTALL_LIBNAME
-        "${CMAKE_STATIC_LIBRARY_PREFIX}${crate_name}_rs${CMAKE_STATIC_LIBRARY_SUFFIX}"
-  )
-  target_link_libraries(
-    ${TARGET}
-    INTERFACE "$<BUILD_INTERFACE:${rust_staticlib}>"
-  )
-endfunction()
-
-# This function instructs CMake to define a target that will use `cargo build`
-# to build a bin crate referenced by the Cargo.toml file in the current source
-# directory.
-# It accepts a single `TARGET` parameter which will be passed as the package
-# name to `cargo build -p TARGET`. If binary has different name as package,
-# use optional flag BINARY_NAME to override it.
-# It also accepts a `FEATURES` parameter if you want to enable certain features
-# in your Rust binary.
-# The CMake target will be registered to build by default as part of the
-# ALL target.
-function(rust_executable TARGET)
-  fb_cmake_parse_args(ARG "" "BINARY_NAME;FEATURES" "" "${ARGN}")
-
-  set(crate_name "${TARGET}")
-  set(cargo_target "${TARGET}.cargo")
-  set(target_dir $<IF:$<CONFIG:Debug>,debug,release>)
-
-  if(DEFINED ARG_BINARY_NAME)
-    set(executable_name "${ARG_BINARY_NAME}${CMAKE_EXECUTABLE_SUFFIX}")
-  else()
-    set(executable_name "${crate_name}${CMAKE_EXECUTABLE_SUFFIX}")
-  endif()
-  if(DEFINED ARG_FEATURES)
-    set(features --features ${ARG_FEATURES})
-  else()
-    set(features )
-  endif()
-
-  if(DEFINED ARG_FEATURES)
-    set(cargo_flags build $<IF:$<CONFIG:Debug>,,--release> -p ${crate_name} --features ${ARG_FEATURES})
-  else()
-    set(cargo_flags build $<IF:$<CONFIG:Debug>,,--release> -p ${crate_name})
-  endif()
-  if(USE_CARGO_VENDOR)
-    set(extra_cargo_env "CARGO_HOME=${RUST_CARGO_HOME}")
-    set(cargo_flags ${cargo_flags})
-  endif()
-
-  add_custom_target(
-    ${cargo_target}
-    ALL
-    COMMAND
-      "${CMAKE_COMMAND}" -E remove -f "${CMAKE_CURRENT_SOURCE_DIR}/Cargo.lock"
-    COMMAND
-      "${CMAKE_COMMAND}" -E env
-      "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}"
-      ${extra_cargo_env}
-      ${CARGO_COMMAND}
-      ${cargo_flags}
-    COMMENT "Building Rust executable '${crate_name}'..."
-    JOB_POOL rust_job_pool
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    BYPRODUCTS
-      "${CMAKE_CURRENT_BINARY_DIR}/debug/${executable_name}"
-      "${CMAKE_CURRENT_BINARY_DIR}/release/${executable_name}"
-  )
-
-  set_property(TARGET "${cargo_target}"
-      PROPERTY EXECUTABLE "${CMAKE_CURRENT_BINARY_DIR}/${target_dir}/${executable_name}")
-endfunction()
-
-# This function can be used to install the executable generated by a prior
-# call to the `rust_executable` function.
-# It requires a `TARGET` parameter to identify the target to be installed,
-# and an optional `DESTINATION` parameter to specify the installation
-# directory.  If DESTINATION is not specified then the `bin` directory
-# will be assumed.
-function(install_rust_executable TARGET)
-  # Parse the arguments
-  set(one_value_args DESTINATION)
-  set(multi_value_args)
-  fb_cmake_parse_args(
-    ARG "" "${one_value_args}" "${multi_value_args}" "${ARGN}"
-  )
-
-  if(NOT DEFINED ARG_DESTINATION)
-    set(ARG_DESTINATION bin)
-  endif()
-
-  get_target_property(foo "${TARGET}.cargo" EXECUTABLE)
-
-  install(
-    PROGRAMS "${foo}"
-    DESTINATION "${ARG_DESTINATION}"
-  )
-endfunction()
-
-# This function installs the interface target generated from the function
-# `rust_static_library`. Use this function if you want to export your Rust
-# target to external CMake targets.
-#
-# ```cmake
-# install_rust_static_library(
-#   <TARGET>
-#   INSTALL_DIR <INSTALL_DIR>
-#   [EXPORT <EXPORT_NAME>]
-# )
-# ```
-#
-# Parameters:
-# - TARGET: Name of the Rust static library target.
-# - EXPORT_NAME: Name of the exported target.
-# - INSTALL_DIR: Path to the directory where this library will be installed.
-#
-function(install_rust_static_library TARGET)
-  fb_cmake_parse_args(ARG "" "EXPORT;INSTALL_DIR" "" "${ARGN}")
-
-  get_property(
-    staticlib_output_path
-    TARGET "${TARGET}"
-    PROPERTY INTERFACE_STATICLIB_OUTPUT_PATH
-  )
-  get_property(
-    staticlib_output_name
-    TARGET "${TARGET}"
-    PROPERTY INTERFACE_INSTALL_LIBNAME
-  )
-
-  if(NOT DEFINED staticlib_output_path)
-    message(FATAL_ERROR "Not a rust_static_library target.")
-  endif()
-
-  if(NOT DEFINED ARG_INSTALL_DIR)
-    message(FATAL_ERROR "Missing required argument.")
-  endif()
-
-  if(DEFINED ARG_EXPORT)
-    set(install_export_args EXPORT "${ARG_EXPORT}")
-  endif()
-
-  set(install_interface_dir "${ARG_INSTALL_DIR}")
-  if(NOT IS_ABSOLUTE "${install_interface_dir}")
-    set(install_interface_dir "\${_IMPORT_PREFIX}/${install_interface_dir}")
-  endif()
-
-  target_link_libraries(
-    ${TARGET} INTERFACE
-    "$<INSTALL_INTERFACE:${install_interface_dir}/${staticlib_output_name}>"
-  )
-  install(
-    TARGETS ${TARGET}
-    ${install_export_args}
-    LIBRARY DESTINATION ${ARG_INSTALL_DIR}
-  )
-  install(
-    FILES ${staticlib_output_path}
-    RENAME ${staticlib_output_name}
-    DESTINATION ${ARG_INSTALL_DIR}
-  )
-endfunction()
diff --git a/build/fbcode_builder/CMake/fb_py_test_main.py b/build/fbcode_builder/CMake/fb_py_test_main.py
deleted file mode 100644
index 41626181b1ec8..0000000000000
--- a/build/fbcode_builder/CMake/fb_py_test_main.py
+++ /dev/null
@@ -1,819 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-"""
-This file contains the main module code for Python test programs.
-"""
-
-
-import contextlib
-import ctypes
-import fnmatch
-import json
-import logging
-import optparse
-import os
-import platform
-import re
-import sys
-import tempfile
-import time
-import traceback
-import unittest
-import warnings
-
-# Hide warning about importing "imp"; remove once python2 is gone.
-with warnings.catch_warnings():
-    warnings.filterwarnings("ignore", category=DeprecationWarning)
-    import imp
-
-try:
-    from StringIO import StringIO
-except ImportError:
-    from io import StringIO
-try:
-    import coverage
-except ImportError:
-    coverage = None  # type: ignore
-try:
-    from importlib.machinery import SourceFileLoader
-except ImportError:
-    SourceFileLoader = None  # type: ignore
-
-
-class get_cpu_instr_counter(object):
-    def read(self):
-        # TODO
-        return 0
-
-
-EXIT_CODE_SUCCESS = 0
-EXIT_CODE_TEST_FAILURE = 70
-
-
-class TestStatus(object):
-
-    ABORTED = "FAILURE"
-    PASSED = "SUCCESS"
-    FAILED = "FAILURE"
-    EXPECTED_FAILURE = "SUCCESS"
-    UNEXPECTED_SUCCESS = "FAILURE"
-    SKIPPED = "ASSUMPTION_VIOLATION"
-
-
-class PathMatcher(object):
-    def __init__(self, include_patterns, omit_patterns):
-        self.include_patterns = include_patterns
-        self.omit_patterns = omit_patterns
-
-    def omit(self, path):
-        """
-        Omit iff matches any of the omit_patterns or the include patterns are
-        not empty and none is matched
-        """
-        path = os.path.realpath(path)
-        return any(fnmatch.fnmatch(path, p) for p in self.omit_patterns) or (
-            self.include_patterns
-            and not any(fnmatch.fnmatch(path, p) for p in self.include_patterns)
-        )
-
-    def include(self, path):
-        return not self.omit(path)
-
-
-class DebugWipeFinder(object):
-    """
-    PEP 302 finder that uses a DebugWipeLoader for all files which do not need
-    coverage
-    """
-
-    def __init__(self, matcher):
-        self.matcher = matcher
-
-    def find_module(self, fullname, path=None):
-        _, _, basename = fullname.rpartition(".")
-        try:
-            fd, pypath, (_, _, kind) = imp.find_module(basename, path)
-        except Exception:
-            # Finding without hooks using the imp module failed. One reason
-            # could be that there is a zip file on sys.path. The imp module
-            # does not support loading from there. Leave finding this module to
-            # the others finders in sys.meta_path.
-            return None
-
-        if hasattr(fd, "close"):
-            fd.close()
-        if kind != imp.PY_SOURCE:
-            return None
-        if self.matcher.include(pypath):
-            return None
-
-        """
-        This is defined to match CPython's PyVarObject struct
-        """
-
-        class PyVarObject(ctypes.Structure):
-            _fields_ = [
-                ("ob_refcnt", ctypes.c_long),
-                ("ob_type", ctypes.c_void_p),
-                ("ob_size", ctypes.c_ulong),
-            ]
-
-        class DebugWipeLoader(SourceFileLoader):
-            """
-            PEP302 loader that zeros out debug information before execution
-            """
-
-            def get_code(self, fullname):
-                code = super(DebugWipeLoader, self).get_code(fullname)
-                if code:
-                    # Ideally we'd do
-                    # code.co_lnotab = b''
-                    # But code objects are READONLY. Not to worry though; we'll
-                    # directly modify CPython's object
-                    code_impl = PyVarObject.from_address(id(code.co_lnotab))
-                    code_impl.ob_size = 0
-                return code
-
-        return DebugWipeLoader(fullname, pypath)
-
-
-def optimize_for_coverage(cov, include_patterns, omit_patterns):
-    """
-    We get better performance if we zero out debug information for files which
-    we're not interested in. Only available in CPython 3.3+
-    """
-    matcher = PathMatcher(include_patterns, omit_patterns)
-    if SourceFileLoader and platform.python_implementation() == "CPython":
-        sys.meta_path.insert(0, DebugWipeFinder(matcher))
-
-
-class TeeStream(object):
-    def __init__(self, *streams):
-        self._streams = streams
-
-    def write(self, data):
-        for stream in self._streams:
-            stream.write(data)
-
-    def flush(self):
-        for stream in self._streams:
-            stream.flush()
-
-    def isatty(self):
-        return False
-
-
-class CallbackStream(object):
-    def __init__(self, callback, bytes_callback=None, orig=None):
-        self._callback = callback
-        self._fileno = orig.fileno() if orig else None
-
-        # Python 3 APIs:
-        # - `encoding` is a string holding the encoding name
-        # - `errors` is a string holding the error-handling mode for encoding
-        # - `buffer` should look like an io.BufferedIOBase object
-
-        self.errors = orig.errors if orig else None
-        if bytes_callback:
-            # those members are only on the io.TextIOWrapper
-            self.encoding = orig.encoding if orig else "UTF-8"
-            self.buffer = CallbackStream(bytes_callback, orig=orig)
-
-    def write(self, data):
-        self._callback(data)
-
-    def flush(self):
-        pass
-
-    def isatty(self):
-        return False
-
-    def fileno(self):
-        return self._fileno
-
-
-class BuckTestResult(unittest._TextTestResult):
-    """
-    Our own TestResult class that outputs data in a format that can be easily
-    parsed by buck's test runner.
-    """
-
-    _instr_counter = get_cpu_instr_counter()
-
-    def __init__(
-        self, stream, descriptions, verbosity, show_output, main_program, suite
-    ):
-        super(BuckTestResult, self).__init__(stream, descriptions, verbosity)
-        self._main_program = main_program
-        self._suite = suite
-        self._results = []
-        self._current_test = None
-        self._saved_stdout = sys.stdout
-        self._saved_stderr = sys.stderr
-        self._show_output = show_output
-
-    def getResults(self):
-        return self._results
-
-    def startTest(self, test):
-        super(BuckTestResult, self).startTest(test)
-
-        # Pass in the real stdout and stderr filenos.  We can't really do much
-        # here to intercept callers who directly operate on these fileno
-        # objects.
-        sys.stdout = CallbackStream(
-            self.addStdout, self.addStdoutBytes, orig=sys.stdout
-        )
-        sys.stderr = CallbackStream(
-            self.addStderr, self.addStderrBytes, orig=sys.stderr
-        )
-        self._current_test = test
-        self._test_start_time = time.time()
-        self._current_status = TestStatus.ABORTED
-        self._messages = []
-        self._stacktrace = None
-        self._stdout = ""
-        self._stderr = ""
-        self._start_instr_count = self._instr_counter.read()
-
-    def _find_next_test(self, suite):
-        """
-        Find the next test that has not been run.
-        """
-
-        for test in suite:
-
-            # We identify test suites by test that are iterable (as is done in
-            # the builtin python test harness).  If we see one, recurse on it.
-            if hasattr(test, "__iter__"):
-                test = self._find_next_test(test)
-
-            # The builtin python test harness sets test references to `None`
-            # after they have run, so we know we've found the next test up
-            # if it's not `None`.
-            if test is not None:
-                return test
-
-    def stopTest(self, test):
-        sys.stdout = self._saved_stdout
-        sys.stderr = self._saved_stderr
-
-        super(BuckTestResult, self).stopTest(test)
-
-        # If a failure occurred during module/class setup, then this "test" may
-        # actually be a `_ErrorHolder`, which doesn't contain explicit info
-        # about the upcoming test.  Since we really only care about the test
-        # name field (i.e. `_testMethodName`), we use that to detect an actual
-        # test cases, and fall back to looking the test up from the suite
-        # otherwise.
-        if not hasattr(test, "_testMethodName"):
-            test = self._find_next_test(self._suite)
-
-        result = {
-            "testCaseName": "{0}.{1}".format(
-                test.__class__.__module__, test.__class__.__name__
-            ),
-            "testCase": test._testMethodName,
-            "type": self._current_status,
-            "time": int((time.time() - self._test_start_time) * 1000),
-            "message": os.linesep.join(self._messages),
-            "stacktrace": self._stacktrace,
-            "stdOut": self._stdout,
-            "stdErr": self._stderr,
-        }
-
-        # TestPilot supports an instruction count field.
-        if "TEST_PILOT" in os.environ:
-            result["instrCount"] = (
-                int(self._instr_counter.read() - self._start_instr_count),
-            )
-
-        self._results.append(result)
-        self._current_test = None
-
-    def stopTestRun(self):
-        cov = self._main_program.get_coverage()
-        if cov is not None:
-            self._results.append({"coverage": cov})
-
-    @contextlib.contextmanager
-    def _withTest(self, test):
-        self.startTest(test)
-        yield
-        self.stopTest(test)
-
-    def _setStatus(self, test, status, message=None, stacktrace=None):
-        assert test == self._current_test
-        self._current_status = status
-        self._stacktrace = stacktrace
-        if message is not None:
-            if message.endswith(os.linesep):
-                message = message[:-1]
-            self._messages.append(message)
-
-    def setStatus(self, test, status, message=None, stacktrace=None):
-        # addError() may be called outside of a test if one of the shared
-        # fixtures (setUpClass/tearDownClass/setUpModule/tearDownModule)
-        # throws an error.
-        #
-        # In this case, create a fake test result to record the error.
-        if self._current_test is None:
-            with self._withTest(test):
-                self._setStatus(test, status, message, stacktrace)
-        else:
-            self._setStatus(test, status, message, stacktrace)
-
-    def setException(self, test, status, excinfo):
-        exctype, value, tb = excinfo
-        self.setStatus(
-            test,
-            status,
-            "{0}: {1}".format(exctype.__name__, value),
-            "".join(traceback.format_tb(tb)),
-        )
-
-    def addSuccess(self, test):
-        super(BuckTestResult, self).addSuccess(test)
-        self.setStatus(test, TestStatus.PASSED)
-
-    def addError(self, test, err):
-        super(BuckTestResult, self).addError(test, err)
-        self.setException(test, TestStatus.ABORTED, err)
-
-    def addFailure(self, test, err):
-        super(BuckTestResult, self).addFailure(test, err)
-        self.setException(test, TestStatus.FAILED, err)
-
-    def addSkip(self, test, reason):
-        super(BuckTestResult, self).addSkip(test, reason)
-        self.setStatus(test, TestStatus.SKIPPED, "Skipped: %s" % (reason,))
-
-    def addExpectedFailure(self, test, err):
-        super(BuckTestResult, self).addExpectedFailure(test, err)
-        self.setException(test, TestStatus.EXPECTED_FAILURE, err)
-
-    def addUnexpectedSuccess(self, test):
-        super(BuckTestResult, self).addUnexpectedSuccess(test)
-        self.setStatus(test, TestStatus.UNEXPECTED_SUCCESS, "Unexpected success")
-
-    def addStdout(self, val):
-        self._stdout += val
-        if self._show_output:
-            self._saved_stdout.write(val)
-            self._saved_stdout.flush()
-
-    def addStdoutBytes(self, val):
-        string = val.decode("utf-8", errors="backslashreplace")
-        self.addStdout(string)
-
-    def addStderr(self, val):
-        self._stderr += val
-        if self._show_output:
-            self._saved_stderr.write(val)
-            self._saved_stderr.flush()
-
-    def addStderrBytes(self, val):
-        string = val.decode("utf-8", errors="backslashreplace")
-        self.addStderr(string)
-
-
-class BuckTestRunner(unittest.TextTestRunner):
-    def __init__(self, main_program, suite, show_output=True, **kwargs):
-        super(BuckTestRunner, self).__init__(**kwargs)
-        self.show_output = show_output
-        self._main_program = main_program
-        self._suite = suite
-
-    def _makeResult(self):
-        return BuckTestResult(
-            self.stream,
-            self.descriptions,
-            self.verbosity,
-            self.show_output,
-            self._main_program,
-            self._suite,
-        )
-
-
-def _format_test_name(test_class, attrname):
-    return "{0}.{1}.{2}".format(test_class.__module__, test_class.__name__, attrname)
-
-
-class StderrLogHandler(logging.StreamHandler):
-    """
-    This class is very similar to logging.StreamHandler, except that it
-    always uses the current sys.stderr object.
-
-    StreamHandler caches the current sys.stderr object when it is constructed.
-    This makes it behave poorly in unit tests, which may replace sys.stderr
-    with a StringIO buffer during tests.  The StreamHandler will continue using
-    the old sys.stderr object instead of the desired StringIO buffer.
-    """
-
-    def __init__(self):
-        logging.Handler.__init__(self)
-
-    @property
-    def stream(self):
-        return sys.stderr
-
-
-class RegexTestLoader(unittest.TestLoader):
-    def __init__(self, regex=None):
-        self.regex = regex
-        super(RegexTestLoader, self).__init__()
-
-    def getTestCaseNames(self, testCaseClass):
-        """
-        Return a sorted sequence of method names found within testCaseClass
-        """
-
-        testFnNames = super(RegexTestLoader, self).getTestCaseNames(testCaseClass)
-        if self.regex is None:
-            return testFnNames
-        robj = re.compile(self.regex)
-        matched = []
-        for attrname in testFnNames:
-            fullname = _format_test_name(testCaseClass, attrname)
-            if robj.search(fullname):
-                matched.append(attrname)
-        return matched
-
-
-class Loader(object):
-
-    suiteClass = unittest.TestSuite
-
-    def __init__(self, modules, regex=None):
-        self.modules = modules
-        self.regex = regex
-
-    def load_all(self):
-        loader = RegexTestLoader(self.regex)
-        test_suite = self.suiteClass()
-        for module_name in self.modules:
-            __import__(module_name, level=0)
-            module = sys.modules[module_name]
-            module_suite = loader.loadTestsFromModule(module)
-            test_suite.addTest(module_suite)
-        return test_suite
-
-    def load_args(self, args):
-        loader = RegexTestLoader(self.regex)
-
-        suites = []
-        for arg in args:
-            suite = loader.loadTestsFromName(arg)
-            # loadTestsFromName() can only process names that refer to
-            # individual test functions or modules.  It can't process package
-            # names.  If there were no module/function matches, check to see if
-            # this looks like a package name.
-            if suite.countTestCases() != 0:
-                suites.append(suite)
-                continue
-
-            # Load all modules whose name is <arg>.<something>
-            prefix = arg + "."
-            for module in self.modules:
-                if module.startswith(prefix):
-                    suite = loader.loadTestsFromName(module)
-                    suites.append(suite)
-
-        return loader.suiteClass(suites)
-
-
-_COVERAGE_INI = """\
-[report]
-exclude_lines =
-    pragma: no cover
-    pragma: nocover
-    pragma:.*no${PLATFORM}
-    pragma:.*no${PY_IMPL}${PY_MAJOR}${PY_MINOR}
-    pragma:.*no${PY_IMPL}${PY_MAJOR}
-    pragma:.*nopy${PY_MAJOR}
-    pragma:.*nopy${PY_MAJOR}${PY_MINOR}
-"""
-
-
-class MainProgram(object):
-    """
-    This class implements the main program.  It can be subclassed by
-    users who wish to customize some parts of the main program.
-    (Adding additional command line options, customizing test loading, etc.)
-    """
-
-    DEFAULT_VERBOSITY = 2
-
-    def __init__(self, argv):
-        self.init_option_parser()
-        self.parse_options(argv)
-        self.setup_logging()
-
-    def init_option_parser(self):
-        usage = "%prog [options] [TEST] ..."
-        op = optparse.OptionParser(usage=usage, add_help_option=False)
-        self.option_parser = op
-
-        op.add_option(
-            "--hide-output",
-            dest="show_output",
-            action="store_false",
-            default=True,
-            help="Suppress data that tests print to stdout/stderr, and only "
-            "show it if the test fails.",
-        )
-        op.add_option(
-            "-o",
-            "--output",
-            help="Write results to a file in a JSON format to be read by Buck",
-        )
-        op.add_option(
-            "-f",
-            "--failfast",
-            action="store_true",
-            default=False,
-            help="Stop after the first failure",
-        )
-        op.add_option(
-            "-l",
-            "--list-tests",
-            action="store_true",
-            dest="list",
-            default=False,
-            help="List tests and exit",
-        )
-        op.add_option(
-            "-r",
-            "--regex",
-            default=None,
-            help="Regex to apply to tests, to only run those tests",
-        )
-        op.add_option(
-            "--collect-coverage",
-            action="store_true",
-            default=False,
-            help="Collect test coverage information",
-        )
-        op.add_option(
-            "--coverage-include",
-            default="*",
-            help='File globs to include in converage (split by ",")',
-        )
-        op.add_option(
-            "--coverage-omit",
-            default="",
-            help='File globs to omit from converage (split by ",")',
-        )
-        op.add_option(
-            "--logger",
-            action="append",
-            metavar="<category>=<level>",
-            default=[],
-            help="Configure log levels for specific logger categories",
-        )
-        op.add_option(
-            "-q",
-            "--quiet",
-            action="count",
-            default=0,
-            help="Decrease the verbosity (may be specified multiple times)",
-        )
-        op.add_option(
-            "-v",
-            "--verbosity",
-            action="count",
-            default=self.DEFAULT_VERBOSITY,
-            help="Increase the verbosity (may be specified multiple times)",
-        )
-        op.add_option(
-            "-?", "--help", action="help", help="Show this help message and exit"
-        )
-
-    def parse_options(self, argv):
-        self.options, self.test_args = self.option_parser.parse_args(argv[1:])
-        self.options.verbosity -= self.options.quiet
-
-        if self.options.collect_coverage and coverage is None:
-            self.option_parser.error("coverage module is not available")
-        self.options.coverage_include = self.options.coverage_include.split(",")
-        if self.options.coverage_omit == "":
-            self.options.coverage_omit = []
-        else:
-            self.options.coverage_omit = self.options.coverage_omit.split(",")
-
-    def setup_logging(self):
-        # Configure the root logger to log at INFO level.
-        # This is similar to logging.basicConfig(), but uses our
-        # StderrLogHandler instead of a StreamHandler.
-        fmt = logging.Formatter("%(pathname)s:%(lineno)s: %(message)s")
-        log_handler = StderrLogHandler()
-        log_handler.setFormatter(fmt)
-        root_logger = logging.getLogger()
-        root_logger.addHandler(log_handler)
-        root_logger.setLevel(logging.INFO)
-
-        level_names = {
-            "debug": logging.DEBUG,
-            "info": logging.INFO,
-            "warn": logging.WARNING,
-            "warning": logging.WARNING,
-            "error": logging.ERROR,
-            "critical": logging.CRITICAL,
-            "fatal": logging.FATAL,
-        }
-
-        for value in self.options.logger:
-            parts = value.rsplit("=", 1)
-            if len(parts) != 2:
-                self.option_parser.error(
-                    "--logger argument must be of the "
-                    "form <name>=<level>: %s" % value
-                )
-            name = parts[0]
-            level_name = parts[1].lower()
-            level = level_names.get(level_name)
-            if level is None:
-                self.option_parser.error(
-                    "invalid log level %r for log " "category %s" % (parts[1], name)
-                )
-            logging.getLogger(name).setLevel(level)
-
-    def create_loader(self):
-        import __test_modules__
-
-        return Loader(__test_modules__.TEST_MODULES, self.options.regex)
-
-    def load_tests(self):
-        loader = self.create_loader()
-        if self.options.collect_coverage:
-            self.start_coverage()
-            include = self.options.coverage_include
-            omit = self.options.coverage_omit
-            if include and "*" not in include:
-                optimize_for_coverage(self.cov, include, omit)
-
-        if self.test_args:
-            suite = loader.load_args(self.test_args)
-        else:
-            suite = loader.load_all()
-        if self.options.collect_coverage:
-            self.cov.start()
-        return suite
-
-    def get_tests(self, test_suite):
-        tests = []
-
-        for test in test_suite:
-            if isinstance(test, unittest.TestSuite):
-                tests.extend(self.get_tests(test))
-            else:
-                tests.append(test)
-
-        return tests
-
-    def run(self):
-        test_suite = self.load_tests()
-
-        if self.options.list:
-            for test in self.get_tests(test_suite):
-                method_name = getattr(test, "_testMethodName", "")
-                name = _format_test_name(test.__class__, method_name)
-                print(name)
-            return EXIT_CODE_SUCCESS
-        else:
-            result = self.run_tests(test_suite)
-            if self.options.output is not None:
-                with open(self.options.output, "w") as f:
-                    json.dump(result.getResults(), f, indent=4, sort_keys=True)
-            if not result.wasSuccessful():
-                return EXIT_CODE_TEST_FAILURE
-            return EXIT_CODE_SUCCESS
-
-    def run_tests(self, test_suite):
-        # Install a signal handler to catch Ctrl-C and display the results
-        # (but only if running >2.6).
-        if sys.version_info[0] > 2 or sys.version_info[1] > 6:
-            unittest.installHandler()
-
-        # Run the tests
-        runner = BuckTestRunner(
-            self,
-            test_suite,
-            verbosity=self.options.verbosity,
-            show_output=self.options.show_output,
-        )
-        result = runner.run(test_suite)
-
-        if self.options.collect_coverage and self.options.show_output:
-            self.cov.stop()
-            try:
-                self.cov.report(file=sys.stdout)
-            except coverage.misc.CoverageException:
-                print("No lines were covered, potentially restricted by file filters")
-
-        return result
-
-    def get_abbr_impl(self):
-        """Return abbreviated implementation name."""
-        impl = platform.python_implementation()
-        if impl == "PyPy":
-            return "pp"
-        elif impl == "Jython":
-            return "jy"
-        elif impl == "IronPython":
-            return "ip"
-        elif impl == "CPython":
-            return "cp"
-        else:
-            raise RuntimeError("unknown python runtime")
-
-    def start_coverage(self):
-        if not self.options.collect_coverage:
-            return
-
-        with tempfile.NamedTemporaryFile("w", delete=False) as coverage_ini:
-            coverage_ini.write(_COVERAGE_INI)
-            self._coverage_ini_path = coverage_ini.name
-
-        # Keep the original working dir in case tests use os.chdir
-        self._original_working_dir = os.getcwd()
-
-        # for coverage config ignores by platform/python version
-        os.environ["PLATFORM"] = sys.platform
-        os.environ["PY_IMPL"] = self.get_abbr_impl()
-        os.environ["PY_MAJOR"] = str(sys.version_info.major)
-        os.environ["PY_MINOR"] = str(sys.version_info.minor)
-
-        self.cov = coverage.Coverage(
-            include=self.options.coverage_include,
-            omit=self.options.coverage_omit,
-            config_file=coverage_ini.name,
-        )
-        self.cov.erase()
-        self.cov.start()
-
-    def get_coverage(self):
-        if not self.options.collect_coverage:
-            return None
-
-        try:
-            os.remove(self._coverage_ini_path)
-        except OSError:
-            pass  # Better to litter than to fail the test
-
-        # Switch back to the original working directory.
-        os.chdir(self._original_working_dir)
-
-        result = {}
-
-        self.cov.stop()
-
-        try:
-            f = StringIO()
-            self.cov.report(file=f)
-            lines = f.getvalue().split("\n")
-        except coverage.misc.CoverageException:
-            # Nothing was covered. That's fine by us
-            return result
-
-        # N.B.: the format of the coverage library's output differs
-        # depending on whether one or more files are in the results
-        for line in lines[2:]:
-            if line.strip("-") == "":
-                break
-            r = line.split()[0]
-            analysis = self.cov.analysis2(r)
-            covString = self.convert_to_diff_cov_str(analysis)
-            if covString:
-                result[r] = covString
-
-        return result
-
-    def convert_to_diff_cov_str(self, analysis):
-        # Info on the format of analysis:
-        # http://nedbatchelder.com/code/coverage/api.html
-        if not analysis:
-            return None
-        numLines = max(
-            analysis[1][-1] if len(analysis[1]) else 0,
-            analysis[2][-1] if len(analysis[2]) else 0,
-            analysis[3][-1] if len(analysis[3]) else 0,
-        )
-        lines = ["N"] * numLines
-        for l in analysis[1]:
-            lines[l - 1] = "C"
-        for l in analysis[2]:
-            lines[l - 1] = "X"
-        for l in analysis[3]:
-            lines[l - 1] = "U"
-        return "".join(lines)
-
-
-def main(argv):
-    return MainProgram(sys.argv).run()
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))
diff --git a/build/fbcode_builder/CMake/fb_py_win_main.c b/build/fbcode_builder/CMake/fb_py_win_main.c
deleted file mode 100644
index 85a95b31563f8..0000000000000
--- a/build/fbcode_builder/CMake/fb_py_win_main.c
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-
-#define WIN32_LEAN_AND_MEAN
-
-#include <Windows.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#define PATH_SIZE 32768
-
-typedef int (*Py_Main)(int, wchar_t**);
-
-// Add the given path to Windows's DLL search path.
-// For Windows DLL search path resolution, see:
-// https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order
-void add_search_path(const wchar_t* path) {
-  wchar_t buffer[PATH_SIZE];
-  wchar_t** lppPart = NULL;
-
-  if (!GetFullPathNameW(path, PATH_SIZE, buffer, lppPart)) {
-    fwprintf(
-        stderr,
-        L"warning: %d unable to expand path %s\n",
-        GetLastError(),
-        path);
-    return;
-  }
-
-  if (!AddDllDirectory(buffer)) {
-    DWORD error = GetLastError();
-    if (error != ERROR_FILE_NOT_FOUND) {
-      fwprintf(
-          stderr,
-          L"warning: %d unable to set DLL search path for %s\n",
-          GetLastError(),
-          path);
-    }
-  }
-}
-
-int locate_py_main(int argc, wchar_t** argv) {
-  /*
-   * We have to dynamically locate Python3.dll because we may be loading a
-   * Python native module while running. If that module is built with a
-   * different Python version, we will end up a DLL import error. To resolve
-   * this, we can either ship an embedded version of Python with us or
-   * dynamically look up existing Python distribution installed on user's
-   * machine. This way, we should be able to get a consistent version of
-   * Python3.dll and .pyd modules.
-   */
-  HINSTANCE python_dll;
-  Py_Main pymain;
-
-  // last added directory has highest priority
-  add_search_path(L"C:\\Python36\\");
-  add_search_path(L"C:\\tools\\fb-python\\fb-python36\\");
-  add_search_path(L"C:\\Python37\\");
-  add_search_path(L"C:\\tools\\fb-python\\fb-python37\\");
-  add_search_path(L"C:\\Python38\\");
-  add_search_path(L"C:\\tools\\fb-python\\fb-python38\\");
-  // TODO(T123615656): Re-enable Python 3.9 after the fix
-  // add_search_path(L"C:\\tools\\fb-python\\fb-python39\\");
-
-  python_dll =
-      LoadLibraryExW(L"python3.dll", NULL, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
-
-  int returncode = 0;
-  if (python_dll != NULL) {
-    pymain = (Py_Main)GetProcAddress(python_dll, "Py_Main");
-
-    if (pymain != NULL) {
-      returncode = (pymain)(argc, argv);
-    } else {
-      fprintf(stderr, "error: %d unable to load Py_Main\n", GetLastError());
-    }
-
-    FreeLibrary(python_dll);
-  } else {
-    fprintf(stderr, "error: %d unable to locate python3.dll\n", GetLastError());
-    return 1;
-  }
-  return returncode;
-}
-
-int wmain() {
-  /*
-   * This executable will be prepended to the start of a Python ZIP archive.
-   * Python will be able to directly execute the ZIP archive, so we simply
-   * need to tell Py_Main() to run our own file.  Duplicate the argument list
-   * and add our file name to the beginning to tell Python what file to invoke.
-   */
-  wchar_t** pyargv = malloc(sizeof(wchar_t*) * (__argc + 1));
-  if (!pyargv) {
-    fprintf(stderr, "error: failed to allocate argument vector\n");
-    return 1;
-  }
-
-  /* Py_Main wants the wide character version of the argv so we pull those
-   * values from the global __wargv array that has been prepared by MSVCRT.
-   *
-   * In order for the zipapp to run we need to insert an extra argument in
-   * the front of the argument vector that points to ourselves.
-   *
-   * An additional complication is that, depending on who prepared the argument
-   * string used to start our process, the computed __wargv[0] can be a simple
-   * shell word like `watchman-wait` which is normally resolved together with
-   * the PATH by the shell.
-   * That unresolved path isn't sufficient to start the zipapp on windows;
-   * we need the fully qualified path.
-   *
-   * Given:
-   * __wargv == {"watchman-wait", "-h"}
-   *
-   * we want to pass the following to Py_Main:
-   *
-   * {
-   *   "z:\build\watchman\python\watchman-wait.exe",
-   *   "z:\build\watchman\python\watchman-wait.exe",
-   *   "-h"
-   * }
-   */
-  wchar_t full_path_to_argv0[PATH_SIZE];
-  DWORD len = GetModuleFileNameW(NULL, full_path_to_argv0, PATH_SIZE);
-  if (len == 0 ||
-      len == PATH_SIZE && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
-    fprintf(
-        stderr,
-        "error: %d while retrieving full path to this executable\n",
-        GetLastError());
-    return 1;
-  }
-
-  for (int n = 1; n < __argc; ++n) {
-    pyargv[n + 1] = __wargv[n];
-  }
-  pyargv[0] = full_path_to_argv0;
-  pyargv[1] = full_path_to_argv0;
-
-  return locate_py_main(__argc + 1, pyargv);
-}
diff --git a/build/fbcode_builder/CMake/make_fbpy_archive.py b/build/fbcode_builder/CMake/make_fbpy_archive.py
deleted file mode 100755
index 3724feb2183f7..0000000000000
--- a/build/fbcode_builder/CMake/make_fbpy_archive.py
+++ /dev/null
@@ -1,327 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-import argparse
-import collections
-import errno
-import os
-import shutil
-import sys
-import tempfile
-import zipapp
-
-MANIFEST_SEPARATOR = " :: "
-MANIFEST_HEADER_V1 = "FBPY_MANIFEST 1\n"
-
-
-class UsageError(Exception):
-    def __init__(self, message):
-        self.message = message
-
-    def __str__(self):
-        return self.message
-
-
-class BadManifestError(UsageError):
-    def __init__(self, path, line_num, message):
-        full_msg = "%s:%s: %s" % (path, line_num, message)
-        super().__init__(full_msg)
-        self.path = path
-        self.line_num = line_num
-        self.raw_message = message
-
-
-PathInfo = collections.namedtuple(
-    "PathInfo", ("src", "dest", "manifest_path", "manifest_line")
-)
-
-
-def parse_manifest(manifest, path_map):
-    bad_prefix = ".." + os.path.sep
-    manifest_dir = os.path.dirname(manifest)
-    with open(manifest, "r") as f:
-        line_num = 1
-        line = f.readline()
-        if line != MANIFEST_HEADER_V1:
-            raise BadManifestError(
-                manifest, line_num, "Unexpected manifest file header"
-            )
-
-        for line in f:
-            line_num += 1
-            if line.startswith("#"):
-                continue
-            line = line.rstrip("\n")
-            parts = line.split(MANIFEST_SEPARATOR)
-            if len(parts) != 2:
-                msg = "line must be of the form SRC %s DEST" % MANIFEST_SEPARATOR
-                raise BadManifestError(manifest, line_num, msg)
-            src, dest = parts
-            dest = os.path.normpath(dest)
-            if dest.startswith(bad_prefix):
-                msg = "destination path starts with %s: %s" % (bad_prefix, dest)
-                raise BadManifestError(manifest, line_num, msg)
-
-            if not os.path.isabs(src):
-                src = os.path.normpath(os.path.join(manifest_dir, src))
-
-            if dest in path_map:
-                prev_info = path_map[dest]
-                msg = (
-                    "multiple source paths specified for destination "
-                    "path %s.  Previous source was %s from %s:%s"
-                    % (
-                        dest,
-                        prev_info.src,
-                        prev_info.manifest_path,
-                        prev_info.manifest_line,
-                    )
-                )
-                raise BadManifestError(manifest, line_num, msg)
-
-            info = PathInfo(
-                src=src,
-                dest=dest,
-                manifest_path=manifest,
-                manifest_line=line_num,
-            )
-            path_map[dest] = info
-
-
-def populate_install_tree(inst_dir, path_map):
-    os.mkdir(inst_dir)
-    dest_dirs = {"": False}
-
-    def make_dest_dir(path):
-        if path in dest_dirs:
-            return
-        parent = os.path.dirname(path)
-        make_dest_dir(parent)
-        abs_path = os.path.join(inst_dir, path)
-        os.mkdir(abs_path)
-        dest_dirs[path] = False
-
-    def install_file(info):
-        dir_name, base_name = os.path.split(info.dest)
-        make_dest_dir(dir_name)
-        if base_name == "__init__.py":
-            dest_dirs[dir_name] = True
-        abs_dest = os.path.join(inst_dir, info.dest)
-        shutil.copy2(info.src, abs_dest)
-
-    # Copy all of the destination files
-    for info in path_map.values():
-        install_file(info)
-
-    # Create __init__ files in any directories that don't have them.
-    for dir_path, has_init in dest_dirs.items():
-        if has_init:
-            continue
-        init_path = os.path.join(inst_dir, dir_path, "__init__.py")
-        with open(init_path, "w"):
-            pass
-
-
-def build_zipapp(args, path_map):
-    """Create a self executing python binary using Python 3's built-in
-    zipapp module.
-
-    This type of Python binary is relatively simple, as zipapp is part of the
-    standard library, but it does not support native language extensions
-    (.so/.dll files).
-    """
-    dest_dir = os.path.dirname(args.output)
-    with tempfile.TemporaryDirectory(prefix="make_fbpy.", dir=dest_dir) as tmpdir:
-        inst_dir = os.path.join(tmpdir, "tree")
-        populate_install_tree(inst_dir, path_map)
-
-        tmp_output = os.path.join(tmpdir, "output.exe")
-        zipapp.create_archive(
-            inst_dir, target=tmp_output, interpreter=args.python, main=args.main
-        )
-        os.replace(tmp_output, args.output)
-
-
-def create_main_module(args, inst_dir, path_map):
-    if not args.main:
-        assert "__main__.py" in path_map
-        return
-
-    dest_path = os.path.join(inst_dir, "__main__.py")
-    main_module, main_fn = args.main.split(":")
-    main_contents = """\
-#!{python}
-
-if __name__ == "__main__":
-    import {main_module}
-    {main_module}.{main_fn}()
-""".format(
-        python=args.python, main_module=main_module, main_fn=main_fn
-    )
-    with open(dest_path, "w") as f:
-        f.write(main_contents)
-    os.chmod(dest_path, 0o755)
-
-
-def build_install_dir(args, path_map):
-    """Create a directory that contains all of the sources, with a __main__
-    module to run the program.
-    """
-    # Populate a temporary directory first, then rename to the destination
-    # location.  This ensures that we don't ever leave a halfway-built
-    # directory behind at the output path if something goes wrong.
-    dest_dir = os.path.dirname(args.output)
-    with tempfile.TemporaryDirectory(prefix="make_fbpy.", dir=dest_dir) as tmpdir:
-        inst_dir = os.path.join(tmpdir, "tree")
-        populate_install_tree(inst_dir, path_map)
-        create_main_module(args, inst_dir, path_map)
-        os.rename(inst_dir, args.output)
-
-
-def ensure_directory(path):
-    try:
-        os.makedirs(path)
-    except OSError as ex:
-        if ex.errno != errno.EEXIST:
-            raise
-
-
-def install_library(args, path_map):
-    """Create an installation directory a python library."""
-    out_dir = args.output
-    out_manifest = args.output + ".manifest"
-
-    install_dir = args.install_dir
-    if not install_dir:
-        install_dir = out_dir
-
-    os.makedirs(out_dir)
-    with open(out_manifest, "w") as manifest:
-        manifest.write(MANIFEST_HEADER_V1)
-        for info in path_map.values():
-            abs_dest = os.path.join(out_dir, info.dest)
-            ensure_directory(os.path.dirname(abs_dest))
-            print("copy %r --> %r" % (info.src, abs_dest))
-            shutil.copy2(info.src, abs_dest)
-            installed_dest = os.path.join(install_dir, info.dest)
-            manifest.write("%s%s%s\n" % (installed_dest, MANIFEST_SEPARATOR, info.dest))
-
-
-def parse_manifests(args):
-    # Process args.manifest_separator to help support older versions of CMake
-    if args.manifest_separator:
-        manifests = []
-        for manifest_arg in args.manifests:
-            split_arg = manifest_arg.split(args.manifest_separator)
-            manifests.extend(split_arg)
-        args.manifests = manifests
-
-    path_map = {}
-    for manifest in args.manifests:
-        parse_manifest(manifest, path_map)
-
-    return path_map
-
-
-def check_main_module(args, path_map):
-    # Translate an empty string in the --main argument to None,
-    # just to allow the CMake logic to be slightly simpler and pass in an
-    # empty string when it really wants the default __main__.py module to be
-    # used.
-    if args.main == "":
-        args.main = None
-
-    if args.type == "lib-install":
-        if args.main is not None:
-            raise UsageError("cannot specify a --main argument with --type=lib-install")
-        return
-
-    main_info = path_map.get("__main__.py")
-    if args.main:
-        if main_info is not None:
-            msg = (
-                "specified an explicit main module with --main, "
-                "but the file listing already includes __main__.py"
-            )
-            raise BadManifestError(
-                main_info.manifest_path, main_info.manifest_line, msg
-            )
-        parts = args.main.split(":")
-        if len(parts) != 2:
-            raise UsageError(
-                "argument to --main must be of the form MODULE:CALLABLE "
-                "(received %s)" % (args.main,)
-            )
-    else:
-        if main_info is None:
-            raise UsageError(
-                "no main module specified with --main, "
-                "and no __main__.py module present"
-            )
-
-
-BUILD_TYPES = {
-    "zipapp": build_zipapp,
-    "dir": build_install_dir,
-    "lib-install": install_library,
-}
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("-o", "--output", required=True, help="The output file path")
-    ap.add_argument(
-        "--install-dir",
-        help="When used with --type=lib-install, this parameter specifies the "
-        "final location where the library where be installed.  This can be "
-        "used to generate the library in one directory first, when you plan "
-        "to move or copy it to another final location later.",
-    )
-    ap.add_argument(
-        "--manifest-separator",
-        help="Split manifest arguments around this separator.  This is used "
-        "to support older versions of CMake that cannot supply the manifests "
-        "as separate arguments.",
-    )
-    ap.add_argument(
-        "--main",
-        help="The main module to run, specified as <module>:<callable>.  "
-        "This must be specified if and only if the archive does not contain "
-        "a __main__.py file.",
-    )
-    ap.add_argument(
-        "--python",
-        help="Explicitly specify the python interpreter to use for the " "executable.",
-    )
-    ap.add_argument(
-        "--type", choices=BUILD_TYPES.keys(), help="The type of output to build."
-    )
-    ap.add_argument(
-        "manifests",
-        nargs="+",
-        help="The manifest files specifying how to construct the archive",
-    )
-    args = ap.parse_args()
-
-    if args.python is None:
-        args.python = sys.executable
-
-    if args.type is None:
-        # In the future we might want different default output types
-        # for different platforms.
-        args.type = "zipapp"
-    build_fn = BUILD_TYPES[args.type]
-
-    try:
-        path_map = parse_manifests(args)
-        check_main_module(args, path_map)
-    except UsageError as ex:
-        print("error: %s" % (ex,), file=sys.stderr)
-        sys.exit(1)
-
-    build_fn(args, path_map)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/build/fbcode_builder/LICENSE b/build/fbcode_builder/LICENSE
deleted file mode 100644
index b96dcb0480a0b..0000000000000
--- a/build/fbcode_builder/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) Facebook, Inc. and its affiliates.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/build/fbcode_builder/README.md b/build/fbcode_builder/README.md
deleted file mode 100644
index d47dd41c01492..0000000000000
--- a/build/fbcode_builder/README.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# Easy builds for Facebook projects
-
-This directory contains tools designed to simplify continuous-integration
-(and other builds) of Facebook open source projects.  In particular, this helps
-manage builds for cross-project dependencies.
-
-The main entry point is the `getdeps.py` script.  This script has several
-subcommands, but the most notable is the `build` command.  This will download
-and build all dependencies for a project, and then build the project itself.
-
-## Deployment
-
-This directory is copied literally into a number of different Facebook open
-source repositories.  Any change made to code in this directory will be
-automatically be replicated by our open source tooling into all GitHub hosted
-repositories that use `fbcode_builder`.  Typically this directory is copied
-into the open source repositories as `build/fbcode_builder/`.
-
-
-# Project Configuration Files
-
-The `manifests` subdirectory contains configuration files for many different
-projects, describing how to build each project.  These files also list
-dependencies between projects, enabling `getdeps.py` to build all dependencies
-for a project before building the project itself.
-
-
-# Shared CMake utilities
-
-Since this directory is copied into many Facebook open source repositories,
-it is also used to help share some CMake utility files across projects.  The
-`CMake/` subdirectory contains a number of `.cmake` files that are shared by
-the CMake-based build systems across several different projects.
-
-
-# Older Build Scripts
-
-This directory also still contains a handful of older build scripts that
-pre-date the current `getdeps.py` build system.  Most of the other `.py` files
-in this top directory, apart from `getdeps.py` itself, are from this older
-build system.  This older system is only used by a few remaining projects, and
-new projects should generally use the newer `getdeps.py` script, by adding a
-new configuration file in the `manifests/` subdirectory.
diff --git a/build/fbcode_builder/getdeps.py b/build/fbcode_builder/getdeps.py
deleted file mode 100755
index b6ea1aa2c6161..0000000000000
--- a/build/fbcode_builder/getdeps.py
+++ /dev/null
@@ -1,1340 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import argparse
-import json
-import os
-import shutil
-import subprocess
-import sys
-import tarfile
-import tempfile
-
-# We don't import cache.create_cache directly as the facebook
-# specific import below may monkey patch it, and we want to
-# observe the patched version of this function!
-import getdeps.cache as cache_module
-from getdeps.buildopts import setup_build_options
-from getdeps.dyndeps import create_dyn_dep_munger
-from getdeps.errors import TransientFailure
-from getdeps.fetcher import (
-    file_name_is_cmake_file,
-    list_files_under_dir_newer_than_timestamp,
-    SystemPackageFetcher,
-)
-from getdeps.load import ManifestLoader
-from getdeps.manifest import ManifestParser
-from getdeps.platform import HostType
-from getdeps.runcmd import run_cmd
-from getdeps.subcmd import add_subcommands, cmd, SubCmd
-
-try:
-    import getdeps.facebook  # noqa: F401
-except ImportError:
-    # we don't ship the facebook specific subdir,
-    # so allow that to fail silently
-    pass
-
-
-sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "getdeps"))
-
-
-class UsageError(Exception):
-    pass
-
-
-@cmd("validate-manifest", "parse a manifest and validate that it is correct")
-class ValidateManifest(SubCmd):
-    def run(self, args):
-        try:
-            ManifestParser(file_name=args.file_name)
-            print("OK", file=sys.stderr)
-            return 0
-        except Exception as exc:
-            print("ERROR: %s" % str(exc), file=sys.stderr)
-            return 1
-
-    def setup_parser(self, parser):
-        parser.add_argument("file_name", help="path to the manifest file")
-
-
-@cmd("show-host-type", "outputs the host type tuple for the host machine")
-class ShowHostType(SubCmd):
-    def run(self, args):
-        host = HostType()
-        print("%s" % host.as_tuple_string())
-        return 0
-
-
-class ProjectCmdBase(SubCmd):
-    def run(self, args):
-        opts = setup_build_options(args)
-
-        if args.current_project is not None:
-            opts.repo_project = args.current_project
-        if args.project is None:
-            if opts.repo_project is None:
-                raise UsageError(
-                    "no project name specified, and no .projectid file found"
-                )
-            if opts.repo_project == "fbsource":
-                # The fbsource repository is a little special.  There is no project
-                # manifest file for it.  A specific project must always be explicitly
-                # specified when building from fbsource.
-                raise UsageError(
-                    "no project name specified (required when building in fbsource)"
-                )
-            args.project = opts.repo_project
-
-        ctx_gen = opts.get_context_generator()
-        if args.test_dependencies:
-            ctx_gen.set_value_for_all_projects("test", "on")
-        if args.enable_tests:
-            ctx_gen.set_value_for_project(args.project, "test", "on")
-        else:
-            ctx_gen.set_value_for_project(args.project, "test", "off")
-
-        if opts.shared_libs:
-            ctx_gen.set_value_for_all_projects("shared_libs", "on")
-
-        loader = ManifestLoader(opts, ctx_gen)
-        self.process_project_dir_arguments(args, loader)
-
-        manifest = loader.load_manifest(args.project)
-
-        self.run_project_cmd(args, loader, manifest)
-
-    def process_project_dir_arguments(self, args, loader):
-        def parse_project_arg(arg, arg_type):
-            parts = arg.split(":")
-            if len(parts) == 2:
-                project, path = parts
-            elif len(parts) == 1:
-                project = args.project
-                path = parts[0]
-            # On Windows path contains colon, e.g. C:\open
-            elif os.name == "nt" and len(parts) == 3:
-                project = parts[0]
-                path = parts[1] + ":" + parts[2]
-            else:
-                raise UsageError(
-                    "invalid %s argument; too many ':' characters: %s" % (arg_type, arg)
-                )
-
-            return project, os.path.abspath(path)
-
-        # If we are currently running from a project repository,
-        # use the current repository for the project sources.
-        build_opts = loader.build_opts
-        if build_opts.repo_project is not None and build_opts.repo_root is not None:
-            loader.set_project_src_dir(build_opts.repo_project, build_opts.repo_root)
-
-        for arg in args.src_dir:
-            project, path = parse_project_arg(arg, "--src-dir")
-            loader.set_project_src_dir(project, path)
-
-        for arg in args.build_dir:
-            project, path = parse_project_arg(arg, "--build-dir")
-            loader.set_project_build_dir(project, path)
-
-        for arg in args.install_dir:
-            project, path = parse_project_arg(arg, "--install-dir")
-            loader.set_project_install_dir(project, path)
-
-        for arg in args.project_install_prefix:
-            project, path = parse_project_arg(arg, "--install-prefix")
-            loader.set_project_install_prefix(project, path)
-
-    def setup_parser(self, parser):
-        parser.add_argument(
-            "project",
-            nargs="?",
-            help=(
-                "name of the project or path to a manifest "
-                "file describing the project"
-            ),
-        )
-        parser.add_argument(
-            "--no-tests",
-            action="store_false",
-            dest="enable_tests",
-            default=True,
-            help="Disable building tests for this project.",
-        )
-        parser.add_argument(
-            "--test-dependencies",
-            action="store_true",
-            help="Enable building tests for dependencies as well.",
-        )
-        parser.add_argument(
-            "--current-project",
-            help="Specify the name of the fbcode_builder manifest file for the "
-            "current repository.  If not specified, the code will attempt to find "
-            "this in a .projectid file in the repository root.",
-        )
-        parser.add_argument(
-            "--src-dir",
-            default=[],
-            action="append",
-            help="Specify a local directory to use for the project source, "
-            "rather than fetching it.",
-        )
-        parser.add_argument(
-            "--build-dir",
-            default=[],
-            action="append",
-            help="Explicitly specify the build directory to use for the "
-            "project, instead of the default location in the scratch path. "
-            "This only affects the project specified, and not its dependencies.",
-        )
-        parser.add_argument(
-            "--install-dir",
-            default=[],
-            action="append",
-            help="Explicitly specify the install directory to use for the "
-            "project, instead of the default location in the scratch path. "
-            "This only affects the project specified, and not its dependencies.",
-        )
-        parser.add_argument(
-            "--project-install-prefix",
-            default=[],
-            action="append",
-            help="Specify the final deployment installation path for a project",
-        )
-
-        self.setup_project_cmd_parser(parser)
-
-    def setup_project_cmd_parser(self, parser):
-        pass
-
-
-class CachedProject(object):
-    """A helper that allows calling the cache logic for a project
-    from both the build and the fetch code"""
-
-    def __init__(self, cache, loader, m):
-        self.m = m
-        self.inst_dir = loader.get_project_install_dir(m)
-        self.project_hash = loader.get_project_hash(m)
-        self.ctx = loader.ctx_gen.get_context(m.name)
-        self.loader = loader
-        self.cache = cache
-
-        self.cache_file_name = "-".join(
-            (
-                m.name,
-                self.ctx.get("os"),
-                self.ctx.get("distro") or "none",
-                self.ctx.get("distro_vers") or "none",
-                self.project_hash,
-                "buildcache.tgz",
-            )
-        )
-
-    def is_cacheable(self):
-        """We only cache third party projects"""
-        return self.cache and self.m.shipit_project is None
-
-    def was_cached(self):
-        cached_marker = os.path.join(self.inst_dir, ".getdeps-cached-build")
-        return os.path.exists(cached_marker)
-
-    def download(self):
-        if self.is_cacheable() and not os.path.exists(self.inst_dir):
-            print("check cache for %s" % self.cache_file_name)
-            dl_dir = os.path.join(self.loader.build_opts.scratch_dir, "downloads")
-            if not os.path.exists(dl_dir):
-                os.makedirs(dl_dir)
-            try:
-                target_file_name = os.path.join(dl_dir, self.cache_file_name)
-                if self.cache.download_to_file(self.cache_file_name, target_file_name):
-                    tf = tarfile.open(target_file_name, "r")
-                    print(
-                        "Extracting %s -> %s..." % (self.cache_file_name, self.inst_dir)
-                    )
-                    tf.extractall(self.inst_dir)
-
-                    cached_marker = os.path.join(self.inst_dir, ".getdeps-cached-build")
-                    with open(cached_marker, "w") as f:
-                        f.write("\n")
-
-                    return True
-            except Exception as exc:
-                print("%s" % str(exc))
-
-        return False
-
-    def upload(self):
-        if self.is_cacheable():
-            # We can prepare an archive and stick it in LFS
-            tempdir = tempfile.mkdtemp()
-            tarfilename = os.path.join(tempdir, self.cache_file_name)
-            print("Archiving for cache: %s..." % tarfilename)
-            tf = tarfile.open(tarfilename, "w:gz")
-            tf.add(self.inst_dir, arcname=".")
-            tf.close()
-            try:
-                self.cache.upload_from_file(self.cache_file_name, tarfilename)
-            except Exception as exc:
-                print(
-                    "Failed to upload to cache (%s), continue anyway" % str(exc),
-                    file=sys.stderr,
-                )
-            shutil.rmtree(tempdir)
-
-
-@cmd("fetch", "fetch the code for a given project")
-class FetchCmd(ProjectCmdBase):
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--recursive",
-            help="fetch the transitive deps also",
-            action="store_true",
-            default=False,
-        )
-        parser.add_argument(
-            "--host-type",
-            help=(
-                "When recursively fetching, fetch deps for "
-                "this host type rather than the current system"
-            ),
-        )
-
-    def run_project_cmd(self, args, loader, manifest):
-        if args.recursive:
-            projects = loader.manifests_in_dependency_order()
-        else:
-            projects = [manifest]
-
-        cache = cache_module.create_cache()
-        for m in projects:
-            cached_project = CachedProject(cache, loader, m)
-            if cached_project.download():
-                continue
-
-            inst_dir = loader.get_project_install_dir(m)
-            built_marker = os.path.join(inst_dir, ".built-by-getdeps")
-            if os.path.exists(built_marker):
-                with open(built_marker, "r") as f:
-                    built_hash = f.read().strip()
-
-                project_hash = loader.get_project_hash(m)
-                if built_hash == project_hash:
-                    continue
-
-            # We need to fetch the sources
-            fetcher = loader.create_fetcher(m)
-            fetcher.update()
-
-
-@cmd("install-system-deps", "Install system packages to satisfy the deps for a project")
-class InstallSysDepsCmd(ProjectCmdBase):
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--recursive",
-            help="install the transitive deps also",
-            action="store_true",
-            default=False,
-        )
-        parser.add_argument(
-            "--dry-run",
-            action="store_true",
-            default=False,
-            help="Don't install, just print the commands specs we would run",
-        )
-        parser.add_argument(
-            "--os-type",
-            help="Filter to just this OS type to run",
-            choices=["linux", "darwin", "windows"],
-            action="store",
-            dest="ostype",
-            default=None,
-        )
-        parser.add_argument(
-            "--distro",
-            help="Filter to just this distro to run",
-            choices=["ubuntu", "centos_stream"],
-            action="store",
-            dest="distro",
-            default=None,
-        )
-        parser.add_argument(
-            "--distro-version",
-            help="Filter to just this distro version",
-            action="store",
-            dest="distrovers",
-            default=None,
-        )
-
-    def run_project_cmd(self, args, loader, manifest):
-        if args.recursive:
-            projects = loader.manifests_in_dependency_order()
-        else:
-            projects = [manifest]
-
-        rebuild_ctx_gen = False
-        if args.ostype:
-            loader.build_opts.host_type.ostype = args.ostype
-            loader.build_opts.host_type.distro = None
-            loader.build_opts.host_type.distrovers = None
-            rebuild_ctx_gen = True
-
-        if args.distro:
-            loader.build_opts.host_type.distro = args.distro
-            loader.build_opts.host_type.distrovers = None
-            rebuild_ctx_gen = True
-
-        if args.distrovers:
-            loader.build_opts.host_type.distrovers = args.distrovers
-            rebuild_ctx_gen = True
-
-        if rebuild_ctx_gen:
-            loader.ctx_gen = loader.build_opts.get_context_generator()
-
-        manager = loader.build_opts.host_type.get_package_manager()
-
-        all_packages = {}
-        for m in projects:
-            ctx = loader.ctx_gen.get_context(m.name)
-            packages = m.get_required_system_packages(ctx)
-            for k, v in packages.items():
-                merged = all_packages.get(k, [])
-                merged += v
-                all_packages[k] = merged
-
-        cmd_args = None
-        if manager == "rpm":
-            packages = sorted(set(all_packages["rpm"]))
-            if packages:
-                cmd_args = ["sudo", "dnf", "install", "-y"] + packages
-        elif manager == "deb":
-            packages = sorted(set(all_packages["deb"]))
-            if packages:
-                cmd_args = ["sudo", "apt", "install", "-y"] + packages
-        elif manager == "homebrew":
-            packages = sorted(set(all_packages["homebrew"]))
-            if packages:
-                cmd_args = ["brew", "install"] + packages
-
-        else:
-            host_tuple = loader.build_opts.host_type.as_tuple_string()
-            print(
-                f"I don't know how to install any packages on this system {host_tuple}"
-            )
-            return
-
-        if cmd_args:
-            if args.dry_run:
-                print(" ".join(cmd_args))
-            else:
-                run_cmd(cmd_args)
-        else:
-            print("no packages to install")
-
-
-@cmd("list-deps", "lists the transitive deps for a given project")
-class ListDepsCmd(ProjectCmdBase):
-    def run_project_cmd(self, args, loader, manifest):
-        for m in loader.manifests_in_dependency_order():
-            print(m.name)
-        return 0
-
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--host-type",
-            help=(
-                "Produce the list for the specified host type, "
-                "rather than that of the current system"
-            ),
-        )
-
-
-def clean_dirs(opts):
-    for d in ["build", "installed", "extracted", "shipit"]:
-        d = os.path.join(opts.scratch_dir, d)
-        print("Cleaning %s..." % d)
-        if os.path.exists(d):
-            shutil.rmtree(d)
-
-
-@cmd("clean", "clean up the scratch dir")
-class CleanCmd(SubCmd):
-    def run(self, args):
-        opts = setup_build_options(args)
-        clean_dirs(opts)
-
-
-@cmd("show-build-dir", "print the build dir for a given project")
-class ShowBuildDirCmd(ProjectCmdBase):
-    def run_project_cmd(self, args, loader, manifest):
-        if args.recursive:
-            manifests = loader.manifests_in_dependency_order()
-        else:
-            manifests = [manifest]
-
-        for m in manifests:
-            inst_dir = loader.get_project_build_dir(m)
-            print(inst_dir)
-
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--recursive",
-            help="print the transitive deps also",
-            action="store_true",
-            default=False,
-        )
-
-
-@cmd("show-inst-dir", "print the installation dir for a given project")
-class ShowInstDirCmd(ProjectCmdBase):
-    def run_project_cmd(self, args, loader, manifest):
-        if args.recursive:
-            manifests = loader.manifests_in_dependency_order()
-        else:
-            manifests = [manifest]
-
-        for m in manifests:
-            inst_dir = loader.get_project_install_dir_respecting_install_prefix(m)
-            print(inst_dir)
-
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--recursive",
-            help="print the transitive deps also",
-            action="store_true",
-            default=False,
-        )
-
-
-@cmd("show-source-dir", "print the source dir for a given project")
-class ShowSourceDirCmd(ProjectCmdBase):
-    def run_project_cmd(self, args, loader, manifest):
-        if args.recursive:
-            manifests = loader.manifests_in_dependency_order()
-        else:
-            manifests = [manifest]
-
-        for m in manifests:
-            fetcher = loader.create_fetcher(m)
-            print(fetcher.get_src_dir())
-
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--recursive",
-            help="print the transitive deps also",
-            action="store_true",
-            default=False,
-        )
-
-
-@cmd("build", "build a given project")
-class BuildCmd(ProjectCmdBase):
-    def run_project_cmd(self, args, loader, manifest):
-        if args.clean:
-            clean_dirs(loader.build_opts)
-
-        print("Building on %s" % loader.ctx_gen.get_context(args.project))
-        projects = loader.manifests_in_dependency_order()
-
-        cache = cache_module.create_cache() if args.use_build_cache else None
-
-        # Accumulate the install directories so that the build steps
-        # can find their dep installation
-        install_dirs = []
-
-        for m in projects:
-            fetcher = loader.create_fetcher(m)
-
-            if isinstance(fetcher, SystemPackageFetcher):
-                # We are guaranteed that if the fetcher is set to
-                # SystemPackageFetcher then this item is completely
-                # satisfied by the appropriate system packages
-                continue
-
-            if args.clean:
-                fetcher.clean()
-
-            build_dir = loader.get_project_build_dir(m)
-            inst_dir = loader.get_project_install_dir(m)
-
-            if (
-                m == manifest
-                and not args.only_deps
-                or m != manifest
-                and not args.no_deps
-            ):
-                print("Assessing %s..." % m.name)
-                project_hash = loader.get_project_hash(m)
-                ctx = loader.ctx_gen.get_context(m.name)
-                built_marker = os.path.join(inst_dir, ".built-by-getdeps")
-
-                cached_project = CachedProject(cache, loader, m)
-
-                reconfigure, sources_changed = self.compute_source_change_status(
-                    cached_project, fetcher, m, built_marker, project_hash
-                )
-
-                if os.path.exists(built_marker) and not cached_project.was_cached():
-                    # We've previously built this. We may need to reconfigure if
-                    # our deps have changed, so let's check them.
-                    dep_reconfigure, dep_build = self.compute_dep_change_status(
-                        m, built_marker, loader
-                    )
-                    if dep_reconfigure:
-                        reconfigure = True
-                    if dep_build:
-                        sources_changed = True
-
-                extra_cmake_defines = (
-                    json.loads(args.extra_cmake_defines)
-                    if args.extra_cmake_defines
-                    else {}
-                )
-
-                extra_b2_args = args.extra_b2_args or []
-
-                if sources_changed or reconfigure or not os.path.exists(built_marker):
-                    if os.path.exists(built_marker):
-                        os.unlink(built_marker)
-                    src_dir = fetcher.get_src_dir()
-                    # Prepare builders write out config before the main builder runs
-                    prepare_builders = m.create_prepare_builders(
-                        loader.build_opts,
-                        ctx,
-                        src_dir,
-                        build_dir,
-                        inst_dir,
-                        loader,
-                    )
-                    for preparer in prepare_builders:
-                        preparer.prepare(install_dirs, reconfigure=reconfigure)
-
-                    builder = m.create_builder(
-                        loader.build_opts,
-                        src_dir,
-                        build_dir,
-                        inst_dir,
-                        ctx,
-                        loader,
-                        final_install_prefix=loader.get_project_install_prefix(m),
-                        extra_cmake_defines=extra_cmake_defines,
-                        cmake_target=args.cmake_target if m == manifest else "install",
-                        extra_b2_args=extra_b2_args,
-                    )
-                    builder.build(install_dirs, reconfigure=reconfigure)
-
-                    # If we are building the project (not dependency) and a specific
-                    # cmake_target (not 'install') has been requested, then we don't
-                    # set the built_marker. This allows subsequent runs of getdeps.py
-                    # for the project to run with different cmake_targets to trigger
-                    # cmake
-                    has_built_marker = False
-                    if not (m == manifest and args.cmake_target != "install"):
-                        with open(built_marker, "w") as f:
-                            f.write(project_hash)
-                            has_built_marker = True
-
-                    # Only populate the cache from continuous build runs, and
-                    # only if we have a built_marker.
-                    if args.schedule_type == "continuous" and has_built_marker:
-                        cached_project.upload()
-                elif args.verbose:
-                    print("found good %s" % built_marker)
-
-            # Paths are resolved from front. We prepend rather than append as
-            # the last project in topo order is the project itself, which
-            # should be first in the path, then its deps and so on.
-            install_dirs.insert(0, inst_dir)
-
-    def compute_dep_change_status(self, m, built_marker, loader):
-        reconfigure = False
-        sources_changed = False
-        st = os.lstat(built_marker)
-
-        ctx = loader.ctx_gen.get_context(m.name)
-        dep_list = m.get_dependencies(ctx)
-        for dep in dep_list:
-            if reconfigure and sources_changed:
-                break
-
-            dep_manifest = loader.load_manifest(dep)
-            dep_root = loader.get_project_install_dir(dep_manifest)
-            for dep_file in list_files_under_dir_newer_than_timestamp(
-                dep_root, st.st_mtime
-            ):
-                if os.path.basename(dep_file) == ".built-by-getdeps":
-                    continue
-                if file_name_is_cmake_file(dep_file):
-                    if not reconfigure:
-                        reconfigure = True
-                        print(
-                            f"Will reconfigure cmake because {dep_file} is newer than {built_marker}"
-                        )
-                else:
-                    if not sources_changed:
-                        sources_changed = True
-                        print(
-                            f"Will run build because {dep_file} is newer than {built_marker}"
-                        )
-
-                if reconfigure and sources_changed:
-                    break
-
-        return reconfigure, sources_changed
-
-    def compute_source_change_status(
-        self, cached_project, fetcher, m, built_marker, project_hash
-    ):
-        reconfigure = False
-        sources_changed = False
-        if cached_project.download():
-            if not os.path.exists(built_marker):
-                fetcher.update()
-        else:
-            check_fetcher = True
-            if os.path.exists(built_marker):
-                check_fetcher = False
-                with open(built_marker, "r") as f:
-                    built_hash = f.read().strip()
-                if built_hash == project_hash:
-                    if cached_project.is_cacheable():
-                        # We can blindly trust the build status
-                        reconfigure = False
-                        sources_changed = False
-                    else:
-                        # Otherwise, we may have changed the source, so let's
-                        # check in with the fetcher layer
-                        check_fetcher = True
-                else:
-                    # Some kind of inconsistency with a prior build,
-                    # let's run it again to be sure
-                    os.unlink(built_marker)
-                    reconfigure = True
-                    sources_changed = True
-                    # While we don't need to consult the fetcher for the
-                    # status in this case, we may still need to have eg: shipit
-                    # run in order to have a correct source tree.
-                    fetcher.update()
-
-            if check_fetcher:
-                change_status = fetcher.update()
-                reconfigure = change_status.build_changed()
-                sources_changed = change_status.sources_changed()
-
-        return reconfigure, sources_changed
-
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--clean",
-            action="store_true",
-            default=False,
-            help=(
-                "Clean up the build and installation area prior to building, "
-                "causing the projects to be built from scratch"
-            ),
-        )
-        parser.add_argument(
-            "--no-deps",
-            action="store_true",
-            default=False,
-            help=(
-                "Only build the named project, not its deps. "
-                "This is most useful after you've built all of the deps, "
-                "and helps to avoid waiting for relatively "
-                "slow up-to-date-ness checks"
-            ),
-        )
-        parser.add_argument(
-            "--only-deps",
-            action="store_true",
-            default=False,
-            help=(
-                "Only build the named project's deps. "
-                "This is most useful when you want to separate out building "
-                "of all of the deps and your project"
-            ),
-        )
-        parser.add_argument(
-            "--no-build-cache",
-            action="store_false",
-            default=True,
-            dest="use_build_cache",
-            help="Do not attempt to use the build cache.",
-        )
-        parser.add_argument(
-            "--schedule-type", help="Indicates how the build was activated"
-        )
-        parser.add_argument(
-            "--extra-cmake-defines",
-            help=(
-                "Input json map that contains extra cmake defines to be used "
-                "when compiling the current project and all its deps. "
-                'e.g: \'{"CMAKE_CXX_FLAGS": "--bla"}\''
-            ),
-        )
-        parser.add_argument(
-            "--cmake-target",
-            help=("Target for cmake build."),
-            default="install",
-        )
-        parser.add_argument(
-            "--extra-b2-args",
-            help=(
-                "Repeatable argument that contains extra arguments to pass "
-                "to b2, which compiles boost. "
-                "e.g.: 'cxxflags=-fPIC' 'cflags=-fPIC'"
-            ),
-            action="append",
-        )
-        parser.add_argument(
-            "--shared-libs",
-            help="Build shared libraries if possible",
-            action="store_true",
-            default=False,
-        )
-        parser.add_argument(
-            "--free-up-disk",
-            help="Remove unused tools and clean up intermediate files if possible to maximise space for the build",
-            action="store_true",
-            default=False,
-        )
-
-
-@cmd("fixup-dyn-deps", "Adjusts dynamic dependencies for packaging purposes")
-class FixupDeps(ProjectCmdBase):
-    def run_project_cmd(self, args, loader, manifest):
-        projects = loader.manifests_in_dependency_order()
-
-        # Accumulate the install directories so that the build steps
-        # can find their dep installation
-        install_dirs = []
-
-        for m in projects:
-            inst_dir = loader.get_project_install_dir_respecting_install_prefix(m)
-            install_dirs.append(inst_dir)
-
-            if m == manifest:
-                dep_munger = create_dyn_dep_munger(
-                    loader.build_opts, install_dirs, args.strip
-                )
-                if dep_munger is None:
-                    print(f"dynamic dependency fixups not supported on {sys.platform}")
-                else:
-                    dep_munger.process_deps(args.destdir, args.final_install_prefix)
-
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument("destdir", help="Where to copy the fixed up executables")
-        parser.add_argument(
-            "--final-install-prefix", help="specify the final installation prefix"
-        )
-        parser.add_argument(
-            "--strip",
-            action="store_true",
-            default=False,
-            help="Strip debug info while processing executables",
-        )
-
-
-@cmd("test", "test a given project")
-class TestCmd(ProjectCmdBase):
-    def run_project_cmd(self, args, loader, manifest):
-        projects = loader.manifests_in_dependency_order()
-
-        # Accumulate the install directories so that the test steps
-        # can find their dep installation
-        install_dirs = []
-
-        for m in projects:
-            inst_dir = loader.get_project_install_dir(m)
-
-            if m == manifest or args.test_dependencies:
-                built_marker = os.path.join(inst_dir, ".built-by-getdeps")
-                if not os.path.exists(built_marker):
-                    print("project %s has not been built" % m.name)
-                    # TODO: we could just go ahead and build it here, but I
-                    # want to tackle that as part of adding build-for-test
-                    # support.
-                    return 1
-                fetcher = loader.create_fetcher(m)
-                src_dir = fetcher.get_src_dir()
-                ctx = loader.ctx_gen.get_context(m.name)
-                build_dir = loader.get_project_build_dir(m)
-                builder = m.create_builder(
-                    loader.build_opts, src_dir, build_dir, inst_dir, ctx, loader
-                )
-
-                builder.run_tests(
-                    install_dirs,
-                    schedule_type=args.schedule_type,
-                    owner=args.test_owner,
-                    test_filter=args.filter,
-                    retry=args.retry,
-                    no_testpilot=args.no_testpilot,
-                )
-
-            install_dirs.append(inst_dir)
-
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--schedule-type", help="Indicates how the build was activated"
-        )
-        parser.add_argument("--test-owner", help="Owner for testpilot")
-        parser.add_argument("--filter", help="Only run the tests matching the regex")
-        parser.add_argument(
-            "--retry",
-            type=int,
-            default=3,
-            help="Number of immediate retries for failed tests "
-            "(noop in continuous and testwarden runs)",
-        )
-        parser.add_argument(
-            "--no-testpilot",
-            help="Do not use Test Pilot even when available",
-            action="store_true",
-        )
-
-
-@cmd("generate-github-actions", "generate a GitHub actions configuration")
-class GenerateGitHubActionsCmd(ProjectCmdBase):
-    RUN_ON_ALL = """ [push, pull_request]"""
-
-    def run_project_cmd(self, args, loader, manifest):
-        platforms = [
-            HostType("linux", "ubuntu", "18"),
-            HostType("darwin", None, None),
-            HostType("windows", None, None),
-        ]
-
-        for p in platforms:
-            if args.os_types and p.ostype not in args.os_types:
-                continue
-            self.write_job_for_platform(p, args)
-
-    def get_run_on(self, args):
-        if args.run_on_all_branches:
-            return self.RUN_ON_ALL
-        return f"""
-  push:
-    branches:
-    - {args.main_branch}
-  pull_request:
-    branches:
-    - {args.main_branch}"""
-
-    # TODO: Break up complex function
-    def write_job_for_platform(self, platform, args):  # noqa: C901
-        build_opts = setup_build_options(args, platform)
-        ctx_gen = build_opts.get_context_generator()
-        loader = ManifestLoader(build_opts, ctx_gen)
-        manifest = loader.load_manifest(args.project)
-        manifest_ctx = loader.ctx_gen.get_context(manifest.name)
-        run_on = self.get_run_on(args)
-
-        # Some projects don't do anything "useful" as a leaf project, only
-        # as a dep for a leaf project. Check for those here; we don't want
-        # to waste the effort scheduling them on CI.
-        # We do this by looking at the builder type in the manifest file
-        # rather than creating a builder and checking its type because we
-        # don't know enough to create the full builder instance here.
-        builder_name = manifest.get("build", "builder", ctx=manifest_ctx)
-        if builder_name == "nop":
-            return None
-
-        # We want to be sure that we're running things with python 3
-        # but python versioning is honestly a bit of a frustrating mess.
-        # `python` may be version 2 or version 3 depending on the system.
-        # python3 may not be a thing at all!
-        # Assume an optimistic default
-        py3 = "python3"
-
-        if build_opts.is_linux():
-            artifacts = "linux"
-            runs_on = f"ubuntu-{args.ubuntu_version}"
-        elif build_opts.is_windows():
-            artifacts = "windows"
-            runs_on = "windows-2019"
-            # The windows runners are python 3 by default; python2.exe
-            # is available if needed.
-            py3 = "python"
-        else:
-            artifacts = "mac"
-            runs_on = "macOS-latest"
-
-        os.makedirs(args.output_dir, exist_ok=True)
-
-        job_file_prefix = "getdeps_"
-        if args.job_file_prefix:
-            job_file_prefix = args.job_file_prefix
-
-        output_file = os.path.join(args.output_dir, f"{job_file_prefix}{artifacts}.yml")
-
-        if args.job_name_prefix:
-            job_name = args.job_name_prefix + artifacts.capitalize()
-        else:
-            job_name = artifacts
-
-        with open(output_file, "w") as out:
-            # Deliberate line break here because the @ and the generated
-            # symbols are meaningful to our internal tooling when they
-            # appear in a single token
-            out.write("# This file was @")
-            out.write("generated by getdeps.py\n")
-            out.write(
-                f"""
-name: {job_name}
-
-on:{run_on}
-
-permissions:
-  contents: read  #  to fetch code (actions/checkout)
-
-jobs:
-"""
-            )
-
-            getdepscmd = f"{py3} build/fbcode_builder/getdeps.py"
-
-            out.write("  build:\n")
-            out.write("    runs-on: %s\n" % runs_on)
-            out.write("    steps:\n")
-
-            if build_opts.is_windows():
-                # cmake relies on BOOST_ROOT but GH deliberately don't set it in order
-                # to avoid versioning issues:
-                # https://github.com/actions/virtual-environments/issues/319
-                # Instead, set the version we think we need; this is effectively
-                # coupled with the boost manifest
-                # This is the unusual syntax for setting an env var for the rest of
-                # the steps in a workflow:
-                # https://github.blog/changelog/2020-10-01-github-actions-deprecating-set-env-and-add-path-commands/
-                out.write("    - name: Export boost environment\n")
-                out.write(
-                    '      run: "echo BOOST_ROOT=%BOOST_ROOT_1_83_0% >> %GITHUB_ENV%"\n'
-                )
-                out.write("      shell: cmd\n")
-
-                # The git installation may not like long filenames, so tell it
-                # that we want it to use them!
-                out.write("    - name: Fix Git config\n")
-                out.write("      run: git config --system core.longpaths true\n")
-                out.write("    - name: Disable autocrlf\n")
-                out.write("      run: git config --system core.autocrlf false\n")
-
-            out.write("    - uses: actions/checkout@v2\n")
-
-            if build_opts.free_up_disk:
-                free_up_disk = "--free-up-disk "
-                if not build_opts.is_windows():
-                    out.write("    - name: Show disk space at start\n")
-                    out.write("      run: df -h\n")
-                    # remove the unused github supplied android dev tools
-                    out.write("    - name: Free up disk space\n")
-                    out.write("      run: sudo rm -rf /usr/local/lib/android\n")
-                    out.write("    - name: Show disk space after freeing up\n")
-                    out.write("      run: df -h\n")
-            else:
-                free_up_disk = ""
-
-            allow_sys_arg = ""
-            if (
-                build_opts.allow_system_packages
-                and build_opts.host_type.get_package_manager()
-            ):
-                sudo_arg = "sudo "
-                allow_sys_arg = " --allow-system-packages"
-                if build_opts.host_type.get_package_manager() == "deb":
-                    out.write("    - name: Update system package info\n")
-                    out.write(f"      run: {sudo_arg}apt-get update\n")
-
-                out.write("    - name: Install system deps\n")
-                if build_opts.is_darwin():
-                    # brew is installed as regular user
-                    sudo_arg = ""
-                out.write(
-                    f"      run: {sudo_arg}python3 build/fbcode_builder/getdeps.py --allow-system-packages install-system-deps --recursive {manifest.name}\n"
-                )
-
-            projects = loader.manifests_in_dependency_order()
-
-            main_repo_url = manifest.get_repo_url(manifest_ctx)
-            has_same_repo_dep = False
-
-            # Add the rust dep which doesn't have a manifest
-            for m in projects:
-                if m == manifest:
-                    continue
-                mbuilder_name = m.get("build", "builder", ctx=manifest_ctx)
-                if (
-                    m.name == "rust"
-                    or builder_name == "cargo"
-                    or mbuilder_name == "cargo"
-                ):
-                    out.write("    - name: Install Rust Stable\n")
-                    out.write("      uses: dtolnay/rust-toolchain@stable\n")
-                    break
-
-            # Normal deps that have manifests
-            for m in projects:
-                if m == manifest or m.name == "rust":
-                    continue
-                ctx = loader.ctx_gen.get_context(m.name)
-                if m.get_repo_url(ctx) != main_repo_url:
-                    out.write("    - name: Fetch %s\n" % m.name)
-                    out.write(
-                        f"      run: {getdepscmd}{allow_sys_arg} fetch --no-tests {m.name}\n"
-                    )
-
-            for m in projects:
-                if m != manifest:
-                    if m.name == "rust":
-                        continue
-                    else:
-                        src_dir_arg = ""
-                        ctx = loader.ctx_gen.get_context(m.name)
-                        if main_repo_url and m.get_repo_url(ctx) == main_repo_url:
-                            # Its in the same repo, so src-dir is also .
-                            src_dir_arg = "--src-dir=. "
-                            has_same_repo_dep = True
-                        out.write("    - name: Build %s\n" % m.name)
-                        out.write(
-                            f"      run: {getdepscmd}{allow_sys_arg} build {src_dir_arg}{free_up_disk}--no-tests {m.name}\n"
-                        )
-
-            out.write("    - name: Build %s\n" % manifest.name)
-
-            project_prefix = ""
-            if not build_opts.is_windows():
-                project_prefix = (
-                    " --project-install-prefix %s:/usr/local" % manifest.name
-                )
-
-            # If we have dep from same repo, we already built it and don't want to rebuild it again
-            no_deps_arg = ""
-            if has_same_repo_dep:
-                no_deps_arg = "--no-deps "
-
-            no_tests_arg = ""
-            if not args.enable_tests:
-                no_tests_arg = "--no-tests "
-
-            out.write(
-                f"      run: {getdepscmd}{allow_sys_arg} build {no_tests_arg}{no_deps_arg}--src-dir=. {manifest.name} {project_prefix}\n"
-            )
-
-            out.write("    - name: Copy artifacts\n")
-            if build_opts.is_linux():
-                # Strip debug info from the binaries, but only on linux.
-                # While the `strip` utility is also available on macOS,
-                # attempting to strip there results in an error.
-                # The `strip` utility is not available on Windows.
-                strip = " --strip"
-            else:
-                strip = ""
-
-            out.write(
-                f"      run: {getdepscmd}{allow_sys_arg} fixup-dyn-deps{strip} "
-                f"--src-dir=. {manifest.name} _artifacts/{artifacts} {project_prefix} "
-                f"--final-install-prefix /usr/local\n"
-            )
-
-            out.write("    - uses: actions/upload-artifact@v2\n")
-            out.write("      with:\n")
-            out.write("        name: %s\n" % manifest.name)
-            out.write("        path: _artifacts\n")
-
-            if (
-                args.enable_tests
-                and manifest.get("github.actions", "run_tests", ctx=manifest_ctx)
-                != "off"
-            ):
-                out.write("    - name: Test %s\n" % manifest.name)
-                out.write(
-                    f"      run: {getdepscmd}{allow_sys_arg} test --src-dir=. {manifest.name} {project_prefix}\n"
-                )
-            if build_opts.free_up_disk and not build_opts.is_windows():
-                out.write("    - name: Show disk space at end\n")
-                out.write("      run: df -h\n")
-
-    def setup_project_cmd_parser(self, parser):
-        parser.add_argument(
-            "--disallow-system-packages",
-            help="Disallow satisfying third party deps from installed system packages",
-            action="store_true",
-            default=False,
-        )
-        parser.add_argument(
-            "--output-dir", help="The directory that will contain the yml files"
-        )
-        parser.add_argument(
-            "--run-on-all-branches",
-            action="store_true",
-            help="Allow CI to fire on all branches - Handy for testing",
-        )
-        parser.add_argument(
-            "--ubuntu-version", default="20.04", help="Version of Ubuntu to use"
-        )
-        parser.add_argument(
-            "--main-branch",
-            default="main",
-            help="Main branch to trigger GitHub Action on",
-        )
-        parser.add_argument(
-            "--os-type",
-            help="Filter to just this OS type to run",
-            choices=["linux", "darwin", "windows"],
-            action="append",
-            dest="os_types",
-            default=[],
-        )
-        parser.add_argument(
-            "--job-file-prefix",
-            type=str,
-            help="add a prefix to all job file names",
-            default=None,
-        )
-        parser.add_argument(
-            "--job-name-prefix",
-            type=str,
-            help="add a prefix to all job names",
-            default=None,
-        )
-        parser.add_argument(
-            "--free-up-disk",
-            help="Remove unused tools and clean up intermediate files if possible to maximise space for the build",
-            action="store_true",
-            default=False,
-        )
-
-
-def get_arg_var_name(args):
-    for arg in args:
-        if arg.startswith("--"):
-            return arg[2:].replace("-", "_")
-
-    raise Exception("unable to determine argument variable name from %r" % (args,))
-
-
-def parse_args():
-    # We want to allow common arguments to be specified either before or after
-    # the subcommand name.  In order to do this we add them to the main parser
-    # and to subcommand parsers.  In order for this to work, we need to tell
-    # argparse that the default value is SUPPRESS, so that the default values
-    # from the subparser arguments won't override values set by the user from
-    # the main parser.  We maintain our own list of desired defaults in the
-    # common_defaults dictionary, and manually set those if the argument wasn't
-    # present at all.
-    common_args = argparse.ArgumentParser(add_help=False)
-    common_defaults = {}
-
-    def add_common_arg(*args, **kwargs):
-        var_name = get_arg_var_name(args)
-        default_value = kwargs.pop("default", None)
-        common_defaults[var_name] = default_value
-        kwargs["default"] = argparse.SUPPRESS
-        common_args.add_argument(*args, **kwargs)
-
-    add_common_arg("--scratch-path", help="Where to maintain checkouts and build dirs")
-    add_common_arg(
-        "--vcvars-path", default=None, help="Path to the vcvarsall.bat on Windows."
-    )
-    add_common_arg(
-        "--install-prefix",
-        help=(
-            "Where the final build products will be installed "
-            "(default is [scratch-path]/installed)"
-        ),
-    )
-    add_common_arg(
-        "--num-jobs",
-        type=int,
-        help=(
-            "Number of concurrent jobs to use while building. "
-            "(default=number of cpu cores)"
-        ),
-    )
-    add_common_arg(
-        "--use-shipit",
-        help="use the real ShipIt instead of the simple shipit transformer",
-        action="store_true",
-        default=False,
-    )
-    add_common_arg(
-        "--facebook-internal",
-        help="Setup the build context as an FB internal build",
-        action="store_true",
-        default=None,
-    )
-    add_common_arg(
-        "--no-facebook-internal",
-        help="Perform a non-FB internal build, even when in an fbsource repository",
-        action="store_false",
-        dest="facebook_internal",
-    )
-    add_common_arg(
-        "--allow-system-packages",
-        help="Allow satisfying third party deps from installed system packages",
-        action="store_true",
-        default=False,
-    )
-    add_common_arg(
-        "-v",
-        "--verbose",
-        help="Print more output",
-        action="store_true",
-        default=False,
-    )
-    add_common_arg(
-        "--lfs-path",
-        help="Provide a parent directory for lfs when fbsource is unavailable",
-        default=None,
-    )
-
-    ap = argparse.ArgumentParser(
-        description="Get and build dependencies and projects", parents=[common_args]
-    )
-    sub = ap.add_subparsers(
-        # metavar suppresses the long and ugly default list of subcommands on a
-        # single line.  We still render the nicer list below where we would
-        # have shown the nasty one.
-        metavar="",
-        title="Available commands",
-        help="",
-    )
-
-    add_subcommands(sub, common_args)
-
-    args = ap.parse_args()
-    for var_name, default_value in common_defaults.items():
-        if not hasattr(args, var_name):
-            setattr(args, var_name, default_value)
-
-    return ap, args
-
-
-def main():
-    ap, args = parse_args()
-    if getattr(args, "func", None) is None:
-        ap.print_help()
-        return 0
-    try:
-        return args.func(args)
-    except UsageError as exc:
-        ap.error(str(exc))
-        return 1
-    except TransientFailure as exc:
-        print("TransientFailure: %s" % str(exc))
-        # This return code is treated as a retryable transient infrastructure
-        # error by Facebook's internal CI, rather than eg: a build or code
-        # related error that needs to be fixed before progress can be made.
-        return 128
-    except subprocess.CalledProcessError as exc:
-        print("%s" % str(exc), file=sys.stderr)
-        print("!! Failed", file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/build/fbcode_builder/getdeps/__init__.py b/build/fbcode_builder/getdeps/__init__.py
deleted file mode 100644
index e69de29bb2d1d..0000000000000
diff --git a/build/fbcode_builder/getdeps/builder.py b/build/fbcode_builder/getdeps/builder.py
deleted file mode 100644
index 3bcadb5d6e986..0000000000000
--- a/build/fbcode_builder/getdeps/builder.py
+++ /dev/null
@@ -1,1202 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import glob
-import json
-import os
-import pathlib
-import shutil
-import stat
-import subprocess
-import sys
-import typing
-from typing import Optional
-
-from .dyndeps import create_dyn_dep_munger
-from .envfuncs import add_path_entry, Env, path_search
-from .fetcher import copy_if_different
-from .runcmd import run_cmd
-
-if typing.TYPE_CHECKING:
-    from .buildopts import BuildOptions
-
-
-class BuilderBase(object):
-    def __init__(
-        self,
-        build_opts: "BuildOptions",
-        ctx,
-        manifest,
-        src_dir,
-        build_dir,
-        inst_dir,
-        env=None,
-        final_install_prefix=None,
-    ) -> None:
-        self.env = Env()
-        if env:
-            self.env.update(env)
-
-        subdir = manifest.get("build", "subdir", ctx=ctx)
-        if subdir:
-            src_dir = os.path.join(src_dir, subdir)
-
-        self.patchfile = manifest.get("build", "patchfile", ctx=ctx)
-        self.patchfile_opts = manifest.get("build", "patchfile_opts", ctx=ctx) or ""
-        self.ctx = ctx
-        self.src_dir = src_dir
-        self.build_dir = build_dir or src_dir
-        self.inst_dir = inst_dir
-        self.build_opts = build_opts
-        self.manifest = manifest
-        self.final_install_prefix = final_install_prefix
-
-    def _get_cmd_prefix(self):
-        if self.build_opts.is_windows():
-            vcvarsall = self.build_opts.get_vcvars_path()
-            if vcvarsall is not None:
-                # Since it sets rather a large number of variables we mildly abuse
-                # the cmd quoting rules to assemble a command that calls the script
-                # to prep the environment and then triggers the actual command that
-                # we wanted to run.
-                return [vcvarsall, "amd64", "&&"]
-        return []
-
-    def _run_cmd(
-        self,
-        cmd,
-        cwd=None,
-        env=None,
-        use_cmd_prefix: bool = True,
-        allow_fail: bool = False,
-    ) -> int:
-        if env:
-            e = self.env.copy()
-            e.update(env)
-            env = e
-        else:
-            env = self.env
-
-        if use_cmd_prefix:
-            cmd_prefix = self._get_cmd_prefix()
-            if cmd_prefix:
-                cmd = cmd_prefix + cmd
-
-        log_file = os.path.join(self.build_dir, "getdeps_build.log")
-        return run_cmd(
-            cmd=cmd,
-            env=env,
-            cwd=cwd or self.build_dir,
-            log_file=log_file,
-            allow_fail=allow_fail,
-        )
-
-    def _reconfigure(self, reconfigure: bool) -> bool:
-        if self.build_dir is not None:
-            if not os.path.isdir(self.build_dir):
-                os.makedirs(self.build_dir)
-                reconfigure = True
-        return reconfigure
-
-    def _apply_patchfile(self) -> None:
-        if self.patchfile is None:
-            return
-        patched_sentinel_file = pathlib.Path(self.src_dir + "/.getdeps_patched")
-        if patched_sentinel_file.exists():
-            return
-        old_wd = os.getcwd()
-        os.chdir(self.src_dir)
-        print(f"Patching {self.manifest.name} with {self.patchfile} in {self.src_dir}")
-        patchfile = os.path.join(
-            self.build_opts.fbcode_builder_dir, "patches", self.patchfile
-        )
-        patchcmd = ["git", "apply"]
-        if self.patchfile_opts:
-            patchcmd.append(self.patchfile_opts)
-        try:
-            subprocess.check_call(patchcmd + [patchfile])
-        except subprocess.CalledProcessError:
-            raise ValueError(f"Failed to apply patch to {self.manifest.name}")
-        os.chdir(old_wd)
-        patched_sentinel_file.touch()
-
-    def prepare(self, install_dirs, reconfigure: bool) -> None:
-        print("Preparing %s..." % self.manifest.name)
-        reconfigure = self._reconfigure(reconfigure)
-        self._apply_patchfile()
-        self._prepare(install_dirs=install_dirs, reconfigure=reconfigure)
-
-    def build(self, install_dirs, reconfigure: bool) -> None:
-        print("Building %s..." % self.manifest.name)
-        reconfigure = self._reconfigure(reconfigure)
-        self._apply_patchfile()
-        self._prepare(install_dirs=install_dirs, reconfigure=reconfigure)
-        self._build(install_dirs=install_dirs, reconfigure=reconfigure)
-
-        if self.build_opts.free_up_disk:
-            # don't clean --src-dir=. case as user may want to build again or run tests on the build
-            if self.src_dir.startswith(self.build_opts.scratch_dir) and os.path.isdir(
-                self.build_dir
-            ):
-                if os.path.islink(self.build_dir):
-                    os.remove(self.build_dir)
-                else:
-                    shutil.rmtree(self.build_dir)
-
-        # On Windows, emit a wrapper script that can be used to run build artifacts
-        # directly from the build directory, without installing them.  On Windows $PATH
-        # needs to be updated to include all of the directories containing the runtime
-        # library dependencies in order to run the binaries.
-        if self.build_opts.is_windows():
-            script_path = self.get_dev_run_script_path()
-            dep_munger = create_dyn_dep_munger(self.build_opts, install_dirs)
-            dep_dirs = self.get_dev_run_extra_path_dirs(install_dirs, dep_munger)
-            # pyre-fixme[16]: Optional type has no attribute `emit_dev_run_script`.
-            dep_munger.emit_dev_run_script(script_path, dep_dirs)
-
-    @property
-    def num_jobs(self) -> int:
-        # This is a hack, but we don't have a "defaults manifest" that we can
-        # customize per platform.
-        # TODO: Introduce some sort of defaults config that can select by
-        # platform, just like manifest contexts.
-        if sys.platform.startswith("freebsd"):
-            # clang on FreeBSD is quite memory-efficient.
-            default_job_weight = 512
-        else:
-            # 1.5 GiB is a lot to assume, but it's typical of Facebook-style C++.
-            # Some manifests are even heavier and should override.
-            default_job_weight = 1536
-        return self.build_opts.get_num_jobs(
-            int(
-                self.manifest.get(
-                    "build", "job_weight_mib", default_job_weight, ctx=self.ctx
-                )
-            )
-        )
-
-    def run_tests(
-        self, install_dirs, schedule_type, owner, test_filter, retry, no_testpilot
-    ) -> None:
-        """Execute any tests that we know how to run.  If they fail,
-        raise an exception."""
-        pass
-
-    def _prepare(self, install_dirs, reconfigure) -> None:
-        """Prepare the build. Useful when need to generate config,
-        but builder is not the primary build system.
-        e.g. cargo when called from cmake"""
-        pass
-
-    def _build(self, install_dirs, reconfigure) -> None:
-        """Perform the build.
-        install_dirs contains the list of installation directories for
-        the dependencies of this project.
-        reconfigure will be set to true if the fetcher determined
-        that the sources have changed in such a way that the build
-        system needs to regenerate its rules."""
-        pass
-
-    def _compute_env(self, install_dirs):
-        # CMAKE_PREFIX_PATH is only respected when passed through the
-        # environment, so we construct an appropriate path to pass down
-        return self.build_opts.compute_env_for_install_dirs(
-            install_dirs, env=self.env, manifest=self.manifest
-        )
-
-    def get_dev_run_script_path(self):
-        assert self.build_opts.is_windows()
-        return os.path.join(self.build_dir, "run.ps1")
-
-    def get_dev_run_extra_path_dirs(self, install_dirs, dep_munger=None):
-        assert self.build_opts.is_windows()
-        if dep_munger is None:
-            dep_munger = create_dyn_dep_munger(self.build_opts, install_dirs)
-        return dep_munger.compute_dependency_paths(self.build_dir)
-
-
-class MakeBuilder(BuilderBase):
-    def __init__(
-        self,
-        build_opts,
-        ctx,
-        manifest,
-        src_dir,
-        build_dir,
-        inst_dir,
-        build_args,
-        install_args,
-        test_args,
-    ) -> None:
-        super(MakeBuilder, self).__init__(
-            build_opts, ctx, manifest, src_dir, build_dir, inst_dir
-        )
-        self.build_args = build_args or []
-        self.install_args = install_args or []
-        self.test_args = test_args
-
-    @property
-    def _make_binary(self):
-        return self.manifest.get("build", "make_binary", "make", ctx=self.ctx)
-
-    def _get_prefix(self):
-        return ["PREFIX=" + self.inst_dir, "prefix=" + self.inst_dir]
-
-    def _build(self, install_dirs, reconfigure) -> None:
-
-        env = self._compute_env(install_dirs)
-
-        # Need to ensure that PREFIX is set prior to install because
-        # libbpf uses it when generating its pkg-config file.
-        # The lowercase prefix is used by some projects.
-        cmd = (
-            [self._make_binary, "-j%s" % self.num_jobs]
-            + self.build_args
-            + self._get_prefix()
-        )
-        self._run_cmd(cmd, env=env)
-
-        install_cmd = [self._make_binary] + self.install_args + self._get_prefix()
-        self._run_cmd(install_cmd, env=env)
-
-        # bz2's Makefile doesn't install its .so properly
-        if self.manifest and self.manifest.name == "bz2":
-            libdir = os.path.join(self.inst_dir, "lib")
-            srcpattern = os.path.join(self.src_dir, "lib*.so.*")
-            print(f"copying to {libdir} from {srcpattern}")
-            for file in glob.glob(srcpattern):
-                shutil.copy(file, libdir)
-
-    def run_tests(
-        self, install_dirs, schedule_type, owner, test_filter, retry, no_testpilot
-    ) -> None:
-        if not self.test_args:
-            return
-
-        env = self._compute_env(install_dirs)
-
-        cmd = [self._make_binary] + self.test_args + self._get_prefix()
-        self._run_cmd(cmd, env=env)
-
-
-class CMakeBootStrapBuilder(MakeBuilder):
-    def _build(self, install_dirs, reconfigure) -> None:
-        self._run_cmd(
-            [
-                "./bootstrap",
-                "--prefix=" + self.inst_dir,
-                f"--parallel={self.num_jobs}",
-            ]
-        )
-        super(CMakeBootStrapBuilder, self)._build(install_dirs, reconfigure)
-
-
-class AutoconfBuilder(BuilderBase):
-    def __init__(
-        self,
-        build_opts,
-        ctx,
-        manifest,
-        src_dir,
-        build_dir,
-        inst_dir,
-        args,
-        conf_env_args,
-    ) -> None:
-        super(AutoconfBuilder, self).__init__(
-            build_opts, ctx, manifest, src_dir, build_dir, inst_dir
-        )
-        self.args = args or []
-        self.conf_env_args = conf_env_args or {}
-
-    @property
-    def _make_binary(self):
-        return self.manifest.get("build", "make_binary", "make", ctx=self.ctx)
-
-    def _build(self, install_dirs, reconfigure) -> None:
-        configure_path = os.path.join(self.src_dir, "configure")
-        autogen_path = os.path.join(self.src_dir, "autogen.sh")
-
-        env = self._compute_env(install_dirs)
-
-        # Some configure scripts need additional env values passed derived from cmds
-        for (k, cmd_args) in self.conf_env_args.items():
-            out = (
-                subprocess.check_output(cmd_args, env=dict(env.items()))
-                .decode("utf-8")
-                .strip()
-            )
-            if out:
-                env.set(k, out)
-
-        if not os.path.exists(configure_path):
-            print("%s doesn't exist, so reconfiguring" % configure_path)
-            # This libtoolize call is a bit gross; the issue is that
-            # `autoreconf` as invoked by libsodium's `autogen.sh` doesn't
-            # seem to realize that it should invoke libtoolize and then
-            # error out when the configure script references a libtool
-            # related symbol.
-            self._run_cmd(["libtoolize"], cwd=self.src_dir, env=env)
-
-            # We generally prefer to call the `autogen.sh` script provided
-            # by the project on the basis that it may know more than plain
-            # autoreconf does.
-            if os.path.exists(autogen_path):
-                self._run_cmd(["bash", autogen_path], cwd=self.src_dir, env=env)
-            else:
-                self._run_cmd(["autoreconf", "-ivf"], cwd=self.src_dir, env=env)
-        configure_cmd = [configure_path, "--prefix=" + self.inst_dir] + self.args
-        self._run_cmd(configure_cmd, env=env)
-        self._run_cmd([self._make_binary, "-j%s" % self.num_jobs], env=env)
-        self._run_cmd([self._make_binary, "install"], env=env)
-
-
-class Iproute2Builder(BuilderBase):
-    # ./configure --prefix does not work for iproute2.
-    # Thus, explicitly copy sources from src_dir to build_dir, build,
-    # and then install to inst_dir using DESTDIR
-    # lastly, also copy include from build_dir to inst_dir
-    def __init__(self, build_opts, ctx, manifest, src_dir, build_dir, inst_dir) -> None:
-        super(Iproute2Builder, self).__init__(
-            build_opts, ctx, manifest, src_dir, build_dir, inst_dir
-        )
-
-    def _patch(self) -> None:
-        # FBOSS build currently depends on an old version of iproute2 (commit
-        # 7ca63aef7d1b0c808da0040c6b366ef7a61f38c1). This is missing a commit
-        # (ae717baf15fb4d30749ada3948d9445892bac239) needed to build iproute2
-        # successfully. Apply it viz.: include stdint.h
-        # Reference: https://fburl.com/ilx9g5xm
-        with open(self.build_dir + "/tc/tc_core.c", "r") as f:
-            data = f.read()
-
-        with open(self.build_dir + "/tc/tc_core.c", "w") as f:
-            f.write("#include <stdint.h>\n")
-            f.write(data)
-
-    def _build(self, install_dirs, reconfigure) -> None:
-        configure_path = os.path.join(self.src_dir, "configure")
-
-        env = self.env.copy()
-        self._run_cmd([configure_path], env=env)
-        shutil.rmtree(self.build_dir)
-        shutil.copytree(self.src_dir, self.build_dir)
-        self._patch()
-        self._run_cmd(["make", "-j%s" % self.num_jobs], env=env)
-        install_cmd = ["make", "install", "DESTDIR=" + self.inst_dir]
-
-        for d in ["include", "lib"]:
-            if not os.path.isdir(os.path.join(self.inst_dir, d)):
-                shutil.copytree(
-                    os.path.join(self.build_dir, d), os.path.join(self.inst_dir, d)
-                )
-
-        self._run_cmd(install_cmd, env=env)
-
-
-class CMakeBuilder(BuilderBase):
-    MANUAL_BUILD_SCRIPT = """\
-#!{sys.executable}
-
-
-import argparse
-import subprocess
-import sys
-
-CMAKE = {cmake!r}
-CTEST = {ctest!r}
-SRC_DIR = {src_dir!r}
-BUILD_DIR = {build_dir!r}
-INSTALL_DIR = {install_dir!r}
-CMD_PREFIX = {cmd_prefix!r}
-CMAKE_ENV = {env_str}
-CMAKE_DEFINE_ARGS = {define_args_str}
-
-
-def get_jobs_argument(num_jobs_arg: int) -> str:
-    if num_jobs_arg > 0:
-        return "-j" + str(num_jobs_arg)
-
-    import multiprocessing
-    num_jobs = multiprocessing.cpu_count() // 2
-    return "-j" + str(num_jobs)
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument(
-      "cmake_args",
-      nargs=argparse.REMAINDER,
-      help='Any extra arguments after an "--" argument will be passed '
-      "directly to CMake."
-    )
-    ap.add_argument(
-      "--mode",
-      choices=["configure", "build", "install", "test"],
-      default="configure",
-      help="The mode to run: configure, build, or install.  "
-      "Defaults to configure",
-    )
-    ap.add_argument(
-      "--build",
-      action="store_const",
-      const="build",
-      dest="mode",
-      help="An alias for --mode=build",
-    )
-    ap.add_argument(
-      "-j",
-      "--num-jobs",
-      action="store",
-      type=int,
-      default=0,
-      help="Run the build or tests with the specified number of parallel jobs",
-    )
-    ap.add_argument(
-      "--install",
-      action="store_const",
-      const="install",
-      dest="mode",
-      help="An alias for --mode=install",
-    )
-    ap.add_argument(
-      "--test",
-      action="store_const",
-      const="test",
-      dest="mode",
-      help="An alias for --mode=test",
-    )
-    args = ap.parse_args()
-
-    # Strip off a leading "--" from the additional CMake arguments
-    if args.cmake_args and args.cmake_args[0] == "--":
-        args.cmake_args = args.cmake_args[1:]
-
-    env = CMAKE_ENV
-
-    if args.mode == "configure":
-        full_cmd = CMD_PREFIX + [CMAKE, SRC_DIR] + CMAKE_DEFINE_ARGS + args.cmake_args
-    elif args.mode in ("build", "install"):
-        target = "all" if args.mode == "build" else "install"
-        full_cmd = CMD_PREFIX + [
-                CMAKE,
-                "--build",
-                BUILD_DIR,
-                "--target",
-                target,
-                "--config",
-                "Release",
-                get_jobs_argument(args.num_jobs),
-        ] + args.cmake_args
-    elif args.mode == "test":
-        full_cmd = CMD_PREFIX + [
-            {dev_run_script}CTEST,
-            "--output-on-failure",
-            get_jobs_argument(args.num_jobs),
-        ] + args.cmake_args
-    else:
-        ap.error("unknown invocation mode: %s" % (args.mode,))
-
-    cmd_str = " ".join(full_cmd)
-    print("Running: %r" % (cmd_str,))
-    proc = subprocess.run(full_cmd, env=env, cwd=BUILD_DIR)
-    sys.exit(proc.returncode)
-
-
-if __name__ == "__main__":
-    main()
-"""
-
-    def __init__(
-        self,
-        build_opts,
-        ctx,
-        manifest,
-        src_dir,
-        build_dir,
-        inst_dir,
-        defines,
-        loader=None,
-        final_install_prefix=None,
-        extra_cmake_defines=None,
-        cmake_target="install",
-    ) -> None:
-        super(CMakeBuilder, self).__init__(
-            build_opts,
-            ctx,
-            manifest,
-            src_dir,
-            build_dir,
-            inst_dir,
-            final_install_prefix=final_install_prefix,
-        )
-        self.defines = defines or {}
-        if extra_cmake_defines:
-            self.defines.update(extra_cmake_defines)
-        self.cmake_target = cmake_target
-
-        try:
-            from .facebook.vcvarsall import extra_vc_cmake_defines
-        except ImportError:
-            pass
-        else:
-            self.defines.update(extra_vc_cmake_defines)
-
-        self.loader = loader
-        if build_opts.shared_libs:
-            self.defines["BUILD_SHARED_LIBS"] = "ON"
-
-    def _invalidate_cache(self) -> None:
-        for name in [
-            "CMakeCache.txt",
-            "CMakeFiles/CMakeError.log",
-            "CMakeFiles/CMakeOutput.log",
-        ]:
-            name = os.path.join(self.build_dir, name)
-            if os.path.isdir(name):
-                shutil.rmtree(name)
-            elif os.path.exists(name):
-                os.unlink(name)
-
-    def _needs_reconfigure(self) -> bool:
-        for name in ["CMakeCache.txt", "build.ninja"]:
-            name = os.path.join(self.build_dir, name)
-            if not os.path.exists(name):
-                return True
-        return False
-
-    def _write_build_script(self, **kwargs) -> None:
-        env_lines = ["    {!r}: {!r},".format(k, v) for k, v in kwargs["env"].items()]
-        kwargs["env_str"] = "\n".join(["{"] + env_lines + ["}"])
-
-        if self.build_opts.is_windows():
-            kwargs["dev_run_script"] = '"powershell.exe", {!r}, '.format(
-                self.get_dev_run_script_path()
-            )
-        else:
-            kwargs["dev_run_script"] = ""
-
-        define_arg_lines = ["["]
-        for arg in kwargs["define_args"]:
-            # Replace the CMAKE_INSTALL_PREFIX argument to use the INSTALL_DIR
-            # variable that we define in the MANUAL_BUILD_SCRIPT code.
-            if arg.startswith("-DCMAKE_INSTALL_PREFIX="):
-                value = "    {!r}.format(INSTALL_DIR),".format(
-                    "-DCMAKE_INSTALL_PREFIX={}"
-                )
-            else:
-                value = "    {!r},".format(arg)
-            define_arg_lines.append(value)
-        define_arg_lines.append("]")
-        kwargs["define_args_str"] = "\n".join(define_arg_lines)
-
-        # In order to make it easier for developers to manually run builds for
-        # CMake-based projects, write out some build scripts that can be used to invoke
-        # CMake manually.
-        build_script_path = os.path.join(self.build_dir, "run_cmake.py")
-        script_contents = self.MANUAL_BUILD_SCRIPT.format(**kwargs)
-        with open(build_script_path, "wb") as f:
-            f.write(script_contents.encode())
-        os.chmod(build_script_path, 0o755)
-
-    def _compute_cmake_define_args(self, env):
-        defines = {
-            "CMAKE_INSTALL_PREFIX": self.final_install_prefix or self.inst_dir,
-            "BUILD_SHARED_LIBS": "OFF",
-            # Some of the deps (rsocket) default to UBSAN enabled if left
-            # unspecified.  Some of the deps fail to compile in release mode
-            # due to warning->error promotion.  RelWithDebInfo is the happy
-            # medium.
-            "CMAKE_BUILD_TYPE": "RelWithDebInfo",
-        }
-        if "SANDCASTLE" not in os.environ:
-            # We sometimes see intermittent ccache related breakages on some
-            # of the FB internal CI hosts, so we prefer to disable ccache
-            # when running in that environment.
-            ccache = path_search(env, "ccache")
-            if ccache:
-                defines["CMAKE_CXX_COMPILER_LAUNCHER"] = ccache
-        else:
-            # rocksdb does its own probing for ccache.
-            # Ensure that it is disabled on sandcastle
-            env["CCACHE_DISABLE"] = "1"
-            # Some sandcastle hosts have broken ccache related dirs, and
-            # even though we've asked for it to be disabled ccache is
-            # still invoked by rocksdb's cmake.
-            # Redirect its config directory to somewhere that is guaranteed
-            # fresh to us, and that won't have any ccache data inside.
-            env["CCACHE_DIR"] = f"{self.build_opts.scratch_dir}/ccache"
-
-        if "GITHUB_ACTIONS" in os.environ and self.build_opts.is_windows():
-            # GitHub actions: the host has both gcc and msvc installed, and
-            # the default behavior of cmake is to prefer gcc.
-            # Instruct cmake that we want it to use cl.exe; this is important
-            # because Boost prefers cl.exe and the mismatch results in cmake
-            # with gcc not being able to find boost built with cl.exe.
-            defines["CMAKE_C_COMPILER"] = "cl.exe"
-            defines["CMAKE_CXX_COMPILER"] = "cl.exe"
-
-        if self.build_opts.is_darwin():
-            # Try to persuade cmake to set the rpath to match the lib
-            # dirs of the dependencies.  This isn't automatic, and to
-            # make things more interesting, cmake uses `;` as the path
-            # separator, so translate the runtime path to something
-            # that cmake will parse
-            defines["CMAKE_INSTALL_RPATH"] = ";".join(
-                env.get("DYLD_LIBRARY_PATH", "").split(":")
-            )
-            # Tell cmake that we want to set the rpath in the tree
-            # at build time.  Without this the rpath is only set
-            # at the moment that the binaries are installed.  That
-            # default is problematic for example when using the
-            # gtest integration in cmake which runs the built test
-            # executables during the build to discover the set of
-            # tests.
-            defines["CMAKE_BUILD_WITH_INSTALL_RPATH"] = "ON"
-
-        boost_169_is_required = False
-        if self.loader:
-            for m in self.loader.manifests_in_dependency_order():
-                preinstalled = m.get_section_as_dict("preinstalled.env", self.ctx)
-                boost_169_is_required = "BOOST_ROOT_1_69_0" in preinstalled.keys()
-                if boost_169_is_required:
-                    break
-
-        if (
-            boost_169_is_required
-            and self.build_opts.allow_system_packages
-            and self.build_opts.host_type.get_package_manager()
-            and self.build_opts.host_type.get_package_manager() == "rpm"
-        ):
-            # Boost 1.69 rpms don't install cmake config to the system, so to point to them explicitly
-            defines["BOOST_INCLUDEDIR"] = "/usr/include/boost169"
-            defines["BOOST_LIBRARYDIR"] = "/usr/lib64/boost169"
-
-        defines.update(self.defines)
-        define_args = ["-D%s=%s" % (k, v) for (k, v) in defines.items()]
-
-        # if self.build_opts.is_windows():
-        #    define_args += ["-G", "Visual Studio 15 2017 Win64"]
-        define_args += ["-G", "Ninja"]
-
-        return define_args
-
-    def _build(self, install_dirs, reconfigure: bool) -> None:
-        reconfigure = reconfigure or self._needs_reconfigure()
-
-        env = self._compute_env(install_dirs)
-        if not self.build_opts.is_windows() and self.final_install_prefix:
-            env["DESTDIR"] = self.inst_dir
-
-        # Resolve the cmake that we installed
-        cmake = path_search(env, "cmake")
-        if cmake is None:
-            raise Exception("Failed to find CMake")
-
-        if reconfigure:
-            define_args = self._compute_cmake_define_args(env)
-            self._write_build_script(
-                cmd_prefix=self._get_cmd_prefix(),
-                cmake=cmake,
-                ctest=path_search(env, "ctest"),
-                env=env,
-                define_args=define_args,
-                src_dir=self.src_dir,
-                build_dir=self.build_dir,
-                install_dir=self.inst_dir,
-                sys=sys,
-            )
-
-            self._invalidate_cache()
-            self._run_cmd([cmake, self.src_dir] + define_args, env=env)
-
-        self._run_cmd(
-            [
-                cmake,
-                "--build",
-                self.build_dir,
-                "--target",
-                self.cmake_target,
-                "--config",
-                "Release",
-                "-j",
-                str(self.num_jobs),
-            ],
-            env=env,
-        )
-
-    def run_tests(
-        self, install_dirs, schedule_type, owner, test_filter, retry: int, no_testpilot
-    ) -> None:
-        env = self._compute_env(install_dirs)
-        ctest = path_search(env, "ctest")
-        cmake = path_search(env, "cmake")
-
-        def require_command(path: Optional[str], name: str) -> str:
-            if path is None:
-                raise RuntimeError("unable to find command `{}`".format(name))
-            return path
-
-        # On Windows, we also need to update $PATH to include the directories that
-        # contain runtime library dependencies.  This is not needed on other platforms
-        # since CMake will emit RPATH properly in the binary so they can find these
-        # dependencies.
-        if self.build_opts.is_windows():
-            path_entries = self.get_dev_run_extra_path_dirs(install_dirs)
-            path = env.get("PATH")
-            if path:
-                path_entries.insert(0, path)
-            env["PATH"] = ";".join(path_entries)
-
-        # Don't use the cmd_prefix when running tests.  This is vcvarsall.bat on
-        # Windows.  vcvarsall.bat is only needed for the build, not tests.  It
-        # unfortunately fails if invoked with a long PATH environment variable when
-        # running the tests.
-        use_cmd_prefix = False
-
-        def get_property(test, propname, defval=None):
-            """extracts a named property from a cmake test info json blob.
-            The properties look like:
-            [{"name": "WORKING_DIRECTORY"},
-             {"value": "something"}]
-            We assume that it is invalid for the same named property to be
-            listed more than once.
-            """
-            props = test.get("properties", [])
-            for p in props:
-                if p.get("name", None) == propname:
-                    return p.get("value", defval)
-            return defval
-
-        def list_tests():
-            output = subprocess.check_output(
-                [require_command(ctest, "ctest"), "--show-only=json-v1"],
-                env=env,
-                cwd=self.build_dir,
-            )
-            try:
-                data = json.loads(output.decode("utf-8"))
-            except ValueError as exc:
-                raise Exception(
-                    "Failed to decode cmake test info using %s: %s.  Output was: %r"
-                    % (ctest, str(exc), output)
-                )
-
-            tests = []
-            machine_suffix = self.build_opts.host_type.as_tuple_string()
-            for test in data["tests"]:
-                working_dir = get_property(test, "WORKING_DIRECTORY")
-                labels = []
-                machine_suffix = self.build_opts.host_type.as_tuple_string()
-                labels.append("tpx-fb-test-type=3")
-                labels.append("tpx_test_config::buildsystem=getdeps")
-                labels.append("tpx_test_config::platform={}".format(machine_suffix))
-
-                if get_property(test, "DISABLED"):
-                    labels.append("disabled")
-                command = test["command"]
-                if working_dir:
-                    command = [
-                        require_command(cmake, "cmake"),
-                        "-E",
-                        "chdir",
-                        working_dir,
-                    ] + command
-
-                import os
-
-                tests.append(
-                    {
-                        "type": "custom",
-                        "target": "%s-%s-getdeps-%s"
-                        % (self.manifest.name, test["name"], machine_suffix),
-                        "command": command,
-                        "labels": labels,
-                        "env": {},
-                        "required_paths": [],
-                        "contacts": [],
-                        "cwd": os.getcwd(),
-                    }
-                )
-            return tests
-
-        if schedule_type == "continuous" or schedule_type == "testwarden":
-            # for continuous and testwarden runs, disabling retry can give up
-            # better signals for flaky tests.
-            retry = 0
-
-        tpx = path_search(env, "tpx")
-        if tpx and not no_testpilot:
-            buck_test_info = list_tests()
-            import os
-
-            from .facebook.testinfra import start_run
-
-            buck_test_info_name = os.path.join(self.build_dir, ".buck-test-info.json")
-            with open(buck_test_info_name, "w") as f:
-                json.dump(buck_test_info, f)
-
-            env.set("http_proxy", "")
-            env.set("https_proxy", "")
-            runs = []
-            from sys import platform
-
-            with start_run(env["FBSOURCE_HASH"]) as run_id:
-                testpilot_args = [
-                    tpx,
-                    "--force-local-execution",
-                    "--buck-test-info",
-                    buck_test_info_name,
-                    "--retry=%d" % retry,
-                    "-j=%s" % str(self.num_jobs),
-                    "--print-long-results",
-                ]
-
-                if owner:
-                    testpilot_args += ["--contacts", owner]
-
-                if env:
-                    testpilot_args.append("--env")
-                    testpilot_args.extend(f"{key}={val}" for key, val in env.items())
-
-                if run_id is not None:
-                    testpilot_args += ["--run-id", run_id]
-
-                if test_filter:
-                    testpilot_args += ["--", test_filter]
-
-                if schedule_type == "diff":
-                    runs.append(["--collection", "oss-diff", "--purpose", "diff"])
-                elif schedule_type == "continuous":
-                    runs.append(
-                        [
-                            "--tag-new-tests",
-                            "--collection",
-                            "oss-continuous",
-                            "--purpose",
-                            "continuous",
-                        ]
-                    )
-                elif schedule_type == "testwarden":
-                    # One run to assess new tests
-                    runs.append(
-                        [
-                            "--tag-new-tests",
-                            "--collection",
-                            "oss-new-test-stress",
-                            "--stress-runs",
-                            "10",
-                            "--purpose",
-                            "stress-run-new-test",
-                        ]
-                    )
-                    # And another for existing tests
-                    runs.append(
-                        [
-                            "--tag-new-tests",
-                            "--collection",
-                            "oss-existing-test-stress",
-                            "--stress-runs",
-                            "10",
-                            "--purpose",
-                            "stress-run",
-                        ]
-                    )
-                else:
-                    runs.append([])
-
-                for run in runs:
-                    self._run_cmd(
-                        testpilot_args + run,
-                        cwd=self.build_opts.fbcode_builder_dir,
-                        env=env,
-                        use_cmd_prefix=use_cmd_prefix,
-                    )
-        else:
-            args = [
-                require_command(ctest, "ctest"),
-                "--output-on-failure",
-                "-j",
-                str(self.num_jobs),
-            ]
-            if test_filter:
-                args += ["-R", test_filter]
-
-            count = 0
-            while count <= retry:
-                retcode = self._run_cmd(
-                    args, env=env, use_cmd_prefix=use_cmd_prefix, allow_fail=True
-                )
-
-                if retcode == 0:
-                    break
-                if count == 0:
-                    # Only add this option in the second run.
-                    args += ["--rerun-failed"]
-                count += 1
-            # pyre-fixme[61]: `retcode` is undefined, or not always defined.
-            if retcode != 0:
-                # Allow except clause in getdeps.main to catch and exit gracefully
-                # This allows non-testpilot runs to fail through the same logic as failed testpilot runs, which may become handy in case if post test processing is needed in the future
-                # pyre-fixme[61]: `retcode` is undefined, or not always defined.
-                raise subprocess.CalledProcessError(retcode, args)
-
-
-class NinjaBootstrap(BuilderBase):
-    def __init__(self, build_opts, ctx, manifest, build_dir, src_dir, inst_dir) -> None:
-        super(NinjaBootstrap, self).__init__(
-            build_opts, ctx, manifest, src_dir, build_dir, inst_dir
-        )
-
-    def _build(self, install_dirs, reconfigure) -> None:
-        self._run_cmd([sys.executable, "configure.py", "--bootstrap"], cwd=self.src_dir)
-        src_ninja = os.path.join(self.src_dir, "ninja")
-        dest_ninja = os.path.join(self.inst_dir, "bin/ninja")
-        bin_dir = os.path.dirname(dest_ninja)
-        if not os.path.exists(bin_dir):
-            os.makedirs(bin_dir)
-        shutil.copyfile(src_ninja, dest_ninja)
-        shutil.copymode(src_ninja, dest_ninja)
-
-
-class OpenSSLBuilder(BuilderBase):
-    def __init__(self, build_opts, ctx, manifest, build_dir, src_dir, inst_dir) -> None:
-        super(OpenSSLBuilder, self).__init__(
-            build_opts, ctx, manifest, src_dir, build_dir, inst_dir
-        )
-
-    def _build(self, install_dirs, reconfigure) -> None:
-        configure = os.path.join(self.src_dir, "Configure")
-
-        # prefer to resolve the perl that we installed from
-        # our manifest on windows, but fall back to the system
-        # path on eg: darwin
-        env = self.env.copy()
-        for d in install_dirs:
-            bindir = os.path.join(d, "bin")
-            add_path_entry(env, "PATH", bindir, append=False)
-
-        perl = typing.cast(str, path_search(env, "perl", "perl"))
-
-        make_j_args = []
-        if self.build_opts.is_windows():
-            make = "nmake.exe"
-            args = ["VC-WIN64A-masm", "-utf-8"]
-        elif self.build_opts.is_darwin():
-            make = "make"
-            make_j_args = ["-j%s" % self.num_jobs]
-            args = (
-                ["darwin64-x86_64-cc"]
-                if not self.build_opts.is_arm()
-                else ["darwin64-arm64-cc"]
-            )
-        elif self.build_opts.is_linux():
-            make = "make"
-            make_j_args = ["-j%s" % self.num_jobs]
-            args = (
-                ["linux-x86_64"] if not self.build_opts.is_arm() else ["linux-aarch64"]
-            )
-        else:
-            raise Exception("don't know how to build openssl for %r" % self.ctx)
-
-        self._run_cmd(
-            [
-                perl,
-                configure,
-                "--prefix=%s" % self.inst_dir,
-                "--openssldir=%s" % self.inst_dir,
-            ]
-            + args
-            + [
-                "enable-static-engine",
-                "enable-capieng",
-                "no-makedepend",
-                "no-unit-test",
-                "no-tests",
-            ]
-        )
-        make_build = [make] + make_j_args
-        self._run_cmd(make_build)
-        make_install = [make, "install_sw", "install_ssldirs"]
-        self._run_cmd(make_install)
-
-
-class Boost(BuilderBase):
-    def __init__(
-        self, build_opts, ctx, manifest, src_dir, build_dir, inst_dir, b2_args
-    ) -> None:
-        children = os.listdir(src_dir)
-        assert len(children) == 1, "expected a single directory entry: %r" % (children,)
-        boost_src = children[0]
-        assert boost_src.startswith("boost")
-        src_dir = os.path.join(src_dir, children[0])
-        super(Boost, self).__init__(
-            build_opts, ctx, manifest, src_dir, build_dir, inst_dir
-        )
-        self.b2_args = b2_args
-
-    def _build(self, install_dirs, reconfigure) -> None:
-        env = self._compute_env(install_dirs)
-        linkage = ["static"]
-        if self.build_opts.is_windows() or self.build_opts.shared_libs:
-            linkage.append("shared")
-
-        args = []
-        if self.build_opts.is_darwin():
-            clang = subprocess.check_output(["xcrun", "--find", "clang"])
-            user_config = os.path.join(self.build_dir, "project-config.jam")
-            with open(user_config, "w") as jamfile:
-                jamfile.write("using clang : : %s ;\n" % clang.decode().strip())
-            args.append("--user-config=%s" % user_config)
-
-        for link in linkage:
-            bootstrap_args = self.manifest.get_section_as_args(
-                "bootstrap.args", self.ctx
-            )
-            if self.build_opts.is_windows():
-                bootstrap = os.path.join(self.src_dir, "bootstrap.bat")
-                self._run_cmd([bootstrap] + bootstrap_args, cwd=self.src_dir, env=env)
-                args += ["address-model=64"]
-            else:
-                bootstrap = os.path.join(self.src_dir, "bootstrap.sh")
-                self._run_cmd(
-                    [bootstrap, "--prefix=%s" % self.inst_dir] + bootstrap_args,
-                    cwd=self.src_dir,
-                    env=env,
-                )
-
-            b2 = os.path.join(self.src_dir, "b2")
-            self._run_cmd(
-                [
-                    b2,
-                    "-j%s" % self.num_jobs,
-                    "--prefix=%s" % self.inst_dir,
-                    "--builddir=%s" % self.build_dir,
-                ]
-                + args
-                + self.b2_args
-                + [
-                    "link=%s" % link,
-                    "runtime-link=shared",
-                    "variant=release",
-                    "threading=multi",
-                    "debug-symbols=on",
-                    "visibility=global",
-                    "-d2",
-                    "install",
-                ],
-                cwd=self.src_dir,
-                env=env,
-            )
-
-
-class NopBuilder(BuilderBase):
-    def __init__(self, build_opts, ctx, manifest, src_dir, inst_dir) -> None:
-        super(NopBuilder, self).__init__(
-            build_opts, ctx, manifest, src_dir, None, inst_dir
-        )
-
-    def build(self, install_dirs, reconfigure: bool) -> None:
-        print("Installing %s -> %s" % (self.src_dir, self.inst_dir))
-        parent = os.path.dirname(self.inst_dir)
-        if not os.path.exists(parent):
-            os.makedirs(parent)
-
-        install_files = self.manifest.get_section_as_ordered_pairs(
-            "install.files", self.ctx
-        )
-        if install_files:
-            for src_name, dest_name in self.manifest.get_section_as_ordered_pairs(
-                "install.files", self.ctx
-            ):
-                full_dest = os.path.join(self.inst_dir, dest_name)
-                full_src = os.path.join(self.src_dir, src_name)
-
-                dest_parent = os.path.dirname(full_dest)
-                if not os.path.exists(dest_parent):
-                    os.makedirs(dest_parent)
-                if os.path.isdir(full_src):
-                    if not os.path.exists(full_dest):
-                        shutil.copytree(full_src, full_dest)
-                else:
-                    shutil.copyfile(full_src, full_dest)
-                    shutil.copymode(full_src, full_dest)
-                    # This is a bit gross, but the mac ninja.zip doesn't
-                    # give ninja execute permissions, so force them on
-                    # for things that look like they live in a bin dir
-                    if os.path.dirname(dest_name) == "bin":
-                        st = os.lstat(full_dest)
-                        os.chmod(full_dest, st.st_mode | stat.S_IXUSR)
-        else:
-            if not os.path.exists(self.inst_dir):
-                shutil.copytree(self.src_dir, self.inst_dir)
-
-
-class SqliteBuilder(BuilderBase):
-    def __init__(self, build_opts, ctx, manifest, src_dir, build_dir, inst_dir) -> None:
-        super(SqliteBuilder, self).__init__(
-            build_opts, ctx, manifest, src_dir, build_dir, inst_dir
-        )
-
-    def _build(self, install_dirs, reconfigure) -> None:
-        for f in ["sqlite3.c", "sqlite3.h", "sqlite3ext.h"]:
-            src = os.path.join(self.src_dir, f)
-            dest = os.path.join(self.build_dir, f)
-            copy_if_different(src, dest)
-
-        cmake_lists = """
-cmake_minimum_required(VERSION 3.1.3 FATAL_ERROR)
-project(sqlite3 C)
-add_library(sqlite3 STATIC sqlite3.c)
-# These options are taken from the defaults in Makefile.msc in
-# the sqlite distribution
-target_compile_definitions(sqlite3 PRIVATE
-    -DSQLITE_ENABLE_COLUMN_METADATA=1
-    -DSQLITE_ENABLE_FTS3=1
-    -DSQLITE_ENABLE_RTREE=1
-    -DSQLITE_ENABLE_GEOPOLY=1
-    -DSQLITE_ENABLE_JSON1=1
-    -DSQLITE_ENABLE_STMTVTAB=1
-    -DSQLITE_ENABLE_DBPAGE_VTAB=1
-    -DSQLITE_ENABLE_DBSTAT_VTAB=1
-    -DSQLITE_INTROSPECTION_PRAGMAS=1
-    -DSQLITE_ENABLE_DESERIALIZE=1
-)
-install(TARGETS sqlite3)
-install(FILES sqlite3.h sqlite3ext.h DESTINATION include)
-            """
-
-        with open(os.path.join(self.build_dir, "CMakeLists.txt"), "w") as f:
-            f.write(cmake_lists)
-
-        defines = {
-            "CMAKE_INSTALL_PREFIX": self.inst_dir,
-            "BUILD_SHARED_LIBS": "ON" if self.build_opts.shared_libs else "OFF",
-            "CMAKE_BUILD_TYPE": "RelWithDebInfo",
-        }
-        define_args = ["-D%s=%s" % (k, v) for (k, v) in defines.items()]
-        define_args += ["-G", "Ninja"]
-
-        env = self._compute_env(install_dirs)
-
-        # Resolve the cmake that we installed
-        cmake = path_search(env, "cmake")
-
-        self._run_cmd([cmake, self.build_dir] + define_args, env=env)
-        self._run_cmd(
-            [
-                cmake,
-                "--build",
-                self.build_dir,
-                "--target",
-                "install",
-                "--config",
-                "Release",
-                "-j",
-                str(self.num_jobs),
-            ],
-            env=env,
-        )
diff --git a/build/fbcode_builder/getdeps/buildopts.py b/build/fbcode_builder/getdeps/buildopts.py
deleted file mode 100644
index 48b000f90ebc0..0000000000000
--- a/build/fbcode_builder/getdeps/buildopts.py
+++ /dev/null
@@ -1,619 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import errno
-import glob
-import ntpath
-import os
-import subprocess
-import sys
-import tempfile
-from typing import Mapping, Optional
-
-from .copytree import containing_repo_type
-from .envfuncs import add_flag, add_path_entry, Env
-from .fetcher import get_fbsource_repo_data, homebrew_package_prefix
-from .manifest import ContextGenerator
-from .platform import get_available_ram, HostType, is_windows
-
-
-def detect_project(path):
-    repo_type, repo_root = containing_repo_type(path)
-    if repo_type is None:
-        return None, None
-
-    # Look for a .projectid file.  If it exists, read the project name from it.
-    project_id_path = os.path.join(repo_root, ".projectid")
-    try:
-        with open(project_id_path, "r") as f:
-            project_name = f.read().strip()
-            return repo_root, project_name
-    except EnvironmentError as ex:
-        if ex.errno != errno.ENOENT:
-            raise
-
-    return repo_root, None
-
-
-class BuildOptions(object):
-    def __init__(
-        self,
-        fbcode_builder_dir,
-        scratch_dir,
-        host_type,
-        install_dir=None,
-        num_jobs: int = 0,
-        use_shipit: bool = False,
-        vcvars_path=None,
-        allow_system_packages: bool = False,
-        lfs_path=None,
-        shared_libs: bool = False,
-        facebook_internal=None,
-        free_up_disk: bool = False,
-    ) -> None:
-        """fbcode_builder_dir - the path to either the in-fbsource fbcode_builder dir,
-                             or for shipit-transformed repos, the build dir that
-                             has been mapped into that dir.
-        scratch_dir - a place where we can store repos and build bits.
-                      This path should be stable across runs and ideally
-                      should not be in the repo of the project being built,
-                      but that is ultimately where we generally fall back
-                      for builds outside of FB
-        install_dir - where the project will ultimately be installed
-        num_jobs - the level of concurrency to use while building
-        use_shipit - use real shipit instead of the simple shipit transformer
-        vcvars_path - Path to external VS toolchain's vsvarsall.bat
-        shared_libs - whether to build shared libraries
-        free_up_disk - take extra actions to save runner disk space
-        """
-
-        if not install_dir:
-            install_dir = os.path.join(scratch_dir, "installed")
-
-        self.project_hashes = None
-        for p in ["../deps/github_hashes", "../project_hashes"]:
-            hashes = os.path.join(fbcode_builder_dir, p)
-            if os.path.exists(hashes):
-                self.project_hashes = hashes
-                break
-
-        # Detect what repository and project we are being run from.
-        self.repo_root, self.repo_project = detect_project(os.getcwd())
-
-        # If we are running from an fbsource repository, set self.fbsource_dir
-        # to allow the ShipIt-based fetchers to use it.
-        if self.repo_project == "fbsource":
-            self.fbsource_dir: Optional[str] = self.repo_root
-        else:
-            self.fbsource_dir = None
-
-        if facebook_internal is None:
-            if self.fbsource_dir:
-                facebook_internal = True
-            else:
-                facebook_internal = False
-
-        self.facebook_internal = facebook_internal
-        self.specified_num_jobs = num_jobs
-        self.scratch_dir = scratch_dir
-        self.install_dir = install_dir
-        self.fbcode_builder_dir = fbcode_builder_dir
-        self.host_type = host_type
-        self.use_shipit = use_shipit
-        self.allow_system_packages = allow_system_packages
-        self.lfs_path = lfs_path
-        self.shared_libs = shared_libs
-        self.free_up_disk = free_up_disk
-
-        lib_path = None
-        if self.is_darwin():
-            lib_path = "DYLD_LIBRARY_PATH"
-        elif self.is_linux():
-            lib_path = "LD_LIBRARY_PATH"
-        elif self.is_windows():
-            lib_path = "PATH"
-        else:
-            lib_path = None
-        self.lib_path = lib_path
-
-        if vcvars_path is None and is_windows():
-
-            try:
-                # Allow a site-specific vcvarsall path.
-                from .facebook.vcvarsall import build_default_vcvarsall
-            except ImportError:
-                vcvarsall = []
-            else:
-                vcvarsall = (
-                    build_default_vcvarsall(self.fbsource_dir)
-                    if self.fbsource_dir is not None
-                    else []
-                )
-
-            # On Windows, the compiler is not available in the PATH by
-            # default so we need to run the vcvarsall script to populate the
-            # environment. We use a glob to find some version of this script
-            # as deployed with Visual Studio 2017.  This logic can also
-            # locate Visual Studio 2019 but note that at the time of writing
-            # the version of boost in our manifest cannot be built with
-            # VS 2019, so we're effectively tied to VS 2017 until we upgrade
-            # the boost dependency.
-            for year in ["2017", "2019"]:
-                vcvarsall += glob.glob(
-                    os.path.join(
-                        os.environ["ProgramFiles(x86)"],
-                        "Microsoft Visual Studio",
-                        year,
-                        "*",
-                        "VC",
-                        "Auxiliary",
-                        "Build",
-                        "vcvarsall.bat",
-                    )
-                )
-            vcvars_path = vcvarsall[0]
-
-        self.vcvars_path = vcvars_path
-
-    @property
-    def manifests_dir(self):
-        return os.path.join(self.fbcode_builder_dir, "manifests")
-
-    def is_darwin(self):
-        return self.host_type.is_darwin()
-
-    def is_windows(self):
-        return self.host_type.is_windows()
-
-    def is_arm(self):
-        return self.host_type.is_arm()
-
-    def get_vcvars_path(self):
-        return self.vcvars_path
-
-    def is_linux(self):
-        return self.host_type.is_linux()
-
-    def is_freebsd(self):
-        return self.host_type.is_freebsd()
-
-    def get_num_jobs(self, job_weight: int) -> int:
-        """Given an estimated job_weight in MiB, compute a reasonable concurrency limit."""
-        if self.specified_num_jobs:
-            return self.specified_num_jobs
-
-        available_ram = get_available_ram()
-
-        import multiprocessing
-
-        return max(1, min(multiprocessing.cpu_count(), available_ram // job_weight))
-
-    def get_context_generator(self, host_tuple=None):
-        """Create a manifest ContextGenerator for the specified target platform."""
-        if host_tuple is None:
-            host_type = self.host_type
-        elif isinstance(host_tuple, HostType):
-            host_type = host_tuple
-        else:
-            host_type = HostType.from_tuple_string(host_tuple)
-
-        return ContextGenerator(
-            {
-                "os": host_type.ostype,
-                "distro": host_type.distro,
-                "distro_vers": host_type.distrovers,
-                "fb": "on" if self.facebook_internal else "off",
-                "fbsource": "on" if self.fbsource_dir else "off",
-                "test": "off",
-                "shared_libs": "on" if self.shared_libs else "off",
-            }
-        )
-
-    def compute_env_for_install_dirs(
-        self, install_dirs, env=None, manifest=None
-    ):  # noqa: C901
-        if env is not None:
-            env = env.copy()
-        else:
-            env = Env()
-
-        env["GETDEPS_BUILD_DIR"] = os.path.join(self.scratch_dir, "build")
-        env["GETDEPS_INSTALL_DIR"] = self.install_dir
-
-        # Python setuptools attempts to discover a local MSVC for
-        # building Python extensions. On Windows, getdeps already
-        # supports invoking a vcvarsall prior to compilation.
-        #
-        # Tell setuptools to bypass its own search. This fixes a bug
-        # where setuptools would fail when run from CMake on GitHub
-        # Actions with the inscrutable message 'error: Microsoft
-        # Visual C++ 14.0 is required. Get it with "Build Tools for
-        # Visual Studio"'. I suspect the actual error is that the
-        # environment or PATH is overflowing.
-        #
-        # For extra credit, someone could patch setuptools to
-        # propagate the actual error message from vcvarsall, because
-        # often it does not mean Visual C++ is not available.
-        #
-        # Related discussions:
-        # - https://github.com/pypa/setuptools/issues/2028
-        # - https://github.com/pypa/setuptools/issues/2307
-        # - https://developercommunity.visualstudio.com/t/error-microsoft-visual-c-140-is-required/409173
-        # - https://github.com/OpenMS/OpenMS/pull/4779
-        # - https://github.com/actions/virtual-environments/issues/1484
-
-        if self.is_windows() and self.get_vcvars_path():
-            env["DISTUTILS_USE_SDK"] = "1"
-
-        # On macOS we need to set `SDKROOT` when we use clang for system
-        # header files.
-        if self.is_darwin() and "SDKROOT" not in env:
-            sdkroot = subprocess.check_output(["xcrun", "--show-sdk-path"])
-            env["SDKROOT"] = sdkroot.decode().strip()
-
-        if (
-            self.is_darwin()
-            and self.allow_system_packages
-            and self.host_type.get_package_manager() == "homebrew"
-            and manifest
-            and manifest.resolved_system_packages
-        ):
-            # Homebrew packages may not be on the default PATHs
-            brew_packages = manifest.resolved_system_packages.get("homebrew", [])
-            for p in brew_packages:
-                found = self.add_homebrew_package_to_env(p, env)
-                # Try extra hard to find openssl, needed with homebrew on macOS
-                if found and p.startswith("openssl"):
-                    candidate = homebrew_package_prefix("openssl@1.1")
-                    if os.path.exists(candidate):
-                        os.environ["OPENSSL_ROOT_DIR"] = candidate
-                        env["OPENSSL_ROOT_DIR"] = os.environ["OPENSSL_ROOT_DIR"]
-
-        if self.fbsource_dir:
-            env["YARN_YARN_OFFLINE_MIRROR"] = os.path.join(
-                self.fbsource_dir, "xplat/third-party/yarn/offline-mirror"
-            )
-            yarn_exe = "yarn.bat" if self.is_windows() else "yarn"
-            env["YARN_PATH"] = os.path.join(
-                self.fbsource_dir, "xplat/third-party/yarn/", yarn_exe
-            )
-            node_exe = "node-win-x64.exe" if self.is_windows() else "node"
-            env["NODE_BIN"] = os.path.join(
-                self.fbsource_dir, "xplat/third-party/node/bin/", node_exe
-            )
-            env["RUST_VENDORED_CRATES_DIR"] = os.path.join(
-                self.fbsource_dir, "third-party/rust/vendor"
-            )
-            hash_data = get_fbsource_repo_data(self)
-            env["FBSOURCE_HASH"] = hash_data.hash
-            env["FBSOURCE_DATE"] = hash_data.date
-
-        # reverse as we are prepending to the PATHs
-        for d in reversed(install_dirs):
-            self.add_prefix_to_env(d, env, append=False)
-
-        # Linux is always system openssl
-        system_openssl = self.is_linux()
-
-        # For other systems lets see if package is requested
-        if not system_openssl and manifest and manifest.resolved_system_packages:
-            for _pkg_type, pkgs in manifest.resolved_system_packages.items():
-                for p in pkgs:
-                    if p.startswith("openssl") or p.startswith("libssl"):
-                        system_openssl = True
-                        break
-
-        # Let openssl know to pick up the system certs if present
-        if system_openssl or "OPENSSL_DIR" in env:
-            for system_ssl_cfg in ["/etc/pki/tls", "/etc/ssl"]:
-                if os.path.isdir(system_ssl_cfg):
-                    cert_dir = system_ssl_cfg + "/certs"
-                    if os.path.isdir(cert_dir):
-                        env["SSL_CERT_DIR"] = cert_dir
-                    cert_file = system_ssl_cfg + "/cert.pem"
-                    if os.path.isfile(cert_file):
-                        env["SSL_CERT_FILE"] = cert_file
-
-        return env
-
-    def add_homebrew_package_to_env(self, package, env) -> bool:
-        prefix = homebrew_package_prefix(package)
-        if prefix and os.path.exists(prefix):
-            return self.add_prefix_to_env(
-                prefix, env, append=False, add_library_path=True
-            )
-        return False
-
-    def add_prefix_to_env(
-        self, d, env, append: bool = True, add_library_path: bool = False
-    ) -> bool:  # noqa: C901
-        bindir = os.path.join(d, "bin")
-        found = False
-        pkgconfig = os.path.join(d, "lib", "pkgconfig")
-        if os.path.exists(pkgconfig):
-            found = True
-            add_path_entry(env, "PKG_CONFIG_PATH", pkgconfig, append=append)
-
-        pkgconfig = os.path.join(d, "lib64", "pkgconfig")
-        if os.path.exists(pkgconfig):
-            found = True
-            add_path_entry(env, "PKG_CONFIG_PATH", pkgconfig, append=append)
-
-        add_path_entry(env, "CMAKE_PREFIX_PATH", d, append=append)
-
-        # Tell the thrift compiler about includes it needs to consider
-        thriftdir = os.path.join(d, "include", "thrift-files")
-        if os.path.exists(thriftdir):
-            found = True
-            add_path_entry(env, "THRIFT_INCLUDE_PATH", thriftdir, append=append)
-
-        # module detection for python is old fashioned and needs flags
-        includedir = os.path.join(d, "include")
-        if os.path.exists(includedir):
-            found = True
-            ncursesincludedir = os.path.join(d, "include", "ncurses")
-            if os.path.exists(ncursesincludedir):
-                add_path_entry(env, "C_INCLUDE_PATH", ncursesincludedir, append=append)
-                add_flag(env, "CPPFLAGS", f"-I{includedir}", append=append)
-                add_flag(env, "CPPFLAGS", f"-I{ncursesincludedir}", append=append)
-            elif "/bz2-" in d:
-                add_flag(env, "CPPFLAGS", f"-I{includedir}", append=append)
-
-        # Map from FB python manifests to PYTHONPATH
-        pydir = os.path.join(d, "lib", "fb-py-libs")
-        if os.path.exists(pydir):
-            found = True
-            manifest_ext = ".manifest"
-            pymanifestfiles = [
-                f
-                for f in os.listdir(pydir)
-                if f.endswith(manifest_ext) and os.path.isfile(os.path.join(pydir, f))
-            ]
-            for f in pymanifestfiles:
-                subdir = f[: -len(manifest_ext)]
-                add_path_entry(
-                    env, "PYTHONPATH", os.path.join(pydir, subdir), append=append
-                )
-
-        # Allow resolving shared objects built earlier (eg: zstd
-        # doesn't include the full path to the dylib in its linkage
-        # so we need to give it an assist)
-        if self.lib_path:
-            for lib in ["lib", "lib64"]:
-                libdir = os.path.join(d, lib)
-                if os.path.exists(libdir):
-                    found = True
-                    add_path_entry(env, self.lib_path, libdir, append=append)
-                    # module detection for python is old fashioned and needs flags
-                    if "/ncurses-" in d:
-                        add_flag(env, "LDFLAGS", f"-L{libdir}", append=append)
-                    elif "/bz2-" in d:
-                        add_flag(env, "LDFLAGS", f"-L{libdir}", append=append)
-                    if add_library_path:
-                        add_path_entry(env, "LIBRARY_PATH", libdir, append=append)
-
-        # Allow resolving binaries (eg: cmake, ninja) and dlls
-        # built by earlier steps
-        if os.path.exists(bindir):
-            found = True
-            add_path_entry(env, "PATH", bindir, append=append)
-
-        # If rustc is present in the `bin` directory, set RUSTC to prevent
-        # cargo uses the rustc installed in the system.
-        if self.is_windows():
-            cargo_path = os.path.join(bindir, "cargo.exe")
-            rustc_path = os.path.join(bindir, "rustc.exe")
-            rustdoc_path = os.path.join(bindir, "rustdoc.exe")
-        else:
-            cargo_path = os.path.join(bindir, "cargo")
-            rustc_path = os.path.join(bindir, "rustc")
-            rustdoc_path = os.path.join(bindir, "rustdoc")
-
-        if os.path.isfile(rustc_path):
-            env["CARGO_BIN"] = cargo_path
-            env["RUSTC"] = rustc_path
-            env["RUSTDOC"] = rustdoc_path
-
-        openssl_include = os.path.join(d, "include", "openssl")
-        if os.path.isdir(openssl_include) and any(
-            os.path.isfile(os.path.join(d, "lib", libcrypto))
-            for libcrypto in ("libcrypto.lib", "libcrypto.so", "libcrypto.a")
-        ):
-            # This must be the openssl library, let Rust know about it
-            env["OPENSSL_DIR"] = d
-
-        return found
-
-
-def list_win32_subst_letters():
-    output = subprocess.check_output(["subst"]).decode("utf-8")
-    # The output is a set of lines like: `F:\: => C:\open\some\where`
-    lines = output.strip().split("\r\n")
-    mapping = {}
-    for line in lines:
-        fields = line.split(": => ")
-        if len(fields) != 2:
-            continue
-        letter = fields[0]
-        path = fields[1]
-        mapping[letter] = path
-
-    return mapping
-
-
-def find_existing_win32_subst_for_path(
-    path: str,
-    subst_mapping: Mapping[str, str],
-) -> Optional[str]:
-    path = ntpath.normcase(ntpath.normpath(path))
-    for letter, target in subst_mapping.items():
-        if ntpath.normcase(target) == path:
-            return letter
-    return None
-
-
-def find_unused_drive_letter():
-    import ctypes
-
-    buffer_len = 256
-    blen = ctypes.c_uint(buffer_len)
-    rv = ctypes.c_uint()
-    bufs = ctypes.create_string_buffer(buffer_len)
-    rv = ctypes.windll.kernel32.GetLogicalDriveStringsA(blen, bufs)
-    if rv > buffer_len:
-        raise Exception("GetLogicalDriveStringsA result too large for buffer")
-    nul = "\x00".encode("ascii")
-
-    used = [drive.decode("ascii")[0] for drive in bufs.raw.strip(nul).split(nul)]
-    possible = [c for c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
-    available = sorted(list(set(possible) - set(used)))
-    if len(available) == 0:
-        return None
-    # Prefer to assign later letters rather than earlier letters
-    return available[-1]
-
-
-def create_subst_path(path: str) -> str:
-    for _attempt in range(0, 24):
-        drive = find_existing_win32_subst_for_path(
-            path, subst_mapping=list_win32_subst_letters()
-        )
-        if drive:
-            return drive
-        available = find_unused_drive_letter()
-        if available is None:
-            raise Exception(
-                (
-                    "unable to make shorter subst mapping for %s; "
-                    "no available drive letters"
-                )
-                % path
-            )
-
-        # Try to set up a subst mapping; note that we may be racing with
-        # other processes on the same host, so this may not succeed.
-        try:
-            subprocess.check_call(["subst", "%s:" % available, path])
-            return "%s:\\" % available
-        except Exception:
-            print("Failed to map %s -> %s" % (available, path))
-
-    raise Exception("failed to set up a subst path for %s" % path)
-
-
-def _check_host_type(args, host_type):
-    if host_type is None:
-        host_tuple_string = getattr(args, "host_type", None)
-        if host_tuple_string:
-            host_type = HostType.from_tuple_string(host_tuple_string)
-        else:
-            host_type = HostType()
-
-    assert isinstance(host_type, HostType)
-    return host_type
-
-
-def setup_build_options(args, host_type=None) -> BuildOptions:
-    """Create a BuildOptions object based on the arguments"""
-
-    fbcode_builder_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    scratch_dir = args.scratch_path
-    if not scratch_dir:
-        # TODO: `mkscratch` doesn't currently know how best to place things on
-        # sandcastle, so whip up something reasonable-ish
-        if "SANDCASTLE" in os.environ:
-            if "DISK_TEMP" not in os.environ:
-                raise Exception(
-                    (
-                        "I need DISK_TEMP to be set in the sandcastle environment "
-                        "so that I can store build products somewhere sane"
-                    )
-                )
-            scratch_dir = os.path.join(
-                os.environ["DISK_TEMP"], "fbcode_builder_getdeps"
-            )
-        if not scratch_dir:
-            try:
-                scratch_dir = (
-                    subprocess.check_output(
-                        ["mkscratch", "path", "--subdir", "fbcode_builder_getdeps"]
-                    )
-                    .strip()
-                    .decode("utf-8")
-                )
-            except OSError as exc:
-                if exc.errno != errno.ENOENT:
-                    # A legit failure; don't fall back, surface the error
-                    raise
-                # This system doesn't have mkscratch so we fall back to
-                # something local.
-                munged = fbcode_builder_dir.replace("Z", "zZ")
-                for s in ["/", "\\", ":"]:
-                    munged = munged.replace(s, "Z")
-
-                if is_windows() and os.path.isdir("c:/open"):
-                    temp = "c:/open/scratch"
-                else:
-                    temp = tempfile.gettempdir()
-
-                scratch_dir = os.path.join(temp, "fbcode_builder_getdeps-%s" % munged)
-                if not is_windows() and os.geteuid() == 0:
-                    # Running as root; in the case where someone runs
-                    # sudo getdeps.py install-system-deps
-                    # and then runs as build without privs, we want to avoid creating
-                    # a scratch dir that the second stage cannot write to.
-                    # So we generate a different path if we are root.
-                    scratch_dir += "-root"
-
-        if not os.path.exists(scratch_dir):
-            os.makedirs(scratch_dir)
-
-        if is_windows():
-            subst = create_subst_path(scratch_dir)
-            print(
-                "Mapping scratch dir %s -> %s" % (scratch_dir, subst), file=sys.stderr
-            )
-            scratch_dir = subst
-    else:
-        if not os.path.exists(scratch_dir):
-            os.makedirs(scratch_dir)
-
-    # Make sure we normalize the scratch path.  This path is used as part of the hash
-    # computation for detecting if projects have been updated, so we need to always
-    # use the exact same string to refer to a given directory.
-    # But! realpath in some combinations of Windows/Python3 versions can expand the
-    # drive substitutions on Windows, so avoid that!
-    if not is_windows():
-        scratch_dir = os.path.realpath(scratch_dir)
-
-    # Save these args passed by the user in an env variable, so it
-    # can be used while hashing this build.
-    os.environ["GETDEPS_CMAKE_DEFINES"] = getattr(args, "extra_cmake_defines", "") or ""
-
-    host_type = _check_host_type(args, host_type)
-
-    build_args = {
-        k: v
-        for (k, v) in vars(args).items()
-        if k
-        in {
-            "num_jobs",
-            "use_shipit",
-            "vcvars_path",
-            "allow_system_packages",
-            "lfs_path",
-            "shared_libs",
-            "free_up_disk",
-        }
-    }
-
-    return BuildOptions(
-        fbcode_builder_dir,
-        scratch_dir,
-        host_type,
-        install_dir=args.install_prefix,
-        facebook_internal=args.facebook_internal,
-        **build_args,
-    )
diff --git a/build/fbcode_builder/getdeps/cache.py b/build/fbcode_builder/getdeps/cache.py
deleted file mode 100644
index 4d2786e7e1b5f..0000000000000
--- a/build/fbcode_builder/getdeps/cache.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-class ArtifactCache(object):
-    """The ArtifactCache is a small abstraction that allows caching
-    named things in some external storage mechanism.
-    The primary use case is for storing the build products on CI
-    systems to accelerate the build"""
-
-    def download_to_file(self, name, dest_file_name) -> bool:
-        """If `name` exists in the cache, download it and place it
-        in the specified `dest_file_name` location on the filesystem.
-        If a transient issue was encountered a TransientFailure shall
-        be raised.
-        If `name` doesn't exist in the cache `False` shall be returned.
-        If `dest_file_name` was successfully updated `True` shall be
-        returned.
-        All other conditions shall raise an appropriate exception."""
-        return False
-
-    def upload_from_file(self, name, source_file_name) -> None:
-        """Causes `name` to be populated in the cache by uploading
-        the contents of `source_file_name` to the storage system.
-        If a transient issue was encountered a TransientFailure shall
-        be raised.
-        If the upload failed for some other reason, an appropriate
-        exception shall be raised."""
-        pass
-
-
-def create_cache() -> None:
-    """This function is monkey patchable to provide an actual
-    implementation"""
-    return None
diff --git a/build/fbcode_builder/getdeps/cargo.py b/build/fbcode_builder/getdeps/cargo.py
deleted file mode 100644
index bb41cc3e294b1..0000000000000
--- a/build/fbcode_builder/getdeps/cargo.py
+++ /dev/null
@@ -1,449 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import os
-import re
-import shutil
-import typing
-
-from .builder import BuilderBase
-
-if typing.TYPE_CHECKING:
-    from .buildopts import BuildOptions
-
-
-class CargoBuilder(BuilderBase):
-    def __init__(
-        self,
-        build_opts: "BuildOptions",
-        ctx,
-        manifest,
-        src_dir,
-        build_dir,
-        inst_dir,
-        build_doc,
-        workspace_dir,
-        manifests_to_build,
-        loader,
-        cargo_config_file,
-    ) -> None:
-        super(CargoBuilder, self).__init__(
-            build_opts, ctx, manifest, src_dir, build_dir, inst_dir
-        )
-        self.build_doc = build_doc
-        self.ws_dir = workspace_dir
-        self.manifests_to_build = manifests_to_build and manifests_to_build.split(",")
-        self.loader = loader
-        self.cargo_config_file_subdir = cargo_config_file
-
-    def run_cargo(self, install_dirs, operation, args=None) -> None:
-        args = args or []
-        env = self._compute_env(install_dirs)
-        # Enable using nightly features with stable compiler
-        env["RUSTC_BOOTSTRAP"] = "1"
-        env["LIBZ_SYS_STATIC"] = "1"
-        cmd = [
-            "cargo",
-            operation,
-            "--workspace",
-            "-j%s" % self.num_jobs,
-        ] + args
-        self._run_cmd(cmd, cwd=self.workspace_dir(), env=env)
-
-    def build_source_dir(self):
-        return os.path.join(self.build_dir, "source")
-
-    def workspace_dir(self):
-        return os.path.join(self.build_source_dir(), self.ws_dir or "")
-
-    def manifest_dir(self, manifest):
-        return os.path.join(self.build_source_dir(), manifest)
-
-    def recreate_dir(self, src, dst) -> None:
-        if os.path.isdir(dst):
-            if os.path.islink(dst):
-                os.remove(dst)
-            else:
-                shutil.rmtree(dst)
-        shutil.copytree(src, dst)
-
-    def cargo_config_file(self):
-        build_source_dir = self.build_dir
-        if self.cargo_config_file_subdir:
-            return os.path.join(build_source_dir, self.cargo_config_file_subdir)
-        else:
-            return os.path.join(build_source_dir, ".cargo", "config")
-
-    def _create_cargo_config(self):
-        cargo_config_file = self.cargo_config_file()
-        cargo_config_dir = os.path.dirname(cargo_config_file)
-        if not os.path.isdir(cargo_config_dir):
-            os.mkdir(cargo_config_dir)
-
-        dep_to_git = self._resolve_dep_to_git()
-
-        if os.path.isfile(cargo_config_file):
-            with open(cargo_config_file, "r") as f:
-                print(f"Reading {cargo_config_file}")
-                cargo_content = f.read()
-        else:
-            cargo_content = ""
-
-        new_content = cargo_content
-        if "# Generated by getdeps.py" not in cargo_content:
-            new_content += """\
-# Generated by getdeps.py
-[build]
-target-dir = '''{}'''
-
-[profile.dev]
-debug = false
-incremental = false
-""".format(
-                self.build_dir.replace("\\", "\\\\")
-            )
-
-        # Point to vendored sources from getdeps manifests
-        for _dep, git_conf in dep_to_git.items():
-            if "cargo_vendored_sources" in git_conf:
-                vendored_dir = git_conf["cargo_vendored_sources"].replace("\\", "\\\\")
-                override = (
-                    f'[source."{git_conf["repo_url"]}"]\ndirectory = "{vendored_dir}"\n'
-                )
-                if override not in cargo_content:
-                    new_content += override
-
-        if new_content != cargo_content:
-            with open(cargo_config_file, "w") as f:
-                print(
-                    f"Writing cargo config for {self.manifest.name} to {cargo_config_file}"
-                )
-                f.write(new_content)
-
-        if self.build_opts.fbsource_dir:
-            # Point to vendored crates.io if possible
-            try:
-                from .facebook.rust import vendored_crates
-
-                vendored_crates(self.build_opts.fbsource_dir, cargo_config_file)
-            except ImportError:
-                # This FB internal module isn't shippped to github,
-                # so just rely on cargo downloading crates on it's own
-                pass
-
-        return dep_to_git
-
-    def _prepare(self, install_dirs, reconfigure) -> None:
-        build_source_dir = self.build_source_dir()
-        self.recreate_dir(self.src_dir, build_source_dir)
-
-        dep_to_git = self._create_cargo_config()
-
-        if self.ws_dir is not None:
-            self._patchup_workspace(dep_to_git)
-
-    def _build(self, install_dirs, reconfigure) -> None:
-        # _prepare has been run already. Actually do the build
-        build_source_dir = self.build_source_dir()
-        if self.manifests_to_build is None:
-            self.run_cargo(
-                install_dirs,
-                "build",
-                ["--out-dir", os.path.join(self.inst_dir, "bin"), "-Zunstable-options"],
-            )
-        else:
-            for manifest in self.manifests_to_build:
-                self.run_cargo(
-                    install_dirs,
-                    "build",
-                    [
-                        "--out-dir",
-                        os.path.join(self.inst_dir, "bin"),
-                        "-Zunstable-options",
-                        "--manifest-path",
-                        self.manifest_dir(manifest),
-                    ],
-                )
-
-        self.recreate_dir(build_source_dir, os.path.join(self.inst_dir, "source"))
-
-    def run_tests(
-        self, install_dirs, schedule_type, owner, test_filter, retry, no_testpilot
-    ) -> None:
-        if test_filter:
-            args = ["--", test_filter]
-        else:
-            args = []
-
-        if self.manifests_to_build is None:
-            self.run_cargo(install_dirs, "test", args)
-            if self.build_doc:
-                self.run_cargo(install_dirs, "doc", ["--no-deps"])
-        else:
-            for manifest in self.manifests_to_build:
-                margs = ["--manifest-path", self.manifest_dir(manifest)]
-                self.run_cargo(install_dirs, "test", args + margs)
-                if self.build_doc:
-                    self.run_cargo(install_dirs, "doc", ["--no-deps"] + margs)
-
-    def _patchup_workspace(self, dep_to_git) -> None:
-        """
-        This method makes some assumptions about the state of the project and
-        its cargo dependendies:
-        1. Crates from cargo dependencies can be extracted from Cargo.toml files
-           using _extract_crates function. It is using a heuristic so check its
-           code to understand how it is done.
-        2. The extracted cargo dependencies crates can be found in the
-           dependency's install dir using _resolve_crate_to_path function
-           which again is using a heuristic.
-
-        Notice that many things might go wrong here. E.g. if someone depends
-        on another getdeps crate by writing in their Cargo.toml file:
-
-            my-rename-of-crate = { package = "crate", git = "..." }
-
-        they can count themselves lucky because the code will raise an
-        Exception. There might be more cases where the code will silently pass
-        producing bad results.
-        """
-        workspace_dir = self.workspace_dir()
-        git_url_to_crates_and_paths = self._resolve_config(dep_to_git)
-        if git_url_to_crates_and_paths:
-            patch_cargo = os.path.join(workspace_dir, "Cargo.toml")
-            if os.path.isfile(patch_cargo):
-                with open(patch_cargo, "r") as f:
-                    manifest_content = f.read()
-            else:
-                manifest_content = ""
-
-            new_content = manifest_content
-            if "[package]" not in manifest_content:
-                # A fake manifest has to be crated to change the virtual
-                # manifest into a non-virtual. The virtual manifests are limited
-                # in many ways and the inability to define patches on them is
-                # one. Check https://github.com/rust-lang/cargo/issues/4934 to
-                # see if it is resolved.
-                null_file = "/dev/null"
-                if self.build_opts.is_windows():
-                    null_file = "nul"
-                new_content += f"""
-[package]
-name = "fake_manifest_of_{self.manifest.name}"
-version = "0.0.0"
-
-[lib]
-path = "{null_file}"
-"""
-            config = []
-            for git_url, crates_to_patch_path in git_url_to_crates_and_paths.items():
-                crates_patches = [
-                    '{} = {{ path = "{}" }}'.format(
-                        crate,
-                        crates_to_patch_path[crate].replace("\\", "\\\\"),
-                    )
-                    for crate in sorted(crates_to_patch_path.keys())
-                ]
-                patch_key = f'[patch."{git_url}"]'
-                if patch_key not in manifest_content:
-                    config.append(f"\n{patch_key}\n" + "\n".join(crates_patches))
-            new_content += "\n".join(config)
-            if new_content != manifest_content:
-                with open(patch_cargo, "w") as f:
-                    print(f"writing patch to {patch_cargo}")
-                    f.write(new_content)
-
-    def _resolve_config(self, dep_to_git) -> typing.Dict[str, typing.Dict[str, str]]:
-        """
-        Returns a configuration to be put inside root Cargo.toml file which
-        patches the dependencies git code with local getdeps versions.
-        See https://doc.rust-lang.org/cargo/reference/manifest.html#the-patch-section
-        """
-        dep_to_crates = self._resolve_dep_to_crates(self.build_source_dir(), dep_to_git)
-
-        git_url_to_crates_and_paths = {}
-        for dep_name in sorted(dep_to_git.keys()):
-            git_conf = dep_to_git[dep_name]
-            req_crates = sorted(dep_to_crates.get(dep_name, []))
-            if not req_crates:
-                continue  # nothing to patch, move along
-
-            git_url = git_conf.get("repo_url", None)
-            crate_source_map = git_conf["crate_source_map"]
-            if git_url and crate_source_map:
-                crates_to_patch_path = git_url_to_crates_and_paths.get(git_url, {})
-                for c in req_crates:
-                    if c in crate_source_map and c not in crates_to_patch_path:
-                        crates_to_patch_path[c] = crate_source_map[c]
-                        print(
-                            f"{self.manifest.name}: Patching crate {c} via virtual manifest in {self.workspace_dir()}"
-                        )
-                if crates_to_patch_path:
-                    git_url_to_crates_and_paths[git_url] = crates_to_patch_path
-
-        return git_url_to_crates_and_paths
-
-    def _resolve_dep_to_git(self):
-        """
-        For each direct dependency of the currently build manifest check if it
-        is also cargo-builded and if yes then extract it's git configs and
-        install dir
-        """
-        dependencies = self.manifest.get_dependencies(self.ctx)
-        if not dependencies:
-            return []
-
-        dep_to_git = {}
-        for dep in dependencies:
-            dep_manifest = self.loader.load_manifest(dep)
-            dep_builder = dep_manifest.get("build", "builder", ctx=self.ctx)
-
-            dep_cargo_conf = dep_manifest.get_section_as_dict("cargo", self.ctx)
-            dep_crate_map = dep_manifest.get_section_as_dict("crate.pathmap", self.ctx)
-
-            if (
-                not (dep_crate_map or dep_cargo_conf)
-                and dep_builder not in ["cargo"]
-                or dep == "rust"
-            ):
-                # This dependency has no cargo rust content so ignore it.
-                # The "rust" dependency is an exception since it contains the
-                # toolchain.
-                continue
-
-            git_conf = dep_manifest.get_section_as_dict("git", self.ctx)
-            if dep != "rust" and "repo_url" not in git_conf:
-                raise Exception(
-                    f"{dep}: A cargo dependency requires git.repo_url to be defined."
-                )
-
-            if dep_builder == "cargo":
-                dep_source_dir = self.loader.get_project_install_dir(dep_manifest)
-                dep_source_dir = os.path.join(dep_source_dir, "source")
-            else:
-                fetcher = self.loader.create_fetcher(dep_manifest)
-                dep_source_dir = fetcher.get_src_dir()
-
-            crate_source_map = {}
-            if dep_crate_map:
-                for (crate, subpath) in dep_crate_map.items():
-                    if crate not in crate_source_map:
-                        if self.build_opts.is_windows():
-                            subpath = subpath.replace("/", "\\")
-                        crate_path = os.path.join(dep_source_dir, subpath)
-                        print(
-                            f"{self.manifest.name}: Mapped crate {crate} to dep {dep} dir {crate_path}"
-                        )
-                        crate_source_map[crate] = crate_path
-            elif dep_cargo_conf:
-                # We don't know what crates are defined buy the dep, look for them
-                search_pattern = re.compile('\\[package\\]\nname = "(.*)"')
-                for crate_root, _, files in os.walk(dep_source_dir):
-                    if "Cargo.toml" in files:
-                        with open(os.path.join(crate_root, "Cargo.toml"), "r") as f:
-                            content = f.read()
-                            match = search_pattern.search(content)
-                            if match:
-                                crate = match.group(1)
-                                if crate:
-                                    print(
-                                        f"{self.manifest.name}: Discovered crate {crate} in dep {dep} dir {crate_root}"
-                                    )
-                                    crate_source_map[crate] = crate_root
-
-            git_conf["crate_source_map"] = crate_source_map
-
-            if not dep_crate_map and dep_cargo_conf:
-                dep_cargo_dir = self.loader.get_project_build_dir(dep_manifest)
-                dep_cargo_dir = os.path.join(dep_cargo_dir, "source")
-                dep_ws_dir = dep_cargo_conf.get("workspace_dir", None)
-                if dep_ws_dir:
-                    dep_cargo_dir = os.path.join(dep_cargo_dir, dep_ws_dir)
-                git_conf["cargo_vendored_sources"] = dep_cargo_dir
-
-            dep_to_git[dep] = git_conf
-        return dep_to_git
-
-    def _resolve_dep_to_crates(self, build_source_dir, dep_to_git):
-        """
-        This function traverse the build_source_dir in search of Cargo.toml
-        files, extracts the crate names from them using _extract_crates
-        function and returns a merged result containing crate names per
-        dependency name from all Cargo.toml files in the project.
-        """
-        if not dep_to_git:
-            return {}  # no deps, so don't waste time traversing files
-
-        dep_to_crates = {}
-
-        # First populate explicit crate paths from dependencies
-        for name, git_conf in dep_to_git.items():
-            crates = git_conf["crate_source_map"].keys()
-            if crates:
-                dep_to_crates.setdefault(name, set()).update(crates)
-
-        # Now find from Cargo.tomls
-        for root, _, files in os.walk(build_source_dir):
-            for f in files:
-                if f == "Cargo.toml":
-                    more_dep_to_crates = CargoBuilder._extract_crates_used(
-                        os.path.join(root, f), dep_to_git
-                    )
-                    for dep_name, crates in more_dep_to_crates.items():
-                        existing_crates = dep_to_crates.get(dep_name, set())
-                        for c in crates:
-                            if c not in existing_crates:
-                                print(
-                                    f"Patch {self.manifest.name} uses {dep_name} crate {crates}"
-                                )
-                                existing_crates.add(c)
-                        dep_to_crates.setdefault(name, set()).update(existing_crates)
-        return dep_to_crates
-
-    @staticmethod
-    def _extract_crates_used(cargo_toml_file, dep_to_git):
-        """
-        This functions reads content of provided cargo toml file and extracts
-        crate names per each dependency. The extraction is done by a heuristic
-        so it might be incorrect.
-        """
-        deps_to_crates = {}
-        with open(cargo_toml_file, "r") as f:
-            for line in f.readlines():
-                if line.startswith("#") or "git = " not in line:
-                    continue  # filter out commented lines and ones without git deps
-                for dep_name, conf in dep_to_git.items():
-                    # Only redirect deps that point to git URLS
-                    if 'git = "{}"'.format(conf["repo_url"]) in line:
-                        pkg_template = ' package = "'
-                        if pkg_template in line:
-                            crate_name, _, _ = line.partition(pkg_template)[
-                                2
-                            ].partition('"')
-                        else:
-                            crate_name, _, _ = line.partition("=")
-                        deps_to_crates.setdefault(dep_name, set()).add(
-                            crate_name.strip()
-                        )
-        return deps_to_crates
-
-    def _resolve_crate_to_path(self, crate, crate_source_map):
-        """
-        Tries to find <crate> in source_dir by searching a [package]
-        keyword followed by name = "<crate>".
-        """
-        search_pattern = '[package]\nname = "{}"'.format(crate)
-
-        for (_crate, crate_source_dir) in crate_source_map.items():
-            for crate_root, _, files in os.walk(crate_source_dir):
-                if "Cargo.toml" in files:
-                    with open(os.path.join(crate_root, "Cargo.toml"), "r") as f:
-                        content = f.read()
-                        if search_pattern in content:
-                            return crate_root
-
-        raise Exception(
-            f"{self.manifest.name}: Failed to find dep crate {crate} in paths {crate_source_map}"
-        )
diff --git a/build/fbcode_builder/getdeps/copytree.py b/build/fbcode_builder/getdeps/copytree.py
deleted file mode 100644
index e7b3971cf8e79..0000000000000
--- a/build/fbcode_builder/getdeps/copytree.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import os
-import shutil
-import subprocess
-
-from .platform import is_windows
-
-
-PREFETCHED_DIRS = set()
-
-
-def containing_repo_type(path):
-    while True:
-        if os.path.exists(os.path.join(path, ".git")):
-            return ("git", path)
-        if os.path.exists(os.path.join(path, ".hg")):
-            return ("hg", path)
-
-        parent = os.path.dirname(path)
-        if parent == path:
-            return None, None
-        path = parent
-
-
-def find_eden_root(dirpath):
-    """If the specified directory is inside an EdenFS checkout, returns
-    the canonical absolute path to the root of that checkout.
-
-    Returns None if the specified directory is not in an EdenFS checkout.
-    """
-    if is_windows():
-        repo_type, repo_root = containing_repo_type(dirpath)
-        if repo_root is not None:
-            if os.path.exists(os.path.join(repo_root, ".eden", "config")):
-                return repo_root
-        return None
-
-    try:
-        return os.readlink(os.path.join(dirpath, ".eden", "root"))
-    except OSError:
-        return None
-
-
-def prefetch_dir_if_eden(dirpath) -> None:
-    """After an amend/rebase, Eden may need to fetch a large number
-    of trees from the servers.  The simplistic single threaded walk
-    performed by copytree makes this more expensive than is desirable
-    so we help accelerate things by performing a prefetch on the
-    source directory"""
-    global PREFETCHED_DIRS
-    if dirpath in PREFETCHED_DIRS:
-        return
-    root = find_eden_root(dirpath)
-    if root is None:
-        return
-    glob = f"{os.path.relpath(dirpath, root).replace(os.sep, '/')}/**"
-    print(f"Prefetching {glob}")
-    subprocess.call(
-        ["edenfsctl", "prefetch", "--repo", root, "--silent", glob, "--background"]
-    )
-    PREFETCHED_DIRS.add(dirpath)
-
-
-# pyre-fixme[9]: ignore has type `bool`; used as `None`.
-def copytree(src_dir, dest_dir, ignore: bool = None):
-    """Recursively copy the src_dir to the dest_dir, filtering
-    out entries using the ignore lambda.  The behavior of the
-    ignore lambda must match that described by `shutil.copytree`.
-    This `copytree` function knows how to prefetch data when
-    running in an eden repo.
-    TODO: I'd like to either extend this or add a variant that
-    uses watchman to mirror src_dir into dest_dir.
-    """
-    prefetch_dir_if_eden(src_dir)
-    # pyre-fixme[6]: For 3rd param expected
-    #  `Union[typing.Callable[[Union[PathLike[str], str], List[str]], Iterable[str]],
-    #  typing.Callable[[str, List[str]], Iterable[str]], None]` but got `bool`.
-    return shutil.copytree(src_dir, dest_dir, ignore=ignore)
diff --git a/build/fbcode_builder/getdeps/dyndeps.py b/build/fbcode_builder/getdeps/dyndeps.py
deleted file mode 100644
index e33db7940c570..0000000000000
--- a/build/fbcode_builder/getdeps/dyndeps.py
+++ /dev/null
@@ -1,454 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import errno
-import glob
-import os
-import re
-import shlex
-import shutil
-import stat
-import subprocess
-import sys
-from struct import unpack
-from typing import List, Optional
-
-OBJECT_SUBDIRS = ("bin", "lib", "lib64")
-
-
-def copyfile(src, dest) -> None:
-    shutil.copyfile(src, dest)
-    shutil.copymode(src, dest)
-
-
-class DepBase(object):
-    def __init__(self, buildopts, install_dirs, strip) -> None:
-        self.buildopts = buildopts
-        self.env = buildopts.compute_env_for_install_dirs(install_dirs)
-        self.install_dirs = install_dirs
-        self.strip = strip
-
-        # Deduplicates dependency processing. Keyed on the library
-        # destination path.
-        self.processed_deps = set()
-
-    def list_dynamic_deps(self, objfile):
-        raise RuntimeError("list_dynamic_deps not implemented")
-
-    def interesting_dep(self, d) -> bool:
-        return True
-
-    # final_install_prefix must be the equivalent path to `destdir` on the
-    # installed system.  For example, if destdir is `/tmp/RANDOM/usr/local' which
-    # is intended to map to `/usr/local` in the install image, then
-    # final_install_prefix='/usr/local'.
-    # If left unspecified, destdir will be used.
-    def process_deps(self, destdir, final_install_prefix=None) -> None:
-        if self.buildopts.is_windows():
-            lib_dir = "bin"
-        else:
-            lib_dir = "lib"
-        # pyre-fixme[16]: `DepBase` has no attribute `munged_lib_dir`.
-        self.munged_lib_dir = os.path.join(destdir, lib_dir)
-
-        final_lib_dir = os.path.join(final_install_prefix or destdir, lib_dir)
-
-        if not os.path.isdir(self.munged_lib_dir):
-            os.makedirs(self.munged_lib_dir)
-
-        # Look only at the things that got installed in the leaf package,
-        # which will be the last entry in the install dirs list
-        inst_dir = self.install_dirs[-1]
-        print("Process deps under %s" % inst_dir, file=sys.stderr)
-
-        for dir in OBJECT_SUBDIRS:
-            src_dir = os.path.join(inst_dir, dir)
-            if not os.path.isdir(src_dir):
-                continue
-            dest_dir = os.path.join(destdir, dir)
-            if not os.path.exists(dest_dir):
-                os.makedirs(dest_dir)
-
-            for objfile in self.list_objs_in_dir(src_dir):
-                print("Consider %s/%s" % (dir, objfile))
-                dest_obj = os.path.join(dest_dir, objfile)
-                copyfile(os.path.join(src_dir, objfile), dest_obj)
-                self.munge_in_place(dest_obj, final_lib_dir)
-
-    def find_all_dependencies(self, build_dir):
-        all_deps = set()
-        for objfile in self.list_objs_in_dir(
-            build_dir, recurse=True, output_prefix=build_dir
-        ):
-            for d in self.list_dynamic_deps(objfile):
-                all_deps.add(d)
-
-        interesting_deps = {d for d in all_deps if self.interesting_dep(d)}
-        dep_paths = []
-        for dep in interesting_deps:
-            dep_path = self.resolve_loader_path(dep)
-            if dep_path:
-                dep_paths.append(dep_path)
-
-        return dep_paths
-
-    def munge_in_place(self, objfile, final_lib_dir) -> None:
-        print("Munging %s" % objfile)
-        for d in self.list_dynamic_deps(objfile):
-            if not self.interesting_dep(d):
-                continue
-
-            # Resolve this dep: does it exist in any of our installation
-            # directories?  If so, then it is a candidate for processing
-            dep = self.resolve_loader_path(d)
-            if dep:
-                # pyre-fixme[16]: `DepBase` has no attribute `munged_lib_dir`.
-                dest_dep = os.path.join(self.munged_lib_dir, os.path.basename(dep))
-                print("dep: %s -> %s" % (d, dest_dep))
-                if dest_dep in self.processed_deps:
-                    # A previous dependency with the same name has already
-                    # been installed at dest_dep, so there is no need to copy
-                    # or munge the dependency again.
-                    # TODO: audit that both source paths have the same inode number
-                    pass
-                else:
-                    self.processed_deps.add(dest_dep)
-                    copyfile(dep, dest_dep)
-                    self.munge_in_place(dest_dep, final_lib_dir)
-
-                self.rewrite_dep(objfile, d, dep, dest_dep, final_lib_dir)
-
-        if self.strip:
-            self.strip_debug_info(objfile)
-
-    def rewrite_dep(self, objfile, depname, old_dep, new_dep, final_lib_dir):
-        raise RuntimeError("rewrite_dep not implemented")
-
-    def resolve_loader_path(self, dep: str) -> Optional[str]:
-        if os.path.isabs(dep):
-            return dep
-        d = os.path.basename(dep)
-        for inst_dir in self.install_dirs:
-            for libdir in OBJECT_SUBDIRS:
-                candidate = os.path.join(inst_dir, libdir, d)
-                if os.path.exists(candidate):
-                    return candidate
-        return None
-
-    def list_objs_in_dir(self, dir, recurse: bool = False, output_prefix: str = ""):
-        for entry in os.listdir(dir):
-            entry_path = os.path.join(dir, entry)
-            st = os.lstat(entry_path)
-            if stat.S_ISREG(st.st_mode):
-                if self.is_objfile(entry_path):
-                    relative_result = os.path.join(output_prefix, entry)
-                    yield os.path.normcase(relative_result)
-            elif recurse and stat.S_ISDIR(st.st_mode):
-                child_prefix = os.path.join(output_prefix, entry)
-                for result in self.list_objs_in_dir(
-                    entry_path, recurse=recurse, output_prefix=child_prefix
-                ):
-                    yield result
-
-    def is_objfile(self, objfile) -> bool:
-        return True
-
-    def strip_debug_info(self, objfile) -> None:
-        """override this to define how to remove debug information
-        from an object file"""
-        pass
-
-    def check_call_verbose(self, args: List[str]) -> None:
-        print(" ".join(map(shlex.quote, args)))
-        subprocess.check_call(args)
-
-
-class WinDeps(DepBase):
-    def __init__(self, buildopts, install_dirs, strip) -> None:
-        super(WinDeps, self).__init__(buildopts, install_dirs, strip)
-        self.dumpbin = self.find_dumpbin()
-
-    def find_dumpbin(self) -> str:
-        # Looking for dumpbin in the following hardcoded paths.
-        # The registry option to find the install dir doesn't work anymore.
-        globs = [
-            (
-                "C:/Program Files (x86)/"
-                "Microsoft Visual Studio/"
-                "*/*/VC/Tools/"
-                "MSVC/*/bin/Hostx64/x64/dumpbin.exe"
-            ),
-            (
-                "C:/Program Files (x86)/"
-                "Common Files/"
-                "Microsoft/Visual C++ for Python/*/"
-                "VC/bin/dumpbin.exe"
-            ),
-            ("c:/Program Files (x86)/Microsoft Visual Studio */VC/bin/dumpbin.exe"),
-            (
-                "C:/Program Files/Microsoft Visual Studio/*/Professional/VC/Tools/MSVC/*/bin/HostX64/x64/dumpbin.exe"
-            ),
-        ]
-        for pattern in globs:
-            for exe in glob.glob(pattern):
-                return exe
-
-        raise RuntimeError("could not find dumpbin.exe")
-
-    def list_dynamic_deps(self, exe):
-        deps = []
-        print("Resolve deps for %s" % exe)
-        output = subprocess.check_output(
-            [self.dumpbin, "/nologo", "/dependents", exe]
-        ).decode("utf-8")
-
-        lines = output.split("\n")
-        for line in lines:
-            m = re.match("\\s+(\\S+.dll)", line, re.IGNORECASE)
-            if m:
-                deps.append(m.group(1).lower())
-
-        return deps
-
-    def rewrite_dep(self, objfile, depname, old_dep, new_dep, final_lib_dir) -> None:
-        # We can't rewrite on windows, but we will
-        # place the deps alongside the exe so that
-        # they end up in the search path
-        pass
-
-    # These are the Windows system dll, which we don't want to copy while
-    # packaging.
-    SYSTEM_DLLS = set(  # noqa: C405
-        [
-            "advapi32.dll",
-            "dbghelp.dll",
-            "kernel32.dll",
-            "msvcp140.dll",
-            "vcruntime140.dll",
-            "ws2_32.dll",
-            "ntdll.dll",
-            "shlwapi.dll",
-        ]
-    )
-
-    def interesting_dep(self, d) -> bool:
-        if "api-ms-win-crt" in d:
-            return False
-        if d in self.SYSTEM_DLLS:
-            return False
-        return True
-
-    def is_objfile(self, objfile) -> bool:
-        if not os.path.isfile(objfile):
-            return False
-        if objfile.lower().endswith(".exe"):
-            return True
-        return False
-
-    def emit_dev_run_script(self, script_path, dep_dirs) -> None:
-        """Emit a script that can be used to run build artifacts directly from the
-        build directory, without installing them.
-
-        The dep_dirs parameter should be a list of paths that need to be added to $PATH.
-        This can be computed by calling compute_dependency_paths() or
-        compute_dependency_paths_fast().
-
-        This is only necessary on Windows, which does not have RPATH, and instead
-        requires the $PATH environment variable be updated in order to find the proper
-        library dependencies.
-        """
-        contents = self._get_dev_run_script_contents(dep_dirs)
-        with open(script_path, "w") as f:
-            f.write(contents)
-
-    def compute_dependency_paths(self, build_dir):
-        """Return a list of all directories that need to be added to $PATH to ensure
-        that library dependencies can be found correctly.  This is computed by scanning
-        binaries to determine exactly the right list of dependencies.
-
-        The compute_dependency_paths_fast() is a alternative function that runs faster
-        but may return additional extraneous paths.
-        """
-        dep_dirs = set()
-        # Find paths by scanning the binaries.
-        for dep in self.find_all_dependencies(build_dir):
-            dep_dirs.add(os.path.dirname(dep))
-
-        dep_dirs.update(self.read_custom_dep_dirs(build_dir))
-        return sorted(dep_dirs)
-
-    def compute_dependency_paths_fast(self, build_dir):
-        """Similar to compute_dependency_paths(), but rather than actually scanning
-        binaries, just add all library paths from the specified installation
-        directories.  This is much faster than scanning the binaries, but may result in
-        more paths being returned than actually necessary.
-        """
-        dep_dirs = set()
-        for inst_dir in self.install_dirs:
-            for subdir in OBJECT_SUBDIRS:
-                path = os.path.join(inst_dir, subdir)
-                if os.path.exists(path):
-                    dep_dirs.add(path)
-
-        dep_dirs.update(self.read_custom_dep_dirs(build_dir))
-        return sorted(dep_dirs)
-
-    def read_custom_dep_dirs(self, build_dir):
-        # The build system may also have included libraries from other locations that
-        # we might not be able to find normally in find_all_dependencies().
-        # To handle this situation we support reading additional library paths
-        # from a LIBRARY_DEP_DIRS.txt file that may have been generated in the build
-        # output directory.
-        dep_dirs = set()
-        try:
-            explicit_dep_dirs_path = os.path.join(build_dir, "LIBRARY_DEP_DIRS.txt")
-            with open(explicit_dep_dirs_path, "r") as f:
-                for line in f.read().splitlines():
-                    dep_dirs.add(line)
-        except OSError as ex:
-            if ex.errno != errno.ENOENT:
-                raise
-
-        return dep_dirs
-
-    def _get_dev_run_script_contents(self, path_dirs) -> str:
-        path_entries = ["$env:PATH"] + path_dirs
-        path_str = ";".join(path_entries)
-        return """\
-$orig_env = $env:PATH
-$env:PATH = "{path_str}"
-
-try {{
-    $cmd_args = $args[1..$args.length]
-    & $args[0] @cmd_args
-}} finally {{
-    $env:PATH = $orig_env
-}}
-""".format(
-            path_str=path_str
-        )
-
-
-class ElfDeps(DepBase):
-    def __init__(self, buildopts, install_dirs, strip) -> None:
-        super(ElfDeps, self).__init__(buildopts, install_dirs, strip)
-
-        # We need patchelf to rewrite deps, so ensure that it is built...
-        subprocess.check_call([sys.executable, sys.argv[0], "build", "patchelf"])
-        # ... and that we know where it lives
-        self.patchelf = os.path.join(
-            os.fsdecode(
-                subprocess.check_output(
-                    [sys.executable, sys.argv[0], "show-inst-dir", "patchelf"]
-                ).strip()
-            ),
-            "bin/patchelf",
-        )
-
-    def list_dynamic_deps(self, objfile):
-        out = (
-            subprocess.check_output(
-                [self.patchelf, "--print-needed", objfile], env=dict(self.env.items())
-            )
-            .decode("utf-8")
-            .strip()
-        )
-        lines = out.split("\n")
-        return lines
-
-    def rewrite_dep(self, objfile, depname, old_dep, new_dep, final_lib_dir) -> None:
-        final_dep = os.path.join(
-            final_lib_dir,
-            # pyre-fixme[16]: `ElfDeps` has no attribute `munged_lib_dir`.
-            os.path.relpath(new_dep, self.munged_lib_dir),
-        )
-        self.check_call_verbose(
-            [self.patchelf, "--replace-needed", depname, final_dep, objfile]
-        )
-
-    def is_objfile(self, objfile) -> bool:
-        if not os.path.isfile(objfile):
-            return False
-        with open(objfile, "rb") as f:
-            # https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header
-            magic = f.read(4)
-            return magic == b"\x7fELF"
-
-    def strip_debug_info(self, objfile) -> None:
-        self.check_call_verbose(["strip", objfile])
-
-
-# MACH-O magic number
-MACH_MAGIC = 0xFEEDFACF
-
-
-class MachDeps(DepBase):
-    def interesting_dep(self, d) -> bool:
-        if d.startswith("/usr/lib/") or d.startswith("/System/"):
-            return False
-        return True
-
-    def is_objfile(self, objfile):
-        if not os.path.isfile(objfile):
-            return False
-        with open(objfile, "rb") as f:
-            # mach stores the magic number in native endianness,
-            # so unpack as native here and compare
-            header = f.read(4)
-            if len(header) != 4:
-                return False
-            magic = unpack("I", header)[0]
-            return magic == MACH_MAGIC
-
-    def list_dynamic_deps(self, objfile):
-        if not self.interesting_dep(objfile):
-            return
-        out = (
-            subprocess.check_output(
-                ["otool", "-L", objfile], env=dict(self.env.items())
-            )
-            .decode("utf-8")
-            .strip()
-        )
-        lines = out.split("\n")
-        deps = []
-        for line in lines:
-            m = re.match("\t(\\S+)\\s", line)
-            if m:
-                if os.path.basename(m.group(1)) != os.path.basename(objfile):
-                    deps.append(os.path.normcase(m.group(1)))
-        return deps
-
-    def rewrite_dep(self, objfile, depname, old_dep, new_dep, final_lib_dir) -> None:
-        if objfile.endswith(".dylib"):
-            # Erase the original location from the id of the shared
-            # object.  It doesn't appear to hurt to retain it, but
-            # it does look weird, so let's rewrite it to be sure.
-            self.check_call_verbose(
-                ["install_name_tool", "-id", os.path.basename(objfile), objfile]
-            )
-        final_dep = os.path.join(
-            final_lib_dir,
-            # pyre-fixme[16]: `MachDeps` has no attribute `munged_lib_dir`.
-            os.path.relpath(new_dep, self.munged_lib_dir),
-        )
-
-        self.check_call_verbose(
-            ["install_name_tool", "-change", depname, final_dep, objfile]
-        )
-
-
-def create_dyn_dep_munger(
-    buildopts, install_dirs, strip: bool = False
-) -> Optional[DepBase]:
-    if buildopts.is_linux():
-        return ElfDeps(buildopts, install_dirs, strip)
-    if buildopts.is_darwin():
-        return MachDeps(buildopts, install_dirs, strip)
-    if buildopts.is_windows():
-        return WinDeps(buildopts, install_dirs, strip)
-    if buildopts.is_freebsd():
-        return ElfDeps(buildopts, install_dirs, strip)
-    return None
diff --git a/build/fbcode_builder/getdeps/envfuncs.py b/build/fbcode_builder/getdeps/envfuncs.py
deleted file mode 100644
index 60de6b23143e0..0000000000000
--- a/build/fbcode_builder/getdeps/envfuncs.py
+++ /dev/null
@@ -1,196 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import os
-import shlex
-import sys
-from typing import Optional
-
-
-class Env(object):
-    def __init__(self, src=None) -> None:
-        self._dict = {}
-        if src is None:
-            self.update(os.environ)
-        else:
-            self.update(src)
-
-    def update(self, src) -> None:
-        for k, v in src.items():
-            self.set(k, v)
-
-    def copy(self) -> "Env":
-        return Env(self._dict)
-
-    def _key(self, key):
-        # The `str` cast may not appear to be needed, but without it we run
-        # into issues when passing the environment to subprocess.  The main
-        # issue is that in python2 `os.environ` (which is the initial source
-        # of data for the environment) uses byte based strings, but this
-        # project uses `unicode_literals`.  `subprocess` will raise an error
-        # if the environment that it is passed has a mixture of byte and
-        # unicode strings.
-        # It is simplest to force everything to be `str` for the sake of
-        # consistency.
-        key = str(key)
-        if sys.platform.startswith("win"):
-            # Windows env var names are case insensitive but case preserving.
-            # An implementation of PAR files on windows gets confused if
-            # the env block contains keys with conflicting case, so make a
-            # pass over the contents to remove any.
-            # While this O(n) scan is technically expensive and gross, it
-            # is practically not a problem because the volume of calls is
-            # relatively low and the cost of manipulating the env is dwarfed
-            # by the cost of spawning a process on windows.  In addition,
-            # since the processes that we run are expensive anyway, this
-            # overhead is not the worst thing to worry about.
-            for k in list(self._dict.keys()):
-                if str(k).lower() == key.lower():
-                    return k
-        elif key in self._dict:
-            return key
-        return None
-
-    def get(self, key, defval=None):
-        key = self._key(key)
-        if key is None:
-            return defval
-        return self._dict[key]
-
-    def __getitem__(self, key):
-        val = self.get(key)
-        if key is None:
-            raise KeyError(key)
-        return val
-
-    def unset(self, key) -> None:
-        if key is None:
-            raise KeyError("attempting to unset env[None]")
-
-        key = self._key(key)
-        if key:
-            del self._dict[key]
-
-    def __delitem__(self, key) -> None:
-        self.unset(key)
-
-    def __repr__(self):
-        return repr(self._dict)
-
-    def set(self, key, value) -> None:
-        if key is None:
-            raise KeyError("attempting to assign env[None] = %r" % value)
-
-        if value is None:
-            raise ValueError("attempting to assign env[%s] = None" % key)
-
-        # The `str` conversion is important to avoid triggering errors
-        # with subprocess if we pass in a unicode value; see commentary
-        # in the `_key` method.
-        key = str(key)
-        value = str(value)
-
-        # The `unset` call is necessary on windows where the keys are
-        # case insensitive.   Since this dict is case sensitive, simply
-        # assigning the value to the new key is not sufficient to remove
-        # the old value.  The `unset` call knows how to match keys and
-        # remove any potential duplicates.
-        self.unset(key)
-        self._dict[key] = value
-
-    def __setitem__(self, key, value) -> None:
-        self.set(key, value)
-
-    def __iter__(self):
-        return self._dict.__iter__()
-
-    def __len__(self) -> int:
-        return len(self._dict)
-
-    def keys(self):
-        return self._dict.keys()
-
-    def values(self):
-        return self._dict.values()
-
-    def items(self):
-        return self._dict.items()
-
-
-def add_path_entry(
-    env, name, item, append: bool = True, separator: str = os.pathsep
-) -> None:
-    """Cause `item` to be added to the path style env var named
-    `name` held in the `env` dict.  `append` specifies whether
-    the item is added to the end (the default) or should be
-    prepended if `name` already exists."""
-    val = env.get(name, "")
-    if len(val) > 0:
-        val = val.split(separator)
-    else:
-        val = []
-    if append:
-        val.append(item)
-    else:
-        val.insert(0, item)
-    env.set(name, separator.join(val))
-
-
-def add_flag(env, name, flag: str, append: bool = True) -> None:
-    """Cause `flag` to be added to the CXXFLAGS-style env var named
-    `name` held in the `env` dict.  `append` specifies whether the
-    flag is added to the end (the default) or should be prepended if
-    `name` already exists."""
-    val = shlex.split(env.get(name, ""))
-    if append:
-        val.append(flag)
-    else:
-        val.insert(0, flag)
-    env.set(name, " ".join(val))
-
-
-_path_search_cache = {}
-_not_found = object()
-
-
-def tpx_path() -> str:
-    return "xplat/testinfra/tpx/ctp.tpx"
-
-
-def path_search(env, exename: str, defval: Optional[str] = None) -> Optional[str]:
-    """Search for exename in the PATH specified in env.
-    exename is eg: `ninja` and this function knows to append a .exe
-    to the end on windows.
-    Returns the path to the exe if found, or None if either no
-    PATH is set in env or no executable is found."""
-
-    path = env.get("PATH", None)
-    if path is None:
-        return defval
-
-    # The project hash computation code searches for C++ compilers (g++, clang, etc)
-    # repeatedly.  Cache the result so we don't end up searching for these over and over
-    # again.
-    cache_key = (path, exename)
-    result = _path_search_cache.get(cache_key, _not_found)
-    if result is _not_found:
-        result = _perform_path_search(path, exename)
-        _path_search_cache[cache_key] = result
-    return result
-
-
-def _perform_path_search(path, exename: str) -> Optional[str]:
-    is_win = sys.platform.startswith("win")
-    if is_win:
-        exename = "%s.exe" % exename
-
-    for bindir in path.split(os.pathsep):
-        full_name = os.path.join(bindir, exename)
-        if os.path.exists(full_name) and os.path.isfile(full_name):
-            if not is_win and not os.access(full_name, os.X_OK):
-                continue
-            return full_name
-
-    return None
diff --git a/build/fbcode_builder/getdeps/errors.py b/build/fbcode_builder/getdeps/errors.py
deleted file mode 100644
index 92240c9538c21..0000000000000
--- a/build/fbcode_builder/getdeps/errors.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-class TransientFailure(Exception):
-    """Raising this error causes getdeps to return with an error code
-    that Sandcastle will consider to be a retryable transient
-    infrastructure error"""
-
-    pass
-
-
-class ManifestNotFound(Exception):
-    def __init__(self, manifest_name) -> None:
-        super(Exception, self).__init__("Unable to find manifest '%s'" % manifest_name)
diff --git a/build/fbcode_builder/getdeps/expr.py b/build/fbcode_builder/getdeps/expr.py
deleted file mode 100644
index df8c3022732df..0000000000000
--- a/build/fbcode_builder/getdeps/expr.py
+++ /dev/null
@@ -1,184 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import re
-import shlex
-
-
-def parse_expr(expr_text, valid_variables):
-    """parses the simple criteria expression syntax used in
-    dependency specifications.
-    Returns an ExprNode instance that can be evaluated like this:
-
-    ```
-    expr = parse_expr("os=windows")
-    ok = expr.eval({
-        "os": "windows"
-    })
-    ```
-
-    Whitespace is allowed between tokens.  The following terms
-    are recognized:
-
-    KEY = VALUE   # Evaluates to True if ctx[KEY] == VALUE
-    not(EXPR)     # Evaluates to True if EXPR evaluates to False
-                  # and vice versa
-    all(EXPR1, EXPR2, ...) # Evaluates True if all of the supplied
-                           # EXPR's also evaluate True
-    any(EXPR1, EXPR2, ...) # Evaluates True if any of the supplied
-                           # EXPR's also evaluate True, False if
-                           # none of them evaluated true.
-    """
-
-    p = Parser(expr_text, valid_variables)
-    return p.parse()
-
-
-class ExprNode(object):
-    def eval(self, ctx) -> bool:
-        return False
-
-
-class TrueExpr(ExprNode):
-    def eval(self, ctx) -> bool:
-        return True
-
-    def __str__(self) -> str:
-        return "true"
-
-
-class NotExpr(ExprNode):
-    def __init__(self, node) -> None:
-        self._node = node
-
-    def eval(self, ctx) -> bool:
-        return not self._node.eval(ctx)
-
-    def __str__(self) -> str:
-        return "not(%s)" % self._node
-
-
-class AllExpr(ExprNode):
-    def __init__(self, nodes) -> None:
-        self._nodes = nodes
-
-    def eval(self, ctx) -> bool:
-        for node in self._nodes:
-            if not node.eval(ctx):
-                return False
-        return True
-
-    def __str__(self) -> str:
-        items = []
-        for node in self._nodes:
-            items.append(str(node))
-        return "all(%s)" % ",".join(items)
-
-
-class AnyExpr(ExprNode):
-    def __init__(self, nodes) -> None:
-        self._nodes = nodes
-
-    def eval(self, ctx) -> bool:
-        for node in self._nodes:
-            if node.eval(ctx):
-                return True
-        return False
-
-    def __str__(self) -> str:
-        items = []
-        for node in self._nodes:
-            items.append(str(node))
-        return "any(%s)" % ",".join(items)
-
-
-class EqualExpr(ExprNode):
-    def __init__(self, key, value) -> None:
-        self._key = key
-        self._value = value
-
-    def eval(self, ctx):
-        return ctx.get(self._key) == self._value
-
-    def __str__(self) -> str:
-        return "%s=%s" % (self._key, self._value)
-
-
-class Parser(object):
-    def __init__(self, text, valid_variables) -> None:
-        self.text = text
-        self.lex = shlex.shlex(text)
-        self.valid_variables = valid_variables
-
-    def parse(self):
-        expr = self.top()
-        garbage = self.lex.get_token()
-        if garbage != "":
-            raise Exception(
-                "Unexpected token %s after EqualExpr in %s" % (garbage, self.text)
-            )
-        return expr
-
-    def top(self):
-        name = self.ident()
-        op = self.lex.get_token()
-
-        if op == "(":
-            parsers = {
-                "not": self.parse_not,
-                "any": self.parse_any,
-                "all": self.parse_all,
-            }
-            func = parsers.get(name)
-            if not func:
-                raise Exception("invalid term %s in %s" % (name, self.text))
-            return func()
-
-        if op == "=":
-            if name not in self.valid_variables:
-                raise Exception("unknown variable %r in expression" % (name,))
-            # remove shell quote from value so can test things with period in them, e.g "18.04"
-            unquoted = " ".join(shlex.split(self.lex.get_token()))
-            return EqualExpr(name, unquoted)
-
-        raise Exception(
-            "Unexpected token sequence '%s %s' in %s" % (name, op, self.text)
-        )
-
-    def ident(self) -> str:
-        ident = self.lex.get_token()
-        if not re.match("[a-zA-Z]+", ident):
-            raise Exception("expected identifier found %s" % ident)
-        return ident
-
-    def parse_not(self) -> NotExpr:
-        node = self.top()
-        expr = NotExpr(node)
-        tok = self.lex.get_token()
-        if tok != ")":
-            raise Exception("expected ')' found %s" % tok)
-        return expr
-
-    def parse_any(self) -> AnyExpr:
-        nodes = []
-        while True:
-            nodes.append(self.top())
-            tok = self.lex.get_token()
-            if tok == ")":
-                break
-            if tok != ",":
-                raise Exception("expected ',' or ')' but found %s" % tok)
-        return AnyExpr(nodes)
-
-    def parse_all(self) -> AllExpr:
-        nodes = []
-        while True:
-            nodes.append(self.top())
-            tok = self.lex.get_token()
-            if tok == ")":
-                break
-            if tok != ",":
-                raise Exception("expected ',' or ')' but found %s" % tok)
-        return AllExpr(nodes)
diff --git a/build/fbcode_builder/getdeps/fetcher.py b/build/fbcode_builder/getdeps/fetcher.py
deleted file mode 100644
index ae96ac133426c..0000000000000
--- a/build/fbcode_builder/getdeps/fetcher.py
+++ /dev/null
@@ -1,853 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import errno
-import hashlib
-import os
-import re
-import shutil
-import stat
-import subprocess
-import sys
-import tarfile
-import time
-import zipfile
-from datetime import datetime
-from typing import Dict, NamedTuple
-from urllib.parse import urlparse
-from urllib.request import Request, urlopen
-
-from .copytree import prefetch_dir_if_eden
-from .envfuncs import Env
-from .errors import TransientFailure
-from .platform import is_windows
-from .runcmd import run_cmd
-
-
-def file_name_is_cmake_file(file_name):
-    file_name = file_name.lower()
-    base = os.path.basename(file_name)
-    return (
-        base.endswith(".cmake")
-        or base.endswith(".cmake.in")
-        or base == "cmakelists.txt"
-    )
-
-
-class ChangeStatus(object):
-    """Indicates the nature of changes that happened while updating
-    the source directory.  There are two broad uses:
-    * When extracting archives for third party software we want to
-      know that we did something (eg: we either extracted code or
-      we didn't do anything)
-    * For 1st party code where we use shipit to transform the code,
-      we want to know if we changed anything so that we can perform
-      a build, but we generally want to be a little more nuanced
-      and be able to distinguish between just changing a source file
-      and whether we might need to reconfigure the build system.
-    """
-
-    def __init__(self, all_changed: bool = False) -> None:
-        """Construct a ChangeStatus object.  The default is to create
-        a status that indicates no changes, but passing all_changed=True
-        will create one that indicates that everything changed"""
-        if all_changed:
-            self.source_files = 1
-            self.make_files = 1
-        else:
-            self.source_files = 0
-            self.make_files = 0
-
-    def record_change(self, file_name) -> None:
-        """Used by the shipit fetcher to record changes as it updates
-        files in the destination.  If the file name might be one used
-        in the cmake build system that we use for 1st party code, then
-        record that as a "make file" change.  We could broaden this
-        to match any file used by various build systems, but it is
-        only really useful for our internal cmake stuff at this time.
-        If the file isn't a build file and is under the `fbcode_builder`
-        dir then we don't class that as an interesting change that we
-        might need to rebuild, so we ignore it.
-        Otherwise we record the file as a source file change."""
-
-        file_name = file_name.lower()
-        if file_name_is_cmake_file(file_name):
-            self.make_files += 1
-        elif "/fbcode_builder/cmake" in file_name:
-            self.source_files += 1
-        elif "/fbcode_builder/" not in file_name:
-            self.source_files += 1
-
-    def sources_changed(self) -> bool:
-        """Returns true if any source files were changed during
-        an update operation.  This will typically be used to decide
-        that the build system to be run on the source dir in an
-        incremental mode"""
-        return self.source_files > 0
-
-    def build_changed(self) -> bool:
-        """Returns true if any build files were changed during
-        an update operation.  This will typically be used to decidfe
-        that the build system should be reconfigured and re-run
-        as a full build"""
-        return self.make_files > 0
-
-
-class Fetcher(object):
-    """The Fetcher is responsible for fetching and extracting the
-    sources for project.  The Fetcher instance defines where the
-    extracted data resides and reports this to the consumer via
-    its `get_src_dir` method."""
-
-    def update(self) -> ChangeStatus:
-        """Brings the src dir up to date, ideally minimizing
-        changes so that a subsequent build doesn't over-build.
-        Returns a ChangeStatus object that helps the caller to
-        understand the nature of the changes required during
-        the update."""
-        return ChangeStatus()
-
-    def clean(self) -> None:
-        """Reverts any changes that might have been made to
-        the src dir"""
-        pass
-
-    def hash(self) -> None:
-        """Returns a hash that identifies the version of the code in the
-        working copy.  For a git repo this is commit hash for the working
-        copy.  For other Fetchers this should relate to the version of
-        the code in the src dir.  The intent is that if a manifest
-        changes the version/rev of a project that the hash be different.
-        Importantly, this should be computable without actually fetching
-        the code, as we want this to factor into a hash used to download
-        a pre-built version of the code, without having to first download
-        and extract its sources (eg: boost on windows is pretty painful).
-        """
-        pass
-
-    def get_src_dir(self) -> None:
-        """Returns the source directory that the project was
-        extracted into"""
-        pass
-
-
-class LocalDirFetcher(object):
-    """This class exists to override the normal fetching behavior, and
-    use an explicit user-specified directory for the project sources.
-
-    This fetcher cannot update or track changes.  It always reports that the
-    project has changed, forcing it to always be built."""
-
-    def __init__(self, path) -> None:
-        self.path = os.path.realpath(path)
-
-    def update(self) -> ChangeStatus:
-        return ChangeStatus(all_changed=True)
-
-    def hash(self) -> str:
-        return "0" * 40
-
-    def get_src_dir(self):
-        return self.path
-
-
-class SystemPackageFetcher(object):
-    def __init__(self, build_options, packages) -> None:
-        self.manager = build_options.host_type.get_package_manager()
-        self.packages = packages.get(self.manager)
-        self.host_type = build_options.host_type
-        if self.packages:
-            self.installed = None
-        else:
-            self.installed = False
-
-    def packages_are_installed(self):
-        if self.installed is not None:
-            return self.installed
-
-        cmd = None
-        if self.manager == "rpm":
-            cmd = ["rpm", "-q"] + sorted(self.packages)
-        elif self.manager == "deb":
-            cmd = ["dpkg", "-s"] + sorted(self.packages)
-        elif self.manager == "homebrew":
-            cmd = ["brew", "ls", "--versions"] + sorted(self.packages)
-
-        if cmd:
-            proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            if proc.returncode == 0:
-                # captured as binary as we will hash this later
-                self.installed = proc.stdout
-            else:
-                # Need all packages to be present to consider us installed
-                self.installed = False
-
-        else:
-            self.installed = False
-
-        return bool(self.installed)
-
-    def update(self) -> ChangeStatus:
-        assert self.installed
-        return ChangeStatus(all_changed=False)
-
-    def hash(self) -> str:
-        if self.packages_are_installed():
-            return hashlib.sha256(self.installed).hexdigest()
-        else:
-            return "0" * 40
-
-    def get_src_dir(self) -> None:
-        return None
-
-
-class PreinstalledNopFetcher(SystemPackageFetcher):
-    def __init__(self) -> None:
-        self.installed = True
-
-
-class GitFetcher(Fetcher):
-    DEFAULT_DEPTH = 1
-
-    def __init__(self, build_options, manifest, repo_url, rev, depth) -> None:
-        # Extract the host/path portions of the URL and generate a flattened
-        # directory name.  eg:
-        # github.com/facebook/folly.git -> github.com-facebook-folly.git
-        url = urlparse(repo_url)
-        directory = "%s%s" % (url.netloc, url.path)
-        for s in ["/", "\\", ":"]:
-            directory = directory.replace(s, "-")
-
-        # Place it in a repos dir in the scratch space
-        repos_dir = os.path.join(build_options.scratch_dir, "repos")
-        if not os.path.exists(repos_dir):
-            os.makedirs(repos_dir)
-        self.repo_dir = os.path.join(repos_dir, directory)
-
-        if not rev and build_options.project_hashes:
-            hash_file = os.path.join(
-                build_options.project_hashes,
-                re.sub("\\.git$", "-rev.txt", url.path[1:]),
-            )
-            if os.path.exists(hash_file):
-                with open(hash_file, "r") as f:
-                    data = f.read()
-                    m = re.match("Subproject commit ([a-fA-F0-9]{40})", data)
-                    if not m:
-                        raise Exception("Failed to parse rev from %s" % hash_file)
-                    rev = m.group(1)
-                    print("Using pinned rev %s for %s" % (rev, repo_url))
-
-        self.rev = rev or "main"
-        self.origin_repo = repo_url
-        self.manifest = manifest
-        self.depth = depth if depth else GitFetcher.DEFAULT_DEPTH
-
-    def _update(self) -> ChangeStatus:
-        current_hash = (
-            subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=self.repo_dir)
-            .strip()
-            .decode("utf-8")
-        )
-        target_hash = (
-            subprocess.check_output(["git", "rev-parse", self.rev], cwd=self.repo_dir)
-            .strip()
-            .decode("utf-8")
-        )
-        if target_hash == current_hash:
-            # It's up to date, so there are no changes.  This doesn't detect eg:
-            # if origin/main moved and rev='main', but that's ok for our purposes;
-            # we should be using explicit hashes or eg: a stable branch for the cases
-            # that we care about, and it isn't unreasonable to require that the user
-            # explicitly perform a clean build if those have moved.  For the most
-            # part we prefer that folks build using a release tarball from github
-            # rather than use the git protocol, as it is generally a bit quicker
-            # to fetch and easier to hash and verify tarball downloads.
-            return ChangeStatus()
-
-        print("Updating %s -> %s" % (self.repo_dir, self.rev))
-        run_cmd(["git", "fetch", "origin", self.rev], cwd=self.repo_dir)
-        run_cmd(["git", "checkout", self.rev], cwd=self.repo_dir)
-        run_cmd(["git", "submodule", "update", "--init"], cwd=self.repo_dir)
-
-        return ChangeStatus(True)
-
-    def update(self) -> ChangeStatus:
-        if os.path.exists(self.repo_dir):
-            return self._update()
-        self._clone()
-        return ChangeStatus(True)
-
-    def _clone(self) -> None:
-        print("Cloning %s..." % self.origin_repo)
-        # The basename/dirname stuff allows us to dance around issues where
-        # eg: this python process is native win32, but the git.exe is cygwin
-        # or msys and doesn't like the absolute windows path that we'd otherwise
-        # pass to it.  Careful use of cwd helps avoid headaches with cygpath.
-        run_cmd(
-            [
-                "git",
-                "clone",
-                "--depth=" + str(self.depth),
-                "--",
-                self.origin_repo,
-                os.path.basename(self.repo_dir),
-            ],
-            cwd=os.path.dirname(self.repo_dir),
-        )
-        self._update()
-
-    def clean(self) -> None:
-        if os.path.exists(self.repo_dir):
-            run_cmd(["git", "clean", "-fxd"], cwd=self.repo_dir)
-
-    def hash(self):
-        return self.rev
-
-    def get_src_dir(self):
-        return self.repo_dir
-
-
-def does_file_need_update(src_name, src_st, dest_name):
-    try:
-        target_st = os.lstat(dest_name)
-    except OSError as exc:
-        if exc.errno != errno.ENOENT:
-            raise
-        return True
-
-    if src_st.st_size != target_st.st_size:
-        return True
-
-    if stat.S_IFMT(src_st.st_mode) != stat.S_IFMT(target_st.st_mode):
-        return True
-    if stat.S_ISLNK(src_st.st_mode):
-        return os.readlink(src_name) != os.readlink(dest_name)
-    if not stat.S_ISREG(src_st.st_mode):
-        return True
-
-    # They might have the same content; compare.
-    with open(src_name, "rb") as sf, open(dest_name, "rb") as df:
-        chunk_size = 8192
-        while True:
-            src_data = sf.read(chunk_size)
-            dest_data = df.read(chunk_size)
-            if src_data != dest_data:
-                return True
-            if len(src_data) < chunk_size:
-                # EOF
-                break
-    return False
-
-
-def copy_if_different(src_name, dest_name) -> bool:
-    """Copy src_name -> dest_name, but only touch dest_name
-    if src_name is different from dest_name, making this a
-    more build system friendly way to copy."""
-    src_st = os.lstat(src_name)
-    if not does_file_need_update(src_name, src_st, dest_name):
-        return False
-
-    dest_parent = os.path.dirname(dest_name)
-    if not os.path.exists(dest_parent):
-        os.makedirs(dest_parent)
-    if stat.S_ISLNK(src_st.st_mode):
-        try:
-            os.unlink(dest_name)
-        except OSError as exc:
-            if exc.errno != errno.ENOENT:
-                raise
-        target = os.readlink(src_name)
-        print("Symlinking %s -> %s" % (dest_name, target))
-        os.symlink(target, dest_name)
-    else:
-        print("Copying %s -> %s" % (src_name, dest_name))
-        shutil.copy2(src_name, dest_name)
-
-    return True
-
-
-def list_files_under_dir_newer_than_timestamp(dir_to_scan, ts):
-    for root, _dirs, files in os.walk(dir_to_scan):
-        for src_file in files:
-            full_name = os.path.join(root, src_file)
-            st = os.lstat(full_name)
-            if st.st_mtime > ts:
-                yield full_name
-
-
-class ShipitPathMap(object):
-    def __init__(self) -> None:
-        self.roots = []
-        self.mapping = []
-        self.exclusion = []
-
-    def add_mapping(self, fbsource_dir, target_dir) -> None:
-        """Add a posix path or pattern.  We cannot normpath the input
-        here because that would change the paths from posix to windows
-        form and break the logic throughout this class."""
-        self.roots.append(fbsource_dir)
-        self.mapping.append((fbsource_dir, target_dir))
-
-    def add_exclusion(self, pattern) -> None:
-        self.exclusion.append(re.compile(pattern))
-
-    def _minimize_roots(self) -> None:
-        """compute the de-duplicated set of roots within fbsource.
-        We take the shortest common directory prefix to make this
-        determination"""
-        self.roots.sort(key=len)
-        minimized = []
-
-        for r in self.roots:
-            add_this_entry = True
-            for existing in minimized:
-                if r.startswith(existing + "/"):
-                    add_this_entry = False
-                    break
-            if add_this_entry:
-                minimized.append(r)
-
-        self.roots = minimized
-
-    def _sort_mapping(self) -> None:
-        self.mapping.sort(reverse=True, key=lambda x: len(x[0]))
-
-    def _map_name(self, norm_name, dest_root):
-        if norm_name.endswith(".pyc") or norm_name.endswith(".swp"):
-            # Ignore some incidental garbage while iterating
-            return None
-
-        for excl in self.exclusion:
-            if excl.match(norm_name):
-                return None
-
-        for src_name, dest_name in self.mapping:
-            if norm_name == src_name or norm_name.startswith(src_name + "/"):
-                rel_name = os.path.relpath(norm_name, src_name)
-                # We can have "." as a component of some paths, depending
-                # on the contents of the shipit transformation section.
-                # normpath doesn't always remove `.` as the final component
-                # of the path, which be problematic when we later mkdir
-                # the dirname of the path that we return.  Take care to avoid
-                # returning a path with a `.` in it.
-                rel_name = os.path.normpath(rel_name)
-                if dest_name == ".":
-                    return os.path.normpath(os.path.join(dest_root, rel_name))
-                dest_name = os.path.normpath(dest_name)
-                return os.path.normpath(os.path.join(dest_root, dest_name, rel_name))
-
-        raise Exception("%s did not match any rules" % norm_name)
-
-    def mirror(self, fbsource_root, dest_root) -> ChangeStatus:
-        self._minimize_roots()
-        self._sort_mapping()
-
-        change_status = ChangeStatus()
-
-        # Record the full set of files that should be in the tree
-        full_file_list = set()
-
-        if sys.platform == "win32":
-            # Let's not assume st_dev has a consistent value on Windows.
-            def st_dev(path):
-                return 1
-
-        else:
-
-            def st_dev(path):
-                return os.lstat(path).st_dev
-
-        for fbsource_subdir in self.roots:
-            dir_to_mirror = os.path.join(fbsource_root, fbsource_subdir)
-            root_dev = st_dev(dir_to_mirror)
-            prefetch_dir_if_eden(dir_to_mirror)
-            if not os.path.exists(dir_to_mirror):
-                raise Exception(
-                    "%s doesn't exist; check your sparse profile!" % dir_to_mirror
-                )
-
-            for root, dirs, files in os.walk(dir_to_mirror):
-                dirs[:] = [d for d in dirs if root_dev == st_dev(os.path.join(root, d))]
-
-                for src_file in files:
-                    full_name = os.path.join(root, src_file)
-                    rel_name = os.path.relpath(full_name, fbsource_root)
-                    norm_name = rel_name.replace("\\", "/")
-
-                    target_name = self._map_name(norm_name, dest_root)
-                    if target_name:
-                        full_file_list.add(target_name)
-                        if copy_if_different(full_name, target_name):
-                            change_status.record_change(target_name)
-
-        # Compare the list of previously shipped files; if a file is
-        # in the old list but not the new list then it has been
-        # removed from the source and should be removed from the
-        # destination.
-        # Why don't we simply create this list by walking dest_root?
-        # Some builds currently have to be in-source builds and
-        # may legitimately need to keep some state in the source tree :-/
-        installed_name = os.path.join(dest_root, ".shipit_shipped")
-        if os.path.exists(installed_name):
-            with open(installed_name, "rb") as f:
-                for name in f.read().decode("utf-8").splitlines():
-                    name = name.strip()
-                    if name not in full_file_list:
-                        print("Remove %s" % name)
-                        os.unlink(name)
-                        change_status.record_change(name)
-
-        with open(installed_name, "wb") as f:
-            for name in sorted(list(full_file_list)):
-                f.write(("%s\n" % name).encode("utf-8"))
-
-        return change_status
-
-
-class FbsourceRepoData(NamedTuple):
-    hash: str
-    date: str
-
-
-FBSOURCE_REPO_DATA: Dict[str, FbsourceRepoData] = {}
-
-
-def get_fbsource_repo_data(build_options) -> FbsourceRepoData:
-    """Returns the commit metadata for the fbsource repo.
-    Since we may have multiple first party projects to
-    hash, and because we don't mutate the repo, we cache
-    this hash in a global."""
-    cached_data = FBSOURCE_REPO_DATA.get(build_options.fbsource_dir)
-    if cached_data:
-        return cached_data
-
-    if "GETDEPS_HG_REPO_DATA" in os.environ:
-        log_data = os.environ["GETDEPS_HG_REPO_DATA"]
-    else:
-        cmd = ["hg", "log", "-r.", "-T{node}\n{date|hgdate}"]
-        env = Env()
-        env.set("HGPLAIN", "1")
-        log_data = subprocess.check_output(
-            cmd, cwd=build_options.fbsource_dir, env=dict(env.items())
-        ).decode("ascii")
-
-    (hash, datestr) = log_data.split("\n")
-
-    # datestr is like "seconds fractionalseconds"
-    # We want "20200324.113140"
-    (unixtime, _fractional) = datestr.split(" ")
-    date = datetime.fromtimestamp(int(unixtime)).strftime("%Y%m%d.%H%M%S")
-    cached_data = FbsourceRepoData(hash=hash, date=date)
-
-    FBSOURCE_REPO_DATA[build_options.fbsource_dir] = cached_data
-
-    return cached_data
-
-
-class SimpleShipitTransformerFetcher(Fetcher):
-    def __init__(self, build_options, manifest, ctx) -> None:
-        self.build_options = build_options
-        self.manifest = manifest
-        self.repo_dir = os.path.join(build_options.scratch_dir, "shipit", manifest.name)
-        self.ctx = ctx
-
-    def clean(self) -> None:
-        if os.path.exists(self.repo_dir):
-            shutil.rmtree(self.repo_dir)
-
-    def update(self) -> ChangeStatus:
-        mapping = ShipitPathMap()
-        for src, dest in self.manifest.get_section_as_ordered_pairs(
-            "shipit.pathmap", self.ctx
-        ):
-            mapping.add_mapping(src, dest)
-        if self.manifest.shipit_fbcode_builder:
-            mapping.add_mapping(
-                "fbcode/opensource/fbcode_builder", "build/fbcode_builder"
-            )
-        for pattern in self.manifest.get_section_as_args("shipit.strip", self.ctx):
-            mapping.add_exclusion(pattern)
-
-        return mapping.mirror(self.build_options.fbsource_dir, self.repo_dir)
-
-    # pyre-fixme[15]: `hash` overrides method defined in `Fetcher` inconsistently.
-    def hash(self) -> str:
-        # We return a fixed non-hash string for in-fbsource builds.
-        # We're relying on the `update` logic to correctly invalidate
-        # the build in the case that files have changed.
-        return "fbsource"
-
-    def get_src_dir(self):
-        return self.repo_dir
-
-
-class ShipitTransformerFetcher(Fetcher):
-    SHIPIT = "/var/www/scripts/opensource/shipit/run_shipit.php"
-
-    def __init__(self, build_options, project_name) -> None:
-        self.build_options = build_options
-        self.project_name = project_name
-        self.repo_dir = os.path.join(build_options.scratch_dir, "shipit", project_name)
-
-    def update(self) -> ChangeStatus:
-        if os.path.exists(self.repo_dir):
-            return ChangeStatus()
-        self.run_shipit()
-        return ChangeStatus(True)
-
-    def clean(self) -> None:
-        if os.path.exists(self.repo_dir):
-            shutil.rmtree(self.repo_dir)
-
-    @classmethod
-    def available(cls):
-        return os.path.exists(cls.SHIPIT)
-
-    def run_shipit(self) -> None:
-        tmp_path = self.repo_dir + ".new"
-        try:
-            if os.path.exists(tmp_path):
-                shutil.rmtree(tmp_path)
-
-            # Run shipit
-            run_cmd(
-                [
-                    "php",
-                    ShipitTransformerFetcher.SHIPIT,
-                    "--project=" + self.project_name,
-                    "--create-new-repo",
-                    "--source-repo-dir=" + self.build_options.fbsource_dir,
-                    "--source-branch=.",
-                    "--skip-source-init",
-                    "--skip-source-pull",
-                    "--skip-source-clean",
-                    "--skip-push",
-                    "--skip-reset",
-                    "--destination-use-anonymous-https",
-                    "--create-new-repo-output-path=" + tmp_path,
-                ]
-            )
-
-            # Remove the .git directory from the repository it generated.
-            # There is no need to commit this.
-            repo_git_dir = os.path.join(tmp_path, ".git")
-            shutil.rmtree(repo_git_dir)
-            os.rename(tmp_path, self.repo_dir)
-        except Exception:
-            # Clean up after a failed extraction
-            if os.path.exists(tmp_path):
-                shutil.rmtree(tmp_path)
-            self.clean()
-            raise
-
-    # pyre-fixme[15]: `hash` overrides method defined in `Fetcher` inconsistently.
-    def hash(self) -> str:
-        # We return a fixed non-hash string for in-fbsource builds.
-        return "fbsource"
-
-    def get_src_dir(self):
-        return self.repo_dir
-
-
-def download_url_to_file_with_progress(url: str, file_name) -> None:
-    print("Download with %s -> %s ..." % (url, file_name))
-
-    class Progress(object):
-        last_report = 0
-
-        def write_update(self, total, amount):
-            if total == -1:
-                total = "(Unknown)"
-
-            if sys.stdout.isatty():
-                sys.stdout.write("\r downloading %s of %s " % (amount, total))
-            else:
-                # When logging to CI logs, avoid spamming the logs and print
-                # status every few seconds
-                now = time.time()
-                if now - self.last_report > 5:
-                    sys.stdout.write(".. %s of %s " % (amount, total))
-                    self.last_report = now
-            sys.stdout.flush()
-
-        def progress_pycurl(self, total, amount, _uploadtotal, _uploadamount):
-            self.write_update(total, amount)
-
-    progress = Progress()
-    start = time.time()
-    try:
-        if os.environ.get("GETDEPS_USE_WGET") is not None:
-            subprocess.run(
-                [
-                    "wget",
-                    "-O",
-                    file_name,
-                    url,
-                ]
-            )
-
-            headers = None
-
-        elif os.environ.get("GETDEPS_USE_LIBCURL") is not None:
-            import pycurl
-
-            with open(file_name, "wb") as f:
-                c = pycurl.Curl()
-                c.setopt(pycurl.URL, url)
-                c.setopt(pycurl.WRITEDATA, f)
-                # display progress
-                c.setopt(pycurl.NOPROGRESS, False)
-                c.setopt(pycurl.XFERINFOFUNCTION, progress.progress_pycurl)
-                c.perform()
-                c.close()
-            headers = None
-        else:
-            req_header = {"Accept": "application/*"}
-            res = urlopen(Request(url, None, req_header))
-            chunk_size = 8192  # urlretrieve uses this value
-            headers = res.headers
-            content_length = res.headers.get("Content-Length")
-            total = int(content_length.strip()) if content_length else -1
-            amount = 0
-            with open(file_name, "wb") as f:
-                chunk = res.read(chunk_size)
-                while chunk:
-                    f.write(chunk)
-                    amount += len(chunk)
-                    progress.write_update(total, amount)
-                    chunk = res.read(chunk_size)
-    except (OSError, IOError) as exc:  # noqa: B014
-        raise TransientFailure(
-            "Failed to download %s to %s: %s" % (url, file_name, str(exc))
-        )
-
-    end = time.time()
-    sys.stdout.write(" [Complete in %f seconds]\n" % (end - start))
-    sys.stdout.flush()
-    if headers is not None:
-        print(f"{headers}")
-
-
-class ArchiveFetcher(Fetcher):
-    def __init__(self, build_options, manifest, url, sha256) -> None:
-        self.manifest = manifest
-        self.url = url
-        self.sha256 = sha256
-        self.build_options = build_options
-
-        url = urlparse(self.url)
-        basename = "%s-%s" % (manifest.name, os.path.basename(url.path))
-        self.file_name = os.path.join(build_options.scratch_dir, "downloads", basename)
-        self.src_dir = os.path.join(build_options.scratch_dir, "extracted", basename)
-        self.hash_file = self.src_dir + ".hash"
-
-    def _verify_hash(self) -> None:
-        h = hashlib.sha256()
-        with open(self.file_name, "rb") as f:
-            while True:
-                block = f.read(8192)
-                if not block:
-                    break
-                h.update(block)
-        digest = h.hexdigest()
-        if digest != self.sha256:
-            os.unlink(self.file_name)
-            raise Exception(
-                "%s: expected sha256 %s but got %s" % (self.url, self.sha256, digest)
-            )
-
-    def _download_dir(self):
-        """returns the download dir, creating it if it doesn't already exist"""
-        download_dir = os.path.dirname(self.file_name)
-        if not os.path.exists(download_dir):
-            os.makedirs(download_dir)
-        return download_dir
-
-    def _download(self) -> None:
-        self._download_dir()
-        download_url_to_file_with_progress(self.url, self.file_name)
-        self._verify_hash()
-
-    def clean(self) -> None:
-        if os.path.exists(self.src_dir):
-            shutil.rmtree(self.src_dir)
-
-    def update(self) -> ChangeStatus:
-        try:
-            with open(self.hash_file, "r") as f:
-                saved_hash = f.read().strip()
-                if saved_hash == self.sha256 and os.path.exists(self.src_dir):
-                    # Everything is up to date
-                    return ChangeStatus()
-                print(
-                    "saved hash %s doesn't match expected hash %s, re-validating"
-                    % (saved_hash, self.sha256)
-                )
-                os.unlink(self.hash_file)
-        except EnvironmentError:
-            pass
-
-        # If we got here we know the contents of src_dir are either missing
-        # or wrong, so blow away whatever happened to be there first.
-        if os.path.exists(self.src_dir):
-            shutil.rmtree(self.src_dir)
-
-        # If we already have a file here, make sure it looks legit before
-        # proceeding: any errors and we just remove it and re-download
-        if os.path.exists(self.file_name):
-            try:
-                self._verify_hash()
-            except Exception:
-                if os.path.exists(self.file_name):
-                    os.unlink(self.file_name)
-
-        if not os.path.exists(self.file_name):
-            self._download()
-
-        if tarfile.is_tarfile(self.file_name):
-            opener = tarfile.open
-        elif zipfile.is_zipfile(self.file_name):
-            opener = zipfile.ZipFile
-        else:
-            raise Exception("don't know how to extract %s" % self.file_name)
-        os.makedirs(self.src_dir)
-        print("Extract %s -> %s" % (self.file_name, self.src_dir))
-        t = opener(self.file_name)
-        if is_windows():
-            # Ensure that we don't fall over when dealing with long paths
-            # on windows
-            src = r"\\?\%s" % os.path.normpath(self.src_dir)
-        else:
-            src = self.src_dir
-        # The `str` here is necessary to ensure that we don't pass a unicode
-        # object down to tarfile.extractall on python2.  When extracting
-        # the boost tarball it makes some assumptions and tries to convert
-        # a non-ascii path to ascii and throws.
-        src = str(src)
-        t.extractall(src)
-
-        with open(self.hash_file, "w") as f:
-            f.write(self.sha256)
-
-        return ChangeStatus(True)
-
-    def hash(self):
-        return self.sha256
-
-    def get_src_dir(self):
-        return self.src_dir
-
-
-def homebrew_package_prefix(package):
-    cmd = ["brew", "--prefix", package]
-    try:
-        proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    except FileNotFoundError:
-        return
-
-    if proc.returncode == 0:
-        return proc.stdout.decode("utf-8").rstrip()
diff --git a/build/fbcode_builder/getdeps/load.py b/build/fbcode_builder/getdeps/load.py
deleted file mode 100644
index 6390f2fb14b4a..0000000000000
--- a/build/fbcode_builder/getdeps/load.py
+++ /dev/null
@@ -1,356 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import base64
-import copy
-import hashlib
-import os
-
-from . import fetcher
-from .envfuncs import path_search
-from .errors import ManifestNotFound
-from .manifest import ManifestParser
-
-
-class Loader(object):
-    """The loader allows our tests to patch the load operation"""
-
-    def _list_manifests(self, build_opts):
-        """Returns a generator that iterates all the available manifests"""
-        for (path, _, files) in os.walk(build_opts.manifests_dir):
-            for name in files:
-                # skip hidden files
-                if name.startswith("."):
-                    continue
-
-                yield os.path.join(path, name)
-
-    def _load_manifest(self, path):
-        return ManifestParser(path)
-
-    def load_project(self, build_opts, project_name):
-        if "/" in project_name or "\\" in project_name:
-            # Assume this is a path already
-            return ManifestParser(project_name)
-
-        for manifest in self._list_manifests(build_opts):
-            if os.path.basename(manifest) == project_name:
-                return ManifestParser(manifest)
-
-        raise ManifestNotFound(project_name)
-
-    def load_all(self, build_opts):
-        manifests_by_name = {}
-
-        for manifest in self._list_manifests(build_opts):
-            m = self._load_manifest(manifest)
-
-            if m.name in manifests_by_name:
-                raise Exception("found duplicate manifest '%s'" % m.name)
-
-            manifests_by_name[m.name] = m
-
-        return manifests_by_name
-
-
-class ResourceLoader(Loader):
-    def __init__(self, namespace, manifests_dir) -> None:
-        self.namespace = namespace
-        self.manifests_dir = manifests_dir
-
-    def _list_manifests(self, _build_opts):
-        import pkg_resources
-
-        dirs = [self.manifests_dir]
-
-        while dirs:
-            current = dirs.pop(0)
-            for name in pkg_resources.resource_listdir(self.namespace, current):
-                path = "%s/%s" % (current, name)
-
-                if pkg_resources.resource_isdir(self.namespace, path):
-                    dirs.append(path)
-                else:
-                    yield "%s/%s" % (current, name)
-
-    def _find_manifest(self, project_name):
-        for name in self._list_manifests():
-            if name.endswith("/%s" % project_name):
-                return name
-
-        raise ManifestNotFound(project_name)
-
-    def _load_manifest(self, path: str):
-        import pkg_resources
-
-        contents = pkg_resources.resource_string(self.namespace, path).decode("utf8")
-        return ManifestParser(file_name=path, fp=contents)
-
-    def load_project(self, build_opts, project_name):
-        project_name = self._find_manifest(project_name)
-        return self._load_resource_manifest(project_name)
-
-
-LOADER = Loader()
-
-
-def patch_loader(namespace, manifests_dir: str = "manifests") -> None:
-    global LOADER
-    LOADER = ResourceLoader(namespace, manifests_dir)
-
-
-def load_project(build_opts, project_name):
-    """given the name of a project or a path to a manifest file,
-    load up the ManifestParser instance for it and return it"""
-    return LOADER.load_project(build_opts, project_name)
-
-
-def load_all_manifests(build_opts):
-    return LOADER.load_all(build_opts)
-
-
-class ManifestLoader(object):
-    """ManifestLoader stores information about project manifest relationships for a
-    given set of (build options + platform) configuration.
-
-    The ManifestLoader class primarily serves as a location to cache project dependency
-    relationships and project hash values for this build configuration.
-    """
-
-    def __init__(self, build_opts, ctx_gen=None) -> None:
-        self._loader = LOADER
-        self.build_opts = build_opts
-        if ctx_gen is None:
-            self.ctx_gen = self.build_opts.get_context_generator()
-        else:
-            self.ctx_gen = ctx_gen
-
-        self.manifests_by_name = {}
-        self._loaded_all = False
-        self._project_hashes = {}
-        self._fetcher_overrides = {}
-        self._build_dir_overrides = {}
-        self._install_dir_overrides = {}
-        self._install_prefix_overrides = {}
-
-    def load_manifest(self, name):
-        manifest = self.manifests_by_name.get(name)
-        if manifest is None:
-            manifest = self._loader.load_project(self.build_opts, name)
-            self.manifests_by_name[name] = manifest
-        return manifest
-
-    def load_all_manifests(self):
-        if not self._loaded_all:
-            all_manifests_by_name = self._loader.load_all(self.build_opts)
-            if self.manifests_by_name:
-                # To help ensure that we only ever have a single manifest object for a
-                # given project, and that it can't change once we have loaded it,
-                # only update our mapping for projects that weren't already loaded.
-                for name, manifest in all_manifests_by_name.items():
-                    self.manifests_by_name.setdefault(name, manifest)
-            else:
-                self.manifests_by_name = all_manifests_by_name
-            self._loaded_all = True
-
-        return self.manifests_by_name
-
-    def manifests_in_dependency_order(self, manifest=None):
-        """Compute all dependencies of the specified project.  Returns a list of the
-        dependencies plus the project itself, in topologically sorted order.
-
-        Each entry in the returned list only depends on projects that appear before it
-        in the list.
-
-        If the input manifest is None, the dependencies for all currently loaded
-        projects will be computed.  i.e., if you call load_all_manifests() followed by
-        manifests_in_dependency_order() this will return a global dependency ordering of
-        all projects."""
-        # The list of deps that have been fully processed
-        seen = set()
-        # The list of deps which have yet to be evaluated.  This
-        # can potentially contain duplicates.
-        if manifest is None:
-            deps = list(self.manifests_by_name.values())
-        else:
-            assert manifest.name in self.manifests_by_name
-            deps = [manifest]
-        # The list of manifests in dependency order
-        dep_order = []
-        system_packages = {}
-
-        while len(deps) > 0:
-            m = deps.pop(0)
-            if m.name in seen:
-                continue
-
-            # Consider its deps, if any.
-            # We sort them for increased determinism; we'll produce
-            # a correct order even if they aren't sorted, but we prefer
-            # to produce the same order regardless of how they are listed
-            # in the project manifest files.
-            ctx = self.ctx_gen.get_context(m.name)
-            dep_list = m.get_dependencies(ctx)
-
-            dep_count = 0
-            for dep_name in dep_list:
-                # If we're not sure whether it is done, queue it up
-                if dep_name not in seen:
-                    dep = self.manifests_by_name.get(dep_name)
-                    if dep is None:
-                        dep = self._loader.load_project(self.build_opts, dep_name)
-                        self.manifests_by_name[dep.name] = dep
-
-                    deps.append(dep)
-                    dep_count += 1
-
-            if dep_count > 0:
-                # If we queued anything, re-queue this item, as it depends
-                # those new item(s) and their transitive deps.
-                deps.append(m)
-                continue
-
-            # Its deps are done, so we can emit it
-            seen.add(m.name)
-            # Capture system packages as we may need to set PATHs to then later
-            if (
-                self.build_opts.allow_system_packages
-                and self.build_opts.host_type.get_package_manager()
-            ):
-                packages = m.get_required_system_packages(ctx)
-                for pkg_type, v in packages.items():
-                    merged = system_packages.get(pkg_type, [])
-                    if v not in merged:
-                        merged += v
-                    system_packages[pkg_type] = merged
-                # A manifest depends on all system packages in it dependencies as well
-                m.resolved_system_packages = copy.copy(system_packages)
-            dep_order.append(m)
-
-        return dep_order
-
-    def set_project_src_dir(self, project_name, path) -> None:
-        self._fetcher_overrides[project_name] = fetcher.LocalDirFetcher(path)
-
-    def set_project_build_dir(self, project_name, path) -> None:
-        self._build_dir_overrides[project_name] = path
-
-    def set_project_install_dir(self, project_name, path) -> None:
-        self._install_dir_overrides[project_name] = path
-
-    def set_project_install_prefix(self, project_name, path) -> None:
-        self._install_prefix_overrides[project_name] = path
-
-    def create_fetcher(self, manifest):
-        override = self._fetcher_overrides.get(manifest.name)
-        if override is not None:
-            return override
-
-        ctx = self.ctx_gen.get_context(manifest.name)
-        return manifest.create_fetcher(self.build_opts, ctx)
-
-    def get_project_hash(self, manifest):
-        h = self._project_hashes.get(manifest.name)
-        if h is None:
-            h = self._compute_project_hash(manifest)
-            self._project_hashes[manifest.name] = h
-        return h
-
-    def _compute_project_hash(self, manifest) -> str:
-        """This recursive function computes a hash for a given manifest.
-        The hash takes into account some environmental factors on the
-        host machine and includes the hashes of its dependencies.
-        No caching of the computation is performed, which is theoretically
-        wasteful but the computation is fast enough that it is not required
-        to cache across multiple invocations."""
-        ctx = self.ctx_gen.get_context(manifest.name)
-
-        hasher = hashlib.sha256()
-        # Some environmental and configuration things matter
-        env = {}
-        env["install_dir"] = self.build_opts.install_dir
-        env["scratch_dir"] = self.build_opts.scratch_dir
-        env["vcvars_path"] = self.build_opts.vcvars_path
-        env["os"] = self.build_opts.host_type.ostype
-        env["distro"] = self.build_opts.host_type.distro
-        env["distro_vers"] = self.build_opts.host_type.distrovers
-        env["shared_libs"] = str(self.build_opts.shared_libs)
-        for name in [
-            "CXXFLAGS",
-            "CPPFLAGS",
-            "LDFLAGS",
-            "CXX",
-            "CC",
-            "GETDEPS_CMAKE_DEFINES",
-        ]:
-            env[name] = os.environ.get(name)
-        for tool in ["cc", "c++", "gcc", "g++", "clang", "clang++"]:
-            env["tool-%s" % tool] = path_search(os.environ, tool)
-        for name in manifest.get_section_as_args("depends.environment", ctx):
-            env[name] = os.environ.get(name)
-
-        fetcher = self.create_fetcher(manifest)
-        env["fetcher.hash"] = fetcher.hash()
-
-        for name in sorted(env.keys()):
-            hasher.update(name.encode("utf-8"))
-            value = env.get(name)
-            if value is not None:
-                try:
-                    hasher.update(value.encode("utf-8"))
-                except AttributeError as exc:
-                    raise AttributeError("name=%r, value=%r: %s" % (name, value, exc))
-
-        manifest.update_hash(hasher, ctx)
-
-        dep_list = manifest.get_dependencies(ctx)
-        for dep in dep_list:
-            dep_manifest = self.load_manifest(dep)
-            dep_hash = self.get_project_hash(dep_manifest)
-            hasher.update(dep_hash.encode("utf-8"))
-
-        # Use base64 to represent the hash, rather than the simple hex digest,
-        # so that the string is shorter.  Use the URL-safe encoding so that
-        # the hash can also be safely used as a filename component.
-        h = base64.urlsafe_b64encode(hasher.digest()).decode("ascii")
-        # ... and because cmd.exe is troublesome with `=` signs, nerf those.
-        # They tend to be padding characters at the end anyway, so we can
-        # safely discard them.
-        h = h.replace("=", "")
-
-        return h
-
-    def _get_project_dir_name(self, manifest):
-        if manifest.is_first_party_project():
-            return manifest.name
-        else:
-            project_hash = self.get_project_hash(manifest)
-            return "%s-%s" % (manifest.name, project_hash)
-
-    def get_project_install_dir(self, manifest):
-        override = self._install_dir_overrides.get(manifest.name)
-        if override:
-            return override
-
-        project_dir_name = self._get_project_dir_name(manifest)
-        return os.path.join(self.build_opts.install_dir, project_dir_name)
-
-    def get_project_build_dir(self, manifest):
-        override = self._build_dir_overrides.get(manifest.name)
-        if override:
-            return override
-
-        project_dir_name = self._get_project_dir_name(manifest)
-        return os.path.join(self.build_opts.scratch_dir, "build", project_dir_name)
-
-    def get_project_install_prefix(self, manifest):
-        return self._install_prefix_overrides.get(manifest.name)
-
-    def get_project_install_dir_respecting_install_prefix(self, manifest):
-        inst_dir = self.get_project_install_dir(manifest)
-        prefix = self.get_project_install_prefix(manifest)
-        if prefix:
-            return inst_dir + prefix
-        return inst_dir
diff --git a/build/fbcode_builder/getdeps/manifest.py b/build/fbcode_builder/getdeps/manifest.py
deleted file mode 100644
index 15f69af7d4e86..0000000000000
--- a/build/fbcode_builder/getdeps/manifest.py
+++ /dev/null
@@ -1,682 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import configparser
-import io
-import os
-from typing import List
-
-from .builder import (
-    AutoconfBuilder,
-    Boost,
-    CMakeBootStrapBuilder,
-    CMakeBuilder,
-    Iproute2Builder,
-    MakeBuilder,
-    NinjaBootstrap,
-    NopBuilder,
-    OpenSSLBuilder,
-    SqliteBuilder,
-)
-from .cargo import CargoBuilder
-from .expr import parse_expr
-from .fetcher import (
-    ArchiveFetcher,
-    GitFetcher,
-    PreinstalledNopFetcher,
-    ShipitTransformerFetcher,
-    SimpleShipitTransformerFetcher,
-    SystemPackageFetcher,
-)
-from .py_wheel_builder import PythonWheelBuilder
-
-REQUIRED = "REQUIRED"
-OPTIONAL = "OPTIONAL"
-
-SCHEMA = {
-    "manifest": {
-        "optional_section": False,
-        "fields": {
-            "name": REQUIRED,
-            "fbsource_path": OPTIONAL,
-            "shipit_project": OPTIONAL,
-            "shipit_fbcode_builder": OPTIONAL,
-        },
-    },
-    "dependencies": {"optional_section": True, "allow_values": False},
-    "depends.environment": {"optional_section": True},
-    "git": {
-        "optional_section": True,
-        "fields": {"repo_url": REQUIRED, "rev": OPTIONAL, "depth": OPTIONAL},
-    },
-    "download": {
-        "optional_section": True,
-        "fields": {"url": REQUIRED, "sha256": REQUIRED},
-    },
-    "build": {
-        "optional_section": True,
-        "fields": {
-            "builder": REQUIRED,
-            "subdir": OPTIONAL,
-            "make_binary": OPTIONAL,
-            "build_in_src_dir": OPTIONAL,
-            "job_weight_mib": OPTIONAL,
-            "patchfile": OPTIONAL,
-            "patchfile_opts": OPTIONAL,
-        },
-    },
-    "msbuild": {"optional_section": True, "fields": {"project": REQUIRED}},
-    "cargo": {
-        "optional_section": True,
-        "fields": {
-            "build_doc": OPTIONAL,
-            "workspace_dir": OPTIONAL,
-            "manifests_to_build": OPTIONAL,
-            # Where to write cargo config (defaults to build_dir/.cargo/config.toml)
-            "cargo_config_file": OPTIONAL,
-        },
-    },
-    "github.actions": {
-        "optional_section": True,
-        "fields": {
-            "run_tests": OPTIONAL,
-        },
-    },
-    "crate.pathmap": {"optional_section": True},
-    "cmake.defines": {"optional_section": True},
-    "autoconf.args": {"optional_section": True},
-    "autoconf.envcmd.LDFLAGS": {"optional_section": True},
-    "rpms": {"optional_section": True},
-    "debs": {"optional_section": True},
-    "homebrew": {"optional_section": True},
-    "preinstalled.env": {"optional_section": True},
-    "bootstrap.args": {"optional_section": True},
-    "b2.args": {"optional_section": True},
-    "make.build_args": {"optional_section": True},
-    "make.install_args": {"optional_section": True},
-    "make.test_args": {"optional_section": True},
-    "header-only": {"optional_section": True, "fields": {"includedir": REQUIRED}},
-    "shipit.pathmap": {"optional_section": True},
-    "shipit.strip": {"optional_section": True},
-    "install.files": {"optional_section": True},
-    # fb-only
-    "sandcastle": {"optional_section": True, "fields": {"run_tests": OPTIONAL}},
-}
-
-# These sections are allowed to vary for different platforms
-# using the expression syntax to enable/disable sections
-ALLOWED_EXPR_SECTIONS = [
-    "autoconf.args",
-    "autoconf.envcmd.LDFLAGS",
-    "build",
-    "cmake.defines",
-    "dependencies",
-    "make.build_args",
-    "make.install_args",
-    "bootstrap.args",
-    "b2.args",
-    "download",
-    "git",
-    "install.files",
-    "rpms",
-    "debs",
-    "shipit.pathmap",
-    "shipit.strip",
-    "homebrew",
-    "github.actions",
-]
-
-
-def parse_conditional_section_name(name, section_def):
-    expr = name[len(section_def) + 1 :]
-    return parse_expr(expr, ManifestContext.ALLOWED_VARIABLES)
-
-
-def validate_allowed_fields(file_name, section, config, allowed_fields):
-    for field in config.options(section):
-        if not allowed_fields.get(field):
-            raise Exception(
-                ("manifest file %s section '%s' contains " "unknown field '%s'")
-                % (file_name, section, field)
-            )
-
-    for field in allowed_fields:
-        if allowed_fields[field] == REQUIRED and not config.has_option(section, field):
-            raise Exception(
-                ("manifest file %s section '%s' is missing " "required field '%s'")
-                % (file_name, section, field)
-            )
-
-
-def validate_allow_values(file_name, section, config):
-    for field in config.options(section):
-        value = config.get(section, field)
-        if value is not None:
-            raise Exception(
-                (
-                    "manifest file %s section '%s' has '%s = %s' but "
-                    "this section doesn't allow specifying values "
-                    "for its entries"
-                )
-                % (file_name, section, field, value)
-            )
-
-
-def validate_section(file_name, section, config):
-    section_def = SCHEMA.get(section)
-    if not section_def:
-        for name in ALLOWED_EXPR_SECTIONS:
-            if section.startswith(name + "."):
-                # Verify that the conditional parses, but discard it
-                try:
-                    parse_conditional_section_name(section, name)
-                except Exception as exc:
-                    raise Exception(
-                        ("manifest file %s section '%s' has invalid " "conditional: %s")
-                        % (file_name, section, str(exc))
-                    )
-                section_def = SCHEMA.get(name)
-                canonical_section_name = name
-                break
-        if not section_def:
-            raise Exception(
-                "manifest file %s contains unknown section '%s'" % (file_name, section)
-            )
-    else:
-        canonical_section_name = section
-
-    allowed_fields = section_def.get("fields")
-    if allowed_fields:
-        validate_allowed_fields(file_name, section, config, allowed_fields)
-    elif not section_def.get("allow_values", True):
-        validate_allow_values(file_name, section, config)
-    return canonical_section_name
-
-
-class ManifestParser(object):
-    def __init__(self, file_name, fp=None):
-        # allow_no_value enables listing parameters in the
-        # autoconf.args section one per line
-        config = configparser.RawConfigParser(allow_no_value=True)
-        config.optionxform = str  # make it case sensitive
-        if fp is None:
-            with open(file_name, "r") as fp:
-                config.read_file(fp)
-        elif isinstance(fp, type("")):
-            # For testing purposes, parse from a string (str
-            # or unicode)
-            config.read_file(io.StringIO(fp))
-        else:
-            config.read_file(fp)
-
-        # validate against the schema
-        seen_sections = set()
-
-        for section in config.sections():
-            seen_sections.add(validate_section(file_name, section, config))
-
-        for section in SCHEMA.keys():
-            section_def = SCHEMA[section]
-            if (
-                not section_def.get("optional_section", False)
-                and section not in seen_sections
-            ):
-                raise Exception(
-                    "manifest file %s is missing required section %s"
-                    % (file_name, section)
-                )
-
-        self._config = config
-        self.name = config.get("manifest", "name")
-        self.fbsource_path = self.get("manifest", "fbsource_path")
-        self.shipit_project = self.get("manifest", "shipit_project")
-        self.shipit_fbcode_builder = self.get("manifest", "shipit_fbcode_builder")
-        self.resolved_system_packages = {}
-
-        if self.name != os.path.basename(file_name):
-            raise Exception(
-                "filename of the manifest '%s' does not match the manifest name '%s'"
-                % (file_name, self.name)
-            )
-
-    def get(self, section, key, defval=None, ctx=None):
-        ctx = ctx or {}
-
-        for s in self._config.sections():
-            if s == section:
-                if self._config.has_option(s, key):
-                    return self._config.get(s, key)
-                return defval
-
-            if s.startswith(section + "."):
-                expr = parse_conditional_section_name(s, section)
-                if not expr.eval(ctx):
-                    continue
-
-                if self._config.has_option(s, key):
-                    return self._config.get(s, key)
-
-        return defval
-
-    def get_dependencies(self, ctx):
-        dep_list = list(self.get_section_as_dict("dependencies", ctx).keys())
-        dep_list.sort()
-        builder = self.get("build", "builder", ctx=ctx)
-        if builder in ("cmake", "python-wheel"):
-            dep_list.insert(0, "cmake")
-        elif builder == "autoconf" and self.name not in (
-            "autoconf",
-            "libtool",
-            "automake",
-        ):
-            # they need libtool and its deps (automake, autoconf) so add
-            # those as deps (but obviously not if we're building those
-            # projects themselves)
-            dep_list.insert(0, "libtool")
-
-        return dep_list
-
-    def get_section_as_args(self, section, ctx=None) -> List[str]:
-        """Intended for use with the make.[build_args/install_args] and
-        autoconf.args sections, this method collects the entries and returns an
-        array of strings.
-        If the manifest contains conditional sections, ctx is used to
-        evaluate the condition and merge in the values.
-        """
-        args = []
-        ctx = ctx or {}
-
-        for s in self._config.sections():
-            if s != section:
-                if not s.startswith(section + "."):
-                    continue
-                expr = parse_conditional_section_name(s, section)
-                if not expr.eval(ctx):
-                    continue
-            for field in self._config.options(s):
-                value = self._config.get(s, field)
-                if value is None:
-                    args.append(field)
-                else:
-                    args.append("%s=%s" % (field, value))
-        return args
-
-    def get_section_as_ordered_pairs(self, section, ctx=None):
-        """Used for eg: shipit.pathmap which has strong
-        ordering requirements"""
-        res = []
-        ctx = ctx or {}
-
-        for s in self._config.sections():
-            if s != section:
-                if not s.startswith(section + "."):
-                    continue
-                expr = parse_conditional_section_name(s, section)
-                if not expr.eval(ctx):
-                    continue
-
-            for key in self._config.options(s):
-                value = self._config.get(s, key)
-                res.append((key, value))
-        return res
-
-    def get_section_as_dict(self, section, ctx):
-        d = {}
-
-        for s in self._config.sections():
-            if s != section:
-                if not s.startswith(section + "."):
-                    continue
-                expr = parse_conditional_section_name(s, section)
-                if not expr.eval(ctx):
-                    continue
-            for field in self._config.options(s):
-                value = self._config.get(s, field)
-                d[field] = value
-        return d
-
-    def update_hash(self, hasher, ctx):
-        """Compute a hash over the configuration for the given
-        context.  The goal is for the hash to change if the config
-        for that context changes, but not if a change is made to
-        the config only for a different platform than that expressed
-        by ctx.  The hash is intended to be used to help invalidate
-        a future cache for the third party build products.
-        The hasher argument is a hash object returned from hashlib."""
-        for section in sorted(SCHEMA.keys()):
-            hasher.update(section.encode("utf-8"))
-
-            # Note: at the time of writing, nothing in the implementation
-            # relies on keys in any config section being ordered.
-            # In theory we could have conflicting flags in different
-            # config sections and later flags override earlier flags.
-            # For the purposes of computing a hash we're not super
-            # concerned about this: manifest changes should be rare
-            # enough and we'd rather that this trigger an invalidation
-            # than strive for a cache hit at this time.
-            pairs = self.get_section_as_ordered_pairs(section, ctx)
-            pairs.sort(key=lambda pair: pair[0])
-            for key, value in pairs:
-                hasher.update(key.encode("utf-8"))
-                if value is not None:
-                    hasher.update(value.encode("utf-8"))
-
-    def is_first_party_project(self):
-        """returns true if this is an FB first-party project"""
-        return self.shipit_project is not None
-
-    def get_required_system_packages(self, ctx):
-        """Returns dictionary of packager system -> list of packages"""
-        return {
-            "rpm": self.get_section_as_args("rpms", ctx),
-            "deb": self.get_section_as_args("debs", ctx),
-            "homebrew": self.get_section_as_args("homebrew", ctx),
-        }
-
-    def _is_satisfied_by_preinstalled_environment(self, ctx):
-        envs = self.get_section_as_args("preinstalled.env", ctx)
-        if not envs:
-            return False
-        for key in envs:
-            val = os.environ.get(key, None)
-            print(f"Testing ENV[{key}]: {repr(val)}")
-            if val is None:
-                return False
-            if len(val) == 0:
-                return False
-
-        return True
-
-    def get_repo_url(self, ctx):
-        return self.get("git", "repo_url", ctx=ctx)
-
-    def create_fetcher(self, build_options, ctx):
-        use_real_shipit = (
-            ShipitTransformerFetcher.available() and build_options.use_shipit
-        )
-        if (
-            not use_real_shipit
-            and self.fbsource_path
-            and build_options.fbsource_dir
-            and self.shipit_project
-        ):
-            return SimpleShipitTransformerFetcher(build_options, self, ctx)
-
-        if (
-            self.fbsource_path
-            and build_options.fbsource_dir
-            and self.shipit_project
-            and ShipitTransformerFetcher.available()
-        ):
-            # We can use the code from fbsource
-            return ShipitTransformerFetcher(build_options, self.shipit_project)
-
-        # Can we satisfy this dep with system packages?
-        if build_options.allow_system_packages:
-            if self._is_satisfied_by_preinstalled_environment(ctx):
-                return PreinstalledNopFetcher()
-
-            packages = self.get_required_system_packages(ctx)
-            package_fetcher = SystemPackageFetcher(build_options, packages)
-            if package_fetcher.packages_are_installed():
-                return package_fetcher
-
-        repo_url = self.get_repo_url(ctx)
-        if repo_url:
-            rev = self.get("git", "rev")
-            depth = self.get("git", "depth")
-            return GitFetcher(build_options, self, repo_url, rev, depth)
-
-        url = self.get("download", "url", ctx=ctx)
-        if url:
-            # We need to defer this import until now to avoid triggering
-            # a cycle when the facebook/__init__.py is loaded.
-            try:
-                from .facebook.lfs import LFSCachingArchiveFetcher
-
-                return LFSCachingArchiveFetcher(
-                    build_options, self, url, self.get("download", "sha256", ctx=ctx)
-                )
-            except ImportError:
-                # This FB internal module isn't shippped to github,
-                # so just use its base class
-                return ArchiveFetcher(
-                    build_options, self, url, self.get("download", "sha256", ctx=ctx)
-                )
-
-        raise KeyError(
-            "project %s has no fetcher configuration matching %s" % (self.name, ctx)
-        )
-
-    def get_builder_name(self, ctx):
-        builder = self.get("build", "builder", ctx=ctx)
-        if not builder:
-            raise Exception("project %s has no builder for %r" % (self.name, ctx))
-        return builder
-
-    def create_builder(  # noqa:C901
-        self,
-        build_options,
-        src_dir,
-        build_dir,
-        inst_dir,
-        ctx,
-        loader,
-        final_install_prefix=None,
-        extra_cmake_defines=None,
-        cmake_target=None,
-        extra_b2_args=None,
-    ):
-        builder = self.get_builder_name(ctx)
-        build_in_src_dir = self.get("build", "build_in_src_dir", "false", ctx=ctx)
-        if build_in_src_dir == "true":
-            # Some scripts don't work when they are configured and build in
-            # a different directory than source (or when the build directory
-            # is not a subdir of source).
-            build_dir = src_dir
-            subdir = self.get("build", "subdir", None, ctx=ctx)
-            if subdir is not None:
-                build_dir = os.path.join(build_dir, subdir)
-            print("build_dir is %s" % build_dir)  # just to quiet lint
-
-        if builder == "make" or builder == "cmakebootstrap":
-            build_args = self.get_section_as_args("make.build_args", ctx)
-            install_args = self.get_section_as_args("make.install_args", ctx)
-            test_args = self.get_section_as_args("make.test_args", ctx)
-            if builder == "cmakebootstrap":
-                return CMakeBootStrapBuilder(
-                    build_options,
-                    ctx,
-                    self,
-                    src_dir,
-                    None,
-                    inst_dir,
-                    build_args,
-                    install_args,
-                    test_args,
-                )
-            else:
-                return MakeBuilder(
-                    build_options,
-                    ctx,
-                    self,
-                    src_dir,
-                    None,
-                    inst_dir,
-                    build_args,
-                    install_args,
-                    test_args,
-                )
-
-        if builder == "autoconf":
-            args = self.get_section_as_args("autoconf.args", ctx)
-            conf_env_args = {}
-            ldflags_cmd = self.get_section_as_args("autoconf.envcmd.LDFLAGS", ctx)
-            if ldflags_cmd:
-                conf_env_args["LDFLAGS"] = ldflags_cmd
-            return AutoconfBuilder(
-                build_options,
-                ctx,
-                self,
-                src_dir,
-                build_dir,
-                inst_dir,
-                args,
-                conf_env_args,
-            )
-
-        if builder == "boost":
-            args = self.get_section_as_args("b2.args", ctx)
-            if extra_b2_args is not None:
-                args += extra_b2_args
-            return Boost(build_options, ctx, self, src_dir, build_dir, inst_dir, args)
-
-        if builder == "cmake":
-            defines = self.get_section_as_dict("cmake.defines", ctx)
-            return CMakeBuilder(
-                build_options,
-                ctx,
-                self,
-                src_dir,
-                build_dir,
-                inst_dir,
-                defines,
-                loader,
-                final_install_prefix,
-                extra_cmake_defines,
-                cmake_target,
-            )
-
-        if builder == "python-wheel":
-            return PythonWheelBuilder(
-                build_options, ctx, self, src_dir, build_dir, inst_dir
-            )
-
-        if builder == "sqlite":
-            return SqliteBuilder(build_options, ctx, self, src_dir, build_dir, inst_dir)
-
-        if builder == "ninja_bootstrap":
-            return NinjaBootstrap(
-                build_options, ctx, self, build_dir, src_dir, inst_dir
-            )
-
-        if builder == "nop":
-            return NopBuilder(build_options, ctx, self, src_dir, inst_dir)
-
-        if builder == "openssl":
-            return OpenSSLBuilder(
-                build_options, ctx, self, build_dir, src_dir, inst_dir
-            )
-
-        if builder == "iproute2":
-            return Iproute2Builder(
-                build_options, ctx, self, src_dir, build_dir, inst_dir
-            )
-
-        if builder == "cargo":
-            return self.create_cargo_builder(
-                build_options, ctx, src_dir, build_dir, inst_dir, loader
-            )
-
-        raise KeyError("project %s has no known builder" % (self.name))
-
-    def create_prepare_builders(
-        self, build_options, ctx, src_dir, build_dir, inst_dir, loader
-    ):
-        """Create builders that have a prepare step run, e.g. to write config files"""
-        prepare_builders = []
-        builder = self.get_builder_name(ctx)
-        cargo = self.get_section_as_dict("cargo", ctx)
-        if not builder == "cargo" and cargo:
-            cargo_builder = self.create_cargo_builder(
-                build_options, ctx, src_dir, build_dir, inst_dir, loader
-            )
-            prepare_builders.append(cargo_builder)
-        return prepare_builders
-
-    def create_cargo_builder(
-        self, build_options, ctx, src_dir, build_dir, inst_dir, loader
-    ):
-        build_doc = self.get("cargo", "build_doc", False, ctx)
-        workspace_dir = self.get("cargo", "workspace_dir", None, ctx)
-        manifests_to_build = self.get("cargo", "manifests_to_build", None, ctx)
-        cargo_config_file = self.get("cargo", "cargo_config_file", None, ctx)
-        return CargoBuilder(
-            build_options,
-            ctx,
-            self,
-            src_dir,
-            build_dir,
-            inst_dir,
-            build_doc,
-            workspace_dir,
-            manifests_to_build,
-            loader,
-            cargo_config_file,
-        )
-
-
-class ManifestContext(object):
-    """ProjectContext contains a dictionary of values to use when evaluating boolean
-    expressions in a project manifest.
-
-    This object should be passed as the `ctx` parameter in ManifestParser.get() calls.
-    """
-
-    ALLOWED_VARIABLES = {
-        "os",
-        "distro",
-        "distro_vers",
-        "fb",
-        "fbsource",
-        "test",
-        "shared_libs",
-    }
-
-    def __init__(self, ctx_dict):
-        assert set(ctx_dict.keys()) == self.ALLOWED_VARIABLES
-        self.ctx_dict = ctx_dict
-
-    def get(self, key):
-        return self.ctx_dict[key]
-
-    def set(self, key, value):
-        assert key in self.ALLOWED_VARIABLES
-        self.ctx_dict[key] = value
-
-    def copy(self):
-        return ManifestContext(dict(self.ctx_dict))
-
-    def __str__(self):
-        s = ", ".join(
-            "%s=%s" % (key, value) for key, value in sorted(self.ctx_dict.items())
-        )
-        return "{" + s + "}"
-
-
-class ContextGenerator(object):
-    """ContextGenerator allows creating ManifestContext objects on a per-project basis.
-    This allows us to evaluate different projects with slightly different contexts.
-
-    For instance, this can be used to only enable tests for some projects."""
-
-    def __init__(self, default_ctx):
-        self.default_ctx = ManifestContext(default_ctx)
-        self.ctx_by_project = {}
-
-    def set_value_for_project(self, project_name, key, value):
-        project_ctx = self.ctx_by_project.get(project_name)
-        if project_ctx is None:
-            project_ctx = self.default_ctx.copy()
-            self.ctx_by_project[project_name] = project_ctx
-        project_ctx.set(key, value)
-
-    def set_value_for_all_projects(self, key, value):
-        self.default_ctx.set(key, value)
-        for ctx in self.ctx_by_project.values():
-            ctx.set(key, value)
-
-    def get_context(self, project_name):
-        return self.ctx_by_project.get(project_name, self.default_ctx)
diff --git a/build/fbcode_builder/getdeps/platform.py b/build/fbcode_builder/getdeps/platform.py
deleted file mode 100644
index d8ac41b46be44..0000000000000
--- a/build/fbcode_builder/getdeps/platform.py
+++ /dev/null
@@ -1,287 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import os
-
-import platform
-import re
-import shlex
-import sys
-from typing import Optional, Tuple
-
-
-def is_windows() -> bool:
-    """Returns true if the system we are currently running on
-    is a Windows system"""
-    return sys.platform.startswith("win")
-
-
-def get_linux_type() -> Tuple[Optional[str], Optional[str], Optional[str]]:
-    try:
-        with open("/etc/os-release") as f:
-            data = f.read()
-    except EnvironmentError:
-        return (None, None, None)
-
-    os_vars = {}
-    for line in data.splitlines():
-        parts = line.split("=", 1)
-        if len(parts) != 2:
-            continue
-        key = parts[0].strip()
-        value_parts = shlex.split(parts[1].strip())
-        if not value_parts:
-            value = ""
-        else:
-            value = value_parts[0]
-        os_vars[key] = value
-
-    name = os_vars.get("NAME")
-    if name:
-        name = name.lower()
-        name = re.sub("linux", "", name)
-        name = name.strip().replace(" ", "_")
-
-    version_id = os_vars.get("VERSION_ID")
-    if version_id:
-        version_id = version_id.lower()
-
-    return "linux", name, version_id
-
-
-# Ideally we'd use a common library like `psutil` to read system information,
-# but getdeps can't take third-party dependencies.
-
-
-def _get_available_ram_linux() -> int:
-    # TODO: Ideally, this function would inspect the current cgroup for any
-    # limits, rather than solely relying on system RAM.
-
-    meminfo_path = "/proc/meminfo"
-    try:
-        with open(meminfo_path) as f:
-            for line in f:
-                try:
-                    key, value = line.split(":", 1)
-                except ValueError:
-                    continue
-                suffix = " kB\n"
-                if key == "MemAvailable" and value.endswith(suffix):
-                    value = value[: -len(suffix)]
-                    try:
-                        return int(value) // 1024
-                    except ValueError:
-                        continue
-    except OSError:
-        print("error opening {}".format(meminfo_path), end="", file=sys.stderr)
-    else:
-        print(
-            "{} had no valid MemAvailable".format(meminfo_path), end="", file=sys.stderr
-        )
-
-    guess = 8
-    print(", guessing {} GiB".format(guess), file=sys.stderr)
-    return guess * 1024
-
-
-def _get_available_ram_macos() -> int:
-    import ctypes.util
-
-    libc = ctypes.CDLL(ctypes.util.find_library("libc"), use_errno=True)
-    sysctlbyname = libc.sysctlbyname
-    sysctlbyname.restype = ctypes.c_int
-    sysctlbyname.argtypes = [
-        ctypes.c_char_p,
-        ctypes.c_void_p,
-        ctypes.POINTER(ctypes.c_size_t),
-        ctypes.c_void_p,
-        ctypes.c_size_t,
-    ]
-    # TODO: There may be some way to approximate an availability
-    # metric, but just use total RAM for now.
-    memsize = ctypes.c_int64()
-    memsizesize = ctypes.c_size_t(8)
-    res = sysctlbyname(
-        b"hw.memsize", ctypes.byref(memsize), ctypes.byref(memsizesize), None, 0
-    )
-    if res != 0:
-        raise NotImplementedError(
-            f"failed to retrieve hw.memsize sysctl: {ctypes.get_errno()}"
-        )
-    return memsize.value // (1024 * 1024)
-
-
-def _get_available_ram_windows() -> int:
-    import ctypes
-
-    DWORD = ctypes.c_uint32
-    QWORD = ctypes.c_uint64
-
-    class MEMORYSTATUSEX(ctypes.Structure):
-        _fields_ = [
-            ("dwLength", DWORD),
-            ("dwMemoryLoad", DWORD),
-            ("ullTotalPhys", QWORD),
-            ("ullAvailPhys", QWORD),
-            ("ullTotalPageFile", QWORD),
-            ("ullAvailPageFile", QWORD),
-            ("ullTotalVirtual", QWORD),
-            ("ullAvailVirtual", QWORD),
-            ("ullExtendedVirtual", QWORD),
-        ]
-
-    ms = MEMORYSTATUSEX()
-    ms.dwLength = ctypes.sizeof(ms)
-    # pyre-ignore[16]
-    res = ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(ms))
-    if res == 0:
-        raise NotImplementedError("error calling GlobalMemoryStatusEx")
-
-    # This is fuzzy, but AvailPhys is too conservative, and AvailTotal is too
-    # aggressive, so average the two. It's okay for builds to use some swap.
-    return (ms.ullAvailPhys + ms.ullTotalPhys) // (2 * 1024 * 1024)
-
-
-def _get_available_ram_freebsd() -> int:
-    import ctypes.util
-
-    libc = ctypes.CDLL(ctypes.util.find_library("libc"), use_errno=True)
-    sysctlbyname = libc.sysctlbyname
-    sysctlbyname.restype = ctypes.c_int
-    sysctlbyname.argtypes = [
-        ctypes.c_char_p,
-        ctypes.c_void_p,
-        ctypes.POINTER(ctypes.c_size_t),
-        ctypes.c_void_p,
-        ctypes.c_size_t,
-    ]
-    # hw.usermem is pretty close to what we want.
-    memsize = ctypes.c_int64()
-    memsizesize = ctypes.c_size_t(8)
-    res = sysctlbyname(
-        b"hw.usermem", ctypes.byref(memsize), ctypes.byref(memsizesize), None, 0
-    )
-    if res != 0:
-        raise NotImplementedError(
-            f"failed to retrieve hw.memsize sysctl: {ctypes.get_errno()}"
-        )
-    return memsize.value // (1024 * 1024)
-
-
-def get_available_ram() -> int:
-    """
-    Returns a platform-appropriate available RAM metric in MiB.
-    """
-    if sys.platform == "linux":
-        return _get_available_ram_linux()
-    elif sys.platform == "darwin":
-        return _get_available_ram_macos()
-    elif sys.platform == "win32":
-        return _get_available_ram_windows()
-    elif sys.platform.startswith("freebsd"):
-        return _get_available_ram_freebsd()
-    else:
-        raise NotImplementedError(
-            f"platform {sys.platform} does not have an implementation of get_available_ram"
-        )
-
-
-def is_current_host_arm() -> bool:
-    if sys.platform.startswith("darwin"):
-        # platform.machine() can be fooled by rosetta for python < 3.9.2
-        return "ARM64" in os.uname().version
-    else:
-        machine = platform.machine().lower()
-        return "arm" in machine or "aarch" in machine
-
-
-class HostType(object):
-    def __init__(self, ostype=None, distro=None, distrovers=None) -> None:
-        # Maybe we should allow callers to indicate whether this machine uses
-        # an ARM architecture, but we need to change HostType serialization
-        # and deserialization in that case and hunt down anywhere that is
-        # persisting that serialized data.
-        isarm = False
-
-        if ostype is None:
-            distro = None
-            distrovers = None
-            if sys.platform.startswith("linux"):
-                ostype, distro, distrovers = get_linux_type()
-            elif sys.platform.startswith("darwin"):
-                ostype = "darwin"
-            elif is_windows():
-                ostype = "windows"
-                # pyre-fixme[16]: Module `sys` has no attribute `getwindowsversion`.
-                distrovers = str(sys.getwindowsversion().major)
-            elif sys.platform.startswith("freebsd"):
-                ostype = "freebsd"
-            else:
-                ostype = sys.platform
-
-            isarm = is_current_host_arm()
-
-        # The operating system type
-        self.ostype = ostype
-        # The distribution, if applicable
-        self.distro = distro
-        # The OS/distro version if known
-        self.distrovers = distrovers
-        # Does the CPU use an ARM architecture? ARM includes Apple Silicon
-        # Macs as well as other ARM systems that might be running Linux or
-        # something.
-        self.isarm = isarm
-
-    def is_windows(self):
-        return self.ostype == "windows"
-
-    # is_arm is kinda half implemented at the moment. This method is only
-    # intended to be used when HostType represents information about the
-    # current machine we are running on.
-    # When HostType is being used to enumerate platform types (represent
-    # information about machine types that we may or may not be running on)
-    # the result could be nonsense (under the current implementation its always
-    # false.)
-    def is_arm(self):
-        return self.isarm
-
-    def is_darwin(self):
-        return self.ostype == "darwin"
-
-    def is_linux(self):
-        return self.ostype == "linux"
-
-    def is_freebsd(self):
-        return self.ostype == "freebsd"
-
-    def as_tuple_string(self) -> str:
-        return "%s-%s-%s" % (
-            self.ostype,
-            self.distro or "none",
-            self.distrovers or "none",
-        )
-
-    def get_package_manager(self):
-        if not self.is_linux() and not self.is_darwin():
-            return None
-        if self.is_darwin():
-            return "homebrew"
-        if self.distro in ("fedora", "centos", "centos_stream"):
-            return "rpm"
-        if self.distro.startswith(("debian", "ubuntu")):
-            return "deb"
-        return None
-
-    @staticmethod
-    def from_tuple_string(s) -> "HostType":
-        ostype, distro, distrovers = s.split("-")
-        return HostType(ostype=ostype, distro=distro, distrovers=distrovers)
-
-    def __eq__(self, b):
-        return (
-            self.ostype == b.ostype
-            and self.distro == b.distro
-            and self.distrovers == b.distrovers
-        )
diff --git a/build/fbcode_builder/getdeps/py_wheel_builder.py b/build/fbcode_builder/getdeps/py_wheel_builder.py
deleted file mode 100644
index 53e807927f7c8..0000000000000
--- a/build/fbcode_builder/getdeps/py_wheel_builder.py
+++ /dev/null
@@ -1,285 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import codecs
-import collections
-import email
-import os
-import re
-import stat
-from typing import Dict, List
-
-from .builder import BuilderBase, CMakeBuilder
-
-
-WheelNameInfo = collections.namedtuple(
-    "WheelNameInfo", ("distribution", "version", "build", "python", "abi", "platform")
-)
-
-CMAKE_HEADER = """
-cmake_minimum_required(VERSION 3.8)
-
-project("{manifest_name}" LANGUAGES C)
-
-set(CMAKE_MODULE_PATH
-  "{cmake_dir}"
-  ${{CMAKE_MODULE_PATH}}
-)
-include(FBPythonBinary)
-
-set(CMAKE_INSTALL_DIR lib/cmake/{manifest_name} CACHE STRING
-    "The subdirectory where CMake package config files should be installed")
-"""
-
-CMAKE_FOOTER = """
-install_fb_python_library({lib_name} EXPORT all)
-install(
-  EXPORT all
-  FILE {manifest_name}-targets.cmake
-  NAMESPACE {namespace}::
-  DESTINATION ${{CMAKE_INSTALL_DIR}}
-)
-
-include(CMakePackageConfigHelpers)
-configure_package_config_file(
-  ${{CMAKE_BINARY_DIR}}/{manifest_name}-config.cmake.in
-  {manifest_name}-config.cmake
-  INSTALL_DESTINATION ${{CMAKE_INSTALL_DIR}}
-  PATH_VARS
-    CMAKE_INSTALL_DIR
-)
-install(
-  FILES ${{CMAKE_CURRENT_BINARY_DIR}}/{manifest_name}-config.cmake
-  DESTINATION ${{CMAKE_INSTALL_DIR}}
-)
-"""
-
-CMAKE_CONFIG_FILE = """
-@PACKAGE_INIT@
-
-include(CMakeFindDependencyMacro)
-
-set_and_check({upper_name}_CMAKE_DIR "@PACKAGE_CMAKE_INSTALL_DIR@")
-
-if (NOT TARGET {namespace}::{lib_name})
-  include("${{{upper_name}_CMAKE_DIR}}/{manifest_name}-targets.cmake")
-endif()
-
-set({upper_name}_LIBRARIES {namespace}::{lib_name})
-
-{find_dependency_lines}
-
-if (NOT {manifest_name}_FIND_QUIETLY)
-  message(STATUS "Found {manifest_name}: ${{PACKAGE_PREFIX_DIR}}")
-endif()
-"""
-
-
-# Note: for now we are manually manipulating the wheel packet contents.
-# The wheel format is documented here:
-# https://www.python.org/dev/peps/pep-0491/#file-format
-#
-# We currently aren't particularly smart about correctly handling the full wheel
-# functionality, but this is good enough to handle simple pure-python wheels,
-# which is the main thing we care about right now.
-#
-# We could potentially use pip to install the wheel to a temporary location and
-# then copy its "installed" files, but this has its own set of complications.
-# This would require pip to already be installed and available, and we would
-# need to correctly find the right version of pip or pip3 to use.
-# If we did ever want to go down that path, we would probably want to use
-# something like the following pip3 command:
-#   pip3 --isolated install --no-cache-dir --no-index --system \
-#       --target <install_dir> <wheel_file>
-# pyre-fixme[13] fields initialized in _build
-class PythonWheelBuilder(BuilderBase):
-    """This Builder can take Python wheel archives and install them as python libraries
-    that can be used by add_fb_python_library()/add_fb_python_executable() CMake rules.
-    """
-
-    dist_info_dir: str
-    template_format_dict: Dict[str, str]
-
-    def _build(self, install_dirs: List[str], reconfigure: bool) -> None:
-        # When we are invoked, self.src_dir contains the unpacked wheel contents.
-        #
-        # Since a wheel file is just a zip file, the Fetcher code recognizes it as such
-        # and goes ahead and unpacks it.  (We could disable that Fetcher behavior in the
-        # future if we ever wanted to, say if we wanted to call pip here.)
-        wheel_name = self._parse_wheel_name()
-        name_version_prefix = "-".join((wheel_name.distribution, wheel_name.version))
-        dist_info_name = name_version_prefix + ".dist-info"
-        data_dir_name = name_version_prefix + ".data"
-        self.dist_info_dir = os.path.join(self.src_dir, dist_info_name)
-        wheel_metadata = self._read_wheel_metadata(wheel_name)
-
-        # Check that we can understand the wheel version.
-        # We don't really care about wheel_metadata["Root-Is-Purelib"] since
-        # we are generating our own standalone python archives rather than installing
-        # into site-packages.
-        version = wheel_metadata["Wheel-Version"]
-        if not version.startswith("1."):
-            raise Exception("unsupported wheel version %s" % (version,))
-
-        # Add a find_dependency() call for each of our dependencies.
-        # The dependencies are also listed in the wheel METADATA file, but it is simpler
-        # to pull this directly from the getdeps manifest.
-        dep_list = sorted(
-            self.manifest.get_section_as_dict("dependencies", self.ctx).keys()
-        )
-        find_dependency_lines = ["find_dependency({})".format(dep) for dep in dep_list]
-
-        getdeps_cmake_dir = os.path.join(
-            os.path.dirname(os.path.dirname(__file__)), "CMake"
-        )
-        self.template_format_dict = {
-            # Note that CMake files always uses forward slash separators in path names,
-            # even on Windows.  Therefore replace path separators here.
-            "cmake_dir": _to_cmake_path(getdeps_cmake_dir),
-            "lib_name": self.manifest.name,
-            "manifest_name": self.manifest.name,
-            "namespace": self.manifest.name,
-            "upper_name": self.manifest.name.upper().replace("-", "_"),
-            "find_dependency_lines": "\n".join(find_dependency_lines),
-        }
-
-        # Find sources from the root directory
-        path_mapping = {}
-        for entry in os.listdir(self.src_dir):
-            if entry in (dist_info_name, data_dir_name):
-                continue
-            self._add_sources(path_mapping, os.path.join(self.src_dir, entry), entry)
-
-        # Files under the .data directory also need to be installed in the correct
-        # locations
-        if os.path.exists(data_dir_name):
-            # TODO: process the subdirectories of data_dir_name
-            # This isn't implemented yet since for now we have only needed dependencies
-            # on some simple pure Python wheels, so I haven't tested against wheels with
-            # additional files in the .data directory.
-            raise Exception(
-                "handling of the subdirectories inside %s is not implemented yet"
-                % data_dir_name
-            )
-
-        # Emit CMake files
-        self._write_cmakelists(path_mapping, dep_list)
-        self._write_cmake_config_template()
-
-        # Run the build
-        self._run_cmake_build(install_dirs, reconfigure)
-
-    def _run_cmake_build(self, install_dirs: List[str], reconfigure: bool) -> None:
-        cmake_builder = CMakeBuilder(
-            build_opts=self.build_opts,
-            ctx=self.ctx,
-            manifest=self.manifest,
-            # Note that we intentionally supply src_dir=build_dir,
-            # since we wrote out our generated CMakeLists.txt in the build directory
-            src_dir=self.build_dir,
-            build_dir=self.build_dir,
-            inst_dir=self.inst_dir,
-            loader=None,
-            defines={},
-            final_install_prefix=None,
-        )
-        cmake_builder.build(install_dirs=install_dirs, reconfigure=reconfigure)
-
-    def _write_cmakelists(self, path_mapping: Dict[str, str], dependencies) -> None:
-        cmake_path = os.path.join(self.build_dir, "CMakeLists.txt")
-        with open(cmake_path, "w") as f:
-            f.write(CMAKE_HEADER.format(**self.template_format_dict))
-            for dep in dependencies:
-                f.write("find_package({0} REQUIRED)\n".format(dep))
-
-            f.write(
-                "add_fb_python_library({lib_name}\n".format(**self.template_format_dict)
-            )
-            f.write('  BASE_DIR "%s"\n' % _to_cmake_path(self.src_dir))
-            f.write("  SOURCES\n")
-            for src_path, install_path in path_mapping.items():
-                f.write(
-                    '    "%s=%s"\n'
-                    % (_to_cmake_path(src_path), _to_cmake_path(install_path))
-                )
-            if dependencies:
-                f.write("  DEPENDS\n")
-                for dep in dependencies:
-                    f.write('    "{0}::{0}"\n'.format(dep))
-            f.write(")\n")
-
-            f.write(CMAKE_FOOTER.format(**self.template_format_dict))
-
-    def _write_cmake_config_template(self) -> None:
-        config_path_name = self.manifest.name + "-config.cmake.in"
-        output_path = os.path.join(self.build_dir, config_path_name)
-
-        with open(output_path, "w") as f:
-            f.write(CMAKE_CONFIG_FILE.format(**self.template_format_dict))
-
-    def _add_sources(
-        self, path_mapping: Dict[str, str], src_path: str, install_path: str
-    ) -> None:
-        s = os.lstat(src_path)
-        if not stat.S_ISDIR(s.st_mode):
-            path_mapping[src_path] = install_path
-            return
-
-        for entry in os.listdir(src_path):
-            self._add_sources(
-                path_mapping,
-                os.path.join(src_path, entry),
-                os.path.join(install_path, entry),
-            )
-
-    def _parse_wheel_name(self) -> WheelNameInfo:
-        # The ArchiveFetcher prepends "manifest_name-", so strip that off first.
-        wheel_name = os.path.basename(self.src_dir)
-        prefix = self.manifest.name + "-"
-        if not wheel_name.startswith(prefix):
-            raise Exception(
-                "expected wheel source directory to be of the form %s-NAME.whl"
-                % (prefix,)
-            )
-        wheel_name = wheel_name[len(prefix) :]
-
-        wheel_name_re = re.compile(
-            r"(?P<distribution>[^-]+)"
-            r"-(?P<version>\d+[^-]*)"
-            r"(-(?P<build>\d+[^-]*))?"
-            r"-(?P<python>\w+\d+(\.\w+\d+)*)"
-            r"-(?P<abi>\w+)"
-            r"-(?P<platform>\w+(\.\w+)*)"
-            r"\.whl"
-        )
-        match = wheel_name_re.match(wheel_name)
-        if not match:
-            raise Exception(
-                "bad python wheel name %s: expected to have the form "
-                "DISTRIBUTION-VERSION-[-BUILD]-PYTAG-ABI-PLATFORM"
-            )
-
-        return WheelNameInfo(
-            distribution=match.group("distribution"),
-            version=match.group("version"),
-            build=match.group("build"),
-            python=match.group("python"),
-            abi=match.group("abi"),
-            platform=match.group("platform"),
-        )
-
-    def _read_wheel_metadata(self, wheel_name):
-        metadata_path = os.path.join(self.dist_info_dir, "WHEEL")
-        with codecs.open(metadata_path, "r", encoding="utf-8") as f:
-            return email.message_from_file(f)
-
-
-def _to_cmake_path(path):
-    # CMake always uses forward slashes to separate paths in CMakeLists.txt files,
-    # even on Windows.  It treats backslashes as character escapes, so using
-    # backslashes in the path will cause problems.  Therefore replace all path
-    # separators with forward slashes to make sure the paths are correct on Windows.
-    # e.g. "C:\foo\bar.txt" becomes "C:/foo/bar.txt"
-    return path.replace(os.path.sep, "/")
diff --git a/build/fbcode_builder/getdeps/runcmd.py b/build/fbcode_builder/getdeps/runcmd.py
deleted file mode 100644
index dc35b6f026600..0000000000000
--- a/build/fbcode_builder/getdeps/runcmd.py
+++ /dev/null
@@ -1,166 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import os
-import select
-import subprocess
-import sys
-
-from .envfuncs import Env
-from .platform import is_windows
-
-
-try:
-    from shlex import quote as shellquote
-except ImportError:
-    from pipes import quote as shellquote
-
-
-class RunCommandError(Exception):
-    pass
-
-
-def _print_env_diff(env, log_fn) -> None:
-    current_keys = set(os.environ.keys())
-    wanted_env = set(env.keys())
-
-    unset_keys = current_keys.difference(wanted_env)
-    for k in sorted(unset_keys):
-        log_fn("+ unset %s\n" % k)
-
-    added_keys = wanted_env.difference(current_keys)
-    for k in wanted_env.intersection(current_keys):
-        if os.environ[k] != env[k]:
-            added_keys.add(k)
-
-    for k in sorted(added_keys):
-        if ("PATH" in k) and (os.pathsep in env[k]):
-            log_fn("+ %s=\\\n" % k)
-            for elem in env[k].split(os.pathsep):
-                log_fn("+      %s%s\\\n" % (shellquote(elem), os.pathsep))
-        else:
-            log_fn("+ %s=%s \\\n" % (k, shellquote(env[k])))
-
-
-def run_cmd(cmd, env=None, cwd=None, allow_fail: bool = False, log_file=None) -> int:
-    def log_to_stdout(msg):
-        sys.stdout.buffer.write(msg.encode(errors="surrogateescape"))
-
-    if log_file is not None:
-        with open(log_file, "a", encoding="utf-8", errors="surrogateescape") as log:
-
-            def log_function(msg):
-                log.write(msg)
-                log_to_stdout(msg)
-
-            return _run_cmd(
-                cmd, env=env, cwd=cwd, allow_fail=allow_fail, log_fn=log_function
-            )
-    else:
-        return _run_cmd(
-            cmd, env=env, cwd=cwd, allow_fail=allow_fail, log_fn=log_to_stdout
-        )
-
-
-def _run_cmd(cmd, env, cwd, allow_fail, log_fn) -> int:
-    log_fn("---\n")
-    try:
-        cmd_str = " \\\n+      ".join(shellquote(arg) for arg in cmd)
-    except TypeError:
-        # eg: one of the elements is None
-        raise RunCommandError("problem quoting cmd: %r" % cmd)
-
-    if env:
-        assert isinstance(env, Env)
-        _print_env_diff(env, log_fn)
-
-        # Convert from our Env type to a regular dict.
-        # This is needed because python3 looks up b'PATH' and 'PATH'
-        # and emits an error if both are present.  In our Env type
-        # we'll return the same value for both requests, but we don't
-        # have duplicate potentially conflicting values which is the
-        # spirit of the check.
-        env = dict(env.items())
-
-    if cwd:
-        log_fn("+ cd %s && \\\n" % shellquote(cwd))
-        # Our long path escape sequence may confuse cmd.exe, so if the cwd
-        # is short enough, strip that off.
-        if is_windows() and (len(cwd) < 250) and cwd.startswith("\\\\?\\"):
-            cwd = cwd[4:]
-
-    log_fn("+ %s\n" % cmd_str)
-
-    isinteractive = os.isatty(sys.stdout.fileno())
-    if isinteractive:
-        stdout = None
-        sys.stdout.buffer.flush()
-    else:
-        stdout = subprocess.PIPE
-
-    try:
-        p = subprocess.Popen(
-            cmd, env=env, cwd=cwd, stdout=stdout, stderr=subprocess.STDOUT
-        )
-    except (TypeError, ValueError, OSError) as exc:
-        log_fn("error running `%s`: %s" % (cmd_str, exc))
-        raise RunCommandError(
-            "%s while running `%s` with env=%r\nos.environ=%r"
-            % (str(exc), cmd_str, env, os.environ)
-        )
-
-    if not isinteractive:
-        _pipe_output(p, log_fn)
-
-    p.wait()
-    if p.returncode != 0 and not allow_fail:
-        raise subprocess.CalledProcessError(p.returncode, cmd)
-
-    return p.returncode
-
-
-if hasattr(select, "poll"):
-
-    def _pipe_output(p, log_fn):
-        """Read output from p.stdout and call log_fn() with each chunk of data as it
-        becomes available."""
-        # Perform non-blocking reads
-        import fcntl
-
-        fcntl.fcntl(p.stdout.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
-        poll = select.poll()
-        poll.register(p.stdout.fileno(), select.POLLIN)
-
-        buffer_size = 4096
-        while True:
-            poll.poll()
-            data = p.stdout.read(buffer_size)
-            if not data:
-                break
-            # log_fn() accepts arguments as str (binary in Python 2, unicode in
-            # Python 3).  In Python 3 the subprocess output will be plain bytes,
-            # and need to be decoded.
-            if not isinstance(data, str):
-                data = data.decode("utf-8", errors="surrogateescape")
-            log_fn(data)
-
-else:
-
-    def _pipe_output(p, log_fn):
-        """Read output from p.stdout and call log_fn() with each chunk of data as it
-        becomes available."""
-        # Perform blocking reads.  Use a smaller buffer size to avoid blocking
-        # for very long when data is available.
-        buffer_size = 64
-        while True:
-            data = p.stdout.read(buffer_size)
-            if not data:
-                break
-            # log_fn() accepts arguments as str (binary in Python 2, unicode in
-            # Python 3).  In Python 3 the subprocess output will be plain bytes,
-            # and need to be decoded.
-            if not isinstance(data, str):
-                data = data.decode("utf-8", errors="surrogateescape")
-            log_fn(data)
diff --git a/build/fbcode_builder/getdeps/subcmd.py b/build/fbcode_builder/getdeps/subcmd.py
deleted file mode 100644
index 3c338642d8402..0000000000000
--- a/build/fbcode_builder/getdeps/subcmd.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-class SubCmd(object):
-    NAME = None
-    HELP = None
-
-    def run(self, args) -> int:
-        """perform the command"""
-        return 0
-
-    def setup_parser(self, parser) -> None:
-        # Subclasses should override setup_parser() if they have any
-        # command line options or arguments.
-        pass
-
-
-CmdTable = []
-
-
-def add_subcommands(parser, common_args, cmd_table=CmdTable) -> None:
-    """Register parsers for the defined commands with the provided parser"""
-    for cls in cmd_table:
-        command = cls()
-        command_parser = parser.add_parser(
-            command.NAME, help=command.HELP, parents=[common_args]
-        )
-        command.setup_parser(command_parser)
-        command_parser.set_defaults(func=command.run)
-
-
-def cmd(name, help=None, cmd_table=CmdTable):
-    """
-    @cmd() is a decorator that can be used to help define Subcmd instances
-
-    Example usage:
-
-        @subcmd('list', 'Show the result list')
-        class ListCmd(Subcmd):
-            def run(self, args):
-                # Perform the command actions here...
-                pass
-    """
-
-    def wrapper(cls):
-        class SubclassedCmd(cls):
-            NAME = name
-            HELP = help
-
-        cmd_table.append(SubclassedCmd)
-        return SubclassedCmd
-
-    return wrapper
diff --git a/build/fbcode_builder/getdeps/test/expr_test.py b/build/fbcode_builder/getdeps/test/expr_test.py
deleted file mode 100644
index f12f68985ed89..0000000000000
--- a/build/fbcode_builder/getdeps/test/expr_test.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-import unittest
-
-from ..expr import parse_expr
-
-
-class ExprTest(unittest.TestCase):
-    def test_equal(self) -> None:
-        valid_variables = {"foo", "some_var", "another_var"}
-        e = parse_expr("foo=bar", valid_variables)
-        self.assertTrue(e.eval({"foo": "bar"}))
-        self.assertFalse(e.eval({"foo": "not-bar"}))
-        self.assertFalse(e.eval({"not-foo": "bar"}))
-
-    def test_not_equal(self) -> None:
-        valid_variables = {"foo"}
-        e = parse_expr("not(foo=bar)", valid_variables)
-        self.assertFalse(e.eval({"foo": "bar"}))
-        self.assertTrue(e.eval({"foo": "not-bar"}))
-
-    def test_bad_not(self) -> None:
-        valid_variables = {"foo"}
-        with self.assertRaises(Exception):
-            parse_expr("foo=not(bar)", valid_variables)
-
-    def test_bad_variable(self) -> None:
-        valid_variables = {"bar"}
-        with self.assertRaises(Exception):
-            parse_expr("foo=bar", valid_variables)
-
-    def test_all(self) -> None:
-        valid_variables = {"foo", "baz"}
-        e = parse_expr("all(foo = bar, baz = qux)", valid_variables)
-        self.assertTrue(e.eval({"foo": "bar", "baz": "qux"}))
-        self.assertFalse(e.eval({"foo": "bar", "baz": "nope"}))
-        self.assertFalse(e.eval({"foo": "nope", "baz": "nope"}))
-
-    def test_any(self) -> None:
-        valid_variables = {"foo", "baz"}
-        e = parse_expr("any(foo = bar, baz = qux)", valid_variables)
-        self.assertTrue(e.eval({"foo": "bar", "baz": "qux"}))
-        self.assertTrue(e.eval({"foo": "bar", "baz": "nope"}))
-        self.assertFalse(e.eval({"foo": "nope", "baz": "nope"}))
diff --git a/build/fbcode_builder/getdeps/test/fixtures/duplicate/foo b/build/fbcode_builder/getdeps/test/fixtures/duplicate/foo
deleted file mode 100644
index a0384ee3b33fd..0000000000000
--- a/build/fbcode_builder/getdeps/test/fixtures/duplicate/foo
+++ /dev/null
@@ -1,2 +0,0 @@
-[manifest]
-name = foo
diff --git a/build/fbcode_builder/getdeps/test/fixtures/duplicate/subdir/foo b/build/fbcode_builder/getdeps/test/fixtures/duplicate/subdir/foo
deleted file mode 100644
index a0384ee3b33fd..0000000000000
--- a/build/fbcode_builder/getdeps/test/fixtures/duplicate/subdir/foo
+++ /dev/null
@@ -1,2 +0,0 @@
-[manifest]
-name = foo
diff --git a/build/fbcode_builder/getdeps/test/manifest_test.py b/build/fbcode_builder/getdeps/test/manifest_test.py
deleted file mode 100644
index e48b05f321d04..0000000000000
--- a/build/fbcode_builder/getdeps/test/manifest_test.py
+++ /dev/null
@@ -1,232 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-import sys
-import unittest
-
-from ..load import load_all_manifests, patch_loader
-from ..manifest import ManifestParser
-
-
-class ManifestTest(unittest.TestCase):
-    def test_missing_section(self) -> None:
-        with self.assertRaisesRegex(
-            Exception, "manifest file test is missing required section manifest"
-        ):
-            ManifestParser("test", "")
-
-    def test_missing_name(self) -> None:
-        with self.assertRaisesRegex(
-            Exception,
-            "manifest file test section 'manifest' is missing required field 'name'",
-        ):
-            ManifestParser(
-                "test",
-                """
-[manifest]
-""",
-            )
-
-    def test_minimal(self) -> None:
-        p = ManifestParser(
-            "test",
-            """
-[manifest]
-name = test
-""",
-        )
-        self.assertEqual(p.name, "test")
-        self.assertEqual(p.fbsource_path, None)
-
-    def test_minimal_with_fbsource_path(self) -> None:
-        p = ManifestParser(
-            "test",
-            """
-[manifest]
-name = test
-fbsource_path = fbcode/wat
-""",
-        )
-        self.assertEqual(p.name, "test")
-        self.assertEqual(p.fbsource_path, "fbcode/wat")
-
-    def test_unknown_field(self) -> None:
-        with self.assertRaisesRegex(
-            Exception,
-            (
-                "manifest file test section 'manifest' contains "
-                "unknown field 'invalid.field'"
-            ),
-        ):
-            ManifestParser(
-                "test",
-                """
-[manifest]
-name = test
-invalid.field = woot
-""",
-            )
-
-    def test_invalid_section_name(self) -> None:
-        with self.assertRaisesRegex(
-            Exception, "manifest file test contains unknown section 'invalid.section'"
-        ):
-            ManifestParser(
-                "test",
-                """
-[manifest]
-name = test
-
-[invalid.section]
-foo = bar
-""",
-            )
-
-    def test_value_in_dependencies_section(self) -> None:
-        with self.assertRaisesRegex(
-            Exception,
-            (
-                "manifest file test section 'dependencies' has "
-                "'foo = bar' but this section doesn't allow "
-                "specifying values for its entries"
-            ),
-        ):
-            ManifestParser(
-                "test",
-                """
-[manifest]
-name = test
-
-[dependencies]
-foo = bar
-""",
-            )
-
-    def test_invalid_conditional_section_name(self) -> None:
-        with self.assertRaisesRegex(
-            Exception,
-            (
-                "manifest file test section 'dependencies.=' "
-                "has invalid conditional: expected "
-                "identifier found ="
-            ),
-        ):
-            ManifestParser(
-                "test",
-                """
-[manifest]
-name = test
-
-[dependencies.=]
-""",
-            )
-
-    def test_section_as_args(self) -> None:
-        p = ManifestParser(
-            "test",
-            """
-[manifest]
-name = test
-
-[dependencies]
-a
-b
-c
-
-[dependencies.test=on]
-foo
-""",
-        )
-        self.assertEqual(p.get_section_as_args("dependencies"), ["a", "b", "c"])
-        self.assertEqual(
-            p.get_section_as_args("dependencies", {"test": "off"}), ["a", "b", "c"]
-        )
-        self.assertEqual(
-            p.get_section_as_args("dependencies", {"test": "on"}),
-            ["a", "b", "c", "foo"],
-        )
-
-        p2 = ManifestParser(
-            "test",
-            """
-[manifest]
-name = test
-
-[autoconf.args]
---prefix=/foo
---with-woot
-""",
-        )
-        self.assertEqual(
-            p2.get_section_as_args("autoconf.args"), ["--prefix=/foo", "--with-woot"]
-        )
-
-    def test_section_as_dict(self) -> None:
-        p = ManifestParser(
-            "test",
-            """
-[manifest]
-name = test
-
-[cmake.defines]
-foo = bar
-
-[cmake.defines.test=on]
-foo = baz
-""",
-        )
-        self.assertEqual(p.get_section_as_dict("cmake.defines", {}), {"foo": "bar"})
-        self.assertEqual(
-            p.get_section_as_dict("cmake.defines", {"test": "on"}), {"foo": "baz"}
-        )
-
-        p2 = ManifestParser(
-            "test",
-            """
-[manifest]
-name = test
-
-[cmake.defines.test=on]
-foo = baz
-
-[cmake.defines]
-foo = bar
-""",
-        )
-        self.assertEqual(
-            p2.get_section_as_dict("cmake.defines", {"test": "on"}),
-            {"foo": "bar"},
-            msg="sections cascade in the order they appear in the manifest",
-        )
-
-    def test_parse_common_manifests(self) -> None:
-        patch_loader(__name__)
-        manifests = load_all_manifests(None)
-        self.assertNotEqual(0, len(manifests), msg="parsed some number of manifests")
-
-    def test_mismatch_name(self) -> None:
-        with self.assertRaisesRegex(
-            Exception,
-            "filename of the manifest 'foo' does not match the manifest name 'bar'",
-        ):
-            ManifestParser(
-                "foo",
-                """
-[manifest]
-name = bar
-""",
-            )
-
-    def test_duplicate_manifest(self) -> None:
-        patch_loader(__name__, "fixtures/duplicate")
-
-        with self.assertRaisesRegex(Exception, "found duplicate manifest 'foo'"):
-            load_all_manifests(None)
-
-    if sys.version_info < (3, 2):
-
-        def assertRaisesRegex(self, *args, **kwargs):
-            return self.assertRaisesRegexp(*args, **kwargs)
diff --git a/build/fbcode_builder/getdeps/test/platform_test.py b/build/fbcode_builder/getdeps/test/platform_test.py
deleted file mode 100644
index ce0de7a67f5ed..0000000000000
--- a/build/fbcode_builder/getdeps/test/platform_test.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-import unittest
-
-from ..platform import HostType
-
-
-class PlatformTest(unittest.TestCase):
-    def test_create(self) -> None:
-        p = HostType()
-        self.assertNotEqual(p.ostype, None, msg="probed and returned something")
-
-        tuple_string = p.as_tuple_string()
-        round_trip = HostType.from_tuple_string(tuple_string)
-        self.assertEqual(round_trip, p)
-
-    def test_rendering_of_none(self) -> None:
-        p = HostType(ostype="foo")
-        self.assertEqual(p.as_tuple_string(), "foo-none-none")
-
-    def test_is_methods(self) -> None:
-        p = HostType(ostype="windows")
-        self.assertTrue(p.is_windows())
-        self.assertFalse(p.is_darwin())
-        self.assertFalse(p.is_linux())
-
-        p = HostType(ostype="darwin")
-        self.assertFalse(p.is_windows())
-        self.assertTrue(p.is_darwin())
-        self.assertFalse(p.is_linux())
-
-        p = HostType(ostype="linux")
-        self.assertFalse(p.is_windows())
-        self.assertFalse(p.is_darwin())
-        self.assertTrue(p.is_linux())
diff --git a/build/fbcode_builder/getdeps/test/scratch_test.py b/build/fbcode_builder/getdeps/test/scratch_test.py
deleted file mode 100644
index b57d8b583fe40..0000000000000
--- a/build/fbcode_builder/getdeps/test/scratch_test.py
+++ /dev/null
@@ -1,79 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-import unittest
-
-from ..buildopts import find_existing_win32_subst_for_path
-
-
-class Win32SubstTest(unittest.TestCase):
-    def test_no_existing_subst(self) -> None:
-        self.assertIsNone(
-            find_existing_win32_subst_for_path(
-                r"C:\users\alice\appdata\local\temp\fbcode_builder_getdeps",
-                subst_mapping={},
-            )
-        )
-        self.assertIsNone(
-            find_existing_win32_subst_for_path(
-                r"C:\users\alice\appdata\local\temp\fbcode_builder_getdeps",
-                subst_mapping={"X:\\": r"C:\users\alice\appdata\local\temp\other"},
-            )
-        )
-
-    def test_exact_match_returns_drive_path(self) -> None:
-        self.assertEqual(
-            find_existing_win32_subst_for_path(
-                r"C:\temp\fbcode_builder_getdeps",
-                subst_mapping={"X:\\": r"C:\temp\fbcode_builder_getdeps"},
-            ),
-            "X:\\",
-        )
-        self.assertEqual(
-            find_existing_win32_subst_for_path(
-                r"C:/temp/fbcode_builder_getdeps",
-                subst_mapping={"X:\\": r"C:/temp/fbcode_builder_getdeps"},
-            ),
-            "X:\\",
-        )
-
-    def test_multiple_exact_matches_returns_arbitrary_drive_path(self) -> None:
-        self.assertIn(
-            find_existing_win32_subst_for_path(
-                r"C:\temp\fbcode_builder_getdeps",
-                subst_mapping={
-                    "X:\\": r"C:\temp\fbcode_builder_getdeps",
-                    "Y:\\": r"C:\temp\fbcode_builder_getdeps",
-                    "Z:\\": r"C:\temp\fbcode_builder_getdeps",
-                },
-            ),
-            ("X:\\", "Y:\\", "Z:\\"),
-        )
-
-    def test_drive_letter_is_case_insensitive(self) -> None:
-        self.assertEqual(
-            find_existing_win32_subst_for_path(
-                r"C:\temp\fbcode_builder_getdeps",
-                subst_mapping={"X:\\": r"c:\temp\fbcode_builder_getdeps"},
-            ),
-            "X:\\",
-        )
-
-    def test_path_components_are_case_insensitive(self) -> None:
-        self.assertEqual(
-            find_existing_win32_subst_for_path(
-                r"C:\TEMP\FBCODE_builder_getdeps",
-                subst_mapping={"X:\\": r"C:\temp\fbcode_builder_getdeps"},
-            ),
-            "X:\\",
-        )
-        self.assertEqual(
-            find_existing_win32_subst_for_path(
-                r"C:\temp\fbcode_builder_getdeps",
-                subst_mapping={"X:\\": r"C:\TEMP\FBCODE_builder_getdeps"},
-            ),
-            "X:\\",
-        )
diff --git a/build/fbcode_builder/manifests/CLI11 b/build/fbcode_builder/manifests/CLI11
deleted file mode 100644
index 14cb2332af457..0000000000000
--- a/build/fbcode_builder/manifests/CLI11
+++ /dev/null
@@ -1,14 +0,0 @@
-[manifest]
-name = CLI11
-
-[download]
-url = https://github.com/CLIUtils/CLI11/archive/v2.0.0.tar.gz
-sha256 = 2c672f17bf56e8e6223a3bfb74055a946fa7b1ff376510371902adb9cb0ab6a3
-
-[build]
-builder = cmake
-subdir = CLI11-2.0.0
-
-[cmake.defines]
-CLI11_BUILD_TESTS = OFF
-CLI11_BUILD_EXAMPLES = OFF
diff --git a/build/fbcode_builder/manifests/airstore b/build/fbcode_builder/manifests/airstore
deleted file mode 100644
index 91c38c53cc7f0..0000000000000
--- a/build/fbcode_builder/manifests/airstore
+++ /dev/null
@@ -1,38 +0,0 @@
-[manifest]
-name = airstore
-fbsource_path = fbcode/fair_infra/data/airstore/
-shipit_project = AIRStore
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/fairinternal/AIRStore.git
-
-[build.os=linux]
-builder = cmake
-
-[build.not(os=linux)]
-# We only support Linux
-builder = nop
-
-[dependencies]
-boost
-libcurl
-fizz
-fmt
-folly
-googletest
-libsodium
-libevent
-double-conversion
-proxygen
-wangle
-zstd
-zlib
-xz
-
-[shipit.pathmap]
-fbcode/fair_infra/data/airstore = .
-fbcode/deeplearning/projects/fairstore/cpp = deeplearning/projects/fairstore/cpp
-fbcode/proxygen/lib/utils = proxygen/lib/utils
-
-[shipit.strip]
diff --git a/build/fbcode_builder/manifests/autoconf b/build/fbcode_builder/manifests/autoconf
deleted file mode 100644
index 8c8b883974c9a..0000000000000
--- a/build/fbcode_builder/manifests/autoconf
+++ /dev/null
@@ -1,19 +0,0 @@
-[manifest]
-name = autoconf
-
-[debs]
-autoconf
-
-[homebrew]
-autoconf
-
-[rpms]
-autoconf
-
-[download]
-url = http://ftp.gnu.org/gnu/autoconf/autoconf-2.69.tar.gz
-sha256 = 954bd69b391edc12d6a4a51a2dd1476543da5c6bbf05a95b59dc0dd6fd4c2969
-
-[build]
-builder = autoconf
-subdir = autoconf-2.69
diff --git a/build/fbcode_builder/manifests/automake b/build/fbcode_builder/manifests/automake
deleted file mode 100644
index 37ffb95d21e8b..0000000000000
--- a/build/fbcode_builder/manifests/automake
+++ /dev/null
@@ -1,22 +0,0 @@
-[manifest]
-name = automake
-
-[homebrew]
-automake
-
-[debs]
-automake
-
-[rpms]
-automake
-
-[download]
-url = http://ftp.gnu.org/gnu/automake/automake-1.16.1.tar.gz
-sha256 = 608a97523f97db32f1f5d5615c98ca69326ced2054c9f82e65bade7fc4c9dea8
-
-[build]
-builder = autoconf
-subdir = automake-1.16.1
-
-[dependencies]
-autoconf
diff --git a/build/fbcode_builder/manifests/benchmark b/build/fbcode_builder/manifests/benchmark
deleted file mode 100644
index 25d621184cea2..0000000000000
--- a/build/fbcode_builder/manifests/benchmark
+++ /dev/null
@@ -1,13 +0,0 @@
-[manifest]
-name = benchmark
-
-[download]
-url = https://github.com/google/benchmark/archive/refs/tags/v1.8.0.tar.gz
-sha256 = ea2e94c24ddf6594d15c711c06ccd4486434d9cf3eca954e2af8a20c88f9f172
-
-[build]
-builder = cmake
-subdir = benchmark-1.8.0/
-
-[cmake.defines]
-BENCHMARK_ENABLE_TESTING=OFF
diff --git a/build/fbcode_builder/manifests/blake3 b/build/fbcode_builder/manifests/blake3
deleted file mode 100644
index 27a5509e7c4b0..0000000000000
--- a/build/fbcode_builder/manifests/blake3
+++ /dev/null
@@ -1,11 +0,0 @@
-[manifest]
-name = blake3
-
-[download]
-url = https://github.com/BLAKE3-team/BLAKE3/archive/refs/tags/1.3.3.tar.gz
-sha256 = 27d2bc4ee5945ba75434859521042c949463ee7514ff17aaef328e23ef83fec0
-
-[build]
-builder = cmake
-subdir = BLAKE3-1.3.3/c
-patchfile = blake3_CMakeLists_txt.patch
diff --git a/build/fbcode_builder/manifests/boost b/build/fbcode_builder/manifests/boost
deleted file mode 100644
index 89b4ee4e293bf..0000000000000
--- a/build/fbcode_builder/manifests/boost
+++ /dev/null
@@ -1,110 +0,0 @@
-[manifest]
-name = boost
-
-[download.not(os=windows)]
-url = https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.tar.gz
-sha256 = c0685b68dd44cc46574cce86c4e17c0f611b15e195be9848dfd0769a0a207628
-
-[download.os=windows]
-url = https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.zip
-sha256 = c86bd9d9eef795b4b0d3802279419fde5221922805b073b9bd822edecb1ca28e
-
-[preinstalled.env]
-# Here we list the acceptable versions that cmake needs a hint to find
-BOOST_ROOT_1_69_0
-BOOST_ROOT_1_83_0
-
-[debs]
-libboost-all-dev
-
-[homebrew]
-boost
-# Boost cmake detection on homebrew adds this as requirement: https://github.com/Homebrew/homebrew-core/issues/67427#issuecomment-754187345
-icu4c
-
-[rpms.all(distro=centos_stream,distro_vers=8)]
-boost169
-boost169-math
-boost169-test
-boost169-fiber
-boost169-graph
-boost169-log
-boost169-openmpi
-boost169-timer
-boost169-chrono
-boost169-locale
-boost169-thread
-boost169-atomic
-boost169-random
-boost169-static
-boost169-contract
-boost169-date-time
-boost169-iostreams
-boost169-container
-boost169-coroutine
-boost169-filesystem
-boost169-system
-boost169-stacktrace
-boost169-regex
-boost169-devel
-boost169-context
-boost169-python3-devel
-boost169-type_erasure
-boost169-wave
-boost169-python3
-boost169-serialization
-boost169-program-options
-
-[rpms.not(all(distro=centos_stream,distro_vers=8))]
-boost-devel
-boost-static
-
-[build]
-builder = boost
-job_weight_mib = 512
-
-[b2.args]
---with-atomic
---with-chrono
---with-container
---with-context
---with-contract
---with-coroutine
---with-date_time
---with-exception
---with-fiber
---with-filesystem
---with-graph
---with-graph_parallel
---with-iostreams
---with-locale
---with-log
---with-math
---with-mpi
---with-program_options
---with-python
---with-random
---with-regex
---with-serialization
---with-stacktrace
---with-system
---with-test
---with-thread
---with-timer
---with-type_erasure
-
-[bootstrap.args.os=darwin]
-# Not really gcc, but CI puts a broken clang in the PATH, and saying gcc
-# here selects the correct one from Xcode.
---with-toolset=gcc
-
-[b2.args.os=linux]
-# RHEL hardened gcc is not compatible with PCH
-# https://bugzilla.redhat.com/show_bug.cgi?id=1806545
-pch=off
-
-[b2.args.os=darwin]
-toolset=clang
-
-[b2.args.all(os=windows,fb=on)]
-toolset=msvc-14.2
diff --git a/build/fbcode_builder/manifests/bz2 b/build/fbcode_builder/manifests/bz2
deleted file mode 100644
index af2f357d5dbe8..0000000000000
--- a/build/fbcode_builder/manifests/bz2
+++ /dev/null
@@ -1,30 +0,0 @@
-[manifest]
-name = bz2
-
-[debs]
-libbz2-dev
-
-[homebrew]
-bzip2
-
-[rpms]
-bzip2-devel
-
-[download]
-url = https://sourceware.org/pub/bzip2/bzip2-1.0.8.tar.gz
-sha256 = ab5a03176ee106d3f0fa90e381da478ddae405918153cca248e682cd0c4a2269
-
-[build.not(os=windows)]
-builder = make
-subdir = bzip2-1.0.8
-
-[make.build_args.os=linux]
-# python bz2 support on linux needs dynamic library
--f
-Makefile-libbz2_so
-
-[make.install_args]
-install
-
-[build.os=windows]
-builder = nop
diff --git a/build/fbcode_builder/manifests/cmake b/build/fbcode_builder/manifests/cmake
deleted file mode 100644
index 71548f119cba5..0000000000000
--- a/build/fbcode_builder/manifests/cmake
+++ /dev/null
@@ -1,46 +0,0 @@
-[manifest]
-name = cmake
-
-[homebrew]
-cmake
-
-# 18.04 cmake is too old
-[debs.not(all(distro=ubuntu,distro_vers="18.04"))]
-cmake
-
-[rpms]
-cmake
-
-[dependencies]
-ninja
-
-[download.os=windows]
-url = https://github.com/Kitware/CMake/releases/download/v3.20.2/cmake-3.20.2-windows-x86_64.zip
-sha256 = 15a49e2ab81c1822d75b1b1a92f7863f58e31f6d6aac1c4103eef2b071be3112
-
-[download.os=darwin]
-url = https://github.com/Kitware/CMake/releases/download/v3.20.2/cmake-3.20.2-macos-universal.tar.gz
-sha256 = 0100663380a3bd977b001183cd487412db7aad9de6859927bde97e1e6e44e645
-
-[download.any(os=linux,os=freebsd)]
-url = https://github.com/Kitware/CMake/releases/download/v3.20.2/cmake-3.20.2.tar.gz
-sha256 = aecf6ecb975179eb3bb6a4a50cae192d41e92b9372b02300f9e8f1d5f559544e
-
-[build.os=windows]
-builder = nop
-subdir = cmake-3.20.2-windows-x86_64
-
-[build.os=darwin]
-builder = nop
-subdir = cmake-3.20.2-macos-universal
-
-[install.files.os=darwin]
-CMake.app/Contents/bin = bin
-CMake.app/Contents/share = share
-
-[build.any(os=linux,os=freebsd)]
-builder = cmakebootstrap
-subdir = cmake-3.20.2
-
-[make.install_args.any(os=linux,os=freebsd)]
-install
diff --git a/build/fbcode_builder/manifests/cpptoml b/build/fbcode_builder/manifests/cpptoml
deleted file mode 100644
index c4d6d8d9c5656..0000000000000
--- a/build/fbcode_builder/manifests/cpptoml
+++ /dev/null
@@ -1,16 +0,0 @@
-[manifest]
-name = cpptoml
-
-[homebrew]
-cpptoml
-
-[download]
-url = https://github.com/chadaustin/cpptoml/archive/refs/tags/v0.1.2.tar.gz
-sha256 = beda37e94f9746874436c8090c045fd80ae6f8a51f7c668c932a2b110a4fc277
-
-[build]
-builder = cmake
-subdir = cpptoml-0.1.2
-
-[cmake.defines.os=freebsd]
-ENABLE_LIBCXX=NO
diff --git a/build/fbcode_builder/manifests/date b/build/fbcode_builder/manifests/date
deleted file mode 100644
index 8a4e255c88fc0..0000000000000
--- a/build/fbcode_builder/manifests/date
+++ /dev/null
@@ -1,10 +0,0 @@
-[manifest]
-name = date
-
-[download]
-url = https://github.com/HowardHinnant/date/archive/refs/tags/v3.0.1.tar.gz
-sha256 = 7a390f200f0ccd207e8cff6757e04817c1a0aec3e327b006b7eb451c57ee3538
-
-[build]
-builder = cmake
-subdir = date-3.0.1
diff --git a/build/fbcode_builder/manifests/delos_core b/build/fbcode_builder/manifests/delos_core
deleted file mode 100644
index 1de6c3342df48..0000000000000
--- a/build/fbcode_builder/manifests/delos_core
+++ /dev/null
@@ -1,25 +0,0 @@
-[manifest]
-name = delos_core
-fbsource_path = fbcode/delos_core
-shipit_project = delos_core
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebookincubator/delos_core.git
-
-[build.os=linux]
-builder = cmake
-
-[build.not(os=linux)]
-builder = nop
-
-[dependencies]
-glog
-googletest
-folly
-fbthrift
-fb303
-re2
-
-[shipit.pathmap]
-fbcode/delos_core = .
diff --git a/build/fbcode_builder/manifests/double-conversion b/build/fbcode_builder/manifests/double-conversion
deleted file mode 100644
index 2d7265e8d39c8..0000000000000
--- a/build/fbcode_builder/manifests/double-conversion
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = double-conversion
-
-[download]
-url = https://github.com/google/double-conversion/archive/v3.1.4.tar.gz
-sha256 = 95004b65e43fefc6100f337a25da27bb99b9ef8d4071a36a33b5e83eb1f82021
-
-[homebrew]
-double-conversion
-
-[debs]
-libdouble-conversion-dev
-
-[rpms]
-double-conversion
-double-conversion-devel
-
-[build]
-builder = cmake
-subdir = double-conversion-3.1.4
diff --git a/build/fbcode_builder/manifests/eden b/build/fbcode_builder/manifests/eden
deleted file mode 100644
index 4c32bf698a1c0..0000000000000
--- a/build/fbcode_builder/manifests/eden
+++ /dev/null
@@ -1,112 +0,0 @@
-[manifest]
-name = eden
-fbsource_path = fbcode/eden
-shipit_project = eden
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/sapling.git
-
-[github.actions]
-run_tests = off
-
-[sandcastle]
-run_tests = off
-
-[build]
-builder = cmake
-
-[dependencies]
-blake3
-googletest
-folly
-fbthrift
-fb303
-cpptoml
-rocksdb
-re2
-libgit2
-pexpect
-python-toml
-python-filelock
-edencommon
-rust-shed
-
-[dependencies.fbsource=on]
-rust
-
-# macOS ships with sqlite3, and some of the core system
-# frameworks require that that version be linked rather
-# than the one we might build for ourselves here, so we
-# skip building it on macos.
-[dependencies.not(os=darwin)]
-sqlite3
-
-[dependencies.os=darwin]
-osxfuse
-
-[dependencies.not(os=windows)]
-# TODO: teach getdeps to compile curl on Windows.
-# Enabling curl on Windows requires us to find a way to compile libcurl with
-# msvc.
-libcurl
-# Added so that OSS doesn't see system "python" which is python 2 on darwin and some linux
-python
-
-[shipit.pathmap.fb=on]
-# for internal builds that use getdeps
-fbcode/fb303 = fb303
-fbcode/common/rust/fbwhoami = common/rust/fbwhoami
-fbcode/common/rust/shed = common/rust/shed
-fbcode/thrift/lib/rust = thrift/lib/rust
-
-[shipit.pathmap]
-# Map hostcaps for now as eden C++ includes its .h. Rust-shed should install it
-fbcode/common/rust/shed/hostcaps = common/rust/shed/hostcaps
-fbcode/configerator/structs/scm/hg = configerator/structs/scm/hg
-fbcode/eden/oss = .
-fbcode/eden = eden
-fbcode/tools/lfs = tools/lfs
-
-[shipit.pathmap.fb=off]
-fbcode/eden/fs/public_autocargo = eden/fs
-fbcode/eden/scm/public_autocargo = eden/scm
-fbcode/common/rust/shed/hostcaps/public_cargo = common/rust/shed/hostcaps
-fbcode/configerator/structs/scm/hg/public_autocargo = configerator/structs/scm/hg
-
-[shipit.strip]
-^fbcode/eden/addons/.*$
-^fbcode/eden/fs/eden-config\.h$
-^fbcode/eden/fs/py/eden/config\.py$
-^fbcode/eden/hg-server/.*$
-^fbcode/eden/mononoke/(?!lfs_protocol)
-^fbcode/eden/scm/build/.*$
-^fbcode/eden/scm/lib/third-party/rust/.*/Cargo.toml$
-^fbcode/eden/website/.*$
-^fbcode/eden/.*/\.cargo/.*$
-/Cargo\.lock$
-\.pyc$
-
-[shipit.strip.fb=off]
-^fbcode/common/rust/shed(?!/public_autocargo).*/Cargo\.toml$
-^fbcode/configerator/structs/scm/hg(?!/public_autocargo).*/Cargo\.toml$
-^fbcode/eden/fs(?!/public_autocargo).*/Cargo\.toml$
-^fbcode/eden/scm(?!/public_autocargo|/saplingnative).*/Cargo\.toml$
-^.*/facebook/.*$
-^.*/fb/.*$
-
-[cmake.defines.all(fb=on,os=windows)]
-ENABLE_GIT=OFF
-INSTALL_PYTHON_LIB=ON
-
-[cmake.defines.all(not(fb=on),os=windows)]
-ENABLE_GIT=OFF
-
-[cmake.defines.fbsource=on]
-USE_CARGO_VENDOR=ON
-
-[cmake.defines.fb=on]
-IS_FB_BUILD=ON
-
-[depends.environment]
-EDEN_VERSION_OVERRIDE
diff --git a/build/fbcode_builder/manifests/edencommon b/build/fbcode_builder/manifests/edencommon
deleted file mode 100644
index 772c9407ed9f2..0000000000000
--- a/build/fbcode_builder/manifests/edencommon
+++ /dev/null
@@ -1,30 +0,0 @@
-[manifest]
-name = edencommon
-fbsource_path = fbcode/eden/common
-shipit_project = edencommon
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebookexperimental/edencommon.git
-
-[build]
-builder = cmake
-
-[dependencies]
-fmt
-folly
-gflags
-glog
-
-[cmake.defines.test=on]
-BUILD_TESTS=ON
-
-[cmake.defines.test=off]
-BUILD_TESTS=OFF
-
-[shipit.pathmap]
-fbcode/eden/common = eden/common
-fbcode/eden/common/oss = .
-
-[shipit.strip]
-@README.facebook@
diff --git a/build/fbcode_builder/manifests/exprtk b/build/fbcode_builder/manifests/exprtk
deleted file mode 100644
index c0dfc1afbf67f..0000000000000
--- a/build/fbcode_builder/manifests/exprtk
+++ /dev/null
@@ -1,15 +0,0 @@
-[manifest]
-name = exprtk
-
-[download]
-url = https://github.com/ArashPartow/exprtk/archive/refs/tags/0.0.1.tar.gz
-sha256 = fb72791c88ae3b3426e14fdad630027715682584daf56b973569718c56e33f28
-
-[build.not(os=windows)]
-builder = nop
-subdir = exprtk-0.0.1
-
-[install.files]
-exprtk.hpp = exprtk.hpp
-
-[dependencies]
diff --git a/build/fbcode_builder/manifests/f4d b/build/fbcode_builder/manifests/f4d
deleted file mode 100644
index 2f3db2595acbe..0000000000000
--- a/build/fbcode_builder/manifests/f4d
+++ /dev/null
@@ -1,30 +0,0 @@
-[manifest]
-name = f4d
-fbsource_path = fbcode/f4d
-shipit_project = f4d
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebookexternal/f4d.git
-rev = master
-
-[build.os=windows]
-builder = nop
-
-[build.not(os=windows)]
-builder = cmake
-
-[dependencies]
-double-conversion
-folly
-glog
-googletest
-boost
-protobuf
-lzo
-libicu
-re2
-
-[shipit.pathmap]
-fbcode/f4d/public_tld = .
-fbcode/f4d = f4d
diff --git a/build/fbcode_builder/manifests/fatal b/build/fbcode_builder/manifests/fatal
deleted file mode 100644
index b516d765f7ed7..0000000000000
--- a/build/fbcode_builder/manifests/fatal
+++ /dev/null
@@ -1,24 +0,0 @@
-[manifest]
-name = fatal
-fbsource_path = fbcode/fatal
-shipit_project = fatal
-
-[git]
-repo_url = https://github.com/facebook/fatal.git
-
-[shipit.pathmap]
-fbcode/fatal = fatal
-fbcode/fatal/public_tld = .
-
-[build]
-builder = nop
-subdir = .
-
-[install.files]
-fatal/portability.h = fatal/portability.h
-fatal/preprocessor.h = fatal/preprocessor.h
-fatal/container = fatal/container
-fatal/functional = fatal/functional
-fatal/math = fatal/math
-fatal/string = fatal/string
-fatal/type = fatal/type
diff --git a/build/fbcode_builder/manifests/fb303 b/build/fbcode_builder/manifests/fb303
deleted file mode 100644
index ad398a8c281f4..0000000000000
--- a/build/fbcode_builder/manifests/fb303
+++ /dev/null
@@ -1,37 +0,0 @@
-[manifest]
-name = fb303
-fbsource_path = fbcode/fb303
-shipit_project = fb303
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/fb303.git
-
-[cargo]
-cargo_config_file = source/fb303/thrift/.cargo/config.toml
-
-[crate.pathmap]
-fb303_core = fb303/thrift
-
-[build]
-builder = cmake
-
-[dependencies]
-folly
-gflags
-glog
-fbthrift
-
-[cmake.defines.test=on]
-BUILD_TESTS=ON
-
-[cmake.defines.test=off]
-BUILD_TESTS=OFF
-
-[shipit.pathmap]
-fbcode/fb303/github = .
-fbcode/fb303/public_autocargo = fb303
-fbcode/fb303 = fb303
-
-[shipit.strip]
-^fbcode/fb303/(?!public_autocargo).+/Cargo\.toml$
diff --git a/build/fbcode_builder/manifests/fb303-source b/build/fbcode_builder/manifests/fb303-source
deleted file mode 100644
index d62ce3b003254..0000000000000
--- a/build/fbcode_builder/manifests/fb303-source
+++ /dev/null
@@ -1,19 +0,0 @@
-[manifest]
-name = fb303-source
-fbsource_path = fbcode/fb303
-shipit_project = fb303
-shipit_fbcode_builder = false
-
-[git]
-repo_url = https://github.com/facebook/fb303.git
-
-[build]
-builder = nop
-
-[shipit.pathmap]
-fbcode/fb303/github = .
-fbcode/fb303/public_autocargo = fb303
-fbcode/fb303 = fb303
-
-[shipit.strip]
-^fbcode/fb303/(?!public_autocargo).+/Cargo\.toml$
diff --git a/build/fbcode_builder/manifests/fboss b/build/fbcode_builder/manifests/fboss
deleted file mode 100644
index 8bcd1cb110c97..0000000000000
--- a/build/fbcode_builder/manifests/fboss
+++ /dev/null
@@ -1,48 +0,0 @@
-[manifest]
-name = fboss
-fbsource_path = fbcode/fboss
-shipit_project = fboss
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/fboss.git
-
-[build.os=linux]
-builder = cmake
-# fboss files take a lot of RAM to compile.
-job_weight_mib = 3072
-
-[build.not(os=linux)]
-builder = nop
-
-[dependencies]
-folly
-fb303
-wangle
-fizz
-fmt
-libsodium
-googletest
-zstd
-fatal
-fbthrift
-iproute2
-libusb
-libcurl
-libnl
-libsai
-re2
-python
-yaml-cpp
-libyaml
-CLI11
-exprtk
-nlohmann-json
-
-[shipit.pathmap]
-fbcode/fboss/github = .
-fbcode/fboss/common = common
-fbcode/fboss = fboss
-
-[sandcastle]
-run_tests = off
diff --git a/build/fbcode_builder/manifests/fbthrift b/build/fbcode_builder/manifests/fbthrift
deleted file mode 100644
index 3d852d8d1c56b..0000000000000
--- a/build/fbcode_builder/manifests/fbthrift
+++ /dev/null
@@ -1,47 +0,0 @@
-[manifest]
-name = fbthrift
-fbsource_path = fbcode/thrift
-shipit_project = fbthrift
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/fbthrift.git
-
-[cargo]
-cargo_config_file =  source/thrift/lib/rust/.cargo/config.toml
-
-[crate.pathmap]
-fbthrift = thrift/lib/rust
-
-[build]
-builder = cmake
-job_weight_mib = 2048
-
-[dependencies]
-fizz
-fmt
-folly
-googletest
-libsodium
-python-six
-wangle
-zstd
-mvfst
-# Thrift also depends on openssl but since the latter requires a platform-
-# specific configuration we rely on the folly manifest to provide this
-# dependency to avoid duplication.
-
-[dependencies.os=linux]
-# python doesn't build on Windows yet and this causes python3 shebangs to
-# expand to a non-portable path on macOS
-python
-
-[shipit.pathmap]
-fbcode/thrift/public_tld = .
-fbcode/thrift = thrift
-
-[shipit.strip]
-^fbcode/thrift/thrift-config\.h$
-^fbcode/thrift/perf/canary.py$
-^fbcode/thrift/perf/loadtest.py$
-^fbcode/thrift/.castle/.*
diff --git a/build/fbcode_builder/manifests/fbthrift-source b/build/fbcode_builder/manifests/fbthrift-source
deleted file mode 100644
index 7af0d6ddac0e3..0000000000000
--- a/build/fbcode_builder/manifests/fbthrift-source
+++ /dev/null
@@ -1,21 +0,0 @@
-[manifest]
-name = fbthrift-source
-fbsource_path = fbcode/thrift
-shipit_project = fbthrift
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/fbthrift.git
-
-[build]
-builder = nop
-
-[shipit.pathmap]
-fbcode/thrift/public_tld = .
-fbcode/thrift = thrift
-
-[shipit.strip]
-^fbcode/thrift/thrift-config\.h$
-^fbcode/thrift/perf/canary.py$
-^fbcode/thrift/perf/loadtest.py$
-^fbcode/thrift/.castle/.*
diff --git a/build/fbcode_builder/manifests/fbzmq b/build/fbcode_builder/manifests/fbzmq
deleted file mode 100644
index 5739016c84ac6..0000000000000
--- a/build/fbcode_builder/manifests/fbzmq
+++ /dev/null
@@ -1,29 +0,0 @@
-[manifest]
-name = fbzmq
-fbsource_path = facebook/fbzmq
-shipit_project = fbzmq
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/fbzmq.git
-
-[build.os=linux]
-builder = cmake
-
-[build.not(os=linux)]
-# boost.fiber is required and that is not available on macos.
-# libzmq doesn't currently build on windows.
-builder = nop
-
-[dependencies]
-boost
-folly
-fbthrift
-googletest
-libzmq
-
-[shipit.pathmap]
-fbcode/fbzmq = fbzmq
-fbcode/fbzmq/public_tld = .
-
-[shipit.strip]
diff --git a/build/fbcode_builder/manifests/fizz b/build/fbcode_builder/manifests/fizz
deleted file mode 100644
index 15e14ec608b3c..0000000000000
--- a/build/fbcode_builder/manifests/fizz
+++ /dev/null
@@ -1,37 +0,0 @@
-[manifest]
-name = fizz
-fbsource_path = fbcode/fizz
-shipit_project = fizz
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebookincubator/fizz.git
-
-[build]
-builder = cmake
-subdir = fizz
-
-[cmake.defines]
-BUILD_EXAMPLES = OFF
-
-[cmake.defines.test=on]
-BUILD_TESTS = ON
-
-[cmake.defines.all(os=windows, test=on)]
-BUILD_TESTS = OFF
-
-[cmake.defines.test=off]
-BUILD_TESTS = OFF
-
-[dependencies]
-folly
-libsodium
-zlib
-zstd
-
-[dependencies.all(test=on, not(os=windows))]
-googletest
-
-[shipit.pathmap]
-fbcode/fizz/public_tld = .
-fbcode/fizz = fizz
diff --git a/build/fbcode_builder/manifests/fmt b/build/fbcode_builder/manifests/fmt
deleted file mode 100644
index eb79496e3d991..0000000000000
--- a/build/fbcode_builder/manifests/fmt
+++ /dev/null
@@ -1,14 +0,0 @@
-[manifest]
-name = fmt
-
-[download]
-url = https://github.com/fmtlib/fmt/archive/refs/tags/9.1.0.tar.gz
-sha256 = 5dea48d1fcddc3ec571ce2058e13910a0d4a6bab4cc09a809d8b1dd1c88ae6f2
-
-[build]
-builder = cmake
-subdir = fmt-9.1.0
-
-[cmake.defines]
-FMT_TEST = OFF
-FMT_DOC = OFF
diff --git a/build/fbcode_builder/manifests/folly b/build/fbcode_builder/manifests/folly
deleted file mode 100644
index 3c17c184e053f..0000000000000
--- a/build/fbcode_builder/manifests/folly
+++ /dev/null
@@ -1,71 +0,0 @@
-[manifest]
-name = folly
-fbsource_path = fbcode/folly
-shipit_project = folly
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/folly.git
-
-[build]
-builder = cmake
-job_weight_mib = 1024
-
-[dependencies]
-gflags
-glog
-googletest
-boost
-libevent
-libsodium
-double-conversion
-fmt
-lz4
-snappy
-zstd
-# no openssl or zlib in the linux case, why?
-# these are usually installed on the system
-# and are the easiest system deps to pull in.
-# In the future we want to be able to express
-# that a system dep is sufficient in the manifest
-# for eg: openssl and zlib, but for now we don't
-# have it.
-
-# macOS doesn't expose the openssl api so we need
-# to build our own.
-[dependencies.os=darwin]
-openssl
-
-# Windows has neither openssl nor zlib, so we get
-# to provide both
-[dependencies.os=windows]
-openssl
-zlib
-
-# xz depends on autoconf which does not build on
-# Windows
-[dependencies.not(os=windows)]
-xz
-
-[shipit.pathmap]
-fbcode/folly/public_tld = .
-fbcode/folly = folly
-
-[shipit.strip]
-^fbcode/folly/folly-config\.h$
-^fbcode/folly/public_tld/build/facebook_.*
-
-[cmake.defines]
-BUILD_SHARED_LIBS=OFF
-BOOST_LINK_STATIC=ON
-
-[cmake.defines.os=freebsd]
-LIBDWARF_FOUND=NO
-
-[cmake.defines.test=on]
-BUILD_TESTS=ON
-BUILD_BENCHMARKS=OFF
-
-[cmake.defines.test=off]
-BUILD_TESTS=OFF
-BUILD_BENCHMARKS=OFF
diff --git a/build/fbcode_builder/manifests/gflags b/build/fbcode_builder/manifests/gflags
deleted file mode 100644
index a2704180eb3b5..0000000000000
--- a/build/fbcode_builder/manifests/gflags
+++ /dev/null
@@ -1,22 +0,0 @@
-[manifest]
-name = gflags
-
-[download]
-url = https://github.com/gflags/gflags/archive/v2.2.2.tar.gz
-sha256 = 34af2f15cf7367513b352bdcd2493ab14ce43692d2dcd9dfc499492966c64dcf
-
-[build]
-builder = cmake
-subdir = gflags-2.2.2
-
-[cmake.defines]
-BUILD_SHARED_LIBS = ON
-BUILD_STATIC_LIBS = ON
-#BUILD_gflags_nothreads_LIB = OFF
-BUILD_gflags_LIB = ON
-
-[debs]
-libgflags-dev
-
-[rpms]
-gflags-devel
diff --git a/build/fbcode_builder/manifests/git-lfs b/build/fbcode_builder/manifests/git-lfs
deleted file mode 100644
index 38a5e6aeba581..0000000000000
--- a/build/fbcode_builder/manifests/git-lfs
+++ /dev/null
@@ -1,12 +0,0 @@
-[manifest]
-name = git-lfs
-
-[download.os=linux]
-url = https://github.com/git-lfs/git-lfs/releases/download/v2.9.1/git-lfs-linux-amd64-v2.9.1.tar.gz
-sha256 = 2a8e60cf51ec45aa0f4332aa0521d60ec75c76e485d13ebaeea915b9d70ea466
-
-[build]
-builder = nop
-
-[install.files]
-git-lfs = bin/git-lfs
diff --git a/build/fbcode_builder/manifests/glog b/build/fbcode_builder/manifests/glog
deleted file mode 100644
index 946d3e359bc53..0000000000000
--- a/build/fbcode_builder/manifests/glog
+++ /dev/null
@@ -1,28 +0,0 @@
-[manifest]
-name = glog
-
-[download]
-url = https://github.com/google/glog/archive/v0.5.0.tar.gz
-sha256 = eede71f28371bf39aa69b45de23b329d37214016e2055269b3b5e7cfd40b59f5
-
-[build]
-builder = cmake
-subdir = glog-0.5.0
-
-[dependencies]
-gflags
-
-[cmake.defines]
-BUILD_SHARED_LIBS=ON
-BUILD_TESTING=NO
-WITH_PKGCONFIG=ON
-
-[cmake.defines.os=freebsd]
-HAVE_TR1_UNORDERED_MAP=OFF
-HAVE_TR1_UNORDERED_SET=OFF
-
-[debs]
-libgoogle-glog-dev
-
-[rpms]
-glog-devel
diff --git a/build/fbcode_builder/manifests/gnu-bash b/build/fbcode_builder/manifests/gnu-bash
deleted file mode 100644
index 89da77ca2b70b..0000000000000
--- a/build/fbcode_builder/manifests/gnu-bash
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = gnu-bash
-
-[download.os=darwin]
-url = https://ftp.gnu.org/gnu/bash/bash-5.1-rc1.tar.gz
-sha256 = 0b2684eb1990329d499c96decfe2459f3e150deb915b0a9d03cf1be692b1d6d3
-
-[build.os=darwin]
-# The buildin FreeBSD bash on OSX is both outdated and incompatible with the
-# modern GNU bash, so for the sake of being cross-platform friendly this
-# manifest provides GNU bash.
-# NOTE: This is the 5.1-rc1 version, which is almost the same as what Homebrew
-# uses (Homebrew installs 5.0 with the 18 patches that in fact make the 5.1-rc1
-# version).
-builder = autoconf
-subdir = bash-5.1-rc1
-build_in_src_dir = true
-
-[build.not(os=darwin)]
-builder = nop
diff --git a/build/fbcode_builder/manifests/gnu-coreutils b/build/fbcode_builder/manifests/gnu-coreutils
deleted file mode 100644
index 1ab4d9d4a5a5b..0000000000000
--- a/build/fbcode_builder/manifests/gnu-coreutils
+++ /dev/null
@@ -1,15 +0,0 @@
-[manifest]
-name = gnu-coreutils
-
-[download.os=darwin]
-url = https://ftp.gnu.org/gnu/coreutils/coreutils-8.32.tar.gz
-sha256 = d5ab07435a74058ab69a2007e838be4f6a90b5635d812c2e26671e3972fca1b8
-
-[build.os=darwin]
-# The buildin FreeBSD version incompatible with the GNU one, so for the sake of
-# being cross-platform friendly this manifest provides the GNU version.
-builder = autoconf
-subdir = coreutils-8.32
-
-[build.not(os=darwin)]
-builder = nop
diff --git a/build/fbcode_builder/manifests/gnu-grep b/build/fbcode_builder/manifests/gnu-grep
deleted file mode 100644
index e6a163d37a84f..0000000000000
--- a/build/fbcode_builder/manifests/gnu-grep
+++ /dev/null
@@ -1,15 +0,0 @@
-[manifest]
-name = gnu-grep
-
-[download.os=darwin]
-url = https://ftp.gnu.org/gnu/grep/grep-3.5.tar.gz
-sha256 = 9897220992a8fd38a80b70731462defa95f7ff2709b235fb54864ddd011141dd
-
-[build.os=darwin]
-# The buildin FreeBSD version incompatible with the GNU one, so for the sake of
-# being cross-platform friendly this manifest provides the GNU version.
-builder = autoconf
-subdir = grep-3.5
-
-[build.not(os=darwin)]
-builder = nop
diff --git a/build/fbcode_builder/manifests/gnu-sed b/build/fbcode_builder/manifests/gnu-sed
deleted file mode 100644
index 9b458df6ef987..0000000000000
--- a/build/fbcode_builder/manifests/gnu-sed
+++ /dev/null
@@ -1,15 +0,0 @@
-[manifest]
-name = gnu-sed
-
-[download.os=darwin]
-url = https://ftp.gnu.org/gnu/sed/sed-4.8.tar.gz
-sha256 = 53cf3e14c71f3a149f29d13a0da64120b3c1d3334fba39c4af3e520be053982a
-
-[build.os=darwin]
-# The buildin FreeBSD version incompatible with the GNU one, so for the sake of
-# being cross-platform friendly this manifest provides the GNU version.
-builder = autoconf
-subdir = sed-4.8
-
-[build.not(os=darwin)]
-builder = nop
diff --git a/build/fbcode_builder/manifests/googletest b/build/fbcode_builder/manifests/googletest
deleted file mode 100644
index 90b05c635fbce..0000000000000
--- a/build/fbcode_builder/manifests/googletest
+++ /dev/null
@@ -1,23 +0,0 @@
-[manifest]
-name = googletest
-
-[download]
-url = https://github.com/google/googletest/archive/refs/tags/release-1.12.1.tar.gz
-sha256 = 81964fe578e9bd7c94dfdb09c8e4d6e6759e19967e397dbea48d1c10e45d0df2
-
-[build]
-builder = cmake
-subdir = googletest-release-1.12.1
-
-[cmake.defines]
-# Everything else defaults to the shared runtime, so tell gtest that
-# it should not use its choice of the static runtime
-gtest_force_shared_crt=ON
-
-[cmake.defines.os=windows]
-BUILD_SHARED_LIBS=ON
-
-# packaged googletest is too old
-[debs.not(all(distro=ubuntu,any(distro_vers="18.04",distro_vers="20.04",distro_vers="22.04")))]
-libgtest-dev
-libgmock-dev
diff --git a/build/fbcode_builder/manifests/googletest_1_8 b/build/fbcode_builder/manifests/googletest_1_8
deleted file mode 100644
index 76c0ce51f9eb2..0000000000000
--- a/build/fbcode_builder/manifests/googletest_1_8
+++ /dev/null
@@ -1,18 +0,0 @@
-[manifest]
-name = googletest_1_8
-
-[download]
-url = https://github.com/google/googletest/archive/release-1.8.0.tar.gz
-sha256 = 58a6f4277ca2bc8565222b3bbd58a177609e9c488e8a72649359ba51450db7d8
-
-[build]
-builder = cmake
-subdir = googletest-release-1.8.0
-
-[cmake.defines]
-# Everything else defaults to the shared runtime, so tell gtest that
-# it should not use its choice of the static runtime
-gtest_force_shared_crt=ON
-
-[cmake.defines.os=windows]
-BUILD_SHARED_LIBS=ON
diff --git a/build/fbcode_builder/manifests/gperf b/build/fbcode_builder/manifests/gperf
deleted file mode 100644
index 13d7a890fdede..0000000000000
--- a/build/fbcode_builder/manifests/gperf
+++ /dev/null
@@ -1,14 +0,0 @@
-[manifest]
-name = gperf
-
-[download]
-url = http://ftp.gnu.org/pub/gnu/gperf/gperf-3.1.tar.gz
-sha256 = 588546b945bba4b70b6a3a616e80b4ab466e3f33024a352fc2198112cdbb3ae2
-
-[build.not(os=windows)]
-builder = autoconf
-subdir = gperf-3.1
-
-[build.os=windows]
-builder = nop
-
diff --git a/build/fbcode_builder/manifests/iproute2 b/build/fbcode_builder/manifests/iproute2
deleted file mode 100644
index 6fb7f77ed9c2e..0000000000000
--- a/build/fbcode_builder/manifests/iproute2
+++ /dev/null
@@ -1,13 +0,0 @@
-[manifest]
-name = iproute2
-
-[download]
-url = https://mirrors.edge.kernel.org/pub/linux/utils/net/iproute2/iproute2-4.12.0.tar.gz
-sha256 = 46612a1e2d01bb31932557bccdb1b8618cae9a439dfffc08ef35ed8e197f14ce
-
-[build.os=linux]
-builder = iproute2
-subdir = iproute2-4.12.0
-
-[build.not(os=linux)]
-builder = nop
diff --git a/build/fbcode_builder/manifests/jq b/build/fbcode_builder/manifests/jq
deleted file mode 100644
index 231818f343e97..0000000000000
--- a/build/fbcode_builder/manifests/jq
+++ /dev/null
@@ -1,24 +0,0 @@
-[manifest]
-name = jq
-
-[rpms]
-jq
-
-[debs]
-jq
-
-[download.not(os=windows)]
-url = https://github.com/stedolan/jq/releases/download/jq-1.5/jq-1.5.tar.gz
-sha256 = c4d2bfec6436341113419debf479d833692cc5cdab7eb0326b5a4d4fbe9f493c
-
-[build.not(os=windows)]
-builder = autoconf
-subdir = jq-1.5
-
-[build.os=windows]
-builder = nop
-
-[autoconf.args]
-# This argument turns off some developers tool and it is recommended in jq's
-# README
---disable-maintainer-mode
diff --git a/build/fbcode_builder/manifests/katran b/build/fbcode_builder/manifests/katran
deleted file mode 100644
index c4f2c74f40f5a..0000000000000
--- a/build/fbcode_builder/manifests/katran
+++ /dev/null
@@ -1,41 +0,0 @@
-[manifest]
-name = katran
-fbsource_path = fbcode/katran
-shipit_project = katran
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebookincubator/katran.git
-
-[build.not(os=linux)]
-builder = nop
-
-[build.os=linux]
-builder = cmake
-subdir = .
-
-[cmake.defines.test=on]
-BUILD_TESTS=ON
-
-[cmake.defines.test=off]
-BUILD_TESTS=OFF
-
-[dependencies]
-folly
-fizz
-libbpf
-libmnl
-zlib
-googletest
-fmt
-
-[debs]
-libssl-dev
-
-[shipit.pathmap]
-fbcode/katran/public_root = .
-fbcode/katran = katran
-
-[shipit.strip]
-^fbcode/katran/facebook
-^fbcode/katran/OSS_SYNC
diff --git a/build/fbcode_builder/manifests/libbpf b/build/fbcode_builder/manifests/libbpf
deleted file mode 100644
index 9ab3a26bee069..0000000000000
--- a/build/fbcode_builder/manifests/libbpf
+++ /dev/null
@@ -1,26 +0,0 @@
-[manifest]
-name = libbpf
-
-[download]
-url = https://github.com/libbpf/libbpf/archive/refs/tags/v0.7.0.tar.gz
-sha256 = 5083588ce5a3a620e395ee1e596af77b4ec5771ffc71cff2af49dfee38c06361
-
-# BPF only builds on linux, so make it a NOP on other platforms
-[build.not(os=linux)]
-builder = nop
-
-[build.os=linux]
-builder = make
-subdir = libbpf-0.7.0/src
-
-[make.build_args]
-BUILD_STATIC_ONLY=y
-
-# libbpf-0.3 requires uapi headers >= 5.8
-[make.install_args]
-install
-install_uapi_headers
-BUILD_STATIC_ONLY=y
-
-[dependencies]
-libelf
diff --git a/build/fbcode_builder/manifests/libbpf_0_2_0_beta b/build/fbcode_builder/manifests/libbpf_0_2_0_beta
deleted file mode 100644
index 072639817d769..0000000000000
--- a/build/fbcode_builder/manifests/libbpf_0_2_0_beta
+++ /dev/null
@@ -1,26 +0,0 @@
-[manifest]
-name = libbpf_0_2_0_beta
-
-[download]
-url = https://github.com/libbpf/libbpf/archive/b6dd2f2.tar.gz
-sha256 = 8db9dca90f5c445ef2362e3c6a00f3d6c4bf36e8782f8e27704109c78e541497
-
-# BPF only builds on linux, so make it a NOP on other platforms
-[build.not(os=linux)]
-builder = nop
-
-[build.os=linux]
-builder = make
-subdir = libbpf-b6dd2f2b7df4d3bd35d64aaf521d9ad18d766f53/src
-
-[make.build_args]
-BUILD_STATIC_ONLY=y
-
-# libbpf now requires uapi headers >= 5.8
-[make.install_args]
-install
-install_uapi_headers
-BUILD_STATIC_ONLY=y
-
-[dependencies]
-libelf
diff --git a/build/fbcode_builder/manifests/libcurl b/build/fbcode_builder/manifests/libcurl
deleted file mode 100644
index 466b4497c35d0..0000000000000
--- a/build/fbcode_builder/manifests/libcurl
+++ /dev/null
@@ -1,39 +0,0 @@
-[manifest]
-name = libcurl
-
-[rpms]
-libcurl-devel
-libcurl
-
-[debs]
-libcurl4-openssl-dev
-
-[download]
-url = https://curl.haxx.se/download/curl-7.65.1.tar.gz
-sha256 = 821aeb78421375f70e55381c9ad2474bf279fc454b791b7e95fc83562951c690
-
-[dependencies]
-nghttp2
-
-# We use system OpenSSL on Linux (see folly's manifest for details)
-[dependencies.not(os=linux)]
-openssl
-
-[build.not(os=windows)]
-builder = autoconf
-subdir = curl-7.65.1
-
-[autoconf.args]
-# fboss (which added the libcurl dep) doesn't need ldap so it is disabled here.
-# if someone in the future wants to add ldap for something else, it won't hurt
-# fboss. However, that would require adding an ldap manifest.
-#
-# For the same reason, we disable libssh2 and libidn2 which aren't really used
-# but would require adding manifests if we don't disable them.
---disable-ldap
---without-libssh2
---without-libidn2
-
-[build.os=windows]
-builder = cmake
-subdir = curl-7.65.1
diff --git a/build/fbcode_builder/manifests/libelf b/build/fbcode_builder/manifests/libelf
deleted file mode 100644
index a46aab8796eaa..0000000000000
--- a/build/fbcode_builder/manifests/libelf
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = libelf
-
-[rpms]
-elfutils-libelf-devel-static
-
-[debs]
-libelf-dev
-
-[download]
-url = https://ftp.osuosl.org/pub/blfs/conglomeration/libelf/libelf-0.8.13.tar.gz
-sha256 = 591a9b4ec81c1f2042a97aa60564e0cb79d041c52faa7416acb38bc95bd2c76d
-
-# libelf only makes sense on linux, so make it a NOP on other platforms
-[build.not(os=linux)]
-builder = nop
-
-[build.os=linux]
-builder = autoconf
-subdir = libelf-0.8.13
diff --git a/build/fbcode_builder/manifests/libevent b/build/fbcode_builder/manifests/libevent
deleted file mode 100644
index 1c073333fc826..0000000000000
--- a/build/fbcode_builder/manifests/libevent
+++ /dev/null
@@ -1,38 +0,0 @@
-[manifest]
-name = libevent
-
-[debs]
-libevent-dev
-
-[homebrew]
-libevent
-
-[rpms]
-libevent-devel
-
-# Note that the CMakeLists.txt file is present only in
-# git repo and not in the release tarball, so take care
-# to use the github generated source tarball rather than
-# the explicitly uploaded source tarball
-[download]
-url = https://github.com/libevent/libevent/releases/download/release-2.1.12-stable/libevent-2.1.12-stable.tar.gz
-sha256 = 92e6de1be9ec176428fd2367677e61ceffc2ee1cb119035037a27d346b0403bb
-
-[build]
-builder = cmake
-subdir = libevent-2.1.12-stable
-
-[cmake.defines]
-EVENT__DISABLE_TESTS = ON
-EVENT__DISABLE_BENCHMARK = ON
-EVENT__DISABLE_SAMPLES = ON
-EVENT__DISABLE_REGRESS = ON
-
-[cmake.defines.shared_libs=on]
-EVENT__BUILD_SHARED_LIBRARIES = ON
-
-[cmake.defines.os=windows]
-EVENT__LIBRARY_TYPE = STATIC
-
-[dependencies.not(any(os=linux, os=freebsd))]
-openssl
diff --git a/build/fbcode_builder/manifests/libffi b/build/fbcode_builder/manifests/libffi
deleted file mode 100644
index 0511287c28923..0000000000000
--- a/build/fbcode_builder/manifests/libffi
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = libffi
-
-[debs]
-libffi-dev
-
-[homebrew]
-libffi
-
-[rpms]
-libffi-devel
-libffi
-
-[download]
-url = https://github.com/libffi/libffi/releases/download/v3.4.2/libffi-3.4.2.tar.gz
-sha256 = 540fb721619a6aba3bdeef7d940d8e9e0e6d2c193595bc243241b77ff9e93620
-
-[build]
-builder = autoconf
-subdir = libffi-3.4.2
diff --git a/build/fbcode_builder/manifests/libgit2 b/build/fbcode_builder/manifests/libgit2
deleted file mode 100644
index 33e6b506f98f4..0000000000000
--- a/build/fbcode_builder/manifests/libgit2
+++ /dev/null
@@ -1,30 +0,0 @@
-[manifest]
-name = libgit2
-
-[homebrew]
-libgit2
-
-[rpms]
-libgit2-devel
-
-# Ubuntu 18.04 libgit2 has clash with libcurl4-openssl-dev as it depends on
-# libcurl4-gnutls-dev.  Should be ok from 20.04 again
-# There is a description at https://github.com/r-hub/sysreqsdb/issues/77
-[debs.not(all(distro=ubuntu,distro_vers="18.04"))]
-libgit2-dev
-
-[download]
-url = https://github.com/libgit2/libgit2/archive/v0.28.1.tar.gz
-sha256 = 0ca11048795b0d6338f2e57717370208c2c97ad66c6d5eac0c97a8827d13936b
-
-[build]
-builder = cmake
-subdir = libgit2-0.28.1
-
-[cmake.defines]
-# Could turn this on if we also wanted to add a manifest for libssh2
-USE_SSH = OFF
-BUILD_CLAR = OFF
-# Have to build shared to work around annoying problems with cmake
-# mis-parsing the frameworks required to link this on macos :-/
-BUILD_SHARED_LIBS = ON
diff --git a/build/fbcode_builder/manifests/libicu b/build/fbcode_builder/manifests/libicu
deleted file mode 100644
index c1deda503760f..0000000000000
--- a/build/fbcode_builder/manifests/libicu
+++ /dev/null
@@ -1,19 +0,0 @@
-[manifest]
-name = libicu
-
-[rpms]
-libicu-devel
-
-[debs]
-libicu-dev
-
-[download]
-url = https://github.com/unicode-org/icu/releases/download/release-68-2/icu4c-68_2-src.tgz
-sha256 = c79193dee3907a2199b8296a93b52c5cb74332c26f3d167269487680d479d625
-
-[build.not(os=windows)]
-builder = autoconf
-subdir = icu/source
-
-[build.os=windows]
-builder = nop
diff --git a/build/fbcode_builder/manifests/libmnl b/build/fbcode_builder/manifests/libmnl
deleted file mode 100644
index 1f8d609c1392a..0000000000000
--- a/build/fbcode_builder/manifests/libmnl
+++ /dev/null
@@ -1,21 +0,0 @@
-[manifest]
-name = libmnl
-
-[rpms]
-libmnl-devel
-
-# all centos 8 distros are missing this,
-# but its in fedora so may be back in a later version
-[rpms.not(all(any(distro=centos_stream,distro=centos),distro_vers=8))]
-libmnl-static
-
-[debs]
-libmnl-dev
-
-[download]
-url = http://www.netfilter.org/pub/libmnl/libmnl-1.0.4.tar.bz2
-sha256 = 171f89699f286a5854b72b91d06e8f8e3683064c5901fb09d954a9ab6f551f81
-
-[build.os=linux]
-builder = autoconf
-subdir = libmnl-1.0.4
diff --git a/build/fbcode_builder/manifests/libnl b/build/fbcode_builder/manifests/libnl
deleted file mode 100644
index 560885c2e331a..0000000000000
--- a/build/fbcode_builder/manifests/libnl
+++ /dev/null
@@ -1,18 +0,0 @@
-[manifest]
-name = libnl
-
-[rpms]
-libnl3-devel
-libnl3
-
-[debs]
-libnl-3-dev
-libnl-route-3-dev
-
-[download]
-url = https://www.infradead.org/~tgr/libnl/files/libnl-3.2.25.tar.gz
-sha256 = 8beb7590674957b931de6b7f81c530b85dc7c1ad8fbda015398bc1e8d1ce8ec5
-
-[build.os=linux]
-builder = autoconf
-subdir = libnl-3.2.25
diff --git a/build/fbcode_builder/manifests/libsai b/build/fbcode_builder/manifests/libsai
deleted file mode 100644
index 4f772d826e113..0000000000000
--- a/build/fbcode_builder/manifests/libsai
+++ /dev/null
@@ -1,14 +0,0 @@
-[manifest]
-name = libsai
-
-[download]
-url = https://github.com/opencomputeproject/SAI/archive/v1.13.0.tar.gz
-sha256 = bb8c5d6cb0c7897422875d0da7b903708d1a15557ad07c6d6266dff83cb8c78d
-
-[build]
-builder = nop
-subdir = SAI-1.13.0
-
-[install.files]
-inc = include
-experimental = experimental
diff --git a/build/fbcode_builder/manifests/libsodium b/build/fbcode_builder/manifests/libsodium
deleted file mode 100644
index 0c9941c3fee76..0000000000000
--- a/build/fbcode_builder/manifests/libsodium
+++ /dev/null
@@ -1,36 +0,0 @@
-[manifest]
-name = libsodium
-
-[debs]
-libsodium-dev
-
-[homebrew]
-libsodium
-
-[rpms]
-libsodium-devel
-libsodium-static
-
-[download.not(os=windows)]
-url = https://github.com/jedisct1/libsodium/releases/download/1.0.17/libsodium-1.0.17.tar.gz
-sha256 = 0cc3dae33e642cc187b5ceb467e0ad0e1b51dcba577de1190e9ffa17766ac2b1
-
-[build.not(os=windows)]
-builder = autoconf
-subdir = libsodium-1.0.17
-
-[download.os=windows]
-url = https://download.libsodium.org/libsodium/releases/old/libsodium-1.0.17-msvc.zip
-sha256 = f0f32ad8ebd76eee99bb039f843f583f2babca5288a8c26a7261db9694c11467
-
-[build.os=windows]
-builder = nop
-
-[install.files.os=windows]
-x64/Release/v141/dynamic/libsodium.dll = bin/libsodium.dll
-x64/Release/v141/dynamic/libsodium.lib = lib/libsodium.lib
-x64/Release/v141/dynamic/libsodium.exp = lib/libsodium.exp
-x64/Release/v141/dynamic/libsodium.pdb = lib/libsodium.pdb
-include = include
-
-[autoconf.args]
diff --git a/build/fbcode_builder/manifests/libtool b/build/fbcode_builder/manifests/libtool
deleted file mode 100644
index 887a23cdfba7a..0000000000000
--- a/build/fbcode_builder/manifests/libtool
+++ /dev/null
@@ -1,25 +0,0 @@
-[manifest]
-name = libtool
-
-[homebrew]
-libtool
-
-[rpms]
-libtool
-
-[debs]
-libtool
-
-[download]
-url = http://ftp.gnu.org/gnu/libtool/libtool-2.4.6.tar.gz
-sha256 = e3bd4d5d3d025a36c21dd6af7ea818a2afcd4dfc1ea5a17b39d7854bcd0c06e3
-
-[build]
-builder = autoconf
-subdir = libtool-2.4.6
-
-[dependencies]
-automake
-
-[autoconf.args]
---enable-ltdl-install
diff --git a/build/fbcode_builder/manifests/libusb b/build/fbcode_builder/manifests/libusb
deleted file mode 100644
index 9b97c3a597629..0000000000000
--- a/build/fbcode_builder/manifests/libusb
+++ /dev/null
@@ -1,26 +0,0 @@
-[manifest]
-name = libusb
-
-[debs]
-libusb-1.0-0-dev
-
-[homebrew]
-libusb
-
-[rpms]
-libusb-devel
-libusb
-
-[download]
-url = https://github.com/libusb/libusb/releases/download/v1.0.22/libusb-1.0.22.tar.bz2
-sha256 = 75aeb9d59a4fdb800d329a545c2e6799f732362193b465ea198f2aa275518157
-
-[build.os=linux]
-builder = autoconf
-subdir = libusb-1.0.22
-
-[autoconf.args]
-# fboss (which added the libusb dep) doesn't need udev so it is disabled here.
-# if someone in the future wants to add udev for something else, it won't hurt
-# fboss.
---disable-udev
diff --git a/build/fbcode_builder/manifests/libyaml b/build/fbcode_builder/manifests/libyaml
deleted file mode 100644
index a7ff57316fe10..0000000000000
--- a/build/fbcode_builder/manifests/libyaml
+++ /dev/null
@@ -1,13 +0,0 @@
-[manifest]
-name = libyaml
-
-[download]
-url = http://pyyaml.org/download/libyaml/yaml-0.1.7.tar.gz
-sha256 = 8088e457264a98ba451a90b8661fcb4f9d6f478f7265d48322a196cec2480729
-
-[build.os=linux]
-builder = autoconf
-subdir = yaml-0.1.7
-
-[build.not(os=linux)]
-builder = nop
diff --git a/build/fbcode_builder/manifests/libzmq b/build/fbcode_builder/manifests/libzmq
deleted file mode 100644
index a36121d67fd72..0000000000000
--- a/build/fbcode_builder/manifests/libzmq
+++ /dev/null
@@ -1,27 +0,0 @@
-[manifest]
-name = libzmq
-
-[debs]
-libzmq3-dev
-
-[homebrew]
-zeromq
-
-[rpms]
-zeromq-devel
-zeromq
-
-[download]
-url = https://github.com/zeromq/libzmq/releases/download/v4.3.1/zeromq-4.3.1.tar.gz
-sha256 = bcbabe1e2c7d0eec4ed612e10b94b112dd5f06fcefa994a0c79a45d835cd21eb
-
-
-[build]
-builder = autoconf
-subdir = zeromq-4.3.1
-
-[autoconf.args]
-
-[dependencies]
-autoconf
-libtool
diff --git a/build/fbcode_builder/manifests/lld b/build/fbcode_builder/manifests/lld
deleted file mode 100644
index 39f5b095213ef..0000000000000
--- a/build/fbcode_builder/manifests/lld
+++ /dev/null
@@ -1,13 +0,0 @@
-[manifest]
-name = lld
-
-[debs]
-lld
-
-[rpms]
-lld
-
-# We use the system lld where needed on linux and default linker elsewhere
-[build]
-builder = nop
-
diff --git a/build/fbcode_builder/manifests/lz4 b/build/fbcode_builder/manifests/lz4
deleted file mode 100644
index 084d6a4aecd8b..0000000000000
--- a/build/fbcode_builder/manifests/lz4
+++ /dev/null
@@ -1,22 +0,0 @@
-[manifest]
-name = lz4
-
-[homebrew]
-lz4
-
-[rpms]
-lz4-devel
-# centos 8 and centos_stream 9 are missing this rpm
-[rpms.not(any(all(distro=centos,distro_vers=8),all(distro=centos_stream,distro_vers=9)))]
-lz4-static
-
-[debs]
-liblz4-dev
-
-[download]
-url = https://github.com/lz4/lz4/archive/v1.8.3.tar.gz
-sha256 = 33af5936ac06536805f9745e0b6d61da606a1f8b4cc5c04dd3cbaca3b9b4fc43
-
-[build]
-builder = cmake
-subdir = lz4-1.8.3/contrib/cmake_unofficial
diff --git a/build/fbcode_builder/manifests/lzo b/build/fbcode_builder/manifests/lzo
deleted file mode 100644
index fd474127bbb12..0000000000000
--- a/build/fbcode_builder/manifests/lzo
+++ /dev/null
@@ -1,22 +0,0 @@
-[manifest]
-name = lzo
-
-[debs]
-liblzo2-dev
-
-[homebrew]
-lzo
-
-[rpms]
-lzo-devel
-
-[download]
-url = http://www.oberhumer.com/opensource/lzo/download/lzo-2.10.tar.gz 
-sha256 = c0f892943208266f9b6543b3ae308fab6284c5c90e627931446fb49b4221a072
-
-[build.not(os=windows)]
-builder = autoconf
-subdir = lzo-2.10
-
-[build.os=windows]
-builder = nop
diff --git a/build/fbcode_builder/manifests/mononoke b/build/fbcode_builder/manifests/mononoke
deleted file mode 100644
index 9df5bbd484e0f..0000000000000
--- a/build/fbcode_builder/manifests/mononoke
+++ /dev/null
@@ -1,55 +0,0 @@
-[manifest]
-name = mononoke
-fbsource_path = fbcode/eden
-shipit_project = eden
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/sapling.git
-
-[build.not(os=windows)]
-builder = cargo
-
-[build.os=windows]
-# building Mononoke on windows is not supported
-builder = nop
-
-[cargo]
-build_doc = true
-workspace_dir = eden/mononoke
-cargo_config_file = source/eden/mononoke/.cargo/config
-
-[shipit.pathmap]
-fbcode/configerator/structs/scm/hg = configerator/structs/scm/hg
-fbcode/configerator/structs/scm/hg/public_autocargo = configerator/structs/scm/hg
-fbcode/configerator/structs/scm/mononoke/public_autocargo = configerator/structs/scm/mononoke
-fbcode/configerator/structs/scm/mononoke = configerator/structs/scm/mononoke
-fbcode/eden/oss = .
-fbcode/eden = eden
-fbcode/eden/fs/public_autocargo = eden/fs
-fbcode/eden/mononoke/public_autocargo = eden/mononoke
-fbcode/eden/scm/public_autocargo = eden/scm
-fbcode/tools/lfs = tools/lfs
-tools/rust/ossconfigs = .
-
-[shipit.strip]
-^fbcode/configerator/structs/scm/hg(?!/public_autocargo).*/Cargo\.toml$
-^fbcode/configerator/structs/scm/mononoke(?!/public_autocargo).*/Cargo\.toml$
-^fbcode/eden/fs(?!/public_autocargo).*/Cargo\.toml$
-^fbcode/eden/scm/lib/third-party/rust/.*/Cargo\.toml$
-^fbcode/eden/mononoke(?!/public_autocargo).*/Cargo\.toml$
-# strip other scm code  unrelated to mononoke to prevent triggering unnecessary checks
-^fbcode/eden(?!/mononoke|/scm/(lib|public_autocargo))/.*$
-^.*/facebook/.*$
-^.*/fb/.*$
-
-[dependencies]
-fb303
-fbthrift
-rust-shed
-
-[dependencies.os=linux]
-lld
-
-[dependencies.fb=on]
-rust
diff --git a/build/fbcode_builder/manifests/mvfst b/build/fbcode_builder/manifests/mvfst
deleted file mode 100644
index c2a797be23478..0000000000000
--- a/build/fbcode_builder/manifests/mvfst
+++ /dev/null
@@ -1,32 +0,0 @@
-[manifest]
-name = mvfst
-fbsource_path = fbcode/quic
-shipit_project = mvfst
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/mvfst.git
-
-[build]
-builder = cmake
-subdir = .
-
-[cmake.defines.test=on]
-BUILD_TESTS = ON
-
-[cmake.defines.all(os=windows, test=on)]
-BUILD_TESTS = OFF
-
-[cmake.defines.test=off]
-BUILD_TESTS = OFF
-
-[dependencies]
-folly
-fizz
-
-[dependencies.all(test=on, not(os=windows))]
-googletest
-
-[shipit.pathmap]
-fbcode/quic/public_root = .
-fbcode/quic = quic
diff --git a/build/fbcode_builder/manifests/ncurses b/build/fbcode_builder/manifests/ncurses
deleted file mode 100644
index 1bb5e8a45396a..0000000000000
--- a/build/fbcode_builder/manifests/ncurses
+++ /dev/null
@@ -1,30 +0,0 @@
-[manifest]
-name = ncurses
-
-[debs]
-libncurses-dev
-
-[homebrew]
-ncurses
-
-[rpms]
-ncurses-devel
-
-[download]
-url = https://ftp.gnu.org/pub/gnu/ncurses/ncurses-6.3.tar.gz
-sha256 = 97fc51ac2b085d4cde31ef4d2c3122c21abc217e9090a43a30fc5ec21684e059
-
-[build.not(os=windows)]
-builder = autoconf
-subdir = ncurses-6.3
-
-[autoconf.args]
---without-cxx-binding
---without-ada
-
-[autoconf.args.os=linux]
---enable-shared
---with-shared
-
-[build.os=windows]
-builder = nop
diff --git a/build/fbcode_builder/manifests/nghttp2 b/build/fbcode_builder/manifests/nghttp2
deleted file mode 100644
index 5ebdce0a42fed..0000000000000
--- a/build/fbcode_builder/manifests/nghttp2
+++ /dev/null
@@ -1,21 +0,0 @@
-[manifest]
-name = nghttp2
-
-[rpms]
-libnghttp2-devel
-libnghttp2
-
-[debs]
-libnghttp2-dev
-
-[download]
-url = https://github.com/nghttp2/nghttp2/releases/download/v1.47.0/nghttp2-1.47.0.tar.gz
-sha256 = 62f50f0e9fc479e48b34e1526df8dd2e94136de4c426b7680048181606832b7c
-
-[build]
-builder = autoconf
-subdir = nghttp2-1.47.0
-
-[autoconf.args]
---enable-lib-only
---disable-dependency-tracking
diff --git a/build/fbcode_builder/manifests/ninja b/build/fbcode_builder/manifests/ninja
deleted file mode 100644
index 713c59d69f98d..0000000000000
--- a/build/fbcode_builder/manifests/ninja
+++ /dev/null
@@ -1,29 +0,0 @@
-[manifest]
-name = ninja
-
-[debs]
-ninja-build
-
-[homebrew]
-ninja
-
-[rpms]
-ninja-build
-
-[download.os=windows]
-url = https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip
-sha256 = bbde850d247d2737c5764c927d1071cbb1f1957dcabda4a130fa8547c12c695f
-
-[build.os=windows]
-builder = nop
-
-[install.files.os=windows]
-ninja.exe = bin/ninja.exe
-
-[download.not(os=windows)]
-url = https://github.com/ninja-build/ninja/archive/v1.10.2.tar.gz
-sha256 = ce35865411f0490368a8fc383f29071de6690cbadc27704734978221f25e2bed
-
-[build.not(os=windows)]
-builder = ninja_bootstrap
-subdir = ninja-1.10.2
diff --git a/build/fbcode_builder/manifests/nlohmann-json b/build/fbcode_builder/manifests/nlohmann-json
deleted file mode 100644
index 7d552d95faccf..0000000000000
--- a/build/fbcode_builder/manifests/nlohmann-json
+++ /dev/null
@@ -1,12 +0,0 @@
-[manifest]
-name = nlohmann-json
-
-[download]
-url = https://github.com/nlohmann/json/archive/refs/tags/v3.10.5.tar.gz
-sha256 = 5daca6ca216495edf89d167f808d1d03c4a4d929cef7da5e10f135ae1540c7e4
-
-[dependencies]
-
-[build]
-builder = cmake
-subdir = json-3.10.5
diff --git a/build/fbcode_builder/manifests/nmap b/build/fbcode_builder/manifests/nmap
deleted file mode 100644
index c245e12417be6..0000000000000
--- a/build/fbcode_builder/manifests/nmap
+++ /dev/null
@@ -1,25 +0,0 @@
-[manifest]
-name = nmap
-
-[rpms]
-nmap
-
-[debs]
-nmap
-
-[download.not(os=windows)]
-url = https://api.github.com/repos/nmap/nmap/tarball/ef8213a36c2e89233c806753a57b5cd473605408
-sha256 = eda39e5a8ef4964fac7db16abf91cc11ff568eac0fa2d680b0bfa33b0ed71f4a
-
-[build.not(os=windows)]
-builder = autoconf
-subdir = nmap-nmap-ef8213a
-build_in_src_dir = true
-
-[build.os=windows]
-builder = nop
-
-[autoconf.args]
-# Without this option the build was filing to find some third party libraries
-# that we don't need
-enable_rdma=no
diff --git a/build/fbcode_builder/manifests/openr b/build/fbcode_builder/manifests/openr
deleted file mode 100644
index 913d81f379ee1..0000000000000
--- a/build/fbcode_builder/manifests/openr
+++ /dev/null
@@ -1,38 +0,0 @@
-[manifest]
-name = openr
-fbsource_path = facebook/openr
-shipit_project = openr
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/openr.git
-
-[build.os=linux]
-builder = cmake
-# openr files take a lot of RAM to compile.
-job_weight_mib = 3072
-
-[build.not(os=linux)]
-# boost.fiber is required and that is not available on macos.
-builder = nop
-
-[dependencies]
-boost
-fb303
-fbthrift
-folly
-googletest
-re2
-range-v3
-
-[cmake.defines.test=on]
-BUILD_TESTS=ON
-ADD_ROOT_TESTS=OFF
-
-[cmake.defines.test=off]
-BUILD_TESTS=OFF
-
-
-[shipit.pathmap]
-fbcode/openr = openr
-fbcode/openr/public_tld = .
diff --git a/build/fbcode_builder/manifests/openssl b/build/fbcode_builder/manifests/openssl
deleted file mode 100644
index b806b701ae720..0000000000000
--- a/build/fbcode_builder/manifests/openssl
+++ /dev/null
@@ -1,26 +0,0 @@
-[manifest]
-name = openssl
-
-[debs]
-libssl-dev
-
-[homebrew]
-openssl@1.1
-# on homebrew need the matching curl and ca-
-
-[rpms]
-openssl
-openssl-devel
-openssl-libs
-
-[download]
-url = https://www.openssl.org/source/openssl-1.1.1l.tar.gz
-sha256 = 0b7a3e5e59c34827fe0c3a74b7ec8baef302b98fa80088d7f9153aa16fa76bd1
-
-# We use the system openssl on linux
-[build.not(any(os=linux, os=freebsd))]
-builder = openssl
-subdir = openssl-1.1.1l
-
-[dependencies.os=windows]
-perl
diff --git a/build/fbcode_builder/manifests/osxfuse b/build/fbcode_builder/manifests/osxfuse
deleted file mode 100644
index b6c6c551f118d..0000000000000
--- a/build/fbcode_builder/manifests/osxfuse
+++ /dev/null
@@ -1,12 +0,0 @@
-[manifest]
-name = osxfuse
-
-[download]
-url = https://github.com/osxfuse/osxfuse/archive/osxfuse-3.8.3.tar.gz
-sha256 = 93bab6731bdfe8dc1ef069483437270ce7fe5a370f933d40d8d0ef09ba846c0c
-
-[build]
-builder = nop
-
-[install.files]
-osxfuse-osxfuse-3.8.3/common = include
diff --git a/build/fbcode_builder/manifests/patchelf b/build/fbcode_builder/manifests/patchelf
deleted file mode 100644
index f9d050424a293..0000000000000
--- a/build/fbcode_builder/manifests/patchelf
+++ /dev/null
@@ -1,17 +0,0 @@
-[manifest]
-name = patchelf
-
-[rpms]
-patchelf
-
-[debs]
-patchelf
-
-[download]
-url = https://github.com/NixOS/patchelf/archive/0.10.tar.gz
-sha256 = b3cb6bdedcef5607ce34a350cf0b182eb979f8f7bc31eae55a93a70a3f020d13
-
-[build]
-builder = autoconf
-subdir = patchelf-0.10
-
diff --git a/build/fbcode_builder/manifests/pcre b/build/fbcode_builder/manifests/pcre
deleted file mode 100644
index 047f6352b2715..0000000000000
--- a/build/fbcode_builder/manifests/pcre
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = pcre
-
-[homebrew]
-pcre
-
-[rpms]
-pcre-devel
-pcre-static
-
-[debs]
-libpcre3-dev
-
-[download]
-url = https://versaweb.dl.sourceforge.net/project/pcre/pcre/8.43/pcre-8.43.tar.gz
-sha256 = 0b8e7465dc5e98c757cc3650a20a7843ee4c3edf50aaf60bb33fd879690d2c73
-
-[build]
-builder = cmake
-subdir = pcre-8.43
diff --git a/build/fbcode_builder/manifests/pcre2 b/build/fbcode_builder/manifests/pcre2
deleted file mode 100644
index 9ba119a78f570..0000000000000
--- a/build/fbcode_builder/manifests/pcre2
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = pcre2
-
-[homebrew]
-pcre2
-
-[rpms]
-pcre2-devel
-pcre-static
-
-[debs]
-libpcre2-dev
-
-[download]
-url = https://github.com/PCRE2Project/pcre2/releases/download/pcre2-10.40/pcre2-10.40.tar.bz2
-sha256 = 14e4b83c4783933dc17e964318e6324f7cae1bc75d8f3c79bc6969f00c159d68
-
-[build]
-builder = cmake
-subdir = pcre2-10.40
diff --git a/build/fbcode_builder/manifests/perl b/build/fbcode_builder/manifests/perl
deleted file mode 100644
index 32bddc51ca69e..0000000000000
--- a/build/fbcode_builder/manifests/perl
+++ /dev/null
@@ -1,11 +0,0 @@
-[manifest]
-name = perl
-
-[download.os=windows]
-url = http://strawberryperl.com/download/5.28.1.1/strawberry-perl-5.28.1.1-64bit-portable.zip
-sha256 = 935c95ba096fa11c4e1b5188732e3832d330a2a79e9882ab7ba8460ddbca810d
-
-[build.os=windows]
-builder = nop
-subdir = perl
-
diff --git a/build/fbcode_builder/manifests/pexpect b/build/fbcode_builder/manifests/pexpect
deleted file mode 100644
index 682e66a540c12..0000000000000
--- a/build/fbcode_builder/manifests/pexpect
+++ /dev/null
@@ -1,12 +0,0 @@
-[manifest]
-name = pexpect
-
-[download]
-url = https://files.pythonhosted.org/packages/0e/3e/377007e3f36ec42f1b84ec322ee12141a9e10d808312e5738f52f80a232c/pexpect-4.7.0-py2.py3-none-any.whl
-sha256 = 2094eefdfcf37a1fdbfb9aa090862c1a4878e5c7e0e7e7088bdb511c558e5cd1
-
-[build]
-builder = python-wheel
-
-[dependencies]
-python-ptyprocess
diff --git a/build/fbcode_builder/manifests/protobuf b/build/fbcode_builder/manifests/protobuf
deleted file mode 100644
index 311775b98179f..0000000000000
--- a/build/fbcode_builder/manifests/protobuf
+++ /dev/null
@@ -1,18 +0,0 @@
-[manifest]
-name = protobuf
-
-[rpms]
-protobuf-devel
-
-[debs]
-libprotobuf-dev
-
-[git]
-repo_url = https://github.com/protocolbuffers/protobuf.git
-rev = master
-
-[build.not(os=windows)]
-builder = autoconf
-
-[build.os=windows]
-builder = nop
diff --git a/build/fbcode_builder/manifests/proxygen b/build/fbcode_builder/manifests/proxygen
deleted file mode 100644
index a7b48043f8fb9..0000000000000
--- a/build/fbcode_builder/manifests/proxygen
+++ /dev/null
@@ -1,37 +0,0 @@
-[manifest]
-name = proxygen
-fbsource_path = fbcode/proxygen
-shipit_project = proxygen
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/proxygen.git
-
-[build.os=windows]
-builder = nop
-
-[build]
-builder = cmake
-subdir = .
-job_weight_mib = 3072
-
-[cmake.defines.test=on]
-BUILD_TESTS = ON
-
-[cmake.defines.test=off]
-BUILD_TESTS = OFF
-
-[dependencies]
-zlib
-gperf
-folly
-fizz
-wangle
-mvfst
-
-[dependencies.test=on]
-googletest
-
-[shipit.pathmap]
-fbcode/proxygen/public_tld = .
-fbcode/proxygen = proxygen
diff --git a/build/fbcode_builder/manifests/python b/build/fbcode_builder/manifests/python
deleted file mode 100644
index c2e98e5711c4a..0000000000000
--- a/build/fbcode_builder/manifests/python
+++ /dev/null
@@ -1,45 +0,0 @@
-[manifest]
-name = python
-
-[homebrew]
-python@3.8
-
-[rpms]
-python3
-python3-devel
-
-# sapling needs dataclasses which arrive in 3.7, and the bionic python is 3.6
-[debs.all(distro=ubuntu,distro_vers="18.04")]
-python3.8-dev
-
-[debs.not(all(distro=ubuntu,distro_vers="18.04"))]
-python3-all-dev
-
-[download]
-url = https://www.python.org/ftp/python/3.8.13/Python-3.8.13.tgz
-sha256 = 903b92d76354366b1d9c4434d0c81643345cef87c1600adfa36095d7b00eede4
-
-[build]
-builder = autoconf
-subdir = Python-3.8.13
-
-[autoconf.args]
---enable-shared
---with-ensurepip=install
-
-# python's pkg-config libffi detection is broken
-# See https://bugs.python.org/issue34823 for clearest description
-# and pending PR https://github.com/python/cpython/pull/20451
-# The documented workaround requires an environment variable derived from
-# pkg-config to be passed into its configure step
-[autoconf.envcmd.LDFLAGS]
-pkg-config
---libs-only-L
-libffi
-
-[dependencies]
-libffi
-# eden tests expect the python bz2 support
-bz2
-# eden tests expect the python curses support
-ncurses
diff --git a/build/fbcode_builder/manifests/python-click b/build/fbcode_builder/manifests/python-click
deleted file mode 100644
index ea9a9d2d3dc38..0000000000000
--- a/build/fbcode_builder/manifests/python-click
+++ /dev/null
@@ -1,9 +0,0 @@
-[manifest]
-name = python-click
-
-[download]
-url = https://files.pythonhosted.org/packages/d2/3d/fa76db83bf75c4f8d338c2fd15c8d33fdd7ad23a9b5e57eb6c5de26b430e/click-7.1.2-py2.py3-none-any.whl
-sha256 = dacca89f4bfadd5de3d7489b7c8a566eee0d3676333fbb50030263894c38c0dc
-
-[build]
-builder = python-wheel
diff --git a/build/fbcode_builder/manifests/python-dulwich b/build/fbcode_builder/manifests/python-dulwich
deleted file mode 100644
index 0d995e12f4b36..0000000000000
--- a/build/fbcode_builder/manifests/python-dulwich
+++ /dev/null
@@ -1,19 +0,0 @@
-[manifest]
-name = python-dulwich
-
-# The below links point to custom github forks of project dulwich, because the
-# 0.18.6 version didn't have an official rollout of wheel packages.
-
-[download.os=linux]
-url = https://github.com/lukaspiatkowski/dulwich/releases/download/dulwich-0.18.6-wheel/dulwich-0.18.6-cp36-cp36m-linux_x86_64.whl
-sha256 = e96f545f3d003e67236785473caaba2c368e531ea85fd508a3bd016ebac3a6d8
-
-[download.os=darwin]
-url = https://github.com/lukaspiatkowski/dulwich/releases/download/dulwich-0.18.6-wheel/dulwich-0.18.6-cp37-cp37m-macosx_10_14_x86_64.whl
-sha256 = 8373652056284ad40ea5220b659b3489b0a91f25536322345a3e4b5d29069308
-
-[build.not(os=windows)]
-builder = python-wheel
-
-[build.os=windows]
-builder = nop
diff --git a/build/fbcode_builder/manifests/python-filelock b/build/fbcode_builder/manifests/python-filelock
deleted file mode 100644
index 40502de7c2159..0000000000000
--- a/build/fbcode_builder/manifests/python-filelock
+++ /dev/null
@@ -1,9 +0,0 @@
-[manifest]
-name = python-filelock
-
-[download]
-url = https://files.pythonhosted.org/packages/31/24/ee722b92f23b9ebd87783e893a75352c048bbbc1f67dce0d63b58b46cb48/filelock-3.3.2-py3-none-any.whl
-sha256 = bb2a1c717df74c48a2d00ed625e5a66f8572a3a30baacb7657add1d7bac4097b
-
-[build]
-builder = python-wheel
diff --git a/build/fbcode_builder/manifests/python-ptyprocess b/build/fbcode_builder/manifests/python-ptyprocess
deleted file mode 100644
index adc60e048ed17..0000000000000
--- a/build/fbcode_builder/manifests/python-ptyprocess
+++ /dev/null
@@ -1,9 +0,0 @@
-[manifest]
-name = python-ptyprocess
-
-[download]
-url = https://files.pythonhosted.org/packages/d1/29/605c2cc68a9992d18dada28206eeada56ea4bd07a239669da41674648b6f/ptyprocess-0.6.0-py2.py3-none-any.whl
-sha256 = d7cc528d76e76342423ca640335bd3633420dc1366f258cb31d05e865ef5ca1f
-
-[build]
-builder = python-wheel
diff --git a/build/fbcode_builder/manifests/python-six b/build/fbcode_builder/manifests/python-six
deleted file mode 100644
index a712188dc2909..0000000000000
--- a/build/fbcode_builder/manifests/python-six
+++ /dev/null
@@ -1,9 +0,0 @@
-[manifest]
-name = python-six
-
-[download]
-url = https://files.pythonhosted.org/packages/73/fb/00a976f728d0d1fecfe898238ce23f502a721c0ac0ecfedb80e0d88c64e9/six-1.12.0-py2.py3-none-any.whl
-sha256 = 3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c
-
-[build]
-builder = python-wheel
diff --git a/build/fbcode_builder/manifests/python-toml b/build/fbcode_builder/manifests/python-toml
deleted file mode 100644
index b49a3b8fb8604..0000000000000
--- a/build/fbcode_builder/manifests/python-toml
+++ /dev/null
@@ -1,9 +0,0 @@
-[manifest]
-name = python-toml
-
-[download]
-url = https://files.pythonhosted.org/packages/a2/12/ced7105d2de62fa7c8fb5fce92cc4ce66b57c95fb875e9318dba7f8c5db0/toml-0.10.0-py2.py3-none-any.whl
-sha256 = 235682dd292d5899d361a811df37e04a8828a5b1da3115886b73cf81ebc9100e
-
-[build]
-builder = python-wheel
diff --git a/build/fbcode_builder/manifests/range-v3 b/build/fbcode_builder/manifests/range-v3
deleted file mode 100644
index f96403c83f8c7..0000000000000
--- a/build/fbcode_builder/manifests/range-v3
+++ /dev/null
@@ -1,11 +0,0 @@
-[manifest]
-name = range-v3
-
-[download]
-url = https://github.com/ericniebler/range-v3/archive/refs/tags/0.11.0.tar.gz
-sha256 = 376376615dbba43d3bef75aa590931431ecb49eb36d07bb726a19f680c75e20c 
-
-
-[build]
-builder = cmake
-subdir = range-v3-0.11.0
diff --git a/build/fbcode_builder/manifests/re2 b/build/fbcode_builder/manifests/re2
deleted file mode 100644
index 945750afd6cba..0000000000000
--- a/build/fbcode_builder/manifests/re2
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = re2
-
-[homebrew]
-re2
-
-[debs]
-libre2-dev
-
-[rpms]
-re2
-re2-devel
-
-[download]
-url = https://github.com/google/re2/archive/2019-06-01.tar.gz
-sha256 = 02b7d73126bd18e9fbfe5d6375a8bb13fadaf8e99e48cbb062e4500fc18e8e2e
-
-[build]
-builder = cmake
-subdir = re2-2019-06-01
diff --git a/build/fbcode_builder/manifests/rocksdb b/build/fbcode_builder/manifests/rocksdb
deleted file mode 100644
index e1e3e717318fc..0000000000000
--- a/build/fbcode_builder/manifests/rocksdb
+++ /dev/null
@@ -1,42 +0,0 @@
-[manifest]
-name = rocksdb
-
-[download]
-url = https://github.com/facebook/rocksdb/archive/refs/tags/v7.7.3.tar.gz
-sha256 = b8ac9784a342b2e314c821f6d701148912215666ac5e9bdbccd93cf3767cb611
-
-[dependencies]
-lz4
-snappy
-
-[build]
-builder = cmake
-subdir = rocksdb-7.7.3
-
-[cmake.defines]
-WITH_SNAPPY=ON
-WITH_LZ4=ON
-WITH_TESTS=OFF
-WITH_BENCHMARK_TOOLS=OFF
-# We get relocation errors with the static gflags lib,
-# and there's no clear way to make it pick the shared gflags
-# so just turn it off.
-WITH_GFLAGS=OFF
-# mac pro machines don't have some of the newer features that
-# rocksdb enables by default; ask it to disable their use even
-# when building on new hardware
-PORTABLE = ON
-# Disable the use of -Werror
-FAIL_ON_WARNINGS = OFF
-
-[cmake.defines.os=windows]
-ROCKSDB_INSTALL_ON_WINDOWS=ON
-# RocksDB hard codes the paths to the snappy libs to something
-# that doesn't exist; ignoring the usual cmake rules.  As a result,
-# we can't build it with snappy without either patching rocksdb or
-# without introducing more complex logic to the build system to
-# connect the snappy build outputs to rocksdb's custom logic here.
-# Let's just turn it off on windows.
-WITH_SNAPPY=OFF
-WITH_LZ4=ON
-ROCKSDB_SKIP_THIRDPARTY=ON
diff --git a/build/fbcode_builder/manifests/rust-shed b/build/fbcode_builder/manifests/rust-shed
deleted file mode 100644
index 31e2b61d91313..0000000000000
--- a/build/fbcode_builder/manifests/rust-shed
+++ /dev/null
@@ -1,35 +0,0 @@
-[manifest]
-name = rust-shed
-fbsource_path = fbcode/common/rust/shed
-shipit_project = rust-shed
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebookexperimental/rust-shed.git
-
-[build]
-builder = cargo
-
-[cargo]
-build_doc = true
-workspace_dir =
-
-[shipit.pathmap]
-fbcode/common/rust/shed = shed
-fbcode/common/rust/shed/public_autocargo = shed
-fbcode/common/rust/shed/public_tld = .
-tools/rust/ossconfigs = .
-
-[shipit.strip]
-^fbcode/common/rust/shed/(?!public_autocargo|public_tld).+/Cargo\.toml$
-
-[dependencies]
-fbthrift
-fb303
-
-# We use the system openssl on linux
-[dependencies.not(os=linux)]
-openssl
-
-[dependencies.fbsource=on]
-rust
diff --git a/build/fbcode_builder/manifests/snappy b/build/fbcode_builder/manifests/snappy
deleted file mode 100644
index c4517efa24d04..0000000000000
--- a/build/fbcode_builder/manifests/snappy
+++ /dev/null
@@ -1,24 +0,0 @@
-[manifest]
-name = snappy
-
-[debs]
-libsnappy-dev
-
-[rpms]
-snappy-devel
-
-[download]
-url = https://github.com/google/snappy/archive/1.1.7.tar.gz
-sha256 = 3dfa02e873ff51a11ee02b9ca391807f0c8ea0529a4924afa645fbf97163f9d4
-
-[build]
-builder = cmake
-subdir = snappy-1.1.7
-
-[cmake.defines]
-SNAPPY_BUILD_TESTS = OFF
-
-# Avoid problems like `relocation R_X86_64_PC32 against symbol` on ELF systems
-# when linking rocksdb, which builds PIC even when building a static lib
-[cmake.defines.os=linux]
-BUILD_SHARED_LIBS = ON
diff --git a/build/fbcode_builder/manifests/sqlite3 b/build/fbcode_builder/manifests/sqlite3
deleted file mode 100644
index c87d4cf932c19..0000000000000
--- a/build/fbcode_builder/manifests/sqlite3
+++ /dev/null
@@ -1,24 +0,0 @@
-[manifest]
-name = sqlite3
-
-[debs]
-libsqlite3-dev
-
-[homebrew]
-sqlite
-
-[rpms]
-sqlite-devel
-sqlite-libs
-
-[download]
-url = https://sqlite.org/2019/sqlite-amalgamation-3280000.zip
-sha256 = d02fc4e95cfef672b45052e221617a050b7f2e20103661cda88387349a9b1327
-
-[dependencies]
-cmake
-ninja
-
-[build]
-builder = sqlite
-subdir = sqlite-amalgamation-3280000
diff --git a/build/fbcode_builder/manifests/sqlite3-bin b/build/fbcode_builder/manifests/sqlite3-bin
deleted file mode 100644
index aa138d499d6b6..0000000000000
--- a/build/fbcode_builder/manifests/sqlite3-bin
+++ /dev/null
@@ -1,28 +0,0 @@
-[manifest]
-name = sqlite3-bin
-
-[rpms]
-sqlite
-
-[debs]
-sqlite3
-
-[download.os=linux]
-url = https://github.com/sqlite/sqlite/archive/version-3.33.0.tar.gz
-sha256 = 48e5f989eefe9af0ac758096f82ead0f3c7b58118ac17cc5810495bd5084a331
-
-[build.os=linux]
-builder = autoconf
-subdir = sqlite-version-3.33.0
-
-[build.not(os=linux)]
-# MacOS comes with sqlite3 preinstalled and don't need Windows here
-builder = nop
-
-[dependencies.os=linux]
-tcl
-
-[autoconf.args]
-# This flag disabled tcl as a runtime library used for some functionality,
-# but tcl is still a required dependency as it is used by the build files
---disable-tcl
diff --git a/build/fbcode_builder/manifests/tcl b/build/fbcode_builder/manifests/tcl
deleted file mode 100644
index 5e9892f37a6d3..0000000000000
--- a/build/fbcode_builder/manifests/tcl
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = tcl
-
-[rpms]
-tcl
-
-[debs]
-tcl
-
-[download]
-url = https://github.com/tcltk/tcl/archive/core-8-7a3.tar.gz
-sha256 = 22d748f0c9652f3ecc195fed3f24a1b6eea8d449003085e6651197951528982e
-
-[build.os=linux]
-builder = autoconf
-subdir = tcl-core-8-7a3/unix
-
-[build.not(os=linux)]
-# This is for sqlite3 on Linux for now
-builder = nop
diff --git a/build/fbcode_builder/manifests/tree b/build/fbcode_builder/manifests/tree
deleted file mode 100644
index ccd0180a74c0d..0000000000000
--- a/build/fbcode_builder/manifests/tree
+++ /dev/null
@@ -1,37 +0,0 @@
-[manifest]
-name = tree
-
-[debs]
-tree
-
-[homebrew]
-tree
-
-[rpms]
-tree
-
-[download.os=linux]
-url = https://salsa.debian.org/debian/tree-packaging/-/archive/debian/1.8.0-1/tree-packaging-debian-1.8.0-1.tar.gz
-sha256 = a841eee1d52bfd64a48f54caab9937b9bd92935055c48885c4ab1ae4dab7fae5
-
-[download.os=darwin]
-# The official package of tree source requires users of non-Linux platform to
-# comment/uncomment certain lines in the Makefile to build for their platform.
-# Besauce getdeps.py doesn't have that functionality we just use this custom
-# fork of tree which has proper lines uncommented for a OSX build
-url = https://github.com/lukaspiatkowski/tree-command/archive/debian/1.8.0-1-macos.tar.gz
-sha256 = 9cbe889553d95cf5a2791dd0743795d46a3c092c5bba691769c0e5c52e11229e
-
-[build.os=linux]
-builder = make
-subdir = tree-packaging-debian-1.8.0-1
-
-[build.os=darwin]
-builder = make
-subdir = tree-command-debian-1.8.0-1-macos
-
-[build.os=windows]
-builder = nop
-
-[make.install_args]
-install
diff --git a/build/fbcode_builder/manifests/wangle b/build/fbcode_builder/manifests/wangle
deleted file mode 100644
index 6b330d620f466..0000000000000
--- a/build/fbcode_builder/manifests/wangle
+++ /dev/null
@@ -1,27 +0,0 @@
-[manifest]
-name = wangle
-fbsource_path = fbcode/wangle
-shipit_project = wangle
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/wangle.git
-
-[build]
-builder = cmake
-subdir = wangle
-
-[cmake.defines.test=on]
-BUILD_TESTS=ON
-
-[cmake.defines.test=off]
-BUILD_TESTS=OFF
-
-[dependencies]
-folly
-googletest
-fizz
-
-[shipit.pathmap]
-fbcode/wangle/public_tld = .
-fbcode/wangle = wangle
diff --git a/build/fbcode_builder/manifests/watchman b/build/fbcode_builder/manifests/watchman
deleted file mode 100644
index b733a0c09c372..0000000000000
--- a/build/fbcode_builder/manifests/watchman
+++ /dev/null
@@ -1,47 +0,0 @@
-[manifest]
-name = watchman
-fbsource_path = fbcode/watchman
-shipit_project = watchman
-shipit_fbcode_builder = true
-
-[git]
-repo_url = https://github.com/facebook/watchman.git
-
-[build]
-builder = cmake
-
-[dependencies]
-boost
-cpptoml
-edencommon
-fb303
-fbthrift
-folly
-pcre2
-googletest
-
-[dependencies.fbsource=on]
-rust
-
-[shipit.pathmap]
-fbcode/watchman = watchman
-fbcode/watchman/oss = .
-fbcode/eden/fs = eden/fs
-
-[shipit.strip]
-^fbcode/eden/fs/(?!.*\.thrift|service/shipit_test_file\.txt)
-
-[cmake.defines.fb=on]
-ENABLE_EDEN_SUPPORT=ON
-IS_FB_BUILD=ON
-
-# FB macos specific settings
-[cmake.defines.all(fb=on,os=darwin)]
-# this path is coupled with the FB internal watchman-osx.spec
-WATCHMAN_STATE_DIR=/opt/facebook/watchman/var/run/watchman
-# tell cmake not to try to create /opt/facebook/...
-INSTALL_WATCHMAN_STATE_DIR=OFF
-USE_SYS_PYTHON=OFF
-
-[depends.environment]
-WATCHMAN_VERSION_OVERRIDE
diff --git a/build/fbcode_builder/manifests/ws_airstore b/build/fbcode_builder/manifests/ws_airstore
deleted file mode 100644
index 3e5daa72a17d2..0000000000000
--- a/build/fbcode_builder/manifests/ws_airstore
+++ /dev/null
@@ -1,32 +0,0 @@
-[manifest]
-name = ws_airstore
-fbsource_path = fbcode/warm_storage/experimental/ws_airstore/
-shipit_project = WS_AIRStore
-shipit_fbcode_builder = true
-
-[build.os=linux]
-builder = cmake
-
-[build.not(os=linux)]
-# We only support Linux
-builder = nop
-
-[dependencies]
-boost
-libcurl
-fizz
-fmt
-folly
-googletest
-libsodium
-libevent
-double-conversion
-wangle
-zstd
-zlib
-xz
-
-[shipit.pathmap]
-fbcode/warm_storage/experimental/ws_airstore = .
-
-[shipit.strip]
diff --git a/build/fbcode_builder/manifests/xz b/build/fbcode_builder/manifests/xz
deleted file mode 100644
index 0b27ad63cc91c..0000000000000
--- a/build/fbcode_builder/manifests/xz
+++ /dev/null
@@ -1,22 +0,0 @@
-[manifest]
-name = xz
-
-[debs]
-liblzma-dev
-
-[homebrew]
-xz
-
-[rpms]
-xz-devel
-
-[download]
-url = https://tukaani.org/xz/xz-5.2.5.tar.gz
-sha256 = f6f4910fd033078738bd82bfba4f49219d03b17eb0794eb91efbae419f4aba10
-
-[build]
-builder = autoconf
-subdir = xz-5.2.5
-
-[autoconf.args]
---disable-shared
diff --git a/build/fbcode_builder/manifests/yaml-cpp b/build/fbcode_builder/manifests/yaml-cpp
deleted file mode 100644
index bffa540fe78ea..0000000000000
--- a/build/fbcode_builder/manifests/yaml-cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-[manifest]
-name = yaml-cpp
-
-[download]
-url = https://github.com/jbeder/yaml-cpp/archive/yaml-cpp-0.6.2.tar.gz
-sha256 = e4d8560e163c3d875fd5d9e5542b5fd5bec810febdcba61481fe5fc4e6b1fd05
-
-[build.os=linux]
-builder = cmake
-subdir = yaml-cpp-yaml-cpp-0.6.2
-
-[build.not(os=linux)]
-builder = nop
-
-[dependencies]
-boost
-googletest
-
-[cmake.defines]
-YAML_CPP_BUILD_TESTS=OFF
diff --git a/build/fbcode_builder/manifests/zlib b/build/fbcode_builder/manifests/zlib
deleted file mode 100644
index 86647fc9275ed..0000000000000
--- a/build/fbcode_builder/manifests/zlib
+++ /dev/null
@@ -1,21 +0,0 @@
-[manifest]
-name = zlib
-
-[debs]
-zlib1g-dev
-
-[homebrew]
-zlib
-
-[rpms]
-zlib-devel
-zlib-static
-
-[download]
-url = https://zlib.net/zlib-1.3.tar.gz
-sha256 = ff0ba4c292013dbc27530b3a81e1f9a813cd39de01ca5e0f8bf355702efa593e
-
-[build]
-builder = cmake
-subdir = zlib-1.3
-patchfile = zlib_dont_build_more_than_needed.patch
diff --git a/build/fbcode_builder/manifests/zstd b/build/fbcode_builder/manifests/zstd
deleted file mode 100644
index 18484f4b1ed15..0000000000000
--- a/build/fbcode_builder/manifests/zstd
+++ /dev/null
@@ -1,31 +0,0 @@
-[manifest]
-name = zstd
-
-[homebrew]
-zstd
-
-# 18.04 zstd is too old
-[debs.not(all(distro=ubuntu,distro_vers="18.04"))]
-libzstd-dev
-
-[rpms]
-libzstd-devel
-libzstd
-
-[download]
-url = https://github.com/facebook/zstd/releases/download/v1.5.5/zstd-1.5.5.tar.gz
-sha256 = 9c4396cc829cfae319a6e2615202e82aad41372073482fce286fac78646d3ee4
-
-[build]
-builder = cmake
-subdir = zstd-1.5.5/build/cmake
-
-# The zstd cmake build explicitly sets the install name
-# for the shared library in such a way that cmake discards
-# the path to the library from the install_name, rendering
-# the library non-resolvable during the build.  The short
-# term solution for this is just to link static on macos.
-#
-# And while we're at it, let's just always link statically.
-[cmake.defines]
-ZSTD_BUILD_SHARED = OFF
diff --git a/build/fbcode_builder/manifests/zstrong b/build/fbcode_builder/manifests/zstrong
deleted file mode 100644
index 5205c2c6708f7..0000000000000
--- a/build/fbcode_builder/manifests/zstrong
+++ /dev/null
@@ -1,33 +0,0 @@
-[manifest]
-name = zstrong
-
-[git]
-repo_url = https://github.com/facebookincubator/zstrong.git
-
-[build]
-builder = cmake
-
-[dependencies]
-zstd
-
-[dependencies.test=on]
-benchmark
-fmt
-googletest
-
-[shipit.pathmap]
-fbcode/data_compression/experimental/zstrong = .
-
-[shipit.strip]
-^fbcode/data_compression/experimental/zstrong/zstrong/zs2_config\.h$
-
-[cmake.defines]
-BUILD_SHARED_LIBS=OFF
-
-[cmake.defines.test=on]
-BUILD_TESTS=ON
-BUILD_BENCHMARKS=ON
-
-[cmake.defines.test=off]
-BUILD_TESTS=OFF
-BUILD_BENCHMARKS=OFF
diff --git a/build/fbcode_builder/patches/blake3_CMakeLists_txt.patch b/build/fbcode_builder/patches/blake3_CMakeLists_txt.patch
deleted file mode 100644
index 9b1c828fafe62..0000000000000
--- a/build/fbcode_builder/patches/blake3_CMakeLists_txt.patch
+++ /dev/null
@@ -1,97 +0,0 @@
-diff --git a/BLAKE3Config.cmake.in b/BLAKE3Config.cmake.in
-new file mode 100644
-index 0000000..5a8919d
---- /dev/null
-+++ b/BLAKE3Config.cmake.in
-@@ -0,0 +1,4 @@
-+@PACKAGE_INIT@
-+
-+set_and_check(BLAKE3_INCLUDE_DIR "@PACKAGE_INCLUDE_DIR@")
-+include("${CMAKE_CURRENT_LIST_DIR}/BLAKE3Targets.cmake")
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-new file mode 100644
-index 0000000..171554b
---- /dev/null
-+++ b/CMakeLists.txt
-@@ -0,0 +1,81 @@
-+cmake_minimum_required(VERSION 3.12)
-+cmake_policy(VERSION ${CMAKE_VERSION})
-+
-+project(BLAKE3
-+	VERSION 1.3.3
-+	DESCRIPTION "BLAKE3 C implementation"
-+	HOMEPAGE_URL "https://github.com/BLAKE3-team/BLAKE3"
-+	LANGUAGES C)
-+
-+include(GNUInstallDirs)
-+
-+add_library(blake3)
-+
-+set(INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH
-+    "The subdirectory where header files should be installed")
-+
-+set_target_properties(blake3 PROPERTIES
-+	PUBLIC_HEADER "blake3.h"
-+	SOVERSION ${PROJECT_VERSION_MAJOR}
-+	VERSION ${PROJECT_VERSION})
-+
-+target_sources(blake3 PRIVATE
-+	blake3.c
-+	blake3_dispatch.c
-+	blake3_portable.c)
-+
-+if((CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64) OR (CMAKE_SYSTEM_PROCESSOR STREQUAL AMD64))
-+	enable_language(ASM)
-+	if(MSVC)
-+		enable_language(ASM_MASM)
-+		set(SUFFIX "windows_msvc.asm")
-+	elseif(WIN32)
-+		enable_language(ASM)
-+		set(SUFFIX "windows_gnu.S")
-+	else()
-+		enable_language(ASM)
-+		set(SUFFIX "unix.S")
-+	endif()
-+	target_sources(blake3 PRIVATE
-+		blake3_avx2_x86-64_${SUFFIX}
-+		blake3_avx512_x86-64_${SUFFIX}
-+		blake3_sse2_x86-64_${SUFFIX}
-+		blake3_sse41_x86-64_${SUFFIX})
-+elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL i686)
-+	target_compile_options(blake3 PRIVATE
-+		-mavx2
-+		-mavx512f -mavx512vl
-+		-msse2
-+		-msse4.1)
-+	target_sources(blake3 PRIVATE
-+		blake3_avx2.c
-+		blake3_avx512.c
-+		blake3_sse2.c
-+		blake3_sse41.c)
-+elseif((CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64) OR
-+       (ANDROID_ABI STREQUAL armeabi-v7a))
-+	target_compile_definitions(blake3 PRIVATE BLAKE3_USE_NEON)
-+	target_compile_options(blake3 PRIVATE -mfpu=neon)
-+	target_sources(blake3 PRIVATE blake3_neon.c)
-+endif()
-+
-+install(TARGETS blake3
-+        EXPORT blake3_targets
-+        PUBLIC_HEADER)
-+install(EXPORT blake3_targets
-+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
-+        FILE "${PROJECT_NAME}Targets.cmake"
-+        NAMESPACE "${PROJECT_NAME}::")
-+
-+include(CMakePackageConfigHelpers)
-+write_basic_package_version_file(
-+        "${PROJECT_NAME}ConfigVersion.cmake"
-+        VERSION ${PROJECT_VERSION}
-+        COMPATIBILITY AnyNewerVersion)
-+configure_package_config_file(
-+        ${PROJECT_NAME}Config.cmake.in
-+        ${PROJECT_NAME}Config.cmake
-+        INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
-+        PATH_VARS INCLUDE_DIR)
-+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
-+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
diff --git a/build/fbcode_builder/patches/zlib_dont_build_more_than_needed.patch b/build/fbcode_builder/patches/zlib_dont_build_more_than_needed.patch
deleted file mode 100644
index 919f4ec8adc0f..0000000000000
--- a/build/fbcode_builder/patches/zlib_dont_build_more_than_needed.patch
+++ /dev/null
@@ -1,31 +0,0 @@
-diff -Naur ../zlib-1.2.13/CMakeLists.txt ./CMakeLists.txt
---- ../zlib-1.2.13/CMakeLists.txt	2022-10-12 22:06:55.000000000 -0700
-+++ ./CMakeLists.txt	2022-10-14 14:50:28.000000000 -0700
-@@ -147,8 +147,7 @@
-     set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
- endif(MINGW)
- 
--add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
--add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
-+add_library(zlib ${ZLIB_SRCS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
- set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
- set_target_properties(zlib PROPERTIES SOVERSION 1)
- 
-@@ -165,7 +164,7 @@
- 
- if(UNIX)
-     # On unix-like platforms the library is almost always called libz
--   set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z)
-+   set_target_properties(zlib PROPERTIES OUTPUT_NAME z)
-    if(NOT APPLE)
-      set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/zlib.map\"")
-    endif()
-@@ -175,7 +174,7 @@
- endif()
- 
- if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
--    install(TARGETS zlib zlibstatic
-+    install(TARGETS zlib
-         RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
-         ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
-         LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
diff --git a/docker-compose.yml b/docker-compose.yml
index a8fe32b71706f..6904baa543eea 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -21,7 +21,7 @@ services:
     #   or
     #   docker-compose run -e NUM_THREADS=<NUMBER_OF_THREADS_TO_USE> --rm ubuntu-cpp
     #   to set the number of threads used during compilation
-    image: ghcr.io/facebookincubator/velox-dev:amd64-ubuntu-22.04-avx
+    image: ghcr.io/facebookincubator/velox-dev:ubuntu-22.04
     build:
       context: .
       dockerfile: scripts/ubuntu-22.04-cpp.dockerfile
@@ -33,6 +33,32 @@ services:
       - .:/velox:delegated
     command: scripts/docker-command.sh
 
+  adapters-cpp:
+    # Usage:
+    #   docker-compose pull adapters-cpp or docker-compose build adapters-cpp
+    #   or
+    #   docker-compose run --rm adapters-cpp
+    #   or
+    #   docker-compose run -e NUM_THREADS=<NUMBER_OF_THREADS_TO_USE> --rm adapters-cpp
+    #   to set the number of threads used during compilation
+    # scripts/adapters.dockerfile uses SHELL which is not supported for OCI image format.
+    # podman users must specify "--podman-build-args='--format docker'" argument.
+    image: ghcr.io/facebookincubator/velox-dev:adapters
+    build:
+      context: .
+      dockerfile: scripts/adapters.dockerfile
+      args:
+        image: ghcr.io/facebookincubator/velox-dev:centos9
+    environment:
+      NUM_THREADS: 8 # default value for NUM_THREADS
+      CCACHE_DIR: "/velox/.ccache"
+      EXTRA_CMAKE_FLAGS: -DVELOX_ENABLE_PARQUET=ON 
+                         -DVELOX_ENABLE_S3=ON
+    volumes:
+      - .:/velox:delegated
+    working_dir: /velox
+    command: /velox/scripts/docker-command.sh
+
   centos-cpp:
     # Usage:
     #   docker-compose pull centos-cpp or docker-compose build centos-cpp
@@ -40,32 +66,58 @@ services:
     #   or
     #   docker-compose run -e NUM_THREADS=<NUMBER_OF_THREADS_TO_USE> --rm centos-cpp
     #   to set the number of threads used during compilation
-    image: ghcr.io/facebookincubator/velox-dev:amd64-centos-8-avx
+    image: ghcr.io/facebookincubator/velox-dev:centos9
     build:
       context: .
-      dockerfile: scripts/centos-8-stream.dockerfile
+      dockerfile: scripts/centos.dockerfile
+      args:
+        image: quay.io/centos/centos:stream9
     environment:
       NUM_THREADS: 8 # default value for NUM_THREADS
       CCACHE_DIR: "/velox/.ccache"
     volumes:
       - .:/velox:delegated
-    command: /bin/bash -c "scl enable gcc-toolset-9 '/velox/scripts/docker-command.sh'"
+    working_dir: /velox
+    command: /velox/scripts/docker-command.sh
 
-  python:
-    # Usage:
-    #   docker-compose pull ubuntu-cpp or docker-compose build ubuntu-cpp
-    #   docker-compose run --rm ubuntu-cpp
-    #   or
-    #   docker-compose run -e NUM_THREADS=<NUMBER_OF_THREADS_TO_USE> --rm ubuntu-cpp
-    #   to set the number of threads used during compilation
-    image: ghcr.io/facebookincubator/velox-dev:torcharrow-avx
+  presto-java:
+  # Usage:
+  #   docker-compose pull presto-java or docker-compose build presto-java
+  #   docker-compose run --rm presto-java
+  #   or
+  #   docker-compose run -e NUM_THREADS=<NUMBER_OF_THREADS_TO_USE> --rm presto-java
+  #   to set the number of threads used during compilation
+    image: ghcr.io/facebookincubator/velox-dev:presto-java
+    build:
+      args:
+        - PRESTO_VERSION=0.288
+      context: .
+      dockerfile: scripts/prestojava-container.dockerfile
+    environment:
+      NUM_THREADS: 8 # default value for NUM_THREADS
+      CCACHE_DIR: "/velox/.ccache"
+    volumes:
+      - .:/velox:delegated
+    working_dir: /velox
+    command: /velox/scripts/docker-command.sh
+
+  spark-server:
+  # Usage:
+  #   docker-compose pull spark-server or docker-compose build spark-server
+  #   docker-compose run --rm spark-server
+  #   or
+  #   docker-compose run -e NUM_THREADS=<NUMBER_OF_THREADS_TO_USE> --rm spark-server
+  #   to set the number of threads used during compilation
+    image: ghcr.io/facebookincubator/velox-dev:spark-server
     build:
+      args:
+        - SPARK_VERSION=3.5.1
       context: .
-      dockerfile: scripts/velox-torcharrow-container.dockfile
+      dockerfile: scripts/spark-container.dockerfile
     environment:
-      PYTHON_EXECUTABLE: python3.7
       NUM_THREADS: 8 # default value for NUM_THREADS
       CCACHE_DIR: "/velox/.ccache"
     volumes:
       - .:/velox:delegated
-    command: cd /velox && make python-test
+    working_dir: /velox
+    command: /velox/scripts/docker-command.sh
diff --git a/pyvelox/CMakeLists.txt b/pyvelox/CMakeLists.txt
index 92d4adbef213f..f6fb59151cffe 100644
--- a/pyvelox/CMakeLists.txt
+++ b/pyvelox/CMakeLists.txt
@@ -14,28 +14,30 @@
 
 if(VELOX_BUILD_PYTHON_PACKAGE)
   message("Creating pyvelox module")
-  include_directories(SYSTEM ${CMAKE_SOURCE_DIR})
-  add_definitions(-DCREATE_PYVELOX_MODULE -DVELOX_DISABLE_GOOGLETEST)
   # Define our Python module:
-  pybind11_add_module(pyvelox MODULE pyvelox.cpp serde.cpp signatures.cpp
-                      conversion.cpp)
-  # Link with Velox:
+  pybind11_add_module(
+    pyvelox
+    MODULE
+    complex.cpp
+    conversion.cpp
+    pyvelox.cpp
+    serde.cpp
+    signatures.cpp)
+
   target_link_libraries(
     pyvelox
     PRIVATE velox_type
             velox_vector
             velox_core
             velox_exec
-            velox_functions_prestosql
             velox_parse_parser
             velox_functions_prestosql
-            velox_functions_spark)
+            velox_functions_spark
+            velox_aggregates
+            velox_functions_spark_aggregates)
 
+  target_include_directories(pyvelox SYSTEM
+                             PRIVATE ${CMAKE_CURRENT_LIST_DIR}/..)
+  target_compile_definitions(pyvelox PRIVATE -DCREATE_PYVELOX_MODULE)
   install(TARGETS pyvelox LIBRARY DESTINATION .)
-else()
-  # Torcharrow will not use pyvelox as an extension module for compatibility
-  # reasons.
-  message("Creating pyvelox library")
-  add_library(pyvelox pyvelox.cpp pyvelox.h)
-  target_link_libraries(pyvelox velox_type pybind11::module)
 endif()
diff --git a/pyvelox/complex.cpp b/pyvelox/complex.cpp
new file mode 100644
index 0000000000000..cd401e09cd46b
--- /dev/null
+++ b/pyvelox/complex.cpp
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "complex.h"
+#include "velox/vector/ComplexVector.h"
+
+#include <functional>
+
+namespace facebook::velox::py {
+
+using namespace velox;
+namespace py = pybind11;
+
+namespace {
+// Structure used to keep check on the number
+// of constituent elements. Attributes totalElements
+// and insertedElements keeps the length of the vector, and
+// the number of elements inserted during the operation
+// respectively.
+struct ElementCounter {
+  vector_size_t insertedElements =
+      0; // to track the elements already in the vector
+  vector_size_t totalElements = 0;
+  std::vector<ElementCounter> children;
+};
+} // namespace
+
+void checkOrAssignType(TypePtr& type, const TypePtr& expected_type) {
+  if (type->kind() == TypeKind::UNKNOWN) {
+    type = expected_type;
+  } else if (!(type->kindEquals(expected_type))) {
+    throw py::type_error(
+        "Cannot construct type tree, invalid variant for complex type");
+  }
+}
+
+template <TypeKind Kind>
+void setElementInFlatVector(
+    vector_size_t idx,
+    const variant& v,
+    VectorPtr& vector) {
+  using NativeType = typename TypeTraits<Kind>::NativeType;
+  auto asFlat = vector->asFlatVector<NativeType>();
+  asFlat->set(idx, NativeType{v.value<NativeType>()});
+}
+
+// This function determines the type and the number of elements for a variant.
+// Takes reference to Type and ElementCounter which will be set after the run.
+// It is supposed to run a recursive call with a pre-instantiated TypePtr,
+// the target variant and the counter. The passed variant is checked for its
+// data type, and for any complex type involved, the function is called again.
+// The counter here is used to keep in track of the number of elements inserted
+// and the number of types of elements allowed if a complex vector is involved
+// in the variant.
+void constructType(const variant& v, TypePtr& type, ElementCounter& counter) {
+  ++counter.totalElements;
+
+  if (v.isNull()) {
+    // since the variant is NULL, we can't infer the data type
+    // thus it maybe UNKNOWN or INVALID at this stage
+    // which implies further investigation is required
+    if (v.kind() != TypeKind::UNKNOWN && v.kind() != TypeKind::INVALID &&
+        v.kind() != type->kind()) {
+      throw std::invalid_argument("Variant was of an unexpected kind");
+    }
+    return;
+  } else {
+    // if a Non-Null variant's type is unknown or not one of the valid
+    // types which are supported then the Type tree cannot be constructed
+    if (v.kind() == TypeKind::UNKNOWN || v.kind() == TypeKind::INVALID) {
+      throw std::invalid_argument(
+          "Non-null variant has unknown or invalid kind");
+    }
+
+    switch (v.kind()) {
+      case TypeKind::ARRAY: {
+        counter.children.resize(1);
+        auto asArray = v.array();
+        TypePtr childType = createType(TypeKind::UNKNOWN, {});
+        for (const auto& element : asArray) {
+          constructType(element, childType, counter.children[0]);
+        }
+
+        // if child's type still remains Unknown, implies all the
+        // elements in the array are actually NULL
+        if (childType->kind() == TypeKind::UNKNOWN) {
+          throw py::value_error("Cannot construct array with all None values");
+        }
+        checkOrAssignType(type, createType<TypeKind::ARRAY>({childType}));
+        break;
+      }
+
+      default: {
+        checkOrAssignType(type, createScalarType(v.kind()));
+        break;
+      }
+    }
+  }
+}
+
+// Function is called with the variant to be added,
+// the target vector and the element counter. The element counter
+// is used to track the number of elements already inserted, so as
+// to get the index for the next element to insert. For an array
+// vector, the required offset and size is first set into the vector
+// then the function is called recursively for the contained elements.
+// In the default case where the variant is a scalar type, the
+// setElementInFlatVector is called without any further recursion.
+static void insertVariantIntoVector(
+    const variant& v,
+    VectorPtr& vector,
+    ElementCounter& counter,
+    vector_size_t previous_size,
+    vector_size_t previous_offset) {
+  if (v.isNull()) {
+    vector->setNull(counter.insertedElements, true);
+  } else {
+    switch (v.kind()) {
+      case TypeKind::ARRAY: {
+        auto asArray = vector->as<ArrayVector>();
+        asArray->elements()->resize(counter.children[0].totalElements);
+        const std::vector<variant>& elements = v.array();
+        vector_size_t offset = previous_offset + previous_size;
+        vector_size_t size = elements.size();
+        asArray->setOffsetAndSize(counter.insertedElements, offset, size);
+        for (const variant& elt : elements) {
+          insertVariantIntoVector(
+              elt, asArray->elements(), counter.children[0], offset, size);
+        }
+
+        break;
+      }
+      default: {
+        VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+            setElementInFlatVector,
+            v.kind(),
+            counter.insertedElements,
+            v,
+            vector);
+        break;
+      }
+    }
+  }
+  counter.insertedElements += 1;
+}
+
+VectorPtr variantsToVector(
+    const std::vector<variant>& variants,
+    velox::memory::MemoryPool* pool) {
+  ElementCounter counter;
+  TypePtr type = createType(TypeKind::UNKNOWN, {});
+  for (const auto& variant : variants) {
+    constructType(variant, type, counter);
+  }
+  VectorPtr resultVector =
+      BaseVector::create(std::move(type), variants.size(), pool);
+  for (const variant& v : variants) {
+    insertVariantIntoVector(
+        v,
+        resultVector,
+        counter,
+        /*previous_size*/ 0,
+        /*previous_offset*/ 0);
+  }
+  return resultVector;
+}
+
+} // namespace facebook::velox::py
diff --git a/pyvelox/complex.h b/pyvelox/complex.h
new file mode 100644
index 0000000000000..e8c0217d993f4
--- /dev/null
+++ b/pyvelox/complex.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::py {
+
+VectorPtr variantsToVector(
+    const std::vector<variant>& variants,
+    velox::memory::MemoryPool* pool);
+
+}
diff --git a/pyvelox/context.h b/pyvelox/context.h
index bc154f039f486..ca3c320af4c49 100644
--- a/pyvelox/context.h
+++ b/pyvelox/context.h
@@ -56,9 +56,9 @@ struct PyVeloxContext {
   PyVeloxContext& operator=(const PyVeloxContext&&) = delete;
 
   std::shared_ptr<facebook::velox::memory::MemoryPool> pool_ =
-      facebook::velox::memory::addDefaultLeafMemoryPool();
+      facebook::velox::memory::deprecatedAddDefaultLeafMemoryPool();
   std::shared_ptr<facebook::velox::core::QueryCtx> queryCtx_ =
-      std::make_shared<facebook::velox::core::QueryCtx>();
+      facebook::velox::core::QueryCtx::create();
   std::unique_ptr<facebook::velox::core::ExecCtx> execCtx_ =
       std::make_unique<facebook::velox::core::ExecCtx>(
           pool_.get(),
diff --git a/pyvelox/pyvelox.cpp b/pyvelox/pyvelox.cpp
index 93957c098eebb..8f39fb4b904ef 100644
--- a/pyvelox/pyvelox.cpp
+++ b/pyvelox/pyvelox.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "pyvelox.h"
+#include "complex.h"
 #include "conversion.h"
 #include "serde.h"
 #include "signatures.h"
@@ -36,7 +37,7 @@ static VectorPtr variantToConstantVector(
     facebook::velox::memory::MemoryPool* pool) {
   using NativeType = typename TypeTraits<T>::NativeType;
 
-  TypePtr typePtr = fromKindToScalerType(T);
+  TypePtr typePtr = createScalarType(T);
   if (!variant.hasValue()) {
     return std::make_shared<ConstantVector<NativeType>>(
         pool,
@@ -90,7 +91,7 @@ static VectorPtr variantsToFlatVector(
   constexpr bool kNeedsHolder =
       (T == TypeKind::VARCHAR || T == TypeKind::VARBINARY);
 
-  TypePtr type = fromKindToScalerType(T);
+  TypePtr type = createScalarType(T);
   auto result =
       BaseVector::create<FlatVector<NativeType>>(type, variants.size(), pool);
 
@@ -143,6 +144,8 @@ static VectorPtr pyListToVector(
   if (first_kind == velox::TypeKind::INVALID) {
     throw py::value_error(
         "Can't create a Velox vector consisting of only None");
+  } else if (first_kind == velox::TypeKind::ARRAY) {
+    return variantsToVector(variants, pool);
   }
 
   return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
@@ -164,7 +167,7 @@ static VectorPtr pyListToVector(
 }
 
 template <typename NativeType>
-static py::object getItemFromSimpleVector(
+inline py::object getItemFromSimpleVector(
     SimpleVectorPtr<NativeType>& vector,
     vector_size_t idx) {
   checkBounds(vector, idx);
diff --git a/pyvelox/pyvelox.h b/pyvelox/pyvelox.h
index eb1de36ee9976..975f09c967c1f 100644
--- a/pyvelox/pyvelox.h
+++ b/pyvelox/pyvelox.h
@@ -16,6 +16,9 @@
 
 #pragma once
 
+#include <cassert>
+
+#include <pybind11/functional.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/stl_bind.h>
@@ -27,9 +30,11 @@
 #include <velox/parse/TypeResolver.h>
 #include <velox/type/Type.h>
 #include <velox/type/Variant.h>
+#include <velox/vector/ComplexVector.h>
 #include <velox/vector/DictionaryVector.h>
 #include <velox/vector/FlatVector.h>
 #include "folly/json.h"
+#include "velox/vector/VariantToVector.h"
 
 #include "context.h"
 
@@ -64,6 +69,13 @@ inline velox::variant pyToVariant(const py::handle& obj) {
     return pyToVariant<velox::TypeKind::DOUBLE>(obj);
   } else if (py::isinstance<py::str>(obj)) {
     return pyToVariant<velox::TypeKind::VARCHAR>(obj);
+  } else if (py::isinstance<py::list>(obj)) {
+    py::list objAsList = py::cast<py::list>(obj);
+    std::vector<velox::variant> result;
+    for (auto& item : objAsList) {
+      result.push_back(pyToVariant(item));
+    }
+    return velox::variant::array(std::move(result));
   } else {
     throw py::type_error("Invalid type of object");
   }
@@ -109,6 +121,32 @@ inline velox::variant pyToVariant(const py::handle& obj, const Type& dtype) {
   }
 }
 
+inline void checkRowVectorBounds(const RowVectorPtr& v, vector_size_t idx) {
+  if (idx < 0 || size_t(idx) >= v->childrenSize()) {
+    throw std::out_of_range("Index out of range");
+  }
+}
+
+bool compareRowVector(const RowVectorPtr& u, const RowVectorPtr& v) {
+  CompareFlags compFlags =
+      CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
+
+  if (u->size() != v->size()) {
+    return false;
+  }
+  for (size_t i = 0; i < u->size(); i++) {
+    if (u->compare(v.get(), i, i, compFlags) != 0) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+inline std::string rowVectorToString(const RowVectorPtr& vector) {
+  return vector->toString(0, vector->size());
+}
+
 static VectorPtr pyToConstantVector(
     const py::handle& obj,
     vector_size_t length,
@@ -145,13 +183,13 @@ static VectorPtr createDictionaryVector(
 }
 
 template <typename NativeType>
-static py::object getItemFromSimpleVector(
-    SimpleVectorPtr<NativeType>& vector,
+inline py::object getItemFromSimpleVector(
+    SimpleVectorPtr<NativeType>& v,
     vector_size_t idx);
 
 template <typename NativeType>
 inline void setItemInFlatVector(
-    FlatVectorPtr<NativeType>& vector,
+    FlatVectorPtr<NativeType>& v,
     vector_size_t idx,
     py::handle& obj);
 
@@ -371,7 +409,9 @@ static void registerTypedVectors(
           [](DictionaryVectorPtr<NativeType> vec) {
             return DictionaryIndices{vec->indices()};
           })
-      .def("values", &DictionaryVector<NativeType>::valueVector);
+      .def("values", [](DictionaryVectorPtr<NativeType> vec) {
+        return vec->valueVector();
+      });
 }
 
 static void addVectorBindings(
@@ -434,6 +474,12 @@ static void addVectorBindings(
           py::arg("stop"),
           py::arg("step") = 1);
 
+  py::class_<ArrayVector, ArrayVectorPtr, BaseVector>(
+      m, "ArrayVector", py::module_local(asModuleLocalDefinitions))
+      .def("elements", [](ArrayVectorPtr vec) -> VectorPtr {
+        return vec->elements();
+      });
+
   constexpr TypeKind supportedTypes[] = {
       TypeKind::BOOLEAN,
       TypeKind::TINYINT,
@@ -504,6 +550,75 @@ static void addVectorBindings(
             std::move(baseVector),
             PyVeloxContext::getSingletonInstance().pool());
       });
+
+  m.def(
+      "row_vector",
+      [](std::vector<std::string>& names,
+         std::vector<VectorPtr>& children,
+         const std::optional<py::dict>& nullabilityDict) {
+        if (children.size() == 0 || names.size() == 0) {
+          throw py::value_error("RowVector must have children.");
+        }
+        std::vector<std::shared_ptr<const Type>> childTypes;
+        childTypes.reserve(children.size());
+
+        size_t vectorSize = children[0]->size();
+        for (int i = 0; i < children.size(); i++) {
+          if (i > 0 && children[i]->size() != vectorSize) {
+            PyErr_SetString(PyExc_ValueError, "Each child must have same size");
+            throw py::error_already_set();
+          }
+          childTypes.push_back(children[i]->type());
+        }
+        auto rowType = ROW(std::move(names), std::move(childTypes));
+
+        BufferPtr nullabilityBuffer = nullptr;
+        if (nullabilityDict.has_value()) {
+          auto nullabilityValues = nullabilityDict.value();
+          nullabilityBuffer = AlignedBuffer::allocate<bool>(
+              vectorSize, PyVeloxContext::getSingletonInstance().pool(), true);
+          for (const auto&& item : nullabilityValues) {
+            auto row = item.first;
+            auto nullability = item.second;
+            if (!py::isinstance<py::int_>(row) ||
+                !py::isinstance<py::bool_>(nullability)) {
+              throw py::type_error(
+                  "Nullability must be a dictionary, rowId in int and nullability in boolean.");
+            }
+            int rowId = py::cast<int>(row);
+            if (!(rowId >= 0 && rowId < vectorSize)) {
+              throw py::type_error("Nullability index out of bounds.");
+            }
+            bool nullabilityVal = py::cast<bool>(nullability);
+            bits::setBit(
+                nullabilityBuffer->asMutable<uint64_t>(),
+                rowId,
+                bits::kNull ? nullabilityVal : !nullabilityVal);
+          }
+        }
+
+        return std::make_shared<RowVector>(
+            PyVeloxContext::getSingletonInstance().pool(),
+            rowType,
+            nullabilityBuffer,
+            vectorSize,
+            children);
+      },
+      py::arg("names"),
+      py::arg("children"),
+      py::arg("nullability") = std::nullopt);
+
+  py::class_<RowVector, BaseVector, RowVectorPtr>(
+      m, "RowVector", py::module_local(asModuleLocalDefinitions))
+      .def(
+          "__len__",
+          [](RowVectorPtr& v) {
+            return v->childrenSize() > 0 ? v->childAt(0)->size() : 0;
+          })
+      .def("__str__", [](RowVectorPtr& v) { return rowVectorToString(v); })
+      .def("__eq__", [](RowVectorPtr& u, RowVectorPtr& v) {
+        return compareRowVector(u, v);
+      });
 }
 
 static void addExpressionBindings(
diff --git a/pyvelox/serde.cpp b/pyvelox/serde.cpp
index 19ffde942dd91..64f6ab0be1023 100644
--- a/pyvelox/serde.cpp
+++ b/pyvelox/serde.cpp
@@ -24,7 +24,7 @@ namespace facebook::velox::py {
 namespace py = pybind11;
 
 namespace {
-VectorPtr pyRestoreVectorFromFileHelper(const char* FOLLY_NONNULL filePath) {
+VectorPtr pyRestoreVectorFromFileHelper(const char* filePath) {
   using namespace facebook::velox;
   memory::MemoryPool* pool = PyVeloxContext::getSingletonInstance().pool();
   return restoreVectorFromFile(filePath, pool);
diff --git a/pyvelox/signatures.cpp b/pyvelox/signatures.cpp
index c12912f759040..27b5674f6557f 100644
--- a/pyvelox/signatures.cpp
+++ b/pyvelox/signatures.cpp
@@ -15,9 +15,12 @@
  */
 
 #include "signatures.h" // @manual
+#include "velox/exec/Aggregate.h"
 #include "velox/functions/FunctionRegistry.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/sparksql/Register.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
 
 namespace facebook::velox::py {
 
@@ -31,6 +34,24 @@ void registerSparkFunctions(const std::string& prefix) {
   facebook::velox::functions::sparksql::registerFunctions(prefix);
 }
 
+void registerPrestoAggregateFunctions(const std::string& prefix) {
+  facebook::velox::aggregate::prestosql::registerAllAggregateFunctions(prefix);
+}
+
+void registerSparkAggregateFunctions(const std::string& prefix) {
+  facebook::velox::functions::aggregate::sparksql::registerAggregateFunctions(
+      prefix);
+}
+
+exec::AggregateFunctionSignatureMap getAggregateSignatures() {
+  return exec::getAggregateFunctionSignatures();
+}
+
+void clearAggregateSignatures() {
+  exec::aggregateFunctions().withWLock(
+      [&](auto& aggregateFunctions) { aggregateFunctions.clear(); });
+}
+
 void addSignatureBindings(py::module& m, bool asModuleLocalDefinitions) {
   // TypeSignature
   py::class_<exec::TypeSignature> typeSignature(
@@ -53,6 +74,19 @@ void addSignatureBindings(py::module& m, bool asModuleLocalDefinitions) {
   functionSignature.def(
       "constant_arguments", &exec::FunctionSignature::constantArguments);
 
+  // AggregateFunctionSignature
+  py::class_<
+      exec::AggregateFunctionSignature,
+      std::unique_ptr<exec::AggregateFunctionSignature, py::nodelete>>
+      aggregateFunctionSignature(
+          m,
+          "AggregateFunctionSignature",
+          py::module_local(asModuleLocalDefinitions));
+  aggregateFunctionSignature.def(
+      "__str__", &exec::AggregateFunctionSignature::toString);
+  aggregateFunctionSignature.def(
+      "intermediate_type", &exec::AggregateFunctionSignature::intermediateType);
+
   m.def(
       "clear_signatures",
       &clearFunctionRegistry,
@@ -75,5 +109,28 @@ void addSignatureBindings(py::module& m, bool asModuleLocalDefinitions) {
       &getFunctionSignatures,
       py::return_value_policy::reference,
       "Returns a dictionary of the current signatures.");
+
+  m.def(
+      "register_presto_aggregate_signatures",
+      &registerPrestoAggregateFunctions,
+      "Adds Presto Aggregate signatures to the function registry.",
+      py::arg("prefix") = "");
+
+  m.def(
+      "register_spark_aggregate_signatures",
+      &registerSparkAggregateFunctions,
+      "Adds Spark Aggregate signatures to the function registry.",
+      py::arg("prefix") = "");
+
+  m.def(
+      "get_aggregate_function_signatures",
+      &getAggregateSignatures,
+      py::return_value_policy::reference,
+      "Returns a dictionary of the current aggregate signatures.");
+
+  m.def(
+      "clear_aggregate_signatures",
+      &clearAggregateSignatures,
+      "Clears the Aggregate function registry.");
 }
 } // namespace facebook::velox::py
diff --git a/pyvelox/test/test_signatures.py b/pyvelox/test/test_signatures.py
index 8cefcdd196544..dddb2869537ae 100644
--- a/pyvelox/test/test_signatures.py
+++ b/pyvelox/test/test_signatures.py
@@ -41,9 +41,11 @@ def test_function_signature(self):
         concat_signatures = presto_signatures["concat"]
         self.assertTrue(len(concat_signatures) > 0)
         # Array functions are registered first, then string functions.
+        concat_signatures.sort(key=lambda sig: sig.__str__())
         self.assertEqual(str(concat_signatures[0].return_type()), "array(__user_T1)")
         self.assertEqual(
-            str(concat_signatures[0]), "(array(__user_T1)...) -> array(__user_T1)"
+            str(concat_signatures[0]),
+            "(__user_T1,array(__user_T1)) -> array(__user_T1)",
         )
         self.assertEqual(str(concat_signatures[-1].return_type()), "varchar")
         self.assertEqual(str(concat_signatures[-1]), "(varchar,varchar...) -> varchar")
@@ -62,3 +64,21 @@ def test_function_prefix(self):
 
         concat_signatures = spark_signatures["barconcat"]
         self.assertTrue(len(concat_signatures) > 0)
+
+    def test_aggregate_signatures(self):
+        pv.clear_aggregate_signatures()
+
+        pv.register_presto_aggregate_signatures()
+        presto_agg_signatures = pv.get_aggregate_function_signatures()
+
+        min_signatures = presto_agg_signatures["min"]
+        self.assertTrue(len(min_signatures) > 0)
+
+        max_signatures = presto_agg_signatures["max"]
+        self.assertTrue(len(max_signatures) > 0)
+
+        pv.clear_aggregate_signatures()
+
+        pv.register_spark_aggregate_signatures()
+        spark_agg_signatures = pv.get_aggregate_function_signatures()
+        self.assertTrue(len(spark_agg_signatures) > 0)
diff --git a/pyvelox/test/test_vector.py b/pyvelox/test/test_vector.py
index 482449ed060ca..2e15d4bfca0e9 100644
--- a/pyvelox/test/test_vector.py
+++ b/pyvelox/test/test_vector.py
@@ -156,6 +156,46 @@ def test_dictionary_encoding(self):
             pv.dictionary_vector(pv.from_list([1, 2, 3]), [1, 2, 1000000])
             pv.dictionary_vector(pv.from_list([1, 2, 3]), [0, -1, -2])
 
+    def test_array_vector(self):
+        v1 = pv.from_list([[1, 2, 3], [1, 2, 3]])
+        self.assertTrue(isinstance(v1, pv.ArrayVector))
+        self.assertTrue(isinstance(v1.elements(), pv.FlatVector_BIGINT))
+        self.assertEqual(len(v1), 2)
+        expected_flat = [1, 2, 3, 1, 2, 3]
+        self.assertEqual(len(expected_flat), len(v1.elements()))
+        for i in range(len(expected_flat)):
+            self.assertEqual(expected_flat[i], v1.elements()[i])
+
+        v2 = pv.from_list([[1], [1, 2, None]])
+        self.assertTrue(isinstance(v2, pv.ArrayVector))
+        self.assertTrue(isinstance(v2.elements(), pv.FlatVector_BIGINT))
+        self.assertEqual(len(v2), 2)
+        expected_flat = [1, 1, 2, None]
+        self.assertEqual(len(v2.elements()), len(expected_flat))
+        for i in range(len(expected_flat)):
+            self.assertEqual(expected_flat[i], v2.elements()[i])
+
+        doubleNested = pv.from_list([[[1, 2], [3, None]], [[1], [2]]])
+        self.assertTrue(isinstance(doubleNested, pv.ArrayVector))
+        self.assertTrue(isinstance(doubleNested.elements(), pv.ArrayVector))
+        self.assertEqual(len(doubleNested), 2)
+        elements = doubleNested.elements().elements()
+        self.assertTrue(isinstance(elements, pv.FlatVector_BIGINT))
+        self.assertEqual(len(elements), 6)
+        expected_firstElements = [1, 2, 3, None, 1, 2]
+        self.assertEqual(len(elements), len(expected_firstElements))
+        for i in range(len(expected_firstElements)):
+            self.assertEqual(expected_firstElements[i], elements[i])
+
+        with self.assertRaises(TypeError):
+            a = pv.from_list([[[1, 2], [3, 4]], [[1.1], [2.3]]])
+
+        with self.assertRaises(ValueError):
+            v = pv.from_list([[None], [None, None, None]])
+
+        with self.assertRaises(TypeError):
+            a = pv.from_list([[[1, 2], [3, 4]], [["hello"], ["world"]]])
+
     def test_to_string(self):
         self.assertEqual(
             str(pv.from_list([1, 2, 3])),
@@ -351,3 +391,65 @@ def test_roundtrip_conversion(self):
                 self.assertTrue(velox_vector.dtype(), expected_type)
                 for i in range(0, len(data)):
                     self.assertEqual(velox_vector[i], data[i])
+
+    def test_row_vector_basic(self):
+        vals = [
+            pv.from_list([1, 2, 3]),
+            pv.from_list([4.0, 5.0, 6.0]),
+            pv.from_list(["a", "b", "c"]),
+        ]
+
+        col_names = ["x", "y", "z"]
+        rw = pv.row_vector(col_names, vals)
+        rw_str = str(rw)
+        expected_str = "0: {1, 4, a}\n1: {2, 5, b}\n2: {3, 6, c}"
+        assert expected_str == rw_str
+
+    def test_row_vector_with_nulls(self):
+        vals = [
+            pv.from_list([1, 2, 3, 1, 2]),
+            pv.from_list([4, 5, 6, 4, 5]),
+            pv.from_list([7, 8, 9, 7, 8]),
+            pv.from_list([10, 11, 12, 10, 11]),
+        ]
+
+        col_names = ["a", "b", "c", "d"]
+        rw = pv.row_vector(col_names, vals, {0: True, 2: True})
+        rw_str = str(rw)
+        expected_str = (
+            "0: null\n1: {2, 5, 8, 11}\n2: null\n3: {1, 4, 7, 10}\n4: {2, 5, 8, 11}"
+        )
+        assert expected_str == rw_str
+
+    def test_row_vector_comparison(self):
+        u = [
+            pv.from_list([1, 2, 3]),
+            pv.from_list([7, 4, 9]),
+            pv.from_list([10, 11, 12]),
+        ]
+
+        v = [
+            pv.from_list([1, 2, 3]),
+            pv.from_list([7, 8, 9]),
+            pv.from_list([10, 11, 12]),
+        ]
+
+        w = [
+            pv.from_list([1, 2, 3]),
+            pv.from_list([7, 8, 9]),
+        ]
+
+        u_names = ["a", "b", "c"]
+        w_names = ["x", "y"]
+        u_rw = pv.row_vector(u_names, u)
+        v_rw = pv.row_vector(u_names, v)
+        w_rw = pv.row_vector(w_names, w)
+        y_rw = pv.row_vector(u_names, u)
+        x1_rw = pv.row_vector(u_names, u, {0: True, 2: True})
+        x2_rw = pv.row_vector(u_names, u, {0: True, 2: True})
+
+        assert u_rw != w_rw  # num of children doesn't match
+        assert u_rw != v_rw  # data doesn't match
+        assert u_rw == y_rw  # data match
+        assert x1_rw == x2_rw  # with null
+        assert x1_rw != u_rw  # with and without null
diff --git a/scripts/adapters.dockerfile b/scripts/adapters.dockerfile
new file mode 100644
index 0000000000000..6f8ebc1c95808
--- /dev/null
+++ b/scripts/adapters.dockerfile
@@ -0,0 +1,46 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Build the test and build container for presto_cpp
+ARG image=ghcr.io/facebookincubator/velox-dev:centos9
+FROM $image
+
+COPY scripts/setup-helper-functions.sh /
+COPY scripts/setup-adapters.sh /
+RUN mkdir build && ( cd build &&  source /opt/rh/gcc-toolset-12/enable && \
+    bash /setup-adapters.sh ) && rm -rf build && dnf remove -y conda && dnf clean all
+
+# install miniforge
+RUN curl -L -o /tmp/miniforge.sh https://github.com/conda-forge/miniforge/releases/download/23.11.0-0/Mambaforge-23.11.0-0-Linux-x86_64.sh && \
+    bash /tmp/miniforge.sh -b -p /opt/miniforge && \
+    rm /tmp/miniforge.sh
+ENV PATH=/opt/miniforge/condabin:${PATH} 
+
+# install test dependencies
+RUN mamba create -y --name adapters python=3.8
+SHELL ["mamba", "run", "-n", "adapters", "/bin/bash", "-c"]
+
+RUN pip install https://github.com/googleapis/storage-testbench/archive/refs/tags/v0.36.0.tar.gz
+RUN mamba install -y nodejs
+RUN npm install -g azurite
+
+ENV HADOOP_HOME=/usr/local/hadoop \
+    HADOOP_ROOT_LOGGER="WARN,DRFA" \
+    LC_ALL=C \
+    PATH=/usr/local/hadoop/bin:${PATH} \
+    JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk \
+    PATH=/usr/lib/jvm/java-1.8.0-openjdk/bin:${PATH}
+
+COPY scripts/setup-classpath.sh /
+ENTRYPOINT ["/bin/bash", "-c", "source /set_classpath.sh && source /opt/rh/gcc-toolset-12/enable && exec \"$@\"", "--"]
+CMD ["/bin/bash"]
diff --git a/scripts/benchmark-requirements.txt b/scripts/benchmark-requirements.txt
index bb0bfc7203ff7..3df0a15d0bd45 100644
--- a/scripts/benchmark-requirements.txt
+++ b/scripts/benchmark-requirements.txt
@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-benchadapt@git+https://github.com/conbench/conbench.git@7599305#subdirectory=benchadapt/python
-benchalerts@git+https://github.com/conbench/conbench.git@7599305#subdirectory=benchalerts
-benchclients@git+https://github.com/conbench/conbench.git@7599305#subdirectory=benchclients/python
+benchadapt==2024.3.20
+benchalerts==2024.1.10.1
+benchclients==2024.3.29.1
diff --git a/scripts/bm-report/default.nix b/scripts/bm-report/default.nix
new file mode 100644
index 0000000000000..4267be1044dd4
--- /dev/null
+++ b/scripts/bm-report/default.nix
@@ -0,0 +1,61 @@
+# This file was generated by the {rix} R package v0.6.0 on 2024-05-15
+# with following call:
+# >rix::rix(r_ver = "abd6d48f8c77bea7dc51beb2adfa6ed3950d2585",
+#  > r_pkgs = c("dplyr",
+#  > "prettyunits",
+#  > "ggplot2",
+#  > "gh",
+#  > "gt",
+#  > "hms",
+#  > "jqr",
+#  > "jsonlite",
+#  > "lubridate",
+#  > "memoise",
+#  > "plotly",
+#  > "purrr",
+#  > "remotes"),
+#  > system_pkgs = c("quarto"),
+#  > git_pkgs = list(package_name = "conbenchcoms",
+#  > repo_url = "https://github.com/conbench/conbenchcoms",
+#  > branch_name = "main",
+#  > commit = "55cdb120bbe2c668d3cf8ae543f4922131653645"),
+#  > ide = "other",
+#  > project_path = path_default_nix,
+#  > overwrite = TRUE,
+#  > print = TRUE)
+# It uses nixpkgs' revision abd6d48f8c77bea7dc51beb2adfa6ed3950d2585 for reproducibility purposes
+# which will install R version latest
+# Report any issues to https://github.com/b-rodrigues/rix
+let
+ pkgs = import (fetchTarball "https://github.com/NixOS/nixpkgs/archive/abd6d48f8c77bea7dc51beb2adfa6ed3950d2585.tar.gz") {};
+ rpkgs = builtins.attrValues {
+  inherit (pkgs.rPackages) dplyr prettyunits ggplot2 gh gt hms jqr jsonlite lubridate memoise plotly quarto purrr remotes;
+};
+ git_archive_pkgs = [(pkgs.rPackages.buildRPackage {
+    name = "conbenchcoms";
+    src = pkgs.fetchgit {
+      url = "https://github.com/conbench/conbenchcoms";
+      branchName = "main";
+      rev = "55cdb120bbe2c668d3cf8ae543f4922131653645";
+      sha256 = "sha256-XR5+grCUKyvSxsqiOkKd3gMUsWDJblZDmF4O+Jehq6U=";
+    };
+    propagatedBuildInputs = builtins.attrValues {
+      inherit (pkgs.rPackages) dplyr glue httr2 yaml;
+    };
+  }) ];
+  system_packages = builtins.attrValues {
+  inherit (pkgs) R glibcLocales nix quartoMinimal;
+};
+  in
+  pkgs.mkShell {
+    LOCALE_ARCHIVE = if pkgs.system == "x86_64-linux" then  "${pkgs.glibcLocales}/lib/locale/locale-archive" else "";
+    LANG = "en_US.UTF-8";
+    LC_ALL = "en_US.UTF-8";
+    LC_TIME = "en_US.UTF-8";
+    LC_MONETARY = "en_US.UTF-8";
+    LC_PAPER = "en_US.UTF-8";
+    LC_MEASUREMENT = "en_US.UTF-8";
+
+    buildInputs = [ git_archive_pkgs rpkgs  system_packages  ];
+
+  }
diff --git a/scripts/bm-report/report.qmd b/scripts/bm-report/report.qmd
new file mode 100644
index 0000000000000..bca541e498411
--- /dev/null
+++ b/scripts/bm-report/report.qmd
@@ -0,0 +1,333 @@
+---
+title: "Velox Build Metrics"
+execute:
+  echo: false
+  warning: false
+format:
+  html:
+    grid:
+        sidebar-width: 0px
+        body-width: 1800px
+        margin-width: 150px
+        gutter-width: 1.5rem
+    self-contained: true
+    page-layout: full
+    toc: false
+    margin-left: 30px
+    link-external-newwindow: true
+    theme: cosmo
+---
+
+
+
+
+```{r setup}
+library(gt)
+library(ggplot2)
+library(plotly)
+library(dplyr)
+library(purrr)
+
+# Cache conbench and gh api results for local development
+cd <- cachem::cache_disk(rappdirs::user_cache_dir("velox-bm-report"))
+mgh <- memoise::memoise(gh::gh, cache = cd)
+mruns <- memoise::memoise(conbenchcoms::runs, cache = cd)
+mresults <- memoise::memoise(conbenchcoms::benchmark_results, cache = cd)
+
+# Get latest runs of build-metric job 
+runs <- mgh(
+  "GET /repos/facebookincubator/velox/actions/workflows/build-metrics.yml/runs",
+  status = "success",
+  branch = "main"
+) |> jsonlite::toJSON()
+
+# Extract the commit sha of the most recent run. The results of the latest
+# run are displayed in the tables.
+newest_sha <- runs |>
+  jqr::jq(".workflow_runs | max_by(.updated_at) | .head_sha") |>
+  jsonlite::fromJSON()
+
+run_shas <- runs |>
+  jqr::jq("[.workflow_runs[].head_sha]") |>
+  jsonlite::fromJSON()
+run_ids <- mruns(run_shas) |>
+  filter(commit.branch == "facebookincubator:main", substr(id, 1, 2) == "BM") |>
+  pull(id)
+
+# Fetch the result and do clean/format the data
+results <- run_ids |>
+  purrr::map_df(mresults) |>
+  mutate(
+    timestamp = lubridate::as_datetime(timestamp),
+    stats.data = unlist(stats.data),
+    type = case_when(
+      startsWith(run_id, "BM-debug") ~ "debug",
+      .default = "release"
+    )
+  )
+```
+
+```{r ggplot2-specs}
+theme_set(theme_minimal(base_size = 12) %+replace%
+  theme(
+    plot.title.position = "plot",
+    strip.text = element_text(size = 12)
+  ))
+
+format_tags <- function(x) {
+  x |>
+    stringr::str_replace_all("_", " ") |>
+    stringr::str_to_title()
+}
+```
+
+::::: {.panel-tabset}
+
+## Times
+```{r total-graphs}
+# Filter the data and layout the overview plots
+times_plot <- results |>
+  filter(tags.suite == "total", endsWith(tags.source, "time"), tags.name != "wall_time") |>
+  mutate(
+    stats.data = lubridate::dseconds(stats.data),
+    tags.name = format_tags(tags.name)
+  ) |>
+  ggplot(aes(
+    x = timestamp,
+    y = stats.data,
+    group = interaction(tags.name, type), color = tags.name
+  )) +
+  facet_wrap(~type) +
+  geom_line() +
+  geom_point() +
+  scale_y_time() +
+  scale_x_datetime() +
+  labs(
+    title = "Velox Build Times",
+    x = "Date",
+    y = "Time in Minutes"
+  ) +
+  scale_color_viridis_d()
+ggplotly(times_plot) |>
+  layout(legend = list(title = list(text = "Tags Name<br>"))) ## needed because theme legend specs don't work with ggplotly
+```
+
+```{r expensive-objects-compile}
+# Format compile time data
+compile_times <- results |>
+  filter(tags.suite == "compiling", commit.sha == newest_sha) |>
+  mutate(
+    stats.data = lubridate::dseconds(stats.data),
+    tags.name = glue::glue("`{tags.name}`")
+  )
+```
+
+### Compile Times
+
+:::: {.columns}
+
+::: {.column width="49%"}
+
+```{r compile-times-release}
+# Select and format the data to be displayed in the release compile time table
+compile_times |>
+  filter(type == "release") |>
+  select(tags.name, stats.data) |>
+  arrange(desc(stats.data)) |>
+  gt() |>
+  cols_label(
+    `tags.name` = "Object",
+    `stats.data` = "Time"
+  ) |>
+  cols_align(align = "left", columns = everything()) |>
+  tab_header(title = "Release") |>
+  fmt_markdown(columns = "tags.name") |>
+  opt_interactive(use_page_size_select = TRUE, use_search = TRUE)
+```
+
+:::
+
+::: {.column width="2%"}
+
+:::
+
+::: {.column width="49%"}
+
+```{r compile-times-debug}
+# Select and format the data to be displayed in the debug compile time table
+compile_times |>
+  filter(type == "debug") |>
+  select(tags.name, stats.data) |>
+  arrange(desc(stats.data)) |>
+  gt() |>
+  cols_label(
+    `tags.name` = "Object",
+    `stats.data` = "Time"
+  ) |>
+  cols_align(align = "left", columns = everything()) |>
+  tab_header(title = "Debug") |>
+  fmt_markdown(columns = "tags.name") |>
+  opt_interactive(use_page_size_select = TRUE, use_search = TRUE)
+```
+
+:::
+
+::::
+
+```{r expensive-objects-link}
+# Format linke time data
+link_times <- results |>
+  filter(tags.suite == "linking", commit.sha == newest_sha) |>
+  mutate(
+    stats.data = lubridate::dseconds(stats.data),
+    tags.name = glue::glue("`{tags.name}`")
+  )
+
+```
+
+### Link Times
+
+:::: {.columns}
+
+::: {.column width="49%"}
+
+```{r link-times-release}
+# Select and format the data to be displayed in the release link time table
+link_times |>
+  filter(type == "release") |>
+  select(tags.name, stats.data) |>
+  arrange(desc(stats.data)) |>
+  gt() |>
+  cols_label(
+    `tags.name` = "Object",
+    `stats.data` = "Time"
+  ) |>
+  cols_align(align = "left", columns = everything()) |>
+  tab_header(title = "Release") |>
+  fmt_markdown(columns = "tags.name") |>
+  opt_interactive(use_page_size_select = TRUE, use_search = TRUE)
+```
+
+:::
+
+::: {.column width="2%"}
+
+:::
+
+::: {.column width="49%"}
+
+```{r link-times-debug}
+# Select and format the data to be displayed in the debug link time table
+link_times |>
+  filter(type == "debug") |>
+  select(tags.name, stats.data) |>
+  arrange(desc(stats.data)) |>
+  gt() |>
+  cols_label(
+    `tags.name` = "Object",
+    `stats.data` = "Time"
+  ) |>
+  cols_align(align = "left", columns = everything()) |>
+  tab_header(title = "Link Times - Debug") |>
+  fmt_markdown(columns = "tags.name") |>
+  opt_interactive(use_page_size_select = TRUE, use_search = TRUE)
+```
+
+:::
+
+::::
+
+
+## Sizes
+```{r big-objects}
+# This is converts byte values into human-readable values in the tables
+size_formatter <- function(x) {
+  function(x) {
+    prettyunits::pretty_bytes(x)
+  }
+}
+
+# Prepare object size data
+object_sizes <- results |>
+  filter(endsWith(tags.source, "size"), commit.sha == newest_sha)  |>
+  mutate(
+    tags.name = glue::glue("`{tags.name}`")
+  )
+
+# Filter the data and layout the size overview plots
+sizes_plot <- results |>
+  filter(tags.suite == "executable", startsWith(tags.name, "total_")) |>
+  ggplot(aes(
+    x = timestamp,
+    y = stats.data,
+    group = interaction(tags.name, type), color = tags.name
+  )) +
+  facet_wrap(~type) +
+  geom_line() +
+  geom_point() +
+  scale_y_continuous(labels = size_formatter()) +
+  scale_x_datetime() +
+  labs(
+    title = "Velox Object Sizes",
+    x = "Date",
+    y = "Size"
+  ) +
+  scale_color_viridis_d()
+ggplotly(sizes_plot) |>
+  layout(legend = list(title = list(text = "Tags Name<br>"))) ## needed because theme legend specs don't work with ggplotly
+```
+
+### Object Sizes 
+:::: {.columns}
+
+::: {.column width="49%"}
+
+```{r object-sizes-release}
+# Select and format the data to be displayed in the release size table
+object_sizes |>
+  filter(type == "release") |>
+  select(tags.name, stats.data) |>
+  arrange(desc(stats.data)) |>
+  gt() |>
+  cols_label(
+    `tags.name` = "Object",
+    `stats.data` = "Size"
+  ) |>
+  fmt(columns = `stats.data`, fn = size_formatter()) |>
+  fmt_markdown(columns = "tags.name") |>
+  cols_align(align = "left", columns = everything()) |>
+  tab_header(title = "Release") |>
+  opt_interactive(use_page_size_select = TRUE, use_search = TRUE)
+```
+
+:::
+
+::: {.column width="2%"}
+
+:::
+
+::: {.column width="49%"}
+
+```{r object-sizes-debug}
+# Select and format the data to be displayed in the debug size table
+object_sizes |>
+  filter(type == "debug") |>
+  select(tags.name, stats.data) |>
+  arrange(desc(stats.data)) |>
+  gt() |>
+  fmt(columns = `stats.data`, fn = size_formatter()) |>
+  fmt_markdown(columns = "tags.name") |>
+  cols_label(
+    `tags.name` = "Object",
+    `stats.data` = "Time"
+  ) |>
+  cols_align(align = "left", columns = everything()) |>
+  tab_header(title = "Debug") |>
+  opt_interactive(use_page_size_select = TRUE, use_search = TRUE)
+```
+
+:::
+
+::::
+
+:::::
diff --git a/scripts/build-metrics.py b/scripts/build-metrics.py
new file mode 100755
index 0000000000000..707d81eb6a31b
--- /dev/null
+++ b/scripts/build-metrics.py
@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import sys
+import uuid
+from os.path import join, splitext
+from pathlib import Path
+from typing import Any, Dict, List
+
+from benchadapt import BenchmarkResult
+from benchadapt.adapters import BenchmarkAdapter
+
+
+class BinarySizeAdapter(BenchmarkAdapter):
+    """
+    Adapter to track build artifact sizes in conbench.
+    Expects the `size_file` to be formatted like this:
+    <size in bytes> <path/to/binary|arbitrary_name>
+
+    Suite meta data will be library, object or executable
+    based on file ending.
+    """
+
+    size_file: Path
+
+    def __init__(
+        self,
+        command: List[str],
+        size_file: str,
+        build_type: str,
+        result_fields_override: Dict[str, Any] = {},
+        result_fields_append: Dict[str, Any] = {},
+    ) -> None:
+        self.size_file = Path(size_file)
+        if build_type not in ["debug", "release"]:
+            raise ValueError(f"Build type '{build_type}' is not valid!")
+        self.build_type = build_type
+        super().__init__(command, result_fields_override, result_fields_append)
+
+    def _transform_results(self) -> List[BenchmarkResult]:
+        results = []
+
+        batch_id = uuid.uuid4().hex
+        with open(self.size_file, "r") as file:
+            sizes = [line.strip() for line in file]
+
+        if not sizes:
+            raise ValueError("'size_file' is empty!")
+
+        for line in sizes:
+            size, path = line.split(maxsplit=1)
+            path = path.strip()
+            _, ext = splitext(path)
+            if ext in [".so", ".a"]:
+                suite = "library"
+            elif ext == ".o":
+                suite = "object"
+            else:
+                suite = "executable"
+
+            parsed_size = BenchmarkResult(
+                run_reason="merge",
+                batch_id=batch_id,
+                stats={
+                    "data": [size],
+                    "unit": "B",
+                    "iterations": 1,
+                },
+                tags={
+                    "name": path,
+                    "suite": suite,
+                    "source": f"{self.build_type}_build_metrics_size",
+                },
+                info={},
+                context={"benchmark_language": "C++"},
+            )
+            results.append(parsed_size)
+
+        return results
+
+
+class NinjaLogAdapter(BenchmarkAdapter):
+    """
+    Adapter to extract compile and link times from a .ninja_log.
+    Will calculate aggregates for total, compile and link time.
+    Suite metadata will be set based on binary ending to object, library or executable.
+
+    Only files in paths beginning with velox/ will be tracked to avoid dependencies.
+    """
+
+    ninja_log: Path
+
+    def __init__(
+        self,
+        command: List[str],
+        ninja_log: str,
+        build_type: str,
+        result_fields_override: Dict[str, Any] = {},
+        result_fields_append: Dict[str, Any] = {},
+    ) -> None:
+        self.ninja_log = Path(ninja_log)
+        if build_type not in ["debug", "release"]:
+            raise ValueError(f"Build type '{build_type}' is not valid!")
+        self.build_type = build_type
+        super().__init__(command, result_fields_override, result_fields_append)
+
+    def _transform_results(self) -> List[BenchmarkResult]:
+        results = []
+
+        batch_id = uuid.uuid4().hex
+        with open(self.ninja_log, "r") as file:
+            log_lines = [line.strip() for line in file]
+
+        if not log_lines[0].startswith("# ninja log v"):
+            raise ValueError("Malformed Ninja log found!")
+        else:
+            del log_lines[0]
+
+        ms2sec = lambda x: x / 1000
+        get_epoch = lambda l: int(l.split()[2])
+        totals = {
+            "link_time": 0,
+            "compile_time": 0,
+            "total_time": 0,
+        }
+
+        for line in log_lines:
+            start, end, epoch, object_path, _ = line.split()
+            start = int(start)
+            end = int(end)
+            duration = ms2sec(end - start)
+
+            # Don't track dependency times (refine check potentially?)
+            if not object_path.startswith("velox"):
+                continue
+
+            _, ext = splitext(object_path)
+            if ext in [".so", ".a"] or not ext:
+                totals["link_time"] += duration
+                suite = "linking"
+            elif ext == ".o":
+                totals["compile_time"] += duration
+                suite = "compiling"
+            else:
+                print(f"Unkown file type found: {object_path}")
+                print("Skipping...")
+                continue
+
+            time_result = BenchmarkResult(
+                run_reason="merge",
+                batch_id=batch_id,
+                stats={
+                    "data": [duration],
+                    "unit": "s",
+                    "iterations": 1,
+                },
+                tags={
+                    "name": object_path,
+                    "suite": suite,
+                    "source": f"{self.build_type}_build_metrics_time",
+                },
+                info={},
+                context={"benchmark_language": "C++"},
+            )
+            results.append(time_result)
+
+        totals["total_time"] = totals["link_time"] + totals["compile_time"]
+        for total_name, total in totals.items():
+            total_result = BenchmarkResult(
+                run_reason="merge",
+                batch_id=batch_id,
+                stats={
+                    "data": [total],
+                    "unit": "s",
+                    "iterations": 1,
+                },
+                tags={
+                    "name": total_name,
+                    "suite": "total",
+                    "source": f"{self.build_type}_build_metrics_time",
+                },
+                info={},
+                context={"benchmark_language": "C++"},
+            )
+            results.append(total_result)
+
+        return results
+
+
+# find velox -type f -name '*.o' -exec ls -l -BB {} \; | awk '{print $5, $9}' |  sed 's|CMakeFiles/.*dir/||g' > /tmp/object-size
+
+
+def upload(args):
+    print("Uploading Build Metrics")
+    pr_number = int(args.pr_number) if args.pr_number else None
+    run_reason = "pull request" if pr_number else "commit"
+    run_name = f"{run_reason}: {args.sha}"
+    sizes = BinarySizeAdapter(
+        command=["true"],
+        size_file=join(args.base_path, args.size_file),
+        build_type=args.build_type,
+        result_fields_override={
+            "run_id": args.run_id,
+            "run_name": run_name,
+            "run_reason": run_reason,
+            "github": {
+                "repository": "https://github.com/facebookincubator/velox",
+                "pr_number": pr_number,
+                "commit": args.sha,
+            },
+        },
+    )
+    sizes()
+
+    times = NinjaLogAdapter(
+        command=["true"],
+        ninja_log=join(args.base_path, args.ninja_log),
+        build_type=args.build_type,
+        result_fields_override={
+            "run_id": args.run_id,
+            "run_name": run_name,
+            "run_reason": run_reason,
+            "github": {
+                "repository": "https://github.com/facebookincubator/velox",
+                "pr_number": pr_number,
+                "commit": args.sha,
+            },
+        },
+    )
+    times()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Velox Build Metric Utility.")
+    parser.set_defaults(func=lambda _: parser.print_help())
+
+    subparsers = parser.add_subparsers(help="Please specify one of the subcommands.")
+
+    upload_parser = subparsers.add_parser(
+        "upload", help="Parse and upload build metrics"
+    )
+    upload_parser.set_defaults(func=upload)
+    upload_parser.add_argument(
+        "--ninja_log", default=".ninja_log", help="Name of the ninja log file."
+    )
+    upload_parser.add_argument(
+        "--size_file",
+        default="object_sizes",
+        help="Name of the file containing size information.",
+    )
+    upload_parser.add_argument(
+        "--build_type",
+        required=True,
+        help="Type of build results come from, e.g. debug or release",
+    )
+    upload_parser.add_argument(
+        "--run_id",
+        required=True,
+        help="A Conbench run ID unique to this build.",
+    )
+    upload_parser.add_argument(
+        "--sha",
+        required=True,
+        help="HEAD sha for the result upload to conbench.",
+    )
+    upload_parser.add_argument(
+        "--pr_number",
+        default=0,
+        help="PR number for the result upload to conbench.",
+    )
+    upload_parser.add_argument(
+        "base_path",
+        help="Path in which the .ninja_log and sizes_file are found.",
+    )
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    args.func(args)
diff --git a/scripts/centos-8-stream.dockerfile b/scripts/centos-8-stream.dockerfile
deleted file mode 100644
index a6a4531c8ef8c..0000000000000
--- a/scripts/centos-8-stream.dockerfile
+++ /dev/null
@@ -1,22 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Build the test and build container for presto_cpp
-#
-FROM quay.io/centos/centos:stream8
-
-ADD scripts /velox/scripts/
-RUN /velox/scripts/setup-centos8.sh
-
-WORKDIR /velox
-
diff --git a/scripts/centos.dockerfile b/scripts/centos.dockerfile
new file mode 100644
index 0000000000000..50a18e9a7243e
--- /dev/null
+++ b/scripts/centos.dockerfile
@@ -0,0 +1,32 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Build the test and build container for presto_cpp
+ARG image=quay.io/centos/centos:stream9
+FROM $image
+
+COPY scripts/setup-helper-functions.sh /
+COPY scripts/setup-centos9.sh /
+# The removal of the build dir has to happen in the same layer as the build
+# to minimize the image size. gh & jq are required for CI
+RUN mkdir build && ( cd build && bash /setup-centos9.sh ) && rm -rf build && \
+        dnf install -y -q 'dnf-command(config-manager)' && \
+        dnf config-manager --add-repo 'https://cli.github.com/packages/rpm/gh-cli.repo' && \
+        dnf install -y -q gh jq && \
+        dnf clean all
+
+ENV CC=/opt/rh/gcc-toolset-12/root/bin/gcc \
+    CXX=/opt/rh/gcc-toolset-12/root/bin/g++
+
+ENTRYPOINT ["/bin/bash", "-c", "source /opt/rh/gcc-toolset-12/enable && exec \"$@\"", "--"]
+CMD ["/bin/bash"]
diff --git a/scripts/check-container.dockfile b/scripts/check-container.dockfile
index d5f1ba4c873e4..9240a97dcd8c1 100644
--- a/scripts/check-container.dockfile
+++ b/scripts/check-container.dockfile
@@ -11,8 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-FROM amd64/ubuntu:22.04
-ARG cpu_target
-COPY setup-check.sh /root
-COPY setup-helper-functions.sh /
-RUN CPU_TARGET="$cpu_target" bash /root/setup-check.sh
+FROM amd64/ubuntu:24.04
+COPY scripts/setup-check.sh /root
+COPY scripts/setup-helper-functions.sh /
+RUN bash /root/setup-check.sh
diff --git a/scripts/check.py b/scripts/check.py
index f76f130533f77..bd47ecd5324f1 100755
--- a/scripts/check.py
+++ b/scripts/check.py
@@ -63,6 +63,15 @@ def fix(self, commit):
 
 
 class CMakeFormatter(str):
+    def __init__(self, commit) -> None:
+        super().__init__()
+        try:
+            import yaml
+        except ModuleNotFoundError:
+            # We need pyyaml so cmake-format can read '.cmake-format.yml'
+            # otherwise it will run with default
+            raise SystemExit("Please install 'pyyaml' for the CMake formatter.")
+
     def diff(self, commit):
         return get_diff(
             self, util.run(f"cmake-format --first-comment-is-literal True {self}")[1]
@@ -185,13 +194,16 @@ def get_files(commit, path):
 
     if commit != "":
         status, stdout, stderr = util.run(
-            f"git diff --relative --name-only --diff-filter='ACM' {commit}"
+            f"git diff --relative --name-only --diff-filter='ACMR' {commit}"
         )
         filelist = stdout.splitlines()
     else:
-        for root, dirs, files in os.walk(path):
-            for name in files:
-                filelist.append(os.path.join(root, name))
+        if os.path.isfile(path):
+            filelist.append(path)
+        else:
+            for root, dirs, files in os.walk(path):
+                for name in files:
+                    filelist.append(os.path.join(root, name))
 
     return [
         file
@@ -201,6 +213,7 @@ def get_files(commit, path):
         and "build/fbcode_builder" not in file
         and "build/deps" not in file
         and "cmake-build-debug" not in file
+        and "NOTICE.txt" != file
     ]
 
 
diff --git a/scripts/circleci-container.dockfile b/scripts/circleci-container.dockfile
deleted file mode 100644
index 3c9152d7e7eb9..0000000000000
--- a/scripts/circleci-container.dockfile
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Build the test and build container for presto_cpp
-#
-FROM quay.io/centos/centos:stream8
-ARG cpu_target
-COPY setup-circleci.sh /
-COPY setup-helper-functions.sh /
-RUN mkdir build && ( cd build && CPU_TARGET="$cpu_target" bash /setup-circleci.sh ) && rm -rf build
diff --git a/scripts/docker-command.sh b/scripts/docker-command.sh
index 4c340351313b8..8abc2af301885 100755
--- a/scripts/docker-command.sh
+++ b/scripts/docker-command.sh
@@ -16,4 +16,4 @@
 set -eu
 # Compilation and testing
 make
-cd _build/release && ctest -j${NUM_THREADS} -VV --output-on-failure
+cd _build/release && ctest -j${NUM_THREADS} --output-on-failure --no-tests=error
diff --git a/scripts/gen-docs.sh b/scripts/gen-docs.sh
deleted file mode 100755
index 4b40dda01a7c6..0000000000000
--- a/scripts/gen-docs.sh
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/bin/bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Generate Documentation
-# **NOTE**
-# ********
-# scripts assume there is a conda environment already
-# created with the name as an argument to the script
-# Example
-#   Create Environment
-#       `conda create -y --name pyveloxenv-docs python=3.7`
-DOCS_CONDA_ENV=$1
-ENVS=$(conda env list | grep $DOCS_CONDA_ENV)
-if [ -z "$ENVS" ]
-then
-        echo "conda environment for documentation not available"
-else
-        echo "Installing doc generation dependencies..."
-        source ${CONDA_PREFIX}/etc/profile.d/conda.sh
-        conda activate ${DOCS_CONDA_ENV}
-        conda install -y -c anaconda sphinx
-        conda install -y -c conda-forge pandoc
-        ## install Pyvelox
-        LD_LIBRARY_PATH=/usr/local/lib make python-build
-        ## generate the Python README
-        cd velox/docs \
-                && make clean \
-                && mkdir -p bindings/python \
-                && pandoc ../../pyvelox/README.md --from markdown --to rst -s -o bindings/python/README_generated_pyvelox.rst \
-                && make html
-fi
diff --git a/.circleci/hdfs-client.xml b/scripts/hdfs-client.xml
similarity index 100%
rename from .circleci/hdfs-client.xml
rename to scripts/hdfs-client.xml
diff --git a/scripts/presto/etc/config.properties.example b/scripts/presto/etc/config.properties.example
new file mode 100644
index 0000000000000..1639cec2fe979
--- /dev/null
+++ b/scripts/presto/etc/config.properties.example
@@ -0,0 +1,5 @@
+coordinator=true
+node-scheduler.include-coordinator=true
+http-server.http.port=8080
+discovery-server.enabled=true
+discovery.uri=http://localhost:8080
diff --git a/scripts/presto/etc/hive.properties b/scripts/presto/etc/hive.properties
new file mode 100644
index 0000000000000..e9a0d05c76a77
--- /dev/null
+++ b/scripts/presto/etc/hive.properties
@@ -0,0 +1,4 @@
+connector.name=hive-hadoop2
+hive.metastore=file
+hive.metastore.catalog.dir=file:/opt/presto-server/etc/data
+hive.allow-drop-table=true
\ No newline at end of file
diff --git a/scripts/presto/etc/jvm.config.example b/scripts/presto/etc/jvm.config.example
new file mode 100644
index 0000000000000..3005c82637f8d
--- /dev/null
+++ b/scripts/presto/etc/jvm.config.example
@@ -0,0 +1,10 @@
+-server
+-Xmx10G
+-XX:+UseG1GC
+-XX:G1HeapRegionSize=32M
+-XX:+UseGCOverheadLimit
+-XX:+ExplicitGCInvokesConcurrent
+-XX:+HeapDumpOnOutOfMemoryError
+-XX:+ExitOnOutOfMemoryError
+-Djdk.attach.allowAttachSelf=true
+-Duser.timezone=America/Los_Angeles
diff --git a/scripts/presto/etc/node.properties b/scripts/presto/etc/node.properties
new file mode 100644
index 0000000000000..9aeda0213159b
--- /dev/null
+++ b/scripts/presto/etc/node.properties
@@ -0,0 +1,3 @@
+node.environment=production
+node.id=ffffffff-ffff-ffff-ffff-ffffffffffff
+node.data-dir=/tmp/presto/data
diff --git a/scripts/presto/start-prestojava.sh b/scripts/presto/start-prestojava.sh
new file mode 100755
index 0000000000000..290e43af8afe7
--- /dev/null
+++ b/scripts/presto/start-prestojava.sh
@@ -0,0 +1,19 @@
+#!/bin/sh
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -e
+
+"$PRESTO_HOME"/bin/launcher --pid-file=/tmp/pidfile  run
+
diff --git a/scripts/prestojava-container.dockerfile b/scripts/prestojava-container.dockerfile
new file mode 100644
index 0000000000000..7ef27c6f68a51
--- /dev/null
+++ b/scripts/prestojava-container.dockerfile
@@ -0,0 +1,51 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Build the test and build container for presto_cpp
+#
+FROM ghcr.io/facebookincubator/velox-dev:centos9 
+
+ARG PRESTO_VERSION=0.288
+
+ADD scripts /velox/scripts/
+RUN wget https://repo1.maven.org/maven2/com/facebook/presto/presto-server/${PRESTO_VERSION}/presto-server-${PRESTO_VERSION}.tar.gz
+RUN wget https://repo1.maven.org/maven2/com/facebook/presto/presto-cli/${PRESTO_VERSION}/presto-cli-${PRESTO_VERSION}-executable.jar
+
+ARG PRESTO_PKG=presto-server-$PRESTO_VERSION.tar.gz
+ARG PRESTO_CLI_JAR=presto-cli-$PRESTO_VERSION-executable.jar
+
+ENV PRESTO_HOME="/opt/presto-server"
+RUN cp $PRESTO_CLI_JAR /opt/presto-cli
+
+RUN dnf install -y java-11-openjdk less procps python3 tzdata \
+    && ln -s $(which python3) /usr/bin/python \
+    && tar -zxf $PRESTO_PKG \
+    && mv ./presto-server-$PRESTO_VERSION $PRESTO_HOME \
+    && chmod +x /opt/presto-cli \
+    && ln -s /opt/presto-cli /usr/local/bin/ \
+    && mkdir -p $PRESTO_HOME/etc \
+    && mkdir -p $PRESTO_HOME/etc/catalog \
+    && mkdir -p $PRESTO_HOME/etc/data \
+    && mkdir -p /usr/lib/presto/utils
+
+# We set the timezone to America/Los_Angeles due to issue
+# detailed here : https://github.com/facebookincubator/velox/issues/8127
+ENV TZ=America/Los_Angeles
+
+COPY scripts/presto/etc/config.properties.example $PRESTO_HOME/etc/config.properties
+COPY scripts/presto/etc/jvm.config.example $PRESTO_HOME/etc/jvm.config
+COPY scripts/presto/etc/node.properties $PRESTO_HOME/etc/node.properties
+COPY scripts/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
+COPY scripts/presto/start-prestojava.sh /opt
+
+WORKDIR /velox
diff --git a/scripts/setup-adapters.sh b/scripts/setup-adapters.sh
index 5bc9c81e4605f..4fed3cdced9a1 100755
--- a/scripts/setup-adapters.sh
+++ b/scripts/setup-adapters.sh
@@ -21,14 +21,39 @@ set -eufx -o pipefail
 
 SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
 source $SCRIPTDIR/setup-helper-functions.sh
-DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)}
+DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)/deps-download}
+CMAKE_BUILD_TYPE="${BUILD_TYPE:-Release}"
+MACHINE=$(uname -m)
 
-function install_aws-sdk-cpp {
+if [[ "$OSTYPE" == darwin* ]]; then
+  export INSTALL_PREFIX=${INSTALL_PREFIX:-"$(pwd)/deps-install"}
+fi
+
+function install_aws_deps {
   local AWS_REPO_NAME="aws/aws-sdk-cpp"
-  local AWS_SDK_VERSION="1.10.57"
+  local AWS_SDK_VERSION="1.11.321"
 
   github_checkout $AWS_REPO_NAME $AWS_SDK_VERSION --depth 1 --recurse-submodules
-  cmake_install -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS:BOOL=OFF -DMINIMIZE_SIZE:BOOL=ON -DENABLE_TESTING:BOOL=OFF -DBUILD_ONLY:STRING="s3;identity-management"
+  cmake_install -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS:BOOL=OFF -DMINIMIZE_SIZE:BOOL=ON -DENABLE_TESTING:BOOL=OFF -DBUILD_ONLY:STRING="s3;identity-management"
+  # Dependencies for S3 testing
+  # We need this specific version of Minio for testing.
+  local MINIO_ARCH=$MACHINE
+  if [[ $MACHINE == aarch64 ]]; then
+    MINIO_ARCH="arm64"
+  elif [[ $MACHINE == x86_64 ]]; then
+    MINIO_ARCH="amd64"
+  fi
+  local MINIO_BINARY="minio-2022-05-26"
+  if [ ! -f /usr/local/bin/${MINIO_BINARY} ]; then
+    local MINIO_OS="linux"
+    if [[ "$OSTYPE" == darwin* ]]; then
+      # minio will have to approved under the Privacy & Security on MacOS on first use.
+      MINIO_OS="darwin"
+    fi
+    wget https://dl.min.io/server/minio/release/${MINIO_OS}-${MINIO_ARCH}/archive/minio.RELEASE.2022-05-26T05-48-41Z -O ${MINIO_BINARY}
+    chmod +x ./${MINIO_BINARY}
+    mv ./${MINIO_BINARY} /usr/local/bin/
+  fi
 }
 
 function install_gcs-sdk-cpp {
@@ -36,95 +61,132 @@ function install_gcs-sdk-cpp {
   # https://github.com/googleapis/google-cloud-cpp/blob/main/doc/packaging.md#required-libraries
 
   # abseil-cpp
-  github_checkout abseil/abseil-cpp 20230125.3 --depth 1
-  sed -i 's/^#define ABSL_OPTION_USE_\(.*\) 2/#define ABSL_OPTION_USE_\1 0/' "absl/base/options.h"
-  cmake_install -DBUILD_SHARED_LIBS=OFF \
-    -DABSL_BUILD_TESTING=OFF
+  github_checkout abseil/abseil-cpp 20240116.2 --depth 1
+  cmake_install \
+    -DABSL_BUILD_TESTING=OFF \
+    -DCMAKE_CXX_STANDARD=17 \
+    -DABSL_PROPAGATE_CXX_STD=ON \
+    -DABSL_ENABLE_INSTALL=ON
+
+  # protobuf
+  github_checkout protocolbuffers/protobuf v21.8 --depth 1
+  cmake_install \
+    -Dprotobuf_BUILD_TESTS=OFF \
+    -Dprotobuf_ABSL_PROVIDER=package
+
+  # grpc
+  github_checkout grpc/grpc v1.48.1 --depth 1
+  cmake_install \
+    -DgRPC_BUILD_TESTS=OFF \
+    -DgRPC_ABSL_PROVIDER=package \
+    -DgRPC_ZLIB_PROVIDER=package \
+    -DgRPC_CARES_PROVIDER=package \
+    -DgRPC_RE2_PROVIDER=package \
+    -DgRPC_SSL_PROVIDER=package \
+    -DgRPC_PROTOBUF_PROVIDER=package \
+    -DgRPC_INSTALL=ON
 
   # crc32
   github_checkout google/crc32c 1.1.2 --depth 1
-  cmake_install -DBUILD_SHARED_LIBS=OFF \
+  cmake_install \
     -DCRC32C_BUILD_TESTS=OFF \
     -DCRC32C_BUILD_BENCHMARKS=OFF \
     -DCRC32C_USE_GLOG=OFF
 
   # nlohmann json
-  github_checkout nlohmann/json v3.11.2 --depth 1
-  cmake_install -DBUILD_SHARED_LIBS=OFF \
+  github_checkout nlohmann/json v3.11.3 --depth 1
+  cmake_install \
     -DJSON_BuildTests=OFF
 
   # google-cloud-cpp
-  github_checkout googleapis/google-cloud-cpp v2.10.1 --depth 1
-  cmake_install -DBUILD_SHARED_LIBS=OFF \
-    -DCMAKE_INSTALL_MESSAGE=NEVER \
+  github_checkout googleapis/google-cloud-cpp v2.22.0 --depth 1
+  cmake_install \
     -DGOOGLE_CLOUD_CPP_ENABLE_EXAMPLES=OFF \
     -DGOOGLE_CLOUD_CPP_ENABLE=storage
 }
 
 function install_azure-storage-sdk-cpp {
-  github_checkout azure/azure-sdk-for-cpp azure-storage-blobs_12.8.0
-
-  cd sdk/core/azure-core
-  if ! grep -q "baseline" vcpkg.json; then
+  # Disable VCPKG to install additional static dependencies under the VCPKG installed path
+  # instead of using system pre-installed dependencies.
+  export AZURE_SDK_DISABLE_AUTO_VCPKG=ON
+  vcpkg_commit_id=7a6f366cefd27210f6a8309aed10c31104436509
+  github_checkout azure/azure-sdk-for-cpp azure-storage-files-datalake_12.8.0
+  sed -i "s/set(VCPKG_COMMIT_STRING .*)/set(VCPKG_COMMIT_STRING $vcpkg_commit_id)/" cmake-modules/AzureVcpkg.cmake
+
+  azure_core_dir="sdk/core/azure-core"
+  if ! grep -q "baseline" $azure_core_dir/vcpkg.json; then
     # build and install azure-core with the version compatible with system pre-installed openssl
     openssl_version=$(openssl version -v | awk '{print $2}')
     if [[ "$openssl_version" == 1.1.1* ]]; then
       openssl_version="1.1.1n"
     fi
-    sed -i 's/"version-string"/"builtin-baseline": "dafef74af53669ef1cc9015f55e0ce809ead62aa","version-string"/' vcpkg.json
-    sed -i "s/\"version-string\"/\"overrides\": [{ \"name\": \"openssl\", \"version-string\": \"$openssl_version\" }],\"version-string\"/" vcpkg.json
+    sed -i "s/\"version-string\"/\"builtin-baseline\": \"$vcpkg_commit_id\",\"version-string\"/" $azure_core_dir/vcpkg.json
+    sed -i "s/\"version-string\"/\"overrides\": [{ \"name\": \"openssl\", \"version-string\": \"$openssl_version\" }],\"version-string\"/" $azure_core_dir/vcpkg.json
   fi
-  cmake_install -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF
-
-  cd -
+  (
+    cd $azure_core_dir 
+    cmake_install -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF
+  )
   # install azure-storage-common
-  cd sdk/storage/azure-storage-common
-  cmake_install -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF
+  (
+    cd sdk/storage/azure-storage-common
+    cmake_install -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF
+  )
 
-  cd -
   # install azure-storage-blobs
-  cd sdk/storage/azure-storage-blobs
-  if ! grep -q "baseline" vcpkg.json; then
-    sed -i 's/"version-semver"/"builtin-baseline": "dafef74af53669ef1cc9015f55e0ce809ead62aa","version-semver"/' vcpkg.json
-  fi
-  cmake_install -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF
+  (
+    cd sdk/storage/azure-storage-blobs
+    cmake_install -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF
+  )
+  # install azure-storage-files-datalake
+  (
+    cd sdk/storage/azure-storage-files-datalake
+    cmake_install -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF
+  )
 }
 
-function install_libhdfs3 {
+function install_hdfs_deps {
   github_checkout apache/hawq master
-  cd $DEPENDENCY_DIR/hawq/depends/libhdfs3
+  libhdfs3_dir=hawq/depends/libhdfs3
   if [[ "$OSTYPE" == darwin* ]]; then
-     sed -i '' -e "/FIND_PACKAGE(GoogleTest REQUIRED)/d" ./CMakeLists.txt
-     sed -i '' -e "s/dumpversion/dumpfullversion/" ./CMakeLists.txt
+     sed -i '' -e "/FIND_PACKAGE(GoogleTest REQUIRED)/d" $DEPENDENCY_DIR/$libhdfs3_dir/CMakeLists.txt
+     sed -i '' -e "s/dumpversion/dumpfullversion/" $DEPENDENCY_DIR/$libhdfs3_dir/CMakeLists.txt
   fi
 
   if [[ "$OSTYPE" == linux-gnu* ]]; then
-    sed -i "/FIND_PACKAGE(GoogleTest REQUIRED)/d" ./CMakeLists.txt
-    sed -i "s/dumpversion/dumpfullversion/" ./CMake/Platform.cmake
+    sed -i "/FIND_PACKAGE(GoogleTest REQUIRED)/d" $DEPENDENCY_DIR/$libhdfs3_dir/CMakeLists.txt
+    sed -i "s/dumpversion/dumpfullversion/" $DEPENDENCY_DIR/$libhdfs3_dir/CMake/Platform.cmake
+    # Dependencies for Hadoop testing
+    wget_and_untar https://archive.apache.org/dist/hadoop/common/hadoop-3.3.0/hadoop-3.3.0.tar.gz hadoop
+    cp -a ${DEPENDENCY_DIR}/hadoop /usr/local/
+    wget -P /usr/local/hadoop/share/hadoop/common/lib/ https://repo1.maven.org/maven2/junit/junit/4.11/junit-4.11.jar
+
+    yum install -y java-1.8.0-openjdk-devel
+    
   fi
-  cmake_install
+  cmake_install_dir $libhdfs3_dir
 }
 
-cd "${DEPENDENCY_DIR}" || exit
+(mkdir -p "${DEPENDENCY_DIR}") || exit
 # aws-sdk-cpp missing dependencies
 
 if [[ "$OSTYPE" == "linux-gnu"* ]]; then
    # /etc/os-release is a standard way to query various distribution
    # information and is available everywhere
    LINUX_DISTRIBUTION=$(. /etc/os-release && echo ${ID})
-   if [[ "$LINUX_DISTRIBUTION" == "ubuntu" ]]; then
+   if [[ "$LINUX_DISTRIBUTION" == "ubuntu" || "$LINUX_DISTRIBUTION" == "debian" ]]; then
       apt install -y --no-install-recommends libxml2-dev libgsasl7-dev uuid-dev
       # Dependencies of GCS, probably a workaround until the docker image is rebuilt
       apt install -y --no-install-recommends libc-ares-dev libcurl4-openssl-dev
       # Dependencies of Azure Storage Blob cpp
       apt install -y openssl
    else # Assume Fedora/CentOS
-      yum -y install libxml2-devel libgsasl-devel libuuid-devel
+      dnf -y install libxml2-devel libgsasl-devel libuuid-devel krb5-devel
       # Dependencies of GCS, probably a workaround until the docker image is rebuilt
-      yum -y install curl-devel c-ares-devel
+      dnf -y install npm curl-devel c-ares-devel
       # Dependencies of Azure Storage Blob Cpp
-      yum -y install perl-IPC-Cmd
-      yum -y install openssl
+      dnf -y install perl-IPC-Cmd
+      dnf -y install openssl
    fi
 fi
 
@@ -174,10 +236,10 @@ if [ $install_gcs -eq 1 ]; then
   install_gcs-sdk-cpp
 fi
 if [ $install_aws -eq 1 ]; then
-  install_aws-sdk-cpp
+  install_aws_deps
 fi
 if [ $install_hdfs -eq 1 ]; then
-  install_libhdfs3
+  install_hdfs_deps
 fi
 if [ $install_abfs -eq 1 ]; then
   install_azure-storage-sdk-cpp
diff --git a/scripts/setup-centos8.sh b/scripts/setup-centos8.sh
deleted file mode 100755
index fe6042301d8fb..0000000000000
--- a/scripts/setup-centos8.sh
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/bin/bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set -efx -o pipefail
-# Some of the packages must be build with the same compiler flags
-# so that some low level types are the same size. Also, disable warnings.
-SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
-source $SCRIPTDIR/setup-helper-functions.sh
-CPU_TARGET="${CPU_TARGET:-avx}"
-NPROC=$(getconf _NPROCESSORS_ONLN)
-export CFLAGS=$(get_cxx_flags $CPU_TARGET)  # Used by LZO.
-export CXXFLAGS=$CFLAGS  # Used by boost.
-export CPPFLAGS=$CFLAGS  # Used by LZO.
-
-function dnf_install {
-  dnf install -y -q --setopt=install_weak_deps=False "$@"
-}
-
-dnf_install epel-release dnf-plugins-core # For ccache, ninja
-dnf config-manager --set-enabled powertools
-dnf_install ninja-build ccache gcc-toolset-9 git wget which libevent-devel \
-  openssl-devel re2-devel libzstd-devel lz4-devel double-conversion-devel \
-  libdwarf-devel curl-devel cmake libicu-devel
-
-dnf remove -y gflags
-
-# Required for Thrift
-dnf_install autoconf automake libtool bison flex python3
-
-# Required for google-cloud-storage
-dnf_install curl-devel c-ares-devel
-
-dnf_install conda
-
-# Activate gcc9; enable errors on unset variables afterwards.
-source /opt/rh/gcc-toolset-9/enable || exit 1
-set -u
-
-function cmake_install_deps {
-  cmake -B "$1-build" -GNinja -DCMAKE_CXX_STANDARD=17 \
-    -DCMAKE_CXX_FLAGS="${CFLAGS}" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_BUILD_TYPE=Release -Wno-dev "$@"
-  ninja -C "$1-build" install
-}
-
-function wget_and_untar {
-  local URL=$1
-  local DIR=$2
-  mkdir -p "${DIR}"
-  wget -q --max-redirect 3 -O - "${URL}" | tar -xz -C "${DIR}" --strip-components=1
-}
-
-
-# Fetch sources.
-wget_and_untar https://github.com/gflags/gflags/archive/v2.2.2.tar.gz gflags &
-wget_and_untar https://github.com/google/glog/archive/v0.4.0.tar.gz glog &
-wget_and_untar http://www.oberhumer.com/opensource/lzo/download/lzo-2.10.tar.gz lzo &
-wget_and_untar https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.gz boost &
-wget_and_untar https://github.com/google/snappy/archive/1.1.8.tar.gz snappy &
-wget_and_untar https://github.com/fmtlib/fmt/archive/8.0.1.tar.gz fmt &
-
-wait  # For cmake and source downloads to complete.
-
-# Build & install.
-(
-  cd lzo
-  ./configure --prefix=/usr --enable-shared --disable-static --docdir=/usr/share/doc/lzo-2.10
-  make "-j$(nproc)"
-  make install
-)
-
-(
-  cd boost
-  ./bootstrap.sh --prefix=/usr/local
-  ./b2 "-j$(nproc)" -d0 install threading=multi
-)
-
-cmake_install_deps gflags -DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=ON -DBUILD_gflags_LIB=ON -DLIB_SUFFIX=64 -DCMAKE_INSTALL_PREFIX:PATH=/usr
-cmake_install_deps glog -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=/usr
-cmake_install_deps snappy -DSNAPPY_BUILD_TESTS=OFF
-cmake_install_deps fmt -DFMT_TEST=OFF
-
-dnf clean all
diff --git a/scripts/setup-centos9.sh b/scripts/setup-centos9.sh
new file mode 100755
index 0000000000000..1efb8e53ec34e
--- /dev/null
+++ b/scripts/setup-centos9.sh
@@ -0,0 +1,281 @@
+#!/bin/bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This script documents setting up a Centos9 host for Velox
+# development.  Running it should make you ready to compile.
+#
+# Environment variables:
+# * INSTALL_PREREQUISITES="N": Skip installation of packages for build.
+# * PROMPT_ALWAYS_RESPOND="n": Automatically respond to interactive prompts.
+#     Use "n" to never wipe directories.
+#
+# You can also run individual functions below by specifying them as arguments:
+# $ scripts/setup-centos9.sh install_googletest install_fmt
+#
+
+set -efx -o pipefail
+# Some of the packages must be build with the same compiler flags
+# so that some low level types are the same size. Also, disable warnings.
+SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+source $SCRIPTDIR/setup-helper-functions.sh
+NPROC=$(getconf _NPROCESSORS_ONLN)
+export CXXFLAGS=$(get_cxx_flags) # Used by boost.
+export CFLAGS=${CXXFLAGS//"-std=c++17"/} # Used by LZO.
+CMAKE_BUILD_TYPE="${BUILD_TYPE:-Release}"
+BUILD_DUCKDB="${BUILD_DUCKDB:-true}"
+USE_CLANG="${USE_CLANG:-false}"
+export INSTALL_PREFIX=${INSTALL_PREFIX:-"/usr/local"}
+DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)/deps-download}
+
+FB_OS_VERSION="v2024.09.16.00"
+FMT_VERSION="10.1.1"
+BOOST_VERSION="boost-1.84.0"
+ARROW_VERSION="15.0.0"
+FAST_FLOAT_VERSION="v6.1.6"
+
+function dnf_install {
+  dnf install -y -q --setopt=install_weak_deps=False "$@"
+}
+
+function install_clang15 {
+  dnf_install clang15 gcc-toolset-13-libatomic-devel
+}
+
+# Install packages required for build.
+function install_build_prerequisites {
+  dnf update -y
+  dnf_install epel-release dnf-plugins-core # For ccache, ninja
+  dnf config-manager --set-enabled crb
+  dnf update -y
+  dnf_install ninja-build cmake ccache gcc-toolset-12 git wget which
+  dnf_install autoconf automake python3-devel pip libtool
+
+  pip install cmake==3.28.3
+
+  if [[ ${USE_CLANG} != "false" ]]; then
+    install_clang15
+  fi
+}
+
+# Install dependencies from the package managers.
+function install_velox_deps_from_dnf {
+  dnf_install libevent-devel \
+    openssl-devel re2-devel libzstd-devel lz4-devel double-conversion-devel \
+    libdwarf-devel elfutils-libelf-devel curl-devel libicu-devel bison flex \
+    libsodium-devel zlib-devel
+
+  # install sphinx for doc gen
+  pip install sphinx sphinx-tabs breathe sphinx_rtd_theme
+}
+
+function install_conda {
+  dnf_install conda
+}
+
+function install_gflags {
+  # Remove an older version if present.
+  dnf remove -y gflags
+  wget_and_untar https://github.com/gflags/gflags/archive/v2.2.2.tar.gz gflags
+  cmake_install_dir gflags -DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=ON -DBUILD_gflags_LIB=ON -DLIB_SUFFIX=64
+}
+
+function install_glog {
+  wget_and_untar https://github.com/google/glog/archive/v0.6.0.tar.gz glog
+  cmake_install_dir glog -DBUILD_SHARED_LIBS=ON
+}
+
+function install_lzo {
+  wget_and_untar http://www.oberhumer.com/opensource/lzo/download/lzo-2.10.tar.gz lzo
+  (
+    cd ${DEPENDENCY_DIR}/lzo
+    ./configure --prefix=${INSTALL_PREFIX} --enable-shared --disable-static --docdir=/usr/share/doc/lzo-2.10
+    make "-j$(nproc)"
+    make install
+  )
+}
+
+function install_boost {
+  wget_and_untar https://github.com/boostorg/boost/releases/download/${BOOST_VERSION}/${BOOST_VERSION}.tar.gz boost
+  (
+    cd ${DEPENDENCY_DIR}/boost
+    if [[ ${USE_CLANG} != "false" ]]; then
+      ./bootstrap.sh --prefix=${INSTALL_PREFIX} --with-toolset="clang-15"
+      # Switch the compiler from the clang-15 toolset which doesn't exist (clang-15.jam) to
+      # clang of version 15 when toolset clang-15 is used.
+      # This reconciles the project-config.jam generation with what the b2 build system allows for customization.
+      sed -i 's/using clang-15/using clang : 15/g' project-config.jam
+      ${SUDO} ./b2 "-j$(nproc)" -d0 install threading=multi toolset=clang-15 --without-python
+    else
+      ./bootstrap.sh --prefix=${INSTALL_PREFIX}
+      ${SUDO} ./b2 "-j$(nproc)" -d0 install threading=multi --without-python
+    fi
+  )
+}
+
+function install_snappy {
+  wget_and_untar https://github.com/google/snappy/archive/1.1.8.tar.gz snappy
+  cmake_install_dir snappy -DSNAPPY_BUILD_TESTS=OFF
+}
+
+function install_fmt {
+  wget_and_untar https://github.com/fmtlib/fmt/archive/${FMT_VERSION}.tar.gz fmt
+  cmake_install_dir fmt -DFMT_TEST=OFF
+}
+
+function install_protobuf {
+  wget_and_untar https://github.com/protocolbuffers/protobuf/releases/download/v21.8/protobuf-all-21.8.tar.gz protobuf
+  (
+    cd ${DEPENDENCY_DIR}/protobuf
+    ./configure --prefix=${INSTALL_PREFIX}
+    make "-j${NPROC}"
+    make install
+    ldconfig
+  )
+}
+
+function install_fizz {
+  wget_and_untar https://github.com/facebookincubator/fizz/archive/refs/tags/${FB_OS_VERSION}.tar.gz fizz
+  cmake_install_dir fizz/fizz -DBUILD_TESTS=OFF
+}
+
+function install_folly {
+  wget_and_untar https://github.com/facebook/folly/archive/refs/tags/${FB_OS_VERSION}.tar.gz folly
+  cmake_install_dir folly -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON
+}
+
+function install_wangle {
+  wget_and_untar https://github.com/facebook/wangle/archive/refs/tags/${FB_OS_VERSION}.tar.gz wangle
+  cmake_install_dir wangle/wangle -DBUILD_TESTS=OFF
+}
+
+function install_fbthrift {
+  wget_and_untar https://github.com/facebook/fbthrift/archive/refs/tags/${FB_OS_VERSION}.tar.gz fbthrift
+  cmake_install_dir fbthrift -Denable_tests=OFF -DBUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF
+}
+
+function install_mvfst {
+  wget_and_untar https://github.com/facebook/mvfst/archive/refs/tags/${FB_OS_VERSION}.tar.gz mvfst
+  cmake_install_dir mvfst -DBUILD_TESTS=OFF
+}
+
+function install_duckdb {
+  if $BUILD_DUCKDB ; then
+    echo 'Building DuckDB'
+    wget_and_untar https://github.com/duckdb/duckdb/archive/refs/tags/v0.8.1.tar.gz duckdb
+    cmake_install_dir duckdb -DBUILD_UNITTESTS=OFF -DENABLE_SANITIZER=OFF -DENABLE_UBSAN=OFF -DBUILD_SHELL=OFF -DEXPORT_DLL_SYMBOLS=OFF -DCMAKE_BUILD_TYPE=Release
+  fi
+}
+
+function install_arrow {
+  wget_and_untar https://archive.apache.org/dist/arrow/arrow-${ARROW_VERSION}/apache-arrow-${ARROW_VERSION}.tar.gz arrow
+  cmake_install_dir arrow/cpp \
+    -DARROW_PARQUET=OFF \
+    -DARROW_WITH_THRIFT=ON \
+    -DARROW_WITH_LZ4=ON \
+    -DARROW_WITH_SNAPPY=ON \
+    -DARROW_WITH_ZLIB=ON \
+    -DARROW_WITH_ZSTD=ON \
+    -DARROW_JEMALLOC=OFF \
+    -DARROW_SIMD_LEVEL=NONE \
+    -DARROW_RUNTIME_SIMD_LEVEL=NONE \
+    -DARROW_WITH_UTF8PROC=OFF \
+    -DARROW_TESTING=ON \
+    -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DARROW_BUILD_STATIC=ON \
+    -DThrift_SOURCE=BUNDLED
+
+  (
+    # Install thrift.
+    cd ${DEPENDENCY_DIR}/arrow/cpp/_build/thrift_ep-prefix/src/thrift_ep-build
+    cmake --install ./ --prefix ${INSTALL_PREFIX}
+  )
+}
+
+function install_cuda {
+  # See https://developer.nvidia.com/cuda-downloads
+  dnf config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel9/x86_64/cuda-rhel9.repo
+  dnf install -y cuda-nvcc-$(echo $1 | tr '.' '-') cuda-cudart-devel-$(echo $1 | tr '.' '-')
+}
+
+function install_fast_float {
+  # Dependency of folly.
+  wget_and_untar https://github.com/fastfloat/fast_float/archive/refs/tags/${FAST_FLOAT_VERSION}.tar.gz fast_float
+  cmake_install_dir fast_float
+}
+
+function install_velox_deps {
+  run_and_time install_velox_deps_from_dnf
+  run_and_time install_conda
+  run_and_time install_gflags
+  run_and_time install_glog
+  run_and_time install_lzo
+  run_and_time install_snappy
+  run_and_time install_boost
+  run_and_time install_protobuf
+  run_and_time install_fmt
+  run_and_time install_fast_float
+  run_and_time install_folly
+  run_and_time install_fizz
+  run_and_time install_wangle
+  run_and_time install_mvfst
+  run_and_time install_fbthrift
+  run_and_time install_duckdb
+  run_and_time install_arrow
+}
+
+(return 2> /dev/null) && return # If script was sourced, don't run commands.
+
+(
+  if [[ $# -ne 0 ]]; then
+    if [[ ${USE_CLANG} != "false" ]]; then
+      export CC=/usr/bin/clang-15
+      export CXX=/usr/bin/clang++-15
+    else
+      # Activate gcc12; enable errors on unset variables afterwards.
+      source /opt/rh/gcc-toolset-12/enable || exit 1
+      set -u
+    fi
+
+    for cmd in "$@"; do
+      run_and_time "${cmd}"
+    done
+    echo "All specified dependencies installed!"
+  else
+    if [ "${INSTALL_PREREQUISITES:-Y}" == "Y" ]; then
+      echo "Installing build dependencies"
+      run_and_time install_build_prerequisites
+    else
+      echo "Skipping installation of build dependencies since INSTALL_PREREQUISITES is not set"
+    fi
+    if [[ ${USE_CLANG} != "false" ]]; then
+      export CC=/usr/bin/clang-15
+      export CXX=/usr/bin/clang++-15
+    else
+      # Activate gcc12; enable errors on unset variables afterwards.
+      source /opt/rh/gcc-toolset-12/enable || exit 1
+      set -u
+    fi
+    install_velox_deps
+    echo "All dependencies for Velox installed!"
+    if [[ ${USE_CLANG} != "false" ]]; then
+      echo "To use clang for the Velox build set the CC and CXX environment variables in your session."
+      echo "  export CC=/usr/bin/clang-15"
+      echo "  export CXX=/usr/bin/clang++-15"
+    fi
+    dnf clean all
+  fi
+)
+
diff --git a/scripts/setup-check.sh b/scripts/setup-check.sh
index 59b7baece99d5..d3d6573a8eda9 100644
--- a/scripts/setup-check.sh
+++ b/scripts/setup-check.sh
@@ -18,9 +18,9 @@ set -x
 
 export DEBIAN_FRONTEND=noninteractive
 apt update
-apt install --no-install-recommends -y clang-format-12 python3-pip git make ssh
-pip3 install cmake_format black regex
+apt install --no-install-recommends -y clang-format-18 python3-pip git make ssh
+pip3 install --break-system-packages cmake==3.28.3 cmake_format black pyyaml regex
 pip3 cache purge
 apt purge --auto-remove -y python3-pip
-update-alternatives --install /usr/bin/clang-format clang-format "$(command -v clang-format-12)" 12
+update-alternatives --install /usr/bin/clang-format clang-format "$(command -v clang-format-18)" 18
 apt clean
diff --git a/scripts/setup-circleci.sh b/scripts/setup-circleci.sh
deleted file mode 100755
index bd275f48869ef..0000000000000
--- a/scripts/setup-circleci.sh
+++ /dev/null
@@ -1,122 +0,0 @@
-#!/bin/bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set -efx -o pipefail
-# Some of the packages must be build with the same compiler flags
-# so that some low level types are the same size. Also, disable warnings.
-SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
-source $SCRIPTDIR/setup-helper-functions.sh
-CPU_TARGET="${CPU_TARGET:-avx}"
-NPROC=$(getconf _NPROCESSORS_ONLN)
-export CFLAGS=$(get_cxx_flags $CPU_TARGET)  # Used by LZO.
-export CXXFLAGS=$CFLAGS  # Used by boost.
-export CPPFLAGS=$CFLAGS  # Used by LZO.
-
-function dnf_install {
-  dnf install -y -q --setopt=install_weak_deps=False "$@"
-}
-
-dnf_install epel-release dnf-plugins-core # For ccache, ninja
-dnf config-manager --set-enabled powertools
-dnf_install ninja-build ccache gcc-toolset-9 git wget which libevent-devel \
-  openssl-devel re2-devel libzstd-devel lz4-devel double-conversion-devel \
-  libdwarf-devel curl-devel libicu-devel
-
-dnf remove -y gflags
-
-# Required for Thrift
-dnf_install autoconf automake libtool bison flex python3 libsodium-devel
-
-dnf_install conda
-
-# install sphinx for doc gen
-pip3 install sphinx sphinx-tabs breathe sphinx_rtd_theme
-
-# Activate gcc9; enable errors on unset variables afterwards.
-source /opt/rh/gcc-toolset-9/enable || exit 1
-set -u
-
-function cmake_install {
-  cmake -B "$1-build" -GNinja -DCMAKE_CXX_STANDARD=17 \
-    -DCMAKE_CXX_FLAGS="${CFLAGS}" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_BUILD_TYPE=Release -Wno-dev "$@"
-  ninja -C "$1-build" install
-}
-
-function wget_and_untar {
-  local URL=$1
-  local DIR=$2
-  mkdir -p "${DIR}"
-  wget -q --max-redirect 3 -O - "${URL}" | tar -xz -C "${DIR}" --strip-components=1
-}
-
-# untar cmake binary release directly to /usr.
-wget_and_untar https://github.com/Kitware/CMake/releases/download/v3.17.5/cmake-3.17.5-Linux-x86_64.tar.gz /usr &
-
-# Fetch sources.
-wget_and_untar https://github.com/gflags/gflags/archive/v2.2.2.tar.gz gflags &
-wget_and_untar https://github.com/google/glog/archive/v0.4.0.tar.gz glog &
-wget_and_untar http://www.oberhumer.com/opensource/lzo/download/lzo-2.10.tar.gz lzo &
-wget_and_untar https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.gz boost &
-wget_and_untar https://github.com/google/snappy/archive/1.1.8.tar.gz snappy &
-wget_and_untar https://github.com/fmtlib/fmt/archive/8.0.1.tar.gz fmt &
-#  wget_and_untar https://github.com/ericniebler/range-v3/archive/0.11.0.tar.gz ranges-v3 &
-wget_and_untar https://archive.apache.org/dist/hadoop/common/hadoop-2.10.1/hadoop-2.10.1.tar.gz hadoop
-wget_and_untar https://github.com/protocolbuffers/protobuf/releases/download/v21.4/protobuf-all-21.4.tar.gz protobuf &
-
-FB_OS_VERSION="v2022.11.14.00"
-
-wget_and_untar https://github.com/facebook/folly/archive/${FB_OS_VERSION}.tar.gz folly &
-wget_and_untar https://github.com/facebookincubator/fizz/archive/refs/tags/${FB_OS_VERSION}.tar.gz fizz &
-wget_and_untar https://github.com/facebook/wangle/archive/refs/tags/${FB_OS_VERSION}.tar.gz wangle &
-wget_and_untar https://github.com/facebook/fbthrift/archive/refs/tags/${FB_OS_VERSION}.tar.gz fbthrift &
-
-wait  # For cmake and source downloads to complete.
-
-cp -a hadoop /usr/local/
-
-# Build & install.
-(
-  cd lzo
-  ./configure --prefix=/usr --enable-shared --disable-static --docdir=/usr/share/doc/lzo-2.10
-  make "-j$(nproc)"
-  make install
-)
-
-(
-  cd boost
-  ./bootstrap.sh --prefix=/usr/local
-  ./b2 "-j$(nproc)" -d0 install threading=multi
-)
-
-(
-  cd protobuf
-  ./configure --prefix=/usr
-  make "-j${NPROC}"
-  make install
-  ldconfig
-)
-
-cmake_install gflags -DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=ON -DBUILD_gflags_LIB=ON -DLIB_SUFFIX=64 -DCMAKE_INSTALL_PREFIX:PATH=/usr
-cmake_install glog -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=/usr
-cmake_install snappy -DSNAPPY_BUILD_TESTS=OFF
-cmake_install fmt -DFMT_TEST=OFF
-cmake_install folly -DFOLLY_HAVE_INT128_T=ON
-
-cmake_install fizz/fizz -DBUILD_TESTS=OFF
-cmake_install wangle/wangle -DBUILD_TESTS=OFF
-cmake_install fbthrift -Denable_tests=OFF
-# cmake_install ranges-v3
-
-dnf clean all
diff --git a/scripts/setup-classpath.sh b/scripts/setup-classpath.sh
new file mode 100644
index 0000000000000..e52184d92138a
--- /dev/null
+++ b/scripts/setup-classpath.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+export CLASSPATH=`/usr/local/hadoop/bin/hdfs classpath --glob`
diff --git a/scripts/setup-helper-functions.sh b/scripts/setup-helper-functions.sh
old mode 100644
new mode 100755
index 8076edc4a1850..4c332bb305f42
--- a/scripts/setup-helper-functions.sh
+++ b/scripts/setup-helper-functions.sh
@@ -15,6 +15,30 @@
 
 # github_checkout $REPO $VERSION $GIT_CLONE_PARAMS clones or re-uses an existing clone of the
 # specified repo, checking out the requested version.
+
+DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)/deps-download}
+OS_CXXFLAGS=""
+
+function run_and_time {
+  time "$@" || (echo "Failed to run $* ." ; exit 1 )
+  { echo "+ Finished running $*"; } 2> /dev/null
+}
+
+function prompt {
+  (
+    while true; do
+      local input="${PROMPT_ALWAYS_RESPOND:-}"
+      echo -n "$(tput bold)$* [Y, n]$(tput sgr0) "
+      [[ -z "${input}" ]] && read input
+      if [[ "${input}" == "Y" || "${input}" == "y" || "${input}" == "" ]]; then
+        return 0
+      elif [[ "${input}" == "N" || "${input}" == "n" ]]; then
+        return 1
+      fi
+    done
+  ) 2> /dev/null
+}
+
 function github_checkout {
   local REPO=$1
   shift
@@ -22,13 +46,14 @@ function github_checkout {
   shift
   local GIT_CLONE_PARAMS=$@
   local DIRNAME=$(basename $REPO)
+  SUDO="${SUDO:-""}"
   cd "${DEPENDENCY_DIR}"
   if [ -z "${DIRNAME}" ]; then
     echo "Failed to get repo name from ${REPO}"
     exit 1
   fi
   if [ -d "${DIRNAME}" ] && prompt "${DIRNAME} already exists. Delete?"; then
-    rm -rf "${DIRNAME}"
+    ${SUDO} rm -rf "${DIRNAME}"
   fi
   if [ ! -d "${DIRNAME}" ]; then
     git clone -q -b $VERSION $GIT_CLONE_PARAMS "https://github.com/${REPO}.git"
@@ -36,9 +61,8 @@ function github_checkout {
   cd "${DIRNAME}"
 }
 
-
 # get_cxx_flags [$CPU_ARCH]
-# Sets and exports the variable VELOX_CXX_FLAGS with appropriate compiler flags.
+# Echos appropriate compiler flags.
 # If $CPU_ARCH is set then we use that else we determine best possible set of flags
 # to use based on current cpu architecture.
 # The goal of this function is to consolidate all architecture specific flags to one
@@ -53,65 +77,78 @@ function github_checkout {
 # CXX_FLAGS=$(get_cxx_flags "avx")
 
 function get_cxx_flags {
-  local CPU_ARCH=$1
-
-  local OS
-  OS=$(uname)
-  local MACHINE
-  MACHINE=$(uname -m)
-  ADDITIONAL_FLAGS=""
-
-  if [[ -z "$CPU_ARCH" ]] || [[ $CPU_ARCH == "unknown" ]]; then
-    if [ "$OS" = "Darwin" ]; then
-
-      if [ "$MACHINE" = "x86_64" ]; then
-        local CPU_CAPABILITIES
-        CPU_CAPABILITIES=$(sysctl -a | grep machdep.cpu.features | awk '{print tolower($0)}')
-
-        if [[ $CPU_CAPABILITIES =~ "avx" ]]; then
-          CPU_ARCH="avx"
-        else
-          CPU_ARCH="sse"
-        fi
-
-      elif [[ $(sysctl -a | grep machdep.cpu.brand_string) =~ "Apple" ]]; then
-        # Apple silicon.
-        CPU_ARCH="arm64"
-      fi
-
-    # On MacOs prevent the flood of translation visibility settings warnings.
-    ADDITIONAL_FLAGS="-fvisibility=hidden -fvisibility-inlines-hidden"
-    else [ "$OS" = "Linux" ];
-
-      local CPU_CAPABILITIES
-      CPU_CAPABILITIES=$(cat /proc/cpuinfo | grep flags | head -n 1| awk '{print tolower($0)}')
-
-      if [[ "$CPU_CAPABILITIES" =~ "avx" ]]; then
-            CPU_ARCH="avx"
-      elif [[ "$CPU_CAPABILITIES" =~ "sse" ]]; then
-            CPU_ARCH="sse"
-      elif [ "$MACHINE" = "aarch64" ]; then
-            CPU_ARCH="aarch64"
-      fi
-    fi
+  local CPU_ARCH=${1:-""}
+  local OS=$(uname)
+  local MACHINE=$(uname -m)
+
+  if [[ -z "$CPU_ARCH" ]]; then
+   if [ "$OS" = "Darwin" ]; then
+     if [ "$MACHINE" = "arm64" ]; then
+       CPU_ARCH="arm64"
+     else # x86_64
+       local CPU_CAPABILITIES=$(sysctl -a | grep machdep.cpu.features | awk '{print tolower($0)}')
+       if [[ $CPU_CAPABILITIES =~ "avx" ]]; then
+         CPU_ARCH="avx"
+       else
+         CPU_ARCH="sse"
+       fi
+     fi
+   elif [ "$OS" = "Linux" ]; then
+     if [ "$MACHINE" = "aarch64" ]; then
+       CPU_ARCH="aarch64"
+     else # x86_64
+       local CPU_CAPABILITIES=$(cat /proc/cpuinfo | grep flags | head -n 1| awk '{print tolower($0)}')
+       if [[ $CPU_CAPABILITIES =~ "avx" ]]; then
+           CPU_ARCH="avx"
+       elif [[ $CPU_CAPABILITIES =~ "sse" ]]; then
+           CPU_ARCH="sse"
+       fi
+     fi
+   else
+     echo "Unsupported platform $OS"; exit 1;
+   fi
   fi
-
   case $CPU_ARCH in
 
     "arm64")
-      echo -n "-mcpu=apple-m1+crc -std=c++17 -fvisibility=hidden $ADDITIONAL_FLAGS"
+      echo -n "-mcpu=apple-m1+crc -std=c++17 -fvisibility=hidden"
     ;;
 
     "avx")
-      echo -n "-mavx2 -mfma -mavx -mf16c -mlzcnt -std=c++17 -mbmi2 $ADDITIONAL_FLAGS"
+      echo -n "-mavx2 -mfma -mavx -mf16c -mlzcnt -std=c++17 -mbmi2"
     ;;
 
     "sse")
-      echo -n "-msse4.2 -std=c++17 $ADDITIONAL_FLAGS"
+      echo -n "-msse4.2 -std=c++17"
     ;;
 
     "aarch64")
-      echo -n "-mcpu=neoverse-n1 -std=c++17 $ADDITIONAL_FLAGS"
+      # Read Arm MIDR_EL1 register to detect Arm cpu.
+      # https://developer.arm.com/documentation/100616/0301/register-descriptions/aarch64-system-registers/midr-el1--main-id-register--el1
+      ARM_CPU_FILE="/sys/devices/system/cpu/cpu0/regs/identification/midr_el1"
+
+      # https://gitlab.arm.com/telemetry-solution/telemetry-solution/-/blob/main/data/pmu/cpu/neoverse/neoverse-n1.json#L13
+      # N1:d0c; N2:d49; V1:d40;
+      Neoverse_N1="d0c"
+      Neoverse_N2="d49"
+      Neoverse_V1="d40"
+      if [ -f "$ARM_CPU_FILE" ]; then
+        hex_ARM_CPU_DETECT=`cat $ARM_CPU_FILE`
+        # PartNum, [15:4]: The primary part number such as Neoverse N1/N2 core.
+        ARM_CPU_PRODUCT=${hex_ARM_CPU_DETECT: -4:3}
+
+        if [ "$ARM_CPU_PRODUCT" = "$Neoverse_N1" ]; then
+          echo -n "-mcpu=neoverse-n1 -std=c++17"
+        elif [ "$ARM_CPU_PRODUCT" = "$Neoverse_N2" ]; then
+          echo -n "-mcpu=neoverse-n2 -std=c++17"
+        elif [ "$ARM_CPU_PRODUCT" = "$Neoverse_V1" ]; then
+          echo -n "-mcpu=neoverse-v1 -std=c++17"
+        else
+          echo -n "-march=armv8-a+crc+crypto -std=c++17"
+        fi
+      else
+        echo -n "-std=c++17"
+      fi
     ;;
   *)
     echo -n "Architecture not supported!"
@@ -119,15 +156,52 @@ function get_cxx_flags {
 
 }
 
+function wget_and_untar {
+  local URL=$1
+  local DIR=$2
+  mkdir -p "${DEPENDENCY_DIR}"
+  pushd "${DEPENDENCY_DIR}"
+  SUDO="${SUDO:-""}"
+  if [ -d "${DIR}" ]; then
+    if prompt "${DIR} already exists. Delete?"; then
+      ${SUDO} rm -rf "${DIR}"
+    else
+      popd
+      return
+    fi
+  fi
+  mkdir -p "${DIR}"
+  pushd "${DIR}"
+  curl -L "${URL}" > $2.tar.gz
+  tar -xz --strip-components=1 -f $2.tar.gz
+  popd
+  popd
+}
+
+function cmake_install_dir {
+  pushd "${DEPENDENCY_DIR}/$1"
+  # remove the directory argument
+  shift
+  cmake_install $@
+  popd
+}
+
 function cmake_install {
   local NAME=$(basename "$(pwd)")
   local BINARY_DIR=_build
-  if [ -d "${BINARY_DIR}" ] && prompt "Do you want to rebuild ${NAME}?"; then
-    rm -rf "${BINARY_DIR}"
+  SUDO="${SUDO:-""}"
+  if [ -d "${BINARY_DIR}" ]; then
+    if prompt "Do you want to rebuild ${NAME}?"; then
+      ${SUDO} rm -rf "${BINARY_DIR}"
+    else
+      return
+    fi
   fi
+
   mkdir -p "${BINARY_DIR}"
-  CPU_TARGET="${CPU_TARGET:-unknown}"
-  COMPILER_FLAGS=$(get_cxx_flags $CPU_TARGET)
+  COMPILER_FLAGS=$(get_cxx_flags)
+  # Add platform specific CXX flags if any
+  COMPILER_FLAGS+=${OS_CXXFLAGS}
 
   # CMAKE_POSITION_INDEPENDENT_CODE is required so that Velox can be built into dynamic libraries \
   cmake -Wno-dev -B"${BINARY_DIR}" \
@@ -139,6 +213,8 @@ function cmake_install {
     -DCMAKE_CXX_FLAGS="$COMPILER_FLAGS" \
     -DBUILD_TESTING=OFF \
     "$@"
-  ninja -C "${BINARY_DIR}" install
+  # Exit if the build fails.
+  cmake --build "${BINARY_DIR}" || { echo 'build failed' ; exit 1; }
+  ${SUDO} cmake --install "${BINARY_DIR}"
 }
 
diff --git a/scripts/setup-macos.sh b/scripts/setup-macos.sh
index 83d8990603eae..6eb600c34aa0e 100755
--- a/scripts/setup-macos.sh
+++ b/scripts/setup-macos.sh
@@ -29,32 +29,20 @@ set -e # Exit on error.
 set -x # Print commands that are executed.
 
 SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+export INSTALL_PREFIX=${INSTALL_PREFIX:-"$(pwd)/deps-install"}
 source $SCRIPTDIR/setup-helper-functions.sh
-
+PYTHON_VENV=${PYHTON_VENV:-"${SCRIPTDIR}/../.venv"}
+# Allow installed package headers to be picked up before brew package headers
+# by tagging the brew packages to be system packages.
+# This is used during package builds.
+export OS_CXXFLAGS=" -isystem $(brew --prefix)/include "
 NPROC=$(getconf _NPROCESSORS_ONLN)
 
 DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)}
-MACOS_DEPS="ninja flex bison cmake ccache protobuf@21 icu4c boost gflags glog libevent lz4 lzo snappy xz zstd openssl@1.1"
-
-function run_and_time {
-  time "$@" || (echo "Failed to run $* ." ; exit 1 )
-  { echo "+ Finished running $*"; } 2> /dev/null
-}
-
-function prompt {
-  (
-    while true; do
-      local input="${PROMPT_ALWAYS_RESPOND:-}"
-      echo -n "$(tput bold)$* [Y, n]$(tput sgr0) "
-      [[ -z "${input}" ]] && read input
-      if [[ "${input}" == "Y" || "${input}" == "y" || "${input}" == "" ]]; then
-        return 0
-      elif [[ "${input}" == "N" || "${input}" == "n" ]]; then
-        return 1
-      fi
-    done
-  ) 2> /dev/null
-}
+MACOS_VELOX_DEPS="bison flex gflags glog googletest icu4c libevent libsodium lz4 lzo openssl protobuf@21 snappy xz zstd"
+MACOS_BUILD_DEPS="ninja cmake"
+FB_OS_VERSION="v2024.09.16.00"
+FMT_VERSION="10.1.1"
 
 function update_brew {
   DEFAULT_BREW_PATH=/usr/local/bin/brew
@@ -67,76 +55,132 @@ function update_brew {
   $BREW_PATH developer off
 }
 
+function install_from_brew {
+  pkg=$1
+  if [[ "${pkg}" =~ ^([0-9a-z-]*):([0-9](\.[0-9\])*)$ ]];
+  then
+    pkg=${BASH_REMATCH[1]}
+    ver=${BASH_REMATCH[2]}
+    echo "Installing '${pkg}' at '${ver}'"
+    tap="velox/local-${pkg}"
+    brew tap-new "${tap}"
+    brew extract "--version=${ver}" "${pkg}" "${tap}"
+    brew install "${tap}/${pkg}@${ver}" || ( echo "Failed to install ${tap}/${pkg}@${ver}" ; exit 1 )
+  else
+    ( brew install --formula "${pkg}" && echo "Installation of ${pkg} is successful" || brew upgrade --formula "$pkg" ) || ( echo "Failed to install ${pkg}" ; exit 1 )
+  fi
+}
+
 function install_build_prerequisites {
-  for pkg in ${MACOS_DEPS}
+  for pkg in ${MACOS_BUILD_DEPS}
   do
-    if [[ "${pkg}" =~ ^([0-9a-z-]*):([0-9](\.[0-9\])*)$ ]];
-    then
-      pkg=${BASH_REMATCH[1]}
-      ver=${BASH_REMATCH[2]}
-      echo "Installing '${pkg}' at '${ver}'"
-      tap="velox/local-${pkg}"
-      brew tap-new "${tap}"
-      brew extract "--version=${ver}" "${pkg}" "${tap}"
-      brew install "${tap}/${pkg}@${ver}" || ( echo "Failed to install ${tap}/${pkg}@${ver}" ; exit 1 )
-    else
-      ( brew install --formula "${pkg}" && echo "Installation of ${pkg} is successful" || brew upgrade --formula "$pkg" ) || ( echo "Failed to install ${pkg}" ; exit 1 )
-    fi
+    install_from_brew ${pkg}
   done
+  if [ ! -f ${PYTHON_VENV}/pyvenv.cfg ]; then
+    echo "Creating Python Virtual Environment at ${PYTHON_VENV}"
+    python3 -m venv ${PYTHON_VENV}
+  fi
+  source ${PYTHON_VENV}/bin/activate; pip3 install cmake-format regex pyyaml
+  if [ ! -f /usr/local/bin/ccache ]; then
+    curl -L https://github.com/ccache/ccache/releases/download/v4.10.2/ccache-4.10.2-darwin.tar.gz > ccache.tar.gz
+    tar -xf ccache.tar.gz
+    mv ccache-4.10.2-darwin/ccache /usr/local/bin/
+    rm -rf ccache-4.10.2-darwin ccache.tar.gz
+  fi
+}
 
-  pip3 install --user cmake-format regex
+function install_velox_deps_from_brew {
+  for pkg in ${MACOS_VELOX_DEPS}
+  do
+    install_from_brew ${pkg}
+  done
 }
 
 function install_fmt {
-  github_checkout fmtlib/fmt 8.0.1
-  cmake_install -DFMT_TEST=OFF
+  wget_and_untar https://github.com/fmtlib/fmt/archive/${FMT_VERSION}.tar.gz fmt
+  cmake_install_dir fmt -DFMT_TEST=OFF
 }
 
 function install_folly {
-  github_checkout facebook/folly "v2022.11.14.00"
-  OPENSSL_ROOT_DIR=$(brew --prefix openssl@1.1) \
-  cmake_install -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON
+  wget_and_untar https://github.com/facebook/folly/archive/refs/tags/${FB_OS_VERSION}.tar.gz folly
+  cmake_install_dir folly -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON
+}
+
+function install_fizz {
+  wget_and_untar https://github.com/facebookincubator/fizz/archive/refs/tags/${FB_OS_VERSION}.tar.gz fizz
+  cmake_install_dir fizz/fizz -DBUILD_TESTS=OFF
+}
+
+function install_wangle {
+  wget_and_untar https://github.com/facebook/wangle/archive/refs/tags/${FB_OS_VERSION}.tar.gz wangle
+  cmake_install_dir wangle/wangle -DBUILD_TESTS=OFF
+}
+
+function install_mvfst {
+  wget_and_untar https://github.com/facebook/mvfst/archive/refs/tags/${FB_OS_VERSION}.tar.gz mvfst
+  cmake_install_dir mvfst -DBUILD_TESTS=OFF
+}
+
+function install_fbthrift {
+  wget_and_untar https://github.com/facebook/fbthrift/archive/refs/tags/${FB_OS_VERSION}.tar.gz fbthrift
+  cmake_install_dir fbthrift -Denable_tests=OFF -DBUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF
 }
 
 function install_double_conversion {
-  github_checkout google/double-conversion v3.1.5
-  cmake_install -DBUILD_TESTING=OFF
+  wget_and_untar https://github.com/google/double-conversion/archive/refs/tags/v3.1.5.tar.gz double-conversion
+  cmake_install_dir double-conversion -DBUILD_TESTING=OFF
 }
 
 function install_ranges_v3 {
-  github_checkout ericniebler/range-v3 0.12.0
-  cmake_install -DRANGES_ENABLE_WERROR=OFF -DRANGE_V3_TESTS=OFF -DRANGE_V3_EXAMPLES=OFF
+  wget_and_untar https://github.com/ericniebler/range-v3/archive/refs/tags/0.12.0.tar.gz ranges_v3
+  cmake_install_dir ranges_v3 -DRANGES_ENABLE_WERROR=OFF -DRANGE_V3_TESTS=OFF -DRANGE_V3_EXAMPLES=OFF
 }
 
 function install_re2 {
-  github_checkout google/re2 2021-04-01
-  cmake_install -DRE2_BUILD_TESTING=OFF
+  wget_and_untar https://github.com/google/re2/archive/refs/tags/2022-02-01.tar.gz re2
+  cmake_install_dir re2 -DRE2_BUILD_TESTING=OFF
+}
+
+function install_fast_float {
+  # Dependency of folly.
+  wget_and_untar https://github.com/fastfloat/fast_float/archive/refs/tags/${FAST_FLOAT_VERSION}.tar.gz fast_float
+  cmake_install_dir fast_float
 }
 
 function install_velox_deps {
-  if [ "${INSTALL_PREREQUISITES:-Y}" == "Y" ]; then
-    run_and_time install_build_prerequisites
-  fi
+  run_and_time install_velox_deps_from_brew
   run_and_time install_ranges_v3
-  run_and_time install_fmt
   run_and_time install_double_conversion
   run_and_time install_re2
+  run_and_time install_fmt
+  run_and_time install_fast_float
+  run_and_time install_folly
+  run_and_time install_fizz
+  run_and_time install_wangle
+  run_and_time install_mvfst
+  run_and_time install_fbthrift
 }
 
 (return 2> /dev/null) && return # If script was sourced, don't run commands.
 
 (
-  echo "Installing mac dependencies"
   update_brew
   if [[ $# -ne 0 ]]; then
     for cmd in "$@"; do
       run_and_time "${cmd}"
     done
+    echo "All specified dependencies installed!"
   else
+    if [ "${INSTALL_PREREQUISITES:-Y}" == "Y" ]; then
+      echo "Installing build dependencies"
+      run_and_time install_build_prerequisites
+    else
+      echo "Skipping installation of build dependencies since INSTALL_PREREQUISITES is not set"
+    fi
     install_velox_deps
+    echo "All deps for Velox installed! Now try \"make\""
   fi
 )
 
-echo "All deps for Velox installed! Now try \"make\""
-echo 'To add cmake-format bin to your $PATH, consider adding this to your ~/.profile:'
-echo 'export PATH=$HOME/bin:$HOME/Library/Python/3.7/bin:$PATH'
+echo "To reuse the installed dependencies for subsequent builds, consider adding this to your ~/.zshrc"
+echo "export INSTALL_PREFIX=$INSTALL_PREFIX"
diff --git a/scripts/setup-ubuntu.sh b/scripts/setup-ubuntu.sh
index a1dda4b6c29ce..c4785af00fe5d 100755
--- a/scripts/setup-ubuntu.sh
+++ b/scripts/setup-ubuntu.sh
@@ -13,127 +13,268 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Minimal setup for Ubuntu 20.04.
+# This script documents setting up a Ubuntu host for Velox
+# development.  Running it should make you ready to compile.
+#
+# Environment variables:
+# * INSTALL_PREREQUISITES="N": Skip installation of packages for build.
+# * PROMPT_ALWAYS_RESPOND="n": Automatically respond to interactive prompts.
+#     Use "n" to never wipe directories.
+#
+# You can also run individual functions below by specifying them as arguments:
+# $ scripts/setup-ubuntu.sh install_googletest install_fmt
+#
+
+# Minimal setup for Ubuntu 22.04.
 set -eufx -o pipefail
 SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
 source $SCRIPTDIR/setup-helper-functions.sh
 
 # Folly must be built with the same compiler flags so that some low level types
 # are the same size.
-CPU_TARGET="${CPU_TARGET:-avx}"
-COMPILER_FLAGS=$(get_cxx_flags "$CPU_TARGET")
+COMPILER_FLAGS=$(get_cxx_flags)
 export COMPILER_FLAGS
-FB_OS_VERSION=v2022.11.14.00
 NPROC=$(getconf _NPROCESSORS_ONLN)
-DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)}
+BUILD_DUCKDB="${BUILD_DUCKDB:-true}"
 export CMAKE_BUILD_TYPE=Release
+SUDO="${SUDO:-"sudo --preserve-env"}"
+USE_CLANG="${USE_CLANG:-false}"
+export INSTALL_PREFIX=${INSTALL_PREFIX:-"/usr/local"}
+DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)/deps-download}
 
-# Install all velox and folly dependencies. 
-# The is an issue on 22.04 where a version conflict prevents glog install,
-# installing libunwind first fixes this.
-sudo --preserve-env apt update && sudo --preserve-env apt install -y libunwind-dev && \
-  sudo --preserve-env apt install -y \
-  g++ \
-  cmake \
-  ccache \
-  ninja-build \
-  checkinstall \
-  git \
-  libc-ares-dev \
-  libcurl4-openssl-dev \
-  libssl-dev \
-  libboost-all-dev \
-  libicu-dev \
-  libdouble-conversion-dev \
-  libgoogle-glog-dev \
-  libbz2-dev \
-  libgflags-dev \
-  libgmock-dev \
-  libevent-dev \
-  liblz4-dev \
-  libzstd-dev \
-  libre2-dev \
-  libsnappy-dev \
-  libsodium-dev \
-  libthrift-dev \
-  liblzo2-dev \
-  bison \
-  flex \
-  libfl-dev \
-  tzdata \
-  wget
-
-function run_and_time {
-  time "$@"
-  { echo "+ Finished running $*"; } 2> /dev/null
-}
-
-function prompt {
-  (
-    while true; do
-      local input="${PROMPT_ALWAYS_RESPOND:-}"
-      echo -n "$(tput bold)$* [Y, n]$(tput sgr0) "
-      [[ -z "${input}" ]] && read input
-      if [[ "${input}" == "Y" || "${input}" == "y" || "${input}" == "" ]]; then
-        return 0
-      elif [[ "${input}" == "N" || "${input}" == "n" ]]; then
-        return 1
-      fi
-    done
-  ) 2> /dev/null
+function install_clang15 {
+  VERSION=`cat /etc/os-release | grep VERSION_ID`
+  if [[ ! ${VERSION} =~ "22.04" && ! ${VERSION} =~ "24.04" ]]; then
+    echo "Warning: using the Clang configuration is for Ubuntu 22.04 and 24.04. Errors might occur."
+  fi
+  CLANG_PACKAGE_LIST=clang-15
+  if [[ ${VERSION} =~ "22.04" ]]; then
+    CLANG_PACKAGE_LIST=${CLANG_PACKAGE_LIST} gcc-12 g++-12 libc++-12-dev
+  fi
+  ${SUDO} apt install ${CLANG_PACKAGE_LIST} -y
+}
+
+FB_OS_VERSION="v2024.09.16.00"
+FMT_VERSION="10.1.1"
+BOOST_VERSION="boost-1.84.0"
+ARROW_VERSION="15.0.0"
+FAST_FLOAT_VERSION="v6.1.6"
+
+# Install packages required for build.
+function install_build_prerequisites {
+  ${SUDO} apt update
+  # The is an issue on 22.04 where a version conflict prevents glog install,
+  # installing libunwind first fixes this.
+  ${SUDO} apt install -y libunwind-dev
+  ${SUDO} apt install -y \
+    build-essential \
+    python3-pip \
+    ccache \
+    curl \
+    ninja-build \
+    checkinstall \
+    git \
+    wget
+
+  # Install to /usr/local to make it available to all users.
+  ${SUDO} pip3 install cmake==3.28.3
+
+  if [[ ${USE_CLANG} != "false" ]]; then
+    install_clang15
+  fi
+}
+
+# Install packages required for build.
+function install_velox_deps_from_apt {
+  ${SUDO} apt update
+  ${SUDO} apt install -y \
+    libc-ares-dev \
+    libcurl4-openssl-dev \
+    libssl-dev \
+    libicu-dev \
+    libdouble-conversion-dev \
+    libgoogle-glog-dev \
+    libbz2-dev \
+    libgflags-dev \
+    libgmock-dev \
+    libevent-dev \
+    liblz4-dev \
+    libzstd-dev \
+    libre2-dev \
+    libsnappy-dev \
+    libsodium-dev \
+    liblzo2-dev \
+    libelf-dev \
+    libdwarf-dev \
+    bison \
+    flex \
+    libfl-dev \
+    tzdata
 }
 
 function install_fmt {
-  github_checkout fmtlib/fmt 8.0.1
-  cmake_install -DFMT_TEST=OFF
+  wget_and_untar https://github.com/fmtlib/fmt/archive/${FMT_VERSION}.tar.gz fmt
+  cmake_install_dir fmt -DFMT_TEST=OFF
+}
+
+function install_boost {
+  wget_and_untar https://github.com/boostorg/boost/releases/download/${BOOST_VERSION}/${BOOST_VERSION}.tar.gz boost
+  (
+    cd ${DEPENDENCY_DIR}/boost
+    if [[ ${USE_CLANG} != "false" ]]; then
+      ./bootstrap.sh --prefix=${INSTALL_PREFIX} --with-toolset="clang-15"
+      # Switch the compiler from the clang-15 toolset which doesn't exist (clang-15.jam) to
+      # clang of version 15 when toolset clang-15 is used.
+      # This reconciles the project-config.jam generation with what the b2 build system allows for customization.
+      sed -i 's/using clang-15/using clang : 15/g' project-config.jam
+      ${SUDO} ./b2 "-j$(nproc)" -d0 install threading=multi toolset=clang-15 --without-python
+    else
+      ./bootstrap.sh --prefix=${INSTALL_PREFIX}
+      ${SUDO} ./b2 "-j$(nproc)" -d0 install threading=multi --without-python
+    fi
+  )
 }
 
 function install_folly {
-  github_checkout facebook/folly "${FB_OS_VERSION}"
-  cmake_install -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON
+  wget_and_untar https://github.com/facebook/folly/archive/refs/tags/${FB_OS_VERSION}.tar.gz folly
+  cmake_install_dir folly -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON
 }
 
 function install_fizz {
-  github_checkout facebookincubator/fizz "${FB_OS_VERSION}"
-  cmake_install -DBUILD_TESTS=OFF -S fizz
+  wget_and_untar https://github.com/facebookincubator/fizz/archive/refs/tags/${FB_OS_VERSION}.tar.gz fizz
+  cmake_install_dir fizz/fizz -DBUILD_TESTS=OFF
 }
 
 function install_wangle {
-  github_checkout facebook/wangle "${FB_OS_VERSION}"
-  cmake_install -DBUILD_TESTS=OFF -S wangle
+  wget_and_untar https://github.com/facebook/wangle/archive/refs/tags/${FB_OS_VERSION}.tar.gz wangle
+  cmake_install_dir wangle/wangle -DBUILD_TESTS=OFF
+}
+
+function install_mvfst {
+  wget_and_untar https://github.com/facebook/mvfst/archive/refs/tags/${FB_OS_VERSION}.tar.gz mvfst
+  cmake_install_dir mvfst -DBUILD_TESTS=OFF
 }
 
 function install_fbthrift {
-  github_checkout facebook/fbthrift "${FB_OS_VERSION}"
-  cmake_install -DBUILD_TESTS=OFF
+  wget_and_untar https://github.com/facebook/fbthrift/archive/refs/tags/${FB_OS_VERSION}.tar.gz fbthrift
+  cmake_install_dir fbthrift -Denable_tests=OFF -DBUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF
 }
 
 function install_conda {
-  mkdir -p conda && cd conda
-  wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
-  MINICONDA_PATH=/opt/miniconda-for-velox
-  bash Miniconda3-latest-Linux-x86_64.sh -b -p $MINICONDA_PATH
+  MINICONDA_PATH="${HOME:-/opt}/miniconda-for-velox"
+  if [ -e ${MINICONDA_PATH} ]; then
+    echo "File or directory already exists: ${MINICONDA_PATH}"
+    return
+  fi
+  ARCH=$(uname -m)
+  if [ "$ARCH" != "x86_64" ] && [ "$ARCH" != "aarch64" ]; then
+    echo "Unsupported architecture: $ARCH"
+    exit 1
+  fi
+  (
+    mkdir -p conda && cd conda
+    wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-$ARCH.sh -O Miniconda3-latest-Linux-$ARCH.sh
+    bash Miniconda3-latest-Linux-$ARCH.sh -b -p $MINICONDA_PATH
+  )
+}
+
+function install_duckdb {
+  if $BUILD_DUCKDB ; then
+    echo 'Building DuckDB'
+    wget_and_untar https://github.com/duckdb/duckdb/archive/refs/tags/v0.8.1.tar.gz duckdb
+    cmake_install_dir duckdb -DBUILD_UNITTESTS=OFF -DENABLE_SANITIZER=OFF -DENABLE_UBSAN=OFF -DBUILD_SHELL=OFF -DEXPORT_DLL_SYMBOLS=OFF -DCMAKE_BUILD_TYPE=Release
+  fi
+}
+
+function install_arrow {
+  wget_and_untar https://archive.apache.org/dist/arrow/arrow-${ARROW_VERSION}/apache-arrow-${ARROW_VERSION}.tar.gz arrow
+  cmake_install_dir arrow/cpp \
+    -DARROW_PARQUET=OFF \
+    -DARROW_WITH_THRIFT=ON \
+    -DARROW_WITH_LZ4=ON \
+    -DARROW_WITH_SNAPPY=ON \
+    -DARROW_WITH_ZLIB=ON \
+    -DARROW_WITH_ZSTD=ON \
+    -DARROW_JEMALLOC=OFF \
+    -DARROW_SIMD_LEVEL=NONE \
+    -DARROW_RUNTIME_SIMD_LEVEL=NONE \
+    -DARROW_WITH_UTF8PROC=OFF \
+    -DARROW_TESTING=ON \
+    -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DARROW_BUILD_STATIC=ON \
+    -DThrift_SOURCE=BUNDLED
+
+  (
+    # Install thrift.
+    cd ${DEPENDENCY_DIR}/arrow/cpp/_build/thrift_ep-prefix/src/thrift_ep-build
+    $SUDO cmake --install ./ --prefix ${INSTALL_PREFIX}
+  )
+}
+
+function install_cuda {
+  # See https://developer.nvidia.com/cuda-downloads
+  if ! dpkg -l cuda-keyring 1>/dev/null; then
+    wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
+    $SUDO dpkg -i cuda-keyring_1.1-1_all.deb
+    rm cuda-keyring_1.1-1_all.deb
+    $SUDO apt update
+  fi
+  $SUDO apt install -y cuda-nvcc-$(echo $1 | tr '.' '-') cuda-cudart-dev-$(echo $1 | tr '.' '-')
+}
+
+function install_fast_float {
+  # Dependency of folly.
+  wget_and_untar https://github.com/fastfloat/fast_float/archive/refs/tags/${FAST_FLOAT_VERSION}.tar.gz fast_float
+  cmake_install_dir fast_float
 }
 
 function install_velox_deps {
+  run_and_time install_velox_deps_from_apt
   run_and_time install_fmt
+  run_and_time install_boost
+  run_and_time install_fast_float
   run_and_time install_folly
   run_and_time install_fizz
   run_and_time install_wangle
+  run_and_time install_mvfst
   run_and_time install_fbthrift
   run_and_time install_conda
+  run_and_time install_duckdb
+  run_and_time install_arrow
+}
+
+function install_apt_deps {
+  install_build_prerequisites
+  install_velox_deps_from_apt
 }
 
 (return 2> /dev/null) && return # If script was sourced, don't run commands.
 
 (
+  if [[ ${USE_CLANG} != "false" ]]; then
+    export CC=/usr/bin/clang-15
+    export CXX=/usr/bin/clang++-15
+  fi
   if [[ $# -ne 0 ]]; then
     for cmd in "$@"; do
       run_and_time "${cmd}"
     done
+    echo "All specified dependencies installed!"
   else
+    if [ "${INSTALL_PREREQUISITES:-Y}" == "Y" ]; then
+      echo "Installing build dependencies"
+      run_and_time install_build_prerequisites
+    else
+      echo "Skipping installation of build dependencies since INSTALL_PREREQUISITES is not set"
+    fi
     install_velox_deps
+    echo "All dependencies for Velox installed!"
+    if [[ ${USE_CLANG} != "false" ]]; then
+      echo "To use clang for the Velox build set the CC and CXX environment variables in your session."
+      echo "  export CC=/usr/bin/clang-15"
+      echo "  export CXX=/usr/bin/clang++-15"
+    fi
   fi
 )
 
-echo "All deps for Velox installed! Now try \"make\""
diff --git a/scripts/setup-velox-torcharrow.sh b/scripts/setup-velox-torcharrow.sh
deleted file mode 100755
index a31e35515d214..0000000000000
--- a/scripts/setup-velox-torcharrow.sh
+++ /dev/null
@@ -1,102 +0,0 @@
-#!/bin/bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set -efx -o pipefail
-
-# Some of the packages must be build with the same compiler flags
-# so that some low level types are the same size. Also, disable warnings.
-
-SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
-source $SCRIPTDIR/setup-helper-functions.sh
-CPU_TARGET="${CPU_TARGET:-avx}"
-CONDA=${1:-true}
-export CFLAGS=$(get_cxx_flags $CPU_TARGET)
-export CXXFLAGS=$CFLAGS  # Used by boost.
-
-yum -y install bzip2-devel \
-  ccache \
-  double-conversion-devel \
-  flex \
-  gflags-devel \
-  git \
-  glog-devel \
-  libevent-devel \
-  libicu-devel \
-  libzstd-devel \
-  lz4-devel \
-  lzo-devel \
-  ninja-build \
-  pcre-devel \
-  perl-core \
-  python3-devel.x86_64 \
-  re2-devel \
-  snappy-devel \
-  wget \
-  zlib-devel
-
-if [ "$CONDA" = true ]; then
-  #Install conda
-  rpm --import https://repo.anaconda.com/pkgs/misc/gpgkeys/anaconda.asc
-
-  # Add the Anaconda repository
-  cat <<EOF > /etc/yum.repos.d/conda.repo
-[conda]
-name=Conda
-baseurl=https://repo.anaconda.com/pkgs/misc/rpmrepo/conda
-enabled=1
-gpgcheck=1
-gpgkey=https://repo.anaconda.com/pkgs/misc/gpgkeys/anaconda.asc
-EOF
-
-  yum -y install conda
-fi
-
-function cmake_install {
-  cmake -B "$1-build" -GNinja -DCMAKE_CXX_STANDARD=17 \
-    -DCMAKE_CXX_FLAGS="${CFLAGS}" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_BUILD_TYPE=Release -Wno-dev "$@"
-  ninja -C "$1-build" install
-}
-
-function wget_and_untar {
-  local URL=$1
-  local DIR=$2
-  mkdir -p "${DIR}"
-  wget --no-check-certificate -q --max-redirect 3 -O - "${URL}" | tar -xz -C "${DIR}" --strip-components=1
-}
-
-wget_and_untar https://github.com/gflags/gflags/archive/refs/tags/v2.2.2.tar.gz gflags
-wget_and_untar https://ftp.openssl.org/source/openssl-1.1.1k.tar.gz openssl &
-wget_and_untar https://boostorg.jfrog.io/artifactory/main/release/1.69.0/source/boost_1_69_0.tar.gz boost &
-wget_and_untar https://github.com/facebook/folly/archive/v2022.11.14.00.tar.gz folly &
-wget_and_untar https://github.com/fmtlib/fmt/archive/refs/tags/8.0.1.tar.gz fmt &
-
-wait
-
-(
-  cd openssl
-  ./config --prefix=/usr --openssldir=/etc/ssl --libdir=lib no-shared zlib-dynamic
-  make install
-)
-
-(
-  cd boost
-  ls
-  ./bootstrap.sh --prefix=/usr/local
-  CPLUS_INCLUDE_PATH=/usr/include/python3.6m  ./b2 "-j$(nproc)" -d0 install threading=multi
-)
-
-cmake_install gflags -DBUILD_SHARED_LIBS=ON
-cmake_install fmt -DFMT_TEST=OFF
-cmake_install folly -DFOLLY_HAVE_INT128_T=ON
diff --git a/scripts/signature.py b/scripts/signature.py
index 95a51b11371b5..a619d4fe05a1b 100644
--- a/scripts/signature.py
+++ b/scripts/signature.py
@@ -13,11 +13,14 @@
 # limitations under the License.
 import argparse
 import json
+import os
+import re
 import sys
+from typing import Any
 
-import pyvelox.pyvelox as pv
 from deepdiff import DeepDiff
 
+import pyvelox.pyvelox as pv
 
 # Utility to export and diff function signatures.
 
@@ -31,8 +34,44 @@ class bcolors:
     BOLD = "\033[1m"
 
 
+aggregate_pattern = re.compile("(.*)(_merge|_merge_extract|_partial)")
+
+
+def get_error_string(error_message):
+    return f"""
+Incompatible changes in function signatures have been detected.
+
+{error_message}
+
+Changing or removing function signatures breaks backwards compatibility as some users may rely on function signatures that no longer exist.
+
+"""
+
+
+def set_gh_output(name: str, value: Any):
+    """Sets a Github Actions output variable. Only single line values are supported.
+    value will be converted to a lower case string."""
+    value = str(value).lower()
+
+    if "\n" in value:
+        raise ValueError("Only single line values are supported.")
+
+    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+        f.write(f"{name}={value}\n")
+
+
+def show_error(error_message, error_path):
+    if error_path:
+        with open(error_path, "a+") as f:
+            f.writelines(get_error_string(error_message))
+
+    print(get_error_string(error_message))
+
+
 def export(args):
     """Exports Velox function signatures."""
+    pv.clear_signatures()
+
     if args.spark:
         pv.register_spark_signatures()
 
@@ -41,6 +80,30 @@ def export(args):
 
     signatures = pv.get_function_signatures()
 
+    # Convert signatures to json
+    jsoned_signatures = {}
+    for key in signatures.keys():
+        jsoned_signatures[key] = [str(value) for value in signatures[key]]
+
+    # Persist to file
+    with open(args.output_file, "w") as f:
+        json.dump(jsoned_signatures, f)
+
+    return 0
+
+
+def export_aggregates(args):
+    """Exports Velox Aggregate function signatures."""
+    pv.clear_aggregate_signatures()
+
+    if args.spark:
+        pv.register_spark_aggregate_signatures()
+
+    if args.presto:
+        pv.register_presto_aggregate_signatures()
+
+    signatures = pv.get_aggregate_function_signatures()
+
     # Convert signatures to json
     jsoned_signatures = {}
     for key in signatures.keys():
@@ -51,104 +114,190 @@ def export(args):
     return 0
 
 
-def diff_signatures(base_signatures, contender_signatures):
+def diff_signatures(base_signatures, contender_signatures, error_path=""):
     """Diffs Velox function signatures. Returns a tuple of the delta diff and exit status"""
 
     delta = DeepDiff(
         base_signatures,
         contender_signatures,
         ignore_order=True,
+        cutoff_distance_for_pairs=0.9,
         report_repetition=True,
         view="tree",
     )
     exit_status = 0
     if delta:
         if "dictionary_item_removed" in delta:
-            print(
-                f"Signature removed: {bcolors.FAIL}{delta['dictionary_item_removed']}"
-            )
+            error_message = ""
+            for dic_removed in delta["dictionary_item_removed"]:
+                error_message += (
+                    f"""Function '{dic_removed.get_root_key()}' has been removed.\n"""
+                )
+            show_error(error_message, error_path)
             exit_status = 1
 
         if "values_changed" in delta:
-            print(f"Signature changed: {bcolors.FAIL}{delta['values_changed']}")
+            error_message = ""
+            for value_change in delta["values_changed"]:
+                error_message += f"""'{value_change.get_root_key()}{value_change.t1}' is changed to '{value_change.get_root_key()}{value_change.t2}'.\n"""
+            show_error(error_message, error_path)
             exit_status = 1
 
         if "repetition_change" in delta:
-            print(f"Signature repeated: {bcolors.FAIL}{delta['repetition_change']}")
+            error_message = ""
+            for rep_change in delta["repetition_change"]:
+                error_message += f"""'{rep_change.get_root_key()}{rep_change.t1}' is repeated {rep_change.repetition['new_repeat']} times.\n"""
+            show_error(error_message, error_path)
             exit_status = 1
 
         if "iterable_item_removed" in delta:
-            print(
-                f"Iterable item removed: {bcolors.FAIL}{delta['iterable_item_removed']}"
-            )
+            error_message = ""
+            for iter_change in delta["iterable_item_removed"]:
+                error_message += f"""{iter_change.get_root_key()} has its function signature '{iter_change.t1}' removed.\n"""
+            show_error(error_message, error_path)
             exit_status = 1
 
-        print(f"Found differences: {bcolors.OKGREEN}{delta}")
-
     else:
         print(f"{bcolors.BOLD}No differences found.")
 
-    if exit_status:
-        print(
-            f""" 
-            {bcolors.BOLD}Incompatible changes in function signatures have been detected.
-            This means your changes have modified function signatures and possibly broken backwards compatibility.  
-        """
-        )
-
     return delta, exit_status
 
 
 def diff(args):
     """Diffs Velox function signatures."""
-    base_signatures = json.load(args.base)
-    contender_signatures = json.load(args.contender)
+    with open(args.base) as f:
+        base_signatures = json.load(f)
+
+    with open(args.contender) as f:
+        contender_signatures = json.load(f)
     return diff_signatures(base_signatures, contender_signatures)[1]
 
 
 def bias(args):
-    base_signatures = json.load(args.base)
-    contender_signatures = json.load(args.contender)
+    with open(args.base) as f:
+        base_signatures = json.load(f)
+
+    with open(args.contender) as f:
+        contender_signatures = json.load(f)
+
     tickets = args.ticket_value
     bias_output, status = bias_signatures(
-        base_signatures, contender_signatures, tickets
+        base_signatures, contender_signatures, tickets, args.error_path
     )
-    if status:
-        return status
 
     if bias_output:
         with open(args.output_path, "w") as f:
             print(f"{bias_output}", file=f, end="")
 
-    return 0
+    return status
 
 
-def bias_signatures(base_signatures, contender_signatures, tickets):
+def bias_signatures(base_signatures, contender_signatures, tickets, error_path):
     """Returns newly added functions as string and a status flag.
     Newly added functions are biased like so `fn_name1=<ticket_count>,fn_name2=<ticket_count>`.
-    If it detects incompatible changes returns 1 in the status and empty string.
+    If it detects incompatible changes returns 1 in the status.
     """
-    delta, status = diff_signatures(base_signatures, contender_signatures)
-
-    # Return if the signature check call flags incompatible changes.
-    if status:
-        return "", status
+    delta, status = diff_signatures(base_signatures, contender_signatures, error_path)
 
     if not delta:
         print(f"{bcolors.BOLD} No changes detected: Nothing to do!")
-        return "", 0
+        return "", status
 
     function_set = set()
     for items in delta.values():
         for item in items:
             function_set.add(item.get_root_key())
 
-    print(f"{bcolors.BOLD}Functions to be biased: {function_set}")
+    if function_set:
+        return f"{f'={tickets},'.join(sorted(function_set)) + f'={tickets}'}", status
+
+    return "", status
+
+
+def bias_aggregates(args):
+    """
+    Finds and exports aggregates whose signatures have been modified agasint a baseline.
+    Saves the results to a file and sets a Github Actions Output.
+    Currently this is hardcoded to presto aggregates.
+    """
+    with open(args.base) as f:
+        base_signatures = json.load(f)
+
+    with open(args.contender) as f:
+        contender_signatures = json.load(f)
+
+    delta, status = diff_signatures(
+        base_signatures, contender_signatures, args.error_path
+    )
+
+    set_gh_output("presto_aggregate_error", status == 1)
+
+    if not delta:
+        print(f"{bcolors.BOLD} No changes detected: Nothing to do!")
+        return status
+
+    function_set = set()
+    for items in delta.values():
+        for item in items:
+            fn_name = item.get_root_key()
+            pattern = aggregate_pattern.match(fn_name)
+            if pattern:
+                function_set.add(pattern.group(1))
+            else:
+                function_set.add(fn_name)
 
     if function_set:
-        return f"{f'={tickets},'.join(sorted(function_set)) + f'={tickets}'}", 0
+        biased_functions = ",".join(function_set)
+        with open(args.output_path, "w") as f:
+            print(f"{biased_functions}", file=f, end="")
+
+        set_gh_output("presto_aggregate_functions", True)
+
+    return 0
+
+
+def gh_bias_check(args):
+    """
+    Exports signatures for the given group(s) and checks them for changes compared to a baseline.
+    Saves the results to a file and sets a Github Actions Output for each group.
+    """
+    if not os.getenv("GITHUB_ACTIONS"):
+        print("This command is meant to be run in a Github Actions environment.")
+        return 1
+
+    # export signatures for each group
+    for group in args.group:
+        print(f"Exporting {group} signatures...")
+        export_args = parse_args(
+            [
+                "export",
+                f"--{group}",
+                os.path.join(args.signature_dir, group + args.contender_postfix),
+            ]
+        )
+        export(export_args)
+
+    # compare signatures for each group
+    for group in args.group:
+        print(f"Comparing {group} signatures...")
+        bias_args = parse_args(
+            [
+                "bias",
+                os.path.join(args.signature_dir, group + args.base_postfix),
+                os.path.join(args.signature_dir, group + args.contender_postfix),
+                os.path.join(args.signature_dir, group + args.output_postfix),
+                os.path.join(args.signature_dir, group + "_errors"),
+            ]
+        )
 
-    return "", 0
+        bias_status = bias(bias_args)
+        set_gh_output(f"{group}_error", bias_status == 1)
+
+        # check if there are any changes that require the bias fuzzer to run
+        has_tickets = os.path.isfile(
+            os.path.join(args.signature_dir, group + args.output_postfix)
+        )
+        set_gh_output(f"{group}_functions", has_tickets)
 
 
 def get_tickets(val):
@@ -169,20 +318,55 @@ def parse_args(args):
     command = parser.add_subparsers(dest="command")
     export_command_parser = command.add_parser("export")
     export_command_parser.add_argument("--spark", action="store_true")
-    export_command_parser.add_argument("--presto", action="store_false")
-    export_command_parser.add_argument("output_file", type=argparse.FileType("w"))
+    export_command_parser.add_argument("--presto", action="store_true")
+    export_command_parser.add_argument("output_file", type=str)
+
+    export_aggregates_command_parser = command.add_parser("export_aggregates")
+    export_aggregates_command_parser.add_argument("--spark", action="store_true")
+    export_aggregates_command_parser.add_argument("--presto", action="store_true")
+    export_aggregates_command_parser.add_argument(
+        "output_file", type=argparse.FileType("w")
+    )
 
     diff_command_parser = command.add_parser("diff")
-    diff_command_parser.add_argument("base", type=argparse.FileType("r"))
-    diff_command_parser.add_argument("contender", type=argparse.FileType("r"))
+    diff_command_parser.add_argument("base", type=str)
+    diff_command_parser.add_argument("contender", type=str)
 
     bias_command_parser = command.add_parser("bias")
-    bias_command_parser.add_argument("base", type=argparse.FileType("r"))
-    bias_command_parser.add_argument("contender", type=argparse.FileType("r"))
-    bias_command_parser.add_argument("output_path")
+    bias_command_parser.add_argument("base", type=str)
+    bias_command_parser.add_argument("contender", type=str)
+    bias_command_parser.add_argument("output_path", type=str)
     bias_command_parser.add_argument(
         "ticket_value", type=get_tickets, default=10, nargs="?"
     )
+    bias_command_parser.add_argument("error_path", type=str, default="")
+
+    gh_command_parser = command.add_parser("gh_bias_check")
+    gh_command_parser.add_argument(
+        "group",
+        nargs="+",
+        help='One or more group names to check for changed signatures. e.g. "spark" or "presto"',
+        type=str,
+    )
+    gh_command_parser.add_argument(
+        "--signature_dir", type=str, default="/tmp/signatures"
+    )
+    gh_command_parser.add_argument(
+        "--base_postfix", type=str, default="_signatures_main.json"
+    )
+    gh_command_parser.add_argument(
+        "--contender_postfix", type=str, default="_signatures_contender.json"
+    )
+    gh_command_parser.add_argument(
+        "--output_postfix", type=str, default="_bias_functions"
+    )
+
+    bias_aggregate_command_parser = command.add_parser("bias_aggregates")
+    bias_aggregate_command_parser.add_argument("base", type=str)
+    bias_aggregate_command_parser.add_argument("contender", type=str)
+    bias_aggregate_command_parser.add_argument("output_path", type=str)
+    bias_aggregate_command_parser.add_argument("error_path", type=str, default="")
+
     parser.set_defaults(command="help")
 
     return parser.parse_args(args)
diff --git a/scripts/spark-container.dockerfile b/scripts/spark-container.dockerfile
new file mode 100644
index 0000000000000..7b7df7910c794
--- /dev/null
+++ b/scripts/spark-container.dockerfile
@@ -0,0 +1,45 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Build the test and build container for presto_cpp
+#
+FROM ghcr.io/facebookincubator/velox-dev:centos9 
+
+ARG SPARK_VERSION=3.5.1
+
+ADD scripts /velox/scripts/
+RUN wget https://archive.apache.org/dist/spark/spark-${SPARK_VERSION}/spark-${SPARK_VERSION}-bin-hadoop3.tgz
+RUN wget https://repo1.maven.org/maven2/org/apache/spark/spark-connect_2.12/${SPARK_VERSION}/spark-connect_2.12-${SPARK_VERSION}.jar
+
+ARG SPARK_PKG=spark-${SPARK_VERSION}-bin-hadoop3.tgz
+ARG SPARK_CONNECT_JAR=spark-connect_2.12-${SPARK_VERSION}.jar
+
+ENV SPARK_HOME="/opt/spark-server"
+
+RUN dnf install -y java-11-openjdk less procps python3 tzdata \
+    && ln -s $(which python3) /usr/bin/python \
+    && tar -zxf $SPARK_PKG \
+    && mv ./spark-${SPARK_VERSION}-bin-hadoop3 $SPARK_HOME \
+    && mkdir ${SPARK_HOME}/misc/ \
+    && mv ./$SPARK_CONNECT_JAR ${SPARK_HOME}/misc/
+
+# We set the timezone to America/Los_Angeles due to issue
+# detailed here : https://github.com/facebookincubator/velox/issues/8127
+ENV TZ=America/Los_Angeles
+
+COPY scripts/spark/conf/spark-defaults.conf.example $SPARK_HOME/conf/spark-defaults.conf
+COPY scripts/spark/conf/spark-env.sh.example $SPARK_HOME/conf/spark-env.sh
+COPY scripts/spark/conf/workers.example $SPARK_HOME/conf/workers
+COPY scripts/spark/start-spark.sh /opt
+
+WORKDIR /velox
diff --git a/scripts/spark/conf/spark-defaults.conf.example b/scripts/spark/conf/spark-defaults.conf.example
new file mode 100644
index 0000000000000..5b008b4480144
--- /dev/null
+++ b/scripts/spark/conf/spark-defaults.conf.example
@@ -0,0 +1 @@
+spark.master local[*]
diff --git a/scripts/spark/conf/spark-env.sh.example b/scripts/spark/conf/spark-env.sh.example
new file mode 100644
index 0000000000000..8cd004a86130f
--- /dev/null
+++ b/scripts/spark/conf/spark-env.sh.example
@@ -0,0 +1 @@
+export SPARK_DAEMON_MEMORY=5g
diff --git a/scripts/spark/conf/workers.example b/scripts/spark/conf/workers.example
new file mode 100644
index 0000000000000..2fbb50c4a8dc7
--- /dev/null
+++ b/scripts/spark/conf/workers.example
@@ -0,0 +1 @@
+localhost
diff --git a/scripts/spark/start-spark.sh b/scripts/spark/start-spark.sh
new file mode 100755
index 0000000000000..7aca5999f8f94
--- /dev/null
+++ b/scripts/spark/start-spark.sh
@@ -0,0 +1,18 @@
+#!/bin/sh
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -e
+
+"$SPARK_HOME"/sbin/start-connect-server.sh --jars "$SPARK_HOME"/misc/spark-connect_2.12-3.5.1.jar
diff --git a/scripts/tests/data/foo.almost.cpp b/scripts/tests/data/foo.almost.cpp
index 2804910f6e73a..e0d9ceefb65cb 100644
--- a/scripts/tests/data/foo.almost.cpp
+++ b/scripts/tests/data/foo.almost.cpp
@@ -14,12 +14,12 @@
  */
 import argparse import fnmatch import os import regex import sys
 
-    class attrdict(dict) : __getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
+    class attrdict(dict) :__getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
 
-                   def parse_args() : parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
+                   def parse_args() :parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           return parser.parse_args()
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return parser.parse_args()
diff --git a/scripts/tests/data/foo.cpp b/scripts/tests/data/foo.cpp
index f4f78dfbffbe2..d631de2ff2e1d 100644
--- a/scripts/tests/data/foo.cpp
+++ b/scripts/tests/data/foo.cpp
@@ -1,11 +1,11 @@
 import argparse import fnmatch import os import regex import sys
 
-    class attrdict(dict) : __getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
+    class attrdict(dict) :__getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
 
-                   def parse_args() : parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
+                   def parse_args() :parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           return parser.parse_args()
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return parser.parse_args()
diff --git a/scripts/tests/data/foo.expected.cpp b/scripts/tests/data/foo.expected.cpp
index e3f75b39c6a5a..31b2bce9b2833 100644
--- a/scripts/tests/data/foo.expected.cpp
+++ b/scripts/tests/data/foo.expected.cpp
@@ -13,12 +13,12 @@
  */
 import argparse import fnmatch import os import regex import sys
 
-    class attrdict(dict) : __getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
+    class attrdict(dict) :__getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
 
-                   def parse_args() : parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
+                   def parse_args() :parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           return parser.parse_args()
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return parser.parse_args()
diff --git a/scripts/tests/data/foo.expected.h b/scripts/tests/data/foo.expected.h
index e3f75b39c6a5a..31b2bce9b2833 100644
--- a/scripts/tests/data/foo.expected.h
+++ b/scripts/tests/data/foo.expected.h
@@ -13,12 +13,12 @@
  */
 import argparse import fnmatch import os import regex import sys
 
-    class attrdict(dict) : __getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
+    class attrdict(dict) :__getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
 
-                   def parse_args() : parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
+                   def parse_args() :parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           return parser.parse_args()
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return parser.parse_args()
diff --git a/scripts/tests/data/foo.h b/scripts/tests/data/foo.h
index f4f78dfbffbe2..d631de2ff2e1d 100644
--- a/scripts/tests/data/foo.h
+++ b/scripts/tests/data/foo.h
@@ -1,11 +1,11 @@
 import argparse import fnmatch import os import regex import sys
 
-    class attrdict(dict) : __getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
+    class attrdict(dict) :__getattr__ = dict.__getitem__ __setattr__ = dict.__setitem__
 
-                   def parse_args() : parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
+                   def parse_args() :parser = argparse.ArgumentParser(description = 'Update license headers') parser.add_argument('--header', default = 'license.header', help = 'header file') parser.add_argument('--extra', default = 30, help = 'extra characters past beginning of file to look for header') parser.add_argument('--editdist', default = 7, help = 'max edit distance between headers') parser.add_argument('--remove', default = False, action = "store_true", help = 'remove the header') parser.add_argument('--cslash', default = False, action = "store_true", help = 'use C slash "//" style comments') parser.add_argument('-v', default = False, action = "store_true", dest = "verbose", help = 'verbose output')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           group = parser.add_mutually_exclusive_group() group.add_argument('-k', default = False, action = "store_true", dest = "check", help = 'check headers') group.add_argument('-i', default = False, action = "store_true", dest = "inplace", help = 'edit file inplace')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         parser.add_argument('files', metavar = 'FILES', nargs = '+', help = 'files to process')
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           return parser.parse_args()
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return parser.parse_args()
diff --git a/scripts/tests/test_signature.py b/scripts/tests/test_signature.py
index a32c1121c0b72..e003fb5e97309 100644
--- a/scripts/tests/test_signature.py
+++ b/scripts/tests/test_signature.py
@@ -13,9 +13,11 @@
 # limitations under the License.
 
 import unittest
-from scripts.signature import bias_signatures
+import unittest.mock
+from scripts.signature import bias_signatures, get_error_string
 from pathlib import Path
 import json
+import io
 
 
 def read_from_file(file_path):
@@ -65,6 +67,54 @@ def test_bias(self):
 
         self.assertEqual(bias_functions, "bar=10,foo=10")
 
+    @unittest.mock.patch("sys.stdout", new_callable=io.StringIO)
+    def get_bias_messaging(self, base_signatures, contender_signatures, mock_stdout):
+        test_bias(base_signatures, contender_signatures)
+        return mock_stdout.getvalue()
+
+    def assert_messaging(self, base_signatures, contender_signatures, expected_message):
+        test_bias(base_signatures, contender_signatures)
+        actual = self.get_bias_messaging(base_signatures, contender_signatures)
+        expected = get_error_string(expected_message)
+        expected += "\n"  # Add trailing newline for std output.
+        self.assertEquals(expected, actual)
+
+    def test_messaging(self):
+        # Remove a signature
+        self.assert_messaging(
+            """{"reverse": ["(array(T)) -> array(T)"]}""",
+            """{"reverse": []}""",
+            "reverse has its function signature '(array(T)) -> array(T)' removed.\n",
+        )
+
+        # Remove more than one signature
+        self.assert_messaging(
+            """{"reverse": ["(array(T)) -> array(T)", "(varchar) -> varchar"]}""",
+            """{"reverse": []}""",
+            """reverse has its function signature '(array(T)) -> array(T)' removed.\nreverse has its function signature '(varchar) -> varchar' removed.\n""",
+        )
+
+        # Mutate a signature
+        self.assert_messaging(
+            """{"reverse": ["(array(T)) -> array(T)"]}""",
+            """{"reverse": ["(array(T)) -> array(varchar)"]}""",
+            """'reverse(array(T)) -> array(T)' is changed to 'reverse(array(T)) -> array(varchar)'.\n""",
+        )
+
+        # Function repeated
+        self.assert_messaging(
+            """{"reverse": ["(array(T)) -> array(T)"]}""",
+            """{"reverse": ["(array(T)) -> array(T)", "(array(T)) -> array(T)"]}""",
+            "'reverse(array(T)) -> array(T)' is repeated 2 times.\n",
+        )
+
+        # Remove a udf
+        self.assert_messaging(
+            """{"reverse": ["(array(T)) -> array(T)"]}""",
+            """{}""",
+            "Function 'reverse' has been removed.\n",
+        )
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/scripts/ubuntu-22.04-cpp.dockerfile b/scripts/ubuntu-22.04-cpp.dockerfile
index 2aa1ee7cbb3ff..ea98a0f64b9eb 100644
--- a/scripts/ubuntu-22.04-cpp.dockerfile
+++ b/scripts/ubuntu-22.04-cpp.dockerfile
@@ -11,10 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-ARG base=amd64/ubuntu:22.04
-# Set a default timezone, can be overriden via ARG
-ARG tz="Europe/Madrid"
-
+ARG base=ubuntu:22.04
 FROM ${base}
 
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]
@@ -32,6 +29,8 @@ ADD scripts /velox/scripts/
 # are required to avoid tzdata installation
 # to prompt for region selection.
 ARG DEBIAN_FRONTEND="noninteractive"
+# Set a default timezone, can be overriden via ARG
+ARG tz="Etc/UTC"
 ENV TZ=${tz}
 RUN /velox/scripts/setup-ubuntu.sh
 
diff --git a/scripts/velox-torcharrow-container.dockfile b/scripts/velox-torcharrow-container.dockfile
deleted file mode 100644
index f4498101cfb9d..0000000000000
--- a/scripts/velox-torcharrow-container.dockfile
+++ /dev/null
@@ -1,21 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Build container to be used for TorchArrow.
-
-FROM quay.io/pypa/manylinux2014_x86_64
-ARG cpu_target
-COPY setup-velox-torcharrow.sh /
-COPY setup-helper-functions.sh /
-RUN mkdir build && ( cd build && CPU_TARGET="$cpu_target" bash /setup-velox-torcharrow.sh ) && rm -rf build
diff --git a/scripts/velox_env_linux.yml b/scripts/velox_env_linux.yml
new file mode 100644
index 0000000000000..fc0b4cf0c40fe
--- /dev/null
+++ b/scripts/velox_env_linux.yml
@@ -0,0 +1,67 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: velox_base
+
+channels:
+  - conda-forge
+
+variables:
+  CC: clang
+  CXX: clang++
+
+dependencies:
+# tools
+  - binutils
+  - bison
+  - clangxx=14
+  - cmake=3.28.3
+  - ccache
+  - flex
+  - gxx=12 # has to be installed to get clang to work...
+  - make
+  - minio-server
+  - ninja
+  - nodejs
+  - openjdk=8.*
+  - python=3.8
+  - sysroot_linux-64=2.17
+# dependencies
+  - aws-sdk-cpp
+  - azure-storage-blobs-cpp
+  - boost-cpp
+  - bzip2
+  - double-conversion
+  - fmt=8.0.*
+  - gflags=2.2.2
+  - glog=0.6.0
+  - gmock=1.13
+  - google-cloud-cpp
+  - gtest=1.13
+  - libaio
+  - libdwarf-dev
+  - libevent
+  - libprotobuf=3.21
+  - libsodium
+  - libtool
+  - libunwind
+  - lz4-c
+  - lzo
+  - openssl=1.1
+  - re2
+  - simdjson
+  - snappy
+  - xz
+  - zlib
+  - zstd
diff --git a/scripts/velox_env_mac.yml b/scripts/velox_env_mac.yml
new file mode 100644
index 0000000000000..a999f18d0d6b0
--- /dev/null
+++ b/scripts/velox_env_mac.yml
@@ -0,0 +1,66 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: velox_base
+
+channels:
+  - conda-forge
+
+variables:
+  CC: clang
+  CXX: clang++
+
+dependencies:
+# tools
+  - binutils
+  - bison
+  - clangxx=14 # pin to something recent'ish to avoid warings on upgrade
+  - cmake=3.28
+  - ccache
+  - flex
+  - make
+  - minio-server
+  - ninja
+  - nodejs
+  - openjdk=8.*
+  - python=3.8
+  - sysroot_linux-64=2.17
+# dependencies
+  - aws-sdk-cpp
+  - azure-storage-blobs-cpp
+  - boost-cpp
+  - bzip2
+  - crc32c
+  - double-conversion
+  - fmt=8.0.*
+  - gflags=2.2.2
+  - glog=0.6.0
+  - gmock=1.13
+  - google-cloud-cpp
+  - gtest=1.13
+  - libdwarf-dev
+  - libevent
+  - libprotobuf=3.21
+  - libsodium
+  - libtool
+  - lz4-c
+  - lzo
+  - openssl=1.1.*
+  - re2
+  - snappy
+  - simdjson
+  - xz
+  - zlib
+  - zstd
+
diff --git a/setup.py b/setup.py
index 8ec26c7d3aab7..40f8ae9645bfe 100644
--- a/setup.py
+++ b/setup.py
@@ -109,6 +109,16 @@ def run(self):
 
     def build_extension(self, ext):
         extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
+        # Allow using a pre-built Velox library (for CI and development) e.g. 'VELOX_BUILD_DIR=_build/velox/debug'
+        # The build in question must have been built with 'VELOX_BUILD_PYTHON_PACKAGE=ON' and the same python version.
+        if "VELOX_BUILD_DIR" in os.environ:
+            velox_dir = os.path.abspath(os.environ["VELOX_BUILD_DIR"])
+
+            if not os.path.isdir(extdir):
+                os.symlink(velox_dir, os.path.dirname(extdir), target_is_directory=True)
+
+            print(f"Using pre-built Velox library from {velox_dir}")
+            return
 
         # required for auto-detection of auxiliary "native" libs
         if not extdir.endswith(os.path.sep):
@@ -126,9 +136,9 @@ def build_extension(self, ext):
             f"-DCMAKE_BUILD_TYPE={cfg}",
             f"-DCMAKE_INSTALL_PREFIX={extdir}",
             "-DCMAKE_VERBOSE_MAKEFILE=ON",
+            "-DVELOX_BUILD_MINIMAL=ON",
             "-DVELOX_BUILD_PYTHON_PACKAGE=ON",
             f"-DPYTHON_EXECUTABLE={exec_path} ",
-            "-DVELOX_CODEGEN_SUPPORT=OFF",
         ]
         build_args = []
 
@@ -149,9 +159,9 @@ def build_extension(self, ext):
             os.makedirs(self.build_temp)
 
         subprocess.check_call(
-            ["cmake", str(ROOT_DIR)] + cmake_args, cwd=self.build_temp
+            ["cmake", str(ROOT_DIR)] + cmake_args,
+            cwd=self.build_temp,
         )
-        print(self.build_temp)
         subprocess.check_call(
             ["cmake", "--build", "."] + build_args, cwd=self.build_temp
         )
diff --git a/third_party/CMakeLists.txt b/third_party/CMakeLists.txt
deleted file mode 100644
index 570af4593e721..0000000000000
--- a/third_party/CMakeLists.txt
+++ /dev/null
@@ -1,95 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
-                      "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/")
-
-include(ExternalProject)
-
-if(VELOX_ENABLE_ARROW)
-  find_package(Thrift)
-  if(Thrift_FOUND)
-    set(THRIFT_SOURCE "SYSTEM")
-  else()
-    set(THRIFT_SOURCE "BUNDLED")
-  endif()
-  set(ARROW_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/arrow_ep")
-  set(ARROW_CMAKE_ARGS
-      -DARROW_PARQUET=ON
-      -DARROW_WITH_LZ4=ON
-      -DARROW_WITH_SNAPPY=ON
-      -DARROW_WITH_ZLIB=ON
-      -DARROW_WITH_ZSTD=ON
-      -DARROW_JEMALLOC=OFF
-      -DARROW_SIMD_LEVEL=NONE
-      -DARROW_RUNTIME_SIMD_LEVEL=NONE
-      -DARROW_WITH_UTF8PROC=OFF
-      -DARROW_TESTING=ON
-      -DCMAKE_INSTALL_PREFIX=${ARROW_PREFIX}/install
-      -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-      -DARROW_BUILD_STATIC=ON
-      -DThrift_SOURCE=${THRIFT_SOURCE})
-  set(ARROW_LIBDIR ${ARROW_PREFIX}/install/${CMAKE_INSTALL_LIBDIR})
-
-  add_library(thrift STATIC IMPORTED GLOBAL)
-  if(NOT Thrift_FOUND)
-    set(THRIFT_ROOT ${ARROW_PREFIX}/src/arrow_ep-build/thrift_ep-install)
-    set(THRIFT_LIB ${THRIFT_ROOT}/lib/libthrift.a)
-
-    file(MAKE_DIRECTORY ${THRIFT_ROOT}/include)
-    set(THRIFT_INCLUDE_DIR ${THRIFT_ROOT}/include)
-  endif()
-
-  set_property(TARGET thrift PROPERTY INTERFACE_INCLUDE_DIRECTORIES
-                                      ${THRIFT_INCLUDE_DIR})
-  set_property(TARGET thrift PROPERTY IMPORTED_LOCATION ${THRIFT_LIB})
-
-  set(VELOX_ARROW_BUILD_VERSION 13.0.0)
-  set(VELOX_ARROW_BUILD_SHA256_CHECKSUM
-      35dfda191262a756be934eef8afee8d09762cad25021daa626eb249e251ac9e6)
-  set(VELOX_ARROW_SOURCE_URL
-      "https://archive.apache.org/dist/arrow/arrow-${VELOX_ARROW_BUILD_VERSION}/apache-arrow-${VELOX_ARROW_BUILD_VERSION}.tar.gz"
-  )
-
-  resolve_dependency_url(ARROW)
-
-  ExternalProject_Add(
-    arrow_ep
-    PREFIX ${ARROW_PREFIX}
-    URL ${VELOX_ARROW_SOURCE_URL}
-    URL_HASH ${VELOX_ARROW_BUILD_SHA256_CHECKSUM}
-    SOURCE_SUBDIR cpp
-    CMAKE_ARGS ${ARROW_CMAKE_ARGS}
-    BUILD_BYPRODUCTS ${ARROW_LIBDIR}/libarrow.a ${ARROW_LIBDIR}/libparquet.a
-                     ${ARROW_LIBDIR}/libarrow_testing.a ${THRIFT_LIB})
-  add_library(arrow STATIC IMPORTED GLOBAL)
-  add_library(arrow_testing STATIC IMPORTED GLOBAL)
-  add_library(parquet STATIC IMPORTED GLOBAL)
-  add_dependencies(arrow arrow_ep)
-  add_dependencies(arrow_testing arrow)
-  add_dependencies(parquet arrow)
-  file(MAKE_DIRECTORY ${ARROW_PREFIX}/install/include)
-  set_target_properties(
-    arrow arrow_testing parquet PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                           ${ARROW_PREFIX}/install/include)
-  set_target_properties(arrow PROPERTIES IMPORTED_LOCATION
-                                         ${ARROW_LIBDIR}/libarrow.a)
-  set_property(TARGET arrow PROPERTY INTERFACE_LINK_LIBRARIES ${RE2} thrift)
-  set_target_properties(
-    arrow_testing PROPERTIES IMPORTED_LOCATION
-                             ${ARROW_LIBDIR}/libarrow_testing.a)
-  set_target_properties(parquet PROPERTIES IMPORTED_LOCATION
-                                           ${ARROW_LIBDIR}/libparquet.a)
-
-endif()
diff --git a/third_party/cmake_modules/FindThrift.cmake b/third_party/cmake_modules/FindThrift.cmake
deleted file mode 100644
index 07028971d9fcc..0000000000000
--- a/third_party/cmake_modules/FindThrift.cmake
+++ /dev/null
@@ -1,158 +0,0 @@
-# Copyright 2012 Cloudera Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# - Find Thrift (a cross platform RPC lib/tool)
-#
-# Variables used by this module, they can change the default behaviour and need
-# to be set before calling find_package:
-#
-#  Thrift_ROOT - When set, this path is inspected instead of standard library
-#                locations as the root of the Thrift installation.
-#                The environment variable THRIFT_HOME overrides this variable.
-#
-# This module defines
-#  Thrift_FOUND, whether Thrift is found or not
-#  Thrift_COMPILER_FOUND, whether Thrift compiler is found or not
-#
-#  thrift::thrift, a library target to use Thrift
-#  thrift::compiler, a executable target to use Thrift compiler
-
-function(EXTRACT_THRIFT_VERSION)
-  if(THRIFT_INCLUDE_DIR)
-    file(READ "${THRIFT_INCLUDE_DIR}/thrift/config.h" THRIFT_CONFIG_H_CONTENT)
-    string(REGEX MATCH "#define PACKAGE_VERSION \"[0-9.]+\"" THRIFT_VERSION_DEFINITION
-                 "${THRIFT_CONFIG_H_CONTENT}")
-    string(REGEX MATCH "[0-9.]+" Thrift_VERSION "${THRIFT_VERSION_DEFINITION}")
-    set(Thrift_VERSION
-        "${Thrift_VERSION}"
-        PARENT_SCOPE)
-  else()
-    set(Thrift_VERSION
-        ""
-        PARENT_SCOPE)
-  endif()
-endfunction(EXTRACT_THRIFT_VERSION)
-
-if(MSVC_TOOLCHAIN AND NOT DEFINED THRIFT_MSVC_LIB_SUFFIX)
-  if(NOT ARROW_THRIFT_USE_SHARED)
-    if(ARROW_USE_STATIC_CRT)
-      if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
-        set(THRIFT_MSVC_LIB_SUFFIX "mtd")
-      else()
-        set(THRIFT_MSVC_LIB_SUFFIX "mt")
-      endif()
-    else()
-      if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
-        set(THRIFT_MSVC_LIB_SUFFIX "mdd")
-      else()
-        set(THRIFT_MSVC_LIB_SUFFIX "md")
-      endif()
-    endif()
-  endif()
-endif()
-set(THRIFT_LIB_NAME_BASE "thrift${THRIFT_MSVC_LIB_SUFFIX}")
-
-if(ARROW_THRIFT_USE_SHARED)
-  set(THRIFT_LIB_NAMES thrift)
-  if(CMAKE_IMPORT_LIBRARY_SUFFIX)
-    list(APPEND
-         THRIFT_LIB_NAMES
-         "${CMAKE_IMPORT_LIBRARY_PREFIX}${THRIFT_LIB_NAME_BASE}${CMAKE_IMPORT_LIBRARY_SUFFIX}"
-    )
-  endif()
-  list(APPEND
-       THRIFT_LIB_NAMES
-       "${CMAKE_SHARED_LIBRARY_PREFIX}${THRIFT_LIB_NAME_BASE}${CMAKE_SHARED_LIBRARY_SUFFIX}"
-  )
-else()
-  set(THRIFT_LIB_NAMES
-      "${CMAKE_STATIC_LIBRARY_PREFIX}${THRIFT_LIB_NAME_BASE}${CMAKE_STATIC_LIBRARY_SUFFIX}"
-  )
-endif()
-
-if(Thrift_ROOT)
-  find_library(THRIFT_LIB
-               NAMES ${THRIFT_LIB_NAMES}
-               PATHS ${Thrift_ROOT}
-               PATH_SUFFIXES "lib/${CMAKE_LIBRARY_ARCHITECTURE}" "lib")
-  find_path(THRIFT_INCLUDE_DIR thrift/Thrift.h
-            PATHS ${Thrift_ROOT}
-            PATH_SUFFIXES "include")
-  find_program(THRIFT_COMPILER thrift
-               PATHS ${Thrift_ROOT}
-               PATH_SUFFIXES "bin")
-  extract_thrift_version()
-else()
-  # THRIFT-4760: The pkgconfig files are currently only installed when using autotools.
-  # Starting with 0.13, they are also installed for the CMake-based installations of Thrift.
-  find_package(PkgConfig QUIET)
-  pkg_check_modules(THRIFT_PC thrift)
-  if(THRIFT_PC_FOUND)
-    set(THRIFT_INCLUDE_DIR "${THRIFT_PC_INCLUDEDIR}")
-
-    list(APPEND THRIFT_PC_LIBRARY_DIRS "${THRIFT_PC_LIBDIR}")
-
-    find_library(THRIFT_LIB
-                 NAMES ${THRIFT_LIB_NAMES}
-                 PATHS ${THRIFT_PC_LIBRARY_DIRS}
-                 NO_DEFAULT_PATH)
-    find_program(THRIFT_COMPILER thrift
-                 HINTS ${THRIFT_PC_PREFIX}
-                 NO_DEFAULT_PATH
-                 PATH_SUFFIXES "bin")
-    set(Thrift_VERSION ${THRIFT_PC_VERSION})
-  else()
-    find_library(THRIFT_LIB
-                 NAMES ${THRIFT_LIB_NAMES}
-                 PATH_SUFFIXES "lib/${CMAKE_LIBRARY_ARCHITECTURE}" "lib")
-    find_path(THRIFT_INCLUDE_DIR thrift/Thrift.h PATH_SUFFIXES "include")
-    find_program(THRIFT_COMPILER thrift PATH_SUFFIXES "bin")
-    extract_thrift_version()
-  endif()
-endif()
-
-if(THRIFT_COMPILER)
-  set(Thrift_COMPILER_FOUND TRUE)
-else()
-  set(Thrift_COMPILER_FOUND FALSE)
-endif()
-
-find_package_handle_standard_args(
-  Thrift
-  REQUIRED_VARS THRIFT_LIB THRIFT_INCLUDE_DIR
-  VERSION_VAR Thrift_VERSION
-  HANDLE_COMPONENTS)
-
-if(Thrift_FOUND)
-  if(ARROW_THRIFT_USE_SHARED)
-    add_library(thrift::thrift SHARED IMPORTED)
-  else()
-    add_library(thrift::thrift STATIC IMPORTED)
-  endif()
-  set_target_properties(thrift::thrift
-                        PROPERTIES IMPORTED_LOCATION "${THRIFT_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${THRIFT_INCLUDE_DIR}")
-  if(WIN32 AND NOT MSVC_TOOLCHAIN)
-    # We don't need this for Visual C++ because Thrift uses
-    # "#pragma comment(lib, "Ws2_32.lib")" in
-    # thrift/windows/config.h for Visual C++.
-    set_target_properties(thrift::thrift PROPERTIES INTERFACE_LINK_LIBRARIES "ws2_32")
-  endif()
-
-  if(Thrift_COMPILER_FOUND)
-    add_executable(thrift::compiler IMPORTED)
-    set_target_properties(thrift::compiler PROPERTIES IMPORTED_LOCATION
-                                                      "${THRIFT_COMPILER}")
-  endif()
-endif()
diff --git a/velox/CMakeLists.txt b/velox/CMakeLists.txt
index ea35aa1ea59ca..064917ef60ed4 100644
--- a/velox/CMakeLists.txt
+++ b/velox/CMakeLists.txt
@@ -44,7 +44,7 @@ if(${VELOX_ENABLE_PARSE})
 endif()
 
 # hive connector depends on dwio
-if(${VELOX_ENABLE_HIVE_CONNECTOR})
+if(${VELOX_BUILD_MINIMAL_WITH_DWIO} OR ${VELOX_ENABLE_HIVE_CONNECTOR})
   add_subdirectory(dwio)
 endif()
 
@@ -55,19 +55,12 @@ endif()
 add_subdirectory(functions) # depends on md5 (postgresql)
 add_subdirectory(connectors)
 
-# exec depends on codegen
 if(${VELOX_ENABLE_EXEC})
   add_subdirectory(exec)
-  add_subdirectory(codegen)
 endif()
 
 if(${VELOX_ENABLE_DUCKDB})
   add_subdirectory(duckdb)
-  add_subdirectory(external/duckdb)
-endif()
-
-if(${VELOX_CODEGEN_SUPPORT})
-  add_subdirectory(experimental/codegen)
 endif()
 
 if(${VELOX_ENABLE_GPU})
diff --git a/velox/benchmarks/CMakeLists.txt b/velox/benchmarks/CMakeLists.txt
index 263920704d544..dda7226d67150 100644
--- a/velox/benchmarks/CMakeLists.txt
+++ b/velox/benchmarks/CMakeLists.txt
@@ -29,10 +29,37 @@ set(velox_benchmark_deps
     glog::glog)
 
 add_library(velox_benchmark_builder ExpressionBenchmarkBuilder.cpp)
-target_link_libraries(velox_benchmark_builder ${velox_benchmark_deps})
+target_link_libraries(
+  velox_benchmark_builder ${velox_benchmark_deps})
 # This is a workaround for the use of VectorTestBase.h which includes gtest.h
-target_link_libraries(velox_benchmark_builder gtest)
+target_link_libraries(
+  velox_benchmark_builder GTest::gtest)
 
 if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(tpch)
+  add_subdirectory(filesystem)
 endif()
+
+add_library(velox_query_benchmark QueryBenchmarkBase.cpp)
+target_link_libraries(
+  velox_query_benchmark
+  velox_aggregates
+  velox_exec
+  velox_exec_test_lib
+  velox_dwio_common
+  velox_dwio_common_exception
+  velox_dwio_parquet_reader
+  velox_dwio_common_test_utils
+  velox_hive_connector
+  velox_exception
+  velox_memory
+  velox_process
+  velox_serialization
+  velox_encode
+  velox_type
+  velox_type_fbhive
+  velox_caching
+  velox_vector_test_lib
+  ${FOLLY_BENCHMARK}
+  Folly::folly
+  fmt::fmt)
diff --git a/velox/benchmarks/ExpressionBenchmarkBuilder.cpp b/velox/benchmarks/ExpressionBenchmarkBuilder.cpp
index fcb0621272666..bfed3aa229846 100644
--- a/velox/benchmarks/ExpressionBenchmarkBuilder.cpp
+++ b/velox/benchmarks/ExpressionBenchmarkBuilder.cpp
@@ -39,9 +39,9 @@ ExpressionBenchmarkSet& ExpressionBenchmarkSet::addExpressions(
 // Make sure all input vectors are generated.
 void ExpressionBenchmarkBuilder::ensureInputVectors() {
   for (auto& [_, benchmarkSet] : benchmarkSets_) {
-    if (!benchmarkSet.inputRowVetor_) {
+    if (!benchmarkSet.inputRowVector_) {
       VectorFuzzer fuzzer(benchmarkSet.fuzzerOptions_, pool());
-      benchmarkSet.inputRowVetor_ = std::dynamic_pointer_cast<RowVector>(
+      benchmarkSet.inputRowVector_ = std::dynamic_pointer_cast<RowVector>(
           fuzzer.fuzzFlat(benchmarkSet.inputType_));
     }
   }
@@ -64,10 +64,10 @@ void ExpressionBenchmarkBuilder::testBenchmarks() {
     }
     // Evaluate the first expression.
     auto it = benchmarkSet.expressions_.begin();
-    auto refResult = evalExpression(it->second, benchmarkSet.inputRowVetor_);
+    auto refResult = evalExpression(it->second, benchmarkSet.inputRowVector_);
     it++;
     while (it != benchmarkSet.expressions_.end()) {
-      auto result = evalExpression(it->second, benchmarkSet.inputRowVetor_);
+      auto result = evalExpression(it->second, benchmarkSet.inputRowVector_);
       test::assertEqualVectors(refResult, result);
       it++;
     }
@@ -86,9 +86,9 @@ void ExpressionBenchmarkBuilder::registerBenchmarks() {
   for (auto& [setName, benchmarkSet] : benchmarkSets_) {
     for (auto& [exprName, exprSet] : benchmarkSet.expressions_) {
       auto name = fmt::format("{}##{}", setName, exprName);
-      auto& inputVector = benchmarkSet.inputRowVetor_;
-      auto times = benchmarkSet.itterations_;
-      // The compiler does not allow capturing exprSet int the lambda
+      auto& inputVector = benchmarkSet.inputRowVector_;
+      auto times = benchmarkSet.iterations_;
+      // The compiler does not allow capturing exprSet int the lambda.
       auto& exprSetLocal = exprSet;
       folly::addBenchmark(
           __FILE__, name, [this, &inputVector, &exprSetLocal, times]() {
@@ -104,7 +104,7 @@ void ExpressionBenchmarkBuilder::registerBenchmarks() {
             for (auto i = 0; i < times; i++) {
               exprSetLocal.eval(rows, evalCtx, results);
 
-              // TODO: add flag to enable/disable flatenning.
+              // TODO: add flag to enable/disable flattening.
               BaseVector::flattenVector(results[0]);
 
               // TODO: add flag to enable/disable reuse.
@@ -116,8 +116,8 @@ void ExpressionBenchmarkBuilder::registerBenchmarks() {
             return 1;
           });
     }
-    BENCHMARK_DRAW_LINE();
-    BENCHMARK_DRAW_LINE();
+
+    folly::addBenchmark(__FILE__, "-", []() -> unsigned { return 0; });
   }
 }
 } // namespace facebook::velox
diff --git a/velox/benchmarks/ExpressionBenchmarkBuilder.h b/velox/benchmarks/ExpressionBenchmarkBuilder.h
index ac29707e99eec..8034397f77cfb 100644
--- a/velox/benchmarks/ExpressionBenchmarkBuilder.h
+++ b/velox/benchmarks/ExpressionBenchmarkBuilder.h
@@ -47,23 +47,23 @@ class ExpressionBenchmarkSet {
   ExpressionBenchmarkSet& withFuzzerOptions(
       const VectorFuzzer::Options& options) {
     VELOX_CHECK(
-        !inputRowVetor_,
+        !inputRowVector_,
         "input row vector is already passed, fuzzer wont be used");
     fuzzerOptions_ = options;
     return *this;
   }
 
-  ExpressionBenchmarkSet& withIterations(int itterations) {
-    itterations_ = itterations;
+  ExpressionBenchmarkSet& withIterations(int iterations) {
+    iterations_ = iterations;
     return *this;
   }
 
  private:
   ExpressionBenchmarkSet(
       ExpressionBenchmarkBuilder& builder,
-      const RowVectorPtr& inputRowVetor)
-      : inputRowVetor_(inputRowVetor),
-        inputType_(inputRowVetor_->type()),
+      const RowVectorPtr& inputRowVector)
+      : inputRowVector_(inputRowVector),
+        inputType_(inputRowVector_->type()),
         builder_(builder) {}
 
   ExpressionBenchmarkSet(
@@ -74,9 +74,9 @@ class ExpressionBenchmarkSet {
   // All the expressions that belongs to this set.
   std::vector<std::pair<std::string, exec::ExprSet>> expressions_;
 
-  // The input that will be used for for benchmarking expressions. If not set,
+  // The input that will be used for benchmarking expressions. If not set,
   // a flat input vector is fuzzed using fuzzerOptions_.
-  RowVectorPtr inputRowVetor_;
+  RowVectorPtr inputRowVector_;
 
   // The type of the input that will be used for all the expressions
   // benchmarked.
@@ -84,11 +84,11 @@ class ExpressionBenchmarkSet {
 
   // User can provide fuzzer options for the input row vector used for this
   // benchmark. Note that the fuzzer will be used to generate a flat input row
-  // vector if inputRowVetor_ is nullptr.
+  // vector if inputRowVector_ is nullptr.
   VectorFuzzer::Options fuzzerOptions_{.vectorSize = 10000, .nullRatio = 0};
 
   // Number of times to run each benchmark.
-  int itterations_ = 1000;
+  int iterations_ = 1000;
 
   bool disableTesting_ = false;
 
@@ -108,7 +108,7 @@ class ExpressionBenchmarkBuilder
   void registerBenchmarks();
 
   // All benchmarks within one group set are expected to have the same results.
-  // If disbleTesting=true for a group set, testing is skipped.
+  // If disableTesting=true for a group set, testing is skipped.
   void testBenchmarks();
 
   test::VectorMaker& vectorMaker() {
@@ -117,9 +117,9 @@ class ExpressionBenchmarkBuilder
 
   ExpressionBenchmarkSet& addBenchmarkSet(
       const std::string& name,
-      const RowVectorPtr& inputRowVetor) {
+      const RowVectorPtr& inputRowVector) {
     VELOX_CHECK(!benchmarkSets_.count(name));
-    benchmarkSets_.emplace(name, ExpressionBenchmarkSet(*this, inputRowVetor));
+    benchmarkSets_.emplace(name, ExpressionBenchmarkSet(*this, inputRowVector));
     return benchmarkSets_.at(name);
   }
 
diff --git a/velox/benchmarks/QueryBenchmarkBase.cpp b/velox/benchmarks/QueryBenchmarkBase.cpp
new file mode 100644
index 0000000000000..f51acd5544ad7
--- /dev/null
+++ b/velox/benchmarks/QueryBenchmarkBase.cpp
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/benchmarks/QueryBenchmarkBase.h"
+
+DEFINE_string(data_format, "parquet", "Data format");
+
+DEFINE_validator(
+    data_format,
+    &facebook::velox::QueryBenchmarkBase::validateDataFormat);
+
+DEFINE_bool(
+    include_custom_stats,
+    false,
+    "Include custom statistics along with execution statistics");
+DEFINE_bool(include_results, false, "Include results in the output");
+DEFINE_int32(num_drivers, 4, "Number of drivers");
+
+DEFINE_int32(num_splits_per_file, 10, "Number of splits per file");
+DEFINE_int32(
+    cache_gb,
+    0,
+    "GB of process memory for cache and query.. if "
+    "non-0, uses mmap to allocator and in-process data cache.");
+DEFINE_int32(num_repeats, 1, "Number of times to run each query");
+DEFINE_int32(num_io_threads, 8, "Threads for speculative IO");
+DEFINE_string(
+    test_flags_file,
+    "",
+    "Path to a file containing gflafs and "
+    "values to try. Produces results for each flag combination "
+    "sorted on performance");
+DEFINE_bool(
+    full_sorted_stats,
+    true,
+    "Add full stats to the report on  --test_flags_file");
+
+DEFINE_string(ssd_path, "", "Directory for local SSD cache");
+DEFINE_int32(ssd_cache_gb, 0, "Size of local SSD cache in GB");
+DEFINE_int32(
+    ssd_checkpoint_interval_gb,
+    8,
+    "Checkpoint every n "
+    "GB new data in cache");
+DEFINE_bool(
+    clear_ram_cache,
+    false,
+    "Clear RAM cache before each query."
+    "Flushes in process and OS file system cache (if root on Linux)");
+DEFINE_bool(
+    clear_ssd_cache,
+    false,
+    "Clears SSD cache before "
+    "each query");
+
+DEFINE_bool(
+    warmup_after_clear,
+    false,
+    "Runs one warmup of the query before "
+    "measured run. Use to run warm after clearing caches.");
+
+DEFINE_int64(
+    max_coalesced_bytes,
+    128 << 20,
+    "Maximum size of single coalesced IO");
+
+DEFINE_int32(
+    max_coalesced_distance_bytes,
+    512 << 10,
+    "Maximum distance in bytes in which coalesce will combine requests");
+
+DEFINE_int32(
+    parquet_prefetch_rowgroups,
+    1,
+    "Number of next row groups to "
+    "prefetch. 1 means prefetch the next row group before decoding "
+    "the current one");
+
+DEFINE_int32(split_preload_per_driver, 2, "Prefetch split metadata");
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::dwio::common;
+
+namespace facebook::velox {
+
+//  static
+bool QueryBenchmarkBase::validateDataFormat(
+    const char* flagname,
+    const std::string& value) {
+  if ((value.compare("parquet") == 0) || (value.compare("dwrf") == 0)) {
+    return true;
+  }
+  std::cout
+      << fmt::format(
+             "Invalid value for --{}: {}. Allowed values are [\"parquet\", \"dwrf\"]",
+             flagname,
+             value)
+      << std::endl;
+  return false;
+}
+
+// static
+void QueryBenchmarkBase::ensureTaskCompletion(exec::Task* task) {
+  // ASSERT_TRUE requires a function with return type void.
+  ASSERT_TRUE(exec::test::waitForTaskCompletion(task));
+}
+
+// static
+void QueryBenchmarkBase::printResults(
+    const std::vector<RowVectorPtr>& results,
+    std::ostream& out) {
+  out << "Results:" << std::endl;
+  bool printType = true;
+  for (const auto& vector : results) {
+    // Print RowType only once.
+    if (printType) {
+      out << vector->type()->asRow().toString() << std::endl;
+      printType = false;
+    }
+    for (vector_size_t i = 0; i < vector->size(); ++i) {
+      out << vector->toString(i) << std::endl;
+    }
+  }
+}
+
+void QueryBenchmarkBase::initialize() {
+  if (FLAGS_cache_gb) {
+    memory::MemoryManagerOptions options;
+    int64_t memoryBytes = FLAGS_cache_gb * (1LL << 30);
+    options.useMmapAllocator = true;
+    options.allocatorCapacity = memoryBytes;
+    options.useMmapArena = true;
+    options.mmapArenaCapacityRatio = 1;
+    memory::MemoryManager::testingSetInstance(options);
+    std::unique_ptr<cache::SsdCache> ssdCache;
+    if (FLAGS_ssd_cache_gb) {
+      constexpr int32_t kNumSsdShards = 16;
+      cacheExecutor_ =
+          std::make_unique<folly::IOThreadPoolExecutor>(kNumSsdShards);
+      const cache::SsdCache::Config config(
+          FLAGS_ssd_path,
+          static_cast<uint64_t>(FLAGS_ssd_cache_gb) << 30,
+          kNumSsdShards,
+          cacheExecutor_.get(),
+          static_cast<uint64_t>(FLAGS_ssd_checkpoint_interval_gb) << 30);
+      ssdCache = std::make_unique<cache::SsdCache>(config);
+    }
+
+    cache_ = cache::AsyncDataCache::create(
+        memory::memoryManager()->allocator(), std::move(ssdCache));
+    cache::AsyncDataCache::setInstance(cache_.get());
+  } else {
+    memory::MemoryManager::testingSetInstance({});
+  }
+  functions::prestosql::registerAllScalarFunctions();
+  aggregate::prestosql::registerAllAggregateFunctions();
+  parse::registerTypeResolver();
+  filesystems::registerLocalFileSystem();
+
+  ioExecutor_ =
+      std::make_unique<folly::IOThreadPoolExecutor>(FLAGS_num_io_threads);
+
+  // Add new values into the hive configuration...
+  auto configurationValues = std::unordered_map<std::string, std::string>();
+  configurationValues[connector::hive::HiveConfig::kMaxCoalescedBytes] =
+      std::to_string(FLAGS_max_coalesced_bytes);
+  configurationValues[connector::hive::HiveConfig::kMaxCoalescedDistanceBytes] =
+      std::to_string(FLAGS_max_coalesced_distance_bytes);
+  configurationValues[connector::hive::HiveConfig::kPrefetchRowGroups] =
+      std::to_string(FLAGS_parquet_prefetch_rowgroups);
+  auto properties = std::make_shared<const config::ConfigBase>(
+      std::move(configurationValues));
+
+  // Create hive connector with config...
+  auto hiveConnector =
+      connector::getConnectorFactory(
+          connector::hive::HiveConnectorFactory::kHiveConnectorName)
+          ->newConnector(kHiveConnectorId, properties, ioExecutor_.get());
+  connector::registerConnector(hiveConnector);
+}
+
+std::vector<std::shared_ptr<connector::ConnectorSplit>>
+QueryBenchmarkBase::listSplits(
+    const std::string& path,
+    int32_t numSplitsPerFile,
+    const exec::test::TpchPlan& plan) {
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> result;
+  auto temp = HiveConnectorTestBase::makeHiveConnectorSplits(
+      path, numSplitsPerFile, plan.dataFileFormat);
+  for (auto& i : temp) {
+    result.push_back(i);
+  }
+  return result;
+}
+
+void QueryBenchmarkBase::shutdown() {
+  if (cache_) {
+    cache_->shutdown();
+  }
+}
+
+std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
+QueryBenchmarkBase::run(const TpchPlan& tpchPlan) {
+  int32_t repeat = 0;
+  try {
+    for (;;) {
+      CursorParameters params;
+      params.maxDrivers = FLAGS_num_drivers;
+      params.planNode = tpchPlan.plan;
+      params.queryConfigs[core::QueryConfig::kMaxSplitPreloadPerDriver] =
+          std::to_string(FLAGS_split_preload_per_driver);
+      const int numSplitsPerFile = FLAGS_num_splits_per_file;
+
+      bool noMoreSplits = false;
+      auto addSplits = [&](exec::Task* task) {
+        if (!noMoreSplits) {
+          for (const auto& entry : tpchPlan.dataFiles) {
+            for (const auto& path : entry.second) {
+              auto splits = listSplits(path, numSplitsPerFile, tpchPlan);
+              for (auto split : splits) {
+                task->addSplit(entry.first, exec::Split(std::move(split)));
+              }
+            }
+            task->noMoreSplits(entry.first);
+          }
+        }
+        noMoreSplits = true;
+      };
+      auto result = readCursor(params, addSplits);
+      ensureTaskCompletion(result.first->task().get());
+      if (++repeat >= FLAGS_num_repeats) {
+        return result;
+      }
+    }
+  } catch (const std::exception& e) {
+    LOG(ERROR) << "Query terminated with: " << e.what();
+    return {nullptr, std::vector<RowVectorPtr>()};
+  }
+}
+
+void QueryBenchmarkBase::readCombinations() {
+  std::ifstream file(FLAGS_test_flags_file);
+  std::string line;
+  while (std::getline(file, line)) {
+    ParameterDim dim;
+    int32_t previous = 0;
+    for (auto i = 0; i < line.size(); ++i) {
+      if (line[i] == ':') {
+        dim.flag = line.substr(0, i);
+        previous = i + 1;
+      } else if (line[i] == ',') {
+        dim.values.push_back(line.substr(previous, i - previous));
+        previous = i + 1;
+      }
+    }
+    if (previous < line.size()) {
+      dim.values.push_back(line.substr(previous, line.size() - previous));
+    }
+    if (!dim.flag.empty() && !dim.values.empty()) {
+      parameters_.push_back(dim);
+    }
+  }
+}
+
+void QueryBenchmarkBase::runCombinations(int32_t level) {
+  if (level == parameters_.size()) {
+    if (FLAGS_clear_ram_cache) {
+#ifdef linux
+      // system("echo 3 >/proc/sys/vm/drop_caches");
+      bool success = false;
+      auto fd = open("/proc//sys/vm/drop_caches", O_WRONLY);
+      if (fd > 0) {
+        success = write(fd, "3", 1) == 1;
+        close(fd);
+      }
+      if (!success) {
+        LOG(ERROR) << "Failed to clear OS disk cache: errno=" << errno;
+      }
+#endif
+
+      if (cache_) {
+        cache_->clear();
+      }
+    }
+    if (FLAGS_clear_ssd_cache) {
+      if (cache_) {
+        auto ssdCache = cache_->ssdCache();
+        if (ssdCache) {
+          ssdCache->clear();
+        }
+      }
+    }
+    if (FLAGS_warmup_after_clear) {
+      std::stringstream result;
+      RunStats ignore;
+      runMain(result, ignore);
+    }
+    RunStats stats;
+    std::stringstream result;
+    uint64_t micros = 0;
+    {
+      struct rusage start;
+      getrusage(RUSAGE_SELF, &start);
+      MicrosecondTimer timer(&micros);
+      runMain(result, stats);
+      struct rusage final;
+      getrusage(RUSAGE_SELF, &final);
+      auto tvNanos = [](struct timeval tv) {
+        return tv.tv_sec * 1000000000 + tv.tv_usec * 1000;
+      };
+      stats.userNanos = tvNanos(final.ru_utime) - tvNanos(start.ru_utime);
+      stats.systemNanos = tvNanos(final.ru_stime) - tvNanos(start.ru_stime);
+    }
+    stats.micros = micros;
+    stats.output = result.str();
+    for (auto i = 0; i < parameters_.size(); ++i) {
+      std::string name;
+      gflags::GetCommandLineOption(parameters_[i].flag.c_str(), &name);
+      stats.flags[parameters_[i].flag] = name;
+    }
+    runStats_.push_back(std::move(stats));
+  } else {
+    auto& flag = parameters_[level].flag;
+    for (auto& value : parameters_[level].values) {
+      std::string result =
+          gflags::SetCommandLineOption(flag.c_str(), value.c_str());
+      if (result.empty()) {
+        LOG(ERROR) << "Failed to set " << flag << "=" << value;
+      }
+      std::cout << result << std::endl;
+      runCombinations(level + 1);
+    }
+  }
+}
+
+void QueryBenchmarkBase::runOne(std::ostream& out, RunStats& stats) {
+  std::stringstream result;
+  uint64_t micros = 0;
+  {
+    struct rusage start;
+    getrusage(RUSAGE_SELF, &start);
+    MicrosecondTimer timer(&micros);
+    runMain(out, stats);
+    struct rusage final;
+    getrusage(RUSAGE_SELF, &final);
+    auto tvNanos = [](struct timeval tv) {
+      return tv.tv_sec * 1000000000 + tv.tv_usec * 1000;
+    };
+    stats.userNanos = tvNanos(final.ru_utime) - tvNanos(start.ru_utime);
+    stats.systemNanos = tvNanos(final.ru_stime) - tvNanos(start.ru_stime);
+  }
+  stats.micros = micros;
+  stats.output = result.str();
+  out << result.str();
+}
+
+void QueryBenchmarkBase::runAllCombinations() {
+  readCombinations();
+  runCombinations(0);
+  std::sort(
+      runStats_.begin(),
+      runStats_.end(),
+      [](const RunStats& left, const RunStats& right) {
+        return left.micros < right.micros;
+      });
+  for (auto& stats : runStats_) {
+    std::cout << stats.toString(false);
+  }
+  if (FLAGS_full_sorted_stats) {
+    std::cout << "Detail for stats:" << std::endl;
+    for (auto& stats : runStats_) {
+      std::cout << stats.toString(true);
+    }
+  }
+}
+
+} // namespace facebook::velox
diff --git a/velox/benchmarks/QueryBenchmarkBase.h b/velox/benchmarks/QueryBenchmarkBase.h
new file mode 100644
index 0000000000000..d3577fe53cf25
--- /dev/null
+++ b/velox/benchmarks/QueryBenchmarkBase.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <fcntl.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fstream>
+
+#include "velox/common/base/SuccinctPrinter.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/MmapAllocator.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/Split.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/TpchQueryBuilder.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+
+DECLARE_string(test_flags_file);
+DECLARE_bool(include_results);
+DECLARE_bool(include_custom_stats);
+DECLARE_string(data_format);
+
+namespace facebook::velox {
+
+struct RunStats {
+  std::map<std::string, std::string> flags;
+  int64_t micros{0};
+  int64_t rawInputBytes{0};
+  int64_t userNanos{0};
+  int64_t systemNanos{0};
+  std::string output;
+
+  std::string toString(bool detail) {
+    std::stringstream out;
+    out << succinctNanos(micros * 1000) << " "
+        << succinctBytes(rawInputBytes / (micros / 1000000.0)) << "/s raw, "
+        << succinctNanos(userNanos) << " user " << succinctNanos(systemNanos)
+        << " system (" << (100 * (userNanos + systemNanos) / (micros * 1000))
+        << "%), flags: ";
+    for (auto& pair : flags) {
+      out << pair.first << "=" << pair.second << " ";
+    }
+    out << std::endl << "======" << std::endl;
+    if (detail) {
+      out << std::endl << output << std::endl;
+    }
+    return out.str();
+  }
+};
+
+struct ParameterDim {
+  std::string flag;
+  std::vector<std::string> values;
+};
+
+class QueryBenchmarkBase {
+ public:
+  virtual ~QueryBenchmarkBase() = default;
+  virtual void initialize();
+  void shutdown();
+  std::pair<std::unique_ptr<exec::test::TaskCursor>, std::vector<RowVectorPtr>>
+  run(const exec::test::TpchPlan& tpchPlan);
+
+  virtual std::vector<std::shared_ptr<connector::ConnectorSplit>> listSplits(
+      const std::string& path,
+      int32_t numSplitsPerFile,
+      const exec::test::TpchPlan& plan);
+
+  static void ensureTaskCompletion(exec::Task* task);
+
+  static bool validateDataFormat(
+      const char* flagname,
+      const std::string& value);
+
+  static void printResults(
+      const std::vector<RowVectorPtr>& results,
+      std::ostream& out);
+
+  void readCombinations();
+
+  /// Entry point invoked with different settings to run the benchmark.
+  virtual void runMain(std::ostream& out, RunStats& runStats) = 0;
+
+  void runOne(std::ostream& outtt, RunStats& stats);
+
+  void runCombinations(int32_t level);
+
+  void runAllCombinations();
+
+ protected:
+  std::unique_ptr<folly::IOThreadPoolExecutor> ioExecutor_;
+  std::unique_ptr<folly::IOThreadPoolExecutor> cacheExecutor_;
+  std::shared_ptr<memory::MemoryAllocator> allocator_;
+  std::shared_ptr<cache::AsyncDataCache> cache_;
+  // Parameter combinations to try. Each element specifies a flag and possible
+  // values. All permutations are tried.
+  std::vector<ParameterDim> parameters_;
+
+  std::vector<RunStats> runStats_;
+};
+} // namespace facebook::velox
diff --git a/velox/benchmarks/basic/CMakeLists.txt b/velox/benchmarks/basic/CMakeLists.txt
index 8b14e6c8245ef..45a57b0944fe2 100644
--- a/velox/benchmarks/basic/CMakeLists.txt
+++ b/velox/benchmarks/basic/CMakeLists.txt
@@ -21,6 +21,7 @@ set(velox_benchmark_deps
     velox_parse_expression
     velox_serialization
     velox_benchmark_builder
+    velox_vector_test_lib
     Folly::folly
     ${FOLLY_BENCHMARK}
     ${DOUBLE_CONVERSION}
@@ -28,48 +29,74 @@ set(velox_benchmark_deps
     glog::glog)
 
 add_executable(velox_benchmark_basic_simple_arithmetic SimpleArithmetic.cpp)
-target_link_libraries(velox_benchmark_basic_simple_arithmetic
-                      ${velox_benchmark_deps})
+target_link_libraries(
+  velox_benchmark_basic_simple_arithmetic ${velox_benchmark_deps})
 
 add_executable(velox_benchmark_basic_comparison_conjunct ComparisonConjunct.cpp)
-target_link_libraries(velox_benchmark_basic_comparison_conjunct
-                      ${velox_benchmark_deps})
+target_link_libraries(
+  velox_benchmark_basic_comparison_conjunct ${velox_benchmark_deps})
 
 add_executable(velox_benchmark_basic_simple_cast SimpleCastExpr.cpp)
-target_link_libraries(velox_benchmark_basic_simple_cast ${velox_benchmark_deps})
+target_link_libraries(
+  velox_benchmark_basic_simple_cast ${velox_benchmark_deps})
 
 add_executable(velox_benchmark_basic_decoded_vector DecodedVector.cpp)
-target_link_libraries(velox_benchmark_basic_decoded_vector
-                      ${velox_benchmark_deps})
+target_link_libraries(
+  velox_benchmark_basic_decoded_vector ${velox_benchmark_deps})
 
 add_executable(velox_benchmark_basic_selectivity_vector SelectivityVector.cpp)
-target_link_libraries(velox_benchmark_basic_selectivity_vector
-                      ${velox_benchmark_deps})
+target_link_libraries(
+  velox_benchmark_basic_selectivity_vector ${velox_benchmark_deps})
 
 add_executable(velox_benchmark_basic_vector_compare VectorCompare.cpp)
-target_link_libraries(velox_benchmark_basic_vector_compare
-                      ${velox_benchmark_deps} velox_vector_test_lib)
+target_link_libraries(
+  velox_benchmark_basic_vector_compare ${velox_benchmark_deps}
+  velox_vector_test_lib)
 
 add_executable(velox_benchmark_basic_vector_slice VectorSlice.cpp)
-target_link_libraries(velox_benchmark_basic_vector_slice
-                      ${velox_benchmark_deps} velox_vector_test_lib)
+target_link_libraries(
+  velox_benchmark_basic_vector_slice ${velox_benchmark_deps}
+  velox_vector_test_lib)
 
 add_executable(velox_benchmark_feature_normalization FeatureNormalization.cpp)
-target_link_libraries(velox_benchmark_feature_normalization
-                      ${velox_benchmark_deps} velox_functions_prestosql)
+target_link_libraries(
+  velox_benchmark_feature_normalization ${velox_benchmark_deps}
+  velox_functions_prestosql)
 
 add_executable(velox_benchmark_basic_preproc Preproc.cpp)
-target_link_libraries(velox_benchmark_basic_preproc ${velox_benchmark_deps}
-                      velox_functions_prestosql velox_vector_test_lib)
+target_link_libraries(
+  velox_benchmark_basic_preproc ${velox_benchmark_deps}
+  velox_functions_prestosql velox_vector_test_lib)
 
-add_executable(velox_like_functions_benchmark LikeFunctionsBenchmark.cpp)
-target_link_libraries(velox_like_functions_benchmark ${velox_benchmark_deps}
-                      velox_functions_lib velox_tpch_gen velox_vector_test_lib)
+add_executable(velox_like_tpch_benchmark LikeTpchBenchmark.cpp)
+target_link_libraries(
+  velox_like_tpch_benchmark
+  ${velox_benchmark_deps}
+  velox_functions_lib
+  velox_tpch_gen
+  velox_vector_test_lib)
+
+add_executable(velox_like_benchmark LikeBenchmark.cpp)
+target_link_libraries(
+  velox_like_benchmark
+  ${velox_benchmark_deps}
+  velox_functions_lib
+  velox_functions_prestosql
+  velox_vector_test_lib)
 
 add_executable(velox_benchmark_basic_vector_fuzzer VectorFuzzer.cpp)
-target_link_libraries(velox_benchmark_basic_vector_fuzzer
-                      ${velox_benchmark_deps} velox_vector_test_lib)
+target_link_libraries(
+  velox_benchmark_basic_vector_fuzzer ${velox_benchmark_deps}
+  velox_vector_test_lib)
 
 add_executable(velox_cast_benchmark CastBenchmark.cpp)
-target_link_libraries(velox_cast_benchmark ${velox_benchmark_deps}
-                      velox_vector_test_lib)
+target_link_libraries(
+  velox_cast_benchmark ${velox_benchmark_deps} velox_vector_test_lib)
+
+add_executable(velox_format_datetime_benchmark FormatDateTimeBenchmark.cpp)
+target_link_libraries(
+  velox_format_datetime_benchmark
+  ${velox_benchmark_deps}
+  velox_vector_test_lib
+  velox_functions_spark
+  velox_functions_prestosql)
diff --git a/velox/benchmarks/basic/CastBenchmark.cpp b/velox/benchmarks/basic/CastBenchmark.cpp
index 192997e01570f..f937f354f8935 100644
--- a/velox/benchmarks/basic/CastBenchmark.cpp
+++ b/velox/benchmarks/basic/CastBenchmark.cpp
@@ -25,13 +25,37 @@ using namespace facebook::velox;
 
 int main(int argc, char** argv) {
   folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
 
   ExpressionBenchmarkBuilder benchmarkBuilder;
   const vector_size_t vectorSize = 1000;
   auto vectorMaker = benchmarkBuilder.vectorMaker();
-  auto invalidInput = vectorMaker.flatVector<facebook::velox::StringView>({""});
-  auto validInput = vectorMaker.flatVector<facebook::velox::StringView>({""});
-  auto nanInput = vectorMaker.flatVector<facebook::velox::StringView>({""});
+  auto emptyInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto /*row*/) { return ""; });
+  auto validInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto row) { return std::to_string(row); });
+  auto invalidInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto /*row*/) { return "$"; });
+  auto validDoubleStringInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto row) { return fmt::format("{}.12345678910", row); });
+  auto validNaNInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto /*row*/) { return "NaN"; });
+  auto validInfinityInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto /*row*/) { return "Infinity"; });
+  auto invalidNaNInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto /*row*/) { return "nan"; });
+  auto invalidInfinityInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto /*row*/) { return "infinity"; });
+  auto spaceInput = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto /*row*/) { return "   "; });
+  auto integerInput = vectorMaker.flatVector<int32_t>(
+      vectorSize, [&](auto j) { return 12345 * j; }, nullptr);
+  auto bigintInput = vectorMaker.flatVector<int64_t>(
+      vectorSize,
+      [&](auto j) {
+        return facebook::velox::HugeInt::build(12345 * j, 56789 * j + 12345);
+      },
+      nullptr);
   auto decimalInput = vectorMaker.flatVector<int64_t>(
       vectorSize, [&](auto j) { return 12345 * j; }, nullptr, DECIMAL(9, 2));
   auto shortDecimalInput = vectorMaker.flatVector<int64_t>(
@@ -46,20 +70,84 @@ int main(int argc, char** argv) {
       },
       nullptr,
       DECIMAL(38, 16));
+  auto largeRealInput = vectorMaker.flatVector<float>(
+      vectorSize, [&](auto j) { return 12345678.0 * j; });
+  auto smallRealInput = vectorMaker.flatVector<float>(
+      vectorSize, [&](auto j) { return 1.2345678 * j; });
+  auto smallDoubleInput = vectorMaker.flatVector<double>(
+      vectorSize, [&](auto j) { return -0.00012345678 / j; });
+  auto largeDoubleInput = vectorMaker.flatVector<double>(
+      vectorSize, [&](auto j) { return -123456.7 / j; });
   auto timestampInput =
       vectorMaker.flatVector<Timestamp>(vectorSize, [&](auto j) {
         return Timestamp(1695859694 + j / 1000, j % 1000 * 1'000'000);
       });
+  auto validDateStrings = vectorMaker.flatVector<std::string>(
+      vectorSize,
+      [](auto row) { return fmt::format("2024-05-{:02d}", 1 + row % 30); });
+  auto invalidDateStrings = vectorMaker.flatVector<std::string>(
+      vectorSize, [](auto row) { return fmt::format("2024-05...{}", row); });
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "cast_varhar_as_date",
+          vectorMaker.rowVector(
+              {"empty", "invalid_date", "valid_date"},
+              {emptyInput, invalidDateStrings, validDateStrings}))
+      .addExpression("try_cast_invalid_empty_input", "try_cast(empty as date) ")
+      .addExpression(
+          "tryexpr_cast_invalid_empty_input", "try(cast (empty as date))")
+      .addExpression(
+          "try_cast_invalid_input", "try_cast(invalid_date as date) ")
+      .addExpression(
+          "tryexpr_cast_invalid_input", "try(cast (invalid_date as date))")
+      .addExpression("cast_valid", "cast(valid_date as date)");
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "cast_varhar_as_timestamp",
+          vectorMaker.rowVector(
+              {"empty", "invalid_date", "valid_date"},
+              {emptyInput, invalidDateStrings, validDateStrings}))
+      .addExpression(
+          "try_cast_invalid_empty_input", "try_cast(empty as timestamp) ")
+      .addExpression(
+          "tryexpr_cast_invalid_empty_input", "try(cast (empty as timestamp))")
+      .addExpression(
+          "try_cast_invalid_input", "try_cast(invalid_date as timestamp) ")
+      .addExpression(
+          "tryexpr_cast_invalid_input", "try(cast (invalid_date as timestamp))")
+      .addExpression("cast_valid", "cast(valid_date as timestamp)");
 
-  invalidInput->resize(vectorSize);
-  validInput->resize(vectorSize);
-  nanInput->resize(vectorSize);
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "cast_timestamp_as_varchar",
+          vectorMaker.rowVector({"timestamp"}, {timestampInput}))
+      .addExpression("cast", "cast (timestamp as varchar)");
 
-  for (int i = 0; i < vectorSize; i++) {
-    nanInput->set(i, "$"_sv);
-    invalidInput->set(i, StringView::makeInline(std::string("")));
-    validInput->set(i, StringView::makeInline(std::to_string(i)));
-  }
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "cast_varchar_as_double",
+          vectorMaker.rowVector(
+              {"valid",
+               "valid_nan",
+               "valid_infinity",
+               "invalid_nan",
+               "invalid_infinity",
+               "space"},
+              {validDoubleStringInput,
+               validNaNInput,
+               validInfinityInput,
+               invalidNaNInput,
+               invalidInfinityInput,
+               spaceInput}))
+      .addExpression("cast_valid", "cast (valid as double)")
+      .addExpression("cast_valid_nan", "cast (valid_nan as double)")
+      .addExpression("cast_valid_infinity", "cast (valid_infinity as double)")
+      .addExpression("try_cast_invalid_nan", "try_cast (invalid_nan as double)")
+      .addExpression(
+          "try_cast_invalid_infinity", "try_cast (invalid_infinity as double)")
+      .addExpression("try_cast_space", "try_cast (space as double)");
 
   benchmarkBuilder
       .addBenchmarkSet(
@@ -67,23 +155,34 @@ int main(int argc, char** argv) {
           vectorMaker.rowVector(
               {"valid",
                "empty",
-               "nan",
+               "invalid",
+               "integer",
+               "bigint",
                "decimal",
                "short_decimal",
                "long_decimal",
-               "timestamp"},
+               "large_real",
+               "small_real",
+               "small_double",
+               "large_double"},
               {validInput,
+               emptyInput,
                invalidInput,
-               nanInput,
+               integerInput,
+               bigintInput,
                decimalInput,
                shortDecimalInput,
                longDecimalInput,
-               timestampInput}))
+               largeRealInput,
+               smallRealInput,
+               smallDoubleInput,
+               largeDoubleInput}))
       .addExpression("try_cast_invalid_empty_input", "try_cast (empty as int) ")
       .addExpression(
           "tryexpr_cast_invalid_empty_input", "try (cast (empty as int))")
-      .addExpression("try_cast_invalid_nan", "try_cast (nan as int)")
-      .addExpression("tryexpr_cast_invalid_nan", "try (cast (nan as int))")
+      .addExpression("try_cast_invalid_number", "try_cast (invalid as int)")
+      .addExpression(
+          "tryexpr_cast_invalid_number", "try (cast (invalid as int))")
       .addExpression("try_cast_valid", "try_cast (valid as int)")
       .addExpression("tryexpr_cast_valid", "try (cast (valid as int))")
       .addExpression("cast_valid", "cast(valid as int)")
@@ -91,7 +190,27 @@ int main(int argc, char** argv) {
           "cast_decimal_to_inline_string", "cast (decimal as varchar)")
       .addExpression("cast_short_decimal", "cast (short_decimal as varchar)")
       .addExpression("cast_long_decimal", "cast (long_decimal as varchar)")
-      .addExpression("cast_timestamp", "cast (timestamp as varchar)")
+      .addExpression(
+          "cast_large_real_to_scientific_notation",
+          "cast(large_real as varchar)")
+      .addExpression(
+          "cast_small_real_to_standard_notation", "cast(small_real as varchar)")
+      .addExpression(
+          "cast_small_double_to_scientific_notation",
+          "cast(small_double as varchar)")
+      .addExpression(
+          "cast_large_double_to_standard_notation",
+          "cast(large_double as varchar)")
+      .addExpression("cast_real_as_int", "cast (small_real as integer)")
+      .addExpression("cast_decimal_as_bigint", "cast (short_decimal as bigint)")
+      .addExpression(
+          "cast_int_as_short_decimal", "cast (integer as decimal(18,6))")
+      .addExpression(
+          "cast_int_as_long_decimal", "cast (integer as decimal(38,16))")
+      .addExpression(
+          "cast_bigint_as_short_decimal", "cast (bigint as decimal(18,6))")
+      .addExpression(
+          "cast_bigint_as_long_decimal", "cast (bigint as decimal(38,16))")
       .withIterations(100)
       .disableTesting();
 
diff --git a/velox/benchmarks/basic/ComparisonConjunct.cpp b/velox/benchmarks/basic/ComparisonConjunct.cpp
index 24aafb96c2ce2..cf40330eef4bc 100644
--- a/velox/benchmarks/basic/ComparisonConjunct.cpp
+++ b/velox/benchmarks/basic/ComparisonConjunct.cpp
@@ -175,9 +175,9 @@ BENCHMARK(conjunctsNested) {
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
-
+  memory::MemoryManager::initialize({});
   benchmark = std::make_unique<ComparisonBenchmark>(1'000);
   folly::runBenchmarks();
   benchmark.reset();
diff --git a/velox/benchmarks/basic/DecodedVector.cpp b/velox/benchmarks/basic/DecodedVector.cpp
index ef13901452c7f..3489967da7a24 100644
--- a/velox/benchmarks/basic/DecodedVector.cpp
+++ b/velox/benchmarks/basic/DecodedVector.cpp
@@ -188,9 +188,9 @@ BENCHMARK(decodeDictionary5Nested) {
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
-
+  memory::MemoryManager::initialize({});
   benchmark = std::make_unique<DecodedVectorBenchmark>(10'000);
   folly::runBenchmarks();
   benchmark.reset();
diff --git a/velox/benchmarks/basic/FeatureNormalization.cpp b/velox/benchmarks/basic/FeatureNormalization.cpp
index 4730510f43243..405e14819aa6b 100644
--- a/velox/benchmarks/basic/FeatureNormalization.cpp
+++ b/velox/benchmarks/basic/FeatureNormalization.cpp
@@ -110,9 +110,9 @@ BENCHMARK(normalizeConstant) {
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
-
+  memory::MemoryManager::initialize({});
   benchmark = std::make_unique<FeatureNormailzationBenchmark>();
   folly::runBenchmarks();
   benchmark.reset();
diff --git a/velox/benchmarks/basic/FormatDateTimeBenchmark.cpp b/velox/benchmarks/basic/FormatDateTimeBenchmark.cpp
new file mode 100644
index 0000000000000..a53b8eb770878
--- /dev/null
+++ b/velox/benchmarks/basic/FormatDateTimeBenchmark.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+using namespace facebook;
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+  functions::prestosql::registerDateTimeFunctions("");
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  VectorFuzzer::Options options;
+  options.vectorSize = 1000;
+  auto* pool = benchmarkBuilder.pool();
+  VectorFuzzer fuzzer(options, pool);
+  auto vectorMaker = benchmarkBuilder.vectorMaker();
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "Benchmark format_datetime",
+          vectorMaker.rowVector({fuzzer.fuzz(TIMESTAMP())}))
+      .addExpression("", "format_datetime(c0, 'yyyy-MM-dd HH:mm:ss.SSS')")
+      .disableTesting();
+
+  benchmarkBuilder.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/benchmarks/basic/LikeBenchmark.cpp b/velox/benchmarks/basic/LikeBenchmark.cpp
new file mode 100644
index 0000000000000..615cf625e37b7
--- /dev/null
+++ b/velox/benchmarks/basic/LikeBenchmark.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/lib/Re2Functions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+using namespace facebook;
+using namespace facebook::velox;
+using namespace facebook::velox::functions;
+using namespace facebook::velox::functions::test;
+using namespace facebook::velox::memory;
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+  exec::registerStatefulVectorFunction("like", likeSignatures(), makeLike);
+  // Register the scalar functions.
+  prestosql::registerAllScalarFunctions("");
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  const vector_size_t vectorSize = 1000;
+  auto vectorMaker = benchmarkBuilder.vectorMaker();
+
+  auto makeInput = [&](vector_size_t vectorSize,
+                       bool padAtHead,
+                       bool padAtTail,
+                       std::string content = "a_b_c",
+                       std::string paddingStr = "xxx") {
+    return vectorMaker.flatVector<std::string>(vectorSize, [&](auto row) {
+      // Strings in even rows contain/start with/end with a_b_c depends on
+      // value of padAtHead && padAtTail.
+
+      // Calculates the padding.
+      std::ostringstream os;
+      for (auto i = 0; i < row / 2 + 1; ++i) {
+        os << paddingStr;
+      }
+      auto padding = os.str();
+
+      if (row % 2 == 0) {
+        if (padAtHead && padAtTail) {
+          return fmt::format("{}{}{}", padding, content, padding);
+        } else if (padAtHead) {
+          return fmt::format("{}{}", padding, content);
+        } else if (padAtTail) {
+          return fmt::format("{}{}", content, padding);
+        } else {
+          return content;
+        }
+      } else {
+        // Yes, two padding concatenated, since we have a '/2' above.
+        return padding + padding;
+      }
+    });
+  };
+
+  auto substringInput = makeInput(vectorSize, true, true);
+  auto prefixInput = makeInput(vectorSize, false, true);
+  auto prefixUnicodeInput = makeInput(vectorSize, false, true, "你_好_啊");
+  auto suffixInput = makeInput(vectorSize, true, false);
+  auto suffixUnicodeInput = makeInput(vectorSize, true, false, "你_好_啊");
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "substring", vectorMaker.rowVector({"col0"}, {substringInput}))
+      .addExpression("substring", R"(like(col0, '%a\_b\_c%', '\'))")
+      .addExpression("strpos", R"(strpos(col0, 'a_b_c') > 0)");
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "prefix",
+          vectorMaker.rowVector(
+              {"col0", "col1"}, {prefixInput, prefixUnicodeInput}))
+      .addExpression("prefix", R"(like(col0, 'a\_b\_c%', '\'))")
+      .addExpression("relaxed_prefix_1", R"(like(col0, 'a\__\_c%', '\'))")
+      .addExpression("relaxed_prefix_2", R"(like(col0, '_\__\_c%', '\'))")
+      .addExpression(
+          "relaxed_prefix_unicode_1", R"(like(col1, '你\__\_啊%', '\'))")
+      .addExpression(
+          "relaxed_prefix_unicode_2", R"(like(col1, '_\__\_啊%', '\'))")
+      .addExpression("starts_with", R"(starts_with(col0, 'a_b_c'))");
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "suffix",
+          vectorMaker.rowVector(
+              {"col0", "col1"}, {suffixInput, suffixUnicodeInput}))
+      .addExpression("suffix", R"(like(col0, '%a\_b\_c', '\'))")
+      .addExpression("relaxed_suffix_1", R"(like(col0, '%a\__\_c', '\'))")
+      .addExpression("relaxed_suffix_2", R"(like(col0, '%_\__\_c', '\'))")
+      .addExpression(
+          "relaxed_suffix_unicode_1", R"(like(col1, '%你\__\_啊', '\'))")
+      .addExpression(
+          "relaxed_suffix_unicode_2", R"(like(col1, '%_\__\_啊', '\'))")
+      .addExpression("ends_with", R"(ends_with(col0, 'a_b_c'))");
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          "generic", vectorMaker.rowVector({"col0"}, {substringInput}))
+      .addExpression("generic", R"(like(col0, '%a%b%c'))");
+
+  benchmarkBuilder.registerBenchmarks();
+  benchmarkBuilder.testBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/benchmarks/basic/LikeFunctionsBenchmark.cpp b/velox/benchmarks/basic/LikeFunctionsBenchmark.cpp
deleted file mode 100644
index 1931585fdc9a6..0000000000000
--- a/velox/benchmarks/basic/LikeFunctionsBenchmark.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Benchmark.h>
-#include <folly/init/Init.h>
-
-#include "velox/functions/lib/Re2Functions.h"
-#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
-#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
-#include "velox/tpch/gen/TpchGen.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::tpch;
-using namespace facebook::velox::functions;
-using namespace facebook::velox::functions::test;
-using namespace facebook::velox::memory;
-
-DEFINE_int32(vector_size, 10000, "Vector size");
-DEFINE_int32(num_runs, 100, "Number of runs");
-DEFINE_int32(num_rows, 10000, "Number of rows");
-
-namespace {
-
-enum class TpchBenchmarkCase {
-  TpchQuery2,
-  TpchQuery9,
-  TpchQuery13,
-  TpchQuery14,
-  TpchQuery16Part,
-  TpchQuery16Supplier,
-  TpchQuery20,
-};
-
-class LikeFunctionsBenchmark : public FunctionBaseTest,
-                               public FunctionBenchmarkBase {
- public:
-  explicit LikeFunctionsBenchmark() {
-    exec::registerStatefulVectorFunction("like", likeSignatures(), makeLike);
-
-    VectorFuzzer::Options opts;
-    opts.vectorSize = FLAGS_vector_size;
-    VectorFuzzer fuzzer(opts, FunctionBenchmarkBase::pool());
-    inputFuzzer_ = fuzzer.fuzzFlat(VARCHAR());
-  }
-
-  // Generate random string using characters from characterSet.
-  std::string generateRandomString(const char* characterSet) {
-    auto characterSetLength = strlen(characterSet);
-    auto minimumLength = 1;
-    auto maximumLength = 10;
-    auto outputStringLength = rand() % maximumLength + minimumLength;
-    std::string output;
-
-    for (int i = 0; i < outputStringLength; i++) {
-      output += characterSet[rand() % characterSetLength];
-    }
-    return output;
-  }
-
-  std::string generatePattern(
-      PatternKind patternKind,
-      const std::string& inputString) {
-    switch (patternKind) {
-      case PatternKind::kExactlyN:
-        return std::string(inputString.size(), '_');
-      case PatternKind::kAtLeastN:
-        return generateRandomString(kWildcardCharacterSet);
-      case PatternKind::kPrefix: {
-        auto fixedPatternLength =
-            std::min(vector_size_t(inputString.size()), 10);
-        auto fixedPatternString = inputString.substr(0, fixedPatternLength);
-        return fixedPatternString + generateRandomString(kAnyWildcardCharacter);
-      }
-      case PatternKind::kSuffix: {
-        auto fixedPatternStartIdx =
-            std::max(vector_size_t(inputString.size() - 10), 0);
-        auto fixedPatternString = inputString.substr(fixedPatternStartIdx, 10);
-        return generateRandomString(kAnyWildcardCharacter) + fixedPatternString;
-      }
-      default:
-        return inputString;
-    }
-  }
-
-  const VectorPtr getTpchData(const TpchBenchmarkCase tpchCase) {
-    switch (tpchCase) {
-      case TpchBenchmarkCase::TpchQuery2:
-      case TpchBenchmarkCase::TpchQuery14:
-      case TpchBenchmarkCase::TpchQuery16Part: {
-        auto tpchPart = genTpchPart(pool_.get(), FLAGS_num_rows);
-        return tpchPart->childAt(4);
-      }
-      case TpchBenchmarkCase::TpchQuery9:
-      case TpchBenchmarkCase::TpchQuery20: {
-        auto tpchPart = genTpchPart(pool_.get(), FLAGS_num_rows);
-        return tpchPart->childAt(1);
-      }
-      case TpchBenchmarkCase::TpchQuery13: {
-        auto tpchOrders = genTpchOrders(pool_.get(), FLAGS_num_rows);
-        return tpchOrders->childAt(8);
-      }
-      case TpchBenchmarkCase::TpchQuery16Supplier: {
-        auto tpchSupplier = genTpchSupplier(pool_.get(), FLAGS_num_rows);
-        return tpchSupplier->childAt(6);
-      }
-      default:
-        VELOX_FAIL(fmt::format(
-            "Tpch data generation for case {} is not supported", tpchCase));
-    }
-  }
-
-  size_t run(const TpchBenchmarkCase tpchCase, const StringView patternString) {
-    folly::BenchmarkSuspender kSuspender;
-    const auto input = getTpchData(tpchCase);
-    const auto data = makeRowVector({input});
-    auto likeExpression = fmt::format("like(c0, '{}')", patternString);
-    auto rowType = std::dynamic_pointer_cast<const RowType>(data->type());
-    exec::ExprSet exprSet =
-        FunctionBenchmarkBase::compileExpression(likeExpression, rowType);
-    kSuspender.dismiss();
-
-    size_t cnt = 0;
-    for (auto i = 0; i < FLAGS_num_runs; i++) {
-      auto result = FunctionBenchmarkBase::evaluate(exprSet, data);
-      cnt += result->size();
-    }
-    folly::doNotOptimizeAway(cnt);
-
-    return cnt;
-  }
-
-  size_t run(PatternKind patternKind) {
-    folly::BenchmarkSuspender kSuspender;
-    const auto input = inputFuzzer_->values()->as<StringView>();
-    auto patternString = generatePattern(patternKind, input[0].str());
-    std::vector<std::string> patternVector(FLAGS_vector_size, patternString);
-    const auto data = makeRowVector({inputFuzzer_});
-    auto likeExpression = fmt::format("like(c0, '{}')", patternString);
-    auto rowType = std::dynamic_pointer_cast<const RowType>(data->type());
-    exec::ExprSet exprSet =
-        FunctionBenchmarkBase::compileExpression(likeExpression, rowType);
-    kSuspender.dismiss();
-
-    size_t cnt = 0;
-    for (auto i = 0; i < FLAGS_num_runs; i++) {
-      auto result = FunctionBenchmarkBase::evaluate(exprSet, data);
-      cnt += result->size();
-    }
-    folly::doNotOptimizeAway(cnt);
-
-    return cnt;
-  }
-
-  // We inherit from FunctionBaseTest so that we can get access to the helpers
-  // it defines, but since it is supposed to be a test fixture TestBody() is
-  // declared pure virtual.  We must provide an implementation here.
-  void TestBody() override {}
-
- private:
-  static constexpr const char* kWildcardCharacterSet = "%_";
-  static constexpr const char* kAnyWildcardCharacter = "%";
-  std::shared_ptr<MemoryPool> pool_{addDefaultLeafMemoryPool()};
-  VectorPtr inputFuzzer_;
-};
-
-std::unique_ptr<LikeFunctionsBenchmark> benchmark;
-
-BENCHMARK(wildcardExactlyN) {
-  benchmark->run(PatternKind::kExactlyN);
-}
-
-BENCHMARK(wildcardAtLeastN) {
-  benchmark->run(PatternKind::kAtLeastN);
-}
-
-BENCHMARK(fixedPattern) {
-  benchmark->run(PatternKind::kFixed);
-}
-
-BENCHMARK(prefixPattern) {
-  benchmark->run(PatternKind::kPrefix);
-}
-
-BENCHMARK(suffixPattern) {
-  benchmark->run(PatternKind::kSuffix);
-}
-
-BENCHMARK_DRAW_LINE();
-
-BENCHMARK(tpchQuery2) {
-  benchmark->run(TpchBenchmarkCase::TpchQuery2, "%BRASS");
-}
-
-BENCHMARK(tpchQuery9) {
-  benchmark->run(TpchBenchmarkCase::TpchQuery9, "%green%");
-}
-
-BENCHMARK(tpchQuery13) {
-  benchmark->run(TpchBenchmarkCase::TpchQuery13, "%special%requests%");
-}
-
-BENCHMARK(tpchQuery14) {
-  benchmark->run(TpchBenchmarkCase::TpchQuery14, "PROMO%");
-}
-
-BENCHMARK(tpchQuery16Part) {
-  benchmark->run(TpchBenchmarkCase::TpchQuery16Part, "MEDIUM POLISHED%");
-}
-
-BENCHMARK(tpchQuery16Supplier) {
-  benchmark->run(
-      TpchBenchmarkCase::TpchQuery16Supplier, "%Customer%Complaints%");
-}
-
-BENCHMARK(tpchQuery20) {
-  benchmark->run(TpchBenchmarkCase::TpchQuery20, "forest%");
-}
-
-} // namespace
-
-int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv, true);
-  benchmark = std::make_unique<LikeFunctionsBenchmark>();
-  folly::runBenchmarks();
-  benchmark.reset();
-
-  return 0;
-}
diff --git a/velox/benchmarks/basic/LikeTpchBenchmark.cpp b/velox/benchmarks/basic/LikeTpchBenchmark.cpp
new file mode 100644
index 0000000000000..29cde56e51e37
--- /dev/null
+++ b/velox/benchmarks/basic/LikeTpchBenchmark.cpp
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/functions/lib/Re2Functions.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/tpch/gen/TpchGen.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::tpch;
+using namespace facebook::velox::functions;
+using namespace facebook::velox::functions::test;
+using namespace facebook::velox::memory;
+
+DEFINE_int32(vector_size, 10000, "Vector size");
+DEFINE_int32(num_runs, 100, "Number of runs");
+DEFINE_int32(num_rows, 10000, "Number of rows");
+
+namespace {
+
+enum class TpchBenchmarkCase {
+  TpchQuery2,
+  TpchQuery9,
+  TpchQuery13,
+  TpchQuery14,
+  TpchQuery16Part,
+  TpchQuery16Supplier,
+  TpchQuery20,
+};
+}
+
+template <>
+struct fmt::formatter<TpchBenchmarkCase> : fmt::formatter<int> {
+  auto format(const TpchBenchmarkCase& s, format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
+
+namespace {
+class LikeFunctionsBenchmark : public FunctionBaseTest,
+                               public FunctionBenchmarkBase {
+ public:
+  explicit LikeFunctionsBenchmark() {
+    exec::registerStatefulVectorFunction("like", likeSignatures(), makeLike);
+
+    VectorFuzzer::Options opts;
+    opts.vectorSize = FLAGS_vector_size;
+    VectorFuzzer fuzzer(opts, FunctionBenchmarkBase::pool());
+    inputFuzzer_ = fuzzer.fuzzFlat(VARCHAR());
+  }
+
+  // Generate random string using characters from characterSet.
+  std::string generateRandomString(const char* characterSet) {
+    auto characterSetLength = strlen(characterSet);
+    auto minimumLength = 1;
+    auto maximumLength = 10;
+    auto outputStringLength = rand() % maximumLength + minimumLength;
+    std::string output;
+
+    for (int i = 0; i < outputStringLength; i++) {
+      output += characterSet[rand() % characterSetLength];
+    }
+    return output;
+  }
+
+  std::string generatePattern(
+      PatternKind patternKind,
+      const std::string& inputString) {
+    switch (patternKind) {
+      case PatternKind::kExactlyN:
+        return std::string(inputString.size(), '_');
+      case PatternKind::kAtLeastN:
+        return generateRandomString(kWildcardCharacterSet);
+      case PatternKind::kPrefix: {
+        auto fixedPatternLength =
+            std::min(vector_size_t(inputString.size()), 10);
+        auto fixedPatternString = inputString.substr(0, fixedPatternLength);
+        return fixedPatternString + generateRandomString(kAnyWildcardCharacter);
+      }
+      case PatternKind::kSuffix: {
+        auto fixedPatternStartIdx =
+            std::max(vector_size_t(inputString.size() - 10), 0);
+        auto fixedPatternString = inputString.substr(fixedPatternStartIdx, 10);
+        return generateRandomString(kAnyWildcardCharacter) + fixedPatternString;
+      }
+      default:
+        return inputString;
+    }
+  }
+
+  const VectorPtr getTpchData(const TpchBenchmarkCase tpchCase) {
+    switch (tpchCase) {
+      case TpchBenchmarkCase::TpchQuery2:
+      case TpchBenchmarkCase::TpchQuery14:
+      case TpchBenchmarkCase::TpchQuery16Part: {
+        auto tpchPart = genTpchPart(pool_.get(), FLAGS_num_rows);
+        return tpchPart->childAt(4);
+      }
+      case TpchBenchmarkCase::TpchQuery9:
+      case TpchBenchmarkCase::TpchQuery20: {
+        auto tpchPart = genTpchPart(pool_.get(), FLAGS_num_rows);
+        return tpchPart->childAt(1);
+      }
+      case TpchBenchmarkCase::TpchQuery13: {
+        auto tpchOrders = genTpchOrders(pool_.get(), FLAGS_num_rows);
+        return tpchOrders->childAt(8);
+      }
+      case TpchBenchmarkCase::TpchQuery16Supplier: {
+        auto tpchSupplier = genTpchSupplier(pool_.get(), FLAGS_num_rows);
+        return tpchSupplier->childAt(6);
+      }
+      default:
+        VELOX_FAIL(fmt::format(
+            "Tpch data generation for case {} is not supported", tpchCase));
+    }
+  }
+
+  size_t run(const TpchBenchmarkCase tpchCase, const StringView patternString) {
+    folly::BenchmarkSuspender kSuspender;
+    const auto input = getTpchData(tpchCase);
+    const auto data = makeRowVector({input});
+    auto likeExpression = fmt::format("like(c0, '{}')", patternString);
+    auto rowType = std::dynamic_pointer_cast<const RowType>(data->type());
+    exec::ExprSet exprSet =
+        FunctionBenchmarkBase::compileExpression(likeExpression, rowType);
+    kSuspender.dismiss();
+
+    size_t cnt = 0;
+    for (auto i = 0; i < FLAGS_num_runs; i++) {
+      auto result = FunctionBenchmarkBase::evaluate(exprSet, data);
+      cnt += result->size();
+    }
+    folly::doNotOptimizeAway(cnt);
+
+    return cnt;
+  }
+
+  size_t run(PatternKind patternKind) {
+    folly::BenchmarkSuspender kSuspender;
+    const auto input = inputFuzzer_->values()->as<StringView>();
+    auto patternString = generatePattern(patternKind, input[0].str());
+    std::vector<std::string> patternVector(FLAGS_vector_size, patternString);
+    const auto data = makeRowVector({inputFuzzer_});
+    auto likeExpression = fmt::format("like(c0, '{}')", patternString);
+    auto rowType = std::dynamic_pointer_cast<const RowType>(data->type());
+    exec::ExprSet exprSet =
+        FunctionBenchmarkBase::compileExpression(likeExpression, rowType);
+    kSuspender.dismiss();
+
+    size_t cnt = 0;
+    for (auto i = 0; i < FLAGS_num_runs; i++) {
+      auto result = FunctionBenchmarkBase::evaluate(exprSet, data);
+      cnt += result->size();
+    }
+    folly::doNotOptimizeAway(cnt);
+
+    return cnt;
+  }
+
+  // We inherit from FunctionBaseTest so that we can get access to the helpers
+  // it defines, but since it is supposed to be a test fixture TestBody() is
+  // declared pure virtual.  We must provide an implementation here.
+  void TestBody() override {}
+
+ private:
+  static constexpr const char* kWildcardCharacterSet = "%_";
+  static constexpr const char* kAnyWildcardCharacter = "%";
+  std::shared_ptr<MemoryPool> pool_{memory::memoryManager()->addLeafPool()};
+  VectorPtr inputFuzzer_;
+};
+
+std::unique_ptr<LikeFunctionsBenchmark> benchmark;
+
+BENCHMARK(wildcardExactlyN) {
+  benchmark->run(PatternKind::kExactlyN);
+}
+
+BENCHMARK(wildcardAtLeastN) {
+  benchmark->run(PatternKind::kAtLeastN);
+}
+
+BENCHMARK(fixedPattern) {
+  benchmark->run(PatternKind::kFixed);
+}
+
+BENCHMARK(prefixPattern) {
+  benchmark->run(PatternKind::kPrefix);
+}
+
+BENCHMARK(suffixPattern) {
+  benchmark->run(PatternKind::kSuffix);
+}
+
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK(tpchQuery2) {
+  benchmark->run(TpchBenchmarkCase::TpchQuery2, "%BRASS");
+}
+
+BENCHMARK(tpchQuery9) {
+  benchmark->run(TpchBenchmarkCase::TpchQuery9, "%green%");
+}
+
+BENCHMARK(tpchQuery13) {
+  benchmark->run(TpchBenchmarkCase::TpchQuery13, "%special%requests%");
+}
+
+BENCHMARK(tpchQuery14) {
+  benchmark->run(TpchBenchmarkCase::TpchQuery14, "PROMO%");
+}
+
+BENCHMARK(tpchQuery16Part) {
+  benchmark->run(TpchBenchmarkCase::TpchQuery16Part, "MEDIUM POLISHED%");
+}
+
+BENCHMARK(tpchQuery16Supplier) {
+  benchmark->run(
+      TpchBenchmarkCase::TpchQuery16Supplier, "%Customer%Complaints%");
+}
+
+BENCHMARK(tpchQuery20) {
+  benchmark->run(TpchBenchmarkCase::TpchQuery20, "forest%");
+}
+
+} // namespace
+
+int main(int argc, char* argv[]) {
+  folly::Init init{&argc, &argv, true};
+  memory::MemoryManager::initialize({});
+  benchmark = std::make_unique<LikeFunctionsBenchmark>();
+  folly::runBenchmarks();
+  benchmark.reset();
+
+  return 0;
+}
diff --git a/velox/benchmarks/basic/Preproc.cpp b/velox/benchmarks/basic/Preproc.cpp
index 214be1fe773e2..528e1a6461f9e 100644
--- a/velox/benchmarks/basic/Preproc.cpp
+++ b/velox/benchmarks/basic/Preproc.cpp
@@ -444,8 +444,8 @@ BENCHMARK(allFusedWithNulls) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
-
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
   benchmark = std::make_unique<PreprocBenchmark>();
   // Verify that benchmark calculations are correct.
   benchmark->test();
diff --git a/velox/benchmarks/basic/SelectivityVector.cpp b/velox/benchmarks/basic/SelectivityVector.cpp
index 22273d3d77906..cef36633157eb 100644
--- a/velox/benchmarks/basic/SelectivityVector.cpp
+++ b/velox/benchmarks/basic/SelectivityVector.cpp
@@ -164,9 +164,9 @@ BENCHMARK(sumSelectivity1PerCent) {
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
-
+  memory::MemoryManager::initialize({});
   benchmark = std::make_unique<SelectivityVectorBenchmark>(10'000);
   folly::runBenchmarks();
   benchmark.reset();
diff --git a/velox/benchmarks/basic/SimpleArithmetic.cpp b/velox/benchmarks/basic/SimpleArithmetic.cpp
index c2715fdca028c..4da3453a1863d 100644
--- a/velox/benchmarks/basic/SimpleArithmetic.cpp
+++ b/velox/benchmarks/basic/SimpleArithmetic.cpp
@@ -20,9 +20,9 @@
 #include <gflags/gflags.h>
 
 #include "velox/functions/Registerer.h"
+#include "velox/functions/lib/CheckedArithmeticImpl.h"
 #include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
 #include "velox/functions/prestosql/ArithmeticImpl.h"
-#include "velox/functions/prestosql/CheckedArithmeticImpl.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 DEFINE_int64(fuzzer_seed, 99887766, "Seed for random input dataset generator");
@@ -343,9 +343,9 @@ BENCHMARK(plusCheckedLarge) {
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
-
+  memory::MemoryManager::initialize({});
   benchmark = std::make_unique<SimpleArithmeticBenchmark>();
   folly::runBenchmarks();
   benchmark.reset();
diff --git a/velox/benchmarks/basic/SimpleCastExpr.cpp b/velox/benchmarks/basic/SimpleCastExpr.cpp
index 5858d5602bba2..497b66d8c0b88 100644
--- a/velox/benchmarks/basic/SimpleCastExpr.cpp
+++ b/velox/benchmarks/basic/SimpleCastExpr.cpp
@@ -19,9 +19,7 @@
 
 #include <gflags/gflags.h>
 
-#include "velox/functions/Registerer.h"
 #include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
-#include "velox/functions/prestosql/ArithmeticImpl.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 DEFINE_int64(fuzzer_seed, 99887766, "Seed for random input dataset generator");
@@ -31,83 +29,230 @@ using namespace facebook::velox::exec;
 using namespace facebook::velox::test;
 
 namespace {
+const std::string_view kColName{"a"};
+
 class SimpleCastBenchmark : public functions::test::FunctionBenchmarkBase {
  public:
   explicit SimpleCastBenchmark() : FunctionBenchmarkBase() {}
 
-  RowVectorPtr makeRowVector(vector_size_t size) {
+  RowVectorPtr makeRowVector(const TypePtr& type, vector_size_t size) {
     VectorFuzzer::Options opts;
     opts.vectorSize = size;
     opts.nullRatio = 0;
-    VectorFuzzer fuzzer(opts, pool(), FLAGS_fuzzer_seed);
-    std::vector<VectorPtr> children;
-    children.emplace_back(fuzzer.fuzzFlat(TIMESTAMP())); // Col a
-    return std::make_shared<RowVector>(
-        pool(), inputType_, nullptr, size, std::move(children));
+    VectorFuzzer fuzzer(std::move(opts), pool(), FLAGS_fuzzer_seed);
+    VectorPtr input = fuzzer.fuzzFlat(type); // Col a
+    return vectorMaker_.rowVector(
+        std::vector<std::string>{std::string(kColName)},
+        std::vector<VectorPtr>{std::move(input)});
   }
 
-  static constexpr auto kNumSmallRuns = 10'000;
+  static constexpr auto kNumSmallRuns = 100;
   static constexpr auto kNumMediumRuns = 1000;
-  static constexpr auto kNumLargeRuns = 100;
+  static constexpr auto kNumLargeRuns = 10'000;
 
-  void runSmall(const std::string& expression) {
-    run(expression, kNumSmallRuns, smallRowVector_);
+  void runSmall(const TypePtr& inputType, const TypePtr& outputType) {
+    run(inputType, outputType, kNumSmallRuns);
   }
 
-  void runMedium(const std::string& expression) {
-    run(expression, kNumMediumRuns, mediumRowVector_);
+  void runMedium(const TypePtr& inputType, const TypePtr& outputType) {
+    run(inputType, outputType, kNumMediumRuns);
   }
 
-  void runLarge(const std::string& expression) {
-    run(expression, kNumLargeRuns, largeRowVector_);
+  void runLarge(const TypePtr& inputType, const TypePtr& outputType) {
+    run(inputType, outputType, kNumLargeRuns);
   }
 
-  // Compiles and runs the `expression` `iterations` number of times.
-  size_t run(
-      const std::string& expression,
-      size_t iterations,
-      const RowVectorPtr& input) {
+  size_t
+  run(const TypePtr& inputType, const TypePtr& outputType, size_t batchSize) {
     folly::BenchmarkSuspender suspender;
-    auto exprSet = compileExpression(expression, inputType_);
+    auto input = makeRowVector(inputType, batchSize);
+    auto castInput =
+        std::make_shared<facebook::velox::core::FieldAccessTypedExpr>(
+            inputType, std::string(kColName));
+    std::vector<facebook::velox::core::TypedExprPtr> expr{
+        std::make_shared<facebook::velox::core::CastTypedExpr>(
+            outputType, castInput, false)};
+    exec::ExprSet exprSet(expr, &execCtx_);
+    SelectivityVector rows(input->size());
+    VectorPtr result;
     suspender.dismiss();
 
     size_t count = 0;
-    for (auto i = 0; i < iterations; i++) {
-      count += evaluate(exprSet, input)->size();
+    for (auto i = 0; i < 1000; i++) {
+      evaluate(exprSet, input, rows, result);
+      count += result->size();
     }
     return count;
   }
-
- private:
-  const TypePtr inputType_ = ROW({
-      {"a", TIMESTAMP()},
-  });
-  const RowVectorPtr smallRowVector_ = makeRowVector(100);
-  const RowVectorPtr mediumRowVector_ = makeRowVector(1'000);
-  const RowVectorPtr largeRowVector_ = makeRowVector(10'000);
 };
 
+TypePtr buildStructType(
+    std::function<std::string(int)>&& nameGenerator,
+    const TypePtr& fieldType,
+    size_t numChildren) {
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  for (int i = 0; i < numChildren; i++) {
+    names.push_back(nameGenerator(i));
+    types.push_back(fieldType);
+  }
+  return ROW(std::move(names), std::move(types));
+}
+
 std::unique_ptr<SimpleCastBenchmark> benchmark;
 
-BENCHMARK(castTimestampDate) {
+BENCHMARK(castTimestampDateSmall) {
+  benchmark->setAdjustTimestampToTimezone("false");
+  benchmark->runSmall(TIMESTAMP(), DATE());
+}
+
+BENCHMARK(castTimestampDateMedium) {
+  benchmark->setAdjustTimestampToTimezone("false");
+  benchmark->runMedium(TIMESTAMP(), DATE());
+}
+
+BENCHMARK(castTimestampDateLarge) {
   benchmark->setAdjustTimestampToTimezone("false");
-  benchmark->runSmall("cast (a as date)");
-  benchmark->runMedium("cast (a as date)");
-  benchmark->runLarge("cast (a as date)");
+  benchmark->runLarge(TIMESTAMP(), DATE());
 }
 
-BENCHMARK(castTimestampDateAdjustTimeZone) {
+BENCHMARK(castTimestampDateAdjustTimeZoneSmall) {
   benchmark->setTimezone("America/Los_Angeles");
   benchmark->setAdjustTimestampToTimezone("true");
-  benchmark->runSmall("cast (a as date)");
-  benchmark->runMedium("cast (a as date)");
-  benchmark->runLarge("cast (a as date)");
+  benchmark->runSmall(TIMESTAMP(), DATE());
+}
+
+BENCHMARK(castTimestampDateAdjustTimeZoneMedium) {
+  benchmark->setTimezone("America/Los_Angeles");
+  benchmark->setAdjustTimestampToTimezone("true");
+  benchmark->runMedium(TIMESTAMP(), DATE());
+}
+
+BENCHMARK(castTimestampDateAdjustTimeZoneLarge) {
+  benchmark->setTimezone("America/Los_Angeles");
+  benchmark->setAdjustTimestampToTimezone("true");
+  benchmark->runLarge(TIMESTAMP(), DATE());
+}
+
+BENCHMARK(castStructFewFieldsRenameSmall) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 3);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, INTEGER(), 3);
+  suspender.dismiss();
+
+  benchmark->runSmall(oldType, newType);
+}
+
+BENCHMARK(castStructFewFieldsRenameMedium) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 3);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, INTEGER(), 3);
+  suspender.dismiss();
+
+  benchmark->runMedium(oldType, newType);
+}
+
+BENCHMARK(castStructFewFieldsRenameLarge) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 3);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, INTEGER(), 3);
+  suspender.dismiss();
+
+  benchmark->runLarge(oldType, newType);
+}
+
+BENCHMARK(castStructManyFieldsRenameSmall) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 1000);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, INTEGER(), 1000);
+  suspender.dismiss();
+
+  benchmark->runSmall(oldType, newType);
+}
+
+BENCHMARK(castStructManyFieldsRenameMedium) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 1000);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, INTEGER(), 1000);
+  suspender.dismiss();
+
+  benchmark->runMedium(oldType, newType);
 }
+
+BENCHMARK(castStructManyFieldsRenameLarge) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 1000);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, INTEGER(), 1000);
+  suspender.dismiss();
+
+  benchmark->runLarge(oldType, newType);
+}
+
+BENCHMARK(castStructFewFieldsNestedCastSmall) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 3);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, BIGINT(), 3);
+  suspender.dismiss();
+
+  benchmark->runSmall(oldType, newType);
+}
+
+BENCHMARK(castStructFewFieldsNestedCastMedium) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 3);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, BIGINT(), 3);
+  suspender.dismiss();
+
+  benchmark->runMedium(oldType, newType);
+}
+
+BENCHMARK(castStructFewFieldsNestedCastLarge) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 3);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, BIGINT(), 3);
+  suspender.dismiss();
+
+  benchmark->runLarge(oldType, newType);
+}
+
+BENCHMARK(castStructManyFieldsNestedCastSmall) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 1000);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, BIGINT(), 1000);
+  suspender.dismiss();
+
+  benchmark->runSmall(oldType, newType);
+}
+
+BENCHMARK(castStructManyFieldsNestedCastMedium) {
+  folly::BenchmarkSuspender suspender;
+  auto oldType = buildStructType([](int) { return ""; }, INTEGER(), 1000);
+  auto newType = buildStructType(
+      [](int i) { return fmt::format("col{}", i); }, BIGINT(), 1000);
+  suspender.dismiss();
+
+  benchmark->runMedium(oldType, newType);
+}
+
+// castStructManyFieldsNestedCastLarge is skipped because it takes too long to
+// run.
+
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
+  memory::MemoryManager::initialize({});
   benchmark = std::make_unique<SimpleCastBenchmark>();
   folly::runBenchmarks();
   benchmark.reset();
diff --git a/velox/benchmarks/basic/VectorCompare.cpp b/velox/benchmarks/basic/VectorCompare.cpp
index b967b49ffbb6a..6b67e267d8820 100644
--- a/velox/benchmarks/basic/VectorCompare.cpp
+++ b/velox/benchmarks/basic/VectorCompare.cpp
@@ -81,7 +81,7 @@ class VectorCompareBenchmark : public functions::test::FunctionBenchmarkBase {
       true,
       true,
       false,
-      CompareFlags::NullHandlingMode::NoStop};
+      CompareFlags::NullHandlingMode::kNullAsValue};
 
   const size_t vectorSize_;
   SelectivityVector rows_;
@@ -114,9 +114,9 @@ BENCHMARK_DRAW_LINE();
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
-
+  memory::MemoryManager::initialize({});
   benchmark = std::make_unique<VectorCompareBenchmark>(1000);
   folly::runBenchmarks();
   benchmark.reset();
diff --git a/velox/benchmarks/basic/VectorFuzzer.cpp b/velox/benchmarks/basic/VectorFuzzer.cpp
index ba76519e9a2f9..2196e8bf9952d 100644
--- a/velox/benchmarks/basic/VectorFuzzer.cpp
+++ b/velox/benchmarks/basic/VectorFuzzer.cpp
@@ -28,7 +28,10 @@ namespace {
 
 using namespace facebook::velox;
 
-std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+memory::MemoryPool* pool() {
+  static auto leaf = memory::MemoryManager::getInstance()->addLeafPool();
+  return leaf.get();
+}
 
 VectorFuzzer::Options getOpts(size_t n, double nullRatio = 0) {
   VectorFuzzer::Options opts;
@@ -38,25 +41,25 @@ VectorFuzzer::Options getOpts(size_t n, double nullRatio = 0) {
 }
 
 BENCHMARK_MULTI(flatInteger, n) {
-  VectorFuzzer fuzzer(getOpts(n), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n), pool(), FLAGS_fuzzer_seed);
   folly::doNotOptimizeAway(fuzzer.fuzzFlat(BIGINT()));
   return n;
 }
 
 BENCHMARK_RELATIVE_MULTI(flatIntegerHalfNull, n) {
-  VectorFuzzer fuzzer(getOpts(n, 0.5), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n, 0.5), pool(), FLAGS_fuzzer_seed);
   folly::doNotOptimizeAway(fuzzer.fuzzFlat(BIGINT()));
   return n;
 }
 
 BENCHMARK_RELATIVE_MULTI(flatDouble, n) {
-  VectorFuzzer fuzzer(getOpts(n), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n), pool(), FLAGS_fuzzer_seed);
   folly::doNotOptimizeAway(fuzzer.fuzzFlat(DOUBLE()));
   return n;
 }
 
 BENCHMARK_RELATIVE_MULTI(flatBool, n) {
-  VectorFuzzer fuzzer(getOpts(n), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n), pool(), FLAGS_fuzzer_seed);
   folly::doNotOptimizeAway(fuzzer.fuzzFlat(BOOLEAN()));
   return n;
 }
@@ -65,7 +68,7 @@ BENCHMARK_RELATIVE_MULTI(flatVarcharAscii, n) {
   auto opts = getOpts(n);
   opts.charEncodings = {UTF8CharList::ASCII};
 
-  VectorFuzzer fuzzer(opts, pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(opts, pool(), FLAGS_fuzzer_seed);
   folly::doNotOptimizeAway(fuzzer.fuzzFlat(VARCHAR()));
   return n;
 }
@@ -74,7 +77,7 @@ BENCHMARK_RELATIVE_MULTI(flatVarcharUtf8, n) {
   auto opts = getOpts(n);
   opts.charEncodings = {UTF8CharList::EXTENDED_UNICODE};
 
-  VectorFuzzer fuzzer(opts, pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(opts, pool(), FLAGS_fuzzer_seed);
   folly::doNotOptimizeAway(fuzzer.fuzzFlat(VARCHAR()));
   return n;
 }
@@ -82,13 +85,13 @@ BENCHMARK_RELATIVE_MULTI(flatVarcharUtf8, n) {
 BENCHMARK_DRAW_LINE();
 
 BENCHMARK_RELATIVE_MULTI(constantInteger, n) {
-  VectorFuzzer fuzzer(getOpts(n), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n), pool(), FLAGS_fuzzer_seed);
   folly::doNotOptimizeAway(fuzzer.fuzzConstant(BIGINT()));
   return n;
 }
 
 BENCHMARK_RELATIVE_MULTI(dictionaryInteger, n) {
-  VectorFuzzer fuzzer(getOpts(n), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n), pool(), FLAGS_fuzzer_seed);
   folly::doNotOptimizeAway(fuzzer.fuzzDictionary(fuzzer.fuzzFlat(BIGINT())));
   return n;
 }
@@ -96,7 +99,7 @@ BENCHMARK_RELATIVE_MULTI(dictionaryInteger, n) {
 BENCHMARK_DRAW_LINE();
 
 BENCHMARK_RELATIVE_MULTI(flatArray, n) {
-  VectorFuzzer fuzzer(getOpts(n), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n), pool(), FLAGS_fuzzer_seed);
   const size_t elementsSize = n * fuzzer.getOptions().containerLength;
   folly::doNotOptimizeAway(
       fuzzer.fuzzArray(fuzzer.fuzzFlat(BIGINT(), elementsSize), n));
@@ -104,7 +107,7 @@ BENCHMARK_RELATIVE_MULTI(flatArray, n) {
 }
 
 BENCHMARK_RELATIVE_MULTI(flatMap, n) {
-  VectorFuzzer fuzzer(getOpts(n), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n), pool(), FLAGS_fuzzer_seed);
   const size_t elementsSize = n * fuzzer.getOptions().containerLength;
   folly::doNotOptimizeAway(fuzzer.fuzzMap(
       fuzzer.fuzzFlat(BIGINT(), elementsSize),
@@ -114,7 +117,7 @@ BENCHMARK_RELATIVE_MULTI(flatMap, n) {
 }
 
 BENCHMARK_RELATIVE_MULTI(flatMapArrayNested, n) {
-  VectorFuzzer fuzzer(getOpts(n), pool.get(), FLAGS_fuzzer_seed);
+  VectorFuzzer fuzzer(getOpts(n), pool(), FLAGS_fuzzer_seed);
   const size_t elementsSize = n * fuzzer.getOptions().containerLength;
 
   folly::doNotOptimizeAway(fuzzer.fuzzMap(
@@ -128,8 +131,9 @@ BENCHMARK_RELATIVE_MULTI(flatMapArrayNested, n) {
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
+  memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/benchmarks/basic/VectorSlice.cpp b/velox/benchmarks/basic/VectorSlice.cpp
index 58fa5642abf25..d03cc06ea6afd 100644
--- a/velox/benchmarks/basic/VectorSlice.cpp
+++ b/velox/benchmarks/basic/VectorSlice.cpp
@@ -37,7 +37,7 @@ constexpr int kVectorSize = 16 << 10;
 
 struct BenchmarkData {
   BenchmarkData()
-      : pool_(memory::addDefaultLeafMemoryPool(
+      : pool_(memory::memoryManager()->addLeafPool(
             "BenchmarkData",
             FLAGS_use_thread_safe_memory_usage_track)) {
     VectorFuzzer::Options opts;
@@ -110,10 +110,11 @@ DEFINE_BENCHMARKS(row)
 } // namespace facebook::velox
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   using namespace facebook::velox;
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   VELOX_CHECK_LE(FLAGS_slice_size, kVectorSize);
+  memory::MemoryManager::initialize({});
   data = std::make_unique<BenchmarkData>();
   folly::runBenchmarks();
   data.reset();
diff --git a/velox/benchmarks/filesystem/CMakeLists.txt b/velox/benchmarks/filesystem/CMakeLists.txt
new file mode 100644
index 0000000000000..10a5ebdf710d0
--- /dev/null
+++ b/velox/benchmarks/filesystem/CMakeLists.txt
@@ -0,0 +1,31 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_read_benchmark_lib ReadBenchmark.cpp)
+
+target_link_libraries(
+  velox_read_benchmark_lib
+  PUBLIC velox_file velox_time Folly::folly gflags::gflags)
+
+add_executable(velox_read_benchmark ReadBenchmarkMain.cpp)
+
+target_link_libraries(
+  velox_read_benchmark
+  PRIVATE
+    velox_read_benchmark_lib
+    velox_hive_config
+    velox_s3fs
+    velox_hdfs
+    velox_abfs
+    velox_gcs)
diff --git a/velox/benchmarks/filesystem/ReadBenchmark.cpp b/velox/benchmarks/filesystem/ReadBenchmark.cpp
new file mode 100644
index 0000000000000..f99639b8c9663
--- /dev/null
+++ b/velox/benchmarks/filesystem/ReadBenchmark.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/benchmarks/filesystem/ReadBenchmark.h"
+
+#include "velox/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h"
+#include "velox/connectors/hive/storage_adapters/gcs/RegisterGCSFileSystem.h"
+#include "velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
+
+DEFINE_string(path, "", "Path of the input file");
+DEFINE_int64(
+    file_size_gb,
+    0,
+    "Limits the test to the first --file_size_gb "
+    "of --path. 0 means use the whole file");
+DEFINE_int32(num_threads, 16, "Test paralelism");
+DEFINE_int32(seed, 0, "Random seed, 0 means no seed");
+DEFINE_bool(odirect, false, "Use O_DIRECT");
+
+DEFINE_int32(
+    bytes,
+    0,
+    "If 0, runs through a set of predefined read patterns. "
+    "If non-0, this is the size of a single read. The reads are "
+    "made in --num_in_run consecutive batchhes with --gap bytes between each read");
+DEFINE_int32(gap, 0, "Gap between consecutive reads if --bytes is non-0");
+DEFINE_int32(
+    num_in_run,
+    10,
+    "Number of consecutive reads of --bytes separated by --gap bytes");
+DEFINE_int32(
+    measurement_size,
+    100 << 20,
+    "Total reads per thread when throughput for a --bytes/--gap/--/gap/"
+    "--num_in_run combination");
+DEFINE_string(config, "", "Path of the config file");
+
+namespace {
+static bool notEmpty(const char* /*flagName*/, const std::string& value) {
+  return !value.empty();
+}
+} // namespace
+
+DEFINE_validator(path, &notEmpty);
+
+namespace facebook::velox {
+
+std::shared_ptr<config::ConfigBase> readConfig(const std::string& filePath) {
+  std::ifstream configFile(filePath);
+  if (!configFile.is_open()) {
+    throw std::runtime_error(
+        fmt::format("Couldn't open config file {} for reading.", filePath));
+  }
+
+  std::unordered_map<std::string, std::string> properties;
+  std::string line;
+  while (getline(configFile, line)) {
+    line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());
+    if (line[0] == '#' || line.empty()) {
+      continue;
+    }
+    auto delimiterPos = line.find('=');
+    auto name = line.substr(0, delimiterPos);
+    auto value = line.substr(delimiterPos + 1);
+    properties.emplace(name, value);
+  }
+
+  return std::make_shared<config::ConfigBase>(std::move(properties));
+}
+
+// Initialize a LocalReadFile instance for the specified 'path'.
+void ReadBenchmark::initialize() {
+  executor_ = std::make_unique<folly::IOThreadPoolExecutor>(FLAGS_num_threads);
+  if (FLAGS_odirect) {
+    int32_t o_direct =
+#ifdef linux
+        O_DIRECT;
+#else
+        0;
+#endif
+    fd_ = open(
+        FLAGS_path.c_str(),
+        O_CREAT | O_RDWR | (FLAGS_odirect ? o_direct : 0),
+        S_IRUSR | S_IWUSR);
+    if (fd_ < 0) {
+      LOG(ERROR) << "Could not open " << FLAGS_path;
+      exit(1);
+    }
+    readFile_ = std::make_unique<LocalReadFile>(fd_);
+  } else {
+    filesystems::registerLocalFileSystem();
+    filesystems::registerS3FileSystem();
+    filesystems::registerGCSFileSystem();
+    filesystems::registerHdfsFileSystem();
+    filesystems::abfs::registerAbfsFileSystem();
+    std::shared_ptr<config::ConfigBase> config;
+    if (!FLAGS_config.empty()) {
+      config = readConfig(FLAGS_config);
+    }
+    auto fs = filesystems::getFileSystem(FLAGS_path, config);
+    readFile_ = fs->openFileForRead(FLAGS_path);
+    fileSize_ = readFile_->size();
+    if (FLAGS_file_size_gb) {
+      fileSize_ = std::min<uint64_t>(FLAGS_file_size_gb << 30, fileSize_);
+    }
+  }
+
+  if (fileSize_ <= FLAGS_measurement_size) {
+    LOG(ERROR) << "File size " << fileSize_ << " is <= then --measurement_size "
+               << FLAGS_measurement_size;
+    exit(1);
+  }
+  if (FLAGS_seed) {
+    rng_.seed(FLAGS_seed);
+  }
+}
+
+void ReadBenchmark::finalize() {
+  filesystems::finalizeS3FileSystem();
+}
+
+void ReadBenchmark::run() {
+  if (FLAGS_bytes) {
+    modes(FLAGS_bytes, FLAGS_gap, FLAGS_num_in_run);
+    return;
+  }
+  modes(1100, 0, 10);
+  modes(1100, 1200, 10);
+  modes(16 * 1024, 0, 10);
+  modes(16 * 1024, 10000, 10);
+  modes(1000000, 0, 8);
+  modes(1000000, 100000, 8);
+}
+} // namespace facebook::velox
diff --git a/velox/common/file/benchmark/ReadBenchmark.h b/velox/benchmarks/filesystem/ReadBenchmark.h
similarity index 88%
rename from velox/common/file/benchmark/ReadBenchmark.h
rename to velox/benchmarks/filesystem/ReadBenchmark.h
index 5a59e09e3cb0f..e033bc953acac 100644
--- a/velox/common/file/benchmark/ReadBenchmark.h
+++ b/velox/benchmarks/filesystem/ReadBenchmark.h
@@ -43,6 +43,7 @@ DECLARE_int32(gap);
 DECLARE_int32(num_in_run);
 
 DECLARE_int32(measurement_size);
+DECLARE_string(config);
 
 namespace facebook::velox {
 
@@ -62,46 +63,9 @@ class ReadBenchmark {
  public:
   virtual ~ReadBenchmark() = default;
 
-  // Initialize a LocalReadFile instance for the specified 'path'.
-  virtual void initialize() {
-    executor_ =
-        std::make_unique<folly::IOThreadPoolExecutor>(FLAGS_num_threads);
-    if (FLAGS_odirect) {
-      int32_t o_direct =
-#ifdef linux
-          O_DIRECT;
-#else
-          0;
-#endif
-      fd_ = open(
-          FLAGS_path.c_str(),
-          O_CREAT | O_RDWR | (FLAGS_odirect ? o_direct : 0),
-          S_IRUSR | S_IWUSR);
-      if (fd_ < 0) {
-        LOG(ERROR) << "Could not open " << FLAGS_path;
-        exit(1);
-      }
-      readFile_ = std::make_unique<LocalReadFile>(fd_);
+  virtual void initialize();
 
-    } else {
-      filesystems::registerLocalFileSystem();
-      auto lfs = filesystems::getFileSystem(FLAGS_path, nullptr);
-      readFile_ = lfs->openFileForRead(FLAGS_path);
-    }
-    fileSize_ = readFile_->size();
-    if (FLAGS_file_size_gb) {
-      fileSize_ = std::min<uint64_t>(FLAGS_file_size_gb << 30, fileSize_);
-    }
-
-    if (fileSize_ <= FLAGS_measurement_size) {
-      LOG(ERROR) << "File size " << fileSize_
-                 << " is <= then --measurement_size " << FLAGS_measurement_size;
-      exit(1);
-    }
-    if (FLAGS_seed) {
-      rng_.seed(FLAGS_seed);
-    }
-  }
+  virtual void finalize();
 
   void clearCache() {
 #ifdef linux
diff --git a/velox/common/file/benchmark/ReadBenchmarkMain.cpp b/velox/benchmarks/filesystem/ReadBenchmarkMain.cpp
similarity index 90%
rename from velox/common/file/benchmark/ReadBenchmarkMain.cpp
rename to velox/benchmarks/filesystem/ReadBenchmarkMain.cpp
index 848321c92de17..0556ff3a6d1f2 100644
--- a/velox/common/file/benchmark/ReadBenchmarkMain.cpp
+++ b/velox/benchmarks/filesystem/ReadBenchmarkMain.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/common/file/benchmark/ReadBenchmark.h"
+#include "velox/benchmarks/filesystem/ReadBenchmark.h"
 
 using namespace facebook::velox;
 
@@ -24,8 +24,9 @@ using namespace facebook::velox;
 // and the IO throughput is 100 MBps, then it takes 10 seconds to just read the
 // data.
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   ReadBenchmark bm;
   bm.initialize();
   bm.run();
+  bm.finalize();
 }
diff --git a/velox/benchmarks/tpch/CMakeLists.txt b/velox/benchmarks/tpch/CMakeLists.txt
index ef0147ad5c93c..3cbe9a0a6a6ba 100644
--- a/velox/benchmarks/tpch/CMakeLists.txt
+++ b/velox/benchmarks/tpch/CMakeLists.txt
@@ -16,6 +16,7 @@ add_library(velox_tpch_benchmark_lib TpchBenchmark.cpp)
 
 target_link_libraries(
   velox_tpch_benchmark_lib
+  velox_query_benchmark
   velox_aggregates
   velox_exec
   velox_exec_test_lib
@@ -33,10 +34,11 @@ target_link_libraries(
   velox_type_fbhive
   velox_caching
   velox_vector_test_lib
-  Folly::folly
   ${FOLLY_BENCHMARK}
+  Folly::folly
   fmt::fmt)
 
 add_executable(velox_tpch_benchmark TpchBenchmarkMain.cpp)
 
-target_link_libraries(velox_tpch_benchmark velox_tpch_benchmark_lib)
+target_link_libraries(
+  velox_tpch_benchmark velox_tpch_benchmark_lib)
diff --git a/velox/benchmarks/tpch/TpchBenchmark.cpp b/velox/benchmarks/tpch/TpchBenchmark.cpp
index 9ce35e2ec334f..25d02224fc58d 100644
--- a/velox/benchmarks/tpch/TpchBenchmark.cpp
+++ b/velox/benchmarks/tpch/TpchBenchmark.cpp
@@ -14,75 +14,13 @@
  * limitations under the License.
  */
 
-#include <fcntl.h>
-#include <sys/resource.h>
-#include <sys/time.h>
-
-#include <folly/Benchmark.h>
-#include <folly/init/Init.h>
-#include <gflags/gflags.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <fstream>
-
-#include "velox/common/base/SuccinctPrinter.h"
-#include "velox/common/file/FileSystems.h"
-#include "velox/common/memory/MmapAllocator.h"
-#include "velox/connectors/hive/HiveConfig.h"
-#include "velox/connectors/hive/HiveConnector.h"
-#include "velox/dwio/common/Options.h"
-#include "velox/exec/PlanNodeStats.h"
-#include "velox/exec/Split.h"
-#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
-#include "velox/exec/tests/utils/TpchQueryBuilder.h"
-#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/TypeResolver.h"
+#include "velox/benchmarks/QueryBenchmarkBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::dwio::common;
 
-namespace {
-static bool notEmpty(const char* /*flagName*/, const std::string& value) {
-  return !value.empty();
-}
-
-static bool validateDataFormat(const char* flagname, const std::string& value) {
-  if ((value.compare("parquet") == 0) || (value.compare("dwrf") == 0)) {
-    return true;
-  }
-  std::cout
-      << fmt::format(
-             "Invalid value for --{}: {}. Allowed values are [\"parquet\", \"dwrf\"]",
-             flagname,
-             value)
-      << std::endl;
-  return false;
-}
-
-void ensureTaskCompletion(exec::Task* task) {
-  // ASSERT_TRUE requires a function with return type void.
-  ASSERT_TRUE(waitForTaskCompletion(task));
-}
-
-void printResults(const std::vector<RowVectorPtr>& results, std::ostream& out) {
-  out << "Results:" << std::endl;
-  bool printType = true;
-  for (const auto& vector : results) {
-    // Print RowType only once.
-    if (printType) {
-      out << vector->type()->asRow().toString() << std::endl;
-      printType = false;
-    }
-    for (vector_size_t i = 0; i < vector->size(); ++i) {
-      out << vector->toString(i) << std::endl;
-    }
-  }
-}
-} // namespace
-
 DEFINE_string(
     data_path,
     "",
@@ -100,6 +38,13 @@ DEFINE_string(
     "each table. If they are files, they contain a file system path for each "
     "data file, one per line. This allows running against cloud storage or "
     "HDFS");
+namespace {
+static bool notEmpty(const char* /*flagName*/, const std::string& value) {
+  return !value.empty();
+}
+} // namespace
+
+DEFINE_validator(data_path, &notEmpty);
 
 DEFINE_int32(
     run_query_verbose,
@@ -112,207 +57,11 @@ DEFINE_int32(
     "include in IO meter query. The columns are sorted by name and the n% first "
     "are scanned");
 
-DEFINE_bool(
-    include_custom_stats,
-    false,
-    "Include custom statistics along with execution statistics");
-DEFINE_bool(include_results, false, "Include results in the output");
-DEFINE_int32(num_drivers, 4, "Number of drivers");
-DEFINE_string(data_format, "parquet", "Data format");
-DEFINE_int32(num_splits_per_file, 10, "Number of splits per file");
-DEFINE_int32(
-    cache_gb,
-    0,
-    "GB of process memory for cache and query.. if "
-    "non-0, uses mmap to allocator and in-process data cache.");
-DEFINE_int32(num_repeats, 1, "Number of times to run each query");
-DEFINE_int32(num_io_threads, 8, "Threads for speculative IO");
-DEFINE_string(
-    test_flags_file,
-    "",
-    "Path to a file containing gflafs and "
-    "values to try. Produces results for each flag combination "
-    "sorted on performance");
-DEFINE_bool(
-    full_sorted_stats,
-    true,
-    "Add full stats to the report on  --test_flags_file");
-
-DEFINE_string(ssd_path, "", "Directory for local SSD cache");
-DEFINE_int32(ssd_cache_gb, 0, "Size of local SSD cache in GB");
-DEFINE_int32(
-    ssd_checkpoint_interval_gb,
-    8,
-    "Checkpoint every n "
-    "GB new data in cache");
-DEFINE_bool(
-    clear_ram_cache,
-    false,
-    "Clear RAM cache before each query."
-    "Flushes in process and OS file system cache (if root on Linux)");
-DEFINE_bool(
-    clear_ssd_cache,
-    false,
-    "Clears SSD cache before "
-    "each query");
-
-DEFINE_bool(
-    warmup_after_clear,
-    false,
-    "Runs one warmup of the query before "
-    "measured run. Use to run warm after clearing caches.");
-
-DEFINE_validator(data_path, &notEmpty);
-DEFINE_validator(data_format, &validateDataFormat);
-
-DEFINE_int64(
-    max_coalesced_bytes,
-    128 << 20,
-    "Maximum size of single coalesced IO");
-
-DEFINE_int32(
-    max_coalesced_distance_bytes,
-    512 << 10,
-    "Maximum distance in bytes in which coalesce will combine requests");
-
-DEFINE_int32(
-    parquet_prefetch_rowgroups,
-    1,
-    "Number of next row groups to "
-    "prefetch. 1 means prefetch the next row group before decoding "
-    "the current one");
-
-struct RunStats {
-  std::map<std::string, std::string> flags;
-  int64_t micros{0};
-  int64_t rawInputBytes{0};
-  int64_t userNanos{0};
-  int64_t systemNanos{0};
-  std::string output;
-
-  std::string toString(bool detail) {
-    std::stringstream out;
-    out << succinctNanos(micros * 1000) << " "
-        << succinctBytes(rawInputBytes / (micros / 1000000.0)) << "/s raw, "
-        << succinctNanos(userNanos) << " user " << succinctNanos(systemNanos)
-        << " system (" << (100 * (userNanos + systemNanos) / (micros * 1000))
-        << "%), flags: ";
-    for (auto& pair : flags) {
-      out << pair.first << "=" << pair.second << " ";
-    }
-    out << std::endl << "======" << std::endl;
-    if (detail) {
-      out << std::endl << output << std::endl;
-    }
-    return out.str();
-  }
-};
-
-struct ParameterDim {
-  std::string flag;
-  std::vector<std::string> values;
-};
-
 std::shared_ptr<TpchQueryBuilder> queryBuilder;
 
-class TpchBenchmark {
+class TpchBenchmark : public QueryBenchmarkBase {
  public:
-  void initialize() {
-    if (FLAGS_cache_gb) {
-      int64_t memoryBytes = FLAGS_cache_gb * (1LL << 30);
-      memory::MmapAllocator::Options options;
-      options.capacity = memoryBytes;
-      options.useMmapArena = true;
-      options.mmapArenaCapacityRatio = 1;
-      std::unique_ptr<cache::SsdCache> ssdCache;
-      if (FLAGS_ssd_cache_gb) {
-        constexpr int32_t kNumSsdShards = 16;
-        cacheExecutor_ =
-            std::make_unique<folly::IOThreadPoolExecutor>(kNumSsdShards);
-        ssdCache = std::make_unique<cache::SsdCache>(
-            FLAGS_ssd_path,
-            static_cast<uint64_t>(FLAGS_ssd_cache_gb) << 30,
-            kNumSsdShards,
-            cacheExecutor_.get(),
-            static_cast<uint64_t>(FLAGS_ssd_checkpoint_interval_gb) << 30);
-      }
-
-      allocator_ = std::make_shared<memory::MmapAllocator>(options);
-      cache_ =
-          cache::AsyncDataCache::create(allocator_.get(), std::move(ssdCache));
-      cache::AsyncDataCache::setInstance(cache_.get());
-      memory::MemoryAllocator::setDefaultInstance(allocator_.get());
-    }
-    functions::prestosql::registerAllScalarFunctions();
-    aggregate::prestosql::registerAllAggregateFunctions();
-    parse::registerTypeResolver();
-    filesystems::registerLocalFileSystem();
-
-    ioExecutor_ =
-        std::make_unique<folly::IOThreadPoolExecutor>(FLAGS_num_io_threads);
-
-    // Add new values into the hive configuration...
-    auto configurationValues = std::unordered_map<std::string, std::string>();
-    configurationValues[connector::hive::HiveConfig::kMaxCoalescedBytes] =
-        std::to_string(FLAGS_max_coalesced_bytes);
-    configurationValues
-        [connector::hive::HiveConfig::kMaxCoalescedDistanceBytes] =
-            std::to_string(FLAGS_max_coalesced_distance_bytes);
-    auto properties =
-        std::make_shared<const core::MemConfig>(configurationValues);
-
-    // Create hive connector with config...
-    auto hiveConnector =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(kHiveConnectorId, properties, ioExecutor_.get());
-    connector::registerConnector(hiveConnector);
-  }
-
-  void shutdown() {
-    cache_->shutdown();
-  }
-
-  std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>> run(
-      const TpchPlan& tpchPlan) {
-    int32_t repeat = 0;
-    try {
-      for (;;) {
-        CursorParameters params;
-        params.maxDrivers = FLAGS_num_drivers;
-        params.planNode = tpchPlan.plan;
-        const int numSplitsPerFile = FLAGS_num_splits_per_file;
-
-        bool noMoreSplits = false;
-        auto addSplits = [&](exec::Task* task) {
-          if (!noMoreSplits) {
-            for (const auto& entry : tpchPlan.dataFiles) {
-              for (const auto& path : entry.second) {
-                auto const splits =
-                    HiveConnectorTestBase::makeHiveConnectorSplits(
-                        path, numSplitsPerFile, tpchPlan.dataFileFormat);
-                for (const auto& split : splits) {
-                  task->addSplit(entry.first, exec::Split(split));
-                }
-              }
-              task->noMoreSplits(entry.first);
-            }
-          }
-          noMoreSplits = true;
-        };
-        auto result = readCursor(params, addSplits);
-        ensureTaskCompletion(result.first->task().get());
-        if (++repeat >= FLAGS_num_repeats) {
-          return result;
-        }
-      }
-    } catch (const std::exception& e) {
-      LOG(ERROR) << "Query terminated with: " << e.what();
-      return {nullptr, std::vector<RowVectorPtr>()};
-    }
-  }
-
-  void runMain(std::ostream& out, RunStats& runStats) {
+  void runMain(std::ostream& out, RunStats& runStats) override {
     if (FLAGS_run_query_verbose == -1 && FLAGS_io_meter_column_pct == 0) {
       folly::runBenchmarks();
     } else {
@@ -354,130 +103,6 @@ class TpchBenchmark {
           << std::endl;
     }
   }
-
-  void readCombinations() {
-    std::ifstream file(FLAGS_test_flags_file);
-    std::string line;
-    while (std::getline(file, line)) {
-      ParameterDim dim;
-      int32_t previous = 0;
-      for (auto i = 0; i < line.size(); ++i) {
-        if (line[i] == ':') {
-          dim.flag = line.substr(0, i);
-          previous = i + 1;
-        } else if (line[i] == ',') {
-          dim.values.push_back(line.substr(previous, i - previous));
-          previous = i + 1;
-        }
-      }
-      if (previous < line.size()) {
-        dim.values.push_back(line.substr(previous, line.size() - previous));
-      }
-
-      parameters_.push_back(dim);
-    }
-  }
-
-  void runCombinations(int32_t level) {
-    if (level == parameters_.size()) {
-      if (FLAGS_clear_ram_cache) {
-#ifdef linux
-        // system("echo 3 >/proc/sys/vm/drop_caches");
-        bool success = false;
-        auto fd = open("/proc//sys/vm/drop_caches", O_WRONLY);
-        if (fd > 0) {
-          success = write(fd, "3", 1) == 1;
-          close(fd);
-        }
-        if (!success) {
-          LOG(ERROR) << "Failed to clear OS disk cache: errno=" << errno;
-        }
-#endif
-
-        if (cache_) {
-          cache_->clear();
-        }
-      }
-      if (FLAGS_clear_ssd_cache) {
-        if (cache_) {
-          auto ssdCache = cache_->ssdCache();
-          if (ssdCache) {
-            ssdCache->clear();
-          }
-        }
-      }
-      if (FLAGS_warmup_after_clear) {
-        std::stringstream result;
-        RunStats ignore;
-        runMain(result, ignore);
-      }
-      RunStats stats;
-      std::stringstream result;
-      uint64_t micros = 0;
-      {
-        struct rusage start;
-        getrusage(RUSAGE_SELF, &start);
-        MicrosecondTimer timer(&micros);
-        runMain(result, stats);
-        struct rusage final;
-        getrusage(RUSAGE_SELF, &final);
-        auto tvNanos = [](struct timeval tv) {
-          return tv.tv_sec * 1000000000 + tv.tv_usec * 1000;
-        };
-        stats.userNanos = tvNanos(final.ru_utime) - tvNanos(start.ru_utime);
-        stats.systemNanos = tvNanos(final.ru_stime) - tvNanos(start.ru_stime);
-      }
-      stats.micros = micros;
-      stats.output = result.str();
-      for (auto i = 0; i < parameters_.size(); ++i) {
-        std::string name;
-        gflags::GetCommandLineOption(parameters_[i].flag.c_str(), &name);
-        stats.flags[parameters_[i].flag] = name;
-      }
-      runStats_.push_back(std::move(stats));
-    } else {
-      auto& flag = parameters_[level].flag;
-      for (auto& value : parameters_[level].values) {
-        std::string result =
-            gflags::SetCommandLineOption(flag.c_str(), value.c_str());
-        if (result.empty()) {
-          LOG(ERROR) << "Failed to set " << flag << "=" << value;
-        }
-        std::cout << result << std::endl;
-        runCombinations(level + 1);
-      }
-    }
-  }
-
-  void runAllCombinations() {
-    readCombinations();
-    runCombinations(0);
-    std::sort(
-        runStats_.begin(),
-        runStats_.end(),
-        [](const RunStats& left, const RunStats& right) {
-          return left.micros < right.micros;
-        });
-    for (auto& stats : runStats_) {
-      std::cout << stats.toString(false);
-    }
-    if (FLAGS_full_sorted_stats) {
-      std::cout << "Detail for stats:" << std::endl;
-      for (auto& stats : runStats_) {
-        std::cout << stats.toString(true);
-      }
-    }
-  }
-
-  std::unique_ptr<folly::IOThreadPoolExecutor> ioExecutor_;
-  std::unique_ptr<folly::IOThreadPoolExecutor> cacheExecutor_;
-  std::shared_ptr<memory::MemoryAllocator> allocator_;
-  std::shared_ptr<cache::AsyncDataCache> cache_;
-  // Parameter combinations to try. Each element specifies a flag and possible
-  // values. All permutations are tried.
-  std::vector<ParameterDim> parameters_;
-
-  std::vector<RunStats> runStats_;
 };
 
 TpchBenchmark benchmark;
@@ -487,11 +112,21 @@ BENCHMARK(q1) {
   benchmark.run(planContext);
 }
 
+BENCHMARK(q2) {
+  const auto planContext = queryBuilder->getQueryPlan(2);
+  benchmark.run(planContext);
+}
+
 BENCHMARK(q3) {
   const auto planContext = queryBuilder->getQueryPlan(3);
   benchmark.run(planContext);
 }
 
+BENCHMARK(q4) {
+  const auto planContext = queryBuilder->getQueryPlan(4);
+  benchmark.run(planContext);
+}
+
 BENCHMARK(q5) {
   const auto planContext = queryBuilder->getQueryPlan(5);
   benchmark.run(planContext);
@@ -522,6 +157,11 @@ BENCHMARK(q10) {
   benchmark.run(planContext);
 }
 
+BENCHMARK(q11) {
+  const auto planContext = queryBuilder->getQueryPlan(11);
+  benchmark.run(planContext);
+}
+
 BENCHMARK(q12) {
   const auto planContext = queryBuilder->getQueryPlan(12);
   benchmark.run(planContext);
diff --git a/velox/benchmarks/tpch/TpchBenchmarkMain.cpp b/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
index acd59b3878fc8..4477455d8f3c6 100644
--- a/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
+++ b/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
@@ -23,6 +23,6 @@ int main(int argc, char** argv) {
   std::string kUsage(
       "This program benchmarks TPC-H queries. Run 'velox_tpch_benchmark -helpon=TpchBenchmark' for available options.\n");
   gflags::SetUsageMessage(kUsage);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   tpchBenchmarkMain();
 }
diff --git a/velox/benchmarks/unstable/CMakeLists.txt b/velox/benchmarks/unstable/CMakeLists.txt
index fc192487f8f19..e3d264786d151 100644
--- a/velox/benchmarks/unstable/CMakeLists.txt
+++ b/velox/benchmarks/unstable/CMakeLists.txt
@@ -27,5 +27,5 @@ set(velox_benchmark_deps
     glog::glog)
 
 add_executable(velox_memory_alloc_benchmark MemoryAllocationBenchmark.cpp)
-target_link_libraries(velox_memory_alloc_benchmark ${velox_benchmark_deps}
-                      velox_memory pthread)
+target_link_libraries(
+  velox_memory_alloc_benchmark ${velox_benchmark_deps} velox_memory pthread)
diff --git a/velox/benchmarks/unstable/MemoryAllocationBenchmark.cpp b/velox/benchmarks/unstable/MemoryAllocationBenchmark.cpp
index d267274ce56f0..6038c358dfb0d 100644
--- a/velox/benchmarks/unstable/MemoryAllocationBenchmark.cpp
+++ b/velox/benchmarks/unstable/MemoryAllocationBenchmark.cpp
@@ -435,7 +435,7 @@ BENCHMARK_RELATIVE_MULTI(MmapReallocateMix64) {
 } // namespace
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   // TODO: add to run benchmark as a standalone program with multithreading as
   // well as actual memory access to trigger minor page faults in OS which traps
   // into kernel context to setup physical pages for the lazy-mapped virtual
diff --git a/velox/buffer/Buffer.h b/velox/buffer/Buffer.h
index cecf03359c6a5..b7aad5d075306 100644
--- a/velox/buffer/Buffer.h
+++ b/velox/buffer/Buffer.h
@@ -56,9 +56,9 @@ class Buffer {
   // and trivially copyable (so memcpy works)
   template <typename T>
   static inline constexpr bool is_pod_like_v =
-      std::is_trivially_destructible_v<T>&& std::is_trivially_copyable_v<T>;
+      std::is_trivially_destructible_v<T> && std::is_trivially_copyable_v<T>;
 
-  virtual ~Buffer(){};
+  virtual ~Buffer() {}
 
   void addRef() {
     referenceCount_.fetch_add(1);
@@ -381,34 +381,19 @@ class AlignedBuffer : public Buffer {
     auto oldCapacity = checkedPlus<size_t>(old->capacity(), kPaddedSize);
     auto preferredSize =
         pool->preferredSize(checkedPlus<size_t>(size, kPaddedSize));
-    // Make the buffer no longer owned by '*buffer' because reallocate
-    // may free the old buffer. Reassigning the new buffer to
-    // '*buffer' would be a double free.
+
+    void* newPtr = pool->reallocate(old, oldCapacity, preferredSize);
+
+    // Make the old buffer no longer owned by '*buffer' because reallocate
+    // freed the old buffer. Reassigning the new buffer to
+    // '*buffer' would be a double free if we didn't do this.
     buffer->detach();
-    // Decrement the reference count.  No need to check, we just
-    // checked old->unique().
-    old->referenceCount_.fetch_sub(1);
-    void* newPtr;
-    try {
-      newPtr = pool->reallocate(old, oldCapacity, preferredSize);
-    } catch (const std::exception&) {
-      *buffer = old;
-      throw;
-    }
-    if (newPtr == reinterpret_cast<void*>(old)) {
-      // The pointer did not change. Put the old pointer back in the
-      // smart pointer and adjust capacity.
-      *buffer = old;
-      (*buffer)->setCapacity(preferredSize - kPaddedSize);
-      (*buffer)->setSize(size);
-      reinterpret_cast<AlignedBuffer*>(buffer->get())
-          ->fillNewMemory<T>(oldSize, size, initValue);
-      return;
-    }
+
     auto newBuffer =
         new (newPtr) AlignedBuffer(pool, preferredSize - kPaddedSize);
     newBuffer->setSize(size);
     newBuffer->fillNewMemory<T>(oldSize, size, initValue);
+
     *buffer = newBuffer;
   }
 
diff --git a/velox/buffer/CMakeLists.txt b/velox/buffer/CMakeLists.txt
index 8a6df1c1e87ee..2b1e8ea65a78b 100644
--- a/velox/buffer/CMakeLists.txt
+++ b/velox/buffer/CMakeLists.txt
@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_buffer StringViewBufferHolder.cpp)
+velox_add_library(velox_buffer StringViewBufferHolder.cpp)
 
-target_link_libraries(velox_buffer velox_memory velox_common_base Folly::folly)
+velox_link_libraries(velox_buffer velox_memory velox_common_base Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/buffer/tests/BufferTest.cpp b/velox/buffer/tests/BufferTest.cpp
index 90ce32f93170b..2f6107f551ed1 100644
--- a/velox/buffer/tests/BufferTest.cpp
+++ b/velox/buffer/tests/BufferTest.cpp
@@ -17,6 +17,8 @@
 #include "velox/buffer/Buffer.h"
 
 #include "folly/Range.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/type/StringView.h"
 
 #include <glog/logging.h>
@@ -67,7 +69,7 @@ TEST_F(BufferTest, testAlignedBuffer) {
         testString,
         testStringLength);
     other = buffer;
-    EXPECT_EQ(pool_->currentBytes(), pool_->preferredSize(sizeWithHeader));
+    EXPECT_EQ(pool_->usedBytes(), pool_->preferredSize(sizeWithHeader));
 
     AlignedBuffer::reallocate<char>(&other, size * 3, 'e');
     EXPECT_NE(other, buffer);
@@ -83,18 +85,17 @@ TEST_F(BufferTest, testAlignedBuffer) {
         0);
     EXPECT_EQ(other->as<char>()[buffer->capacity()], 'e');
     EXPECT_EQ(
-        pool_->currentBytes(),
+        pool_->usedBytes(),
         pool_->preferredSize(sizeWithHeader) +
             pool_->preferredSize(3 * size + kHeaderSize));
   }
-  EXPECT_EQ(
-      pool_->currentBytes(), pool_->preferredSize(3 * size + kHeaderSize));
+  EXPECT_EQ(pool_->usedBytes(), pool_->preferredSize(3 * size + kHeaderSize));
   other = nullptr;
   BufferPtr bits = AlignedBuffer::allocate<bool>(65, pool_.get(), true);
   EXPECT_EQ(bits->size(), 9);
   EXPECT_EQ(bits->as<uint8_t>()[8], 0xff);
   bits = nullptr;
-  EXPECT_EQ(pool_->currentBytes(), 0);
+  EXPECT_EQ(pool_->usedBytes(), 0);
 }
 
 TEST_F(BufferTest, testAsRange) {
@@ -177,11 +178,122 @@ TEST_F(BufferTest, testReallocate) {
     }
   }
   buffers.clear();
-  EXPECT_EQ(pool_->currentBytes(), 0);
+  EXPECT_EQ(pool_->usedBytes(), 0);
   EXPECT_GT(numInPlace, 0);
   EXPECT_GT(numMoved, 0);
 }
 
+TEST_F(BufferTest, testReallocateNoReuse) {
+  // This test checks that regardless of how we resize a Buffer in reallocate
+  // (up, down, the same) as long as we hit MemoryPool::reallocate,  the Buffer
+  // always points to a new location in memory. If this test fails, it's not
+  // necessarily a problem, but it's worth looking at optimizations we could do
+  // in reallocate when the pointer doesn't change.
+
+  enum BufferResizeOption {
+    BIGGER,
+    SMALLER,
+    SAME,
+  };
+
+  auto test = [&](BufferResizeOption bufferResizeOption,
+                  bool useMmapAllocator) {
+    memory::MemoryManagerOptions options;
+    options.useMmapAllocator = useMmapAllocator;
+    options.allocatorCapacity = 1024 * 1024;
+    memory::MemoryManager memoryManager(options);
+
+    auto pool = memoryManager.addLeafPool("testReallocateNoReuse");
+
+    const size_t originalBufferSize = 10;
+    auto buffer = AlignedBuffer::allocate<char>(originalBufferSize, pool.get());
+    auto* originalBufferPtr = buffer.get();
+
+    size_t newSize;
+    switch (bufferResizeOption) {
+      case SMALLER:
+        newSize = originalBufferSize - 1;
+        break;
+      case SAME:
+        newSize = originalBufferSize;
+        break;
+      case BIGGER:
+        // Make sure the new size is large enough that we hit
+        // MemoryPoolImpl::reallocate.
+        newSize = buffer->capacity() + 1;
+        break;
+      default:
+        VELOX_FAIL("Unexpected buffer resize option");
+    }
+
+    AlignedBuffer::reallocate<char>(&buffer, newSize);
+
+    EXPECT_NE(buffer.get(), originalBufferPtr);
+  };
+
+  test(SMALLER, true);
+  test(SAME, true);
+  test(BIGGER, true);
+
+  test(SMALLER, false);
+  test(SAME, false);
+  test(BIGGER, false);
+}
+
+DEBUG_ONLY_TEST_F(BufferTest, testReallocateFails) {
+  // Reallocating a buffer can cause an exception to be thrown e.g. if we
+  // run out of memory.  If the buffer is left in an invalid state this can
+  // cause crahses, e.g. if VectorSaver attempts to write out a Vector that
+  // was in the midst of resizing.  This test verifies the buffer is valid at
+  // different points in the exception's lifecycle.
+
+  const size_t bufferSize = 10;
+  auto buffer = AlignedBuffer::allocate<char>(bufferSize, pool_.get());
+
+  ::memset(buffer->asMutable<char>(), 'a', bufferSize);
+
+  common::testutil::TestValue::enable();
+
+  const std::string kErrorMessage = "Expected out of memory exception";
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe",
+      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool*) {
+        VELOX_MEM_POOL_CAP_EXCEEDED(kErrorMessage);
+      }));
+
+  {
+    ExceptionContextSetter setter(
+        {.messageFunc = [](VeloxException::Type,
+                           void* untypedArg) -> std::string {
+           // Validate that the buffer is still valid at the point
+           // the exception is thrown.
+           auto bufferArg = *static_cast<BufferPtr*>(untypedArg);
+
+           const auto* bufferContents = bufferArg->as<char>();
+           VELOX_CHECK_EQ(bufferArg->size(), 10);
+           for (int i = 0; i < 10; i++) {
+             VELOX_CHECK_EQ(bufferContents[i], 'a');
+           }
+
+           return "Exception context message func called.";
+         },
+         .arg = &buffer});
+
+    VELOX_ASSERT_THROW_CODE(
+        AlignedBuffer::reallocate<char>(
+            &buffer, pool_->availableReservation() + 1),
+        error_code::kMemCapExceeded,
+        kErrorMessage);
+  }
+
+  // Validate the buffer is valid after the exception is caught.
+  const auto* bufferContents = buffer->as<char>();
+  VELOX_CHECK_EQ(buffer->size(), bufferSize);
+  for (int i = 0; i < bufferSize; i++) {
+    VELOX_CHECK_EQ(bufferContents[i], 'a');
+  }
+}
+
 struct MockCachePin {
   void addRef() {
     ++pinCount;
@@ -327,9 +439,9 @@ TEST_F(BufferTest, testNonPOD) {
 
 TEST_F(BufferTest, testNonPODMemoryUsage) {
   using T = std::shared_ptr<void>;
-  const int64_t currentBytes = pool_->currentBytes();
+  const int64_t currentBytes = pool_->usedBytes();
   { auto buffer = AlignedBuffer::allocate<T>(0, pool_.get()); }
-  EXPECT_EQ(pool_->currentBytes(), currentBytes);
+  EXPECT_EQ(pool_->usedBytes(), currentBytes);
 }
 
 TEST_F(BufferTest, testAllocateSizeOverflow) {
diff --git a/velox/buffer/tests/CMakeLists.txt b/velox/buffer/tests/CMakeLists.txt
index a6029241f9a17..097f5ee3bb3f4 100644
--- a/velox/buffer/tests/CMakeLists.txt
+++ b/velox/buffer/tests/CMakeLists.txt
@@ -20,9 +20,9 @@ target_link_libraries(
   velox_memory
   velox_buffer
   velox_test_util
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   glog::glog
   gflags::gflags
   pthread)
diff --git a/velox/buffer/tests/StringViewBufferHolderTest.cpp b/velox/buffer/tests/StringViewBufferHolderTest.cpp
index e67cae3af6f1e..eae13a75cc849 100644
--- a/velox/buffer/tests/StringViewBufferHolderTest.cpp
+++ b/velox/buffer/tests/StringViewBufferHolderTest.cpp
@@ -35,11 +35,16 @@ std::string inlinedString() {
 
 class StringViewBufferHolderTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::initialize({});
+  }
+
   StringViewBufferHolder makeHolder() {
     return StringViewBufferHolder(pool_.get());
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 TEST_F(StringViewBufferHolderTest, inlinedStringViewDoesNotCopyToBuffer) {
diff --git a/velox/codegen/CMakeLists.txt b/velox/codegen/CMakeLists.txt
deleted file mode 100644
index e54a0d133c07d..0000000000000
--- a/velox/codegen/CMakeLists.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_codegen Codegen.cpp)
-if(${VELOX_CODEGEN_SUPPORT})
-  target_link_libraries(velox_codegen velox_experimental_codegen)
-else()
-  target_link_libraries(velox_codegen velox_core velox_exec velox_expression
-                        glog::glog)
-endif()
diff --git a/velox/codegen/Codegen-Stubs.h b/velox/codegen/Codegen-Stubs.h
deleted file mode 100644
index 44f371dc573be..0000000000000
--- a/velox/codegen/Codegen-Stubs.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#if CODEGEN_ENABLED == 1
-#error "This files shouldn't be included when the codegen is enabled"
-#endif
-
-#include <glog/logging.h>
-#include <filesystem>
-#include "velox/core/PlanNode.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-/// Main interface/entry point with the code generation system.
-/// This is stub code used when the code generation is disabled.
-
-class Codegen {
- public:
-  Codegen() {}
-
-  bool initialize(
-      const std::string_view& codegenOptionsJson,
-      bool lazyLoading = true) {
-    LOG(INFO) << "Codegen disabled, doing nothing : " << std::endl;
-    return true;
-  }
-
-  bool initializeFromFile(
-      const std::filesystem::path& codegenOptionsJsonFile,
-      bool lazyLoading = true) {
-    LOG(INFO) << "Codegen disabled, doing nothing : " << std::endl;
-    return true;
-  };
-
-  std::shared_ptr<const core::PlanNode> compile(
-      const core::PlanNode& planNode) {
-    LOG(INFO) << "Codegen disabled, doing nothing" << std::endl;
-    return nullptr;
-  }
-};
-
-} // namespace codegen
-} // namespace velox
-}; // namespace facebook
diff --git a/velox/codegen/Codegen.cpp b/velox/codegen/Codegen.cpp
deleted file mode 100644
index 4f6fe911619a1..0000000000000
--- a/velox/codegen/Codegen.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/codegen/Codegen.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {}
-} // namespace velox
-} // namespace facebook
diff --git a/velox/codegen/Codegen.h b/velox/codegen/Codegen.h
deleted file mode 100644
index 692fcf85a0502..0000000000000
--- a/velox/codegen/Codegen.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#if CODEGEN_ENABLED == 1
-#include "velox/experimental/codegen/Codegen.h"
-#else
-#include "velox/codegen/Codegen-Stubs.h"
-#endif
diff --git a/velox/codegen/platform-support.h b/velox/codegen/platform-support.h
deleted file mode 100644
index 55243e89658a7..0000000000000
--- a/velox/codegen/platform-support.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-// Collection of preprocessor test
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-W#warnings"
-
-#ifndef __cpp_concepts
-#warning "Concept support is preferred"
-#else
-#define ENABLE_CONCEPT 1
-#endif
-
-#ifndef __cpp_lib_ranges
-#warning "Range support is preferred"
-#else
-#define USE_STD_RANGE 1
-#endif
-
-#pragma clang diagnostic pop
-
-#if __cplusplus < 201703L
-#error "C++17 is required"
-#endif
diff --git a/velox/common/base/AsyncSource.h b/velox/common/base/AsyncSource.h
index d650d4ebecca5..76740dd8681a6 100644
--- a/velox/common/base/AsyncSource.h
+++ b/velox/common/base/AsyncSource.h
@@ -21,10 +21,12 @@
 #include <folly/futures/Future.h>
 #include <functional>
 #include <memory>
+#include "velox/common/time/CpuWallTimer.h"
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Portability.h"
 #include "velox/common/future/VeloxPromise.h"
+#include "velox/common/process/ThreadDebugInfo.h"
 #include "velox/common/testutil/TestValue.h"
 
 namespace facebook::velox {
@@ -39,7 +41,24 @@ template <typename Item>
 class AsyncSource {
  public:
   explicit AsyncSource(std::function<std::unique_ptr<Item>()> make)
-      : make_(make) {}
+      : make_(std::move(make)) {
+    if (process::GetThreadDebugInfo() != nullptr) {
+      auto* currentThreadDebugInfo = process::GetThreadDebugInfo();
+      // We explicitly leave out the callback when copying the ThreadDebugInfo
+      // as that may have captured state that goes out of scope by the time
+      // _make is called.
+      threadDebugInfo_ = std::make_optional<process::ThreadDebugInfo>(
+          {currentThreadDebugInfo->queryId_,
+           currentThreadDebugInfo->taskId_,
+           nullptr});
+    }
+  }
+
+  ~AsyncSource() {
+    VELOX_CHECK(
+        moved_ || closed_,
+        "AsyncSource should be properly consumed or closed.");
+  }
 
   // Makes an item if it is not already made. To be called on a background
   // executor.
@@ -57,8 +76,9 @@ class AsyncSource {
     }
     std::unique_ptr<Item> item;
     try {
-      item = make();
-    } catch (std::exception& e) {
+      CpuWallTimer timer(timing_);
+      item = runMake(make);
+    } catch (std::exception&) {
       std::lock_guard<std::mutex> l(mutex_);
       exception_ = std::current_exception();
     }
@@ -77,9 +97,9 @@ class AsyncSource {
     }
   }
 
-  // Returns the item to the first caller and nullptr to subsequent callers. If
-  // the item is preparing on the executor, waits for the item and otherwise
-  // makes it on the caller thread.
+  // Returns the item to the first caller and nullptr to subsequent callers.
+  // If the item is preparing on the executor, waits for the item and
+  // otherwise makes it on the caller thread.
   std::unique_ptr<Item> move() {
     common::testutil::TestValue::adjust(
         "facebook::velox::AsyncSource::move", this);
@@ -87,6 +107,7 @@ class AsyncSource {
     ContinueFuture wait;
     {
       std::lock_guard<std::mutex> l(mutex_);
+      moved_ = true;
       // 'making_' can be read atomically, 'exception' maybe not. So test
       // 'making' so as not to read half-assigned 'exception_'.
       if (!making_ && exception_) {
@@ -112,8 +133,8 @@ class AsyncSource {
     // Outside of mutex_.
     if (make) {
       try {
-        return make();
-      } catch (const std::exception& e) {
+        return runMake(make);
+      } catch (const std::exception&) {
         std::lock_guard<std::mutex> l(mutex_);
         exception_ = std::current_exception();
         throw;
@@ -135,7 +156,57 @@ class AsyncSource {
     return item_ != nullptr || exception_ != nullptr;
   }
 
+  /// Returns the timing of prepare(). If the item was made on the calling
+  /// thread, the timing is 0 since only off-thread activity needs to be added
+  /// to the caller's timing.
+  const CpuWallTiming& prepareTiming() {
+    return timing_;
+  }
+
+  /// This function assists the caller in ensuring that resources allocated in
+  /// AsyncSource are promptly released:
+  /// 1. Waits for the completion of the 'make_' function if it is executing
+  /// in the thread pool.
+  /// 2. Resets the 'make_' function if it has not started yet.
+  /// 3. Cleans up the 'item_' if 'make_' has completed, but the result
+  /// 'item_' has not been returned to the caller.
+  void close() {
+    if (closed_ || moved_) {
+      return;
+    }
+    ContinueFuture wait;
+    {
+      std::lock_guard<std::mutex> l(mutex_);
+      if (making_) {
+        promise_ = std::make_unique<ContinuePromise>();
+        wait = promise_->getSemiFuture();
+      } else if (make_) {
+        make_ = nullptr;
+      }
+    }
+
+    auto& exec = folly::QueuedImmediateExecutor::instance();
+    std::move(wait).via(&exec).wait();
+    {
+      std::lock_guard<std::mutex> l(mutex_);
+      if (item_) {
+        item_ = nullptr;
+      }
+      closed_ = true;
+    }
+  }
+
  private:
+  std::unique_ptr<Item> runMake(std::function<std::unique_ptr<Item>()>& make) {
+    process::ScopedThreadDebugInfo threadDebugInfo(
+        threadDebugInfo_.has_value() ? &threadDebugInfo_.value() : nullptr);
+    return make();
+  }
+
+  // Stored context (if present upon construction) so they can be restored when
+  // make_ is invoked.
+  std::optional<process::ThreadDebugInfo> threadDebugInfo_;
+
   mutable std::mutex mutex_;
   // True if 'prepare() is making the item.
   bool making_{false};
@@ -143,5 +214,8 @@ class AsyncSource {
   std::unique_ptr<Item> item_;
   std::function<std::unique_ptr<Item>()> make_;
   std::exception_ptr exception_;
+  CpuWallTiming timing_;
+  bool closed_{false};
+  bool moved_{false};
 };
 } // namespace facebook::velox
diff --git a/velox/common/base/BitSet.h b/velox/common/base/BitSet.h
index baf2d9a6f2f05..bcdb6e0a38ba0 100644
--- a/velox/common/base/BitSet.h
+++ b/velox/common/base/BitSet.h
@@ -22,12 +22,12 @@
 #include "velox/common/base/BitUtil.h"
 
 namespace facebook::velox {
-// Dynamic size dense bit set that Keeps track of maximum set bit.
+/// Dynamic size dense bit set that keeps track of maximum set bit.
 class BitSet {
  public:
-  // Constructs a bitSet. 'min' is the lowest possible member of the
-  // set. Values below this are not present and inserting these is a
-  // no-op. 'min' is used when using this as an IN predicate filter.
+  /// Constructs a bitSet. 'min' is the lowest possible member of the set.
+  /// Values below this are not present and inserting these is a no-op. 'min' is
+  /// used when using this as an IN predicate filter.
   explicit BitSet(int64_t min) : min_(min) {}
 
   void insert(int64_t index) {
@@ -46,7 +46,7 @@ class BitSet {
     bits::setBit(bits_.data(), bit, true);
   }
 
-  bool contains(uint32_t index) {
+  bool contains(uint32_t index) const {
     uint64_t bit = index - min_;
     if (bit >= bits_.size() * 64) {
       // If index was < min_, bit will have wrapped around and will be >
@@ -56,7 +56,7 @@ class BitSet {
     return bits::isBitSet(bits_.data(), bit);
   }
 
-  // Returns the largest element of the set or 'min_ - 1' if empty.
+  /// Returns the largest element of the set or 'min_ - 1' if empty.
   int64_t max() const {
     return lastSetBit_ + min_;
   }
@@ -66,8 +66,8 @@ class BitSet {
   }
 
  private:
-  std::vector<uint64_t> bits_;
   const int64_t min_;
+  std::vector<uint64_t> bits_;
   int64_t lastSetBit_ = -1;
 };
 
diff --git a/velox/common/base/BitUtil.cpp b/velox/common/base/BitUtil.cpp
index cb964e405d4dd..686bce02b1a2e 100644
--- a/velox/common/base/BitUtil.cpp
+++ b/velox/common/base/BitUtil.cpp
@@ -16,8 +16,11 @@
 
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/SimdUtil.h"
 #include "velox/common/process/ProcessBase.h"
 
+#include <folly/BenchmarkUtil.h>
+
 namespace facebook::velox::bits {
 
 namespace {
@@ -30,12 +33,13 @@ void scatterBitsSimple(
     char* target) {
   int64_t from = numSource - 1;
   for (int64_t to = numTarget - 1; to >= 0; to--) {
-    bool maskIsSet = bits::isBitSet(targetMask, to);
+    const bool maskIsSet = bits::isBitSet(targetMask, to);
     bits::setBit(target, to, maskIsSet && bits::isBitSet(source, from));
     from -= maskIsSet ? 1 : 0;
   }
 }
 
+#ifdef __BMI2__
 // Fetches 'numBits' bits of data, from data starting at lastBit -
 // numbits (inclusive) and ending at lastBit (exclusive). 'lastBit' is
 // updated to be the bit offset of the lowest returned bit. Successive
@@ -55,6 +59,7 @@ uint64_t getBitField(const char* data, int32_t numBits, int32_t& lastBit) {
   lastBit -= numBits;
   return bits;
 }
+#endif
 
 // Copy bits backward while the remaining data is still larger than size of T.
 template <typename T>
@@ -117,6 +122,17 @@ void scatterBits(
   int32_t highBit = numTarget & 7;
   int lowByte = std::max(0, highByte - 7);
   auto maskAsBytes = reinterpret_cast<const char*>(targetMask);
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+  int32_t sourceOffset = std::min(0, (numSource / 8) - 7) + 1;
+  folly::doNotOptimizeAway(
+      *reinterpret_cast<const uint64_t*>(source + sourceOffset));
+  folly::doNotOptimizeAway(
+      *reinterpret_cast<const uint64_t*>(maskAsBytes + lowByte + 1));
+  folly::doNotOptimizeAway(*reinterpret_cast<uint64_t*>(target + lowByte + 1));
+#endif
+#endif
+
   // Loop from top to bottom of 'targetMask' up to 64 bits at a time,
   // with a partial word at either end. Count the set bits and fetch
   // as many consecutive bits of source data. Scatter the source bits
@@ -158,4 +174,49 @@ void scatterBits(
 #endif
 }
 
+uint64_t hashBytes(uint64_t seed, const char* data, size_t size) {
+  auto begin = reinterpret_cast<const uint8_t*>(data);
+  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
+  if (size < 8) {
+    auto word = loadPartialWord(begin, size);
+    uint64_t crc = simd::crc32U64(seed, word);
+    uint64_t crc2 = simd::crc32U64(seed, word >> 32);
+    return crc | (crc2 << 32);
+  }
+  uint64_t a0 = seed;
+  uint64_t a1 = seed << 32;
+  uint64_t a2 = seed >> 16;
+  int32_t toGo = size;
+  auto words = reinterpret_cast<const uint64_t*>(data);
+  while (toGo >= 24) {
+    a0 = simd::crc32U64(a0, words[0]);
+    a1 = simd::crc32U64(a1, words[1]);
+    a2 = simd::crc32U64(a2, words[2]);
+    words += 3;
+    toGo -= 24;
+  }
+  if (toGo > 16) {
+    a0 = simd::crc32U64(a0, words[0]);
+    a1 = simd::crc32U64(a1, words[1]);
+    a2 = simd::crc32U64(
+        a2,
+        loadPartialWord(
+            reinterpret_cast<const uint8_t*>(words + 2), toGo - 16));
+  } else if (toGo > 8) {
+    a0 = simd::crc32U64(a0, words[0]);
+    a1 = simd::crc32U64(
+        a1,
+        toGo == 16
+            ? words[1]
+            : loadPartialWord(
+                  reinterpret_cast<const uint8_t*>(words + 1), toGo - 8));
+  } else if (toGo > 0) {
+    a0 = simd::crc32U64(
+        a0,
+        toGo == 8
+            ? words[0]
+            : loadPartialWord(reinterpret_cast<const uint8_t*>(words), toGo));
+  }
+  return a0 ^ ((a1 * kMul)) ^ (a2 * kMul);
+}
 } // namespace facebook::velox::bits
diff --git a/velox/common/base/BitUtil.h b/velox/common/base/BitUtil.h
index 8bd07344aafbf..75b118ce094fc 100644
--- a/velox/common/base/BitUtil.h
+++ b/velox/common/base/BitUtil.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include "velox/common/base/Exceptions.h"
+
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
@@ -93,6 +95,11 @@ constexpr inline T roundUp(T value, U factor) {
   return (value + (factor - 1)) / factor * factor;
 }
 
+template <typename T, typename U>
+constexpr inline T divRoundUp(T value, U factor) {
+  return (value + (factor - 1)) / factor;
+}
+
 constexpr inline uint64_t lowMask(int32_t bits) {
   return (1UL << bits) - 1;
 }
@@ -714,7 +721,7 @@ inline uint64_t nextPowerOfTwo(uint64_t size) {
     return 0;
   }
   uint32_t bits = 63 - countLeadingZeros(size);
-  uint64_t lower = 1U << bits;
+  uint64_t lower = 1ULL << bits;
   // Size is a power of 2.
   if (lower == size) {
     return size;
@@ -784,24 +791,7 @@ inline uint64_t loadPartialWord(const uint8_t* data, int32_t size) {
   return result;
 }
 
-inline size_t hashBytes(size_t seed, const char* data, size_t size) {
-  auto begin = reinterpret_cast<const uint8_t*>(data);
-  if (size < 8) {
-    return hashMix(seed, loadPartialWord(begin, size));
-  }
-  auto result = seed;
-  auto end = begin + size;
-  while (begin + 8 <= end) {
-    result = hashMix(result, *reinterpret_cast<const uint64_t*>(begin));
-    begin += 8;
-  }
-  if (end != begin) {
-    // Accesses the last 64 bits. Some bytes may get processed twice but the
-    // access is safe.
-    result = hashMix(result, *reinterpret_cast<const uint64_t*>(end - 8));
-  }
-  return result;
-}
+uint64_t hashBytes(uint64_t seed, const char* data, size_t size);
 
 namespace detail {
 // Returns at least 'numBits' bits of data starting at bit 'bitOffset'
@@ -890,13 +880,17 @@ void copyBitsBackward(
     uint64_t targetOffset,
     uint64_t numBits);
 
-// Copies consecutive bits from 'source' to positions in 'target'
-// where 'targetMask' has a 1. 'source' may be a prefix of 'target',
-// so that contiguous bits of source are scattered in place. The
-// positions of 'target' where 'targetMask' is 0 are 0. A sample use
-// case is reading a column of boolean with nulls. The booleans
-// from the column get inserted into the places given by ones in the
-// present bitmap.
+/// Copies consecutive bits from 'source' to positions in 'target' where
+/// 'targetMask' has a 1. 'source' may be a prefix of 'target', so that
+/// contiguous bits of source are scattered in place. The positions of 'target'
+/// where 'targetMask' is 0 are 0. A sample use case is reading a column of
+/// boolean with nulls. The booleans from the column get inserted into the
+/// places given by ones in the present bitmap. All source, target and mask bit
+/// arrays are accessed at 64 bit width and must have a minimum of 64 bits plus
+/// one addressable byte after the last bit. Using std::vector as a
+/// bit array without explicit padding, for example, can crash with
+/// access to unmapped address if the vector happens to border on
+/// unmapped memory.
 void scatterBits(
     int32_t numSource,
     int32_t numTarget,
@@ -904,9 +898,9 @@ void scatterBits(
     const uint64_t* targetMask,
     char* target);
 
-// Extract bits from integer 'a' at the corresponding bit locations
-// specified by 'mask' to contiguous low bits in return value; the
-// remaining upper bits in return value are set to zero.
+/// Extract bits from integer 'a' at the corresponding bit locations specified
+/// by 'mask' to contiguous low bits in return value; the remaining upper bits
+/// in return value are set to zero.
 template <typename T>
 inline T extractBits(T a, T mask);
 
@@ -989,6 +983,26 @@ inline __int128_t builtin_bswap128(__int128_t value) {
 #endif
 }
 
+/// Store `bits' into the memory region pointed by `byte', at `index' (bit
+/// index).  If `kSize' is 8, we store the whole byte directly; otherwise it
+/// must be 4 and we store either the whole byte or the upper 4 bits only,
+/// depending on the `index'.
+template <int kSize>
+void storeBitsToByte(uint8_t bits, uint8_t* bytes, unsigned index) {
+  VELOX_DCHECK_EQ(index % kSize, 0);
+  VELOX_DCHECK_EQ(bits >> kSize, 0);
+  if constexpr (kSize == 8) {
+    bytes[index / 8] = bits;
+  } else {
+    VELOX_DCHECK_EQ(kSize, 4);
+    if (index % 8 == 0) {
+      bytes[index / 8] = bits;
+    } else {
+      bytes[index / 8] |= bits << 4;
+    }
+  }
+}
+
 } // namespace bits
 } // namespace velox
 } // namespace facebook
diff --git a/velox/common/base/BloomFilter.h b/velox/common/base/BloomFilter.h
index 0ad1b94f66c7c..1d23e382834bb 100644
--- a/velox/common/base/BloomFilter.h
+++ b/velox/common/base/BloomFilter.h
@@ -114,16 +114,14 @@ class BloomFilter {
   }
 
   inline static void
-  set(uint64_t* FOLLY_NONNULL bloom, int32_t bloomSize, uint64_t hashCode) {
+  set(uint64_t* bloom, int32_t bloomSize, uint64_t hashCode) {
     auto mask = bloomMask(hashCode);
     auto index = bloomIndex(bloomSize, hashCode);
     bloom[index] |= mask;
   }
 
-  inline static bool test(
-      const uint64_t* FOLLY_NONNULL bloom,
-      int32_t bloomSize,
-      uint64_t hashCode) {
+  inline static bool
+  test(const uint64_t* bloom, int32_t bloomSize, uint64_t hashCode) {
     auto mask = bloomMask(hashCode);
     auto index = bloomIndex(bloomSize, hashCode);
     return mask == (bloom[index] & mask);
diff --git a/velox/common/base/CMakeLists.txt b/velox/common/base/CMakeLists.txt
index cc10739914017..6c26222ef56cd 100644
--- a/velox/common/base/CMakeLists.txt
+++ b/velox/common/base/CMakeLists.txt
@@ -12,27 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_exception Exceptions.cpp VeloxException.cpp Exceptions.h)
-target_link_libraries(
-  velox_exception PUBLIC velox_flag_definitions velox_process Folly::folly
-                         fmt::fmt gflags::gflags glog::glog)
+velox_add_library(velox_exception Exceptions.cpp VeloxException.cpp
+                  Exceptions.h)
+velox_link_libraries(
+  velox_exception
+  PUBLIC velox_flag_definitions
+         velox_process
+         Folly::folly
+         fmt::fmt
+         gflags::gflags
+         glog::glog)
 
-add_library(
+velox_add_library(
   velox_common_base
   BitUtil.cpp
   Counters.cpp
   Fs.cpp
+  PeriodicStatsReporter.cpp
   RandomUtil.cpp
   RawVector.cpp
   RuntimeMetrics.cpp
   SimdUtil.cpp
+  SpillConfig.cpp
+  SpillStats.cpp
   StatsReporter.cpp
   SuccinctPrinter.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_common_base
   PUBLIC velox_exception Folly::folly fmt::fmt xsimd
-  PRIVATE velox_process velox_test_util glog::glog)
+  PRIVATE velox_common_compression velox_process velox_test_util glog::glog)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
@@ -42,8 +51,8 @@ if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(benchmarks)
 endif()
 
-add_library(velox_id_map BigintIdMap.cpp)
-target_link_libraries(
+velox_add_library(velox_id_map BigintIdMap.cpp)
+velox_link_libraries(
   velox_id_map
   velox_memory
   velox_flag_definitions
@@ -52,3 +61,9 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   gflags::gflags)
+
+velox_add_library(velox_status Status.cpp)
+velox_link_libraries(
+  velox_status
+  PUBLIC fmt::fmt Folly::folly
+  PRIVATE glog::glog)
diff --git a/velox/common/base/CoalesceIo.h b/velox/common/base/CoalesceIo.h
index 718ddd5926df7..f5f58ba1092bf 100644
--- a/velox/common/base/CoalesceIo.h
+++ b/velox/common/base/CoalesceIo.h
@@ -19,9 +19,9 @@
 #include <cstdint>
 #include <vector>
 namespace facebook::velox {
-// Utility for combining IOs to nearby location into fewer coalesced
-// IOs. This may increase data transfer but generally reduces
-// latency and may reduce throttling.
+/// Utility for combining IOs to nearby location into fewer coalesced IOs. This
+/// may increase data transfer but generally reduces latency and may reduce
+/// throttling.
 
 /// Describes the outcome of coalescedIo().
 struct CoalesceIoStats {
diff --git a/velox/common/base/CompareFlags.h b/velox/common/base/CompareFlags.h
index 436e6c203ef75..265f84652f81d 100644
--- a/velox/common/base/CompareFlags.h
+++ b/velox/common/base/CompareFlags.h
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include <fmt/core.h>
+#include <optional>
 #include <sstream>
 #include <string>
 
@@ -21,14 +22,10 @@
 
 namespace facebook::velox {
 
+constexpr auto kIndeterminate = std::nullopt;
+
 // Describes value collation in comparison.
 struct CompareFlags {
-  // NoStop: The compare doesn't stop at null.
-  // StopAtNull: The compare returns std::nullopt if null is encountered in rhs
-  // or lhs.
-  enum class NullHandlingMode { NoStop, StopAtNull };
-
-  // This flag will be ignored if nullHandlingMode is true.
   bool nullsFirst = true;
 
   bool ascending = true;
@@ -36,18 +33,138 @@ struct CompareFlags {
   // When true, comparison should return non-0 early when sizes mismatch.
   bool equalsOnly = false;
 
-  NullHandlingMode nullHandlingMode = NullHandlingMode::NoStop;
+  enum class NullHandlingMode {
+
+    /// The default null handling mode where nulls are treated as values such
+    /// that:
+    ///    - null == null is true,
+    ///    - null == value is false.
+    ///    - when equalsOnly=false null ordering is determined using the
+    ///    nullsFirst flag.
+    kNullAsValue,
+
+    /// Presto semantics for handling nulls.
+    /// It matches the behavior of ==, >, < functions and many other Presto
+    /// functions such as array_remove and array_contains.
+    ///
+    /// Under this mode, result of comparison can be indeterminate.
+    /// Such result is represented as std::nullopt and means that the
+    /// function can not decide on the result of the comparison due to some
+    /// existing nulls. Not every null results in indeterminate result.
+    ///
+    /// ## When equalsOnly=true:
+    /// The compare can return kIndeterminate, or a value according to the
+    /// following:
+    ///   1. Primitive types and top level nulls:
+    ///     - Comparing null with anything else is indeterminate, otherwise a
+    ///       value result is returned.
+    ///
+    ///     - Comparing top level nulls in complex types is indeterminate.
+    ///
+    ///   2. Arrays:
+    ///     - If the compared array sizes are different then result is false,
+    ///       ex:[null] == [null, null] is false.
+    ///
+    ///      - If any two elements compare result is false, result is false
+    ///        ex: [null, 1] = [null, 2] is false.
+    ///
+    ///      - If result is not false and any two elements compared result is
+    ///        indeterminate, then result is indeterminate.
+    ///        ex: [null, 1] = [null, 1] is indeterminate.
+    ///
+    ///      - If elements compare results are true, then result is true.
+    ///        ex: [1, 1] = [1, 1] is true.
+    ///
+    ///   3. Rows: Follows the same logic as array, with fields being elements.
+    ///     - If any two fields compare result is false, result is false
+    ///       ex: (null, 1) = (null, 2) is false.
+    ///
+    ///     - If result is not false and any two fields compare result is
+    ///       indeterminate, then the result is indeterminate.
+    ///       ex: (null, 1) = (null, 1) is indeterminate.
+    ///
+    ///       - If all fields compare results are true, then result is true.
+    ///       ex: (1, 1) = (1, 1) is indeterminate.
+    ///
+    ///   4. Maps:
+    ///     - Keys are compared first, if keys are not equal values are not
+    ///       checked even if they have nulls and result is false.
+    ///
+    ///    - If keys are the same for all maps, values are compared by applying
+    ///      the array compare logic explained above observing each map as an
+    ///      array of values.
+    ///      ex: {1:null, 2:2} = {1:null, 2:3} is false.
+    ///      ex: {1:null, 2:2} = {1:null, 2:2} is indeterminate.
+    ///      ex: {1:1, 2:2} = {1:1, 2:2} is true.
+    ///
+    /// ## When equalsOnly=false:
+    /// The compare either returns a value or throws a user error if a null is
+    /// encountered before result is determined, as explained below:
+    ///
+    ///   1. Primitive types and top level nulls:
+    ///     - Comparing null with anything else throws (note that functions like
+    ///       >, < do not pass nulls to compare since they are default nulls
+    ///       functions).
+    ///
+    ///     - Comparing top level nulls also throws.
+    ///
+    ///   2. Arrays:
+    ///     - Only elements up to index min(rhs.size(), lhs.size()) are
+    ///     compared.
+    ///
+    ///     - Elements are compared in order starting from index 0.
+    ///
+    ///     - If all elements in the range above are the same, then sizes are
+    ///       compared.
+    ///       ex: [1, null] > [1] -> result is true, and null is not read.
+    ///
+    ///     - If any two elements are different but not null, then result is
+    ///       determined and remaining elements are not considered for
+    ///       comparison.
+    ///       ex: [1, null] > [2, null] -> result is false and nulls are not
+    ///       compared.
+    ///
+    ///     - If a null element is encountered before result is determined then
+    ///       the compare throws a user exception.
+    ///       ex: [1, null, null] > [1, 2]-> throws.
+    ///
+    ///   3. Rows:
+    ///     - Fields are compared in order starting from index 0.
+    ///
+    ///     - If any two fields are different but not null, then result is
+    ///       determined and remaining elements are not considered for
+    ///       comparison.
+    ///       ex: (1, null) > (2, null) -> result is false and nulls not
+    ///       compared.
+    ///
+    ///     - If a null element is encountered before result is determined then
+    ///       the compare throws a user exception.
+    ///       ex: (1, null) > (1, 2) -> throws.
+    ///
+    ///   4. Maps:
+    ///     - This mode does not allow ordering maps.
+    kNullAsIndeterminate
+  };
+
+  NullHandlingMode nullHandlingMode = NullHandlingMode::kNullAsValue;
+
+  bool nullAsValue() const {
+    return nullHandlingMode == CompareFlags::NullHandlingMode::kNullAsValue;
+  }
 
-  bool mayStopAtNull() {
-    return nullHandlingMode == CompareFlags::NullHandlingMode::StopAtNull;
+  // Helper method to construct compare flags with equalsOnly = true, in that
+  // case nullsFirst and ascending are not needed.
+  static constexpr CompareFlags equality(NullHandlingMode nullHandlingMode) {
+    return CompareFlags{
+        .equalsOnly = true, .nullHandlingMode = nullHandlingMode};
   }
 
   static std::string nullHandlingModeToStr(NullHandlingMode mode) {
     switch (mode) {
-      case CompareFlags::NullHandlingMode::NoStop:
-        return "NoStop";
-      case CompareFlags::NullHandlingMode::StopAtNull:
-        return "StopAtNull";
+      case CompareFlags::NullHandlingMode::kNullAsValue:
+        return "NullAsValue";
+      case CompareFlags::NullHandlingMode::kNullAsIndeterminate:
+        return "NullAsIndeterminate";
       default:
         return fmt::format(
             "Unknown Null Handling mode {}", static_cast<int>(mode));
diff --git a/velox/common/base/ConcurrentCounter.h b/velox/common/base/ConcurrentCounter.h
new file mode 100644
index 0000000000000..689c91d152519
--- /dev/null
+++ b/velox/common/base/ConcurrentCounter.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+#include <new>
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox {
+
+/// The class provides concurrent updates to a counter with minimum lock
+/// contention. The template argument T specifies the counter type. The counter
+/// is N-way sharded internally. Each update goes to one of the sharded counters
+/// based on the update thread id.
+template <class T>
+class ConcurrentCounter {
+ public:
+  /// Creates a concurrent counter with specified number of shards.
+  ///
+  /// NOTE: the constructor sets the actual number of shards to be the next
+  /// power of 2.
+  explicit ConcurrentCounter(size_t numShards)
+      : numShards_(bits::nextPowerOfTwo(numShards)),
+        shardMask_(numShards_ - 1),
+        counters_(numShards_) {
+    VELOX_CHECK_GE(numShards_, 1);
+    for (auto& counter : counters_) {
+      counter.value = T();
+    }
+  }
+
+  ConcurrentCounter(const ConcurrentCounter&) = delete;
+  ConcurrentCounter& operator=(const ConcurrentCounter&) = delete;
+
+  /// Invoked to read the sum of values from 'counters_'.
+  T read() const {
+    T sum = T();
+    for (size_t i = 0; i < numShards_; ++i) {
+      sum += counters_[i].read();
+    }
+    return sum;
+  }
+
+  /// Invoked to update with 'delta'.
+  void update(T delta) {
+    counters_[shardIndex()].update(delta);
+  }
+
+  /// Invoked to update with 'delta' and user provided 'updateFn'. The function
+  /// picks up the shard to apply the customized update.
+  using UpdateFn = std::function<bool(T& counter, T delta, std::mutex& lock)>;
+  bool update(T delta, const UpdateFn& updateFn) {
+    return counters_[shardIndex()].update(delta, updateFn);
+  }
+
+  void testingClear() {
+    for (auto& counter : counters_) {
+      counter.value = T();
+    }
+  }
+
+  T testingRead(size_t index) const {
+    return counters_[index].read();
+  }
+
+  bool testingUpdate(size_t index, T delta, const UpdateFn& updateFn) {
+    return counters_[index].update(delta, updateFn);
+  }
+
+ private:
+  struct alignas(folly::hardware_destructive_interference_size) Counter {
+    mutable std::mutex lock;
+    T value;
+
+    T read() const {
+      std::lock_guard<std::mutex> l(lock);
+      return value;
+    }
+
+    void update(T delta) {
+      std::lock_guard<std::mutex> l(lock);
+      value += delta;
+    }
+
+    bool update(T delta, const UpdateFn& updateFn) {
+      return updateFn(value, delta, lock);
+    }
+  };
+
+  size_t shardIndex() const {
+    const size_t hash =
+        std::hash<std::thread::id>{}(std::this_thread::get_id());
+    const size_t index = hash & shardMask_;
+    VELOX_DCHECK_LT(index, counters_.size());
+    return index;
+  }
+
+  const size_t numShards_;
+  const size_t shardMask_;
+
+  std::vector<Counter> counters_;
+};
+} // namespace facebook::velox
diff --git a/velox/common/base/CountBits.h b/velox/common/base/CountBits.h
new file mode 100644
index 0000000000000..b267d2f636ef0
--- /dev/null
+++ b/velox/common/base/CountBits.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace facebook::velox {
+
+// Copied from format.h of fmt.
+FOLLY_ALWAYS_INLINE int countDigits(__uint128_t n) {
+  int count = 1;
+  for (;;) {
+    if (n < 10) {
+      return count;
+    }
+    if (n < 100) {
+      return count + 1;
+    }
+    if (n < 1000) {
+      return count + 2;
+    }
+    if (n < 10000) {
+      return count + 3;
+    }
+    n /= 10000u;
+    count += 4;
+  }
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/base/Counters.cpp b/velox/common/base/Counters.cpp
index a7c1b931a4544..67421ced6be9f 100644
--- a/velox/common/base/Counters.cpp
+++ b/velox/common/base/Counters.cpp
@@ -19,11 +19,503 @@
 
 namespace facebook::velox {
 
-void registerVeloxCounters() {
-  // Track hive handle generation latency in range of [0, 100s] and reports
+void registerVeloxMetrics() {
+  /// ================== Task Execution Counters =================
+  // The number of driver yield count when exceeds the per-driver cpu time slice
+  // limit if enforced.
+  DEFINE_METRIC(kMetricDriverYieldCount, facebook::velox::StatType::COUNT);
+
+  // Tracks driver queue latency in range of [0, 10s] with 20 buckets and
+  // reports P50, P90, P99, and P100.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricDriverQueueTimeMs, 500, 0, 10'000, 50, 90, 99, 100);
+
+  // Tracks driver execution latency in range of [0, 30s] with 30 buckets and
+  // reports P50, P90, P99, and P100.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricDriverExecTimeMs, 1'000, 0, 30'000, 50, 90, 99, 100);
+
+  /// ================== Cache Counters =================
+
+  // Tracks hive handle generation latency in range of [0, 100s] and reports
   // P50, P90, P99, and P100.
-  REPORT_ADD_HISTOGRAM_EXPORT_PERCENTILE(
-      kCounterHiveFileHandleGenerateLatencyMs, 10, 0, 100000, 50, 90, 99, 100);
-}
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricHiveFileHandleGenerateLatencyMs,
+      10'000,
+      0,
+      100'000,
+      50,
+      90,
+      99,
+      100);
+
+  DEFINE_METRIC(kMetricCacheShrinkCount, facebook::velox::StatType::COUNT);
+
+  // Tracks cache shrink latency in range of [0, 100s] with 10 buckets and
+  // reports P50, P90, P99, and P100.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricCacheShrinkTimeMs, 10'000, 0, 100'000, 50, 90, 99, 100);
+
+  /// ================== Memory Allocator Counters =================
+
+  // Number of bytes currently mapped in MemoryAllocator. These bytes represent
+  // the bytes that are either currently being allocated or were in the past
+  // allocated, not yet been returned back to the operating system, in the
+  // form of 'Allocation' or 'ContiguousAllocation'.
+  DEFINE_METRIC(kMetricMappedMemoryBytes, facebook::velox::StatType::AVG);
+
+  // Number of bytes currently allocated (used) from MemoryAllocator in the form
+  // of 'Allocation' or 'ContiguousAllocation'.
+  DEFINE_METRIC(kMetricAllocatedMemoryBytes, facebook::velox::StatType::AVG);
+
+  // Number of bytes currently mapped in MmapAllocator, in the form of
+  // 'ContiguousAllocation'.
+  //
+  // NOTE: This applies only to MmapAllocator
+  DEFINE_METRIC(kMetricMmapExternalMappedBytes, facebook::velox::StatType::AVG);
+
+  // Number of bytes currently allocated from MmapAllocator directly from raw
+  // allocateBytes() interface, and internally allocated by malloc. Only small
+  // chunks of memory are delegated to malloc.
+  //
+  // NOTE: This applies only to MmapAllocator
+  DEFINE_METRIC(kMetricMmapDelegatedAllocBytes, facebook::velox::StatType::AVG);
+
+  /// ================== AsyncDataCache Counters =================
+
+  // Max possible age of AsyncDataCache and SsdCache entries since the raw file
+  // was opened to load the cache.
+  DEFINE_METRIC(kMetricCacheMaxAgeSecs, facebook::velox::StatType::AVG);
+
+  // Total number of cache entries.
+  DEFINE_METRIC(kMetricMemoryCacheNumEntries, facebook::velox::StatType::AVG);
+
+  // Total number of cache entries that do not cache anything.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumEmptyEntries, facebook::velox::StatType::AVG);
+
+  // Total number of cache entries that are pinned for shared access.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumSharedEntries, facebook::velox::StatType::AVG);
+
+  // Total number of cache entries that are pinned for exclusive access.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumExclusiveEntries, facebook::velox::StatType::AVG);
+
+  // Total number of cache entries that are being or have been prefetched but
+  // have not been hit.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumPrefetchedEntries, facebook::velox::StatType::AVG);
+
+  // Total number of bytes of the cached data that is much smaller than
+  // kTinyDataSize.
+  DEFINE_METRIC(
+      kMetricMemoryCacheTotalTinyBytes, facebook::velox::StatType::AVG);
+
+  // Total number of bytes of the cached data excluding
+  // 'kMetricMemoryCacheTotalTinyBytes'.
+  DEFINE_METRIC(
+      kMetricMemoryCacheTotalLargeBytes, facebook::velox::StatType::AVG);
+
+  // Total unused capacity bytes in 'kMetricMemoryCacheTotalTinyBytes'.
+  DEFINE_METRIC(
+      kMetricMemoryCacheTotalTinyPaddingBytes, facebook::velox::StatType::AVG);
+
+  // Total unused capacity bytes in 'kMetricMemoryCacheTotalLargeBytes'.
+  DEFINE_METRIC(
+      kMetricMemoryCacheTotalLargePaddingBytes, facebook::velox::StatType::AVG);
+
+  // Total bytes of cache entries in prefetch state.
+  DEFINE_METRIC(
+      kMetricMemoryCacheTotalPrefetchBytes, facebook::velox::StatType::AVG);
+
+  // Sum of scores of evicted entries. This serves to infer an average lifetime
+  // for entries in cache.
+  DEFINE_METRIC(
+      kMetricMemoryCacheSumEvictScore, facebook::velox::StatType::SUM);
+
+  // Number of hits (saved IO) since last counter retrieval. The first hit to a
+  // prefetched entry does not count.
+  DEFINE_METRIC(kMetricMemoryCacheNumHits, facebook::velox::StatType::SUM);
+
+  // Amount of hit bytes (saved IO) since last counter retrieval. The first hit
+  // to a prefetched entry does not count.
+  DEFINE_METRIC(kMetricMemoryCacheHitBytes, facebook::velox::StatType::SUM);
+
+  // Number of new entries created since last counter retrieval.
+  DEFINE_METRIC(kMetricMemoryCacheNumNew, facebook::velox::StatType::SUM);
+
+  // Number of times a valid entry was removed in order to make space, since
+  // last counter retrieval.
+  DEFINE_METRIC(kMetricMemoryCacheNumEvicts, facebook::velox::StatType::SUM);
+
+  // Number of times a valid entry was removed in order to make space but has
+  // not been saved to SSD yet, since last counter retrieval.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumSavableEvicts, facebook::velox::StatType::SUM);
+
+  // Number of entries considered for evicting, since last counter retrieval.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumEvictChecks, facebook::velox::StatType::SUM);
+
+  // Number of times a user waited for an entry to transit from exclusive to
+  // shared mode, since last counter retrieval.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumWaitExclusive, facebook::velox::StatType::SUM);
+
+  // Clocks spent in allocating or freeing memory for backing cache entries,
+  // since last counter retrieval
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumAllocClocks, facebook::velox::StatType::SUM);
+
+  // Number of AsyncDataCache entries that are aged out and evicted
+  // given configured TTL.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumAgedOutEntries, facebook::velox::StatType::SUM);
+
+  // Number of AsyncDataCache entries that are stale because of cache request
+  // size mismatch.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumStaleEntries, facebook::velox::StatType::COUNT);
+
+  /// ================== SsdCache Counters ==================
+
+  // Number of regions currently cached by SSD.
+  DEFINE_METRIC(kMetricSsdCacheCachedRegions, facebook::velox::StatType::AVG);
+
+  // Number of entries currently cached by SSD.
+  DEFINE_METRIC(kMetricSsdCacheCachedEntries, facebook::velox::StatType::AVG);
+
+  // Total bytes currently cached by SSD.
+  DEFINE_METRIC(kMetricSsdCacheCachedBytes, facebook::velox::StatType::AVG);
+
+  // Total number of entries read from SSD.
+  DEFINE_METRIC(kMetricSsdCacheReadEntries, facebook::velox::StatType::SUM);
+
+  // Total number of bytes read from SSD.
+  DEFINE_METRIC(kMetricSsdCacheReadBytes, facebook::velox::StatType::SUM);
+
+  // Total number of entries written to SSD.
+  DEFINE_METRIC(kMetricSsdCacheWrittenEntries, facebook::velox::StatType::SUM);
+
+  // Total number of bytes written to SSD.
+  DEFINE_METRIC(kMetricSsdCacheWrittenBytes, facebook::velox::StatType::SUM);
+
+  // Total number of SsdCache entries that are aged out and evicted given
+  // configured TTL.
+  DEFINE_METRIC(kMetricSsdCacheAgedOutEntries, facebook::velox::StatType::SUM);
+
+  // Total number of SsdCache regions that are aged out and evicted given
+  // configured TTL.
+  DEFINE_METRIC(kMetricSsdCacheAgedOutRegions, facebook::velox::StatType::SUM);
+
+  // Total number of SSD file open errors.
+  DEFINE_METRIC(kMetricSsdCacheOpenSsdErrors, facebook::velox::StatType::SUM);
+
+  // Total number of SSD checkpoint file open errors.
+  DEFINE_METRIC(
+      kMetricSsdCacheOpenCheckpointErrors, facebook::velox::StatType::SUM);
+
+  // Total number of SSD evict log file open errors.
+  DEFINE_METRIC(kMetricSsdCacheOpenLogErrors, facebook::velox::StatType::SUM);
+
+  // Total number of errors while deleting SSD checkpoint files.
+  DEFINE_METRIC(
+      kMetricSsdCacheDeleteCheckpointErrors, facebook::velox::StatType::SUM);
+
+  // Total number of errors while growing SSD cache files.
+  DEFINE_METRIC(kMetricSsdCacheGrowFileErrors, facebook::velox::StatType::SUM);
+
+  // Total number of error while writing to SSD cache files.
+  DEFINE_METRIC(kMetricSsdCacheWriteSsdErrors, facebook::velox::StatType::SUM);
+
+  // Total number of errors while writing SSD checkpoint file.
+  DEFINE_METRIC(
+      kMetricSsdCacheWriteCheckpointErrors, facebook::velox::StatType::SUM);
+
+  // Total number of writes dropped due to no cache space.
+  DEFINE_METRIC(kMetricSsdCacheWriteSsdDropped, facebook::velox::StatType::SUM);
+
+  // Total number of errors while reading from SSD cache files.
+  DEFINE_METRIC(kMetricSsdCacheReadSsdErrors, facebook::velox::StatType::SUM);
+
+  // Total number of corrupted SSD data read detected by checksum.
+  DEFINE_METRIC(kMetricSsdCacheReadCorruptions, facebook::velox::StatType::SUM);
 
+  // Total number of errors while reading from SSD checkpoint files.
+  DEFINE_METRIC(
+      kMetricSsdCacheReadCheckpointErrors, facebook::velox::StatType::SUM);
+
+  // Total number of SSD cache reads without checksum verification due to
+  // mismatch in SSD cache request size.
+  DEFINE_METRIC(
+      kMetricSsdCacheReadWithoutChecksum, facebook::velox::StatType::SUM);
+
+  // Total number of checkpoints read.
+  DEFINE_METRIC(kMetricSsdCacheCheckpointsRead, facebook::velox::StatType::SUM);
+
+  // Total number of checkpoints written.
+  DEFINE_METRIC(
+      kMetricSsdCacheCheckpointsWritten, facebook::velox::StatType::SUM);
+
+  // Total number of cache regions evicted.
+  DEFINE_METRIC(kMetricSsdCacheRegionsEvicted, facebook::velox::StatType::SUM);
+
+  // Total number of cache entries recovered from checkpoint.
+  DEFINE_METRIC(
+      kMetricSsdCacheRecoveredEntries, facebook::velox::StatType::SUM);
+
+  /// ================== Memory Arbitration Counters =================
+
+  // The number of arbitration requests.
+  DEFINE_METRIC(
+      kMetricArbitratorRequestsCount, facebook::velox::StatType::COUNT);
+
+  // The number of times a query level memory pool is aborted as a result of a
+  // memory arbitration process. The memory pool aborted will eventually result
+  // in a cancelling of the original query.
+  DEFINE_METRIC(
+      kMetricArbitratorAbortedCount, facebook::velox::StatType::COUNT);
+
+  // The number of times a memory arbitration request failed. This may occur
+  // either because the requester was terminated during the processing of its
+  // request, the arbitration request would surpass the maximum allowed capacity
+  // for the requester, or the arbitration process couldn't release the
+  // requested amount of memory.
+  DEFINE_METRIC(
+      kMetricArbitratorFailuresCount, facebook::velox::StatType::COUNT);
+
+  // Tracks the memory reclaim count on an operator.
+  DEFINE_METRIC(kMetricMemoryReclaimCount, facebook::velox::StatType::COUNT);
+
+  // Tracks op memory reclaim exec time in range of [0, 600s] with 20 buckets
+  // and reports P50, P90, P99, and P100.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricMemoryReclaimExecTimeMs, 30'000, 0, 600'000, 50, 90, 99, 100);
+
+  // Tracks op memory reclaim bytes distribution in range of [0, 4GB] with 64
+  // buckets and reports P50, P90, P99, and P100
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricMemoryReclaimedBytes,
+      67'108'864,
+      0,
+      4'294'967'296,
+      50,
+      90,
+      99,
+      100);
+
+  // Tracks the memory reclaim count on an operator.
+  DEFINE_METRIC(
+      kMetricTaskMemoryReclaimCount, facebook::velox::StatType::COUNT);
+
+  // Tracks memory reclaim task wait time in range of [0, 60s] with 60 buckets
+  // and reports P50, P90, P99, and P100.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricTaskMemoryReclaimWaitTimeMs, 1'000, 0, 60'000, 50, 90, 99, 100);
+
+  // Tracks memory reclaim task wait time in range of [0, 240s] with 60 buckets
+  // and reports P50, P90, P99, and P100.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricTaskMemoryReclaimExecTimeMs, 4'000, 0, 240'000, 50, 90, 99, 100);
+
+  // Tracks the number of times that the task memory reclaim wait timeouts.
+  DEFINE_METRIC(
+      kMetricTaskMemoryReclaimWaitTimeoutCount,
+      facebook::velox::StatType::COUNT);
+
+  // The number of times that the memory reclaim fails because the operator is
+  // executing a non-reclaimable section where it is expected to have reserved
+  // enough memory to execute without asking for more. Therefore, it is an
+  // indicator that the memory reservation is not sufficient. It excludes
+  // counting instances where the operator is in a non-reclaimable state due to
+  // currently being on-thread and running or being already cancelled.
+  DEFINE_METRIC(
+      kMetricMemoryNonReclaimableCount, facebook::velox::StatType::COUNT);
+
+  // The number of arbitration that reclaims the used memory from the query
+  // which initiates the memory arbitration request itself. It ensures the
+  // memory arbitration request won't exceed its per-query memory capacity
+  // limit.
+  DEFINE_METRIC(
+      kMetricArbitratorLocalArbitrationCount, facebook::velox::StatType::COUNT);
+
+  // The number of arbitration which ensures the total allocated query capacity
+  // won't exceed the arbitrator capacity limit. It may or may not reclaim
+  // memory from the query which initiate the memory arbitration request. This
+  // indicates the velox runtime doesn't have enough memory to run all the
+  // queries at their peak memory usage. We have to trigger spilling to let them
+  // run through completion.
+  DEFINE_METRIC(
+      kMetricArbitratorGlobalArbitrationCount,
+      facebook::velox::StatType::COUNT);
+
+  // The number of global arbitration that reclaims used memory by slow disk
+  // spilling.
+  DEFINE_METRIC(
+      kMetricArbitratorSlowGlobalArbitrationCount,
+      facebook::velox::StatType::COUNT);
+
+  // The distribution of the amount of time an arbitration operation stays in
+  // arbitration queues and waits the arbitration r/w locks in range of [0,
+  // 600s] with 20 buckets. It is configured to report the latency at P50, P90,
+  // P99, and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricArbitratorWaitTimeMs, 30'000, 0, 600'000, 50, 90, 99, 100);
+
+  // The distribution of the amount of time it takes to complete a single
+  // arbitration request stays queued in range of [0, 600s] with 20
+  // buckets. It is configured to report the latency at P50, P90, P99,
+  // and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricArbitratorArbitrationTimeMs, 30'000, 0, 600'000, 50, 90, 99, 100);
+
+  // Tracks the average of free memory capacity managed by the arbitrator in
+  // bytes.
+  DEFINE_METRIC(
+      kMetricArbitratorFreeCapacityBytes, facebook::velox::StatType::AVG);
+
+  DEFINE_METRIC(
+      kMetricArbitratorFreeReservedCapacityBytes,
+      facebook::velox::StatType::AVG);
+
+  // Tracks the leaf memory pool usage leak in bytes.
+  DEFINE_METRIC(
+      kMetricMemoryPoolUsageLeakBytes, facebook::velox::StatType::SUM);
+
+  // Tracks the leaf memory pool reservation leak in bytes.
+  DEFINE_METRIC(
+      kMetricMemoryPoolReservationLeakBytes, facebook::velox::StatType::SUM);
+
+  // The distribution of a root memory pool's initial capacity in range of [0,
+  // 256MB] with 32 buckets. It is configured to report the capacity at P50,
+  // P90, P99, and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricMemoryPoolInitialCapacityBytes,
+      8L << 20,
+      0,
+      256L << 20,
+      50,
+      90,
+      99,
+      100);
+
+  // The distribution of a root memory pool cappacity growth attempts through
+  // memory arbitration in range of [0, 256] with 32 buckets. It is configured
+  // to report the count at P50, P90, P99, and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricMemoryPoolCapacityGrowCount, 8, 0, 256, 50, 90, 99, 100);
+
+  // Tracks the count of double frees in memory allocator, indicating the
+  // possibility of buffer ownership issues when a buffer is freed more than
+  // once.
+  DEFINE_METRIC(
+      kMetricMemoryAllocatorDoubleFreeCount, facebook::velox::StatType::COUNT);
+
+  /// ================== Spill related Counters =================
+
+  // The number of bytes in memory to spill.
+  DEFINE_METRIC(kMetricSpilledInputBytes, facebook::velox::StatType::SUM);
+
+  // The number of bytes spilled to disk which can be number of compressed
+  // bytes if compression is enabled.
+  DEFINE_METRIC(kMetricSpilledBytes, facebook::velox::StatType::SUM);
+
+  // The number of spilled rows.
+  DEFINE_METRIC(kMetricSpilledRowsCount, facebook::velox::StatType::COUNT);
+
+  // The number of spilled files.
+  DEFINE_METRIC(kMetricSpilledFilesCount, facebook::velox::StatType::COUNT);
+
+  // The distribution of the amount of time spent on filling rows for spilling.
+  // in range of [0, 600s] with 20 buckets. It is configured to report the
+  // latency at P50, P90, P99, and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricSpillFillTimeMs, 30'000, 0, 600'000, 50, 90, 99, 100);
+
+  // The distribution of the amount of time spent on sorting rows for spilling
+  // in range of [0, 600s] with 20 buckets. It is configured to report the
+  // latency at P50, P90, P99, and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricSpillSortTimeMs, 30'000, 0, 600'000, 50, 90, 99, 100);
+
+  // The distribution of the amount of time spent on serializing rows for
+  // spilling in range of [0, 600s] with 20 buckets. It is configured to report
+  // the latency at P50, P90, P99, and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricSpillSerializationTimeMs, 30'000, 0, 600'000, 50, 90, 99, 100);
+
+  // The number of spill writes to storage, which is the number of write calls
+  // to velox filesystem.
+  DEFINE_METRIC(kMetricSpillWritesCount, facebook::velox::StatType::COUNT);
+
+  // The distribution of the amount of time spent on copy out serialized
+  // rows for disk write in range of [0, 600s] with 20 buckets. It is configured
+  // to report the latency at P50, P90, P99, and P100 percentiles. Note:  If
+  // compression is enabled, this includes the compression time.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricSpillFlushTimeMs, 30'000, 0, 600'000, 50, 90, 99, 100);
+
+  // The distribution of the amount of time spent on writing spilled rows to
+  // disk in range of [0, 600s] with 20 buckets. It is configured to report the
+  // latency at P50, P90, P99, and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricSpillWriteTimeMs, 30'000, 0, 600'000, 50, 90, 99, 100);
+
+  // Tracks the number of times that we hit the max spill level limit.
+  DEFINE_METRIC(
+      kMetricMaxSpillLevelExceededCount, facebook::velox::StatType::COUNT);
+
+  // Tracks the total number of bytes in file writers that's pre-maturely
+  // flushed due to memory reclaiming.
+  DEFINE_METRIC(
+      kMetricFileWriterEarlyFlushedRawBytes, facebook::velox::StatType::SUM);
+
+  // The current spilling memory usage in bytes.
+  DEFINE_METRIC(kMetricSpillMemoryBytes, facebook::velox::StatType::AVG);
+
+  // The peak spilling memory usage in bytes.
+  DEFINE_METRIC(kMetricSpillPeakMemoryBytes, facebook::velox::StatType::AVG);
+
+  // The data exchange time distribution in range of [0, 5s] with 50 buckets. It
+  // is configured to report the latency at P50, P90, P99, and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricExchangeDataTimeMs, 1'00, 0, 5'000, 50, 90, 99, 100);
+
+  // The exchange data size in bytes.
+  DEFINE_METRIC(kMetricExchangeDataBytes, facebook::velox::StatType::SUM);
+
+  // The number of data exchange requests.
+  DEFINE_METRIC(kMetricExchangeDataCount, facebook::velox::StatType::COUNT);
+
+  // The data exchange size time distribution in range of [0, 5s] with 50
+  // buckets. It is configured to report the latency at P50, P90, P99, and P100
+  // percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricExchangeDataSizeTimeMs, 1'00, 0, 5'000, 50, 90, 99, 100);
+
+  // The distribution of exchange data size in range of [0, 128MB] with 128
+  // buckets. It is configured to report the capacity at P50, P90, P99, and P100
+  // percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricExchangeDataSize, 1L << 20, 0, 128L << 20, 50, 90, 99, 100);
+
+  // The number of data size exchange requests.
+  DEFINE_METRIC(kMetricExchangeDataSizeCount, facebook::velox::StatType::COUNT);
+
+  /// ================== Storage Counters =================
+
+  // The time distribution of storage IO throttled duration in range of [0, 30s]
+  // with 30 buckets. It is configured to report the capacity at P50, P90, P99,
+  // and P100 percentiles.
+  DEFINE_HISTOGRAM_METRIC(
+      kMetricStorageThrottledDurationMs, 1'000, 0, 30'000, 50, 90, 99, 100);
+
+  // The number of times that storage IOs get throttled in a storage directory.
+  DEFINE_METRIC(kMetricStorageLocalThrottled, facebook::velox::StatType::COUNT);
+
+  // The number of times that storage IOs get throttled in a storage cluster.
+  DEFINE_METRIC(
+      kMetricStorageGlobalThrottled, facebook::velox::StatType::COUNT);
+}
 } // namespace facebook::velox
diff --git a/velox/common/base/Counters.h b/velox/common/base/Counters.h
index bd661709fddcd..eb1e46d971a53 100644
--- a/velox/common/base/Counters.h
+++ b/velox/common/base/Counters.h
@@ -20,9 +20,309 @@
 
 namespace facebook::velox {
 
-// Velox Counter Registration
-void registerVeloxCounters();
+/// Velox metrics Registration.
+void registerVeloxMetrics();
 
-constexpr folly::StringPiece kCounterHiveFileHandleGenerateLatencyMs{
+constexpr folly::StringPiece kMetricHiveFileHandleGenerateLatencyMs{
     "velox.hive_file_handle_generate_latency_ms"};
+
+constexpr folly::StringPiece kMetricCacheShrinkCount{
+    "velox.cache_shrink_count"};
+
+constexpr folly::StringPiece kMetricCacheShrinkTimeMs{"velox.cache_shrink_ms"};
+
+constexpr folly::StringPiece kMetricMaxSpillLevelExceededCount{
+    "velox.spill_max_level_exceeded_count"};
+
+constexpr folly::StringPiece kMetricMemoryReclaimExecTimeMs{
+    "velox.memory_reclaim_exec_ms"};
+
+constexpr folly::StringPiece kMetricMemoryReclaimedBytes{
+    "velox.memory_reclaim_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryReclaimCount{
+    "velox.memory_reclaim_count"};
+
+constexpr folly::StringPiece kMetricTaskMemoryReclaimCount{
+    "velox.task_memory_reclaim_count"};
+
+constexpr folly::StringPiece kMetricTaskMemoryReclaimWaitTimeMs{
+    "velox.task_memory_reclaim_wait_ms"};
+
+constexpr folly::StringPiece kMetricTaskMemoryReclaimExecTimeMs{
+    "velox.task_memory_reclaim_exec_ms"};
+
+constexpr folly::StringPiece kMetricTaskMemoryReclaimWaitTimeoutCount{
+    "velox.task_memory_reclaim_wait_timeout_count"};
+
+constexpr folly::StringPiece kMetricMemoryNonReclaimableCount{
+    "velox.memory_non_reclaimable_count"};
+
+constexpr folly::StringPiece kMetricMemoryPoolInitialCapacityBytes{
+    "velox.memory_pool_initial_capacity_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryPoolCapacityGrowCount{
+    "velox.memory_pool_capacity_growth_count"};
+
+constexpr folly::StringPiece kMetricMemoryPoolUsageLeakBytes{
+    "velox.memory_pool_usage_leak_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryPoolReservationLeakBytes{
+    "velox.memory_pool_reservation_leak_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryAllocatorDoubleFreeCount{
+    "velox.memory_allocator_double_free_count"};
+
+constexpr folly::StringPiece kMetricArbitratorLocalArbitrationCount{
+    "velox.arbitrator_local_arbitration_count"};
+
+constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationCount{
+    "velox.arbitrator_global_arbitration_count"};
+
+constexpr folly::StringPiece kMetricArbitratorSlowGlobalArbitrationCount{
+    "velox.arbitrator_slow_global_arbitration_count"};
+
+constexpr folly::StringPiece kMetricArbitratorAbortedCount{
+    "velox.arbitrator_aborted_count"};
+
+constexpr folly::StringPiece kMetricArbitratorFailuresCount{
+    "velox.arbitrator_failures_count"};
+
+constexpr folly::StringPiece kMetricArbitratorArbitrationTimeMs{
+    "velox.arbitrator_arbitration_time_ms"};
+
+constexpr folly::StringPiece kMetricArbitratorWaitTimeMs{
+    "velox.arbitrator_wait_time_ms"};
+
+constexpr folly::StringPiece kMetricArbitratorFreeCapacityBytes{
+    "velox.arbitrator_free_capacity_bytes"};
+
+constexpr folly::StringPiece kMetricArbitratorFreeReservedCapacityBytes{
+    "velox.arbitrator_free_reserved_capacity_bytes"};
+
+constexpr folly::StringPiece kMetricDriverYieldCount{
+    "velox.driver_yield_count"};
+
+constexpr folly::StringPiece kMetricDriverQueueTimeMs{
+    "velox.driver_queue_time_ms"};
+
+constexpr folly::StringPiece kMetricDriverExecTimeMs{
+    "velox.driver_exec_time_ms"};
+
+constexpr folly::StringPiece kMetricSpilledInputBytes{
+    "velox.spill_input_bytes"};
+
+constexpr folly::StringPiece kMetricSpilledBytes{"velox.spill_bytes"};
+
+constexpr folly::StringPiece kMetricSpilledRowsCount{"velox.spill_rows_count"};
+
+constexpr folly::StringPiece kMetricSpilledFilesCount{
+    "velox.spill_files_count"};
+
+constexpr folly::StringPiece kMetricSpillFillTimeMs{"velox.spill_fill_time_ms"};
+
+constexpr folly::StringPiece kMetricSpillSortTimeMs{"velox.spill_sort_time_ms"};
+
+constexpr folly::StringPiece kMetricSpillSerializationTimeMs{
+    "velox.spill_serialization_time_ms"};
+
+constexpr folly::StringPiece kMetricSpillWritesCount{
+    "velox.spill_writes_count"};
+
+constexpr folly::StringPiece kMetricSpillFlushTimeMs{
+    "velox.spill_flush_time_ms"};
+
+constexpr folly::StringPiece kMetricSpillWriteTimeMs{
+    "velox.spill_write_time_ms"};
+
+constexpr folly::StringPiece kMetricSpillMemoryBytes{
+    "velox.spill_memory_bytes"};
+
+constexpr folly::StringPiece kMetricSpillPeakMemoryBytes{
+    "velox.spill_peak_memory_bytes"};
+
+constexpr folly::StringPiece kMetricFileWriterEarlyFlushedRawBytes{
+    "velox.file_writer_early_flushed_raw_bytes"};
+
+constexpr folly::StringPiece kMetricArbitratorRequestsCount{
+    "velox.arbitrator_requests_count"};
+
+constexpr folly::StringPiece kMetricMappedMemoryBytes{
+    "velox.memory_allocator_mapped_bytes"};
+
+constexpr folly::StringPiece kMetricAllocatedMemoryBytes{
+    "velox.memory_allocator_alloc_bytes"};
+
+constexpr folly::StringPiece kMetricMmapExternalMappedBytes{
+    "velox.mmap_allocator_external_mapped_bytes"};
+
+constexpr folly::StringPiece kMetricMmapDelegatedAllocBytes{
+    "velox.mmap_allocator_delegated_alloc_bytes"};
+
+constexpr folly::StringPiece kMetricCacheMaxAgeSecs{"velox.cache_max_age_secs"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumEntries{
+    "velox.memory_cache_num_entries"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumEmptyEntries{
+    "velox.memory_cache_num_empty_entries"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumSharedEntries{
+    "velox.memory_cache_num_shared_entries"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumExclusiveEntries{
+    "velox.memory_cache_num_exclusive_entries"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumPrefetchedEntries{
+    "velox.memory_cache_num_prefetched_entries"};
+
+constexpr folly::StringPiece kMetricMemoryCacheTotalTinyBytes{
+    "velox.memory_cache_total_tiny_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryCacheTotalLargeBytes{
+    "velox.memory_cache_total_large_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryCacheTotalTinyPaddingBytes{
+    "velox.memory_cache_total_tiny_padding_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryCacheTotalLargePaddingBytes{
+    "velox.memory_cache_total_large_padding_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryCacheTotalPrefetchBytes{
+    "velox.memory_cache_total_prefetched_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryCacheSumEvictScore{
+    "velox.memory_cache_sum_evict_score"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumHits{
+    "velox.memory_cache_num_hits"};
+
+constexpr folly::StringPiece kMetricMemoryCacheHitBytes{
+    "velox.memory_cache_hit_bytes"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumNew{
+    "velox.memory_cache_num_new"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumEvicts{
+    "velox.memory_cache_num_evicts"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumSavableEvicts{
+    "velox.memory_cache_num_savable_evicts"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumEvictChecks{
+    "velox.memory_cache_num_evict_checks"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumWaitExclusive{
+    "velox.memory_cache_num_wait_exclusive"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumAllocClocks{
+    "velox.memory_cache_num_alloc_clocks"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumAgedOutEntries{
+    "velox.memory_cache_num_aged_out_entries"};
+
+constexpr folly::StringPiece kMetricMemoryCacheNumStaleEntries{
+    "velox.memory_cache_num_stale_entries"};
+
+constexpr folly::StringPiece kMetricSsdCacheCachedRegions{
+    "velox.ssd_cache_cached_regions"};
+
+constexpr folly::StringPiece kMetricSsdCacheCachedEntries{
+    "velox.ssd_cache_cached_entries"};
+
+constexpr folly::StringPiece kMetricSsdCacheCachedBytes{
+    "velox.ssd_cache_cached_bytes"};
+
+constexpr folly::StringPiece kMetricSsdCacheReadEntries{
+    "velox.ssd_cache_read_entries"};
+
+constexpr folly::StringPiece kMetricSsdCacheReadBytes{
+    "velox.ssd_cache_read_bytes"};
+
+constexpr folly::StringPiece kMetricSsdCacheWrittenEntries{
+    "velox.ssd_cache_written_entries"};
+
+constexpr folly::StringPiece kMetricSsdCacheWrittenBytes{
+    "velox.ssd_cache_written_bytes"};
+
+constexpr folly::StringPiece kMetricSsdCacheAgedOutEntries{
+    "velox.ssd_cache_aged_out_entries"};
+
+constexpr folly::StringPiece kMetricSsdCacheAgedOutRegions{
+    "velox.ssd_cache_aged_out_regions"};
+
+constexpr folly::StringPiece kMetricSsdCacheOpenSsdErrors{
+    "velox.ssd_cache_open_ssd_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheOpenCheckpointErrors{
+    "velox.ssd_cache_open_checkpoint_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheOpenLogErrors{
+    "velox.ssd_cache_open_log_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheDeleteCheckpointErrors{
+    "velox.ssd_cache_delete_checkpoint_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheGrowFileErrors{
+    "velox.ssd_cache_grow_file_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheWriteSsdErrors{
+    "velox.ssd_cache_write_ssd_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheWriteSsdDropped{
+    "velox.ssd_cache_write_ssd_dropped"};
+
+constexpr folly::StringPiece kMetricSsdCacheWriteCheckpointErrors{
+    "velox.ssd_cache_write_checkpoint_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheReadCorruptions{
+    "velox.ssd_cache_read_corruptions"};
+
+constexpr folly::StringPiece kMetricSsdCacheReadSsdErrors{
+    "velox.ssd_cache_read_ssd_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheReadCheckpointErrors{
+    "velox.ssd_cache_read_checkpoint_errors"};
+
+constexpr folly::StringPiece kMetricSsdCacheReadWithoutChecksum{
+    "velox.ssd_cache_read_without_checksum"};
+
+constexpr folly::StringPiece kMetricSsdCacheCheckpointsRead{
+    "velox.ssd_cache_checkpoints_read"};
+
+constexpr folly::StringPiece kMetricSsdCacheCheckpointsWritten{
+    "velox.ssd_cache_checkpoints_written"};
+
+constexpr folly::StringPiece kMetricSsdCacheRegionsEvicted{
+    "velox.ssd_cache_regions_evicted"};
+
+constexpr folly::StringPiece kMetricSsdCacheRecoveredEntries{
+    "velox.ssd_cache_recovered_entries"};
+
+constexpr folly::StringPiece kMetricExchangeDataTimeMs{
+    "velox.exchange_data_time_ms"};
+
+constexpr folly::StringPiece kMetricExchangeDataBytes{
+    "velox.exchange_data_bytes"};
+
+constexpr folly::StringPiece kMetricExchangeDataSize{
+    "velox.exchange_data_size"};
+
+constexpr folly::StringPiece kMetricExchangeDataCount{
+    "velox.exchange_data_count"};
+
+constexpr folly::StringPiece kMetricExchangeDataSizeTimeMs{
+    "velox.exchange_data_size_time_ms"};
+
+constexpr folly::StringPiece kMetricExchangeDataSizeCount{
+    "velox.exchange_data_size_count"};
+
+constexpr folly::StringPiece kMetricStorageThrottledDurationMs{
+    "velox.storage_throttled_duration_ms"};
+
+constexpr folly::StringPiece kMetricStorageLocalThrottled{
+    "velox.storage_local_throttled_count"};
+
+constexpr folly::StringPiece kMetricStorageGlobalThrottled{
+    "velox.storage_global_throttled_count"};
 } // namespace facebook::velox
diff --git a/velox/common/base/Doubles.h b/velox/common/base/Doubles.h
new file mode 100644
index 0000000000000..d400d92ba1885
--- /dev/null
+++ b/velox/common/base/Doubles.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace facebook::velox {
+
+/// Comparing double against int64:max() like the following would get compile
+/// time error on some compilers(e.g. clang 12 and above):
+///
+/// ```
+/// double_value <= int64::max()
+/// double_value >= int64::max()
+/// ```
+///
+/// Here `int64::max()` will be implicitly converted to double, but due to the
+/// floating point nature of double, converting `int64::max()` to double lose
+/// precision(see [1]), so instead of comparing double with int64:max(), we
+/// suggest compare it with the max double value below int64:max() 2 ^ 63 -
+/// 1024 for < or <=, 2 ^ 63 for >, >=.
+///
+/// [1].https://en.wikipedia.org/wiki/Double-precision_floating-point_format#Precision_limitations_on_integer_values
+
+/// 2 ^ 63 - 1024
+constexpr double kMaxDoubleBelowInt64Max = 9223372036854774784.0;
+/// 2 ^ 63
+constexpr double kMinDoubleAboveInt64Max = 9223372036854775808.0;
+
+/// For int128::max()
+///  2 ^ 127 - 2 ^ 74
+constexpr double kMaxDoubleBelowInt128Max =
+    170141183460469212842221372237303250944.0;
+} // namespace facebook::velox
diff --git a/velox/common/base/Exceptions.cpp b/velox/common/base/Exceptions.cpp
index 62a28388496c6..0d6e65b1d76c2 100644
--- a/velox/common/base/Exceptions.cpp
+++ b/velox/common/base/Exceptions.cpp
@@ -16,13 +16,9 @@
 
 #include "velox/common/base/Exceptions.h"
 
-namespace facebook {
-namespace velox {
-namespace detail {
+namespace facebook::velox::detail {
 
 DEFINE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxRuntimeError);
 DEFINE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxUserError);
 
-} // namespace detail
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::detail
diff --git a/velox/common/base/Exceptions.h b/velox/common/base/Exceptions.h
index 1a96c5e59da5f..47aedd2af7b7a 100644
--- a/velox/common/base/Exceptions.h
+++ b/velox/common/base/Exceptions.h
@@ -21,15 +21,12 @@
 
 #include <fmt/format.h>
 #include <fmt/ostream.h>
-#include <glog/logging.h>
-
-#include <folly/Conv.h>
-#include <folly/Exception.h>
 #include <folly/Preprocessor.h>
+
+#include "velox/common/base/FmtStdFormatters.h"
 #include "velox/common/base/VeloxException.h"
 
-namespace facebook {
-namespace velox {
+namespace facebook::velox {
 namespace detail {
 
 struct VeloxCheckFailArgs {
@@ -157,15 +154,15 @@ std::string errorMessage(fmt::string_view fmt, const Args&... args) {
 } // namespace detail
 
 #define _VELOX_THROW_IMPL(                                               \
-    exception, expr_str, errorSource, errorCode, isRetriable, ...)       \
-  {                                                                      \
+    exception, exprStr, errorSource, errorCode, isRetriable, ...)        \
+  do {                                                                   \
     /* GCC 9.2.1 doesn't accept this code with constexpr. */             \
     static const ::facebook::velox::detail::VeloxCheckFailArgs           \
         veloxCheckFailArgs = {                                           \
             __FILE__,                                                    \
             __LINE__,                                                    \
             __FUNCTION__,                                                \
-            expr_str,                                                    \
+            exprStr,                                                     \
             errorSource,                                                 \
             errorCode,                                                   \
             isRetriable};                                                \
@@ -174,35 +171,53 @@ std::string errorMessage(fmt::string_view fmt, const Args&... args) {
         exception,                                                       \
         typename ::facebook::velox::detail::VeloxCheckFailStringType<    \
             decltype(message)>::type>(veloxCheckFailArgs, message);      \
-  }
-
-#define _VELOX_CHECK_AND_THROW_IMPL(                                     \
-    expr, expr_str, exception, errorSource, errorCode, isRetriable, ...) \
-  if (UNLIKELY(!(expr))) {                                               \
-    _VELOX_THROW_IMPL(                                                   \
-        exception,                                                       \
-        expr_str,                                                        \
-        errorSource,                                                     \
-        errorCode,                                                       \
-        isRetriable,                                                     \
-        __VA_ARGS__);                                                    \
-  }
+  } while (0)
+
+#define _VELOX_CHECK_AND_THROW_IMPL(                                    \
+    expr, exprStr, exception, errorSource, errorCode, isRetriable, ...) \
+  do {                                                                  \
+    if (UNLIKELY(!(expr))) {                                            \
+      _VELOX_THROW_IMPL(                                                \
+          exception,                                                    \
+          exprStr,                                                      \
+          errorSource,                                                  \
+          errorCode,                                                    \
+          isRetriable,                                                  \
+          __VA_ARGS__);                                                 \
+    }                                                                   \
+  } while (0)
 
 #define _VELOX_THROW(exception, ...) \
   _VELOX_THROW_IMPL(exception, "", ##__VA_ARGS__)
 
 DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxRuntimeError);
 
-#define _VELOX_CHECK_IMPL(expr, expr_str, ...)                      \
+#define _VELOX_CHECK_IMPL(expr, exprStr, ...)                       \
   _VELOX_CHECK_AND_THROW_IMPL(                                      \
       expr,                                                         \
-      expr_str,                                                     \
+      exprStr,                                                      \
       ::facebook::velox::VeloxRuntimeError,                         \
       ::facebook::velox::error_source::kErrorSourceRuntime.c_str(), \
       ::facebook::velox::error_code::kInvalidState.c_str(),         \
       /* isRetriable */ false,                                      \
       ##__VA_ARGS__)
 
+/// Throws VeloxRuntimeError when functions receive input values out of the
+/// supported range. This should only be used when we want to force TRY() to not
+/// suppress the error.
+#define VELOX_CHECK_UNSUPPORTED_INPUT_UNCATCHABLE(expr, ...)                   \
+  do {                                                                         \
+    if (UNLIKELY(!(expr))) {                                                   \
+      _VELOX_THROW_IMPL(                                                       \
+          ::facebook::velox::VeloxRuntimeError,                                \
+          #expr,                                                               \
+          ::facebook::velox::error_source::kErrorSourceRuntime.c_str(),        \
+          ::facebook::velox::error_code::kUnsupportedInputUncatchable.c_str(), \
+          /* isRetriable */ false,                                             \
+          __VA_ARGS__);                                                        \
+    }                                                                          \
+  } while (0)
+
 // If the caller passes a custom message (4 *or more* arguments), we
 // have to construct a format string from ours ("({} vs. {})") plus
 // theirs by adding a space and shuffling arguments. If they don't (exactly 3
@@ -220,25 +235,27 @@ DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxRuntimeError);
       ##__VA_ARGS__)
 
 #define _VELOX_CHECK_OP_HELPER(implmacro, expr1, expr2, op, ...) \
-  if constexpr (FOLLY_PP_DETAIL_NARGS(__VA_ARGS__) > 0) {        \
-    _VELOX_CHECK_OP_WITH_USER_FMT_HELPER(                        \
-        implmacro, expr1, expr2, op, __VA_ARGS__);               \
-  } else {                                                       \
-    implmacro(                                                   \
-        (expr1)op(expr2),                                        \
-        #expr1 " " #op " " #expr2,                               \
-        "({} vs. {})",                                           \
-        expr1,                                                   \
-        expr2);                                                  \
-  }
+  do {                                                           \
+    if constexpr (FOLLY_PP_DETAIL_NARGS(__VA_ARGS__) > 0) {      \
+      _VELOX_CHECK_OP_WITH_USER_FMT_HELPER(                      \
+          implmacro, expr1, expr2, op, __VA_ARGS__);             \
+    } else {                                                     \
+      implmacro(                                                 \
+          (expr1)op(expr2),                                      \
+          #expr1 " " #op " " #expr2,                             \
+          "({} vs. {})",                                         \
+          expr1,                                                 \
+          expr2);                                                \
+    }                                                            \
+  } while (0)
 
 #define _VELOX_CHECK_OP(expr1, expr2, op, ...) \
   _VELOX_CHECK_OP_HELPER(_VELOX_CHECK_IMPL, expr1, expr2, op, ##__VA_ARGS__)
 
-#define _VELOX_USER_CHECK_IMPL(expr, expr_str, ...)              \
+#define _VELOX_USER_CHECK_IMPL(expr, exprStr, ...)               \
   _VELOX_CHECK_AND_THROW_IMPL(                                   \
       expr,                                                      \
-      expr_str,                                                  \
+      exprStr,                                                   \
       ::facebook::velox::VeloxUserError,                         \
       ::facebook::velox::error_source::kErrorSourceUser.c_str(), \
       ::facebook::velox::error_code::kInvalidArgument.c_str(),   \
@@ -261,6 +278,12 @@ DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxRuntimeError);
 #define VELOX_CHECK_NULL(e, ...) VELOX_CHECK(e == nullptr, ##__VA_ARGS__)
 #define VELOX_CHECK_NOT_NULL(e, ...) VELOX_CHECK(e != nullptr, ##__VA_ARGS__)
 
+#define VELOX_CHECK_OK(expr)                          \
+  do {                                                \
+    ::facebook::velox::Status _s = (expr);            \
+    _VELOX_CHECK_IMPL(_s.ok(), #expr, _s.toString()); \
+  } while (false)
+
 #define VELOX_UNSUPPORTED(...)                                   \
   _VELOX_THROW(                                                  \
       ::facebook::velox::VeloxUserError,                         \
@@ -285,6 +308,14 @@ DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxRuntimeError);
       /* isRetriable */ false,                                   \
       ##__VA_ARGS__)
 
+#define VELOX_FILE_NOT_FOUND_ERROR(...)                             \
+  _VELOX_THROW(                                                     \
+      ::facebook::velox::VeloxRuntimeError,                         \
+      ::facebook::velox::error_source::kErrorSourceRuntime.c_str(), \
+      ::facebook::velox::error_code::kFileNotFound.c_str(),         \
+      /* isRetriable */ false,                                      \
+      ##__VA_ARGS__)
+
 #define VELOX_UNREACHABLE(...)                                      \
   _VELOX_THROW(                                                     \
       ::facebook::velox::VeloxRuntimeError,                         \
@@ -311,6 +342,7 @@ DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxRuntimeError);
 #define VELOX_DCHECK_LE(e1, e2, ...) VELOX_CHECK(true)
 #define VELOX_DCHECK_EQ(e1, e2, ...) VELOX_CHECK(true)
 #define VELOX_DCHECK_NE(e1, e2, ...) VELOX_CHECK(true)
+#define VELOX_DCHECK_NULL(e, ...) VELOX_CHECK(true)
 #define VELOX_DCHECK_NOT_NULL(e, ...) VELOX_CHECK(true)
 #endif
 
@@ -322,6 +354,17 @@ DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxRuntimeError);
       /* isRetriable */ false,                                      \
       ##__VA_ARGS__)
 
+/// Throws VeloxRuntimeError when functions receive input values out of the
+/// supported range. This should only be used when we want to force TRY() to not
+/// suppress the error.
+#define VELOX_FAIL_UNSUPPORTED_INPUT_UNCATCHABLE(...)                      \
+  _VELOX_THROW(                                                            \
+      ::facebook::velox::VeloxRuntimeError,                                \
+      ::facebook::velox::error_source::kErrorSourceRuntime.c_str(),        \
+      ::facebook::velox::error_code::kUnsupportedInputUncatchable.c_str(), \
+      /* isRetriable */ false,                                             \
+      ##__VA_ARGS__)
+
 DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxUserError);
 
 // For all below macros, an additional message can be passed using a
@@ -390,5 +433,4 @@ DECLARE_CHECK_FAIL_TEMPLATES(::facebook::velox::VeloxUserError);
       /* isRetriable */ false,                                      \
       ##__VA_ARGS__)
 
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox
diff --git a/velox/common/base/FmtStdFormatters.h b/velox/common/base/FmtStdFormatters.h
new file mode 100644
index 0000000000000..90784d8ce461a
--- /dev/null
+++ b/velox/common/base/FmtStdFormatters.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <fmt/format.h>
+#if FMT_VERSION >= 100100
+#include <fmt/std.h>
+#endif
+
+#include <atomic>
+#include <bitset>
+#include <string_view>
+#include <system_error>
+#include <type_traits>
+#include <vector>
+
+template <typename Char>
+struct fmt::formatter<std::errc, Char>
+    : formatter<std::underlying_type<std::errc>::type, Char> {
+  template <typename FormatContext>
+  auto format(std::errc v, FormatContext& ctx) const -> decltype(ctx.out()) {
+    using underlying_type = std::underlying_type<std::errc>::type;
+    return formatter<underlying_type, Char>::format(
+        static_cast<underlying_type>(v), ctx);
+  }
+};
+
+#if FMT_VERSION < 100100
+// This should be 100101 but FMT_VERSION was not bumped in 10.1.1
+// but under a month has passed since 10.1.0 release so we can assume 10.1.1
+//
+// Backport from fmt 10.1.1 see fmtlib/fmt#3574
+// Formats std::atomic
+template <typename T, typename Char>
+struct fmt::formatter<
+    std::atomic<T>,
+    Char,
+    std::enable_if_t<fmt::is_formattable<T, Char>::value>>
+    : formatter<T, Char> {
+  template <typename FormatContext>
+  auto format(const std::atomic<T>& v, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return formatter<T, Char>::format(v.load(), ctx);
+  }
+};
+#endif
+
+#if FMT_VERSION < 100100
+// Backport from fmt 10.1 see fmtlib/fmt#3570
+// Formats std::vector<bool>
+namespace fmt::detail {
+template <typename T, typename Enable = void>
+struct has_flip : std::false_type {};
+
+template <typename T>
+struct has_flip<T, std::void_t<decltype(std::declval<T>().flip())>>
+    : std::true_type {};
+
+template <typename T>
+struct is_bit_reference_like {
+  static constexpr const bool value = std::is_convertible<T, bool>::value &&
+      std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
+};
+
+#ifdef _LIBCPP_VERSION
+
+// Workaround for libc++ incompatibility with C++ standard.
+// According to the Standard, `bitset::operator[] const` returns bool.
+template <typename C>
+struct is_bit_reference_like<std::__bit_const_reference<C>> {
+  static constexpr const bool value = true;
+};
+
+#endif
+} // namespace fmt::detail
+
+// We can't use std::vector<bool, Allocator>::reference and
+// std::bitset<N>::reference because the compiler can't deduce Allocator and N
+// in partial specialization.
+template <typename BitRef, typename Char>
+struct fmt::formatter<
+    BitRef,
+    Char,
+    std::enable_if_t<fmt::detail::is_bit_reference_like<BitRef>::value>>
+    : formatter<bool, Char> {
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return formatter<bool, Char>::format(v, ctx);
+  }
+};
+#endif
diff --git a/velox/common/base/Fs.cpp b/velox/common/base/Fs.cpp
index 82c748fae843a..bbea7b77878ba 100644
--- a/velox/common/base/Fs.cpp
+++ b/velox/common/base/Fs.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/base/Fs.h"
+
 #include <fmt/format.h>
 #include <glog/logging.h>
 
diff --git a/velox/common/base/Macros.h b/velox/common/base/Macros.h
index 03e45f7ce1f94..48bc0f38dcdfc 100644
--- a/velox/common/base/Macros.h
+++ b/velox/common/base/Macros.h
@@ -18,19 +18,13 @@
 
 // Macros to disable deprecation warnings
 #ifdef __clang__
-#define VELOX_SUPPRESS_DEPRECATION_WARNING \
-  _Pragma("clang diagnostic push");        \
-  _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
-#define VELOX_UNSUPPRESS_DEPRECATION_WARNING _Pragma("clang diagnostic pop");
-#define VELOX_SUPPRESS_RETURN_LOCAL_ADDR_WARNING
-#define VELOX_UNSUPPRESS_RETURN_LOCAL_ADDR_WARNING
+#define VELOX_SUPPRESS_STRINGOP_OVERFLOW_WARNING
+#define VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
 #else
-#define VELOX_SUPPRESS_DEPRECATION_WARNING
-#define VELOX_UNSUPPRESS_DEPRECATION_WARNING
-#define VELOX_SUPPRESS_RETURN_LOCAL_ADDR_WARNING \
+#define VELOX_SUPPRESS_STRINGOP_OVERFLOW_WARNING \
   _Pragma("GCC diagnostic push");                \
-  _Pragma("GCC diagnostic ignored \"-Wreturn-local-addr\"")
-#define VELOX_UNSUPPRESS_RETURN_LOCAL_ADDR_WARNING \
+  _Pragma("GCC diagnostic ignored \"-Wstringop-overflow\"")
+#define VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING \
   _Pragma("GCC diagnostic pop");
 #endif
 
diff --git a/velox/common/base/PeriodicStatsReporter.cpp b/velox/common/base/PeriodicStatsReporter.cpp
new file mode 100644
index 0000000000000..5bd8781a6b083
--- /dev/null
+++ b/velox/common/base/PeriodicStatsReporter.cpp
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/PeriodicStatsReporter.h"
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/caching/CacheTTLController.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/common/memory/MmapAllocator.h"
+
+namespace facebook::velox {
+
+namespace {
+#define REPORT_IF_NOT_ZERO(name, counter)   \
+  if ((counter) != 0) {                     \
+    RECORD_METRIC_VALUE((name), (counter)); \
+  }
+
+std::mutex& instanceMutex() {
+  static std::mutex instanceMu;
+  return instanceMu;
+}
+
+// Global instance. Must be called while holding a lock over instanceMutex().
+std::unique_ptr<PeriodicStatsReporter>& instance() {
+  static std::unique_ptr<PeriodicStatsReporter> reporter;
+  return reporter;
+}
+} // namespace
+
+void startPeriodicStatsReporter(const PeriodicStatsReporter::Options& options) {
+  std::lock_guard<std::mutex> l(instanceMutex());
+  auto& instanceRef = instance();
+  VELOX_CHECK_NULL(
+      instanceRef, "The periodic stats reporter has already started.");
+  instanceRef = std::make_unique<PeriodicStatsReporter>(options);
+  instanceRef->start();
+}
+
+void stopPeriodicStatsReporter() {
+  std::lock_guard<std::mutex> l(instanceMutex());
+  auto& instanceRef = instance();
+  VELOX_CHECK_NOT_NULL(instanceRef, "No periodic stats reporter to stop.");
+  instanceRef->stop();
+  instanceRef.reset();
+}
+
+PeriodicStatsReporter::PeriodicStatsReporter(const Options& options)
+    : allocator_(options.allocator),
+      cache_(options.cache),
+      arbitrator_(options.arbitrator),
+      spillMemoryPool_(options.spillMemoryPool),
+      options_(options) {}
+
+void PeriodicStatsReporter::start() {
+  LOG(INFO) << "Starting PeriodicStatsReporter with options "
+            << options_.toString();
+  addTask(
+      "report_allocator_stats",
+      [this]() { reportAllocatorStats(); },
+      options_.allocatorStatsIntervalMs);
+  addTask(
+      "report_cache_stats",
+      [this]() { reportCacheStats(); },
+      options_.cacheStatsIntervalMs);
+  addTask(
+      "report_arbitrator_stats",
+      [this]() { reportArbitratorStats(); },
+      options_.arbitratorStatsIntervalMs);
+  addTask(
+      "report_spill_stats",
+      [this]() { reportSpillStats(); },
+      options_.spillStatsIntervalMs);
+}
+
+void PeriodicStatsReporter::stop() {
+  LOG(INFO) << "Stopping PeriodicStatsReporter";
+  scheduler_.stop();
+}
+
+void PeriodicStatsReporter::reportArbitratorStats() {
+  if (arbitrator_ == nullptr) {
+    return;
+  }
+
+  const auto stats = arbitrator_->stats();
+  RECORD_METRIC_VALUE(
+      kMetricArbitratorFreeCapacityBytes,
+      stats.freeCapacityBytes + stats.freeReservedCapacityBytes);
+  RECORD_METRIC_VALUE(
+      kMetricArbitratorFreeReservedCapacityBytes,
+      stats.freeReservedCapacityBytes);
+}
+
+void PeriodicStatsReporter::reportAllocatorStats() {
+  if (allocator_ == nullptr) {
+    return;
+  }
+  RECORD_METRIC_VALUE(
+      kMetricMappedMemoryBytes,
+      (velox::memory::AllocationTraits::pageBytes(allocator_->numMapped())));
+  RECORD_METRIC_VALUE(
+      kMetricAllocatedMemoryBytes,
+      (velox::memory::AllocationTraits::pageBytes(allocator_->numAllocated())));
+  // TODO(jtan6): Remove condition after T150019700 is done
+  if (auto* mmapAllocator =
+          dynamic_cast<const velox::memory::MmapAllocator*>(allocator_)) {
+    RECORD_METRIC_VALUE(
+        kMetricMmapDelegatedAllocBytes, (mmapAllocator->numMallocBytes()));
+    RECORD_METRIC_VALUE(
+        kMetricMmapExternalMappedBytes,
+        velox::memory::AllocationTraits::pageBytes(
+            (mmapAllocator->numExternalMapped())));
+  }
+  // TODO(xiaoxmeng): add memory allocation size stats.
+}
+
+void PeriodicStatsReporter::reportCacheStats() {
+  if (cache_ == nullptr) {
+    return;
+  }
+  const auto cacheStats = cache_->refreshStats();
+
+  // Memory cache snapshot stats.
+  RECORD_METRIC_VALUE(kMetricMemoryCacheNumEntries, cacheStats.numEntries);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheNumEmptyEntries, cacheStats.numEmptyEntries);
+  RECORD_METRIC_VALUE(kMetricMemoryCacheNumSharedEntries, cacheStats.numShared);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheNumExclusiveEntries, cacheStats.numExclusive);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheNumPrefetchedEntries, cacheStats.numPrefetch);
+  RECORD_METRIC_VALUE(kMetricMemoryCacheTotalTinyBytes, cacheStats.tinySize);
+  RECORD_METRIC_VALUE(kMetricMemoryCacheTotalLargeBytes, cacheStats.largeSize);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheTotalTinyPaddingBytes, cacheStats.tinyPadding);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheTotalLargePaddingBytes, cacheStats.largePadding);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheTotalPrefetchBytes, cacheStats.prefetchBytes);
+
+  // Memory cache cumulative stats.
+  const auto deltaCacheStats = cacheStats - lastCacheStats_;
+
+  REPORT_IF_NOT_ZERO(kMetricMemoryCacheNumHits, deltaCacheStats.numHit);
+  REPORT_IF_NOT_ZERO(kMetricMemoryCacheHitBytes, deltaCacheStats.hitBytes);
+  REPORT_IF_NOT_ZERO(kMetricMemoryCacheNumNew, deltaCacheStats.numNew);
+  REPORT_IF_NOT_ZERO(kMetricMemoryCacheNumEvicts, deltaCacheStats.numEvict);
+  REPORT_IF_NOT_ZERO(
+      kMetricMemoryCacheNumSavableEvicts, deltaCacheStats.numSavableEvict);
+  REPORT_IF_NOT_ZERO(
+      kMetricMemoryCacheNumEvictChecks, deltaCacheStats.numEvictChecks);
+  REPORT_IF_NOT_ZERO(
+      kMetricMemoryCacheNumWaitExclusive, deltaCacheStats.numWaitExclusive);
+  REPORT_IF_NOT_ZERO(
+      kMetricMemoryCacheNumAllocClocks, deltaCacheStats.allocClocks);
+  REPORT_IF_NOT_ZERO(
+      kMetricMemoryCacheNumAgedOutEntries, deltaCacheStats.numAgedOut);
+  REPORT_IF_NOT_ZERO(
+      kMetricMemoryCacheSumEvictScore, deltaCacheStats.sumEvictScore);
+
+  // SSD cache snapshot stats.
+  if (cacheStats.ssdStats != nullptr) {
+    RECORD_METRIC_VALUE(
+        kMetricSsdCacheCachedEntries, cacheStats.ssdStats->entriesCached);
+    RECORD_METRIC_VALUE(
+        kMetricSsdCacheCachedRegions, cacheStats.ssdStats->regionsCached);
+    RECORD_METRIC_VALUE(
+        kMetricSsdCacheCachedBytes, cacheStats.ssdStats->bytesCached);
+  }
+
+  // SSD cache cumulative stats.
+  if (deltaCacheStats.ssdStats != nullptr) {
+    const auto deltaSsdStats = *deltaCacheStats.ssdStats;
+    REPORT_IF_NOT_ZERO(kMetricSsdCacheReadEntries, deltaSsdStats.entriesRead)
+    REPORT_IF_NOT_ZERO(kMetricSsdCacheReadBytes, deltaSsdStats.bytesRead);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheWrittenEntries, deltaSsdStats.entriesWritten);
+    REPORT_IF_NOT_ZERO(kMetricSsdCacheWrittenBytes, deltaSsdStats.bytesWritten);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheOpenSsdErrors, deltaSsdStats.openFileErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheOpenCheckpointErrors,
+        deltaSsdStats.openCheckpointErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheOpenLogErrors, deltaSsdStats.openLogErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheDeleteCheckpointErrors,
+        deltaSsdStats.deleteCheckpointErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheGrowFileErrors, deltaSsdStats.growFileErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheWriteSsdErrors, deltaSsdStats.writeSsdErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheWriteSsdDropped, deltaSsdStats.writeSsdDropped);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheWriteCheckpointErrors,
+        deltaSsdStats.writeCheckpointErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheReadSsdErrors, deltaSsdStats.readSsdErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheReadCorruptions, deltaSsdStats.readSsdCorruptions);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheReadCheckpointErrors,
+        deltaSsdStats.readCheckpointErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheCheckpointsRead, deltaSsdStats.checkpointsRead);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheCheckpointsWritten, deltaSsdStats.checkpointsWritten);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheRegionsEvicted, deltaSsdStats.regionsEvicted);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheAgedOutEntries, deltaSsdStats.entriesAgedOut)
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheAgedOutRegions, deltaSsdStats.regionsAgedOut);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheReadWithoutChecksum,
+        deltaSsdStats.readWithoutChecksumChecks);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheRecoveredEntries, deltaSsdStats.entriesRecovered);
+  }
+
+  // TTL controler snapshot stats.
+  if (auto* cacheTTLController =
+          velox::cache::CacheTTLController::getInstance()) {
+    RECORD_METRIC_VALUE(
+        kMetricCacheMaxAgeSecs,
+        cacheTTLController->getCacheAgeStats().maxAgeSecs);
+  }
+
+  lastCacheStats_ = cacheStats;
+}
+
+void PeriodicStatsReporter::reportSpillStats() {
+  if (spillMemoryPool_ == nullptr) {
+    return;
+  }
+  const auto spillMemoryStats = spillMemoryPool_->stats();
+  LOG(INFO) << "Spill memory usage: current["
+            << velox::succinctBytes(spillMemoryStats.usedBytes) << "] peak["
+            << velox::succinctBytes(spillMemoryStats.peakBytes) << "]";
+  RECORD_METRIC_VALUE(kMetricSpillMemoryBytes, spillMemoryStats.usedBytes);
+  RECORD_METRIC_VALUE(kMetricSpillPeakMemoryBytes, spillMemoryStats.peakBytes);
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/base/PeriodicStatsReporter.h b/velox/common/base/PeriodicStatsReporter.h
new file mode 100644
index 0000000000000..a902f3de8222b
--- /dev/null
+++ b/velox/common/base/PeriodicStatsReporter.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/experimental/ThreadedRepeatingFunctionRunner.h>
+#include "velox/common/caching/AsyncDataCache.h"
+#include "velox/common/caching/SsdFile.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+
+namespace folly {
+class CPUThreadPoolExecutor;
+}
+
+namespace facebook::velox {
+
+namespace memory {
+class MemoryAllocator;
+}
+
+namespace cache {
+class AsyncDataCache;
+}
+
+/// Manages a background daemon thread to report stats through 'StatsReporter'.
+class PeriodicStatsReporter {
+ public:
+  struct Options {
+    Options() {}
+
+    const velox::memory::MemoryAllocator* allocator{nullptr};
+    uint64_t allocatorStatsIntervalMs{2'000};
+
+    const velox::cache::AsyncDataCache* cache{nullptr};
+    uint64_t cacheStatsIntervalMs{60'000};
+
+    const memory::MemoryArbitrator* arbitrator{nullptr};
+    uint64_t arbitratorStatsIntervalMs{60'000};
+
+    const memory::MemoryPool* spillMemoryPool{nullptr};
+    uint64_t spillStatsIntervalMs{60'000};
+
+    std::string toString() const {
+      return fmt::format(
+          "allocatorStatsIntervalMs:{}, cacheStatsIntervalMs:{}, "
+          "arbitratorStatsIntervalMs:{}, spillStatsIntervalMs:{}",
+          allocatorStatsIntervalMs,
+          cacheStatsIntervalMs,
+          arbitratorStatsIntervalMs,
+          spillStatsIntervalMs);
+    }
+  };
+
+  PeriodicStatsReporter(const Options& options = Options());
+
+  /// Invoked to start the report daemon in background.
+  void start();
+
+  /// Invoked to stop the report daemon in background.
+  void stop();
+
+ private:
+  // Add a task to run periodically.
+  template <typename TFunc>
+  void addTask(const std::string& taskName, TFunc&& func, size_t intervalMs) {
+    scheduler_.add(
+        taskName,
+        [taskName,
+         intervalMs,
+         func = std::forward<TFunc>(func)]() mutable noexcept {
+          try {
+            func();
+          } catch (const std::exception& e) {
+            LOG(ERROR) << "Error running periodic task " << taskName << ": "
+                       << e.what();
+          }
+          return std::chrono::milliseconds(intervalMs);
+        });
+  }
+
+  void reportCacheStats();
+  void reportAllocatorStats();
+  void reportArbitratorStats();
+  void reportSpillStats();
+
+  const velox::memory::MemoryAllocator* const allocator_{nullptr};
+  const velox::cache::AsyncDataCache* const cache_{nullptr};
+  const velox::memory::MemoryArbitrator* const arbitrator_{nullptr};
+  const velox::memory::MemoryPool* const spillMemoryPool_{nullptr};
+  const Options options_;
+
+  cache::CacheStats lastCacheStats_;
+
+  folly::ThreadedRepeatingFunctionRunner scheduler_;
+};
+
+/// Initializes and starts the process-wide periodic stats reporter. Before
+/// 'stopPeriodicStatsReporter()' is called, this method can only be called once
+/// process-wide, and additional calls to this method will throw.
+void startPeriodicStatsReporter(const PeriodicStatsReporter::Options& options);
+
+/// Stops the process-wide periodic stats reporter.
+void stopPeriodicStatsReporter();
+
+} // namespace facebook::velox
diff --git a/velox/common/base/Pointers.h b/velox/common/base/Pointers.h
new file mode 100644
index 0000000000000..50eb1bf0b2634
--- /dev/null
+++ b/velox/common/base/Pointers.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox {
+
+/// Used to dynamically cast a unique pointer from 'SourceType' to
+/// 'DestinationType'. The raw object is moved from 'srcPtr' to 'dstPtr' on
+/// success. The function throws if the cast fails, and the raw object is also
+/// freed.
+template <typename SourceType, typename DestinationType>
+inline void castUniquePointer(
+    std::unique_ptr<SourceType>&& srcPtr,
+    std::unique_ptr<DestinationType>& dstPtr) {
+  auto* rawSrcPtr = srcPtr.release();
+  VELOX_CHECK_NOT_NULL(rawSrcPtr);
+  try {
+    auto* rawDstPtr = dynamic_cast<DestinationType*>(rawSrcPtr);
+    VELOX_CHECK_NOT_NULL(rawDstPtr);
+    dstPtr.reset(rawDstPtr);
+  } catch (const std::exception& e) {
+    srcPtr.reset(rawSrcPtr);
+    throw;
+  }
+}
+} // namespace facebook::velox
diff --git a/velox/common/base/PrefixSortConfig.h b/velox/common/base/PrefixSortConfig.h
new file mode 100644
index 0000000000000..34adee1b7914a
--- /dev/null
+++ b/velox/common/base/PrefixSortConfig.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+namespace facebook::velox::common {
+
+/// Specifies the config for prefix-sort.
+struct PrefixSortConfig {
+  explicit PrefixSortConfig(
+      int64_t maxNormalizedKeySize,
+      int32_t threshold = 130)
+      : maxNormalizedKeySize(maxNormalizedKeySize), threshold(threshold) {}
+
+  /// Max number of bytes can store normalized keys in prefix-sort buffer per
+  /// entry.
+  const int64_t maxNormalizedKeySize;
+
+  /// PrefixSort will have performance regression when the dateset is too small.
+  const int32_t threshold;
+};
+} // namespace facebook::velox::common
diff --git a/velox/common/base/RandomUtil.cpp b/velox/common/base/RandomUtil.cpp
index 7353109e263d7..5fe3dcf765989 100644
--- a/velox/common/base/RandomUtil.cpp
+++ b/velox/common/base/RandomUtil.cpp
@@ -16,10 +16,6 @@
 
 #include "velox/common/base/RandomUtil.h"
 
-#include <optional>
-
-#include <folly/Random.h>
-
 namespace facebook::velox::random {
 
 namespace {
@@ -36,4 +32,13 @@ uint32_t getSeed() {
   return customSeed ? *customSeed : folly::Random::rand32();
 }
 
+RandomSkipTracker::RandomSkipTracker(double sampleRate)
+    : sampleRate_(sampleRate) {
+  VELOX_CHECK(0 <= sampleRate && sampleRate < 1);
+  if (sampleRate > 0) {
+    dist_ = std::geometric_distribution<uint64_t>(sampleRate);
+    rng_.seed(getSeed());
+  }
+}
+
 } // namespace facebook::velox::random
diff --git a/velox/common/base/RandomUtil.h b/velox/common/base/RandomUtil.h
index e9ea8f0d2173d..89645a33fa519 100644
--- a/velox/common/base/RandomUtil.h
+++ b/velox/common/base/RandomUtil.h
@@ -16,7 +16,13 @@
 
 #pragma once
 
+#include "velox/common/base/Exceptions.h"
+
+#include <folly/Random.h>
+
 #include <cstdint>
+#include <optional>
+#include <random>
 
 namespace facebook::velox::random {
 
@@ -27,4 +33,66 @@ void setSeed(uint32_t);
 // Return a true random seed unless setSeed() is called before.
 uint32_t getSeed();
 
+/// Utility class to accelerate random sampling based on Bernoulli trials.
+/// Internally this keeps the number of skips for next hit.  User can consume a
+/// bulk of trials calling the `nextSkip' then `consume', or call `testOne` to
+/// do the trials one by one.
+class RandomSkipTracker {
+ public:
+  explicit RandomSkipTracker(double sampleRate);
+
+  RandomSkipTracker(const RandomSkipTracker&) = delete;
+  RandomSkipTracker& operator=(const RandomSkipTracker&) = delete;
+
+  /// Return the number of skips need to get a hit.  Must be called before
+  /// calling `consume'.
+  uint64_t nextSkip() {
+    if (sampleRate_ == 0) {
+      return std::numeric_limits<uint64_t>::max();
+    }
+    if (skip_.has_value()) {
+      return *skip_;
+    }
+    skip_ = dist_(rng_);
+    return *skip_;
+  }
+
+  /// Consume the remaining skips followed by at most one hit.
+  void consume(uint64_t numElements) {
+    if (sampleRate_ == 0) {
+      return;
+    }
+    VELOX_DCHECK(skip_.has_value());
+    if (*skip_ >= numElements) {
+      *skip_ -= numElements;
+    } else {
+      VELOX_DCHECK_EQ(numElements - *skip_, 1);
+      skip_.reset();
+    }
+  }
+
+  /// Consume one trial and return the result.
+  bool testOne() {
+    if (sampleRate_ == 0) {
+      return false;
+    }
+    if (nextSkip() == 0) {
+      skip_.reset();
+      return true;
+    }
+    --*skip_;
+    return false;
+  }
+
+  double sampleRate() const {
+    return sampleRate_;
+  }
+
+ private:
+  const double sampleRate_;
+  std::geometric_distribution<uint64_t> dist_;
+  folly::Random::DefaultGenerator rng_;
+  std::optional<uint64_t> skip_;
+};
+
 } // namespace facebook::velox::random
diff --git a/velox/common/base/Range.h b/velox/common/base/Range.h
index bf061a398ab7b..cc68ccb119469 100644
--- a/velox/common/base/Range.h
+++ b/velox/common/base/Range.h
@@ -16,12 +16,10 @@
 
 #pragma once
 
-#include <cstddef>
 #include <cstdint>
 #include "velox/common/base/BitUtil.h"
 
-namespace facebook {
-namespace velox {
+namespace facebook::velox {
 
 template <typename T>
 class Range {
@@ -63,12 +61,12 @@ inline bool Range<bool>::operator[](int32_t idx) const {
 template <typename T>
 class WritablePosition {
  public:
-  WritablePosition(uint64_t* pointer, unsigned char bit)
+  WritablePosition(uint64_t* pointer, int8_t bitIndex)
       : pointer_(
             reinterpret_cast<uint64_t>(pointer) |
-            (static_cast<uint64_t>(bit) << 56)) {}
+            (static_cast<uint64_t>(bitIndex) << 56)) {}
 
-  WritablePosition(T* pointer)
+  explicit WritablePosition(T* pointer)
       : pointer_(reinterpret_cast<uint64_t>(pointer)) {}
 
   operator T() const {
@@ -144,8 +142,8 @@ template <>
 inline WritablePosition<bool> MutableRange<bool>::operator[](int32_t idx) {
   int32_t bit = begin_ + idx;
   return WritablePosition<bool>(
-      reinterpret_cast<uint64_t*>(data_) + (bit / 64), bit & 63);
+      reinterpret_cast<uint64_t*>(data_) + (bit / 64),
+      static_cast<int8_t>(bit & 63));
 }
 
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox
diff --git a/velox/common/base/RawVector.cpp b/velox/common/base/RawVector.cpp
index d541bbe26b968..6dc1c048d57f6 100644
--- a/velox/common/base/RawVector.cpp
+++ b/velox/common/base/RawVector.cpp
@@ -30,13 +30,14 @@ bool initializeIota() {
 }
 } // namespace
 
-const int32_t* iota(int32_t size, raw_vector<int32_t>& storage) {
-  if (iotaData.size() < size) {
+const int32_t*
+iota(int32_t size, raw_vector<int32_t>& storage, int32_t offset) {
+  if (iotaData.size() < offset + size) {
     storage.resize(size);
-    std::iota(&storage[0], &storage[storage.size()], 0);
+    std::iota(storage.begin(), storage.end(), offset);
     return storage.data();
   }
-  return iotaData.data();
+  return iotaData.data() + offset;
 }
 
 static bool FB_ANONYMOUS_VARIABLE(g_iotaConstants) = initializeIota();
diff --git a/velox/common/base/RawVector.h b/velox/common/base/RawVector.h
index d4941a7fdf5cc..fc6e01d133208 100644
--- a/velox/common/base/RawVector.h
+++ b/velox/common/base/RawVector.h
@@ -67,7 +67,9 @@ class raw_vector {
     data_ = other.data_;
     size_ = other.size_;
     capacity_ = other.capacity_;
-    simd::memset(&other, 0, sizeof(other));
+    other.data_ = nullptr;
+    other.size_ = 0;
+    other.capacity_ = 0;
   }
 
   bool empty() const {
@@ -199,6 +201,7 @@ class raw_vector {
 // SIMD width. Typically returns preallocated memory but if this is
 // not large enough,resizes and initializes 'storage' to the requested
 // size and returns storage.data().
-const int32_t* iota(int32_t size, raw_vector<int32_t>& storage);
+const int32_t*
+iota(int32_t size, raw_vector<int32_t>& storage, int32_t offset = 0);
 
 } // namespace facebook::velox
diff --git a/velox/common/base/RuntimeMetrics.cpp b/velox/common/base/RuntimeMetrics.cpp
index f1150292b8d0b..dc4ad630366d8 100644
--- a/velox/common/base/RuntimeMetrics.cpp
+++ b/velox/common/base/RuntimeMetrics.cpp
@@ -34,7 +34,13 @@ void RuntimeMetric::aggregate() {
   min = max = sum;
 }
 
-void RuntimeMetric::merge(const RuntimeMetric& other) {
+void RuntimeMetric::merge(const RuntimeMetric& other)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+    __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+{
   VELOX_CHECK_EQ(unit, other.unit);
   sum += other.sum;
   count += other.count;
diff --git a/velox/common/base/RuntimeMetrics.h b/velox/common/base/RuntimeMetrics.h
index 9a81ff1837916..7bb45ab4807d6 100644
--- a/velox/common/base/RuntimeMetrics.h
+++ b/velox/common/base/RuntimeMetrics.h
@@ -16,11 +16,12 @@
 
 #pragma once
 
-#include <fmt/format.h>
-#include <folly/CppAttributes.h>
 #include <limits>
 #include <sstream>
 
+#include <fmt/format.h>
+#include <folly/CppAttributes.h>
+
 namespace facebook::velox {
 
 struct RuntimeCounter {
@@ -111,3 +112,10 @@ class RuntimeStatWriterScopeGuard {
 };
 
 } // namespace facebook::velox
+template <>
+struct fmt::formatter<facebook::velox::RuntimeCounter::Unit> : formatter<int> {
+  auto format(facebook::velox::RuntimeCounter::Unit s, format_context& ctx)
+      const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/common/base/Scratch.h b/velox/common/base/Scratch.h
new file mode 100644
index 0000000000000..5866c82063fd9
--- /dev/null
+++ b/velox/common/base/Scratch.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/RawVector.h"
+
+/// A utility for reusable scoped temporary scratch areas.
+namespace facebook::velox {
+
+/// A collection of temporary reusable scratch vectors. The vectors are accessed
+/// via the ScratchPtr scoped lease. The vectors are padded so that their last
+/// element can be written at full SIMD width, as with raw_vector.
+class Scratch {
+ public:
+  using Item = raw_vector<char>;
+
+  Scratch() = default;
+  Scratch(const Scratch& other) = delete;
+
+  ~Scratch() {
+    reserve(0);
+    ::free(items_);
+    items_ = nullptr;
+    capacity_ = 0;
+    fill_ = 0;
+  }
+  void operator=(const Scratch& other) = delete;
+
+  /// Returns the next reusable scratch vector or makes a new one.
+  Item get() {
+    if (fill_ == 0) {
+      return Item();
+    }
+    auto temp = std::move(items_[fill_ - 1]);
+    --fill_;
+    retainedSize_ -= temp.capacity();
+    return temp;
+  }
+
+  void release(Item&& item) {
+    retainedSize_ += item.capacity();
+    if (fill_ == capacity_) {
+      reserve(std::max(16, 2 * capacity_));
+    }
+    items_[fill_++] = std::move(item);
+  }
+
+  void trim() {
+    reserve(0);
+    retainedSize_ = 0;
+  }
+
+  size_t retainedSize() {
+    return retainedSize_;
+  }
+
+ private:
+  void reserve(int32_t newCapacity) {
+    VELOX_CHECK_LE(fill_, capacity_);
+    // Delete the items above the new capacity.
+    for (auto i = newCapacity; i < fill_; ++i) {
+      std::destroy_at(&items_[i]);
+    }
+    // Add hint to prevent the compiler from generating the
+    // stringop-overflow warning when 'newCapacity' is 0.
+    folly::assume(capacity_ >= 0);
+    if (newCapacity > capacity_) {
+      Item* newItems =
+          reinterpret_cast<Item*>(::malloc(sizeof(Item) * newCapacity));
+      if (fill_ > 0) {
+        ::memcpy(newItems, items_, fill_ * sizeof(Item));
+      }
+      ::memset(newItems + fill_, 0, (newCapacity - fill_) * sizeof(Item));
+      ::free(items_);
+      items_ = newItems;
+      capacity_ = newCapacity;
+    }
+    fill_ = std::min(fill_, newCapacity);
+  }
+
+  Item* items_{nullptr};
+  int32_t fill_{0};
+  int32_t capacity_{0};
+  // The total size held. If too large from outlier use cases, 'this' should be
+  // trimmed.
+  int64_t retainedSize_{0};
+};
+
+/// A scoped lease for a scratch area of T. For scratch areas <=
+/// 'inlineSize' the scratch area is inlined, typically on stack, and
+/// no allocation will ever take place. The inline storage is padded
+/// with a trailer of simd::kPadding bytes to allow writing at full
+/// SIMD width at the end of the area.
+template <typename T, int32_t inlineSize = 0>
+class ScratchPtr {
+ public:
+  ScratchPtr(Scratch& scratch) : scratch_(&scratch) {}
+
+  ScratchPtr(const ScratchPtr& other) = delete;
+  ScratchPtr(ScratchPtr&& other) = delete;
+
+  inline ~ScratchPtr() {
+    if (data_.data() != nullptr) {
+      scratch_->release(std::move(data_));
+    }
+  }
+
+  void operator=(ScratchPtr&& other) = delete;
+  void operator=(const ScratchPtr& other) = delete;
+
+  /// Returns a writable pointer to at least 'size' uninitialized
+  /// elements of T. The last element is followed by simd::kPadding
+  /// bytes to allow a full width SIMD store for any element. This may
+  /// be called once per lifetime.
+  T* get(int32_t size) {
+    VELOX_CHECK_NULL(ptr_);
+    size_ = size;
+    if (size <= inlineSize) {
+      ptr_ = inline_;
+      return ptr_;
+    }
+    data_ = scratch_->get();
+    data_.resize(size * sizeof(T));
+    ptr_ = reinterpret_cast<T*>(data_.data());
+    return ptr_;
+  }
+
+  /// Returns the pointer returned by a previous get(int32_t).
+  T* get() const {
+    VELOX_DCHECK_NOT_NULL(ptr_);
+    return ptr_;
+  }
+
+  /// Returns the size of the previous get(int32_t).
+  int32_t size() const {
+    return size_;
+  }
+
+ private:
+  Scratch* const scratch_{nullptr};
+
+  raw_vector<char> data_;
+  T* ptr_{nullptr};
+  int32_t size_{0};
+  T inline_[inlineSize];
+  char padding_[inlineSize == 0 ? 0 : simd::kPadding];
+};
+
+} // namespace facebook::velox
diff --git a/velox/common/base/SelectivityInfo.h b/velox/common/base/SelectivityInfo.h
index 825e476321a4b..6d52790d637eb 100644
--- a/velox/common/base/SelectivityInfo.h
+++ b/velox/common/base/SelectivityInfo.h
@@ -58,8 +58,8 @@ class SelectivityInfo {
 class SelectivityTimer {
  public:
   SelectivityTimer(SelectivityInfo& info, uint64_t numIn)
-      : startClocks_(folly::hardware_timestamp()),
-        totalClocks_(&info.timeClocks_) {
+      : totalClocks_(&info.timeClocks_),
+        startClocks_(folly::hardware_timestamp()) {
     info.numIn_ += numIn;
   }
 
@@ -72,8 +72,8 @@ class SelectivityTimer {
   }
 
  private:
-  uint64_t startClocks_;
   uint64_t* const totalClocks_;
+  uint64_t startClocks_;
 };
 
 } // namespace velox
diff --git a/velox/common/base/SimdUtil-inl.h b/velox/common/base/SimdUtil-inl.h
index 63d4fdbe92eaf..87ff71f8b181c 100644
--- a/velox/common/base/SimdUtil-inl.h
+++ b/velox/common/base/SimdUtil-inl.h
@@ -42,22 +42,29 @@ int genericToBitMask(xsimd::batch_bool<T, A> mask) {
 }
 
 template <typename T, typename A>
-xsimd::batch_bool<T, A> fromBitMaskImpl(int mask) {
-  static const auto kMemo = ({
-    constexpr int N = xsimd::batch_bool<T, A>::size;
+struct FromBitMask {
+  FromBitMask() {
     static_assert(N <= 8);
-    std::array<xsimd::batch_bool<T, A>, (1 << N)> memo;
     for (int i = 0; i < (1 << N); ++i) {
       bool tmp[N];
       for (int bit = 0; bit < N; ++bit) {
         tmp[bit] = (i & (1 << bit)) ? true : false;
       }
-      memo[i] = xsimd::batch_bool<T, A>::load_unaligned(tmp);
+      memo_[i] = xsimd::batch_bool<T, A>::load_unaligned(tmp);
     }
-    memo;
-  });
-  return kMemo[mask];
-}
+  }
+
+  xsimd::batch_bool<T, A> operator[](size_t i) const {
+    return memo_[i];
+  }
+
+ private:
+  static constexpr int N = xsimd::batch_bool<T, A>::size;
+  xsimd::batch_bool<T, A> memo_[1 << N];
+};
+
+extern const FromBitMask<int32_t, xsimd::default_arch> fromBitMask32;
+extern const FromBitMask<int64_t, xsimd::default_arch> fromBitMask64;
 
 template <typename T, typename A>
 struct BitMask<T, A, 1> {
@@ -132,9 +139,10 @@ struct BitMask<T, A, 4> {
     return genericToBitMask(mask);
   }
 
-  static xsimd::batch_bool<T, A> fromBitMask(int mask, const A&) {
-    return UNLIKELY(mask == kAllSet) ? xsimd::batch_bool<T, A>(true)
-                                     : fromBitMaskImpl<T, A>(mask);
+  static xsimd::batch_bool<T, A> fromBitMask(
+      int mask,
+      const xsimd::default_arch&) {
+    return fromBitMask32[mask];
   }
 };
 
@@ -158,9 +166,10 @@ struct BitMask<T, A, 8> {
     return genericToBitMask(mask);
   }
 
-  static xsimd::batch_bool<T, A> fromBitMask(int mask, const A&) {
-    return UNLIKELY(mask == kAllSet) ? xsimd::batch_bool<T, A>(true)
-                                     : fromBitMaskImpl<T, A>(mask);
+  static xsimd::batch_bool<T, A> fromBitMask(
+      int mask,
+      const xsimd::default_arch&) {
+    return fromBitMask64[mask];
   }
 };
 
@@ -242,19 +251,72 @@ int32_t indicesOfSetBits(
   return result - originalResult;
 }
 
+namespace detail {
+
 template <typename T, typename A>
-xsimd::batch_bool<T, A> leadingMask(int n, const A&) {
-  constexpr int N = xsimd::batch_bool<T, A>::size;
-  static const auto kMemo = ({
-    std::array<xsimd::batch_bool<T, A>, N> memo;
+struct LeadingMask {
+  LeadingMask() {
     bool tmp[N]{};
     for (int i = 0; i < N; ++i) {
-      memo[i] = xsimd::batch_bool<T, A>::load_unaligned(tmp);
+      memo_[i] = xsimd::batch_bool<T, A>::load_unaligned(tmp);
       tmp[i] = true;
     }
-    memo;
-  });
-  return LIKELY(n >= N) ? xsimd::batch_bool<T, A>(true) : kMemo[n];
+    memo_[N] = xsimd::batch_bool<T, A>::load_unaligned(tmp);
+  }
+
+  xsimd::batch_bool<T, A> operator[](size_t i) const {
+    return memo_[i];
+  }
+
+ private:
+  static constexpr int N = xsimd::batch_bool<T, A>::size;
+  xsimd::batch_bool<T, A> memo_[N + 1];
+};
+
+extern const LeadingMask<int32_t, xsimd::default_arch> leadingMask32;
+extern const LeadingMask<int64_t, xsimd::default_arch> leadingMask64;
+
+template <typename T, typename A>
+xsimd::batch_bool<T, xsimd::default_arch> leadingMask(int i, const A&);
+
+template <>
+inline xsimd::batch_bool<int32_t, xsimd::default_arch> leadingMask(
+    int i,
+    const xsimd::default_arch&) {
+  return leadingMask32[i];
+}
+
+template <>
+inline xsimd::batch_bool<float, xsimd::default_arch> leadingMask(
+    int i,
+    const xsimd::default_arch&) {
+  return reinterpret_cast<
+      xsimd::batch_bool<float, xsimd::default_arch>::register_type>(
+      leadingMask32[i].data);
+}
+
+template <>
+inline xsimd::batch_bool<int64_t, xsimd::default_arch> leadingMask(
+    int i,
+    const xsimd::default_arch&) {
+  return leadingMask64[i];
+}
+
+template <>
+inline xsimd::batch_bool<double, xsimd::default_arch> leadingMask(
+    int i,
+    const xsimd::default_arch&) {
+  return reinterpret_cast<
+      xsimd::batch_bool<double, xsimd::default_arch>::register_type>(
+      leadingMask64[i].data);
+}
+
+} // namespace detail
+
+template <typename T, typename A>
+xsimd::batch_bool<T, A> leadingMask(int n, const A& arch) {
+  constexpr int N = xsimd::batch_bool<T, A>::size;
+  return detail::leadingMask<T, A>(std::min(n, N), arch);
 }
 
 namespace detail {
@@ -294,7 +356,7 @@ inline bool copyNextWord(void*& to, const void*& from, int32_t& bytes) {
 } // namespace detail
 
 template <typename A>
-void memcpy(void* to, const void* from, int32_t bytes, const A& arch) {
+inline void memcpy(void* to, const void* from, int32_t bytes, const A& arch) {
   while (bytes >= batchByteSize(arch)) {
     if (!detail::copyNextWord<xsimd::batch<int8_t, A>, A>(to, from, bytes)) {
       return;
diff --git a/velox/common/base/SimdUtil.cpp b/velox/common/base/SimdUtil.cpp
index d8a190917e22f..03576ac31ec43 100644
--- a/velox/common/base/SimdUtil.cpp
+++ b/velox/common/base/SimdUtil.cpp
@@ -19,11 +19,49 @@
 
 namespace facebook::velox::simd {
 
+void gatherBits(
+    const uint64_t* bits,
+    folly::Range<const int32_t*> indexRange,
+    uint64_t* result) {
+  constexpr int32_t kStep = xsimd::batch<int32_t>::size;
+  const auto size = indexRange.size();
+  auto indices = indexRange.data();
+  uint8_t* resultPtr = reinterpret_cast<uint8_t*>(result);
+  if (FOLLY_LIKELY(size < 5)) {
+    uint8_t smallResult = 0;
+    for (auto i = 0; i < size; ++i) {
+      smallResult |= static_cast<uint8_t>(bits::isBitSet(bits, indices[i]))
+          << i;
+    }
+    *resultPtr = smallResult;
+    return;
+  }
+
+  int32_t i = 0;
+  for (; i + kStep < size; i += kStep) {
+    uint16_t flags =
+        simd::gather8Bits(bits, xsimd::load_unaligned(indices + i), kStep);
+    bits::storeBitsToByte<kStep>(flags, resultPtr, i);
+  }
+  const auto bitsLeft = size - i;
+  if (bitsLeft > 0) {
+    uint16_t flags =
+        simd::gather8Bits(bits, xsimd::load_unaligned(indices + i), bitsLeft);
+    bits::storeBitsToByte<kStep>(flags, resultPtr, i);
+  }
+}
+
 namespace detail {
 
 alignas(kPadding) int32_t byteSetBits[256][8];
 alignas(kPadding) int32_t permute4x64Indices[16][8];
 
+const LeadingMask<int32_t, xsimd::default_arch> leadingMask32;
+const LeadingMask<int64_t, xsimd::default_arch> leadingMask64;
+
+const FromBitMask<int32_t, xsimd::default_arch> fromBitMask32;
+const FromBitMask<int64_t, xsimd::default_arch> fromBitMask64;
+
 } // namespace detail
 
 namespace {
diff --git a/velox/common/base/SimdUtil.h b/velox/common/base/SimdUtil.h
index 7ebbf7931f0bd..9a6ad0c374253 100644
--- a/velox/common/base/SimdUtil.h
+++ b/velox/common/base/SimdUtil.h
@@ -376,6 +376,73 @@ xsimd::batch<T, A> setAll(T value, const A& = {}) {
   }
 }
 
+// Stores 'data' into 'destination' for the lanes in 'mask'. 'mask' is expected
+// to specify contiguous lower lanes of 'batch'. For non-SIMD cases, 'mask' is
+// not used but rather the number of leading lanes of 'batch' to store is given
+// by 'n'.
+template <typename T, typename A = xsimd::default_arch>
+inline void storeLeading(
+    const xsimd::batch<T, A>& data,
+    const xsimd::batch_bool<T, A>& mask,
+    int32_t n,
+    T* destination) {
+#if XSIMD_WITH_AVX2
+  if constexpr (sizeof(T) == 8) {
+    _mm256_maskstore_epi64(
+        reinterpret_cast<long long*>(destination),
+        *reinterpret_cast<const __m256i*>(&mask),
+        *reinterpret_cast<const __m256i*>(&data));
+  } else if constexpr (sizeof(T) == 4) {
+    _mm256_maskstore_epi32(
+        reinterpret_cast<int*>(destination),
+        *reinterpret_cast<const __m256i*>(&mask),
+        *reinterpret_cast<const __m256i*>(&data));
+  } else {
+#endif
+    for (auto i = 0; i < n; ++i) {
+      reinterpret_cast<T*>(destination)[i] =
+          reinterpret_cast<const T*>(&data)[i];
+    }
+#if XSIMD_WITH_AVX2
+  }
+#endif
+}
+
+/// Stores elements of 'input' selected by 'indices' into 'output'. output[i] =
+/// input[indices[i]].
+/// Indices and output may be the same. May over-read indices but will not
+/// dereference indices that are not in range. Writes exactly indices.size()
+/// elements of 'output'.
+template <typename TData, typename TIndex, typename A = xsimd::default_arch>
+inline void transpose(
+    const TData* input,
+    folly::Range<const TIndex*> indices,
+    TData* output) {
+  constexpr int32_t kBatch = xsimd::batch<TData>::size;
+  const auto size = indices.size();
+  int32_t i = 0;
+  for (; i + kBatch < size; i += kBatch) {
+    auto indexBatch = loadGatherIndices<TData, TIndex>(indices.data() + i);
+    simd::gather<TData, TIndex>(input, indexBatch).store_unaligned(output + i);
+  }
+  if (i < size) {
+    const auto numLeft = size - i;
+    auto mask = simd::leadingMask<TData>(numLeft);
+    auto indexBatch = loadGatherIndices<TData, TIndex>(indices.data() + i);
+    const auto values = simd::maskGather<TData, TIndex>(
+        xsimd::broadcast<TData>(0), mask, input, indexBatch);
+    storeLeading<TData, A>(values, mask, numLeft, output + i);
+  }
+}
+
+/// Gathers the bit from 'bits' for each bit offset in 'indices'. Stores the
+/// result in 'result'. Writes one byte of 'result' for each 8 bits. If the last
+/// byte is not full the trailing bits are undefined.
+void gatherBits(
+    const uint64_t* bits,
+    folly::Range<const int32_t*> indices,
+    uint64_t* result);
+
 // Adds 'bytes' bytes to an address of arbitrary type.
 template <typename T>
 inline T* addBytes(T* pointer, int32_t bytes) {
@@ -385,7 +452,7 @@ inline T* addBytes(T* pointer, int32_t bytes) {
 // 'memcpy' implementation that copies at maximum width and unrolls
 // when 'bytes' is constant.
 template <typename A = xsimd::default_arch>
-void memcpy(void* to, const void* from, int32_t bytes, const A& = {});
+inline void memcpy(void* to, const void* from, int32_t bytes, const A& = {});
 
 // memset implementation that writes at maximum width and unrolls for
 // constant values of 'bytes'.
diff --git a/velox/common/base/SpillConfig.cpp b/velox/common/base/SpillConfig.cpp
new file mode 100644
index 0000000000000..eb02a00b4f1d6
--- /dev/null
+++ b/velox/common/base/SpillConfig.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/SpillConfig.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::common {
+SpillConfig::SpillConfig(
+    GetSpillDirectoryPathCB _getSpillDirPathCb,
+    UpdateAndCheckSpillLimitCB _updateAndCheckSpillLimitCb,
+    std::string _fileNamePrefix,
+    uint64_t _maxFileSize,
+    uint64_t _writeBufferSize,
+    uint64_t _readBufferSize,
+    folly::Executor* _executor,
+    int32_t _minSpillableReservationPct,
+    int32_t _spillableReservationGrowthPct,
+    uint8_t _startPartitionBit,
+    uint8_t _numPartitionBits,
+    int32_t _maxSpillLevel,
+    uint64_t _maxSpillRunRows,
+    uint64_t _writerFlushThresholdSize,
+    const std::string& _compressionKind,
+    const std::string& _fileCreateConfig)
+    : getSpillDirPathCb(std::move(_getSpillDirPathCb)),
+      updateAndCheckSpillLimitCb(std::move(_updateAndCheckSpillLimitCb)),
+      fileNamePrefix(std::move(_fileNamePrefix)),
+      maxFileSize(
+          _maxFileSize == 0 ? std::numeric_limits<int64_t>::max()
+                            : _maxFileSize),
+      writeBufferSize(_writeBufferSize),
+      readBufferSize(_readBufferSize),
+      executor(_executor),
+      minSpillableReservationPct(_minSpillableReservationPct),
+      spillableReservationGrowthPct(_spillableReservationGrowthPct),
+      startPartitionBit(_startPartitionBit),
+      numPartitionBits(_numPartitionBits),
+      maxSpillLevel(_maxSpillLevel),
+      maxSpillRunRows(_maxSpillRunRows),
+      writerFlushThresholdSize(_writerFlushThresholdSize),
+      compressionKind(common::stringToCompressionKind(_compressionKind)),
+      fileCreateConfig(_fileCreateConfig) {
+  VELOX_USER_CHECK_GE(
+      spillableReservationGrowthPct,
+      minSpillableReservationPct,
+      "Spillable memory reservation growth pct should not be lower than minimum available pct");
+}
+
+int32_t SpillConfig::spillLevel(uint8_t startBitOffset) const {
+  VELOX_CHECK_LE(
+      startBitOffset + numPartitionBits,
+      64,
+      "startBitOffset:{} numPartitionsBits:{}",
+      startBitOffset,
+      numPartitionBits);
+  const int32_t deltaBits = startBitOffset - startPartitionBit;
+  VELOX_CHECK_GE(deltaBits, 0, "deltaBits:{}", deltaBits);
+  VELOX_CHECK_EQ(
+      deltaBits % numPartitionBits,
+      0,
+      "deltaBits:{} numPartitionsBits{}",
+      deltaBits,
+      numPartitionBits);
+  return deltaBits / numPartitionBits;
+}
+
+bool SpillConfig::exceedSpillLevelLimit(uint8_t startBitOffset) const {
+  if (startBitOffset + numPartitionBits > 64) {
+    return true;
+  }
+  if (maxSpillLevel == -1) {
+    return false;
+  }
+  return spillLevel(startBitOffset) > maxSpillLevel;
+}
+} // namespace facebook::velox::common
diff --git a/velox/common/base/SpillConfig.h b/velox/common/base/SpillConfig.h
new file mode 100644
index 0000000000000..d6ced347e7870
--- /dev/null
+++ b/velox/common/base/SpillConfig.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <string.h>
+
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include "velox/common/compression/Compression.h"
+
+namespace facebook::velox::common {
+
+#define VELOX_SPILL_LIMIT_EXCEEDED(errorMessage)                    \
+  _VELOX_THROW(                                                     \
+      ::facebook::velox::VeloxRuntimeError,                         \
+      ::facebook::velox::error_source::kErrorSourceRuntime.c_str(), \
+      ::facebook::velox::error_code::kSpillLimitExceeded.c_str(),   \
+      /* isRetriable */ true,                                       \
+      "{}",                                                         \
+      errorMessage);
+
+/// Defining type for a callback function that returns the spill directory path.
+/// Implementations can use it to ensure the path exists before returning.
+using GetSpillDirectoryPathCB = std::function<std::string_view()>;
+
+/// The callback used to update the aggregated spill bytes of a query. If the
+/// query spill limit is set, the callback throws if the aggregated spilled
+/// bytes exceed the set limit.
+using UpdateAndCheckSpillLimitCB = std::function<void(uint64_t)>;
+
+/// Specifies the config for spilling.
+struct SpillConfig {
+  SpillConfig() = default;
+  SpillConfig(
+      GetSpillDirectoryPathCB _getSpillDirPathCb,
+      UpdateAndCheckSpillLimitCB _updateAndCheckSpillLimitCb,
+      std::string _filePath,
+      uint64_t _maxFileSize,
+      uint64_t _writeBufferSize,
+      uint64_t _readBufferSize,
+      folly::Executor* _executor,
+      int32_t _minSpillableReservationPct,
+      int32_t _spillableReservationGrowthPct,
+      uint8_t _startPartitionBit,
+      uint8_t _numPartitionBits,
+      int32_t _maxSpillLevel,
+      uint64_t _maxSpillRunRows,
+      uint64_t _writerFlushThresholdSize,
+      const std::string& _compressionKind,
+      const std::string& _fileCreateConfig = {});
+
+  /// Returns the spilling level with given 'startBitOffset' and
+  /// 'numPartitionBits'.
+  ///
+  /// NOTE: we advance (or right shift) the partition bit offset when goes to
+  /// the next level of recursive spilling.
+  int32_t spillLevel(uint8_t startBitOffset) const;
+
+  /// Checks if the given 'startBitOffset' has exceeded the max spill limit.
+  bool exceedSpillLevelLimit(uint8_t startBitOffset) const;
+
+  /// A callback function that returns the spill directory path. Implementations
+  /// can use it to ensure the path exists before returning.
+  GetSpillDirectoryPathCB getSpillDirPathCb;
+
+  /// The callback used to update the aggregated spill bytes of a query. If the
+  /// query spill limit is set, the callback throws if the aggregated spilled
+  /// bytes exceed the set limit.
+  UpdateAndCheckSpillLimitCB updateAndCheckSpillLimitCb;
+
+  /// Prefix for spill files.
+  std::string fileNamePrefix;
+
+  /// The max spill file size. If it is zero, there is no limit on the spill
+  /// file size.
+  uint64_t maxFileSize;
+
+  /// Specifies the size to buffer the serialized spill data before write to
+  /// storage system for io efficiency.
+  uint64_t writeBufferSize;
+
+  /// Specifies the buffer size to read from one spilled file. If the underlying
+  /// filesystem supports async read, we do read-ahead with double buffering,
+  /// which doubles the buffer used to read from each spill file.
+  uint64_t readBufferSize;
+
+  /// Executor for spilling. If nullptr spilling writes on the Driver's thread.
+  folly::Executor* executor; // Not owned.
+
+  /// The minimal spillable memory reservation in percentage of the current
+  /// memory usage.
+  int32_t minSpillableReservationPct;
+
+  /// The spillable memory reservation growth in percentage of the current
+  /// memory usage.
+  int32_t spillableReservationGrowthPct;
+
+  /// The start partition bit offset of the top (the first level) partitions.
+  uint8_t startPartitionBit;
+
+  /// Used to calculate the spill hash partition number for hash join and
+  /// RowNumber with 'startPartitionBit'.
+  uint8_t numPartitionBits;
+
+  /// The max allowed spilling level with zero being the initial spilling
+  /// level. This only applies for hash build spilling which needs recursive
+  /// spilling when the build table is too big. If it is set to -1, then there
+  /// is no limit and then some extreme large query might run out of spilling
+  /// partition bits at the end.
+  int32_t maxSpillLevel;
+
+  /// The max row numbers to fill and spill for each spill run. This is used to
+  /// cap the memory used for spilling. If it is zero, then there is no limit
+  /// and spilling might run out of memory.
+  uint64_t maxSpillRunRows;
+
+  /// Minimum memory footprint size required to reclaim memory from a file
+  /// writer by flushing its buffered data to disk.
+  uint64_t writerFlushThresholdSize;
+
+  /// CompressionKind when spilling, CompressionKind_NONE means no compression.
+  common::CompressionKind compressionKind;
+
+  /// Custom options passed to velox::FileSystem to create spill WriteFile.
+  std::string fileCreateConfig;
+};
+} // namespace facebook::velox::common
diff --git a/velox/common/base/SpillStats.cpp b/velox/common/base/SpillStats.cpp
new file mode 100644
index 0000000000000..a6a3dae5f9d2c
--- /dev/null
+++ b/velox/common/base/SpillStats.cpp
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/SpillStats.h"
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/base/SuccinctPrinter.h"
+
+namespace facebook::velox::common {
+namespace {
+std::vector<folly::Synchronized<SpillStats>>& allSpillStats() {
+  static std::vector<folly::Synchronized<SpillStats>> spillStatsList(
+      std::thread::hardware_concurrency());
+  return spillStatsList;
+}
+
+folly::Synchronized<SpillStats>& localSpillStats() {
+  const auto idx = std::hash<std::thread::id>{}(std::this_thread::get_id());
+  auto& spillStatsVector = allSpillStats();
+  return spillStatsVector[idx % spillStatsVector.size()];
+}
+} // namespace
+
+SpillStats::SpillStats(
+    uint64_t _spillRuns,
+    uint64_t _spilledInputBytes,
+    uint64_t _spilledBytes,
+    uint64_t _spilledRows,
+    uint32_t _spilledPartitions,
+    uint64_t _spilledFiles,
+    uint64_t _spillFillTimeNanos,
+    uint64_t _spillSortTimeNanos,
+    uint64_t _spillSerializationTimeNanos,
+    uint64_t _spillWrites,
+    uint64_t _spillFlushTimeNanos,
+    uint64_t _spillWriteTimeNanos,
+    uint64_t _spillMaxLevelExceededCount,
+    uint64_t _spillReadBytes,
+    uint64_t _spillReads,
+    uint64_t _spillReadTimeNanos,
+    uint64_t _spillDeserializationTimeNanos)
+    : spillRuns(_spillRuns),
+      spilledInputBytes(_spilledInputBytes),
+      spilledBytes(_spilledBytes),
+      spilledRows(_spilledRows),
+      spilledPartitions(_spilledPartitions),
+      spilledFiles(_spilledFiles),
+      spillFillTimeNanos(_spillFillTimeNanos),
+      spillSortTimeNanos(_spillSortTimeNanos),
+      spillSerializationTimeNanos(_spillSerializationTimeNanos),
+      spillWrites(_spillWrites),
+      spillFlushTimeNanos(_spillFlushTimeNanos),
+      spillWriteTimeNanos(_spillWriteTimeNanos),
+      spillMaxLevelExceededCount(_spillMaxLevelExceededCount),
+      spillReadBytes(_spillReadBytes),
+      spillReads(_spillReads),
+      spillReadTimeNanos(_spillReadTimeNanos),
+      spillDeserializationTimeNanos(_spillDeserializationTimeNanos) {}
+
+SpillStats& SpillStats::operator+=(const SpillStats& other) {
+  spillRuns += other.spillRuns;
+  spilledInputBytes += other.spilledInputBytes;
+  spilledBytes += other.spilledBytes;
+  spilledRows += other.spilledRows;
+  spilledPartitions += other.spilledPartitions;
+  spilledFiles += other.spilledFiles;
+  spillFillTimeNanos += other.spillFillTimeNanos;
+  spillSortTimeNanos += other.spillSortTimeNanos;
+  spillSerializationTimeNanos += other.spillSerializationTimeNanos;
+  spillWrites += other.spillWrites;
+  spillFlushTimeNanos += other.spillFlushTimeNanos;
+  spillWriteTimeNanos += other.spillWriteTimeNanos;
+  spillMaxLevelExceededCount += other.spillMaxLevelExceededCount;
+  spillReadBytes += other.spillReadBytes;
+  spillReads += other.spillReads;
+  spillReadTimeNanos += other.spillReadTimeNanos;
+  spillDeserializationTimeNanos += other.spillDeserializationTimeNanos;
+  return *this;
+}
+
+SpillStats SpillStats::operator-(const SpillStats& other) const {
+  SpillStats result;
+  result.spillRuns = spillRuns - other.spillRuns;
+  result.spilledInputBytes = spilledInputBytes - other.spilledInputBytes;
+  result.spilledBytes = spilledBytes - other.spilledBytes;
+  result.spilledRows = spilledRows - other.spilledRows;
+  result.spilledPartitions = spilledPartitions - other.spilledPartitions;
+  result.spilledFiles = spilledFiles - other.spilledFiles;
+  result.spillFillTimeNanos = spillFillTimeNanos - other.spillFillTimeNanos;
+  result.spillSortTimeNanos = spillSortTimeNanos - other.spillSortTimeNanos;
+  result.spillSerializationTimeNanos =
+      spillSerializationTimeNanos - other.spillSerializationTimeNanos;
+  result.spillWrites = spillWrites - other.spillWrites;
+  result.spillFlushTimeNanos = spillFlushTimeNanos - other.spillFlushTimeNanos;
+  result.spillWriteTimeNanos = spillWriteTimeNanos - other.spillWriteTimeNanos;
+  result.spillMaxLevelExceededCount =
+      spillMaxLevelExceededCount - other.spillMaxLevelExceededCount;
+  result.spillReadBytes = spillReadBytes - other.spillReadBytes;
+  result.spillReads = spillReads - other.spillReads;
+  result.spillReadTimeNanos = spillReadTimeNanos - other.spillReadTimeNanos;
+  result.spillDeserializationTimeNanos =
+      spillDeserializationTimeNanos - other.spillDeserializationTimeNanos;
+  return result;
+}
+
+bool SpillStats::operator<(const SpillStats& other) const {
+  uint32_t gtCount{0};
+  uint32_t ltCount{0};
+#define UPDATE_COUNTER(counter)           \
+  do {                                    \
+    if (counter < other.counter) {        \
+      ++ltCount;                          \
+    } else if (counter > other.counter) { \
+      ++gtCount;                          \
+    }                                     \
+  } while (0);
+
+  UPDATE_COUNTER(spillRuns);
+  UPDATE_COUNTER(spilledInputBytes);
+  UPDATE_COUNTER(spilledBytes);
+  UPDATE_COUNTER(spilledRows);
+  UPDATE_COUNTER(spilledPartitions);
+  UPDATE_COUNTER(spilledFiles);
+  UPDATE_COUNTER(spillFillTimeNanos);
+  UPDATE_COUNTER(spillSortTimeNanos);
+  UPDATE_COUNTER(spillSerializationTimeNanos);
+  UPDATE_COUNTER(spillWrites);
+  UPDATE_COUNTER(spillFlushTimeNanos);
+  UPDATE_COUNTER(spillWriteTimeNanos);
+  UPDATE_COUNTER(spillMaxLevelExceededCount);
+  UPDATE_COUNTER(spillReadBytes);
+  UPDATE_COUNTER(spillReads);
+  UPDATE_COUNTER(spillReadTimeNanos);
+  UPDATE_COUNTER(spillDeserializationTimeNanos);
+#undef UPDATE_COUNTER
+  VELOX_CHECK(
+      !((gtCount > 0) && (ltCount > 0)),
+      "gtCount {} ltCount {}",
+      gtCount,
+      ltCount);
+  return ltCount > 0;
+}
+
+bool SpillStats::operator>(const SpillStats& other) const {
+  return !(*this < other) && (*this != other);
+}
+
+bool SpillStats::operator>=(const SpillStats& other) const {
+  return !(*this < other);
+}
+
+bool SpillStats::operator<=(const SpillStats& other) const {
+  return !(*this > other);
+}
+
+bool SpillStats::operator==(const SpillStats& other) const {
+  return std::tie(
+             spillRuns,
+             spilledInputBytes,
+             spilledBytes,
+             spilledRows,
+             spilledPartitions,
+             spilledFiles,
+             spillFillTimeNanos,
+             spillSortTimeNanos,
+             spillSerializationTimeNanos,
+             spillWrites,
+             spillFlushTimeNanos,
+             spillWriteTimeNanos,
+             spillMaxLevelExceededCount,
+             spillReadBytes,
+             spillReads,
+             spillReadTimeNanos,
+             spillDeserializationTimeNanos) ==
+      std::tie(
+             other.spillRuns,
+             other.spilledInputBytes,
+             other.spilledBytes,
+             other.spilledRows,
+             other.spilledPartitions,
+             other.spilledFiles,
+             other.spillFillTimeNanos,
+             other.spillSortTimeNanos,
+             other.spillSerializationTimeNanos,
+             other.spillWrites,
+             other.spillFlushTimeNanos,
+             other.spillWriteTimeNanos,
+             spillMaxLevelExceededCount,
+             spillReadBytes,
+             spillReads,
+             spillReadTimeNanos,
+             spillDeserializationTimeNanos);
+}
+
+void SpillStats::reset() {
+  spillRuns = 0;
+  spilledInputBytes = 0;
+  spilledBytes = 0;
+  spilledRows = 0;
+  spilledPartitions = 0;
+  spilledFiles = 0;
+  spillFillTimeNanos = 0;
+  spillSortTimeNanos = 0;
+  spillSerializationTimeNanos = 0;
+  spillWrites = 0;
+  spillFlushTimeNanos = 0;
+  spillWriteTimeNanos = 0;
+  spillMaxLevelExceededCount = 0;
+  spillReadBytes = 0;
+  spillReads = 0;
+  spillReadTimeNanos = 0;
+  spillDeserializationTimeNanos = 0;
+}
+
+std::string SpillStats::toString() const {
+  return fmt::format(
+      "spillRuns[{}] spilledInputBytes[{}] spilledBytes[{}] spilledRows[{}] "
+      "spilledPartitions[{}] spilledFiles[{}] spillFillTimeNanos[{}] "
+      "spillSortTimeNanos[{}] spillSerializationTimeNanos[{}] spillWrites[{}] "
+      "spillFlushTimeNanos[{}] spillWriteTimeNanos[{}] maxSpillExceededLimitCount[{}] "
+      "spillReadBytes[{}] spillReads[{}] spillReadTimeNanos[{}] "
+      "spillReadDeserializationTimeNanos[{}]",
+      spillRuns,
+      succinctBytes(spilledInputBytes),
+      succinctBytes(spilledBytes),
+      spilledRows,
+      spilledPartitions,
+      spilledFiles,
+      succinctNanos(spillFillTimeNanos),
+      succinctNanos(spillSortTimeNanos),
+      succinctNanos(spillSerializationTimeNanos),
+      spillWrites,
+      succinctNanos(spillFlushTimeNanos),
+      succinctNanos(spillWriteTimeNanos),
+      spillMaxLevelExceededCount,
+      succinctBytes(spillReadBytes),
+      spillReads,
+      succinctNanos(spillReadTimeNanos),
+      succinctNanos(spillDeserializationTimeNanos));
+}
+
+void updateGlobalSpillRunStats(uint64_t numRuns) {
+  auto statsLocked = localSpillStats().wlock();
+  statsLocked->spillRuns += numRuns;
+}
+
+void updateGlobalSpillAppendStats(
+    uint64_t numRows,
+    uint64_t serializationTimeNs) {
+  RECORD_METRIC_VALUE(kMetricSpilledRowsCount, numRows);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillSerializationTimeMs, serializationTimeNs / 1'000'000);
+  auto statsLocked = localSpillStats().wlock();
+  statsLocked->spilledRows += numRows;
+  statsLocked->spillSerializationTimeNanos += serializationTimeNs;
+}
+
+void incrementGlobalSpilledPartitionStats() {
+  ++localSpillStats().wlock()->spilledPartitions;
+}
+
+void updateGlobalSpillFillTime(uint64_t timeNs) {
+  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillFillTimeMs, timeNs / 1'000'000);
+  localSpillStats().wlock()->spillFillTimeNanos += timeNs;
+}
+
+void updateGlobalSpillSortTime(uint64_t timeNs) {
+  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillSortTimeMs, timeNs / 1'000'000);
+  localSpillStats().wlock()->spillSortTimeNanos += timeNs;
+}
+
+void updateGlobalSpillWriteStats(
+    uint64_t spilledBytes,
+    uint64_t flushTimeNs,
+    uint64_t writeTimeNs) {
+  RECORD_METRIC_VALUE(kMetricSpillWritesCount);
+  RECORD_METRIC_VALUE(kMetricSpilledBytes, spilledBytes);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillFlushTimeMs, flushTimeNs / 1'000'000);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillWriteTimeMs, writeTimeNs / 1'000'000);
+  auto statsLocked = localSpillStats().wlock();
+  ++statsLocked->spillWrites;
+  statsLocked->spilledBytes += spilledBytes;
+  statsLocked->spillFlushTimeNanos += flushTimeNs;
+  statsLocked->spillWriteTimeNanos += writeTimeNs;
+}
+
+void updateGlobalSpillReadStats(
+    uint64_t spillReads,
+    uint64_t spillReadBytes,
+    uint64_t spillReadTimeNs) {
+  auto statsLocked = localSpillStats().wlock();
+  statsLocked->spillReads += spillReads;
+  statsLocked->spillReadBytes += spillReadBytes;
+  statsLocked->spillReadTimeNanos += spillReadTimeNs;
+}
+
+void updateGlobalSpillMemoryBytes(uint64_t spilledInputBytes) {
+  RECORD_METRIC_VALUE(kMetricSpilledInputBytes, spilledInputBytes);
+  auto statsLocked = localSpillStats().wlock();
+  statsLocked->spilledInputBytes += spilledInputBytes;
+}
+
+void incrementGlobalSpilledFiles() {
+  RECORD_METRIC_VALUE(kMetricSpilledFilesCount);
+  ++localSpillStats().wlock()->spilledFiles;
+}
+
+void updateGlobalMaxSpillLevelExceededCount(
+    uint64_t maxSpillLevelExceededCount) {
+  localSpillStats().wlock()->spillMaxLevelExceededCount +=
+      maxSpillLevelExceededCount;
+}
+
+void updateGlobalSpillDeserializationTimeNs(uint64_t timeNs) {
+  localSpillStats().wlock()->spillDeserializationTimeNanos += timeNs;
+}
+
+SpillStats globalSpillStats() {
+  SpillStats gSpillStats;
+  for (auto& spillStats : allSpillStats()) {
+    gSpillStats += spillStats.copy();
+  }
+  return gSpillStats;
+}
+} // namespace facebook::velox::common
diff --git a/velox/common/base/SpillStats.h b/velox/common/base/SpillStats.h
new file mode 100644
index 0000000000000..e88db0527c057
--- /dev/null
+++ b/velox/common/base/SpillStats.h
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <stdint.h>
+#include <string.h>
+
+#include <folly/executors/CPUThreadPoolExecutor.h>
+
+#include "velox/common/compression/Compression.h"
+
+namespace facebook::velox::common {
+/// Provides the fine-grained spill execution stats.
+struct SpillStats {
+  /// The number of times that spilling runs on an operator.
+  uint64_t spillRuns{0};
+  /// The number of bytes in memory to spill
+  uint64_t spilledInputBytes{0};
+  /// The number of bytes spilled to disks.
+  ///
+  /// NOTE: if compression is enabled, this counts the compressed bytes.
+  uint64_t spilledBytes{0};
+  /// The number of spilled rows.
+  uint64_t spilledRows{0};
+  /// NOTE: when we sum up the stats from a group of spill operators, it is
+  /// the total number of spilled partitions X number of operators.
+  uint32_t spilledPartitions{0};
+  /// The number of spilled files.
+  uint64_t spilledFiles{0};
+  /// The time spent on filling rows for spilling.
+  uint64_t spillFillTimeNanos{0};
+  /// The time spent on sorting rows for spilling.
+  uint64_t spillSortTimeNanos{0};
+  /// The time spent on serializing rows for spilling.
+  uint64_t spillSerializationTimeNanos{0};
+  /// The number of spill writer flushes, equivalent to number of write calls to
+  /// underlying filesystem.
+  uint64_t spillWrites{0};
+  /// The time spent on copy out serialized rows for disk write. If compression
+  /// is enabled, this includes the compression time.
+  uint64_t spillFlushTimeNanos{0};
+  /// The time spent on writing spilled rows to disk.
+  uint64_t spillWriteTimeNanos{0};
+  /// The number of times that an hash build operator exceeds the max spill
+  /// limit.
+  uint64_t spillMaxLevelExceededCount{0};
+  /// The number of bytes read from spilled files.
+  uint64_t spillReadBytes{0};
+  /// The number of spill reader reads, equivalent to the number of read calls
+  /// to the underlying filesystem.
+  uint64_t spillReads{0};
+  /// The time spent on read data from spilled files.
+  uint64_t spillReadTimeNanos{0};
+  /// The time spent on deserializing rows read from spilled files.
+  uint64_t spillDeserializationTimeNanos{0};
+
+  SpillStats(
+      uint64_t _spillRuns,
+      uint64_t _spilledInputBytes,
+      uint64_t _spilledBytes,
+      uint64_t _spilledRows,
+      uint32_t _spilledPartitions,
+      uint64_t _spilledFiles,
+      uint64_t _spillFillTimeNanos,
+      uint64_t _spillSortTimeNanos,
+      uint64_t _spillSerializationTimeNanos,
+      uint64_t _spillWrites,
+      uint64_t _spillFlushTimeNanos,
+      uint64_t _spillWriteTimeNanos,
+      uint64_t _spillMaxLevelExceededCount,
+      uint64_t _spillReadBytes,
+      uint64_t _spillReads,
+      uint64_t _spillReadTimeNanos,
+      uint64_t _spillDeserializationTimeNanos);
+
+  SpillStats() = default;
+
+  bool empty() const {
+    return spilledBytes == 0;
+  }
+
+  SpillStats& operator+=(const SpillStats& other);
+  SpillStats operator-(const SpillStats& other) const;
+  bool operator==(const SpillStats& other) const;
+  bool operator!=(const SpillStats& other) const {
+    return !(*this == other);
+  }
+  bool operator>(const SpillStats& other) const;
+  bool operator<(const SpillStats& other) const;
+  bool operator>=(const SpillStats& other) const;
+  bool operator<=(const SpillStats& other) const;
+
+  void reset();
+
+  std::string toString() const;
+};
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& o,
+    const common::SpillStats& stats) {
+  return o << stats.toString();
+}
+
+/// The utilities to update the process wide spilling stats.
+/// Updates the number of spill runs.
+void updateGlobalSpillRunStats(uint64_t numRuns);
+
+/// Updates the stats of new append spilled rows including the number of spilled
+/// rows and the serializaion time.
+void updateGlobalSpillAppendStats(
+    uint64_t numRows,
+    uint64_t serializaionTimeUs);
+
+/// Increments the number of spilled partitions.
+void incrementGlobalSpilledPartitionStats();
+
+/// Updates the time spent on filling rows to spill.
+void updateGlobalSpillFillTime(uint64_t timeUs);
+
+/// Updates the time spent on sorting rows to spill.
+void updateGlobalSpillSortTime(uint64_t timeUs);
+
+/// Updates the stats for disk write including the number of disk writes,
+/// the written bytes, the time spent on copying out (compression) for disk
+/// writes, the time spent on disk writes.
+void updateGlobalSpillWriteStats(
+    uint64_t spilledBytes,
+    uint64_t flushTimeUs,
+    uint64_t writeTimeUs);
+
+/// Updates the stats for disk read including the number of disk reads, the
+/// amount of data read in bytes, and the time it takes to read from the disk.
+void updateGlobalSpillReadStats(
+    uint64_t spillReads,
+    uint64_t spillReadBytes,
+    uint64_t spillRadTimeUs);
+
+/// Increments the spill memory bytes.
+void updateGlobalSpillMemoryBytes(uint64_t spilledInputBytes);
+
+/// Increments the spilled files by one.
+void incrementGlobalSpilledFiles();
+
+/// Increments the exceeded max spill level count.
+void updateGlobalMaxSpillLevelExceededCount(
+    uint64_t maxSpillLevelExceededCount);
+
+/// Increments the spill read deserialization time.
+void updateGlobalSpillDeserializationTimeNs(uint64_t timeUs);
+
+/// Gets the cumulative global spill stats.
+SpillStats globalSpillStats();
+} // namespace facebook::velox::common
+
+template <>
+struct fmt::formatter<facebook::velox::common::SpillStats>
+    : fmt::formatter<std::string> {
+  auto format(const facebook::velox::common::SpillStats& s, format_context& ctx)
+      const {
+    return formatter<std::string>::format(s.toString(), ctx);
+  }
+};
diff --git a/velox/common/base/StatsReporter.h b/velox/common/base/StatsReporter.h
index b27ad242a672a..d306c31cde182 100644
--- a/velox/common/base/StatsReporter.h
+++ b/velox/common/base/StatsReporter.h
@@ -19,11 +19,11 @@
 #include <folly/Singleton.h>
 #include <memory>
 
-/// StatsReporter designed to assist in reporting various stats of the
+/// StatsReporter designed to assist in reporting various metrics of the
 /// application that uses velox library. The library itself does not implement
 /// the StatsReporter and it should be implemented by the application.
 ///
-/// To inialize the reporter singleton in your application use this pattern
+/// To initialize the reporter singleton in your application use this pattern
 /// (note that MyReporter should implement the abstract class
 /// BaseStatsReporter):
 ///
@@ -31,34 +31,56 @@
 ///     return new MyReporter();
 ///   });
 ///
-/// Then, for every stat that needs to be reported, it is required to register
-/// one (usually) or more types (StatType) before reporting the stat:
+/// Then, for every metric that needs to be reported, it is required to register
+/// one (usually) or more types (StatType) before reporting the metric:
 ///
-///   REPORT_ADD_STAT_EXPORT_TYPE("my_stat1", facebook::velox::StatType::COUNT);
+///   DEFINE_METRIC("my_stat1", facebook::velox::StatType::COUNT);
 ///
 /// To register one histogram, it requires the min and max value of
-//  the range, the bucket width as well as the percentiles to be reported.
-///   REPORT_ADD_HISTOGRAM_EXPORT_PERCENTILE("my_stat2", 10, 0, 100, 50, 99,
-///   100);
+///  the range, the bucket width as well as the percentiles to be reported.
+///   DEFINE_HISTOGRAM_METRIC("my_stat2", 10, 0, 100, 50, 99, 100);
 ///
-/// The StatType controls how counter/stat is aggregated.
-/// After that, every call to REPORT_ADD_STAT_VALUE increases the counter by the
+/// The StatType controls how metric is aggregated.
+/// After that, every call to RECORD_METRIC_VALUE increases the metric by the
 /// given value:
 ///
-///   By default the following will add 1 to the stat if not provided value
-///   REPORT_ADD_STAT_VALUE("my_stat1");
-///   REPORT_ADD_STAT_VALUE("my_stat2", 10);
-///   REPORT_ADD_STAT_VALUE("my_stat1", numOfFailures);
+///   By default the following will add 1 to the metric if not provided value
+///   RECORD_METRIC_VALUE("my_stat1");
+///   RECORD_METRIC_VALUE("my_stat2", 10);
+///   RECORD_METRIC_VALUE("my_stat1", numOfFailures);
 
 namespace facebook::velox {
 
 enum class StatType {
+  /// Tracks the average of the inserted values.
   AVG,
+  /// Tracks the sum of the inserted values.
   SUM,
+  /// Tracks the sum of the inserted values per second.
   RATE,
+  /// Tracks the count of inserted values.
   COUNT,
+  /// Tracks the histogram of inserted values.
+  HISTOGRAM,
 };
 
+inline std::string statTypeString(StatType stat) {
+  switch (stat) {
+    case StatType::AVG:
+      return "Avg";
+    case StatType::SUM:
+      return "Sum";
+    case StatType::RATE:
+      return "Rate";
+    case StatType::COUNT:
+      return "Count";
+    case StatType::HISTOGRAM:
+      return "Histogram";
+    default:
+      return fmt::format("UNKNOWN: {}", static_cast<int>(stat));
+  }
+}
+
 /// This is the base stats reporter interface that should be extended by
 /// different implementations.
 class BaseStatsReporter {
@@ -68,25 +90,27 @@ class BaseStatsReporter {
   /// Register a stat of the given stat type.
   /// @param key The key to identify the stat.
   /// @param statType How the stat is aggregated.
-  virtual void addStatExportType(const char* key, StatType statType) const = 0;
-
-  virtual void addStatExportType(folly::StringPiece key, StatType statType)
+  virtual void registerMetricExportType(const char* key, StatType statType)
       const = 0;
 
+  virtual void registerMetricExportType(
+      folly::StringPiece key,
+      StatType statType) const = 0;
+
   /// Register a histogram with a list of percentiles defined.
   /// @param key The key to identify the histogram.
   /// @param bucketWidth The width of the buckets.
   /// @param min The starting value of the buckets.
   /// @param max The ending value of the buckets.
   /// @param pcts The aggregated percentiles to be reported.
-  virtual void addHistogramExportPercentiles(
+  virtual void registerHistogramMetricExportType(
       const char* key,
       int64_t bucketWidth,
       int64_t min,
       int64_t max,
       const std::vector<int32_t>& pcts) const = 0;
 
-  virtual void addHistogramExportPercentiles(
+  virtual void registerHistogramMetricExportType(
       folly::StringPiece key,
       int64_t bucketWidth,
       int64_t min,
@@ -94,112 +118,122 @@ class BaseStatsReporter {
       const std::vector<int32_t>& pcts) const = 0;
 
   /// Add the given value to the stat.
-  virtual void addStatValue(const std::string& key, size_t value = 1) const = 0;
+  virtual void addMetricValue(const std::string& key, size_t value = 1)
+      const = 0;
 
-  virtual void addStatValue(const char* key, size_t value = 1) const = 0;
+  virtual void addMetricValue(const char* key, size_t value = 1) const = 0;
 
-  virtual void addStatValue(folly::StringPiece key, size_t value = 1) const = 0;
+  virtual void addMetricValue(folly::StringPiece key, size_t value = 1)
+      const = 0;
 
   /// Add the given value to the histogram.
-  virtual void addHistogramValue(const std::string& key, size_t value)
+  virtual void addHistogramMetricValue(const std::string& key, size_t value)
       const = 0;
 
-  virtual void addHistogramValue(const char* key, size_t value) const = 0;
+  virtual void addHistogramMetricValue(const char* key, size_t value) const = 0;
 
-  virtual void addHistogramValue(folly::StringPiece key, size_t value)
+  virtual void addHistogramMetricValue(folly::StringPiece key, size_t value)
       const = 0;
 
+  /// Return the aggregated metrics in a serialized string format.
+  virtual std::string fetchMetrics() = 0;
+
   static bool registered;
 };
 
 // This is a dummy reporter that does nothing
 class DummyStatsReporter : public BaseStatsReporter {
  public:
-  void addStatExportType(const char* /*key*/, StatType /*statType*/)
+  void registerMetricExportType(const char* /*key*/, StatType /*statType*/)
       const override {}
 
-  void addStatExportType(folly::StringPiece /*key*/, StatType /*statType*/)
-      const override {}
+  void registerMetricExportType(
+      folly::StringPiece /*key*/,
+      StatType /*statType*/) const override {}
 
-  void addHistogramExportPercentiles(
+  void registerHistogramMetricExportType(
       const char* /*key*/,
       int64_t /* bucketWidth */,
       int64_t /* min */,
       int64_t /* max */,
       const std::vector<int32_t>& /* pcts */) const override {}
 
-  void addHistogramExportPercentiles(
+  void registerHistogramMetricExportType(
       folly::StringPiece /* key */,
       int64_t /* bucketWidth */,
       int64_t /* min */,
       int64_t /* max */,
       const std::vector<int32_t>& /* pcts */) const override {}
 
-  void addStatValue(const std::string& /* key */, size_t /* value */)
+  void addMetricValue(const std::string& /* key */, size_t /* value */)
       const override {}
 
-  void addStatValue(const char* /* key */, size_t /* value */) const override {}
+  void addMetricValue(const char* /* key */, size_t /* value */)
+      const override {}
 
-  void addStatValue(folly::StringPiece /* key */, size_t /* value */)
+  void addMetricValue(folly::StringPiece /* key */, size_t /* value */)
       const override {}
 
-  void addHistogramValue(const std::string& /* key */, size_t /* value */)
+  void addHistogramMetricValue(const std::string& /* key */, size_t /* value */)
       const override {}
 
-  void addHistogramValue(const char* /* key */, size_t /* value */)
+  void addHistogramMetricValue(const char* /* key */, size_t /* value */)
       const override {}
 
-  void addHistogramValue(folly::StringPiece /* key */, size_t /* value */)
+  void addHistogramMetricValue(folly::StringPiece /* key */, size_t /* value */)
       const override {}
+
+  std::string fetchMetrics() override {
+    return "";
+  }
 };
 
-#define REPORT_ADD_STAT_VALUE(key, ...)                        \
+#define DEFINE_METRIC(key, type)                               \
   {                                                            \
     if (::facebook::velox::BaseStatsReporter::registered) {    \
       auto reporter = folly::Singleton<                        \
           facebook::velox::BaseStatsReporter>::try_get_fast(); \
       if (FOLLY_LIKELY(reporter != nullptr)) {                 \
-        reporter->addStatValue((key), ##__VA_ARGS__);          \
+        reporter->registerMetricExportType((key), (type));     \
       }                                                        \
     }                                                          \
   }
 
-#define REPORT_ADD_STAT_EXPORT_TYPE(key, type)                 \
+#define RECORD_METRIC_VALUE(key, ...)                          \
   {                                                            \
     if (::facebook::velox::BaseStatsReporter::registered) {    \
       auto reporter = folly::Singleton<                        \
           facebook::velox::BaseStatsReporter>::try_get_fast(); \
       if (FOLLY_LIKELY(reporter != nullptr)) {                 \
-        reporter->addStatExportType((key), (type));            \
+        reporter->addMetricValue((key), ##__VA_ARGS__);        \
       }                                                        \
     }                                                          \
   }
 
-#define REPORT_ADD_HISTOGRAM_VALUE(key, ...)                   \
+#define DEFINE_HISTOGRAM_METRIC(key, bucket, min, max, ...)    \
   {                                                            \
     if (::facebook::velox::BaseStatsReporter::registered) {    \
       auto reporter = folly::Singleton<                        \
           facebook::velox::BaseStatsReporter>::try_get_fast(); \
       if (FOLLY_LIKELY(reporter != nullptr)) {                 \
-        reporter->addHistogramValue((key), ##__VA_ARGS__);     \
+        reporter->registerHistogramMetricExportType(           \
+            (key),                                             \
+            (bucket),                                          \
+            (min),                                             \
+            (max),                                             \
+            (std::vector<int32_t>({__VA_ARGS__})));            \
       }                                                        \
     }                                                          \
   }
 
-#define REPORT_ADD_HISTOGRAM_EXPORT_PERCENTILE(key, bucket, min, max, ...) \
-  {                                                                        \
-    if (::facebook::velox::BaseStatsReporter::registered) {                \
-      auto reporter = folly::Singleton<                                    \
-          facebook::velox::BaseStatsReporter>::try_get_fast();             \
-      if (FOLLY_LIKELY(reporter != nullptr)) {                             \
-        reporter->addHistogramExportPercentiles(                           \
-            (key),                                                         \
-            (bucket),                                                      \
-            (min),                                                         \
-            (max),                                                         \
-            (std::vector<int32_t>({__VA_ARGS__})));                        \
-      }                                                                    \
-    }                                                                      \
+#define RECORD_HISTOGRAM_METRIC_VALUE(key, ...)                  \
+  {                                                              \
+    if (::facebook::velox::BaseStatsReporter::registered) {      \
+      auto reporter = folly::Singleton<                          \
+          facebook::velox::BaseStatsReporter>::try_get_fast();   \
+      if (FOLLY_LIKELY(reporter != nullptr)) {                   \
+        reporter->addHistogramMetricValue((key), ##__VA_ARGS__); \
+      }                                                          \
+    }                                                            \
   }
-
 } // namespace facebook::velox
diff --git a/velox/common/base/Status.cpp b/velox/common/base/Status.cpp
new file mode 100644
index 0000000000000..a170d3d9053f4
--- /dev/null
+++ b/velox/common/base/Status.cpp
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/Status.h"
+
+#include <glog/logging.h>
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+
+namespace facebook::velox {
+
+std::string_view toString(StatusCode code) {
+  switch (code) {
+    case StatusCode::kOK:
+      return "OK";
+    case StatusCode::kUserError:
+      return "User error";
+    case StatusCode::kTypeError:
+      return "Type error";
+    case StatusCode::kIndexError:
+      return "Index error";
+    case StatusCode::kKeyError:
+      return "Key error";
+    case StatusCode::kAlreadyExists:
+      return "Already exists";
+    case StatusCode::kOutOfMemory:
+      return "Out of memory";
+    case StatusCode::kIOError:
+      return "IOError";
+    case StatusCode::kCancelled:
+      return "Cancelled";
+    case StatusCode::kInvalid:
+      return "Invalid";
+    case StatusCode::kUnknownError:
+      return "Unknown error";
+    case StatusCode::kNotImplemented:
+      return "NotImplemented";
+  }
+  return ""; // no-op
+}
+
+Status::Status(StatusCode code) {
+  state_ = new State;
+  state_->code = code;
+}
+
+Status::Status(StatusCode code, std::string msg) {
+  if (FOLLY_UNLIKELY(code == StatusCode::kOK)) {
+    throw std::invalid_argument("Cannot construct ok status with message");
+  }
+  state_ = new State;
+  state_->code = code;
+  state_->msg = std::move(msg);
+}
+
+void Status::copyFrom(const Status& s) {
+  delete state_;
+  if (s.state_ == nullptr) {
+    state_ = nullptr;
+  } else {
+    state_ = new State(*s.state_);
+  }
+}
+
+std::string_view Status::codeAsString() const {
+  if (state_ == nullptr) {
+    return "OK";
+  }
+  return ::facebook::velox::toString(code());
+}
+
+std::string Status::toString() const {
+  std::string result(codeAsString());
+  if (state_ == nullptr) {
+    return result;
+  }
+  result += ": ";
+  result += state_->msg;
+  return result;
+}
+
+void Status::abort() const {
+  abort("");
+}
+
+void Status::abort(const std::string_view& message) const {
+  std::cerr << "-- Velox Fatal Error --\n";
+  if (!message.empty()) {
+    std::cerr << message << "\n";
+  }
+  std::cerr << toString() << std::endl;
+  std::abort();
+}
+
+void Status::warn() const {
+  LOG(WARNING) << toString();
+}
+
+void Status::warn(const std::string_view& message) const {
+  LOG(WARNING) << message << ": " << toString();
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/base/Status.h b/velox/common/base/Status.h
new file mode 100644
index 0000000000000..2f99acca70ec9
--- /dev/null
+++ b/velox/common/base/Status.h
@@ -0,0 +1,535 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#pragma once
+
+#include <string>
+#include <utility>
+
+#include <fmt/format.h>
+#include <fmt/ostream.h>
+#include <folly/Expected.h>
+#include <folly/Likely.h>
+
+namespace facebook::velox {
+
+/// The Status object is an object holding the outcome of an operation (success
+/// or error).
+///
+/// The outcome is represented as a StatusCode, holding either a success
+/// (StatusCode::kOK) or an error (any other of the StatusCode enumeration
+/// values). If an error occurred, a specific error message is generally
+/// attached.
+///
+/// The status object is commonly allocated in the stack, so it needs be compact
+/// to be efficient. For the common success case, its size is a single (nullptr)
+/// pointer. For failure cases, it allocates an external object containing the
+/// StatusCode and error message. This keeps the object compact and prevents
+/// allocations in the common success case. The same strategy is used in Status
+/// object from other well-known libraries like Apache Arrow, RocksDB, Kudu, and
+/// others.
+///
+/// Simple usage:
+///
+///  Status operation() {
+///    if (noMoreMemory) {
+///      return Status::OutOfMemory("Not enough memory to run 'operation'!");
+///    }
+///    return Status::OK();
+///  }
+///
+/// Call site:
+///
+///  auto status = operation();
+///  if (status.ok()) {
+///    ...
+///  } else if (status.isOutOfMemory()) {
+///    (gracefully handle out of memory)
+///  } else if (status.isNotImplemented()) {
+///    (and so on)
+///  }
+///
+/// Other common usage patterns:
+///
+/// The same logic above can be implemented using helper macros:
+///
+///  Status operation() {
+///    VELOX_RETURN_IF(noMoreMemory, Status::OutOfMemory(
+///       "Not enough memory to run 'operation'!"));
+///    ...
+///    return Status::OK();
+///  }
+///
+/// To ensure operations succeed (or if not, return the same status from the
+/// current function):
+///
+///  ...
+///  VELOX_RETURN_NOT_OK(operation1());
+///  VELOX_RETURN_NOT_OK(operation2());
+///  VELOX_RETURN_NOT_OK(operation3());
+///  ...
+
+/// This enum represents common categories of errors found in the library. These
+/// are not meant to cover every specific error situation, but rather cover
+/// broader categories of errors. Therefore, additions to this list should be
+/// infrequent.
+///
+/// Errors should be further described by attaching an error message to the
+/// Status object.
+///
+/// The error classes are loosely defined as follows:
+///
+/// - kOk: A successful operation. No errors.
+///
+/// - kUserError: An error triggered by bad input from an API user. The user
+///   in this context usually means the program using Velox (or its end users).
+///
+/// - kTypeError: An error triggered by a logical type mismatch (e.g. expecting
+///   BIGINT but REAL provided).
+///
+/// - kIndexError: An error triggered by the index of something being invalid or
+///   out-of-bounds.
+///
+/// - kKeyError: An error triggered by the key of something in a map/set being
+///   invalid or not found.
+///
+/// - kAlreadyExists: An error triggered by an operation meant to create some
+///   form of resource which already exists.
+///
+/// - kOutOfMemory: A failure triggered by a lack of available memory to
+///   complete the operation.
+///
+/// - kIOError: An error triggered by IO failures (e.g: network or disk/SSD read
+///   error).
+///
+/// - kCancelled: An error triggered because a certain resource required has
+///   been stopped or cancelled.
+///
+/// - kInvalid: An error triggered by an invalid program state. Usually
+///   triggered by bugs.
+///
+/// - kUnknownError: An error triggered by an unknown cause. Also usually
+///   triggered by bugs. Should be used scarcely, favoring a more specific error
+///   class above.
+///
+/// - kNotImplemented: An error triggered by a feature not being implemented
+///   yet.
+///
+enum class StatusCode : int8_t {
+  kOK = 0,
+  kUserError = 1,
+  kTypeError = 2,
+  kIndexError = 3,
+  kKeyError = 4,
+  kAlreadyExists = 5,
+  kOutOfMemory = 6,
+  kIOError = 7,
+  kCancelled = 8,
+  kInvalid = 9,
+  kUnknownError = 10,
+  kNotImplemented = 11,
+};
+std::string_view toString(StatusCode code);
+
+class [[nodiscard]] Status {
+ public:
+  // Create a success status.
+  constexpr Status() noexcept : state_(nullptr) {}
+
+  ~Status() noexcept {
+    if (FOLLY_UNLIKELY(state_ != nullptr)) {
+      deleteState();
+    }
+  }
+
+  explicit Status(StatusCode code);
+
+  Status(StatusCode code, std::string msg);
+
+  // Copy the specified status.
+  inline Status(const Status& s);
+  inline Status& operator=(const Status& s);
+
+  // Move the specified status.
+  inline Status(Status&& s) noexcept;
+  inline Status& operator=(Status&& s) noexcept;
+
+  inline bool operator==(const Status& other) const noexcept;
+  inline bool operator!=(const Status& other) const noexcept {
+    return !(*this == other);
+  }
+
+  // AND the statuses.
+  inline Status operator&(const Status& s) const noexcept;
+  inline Status operator&(Status&& s) const noexcept;
+  inline Status& operator&=(const Status& s) noexcept;
+  inline Status& operator&=(Status&& s) noexcept;
+
+  inline friend std::ostream& operator<<(std::ostream& ss, const Status& s) {
+    return ss << s.toString();
+  }
+
+  /// Return a success status.
+  static Status OK() {
+    return Status();
+  }
+
+  // The static factory methods below do not follow the lower camel-case pattern
+  // as they are meant to represent classes of errors. For example:
+  //
+  //   auto st1 = Status::UserError("my error"):
+  //   auto st2 = Status::TypeError("my other error"):
+
+  /// Return an error status for user errors.
+  template <typename... Args>
+  static Status UserError(Args&&... args) {
+    return Status::fromArgs(
+        StatusCode::kUserError, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status for type errors (such as mismatching data types)
+  template <typename... Args>
+  static Status TypeError(Args&&... args) {
+    return Status::fromArgs(
+        StatusCode::kTypeError, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status when an index is out of bounds
+  template <typename... Args>
+  static Status IndexError(Args&&... args) {
+    return Status::fromArgs(
+        StatusCode::kIndexError, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status for failed key lookups (e.g. column name in a
+  /// table)
+  template <typename... Args>
+  static Status KeyError(Args&&... args) {
+    return Status::fromArgs(StatusCode::kKeyError, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status when something already exists (e.g. a file).
+  template <typename... Args>
+  static Status AlreadyExists(Args&&... args) {
+    return Status::fromArgs(
+        StatusCode::kAlreadyExists, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status for out-of-memory conditions.
+  template <typename... Args>
+  static Status OutOfMemory(Args&&... args) {
+    return Status::fromArgs(
+        StatusCode::kOutOfMemory, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status when some IO-related operation failed
+  template <typename... Args>
+  static Status IOError(Args&&... args) {
+    return Status::fromArgs(StatusCode::kIOError, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status for cancelled operation
+  template <typename... Args>
+  static Status Cancelled(Args&&... args) {
+    return Status::fromArgs(
+        StatusCode::kCancelled, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status for invalid data (for example a string that fails
+  /// parsing)
+  template <typename... Args>
+  static Status Invalid(Args&&... args) {
+    return Status::fromArgs(StatusCode::kInvalid, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status for unknown errors
+  template <typename... Args>
+  static Status UnknownError(Args&&... args) {
+    return Status::fromArgs(
+        StatusCode::kUnknownError, std::forward<Args>(args)...);
+  }
+
+  /// Return an error status when an operation or a combination of operation and
+  /// data types is unimplemented
+  template <typename... Args>
+  static Status NotImplemented(Args&&... args) {
+    return Status::fromArgs(
+        StatusCode::kNotImplemented, std::forward<Args>(args)...);
+  }
+
+  /// Return true iff the status indicates success.
+  constexpr bool ok() const {
+    return (state_ == nullptr);
+  }
+
+  /// Return true iff the status indicates an user error.
+  constexpr bool isUserError() const {
+    return code() == StatusCode::kUserError;
+  }
+
+  /// Return true iff the status indicates a type error.
+  constexpr bool isTypeError() const {
+    return code() == StatusCode::kTypeError;
+  }
+
+  /// Return true iff the status indicates an out of bounds index.
+  constexpr bool isIndexError() const {
+    return code() == StatusCode::kIndexError;
+  }
+
+  /// Return true iff the status indicates a key lookup error.
+  constexpr bool isKeyError() const {
+    return code() == StatusCode::kKeyError;
+  }
+
+  /// Return true iff the status indicates that something already exists.
+  constexpr bool isAlreadyExists() const {
+    return code() == StatusCode::kAlreadyExists;
+  }
+
+  /// Return true iff the status indicates an out-of-memory error.
+  constexpr bool isOutOfMemory() const {
+    return code() == StatusCode::kOutOfMemory;
+  }
+
+  /// Return true iff the status indicates an IO-related failure.
+  constexpr bool isIOError() const {
+    return code() == StatusCode::kIOError;
+  }
+
+  /// Return true iff the status indicates a cancelled operation.
+  constexpr bool isCancelled() const {
+    return code() == StatusCode::kCancelled;
+  }
+
+  /// Return true iff the status indicates invalid data.
+  constexpr bool isInvalid() const {
+    return code() == StatusCode::kInvalid;
+  }
+
+  /// Return true iff the status indicates an unknown error.
+  constexpr bool isUnknownError() const {
+    return code() == StatusCode::kUnknownError;
+  }
+
+  /// Return true iff the status indicates an unimplemented operation.
+  constexpr bool isNotImplemented() const {
+    return code() == StatusCode::kNotImplemented;
+  }
+
+  /// Return a string representation of this status suitable for printing.
+  ///
+  /// The string "OK" is returned for success.
+  std::string toString() const;
+
+  /// Return a string representation of the status code, without the message
+  /// text or POSIX code information.
+  std::string_view codeAsString() const;
+  static std::string_view codeAsString(StatusCode);
+
+  /// Return the StatusCode value attached to this status.
+  constexpr StatusCode code() const {
+    return ok() ? StatusCode::kOK : state_->code;
+  }
+
+  /// Return the specific error message attached to this status.
+  const std::string& message() const {
+    static const std::string kNoMessage = "";
+    return ok() ? kNoMessage : state_->msg;
+  }
+
+  /// Return a new Status with changed message, copying the existing status
+  /// code.
+  template <typename... Args>
+  Status withMessage(Args&&... args) const {
+    return fromArgs(code(), std::forward<Args>(args)...);
+  }
+
+  void warn() const;
+  void warn(const std::string_view& message) const;
+
+  [[noreturn]] void abort() const;
+  [[noreturn]] void abort(const std::string_view& message) const;
+
+ private:
+  template <typename... Args>
+  static Status
+  fromArgs(StatusCode code, fmt::string_view fmt, Args&&... args) {
+    return Status(code, fmt::vformat(fmt, fmt::make_format_args(args...)));
+  }
+
+  static Status fromArgs(StatusCode code) {
+    return Status(code);
+  }
+
+  void deleteState() {
+    delete state_;
+    state_ = nullptr;
+  }
+
+  void copyFrom(const Status& s);
+  inline void moveFrom(Status& s);
+
+  struct State {
+    StatusCode code;
+    std::string msg;
+  };
+
+  // OK status has a `nullptr` state_.  Otherwise, `state_` points to
+  // a `State` structure containing the error code and message(s)
+  State* state_;
+};
+
+// Copy the specified status.
+Status::Status(const Status& s)
+    : state_((s.state_ == nullptr) ? nullptr : new State(*s.state_)) {}
+
+Status& Status::operator=(const Status& s) {
+  // The following condition catches both aliasing (when this == &s),
+  // and the common case where both s and *this are ok.
+  if (state_ != s.state_) {
+    copyFrom(s);
+  }
+  return *this;
+}
+
+// Move the specified status.
+Status::Status(Status&& s) noexcept : state_(s.state_) {
+  s.state_ = nullptr;
+}
+
+Status& Status::operator=(Status&& s) noexcept {
+  moveFrom(s);
+  return *this;
+}
+
+inline bool Status::operator==(const Status& other) const noexcept {
+  if (state_ == other.state_) {
+    return true;
+  }
+
+  if (ok() || other.ok()) {
+    return false;
+  }
+  return (code() == other.code()) && (message() == other.message());
+}
+
+Status Status::operator&(const Status& s) const noexcept {
+  if (ok()) {
+    return s;
+  } else {
+    return *this;
+  }
+}
+
+Status Status::operator&(Status&& s) const noexcept {
+  if (ok()) {
+    return std::move(s);
+  } else {
+    return *this;
+  }
+}
+
+Status& Status::operator&=(const Status& s) noexcept {
+  if (ok() && !s.ok()) {
+    copyFrom(s);
+  }
+  return *this;
+}
+
+Status& Status::operator&=(Status&& s) noexcept {
+  if (ok() && !s.ok()) {
+    moveFrom(s);
+  }
+  return *this;
+}
+
+void Status::moveFrom(Status& s) {
+  delete state_;
+  state_ = s.state_;
+  s.state_ = nullptr;
+}
+
+// Helper Macros.
+
+#define _VELOX_STRINGIFY(x) #x
+
+/// Return with given status if condition is met.
+#define VELOX_RETURN_IF(condition, status) \
+  do {                                     \
+    if (FOLLY_UNLIKELY(condition)) {       \
+      return (status);                     \
+    }                                      \
+  } while (0)
+
+/// Propagate any non-successful Status to the caller.
+#define VELOX_RETURN_NOT_OK(status)                           \
+  do {                                                        \
+    ::facebook::velox::Status __s =                           \
+        ::facebook::velox::internal::genericToStatus(status); \
+    VELOX_RETURN_IF(!__s.ok(), __s);                          \
+  } while (false)
+
+namespace internal {
+
+/// Common API for extracting Status from either Status or Result<T> (the latter
+/// is defined in Result.h).
+/// Useful for status check macros such as VELOX_RETURN_NOT_OK.
+inline const Status& genericToStatus(const Status& st) {
+  return st;
+}
+inline Status genericToStatus(Status&& st) {
+  return std::move(st);
+}
+
+} // namespace internal
+
+/// Holds a result or an error. Designed to be used by APIs that do not throw.
+///
+/// Here is an example of a modulo operation that doesn't throw, but indicates
+/// failure using Status.
+///
+/// Expected<int> modulo(int a, int b) {
+///   if (b == 0) {
+///     return folly::makeUnexpected(Status::UserError("division by zero"));
+///   }
+///
+///   return a % b;
+/// }
+///
+/// Status should not be OK.
+template <typename T>
+using Expected = folly::Expected<T, Status>;
+
+} // namespace facebook::velox
+
+template <>
+struct fmt::formatter<facebook::velox::Status> : fmt::formatter<std::string> {
+  auto format(const facebook::velox::Status& s, format_context& ctx) const {
+    return formatter<std::string>::format(s.toString(), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::StatusCode>
+    : fmt::formatter<std::string_view> {
+  auto format(facebook::velox::StatusCode code, format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::toString(code), ctx);
+  }
+};
diff --git a/velox/common/base/SuccinctPrinter.h b/velox/common/base/SuccinctPrinter.h
index e5c3cc9cf9871..a09b487a912a8 100644
--- a/velox/common/base/SuccinctPrinter.h
+++ b/velox/common/base/SuccinctPrinter.h
@@ -15,6 +15,8 @@
  */
 
 #pragma once
+
+#include <cstdint>
 #include <string>
 
 namespace facebook::velox {
diff --git a/velox/common/base/VeloxException.cpp b/velox/common/base/VeloxException.cpp
index ffdb32ac853eb..0c00c461b5e95 100644
--- a/velox/common/base/VeloxException.cpp
+++ b/velox/common/base/VeloxException.cpp
@@ -25,7 +25,7 @@ namespace velox {
 std::exception_ptr toVeloxException(const std::exception_ptr& exceptionPtr) {
   try {
     std::rethrow_exception(exceptionPtr);
-  } catch (const VeloxException& e) {
+  } catch (const VeloxException&) {
     return exceptionPtr;
   } catch (const std::exception& e) {
     return std::make_exception_ptr(
@@ -38,34 +38,41 @@ int64_t& threadNumVeloxThrow() {
   return numThrow;
 }
 
+bool& threadSkipErrorDetails() {
+  thread_local bool skipErrorDetails{false};
+  return skipErrorDetails;
+}
+
 ExceptionContext& getExceptionContext() {
   thread_local ExceptionContext context;
   return context;
 }
 
-// Retrieves the message of the top-level ancestor of the current exception
-// context. If the top-level context message is not empty and is the same as the
-// current one, returns a string indicating they are the same.
-std::string getTopLevelExceptionContextString(
+// Traverses the context hierarchy and appends messages from all contexts that
+// are marked as essential.
+std::string getAdditionalExceptionContextString(
     VeloxException::Type exceptionType,
     const std::string& currentMessage) {
   auto* context = &getExceptionContext();
-  if (context->parent && context->parent->parent) {
-    while (context->parent && context->parent->parent) {
-      context = context->parent;
-    }
-    auto topLevelMessage = context->message(exceptionType);
-    if (!topLevelMessage.empty() && topLevelMessage == currentMessage) {
-      return "Same as context.";
-    } else {
-      return topLevelMessage;
+  std::string additionalMessage = "";
+  if (!context->parent || !context->parent->parent) {
+    return additionalMessage;
+  }
+  context = context->parent;
+  while (context->parent) {
+    if (context->isEssential) {
+      auto message = context->message(exceptionType);
+      if (!message.empty()) {
+        additionalMessage += message + " ";
+      }
     }
+    context = context->parent;
   }
-
-  if (!currentMessage.empty()) {
-    return "Same as context.";
+  if (!additionalMessage.empty()) {
+    // Get rid of the extra space at the end.
+    additionalMessage.pop_back();
   }
-  return "";
+  return additionalMessage;
 }
 
 VeloxException::VeloxException(
@@ -90,8 +97,8 @@ VeloxException::VeloxException(
         state.errorSource = errorSource;
         state.errorCode = errorCode;
         state.context = getExceptionContext().message(exceptionType);
-        state.topLevelContext =
-            getTopLevelExceptionContextString(exceptionType, state.context);
+        state.additionalContext =
+            getAdditionalExceptionContextString(exceptionType, state.context);
         state.isRetriable = isRetriable;
       })) {}
 
@@ -114,8 +121,8 @@ VeloxException::VeloxException(
         state.errorSource = errorSource;
         state.errorCode = errorCode;
         state.context = getExceptionContext().message(exceptionType);
-        state.topLevelContext =
-            getTopLevelExceptionContextString(exceptionType, state.context);
+        state.additionalContext =
+            getAdditionalExceptionContextString(exceptionType, state.context);
         state.isRetriable = isRetriable;
         state.wrappedException = e;
       })) {}
@@ -223,8 +230,8 @@ void VeloxException::State::finalize() const {
     elaborateMessage += "Context: " + context + "\n";
   }
 
-  if (!topLevelContext.empty()) {
-    elaborateMessage += "Top-Level Context: " + topLevelContext + "\n";
+  if (!additionalContext.empty()) {
+    elaborateMessage += "Additional Context: " + additionalContext + "\n";
   }
 
   if (function) {
diff --git a/velox/common/base/VeloxException.h b/velox/common/base/VeloxException.h
index 15930f4ee49df..bb22e9a490c23 100644
--- a/velox/common/base/VeloxException.h
+++ b/velox/common/base/VeloxException.h
@@ -99,11 +99,23 @@ inline constexpr auto kMemAllocError = "MEM_ALLOC_ERROR"_fs;
 // Error caused by failing to allocate cache buffer space for IO.
 inline constexpr auto kNoCacheSpace = "NO_CACHE_SPACE"_fs;
 
+// An error raised when spill bytes exceeds limits.
+inline constexpr auto kSpillLimitExceeded = "SPILL_LIMIT_EXCEEDED"_fs;
+
 // Errors indicating file read corruptions.
 inline constexpr auto kFileCorruption = "FILE_CORRUPTION"_fs;
 
+// Errors indicating file not found.
+inline constexpr auto kFileNotFound = "FILE_NOT_FOUND"_fs;
+
 // We do not know how to classify it yet.
 inline constexpr auto kUnknown = "UNKNOWN"_fs;
+
+// VeloxRuntimeErrors due to unsupported input values such as unicode input to
+// cast-varchar-to-integer and timestamps beyond the year 2037 to datetime
+// functions. This kind of errors is allowed in expression fuzzer.
+inline constexpr auto kUnsupportedInputUncatchable =
+    "UNSUPPORTED_INPUT_UNCATCHABLE"_fs;
 } // namespace error_code
 
 class VeloxException : public std::exception {
@@ -201,8 +213,8 @@ class VeloxException : public std::exception {
     return state_->context;
   }
 
-  const std::string& topLevelContext() const {
-    return state_->topLevelContext;
+  const std::string& additionalContext() const {
+    return state_->additionalContext;
   }
 
   const std::exception_ptr& wrappedException() const {
@@ -224,7 +236,7 @@ class VeloxException : public std::exception {
     // The current exception context.
     std::string context;
     // The top-level ancestor of the current exception context.
-    std::string topLevelContext;
+    std::string additionalContext;
     bool isRetriable;
     // The original std::exception.
     std::exception_ptr wrappedException;
@@ -335,6 +347,25 @@ class VeloxRuntimeError final : public VeloxException {
 /// Returns a reference to a thread level counter of Velox error throws.
 int64_t& threadNumVeloxThrow();
 
+/// Returns a reference to a thread level boolean that controls whether no-throw
+/// APIs include detailed error messages in Status.
+bool& threadSkipErrorDetails();
+
+class ScopedThreadSkipErrorDetails {
+ public:
+  ScopedThreadSkipErrorDetails(bool skip = true)
+      : original_{threadSkipErrorDetails()} {
+    threadSkipErrorDetails() = skip;
+  }
+
+  ~ScopedThreadSkipErrorDetails() {
+    threadSkipErrorDetails() = original_;
+  }
+
+ private:
+  bool original_;
+};
+
 /// Holds a pointer to a function that provides addition context to be
 /// added to the detailed error message in case of an exception.
 struct ExceptionContext {
@@ -347,6 +378,10 @@ struct ExceptionContext {
   /// Value to pass to `messageFunc`. Can be null.
   void* arg{nullptr};
 
+  /// If true, then the addition context in 'this' is always included when there
+  /// are hierarchical exception contexts.
+  bool isEssential{false};
+
   /// Pointer to the parent context when there are hierarchical exception
   /// contexts.
   ExceptionContext* parent{nullptr};
diff --git a/velox/common/base/benchmarks/BitUtilBenchmark.cpp b/velox/common/base/benchmarks/BitUtilBenchmark.cpp
index 6f8ac7cefbbd2..453c61ddcaefc 100644
--- a/velox/common/base/benchmarks/BitUtilBenchmark.cpp
+++ b/velox/common/base/benchmarks/BitUtilBenchmark.cpp
@@ -191,7 +191,7 @@ BENCHMARK_RELATIVE_MULTI(forEachBitFirstBitFalse) {
 } // namespace facebook
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/common/base/benchmarks/SimdUtilBenchmark.cpp b/velox/common/base/benchmarks/SimdUtilBenchmark.cpp
new file mode 100644
index 0000000000000..c358b673c05ae
--- /dev/null
+++ b/velox/common/base/benchmarks/SimdUtilBenchmark.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/SimdUtil.h"
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include <random>
+
+namespace facebook::velox {
+namespace {
+
+#define VELOX_BENCHMARK(_type, _name, ...) \
+  [[maybe_unused]] _type _name(FOLLY_PP_STRINGIZE(_name), __VA_ARGS__)
+
+template <typename T>
+class LeadingMask {
+ public:
+  LeadingMask(const char* name, std::default_random_engine& gen) {
+    std::uniform_int_distribution<> dist(0, xsimd::batch<T>::size + 1);
+    for (int i = 0; i < kSize; ++i) {
+      inputs_[i] = dist(gen);
+    }
+    folly::addBenchmark(__FILE__, name, [this] { return run(); });
+  }
+
+ private:
+  unsigned run() {
+    xsimd::batch_bool<T> ans = {};
+    for (int i = 0; i < kSize; ++i) {
+      ans = ans ^ simd::leadingMask<T>(inputs_[i]);
+    }
+    folly::doNotOptimizeAway(ans);
+    return kSize;
+  }
+
+  static constexpr int kSize = 4 << 10;
+  int8_t inputs_[kSize];
+};
+
+template <typename T>
+class FromBitMask {
+ public:
+  FromBitMask(const char* name, std::default_random_engine& gen) {
+    std::uniform_int_distribution<uint64_t> dist(
+        0, (1ull << xsimd::batch<T>::size) - 1);
+    for (int i = 0; i < kSize; ++i) {
+      inputs_[i] = dist(gen);
+    }
+    folly::addBenchmark(__FILE__, name, [this] { return run(); });
+  }
+
+ private:
+  unsigned run() {
+    xsimd::batch_bool<T> ans = {};
+    for (int i = 0; i < kSize; ++i) {
+      ans = ans ^ simd::fromBitMask<T>(inputs_[i]);
+    }
+    folly::doNotOptimizeAway(ans);
+    return kSize;
+  }
+
+  static constexpr int kSize = 2 << 10;
+  uint64_t inputs_[kSize];
+};
+
+} // namespace
+} // namespace facebook::velox
+
+int main(int argc, char* argv[]) {
+  using namespace facebook::velox;
+  folly::Init follyInit(&argc, &argv);
+  std::default_random_engine gen(std::random_device{}());
+  VELOX_BENCHMARK(LeadingMask<int32_t>, leadingMaskInt32, gen);
+  VELOX_BENCHMARK(LeadingMask<int64_t>, leadingMaskInt64, gen);
+  VELOX_BENCHMARK(FromBitMask<int32_t>, fromBitMaskInt32, gen);
+  VELOX_BENCHMARK(FromBitMask<int64_t>, fromBitMaskInt64, gen);
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/common/base/tests/AsyncSourceTest.cpp b/velox/common/base/tests/AsyncSourceTest.cpp
index 1ed6f90893d17..657a7ba8e08e8 100644
--- a/velox/common/base/tests/AsyncSourceTest.cpp
+++ b/velox/common/base/tests/AsyncSourceTest.cpp
@@ -18,11 +18,13 @@
 #include <fmt/format.h>
 #include <folly/Random.h>
 #include <folly/Synchronized.h>
+#include <folly/synchronization/Baton.h>
 #include <gtest/gtest.h>
 #include <thread>
 #include "velox/common/base/Exceptions.h"
 
 using namespace facebook::velox;
+using namespace std::chrono_literals;
 
 // A sample class to be constructed via AsyncSource.
 struct Gizmo {
@@ -39,6 +41,7 @@ TEST(AsyncSourceTest, basic) {
   auto value = gizmo.move();
   EXPECT_FALSE(gizmo.hasValue());
   EXPECT_EQ(11, value->id);
+  EXPECT_EQ(1, gizmo.prepareTiming().count);
 
   AsyncSource<Gizmo> error(
       []() -> std::unique_ptr<Gizmo> { VELOX_USER_FAIL("Testing error"); });
@@ -111,7 +114,7 @@ TEST(AsyncSourceTest, errorsWithThreads) {
   std::atomic<int32_t> numErrors{0};
   for (auto i = 0; i < kNumGizmos; ++i) {
     gizmos.push_back(
-        std::make_shared<AsyncSource<Gizmo>>([i]() -> std::unique_ptr<Gizmo> {
+        std::make_shared<AsyncSource<Gizmo>>([]() -> std::unique_ptr<Gizmo> {
           std::this_thread::sleep_for(std::chrono::milliseconds(1)); // NOLINT
           VELOX_USER_FAIL("Testing error");
         }));
@@ -136,7 +139,7 @@ TEST(AsyncSourceTest, errorsWithThreads) {
             auto gizmo =
                 gizmos[folly::Random::rand32(rng) % gizmos.size()]->move();
             EXPECT_EQ(nullptr, gizmo);
-          } catch (std::exception& e) {
+          } catch (std::exception&) {
             ++numErrors;
           }
         }
@@ -149,4 +152,147 @@ TEST(AsyncSourceTest, errorsWithThreads) {
   // There will always be errors since the first to wait for any given
   // gizmo is sure to get an error.
   EXPECT_LT(0, numErrors);
+  for (auto& source : gizmos) {
+    source->close();
+  }
+}
+
+class DataCounter {
+ public:
+  DataCounter() {
+    objectNumber_ = ++numCreatedDataCounters_;
+  }
+
+  ~DataCounter() {
+    ++numDeletedDataCounters_;
+  }
+
+  static uint64_t numCreatedDataCounters() {
+    return numCreatedDataCounters_;
+  }
+
+  static uint64_t numDeletedDataCounters() {
+    return numDeletedDataCounters_;
+  }
+
+  static void reset() {
+    numCreatedDataCounters_ = 0;
+    numDeletedDataCounters_ = 0;
+  }
+
+  uint64_t objectNumber() const {
+    return objectNumber_;
+  }
+
+ private:
+  static std::atomic<uint64_t> numCreatedDataCounters_;
+  static std::atomic<uint64_t> numDeletedDataCounters_;
+
+  uint64_t objectNumber_{0};
+};
+
+std::atomic<uint64_t> DataCounter::numCreatedDataCounters_ = 0;
+
+std::atomic<uint64_t> DataCounter::numDeletedDataCounters_ = 0;
+
+TEST(AsyncSourceTest, close) {
+  // If 'prepare()' is not executed within the thread pool, invoking 'close()'
+  // will set 'make_' to nullptr. The deletion of 'dateCounter' is used as a
+  // verification for this behavior.
+  auto dateCounter = std::make_shared<DataCounter>();
+  AsyncSource<uint64_t> countAsyncSource([dateCounter]() {
+    return std::make_unique<uint64_t>(dateCounter->objectNumber());
+  });
+  dateCounter.reset();
+  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 0);
+
+  countAsyncSource.close();
+  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+  DataCounter::reset();
+
+  // If 'prepare()' is executed within the thread pool but 'move()' is not
+  // invoked, invoking 'close()' will set 'item_' to nullptr. The deletion of
+  // 'dateCounter' is used as a verification for this behavior.
+  auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+      []() { return std::make_unique<DataCounter>(); });
+  asyncSource->prepare();
+  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 0);
+
+  asyncSource->close();
+  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+  DataCounter::reset();
+
+  // If 'prepare()' is currently being executed within the thread pool,
+  // 'close()' should wait for the completion of 'prepare()' and set 'item_' to
+  // nullptr.
+  folly::Baton<> baton;
+  auto sleepAsyncSource =
+      std::make_shared<AsyncSource<DataCounter>>([&baton]() {
+        baton.post();
+        return std::make_unique<DataCounter>();
+      });
+  auto thread1 =
+      std::thread([&sleepAsyncSource] { sleepAsyncSource->prepare(); });
+  EXPECT_TRUE(baton.try_wait_for(1s));
+  sleepAsyncSource->close();
+  EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+  thread1.join();
+}
+
+void verifyContexts(
+    const std::string& expectedPoolName,
+    const std::string& expectedTaskId) {
+  EXPECT_EQ(process::GetThreadDebugInfo()->taskId_, expectedTaskId);
+}
+
+TEST(AsyncSourceTest, emptyContexts) {
+  EXPECT_EQ(process::GetThreadDebugInfo(), nullptr);
+
+  AsyncSource<bool> src([]() {
+    // The Contexts at the time this was created were null so we should inherit
+    // them from the caller.
+    verifyContexts("test", "task_id");
+
+    return std::make_unique<bool>(true);
+  });
+
+  process::ThreadDebugInfo debugInfo{"query_id", "task_id", nullptr};
+  process::ScopedThreadDebugInfo scopedDebugInfo(debugInfo);
+
+  verifyContexts("test", "task_id");
+
+  ASSERT_TRUE(*src.move());
+
+  verifyContexts("test", "task_id");
+}
+
+TEST(AsyncSourceTest, setContexts) {
+  process::ThreadDebugInfo debugInfo1{"query_id1", "task_id1", nullptr};
+
+  std::unique_ptr<AsyncSource<bool>> src;
+  process::ScopedThreadDebugInfo scopedDebugInfo1(debugInfo1);
+
+  verifyContexts("test1", "task_id1");
+
+  src = std::make_unique<AsyncSource<bool>>(([]() {
+    // The Contexts at the time this was created were set so we should have
+    // the same contexts when this is executed.
+    verifyContexts("test1", "task_id1");
+
+    return std::make_unique<bool>(true);
+  }));
+
+  process::ThreadDebugInfo debugInfo2{"query_id2", "task_id2", nullptr};
+  process::ScopedThreadDebugInfo scopedDebugInfo2(debugInfo2);
+
+  verifyContexts("test2", "task_id2");
+
+  ASSERT_TRUE(*src->move());
+
+  verifyContexts("test2", "task_id2");
 }
diff --git a/velox/common/base/tests/BitUtilTest.cpp b/velox/common/base/tests/BitUtilTest.cpp
index 36d63f0dd1a81..c0c31464d3b51 100644
--- a/velox/common/base/tests/BitUtilTest.cpp
+++ b/velox/common/base/tests/BitUtilTest.cpp
@@ -461,12 +461,29 @@ TEST_F(BitUtilTest, forEachBit) {
 }
 
 TEST_F(BitUtilTest, hash) {
-  std::unordered_set<size_t> hashes;
-  const char* text = "Forget the night, come live with us in forests of azure";
-  for (int32_t i = 0; i < strlen(text); ++i) {
-    hashes.insert(hashBytes(1, text, i));
+  std::unordered_map<uint64_t, int32_t> hashes;
+  std::string text =
+      "Forget the night, come live with us in forests of azure, "
+      "for we have constructed pyramids in honor of our escaping...";
+  for (int32_t i = 0; i < text.size(); ++i) {
+    // starts hashing at unaligned addresses.
+    int32_t offset = i > 3 && i < text.size() - 3 ? i % 3 : 0;
+    auto hash = hashBytes(1, text.data() + offset, i);
+    if (i + offset < text.size() - 1) {
+      ++text[i + offset];
+      // Change the first byte after the hashed range and check that the hash
+      // function does not overread its range.
+      EXPECT_EQ(hash, hashBytes(1, text.data() + offset, i));
+      --text[i + offset];
+    }
+    auto it = hashes.find(hash);
+    if (it == hashes.end()) {
+      hashes[hash] = i;
+    } else {
+      EXPECT_TRUE(false) << "Duplicate hash at " << i;
+    }
   }
-  EXPECT_EQ(hashes.size(), strlen(text));
+  EXPECT_EQ(hashes.size(), text.size());
 }
 
 TEST_F(BitUtilTest, nextPowerOfTwo) {
@@ -482,6 +499,9 @@ TEST_F(BitUtilTest, nextPowerOfTwo) {
   EXPECT_EQ(nextPowerOfTwo(31), 32);
   EXPECT_EQ(nextPowerOfTwo(32), 32);
   EXPECT_EQ(nextPowerOfTwo(33), 64);
+  EXPECT_EQ(nextPowerOfTwo(1ULL << 32), 1ULL << 32);
+  EXPECT_EQ(nextPowerOfTwo((1ULL << 32) + 1), 1ULL << 33);
+  EXPECT_EQ(nextPowerOfTwo((1ULL << 62) + 1), 1ULL << 63);
 }
 
 TEST_F(BitUtilTest, isPowerOfTwo) {
@@ -833,6 +853,84 @@ TEST_F(BitUtilTest, countLeadingZeros) {
   EXPECT_EQ(
       countLeadingZeros<__uint128_t>(HugeInt::build(0x08FFFFFFFFFFFFFF, 0)), 4);
 }
+
+TEST_F(BitUtilTest, storeBitsToByte) {
+  uint8_t bytes[3]{};
+  storeBitsToByte<8>(0xAA, bytes, 0);
+  ASSERT_EQ(bytes[0], 0xAA);
+  ASSERT_EQ(bytes[1], 0);
+  ASSERT_EQ(bytes[2], 0);
+  storeBitsToByte<4>(0x5, bytes, 8);
+  ASSERT_EQ(bytes[0], 0xAA);
+  ASSERT_EQ(bytes[1], 0x5);
+  ASSERT_EQ(bytes[2], 0);
+  storeBitsToByte<4>(0xA, bytes, 12);
+  ASSERT_EQ(bytes[0], 0xAA);
+  ASSERT_EQ(bytes[1], 0xA5);
+  ASSERT_EQ(bytes[2], 0);
+}
+
+TEST_F(BitUtilTest, roundUp) {
+  struct {
+    uint64_t value;
+    uint64_t factor;
+    uint64_t expected;
+
+    std::string debugString() const {
+      return fmt::format(
+          "value: {}, factor: {}, expected: {}", value, factor, expected);
+    }
+  } testSettings[] = {
+      {10, 1, 10},
+      {10, 3, 12},
+      {10, 4, 12},
+      {10, 10, 10},
+      {10, 11, 11},
+      {10, 20, 20},
+      {11, 1, 11},
+      {11, 3, 12},
+      {11, 4, 12},
+      {11, 11, 11},
+      {11, 12, 12},
+      {11, 23, 23}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    ASSERT_EQ(
+        bits::roundUp(testData.value, testData.factor), testData.expected);
+  }
+}
+
+TEST_F(BitUtilTest, divRoundUp) {
+  struct {
+    uint64_t value;
+    uint64_t factor;
+    uint64_t expected;
+
+    std::string debugString() const {
+      return fmt::format(
+          "value: {}, factor: {}, expected: {}", value, factor, expected);
+    }
+  } testSettings[] = {
+      {10, 1, 10},
+      {10, 3, 4},
+      {10, 4, 3},
+      {10, 10, 1},
+      {10, 11, 1},
+      {10, 20, 1},
+      {11, 1, 11},
+      {11, 3, 4},
+      {11, 4, 3},
+      {11, 11, 1},
+      {11, 12, 1},
+      {11, 23, 1}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    ASSERT_EQ(
+        bits::divRoundUp(testData.value, testData.factor), testData.expected);
+  }
+}
 } // namespace bits
 } // namespace velox
 } // namespace facebook
diff --git a/velox/common/base/tests/CMakeLists.txt b/velox/common/base/tests/CMakeLists.txt
index 4731d686db904..51fa95a14f95f 100644
--- a/velox/common/base/tests/CMakeLists.txt
+++ b/velox/common/base/tests/CMakeLists.txt
@@ -18,31 +18,42 @@ add_executable(
   BitUtilTest.cpp
   BloomFilterTest.cpp
   CoalesceIoTest.cpp
+  ConcurrentCounterTest.cpp
   ExceptionTest.cpp
   FsTest.cpp
   RangeTest.cpp
   RawVectorTest.cpp
   RuntimeMetricsTest.cpp
   ScopedLockTest.cpp
+  ScratchTest.cpp
   SemaphoreTest.cpp
   SimdUtilTest.cpp
+  SpillConfigTest.cpp
+  SpillStatsTest.cpp
   StatsReporterTest.cpp
+  StatusTest.cpp
   SuccinctPrinterTest.cpp)
 
 add_test(velox_base_test velox_base_test)
 
 target_link_libraries(
   velox_base_test
-  PRIVATE velox_common_base
-          velox_exception
-          velox_temp_path
-          Boost::filesystem
-          Boost::headers
-          Folly::folly
-          fmt::fmt
-          gflags::gflags
-          gtest
-          gtest_main)
+  PRIVATE
+    velox_caching
+    velox_common_base
+    velox_memory
+    velox_time
+    velox_status
+    velox_exception
+    velox_temp_path
+    Boost::filesystem
+    Boost::headers
+    Folly::folly
+    fmt::fmt
+    gflags::gflags
+    GTest::gtest
+    GTest::gmock
+    GTest::gtest_main)
 
 add_executable(velox_id_map_test IdMapTest.cpp)
 
@@ -56,11 +67,16 @@ target_link_libraries(
   Boost::headers
   gflags::gflags
   glog::glog
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   pthread)
 
 add_executable(velox_memcpy_meter Memcpy.cpp)
 target_link_libraries(
-  velox_memcpy_meter PRIVATE velox_common_base velox_exception velox_time
-                             Folly::folly gflags::gflags)
+  velox_memcpy_meter
+  PRIVATE
+    velox_common_base
+    velox_exception
+    velox_time
+    Folly::folly
+    gflags::gflags)
diff --git a/velox/common/base/tests/ConcurrentCounterTest.cpp b/velox/common/base/tests/ConcurrentCounterTest.cpp
new file mode 100644
index 0000000000000..5b5975a2389fe
--- /dev/null
+++ b/velox/common/base/tests/ConcurrentCounterTest.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/ConcurrentCounter.h"
+
+#include <fmt/format.h>
+#include <folly/Random.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+
+namespace facebook::velox::common::test {
+
+class ConcurrentCounterTest : public testing::TestWithParam<bool> {
+ protected:
+  void SetUp() override {
+    setupCounter();
+  }
+
+  void update(int64_t delta) {
+    if (useUpdateFn_) {
+      counter_->update(
+          delta, [&](int64_t& counter, int64_t delta, std::mutex& lock) {
+            std::lock_guard<std::mutex> l(lock);
+            counter += delta;
+            return true;
+          });
+    } else {
+      counter_->update(delta);
+    }
+  }
+
+  int64_t read() const {
+    return counter_->read();
+  }
+
+  void setupCounter() {
+    counter_ = std::make_unique<ConcurrentCounter<int64_t>>(
+        std::thread::hardware_concurrency());
+  }
+
+  const bool useUpdateFn_{GetParam()};
+
+  std::unique_ptr<ConcurrentCounter<int64_t>> counter_;
+};
+
+TEST_P(ConcurrentCounterTest, basic) {
+  ASSERT_EQ(read(), 0);
+  update(1);
+  ASSERT_EQ(read(), 1);
+  update(1);
+  ASSERT_EQ(read(), 2);
+  update(-1);
+  ASSERT_EQ(read(), 1);
+  update(-3);
+  ASSERT_EQ(read(), -2);
+}
+
+TEST_P(ConcurrentCounterTest, multithread) {
+  const int32_t numUpdatesPerThread = 5'000;
+  std::vector<int> numThreads;
+  numThreads.push_back(1);
+  numThreads.push_back(std::thread::hardware_concurrency());
+  numThreads.push_back(std::thread::hardware_concurrency() * 2);
+  for (int numThreads : numThreads) {
+    SCOPED_TRACE(fmt::format("numThreads: {}", numThreads));
+    counter_->testingClear();
+    ASSERT_EQ(counter_->read(), 0);
+
+    std::vector<std::thread> threads;
+    threads.reserve(numThreads);
+    std::vector<int64_t> counts(numThreads, 0);
+    for (size_t i = 0; i < numThreads; ++i) {
+      ASSERT_EQ(counts[i], 0);
+      threads.emplace_back([&, i]() {
+        folly::Random::DefaultGenerator rng;
+        rng.seed(1234 + i);
+        ASSERT_EQ(counts[i], 0);
+        for (int j = 0; j < numUpdatesPerThread; ++j) {
+          const int delta = folly::Random::rand32(rng);
+          counts[i] += delta;
+          update(delta);
+        }
+      });
+    }
+
+    for (auto& th : threads) {
+      th.join();
+    }
+    int64_t expectedCount{0};
+    for (int i = 0; i < numThreads; ++i) {
+      expectedCount += counts[i];
+    }
+    ASSERT_EQ(read(), expectedCount);
+  }
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    ConcurrentCounterTestSuite,
+    ConcurrentCounterTest,
+    testing::ValuesIn({false, true}));
+
+} // namespace facebook::velox::common::test
diff --git a/velox/common/base/tests/ExceptionTest.cpp b/velox/common/base/tests/ExceptionTest.cpp
index 4e5dd6dbaa54d..9386b8cb672e0 100644
--- a/velox/common/base/tests/ExceptionTest.cpp
+++ b/velox/common/base/tests/ExceptionTest.cpp
@@ -583,11 +583,13 @@ TEST(ExceptionTest, context) {
   };
 
   {
-    // Create multi-layer contexts.
+    // Create multi-layer contexts with top level marked as essential.
     MessageFunctionArg topLevelTroubleshootingAid{
         "Top-level troubleshooting aid.", &callCount};
-    facebook::velox::ExceptionContextSetter topLevelContext(
-        {messageFunction, &topLevelTroubleshootingAid});
+    facebook::velox::ExceptionContextSetter additionalContext(
+        {.messageFunc = messageFunction,
+         .arg = &topLevelTroubleshootingAid,
+         .isEssential = true});
 
     MessageFunctionArg midLevelTroubleshootingAid{
         "Mid-level troubleshooting aid.", &callCount};
@@ -608,7 +610,7 @@ TEST(ExceptionTest, context) {
         "\nRetriable: False"
         "\nExpression: 1 == 3"
         "\nContext: System error: Inner-level troubleshooting aid."
-        "\nTop-Level Context: System error: Top-level troubleshooting aid."
+        "\nAdditional Context: System error: Top-level troubleshooting aid."
         "\nFunction: operator()"
         "\nFile: ");
 
@@ -623,13 +625,164 @@ TEST(ExceptionTest, context) {
         "\nRetriable: False"
         "\nExpression: 1 == 3"
         "\nContext: User error: Inner-level troubleshooting aid."
-        "\nTop-Level Context: User error: Top-level troubleshooting aid."
+        "\nAdditional Context: User error: Top-level troubleshooting aid."
         "\nFunction: operator()"
         "\nFile: ");
 
     EXPECT_EQ(4, callCount);
   }
 
+  {
+    callCount = 0;
+    // Create multi-layer contexts with middle level marked as essential.
+    MessageFunctionArg topLevelTroubleshootingAid{
+        "Top-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter additionalContext(
+        {.messageFunc = messageFunction, .arg = &topLevelTroubleshootingAid});
+
+    MessageFunctionArg midLevelTroubleshootingAid{
+        "Mid-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter midLevelContext(
+        {.messageFunc = messageFunction,
+         .arg = &midLevelTroubleshootingAid,
+         .isEssential = true});
+
+    MessageFunctionArg innerLevelTroubleshootingAid{
+        "Inner-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter innerLevelContext(
+        {messageFunction, &innerLevelTroubleshootingAid});
+
+    verifyVeloxException(
+        [&]() { VELOX_CHECK_EQ(1, 3); },
+        "Exception: VeloxRuntimeError"
+        "\nError Source: RUNTIME"
+        "\nError Code: INVALID_STATE"
+        "\nReason: (1 vs. 3)"
+        "\nRetriable: False"
+        "\nExpression: 1 == 3"
+        "\nContext: System error: Inner-level troubleshooting aid."
+        "\nAdditional Context: System error: Mid-level troubleshooting aid."
+        "\nFunction: operator()"
+        "\nFile: ");
+
+    EXPECT_EQ(2, callCount);
+
+    verifyVeloxException(
+        [&]() { VELOX_USER_CHECK_EQ(1, 3); },
+        "Exception: VeloxUserError"
+        "\nError Source: USER"
+        "\nError Code: INVALID_ARGUMENT"
+        "\nReason: (1 vs. 3)"
+        "\nRetriable: False"
+        "\nExpression: 1 == 3"
+        "\nContext: User error: Inner-level troubleshooting aid."
+        "\nAdditional Context: User error: Mid-level troubleshooting aid."
+        "\nFunction: operator()"
+        "\nFile: ");
+
+    EXPECT_EQ(4, callCount);
+  }
+
+  {
+    callCount = 0;
+    // Create multi-layer contexts with none marked as essential.
+    MessageFunctionArg topLevelTroubleshootingAid{
+        "Top-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter additionalContext(
+        {.messageFunc = messageFunction, .arg = &topLevelTroubleshootingAid});
+
+    MessageFunctionArg midLevelTroubleshootingAid{
+        "Mid-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter midLevelContext(
+        {.messageFunc = messageFunction, .arg = &midLevelTroubleshootingAid});
+
+    MessageFunctionArg innerLevelTroubleshootingAid{
+        "Inner-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter innerLevelContext(
+        {messageFunction, &innerLevelTroubleshootingAid});
+
+    verifyVeloxException(
+        [&]() { VELOX_CHECK_EQ(1, 3); },
+        "Exception: VeloxRuntimeError"
+        "\nError Source: RUNTIME"
+        "\nError Code: INVALID_STATE"
+        "\nReason: (1 vs. 3)"
+        "\nRetriable: False"
+        "\nExpression: 1 == 3"
+        "\nContext: System error: Inner-level troubleshooting aid."
+        "\nFunction: operator()"
+        "\nFile: ");
+
+    EXPECT_EQ(1, callCount);
+
+    verifyVeloxException(
+        [&]() { VELOX_USER_CHECK_EQ(1, 3); },
+        "Exception: VeloxUserError"
+        "\nError Source: USER"
+        "\nError Code: INVALID_ARGUMENT"
+        "\nReason: (1 vs. 3)"
+        "\nRetriable: False"
+        "\nExpression: 1 == 3"
+        "\nContext: User error: Inner-level troubleshooting aid."
+        "\nFunction: operator()"
+        "\nFile: ");
+
+    EXPECT_EQ(2, callCount);
+  }
+
+  {
+    callCount = 0;
+    // Create multi-layer contexts with all ancestors marked as essential.
+    MessageFunctionArg topLevelTroubleshootingAid{
+        "Top-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter additionalContext(
+        {.messageFunc = messageFunction,
+         .arg = &topLevelTroubleshootingAid,
+         .isEssential = true});
+
+    MessageFunctionArg midLevelTroubleshootingAid{
+        "Mid-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter midLevelContext(
+        {.messageFunc = messageFunction,
+         .arg = &midLevelTroubleshootingAid,
+         .isEssential = true});
+
+    MessageFunctionArg innerLevelTroubleshootingAid{
+        "Inner-level troubleshooting aid.", &callCount};
+    facebook::velox::ExceptionContextSetter innerLevelContext(
+        {messageFunction, &innerLevelTroubleshootingAid});
+
+    verifyVeloxException(
+        [&]() { VELOX_CHECK_EQ(1, 3); },
+        "Exception: VeloxRuntimeError"
+        "\nError Source: RUNTIME"
+        "\nError Code: INVALID_STATE"
+        "\nReason: (1 vs. 3)"
+        "\nRetriable: False"
+        "\nExpression: 1 == 3"
+        "\nContext: System error: Inner-level troubleshooting aid."
+        "\nAdditional Context: System error: Mid-level troubleshooting aid. System error: Top-level troubleshooting aid."
+        "\nFunction: operator()"
+        "\nFile: ");
+
+    EXPECT_EQ(3, callCount);
+
+    verifyVeloxException(
+        [&]() { VELOX_USER_CHECK_EQ(1, 3); },
+        "Exception: VeloxUserError"
+        "\nError Source: USER"
+        "\nError Code: INVALID_ARGUMENT"
+        "\nReason: (1 vs. 3)"
+        "\nRetriable: False"
+        "\nExpression: 1 == 3"
+        "\nContext: User error: Inner-level troubleshooting aid."
+        "\nAdditional Context: User error: Mid-level troubleshooting aid. User error: Top-level troubleshooting aid."
+        "\nFunction: operator()"
+        "\nFile: ");
+
+    EXPECT_EQ(6, callCount);
+  }
+
   // Different context.
   {
     callCount = 0;
@@ -649,7 +802,6 @@ TEST(ExceptionTest, context) {
         "\nRetriable: False"
         "\nExpression: 1 == 3"
         "\nContext: System error: Debugging info."
-        "\nTop-Level Context: Same as context."
         "\nFunction: operator()"
         "\nFile: ");
 
@@ -664,7 +816,6 @@ TEST(ExceptionTest, context) {
         "\nRetriable: False"
         "\nExpression: 1 == 3"
         "\nContext: User error: Debugging info."
-        "\nTop-Level Context: Same as context."
         "\nFunction: operator()"
         "\nFile: ");
 
@@ -709,7 +860,6 @@ TEST(ExceptionTest, context) {
         "\nRetriable: False"
         "\nExpression: 1 == 3"
         "\nContext: Failed to produce additional context."
-        "\nTop-Level Context: Same as context."
         "\nFunction: operator()"
         "\nFile: ");
 
@@ -743,7 +893,7 @@ TEST(ExceptionTest, wrappedException) {
     ASSERT_EQ(ve.message(), "This is a test.");
     ASSERT_TRUE(ve.isUserError());
     ASSERT_EQ(ve.context(), "");
-    ASSERT_EQ(ve.topLevelContext(), "");
+    ASSERT_EQ(ve.additionalContext(), "");
     ASSERT_THROW(
         std::rethrow_exception(ve.wrappedException()), std::invalid_argument);
   }
@@ -755,7 +905,7 @@ TEST(ExceptionTest, wrappedException) {
     ASSERT_EQ(ve.message(), "This is a test.");
     ASSERT_FALSE(ve.isUserError());
     ASSERT_EQ(ve.context(), "");
-    ASSERT_EQ(ve.topLevelContext(), "");
+    ASSERT_EQ(ve.additionalContext(), "");
     ASSERT_THROW(
         std::rethrow_exception(ve.wrappedException()), std::invalid_argument);
   }
@@ -784,7 +934,7 @@ TEST(ExceptionTest, wrappedExceptionWithContext) {
 
   std::string data = "lakes";
   facebook::velox::ExceptionContextSetter context(
-      {messageFunction, data.data()});
+      {messageFunction, data.data(), true});
 
   try {
     throw std::invalid_argument("This is a test.");
@@ -793,7 +943,7 @@ TEST(ExceptionTest, wrappedExceptionWithContext) {
     ASSERT_EQ(ve.message(), "This is a test.");
     ASSERT_TRUE(ve.isUserError());
     ASSERT_EQ(ve.context(), "User error: lakes");
-    ASSERT_EQ(ve.topLevelContext(), "Same as context.");
+    ASSERT_EQ(ve.additionalContext(), "");
     ASSERT_THROW(
         std::rethrow_exception(ve.wrappedException()), std::invalid_argument);
   }
@@ -805,7 +955,7 @@ TEST(ExceptionTest, wrappedExceptionWithContext) {
     ASSERT_EQ(ve.message(), "This is a test.");
     ASSERT_FALSE(ve.isUserError());
     ASSERT_EQ(ve.context(), "System error: lakes");
-    ASSERT_EQ(ve.topLevelContext(), "Same as context.");
+    ASSERT_EQ(ve.additionalContext(), "");
     ASSERT_THROW(
         std::rethrow_exception(ve.wrappedException()), std::invalid_argument);
   }
@@ -821,7 +971,7 @@ TEST(ExceptionTest, wrappedExceptionWithContext) {
     ASSERT_EQ(ve.message(), "This is a test.");
     ASSERT_TRUE(ve.isUserError());
     ASSERT_EQ(ve.context(), "User error: mountains");
-    ASSERT_EQ(ve.topLevelContext(), "User error: lakes");
+    ASSERT_EQ(ve.additionalContext(), "User error: lakes");
     ASSERT_THROW(
         std::rethrow_exception(ve.wrappedException()), std::invalid_argument);
   }
@@ -833,7 +983,7 @@ TEST(ExceptionTest, wrappedExceptionWithContext) {
     ASSERT_EQ(ve.message(), "This is a test.");
     ASSERT_FALSE(ve.isUserError());
     ASSERT_EQ(ve.context(), "System error: mountains");
-    ASSERT_EQ(ve.topLevelContext(), "System error: lakes");
+    ASSERT_EQ(ve.additionalContext(), "System error: lakes");
     ASSERT_THROW(
         std::rethrow_exception(ve.wrappedException()), std::invalid_argument);
   }
diff --git a/velox/common/base/tests/FsTest.cpp b/velox/common/base/tests/FsTest.cpp
index a9dbd822c0faf..10e4dafee6792 100644
--- a/velox/common/base/tests/FsTest.cpp
+++ b/velox/common/base/tests/FsTest.cpp
@@ -24,7 +24,8 @@ namespace facebook::velox::common {
 class FsTest : public testing::Test {};
 
 TEST_F(FsTest, createDirectory) {
-  auto rootPath = exec::test::TempDirectoryPath::createTempDirectory();
+  auto dir = exec::test::TempDirectoryPath::create();
+  auto rootPath = dir->getPath();
   auto tmpDirectoryPath = rootPath + "/first/second/third";
   // First time should generate directory successfully.
   EXPECT_FALSE(fs::exists(tmpDirectoryPath.c_str()));
@@ -34,7 +35,7 @@ TEST_F(FsTest, createDirectory) {
   // Directory already exist, not creating but should return success.
   EXPECT_TRUE(generateFileDirectory(tmpDirectoryPath.c_str()));
   EXPECT_TRUE(fs::exists(tmpDirectoryPath.c_str()));
-  boost::filesystem::remove_all(rootPath);
+  dir.reset();
   EXPECT_FALSE(fs::exists(rootPath.c_str()));
 }
 
diff --git a/velox/common/base/tests/GTestUtils.h b/velox/common/base/tests/GTestUtils.h
index dbb7a213585a5..0ed61bf9b15d9 100644
--- a/velox/common/base/tests/GTestUtils.h
+++ b/velox/common/base/tests/GTestUtils.h
@@ -32,16 +32,69 @@
 #define VELOX_INSTANTIATE_TEST_SUITE_P INSTANTIATE_TEST_CASE_P
 #endif
 
-#define VELOX_ASSERT_THROW(expression, errorMessage)                 \
-  try {                                                              \
-    (expression);                                                    \
-    FAIL() << "Expected an exception";                               \
-  } catch (const facebook::velox::VeloxException& e) {               \
-    ASSERT_TRUE(e.message().find(errorMessage) != std::string::npos) \
-        << "Expected error message to contain '" << errorMessage     \
-        << "', but received '" << e.message() << "'.";               \
+// The void static cast supresses the "unused expression result" warning in
+// clang.
+#define VELOX_ASSERT_THROW_IMPL(_type, _expression, _errorMessage)    \
+  try {                                                               \
+    static_cast<void>(_expression);                                   \
+    FAIL() << "Expected an exception";                                \
+  } catch (const _type& e) {                                          \
+    ASSERT_TRUE(e.message().find(_errorMessage) != std::string::npos) \
+        << "Expected error message to contain '" << (_errorMessage)   \
+        << "', but received '" << e.message() << "'.";                \
   }
 
+#define VELOX_ASSERT_THROW(_expression, _errorMessage) \
+  VELOX_ASSERT_THROW_IMPL(                             \
+      facebook::velox::VeloxException, _expression, _errorMessage)
+
+#define VELOX_ASSERT_USER_THROW(_expression, _errorMessage) \
+  VELOX_ASSERT_THROW_IMPL(                                  \
+      facebook::velox::VeloxUserError, _expression, _errorMessage)
+
+#define VELOX_ASSERT_RUNTIME_THROW(_expression, _errorMessage) \
+  VELOX_ASSERT_THROW_IMPL(                                     \
+      facebook::velox::VeloxRuntimeError, _expression, _errorMessage)
+
+#define VELOX_ASSERT_ERROR_STATUS(_expression, _statusCode, _errorMessage) \
+  const auto status = (_expression);                                       \
+  ASSERT_TRUE(status.code() == _statusCode)                                \
+      << "Expected error code to be '" << toString(_statusCode)            \
+      << "', but received '" << toString(status.code()) << "'.";           \
+  ASSERT_TRUE(status.message().find(_errorMessage) != std::string::npos)   \
+      << "Expected error message to contain '" << (_errorMessage)          \
+      << "', but received '" << status.message() << "'."
+
+#define VELOX_ASSERT_ERROR_CODE_IMPL(                                         \
+    _type, _expression, _errorCode, _errorMessage)                            \
+  try {                                                                       \
+    (_expression);                                                            \
+    FAIL() << "Expected an exception";                                        \
+  } catch (const _type& e) {                                                  \
+    ASSERT_TRUE(e.errorCode() == _errorCode)                                  \
+        << "Expected error code to be '" << _errorCode << "', but received '" \
+        << e.errorCode() << "'.";                                             \
+    ASSERT_TRUE(e.message().find(_errorMessage) != std::string::npos)         \
+        << "Expected error message to contain '" << (_errorMessage)           \
+        << "', but received '" << e.message() << "'.";                        \
+  }
+
+#define VELOX_ASSERT_THROW_CODE(_expression, _errorCode, _errorMessage) \
+  VELOX_ASSERT_ERROR_CODE_IMPL(                                         \
+      facebook::velox::VeloxException, _expression, _errorCode, _errorMessage)
+
+#define VELOX_ASSERT_USER_THROW_CODE(_expression, _errorCode, _errorMessage) \
+  VELOX_ASSERT_ERROR_CODE_IMPL(                                              \
+      facebook::velox::VeloxUserError, _expression, _errorCode, _errorMessage)
+
+#define VELOX_ASSERT_RUNTIME_THROW_CODE(    \
+    _expression, _errorCode, _errorMessage) \
+  VELOX_ASSERT_ERROR_CODE_IMPL(             \
+      facebook::velox::VeloxRuntimeError,   \
+      _expression,                          \
+      _errorCode,                           \
+      _errorMessage)
+
 #ifndef NDEBUG
 #define DEBUG_ONLY_TEST(test_fixture, test_name) TEST(test_fixture, test_name)
 #define DEBUG_ONLY_TEST_F(test_fixture, test_name) \
diff --git a/velox/common/base/tests/IdMapTest.cpp b/velox/common/base/tests/IdMapTest.cpp
index e57ef50f81c19..3b0b157321f63 100644
--- a/velox/common/base/tests/IdMapTest.cpp
+++ b/velox/common/base/tests/IdMapTest.cpp
@@ -76,8 +76,12 @@ class IdMapTest : public testing::Test {
     int64_t n4;
   };
 
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    root_ = memory::MemoryManager::getInstance().addRootPool("IdMapRoot");
+    root_ = memory::memoryManager()->addRootPool("IdMapRoot");
     pool_ = root_->addLeafChild("IdMapLeakLeaf");
   }
 
diff --git a/velox/common/base/tests/Memcpy.cpp b/velox/common/base/tests/Memcpy.cpp
index 236612db45e20..2ab51f87815e1 100644
--- a/velox/common/base/tests/Memcpy.cpp
+++ b/velox/common/base/tests/Memcpy.cpp
@@ -41,10 +41,10 @@ uint64_t sum(uint64_t* data, int32_t size) {
 }
 
 struct CopyCallable {
-  void* FOLLY_NULLABLE source;
-  void* FOLLY_NULLABLE destination;
+  void* source;
+  void* destination;
   int64_t size;
-  Semaphore* FOLLY_NULLABLE sem;
+  Semaphore* sem;
 
   void operator()() {
     if (FLAGS_system_memcpy) {
@@ -58,7 +58,7 @@ struct CopyCallable {
 
 int main(int argc, char** argv) {
   constexpr int32_t kAlignment = folly::hardware_destructive_interference_size;
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   auto chunk = bits::roundUp(
       std::max<int64_t>(FLAGS_bytes / FLAGS_threads, kAlignment), kAlignment);
   int64_t bytes = chunk * FLAGS_threads;
diff --git a/velox/common/base/tests/PointersTest.cpp b/velox/common/base/tests/PointersTest.cpp
new file mode 100644
index 0000000000000..4c016dfae6dc1
--- /dev/null
+++ b/velox/common/base/tests/PointersTest.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/Pointers.h"
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox;
+namespace {
+TEST(PointersTest, uniquePtrConvert) {
+  class Foo1 {
+   public:
+    explicit Foo1(int32_t a) : a_(a) {}
+    virtual ~Foo1() = default;
+
+    int32_t a() const {
+      return a_;
+    }
+
+   protected:
+    int32_t a_;
+  };
+
+  class Foo2 : public Foo1 {
+   public:
+    Foo2(int32_t a, int32_t b) : Foo1(a), b_(b) {}
+
+    int32_t b() const {
+      return b_;
+    }
+
+   private:
+    int32_t b_;
+  };
+
+  Foo2* rawFoo2 = new Foo2(10, 20);
+  ASSERT_EQ(rawFoo2->a(), 10);
+  ASSERT_EQ(rawFoo2->b(), 20);
+  std::unique_ptr<Foo1> foo1(rawFoo2);
+  std::unique_ptr<Foo2> foo2;
+  castUniquePointer(std::move(foo1), foo2);
+  ASSERT_TRUE(foo2 != nullptr);
+  ASSERT_EQ(foo2->a(), 10);
+  ASSERT_EQ(foo2->b(), 20);
+
+  class Foo3 {
+   public:
+    explicit Foo3(int32_t c) : c_(c) {}
+
+   private:
+    int32_t c_;
+  };
+  std::unique_ptr<Foo3> foo3;
+
+  ASSERT_ANY_THROW(castUniquePointer(std::move(foo2), foo3));
+  ASSERT_TRUE(foo3 == nullptr);
+}
+} // namespace
diff --git a/velox/common/base/tests/RangeTest.cpp b/velox/common/base/tests/RangeTest.cpp
index e3aa5ccbb6d04..a5d3507644325 100644
--- a/velox/common/base/tests/RangeTest.cpp
+++ b/velox/common/base/tests/RangeTest.cpp
@@ -18,30 +18,35 @@
 
 #include <gtest/gtest.h>
 
-namespace facebook {
-namespace velox {
+namespace facebook::velox {
 
 TEST(RangeTest, ranges) {
   std::vector<uint64_t> bits(10);
   uint64_t* data = &bits[0];
+
   Range<bool> readable(data, 11, 511);
   MutableRange<bool> writable(data, 9, 509);
   Range<uint8_t> readableBytes(&bits[0], 1, 79);
   MutableRange<uint8_t> writableBytes(&bits[0], 0, 80);
-  // Bit 13 appears as bit 2 in readable and as bit 4 in writable.
+
+  // Bit 13 appears as bit 2 in 'readable' and as bit 4 in 'writable'.
   bits::setBit(data, 13);
   EXPECT_TRUE(readable[2]);
   EXPECT_TRUE(writable[4]);
+
+  // Bit 21 appears as bit 11 in 'readable' and as bit 13 in 'writable'.
   writable[13] = true;
   EXPECT_TRUE(readable[11]);
+
   writable[13] = false;
   EXPECT_FALSE(readable[11]);
 
+  // Byte 10 (ie, bit[80~87]), which corresponds to byte 9 in 'readableBytes'
+  // and bit[69~76] in 'readable'.
   writableBytes[10] = 123;
   EXPECT_EQ(readableBytes[9], 123);
   // Bit 80 is set.
   EXPECT_TRUE(readable[69]);
 }
 
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox
diff --git a/velox/common/base/tests/ScratchTest.cpp b/velox/common/base/tests/ScratchTest.cpp
new file mode 100644
index 0000000000000..36bdd2da2f814
--- /dev/null
+++ b/velox/common/base/tests/ScratchTest.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/Scratch.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+
+TEST(ScratchTest, basic) {
+  Scratch scratch;
+  {
+    ScratchPtr<int32_t> ints(scratch);
+    ScratchPtr<int64_t> longs(scratch);
+    auto tempInts = ints.get(1000);
+    auto tempLongs = longs.get(2000);
+    std::fill(tempInts, tempInts + 1000, -1);
+    std::fill(tempLongs, tempLongs + 2000, -1);
+    EXPECT_EQ(0, scratch.retainedSize());
+  }
+  EXPECT_EQ(20352, scratch.retainedSize());
+  {
+    ScratchPtr<int32_t> ints(scratch);
+    ScratchPtr<int64_t> longs(scratch);
+    auto tempLongs = longs.get(2000);
+    auto tempInts = ints.get(1000);
+    std::fill(tempInts, tempInts + 1000, -1);
+    std::fill(tempInts, tempInts + 2000, -1);
+    EXPECT_EQ(0, scratch.retainedSize());
+  }
+  // The scratch vectors were acquired in a different order, so the smaller got
+  // resized to the larger size.
+  EXPECT_EQ(32640, scratch.retainedSize());
+  scratch.trim();
+  EXPECT_EQ(0, scratch.retainedSize());
+  {
+    ScratchPtr<int32_t, 10> ints(scratch);
+    // The size is the inline size, nothing gets returned to 'scratch'.
+    auto temp = ints.get(10);
+    temp[0] = 1;
+  }
+  EXPECT_EQ(0, scratch.retainedSize());
+}
+
+TEST(ScratchTest, large) {
+  constexpr int32_t kSize = 100;
+  Scratch scratch;
+  std::vector<std::unique_ptr<ScratchPtr<int32_t>>> pointers;
+  for (auto i = 0; i < kSize; ++i) {
+    pointers.push_back(std::make_unique<ScratchPtr<int32_t>>(scratch));
+    pointers.back()->get(1000);
+  }
+  pointers.clear();
+  // 100 times 1000 bytes returned.
+  EXPECT_LT(100'000, scratch.retainedSize());
+  for (auto i = 0; i < kSize; ++i) {
+    pointers.push_back(std::make_unique<ScratchPtr<int32_t>>(scratch));
+    pointers.back()->get(1000);
+  }
+  EXPECT_EQ(0, scratch.retainedSize());
+}
diff --git a/velox/common/base/tests/SimdUtilTest.cpp b/velox/common/base/tests/SimdUtilTest.cpp
index ba481f11d0485..ba389780b1cba 100644
--- a/velox/common/base/tests/SimdUtilTest.cpp
+++ b/velox/common/base/tests/SimdUtilTest.cpp
@@ -16,6 +16,8 @@
 
 #include "velox/common/base/SimdUtil.h"
 #include <folly/Random.h>
+#include "velox/common/base/RawVector.h"
+#include "velox/common/time/Timer.h"
 
 #include <gtest/gtest.h>
 
@@ -207,6 +209,58 @@ TEST_F(SimdUtilTest, gatherBits) {
     EXPECT_EQ(bits::isBitSet(&bits, i), bits::isBitSet(data, vindex.get(i)));
   }
   EXPECT_FALSE(bits::isBitSet(&bits, N - 1));
+
+  uint64_t source = 0x123456789abcdefLU;
+  raw_vector<int32_t> bitIndices;
+  uint64_t result = 0;
+  for (auto i = 61; i >= 0; i -= 2) {
+    bitIndices.push_back(i);
+  }
+  simd::gatherBits(
+      &source,
+      folly::Range<int32_t*>(bitIndices.data(), bitIndices.size()),
+      &result);
+  for (auto i = 0; i < bitIndices.size(); ++i) {
+    EXPECT_EQ(
+        bits::isBitSet(&source, bitIndices[i]), bits::isBitSet(&result, i));
+  }
+}
+
+TEST_F(SimdUtilTest, transpose) {
+  constexpr int32_t kMaxSize = 100;
+  std::vector<int32_t> data32(kMaxSize);
+  std::vector<int64_t> data64(kMaxSize);
+  raw_vector<int32_t> indices(kMaxSize);
+  constexpr int64_t kMagic = 0x4fe12LU;
+  // indices are scattered over 0..kMaxSize - 1.
+  for (auto i = 0; i < kMaxSize; ++i) {
+    indices[i] = ((i * kMagic) & 0xffffff) % indices.size();
+    data32[i] = i;
+    data64[i] = static_cast<int64_t>(i) << 32;
+  }
+  for (auto size = 1; size < kMaxSize; ++size) {
+    std::vector<int32_t> result32(kMaxSize + 1, -1);
+    simd::transpose(
+        data32.data(),
+        folly::Range<const int32_t*>(indices.data(), size),
+        result32.data());
+    for (auto i = 0; i < size; ++i) {
+      EXPECT_EQ(data32[indices[i]], result32[i]);
+    }
+    // See that there is no write past 'size'.
+    EXPECT_EQ(-1, result32[size]);
+
+    std::vector<int64_t> result64(kMaxSize + 1, -1);
+    simd::transpose(
+        data64.data(),
+        folly::Range<const int32_t*>(indices.data(), size),
+        result64.data());
+    for (auto i = 0; i < size; ++i) {
+      EXPECT_EQ(data64[indices[i]], result64[i]);
+    }
+    // See that there is no write past 'size'.
+    EXPECT_EQ(-1, result64[size]);
+  }
 }
 
 namespace {
@@ -376,7 +430,7 @@ TEST_F(SimdUtilTest, reinterpretBatch) {
   validateReinterpretBatch<int64_t>();
 }
 
-TEST_F(SimdUtilTest, memEqual) {
+TEST_F(SimdUtilTest, memEqualUnsafe) {
   constexpr int32_t kSize = 132;
   struct {
     char x[kSize];
@@ -399,4 +453,42 @@ TEST_F(SimdUtilTest, memEqual) {
   EXPECT_FALSE(simd::memEqualUnsafe(&data.x[1], &data.y[1], 67));
 }
 
+TEST_F(SimdUtilTest, memcpyTime) {
+  constexpr int64_t kMaxMove = 128;
+  constexpr int64_t kSize = (128 << 20) + kMaxMove;
+  constexpr uint64_t kSizeMask = (128 << 20) - 1;
+  constexpr int32_t kMoveMask = kMaxMove - 1;
+  constexpr uint64_t kMagic1 = 0x5231871;
+  constexpr uint64_t kMagic3 = 0xfae1;
+  constexpr uint64_t kMagic2 = 0x817952491;
+  std::vector<char> dataV(kSize);
+
+  auto data = dataV.data();
+  uint64_t simd = 0;
+  uint64_t sys = 0;
+  {
+    MicrosecondTimer t(&simd);
+    for (auto ctr = 0; ctr < 100; ++ctr) {
+      for (auto i = 0; i < 10000; ++i) {
+        char* from = data + ((i * kMagic1) & kSizeMask);
+        char* to = data + ((i * kMagic2) & kSizeMask);
+        int32_t size = (i * kMagic3) % kMoveMask;
+        simd::memcpy(to, from, size);
+      }
+    }
+  }
+  {
+    MicrosecondTimer t(&sys);
+    for (auto ctr = 0; ctr < 100; ++ctr) {
+      for (auto i = 0; i < 10000; ++i) {
+        char* from = data + ((i * kMagic1) & kSizeMask);
+        char* to = data + ((i * kMagic2) & kSizeMask);
+        int32_t size = (i * kMagic3) % kMoveMask;
+        ::memcpy(to, from, size);
+      }
+    }
+  }
+  LOG(INFO) << "simd=" << simd << " sys=" << sys;
+}
+
 } // namespace
diff --git a/velox/common/testutil/tests/SpillConfigTest.cpp b/velox/common/base/tests/SpillConfigTest.cpp
similarity index 89%
rename from velox/common/testutil/tests/SpillConfigTest.cpp
rename to velox/common/base/tests/SpillConfigTest.cpp
index 3a1ea251f39fe..837f0098c47c5 100644
--- a/velox/common/testutil/tests/SpillConfigTest.cpp
+++ b/velox/common/base/tests/SpillConfigTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/common/config/SpillConfig.h"
+#include "velox/common/base/SpillConfig.h"
 #include <gtest/gtest.h>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/HashBitRange.h"
@@ -26,6 +26,8 @@ TEST(SpillConfig, spillLevel) {
   const uint8_t kInitialBitOffset = 16;
   const uint8_t kNumPartitionsBits = 3;
   const SpillConfig config(
+      []() -> std::string_view { return ""; },
+      [&](uint64_t) {},
       "fakeSpillPath",
       0,
       0,
@@ -36,7 +38,6 @@ TEST(SpillConfig, spillLevel) {
       kInitialBitOffset,
       kNumPartitionsBits,
       0,
-      false,
       0,
       0,
       "none");
@@ -62,10 +63,9 @@ TEST(SpillConfig, spillLevel) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     if (testData.expectedLevel == -1) {
-      ASSERT_ANY_THROW(config.joinSpillLevel(testData.bitOffset));
+      ASSERT_ANY_THROW(config.spillLevel(testData.bitOffset));
     } else {
-      ASSERT_EQ(
-          config.joinSpillLevel(testData.bitOffset), testData.expectedLevel);
+      ASSERT_EQ(config.spillLevel(testData.bitOffset), testData.expectedLevel);
     }
   }
 }
@@ -76,7 +76,7 @@ TEST(SpillConfig, spillLevelLimit) {
     int32_t numBits;
     uint8_t bitOffset;
     int32_t maxSpillLevel;
-    int32_t expectedExceeds;
+    bool expectedExceeds;
 
     std::string debugString() const {
       return fmt::format(
@@ -111,6 +111,8 @@ TEST(SpillConfig, spillLevelLimit) {
     const HashBitRange partitionBits(
         testData.startBitOffset, testData.startBitOffset + testData.numBits);
     const SpillConfig config(
+        []() -> std::string_view { return ""; },
+        [&](uint64_t) {},
         "fakeSpillPath",
         0,
         0,
@@ -120,15 +122,14 @@ TEST(SpillConfig, spillLevelLimit) {
         0,
         testData.startBitOffset,
         testData.numBits,
-        0,
-        false,
         testData.maxSpillLevel,
         0,
+        0,
         "none");
 
     ASSERT_EQ(
         testData.expectedExceeds,
-        config.exceedJoinSpillLevelLimit(testData.bitOffset));
+        config.exceedSpillLevelLimit(testData.bitOffset));
   }
 }
 
@@ -151,12 +152,13 @@ TEST(SpillConfig, spillableReservationPercentages) {
       {50, 100, true},
       {1, 50, true},
       {1, 1, false}};
-
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
     auto createConfigFn = [&]() {
       const SpillConfig config(
+          [&]() -> std::string_view { return ""; },
+          [&](uint64_t) {},
           "spillableReservationPercentages",
           0,
           0,
@@ -167,8 +169,7 @@ TEST(SpillConfig, spillableReservationPercentages) {
           0,
           0,
           0,
-          false,
-          0,
+          1'000'000,
           0,
           "none");
     };
diff --git a/velox/common/base/tests/SpillStatsTest.cpp b/velox/common/base/tests/SpillStatsTest.cpp
new file mode 100644
index 0000000000000..114c728fe4f02
--- /dev/null
+++ b/velox/common/base/tests/SpillStatsTest.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/SpillStats.h"
+#include <gtest/gtest.h>
+#include "velox/common/base/VeloxException.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace facebook::velox::common;
+
+TEST(SpillStatsTest, spillStats) {
+  SpillStats stats1;
+  ASSERT_TRUE(stats1.empty());
+  stats1.spillRuns = 100;
+  stats1.spilledInputBytes = 2048;
+  stats1.spilledBytes = 1024;
+  stats1.spilledPartitions = 1024;
+  stats1.spilledFiles = 1023;
+  stats1.spillWriteTimeNanos = 1023;
+  stats1.spillFlushTimeNanos = 1023;
+  stats1.spillWrites = 1023;
+  stats1.spillSortTimeNanos = 1023;
+  stats1.spillFillTimeNanos = 1023;
+  stats1.spilledRows = 1023;
+  stats1.spillSerializationTimeNanos = 1023;
+  stats1.spillMaxLevelExceededCount = 3;
+  stats1.spillReadBytes = 1024;
+  stats1.spillReads = 10;
+  stats1.spillReadTimeNanos = 100;
+  stats1.spillDeserializationTimeNanos = 100;
+  ASSERT_FALSE(stats1.empty());
+  SpillStats stats2;
+  stats2.spillRuns = 100;
+  stats2.spilledInputBytes = 2048;
+  stats2.spilledBytes = 1024;
+  stats2.spilledPartitions = 1025;
+  stats2.spilledFiles = 1026;
+  stats2.spillWriteTimeNanos = 1026;
+  stats2.spillFlushTimeNanos = 1027;
+  stats2.spillWrites = 1028;
+  stats2.spillSortTimeNanos = 1029;
+  stats2.spillFillTimeNanos = 1030;
+  stats2.spilledRows = 1031;
+  stats2.spillSerializationTimeNanos = 1032;
+  stats2.spillMaxLevelExceededCount = 4;
+  stats2.spillReadBytes = 2048;
+  stats2.spillReads = 10;
+  stats2.spillReadTimeNanos = 100;
+  stats2.spillDeserializationTimeNanos = 100;
+  ASSERT_TRUE(stats1 < stats2);
+  ASSERT_TRUE(stats1 <= stats2);
+  ASSERT_FALSE(stats1 > stats2);
+  ASSERT_FALSE(stats1 >= stats2);
+  ASSERT_TRUE(stats1 != stats2);
+  ASSERT_FALSE(stats1 == stats2);
+
+  ASSERT_TRUE(stats1 == stats1);
+  ASSERT_FALSE(stats1 != stats1);
+  ASSERT_FALSE(stats1 > stats1);
+  ASSERT_TRUE(stats1 >= stats1);
+  ASSERT_FALSE(stats1 < stats1);
+  ASSERT_TRUE(stats1 <= stats1);
+
+  SpillStats delta = stats2 - stats1;
+  ASSERT_EQ(delta.spilledInputBytes, 0);
+  ASSERT_EQ(delta.spilledBytes, 0);
+  ASSERT_EQ(delta.spilledPartitions, 1);
+  ASSERT_EQ(delta.spilledFiles, 3);
+  ASSERT_EQ(delta.spillWriteTimeNanos, 3);
+  ASSERT_EQ(delta.spillFlushTimeNanos, 4);
+  ASSERT_EQ(delta.spillWrites, 5);
+  ASSERT_EQ(delta.spillSortTimeNanos, 6);
+  ASSERT_EQ(delta.spillFillTimeNanos, 7);
+  ASSERT_EQ(delta.spilledRows, 8);
+  ASSERT_EQ(delta.spillSerializationTimeNanos, 9);
+  ASSERT_EQ(delta.spillReadBytes, 1024);
+  ASSERT_EQ(delta.spillReads, 0);
+  ASSERT_EQ(delta.spillReadTimeNanos, 0);
+  ASSERT_EQ(delta.spillDeserializationTimeNanos, 0);
+  delta = stats1 - stats2;
+  ASSERT_EQ(delta.spilledInputBytes, 0);
+  ASSERT_EQ(delta.spilledBytes, 0);
+  ASSERT_EQ(delta.spilledPartitions, -1);
+  ASSERT_EQ(delta.spilledFiles, -3);
+  ASSERT_EQ(delta.spillWriteTimeNanos, -3);
+  ASSERT_EQ(delta.spillFlushTimeNanos, -4);
+  ASSERT_EQ(delta.spillWrites, -5);
+  ASSERT_EQ(delta.spillSortTimeNanos, -6);
+  ASSERT_EQ(delta.spillFillTimeNanos, -7);
+  ASSERT_EQ(delta.spilledRows, -8);
+  ASSERT_EQ(delta.spillSerializationTimeNanos, -9);
+  ASSERT_EQ(delta.spillMaxLevelExceededCount, -1);
+  ASSERT_EQ(delta.spillReadBytes, -1024);
+  ASSERT_EQ(delta.spillReads, 0);
+  ASSERT_EQ(delta.spillReadTimeNanos, 0);
+  ASSERT_EQ(delta.spillDeserializationTimeNanos, 0);
+  stats1.spilledInputBytes = 2060;
+  stats1.spilledBytes = 1030;
+  stats1.spillReadBytes = 4096;
+  VELOX_ASSERT_THROW(stats1 < stats2, "");
+  VELOX_ASSERT_THROW(stats1 > stats2, "");
+  VELOX_ASSERT_THROW(stats1 <= stats2, "");
+  VELOX_ASSERT_THROW(stats1 >= stats2, "");
+  ASSERT_TRUE(stats1 != stats2);
+  ASSERT_FALSE(stats1 == stats2);
+  const SpillStats zeroStats;
+  stats1.reset();
+  ASSERT_EQ(zeroStats, stats1);
+  ASSERT_EQ(
+      stats2.toString(),
+      "spillRuns[100] spilledInputBytes[2.00KB] spilledBytes[1.00KB] "
+      "spilledRows[1031] spilledPartitions[1025] spilledFiles[1026] "
+      "spillFillTimeNanos[1.03us] spillSortTimeNanos[1.03us] "
+      "spillSerializationTimeNanos[1.03us] spillWrites[1028] spillFlushTimeNanos[1.03us] "
+      "spillWriteTimeNanos[1.03us] maxSpillExceededLimitCount[4] "
+      "spillReadBytes[2.00KB] spillReads[10] spillReadTimeNanos[100ns] "
+      "spillReadDeserializationTimeNanos[100ns]");
+  ASSERT_EQ(
+      fmt::format("{}", stats2),
+      "spillRuns[100] spilledInputBytes[2.00KB] spilledBytes[1.00KB] "
+      "spilledRows[1031] spilledPartitions[1025] spilledFiles[1026] "
+      "spillFillTimeNanos[1.03us] spillSortTimeNanos[1.03us] "
+      "spillSerializationTimeNanos[1.03us] spillWrites[1028] "
+      "spillFlushTimeNanos[1.03us] spillWriteTimeNanos[1.03us] "
+      "maxSpillExceededLimitCount[4] "
+      "spillReadBytes[2.00KB] spillReads[10] spillReadTimeNanos[100ns] "
+      "spillReadDeserializationTimeNanos[100ns]");
+}
diff --git a/velox/common/base/tests/StatsReporterTest.cpp b/velox/common/base/tests/StatsReporterTest.cpp
index d70c00e5f4342..bf268d1a78ef2 100644
--- a/velox/common/base/tests/StatsReporterTest.cpp
+++ b/velox/common/base/tests/StatsReporterTest.cpp
@@ -20,32 +20,43 @@
 #include <gtest/gtest.h>
 #include <cstdint>
 #include <unordered_map>
+#include <unordered_set>
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/PeriodicStatsReporter.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/caching/AsyncDataCache.h"
+#include "velox/common/caching/CacheTTLController.h"
+#include "velox/common/caching/SsdCache.h"
+#include "velox/common/memory/MmapAllocator.h"
 
 namespace facebook::velox {
 
-class StatsReporterTest : public testing::Test {
- protected:
-  void SetUp() override {}
-  void TearDown() override {}
-};
-
 class TestReporter : public BaseStatsReporter {
  public:
-  mutable std::unordered_map<std::string, size_t> counterMap;
+  mutable std::mutex m;
+  mutable std::map<std::string, size_t> counterMap;
   mutable std::unordered_map<std::string, StatType> statTypeMap;
   mutable std::unordered_map<std::string, std::vector<int32_t>>
       histogramPercentilesMap;
 
-  void addStatExportType(const char* key, StatType statType) const override {
+  void clear() {
+    std::lock_guard<std::mutex> l(m);
+    counterMap.clear();
+    statTypeMap.clear();
+    histogramPercentilesMap.clear();
+  }
+
+  void registerMetricExportType(const char* key, StatType statType)
+      const override {
     statTypeMap[key] = statType;
   }
 
-  void addStatExportType(folly::StringPiece key, StatType statType)
+  void registerMetricExportType(folly::StringPiece key, StatType statType)
       const override {
     statTypeMap[key.str()] = statType;
   }
 
-  void addHistogramExportPercentiles(
+  void registerHistogramMetricExportType(
       const char* key,
       int64_t /* bucketWidth */,
       int64_t /* min */,
@@ -54,7 +65,7 @@ class TestReporter : public BaseStatsReporter {
     histogramPercentilesMap[key] = pcts;
   }
 
-  void addHistogramExportPercentiles(
+  void registerHistogramMetricExportType(
       folly::StringPiece key,
       int64_t /* bucketWidth */,
       int64_t /* min */,
@@ -63,64 +74,539 @@ class TestReporter : public BaseStatsReporter {
     histogramPercentilesMap[key.str()] = pcts;
   }
 
-  void addStatValue(const std::string& key, const size_t value) const override {
+  void addMetricValue(const std::string& key, const size_t value)
+      const override {
+    std::lock_guard<std::mutex> l(m);
     counterMap[key] += value;
   }
 
-  void addStatValue(const char* key, const size_t value) const override {
+  void addMetricValue(const char* key, const size_t value) const override {
+    std::lock_guard<std::mutex> l(m);
     counterMap[key] += value;
   }
 
-  void addStatValue(folly::StringPiece key, size_t value) const override {
+  void addMetricValue(folly::StringPiece key, size_t value) const override {
+    std::lock_guard<std::mutex> l(m);
     counterMap[key.str()] += value;
   }
 
-  void addHistogramValue(const std::string& key, size_t value) const override {
+  void addHistogramMetricValue(const std::string& key, size_t value)
+      const override {
+    std::lock_guard<std::mutex> l(m);
     counterMap[key] = std::max(counterMap[key], value);
   }
 
-  void addHistogramValue(const char* key, size_t value) const override {
+  void addHistogramMetricValue(const char* key, size_t value) const override {
+    std::lock_guard<std::mutex> l(m);
     counterMap[key] = std::max(counterMap[key], value);
   }
 
-  void addHistogramValue(folly::StringPiece key, size_t value) const override {
+  void addHistogramMetricValue(folly::StringPiece key, size_t value)
+      const override {
+    std::lock_guard<std::mutex> l(m);
     counterMap[key.str()] = std::max(counterMap[key.str()], value);
   }
+
+  std::string fetchMetrics() override {
+    std::stringstream ss;
+    ss << "[";
+    auto sep = "";
+    for (const auto& [key, value] : counterMap) {
+      ss << sep << key << ":" << value;
+      sep = ",";
+    }
+    ss << "]";
+    return ss.str();
+  }
 };
 
-TEST_F(StatsReporterTest, trivialReporter) {
-  auto reporter = std::dynamic_pointer_cast<TestReporter>(
-      folly::Singleton<BaseStatsReporter>::try_get());
+class StatsReporterTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    reporter_ = std::dynamic_pointer_cast<TestReporter>(
+        folly::Singleton<BaseStatsReporter>::try_get());
+    reporter_->clear();
+  }
+  void TearDown() override {
+    reporter_->clear();
+  }
 
-  REPORT_ADD_STAT_EXPORT_TYPE("key1", StatType::COUNT);
-  REPORT_ADD_STAT_EXPORT_TYPE("key2", StatType::SUM);
-  REPORT_ADD_STAT_EXPORT_TYPE("key3", StatType::RATE);
-  REPORT_ADD_HISTOGRAM_EXPORT_PERCENTILE("key4", 10, 0, 100, 50, 99, 100);
+  std::shared_ptr<TestReporter> reporter_;
+};
 
-  EXPECT_EQ(StatType::COUNT, reporter->statTypeMap["key1"]);
-  EXPECT_EQ(StatType::SUM, reporter->statTypeMap["key2"]);
-  EXPECT_EQ(StatType::RATE, reporter->statTypeMap["key3"]);
+TEST_F(StatsReporterTest, trivialReporter) {
+  DEFINE_METRIC("key1", StatType::COUNT);
+  DEFINE_METRIC("key2", StatType::SUM);
+  DEFINE_METRIC("key3", StatType::RATE);
+  DEFINE_HISTOGRAM_METRIC("key4", 10, 0, 100, 50, 99, 100);
+
+  EXPECT_EQ(StatType::COUNT, reporter_->statTypeMap["key1"]);
+  EXPECT_EQ(StatType::SUM, reporter_->statTypeMap["key2"]);
+  EXPECT_EQ(StatType::RATE, reporter_->statTypeMap["key3"]);
   std::vector<int32_t> expected = {50, 99, 100};
-  EXPECT_EQ(expected, reporter->histogramPercentilesMap["key4"]);
+  EXPECT_EQ(expected, reporter_->histogramPercentilesMap["key4"]);
   EXPECT_TRUE(
-      reporter->statTypeMap.find("key5") == reporter->statTypeMap.end());
-
-  REPORT_ADD_STAT_VALUE("key1", 10);
-  REPORT_ADD_STAT_VALUE("key1", 11);
-  REPORT_ADD_STAT_VALUE("key1", 15);
-  REPORT_ADD_STAT_VALUE("key2", 1001);
-  REPORT_ADD_STAT_VALUE("key2", 1200);
-  REPORT_ADD_STAT_VALUE("key3");
-  REPORT_ADD_STAT_VALUE("key3", 1100);
-  REPORT_ADD_HISTOGRAM_VALUE("key4", 50);
-  REPORT_ADD_HISTOGRAM_VALUE("key4", 100);
-
-  EXPECT_EQ(36, reporter->counterMap["key1"]);
-  EXPECT_EQ(2201, reporter->counterMap["key2"]);
-  EXPECT_EQ(1101, reporter->counterMap["key3"]);
-  EXPECT_EQ(100, reporter->counterMap["key4"]);
+      reporter_->statTypeMap.find("key5") == reporter_->statTypeMap.end());
+
+  RECORD_METRIC_VALUE("key1", 10);
+  RECORD_METRIC_VALUE("key1", 11);
+  RECORD_METRIC_VALUE("key1", 15);
+  RECORD_METRIC_VALUE("key2", 1001);
+  RECORD_METRIC_VALUE("key2", 1200);
+  RECORD_METRIC_VALUE("key3");
+  RECORD_METRIC_VALUE("key3", 1100);
+  RECORD_HISTOGRAM_METRIC_VALUE("key4", 50);
+  RECORD_HISTOGRAM_METRIC_VALUE("key4", 100);
+
+  EXPECT_EQ(36, reporter_->counterMap["key1"]);
+  EXPECT_EQ(2201, reporter_->counterMap["key2"]);
+  EXPECT_EQ(1101, reporter_->counterMap["key3"]);
+  EXPECT_EQ(100, reporter_->counterMap["key4"]);
+
+  EXPECT_EQ(
+      "[key1:36,key2:2201,key3:1101,key4:100]", reporter_->fetchMetrics());
+};
+
+class PeriodicStatsReporterTest : public StatsReporterTest {};
+
+class TestStatsReportMmapAllocator : public memory::MmapAllocator {
+ public:
+  TestStatsReportMmapAllocator(
+      memory::MachinePageCount numMapped,
+      memory::MachinePageCount numAllocated,
+      memory::MachinePageCount numMallocBytes,
+      memory::MachinePageCount numExternalMapped)
+      : memory::MmapAllocator({.capacity = 1024}),
+        numMapped_(numMapped),
+        numAllocated_(numAllocated),
+        numMallocBytes_(numMallocBytes),
+        numExternalMapped_(numExternalMapped) {}
+
+  memory::MachinePageCount numMapped() const override {
+    return numMapped_;
+  }
+
+  memory::MachinePageCount numAllocated() const override {
+    return numAllocated_;
+  }
+
+  uint64_t numMallocBytes() const {
+    return numMallocBytes_;
+  }
+
+  memory::MachinePageCount numExternalMapped() const {
+    return numExternalMapped_;
+  }
+
+ private:
+  memory::MachinePageCount numMapped_;
+  memory::MachinePageCount numAllocated_;
+  memory::MachinePageCount numMallocBytes_;
+  memory::MachinePageCount numExternalMapped_;
+};
+
+class TestStatsReportAsyncDataCache : public cache::AsyncDataCache {
+ public:
+  TestStatsReportAsyncDataCache(cache::CacheStats stats)
+      : cache::AsyncDataCache(nullptr, nullptr), stats_(stats) {}
+
+  cache::CacheStats refreshStats() const override {
+    std::lock_guard<std::mutex> l(mutex_);
+    return stats_;
+  }
+
+  void updateStats(cache::CacheStats stats) {
+    std::lock_guard<std::mutex> l(mutex_);
+    stats_ = stats;
+  }
+
+ private:
+  mutable std::mutex mutex_;
+  cache::CacheStats stats_;
+};
+
+class TestStatsReportMemoryArbitrator : public memory::MemoryArbitrator {
+ public:
+  explicit TestStatsReportMemoryArbitrator(
+      memory::MemoryArbitrator::Stats stats)
+      : memory::MemoryArbitrator({}), stats_(stats) {}
+
+  ~TestStatsReportMemoryArbitrator() override = default;
+
+  void updateStats(memory::MemoryArbitrator::Stats stats) {
+    std::lock_guard<std::mutex> l(mutex_);
+    stats_ = stats;
+  }
+
+  std::string kind() const override {
+    return "test";
+  }
+
+  void addPool(const std::shared_ptr<memory::MemoryPool>& /*unused*/) override {
+  }
+
+  void removePool(memory::MemoryPool* /*unused*/) override {}
+
+  bool growCapacity(memory::MemoryPool* /*unused*/, uint64_t /*unused*/)
+      override {
+    return false;
+  }
+
+  uint64_t shrinkCapacity(memory::MemoryPool* /*unused*/, uint64_t /*unused*/)
+      override {
+    return 0;
+  }
+
+  uint64_t shrinkCapacity(uint64_t /*unused*/, bool /*unused*/, bool /*unused*/)
+      override {
+    return 0;
+  }
+
+  Stats stats() const override {
+    std::lock_guard<std::mutex> l(mutex_);
+    return stats_;
+  }
+
+  std::string toString() const override {
+    return "TestStatsReportMemoryArbitrator::toString()";
+  }
+
+ private:
+  mutable std::mutex mutex_;
+  memory::MemoryArbitrator::Stats stats_;
+};
+
+class TestMemoryPool : public memory::MemoryPool {
+ public:
+  explicit TestMemoryPool() : MemoryPool("", Kind::kAggregate, nullptr, {}) {}
+
+  void* allocate(int64_t size) override {
+    return nullptr;
+  }
+
+  void* allocateZeroFilled(int64_t /* unused */, int64_t /* unused */)
+      override {
+    return nullptr;
+  }
+
+  void* reallocate(
+      void* /* unused */,
+      int64_t /* unused */,
+      int64_t /* unused */) override {
+    return nullptr;
+  }
+
+  void free(void* /* unused */, int64_t /* unused */) override {}
+
+  void allocateNonContiguous(
+      memory::MachinePageCount /* unused */,
+      memory::Allocation& /* unused */,
+      memory::MachinePageCount /* unused */) override {}
+
+  void freeNonContiguous(memory::Allocation& /* unused */) override {}
+
+  memory::MachinePageCount largestSizeClass() const override {
+    return 0;
+  }
+
+  const std::vector<memory::MachinePageCount>& sizeClasses() const override {
+    static std::vector<memory::MachinePageCount> sizeClasses;
+    return sizeClasses;
+  }
+
+  void allocateContiguous(
+      memory::MachinePageCount /* unused */,
+      memory::ContiguousAllocation& /* unused */,
+      memory::MachinePageCount /* unused */) override {}
+
+  void freeContiguous(memory::ContiguousAllocation& /* unused */) override {}
+
+  void growContiguous(
+      memory::MachinePageCount /* unused */,
+      memory::ContiguousAllocation& /* unused */) override {}
+
+  int64_t capacity() const override {
+    return 0;
+  }
+
+  int64_t usedBytes() const override {
+    return 0;
+  }
+
+  int64_t peakBytes() const override {
+    return 0;
+  }
+
+  int64_t availableReservation() const override {
+    return 0;
+  }
+
+  int64_t releasableReservation() const override {
+    return 0;
+  }
+
+  int64_t reservedBytes() const override {
+    return 0;
+  }
+
+  bool maybeReserve(uint64_t /* unused */) override {
+    return false;
+  }
+
+  void release() override {}
+
+  uint64_t freeBytes() const override {
+    return 0;
+  }
+
+  uint64_t shrink(uint64_t /* unused */) override {
+    return 0;
+  }
+
+  bool grow(uint64_t /* unused */, uint64_t /* unused */) override {
+    return false;
+  }
+
+  void setReclaimer(
+      std::unique_ptr<memory::MemoryReclaimer> /* unused */) override {}
+  memory::MemoryReclaimer* reclaimer() const override {
+    return nullptr;
+  }
+
+  void enterArbitration() override {}
+
+  void leaveArbitration() noexcept override {}
+
+  std::optional<uint64_t> reclaimableBytes() const override {
+    return std::nullopt;
+  }
+
+  uint64_t reclaim(
+      uint64_t /* unused */,
+      uint64_t /* unused */,
+      memory::MemoryReclaimer::Stats& /* unused */) override {
+    return 0;
+  }
+
+  void abort(const std::exception_ptr& /* unused */) override {}
+
+  bool aborted() const override {
+    return false;
+  }
+
+  std::string toString() const override {
+    return "";
+  }
+
+  std::string treeMemoryUsage(bool /* unused */) const override {
+    return "";
+  }
+
+  std::shared_ptr<MemoryPool> genChild(
+      std::shared_ptr<MemoryPool> /* unused */,
+      const std::string& /* unused */,
+      Kind /* unused */,
+      bool /* unused */,
+      std::unique_ptr<memory::MemoryReclaimer> /* unused */) override {
+    return nullptr;
+  }
+
+  Stats stats() const override {
+    return Stats();
+  }
 };
 
+TEST_F(PeriodicStatsReporterTest, basic) {
+  TestStatsReportMmapAllocator allocator(1, 1, 1, 1);
+  TestStatsReportAsyncDataCache cache(
+      {.ssdStats = std::make_shared<cache::SsdCacheStats>()});
+  cache::CacheTTLController::create(cache);
+  TestStatsReportMemoryArbitrator arbitrator({});
+  TestMemoryPool spillMemoryPool;
+  PeriodicStatsReporter::Options options;
+  options.cache = &cache;
+  options.cacheStatsIntervalMs = 4'000;
+  options.allocator = &allocator;
+  options.allocatorStatsIntervalMs = 4'000;
+  options.arbitrator = &arbitrator;
+  options.arbitratorStatsIntervalMs = 4'000;
+  options.spillMemoryPool = &spillMemoryPool;
+  options.spillStatsIntervalMs = 4'000;
+  PeriodicStatsReporter periodicReporter(options);
+
+  periodicReporter.start();
+  std::this_thread::sleep_for(std::chrono::milliseconds(2'000));
+
+  // Check snapshot stats
+  const auto& counterMap = reporter_->counterMap;
+  {
+    std::lock_guard<std::mutex> l(reporter_->m);
+    ASSERT_EQ(counterMap.count(kMetricArbitratorFreeCapacityBytes.str()), 1);
+    ASSERT_EQ(
+        counterMap.count(kMetricArbitratorFreeReservedCapacityBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEmptyEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumSharedEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumExclusiveEntries.str()), 1);
+    ASSERT_EQ(
+        counterMap.count(kMetricMemoryCacheNumPrefetchedEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheTotalTinyBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheTotalLargeBytes.str()), 1);
+    ASSERT_EQ(
+        counterMap.count(kMetricMemoryCacheTotalTinyPaddingBytes.str()), 1);
+    ASSERT_EQ(
+        counterMap.count(kMetricMemoryCacheTotalLargePaddingBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheTotalPrefetchBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheCachedEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheCachedRegions.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheCachedBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricCacheMaxAgeSecs.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMappedMemoryBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricAllocatedMemoryBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMmapDelegatedAllocBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMmapExternalMappedBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSpillMemoryBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSpillPeakMemoryBytes.str()), 1);
+    // Check deltas are not reported
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumHits.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheHitBytes.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumNew.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEvicts.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumSavableEvicts.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEvictChecks.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumWaitExclusive.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumAllocClocks.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumAgedOutEntries.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheSumEvictScore.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadEntries.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadBytes.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWrittenEntries.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWrittenBytes.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenSsdErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenCheckpointErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenLogErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheDeleteCheckpointErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheGrowFileErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteSsdErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteSsdDropped.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteCheckpointErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadSsdErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadCorruptions.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadCheckpointErrors.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheCheckpointsRead.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheCheckpointsWritten.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheRegionsEvicted.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheAgedOutEntries.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheAgedOutRegions.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheRecoveredEntries.str()), 0);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadWithoutChecksum.str()), 0);
+    ASSERT_EQ(counterMap.size(), 22);
+  }
+
+  // Update stats
+  auto newSsdStats = std::make_shared<cache::SsdCacheStats>();
+  newSsdStats->entriesWritten = 10;
+  newSsdStats->bytesWritten = 10;
+  newSsdStats->checkpointsWritten = 10;
+  newSsdStats->entriesRead = 10;
+  newSsdStats->bytesRead = 10;
+  newSsdStats->checkpointsRead = 10;
+  newSsdStats->entriesAgedOut = 10;
+  newSsdStats->regionsAgedOut = 10;
+  newSsdStats->regionsEvicted = 10;
+  newSsdStats->numPins = 10;
+  newSsdStats->openFileErrors = 10;
+  newSsdStats->openCheckpointErrors = 10;
+  newSsdStats->openLogErrors = 10;
+  newSsdStats->deleteCheckpointErrors = 10;
+  newSsdStats->growFileErrors = 10;
+  newSsdStats->writeSsdErrors = 10;
+  newSsdStats->writeSsdDropped = 10;
+  newSsdStats->writeCheckpointErrors = 10;
+  newSsdStats->readSsdErrors = 10;
+  newSsdStats->readSsdCorruptions = 10;
+  newSsdStats->readCheckpointErrors = 10;
+  newSsdStats->readWithoutChecksumChecks = 10;
+  newSsdStats->entriesRecovered = 10;
+  cache.updateStats(
+      {.numHit = 10,
+       .hitBytes = 10,
+       .numNew = 10,
+       .numEvict = 10,
+       .numSavableEvict = 10,
+       .numEvictChecks = 10,
+       .numWaitExclusive = 10,
+       .numAgedOut = 10,
+       .allocClocks = 10,
+       .sumEvictScore = 10,
+       .ssdStats = newSsdStats});
+  arbitrator.updateStats(memory::MemoryArbitrator::Stats(
+      10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10));
+  std::this_thread::sleep_for(std::chrono::milliseconds(4'000));
+
+  // Stop right after sufficient wait to ensure the following reads from main
+  // thread does not trigger TSAN failures.
+  periodicReporter.stop();
+
+  // Check delta stats are reported
+  {
+    std::lock_guard<std::mutex> l(reporter_->m);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumHits.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheHitBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumNew.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEvicts.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumSavableEvicts.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumEvictChecks.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumWaitExclusive.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumAllocClocks.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheNumAgedOutEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricMemoryCacheSumEvictScore.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWrittenEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWrittenBytes.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenSsdErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenCheckpointErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheOpenLogErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheDeleteCheckpointErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheGrowFileErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteSsdErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteSsdDropped.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheWriteCheckpointErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadSsdErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadCorruptions.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadCheckpointErrors.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheCheckpointsRead.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheCheckpointsWritten.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheRegionsEvicted.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheAgedOutEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheAgedOutRegions.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheRecoveredEntries.str()), 1);
+    ASSERT_EQ(counterMap.count(kMetricSsdCacheReadWithoutChecksum.str()), 1);
+    ASSERT_EQ(counterMap.size(), 54);
+  }
+}
+
+TEST_F(PeriodicStatsReporterTest, globalInstance) {
+  TestStatsReportMemoryArbitrator arbitrator({});
+  PeriodicStatsReporter::Options options;
+  PeriodicStatsReporter periodicReporter(options);
+  ASSERT_NO_THROW(periodicReporter.start());
+  std::this_thread::sleep_for(std::chrono::milliseconds(4'000));
+  ASSERT_NO_THROW(periodicReporter.stop());
+}
+
+TEST_F(PeriodicStatsReporterTest, allNullOption) {
+  PeriodicStatsReporter::Options options;
+  VELOX_ASSERT_THROW(
+      stopPeriodicStatsReporter(), "No periodic stats reporter to stop.");
+  ASSERT_NO_THROW(startPeriodicStatsReporter(options));
+  VELOX_ASSERT_THROW(
+      startPeriodicStatsReporter(options),
+      "The periodic stats reporter has already started.");
+  ASSERT_NO_THROW(stopPeriodicStatsReporter());
+}
+
 // Registering to folly Singleton with intended reporter type
 folly::Singleton<BaseStatsReporter> reporter([]() {
   return new TestReporter();
@@ -130,7 +616,7 @@ folly::Singleton<BaseStatsReporter> reporter([]() {
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   facebook::velox::BaseStatsReporter::registered = true;
   return RUN_ALL_TESTS();
 }
diff --git a/velox/common/base/tests/StatusTest.cpp b/velox/common/base/tests/StatusTest.cpp
new file mode 100644
index 0000000000000..8c0019e76ce72
--- /dev/null
+++ b/velox/common/base/tests/StatusTest.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/Status.h"
+#include <gtest/gtest.h>
+#include <sstream>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+namespace facebook::velox::test {
+namespace {
+
+TEST(StatusTest, testCodeAndMessage) {
+  Status ok = Status::OK();
+  ASSERT_EQ(StatusCode::kOK, ok.code());
+  ASSERT_EQ("", ok.message());
+  ASSERT_EQ("OK", ok.codeAsString());
+  ASSERT_TRUE(ok.ok());
+  ASSERT_FALSE(ok.isIOError());
+
+  Status fileError = Status::IOError("file error");
+  ASSERT_EQ(StatusCode::kIOError, fileError.code());
+  ASSERT_EQ("file error", fileError.message());
+}
+
+TEST(StatusTest, testNoMessage) {
+  Status fileError = Status::IOError();
+  ASSERT_EQ(StatusCode::kIOError, fileError.code());
+  ASSERT_EQ("", fileError.message());
+  ASSERT_EQ("IOError: ", fileError.toString());
+  ASSERT_EQ("IOError", fileError.codeAsString());
+}
+
+TEST(StatusTest, testToString) {
+  Status fileError = Status::IOError("file error");
+  ASSERT_EQ("IOError: file error", fileError.toString());
+  ASSERT_EQ("IOError", fileError.codeAsString());
+
+  std::stringstream ss;
+  ss << fileError;
+  ASSERT_EQ(fileError.toString(), ss.str());
+
+  // Check that fmt has the right specializations.
+  ASSERT_EQ(fileError.toString(), fmt::format("{}", fileError));
+  ASSERT_EQ("Unknown error", fmt::format("{}", StatusCode::kUnknownError));
+}
+
+TEST(StatusTest, andStatus) {
+  Status a = Status::OK();
+  Status b = Status::OK();
+  Status c = Status::Invalid("invalid value");
+  Status d = Status::IOError("file error");
+
+  Status res;
+  res = a & b;
+  ASSERT_TRUE(res.ok());
+  res = a & c;
+  ASSERT_TRUE(res.isInvalid());
+  res = d & c;
+  ASSERT_TRUE(res.isIOError());
+
+  res = Status::OK();
+  res &= c;
+  ASSERT_TRUE(res.isInvalid());
+  res &= d;
+  ASSERT_TRUE(res.isInvalid());
+
+  // With rvalues.
+  res = Status::OK() & Status::Invalid("foo");
+  ASSERT_TRUE(res.isInvalid());
+  res = Status::Invalid("foo") & Status::OK();
+  ASSERT_TRUE(res.isInvalid());
+  res = Status::Invalid("foo") & Status::IOError("bar");
+  ASSERT_TRUE(res.isInvalid());
+
+  res = Status::OK();
+  res &= Status::OK();
+  ASSERT_TRUE(res.ok());
+  res &= Status::Invalid("foo");
+  ASSERT_TRUE(res.isInvalid());
+  res &= Status::IOError("bar");
+  ASSERT_TRUE(res.isInvalid());
+}
+
+TEST(StatusTest, testEquality) {
+  ASSERT_EQ(Status(), Status::OK());
+  ASSERT_EQ(Status::Invalid("error"), Status::Invalid("error"));
+
+  ASSERT_NE(Status::Invalid("error"), Status::OK());
+  ASSERT_NE(Status::Invalid("error"), Status::Invalid("other error"));
+}
+
+TEST(StatusTest, testAbort) {
+  Status a = Status::Invalid("will abort process");
+  ASSERT_DEATH(a.abort(), "");
+}
+
+Status returnIf(bool cond) {
+  VELOX_RETURN_IF(cond, Status::Invalid("error"));
+  return Status::OK();
+}
+
+Status returnNotOk(Status s) {
+  VELOX_RETURN_NOT_OK(s);
+  return Status::Invalid("invalid");
+}
+
+TEST(StatusTest, macros) {
+  ASSERT_EQ(returnIf(true), Status::Invalid("error"));
+  ASSERT_EQ(returnIf(false), Status::OK());
+
+  ASSERT_EQ(returnNotOk(Status::UserError("user")), Status::UserError("user"));
+  ASSERT_EQ(returnNotOk(Status::OK()), Status::Invalid("invalid"));
+
+  VELOX_CHECK_OK(Status::OK()); // does not throw.
+
+  bool didThrow = false;
+  try {
+    VELOX_CHECK_OK(Status::Invalid("invalid"));
+  } catch (const VeloxRuntimeError&) {
+    didThrow = true;
+  }
+  ASSERT_TRUE(didThrow) << "VELOX_CHECK_OK did not throw";
+}
+
+Expected<int> modulo(int a, int b) {
+  if (b == 0) {
+    return folly::makeUnexpected(Status::UserError("division by zero"));
+  }
+
+  return a % b;
+}
+
+TEST(StatusTest, expected) {
+  auto result = modulo(10, 3);
+  EXPECT_TRUE(result.hasValue());
+  EXPECT_EQ(result.value(), 1);
+
+  result = modulo(10, 0);
+  EXPECT_TRUE(result.hasError());
+  EXPECT_EQ(result.error(), Status::UserError("division by zero"));
+}
+
+} // namespace
+} // namespace facebook::velox::test
diff --git a/velox/common/caching/AsyncDataCache.cpp b/velox/common/caching/AsyncDataCache.cpp
index 2d8015816ac2a..6da669daed66e 100644
--- a/velox/common/caching/AsyncDataCache.cpp
+++ b/velox/common/caching/AsyncDataCache.cpp
@@ -17,11 +17,23 @@
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/caching/FileIds.h"
 #include "velox/common/caching/SsdCache.h"
+#include "velox/common/caching/SsdFile.h"
 
-#include <folly/executors/QueuedImmediateExecutor.h>
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/caching/FileIds.h"
 
+#define VELOX_CACHE_ERROR(errorMessage)                             \
+  _VELOX_THROW(                                                     \
+      ::facebook::velox::VeloxRuntimeError,                         \
+      ::facebook::velox::error_source::kErrorSourceRuntime.c_str(), \
+      ::facebook::velox::error_code::kNoCacheSpace.c_str(),         \
+      /* isRetriable */ true,                                       \
+      "{}",                                                         \
+      errorMessage);
+
 namespace facebook::velox::cache {
 
 using memory::MachinePageCount;
@@ -35,7 +47,7 @@ AsyncDataCacheEntry::~AsyncDataCacheEntry() {
   shard_->cache()->allocator()->freeNonContiguous(data_);
 }
 
-void AsyncDataCacheEntry::setExclusiveToShared() {
+void AsyncDataCacheEntry::setExclusiveToShared(bool ssdSavable) {
   VELOX_CHECK(isExclusive());
   numPins_ = 1;
   std::unique_ptr<folly::SharedPromise<bool>> promise;
@@ -51,14 +63,19 @@ void AsyncDataCacheEntry::setExclusiveToShared() {
 
   // The entry may now have other readers, It is safe to do read-only ops like
   // integrity and notifying SSD cache of another candidate.
+  //
+  // NOTE: this is only used by test for now.
   const auto& hook = shard_->cache()->verifyHook();
   if (hook != nullptr) {
     hook(*this);
   }
 
-  if ((ssdFile_ == nullptr) && (shard_->cache()->ssdCache() != nullptr)) {
-    auto* ssdCache = shard_->cache()->ssdCache();
-    assert(ssdCache); // for lint only.
+  if (!ssdSavable) {
+    return;
+  }
+
+  auto* ssdCache = shard_->cache()->ssdCache();
+  if ((ssdCache != nullptr) && (ssdFile_ == nullptr)) {
     if (ssdCache->groupStats().shouldSaveToSsd(groupId_, trackingId_)) {
       ssdSaveable_ = true;
       shard_->cache()->possibleSsdSave(size_);
@@ -112,13 +129,10 @@ void AsyncDataCacheEntry::initialize(FileCacheKey key) {
     } else {
       // No memory to cover 'this'.
       release();
-      _VELOX_THROW(
-          VeloxRuntimeError,
-          error_source::kErrorSourceRuntime.c_str(),
-          error_code::kNoCacheSpace.c_str(),
-          /* isRetriable */ true,
-          "Failed to allocate {} bytes for cache",
-          size_);
+      VELOX_CACHE_ERROR(fmt::format(
+          "Failed to allocate {} bytes for cache: {}",
+          size_,
+          cache->allocator()->getAndClearFailureMessage()));
     }
   }
 }
@@ -158,28 +172,28 @@ CachePin CacheShard::findOrCreate(
     ++eventCounter_;
     auto it = entryMap_.find(key);
     if (it != entryMap_.end()) {
-      auto* found = it->second;
-      if (found->isExclusive()) {
+      auto* foundEntry = it->second;
+      if (foundEntry->isExclusive()) {
         ++numWaitExclusive_;
-        if (wait == nullptr) {
-          return CachePin();
+        if (wait != nullptr) {
+          *wait = foundEntry->getFuture();
         }
-        *wait = found->getFuture();
         return CachePin();
       }
-      if (found->size() >= size) {
-        found->touch();
+
+      if (foundEntry->size() >= size) {
+        foundEntry->touch();
         // The entry is in a readable state. Add a pin.
-        if (found->isPrefetch()) {
-          found->isFirstUse_ = true;
-          found->setPrefetch(false);
+        if (foundEntry->isPrefetch()) {
+          foundEntry->isFirstUse_ = true;
+          foundEntry->setPrefetch(false);
         } else {
           ++numHit_;
-          hitBytes_ += found->size();
+          hitBytes_ += foundEntry->size();
         }
-        ++found->numPins_;
+        ++foundEntry->numPins_;
         CachePin pin;
-        pin.setEntry(found);
+        pin.setEntry(foundEntry);
         return pin;
       }
 
@@ -188,11 +202,14 @@ CachePin CacheShard::findOrCreate(
       // This can happen if different load quanta apply to access via different
       // connectors. This is not an error but still worth logging.
       VELOX_CACHE_LOG_EVERY_MS(WARNING, 1'000)
-          << "Requested larger entry. Found size " << found->size()
+          << "Requested larger entry. Found size " << foundEntry->size()
           << " requested size " << size;
       // The old entry is superseded. Possible readers of the old entry still
       // retain a valid read pin.
-      found->key_.fileNum.clear();
+      RECORD_METRIC_VALUE(kMetricMemoryCacheNumStaleEntries);
+      ++numStales_;
+      foundEntry->key_.fileNum.clear();
+      entryMap_.erase(it);
     }
 
     auto newEntry = getFreeEntry();
@@ -217,6 +234,15 @@ CachePin CacheShard::findOrCreate(
   return initEntry(key, entryToInit);
 }
 
+void CacheShard::makeEvictable(RawFileCacheKey key) {
+  std::lock_guard<std::mutex> l(mutex_);
+  auto it = entryMap_.find(key);
+  if (it == entryMap_.end()) {
+    return;
+  }
+  it->second->makeEvictable();
+}
+
 bool CacheShard::exists(RawFileCacheKey key) const {
   std::lock_guard<std::mutex> l(mutex_);
   auto it = entryMap_.find(key);
@@ -248,7 +274,9 @@ CoalescedLoad::~CoalescedLoad() {
   setEndState(State::kCancelled);
 }
 
-bool CoalescedLoad::loadOrFuture(folly::SemiFuture<bool>* wait) {
+bool CoalescedLoad::loadOrFuture(
+    folly::SemiFuture<bool>* wait,
+    bool ssdSavable) {
   {
     std::lock_guard<std::mutex> l(mutex_);
     if (state_ == State::kCancelled || state_ == State::kLoaded) {
@@ -268,20 +296,21 @@ bool CoalescedLoad::loadOrFuture(folly::SemiFuture<bool>* wait) {
     VELOX_CHECK_EQ(State::kPlanned, state_);
     state_ = State::kLoading;
   }
+
   // Outside of 'mutex_'.
   try {
-    const auto pins = loadData(!wait);
+    const auto pins = loadData(/*prefetch=*/wait == nullptr);
     for (const auto& pin : pins) {
       auto* entry = pin.checkedEntry();
       VELOX_CHECK(entry->key().fileNum.hasValue());
       VELOX_CHECK(entry->isExclusive());
-      entry->setExclusiveToShared();
+      entry->setExclusiveToShared(ssdSavable);
     }
     setEndState(State::kLoaded);
-  } catch (std::exception& e) {
+  } catch (std::exception&) {
     try {
       setEndState(State::kCancelled);
-    } catch (std::exception& inner) {
+    } catch (std::exception&) {
       // May not throw from inside catch.
     }
     throw;
@@ -290,11 +319,14 @@ bool CoalescedLoad::loadOrFuture(folly::SemiFuture<bool>* wait) {
 }
 
 void CoalescedLoad::setEndState(State endState) {
-  std::lock_guard<std::mutex> l(mutex_);
-  state_ = endState;
-  if (promise_ != nullptr) {
-    promise_->setValue(true);
-    promise_.reset();
+  std::unique_ptr<folly::SharedPromise<bool>> promise;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    state_ = endState;
+    promise.swap(promise_);
+  }
+  if (promise != nullptr) {
+    promise->setValue(true);
   }
 }
 
@@ -308,14 +340,13 @@ std::unique_ptr<folly::SharedPromise<bool>> CacheShard::removeEntry(
 }
 
 void CacheShard::removeEntryLocked(AsyncDataCacheEntry* entry) {
-  if (!entry->key_.fileNum.hasValue()) {
-    return;
+  if (entry->key_.fileNum.hasValue()) {
+    const auto it = entryMap_.find(
+        RawFileCacheKey{entry->key_.fileNum.id(), entry->key_.offset});
+    VELOX_CHECK(it != entryMap_.end());
+    entryMap_.erase(it);
+    entry->key_.fileNum.clear();
   }
-  const auto it = entryMap_.find(
-      RawFileCacheKey{entry->key_.fileNum.id(), entry->key_.offset});
-  VELOX_CHECK(it != entryMap_.end());
-  entryMap_.erase(it);
-  entry->key_.fileNum.clear();
   entry->setSsdFile(nullptr, 0);
   if (entry->isPrefetch()) {
     entry->setPrefetch(false);
@@ -329,25 +360,29 @@ void CacheShard::removeEntryLocked(AsyncDataCacheEntry* entry) {
     cache_->incrementCachedPages(-numPages);
     cache_->allocator()->freeNonContiguous(entry->data());
   }
+  entry->tinyData_.clear();
+  entry->tinyData_.shrink_to_fit();
+  entry->size_ = 0;
 }
 
-void CacheShard::evict(
+uint64_t CacheShard::evict(
     uint64_t bytesToFree,
     bool evictAllUnpinned,
-    int32_t pagesToAcquire,
+    MachinePageCount pagesToAcquire,
     memory::Allocation& acquired) {
-  int64_t tinyFreed = 0;
-  int64_t largeFreed = 0;
-  int32_t evictSaveableSkipped = 0;
-  auto ssdCache = cache_->ssdCache();
-  bool skipSsdSaveable = ssdCache && ssdCache->writeInProgress();
+  auto* ssdCache = cache_->ssdCache();
+  const bool skipSsdSaveable =
+      (ssdCache != nullptr) && ssdCache->writeInProgress();
   auto now = accessTime();
   std::vector<memory::Allocation> toFree;
+  int64_t tinyEvicted = 0;
+  int64_t largeEvicted = 0;
+  int32_t evictSaveableSkipped = 0;
   {
     std::lock_guard<std::mutex> l(mutex_);
-    int size = entries_.size();
-    if (!size) {
-      return;
+    const size_t size = entries_.size();
+    if (size == 0) {
+      return 0;
     }
     int32_t counter = 0;
     int32_t numChecked = 0;
@@ -360,13 +395,15 @@ void CacheShard::evict(
       } else {
         ++entryIndex;
       }
+
       ++numEvictChecks_;
+      ++clockHand_;
       auto candidate = iter->get();
-      if (!candidate) {
+      if (candidate == nullptr) {
         continue;
       }
+
       ++numChecked;
-      ++clockHand_;
       if (evictionThreshold_ == kNoThreshold ||
           eventCounter_ > entries_.size() / 4 ||
           numChecked > entries_.size() / 8) {
@@ -375,17 +412,21 @@ void CacheShard::evict(
         numChecked = 0;
         eventCounter_ = 0;
       }
+
       int32_t score = 0;
       if (candidate->numPins_ == 0 &&
           (!candidate->key_.fileNum.hasValue() || evictAllUnpinned ||
            (score = candidate->score(now)) >= evictionThreshold_)) {
-        if (skipSsdSaveable && candidate->ssdSaveable_ && !evictAllUnpinned) {
+        if (skipSsdSaveable && candidate->ssdSaveable() && !evictAllUnpinned) {
           ++evictSaveableSkipped;
           continue;
         }
-        largeFreed += candidate->data_.byteSize();
+        if (candidate->ssdSaveable()) {
+          ++numSavableEvict_;
+        }
+        largeEvicted += candidate->data_.byteSize();
         if (pagesToAcquire > 0) {
-          auto candidatePages = candidate->data().numPages();
+          const auto candidatePages = candidate->data().numPages();
           pagesToAcquire = candidatePages > pagesToAcquire
               ? 0
               : pagesToAcquire - candidatePages;
@@ -394,36 +435,43 @@ void CacheShard::evict(
         } else {
           toFree.push_back(std::move(candidate->data()));
         }
-        removeEntryLocked(candidate);
-        emptySlots_.push_back(entryIndex);
-        tinyFreed += candidate->tinyData_.size();
+        tinyEvicted += candidate->tinyData_.size();
         candidate->tinyData_.clear();
         candidate->tinyData_.shrink_to_fit();
         candidate->size_ = 0;
+
+        removeEntryLocked(candidate);
+        emptySlots_.push_back(entryIndex);
         tryAddFreeEntry(std::move(*iter));
         ++numEvict_;
-        if (score) {
+        if (score > 0) {
           sumEvictScore_ += score;
         }
-        if (largeFreed + tinyFreed > bytesToFree) {
+        if (largeEvicted + tinyEvicted > bytesToFree) {
           break;
         }
       }
     }
   }
+
   ClockTimer t(allocClocks_);
   freeAllocations(toFree);
   cache_->incrementCachedPages(
-      -largeFreed / static_cast<int32_t>(memory::AllocationTraits::kPageSize));
-  if (evictSaveableSkipped && ssdCache && ssdCache->startWrite()) {
-    // Rare. May occur if SSD is unusually slow. Useful for  diagnostics.
-    VELOX_SSD_CACHE_LOG(INFO)
-        << "Start save for old saveable, skipped " << cache_->numSkippedSaves();
-    cache_->numSkippedSaves() = 0;
-    cache_->saveToSsd();
-  } else if (evictSaveableSkipped) {
-    ++cache_->numSkippedSaves();
+      -memory::AllocationTraits::numPages(largeEvicted));
+  if (evictSaveableSkipped) {
+    VELOX_CHECK_NOT_NULL(ssdCache);
+    if (ssdCache->startWrite()) {
+      // Rare. May occur if SSD is unusually slow. Useful for diagnostics.
+      VELOX_SSD_CACHE_LOG(INFO) << "Start save for old saveable, skipped "
+                                << cache_->numSkippedSaves();
+      cache_->numSkippedSaves() = 0;
+      cache_->saveToSsd();
+    } else {
+      ++cache_->numSkippedSaves();
+    }
   }
+
+  return largeEvicted + tinyEvicted;
 }
 
 void CacheShard::tryAddFreeEntry(std::unique_ptr<AsyncDataCacheEntry>&& entry) {
@@ -471,8 +519,12 @@ void CacheShard::updateStats(CacheStats& stats) {
       ++stats.numEmptyEntries;
       continue;
     } else if (entry->isExclusive()) {
+      stats.exclusivePinnedBytes +=
+          entry->data().byteSize() + entry->tinyData_.capacity();
       ++stats.numExclusive;
     } else if (entry->isShared()) {
+      stats.sharedPinnedBytes +=
+          entry->data().byteSize() + entry->tinyData_.capacity();
       ++stats.numShared;
     }
     if (entry->isPrefetch_) {
@@ -482,29 +534,37 @@ void CacheShard::updateStats(CacheStats& stats) {
     ++stats.numEntries;
     stats.tinySize += entry->tinyData_.size();
     stats.tinyPadding += entry->tinyData_.capacity() - entry->tinyData_.size();
-    stats.largeSize += entry->size_;
-    stats.largePadding += entry->data_.byteSize() - entry->size_;
+    if (entry->tinyData_.empty()) {
+      stats.largeSize += entry->size_;
+      stats.largePadding += entry->data_.byteSize() - entry->size_;
+    }
   }
   stats.numHit += numHit_;
   stats.hitBytes += hitBytes_;
   stats.numNew += numNew_;
   stats.numEvict += numEvict_;
+  stats.numSavableEvict += numSavableEvict_;
   stats.numEvictChecks += numEvictChecks_;
   stats.numWaitExclusive += numWaitExclusive_;
+  stats.numAgedOut += numAgedOut_;
+  stats.numStales += numStales_;
   stats.sumEvictScore += sumEvictScore_;
   stats.allocClocks += allocClocks_;
 }
 
-void CacheShard::appendSsdSaveable(std::vector<CachePin>& pins) {
+void CacheShard::appendSsdSaveable(bool saveAll, std::vector<CachePin>& pins) {
   std::lock_guard<std::mutex> l(mutex_);
-  // Do not add more than 70% of entries to a write batch.If SSD save
-  // is slower than storage read, we must not have a situation where
-  // SSD save pins everything and stops reading.
-  const int32_t limit = (entries_.size() * 100) / 70;
+  // Do not add entries to a write batch more than maxWriteRatio_. If SSD save
+  // is slower than storage read, we must not have a situation where SSD save
+  // pins everything and stops reading.
+  const int32_t limit = saveAll
+      ? std::numeric_limits<int32_t>::max()
+      : static_cast<int32_t>(
+            static_cast<double>(entries_.size()) * maxWriteRatio_);
   VELOX_CHECK(cache_->ssdCache()->writeInProgress());
   for (auto& entry : entries_) {
-    if (entry && !entry->ssdFile_ && !entry->isExclusive() &&
-        entry->ssdSaveable_) {
+    if (entry && (entry->ssdFile_ == nullptr) && !entry->isExclusive() &&
+        entry->ssdSaveable()) {
       CachePin pin;
       ++entry->numPins_;
       pin.setEntry(entry.get());
@@ -518,22 +578,105 @@ void CacheShard::appendSsdSaveable(std::vector<CachePin>& pins) {
   }
 }
 
+bool CacheShard::removeFileEntries(
+    const folly::F14FastSet<uint64_t>& filesToRemove,
+    folly::F14FastSet<uint64_t>& filesRetained) {
+  if (filesToRemove.empty()) {
+    VELOX_CACHE_LOG(INFO) << "Removed 0 AsyncDataCache entry.";
+    return true;
+  }
+
+  int64_t pagesRemoved = 0;
+  std::vector<memory::Allocation> toFree;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+
+    auto entryIndex = -1;
+    for (auto& cacheEntry : entries_) {
+      entryIndex++;
+      if (!cacheEntry || !cacheEntry->key_.fileNum.hasValue()) {
+        continue;
+      }
+      if (filesToRemove.count(cacheEntry->key_.fileNum.id()) == 0) {
+        continue;
+      }
+      if (cacheEntry->isExclusive() || cacheEntry->isShared()) {
+        filesRetained.insert(cacheEntry->key_.fileNum.id());
+        continue;
+      }
+
+      numAgedOut_++;
+      pagesRemoved += (int64_t)cacheEntry->data().numPages();
+
+      toFree.push_back(std::move(cacheEntry->data()));
+      removeEntryLocked(cacheEntry.get());
+      emptySlots_.push_back(entryIndex);
+      tryAddFreeEntry(std::move(cacheEntry));
+      cacheEntry = nullptr;
+    }
+  }
+  VELOX_CACHE_LOG(INFO) << "Removed " << toFree.size()
+                        << " AsyncDataCache entries.";
+
+  // Free the memory allocation out of the cache shard lock.
+  ClockTimer t(allocClocks_);
+  freeAllocations(toFree);
+  cache_->incrementCachedPages(-pagesRemoved);
+
+  return true;
+}
+
+CacheStats CacheStats::operator-(const CacheStats& other) const {
+  CacheStats result;
+  result.numHit = numHit - other.numHit;
+  result.hitBytes = hitBytes - other.hitBytes;
+  result.numNew = numNew - other.numNew;
+  result.numEvict = numEvict - other.numEvict;
+  result.numSavableEvict = numSavableEvict - other.numSavableEvict;
+  result.numEvictChecks = numEvictChecks - other.numEvictChecks;
+  result.numWaitExclusive = numWaitExclusive - other.numWaitExclusive;
+  result.numAgedOut = numAgedOut - other.numAgedOut;
+  result.numStales = numStales - other.numStales;
+  result.allocClocks = allocClocks - other.allocClocks;
+  result.sumEvictScore = sumEvictScore - other.sumEvictScore;
+  if (ssdStats != nullptr) {
+    if (other.ssdStats != nullptr) {
+      result.ssdStats =
+          std::make_shared<SsdCacheStats>(*ssdStats - *other.ssdStats);
+    } else {
+      result.ssdStats = std::make_shared<SsdCacheStats>(*ssdStats);
+    }
+  }
+  return result;
+}
+
 AsyncDataCache::AsyncDataCache(
     memory::MemoryAllocator* allocator,
     std::unique_ptr<SsdCache> ssdCache)
-    : allocator_(allocator), ssdCache_(std::move(ssdCache)), cachedPages_(0) {
+    : AsyncDataCache({}, allocator, std::move(ssdCache)){};
+
+AsyncDataCache::AsyncDataCache(
+    const Options& options,
+    memory::MemoryAllocator* allocator,
+    std::unique_ptr<SsdCache> ssdCache)
+    : opts_(options),
+      allocator_(allocator),
+      ssdCache_(std::move(ssdCache)),
+      cachedPages_(0) {
   for (auto i = 0; i < kNumShards; ++i) {
-    shards_.push_back(std::make_unique<CacheShard>(this));
+    shards_.push_back(std::make_unique<CacheShard>(this, opts_.maxWriteRatio));
   }
 }
 
-AsyncDataCache::~AsyncDataCache() {}
+AsyncDataCache::~AsyncDataCache() = default;
 
 // static
 std::shared_ptr<AsyncDataCache> AsyncDataCache::create(
     memory::MemoryAllocator* allocator,
-    std::unique_ptr<SsdCache> ssdCache) {
-  auto cache = std::make_shared<AsyncDataCache>(allocator, std::move(ssdCache));
+    std::unique_ptr<SsdCache> ssdCache,
+    const AsyncDataCache::Options& options) {
+  auto cache =
+      std::make_shared<AsyncDataCache>(options, allocator, std::move(ssdCache));
   allocator->registerCache(cache);
   return cache;
 }
@@ -555,6 +698,9 @@ AsyncDataCache** AsyncDataCache::getInstancePtr() {
 }
 
 void AsyncDataCache::shutdown() {
+  if (ssdCache_) {
+    ssdCache_->shutdown();
+  }
   for (auto& shard : shards_) {
     shard->shutdown();
   }
@@ -573,6 +719,11 @@ CachePin AsyncDataCache::findOrCreate(
   return shards_[shard]->findOrCreate(key, size, wait);
 }
 
+void AsyncDataCache::makeEvictable(RawFileCacheKey key) {
+  const int shard = std::hash<RawFileCacheKey>()(key) & (kShardMask);
+  return shards_[shard]->makeEvictable(key);
+}
+
 bool AsyncDataCache::exists(RawFileCacheKey key) const {
   int shard = std::hash<RawFileCacheKey>()(key) & (kShardMask);
   return shards_[shard]->exists(key);
@@ -659,7 +810,7 @@ bool AsyncDataCache::makeSpace(
     // with 'evictAllUnpinned' set to true.
     shards_[shardCounter_ & (kShardMask)]->evict(
         memory::AllocationTraits::pageBytes(
-            std::max<int32_t>(kMinEvictPages, numPages) * sizeMultiplier),
+            std::max<uint64_t>(kMinEvictPages, numPages) * sizeMultiplier),
         nthAttempt >= kNumShards,
         numPagesToAcquire,
         acquired);
@@ -667,9 +818,51 @@ bool AsyncDataCache::makeSpace(
       sizeMultiplier *= 2;
     }
   }
+  memory::setCacheFailureMessage(
+      fmt::format("Failed to evict from cache state: {}", toString(false)));
   return false;
 }
 
+uint64_t AsyncDataCache::shrink(uint64_t targetBytes) {
+  VELOX_CHECK_GT(targetBytes, 0);
+
+  RECORD_METRIC_VALUE(kMetricCacheShrinkCount);
+  LOG(INFO) << "Try to shrink cache to free up "
+            << velox::succinctBytes(targetBytes) << "  memory";
+
+  const uint64_t minBytesToEvict = 8UL << 20;
+  uint64_t evictedBytes{0};
+  uint64_t shrinkTimeUs{0};
+  {
+    MicrosecondTimer timer(&shrinkTimeUs);
+    for (int shard = 0; shard < shards_.size(); ++shard) {
+      memory::Allocation unused;
+      evictedBytes += shards_[shardCounter_++ & (kShardMask)]->evict(
+          std::max<uint64_t>(minBytesToEvict, targetBytes - evictedBytes),
+          // Cache shrink is triggered when server is under low memory pressure
+          // so need to free up memory as soon as possible. So we always avoid
+          // triggering ssd save to accelerate the cache evictions.
+          true,
+          0,
+          unused);
+      VELOX_CHECK(unused.empty());
+      if (evictedBytes >= targetBytes) {
+        break;
+      }
+    }
+    // Call unmap to free up to 'targetBytes' unused memory space back to
+    // operating system after shrink.
+    allocator_->unmap(memory::AllocationTraits::numPages(targetBytes));
+  }
+
+  RECORD_HISTOGRAM_METRIC_VALUE(kMetricCacheShrinkTimeMs, shrinkTimeUs / 1'000);
+  LOG(INFO) << "Freed " << velox::succinctBytes(evictedBytes)
+            << " cache memory, spent " << velox::succinctMicros(shrinkTimeUs)
+            << "\n"
+            << toString();
+  return evictedBytes;
+}
+
 bool AsyncDataCache::canTryAllocate(
     int32_t numPages,
     const memory::Allocation& acquired) const {
@@ -683,11 +876,11 @@ bool AsyncDataCache::canTryAllocate(
 
 void AsyncDataCache::backoff(int32_t counter) {
   size_t seed = folly::hasher<uint16_t>()(++backoffCounter_);
-  const auto usec = (seed & 0xfff) * (counter & 0x1f);
+  const auto usecs = (seed & 0xfff) * (counter & 0x1f);
   VELOX_CACHE_LOG_EVERY_MS(INFO, 1'000)
-      << "Backoff in allocation contention for " << succinctMicros(usec);
+      << "Backoff in allocation contention for " << succinctMicros(usecs);
 
-  std::this_thread::sleep_for(std::chrono::microseconds(usec)); // NOLINT
+  std::this_thread::sleep_for(std::chrono::microseconds(usecs)); // NOLINT
 }
 
 void AsyncDataCache::incrementNew(uint64_t size) {
@@ -705,14 +898,17 @@ void AsyncDataCache::incrementNew(uint64_t size) {
 }
 
 void AsyncDataCache::possibleSsdSave(uint64_t bytes) {
-  constexpr int32_t kMinSavePages = 4096; // Save at least 16MB at a time.
   if (ssdCache_ == nullptr) {
     return;
   }
 
   ssdSaveable_ += bytes;
   if (memory::AllocationTraits::numPages(ssdSaveable_) >
-      std::max<int32_t>(kMinSavePages, cachedPages_ / 8)) {
+      std::max<int32_t>(
+          static_cast<int32_t>(
+              memory::AllocationTraits::numPages(opts_.minSsdSavableBytes)),
+          static_cast<int32_t>(
+              static_cast<double>(cachedPages_) * opts_.ssdSavableRatio))) {
     // Do not start a new save if another one is in progress.
     if (!ssdCache_->startWrite()) {
       return;
@@ -721,16 +917,37 @@ void AsyncDataCache::possibleSsdSave(uint64_t bytes) {
   }
 }
 
-void AsyncDataCache::saveToSsd() {
+void AsyncDataCache::saveToSsd(bool saveAll) {
   std::vector<CachePin> pins;
   VELOX_CHECK(ssdCache_->writeInProgress());
   ssdSaveable_ = 0;
   for (auto& shard : shards_) {
-    shard->appendSsdSaveable(pins);
+    shard->appendSsdSaveable(saveAll, pins);
   }
   ssdCache_->write(std::move(pins));
 }
 
+bool AsyncDataCache::removeFileEntries(
+    const folly::F14FastSet<uint64_t>& filesToRemove,
+    folly::F14FastSet<uint64_t>& filesRetained) {
+  bool success = true;
+
+  for (auto& shard : shards_) {
+    try {
+      success &= shard->removeFileEntries(filesToRemove, filesRetained);
+    } catch (const std::exception&) {
+      VELOX_CACHE_LOG(ERROR)
+          << "Error removing file entries from AsyncDataCache shard.";
+      success = false;
+    }
+  }
+
+  if (ssdCache_) {
+    success &= ssdCache_->removeFileEntries(filesToRemove, filesRetained);
+  }
+  return success;
+}
+
 CacheStats AsyncDataCache::refreshStats() const {
   CacheStats stats;
   for (auto& shard : shards_) {
@@ -744,26 +961,40 @@ CacheStats AsyncDataCache::refreshStats() const {
 
 void AsyncDataCache::clear() {
   for (auto& shard : shards_) {
-    memory::Allocation acquired;
-    shard->evict(std::numeric_limits<int32_t>::max(), true, 0, acquired);
-    VELOX_CHECK(acquired.empty());
+    memory::Allocation unused;
+    shard->evict(std::numeric_limits<uint64_t>::max(), true, 0, unused);
+    VELOX_CHECK(unused.empty());
   }
 }
 
-std::string AsyncDataCache::toString() const {
+std::string AsyncDataCache::toString(bool details) const {
   auto stats = refreshStats();
   std::stringstream out;
   out << "AsyncDataCache:\n"
       << stats.toString() << "\n"
       << "Allocated pages: " << allocator_->numAllocated()
       << " cached pages: " << cachedPages_ << "\n";
-  out << "Backing: " << allocator_->toString();
-  if (ssdCache_) {
-    out << "\nSSD: " << ssdCache_->toString();
+  if (details) {
+    out << "Backing: " << allocator_->toString();
+    if (ssdCache_) {
+      out << "\nSSD: " << ssdCache_->toString();
+    }
   }
   return out.str();
 }
 
+std::vector<AsyncDataCacheEntry*> AsyncDataCache::testingCacheEntries() const {
+  std::vector<AsyncDataCacheEntry*> totalEntries;
+  for (const auto& shard : shards_) {
+    const auto shardEntries = shard->testingCacheEntries();
+    std::copy(
+        shardEntries.begin(),
+        shardEntries.end(),
+        std::back_inserter(totalEntries));
+  }
+  return totalEntries;
+}
+
 std::string CacheStats::toString() const {
   std::stringstream out;
   // Cache size stats.
@@ -775,13 +1006,17 @@ std::string CacheStats::toString() const {
       // Cache entries
       << "Cache entries: " << numEntries << " read pins: " << numShared
       << " write pins: " << numExclusive
+      << " pinned shared: " << succinctBytes(sharedPinnedBytes)
+      << " pinned exclusive: " << succinctBytes(exclusivePinnedBytes) << "\n"
       << " num write wait: " << numWaitExclusive
       << " empty entries: " << numEmptyEntries
       << "\n"
       // Cache access stats.
       << "Cache access miss: " << numNew << " hit: " << numHit
       << " hit bytes: " << succinctBytes(hitBytes) << " eviction: " << numEvict
-      << " eviction checks: " << numEvictChecks
+      << " savable eviction: " << numSavableEvict
+      << " eviction checks: " << numEvictChecks << " aged out: " << numAgedOut
+      << " stales: " << numStales
       << "\n"
       // Cache prefetch stats.
       << "Prefetch entries: " << numPrefetch
@@ -841,4 +1076,14 @@ CoalesceIoStats readPins(
       std::move(readFunc));
 }
 
+std::vector<AsyncDataCacheEntry*> CacheShard::testingCacheEntries() const {
+  std::vector<AsyncDataCacheEntry*> entries;
+  std::lock_guard<std::mutex> l(mutex_);
+  entries.reserve(entries_.size());
+  for (const auto& entry : entries_) {
+    entries.push_back(entry.get());
+  }
+  return entries;
+}
+
 } // namespace facebook::velox::cache
diff --git a/velox/common/caching/AsyncDataCache.h b/velox/common/caching/AsyncDataCache.h
index 4f34306ae2ab0..b1e3c6a409c03 100644
--- a/velox/common/caching/AsyncDataCache.h
+++ b/velox/common/caching/AsyncDataCache.h
@@ -19,9 +19,11 @@
 #include <deque>
 
 #include <fmt/format.h>
+#include <folly/GLog.h>
 #include <folly/chrono/Hardware.h>
+#include <folly/container/F14Set.h>
 #include <folly/futures/SharedPromise.h>
-#include "folly/GLog.h"
+
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/CoalesceIo.h"
 #include "velox/common/base/Portability.h"
@@ -30,6 +32,7 @@
 #include "velox/common/caching/ScanTracker.h"
 #include "velox/common/caching/StringIdMap.h"
 #include "velox/common/file/File.h"
+#include "velox/common/memory/Memory.h"
 #include "velox/common/memory/MemoryAllocator.h"
 
 namespace facebook::velox::cache {
@@ -42,7 +45,7 @@ namespace facebook::velox::cache {
 class AsyncDataCache;
 class CacheShard;
 class SsdCache;
-class SsdCacheStats;
+struct SsdCacheStats;
 class SsdFile;
 
 // Type for tracking last access. This is based on CPU clock and
@@ -60,8 +63,8 @@ inline AccessTime accessTime() {
 }
 
 struct AccessStats {
-  AccessTime lastUse{0};
-  int32_t numUses{0};
+  tsan_atomic<AccessTime> lastUse{0};
+  tsan_atomic<int32_t> numUses{0};
 
   // Retention score. A higher number means less worth retaining. This
   // works well with a typical formula of time over use count going to
@@ -76,9 +79,9 @@ struct AccessStats {
     return (now - lastUse) / (1 + numUses);
   }
 
-  // Resets the access tracking to not accessed. This is used after
-  // evicting the previous contents of the entry, so that the new data
-  // does not inherit the history of the previous.
+  // Resets the access tracking to not accessed. This is used after evicting the
+  // previous contents of the entry, so that the new data does not inherit the
+  // history of the previous.
   void reset() {
     lastUse = accessTime();
     numUses = 0;
@@ -132,17 +135,17 @@ struct hash<::facebook::velox::cache::RawFileCacheKey> {
 
 namespace facebook::velox::cache {
 
-// Represents a contiguous range of bytes cached from a file. This
-// is the primary unit of access. These are typically owned via
-// CachePin and can be in shared or exclusive mode. 'numPins_'
-// counts the shared leases, the special value kExclusive means that
-// this is being written to by another thread. It is possible to
-// wait for the exclusive mode to finish, at which time one can
-// retry getting access. Entries belong to one CacheShard at a
-// time. The CacheShard serializes the mapping from a key to the
-// entry and the setting entries to exclusive mode. An unpinned
-// entry is evictable. CacheShard decides the eviction policy and
-// serializes eviction with other access.
+/// Represents a contiguous range of bytes cached from a file. This
+/// is the primary unit of access. These are typically owned via
+/// CachePin and can be in shared or exclusive mode. 'numPins_'
+/// counts the shared leases, the special value kExclusive means that
+/// this is being written to by another thread. It is possible to
+/// wait for the exclusive mode to finish, at which time one can
+/// retry getting access. Entries belong to one CacheShard at a
+/// time. The CacheShard serializes the mapping from a key to the
+/// entry and the setting entries to exclusive mode. An unpinned
+/// entry is evictable. CacheShard decides the eviction policy and
+/// serializes eviction with other access.
 class AsyncDataCacheEntry {
  public:
   static constexpr int32_t kExclusive = -10000;
@@ -151,9 +154,9 @@ class AsyncDataCacheEntry {
   explicit AsyncDataCacheEntry(CacheShard* shard);
   ~AsyncDataCacheEntry();
 
-  // Sets the key and allocates the entry's memory.  Resets
-  //  all other state. The entry must be held exclusively and must
-  //  hold no memory when calling this.
+  /// Sets the key and allocates the entry's memory.  Resets
+  ///  all other state. The entry must be held exclusively and must
+  ///  hold no memory when calling this.
   void initialize(FileCacheKey key);
 
   memory::Allocation& data() {
@@ -221,7 +224,9 @@ class AsyncDataCacheEntry {
     return value;
   }
 
-  void setExclusiveToShared();
+  /// If 'ssdSavable' is true, marks the loaded cache entry as ssdSavable if it
+  /// is not loaded from ssd.
+  void setExclusiveToShared(bool ssdSavable = true);
 
   void setSsdFile(SsdFile* file, uint64_t offset) {
     ssdFile_ = file;
@@ -237,6 +242,10 @@ class AsyncDataCacheEntry {
     return ssdOffset_;
   }
 
+  bool ssdSaveable() const {
+    return ssdSaveable_;
+  }
+
   void setTrackingId(TrackingId id) {
     trackingId_ = id;
   }
@@ -248,15 +257,23 @@ class AsyncDataCacheEntry {
   /// Sets access stats so that this is immediately evictable.
   void makeEvictable();
 
-  // Moves the promise out of 'this'. Used in order to handle the
-  // promise within the lock of the cache shard, so not within private
-  // methods of 'this'.
+  /// Moves the promise out of 'this'. Used in order to handle the
+  /// promise within the lock of the cache shard, so not within private
+  /// methods of 'this'.
   std::unique_ptr<folly::SharedPromise<bool>> movePromise() {
     return std::move(promise_);
   }
 
   std::string toString() const;
 
+  const AccessStats& testingAccessStats() const {
+    return accessStats_;
+  }
+
+  bool testingFirstUse() const {
+    return isFirstUse_;
+  }
+
  private:
   void release();
   void addReference();
@@ -290,9 +307,9 @@ class AsyncDataCacheEntry {
 
   AccessStats accessStats_;
 
-  // True if 'this' is speculatively loaded. This is reset on first
-  // hit. Allows catching a situation where prefetched entries get
-  // evicted before they are hit.
+  // True if 'this' is speculatively loaded. This is reset on first hit. Allows
+  // catching a situation where prefetched entries get evicted before they are
+  // hit.
   bool isPrefetch_{false};
 
   // Sets after first use of a prefetched entry. Cleared by
@@ -421,8 +438,9 @@ class CoalescedLoad {
   /// load of the entries that are not yet present. If another thread is in the
   /// process of doing this and 'wait' is null, returns immediately. If another
   /// thread is in the process of doing this and 'wait' is not null, waits for
-  /// the other thread to be done.
-  bool loadOrFuture(folly::SemiFuture<bool>* wait);
+  /// the other thread to be done. If 'ssdSavable' is true, marks the loaded
+  /// entries as ssdsavable.
+  bool loadOrFuture(folly::SemiFuture<bool>* wait, bool ssdSavable = true);
 
   State state() const {
     tsan_lock_guard<std::mutex> l(mutex_);
@@ -441,14 +459,13 @@ class CoalescedLoad {
   }
 
  protected:
-  // Makes entries for 'keys_' and loads their content. Elements of
-  // 'keys_' that are already loaded or loading are expected to be left
-  // out. The returned pins are expected to be exclusive with data
-  // loaded. The caller will set them to shared state on success. If
-  // loadData() throws, the pins it may have made will be destructed in
-  // their exclusive state so that they do not become visible to other
-  // users of the cache.
-  virtual std::vector<CachePin> loadData(bool isPrefetch) = 0;
+  // Makes entries for 'keys_' and loads their content. Elements of 'keys_' that
+  // are already loaded or loading are expected to be left out. The returned
+  // pins are expected to be exclusive with data loaded. The caller will set
+  // them to shared state on success. If loadData() throws, the pins it may have
+  // made will be destructed in their exclusive state so that they do not become
+  // visible to other users of the cache.
+  virtual std::vector<CachePin> loadData(bool prefetch) = 0;
 
   // Sets a final state and resumes waiting threads.
   void setEndState(State endState);
@@ -465,53 +482,72 @@ class CoalescedLoad {
   std::vector<int32_t> sizes_;
 };
 
-// Struct for CacheShard stats. Stats from all shards are added into
-// this struct to provide a snapshot of state.
+/// Struct for CacheShard stats. Stats from all shards are added into
+/// this struct to provide a snapshot of state.
 struct CacheStats {
-  // Total size in 'tinyData_'
+  /// ============= Snapshot stats =============
+
+  /// Total size in 'tinyData_'
   int64_t tinySize{0};
-  // Total size in 'data_'
+  /// Total size in 'data_'
   int64_t largeSize{0};
-  // Unused capacity in 'tinyData_'.
+  /// Unused capacity in 'tinyData_'.
   int64_t tinyPadding{0};
-  // Unused capacity in 'data_'.
+  /// Unused capacity in 'data_'.
   int64_t largePadding{0};
-  // Total number of entries.
+  /// Total number of entries.
   int32_t numEntries{0};
-  // Number of entries that do not cache anything.
+  /// Number of entries that do not cache anything.
   int32_t numEmptyEntries{0};
-  // Number of entries pinned for shared access.
+  /// Number of entries pinned for shared access.
   int32_t numShared{0};
-  // Number of entries pinned for exclusive access.
+  /// Number of entries pinned for exclusive access.
   int32_t numExclusive{0};
-  // Number of entries that are being or have been prefetched but have not been
-  // hit.
+  /// Number of entries that are being or have been prefetched but have not been
+  /// hit.
   int32_t numPrefetch{0};
-  // Total size of entries in prefetch state.
+  /// Total size of entries in prefetch state.
   int64_t prefetchBytes{0};
-  // Number of hits (saved IO). The first hit to a prefetched entry does not
-  // count.
+  /// Total size of shared/exclusive pinned entries.
+  int64_t sharedPinnedBytes{0};
+  int64_t exclusivePinnedBytes{0};
+
+  /// ============= Cumulative stats =============
+
+  /// Number of hits (saved IO). The first hit to a prefetched entry does not
+  /// count.
   int64_t numHit{0};
-  // Sum of sizes of entries counted in 'numHit'.
+  /// Sum of sizes of entries counted in 'numHit'.
   int64_t hitBytes{0};
-  // Number of new entries created.
+  /// Number of new entries created.
   int64_t numNew{0};
-  // Number of times a valid entry was removed in order to make space.
+  /// Number of times a valid entry was removed in order to make space.
   int64_t numEvict{0};
-  // Number of entries considered for evicting.
+  /// Number of times a valid entry was removed in order to make space but has
+  /// not been saved to SSD yet.
+  int64_t numSavableEvict{0};
+  /// Number of entries considered for evicting.
   int64_t numEvictChecks{0};
-  // Number of times a user waited for an entry to transit from exclusive to
-  // shared mode.
+  /// Number of times a user waited for an entry to transit from exclusive to
+  /// shared mode.
   int64_t numWaitExclusive{0};
-  // Cumulative clocks spent in allocating or freeing memory for backing cache
-  // entries.
+  /// Total number of entries that are aged out and beyond TTL.
+  int64_t numAgedOut{0};
+  /// Total number of entries that are stale because of cache request size
+  /// mismatch.
+  int64_t numStales{0};
+  /// Cumulative clocks spent in allocating or freeing memory for backing cache
+  /// entries.
   uint64_t allocClocks{0};
-  // Sum of scores of evicted entries. This serves to infer an average
-  // lifetime for entries in cache.
+  /// Sum of scores of evicted entries. This serves to infer an average
+  /// lifetime for entries in cache.
   int64_t sumEvictScore{0};
 
+  /// Ssd cache stats that include both snapshot and cumulative stats.
   std::shared_ptr<SsdCacheStats> ssdStats = nullptr;
 
+  CacheStats operator-(const CacheStats& other) const;
+
   std::string toString() const;
 };
 
@@ -521,7 +557,8 @@ struct CacheStats {
 /// and other housekeeping.
 class CacheShard {
  public:
-  explicit CacheShard(AsyncDataCache* cache) : cache_(cache) {}
+  CacheShard(AsyncDataCache* cache, double maxWriteRatio)
+      : cache_(cache), maxWriteRatio_(maxWriteRatio) {}
 
   /// See AsyncDataCache::findOrCreate.
   CachePin findOrCreate(
@@ -529,6 +566,9 @@ class CacheShard {
       uint64_t size,
       folly::SemiFuture<bool>* readyFuture);
 
+  /// Marks the cache entry with given cache 'key' as immediate evictable.
+  void makeEvictable(RawFileCacheKey key);
+
   /// Returns true if there is an entry for 'key'. Updates access time.
   bool exists(RawFileCacheKey key) const;
 
@@ -544,39 +584,51 @@ class CacheShard {
   /// graceful shutdown. The shard will no longer be valid after this call.
   void shutdown();
 
-  // removes 'bytesToFree' worth of entries or as many entries as are
-  // not pinned. This favors first removing older and less frequently
-  // used entries. If 'evictAllUnpinned' is true, anything that is
-  // not pinned is evicted at first sight. This is for out of memory
-  // emergencies. If 'pagesToAcquire' is set, up to this amount is added to
-  // 'allocation'. A smaller amount can be added if not enough evictable data is
-  // found.
-  void evict(
+  /// Removes 'bytesToFree' worth of entries or as many entries as are not
+  /// pinned. This favors first removing older and less frequently used entries.
+  /// If 'evictAllUnpinned' is true, anything that is not pinned is evicted at
+  /// first sight. This is for out of memory emergencies. If 'pagesToAcquire' is
+  /// set, up to this amount is added to 'allocation'. A smaller amount can be
+  /// added if not enough evictable data is found. The function returns the
+  /// total evicted bytes.
+  uint64_t evict(
       uint64_t bytesToFree,
       bool evictAllUnpinned,
-      int32_t pagesToAcquire,
+      memory::MachinePageCount pagesToAcquire,
       memory::Allocation& acquiredAllocation);
 
-  // Removes 'entry' from 'this'. Removes a possible promise from the entry
-  // inside the shard mutex and returns it so that it can be realized outside of
-  // the mutex.
+  /// Removes 'entry' from 'this'. Removes a possible promise from the entry
+  /// inside the shard mutex and returns it so that it can be realized outside
+  /// of the mutex.
   std::unique_ptr<folly::SharedPromise<bool>> removeEntry(
       AsyncDataCacheEntry* entry);
 
-  // Adds the stats of 'this' to 'stats'.
+  /// Adds the stats of 'this' to 'stats'.
   void updateStats(CacheStats& stats);
 
-  // Appends a batch of non-saved SSD saveable entries in 'this' to
-  // 'pins'. This may have to be called several times since this keeps
-  // limits on the batch to write at one time. The saveable entries
-  // are pinned for read. 'pins' should be written or dropped before
-  // calling this a second time.
-  void appendSsdSaveable(std::vector<CachePin>& pins);
+  /// Appends a batch of non-saved SSD savable entries in 'this' to 'pins'. This
+  /// may have to be called several times since this keeps limits on the batch
+  /// to write at one time. The savable entries are pinned for read. 'pins'
+  /// should be written or dropped before calling this a second time. If 'all'
+  /// is true, then appends all the non-savable SSD savable entries without
+  /// limitation check. 'saveAll' is set to true for Prestissimo worker
+  /// operation use case.
+  void appendSsdSaveable(bool saveAll, std::vector<CachePin>& pins);
+
+  /// Remove cache entries from this shard for files in the fileNum set
+  /// 'filesToRemove'. If successful, return true, and 'filesRetained' contains
+  /// entries that should not be removed, ex., in exclusive mode or in shared
+  /// mode. Otherwise, return false and 'filesRetained' could be ignored.
+  bool removeFileEntries(
+      const folly::F14FastSet<uint64_t>& filesToRemove,
+      folly::F14FastSet<uint64_t>& filesRetained);
 
   auto& allocClocks() {
     return allocClocks_;
   }
 
+  std::vector<AsyncDataCacheEntry*> testingCacheEntries() const;
+
  private:
   static constexpr uint32_t kMaxFreeEntries = 1 << 10;
   static constexpr int32_t kNoThreshold = std::numeric_limits<int32_t>::max();
@@ -598,6 +650,7 @@ class CacheShard {
   void tryAddFreeEntry(std::unique_ptr<AsyncDataCacheEntry>&& entry);
 
   AsyncDataCache* const cache_;
+  const double maxWriteRatio_;
 
   mutable std::mutex mutex_;
   folly::F14FastMap<RawFileCacheKey, AsyncDataCacheEntry*> entryMap_;
@@ -617,27 +670,66 @@ class CacheShard {
   int32_t evictionThreshold_{kNoThreshold};
   // Cumulative count of cache hits.
   uint64_t numHit_{0};
-  // Sum of bytes in cache hits.
+  // Cumulative Sum of bytes in cache hits.
   uint64_t hitBytes_{0};
   // Cumulative count of hits on entries held in exclusive mode.
   uint64_t numWaitExclusive_{0};
   // Cumulative count of new entry creation.
   uint64_t numNew_{0};
-  // Count of entries evicted.
+  // Cumulative count of entries evicted.
   uint64_t numEvict_{0};
-  // Count of entries considered for eviction. This divided by
+  // Cumulative count of evicted entries which has not been saved to SSD yet.
+  uint64_t numSavableEvict_{0};
+  // Cumulative count of entries considered for eviction. This divided by
   // 'numEvict_' measured efficiency of eviction.
   uint64_t numEvictChecks_{0};
-  // Sum of evict scores. This divided by 'numEvict_' correlates to
+  // Cumulative count of entries aged out due to TTL.
+  uint64_t numAgedOut_{0};
+  // Cumulative count of stale entries because of cache request size mismatch.
+  uint64_t numStales_{0};
+  // Cumulative sum of evict scores. This divided by 'numEvict_' correlates to
   // time data stays in cache.
   uint64_t sumEvictScore_{0};
-  // Tracker of time spent in allocating/freeing MemoryAllocator space
-  // for backing cached data.
+  // Tracker of cumulative time spent in allocating/freeing MemoryAllocator
+  // space for backing cached data.
   std::atomic<uint64_t> allocClocks_{0};
 };
 
 class AsyncDataCache : public memory::Cache {
  public:
+  struct Options {
+    Options(
+        double _maxWriteRatio = 0.7,
+        double _ssdSavableRatio = 0.125,
+        int32_t _minSsdSavableBytes = 1 << 24)
+        : maxWriteRatio(_maxWriteRatio),
+          ssdSavableRatio(_ssdSavableRatio),
+          minSsdSavableBytes(_minSsdSavableBytes){};
+
+    /// The max ratio of the number of in-memory cache entries being written to
+    /// SSD cache over the total number of cache entries. This is to control SSD
+    /// cache write rate, and once the ratio exceeds this threshold, then we
+    /// stop writing to SSD cache.
+    double maxWriteRatio;
+
+    /// The min ratio of SSD savable (in-memory) cache space over the total
+    /// cache space. Once the ratio exceeds this limit, we start writing SSD
+    /// savable cache entries into SSD cache.
+    double ssdSavableRatio;
+
+    /// Min SSD savable (in-memory) cache space to start writing SSD savable
+    /// cache entries into SSD cache.
+    ///
+    /// NOTE: we only write to SSD cache when both above conditions satisfy. The
+    /// default is 16MB.
+    int32_t minSsdSavableBytes;
+  };
+
+  AsyncDataCache(
+      const Options& options,
+      memory::MemoryAllocator* allocator,
+      std::unique_ptr<SsdCache> ssdCache = nullptr);
+
   AsyncDataCache(
       memory::MemoryAllocator* allocator,
       std::unique_ptr<SsdCache> ssdCache = nullptr);
@@ -646,7 +738,8 @@ class AsyncDataCache : public memory::Cache {
 
   static std::shared_ptr<AsyncDataCache> create(
       memory::MemoryAllocator* allocator,
-      std::unique_ptr<SsdCache> ssdCache = nullptr);
+      std::unique_ptr<SsdCache> ssdCache = nullptr,
+      const AsyncDataCache::Options& = {});
 
   static AsyncDataCache* getInstance();
 
@@ -667,6 +760,8 @@ class AsyncDataCache : public memory::Cache {
       memory::MachinePageCount numPages,
       std::function<bool(memory::Allocation& allocation)> allocate) override;
 
+  uint64_t shrink(uint64_t targetBytes) override;
+
   memory::MemoryAllocator* allocator() const override {
     return allocator_;
   }
@@ -687,12 +782,19 @@ class AsyncDataCache : public memory::Cache {
       uint64_t size,
       folly::SemiFuture<bool>* waitFuture = nullptr);
 
+  /// Marks the cache entry with given cache 'key' as immediate evictable.
+  void makeEvictable(RawFileCacheKey key);
+
   /// Returns true if there is an entry for 'key'. Updates access time.
   bool exists(RawFileCacheKey key) const;
 
-  CacheStats refreshStats() const;
+  /// Returns snapshot of the aggregated stats from all shards and the stats of
+  /// SSD cache if used.
+  virtual CacheStats refreshStats() const;
 
-  std::string toString() const;
+  /// If 'details' is true, returns the stats of the backing memory allocator
+  /// and ssd cache. Otherwise, only returns the cache stats.
+  std::string toString(bool details = true) const;
 
   memory::MachinePageCount incrementCachedPages(int64_t pages) {
     // The counter is unsigned and the increment is signed.
@@ -729,16 +831,15 @@ class AsyncDataCache : public memory::Cache {
     return verifyHook_;
   }
 
-  // Looks up a pin for each in 'keys' and skips all loading or
-  // loaded pins. Calls processPin for each exclusive
-  // pin. processPin must move its argument if it wants to use it
-  // afterwards. sizeFunc(i) returns the size of the ith item in
-  // 'keys'.
+  /// Looks up a pin for each in 'keys' and skips all loading or loaded pins.
+  /// Calls processPin for each exclusive pin. processPin must move its argument
+  /// if it wants to use it afterwards. sizeFunc(i) returns the size of the ith
+  /// item in 'keys'.
   template <typename SizeFunc, typename ProcessPin>
   void makePins(
       const std::vector<RawFileCacheKey>& keys,
-      SizeFunc sizeFunc,
-      ProcessPin processPin) {
+      const SizeFunc& sizeFunc,
+      const ProcessPin& processPin) {
     for (auto i = 0; i < keys.size(); ++i) {
       auto pin = findOrCreate(keys[i], sizeFunc(i), nullptr);
       if (pin.empty() || pin.checkedEntry()->isShared()) {
@@ -748,16 +849,37 @@ class AsyncDataCache : public memory::Cache {
     }
   }
 
-  // Drops all unpinned entries. Pins stay valid.
-  void clear();
-
-  // Saves all entries with 'ssdSaveable_' to 'ssdCache_'.
-  void saveToSsd();
+  /// Saves entries in 'ssdSaveable_' to 'ssdCache_'. If 'saveAll' is true, then
+  /// write them all in 'ssdSaveable_'.
+  void saveToSsd(bool saveAll = false);
 
   tsan_atomic<int32_t>& numSkippedSaves() {
     return numSkippedSaves_;
   }
 
+  /// Remove cache entries from all shards for files in the fileNum set
+  /// 'filesToRemove'. If successful, return true, and 'filesRetained' contains
+  /// entries that should not be removed, ex., in exclusive mode or in shared
+  /// mode. Otherwise, return false and 'filesRetained' could be ignored.
+  bool removeFileEntries(
+      const folly::F14FastSet<uint64_t>& filesToRemove,
+      folly::F14FastSet<uint64_t>& filesRetained);
+
+  /// Drops all unpinned entries. Pins stay valid.
+  ///
+  /// NOTE: it is used by testing and Prestissimo server operation.
+  void clear();
+
+  std::vector<AsyncDataCacheEntry*> testingCacheEntries() const;
+
+  uint64_t testingSsdSavable() const {
+    return ssdSaveable_;
+  }
+
+  int32_t testingNumShards() const {
+    return shards_.size();
+  }
+
  private:
   static constexpr int32_t kNumShards = 4; // Must be power of 2.
   static constexpr int32_t kShardMask = kNumShards - 1;
@@ -772,6 +894,7 @@ class AsyncDataCache : public memory::Cache {
   // Waits a pseudorandom delay times 'counter'.
   void backoff(int32_t counter);
 
+  const Options opts_;
   memory::MemoryAllocator* const allocator_;
   std::unique_ptr<SsdCache> ssdCache_;
   std::vector<std::unique_ptr<CacheShard>> shards_;
@@ -808,9 +931,8 @@ class AsyncDataCache : public memory::Cache {
   std::atomic<int32_t> numThreadsInAllocate_{0};
 };
 
-// Samples a set of values T from 'numSamples' calls of
-// 'iter'. Returns the value where 'percent' of the samples are less than the
-// returned value.
+/// Samples a set of values T from 'numSamples' calls of 'iter'. Returns the
+/// value where 'percent' of the samples are less than the returned value.
 template <typename T, typename Next>
 T percentile(Next next, int32_t numSamples, int percent) {
   std::vector<T> values;
@@ -822,24 +944,22 @@ T percentile(Next next, int32_t numSamples, int percent) {
   return values.empty() ? 0 : values[(values.size() * percent) / 100];
 }
 
-// Utility function for loading multiple pins with coalesced
-// IO. 'pins' is a vector of CachePins to fill. 'maxGap' is the
-// largest allowed distance in bytes between the end of one entry and
-// the start of the next. If the gap is larger or the next is before
-// the end of the previous, the entries will be fetched separately.
-//
-//'offsetFunc' returns the starting offset of the data in the
-// file given a pin and the pin's index in 'pins'. The pins are expected to be
-// sorted by this offset. 'readFunc' reads from the appropriate media. It gets
-// the 'pins' and the index of the first pin included in the read and the
-// index of the first pin not included. It gets the starting offset of the
-// read and a vector of memory ranges to fill by ReadFile::preadv or a similar
-// function.
-// The caller is responsible for calling setValid on the pins after a
-// successful read.
-//
-// Returns the number of distinct IOs, the number of bytes loaded into pins
-// and the number of extra bytes read.
+/// Utility function for loading multiple pins with coalesced IO. 'pins' is a
+/// vector of CachePins to fill. 'maxGap' is the largest allowed distance in
+/// bytes between the end of one entry and the start of the next. If the gap is
+/// larger or the next is before the end of the previous, the entries will be
+/// fetched separately.
+///
+/// 'offsetFunc' returns the starting offset of the data in the file given a pin
+/// and the pin's index in 'pins'. The pins are expected to be sorted by this
+/// offset. 'readFunc' reads from the appropriate media. It gets the 'pins' and
+/// the index of the first pin included in the read and the index of the first
+/// pin not included. It gets the starting offset of the read and a vector of
+/// memory ranges to fill by ReadFile::preadv or a similar function. The caller
+/// is responsible for calling setValid on the pins after a successful read.
+///
+/// Returns the number of distinct IOs, the number of bytes loaded into pins
+/// and the number of extra bytes read.
 CoalesceIoStats readPins(
     const std::vector<CachePin>& pins,
     int32_t maxGap,
@@ -859,7 +979,7 @@ struct fmt::formatter<facebook::velox::cache::CoalescedLoad::State>
     : formatter<int> {
   auto format(
       facebook::velox::cache::CoalescedLoad::State s,
-      format_context& ctx) {
+      format_context& ctx) const {
     return formatter<int>::format(static_cast<int>(s), ctx);
   }
 };
diff --git a/velox/common/caching/CMakeLists.txt b/velox/common/caching/CMakeLists.txt
index f30696ac77e58..76d7694b0a805 100644
--- a/velox/common/caching/CMakeLists.txt
+++ b/velox/common/caching/CMakeLists.txt
@@ -12,21 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(
   velox_caching
-  FileIds.cpp
-  StringIdMap.cpp
   AsyncDataCache.cpp
+  CacheTTLController.cpp
+  FileIds.cpp
   ScanTracker.cpp
   SsdCache.cpp
   SsdFile.cpp
-  SsdFileTracker.cpp)
-target_link_libraries(
+  SsdFileTracker.cpp
+  StringIdMap.cpp)
+velox_link_libraries(
   velox_caching
   PUBLIC velox_common_base
          velox_exception
          velox_file
          velox_memory
+         velox_process
+         velox_time
          Folly::folly
          fmt::fmt
          gflags::gflags
diff --git a/velox/common/caching/CacheTTLController.cpp b/velox/common/caching/CacheTTLController.cpp
new file mode 100644
index 0000000000000..1a731420c5191
--- /dev/null
+++ b/velox/common/caching/CacheTTLController.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/caching/CacheTTLController.h"
+
+#include "velox/common/caching/AsyncDataCache.h"
+
+namespace facebook::velox::cache {
+
+std::unique_ptr<CacheTTLController> CacheTTLController::instance_ = nullptr;
+
+bool CacheTTLController::addOpenFileInfo(
+    uint64_t fileNum,
+    int64_t openTimeSec) {
+  auto lockedFileMap = fileInfoMap_.wlock();
+  auto it = lockedFileMap->find(fileNum);
+  if (it == lockedFileMap->end() || it->second.removeInProgress) {
+    lockedFileMap->insert_or_assign(fileNum, RawFileInfo{openTimeSec, false});
+    return true;
+  }
+  return false;
+}
+
+CacheAgeStats CacheTTLController::getCacheAgeStats() const {
+  auto lockedFileMap = fileInfoMap_.rlock();
+
+  if (lockedFileMap->empty()) {
+    return CacheAgeStats{.maxAgeSecs = 0};
+  }
+
+  // Use the oldest file open time to calculate the max possible age of cache
+  // entries loaded from the files.
+  int64_t minOpenTime = std::numeric_limits<int64_t>::max();
+  for (auto it = lockedFileMap->cbegin(); it != lockedFileMap->cend(); it++) {
+    minOpenTime = std::min<int64_t>(minOpenTime, it->second.openTimeSec);
+  }
+
+  int64_t maxAge = getCurrentTimeSec() - minOpenTime;
+  return CacheAgeStats{.maxAgeSecs = std::max<int64_t>(maxAge, 0)};
+}
+
+void CacheTTLController::applyTTL(int64_t ttlSecs) {
+  int64_t maxOpenTime = getCurrentTimeSec() - ttlSecs;
+
+  folly::F14FastSet<uint64_t> filesToRemove =
+      getAndMarkAgedOutFiles(maxOpenTime);
+  if (filesToRemove.empty()) {
+    LOG(INFO) << "No cache entry is out of TTL " << ttlSecs << ".";
+    return;
+  }
+
+  folly::F14FastSet<uint64_t> filesRetained;
+  bool success = cache_.removeFileEntries(filesToRemove, filesRetained);
+
+  LOG(INFO) << (success ? "Succeeded" : "Failed") << " applying cache TTL of "
+            << ttlSecs << " seconds. Entries from " << filesToRemove.size()
+            << " files are to be removed, while " << filesRetained.size()
+            << " files are retained";
+  if (success) {
+    cleanUp(filesRetained);
+  } else {
+    reset();
+  }
+}
+
+folly::F14FastSet<uint64_t> CacheTTLController::getAndMarkAgedOutFiles(
+    int64_t maxOpenTimeSecs) {
+  auto lockedFileMap = fileInfoMap_.wlock();
+
+  folly::F14FastSet<uint64_t> fileNums;
+
+  for (auto it = lockedFileMap->begin(); it != lockedFileMap->end(); it++) {
+    if (it->second.removeInProgress ||
+        it->second.openTimeSec < maxOpenTimeSecs) {
+      fileNums.insert(it->first);
+      it->second.removeInProgress = true;
+    }
+  }
+
+  return fileNums;
+}
+
+void CacheTTLController::cleanUp(
+    const folly::F14FastSet<uint64_t>& filesToRetain) {
+  fileInfoMap_.withWLock([&](auto& fileMap) {
+    auto it = fileMap.begin();
+    while (it != fileMap.end()) {
+      if (!it->second.removeInProgress) {
+        it++;
+        continue;
+      }
+      if (filesToRetain.count(it->first) > 0) {
+        it->second.removeInProgress = false;
+        it++;
+        continue;
+      }
+      it = fileMap.erase(it);
+    }
+  });
+}
+
+void CacheTTLController::reset() {
+  fileInfoMap_.withWLock([](auto& fileMap) {
+    for (auto& [_, fileInfo] : fileMap) {
+      fileInfo.removeInProgress = false;
+    }
+  });
+}
+
+} // namespace facebook::velox::cache
diff --git a/velox/common/caching/CacheTTLController.h b/velox/common/caching/CacheTTLController.h
new file mode 100644
index 0000000000000..f81e596ed3b02
--- /dev/null
+++ b/velox/common/caching/CacheTTLController.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/time/Timer.h"
+
+#include "folly/Synchronized.h"
+#include "folly/container/F14Map.h"
+#include "folly/container/F14Set.h"
+
+namespace facebook::velox::cache {
+
+class AsyncDataCache;
+
+struct RawFileInfo {
+  int64_t openTimeSec;
+  bool removeInProgress;
+
+  bool operator==(const RawFileInfo& other) {
+    return openTimeSec == other.openTimeSec &&
+        removeInProgress == other.removeInProgress;
+  }
+};
+
+struct CacheAgeStats {
+  // Age in seconds of the oldest opened file loaded to the caches.
+  int64_t maxAgeSecs{0};
+};
+
+/// A process-wide singleton to handle TTL of AsyncDataCache and SsdCache.
+class CacheTTLController {
+ public:
+  /// Create and return a singleton instance of CacheTTLController.
+  static CacheTTLController* create(AsyncDataCache& cache) {
+    if (instance_ == nullptr) {
+      instance_ =
+          std::unique_ptr<CacheTTLController>(new CacheTTLController(cache));
+    }
+    return instance_.get();
+  }
+
+  /// Return the process-wide singleton instance of CacheTTLController if it has
+  /// been created. Otherwise, return nullptr.
+  static CacheTTLController* getInstance() {
+    if (instance_ == nullptr) {
+      return nullptr;
+    }
+    return instance_.get();
+  }
+
+  static void testingClear() {
+    instance_ = nullptr;
+  }
+
+  /// Add file opening info for a file identified by fileNum. Return true if a
+  /// new file entry is inserted, or if the existing file entry is updated
+  /// while cache deletion for the file is in progress. Return false otherwise
+  /// if the existing file entry is not updated.
+  bool addOpenFileInfo(
+      uint64_t fileNum,
+      int64_t openTimeSec = getCurrentTimeSec());
+
+  /// Compute age related stats of the cached files.
+  CacheAgeStats getCacheAgeStats() const;
+
+  void applyTTL(int64_t ttlSecs);
+
+ private:
+  /// A process-wide singleton instance of CacheTTLController.
+  static std::unique_ptr<CacheTTLController> instance_;
+
+ private:
+  // Prevent creating a random instance of CacheTTLController.
+  explicit CacheTTLController(AsyncDataCache& cache) : cache_(cache) {}
+
+  folly::F14FastSet<uint64_t> getAndMarkAgedOutFiles(int64_t maxOpenTimeSecs);
+
+  /// Clean up file entries with removeInProgress true but keep entries for
+  /// fileNums in filesToRetain.
+  void cleanUp(const folly::F14FastSet<uint64_t>& filesToRetain);
+
+  void reset();
+
+  AsyncDataCache& cache_;
+
+  /// A Map of fileNum to RawFileInfo.
+  folly::Synchronized<folly::F14FastMap<uint64_t, RawFileInfo>> fileInfoMap_;
+};
+
+} // namespace facebook::velox::cache
diff --git a/velox/common/caching/CachedFactory.h b/velox/common/caching/CachedFactory.h
index 0e02627d2b6bc..22d266ec6235e 100644
--- a/velox/common/caching/CachedFactory.h
+++ b/velox/common/caching/CachedFactory.h
@@ -31,6 +31,7 @@
 #include <mutex>
 #include <utility>
 
+#include <folly/GLog.h>
 #include <glog/logging.h>
 #include "folly/container/F14Set.h"
 
@@ -39,75 +40,226 @@
 
 namespace facebook::velox {
 
-// CachedFactory provides a thread-safe way of backing a keyed generator
-// (e.g. the key is filename, and the value is the file data) by a cache.
-//
-// Generator should take a single Key argument and return a Value;
-// The Value should be either a value type or should manage its own lifecycle
-// (shared_ptr). If it is not thread-safe it must do its own internal locking.
-template <typename Key, typename Value, typename Generator>
+/// A smart pointer that represents data that may be in a cache and is thus not
+/// owned, or is owned like a unique_ptr. We could also implement this by a
+/// unique_ptr with a custom deleter.
+template <
+    typename Key,
+    typename Value,
+    typename Comparator = std::equal_to<Key>,
+    typename Hash = std::hash<Key>>
+class CachedPtr {
+ public:
+  /// Nullptr case.
+  CachedPtr();
+
+  /// Data is not in cache, ownership taken by *this.
+  explicit CachedPtr(Value* value);
+
+  /// Data is in the provided cache referenced by the given key. The cache is
+  /// not guarded by a mutex.
+  CachedPtr(
+      bool cached,
+      Value* value,
+      SimpleLRUCache<Key, Value, Comparator, Hash>* cache,
+      std::unique_ptr<Key> key);
+
+  /// Same as above, but the cache is guarded by a mutex.
+  CachedPtr(
+      bool cached,
+      Value* value,
+      SimpleLRUCache<Key, Value, Comparator, Hash>* cache,
+      std::unique_ptr<Key> key,
+      std::mutex* cacheMu);
+
+  /// The destructor handles the in-cache and non-in-cache cases appropriately.
+  ~CachedPtr();
+
+  /// Move allowed, copy disallowed. Moving a new value into a non-null
+  /// CachedPtr will clear the previous value.
+  CachedPtr(CachedPtr&&);
+  CachedPtr& operator=(CachedPtr&&);
+  CachedPtr(const CachedPtr&) = delete;
+  CachedPtr& operator=(const CachedPtr&) = delete;
+
+  /// Whether this value is load from cache. If we had to wait for a generation
+  /// (whether the actual generation was done in this thread or another) then
+  /// this is false. Has no effect on this behavior, but may be useful for
+  /// monitoring cache hit rates/etc.
+  bool fromCache() const {
+    return fromCache_;
+  }
+
+  /// Indicates if this value is cached or not.
+  bool cached() const {
+    return cache_ != nullptr;
+  }
+
+  Value* operator->() const {
+    return value_;
+  }
+  Value& operator*() const {
+    return *value_;
+  }
+  Value* get() const {
+    return value_;
+  }
+
+  void testingClear() {
+    clear();
+    key_.reset();
+    value_ = nullptr;
+    cache_ = nullptr;
+    cacheMu_ = nullptr;
+  }
+
+ private:
+  // Delete or release owned value.
+  void clear();
+
+  bool fromCache_;
+  std::unique_ptr<Key> key_;
+  Value* value_;
+  std::mutex* cacheMu_;
+  // If 'value_' is in cache, 'cache_' and 'key_' will be non-null, and
+  // 'cacheMu_' may be non-null. If cacheMu_ is non-null, we use it to protect
+  // our operations to 'cache_'.
+  SimpleLRUCache<Key, Value, Comparator, Hash>* cache_;
+};
+
+template <typename Value>
+struct DefaultSizer {
+  int64_t operator()(const Value& value) const {
+    return 1;
+  }
+};
+
+/// CachedFactory provides a thread-safe way of backing a keyed generator
+/// (e.g. the key is filename, and the value is the file data) by a cache.
+///
+/// Generator should take a single Key argument and return a unique_ptr<Value>;
+/// If it is not thread-safe it must do its own internal locking.
+/// Sizer takes a Value and returns how much cache space it will occupy. The
+/// DefaultSizer says each value occupies 1 space.
+template <
+    typename Key,
+    typename Value,
+    typename Generator,
+    typename Properties = void,
+    typename Sizer = DefaultSizer<Value>,
+    typename Comparator = std::equal_to<Key>,
+    typename Hash = std::hash<Key>>
 class CachedFactory {
  public:
-  // It is generally expected that most inserts into the cache will succeed,
-  // i.e. the cache is large compared to the size of the elements and the number
-  // of elements that are pinned. Everything should still work if this is not
-  // true, but performance will suffer.
+  /// It is generally expected that most inserts into the cache will succeed,
+  /// i.e. the cache is large compared to the size of the elements and the
+  /// number of elements that are pinned. Everything should still work if this
+  /// is not true, but performance will suffer. If 'cache' is nullptr, this
+  /// means the cache is disabled. 'generator' is invoked directly in 'generate'
+  /// function.
   CachedFactory(
-      std::unique_ptr<SimpleLRUCache<Key, Value>> cache,
+      std::unique_ptr<SimpleLRUCache<Key, Value, Comparator, Hash>> cache,
       std::unique_ptr<Generator> generator)
-      : cache_(std::move(cache)), generator_(std::move(generator)) {}
-
-  // Returns the generator's output on the given key. If the output is
-  // in the cache, returns immediately. Otherwise, blocks until the output
-  // is ready.
-  // The function returns a pair. The boolean in the pair indicates whether a
-  // cache hit or miss. The Value is the generator output for the key if cache
-  // miss, or Value in the cache if cache hit.
-  std::pair<bool, Value> generate(const Key& key);
-
-  // Advanced function taking in a group of keys. Separates those keys into
-  // one's present in the cache (returning CachedPtrs for them) and those not
-  // in the cache. Does NOT call the Generator for any key.
+      : generator_(std::move(generator)), cache_(std::move(cache)) {}
+
+  CachedFactory(std::unique_ptr<Generator> generator)
+      : CachedFactory(nullptr, std::move(generator)) {}
+
+  /// Returns the generator's output on the given key. If the output is in the
+  /// cache, returns immediately. Otherwise, blocks until the output is ready.
+  /// For a given key we will only ever be running the Generator function once.
+  /// E.g., if N threads ask for the same key at once, the generator will be
+  /// fired once and all N will receive a pointer from the cache.
+  ///
+  /// Actually the last sentence is not quite true in the edge case where
+  /// inserts into the cache fail; in that case we will re-run the generator
+  /// repeatedly, handing off the results to one thread at a time until the
+  /// all pending requests are satisfied or a cache insert succeeds. This
+  /// will probably mess with your memory model, so really try to avoid it.
+  CachedPtr<Key, Value, Comparator, Hash> generate(
+      const Key& key,
+      const Properties* properties = nullptr);
+
+  /// Looks up the cache entry of the given key if it exists, otherwise returns
+  /// null.
+  CachedPtr<Key, Value, Comparator, Hash> get(const Key& key);
+
+  /// Advanced function taking in a group of keys. Separates those keys into
+  /// one's present in the cache (returning CachedPtrs for them) and those not
+  /// in the cache. Does NOT call the Generator for any key.
   void retrieveCached(
       const std::vector<Key>& keys,
-      std::vector<std::pair<Key, Value>>* cached,
-      std::vector<Key>* missing);
+      std::vector<std::pair<Key, CachedPtr<Key, Value, Comparator, Hash>>>&
+          cached,
+      std::vector<Key>& missing);
 
-  // Total size of elements cached (NOT the maximum size/limit).
+  /// Total size of elements cached (NOT the maximum size/limit).
   int64_t currentSize() const {
+    if (cache_ == nullptr) {
+      return 0;
+    }
     return cache_->currentSize();
   }
 
-  // The maximum size of the underlying cache.
+  /// The maximum size of the underlying cache.
   int64_t maxSize() const {
+    if (cache_ == nullptr) {
+      return 0;
+    }
     return cache_->maxSize();
   }
 
   SimpleLRUCacheStats cacheStats() {
+    if (cache_ == nullptr) {
+      return {};
+    }
     std::lock_guard l(cacheMu_);
-    return cache_->getStats();
+    return cache_->stats();
   }
 
   // Clear the cache and return the current cache status
   SimpleLRUCacheStats clearCache() {
+    if (cache_ == nullptr) {
+      return {};
+    }
     std::lock_guard l(cacheMu_);
-    cache_->clear();
-    return cache_->getStats();
+    cache_->free(cache_->maxSize());
+    return cache_->stats();
   }
 
-  // Move allowed, copy disallowed.
+  /// Move allowed, copy disallowed.
   CachedFactory(CachedFactory&&) = default;
   CachedFactory& operator=(CachedFactory&&) = default;
   CachedFactory(const CachedFactory&) = delete;
   CachedFactory& operator=(const CachedFactory&) = delete;
 
  private:
-  std::unique_ptr<SimpleLRUCache<Key, Value>> cache_;
+  void removePending(const Key& key) {
+    std::lock_guard<std::mutex> pendingLock(pendingMu_);
+    pending_.erase(key);
+  }
+
+  bool addCache(const Key& key, Value* value, int64_t size) {
+    std::lock_guard<std::mutex> cacheLock(cacheMu_);
+    return cache_->addPinned(key, value, size);
+  }
+
+  Value* getCache(const Key& key) {
+    std::lock_guard<std::mutex> cacheLock(cacheMu_);
+    return getCacheLocked(key);
+  }
+
+  Value* getCacheLocked(const Key& key) {
+    return cache_->get(key);
+  }
+
   std::unique_ptr<Generator> generator_;
-  folly::F14FastSet<Key> pending_;
 
   std::mutex cacheMu_;
+  std::unique_ptr<SimpleLRUCache<Key, Value, Comparator, Hash>> cache_;
+
   std::mutex pendingMu_;
+  folly::F14FastSet<Key, Hash, Comparator> pending_;
   std::condition_variable pendingCv_;
 };
 
@@ -115,74 +267,227 @@ class CachedFactory {
 // End of public API. Implementation follows.
 //
 
-template <typename Key, typename Value, typename Generator>
-std::pair<bool, Value> CachedFactory<Key, Value, Generator>::generate(
-    const Key& key) {
+template <typename Key, typename Value, typename Comparator, typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>::CachedPtr()
+    : fromCache_(false),
+      key_(nullptr),
+      value_(nullptr),
+      cacheMu_(nullptr),
+      cache_(nullptr) {}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>::CachedPtr(Value* value)
+    : fromCache_(false),
+      key_(nullptr),
+      value_(value),
+      cacheMu_(nullptr),
+      cache_(nullptr) {}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>::CachedPtr(
+    bool cached,
+    Value* value,
+    SimpleLRUCache<Key, Value, Comparator, Hash>* cache,
+    std::unique_ptr<Key> key)
+    : fromCache_(cached),
+      key_(std::move(key)),
+      value_(value),
+      cacheMu_(nullptr),
+      cache_(cache) {}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>::CachedPtr(
+    bool cached,
+    Value* value,
+    SimpleLRUCache<Key, Value, Comparator, Hash>* cache,
+    std::unique_ptr<Key> key,
+    std::mutex* cacheMu)
+    : fromCache_(cached),
+      key_(std::move(key)),
+      value_(value),
+      cacheMu_(cacheMu),
+      cache_(cache) {}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>::~CachedPtr() {
+  clear();
+}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>::CachedPtr(CachedPtr&& other) {
+  fromCache_ = other.fromCache_;
+  value_ = other.value_;
+  key_ = std::move(other.key_);
+  cache_ = other.cache_;
+  cacheMu_ = other.cacheMu_;
+  other.value_ = nullptr;
+}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>&
+CachedPtr<Key, Value, Comparator, Hash>::operator=(CachedPtr&& other) {
+  clear();
+  fromCache_ = other.fromCache_;
+  value_ = other.value_;
+  key_ = std::move(other.key_);
+  cache_ = other.cache_;
+  cacheMu_ = other.cacheMu_;
+  other.value_ = nullptr;
+  return *this;
+}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+void CachedPtr<Key, Value, Comparator, Hash>::clear() {
+  if (value_ == nullptr) {
+    return;
+  }
+  if (cache_ == nullptr) {
+    delete value_;
+    return;
+  }
+  if (cacheMu_ != nullptr) {
+    std::lock_guard<std::mutex> l(*cacheMu_);
+    cache_->release(*key_);
+  } else {
+    cache_->release(*key_);
+  }
+}
+
+template <
+    typename Key,
+    typename Value,
+    typename Generator,
+    typename Properties,
+    typename Sizer,
+    typename Comparator,
+    typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>
+CachedFactory<Key, Value, Generator, Properties, Sizer, Comparator, Hash>::
+    generate(const Key& key, const Properties* properties) {
   process::TraceContext trace("CachedFactory::generate");
-  std::unique_lock<std::mutex> pending_lock(pendingMu_);
+  if (cache_ == nullptr) {
+    return CachedPtr<Key, Value, Comparator, Hash>{
+        /*fromCache=*/false,
+        (*generator_)(key, properties).release(),
+        nullptr,
+        std::make_unique<Key>(key)};
+  }
+
+  std::unique_lock<std::mutex> pendingLock(pendingMu_);
   {
-    std::lock_guard<std::mutex> cache_lock(cacheMu_);
-    auto value = cache_->get(key);
-    if (value) {
-      return std::make_pair(true, value.value());
+    if (Value* value = getCache(key)) {
+      return CachedPtr<Key, Value, Comparator, Hash>(
+          /*fromCache=*/true,
+          value,
+          cache_.get(),
+          std::make_unique<Key>(key),
+          &cacheMu_);
     }
   }
-
   if (pending_.contains(key)) {
-    pendingCv_.wait(pending_lock, [&]() { return !pending_.contains(key); });
+    pendingCv_.wait(pendingLock, [&]() { return !pending_.contains(key); });
     // Will normally hit the cache now.
-    {
-      std::lock_guard<std::mutex> cache_lock(cacheMu_);
-      auto value = cache_->get(key);
-      if (value) {
-        return std::make_pair(true, value.value());
-      }
-    }
-    pending_lock.unlock();
-    return generate(key); // Regenerate in the edge case.
-  } else {
-    pending_.insert(key);
-    pending_lock.unlock();
-    Value generatedValue;
-    // TODO: consider using folly/ScopeGuard here.
-    try {
-      generatedValue = (*generator_)(key);
-    } catch (const std::exception& e) {
-      {
-        std::lock_guard<std::mutex> pending_lock(pendingMu_);
-        pending_.erase(key);
-      }
-      pendingCv_.notify_all();
-      throw;
-    }
-    cacheMu_.lock();
-    cache_->add(key, generatedValue);
-    cacheMu_.unlock();
-
-    // TODO: this code is exception unsafe and can leave pending_ in an
-    // inconsistent state. Eventually this code should move to
-    // folly:synchronized and rewritten with better primitives.
-    {
-      std::lock_guard<std::mutex> pending_lock(pendingMu_);
-      pending_.erase(key);
+    if (Value* value = getCache(key)) {
+      return CachedPtr<Key, Value, Comparator, Hash>(
+          /*fromCache=*/false,
+          value,
+          cache_.get(),
+          std::make_unique<Key>(key),
+          &cacheMu_);
     }
+    pendingLock.unlock();
+    // Regenerates in the edge case.
+    return generate(key, properties);
+  }
+
+  pending_.insert(key);
+  pendingLock.unlock();
+
+  SCOPE_EXIT {
+    removePending(key);
     pendingCv_.notify_all();
-    return std::make_pair(false, generatedValue);
+  };
+
+  std::unique_ptr<Value> generatedValue = (*generator_)(key, properties);
+  const uint64_t valueSize = Sizer()(*generatedValue);
+  Value* rawValue = generatedValue.release();
+  const bool inserted = addCache(key, rawValue, valueSize);
+
+  CachedPtr<Key, Value, Comparator, Hash> result;
+  if (inserted) {
+    result = CachedPtr<Key, Value, Comparator, Hash>(
+        /*fromCache=*/false,
+        rawValue,
+        cache_.get(),
+        std::make_unique<Key>(key),
+        &cacheMu_);
+  } else {
+    FB_LOG_EVERY_MS(WARNING, 60'000) << "Unable to insert into cache!";
+    result = CachedPtr<Key, Value, Comparator, Hash>(rawValue);
   }
+  return result;
 }
 
-template <typename Key, typename Value, typename Generator>
-void CachedFactory<Key, Value, Generator>::retrieveCached(
-    const std::vector<Key>& keys,
-    std::vector<std::pair<Key, Value>>* cached,
-    std::vector<Key>* missing) {
-  std::lock_guard<std::mutex> cache_lock(cacheMu_);
+template <
+    typename Key,
+    typename Value,
+    typename Generator,
+    typename Properties,
+    typename Sizer,
+    typename Comparator,
+    typename Hash>
+CachedPtr<Key, Value, Comparator, Hash>
+CachedFactory<Key, Value, Generator, Properties, Sizer, Comparator, Hash>::get(
+    const Key& key) {
+  if (cache_ == nullptr) {
+    return {};
+  }
+  std::lock_guard<std::mutex> l(cacheMu_);
+  Value* value = getCacheLocked(key);
+  if (value == nullptr) {
+    return {};
+  }
+  return CachedPtr<Key, Value, Comparator, Hash>(
+      /*fromCache=*/true,
+      value,
+      cache_.get(),
+      std::make_unique<Key>(key),
+      &cacheMu_);
+}
+
+template <
+    typename Key,
+    typename Value,
+    typename Generator,
+    typename Properties,
+    typename Sizer,
+    typename Comparator,
+    typename Hash>
+void CachedFactory<Key, Value, Generator, Properties, Sizer, Comparator, Hash>::
+    retrieveCached(
+        const std::vector<Key>& keys,
+        std::vector<std::pair<Key, CachedPtr<Key, Value, Comparator, Hash>>>&
+            cached,
+        std::vector<Key>& missing) {
+  if (cache_ == nullptr) {
+    missing.insert(missing.end(), keys.begin(), keys.end());
+    return;
+  }
+
+  std::lock_guard<std::mutex> l(cacheMu_);
   for (const Key& key : keys) {
-    auto value = cache_->get(key);
-    if (value) {
-      cached->emplace_back(key, value.value());
+    Value* value = getCacheLocked(key);
+    if (value != nullptr) {
+      cached.emplace_back(
+          key,
+          CachedPtr<Key, Value, Comparator, Hash>(
+              /*fromCache=*/true,
+              value,
+              cache_.get(),
+              std::make_unique<Key>(key),
+              &cacheMu_));
     } else {
-      missing->push_back(key);
+      missing.push_back(key);
     }
   }
 }
diff --git a/velox/common/caching/ScanTracker.cpp b/velox/common/caching/ScanTracker.cpp
index 3d9410c951101..9bae234d87b0d 100644
--- a/velox/common/caching/ScanTracker.cpp
+++ b/velox/common/caching/ScanTracker.cpp
@@ -21,8 +21,8 @@
 
 namespace facebook::velox::cache {
 
-// Marks that 'bytes' worth of data may be accessed in the
-// future. See TrackingData for meaning of quantum.
+// Marks that 'bytes' worth of data may be accessed in the future. See
+// TrackingData for meaning of quantum.
 void ScanTracker::recordReference(
     const TrackingId id,
     uint64_t bytes,
@@ -52,8 +52,9 @@ void ScanTracker::recordRead(
 std::string ScanTracker::toString() const {
   std::stringstream out;
   out << "ScanTracker for " << id_ << std::endl;
-  for (auto& pair : data_) {
-    int pct = 100 * pair.second.readBytes / (1 + pair.second.referencedBytes);
+  for (const auto& pair : data_) {
+    const int pct =
+        100 * pair.second.readBytes / (1 + pair.second.referencedBytes);
     out << pair.first.id() << ": " << pct << "% " << pair.second.readBytes
         << "/" << pair.second.numReads << std::endl;
   }
diff --git a/velox/common/caching/ScanTracker.h b/velox/common/caching/ScanTracker.h
index 8103339f76655..4281175e2b8f1 100644
--- a/velox/common/caching/ScanTracker.h
+++ b/velox/common/caching/ScanTracker.h
@@ -25,11 +25,11 @@
 
 namespace facebook::velox::cache {
 
-// Represents a stream in a table, e.g. nulls/lengths/data of a
-// particular column. Column-level access tracking uses this to
-// identify the column within a file or partition. The low 5 bits are
-// the stream kind, e.g. nulls, data etc. The high 27 bits are the node
-// number in the file schema tree, i.e. the column.
+/// Represents a stream in a table, e.g. nulls/lengths/data of a particular
+/// column. Column-level access tracking uses this to identify the column within
+/// a file or partition. The low 5 bits are the stream kind, e.g. nulls, data
+/// etc. The high 27 bits are the node number in the file schema tree, i.e. the
+/// column.
 class TrackingId {
  public:
   TrackingId() : id_(-1) {}
@@ -71,22 +71,22 @@ namespace facebook::velox::cache {
 
 class FileGroupStats;
 
-// Records references and actual uses of a stream.
+/// Records references and actual uses of a stream.
 struct TrackingData {
   int64_t referencedBytes{};
   int64_t readBytes{};
   int32_t numReferences{};
   int32_t numReads{};
 
-  // Marks that 'bytes' worth of data in the tracked object has been
-  // referenced and may later be accessed. If 'bytes' is larger than a single
-  // 'oadQuantum', the reference counts for as many accesses as are needed to
-  // cover 'bytes'. When reading a large object, we will get a read per quantum.
-  // So then if the referenced and read counts match, we know that the object is
-  // densely read.
+  /// Marks that 'bytes' worth of data in the tracked object has been referenced
+  /// and may later be accessed. If 'bytes' is larger than a single
+  /// 'loadQuantum', the reference counts for as many accesses as are needed to
+  /// cover 'bytes'. When reading a large object, we will get a read per
+  /// quantum. So then if the referenced and read counts match, we know that the
+  /// object is densely read.
   void incrementReference(uint64_t bytes, int32_t loadQuantum) {
     referencedBytes += bytes;
-    if (!loadQuantum) {
+    if (loadQuantum == 0) {
       ++numReferences;
     } else {
       numReferences += bits::roundUp(bytes, loadQuantum) / loadQuantum;
@@ -99,29 +99,28 @@ struct TrackingData {
   }
 };
 
-// Tracks column access frequency during execution of a query. A
-// ScanTracker is created at the level of a Task/TableScan, so that
-// all threads of a scan report in the same tracker. The same
-// ScanTracker tracks all reads of all partitions of the scan. The
-// groupId argument identifies the file group (e.g. partition) a
-// tracking event pertains to, since a single ScanTracker can range
-// over multiple partitions.
+/// Tracks column access frequency during execution of a query. A ScanTracker is
+/// created at the level of a Task/TableScan, so that all threads of a scan
+/// report in the same tracker. The same ScanTracker tracks all reads of all
+/// partitions of the scan. The groupId argument identifies the file group (e.g.
+/// partition) a tracking event pertains to, since a single ScanTracker can
+/// range over multiple partitions.
 class ScanTracker {
  public:
-  ScanTracker() : loadQuantum_(1 /*not used*/) {}
+  ScanTracker() : ScanTracker({}, nullptr, 1) {}
 
-  // Constructs a tracker with 'id'. The tracker will be owned by
-  // shared_ptr and will be referenced from a map from id to weak_ptr
-  // to 'this'. 'unregisterer' is supplied so that the destructor can
-  // remove the weak_ptr from the map of pending trackers. 'loadQuantum' is the
-  // largest single IO size for read.
+  /// Constructs a tracker with 'id'. The tracker will be owned by shared_ptr
+  /// and will be referenced from a map from id to weak_ptr to 'this'.
+  /// 'unregisterer' is supplied so that the destructor can remove the weak_ptr
+  /// from the map of pending trackers. 'loadQuantum' is the largest single IO
+  /// size for read.
   ScanTracker(
       std::string_view id,
-      std::function<void(ScanTracker* FOLLY_NONNULL)> unregisterer,
+      std::function<void(ScanTracker*)> unregisterer,
       int32_t loadQuantum,
-      FileGroupStats* FOLLY_NULLABLE fileGroupStats = nullptr)
+      FileGroupStats* fileGroupStats = nullptr)
       : id_(id),
-        unregisterer_(unregisterer),
+        unregisterer_(std::move(unregisterer)),
         loadQuantum_(loadQuantum),
         fileGroupStats_(fileGroupStats) {}
 
@@ -131,33 +130,33 @@ class ScanTracker {
     }
   }
 
-  // Records that a scan references 'bytes' bytes of the stream given
-  // by 'id'. This is called when preparing to read a stripe.
+  /// Records that a scan references 'bytes' bytes of the stream given by 'id'.
+  /// This is called when preparing to read a stripe.
   void recordReference(
       const TrackingId id,
       uint64_t bytes,
       uint64_t fileId,
       uint64_t groupId);
 
-  // Records that 'bytes' bytes have actually been read from the stream
-  // given by 'id'.
+  /// Records that 'bytes' bytes have actually been read from the stream given
+  /// by 'id'.
   void recordRead(
       const TrackingId id,
       uint64_t bytes,
       uint64_t fileId,
       uint64_t groupId);
 
-  // True if 'trackingId' is read at least  'minReadPct' % of the time.
+  /// True if 'trackingId' is read at least 'minReadPct' % of the time.
   bool shouldPrefetch(TrackingId id, int32_t minReadPct) {
     return readPct(id) >= minReadPct;
   }
 
-  // Returns the percentage of referenced columns that are actually read. 100%
-  // if no data.
+  /// Returns the percentage of referenced columns that are actually read. 100%
+  /// if no data.
   int32_t readPct(TrackingId id) {
     std::lock_guard<std::mutex> l(mutex_);
     const auto& data = data_[id];
-    if (!data.numReferences) {
+    if (data.numReferences == 0) {
       return 100;
     }
     return (100 * data.numReads) / data.numReferences;
@@ -172,25 +171,25 @@ class ScanTracker {
     return id_;
   }
 
-  FileGroupStats* FOLLY_NULLABLE fileGroupStats() const {
+  FileGroupStats* fileGroupStats() const {
     return fileGroupStats_;
   }
 
   std::string toString() const;
 
  private:
-  std::mutex mutex_;
   // Id of query + scan operator to track.
   const std::string id_;
-  std::function<void(ScanTracker* FOLLY_NONNULL)> unregisterer_;
+  const std::function<void(ScanTracker*)> unregisterer_{nullptr};
+  // Maximum size of a read. 10MB would count as two references if the quantum
+  // were 8MB. At the same time this would count as a single 10MB reference for
+  // 'fileGroupStats_'. 0 means the read size is unlimited.
+  const int32_t loadQuantum_;
+  FileGroupStats* const fileGroupStats_;
+
+  std::mutex mutex_;
   folly::F14FastMap<TrackingId, TrackingData> data_;
   TrackingData sum_;
-  // Maximum size of a read. 10MB would count as two references
-  // if the quantum were 8MB. At the same time this would count as a
-  // single 10MB reference for 'fileGroupStats_'. 0 means the read
-  // size is unlimited.
-  const int32_t loadQuantum_;
-  FileGroupStats* FOLLY_NULLABLE fileGroupStats_;
 };
 
 } // namespace facebook::velox::cache
diff --git a/velox/common/caching/SimpleLRUCache.h b/velox/common/caching/SimpleLRUCache.h
index cd420995f6413..5812a30c99a91 100644
--- a/velox/common/caching/SimpleLRUCache.h
+++ b/velox/common/caching/SimpleLRUCache.h
@@ -18,147 +18,379 @@
 #include <cstdint>
 #include <functional>
 #include <list>
-#include <optional>
 
 #include <glog/logging.h>
-#include "folly/container/EvictingCacheMap.h"
+#include "folly/IntrusiveList.h"
+#include "folly/container/F14Map.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/time/Timer.h"
 
 namespace facebook::velox {
 
 struct SimpleLRUCacheStats {
   SimpleLRUCacheStats(
       size_t _maxSize,
+      size_t _expireDurationMs,
       size_t _curSize,
+      size_t _pinnedSize,
+      size_t _numElements,
       size_t _numHits,
       size_t _numLookups)
       : maxSize{_maxSize},
+        expireDurationMs(_expireDurationMs),
         curSize{_curSize},
+        pinnedSize{_pinnedSize},
+        numElements{_numElements},
         numHits{_numHits},
-        numLookups{_numLookups},
-        numElements{curSize},
-        pinnedSize{curSize} {}
+        numLookups{_numLookups} {}
 
-  // Capacity of the cache.
-  const size_t maxSize;
+  SimpleLRUCacheStats() = default;
 
-  // Current cache size used.
-  const size_t curSize;
+  /// Capacity of the cache.
+  size_t maxSize{0};
 
-  // Total number of cache hits since server start.
-  const size_t numHits;
+  size_t expireDurationMs{0};
 
-  // Total number of cache lookups since server start.
-  const size_t numLookups;
+  /// Current cache size used.
+  size_t curSize{0};
 
-  // TODO: These 2 are unused, but open source Presto depends on them
-  // Remove the usage in open source presto and get rid of them.
-  const size_t numElements;
-  const size_t pinnedSize;
+  /// Current cache size used by pinned entries.
+  size_t pinnedSize{0};
+
+  /// Total number of elements in the cache.
+  size_t numElements{0};
+
+  /// Total number of cache hits since server start.
+  size_t numHits{0};
+
+  /// Total number of cache lookups since server start.
+  size_t numLookups{0};
 
   std::string toString() const {
     return fmt::format(
         "{{\n"
         "  maxSize: {}\n"
+        "  expireDurationMs: {}\n"
         "  curSize: {}\n"
+        "  pinnedSize: {}\n"
+        "  numElements: {}\n"
         "  numHits: {}\n"
         "  numLookups: {}\n"
         "}}\n",
         maxSize,
+        expireDurationMs,
         curSize,
+        pinnedSize,
+        numElements,
         numHits,
         numLookups);
   }
 
-  bool operator==(const SimpleLRUCacheStats& rhs) const {
-    return std::tie(curSize, maxSize, numHits, numLookups) ==
-        std::tie(rhs.curSize, rhs.maxSize, rhs.numHits, rhs.numLookups);
+  bool operator==(const SimpleLRUCacheStats& other) const {
+    return std::tie(
+               curSize,
+               expireDurationMs,
+               maxSize,
+               pinnedSize,
+               numElements,
+               numHits,
+               numLookups) ==
+        std::tie(
+               other.curSize,
+               other.expireDurationMs,
+               other.maxSize,
+               other.pinnedSize,
+               other.numElements,
+               other.numHits,
+               other.numLookups);
   }
 };
 
-/// A simple wrapper on top of the folly::EvictingCacheMap that tracks
-/// hit/miss counters. Key/Value evicted are immediately destructed.
-/// So the Key/Value should be a value type or self managing lifecycle
-/// shared_ptr.
+/// A simple LRU cache that allows each element to occupy an arbitrary amount of
+/// space in the cache. Useful when the size of the cached elements can vary a
+/// lot; if they are all roughly the same size something that only tracks the
+/// number of elements in the cache like common/datastruct/LRUCacheMap.h may be
+/// better.
 ///
 /// NOTE:
-/// 1. NOT Thread-Safe: All the public calls modify internal structures
-/// and hence require external write locks if used from multiple threads.
-template <typename Key, typename Value>
+/// 1. NOT Thread-Safe: All the public calls modify internal structures and
+/// hence require external write locks if used from multiple threads.
+/// 2. 'Key' is required to be copyable and movable.
+template <
+    typename Key,
+    typename Value,
+    typename Comparator = std::equal_to<Key>,
+    typename Hash = std::hash<Key>>
 class SimpleLRUCache {
  public:
-  /// Constructs a cache of the specified size. The maxSize represents the
-  /// number of entries in the cache. clearSize represents the number of entries
-  /// to evict in a given time, when the cache is full.
-  explicit SimpleLRUCache(size_t maxSize, size_t clearSize = 1);
+  /// Constructs a cache of the specified size. This size can represent whatever
+  /// you want -- slots, or bytes, or etc; you provide the size of each element
+  /// whenever you add a new value to the cache. If 'expireDurationMs' is not
+  /// zero, then a cache value will be evicted out of cache after
+  /// 'expireDurationMs' time passed since its insertion into the cache no
+  /// matter if it been accessed or not.
+  explicit SimpleLRUCache(size_t maxSize, size_t expireDurationMs = 0);
+
+  /// Frees all owned data. Check-fails if any element remains pinned.
+  ~SimpleLRUCache();
+
+  /// Adds a key-value pair that will occupy the provided size, evicting
+  /// older elements repeatedly until enough room is avialable in the cache.
+  /// Returns whether insertion succeeded. If it did, the cache takes
+  /// ownership of |value|. Insertion will fail in two cases:
+  ///   1) There isn't enough room in the cache even after all unpinned
+  ///      elements are freed.
+  ///   2) The key you are adding is already present in the cache. In
+  ///      this case the element currently existing in the cache remains
+  ///      totally unchanged.
+  ///
+  /// If you use size to represent in-memory size, keep in mind that the
+  /// total space used per entry is roughly 2 * key_size + value_size + 30 bytes
+  /// (nonexact because we use a hash map internally, so the ratio of reserved
+  /// slot to used slots will vary).
+  bool add(Key key, Value* value, size_t size);
 
-  /// Add an item to the cache. Returns true if the item is successfully
-  /// added, false otherwise.
-  bool add(const Key& key, const Value& value);
+  /// Same as add(), but the value starts pinned. Saves a map lookup if you
+  /// would otherwise do add() then get(). Keep in mind that if insertion
+  /// fails the key's pin count has NOT been incremented.
+  bool addPinned(Key key, Value* value, size_t size);
 
-  /// Gets value associated with key.
-  /// returns std::nullopt when the key is missing
-  /// returns the cached value, when the key is present.
-  std::optional<Value> get(const Key& key);
+  /// Gets an unowned pointer to the value associated with key.
+  /// Returns nullptr if the key is not present in the cache.
+  /// Once you are done using the returned non-null *value, you must call
+  /// release with the same key you passed to get.
+  ///
+  /// The returned pointer is guaranteed to remain valid until release
+  /// is called.
+  ///
+  /// Note that we return a non-const pointer, and multiple callers
+  /// can lease the same object, so if you're mutating it you need
+  /// to manage your own locking.
+  Value* get(const Key& key);
 
-  void clear();
+  /// Unpins a key. You MUST call release on every key you have
+  /// get'd once are you done using the value or bad things will
+  /// happen (namely, memory leaks).
+  void release(const Key& key);
 
   /// Total size of elements in the cache (NOT the maximum size/limit).
   size_t currentSize() const {
-    return lru_.size();
+    return curSize_;
   }
 
   /// The maximum size of the cache.
   size_t maxSize() const {
-    return lru_.getMaxSize();
+    return maxSize_;
   }
 
-  SimpleLRUCacheStats getStats() const {
+  SimpleLRUCacheStats stats() const {
     return {
-        lru_.getMaxSize(),
-        lru_.size(),
+        maxSize_,
+        expireDurationMs_,
+        curSize_,
+        pinnedSize_,
+        lruList_.size(),
         numHits_,
         numLookups_,
     };
   }
 
+  /// Removes unpinned elements until at least size space is freed. Returns
+  /// the size actually freed, which may be less than requested if the
+  /// remaining are all pinned.
+  size_t free(size_t size);
+
  private:
+  struct Element {
+    Key key;
+    Value* value;
+    size_t size;
+    uint32_t numPins;
+    size_t expireTimeMs;
+    folly::IntrusiveListHook lruEntry;
+    folly::IntrusiveListHook expireEntry;
+  };
+  using LruList = folly::IntrusiveList<Element, &Element::lruEntry>;
+  using ExpireList = folly::IntrusiveList<Element, &Element::expireEntry>;
+
+  bool addInternal(Key key, Value* value, size_t size, bool pinned);
+
+  // Removes the expired and unpinned cache entries from the cache. The function
+  // is invoked upon cache lookup, cache insertion and cache entry release.
+  void removeExpiredEntries();
+
+  // Removes entry 'e' from cache by unlinking it from 'lruList_' and
+  // 'expireList_', and destroy the object at the end.
+  size_t freeEntry(Element* e);
+
+  const size_t maxSize_;
+  const size_t expireDurationMs_;
+  size_t curSize_{0};
+  size_t pinnedSize_{0};
   size_t numHits_{0};
   size_t numLookups_{0};
 
-  folly::EvictingCacheMap<Key, Value> lru_;
+  // Elements get newer as we evict from lruList_.begin() to lruList_.end().
+  LruList lruList_;
+  ExpireList expireList_;
+  folly::F14FastMap<Key, Element*, Hash, Comparator> keys_;
 };
 
-//
-//  End of public API. Imlementation follows.
-//
-
-template <typename Key, typename Value>
-inline SimpleLRUCache<Key, Value>::SimpleLRUCache(
+///
+/// End of public API. Implementation follows.
+///
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline SimpleLRUCache<Key, Value, Comparator, Hash>::SimpleLRUCache(
     size_t maxSize,
-    size_t clearSize)
-    : lru_(maxSize, clearSize) {}
-
-template <typename Key, typename Value>
-inline bool SimpleLRUCache<Key, Value>::add(
-    const Key& key,
-    const Value& value) {
-  return lru_.insert(key, value).second;
+    size_t expireDurationMs)
+    : maxSize_(maxSize), expireDurationMs_(expireDurationMs) {}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline SimpleLRUCache<Key, Value, Comparator, Hash>::~SimpleLRUCache() {
+  VELOX_CHECK_EQ(pinnedSize_, 0);
+  // We could be more optimal than calling free here, but in
+  // general this destructor will never get called during normal
+  // usage so we don't bother.
+  free(maxSize_);
+  VELOX_CHECK(lruList_.empty());
+  VELOX_CHECK(expireList_.empty());
+  VELOX_CHECK(keys_.empty());
+  VELOX_CHECK_EQ(curSize_, 0);
 }
 
-template <typename Key, typename Value>
-inline std::optional<Value> SimpleLRUCache<Key, Value>::get(const Key& key) {
-  ++numLookups_;
-  auto it = lru_.find(key);
-  if (it == lru_.end()) {
-    return std::nullopt;
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline bool SimpleLRUCache<Key, Value, Comparator, Hash>::add(
+    Key key,
+    Value* value,
+    size_t size) {
+  return addInternal(key, value, size, /*pinned=*/false);
+}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline bool SimpleLRUCache<Key, Value, Comparator, Hash>::addPinned(
+    Key key,
+    Value* value,
+    size_t size) {
+  return addInternal(key, value, size, /*pinned=*/true);
+}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline void
+SimpleLRUCache<Key, Value, Comparator, Hash>::removeExpiredEntries() {
+  if (expireDurationMs_ == 0) {
+    return;
+  }
+  const auto currentTimeMs = getCurrentTimeMs();
+  auto it = expireList_.begin();
+  while (it != expireList_.end()) {
+    if (it->expireTimeMs > currentTimeMs) {
+      return;
+    }
+    if (it->numPins > 0) {
+      ++it;
+      continue;
+    }
+    Element* expiredEntry = &*it;
+    it = expireList_.erase(it);
+    freeEntry(expiredEntry);
   }
+}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline bool SimpleLRUCache<Key, Value, Comparator, Hash>::addInternal(
+    Key key,
+    Value* value,
+    size_t size,
+    bool pinned) {
+  removeExpiredEntries();
+
+  if (keys_.find(key) != keys_.end()) {
+    return false;
+  }
+  if (pinnedSize_ + size > maxSize_) {
+    return false;
+  }
+  const int64_t spaceNeeded = curSize_ + size - maxSize_;
+  if (spaceNeeded > 0) {
+    free(spaceNeeded);
+  }
+
+  Element* e = new Element;
+  e->key = std::move(key);
+  e->value = value;
+  e->size = size;
+  e->numPins = !!pinned;
+  if (pinned) {
+    pinnedSize_ += size;
+  }
+  keys_.emplace(e->key, e);
+  lruList_.push_back(*e);
+  if (expireDurationMs_ != 0) {
+    e->expireTimeMs = getCurrentTimeMs() + expireDurationMs_;
+    expireList_.push_back(*e);
+  }
+  curSize_ += size;
+  return true;
+}
 
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline Value* SimpleLRUCache<Key, Value, Comparator, Hash>::get(
+    const Key& key) {
+  removeExpiredEntries();
+
+  ++numLookups_;
+  auto it = keys_.find(key);
+  if (it == keys_.end()) {
+    return nullptr;
+  }
+  Element* entry = it->second;
+  if (entry->numPins++ == 0) {
+    pinnedSize_ += entry->size;
+  }
+  VELOX_DCHECK(entry->lruEntry.is_linked());
+  entry->lruEntry.unlink();
+  lruList_.push_back(*entry);
   ++numHits_;
-  return it->second;
+  return it->second->value;
+}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline void SimpleLRUCache<Key, Value, Comparator, Hash>::release(
+    const Key& key) {
+  Element* e = keys_[key];
+  if (--e->numPins == 0) {
+    pinnedSize_ -= e->size;
+  }
+  removeExpiredEntries();
+}
+
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline size_t SimpleLRUCache<Key, Value, Comparator, Hash>::free(size_t size) {
+  auto it = lruList_.begin();
+  size_t freed = 0;
+  while (it != lruList_.end() && freed < size) {
+    if (it->numPins == 0) {
+      Element* evictedEntry = &*it;
+      it = lruList_.erase(it);
+      freed += freeEntry(evictedEntry);
+    } else {
+      ++it;
+    }
+  }
+  return freed;
 }
 
-template <typename Key, typename Value>
-inline void SimpleLRUCache<Key, Value>::clear() {
-  lru_.clear();
+template <typename Key, typename Value, typename Comparator, typename Hash>
+inline size_t SimpleLRUCache<Key, Value, Comparator, Hash>::freeEntry(
+    Element* e) {
+  VELOX_CHECK_EQ(e->numPins, 0);
+  // NOTE: the list hook dtor will unlink the entry from list so we don't need
+  // to explicitly unlink here.
+  const auto freedSize = e->size;
+  curSize_ -= freedSize;
+  keys_.erase(e->key);
+  delete e->value;
+  delete e;
+  return freedSize;
 }
 } // namespace facebook::velox
diff --git a/velox/common/caching/SsdCache.cpp b/velox/common/caching/SsdCache.cpp
index 16ebf0f539c89..29b44e8abd4b9 100644
--- a/velox/common/caching/SsdCache.cpp
+++ b/velox/common/caching/SsdCache.cpp
@@ -16,47 +16,60 @@
 #include "velox/common/caching/SsdCache.h"
 #include <folly/Executor.h>
 #include <folly/portability/SysUio.h>
+#include "velox/common/base/Exceptions.h"
 #include "velox/common/caching/FileIds.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/common/time/Timer.h"
 
 #include <filesystem>
 #include <numeric>
 
+using facebook::velox::common::testutil::TestValue;
+
 namespace facebook::velox::cache {
 
-SsdCache::SsdCache(
-    std::string_view filePrefix,
-    uint64_t maxBytes,
-    int32_t numShards,
-    folly::Executor* executor,
-    int64_t checkpointIntervalBytes,
-    bool disableFileCow)
-    : filePrefix_(filePrefix),
-      numShards_(numShards),
+SsdCache::SsdCache(const Config& config)
+    : filePrefix_(config.filePrefix),
+      numShards_(config.numShards),
       groupStats_(std::make_unique<FileGroupStats>()),
-      executor_(executor) {
+      executor_(config.executor) {
   // Make sure the given path of Ssd files has the prefix for local file system.
   // Local file system would be derived based on the prefix.
   VELOX_CHECK(
-      filePrefix_.find("/") == 0,
+      filePrefix_.find('/') == 0,
       "Ssd path '{}' does not start with '/' that points to local file system.",
       filePrefix_);
+  VELOX_CHECK_NOT_NULL(executor_);
+
+  VELOX_SSD_CACHE_LOG(INFO) << "SSD cache config: " << config.toString();
+
+  auto checksumReadVerificationEnabled = config.checksumReadVerificationEnabled;
+  if (config.checksumReadVerificationEnabled && !config.checksumEnabled) {
+    VELOX_SSD_CACHE_LOG(WARNING)
+        << "Checksum read has been disabled as checksum is not enabled.";
+    checksumReadVerificationEnabled = false;
+  }
   filesystems::getFileSystem(filePrefix_, nullptr)
-      ->mkdir(std::filesystem::path(filePrefix).parent_path().string());
+      ->mkdir(std::filesystem::path(filePrefix_).parent_path().string());
 
   files_.reserve(numShards_);
   // Cache size must be a multiple of this so that each shard has the same max
   // size.
-  uint64_t sizeQuantum = numShards_ * SsdFile::kRegionSize;
-  int32_t fileMaxRegions = bits::roundUp(maxBytes, sizeQuantum) / sizeQuantum;
+  const uint64_t sizeQuantum = numShards_ * SsdFile::kRegionSize;
+  const int32_t fileMaxRegions =
+      bits::roundUp(config.maxBytes, sizeQuantum) / sizeQuantum;
   for (auto i = 0; i < numShards_; ++i) {
-    files_.push_back(std::make_unique<SsdFile>(
+    const auto fileConfig = SsdFile::Config(
         fmt::format("{}{}", filePrefix_, i),
         i,
         fileMaxRegions,
-        checkpointIntervalBytes / numShards,
-        disableFileCow));
+        config.checkpointIntervalBytes / config.numShards,
+        config.disableFileCow,
+        config.checksumEnabled,
+        checksumReadVerificationEnabled,
+        executor_);
+    files_.push_back(std::make_unique<SsdFile>(fileConfig));
   }
 }
 
@@ -66,20 +79,21 @@ SsdFile& SsdCache::file(uint64_t fileId) {
 }
 
 bool SsdCache::startWrite() {
-  if (isShutdown_) {
-    return false;
-  }
-  if (writesInProgress_.fetch_add(numShards_) == 0) {
+  std::lock_guard<std::mutex> l(mutex_);
+  checkNotShutdownLocked();
+  if (writesInProgress_ == 0) {
     // No write was pending, so now all shards are counted as writing.
+    writesInProgress_ += numShards_;
     return true;
   }
-  // There were writes in progress, so compensate for the increment.
-  writesInProgress_.fetch_sub(numShards_);
+  VELOX_CHECK_GE(writesInProgress_, 0);
   return false;
 }
 
 void SsdCache::write(std::vector<CachePin> pins) {
-  VELOX_CHECK_LE(numShards_, writesInProgress_);
+  VELOX_CHECK_EQ(numShards_, writesInProgress_);
+
+  TestValue::adjust("facebook::velox::cache::SsdCache::write", this);
 
   const auto startTimeUs = getCurrentTimeMicro();
 
@@ -97,6 +111,7 @@ void SsdCache::write(std::vector<CachePin> pins) {
       ++numNoStore;
       continue;
     }
+
     struct PinHolder {
       std::vector<CachePin> pins;
 
@@ -104,8 +119,8 @@ void SsdCache::write(std::vector<CachePin> pins) {
           : pins(std::move(_pins)) {}
     };
 
-    // We move the mutable vector of pins to the executor. These must
-    // be wrapped in a shared struct to be passed via lambda capture.
+    // We move the mutable vector of pins to the executor. These must be wrapped
+    // in a shared struct to be passed via lambda capture.
     auto pinHolder = std::make_shared<PinHolder>(std::move(shards[i]));
     executor_->add([this, i, pinHolder, bytes, startTimeUs]() {
       try {
@@ -116,12 +131,13 @@ void SsdCache::write(std::vector<CachePin> pins) {
         VELOX_SSD_CACHE_LOG(WARNING)
             << "Ignoring error in SsdFile::write: " << e.what();
       }
+      pinHolder->pins.clear();
       if (--writesInProgress_ == 0) {
         // Typically occurs every few GB. Allows detecting unusually slow rates
         // from failing devices.
         VELOX_SSD_CACHE_LOG(INFO) << fmt::format(
-            "Wrote {}MB, {} MB/s",
-            bytes >> 20,
+            "Wrote {}, {} bytes/s",
+            succinctBytes(bytes),
             static_cast<float>(bytes) / (getCurrentTimeMicro() - startTimeUs));
       }
     });
@@ -129,6 +145,38 @@ void SsdCache::write(std::vector<CachePin> pins) {
   writesInProgress_.fetch_sub(numNoStore);
 }
 
+void SsdCache::checkpoint() {
+  VELOX_CHECK_EQ(numShards_, writesInProgress_);
+  for (auto i = 0; i < numShards_; ++i) {
+    executor_->add([this, i]() {
+      files_[i]->checkpoint(/*force=*/true);
+      --writesInProgress_;
+    });
+  }
+}
+
+bool SsdCache::removeFileEntries(
+    const folly::F14FastSet<uint64_t>& filesToRemove,
+    folly::F14FastSet<uint64_t>& filesRetained) {
+  if (!startWrite()) {
+    return false;
+  }
+
+  bool success = true;
+  for (auto i = 0; i < numShards_; i++) {
+    try {
+      success &= files_[i]->removeFileEntries(filesToRemove, filesRetained);
+    } catch (const std::exception& e) {
+      VELOX_SSD_CACHE_LOG(ERROR)
+          << "Error removing file entries from SSD shard "
+          << files_[i]->shardId() << ": " << e.what();
+      success = false;
+    }
+    --writesInProgress_;
+  }
+  return success;
+}
+
 SsdCacheStats SsdCache::stats() const {
   SsdCacheStats stats;
   for (auto& file : files_) {
@@ -137,38 +185,68 @@ SsdCacheStats SsdCache::stats() const {
   return stats;
 }
 
-void SsdCache::clear() {
-  for (auto& file : files_) {
-    file->clear();
-  }
-}
-
 std::string SsdCache::toString() const {
-  auto data = stats();
-  uint64_t capacity = maxBytes();
+  const auto data = stats();
+  const uint64_t capacity = maxBytes();
   std::stringstream out;
-  out << "Ssd cache IO: Write " << (data.bytesWritten >> 20) << "MB read "
-      << (data.bytesRead >> 20) << "MB Size " << (capacity >> 30)
-      << "GB Occupied " << (data.bytesCached >> 30) << "GB";
-  out << (data.entriesCached >> 10) << "K entries.";
+  out << "Ssd cache IO: Write " << succinctBytes(data.bytesWritten) << " read "
+      << succinctBytes(data.bytesRead) << " Size " << succinctBytes(capacity)
+      << " Occupied " << succinctBytes(data.bytesCached);
+  out << " " << (data.entriesCached >> 10) << "K entries.";
   out << "\nGroupStats: " << groupStats_->toString(capacity);
   return out.str();
 }
 
-void SsdCache::testingDeleteFiles() {
-  for (auto& file : files_) {
-    file->deleteFile();
+void SsdCache::shutdown() {
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    if (shutdown_) {
+      VELOX_SSD_CACHE_LOG(INFO) << "SSD cache has already been shutdown";
+    }
+    shutdown_ = true;
   }
-}
 
-void SsdCache::shutdown() {
-  isShutdown_ = true;
+  VELOX_SSD_CACHE_LOG(INFO) << "SSD cache is shutting down";
   while (writesInProgress_) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
   }
   for (auto& file : files_) {
     file->checkpoint(true);
   }
+  VELOX_SSD_CACHE_LOG(INFO) << "SSD cache has been shutdown";
+}
+
+void SsdCache::clear() {
+  for (auto& file : files_) {
+    file->clear();
+  }
+}
+
+void SsdCache::testingDeleteFiles() {
+  for (auto& file : files_) {
+    file->testingDeleteFile();
+  }
+}
+
+void SsdCache::testingDeleteCheckpoints() {
+  for (auto& file : files_) {
+    file->deleteCheckpoint();
+  }
+}
+
+uint64_t SsdCache::testingTotalLogEvictionFilesSize() {
+  uint64_t size = 0;
+  for (auto& file : files_) {
+    std::filesystem::path p{file->getEvictLogFilePath()};
+    size += std::filesystem::file_size(p);
+  }
+  return size;
+}
+
+void SsdCache::waitForWriteToFinish() {
+  while (writesInProgress_ != 0) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+  }
 }
 
 } // namespace facebook::velox::cache
diff --git a/velox/common/caching/SsdCache.h b/velox/common/caching/SsdCache.h
index 4bbf8583e736d..386e79ed8eecb 100644
--- a/velox/common/caching/SsdCache.h
+++ b/velox/common/caching/SsdCache.h
@@ -26,30 +26,73 @@ namespace facebook::velox::cache {
 
 class SsdCache {
  public:
+  struct Config {
+    Config() = default;
+
+    Config(
+        const std::string& _filePrefix,
+        uint64_t _maxBytes,
+        int32_t _numShards,
+        folly::Executor* _executor,
+        uint64_t _checkpointIntervalBytes = 0,
+        bool _disableFileCow = false,
+        bool _checksumEnabled = false,
+        bool _checksumReadVerificationEnabled = false)
+        : filePrefix(_filePrefix),
+          maxBytes(_maxBytes),
+          numShards(_numShards),
+          checkpointIntervalBytes(_checkpointIntervalBytes),
+          disableFileCow(_disableFileCow),
+          checksumEnabled(_checksumEnabled),
+          checksumReadVerificationEnabled(_checksumReadVerificationEnabled),
+          executor(_executor){};
+
+    std::string filePrefix;
+    uint64_t maxBytes;
+    int32_t numShards;
+
+    /// Checkpoint after every 'checkpointIntervalBytes'/'numShards' written
+    /// into each file. 0 means no checkpointing.
+    uint64_t checkpointIntervalBytes;
+
+    /// True if copy on write should be disabled.
+    bool disableFileCow;
+
+    /// If true, checksum write to SSD is enabled.
+    bool checksumEnabled;
+
+    /// If true, checksum read verification from SSD is enabled.
+    bool checksumReadVerificationEnabled;
+
+    /// Executor for async fsync in checkpoint.
+    folly::Executor* executor;
+
+    std::string toString() const {
+      return fmt::format(
+          "{} shards, capacity {}, checkpoint size {}, file cow {}, checksum {}, read verification {}",
+          numShards,
+          succinctBytes(maxBytes),
+          succinctBytes(checkpointIntervalBytes),
+          (disableFileCow ? "DISABLED" : "ENABLED"),
+          (checksumEnabled ? "ENABLED" : "DISABLED"),
+          (checksumReadVerificationEnabled ? "ENABLED" : "DISABLED"));
+    }
+  };
+
   /// Constructs a cache with backing files at path 'filePrefix'.<ordinal>.
   /// <ordinal> ranges from 0 to 'numShards' - 1.
   /// 'maxBytes' is the total capacity of the cache. This is rounded up to the
   /// next multiple of kRegionSize * 'numShards'. This means that all the shards
   /// have an equal number of regions. For 2 shards and 200MB size, the size
   /// rounds up to 256M with 2 shards each of 128M (2 regions).
-  /// If 'checkpointIntervalBytes' is non-0, the cache makes a durable
+  /// If 'checkpointIntervalBytes' is non-zero, the cache makes a durable
   /// checkpointed state that survives restart after each
   /// 'checkpointIntervalBytes' written.
-  /// If 'setNoCowFlagForSsdFiles' is true, the cache sets 'no copy on write'
-  /// flag to each file. This prevents the cache to go over the 'maxBytes',
-  /// eventually use up all disk space and stop working. Should be set to true
-  /// for file systems supporting COW (like brtfs).
   /// If 'disableFileCow' is true, the cache disables the file COW (copy on
   /// write) feature if the underlying filesystem (such as brtfs) supports it.
   /// This prevents the actual cache space usage on disk from exceeding the
   /// 'maxBytes' limit and stop working.
-  SsdCache(
-      std::string_view filePrefix,
-      uint64_t maxBytes,
-      int32_t numShards,
-      folly::Executor* executor,
-      int64_t checkpointIntervalBytes = 0,
-      bool disableFileCow = false);
+  SsdCache(const Config& config);
 
   /// Returns the shard corresponding to 'fileId'. 'fileId' is a file id from
   /// e.g. FileCacheKey.
@@ -72,10 +115,27 @@ class SsdCache {
 
   /// Stores the entries of 'pins' into the corresponding files. Sets the file
   /// for the successfully stored entries. May evict existing entries from
-  /// unpinned regions. startWrite() must have been called first and it must
-  /// have returned true.
+  /// unpinned regions.
+  ///
+  /// NOTE: startWrite() must have been called first and it must have returned
+  /// true.
   void write(std::vector<CachePin> pins);
 
+  /// Invoked to write checkpoints to all ssd files. This is used by Prestissimo
+  /// worker operation.
+  ///
+  /// NOTE: startWrite() must have been called first and it must have returned
+  /// true.
+  void checkpoint();
+
+  /// Removes cached entries from all SsdFiles for files in the fileNum set
+  /// 'filesToRemove'. If successful, return true, and 'filesRetained' contains
+  /// entries that should not be removed, ex., from pinned regions. Otherwise,
+  /// return false and 'filesRetained' could be ignored.
+  bool removeFileEntries(
+      const folly::F14FastSet<uint64_t>& filesToRemove,
+      folly::F14FastSet<uint64_t>& filesRetained);
+
   /// Returns stats aggregated from all shards.
   SsdCacheStats stats() const;
 
@@ -83,32 +143,54 @@ class SsdCache {
     return *groupStats_;
   }
 
+  /// Stops writing to the cache files and waits for pending writes to finish.
+  /// If checkpointing is on, makes a checkpoint.
+  void shutdown();
+
+  std::string toString() const;
+
+  const std::string& filePrefix() const {
+    return filePrefix_;
+  }
+
   /// Drops all entries. Outstanding pins become invalid but reading them will
   /// mostly succeed since the files will not be rewritten until new content is
   /// stored.
+  ///
+  /// NOTE: it is used by test and Prestissimo worker operation.
   void clear();
 
+  /// Waits until the pending ssd cache writes or checkpoints to finish. Used by
+  /// test and Prestissimo worker operation.
+  void waitForWriteToFinish();
+
   /// Deletes backing files. Used in testing.
   void testingDeleteFiles();
 
-  /// Stops writing to the cache files and waits for pending writes to finish.
-  /// If checkpointing is on, makes a checkpoint.
-  void shutdown();
+  /// Deletes checkpoint files. Used in testing.
+  void testingDeleteCheckpoints();
 
-  std::string toString() const;
+  /// Returns the total size of eviction log files. Used by test only.
+  uint64_t testingTotalLogEvictionFilesSize();
 
  private:
+  void checkNotShutdownLocked() {
+    VELOX_CHECK(
+        !shutdown_, "Unexpected write after SSD cache has been shutdown");
+  }
+
   const std::string filePrefix_;
   const int32_t numShards_;
+  // Stats for selecting entries to save from AsyncDataCache.
+  const std::unique_ptr<FileGroupStats> groupStats_;
+  folly::Executor* const executor_;
+  mutable std::mutex mutex_;
+
   std::vector<std::unique_ptr<SsdFile>> files_;
 
   // Count of shards with unfinished writes.
-  std::atomic<int32_t> writesInProgress_{0};
-
-  // Stats for selecting entries to save from AsyncDataCache.
-  std::unique_ptr<FileGroupStats> groupStats_;
-  folly::Executor* executor_;
-  std::atomic<bool> isShutdown_{false};
+  std::atomic_int32_t writesInProgress_{0};
+  bool shutdown_{false};
 };
 
 } // namespace facebook::velox::cache
diff --git a/velox/common/caching/SsdFile.cpp b/velox/common/caching/SsdFile.cpp
index f1b4483386f7e..7f500973917a1 100644
--- a/velox/common/caching/SsdFile.cpp
+++ b/velox/common/caching/SsdFile.cpp
@@ -15,12 +15,15 @@
  */
 
 #include "velox/common/caching/SsdFile.h"
+
 #include <folly/Executor.h>
 #include <folly/portability/SysUio.h>
 #include "velox/common/base/AsyncSource.h"
+#include "velox/common/base/Crc.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/caching/FileIds.h"
 #include "velox/common/caching/SsdCache.h"
+#include "velox/common/process/TraceContext.h"
 
 #include <fcntl.h>
 #ifdef linux
@@ -32,6 +35,9 @@
 #include <fstream>
 #include <numeric>
 
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+
 DEFINE_bool(ssd_odirect, true, "Use O_DIRECT for SSD cache IO");
 DEFINE_bool(ssd_verify_write, false, "Read back data after writing to SSD");
 
@@ -79,6 +85,14 @@ void addEntryToIovecs(AsyncDataCacheEntry& entry, std::vector<iovec>& iovecs) {
     };
   }
 }
+
+// Returns the number of entries in a cache 'entry'.
+uint32_t numIoVectorsFromEntry(AsyncDataCacheEntry& entry) {
+  if (entry.tinyData() != nullptr) {
+    return 1;
+  }
+  return entry.data().numRuns();
+}
 } // namespace
 
 SsdPin::SsdPin(SsdFile& file, SsdRun run) : file_(&file), run_(run) {
@@ -116,24 +130,23 @@ std::string SsdPin::toString() const {
       run_.size());
 }
 
-SsdFile::SsdFile(
-    const std::string& filename,
-    int32_t shardId,
-    int32_t maxRegions,
-    int64_t checkpointIntervalBytes,
-    bool disableFileCow,
-    folly::Executor* executor)
-    : fileName_(filename),
-      maxRegions_(maxRegions),
-      shardId_(shardId),
-      checkpointIntervalBytes_(checkpointIntervalBytes),
-      executor_(executor) {
+SsdFile::SsdFile(const Config& config)
+    : fileName_(config.fileName),
+      maxRegions_(config.maxRegions),
+      disableFileCow_(config.disableFileCow),
+      checksumEnabled_(config.checksumEnabled),
+      checksumReadVerificationEnabled_(
+          config.checksumEnabled && config.checksumReadVerificationEnabled),
+      shardId_(config.shardId),
+      checkpointIntervalBytes_(config.checkpointIntervalBytes),
+      executor_(config.executor) {
+  process::TraceContext trace("SsdFile::SsdFile");
   int32_t oDirect = 0;
 #ifdef linux
   oDirect = FLAGS_ssd_odirect ? O_DIRECT : 0;
 #endif // linux
   fd_ = open(fileName_.c_str(), O_CREAT | O_RDWR | oDirect, S_IRUSR | S_IWUSR);
-  if (FOLLY_UNLIKELY(fd_ < 0)) {
+  if (fd_ < 0) {
     ++stats_.openFileErrors;
   }
   // TODO: add fault tolerant handling for open file errors.
@@ -141,30 +154,28 @@ SsdFile::SsdFile(
       fd_,
       0,
       "Cannot open or create {}. Error: {}",
-      filename,
+      fileName_,
       folly::errnoStr(errno));
 
-  if (disableFileCow) {
+  if (disableFileCow_) {
     disableCow(fd_);
   }
 
   readFile_ = std::make_unique<LocalReadFile>(fd_);
-  uint64_t size = lseek(fd_, 0, SEEK_END);
-  numRegions_ = size / kRegionSize;
-  if (numRegions_ > maxRegions_) {
-    numRegions_ = maxRegions_;
-  }
+  const uint64_t size = lseek(fd_, 0, SEEK_END);
+  numRegions_ = std::min<int32_t>(size / kRegionSize, maxRegions_);
   fileSize_ = numRegions_ * kRegionSize;
-  if (size % kRegionSize > 0 || size > numRegions_ * kRegionSize) {
-    ftruncate(fd_, fileSize_);
+  if ((size % kRegionSize > 0) || (size > numRegions_ * kRegionSize)) {
+    ::ftruncate(fd_, fileSize_);
   }
   // The existing regions in the file are writable.
   writableRegions_.resize(numRegions_);
   std::iota(writableRegions_.begin(), writableRegions_.end(), 0);
   tracker_.resize(maxRegions_);
-  regionSizes_.resize(maxRegions_);
-  regionPins_.resize(maxRegions_);
-  if (checkpointIntervalBytes_) {
+  regionSizes_.resize(maxRegions_, 0);
+  erasedRegionSizes_.resize(maxRegions_, 0);
+  regionPins_.resize(maxRegions_, 0);
+  if (checkpointEnabled()) {
     initializeCheckpoint();
   }
 }
@@ -220,7 +231,7 @@ CoalesceIoStats SsdFile::load(
   if (pins.empty()) {
     return CoalesceIoStats();
   }
-  int payloadTotal = 0;
+  size_t totalPayloadBytes = 0;
   for (auto i = 0; i < pins.size(); ++i) {
     const auto runSize = ssdPins[i].run().size();
     auto* entry = pins[i].checkedEntry();
@@ -231,7 +242,7 @@ CoalesceIoStats SsdFile::load(
           succinctBytes(runSize),
           succinctBytes(entry->size()));
     }
-    payloadTotal += entry->size();
+    totalPayloadBytes += entry->size();
     regionRead(regionIndex(ssdPins[i].run().offset()), runSize);
     ++stats_.entriesRead;
     stats_.bytesRead += entry->size();
@@ -240,9 +251,9 @@ CoalesceIoStats SsdFile::load(
   // Do coalesced IO for the pins. For short payloads, the break-even between
   // discrete pread calls and a single preadv that discards gaps is ~25K per
   // gap. For longer payloads this is ~50-100K.
-  auto stats = readPins(
+  const auto stats = readPins(
       pins,
-      payloadTotal / pins.size() < 10000 ? 25000 : 50000,
+      totalPayloadBytes / pins.size() < 10000 ? 25000 : 50000,
       // Max ranges in one preadv call. Longest gap + longest cache entry are
       // under 12 ranges. If a system has a limit of 1K ranges, coalesce limit
       // of 1000 is safe.
@@ -258,6 +269,9 @@ CoalesceIoStats SsdFile::load(
 
   for (auto i = 0; i < ssdPins.size(); ++i) {
     pins[i].checkedEntry()->setSsdFile(this, ssdPins[i].run().offset());
+    auto* entry = pins[i].checkedEntry();
+    auto ssdRun = ssdPins[i].run();
+    maybeVerifyChecksum(*entry, ssdRun);
   }
   return stats;
 }
@@ -265,6 +279,7 @@ CoalesceIoStats SsdFile::load(
 void SsdFile::read(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers) {
+  process::TraceContext trace("SsdFile::read");
   readFile_->preadv(offset, buffers);
 }
 
@@ -279,7 +294,7 @@ std::optional<std::pair<uint64_t, int32_t>> SsdFile::getSpace(
         return std::nullopt;
       }
     }
-    assert(!writableRegions_.empty());
+    VELOX_CHECK(!writableRegions_.empty());
     const auto region = writableRegions_[0];
     const auto offset = regionSizes_[region];
     auto available = kRegionSize - offset;
@@ -306,6 +321,7 @@ std::optional<std::pair<uint64_t, int32_t>> SsdFile::getSpace(
 }
 
 bool SsdFile::growOrEvictLocked() {
+  process::TraceContext trace("SsdFile::growOrEvictLocked");
   if (numRegions_ < maxRegions_) {
     const auto newSize = (numRegions_ + 1) * kRegionSize;
     const auto rc = ::ftruncate(fd_, newSize);
@@ -313,16 +329,17 @@ bool SsdFile::growOrEvictLocked() {
       fileSize_ = newSize;
       writableRegions_.push_back(numRegions_);
       regionSizes_[numRegions_] = 0;
+      erasedRegionSizes_[numRegions_] = 0;
       ++numRegions_;
       return true;
     }
 
     ++stats_.growFileErrors;
-    LOG(ERROR) << "Failed to grow cache file " << fileName_ << " to "
-               << newSize;
+    VELOX_SSD_CACHE_LOG(ERROR)
+        << "Failed to grow cache file " << fileName_ << " to " << newSize;
   }
 
-  auto candidates =
+  const auto candidates =
       tracker_.findEvictionCandidates(3, numRegions_, regionPins_);
   if (candidates.empty()) {
     suspended_ = true;
@@ -331,6 +348,7 @@ bool SsdFile::growOrEvictLocked() {
 
   logEviction(candidates);
   clearRegionEntriesLocked(candidates);
+  stats_.regionsEvicted += candidates.size();
   writableRegions_ = std::move(candidates);
   suspended_ = false;
   return true;
@@ -353,68 +371,86 @@ void SsdFile::clearRegionEntriesLocked(const std::vector<int32_t>& regions) {
     // full, it will get a score boost to be a little ahead of the best.
     tracker_.regionCleared(region);
     regionSizes_[region] = 0;
+    erasedRegionSizes_[region] = 0;
   }
 }
 
 void SsdFile::write(std::vector<CachePin>& pins) {
+  process::TraceContext trace("SsdFile::write");
   // Sorts the pins by their file/offset. In this way what is adjacent in
   // storage is likely adjacent on SSD.
   std::sort(pins.begin(), pins.end());
-  uint64_t total = 0;
   for (const auto& pin : pins) {
     auto* entry = pin.checkedEntry();
     VELOX_CHECK_NULL(entry->ssdFile());
-    total += entry->size();
   }
 
-  int32_t storeIndex = 0;
-  while (storeIndex < pins.size()) {
-    auto space = getSpace(pins, storeIndex);
+  int32_t writeIndex = 0;
+  while (writeIndex < pins.size()) {
+    auto space = getSpace(pins, writeIndex);
     if (!space.has_value()) {
       // No space can be reclaimed. The pins are freed when the caller is freed.
+      ++stats_.writeSsdDropped;
       return;
     }
 
     auto [offset, available] = space.value();
-    int32_t numWritten = 0;
-    int32_t bytes = 0;
-    std::vector<iovec> iovecs;
-    for (auto i = storeIndex; i < pins.size(); ++i) {
+    int32_t numWrittenEntries = 0;
+    uint64_t writeOffset = offset;
+    int32_t writeLength = 0;
+    std::vector<iovec> writeIovecs;
+    for (auto i = writeIndex; i < pins.size(); ++i) {
       auto* entry = pins[i].checkedEntry();
       const auto entrySize = entry->size();
-      if (bytes + entrySize > available) {
+      const auto numIovecs = numIoVectorsFromEntry(*entry);
+      VELOX_CHECK_LE(numIovecs, IOV_MAX);
+      if (writeIovecs.size() + numIovecs > IOV_MAX) {
+        // Writes out the accumulated iovecs if it exceeds IOV_MAX limit.
+        if (!write(writeOffset, writeLength, writeIovecs)) {
+          // If write fails, we return without adding the pins to the cache. The
+          // entries are unchanged.
+          return;
+        }
+        writeIovecs.clear();
+        available -= writeLength;
+        writeOffset += writeLength;
+        writeLength = 0;
+      }
+      if (writeLength + entrySize > available) {
         break;
       }
-      addEntryToIovecs(*entry, iovecs);
-      bytes += entrySize;
-      ++numWritten;
-    }
-    VELOX_CHECK_GE(fileSize_, offset + bytes);
-
-    const auto rc = folly::pwritev(fd_, iovecs.data(), iovecs.size(), offset);
-    if (rc != bytes) {
-      VELOX_SSD_CACHE_LOG(ERROR)
-          << "Failed to write to SSD, file name: " << fileName_
-          << ", fd: " << fd_ << ", size: " << iovecs.size()
-          << ", offset: " << offset << ", error code: " << errno
-          << ", error string: " << folly::errnoStr(errno);
-      ++stats_.writeSsdErrors;
-      // If write fails, we return without adding the pins to the cache. The
-      // entries are unchanged.
-      return;
+      addEntryToIovecs(*entry, writeIovecs);
+      writeLength += entrySize;
+      ++numWrittenEntries;
+    }
+    if (writeLength > 0) {
+      VELOX_CHECK(!writeIovecs.empty());
+      if (!write(writeOffset, writeLength, writeIovecs)) {
+        return;
+      }
+      writeIovecs.clear();
+      available -= writeLength;
+      writeOffset += writeLength;
+      writeLength = 0;
     }
+    VELOX_CHECK_GE(fileSize_, writeOffset);
 
     {
       std::lock_guard<std::shared_mutex> l(mutex_);
-      for (auto i = storeIndex; i < storeIndex + numWritten; ++i) {
+      for (auto i = writeIndex; i < writeIndex + numWrittenEntries; ++i) {
         auto* entry = pins[i].checkedEntry();
+        VELOX_CHECK_NULL(entry->ssdFile());
         entry->setSsdFile(this, offset);
         const auto size = entry->size();
         FileCacheKey key = {
             entry->key().fileNum, static_cast<uint64_t>(entry->offset())};
-        entries_[std::move(key)] = SsdRun(offset, size);
+        uint32_t checksum = 0;
+        if (checksumEnabled_) {
+          checksum = checksumEntry(*entry);
+        }
+        entries_[std::move(key)] = SsdRun(offset, size, checksum);
         if (FLAGS_ssd_verify_write) {
-          verifyWrite(*entry, SsdRun(offset, size));
+          verifyWrite(*entry, SsdRun(offset, size, checksum));
         }
         offset += size;
         ++stats_.entriesWritten;
@@ -422,15 +458,31 @@ void SsdFile::write(std::vector<CachePin>& pins) {
         bytesAfterCheckpoint_ += size;
       }
     }
-    storeIndex += numWritten;
+    writeIndex += numWrittenEntries;
   }
 
-  if ((checkpointIntervalBytes_ > 0) &&
-      (bytesAfterCheckpoint_ >= checkpointIntervalBytes_)) {
+  if (checkpointEnabled()) {
     checkpoint();
   }
 }
 
+bool SsdFile::write(
+    uint64_t offset,
+    uint64_t length,
+    const std::vector<iovec>& iovecs) {
+  const auto ret = folly::pwritev(fd_, iovecs.data(), iovecs.size(), offset);
+  if (ret == length) {
+    return true;
+  }
+  VELOX_SSD_CACHE_LOG(ERROR)
+      << "Failed to write to SSD, file name: " << fileName_ << ", fd: " << fd_
+      << ", size: " << iovecs.size() << ", offset: " << offset
+      << ", error code: " << errno
+      << ", error string: " << folly::errnoStr(errno);
+  ++stats_.writeSsdErrors;
+  return false;
+}
+
 namespace {
 int32_t indexOfFirstMismatch(char* x, char* y, int n) {
   for (auto i = 0; i < n; ++i) {
@@ -443,10 +495,11 @@ int32_t indexOfFirstMismatch(char* x, char* y, int n) {
 } // namespace
 
 void SsdFile::verifyWrite(AsyncDataCacheEntry& entry, SsdRun ssdRun) {
+  process::TraceContext trace("SsdFile::verifyWrite");
   auto testData = std::make_unique<char[]>(entry.size());
   const auto rc = ::pread(fd_, testData.get(), entry.size(), ssdRun.offset());
   VELOX_CHECK_EQ(rc, entry.size());
-  if (entry.tinyData() != 0) {
+  if (entry.tinyData() != nullptr) {
     if (::memcmp(testData.get(), entry.tinyData(), entry.size()) != 0) {
       VELOX_FAIL("bad read back");
     }
@@ -457,11 +510,9 @@ void SsdFile::verifyWrite(AsyncDataCacheEntry& entry, SsdRun ssdRun) {
     for (auto i = 0; i < data.numRuns(); ++i) {
       const auto run = data.runAt(i);
       const auto compareSize = std::min<int64_t>(bytesLeft, run.numBytes());
-      auto badIndex = indexOfFirstMismatch(
+      const auto badIndex = indexOfFirstMismatch(
           run.data<char>(), testData.get() + offset, compareSize);
-      if (badIndex != -1) {
-        VELOX_FAIL("Bad read back");
-      }
+      VELOX_CHECK_EQ(badIndex, -1, "Bad read back");
       bytesLeft -= run.numBytes();
       offset += run.numBytes();
       if (bytesLeft <= 0) {
@@ -473,16 +524,22 @@ void SsdFile::verifyWrite(AsyncDataCacheEntry& entry, SsdRun ssdRun) {
 
 void SsdFile::updateStats(SsdCacheStats& stats) const {
   // Lock only in tsan build. Incrementing the counters has no synchronized
-  // emantics.
+  // semantics.
   std::shared_lock<std::shared_mutex> l(mutex_);
   stats.entriesWritten += stats_.entriesWritten;
   stats.bytesWritten += stats_.bytesWritten;
+  stats.checkpointsWritten += stats_.checkpointsWritten;
   stats.entriesRead += stats_.entriesRead;
   stats.bytesRead += stats_.bytesRead;
+  stats.checkpointsRead += stats_.checkpointsRead;
   stats.entriesCached += entries_.size();
-  for (auto& regionSize : regionSizes_) {
-    stats.bytesCached += regionSize;
+  stats.regionsCached += numRegions_;
+  for (auto i = 0; i < numRegions_; i++) {
+    stats.bytesCached += (regionSizes_[i] - erasedRegionSizes_[i]);
   }
+  stats.entriesAgedOut += stats_.entriesAgedOut;
+  stats.regionsAgedOut += stats_.regionsAgedOut;
+  stats.regionsEvicted += stats_.regionsEvicted;
   for (auto pins : regionPins_) {
     stats.numPins += pins;
   }
@@ -496,17 +553,22 @@ void SsdFile::updateStats(SsdCacheStats& stats) const {
   stats.writeCheckpointErrors += stats_.writeCheckpointErrors;
   stats.readSsdErrors += stats_.readSsdErrors;
   stats.readCheckpointErrors += stats_.readCheckpointErrors;
+  stats.readSsdCorruptions += stats_.readSsdCorruptions;
+  stats.readWithoutChecksumChecks += stats_.readWithoutChecksumChecks;
 }
 
 void SsdFile::clear() {
   std::lock_guard<std::shared_mutex> l(mutex_);
   entries_.clear();
   std::fill(regionSizes_.begin(), regionSizes_.end(), 0);
+  std::fill(erasedRegionSizes_.begin(), erasedRegionSizes_.end(), 0);
   writableRegions_.resize(numRegions_);
   std::iota(writableRegions_.begin(), writableRegions_.end(), 0);
+  tracker_.clear();
 }
 
-void SsdFile::deleteFile() {
+void SsdFile::testingDeleteFile() {
+  process::TraceContext trace("SsdFile::testingDeleteFile");
   if (fd_) {
     close(fd_);
     fd_ = 0;
@@ -518,8 +580,85 @@ void SsdFile::deleteFile() {
   }
 }
 
+bool SsdFile::removeFileEntries(
+    const folly::F14FastSet<uint64_t>& filesToRemove,
+    folly::F14FastSet<uint64_t>& filesRetained) {
+  if (filesToRemove.empty()) {
+    VELOX_SSD_CACHE_LOG(INFO)
+        << "Removed 0 entry from " << fileName_ << ". And erased 0 region with "
+        << kMaxErasedSizePct << "% entries removed.";
+    return true;
+  }
+
+  std::lock_guard<std::shared_mutex> l(mutex_);
+
+  int64_t entriesAgedOut = 0;
+  auto it = entries_.begin();
+  while (it != entries_.end()) {
+    const FileCacheKey& cacheKey = it->first;
+    const SsdRun& ssdRun = it->second;
+
+    if (!cacheKey.fileNum.hasValue()) {
+      ++it;
+      continue;
+    }
+    if (filesToRemove.count(cacheKey.fileNum.id()) == 0) {
+      ++it;
+      continue;
+    }
+
+    auto region = regionIndex(ssdRun.offset());
+    if (regionPins_[region] > 0) {
+      filesRetained.insert(cacheKey.fileNum.id());
+      ++it;
+      continue;
+    }
+
+    ++entriesAgedOut;
+    erasedRegionSizes_[region] += ssdRun.size();
+
+    it = entries_.erase(it);
+  }
+
+  std::vector<int32_t> toFree;
+  toFree.reserve(numRegions_);
+  for (auto region = 0; region < numRegions_; ++region) {
+    if (regionPins_[region] == 0 &&
+        erasedRegionSizes_[region] >
+            regionSizes_[region] * kMaxErasedSizePct / 100) {
+      toFree.push_back(region);
+    }
+  }
+  if (toFree.size() > 0) {
+    VELOX_CHECK(!suspended_);
+    logEviction(toFree);
+    clearRegionEntriesLocked(toFree);
+    writableRegions_.reserve(
+        std::min<size_t>(writableRegions_.size() + toFree.size(), numRegions_));
+    folly::F14FastSet<uint64_t> existingWritableRegions(
+        writableRegions_.begin(), writableRegions_.end());
+    for (int32_t region : toFree) {
+      if (existingWritableRegions.count(region) == 0) {
+        writableRegions_.push_back(region);
+      }
+      VELOX_CHECK_EQ(regionSizes_[region], 0);
+      VELOX_CHECK_EQ(erasedRegionSizes_[region], 0);
+    }
+  }
+
+  stats_.entriesAgedOut += entriesAgedOut;
+  stats_.regionsAgedOut += toFree.size();
+  stats_.regionsEvicted += toFree.size();
+  VELOX_SSD_CACHE_LOG(INFO)
+      << "Removed " << entriesAgedOut << " entries from " << fileName_
+      << ". And erased " << toFree.size() << " regions with "
+      << kMaxErasedSizePct << "% entries removed, and " << entries_.size()
+      << " left.";
+  return true;
+}
+
 void SsdFile::logEviction(const std::vector<int32_t>& regions) {
-  if (checkpointIntervalBytes_ > 0) {
+  if (checkpointEnabled()) {
     const int32_t rc = ::write(
         evictLogFd_, regions.data(), regions.size() * sizeof(regions[0]));
     if (rc != regions.size() * sizeof(regions[0])) {
@@ -544,17 +683,17 @@ void SsdFile::deleteCheckpoint(bool keepLog) {
   }
 
   checkpointDeleted_ = true;
-  const auto logPath = fileName_ + kLogExtension;
+  const auto logPath = getEvictLogFilePath();
   int32_t logRc = 0;
   if (!keepLog) {
     logRc = ::unlink(logPath.c_str());
   }
-  const auto checkpointPath = fileName_ + kCheckpointExtension;
+  const auto checkpointPath = getCheckpointFilePath();
   const auto checkpointRc = ::unlink(checkpointPath.c_str());
   if ((logRc != 0) || (checkpointRc != 0)) {
     ++stats_.deleteCheckpointErrors;
     VELOX_SSD_CACHE_LOG(ERROR)
-        << "Error in deleting log and checkpoint. log:  " << logRc
+        << "Error in deleting log and checkpoint. log: " << logRc
         << " checkpoint: " << checkpointRc;
   }
 }
@@ -580,14 +719,28 @@ inline const char* asChar(const T* ptr) {
 } // namespace
 
 void SsdFile::checkpoint(bool force) {
+  process::TraceContext trace("SsdFile::checkpoint");
   std::lock_guard<std::shared_mutex> l(mutex_);
-  if (!force && (bytesAfterCheckpoint_ < checkpointIntervalBytes_)) {
+  if (!needCheckpoint(force)) {
     return;
   }
 
+  VELOX_SSD_CACHE_LOG(INFO)
+      << "Checkpointing shard " << shardId_ << ", force: " << force
+      << " bytesAfterCheckpoint: " << succinctBytes(bytesAfterCheckpoint_)
+      << " checkpointIntervalBytes: "
+      << succinctBytes(checkpointIntervalBytes_);
+
   checkpointDeleted_ = false;
   bytesAfterCheckpoint_ = 0;
   try {
+    const auto checkRc = [&](int32_t rc, const std::string& errMsg) {
+      if (rc < 0) {
+        VELOX_FAIL("{} with rc {} :{}", errMsg, rc, folly::errnoStr(errno));
+      }
+      return rc;
+    };
+
     // We schedule the potentially long fsync of the cache file on another
     // thread of the cache write executor, if available. If there is none, we do
     // the sync on this thread at the end.
@@ -597,53 +750,55 @@ void SsdFile::checkpoint(bool force) {
       executor_->add([fileSync]() { fileSync->prepare(); });
     }
 
-    const auto checkRc = [&](int32_t rc, const std::string& errMsg) {
-      if (rc < 0) {
-        VELOX_FAIL("{} with rc {} :{}", errMsg, rc, folly::errnoStr(errno));
-      }
-      return rc;
-    };
-
     std::ofstream state;
-    auto checkpointPath = fileName_ + kCheckpointExtension;
-    state.exceptions(std::ofstream::failbit);
-    state.open(checkpointPath, std::ios_base::out | std::ios_base::trunc);
-    // The checkpoint state file contains:
-    // int32_t The 4 bytes of kCheckpointMagic,
-    // int32_t maxRegions,
-    // int32_t numRegions,
-    // regionScores from the 'tracker_',
-    // {fileId, fileName} pairs,
-    // kMapMarker,
-    // {fileId, offset, SSdRun} triples,
-    // kEndMarker.
-    state.write(kCheckpointMagic, sizeof(int32_t));
-    state.write(asChar(&maxRegions_), sizeof(maxRegions_));
-    state.write(asChar(&numRegions_), sizeof(numRegions_));
-
-    // Copy the region scores before writing out for tsan.
-    const auto scoresCopy = tracker_.copyScores();
-    state.write(asChar(scoresCopy.data()), maxRegions_ * sizeof(uint64_t));
-    std::unordered_set<uint64_t> fileNums;
-    for (const auto& entry : entries_) {
-      const auto fileNum = entry.first.fileNum.id();
-      if (fileNums.insert(fileNum).second) {
-        state.write(asChar(&fileNum), sizeof(fileNum));
-        const auto name = fileIds().string(fileNum);
-        const int32_t length = name.size();
-        state.write(asChar(&length), sizeof(length));
-        state.write(name.data(), length);
+    const auto checkpointPath = getCheckpointFilePath();
+    try {
+      state.exceptions(std::ofstream::failbit);
+      state.open(checkpointPath, std::ios_base::out | std::ios_base::trunc);
+      // The checkpoint state file contains:
+      // int32_t The 4 bytes of checkpoint version,
+      // int32_t maxRegions,
+      // int32_t numRegions,
+      // regionScores from the 'tracker_',
+      // {fileId, fileName} pairs,
+      // kMapMarker,
+      // {fileId, offset, SSdRun} triples,
+      // kEndMarker.
+      state.write(checkpointVersion().data(), sizeof(int32_t));
+      state.write(asChar(&maxRegions_), sizeof(maxRegions_));
+      state.write(asChar(&numRegions_), sizeof(numRegions_));
+
+      // Copy the region scores before writing out for tsan.
+      const auto scoresCopy = tracker_.copyScores();
+      state.write(asChar(scoresCopy.data()), maxRegions_ * sizeof(uint64_t));
+      std::unordered_set<uint64_t> fileNums;
+      for (const auto& entry : entries_) {
+        const auto fileNum = entry.first.fileNum.id();
+        if (fileNums.insert(fileNum).second) {
+          state.write(asChar(&fileNum), sizeof(fileNum));
+          const auto name = fileIds().string(fileNum);
+          const int32_t length = name.size();
+          state.write(asChar(&length), sizeof(length));
+          state.write(name.data(), length);
+        }
       }
-    }
 
-    const auto mapMarker = kCheckpointMapMarker;
-    state.write(asChar(&mapMarker), sizeof(mapMarker));
-    for (auto& pair : entries_) {
-      auto id = pair.first.fileNum.id();
-      state.write(asChar(&id), sizeof(id));
-      state.write(asChar(&pair.first.offset), sizeof(pair.first.offset));
-      auto offsetAndSize = pair.second.bits();
-      state.write(asChar(&offsetAndSize), sizeof(offsetAndSize));
+      const auto mapMarker = kCheckpointMapMarker;
+      state.write(asChar(&mapMarker), sizeof(mapMarker));
+      for (auto& pair : entries_) {
+        const auto id = pair.first.fileNum.id();
+        state.write(asChar(&id), sizeof(id));
+        state.write(asChar(&pair.first.offset), sizeof(pair.first.offset));
+        const auto offsetAndSize = pair.second.fileBits();
+        state.write(asChar(&offsetAndSize), sizeof(offsetAndSize));
+        if (checksumEnabled_) {
+          const auto checksum = pair.second.checksum();
+          state.write(asChar(&checksum), sizeof(checksum));
+        }
+      }
+    } catch (const std::exception& e) {
+      fileSync->close();
+      std::rethrow_exception(std::current_exception());
     }
 
     // NOTE: we need to ensure cache file data sync update completes before
@@ -657,6 +812,8 @@ void SsdFile::checkpoint(bool force) {
     if (state.bad()) {
       ++stats_.writeCheckpointErrors;
       checkRc(-1, "Write of checkpoint file");
+    } else {
+      ++stats_.checkpointsWritten;
     }
     state.close();
 
@@ -665,6 +822,11 @@ void SsdFile::checkpoint(bool force) {
     const auto checkpointFd = checkRc(
         ::open(checkpointPath.c_str(), O_WRONLY),
         "Open of checkpoint file for sync");
+    // TODO: add this as file open option after we migrate to use velox
+    // filesystem for ssd file access.
+    if (disableFileCow_) {
+      disableCow(checkpointFd);
+    }
     VELOX_CHECK_GE(checkpointFd, 0);
     checkRc(::fsync(checkpointFd), "Sync of checkpoint file");
     ::close(checkpointFd);
@@ -674,29 +836,40 @@ void SsdFile::checkpoint(bool force) {
     // log evictions. The latter might lead to data consistent issue.
     checkRc(::ftruncate(evictLogFd_, 0), "Truncate of event log");
     checkRc(::fsync(evictLogFd_), "Sync of evict log");
+
+    VELOX_SSD_CACHE_LOG(INFO)
+        << "Checkpoint persisted with " << entries_.size() << " cache entries";
   } catch (const std::exception& e) {
     try {
       checkpointError(-1, e.what());
-    } catch (const std::exception& inner) {
+    } catch (const std::exception&) {
     }
     // Ignore nested exception.
   }
 }
 
 void SsdFile::initializeCheckpoint() {
-  if (checkpointIntervalBytes_ == 0) {
+  if (!checkpointEnabled()) {
     return;
   }
+
   bool hasCheckpoint = true;
-  std::ifstream state(fileName_ + kCheckpointExtension);
+  std::ifstream state(getCheckpointFilePath());
   if (!state.is_open()) {
     hasCheckpoint = false;
     ++stats_.openCheckpointErrors;
-    VELOX_SSD_CACHE_LOG(INFO)
-        << "Starting shard " << shardId_ << " without checkpoint";
+    VELOX_SSD_CACHE_LOG(WARNING) << fmt::format(
+        "Starting shard {} without checkpoint, with checksum write {}, read verification {}, checkpoint file {}",
+        shardId_,
+        checksumEnabled_ ? "enabled" : "disabled",
+        checksumReadVerificationEnabled_ ? "enabled" : "disabled",
+        getCheckpointFilePath());
   }
-  const auto logPath = fileName_ + kLogExtension;
+  const auto logPath = getEvictLogFilePath();
   evictLogFd_ = ::open(logPath.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+  if (disableFileCow_) {
+    disableCow(evictLogFd_);
+  }
   if (evictLogFd_ < 0) {
     ++stats_.openLogErrors;
     // Failure to open the log at startup is a process terminating error.
@@ -719,8 +892,54 @@ void SsdFile::initializeCheckpoint() {
                                  << e.what() << ": Starting without checkpoint";
       entries_.clear();
       deleteCheckpoint(true);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
+    }
+  }
+}
+
+uint32_t SsdFile::checksumEntry(const AsyncDataCacheEntry& entry) const {
+  bits::Crc32 crc;
+  if (entry.tinyData()) {
+    crc.process_bytes(entry.tinyData(), entry.size());
+  } else {
+    int64_t bytesLeft = entry.size();
+    const auto& data = entry.data();
+    for (auto i = 0; i < data.numRuns() && bytesLeft > 0; ++i) {
+      const auto run = data.runAt(i);
+      const auto bytesToProcess = std::min<size_t>(bytesLeft, run.numBytes());
+      crc.process_bytes(run.data<char>(), bytesToProcess);
+      bytesLeft -= bytesToProcess;
     }
+    VELOX_CHECK_EQ(bytesLeft, 0);
+  }
+  return crc.checksum();
+}
+
+void SsdFile::maybeVerifyChecksum(
+    const AsyncDataCacheEntry& entry,
+    const SsdRun& ssdRun) {
+  if (!checksumReadVerificationEnabled_) {
+    return;
+  }
+  VELOX_DCHECK_EQ(ssdRun.size(), entry.size());
+  if (ssdRun.size() != entry.size()) {
+    ++stats_.readWithoutChecksumChecks;
+    VELOX_CACHE_LOG_EVERY_MS(WARNING, 1'000)
+        << "SSD read without checksum due to cache request size mismatch, SSD cache size "
+        << ssdRun.size() << " request size " << entry.size()
+        << ", cache request: " << entry.toString();
+    return;
+  }
+
+  // Verifies that the checksum matches after we read from SSD.
+  const auto checksum = checksumEntry(entry);
+  if (checksum != ssdRun.checksum()) {
+    ++stats_.readSsdCorruptions;
+    VELOX_FAIL(
+        "IOERR: Corrupt SSD cache entry - File: {}, Offset: {}, Size: {}",
+        fileName_,
+        ssdRun.offset(),
+        ssdRun.size());
   }
 }
 
@@ -751,28 +970,36 @@ T readNumber(std::ifstream& stream) {
 } // namespace
 
 void SsdFile::readCheckpoint(std::ifstream& state) {
-  char magic[4];
-  state.read(magic, sizeof(magic));
-  VELOX_CHECK_EQ(strncmp(magic, kCheckpointMagic, 4), 0);
+  char versionMagic[4];
+  state.read(versionMagic, sizeof(versionMagic));
+  const auto checkpoinHasChecksum =
+      isChecksumEnabledOnCheckpointVersion(std::string(versionMagic, 4));
+  if (checksumEnabled_ && !checkpoinHasChecksum) {
+    VELOX_SSD_CACHE_LOG(WARNING) << fmt::format(
+        "Starting shard {} without checkpoint: checksum is enabled but the checkpoint was made without checksum, so skip the checkpoint recovery, checkpoint file {}",
+        shardId_,
+        getCheckpointFilePath());
+    return;
+  }
+
   const auto maxRegions = readNumber<int32_t>(state);
   VELOX_CHECK_EQ(
       maxRegions,
       maxRegions_,
       "Trying to start from checkpoint with a different capacity");
   numRegions_ = readNumber<int32_t>(state);
-  std::vector<int64_t> scores(maxRegions);
-  state.read(asChar(scores.data()), maxRegions_ * sizeof(uint64_t));
+  std::vector<double> scores(maxRegions);
+  state.read(asChar(scores.data()), maxRegions_ * sizeof(double));
   std::unordered_map<uint64_t, StringIdLease> idMap;
   for (;;) {
-    auto id = readNumber<uint64_t>(state);
+    const auto id = readNumber<uint64_t>(state);
     if (id == kCheckpointMapMarker) {
       break;
     }
     std::string name;
     name.resize(readNumber<int32_t>(state));
     state.read(name.data(), name.size());
-    auto lease = StringIdLease(fileIds(), name);
-    idMap[id] = std::move(lease);
+    idMap[id] = StringIdLease(fileIds(), id, name);
   }
 
   const auto logSize = ::lseek(evictLogFd_, 0, SEEK_END);
@@ -783,22 +1010,49 @@ void SsdFile::readCheckpoint(std::ifstream& state) {
   for (auto region : evicted) {
     evictedMap.insert(region);
   }
+
+  std::vector<uint32_t> regionCacheSizes(numRegions_, 0);
   for (;;) {
-    const uint64_t fileNum = readNumber<uint64_t>(state);
+    const auto fileNum = readNumber<uint64_t>(state);
     if (fileNum == kCheckpointEndMarker) {
       break;
     }
-    const uint64_t offset = readNumber<uint64_t>(state);
-    const auto run = SsdRun(readNumber<uint64_t>(state));
+    const auto offset = readNumber<uint64_t>(state);
+    const auto fileBits = readNumber<uint64_t>(state);
+    uint32_t checksum = 0;
+    if (checkpoinHasChecksum) {
+      checksum = readNumber<uint32_t>(state);
+    }
+    const auto run = SsdRun(fileBits, checksum);
+    const auto region = regionIndex(run.offset());
     // Check that the recovered entry does not fall in an evicted region.
-    if (evictedMap.find(regionIndex(run.offset())) == evictedMap.end()) {
-      // The file may have a different id on restore.
-      auto it = idMap.find(fileNum);
-      VELOX_CHECK(it != idMap.end());
-      FileCacheKey key{it->second, offset};
-      entries_[std::move(key)] = run;
+    if (evictedMap.find(region) != evictedMap.end()) {
+      continue;
     }
+    // The file may have a different id on restore.
+    const auto it = idMap.find(fileNum);
+    VELOX_CHECK(it != idMap.end());
+    FileCacheKey key{it->second, offset};
+    entries_[std::move(key)] = run;
+    regionCacheSizes[region] += run.size();
+    regionSizes_[region] = std::max<uint32_t>(
+        regionSizes_[region], regionOffset(run.offset()) + run.size());
   }
+
+  // NOTE: we might erase entries from a region for TTL eviction, so we need to
+  // set the region size to the max offset of the recovered cache entry from the
+  // region. Correspondingly, we substract the cached size from the region size
+  // to get the erased size.
+  for (auto region = 0; region < numRegions_; ++region) {
+    VELOX_CHECK_LE(regionSizes_[region], kRegionSize);
+    VELOX_CHECK_LE(regionCacheSizes[region], regionSizes_[region]);
+    erasedRegionSizes_[region] =
+        regionSizes_[region] - regionCacheSizes[region];
+  }
+
+  ++stats_.checkpointsRead;
+  stats_.entriesRecovered += entries_.size();
+
   // The state is successfully read. Install the access frequency scores and
   // evicted regions.
   VELOX_CHECK_EQ(scores.size(), tracker_.regionScores().size());
@@ -808,12 +1062,21 @@ void SsdFile::readCheckpoint(std::ifstream& state) {
     writableRegions_.push_back(region);
   }
   tracker_.setRegionScores(scores);
+
+  uint64_t cachedBytes{0};
+  for (const auto regionSize : regionSizes_) {
+    cachedBytes += regionSize;
+  }
   VELOX_SSD_CACHE_LOG(INFO) << fmt::format(
-      "Starting shard {} from checkpoint with {} entries, {} regions with {} free.",
+      "Starting shard {} from checkpoint with {} entries, {} cached data, {} regions with {} free, with checksum write {}, read verification {}, checkpoint file {}",
       shardId_,
       entries_.size(),
+      succinctBytes(cachedBytes),
       numRegions_,
-      writableRegions_.size());
+      writableRegions_.size(),
+      checksumEnabled_ ? "enabled" : "disabled",
+      checksumReadVerificationEnabled_ ? "enabled" : "disabled",
+      getCheckpointFilePath());
 }
 
 } // namespace facebook::velox::cache
diff --git a/velox/common/caching/SsdFile.h b/velox/common/caching/SsdFile.h
index 31583cfcd23bf..434d41c342b9e 100644
--- a/velox/common/caching/SsdFile.h
+++ b/velox/common/caching/SsdFile.h
@@ -16,71 +16,82 @@
 
 #pragma once
 
+#include <gflags/gflags.h>
+#include <shared_mutex>
+
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/caching/SsdFileTracker.h"
 #include "velox/common/file/File.h"
 
-#include <gflags/gflags.h>
-
 DECLARE_bool(ssd_odirect);
 DECLARE_bool(ssd_verify_write);
 
 namespace facebook::velox::cache {
 
-// A 64 bit word describing a SSD cache entry in an SsdFile. The low
-// 23 bits are the size, for a maximum entry size of 8MB. The high
-// bits are the offset.
+/// A 64 bit word describing a SSD cache entry in an SsdFile. The low 23 bits
+/// are the size, for a maximum entry size of 8MB. The high bits are the offset.
 class SsdRun {
  public:
   static constexpr int32_t kSizeBits = 23;
 
-  SsdRun() : bits_(0) {}
+  SsdRun() : fileBits_(0) {}
 
-  SsdRun(uint64_t offset, uint32_t size)
-      : bits_((offset << kSizeBits) | ((size - 1))) {
+  SsdRun(uint64_t offset, uint32_t size, uint32_t checksum)
+      : fileBits_((offset << kSizeBits) | ((size - 1))), checksum_(checksum) {
     VELOX_CHECK_LT(offset, 1L << (64 - kSizeBits));
-    VELOX_CHECK_LT(size - 1, 1 << kSizeBits);
+    VELOX_CHECK_NE(size, 0);
+    VELOX_CHECK_LE(size, 1 << kSizeBits);
   }
 
-  SsdRun(uint64_t bits) : bits_(bits) {}
+  SsdRun(uint64_t fileBits, uint32_t checksum)
+      : fileBits_(fileBits), checksum_(checksum) {}
 
   SsdRun(const SsdRun& other) = default;
   SsdRun(SsdRun&& other) = default;
 
   void operator=(const SsdRun& other) {
-    bits_ = other.bits_;
+    fileBits_ = other.fileBits_;
+    checksum_ = other.checksum_;
   }
   void operator=(SsdRun&& other) {
-    bits_ = other.bits_;
+    fileBits_ = other.fileBits_;
+    checksum_ = other.checksum_;
   }
 
   uint64_t offset() const {
-    return (bits_ >> kSizeBits);
+    return (fileBits_ >> kSizeBits);
   }
 
   uint32_t size() const {
-    return (bits_ & ((1 << kSizeBits) - 1)) + 1;
+    return (fileBits_ & ((1 << kSizeBits) - 1)) + 1;
+  }
+
+  /// Returns the checksum computed with crc32.
+  uint32_t checksum() const {
+    return checksum_;
   }
 
-  // Returns raw bits for serialization.
-  uint64_t bits() const {
-    return bits_;
+  /// Returns raw bits for offset and size for serialization.
+  uint64_t fileBits() const {
+    return fileBits_;
   }
 
  private:
-  uint64_t bits_;
+  // Contains the file offset and size.
+  uint64_t fileBits_;
+  uint32_t checksum_;
 };
 
-// Represents an SsdFile entry that is planned for load or being
-// loaded. This is destroyed after load. Destruction decrements the
-// pin count of the corresponding region of 'file_'. While there are
-// pins, the region cannot be evicted.
+/// Represents an SsdFile entry that is planned for load or being loaded. This
+/// is destroyed after load. Destruction decrements the pin count of the
+/// corresponding region of 'file_'. While there are pins, the region cannot be
+/// evicted.
 class SsdPin {
  public:
   SsdPin() : file_(nullptr) {}
 
-  // Constructs a pin referencing 'run' in 'file'. The region must be
-  // pinned before constructing the pin.
+  /// Constructs a pin referencing 'run' in 'file'. The region must be pinned
+  /// before constructing the pin.
   SsdPin(SsdFile& file, SsdRun run);
 
   SsdPin(const SsdPin& other) = delete;
@@ -118,7 +129,7 @@ class SsdPin {
   SsdRun run_;
 };
 
-// Metrics for SSD cache. Maintained by SsdFile and aggregated by SsdCache.
+/// Metrics for SSD cache. Maintained by SsdFile and aggregated by SsdCache.
 struct SsdCacheStats {
   SsdCacheStats() {}
 
@@ -129,10 +140,17 @@ struct SsdCacheStats {
   void operator=(const SsdCacheStats& other) {
     entriesWritten = tsanAtomicValue(other.entriesWritten);
     bytesWritten = tsanAtomicValue(other.bytesWritten);
+    checkpointsWritten = tsanAtomicValue(other.checkpointsWritten);
     entriesRead = tsanAtomicValue(other.entriesRead);
+    entriesRecovered = tsanAtomicValue(other.entriesRecovered);
     bytesRead = tsanAtomicValue(other.bytesRead);
+    checkpointsRead = tsanAtomicValue(other.checkpointsRead);
     entriesCached = tsanAtomicValue(other.entriesCached);
+    regionsCached = tsanAtomicValue(other.regionsCached);
     bytesCached = tsanAtomicValue(other.bytesCached);
+    entriesAgedOut = tsanAtomicValue(other.entriesAgedOut);
+    regionsAgedOut = tsanAtomicValue(other.regionsAgedOut);
+    regionsEvicted = tsanAtomicValue(other.regionsEvicted);
     numPins = tsanAtomicValue(other.numPins);
 
     openFileErrors = tsanAtomicValue(other.openFileErrors);
@@ -141,93 +159,172 @@ struct SsdCacheStats {
     deleteCheckpointErrors = tsanAtomicValue(other.deleteCheckpointErrors);
     growFileErrors = tsanAtomicValue(other.growFileErrors);
     writeSsdErrors = tsanAtomicValue(other.writeSsdErrors);
+    writeSsdDropped = tsanAtomicValue(other.writeSsdDropped);
     writeCheckpointErrors = tsanAtomicValue(other.writeCheckpointErrors);
     readSsdErrors = tsanAtomicValue(other.readSsdErrors);
     readCheckpointErrors = tsanAtomicValue(other.readCheckpointErrors);
+    readSsdCorruptions = tsanAtomicValue(other.readSsdCorruptions);
+    readWithoutChecksumChecks =
+        tsanAtomicValue(other.readWithoutChecksumChecks);
   }
 
-  tsan_atomic<uint64_t> entriesWritten{0};
-  tsan_atomic<uint64_t> bytesWritten{0};
-  tsan_atomic<uint64_t> entriesRead{0};
-  tsan_atomic<uint64_t> bytesRead{0};
+  SsdCacheStats operator-(const SsdCacheStats& other) const {
+    SsdCacheStats result;
+    result.entriesWritten = entriesWritten - other.entriesWritten;
+    result.bytesWritten = bytesWritten - other.bytesWritten;
+    result.checkpointsWritten = checkpointsWritten - other.checkpointsWritten;
+    result.entriesRead = entriesRead - other.entriesRead;
+    result.entriesRecovered = entriesRecovered - other.entriesRecovered;
+    result.bytesRead = bytesRead - other.bytesRead;
+    result.checkpointsRead = checkpointsRead - other.checkpointsRead;
+    result.entriesAgedOut = entriesAgedOut - other.entriesAgedOut;
+    result.regionsAgedOut = regionsAgedOut - other.regionsAgedOut;
+    result.regionsEvicted = regionsEvicted - other.regionsEvicted;
+    result.openFileErrors = openFileErrors - other.openFileErrors;
+    result.openCheckpointErrors =
+        openCheckpointErrors - other.openCheckpointErrors;
+    result.openLogErrors = openLogErrors - other.openLogErrors;
+    result.deleteCheckpointErrors =
+        deleteCheckpointErrors - other.deleteCheckpointErrors;
+    result.growFileErrors = growFileErrors - other.growFileErrors;
+    result.writeSsdErrors = writeSsdErrors - other.writeSsdErrors;
+    result.writeSsdDropped = writeSsdDropped - other.writeSsdDropped;
+    result.writeCheckpointErrors =
+        writeCheckpointErrors - other.writeCheckpointErrors;
+    result.readSsdCorruptions = readSsdCorruptions - other.readSsdCorruptions;
+    result.readSsdErrors = readSsdErrors - other.readSsdErrors;
+    result.readCheckpointErrors =
+        readCheckpointErrors - other.readCheckpointErrors;
+    result.readWithoutChecksumChecks =
+        readWithoutChecksumChecks - other.readWithoutChecksumChecks;
+    return result;
+  }
+
+  void clear() {
+    *this = SsdCacheStats();
+  }
+
+  /// Snapshot stats
   tsan_atomic<uint64_t> entriesCached{0};
+  tsan_atomic<uint64_t> regionsCached{0};
   tsan_atomic<uint64_t> bytesCached{0};
   tsan_atomic<int32_t> numPins{0};
 
+  /// Cumulative stats
+  tsan_atomic<uint64_t> entriesWritten{0};
+  tsan_atomic<uint64_t> bytesWritten{0};
+  tsan_atomic<uint64_t> checkpointsWritten{0};
+  tsan_atomic<uint64_t> entriesRead{0};
+  tsan_atomic<uint64_t> entriesRecovered{0};
+  tsan_atomic<uint64_t> bytesRead{0};
+  tsan_atomic<uint64_t> checkpointsRead{0};
+  tsan_atomic<uint64_t> entriesAgedOut{0};
+  tsan_atomic<uint64_t> regionsAgedOut{0};
+  tsan_atomic<uint64_t> regionsEvicted{0};
   tsan_atomic<uint32_t> openFileErrors{0};
   tsan_atomic<uint32_t> openCheckpointErrors{0};
   tsan_atomic<uint32_t> openLogErrors{0};
   tsan_atomic<uint32_t> deleteCheckpointErrors{0};
   tsan_atomic<uint32_t> growFileErrors{0};
   tsan_atomic<uint32_t> writeSsdErrors{0};
+  tsan_atomic<uint32_t> writeSsdDropped{0};
   tsan_atomic<uint32_t> writeCheckpointErrors{0};
   tsan_atomic<uint32_t> readSsdErrors{0};
   tsan_atomic<uint32_t> readCheckpointErrors{0};
+  tsan_atomic<uint32_t> readSsdCorruptions{0};
+  tsan_atomic<uint32_t> readWithoutChecksumChecks{0};
 };
 
-// A shard of SsdCache. Corresponds to one file on SSD.  The data
-// backed by each SsdFile is selected on a hash of the storage file
-// number of the cached data. Each file consists of an integer number
-// of 64MB regions. Each region has a pin count and an read
-// count. Cache replacement takes place region by region, preferring
-// regions with a smaller read count. Entries do not span
-// regions. Otherwise entries are consecutive byte ranges inside
-// their region.
+/// A shard of SsdCache. Corresponds to one file on SSD. The data backed by each
+/// SsdFile is selected on a hash of the storage file number of the cached data.
+/// Each file consists of an integer number of 64MB regions. Each region has a
+/// pin count and an read count. Cache replacement takes place region by region,
+/// preferring regions with a smaller read count. Entries do not span regions.
+/// Otherwise entries are consecutive byte ranges inside their region.
 class SsdFile {
  public:
+  struct Config {
+    Config(
+        const std::string& _fileName,
+        int32_t _shardId,
+        int32_t _maxRegions,
+        uint64_t _checkpointIntervalBytes = 0,
+        bool _disableFileCow = false,
+        bool _checksumEnabled = false,
+        bool _checksumReadVerificationEnabled = false,
+        folly::Executor* _executor = nullptr)
+        : fileName(_fileName),
+          shardId(_shardId),
+          maxRegions(_maxRegions),
+          checkpointIntervalBytes(_checkpointIntervalBytes),
+          disableFileCow(_disableFileCow),
+          checksumEnabled(_checksumEnabled),
+          checksumReadVerificationEnabled(
+              _checksumEnabled && _checksumReadVerificationEnabled),
+          executor(_executor){};
+
+    /// Name of cache file, used as prefix for checkpoint files.
+    const std::string fileName;
+
+    /// Shard index within the SsdCache.
+    const int32_t shardId;
+
+    /// Maximum size of the backing file in kRegionSize units.
+    const int32_t maxRegions;
+
+    /// Checkpoint after every 'checkpointIntervalBytes' written into this
+    /// file. 0 means no checkpointing. This is set to 0 if checkpointing fails.
+    uint64_t checkpointIntervalBytes;
+
+    /// True if copy on write should be disabled.
+    bool disableFileCow;
+
+    /// If true, checksum write to SSD is enabled.
+    bool checksumEnabled;
+
+    /// If true, checksum read verification from SSD is enabled.
+    bool checksumReadVerificationEnabled;
+
+    /// Executor for async fsync in checkpoint.
+    folly::Executor* executor;
+  };
+
   static constexpr uint64_t kRegionSize = 1 << 26; // 64MB
 
-  // Constructs a cache backed by filename. Discards any previous
-  // contents of filename.
-  SsdFile(
-      const std::string& filename,
-      int32_t shardId,
-      int32_t maxRegions,
-      int64_t checkpointInternalBytes = 0,
-      bool disableFileCow = false,
-      folly::Executor* executor = nullptr);
-
-  // Adds entries of  'pins'  to this file. 'pins' must be in read mode and
-  // those pins that are successfully added to SSD are marked as being on SSD.
-  // The file of the entries must be a file that is backed by 'this'.
+  /// Constructs a cache backed by filename. Discards any previous contents of
+  /// filename.
+  SsdFile(const Config& config);
+
+  /// Adds entries of 'pins' to this file. 'pins' must be in read mode and
+  /// those pins that are successfully added to SSD are marked as being on SSD.
+  /// The file of the entries must be a file that is backed by 'this'.
   void write(std::vector<CachePin>& pins);
 
-  // Finds an entry for 'key'. If no entry is found, the returned pin is empty.
+  /// Finds an entry for 'key'. If no entry is found, the returned pin is empty.
   SsdPin find(RawFileCacheKey key);
 
-  // Erases 'key'
+  /// Erases 'key'
   bool erase(RawFileCacheKey key);
-
-  // Copies the data in 'ssdPins' into 'pins'. Coalesces IO for nearby
-  // entries if they are in ascending order and near enough.
+  /// Copies the data in 'ssdPins' into 'pins'. Coalesces IO for nearby
+  /// entries if they are in ascending order and near enough.
   CoalesceIoStats load(
       const std::vector<SsdPin>& ssdPins,
       const std::vector<CachePin>& pins);
 
-  // Increments the pin count of the region of 'offset'.
+  /// Increments the pin count of the region of 'offset'.
   void pinRegion(uint64_t offset);
 
-  // Decrements the pin count of the region of 'offset'. If the pin count goes
-  // to zero and evict is due, starts the eviction.
+  /// Decrements the pin count of the region of 'offset'. If the pin count goes
+  /// to zero and evict is due, starts the eviction.
   void unpinRegion(uint64_t offset);
 
-  // Asserts that the region of 'offset' is pinned. This is called by
-  // the pin holder. The pin count can be read without mutex.
+  /// Asserts that the region of 'offset' is pinned. This is called by the pin
+  /// holder. The pin count can be read without mutex.
   void checkPinned(uint64_t offset) const {
     tsan_lock_guard<std::shared_mutex> l(mutex_);
     VELOX_CHECK_GT(regionPins_[regionIndex(offset)], 0);
   }
 
-  // Returns the region number corresponding to offset.
-  static int32_t regionIndex(uint64_t offset) {
-    return offset / kRegionSize;
-  }
-
-  // Updates the read count of a region.
-  void regionRead(int32_t region, int32_t size) {
-    tracker_.regionRead(region, size);
-  }
-
   int32_t maxRegions() const {
     return maxRegions_;
   }
@@ -236,34 +333,99 @@ class SsdFile {
     return shardId_;
   }
 
-  // Adds 'stats_' to 'stats'.
+  /// Adds 'stats_' to 'stats'.
   void updateStats(SsdCacheStats& stats) const;
 
-  // Resets this' to a post-construction empty state. See SsdCache::clear().
-  void clear();
+  /// Remove cached entries of files in the fileNum set 'filesToRemove'. If
+  /// successful, return true, and 'filesRetained' contains entries that should
+  /// not be removed, ex., from pinned regions. Otherwise, return false and
+  /// 'filesRetained' could be ignored.
+  bool removeFileEntries(
+      const folly::F14FastSet<uint64_t>& filesToRemove,
+      folly::F14FastSet<uint64_t>& filesRetained);
+
+  /// Writes a checkpoint state that can be recovered from. The checkpoint is
+  /// serialized on 'mutex_'. If 'force' is false, rechecks that at least
+  /// 'checkpointIntervalBytes_' have been written since last checkpoint and
+  /// silently returns if not.
+  void checkpoint(bool force = false);
 
-  // Deletes the backing file. Used in testing.
-  void deleteFile();
+  /// Deletes checkpoint files. If 'keepLog' is true, truncates and syncs the
+  /// eviction log and leaves this open.
+  void deleteCheckpoint(bool keepLog = false);
 
-  // Writes a checkpoint state that can be recovered from. The
-  // checkpoint is serialized on 'mutex_'. If 'force' is false,
-  // rechecks that at least 'checkpointIntervalBytes_' have been
-  // written since last checkpoint and silently returns if not.
-  void checkpoint(bool force = false);
+  /// Returns the SSD file path.
+  const std::string& fileName() const {
+    return fileName_;
+  }
+
+  /// Returns the eviction log file path.
+  std::string getEvictLogFilePath() const {
+    return fileName_ + kLogExtension;
+  }
+
+  /// Returns the checkpoint file path.
+  std::string getCheckpointFilePath() const {
+    return fileName_ + kCheckpointExtension;
+  }
+
+  /// Deletes the backing file. Used in testing.
+  void testingDeleteFile();
+
+  /// Resets this' to a post-construction empty state. See SsdCache::clear().
+  ///
+  /// NOTE: this is only used by test and Prestissimo worker operation.
+  void clear();
 
   /// Returns true if copy on write is disabled for this file. Used in testing.
   bool testingIsCowDisabled() const;
 
+  std::vector<double> testingCopyScores() {
+    return tracker_.copyScores();
+  }
+
+  int32_t testingNumWritableRegions() const {
+    return writableRegions_.size();
+  }
+
+  const folly::F14FastMap<FileCacheKey, SsdRun>& testingEntries() {
+    return entries_;
+  }
+
+  bool testingChecksumReadVerificationEnabled() const {
+    return checksumReadVerificationEnabled_;
+  }
+
  private:
-  // 4 first bytes of a checkpoint file. Allows distinguishing between format
-  // versions.
-  static constexpr const char* kCheckpointMagic = "CPT1";
   // Magic number separating file names from cache entry data in checkpoint
   // file.
   static constexpr int64_t kCheckpointMapMarker = 0xfffffffffffffffe;
   // Magic number at end of completed checkpoint file.
   static constexpr int64_t kCheckpointEndMarker = 0xcbedf11e;
 
+  static constexpr int kMaxErasedSizePct = 50;
+
+  // Updates the read count of a region.
+  void regionRead(int32_t region, int32_t size) {
+    tracker_.regionRead(region, size);
+  }
+
+  // Returns the region number corresponding to 'offset'.
+  static int32_t regionIndex(uint64_t offset) {
+    return offset / kRegionSize;
+  }
+
+  // Returns the offset within a region corresponding to 'offset'.
+  static int32_t regionOffset(uint64_t offset) {
+    return offset % kRegionSize;
+  }
+
+  // The first 4 bytes of a checkpoint file contains version string to indicate
+  // if checksum write is enabled or not.
+  std::string checkpointVersion() const {
+    return checksumEnabled_ ? "CPT2" : "CPT1";
+  }
+
   // Increments the pin count of the region of 'offset'. Caller must hold
   // 'mutex_'.
   void pinRegionLocked(uint64_t offset) {
@@ -292,13 +454,9 @@ class SsdFile {
   // Verifies that 'entry' has the data at 'run'.
   void verifyWrite(AsyncDataCacheEntry& entry, SsdRun run);
 
-  // Deletes checkpoint files. If 'keepLog' is true, truncates and syncs the
-  // eviction log and leaves this open.
-  void deleteCheckpoint(bool keepLog = false);
-
-  // Reads a checkpoint state file and sets 'this' accordingly if read
-  // is successful. Return true for successful read. A failed read
-  // deletes the checkpoint and leaves the log truncated open.
+  // Reads a checkpoint state file and sets 'this' accordingly if read is
+  // successful. Return true for successful read. A failed read deletes the
+  // checkpoint and leaves the log truncated open.
   void readCheckpoint(std::ifstream& state);
 
   // Logs an error message, deletes the checkpoint and stop making new
@@ -312,10 +470,41 @@ class SsdFile {
   // the files for making new checkpoints.
   void initializeCheckpoint();
 
-  // Synchronously logs that 'regions' are no longer valid in a possibly xisting
-  // checkpoint.
+  // Writes 'iovecs' to the SSD file at the 'offset'. Returns true if the write
+  // succeeds; otherwise, log the error and return false.
+  bool
+  write(uint64_t offset, uint64_t length, const std::vector<iovec>& iovecs);
+
+  // Synchronously logs that 'regions' are no longer valid in a possibly
+  // existing checkpoint.
   void logEviction(const std::vector<int32_t>& regions);
 
+  // Computes the checksum of data in cache 'entry'.
+  uint32_t checksumEntry(const AsyncDataCacheEntry& entry) const;
+
+  // Returns true if checkpoint has been enabled.
+  bool checkpointEnabled() const {
+    return checkpointIntervalBytes_ > 0;
+  }
+
+  // Returns true if checkpoint is needed.
+  bool needCheckpoint(bool force) const {
+    if (!checkpointEnabled()) {
+      return false;
+    }
+    return force || (bytesAfterCheckpoint_ >= checkpointIntervalBytes_);
+  }
+
+  void maybeVerifyChecksum(
+      const AsyncDataCacheEntry& entry,
+      const SsdRun& ssdRun);
+
+  // Returns true if checksum write is enabled for the given version.
+  static bool isChecksumEnabledOnCheckpointVersion(
+      const std::string& checkpointVersion) {
+    return checkpointVersion == "CPT2";
+  }
+
   static constexpr const char* kLogExtension = ".log";
   static constexpr const char* kCheckpointExtension = ".cpt";
 
@@ -325,11 +514,20 @@ class SsdFile {
   // Maximum size of the backing file in kRegionSize units.
   const int32_t maxRegions_;
 
-  // Serializes access to all private data members.
-  mutable std::shared_mutex mutex_;
+  // True if copy on write should be disabled.
+  const bool disableFileCow_;
+
+  // If true, checksum write to SSD is enabled.
+  const bool checksumEnabled_;
+
+  // If true, checksum read verification from SSD is enabled.
+  const bool checksumReadVerificationEnabled_;
 
   // Shard index within 'cache_'.
-  int32_t shardId_;
+  const int32_t shardId_;
+
+  // Serializes access to all private data members.
+  mutable std::shared_mutex mutex_;
 
   // Number of kRegionSize regions in the file.
   int32_t numRegions_{0};
@@ -340,10 +538,12 @@ class SsdFile {
   bool suspended_{false};
 
   // Number of used bytes in each region. A new entry must fit between the
-  // offset and the end of the region. This is subscripted with the region
+  // offset and the end of the region. This is sub-scripted with the region
   // index. The regionIndex times kRegionSize is an offset into the file.
   std::vector<uint32_t> regionSizes_;
 
+  std::vector<uint32_t> erasedRegionSizes_;
+
   // Indices of regions available for writing new entries.
   std::vector<int32_t> writableRegions_;
 
@@ -368,9 +568,8 @@ class SsdFile {
   // Counters.
   SsdCacheStats stats_;
 
-  // Checkpoint after every 'checkpointIntervalBytes_' written into
-  // this file. 0 means no checkpointing. This is set to 0 if
-  // checkpointing fails.
+  // Checkpoint after every 'checkpointIntervalBytes_' written into this file. 0
+  // means no checkpointing. This is set to 0 if checkpointing fails.
   int64_t checkpointIntervalBytes_{0};
 
   // Executor for async fsync in checkpoint.
diff --git a/velox/common/caching/SsdFileTracker.cpp b/velox/common/caching/SsdFileTracker.cpp
index 32e3c307e352b..9e05695b1248e 100644
--- a/velox/common/caching/SsdFileTracker.cpp
+++ b/velox/common/caching/SsdFileTracker.cpp
@@ -30,19 +30,19 @@ void SsdFileTracker::fileTouched(int32_t totalEntries) {
 }
 
 void SsdFileTracker::regionFilled(int32_t region) {
-  const uint64_t best =
+  const double best =
       *std::max_element(regionScores_.begin(), regionScores_.end());
-  regionScores_[region] = std::max<int64_t>(regionScores_[region], best * 1.1);
+  regionScores_[region] = std::max<double>(regionScores_[region], best * 1.1);
 }
 
 std::vector<int32_t> SsdFileTracker::findEvictionCandidates(
     int32_t numCandidates,
     int32_t numRegions,
     const std::vector<int32_t>& regionPins) {
-  // Calculates average score of regions wiht no pins. Returns up to
-  // 'numCandidates' unpinned regions with score <= average, lowest
-  // scoring region first.
-  int64_t scoreSum = 0;
+  // Calculates average score of regions with no pins. Returns up to
+  // 'numCandidates' unpinned regions with score <= average, lowest scoring
+  // region first.
+  double scoreSum = 0;
   int32_t numUnpinned = 0;
   for (int i = 0; i < numRegions; ++i) {
     if (regionPins[i] > 0) {
diff --git a/velox/common/caching/SsdFileTracker.h b/velox/common/caching/SsdFileTracker.h
index e8dd2154fea78..5ab825f50b88f 100644
--- a/velox/common/caching/SsdFileTracker.h
+++ b/velox/common/caching/SsdFileTracker.h
@@ -24,9 +24,9 @@
 
 namespace facebook::velox::cache {
 
-// Tracks reads on an SsdFile. Reads are counted for fixed size regions and
-// periodically decayed. Not thread safe, synchronization is the caller's
-// responsibility.
+/// Tracks reads on an SsdFile. Reads are counted for fixed size regions and
+/// periodically decayed. Not thread safe, synchronization is the caller's
+/// responsibility.
 class SsdFileTracker {
  public:
   void resize(int32_t numRegions) {
@@ -42,9 +42,9 @@ class SsdFileTracker {
   }
 
   // Marks that a region has been filled and transits from writable to
-  // evictable. Set its score to be at least the best score +
-  // a small margin so that it gets time to live. Otherwise it has had
-  // the least time to get hits and would be the first evicted.
+  // evictable. Set its score to be at least the best score + a small margin so
+  // that it gets time to live. Otherwise, it has had the least time to get hits
+  // and would be the first evicted.
   void regionFilled(int32_t region);
 
   // Increments event count and periodically decays
@@ -52,21 +52,21 @@ class SsdFileTracker {
   // tracked file.
   void fileTouched(int32_t totalEntries);
 
-  // Returns up to 'numCandidates' least used regions. 'numRegions' is
-  // the count of existing regions. This can be less than the size of
-  // the tracker if the file cannot grow to full size. Regions with a
-  // non-zero count in 'regionPins' are not considered.
+  /// Returns up to 'numCandidates' least used regions. 'numRegions' is the
+  /// count of existing regions. This can be less than the size of the tracker
+  /// if the file cannot grow to full size. Regions with a non-zero count in
+  /// 'regionPins' are not considered.
   std::vector<int32_t> findEvictionCandidates(
       int32_t numCandidates,
       int32_t numRegions,
       const std::vector<int32_t>& regionPins);
 
   // Expose the region access data. Used in checkpointing cache state.
-  std::vector<tsan_atomic<uint64_t>>& regionScores() {
+  std::vector<tsan_atomic<double>>& regionScores() {
     return regionScores_;
   }
 
-  void setRegionScores(const std::vector<int64_t>& scores) {
+  void setRegionScores(const std::vector<double>& scores) {
     VELOX_CHECK_EQ(scores.size(), regionScores_.size());
     for (auto i = 0; i < scores.size(); ++i) {
       regionScores_[i] = scores[i];
@@ -76,18 +76,25 @@ class SsdFileTracker {
   /// Exports a copy of the scores. Tsan will report an error if a
   /// pointer to atomics is passed to write(). Therefore copy the
   /// atomics into non-atomics before writing.
-  std::vector<uint64_t> copyScores() {
-    std::vector<uint64_t> scores(regionScores_.size());
+  std::vector<double> copyScores() {
+    std::vector<double> scores(regionScores_.size());
     for (auto i = 0; i < scores.size(); ++i) {
       scores[i] = tsanAtomicValue(regionScores_[i]);
     }
     return scores;
   }
 
+  /// Resets scores of all regions.
+  ///
+  /// NOTE: this is only used by test and Prestissimo worker operation.
+  void clear() {
+    std::fill(regionScores_.begin(), regionScores_.end(), 0);
+  }
+
  private:
   static constexpr int32_t kDecayInterval = 1000;
 
-  std::vector<tsan_atomic<uint64_t>> regionScores_;
+  std::vector<tsan_atomic<double>> regionScores_;
 
   // Count of lookups. The scores are decayed every time the count goes
   // over kDecayInterval or half count of cache entries, whichever comes first.
diff --git a/velox/common/caching/StringIdMap.cpp b/velox/common/caching/StringIdMap.cpp
index 9d500ff19aeba..c8c88542da1e9 100644
--- a/velox/common/caching/StringIdMap.cpp
+++ b/velox/common/caching/StringIdMap.cpp
@@ -29,25 +29,25 @@ uint64_t StringIdMap::id(std::string_view string) {
 
 void StringIdMap::release(uint64_t id) {
   std::lock_guard<std::mutex> l(mutex_);
-  auto it = idToString_.find(id);
-  if (it != idToString_.end()) {
+  auto it = idToEntry_.find(id);
+  if (it != idToEntry_.end()) {
     VELOX_CHECK_LT(
         0, it->second.numInUse, "Extra release of id in StringIdMap");
     if (--it->second.numInUse == 0) {
       pinnedSize_ -= it->second.string.size();
       auto strIter = stringToId_.find(it->second.string);
-      assert(strIter != stringToId_.end());
+      VELOX_DCHECK(strIter != stringToId_.end());
       stringToId_.erase(strIter);
-      idToString_.erase(it);
+      idToEntry_.erase(it);
     }
   }
 }
 
 void StringIdMap::addReference(uint64_t id) {
   std::lock_guard<std::mutex> l(mutex_);
-  auto it = idToString_.find(id);
+  auto it = idToEntry_.find(id);
   VELOX_CHECK(
-      it != idToString_.end(),
+      it != idToEntry_.end(),
       "Trying to add a reference to id {} that is not in StringIdMap",
       id);
 
@@ -58,16 +58,15 @@ uint64_t StringIdMap::makeId(std::string_view string) {
   std::lock_guard<std::mutex> l(mutex_);
   auto it = stringToId_.find(string);
   if (it != stringToId_.end()) {
-    auto entry = idToString_.find(it->second);
-    VELOX_CHECK(entry != idToString_.end());
+    auto entry = idToEntry_.find(it->second);
+    VELOX_CHECK(entry != idToEntry_.end());
     if (++entry->second.numInUse == 1) {
       pinnedSize_ += entry->second.string.size();
     }
-
     return it->second;
   }
   Entry entry;
-  entry.string = std::string(string);
+  entry.string = string;
   // Check that we do not use an id twice. In practice this never
   // happens because the int64 counter would have to wrap around for
   // this. Even if this happened, the time spent in the loop would
@@ -75,13 +74,44 @@ uint64_t StringIdMap::makeId(std::string_view string) {
   // be in the 100K range.
   do {
     entry.id = ++lastId_;
-  } while (idToString_.find(entry.id) != idToString_.end());
+  } while (idToEntry_.find(entry.id) != idToEntry_.end());
   entry.numInUse = 1;
-  pinnedSize_ += entry.string.size();
-  auto id = entry.id;
-  auto& entryInTable = idToString_[id] = std::move(entry);
-  stringToId_[entryInTable.string] = entry.id;
+  pinnedSize_ += string.size();
+  const auto id = entry.id;
+  idToEntry_[id] = std::move(entry);
+  stringToId_[string] = id;
   return lastId_;
 }
 
+uint64_t StringIdMap::recoverId(uint64_t id, std::string_view string) {
+  std::lock_guard<std::mutex> l(mutex_);
+  auto it = stringToId_.find(string);
+  if (it != stringToId_.end()) {
+    VELOX_CHECK_EQ(
+        id, it->second, "Multiple recover ids assigned to {}", string);
+    auto entry = idToEntry_.find(it->second);
+    VELOX_CHECK(entry != idToEntry_.end());
+    if (++entry->second.numInUse == 1) {
+      pinnedSize_ += entry->second.string.size();
+    }
+    return id;
+  }
+
+  VELOX_CHECK_EQ(
+      idToEntry_.count(id),
+      0,
+      "Reused recover id {} assigned to {}",
+      id,
+      string);
+
+  Entry entry;
+  entry.string = string;
+  entry.id = id;
+  lastId_ = std::max(lastId_, id);
+  entry.numInUse = 1;
+  pinnedSize_ += string.size();
+  idToEntry_[id] = std::move(entry);
+  stringToId_[string] = id;
+  return id;
+}
 } // namespace facebook::velox
diff --git a/velox/common/caching/StringIdMap.h b/velox/common/caching/StringIdMap.h
index c5ec74fd4121a..582de4d09c537 100644
--- a/velox/common/caching/StringIdMap.h
+++ b/velox/common/caching/StringIdMap.h
@@ -28,39 +28,66 @@ class StringIdMap {
  public:
   static constexpr uint64_t kNoId = ~0UL;
 
-  StringIdMap() {}
+  StringIdMap() = default;
 
   StringIdMap(const StringIdMap& other) = delete;
   StringIdMap(StringIdMap&& other) = delete;
   void operator=(const StringIdMap& other) = delete;
   void operator=(StringIdMap&& other) = delete;
 
-  // Returns the id of 'string' or kNoId if the string is not known.
+  /// Returns the id of 'string' or kNoId if the string is not known.
   uint64_t id(std::string_view string);
 
-  // Returns the total length of strings involved in currently referenced
-  // mappings.
+  /// Returns the total length of strings involved in currently referenced
+  /// mappings.
   int64_t pinnedSize() const {
     return pinnedSize_;
   }
 
-  // Returns the id for 'string' and increments its use count. Assigns a
-  // new id if none exists. must be released with release() when no longer used.
+  /// Returns the id for 'string' and increments its use count. Assigns a
+  /// new id if none exists. Must be released with release() when no longer
+  /// used.
   uint64_t makeId(std::string_view string);
 
+  /// Returns the id for 'string' and increments its use count. Assigns a new id
+  /// if none exists. Must be released with release() when no longer used.
+  /// Recovers string id map by assigning 'id' to 'string' and increments its
+  /// use count. The function returns the recovered 'id'. It throws if 'id' has
+  /// already been assigned to other string or 'string' has already assigned a
+  /// different id. Must be released with release() when no longer used.
+  ///
+  /// NOTE: this is used by SSD cache to recover the file name to file id
+  /// mapping. This is to ensure the same file to be mapped to the same SSD file
+  /// shard after recover.
+  uint64_t recoverId(uint64_t id, std::string_view string);
+
   // Decrements the use count of id and may free the associated memory if no
   // uses remain.
   void release(uint64_t id);
 
-  // Increments the use count of 'id'.
+  /// Increments the use count of 'id'.
   void addReference(uint64_t id);
 
-  // Returns a copy of the string associated with id or empty string if id has
-  // no string.
+  /// Returns a copy of the string associated with id or empty string if id has
+  /// no string.
   std::string string(uint64_t id) {
     std::lock_guard<std::mutex> l(mutex_);
-    auto it = idToString_.find(id);
-    return it == idToString_.end() ? "" : it->second.string;
+    auto it = idToEntry_.find(id);
+    return it == idToEntry_.end() ? "" : it->second.string;
+  }
+
+  /// Resets StringIdMap.
+  void testingReset() {
+    std::lock_guard<std::mutex> l(mutex_);
+    stringToId_.clear();
+    idToEntry_.clear();
+    lastId_ = 0;
+    pinnedSize_ = 0;
+  }
+
+  uint64_t testingLastId() const {
+    std::lock_guard<std::mutex> l(mutex_);
+    return lastId_;
   }
 
  private:
@@ -70,23 +97,26 @@ class StringIdMap {
     uint32_t numInUse{};
   };
 
-  std::mutex mutex_;
+  mutable std::mutex mutex_;
   folly::F14FastMap<std::string, uint64_t> stringToId_;
-  folly::F14FastMap<uint64_t, Entry> idToString_;
-  uint64_t lastId_{};
-  uint64_t pinnedSize_{};
+  folly::F14FastMap<uint64_t, Entry> idToEntry_;
+  uint64_t lastId_{0};
+  uint64_t pinnedSize_{0};
 };
 
-// Keeps a string-id association live for the duration of this.
+/// Keeps a string-id association live for the duration of this.
 class StringIdLease {
  public:
   StringIdLease() = default;
 
-  // Makes a lease for 'string' and makes sure it has an id.
+  /// Makes a lease for 'string' and makes sure it has an id.
   StringIdLease(StringIdMap& ids, std::string_view string)
       : ids_(&ids), id_(ids_->makeId(string)) {}
 
-  // Makes a new lease for an id that already references a string.
+  StringIdLease(StringIdMap& ids, uint64_t id, std::string_view string)
+      : ids_(&ids), id_(ids_->recoverId(id, string)) {}
+
+  /// Makes a new lease for an id that already references a string.
   StringIdLease(StringIdMap& ids, uint64_t id) : ids_(&ids), id_(id) {
     ids_->addReference(id_);
   }
@@ -106,6 +136,15 @@ class StringIdLease {
     other.id_ = StringIdMap::kNoId;
   }
 
+  void operator=(const StringIdLease& other) {
+    clear();
+    ids_ = other.ids_;
+    if (ids_ && other.id_ != StringIdMap::kNoId) {
+      ids_->addReference(other.id_);
+    }
+    id_ = other.id_;
+  }
+
   void operator=(StringIdLease&& other) noexcept {
     clear();
     ids_ = other.ids_;
@@ -130,15 +169,6 @@ class StringIdLease {
     return id_ != StringIdMap::kNoId;
   }
 
-  void operator=(const StringIdLease& other) {
-    clear();
-    ids_ = other.ids_;
-    if (ids_ && other.id_ != StringIdMap::kNoId) {
-      ids_->addReference(other.id_);
-    }
-    id_ = other.id_;
-  }
-
   uint64_t id() const {
     return id_;
   }
diff --git a/velox/common/caching/tests/AsyncDataCacheTest.cpp b/velox/common/caching/tests/AsyncDataCacheTest.cpp
index 4c2714db04b19..bb334036cb19f 100644
--- a/velox/common/caching/tests/AsyncDataCacheTest.cpp
+++ b/velox/common/caching/tests/AsyncDataCacheTest.cpp
@@ -14,12 +14,17 @@
  * limitations under the License.
  */
 
+#include "folly/experimental/EventCount.h"
+#include "velox/common/base/Semaphore.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/caching/CacheTTLController.h"
 #include "velox/common/caching/FileIds.h"
 #include "velox/common/caching/SsdCache.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/common/memory/MmapAllocator.h"
+#include "velox/common/testutil/ScopedTestTime.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <folly/executors/IOThreadPoolExecutor.h>
@@ -28,11 +33,11 @@
 #include <gtest/gtest.h>
 
 #include <fcntl.h>
-#include <sys/stat.h>
 #include <sys/types.h>
 
 using namespace facebook::velox;
 using namespace facebook::velox::cache;
+using namespace facebook::velox::common::testutil;
 
 using facebook::velox::memory::MemoryAllocator;
 
@@ -45,8 +50,19 @@ struct Request {
   SsdPin ssdPin;
 };
 
-class AsyncDataCacheTest : public testing::Test {
+struct TestParam {
+  bool checksumEnabled;
+  bool checksumVerificationEnabled;
+};
+
+class AsyncDataCacheTest : public ::testing::TestWithParam<TestParam> {
  public:
+  static std::vector<TestParam> getTestParams() {
+    static std::vector<TestParam> testParams = {
+        {false, false}, {true, false}, {true, true}};
+    return testParams;
+  }
+
   // Deterministically fills 'allocation' based on 'sequence'
   static void initializeContents(int64_t sequence, memory::Allocation& alloc) {
     for (int32_t i = 0; i < alloc.numRuns(); ++i) {
@@ -62,25 +78,49 @@ class AsyncDataCacheTest : public testing::Test {
 
  protected:
   static constexpr int32_t kNumFiles = 100;
+  static constexpr int32_t kNumSsdShards = 4;
+
+  static void SetUpTestCase() {
+    TestValue::enable();
+  }
 
   void SetUp() override {
     filesystems::registerLocalFileSystem();
   }
 
   void TearDown() override {
-    if (executor_) {
-      executor_->join();
-    }
     if (cache_) {
-      auto ssdCache = cache_->ssdCache();
+      cache_->shutdown();
+      auto* ssdCache = cache_->ssdCache();
       if (ssdCache) {
         ssdCache->testingDeleteFiles();
       }
-      cache_->shutdown();
     }
+    if (loadExecutor_ != nullptr) {
+      loadExecutor_->join();
+    }
+    filenames_.clear();
+    CacheTTLController::testingClear();
+    fileIds().testingReset();
   }
 
-  void initializeCache(uint64_t maxBytes, int64_t ssdBytes = 0) {
+  void waitForPendingLoads() {
+    while (numPendingLoads_ > 0) {
+      std::this_thread::sleep_for(std::chrono::microseconds(2000)); // NOLINT
+    }
+  }
+
+  void initializeCache(
+      uint64_t maxBytes,
+      int64_t ssdBytes = 0,
+      uint64_t checkpointIntervalBytes = 0,
+      bool eraseCheckpoint = false,
+      AsyncDataCache::Options cacheOptions = {}) {
+    if (cache_ != nullptr) {
+      cache_->shutdown();
+    }
+    cache_.reset();
+
     std::unique_ptr<SsdCache> ssdCache;
     if (ssdBytes > 0) {
       // tmpfs does not support O_DIRECT, so turn this off for testing.
@@ -88,27 +128,31 @@ class AsyncDataCacheTest : public testing::Test {
       // Make a new tempDirectory only if one is not already set. The
       // second creation of cache must find the checkpoint of the
       // previous one.
-      if (tempDirectory_ == nullptr) {
+      if (tempDirectory_ == nullptr || eraseCheckpoint) {
         tempDirectory_ = exec::test::TempDirectoryPath::create();
       }
-      ssdCache = std::make_unique<SsdCache>(
-          fmt::format("{}/cache", tempDirectory_->path),
+      SsdCache::Config config(
+          fmt::format("{}/cache", tempDirectory_->getPath()),
           ssdBytes,
-          4,
-          executor(),
-          ssdBytes / 20);
-    }
-
-    if (cache_ != nullptr) {
-      cache_->shutdown();
+          kNumSsdShards,
+          ssdExecutor(),
+          checkpointIntervalBytes > 0 ? checkpointIntervalBytes : ssdBytes / 20,
+          false,
+          GetParam().checksumEnabled,
+          GetParam().checksumVerificationEnabled);
+      ssdCache = std::make_unique<SsdCache>(config);
     }
-    cache_.reset();
-    allocator_.reset();
 
-    memory::MmapAllocator::Options options;
-    options.capacity = maxBytes;
-    allocator_ = std::make_shared<memory::MmapAllocator>(options);
-    cache_ = AsyncDataCache::create(allocator_.get(), std::move(ssdCache));
+    memory::MemoryManagerOptions options;
+    options.useMmapAllocator = true;
+    options.allocatorCapacity = maxBytes;
+    options.arbitratorCapacity = maxBytes;
+    options.arbitratorReservedCapacity = 0;
+    options.trackDefaultUsage = true;
+    manager_ = std::make_unique<memory::MemoryManager>(options);
+    allocator_ = static_cast<memory::MmapAllocator*>(manager_->allocator());
+    cache_ =
+        AsyncDataCache::create(allocator_, std::move(ssdCache), cacheOptions);
     if (filenames_.empty()) {
       for (auto i = 0; i < kNumFiles; ++i) {
         auto name = fmt::format("testing_file_{}", i);
@@ -125,9 +169,14 @@ class AsyncDataCacheTest : public testing::Test {
   void loadOne(uint64_t fileNum, Request& request, bool injectError);
 
   // Brings the data for the ranges in 'requests' into cache. The individual
-  // entries should be accessed with loadOne().
-  void
-  loadBatch(uint64_t fileNum, std::vector<Request>& requests, bool injectError);
+  // entries should be accessed with loadOne(). 'requests' are handled with one
+  // TestingCoalescedSsdLoad and one TestingCoalescedLoad. Call
+  // semaphore.acquire() twice if needing to wait for the two loads to finish.
+  void loadBatch(
+      uint64_t fileNum,
+      std::vector<Request>& requests,
+      bool injectError,
+      Semaphore* semaphore = nullptr);
 
   // Gets a pin on each of 'requests' individually. This checks the contents via
   // cache_'s verifyHook.
@@ -140,13 +189,15 @@ class AsyncDataCacheTest : public testing::Test {
     }
   }
 
+  void loadNFiles(int32_t numFiles, std::vector<int64_t> offsets);
+
   // Loads a sequence of entries from a number of files. Looks up a
   // number of entries, then loads the ones that nobody else is
   // loading. Stops after loading 'loadBytes' worth of entries. If
   // 'errorEveryNBatches' is non-0, every nth load batch will have a
   // bad read and wil be dropped. The entries of the failed batch read
   // will still be accessed one by one. If 'largeEveryNBatches' is
-  // non-0, allocates and freees a single allocation of 'largeBytes'
+  // non-0, allocates and frees a single allocation of 'largeBytes'
   // every so many batches. This creates extra memory pressure, as
   // happens when allocating large hash tables in queries.
   void loadLoop(
@@ -162,7 +213,7 @@ class AsyncDataCacheTest : public testing::Test {
     std::vector<std::thread> threads;
     threads.reserve(numThreads);
     for (int32_t i = 0; i < numThreads; ++i) {
-      threads.push_back(std::thread([this, i, func]() { func(i); }));
+      threads.push_back(std::thread([i, func]() { func(i); }));
     }
     for (auto& thread : threads) {
       thread.join();
@@ -192,6 +243,12 @@ class AsyncDataCacheTest : public testing::Test {
     }
   }
 
+  static void waitForSsdWriteToFinish(const SsdCache* ssdCache) {
+    while (ssdCache->writeInProgress()) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+    }
+  }
+
   CachePin newEntry(uint64_t offset, int32_t size) {
     folly::SemiFuture<bool> wait(false);
     try {
@@ -206,15 +263,26 @@ class AsyncDataCacheTest : public testing::Test {
     };
   }
 
-  folly::IOThreadPoolExecutor* executor() {
+  folly::IOThreadPoolExecutor* loadExecutor() {
     static std::mutex mutex;
     std::lock_guard<std::mutex> l(mutex);
-    if (!executor_) {
+    if (loadExecutor_ == nullptr) {
       // We have up to 20 threads. Some tests run at max 16 threads so
       // that there are threads left over for SSD background write.
-      executor_ = std::make_unique<folly::IOThreadPoolExecutor>(20);
+      loadExecutor_ = std::make_unique<folly::IOThreadPoolExecutor>(20);
     }
-    return executor_.get();
+    return loadExecutor_.get();
+  }
+
+  folly::IOThreadPoolExecutor* ssdExecutor() {
+    static std::mutex mutex;
+    std::lock_guard<std::mutex> l(mutex);
+    if (ssdExecutor_ == nullptr) {
+      // We have up to 20 threads. Some tests run at max 16 threads so
+      // that there are threads left over for SSD background write.
+      ssdExecutor_ = std::make_unique<folly::IOThreadPoolExecutor>(20);
+    }
+    return ssdExecutor_.get();
   }
 
   void clearAllocations(std::deque<memory::Allocation>& allocations) {
@@ -225,11 +293,14 @@ class AsyncDataCacheTest : public testing::Test {
   }
 
   std::shared_ptr<exec::test::TempDirectoryPath> tempDirectory_;
-  std::shared_ptr<memory::MemoryAllocator> allocator_;
+  std::unique_ptr<memory::MemoryManager> manager_;
+  memory::MemoryAllocator* allocator_;
   std::shared_ptr<AsyncDataCache> cache_;
   std::vector<StringIdLease> filenames_;
-  std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
+  std::unique_ptr<folly::IOThreadPoolExecutor> loadExecutor_;
+  std::unique_ptr<folly::IOThreadPoolExecutor> ssdExecutor_;
   int32_t numLargeRetries_{0};
+  std::atomic_int64_t numPendingLoads_{0};
 };
 
 class TestingCoalescedLoad : public CoalescedLoad {
@@ -382,7 +453,8 @@ void AsyncDataCacheTest::loadOne(
 void AsyncDataCacheTest::loadBatch(
     uint64_t fileNum,
     std::vector<Request>& requests,
-    bool injectError) {
+    bool injectError,
+    Semaphore* semaphore) {
   // Pattern for loading a set of buffers from a file: Divide the requested
   // ranges between already loaded and loadable from storage.
   std::vector<Request*> fromStorage;
@@ -415,13 +487,22 @@ void AsyncDataCacheTest::loadBatch(
     }
     auto load = std::make_shared<TestingCoalescedLoad>(
         std::move(keys), std::move(sizes), cache_, injectError);
-    executor()->add([load]() {
+    ++numPendingLoads_;
+    loadExecutor()->add([this, load, semaphore]() {
+      SCOPE_EXIT {
+        --numPendingLoads_;
+      };
       try {
         load->loadOrFuture(nullptr);
       } catch (const std::exception& e) {
         // Expecting error, ignore.
       };
+      if (semaphore) {
+        semaphore->release();
+      }
     });
+  } else if (semaphore) {
+    semaphore->release();
   }
 
   if (!fromSsd.empty()) {
@@ -439,13 +520,50 @@ void AsyncDataCacheTest::loadBatch(
         std::move(ssdPins),
         cache_,
         injectError);
-    executor()->add([load]() {
+    ++numPendingLoads_;
+    loadExecutor()->add([this, load, semaphore]() {
+      SCOPE_EXIT {
+        --numPendingLoads_;
+      };
       try {
         load->loadOrFuture(nullptr);
       } catch (const std::exception& e) {
         // Expecting error, ignore.
       };
+      if (semaphore) {
+        semaphore->release();
+      }
     });
+  } else if (semaphore) {
+    semaphore->release();
+  }
+}
+
+void AsyncDataCacheTest::loadNFiles(
+    int32_t numFiles,
+    std::vector<int64_t> offsets) {
+  Semaphore semaphore(0);
+
+  std::vector<Request> batch;
+  int32_t numLoads = 0;
+  for (auto file = 0; file < numFiles; ++file) {
+    auto fileNum = filenames_[file].id();
+    if (auto instance = CacheTTLController::getInstance()) {
+      instance->addOpenFileInfo(fileNum);
+    }
+    for (auto i = 0; i < offsets.size() - 1; i++) {
+      batch.emplace_back(offsets[i], offsets[i + 1] - offsets[i]);
+      if (batch.size() == 8 || i == (offsets.size() - 2)) {
+        loadBatch(fileNum, batch, false, &semaphore);
+        batch.clear();
+        numLoads +=
+            2; // One TestingCoalescedSsdLoad and one TestingCoalescedLoad.
+      }
+    }
+  }
+
+  for (auto i = 0; i < numLoads; i++) {
+    semaphore.acquire();
   }
 }
 
@@ -511,7 +629,7 @@ void AsyncDataCacheTest::loadLoop(
   }
 }
 
-TEST_F(AsyncDataCacheTest, pin) {
+TEST_P(AsyncDataCacheTest, pin) {
   constexpr int64_t kSize = 25000;
   initializeCache(1 << 20);
   auto& exec = folly::QueuedImmediateExecutor::instance();
@@ -578,14 +696,14 @@ TEST_F(AsyncDataCacheTest, pin) {
   EXPECT_EQ(0, cache_->incrementPrefetchPages(0));
 }
 
-TEST_F(AsyncDataCacheTest, replace) {
+TEST_P(AsyncDataCacheTest, replace) {
   constexpr int64_t kMaxBytes = 64 << 20;
   FLAGS_velox_exception_user_stacktrace_enabled = false;
   initializeCache(kMaxBytes);
   // Load 10x the max size, inject an error every 21 batches.
   loadLoop(0, kMaxBytes * 10, 21);
-  if (executor_) {
-    executor_->join();
+  if (loadExecutor_ != nullptr) {
+    loadExecutor_->join();
   }
   auto stats = cache_->refreshStats();
   EXPECT_LT(0, stats.numHit);
@@ -596,16 +714,11 @@ TEST_F(AsyncDataCacheTest, replace) {
       cache_->incrementCachedPages(0));
 }
 
-TEST_F(AsyncDataCacheTest, evictAccounting) {
+TEST_P(AsyncDataCacheTest, evictAccounting) {
   constexpr int64_t kMaxBytes = 64 << 20;
   FLAGS_velox_exception_user_stacktrace_enabled = false;
   initializeCache(kMaxBytes);
-  auto memoryManager =
-      std::make_unique<memory::MemoryManager>(memory::MemoryManagerOptions{
-          .capacity = (int64_t)allocator_->capacity(),
-          .trackDefaultUsage = true,
-          .allocator = allocator_.get()});
-  auto pool = memoryManager->addLeafPool("test");
+  auto pool = manager_->addLeafPool("test");
 
   // We make allocations that we exchange for larger ones later. This will evict
   // cache. We check that the evictions are not counted on the pool even if they
@@ -614,16 +727,17 @@ TEST_F(AsyncDataCacheTest, evictAccounting) {
   memory::ContiguousAllocation large;
   pool->allocateNonContiguous(1200, allocation);
   pool->allocateContiguous(1200, large);
-  EXPECT_EQ(memory::AllocationTraits::kPageSize * 2400, pool->currentBytes());
+  EXPECT_EQ(memory::AllocationTraits::pageBytes(2400), pool->usedBytes());
   loadLoop(0, kMaxBytes * 1.1);
+  waitForPendingLoads();
   pool->allocateNonContiguous(2400, allocation);
   pool->allocateContiguous(2400, large);
-  EXPECT_EQ(memory::AllocationTraits::kPageSize * 4800, pool->currentBytes());
+  EXPECT_EQ(memory::AllocationTraits::pageBytes(4800), pool->usedBytes());
   auto stats = cache_->refreshStats();
   EXPECT_LT(0, stats.numEvict);
 }
 
-TEST_F(AsyncDataCacheTest, largeEvict) {
+TEST_P(AsyncDataCacheTest, largeEvict) {
   constexpr int64_t kMaxBytes = 256 << 20;
   constexpr int32_t kNumThreads = 24;
   FLAGS_velox_exception_user_stacktrace_enabled = false;
@@ -633,8 +747,8 @@ TEST_F(AsyncDataCacheTest, largeEvict) {
   runThreads(kNumThreads, [&](int32_t /*i*/) {
     loadLoop(0, kMaxBytes * 1.2, 0, 1, kMaxBytes / 4);
   });
-  if (executor_) {
-    executor_->join();
+  if (loadExecutor_ != nullptr) {
+    loadExecutor_->join();
   }
   auto stats = cache_->refreshStats();
   EXPECT_LT(0, stats.numEvict);
@@ -644,7 +758,7 @@ TEST_F(AsyncDataCacheTest, largeEvict) {
   LOG(INFO) << "Reties after failed evict: " << numLargeRetries_;
 }
 
-TEST_F(AsyncDataCacheTest, outOfCapacity) {
+TEST_P(AsyncDataCacheTest, outOfCapacity) {
   const int64_t kMaxBytes = 64
       << 20; // 64MB as MmapAllocator's min size is 64MB
   const int32_t kSize = 16 << 10;
@@ -695,7 +809,7 @@ void corruptFile(const std::string& path) {
 }
 } // namespace
 
-TEST_F(AsyncDataCacheTest, DISABLED_ssd) {
+TEST_P(AsyncDataCacheTest, DISABLED_ssd) {
 #ifdef TSAN_BUILD
   // NOTE: scale down the test data set to prevent tsan tester from running out
   // of memory.
@@ -719,8 +833,8 @@ TEST_F(AsyncDataCacheTest, DISABLED_ssd) {
   // data may not get written if reading is faster than writing. Error out once
   // every 11 load batches.
   //
-  // Note that executor() must have more threads so that background
-  // write does not wait for the workload.
+  // NOTE: loadExecutor() must have more threads so that background write does
+  // not wait for the workload.
   runThreads(16, [&](int32_t /*i*/) { loadLoop(0, kSsdBytes, 11); });
   LOG(INFO) << "Stats after first pass: " << cache_->toString();
   auto ssdStats = cache_->ssdCache()->stats();
@@ -757,7 +871,7 @@ TEST_F(AsyncDataCacheTest, DISABLED_ssd) {
 
   cache_->ssdCache()->clear();
   // We cut the tail off one of the cache shards.
-  corruptFile(fmt::format("{}/cache0.cpt", tempDirectory_->path));
+  corruptFile(fmt::format("{}/cache0.cpt", tempDirectory_->getPath()));
   // We open the cache from checkpoint. Reading checks the data integrity, here
   // we check that more data was read than written.
   initializeCache(kRamBytes, kSsdBytes);
@@ -770,17 +884,18 @@ TEST_F(AsyncDataCacheTest, DISABLED_ssd) {
   ASSERT_EQ(ssdStatsFromCP.readCheckpointErrors, 1);
 }
 
-TEST_F(AsyncDataCacheTest, invalidSsdPath) {
+TEST_P(AsyncDataCacheTest, invalidSsdPath) {
   auto testPath = "hdfs:/test/prefix_";
   uint64_t ssdBytes = 256UL << 20;
+  SsdCache::Config config(testPath, ssdBytes, 4, ssdExecutor(), ssdBytes / 20);
   VELOX_ASSERT_THROW(
-      SsdCache(testPath, ssdBytes, 4, executor(), ssdBytes / 20),
+      SsdCache(config),
       fmt::format(
           "Ssd path '{}' does not start with '/' that points to local file system.",
           testPath));
 }
 
-TEST_F(AsyncDataCacheTest, cacheStats) {
+TEST_P(AsyncDataCacheTest, cacheStats) {
   CacheStats stats;
   stats.tinySize = 234;
   stats.largeSize = 1024;
@@ -789,6 +904,8 @@ TEST_F(AsyncDataCacheTest, cacheStats) {
   stats.numEntries = 100;
   stats.numExclusive = 20;
   stats.numShared = 30;
+  stats.sharedPinnedBytes = 10 << 20;
+  stats.exclusivePinnedBytes = 10 << 20;
   stats.numEmptyEntries = 20;
   stats.numPrefetch = 30;
   stats.prefetchBytes = 100;
@@ -798,29 +915,56 @@ TEST_F(AsyncDataCacheTest, cacheStats) {
   stats.numEvict = 463;
   stats.numEvictChecks = 348;
   stats.numWaitExclusive = 244;
+  stats.numAgedOut = 10;
   stats.allocClocks = 1320;
   stats.sumEvictScore = 123;
+  stats.numStales = 100;
   ASSERT_EQ(
       stats.toString(),
       "Cache size: 2.56KB tinySize: 257B large size: 2.31KB\n"
-      "Cache entries: 100 read pins: 30 write pins: 20 num write wait: 244 empty entries: 20\n"
-      "Cache access miss: 2041 hit: 46 hit bytes: 1.34KB eviction: 463 eviction checks: 348\n"
+      "Cache entries: 100 read pins: 30 write pins: 20 pinned shared: 10.00MB pinned exclusive: 10.00MB\n"
+      " num write wait: 244 empty entries: 20\n"
+      "Cache access miss: 2041 hit: 46 hit bytes: 1.34KB eviction: 463 savable eviction: 0 eviction checks: 348 aged out: 10 stales: 100\n"
       "Prefetch entries: 30 bytes: 100B\n"
       "Alloc Megaclocks 0");
 
+  CacheStats statsDelta = stats - stats;
+  ASSERT_EQ(statsDelta.tinySize, 0);
+  ASSERT_EQ(statsDelta.largeSize, 0);
+  ASSERT_EQ(statsDelta.tinyPadding, 0);
+  ASSERT_EQ(statsDelta.largePadding, 0);
+  ASSERT_EQ(statsDelta.numEntries, 0);
+  ASSERT_EQ(statsDelta.numExclusive, 0);
+  ASSERT_EQ(statsDelta.numShared, 0);
+  ASSERT_EQ(statsDelta.sharedPinnedBytes, 0);
+  ASSERT_EQ(statsDelta.exclusivePinnedBytes, 0);
+  ASSERT_EQ(statsDelta.numEmptyEntries, 0);
+  ASSERT_EQ(statsDelta.numPrefetch, 0);
+  ASSERT_EQ(statsDelta.prefetchBytes, 0);
+  ASSERT_EQ(statsDelta.numHit, 0);
+  ASSERT_EQ(statsDelta.hitBytes, 0);
+  ASSERT_EQ(statsDelta.numNew, 0);
+  ASSERT_EQ(statsDelta.numEvict, 0);
+  ASSERT_EQ(statsDelta.numEvictChecks, 0);
+  ASSERT_EQ(statsDelta.numWaitExclusive, 0);
+  ASSERT_EQ(statsDelta.numAgedOut, 0);
+  ASSERT_EQ(statsDelta.allocClocks, 0);
+  ASSERT_EQ(statsDelta.sumEvictScore, 0);
+  ASSERT_EQ(statsDelta.numStales, 0);
+
   constexpr uint64_t kRamBytes = 32 << 20;
   constexpr uint64_t kSsdBytes = 512UL << 20;
   initializeCache(kRamBytes, kSsdBytes);
-  ASSERT_EQ(
-      cache_->toString(),
+  const std::string expectedDetailedCacheOutput =
       "AsyncDataCache:\n"
       "Cache size: 0B tinySize: 0B large size: 0B\n"
-      "Cache entries: 0 read pins: 0 write pins: 0 num write wait: 0 empty entries: 0\n"
-      "Cache access miss: 0 hit: 0 hit bytes: 0B eviction: 0 eviction checks: 0\n"
+      "Cache entries: 0 read pins: 0 write pins: 0 pinned shared: 0B pinned exclusive: 0B\n"
+      " num write wait: 0 empty entries: 0\n"
+      "Cache access miss: 0 hit: 0 hit bytes: 0B eviction: 0 savable eviction: 0 eviction checks: 0 aged out: 0 stales: 0\n"
       "Prefetch entries: 0 bytes: 0B\n"
       "Alloc Megaclocks 0\n"
       "Allocated pages: 0 cached pages: 0\n"
-      "Backing: Memory Allocator[MMAP capacity 16.00KB allocated pages 0 mapped pages 0 external mapped pages 0\n"
+      "Backing: Memory Allocator[MMAP total capacity 64.00MB free capacity 64.00MB allocated pages 0 mapped pages 0 external mapped pages 0\n"
       "[size 1: 0(0MB) allocated 0 mapped]\n"
       "[size 2: 0(0MB) allocated 0 mapped]\n"
       "[size 4: 0(0MB) allocated 0 mapped]\n"
@@ -831,6 +975,574 @@ TEST_F(AsyncDataCacheTest, cacheStats) {
       "[size 128: 0(0MB) allocated 0 mapped]\n"
       "[size 256: 0(0MB) allocated 0 mapped]\n"
       "]\n"
-      "SSD: Ssd cache IO: Write 0MB read 0MB Size 0GB Occupied 0GB0K entries.\n"
-      "GroupStats: <dummy FileGroupStats>");
+      "SSD: Ssd cache IO: Write 0B read 0B Size 512.00MB Occupied 0B 0K entries.\n"
+      "GroupStats: <dummy FileGroupStats>";
+  ASSERT_EQ(cache_->toString(), expectedDetailedCacheOutput);
+  ASSERT_EQ(cache_->toString(true), expectedDetailedCacheOutput);
+  const std::string expectedShortCacheOutput =
+      "AsyncDataCache:\n"
+      "Cache size: 0B tinySize: 0B large size: 0B\n"
+      "Cache entries: 0 read pins: 0 write pins: 0 pinned shared: 0B pinned exclusive: 0B\n"
+      " num write wait: 0 empty entries: 0\n"
+      "Cache access miss: 0 hit: 0 hit bytes: 0B eviction: 0 savable eviction: 0 eviction checks: 0 aged out: 0 stales: 0\n"
+      "Prefetch entries: 0 bytes: 0B\n"
+      "Alloc Megaclocks 0\n"
+      "Allocated pages: 0 cached pages: 0\n";
+  ASSERT_EQ(cache_->toString(false), expectedShortCacheOutput);
 }
+
+TEST_P(AsyncDataCacheTest, cacheStatsWithSsd) {
+  CacheStats stats;
+  stats.numHit = 234;
+  stats.numEvict = 1024;
+  stats.ssdStats = std::make_shared<SsdCacheStats>();
+  stats.ssdStats->bytesWritten = 1;
+  stats.ssdStats->bytesRead = 1;
+
+  const CacheStats otherStats;
+  const CacheStats deltaStats = stats - otherStats;
+  ASSERT_EQ(deltaStats.numHit, 234);
+  ASSERT_EQ(deltaStats.numEvict, 1024);
+  ASSERT_TRUE(deltaStats.ssdStats != nullptr);
+  ASSERT_EQ(deltaStats.ssdStats->bytesWritten, 1);
+  ASSERT_EQ(deltaStats.ssdStats->bytesRead, 1);
+  const std::string expectedDeltaCacheStats =
+      "Cache size: 0B tinySize: 0B large size: 0B\nCache entries: 0 read pins: 0 write pins: 0 pinned shared: 0B pinned exclusive: 0B\n num write wait: 0 empty entries: 0\nCache access miss: 0 hit: 234 hit bytes: 0B eviction: 1024 savable eviction: 0 eviction checks: 0 aged out: 0 stales: 0\nPrefetch entries: 0 bytes: 0B\nAlloc Megaclocks 0";
+  ASSERT_EQ(deltaStats.toString(), expectedDeltaCacheStats);
+}
+
+TEST_P(AsyncDataCacheTest, staleEntry) {
+  constexpr uint64_t kRamBytes = 1UL << 30;
+  // Disable SSD cache to test in-memory cache stale entry only.
+  initializeCache(kRamBytes, 0, 0);
+  StringIdLease file(fileIds(), std::string_view("staleEntry"));
+  const uint64_t offset = 1000;
+  const uint64_t size = 200;
+  folly::SemiFuture<bool> wait(false);
+  RawFileCacheKey key{file.id(), offset};
+  auto pin = cache_->findOrCreate(key, size, &wait);
+  ASSERT_FALSE(pin.empty());
+  ASSERT_TRUE(wait.isReady());
+  ASSERT_TRUE(pin.entry()->isExclusive());
+  pin.entry()->setExclusiveToShared();
+  ASSERT_FALSE(pin.entry()->isExclusive());
+  auto stats = cache_->refreshStats();
+  ASSERT_EQ(stats.numStales, 0);
+  ASSERT_EQ(stats.numEntries, 1);
+  ASSERT_EQ(stats.numHit, 0);
+
+  auto validPin = cache_->findOrCreate(key, size, &wait);
+  ASSERT_FALSE(validPin.empty());
+  ASSERT_TRUE(wait.isReady());
+  ASSERT_FALSE(validPin.entry()->isExclusive());
+  stats = cache_->refreshStats();
+  ASSERT_EQ(stats.numStales, 0);
+  ASSERT_EQ(stats.numEntries, 1);
+  ASSERT_EQ(stats.numHit, 1);
+
+  // Stale cache access with large cache size.
+  auto stalePin = cache_->findOrCreate(key, 2 * size, &wait);
+  ASSERT_FALSE(stalePin.empty());
+  ASSERT_TRUE(wait.isReady());
+  ASSERT_TRUE(stalePin.entry()->isExclusive());
+  stalePin.entry()->setExclusiveToShared();
+  stats = cache_->refreshStats();
+  ASSERT_EQ(stats.numStales, 1);
+  ASSERT_EQ(stats.numEntries, 1);
+  ASSERT_EQ(stats.numHit, 1);
+}
+
+TEST_P(AsyncDataCacheTest, shrinkCache) {
+  constexpr uint64_t kRamBytes = 128UL << 20;
+  constexpr uint64_t kSsdBytes = 512UL << 20;
+  constexpr int kTinyDataSize = AsyncDataCacheEntry::kTinyDataSize - 1;
+  const int numEntries{10};
+  constexpr int kLargeDataSize = kTinyDataSize * 2;
+  ASSERT_LE(numEntries * (kTinyDataSize + kLargeDataSize), kRamBytes);
+
+  std::vector<RawFileCacheKey> tinyCacheKeys;
+  std::vector<RawFileCacheKey> largeCacheKeys;
+  std::vector<StringIdLease> fileLeases;
+  for (int i = 0; i < numEntries; ++i) {
+    fileLeases.emplace_back(
+        StringIdLease(fileIds(), fmt::format("shrinkCacheFile{}", i)));
+    tinyCacheKeys.emplace_back(RawFileCacheKey{fileLeases.back().id(), 0});
+    largeCacheKeys.emplace_back(
+        RawFileCacheKey{fileLeases.back().id(), kLargeDataSize});
+  }
+
+  struct {
+    bool shrinkAll;
+    bool hasSsd;
+    bool releaseAll;
+
+    std::string debugString() const {
+      return fmt::format(
+          "shrinkAll {}, hasSsd {}, releaseAll {}",
+          shrinkAll,
+          hasSsd,
+          releaseAll);
+    }
+  } testSettings[] = {
+      {true, false, false},
+      {true, true, false},
+      {true, false, true},
+      {true, true, true},
+      {false, false, true},
+      {false, true, true},
+      {false, false, false},
+      {false, true, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    initializeCache(kRamBytes, testData.hasSsd ? kSsdBytes : 0);
+    std::vector<CachePin> pins;
+    for (int i = 0; i < numEntries; ++i) {
+      auto tinyPin = cache_->findOrCreate(tinyCacheKeys[i], kTinyDataSize);
+      ASSERT_FALSE(tinyPin.empty());
+      ASSERT_TRUE(tinyPin.entry()->tinyData() != nullptr);
+      ASSERT_TRUE(tinyPin.entry()->data().empty());
+      ASSERT_FALSE(tinyPin.entry()->isPrefetch());
+      ASSERT_FALSE(tinyPin.entry()->ssdSaveable());
+      pins.push_back(std::move(tinyPin));
+      auto largePin = cache_->findOrCreate(largeCacheKeys[i], kLargeDataSize);
+      ASSERT_FALSE(largePin.entry()->tinyData() != nullptr);
+      ASSERT_FALSE(largePin.entry()->data().empty());
+      ASSERT_FALSE(largePin.entry()->isPrefetch());
+      ASSERT_FALSE(largePin.entry()->ssdSaveable());
+      pins.push_back(std::move(largePin));
+    }
+    auto stats = cache_->refreshStats();
+    ASSERT_EQ(stats.numEntries, numEntries * 2);
+    ASSERT_EQ(stats.numEmptyEntries, 0);
+    ASSERT_EQ(stats.numExclusive, numEntries * 2);
+    ASSERT_EQ(stats.numEvict, 0);
+    ASSERT_EQ(stats.numHit, 0);
+    ASSERT_EQ(stats.tinySize, kTinyDataSize * numEntries);
+    ASSERT_EQ(stats.largeSize, kLargeDataSize * numEntries);
+    ASSERT_EQ(stats.sharedPinnedBytes, 0);
+    ASSERT_GE(
+        stats.exclusivePinnedBytes,
+        (kTinyDataSize + kLargeDataSize) * numEntries);
+    ASSERT_EQ(stats.prefetchBytes, 0);
+    ASSERT_EQ(stats.numPrefetch, 0);
+
+    const auto numMappedPagesBeforeShrink = allocator_->numMapped();
+    ASSERT_GT(numMappedPagesBeforeShrink, 0);
+
+    // Everything gets pinged in memory.
+    VELOX_ASSERT_THROW(cache_->shrink(0), "");
+    ASSERT_EQ(cache_->shrink(testData.shrinkAll ? kRamBytes : 1), 0);
+
+    if (!testData.releaseAll) {
+      for (auto& pin : pins) {
+        pin.entry()->setExclusiveToShared();
+      }
+      pins.clear();
+      if (testData.shrinkAll) {
+        ASSERT_GE(
+            cache_->shrink(kRamBytes),
+            (kLargeDataSize + kTinyDataSize) * numEntries);
+      } else {
+        ASSERT_GE(cache_->shrink(2 * kTinyDataSize), kTinyDataSize);
+      }
+    } else {
+      pins.clear();
+      // We expect everything has been freed.
+      ASSERT_EQ(
+          cache_->shrink(testData.shrinkAll ? kRamBytes : 2 * kTinyDataSize),
+          0);
+    }
+    stats = cache_->refreshStats();
+    const auto numMappedPagesAfterShrink = allocator_->numMapped();
+    if (testData.shrinkAll || testData.releaseAll) {
+      ASSERT_EQ(stats.numEntries, 0);
+      ASSERT_EQ(stats.numEmptyEntries, 2 * numEntries);
+      ASSERT_EQ(stats.numExclusive, 0);
+      ASSERT_EQ(stats.numEvict, 2 * numEntries);
+      ASSERT_EQ(stats.numHit, 0);
+      ASSERT_EQ(stats.tinySize, 0);
+      ASSERT_EQ(stats.largeSize, 0);
+      ASSERT_EQ(stats.sharedPinnedBytes, 0);
+      ASSERT_GE(stats.exclusivePinnedBytes, 0);
+      ASSERT_EQ(stats.prefetchBytes, 0);
+      ASSERT_EQ(stats.numPrefetch, 0);
+      if (testData.shrinkAll) {
+        ASSERT_EQ(numMappedPagesAfterShrink, 0);
+      } else {
+        ASSERT_LT(numMappedPagesAfterShrink, numMappedPagesBeforeShrink);
+      }
+    } else {
+      ASSERT_LT(stats.numEntries, 2 * numEntries);
+      ASSERT_GT(stats.numEntries, 0);
+      ASSERT_GE(stats.numEmptyEntries, 1);
+      ASSERT_EQ(stats.numExclusive, 0);
+      ASSERT_GE(stats.numEvict, 1);
+      ASSERT_EQ(stats.numHit, 0);
+      ASSERT_GT(stats.tinySize, 0);
+      ASSERT_GT(stats.largeSize, 0);
+      ASSERT_EQ(stats.sharedPinnedBytes, 0);
+      ASSERT_GE(stats.exclusivePinnedBytes, 0);
+      ASSERT_EQ(stats.prefetchBytes, 0);
+      ASSERT_EQ(stats.numPrefetch, 0);
+      ASSERT_LT(numMappedPagesAfterShrink, numMappedPagesBeforeShrink);
+    }
+  }
+}
+
+TEST_P(AsyncDataCacheTest, shutdown) {
+  constexpr uint64_t kRamBytes = 16 << 20;
+  constexpr uint64_t kSsdBytes = 64UL << 20;
+
+  for (const auto asyncShutdown : {false, true}) {
+    SCOPED_TRACE(fmt::format("asyncShutdown {}", asyncShutdown));
+    // Initialize cache with a big checkpointIntervalBytes, giving eviction log
+    // chance to survive.
+    initializeCache(
+        kRamBytes,
+        kSsdBytes,
+        /*checkpointIntervalBytes=*/(1ULL << 30) * kNumSsdShards);
+    ASSERT_EQ(cache_->ssdCache()->stats().openCheckpointErrors, 4);
+
+    // Write large amount of data, making sure eviction is triggered and the log
+    // file is not zero.
+    loadLoop(0, 16 * kSsdBytes);
+    ASSERT_EQ(cache_->ssdCache()->stats().checkpointsWritten, 0);
+    ASSERT_GT(cache_->ssdCache()->stats().regionsEvicted, 0);
+    ASSERT_GT(cache_->ssdCache()->testingTotalLogEvictionFilesSize(), 0);
+
+    // Shutdown cache.
+    if (!asyncShutdown) {
+      waitForSsdWriteToFinish(cache_->ssdCache());
+    }
+    // NOTE: we need to wait for async load to complete before shutdown as async
+    // data cache doesn't handle the cache access after the cache shutdown.
+    if (loadExecutor_ != nullptr) {
+      loadExecutor_->join();
+      loadExecutor_.reset();
+    }
+    const uint64_t bytesWrittenBeforeShutdown =
+        cache_->ssdCache()->stats().bytesWritten;
+    cache_->ssdCache()->shutdown();
+    const uint64_t bytesWrittenAfterShutdown =
+        cache_->ssdCache()->stats().bytesWritten;
+
+    if (asyncShutdown) {
+      // The written bytes before shutdown is not larger than before shutdown.
+      ASSERT_LE(bytesWrittenBeforeShutdown, bytesWrittenAfterShutdown);
+    } else {
+      // No new data has been written after shutdown.
+      ASSERT_EQ(bytesWrittenBeforeShutdown, bytesWrittenAfterShutdown);
+    }
+    // Eviction log files have been truncated.
+    ASSERT_EQ(cache_->ssdCache()->testingTotalLogEvictionFilesSize(), 0);
+
+    // Shutdown again making sure no issue is triggered.
+    cache_->ssdCache()->shutdown();
+
+    // New cache write attempt is blocked and triggers exception.
+    VELOX_ASSERT_THROW(
+        cache_->ssdCache()->startWrite(),
+        "Unexpected write after SSD cache has been shutdown");
+
+    // Re-initialize cache.
+    cache_->ssdCache()->clear();
+    initializeCache(kRamBytes, kSsdBytes, kSsdBytes * 10);
+    // Checkpoint files are intact and readable.
+    ASSERT_EQ(cache_->ssdCache()->stats().openCheckpointErrors, 0);
+    ASSERT_EQ(cache_->ssdCache()->stats().readCheckpointErrors, 0);
+    cache_->ssdCache()->testingDeleteCheckpoints();
+  }
+}
+
+DEBUG_ONLY_TEST_P(AsyncDataCacheTest, shrinkWithSsdWrite) {
+  constexpr uint64_t kRamBytes = 128UL << 20;
+  constexpr uint64_t kSsdBytes = 512UL << 20;
+  constexpr int kDataSize = 4096;
+  initializeCache(kRamBytes, kSsdBytes);
+  const int numEntries{10};
+  std::vector<CachePin> cachePins;
+  uint64_t offset = 0;
+  for (int i = 0; i < numEntries; ++i) {
+    cachePins.push_back(newEntry(offset, kDataSize));
+    offset += kDataSize;
+  }
+  for (auto& pin : cachePins) {
+    pin.entry()->setExclusiveToShared();
+  }
+
+  std::atomic_bool writeStartFlag{false};
+  folly::EventCount writeStartWait;
+  std::atomic_bool writeWaitFlag{true};
+  folly::EventCount writeWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::cache::SsdCache::write",
+      std::function<void(const SsdCache*)>(([&](const SsdCache* cache) {
+        writeStartFlag = true;
+        writeStartWait.notifyAll();
+        writeWait.await([&]() { return !writeWaitFlag.load(); });
+      })));
+
+  // Starts a write thread running at background.
+  std::thread ssdWriteThread([&]() {
+    ASSERT_TRUE(cache_->ssdCache()->startWrite());
+    cache_->saveToSsd();
+  });
+
+  // Wait for the write thread to start, and block it while do cache shrink.
+  writeStartWait.await([&]() { return writeStartFlag.load(); });
+  ASSERT_TRUE(cache_->ssdCache()->writeInProgress());
+
+  cachePins.clear();
+  cache_->shrink(kRamBytes);
+  auto stats = cache_->refreshStats();
+  // Shrink can only reclaim some entries but not all as some of the cache
+  // entries have been pickup for ssd write which is not evictable.
+  ASSERT_LT(stats.numEntries, numEntries);
+  ASSERT_GT(stats.numEmptyEntries, 0);
+  ASSERT_GT(stats.numEvict, 0);
+  ASSERT_GT(stats.numShared, 0);
+  ASSERT_EQ(stats.numExclusive, 0);
+  ASSERT_EQ(stats.numWaitExclusive, 0);
+
+  // Wait for write to complete.
+  writeWaitFlag = false;
+  writeWait.notifyAll();
+  ssdWriteThread.join();
+  waitForSsdWriteToFinish(cache_->ssdCache());
+
+  stats = cache_->refreshStats();
+  ASSERT_GT(stats.numEntries, stats.numEmptyEntries);
+
+  ASSERT_GT(cache_->shrink(kRamBytes), 0);
+  stats = cache_->refreshStats();
+  ASSERT_EQ(stats.numEntries, 0);
+  ASSERT_EQ(stats.numEmptyEntries, numEntries);
+}
+
+DEBUG_ONLY_TEST_P(AsyncDataCacheTest, ttl) {
+  constexpr uint64_t kRamBytes = 32 << 20;
+  constexpr uint64_t kSsdBytes = 128UL << 20;
+
+  initializeCache(kRamBytes, kSsdBytes);
+  CacheTTLController::create(*cache_);
+
+  std::vector<int64_t> offsets(32);
+  std::generate(offsets.begin(), offsets.end(), [&, n = 0]() mutable {
+    return n += (kRamBytes / kNumFiles / offsets.size());
+  });
+
+  ScopedTestTime stt;
+  auto loadTime1 = getCurrentTimeSec();
+  auto loadTime2 = loadTime1 + 100;
+
+  stt.setCurrentTestTimeSec(loadTime1);
+  loadNFiles(filenames_.size() * 2 / 3, offsets);
+  waitForSsdWriteToFinish(cache_->ssdCache());
+  auto statsT1 = cache_->refreshStats();
+
+  stt.setCurrentTestTimeSec(loadTime2);
+  loadNFiles(filenames_.size(), offsets);
+
+  runThreads(2, [&](int32_t /*i*/) {
+    CacheTTLController::getInstance()->applyTTL(
+        getCurrentTimeSec() - loadTime1 - 2);
+  });
+
+  auto statsTtl = cache_->refreshStats();
+  EXPECT_EQ(statsTtl.numAgedOut, statsT1.numEntries);
+  EXPECT_EQ(statsTtl.ssdStats->entriesAgedOut, statsT1.ssdStats->entriesCached);
+}
+
+TEST_P(AsyncDataCacheTest, makeEvictable) {
+  constexpr uint64_t kRamBytes = 128UL << 20;
+  constexpr uint64_t kSsdBytes = 512UL << 20;
+  constexpr int kDataSize = 4096;
+  for (const bool evictable : {false, true}) {
+    SCOPED_TRACE(fmt::format("evictable: {}", evictable));
+    initializeCache(kRamBytes, kSsdBytes);
+    const int numEntries{10};
+    std::vector<CachePin> cachePins;
+    uint64_t offset = 0;
+    for (int i = 0; i < numEntries; ++i) {
+      cachePins.push_back(newEntry(offset, kDataSize));
+      offset += kDataSize;
+    }
+    for (auto& pin : cachePins) {
+      pin.entry()->setExclusiveToShared(!evictable);
+    }
+    if (evictable) {
+      std::vector<RawFileCacheKey> keys;
+      keys.reserve(cachePins.size());
+      for (const auto& pin : cachePins) {
+        keys.push_back(RawFileCacheKey{
+            pin.checkedEntry()->key().fileNum.id(),
+            pin.checkedEntry()->key().offset});
+      }
+      cachePins.clear();
+      for (const auto& key : keys) {
+        cache_->makeEvictable(key);
+      }
+    }
+    const auto cacheEntries = cache_->testingCacheEntries();
+    for (const auto& cacheEntry : cacheEntries) {
+      ASSERT_EQ(cacheEntry->ssdSaveable(), !evictable);
+      ASSERT_EQ(cacheEntry->testingAccessStats().numUses, 0);
+      if (evictable) {
+        ASSERT_EQ(cacheEntry->testingAccessStats().lastUse, 0);
+      } else {
+        ASSERT_NE(cacheEntry->testingAccessStats().lastUse, 0);
+      }
+    }
+    auto* ssdCache = cache_->ssdCache();
+    if (ssdCache == nullptr) {
+      continue;
+    }
+    ssdCache->waitForWriteToFinish();
+    if (evictable) {
+      ASSERT_EQ(ssdCache->stats().entriesCached, 0);
+    } else {
+      if (cache_->testingSsdSavable() == 0) {
+        ASSERT_GT(ssdCache->stats().entriesCached, 0);
+      } else {
+        // Ssd write only gets triggered after a certain ssd space usage
+        // threshold.
+        ASSERT_GE(ssdCache->stats().entriesCached, 0);
+      }
+    }
+  }
+}
+
+TEST_P(AsyncDataCacheTest, ssdWriteOptions) {
+  constexpr uint64_t kRamBytes = 16UL << 20; // 16 MB
+  constexpr uint64_t kSsdBytes = 64UL << 20; // 64 MB
+
+  // Test if ssd write behavior with different settings.
+  struct {
+    double maxWriteRatio;
+    double ssdSavableRatio;
+    int32_t minSsdSavableBytes;
+    bool expectedSaveToSsd;
+
+    std::string debugString() const {
+      return fmt::format(
+          "maxWriteRatio {}, ssdSavableRatio {}, minSsdSavableBytes {}, expectedSaveToSsd {}",
+          maxWriteRatio,
+          ssdSavableRatio,
+          minSsdSavableBytes,
+          expectedSaveToSsd);
+    }
+  } testSettings[] = {
+      {0.8, 0.95, 32UL << 20, false},
+      {0.8, 0.95, 4UL << 20, false},
+      {0.8, 0.3, 32UL << 20, false},
+      {0.8, 0.3, 4UL << 20, true},
+      {0.0, 0.95, 0, true}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    initializeCache(
+        kRamBytes,
+        kSsdBytes,
+        0,
+        true,
+        {testData.maxWriteRatio,
+         testData.ssdSavableRatio,
+         testData.minSsdSavableBytes});
+    // Load data half of the in-memory capacity.
+    loadLoop(0, kRamBytes / 2);
+    waitForPendingLoads();
+    auto stats = cache_->refreshStats();
+    if (testData.expectedSaveToSsd) {
+      EXPECT_GT(stats.ssdStats->entriesWritten, 0);
+    } else {
+      EXPECT_EQ(stats.ssdStats->entriesWritten, 0);
+    }
+    if (testData.maxWriteRatio < 0.0001) {
+      // SSD cache write stops right after the first entry in each shard.
+      // Only a few entries can be written.
+      EXPECT_LE(stats.ssdStats->entriesWritten, 20);
+    }
+  }
+}
+
+TEST_P(AsyncDataCacheTest, appendSsdSaveable) {
+  constexpr uint64_t kRamBytes = 64UL << 20; // 64 MB
+  constexpr uint64_t kSsdBytes = 128UL << 20; // 128 MB
+
+  // Test if ssd write behavior with different settings.
+  struct {
+    double maxWriteRatio;
+    double ssdSavableRatio;
+    int32_t minSsdSavableBytes;
+    bool appendAll;
+
+    std::string debugString() const {
+      return fmt::format(
+          "maxWriteRatio {}, ssdSavableRatio {}, minSsdSavableBytes {}, appendAll {}",
+          maxWriteRatio,
+          ssdSavableRatio,
+          minSsdSavableBytes,
+          appendAll);
+    }
+  } testSettings[] = {
+      {0.0, 10000.0, 1ULL << 30, true}, {0.0, 10000.0, 1UL << 30, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    initializeCache(
+        kRamBytes,
+        kSsdBytes,
+        /*checkpointIntervalBytes=*/1UL << 30,
+        /*eraseCheckpoint=*/true,
+        {testData.maxWriteRatio,
+         testData.ssdSavableRatio,
+         testData.minSsdSavableBytes});
+    // Load data half of the in-memory capacity.
+    loadLoop(0, kRamBytes / 2);
+    waitForPendingLoads();
+    auto stats = cache_->refreshStats();
+
+    ASSERT_TRUE(cache_->ssdCache()->startWrite());
+    cache_->saveToSsd(testData.appendAll);
+
+    cache_->ssdCache()->waitForWriteToFinish();
+    stats = cache_->refreshStats();
+    if (testData.appendAll) {
+      // There might be some cache evictions.
+      ASSERT_GE(stats.ssdStats->entriesWritten, stats.numEntries);
+    } else {
+      ASSERT_EQ(stats.ssdStats->entriesWritten, cache_->testingNumShards());
+    }
+  }
+}
+
+TEST_P(AsyncDataCacheTest, checkpoint) {
+  constexpr uint64_t kRamBytes = 16UL << 20; // 16 MB
+  constexpr uint64_t kSsdBytes = 64UL << 20; // 64 MB
+
+  initializeCache(
+      kRamBytes,
+      kSsdBytes,
+      /*checkpointIntervalBytes=*/1ULL << 30,
+      /*eraseCheckpoint=*/true);
+  // Load data half of the in-memory capacity.
+  loadLoop(0, kRamBytes / 2);
+  waitForPendingLoads();
+  auto stats = cache_->refreshStats();
+  ASSERT_EQ(stats.ssdStats->checkpointsWritten, 0);
+  ASSERT_TRUE(cache_->ssdCache()->startWrite());
+  cache_->ssdCache()->checkpoint();
+  cache_->ssdCache()->waitForWriteToFinish();
+  stats = cache_->refreshStats();
+  ASSERT_EQ(stats.ssdStats->checkpointsWritten, kNumSsdShards);
+}
+
+// TODO: add concurrent fuzzer test.
+
+INSTANTIATE_TEST_SUITE_P(
+    AsyncDataCacheTest,
+    AsyncDataCacheTest,
+    ::testing::ValuesIn(AsyncDataCacheTest::getTestParams()));
diff --git a/velox/common/caching/tests/CMakeLists.txt b/velox/common/caching/tests/CMakeLists.txt
index afe42f2b7087f..cc7fafe2a752e 100644
--- a/velox/common/caching/tests/CMakeLists.txt
+++ b/velox/common/caching/tests/CMakeLists.txt
@@ -14,24 +14,43 @@
 
 add_executable(simple_lru_cache_test SimpleLRUCacheTest.cpp)
 add_test(simple_lru_cache_test simple_lru_cache_test)
-target_link_libraries(simple_lru_cache_test PRIVATE Folly::folly glog::glog
-                                                    gtest gtest_main)
+target_link_libraries(
+  simple_lru_cache_test
+  PRIVATE
+    Folly::folly
+    velox_time
+    glog::glog
+    GTest::gtest
+    GTest::gtest_main)
 
-add_executable(velox_cache_test StringIdMapTest.cpp AsyncDataCacheTest.cpp
-                                SsdFileTest.cpp SsdFileTrackerTest.cpp)
+add_executable(
+  velox_cache_test
+  AsyncDataCacheTest.cpp
+  CacheTTLControllerTest.cpp
+  SsdFileTest.cpp
+  SsdFileTrackerTest.cpp
+  StringIdMapTest.cpp)
 add_test(velox_cache_test velox_cache_test)
 target_link_libraries(
   velox_cache_test
-  PRIVATE velox_caching
-          velox_file
-          velox_memory
-          velox_temp_path
-          Folly::folly
-          glog::glog
-          gtest
-          gtest_main)
+  PRIVATE
+    velox_caching
+    velox_file
+    velox_memory
+    velox_temp_path
+    Folly::folly
+    glog::glog
+    GTest::gtest
+    GTest::gtest_main)
 
 add_executable(cached_factory_test CachedFactoryTest.cpp)
 add_test(cached_factory_test cached_factory_test)
-target_link_libraries(cached_factory_test PRIVATE velox_process Folly::folly
-                                                  glog::glog gtest gtest_main)
+target_link_libraries(
+  cached_factory_test
+  PRIVATE
+    velox_process
+    Folly::folly
+    velox_time
+    glog::glog
+    GTest::gtest
+    GTest::gtest_main)
diff --git a/velox/common/caching/tests/CacheTTLControllerTest.cpp b/velox/common/caching/tests/CacheTTLControllerTest.cpp
new file mode 100644
index 0000000000000..6f7f39454af90
--- /dev/null
+++ b/velox/common/caching/tests/CacheTTLControllerTest.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/caching/CacheTTLController.h"
+
+#include "gtest/gtest.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/caching/AsyncDataCache.h"
+#include "velox/common/caching/SsdCache.h"
+#include "velox/common/memory/MmapAllocator.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::memory;
+
+namespace facebook::velox::cache {
+
+class CacheTTLControllerTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    allocator_ = std::make_shared<MmapAllocator>(
+        MmapAllocator::Options{.capacity = 1024L * 1024L});
+    cache_ = AsyncDataCache::create(allocator_.get());
+  }
+
+  std::shared_ptr<MemoryAllocator> allocator_;
+  std::shared_ptr<AsyncDataCache> cache_;
+};
+
+TEST_F(CacheTTLControllerTest, addOpenFileInfo) {
+  CacheTTLController::create(*cache_);
+
+  EXPECT_TRUE(CacheTTLController::getInstance()->addOpenFileInfo(123L));
+  EXPECT_FALSE(CacheTTLController::getInstance()->addOpenFileInfo(123L));
+
+  EXPECT_TRUE(CacheTTLController::getInstance()->addOpenFileInfo(456L));
+}
+
+TEST_F(CacheTTLControllerTest, getCacheAgeStats) {
+  CacheTTLController::create(*cache_);
+
+  int64_t fileOpenTime = getCurrentTimeSec();
+  for (auto i = 0; i < 1000; i++) {
+    CacheTTLController::getInstance()->addOpenFileInfo(i, fileOpenTime + i);
+  }
+
+  int64_t current = getCurrentTimeSec();
+  EXPECT_GE(
+      CacheTTLController::getInstance()->getCacheAgeStats().maxAgeSecs,
+      current - fileOpenTime);
+}
+} // namespace facebook::velox::cache
diff --git a/velox/common/caching/tests/CachedFactoryTest.cpp b/velox/common/caching/tests/CachedFactoryTest.cpp
index 4a04bf533735d..e8161a9792569 100644
--- a/velox/common/caching/tests/CachedFactoryTest.cpp
+++ b/velox/common/caching/tests/CachedFactoryTest.cpp
@@ -16,140 +16,167 @@
 
 #include "velox/common/caching/CachedFactory.h"
 
+#include "folly/Random.h"
 #include "folly/executors/EDFThreadPoolExecutor.h"
 #include "folly/executors/thread_factory/NamedThreadFactory.h"
 #include "folly/synchronization/Latch.h"
 #include "gtest/gtest.h"
+#include "velox/common/base/tests/GTestUtils.h"
 
 using namespace facebook::velox;
+
 namespace {
 
 struct DoublerGenerator {
-  int operator()(const int& value) {
-    ++generated_;
-    return value * 2;
+  std::unique_ptr<int> operator()(
+      const int& value,
+      const void* properties = nullptr) {
+    ++generated;
+    return std::make_unique<int>(value * 2);
   }
-  std::atomic<int> generated_ = 0;
+  std::atomic<int> generated = 0;
 };
 
-template <typename T>
-T getCachedValue(std::pair<bool, T>& value) {
-  return value.second;
-}
-
-template <typename T>
-bool isCached(std::pair<bool, T>& value) {
-  return value.first;
-}
-
-template <typename T>
-std::pair<bool, T> cacheHit(const T& value) {
-  return std::make_pair(true, value);
-}
-
-template <typename T>
-std::pair<bool, T> cacheMiss(const T& value) {
-  return std::make_pair(false, value);
-}
-
+struct IdentityGenerator {
+  std::unique_ptr<int> operator()(
+      const int& value,
+      const void* properties = nullptr) {
+    return std::make_unique<int>(value);
+  }
+};
 } // namespace
 
 TEST(CachedFactoryTest, basicGeneration) {
   auto generator = std::make_unique<DoublerGenerator>();
-  auto* generated = &generator->generated_;
+  auto* generated = &generator->generated;
   CachedFactory<int, int, DoublerGenerator> factory(
       std::make_unique<SimpleLRUCache<int, int>>(1000), std::move(generator));
-  EXPECT_EQ(factory.maxSize(), 1000);
+  ASSERT_EQ(factory.maxSize(), 1000);
+  ASSERT_EQ(factory.currentSize(), 0);
+
   {
     auto val1 = factory.generate(1);
-    EXPECT_EQ(val1, cacheMiss(2));
-    EXPECT_EQ(*generated, 1);
-
+    ASSERT_EQ(*val1, 2);
+    ASSERT_EQ(*generated, 1);
+    ASSERT_FALSE(val1.fromCache());
     auto val2 = factory.generate(1);
-    EXPECT_EQ(val2, cacheHit(2));
-    EXPECT_EQ(*generated, 1);
-    EXPECT_EQ(factory.currentSize(), 1);
+    ASSERT_EQ(*val2, 2);
+    ASSERT_EQ(*generated, 1);
+    ASSERT_TRUE(val2.fromCache());
+    ASSERT_EQ(factory.currentSize(), 1);
+    ASSERT_EQ(factory.cacheStats().pinnedSize, 1);
   }
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
+
   {
     auto val3 = factory.generate(1);
-    EXPECT_EQ(val3, cacheHit(2));
-    EXPECT_EQ(*generated, 1);
-
+    ASSERT_EQ(*val3, 2);
+    ASSERT_EQ(*generated, 1);
+    ASSERT_TRUE(val3.fromCache());
     auto val4 = factory.generate(2);
-    EXPECT_EQ(val4, cacheMiss(4));
-    EXPECT_EQ(*generated, 2);
-
+    ASSERT_EQ(*val4, 4);
+    ASSERT_EQ(*generated, 2);
+    ASSERT_FALSE(val4.fromCache());
     auto val5 = factory.generate(3);
-    EXPECT_EQ(val5, cacheMiss(6));
-    EXPECT_EQ(*generated, 3);
-    EXPECT_EQ(factory.currentSize(), 3);
+    ASSERT_EQ(*val5, 6);
+    ASSERT_EQ(*generated, 3);
+    ASSERT_FALSE(val5.fromCache());
+    ASSERT_EQ(factory.currentSize(), 3);
+    ASSERT_EQ(factory.cacheStats().pinnedSize, 3);
   }
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
 
-  auto val6 = factory.generate(1);
-  EXPECT_EQ(val6, cacheHit(2));
-  EXPECT_EQ(*generated, 3);
-
-  auto val7 = factory.generate(4);
-  EXPECT_EQ(val7, cacheMiss(8));
-  EXPECT_EQ(*generated, 4);
+  {
+    auto val6 = factory.generate(1);
+    ASSERT_EQ(*val6, 2);
+    ASSERT_EQ(*generated, 3);
+    ASSERT_TRUE(val6.fromCache());
+    auto val7 = factory.generate(4);
+    ASSERT_EQ(*val7, 8);
+    ASSERT_EQ(*generated, 4);
+    ASSERT_FALSE(val7.fromCache());
+    auto val8 = factory.generate(3);
+    ASSERT_EQ(*val8, 6);
+    ASSERT_EQ(*generated, 4);
+    ASSERT_TRUE(val8.fromCache());
+    ASSERT_EQ(factory.currentSize(), 4);
+    ASSERT_EQ(factory.cacheStats().pinnedSize, 3);
+  }
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
 
-  auto val8 = factory.generate(3);
-  EXPECT_EQ(val8, cacheHit(6));
-  EXPECT_EQ(*generated, 4);
-  EXPECT_EQ(factory.currentSize(), 4);
+  factory.clearCache();
+  ASSERT_EQ(factory.currentSize(), 0);
+  ASSERT_EQ(factory.cacheStats().curSize, 0);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
 }
 
 struct DoublerWithExceptionsGenerator {
-  int operator()(const int& value) {
+  std::unique_ptr<int> operator()(
+      const int& value,
+      const void* properties = nullptr) {
     if (value == 3) {
-      throw std::invalid_argument("3 is bad");
+      VELOX_FAIL("3 is bad");
     }
-    ++generated_;
-    return value * 2;
+    ++generated;
+    return std::make_unique<int>(value * 2);
   }
-  int generated_ = 0;
+  int generated = 0;
 };
 
 TEST(CachedFactoryTest, clearCache) {
   auto generator = std::make_unique<DoublerGenerator>();
   CachedFactory<int, int, DoublerGenerator> factory(
       std::make_unique<SimpleLRUCache<int, int>>(1000), std::move(generator));
-  EXPECT_EQ(factory.maxSize(), 1000);
+  ASSERT_EQ(factory.maxSize(), 1000);
   {
     auto val1 = factory.generate(1);
-    EXPECT_EQ(val1, cacheMiss(2));
+    ASSERT_FALSE(val1.fromCache());
   }
 
   factory.clearCache();
-  EXPECT_EQ(factory.currentSize(), 0);
-  EXPECT_EQ(factory.generate(1), cacheMiss(2));
+  ASSERT_EQ(factory.currentSize(), 0);
+
+  ASSERT_FALSE(factory.generate(1).fromCache());
+  auto cachedValue = factory.generate(1);
+  ASSERT_TRUE(cachedValue.fromCache());
+  ASSERT_FALSE(factory.generate(2).fromCache());
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 1);
+  ASSERT_EQ(factory.cacheStats().curSize, 2);
+
+  factory.clearCache();
+  ASSERT_EQ(factory.currentSize(), 1);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 1);
+
+  cachedValue.testingClear();
+  ASSERT_EQ(factory.currentSize(), 1);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
+
+  factory.clearCache();
+  ASSERT_EQ(factory.currentSize(), 0);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
 }
 
 TEST(CachedFactoryTest, basicExceptionHandling) {
   auto generator = std::make_unique<DoublerWithExceptionsGenerator>();
-  int* generated = &generator->generated_;
+  int* generated = &generator->generated;
   CachedFactory<int, int, DoublerWithExceptionsGenerator> factory(
       std::make_unique<SimpleLRUCache<int, int>>(1000), std::move(generator));
   auto val1 = factory.generate(1);
-  EXPECT_EQ(getCachedValue(val1), 2);
-  EXPECT_EQ(*generated, 1);
-  try {
-    auto val2 = factory.generate(3);
-    FAIL() << "Factory generation should have failed";
-  } catch (const std::invalid_argument& e) {
-    // Expected.
-  }
+  ASSERT_EQ(*val1, 2);
+  ASSERT_EQ(*generated, 1);
+  VELOX_ASSERT_THROW(factory.generate(3), "3 is bad");
+
   val1 = factory.generate(4);
-  EXPECT_EQ(getCachedValue(val1), 8);
-  EXPECT_EQ(*generated, 2);
+  ASSERT_EQ(*val1, 8);
+  ASSERT_EQ(*generated, 2);
   val1 = factory.generate(1);
-  EXPECT_EQ(getCachedValue(val1), 2);
-  EXPECT_EQ(*generated, 2);
+  ASSERT_EQ(*val1, 2);
+  ASSERT_EQ(*generated, 2);
 }
 
 TEST(CachedFactoryTest, multiThreadedGeneration) {
   auto generator = std::make_unique<DoublerGenerator>();
-  auto* generated = &generator->generated_;
+  auto* generated = &generator->generated;
   CachedFactory<int, int, DoublerGenerator> factory(
       std::make_unique<SimpleLRUCache<int, int>>(1000), std::move(generator));
   folly::EDFThreadPoolExecutor pool(
@@ -157,31 +184,31 @@ TEST(CachedFactoryTest, multiThreadedGeneration) {
   const int numValues = 5;
   const int requestsPerValue = 10;
   folly::Latch latch(numValues * requestsPerValue);
-  for (int i = 0; i < requestsPerValue; i++) {
-    for (int j = 0; j < numValues; j++) {
+  for (int i = 0; i < requestsPerValue; ++i) {
+    for (int j = 0; j < numValues; ++j) {
       pool.add([&, j]() {
         auto value = factory.generate(j);
-        EXPECT_EQ(getCachedValue(value), 2 * j);
+        CHECK_EQ(*value, 2 * j);
         latch.count_down();
       });
     }
   }
   latch.wait();
-  EXPECT_EQ(*generated, numValues);
+  ASSERT_EQ(*generated, numValues);
 }
 
-// Same as above, but we keep the returned CachedPtrs till the end
-// of the function.
+// Same as above, but we keep the returned CachedPtrs till the end of the
+// function.
 TEST(CachedFactoryTest, multiThreadedGenerationAgain) {
   auto generator = std::make_unique<DoublerGenerator>();
-  auto* generated = &generator->generated_;
+  auto* generated = &generator->generated;
   CachedFactory<int, int, DoublerGenerator> factory(
       std::make_unique<SimpleLRUCache<int, int>>(1000), std::move(generator));
   folly::EDFThreadPoolExecutor pool(
       100, std::make_shared<folly::NamedThreadFactory>("test_pool"));
   const int numValues = 5;
   const int requestsPerValue = 10;
-  std::vector<std::pair<bool, int>> cachedValues(numValues * requestsPerValue);
+  std::vector<CachedPtr<int, int>> cachedValues(numValues * requestsPerValue);
   folly::Latch latch(numValues * requestsPerValue);
   for (int i = 0; i < requestsPerValue; i++) {
     for (int j = 0; j < numValues; j++) {
@@ -195,33 +222,289 @@ TEST(CachedFactoryTest, multiThreadedGenerationAgain) {
   ASSERT_EQ(*generated, numValues);
   for (int i = 0; i < requestsPerValue; i++) {
     for (int j = 0; j < numValues; j++) {
-      EXPECT_EQ(getCachedValue(cachedValues[i * numValues + j]), 2 * j);
+      ASSERT_EQ(*cachedValues[i * numValues + j], 2 * j);
     }
   }
 }
 
+TEST(CachedFactoryTest, lruCacheEviction) {
+  auto generator = std::make_unique<DoublerGenerator>();
+  CachedFactory<int, int, DoublerGenerator> factory(
+      std::make_unique<SimpleLRUCache<int, int>>(3), std::move(generator));
+  ASSERT_EQ(factory.maxSize(), 3);
+  ASSERT_EQ(factory.currentSize(), 0);
+
+  auto val1 = factory.generate(1);
+  ASSERT_FALSE(val1.fromCache());
+  ASSERT_TRUE(val1.cached());
+  auto val2 = factory.generate(2);
+  ASSERT_FALSE(val2.fromCache());
+  ASSERT_TRUE(val2.cached());
+  auto val3 = factory.generate(3);
+  ASSERT_FALSE(val3.fromCache());
+  ASSERT_TRUE(val3.cached());
+  ASSERT_EQ(factory.currentSize(), 3);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 3);
+  auto val4 = factory.generate(4);
+  ASSERT_FALSE(val4.fromCache());
+  ASSERT_FALSE(val4.cached());
+
+  {
+    auto val = factory.generate(4);
+    ASSERT_FALSE(val.fromCache());
+    ASSERT_FALSE(val.cached());
+    val = factory.generate(1);
+    ASSERT_TRUE(val.fromCache());
+    ASSERT_TRUE(val.cached());
+    val = factory.generate(2);
+    ASSERT_TRUE(val.fromCache());
+    ASSERT_TRUE(val.cached());
+    val = factory.generate(3);
+    ASSERT_TRUE(val.fromCache());
+    ASSERT_TRUE(val.cached());
+  }
+  {
+    auto val = factory.generate(1);
+    ASSERT_TRUE(val.fromCache());
+    ASSERT_TRUE(val.cached());
+  }
+  val1.testingClear();
+  val2.testingClear();
+  val3.testingClear();
+
+  val4 = factory.generate(4);
+  ASSERT_FALSE(val4.fromCache());
+  ASSERT_TRUE(val4.cached());
+  ASSERT_EQ(factory.cacheStats().curSize, 3);
+  {
+    auto val = factory.generate(4);
+    ASSERT_TRUE(val.fromCache());
+    ASSERT_TRUE(val.cached());
+    val = factory.generate(1);
+    ASSERT_TRUE(val.fromCache());
+    ASSERT_TRUE(val.cached());
+    // Cache entry 2 should be selected for eviction.
+    val = factory.generate(2);
+    ASSERT_FALSE(val.fromCache());
+    ASSERT_TRUE(val.cached());
+    // Cache entry 2 insertion caused cache entry 3 eviction.
+    val = factory.generate(3);
+    ASSERT_FALSE(val.fromCache());
+    ASSERT_TRUE(val.cached());
+  }
+  ASSERT_EQ(factory.currentSize(), 3);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 1);
+}
+
+TEST(CachedFactoryTest, cacheExpiration) {
+  auto generator = std::make_unique<DoublerGenerator>();
+  CachedFactory<int, int, DoublerGenerator> factory(
+      std::make_unique<SimpleLRUCache<int, int>>(3, 1'000),
+      std::move(generator));
+  ASSERT_EQ(factory.maxSize(), 3);
+  ASSERT_EQ(factory.currentSize(), 0);
+
+  auto val1 = factory.generate(1);
+  ASSERT_FALSE(val1.fromCache());
+  ASSERT_TRUE(val1.cached());
+  auto val2 = factory.generate(2);
+  ASSERT_FALSE(val2.fromCache());
+  ASSERT_TRUE(val2.cached());
+  auto val3 = factory.generate(3);
+  ASSERT_FALSE(val3.fromCache());
+  ASSERT_TRUE(val3.cached());
+  ASSERT_EQ(factory.currentSize(), 3);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 3);
+  auto val4 = factory.generate(4);
+  ASSERT_FALSE(val4.fromCache());
+  ASSERT_FALSE(val4.cached());
+
+  std::this_thread::sleep_for(std::chrono::milliseconds{1'500});
+  ASSERT_EQ(factory.currentSize(), 3);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 3);
+
+  val4 = factory.generate(4);
+  ASSERT_FALSE(val4.fromCache());
+  ASSERT_FALSE(val4.cached());
+  ASSERT_EQ(factory.currentSize(), 3);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 3);
+
+  val1.testingClear();
+  ASSERT_EQ(factory.currentSize(), 2);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 2);
+
+  val4 = factory.generate(4);
+  ASSERT_FALSE(val4.fromCache());
+  ASSERT_TRUE(val4.cached());
+  ASSERT_EQ(factory.currentSize(), 3);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 3);
+
+  val2.testingClear();
+  val3.testingClear();
+  ASSERT_EQ(factory.currentSize(), 1);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 1);
+  val4.testingClear();
+  ASSERT_EQ(factory.currentSize(), 1);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
+
+  std::this_thread::sleep_for(std::chrono::milliseconds{1'500});
+
+  val1 = factory.generate(1);
+  ASSERT_FALSE(val1.fromCache());
+  ASSERT_TRUE(val1.cached());
+  ASSERT_EQ(factory.currentSize(), 1);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 1);
+}
+
 TEST(CachedFactoryTest, retrievedCached) {
   auto generator = std::make_unique<DoublerGenerator>();
-  auto* generated = &generator->generated_;
+  auto* generated = &generator->generated;
   CachedFactory<int, int, DoublerGenerator> factory(
       std::make_unique<SimpleLRUCache<int, int>>(1000), std::move(generator));
-  for (int i = 0; i < 10; i += 2)
+  for (int i = 0; i < 10; i += 2) {
     factory.generate(i);
-  EXPECT_EQ(*generated, 5);
+  }
+  ASSERT_EQ(*generated, 5);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
+  ASSERT_EQ(factory.cacheStats().curSize, 5);
+
   std::vector<int> keys(10);
-  for (int i = 0; i < 10; i += 1)
+  for (int i = 0; i < 10; ++i) {
     keys[i] = i;
-  std::vector<std::pair<int, int>> cached;
+    if (i % 2 == 0) {
+      ASSERT_EQ(*factory.get(keys[i]), i * 2) << i;
+    } else {
+      ASSERT_EQ(factory.get(keys[i]).get(), nullptr);
+    }
+  }
+  std::vector<std::pair<int, CachedPtr<int, int>>> cached;
   std::vector<int> missing;
-  factory.retrieveCached(keys, &cached, &missing);
-  ASSERT_EQ(5, cached.size());
+  factory.retrieveCached(keys, cached, missing);
+  ASSERT_EQ(cached.size(), 5);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 5);
+  ASSERT_EQ(factory.cacheStats().curSize, 5);
+
   for (int i = 0; i < 5; ++i) {
-    EXPECT_EQ(cached[i].first, 2 * i);
-    EXPECT_EQ(cached[i].second, 4 * i);
+    ASSERT_EQ(cached[i].first, 2 * i);
+    ASSERT_EQ(*cached[i].second, 4 * i);
+    ASSERT_TRUE(cached[i].second.fromCache());
   }
-  ASSERT_EQ(5, missing.size());
+  ASSERT_EQ(missing.size(), 5);
+
   for (int i = 0; i < 5; ++i) {
-    EXPECT_EQ(missing[i], 2 * i + 1);
+    ASSERT_EQ(missing[i], 2 * i + 1);
+  }
+  ASSERT_EQ(*generated, 5);
+}
+
+TEST(CachedFactoryTest, clearCacheWithManyEntries) {
+  auto generator = std::make_unique<DoublerGenerator>();
+  CachedFactory<int, int, DoublerGenerator> factory(
+      std::make_unique<SimpleLRUCache<int, int>>(1000), std::move(generator));
+  for (auto i = 0; i < 1000; ++i) {
+    factory.generate(i);
+  }
+  std::vector<int> keys(500);
+  for (int i = 0; i < 500; ++i) {
+    keys[i] = i;
+  }
+  {
+    std::vector<std::pair<int, CachedPtr<int, int>>> cached;
+    std::vector<int> missing;
+    factory.retrieveCached(keys, cached, missing);
+    ASSERT_EQ(cached.size(), 500);
+    auto cacheStats = factory.clearCache();
+    ASSERT_EQ(cacheStats.numElements, 500);
+    ASSERT_EQ(cacheStats.pinnedSize, 500);
+  }
+  auto cacheStats = factory.cacheStats();
+  ASSERT_EQ(cacheStats.numElements, 500);
+  ASSERT_EQ(cacheStats.pinnedSize, 0);
+
+  cacheStats = factory.clearCache();
+  ASSERT_EQ(cacheStats.numElements, 0);
+  ASSERT_EQ(cacheStats.pinnedSize, 0);
+}
+
+TEST(CachedFactoryTest, disableCache) {
+  auto generator = std::make_unique<DoublerGenerator>();
+  auto* generated = &generator->generated;
+  CachedFactory<int, int, DoublerGenerator> factory(std::move(generator));
+
+  auto val1 = factory.generate(1);
+  ASSERT_FALSE(val1.fromCache());
+  ASSERT_EQ(*generated, 1);
+  ASSERT_EQ(factory.currentSize(), 0);
+  ASSERT_EQ(factory.cacheStats().curSize, 0);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
+
+  auto val2 = factory.generate(1);
+  ASSERT_FALSE(val2.fromCache());
+  EXPECT_EQ(*generated, 2);
+  ASSERT_EQ(factory.currentSize(), 0);
+  ASSERT_EQ(factory.cacheStats().curSize, 0);
+  ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
+  ASSERT_EQ(factory.cacheStats().expireDurationMs, 0);
+
+  ASSERT_EQ(factory.maxSize(), 0);
+
+  EXPECT_EQ(factory.cacheStats(), SimpleLRUCacheStats{});
+
+  EXPECT_EQ(factory.clearCache(), SimpleLRUCacheStats{});
+
+  std::vector<int> keys(10);
+  for (int i = 0; i < 10; ++i) {
+    keys[i] = i;
+  }
+
+  std::vector<std::pair<int, CachedPtr<int, int>>> cached;
+  std::vector<int> missing;
+  factory.retrieveCached(keys, cached, missing);
+  ASSERT_EQ(cached.size(), 0);
+  ASSERT_EQ(missing.size(), 10);
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_EQ(missing[i], i);
+  }
+}
+
+TEST(CachedFactoryTest, fuzzer) {
+  const int numThreads = 32;
+  const int testDurationMs = 5'000;
+  const size_t expirationDurationMs = 1;
+  for (const bool expireCache : {false, true}) {
+    SCOPED_TRACE(fmt::format("expireCache: {}", expireCache));
+    auto generator = std::make_unique<IdentityGenerator>();
+    CachedFactory<int, int, IdentityGenerator> factory(
+        std::make_unique<SimpleLRUCache<int, int>>(
+            128, expireCache ? expirationDurationMs : 0),
+        std::move(generator));
+
+    std::vector<std::thread> threads;
+    threads.reserve(numThreads);
+    for (int i = 0; i < numThreads; ++i) {
+      threads.emplace_back([&factory, i]() {
+        folly::Random::DefaultGenerator rng(23 + i);
+        const auto startTimeMs = getCurrentTimeMs();
+        while (startTimeMs + testDurationMs > getCurrentTimeMs()) {
+          const auto key = folly::Random::rand32(rng) % 256;
+          const auto val = factory.generate(key);
+          if (val.fromCache()) {
+            ASSERT_TRUE(val.cached());
+            ASSERT_EQ(*val, key);
+          }
+          if (folly::Random::oneIn(4)) {
+            std::this_thread::sleep_for(std::chrono::microseconds{100});
+          }
+        }
+      });
+    }
+    for (auto& thread : threads) {
+      thread.join();
+    }
+    ASSERT_EQ(factory.cacheStats().pinnedSize, 0);
+    ASSERT_LE(factory.cacheStats().curSize, 128);
+    ASSERT_LE(factory.cacheStats().numElements, 128);
+    ASSERT_GT(factory.cacheStats().numHits, 0);
+    ASSERT_GT(factory.cacheStats().numLookups, 0);
   }
-  EXPECT_EQ(*generated, 5);
 }
diff --git a/velox/common/caching/tests/SimpleLRUCacheTest.cpp b/velox/common/caching/tests/SimpleLRUCacheTest.cpp
index c7e5b4a9a1001..9193d34d0fc0c 100644
--- a/velox/common/caching/tests/SimpleLRUCacheTest.cpp
+++ b/velox/common/caching/tests/SimpleLRUCacheTest.cpp
@@ -15,75 +15,238 @@
  */
 
 #include "velox/common/caching/SimpleLRUCache.h"
-#include <optional>
 
 #include "gtest/gtest.h"
 
 using namespace facebook::velox;
 
-namespace {
-void verifyCacheStats(
-    const SimpleLRUCacheStats& actual,
-    size_t maxSize,
-    size_t curSize,
-    size_t numHits,
-    size_t numLookups) {
-  SimpleLRUCacheStats expectedStats{maxSize, curSize, numHits, numLookups};
-  EXPECT_EQ(actual, expectedStats) << " Actual " << actual.toString()
-                                   << " Expected " << expectedStats.toString();
-}
-} // namespace
-
 TEST(SimpleLRUCache, basicCaching) {
   SimpleLRUCache<int, int> cache(1000);
 
-  EXPECT_FALSE(cache.get(1).has_value());
-  EXPECT_FALSE(cache.get(2).has_value());
-
-  verifyCacheStats(cache.getStats(), 1000, 0, 0, 2);
+  ASSERT_TRUE(cache.add(1, new int(11), 1));
+  int* value = cache.get(1);
+  ASSERT_NE(value, nullptr);
+  ASSERT_EQ(*value, 11);
+  cache.release(1);
 
-  int firstValue = 11;
-  ASSERT_TRUE(cache.add(1, firstValue));
-  auto value = cache.get(1);
-  ASSERT_EQ(value, std::make_optional(11));
-
-  int secondValue = 22;
-  ASSERT_TRUE(cache.add(2, secondValue));
-
-  verifyCacheStats(cache.getStats(), 1000, 2, 1, 3);
+  int* secondValue = new int(22);
+  ASSERT_TRUE(cache.addPinned(2, secondValue, 1));
+  *secondValue += 5;
+  cache.release(2);
 
   value = cache.get(1);
-  ASSERT_EQ(value, std::make_optional(11));
+  ASSERT_NE(value, nullptr);
+  ASSERT_EQ(*value, 11);
+  cache.release(1);
 
   value = cache.get(2);
-  ASSERT_EQ(value, std::make_optional(22));
+  ASSERT_NE(value, nullptr);
+  ASSERT_EQ(*value, 27);
+  cache.release(2);
 
   value = cache.get(1);
-  ASSERT_EQ(value, std::make_optional(11));
+  ASSERT_NE(value, nullptr);
+  ASSERT_EQ(*value, 11);
+  secondValue = cache.get(1);
+  ASSERT_EQ(value, secondValue);
+  cache.release(1);
+  cache.release(1);
+
+  ASSERT_EQ(
+      cache.stats().toString(),
+      "{\n  maxSize: 1000\n  expireDurationMs: 0\n  curSize: 2\n  pinnedSize: 0\n  numElements: 2\n  numHits: 5\n  numLookups: 5\n}\n");
+}
 
-  value = cache.get(2);
-  ASSERT_EQ(value, std::make_optional(22));
-  verifyCacheStats(cache.getStats(), 1000, 2, 5, 7);
+TEST(SimpleLRUCache, lruEviction) {
+  SimpleLRUCache<int, int> cache(3);
 
-  cache.clear();
-  verifyCacheStats(cache.getStats(), 1000, 0, 5, 7);
-  EXPECT_FALSE(cache.get(1).has_value());
-  EXPECT_FALSE(cache.get(2).has_value());
+  for (int i = 0; i < 3; ++i) {
+    ASSERT_TRUE(cache.add(i, new int(i), 1));
+  }
+  ASSERT_EQ(cache.stats().numElements, 3);
+  ASSERT_EQ(*cache.get(0), 0);
+  cache.release(0);
+
+  ASSERT_TRUE(cache.add(3, new int(3), 1));
+  ASSERT_EQ(*cache.get(0), 0);
+  cache.release(0);
+  ASSERT_EQ(cache.get(1), nullptr);
+  ASSERT_EQ(*cache.get(3), 3);
+  cache.release(3);
+  ASSERT_EQ(cache.stats().numElements, 3);
 }
 
 TEST(SimpleLRUCache, eviction) {
   SimpleLRUCache<int, int> cache(1000);
 
   for (int i = 0; i < 1010; ++i) {
-    ASSERT_TRUE(cache.add(i, i));
+    ASSERT_TRUE(cache.add(i, new int(i), 1));
   }
 
   for (int i = 0; i < 10; ++i) {
-    ASSERT_FALSE(cache.get(i).has_value());
+    ASSERT_EQ(cache.get(i), nullptr);
   }
-
   for (int i = 10; i < 1010; ++i) {
-    auto value = cache.get(i);
-    ASSERT_EQ(value, std::make_optional(i));
+    int* value = cache.get(i);
+    ASSERT_NE(value, nullptr);
+    ASSERT_EQ(*value, i);
+    cache.release(i);
+  }
+}
+
+TEST(SimpleLRUCache, pinnedEviction) {
+  SimpleLRUCache<int, int> cache(100);
+
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_TRUE(cache.addPinned(i, new int(i), 1));
+  }
+  for (int i = 10; i < 110; ++i) {
+    ASSERT_TRUE(cache.add(i, new int(i), 1));
+  }
+
+  for (int i = 0; i < 10; ++i) {
+    int* value = cache.get(i);
+    ASSERT_NE(value, nullptr);
+    ASSERT_EQ(*value, i);
+    cache.release(i);
+    cache.release(i); // Release the original pin too.
+  }
+  for (int i = 10; i < 20; ++i) {
+    ASSERT_EQ(cache.get(i), nullptr);
+  }
+  for (int i = 20; i < 110; ++i) {
+    int* value = cache.get(i);
+    ASSERT_NE(value, nullptr);
+    ASSERT_EQ(*value, i);
+    cache.release(i);
+  }
+}
+
+TEST(SimpleLRUCache, fullyPinned) {
+  SimpleLRUCache<int, int> cache(10);
+
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_TRUE(cache.addPinned(i, new int(i), 1));
+  }
+  for (int i = 10; i < 20; ++i) {
+    int* value = new int(i);
+    ASSERT_FALSE(cache.add(i, value, 1));
+    delete value;
+  }
+  for (int i = 20; i < 30; ++i) {
+    int* value = new int(i);
+    ASSERT_FALSE(cache.addPinned(i, value, 1));
+    delete value;
+  }
+
+  for (int i = 0; i < 10; ++i) {
+    int* value = cache.get(i);
+    ASSERT_NE(value, nullptr);
+    ASSERT_EQ(*value, i);
+    cache.release(i);
+    cache.release(i); // Release the original pin too.
+  }
+  for (int i = 10; i < 30; ++i) {
+    ASSERT_EQ(cache.get(i), nullptr);
+  }
+}
+
+TEST(SimpleLRUCache, size) {
+  SimpleLRUCache<int, int> cache(10);
+  ASSERT_EQ(cache.maxSize(), 10);
+
+  for (int i = 0; i < 5; ++i) {
+    ASSERT_TRUE(cache.addPinned(i, new int(i), 2));
+    ASSERT_EQ(cache.currentSize(), 2 * (i + 1));
+  }
+  int* value = new int(5);
+  ASSERT_FALSE(cache.addPinned(5, value, 1));
+
+  for (int i = 0; i < 5; ++i) {
+    cache.release(i);
+  }
+  ASSERT_TRUE(cache.addPinned(5, value, 10));
+  ASSERT_EQ(cache.currentSize(), 10);
+
+  for (int i = 0; i < 5; ++i) {
+    ASSERT_EQ(cache.get(i), nullptr);
+  }
+  cache.release(5);
+}
+
+TEST(SimpleLRUCache, insertLargerThanCacheFails) {
+  SimpleLRUCache<int, int> cache(10);
+
+  int* value = new int(42);
+  ASSERT_FALSE(cache.add(123, value, 11));
+  delete value;
+}
+
+TEST(SimpleLRUCache, expiredCacheEntries) {
+  SimpleLRUCache<int, int> cache(100, 1'000);
+
+  // Expires on insert new entry.
+  int* value1 = new int(42);
+  ASSERT_TRUE(cache.add(123, value1, 11));
+  ASSERT_EQ(cache.currentSize(), 11);
+  ASSERT_EQ(cache.get(123), value1);
+  cache.release(123);
+
+  std::this_thread::sleep_for(std::chrono::seconds{2});
+  ASSERT_EQ(cache.currentSize(), 11);
+
+  int* value2 = new int(32);
+  ASSERT_TRUE(cache.add(122, value2, 22));
+  ASSERT_EQ(cache.currentSize(), 22);
+  ASSERT_EQ(cache.get(123), nullptr);
+  ASSERT_EQ(cache.get(122), value2);
+  cache.release(122);
+
+  // Expires when get cache entry.
+  std::this_thread::sleep_for(std::chrono::seconds{2});
+  ASSERT_EQ(cache.currentSize(), 22);
+  ASSERT_EQ(cache.get(123), nullptr);
+  ASSERT_EQ(cache.currentSize(), 0);
+  ASSERT_EQ(cache.get(122), nullptr);
+  ASSERT_EQ(cache.currentSize(), 0);
+
+  // Expires when get the same cache entry.
+  value2 = new int(33);
+  ASSERT_TRUE(cache.add(124, value2, 11));
+  ASSERT_EQ(cache.currentSize(), 11);
+  ASSERT_EQ(cache.get(124), value2);
+  cache.release(124);
+  ASSERT_EQ(cache.currentSize(), 11);
+  std::this_thread::sleep_for(std::chrono::seconds{2});
+  ASSERT_EQ(cache.currentSize(), 11);
+  ASSERT_EQ(cache.get(124), nullptr);
+  ASSERT_EQ(cache.currentSize(), 0);
+
+  // Adds multiple entries.
+  int expectedCacheSize{0};
+  for (int i = 0; i < 10; ++i) {
+    int* value = new int(i);
+    ASSERT_TRUE(cache.add(i, value, i));
+    ASSERT_EQ(cache.get(i), value);
+    cache.release(i);
+    expectedCacheSize += i;
+    ASSERT_EQ(cache.currentSize(), expectedCacheSize);
   }
+  std::this_thread::sleep_for(std::chrono::seconds{2});
+  ASSERT_EQ(cache.currentSize(), expectedCacheSize);
+  ASSERT_EQ(cache.get(0), nullptr);
+  ASSERT_EQ(cache.currentSize(), 0);
+
+  // Expire on release.
+  value2 = new int(64);
+  ASSERT_TRUE(cache.addPinned(124, value2, 11));
+  ASSERT_EQ(cache.currentSize(), 11);
+  std::this_thread::sleep_for(std::chrono::seconds{2});
+  ASSERT_EQ(cache.currentSize(), 11);
+  ASSERT_EQ(*cache.get(124), 64);
+  cache.release(124);
+  ASSERT_EQ(cache.currentSize(), 11);
+  cache.release(124);
+  ASSERT_EQ(cache.currentSize(), 0);
+  ASSERT_EQ(cache.get(124), nullptr);
 }
diff --git a/velox/common/caching/tests/SsdFileTest.cpp b/velox/common/caching/tests/SsdFileTest.cpp
index 9e6dd666d48b6..fd2835596ad34 100644
--- a/velox/common/caching/tests/SsdFileTest.cpp
+++ b/velox/common/caching/tests/SsdFileTest.cpp
@@ -14,10 +14,13 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/caching/FileIds.h"
 #include "velox/common/caching/SsdCache.h"
+#include "velox/common/memory/Memory.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 
+#include <fcntl.h>
 #include <folly/executors/QueuedImmediateExecutor.h>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
@@ -41,32 +44,62 @@ class SsdFileTest : public testing::Test {
  protected:
   static constexpr int64_t kMB = 1 << 20;
 
+  void SetUp() override {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void TearDown() override {
     if (ssdFile_) {
-      ssdFile_->deleteFile();
+      ssdFile_->testingDeleteFile();
     }
     if (cache_) {
       cache_->shutdown();
     }
+    fileIds().testingReset();
   }
 
   void initializeCache(
-      int64_t maxBytes,
       int64_t ssdBytes = 0,
-      bool setNoCowFlag = false) {
+      uint64_t checkpointIntervalBytes = 0,
+      bool checksumEnabled = false,
+      bool checksumReadVerificationEnabled = false,
+      bool disableFileCow = false) {
     // tmpfs does not support O_DIRECT, so turn this off for testing.
     FLAGS_ssd_odirect = false;
-    cache_ = AsyncDataCache::create(MemoryAllocator::getInstance());
-
+    cache_ = AsyncDataCache::create(memory::memoryManager()->allocator());
     fileName_ = StringIdLease(fileIds(), "fileInStorage");
-
     tempDirectory_ = exec::test::TempDirectoryPath::create();
-    ssdFile_ = std::make_unique<SsdFile>(
-        fmt::format("{}/ssdtest", tempDirectory_->path),
+    initializeSsdFile(
+        ssdBytes,
+        checkpointIntervalBytes,
+        checksumEnabled,
+        checksumReadVerificationEnabled,
+        disableFileCow);
+  }
+
+  void initializeSsdFile(
+      int64_t ssdBytes = 0,
+      uint64_t checkpointIntervalBytes = 0,
+      bool checksumEnabled = false,
+      bool checksumReadVerificationEnabled = false,
+      bool disableFileCow = false) {
+    SsdFile::Config config(
+        fmt::format("{}/ssdtest", tempDirectory_->getPath()),
         0, // shardId
         bits::roundUp(ssdBytes, SsdFile::kRegionSize) / SsdFile::kRegionSize,
-        0, // checkpointInternalBytes
-        setNoCowFlag);
+        checkpointIntervalBytes,
+        disableFileCow,
+        checksumEnabled,
+        checksumReadVerificationEnabled);
+    ssdFile_ = std::make_unique<SsdFile>(config);
+  }
+
+  // Corrupts the file by invalidate the last 1/10th of its content.
+  void corruptSsdFile(const std::string& path) {
+    const auto fd = ::open(path.c_str(), O_WRONLY);
+    const auto size = ::lseek(fd, 0, SEEK_END);
+    ASSERT_EQ(ftruncate(fd, size / 10 * 9), 0);
+    ASSERT_EQ(ftruncate(fd, size), 0);
   }
 
   static void initializeContents(int64_t sequence, memory::Allocation& alloc) {
@@ -89,7 +122,10 @@ class SsdFileTest : public testing::Test {
 
   // Checks that the contents are consistent with what is set in
   // initializeContents.
-  static void checkContents(const memory::Allocation& alloc, int32_t numBytes) {
+  static void checkContents(
+      const memory::Allocation& alloc,
+      int32_t numBytes,
+      bool expectEqual = true) {
     bool first = true;
     int64_t sequence;
     int32_t bytesChecked = sizeof(int64_t);
@@ -107,18 +143,22 @@ class SsdFileTest : public testing::Test {
           if (bytesChecked >= numBytes) {
             return;
           }
-          ASSERT_EQ(ptr[offset], offset + sequence);
+          if (expectEqual) {
+            ASSERT_EQ(ptr[offset], offset + sequence);
+          } else {
+            ASSERT_NE(ptr[offset], offset + sequence);
+          }
         }
       }
     }
   }
 
-  // Gets consecutive entries from file 'fileId' starting at 'startOffset'  with
+  // Gets consecutive entries from file 'fileId' starting at 'startOffset' with
   // sizes between 'minSize' and 'maxSize'. Sizes start at 'minSize' and double
   // each time and go back to 'minSize' after exceeding 'maxSize'. This stops
   // after the total size has exceeded 'totalSize'. The entries are returned as
   // pins. The pins are exclusive for newly created entries and shared for
-  // existing ones. New entries are deterministically  initialized from 'fileId'
+  // existing ones. New entries are deterministically initialized from 'fileId'
   // and the entry's offset.
   std::vector<CachePin> makePins(
       uint64_t fileId,
@@ -166,8 +206,8 @@ class SsdFileTest : public testing::Test {
     std::vector<SsdPin> ssdPins;
     ssdPins.reserve(pins.size());
     for (auto& pin : pins) {
-      ssdPins.push_back(ssdFile_->find(
-          RawFileCacheKey{fileName_.id(), pin.entry()->key().offset}));
+      ssdPins.push_back(ssdFile_->find(RawFileCacheKey{
+          pin.entry()->key().fileNum.id(), pin.entry()->key().offset}));
       EXPECT_FALSE(ssdPins.back().empty());
     }
     ssdFile_->load(ssdPins, pins);
@@ -224,6 +264,33 @@ class SsdFileTest : public testing::Test {
     readAndCheckPins(pins);
   }
 
+  // Reads back the found entries and check their contents, return the number of
+  // entries found.
+  int32_t checkEntries(
+      const std::vector<TestEntry>& entries,
+      bool expectEqual = true) {
+    int32_t numFound = 0;
+    for (auto& entry : entries) {
+      std::vector<CachePin> pins;
+      pins.push_back(cache_->findOrCreate(
+          RawFileCacheKey{entry.key.fileNum.id(), entry.key.offset},
+          entry.size,
+          nullptr));
+      if (pins.back().entry()->isExclusive()) {
+        std::vector<SsdPin> ssdPins;
+        ssdPins.push_back(ssdFile_->find(
+            RawFileCacheKey{entry.key.fileNum.id(), entry.key.offset}));
+        if (!ssdPins.back().empty()) {
+          ++numFound;
+          ssdFile_->load(ssdPins, pins);
+          checkContents(
+              pins[0].entry()->data(), pins[0].entry()->size(), expectEqual);
+        }
+      }
+    }
+    return numFound;
+  }
+
   std::shared_ptr<exec::test::TempDirectoryPath> tempDirectory_;
 
   std::shared_ptr<AsyncDataCache> cache_;
@@ -235,7 +302,7 @@ class SsdFileTest : public testing::Test {
 TEST_F(SsdFileTest, writeAndRead) {
   constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
   std::vector<TestEntry> allEntries;
-  initializeCache(128 * kMB, kSsdSize);
+  initializeCache(kSsdSize);
   FLAGS_ssd_verify_write = true;
   for (auto startOffset = 0; startOffset <= kSsdSize - SsdFile::kRegionSize;
        startOffset += SsdFile::kRegionSize) {
@@ -275,9 +342,8 @@ TEST_F(SsdFileTest, writeAndRead) {
     }
   }
 
-  // We check howmany entries are found. The earliest writes will have been
+  // We check how many entries are found. The earliest writes will have been
   // evicted. We read back the found entries and check their contents.
-  int32_t numFound = 0;
   for (auto& entry : allEntries) {
     std::vector<CachePin> pins;
 
@@ -291,24 +357,452 @@ TEST_F(SsdFileTest, writeAndRead) {
       ssdPins.push_back(
           ssdFile_->find(RawFileCacheKey{fileName_.id(), entry.key.offset}));
       if (!ssdPins.back().empty()) {
-        ++numFound;
         ssdFile_->load(ssdPins, pins);
         checkContents(pins[0].entry()->data(), pins[0].entry()->size());
       }
     }
   }
+
+  // Test cache writes with different iobufs sizes.
+  for (int numPins : {0, 1, IOV_MAX - 1, IOV_MAX, IOV_MAX + 1}) {
+    SCOPED_TRACE(fmt::format("numPins: {}", numPins));
+    auto pins = makePins(fileName_.id(), 0, 4096, 4096, 4096 * numPins);
+    EXPECT_EQ(pins.size(), numPins);
+    ssdFile_->write(pins);
+    readAndCheckPins(pins);
+    pins.clear();
+  }
+}
+
+TEST_F(SsdFileTest, checkpoint) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  const uint64_t checkpointIntervalBytes = 5 * SsdFile::kRegionSize;
+  const auto fileNameAlt = StringIdLease(fileIds(), "fileInStorageAlt");
+  FLAGS_ssd_verify_write = true;
+  initializeCache(kSsdSize, checkpointIntervalBytes);
+
+  std::vector<TestEntry> allEntries;
+  for (auto startOffset = 0; startOffset <= kSsdSize - SsdFile::kRegionSize;
+       startOffset += SsdFile::kRegionSize) {
+    auto pins =
+        makePins(fileName_.id(), startOffset, 4096, 2048 * 1025, 62 * kMB);
+    // Each region has one entry from `fileNameAlt`.
+    pins.push_back(cache_->findOrCreate(
+        RawFileCacheKey{fileNameAlt.id(), (uint64_t)startOffset},
+        1024,
+        nullptr));
+    ssdFile_->write(pins);
+    for (auto& pin : pins) {
+      EXPECT_EQ(ssdFile_.get(), pin.entry()->ssdFile());
+      allEntries.emplace_back(
+          pin.entry()->key(), pin.entry()->ssdOffset(), pin.entry()->size());
+    };
+    readAndCheckPins(pins);
+  }
+  const auto originalRegionScores = ssdFile_->testingCopyScores();
+  EXPECT_EQ(originalRegionScores.size(), 16);
+
+  // Re-initialize SSD file from checkpoint.
+  ssdFile_->checkpoint(true);
+  initializeSsdFile(kSsdSize, checkpointIntervalBytes);
+  const auto recoveredRegionScores = ssdFile_->testingCopyScores();
+  EXPECT_EQ(recoveredRegionScores.size(), 16);
+  EXPECT_EQ(originalRegionScores, recoveredRegionScores);
+
+  // Reconstruct cache pins and check the recovered content from cache file.
+  for (auto startOffset = 0; startOffset <= kSsdSize - SsdFile::kRegionSize;
+       startOffset += SsdFile::kRegionSize) {
+    auto pins =
+        makePins(fileName_.id(), startOffset, 4096, 2048 * 1025, 62 * kMB);
+    pins.push_back(cache_->findOrCreate(
+        RawFileCacheKey{fileNameAlt.id(), (uint64_t)startOffset},
+        1024,
+        nullptr));
+    readAndCheckPins(pins);
+  }
+  // All entries can be found.
+  auto numEntriesFound = checkEntries(allEntries);
+  EXPECT_EQ(numEntriesFound, allEntries.size());
+
+  // Test removeFileEntries.
+  folly::F14FastSet<uint64_t> filesToRemove{fileName_.id()};
+  folly::F14FastSet<uint64_t> filesRetained{};
+  SsdCacheStats stats;
+  ssdFile_->updateStats(stats);
+  EXPECT_EQ(stats.entriesAgedOut, 0);
+  EXPECT_EQ(stats.regionsAgedOut, 0);
+  EXPECT_EQ(stats.regionsEvicted, 0);
+
+  // Block eviction.
+  auto ssdPins = pinAllRegions(allEntries);
+  ssdFile_->removeFileEntries(filesToRemove, filesRetained);
+  EXPECT_EQ(ssdFile_->testingNumWritableRegions(), 0);
+  EXPECT_EQ(filesRetained.size(), 1);
+  numEntriesFound = checkEntries(allEntries);
+  EXPECT_EQ(numEntriesFound, allEntries.size());
+  auto prevStats = stats;
+  stats.clear();
+  ssdFile_->updateStats(stats);
+  EXPECT_EQ(stats.entriesAgedOut - prevStats.entriesAgedOut, 0);
+  EXPECT_EQ(stats.regionsAgedOut - prevStats.regionsAgedOut, 0);
+  EXPECT_EQ(stats.regionsEvicted - prevStats.regionsEvicted, 0);
+
+  // Unblock eviction.
+  ssdPins.clear();
+  filesRetained.clear();
+  ssdFile_->removeFileEntries(filesToRemove, filesRetained);
+  // All regions have been evicted and marked as writable.
+  EXPECT_EQ(ssdFile_->testingNumWritableRegions(), 16);
+  EXPECT_EQ(filesRetained.size(), 0);
+  numEntriesFound = checkEntries(allEntries);
+  EXPECT_EQ(numEntriesFound, 0);
+  prevStats = stats;
+  stats.clear();
+  ssdFile_->updateStats(stats);
+  EXPECT_EQ(
+      stats.entriesAgedOut - prevStats.entriesAgedOut, allEntries.size() - 16);
+  EXPECT_EQ(stats.regionsAgedOut - prevStats.regionsAgedOut, 16);
+  EXPECT_EQ(stats.regionsEvicted - prevStats.regionsEvicted, 16);
+
+  // Re-initialize SSD file from checkpoint. Since all regions were evicted, no
+  // entries should be found.
+  initializeSsdFile(kSsdSize, checkpointIntervalBytes);
+  numEntriesFound = checkEntries(allEntries);
+  EXPECT_EQ(numEntriesFound, 0);
+}
+
+TEST_F(SsdFileTest, fileCorruption) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  const uint64_t checkpointIntervalBytes = 5 * SsdFile::kRegionSize;
+  FLAGS_ssd_verify_write = true;
+
+  const auto populateCache = [&](std::vector<TestEntry>& entries) {
+    entries.clear();
+    for (auto startOffset = 0; startOffset <= kSsdSize - SsdFile::kRegionSize;
+         startOffset += SsdFile::kRegionSize) {
+      auto pins =
+          makePins(fileName_.id(), startOffset, 4096, 2048 * 1025, 62 * kMB);
+      ssdFile_->write(pins);
+      for (auto& pin : pins) {
+        EXPECT_EQ(ssdFile_.get(), pin.entry()->ssdFile());
+        entries.emplace_back(
+            pin.entry()->key(), pin.entry()->ssdOffset(), pin.entry()->size());
+      };
+    }
+  };
+
+  // Initialize cache with checksum write enabled.
+  initializeCache(kSsdSize, checkpointIntervalBytes, true, true);
+  std::vector<TestEntry> allEntries;
+  populateCache(allEntries);
+  // All entries can be found.
+  EXPECT_EQ(checkEntries(allEntries), allEntries.size());
+  SsdCacheStats stats;
+  ssdFile_->updateStats(stats);
+  EXPECT_EQ(stats.readSsdCorruptions, 0);
+
+  // Corrupt the SSD file, initialize the cache from checkpoint without read
+  // verification.
+  ssdFile_->checkpoint(true);
+  corruptSsdFile(fmt::format("{}/ssdtest", tempDirectory_->getPath()));
+  initializeSsdFile(kSsdSize, checkpointIntervalBytes, true, false);
+  // Cache can be loaded but the data of the last part is corrupted.
+  EXPECT_EQ(checkEntries({allEntries.begin(), allEntries.begin() + 100}), 100);
+  EXPECT_EQ(
+      checkEntries({allEntries.end() - 100, allEntries.end()}, false), 100);
+  // Corrupt the SSD file, initialize the cache from checkpoint with read
+  // verification enabled.
+  ssdFile_->checkpoint(true);
+  initializeSsdFile(kSsdSize, checkpointIntervalBytes, true, true);
+  // Entries at the front are still loadable.
+  EXPECT_EQ(checkEntries({allEntries.begin(), allEntries.begin() + 100}), 100);
+  stats.clear();
+  ssdFile_->updateStats(stats);
+  EXPECT_EQ(stats.readSsdCorruptions, 0);
+  // The last 1/10 entries are corrupted and cannot be loaded.
+  VELOX_ASSERT_THROW(checkEntries(allEntries), "Corrupt SSD cache entry");
+  stats.clear();
+  ssdFile_->updateStats(stats);
+  EXPECT_GT(stats.readSsdCorruptions, 0);
+  // New entries can be written.
+  populateCache(allEntries);
+
+  // Corrupt the Checkpoint file. Cache cannot be recovered. All entries are
+  // lost.
+  ssdFile_->checkpoint(true);
+  corruptSsdFile(ssdFile_->getCheckpointFilePath());
+  stats.clear();
+  ssdFile_->updateStats(stats);
+  EXPECT_EQ(stats.readCheckpointErrors, 0);
+  initializeSsdFile(kSsdSize, checkpointIntervalBytes, true, true);
+  EXPECT_EQ(checkEntries(allEntries), 0);
+  stats.clear();
+  ssdFile_->updateStats(stats);
+  EXPECT_EQ(stats.readCheckpointErrors, 1);
+  // New entries can be written.
+  populateCache(allEntries);
+}
+
+TEST_F(SsdFileTest, recoverFromCheckpointWithChecksum) {
+  constexpr int64_t kSsdSize = 4 * SsdFile::kRegionSize;
+  const uint64_t checkpointIntervalBytes = 3 * SsdFile::kRegionSize;
+  FLAGS_ssd_verify_write = true;
+
+  // Test if cache data can be recovered with different settings.
+  struct {
+    bool writeEnabled;
+    bool readVerificationEnabled;
+    bool writeEnabledOnRecovery;
+    bool readVerificationEnabledOnRecovery;
+    bool expectedReadVerificationEnabled;
+    bool expectedReadVerificationEnabledOnRecovery;
+    bool expectedCheckpointOnRecovery;
+
+    std::string debugString() const {
+      return fmt::format(
+          "writeEnabled {}, readVerificationEnabled {}, writeEnabledOnRecovery {}, readVerificationEnabledOnRecovery {}, expectedReadVerificationEnabled {}, expectedReadVerificationEnabledOnRecovery {}, expectedCheckpointOnRecovery {}",
+          writeEnabled,
+          readVerificationEnabled,
+          writeEnabledOnRecovery,
+          readVerificationEnabledOnRecovery,
+          expectedReadVerificationEnabled,
+          expectedReadVerificationEnabledOnRecovery,
+          expectedCheckpointOnRecovery);
+    }
+  } testSettings[] = {
+      {false, false, false, false, false, false, true},
+      {false, false, false, true, false, false, true},
+      {false, false, true, false, false, false, false},
+      {false, false, true, true, false, true, false},
+      {false, true, false, false, false, false, true},
+      {false, true, false, true, false, false, true},
+      {false, true, true, false, false, false, false},
+      {false, true, true, true, false, true, false},
+      {true, false, false, false, false, false, true},
+      {true, false, false, true, false, false, true},
+      {true, false, true, false, false, false, true},
+      {true, false, true, true, false, true, true},
+      {true, true, false, false, true, false, true},
+      {true, true, false, true, true, false, true},
+      {true, true, true, false, true, false, true},
+      {true, true, true, true, true, true, true}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    // Initialize cache with checksum write enabled/disabled.
+    initializeCache(
+        kSsdSize,
+        checkpointIntervalBytes,
+        testData.writeEnabled,
+        testData.readVerificationEnabled);
+    EXPECT_EQ(
+        ssdFile_->testingChecksumReadVerificationEnabled(),
+        testData.expectedReadVerificationEnabled);
+
+    // Populate the cache with some entries.
+    std::vector<TestEntry> allEntries;
+    for (auto startOffset = 0; startOffset <= kSsdSize - SsdFile::kRegionSize;
+         startOffset += SsdFile::kRegionSize) {
+      auto pins =
+          makePins(fileName_.id(), startOffset, 4096, 2048 * 1025, 62 * kMB);
+      ssdFile_->write(pins);
+      for (auto& pin : pins) {
+        EXPECT_EQ(ssdFile_.get(), pin.entry()->ssdFile());
+        allEntries.emplace_back(
+            pin.entry()->key(), pin.entry()->ssdOffset(), pin.entry()->size());
+      };
+    }
+    // All entries can be found.
+    EXPECT_EQ(checkEntries(allEntries), allEntries.size());
+
+    SsdCacheStats stats;
+    ssdFile_->updateStats(stats);
+    VELOX_CHECK_GT(stats.bytesCached, 0);
+    VELOX_CHECK_GT(stats.regionsCached, 0);
+    VELOX_CHECK_GT(stats.entriesCached, 0);
+
+    // Try reinitializing cache from checkpoint with read verification
+    // enabled/disabled.
+    ssdFile_->checkpoint(true);
+
+    SsdCacheStats statsAfterCheckpoint;
+    ssdFile_->updateStats(statsAfterCheckpoint);
+    ASSERT_EQ(statsAfterCheckpoint.bytesCached, stats.bytesCached);
+    ASSERT_EQ(statsAfterCheckpoint.regionsCached, stats.regionsCached);
+    ASSERT_EQ(statsAfterCheckpoint.entriesCached, stats.entriesCached);
+
+    initializeSsdFile(
+        kSsdSize,
+        checkpointIntervalBytes,
+        testData.writeEnabledOnRecovery,
+        testData.readVerificationEnabledOnRecovery);
+
+    SsdCacheStats statsAfterRecover;
+    ssdFile_->updateStats(statsAfterRecover);
+    if (testData.expectedCheckpointOnRecovery) {
+      ASSERT_EQ(statsAfterRecover.bytesCached, stats.bytesCached);
+      ASSERT_EQ(statsAfterRecover.regionsCached, stats.regionsCached);
+      ASSERT_EQ(statsAfterRecover.entriesCached, stats.entriesCached);
+    } else {
+      ASSERT_EQ(statsAfterRecover.bytesCached, 0);
+      ASSERT_EQ(statsAfterRecover.regionsCached, stats.regionsCached);
+      ASSERT_EQ(statsAfterRecover.entriesCached, 0);
+    }
+
+    EXPECT_EQ(
+        ssdFile_->testingChecksumReadVerificationEnabled(),
+        testData.expectedReadVerificationEnabledOnRecovery);
+
+    // Check if cache data is recoverable as expected.
+    if (testData.expectedCheckpointOnRecovery) {
+      EXPECT_EQ(checkEntries(allEntries), allEntries.size());
+    } else {
+      EXPECT_EQ(checkEntries(allEntries), 0);
+    }
+    cache_->shutdown();
+    memory::MemoryManager::testingSetInstance({});
+  }
+}
+
+TEST_F(SsdFileTest, recoverWithEvictedEntries) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  const uint64_t checkpointIntervalBytes = 5 * SsdFile::kRegionSize;
+  const auto retainFile =
+      StringIdLease(fileIds(), "recoverWithEvictedEntries.Retained");
+  const auto evictFile =
+      StringIdLease(fileIds(), "recoverWithEvictedEntries.Evicted");
+  initializeCache(kSsdSize, checkpointIntervalBytes);
+
+  std::vector<TestEntry> allEntries;
+  uint32_t retainedCacheEntries{0};
+  uint64_t retainedCacheSize{0};
+  for (auto startOffset = 0; startOffset <= kSsdSize / 2 - SsdFile::kRegionSize;
+       startOffset += SsdFile::kRegionSize) {
+    auto pins = makePins(
+        retainFile.id(),
+        startOffset,
+        4096,
+        2048 * 1025,
+        SsdFile::kRegionSize / 2);
+    for (const auto& pin : pins) {
+      ++retainedCacheEntries;
+      retainedCacheSize += pin.entry()->size();
+    }
+    ssdFile_->write(pins);
+    readAndCheckPins(pins);
+  }
+
+  uint32_t evictedCacheEntries{0};
+  uint64_t evictedCacheSize{0};
+  for (auto startOffset = kSsdSize / 2;
+       startOffset <= kSsdSize - SsdFile::kRegionSize;
+       startOffset += SsdFile::kRegionSize) {
+    auto pins = makePins(
+        evictFile.id(),
+        startOffset + SsdFile::kRegionSize,
+        4096,
+        2048 * 1025,
+        SsdFile::kRegionSize / 2);
+    for (const auto& pin : pins) {
+      ++evictedCacheEntries;
+      evictedCacheSize += pin.entry()->size();
+    }
+    ssdFile_->write(pins);
+    readAndCheckPins(pins);
+  }
+
+  SsdCacheStats stats;
+  ssdFile_->updateStats(stats);
+  ASSERT_EQ(stats.bytesCached, retainedCacheSize + evictedCacheSize);
+  ASSERT_EQ(stats.regionsCached, 9);
+  ASSERT_EQ(stats.entriesCached, retainedCacheEntries + evictedCacheEntries);
+
+  // Remove one file from the ssd cache.
+  folly::F14FastSet<uint64_t> retainedFileIds;
+  ssdFile_->removeFileEntries({evictFile.id()}, retainedFileIds);
+  ASSERT_TRUE(retainedFileIds.empty());
+
+  stats.clear();
+  ssdFile_->updateStats(stats);
+  // NOTE: remove file entries might erase region which has space utilization
+  // below certain threshold.
+  ASSERT_LE(stats.bytesCached, retainedCacheSize);
+  ASSERT_LE(stats.regionsCached, 9);
+  ASSERT_LE(stats.entriesCached, retainedCacheEntries);
+
+  // Re-initialize SSD file from checkpoint.
+  ssdFile_->checkpoint(true);
+  initializeSsdFile(kSsdSize, checkpointIntervalBytes);
+
+  SsdCacheStats statsAfterRecovery;
+  ssdFile_->updateStats(statsAfterRecovery);
+  ASSERT_EQ(statsAfterRecovery.bytesCached, stats.bytesCached);
+  ASSERT_EQ(statsAfterRecovery.regionsCached, stats.regionsCached);
+  ASSERT_EQ(statsAfterRecovery.entriesCached, stats.entriesCached);
+}
+
+TEST_F(SsdFileTest, ssdReadWithoutChecksumCheck) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+
+  // Initialize cache with checksum read/write enabled.
+  initializeCache(kSsdSize, 0, true, true);
+
+  // Test with one SSD cache entry only.
+  auto pins = makePins(fileName_.id(), 0, 4096, 4096, 4096);
+  ssdFile_->write(pins);
+  ASSERT_EQ(pins.size(), 1);
+  pins.back().entry()->setExclusiveToShared();
+  SsdCacheStats stats;
+  ssdFile_->updateStats(stats);
+  ASSERT_EQ(stats.readWithoutChecksumChecks, 0);
+
+  std::vector<TestEntry> entries;
+  for (auto& pin : pins) {
+    ASSERT_EQ(ssdFile_.get(), pin.entry()->ssdFile());
+    entries.emplace_back(
+        pin.entry()->key(), pin.entry()->ssdOffset(), pin.entry()->size());
+  };
+  std::vector<TestEntry> shortEntries;
+  for (auto& pin : pins) {
+    ASSERT_EQ(ssdFile_.get(), pin.entry()->ssdFile());
+    shortEntries.emplace_back(
+        pin.entry()->key(), pin.entry()->ssdOffset(), pin.entry()->size() / 2);
+  };
+
+  pins.clear();
+  cache_->clear();
+  ASSERT_EQ(cache_->refreshStats().numEntries, 0);
+
+  ASSERT_EQ(checkEntries(entries), entries.size());
+  stats.clear();
+  ssdFile_->updateStats(stats);
+  ASSERT_EQ(stats.readWithoutChecksumChecks, 0);
+
+  cache_->clear();
+  ASSERT_EQ(cache_->refreshStats().numEntries, 0);
+
+  stats.clear();
+#ifndef NDEBUG
+  VELOX_ASSERT_THROW(checkEntries(shortEntries), "");
+  ssdFile_->updateStats(stats);
+  ASSERT_EQ(stats.readWithoutChecksumChecks, 0);
+#else
+  ASSERT_EQ(checkEntries(shortEntries), shortEntries.size());
+  ssdFile_->updateStats(stats);
+  ASSERT_EQ(stats.readWithoutChecksumChecks, 1);
+#endif
 }
 
 #ifdef VELOX_SSD_FILE_TEST_SET_NO_COW_FLAG
 TEST_F(SsdFileTest, disabledCow) {
   constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
-  initializeCache(128 * kMB, kSsdSize, true);
+  initializeCache(kSsdSize, 0, false, false, true);
   EXPECT_TRUE(ssdFile_->testingIsCowDisabled());
 }
 
 TEST_F(SsdFileTest, notDisabledCow) {
   constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
-  initializeCache(128 * kMB, kSsdSize, false);
+  initializeCache(kSsdSize, 0, false, false, false);
   EXPECT_FALSE(ssdFile_->testingIsCowDisabled());
 }
 #endif // VELOX_SSD_FILE_TEST_SET_NO_COW_FLAG
diff --git a/velox/common/caching/tests/SsdFileTrackerTest.cpp b/velox/common/caching/tests/SsdFileTrackerTest.cpp
index eb21084a32298..851c72773747d 100644
--- a/velox/common/caching/tests/SsdFileTrackerTest.cpp
+++ b/velox/common/caching/tests/SsdFileTrackerTest.cpp
@@ -48,4 +48,23 @@ TEST(SsdFileTrackerTest, tracker) {
       tracker.findEvictionCandidates(kNumRegions, kNumRegions, pins);
   std::vector<int32_t> expected{0, 1, 4, 5, 6, 7, 8, 9};
   EXPECT_EQ(candidates, expected);
+
+  // Test large region scores.
+  tracker.clear();
+  for (auto region = 0; region < kNumRegions; ++region) {
+    tracker.regionRead(region, INT32_MAX);
+    tracker.regionRead(region, region * 100'000'000);
+  }
+  for (int i = 0; i < 999; ++i) {
+    for (auto region = 0; region < kNumRegions; ++region) {
+      tracker.regionFilled(region);
+    }
+  }
+  for (const auto score : tracker.copyScores()) {
+    EXPECT_TRUE(std::isinf(score));
+  }
+  // Mark all regions to be evictable.
+  std::fill(pins.begin(), pins.end(), 0);
+  candidates = tracker.findEvictionCandidates(3, kNumRegions, pins);
+  EXPECT_EQ(candidates.size(), 3);
 }
diff --git a/velox/common/caching/tests/StringIdMapTest.cpp b/velox/common/caching/tests/StringIdMapTest.cpp
index 3c1d319fc8855..59d95af2e88a1 100644
--- a/velox/common/caching/tests/StringIdMapTest.cpp
+++ b/velox/common/caching/tests/StringIdMapTest.cpp
@@ -17,6 +17,7 @@
 #include "velox/common/caching/StringIdMap.h"
 
 #include "gtest/gtest.h"
+#include "velox/common/base/tests/GTestUtils.h"
 
 using namespace facebook::velox;
 
@@ -53,3 +54,52 @@ TEST(StringIdMapTest, rehash) {
     EXPECT_EQ(ids[i].id(), StringIdLease(map, name).id());
   }
 }
+
+TEST(StringIdMapTest, recover) {
+  constexpr const char* kRecoverFile1 = "file_1";
+  constexpr const char* kRecoverFile2 = "file_2";
+  constexpr const char* kRecoverFile3 = "file_3";
+  StringIdMap map;
+  const uint64_t recoverId1{10};
+  const uint64_t recoverId2{20};
+  {
+    StringIdLease lease(map, recoverId1, kRecoverFile1);
+    ASSERT_TRUE(lease.hasValue());
+    ASSERT_EQ(map.pinnedSize(), ::strlen(kRecoverFile1));
+    ASSERT_EQ(map.testingLastId(), recoverId1);
+    VELOX_ASSERT_THROW(
+        std::make_unique<StringIdLease>(map, recoverId1, kRecoverFile2),
+        "(1 vs. 0) Reused recover id 10 assigned to file_2");
+    VELOX_ASSERT_THROW(
+        std::make_unique<StringIdLease>(map, recoverId2, kRecoverFile1),
+        "(20 vs. 10) Multiple recover ids assigned to file_1");
+  }
+  ASSERT_EQ(map.pinnedSize(), 0);
+
+  StringIdLease lease1(map, kRecoverFile1);
+  ASSERT_EQ(map.pinnedSize(), ::strlen(kRecoverFile1));
+  ASSERT_EQ(map.testingLastId(), recoverId1 + 1);
+
+  {
+    StringIdLease lease(map, recoverId2, kRecoverFile2);
+    ASSERT_TRUE(lease.hasValue());
+    ASSERT_EQ(lease.id(), recoverId2);
+    ASSERT_EQ(
+        map.pinnedSize(), ::strlen(kRecoverFile1) + ::strlen(kRecoverFile2));
+    ASSERT_EQ(map.testingLastId(), recoverId2);
+    VELOX_ASSERT_THROW(
+        std::make_unique<StringIdLease>(map, recoverId2, kRecoverFile3),
+        "(1 vs. 0) Reused recover id 20 assigned to file_3");
+    VELOX_ASSERT_THROW(
+        std::make_unique<StringIdLease>(map, recoverId2, kRecoverFile1),
+        "(20 vs. 11) Multiple recover ids assigned to file_1");
+    StringIdLease dupLease(map, recoverId2, kRecoverFile2);
+    ASSERT_TRUE(lease.hasValue());
+    ASSERT_EQ(lease.id(), recoverId2);
+    ASSERT_EQ(
+        map.pinnedSize(), ::strlen(kRecoverFile1) + ::strlen(kRecoverFile2));
+  }
+
+  ASSERT_EQ(map.testingLastId(), recoverId2);
+  ASSERT_EQ(map.pinnedSize(), ::strlen(kRecoverFile1));
+}
diff --git a/velox/common/compression/CMakeLists.txt b/velox/common/compression/CMakeLists.txt
index e429485151e35..25835c26c4bbd 100644
--- a/velox/common/compression/CMakeLists.txt
+++ b/velox/common/compression/CMakeLists.txt
@@ -16,8 +16,8 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-add_library(velox_common_compression Compression.cpp LzoDecompressor.cpp)
-target_link_libraries(
+velox_add_library(velox_common_compression Compression.cpp LzoDecompressor.cpp)
+velox_link_libraries(
   velox_common_compression
   PUBLIC Folly::folly
   PRIVATE velox_exception)
diff --git a/velox/common/compression/Compression.cpp b/velox/common/compression/Compression.cpp
index 3843f5902a980..e17ff941ba99f 100644
--- a/velox/common/compression/Compression.cpp
+++ b/velox/common/compression/Compression.cpp
@@ -56,7 +56,8 @@ CompressionKind codecTypeToCompressionKind(folly::io::CodecType type) {
     case folly::io::CodecType::GZIP:
       return CompressionKind_GZIP;
     default:
-      VELOX_UNSUPPORTED("Not support folly codec type {}", type);
+      VELOX_UNSUPPORTED(
+          "Not support folly codec type {}", folly::to<std::string>(type));
   }
 }
 
diff --git a/velox/common/compression/Compression.h b/velox/common/compression/Compression.h
index 317f9717a2ae5..70f804f2e8611 100644
--- a/velox/common/compression/Compression.h
+++ b/velox/common/compression/Compression.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <fmt/format.h>
 #include <folly/compression/Compression.h>
 #include <string>
 
@@ -46,3 +47,14 @@ CompressionKind stringToCompressionKind(const std::string& kind);
 constexpr uint64_t DEFAULT_COMPRESSION_BLOCK_SIZE = 256 * 1024;
 
 } // namespace facebook::velox::common
+
+template <>
+struct fmt::formatter<facebook::velox::common::CompressionKind>
+    : fmt::formatter<std::string> {
+  auto format(
+      const facebook::velox::common::CompressionKind& s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::common::compressionKindToString(s), ctx);
+  }
+};
diff --git a/velox/common/compression/tests/CMakeLists.txt b/velox/common/compression/tests/CMakeLists.txt
index d7200934b9fd8..3b75b6fea6981 100644
--- a/velox/common/compression/tests/CMakeLists.txt
+++ b/velox/common/compression/tests/CMakeLists.txt
@@ -17,4 +17,5 @@ add_test(velox_common_compression_test velox_common_compression_test)
 target_link_libraries(
   velox_common_compression_test
   PUBLIC velox_link_libs
-  PRIVATE velox_common_compression velox_exception gtest gtest_main)
+  PRIVATE velox_common_compression velox_exception GTest::gtest
+          GTest::gtest_main)
diff --git a/velox/common/config/CMakeLists.txt b/velox/common/config/CMakeLists.txt
index f6f4df0f1992d..7780665a29251 100644
--- a/velox/common/config/CMakeLists.txt
+++ b/velox/common/config/CMakeLists.txt
@@ -12,6 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_spill_config SpillConfig.cpp)
-target_link_libraries(velox_spill_config Folly::folly velox_exception
-                      velox_common_compression)
+if (${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif ()
+
+velox_add_library(velox_common_config Config.cpp)
+velox_link_libraries(
+  velox_common_config
+  PUBLIC velox_common_base
+         velox_exception
+  PRIVATE re2::re2)
diff --git a/velox/common/config/Config.cpp b/velox/common/config/Config.cpp
new file mode 100644
index 0000000000000..0582b1e755e40
--- /dev/null
+++ b/velox/common/config/Config.cpp
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <re2/re2.h>
+
+#include "velox/common/config/Config.h"
+
+namespace facebook::velox::config {
+
+double toBytesPerCapacityUnit(CapacityUnit unit) {
+  switch (unit) {
+    case CapacityUnit::BYTE:
+      return 1;
+    case CapacityUnit::KILOBYTE:
+      return exp2(10);
+    case CapacityUnit::MEGABYTE:
+      return exp2(20);
+    case CapacityUnit::GIGABYTE:
+      return exp2(30);
+    case CapacityUnit::TERABYTE:
+      return exp2(40);
+    case CapacityUnit::PETABYTE:
+      return exp2(50);
+    default:
+      VELOX_USER_FAIL("Invalid capacity unit '{}'", (int)unit);
+  }
+}
+
+CapacityUnit valueOfCapacityUnit(const std::string& unitStr) {
+  std::stringstream ss;
+  for (const char c : unitStr) {
+    ss << static_cast<char>(std::tolower(c));
+  }
+  const auto lowerUnitStr = ss.str();
+  if (lowerUnitStr == "b") {
+    return CapacityUnit::BYTE;
+  }
+  if (lowerUnitStr == "kb") {
+    return CapacityUnit::KILOBYTE;
+  }
+  if (lowerUnitStr == "mb") {
+    return CapacityUnit::MEGABYTE;
+  }
+  if (lowerUnitStr == "gb") {
+    return CapacityUnit::GIGABYTE;
+  }
+  if (lowerUnitStr == "tb") {
+    return CapacityUnit::TERABYTE;
+  }
+  if (lowerUnitStr == "pb") {
+    return CapacityUnit::PETABYTE;
+  }
+  VELOX_USER_FAIL("Invalid capacity unit '{}'", unitStr);
+}
+
+uint64_t toCapacity(const std::string& from, CapacityUnit to) {
+  static const RE2 kPattern(R"(^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]+)\s*$)");
+  double value;
+  std::string unit;
+  if (!RE2::FullMatch(from, kPattern, &value, &unit)) {
+    VELOX_USER_FAIL("Invalid capacity string '{}'", from);
+  }
+
+  return value *
+      (toBytesPerCapacityUnit(valueOfCapacityUnit(unit)) /
+       toBytesPerCapacityUnit(to));
+}
+
+std::chrono::duration<double> toDuration(const std::string& str) {
+  static const RE2 kPattern(R"(^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]+)\s*)");
+
+  double value;
+  std::string unit;
+  if (!RE2::FullMatch(str, kPattern, &value, &unit)) {
+    VELOX_USER_FAIL("Invalid duration '{}'", str);
+  }
+  if (unit == "ns") {
+    return std::chrono::duration<double, std::nano>(value);
+  } else if (unit == "us") {
+    return std::chrono::duration<double, std::micro>(value);
+  } else if (unit == "ms") {
+    return std::chrono::duration<double, std::milli>(value);
+  } else if (unit == "s") {
+    return std::chrono::duration<double>(value);
+  } else if (unit == "m") {
+    return std::chrono::duration<double, std::ratio<60>>(value);
+  } else if (unit == "h") {
+    return std::chrono::duration<double, std::ratio<60 * 60>>(value);
+  } else if (unit == "d") {
+    return std::chrono::duration<double, std::ratio<60 * 60 * 24>>(value);
+  }
+  VELOX_USER_FAIL("Invalid duration '{}'", str);
+}
+
+ConfigBase& ConfigBase::set(const std::string& key, const std::string& val) {
+  VELOX_CHECK(mutable_, "Cannot set in immutable config");
+  std::unique_lock<std::shared_mutex> l(mutex_);
+  configs_[key] = val;
+  return *this;
+}
+
+ConfigBase& ConfigBase::reset() {
+  VELOX_CHECK(mutable_, "Cannot reset in immutable config");
+  std::unique_lock<std::shared_mutex> l(mutex_);
+  configs_.clear();
+  return *this;
+}
+
+bool ConfigBase::valueExists(const std::string& key) const {
+  std::shared_lock<std::shared_mutex> l(mutex_);
+  return configs_.find(key) != configs_.end();
+};
+
+const std::unordered_map<std::string, std::string>& ConfigBase::rawConfigs()
+    const {
+  VELOX_CHECK(
+      !mutable_,
+      "Mutable config cannot return unprotected reference to raw configs.");
+  return configs_;
+}
+
+std::unordered_map<std::string, std::string> ConfigBase::rawConfigsCopy()
+    const {
+  std::shared_lock<std::shared_mutex> l(mutex_);
+  return configs_;
+}
+
+folly::Optional<std::string> ConfigBase::get(const std::string& key) const {
+  folly::Optional<std::string> val;
+  std::shared_lock<std::shared_mutex> l(mutex_);
+  auto it = configs_.find(key);
+  if (it != configs_.end()) {
+    val = it->second;
+  }
+  return val;
+}
+} // namespace facebook::velox::config
diff --git a/velox/common/config/Config.h b/velox/common/config/Config.h
index dd5f37c55b73a..96f77d59cd7b8 100644
--- a/velox/common/config/Config.h
+++ b/velox/common/config/Config.h
@@ -18,84 +18,144 @@
 
 #include <functional>
 #include <map>
+#include <shared_mutex>
 #include <unordered_map>
 
 #include "folly/Conv.h"
 #include "velox/common/base/Exceptions.h"
 
-namespace facebook::velox::common {
-// The concrete config class would inherit the config base
-// and then just define all the entries.
-template <class ConcreteConfig>
+namespace facebook::velox::config {
+
+enum class CapacityUnit {
+  BYTE,
+  KILOBYTE,
+  MEGABYTE,
+  GIGABYTE,
+  TERABYTE,
+  PETABYTE
+};
+
+double toBytesPerCapacityUnit(CapacityUnit unit);
+
+CapacityUnit valueOfCapacityUnit(const std::string& unitStr);
+
+/// Convert capacity string with unit to the capacity number in the specified
+/// units
+uint64_t toCapacity(const std::string& from, CapacityUnit to);
+
+std::chrono::duration<double> toDuration(const std::string& str);
+
+/// The concrete config class should inherit the config base and define all the
+/// entries.
 class ConfigBase {
  public:
   template <typename T>
-  class Entry {
-   private:
+  struct Entry {
     Entry(
-        const std::string& key,
-        const T& val,
-        std::function<std::string(const T&)> toStr =
+        const std::string& _key,
+        const T& _val,
+        std::function<std::string(const T&)> _toStr =
             [](const T& val) { return folly::to<std::string>(val); },
-        std::function<T(const std::string&, const std::string&)> toT =
-            [](const std::string& key, const std::string& val) {
-              auto converted = folly::tryTo<T>(val);
+        std::function<T(const std::string&, const std::string&)> _toT =
+            [](const std::string& k, const std::string& v) {
+              auto converted = folly::tryTo<T>(v);
               VELOX_CHECK(
                   converted.hasValue(),
                   fmt::format(
                       "Invalid configuration for key '{}'. Value '{}' cannot be converted to type {}.",
-                      key,
-                      val,
+                      k,
+                      v,
                       folly::demangle(typeid(T))));
               return converted.value();
             })
-        : key_{key}, default_{val}, toStr_{toStr}, toT_{toT} {}
+        : key{_key}, defaultVal{_val}, toStr{_toStr}, toT{_toT} {}
 
-   public:
-    const std::string& configKey() const {
-      return key_;
-    }
+    const std::string key;
+    const T defaultVal;
+    const std::function<std::string(const T&)> toStr;
+    const std::function<T(const std::string&, const std::string&)> toT;
+  };
 
-   private:
-    const std::string key_;
-    const T default_;
-    const std::function<std::string(const T&)> toStr_;
-    const std::function<T(const std::string&, const std::string&)> toT_;
+  ConfigBase(
+      std::unordered_map<std::string, std::string>&& configs,
+      bool _mutable = false)
+      : configs_(std::move(configs)), mutable_(_mutable) {}
 
-    friend ConfigBase;
-    friend ConcreteConfig;
-  };
+  virtual ~ConfigBase() {}
 
   template <typename T>
   ConfigBase& set(const Entry<T>& entry, const T& val) {
-    configs_[entry.key_] = entry.toStr_(val);
+    VELOX_CHECK(mutable_, "Cannot set in immutable config");
+    std::unique_lock<std::shared_mutex> l(mutex_);
+    configs_[entry.key] = entry.toStr(val);
     return *this;
   }
 
+  ConfigBase& set(const std::string& key, const std::string& val);
+
   template <typename T>
   ConfigBase& unset(const Entry<T>& entry) {
-    configs_.erase(entry.key_);
+    VELOX_CHECK(mutable_, "Cannot unset in immutable config");
+    std::unique_lock<std::shared_mutex> l(mutex_);
+    configs_.erase(entry.key);
     return *this;
   }
 
-  ConfigBase& reset() {
-    configs_.clear();
-    return *this;
-  }
+  ConfigBase& reset();
 
   template <typename T>
   T get(const Entry<T>& entry) const {
-    auto iter = configs_.find(entry.key_);
-    return iter != configs_.end() ? entry.toT_(entry.key_, iter->second)
-                                  : entry.default_;
+    std::shared_lock<std::shared_mutex> l(mutex_);
+    auto iter = configs_.find(entry.key);
+    return iter != configs_.end() ? entry.toT(entry.key, iter->second)
+                                  : entry.defaultVal;
+  }
+
+  template <typename T>
+  folly::Optional<T> get(
+      const std::string& key,
+      std::function<T(std::string, std::string)> toT = [](auto /* unused */,
+                                                          auto value) {
+        return folly::to<T>(value);
+      }) const {
+    auto val = get(key);
+    if (val.hasValue()) {
+      return toT(key, val.value());
+    } else {
+      return folly::none;
+    }
   }
 
-  std::map<std::string, std::string> toSerdeParams() {
-    return std::map{configs_.cbegin(), configs_.cend()};
+  template <typename T>
+  T get(
+      const std::string& key,
+      const T& defaultValue,
+      std::function<T(std::string, std::string)> toT = [](auto /* unused */,
+                                                          auto value) {
+        return folly::to<T>(value);
+      }) const {
+    auto val = get(key);
+    if (val.hasValue()) {
+      return toT(key, val.value());
+    } else {
+      return defaultValue;
+    }
   }
 
+  bool valueExists(const std::string& key) const;
+
+  const std::unordered_map<std::string, std::string>& rawConfigs() const;
+
+  std::unordered_map<std::string, std::string> rawConfigsCopy() const;
+
  protected:
+  mutable std::shared_mutex mutex_;
   std::unordered_map<std::string, std::string> configs_;
+
+ private:
+  folly::Optional<std::string> get(const std::string& key) const;
+
+  const bool mutable_;
 };
 
-} // namespace facebook::velox::common
+} // namespace facebook::velox::config
diff --git a/velox/common/config/SpillConfig.cpp b/velox/common/config/SpillConfig.cpp
deleted file mode 100644
index 05936c0325d46..0000000000000
--- a/velox/common/config/SpillConfig.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/common/config/SpillConfig.h"
-#include "velox/common/base/Exceptions.h"
-
-namespace facebook::velox::common {
-SpillConfig::SpillConfig(
-    const std::string& _filePath,
-    uint64_t _maxFileSize,
-    uint64_t _writeBufferSize,
-    uint64_t _minSpillRunSize,
-    folly::Executor* _executor,
-    int32_t _minSpillableReservationPct,
-    int32_t _spillableReservationGrowthPct,
-    uint8_t _startPartitionBit,
-    uint8_t _joinPartitionBits,
-    uint8_t _aggregationPartitionBits,
-    bool _aggregationSpillAll,
-    int32_t _maxSpillLevel,
-    int32_t _testSpillPct,
-    const std::string& _compressionKind)
-    : filePath(_filePath),
-      maxFileSize(
-          _maxFileSize == 0 ? std::numeric_limits<int64_t>::max()
-                            : _maxFileSize),
-      writeBufferSize(_writeBufferSize),
-      minSpillRunSize(_minSpillRunSize),
-      executor(_executor),
-      minSpillableReservationPct(_minSpillableReservationPct),
-      spillableReservationGrowthPct(_spillableReservationGrowthPct),
-      startPartitionBit(_startPartitionBit),
-      joinPartitionBits(_joinPartitionBits),
-      aggregationPartitionBits(_aggregationPartitionBits),
-      aggregationSpillAll(_aggregationSpillAll),
-      maxSpillLevel(_maxSpillLevel),
-      testSpillPct(_testSpillPct),
-      compressionKind(common::stringToCompressionKind(_compressionKind)) {
-  VELOX_USER_CHECK_GE(
-      spillableReservationGrowthPct,
-      minSpillableReservationPct,
-      "Spillable memory reservation growth pct should not be lower than minimum available pct");
-}
-
-int32_t SpillConfig::joinSpillLevel(uint8_t startBitOffset) const {
-  const auto numPartitionBits = joinPartitionBits;
-  VELOX_CHECK_LE(
-      startBitOffset + numPartitionBits,
-      64,
-      "startBitOffset:{} numPartitionsBits:{}",
-      startBitOffset,
-      numPartitionBits);
-  const int32_t deltaBits = startBitOffset - startPartitionBit;
-  VELOX_CHECK_GE(deltaBits, 0, "deltaBits:{}", deltaBits);
-  VELOX_CHECK_EQ(
-      deltaBits % numPartitionBits,
-      0,
-      "deltaBits:{} numPartitionsBits{}",
-      deltaBits,
-      numPartitionBits);
-  return deltaBits / numPartitionBits;
-}
-
-bool SpillConfig::exceedJoinSpillLevelLimit(uint8_t startBitOffset) const {
-  if (startBitOffset + joinPartitionBits > 64) {
-    return true;
-  }
-  if (maxSpillLevel == -1) {
-    return false;
-  }
-  return joinSpillLevel(startBitOffset) > maxSpillLevel;
-}
-} // namespace facebook::velox::common
diff --git a/velox/common/config/SpillConfig.h b/velox/common/config/SpillConfig.h
deleted file mode 100644
index 5c20f677642be..0000000000000
--- a/velox/common/config/SpillConfig.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <stdint.h>
-#include <string.h>
-
-#include <folly/executors/CPUThreadPoolExecutor.h>
-#include "velox/common/compression/Compression.h"
-
-namespace facebook::velox::common {
-/// Specifies the config for spilling.
-struct SpillConfig {
-  SpillConfig(
-      const std::string& _filePath,
-      uint64_t _maxFileSize,
-      uint64_t _writeBufferSize,
-      uint64_t _minSpillRunSize,
-      folly::Executor* _executor,
-      int32_t _minSpillableReservationPct,
-      int32_t _spillableReservationGrowthPct,
-      uint8_t _startPartitionBit,
-      uint8_t _joinPartitionBits,
-      uint8_t _aggregationPartitionBits,
-      bool _aggregationSpillAll,
-      int32_t _maxSpillLevel,
-      int32_t _testSpillPct,
-      const std::string& _compressionKind);
-
-  /// Returns the hash join spilling level with given 'startBitOffset'.
-  ///
-  /// NOTE: we advance (or right shift) the partition bit offset when goes to
-  /// the next level of recursive spilling.
-  int32_t joinSpillLevel(uint8_t startBitOffset) const;
-
-  /// Checks if the given 'startBitOffset' has exceeded the max hash join
-  /// spill limit.
-  bool exceedJoinSpillLevelLimit(uint8_t startBitOffset) const;
-
-  /// Filesystem path for spill files.
-  std::string filePath;
-
-  /// The max spill file size. If it is zero, there is no limit on the spill
-  /// file size.
-  uint64_t maxFileSize;
-
-  /// Specifies the size to buffer the serialized spill data before write to
-  /// storage system for io efficiency.
-  uint64_t writeBufferSize;
-
-  /// The min spill run size (bytes) limit used to select partitions for
-  /// spilling. The spiller tries to spill a previously spilled partitions if
-  /// its data size exceeds this limit, otherwise it spills the partition with
-  /// most data. If the limit is zero, then the spiller always spill a
-  /// previously spilled partition if it has any data. This is to avoid spill
-  /// from a partition wigth a small amount of data which might result in
-  /// generating too many small spilled files.
-  uint64_t minSpillRunSize;
-
-  /// Executor for spilling. If nullptr spilling writes on the Driver's thread.
-  folly::Executor* executor; // Not owned.
-
-  /// The minimal spillable memory reservation in percentage of the current
-  /// memory usage.
-  int32_t minSpillableReservationPct;
-
-  /// The spillable memory reservation growth in percentage of the current
-  /// memory usage.
-  int32_t spillableReservationGrowthPct;
-
-  /// Used to calculate spill partition number.
-  uint8_t startPartitionBit;
-
-  /// Used to calculate the spill hash partition number for hash join with
-  /// 'startPartitionBit'.
-  uint8_t joinPartitionBits;
-
-  /// Used to calculate the spill hash partition number for aggregation with
-  /// 'startPartitionBit'.
-  uint8_t aggregationPartitionBits;
-
-  /// If true and spilling has been triggered during the input processing, the
-  /// spiller will spill all the remaining in-memory state to disk before output
-  /// processing. This is to simplify the aggregation query OOM prevention in
-  /// output processing stage.
-  bool aggregationSpillAll;
-
-  /// The max allowed spilling level with zero being the initial spilling
-  /// level. This only applies for hash build spilling which needs recursive
-  /// spilling when the build table is too big. If it is set to -1, then there
-  /// is no limit and then some extreme large query might run out of spilling
-  /// partition bits at the end.
-  int32_t maxSpillLevel;
-
-  /// Percentage of input batches to be spilled for testing. 0 means no
-  /// spilling for test.
-  int32_t testSpillPct;
-
-  /// CompressionKind when spilling, CompressionKind_NONE means no compression.
-  common::CompressionKind compressionKind;
-};
-} // namespace facebook::velox::common
diff --git a/velox/common/config/tests/CMakeLists.txt b/velox/common/config/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..83de01821eea5
--- /dev/null
+++ b/velox/common/config/tests/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_config_test ConfigTest.cpp)
+add_test(velox_config_test velox_config_test)
+target_link_libraries(
+  velox_config_test
+  PUBLIC Folly::folly
+  PRIVATE velox_common_config GTest::gtest GTest::gtest_main)
diff --git a/velox/common/config/tests/ConfigTest.cpp b/velox/common/config/tests/ConfigTest.cpp
new file mode 100644
index 0000000000000..b97e2df3528b0
--- /dev/null
+++ b/velox/common/config/tests/ConfigTest.cpp
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Random.h>
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/config/Config.h"
+
+namespace facebook::velox::config {
+
+class ConfigTest : public ::testing::Test {};
+
+enum TestEnum { ENUM_0 = 0, ENUM_1 = 1, ENUM_2 = 2, UNKNOWN = 3 };
+
+class TestConfig : public ConfigBase {
+ public:
+  template <typename T>
+  using Entry = ConfigBase::Entry<T>;
+
+  static Entry<int32_t> kInt32Entry;
+  static Entry<uint64_t> kUint64Entry;
+  static Entry<bool> kBoolEntry;
+  static Entry<std::string> kStringEntry;
+  static Entry<TestEnum> kEnumEntry;
+
+  TestConfig(
+      std::unordered_map<std::string, std::string>&& configs,
+      bool _mutable)
+      : ConfigBase(std::move(configs), _mutable) {}
+};
+
+// Definition needs to be outside of class
+TestConfig::Entry<int32_t> TestConfig::kInt32Entry("int32_entry", -32);
+TestConfig::Entry<uint64_t> TestConfig::kUint64Entry("uint64_entry", 64);
+TestConfig::Entry<bool> TestConfig::kBoolEntry("bool_entry", true);
+TestConfig::Entry<std::string> TestConfig::kStringEntry(
+    "string_entry",
+    "default.string.value");
+TestConfig::Entry<TestEnum> TestConfig::kEnumEntry(
+    "enum_entry",
+    TestEnum::ENUM_0,
+    [](const TestEnum& value) {
+      if (value == TestEnum::ENUM_0) {
+        return "ENUM_0";
+      }
+      if (value == TestEnum::ENUM_1) {
+        return "ENUM_1";
+      }
+      if (value == TestEnum::ENUM_2) {
+        return "ENUM_2";
+      }
+      return "UNKNOWN";
+    },
+    [](const std::string& /* unused */, const std::string& v) {
+      if (v == "ENUM_0") {
+        return TestEnum::ENUM_0;
+      }
+      if (v == "ENUM_1") {
+        return TestEnum::ENUM_1;
+      }
+      if (v == "ENUM_2") {
+        return TestEnum::ENUM_2;
+      }
+      return TestEnum::UNKNOWN;
+    });
+
+TEST_F(ConfigTest, creation) {
+  {
+    std::unordered_map<std::string, std::string> rawConfigs{};
+    auto config = std::make_shared<TestConfig>(std::move(rawConfigs), false);
+    ASSERT_EQ(config->rawConfigs().size(), 0);
+    ASSERT_EQ(config->rawConfigsCopy().size(), 0);
+  }
+
+  {
+    std::unordered_map<std::string, std::string> rawConfigs{};
+    rawConfigs.emplace("int32_entry", "-3200");
+    auto config = std::make_shared<TestConfig>(std::move(rawConfigs), true);
+    ASSERT_EQ(config->rawConfigsCopy().size(), 1);
+    VELOX_ASSERT_THROW(
+        config->rawConfigs(),
+        "Mutable config cannot return unprotected reference to raw configs.");
+  }
+}
+
+TEST_F(ConfigTest, immutableConfig) {
+  // Testing default values
+  auto config = std::make_shared<TestConfig>(
+      std::unordered_map<std::string, std::string>(), false);
+  ASSERT_EQ(config->get(TestConfig::kInt32Entry), -32);
+  ASSERT_EQ(config->get(TestConfig::kUint64Entry), 64);
+  ASSERT_EQ(config->get(TestConfig::kBoolEntry), true);
+  ASSERT_EQ(config->get(TestConfig::kStringEntry), "default.string.value");
+  ASSERT_EQ(config->get(TestConfig::kEnumEntry), TestEnum::ENUM_0);
+
+  std::unordered_map<std::string, std::string> rawConfigs{
+      {TestConfig::kInt32Entry.key, "-3200"},
+      {TestConfig::kUint64Entry.key, "6400"},
+      {TestConfig::kStringEntry.key, "not.default.string.value"},
+      {TestConfig::kBoolEntry.key, "false"},
+      {TestConfig::kEnumEntry.key, "ENUM_2"},
+  };
+
+  auto expectedRawConfigs = rawConfigs;
+
+  config = std::make_shared<TestConfig>(std::move(rawConfigs), false);
+
+  // Testing behavior when trying to modify the immutable config
+  VELOX_ASSERT_THROW(config->set(TestConfig::kInt32Entry, 100), "Cannot set");
+  VELOX_ASSERT_THROW(
+      config->set(TestConfig::kInt32Entry.key, "100"), "Cannot set");
+  VELOX_ASSERT_THROW(config->unset(TestConfig::kInt32Entry), "Cannot unset");
+  VELOX_ASSERT_THROW(config->reset(), "Cannot reset");
+
+  // Ensure values are unchanged after attempted modifications
+  ASSERT_EQ(config->get(TestConfig::kInt32Entry), -3200);
+  ASSERT_EQ(config->get(TestConfig::kUint64Entry), 6400);
+  ASSERT_EQ(config->get(TestConfig::kBoolEntry), false);
+  ASSERT_EQ(config->get(TestConfig::kStringEntry), "not.default.string.value");
+  ASSERT_EQ(config->get(TestConfig::kEnumEntry), TestEnum::ENUM_2);
+  ASSERT_EQ(
+      config->get(
+          TestConfig::kInt32Entry.key, TestConfig::kInt32Entry.defaultVal),
+      -3200);
+  ASSERT_EQ(
+      config->get(
+          TestConfig::kUint64Entry.key, TestConfig::kUint64Entry.defaultVal),
+      6400);
+  ASSERT_EQ(
+      config->get(
+          TestConfig::kBoolEntry.key, TestConfig::kBoolEntry.defaultVal),
+      false);
+  ASSERT_EQ(
+      config->get(
+          TestConfig::kStringEntry.key, TestConfig::kStringEntry.defaultVal),
+      "not.default.string.value");
+  ASSERT_EQ(
+      config->get<TestEnum>(
+          TestConfig::kEnumEntry.key,
+          TestConfig::kEnumEntry.defaultVal,
+          TestConfig::kEnumEntry.toT),
+      TestEnum::ENUM_2);
+  ASSERT_TRUE(config->get<int32_t>(TestConfig::kInt32Entry.key).has_value());
+  ASSERT_EQ(config->get<int32_t>(TestConfig::kInt32Entry.key).value(), -3200);
+  ASSERT_FALSE(config->get<int32_t>("wrong_int32_key").has_value());
+
+  // Testing value existence
+  ASSERT_TRUE(config->valueExists(TestConfig::kInt32Entry.key));
+  ASSERT_FALSE(config->valueExists("non_existent_entry"));
+
+  // Testing retrieval of raw configurations
+  ASSERT_EQ(expectedRawConfigs, config->rawConfigs());
+  ASSERT_EQ(expectedRawConfigs, config->rawConfigsCopy());
+}
+
+TEST_F(ConfigTest, mutableConfig) {
+  // Create a mutable configuration with some initial values
+  std::unordered_map<std::string, std::string> initialConfigs{
+      {TestConfig::kInt32Entry.key, "-3200"},
+      {TestConfig::kUint64Entry.key, "6400"},
+      {TestConfig::kStringEntry.key, "initial.string.value"},
+      {TestConfig::kBoolEntry.key, "false"},
+      {TestConfig::kEnumEntry.key, "ENUM_2"},
+  };
+
+  auto config = std::make_shared<TestConfig>(std::move(initialConfigs), true);
+
+  // Test setting new values
+  (*config)
+      .set(TestConfig::kInt32Entry, 123)
+      .set(TestConfig::kStringEntry, std::string("modified.string.value"))
+      .set(TestConfig::kBoolEntry.key, "true")
+      .set(TestConfig::kEnumEntry.key, "ENUM_1");
+
+  ASSERT_EQ(config->get(TestConfig::kInt32Entry), 123);
+  ASSERT_EQ(config->get(TestConfig::kStringEntry), "modified.string.value");
+  ASSERT_EQ(config->get(TestConfig::kBoolEntry), true);
+  ASSERT_EQ(config->get(TestConfig::kEnumEntry), TestEnum::ENUM_1);
+
+  // Test unsetting values
+  ASSERT_EQ(config->get(TestConfig::kUint64Entry), 6400);
+  config->unset(TestConfig::kUint64Entry);
+  ASSERT_EQ(
+      config->get(TestConfig::kUint64Entry),
+      TestConfig::kUint64Entry.defaultVal);
+
+  // Test resetting the configuration
+  config->reset();
+  auto rawConfigsCopy = config->rawConfigsCopy();
+  ASSERT_TRUE(rawConfigsCopy.empty());
+  ASSERT_FALSE(config->valueExists(TestConfig::kUint64Entry.key));
+}
+
+TEST_F(ConfigTest, capacityConversion) {
+  folly::Random::DefaultGenerator rng;
+  rng.seed(1);
+
+  std::unordered_map<CapacityUnit, std::vector<std::string>> unitStrLookup{
+      {CapacityUnit::BYTE, {"b", "B"}},
+      {CapacityUnit::KILOBYTE, {"kb", "kB", "Kb", "KB"}},
+      {CapacityUnit::MEGABYTE, {"mb", "mB", "Mb", "MB"}},
+      {CapacityUnit::GIGABYTE, {"gb", "gB", "Gb", "GB"}},
+      {CapacityUnit::TERABYTE, {"tb", "tB", "Tb", "TB"}},
+      {CapacityUnit::PETABYTE, {"pb", "pB", "Pb", "PB"}}};
+
+  std::vector<std::pair<CapacityUnit, double>> units{
+      {CapacityUnit::BYTE, 1},
+      {CapacityUnit::KILOBYTE, 1024},
+      {CapacityUnit::MEGABYTE, 1024 * 1024},
+      {CapacityUnit::GIGABYTE, 1024 * 1024 * 1024},
+      {CapacityUnit::TERABYTE, 1024ll * 1024 * 1024 * 1024},
+      {CapacityUnit::PETABYTE, 1024ll * 1024 * 1024 * 1024 * 1024}};
+  for (int32_t i = 0; i < units.size(); i++) {
+    for (int32_t j = 0; j < units.size(); j++) {
+      // We use this diffRatio to prevent float conversion overflow when
+      // converting from one unit to another.
+      uint64_t diffRatio = i < j ? units[j].second / units[i].second
+                                 : units[i].second / units[j].second;
+      uint64_t randNumber = folly::Random::rand64(rng);
+      uint64_t testNumber = i > j ? randNumber / diffRatio : randNumber;
+      const auto& unitStrs = unitStrLookup[units[i].first];
+      for (int32_t k = 0; k < unitStrs.size(); k++) {
+        ASSERT_EQ(
+            toCapacity(
+                std::string(std::to_string(testNumber) + unitStrs[k]),
+                units[j].first),
+            (uint64_t)(testNumber * (units[i].second / units[j].second)));
+      }
+    }
+  }
+}
+
+TEST_F(ConfigTest, durationConversion) {
+  folly::Random::DefaultGenerator rng;
+  rng.seed(1);
+
+  std::vector<std::pair<std::string, uint64_t>> units{
+      {"ns", 1},
+      {"us", 1000},
+      {"ms", 1000 * 1000},
+      {"s", 1000ll * 1000 * 1000},
+      {"m", 1000ll * 1000 * 1000 * 60},
+      {"h", 1000ll * 1000 * 1000 * 60 * 60},
+      {"d", 1000ll * 1000 * 1000 * 60 * 60 * 24}};
+  for (uint32_t i = 0; i < units.size(); i++) {
+    auto testNumber = folly::Random::rand32(rng) % 10000;
+    auto duration =
+        toDuration(std::string(std::to_string(testNumber) + units[i].first));
+    ASSERT_EQ(
+        testNumber * units[i].second,
+        std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count());
+  }
+}
+} // namespace facebook::velox::config
diff --git a/velox/common/encode/Base64.cpp b/velox/common/encode/Base64.cpp
index 85fd843b86a83..da4e9cdbfcfdd 100644
--- a/velox/common/encode/Base64.cpp
+++ b/velox/common/encode/Base64.cpp
@@ -20,14 +20,25 @@
 #include <folly/io/Cursor.h>
 #include <stdint.h>
 
+#include "velox/common/base/Exceptions.h"
+
 namespace facebook::velox::encoding {
 
+// Constants defining the size in bytes of binary and encoded blocks for Base64
+// encoding.
+// Size of a binary block in bytes (3 bytes = 24 bits)
+constexpr static int kBinaryBlockByteSize = 3;
+// Size of an encoded block in bytes (4 bytes = 24 bits)
+constexpr static int kEncodedBlockByteSize = 4;
+
+// Character sets for Base64 and Base64 URL encoding
 constexpr const Base64::Charset kBase64Charset = {
     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
     'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
     'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
+
 constexpr const Base64::Charset kBase64UrlCharset = {
     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
     'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
@@ -35,6 +46,7 @@ constexpr const Base64::Charset kBase64UrlCharset = {
     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'};
 
+// Reverse lookup tables for decoding
 constexpr const Base64::ReverseIndex kBase64ReverseIndexTable = {
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
@@ -54,6 +66,7 @@ constexpr const Base64::ReverseIndex kBase64ReverseIndexTable = {
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255};
+
 constexpr const Base64::ReverseIndex kBase64UrlReverseIndexTable = {
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
@@ -74,13 +87,15 @@ constexpr const Base64::ReverseIndex kBase64UrlReverseIndexTable = {
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255};
 
+// Validate the character in charset with ReverseIndex table
 constexpr bool checkForwardIndex(
     uint8_t idx,
     const Base64::Charset& charset,
-    const Base64::ReverseIndex& table) {
-  return (table[static_cast<uint8_t>(charset[idx])] == idx) &&
-      (idx > 0 ? checkForwardIndex(idx - 1, charset, table) : true);
+    const Base64::ReverseIndex& reverseIndex) {
+  return (reverseIndex[static_cast<uint8_t>(charset[idx])] == idx) &&
+      (idx > 0 ? checkForwardIndex(idx - 1, charset, reverseIndex) : true);
 }
+
 // Verify that for every entry in kBase64Charset, the corresponding entry
 // in kBase64ReverseIndexTable is correct.
 static_assert(
@@ -89,6 +104,7 @@ static_assert(
         kBase64Charset,
         kBase64ReverseIndexTable),
     "kBase64Charset has incorrect entries");
+
 // Verify that for every entry in kBase64UrlCharset, the corresponding entry
 // in kBase64UrlReverseIndexTable is correct.
 static_assert(
@@ -97,26 +113,28 @@ static_assert(
         kBase64UrlCharset,
         kBase64UrlReverseIndexTable),
     "kBase64UrlCharset has incorrect entries");
-// Similar to strchr(), but for null-terminated const strings.
-// Another difference is that we do not consider "\0" to be present in the
-// string.
-// Returns true if "str" contains the character c.
-constexpr bool constCharsetContains(
+
+// Searches for a character within a charset up to a certain index.
+constexpr bool findCharacterInCharset(
     const Base64::Charset& charset,
     uint8_t idx,
     const char c) {
   return idx < charset.size() &&
-      ((charset[idx] == c) || constCharsetContains(charset, idx + 1, c));
+      ((charset[idx] == c) || findCharacterInCharset(charset, idx + 1, c));
 }
+
+// Checks the consistency of a reverse index mapping for a given character
+// set.
 constexpr bool checkReverseIndex(
     uint8_t idx,
     const Base64::Charset& charset,
-    const Base64::ReverseIndex& table) {
-  return (table[idx] == 255
-              ? !constCharsetContains(charset, 0, static_cast<char>(idx))
-              : (charset[table[idx]] == idx)) &&
-      (idx > 0 ? checkReverseIndex(idx - 1, charset, table) : true);
+    const Base64::ReverseIndex& reverseIndex) {
+  return (reverseIndex[idx] == 255
+              ? !findCharacterInCharset(charset, 0, static_cast<char>(idx))
+              : (charset[reverseIndex[idx]] == idx)) &&
+      (idx > 0 ? checkReverseIndex(idx - 1, charset, reverseIndex) : true);
 }
+
 // Verify that for every entry in kBase64ReverseIndexTable, the corresponding
 // entry in kBase64Charset is correct.
 static_assert(
@@ -125,10 +143,11 @@ static_assert(
         kBase64Charset,
         kBase64ReverseIndexTable),
     "kBase64ReverseIndexTable has incorrect entries.");
+
 // Verify that for every entry in kBase64ReverseIndexTable, the corresponding
 // entry in kBase64Charset is correct.
-// We can't run this check as the URL version has two duplicate entries so that
-// the url decoder can handle url encodings and default encodings
+// We can't run this check as the URL version has two duplicate entries so
+// that the url decoder can handle url encodings and default encodings
 // static_assert(
 //     checkReverseIndex(
 //         sizeof(kBase64UrlReverseIndexTable) - 1,
@@ -136,14 +155,15 @@ static_assert(
 //         kBase64UrlReverseIndexTable),
 //     "kBase64UrlReverseIndexTable has incorrect entries.");
 
+// Implementation of Base64 encoding and decoding functions.
 template <class T>
-/*  static */ std::string
-Base64::encodeImpl(const T& data, const Charset& charset, bool include_pad) {
+/* static */ std::string Base64::encodeImpl(
+    const T& data,
+    const Base64::Charset& charset,
+    bool include_pad) {
   size_t outlen = calculateEncodedSize(data.size(), include_pad);
-
   std::string out;
   out.resize(outlen);
-
   encodeImpl(data, charset, include_pad, out.data());
   return out;
 }
@@ -176,7 +196,7 @@ void Base64::encodeUrl(const char* data, size_t len, char* output) {
 template <class T>
 /* static */ void Base64::encodeImpl(
     const T& data,
-    const Charset& charset,
+    const Base64::Charset& charset,
     bool include_pad,
     char* out) {
   auto len = data.size();
@@ -211,22 +231,24 @@ template <class T>
       *wp++ = charset[(curr >> 12) & 0x3f];
       *wp++ = charset[(curr >> 6) & 0x3f];
       if (include_pad) {
-        *wp = kBase64Pad;
+        *wp = kPadding;
       }
     } else {
       *wp++ = charset[(curr >> 12) & 0x3f];
       if (include_pad) {
-        *wp++ = kBase64Pad;
-        *wp = kBase64Pad;
+        *wp++ = kPadding;
+        *wp = kPadding;
       }
     }
   }
 }
 
+// static
 std::string Base64::encode(folly::StringPiece text) {
   return encodeImpl(text, kBase64Charset, true);
 }
 
+// static
 std::string Base64::encode(const char* data, size_t len) {
   return encode(folly::StringPiece(data, len));
 }
@@ -277,31 +299,25 @@ class IOBufWrapper {
 
 } // namespace
 
+// static
 std::string Base64::encode(const folly::IOBuf* data) {
   return encodeImpl(IOBufWrapper(data), kBase64Charset, true);
 }
 
-void Base64::encodeAppend(folly::StringPiece text, std::string& out) {
-  size_t outlen = calculateEncodedSize(text.size(), true);
-
-  size_t initialLen = out.size();
-  out.resize(initialLen + outlen);
-  encodeImpl(text, kBase64Charset, true, out.data() + initialLen);
-}
-
+// static
 std::string Base64::decode(folly::StringPiece encoded) {
   std::string output;
   Base64::decode(std::make_pair(encoded.data(), encoded.size()), output);
   return output;
 }
 
+// static
 void Base64::decode(
     const std::pair<const char*, int32_t>& payload,
     std::string& output) {
-  size_t out_len = payload.second / 4 * 3;
-  output.resize(out_len, '\0');
-  out_len = Base64::decode(payload.first, payload.second, &output[0], out_len);
-  output.resize(out_len);
+  size_t inputSize = payload.second;
+  output.resize(calculateDecodedSize(payload.first, inputSize));
+  decode(payload.first, inputSize, output.data(), output.size());
 }
 
 // static
@@ -310,81 +326,80 @@ void Base64::decode(const char* data, size_t size, char* output) {
   Base64::decode(data, size, output, out_len);
 }
 
-uint8_t Base64::Base64ReverseLookup(
+// static
+uint8_t Base64::base64ReverseLookup(
     char p,
-    const Base64::ReverseIndex& reverse_lookup) {
-  auto curr = reverse_lookup[(uint8_t)p];
+    const Base64::ReverseIndex& reverseIndex) {
+  auto curr = reverseIndex[(uint8_t)p];
   if (curr >= 0x40) {
-    throw Base64Exception(
-        "Base64::decode() - invalid input string: invalid characters");
+    VELOX_USER_FAIL("decode() - invalid input string: invalid characters");
   }
-
   return curr;
 }
 
+// static
 size_t
 Base64::decode(const char* src, size_t src_len, char* dst, size_t dst_len) {
-  return decodeImpl(src, src_len, dst, dst_len, kBase64ReverseIndexTable, true);
+  return decodeImpl(src, src_len, dst, dst_len, kBase64ReverseIndexTable);
 }
 
 // static
-size_t
-Base64::calculateDecodedSize(const char* data, size_t& size, bool withPadding) {
+size_t Base64::calculateDecodedSize(const char* data, size_t& size) {
   if (size == 0) {
     return 0;
   }
 
-  auto needed = (size / 4) * 3;
-  if (withPadding) {
-    // If the pad characters are included then the source string must be a
-    // multiple of 4 and we can query the end of the string to see how much
-    // padding exists.
-    if (size % 4 != 0) {
-      throw Base64Exception(
+  // Check if the input data is padded
+  if (isPadded(data, size)) {
+    // If padded, ensure that the string length is a multiple of the encoded
+    // block size
+    if (size % kEncodedBlockByteSize != 0) {
+      VELOX_USER_FAIL(
           "Base64::decode() - invalid input string: "
-          "string length is not multiple of 4.");
+          "string length is not a multiple of 4.");
     }
 
-    auto padding = countPadding(data, size);
+    auto needed = (size * kBinaryBlockByteSize) / kEncodedBlockByteSize;
+    auto padding = numPadding(data, size);
     size -= padding;
-    return needed - padding;
+
+    // Adjust the needed size by deducting the bytes corresponding to the
+    // padding from the calculated size.
+    return needed -
+        ((padding * kBinaryBlockByteSize) + (kEncodedBlockByteSize - 1)) /
+        kEncodedBlockByteSize;
   }
+  // If not padded, Calculate extra bytes, if any
+  auto extra = size % kEncodedBlockByteSize;
+  auto needed = (size / kEncodedBlockByteSize) * kBinaryBlockByteSize;
 
-  // If padding doesn't exist we need to calculate it from the size - if the
-  // size % 4 is 0 then we have an even multiple 3 byte chunks in the result
-  // if it is 2 then we need 1 more byte in the output.  If it is 3 then we
-  // need 2 more bytes in the output.  It should never be 1.
-  auto extra = size % 4;
+  // Adjust the needed size for extra bytes, if present
   if (extra) {
     if (extra == 1) {
-      throw Base64Exception(
+      VELOX_USER_FAIL(
           "Base64::decode() - invalid input string: "
           "string length cannot be 1 more than a multiple of 4.");
     }
-    return needed + extra - 1;
+    needed += (extra * kBinaryBlockByteSize) / kEncodedBlockByteSize;
   }
 
-  // Just because we don't need the pad, doesn't mean it is not there.  The
-  // URL decoder should be able to handle the original encoding.
-  auto padding = countPadding(data, size);
-  size -= padding;
-  return needed - padding;
+  return needed;
 }
 
+// static
 size_t Base64::decodeImpl(
     const char* src,
     size_t src_len,
     char* dst,
     size_t dst_len,
-    const Base64::ReverseIndex& reverse_lookup,
-    bool include_pad) {
+    const Base64::ReverseIndex& reverseIndex) {
   if (!src_len) {
     return 0;
   }
 
-  auto needed = calculateDecodedSize(src, src_len, include_pad);
+  auto needed = calculateDecodedSize(src, src_len);
   if (dst_len < needed) {
-    throw Base64Exception(
+    VELOX_USER_FAIL(
         "Base64::decode() - invalid output string: "
         "output string is too small.");
   }
@@ -394,10 +409,10 @@ size_t Base64::decodeImpl(
     // Each character of the 4 encode 6 bits of the original, grab each with
     // the appropriate shifts to rebuild the original and then split that back
     // into the original 8 bit bytes.
-    uint32_t last = (Base64ReverseLookup(src[0], reverse_lookup) << 18) |
-        (Base64ReverseLookup(src[1], reverse_lookup) << 12) |
-        (Base64ReverseLookup(src[2], reverse_lookup) << 6) |
-        Base64ReverseLookup(src[3], reverse_lookup);
+    uint32_t last = (base64ReverseLookup(src[0], reverseIndex) << 18) |
+        (base64ReverseLookup(src[1], reverseIndex) << 12) |
+        (base64ReverseLookup(src[2], reverseIndex) << 6) |
+        base64ReverseLookup(src[3], reverseIndex);
     dst[0] = (last >> 16) & 0xff;
     dst[1] = (last >> 8) & 0xff;
     dst[2] = last & 0xff;
@@ -406,14 +421,14 @@ size_t Base64::decodeImpl(
   // Handle the last 2-4 characters.  This is similar to the above, but the
   // last 2 characters may or may not exist.
   DCHECK(src_len >= 2);
-  uint32_t last = (Base64ReverseLookup(src[0], reverse_lookup) << 18) |
-      (Base64ReverseLookup(src[1], reverse_lookup) << 12);
+  uint32_t last = (base64ReverseLookup(src[0], reverseIndex) << 18) |
+      (base64ReverseLookup(src[1], reverseIndex) << 12);
   dst[0] = (last >> 16) & 0xff;
   if (src_len > 2) {
-    last |= Base64ReverseLookup(src[2], reverse_lookup) << 6;
+    last |= base64ReverseLookup(src[2], reverseIndex) << 6;
     dst[1] = (last >> 8) & 0xff;
     if (src_len > 3) {
-      last |= Base64ReverseLookup(src[3], reverse_lookup);
+      last |= base64ReverseLookup(src[3], reverseIndex);
       dst[2] = last & 0xff;
     }
   }
@@ -421,33 +436,38 @@ size_t Base64::decodeImpl(
   return needed;
 }
 
+// static
 std::string Base64::encodeUrl(folly::StringPiece text) {
   return encodeImpl(text, kBase64UrlCharset, false);
 }
 
+// static
 std::string Base64::encodeUrl(const char* data, size_t len) {
   return encodeUrl(folly::StringPiece(data, len));
 }
 
+// static
 std::string Base64::encodeUrl(const folly::IOBuf* data) {
   return encodeImpl(IOBufWrapper(data), kBase64UrlCharset, false);
 }
 
+// static
 void Base64::decodeUrl(
     const char* src,
     size_t src_len,
     char* dst,
-    size_t dst_len,
-    bool hasPad) {
-  decodeImpl(src, src_len, dst, dst_len, kBase64UrlReverseIndexTable, hasPad);
+    size_t dst_len) {
+  decodeImpl(src, src_len, dst, dst_len, kBase64UrlReverseIndexTable);
 }
 
+// static
 std::string Base64::decodeUrl(folly::StringPiece encoded) {
   std::string output;
   Base64::decodeUrl(std::make_pair(encoded.data(), encoded.size()), output);
   return output;
 }
 
+// static
 void Base64::decodeUrl(
     const std::pair<const char*, int32_t>& payload,
     std::string& output) {
@@ -458,8 +478,8 @@ void Base64::decodeUrl(
       payload.second,
       &output[0],
       out_len,
-      kBase64UrlReverseIndexTable,
-      false);
+      kBase64UrlReverseIndexTable);
   output.resize(out_len);
 }
+
 } // namespace facebook::velox::encoding
diff --git a/velox/common/encode/Base64.h b/velox/common/encode/Base64.h
index 9888d97e67c54..13004175379a6 100644
--- a/velox/common/encode/Base64.h
+++ b/velox/common/encode/Base64.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <array>
 #include <exception>
 #include <map>
 #include <string>
@@ -22,26 +23,34 @@
 #include <folly/Range.h>
 #include <folly/io/IOBuf.h>
 
+#include "velox/common/base/GTestMacros.h"
+
 namespace facebook::velox::encoding {
 
-class Base64Exception : public std::exception {
+class Base64 {
  public:
-  explicit Base64Exception(const char* msg) : msg_(msg) {}
-  const char* what() const noexcept override {
-    return msg_;
-  }
+  static const size_t kCharsetSize = 64;
+  static const size_t kReverseIndexSize = 256;
 
- protected:
-  const char* msg_;
-};
+  /// Character set used for encoding purposes.
+  /// Contains specific characters that form the encoding scheme.
+  using Charset = std::array<char, kCharsetSize>;
 
-class Base64 {
- public:
-  using Charset = std::array<char, 64>;
-  using ReverseIndex = std::array<uint8_t, 256>;
+  /// Reverse lookup table for decoding purposes.
+  /// Maps each possible encoded character to its corresponding numeric value
+  /// within the encoding base.
+  using ReverseIndex = std::array<uint8_t, kReverseIndexSize>;
+
+  /// Padding character used in encoding.
+  static const char kPadding = '=';
 
+  /// Encodes the specified number of characters from the 'data'.
   static std::string encode(const char* data, size_t len);
+
+  /// Encodes the specified text.
   static std::string encode(folly::StringPiece text);
+
+  /// Encodes the specified IOBuf data.
   static std::string encode(const folly::IOBuf* text);
 
   /// Returns encoded size for the input of the specified size.
@@ -52,15 +61,12 @@ class Base64 {
   /// returned by the calculateEncodedSize().
   static void encode(const char* data, size_t size, char* output);
 
-  // Appends the encoded text to out.
-  static void encodeAppend(folly::StringPiece text, std::string& out);
-
+  /// Decodes the specified encoded text.
   static std::string decode(folly::StringPiece encoded);
 
-  /// Returns decoded size for the specified input. Adjusts the 'size' to
-  /// subtract the length of the padding, if exists.
-  static size_t
-  calculateDecodedSize(const char* data, size_t& size, bool withPadding = true);
+  /// Returns the actual size of the decoded data. Will also remove the padding
+  /// length from the input data 'size'.
+  static size_t calculateDecodedSize(const char* data, size_t& size);
 
   /// Decodes the specified number of characters from the 'data' and writes the
   /// result to the 'output'. The output must have enough space, e.g. as
@@ -69,47 +75,68 @@ class Base64 {
 
   static void decode(
       const std::pair<const char*, int32_t>& payload,
-      std::string& outp);
+      std::string& output);
 
   /// Encodes the specified number of characters from the 'data' and writes the
-  /// result to the 'output'. The output must have enough space, e.g. as
-  /// returned by the calculateEncodedSize().
+  /// result to the 'output' using URL encoding. The output must have enough
+  /// space as returned by the calculateEncodedSize().
   static void encodeUrl(const char* data, size_t size, char* output);
 
-  // compatible with www's Base64URL::encode/decode
-  // TODO rename encode_url/decode_url to encodeUrl/encodeUrl.
+  /// Encodes the specified number of characters from the 'data' using URL
+  /// encoding.
   static std::string encodeUrl(const char* data, size_t len);
+
+  /// Encodes the specified IOBuf data using URL encoding.
   static std::string encodeUrl(const folly::IOBuf* data);
+
+  /// Encodes the specified text using URL encoding.
   static std::string encodeUrl(folly::StringPiece text);
+
+  /// Decodes the specified URL encoded payload and writes the result to the
+  /// 'output'.
   static void decodeUrl(
       const std::pair<const char*, int32_t>& payload,
       std::string& output);
+
+  /// Decodes the specified URL encoded text.
   static std::string decodeUrl(folly::StringPiece text);
 
+  /// Decodes the specified number of characters from the 'src' and writes the
+  /// result to the 'dst'.
   static size_t
   decode(const char* src, size_t src_len, char* dst, size_t dst_len);
 
-  static void decodeUrl(
-      const char* src,
-      size_t src_len,
-      char* dst,
-      size_t dst_len,
-      bool pad);
-
-  constexpr static char kBase64Pad = '=';
+  /// Decodes the specified number of characters from the 'src' using URL
+  /// encoding and writes the result to the 'dst'.
+  static void
+  decodeUrl(const char* src, size_t src_len, char* dst, size_t dst_len);
 
  private:
-  static inline size_t countPadding(const char* src, size_t len) {
-    DCHECK_GE(len, 2);
-    return src[len - 1] != kBase64Pad ? 0 : src[len - 2] != kBase64Pad ? 1 : 2;
+  /// Checks if there is padding in encoded data.
+  static inline bool isPadded(const char* data, size_t len) {
+    return (len > 0 && data[len - 1] == kPadding);
   }
 
-  static uint8_t Base64ReverseLookup(char p, const ReverseIndex& table);
+  /// Counts the number of padding characters in encoded data.
+  static inline size_t numPadding(const char* src, size_t len) {
+    size_t numPadding{0};
+    while (len > 0 && src[len - 1] == kPadding) {
+      numPadding++;
+      len--;
+    }
+    return numPadding;
+  }
+
+  /// Performs a reverse lookup in the reverse index to retrieve the original
+  /// index of a character in the base.
+  static uint8_t base64ReverseLookup(char p, const ReverseIndex& reverseIndex);
 
+  /// Encodes the specified data using the provided charset.
   template <class T>
   static std::string
   encodeImpl(const T& data, const Charset& charset, bool include_pad);
 
+  /// Encodes the specified data using the provided charset.
   template <class T>
   static void encodeImpl(
       const T& data,
@@ -117,13 +144,16 @@ class Base64 {
       bool include_pad,
       char* out);
 
+  /// Decodes the specified data using the provided reverse lookup table.
   static size_t decodeImpl(
       const char* src,
       size_t src_len,
       char* dst,
       size_t dst_len,
-      const ReverseIndex& table,
-      bool include_pad);
+      const ReverseIndex& table);
+
+  VELOX_FRIEND_TEST(Base64Test, checksPadding);
+  VELOX_FRIEND_TEST(Base64Test, countsPaddingCorrectly);
 };
 
 } // namespace facebook::velox::encoding
diff --git a/velox/common/encode/CMakeLists.txt b/velox/common/encode/CMakeLists.txt
index d9918d53b59c5..501c690c476bd 100644
--- a/velox/common/encode/CMakeLists.txt
+++ b/velox/common/encode/CMakeLists.txt
@@ -12,5 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_encode Base64.cpp)
-target_link_libraries(velox_encode PUBLIC Folly::folly)
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
+
+velox_add_library(velox_encode Base64.cpp)
+velox_link_libraries(velox_encode PUBLIC Folly::folly)
diff --git a/velox/common/encode/tests/Base64Test.cpp b/velox/common/encode/tests/Base64Test.cpp
new file mode 100644
index 0000000000000..9cbbbad471245
--- /dev/null
+++ b/velox/common/encode/tests/Base64Test.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/encode/Base64.h"
+
+#include <gtest/gtest.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+namespace facebook::velox::encoding {
+
+class Base64Test : public ::testing::Test {};
+
+TEST_F(Base64Test, fromBase64) {
+  EXPECT_EQ(
+      "Hello, World!",
+      Base64::decode(folly::StringPiece("SGVsbG8sIFdvcmxkIQ==")));
+  EXPECT_EQ(
+      "Base64 encoding is fun.",
+      Base64::decode(folly::StringPiece("QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4=")));
+  EXPECT_EQ(
+      "Simple text", Base64::decode(folly::StringPiece("U2ltcGxlIHRleHQ=")));
+  EXPECT_EQ(
+      "1234567890", Base64::decode(folly::StringPiece("MTIzNDU2Nzg5MA==")));
+
+  // Check encoded strings without padding
+  EXPECT_EQ(
+      "Hello, World!",
+      Base64::decode(folly::StringPiece("SGVsbG8sIFdvcmxkIQ")));
+  EXPECT_EQ(
+      "Base64 encoding is fun.",
+      Base64::decode(folly::StringPiece("QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4")));
+  EXPECT_EQ(
+      "Simple text", Base64::decode(folly::StringPiece("U2ltcGxlIHRleHQ")));
+  EXPECT_EQ("1234567890", Base64::decode(folly::StringPiece("MTIzNDU2Nzg5MA")));
+}
+
+TEST_F(Base64Test, calculateDecodedSizeProperSize) {
+  size_t encoded_size{0};
+
+  encoded_size = 20;
+  EXPECT_EQ(
+      13, Base64::calculateDecodedSize("SGVsbG8sIFdvcmxkIQ==", encoded_size));
+  EXPECT_EQ(18, encoded_size);
+
+  encoded_size = 18;
+  EXPECT_EQ(
+      13, Base64::calculateDecodedSize("SGVsbG8sIFdvcmxkIQ", encoded_size));
+  EXPECT_EQ(18, encoded_size);
+
+  encoded_size = 21;
+  VELOX_ASSERT_THROW(
+      Base64::calculateDecodedSize("SGVsbG8sIFdvcmxkIQ==", encoded_size),
+      "Base64::decode() - invalid input string: string length cannot be 1 more than a multiple of 4.");
+
+  encoded_size = 32;
+  EXPECT_EQ(
+      23,
+      Base64::calculateDecodedSize(
+          "QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4=", encoded_size));
+  EXPECT_EQ(31, encoded_size);
+
+  encoded_size = 31;
+  EXPECT_EQ(
+      23,
+      Base64::calculateDecodedSize(
+          "QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4", encoded_size));
+  EXPECT_EQ(31, encoded_size);
+
+  encoded_size = 16;
+  EXPECT_EQ(10, Base64::calculateDecodedSize("MTIzNDU2Nzg5MA==", encoded_size));
+  EXPECT_EQ(14, encoded_size);
+
+  encoded_size = 14;
+  EXPECT_EQ(10, Base64::calculateDecodedSize("MTIzNDU2Nzg5MA", encoded_size));
+  EXPECT_EQ(14, encoded_size);
+}
+
+TEST_F(Base64Test, checksPadding) {
+  EXPECT_TRUE(Base64::isPadded("ABC=", 4));
+  EXPECT_FALSE(Base64::isPadded("ABC", 3));
+}
+
+TEST_F(Base64Test, countsPaddingCorrectly) {
+  EXPECT_EQ(0, Base64::numPadding("ABC", 3));
+  EXPECT_EQ(1, Base64::numPadding("ABC=", 4));
+  EXPECT_EQ(2, Base64::numPadding("AB==", 4));
+}
+} // namespace facebook::velox::encoding
diff --git a/velox/common/encode/tests/CMakeLists.txt b/velox/common/encode/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..90c9733ecf22e
--- /dev/null
+++ b/velox/common/encode/tests/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_common_encode_test Base64Test.cpp)
+add_test(velox_common_encode_test velox_common_encode_test)
+target_link_libraries(
+  velox_common_encode_test
+  PUBLIC Folly::folly
+  PRIVATE velox_encode velox_exception GTest::gtest GTest::gtest_main)
diff --git a/velox/common/file/CMakeLists.txt b/velox/common/file/CMakeLists.txt
index fd139c168a12f..31d9f1ebe0ff9 100644
--- a/velox/common/file/CMakeLists.txt
+++ b/velox/common/file/CMakeLists.txt
@@ -14,15 +14,17 @@
 
 # for generated headers
 include_directories(.)
-add_library(velox_file File.cpp FileSystems.cpp Utils.cpp)
-target_link_libraries(
+velox_add_library(
+  velox_file
+  File.cpp
+  FileInputStream.cpp
+  FileSystems.cpp
+  Utils.cpp)
+velox_link_libraries(
   velox_file
   PUBLIC velox_exception Folly::folly
-  PRIVATE velox_common_base fmt::fmt glog::glog)
+  PRIVATE velox_buffer velox_common_base fmt::fmt glog::glog)
 
-if(${VELOX_BUILD_TESTING})
+if(${VELOX_BUILD_TESTING} OR ${VELOX_BUILD_TEST_UTILS})
   add_subdirectory(tests)
 endif()
-if(${VELOX_ENABLE_BENCHMARKS})
-  add_subdirectory(benchmark)
-endif()
diff --git a/velox/common/file/File.cpp b/velox/common/file/File.cpp
index 68b5c4656b333..46156c2f1aa77 100644
--- a/velox/common/file/File.cpp
+++ b/velox/common/file/File.cpp
@@ -22,8 +22,11 @@
 #include <memory>
 #include <stdexcept>
 
-#include <fcntl.h>
 #include <folly/portability/SysUio.h>
+#ifdef linux
+#include <linux/fs.h>
+#endif // linux
+#include <sys/ioctl.h>
 
 namespace facebook::velox {
 
@@ -33,6 +36,27 @@ namespace facebook::velox {
     return result;                    \
   }
 
+namespace {
+FOLLY_ALWAYS_INLINE void checkNotClosed(bool closed) {
+  VELOX_CHECK(!closed, "file is closed");
+}
+
+template <typename T>
+T getAttribute(
+    const std::unordered_map<std::string, std::string>& attributes,
+    const std::string_view& key,
+    const T& defaultValue) {
+  if (attributes.count(std::string(key)) > 0) {
+    try {
+      return folly::to<T>(attributes.at(std::string(key)));
+    } catch (const std::exception& e) {
+      VELOX_FAIL("Failed while parsing File attributes: {}", e.what());
+    }
+  }
+  return defaultValue;
+}
+} // namespace
+
 std::string ReadFile::pread(uint64_t offset, uint64_t length) const {
   std::string buf;
   buf.resize(length);
@@ -61,17 +85,21 @@ uint64_t ReadFile::preadv(
   return numRead;
 }
 
-void ReadFile::preadv(
+uint64_t ReadFile::preadv(
     folly::Range<const common::Region*> regions,
     folly::Range<folly::IOBuf*> iobufs) const {
   VELOX_CHECK_EQ(regions.size(), iobufs.size());
+  uint64_t length = 0;
   for (size_t i = 0; i < regions.size(); ++i) {
     const auto& region = regions[i];
     auto& output = iobufs[i];
     output = folly::IOBuf(folly::IOBuf::CREATE, region.length);
     pread(region.offset, region.length, output.writableData());
     output.append(region.length);
+    length += region.length;
   }
+
+  return length;
 }
 
 std::string_view
@@ -90,28 +118,39 @@ void InMemoryWriteFile::append(std::string_view data) {
   file_->append(data);
 }
 
+void InMemoryWriteFile::append(std::unique_ptr<folly::IOBuf> data) {
+  for (auto rangeIter = data->begin(); rangeIter != data->end(); ++rangeIter) {
+    file_->append(
+        reinterpret_cast<const char*>(rangeIter->data()), rangeIter->size());
+  }
+}
+
 uint64_t InMemoryWriteFile::size() const {
   return file_->size();
 }
 
 LocalReadFile::LocalReadFile(std::string_view path) : path_(path) {
   fd_ = open(path_.c_str(), O_RDONLY);
+  if (fd_ < 0) {
+    if (errno == ENOENT) {
+      VELOX_FILE_NOT_FOUND_ERROR("No such file or directory: {}", path);
+    } else {
+      VELOX_FAIL(
+          "open failure in LocalReadFile constructor, {} {} {}.",
+          fd_,
+          path,
+          folly::errnoStr(errno));
+    }
+  }
+  const off_t ret = lseek(fd_, 0, SEEK_END);
   VELOX_CHECK_GE(
-      fd_,
-      0,
-      "open failure in LocalReadFile constructor, {} {} {}.",
-      fd_,
-      path,
-      folly::errnoStr(errno));
-  const off_t rc = lseek(fd_, 0, SEEK_END);
-  VELOX_CHECK_GE(
-      rc,
+      ret,
       0,
       "fseek failure in LocalReadFile constructor, {} {} {}.",
-      rc,
+      ret,
       path,
       folly::errnoStr(errno));
-  size_ = rc;
+  size_ = ret;
 }
 
 LocalReadFile::LocalReadFile(int32_t fd) : fd_(fd) {}
@@ -210,36 +249,62 @@ uint64_t LocalReadFile::memoryUsage() const {
   return sizeof(FILE);
 }
 
+bool LocalWriteFile::Attributes::cowDisabled(
+    const std::unordered_map<std::string, std::string>& attrs) {
+  return getAttribute<bool>(attrs, kNoCow, kDefaultNoCow);
+}
+
 LocalWriteFile::LocalWriteFile(
     std::string_view path,
     bool shouldCreateParentDirectories,
-    bool shouldThrowOnFileAlreadyExists) {
-  auto dir = fs::path(path).parent_path();
+    bool shouldThrowOnFileAlreadyExists,
+    bool bufferWrite)
+    : path_(path) {
+  const auto dir = fs::path(path_).parent_path();
   if (shouldCreateParentDirectories && !fs::exists(dir)) {
     VELOX_CHECK(
         common::generateFileDirectory(dir.c_str()),
         "Failed to generate file directory");
   }
 
-  std::unique_ptr<char[]> buf(new char[path.size() + 1]);
-  buf[path.size()] = 0;
-  memcpy(buf.get(), path.data(), path.size());
-  {
-    if (shouldThrowOnFileAlreadyExists) {
-      FILE* exists = fopen(buf.get(), "rb");
-      VELOX_CHECK(
-          !exists,
-          "Failure in LocalWriteFile: path '{}' already exists.",
-          path);
-    }
+  // File open flags: write-only, create the file if it doesn't exist.
+  int32_t flags = O_WRONLY | O_CREAT;
+  if (shouldThrowOnFileAlreadyExists) {
+    flags |= O_EXCL;
   }
-  auto file = fopen(buf.get(), "ab");
-  VELOX_CHECK(
-      file,
-      "fopen failure in LocalWriteFile constructor, {} {}.",
-      path,
+#ifdef linux
+  if (!bufferWrite) {
+    flags |= O_DIRECT;
+  }
+#endif // linux
+
+  // The file mode bits to be applied when a new file is created. By default
+  // user has read and write access to the file.
+  // NOTE: The mode argument must be supplied if O_CREAT or O_TMPFILE is
+  // specified in flags; if it is not supplied, some arbitrary bytes from the
+  // stack will be applied as the file mode.
+  const int32_t mode = S_IRUSR | S_IWUSR;
+
+  std::unique_ptr<char[]> buf(new char[path_.size() + 1]);
+  buf[path_.size()] = 0;
+  ::memcpy(buf.get(), path_.data(), path_.size());
+  fd_ = open(buf.get(), flags, mode);
+  VELOX_CHECK_GE(
+      fd_,
+      0,
+      "Cannot open or create {}. Error: {}",
+      path_,
+      folly::errnoStr(errno));
+
+  const off_t ret = lseek(fd_, 0, SEEK_END);
+  VELOX_CHECK_GE(
+      ret,
+      0,
+      "fseek failure in LocalWriteFile constructor, {} {} {}.",
+      ret,
+      path_,
       folly::errnoStr(errno));
-  file_ = file;
+  size_ = ret;
 }
 
 LocalWriteFile::~LocalWriteFile() {
@@ -253,39 +318,125 @@ LocalWriteFile::~LocalWriteFile() {
 }
 
 void LocalWriteFile::append(std::string_view data) {
-  VELOX_CHECK(!closed_, "file is closed");
-  const uint64_t bytes_written = fwrite(data.data(), 1, data.size(), file_);
+  checkNotClosed(closed_);
+  const uint64_t bytesWritten = ::write(fd_, data.data(), data.size());
   VELOX_CHECK_EQ(
-      bytes_written,
+      bytesWritten,
       data.size(),
-      "fwrite failure in LocalWriteFile::append, {} vs {}.",
-      bytes_written,
-      data.size());
+      "fwrite failure in LocalWriteFile::append, {} vs {}: {}",
+      bytesWritten,
+      data.size(),
+      folly::errnoStr(errno));
+  size_ += bytesWritten;
+}
+
+void LocalWriteFile::append(std::unique_ptr<folly::IOBuf> data) {
+  checkNotClosed(closed_);
+  uint64_t totalBytesWritten{0};
+  for (auto rangeIter = data->begin(); rangeIter != data->end(); ++rangeIter) {
+    const auto bytesToWrite = rangeIter->size();
+    const uint64_t bytesWritten =
+        ::write(fd_, rangeIter->data(), rangeIter->size());
+    totalBytesWritten += bytesWritten;
+    if (bytesWritten != bytesToWrite) {
+      VELOX_FAIL(
+          "fwrite failure in LocalWriteFile::append, {} vs {}: {}",
+          bytesWritten,
+          bytesToWrite,
+          folly::errnoStr(errno));
+    }
+  }
+  const auto totalBytesToWrite = data->computeChainDataLength();
+  VELOX_CHECK_EQ(
+      totalBytesWritten,
+      totalBytesToWrite,
+      "Failure in LocalWriteFile::append, {} vs {}",
+      totalBytesWritten,
+      totalBytesToWrite);
+  size_ += totalBytesWritten;
+}
+
+void LocalWriteFile::write(
+    const std::vector<iovec>& iovecs,
+    int64_t offset,
+    int64_t length) {
+  checkNotClosed(closed_);
+  VELOX_CHECK_GE(offset, 0, "Offset cannot be negative.");
+  const auto bytesWritten = ::pwritev(
+      fd_, iovecs.data(), static_cast<ssize_t>(iovecs.size()), offset);
+  VELOX_CHECK_EQ(
+      bytesWritten,
+      length,
+      "Failure in LocalWriteFile::write, {} vs {}",
+      bytesWritten,
+      length);
+  size_ = std::max<uint64_t>(size_, offset + bytesWritten);
+}
+
+void LocalWriteFile::truncate(int64_t newSize) {
+  checkNotClosed(closed_);
+  VELOX_CHECK_GE(newSize, 0, "New size cannot be negative.");
+  const auto ret = ::ftruncate(fd_, newSize);
+  VELOX_CHECK_EQ(
+      ret,
+      0,
+      "ftruncate failed in LocalWriteFile::truncate: {}.",
+      folly::errnoStr(errno));
+  size_ = newSize;
 }
 
 void LocalWriteFile::flush() {
-  VELOX_CHECK(!closed_, "file is closed");
-  auto ret = fflush(file_);
+  checkNotClosed(closed_);
+  const auto ret = ::fsync(fd_);
   VELOX_CHECK_EQ(
       ret,
       0,
-      "fflush failed in LocalWriteFile::flush: {}.",
+      "fsync failed in LocalWriteFile::flush: {}.",
       folly::errnoStr(errno));
 }
 
+void LocalWriteFile::setAttributes(
+    const std::unordered_map<std::string, std::string>& attributes) {
+  checkNotClosed(closed_);
+  attributes_ = attributes;
+#ifdef linux
+  if (Attributes::cowDisabled(attributes_)) {
+    int attr{0};
+    auto ret = ioctl(fd_, FS_IOC_GETFLAGS, &attr);
+    VELOX_CHECK_EQ(
+        0,
+        ret,
+        "ioctl(FS_IOC_GETFLAGS) failed: {}, {}",
+        ret,
+        folly::errnoStr(errno));
+    attr |= FS_NOCOW_FL;
+    ret = ioctl(fd_, FS_IOC_SETFLAGS, &attr);
+    VELOX_CHECK_EQ(
+        0,
+        ret,
+        "ioctl(FS_IOC_SETFLAGS, FS_NOCOW_FL) failed: {}, {}",
+        ret,
+        folly::errnoStr(errno));
+  }
+#endif // linux
+}
+
+std::unordered_map<std::string, std::string> LocalWriteFile::getAttributes()
+    const {
+  checkNotClosed(closed_);
+  return attributes_;
+}
+
 void LocalWriteFile::close() {
   if (!closed_) {
-    auto ret = fclose(file_);
+    const auto ret = ::close(fd_);
     VELOX_CHECK_EQ(
         ret,
         0,
-        "fwrite failure in LocalWriteFile::close: {}.",
+        "close failed in LocalWriteFile::close: {}.",
         folly::errnoStr(errno));
     closed_ = true;
   }
 }
 
-uint64_t LocalWriteFile::size() const {
-  return ftell(file_);
-}
 } // namespace facebook::velox
diff --git a/velox/common/file/File.h b/velox/common/file/File.h
index f851fcac9f329..294961a32c55e 100644
--- a/velox/common/file/File.h
+++ b/velox/common/file/File.h
@@ -26,6 +26,7 @@
 
 #pragma once
 
+#include <fcntl.h>
 #include <atomic>
 #include <cstdint>
 #include <cstdio>
@@ -50,8 +51,8 @@ class ReadFile {
   // buffer 'buf'. The bytes are returned as a string_view pointing to 'buf'.
   //
   // This method should be thread safe.
-  virtual std::string_view
-  pread(uint64_t offset, uint64_t length, void* FOLLY_NONNULL buf) const = 0;
+  virtual std::string_view pread(uint64_t offset, uint64_t length, void* buf)
+      const = 0;
 
   // Same as above, but returns owned data directly.
   //
@@ -74,17 +75,19 @@ class ReadFile {
   // array must be pre-allocated by the caller, with the same size as `regions`,
   // but don't need to be initialized, since each iobuf will be copy-constructed
   // by the preadv.
+  // Returns the total number of bytes read, which might be different than the
+  // sum of all buffer sizes (for example, if coalescing was used).
   //
   // This method should be thread safe.
-  virtual void preadv(
+  virtual uint64_t preadv(
       folly::Range<const common::Region*> regions,
       folly::Range<folly::IOBuf*> iobufs) const;
 
-  // Like preadv but may execute asynchronously and returns the read
-  // size or exception via SemiFuture. Use hasPreadvAsync() to check
-  // if the implementation is in fact asynchronous.
-  //
-  // This method should be thread safe.
+  /// Like preadv but may execute asynchronously and returns the read size or
+  /// exception via SemiFuture. Use hasPreadvAsync() to check if the
+  /// implementation is in fact asynchronous.
+  ///
+  /// This method should be thread safe.
   virtual folly::SemiFuture<uint64_t> preadvAsync(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers) const {
@@ -124,10 +127,8 @@ class ReadFile {
 
   virtual std::string getName() const = 0;
 
-  //
-  // Get the natural size for reads.
-  // @return the number of bytes that should be read at once
-  //
+  /// Gets the natural size for reads. Returns the number of bytes that should
+  /// be read at once.
   virtual uint64_t getNaturalReadSize() const = 0;
 
  protected:
@@ -140,17 +141,55 @@ class WriteFile {
  public:
   virtual ~WriteFile() = default;
 
-  // Appends data to the end of the file.
+  /// Appends data to the end of the file.
   virtual void append(std::string_view data) = 0;
 
-  // Flushes any local buffers, i.e. ensures the backing medium received
-  // all data that has been appended.
+  /// Appends data to the end of the file.
+  virtual void append(std::unique_ptr<folly::IOBuf> /* data */) {
+    VELOX_NYI("IOBuf appending is not implemented");
+  }
+
+  /// Writes data at the given offset of the file.
+  ///
+  /// NOTE: this is only supported on local file system and used by SSD cache
+  /// for now. For filesystem like S3, it is not supported.
+  virtual void write(
+      const std::vector<iovec>& /* iovecs */,
+      int64_t /* offset */,
+      int64_t /* length */
+  ) {
+    VELOX_NYI("{} is not implemented", __FUNCTION__);
+  }
+
+  /// Truncates file to a new size.
+  ///
+  /// NOTE: this is only supported on local file system and used by SSD cache
+  /// for now. For filesystem like S3, it is not supported.
+  virtual void truncate(int64_t /* newSize */) {
+    VELOX_NYI("{} is not implemented", __FUNCTION__);
+  }
+
+  /// Flushes any write buffers, i.e. ensures the remote storage backend or
+  /// local storage medium received all the written data.
   virtual void flush() = 0;
 
-  // Close the file. Any cleanup (disk flush, etc.) will be done here.
+  /// Sets the file attributes, which are file implementation specific.
+  virtual void setAttributes(
+      const std::unordered_map<std::string, std::string>& /* attributes */) {
+    VELOX_NYI("{} is not implemented", __FUNCTION__);
+  }
+
+  /// Gets the file attributes, which are file implementation specific.
+  virtual std::unordered_map<std::string, std::string> getAttributes() const {
+    VELOX_NYI("{} is not implemented", __FUNCTION__);
+  }
+
+  /// Closes the file. Any cleanup (disk flush, etc.) will be done here.
   virtual void close() = 0;
 
-  // Current file size, i.e. the sum of all previous Appends.
+  /// Current file size, i.e. the sum of all previous Appends.  No flush should
+  /// be needed to get the exact size written, and this should be able to be
+  /// called after the file close.
   virtual uint64_t size() const = 0;
 };
 
@@ -169,10 +208,8 @@ class InMemoryReadFile : public ReadFile {
   explicit InMemoryReadFile(std::string file)
       : ownedFile_(std::move(file)), file_(ownedFile_) {}
 
-  std::string_view pread(
-      uint64_t offset,
-      uint64_t length,
-      void* FOLLY_NONNULL buf) const override;
+  std::string_view pread(uint64_t offset, uint64_t length, void* buf)
+      const override;
 
   std::string pread(uint64_t offset, uint64_t length) const override;
 
@@ -208,31 +245,33 @@ class InMemoryReadFile : public ReadFile {
 
 class InMemoryWriteFile final : public WriteFile {
  public:
-  explicit InMemoryWriteFile(std::string* FOLLY_NONNULL file) : file_(file) {}
+  explicit InMemoryWriteFile(std::string* file) : file_(file) {}
 
   void append(std::string_view data) final;
+  void append(std::unique_ptr<folly::IOBuf> data) final;
   void flush() final {}
   void close() final {}
   uint64_t size() const final;
 
  private:
-  std::string* FOLLY_NONNULL file_;
+  std::string* file_;
 };
 
-// Current implementation for the local version is quite simple (e.g. no
-// internal arenaing), as local disk writes are expected to be cheap. Local
-// files match against any filepath starting with '/'.
-
+/// Current implementation for the local version is quite simple (e.g. no
+/// internal arenaing), as local disk writes are expected to be cheap. Local
+/// files match against any filepath starting with '/'.
 class LocalReadFile final : public ReadFile {
  public:
   explicit LocalReadFile(std::string_view path);
 
+  /// TODO: deprecate this after creating local file all through velox fs
+  /// interface.
   explicit LocalReadFile(int32_t fd);
 
   ~LocalReadFile();
 
-  std::string_view
-  pread(uint64_t offset, uint64_t length, void* FOLLY_NONNULL buf) const final;
+  std::string_view pread(uint64_t offset, uint64_t length, void* buf)
+      const final;
 
   uint64_t size() const final;
 
@@ -258,8 +297,7 @@ class LocalReadFile final : public ReadFile {
   }
 
  private:
-  void preadInternal(uint64_t offset, uint64_t length, char* FOLLY_NONNULL pos)
-      const;
+  void preadInternal(uint64_t offset, uint64_t length, char* pos) const;
 
   std::string path_;
   int32_t fd_;
@@ -268,22 +306,55 @@ class LocalReadFile final : public ReadFile {
 
 class LocalWriteFile final : public WriteFile {
  public:
+  struct Attributes {
+    // If set to true, the file will not be subject to copy-on-write updates.
+    // This flag has an effect only on filesystems that support copy-on-write
+    // semantics, such as Btrfs.
+    static constexpr std::string_view kNoCow{"write-on-copy-disabled"};
+    static constexpr bool kDefaultNoCow{false};
+
+    static bool cowDisabled(
+        const std::unordered_map<std::string, std::string>& attrs);
+  };
+
   // An error is thrown is a file already exists at |path|,
   // unless flag shouldThrowOnFileAlreadyExists is false
   explicit LocalWriteFile(
       std::string_view path,
       bool shouldCreateParentDirectories = false,
-      bool shouldThrowOnFileAlreadyExists = true);
+      bool shouldThrowOnFileAlreadyExists = true,
+      bool bufferWrite = true);
+
   ~LocalWriteFile();
 
   void append(std::string_view data) final;
+
+  void append(std::unique_ptr<folly::IOBuf> data) final;
+
+  void write(const std::vector<iovec>& iovecs, int64_t offset, int64_t length)
+      final;
+
+  void truncate(int64_t newSize) final;
+
   void flush() final;
+
+  void setAttributes(
+      const std::unordered_map<std::string, std::string>& attributes) final;
+
+  std::unordered_map<std::string, std::string> getAttributes() const final;
+
   void close() final;
-  uint64_t size() const final;
+
+  uint64_t size() const final {
+    return size_;
+  }
 
  private:
-  FILE* FOLLY_NONNULL file_;
-  mutable long size_;
+  // File descriptor.
+  int32_t fd_{-1};
+  std::string path_;
+  uint64_t size_{0};
+  std::unordered_map<std::string, std::string> attributes_{};
   bool closed_{false};
 };
 
diff --git a/velox/common/file/FileInputStream.cpp b/velox/common/file/FileInputStream.cpp
new file mode 100644
index 0000000000000..e680733c637b4
--- /dev/null
+++ b/velox/common/file/FileInputStream.cpp
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/file/FileInputStream.h"
+
+namespace facebook::velox::common {
+
+FileInputStream::FileInputStream(
+    std::unique_ptr<ReadFile>&& file,
+    uint64_t bufferSize,
+    memory::MemoryPool* pool)
+    : file_(std::move(file)),
+      fileSize_(file_->size()),
+      bufferSize_(std::min(fileSize_, bufferSize)),
+      pool_(pool),
+      readAheadEnabled_((bufferSize_ < fileSize_) && file_->hasPreadvAsync()) {
+  VELOX_CHECK_NOT_NULL(pool_);
+  VELOX_CHECK_GT(fileSize_, 0, "Empty FileInputStream");
+
+  buffers_.push_back(AlignedBuffer::allocate<char>(bufferSize_, pool_));
+  if (readAheadEnabled_) {
+    buffers_.push_back(AlignedBuffer::allocate<char>(bufferSize_, pool_));
+  }
+  readNextRange();
+}
+
+FileInputStream::~FileInputStream() {
+  if (!readAheadWait_.valid()) {
+    return;
+  }
+  try {
+    readAheadWait_.wait();
+  } catch (const std::exception& ex) {
+    // ignore any prefetch error when query has failed.
+    LOG(WARNING) << "FileInputStream read-ahead failed on destruction "
+                 << ex.what();
+  }
+}
+
+void FileInputStream::readNextRange() {
+  VELOX_CHECK(current_ == nullptr || current_->availableBytes() == 0);
+  ranges_.clear();
+  current_ = nullptr;
+
+  int32_t readBytes{0};
+  uint64_t readTimeNs{0};
+  {
+    NanosecondTimer timer{&readTimeNs};
+    if (readAheadWait_.valid()) {
+      readBytes = std::move(readAheadWait_)
+                      .via(&folly::QueuedImmediateExecutor::instance())
+                      .wait()
+                      .value();
+      VELOX_CHECK(!readAheadWait_.valid());
+      VELOX_CHECK_LT(
+          0, readBytes, "Read past end of FileInputStream {}", fileSize_);
+      advanceBuffer();
+    } else {
+      readBytes = readSize();
+      VELOX_CHECK_LT(
+          0, readBytes, "Read past end of FileInputStream {}", fileSize_);
+      NanosecondTimer timer{&readTimeNs};
+      file_->pread(fileOffset_, readBytes, buffer()->asMutable<char>());
+    }
+  }
+
+  ranges_.resize(1);
+  ranges_[0] = {buffer()->asMutable<uint8_t>(), readBytes, 0};
+  current_ = ranges_.data();
+  fileOffset_ += readBytes;
+
+  updateStats(readBytes, readTimeNs);
+
+  maybeIssueReadahead();
+}
+
+size_t FileInputStream::size() const {
+  return fileSize_;
+}
+
+bool FileInputStream::atEnd() const {
+  return tellp() >= fileSize_;
+}
+
+std::streampos FileInputStream::tellp() const {
+  if (current_ == nullptr) {
+    VELOX_CHECK_EQ(fileOffset_, fileSize_);
+    return fileOffset_;
+  }
+  return fileOffset_ - current_->availableBytes();
+}
+
+void FileInputStream::seekp(std::streampos position) {
+  static_assert(sizeof(std::streamsize) <= sizeof(int64_t));
+  const int64_t seekPos = position;
+  const int64_t curPos = tellp();
+  VELOX_CHECK_GE(
+      seekPos, curPos, "Backward seek is not supported by FileInputStream");
+
+  const int64_t toSkip = seekPos - curPos;
+  if (toSkip == 0) {
+    return;
+  }
+  doSeek(toSkip);
+}
+
+void FileInputStream::skip(int32_t size) {
+  doSeek(size);
+}
+
+void FileInputStream::doSeek(int64_t skipBytes) {
+  VELOX_CHECK_GE(skipBytes, 0, "Attempting to skip negative number of bytes");
+  if (skipBytes == 0) {
+    return;
+  }
+
+  VELOX_CHECK_LE(
+      skipBytes,
+      remainingSize(),
+      "Skip past the end of FileInputStream: {}",
+      fileSize_);
+
+  for (;;) {
+    const int64_t skippedBytes =
+        std::min<int64_t>(current_->availableBytes(), skipBytes);
+    skipBytes -= skippedBytes;
+    current_->position += skippedBytes;
+    if (skipBytes == 0) {
+      return;
+    }
+    readNextRange();
+  }
+}
+
+size_t FileInputStream::remainingSize() const {
+  return fileSize_ - tellp();
+}
+
+uint8_t FileInputStream::readByte() {
+  VELOX_CHECK_GT(
+      remainingSize(), 0, "Read past the end of input file {}", fileSize_);
+
+  if (current_->availableBytes() > 0) {
+    return current_->buffer[current_->position++];
+  }
+  readNextRange();
+  return readByte();
+}
+
+void FileInputStream::readBytes(uint8_t* bytes, int32_t size) {
+  VELOX_CHECK_GE(size, 0, "Attempting to read negative number of bytes");
+  if (size == 0) {
+    return;
+  }
+
+  VELOX_CHECK_LE(
+      size, remainingSize(), "Read past the end of input file {}", fileSize_);
+
+  int32_t offset{0};
+  for (;;) {
+    const int32_t readBytes =
+        std::min<int64_t>(current_->availableBytes(), size);
+    simd::memcpy(
+        bytes + offset, current_->buffer + current_->position, readBytes);
+    offset += readBytes;
+    size -= readBytes;
+    current_->position += readBytes;
+    if (size == 0) {
+      return;
+    }
+    readNextRange();
+  }
+}
+
+std::string_view FileInputStream::nextView(int32_t size) {
+  VELOX_CHECK_GE(size, 0, "Attempting to view negative number of bytes");
+  if (remainingSize() == 0) {
+    return std::string_view(nullptr, 0);
+  }
+
+  if (current_->availableBytes() == 0) {
+    readNextRange();
+  }
+
+  VELOX_CHECK_GT(current_->availableBytes(), 0);
+  const auto position = current_->position;
+  const auto viewSize = std::min<int64_t>(current_->availableBytes(), size);
+  current_->position += viewSize;
+  return std::string_view(
+      reinterpret_cast<char*>(current_->buffer) + position, viewSize);
+}
+
+uint64_t FileInputStream::readSize() const {
+  return std::min(fileSize_ - fileOffset_, bufferSize_);
+}
+
+void FileInputStream::maybeIssueReadahead() {
+  VELOX_CHECK(!readAheadWait_.valid());
+  if (!readAheadEnabled_) {
+    return;
+  }
+  const auto size = readSize();
+  if (size == 0) {
+    return;
+  }
+  std::vector<folly::Range<char*>> ranges;
+  ranges.emplace_back(nextBuffer()->asMutable<char>(), size);
+  readAheadWait_ = file_->preadvAsync(fileOffset_, ranges);
+  VELOX_CHECK(readAheadWait_.valid());
+}
+
+void FileInputStream::updateStats(uint64_t readBytes, uint64_t readTimeNs) {
+  stats_.readBytes += readBytes;
+  stats_.readTimeNs += readTimeNs;
+  ++stats_.numReads;
+}
+
+std::string FileInputStream::toString() const {
+  return fmt::format(
+      "file (offset {}/size {}) current (position {}/ size {})",
+      succinctBytes(fileOffset_),
+      succinctBytes(fileSize_),
+      current_ == nullptr ? "NULL" : succinctBytes(current_->position),
+      current_ == nullptr ? "NULL" : succinctBytes(current_->size));
+}
+
+FileInputStream::Stats FileInputStream::stats() const {
+  return stats_;
+}
+
+bool FileInputStream::Stats::operator==(
+    const FileInputStream::Stats& other) const {
+  return std::tie(numReads, readBytes, readTimeNs) ==
+      std::tie(other.numReads, other.readBytes, other.readTimeNs);
+}
+
+std::string FileInputStream::Stats::toString() const {
+  return fmt::format(
+      "numReads: {}, readBytes: {}, readTimeNs: {}",
+      numReads,
+      succinctBytes(readBytes),
+      succinctMicros(readTimeNs));
+}
+} // namespace facebook::velox::common
diff --git a/velox/common/file/FileInputStream.h b/velox/common/file/FileInputStream.h
new file mode 100644
index 0000000000000..6daf9f84e1098
--- /dev/null
+++ b/velox/common/file/FileInputStream.h
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+#include "velox/buffer/Buffer.h"
+#include "velox/common/file/File.h"
+#include "velox/common/memory/ByteStream.h"
+
+namespace facebook::velox::common {
+
+/// Readonly byte input stream backed by file.
+class FileInputStream : public ByteInputStream {
+ public:
+  FileInputStream(
+      std::unique_ptr<ReadFile>&& file,
+      uint64_t bufferSize,
+      memory::MemoryPool* pool);
+
+  ~FileInputStream() override;
+
+  FileInputStream(const FileInputStream&) = delete;
+  FileInputStream& operator=(const FileInputStream& other) = delete;
+  FileInputStream(FileInputStream&& other) noexcept = delete;
+  FileInputStream& operator=(FileInputStream&& other) noexcept = delete;
+
+  size_t size() const override;
+
+  bool atEnd() const override;
+
+  std::streampos tellp() const override;
+
+  void seekp(std::streampos pos) override;
+
+  void skip(int32_t size) override;
+
+  size_t remainingSize() const override;
+
+  uint8_t readByte() override;
+
+  void readBytes(uint8_t* bytes, int32_t size) override;
+
+  std::string_view nextView(int32_t size) override;
+
+  std::string toString() const override;
+
+  /// Records the file read stats.
+  struct Stats {
+    uint32_t numReads{0};
+    uint64_t readBytes{0};
+    uint64_t readTimeNs{0};
+
+    bool operator==(const Stats& other) const;
+
+    std::string toString() const;
+  };
+  Stats stats() const;
+
+ private:
+  void doSeek(int64_t skipBytes);
+
+  // Invoked to read the next byte range from the file in a buffer.
+  void readNextRange();
+
+  // Issues readahead if underlying file system supports async mode read.
+  //
+  // TODO: we might consider to use AsyncSource to support read-ahead on
+  // filesystem which doesn't support async mode read.
+  void maybeIssueReadahead();
+
+  inline uint64_t readSize() const;
+
+  inline uint32_t bufferIndex() const {
+    return bufferIndex_;
+  }
+
+  inline uint32_t nextBufferIndex() const {
+    return (bufferIndex_ + 1) % buffers_.size();
+  }
+
+  // Advances buffer index to point to the next buffer for read.
+  inline void advanceBuffer() {
+    bufferIndex_ = nextBufferIndex();
+  }
+
+  inline Buffer* buffer() const {
+    return buffers_[bufferIndex()].get();
+  }
+
+  inline Buffer* nextBuffer() const {
+    return buffers_[nextBufferIndex()].get();
+  }
+
+  void updateStats(uint64_t readBytes, uint64_t readTimeNs);
+
+  const std::unique_ptr<ReadFile> file_;
+  const uint64_t fileSize_;
+  const uint64_t bufferSize_;
+  memory::MemoryPool* const pool_;
+  const bool readAheadEnabled_;
+
+  // Offset of the next byte to read from file.
+  uint64_t fileOffset_ = 0;
+
+  std::vector<BufferPtr> buffers_;
+  uint32_t bufferIndex_{0};
+  // Sets to read-ahead future if valid.
+  folly::SemiFuture<uint64_t> readAheadWait_{
+      folly::SemiFuture<uint64_t>::makeEmpty()};
+
+  Stats stats_;
+};
+} // namespace facebook::velox::common
diff --git a/velox/common/file/FileSystems.cpp b/velox/common/file/FileSystems.cpp
index eac9c01337b74..641ac5c958c60 100644
--- a/velox/common/file/FileSystems.cpp
+++ b/velox/common/file/FileSystems.cpp
@@ -30,8 +30,9 @@ constexpr std::string_view kFileScheme("file:");
 
 using RegisteredFileSystems = std::vector<std::pair<
     std::function<bool(std::string_view)>,
-    std::function<std::shared_ptr<
-        FileSystem>(std::shared_ptr<const Config>, std::string_view)>>>;
+    std::function<std::shared_ptr<FileSystem>(
+        std::shared_ptr<const config::ConfigBase>,
+        std::string_view)>>>;
 
 RegisteredFileSystems& registeredFileSystems() {
   // Meyers singleton.
@@ -44,14 +45,14 @@ RegisteredFileSystems& registeredFileSystems() {
 void registerFileSystem(
     std::function<bool(std::string_view)> schemeMatcher,
     std::function<std::shared_ptr<FileSystem>(
-        std::shared_ptr<const Config>,
+        std::shared_ptr<const config::ConfigBase>,
         std::string_view)> fileSystemGenerator) {
   registeredFileSystems().emplace_back(schemeMatcher, fileSystemGenerator);
 }
 
 std::shared_ptr<FileSystem> getFileSystem(
     std::string_view filePath,
-    std::shared_ptr<const Config> properties) {
+    std::shared_ptr<const config::ConfigBase> properties) {
   const auto& filesystems = registeredFileSystems();
   for (const auto& p : filesystems) {
     if (p.first(filePath)) {
@@ -61,6 +62,16 @@ std::shared_ptr<FileSystem> getFileSystem(
   VELOX_FAIL("No registered file system matched with file path '{}'", filePath);
 }
 
+bool isPathSupportedByRegisteredFileSystems(const std::string_view& filePath) {
+  const auto& filesystems = registeredFileSystems();
+  for (const auto& p : filesystems) {
+    if (p.first(filePath)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 namespace {
 
 folly::once_flag localFSInstantiationFlag;
@@ -68,7 +79,7 @@ folly::once_flag localFSInstantiationFlag;
 // Implement Local FileSystem.
 class LocalFileSystem : public FileSystem {
  public:
-  explicit LocalFileSystem(std::shared_ptr<const Config> config)
+  explicit LocalFileSystem(std::shared_ptr<const config::ConfigBase> config)
       : FileSystem(config) {}
 
   ~LocalFileSystem() override {}
@@ -77,7 +88,7 @@ class LocalFileSystem : public FileSystem {
     return "Local FS";
   }
 
-  inline std::string_view extractPath(std::string_view path) {
+  inline std::string_view extractPath(std::string_view path) override {
     if (path.find(kFileScheme) == 0) {
       return path.substr(kFileScheme.length());
     }
@@ -92,8 +103,12 @@ class LocalFileSystem : public FileSystem {
 
   std::unique_ptr<WriteFile> openFileForWrite(
       std::string_view path,
-      const FileOptions& /*unused*/) override {
-    return std::make_unique<LocalWriteFile>(extractPath(path));
+      const FileOptions& options) override {
+    return std::make_unique<LocalWriteFile>(
+        extractPath(path),
+        options.shouldCreateParentDirectories,
+        options.shouldThrowOnFileAlreadyExists,
+        options.bufferWrite);
   }
 
   void remove(std::string_view path) override {
@@ -155,8 +170,8 @@ class LocalFileSystem : public FileSystem {
         0,
         ec.value(),
         "Mkdir {} failed: {}, message: {}",
-        path,
-        ec,
+        std::string(path),
+        ec.value(),
         ec.message());
     VLOG(1) << "LocalFileSystem::mkdir " << path;
   }
@@ -168,8 +183,8 @@ class LocalFileSystem : public FileSystem {
         0,
         ec.value(),
         "Rmdir {} failed: {}, message: {}",
-        path,
-        ec,
+        std::string(path),
+        ec.value(),
         ec.message());
     VLOG(1) << "LocalFileSystem::rmdir " << path;
   }
@@ -183,9 +198,9 @@ class LocalFileSystem : public FileSystem {
   }
 
   static std::function<std::shared_ptr<
-      FileSystem>(std::shared_ptr<const Config>, std::string_view)>
+      FileSystem>(std::shared_ptr<const config::ConfigBase>, std::string_view)>
   fileSystemGenerator() {
-    return [](std::shared_ptr<const Config> properties,
+    return [](std::shared_ptr<const config::ConfigBase> properties,
               std::string_view filePath) {
       // One instance of Local FileSystem is sufficient.
       // Initialize on first access and reuse after that.
diff --git a/velox/common/file/FileSystems.h b/velox/common/file/FileSystems.h
index 07b8400fba7b0..8fccb5bf6d146 100644
--- a/velox/common/file/FileSystems.h
+++ b/velox/common/file/FileSystems.h
@@ -23,7 +23,9 @@
 #include <string_view>
 
 namespace facebook::velox {
-class Config;
+namespace config {
+class ConfigBase;
+}
 class ReadFile;
 class WriteFile;
 } // namespace facebook::velox
@@ -35,20 +37,51 @@ namespace facebook::velox::filesystems {
 /// MemoryPool to allocate buffers needed to read/write files on FileSystems
 /// such as S3.
 struct FileOptions {
+  /// A free form option in 'values' that is provided for file creation. The
+  /// form should be defined by specific implementations of file system. e.g.
+  /// inside this property there could be things like block size, encoding, and
+  /// etc.
+  static constexpr folly::StringPiece kFileCreateConfig{"file-create-config"};
+
   std::unordered_map<std::string, std::string> values;
   memory::MemoryPool* pool{nullptr};
+  /// If specified then can be trusted to be the file size.
+  std::optional<int64_t> fileSize;
+
+  /// Whether to create parent directories if they don't exist.
+  ///
+  /// NOTE: this only applies for write open file.
+  bool shouldCreateParentDirectories{false};
+
+  /// Whether to throw an error if a file already exists.
+  ///
+  /// NOTE: this only applies for write open file.
+  bool shouldThrowOnFileAlreadyExists{true};
+
+  /// Whether to buffer the write data in file system client or not. For local
+  /// filesystem on Unix-like operating system, this corresponds to the direct
+  /// IO mode if set.
+  ///
+  /// NOTE: this only applies for write open file.
+  bool bufferWrite{true};
 };
 
 /// An abstract FileSystem
 class FileSystem {
  public:
-  FileSystem(std::shared_ptr<const Config> config)
+  FileSystem(std::shared_ptr<const config::ConfigBase> config)
       : config_(std::move(config)) {}
   virtual ~FileSystem() = default;
 
   /// Returns the name of the File System
   virtual std::string name() const = 0;
 
+  /// Returns the file path without the fs scheme prefix such as "local:" prefix
+  /// for local file system.
+  virtual std::string_view extractPath(std::string_view path) {
+    VELOX_NYI();
+  }
+
   /// Returns a ReadFile handle for a given file path
   virtual std::unique_ptr<ReadFile> openFileForRead(
       std::string_view path,
@@ -87,12 +120,16 @@ class FileSystem {
   virtual void rmdir(std::string_view path) = 0;
 
  protected:
-  std::shared_ptr<const Config> config_;
+  std::shared_ptr<const config::ConfigBase> config_;
 };
 
 std::shared_ptr<FileSystem> getFileSystem(
     std::string_view filename,
-    std::shared_ptr<const Config> config);
+    std::shared_ptr<const config::ConfigBase> config);
+
+/// Returns true if filePath is supported by any registered file system,
+/// otherwise false.
+bool isPathSupportedByRegisteredFileSystems(const std::string_view& filePath);
 
 /// FileSystems must be registered explicitly.
 /// The registration function takes two parameters:
@@ -102,7 +139,7 @@ std::shared_ptr<FileSystem> getFileSystem(
 void registerFileSystem(
     std::function<bool(std::string_view)> schemeMatcher,
     std::function<std::shared_ptr<FileSystem>(
-        std::shared_ptr<const Config>,
+        std::shared_ptr<const config::ConfigBase>,
         std::string_view)> fileSystemGenerator);
 
 /// Register the local filesystem.
diff --git a/velox/common/file/Region.h b/velox/common/file/Region.h
index c0617ec0437a6..2b396b6789b13 100644
--- a/velox/common/file/Region.h
+++ b/velox/common/file/Region.h
@@ -20,11 +20,11 @@
 
 namespace facebook::velox::common {
 
-// define a disk region to read
+/// Defines a disk region to read.
 struct Region {
   uint64_t offset;
   uint64_t length;
-  // Optional label used by lower layers for cache warm up
+  /// Optional label used by lower layers for cache warm up.
   std::string_view label;
 
   Region(uint64_t offset = 0, uint64_t length = 0, std::string_view label = {})
diff --git a/velox/common/file/Utils.cpp b/velox/common/file/Utils.cpp
index 4c5de66f459b4..bd9bfea9dcb8d 100644
--- a/velox/common/file/Utils.cpp
+++ b/velox/common/file/Utils.cpp
@@ -28,7 +28,10 @@ bool CoalesceIfDistanceLE::operator()(
   VELOX_CHECK_LE(beginGap, endGap, "Regions to combine can't overlap.");
   const uint64_t gap = endGap - beginGap;
 
-  return gap <= maxCoalescingDistance_;
+  const bool shouldCoalesce = gap <= maxCoalescingDistance_;
+  if (coalescedBytes_ && shouldCoalesce) {
+    *coalescedBytes_ += gap;
+  }
+  return shouldCoalesce;
 }
-
 } // namespace facebook::velox::file::utils
diff --git a/velox/common/file/Utils.h b/velox/common/file/Utils.h
index 9b497fac511da..b19468fbe1fe2 100644
--- a/velox/common/file/Utils.h
+++ b/velox/common/file/Utils.h
@@ -106,8 +106,11 @@ class CoalesceRegions {
 
 class CoalesceIfDistanceLE {
  public:
-  explicit CoalesceIfDistanceLE(uint64_t maxCoalescingDistance)
-      : maxCoalescingDistance_(maxCoalescingDistance) {}
+  explicit CoalesceIfDistanceLE(
+      uint64_t maxCoalescingDistance,
+      uint64_t* FOLLY_NULLABLE coalescedBytes = nullptr)
+      : maxCoalescingDistance_{maxCoalescingDistance},
+        coalescedBytes_{coalescedBytes} {}
 
   bool operator()(
       const velox::common::Region& a,
@@ -115,6 +118,7 @@ class CoalesceIfDistanceLE {
 
  private:
   uint64_t maxCoalescingDistance_;
+  uint64_t* coalescedBytes_;
 };
 
 template <typename RegionIter, typename OutputIter, typename Reader>
@@ -161,5 +165,4 @@ class ReadToIOBufs {
   OutputIter output_;
   Reader reader_;
 };
-
 } // namespace facebook::velox::file::utils
diff --git a/velox/common/file/benchmark/CMakeLists.txt b/velox/common/file/benchmark/CMakeLists.txt
deleted file mode 100644
index 8861ce5d9adc3..0000000000000
--- a/velox/common/file/benchmark/CMakeLists.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_read_benchmark_lib ReadBenchmark.cpp)
-
-target_link_libraries(velox_read_benchmark_lib
-                      PUBLIC velox_file velox_time Folly::folly gflags::gflags)
-
-add_executable(velox_read_benchmark ReadBenchmarkMain.cpp)
-
-target_link_libraries(velox_read_benchmark PRIVATE velox_read_benchmark_lib)
diff --git a/velox/common/file/benchmark/ReadBenchmark.cpp b/velox/common/file/benchmark/ReadBenchmark.cpp
deleted file mode 100644
index ba1eaa95f355e..0000000000000
--- a/velox/common/file/benchmark/ReadBenchmark.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/common/file/benchmark/ReadBenchmark.h"
-
-DEFINE_string(path, "", "Path of test file");
-DEFINE_int64(
-    file_size_gb,
-    0,
-    "Limits the test to the first --file_size_gb "
-    "of --path. 0 means use the whole file");
-DEFINE_int32(num_threads, 16, "Test paralelism");
-DEFINE_int32(seed, 0, "Random seed, 0 means no seed");
-DEFINE_bool(odirect, false, "Use O_DIRECT");
-
-DEFINE_int32(
-    bytes,
-    0,
-    "If 0, runs through a set of predefined read patterns. "
-    "If non-0, this is the size of a single read. The reads are "
-    "made in --num_in_run consecutive batchhes with --gap bytes between each read");
-DEFINE_int32(gap, 0, "Gap between consecutive reads if --bytes is non-0");
-DEFINE_int32(
-    num_in_run,
-    10,
-    "Number of consecutive reads of --bytes separated by --gap bytes");
-DEFINE_int32(
-    measurement_size,
-    100 << 20,
-    "Total reads per thread when throughput for a --bytes/--gap/--/gap/"
-    "--num_in_run combination");
-
-namespace {
-static bool notEmpty(const char* /*flagName*/, const std::string& value) {
-  return !value.empty();
-}
-} // namespace
-
-DEFINE_validator(path, &notEmpty);
-
-namespace facebook::velox {
-
-void ReadBenchmark::run() {
-  if (FLAGS_bytes) {
-    modes(FLAGS_bytes, FLAGS_gap, FLAGS_num_in_run);
-    return;
-  }
-  modes(1100, 0, 10);
-  modes(1100, 1200, 10);
-  modes(16 * 1024, 0, 10);
-  modes(16 * 1024, 10000, 10);
-  modes(1000000, 0, 8);
-  modes(1000000, 100000, 8);
-}
-} // namespace facebook::velox
diff --git a/velox/common/file/tests/CMakeLists.txt b/velox/common/file/tests/CMakeLists.txt
index 446ef6a859e18..fb9ef6f735215 100644
--- a/velox/common/file/tests/CMakeLists.txt
+++ b/velox/common/file/tests/CMakeLists.txt
@@ -12,11 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_file_test_utils TestUtils.cpp)
-target_link_libraries(velox_file_test_utils PUBLIC velox_file)
+add_library(velox_file_test_utils TestUtils.cpp FaultyFile.cpp
+                                  FaultyFileSystem.cpp)
 
-add_executable(velox_file_test FileTest.cpp UtilsTest.cpp)
+target_link_libraries(
+  velox_file_test_utils
+  PUBLIC velox_file)
+
+add_executable(velox_file_test FileTest.cpp FileInputStreamTest.cpp
+                               UtilsTest.cpp)
 add_test(velox_file_test velox_file_test)
 target_link_libraries(
-  velox_file_test PRIVATE velox_file velox_file_test_utils velox_temp_path
-                          gmock gtest gtest_main)
+  velox_file_test
+  PRIVATE
+    velox_buffer
+    velox_file
+    velox_file_test_utils
+    velox_temp_path
+    GTest::gmock
+    GTest::gtest
+    GTest::gtest_main)
diff --git a/velox/common/file/tests/FaultyFile.cpp b/velox/common/file/tests/FaultyFile.cpp
new file mode 100644
index 0000000000000..2593fa1fad7ba
--- /dev/null
+++ b/velox/common/file/tests/FaultyFile.cpp
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/file/tests/FaultyFile.h"
+
+namespace facebook::velox::tests::utils {
+
+std::string FaultFileOperation::typeString(Type type) {
+  switch (type) {
+    case Type::kReadv:
+      return "READV";
+    case Type::kRead:
+      return "READ";
+    default:
+      VELOX_UNSUPPORTED(
+          "Unknown file operation type: {}", static_cast<int>(type));
+      break;
+  }
+}
+
+FaultyReadFile::FaultyReadFile(
+    const std::string& path,
+    std::shared_ptr<ReadFile> delegatedFile,
+    FileFaultInjectionHook injectionHook,
+    folly::Executor* executor)
+    : path_(path),
+      delegatedFile_(std::move(delegatedFile)),
+      injectionHook_(std::move(injectionHook)),
+      executor_(executor) {
+  VELOX_CHECK_NOT_NULL(delegatedFile_);
+}
+
+std::string_view
+FaultyReadFile::pread(uint64_t offset, uint64_t length, void* buf) const {
+  if (injectionHook_ != nullptr) {
+    FaultFileReadOperation op(path_, offset, length, buf);
+    injectionHook_(&op);
+    if (!op.delegate) {
+      return std::string_view(static_cast<char*>(op.buf), op.length);
+    }
+  }
+  return delegatedFile_->pread(offset, length, buf);
+}
+
+uint64_t FaultyReadFile::preadv(
+    uint64_t offset,
+    const std::vector<folly::Range<char*>>& buffers) const {
+  if (injectionHook_ != nullptr) {
+    FaultFileReadvOperation op(path_, offset, buffers);
+    injectionHook_(&op);
+    if (!op.delegate) {
+      return op.readBytes;
+    }
+  }
+  return delegatedFile_->preadv(offset, buffers);
+}
+
+folly::SemiFuture<uint64_t> FaultyReadFile::preadvAsync(
+    uint64_t offset,
+    const std::vector<folly::Range<char*>>& buffers) const {
+  // TODO: add fault injection for async read later.
+  if (delegatedFile_->hasPreadvAsync() || executor_ == nullptr) {
+    return delegatedFile_->preadvAsync(offset, buffers);
+  }
+  auto promise = std::make_unique<folly::Promise<uint64_t>>();
+  folly::SemiFuture<uint64_t> future = promise->getSemiFuture();
+  executor_->add([this,
+                  _promise = std::move(promise),
+                  _offset = offset,
+                  _buffers = buffers]() {
+    auto delegateFuture = delegatedFile_->preadvAsync(_offset, _buffers);
+    _promise->setValue(delegateFuture.wait().value());
+  });
+  return future;
+}
+
+FaultyWriteFile::FaultyWriteFile(
+    const std::string& path,
+    std::shared_ptr<WriteFile> delegatedFile,
+    FileFaultInjectionHook injectionHook)
+    : path_(path),
+      delegatedFile_(std::move(delegatedFile)),
+      injectionHook_(std::move(injectionHook)) {
+  VELOX_CHECK_NOT_NULL(delegatedFile_);
+}
+
+void FaultyWriteFile::append(std::string_view data) {
+  if (injectionHook_ != nullptr) {
+    FaultFileWriteOperation op(path_, data);
+    injectionHook_(&op);
+    if (!op.delegate) {
+      return;
+    }
+  }
+  delegatedFile_->append(data);
+}
+
+void FaultyWriteFile::append(std::unique_ptr<folly::IOBuf> data) {
+  delegatedFile_->append(std::move(data));
+}
+
+void FaultyWriteFile::write(
+    const std::vector<iovec>& iovecs,
+    int64_t offset,
+    int64_t length) {
+  delegatedFile_->write(iovecs, offset, length);
+}
+
+void FaultyWriteFile::truncate(int64_t newSize) {
+  delegatedFile_->truncate(newSize);
+}
+
+void FaultyWriteFile::flush() {
+  delegatedFile_->flush();
+}
+
+void FaultyWriteFile::setAttributes(
+    const std::unordered_map<std::string, std::string>& attributes) {
+  delegatedFile_->setAttributes(attributes);
+}
+
+std::unordered_map<std::string, std::string> FaultyWriteFile::getAttributes()
+    const {
+  return delegatedFile_->getAttributes();
+}
+
+void FaultyWriteFile::close() {
+  delegatedFile_->close();
+}
+} // namespace facebook::velox::tests::utils
diff --git a/velox/common/file/tests/FaultyFile.h b/velox/common/file/tests/FaultyFile.h
new file mode 100644
index 0000000000000..968d98da3cf9d
--- /dev/null
+++ b/velox/common/file/tests/FaultyFile.h
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/File.h"
+
+namespace facebook::velox::tests::utils {
+
+/// Defines the per-file operation fault injection.
+struct FaultFileOperation {
+  enum class Type {
+    /// Injects faults for file read operations.
+    kRead,
+    kReadv,
+    kWrite,
+    /// TODO: add to support fault injections for the other file operation
+    /// types.
+  };
+  static std::string typeString(Type type);
+
+  const Type type;
+
+  /// The delegated file path.
+  const std::string path;
+
+  /// Indicates to forward this operation to the delegated file or not. If not,
+  /// then the file fault injection hook must have processed the request. For
+  /// instance, if this is a file read injection, then the hook must have filled
+  /// the fake read data for data corruption tests.
+  bool delegate{true};
+
+  FaultFileOperation(Type _type, const std::string& _path)
+      : type(_type), path(_path) {}
+};
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& o,
+    const FaultFileOperation::Type& type) {
+  return o << FaultFileOperation::typeString(type);
+}
+
+/// Fault injection parameters for file read API.
+struct FaultFileReadOperation : FaultFileOperation {
+  const uint64_t offset;
+  const uint64_t length;
+  void* const buf;
+
+  FaultFileReadOperation(
+      const std::string& _path,
+      uint64_t _offset,
+      uint64_t _length,
+      void* _buf)
+      : FaultFileOperation(FaultFileOperation::Type::kRead, _path),
+        offset(_offset),
+        length(_length),
+        buf(_buf) {}
+};
+
+/// Fault injection parameters for file readv API.
+struct FaultFileReadvOperation : FaultFileOperation {
+  const uint64_t offset;
+  const std::vector<folly::Range<char*>>& buffers;
+  uint64_t readBytes{0};
+
+  FaultFileReadvOperation(
+      const std::string& _path,
+      uint64_t _offset,
+      const std::vector<folly::Range<char*>>& _buffers)
+      : FaultFileOperation(FaultFileOperation::Type::kReadv, _path),
+        offset(_offset),
+        buffers(_buffers) {}
+};
+
+/// Fault injection parameters for file write API.
+struct FaultFileWriteOperation : FaultFileOperation {
+  std::string_view* data;
+
+  FaultFileWriteOperation(
+      const std::string& _path,
+      const std::string_view& _data)
+      : FaultFileOperation(FaultFileOperation::Type::kWrite, _path),
+        data(const_cast<std::string_view*>(&_data)) {}
+};
+
+/// The fault injection hook on the file operation path.
+using FileFaultInjectionHook = std::function<void(FaultFileOperation*)>;
+
+class FaultyReadFile : public ReadFile {
+ public:
+  FaultyReadFile(
+      const std::string& path,
+      std::shared_ptr<ReadFile> delegatedFile,
+      FileFaultInjectionHook injectionHook,
+      folly::Executor* executor);
+
+  ~FaultyReadFile() override{};
+
+  uint64_t size() const override {
+    return delegatedFile_->size();
+  }
+
+  std::string_view pread(uint64_t offset, uint64_t length, void* buf)
+      const override;
+
+  uint64_t preadv(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers) const override;
+
+  uint64_t memoryUsage() const override {
+    return delegatedFile_->memoryUsage();
+  }
+
+  bool shouldCoalesce() const override {
+    return delegatedFile_->shouldCoalesce();
+  }
+
+  std::string getName() const override {
+    return delegatedFile_->getName();
+  }
+
+  uint64_t getNaturalReadSize() const override {
+    return delegatedFile_->getNaturalReadSize();
+  }
+
+  bool hasPreadvAsync() const override {
+    if (executor_ != nullptr) {
+      return true;
+    }
+    return delegatedFile_->hasPreadvAsync();
+  }
+
+  folly::SemiFuture<uint64_t> preadvAsync(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers) const override;
+
+ private:
+  const std::string path_;
+  const std::shared_ptr<ReadFile> delegatedFile_;
+  const FileFaultInjectionHook injectionHook_;
+  folly::Executor* const executor_;
+};
+
+class FaultyWriteFile : public WriteFile {
+ public:
+  FaultyWriteFile(
+      const std::string& path,
+      std::shared_ptr<WriteFile> delegatedFile,
+      FileFaultInjectionHook injectionHook);
+
+  ~FaultyWriteFile() override{};
+
+  void append(std::string_view data) override;
+
+  void append(std::unique_ptr<folly::IOBuf> data) override;
+
+  void write(const std::vector<iovec>& iovecs, int64_t offset, int64_t length)
+      override;
+
+  void truncate(int64_t newSize) override;
+
+  void flush() override;
+
+  void setAttributes(
+      const std::unordered_map<std::string, std::string>& attributes) override;
+
+  std::unordered_map<std::string, std::string> getAttributes() const override;
+
+  void close() override;
+
+  uint64_t size() const override {
+    return delegatedFile_->size();
+  }
+
+ private:
+  const std::string path_;
+  const std::shared_ptr<WriteFile> delegatedFile_;
+  const FileFaultInjectionHook injectionHook_;
+};
+
+} // namespace facebook::velox::tests::utils
diff --git a/velox/common/file/tests/FaultyFileSystem.cpp b/velox/common/file/tests/FaultyFileSystem.cpp
new file mode 100644
index 0000000000000..39b4f6b09e158
--- /dev/null
+++ b/velox/common/file/tests/FaultyFileSystem.cpp
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/file/tests/FaultyFileSystem.h"
+#include <folly/synchronization/CallOnce.h>
+
+#include <filesystem>
+
+namespace facebook::velox::tests::utils {
+namespace {
+// Constructs the faulty file path based on the delegated read file 'path'. It
+// pre-appends the faulty file system scheme.
+inline std::string faultyPath(const std::string& path) {
+  return fmt::format("{}{}", FaultyFileSystem::scheme(), path);
+}
+
+std::function<bool(std::string_view)> schemeMatcher() {
+  // Note: presto behavior is to prefix local paths with 'file:'.
+  // Check for that prefix and prune to absolute regular paths as needed.
+  return [](std::string_view filePath) {
+    return filePath.find(FaultyFileSystem::scheme()) == 0;
+  };
+}
+
+folly::once_flag faultFilesystemInitOnceFlag;
+
+std::function<std::shared_ptr<
+    FileSystem>(std::shared_ptr<const config::ConfigBase>, std::string_view)>
+fileSystemGenerator() {
+  return [](std::shared_ptr<const config::ConfigBase> properties,
+            std::string_view /*unused*/) {
+    // One instance of faulty FileSystem is sufficient. Initializes on first
+    // access and reuse after that.
+    static std::shared_ptr<FileSystem> lfs;
+    folly::call_once(faultFilesystemInitOnceFlag, [&properties]() {
+      lfs = std::make_shared<FaultyFileSystem>(std::move(properties));
+    });
+    return lfs;
+  };
+}
+} // namespace
+
+std::unique_ptr<ReadFile> FaultyFileSystem::openFileForRead(
+    std::string_view path,
+    const FileOptions& options) {
+  const std::string delegatedPath = std::string(extractPath(path));
+  auto delegatedFile = getFileSystem(delegatedPath, config_)
+                           ->openFileForRead(delegatedPath, options);
+  return std::make_unique<FaultyReadFile>(
+      std::string(path),
+      std::move(delegatedFile),
+      [&](FaultFileOperation* op) { maybeInjectFileFault(op); },
+      executor_);
+}
+
+std::unique_ptr<WriteFile> FaultyFileSystem::openFileForWrite(
+    std::string_view path,
+    const FileOptions& options) {
+  const std::string delegatedPath = std::string(extractPath(path));
+  auto delegatedFile = getFileSystem(delegatedPath, config_)
+                           ->openFileForWrite(delegatedPath, options);
+  return std::make_unique<FaultyWriteFile>(
+      std::string(path), std::move(delegatedFile), [&](FaultFileOperation* op) {
+        maybeInjectFileFault(op);
+      });
+}
+
+void FaultyFileSystem::remove(std::string_view path) {
+  const std::string delegatedPath = std::string(extractPath(path));
+  getFileSystem(delegatedPath, config_)->remove(delegatedPath);
+}
+
+void FaultyFileSystem::rename(
+    std::string_view oldPath,
+    std::string_view newPath,
+    bool overwrite) {
+  const auto delegatedOldPath = extractPath(oldPath);
+  const auto delegatedNewPath = extractPath(newPath);
+  getFileSystem(delegatedOldPath, config_)
+      ->rename(delegatedOldPath, delegatedNewPath, overwrite);
+}
+
+bool FaultyFileSystem::exists(std::string_view path) {
+  const auto delegatedPath = extractPath(path);
+  return getFileSystem(delegatedPath, config_)->exists(delegatedPath);
+}
+
+std::vector<std::string> FaultyFileSystem::list(std::string_view path) {
+  const auto delegatedDirPath = extractPath(path);
+  const auto delegatedFiles =
+      getFileSystem(delegatedDirPath, config_)->list(delegatedDirPath);
+  // NOTE: we shall return the faulty file paths instead of the delegated file
+  // paths for list result.
+  std::vector<std::string> files;
+  files.reserve(delegatedFiles.size());
+  for (const auto& delegatedFile : delegatedFiles) {
+    files.push_back(faultyPath(delegatedFile));
+  }
+  return files;
+}
+
+void FaultyFileSystem::mkdir(std::string_view path) {
+  const auto delegatedDirPath = extractPath(path);
+  getFileSystem(delegatedDirPath, config_)->mkdir(delegatedDirPath);
+}
+
+void FaultyFileSystem::rmdir(std::string_view path) {
+  const auto delegatedDirPath = extractPath(path);
+  getFileSystem(delegatedDirPath, config_)->rmdir(delegatedDirPath);
+}
+
+void FaultyFileSystem::setFileInjectionHook(
+    FileFaultInjectionHook injectionHook) {
+  std::lock_guard<std::mutex> l(mu_);
+  fileInjections_ = FileInjections(std::move(injectionHook));
+}
+
+void FaultyFileSystem::setFileInjectionError(
+    std::exception_ptr error,
+    std::unordered_set<FaultFileOperation::Type> opTypes) {
+  std::lock_guard<std::mutex> l(mu_);
+  fileInjections_ = FileInjections(std::move(error), std::move(opTypes));
+}
+
+void FaultyFileSystem::setFileInjectionDelay(
+    uint64_t delayUs,
+    std::unordered_set<FaultFileOperation::Type> opTypes) {
+  std::lock_guard<std::mutex> l(mu_);
+  fileInjections_ = FileInjections(delayUs, std::move(opTypes));
+}
+
+void FaultyFileSystem::clearFileFaultInjections() {
+  std::lock_guard<std::mutex> l(mu_);
+  fileInjections_.reset();
+}
+
+void FaultyFileSystem::maybeInjectFileFault(FaultFileOperation* op) {
+  FileInjections injections;
+  {
+    std::lock_guard<std::mutex> l(mu_);
+    if (!fileInjections_.has_value()) {
+      return;
+    }
+    injections = fileInjections_.value();
+  }
+
+  if (injections.fileInjectionHook != nullptr) {
+    injections.fileInjectionHook(op);
+    return;
+  }
+
+  if (!injections.opTypes.empty() && injections.opTypes.count(op->type) == 0) {
+    return;
+  }
+
+  if (injections.fileException != nullptr) {
+    std::rethrow_exception(injections.fileException);
+  }
+
+  if (injections.fileDelayUs != 0) {
+    std::this_thread::sleep_for(
+        std::chrono::microseconds(injections.fileDelayUs));
+  }
+}
+
+void registerFaultyFileSystem() {
+  registerFileSystem(schemeMatcher(), fileSystemGenerator());
+}
+
+std::shared_ptr<FaultyFileSystem> faultyFileSystem() {
+  return std::dynamic_pointer_cast<FaultyFileSystem>(
+      getFileSystem(FaultyFileSystem::scheme(), {}));
+}
+} // namespace facebook::velox::tests::utils
diff --git a/velox/common/file/tests/FaultyFileSystem.h b/velox/common/file/tests/FaultyFileSystem.h
new file mode 100644
index 0000000000000..b55266d41b9a3
--- /dev/null
+++ b/velox/common/file/tests/FaultyFileSystem.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+
+#include <functional>
+#include <memory>
+#include <string_view>
+#include "velox/common/file/tests/FaultyFile.h"
+#include "velox/common/file/tests/FaultyFileSystem.h"
+
+namespace facebook::velox::tests::utils {
+
+using namespace filesystems;
+
+/// Implements faulty filesystem for io fault injection in unit test. It is a
+/// wrapper on top of a real file system, and by default it delegates the the
+/// file operation to the real file system underneath.
+class FaultyFileSystem : public FileSystem {
+ public:
+  explicit FaultyFileSystem(std::shared_ptr<const config::ConfigBase> config)
+      : FileSystem(std::move(config)) {}
+
+  ~FaultyFileSystem() override {}
+
+  static inline std::string scheme() {
+    return "faulty:";
+  }
+
+  std::string name() const override {
+    return "Faulty FS";
+  }
+
+  // Extracts the delegated real file path by removing the faulty file system
+  // scheme prefix.
+  inline std::string_view extractPath(std::string_view path) override {
+    VELOX_CHECK_EQ(path.find(scheme()), 0, "");
+    const auto filePath = path.substr(scheme().length());
+    return getFileSystem(filePath, config_)->extractPath(filePath);
+  }
+
+  std::unique_ptr<ReadFile> openFileForRead(
+      std::string_view path,
+      const FileOptions& options) override;
+
+  std::unique_ptr<WriteFile> openFileForWrite(
+      std::string_view path,
+      const FileOptions& options) override;
+
+  void remove(std::string_view path) override;
+
+  void rename(
+      std::string_view oldPath,
+      std::string_view newPath,
+      bool overwrite) override;
+
+  bool exists(std::string_view path) override;
+
+  std::vector<std::string> list(std::string_view path) override;
+
+  void mkdir(std::string_view path) override;
+
+  void rmdir(std::string_view path) override;
+
+  /// Sets executor for async read execution.
+  void setExecutor(folly::Executor* executor) {
+    std::lock_guard<std::mutex> l(mu_);
+    executor_ = executor;
+  }
+
+  /// Setups hook for file fault injection.
+  void setFileInjectionHook(FileFaultInjectionHook hook);
+
+  /// Setups to inject 'error' for a particular set of file operation types. If
+  /// 'opTypes' is empty, it injects error for all kinds of file operation
+  /// types.
+  void setFileInjectionError(
+      std::exception_ptr error,
+      std::unordered_set<FaultFileOperation::Type> opTypes = {});
+
+  /// Setups to inject delay for a particular set of file operation types. If
+  /// 'opTypes' is empty, it injects delay for all kinds of file operation
+  /// types.
+  void setFileInjectionDelay(
+      uint64_t delayUs,
+      std::unordered_set<FaultFileOperation::Type> opTypes = {});
+
+  /// Clears the file fault injections.
+  void clearFileFaultInjections();
+
+ private:
+  // Defines the file injection setup and only one type of injection can be set
+  // at a time.
+  struct FileInjections {
+    FileFaultInjectionHook fileInjectionHook{nullptr};
+
+    std::exception_ptr fileException{nullptr};
+
+    uint64_t fileDelayUs{0};
+
+    std::unordered_set<FaultFileOperation::Type> opTypes{};
+
+    FileInjections() = default;
+
+    explicit FileInjections(FileFaultInjectionHook _fileInjectionHook)
+        : fileInjectionHook(std::move(_fileInjectionHook)) {}
+
+    FileInjections(
+        uint64_t _fileDelayUs,
+        std::unordered_set<FaultFileOperation::Type> _opTypes)
+        : fileDelayUs(_fileDelayUs), opTypes(std::move(_opTypes)) {}
+
+    FileInjections(
+        std::exception_ptr _fileException,
+        std::unordered_set<FaultFileOperation::Type> _opTypes)
+        : fileException(std::move(_fileException)),
+          opTypes(std::move(_opTypes)) {}
+  };
+
+  // Invoked to inject file fault to 'op' if configured.
+  void maybeInjectFileFault(FaultFileOperation* op);
+
+  mutable std::mutex mu_;
+  std::optional<FileInjections> fileInjections_;
+  folly::Executor* executor_;
+};
+
+/// Registers the faulty filesystem.
+void registerFaultyFileSystem();
+
+/// Gets the fault filesystem instance.
+std::shared_ptr<FaultyFileSystem> faultyFileSystem();
+} // namespace facebook::velox::tests::utils
diff --git a/velox/common/file/tests/FileInputStreamTest.cpp b/velox/common/file/tests/FileInputStreamTest.cpp
new file mode 100644
index 0000000000000..18ab5733900e0
--- /dev/null
+++ b/velox/common/file/tests/FileInputStreamTest.cpp
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/memory/ByteStream.h"
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/file/FileInputStream.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/MmapAllocator.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::memory;
+
+class FileInputStreamTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    filesystems::registerLocalFileSystem();
+  }
+
+  void SetUp() override {
+    constexpr uint64_t kMaxMappedMemory = 64 << 20;
+    MemoryManagerOptions options;
+    options.useMmapAllocator = true;
+    options.allocatorCapacity = kMaxMappedMemory;
+    options.arbitratorCapacity = kMaxMappedMemory;
+    options.arbitratorReservedCapacity = 0;
+    memoryManager_ = std::make_unique<MemoryManager>(options);
+    mmapAllocator_ = static_cast<MmapAllocator*>(memoryManager_->allocator());
+    pool_ = memoryManager_->addLeafPool("ByteStreamTest");
+    rng_.seed(124);
+    tempDirPath_ = exec::test::TempDirectoryPath::create();
+    fs_ = filesystems::getFileSystem(tempDirPath_->getPath(), nullptr);
+  }
+
+  void TearDown() override {}
+
+  std::unique_ptr<common::FileInputStream> createStream(
+      uint64_t streamSize,
+      uint32_t bufferSize = 1024) {
+    const auto filePath =
+        fmt::format("{}/{}", tempDirPath_->getPath(), fileId_++);
+    auto writeFile = fs_->openFileForWrite(filePath);
+    std::uint8_t buffer[streamSize];
+    for (int i = 0; i < streamSize; ++i) {
+      buffer[i] = i % 256;
+    }
+    writeFile->append(
+        std::string_view(reinterpret_cast<char*>(buffer), streamSize));
+    writeFile->close();
+    return std::make_unique<common::FileInputStream>(
+        fs_->openFileForRead(filePath), bufferSize, pool_.get());
+  }
+
+  folly::Random::DefaultGenerator rng_;
+  std::unique_ptr<MemoryManager> memoryManager_;
+  MmapAllocator* mmapAllocator_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::atomic_uint64_t fileId_{0};
+  std::shared_ptr<exec::test::TempDirectoryPath> tempDirPath_;
+  std::shared_ptr<filesystems::FileSystem> fs_;
+};
+
+TEST_F(FileInputStreamTest, stats) {
+  struct {
+    size_t streamSize;
+    size_t bufferSize;
+
+    std::string debugString() const {
+      return fmt::format(
+          "streamSize {}, bufferSize {}", streamSize, bufferSize);
+    }
+  } testSettings[] = {
+      {4096, 1024}, {4096, 4096}, {4096, 8192}, {4096, 4096 + 1024}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto byteStream = createStream(testData.streamSize, testData.bufferSize);
+    ASSERT_EQ(byteStream->stats().numReads, 1);
+    ASSERT_EQ(
+        byteStream->stats().readBytes,
+        std::min(testData.streamSize, testData.bufferSize));
+    ASSERT_GT(byteStream->stats().readTimeNs, 0);
+    uint8_t buffer[testData.streamSize / 8];
+    for (int offset = 0; offset < testData.streamSize;) {
+      byteStream->readBytes(buffer, testData.streamSize / 8);
+      for (int i = 0; i < testData.streamSize / 8; ++i, ++offset) {
+        ASSERT_EQ(buffer[i], offset % 256);
+      }
+    }
+    ASSERT_TRUE(byteStream->atEnd());
+    ASSERT_EQ(
+        byteStream->stats().numReads,
+        bits::roundUp(testData.streamSize, testData.bufferSize) /
+            testData.bufferSize);
+    ASSERT_EQ(byteStream->stats().readBytes, testData.streamSize);
+    ASSERT_GT(byteStream->stats().readTimeNs, 0);
+  }
+}
diff --git a/velox/common/file/tests/FileTest.cpp b/velox/common/file/tests/FileTest.cpp
index 8ac5f753d2fa8..4534309adc6a7 100644
--- a/velox/common/file/tests/FileTest.cpp
+++ b/velox/common/file/tests/FileTest.cpp
@@ -16,8 +16,10 @@
 
 #include <fcntl.h>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/TempFilePath.h"
 
@@ -25,14 +27,42 @@
 
 using namespace facebook::velox;
 using facebook::velox::common::Region;
+using namespace facebook::velox::tests::utils;
 
 constexpr int kOneMB = 1 << 20;
 
-void writeData(WriteFile* writeFile) {
-  writeFile->append("aaaaa");
-  writeFile->append("bbbbb");
-  writeFile->append(std::string(kOneMB, 'c'));
-  writeFile->append("ddddd");
+void writeData(WriteFile* writeFile, bool useIOBuf = false) {
+  if (useIOBuf) {
+    std::unique_ptr<folly::IOBuf> buf = folly::IOBuf::copyBuffer("aaaaa");
+    buf->appendToChain(folly::IOBuf::copyBuffer("bbbbb"));
+    buf->appendToChain(folly::IOBuf::copyBuffer(std::string(kOneMB, 'c')));
+    buf->appendToChain(folly::IOBuf::copyBuffer("ddddd"));
+    writeFile->append(std::move(buf));
+    ASSERT_EQ(writeFile->size(), 15 + kOneMB);
+  } else {
+    writeFile->append("aaaaa");
+    writeFile->append("bbbbb");
+    writeFile->append(std::string(kOneMB, 'c'));
+    writeFile->append("ddddd");
+    ASSERT_EQ(writeFile->size(), 15 + kOneMB);
+  }
+}
+
+void writeDataWithOffset(WriteFile* writeFile) {
+  ASSERT_EQ(writeFile->size(), 0);
+  writeFile->truncate(15 + kOneMB);
+  std::vector<iovec> iovecs;
+  std::string s1 = "aaaaa";
+  std::string s2 = "bbbbb";
+  std::string s3 = std::string(kOneMB, 'c');
+  std::string s4 = "ddddd";
+  iovecs.push_back({s3.data(), s3.length()});
+  iovecs.push_back({s4.data(), s4.length()});
+  writeFile->write(iovecs, 10, 5 + kOneMB);
+  iovecs.clear();
+  iovecs.push_back({s1.data(), s1.length()});
+  iovecs.push_back({s2.data(), s2.length()});
+  writeFile->write(iovecs, 0, 10);
   ASSERT_EQ(writeFile->size(), 15 + kOneMB);
 }
 
@@ -68,7 +98,8 @@ void readData(ReadFile* readFile, bool checkFileSize = true) {
       folly::Range<char*>(middle, sizeof(middle)),
       folly::Range<char*>(
           nullptr,
-          (char*)(uint64_t)(15 + kOneMB - 500000 - sizeof(head) - sizeof(middle) - sizeof(tail))),
+          (char*)(uint64_t)(15 + kOneMB - 500000 - sizeof(head) -
+                            sizeof(middle) - sizeof(tail))),
       folly::Range<char*>(tail, sizeof(tail))};
   ASSERT_EQ(15 + kOneMB, readFile->preadv(0, buffers));
   ASSERT_EQ(std::string_view(head, sizeof(head)), "aaaaabbbbbcc");
@@ -78,13 +109,15 @@ void readData(ReadFile* readFile, bool checkFileSize = true) {
 
 // We could templated this test, but that's kinda overkill for how simple it is.
 TEST(InMemoryFile, writeAndRead) {
-  std::string buf;
-  {
-    InMemoryWriteFile writeFile(&buf);
-    writeData(&writeFile);
+  for (bool useIOBuf : {true, false}) {
+    std::string buf;
+    {
+      InMemoryWriteFile writeFile(&buf);
+      writeData(&writeFile, useIOBuf);
+    }
+    InMemoryReadFile readFile(buf);
+    readData(&readFile);
   }
-  InMemoryReadFile readFile(buf);
-  readData(&readFile);
 }
 
 TEST(InMemoryFile, preadv) {
@@ -114,41 +147,70 @@ TEST(InMemoryFile, preadv) {
   EXPECT_EQ(expected, values);
 }
 
-TEST(LocalFile, writeAndRead) {
-  auto tempFile = ::exec::test::TempFilePath::create();
-  const auto& filename = tempFile->path.c_str();
-  remove(filename);
-  {
-    LocalWriteFile writeFile(filename);
-    writeData(&writeFile);
+class LocalFileTest : public ::testing::TestWithParam<bool> {
+ protected:
+  LocalFileTest() : useFaultyFs_(GetParam()) {}
+
+  static void SetUpTestCase() {
+    filesystems::registerLocalFileSystem();
+    tests::utils::registerFaultyFileSystem();
+  }
+
+  const bool useFaultyFs_;
+};
+
+TEST_P(LocalFileTest, writeAndRead) {
+  struct {
+    bool useIOBuf;
+    bool withOffset;
+
+    std::string debugString() const {
+      return fmt::format("useIOBuf {}, withOffset {}", useIOBuf, withOffset);
+    }
+  } testSettings[] = {{false, false}, {true, false}, {false, true}};
+  for (auto testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto tempFile = exec::test::TempFilePath::create(useFaultyFs_);
+    const auto& filename = tempFile->getPath();
+    auto fs = filesystems::getFileSystem(filename, {});
+    fs->remove(filename);
+    {
+      auto writeFile = fs->openFileForWrite(filename);
+      if (testData.withOffset) {
+        writeDataWithOffset(writeFile.get());
+      } else {
+        writeData(writeFile.get(), testData.useIOBuf);
+      }
+      writeFile->close();
+      ASSERT_EQ(writeFile->size(), 15 + kOneMB);
+    }
+    auto readFile = fs->openFileForRead(filename);
+    readData(readFile.get());
   }
-  LocalReadFile readFile(filename);
-  readData(&readFile);
 }
 
-TEST(LocalFile, viaRegistry) {
-  filesystems::registerLocalFileSystem();
-  auto tempFile = ::exec::test::TempFilePath::create();
-  const auto& filename = tempFile->path.c_str();
-  remove(filename);
-  auto lfs = filesystems::getFileSystem(filename, nullptr);
+TEST_P(LocalFileTest, viaRegistry) {
+  auto tempFile = exec::test::TempFilePath::create(useFaultyFs_);
+  const auto& filename = tempFile->getPath();
+  auto fs = filesystems::getFileSystem(filename, {});
+  fs->remove(filename);
   {
-    auto writeFile = lfs->openFileForWrite(filename);
+    auto writeFile = fs->openFileForWrite(filename);
     writeFile->append("snarf");
   }
-  auto readFile = lfs->openFileForRead(filename);
+  auto readFile = fs->openFileForRead(filename);
   ASSERT_EQ(readFile->size(), 5);
   char buffer1[5];
   ASSERT_EQ(readFile->pread(0, 5, &buffer1), "snarf");
-  lfs->remove(filename);
+  fs->remove(filename);
 }
 
-TEST(LocalFile, rename) {
-  filesystems::registerLocalFileSystem();
-  auto tempFolder = ::exec::test::TempDirectoryPath::create();
-  auto a = fmt::format("{}/a", tempFolder->path);
-  auto b = fmt::format("{}/b", tempFolder->path);
-  auto newA = fmt::format("{}/newA", tempFolder->path);
+TEST_P(LocalFileTest, rename) {
+  const auto tempFolder = ::exec::test::TempDirectoryPath::create(useFaultyFs_);
+  const auto a = fmt::format("{}/a", tempFolder->getPath());
+  const auto b = fmt::format("{}/b", tempFolder->getPath());
+  const auto newA = fmt::format("{}/newA", tempFolder->getPath());
   const std::string data("aaaaa");
   auto localFs = filesystems::getFileSystem(a, nullptr);
   {
@@ -160,7 +222,7 @@ TEST(LocalFile, rename) {
   ASSERT_TRUE(localFs->exists(a));
   ASSERT_TRUE(localFs->exists(b));
   ASSERT_FALSE(localFs->exists(newA));
-  EXPECT_THROW(localFs->rename(a, b), VeloxUserError);
+  VELOX_ASSERT_USER_THROW(localFs->rename(a, b), "");
   localFs->rename(a, newA);
   ASSERT_FALSE(localFs->exists(a));
   ASSERT_TRUE(localFs->exists(b));
@@ -171,11 +233,10 @@ TEST(LocalFile, rename) {
   ASSERT_EQ(readFile->pread(0, 5, &buffer), data);
 }
 
-TEST(LocalFile, exists) {
-  filesystems::registerLocalFileSystem();
-  auto tempFolder = ::exec::test::TempDirectoryPath::create();
-  auto a = fmt::format("{}/a", tempFolder->path);
-  auto b = fmt::format("{}/b", tempFolder->path);
+TEST_P(LocalFileTest, exists) {
+  auto tempFolder = ::exec::test::TempDirectoryPath::create(useFaultyFs_);
+  auto a = fmt::format("{}/a", tempFolder->getPath());
+  auto b = fmt::format("{}/b", tempFolder->getPath());
   auto localFs = filesystems::getFileSystem(a, nullptr);
   {
     auto writeFile = localFs->openFileForWrite(a);
@@ -191,47 +252,51 @@ TEST(LocalFile, exists) {
   ASSERT_FALSE(localFs->exists(b));
 }
 
-TEST(LocalFile, list) {
-  filesystems::registerLocalFileSystem();
-  auto tempFolder = ::exec::test::TempDirectoryPath::create();
-  auto a = fmt::format("{}/1", tempFolder->path);
-  auto b = fmt::format("{}/2", tempFolder->path);
+TEST_P(LocalFileTest, list) {
+  const auto tempFolder = ::exec::test::TempDirectoryPath::create(useFaultyFs_);
+  const auto a = fmt::format("{}/1", tempFolder->getPath());
+  const auto b = fmt::format("{}/2", tempFolder->getPath());
   auto localFs = filesystems::getFileSystem(a, nullptr);
   {
     auto writeFile = localFs->openFileForWrite(a);
     writeFile = localFs->openFileForWrite(b);
   }
-  auto files = localFs->list(std::string_view(tempFolder->path));
+  auto files = localFs->list(std::string_view(tempFolder->getPath()));
   std::sort(files.begin(), files.end());
   ASSERT_EQ(files, std::vector<std::string>({a, b}));
   localFs->remove(a);
   ASSERT_EQ(
-      localFs->list(std::string_view(tempFolder->path)),
+      localFs->list(std::string_view(tempFolder->getPath())),
       std::vector<std::string>({b}));
   localFs->remove(b);
-  ASSERT_TRUE(localFs->list(std::string_view(tempFolder->path)).empty());
+  ASSERT_TRUE(localFs->list(std::string_view(tempFolder->getPath())).empty());
 }
 
-TEST(LocalFile, readFileDestructor) {
-  auto tempFile = ::exec::test::TempFilePath::create();
-  const auto& filename = tempFile->path.c_str();
-  remove(filename);
+TEST_P(LocalFileTest, readFileDestructor) {
+  if (useFaultyFs_) {
+    return;
+  }
+  auto tempFile = exec::test::TempFilePath::create(useFaultyFs_);
+  const auto& filename = tempFile->getPath();
+  auto fs = filesystems::getFileSystem(filename, {});
+  fs->remove(filename);
   {
-    LocalWriteFile writeFile(filename);
-    writeData(&writeFile);
+    auto writeFile = fs->openFileForWrite(filename);
+    writeData(writeFile.get());
   }
 
   {
-    LocalReadFile readFile(filename);
-    readData(&readFile);
+    auto readFile = fs->openFileForRead(filename);
+    readData(readFile.get());
   }
 
   int32_t readFd;
   {
-    std::unique_ptr<char[]> buf(new char[tempFile->path.size() + 1]);
-    buf[tempFile->path.size()] = 0;
-    memcpy(buf.get(), tempFile->path.data(), tempFile->path.size());
-    readFd = open(buf.get(), O_RDONLY);
+    std::unique_ptr<char[]> buf(new char[tempFile->getPath().size() + 1]);
+    buf[tempFile->getPath().size()] = 0;
+    ::memcpy(
+        buf.get(), tempFile->getPath().c_str(), tempFile->getPath().size());
+    readFd = ::open(buf.get(), O_RDONLY);
   }
   {
     LocalReadFile readFile(readFd);
@@ -244,11 +309,10 @@ TEST(LocalFile, readFileDestructor) {
   }
 }
 
-TEST(LocalFile, mkdir) {
-  filesystems::registerLocalFileSystem();
-  auto tempFolder = ::exec::test::TempDirectoryPath::create();
+TEST_P(LocalFileTest, mkdir) {
+  auto tempFolder = exec::test::TempDirectoryPath::create(useFaultyFs_);
 
-  std::string path = tempFolder->path;
+  std::string path = tempFolder->getPath();
   auto localFs = filesystems::getFileSystem(path, nullptr);
 
   // Create 3 levels of directories and ensure they exist.
@@ -270,11 +334,10 @@ TEST(LocalFile, mkdir) {
   EXPECT_TRUE(localFs->exists(path));
 }
 
-TEST(LocalFile, rmdir) {
-  filesystems::registerLocalFileSystem();
-  auto tempFolder = ::exec::test::TempDirectoryPath::create();
+TEST_P(LocalFileTest, rmdir) {
+  auto tempFolder = exec::test::TempDirectoryPath::create(useFaultyFs_);
 
-  std::string path = tempFolder->path;
+  std::string path = tempFolder->getPath();
   auto localFs = filesystems::getFileSystem(path, nullptr);
 
   // Create 3 levels of directories and ensure they exist.
@@ -293,13 +356,401 @@ TEST(LocalFile, rmdir) {
   EXPECT_TRUE(localFs->exists(path));
 
   // Now delete the whole temp folder and ensure it is gone.
-  EXPECT_NO_THROW(localFs->rmdir(tempFolder->path));
-  EXPECT_FALSE(localFs->exists(tempFolder->path));
+  EXPECT_NO_THROW(localFs->rmdir(tempFolder->getPath()));
+  EXPECT_FALSE(localFs->exists(tempFolder->getPath()));
 
   // Delete a non-existing directory.
   path += "/does_not_exist/subdir";
   EXPECT_FALSE(localFs->exists(path));
   // The function does not throw, but will return zero files and folders
   // deleted, which is not an error.
-  EXPECT_NO_THROW(localFs->rmdir(tempFolder->path));
+  EXPECT_NO_THROW(localFs->rmdir(tempFolder->getPath()));
+}
+
+TEST_P(LocalFileTest, fileNotFound) {
+  auto tempFolder = exec::test::TempDirectoryPath::create(useFaultyFs_);
+  auto path = fmt::format("{}/file", tempFolder->getPath());
+  auto localFs = filesystems::getFileSystem(path, nullptr);
+  VELOX_ASSERT_RUNTIME_THROW_CODE(
+      localFs->openFileForRead(path),
+      error_code::kFileNotFound,
+      "No such file or directory");
+}
+
+TEST_P(LocalFileTest, attributes) {
+  auto tempFile = exec::test::TempFilePath::create(useFaultyFs_);
+  const auto& filename = tempFile->getPath();
+  auto fs = filesystems::getFileSystem(filename, {});
+  fs->remove(filename);
+  auto writeFile = fs->openFileForWrite(filename);
+  ASSERT_FALSE(
+      LocalWriteFile::Attributes::cowDisabled(writeFile->getAttributes()));
+  try {
+    writeFile->setAttributes(
+        {{std::string(LocalWriteFile::Attributes::kNoCow), "true"}});
+  } catch (const std::exception& /*e*/) {
+    // Flags like FS_IOC_SETFLAGS might not be supported for certain
+    // file systems (e.g., EXT4, XFS).
+  }
+  ASSERT_TRUE(
+      LocalWriteFile::Attributes::cowDisabled(writeFile->getAttributes()));
+  writeFile->close();
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    LocalFileTestSuite,
+    LocalFileTest,
+    ::testing::Values(false, true));
+
+class FaultyFsTest : public ::testing::Test {
+ protected:
+  FaultyFsTest() {}
+
+  static void SetUpTestCase() {
+    filesystems::registerLocalFileSystem();
+    tests::utils::registerFaultyFileSystem();
+  }
+
+  void SetUp() {
+    dir_ = exec::test::TempDirectoryPath::create(true);
+    fs_ = std::dynamic_pointer_cast<tests::utils::FaultyFileSystem>(
+        filesystems::getFileSystem(dir_->getPath(), {}));
+    VELOX_CHECK_NOT_NULL(fs_);
+    readFilePath_ = fmt::format("{}/faultyTestReadFile", dir_->getPath());
+    writeFilePath_ = fmt::format("{}/faultyTestWriteFile", dir_->getPath());
+    const int bufSize = 1024;
+    buffer_.resize(bufSize);
+    for (int i = 0; i < bufSize; ++i) {
+      buffer_[i] = i % 256;
+    }
+    {
+      auto writeFile = fs_->openFileForWrite(readFilePath_, {});
+      writeData(writeFile.get());
+    }
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    readData(readFile.get(), true);
+    try {
+      VELOX_FAIL("InjectedFaultFileError");
+    } catch (VeloxRuntimeError&) {
+      fileError_ = std::current_exception();
+    }
+  }
+
+  void TearDown() {
+    fs_->clearFileFaultInjections();
+  }
+
+  void writeData(WriteFile* file) {
+    file->append(std::string_view(buffer_));
+    file->flush();
+  }
+
+  void readData(ReadFile* file, bool useReadv = false) {
+    char readBuf[buffer_.size()];
+    if (!useReadv) {
+      file->pread(0, buffer_.size(), readBuf);
+    } else {
+      std::vector<folly::Range<char*>> buffers;
+      buffers.push_back(folly::Range<char*>(readBuf, buffer_.size()));
+      file->preadv(0, buffers);
+    }
+    for (int i = 0; i < buffer_.size(); ++i) {
+      if (buffer_[i] != readBuf[i]) {
+        VELOX_FAIL("Data Mismatch");
+      }
+    }
+  }
+
+  std::shared_ptr<exec::test::TempDirectoryPath> dir_;
+  std::string readFilePath_;
+  std::string writeFilePath_;
+  std::shared_ptr<tests::utils::FaultyFileSystem> fs_;
+  std::string buffer_;
+  std::exception_ptr fileError_;
+};
+
+TEST_F(FaultyFsTest, schemCheck) {
+  ASSERT_TRUE(
+      filesystems::isPathSupportedByRegisteredFileSystems("faulty:/test"));
+  ASSERT_FALSE(
+      filesystems::isPathSupportedByRegisteredFileSystems("other:/test"));
+}
+
+TEST_F(FaultyFsTest, fileReadErrorInjection) {
+  // Set read error.
+  fs_->setFileInjectionError(fileError_, {FaultFileOperation::Type::kRead});
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    VELOX_ASSERT_THROW(
+        readData(readFile.get(), false), "InjectedFaultFileError");
+  }
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    // We only inject error for pread API so preadv should be fine.
+    readData(readFile.get(), true);
+  }
+
+  // Set readv error
+  fs_->setFileInjectionError(fileError_, {FaultFileOperation::Type::kReadv});
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    VELOX_ASSERT_THROW(
+        readData(readFile.get(), true), "InjectedFaultFileError");
+  }
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    // We only inject error for preadv API so pread should be fine.
+    readData(readFile.get(), false);
+  }
+
+  // Set error for all kinds of operations.
+  fs_->setFileInjectionError(fileError_);
+  auto readFile = fs_->openFileForRead(readFilePath_, {});
+  VELOX_ASSERT_THROW(readData(readFile.get(), true), "InjectedFaultFileError");
+  VELOX_ASSERT_THROW(readData(readFile.get(), false), "InjectedFaultFileError");
+  fs_->remove(readFilePath_);
+}
+
+TEST_F(FaultyFsTest, fileReadDelayInjection) {
+  // Set 2 seconds delay.
+  const uint64_t injectDelay{2'000'000};
+  fs_->setFileInjectionDelay(injectDelay, {FaultFileOperation::Type::kRead});
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    uint64_t readDurationUs{0};
+    {
+      MicrosecondTimer readTimer(&readDurationUs);
+      readData(readFile.get(), false);
+    }
+    ASSERT_GE(readDurationUs, injectDelay);
+  }
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    // We only inject error for pread API so preadv should be fine.
+    uint64_t readDurationUs{0};
+    {
+      MicrosecondTimer readTimer(&readDurationUs);
+      readData(readFile.get(), true);
+    }
+    ASSERT_LT(readDurationUs, injectDelay);
+  }
+
+  // Set readv error
+  fs_->setFileInjectionDelay(injectDelay, {FaultFileOperation::Type::kReadv});
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    uint64_t readDurationUs{0};
+    {
+      MicrosecondTimer readTimer(&readDurationUs);
+      readData(readFile.get(), true);
+    }
+    ASSERT_GE(readDurationUs, injectDelay);
+  }
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    // We only inject error for pread API so preadv should be fine.
+    uint64_t readDurationUs{0};
+    {
+      MicrosecondTimer readTimer(&readDurationUs);
+      readData(readFile.get(), false);
+    }
+    ASSERT_LT(readDurationUs, injectDelay);
+  }
+
+  // Set error for all kinds of operations.
+  fs_->setFileInjectionDelay(injectDelay);
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    // We only inject error for pread API so preadv should be fine.
+    uint64_t readDurationUs{0};
+    {
+      MicrosecondTimer readTimer(&readDurationUs);
+      readData(readFile.get(), false);
+    }
+    ASSERT_GE(readDurationUs, injectDelay);
+  }
+  {
+    auto readFile = fs_->openFileForRead(readFilePath_, {});
+    // We only inject error for pread API so preadv should be fine.
+    uint64_t readDurationUs{0};
+    {
+      MicrosecondTimer readTimer(&readDurationUs);
+      readData(readFile.get(), false);
+    }
+    ASSERT_GE(readDurationUs, injectDelay);
+  }
+}
+
+TEST_F(FaultyFsTest, fileReadFaultHookInjection) {
+  const std::string path1 = fmt::format("{}/hookFile1", dir_->getPath());
+  {
+    auto writeFile = fs_->openFileForWrite(path1, {});
+    writeData(writeFile.get());
+    auto readFile = fs_->openFileForRead(path1, {});
+    readData(readFile.get());
+  }
+  const std::string path2 = fmt::format("{}/hookFile2", dir_->getPath());
+  {
+    auto writeFile = fs_->openFileForWrite(path2, {});
+    writeData(writeFile.get());
+    auto readFile = fs_->openFileForRead(path2, {});
+    readData(readFile.get());
+  }
+  // Set read error.
+  fs_->setFileInjectionHook([&](FaultFileOperation* op) {
+    // Only inject error for readv.
+    if (op->type != FaultFileOperation::Type::kReadv) {
+      return;
+    }
+    // Only inject error for path2.
+    if (op->path != path2) {
+      return;
+    }
+    VELOX_FAIL("inject hook read failure");
+  });
+  {
+    auto readFile = fs_->openFileForRead(path1, {});
+    readData(readFile.get(), false);
+    readData(readFile.get(), true);
+  }
+  {
+    auto readFile = fs_->openFileForRead(path2, {});
+    // Verify only throw for readv.
+    readData(readFile.get(), false);
+    VELOX_ASSERT_THROW(
+        readData(readFile.get(), true), "inject hook read failure");
+  }
+
+  // Set to return fake data.
+  fs_->setFileInjectionHook([&](FaultFileOperation* op) {
+    // Only inject error for path1.
+    if (op->path != path1) {
+      return;
+    }
+    // Only inject error for read.
+    if (op->type != FaultFileOperation::Type::kRead) {
+      return;
+    }
+    auto* readOp = static_cast<FaultFileReadOperation*>(op);
+    char* readBuf = static_cast<char*>(readOp->buf);
+    for (int i = 0; i < readOp->length; ++i) {
+      readBuf[i] = 0;
+    }
+    readOp->delegate = false;
+  });
+
+  {
+    auto readFile = fs_->openFileForRead(path2, {});
+    readData(readFile.get(), false);
+    readData(readFile.get(), true);
+  }
+  {
+    auto readFile = fs_->openFileForRead(path1, {});
+    // Verify only throw for read.
+    readData(readFile.get(), true);
+    VELOX_ASSERT_THROW(readData(readFile.get(), false), "Data Mismatch");
+  }
+}
+
+TEST_F(FaultyFsTest, fileWriteErrorInjection) {
+  // Set write error.
+  fs_->setFileInjectionError(fileError_, {FaultFileOperation::Type::kWrite});
+  {
+    auto writeFile = fs_->openFileForWrite(writeFilePath_, {});
+    VELOX_ASSERT_THROW(writeFile->append("hello"), "InjectedFaultFileError");
+    fs_->remove(writeFilePath_);
+  }
+  // Set error for all kinds of operations.
+  fs_->setFileInjectionError(fileError_);
+  {
+    auto writeFile = fs_->openFileForWrite(writeFilePath_, {});
+    VELOX_ASSERT_THROW(writeFile->append("hello"), "InjectedFaultFileError");
+    fs_->remove(writeFilePath_);
+  }
+}
+
+TEST_F(FaultyFsTest, fileWriteDelayInjection) {
+  // Set 2 seconds delay.
+  const uint64_t injectDelay{2'000'000};
+  fs_->setFileInjectionDelay(injectDelay, {FaultFileOperation::Type::kWrite});
+  {
+    auto writeFile = fs_->openFileForWrite(writeFilePath_, {});
+    uint64_t readDurationUs{0};
+    {
+      MicrosecondTimer readTimer(&readDurationUs);
+      writeFile->append("hello");
+    }
+    ASSERT_GE(readDurationUs, injectDelay);
+    fs_->remove(writeFilePath_);
+  }
+}
+
+TEST_F(FaultyFsTest, fileWriteFaultHookInjection) {
+  const std::string path1 = fmt::format("{}/hookFile1", dir_->getPath());
+  const std::string path2 = fmt::format("{}/hookFile2", dir_->getPath());
+  // Set to write fake data.
+  fs_->setFileInjectionHook([&](FaultFileOperation* op) {
+    // Only inject for write.
+    if (op->type != FaultFileOperation::Type::kWrite) {
+      return;
+    }
+    // Only inject for path2.
+    if (op->path != path2) {
+      return;
+    }
+    auto* writeOp = static_cast<FaultFileWriteOperation*>(op);
+    *writeOp->data = "Error data";
+  });
+  {
+    auto writeFile = fs_->openFileForWrite(path1, {});
+    writeFile->append("hello");
+    writeFile->close();
+    auto readFile = fs_->openFileForRead(path1, {});
+    char buffer[5];
+    ASSERT_EQ(readFile->size(), 5);
+    ASSERT_EQ(readFile->pread(0, 5, &buffer), "hello");
+    fs_->remove(path1);
+  }
+  {
+    auto writeFile = fs_->openFileForWrite(path2, {});
+    writeFile->append("hello");
+    writeFile->close();
+    auto readFile = fs_->openFileForRead(path2, {});
+    char buffer[10];
+    ASSERT_EQ(readFile->size(), 10);
+    ASSERT_EQ(readFile->pread(0, 10, &buffer), "Error data");
+    fs_->remove(path2);
+  }
+
+  // Set to not delegate.
+  fs_->setFileInjectionHook([&](FaultFileOperation* op) {
+    // Only inject for write.
+    if (op->type != FaultFileOperation::Type::kWrite) {
+      return;
+    }
+    // Only inject for path2.
+    if (op->path != path2) {
+      return;
+    }
+    auto* writeOp = static_cast<FaultFileWriteOperation*>(op);
+    writeOp->delegate = false;
+  });
+  {
+    auto writeFile = fs_->openFileForWrite(path1, {});
+    writeFile->append("hello");
+    writeFile->close();
+    auto readFile = fs_->openFileForRead(path1, {});
+    char buffer[5];
+    ASSERT_EQ(readFile->size(), 5);
+    ASSERT_EQ(readFile->pread(0, 5, &buffer), "hello");
+    fs_->remove(path1);
+  }
+  {
+    auto writeFile = fs_->openFileForWrite(path2, {});
+    writeFile->append("hello");
+    writeFile->close();
+    auto readFile = fs_->openFileForRead(path2, {});
+    ASSERT_EQ(readFile->size(), 0);
+    fs_->remove(path2);
+  }
 }
diff --git a/velox/common/file/tests/UtilsTest.cpp b/velox/common/file/tests/UtilsTest.cpp
index 58d9d76f796c5..a2b2d6ee5a04e 100644
--- a/velox/common/file/tests/UtilsTest.cpp
+++ b/velox/common/file/tests/UtilsTest.cpp
@@ -70,8 +70,13 @@ coalescedIndices(Iter begin, Iter end, ShouldCoalesce& shouldCoalesce) {
 bool willCoalesceIfDistanceLE(
     uint64_t distance,
     const Region& regionA,
-    const Region& regionB) {
-  return CoalesceIfDistanceLE(distance)(regionA, regionB);
+    const Region& regionB,
+    uint64_t expectedCoalescedBytes) {
+  uint64_t coalescedBytes = 0;
+  const bool willCoalesce =
+      CoalesceIfDistanceLE(distance, &coalescedBytes)(regionA, regionB);
+  EXPECT_EQ(coalescedBytes, expectedCoalescedBytes);
+  return willCoalesce;
 }
 
 auto getReader(
@@ -197,53 +202,68 @@ TEST(CoalesceSegmentsTest, MergeEven) {
 }
 
 TEST(CoalesceIfDistanceLETest, MultipleCases) {
-  EXPECT_TRUE(willCoalesceIfDistanceLE(0, {0, 1}, {1, 1}));
-  EXPECT_FALSE(willCoalesceIfDistanceLE(0, {0, 1}, {2, 1}));
+  EXPECT_TRUE(willCoalesceIfDistanceLE(0, {0, 1}, {1, 1}, 0));
+  EXPECT_FALSE(willCoalesceIfDistanceLE(0, {0, 1}, {2, 1}, 0));
 
-  EXPECT_TRUE(willCoalesceIfDistanceLE(1, {0, 1}, {2, 1}));
+  EXPECT_TRUE(willCoalesceIfDistanceLE(1, {0, 1}, {2, 1}, 1));
 
-  EXPECT_TRUE(willCoalesceIfDistanceLE(10, {0, 1}, {1, 1}));
-  EXPECT_TRUE(willCoalesceIfDistanceLE(10, {10, 1}, {11, 1}));
-  EXPECT_TRUE(willCoalesceIfDistanceLE(10, {0, 10}, {19, 5}));
-  EXPECT_TRUE(willCoalesceIfDistanceLE(10, {0, 10}, {20, 5}));
-  EXPECT_FALSE(willCoalesceIfDistanceLE(10, {0, 10}, {21, 5}));
+  EXPECT_TRUE(willCoalesceIfDistanceLE(10, {0, 1}, {1, 1}, 0));
+  EXPECT_TRUE(willCoalesceIfDistanceLE(10, {10, 1}, {11, 1}, 0));
+  EXPECT_TRUE(willCoalesceIfDistanceLE(10, {0, 10}, {19, 5}, 9));
+  EXPECT_TRUE(willCoalesceIfDistanceLE(10, {0, 10}, {20, 5}, 10));
+  EXPECT_FALSE(willCoalesceIfDistanceLE(10, {0, 10}, {21, 5}, 0));
 
-  EXPECT_TRUE(willCoalesceIfDistanceLE(0, {0, 0}, {0, 1}));
+  EXPECT_TRUE(willCoalesceIfDistanceLE(0, {0, 0}, {0, 1}, 0));
+}
+
+TEST(CoalesceIfDistanceLETest, MultipleSegments) {
+  uint64_t coalescedBytes = 0;
+  auto willCoalesce = CoalesceIfDistanceLE(10, &coalescedBytes);
+  EXPECT_TRUE(willCoalesce({0, 1}, {1, 1})); // 0
+  EXPECT_TRUE(willCoalesce({10, 1}, {11, 1})); // 0
+  EXPECT_TRUE(willCoalesce({0, 10}, {19, 5})); // 9
+  EXPECT_TRUE(willCoalesce({0, 10}, {20, 5})); // 10
+  EXPECT_FALSE(willCoalesce({0, 10}, {21, 5})); // 0
+  EXPECT_EQ(coalescedBytes, 19);
+}
+
+TEST(CoalesceIfDistanceLETest, SupportsNullArgument) {
+  EXPECT_NO_THROW(CoalesceIfDistanceLE(10, nullptr)({0, 10}, {20, 5})); // 10
 }
 
 TEST(CoalesceIfDistanceLETest, SegmentsMustBeSorted) {
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(0, {1, 1}, {0, 1}),
+      willCoalesceIfDistanceLE(0, {1, 1}, {0, 1}, 0),
       ::facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(10, {1, 1}, {0, 1}),
+      willCoalesceIfDistanceLE(10, {1, 1}, {0, 1}, 0),
       ::facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(0, {1000, 1}, {2, 1}),
+      willCoalesceIfDistanceLE(0, {1000, 1}, {2, 1}, 0),
       ::facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(10, {1000, 1}, {2, 1}),
+      willCoalesceIfDistanceLE(10, {1000, 1}, {2, 1}, 0),
       ::facebook::velox::VeloxRuntimeError);
 }
 
 TEST(CoalesceIfDistanceLETest, SegmentsCantOverlap) {
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(0, {0, 1}, {0, 1}),
+      willCoalesceIfDistanceLE(0, {0, 1}, {0, 1}, 0),
       ::facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(10, {0, 1}, {0, 1}),
+      willCoalesceIfDistanceLE(10, {0, 1}, {0, 1}, 0),
       ::facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(0, {0, 2}, {1, 1}),
+      willCoalesceIfDistanceLE(0, {0, 2}, {1, 1}, 0),
       ::facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(10, {0, 2}, {1, 1}),
+      willCoalesceIfDistanceLE(10, {0, 2}, {1, 1}, 0),
       ::facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(0, {0, 2}, {1, 2}),
+      willCoalesceIfDistanceLE(0, {0, 2}, {1, 2}, 0),
       ::facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
-      willCoalesceIfDistanceLE(10, {0, 2}, {1, 2}),
+      willCoalesceIfDistanceLE(10, {0, 2}, {1, 2}, 0),
       ::facebook::velox::VeloxRuntimeError);
 }
 
diff --git a/velox/common/hyperloglog/CMakeLists.txt b/velox/common/hyperloglog/CMakeLists.txt
index 3b4cb32efcd34..27c07830b8644 100644
--- a/velox/common/hyperloglog/CMakeLists.txt
+++ b/velox/common/hyperloglog/CMakeLists.txt
@@ -11,14 +11,18 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
+velox_add_library(velox_common_hyperloglog BiasCorrection.cpp DenseHll.cpp
+                  SparseHll.cpp)
 
-add_library(velox_common_hyperloglog BiasCorrection.cpp DenseHll.cpp
-                                     SparseHll.cpp)
-
-target_link_libraries(
+velox_link_libraries(
   velox_common_hyperloglog
   PUBLIC velox_memory
   PRIVATE velox_exception)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
+
+if(${VELOX_ENABLE_BENCHMARKS})
+  add_subdirectory(benchmarks)
+endif()
diff --git a/velox/common/hyperloglog/DenseHll.cpp b/velox/common/hyperloglog/DenseHll.cpp
index 09b17af838ca2..d383a7429776f 100644
--- a/velox/common/hyperloglog/DenseHll.cpp
+++ b/velox/common/hyperloglog/DenseHll.cpp
@@ -532,11 +532,11 @@ void DenseHll::mergeWith(const DenseHll& other) {
       "Cannot merge HLLs with different number of buckets");
 
   mergeWith(
-      other.baseline_,
-      other.deltas_.data(),
-      other.overflows_,
-      other.overflowBuckets_.data(),
-      other.overflowValues_.data());
+      {other.baseline_,
+       other.deltas_.data(),
+       other.overflows_,
+       other.overflowBuckets_.data(),
+       other.overflowValues_.data()});
 }
 
 void DenseHll::mergeWith(const char* serialized) {
@@ -558,16 +558,200 @@ void DenseHll::mergeWith(const char* serialized) {
   auto overflows = stream.read<int16_t>();
   auto overflowBuckets = overflows ? stream.read<uint16_t>(overflows) : nullptr;
   auto overflowValues = overflows ? stream.read<int8_t>(overflows) : nullptr;
-  mergeWith(baseline, deltas, overflows, overflowBuckets, overflowValues);
+  mergeWith({baseline, deltas, overflows, overflowBuckets, overflowValues});
 }
 
-void DenseHll::mergeWith(
-    int8_t otherBaseline,
-    const int8_t* otherDeltas,
-    int16_t otherOverflows,
-    const uint16_t* otherOverflowBuckets,
-    const int8_t* otherOverflowValues) {
-  int8_t newBaseline = std::max(baseline_, otherBaseline);
+std::pair<int8_t, int16_t> DenseHll::computeNewValue(
+    int8_t delta,
+    int8_t otherDelta,
+    int32_t bucket,
+    const HllView& other) {
+  int8_t value1 = baseline_ + delta;
+  int8_t value2 = other.baseline + otherDelta;
+
+  int16_t overflowEntry = -1;
+  if (delta == kMaxDelta) {
+    overflowEntry = findOverflowEntry(bucket);
+    if (overflowEntry != -1) {
+      value1 += overflowValues_[overflowEntry];
+    }
+  }
+
+  if (otherDelta == kMaxDelta) {
+    value2 += getOverflowImpl(
+        bucket, other.overflows, other.overflowBuckets, other.overflowValues);
+  }
+
+  return {std::max(value1, value2), overflowEntry};
+}
+
+void DenseHll::mergeWith(const HllView& other) {
+  // Number of 'delta' bytes that fit in a single SIMD batch. Each 'delta' byte
+  // stores 2 4-bit deltas.
+  constexpr auto batchSize = xsimd::batch<int8_t>::size;
+
+  // If deltas_.size() is not a multiple of batchSize, we need to use scalar
+  // code to process the 'tail'. deltas_.size() is a power of 2. batchSize is
+  // also a power of 2. Hence, the only case where deltas_.size() is not a
+  // multiple of batchSize is when deltas_.size() is less than batchSize. In
+  // this case we can't use SIMD path at all. Therefore, there are only 2
+  // possibilities: all data can be processed using SIMD or none.
+
+  const int8_t newBaseline = std::max(baseline_, other.baseline);
+  if (deltas_.size() >= batchSize) {
+    baselineCount_ = mergeWithSimd(other, newBaseline);
+  } else {
+    baselineCount_ = mergeWithScalar(other, newBaseline);
+  }
+
+  baseline_ = newBaseline;
+
+  // If all baseline values in one of the HLLs lost to the values
+  // in the other HLL, we need to adjust the final baseline.
+  adjustBaselineIfNeeded();
+}
+
+int32_t DenseHll::mergeWithSimd(const HllView& other, int8_t newBaseline) {
+  const auto batchSize = xsimd::batch<int8_t>::size;
+
+  const auto bucketMaskBatch = xsimd::broadcast(kBucketMask);
+  const auto maxDeltaBatch = xsimd::broadcast(kMaxDelta);
+  const auto baselineBatch = xsimd::broadcast(baseline_);
+  const auto otherBaselineBatch = xsimd::broadcast(other.baseline);
+  const auto newBaselineBatch = xsimd::broadcast(newBaseline);
+  const auto zeroBatch = xsimd::broadcast((int8_t)0);
+
+  // SIMD doesn't support 4-bit integers. The smallest integer is 8-bit.
+  // We are going to use 2 SIMD registers to process a batch of values.
+  // One register will store values with odd indices (0, 2, 4...). The other
+  // register will store values with even indices (1, 3, 5...).
+
+  // Load deltas with even indices into SIMD register.
+  auto loadEven = [&](const int8_t* deltas) {
+    auto batch = xsimd::load_unaligned(deltas);
+    batch = xsimd::kernel::bitwise_rshift(batch, 4, xsimd::default_arch{});
+    return xsimd::bitwise_and(batch, bucketMaskBatch);
+  };
+
+  // Load deltas with odd indices into SIMD register.
+  auto loadOdd = [&](const int8_t* deltas) {
+    auto batch = xsimd::load_unaligned(deltas);
+    return xsimd::bitwise_and(batch, bucketMaskBatch);
+  };
+
+  // Count number of zeros in a SIMD register.
+  auto countZeros = [&](const xsimd::batch<int8_t>& batch) {
+    auto zerosBitmask = xsimd::eq(batch, zeroBatch).mask();
+    return bits::countBits(&zerosBitmask, 0, batchSize);
+  };
+
+  // Given two SIMD registers of deltas, converts deltas to values by adding
+  // baselines and returns their max along with a bitmask that has bits set for
+  // entries that may have an overflow.
+  auto processBatch = [&](xsimd::batch<int8_t>& batch,
+                          xsimd::batch<int8_t>& otherBatch) {
+    auto overflows = xsimd::eq(batch, maxDeltaBatch).mask();
+    batch += baselineBatch;
+
+    overflows |= xsimd::eq(otherBatch, maxDeltaBatch).mask();
+    otherBatch += otherBaselineBatch;
+
+    // Compute max.
+    auto maxBatch = xsimd::max(batch, otherBatch);
+    maxBatch -= newBaselineBatch;
+
+    return std::pair{maxBatch, overflows};
+  };
+
+  auto processOverflow = [&](int8_t delta1, int8_t delta2, int bucket) {
+    auto [newValue, overflowEntry] =
+        computeNewValue(delta1, delta2, bucket, other);
+
+    int8_t newDelta = newValue - newBaseline;
+
+    return updateOverflow(bucket, overflowEntry, newDelta);
+  };
+
+  int32_t baselineCount = 0;
+  for (int i = 0; i < deltas_.size(); i += batchSize) {
+    // Process values in even indices first.
+    auto evenBatch = loadEven(deltas_.data() + i);
+    auto otherEvenBatch = loadEven(other.deltas + i);
+
+    auto [evenMaxBatch, evenOverflows] =
+        processBatch(evenBatch, otherEvenBatch);
+
+    baselineCount += countZeros(evenMaxBatch);
+
+    // Process values in odd indices.
+    auto oddBatch = loadOdd(deltas_.data() + i);
+    auto otherOddBatch = loadOdd(other.deltas + i);
+
+    auto [oddMaxBatch, oddOverflows] = processBatch(oddBatch, otherOddBatch);
+
+    baselineCount += countZeros(oddMaxBatch);
+
+    // Combine even and odd batches. Shift even batch left by 4 bits, then OR
+    // with odd batch.
+    auto combinedBatch =
+        xsimd::kernel::bitwise_lshift(evenMaxBatch, 4, xsimd::default_arch{});
+    combinedBatch = xsimd::bitwise_or(combinedBatch, oddMaxBatch);
+
+    xsimd::store_unaligned(deltas_.data() + i, combinedBatch);
+
+    // Process overflows.
+    if (evenOverflows != 0) {
+      // deltas_ has been updated and can no longer be used to process overflow
+      // entries. evenBatch and otherEvenBatch contain original deltas +
+      // baseline.
+      int8_t temp[batchSize], otherTemp[batchSize];
+      xsimd::store_unaligned(temp, evenBatch);
+      xsimd::store_unaligned(otherTemp, otherEvenBatch);
+
+      bits::forEachSetBit(&evenOverflows, 0, batchSize, [&](auto index) {
+        const auto deltaIndex = i + index;
+        const auto bucket = deltaIndex * 2;
+        int8_t newDelta = processOverflow(
+            temp[index] - baseline_, otherTemp[index] - other.baseline, bucket);
+
+        if (newDelta == 0) {
+          baselineCount++;
+        }
+
+        // Store newDelta in deltas_[deltaIndex].
+        auto slot1 = deltas_[deltaIndex];
+        deltas_[deltaIndex] = (newDelta << 4) | (slot1 & kBucketMask);
+      });
+    }
+
+    if (oddOverflows != 0) {
+      // deltas_ has been updated and can no longer be used to process overflow
+      // entries. oddBatch and otherOddBatch contain original deltas + baseline.
+      int8_t temp[batchSize], otherTemp[batchSize];
+      xsimd::store_unaligned(temp, oddBatch);
+      xsimd::store_unaligned(otherTemp, otherOddBatch);
+
+      bits::forEachSetBit(&oddOverflows, 0, batchSize, [&](auto index) {
+        const auto deltaIndex = i + index;
+        const auto bucket = deltaIndex * 2 + 1;
+        int8_t newDelta = processOverflow(
+            temp[index] - baseline_, otherTemp[index] - other.baseline, bucket);
+
+        if (newDelta == 0) {
+          baselineCount++;
+        }
+
+        // Store newDelta.
+        auto slot1 = deltas_[deltaIndex];
+        deltas_[deltaIndex] = (((slot1 >> 4) & kBucketMask) << 4) | newDelta;
+      });
+    }
+  }
+
+  return baselineCount;
+}
+
+int32_t DenseHll::mergeWithScalar(const HllView& other, int8_t newBaseline) {
   int32_t baselineCount = 0;
 
   int bucket = 0;
@@ -575,29 +759,15 @@ void DenseHll::mergeWith(
     int newSlot = 0;
 
     int8_t slot1 = deltas_[i];
-    int8_t slot2 = otherDeltas[i];
+    int8_t slot2 = other.deltas[i];
 
     for (int shift = 4; shift >= 0; shift -= 4) {
       int8_t delta1 = (slot1 >> shift) & kBucketMask;
       int8_t delta2 = (slot2 >> shift) & kBucketMask;
 
-      int8_t value1 = baseline_ + delta1;
-      int8_t value2 = otherBaseline + delta2;
+      auto [newValue, overflowEntry] =
+          computeNewValue(delta1, delta2, bucket, other);
 
-      int16_t overflowEntry = -1;
-      if (delta1 == kMaxDelta) {
-        overflowEntry = findOverflowEntry(bucket);
-        if (overflowEntry != -1) {
-          value1 += overflowValues_[overflowEntry];
-        }
-      }
-
-      if (delta2 == kMaxDelta) {
-        value2 += getOverflowImpl(
-            bucket, otherOverflows, otherOverflowBuckets, otherOverflowValues);
-      }
-
-      int8_t newValue = std::max(value1, value2);
       int8_t newDelta = newValue - newBaseline;
 
       if (newDelta == 0) {
@@ -614,12 +784,7 @@ void DenseHll::mergeWith(
     deltas_[i] = newSlot;
   }
 
-  baseline_ = newBaseline;
-  baselineCount_ = baselineCount;
-
-  // All baseline values in one of the HLLs lost to the values
-  // in the other HLL, so we need to adjust the final baseline.
-  adjustBaselineIfNeeded();
+  return baselineCount;
 }
 
 int8_t
diff --git a/velox/common/hyperloglog/DenseHll.h b/velox/common/hyperloglog/DenseHll.h
index 3b3c50b9ae5ef..b6b5f03f8cdf2 100644
--- a/velox/common/hyperloglog/DenseHll.h
+++ b/velox/common/hyperloglog/DenseHll.h
@@ -109,12 +109,34 @@ class DenseHll {
 
   void removeOverflow(int overflowEntry);
 
-  void mergeWith(
-      int8_t otherBaseline,
-      const int8_t* otherDeltas,
-      int16_t otherOverflows,
-      const uint16_t* otherOverflowBuckets,
-      const int8_t* otherOverflowValues);
+  struct HllView {
+    int8_t baseline;
+    const int8_t* deltas;
+    int16_t overflows;
+    const uint16_t* overflowBuckets;
+    const int8_t* overflowValues;
+  };
+
+  void mergeWith(const HllView& other);
+
+  // Merges 'other' HLL into this one using scalar (non-SIMD) code.
+  // @return Number of buckets with values equal to 'newBaseline'.
+  int32_t mergeWithScalar(const HllView& other, int8_t newBaseline);
+
+  // Merges 'other' HLL into this one using SIMD.
+  // @return Number of buckets with values equal to 'newBaseline'.
+  int32_t mergeWithSimd(const HllView& other, int8_t newBaseline);
+
+  // Given two deltas and a bucket, converts deltas into values and returns
+  // their max.
+  // @return Max of two values and an index into overflowBuckets_ and
+  // overflowValues_ if 'delta' has an overflow. If 'delta' doesn't have an
+  // overflow, the second value is -1.
+  std::pair<int8_t, int16_t> computeNewValue(
+      int8_t delta,
+      int8_t otherDelta,
+      int32_t bucket,
+      const HllView& other);
 
   /// Number of first bits of the hash to calculate buckets from.
   int8_t indexBitLength_;
diff --git a/velox/common/hyperloglog/HllUtils.h b/velox/common/hyperloglog/HllUtils.h
index 6ad82de773290..0c32bdb5204ba 100644
--- a/velox/common/hyperloglog/HllUtils.h
+++ b/velox/common/hyperloglog/HllUtils.h
@@ -23,7 +23,8 @@ namespace facebook::velox::common::hll {
 
 constexpr double kLowestMaxStandardError = 0.0040625;
 constexpr double kHighestMaxStandardError = 0.26000;
-constexpr double kDefaultStandardError = 0.023;
+constexpr double kDefaultApproxDistinctStandardError = 0.023;
+constexpr double kDefaultApproxSetStandardError = 0.01625;
 
 const int8_t kPrestoSparseV2 = 2;
 const int8_t kPrestoDenseV2 = 3;
diff --git a/velox/common/hyperloglog/benchmarks/CMakeLists.txt b/velox/common/hyperloglog/benchmarks/CMakeLists.txt
new file mode 100644
index 0000000000000..2b86b9cd66ee8
--- /dev/null
+++ b/velox/common/hyperloglog/benchmarks/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_common_hyperloglog_dense_hll_bm DenseHll.cpp)
+
+target_link_libraries(
+  velox_common_hyperloglog_dense_hll_bm velox_common_hyperloglog
+  ${FOLLY_BENCHMARK})
diff --git a/velox/common/hyperloglog/benchmarks/DenseHll.cpp b/velox/common/hyperloglog/benchmarks/DenseHll.cpp
new file mode 100644
index 0000000000000..0503c4dbe74a0
--- /dev/null
+++ b/velox/common/hyperloglog/benchmarks/DenseHll.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/hyperloglog/DenseHll.h"
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include "velox/common/memory/HashStringAllocator.h"
+
+#define XXH_INLINE_ALL
+#include <xxhash.h>
+
+using namespace facebook::velox;
+
+namespace {
+
+template <typename T>
+uint64_t hashOne(T value) {
+  return XXH64(&value, sizeof(value), 0);
+}
+
+// A benchmark for DenseHll::mergeWith(serialized) API.
+//
+// Measures the time it takes to merge 2 serialized digests using different
+// values for hash bits. Larger values of hash bits corresponds to larger
+// digests that are more accurate, but slower to merge. The default number of
+// hash bits is 11, while in practice 16 is common.
+class DenseHllBenchmark {
+ public:
+  explicit DenseHllBenchmark(memory::MemoryPool* pool) : pool_(pool) {
+    for (auto hashBits : {11, 12, 16}) {
+      serializedHlls_[hashBits].push_back(makeSerializedHll(hashBits, 1));
+      serializedHlls_[hashBits].push_back(makeSerializedHll(hashBits, 2));
+    }
+  }
+
+  void run(int hashBits) {
+    folly::BenchmarkSuspender suspender;
+
+    HashStringAllocator allocator(pool_);
+    common::hll::DenseHll hll(hashBits, &allocator);
+
+    suspender.dismiss();
+
+    for (const auto& serialized : serializedHlls_.at(hashBits)) {
+      hll.mergeWith(serialized.data());
+    }
+  }
+
+ private:
+  std::string makeSerializedHll(int hashBits, int32_t step) {
+    HashStringAllocator allocator(pool_);
+    common::hll::DenseHll hll(hashBits, &allocator);
+    for (int32_t i = 0; i < 1'000'000; ++i) {
+      auto hash = hashOne(i * step);
+      hll.insertHash(hash);
+    }
+    return serialize(hll);
+  }
+
+  static std::string serialize(common::hll::DenseHll& denseHll) {
+    auto size = denseHll.serializedSize();
+    std::string serialized;
+    serialized.resize(size);
+    denseHll.serialize(serialized.data());
+    return serialized;
+  }
+
+  memory::MemoryPool* pool_;
+
+  // List of serialized HLLs to use for merging, keyed by the number of hash
+  // bits.
+  std::unordered_map<int, std::vector<std::string>> serializedHlls_;
+};
+
+} // namespace
+
+std::unique_ptr<DenseHllBenchmark> benchmark;
+
+BENCHMARK(mergeSerialized11) {
+  benchmark->run(11);
+}
+
+BENCHMARK(mergeSerialized12) {
+  benchmark->run(12);
+}
+
+BENCHMARK(mergeSerialized16) {
+  benchmark->run(16);
+}
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+
+  memory::MemoryManager::initialize({});
+  auto rootPool = memory::memoryManager()->addRootPool();
+  auto pool = rootPool->addLeafChild("bm");
+  benchmark = std::make_unique<DenseHllBenchmark>(pool.get());
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/common/hyperloglog/tests/CMakeLists.txt b/velox/common/hyperloglog/tests/CMakeLists.txt
index b500a958cbe6e..c05a810796fee 100644
--- a/velox/common/hyperloglog/tests/CMakeLists.txt
+++ b/velox/common/hyperloglog/tests/CMakeLists.txt
@@ -18,5 +18,5 @@ add_test(NAME velox_common_hyperloglog_test
          COMMAND velox_common_hyperloglog_test)
 
 target_link_libraries(
-  velox_common_hyperloglog_test PRIVATE velox_common_hyperloglog velox_encode
-                                        gtest gtest_main)
+  velox_common_hyperloglog_test
+  PRIVATE velox_common_hyperloglog velox_encode GTest::gtest GTest::gtest_main)
diff --git a/velox/common/hyperloglog/tests/DenseHllTest.cpp b/velox/common/hyperloglog/tests/DenseHllTest.cpp
index 66af1fd635eed..1484eec3c8b92 100644
--- a/velox/common/hyperloglog/tests/DenseHllTest.cpp
+++ b/velox/common/hyperloglog/tests/DenseHllTest.cpp
@@ -36,6 +36,10 @@ uint64_t hashOne(T value) {
 
 class DenseHllTest : public ::testing::TestWithParam<int8_t> {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   DenseHll roundTrip(DenseHll& hll) {
     auto size = hll.serializedSize();
     std::string serialized;
@@ -100,7 +104,8 @@ class DenseHllTest : public ::testing::TestWithParam<int8_t> {
         expected.cardinality());
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   HashStringAllocator allocator_{pool_.get()};
 };
 
diff --git a/velox/common/hyperloglog/tests/SparseHllTest.cpp b/velox/common/hyperloglog/tests/SparseHllTest.cpp
index d2f37ca1a6aac..afc06808fbfe0 100644
--- a/velox/common/hyperloglog/tests/SparseHllTest.cpp
+++ b/velox/common/hyperloglog/tests/SparseHllTest.cpp
@@ -30,6 +30,10 @@ uint64_t hashOne(T value) {
 
 class SparseHllTest : public ::testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   template <typename T>
   void testMergeWith(const std::vector<T>& left, const std::vector<T>& right) {
     testMergeWith(left, right, false);
@@ -98,7 +102,8 @@ class SparseHllTest : public ::testing::Test {
     return serialized;
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   HashStringAllocator allocator_{pool_.get()};
 };
 
@@ -170,6 +175,10 @@ TEST_F(SparseHllTest, mergeWith) {
 
 class SparseHllToDenseTest : public ::testing::TestWithParam<int8_t> {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   std::string serialize(DenseHll& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
@@ -178,7 +187,8 @@ class SparseHllToDenseTest : public ::testing::TestWithParam<int8_t> {
     return serialized;
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   HashStringAllocator allocator_{pool_.get()};
 };
 
diff --git a/velox/common/io/CMakeLists.txt b/velox/common/io/CMakeLists.txt
index 52619f0d5ce1e..3498214b4fdb4 100644
--- a/velox/common/io/CMakeLists.txt
+++ b/velox/common/io/CMakeLists.txt
@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_common_io IoStatistics.cpp)
+velox_add_library(velox_common_io IoStatistics.cpp)
 
-target_link_libraries(velox_common_io Folly::folly glog::glog)
+velox_link_libraries(velox_common_io Folly::folly glog::glog)
diff --git a/velox/common/io/IoStatistics.cpp b/velox/common/io/IoStatistics.cpp
index 562beacb773d1..7dfddc6dc4831 100644
--- a/velox/common/io/IoStatistics.cpp
+++ b/velox/common/io/IoStatistics.cpp
@@ -46,6 +46,10 @@ uint64_t IoStatistics::totalScanTime() const {
   return totalScanTime_.load(std::memory_order_relaxed);
 }
 
+uint64_t IoStatistics::writeIOTimeUs() const {
+  return writeIOTimeUs_.load(std::memory_order_relaxed);
+}
+
 uint64_t IoStatistics::incRawBytesRead(int64_t v) {
   return rawBytesRead_.fetch_add(v, std::memory_order_relaxed);
 }
@@ -70,22 +74,32 @@ uint64_t IoStatistics::incTotalScanTime(int64_t v) {
   return totalScanTime_.fetch_add(v, std::memory_order_relaxed);
 }
 
+uint64_t IoStatistics::incWriteIOTimeUs(int64_t v) {
+  return writeIOTimeUs_.fetch_add(v, std::memory_order_relaxed);
+}
+
 void IoStatistics::incOperationCounters(
     const std::string& operation,
     const uint64_t resourceThrottleCount,
     const uint64_t localThrottleCount,
+    const uint64_t networkThrottleCount,
     const uint64_t globalThrottleCount,
     const uint64_t retryCount,
     const uint64_t latencyInMs,
-    const uint64_t delayInjectedInSecs) {
+    const uint64_t delayInjectedInSecs,
+    const uint64_t fullThrottleCount,
+    const uint64_t partialThrottleCount) {
   std::lock_guard<std::mutex> lock{operationStatsMutex_};
   operationStats_[operation].localThrottleCount += localThrottleCount;
   operationStats_[operation].resourceThrottleCount += resourceThrottleCount;
+  operationStats_[operation].networkThrottleCount += networkThrottleCount;
   operationStats_[operation].globalThrottleCount += globalThrottleCount;
   operationStats_[operation].retryCount += retryCount;
   operationStats_[operation].latencyInMs += latencyInMs;
   operationStats_[operation].requestCount++;
   operationStats_[operation].delayInjectedInSecs += delayInjectedInSecs;
+  operationStats_[operation].fullThrottleCount += fullThrottleCount;
+  operationStats_[operation].partialThrottleCount += partialThrottleCount;
 }
 
 std::unordered_map<std::string, OperationCounters>
@@ -114,22 +128,28 @@ void IoStatistics::merge(const IoStatistics& other) {
 void OperationCounters::merge(const OperationCounters& other) {
   resourceThrottleCount += other.resourceThrottleCount;
   localThrottleCount += other.localThrottleCount;
+  networkThrottleCount += other.networkThrottleCount;
   globalThrottleCount += other.globalThrottleCount;
   retryCount += other.retryCount;
   latencyInMs += other.latencyInMs;
   requestCount += other.requestCount;
   delayInjectedInSecs += other.delayInjectedInSecs;
+  fullThrottleCount += other.fullThrottleCount;
+  partialThrottleCount += other.partialThrottleCount;
 }
 
 folly::dynamic serialize(const OperationCounters& counters) {
   folly::dynamic json = folly::dynamic::object;
   json["latencyInMs"] = counters.latencyInMs;
   json["localThrottleCount"] = counters.localThrottleCount;
+  json["networkThrottleCount"] = counters.networkThrottleCount;
   json["resourceThrottleCount"] = counters.resourceThrottleCount;
   json["globalThrottleCount"] = counters.globalThrottleCount;
   json["retryCount"] = counters.retryCount;
   json["requestCount"] = counters.requestCount;
   json["delayInjectedInSecs"] = counters.delayInjectedInSecs;
+  json["fullThrottleCount"] = counters.fullThrottleCount;
+  json["partialThrottleCount"] = counters.partialThrottleCount;
   return json;
 }
 
diff --git a/velox/common/io/IoStatistics.h b/velox/common/io/IoStatistics.h
index e1d72afc9cfee..2111a8877b475 100644
--- a/velox/common/io/IoStatistics.h
+++ b/velox/common/io/IoStatistics.h
@@ -29,7 +29,10 @@ namespace facebook::velox::io {
 struct OperationCounters {
   uint64_t resourceThrottleCount{0};
   uint64_t localThrottleCount{0};
+  uint64_t networkThrottleCount{0};
   uint64_t globalThrottleCount{0};
+  uint64_t fullThrottleCount{0};
+  uint64_t partialThrottleCount{0};
   uint64_t retryCount{0};
   uint64_t latencyInMs{0};
   uint64_t requestCount{0};
@@ -48,19 +51,42 @@ class IoCounter {
     return sum_;
   }
 
+  uint64_t min() const {
+    return min_;
+  }
+
+  uint64_t max() const {
+    return max_;
+  }
+
   void increment(uint64_t amount) {
     ++count_;
     sum_ += amount;
+    casLoop(min_, amount, std::greater());
+    casLoop(max_, amount, std::less());
   }
 
   void merge(const IoCounter& other) {
     sum_ += other.sum_;
     count_ += other.count_;
+    casLoop(min_, other.min_, std::greater());
+    casLoop(max_, other.max_, std::less());
   }
 
  private:
+  template <typename Compare>
+  static void
+  casLoop(std::atomic<uint64_t>& value, uint64_t newValue, Compare compare) {
+    uint64_t old = value;
+    while (compare(old, newValue) &&
+           !value.compare_exchange_weak(old, newValue)) {
+    }
+  }
+
   std::atomic<uint64_t> count_{0};
   std::atomic<uint64_t> sum_{0};
+  std::atomic<uint64_t> min_{std::numeric_limits<uint64_t>::max()};
+  std::atomic<uint64_t> max_{0};
 };
 
 class IoStatistics {
@@ -71,6 +97,7 @@ class IoStatistics {
   uint64_t inputBatchSize() const;
   uint64_t outputBatchSize() const;
   uint64_t totalScanTime() const;
+  uint64_t writeIOTimeUs() const;
 
   uint64_t incRawBytesRead(int64_t);
   uint64_t incRawOverreadBytes(int64_t);
@@ -78,6 +105,7 @@ class IoStatistics {
   uint64_t incInputBatchSize(int64_t);
   uint64_t incOutputBatchSize(int64_t);
   uint64_t incTotalScanTime(int64_t);
+  uint64_t incWriteIOTimeUs(int64_t);
 
   IoCounter& prefetch() {
     return prefetch_;
@@ -103,10 +131,13 @@ class IoStatistics {
       const std::string& operation,
       const uint64_t resourceThrottleCount,
       const uint64_t localThrottleCount,
+      const uint64_t networkThrottleCount,
       const uint64_t globalThrottleCount,
       const uint64_t retryCount,
       const uint64_t latencyInMs,
-      const uint64_t delayInjectedInSecs);
+      const uint64_t delayInjectedInSecs,
+      const uint64_t fullThrottleCount = 0,
+      const uint64_t partialThrottleCount = 0);
 
   std::unordered_map<std::string, OperationCounters> operationStats() const;
 
@@ -121,6 +152,7 @@ class IoStatistics {
   std::atomic<uint64_t> outputBatchSize_{0};
   std::atomic<uint64_t> rawOverreadBytes_{0};
   std::atomic<uint64_t> totalScanTime_{0};
+  std::atomic<uint64_t> writeIOTimeUs_{0};
 
   // Planned read from storage or SSD.
   IoCounter prefetch_;
@@ -135,8 +167,8 @@ class IoStatistics {
   // reads.
   IoCounter ssdRead_;
 
-  // Time spent by a query processing thread waiting for synchronously
-  // issued IO or for an in-progress read-ahead to finish.
+  // Time spent by a query processing thread waiting for synchronously issued IO
+  // or for an in-progress read-ahead to finish.
   IoCounter queryThreadIoLatency_;
 
   std::unordered_map<std::string, OperationCounters> operationStats_;
diff --git a/velox/common/io/Options.h b/velox/common/io/Options.h
index d10709e99bd97..93f89fe292f36 100644
--- a/velox/common/io/Options.h
+++ b/velox/common/io/Options.h
@@ -57,15 +57,6 @@ enum class PrefetchMode {
 };
 
 class ReaderOptions {
- protected:
-  velox::memory::MemoryPool* memoryPool;
-  uint64_t autoPreloadLength;
-  PrefetchMode prefetchMode;
-  int32_t loadQuantum_{kDefaultLoadQuantum};
-  int32_t maxCoalesceDistance_{kDefaultCoalesceDistance};
-  int64_t maxCoalesceBytes_{kDefaultCoalesceBytes};
-  int32_t prefetchRowGroups_{kDefaultPrefetchRowGroups};
-
  public:
   static constexpr int32_t kDefaultLoadQuantum = 8 << 20; // 8MB
   static constexpr int32_t kDefaultCoalesceDistance = 512 << 10; // 512K
@@ -73,91 +64,63 @@ class ReaderOptions {
   static constexpr int32_t kDefaultPrefetchRowGroups = 1;
 
   explicit ReaderOptions(velox::memory::MemoryPool* pool)
-      : memoryPool(pool),
-        autoPreloadLength(DEFAULT_AUTO_PRELOAD_SIZE),
-        prefetchMode(PrefetchMode::PREFETCH) {}
-
-  ReaderOptions& operator=(const ReaderOptions& other) {
-    memoryPool = other.memoryPool;
-    autoPreloadLength = other.autoPreloadLength;
-    prefetchMode = other.prefetchMode;
-    maxCoalesceDistance_ = other.maxCoalesceDistance_;
-    maxCoalesceBytes_ = other.maxCoalesceBytes_;
-    prefetchRowGroups_ = other.prefetchRowGroups_;
-    return *this;
-  }
+      : memoryPool_(pool),
+        autoPreloadLength_(DEFAULT_AUTO_PRELOAD_SIZE),
+        prefetchMode_(PrefetchMode::PREFETCH) {}
 
-  ReaderOptions(const ReaderOptions& other) {
-    *this = other;
-  }
-
-  /**
-   * Set the memory allocator.
-   */
+  /// Sets the memory pool for allocation.
   ReaderOptions& setMemoryPool(velox::memory::MemoryPool& pool) {
-    memoryPool = &pool;
+    memoryPool_ = &pool;
     return *this;
   }
 
-  /**
-   * Modify the autoPreloadLength
-   */
+  /// Modifies the autoPreloadLength
   ReaderOptions& setAutoPreloadLength(uint64_t len) {
-    autoPreloadLength = len;
+    autoPreloadLength_ = len;
     return *this;
   }
 
-  /**
-   * Modify the prefetch mode.
-   */
+  /// Modifies the prefetch mode.
   ReaderOptions& setPrefetchMode(PrefetchMode mode) {
-    prefetchMode = mode;
+    prefetchMode_ = mode;
     return *this;
   }
 
-  /**
-   * Modify the load quantum.
-   */
+  /// Modifies the load quantum.
   ReaderOptions& setLoadQuantum(int32_t quantum) {
     loadQuantum_ = quantum;
     return *this;
   }
-  /**
-   * Modify the maximum load coalesce distance.
-   */
+
+  /// Modifies the maximum load coalesce distance.
   ReaderOptions& setMaxCoalesceDistance(int32_t distance) {
     maxCoalesceDistance_ = distance;
     return *this;
   }
-  /**
-   * Modify the maximum load coalesce bytes.
-   */
+
+  /// Modifies the maximum load coalesce bytes.
   ReaderOptions& setMaxCoalesceBytes(int64_t bytes) {
     maxCoalesceBytes_ = bytes;
     return *this;
   }
 
-  /**
-   * Modify the number of row groups to prefetch.
-   */
+  /// Modifies the number of row groups to prefetch.
   ReaderOptions& setPrefetchRowGroups(int32_t numPrefetch) {
     prefetchRowGroups_ = numPrefetch;
     return *this;
   }
 
-  /**
-   * Get the memory allocator.
-   */
-  velox::memory::MemoryPool& getMemoryPool() const {
-    return *memoryPool;
+  /// Gets the memory allocator.
+  velox::memory::MemoryPool& memoryPool() const {
+    return *memoryPool_;
   }
 
-  uint64_t getAutoPreloadLength() const {
-    return autoPreloadLength;
+  uint64_t autoPreloadLength() const {
+    return autoPreloadLength_;
   }
 
-  PrefetchMode getPrefetchMode() const {
-    return prefetchMode;
+  PrefetchMode prefetchMode() const {
+    return prefetchMode_;
   }
 
   int32_t loadQuantum() const {
@@ -175,5 +138,23 @@ class ReaderOptions {
   int64_t prefetchRowGroups() const {
     return prefetchRowGroups_;
   }
+
+  bool noCacheRetention() const {
+    return noCacheRetention_;
+  }
+
+  void setNoCacheRetention(bool noCacheRetention) {
+    noCacheRetention_ = noCacheRetention;
+  }
+
+ protected:
+  velox::memory::MemoryPool* memoryPool_;
+  uint64_t autoPreloadLength_;
+  PrefetchMode prefetchMode_;
+  int32_t loadQuantum_{kDefaultLoadQuantum};
+  int32_t maxCoalesceDistance_{kDefaultCoalesceDistance};
+  int64_t maxCoalesceBytes_{kDefaultCoalesceBytes};
+  int32_t prefetchRowGroups_{kDefaultPrefetchRowGroups};
+  bool noCacheRetention_{false};
 };
 } // namespace facebook::velox::io
diff --git a/velox/common/memory/Allocation.cpp b/velox/common/memory/Allocation.cpp
index f24ef76a359b9..884af7c82cf5d 100644
--- a/velox/common/memory/Allocation.cpp
+++ b/velox/common/memory/Allocation.cpp
@@ -30,13 +30,20 @@ Allocation::~Allocation() {
   }
 }
 
-void Allocation::append(uint8_t* address, int32_t numPages) {
-  numPages_ += numPages;
+void Allocation::append(uint8_t* address, MachinePageCount numPages) {
   VELOX_CHECK(
       runs_.empty() || address != runs_.back().data(),
       "Appending a duplicate address into a PageRun");
+  if (FOLLY_UNLIKELY(numPages > Allocation::PageRun::kMaxPagesInRun)) {
+    VELOX_MEM_ALLOC_ERROR(fmt::format(
+        "The number of pages to append {} exceeds the PageRun limit {}",
+        numPages,
+        Allocation::PageRun::kMaxPagesInRun));
+  }
+  numPages_ += numPages;
   runs_.emplace_back(address, numPages);
 }
+
 void Allocation::appendMove(Allocation& other) {
   for (auto& run : other.runs_) {
     numPages_ += run.numPages();
@@ -50,7 +57,7 @@ void Allocation::findRun(uint64_t offset, int32_t* index, int32_t* offsetInRun)
     const {
   uint64_t skipped = 0;
   for (int32_t i = 0; i < runs_.size(); ++i) {
-    uint64_t size = runs_[i].numPages() * AllocationTraits::kPageSize;
+    uint64_t size = AllocationTraits::pageBytes(runs_[i].numPages());
     if (offset - skipped < size) {
       *index = i;
       *offsetInRun = static_cast<int32_t>(offset - skipped);
diff --git a/velox/common/memory/Allocation.h b/velox/common/memory/Allocation.h
index 6378378ab0a59..250db476d7866 100644
--- a/velox/common/memory/Allocation.h
+++ b/velox/common/memory/Allocation.h
@@ -37,6 +37,9 @@ struct AllocationTraits {
   /// Size of huge page as intended with MADV_HUGEPAGE.
   static constexpr uint64_t kHugePageSize = 2 << 20; // 2MB
 
+  static_assert(kHugePageSize >= kPageSize);
+  static_assert(kHugePageSize % kPageSize == 0);
+
   /// Returns the bytes of the given number pages.
   FOLLY_ALWAYS_INLINE static uint64_t pageBytes(MachinePageCount numPages) {
     return numPages * kPageSize;
@@ -47,14 +50,12 @@ struct AllocationTraits {
   }
 
   /// Returns the round up page bytes.
-  FOLLY_ALWAYS_INLINE static MachinePageCount roundUpPageBytes(uint64_t bytes) {
+  FOLLY_ALWAYS_INLINE static uint64_t roundUpPageBytes(uint64_t bytes) {
     return bits::roundUp(bytes, kPageSize);
   }
 
   /// The number of pages in a huge page.
-  FOLLY_ALWAYS_INLINE static MachinePageCount numPagesInHugePage() {
-    VELOX_DCHECK_GE(kHugePageSize, kPageSize);
-    VELOX_DCHECK_EQ(kHugePageSize % kPageSize, 0);
+  static constexpr MachinePageCount numPagesInHugePage() {
     return kHugePageSize / kPageSize;
   }
 };
@@ -171,7 +172,7 @@ class Allocation {
     VELOX_CHECK(numPages_ != 0 || pool_ == nullptr);
   }
 
-  void append(uint8_t* address, int32_t numPages);
+  void append(uint8_t* address, MachinePageCount numPages);
 
   void clear() {
     runs_.clear();
@@ -193,6 +194,7 @@ class Allocation {
   VELOX_FRIEND_TEST(MemoryAllocatorTest, allocationClass2);
   VELOX_FRIEND_TEST(AllocationTest, append);
   VELOX_FRIEND_TEST(AllocationTest, appendMove);
+  VELOX_FRIEND_TEST(AllocationTest, maxPageRunLimit);
 };
 
 /// Represents a run of contiguous pages that do not belong to any size class.
@@ -248,6 +250,7 @@ class ContiguousAllocation {
     VELOX_CHECK_NULL(pool_);
     pool_ = pool;
   }
+
   MemoryPool* pool() const {
     return pool_;
   }
@@ -263,7 +266,7 @@ class ContiguousAllocation {
 
   // Adjusts 'size' towards 'maxSize' by 'increment' pages. Rounds
   // 'increment' to huge pages, since this is the unit of growth of
-  // RSS for large contiguous runs.  Increases the reservation in in
+  // RSS for large contiguous runs.  Increases the reservation in
   // 'pool_' and its allocator. May fail by cap exceeded. If failing,
   // the size is not changed. 'size_' cannot exceed 'maxSize_'.
   void grow(MachinePageCount increment);
diff --git a/velox/common/memory/AllocationPool.cpp b/velox/common/memory/AllocationPool.cpp
index dcb709aacb916..f3f0c50f0221b 100644
--- a/velox/common/memory/AllocationPool.cpp
+++ b/velox/common/memory/AllocationPool.cpp
@@ -52,10 +52,7 @@ char* AllocationPool::allocateFixed(uint64_t bytes, int32_t alignment) {
   VELOX_CHECK_GT(bytes, 0, "Cannot allocate zero bytes");
   if (freeAddressableBytes() >= bytes && alignment == 1) {
     auto* result = startOfRun_ + currentOffset_;
-    currentOffset_ += bytes;
-    if (currentOffset_ > endOfReservedRun()) {
-      growLastAllocation();
-    }
+    maybeGrowLastAllocation(bytes);
     return result;
   }
   VELOX_CHECK_EQ(
@@ -75,19 +72,21 @@ char* AllocationPool::allocateFixed(uint64_t bytes, int32_t alignment) {
   VELOX_CHECK_LE(bytes + currentOffset_, bytesInRun_);
   auto* result = startOfRun_ + currentOffset_;
   VELOX_CHECK_EQ(reinterpret_cast<uintptr_t>(result) % alignment, 0);
-  currentOffset_ += bytes;
-  if (currentOffset_ > endOfReservedRun()) {
-    growLastAllocation();
-  }
+  maybeGrowLastAllocation(bytes);
   return result;
 }
 
-void AllocationPool::growLastAllocation() {
-  VELOX_CHECK_GT(bytesInRun_, AllocationTraits::kHugePageSize);
-  const auto bytesToReserve = bits::roundUp(
-      currentOffset_ - endOfReservedRun(), AllocationTraits::kHugePageSize);
-  largeAllocations_.back().grow(AllocationTraits::numPages(bytesToReserve));
-  usedBytes_ += bytesToReserve;
+void AllocationPool::maybeGrowLastAllocation(uint64_t bytesRequested) {
+  const auto updateOffset = currentOffset_ + bytesRequested;
+  if (updateOffset > endOfReservedRun()) {
+    VELOX_CHECK_GT(bytesInRun_, AllocationTraits::kHugePageSize);
+    const auto bytesToReserve = bits::roundUp(
+        updateOffset - endOfReservedRun(), AllocationTraits::kHugePageSize);
+    largeAllocations_.back().grow(AllocationTraits::numPages(bytesToReserve));
+    usedBytes_ += bytesToReserve;
+  }
+  // Only update currentOffset_ once it points to valid data.
+  currentOffset_ = updateOffset;
 }
 
 void AllocationPool::newRunImpl(MachinePageCount numPages) {
diff --git a/velox/common/memory/AllocationPool.h b/velox/common/memory/AllocationPool.h
index 7a5bfd960642a..1449be6b9af9c 100644
--- a/velox/common/memory/AllocationPool.h
+++ b/velox/common/memory/AllocationPool.h
@@ -18,13 +18,12 @@
 #include "velox/common/memory/Memory.h"
 
 namespace facebook::velox::memory {
-// A set of Allocations holding the fixed width payload
-// rows. The Runs are filled to the end except for the last one. This
-// is used for iterating over the payload for rehashing, returning
-// results etc. This is used via HashStringAllocator for variable length
-// allocation for backing ByteStreams for complex objects. In that case, there
-// is a current run that is appended to and when this is exhausted a new run is
-// started.
+/// A set of Allocations holding the fixed width payload ows. The Runs are
+/// filled to the end except for the last one. This is used for iterating over
+/// the payload for rehashing, returning results etc. This is used via
+/// HashStringAllocator for variable length allocation for backing ByteStreams
+/// for complex objects. In that case, there is a current run that is appended
+/// to and when this is exhausted a new run is started.
 class AllocationPool {
  public:
   static constexpr int32_t kMinPages = 16;
@@ -90,7 +89,7 @@ class AllocationPool {
     return pool_;
   }
 
-  /// Returns true if 'ptr' is inside the range alocations are made from.
+  /// Returns true if 'ptr' is inside the range allocations are made from.
   bool isInCurrentRange(void* ptr) const {
     return reinterpret_cast<char*>(ptr) >= startOfRun_ &&
         reinterpret_cast<char*>(ptr) < startOfRun_ + bytesInRun_;
@@ -131,9 +130,10 @@ class AllocationPool {
     return bytesInRun_ - currentOffset_;
   }
 
-  // Increses the reservation in 'pool_' when 'currentOffset_' goes past
-  // current end of last large allocation.
-  void growLastAllocation();
+  // Increases the reservation in 'pool_' if 'bytesRequested' moves
+  // 'currentOffset_' goes past current end of last large allocation, otherwise
+  // simply updates 'currentOffset_'.
+  void maybeGrowLastAllocation(uint64_t bytesRequested);
 
   void newRunImpl(memory::MachinePageCount numPages);
 
@@ -141,7 +141,7 @@ class AllocationPool {
   std::vector<memory::Allocation> allocations_;
   std::vector<memory::ContiguousAllocation> largeAllocations_;
 
-  // Points to the start of the run from which allocations are being nade.
+  // Points to the start of the run from which allocations are being made.
   char* startOfRun_{nullptr};
 
   // Total addressable bytes from 'startOfRun_'. Not all are necessarily
diff --git a/velox/common/memory/ByteStream.cpp b/velox/common/memory/ByteStream.cpp
index d4e456f92e146..e7802f477823a 100644
--- a/velox/common/memory/ByteStream.cpp
+++ b/velox/common/memory/ByteStream.cpp
@@ -18,119 +18,174 @@
 
 namespace facebook::velox {
 
+uint32_t ByteRange::availableBytes() const {
+  return std::max(0, size - position);
+}
+
 std::string ByteRange::toString() const {
   return fmt::format("[{} starting at {}]", succinctBytes(size), position);
 }
 
-size_t ByteStream::size() const {
-  if (ranges_.empty()) {
-    return 0;
+std::string BufferInputStream::toString() const {
+  std::stringstream oss;
+  oss << ranges_.size() << " ranges (position/size) [";
+  for (const auto& range : ranges_) {
+    oss << "(" << range.position << "/" << range.size
+        << (&range == current_ ? " current" : "") << ")";
+    if (&range != &ranges_.back()) {
+      oss << ",";
+    }
+  }
+  oss << "]";
+  return oss.str();
+}
+
+bool BufferInputStream::atEnd() const {
+  if (current_ == nullptr) {
+    return false;
   }
+  if (current_->position < current_->size) {
+    return false;
+  }
+
+  VELOX_CHECK(current_ >= ranges_.data() && current_ <= &ranges_.back());
+  return current_ == &ranges_.back();
+}
+
+size_t BufferInputStream::size() const {
   size_t total = 0;
-  for (auto i = 0; i < ranges_.size() - 1; ++i) {
-    total += ranges_[i].size;
+  for (const auto& range : ranges_) {
+    total += range.size;
   }
-  return total + std::max(ranges_.back().position, lastRangeEnd_);
+  return total;
 }
 
-size_t ByteStream::remainingSize() const {
+size_t BufferInputStream::remainingSize() const {
   if (ranges_.empty()) {
     return 0;
   }
-  const auto* lastRange = &ranges_[ranges_.size() - 1];
-  auto cur = current_;
-  size_t total{0};
-  if (cur == lastRange) {
-    total += (std::max(cur->position, lastRangeEnd_) - cur->position);
-  } else {
-    total += cur->size - cur->position;
-  }
-
+  const auto* lastRange = &ranges_.back();
+  auto* cur = current_;
+  size_t remainingBytes = cur->availableBytes();
   while (++cur <= lastRange) {
-    total += (cur == lastRange) ? lastRangeEnd_ : cur->size;
+    remainingBytes += cur->size;
   }
-  return total;
+  return remainingBytes;
 }
 
-bool ByteStream::atEnd() const {
-  if (!current_) {
-    return false;
+std::streampos BufferInputStream::tellp() const {
+  if (ranges_.empty()) {
+    return 0;
   }
-  if (current_->position < current_->size) {
-    return false;
+  assert(current_);
+  int64_t size = 0;
+  for (auto& range : ranges_) {
+    if (&range == current_) {
+      return current_->position + size;
+    }
+    size += range.size;
   }
-
-  VELOX_CHECK(current_ >= ranges_.data() && current_ <= &ranges_.back());
-  return current_ == &ranges_.back();
+  VELOX_FAIL("BufferInputStream 'current_' is not in 'ranges_'.");
 }
 
-void ByteStream::next(bool throwIfPastEnd) {
-  VELOX_CHECK(current_ >= &ranges_[0]);
-  size_t position = current_ - &ranges_[0];
-  VELOX_CHECK_LT(position, ranges_.size());
-  if (position == ranges_.size() - 1) {
-    if (throwIfPastEnd) {
-      VELOX_FAIL("Reading past end of ByteStream");
-    }
+void BufferInputStream::seekp(std::streampos position) {
+  if (ranges_.empty() && position == 0) {
     return;
   }
+  int64_t toSkip = position;
+  for (auto& range : ranges_) {
+    if (toSkip <= range.size) {
+      current_ = &range;
+      current_->position = toSkip;
+      return;
+    }
+    toSkip -= range.size;
+  }
+  static_assert(sizeof(std::streamsize) <= sizeof(long long));
+  VELOX_FAIL(
+      "Seeking past end of BufferInputStream: {}",
+      static_cast<long long>(position));
+}
+
+void BufferInputStream::nextRange() {
+  VELOX_CHECK(current_ >= &ranges_[0]);
+  const size_t rangeIndex = current_ - &ranges_[0];
+  VELOX_CHECK_LT(
+      rangeIndex + 1, ranges_.size(), "Reading past end of BufferInputStream");
   ++current_;
   current_->position = 0;
 }
 
-uint8_t ByteStream::readByte() {
+uint8_t BufferInputStream::readByte() {
   if (current_->position < current_->size) {
     return current_->buffer[current_->position++];
   }
-  next();
+  nextRange();
   return readByte();
 }
 
-void ByteStream::readBytes(uint8_t* bytes, int32_t size) {
+void BufferInputStream::readBytes(uint8_t* bytes, int32_t size) {
+  VELOX_CHECK_GE(size, 0, "Attempting to read negative number of bytes");
   int32_t offset = 0;
   for (;;) {
-    int32_t available = current_->size - current_->position;
-    int32_t numUsed = std::min(available, size);
-    memcpy(bytes + offset, current_->buffer + current_->position, numUsed);
-    offset += numUsed;
-    size -= numUsed;
-    current_->position += numUsed;
-    if (!size) {
+    const int32_t availableBytes = current_->size - current_->position;
+    const int32_t readBytes = std::min(availableBytes, size);
+    simd::memcpy(
+        bytes + offset, current_->buffer + current_->position, readBytes);
+    offset += readBytes;
+    size -= readBytes;
+    current_->position += readBytes;
+    if (size == 0) {
       return;
     }
-    next();
+    nextRange();
   }
 }
 
-std::string_view ByteStream::nextView(int32_t size) {
+std::string_view BufferInputStream::nextView(int32_t size) {
+  VELOX_CHECK_GE(size, 0, "Attempting to view negative number of bytes");
   if (current_->position == current_->size) {
     if (current_ == &ranges_.back()) {
       return std::string_view(nullptr, 0);
     }
-    next();
+    nextRange();
   }
-  VELOX_CHECK(current_->size);
-  auto position = current_->position;
-  auto viewSize = std::min(current_->size - current_->position, size);
+  VELOX_CHECK_GT(current_->size, 0);
+  const auto position = current_->position;
+  const auto viewSize = std::min(current_->size - current_->position, size);
   current_->position += viewSize;
   return std::string_view(
       reinterpret_cast<char*>(current_->buffer) + position, viewSize);
 }
 
-void ByteStream::skip(int32_t size) {
+void BufferInputStream::skip(int32_t size) {
+  VELOX_CHECK_GE(size, 0, "Attempting to skip negative number of bytes");
   for (;;) {
-    int32_t available = current_->size - current_->position;
-    int32_t numUsed = std::min(available, size);
-    size -= numUsed;
-    current_->position += numUsed;
-    if (!size) {
+    const int32_t numSkipped =
+        std::min<int32_t>(current_->availableBytes(), size);
+    size -= numSkipped;
+    current_->position += numSkipped;
+    if (size == 0) {
       return;
     }
-    next();
+    nextRange();
+  }
+}
+
+size_t ByteOutputStream::size() const {
+  if (ranges_.empty()) {
+    return 0;
   }
+  size_t total = 0;
+  for (auto i = 0; i < ranges_.size() - 1; ++i) {
+    total += ranges_[i].size;
+  }
+  return total + std::max(ranges_.back().position, lastRangeEnd_);
 }
 
-void ByteStream::appendBool(bool value, int32_t count) {
+void ByteOutputStream::appendBool(bool value, int32_t count) {
+  VELOX_DCHECK(isBits_);
+
   if (count == 1 && current_->size > current_->position) {
     bits::setBit(
         reinterpret_cast<uint64_t*>(current_->buffer),
@@ -139,10 +194,10 @@ void ByteStream::appendBool(bool value, int32_t count) {
     ++current_->position;
     return;
   }
-  int32_t offset = 0;
-  VELOX_DCHECK(isBits_);
+
+  int32_t offset{0};
   for (;;) {
-    int32_t bitsFit =
+    const int32_t bitsFit =
         std::min(count - offset, current_->size - current_->position);
     bits::fillBits(
         reinterpret_cast<uint64_t*>(current_->buffer),
@@ -158,13 +213,44 @@ void ByteStream::appendBool(bool value, int32_t count) {
   }
 }
 
-void ByteStream::appendStringPiece(folly::StringPiece value) {
+void ByteOutputStream::appendBits(
+    const uint64_t* bits,
+    int32_t begin,
+    int32_t end) {
+  VELOX_DCHECK(isBits_);
+
+  const int32_t count = end - begin;
+  int32_t offset = 0;
+  for (;;) {
+    const int32_t bitsFit =
+        std::min(count - offset, current_->size - current_->position);
+    bits::copyBits(
+        bits,
+        begin + offset,
+        reinterpret_cast<uint64_t*>(current_->buffer),
+        current_->position,
+        bitsFit);
+
+    current_->position += bitsFit;
+    offset += bitsFit;
+    if (offset == count) {
+      return;
+    }
+    extend(bits::nbytes(count - offset));
+  }
+}
+
+void ByteOutputStream::appendStringView(StringView value) {
+  appendStringView((std::string_view)value);
+}
+
+void ByteOutputStream::appendStringView(std::string_view value) {
   const int32_t bytes = value.size();
   int32_t offset = 0;
   for (;;) {
     const int32_t bytesFit =
         std::min(bytes - offset, current_->size - current_->position);
-    ::memcpy(
+    simd::memcpy(
         current_->buffer + current_->position, value.data() + offset, bytesFit);
     current_->position += bytesFit;
     offset += bytesFit;
@@ -175,7 +261,7 @@ void ByteStream::appendStringPiece(folly::StringPiece value) {
   }
 }
 
-std::streampos ByteStream::tellp() const {
+std::streampos ByteOutputStream::tellp() const {
   if (ranges_.empty()) {
     return 0;
   }
@@ -187,10 +273,10 @@ std::streampos ByteStream::tellp() const {
     }
     size += range.size;
   }
-  VELOX_FAIL("ByteStream 'current_' is not in 'ranges_'.");
+  VELOX_FAIL("ByteOutputStream 'current_' is not in 'ranges_'.");
 }
 
-void ByteStream::seekp(std::streampos position) {
+void ByteOutputStream::seekp(std::streampos position) {
   int64_t toSkip = position;
   // Record how much was written pre-seek.
   updateEnd();
@@ -205,10 +291,13 @@ void ByteStream::seekp(std::streampos position) {
     }
     toSkip -= range.size;
   }
-  VELOX_FAIL("Seeking past end of ByteStream: {}", position);
+  static_assert(sizeof(std::streamsize) <= sizeof(long long));
+  VELOX_FAIL(
+      "Seeking past end of ByteOutputStream: {}",
+      static_cast<long long>(position));
 }
 
-void ByteStream::flush(OutputStream* out) {
+void ByteOutputStream::flush(OutputStream* out) {
   updateEnd();
   for (int32_t i = 0; i < ranges_.size(); ++i) {
     int32_t count = i == ranges_.size() - 1 ? lastRangeEnd_ : ranges_[i].size;
@@ -223,17 +312,17 @@ void ByteStream::flush(OutputStream* out) {
   }
 }
 
-char* ByteStream::writePosition() {
+char* ByteOutputStream::writePosition() {
   if (ranges_.empty()) {
     return nullptr;
   }
   return reinterpret_cast<char*>(current_->buffer) + current_->position;
 }
 
-void ByteStream::extend(int32_t bytes) {
+void ByteOutputStream::extend(int32_t bytes) {
   if (current_ && current_->position != current_->size) {
-    LOG(FATAL) << "Extend ByteStream before range full: " << current_->position
-               << " vs. " << current_->size;
+    LOG(FATAL) << "Extend ByteOutputStream before range full: "
+               << current_->position << " vs. " << current_->size;
   }
 
   // Check if rewriting existing content. If so, move to next range and start at
@@ -243,10 +332,14 @@ void ByteStream::extend(int32_t bytes) {
     current_->position = 0;
     return;
   }
+
   ranges_.emplace_back();
   current_ = &ranges_.back();
   lastRangeEnd_ = 0;
-  arena_->newRange(newRangeSize(bytes), current_);
+  arena_->newRange(
+      newRangeSize(bytes),
+      ranges_.size() == 1 ? nullptr : &ranges_[ranges_.size() - 2],
+      current_);
   allocatedBytes_ += current_->size;
   VELOX_CHECK_GT(allocatedBytes_, 0);
   if (isBits_) {
@@ -255,7 +348,7 @@ void ByteStream::extend(int32_t bytes) {
   }
 }
 
-int32_t ByteStream::newRangeSize(int32_t bytes) const {
+int32_t ByteOutputStream::newRangeSize(int32_t bytes) const {
   const int32_t newSize = allocatedBytes_ + bytes;
   if (newSize < 128) {
     return 128;
@@ -269,10 +362,33 @@ int32_t ByteStream::newRangeSize(int32_t bytes) const {
   return bits::roundUp(bytes, memory::AllocationTraits::kPageSize);
 }
 
-std::string ByteStream::toString() const {
+void ByteOutputStream::ensureSpace(int32_t bytes) {
+  const auto available = current_->size - current_->position;
+  int64_t toExtend = bytes - available;
+  const auto originalRangeIdx = current_ - ranges_.data();
+  const auto originalPosition = current_->position;
+  while (toExtend > 0) {
+    current_->position = current_->size;
+    extend(toExtend);
+    toExtend -= current_->size;
+  }
+  // Restore original position.
+  current_ = &ranges_[originalRangeIdx];
+  current_->position = originalPosition;
+}
+
+std::unique_ptr<ByteInputStream> ByteOutputStream::inputStream() const {
+  VELOX_CHECK(!ranges_.empty());
+  updateEnd();
+  auto rangeCopy = ranges_;
+  rangeCopy.back().size = lastRangeEnd_;
+  return std::make_unique<BufferInputStream>(std::move(rangeCopy));
+}
+
+std::string ByteOutputStream::toString() const {
   std::stringstream oss;
-  oss << "ByteStream[lastRangeEnd " << lastRangeEnd_ << ", " << ranges_.size()
-      << " ranges (position/size) [";
+  oss << "ByteOutputStream[lastRangeEnd " << lastRangeEnd_ << ", "
+      << ranges_.size() << " ranges (position/size) [";
   for (const auto& range : ranges_) {
     oss << "(" << range.position << "/" << range.size
         << (&range == current_ ? " current" : "") << ")";
diff --git a/velox/common/memory/ByteStream.h b/velox/common/memory/ByteStream.h
index d47e7c74d8a13..040aa23bccb0e 100644
--- a/velox/common/memory/ByteStream.h
+++ b/velox/common/memory/ByteStream.h
@@ -15,10 +15,13 @@
  */
 #pragma once
 
+#include <folly/io/IOBuf.h>
+#include "velox/common/base/Scratch.h"
 #include "velox/common/memory/StreamArena.h"
 #include "velox/type/Type.h"
 
 #include <folly/io/IOBuf.h>
+#include <memory>
 
 namespace facebook::velox {
 
@@ -32,6 +35,9 @@ struct ByteRange {
   /// Index of next byte/bit to be read/written in 'buffer'.
   int32_t position;
 
+  /// Returns the available bytes left in this range.
+  uint32_t availableBytes() const;
+
   std::string toString() const;
 };
 
@@ -88,47 +94,175 @@ class OStreamOutputStream : public OutputStream {
   std::ostream* out_;
 };
 
+/// Read-only byte input stream interface.
+class ByteInputStream {
+ public:
+  virtual ~ByteInputStream() = default;
+
+  /// Returns total number of bytes available in the stream.
+  virtual size_t size() const = 0;
+
+  /// Returns true if all input has been read.
+  virtual bool atEnd() const = 0;
+
+  /// Returns current position (number of bytes from the start) in the stream.
+  virtual std::streampos tellp() const = 0;
+
+  /// Moves current position to specified one.
+  virtual void seekp(std::streampos pos) = 0;
+
+  /// Returns the remaining size left from current reading position.
+  virtual size_t remainingSize() const = 0;
+
+  virtual uint8_t readByte() = 0;
+
+  virtual void readBytes(uint8_t* bytes, int32_t size) = 0;
+
+  template <typename T>
+  T read() {
+    if (current_->position + sizeof(T) <= current_->size) {
+      current_->position += sizeof(T);
+      return *reinterpret_cast<const T*>(
+          current_->buffer + current_->position - sizeof(T));
+    }
+    // The number straddles two buffers. We read byte by byte and make a
+    // little-endian uint64_t. The bytes can be cast to any integer or floating
+    // point type since the wire format has the machine byte order.
+    static_assert(sizeof(T) <= sizeof(uint64_t));
+    uint64_t value = 0;
+    for (int32_t i = 0; i < sizeof(T); ++i) {
+      value |= static_cast<uint64_t>(readByte()) << (i * 8);
+    }
+    return *reinterpret_cast<const T*>(&value);
+  }
+
+  template <typename Char>
+  void readBytes(Char* data, int32_t size) {
+    readBytes(reinterpret_cast<uint8_t*>(data), size);
+  }
+
+  /// Returns a view over the read buffer for up to 'size' next bytes. The size
+  /// of the value may be less if the current byte range ends within 'size'
+  /// bytes from the current position.  The size will be 0 if at end.
+  virtual std::string_view nextView(int32_t size) = 0;
+
+  virtual void skip(int32_t size) = 0;
+
+  virtual std::string toString() const = 0;
+
+ protected:
+  // Points to the current buffered byte range.
+  ByteRange* current_{nullptr};
+  std::vector<ByteRange> ranges_;
+};
+
+/// Read-only input stream backed by a set of buffers.
+class BufferInputStream : public ByteInputStream {
+ public:
+  explicit BufferInputStream(std::vector<ByteRange> ranges) {
+    VELOX_CHECK(!ranges.empty(), "Empty BufferInputStream");
+    ranges_ = std::move(ranges);
+    current_ = &ranges_[0];
+  }
+
+  BufferInputStream(const BufferInputStream&) = delete;
+  BufferInputStream& operator=(const BufferInputStream& other) = delete;
+  BufferInputStream(BufferInputStream&& other) noexcept = delete;
+  BufferInputStream& operator=(BufferInputStream&& other) noexcept = delete;
+
+  size_t size() const override;
+
+  bool atEnd() const override;
+
+  std::streampos tellp() const override;
+
+  void seekp(std::streampos pos) override;
+
+  size_t remainingSize() const override;
+
+  uint8_t readByte() override;
+
+  void readBytes(uint8_t* bytes, int32_t size) override;
+
+  std::string_view nextView(int32_t size) override;
+
+  void skip(int32_t size) override;
+
+  std::string toString() const override;
+
+ private:
+  // Sets 'current_' to the next range of input. The input is consecutive
+  // ByteRanges in 'ranges_' for the base class but any view over external
+  // buffers can be made by specialization.
+  void nextRange();
+
+  const std::vector<ByteRange>& ranges() const {
+    return ranges_;
+  }
+};
+
+template <>
+inline Timestamp ByteInputStream::read<Timestamp>() {
+  Timestamp value;
+  readBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
+  return value;
+}
+
+template <>
+inline int128_t ByteInputStream::read<int128_t>() {
+  int128_t value;
+  readBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
+  return value;
+}
+
 /// Stream over a chain of ByteRanges. Provides read, write and
 /// comparison for equality between stream contents and memory. Used
 /// for streams in repartitioning or for complex variable length data
 /// in hash tables. The stream is seekable and supports overwriting of
 /// previous content, for example, writing a message body and then
 /// seeking back to start to write a length header.
-class ByteStream {
+class ByteOutputStream {
  public:
-  /// For input.
-  ByteStream() : isBits_(false), isReverseBitOrder_(false) {}
-  virtual ~ByteStream() = default;
-
   /// For output.
-  ByteStream(
+  ByteOutputStream(
       StreamArena* arena,
       bool isBits = false,
       bool isReverseBitOrder = false)
       : arena_(arena), isBits_(isBits), isReverseBitOrder_(isReverseBitOrder) {}
 
-  ByteStream(const ByteStream& other) = delete;
+  ByteOutputStream(const ByteOutputStream& other) = delete;
 
-  void operator=(const ByteStream& other) = delete;
+  void operator=(const ByteOutputStream& other) = delete;
 
-  void resetInput(std::vector<ByteRange>&& ranges) {
-    ranges_ = std::move(ranges);
-    current_ = &ranges_[0];
-    lastRangeEnd_ = ranges_.back().size;
-  }
+  // Forcing a move constructor to be able to return ByteOutputStream objects
+  // from a function.
+  ByteOutputStream(ByteOutputStream&&) = default;
 
-  void setRange(ByteRange range) {
+  /// Sets 'this' to range over 'range'. If this is for purposes of writing,
+  /// lastWrittenPosition specifies the end of any pre-existing content in
+  /// 'range'.
+  void setRange(ByteRange range, int32_t lastWrittenPosition) {
     ranges_.resize(1);
     ranges_[0] = range;
     current_ = ranges_.data();
-    lastRangeEnd_ = ranges_[0].size;
+    VELOX_CHECK_GE(ranges_.back().size, lastWrittenPosition);
+    lastRangeEnd_ = lastWrittenPosition;
   }
 
   const std::vector<ByteRange>& ranges() const {
     return ranges_;
   }
 
+  /// Prepares 'this' for writing. Can be called several times,
+  /// e.g. PrestoSerializer resets these. The memory formerly backing
+  /// 'ranges_' is not owned and the caller needs to recycle or free
+  /// this independently.
   void startWrite(int32_t initialSize) {
+    ranges_.clear();
+    isReversed_ = false;
+    allocatedBytes_ = 0;
+    current_ = nullptr;
+    lastRangeEnd_ = 0;
     extend(initialSize);
   }
 
@@ -141,73 +275,27 @@ class ByteStream {
 
   void seekp(std::streampos position);
 
-  /// Returns the size written into ranges_. This is the sum of the
-  /// capacities of non-last ranges + the greatest write position of
-  /// the last range.
+  /// Returns the size written into ranges_. This is the sum of the capacities
+  /// of non-last ranges + the greatest write position of the last range.
   size_t size() const;
 
-  /// Returns the remaining size left from current reading position.
-  size_t remainingSize() const;
-
-  /// For input. Returns true if all input has been read.
-  bool atEnd() const;
-
-  int32_t lastRangeEnd() {
+  int32_t lastRangeEnd() const {
     updateEnd();
     return lastRangeEnd_;
   }
 
-  /// Sets 'current_' to point to the next range of input.  // The
-  /// input is consecutive ByteRanges in 'ranges_' for the base class
-  /// but any view over external buffers can be made by specialization.
-  virtual void next(bool throwIfPastEnd = true);
-
-  uint8_t readByte();
-
-  void readBytes(uint8_t* bytes, int32_t size);
-
-  template <typename T>
-  T read() {
-    if (current_->position + sizeof(T) <= current_->size) {
-      current_->position += sizeof(T);
-      return *reinterpret_cast<const T*>(
-          current_->buffer + current_->position - sizeof(T));
-    }
-    // The number straddles two buffers. We read byte by byte and make
-    // a little-endian uint64_t. The bytes can be cast to any integer
-    // or floating point type since the wire format has the machine byte order.
-    static_assert(sizeof(T) <= sizeof(uint64_t));
-    uint64_t value = 0;
-    for (int32_t i = 0; i < sizeof(T); ++i) {
-      value |= static_cast<uint64_t>(readByte()) << (i * 8);
-    }
-    return *reinterpret_cast<const T*>(&value);
-  }
-
-  template <typename Char>
-  void readBytes(Char* data, int32_t size) {
-    readBytes(reinterpret_cast<uint8_t*>(data), size);
-  }
-
-  /// Returns a view over the read buffer for up to 'size' next
-  /// bytes. The size of the value may be less if the current byte
-  /// range ends within 'size' bytes from the current position.  The
-  /// size will be 0 if at end.
-  std::string_view nextView(int32_t size);
-
-  void skip(int32_t size);
-
   template <typename T>
   void append(folly::Range<const T*> values) {
     if (current_->position + sizeof(T) * values.size() > current_->size) {
-      appendStringPiece(folly::StringPiece(
+      appendStringView(std::string_view(
           reinterpret_cast<const char*>(&values[0]),
           values.size() * sizeof(T)));
       return;
     }
-    auto target = reinterpret_cast<T*>(current_->buffer + current_->position);
-    auto end = target + values.size();
-    auto valuePtr = &values[0];
+
+    auto* target = reinterpret_cast<T*>(current_->buffer + current_->position);
+    const auto* end = target + values.size();
+    auto* valuePtr = &values[0];
     while (target != end) {
       *target = *valuePtr;
       ++target;
@@ -218,7 +306,33 @@ class ByteStream {
 
   void appendBool(bool value, int32_t count);
 
-  void appendStringPiece(folly::StringPiece value);
+  // A fast path for appending bits into pre-cleared buffers after first extend.
+  inline void
+  appendBitsFresh(const uint64_t* bits, int32_t begin, int32_t end) {
+    const auto position = current_->position;
+    if (begin == 0 && end <= 56) {
+      const auto available = current_->size - position;
+      // There must be 8 bytes writable. If available is 56, there are 7, so >.
+      if (available > 56) {
+        const auto offset = position & 7;
+        uint64_t* buffer =
+            reinterpret_cast<uint64_t*>(current_->buffer + (position >> 3));
+        const auto mask = bits::lowMask(offset);
+        *buffer = (*buffer & mask) | (bits[0] << offset);
+        current_->position += end;
+        return;
+      }
+    }
+    appendBits(bits, begin, end);
+  }
+
+  // Writes 'bits' from bit positions begin..end to the current position of
+  // 'this'. Extends 'this' if writing past end.
+  void appendBits(const uint64_t* bits, int32_t begin, int32_t end);
+
+  void appendStringView(StringView value);
+
+  void appendStringView(std::string_view value);
 
   template <typename T>
   void appendOne(const T& value) {
@@ -236,14 +350,45 @@ class ByteStream {
     return allocatedBytes_;
   }
 
+  /// Returns a ByteInputStream to range over the current content of 'this'. The
+  /// result is valid as long as 'this' is live and not changed.
+  std::unique_ptr<ByteInputStream> inputStream() const;
+
   std::string toString() const;
 
  private:
+  // Returns a range of 'size' items of T. If there is no contiguous space in
+  // 'this', uses 'scratch' to make a temp block that is appended to 'this' in
+  template <typename T>
+  T* getAppendWindow(int32_t size, ScratchPtr<T>& scratchPtr) {
+    const int32_t bytes = sizeof(T) * size;
+    if (!current_) {
+      extend(bytes);
+    }
+    auto available = current_->size - current_->position;
+    if (available >= bytes) {
+      current_->position += bytes;
+      return reinterpret_cast<T*>(
+          current_->buffer + current_->position - bytes);
+    }
+    // If the tail is not large enough, make  temp of the right size
+    // in scratch. Extend the stream so that there is guaranteed space to copy
+    // the scratch to the stream. This copy takes place in destruction of
+    // AppendWindow and must not allocate so that it is noexcept.
+    ensureSpace(bytes);
+    return scratchPtr.get(size);
+  }
+
   void extend(int32_t bytes);
 
+  // Calls extend() enough times to make sure 'bytes' bytes can be
+  // appended without new allocation. Does not change the append
+  // position.
+  void ensureSpace(int32_t bytes);
+
   int32_t newRangeSize(int32_t bytes) const;
 
-  void updateEnd() {
+  void updateEnd() const {
     if (!ranges_.empty() && current_ == &ranges_.back() &&
         current_->position > lastRangeEnd_) {
       lastRangeEnd_ = current_->position;
@@ -272,22 +417,43 @@ class ByteStream {
   // of 'ranges_'. In a write situation, all non-last ranges are full
   // and the last may be partly full. The position in the last range
   // is not necessarily the the end if there has been a seek.
-  int32_t lastRangeEnd_{0};
+  mutable int32_t lastRangeEnd_{0};
+
+  template <typename T>
+  friend class AppendWindow;
 };
 
-template <>
-inline Timestamp ByteStream::read<Timestamp>() {
-  Timestamp value;
-  readBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
-  return value;
-}
+/// A scoped wrapper that provides 'size' T's of writable space in 'stream'.
+/// Normally gives an address into 'stream's buffer but can use 'scratch' to
+/// make a contiguous piece if stream does not have a suitable run.
+template <typename T>
+class AppendWindow {
+ public:
+  AppendWindow(ByteOutputStream& stream, Scratch& scratch)
+      : stream_(stream), scratchPtr_(scratch) {}
+
+  ~AppendWindow() noexcept {
+    if (scratchPtr_.size()) {
+      try {
+        stream_.appendStringView(std::string_view(
+            reinterpret_cast<const char*>(scratchPtr_.get()),
+            scratchPtr_.size() * sizeof(T)));
+      } catch (const std::exception& e) {
+        // This is impossible because construction ensures there is space for
+        // the bytes in the stream.
+        LOG(FATAL) << "throw from AppendWindo append: " << e.what();
+      }
+    }
+  }
 
-template <>
-inline int128_t ByteStream::read<int128_t>() {
-  int128_t value;
-  readBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
-  return value;
-}
+  T* get(int32_t size) {
+    return stream_.getAppendWindow(size, scratchPtr_);
+  }
+
+ private:
+  ByteOutputStream& stream_;
+  ScratchPtr<T> scratchPtr_;
+};
 
 class IOBufOutputStream : public OutputStream {
  public:
@@ -297,12 +463,12 @@ class IOBufOutputStream : public OutputStream {
       int32_t initialSize = memory::AllocationTraits::kPageSize)
       : OutputStream(listener),
         arena_(std::make_shared<StreamArena>(&pool)),
-        out_(std::make_unique<ByteStream>(arena_.get())) {
+        out_(std::make_unique<ByteOutputStream>(arena_.get())) {
     out_->startWrite(initialSize);
   }
 
   void write(const char* s, std::streamsize count) override {
-    out_->appendStringPiece(folly::StringPiece(s, count));
+    out_->appendStringView(std::string_view(s, count));
     if (listener_) {
       listener_->onWrite(s, count);
     }
@@ -318,7 +484,7 @@ class IOBufOutputStream : public OutputStream {
 
  private:
   std::shared_ptr<StreamArena> arena_;
-  std::unique_ptr<ByteStream> out_;
+  std::unique_ptr<ByteOutputStream> out_;
 };
 
 } // namespace facebook::velox
diff --git a/velox/common/memory/CMakeLists.txt b/velox/common/memory/CMakeLists.txt
index dc0e618d93f16..2bb6e2d2d1542 100644
--- a/velox/common/memory/CMakeLists.txt
+++ b/velox/common/memory/CMakeLists.txt
@@ -15,7 +15,7 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-add_library(
+velox_add_library(
   velox_memory
   Allocation.cpp
   AllocationPool.cpp
@@ -31,9 +31,10 @@ add_library(
   SharedArbitrator.cpp
   StreamArena.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_memory
   PUBLIC velox_common_base
+         velox_common_config
          velox_exception
          velox_flag_definitions
          velox_time
diff --git a/velox/common/memory/CompactDoubleList.h b/velox/common/memory/CompactDoubleList.h
index 0ed4b5f36f4f5..d048d38e44e0a 100644
--- a/velox/common/memory/CompactDoubleList.h
+++ b/velox/common/memory/CompactDoubleList.h
@@ -21,9 +21,11 @@
 
 namespace facebook::velox {
 
-// Circular double linked list with 6 byte pointers. Used for free
-// list in HashStringAllocator so that we get a minimum allocation
-// payload size of 16 bytes. (12 bits for the links, 4 for trailer).
+/// Circular double linked list with 6 byte pointers. Used for free list in
+/// HashStringAllocator so that we get a minimum allocation payload size of 16
+/// bytes. (12 bits for the links, 4 for trailer).
+///
+/// NOTE: this class is not thread-safe.
 class CompactDoubleList {
  public:
   CompactDoubleList() {
@@ -36,12 +38,12 @@ class CompactDoubleList {
   void operator=(const CompactDoubleList& other) = delete;
   void operator=(CompactDoubleList&& other) = delete;
 
-  // Return true if 'this' is the only element.
+  /// Returns true if 'this' is the only element.
   bool empty() const {
     return next() == this;
   }
 
-  // inserts 'entry' after 'this'
+  /// Inserts 'entry' after 'this'
   void insert(CompactDoubleList* entry) {
     entry->setNext(next());
     entry->setPrevious(this);
@@ -49,7 +51,7 @@ class CompactDoubleList {
     setNext(entry);
   }
 
-  // Unlinks 'this' from its list. Throws if 'this' is the only element.
+  /// Unlinks 'this' from its list. Throws if 'this' is the only element.
   void remove() {
     VELOX_CHECK(!empty());
     previous()->setNext(next());
@@ -64,6 +66,17 @@ class CompactDoubleList {
     return loadPointer(previousLow_, previousHigh_);
   }
 
+  /// Updates links after the next() of 'this' has been moved to 'newNext'. Sets
+  /// the next link of this, the previous link of 'newNext' and the previous
+  /// link of the next() of the moved 'newNext'. The use case is taking the
+  /// head of a free list block without a full remove of block plus reinsert of
+  /// the remainder of the block.
+  void nextMoved(CompactDoubleList* newNext) {
+    setNext(newNext);
+    VELOX_CHECK(newNext->previous() == this);
+    newNext->next()->setPrevious(newNext);
+  }
+
  private:
   static constexpr uint8_t kPointerSignificantBits = 48;
 
@@ -81,11 +94,11 @@ class CompactDoubleList {
   }
 
   void storePointer(CompactDoubleList* pointer, uint32_t& low, uint16_t& high) {
-    DCHECK_EQ(
+    VELOX_DCHECK_EQ(
         reinterpret_cast<uint64_t>(pointer) &
             ~bits::lowMask(kPointerSignificantBits),
         0);
-    uint64_t data = reinterpret_cast<uint64_t>(pointer);
+    const uint64_t data = reinterpret_cast<uint64_t>(pointer);
     low = static_cast<uint32_t>(data);
     high = static_cast<uint16_t>(data >> 32);
   }
@@ -97,6 +110,4 @@ class CompactDoubleList {
   uint16_t previousHigh_;
 };
 
-;
-
 } // namespace facebook::velox
diff --git a/velox/common/memory/HashStringAllocator.cpp b/velox/common/memory/HashStringAllocator.cpp
index e2159af6f67e3..8cb6781a16e3c 100644
--- a/velox/common/memory/HashStringAllocator.cpp
+++ b/velox/common/memory/HashStringAllocator.cpp
@@ -20,22 +20,21 @@
 namespace facebook::velox {
 
 namespace {
-/// Returns the size of the previous free block. The size is stored in the
-/// last 4 bytes of the free block, e.g. 4 bytes just before the current
-/// header.
+// Returns the size of the previous free block. The size is stored in the last 4
+// bytes of the free block, e.g. 4 bytes just before the current header.
 uint32_t* previousFreeSize(HashStringAllocator::Header* header) {
   return reinterpret_cast<uint32_t*>(header) - 1;
 }
 
-/// Returns the header of the previous free block or nullptr if previous block
-/// is not free.
-HashStringAllocator::Header* FOLLY_NULLABLE
-getPreviousFree(HashStringAllocator::Header* FOLLY_NONNULL header) {
+// Returns the header of the previous free block or nullptr if previous block is
+// not free.
+HashStringAllocator::Header* getPreviousFree(
+    HashStringAllocator::Header* header) {
   if (!header->isPreviousFree()) {
     return nullptr;
   }
-  auto numBytes = *previousFreeSize(header);
-  auto previous = reinterpret_cast<HashStringAllocator::Header*>(
+  const auto numBytes = *previousFreeSize(header);
+  auto* previous = reinterpret_cast<HashStringAllocator::Header*>(
       header->begin() - numBytes - 2 * sizeof(HashStringAllocator::Header));
   VELOX_CHECK_EQ(previous->size(), numBytes);
   VELOX_CHECK(previous->isFree());
@@ -43,13 +42,12 @@ getPreviousFree(HashStringAllocator::Header* FOLLY_NONNULL header) {
   return previous;
 }
 
-/// Sets kFree flag in the 'header' and writes the size of the block to the
-/// last 4 bytes of the block. Sets kPreviousFree flag in the next block's
-/// 'header'.
-void markAsFree(HashStringAllocator::Header* FOLLY_NONNULL header) {
+// Sets kFree flag in the 'header' and writes the size of the block to the last
+// 4 bytes of the block. Sets kPreviousFree flag in the next block's 'header'.
+void markAsFree(HashStringAllocator::Header* header) {
   header->setFree();
-  auto nextHeader = header->next();
-  if (nextHeader) {
+  auto* nextHeader = header->next();
+  if (nextHeader != nullptr) {
     nextHeader->setPreviousFree();
     *previousFreeSize(nextHeader) = header->size();
   }
@@ -88,76 +86,135 @@ HashStringAllocator::~HashStringAllocator() {
 }
 
 void HashStringAllocator::clear() {
-  numFree_ = 0;
-  freeBytes_ = 0;
-  freeNonEmpty_ = 0;
-  for (auto& pair : allocationsFromPool_) {
-    pool()->free(pair.first, pair.second);
-  }
-  allocationsFromPool_.clear();
+  state_.numFree() = 0;
+  state_.freeBytes() = 0;
+  std::fill(
+      std::begin(state_.freeNonEmpty()), std::end(state_.freeNonEmpty()), 0);
+  for (auto& pair : state_.allocationsFromPool()) {
+    const auto size = pair.second;
+    pool()->free(pair.first, size);
+    state_.sizeFromPool() -= size;
+    state_.currentBytes() -= size;
+  }
+  state_.allocationsFromPool().clear();
   for (auto i = 0; i < kNumFreeLists; ++i) {
-    new (&free_[i]) CompactDoubleList();
+    new (&state_.freeLists()[i]) CompactDoubleList();
+  }
+
+#ifndef NDEBUG
+  static const auto kHugePageSize = memory::AllocationTraits::kHugePageSize;
+  for (auto i = 0; i < state_.pool().numRanges(); ++i) {
+    const auto range = state_.pool().rangeAt(i);
+    const auto rangeSize = range.size();
+    if (rangeSize >= kHugePageSize) {
+      VELOX_CHECK_EQ(0, rangeSize % kHugePageSize);
+    }
+
+    for (int64_t blockOffset = 0; blockOffset < rangeSize;
+         blockOffset += kHugePageSize) {
+      auto blockRange = folly::Range<char*>(
+          range.data() + blockOffset,
+          std::min<int64_t>(rangeSize, kHugePageSize));
+      const auto size = blockRange.size() - simd::kPadding;
+      auto* end = castToHeader(blockRange.data() + size);
+      auto* header = castToHeader(blockRange.data());
+      while (header != end) {
+        VELOX_CHECK_GE(reinterpret_cast<char*>(header), blockRange.data());
+        VELOX_CHECK_LT(
+            reinterpret_cast<char*>(header), reinterpret_cast<char*>(end));
+        VELOX_CHECK_LE(
+            reinterpret_cast<char*>(header->end()),
+            reinterpret_cast<char*>(end));
+
+        // Continued block & Non-free block.
+        if (!header->isFree()) {
+          state_.currentBytes() -= blockBytes(header);
+        }
+        header = castToHeader(header->end());
+      }
+    }
   }
-  pool_.clear();
+
+  VELOX_DCHECK_EQ(state_.currentBytes(), 0);
+  VELOX_DCHECK_EQ(state_.sizeFromPool(), 0);
+#endif
+  state_.pool().clear();
+
+  state_.currentBytes() = 0;
+  state_.sizeFromPool() = 0;
 }
 
 void* HashStringAllocator::allocateFromPool(size_t size) {
-  auto ptr = pool()->allocate(size);
-  cumulativeBytes_ += size;
-  allocationsFromPool_[ptr] = size;
-  sizeFromPool_ += size;
+  auto* ptr = pool()->allocate(size);
+  state_.currentBytes() += size;
+  state_.allocationsFromPool()[ptr] = size;
+  state_.sizeFromPool() += size;
   return ptr;
 }
 
 void HashStringAllocator::freeToPool(void* ptr, size_t size) {
-  auto it = allocationsFromPool_.find(ptr);
+  auto it = state_.allocationsFromPool().find(ptr);
   VELOX_CHECK(
-      it != allocationsFromPool_.end(),
+      it != state_.allocationsFromPool().end(),
       "freeToPool for block not allocated from pool of HashStringAllocator");
   VELOX_CHECK_EQ(
       size, it->second, "Bad size in HashStringAllocator::freeToPool()");
-  allocationsFromPool_.erase(it);
-  sizeFromPool_ -= size;
-  cumulativeBytes_ -= size;
+  state_.allocationsFromPool().erase(it);
+  state_.sizeFromPool() -= size;
+  state_.currentBytes() -= size;
   pool()->free(ptr, size);
 }
 
 // static
-void HashStringAllocator::prepareRead(const Header* begin, ByteStream& stream) {
+std::unique_ptr<ByteInputStream> HashStringAllocator::prepareRead(
+    const Header* begin,
+    size_t maxBytes) {
   std::vector<ByteRange> ranges;
-  auto header = const_cast<Header*>(begin);
+  auto* header = const_cast<Header*>(begin);
+
+  size_t totalBytes{0};
   for (;;) {
     ranges.push_back(ByteRange{
         reinterpret_cast<uint8_t*>(header->begin()), header->usableSize(), 0});
+    totalBytes += ranges.back().size;
     if (!header->isContinued()) {
       break;
     }
+
+    if (totalBytes >= maxBytes) {
+      break;
+    }
+
     header = header->nextContinued();
   }
-  stream.resetInput(std::move(ranges));
+  return std::make_unique<BufferInputStream>(std::move(ranges));
 }
 
 HashStringAllocator::Position HashStringAllocator::newWrite(
-    ByteStream& stream,
+    ByteOutputStream& stream,
     int32_t preferredSize) {
-  VELOX_CHECK(
-      !currentHeader_,
+  VELOX_CHECK_NULL(
+      state_.currentHeader(),
       "Do not call newWrite before finishing the previous write to "
       "HashStringAllocator");
-  currentHeader_ = allocate(preferredSize, false);
+  state_.currentHeader() = allocate(preferredSize, false);
 
-  stream.setRange(ByteRange{
-      reinterpret_cast<uint8_t*>(currentHeader_->begin()),
-      currentHeader_->size(),
-      0});
+  stream.setRange(
+      ByteRange{
+          reinterpret_cast<uint8_t*>(state_.currentHeader()->begin()),
+          state_.currentHeader()->size(),
+          0},
+      0);
 
-  startPosition_ = Position::atOffset(currentHeader_, 0);
+  state_.startPosition() = Position::atOffset(state_.currentHeader(), 0);
 
-  return startPosition_;
+  return state_.startPosition();
 }
 
-void HashStringAllocator::extendWrite(Position position, ByteStream& stream) {
-  auto header = position.header;
+void HashStringAllocator::extendWrite(
+    Position position,
+    ByteOutputStream& stream) {
+  auto* header = position.header;
   const auto offset = position.offset();
   VELOX_CHECK_GE(
       offset, 0, "Starting extendWrite outside of the current range");
@@ -171,110 +228,127 @@ void HashStringAllocator::extendWrite(Position position, ByteStream& stream) {
     header->clearContinued();
   }
 
-  stream.setRange(ByteRange{
-      reinterpret_cast<uint8_t*>(position.position),
-      static_cast<int32_t>(header->end() - position.position),
-      0});
-  currentHeader_ = header;
-  startPosition_ = position;
+  stream.setRange(
+      ByteRange{
+          reinterpret_cast<uint8_t*>(position.header->begin()),
+          position.header->size(),
+          static_cast<int32_t>(position.position - position.header->begin())},
+      0);
+  state_.currentHeader() = header;
+  state_.startPosition() = position;
 }
 
 std::pair<HashStringAllocator::Position, HashStringAllocator::Position>
-HashStringAllocator::finishWrite(ByteStream& stream, int32_t numReserveBytes) {
-  VELOX_CHECK(
-      currentHeader_, "Must call newWrite or extendWrite before finishWrite");
-  auto writePosition = stream.writePosition();
-  const auto offset = writePosition - currentHeader_->begin();
+HashStringAllocator::finishWrite(
+    ByteOutputStream& stream,
+    int32_t numReserveBytes) {
+  VELOX_CHECK_NOT_NULL(
+      state_.currentHeader(),
+      "Must call newWrite or extendWrite before finishWrite");
+  auto* writePosition = stream.writePosition();
+  const auto offset = writePosition - state_.currentHeader()->begin();
 
   VELOX_CHECK_GE(
       offset, 0, "finishWrite called with writePosition out of range");
   VELOX_CHECK_LE(
       offset,
-      currentHeader_->usableSize(),
+      state_.currentHeader()->usableSize(),
       "finishWrite called with writePosition out of range");
 
-  Position currentPosition = Position::atOffset(currentHeader_, offset);
-  if (currentHeader_->isContinued()) {
-    free(currentHeader_->nextContinued());
-    currentHeader_->clearContinued();
+  const Position currentPosition =
+      Position::atOffset(state_.currentHeader(), offset);
+  if (state_.currentHeader()->isContinued()) {
+    free(state_.currentHeader()->nextContinued());
+    state_.currentHeader()->clearContinued();
   }
   // Free remainder of block if there is a lot left over.
   freeRestOfBlock(
-      currentHeader_,
-      writePosition - currentHeader_->begin() + numReserveBytes);
-  currentHeader_ = nullptr;
+      state_.currentHeader(),
+      writePosition - state_.currentHeader()->begin() + numReserveBytes);
+  state_.currentHeader() = nullptr;
 
   // The starting position may have shifted if it was at the end of the block
   // and the block was extended. Calculate the new position.
-  if (startPosition_.header->isContinued()) {
-    auto header = startPosition_.header;
-    const auto offset = startPosition_.offset();
+  if (state_.startPosition().header->isContinued()) {
+    auto* header = state_.startPosition().header;
+    const auto offset = state_.startPosition().offset();
     const auto extra = offset - header->usableSize();
     if (extra > 0) {
-      auto newHeader = header->nextContinued();
-      auto newPosition = newHeader->begin() + extra;
-      startPosition_ = {newHeader, newPosition};
+      auto* newHeader = header->nextContinued();
+      auto* newPosition = newHeader->begin() + extra;
+      state_.startPosition() = {newHeader, newPosition};
     }
   }
-  return {startPosition_, currentPosition};
+  return {state_.startPosition(), currentPosition};
 }
 
 void HashStringAllocator::newSlab() {
-  constexpr int32_t kSimdPadding = simd::kPadding - sizeof(Header);
-  const int64_t needed = pool_.allocatedBytes() >= pool_.hugePageThreshold()
+  constexpr int32_t kSimdPadding = simd::kPadding - kHeaderSize;
+  const int64_t needed =
+      state_.pool().allocatedBytes() >= state_.pool().hugePageThreshold()
       ? memory::AllocationTraits::kHugePageSize
       : kUnitSize;
-  auto run = pool_.allocateFixed(needed);
-  // We check we got exactly the requested amount. checkConsistency()
-  // depends on slabs made here coinciding with ranges from
-  // AllocationPool::rangeAt(). Sometimes the last range can be
-  // several huge pages for severl huge page sized arenas but
-  // checkConsistency() can interpret that.
-  VELOX_CHECK_EQ(0, pool_.freeBytes());
-  auto available = needed - sizeof(Header) - kSimdPadding;
-
+  auto* run = state_.pool().allocateFixed(needed);
   VELOX_CHECK_NOT_NULL(run);
+  // We check we got exactly the requested amount. checkConsistency() depends on
+  // slabs made here coinciding with ranges from AllocationPool::rangeAt().
+  // Sometimes the last range can be several huge pages for severl huge page
+  // sized arenas but checkConsistency() can interpret that.
+  VELOX_CHECK_EQ(state_.pool().freeBytes(), 0);
+  const auto available = needed - kHeaderSize - kSimdPadding;
   VELOX_CHECK_GT(available, 0);
-  // Write end  marker.
+
+  // Write end marker.
   *reinterpret_cast<uint32_t*>(run + available) = Header::kArenaEnd;
-  cumulativeBytes_ += available;
+  state_.currentBytes() += available;
 
-  // Add the new memory to the free list: Placement construct a header
-  // that covers the space from start to the end marker and add this
-  // to free list.
-  free(new (run) Header(available - sizeof(Header)));
+  // Add the new memory to the free list: Placement construct a header that
+  // covers the space from start to the end marker and add this to free list.
+  free(new (run) Header(available - kHeaderSize));
 }
 
 void HashStringAllocator::newRange(
     int32_t bytes,
+    ByteRange* lastRange,
     ByteRange* range,
     bool contiguous) {
-  // Allocates at least kMinContiguous or to the end of the current
-  // run. At the end of the write the unused space will be made
-  // free.
-  VELOX_CHECK(
-      currentHeader_,
+  // Allocates at least kMinContiguous or to the end of the current run. At the
+  // end of the write, the unused space will be made free.
+  VELOX_CHECK_NOT_NULL(
+      state_.currentHeader(),
       "Must have called newWrite or extendWrite before newRange");
-  auto newHeader = allocate(bytes, contiguous);
+  auto* newHeader = allocate(bytes, contiguous);
 
-  auto lastWordPtr = reinterpret_cast<void**>(
-      currentHeader_->end() - Header::kContinuedPtrSize);
+  // Copy the last word of the current range to the head of new range, and then
+  // used the space to store the new range pointer.
+  auto** lastWordPtr = reinterpret_cast<void**>(
+      state_.currentHeader()->end() - Header::kContinuedPtrSize);
   *reinterpret_cast<void**>(newHeader->begin()) = *lastWordPtr;
   *lastWordPtr = newHeader;
-  currentHeader_->setContinued();
-  currentHeader_ = newHeader;
+  state_.currentHeader()->setContinued();
+  state_.currentHeader() = newHeader;
+  if (lastRange) {
+    // The last bytes of the last range are no longer payload. So do not count
+    // them in size and do not overwrite them if overwriting the multi-range
+    // entry. Set position at the new end.
+    lastRange->size -= Header::kContinuedPtrSize;
+    lastRange->position = std::min(lastRange->size, lastRange->position);
+  }
   *range = ByteRange{
-      reinterpret_cast<uint8_t*>(currentHeader_->begin()),
-      currentHeader_->size(),
+      reinterpret_cast<uint8_t*>(state_.currentHeader()->begin()),
+      state_.currentHeader()->size(),
       Header::kContinuedPtrSize};
 }
 
-void HashStringAllocator::newRange(int32_t bytes, ByteRange* range) {
-  newRange(bytes, range, false);
+void HashStringAllocator::newRange(
+    int32_t bytes,
+    ByteRange* lastRange,
+    ByteRange* range) {
+  newRange(bytes, lastRange, range, false);
 }
 
 void HashStringAllocator::newContiguousRange(int32_t bytes, ByteRange* range) {
-  newRange(bytes, range, true);
+  newRange(bytes, nullptr, range, true);
 }
 
 // static
@@ -284,241 +358,164 @@ StringView HashStringAllocator::contiguousString(
   if (view.isInline()) {
     return view;
   }
-  auto header = headerOf(view.data());
+  auto* header = headerOf(view.data());
   if (view.size() <= header->size()) {
     return view;
   }
 
-  ByteStream stream;
-  prepareRead(headerOf(view.data()), stream);
+  auto stream = prepareRead(headerOf(view.data()));
   storage.resize(view.size());
-  stream.readBytes(storage.data(), view.size());
+  stream->readBytes(storage.data(), view.size());
   return StringView(storage);
 }
 
 void HashStringAllocator::freeRestOfBlock(Header* header, int32_t keepBytes) {
   keepBytes = std::max(keepBytes, kMinAlloc);
-  int32_t freeSize = header->size() - keepBytes - sizeof(Header);
+  const int32_t freeSize = header->size() - keepBytes - kHeaderSize;
   if (freeSize <= kMinAlloc) {
     return;
   }
 
   header->setSize(keepBytes);
-  auto newHeader = new (header->end()) Header(freeSize);
+  auto* newHeader = new (header->end()) Header(freeSize);
   free(newHeader);
 }
 
-// Free list sizes align with size of containers. + 20 allows for padding for an
-// alignment of 16 bytes.
-int32_t HashStringAllocator::freeListSizes_[kNumFreeLists + 7] = {
-    30,
-    50,
-    72,
-    8 * 16 + 20,
-    100,
-    16 * 16 + 20,
-    32 * 16 + 20,
-    64 * 16 + 20,
-    128 * 16 + 20,
-    std::numeric_limits<int32_t>::max(),
-    std::numeric_limits<int32_t>::max(),
-    std::numeric_limits<int32_t>::max(),
-    std::numeric_limits<int32_t>::max(),
-    std::numeric_limits<int32_t>::max(),
-    std::numeric_limits<int32_t>::max(),
-    std::numeric_limits<int32_t>::max(),
-};
-
-// static
-folly::Range<const int32_t*> HashStringAllocator::freeListSizeClasses() {
-  return folly::Range<const int32_t*>(&freeListSizes_[0], kNumFreeLists);
+int32_t HashStringAllocator::freeListIndex(int size) {
+  return std::min(size - kMinAlloc, kNumFreeLists - 1);
 }
 
-int32_t HashStringAllocator::freeListIndex(int32_t size, uint32_t mask) {
-  static_assert(sizeof(freeListSizes_) >= sizeof(xsimd::batch<int32_t>));
-  auto vsize = xsimd::broadcast(size);
-  if constexpr (sizeof(freeListSizes_) == sizeof(xsimd::batch<int32_t>)) {
-    auto sizes = xsimd::load_unaligned(freeListSizes_);
-    auto bits = simd::toBitMask(vsize < sizes) & mask;
-    return count_trailing_zeros(bits);
-  } else {
-    for (int offset = 0; offset <= kNumFreeLists; offset += vsize.size) {
-      auto sizes = xsimd::load_unaligned(freeListSizes_ + offset);
-      auto bits = simd::toBitMask(vsize < sizes) & mask;
-      if (bits) {
-        return offset + count_trailing_zeros(bits);
-      }
-      mask >>= vsize.size;
-    }
-    return count_trailing_zeros(0);
+void HashStringAllocator::removeFromFreeList(Header* header) {
+  VELOX_CHECK(header->isFree());
+  header->clearFree();
+  const auto index = freeListIndex(header->size());
+  reinterpret_cast<CompactDoubleList*>(header->begin())->remove();
+  if (state_.freeLists()[index].empty()) {
+    bits::clearBit(state_.freeNonEmpty(), index);
   }
 }
 
-HashStringAllocator::Header* FOLLY_NULLABLE
-HashStringAllocator::allocate(int32_t size, bool exactSize) {
+HashStringAllocator::Header* HashStringAllocator::allocate(
+    int32_t size,
+    bool exactSize) {
   if (size > kMaxAlloc && exactSize) {
-    VELOX_CHECK(size <= Header::kSizeMask);
-    auto header =
-        reinterpret_cast<Header*>(allocateFromPool(size + sizeof(Header)));
+    VELOX_CHECK_LE(size, Header::kSizeMask);
+    auto* header = castToHeader(allocateFromPool(size + kHeaderSize));
     new (header) Header(size);
     return header;
   }
-  auto header = allocateFromFreeLists(size, exactSize, exactSize);
-  if (!header) {
+
+  auto* header = allocateFromFreeLists(size, exactSize, exactSize);
+  if (header == nullptr) {
     newSlab();
     header = allocateFromFreeLists(size, exactSize, exactSize);
-    VELOX_CHECK(header != nullptr);
+    VELOX_CHECK_NOT_NULL(header);
     VELOX_CHECK_GT(header->size(), 0);
   }
-
   return header;
 }
 
-HashStringAllocator::Header* FOLLY_NULLABLE
-HashStringAllocator::allocateFromFreeLists(
+HashStringAllocator::Header* HashStringAllocator::allocateFromFreeLists(
     int32_t preferredSize,
     bool mustHaveSize,
     bool isFinalSize) {
-  preferredSize = std::max(kMinAlloc, preferredSize);
-  if (!numFree_) {
+  if (state_.numFree() == 0) {
     return nullptr;
   }
-  auto index = freeListIndex(preferredSize, freeNonEmpty_);
-  while (index < kNumFreeLists) {
-    if (auto header = allocateFromFreeList(
-            preferredSize, mustHaveSize, isFinalSize, index)) {
-      return header;
-    }
-    // Go to the next larger size non-empty free list.
-    index = count_trailing_zeros(freeNonEmpty_ & ~bits::lowMask(index + 1));
+  preferredSize = std::max(kMinAlloc, preferredSize);
+  const auto index = freeListIndex(preferredSize);
+  auto available =
+      bits::findFirstBit(state_.freeNonEmpty(), index, kNumFreeLists);
+  if (!mustHaveSize && available == -1) {
+    available = bits::findLastBit(state_.freeNonEmpty(), 0, index);
   }
-  if (mustHaveSize) {
+  if (available == -1) {
     return nullptr;
   }
-  index = freeListIndex(preferredSize) - 1;
-  for (; index >= 0; --index) {
-    if (auto header =
-            allocateFromFreeList(preferredSize, false, isFinalSize, index)) {
-      return header;
-    }
-  }
-  return nullptr;
+  auto* header =
+      allocateFromFreeList(preferredSize, mustHaveSize, isFinalSize, available);
+  VELOX_CHECK_NOT_NULL(header);
+  return header;
 }
 
-HashStringAllocator::Header* FOLLY_NULLABLE
-HashStringAllocator::allocateFromFreeList(
+HashStringAllocator::Header* HashStringAllocator::allocateFromFreeList(
     int32_t preferredSize,
     bool mustHaveSize,
     bool isFinalSize,
     int32_t freeListIndex) {
-  constexpr int32_t kMaxCheckedForFit = 5;
-  int32_t counter = 0;
-  if (mustHaveSize && largestInFreeList_[freeListIndex] < preferredSize) {
+  auto* item = state_.freeLists()[freeListIndex].next();
+  if (item == &state_.freeLists()[freeListIndex]) {
     return nullptr;
   }
-  int32_t largestFreeSize = 0;
-  Header* largest = nullptr;
-  Header* found = nullptr;
-  for (auto* item = free_[freeListIndex].next(); item != &free_[freeListIndex];
-       item = item->next()) {
-    auto header = headerOf(item);
-    VELOX_CHECK(header->isFree());
-    auto size = header->size();
-    if (size >= preferredSize) {
-      found = header;
-      break;
-    }
-    if (!largest || size > largest->size()) {
-      largest = header;
-    }
-    ++counter;
-    if (!mustHaveSize && counter > kMaxCheckedForFit) {
-      break;
-    }
-  }
-  numFreeListNoFit_ += counter;
-  if (!mustHaveSize && !found) {
-    found = largest;
-  }
-  if (!found) {
-    // We have traversed the complete free list and therefore know the largest
-    // size. Either the list is empty or mustHaveSize is true and there is no
-    // block large enough.
-    largestInFreeList_[freeListIndex] = largest ? largest->size() : 0;
-    return nullptr;
-  }
-  --numFree_;
-  freeBytes_ -= found->size() + sizeof(Header);
+  auto* found = headerOf(item);
+  VELOX_CHECK(
+      found->isFree() && (!mustHaveSize || found->size() >= preferredSize));
+  --state_.numFree();
+  state_.freeBytes() -= blockBytes(found);
   removeFromFreeList(found);
-
-  auto next = found->next();
-  if (next) {
+  auto* next = found->next();
+  if (next != nullptr) {
     next->clearPreviousFree();
   }
-  cumulativeBytes_ += found->size();
+  state_.currentBytes() += blockBytes(found);
   if (isFinalSize) {
     freeRestOfBlock(found, preferredSize);
   }
   return found;
 }
 
-void HashStringAllocator::free(Header* _header) {
-  Header* header = _header;
-  if (header->size() > kMaxAlloc && !pool_.isInCurrentRange(header) &&
-      allocationsFromPool_.find(header) != allocationsFromPool_.end()) {
-    // A large free can either be a rest of block or a standalone allocation.
-    VELOX_CHECK(!header->isContinued());
-    freeToPool(header, header->size() + sizeof(Header));
-    return;
-  }
-
+void HashStringAllocator::free(Header* header) {
+  Header* headerToFree = header;
   do {
     Header* continued = nullptr;
-    if (header->isContinued()) {
-      continued = header->nextContinued();
-      header->clearContinued();
+    if (headerToFree->isContinued()) {
+      continued = headerToFree->nextContinued();
+      headerToFree->clearContinued();
     }
-    VELOX_CHECK(!header->isFree());
-    freeBytes_ += header->size() + sizeof(Header);
-    cumulativeBytes_ -= header->size();
-    Header* next = header->next();
-    if (next) {
-      VELOX_CHECK(!next->isPreviousFree());
-      if (next->isFree()) {
-        --numFree_;
-        removeFromFreeList(next);
-        header->setSize(header->size() + next->size() + sizeof(Header));
-        next = reinterpret_cast<Header*>(header->end());
-        VELOX_CHECK(next->isArenaEnd() || !next->isFree());
-      }
-    }
-    if (header->isPreviousFree()) {
-      auto previousFree = getPreviousFree(header);
-      removeFromFreeList(previousFree);
-      previousFree->setSize(
-          previousFree->size() + header->size() + sizeof(Header));
-
-      header = previousFree;
+    if (headerToFree->size() > kMaxAlloc &&
+        !state_.pool().isInCurrentRange(headerToFree) &&
+        state_.allocationsFromPool().find(headerToFree) !=
+            state_.allocationsFromPool().end()) {
+      freeToPool(headerToFree, headerToFree->size() + kHeaderSize);
     } else {
-      ++numFree_;
-    }
-    auto freedSize = header->size();
-    auto freeIndex = freeListIndex(freedSize);
-    freeNonEmpty_ |= 1 << freeIndex;
-    if (largestInFreeList_[freeIndex] < freedSize) {
-      largestInFreeList_[freeIndex] = freedSize;
+      VELOX_CHECK(!headerToFree->isFree());
+      state_.freeBytes() += blockBytes(headerToFree);
+      state_.currentBytes() -= blockBytes(headerToFree);
+      Header* next = headerToFree->next();
+      if (next != nullptr) {
+        VELOX_CHECK(!next->isPreviousFree());
+        if (next->isFree()) {
+          --state_.numFree();
+          removeFromFreeList(next);
+          headerToFree->setSize(
+              headerToFree->size() + next->size() + kHeaderSize);
+          next = castToHeader(headerToFree->end());
+          VELOX_CHECK(next->isArenaEnd() || !next->isFree());
+        }
+      }
+      if (headerToFree->isPreviousFree()) {
+        auto* previousFree = getPreviousFree(headerToFree);
+        removeFromFreeList(previousFree);
+        previousFree->setSize(
+            previousFree->size() + headerToFree->size() + kHeaderSize);
+
+        headerToFree = previousFree;
+      } else {
+        ++state_.numFree();
+      }
+      const auto freedSize = headerToFree->size();
+      const auto freeIndex = freeListIndex(freedSize);
+      bits::setBit(state_.freeNonEmpty(), freeIndex);
+      state_.freeLists()[freeIndex].insert(
+          reinterpret_cast<CompactDoubleList*>(headerToFree->begin()));
+      markAsFree(headerToFree);
     }
-    free_[freeIndex].insert(
-        reinterpret_cast<CompactDoubleList*>(header->begin()));
-    markAsFree(header);
-    header = continued;
-  } while (header);
+    headerToFree = continued;
+  } while (headerToFree != nullptr);
 }
 
 // static
-int64_t HashStringAllocator::offset(
-    Header* FOLLY_NONNULL header,
-    Position position) {
+int64_t HashStringAllocator::offset(Header* header, Position position) {
   static const int64_t kOutOfRange = -1;
   if (!position.isSet()) {
     return kOutOfRange;
@@ -526,7 +523,7 @@ int64_t HashStringAllocator::offset(
 
   int64_t size = 0;
   for (;;) {
-    assert(header);
+    VELOX_CHECK_NOT_NULL(header);
     const auto length = header->usableSize();
     const auto offset = position.position - header->begin();
     if (offset >= 0 && offset <= length) {
@@ -542,12 +539,12 @@ int64_t HashStringAllocator::offset(
 
 // static
 HashStringAllocator::Position HashStringAllocator::seek(
-    Header* FOLLY_NONNULL header,
+    Header* header,
     int64_t offset) {
   int64_t size = 0;
   for (;;) {
-    assert(header);
-    auto length = header->usableSize();
+    VELOX_CHECK_NOT_NULL(header);
+    const auto length = header->usableSize();
     if (offset <= size + length) {
       return Position::atOffset(header, offset - size);
     }
@@ -561,12 +558,12 @@ HashStringAllocator::Position HashStringAllocator::seek(
 
 // static
 int64_t HashStringAllocator::available(const Position& position) {
-  auto header = position.header;
+  auto* header = position.header;
   const auto startOffset = position.offset();
   // startOffset bytes from the first block are already used.
   int64_t size = -startOffset;
   for (;;) {
-    assert(header);
+    VELOX_CHECK_NOT_NULL(header);
     size += header->usableSize();
     if (!header->isContinued()) {
       return size;
@@ -580,31 +577,106 @@ void HashStringAllocator::ensureAvailable(int32_t bytes, Position& position) {
     return;
   }
 
-  ByteStream stream(this);
+  ByteOutputStream stream(this);
   extendWrite(position, stream);
   static char data[128];
-  while (bytes) {
-    auto written = std::min<size_t>(bytes, sizeof(data));
+  while (bytes > 0) {
+    const auto written = std::min<size_t>(bytes, sizeof(data));
     stream.append(folly::StringPiece(data, written));
     bytes -= written;
   }
   position = finishWrite(stream, 0).first;
 }
 
+inline bool HashStringAllocator::storeStringFast(
+    const char* bytes,
+    int32_t numBytes,
+    char* destination) {
+  const auto roundedBytes = std::max(numBytes, kMinAlloc);
+
+  Header* header = nullptr;
+  if (state_.freeLists()[kNumFreeLists - 1].empty()) {
+    if (roundedBytes >= kMaxAlloc) {
+      return false;
+    }
+    const auto index = freeListIndex(roundedBytes);
+    const auto available =
+        bits::findFirstBit(state_.freeNonEmpty(), index, kNumFreeLists);
+    if (available < 0) {
+      return false;
+    }
+    header = allocateFromFreeList(roundedBytes, true, true, available);
+    VELOX_CHECK_NOT_NULL(header);
+  } else {
+    auto& freeList = state_.freeLists()[kNumFreeLists - 1];
+    header = headerOf(freeList.next());
+    const auto spaceTaken = roundedBytes + kHeaderSize;
+    if (spaceTaken > header->size()) {
+      return false;
+    }
+    if (header->size() - spaceTaken > kMaxAlloc) {
+      // The entry after allocation stays in the largest free list.
+      // The size at the end of the block is changed in place.
+      reinterpret_cast<int32_t*>(header->end())[-1] -= spaceTaken;
+      auto* freeHeader = new (header->begin() + roundedBytes)
+          Header(header->size() - spaceTaken);
+      freeHeader->setFree();
+      header->clearFree();
+      ::memcpy(freeHeader->begin(), header->begin(), sizeof(CompactDoubleList));
+      freeList.nextMoved(
+          reinterpret_cast<CompactDoubleList*>(freeHeader->begin()));
+      header->setSize(roundedBytes);
+      state_.freeBytes() -= spaceTaken;
+      state_.currentBytes() += spaceTaken;
+    } else {
+      header =
+          allocateFromFreeList(roundedBytes, true, true, kNumFreeLists - 1);
+      if (!header) {
+        return false;
+      }
+    }
+  }
+
+  simd::memcpy(header->begin(), bytes, numBytes);
+  *reinterpret_cast<StringView*>(destination) =
+      StringView(reinterpret_cast<char*>(header->begin()), numBytes);
+  return true;
+}
+
+void HashStringAllocator::copyMultipartNoInline(
+    const StringView& srcStr,
+    char* group,
+    int32_t offset) {
+  const auto numBytes = srcStr.size();
+  if (storeStringFast(srcStr.data(), numBytes, group + offset)) {
+    return;
+  }
+  // Write the string as non-contiguous chunks.
+  ByteOutputStream stream(this, false, false);
+  auto position = newWrite(stream, numBytes);
+  stream.appendStringView(srcStr);
+  finishWrite(stream, 0);
+
+  // The stringView has a pointer to the first byte and the total
+  // size. Read with contiguousString().
+  *reinterpret_cast<StringView*>(group + offset) =
+      StringView(reinterpret_cast<char*>(position.position), numBytes);
+}
+
 std::string HashStringAllocator::toString() const {
   std::ostringstream out;
 
-  out << "allocated: " << cumulativeBytes_ << " bytes" << std::endl;
-  out << "free: " << freeBytes_ << " bytes in " << numFree_ << " blocks"
-      << std::endl;
-  out << "standalone allocations: " << sizeFromPool_ << " bytes in "
-      << allocationsFromPool_.size() << " allocations" << std::endl;
-  out << "ranges: " << pool_.numRanges() << std::endl;
+  out << "allocated: " << state_.currentBytes() << " bytes" << std::endl;
+  out << "free: " << state_.freeBytes() << " bytes in " << state_.numFree()
+      << " blocks" << std::endl;
+  out << "standalone allocations: " << state_.sizeFromPool() << " bytes in "
+      << state_.allocationsFromPool().size() << " allocations" << std::endl;
+  out << "ranges: " << state_.pool().numRanges() << std::endl;
 
   static const auto kHugePageSize = memory::AllocationTraits::kHugePageSize;
 
-  for (auto i = 0; i < pool_.numRanges(); ++i) {
-    auto topRange = pool_.rangeAt(i);
+  for (auto i = 0; i < state_.pool().numRanges(); ++i) {
+    auto topRange = state_.pool().rangeAt(i);
     auto topRangeSize = topRange.size();
 
     out << "range " << i << ": " << topRangeSize << " bytes" << std::endl;
@@ -618,8 +690,8 @@ std::string HashStringAllocator::toString() const {
           std::min<int64_t>(topRangeSize, kHugePageSize));
       auto size = range.size() - simd::kPadding;
 
-      auto end = reinterpret_cast<Header*>(range.data() + size);
-      auto header = reinterpret_cast<Header*>(range.data());
+      auto end = castToHeader(range.data() + size);
+      auto header = castToHeader(range.data());
       while (header != nullptr && header != end) {
         out << "\t" << header->toString() << std::endl;
         header = header->next();
@@ -636,8 +708,8 @@ int64_t HashStringAllocator::checkConsistency() const {
   uint64_t numFree = 0;
   uint64_t freeBytes = 0;
   int64_t allocatedBytes = 0;
-  for (auto i = 0; i < pool_.numRanges(); ++i) {
-    auto topRange = pool_.rangeAt(i);
+  for (auto i = 0; i < state_.pool().numRanges(); ++i) {
+    auto topRange = state_.pool().rangeAt(i);
     auto topRangeSize = topRange.size();
     if (topRangeSize >= kHugePageSize) {
       VELOX_CHECK_EQ(0, topRangeSize % kHugePageSize);
@@ -649,10 +721,10 @@ int64_t HashStringAllocator::checkConsistency() const {
       auto range = folly::Range<char*>(
           topRange.data() + subRangeStart,
           std::min<int64_t>(topRangeSize, kHugePageSize));
-      auto size = range.size() - simd::kPadding;
+      const auto size = range.size() - simd::kPadding;
       bool previousFree = false;
-      auto end = reinterpret_cast<Header*>(range.data() + size);
-      auto header = reinterpret_cast<Header*>(range.data());
+      auto* end = castToHeader(range.data() + size);
+      auto* header = castToHeader(range.data());
       while (header != end) {
         VELOX_CHECK_GE(reinterpret_cast<char*>(header), range.data());
         VELOX_CHECK_LT(
@@ -665,59 +737,60 @@ int64_t HashStringAllocator::checkConsistency() const {
         if (header->isFree()) {
           VELOX_CHECK(!previousFree);
           VELOX_CHECK(!header->isContinued());
-          if (header->next()) {
+          if (header->next() != nullptr) {
             VELOX_CHECK_EQ(
                 header->size(),
                 *(reinterpret_cast<int32_t*>(header->end()) - 1));
           }
           ++numFree;
-          freeBytes += sizeof(Header) + header->size();
+          freeBytes += blockBytes(header);
         } else if (header->isContinued()) {
-          // If the content of the header is continued, check the
-          // continue header is readable and not free.
-          auto continued = header->nextContinued();
+          // If the content of the header is continued, check the continued
+          // header is readable and not free.
+          auto* continued = header->nextContinued();
           VELOX_CHECK(!continued->isFree());
-          allocatedBytes += header->size() - sizeof(void*);
+          allocatedBytes += blockBytes(header);
         } else {
-          allocatedBytes += header->size();
+          allocatedBytes += blockBytes(header);
         }
         previousFree = header->isFree();
-        header = reinterpret_cast<Header*>(header->end());
+        header = castToHeader(header->end());
       }
     }
   }
 
-  VELOX_CHECK_EQ(numFree, numFree_);
-  VELOX_CHECK_EQ(freeBytes, freeBytes_);
+  VELOX_CHECK_EQ(numFree, state_.numFree());
+  VELOX_CHECK_EQ(freeBytes, state_.freeBytes());
   uint64_t numInFreeList = 0;
   uint64_t bytesInFreeList = 0;
   for (auto i = 0; i < kNumFreeLists; ++i) {
-    bool hasData = freeNonEmpty_ & (1 << i);
-    bool listNonEmpty = !free_[i].empty();
+    const bool hasData = bits::isBitSet(state_.freeNonEmpty(), i);
+    const bool listNonEmpty = !state_.freeLists()[i].empty();
     VELOX_CHECK_EQ(hasData, listNonEmpty);
-    for (auto free = free_[i].next(); free != &free_[i]; free = free->next()) {
+    for (auto* free = state_.freeLists()[i].next();
+         free != &state_.freeLists()[i];
+         free = free->next()) {
       ++numInFreeList;
-      auto size = headerOf(free)->size();
-      if (i > 0) {
-        VELOX_CHECK_GE(size, freeListSizes_[i - 1]);
+      VELOX_CHECK(
+          free->next()->previous() == free,
+          "free list previous link inconsistent");
+      const auto size = headerOf(free)->size();
+      VELOX_CHECK_GE(size, kMinAlloc);
+      if (size - kMinAlloc < kNumFreeLists - 1) {
+        VELOX_CHECK_EQ(size - kMinAlloc, i);
+      } else {
+        VELOX_CHECK_GE(size - kMinAlloc, kNumFreeLists - 1);
       }
-      VELOX_CHECK_LT(size, freeListSizes_[i]);
-      bytesInFreeList += size + sizeof(Header);
+      bytesInFreeList += size + kHeaderSize;
     }
   }
 
-  VELOX_CHECK_EQ(numInFreeList, numFree_);
-  VELOX_CHECK_EQ(bytesInFreeList, freeBytes_);
+  VELOX_CHECK_EQ(numInFreeList, state_.numFree());
+  VELOX_CHECK_EQ(bytesInFreeList, state_.freeBytes());
   return allocatedBytes;
 }
 
 bool HashStringAllocator::isEmpty() const {
-  return sizeFromPool_ == 0 && checkConsistency() == 0;
+  return state_.sizeFromPool() == 0 && checkConsistency() == 0;
 }
-
-void HashStringAllocator::checkEmpty() const {
-  VELOX_CHECK_EQ(0, sizeFromPool_);
-  VELOX_CHECK_EQ(0, checkConsistency());
-}
-
 } // namespace facebook::velox
diff --git a/velox/common/memory/HashStringAllocator.h b/velox/common/memory/HashStringAllocator.h
index a7293201168ba..485da69966d76 100644
--- a/velox/common/memory/HashStringAllocator.h
+++ b/velox/common/memory/HashStringAllocator.h
@@ -27,26 +27,26 @@
 
 namespace facebook::velox {
 
-// Implements an arena backed by MappedMemory::Allocation. This is for backing
-// ByteStream or for allocating single blocks. Blocks can be individually freed.
-// Adjacent frees are coalesced and free blocks are kept in a free list.
-// Allocated blocks are prefixed with a Header. This has a size and flags.
-// kContinue means that last 8 bytes are a pointer to another Header after which
-// the contents of this allocation continue. kFree means the block is free. A
-// free block has pointers to the next and previous free block via a
-// CompactDoubleList struct immediately after the header. The last 4 bytes of a
-// free block contain its length. kPreviousFree means that the block immediately
-// below is free. In this case the uint32_t below the header has the size of the
-// previous free block. The last word of a Allocation::PageRun backing a
-// HashStringAllocator is set to kArenaEnd.
+/// Implements an arena backed by memory::Allocation. This is for backing
+/// ByteOutputStream or for allocating single blocks. Blocks can be individually
+/// freed. Adjacent frees are coalesced and free blocks are kept in a free list.
+/// Allocated blocks are prefixed with a Header. This has a size and flags.
+/// kContinue means that last 8 bytes are a pointer to another Header after
+/// which the contents of this allocation continue. kFree means the block is
+/// free. A free block has pointers to the next and previous free block via a
+/// CompactDoubleList struct immediately after the header. The last 4 bytes of a
+/// free block contain its length. kPreviousFree means that the block
+/// immediately below is free. In this case the uint32_t below the header has
+/// the size of the previous free block. The last word of a Allocation::PageRun
+/// backing a HashStringAllocator is set to kArenaEnd.
 class HashStringAllocator : public StreamArena {
  public:
-  // The minimum allocation must have space after the header for the
-  // free list pointers and the trailing length.
+  /// The minimum allocation must have space after the header for the free list
+  /// pointers and the trailing length.
   static constexpr int32_t kMinAlloc =
       sizeof(CompactDoubleList) + sizeof(uint32_t);
 
-  // Sizes larger than this will come direct from 'pool().
+  /// Sizes larger than this will come direct from pool().
   static constexpr int32_t kMaxAlloc =
       memory::AllocationTraits::kPageSize / 4 * 3;
 
@@ -58,12 +58,12 @@ class HashStringAllocator : public StreamArena {
     static constexpr uint32_t kSizeMask = (1U << 29) - 1;
     static constexpr uint32_t kContinuedPtrSize = sizeof(void*);
 
-    // Marker at end of a PageRun. Distinct from valid headers since
-    // all the 3 high bits are set, which is not valid for a header.
+    /// Marker at end of a PageRun. Distinct from valid headers since all the 3
+    /// high bits are set, which is not valid for a header.
     static constexpr uint32_t kArenaEnd = 0xf0aeab0d;
 
     explicit Header(uint32_t size) : data_(size) {
-      VELOX_CHECK(size <= kSizeMask);
+      VELOX_CHECK_LE(size, kSizeMask);
     }
 
     bool isContinued() const {
@@ -115,22 +115,22 @@ class HashStringAllocator : public StreamArena {
     }
 
     void setSize(int32_t size) {
-      VELOX_CHECK(size <= kSizeMask);
+      VELOX_CHECK_LE(size, kSizeMask);
       data_ = size | (data_ & ~kSizeMask);
     }
 
-    char* FOLLY_NONNULL begin() {
+    char* begin() {
       return reinterpret_cast<char*>(this + 1);
     }
 
-    char* FOLLY_NONNULL end() {
+    char* end() {
       return begin() + size();
     }
 
     /// Returns the Header of the block that is physically next to this block or
     /// null if this is the last block of the arena.
-    Header* FOLLY_NULLABLE next() {
-      auto next = reinterpret_cast<Header*>(end());
+    Header* next() {
+      auto* next = castToHeader(end());
       return next->data_ == kArenaEnd ? nullptr : next;
     }
 
@@ -149,8 +149,8 @@ class HashStringAllocator : public StreamArena {
   };
 
   struct Position {
-    Header* FOLLY_NULLABLE header{nullptr};
-    char* FOLLY_NULLABLE position{nullptr};
+    Header* header{nullptr};
+    char* position{nullptr};
 
     int32_t offset() const {
       VELOX_DCHECK_NOT_NULL(header);
@@ -174,60 +174,37 @@ class HashStringAllocator : public StreamArena {
     }
   };
 
-  explicit HashStringAllocator(memory::MemoryPool* FOLLY_NONNULL pool)
-      : StreamArena(pool), pool_(pool) {}
+  explicit HashStringAllocator(memory::MemoryPool* pool)
+      : StreamArena(pool), state_(pool) {}
 
   ~HashStringAllocator();
 
-  // Copies a StringView at 'offset' in 'group' to storage owned by
-  // the hash table. Updates the StringView.
-  void copy(char* FOLLY_NONNULL group, int32_t offset) {
-    StringView* string = reinterpret_cast<StringView*>(group + offset);
-    if (string->isInline()) {
+  // Copies the StringView 'srcStr' to storage owned by 'this'. Creates a new
+  // StringView at 'offset' in 'group' pointing to the copy. A large string may
+  // be copied into non-contiguous allocation pieces. The size in the StringView
+  // is the sum of the sizes. The pieces are linked via Headers, the first
+  // header is below the first byte of the StringView's data. StringViews
+  // written by this are to be read with contiguousString(). This is nearly
+  // always zero copy but will accommodate the odd extra large string.
+  void copyMultipart(const StringView& str, char* group, int32_t offset) {
+    if (str.isInline()) {
+      *reinterpret_cast<StringView*>(group + offset) = str;
       return;
     }
-    auto data = pool_.allocateFixed(string->size());
-    memcpy(data, string->data(), string->size());
-    *string = StringView(data, string->size());
+    copyMultipartNoInline(str, group, offset);
   }
 
-  // Copies a StringView at 'offset' in 'group' to storage owned by
-  // 'this'. Updates the StringView. A large string may be copied into
-  // non-contiguous allocation pieces. The size in the StringView is
-  // the sum of the sizes. The pieces are linked via Headers, the
-  // first header is below the first byte of the StringView's
-  // data. StringViews written by this are to be read with
-  // contiguousString(). This is nearly always zero copy but will
-  // accommodate the odd extra large string.
-  void copyMultipart(char* FOLLY_NONNULL group, int32_t offset) {
-    auto string = reinterpret_cast<StringView*>(group + offset);
-    if (string->isInline()) {
-      return;
-    }
-    auto numBytes = string->size();
-
-    // Write the string as non-contiguous chunks.
-    ByteStream stream(this, false, false);
-    auto position = newWrite(stream, numBytes);
-    stream.appendStringPiece(folly::StringPiece(string->data(), numBytes));
-    finishWrite(stream, 0);
-
-    // The stringView has a pointer to the first byte and the total
-    // size. Read with contiguousString().
-    *string = StringView(reinterpret_cast<char*>(position.position), numBytes);
-  }
-
-  // Returns a contiguous view on 'view', where 'view' comes from
-  // copyMultipart(). Uses 'storage' to own a possible temporary
-  // copy. Making a temporary copy only happens for non-contiguous
-  // strings.
+  /// Returns a contiguous view on 'view', where 'view' comes from
+  /// copyMultipart(). Uses 'storage' to own a possible temporary copy. Making a
+  /// temporary copy only happens for non-contiguous strings.
   static StringView contiguousString(StringView view, std::string& storage);
 
-  // Allocates 'size' contiguous bytes preceded by a Header. Returns
-  // the address of Header.
-  Header* FOLLY_NONNULL allocate(int32_t size) {
-    VELOX_CHECK(
-        !currentHeader_, "Do not call allocate() when a write is in progress");
+  /// Allocates 'size' contiguous bytes preceded by a Header. Returns the
+  /// address of Header.
+  Header* allocate(int32_t size) {
+    VELOX_CHECK_NULL(
+        state_.currentHeader(),
+        "Do not call allocate() when a write is in progress");
     return allocate(std::max(size, kMinAlloc), true);
   }
 
@@ -240,178 +217,181 @@ class HashStringAllocator : public StreamArena {
   /// match.
   void freeToPool(void* ptr, size_t size);
 
-  // Returns the header immediately below 'data'.
-  static Header* FOLLY_NONNULL headerOf(const void* FOLLY_NONNULL data) {
+  /// Returns the header immediately below 'data'.
+  static Header* headerOf(const void* data) {
+    return castToHeader(data) - 1;
+  }
+
+  /// Returns the header below 'data'.
+  static Header* castToHeader(const void* data) {
     return reinterpret_cast<Header*>(
-               const_cast<char*>(reinterpret_cast<const char*>(data))) -
-        1;
+        const_cast<char*>(reinterpret_cast<const char*>(data)));
   }
 
-  // Sets 'stream' to range over the data in the range of 'header' and
-  // possible continuation ranges.
-  static void prepareRead(
-      const Header* FOLLY_NONNULL header,
-      ByteStream& stream);
+  /// Returns the byte size of block pointed by 'header'.
+  inline size_t blockBytes(const Header* header) const {
+    return header->size() + kHeaderSize;
+  }
+
+  /// Returns ByteInputStream over the data in the range of 'header' and
+  /// possible continuation ranges.
+  /// @param maxBytes If provided, the returned stream will cover at most that
+  /// many bytes.
+  static std::unique_ptr<ByteInputStream> prepareRead(
+      const Header* header,
+      size_t maxBytes = std::numeric_limits<size_t>::max());
 
-  // Returns the number of payload bytes between 'header->begin()' and
-  // 'position'.
-  static int64_t offset(Header* FOLLY_NONNULL header, Position position);
+  /// Returns the number of payload bytes between 'header->begin()' and
+  /// 'position'.
+  static int64_t offset(Header* header, Position position);
 
-  // Returns a position 'offset' bytes after 'header->begin()'.
-  static Position seek(Header* FOLLY_NONNULL header, int64_t offset);
+  /// Returns a position 'offset' bytes after 'header->begin()'.
+  static Position seek(Header* header, int64_t offset);
 
-  // Returns the number of bytes that can be written starting at 'position'
-  // without allocating more space.
+  /// Returns the number of bytes that can be written starting at 'position'
+  /// without allocating more space.
   static int64_t available(const Position& position);
 
-  // Ensures that one can write at least 'bytes' data starting at
-  // 'position' without allocating more space. 'position' can be
-  // changed but will logically point at the same data. Data to the
-  // right of 'position is not preserved.
+  /// Ensures that one can write at least 'bytes' data starting at 'position'
+  /// without allocating more space. 'position' can be changed but will
+  /// logically point at the same data. Data to the right of 'position is not
+  /// preserved.
   void ensureAvailable(int32_t bytes, Position& position);
 
-  // Sets stream to write to this pool. The write can span multiple
-  // non-contiguous runs. Each contiguous run will have at least
-  // kMinContiguous bytes of contiguous space. finishWrite finalizes
-  // the allocation information after the write is done.
-  // Returns the position at the start of the allocated block.
-  Position newWrite(ByteStream& stream, int32_t preferredSize = kMinContiguous);
+  /// Sets stream to write to this pool. The write can span multiple
+  /// non-contiguous runs. Each contiguous run will have at least kMinContiguous
+  /// bytes of contiguous space. finishWrite finalizes the allocation
+  /// information after the write is done. Returns the position at the start of
+  /// the allocated block.
+  Position newWrite(
+      ByteOutputStream& stream,
+      int32_t preferredSize = kMinContiguous);
 
   // Sets 'stream' to write starting at 'position'. If new ranges have to
   // be allocated when writing, headers will be updated accordingly.
-  void extendWrite(Position position, ByteStream& stream);
+  void extendWrite(Position position, ByteOutputStream& stream);
 
-  // Completes a write prepared with newWrite or
-  // extendWrite. Up to 'numReserveBytes' unused bytes, if available, are left
-  // after the end of the write to accommodate another write. Returns a pair of
-  // positions: (1) position at the start of this 'write', (2) position
-  // immediately after the last written byte.
+  /// Completes a write prepared with newWrite or extendWrite. Up to
+  /// 'numReserveBytes' unused bytes, if available, are left after the end of
+  /// the write to accommodate another write. Returns a pair of positions: (1)
+  /// position at the start of this 'write', (2) position immediately after the
+  /// last written byte.
   std::pair<Position, Position> finishWrite(
-      ByteStream& stream,
+      ByteOutputStream& stream,
       int32_t numReserveBytes);
 
   /// Allocates a new range for a stream writing to 'this'. Sets the last word
   /// of the previous range to point to the new range and copies the overwritten
-  /// word as the first word of the new range.
+  /// word as the first word of the new range. If 'lastRange' is non-null, we
+  /// are continuing an existing entry and setting the last word  of the
+  /// previous entry point to the new one. In this case, we decrement the size
+  /// in 'lastEntry' by the size of the continue pointer, so that the sum of the
+  /// sizes reflects the payload size without any overheads. Furthermore,
+  /// rewriting a multirange entry is safe because a write spanning multiple
+  /// ranges will not overwrite the next pointer.
   ///
   /// May allocate less than 'bytes'.
-  void newRange(int32_t bytes, ByteRange* FOLLY_NONNULL range) override;
+  void newRange(int32_t bytes, ByteRange* lastRange, ByteRange* range) override;
 
   /// Allocates a new range of at least 'bytes' size.
   void newContiguousRange(int32_t bytes, ByteRange* range);
 
-  void newTinyRange(int32_t bytes, ByteRange* FOLLY_NONNULL range) override {
-    newRange(bytes, range);
+  void newTinyRange(int32_t bytes, ByteRange* lastRange, ByteRange* range)
+      override {
+    newRange(bytes, lastRange, range);
   }
 
-  // Returns the total memory footprint of 'this'.
+  /// Returns the total memory footprint of 'this'.
   int64_t retainedSize() const {
-    return pool_.allocatedBytes() + sizeFromPool_;
+    return state_.pool().allocatedBytes() + state_.sizeFromPool();
   }
 
-  // Adds the allocation of 'header' and any extensions (if header has
-  // kContinued set) to the free list.
-  void free(Header* FOLLY_NONNULL header);
+  /// Adds the allocation of 'header' and any extensions (if header has
+  /// kContinued set) to the free list.
+  void free(Header* header);
 
-  // Returns a lower bound on bytes available without growing
-  // 'this'. This is the sum of free block sizes minus size of pointer
-  // for each. We subtract the pointer because in the worst case we
-  // would have one allocation that chains many small free blocks
-  // together via kContinued.
+  /// Returns a lower bound on bytes available without growing 'this'. This is
+  /// the sum of free block sizes minus size of pointer for each. We subtract
+  /// the pointer because in the worst case we would have one allocation that
+  /// chains many small free blocks together via kContinued.
   uint64_t freeSpace() const {
-    int64_t minFree = freeBytes_ - numFree_ * (sizeof(Header) + sizeof(void*));
+    const int64_t minFree = state_.freeBytes() -
+        state_.numFree() * (kHeaderSize + Header::kContinuedPtrSize);
     VELOX_CHECK_GE(minFree, 0, "Guaranteed free space cannot be negative");
     return minFree;
   }
 
-  // Frees all memory associated with 'this' and leaves 'this' ready for reuse.
-  void clear();
+  /// Frees all memory associated with 'this' and leaves 'this' ready for reuse.
+  void clear() override;
 
-  memory::MemoryPool* FOLLY_NONNULL pool() const {
-    return pool_.pool();
+  memory::MemoryPool* pool() const {
+    return state_.pool().pool();
   }
 
-  uint64_t cumulativeBytes() const {
-    return cumulativeBytes_;
+  uint64_t currentBytes() const {
+    return state_.currentBytes();
   }
 
-  // Returns the starting sizes of free lists. Allocating one of these
-  // sizes will always be fast because all elements of the free list
-  // in question will fit.
-  static folly::Range<const int32_t*> freeListSizeClasses();
-
-  // Checks the free space accounting and consistency of
-  // Headers. Throws when detects corruption. Returns the number of allocated
-  // payload bytes, excluding headers, continue links and other overhead.
+  /// Checks the free space accounting and consistency of Headers. Throws when
+  /// detects corruption. Returns the number of allocated payload bytes,
+  /// excluding headers, continue links and other overhead.
   int64_t checkConsistency() const;
 
   /// Returns 'true' if this is empty. The implementation includes a call to
   /// checkConsistency() which makes it slow. Do not use in hot paths.
   bool isEmpty() const;
 
-  /// Throws if 'this' is not empty. Checks consistency of
-  /// 'this'. This is a fast check for RowContainer users freeing the
-  /// variable length data they store. Can be used in non-debug
-  /// builds.
-  void checkEmpty() const;
+  std::string toString() const;
 
-  // Returns the cumulative number of free list items allocations have looked at
-  // and skipped because too small.
-  int64_t numFreeListNoFit() const {
-    return numFreeListNoFit_;
-  }
+  /// Effectively makes this immutable while executing f, any attempt to access
+  /// state_ in a mutable way while f is executing will cause an exception to be
+  /// thrown.
+  template <typename F>
+  void freezeAndExecute(F&& f) {
+    state_.freeze();
 
-  std::string toString() const;
+    SCOPE_EXIT {
+      state_.unfreeze();
+    };
+
+    f();
+  }
 
  private:
   static constexpr int32_t kUnitSize = 16 * memory::AllocationTraits::kPageSize;
   static constexpr int32_t kMinContiguous = 48;
-  static constexpr int32_t kNumFreeLists = 10;
-
-  // different sizes have different free lists. Sizes below first size
-  // go to freeLists_[0]. Sizes >= freeListSize_[i] go to freeLists_[i
-  // + 1]. The sizes match the size progression for growing F14
-  // containers. Static array of multiple of 8 ints for simd.
-  static int32_t freeListSizes_[HashStringAllocator::kNumFreeLists + 7];
+  static constexpr int32_t kNumFreeLists = kMaxAlloc - kMinAlloc + 2;
+  static constexpr uint32_t kHeaderSize = sizeof(Header);
 
-  // The largest size present in each free list. This is updated when freing and
-  // when failing to find a large enough block in the free list in question.
-  int32_t largestInFreeList_[HashStringAllocator::kNumFreeLists] = {};
-
-  void newRange(int32_t bytes, ByteRange* range, bool contiguous);
+  void newRange(
+      int32_t bytes,
+      ByteRange* lastRange,
+      ByteRange* range,
+      bool contiguous);
 
   // Adds a new standard size slab to the free list. This
   // grows the footprint in MemoryAllocator but does not allocate
   // anything yet. Throws if fails to grow.
   void newSlab();
 
-  void removeFromFreeList(Header* FOLLY_NONNULL header) {
-    VELOX_CHECK(header->isFree());
-    header->clearFree();
-    auto index = freeListIndex(header->size());
-    reinterpret_cast<CompactDoubleList*>(header->begin())->remove();
-    if (free_[index].empty()) {
-      freeNonEmpty_ &= ~(1 << index);
-    }
-  }
+  void removeFromFreeList(Header* header);
+
+  // Allocates a block of specified size. If exactSize is false, the block may
+  // be smaller or larger. Checks free list before allocating new memory.
+  Header* allocate(int32_t size, bool exactSize);
 
-  /// Allocates a block of specified size. If exactSize is false, the block may
-  /// be smaller or larger. Checks free list before allocating new memory.
-  Header* FOLLY_NULLABLE allocate(int32_t size, bool exactSize);
-
-  // Allocates memory from free list. Returns nullptr if no memory in
-  // free list, otherwise returns a header of a free block of some
-  // size. if 'mustHaveSize' is true, the block will not be smaller
-  // than 'preferredSize'. If 'isFinalSize' is true, this will not
-  // return a block that is much larger than preferredSize. Otherwise,
-  // the block can be larger and the user is expected to call
-  // freeRestOfBlock to finalize the allocation.
-  Header* FOLLY_NULLABLE allocateFromFreeLists(
+  // Allocates memory from free list. Returns nullptr if no memory in free list,
+  // otherwise returns a header of a free block of some size. if 'mustHaveSize'
+  // is true, the block will not be smaller than 'preferredSize'. If
+  // 'isFinalSize' is true, this will not return a block that is much larger
+  // than preferredSize. Otherwise, the block can be larger and the user is
+  // expected to call freeRestOfBlock to finalize the allocation.
+  Header* allocateFromFreeLists(
       int32_t preferredSize,
       bool mustHaveSize,
       bool isFinalSize);
 
-  Header* FOLLY_NULLABLE allocateFromFreeList(
+  Header* allocateFromFreeList(
       int32_t preferredSize,
       bool mustHaveSize,
       bool isFinalSize,
@@ -420,68 +400,138 @@ class HashStringAllocator : public StreamArena {
   // Sets 'header' to be 'keepBytes' long and adds the remainder of
   // 'header's memory to free list. Does nothing if the resulting
   // blocks would be below minimum size.
-  void freeRestOfBlock(Header* FOLLY_NONNULL header, int32_t keepBytes);
+  void freeRestOfBlock(Header* header, int32_t keepBytes);
 
-  // Returns the free list index for 'size'. Masks out empty sizes that can be
-  // given by 'mask'. If 'mask' excludes all free lists, returns >
-  // kNumFreeLists.
-  int32_t freeListIndex(int32_t size, uint32_t mask = ~0);
+  void
+  copyMultipartNoInline(const StringView& str, char* group, int32_t offset);
 
-  // Circular list of free blocks.
-  CompactDoubleList free_[kNumFreeLists];
+  // Fast path for storing a string as a single part. Returns true if succeeded,
+  // has no effect if returns false.
+  bool storeStringFast(const char* bytes, int32_t size, char* destination);
 
-  // Bitmap with a 1 if the corresponding list in 'free_' is not empty.
-  int32_t freeNonEmpty_{0};
+  // Returns the free list index for 'size'.
+  int32_t freeListIndex(int size);
+
+  /// A class that wraps any fields in the HashStringAllocator, it's main
+  /// purpose is to simplify the freeze/unfreeze mechanic.  Fields are exposed
+  /// via accessor methods, attempting to invoke a non-const accessor when the
+  /// HashStringAllocator is frozen will cause an exception to be thrown.
+  class State {
+   public:
+    explicit State(memory::MemoryPool* pool) : pool_(pool) {}
+
+    void freeze() {
+      VELOX_CHECK(
+          mutable_,
+          "Attempting to freeze an already frozen HashStringAllocator.");
+      mutable_ = false;
+    }
+
+    void unfreeze() {
+      VELOX_CHECK(
+          !mutable_,
+          "Attempting to unfreeze an already unfrozen HashStringAllocator.");
+      mutable_ = true;
+    }
+
+   private:
+// Every field has two accessors, one that returns a reference and one that
+// returns a const reference.  The one that returns a reference ensures that the
+// HashStringAllocator isn't frozen first.
+#define DECLARE_GETTERS(TYPE, NAME) \
+ public:                            \
+  inline TYPE& NAME() {             \
+    assertMutability();             \
+    return NAME##_;                 \
+  }                                 \
+                                    \
+  inline TYPE const& NAME() const { \
+    return NAME##_;                 \
+  }
 
-  // Count of elements in 'free_'. This is 0 when all free_[i].next() ==
-  // &free_[i].
-  uint64_t numFree_ = 0;
+// Declare a default initialized field.
+#define DECLARE_FIELD(TYPE, NAME) \
+  DECLARE_GETTERS(TYPE, NAME)     \
+                                  \
+ private:                         \
+  TYPE NAME##_;
 
-  // Sum of the size of blocks in 'free_', excluding headers.
-  uint64_t freeBytes_ = 0;
+// Declare a field initialized with a specific value.
+#define DECLARE_FIELD_WITH_INIT_VALUE(TYPE, NAME, VALUE) \
+  DECLARE_GETTERS(TYPE, NAME)                            \
+                                                         \
+ private:                                                \
+  TYPE NAME##_{VALUE};
 
-  // Counter of allocated bytes. The difference of two point in time values
-  // tells how much memory has been consumed by activity between these points in
-  // time. Incremented by allocation and decremented by free. Used for tracking
-  // the row by row space usage in a RowContainer.
-  uint64_t cumulativeBytes_{0};
+    typedef CompactDoubleList FreeList[kNumFreeLists];
+    typedef uint64_t FreeNonEmptyBitMap[bits::nwords(kNumFreeLists)];
+    typedef folly::F14FastMap<void*, size_t> AllocationsFromPool;
 
-  // Pointer to Header for the range being written. nullptr if a write is not in
-  // progress.
-  Position startPosition_;
-  Header* FOLLY_NULLABLE currentHeader_ = nullptr;
+    // Circular list of free blocks.
+    DECLARE_FIELD(FreeList, freeLists);
 
-  // Pool for getting new slabs.
-  memory::AllocationPool pool_;
+    // Bitmap with a 1 if the corresponding list in 'free_' is not empty.
+    DECLARE_FIELD_WITH_INIT_VALUE(FreeNonEmptyBitMap, freeNonEmpty, {});
 
-  // Map from pointer to size for large blocks allocated from pool().
-  folly::F14FastMap<void*, size_t> allocationsFromPool_;
+    // Count of elements in 'free_'. This is 0 when all free_[i].next() ==
+    // &free_[i].
+    DECLARE_FIELD_WITH_INIT_VALUE(uint64_t, numFree, 0);
 
-  // Sum of sizes in 'allocationsFromPool_'.
-  int64_t sizeFromPool_{0};
+    // Sum of the size of blocks in 'free_', excluding headers.
+    DECLARE_FIELD_WITH_INIT_VALUE(uint64_t, freeBytes, 0);
 
-  // Count of times a free list item was skipped because it did not fit
-  // requested size.
-  int64_t numFreeListNoFit_{0};
+    // Counter of allocated bytes. The difference of two point in time values
+    // tells how much memory has been consumed by activity between these points
+    // in time. Incremented by allocation and decremented by free. Used for
+    // tracking the row by row space usage in a RowContainer.
+    DECLARE_FIELD_WITH_INIT_VALUE(uint64_t, currentBytes, 0);
+
+    // Pointer to Header for the range being written. nullptr if a write is not
+    // in progress.
+    DECLARE_FIELD(Position, startPosition);
+    DECLARE_FIELD_WITH_INIT_VALUE(Header*, currentHeader, nullptr);
+
+    // Pool for getting new slabs.
+    DECLARE_FIELD(memory::AllocationPool, pool);
+
+    // Map from pointer to size for large blocks allocated from pool().
+    DECLARE_FIELD(AllocationsFromPool, allocationsFromPool);
+
+    // Sum of sizes in 'allocationsFromPool_'.
+    DECLARE_FIELD_WITH_INIT_VALUE(int64_t, sizeFromPool, 0);
+
+#undef DECLARE_FIELD_WITH_INIT_VALUE
+#undef DECLARE_FIELD
+#undef DECLARE_GETTERS
+
+    void assertMutability() const {
+      VELOX_CHECK(mutable_, "The HashStringAllocator is immutable.");
+    }
+
+    tsan_atomic<bool> mutable_ = true;
+  };
+
+  // This should be the only field in HashStringAllocator, any additional fields
+  // should be added as private members of State exposed through accessors.
+  State state_;
 };
 
-// Utility for keeping track of allocation between two points in
-// time. A counter on a row supplied at construction is incremented
-// by the change in allocation between construction and
-// destruction. This is a scoped guard to use around setting
-// variable length data in a RowContainer or similar.
+/// Utility for keeping track of allocation between two points in time. A
+/// counter on a row supplied at construction is incremented by the change in
+/// allocation between construction and destruction. This is a scoped guard to
+/// use around setting variable length data in a RowContainer or similar.
 template <typename T, typename TCounter = uint32_t>
 class RowSizeTracker {
  public:
-  //  Will update the counter at pointer cast to TCounter*
-  //  with the change in allocation during the lifetime of 'this'
+  ///  Will update the counter at pointer cast to TCounter* with the change in
+  ///  allocation during the lifetime of 'this'
   RowSizeTracker(T& counter, HashStringAllocator& allocator)
-      : allocator_(allocator),
-        size_(allocator_.cumulativeBytes()),
+      : allocator_(&allocator),
+        size_(allocator_->currentBytes()),
         counter_(counter) {}
 
   ~RowSizeTracker() {
-    auto delta = allocator_.cumulativeBytes() - size_;
+    auto delta = allocator_->currentBytes() - size_;
     if (delta) {
       saturatingIncrement(&counter_, delta);
     }
@@ -489,23 +539,23 @@ class RowSizeTracker {
 
  private:
   // Increments T at *pointer without wrapping around at overflow.
-  void saturatingIncrement(T* FOLLY_NONNULL pointer, int64_t delta) {
+  void saturatingIncrement(T* pointer, int64_t delta) {
     auto value = *reinterpret_cast<TCounter*>(pointer) + delta;
     *reinterpret_cast<TCounter*>(pointer) =
         std::min<uint64_t>(value, std::numeric_limits<TCounter>::max());
   }
 
-  HashStringAllocator& allocator_;
+  HashStringAllocator* const allocator_;
   const uint64_t size_;
   T& counter_;
 };
 
-// An Allocator based by HashStringAllocator to use with STL containers.
+/// An Allocator based by HashStringAllocator to use with STL containers.
 template <class T>
 struct StlAllocator {
   using value_type = T;
 
-  explicit StlAllocator(HashStringAllocator* FOLLY_NONNULL allocator)
+  explicit StlAllocator(HashStringAllocator* allocator)
       : allocator_{allocator} {
     VELOX_CHECK(allocator);
   }
@@ -516,7 +566,7 @@ struct StlAllocator {
     VELOX_CHECK_NOT_NULL(allocator_);
   }
 
-  T* FOLLY_NONNULL allocate(std::size_t n) {
+  T* allocate(std::size_t n) {
     if (n * sizeof(T) > HashStringAllocator::kMaxAlloc) {
       return reinterpret_cast<T*>(allocator_->allocateFromPool(n * sizeof(T)));
     }
@@ -524,14 +574,14 @@ struct StlAllocator {
         allocator_->allocate(checkedMultiply(n, sizeof(T)))->begin());
   }
 
-  void deallocate(T* FOLLY_NONNULL p, std::size_t n) noexcept {
+  void deallocate(T* p, std::size_t n) noexcept {
     if (n * sizeof(T) > HashStringAllocator::kMaxAlloc) {
       return allocator_->freeToPool(p, n * sizeof(T));
     }
     allocator_->free(HashStringAllocator::headerOf(p));
   }
 
-  HashStringAllocator* FOLLY_NONNULL allocator() const {
+  HashStringAllocator* allocator() const {
     return allocator_;
   }
 
@@ -544,12 +594,12 @@ struct StlAllocator {
   }
 
  private:
-  HashStringAllocator* FOLLY_NONNULL allocator_;
+  HashStringAllocator* allocator_;
 };
 
-// An allocator backed by HashStringAllocator that guaratees a configurable
-// alignment. The alignment must be a power of 2 and not be 0. This allocator
-// can be used with folly F14 containers that requires 16-bytes alignment.
+/// An allocator backed by HashStringAllocator that guaratees a configurable
+/// alignment. The alignment must be a power of 2 and not be 0. This allocator
+/// can be used with folly F14 containers that requires 16-bytes alignment.
 template <class T, uint8_t Alignment>
 struct AlignedStlAllocator {
   using value_type = T;
@@ -566,7 +616,7 @@ struct AlignedStlAllocator {
     using other = AlignedStlAllocator<Other, Alignment>;
   };
 
-  explicit AlignedStlAllocator(HashStringAllocator* FOLLY_NONNULL allocator)
+  explicit AlignedStlAllocator(HashStringAllocator* allocator)
       : allocator_{allocator},
         poolAligned_(allocator_->pool()->alignment() >= Alignment) {
     VELOX_CHECK(allocator);
@@ -579,37 +629,43 @@ struct AlignedStlAllocator {
     VELOX_CHECK(allocator_);
   }
 
-  T* FOLLY_NONNULL allocate(std::size_t n) {
-    if (n * sizeof(T) > HashStringAllocator::kMaxAlloc && poolAligned_) {
-      return reinterpret_cast<T*>(allocator_->allocateFromPool(n * sizeof(T)));
+  T* allocate(std::size_t n) {
+    if (n * sizeof(T) > HashStringAllocator::kMaxAlloc) {
+      if (poolAligned_) {
+        return reinterpret_cast<T*>(
+            allocator_->allocateFromPool(n * sizeof(T)));
+      } else {
+        auto paddedSize = calculatePaddedSize(n);
+        // Allocate the memory from pool directly.
+        auto ptr =
+            reinterpret_cast<T*>(allocator_->allocateFromPool(paddedSize));
+
+        return alignPtr((char*)ptr, n, paddedSize);
+      }
     }
-    // Allocate extra Alignment bytes for alignment and 4 bytes to store the
-    // delta between unaligned and aligned pointers.
-    auto size =
-        checkedPlus<size_t>(Alignment + 4, checkedMultiply(n, sizeof(T)));
-    auto ptr = reinterpret_cast<T*>(allocator_->allocate(size)->begin());
 
-    // Align 'ptr + 4'.
-    void* alignedPtr = (char*)ptr + 4;
-    size -= 4;
-    std::align(Alignment, n * sizeof(T), alignedPtr, size);
+    auto paddedSize = calculatePaddedSize(n);
+    auto ptr = reinterpret_cast<T*>(allocator_->allocate(paddedSize)->begin());
 
-    // Write alignment delta just before the aligned pointer.
-    int32_t delta = (char*)alignedPtr - (char*)ptr - 4;
-    *reinterpret_cast<int32_t*>((char*)alignedPtr - 4) = delta;
-
-    return reinterpret_cast<T*>(alignedPtr);
+    return alignPtr((char*)ptr, n, paddedSize);
   }
 
-  void deallocate(T* FOLLY_NONNULL p, std::size_t n) noexcept {
+  void deallocate(T* p, std::size_t n) noexcept {
     if (n * sizeof(T) > HashStringAllocator::kMaxAlloc) {
-      return allocator_->freeToPool(p, n * sizeof(T));
+      if (poolAligned_) {
+        return allocator_->freeToPool(p, n * sizeof(T));
+      } else {
+        auto delta = *reinterpret_cast<int32_t*>((char*)p - 4);
+        return allocator_->freeToPool(
+            (char*)p - 4 - delta, calculatePaddedSize(n));
+      }
     }
+
     auto delta = *reinterpret_cast<int32_t*>((char*)p - 4);
     allocator_->free(HashStringAllocator::headerOf((char*)p - 4 - delta));
   }
 
-  HashStringAllocator* FOLLY_NONNULL allocator() const {
+  HashStringAllocator* allocator() const {
     return allocator_;
   }
 
@@ -626,7 +682,30 @@ struct AlignedStlAllocator {
   }
 
  private:
-  HashStringAllocator* FOLLY_NONNULL allocator_;
+  // Pad the memory user requested by some padding to facilitate memory
+  // alignment later. Memory layout:
+  // - padding(length is stored in `delta`)
+  // - delta(4 bytes storing the size of padding)
+  // - the aligned ptr
+  FOLLY_ALWAYS_INLINE std::size_t calculatePaddedSize(std::size_t n) {
+    return checkedPlus<size_t>(Alignment + 4, checkedMultiply(n, sizeof(T)));
+  }
+
+  FOLLY_ALWAYS_INLINE T*
+  alignPtr(char* ptr, std::size_t allocateCount, std::size_t& paddedSize) {
+    // Align 'ptr + 4'.
+    void* alignedPtr = ptr + 4;
+    paddedSize -= 4;
+    std::align(Alignment, allocateCount * sizeof(T), alignedPtr, paddedSize);
+
+    // Write alignment delta just before the aligned pointer.
+    int32_t delta = (char*)alignedPtr - ptr - 4;
+    *reinterpret_cast<int32_t*>((char*)alignedPtr - 4) = delta;
+
+    return reinterpret_cast<T*>(alignedPtr);
+  }
+
+  HashStringAllocator* allocator_;
   const bool poolAligned_;
 };
 
diff --git a/velox/common/memory/MallocAllocator.cpp b/velox/common/memory/MallocAllocator.cpp
index c8cdb42ca6d7c..ff44791763ace 100644
--- a/velox/common/memory/MallocAllocator.cpp
+++ b/velox/common/memory/MallocAllocator.cpp
@@ -20,100 +20,99 @@
 #include <sys/mman.h>
 
 namespace facebook::velox::memory {
-MallocAllocator::MallocAllocator(size_t capacity)
-    : kind_(MemoryAllocator::Kind::kMalloc), capacity_(capacity) {}
+MallocAllocator::MallocAllocator(size_t capacity, uint32_t reservationByteLimit)
+    : kind_(MemoryAllocator::Kind::kMalloc),
+      capacity_(capacity),
+      reservationByteLimit_(reservationByteLimit),
+      reserveFunc_(
+          [this](uint32_t& counter, uint32_t increment, std::mutex& lock) {
+            return incrementUsageWithReservationFunc(counter, increment, lock);
+          }),
+      releaseFunc_(
+          [&](uint32_t& counter, uint32_t decrement, std::mutex& lock) {
+            decrementUsageWithReservationFunc(counter, decrement, lock);
+            return true;
+          }),
+      reservations_(std::thread::hardware_concurrency()) {}
+
+MallocAllocator::~MallocAllocator() {
+  // TODO: Remove the check when memory leak issue is resolved.
+  if (FLAGS_velox_memory_leak_check_enabled) {
+    VELOX_CHECK(
+        ((allocatedBytes_ - reservations_.read()) == 0) &&
+            (numAllocated_ == 0) && (numMapped_ == 0),
+        "{}",
+        toString());
+  }
+}
 
 bool MallocAllocator::allocateNonContiguousWithoutRetry(
-    MachinePageCount numPages,
-    Allocation& out,
-    ReservationCallback reservationCB,
-    MachinePageCount minSizeClass) {
-  const uint64_t freedBytes = freeNonContiguous(out);
-  if (numPages == 0) {
-    if (freedBytes != 0 && reservationCB != nullptr) {
-      reservationCB(freedBytes, false);
-    }
+    const SizeMix& sizeMix,
+    Allocation& out) {
+  freeNonContiguous(out);
+  if (sizeMix.totalPages == 0) {
     return true;
   }
-  const SizeMix mix = allocationSize(numPages, minSizeClass);
-  const auto totalBytes = AllocationTraits::pageBytes(mix.totalPages);
-  if (!incrementUsage(totalBytes)) {
-    if (freedBytes != 0 && reservationCB != nullptr) {
-      reservationCB(freedBytes, false);
-    }
+  const auto totalBytes = AllocationTraits::pageBytes(sizeMix.totalPages);
+  if (testingHasInjectedFailure(InjectedFailure::kCap) ||
+      !incrementUsage(totalBytes)) {
+    const auto errorMsg = fmt::format(
+        "Exceeded memory allocator limit when allocating {} new pages"
+        ", the memory allocator capacity is {}",
+        sizeMix.totalPages,
+        succinctBytes(capacity_));
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
     return false;
   }
 
-  uint64_t bytesToAllocate = 0;
-  if (reservationCB != nullptr) {
-    bytesToAllocate = AllocationTraits::pageBytes(mix.totalPages) - freedBytes;
-    try {
-      reservationCB(bytesToAllocate, true);
-    } catch (std::exception& e) {
-      VELOX_MEM_LOG(WARNING)
-          << "Failed to reserve " << succinctBytes(bytesToAllocate)
-          << " for non-contiguous allocation of " << numPages
-          << " pages, then release " << succinctBytes(freedBytes)
-          << " from the old allocation";
-      // If the new memory reservation fails, we need to release the memory
-      // reservation of the freed memory of previously allocation.
-      reservationCB(freedBytes, false);
-      decrementUsage(totalBytes);
-      std::rethrow_exception(std::current_exception());
-    }
-  }
-
-  std::vector<void*> pages;
-  pages.reserve(mix.numSizes);
-  for (int32_t i = 0; i < mix.numSizes; ++i) {
-    // Trigger allocation failure by breaking out the loop.
-    if (testingHasInjectedFailure(InjectedFailure::kAllocate)) {
-      break;
-    }
+  std::vector<void*> buffers;
+  buffers.reserve(sizeMix.numSizes);
+  for (int32_t i = 0; i < sizeMix.numSizes; ++i) {
     MachinePageCount numSizeClassPages =
-        mix.sizeCounts[i] * sizeClassSizes_[mix.sizeIndices[i]];
-    void* ptr;
-    stats_.recordAllocate(
-        AllocationTraits::pageBytes(sizeClassSizes_[mix.sizeIndices[i]]),
-        mix.sizeCounts[i],
-        [&]() {
-          ptr = ::malloc(
-              AllocationTraits::pageBytes(numSizeClassPages)); // NOLINT
-        });
+        sizeMix.sizeCounts[i] * sizeClassSizes_[sizeMix.sizeIndices[i]];
+    void* ptr = nullptr;
+    // Trigger allocation failure by skipping malloc
+    if (!testingHasInjectedFailure(InjectedFailure::kAllocate)) {
+      stats_.recordAllocate(
+          AllocationTraits::pageBytes(sizeClassSizes_[sizeMix.sizeIndices[i]]),
+          sizeMix.sizeCounts[i],
+          [&]() {
+            ptr = ::malloc(
+                AllocationTraits::pageBytes(numSizeClassPages)); // NOLINT
+          });
+    }
     if (ptr == nullptr) {
       // Failed to allocate memory from memory.
+      const auto errorMsg = fmt::format(
+          "Malloc failed to allocate {} of memory while allocating for "
+          "non-contiguous allocation of {} pages",
+          succinctBytes(AllocationTraits::pageBytes(numSizeClassPages)),
+          sizeMix.totalPages);
+      VELOX_MEM_LOG(WARNING) << errorMsg;
+      setAllocatorFailureMessage(errorMsg);
       break;
     }
-    pages.emplace_back(ptr);
+    buffers.push_back(ptr);
     out.append(reinterpret_cast<uint8_t*>(ptr), numSizeClassPages); // NOLINT
   }
 
-  if (pages.size() != mix.numSizes) {
+  if (buffers.size() != sizeMix.numSizes) {
     // Failed to allocate memory using malloc. Free any malloced pages and
     // return false.
-    for (auto ptr : pages) {
-      ::free(ptr);
+    for (auto* buffer : buffers) {
+      ::free(buffer);
     }
     out.clear();
-    if (reservationCB != nullptr) {
-      VELOX_MEM_LOG(WARNING)
-          << "Failed to allocate memory for non-contiguous allocation of "
-          << numPages << " pages, then release "
-          << succinctBytes(bytesToAllocate + freedBytes)
-          << " of memory reservation including the old allocation";
-      reservationCB(bytesToAllocate + freedBytes, false);
-    }
+    VELOX_MEM_LOG(WARNING)
+        << "Failed to allocate memory for non-contiguous allocation of "
+        << sizeMix.totalPages << " pages";
     decrementUsage(totalBytes);
     return false;
   }
 
-  {
-    std::lock_guard<std::mutex> l(mallocsMutex_);
-    mallocs_.insert(pages.begin(), pages.end());
-  }
-
   // Successfully allocated all pages.
-  numAllocated_.fetch_add(mix.totalPages);
+  numAllocated_.fetch_add(sizeMix.totalPages);
   return true;
 }
 
@@ -121,12 +120,10 @@ bool MallocAllocator::allocateContiguousWithoutRetry(
     MachinePageCount numPages,
     Allocation* collateral,
     ContiguousAllocation& allocation,
-    ReservationCallback reservationCB,
     MachinePageCount maxPages) {
   bool result;
   stats_.recordAllocate(AllocationTraits::pageBytes(numPages), 1, [&]() {
-    result = allocateContiguousImpl(
-        numPages, collateral, allocation, reservationCB, maxPages);
+    result = allocateContiguousImpl(numPages, collateral, allocation, maxPages);
   });
   return result;
 }
@@ -135,17 +132,14 @@ bool MallocAllocator::allocateContiguousImpl(
     MachinePageCount numPages,
     Allocation* collateral,
     ContiguousAllocation& allocation,
-    ReservationCallback reservationCB,
     MachinePageCount maxPages) {
   if (maxPages == 0) {
     maxPages = numPages;
   } else {
     VELOX_CHECK_LE(numPages, maxPages);
   }
-  MachinePageCount numCollateralPages = 0;
   if (collateral != nullptr) {
-    numCollateralPages =
-        freeNonContiguous(*collateral) / AllocationTraits::kPageSize;
+    freeNonContiguous(*collateral);
   }
   auto numContiguousCollateralPages = allocation.numPages();
   if (numContiguousCollateralPages > 0) {
@@ -159,41 +153,22 @@ bool MallocAllocator::allocateContiguousImpl(
     decrementUsage(AllocationTraits::pageBytes(numContiguousCollateralPages));
     allocation.clear();
   }
-  const auto totalCollateralPages =
-      numCollateralPages + numContiguousCollateralPages;
-  const auto totalCollateralBytes =
-      AllocationTraits::pageBytes(totalCollateralPages);
   if (numPages == 0) {
-    if (totalCollateralBytes != 0 && reservationCB != nullptr) {
-      reservationCB(totalCollateralBytes, false);
-    }
     return true;
   }
 
   const auto totalBytes = AllocationTraits::pageBytes(numPages);
-  if (!incrementUsage(totalBytes)) {
-    if (totalCollateralBytes != 0 && reservationCB != nullptr) {
-      reservationCB(totalCollateralBytes, false);
-    }
+  if (testingHasInjectedFailure(InjectedFailure::kCap) ||
+      !incrementUsage(totalBytes)) {
+    const auto errorMsg = fmt::format(
+        "Exceeded memory allocator limit when allocating {} new pages, the "
+        "memory allocator capacity is {}",
+        numPages,
+        succinctBytes(capacity_));
+    setAllocatorFailureMessage(errorMsg);
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
     return false;
   }
-  const int64_t numNeededPages = numPages - totalCollateralPages;
-  if (reservationCB != nullptr) {
-    try {
-      reservationCB(AllocationTraits::pageBytes(numNeededPages), true);
-    } catch (std::exception& e) {
-      // If the new memory reservation fails, we need to release the memory
-      // reservation of the freed contiguous and non-contiguous memory.
-      VELOX_MEM_LOG(WARNING)
-          << "Failed to reserve " << AllocationTraits::pageBytes(numNeededPages)
-          << " bytes for contiguous allocation of " << numPages
-          << " pages, then release " << succinctBytes(totalCollateralBytes)
-          << " from the old allocations";
-      reservationCB(totalCollateralBytes, false);
-      decrementUsage(totalBytes);
-      std::rethrow_exception(std::current_exception());
-    }
-  }
   numAllocated_.fetch_add(numPages);
   numMapped_.fetch_add(numPages);
   void* data = ::mmap(
@@ -216,28 +191,20 @@ int64_t MallocAllocator::freeNonContiguous(Allocation& allocation) {
   if (allocation.empty()) {
     return 0;
   }
-  MachinePageCount numFreed = 0;
+  MachinePageCount freedPages{0};
   for (int32_t i = 0; i < allocation.numRuns(); ++i) {
     Allocation::PageRun run = allocation.runAt(i);
-    numFreed += run.numPages();
     void* ptr = run.data();
-    {
-      std::lock_guard<std::mutex> l(mallocsMutex_);
-      const auto ret = mallocs_.erase(ptr);
-      VELOX_CHECK_EQ(ret, 1, "Bad free page pointer: {}", ptr);
-    }
-    stats_.recordFree(
-        std::min<int64_t>(
-            AllocationTraits::pageBytes(sizeClassSizes_.back()),
-            AllocationTraits::pageBytes(run.numPages())),
-        [&]() {
-          ::free(ptr); // NOLINT
-        });
+    const int64_t numPages = run.numPages();
+    freedPages += numPages;
+    stats_.recordFree(AllocationTraits::pageBytes(numPages), [&]() {
+      ::free(ptr); // NOLINT
+    });
   }
 
-  const auto freedBytes = AllocationTraits::pageBytes(numFreed);
+  const auto freedBytes = AllocationTraits::pageBytes(freedPages);
   decrementUsage(freedBytes);
-  numAllocated_.fetch_sub(numFreed);
+  numAllocated_.fetch_sub(freedPages);
   allocation.clear();
   return freedBytes;
 }
@@ -267,19 +234,16 @@ void MallocAllocator::freeContiguousImpl(ContiguousAllocation& allocation) {
 
 bool MallocAllocator::growContiguousWithoutRetry(
     MachinePageCount increment,
-    ContiguousAllocation& allocation,
-    ReservationCallback reservationCB) {
-  VELOX_CHECK_LE(
-      allocation.size() + increment * AllocationTraits::kPageSize,
-      allocation.maxSize());
-  if (reservationCB != nullptr) {
-    // May throw. If does, there is nothing to revert.
-    reservationCB(AllocationTraits::pageBytes(increment), true);
-  }
+    ContiguousAllocation& allocation) {
   if (!incrementUsage(AllocationTraits::pageBytes(increment))) {
-    if (reservationCB != nullptr) {
-      reservationCB(AllocationTraits::pageBytes(increment), false);
-    }
+    const auto errorMsg = fmt::format(
+        "Exceeded memory allocator limit when allocating {} new pages for "
+        "total allocation of {} pages, the memory allocator capacity is {}",
+        increment,
+        allocation.numPages(),
+        succinctBytes(capacity_));
+    setAllocatorFailureMessage(errorMsg);
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
     return false;
   }
   numAllocated_ += increment;
@@ -295,6 +259,13 @@ void* MallocAllocator::allocateBytesWithoutRetry(
     uint64_t bytes,
     uint16_t alignment) {
   if (!incrementUsage(bytes)) {
+    auto errorMsg = fmt::format(
+        "Failed to allocateBytes {}: Exceeded memory allocator "
+        "limit of {}",
+        succinctBytes(bytes),
+        succinctBytes(capacity_));
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
     return nullptr;
   }
   if (!isAlignmentValid(bytes, alignment)) {
@@ -315,6 +286,13 @@ void* MallocAllocator::allocateBytesWithoutRetry(
 
 void* MallocAllocator::allocateZeroFilledWithoutRetry(uint64_t bytes) {
   if (!incrementUsage(bytes)) {
+    auto errorMsg = fmt::format(
+        "Failed to allocateZeroFilled {}: Exceeded memory allocator "
+        "limit of {}",
+        succinctBytes(bytes),
+        succinctBytes(capacity_));
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
     return nullptr;
   }
   void* result = std::calloc(1, bytes);
diff --git a/velox/common/memory/MallocAllocator.h b/velox/common/memory/MallocAllocator.h
index 0b5adb0a8d653..ade9536f0fb6b 100644
--- a/velox/common/memory/MallocAllocator.h
+++ b/velox/common/memory/MallocAllocator.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/base/ConcurrentCounter.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/common/memory/MemoryAllocator.h"
 
@@ -25,17 +26,9 @@ namespace facebook::velox::memory {
 /// The implementation of MemoryAllocator using malloc.
 class MallocAllocator : public MemoryAllocator {
  public:
-  explicit MallocAllocator(size_t capacity);
-
-  ~MallocAllocator() override {
-    // TODO: Remove the check when memory leak issue is resolved.
-    if (FLAGS_velox_memory_leak_check_enabled) {
-      VELOX_CHECK(
-          (allocatedBytes_ == 0) && (numAllocated_ == 0) && (numMapped_ == 0),
-          "{}",
-          toString());
-    }
-  }
+  MallocAllocator(size_t capacity, uint32_t reservationByteLimit);
+
+  ~MallocAllocator() override;
 
   void registerCache(const std::shared_ptr<Cache>& cache) override {
     VELOX_CHECK_NULL(cache_);
@@ -62,13 +55,18 @@ class MallocAllocator : public MemoryAllocator {
 
   bool growContiguousWithoutRetry(
       MachinePageCount increment,
-      ContiguousAllocation& allocation,
-      ReservationCallback reservationCB = nullptr) override;
+      ContiguousAllocation& allocation) override;
 
   void freeBytes(void* p, uint64_t bytes) noexcept override;
 
+  MachinePageCount unmap(MachinePageCount targetPages) override {
+    // NOTE: MallocAllocator doesn't support unmap as it delegates all the
+    // memory allocations to std::malloc.
+    return 0;
+  }
+
   size_t totalUsedBytes() const override {
-    return allocatedBytes_;
+    return allocatedBytes_ - reservations_.read();
   }
 
   MachinePageCount numAllocated() const override {
@@ -85,23 +83,19 @@ class MallocAllocator : public MemoryAllocator {
 
  private:
   bool allocateNonContiguousWithoutRetry(
-      MachinePageCount numPages,
-      Allocation& out,
-      ReservationCallback reservationCB = nullptr,
-      MachinePageCount minSizeClass = 0) override;
+      const SizeMix& sizeMix,
+      Allocation& out) override;
 
   bool allocateContiguousWithoutRetry(
       MachinePageCount numPages,
-      Allocation* FOLLY_NULLABLE collateral,
+      Allocation* collateral,
       ContiguousAllocation& allocation,
-      ReservationCallback reservationCB = nullptr,
       MachinePageCount maxPages = 0) override;
 
   bool allocateContiguousImpl(
       MachinePageCount numPages,
-      Allocation* FOLLY_NULLABLE collateral,
+      Allocation* collateral,
       ContiguousAllocation& allocation,
-      ReservationCallback reservationCB,
       MachinePageCount maxPages);
 
   void freeContiguousImpl(ContiguousAllocation& allocation);
@@ -110,13 +104,52 @@ class MallocAllocator : public MemoryAllocator {
 
   void* allocateZeroFilledWithoutRetry(uint64_t bytes) override;
 
-  /// Increment current usage and check current allocator consistency to make
-  /// sure current usage does not go above 'capacity_'. If it goes above
-  /// 'capacity_', the increment will not be applied. Returns true if within
-  /// capacity, false otherwise.
-  ///
-  /// NOTE: This method should always be called BEFORE actual allocation.
+  // Increments current usage and check current 'allocatedBytes_' counter to
+  // make sure current usage does not go above 'capacity_'. If it goes above
+  // 'capacity_', the increment will not be applied. Returns true if within
+  // capacity, false otherwise.
+  //
+  // NOTE: This method should always be called BEFORE the actual allocation.
   inline bool incrementUsage(int64_t bytes) {
+    if (bytes < reservationByteLimit_) {
+      return incrementUsageWithReservation(bytes);
+    }
+    return incrementUsageWithoutReservation(bytes);
+  }
+
+  // Increments the memory usage in the local sharded counter from
+  // 'reservations_' for memory allocation with size < 'reservationByteLimit_'
+  // without updating the global 'allocatedBytes_' counter. If there is not
+  // enough reserved bytes in local sharded counter, then 'reserveFunc_' is
+  // called to reserve 'reservationByteLimit_' bytes from the global counter at
+  // a time.
+  inline bool incrementUsageWithReservation(uint32_t bytes) {
+    return reservations_.update(bytes, reserveFunc_);
+  }
+
+  inline bool incrementUsageWithReservationFunc(
+      uint32_t& counter,
+      uint32_t increment,
+      std::mutex& lock) {
+    VELOX_CHECK_LT(increment, reservationByteLimit_);
+    std::lock_guard<std::mutex> l(lock);
+    if (counter > increment) {
+      counter -= increment;
+      return true;
+    }
+    if (!incrementUsageWithoutReservation(reservationByteLimit_)) {
+      return false;
+    }
+    counter += reservationByteLimit_;
+    counter -= increment;
+    VELOX_CHECK_GT(counter, 0);
+    return true;
+  }
+
+  // Increments the memory usage from the global 'allocatedBytes_' counter
+  // directly.
+  inline bool incrementUsageWithoutReservation(int64_t bytes) {
+    VELOX_CHECK_GE(bytes, reservationByteLimit_);
     const auto originalBytes = allocatedBytes_.fetch_add(bytes);
     // We don't do the check when capacity_ is 0, meaning unlimited capacity.
     if (capacity_ != 0 && originalBytes + bytes > capacity_) {
@@ -126,11 +159,45 @@ class MallocAllocator : public MemoryAllocator {
     return true;
   }
 
-  /// Decrement current usage and check current allocator consistency to make
-  /// sure current usage does not go below 0. Throws if usage goes below 0.
-  ///
-  /// NOTE: This method should always be called AFTER actual free.
+  // Decrements current usage and check current 'allocatedBytes_' counter to
+  // make sure current usage does not go below 0. Throws if usage goes below 0.
+  //
+  // NOTE: This method should always be called AFTER actual free.
   inline void decrementUsage(int64_t bytes) {
+    if (bytes < reservationByteLimit_) {
+      decrementUsageWithReservation(bytes);
+      return;
+    }
+    decrementUsageWithoutReservation(bytes);
+  }
+
+  // Decrements the memory usage in the local sharded counter from
+  // 'reservations_' for memory free with size < 'reservationByteLimit_'
+  // without updating the global 'allocatedBytes_' counter. If there is more
+  // than 2 * 'reservationByteLimit_' free reserved bytes in local sharded
+  // counter, then 'releaseFunc_' is called to release 'reservationByteLimit_'
+  // bytes back to the global counter.
+  inline void decrementUsageWithReservation(int64_t bytes) {
+    reservations_.update(bytes, releaseFunc_);
+  }
+
+  inline void decrementUsageWithReservationFunc(
+      uint32_t& counter,
+      uint32_t decrement,
+      std::mutex& lock) {
+    VELOX_CHECK_LT(decrement, reservationByteLimit_);
+    std::lock_guard<std::mutex> l(lock);
+    counter += decrement;
+    if (counter >= 2 * reservationByteLimit_) {
+      decrementUsageWithoutReservation(reservationByteLimit_);
+      counter -= reservationByteLimit_;
+    }
+    VELOX_CHECK_LT(counter, 2 * reservationByteLimit_);
+  }
+
+  // Decrements the memory usage from the global 'allocatedBytes_' counter
+  // directly.
+  inline void decrementUsageWithoutReservation(int64_t bytes) {
     const auto originalBytes = allocatedBytes_.fetch_sub(bytes);
     if (originalBytes - bytes < 0) {
       // In case of inconsistency while freeing memory, do not revert in this
@@ -145,18 +212,18 @@ class MallocAllocator : public MemoryAllocator {
 
   const Kind kind_;
 
-  /// Capacity in bytes. Total allocation byte is not allowed to exceed this
-  /// value.
+  // Capacity in bytes. Total allocation byte is not allowed to exceed this
+  // value.
   const size_t capacity_;
+  const uint32_t reservationByteLimit_;
 
-  /// Current total allocated bytes by this 'MallocAllocator'.
-  std::atomic<int64_t> allocatedBytes_{0};
+  const ConcurrentCounter<uint32_t>::UpdateFn reserveFunc_;
+  const ConcurrentCounter<uint32_t>::UpdateFn releaseFunc_;
 
-  /// Mutex for 'mallocs_'.
-  std::mutex mallocsMutex_;
+  ConcurrentCounter<uint32_t> reservations_;
 
-  /// Tracks malloc'd pointers to detect bad frees.
-  std::unordered_set<void*> mallocs_;
+  // Current total allocated bytes by this 'MallocAllocator'.
+  std::atomic<int64_t> allocatedBytes_{0};
 
   std::shared_ptr<Cache> cache_;
 };
diff --git a/velox/common/memory/Memory.cpp b/velox/common/memory/Memory.cpp
index 882a27ebb4777..6eb2437d2f8e7 100644
--- a/velox/common/memory/Memory.cpp
+++ b/velox/common/memory/Memory.cpp
@@ -16,93 +16,257 @@
 
 #include "velox/common/memory/Memory.h"
 
+#include <atomic>
+
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/memory/MallocAllocator.h"
+#include "velox/common/memory/MmapAllocator.h"
+
 DECLARE_int32(velox_memory_num_shared_leaf_pools);
 
 namespace facebook::velox::memory {
 namespace {
-constexpr folly::StringPiece kDefaultRootName{"__default_root__"};
-constexpr folly::StringPiece kDefaultLeafName("__default_leaf__");
+constexpr std::string_view kSysRootName{"__sys_root__"};
+constexpr std::string_view kSysSharedLeafNamePrefix{"__sys_shared_leaf__"};
+
+struct SingletonState {
+  ~SingletonState() {
+    delete instance.load(std::memory_order_acquire);
+  }
+
+  std::atomic<MemoryManager*> instance{nullptr};
+  std::mutex mutex;
+};
+
+SingletonState& singletonState() {
+  static SingletonState state;
+  return state;
+}
+
+std::shared_ptr<MemoryAllocator> createAllocator(
+    const MemoryManagerOptions& options) {
+  if (options.useMmapAllocator) {
+    MmapAllocator::Options mmapOptions;
+    mmapOptions.capacity = options.allocatorCapacity;
+    mmapOptions.largestSizeClass = options.largestSizeClassPages;
+    mmapOptions.useMmapArena = options.useMmapArena;
+    mmapOptions.mmapArenaCapacityRatio = options.mmapArenaCapacityRatio;
+    return std::make_shared<MmapAllocator>(mmapOptions);
+  } else {
+    return std::make_shared<MallocAllocator>(
+        options.allocatorCapacity,
+        options.allocationSizeThresholdWithReservation);
+  }
+}
+
+std::unique_ptr<MemoryArbitrator> createArbitrator(
+    const MemoryManagerOptions& options) {
+  // TODO: consider to reserve a small amount of memory to compensate for the
+  //  non-reclaimable cache memory which are pinned by query accesses if
+  //  enabled.
+
+  // TODO(jtan6): [Config Refactor] clean up the if condition after Prestissimo
+  //  switched to use extra configs map.
+  if (options.extraArbitratorConfigs.empty()) {
+    std::unordered_map<std::string, std::string> extraArbitratorConfigs;
+    try {
+      // The literal string is temporary in order to not depend on
+      // SharedArbitrator class. After Prestissimo switches, this part of the
+      // code will be removed.
+      extraArbitratorConfigs["reserved-capacity"] =
+          folly::to<std::string>(options.arbitratorReservedCapacity) + "B";
+      extraArbitratorConfigs["memory-pool-initial-capacity"] =
+          folly::to<std::string>(options.memoryPoolInitCapacity) + "B";
+      extraArbitratorConfigs["memory-pool-reserved-capacity"] =
+          folly::to<std::string>(options.memoryPoolReservedCapacity) + "B";
+      extraArbitratorConfigs["memory-pool-transfer-capacity"] =
+          folly::to<std::string>(options.memoryPoolTransferCapacity) + "B";
+      extraArbitratorConfigs["fast-exponential-growth-capacity-limit"] =
+          folly::to<std::string>(options.fastExponentialGrowthCapacityLimit) +
+          "B";
+      extraArbitratorConfigs["slow-capacity-grow-pct"] =
+          folly::to<std::string>(options.slowCapacityGrowPct);
+      extraArbitratorConfigs["memory-pool-min-free-capacity"] =
+          folly::to<std::string>(options.memoryPoolMinFreeCapacity) + "B";
+      extraArbitratorConfigs["memory-pool-min-free-capacity-pct"] =
+          folly::to<std::string>(options.memoryPoolMinFreeCapacityPct);
+      extraArbitratorConfigs["memory-reclaim-max-wait-time"] =
+          folly::to<std::string>(options.memoryReclaimWaitMs) + "ms";
+      extraArbitratorConfigs["global-arbitration-enabled"] =
+          folly::to<std::string>(options.globalArbitrationEnabled);
+      extraArbitratorConfigs["check-usage-leak"] =
+          folly::to<std::string>(options.checkUsageLeak);
+    } catch (const std::exception& e) {
+      VELOX_USER_FAIL("Failed to parse extra arbitrator configs: {}", e.what());
+    }
+    return MemoryArbitrator::create(
+        {.kind = options.arbitratorKind,
+         .capacity =
+             std::min(options.arbitratorCapacity, options.allocatorCapacity),
+         .arbitrationStateCheckCb = options.arbitrationStateCheckCb,
+         .extraConfigs = extraArbitratorConfigs});
+  } else {
+    return MemoryArbitrator::create(
+        {.kind = options.arbitratorKind,
+         .capacity =
+             std::min(options.arbitratorCapacity, options.allocatorCapacity),
+         .arbitrationStateCheckCb = options.arbitrationStateCheckCb,
+         .extraConfigs = options.extraArbitratorConfigs});
+  }
+}
+
+std::vector<std::shared_ptr<MemoryPool>> createSharedLeafMemoryPools(
+    MemoryPool& sysPool) {
+  VELOX_CHECK_EQ(sysPool.name(), kSysRootName);
+  std::vector<std::shared_ptr<MemoryPool>> leafPools;
+  const size_t numSharedPools =
+      std::max(1, FLAGS_velox_memory_num_shared_leaf_pools);
+  leafPools.reserve(numSharedPools);
+  for (size_t i = 0; i < numSharedPools; ++i) {
+    leafPools.emplace_back(
+        sysPool.addLeafChild(fmt::format("{}{}", kSysSharedLeafNamePrefix, i)));
+  }
+  return leafPools;
+}
 } // namespace
 
 MemoryManager::MemoryManager(const MemoryManagerOptions& options)
-    : capacity_{options.capacity},
-      allocator_{options.allocator->shared_from_this()},
-      // TODO: consider to reserve a small amount of memory to compensate for
-      //  the unreclaimable cache memory which are pinned by query accesses if
-      //  enabled.
-      arbitrator_(MemoryArbitrator::create(
-          {.kind = options.arbitratorKind,
-           .capacity = std::min(options.queryMemoryCapacity, options.capacity),
-           .memoryPoolInitCapacity = options.memoryPoolInitCapacity,
-           .memoryPoolTransferCapacity = options.memoryPoolTransferCapacity,
-           .arbitrationStateCheckCb = options.arbitrationStateCheckCb})),
+    : allocator_{createAllocator(options)},
+      arbitrator_(createArbitrator(options)),
       alignment_(std::max(MemoryAllocator::kMinAlignment, options.alignment)),
       checkUsageLeak_(options.checkUsageLeak),
       debugEnabled_(options.debugEnabled),
+      coreOnAllocationFailureEnabled_(options.coreOnAllocationFailureEnabled),
+      disableMemoryPoolTracking_(options.disableMemoryPoolTracking),
       poolDestructionCb_([&](MemoryPool* pool) { dropPool(pool); }),
-      defaultRoot_{std::make_shared<MemoryPoolImpl>(
+      sysRoot_{std::make_shared<MemoryPoolImpl>(
           this,
-          kDefaultRootName.str(),
+          std::string(kSysRootName),
           MemoryPool::Kind::kAggregate,
           nullptr,
           nullptr,
-          nullptr,
           // NOTE: the default root memory pool has no capacity limit, and it is
           // used for system usage in production such as disk spilling.
           MemoryPool::Options{
               .alignment = alignment_,
               .maxCapacity = kMaxMemory,
               .trackUsage = options.trackDefaultUsage,
-              .checkUsageLeak = options.checkUsageLeak,
-              .debugEnabled = options.debugEnabled})} {
+              .debugEnabled = options.debugEnabled,
+              .coreOnAllocationFailureEnabled =
+                  options.coreOnAllocationFailureEnabled})},
+      spillPool_{addLeafPool("__sys_spilling__")},
+      tracePool_{addLeafPool("__sys_tracing__")},
+      sharedLeafPools_(createSharedLeafMemoryPools(*sysRoot_)) {
   VELOX_CHECK_NOT_NULL(allocator_);
   VELOX_CHECK_NOT_NULL(arbitrator_);
-  VELOX_CHECK_EQ(
-      allocator_->capacity(),
-      capacity_,
-      "MemoryAllocator capacity {} must be the same as MemoryManager capacity {}.",
-      allocator_->capacity(),
-      capacity_);
-  VELOX_USER_CHECK_GE(capacity_, 0);
+  VELOX_USER_CHECK_GE(capacity(), 0);
+  VELOX_CHECK_GE(allocator_->capacity(), arbitrator_->capacity());
   MemoryAllocator::alignmentCheck(0, alignment_);
-  defaultRoot_->grow(defaultRoot_->maxCapacity());
-  const size_t numSharedPools =
-      std::max(1, FLAGS_velox_memory_num_shared_leaf_pools);
-  sharedLeafPools_.reserve(numSharedPools);
-  for (size_t i = 0; i < numSharedPools; ++i) {
-    sharedLeafPools_.emplace_back(
-        addLeafPool(fmt::format("default_shared_leaf_pool_{}", i)));
-  }
+  const bool ret = sysRoot_->grow(sysRoot_->maxCapacity(), 0);
+  VELOX_CHECK(
+      ret,
+      "Failed to set max capacity {} for {}",
+      succinctBytes(sysRoot_->maxCapacity()),
+      sysRoot_->name());
+  VELOX_CHECK_EQ(
+      sharedLeafPools_.size(),
+      std::max(1, FLAGS_velox_memory_num_shared_leaf_pools));
 }
 
 MemoryManager::~MemoryManager() {
-  if (checkUsageLeak_) {
-    VELOX_CHECK_EQ(
-        numPools(),
+  if (pools_.size() != 0) {
+    const auto errMsg = fmt::format(
+        "pools_.size() != 0 ({} vs {}). There are unexpected alive memory "
+        "pools allocated by user on memory manager destruction:\n{}",
+        pools_.size(),
         0,
-        "There are {} unexpected alive memory pools allocated by user on memory manager destruction:\n{}",
-        numPools(),
-        toString());
+        toString(true));
+    if (checkUsageLeak_) {
+      VELOX_FAIL(errMsg);
+    } else {
+      LOG(ERROR) << errMsg;
+    }
   }
 }
 
 // static
-MemoryManager& MemoryManager::getInstance(const MemoryManagerOptions& options) {
-  static MemoryManager manager{options};
-  return manager;
+MemoryManager& MemoryManager::deprecatedGetInstance(
+    const MemoryManagerOptions& options) {
+  auto& state = singletonState();
+  if (auto* instance = state.instance.load(std::memory_order_acquire)) {
+    return *instance;
+  }
+
+  std::lock_guard<std::mutex> l(state.mutex);
+  auto* instance = state.instance.load(std::memory_order_acquire);
+  if (instance != nullptr) {
+    return *instance;
+  }
+  instance = new MemoryManager(options);
+  state.instance.store(instance, std::memory_order_release);
+  return *instance;
+}
+
+// static
+void MemoryManager::initialize(const MemoryManagerOptions& options) {
+  auto& state = singletonState();
+  std::lock_guard<std::mutex> l(state.mutex);
+  auto* instance = state.instance.load(std::memory_order_acquire);
+  VELOX_CHECK_NULL(
+      instance,
+      "The memory manager has already been set: {}",
+      instance->toString());
+  instance = new MemoryManager(options);
+  state.instance.store(instance, std::memory_order_release);
+}
+
+// static.
+MemoryManager* MemoryManager::getInstance() {
+  auto* instance = singletonState().instance.load(std::memory_order_acquire);
+  VELOX_CHECK_NOT_NULL(instance, "The memory manager is not set");
+  return instance;
+}
+
+// static.
+MemoryManager& MemoryManager::testingSetInstance(
+    const MemoryManagerOptions& options) {
+  auto& state = singletonState();
+  std::lock_guard<std::mutex> l(state.mutex);
+  auto* instance = new MemoryManager(options);
+  delete state.instance.exchange(instance, std::memory_order_acq_rel);
+  return *instance;
 }
 
 int64_t MemoryManager::capacity() const {
-  return capacity_;
+  return allocator_->capacity();
 }
 
 uint16_t MemoryManager::alignment() const {
   return alignment_;
 }
 
+std::shared_ptr<MemoryPoolImpl> MemoryManager::createRootPool(
+    std::string poolName,
+    std::unique_ptr<MemoryReclaimer>& reclaimer,
+    MemoryPool::Options& options) {
+  auto pool = std::make_shared<MemoryPoolImpl>(
+      this,
+      poolName,
+      MemoryPool::Kind::kAggregate,
+      nullptr,
+      std::move(reclaimer),
+      options);
+  VELOX_CHECK_EQ(pool->capacity(), 0);
+  arbitrator_->addPool(pool);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricMemoryPoolInitialCapacityBytes, pool->capacity());
+  return pool;
+}
+
 std::shared_ptr<MemoryPool> MemoryManager::addRootPool(
     const std::string& name,
-    int64_t capacity,
+    int64_t maxCapacity,
     std::unique_ptr<MemoryReclaimer> reclaimer) {
   std::string poolName = name;
   if (poolName.empty()) {
@@ -112,26 +276,28 @@ std::shared_ptr<MemoryPool> MemoryManager::addRootPool(
 
   MemoryPool::Options options;
   options.alignment = alignment_;
-  options.maxCapacity = capacity;
+  options.maxCapacity = maxCapacity;
   options.trackUsage = true;
-  options.checkUsageLeak = checkUsageLeak_;
   options.debugEnabled = debugEnabled_;
+  options.coreOnAllocationFailureEnabled = coreOnAllocationFailureEnabled_;
 
-  folly::SharedMutex::WriteHolder guard{mutex_};
-  if (pools_.find(poolName) != pools_.end()) {
-    VELOX_FAIL("Duplicate root pool name found: {}", poolName);
+  auto pool = createRootPool(poolName, reclaimer, options);
+  if (!disableMemoryPoolTracking_) {
+    try {
+      std::unique_lock guard{mutex_};
+      if (pools_.find(poolName) != pools_.end()) {
+        VELOX_FAIL("Duplicate root pool name found: {}", poolName);
+      }
+      pools_.emplace(poolName, pool);
+    } catch (const VeloxRuntimeError& ex) {
+      arbitrator_->removePool(pool.get());
+      throw;
+    }
   }
-  auto pool = std::make_shared<MemoryPoolImpl>(
-      this,
-      poolName,
-      MemoryPool::Kind::kAggregate,
-      nullptr,
-      std::move(reclaimer),
-      poolDestructionCb_,
-      options);
-  pools_.emplace(poolName, pool);
-  VELOX_CHECK_EQ(pool->capacity(), 0);
-  arbitrator_->reserveMemory(pool.get(), capacity);
+  // NOTE: we need to set destruction callback at the end to avoid potential
+  // deadlock or failure because of duplicate memory pool name or unexpected
+  // failure to add memory pool to the arbitrator.
+  pool->setDestructionCallback(poolDestructionCb_);
   return pool;
 }
 
@@ -143,33 +309,33 @@ std::shared_ptr<MemoryPool> MemoryManager::addLeafPool(
     static std::atomic<int64_t> poolId{0};
     poolName = fmt::format("default_leaf_{}", poolId++);
   }
-  return defaultRoot_->addLeafChild(poolName, threadSafe, nullptr);
+  return sysRoot_->addLeafChild(poolName, threadSafe, nullptr);
 }
 
-bool MemoryManager::growPool(MemoryPool* pool, uint64_t incrementBytes) {
-  VELOX_CHECK_NOT_NULL(pool);
-  VELOX_CHECK_NE(pool->capacity(), kMaxMemory);
-  return arbitrator_->growMemory(pool, getAlivePools(), incrementBytes);
-}
-
-uint64_t MemoryManager::shrinkPools(uint64_t targetBytes) {
-  return arbitrator_->shrinkMemory(getAlivePools(), targetBytes);
+uint64_t MemoryManager::shrinkPools(
+    uint64_t targetBytes,
+    bool allowSpill,
+    bool allowAbort) {
+  return arbitrator_->shrinkCapacity(targetBytes, allowSpill, allowAbort);
 }
 
 void MemoryManager::dropPool(MemoryPool* pool) {
   VELOX_CHECK_NOT_NULL(pool);
-  folly::SharedMutex::WriteHolder guard{mutex_};
+  VELOX_DCHECK_EQ(pool->reservedBytes(), 0);
+  arbitrator_->removePool(pool);
+  if (disableMemoryPoolTracking_) {
+    return;
+  }
+  std::unique_lock guard{mutex_};
   auto it = pools_.find(pool->name());
   if (it == pools_.end()) {
     VELOX_FAIL("The dropped memory pool {} not found", pool->name());
   }
   pools_.erase(it);
-  arbitrator_->releaseMemory(pool);
 }
 
 MemoryPool& MemoryManager::deprecatedSharedLeafPool() {
   const auto idx = std::hash<std::thread::id>{}(std::this_thread::get_id());
-  folly::SharedMutex::ReadHolder guard{mutex_};
   return *sharedLeafPools_.at(idx % sharedLeafPools_.size());
 }
 
@@ -178,35 +344,45 @@ int64_t MemoryManager::getTotalBytes() const {
 }
 
 size_t MemoryManager::numPools() const {
-  size_t numPools = defaultRoot_->getChildCount();
-  VELOX_CHECK_GE(numPools, 0);
+  size_t numPools = sysRoot_->getChildCount();
   {
-    folly::SharedMutex::ReadHolder guard{mutex_};
+    std::shared_lock guard{mutex_};
     numPools += pools_.size() - sharedLeafPools_.size();
   }
   return numPools;
 }
 
-MemoryAllocator& MemoryManager::allocator() {
-  return *allocator_;
+MemoryAllocator* MemoryManager::allocator() {
+  return allocator_.get();
 }
 
 MemoryArbitrator* MemoryManager::arbitrator() {
   return arbitrator_.get();
 }
 
-std::string MemoryManager::toString() const {
+std::string MemoryManager::toString(bool detail) const {
+  const int64_t allocatorCapacity = capacity();
   std::stringstream out;
   out << "Memory Manager[capacity "
-      << (capacity_ == kMaxMemory ? "UNLIMITED" : succinctBytes(capacity_))
+      << (allocatorCapacity == kMaxMemory ? "UNLIMITED"
+                                          : succinctBytes(allocatorCapacity))
       << " alignment " << succinctBytes(alignment_) << " usedBytes "
       << succinctBytes(getTotalBytes()) << " number of pools " << numPools()
       << "\n";
   out << "List of root pools:\n";
-  out << "\t" << defaultRoot_->name() << "\n";
+  if (detail) {
+    out << sysRoot_->treeMemoryUsage(false);
+  } else {
+    out << "\t" << sysRoot_->name() << "\n";
+  }
   std::vector<std::shared_ptr<MemoryPool>> pools = getAlivePools();
   for (const auto& pool : pools) {
-    out << "\t" << pool->name() << "\n";
+    if (detail) {
+      out << pool->treeMemoryUsage(false);
+    } else {
+      out << "\t" << pool->name() << "\n";
+    }
+    out << "\trefcount " << pool.use_count() << "\n";
   }
   out << allocator_->toString() << "\n";
   out << arbitrator_->toString();
@@ -216,7 +392,7 @@ std::string MemoryManager::toString() const {
 
 std::vector<std::shared_ptr<MemoryPool>> MemoryManager::getAlivePools() const {
   std::vector<std::shared_ptr<MemoryPool>> pools;
-  folly::SharedMutex::ReadHolder guard{mutex_};
+  std::shared_lock guard{mutex_};
   pools.reserve(pools_.size());
   for (const auto& entry : pools_) {
     auto pool = entry.second.lock();
@@ -227,27 +403,38 @@ std::vector<std::shared_ptr<MemoryPool>> MemoryManager::getAlivePools() const {
   return pools;
 }
 
-MemoryManager& defaultMemoryManager() {
+void initializeMemoryManager(const MemoryManagerOptions& options) {
+  MemoryManager::initialize(options);
+}
+
+MemoryManager* memoryManager() {
   return MemoryManager::getInstance();
 }
 
-std::shared_ptr<MemoryPool> addDefaultLeafMemoryPool(
+MemoryManager& deprecatedDefaultMemoryManager() {
+  return MemoryManager::deprecatedGetInstance();
+}
+
+std::shared_ptr<MemoryPool> deprecatedAddDefaultLeafMemoryPool(
     const std::string& name,
     bool threadSafe) {
-  auto& memoryManager = defaultMemoryManager();
+  auto& memoryManager = deprecatedDefaultMemoryManager();
   return memoryManager.addLeafPool(name, threadSafe);
 }
 
 MemoryPool& deprecatedSharedLeafPool() {
-  return defaultMemoryManager().deprecatedSharedLeafPool();
+  return deprecatedDefaultMemoryManager().deprecatedSharedLeafPool();
 }
 
 memory::MemoryPool* spillMemoryPool() {
-  static auto pool = memory::addDefaultLeafMemoryPool("_sys.spilling");
-  return pool.get();
+  return memory::MemoryManager::getInstance()->spillPool();
 }
 
 bool isSpillMemoryPool(memory::MemoryPool* pool) {
   return pool == spillMemoryPool();
 }
+
+memory::MemoryPool* traceMemoryPool() {
+  return memory::MemoryManager::getInstance()->tracePool();
+}
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/Memory.h b/velox/common/memory/Memory.h
index 1f6fa29836de6..5daea43bd1379 100644
--- a/velox/common/memory/Memory.h
+++ b/velox/common/memory/Memory.h
@@ -63,21 +63,6 @@ struct MemoryManagerOptions {
   /// Specifies the default memory allocation alignment.
   uint16_t alignment{MemoryAllocator::kMaxAlignment};
 
-  /// Specifies the max memory capacity in bytes. MemoryManager will not
-  /// enforce capacity. This will be used by MemoryArbitrator
-  int64_t capacity{MemoryAllocator::kDefaultCapacityBytes};
-
-  /// Memory capacity for query/task memory pools. This capacity setting should
-  /// be equal or smaller than 'capacity'. The difference between 'capacity' and
-  /// 'queryMemoryCapacity' is reserved for system usage such as cache and
-  /// spilling.
-  ///
-  /// NOTE:
-  /// - if 'queryMemoryCapacity' is greater than 'capacity', the behavior
-  /// will be equivalent to as if they are equal, meaning no reservation
-  /// capacity for system usage.
-  int64_t queryMemoryCapacity{kMaxMemory};
-
   /// If true, enable memory usage tracking in the default memory pool.
   bool trackDefaultUsage{
       FLAGS_velox_enable_memory_usage_track_in_default_memory_pool};
@@ -93,10 +78,85 @@ struct MemoryManagerOptions {
   /// testing purpose.
   bool debugEnabled{FLAGS_velox_memory_pool_debug_enabled};
 
-  /// Specifies the backing memory allocator.
-  MemoryAllocator* allocator{MemoryAllocator::getInstance()};
+  /// Terminates the process and generates a core file on an allocation failure
+  bool coreOnAllocationFailureEnabled{false};
+
+  /// Disables the memory manager's tracking on memory pools.
+  bool disableMemoryPoolTracking{false};
+
+  /// ================== 'MemoryAllocator' settings ==================
+
+  /// Specifies the max memory allocation capacity in bytes enforced by
+  /// MemoryAllocator, default unlimited.
+  int64_t allocatorCapacity{kMaxMemory};
+
+  /// If true, uses MmapAllocator for memory allocation which manages the
+  /// physical memory allocation on its own through std::mmap techniques. If
+  /// false, use MallocAllocator which delegates the memory allocation to
+  /// std::malloc.
+  bool useMmapAllocator{false};
+
+  /// Number of pages in the largest size class in MmapAllocator.
+  int32_t largestSizeClassPages{256};
+
+  /// If true, allocations larger than largest size class size will be delegated
+  /// to ManagedMmapArena. Otherwise a system mmap call will be issued for each
+  /// such allocation.
+  ///
+  /// NOTE: this only applies for MmapAllocator.
+  bool useMmapArena{false};
+
+  /// Used to determine MmapArena capacity. The ratio represents
+  /// 'allocatorCapacity' to single MmapArena capacity ratio.
+  ///
+  /// NOTE: this only applies for MmapAllocator.
+  int32_t mmapArenaCapacityRatio{10};
+
+  /// If not zero, reserve 'smallAllocationReservePct'% of space from
+  /// 'allocatorCapacity' for ad hoc small allocations. And those allocations
+  /// are delegated to std::malloc. If 'maxMallocBytes' is 0, this value will be
+  /// disregarded.
+  ///
+  /// NOTE: this only applies for MmapAllocator.
+  uint32_t smallAllocationReservePct{0};
+
+  /// The allocation threshold less than which an allocation is delegated to
+  /// std::malloc(). If it is zero, then we don't delegate any allocation
+  /// std::malloc, and 'smallAllocationReservePct' will be automatically set to
+  /// 0 disregarding any passed in value.
+  ///
+  /// NOTE: this only applies for MmapAllocator.
+  int32_t maxMallocBytes{3072};
+
+  /// The memory allocations with size smaller than this threshold check the
+  /// capacity with local sharded counter to reduce the lock contention on the
+  /// global allocation counter. The sharded local counters reserve/release
+  /// memory capacity from the global counter in batch. With this optimization,
+  /// we don't have to update the global counter for each individual small
+  /// memory allocation. If it is zero, then this optimization is disabled. The
+  /// default is 1MB.
+  ///
+  /// NOTE: this only applies for MallocAllocator.
+  uint32_t allocationSizeThresholdWithReservation{1 << 20};
+
+  /// ================== 'MemoryArbitrator' settings =================
 
-  /// ================== 'MemoryArbitrator' settings ==================
+  /// Memory capacity available for query/task memory pools. This capacity
+  /// setting should be equal or smaller than 'allocatorCapacity'. The
+  /// difference between 'allocatorCapacity' and 'arbitratorCapacity' is
+  /// reserved for system usage such as cache and spilling.
+  ///
+  /// NOTE:
+  /// - if 'arbitratorCapacity' is greater than 'allocatorCapacity', the
+  /// behavior will be equivalent to as if they are equal, meaning no
+  /// reservation capacity for system usage.
+  int64_t arbitratorCapacity{kMaxMemory};
+
+  /// Memory capacity reserved to ensure that a query has minimal memory
+  /// capacity to run. This capacity should be less than 'arbitratorCapacity'.
+  /// A query's minimal memory capacity is defined by
+  /// 'memoryPoolReservedCapacity'.
+  int64_t arbitratorReservedCapacity{0};
 
   /// The string kind of memory arbitrator used in the memory manager.
   ///
@@ -104,12 +164,67 @@ struct MemoryManagerOptions {
   /// Otherwise MemoryArbitrator::create returns a nullptr.
   std::string arbitratorKind{};
 
-  /// The initial memory capacity to reserve for a newly created memory pool.
+  /// The initial memory capacity to reserve for a newly created query memory
+  /// pool.
   uint64_t memoryPoolInitCapacity{256 << 20};
 
+  /// The minimal query memory pool capacity that is ensured during arbitration.
+  /// During arbitration, memory arbitrator ensures the participants' memory
+  /// pool capacity to be no less than this value on a best-effort basis, for
+  /// more smooth executions of the queries, to avoid frequent arbitration
+  /// requests.
+  uint64_t memoryPoolReservedCapacity{0};
+
   /// The minimal memory capacity to transfer out of or into a memory pool
   /// during the memory arbitration.
-  uint64_t memoryPoolTransferCapacity{32 << 20};
+  uint64_t memoryPoolTransferCapacity{128 << 20};
+
+  /// When growing capacity, the growth bytes will be adjusted in the
+  /// following way:
+  ///  - If 2 * current capacity is less than or equal to
+  ///    'fastExponentialGrowthCapacityLimit', grow through fast path by at
+  ///    least doubling the current capacity, when conditions allow (see below
+  ///    NOTE section).
+  ///  - If 2 * current capacity is greater than
+  ///    'fastExponentialGrowthCapacityLimit', grow through slow path by growing
+  ///    capacity by at least 'slowCapacityGrowPct' * current capacity if
+  ///    allowed (see below NOTE section).
+  ///
+  /// NOTE: If original requested growth bytes is larger than the adjusted
+  /// growth bytes or adjusted growth bytes reaches max capacity limit, the
+  /// adjusted growth bytes will not be respected.
+  ///
+  /// NOTE: Capacity growth adjust is only enabled if both
+  /// 'fastExponentialGrowthCapacityLimit' and 'slowCapacityGrowPct' are set,
+  /// otherwise it is disabled.
+  uint64_t fastExponentialGrowthCapacityLimit{512 << 20};
+  double slowCapacityGrowPct{0.25};
+
+  /// When shrinking capacity, the shrink bytes will be adjusted in a way such
+  /// that AFTER shrink, the stricter (whichever is smaller) of the following
+  /// conditions is met, in order to better fit the pool's current memory
+  /// usage:
+  /// - Free capacity is greater or equal to capacity *
+  /// 'memoryPoolMinFreeCapacityPct'
+  /// - Free capacity is greater or equal to 'memoryPoolMinFreeCapacity'
+  ///
+  /// NOTE: In the conditions when original requested shrink bytes ends up
+  /// with more free capacity than above 2 conditions, the adjusted shrink
+  /// bytes is not respected.
+  ///
+  /// NOTE: Capacity shrink adjustment is enabled when both
+  /// 'memoryPoolMinFreeCapacityPct' and 'memoryPoolMinFreeCapacity' are set.
+  uint64_t memoryPoolMinFreeCapacity{128 << 20};
+  double memoryPoolMinFreeCapacityPct{0.25};
+
+  /// Specifies the max time to wait for memory reclaim by arbitration. The
+  /// memory reclaim might fail if the max wait time has exceeded. If it is
+  /// zero, then there is no timeout. The default is 5 mins.
+  uint64_t memoryReclaimWaitMs{300'000};
+
+  /// If true, it allows memory arbitrator to reclaim used memory cross query
+  /// memory pools.
+  bool globalArbitrationEnabled{false};
 
   /// Provided by the query system to validate the state after a memory pool
   /// enters arbitration if not null. For instance, Prestissimo provides
@@ -118,11 +233,16 @@ struct MemoryManagerOptions {
   /// potential deadlock when reclaim memory from the task of the request memory
   /// pool.
   MemoryArbitrationStateCheckCB arbitrationStateCheckCb{nullptr};
+
+  /// TODO(jtan6): [Config Refactor] Remove above shared arbitrator specific
+  /// configs after Prestissimo switch to use extra configs map.
+  ///
+  /// Additional configs that are arbitrator implementation specific.
+  std::unordered_map<std::string, std::string> extraArbitratorConfigs{};
 };
 
-/// 'MemoryManager' is responsible for managing the memory pools. For now, users
-/// wanting multiple different allocators would need to instantiate different
-/// MemoryManager classes and manage them across static boundaries.
+/// 'MemoryManager' is responsible for creating allocator, arbitrator and
+/// managing the memory pools.
 class MemoryManager {
  public:
   explicit MemoryManager(
@@ -130,11 +250,23 @@ class MemoryManager {
 
   ~MemoryManager();
 
-  /// Tries to get the singleton memory manager. If not previously initialized,
-  /// the process singleton manager will be initialized.
-  FOLLY_EXPORT static MemoryManager& getInstance(
+  /// Creates process-wide memory manager using specified options. Throws if
+  /// memory manager has already been created by an easier call.
+  static void initialize(const MemoryManagerOptions& options);
+
+  /// Returns process-wide memory manager. Throws if 'initialize' hasn't been
+  /// called yet.
+  static MemoryManager* getInstance();
+
+  /// Deprecated. Do not use. Remove once existing call sites are updated.
+  /// Returns the process-wide default memory manager instance if exists,
+  /// otherwise creates one based on the specified 'options'.
+  FOLLY_EXPORT static MemoryManager& deprecatedGetInstance(
       const MemoryManagerOptions& options = MemoryManagerOptions{});
 
+  /// Used by test to override the process-wide memory manager.
+  static MemoryManager& testingSetInstance(const MemoryManagerOptions& options);
+
   /// Returns the memory capacity of this memory manager which puts a hard cap
   /// on memory usage, and any allocation that exceeds this capacity throws.
   int64_t capacity() const;
@@ -142,12 +274,12 @@ class MemoryManager {
   /// Returns the memory allocation alignment of this memory manager.
   uint16_t alignment() const;
 
-  /// Creates a root memory pool with specified 'name' and 'capacity'. If 'name'
-  /// is missing, the memory manager generates a default name internally to
-  /// ensure uniqueness.
+  /// Creates a root memory pool with specified 'name' and 'maxCapacity'. If
+  /// 'name' is missing, the memory manager generates a default name internally
+  /// to ensure uniqueness.
   std::shared_ptr<MemoryPool> addRootPool(
       const std::string& name = "",
-      int64_t capacity = kMaxMemory,
+      int64_t maxCapacity = kMaxMemory,
       std::unique_ptr<MemoryReclaimer> reclaimer = nullptr);
 
   /// Creates a leaf memory pool for direct memory allocation use with specified
@@ -160,13 +292,17 @@ class MemoryManager {
       const std::string& name = "",
       bool threadSafe = true);
 
-  /// Invoked to grows a memory pool's free capacity with at least
-  /// 'incrementBytes'. The function returns true on success, otherwise false.
-  bool growPool(MemoryPool* pool, uint64_t incrementBytes);
-
   /// Invoked to shrink alive pools to free 'targetBytes' capacity. The function
-  /// returns the actual freed memory capacity in bytes.
-  uint64_t shrinkPools(uint64_t targetBytes);
+  /// returns the actual freed memory capacity in bytes. If 'targetBytes' is
+  /// zero, then try to reclaim all the memory from the alive pools. If
+  /// 'allowSpill' is true, it reclaims the used memory by spilling. If
+  /// 'allowAbort' is true, it reclaims the used memory by aborting the queries
+  /// with the most memory usage. If both are true, it first reclaims the used
+  /// memory by spilling and then abort queries to reach the reclaim target.
+  uint64_t shrinkPools(
+      uint64_t targetBytes = 0,
+      bool allowSpill = true,
+      bool allowAbort = false);
 
   /// Default unmanaged leaf pool with no threadsafe stats support. Libraries
   /// using this method can get a pool that is shared with other threads. The
@@ -186,17 +322,29 @@ class MemoryManager {
   /// leaf memory pools.
   size_t numPools() const;
 
-  MemoryAllocator& allocator();
+  MemoryAllocator* allocator();
 
   MemoryArbitrator* arbitrator();
 
-  /// Returns debug string of this memory manager.
-  std::string toString() const;
+  /// Returns debug string of this memory manager. If 'detail' is true, it
+  /// returns the detailed tree memory usage from all the top level root memory
+  /// pools.
+  std::string toString(bool detail = false) const;
 
   /// Returns the memory manger's internal default root memory pool for testing
   /// purpose.
   MemoryPool& testingDefaultRoot() const {
-    return *defaultRoot_;
+    return *sysRoot_;
+  }
+
+  /// Returns the process wide leaf memory pool used for disk spilling.
+  MemoryPool* spillPool() {
+    return spillPool_.get();
+  }
+
+  /// Returns the process wide leaf memory pool used for query tracing.
+  MemoryPool* tracePool() const {
+    return tracePool_.get();
   }
 
   const std::vector<std::shared_ptr<MemoryPool>>& testingSharedLeafPools() {
@@ -204,41 +352,62 @@ class MemoryManager {
   }
 
  private:
+  std::shared_ptr<MemoryPoolImpl> createRootPool(
+      std::string poolName,
+      std::unique_ptr<MemoryReclaimer>& reclaimer,
+      MemoryPool::Options& options);
+
   void dropPool(MemoryPool* pool);
 
   //  Returns the shared references to all the alive memory pools in 'pools_'.
   std::vector<std::shared_ptr<MemoryPool>> getAlivePools() const;
 
-  // Specifies the total memory capacity. Memory manager itself doesn't enforce
-  // the capacity but relies on memory allocator and memory arbitrator to do the
-  // enforcement. Memory allocator ensures physical memory allocations are
-  // within capacity limit. Memory arbitrator ensures that total allocated
-  // memory pool capacity is within the limit.
-  const int64_t capacity_;
   const std::shared_ptr<MemoryAllocator> allocator_;
+
   // If not null, used to arbitrate the memory capacity among 'pools_'.
   const std::unique_ptr<MemoryArbitrator> arbitrator_;
   const uint16_t alignment_;
   const bool checkUsageLeak_;
   const bool debugEnabled_;
-  // The destruction callback set for the allocated  root memory pools which are
+  const bool coreOnAllocationFailureEnabled_;
+  const bool disableMemoryPoolTracking_;
+
+  // The destruction callback set for the allocated root memory pools which are
   // tracked by 'pools_'. It is invoked on the root pool destruction and removes
   // the pool from 'pools_'.
   const MemoryPoolImpl::DestructionCallback poolDestructionCb_;
 
-  const std::shared_ptr<MemoryPool> defaultRoot_;
-  std::vector<std::shared_ptr<MemoryPool>> sharedLeafPools_;
+  const std::shared_ptr<MemoryPool> sysRoot_;
+  const std::shared_ptr<MemoryPool> spillPool_;
+  const std::shared_ptr<MemoryPool> tracePool_;
+  const std::vector<std::shared_ptr<MemoryPool>> sharedLeafPools_;
 
   mutable folly::SharedMutex mutex_;
+  // All user root pools allocated from 'this'.
   std::unordered_map<std::string, std::weak_ptr<MemoryPool>> pools_;
 };
 
-MemoryManager& defaultMemoryManager();
+/// Initializes the process-wide memory manager based on the specified
+/// 'options'.
+///
+/// NOTE: user should only call this once on query system startup. Otherwise,
+/// the function throws.
+void initializeMemoryManager(const MemoryManagerOptions& options);
+
+/// Returns the process-wide memory manager.
+///
+/// NOTE: user should have already initialized memory manager by calling.
+/// Otherwise, the function throws.
+MemoryManager* memoryManager();
 
+/// Deprecated. Do not use.
+MemoryManager& deprecatedDefaultMemoryManager();
+
+/// Deprecated. Do not use.
 /// Creates a leaf memory pool from the default memory manager for memory
 /// allocation use. If 'threadSafe' is true, then creates a leaf memory pool
 /// with thread-safe memory usage tracking.
-std::shared_ptr<MemoryPool> addDefaultLeafMemoryPool(
+std::shared_ptr<MemoryPool> deprecatedAddDefaultLeafMemoryPool(
     const std::string& name = "",
     bool threadSafe = true);
 
@@ -257,6 +426,9 @@ memory::MemoryPool* spillMemoryPool();
 /// Returns true if the provided 'pool' is the spilling memory pool.
 bool isSpillMemoryPool(memory::MemoryPool* pool);
 
+/// Returns the system-wide memory pool for tracing memory usage.
+memory::MemoryPool* traceMemoryPool();
+
 FOLLY_ALWAYS_INLINE int32_t alignmentPadding(void* address, int32_t alignment) {
   auto extra = reinterpret_cast<uintptr_t>(address) % alignment;
   return extra == 0 ? 0 : alignment - extra;
diff --git a/velox/common/memory/MemoryAllocator.cpp b/velox/common/memory/MemoryAllocator.cpp
index f2da6e71f0818..2dd22b2ff5777 100644
--- a/velox/common/memory/MemoryAllocator.cpp
+++ b/velox/common/memory/MemoryAllocator.cpp
@@ -18,6 +18,7 @@
 #include "velox/common/memory/MallocAllocator.h"
 
 #include <sys/mman.h>
+#include <sys/resource.h>
 #include <iostream>
 #include <numeric>
 
@@ -28,9 +29,39 @@ DECLARE_bool(velox_memory_use_hugepages);
 
 namespace facebook::velox::memory {
 
-std::shared_ptr<MemoryAllocator> MemoryAllocator::instance_;
-MemoryAllocator* MemoryAllocator::customInstance_;
-std::mutex MemoryAllocator::initMutex_;
+// static
+std::vector<MachinePageCount> MemoryAllocator::makeSizeClassSizes(
+    MachinePageCount largest) {
+  VELOX_CHECK_LE(256, largest);
+  VELOX_CHECK_EQ(largest, bits::nextPowerOfTwo(largest));
+  std::vector<MachinePageCount> sizes;
+  for (auto size = 1; size <= largest; size *= 2) {
+    sizes.push_back(size);
+  }
+  return sizes;
+}
+
+namespace {
+std::string& cacheFailureMessage() {
+  thread_local std::string message;
+  return message;
+}
+
+std::string& allocatorFailureMessage() {
+  thread_local std::string errMsg;
+  return errMsg;
+}
+} // namespace
+
+void setCacheFailureMessage(std::string message) {
+  cacheFailureMessage() = std::move(message);
+}
+
+std::string getAndClearCacheFailureMessage() {
+  auto errMsg = std::move(cacheFailureMessage());
+  cacheFailureMessage().clear(); // ensure its in valid state
+  return errMsg;
+}
 
 std::string MemoryAllocator::kindString(Kind kind) {
   switch (kind) {
@@ -57,78 +88,49 @@ MemoryAllocator::SizeMix MemoryAllocator::allocationSize(
       "Requesting minimum size {} larger than largest size class {}",
       minSizeClass,
       sizeClassSizes_.back());
-
   MemoryAllocator::SizeMix mix;
-  int32_t needed = numPages;
-  int32_t pagesToAlloc = 0;
+  int32_t neededPages = numPages;
+  MachinePageCount pagesToAlloc{0};
   for (int32_t sizeIndex = sizeClassSizes_.size() - 1; sizeIndex >= 0;
        --sizeIndex) {
-    const int32_t size = sizeClassSizes_[sizeIndex];
+    const MachinePageCount classPageSize = sizeClassSizes_[sizeIndex];
     const bool isSmallest =
         sizeIndex == 0 || sizeClassSizes_[sizeIndex - 1] < minSizeClass;
     // If the size is less than 1/8 of the size from the next larger,
     // use the next larger size.
-    if (size > (needed + (needed / 8)) && !isSmallest) {
+    if (classPageSize > (neededPages + (neededPages / 8)) && !isSmallest) {
       continue;
     }
-    int32_t numUnits = std::max(1, needed / size);
-    needed -= numUnits * size;
-    if (isSmallest && needed > 0) {
-      // If needed / size had a remainder, add one more unit. Do this
-      // if the present size class is the smallest or 'minSizeClass'
-      // size.
-      ++numUnits;
-      needed -= size;
-    }
-    if (FOLLY_UNLIKELY(numUnits * size > Allocation::PageRun::kMaxPagesInRun)) {
-      VELOX_MEM_ALLOC_ERROR(fmt::format(
-          "Too many pages {} to allocate, the number of units {} at size class of {} exceeds the PageRun limit {}",
-          numPages,
-          numUnits,
-          size,
-          Allocation::PageRun::kMaxPagesInRun));
+    const MachinePageCount maxNumClassPages =
+        Allocation::PageRun::kMaxPagesInRun / classPageSize;
+    MachinePageCount numClassPages = std::min<int32_t>(
+        maxNumClassPages,
+        std::max<MachinePageCount>(1, neededPages / classPageSize));
+    neededPages -= numClassPages * classPageSize;
+    if (isSmallest && neededPages > 0 && numClassPages < maxNumClassPages) {
+      // If needed / size had a remainder, add one more unit. Do this if the
+      // present size class is the smallest or 'minSizeClass' size.
+      ++numClassPages;
+      neededPages -= classPageSize;
     }
-    mix.sizeCounts[mix.numSizes] = numUnits;
-    pagesToAlloc += numUnits * size;
-    mix.sizeIndices[mix.numSizes++] = sizeIndex;
-    if (needed <= 0) {
+    VELOX_CHECK_LE(
+        classPageSize * numClassPages, Allocation::PageRun::kMaxPagesInRun);
+
+    mix.sizeCounts.push_back(numClassPages);
+    mix.sizeIndices.push_back(sizeIndex);
+    ++mix.numSizes;
+    pagesToAlloc += numClassPages * classPageSize;
+    if (neededPages <= 0) {
       break;
     }
+    if (FOLLY_UNLIKELY(numClassPages == maxNumClassPages)) {
+      ++sizeIndex;
+    }
   }
   mix.totalPages = pagesToAlloc;
   return mix;
 }
 
-// static
-MemoryAllocator* MemoryAllocator::getInstance() {
-  std::lock_guard<std::mutex> l(initMutex_);
-  if (customInstance_ != nullptr) {
-    return customInstance_;
-  }
-  if (instance_ != nullptr) {
-    return instance_.get();
-  }
-  instance_ = createDefaultInstance();
-  return instance_.get();
-}
-
-// static
-std::shared_ptr<MemoryAllocator> MemoryAllocator::createDefaultInstance() {
-  return std::make_shared<MallocAllocator>(kDefaultCapacityBytes);
-}
-
-// static
-void MemoryAllocator::setDefaultInstance(MemoryAllocator* instance) {
-  std::lock_guard<std::mutex> l(initMutex_);
-  customInstance_ = instance;
-}
-
-// static
-void MemoryAllocator::testingDestroyInstance() {
-  std::lock_guard<std::mutex> l(initMutex_);
-  instance_ = nullptr;
-}
-
 // static
 bool MemoryAllocator::isAlignmentValid(
     uint64_t allocateBytes,
@@ -154,8 +156,7 @@ void MemoryAllocator::alignmentCheck(
 MachinePageCount MemoryAllocator::roundUpToSizeClassSize(
     size_t bytes,
     const std::vector<MachinePageCount>& sizes) {
-  auto pages = bits::roundUp(bytes, AllocationTraits::kPageSize) /
-      AllocationTraits::kPageSize;
+  auto pages = AllocationTraits::numPages(bytes);
   VELOX_CHECK_LE(pages, sizes.back());
   return *std::lower_bound(sizes.begin(), sizes.end(), pages);
 }
@@ -173,26 +174,57 @@ bool MemoryAllocator::allocateNonContiguous(
     Allocation& out,
     ReservationCallback reservationCB,
     MachinePageCount minSizeClass) {
+  const MachinePageCount numPagesToFree = out.numPages();
+  const uint64_t bytesToFree = AllocationTraits::pageBytes(numPagesToFree);
+  auto cleanupAllocAndReleaseReservation = [&](uint64_t reservationBytes) {
+    if (!out.empty()) {
+      freeNonContiguous(out);
+    }
+    if (reservationCB != nullptr && reservationBytes > 0) {
+      reservationCB(reservationBytes, false);
+    }
+  };
+  if (numPages == 0) {
+    cleanupAllocAndReleaseReservation(bytesToFree);
+    return true;
+  }
+
+  const SizeMix mix = allocationSize(numPages, minSizeClass);
+  if (reservationCB != nullptr) {
+    if (mix.totalPages >= numPagesToFree) {
+      const uint64_t numNeededPages = mix.totalPages - numPagesToFree;
+      try {
+        reservationCB(AllocationTraits::pageBytes(numNeededPages), true);
+      } catch (const std::exception&) {
+        VELOX_MEM_LOG_EVERY_MS(WARNING, 1'000)
+            << "Exceeded memory reservation limit when reserve "
+            << numNeededPages << " new pages when allocate " << mix.totalPages
+            << " pages";
+        cleanupAllocAndReleaseReservation(bytesToFree);
+        std::rethrow_exception(std::current_exception());
+      }
+    } else {
+      const uint64_t numExtraPages = numPagesToFree - mix.totalPages;
+      reservationCB(AllocationTraits::pageBytes(numExtraPages), false);
+    }
+  }
+
+  const auto totalBytesReserved = AllocationTraits::pageBytes(mix.totalPages);
+  bool success = false;
   if (cache() == nullptr) {
-    return allocateNonContiguousWithoutRetry(
-        numPages, out, reservationCB, minSizeClass);
+    success = allocateNonContiguousWithoutRetry(mix, out);
+  } else {
+    success = cache()->makeSpace(
+        pagesToAcquire(numPages, out.numPages()), [&](Allocation& acquired) {
+          freeNonContiguous(acquired);
+          return allocateNonContiguousWithoutRetry(mix, out);
+        });
   }
-  bool success = cache()->makeSpace(
-      pagesToAcquire(numPages, out.numPages()), [&](Allocation& acquired) {
-        freeNonContiguous(acquired);
-        return allocateNonContiguousWithoutRetry(
-            numPages, out, reservationCB, minSizeClass);
-      });
   if (!success) {
     // There can be a failure where allocation was never called because there
     // never was a chance based on numAllocated() and capacity(). Make sure old
     // data is still freed.
-    if (!out.empty()) {
-      if (reservationCB) {
-        reservationCB(AllocationTraits::pageBytes(out.numPages()), false);
-      }
-      freeNonContiguous(out);
-    }
+    cleanupAllocAndReleaseReservation(totalBytesReserved);
   }
   return success;
 }
@@ -203,38 +235,66 @@ bool MemoryAllocator::allocateContiguous(
     ContiguousAllocation& allocation,
     ReservationCallback reservationCB,
     MachinePageCount maxPages) {
-  if (cache() == nullptr) {
-    return allocateContiguousWithoutRetry(
-        numPages, collateral, allocation, reservationCB, maxPages);
-  }
-  auto numCollateralPages =
+  const MachinePageCount numCollateralPages =
       allocation.numPages() + (collateral ? collateral->numPages() : 0);
-  bool success = cache()->makeSpace(
-      pagesToAcquire(numPages, numCollateralPages), [&](Allocation& acquired) {
-        freeNonContiguous(acquired);
-        return allocateContiguousWithoutRetry(
-            numPages, collateral, allocation, reservationCB, maxPages);
-      });
-  if (!success) {
-    // never was a chance based on numAllocated() and capacity(). Make sure old
-    // data is still freed.
-    int64_t bytes = 0;
-    ;
-    if (collateral && !collateral->empty()) {
-      if (reservationCB) {
-        bytes += AllocationTraits::pageBytes(collateral->numPages());
-      }
+  const uint64_t totalCollateralBytes =
+      AllocationTraits::pageBytes(numCollateralPages);
+  auto cleanupCollateralAndReleaseReservation = [&](uint64_t reservationBytes) {
+    if ((collateral != nullptr) && !collateral->empty()) {
       freeNonContiguous(*collateral);
     }
     if (!allocation.empty()) {
-      if (reservationCB) {
-        bytes += allocation.size();
-      }
       freeContiguous(allocation);
     }
-    if (bytes) {
-      reservationCB(bytes, false);
+    if ((reservationCB) != nullptr && (reservationBytes > 0)) {
+      reservationCB(reservationBytes, false);
     }
+  };
+
+  if (numPages == 0) {
+    cleanupCollateralAndReleaseReservation(totalCollateralBytes);
+    return true;
+  }
+
+  if (reservationCB != nullptr) {
+    if (numPages >= numCollateralPages) {
+      const int64_t numNeededPages = numPages - numCollateralPages;
+      try {
+        reservationCB(AllocationTraits::pageBytes(numNeededPages), true);
+      } catch (const std::exception& e) {
+        VELOX_MEM_LOG_EVERY_MS(WARNING, 1'000)
+            << "Exceeded memory reservation limit when reserve "
+            << numNeededPages << " new pages when allocate " << numPages
+            << " pages, error: " << e.what();
+        cleanupCollateralAndReleaseReservation(totalCollateralBytes);
+        std::rethrow_exception(std::current_exception());
+      }
+    } else {
+      const uint64_t numExtraPages = numCollateralPages - numPages;
+      reservationCB(AllocationTraits::pageBytes(numExtraPages), false);
+    }
+  }
+
+  const uint64_t totalBytesReserved = AllocationTraits::pageBytes(numPages);
+  bool success = false;
+  if (cache() == nullptr) {
+    success = allocateContiguousWithoutRetry(
+        numPages, collateral, allocation, maxPages);
+  } else {
+    success = cache()->makeSpace(
+        pagesToAcquire(numPages, numCollateralPages),
+        [&](Allocation& acquired) {
+          freeNonContiguous(acquired);
+          return allocateContiguousWithoutRetry(
+              numPages, collateral, allocation, maxPages);
+        });
+  }
+
+  if (!success) {
+    // There can be a failure where allocation was never called because there
+    // never was a chance based on numAllocated() and capacity(). Make sure old
+    // data is still freed.
+    cleanupCollateralAndReleaseReservation(totalBytesReserved);
   }
   return success;
 }
@@ -243,13 +303,29 @@ bool MemoryAllocator::growContiguous(
     MachinePageCount increment,
     ContiguousAllocation& allocation,
     ReservationCallback reservationCB) {
+  VELOX_CHECK_LE(
+      allocation.size() + increment * AllocationTraits::kPageSize,
+      allocation.maxSize());
+  if (increment == 0) {
+    return true;
+  }
+  if (reservationCB != nullptr) {
+    // May throw. If it does, there is nothing to revert.
+    reservationCB(AllocationTraits::pageBytes(increment), true);
+  }
+  bool success = false;
   if (cache() == nullptr) {
-    return growContiguousWithoutRetry(increment, allocation, reservationCB);
+    success = growContiguousWithoutRetry(increment, allocation);
+  } else {
+    success = cache()->makeSpace(increment, [&](Allocation& acquired) {
+      freeNonContiguous(acquired);
+      return growContiguousWithoutRetry(increment, allocation);
+    });
   }
-  return cache()->makeSpace(increment, [&](Allocation& acquired) {
-    freeNonContiguous(acquired);
-    return growContiguousWithoutRetry(increment, allocation, reservationCB);
-  });
+  if (!success && reservationCB != nullptr) {
+    reservationCB(AllocationTraits::pageBytes(increment), false);
+  }
+  return success;
 }
 
 void* MemoryAllocator::allocateBytes(uint64_t bytes, uint16_t alignment) {
@@ -301,14 +377,17 @@ std::string Stats::toString() const {
   std::stringstream out;
   int64_t totalClocks = 0;
   int64_t totalBytes = 0;
+  int64_t totalAllocations = 0;
   for (auto i = 0; i < sizes.size(); ++i) {
     totalClocks += sizes[i].clocks();
     totalBytes += sizes[i].totalBytes;
+    totalAllocations += sizes[i].numAllocations;
   }
   out << fmt::format(
-      "Alloc: {}MB {} Gigaclocks, {}MB advised\n",
+      "Alloc: {}MB {} Gigaclocks Allocations={}, advised={} MB\n",
       totalBytes >> 20,
       totalClocks >> 30,
+      totalAllocations,
       numAdvise >> 8);
 
   // Sort the size classes by decreasing clocks.
@@ -323,10 +402,11 @@ std::string Stats::toString() const {
       break;
     }
     out << fmt::format(
-        "Size {}K: {}MB {} Megaclocks\n",
+        "Size {}K: {}MB {} Megaclocks {} Allocations\n",
         sizes[i].size * 4,
         sizes[i].totalBytes >> 20,
-        sizes[i].clocks() >> 20);
+        sizes[i].clocks() >> 20,
+        sizes[i].numAllocations);
   }
   return out.str();
 }
@@ -353,4 +433,82 @@ void MemoryAllocator::useHugePages(
 #endif
 }
 
+void MemoryAllocator::setAllocatorFailureMessage(std::string message) {
+  allocatorFailureMessage() = std::move(message);
+}
+
+std::string MemoryAllocator::getAndClearFailureMessage() {
+  auto allocatorErrMsg = std::move(allocatorFailureMessage());
+  allocatorFailureMessage().clear();
+  if (cache()) {
+    if (allocatorErrMsg.empty()) {
+      return getAndClearCacheFailureMessage();
+    }
+    allocatorErrMsg =
+        fmt::format("{} {}", allocatorErrMsg, getAndClearCacheFailureMessage());
+  }
+  return allocatorErrMsg;
+}
+
+namespace {
+struct TraceState {
+  struct rusage rusage;
+  Stats allocatorStats;
+  int64_t ioTotal;
+  struct timeval tv;
+};
+
+int64_t toUsec(struct timeval tv) {
+  return tv.tv_sec * 1000000LL + tv.tv_usec;
+}
+
+int32_t elapsedUsec(struct timeval end, struct timeval begin) {
+  return toUsec(end) - toUsec(begin);
+}
+} // namespace
+
+void MemoryAllocator::getTracingHooks(
+    std::function<void()>& init,
+    std::function<std::string()>& report,
+    std::function<int64_t()> ioVolume) {
+  auto allocator = shared_from_this();
+  auto state = std::make_shared<TraceState>();
+  init = [state, allocator, ioVolume]() {
+    getrusage(RUSAGE_SELF, &state->rusage);
+    struct timezone tz;
+    gettimeofday(&state->tv, &tz);
+    state->allocatorStats = allocator->stats();
+    state->ioTotal = ioVolume ? ioVolume() : 0;
+  };
+  report = [state, allocator, ioVolume]() -> std::string {
+    struct rusage rusage;
+    getrusage(RUSAGE_SELF, &rusage);
+    auto newStats = allocator->stats();
+    float u = elapsedUsec(rusage.ru_utime, state->rusage.ru_utime);
+    float s = elapsedUsec(rusage.ru_stime, state->rusage.ru_stime);
+    auto m = allocator->stats() - state->allocatorStats;
+    float flt = rusage.ru_minflt - state->rusage.ru_minflt;
+    struct timeval tv;
+    struct timezone tz;
+    gettimeofday(&tv, &tz);
+    float elapsed = elapsedUsec(tv, state->tv);
+    int64_t io = 0;
+    if (ioVolume) {
+      io = ioVolume() - state->ioTotal;
+    }
+    std::stringstream out;
+    out << std::endl
+        << std::endl
+        << fmt::format(
+               "user%={} sys%={} minflt/s={}, io={} MB/s\n",
+               100 * u / elapsed,
+               100 * s / elapsed,
+               flt / (elapsed / 1000000),
+               io / (elapsed));
+    out << m.toString() << std::endl;
+    out << allocator->toString() << std::endl;
+    return out.str();
+  };
+}
+
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/MemoryAllocator.h b/velox/common/memory/MemoryAllocator.h
index bba5db0bc1280..4a7ac706c7151 100644
--- a/velox/common/memory/MemoryAllocator.h
+++ b/velox/common/memory/MemoryAllocator.h
@@ -23,14 +23,13 @@
 #include <mutex>
 #include <unordered_set>
 
+#include <fmt/format.h>
 #include <gflags/gflags.h>
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/memory/Allocation.h"
 #include "velox/common/time/Timer.h"
 
-DECLARE_bool(velox_use_malloc);
-DECLARE_int32(velox_memory_pool_mb);
 DECLARE_bool(velox_time_allocations);
 
 namespace facebook::velox::memory {
@@ -141,11 +140,12 @@ struct Stats {
 
 class MemoryAllocator;
 
-/// A general cache interface using 'MemroyAllocator' to allocate memory, that
+/// A general cache interface using 'MemoryAllocator' to allocate memory, that
 /// is also able to free up memory upon request by shrinking itself.
 class Cache {
  public:
   virtual ~Cache() = default;
+
   /// This method should be implemented so that it tries to
   /// accommodate the passed in 'allocate' by freeing up space from
   /// 'this' if needed. 'numPages' is the number of pages 'allocate
@@ -158,9 +158,24 @@ class Cache {
       memory::MachinePageCount numPages,
       std::function<bool(Allocation&)> allocate) = 0;
 
+  /// This method is implemented to shrink the cache space with the specified
+  /// 'targetBytes'. The method returns the actually freed cache space in bytes.
+  virtual uint64_t shrink(uint64_t targetBytes) = 0;
+
   virtual MemoryAllocator* allocator() const = 0;
 };
 
+/// Sets a thread level failure message describing cache state. Used
+/// for example to expose why space could not be freed from
+/// cache. This is defined here with the abstract Cache base class
+/// and not the cache implementation because allocator cannot depend
+/// on cache.
+void setCacheFailureMessage(std::string message);
+
+/// Returns and clears a thread local message set with
+/// setCacheFailureMessage().
+std::string getAndClearCacheFailureMessage();
+
 /// This class provides interface for the actual memory allocations from memory
 /// pool. It allocates runs of machine pages from predefined size classes, and
 /// supports both contiguous and non-contiguous memory allocations. An
@@ -183,35 +198,18 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
     kMalloc,
     /// The memory allocator kind which is implemented by MmapAllocator. It
     /// manages the large chunk of memory allocations on its own by leveraging
-    /// mmap and madvice, to optimize the memory fragmentation in the long
+    /// mmap and madvise, to optimize the memory fragmentation in the long
     /// running service such as Prestissimo.
     kMmap,
   };
 
   static std::string kindString(Kind kind);
 
-  /// Returns the process-wide default instance or an application-supplied
-  /// custom instance set via setDefaultInstance().
-  static MemoryAllocator* getInstance();
-
-  /// Overrides the process-wide default instance. The caller keeps ownership
-  /// and must not destroy the instance until it is empty. Calling this with
-  /// nullptr restores the initial process-wide default instance.
-  static void setDefaultInstance(MemoryAllocator* instance);
-
-  /// Creates a default MemoryAllocator instance but does not set this to
-  /// process default.
-  static std::shared_ptr<MemoryAllocator> createDefaultInstance();
-
-  static void testingDestroyInstance();
-
   virtual ~MemoryAllocator() = default;
 
   static constexpr int32_t kMaxSizeClasses = 12;
   static constexpr uint16_t kMinAlignment = alignof(max_align_t);
   static constexpr uint16_t kMaxAlignment = 64;
-  static constexpr uint64_t kDefaultCapacityBytes =
-      std::numeric_limits<int64_t>::max();
 
   /// Returns the kind of this memory allocator. For AsyncDataCache, it returns
   /// the kind of the delegated memory allocator underneath.
@@ -222,7 +220,7 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
   /// the same as 'this'.
   virtual void registerCache(const std::shared_ptr<Cache>& cache) = 0;
 
-  using ReservationCallback = std::function<void(int64_t, bool)>;
+  using ReservationCallback = std::function<void(uint64_t, bool)>;
 
   /// Returns the capacity of the allocator in bytes.
   virtual size_t capacity() const = 0;
@@ -317,6 +315,12 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
   /// reallocateBytes.
   virtual void freeBytes(void* p, uint64_t size) noexcept = 0;
 
+  /// Unmaps the unused memory space to return the backing physical pages back
+  /// to the operating system. This only works for MmapAllocator implementation
+  /// which manages the physical memory on its own by mmap. The function returns
+  /// the number of actual unmapped physical pages.
+  virtual MachinePageCount unmap(MachinePageCount targetPages) = 0;
+
   /// Checks internal consistency of allocation data structures. Returns true if
   /// OK.
   virtual bool checkConsistency() const = 0;
@@ -387,8 +391,45 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
     isPersistentFailureInjection_ = false;
   }
 
+  /// Sets a thread level failure message describing the reason for the last
+  /// allocation failure.
+  void setAllocatorFailureMessage(std::string message);
+
+  /// Returns extra information after returning false from any of the allocate
+  /// functions. The error message is scoped to the most recent call on the
+  /// thread. The message is cleared after return.
+  std::string getAndClearFailureMessage();
+
+  void getTracingHooks(
+      std::function<void()>& init,
+      std::function<std::string()>& report,
+      std::function<int64_t()> ioVolume = nullptr);
+
  protected:
-  explicit MemoryAllocator() = default;
+  MemoryAllocator(MachinePageCount largestSizeClassPages = 256)
+      : sizeClassSizes_(makeSizeClassSizes(largestSizeClassPages)) {}
+
+  static std::vector<MachinePageCount> makeSizeClassSizes(
+      MachinePageCount largest);
+
+  /// Represents a mix of blocks of different sizes for covering a single
+  /// allocation.
+  struct SizeMix {
+    // Index into 'sizeClassSizes_'
+    std::vector<int32_t> sizeIndices;
+    // Number of items of the class of the corresponding element in
+    // '"sizeIndices'.
+    std::vector<int32_t> sizeCounts;
+    // Number of valid elements in 'sizeCounts' and 'sizeIndices'.
+    int32_t numSizes{0};
+    // Total number of pages.
+    int32_t totalPages{0};
+
+    SizeMix() {
+      sizeIndices.reserve(kMaxSizeClasses);
+      sizeCounts.reserve(kMaxSizeClasses);
+    }
+  };
 
   /// The actual memory allocation function implementation without retry
   /// attempts by making space from cache.
@@ -396,14 +437,11 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
       MachinePageCount numPages,
       Allocation* collateral,
       ContiguousAllocation& allocation,
-      ReservationCallback reservationCB = nullptr,
       MachinePageCount maxPages = 0) = 0;
 
   virtual bool allocateNonContiguousWithoutRetry(
-      MachinePageCount numPages,
-      Allocation& out,
-      ReservationCallback reservationCB,
-      MachinePageCount minSizeClass) = 0;
+      const SizeMix& sizeMix,
+      Allocation& out) = 0;
 
   virtual void* allocateBytesWithoutRetry(
       uint64_t bytes,
@@ -413,8 +451,7 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
 
   virtual bool growContiguousWithoutRetry(
       MachinePageCount increment,
-      ContiguousAllocation& allocation,
-      ReservationCallback reservationCB = nullptr) = 0;
+      ContiguousAllocation& allocation) = 0;
 
   // 'Cache' getter. The cache is only responsible for freeing up memory space
   // by shrinking itself when there is not enough space upon allocating. The
@@ -426,20 +463,6 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
       size_t bytes,
       const std::vector<MachinePageCount>& sizes);
 
-  // Represents a mix of blocks of different sizes for covering a single
-  // allocation.
-  struct SizeMix {
-    // Index into 'sizeClassSizes_'
-    std::array<int32_t, kMaxSizeClasses> sizeIndices{};
-    // Number of items of the class of the corresponding element in
-    // '"sizeIndices'.
-    std::array<int32_t, kMaxSizeClasses> sizeCounts{};
-    // Number of valid elements in 'sizeCounts' and 'sizeIndices'.
-    int32_t numSizes{0};
-    // Total number of pages.
-    int32_t totalPages{0};
-  };
-
   // Returns a mix of standard sizes and allocation counts for covering
   // 'numPages' worth of memory. 'minSizeClass' is the size of the
   // smallest usable size class.
@@ -457,8 +480,8 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
     return true;
   }
 
-  // If 'data' is sufficiently large, enables/disables adaptive  huge pages for
-  // the address raneg.
+  // If 'data' is sufficiently large, enables/disables adaptive  huge pages
+  // for the address range.
   void useHugePages(const ContiguousAllocation& data, bool enable);
 
   // The machine page counts corresponding to different sizes in order
@@ -466,17 +489,17 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
   const std::vector<MachinePageCount>
       sizeClassSizes_{1, 2, 4, 8, 16, 32, 64, 128, 256};
 
-  // Tracks the number of allocated pages. Allocated pages are the memory pages
-  // that are currently being used.
+  // Tracks the number of allocated pages. Allocated pages are the memory
+  // pages that are currently being used.
   std::atomic<MachinePageCount> numAllocated_{0};
 
   // Tracks the number of mapped pages. Mapped pages are the memory pages that
   // meet following requirements:
   // 1. They are obtained from the operating system from mmap calls directly,
   // without going through std::malloc.
-  // 2. They are currently being allocated (used) or they were allocated (used)
-  // and freed in the past but haven't been returned to the operating system by
-  // 'this' (via madvise calls).
+  // 2. They are currently being allocated (used) or they were allocated
+  // (used) and freed in the past but haven't been returned to the operating
+  // system by 'this' (via madvise calls).
   std::atomic<MachinePageCount> numMapped_{0};
 
   // Indicates if the failure injection is persistent or transient.
@@ -486,15 +509,16 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
   bool isPersistentFailureInjection_{false};
 
   Stats stats_;
-
- private:
-  static std::mutex initMutex_;
-  // Singleton instance.
-  static std::shared_ptr<MemoryAllocator> instance_;
-  // Application-supplied custom implementation of MemoryAllocator to be
-  // returned by getInstance().
-  static MemoryAllocator* customInstance_;
 };
 
 std::ostream& operator<<(std::ostream& out, const MemoryAllocator::Kind& kind);
 } // namespace facebook::velox::memory
+template <>
+struct fmt::formatter<facebook::velox::memory::MemoryAllocator::InjectedFailure>
+    : fmt::formatter<int> {
+  auto format(
+      facebook::velox::memory::MemoryAllocator::InjectedFailure s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/common/memory/MemoryArbitrator.cpp b/velox/common/memory/MemoryArbitrator.cpp
index c5d596aa34c41..5bfff0ec64afb 100644
--- a/velox/common/memory/MemoryArbitrator.cpp
+++ b/velox/common/memory/MemoryArbitrator.cpp
@@ -18,23 +18,26 @@
 
 #include <utility>
 
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/memory/Memory.h"
-#include "velox/common/memory/SharedArbitrator.h"
 
 namespace facebook::velox::memory {
 
 namespace {
 class FactoryRegistry {
  public:
-  void registerFactory(
+  bool registerFactory(
       const std::string& kind,
       MemoryArbitrator::Factory factory) {
     std::lock_guard<std::mutex> l(mutex_);
     VELOX_USER_CHECK(
         map_.find(kind) == map_.end(),
-        "Arbitrator factory for kind {} already registered",
-        kind)
+        "Arbitrator factory for kind {} is already registered",
+        kind);
     map_[kind] = std::move(factory);
+    return true;
   }
 
   MemoryArbitrator::Factory& getFactory(const std::string& kind) {
@@ -42,7 +45,7 @@ class FactoryRegistry {
     VELOX_USER_CHECK(
         map_.find(kind) != map_.end(),
         "Arbitrator factory for kind {} not registered",
-        kind)
+        kind);
     return map_[kind];
   }
 
@@ -51,7 +54,7 @@ class FactoryRegistry {
     VELOX_USER_CHECK(
         map_.find(kind) != map_.end(),
         "Arbitrator factory for kind {} not registered",
-        kind)
+        kind);
     return map_.erase(kind);
   }
 
@@ -88,32 +91,34 @@ class NoopArbitrator : public MemoryArbitrator {
     return "NOOP";
   }
 
-  // Noop arbitrator has no memory capacity limit so no operation needed for
-  // memory pool capacity reserve.
-  void reserveMemory(MemoryPool* pool, uint64_t /*unused*/) override {
-    pool->grow(pool->maxCapacity());
+  void addPool(const std::shared_ptr<MemoryPool>& pool) override {
+    VELOX_CHECK_EQ(pool->capacity(), 0);
+    growPool(pool.get(), pool->maxCapacity(), 0);
   }
 
-  // Noop arbitrator has no memory capacity limit so no operation needed for
-  // memory pool capacity release.
-  void releaseMemory(MemoryPool* /*unused*/) override {
-    // No-op
+  void removePool(MemoryPool* pool) override {
+    VELOX_CHECK_EQ(pool->reservedBytes(), 0);
   }
 
   // Noop arbitrator has no memory capacity limit so no operation needed for
   // memory pool capacity grow.
-  bool growMemory(
-      MemoryPool* /*unused*/,
-      const std::vector<std::shared_ptr<MemoryPool>>& /*unused*/,
-      uint64_t /*unused*/) override {
+  bool growCapacity(MemoryPool* /*unused*/, uint64_t /*unused*/) override {
     return false;
   }
 
+  // Noop arbitrator has no memory capacity limit so no operation needed for
+  // memory pool capacity release.
+  uint64_t shrinkCapacity(MemoryPool* pool, uint64_t /*unused*/) override {
+    // No-op
+    return 0;
+  }
+
   // Noop arbitrator has no memory capacity limit so no operation needed for
   // memory pool capacity shrink.
-  uint64_t shrinkMemory(
-      const std::vector<std::shared_ptr<MemoryPool>>& /*unused*/,
-      uint64_t /*unused*/) override {
+  uint64_t shrinkCapacity(
+      uint64_t /* unused */,
+      bool /* unused */,
+      bool /* unused */) override {
     return 0;
   }
 
@@ -144,28 +149,62 @@ std::unique_ptr<MemoryArbitrator> MemoryArbitrator::create(
   return factory(config);
 }
 
-void MemoryArbitrator::registerFactory(
+bool MemoryArbitrator::registerFactory(
     const std::string& kind,
     MemoryArbitrator::Factory factory) {
-  arbitratorFactories().registerFactory(kind, std::move(factory));
+  return arbitratorFactories().registerFactory(kind, std::move(factory));
 }
 
 void MemoryArbitrator::unregisterFactory(const std::string& kind) {
   arbitratorFactories().unregisterFactory(kind);
 }
 
-void MemoryArbitrator::registerAllFactories() {
-  SharedArbitrator::registerFactory();
+/*static*/ bool MemoryArbitrator::growPool(
+    MemoryPool* pool,
+    uint64_t growBytes,
+    uint64_t reservationBytes) {
+  return pool->grow(growBytes, reservationBytes);
 }
 
-void MemoryArbitrator::unregisterAllFactories() {
-  SharedArbitrator::unregisterFactory();
+/*static*/ uint64_t MemoryArbitrator::shrinkPool(
+    MemoryPool* pool,
+    uint64_t targetBytes) {
+  return pool->shrink(targetBytes);
 }
 
 std::unique_ptr<MemoryReclaimer> MemoryReclaimer::create() {
   return std::unique_ptr<MemoryReclaimer>(new MemoryReclaimer());
 }
 
+// static
+uint64_t MemoryReclaimer::run(
+    const std::function<int64_t()>& func,
+    Stats& stats) {
+  VELOX_CHECK(underMemoryArbitration());
+  uint64_t execTimeUs{0};
+  int64_t reclaimedBytes{0};
+  {
+    MicrosecondTimer timer{&execTimeUs};
+    reclaimedBytes = func();
+  }
+  VELOX_CHECK_GE(reclaimedBytes, 0);
+  stats.reclaimExecTimeUs += execTimeUs;
+  stats.reclaimedBytes += reclaimedBytes;
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricMemoryReclaimExecTimeMs, execTimeUs / 1'000);
+  RECORD_HISTOGRAM_METRIC_VALUE(kMetricMemoryReclaimedBytes, reclaimedBytes);
+  RECORD_METRIC_VALUE(kMetricMemoryReclaimCount);
+  addThreadLocalRuntimeStat(
+      "memoryReclaimWallNanos",
+      RuntimeCounter(execTimeUs * 1'000, RuntimeCounter::Unit::kNanos));
+  addThreadLocalRuntimeStat(
+      "memoryReclaimCount", RuntimeCounter(1, RuntimeCounter::Unit::kNone));
+  addThreadLocalRuntimeStat(
+      "reclaimedMemoryBytes",
+      RuntimeCounter(reclaimedBytes, RuntimeCounter::Unit::kBytes));
+  return reclaimedBytes;
+}
+
 bool MemoryReclaimer::reclaimableBytes(
     const MemoryPool& pool,
     uint64_t& reclaimableBytes) const {
@@ -175,17 +214,20 @@ bool MemoryReclaimer::reclaimableBytes(
   }
   bool reclaimable{false};
   pool.visitChildren([&](MemoryPool* pool) {
-    uint64_t poolReclaimableBytes{0};
-    reclaimable |= pool->reclaimableBytes(poolReclaimableBytes);
-    reclaimableBytes += poolReclaimableBytes;
+    auto reclaimableBytesOpt = pool->reclaimableBytes();
+    reclaimable |= reclaimableBytesOpt.has_value();
+    reclaimableBytes += reclaimableBytesOpt.value_or(0);
     return true;
   });
   VELOX_CHECK(reclaimable || reclaimableBytes == 0);
   return reclaimable;
 }
 
-uint64_t
-MemoryReclaimer::reclaim(MemoryPool* pool, uint64_t targetBytes, Stats& stats) {
+uint64_t MemoryReclaimer::reclaim(
+    MemoryPool* pool,
+    uint64_t targetBytes,
+    uint64_t maxWaitMs,
+    Stats& stats) {
   if (pool->kind() == MemoryPool::Kind::kLeaf) {
     return 0;
   }
@@ -194,15 +236,18 @@ MemoryReclaimer::reclaim(MemoryPool* pool, uint64_t targetBytes, Stats& stats) {
   // child pool with most reservation first.
   struct Candidate {
     std::shared_ptr<memory::MemoryPool> pool;
-    int64_t reservedBytes;
+    int64_t reclaimableBytes;
   };
   std::vector<Candidate> candidates;
-  candidates.reserve(pool->children_.size());
-  for (auto& entry : pool->children_) {
-    auto child = entry.second.lock();
-    if (child != nullptr) {
-      const int64_t reservedBytes = child->reservedBytes();
-      candidates.push_back(Candidate{std::move(child), reservedBytes});
+  {
+    std::shared_lock guard{pool->poolMutex_};
+    candidates.reserve(pool->children_.size());
+    for (auto& entry : pool->children_) {
+      auto child = entry.second.lock();
+      if (child != nullptr) {
+        const int64_t reclaimableBytes = child->reclaimableBytes().value_or(0);
+        candidates.push_back(Candidate{std::move(child), reclaimableBytes});
+      }
     }
   }
 
@@ -210,12 +255,15 @@ MemoryReclaimer::reclaim(MemoryPool* pool, uint64_t targetBytes, Stats& stats) {
       candidates.begin(),
       candidates.end(),
       [](const auto& lhs, const auto& rhs) {
-        return lhs.reservedBytes > rhs.reservedBytes;
+        return lhs.reclaimableBytes > rhs.reclaimableBytes;
       });
 
   uint64_t reclaimedBytes{0};
   for (const auto& candidate : candidates) {
-    const auto bytes = candidate.pool->reclaim(targetBytes, stats);
+    if (candidate.reclaimableBytes == 0) {
+      break;
+    }
+    const auto bytes = candidate.pool->reclaim(targetBytes, maxWaitMs, stats);
     reclaimedBytes += bytes;
     if (targetBytes != 0) {
       if (bytes >= targetBytes) {
@@ -246,11 +294,17 @@ void MemoryReclaimer::abort(MemoryPool* pool, const std::exception_ptr& error) {
 
 void MemoryReclaimer::Stats::reset() {
   numNonReclaimableAttempts = 0;
+  reclaimExecTimeUs = 0;
+  reclaimedBytes = 0;
+  reclaimWaitTimeUs = 0;
 }
 
 bool MemoryReclaimer::Stats::operator==(
     const MemoryReclaimer::Stats& other) const {
-  return numNonReclaimableAttempts == other.numNonReclaimableAttempts;
+  return numNonReclaimableAttempts == other.numNonReclaimableAttempts &&
+      reclaimExecTimeUs == other.reclaimExecTimeUs &&
+      reclaimedBytes == other.reclaimedBytes &&
+      reclaimWaitTimeUs == other.reclaimWaitTimeUs;
 }
 
 bool MemoryReclaimer::Stats::operator!=(
@@ -258,6 +312,15 @@ bool MemoryReclaimer::Stats::operator!=(
   return !(*this == other);
 }
 
+MemoryReclaimer::Stats& MemoryReclaimer::Stats::operator+=(
+    const MemoryReclaimer::Stats& other) {
+  numNonReclaimableAttempts += other.numNonReclaimableAttempts;
+  reclaimExecTimeUs += other.reclaimExecTimeUs;
+  reclaimedBytes += other.reclaimedBytes;
+  reclaimWaitTimeUs += other.reclaimWaitTimeUs;
+  return *this;
+}
+
 MemoryArbitrator::Stats::Stats(
     uint64_t _numRequests,
     uint64_t _numSucceeded,
@@ -269,8 +332,10 @@ MemoryArbitrator::Stats::Stats(
     uint64_t _numReclaimedBytes,
     uint64_t _maxCapacityBytes,
     uint64_t _freeCapacityBytes,
+    uint64_t _freeReservedCapacityBytes,
     uint64_t _reclaimTimeUs,
-    uint64_t _numNonReclaimableAttempts)
+    uint64_t _numNonReclaimableAttempts,
+    uint64_t _numShrinks)
     : numRequests(_numRequests),
       numSucceeded(_numSucceeded),
       numAborted(_numAborted),
@@ -281,24 +346,30 @@ MemoryArbitrator::Stats::Stats(
       numReclaimedBytes(_numReclaimedBytes),
       maxCapacityBytes(_maxCapacityBytes),
       freeCapacityBytes(_freeCapacityBytes),
+      freeReservedCapacityBytes(_freeReservedCapacityBytes),
       reclaimTimeUs(_reclaimTimeUs),
-      numNonReclaimableAttempts(_numNonReclaimableAttempts) {}
+      numNonReclaimableAttempts(_numNonReclaimableAttempts),
+      numShrinks(_numShrinks) {}
 
 std::string MemoryArbitrator::Stats::toString() const {
   return fmt::format(
-      "STATS[numRequests {} numSucceeded {} numAborted {} numFailures {} numNonReclaimableAttempts {} queueTime {} arbitrationTime {} reclaimTime {} shrunkMemory {} reclaimedMemory {} maxCapacity {} freeCapacity {}]",
+      "STATS[numRequests {} numAborted {} numFailures {} "
+      "numNonReclaimableAttempts {} numShrinks {} "
+      "queueTime {} arbitrationTime {} reclaimTime {} shrunkMemory {} "
+      "reclaimedMemory {} maxCapacity {} freeCapacity {} freeReservedCapacity {}]",
       numRequests,
-      numSucceeded,
       numAborted,
       numFailures,
       numNonReclaimableAttempts,
+      numShrinks,
       succinctMicros(queueTimeUs),
       succinctMicros(arbitrationTimeUs),
       succinctMicros(reclaimTimeUs),
       succinctBytes(numShrunkBytes),
       succinctBytes(numReclaimedBytes),
       succinctBytes(maxCapacityBytes),
-      succinctBytes(freeCapacityBytes));
+      succinctBytes(freeCapacityBytes),
+      succinctBytes(freeReservedCapacityBytes));
 }
 
 MemoryArbitrator::Stats MemoryArbitrator::Stats::operator-(
@@ -314,9 +385,11 @@ MemoryArbitrator::Stats MemoryArbitrator::Stats::operator-(
   result.numReclaimedBytes = numReclaimedBytes - other.numReclaimedBytes;
   result.maxCapacityBytes = maxCapacityBytes;
   result.freeCapacityBytes = freeCapacityBytes;
+  result.freeReservedCapacityBytes = freeReservedCapacityBytes;
   result.reclaimTimeUs = reclaimTimeUs - other.reclaimTimeUs;
   result.numNonReclaimableAttempts =
       numNonReclaimableAttempts - other.numNonReclaimableAttempts;
+  result.numShrinks = numShrinks - other.numShrinks;
   return result;
 }
 
@@ -332,8 +405,10 @@ bool MemoryArbitrator::Stats::operator==(const Stats& other) const {
              numReclaimedBytes,
              maxCapacityBytes,
              freeCapacityBytes,
+             freeReservedCapacityBytes,
              reclaimTimeUs,
-             numNonReclaimableAttempts) ==
+             numNonReclaimableAttempts,
+             numShrinks) ==
       std::tie(
              other.numRequests,
              other.numSucceeded,
@@ -345,8 +420,10 @@ bool MemoryArbitrator::Stats::operator==(const Stats& other) const {
              other.numReclaimedBytes,
              other.maxCapacityBytes,
              other.freeCapacityBytes,
+             other.freeReservedCapacityBytes,
              other.reclaimTimeUs,
-             other.numNonReclaimableAttempts);
+             other.numNonReclaimableAttempts,
+             other.numShrinks);
 }
 
 bool MemoryArbitrator::Stats::operator!=(const Stats& other) const {
@@ -354,7 +431,6 @@ bool MemoryArbitrator::Stats::operator!=(const Stats& other) const {
 }
 
 bool MemoryArbitrator::Stats::operator<(const Stats& other) const {
-  uint32_t eqCount{0};
   uint32_t gtCount{0};
   uint32_t ltCount{0};
 #define UPDATE_COUNTER(counter)           \
@@ -363,8 +439,6 @@ bool MemoryArbitrator::Stats::operator<(const Stats& other) const {
       ++ltCount;                          \
     } else if (counter > other.counter) { \
       ++gtCount;                          \
-    } else {                              \
-      ++eqCount;                          \
     }                                     \
   } while (0);
 
@@ -378,6 +452,7 @@ bool MemoryArbitrator::Stats::operator<(const Stats& other) const {
   UPDATE_COUNTER(numReclaimedBytes);
   UPDATE_COUNTER(reclaimTimeUs);
   UPDATE_COUNTER(numNonReclaimableAttempts);
+  UPDATE_COUNTER(numShrinks);
 #undef UPDATE_COUNTER
   VELOX_CHECK(
       !((gtCount > 0) && (ltCount > 0)),
@@ -400,7 +475,7 @@ bool MemoryArbitrator::Stats::operator<=(const Stats& other) const {
 }
 
 ScopedMemoryArbitrationContext::ScopedMemoryArbitrationContext(
-    const MemoryPool& requestor)
+    const MemoryPool* requestor)
     : savedArbitrationCtx_(arbitrationCtx),
       currentArbitrationCtx_({.requestor = requestor}) {
   arbitrationCtx = &currentArbitrationCtx_;
@@ -410,11 +485,64 @@ ScopedMemoryArbitrationContext::~ScopedMemoryArbitrationContext() {
   arbitrationCtx = savedArbitrationCtx_;
 }
 
-MemoryArbitrationContext* memoryArbitrationContext() {
+const MemoryArbitrationContext* memoryArbitrationContext() {
   return arbitrationCtx;
 }
 
+ScopedMemoryPoolArbitrationCtx::ScopedMemoryPoolArbitrationCtx(MemoryPool* pool)
+    : pool_(pool) {
+  VELOX_CHECK_NOT_NULL(pool_);
+  pool_->enterArbitration();
+}
+
+ScopedMemoryPoolArbitrationCtx::~ScopedMemoryPoolArbitrationCtx() {
+  pool_->leaveArbitration();
+}
+
 bool underMemoryArbitration() {
   return memoryArbitrationContext() != nullptr;
 }
+
+void testingRunArbitration(
+    uint64_t targetBytes,
+    bool allowSpill,
+    MemoryManager* manager) {
+  if (manager == nullptr) {
+    manager = memory::memoryManager();
+  }
+  manager->shrinkPools(targetBytes, allowSpill);
+}
+
+void testingRunArbitration(
+    MemoryPool* pool,
+    uint64_t targetBytes,
+    bool allowSpill) {
+  {
+    ScopedMemoryPoolArbitrationCtx arbitrationCtx{pool};
+    static_cast<MemoryPoolImpl*>(pool)->testingManager()->shrinkPools(
+        targetBytes, allowSpill);
+  }
+  static_cast<MemoryPoolImpl*>(pool)->testingCheckIfAborted();
+}
+
+ScopedReclaimedBytesRecorder::ScopedReclaimedBytesRecorder(
+    MemoryPool* pool,
+    int64_t* reclaimedBytes)
+    : pool_(pool),
+      reclaimedBytes_(reclaimedBytes),
+      reservedBytesBeforeReclaim_(pool_->reservedBytes()) {
+  VELOX_CHECK_NOT_NULL(reclaimedBytes_);
+  VELOX_CHECK_EQ(*reclaimedBytes_, 0);
+}
+
+ScopedReclaimedBytesRecorder::~ScopedReclaimedBytesRecorder() {
+  if (std::uncaught_exceptions() > 0) {
+    // NOTE: if there is an alive exception triggered by memory reclaim, then we
+    // won't set reclaimed memory bytes.
+    *reclaimedBytes_ = 0;
+    return;
+  }
+  const int64_t reservedBytesAfterReclaim = pool_->reservedBytes();
+  *reclaimedBytes_ = reservedBytesBeforeReclaim_ - reservedBytesAfterReclaim;
+}
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/MemoryArbitrator.h b/velox/common/memory/MemoryArbitrator.h
index 09bc3a92d0eed..a76164dc3310a 100644
--- a/velox/common/memory/MemoryArbitrator.h
+++ b/velox/common/memory/MemoryArbitrator.h
@@ -18,9 +18,12 @@
 
 #include <vector>
 
+#include "velox/common/base/AsyncSource.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/Portability.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/future/VeloxPromise.h"
+#include "velox/common/time/Timer.h"
 
 namespace facebook::velox::memory {
 
@@ -55,46 +58,34 @@ class MemoryArbitrator {
     /// manager.
     int64_t capacity;
 
-    /// The initial memory capacity to reserve for a newly created memory pool.
-    uint64_t memoryPoolInitCapacity{256 << 20};
-
-    /// The minimal memory capacity to transfer out of or into a memory pool
-    /// during the memory arbitration.
-    uint64_t memoryPoolTransferCapacity{32 << 20};
-
-    /// Provided by the query system to validate the state after a memory pool
-    /// enters arbitration if not null. For instance, Prestissimo provides
-    /// callback to check if a memory arbitration request is issued from a
+    /// Callback to check if a memory arbitration request is issued from a
     /// driver thread, then the driver should be put in suspended state to avoid
     /// the potential deadlock when reclaim memory from the task of the request
     /// memory pool.
     MemoryArbitrationStateCheckCB arbitrationStateCheckCb{nullptr};
+
+    /// Additional configs that are arbitrator implementation specific.
+    std::unordered_map<std::string, std::string> extraConfigs{};
   };
 
   using Factory = std::function<std::unique_ptr<MemoryArbitrator>(
       const MemoryArbitrator::Config& config)>;
 
-  /// Register factory for a specific 'kind' of memory arbitrator
+  /// Registers factory for a specific 'kind' of memory arbitrator
   /// MemoryArbitrator::Create looks up the registry to find the factory to
   /// create arbitrator instance based on the kind specified in arbitrator
   /// config.
   ///
   /// NOTE: we only allow the same 'kind' of memory arbitrator to be registered
-  /// once. The function throws an error if 'kind' is already registered.
-  static void registerFactory(const std::string& kind, Factory factory);
+  /// once. The function returns false if 'kind' is already registered.
+  static bool registerFactory(const std::string& kind, Factory factory);
 
-  /// Unregister the registered factory for a specifc kind.
+  /// Unregisters the registered factory for a specifc kind.
   ///
   /// NOTE: the function throws if the specified arbitrator 'kind' is not
   /// registered.
   static void unregisterFactory(const std::string& kind);
 
-  /// Register all the supported memory arbitrator kinds.
-  static void registerAllFactories();
-
-  /// Unregister all the supported memory arbitrator kinds.
-  static void unregisterAllFactories();
-
   /// Invoked by the memory manager to create an instance of memory arbitrator
   /// based on the kind specified in 'config'. The arbitrator kind must be
   /// registered through MemoryArbitrator::registerFactory(), otherwise the
@@ -112,43 +103,51 @@ class MemoryArbitrator {
 
   virtual ~MemoryArbitrator() = default;
 
-  /// Invoked by the memory manager to reserve up to 'bytes' memory capacity
-  /// without actually freeing memory for a newly created memory pool. The
-  /// function will set the memory pool's capacity based on the actually
-  /// reserved memory.
-  ///
-  /// NOTE: the memory arbitrator can decides how much memory capacity is
-  /// actually reserved for a newly created memory pool. The latter can trigger
-  /// the memory arbitration on demand when actual memory allocation happens.
-  virtual void reserveMemory(MemoryPool* pool, uint64_t bytes) = 0;
+  /// Invoked by the memory manager to add a newly created memory pool. The
+  /// memory arbitrator allocates the initial capacity for 'pool' and
+  /// dynamically adjusts its capacity based query memory needs through memory
+  /// arbitration.
+  virtual void addPool(const std::shared_ptr<MemoryPool>& pool) = 0;
 
-  /// Invoked by the memory manager to return back all the reserved memory
-  /// capacity of a destroying memory pool.
-  virtual void releaseMemory(MemoryPool* pool) = 0;
+  /// Invoked by the memory manager to remove a destroyed memory pool. The
+  /// memory arbitrator frees up all its capacity and stops memory arbitration
+  /// operation on it.
+  virtual void removePool(MemoryPool* pool) = 0;
 
   /// Invoked by the memory manager to grow a memory pool's capacity.
-  /// 'pool' is the memory pool to request to grow. 'candidates' is a list
-  /// of query root pools to participate in the memory arbitration. The memory
-  /// arbitrator picks up a number of pools to either shrink its memory capacity
-  /// without actually freeing memory or reclaim its used memory to free up
-  /// enough memory for 'requestor' to grow. Different arbitrators use different
-  /// policies to select the candidate pools. The shared memory arbitrator used
-  /// by both Prestissimo and Prestissimo-on-Spark, selects the candidates with
-  /// more memory capacity.
+  /// 'pool' is the memory pool to request to grow. The memory arbitrator picks
+  /// up a number of pools to either shrink its memory capacity without actually
+  /// freeing memory or reclaim its used memory to free up enough memory for
+  /// 'requestor' to grow.
+  virtual bool growCapacity(MemoryPool* pool, uint64_t requestBytes) = 0;
+
+  /// Invoked by the memory manager to shrink up to 'targetBytes' free capacity
+  /// from a memory 'pool', and returns them back to the arbitrator. If
+  /// 'targetBytes' is zero, we shrink all the free capacity from the memory
+  /// pool. The function returns the actual freed capacity from 'pool'.
+  virtual uint64_t shrinkCapacity(MemoryPool* pool, uint64_t targetBytes) = 0;
+
+  /// Invoked by the memory manager to globally shrink memory from
+  /// memory pools by reclaiming only used memory, to reduce system memory
+  /// pressure. The freed memory capacity is given back to the arbitrator.  If
+  /// 'targetBytes' is zero, then try to reclaim all the memory from 'pools'.
+  /// The function returns the actual freed memory capacity in bytes. If
+  /// 'allowSpill' is true, it reclaims the used memory by spilling. If
+  /// 'allowAbort' is true, it reclaims the used memory by aborting the queries
+  /// with the most memory usage. If both are true, it first reclaims the used
+  /// memory by spilling and then abort queries to reach the reclaim target.
   ///
-  /// NOTE: the memory manager keeps 'candidates' valid during the arbitration
-  /// processing.
-  virtual bool growMemory(
-      MemoryPool* pool,
-      const std::vector<std::shared_ptr<MemoryPool>>& candidatePools,
-      uint64_t targetBytes) = 0;
-
-  /// Invoked by the memory manager to shrink memory from a given list of memory
-  /// pools. The freed memory capacity is given back to the arbitrator. The
-  /// function returns the actual freed memory capacity in bytes.
-  virtual uint64_t shrinkMemory(
-      const std::vector<std::shared_ptr<MemoryPool>>& pools,
-      uint64_t targetBytes) = 0;
+  /// NOTE: The actual reclaimed used memory (hence system memory) may be less
+  /// than 'targetBytes' due to the accounting of free capacity reclaimed. This
+  /// is okay because when this method is called, system is normally under
+  /// memory pressure, and there normally isn't much free capacity to reclaim.
+  /// So the reclaimed used memory in this case should be very close to
+  /// 'targetBytes' if enough used memory is reclaimable. We should improve this
+  /// in the future.
+  virtual uint64_t shrinkCapacity(
+      uint64_t targetBytes,
+      bool allowSpill = true,
+      bool allowAbort = false) = 0;
 
   /// The internal execution stats of the memory arbitrator.
   struct Stats {
@@ -173,12 +172,16 @@ class MemoryArbitrator {
     uint64_t maxCapacityBytes{0};
     /// The free memory capacity in bytes.
     uint64_t freeCapacityBytes{0};
+    /// The free reserved memory capacity in bytes.
+    uint64_t freeReservedCapacityBytes{0};
     /// The sum of all reclaim operation durations during arbitration in
     /// microseconds.
     uint64_t reclaimTimeUs{0};
     /// The total number of times of the reclaim attempts that end up failing
     /// due to reclaiming at non-reclaimable stage.
     uint64_t numNonReclaimableAttempts{0};
+    /// The total number of memory capacity shrinks.
+    uint64_t numShrinks{0};
 
     Stats(
         uint64_t _numRequests,
@@ -191,8 +194,10 @@ class MemoryArbitrator {
         uint64_t _numReclaimedBytes,
         uint64_t _maxCapacityBytes,
         uint64_t _freeCapacityBytes,
+        uint64_t _freeReservedCapacityBytes,
         uint64_t _reclaimTimeUs,
-        uint64_t _numNonReclaimableAttempts);
+        uint64_t _numNonReclaimableAttempts,
+        uint64_t _numShrinks);
 
     Stats() = default;
 
@@ -220,16 +225,24 @@ class MemoryArbitrator {
  protected:
   explicit MemoryArbitrator(const Config& config)
       : capacity_(config.capacity),
-        memoryPoolInitCapacity_(config.memoryPoolInitCapacity),
-        memoryPoolTransferCapacity_(config.memoryPoolTransferCapacity),
         arbitrationStateCheckCb_(config.arbitrationStateCheckCb) {}
 
+  /// Helper utilities used by the memory arbitrator implementations to call
+  /// protected methods of memory pool.
+  static bool
+  growPool(MemoryPool* pool, uint64_t growBytes, uint64_t reservationBytes);
+
+  static uint64_t shrinkPool(MemoryPool* pool, uint64_t targetBytes);
+
   const uint64_t capacity_;
-  const uint64_t memoryPoolInitCapacity_;
-  const uint64_t memoryPoolTransferCapacity_;
   const MemoryArbitrationStateCheckCB arbitrationStateCheckCb_;
 };
 
+/// Formatter for fmt.
+FOLLY_ALWAYS_INLINE std::string format_as(MemoryArbitrator::Stats stats) {
+  return stats.toString();
+}
+
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
     std::ostream& o,
     const MemoryArbitrator::Stats& stats) {
@@ -262,16 +275,29 @@ class MemoryReclaimer {
     /// due to reclaiming at non-reclaimable stage.
     uint64_t numNonReclaimableAttempts{0};
 
+    /// The total execution time to do the reclaim in microseconds.
+    uint64_t reclaimExecTimeUs{0};
+
+    /// The total reclaimed memory bytes.
+    uint64_t reclaimedBytes{0};
+
+    /// The total time of task pause during reclaim in microseconds.
+    uint64_t reclaimWaitTimeUs{0};
+
     void reset();
 
     bool operator==(const Stats& other) const;
     bool operator!=(const Stats& other) const;
+    Stats& operator+=(const Stats& other);
   };
 
   virtual ~MemoryReclaimer() = default;
 
   static std::unique_ptr<MemoryReclaimer> create();
 
+  /// Invoked memory reclaim function from 'pool' and record execution 'stats'.
+  static uint64_t run(const std::function<int64_t()>& func, Stats& stats);
+
   /// Invoked by the memory arbitrator before entering the memory arbitration
   /// processing. The default implementation does nothing but user can override
   /// this if needs. For example, an operator memory reclaimer needed to put the
@@ -300,10 +326,18 @@ class MemoryReclaimer {
   /// Invoked by the memory arbitrator to reclaim from memory 'pool' with
   /// specified 'targetBytes'. It is expected to reclaim at least that amount of
   /// memory bytes but there is no guarantees. If 'targetBytes' is zero, then it
-  /// reclaims all the reclaimable memory from the memory 'pool'. The function
-  /// returns the actual reclaimed memory bytes.
-  virtual uint64_t
-  reclaim(MemoryPool* pool, uint64_t targetBytes, Stats& stats);
+  /// reclaims all the reclaimable memory from the memory 'pool'. 'maxWaitMs'
+  /// specifies the max time to wait for reclaim if not zero. The memory
+  /// reclaim might fail if exceeds the timeout. The function returns the actual
+  /// reclaimed memory bytes.
+  ///
+  /// NOTE: 'maxWaitMs' is optional and the actual memory reclaim implementation
+  /// can choose to respect this timeout or not on its own.
+  virtual uint64_t reclaim(
+      MemoryPool* pool,
+      uint64_t targetBytes,
+      uint64_t maxWaitMs,
+      Stats& stats);
 
   /// Invoked by the memory arbitrator to abort memory 'pool' and the associated
   /// query execution when encounters non-recoverable memory reclaim error or
@@ -318,20 +352,74 @@ class MemoryReclaimer {
   MemoryReclaimer() = default;
 };
 
+/// Helper class used to measure the memory bytes reclaimed from a memory pool
+/// by a memory reclaim function.
+class ScopedReclaimedBytesRecorder {
+ public:
+  ScopedReclaimedBytesRecorder(MemoryPool* pool, int64_t* reclaimedBytes);
+
+  ~ScopedReclaimedBytesRecorder();
+
+ private:
+  MemoryPool* const pool_;
+  int64_t* const reclaimedBytes_;
+  const int64_t reservedBytesBeforeReclaim_;
+};
+
+/// The object is used to set/clear non-reclaimable section of an operation in
+/// the middle of its execution. It allows the memory arbitrator to reclaim
+/// memory from a running operator which is waiting for memory arbitration.
+/// 'nonReclaimableSection' points to the corresponding flag of the associated
+/// operator.
+class ReclaimableSectionGuard {
+ public:
+  explicit ReclaimableSectionGuard(tsan_atomic<bool>* nonReclaimableSection)
+      : nonReclaimableSection_(nonReclaimableSection),
+        oldNonReclaimableSectionValue_(*nonReclaimableSection_) {
+    *nonReclaimableSection_ = false;
+  }
+
+  ~ReclaimableSectionGuard() {
+    *nonReclaimableSection_ = oldNonReclaimableSectionValue_;
+  }
+
+ private:
+  tsan_atomic<bool>* const nonReclaimableSection_;
+  const bool oldNonReclaimableSectionValue_;
+};
+
+class NonReclaimableSectionGuard {
+ public:
+  explicit NonReclaimableSectionGuard(tsan_atomic<bool>* nonReclaimableSection)
+      : nonReclaimableSection_(nonReclaimableSection),
+        oldNonReclaimableSectionValue_(*nonReclaimableSection_) {
+    *nonReclaimableSection_ = true;
+  }
+
+  ~NonReclaimableSectionGuard() {
+    *nonReclaimableSection_ = oldNonReclaimableSectionValue_;
+  }
+
+ private:
+  tsan_atomic<bool>* const nonReclaimableSection_;
+  const bool oldNonReclaimableSectionValue_;
+};
+
 /// The memory arbitration context which is set on per-thread local variable by
 /// memory arbitrator. It is used to indicate a running thread is under memory
 /// arbitration processing or not. This helps to enable sanity check such as all
 /// the memory reservations during memory arbitration should come from the
 /// spilling memory pool.
 struct MemoryArbitrationContext {
-  const MemoryPool& requestor;
+  const MemoryPool* requestor;
 };
 
 /// Object used to set/restore the memory arbitration context when a thread is
 /// under memory arbitration processing.
 class ScopedMemoryArbitrationContext {
  public:
-  explicit ScopedMemoryArbitrationContext(const MemoryPool& requestor);
+  explicit ScopedMemoryArbitrationContext(const MemoryPool* requestor);
+
   ~ScopedMemoryArbitrationContext();
 
  private:
@@ -339,10 +427,73 @@ class ScopedMemoryArbitrationContext {
   MemoryArbitrationContext currentArbitrationCtx_;
 };
 
+/// Object used to setup arbitration context for a memory pool.
+class ScopedMemoryPoolArbitrationCtx {
+ public:
+  explicit ScopedMemoryPoolArbitrationCtx(MemoryPool* pool);
+
+  ~ScopedMemoryPoolArbitrationCtx();
+
+ private:
+  MemoryPool* const pool_;
+};
+
 /// Returns the memory arbitration context set by a per-thread local variable if
 /// the running thread is under memory arbitration processing.
-MemoryArbitrationContext* memoryArbitrationContext();
+const MemoryArbitrationContext* memoryArbitrationContext();
 
 /// Returns true if the running thread is under memory arbitration or not.
 bool underMemoryArbitration();
+
+/// Creates an async memory reclaim task with memory arbitration context set.
+/// This is to avoid recursive memory arbitration during memory reclaim.
+///
+/// NOTE: this must be called under memory arbitration.
+template <typename Item>
+std::shared_ptr<AsyncSource<Item>> createAsyncMemoryReclaimTask(
+    std::function<std::unique_ptr<Item>()> task) {
+  auto* arbitrationCtx = memory::memoryArbitrationContext();
+  return std::make_shared<AsyncSource<Item>>(
+      [asyncTask = std::move(task), arbitrationCtx]() -> std::unique_ptr<Item> {
+        std::unique_ptr<ScopedMemoryArbitrationContext> restoreArbitrationCtx;
+        if (arbitrationCtx != nullptr) {
+          restoreArbitrationCtx =
+              std::make_unique<ScopedMemoryArbitrationContext>(
+                  arbitrationCtx->requestor);
+        }
+        return asyncTask();
+      });
+}
+
+/// The function triggers memory arbitration by shrinking memory pools from
+/// 'manager' by invoking shrinkPools API. If 'manager' is not set, then it
+/// shrinks from the process wide memory manager. If 'targetBytes' is zero, then
+/// it reclaims all the memory from 'manager' if possible. If 'allowSpill' is
+/// true, then it allows to reclaim the used memory by spilling.
+class MemoryManager;
+void testingRunArbitration(
+    uint64_t targetBytes = 0,
+    bool allowSpill = true,
+    MemoryManager* manager = nullptr);
+
+/// The function triggers memory arbitration by shrinking memory pools from
+/// 'manager' of 'pool' by invoking its shrinkPools API. If 'targetBytes' is
+/// zero, then it reclaims all the memory from 'manager' if possible. If
+/// 'allowSpill' is true, then it allows to reclaim the used memory by spilling.
+void testingRunArbitration(
+    MemoryPool* pool,
+    uint64_t targetBytes = 0,
+    bool allowSpill = true);
 } // namespace facebook::velox::memory
+
+#if FMT_VERSION < 100100
+template <>
+struct fmt::formatter<facebook::velox::memory::MemoryArbitrator::Stats>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::memory::MemoryArbitrator::Stats s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(s.toString(), ctx);
+  }
+};
+#endif
diff --git a/velox/common/memory/MemoryPool.cpp b/velox/common/memory/MemoryPool.cpp
index ab2c3b026f471..2e647dc59a7a3 100644
--- a/velox/common/memory/MemoryPool.cpp
+++ b/velox/common/memory/MemoryPool.cpp
@@ -16,14 +16,22 @@
 
 #include "velox/common/memory/MemoryPool.h"
 
+#include <signal.h>
 #include <set>
 
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/common/testutil/TestValue.h"
 
 #include <re2/re2.h>
 
+DEFINE_bool(
+    velox_memory_pool_capacity_transfer_across_tasks,
+    false,
+    "Whether allow to memory capacity transfer between memory pools from different tasks, which might happen in use case like Spark-Gluten");
+
 DECLARE_bool(velox_suppress_memory_capacity_exceeding_error_message);
 
 using facebook::velox::common::testutil::TestValue;
@@ -60,18 +68,24 @@ namespace {
 struct MemoryUsage {
   std::string name;
   uint64_t currentUsage;
+  uint64_t reservedUsage;
   uint64_t peakUsage;
 
   bool operator>(const MemoryUsage& other) const {
-    return std::tie(currentUsage, peakUsage, name) >
-        std::tie(other.currentUsage, other.peakUsage, other.name);
+    return std::tie(reservedUsage, currentUsage, peakUsage, name) >
+        std::tie(
+               other.reservedUsage,
+               other.currentUsage,
+               other.peakUsage,
+               other.name);
   }
 
   std::string toString() const {
     return fmt::format(
-        "{} usage {} peak {}",
+        "{} usage {} reserved {} peak {}",
         name,
         succinctBytes(currentUsage),
+        succinctBytes(reservedUsage),
         succinctBytes(peakUsage));
   }
 };
@@ -103,20 +117,25 @@ void treeMemoryUsageVisitor(
     MemoryPool* pool,
     size_t indent,
     MemoryUsageHeap& topLeafMemUsages,
+    bool skipEmptyPool,
     std::stringstream& out) {
   const MemoryPool::Stats stats = pool->stats();
-  // Avoid logging empty pools.
-  if (stats.empty()) {
+  // Avoid logging empty pools if 'skipEmptyPool' is true.
+  if (stats.empty() && skipEmptyPool) {
     return;
   }
   const MemoryUsage usage{
       .name = pool->name(),
-      .currentUsage = stats.currentBytes,
+      .currentUsage = stats.usedBytes,
+      .reservedUsage = stats.reservedBytes,
       .peakUsage = stats.peakBytes,
   };
   out << std::string(indent, ' ') << usage.toString() << "\n";
 
   if (pool->kind() == MemoryPool::Kind::kLeaf) {
+    if (stats.empty()) {
+      return;
+    }
     static const size_t kTopNLeafMessages = 10;
     topLeafMemUsages.push(usage);
     if (topLeafMemUsages.size() > kTopNLeafMessages) {
@@ -124,11 +143,11 @@ void treeMemoryUsageVisitor(
     }
     return;
   }
-  pool->visitChildren(
-      [&, indent = indent + kCapMessageIndentSize](MemoryPool* pool) {
-        treeMemoryUsageVisitor(pool, indent, topLeafMemUsages, out);
-        return true;
-      });
+  pool->visitChildren([&, indent = indent + kCapMessageIndentSize](
+                          MemoryPool* pool) {
+    treeMemoryUsageVisitor(pool, indent, topLeafMemUsages, skipEmptyPool, out);
+    return true;
+  });
 }
 
 std::string capacityToString(int64_t capacity) {
@@ -151,8 +170,9 @@ std::string capacityToString(int64_t capacity) {
 
 std::string MemoryPool::Stats::toString() const {
   return fmt::format(
-      "currentBytes:{} peakBytes:{} cumulativeBytes:{} numAllocs:{} numFrees:{} numReserves:{} numReleases:{} numShrinks:{} numReclaims:{} numCollisions:{}",
-      succinctBytes(currentBytes),
+      "usedBytes:{} reservedBytes:{} peakBytes:{} cumulativeBytes:{} numAllocs:{} numFrees:{} numReserves:{} numReleases:{} numShrinks:{} numReclaims:{} numCollisions:{} numCapacityGrowths:{}",
+      succinctBytes(usedBytes),
+      succinctBytes(reservedBytes),
       succinctBytes(peakBytes),
       succinctBytes(cumulativeBytes),
       numAllocs,
@@ -161,28 +181,33 @@ std::string MemoryPool::Stats::toString() const {
       numReleases,
       numShrinks,
       numReclaims,
-      numCollisions);
+      numCollisions,
+      numCapacityGrowths);
 }
 
 bool MemoryPool::Stats::operator==(const MemoryPool::Stats& other) const {
   return std::tie(
-             currentBytes,
+             usedBytes,
+             reservedBytes,
              peakBytes,
              cumulativeBytes,
              numAllocs,
              numFrees,
              numReserves,
              numReleases,
-             numCollisions) ==
+             numCollisions,
+             numCapacityGrowths) ==
       std::tie(
-             other.currentBytes,
+             other.usedBytes,
+             other.reservedBytes,
              other.peakBytes,
              other.cumulativeBytes,
              other.numAllocs,
              other.numFrees,
              other.numReserves,
              other.numReleases,
-             other.numCollisions);
+             other.numCollisions,
+             other.numCapacityGrowths);
 }
 
 std::ostream& operator<<(std::ostream& os, const MemoryPool::Stats& stats) {
@@ -201,8 +226,8 @@ MemoryPool::MemoryPool(
       maxCapacity_(parent_ == nullptr ? options.maxCapacity : kMaxMemory),
       trackUsage_(options.trackUsage),
       threadSafe_(options.threadSafe),
-      checkUsageLeak_(options.checkUsageLeak),
-      debugEnabled_(options.debugEnabled) {
+      debugEnabled_(options.debugEnabled),
+      coreOnAllocationFailureEnabled_(options.coreOnAllocationFailureEnabled) {
   VELOX_CHECK(!isRoot() || !isLeaf());
   VELOX_CHECK_GT(
       maxCapacity_, 0, "Memory pool {} max capacity can't be zero", name_);
@@ -213,6 +238,7 @@ MemoryPool::~MemoryPool() {
   VELOX_CHECK(children_.empty());
 }
 
+// static
 std::string MemoryPool::kindString(Kind kind) {
   switch (kind) {
     case Kind::kLeaf:
@@ -249,7 +275,7 @@ MemoryPool* MemoryPool::root() const {
 }
 
 uint64_t MemoryPool::getChildCount() const {
-  folly::SharedMutex::ReadHolder guard{poolMutex_};
+  std::shared_lock guard{poolMutex_};
   return children_.size();
 }
 
@@ -257,7 +283,7 @@ void MemoryPool::visitChildren(
     const std::function<bool(MemoryPool*)>& visitor) const {
   std::vector<std::shared_ptr<MemoryPool>> children;
   {
-    folly::SharedMutex::ReadHolder guard{poolMutex_};
+    std::shared_lock guard{poolMutex_};
     children.reserve(children_.size());
     for (auto& entry : children_) {
       auto child = entry.second.lock();
@@ -267,16 +293,15 @@ void MemoryPool::visitChildren(
     }
   }
 
-  // NOTE: we should call 'visitor' on child pool object out of
-  // 'poolMutex_' to avoid potential recursive locking issues. Firstly, the
-  // user provided 'visitor' might try to acquire this memory pool lock again.
-  // Secondly, the shared child pool reference created from the weak pointer
-  // might be the last reference if some other threads drop all the external
-  // references during this time window. Then drop of this last shared reference
-  // after 'visitor' call will trigger child memory pool destruction in that
-  // case. The child memory pool destructor will remove its weak pointer
-  // reference from the parent pool which needs to acquire this memory pool lock
-  // again.
+  // NOTE: we should call 'visitor' on child pool object out of 'poolMutex_' to
+  // avoid potential recursive locking issues. Firstly, the user provided
+  // 'visitor' might try to acquire this memory pool lock again. Secondly, the
+  // shared child pool reference created from the weak pointer might be the last
+  // reference if some other threads drop all the external references during
+  // this time window. Then drop of this last shared reference after 'visitor'
+  // call will trigger child memory pool destruction in that case. The child
+  // memory pool destructor will remove its weak pointer reference from the
+  // parent pool which needs to acquire this memory pool lock again.
   for (auto& child : children) {
     if (!visitor(child.get())) {
       return;
@@ -287,51 +312,65 @@ void MemoryPool::visitChildren(
 std::shared_ptr<MemoryPool> MemoryPool::addLeafChild(
     const std::string& name,
     bool threadSafe,
-    std::unique_ptr<MemoryReclaimer> reclaimer) {
+    std::unique_ptr<MemoryReclaimer> _reclaimer) {
   CHECK_POOL_MANAGEMENT_OP(addLeafChild);
+  // NOTE: we shall only set reclaimer in a child pool if its parent has also
+  // set. Otherwise it should be mis-configured.
+  VELOX_CHECK(
+      reclaimer() != nullptr || _reclaimer == nullptr,
+      "Child memory pool {} shall only set memory reclaimer if its parent {} has also set",
+      name,
+      name_);
 
-  folly::SharedMutex::WriteHolder guard{poolMutex_};
+  std::unique_lock guard{poolMutex_};
   VELOX_CHECK_EQ(
       children_.count(name),
       0,
       "Leaf child memory pool {} already exists in {}",
       name,
-      toString());
+      name_);
   auto child = genChild(
       shared_from_this(),
       name,
       MemoryPool::Kind::kLeaf,
       threadSafe,
-      std::move(reclaimer));
+      std::move(_reclaimer));
   children_.emplace(name, child);
   return child;
 }
 
 std::shared_ptr<MemoryPool> MemoryPool::addAggregateChild(
     const std::string& name,
-    std::unique_ptr<MemoryReclaimer> reclaimer) {
+    std::unique_ptr<MemoryReclaimer> _reclaimer) {
   CHECK_POOL_MANAGEMENT_OP(addAggregateChild);
+  // NOTE: we shall only set reclaimer in a child pool if its parent has also
+  // set. Otherwise it should be mis-configured.
+  VELOX_CHECK(
+      reclaimer() != nullptr || _reclaimer == nullptr,
+      "Child memory pool {} shall only set memory reclaimer if its parent {} has also set",
+      name,
+      name_);
 
-  folly::SharedMutex::WriteHolder guard{poolMutex_};
+  std::unique_lock guard{poolMutex_};
   VELOX_CHECK_EQ(
       children_.count(name),
       0,
       "Child memory pool {} already exists in {}",
       name,
-      toString());
+      name_);
   auto child = genChild(
       shared_from_this(),
       name,
       MemoryPool::Kind::kAggregate,
       true,
-      std::move(reclaimer));
+      std::move(_reclaimer));
   children_.emplace(name, child);
   return child;
 }
 
 void MemoryPool::dropChild(const MemoryPool* child) {
   CHECK_POOL_MANAGEMENT_OP(dropChild);
-  folly::SharedMutex::WriteHolder guard{poolMutex_};
+  std::unique_lock guard{poolMutex_};
   const auto ret = children_.erase(child->name());
   VELOX_CHECK_EQ(
       ret,
@@ -341,6 +380,20 @@ void MemoryPool::dropChild(const MemoryPool* child) {
       toString());
 }
 
+bool MemoryPool::aborted() const {
+  if (parent_ != nullptr) {
+    return parent_->aborted();
+  }
+  return aborted_;
+}
+
+std::exception_ptr MemoryPool::abortError() const {
+  if (parent_ != nullptr) {
+    return parent_->abortError();
+  }
+  return abortError_;
+}
+
 size_t MemoryPool::preferredSize(size_t size) {
   if (size < 8) {
     return 8;
@@ -365,26 +418,17 @@ MemoryPoolImpl::MemoryPoolImpl(
     Kind kind,
     std::shared_ptr<MemoryPool> parent,
     std::unique_ptr<MemoryReclaimer> reclaimer,
-    DestructionCallback destructionCb,
     const Options& options)
     : MemoryPool{name, kind, parent, options},
       manager_{memoryManager},
-      allocator_{&manager_->allocator()},
-      destructionCb_(std::move(destructionCb)),
+      allocator_{manager_->allocator()},
+      arbitrator_{manager_->arbitrator()},
       debugPoolNameRegex_(debugEnabled_ ? *(debugPoolNameRegex().rlock()) : ""),
       reclaimer_(std::move(reclaimer)),
       // The memory manager sets the capacity through grow() according to the
       // actually used memory arbitration policy.
       capacity_(parent_ != nullptr ? kMaxMemory : 0) {
   VELOX_CHECK(options.threadSafe || isLeaf());
-  // NOTE: we shall only set reclaimer in a child pool if its parent has also
-  // set. Otherwise. it should be mis-configured.
-  VELOX_CHECK(
-      parent_ == nullptr || parent_->reclaimer() != nullptr ||
-          reclaimer_ == nullptr,
-      "Child memory pool {} shall only set memory reclaimer if its parent {} has also set",
-      name_,
-      parent_->name());
 }
 
 MemoryPoolImpl::~MemoryPoolImpl() {
@@ -392,13 +436,31 @@ MemoryPoolImpl::~MemoryPoolImpl() {
   if (parent_ != nullptr) {
     toImpl(parent_)->dropChild(this);
   }
-  if (checkUsageLeak_) {
-    VELOX_CHECK(
-        (usedReservationBytes_ == 0) && (reservationBytes_ == 0) &&
-            (minReservationBytes_ == 0),
-        "Bad memory usage track state: {}",
-        toString());
+
+  if (isLeaf()) {
+    if (usedReservationBytes_ > 0) {
+      VELOX_MEM_LOG(ERROR) << "Memory leak (Used memory): " << toString();
+      RECORD_METRIC_VALUE(
+          kMetricMemoryPoolUsageLeakBytes, usedReservationBytes_);
+    }
+
+    if (minReservationBytes_ > 0) {
+      VELOX_MEM_LOG(ERROR) << "Memory leak (Reserved Memory): " << toString();
+      RECORD_METRIC_VALUE(
+          kMetricMemoryPoolReservationLeakBytes, minReservationBytes_);
+    }
+  }
+  VELOX_DCHECK(
+      (usedReservationBytes_ == 0) && (reservationBytes_ == 0) &&
+          (minReservationBytes_ == 0),
+      "Bad memory usage track state: {}",
+      toString());
+
+  if (isRoot()) {
+    RECORD_HISTOGRAM_METRIC_VALUE(
+        kMetricMemoryPoolCapacityGrowCount, numCapacityGrowths_);
   }
+
   if (destructionCb_ != nullptr) {
     destructionCb_(this);
   }
@@ -411,7 +473,8 @@ MemoryPool::Stats MemoryPoolImpl::stats() const {
 
 MemoryPool::Stats MemoryPoolImpl::statsLocked() const {
   Stats stats;
-  stats.currentBytes = currentBytesLocked();
+  stats.usedBytes = usedBytes();
+  stats.reservedBytes = reservationBytes_;
   stats.peakBytes = peakBytes_;
   stats.cumulativeBytes = cumulativeBytes_;
   stats.numAllocs = numAllocs_;
@@ -419,6 +482,7 @@ MemoryPool::Stats MemoryPoolImpl::statsLocked() const {
   stats.numReserves = numReserves_;
   stats.numReleases = numReleases_;
   stats.numCollisions = numCollisions_;
+  stats.numCapacityGrowths = numCapacityGrowths_;
   return stats;
 }
 
@@ -429,11 +493,12 @@ void* MemoryPoolImpl::allocate(int64_t size) {
   void* buffer = allocator_->allocateBytes(alignedSize, alignment_);
   if (FOLLY_UNLIKELY(buffer == nullptr)) {
     release(alignedSize);
-    VELOX_MEM_ALLOC_ERROR(fmt::format(
-        "{} failed with {} from {}",
+    handleAllocationFailure(fmt::format(
+        "{} failed with {} from {} {}",
         __FUNCTION__,
         succinctBytes(size),
-        toString()));
+        toString(),
+        allocator_->getAndClearFailureMessage()));
   }
   DEBUG_RECORD_ALLOC(buffer, size);
   return buffer;
@@ -447,12 +512,13 @@ void* MemoryPoolImpl::allocateZeroFilled(int64_t numEntries, int64_t sizeEach) {
   void* buffer = allocator_->allocateZeroFilled(alignedSize);
   if (FOLLY_UNLIKELY(buffer == nullptr)) {
     release(alignedSize);
-    VELOX_MEM_ALLOC_ERROR(fmt::format(
-        "{} failed with {} entries and {} each from {}",
+    handleAllocationFailure(fmt::format(
+        "{} failed with {} entries and {} each from {} {}",
         __FUNCTION__,
         numEntries,
         succinctBytes(sizeEach),
-        toString()));
+        toString(),
+        allocator_->getAndClearFailureMessage()));
   }
   DEBUG_RECORD_ALLOC(buffer, size);
   return buffer;
@@ -466,12 +532,13 @@ void* MemoryPoolImpl::reallocate(void* p, int64_t size, int64_t newSize) {
   void* newP = allocator_->allocateBytes(alignedNewSize, alignment_);
   if (FOLLY_UNLIKELY(newP == nullptr)) {
     release(alignedNewSize);
-    VELOX_MEM_ALLOC_ERROR(fmt::format(
-        "{} failed with new {} and old {} from {}",
+    handleAllocationFailure(fmt::format(
+        "{} failed with new {} and old {} from {} {}",
         __FUNCTION__,
         succinctBytes(newSize),
         succinctBytes(size),
-        toString()));
+        toString(),
+        allocator_->getAndClearFailureMessage()));
   }
   DEBUG_RECORD_ALLOC(newP, newSize);
   if (p != nullptr) {
@@ -505,7 +572,7 @@ void MemoryPoolImpl::allocateNonContiguous(
   if (!allocator_->allocateNonContiguous(
           numPages,
           out,
-          [this](int64_t allocBytes, bool preAllocate) {
+          [this](uint64_t allocBytes, bool preAllocate) {
             if (preAllocate) {
               reserve(allocBytes);
             } else {
@@ -514,8 +581,12 @@ void MemoryPoolImpl::allocateNonContiguous(
           },
           minSizeClass)) {
     VELOX_CHECK(out.empty());
-    VELOX_MEM_ALLOC_ERROR(fmt::format(
-        "{} failed with {} pages from {}", __FUNCTION__, numPages, toString()));
+    handleAllocationFailure(fmt::format(
+        "{} failed with {} pages from {} {}",
+        __FUNCTION__,
+        numPages,
+        toString(),
+        allocator_->getAndClearFailureMessage()));
   }
   DEBUG_RECORD_ALLOC(out);
   VELOX_CHECK(!out.empty());
@@ -553,7 +624,7 @@ void MemoryPoolImpl::allocateContiguous(
           numPages,
           nullptr,
           out,
-          [this](int64_t allocBytes, bool preAlloc) {
+          [this](uint64_t allocBytes, bool preAlloc) {
             if (preAlloc) {
               reserve(allocBytes);
             } else {
@@ -562,8 +633,12 @@ void MemoryPoolImpl::allocateContiguous(
           },
           maxPages)) {
     VELOX_CHECK(out.empty());
-    VELOX_MEM_ALLOC_ERROR(fmt::format(
-        "{} failed with {} pages from {}", __FUNCTION__, numPages, toString()));
+    handleAllocationFailure(fmt::format(
+        "{} failed with {} pages from {} {}",
+        __FUNCTION__,
+        numPages,
+        toString(),
+        allocator_->getAndClearFailureMessage()));
   }
   DEBUG_RECORD_ALLOC(out);
   VELOX_CHECK(!out.empty());
@@ -584,18 +659,19 @@ void MemoryPoolImpl::growContiguous(
     MachinePageCount increment,
     ContiguousAllocation& allocation) {
   if (!allocator_->growContiguous(
-          increment, allocation, [this](int64_t allocBytes, bool preAlloc) {
+          increment, allocation, [this](uint64_t allocBytes, bool preAlloc) {
             if (preAlloc) {
               reserve(allocBytes);
             } else {
               release(allocBytes);
             }
           })) {
-    VELOX_MEM_ALLOC_ERROR(fmt::format(
-        "{} failed with {} pages from {}",
+    handleAllocationFailure(fmt::format(
+        "{} failed with {} pages from {} {}",
         __FUNCTION__,
         increment,
-        toString()));
+        toString(),
+        allocator_->getAndClearFailureMessage()));
   }
   if (FOLLY_UNLIKELY(debugEnabled_)) {
     recordGrowDbg(allocation.data(), allocation.size());
@@ -610,6 +686,38 @@ int64_t MemoryPoolImpl::capacity() const {
   return capacity_;
 }
 
+int64_t MemoryPoolImpl::usedBytes() const {
+  if (isLeaf()) {
+    return usedReservationBytes_;
+  }
+  if (reservedBytes() == 0) {
+    return 0;
+  }
+  int64_t usedBytes{0};
+  visitChildren([&](MemoryPool* pool) {
+    usedBytes += pool->usedBytes();
+    return true;
+  });
+  return usedBytes;
+}
+
+int64_t MemoryPoolImpl::releasableReservation() const {
+  if (isLeaf()) {
+    std::lock_guard<std::mutex> l(mutex_);
+    return std::max<int64_t>(
+        0, reservationBytes_ - quantizedSize(usedReservationBytes_));
+  }
+  if (reservedBytes() == 0) {
+    return 0;
+  }
+  int64_t releasableBytes{0};
+  visitChildren([&](MemoryPool* pool) {
+    releasableBytes += pool->releasableReservation();
+    return true;
+  });
+  return releasableBytes;
+}
+
 std::shared_ptr<MemoryPool> MemoryPoolImpl::genChild(
     std::shared_ptr<MemoryPool> parent,
     const std::string& name,
@@ -622,13 +730,12 @@ std::shared_ptr<MemoryPool> MemoryPoolImpl::genChild(
       kind,
       parent,
       std::move(reclaimer),
-      nullptr,
       Options{
           .alignment = alignment_,
           .trackUsage = trackUsage_,
           .threadSafe = threadSafe,
-          .checkUsageLeak = checkUsageLeak_,
-          .debugEnabled = debugEnabled_});
+          .debugEnabled = debugEnabled_,
+          .coreOnAllocationFailureEnabled = coreOnAllocationFailureEnabled_});
 }
 
 bool MemoryPoolImpl::maybeReserve(uint64_t increment) {
@@ -640,7 +747,7 @@ bool MemoryPoolImpl::maybeReserve(uint64_t increment) {
   const auto reservationToAdd = bits::roundUp(increment, kGrowthQuantum);
   try {
     reserve(reservationToAdd, true);
-  } catch (const std::exception& e) {
+  } catch (const std::exception&) {
     if (aborted()) {
       // NOTE: we shall throw to stop the query execution if the root memory
       // pool has been aborted. It is also unsafe to proceed as the memory abort
@@ -654,13 +761,6 @@ bool MemoryPoolImpl::maybeReserve(uint64_t increment) {
 }
 
 void MemoryPoolImpl::reserve(uint64_t size, bool reserveOnly) {
-  if (FOLLY_UNLIKELY(underMemoryArbitration() && !isSpillMemoryPool(this))) {
-    VELOX_FAIL(
-        "Unexpected non-spilling memory reservation from memory pool: {}, arbitration request pool: {}",
-        name(),
-        memoryArbitrationContext()->requestor.name());
-  }
-
   if (FOLLY_LIKELY(trackUsage_)) {
     if (FOLLY_LIKELY(threadSafe_)) {
       reserveThreadSafe(size, reserveOnly);
@@ -698,7 +798,7 @@ void MemoryPoolImpl::reserveThreadSafe(uint64_t size, bool reserveOnly) {
         "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe", this);
     try {
       incrementReservationThreadSafe(this, increment);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       // When race with concurrent memory reservation free, we might end up with
       // unused reservation but no used reservation if a retry memory
       // reservation attempt run into memory capacity exceeded error.
@@ -732,63 +832,81 @@ bool MemoryPoolImpl::incrementReservationThreadSafe(
     }
   }
 
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    if (maybeIncrementReservationLocked(size)) {
-      return true;
-    }
+  if (maybeIncrementReservation(size)) {
+    return true;
   }
+
   VELOX_CHECK_NULL(parent_);
 
-  if (manager_->growPool(requestor, size)) {
+  if (growCapacity(requestor, size)) {
     TestValue::adjust(
         "facebook::velox::memory::MemoryPoolImpl::incrementReservationThreadSafe::AfterGrowCallback",
         this);
-    // NOTE: the memory reservation might still fail even if the memory grow
-    // callback succeeds. The reason is that we don't hold the root tracker's
-    // mutex lock while running the grow callback. Therefore, there is a
-    // possibility in theory that a concurrent memory reservation request
-    // might steal away the increased memory capacity after the grow callback
-    // finishes and before we increase the reservation. If it happens, we can
-    // simply fall back to retry the memory reservation from the leaf memory
-    // pool which should happen rarely.
-    return maybeIncrementReservation(size);
+    // NOTE: if memory arbitration succeeds, it should have already committed
+    // the reservation 'size' in the root memory pool.
+    return true;
   }
   VELOX_MEM_POOL_CAP_EXCEEDED(fmt::format(
-      "Exceeded memory pool cap of {} with max {} when requesting {}, memory "
-      "manager cap is {}, requestor '{}' with current usage {}\n{}",
+      "Exceeded memory pool capacity after attempt to grow capacity "
+      "through arbitration. Requestor pool name '{}', request size {}, memory "
+      "pool capacity {}, memory pool max capacity {}, memory manager capacity "
+      "{}, current usage {}\n{}",
+      requestor->name(),
+      succinctBytes(size),
       capacityToString(capacity()),
       capacityToString(maxCapacity_),
-      succinctBytes(size),
       capacityToString(manager_->capacity()),
-      requestor->name(),
-      succinctBytes(requestor->currentBytes()),
+      succinctBytes(requestor->usedBytes()),
       treeMemoryUsage()));
 }
 
-bool MemoryPoolImpl::maybeIncrementReservation(uint64_t size) {
-  std::lock_guard<std::mutex> l(mutex_);
-  return maybeIncrementReservationLocked(size);
+bool MemoryPoolImpl::growCapacity(MemoryPool* requestor, uint64_t size) {
+  VELOX_CHECK(requestor->isLeaf());
+  ++numCapacityGrowths_;
+
+  bool success{false};
+  {
+    ScopedMemoryPoolArbitrationCtx arbitrationCtx(requestor);
+    success = arbitrator_->growCapacity(this, size);
+  }
+  // The memory pool might have been aborted during the time it leaves the
+  // arbitration no matter the arbitration succeed or not.
+  if (FOLLY_UNLIKELY(aborted())) {
+    if (success) {
+      // Release the reservation committed by the memory arbitration on success.
+      decrementReservation(size);
+    }
+    VELOX_CHECK_NOT_NULL(abortError());
+    std::rethrow_exception(abortError());
+  }
+  return success;
 }
 
-bool MemoryPoolImpl::maybeIncrementReservationLocked(uint64_t size) {
+bool MemoryPoolImpl::maybeIncrementReservation(uint64_t size) {
+  std::lock_guard<std::mutex> l(mutex_);
   if (isRoot()) {
-    if (aborted()) {
-      // This memory pool has been aborted by the memory arbitrator. Abort to
-      // prevent this pool from triggering memory arbitration. The associated
-      // query should also abort soon.
-      VELOX_MEM_POOL_ABORTED("This memory pool has been aborted.");
-    }
-    if (reservationBytes_ + size > capacity_) {
+    checkIfAborted();
+
+    // NOTE: we allow memory pool to overuse its memory during the memory
+    // arbitration process. The memory arbitration process itself needs to
+    // ensure the memory pool usage of the memory pool is within the capacity
+    // limit after the arbitration operation completes.
+    if (FOLLY_UNLIKELY(
+            (reservationBytes_ + size > capacity_) &&
+            !underMemoryArbitration())) {
       return false;
     }
   }
-  reservationBytes_ += size;
+  incrementReservationLocked(size);
+  return true;
+}
+
+void MemoryPoolImpl::incrementReservationLocked(uint64_t bytes) {
+  reservationBytes_ += bytes;
   if (!isLeaf()) {
-    cumulativeBytes_ += size;
+    cumulativeBytes_ += bytes;
     maybeUpdatePeakBytesLocked(reservationBytes_);
   }
-  return true;
 }
 
 void MemoryPoolImpl::release() {
@@ -849,9 +967,9 @@ void MemoryPoolImpl::decrementReservation(uint64_t size) noexcept {
   sanityCheckLocked();
 }
 
-std::string MemoryPoolImpl::treeMemoryUsage() const {
+std::string MemoryPoolImpl::treeMemoryUsage(bool skipEmptyPool) const {
   if (parent_ != nullptr) {
-    return parent_->treeMemoryUsage();
+    return parent_->treeMemoryUsage(skipEmptyPool);
   }
   if (FLAGS_velox_suppress_memory_capacity_exceeding_error_message) {
     return "";
@@ -862,14 +980,15 @@ std::string MemoryPoolImpl::treeMemoryUsage() const {
     const Stats stats = statsLocked();
     const MemoryUsage usage{
         .name = name(),
-        .currentUsage = stats.currentBytes,
+        .currentUsage = stats.usedBytes,
+        .reservedUsage = stats.reservedBytes,
         .peakUsage = stats.peakBytes};
     out << usage.toString() << "\n";
   }
 
   MemoryUsageHeap topLeafMemUsages;
   visitChildren([&, indent = kCapMessageIndentSize](MemoryPool* pool) {
-    treeMemoryUsageVisitor(pool, indent, topLeafMemUsages, out);
+    treeMemoryUsageVisitor(pool, indent, topLeafMemUsages, skipEmptyPool, out);
     return true;
   });
 
@@ -892,7 +1011,11 @@ uint64_t MemoryPoolImpl::freeBytes() const {
   if (capacity_ == kMaxMemory) {
     return 0;
   }
-  VELOX_CHECK_GE(capacity_, reservationBytes_);
+  if (capacity_ < reservationBytes_) {
+    // NOTE: the memory reservation could be temporarily larger than its
+    // capacity if this memory pool is under memory arbitration processing.
+    return 0;
+  }
   return capacity_ - reservationBytes_;
 }
 
@@ -915,21 +1038,27 @@ MemoryReclaimer* MemoryPoolImpl::reclaimer() const {
   return reclaimer_.get();
 }
 
-bool MemoryPoolImpl::reclaimableBytes(uint64_t& reclaimableBytes) const {
-  reclaimableBytes = 0;
+std::optional<uint64_t> MemoryPoolImpl::reclaimableBytes() const {
   if (reclaimer() == nullptr) {
-    return false;
+    return std::nullopt;
   }
-  return reclaimer()->reclaimableBytes(*this, reclaimableBytes);
+
+  uint64_t reclaimableBytes = 0;
+  if (!reclaimer()->reclaimableBytes(*this, reclaimableBytes)) {
+    return std::nullopt;
+  }
+
+  return reclaimableBytes;
 }
 
 uint64_t MemoryPoolImpl::reclaim(
     uint64_t targetBytes,
+    uint64_t maxWaitMs,
     memory::MemoryReclaimer::Stats& stats) {
   if (reclaimer() == nullptr) {
     return 0;
   }
-  return reclaimer()->reclaim(this, targetBytes, stats);
+  return reclaimer()->reclaim(this, targetBytes, maxWaitMs, stats);
 }
 
 void MemoryPoolImpl::enterArbitration() {
@@ -946,7 +1075,7 @@ void MemoryPoolImpl::leaveArbitration() noexcept {
 
 uint64_t MemoryPoolImpl::shrink(uint64_t targetBytes) {
   if (parent_ != nullptr) {
-    return parent_->shrink(targetBytes);
+    return toImpl(parent_)->shrink(targetBytes);
   }
   std::lock_guard<std::mutex> l(mutex_);
   // We don't expect to shrink a memory pool without capacity limit.
@@ -959,27 +1088,29 @@ uint64_t MemoryPoolImpl::shrink(uint64_t targetBytes) {
   return freeBytes;
 }
 
-uint64_t MemoryPoolImpl::grow(uint64_t bytes) noexcept {
+bool MemoryPoolImpl::grow(uint64_t growBytes, uint64_t reservationBytes) {
   if (parent_ != nullptr) {
-    return parent_->grow(bytes);
+    return toImpl(parent_)->grow(growBytes, reservationBytes);
   }
   // TODO: add to prevent from growing beyond the max capacity and the
   // corresponding support in memory arbitrator.
   std::lock_guard<std::mutex> l(mutex_);
   // We don't expect to grow a memory pool without capacity limit.
   VELOX_CHECK_NE(capacity_, kMaxMemory, "Can't grow with unlimited capacity");
-  VELOX_CHECK_LE(
-      capacity_ + bytes, maxCapacity_, "Can't grow beyond the max capacity");
-  capacity_ += bytes;
-  VELOX_CHECK_GE(capacity_, bytes);
-  return capacity_;
-}
+  if (capacity_ + growBytes > maxCapacity_) {
+    return false;
+  }
+  if (reservationBytes_ + reservationBytes > capacity_ + growBytes) {
+    return false;
+  }
 
-bool MemoryPoolImpl::aborted() const {
-  if (parent_ != nullptr) {
-    return parent_->aborted();
+  capacity_ += growBytes;
+  VELOX_CHECK_GE(capacity_, growBytes);
+  if (reservationBytes > 0) {
+    incrementReservationLocked(reservationBytes);
+    VELOX_CHECK_LE(reservationBytes, reservationBytes_);
   }
-  return aborted_;
+  return true;
 }
 
 void MemoryPoolImpl::abort(const std::exception_ptr& error) {
@@ -991,10 +1122,37 @@ void MemoryPoolImpl::abort(const std::exception_ptr& error) {
   if (reclaimer() == nullptr) {
     VELOX_FAIL("Can't abort the memory pool {} without reclaimer", name_);
   }
-  aborted_ = true;
+  setAbortError(error);
   reclaimer()->abort(this, error);
 }
 
+void MemoryPoolImpl::setAbortError(const std::exception_ptr& error) {
+  VELOX_CHECK(
+      !aborted_,
+      "Trying to set another abort error on an already aborted pool.");
+  abortError_ = error;
+  aborted_ = true;
+}
+
+void MemoryPoolImpl::checkIfAborted() const {
+  if (FOLLY_UNLIKELY(aborted())) {
+    VELOX_CHECK_NOT_NULL(abortError());
+    std::rethrow_exception(abortError());
+  }
+}
+
+void MemoryPoolImpl::setDestructionCallback(
+    const DestructionCallback& callback) {
+  VELOX_CHECK_NOT_NULL(callback);
+  VELOX_CHECK(
+      isRoot(),
+      "Only root memory pool allows to set destruction callbacks: {}",
+      name_);
+  std::lock_guard<std::mutex> l(mutex_);
+  VELOX_CHECK_NULL(destructionCb_);
+  destructionCb_ = callback;
+}
+
 void MemoryPoolImpl::testingSetCapacity(int64_t bytes) {
   if (parent_ != nullptr) {
     return toImpl(parent_)->testingSetCapacity(bytes);
@@ -1003,6 +1161,14 @@ void MemoryPoolImpl::testingSetCapacity(int64_t bytes) {
   capacity_ = bytes;
 }
 
+void MemoryPoolImpl::testingSetReservation(int64_t bytes) {
+  if (parent_ != nullptr) {
+    return toImpl(parent_)->testingSetReservation(bytes);
+  }
+  std::lock_guard<std::mutex> l(mutex_);
+  reservationBytes_ = bytes;
+}
+
 bool MemoryPoolImpl::needRecordDbg(bool /* isAlloc */) {
   if (!debugPoolNameRegex_.empty()) {
     return RE2::FullMatch(name_, debugPoolNameRegex_);
@@ -1016,10 +1182,10 @@ void MemoryPoolImpl::recordAllocDbg(const void* addr, uint64_t size) {
   if (!needRecordDbg(true)) {
     return;
   }
-  const auto stackTrace = process::StackTrace().toString();
   std::lock_guard<std::mutex> l(debugAllocMutex_);
   debugAllocRecords_.emplace(
-      reinterpret_cast<uint64_t>(addr), AllocationRecord{size, stackTrace});
+      reinterpret_cast<uint64_t>(addr),
+      AllocationRecord{size, process::StackTrace()});
 }
 
 void MemoryPoolImpl::recordAllocDbg(const Allocation& allocation) {
@@ -1060,7 +1226,7 @@ void MemoryPoolImpl::recordFreeDbg(const void* addr, uint64_t size) {
         "{}\n",
         size,
         allocRecord.size,
-        allocRecord.callStack,
+        allocRecord.callStack.toString(),
         freeStackTrace));
   }
   debugAllocRecords_.erase(addrUint64);
@@ -1105,12 +1271,51 @@ void MemoryPoolImpl::leakCheckDbg() {
   std::ostream oss(&buf);
   oss << "Detected total of " << debugAllocRecords_.size()
       << " leaked allocations:\n";
+  struct AllocationStats {
+    uint64_t size{0};
+    uint64_t numAllocations{0};
+  };
+  std::unordered_map<std::string, AllocationStats> sizeAggregatedRecords;
   for (const auto& itr : debugAllocRecords_) {
     const auto& allocationRecord = itr.second;
-    oss << "======== Leaked memory allocation of " << allocationRecord.size
-        << " bytes ========\n"
-        << allocationRecord.callStack;
+    const auto stackStr = allocationRecord.callStack.toString();
+    if (sizeAggregatedRecords.count(stackStr) == 0) {
+      sizeAggregatedRecords[stackStr] = AllocationStats();
+    }
+    sizeAggregatedRecords[stackStr].size += allocationRecord.size;
+    ++sizeAggregatedRecords[stackStr].numAllocations;
+  }
+  std::vector<std::pair<std::string, AllocationStats>> sortedRecords(
+      sizeAggregatedRecords.begin(), sizeAggregatedRecords.end());
+  std::sort(
+      sortedRecords.begin(),
+      sortedRecords.end(),
+      [](const std::pair<std::string, AllocationStats>& a,
+         std::pair<std::string, AllocationStats>& b) {
+        return a.second.size > b.second.size;
+      });
+  for (const auto& pair : sortedRecords) {
+    oss << "======== Leaked memory from " << pair.second.numAllocations
+        << " total allocations of " << succinctBytes(pair.second.size)
+        << " total size ========\n"
+        << pair.first << "\n";
   }
   VELOX_FAIL(buf.str());
 }
+
+void MemoryPoolImpl::handleAllocationFailure(
+    const std::string& failureMessage) {
+  if (coreOnAllocationFailureEnabled_) {
+    VELOX_MEM_LOG(ERROR) << failureMessage;
+    // SIGBUS is one of the standard signals in Linux that triggers a core dump
+    // Normally it is raised by the operating system when a misaligned memory
+    // access occurs. On x86 and aarch64 misaligned access is allowed by default
+    // hence this signal should never occur naturally. Raising a signal other
+    // than SIGABRT makes it easier to distinguish an allocation failure from
+    // any other crash
+    raise(SIGBUS);
+  }
+
+  VELOX_MEM_ALLOC_ERROR(failureMessage);
+}
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/MemoryPool.h b/velox/common/memory/MemoryPool.h
index b12e0799a29c2..1f3b33ed3a906 100644
--- a/velox/common/memory/MemoryPool.h
+++ b/velox/common/memory/MemoryPool.h
@@ -22,6 +22,7 @@
 #include <optional>
 #include <queue>
 
+#include <fmt/format.h>
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Portability.h"
@@ -32,6 +33,11 @@
 
 DECLARE_bool(velox_memory_leak_check_enabled);
 DECLARE_bool(velox_memory_pool_debug_enabled);
+DECLARE_bool(velox_memory_pool_capacity_transfer_across_tasks);
+
+namespace facebook::velox::exec {
+class ParallelMemoryReclaimer;
+}
 
 namespace facebook::velox::memory {
 #define VELOX_MEM_POOL_CAP_EXCEEDED(errorMessage)                   \
@@ -56,9 +62,6 @@ class MemoryManager;
 
 constexpr int64_t kMaxMemory = std::numeric_limits<int64_t>::max();
 
-/// Sets the memory reclaimer to the provided memory pool.
-using SetMemoryReclaimer = std::function<void(MemoryPool*)>;
-
 /// This class provides the memory allocation interfaces for a query execution.
 /// Each query execution entity creates a dedicated memory pool object. The
 /// memory pool objects from a query are organized as a tree with four levels
@@ -79,33 +82,33 @@ using SetMemoryReclaimer = std::function<void(MemoryPool*)>;
 /// one per each query plan node. The task pool is the parent of all the node
 /// pools from the task's physical query plan fragment. The node pool is created
 /// by the first operator instantiated for the corresponding plan node. It is
-/// owned by Task via 'childPools_'
+/// owned by Task via 'childPools_'.
 ///
 /// The bottom level consists of per-operator pools. These are children of the
 /// node pool that corresponds to the plan node from which the operator is
 /// created. Operator and node pools are owned by the Task via 'childPools_'.
 ///
-/// The query pool is created from MemoryManager::getChild() as a child of a
-/// singleton root pool object (system pool). There is only one system pool for
-/// a velox process. Hence each query pool objects forms a subtree rooted from
-/// the system pool.
+/// The query pool is created from MemoryManager::addRootPool(), it has no
+/// parent and is the root node of its corresponding subtree. Each query pool is
+/// owned by QueryCtx (such as in Prestissimo), and the memory manager also
+/// tracks the current alive query pools in MemoryManager::pools_ through weak
+/// pointers.
 ///
 /// Each child pool object holds a shared reference to its parent pool object.
-/// The parent object tracks its child pool objects through the raw pool object
-/// pointer protected by a mutex. The child pool object destruction first
-/// removes its raw pointer from its parent through dropChild() and then drops
-/// the shared reference on the parent.
+/// The parent object tracks its child pool objects through weak pointers
+/// protected by a mutex. The child pool object destruction first removes its
+/// weak pointer from its parent through dropChild() and then drops the shared
+/// reference on the parent.
 ///
 /// NOTE: for the users that integrate at expression evaluation level, we don't
 /// need to build the memory pool hierarchy as described above. Users can either
-/// create a single memory pool from MemoryManager::getChild() to share with
+/// create a single memory pool from MemoryManager::addLeafPool() to share with
 /// all the concurrent expression evaluations or create one dedicated memory
 /// pool for each expression evaluation if they need per-expression memory quota
 /// enforcement.
 ///
 /// In addition to providing memory allocation functions, the memory pool object
-/// also provides memory usage accounting through MemoryUsageTracker. This will
-/// be merged into memory pool object later.
+/// also provides memory usage accounting.
 class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
  public:
   /// Defines the kinds of a memory pool.
@@ -135,7 +138,7 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
     /// tracking and the capacity enforcement on top of that, but are sensitive
     /// to its cpu cost so we provide an options for user to turn it off. We can
     /// only turn on/off this feature at the root memory pool and automatically
-    /// applies to all its child pools , and we don't support to selectively
+    /// applies to all its child pools, and we don't support to selectively
     /// enable it on a subset of memory pools.
     bool trackUsage{true};
 
@@ -148,18 +151,13 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
     /// memory pools from the same root memory pool independently.
     bool threadSafe{true};
 
-    /// TODO: deprecate this flag after all the existing memory leak use cases
-    /// have been fixed.
-    ///
-    /// If true, checks the memory usage leak on destruction.
-    ///
-    /// NOTE: user can turn on/off the memory leak check of each individual
-    /// memory pools from the same root memory pool independently.
-    bool checkUsageLeak{FLAGS_velox_memory_leak_check_enabled};
-
     /// If true, tracks the allocation and free call stacks to detect the source
     /// of memory leak for testing purpose.
     bool debugEnabled{FLAGS_velox_memory_pool_debug_enabled};
+
+    /// Terminates the process and generates a core file on an allocation
+    /// failure
+    bool coreOnAllocationFailureEnabled{false};
   };
 
   /// Constructs a named memory pool with specified 'name', 'parent' and 'kind'.
@@ -177,6 +175,7 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   virtual ~MemoryPool();
 
   /// Tree methods used to access and manage the memory hierarchy.
+
   /// Returns the name of this memory pool.
   virtual const std::string& name() const;
 
@@ -208,17 +207,9 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
     return threadSafe_;
   }
 
-  /// Returns true if this memory pool checks memory leak on destruction.
-  /// Used only for test purposes.
-  virtual bool testingCheckUsageLeak() const {
-    return checkUsageLeak_;
-  }
-
-  /// Invoked to traverse the memory pool subtree rooted at this, and calls
-  /// 'visitor' on each visited child memory pool with the parent pool's
-  /// 'poolMutex_' reader lock held. The 'visitor' must not access the
-  /// parent memory pool to avoid the potential recursive locking issues. Note
-  /// that the traversal stops if 'visitor' returns false.
+  /// Invoked to visit the memory pool's direct children, and calls 'visitor' on
+  /// each visited child memory pool. Note that the traversal stops if 'visitor'
+  /// returns false.
   virtual void visitChildren(
       const std::function<bool(MemoryPool*)>& visitor) const;
 
@@ -247,9 +238,7 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   virtual void* allocateZeroFilled(int64_t numEntries, int64_t sizeEach) = 0;
 
   /// Re-allocates from an existing buffer with 'newSize' and update memory
-  /// usage counting accordingly. If 'newSize' is larger than the current buffer
-  /// 'size', the function will allocate a new buffer and free the old buffer.
-  /// If the new allocation fails, this method will throw and not free 'p'.
+  /// usage counting accordingly.
   virtual void* reallocate(void* p, int64_t size, int64_t newSize) = 0;
 
   /// Frees an allocated buffer.
@@ -328,21 +317,30 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   /// 'capacity()' is fixed and set to 'maxCapacity()' on creation.
   virtual int64_t capacity() const = 0;
 
-  /// Returns the currently used memory in bytes of this memory pool.
-  virtual int64_t currentBytes() const = 0;
+  /// Returns the currently used memory in bytes of this memory pool. For
+  /// non-leaf memory pool, the function returns the aggregated used memory from
+  /// all its child memory pools.
+  virtual int64_t usedBytes() const = 0;
 
   /// Returns the peak memory usage in bytes of this memory pool.
   virtual int64_t peakBytes() const = 0;
 
-  /// Returns the reserved but not used memory reservation in bytes of this
-  /// memory pool.
+  /// Returns the reserved but not used memory in bytes of this memory pool.
   ///
-  /// NOTE: this is always zero for non-leaf memory pool as it only aggregate
+  /// NOTE: this is always zero for non-leaf memory pool as it only aggregates
   /// the memory reservations from its child memory pools but not
   /// differentiating whether the aggregated reservations have been actually
   /// used in child pools or not.
   virtual int64_t availableReservation() const = 0;
 
+  /// Returns the reserved but not used memory in bytes that can be released by
+  /// calling 'release()'. This might be different from 'availableReservation()'
+  /// because leaf memory pool makes quantized memory reservation.
+  ///
+  /// NOTE: For non-leaf memory pool, it returns the aggregated releasable
+  /// memory reservations from all its leaf memory pool.
+  virtual int64_t releasableReservation() const = 0;
+
   /// Returns the reserved memory reservation in bytes including both used and
   /// unused reservations.
   virtual int64_t reservedBytes() const = 0;
@@ -366,16 +364,6 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   /// without actually freeing the used memory.
   virtual uint64_t freeBytes() const = 0;
 
-  /// Invoked to free up to the specified amount of free memory by reducing
-  /// this memory pool's capacity without actually freeing any used memory. The
-  /// function returns the actually freed memory capacity in bytes. If
-  /// 'targetBytes' is zero, the function frees all the free memory capacity.
-  virtual uint64_t shrink(uint64_t targetBytes = 0) = 0;
-
-  /// Invoked to increase the memory pool's capacity by 'bytes'. The function
-  /// returns the memory pool's capacity after the growth.
-  virtual uint64_t grow(uint64_t bytes) noexcept = 0;
-
   /// Sets the memory reclaimer for this memory pool.
   ///
   /// NOTE: this shall only be called at most once if the memory pool hasn't set
@@ -385,31 +373,23 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   /// Returns the memory reclaimer of this memory pool if not null.
   virtual MemoryReclaimer* reclaimer() const = 0;
 
-  /// Invoked by the memory arbitrator to enter memory arbitration processing.
-  /// It is a noop if 'reclaimer_' is not set, otherwise invoke the reclaimer's
-  /// corresponding method.
-  virtual void enterArbitration() = 0;
-
-  /// Invoked by the memory arbitrator to leave memory arbitration processing.
-  /// It is a noop if 'reclaimer_' is not set, otherwise invoke the reclaimer's
-  /// corresponding method.
-  virtual void leaveArbitration() noexcept = 0;
-
-  /// Returns how many bytes is reclaimable from this memory pool. The function
-  /// returns true if this memory pool is reclaimable, and returns the estimated
-  /// reclaimable bytes in 'reclaimableBytes'. If 'reclaimer_' is not set, the
-  /// function returns false, otherwise invoke the reclaimer's corresponding
-  /// method.
-  virtual bool reclaimableBytes(uint64_t& reclaimableBytes) const = 0;
+  /// Function estimates the number of reclaimable bytes and returns in
+  /// 'reclaimableBytes'. If the 'reclaimer' is not set, the function returns
+  /// std::nullopt. Otherwise, it will invoke the corresponding method of the
+  /// reclaimer.
+  virtual std::optional<uint64_t> reclaimableBytes() const = 0;
 
   /// Invoked by the memory arbitrator to reclaim memory from this memory pool
   /// with specified reclaim target bytes. If 'targetBytes' is zero, then it
   /// tries to reclaim all the reclaimable memory from the memory pool. It is
   /// noop if the reclaimer is not set, otherwise invoke the reclaimer's
-  /// corresponding method. The function returns the actually freed capacity
-  /// from the root of this memory pool.
+  /// corresponding method. If not zero, 'maxWaitMs' specifies the max time in
+  /// milliseconds to wait for reclaim. The memory reclaim might fail if exceeds
+  /// the timeout. The function returns the actually freed capacity from the
+  /// root of this memory pool.
   virtual uint64_t reclaim(
       uint64_t targetBytes,
+      uint64_t maxWaitMs,
       memory::MemoryReclaimer::Stats& stats) = 0;
 
   /// Invoked by the memory arbitrator to abort a root memory pool. The function
@@ -422,12 +402,14 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   virtual void abort(const std::exception_ptr& error) = 0;
 
   /// Returns true if this memory pool has been aborted.
-  virtual bool aborted() const = 0;
+  virtual bool aborted() const;
 
   /// The memory pool's execution stats.
   struct Stats {
     /// The current memory usage.
-    uint64_t currentBytes{0};
+    uint64_t usedBytes{0};
+    /// The current reserved memory.
+    uint64_t reservedBytes{0};
     /// The peak memory usage.
     uint64_t peakBytes{0};
     /// The accumulative memory usage.
@@ -454,16 +436,21 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
     /// The number of internal memory reservation collisions caused by
     /// concurrent memory requests.
     uint64_t numCollisions{0};
+    /// The number of memory capacity growth attempts through the memory
+    /// arbitration.
+    ///
+    /// NOTE: this only applies for the root memory pool.
+    uint64_t numCapacityGrowths{0};
 
     bool operator==(const Stats& rhs) const;
 
     std::string toString() const;
 
-    /// Returns true if the current bytes is zero.
+    /// Returns true if the current and reserved bytes are zero.
     /// Note that peak or cumulative bytes might be non-zero and we are still
     /// empty at this moment.
     bool empty() const {
-      return currentBytes == 0;
+      return usedBytes == 0 && reservedBytes == 0;
     }
   };
 
@@ -473,8 +460,9 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   virtual std::string toString() const = 0;
 
   /// Invoked to generate a descriptive memory usage summary of the entire tree.
-  /// MemoryPoolImpl::treeMemoryUsage()
-  virtual std::string treeMemoryUsage() const = 0;
+  /// If 'skipEmptyPool' is true, then skip print out the child memory pools
+  /// with empty memory usage.
+  virtual std::string treeMemoryUsage(bool skipEmptyPool = true) const = 0;
 
   /// Indicates if this is a leaf memory pool or not.
   FOLLY_ALWAYS_INLINE bool isLeaf() const {
@@ -502,8 +490,35 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
  protected:
   static constexpr uint64_t kMB = 1 << 20;
 
-  /// Invoked by addChild() to create a child memory pool object. 'parent' is
-  /// a shared pointer created from this.
+  /// Invoked by the memory arbitrator to enter memory arbitration processing.
+  /// It is a noop if 'reclaimer' is not set, otherwise invoke the reclaimer's
+  /// corresponding method.
+  virtual void enterArbitration() = 0;
+
+  /// Invoked by the memory arbitrator to leave memory arbitration processing.
+  /// It is a noop if 'reclaimer' is not set, otherwise invoke the reclaimer's
+  /// corresponding method.
+  virtual void leaveArbitration() noexcept = 0;
+
+  /// Invoked to free up to the specified amount of free memory by reducing
+  /// this memory pool's capacity without actually freeing any used memory. The
+  /// function returns the actually freed memory capacity in bytes. If
+  /// 'targetBytes' is zero, the function frees all the free memory capacity.
+  virtual uint64_t shrink(uint64_t targetBytes = 0) = 0;
+
+  /// Invoked to increase the memory pool's capacity by 'growBytes' and commit
+  /// the reservation by 'reservationBytes'. The function makes the two updates
+  /// atomic. The function returns true if the updates succeed, otherwise false
+  /// and neither change will apply.
+  ///
+  /// NOTE: this should only be called by memory arbitrator when a root memory
+  /// pool tries to grow its capacity for a new reservation request which
+  /// exceeds its current capacity limit.
+  virtual bool grow(uint64_t growBytes, uint64_t reservationBytes = 0) = 0;
+
+  /// Invoked by addLeafChild() and addAggregateChild() to create a child memory
+  /// pool object. 'parent' is a shared pointer created from this, ie,
+  /// shared_from_this().
   virtual std::shared_ptr<MemoryPool> genChild(
       std::shared_ptr<MemoryPool> parent,
       const std::string& name,
@@ -511,6 +526,8 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
       bool threadSafe,
       std::unique_ptr<MemoryReclaimer> reclaimer) = 0;
 
+  virtual std::exception_ptr abortError() const;
+
   /// Invoked only on destruction to remove this memory pool from its parent's
   /// child memory pool tracking.
   virtual void dropChild(const MemoryPool* child);
@@ -522,8 +539,8 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   const int64_t maxCapacity_;
   const bool trackUsage_;
   const bool threadSafe_;
-  const bool checkUsageLeak_;
   const bool debugEnabled_;
+  const bool coreOnAllocationFailureEnabled_;
 
   /// Indicates if the memory pool has been aborted by the memory arbitrator or
   /// not.
@@ -531,15 +548,22 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   /// NOTE: this flag is only set for a root memory pool if it has memory
   /// reclaimer. We process a query abort request from the root memory pool.
   std::atomic<bool> aborted_{false};
+  /// Saves the aborted error exception which is only set if 'aborted_' is true.
+  std::exception_ptr abortError_{nullptr};
 
   mutable folly::SharedMutex poolMutex_;
-  // NOTE: we use raw pointer instead of weak pointer here to minimize
-  // visitChildren() cost as we don't have to upgrade the weak pointer and copy
-  // out the upgraded shared pointers.git
   std::unordered_map<std::string, std::weak_ptr<MemoryPool>> children_;
 
-  friend class TestMemoryReclaimer;
   friend class MemoryReclaimer;
+  friend class velox::exec::ParallelMemoryReclaimer;
+  friend class MemoryManager;
+  friend class MemoryArbitrator;
+  friend class ScopedMemoryPoolArbitrationCtx;
+
+  VELOX_FRIEND_TEST(MemoryPoolTest, shrinkAndGrowAPIs);
+  VELOX_FRIEND_TEST(MemoryPoolTest, grow);
+  VELOX_FRIEND_TEST(MemoryPoolTest, growFailures);
+  VELOX_FRIEND_TEST(MemoryPoolTest, grownonContiguousAllocateFailures);
 };
 
 std::ostream& operator<<(std::ostream& out, MemoryPool::Kind kind);
@@ -548,6 +572,8 @@ std::ostream& operator<<(std::ostream& os, const MemoryPool::Stats& stats);
 
 class MemoryPoolImpl : public MemoryPool {
  public:
+  /// The callback invoked on the root memory pool destruction. It is set by
+  /// memory manager to removes the pool from 'MemoryManager::pools_'.
   using DestructionCallback = std::function<void(MemoryPool*)>;
 
   MemoryPoolImpl(
@@ -555,8 +581,7 @@ class MemoryPoolImpl : public MemoryPool {
       const std::string& name,
       Kind kind,
       std::shared_ptr<MemoryPool> parent,
-      std::unique_ptr<MemoryReclaimer> reclaimer = nullptr,
-      DestructionCallback destructionCb = nullptr,
+      std::unique_ptr<MemoryReclaimer> reclaimer,
       const Options& options = Options{});
 
   ~MemoryPoolImpl() override;
@@ -593,10 +618,7 @@ class MemoryPoolImpl : public MemoryPool {
 
   int64_t capacity() const override;
 
-  int64_t currentBytes() const override {
-    std::lock_guard<std::mutex> l(mutex_);
-    return currentBytesLocked();
-  }
+  int64_t usedBytes() const override;
 
   int64_t peakBytes() const override {
     std::lock_guard<std::mutex> l(mutex_);
@@ -608,8 +630,9 @@ class MemoryPoolImpl : public MemoryPool {
     return availableReservationLocked();
   }
 
+  int64_t releasableReservation() const override;
+
   int64_t reservedBytes() const override {
-    std::lock_guard<std::mutex> l(mutex_);
     return reservationBytes_;
   }
 
@@ -623,65 +646,73 @@ class MemoryPoolImpl : public MemoryPool {
 
   MemoryReclaimer* reclaimer() const override;
 
-  void enterArbitration() override;
-
-  void leaveArbitration() noexcept override;
-
-  bool reclaimableBytes(uint64_t& reclaimableBytes) const override;
-
-  uint64_t reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
-      override;
-
-  uint64_t shrink(uint64_t targetBytes = 0) override;
+  std::optional<uint64_t> reclaimableBytes() const override;
 
-  uint64_t grow(uint64_t bytes) noexcept override;
+  uint64_t reclaim(
+      uint64_t targetBytes,
+      uint64_t maxWaitMs,
+      memory::MemoryReclaimer::Stats& stats) override;
 
   void abort(const std::exception_ptr& error) override;
 
-  bool aborted() const override;
+  void setDestructionCallback(const DestructionCallback& callback);
 
   std::string toString() const override {
     std::lock_guard<std::mutex> l(mutex_);
     return toStringLocked();
   }
 
-  // Detailed debug pool state printout by traversing the pool structure from
-  // the root memory pool.
-  //
-  // Exceeded memory cap of 5.00MB when requesting 2.00MB
-  // default_root_1 usage 5.00MB peak 5.00MB
-  //     task.test_cursor 1 usage 5.00MB peak 5.00MB
-  //         node.N/A usage 0B peak 0B
-  //             op.N/A.0.0.CallbackSink usage 0B peak 0B
-  //         node.2 usage 4.00MB peak 4.00MB
-  //             op.2.0.0.Aggregation usage 3.77MB peak 3.77MB
-  //         node.1 usage 1.00MB peak 1.00MB
-  //             op.1.0.0.FilterProject usage 12.00KB peak 12.00KB
-  //         node.3 usage 0B peak 0B
-  //             op.3.0.0.OrderBy usage 0B peak 0B
-  //         node.0 usage 0B peak 0B
-  //             op.0.0.0.Values usage 0B peak 0B
-  //
-  // Top 5 leaf memory pool usages:
-  //     op.2.0.0.Aggregation usage 3.77MB peak 3.77MB
-  //     op.1.0.0.FilterProject usage 12.00KB peak 12.00KB
-  //     op.N/A.0.0.CallbackSink usage 0B peak 0B
-  //     op.3.0.0.OrderBy usage 0B peak 0B
-  //     op.0.0.0.Values usage 0B peak 0B
-  std::string treeMemoryUsage() const override;
+  /// Detailed debug pool state printout by traversing the pool structure from
+  /// the root memory pool.
+  ///
+  /// Exceeded memory cap of 5.00MB when requesting 2.00MB
+  /// default_root_1 usage 5.00MB peak 5.00MB
+  ///     task.test_cursor 1 usage 5.00MB peak 5.00MB
+  ///         node.N/A usage 0B peak 0B
+  ///             op.N/A.0.0.CallbackSink usage 0B peak 0B
+  ///         node.2 usage 4.00MB peak 4.00MB
+  ///             op.2.0.0.Aggregation usage 3.77MB peak 3.77MB
+  ///         node.1 usage 1.00MB peak 1.00MB
+  ///             op.1.0.0.FilterProject usage 12.00KB peak 12.00KB
+  ///         node.3 usage 0B peak 0B
+  ///             op.3.0.0.OrderBy usage 0B peak 0B
+  ///         node.0 usage 0B peak 0B
+  ///             op.0.0.0.Values usage 0B peak 0B
+  ///
+  /// Top 5 leaf memory pool usages:
+  ///     op.2.0.0.Aggregation usage 3.77MB peak 3.77MB
+  ///     op.1.0.0.FilterProject usage 12.00KB peak 12.00KB
+  ///     op.N/A.0.0.CallbackSink usage 0B peak 0B
+  ///     op.3.0.0.OrderBy usage 0B peak 0B
+  ///     op.0.0.0.Values usage 0B peak 0B
+  std::string treeMemoryUsage(bool skipEmptyPool = true) const override;
 
   Stats stats() const override;
 
   void testingSetCapacity(int64_t bytes);
 
+  void testingSetReservation(int64_t bytes);
+
+  MemoryManager* testingManager() const {
+    return manager_;
+  }
+
   MemoryAllocator* testingAllocator() const {
     return allocator_;
   }
 
+  void testingCheckIfAborted() const {
+    checkIfAborted();
+  }
+
+  uint64_t testingMinReservationBytes() const {
+    return minReservationBytes_;
+  }
+
   /// Structure to store allocation details in debug mode.
   struct AllocationRecord {
     uint64_t size;
-    std::string callStack;
+    process::StackTrace callStack;
   };
 
   std::unordered_map<uint64_t, AllocationRecord>& testingDebugAllocRecords() {
@@ -693,6 +724,14 @@ class MemoryPoolImpl : public MemoryPool {
   }
 
  private:
+  void enterArbitration() override;
+
+  void leaveArbitration() noexcept override;
+
+  uint64_t shrink(uint64_t targetBytes = 0) override;
+
+  bool grow(uint64_t growBytes, uint64_t reservationBytes = 0) override;
+
   FOLLY_ALWAYS_INLINE static MemoryPoolImpl* toImpl(MemoryPool* pool) {
     return static_cast<MemoryPoolImpl*>(pool);
   }
@@ -718,10 +757,6 @@ class MemoryPoolImpl : public MemoryPool {
     return parent_ != nullptr ? toImpl(parent_)->capacity_ : capacity_;
   }
 
-  FOLLY_ALWAYS_INLINE int64_t currentBytesLocked() const {
-    return isLeaf() ? usedReservationBytes_ : reservationBytes_;
-  }
-
   FOLLY_ALWAYS_INLINE int64_t availableReservationLocked() const {
     return !isLeaf()
         ? 0
@@ -822,7 +857,8 @@ class MemoryPoolImpl : public MemoryPool {
   // Tries to increment the reservation 'size' if it is within the limit and
   // returns true, otherwise the function returns false.
   bool maybeIncrementReservation(uint64_t size);
-  bool maybeIncrementReservationLocked(uint64_t size);
+
+  void incrementReservationLocked(uint64_t bytes);
 
   // Release memory reservation for an allocation free or memory release with
   // specified 'size'. If 'releaseOnly' is true, then we only release the unused
@@ -833,6 +869,11 @@ class MemoryPoolImpl : public MemoryPool {
 
   void releaseThreadSafe(uint64_t size, bool releaseOnly);
 
+  // Invoked to grow capacity of the root memory pool from the memory
+  // arbitrator. 'requestor' is the leaf memory pool that triggers the memory
+  // capacity growth. 'size' is the memory capacity growth in bytes.
+  bool growCapacity(MemoryPool* requestor, uint64_t size);
+
   FOLLY_ALWAYS_INLINE void releaseNonThreadSafe(
       uint64_t size,
       bool releaseOnly) {
@@ -874,6 +915,13 @@ class MemoryPoolImpl : public MemoryPool {
     }
   }
 
+  void setAbortError(const std::exception_ptr& error);
+
+  // Check if this memory pool has been aborted. If already aborted, we rethrow
+  // the preserved abort error to prevent this pool from triggering additional
+  // memory arbitration. The associated query should also abort soon.
+  void checkIfAborted() const;
+
   Stats statsLocked() const;
 
   FOLLY_ALWAYS_INLINE std::string toStringLocked() const {
@@ -894,7 +942,7 @@ class MemoryPoolImpl : public MemoryPool {
     } else {
       out << "unlimited capacity ";
     }
-    out << "used " << succinctBytes(currentBytesLocked()) << " available "
+    out << "used " << succinctBytes(usedBytes()) << " available "
         << succinctBytes(availableReservationLocked());
     out << " reservation [used " << succinctBytes(usedReservationBytes_)
         << ", reserved " << succinctBytes(reservationBytes_) << ", min "
@@ -949,22 +997,26 @@ class MemoryPoolImpl : public MemoryPool {
   // pool is enabled.
   void leakCheckDbg();
 
+  void handleAllocationFailure(const std::string& failureMessage);
+
   MemoryManager* const manager_;
   MemoryAllocator* const allocator_;
-  const DestructionCallback destructionCb_;
+  MemoryArbitrator* const arbitrator_;
 
   // Regex for filtering on 'name_' when debug mode is enabled. This allows us
   // to only track the callsites of memory allocations for memory pools whose
   // name matches the specified regular expression 'debugPoolNameRegex_'.
   const std::string debugPoolNameRegex_;
 
-  // Serializes updates on 'grantedReservationBytes_', 'usedReservationBytes_'
+  // Serializes updates on 'reservationBytes_', 'usedReservationBytes_'
   // and 'minReservationBytes_' to make reservation decision on a consistent
   // read/write of those counters. incrementReservation()/decrementReservation()
   // work based on atomic 'reservationBytes_' without mutex as children updating
   // the same parent do not have to be serialized.
   mutable std::mutex mutex_;
 
+  DestructionCallback destructionCb_;
+
   // Used by memory arbitration to reclaim memory from the associated query
   // object if not null. For example, a memory pool can reclaim the used memory
   // from a spillable operator through disk spilling. If null, we can't reclaim
@@ -991,20 +1043,26 @@ class MemoryPoolImpl : public MemoryPool {
 
   // Stats counters.
   // The number of memory allocations.
-  std::atomic<uint64_t> numAllocs_{0};
+  std::atomic_uint64_t numAllocs_{0};
 
   // The number of memory frees.
-  std::atomic<uint64_t> numFrees_{0};
+  std::atomic_uint64_t numFrees_{0};
 
   // The number of external memory reservations made through maybeReserve().
-  std::atomic<uint64_t> numReserves_{0};
+  std::atomic_uint64_t numReserves_{0};
 
   // The number of external memory releases made through release().
-  std::atomic<uint64_t> numReleases_{0};
+  std::atomic_uint64_t numReleases_{0};
 
   // The number of internal memory reservation collisions caused by concurrent
   // memory reservation requests.
-  std::atomic<uint64_t> numCollisions_{0};
+  std::atomic_uint64_t numCollisions_{0};
+
+  // The number of memory capacity growth attempts through the memory
+  // arbitration.
+  //
+  // NOTE: this only applies for root memory pool.
+  std::atomic_uint64_t numCapacityGrowths_{0};
 
   // Mutex for 'debugAllocRecords_'.
   std::mutex debugAllocMutex_;
@@ -1047,3 +1105,13 @@ class StlAllocator {
   }
 };
 } // namespace facebook::velox::memory
+
+template <>
+struct fmt::formatter<facebook::velox::memory::MemoryPool::Kind>
+    : formatter<std::string> {
+  auto format(facebook::velox::memory::MemoryPool::Kind s, format_context& ctx)
+      const {
+    return formatter<std::string>::format(
+        facebook::velox::memory::MemoryPool::kindString(s), ctx);
+  }
+};
diff --git a/velox/common/memory/MmapAllocator.cpp b/velox/common/memory/MmapAllocator.cpp
index 1db2ce06a7416..8ab440e212526 100644
--- a/velox/common/memory/MmapAllocator.cpp
+++ b/velox/common/memory/MmapAllocator.cpp
@@ -18,12 +18,15 @@
 
 #include <sys/mman.h>
 
+#include "velox/common/base/Counters.h"
 #include "velox/common/base/Portability.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/memory/Memory.h"
 
 namespace facebook::velox::memory {
 MmapAllocator::MmapAllocator(const Options& options)
-    : kind_(MemoryAllocator::Kind::kMmap),
+    : MemoryAllocator(options.largestSizeClass),
+      kind_(MemoryAllocator::Kind::kMmap),
       useMmapArena_(options.useMmapArena),
       maxMallocBytes_(options.maxMallocBytes),
       mallocReservedBytes_(
@@ -52,75 +55,53 @@ MmapAllocator::~MmapAllocator() {
 }
 
 bool MmapAllocator::allocateNonContiguousWithoutRetry(
-    MachinePageCount numPages,
-    Allocation& out,
-    ReservationCallback reservationCB,
-    MachinePageCount minSizeClass) {
-  const MachinePageCount numFreed = freeInternal(out);
-  const auto bytesFreed = AllocationTraits::pageBytes(numFreed);
+    const SizeMix& sizeMix,
+    Allocation& out) {
+  const MachinePageCount numFreed = freeNonContiguousInternal(out);
   if (numFreed != 0) {
     numAllocated_.fetch_sub(numFreed);
   }
-  if (numPages == 0) {
-    if ((bytesFreed != 0) && (reservationCB != nullptr)) {
-      reservationCB(bytesFreed, false);
-    }
+  if (sizeMix.totalPages == 0) {
     return true;
   }
-  const SizeMix mix = allocationSize(numPages, minSizeClass);
-  if (testingHasInjectedFailure(InjectedFailure::kCap)) {
-    if ((bytesFreed != 0) && (reservationCB != nullptr)) {
-      reservationCB(bytesFreed, false);
-    }
-    return false;
-  }
 
-  if (numAllocated_ + mix.totalPages > capacity_) {
-    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000)
-        << "Exceeding memory allocator limit when allocate " << mix.totalPages
-        << " pages with capacity of " << capacity_ << " pages";
-    if ((bytesFreed != 0) && (reservationCB != nullptr)) {
-      reservationCB(bytesFreed, false);
-    }
+  if (numAllocated_ + sizeMix.totalPages > capacity_ ||
+      testingHasInjectedFailure(InjectedFailure::kCap)) {
+    const std::string errorMsg = fmt::format(
+        "Exceeded memory allocator limit when allocating {} pages with "
+        "capacity of {} pages",
+        sizeMix.totalPages,
+        capacity_);
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
     return false;
   }
-  if (numAllocated_.fetch_add(mix.totalPages) + mix.totalPages > capacity_) {
-    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000)
-        << "Exceeded memory allocator limit when allocate " << mix.totalPages
-        << " pages with capacity of " << capacity_ << " pages";
-    numAllocated_.fetch_sub(mix.totalPages);
-    if ((bytesFreed != 0) && (reservationCB != nullptr)) {
-      reservationCB(bytesFreed, false);
-    }
+  if (numAllocated_.fetch_add(sizeMix.totalPages) + sizeMix.totalPages >
+      capacity_) {
+    const std::string errorMsg = fmt::format(
+        "Exceeding memory allocator limit when allocating {} pages with "
+        "capacity of {} pages",
+        sizeMix.totalPages,
+        capacity_);
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
+    numAllocated_.fetch_sub(sizeMix.totalPages);
     return false;
   }
 
   ++numAllocations_;
-  numAllocatedPages_ += mix.totalPages;
-  const int64_t numNeededPages = mix.totalPages - numFreed;
-  if (reservationCB != nullptr) {
-    try {
-      reservationCB(AllocationTraits::pageBytes(numNeededPages), true);
-    } catch (const std::exception& e) {
-      VELOX_MEM_LOG_EVERY_MS(WARNING, 1000)
-          << "Exceeded memory reservation limit when reserve " << numNeededPages
-          << " new pages when allocate " << mix.totalPages << " pages";
-      numAllocated_.fetch_sub(mix.totalPages);
-      reservationCB(bytesFreed, false);
-      std::rethrow_exception(std::current_exception());
-    }
-  }
+  numAllocatedPages_ += sizeMix.totalPages;
   MachinePageCount newMapsNeeded = 0;
-  for (int i = 0; i < mix.numSizes; ++i) {
+  for (int i = 0; i < sizeMix.numSizes; ++i) {
     bool success;
     stats_.recordAllocate(
-        AllocationTraits::pageBytes(sizeClassSizes_[mix.sizeIndices[i]]),
-        mix.sizeCounts[i],
+        AllocationTraits::pageBytes(sizeClassSizes_[sizeMix.sizeIndices[i]]),
+        sizeMix.sizeCounts[i],
         [&]() {
-          success = sizeClasses_[mix.sizeIndices[i]]->allocate(
-              mix.sizeCounts[i], newMapsNeeded, out);
+          success = sizeClasses_[sizeMix.sizeIndices[i]]->allocate(
+              sizeMix.sizeCounts[i], newMapsNeeded, out);
         });
-    if (success && ((i > 0) || (mix.numSizes == 1)) &&
+    if (success && ((i > 0) || (sizeMix.numSizes == 1)) &&
         testingHasInjectedFailure(InjectedFailure::kAllocate)) {
       // Trigger memory allocation failure in the middle of the size class
       // allocation series.
@@ -129,14 +110,15 @@ bool MmapAllocator::allocateNonContiguousWithoutRetry(
     if (!success) {
       // This does not normally happen since any size class can accommodate
       // all the capacity. 'allocatedPages_' must be out of sync.
-      VELOX_MEM_LOG(WARNING) << "Failed allocation in size class " << i
-                             << " for " << mix.sizeCounts[i] << " pages";
-      const auto failedPages = mix.totalPages - out.numPages();
+      const std::string errorMsg = fmt::format(
+          "Failed allocation in size class {} for {} pages",
+          i,
+          sizeMix.sizeCounts[i]);
+      VELOX_MEM_LOG(WARNING) << errorMsg;
+      setAllocatorFailureMessage(errorMsg);
+      const auto failedPages = sizeMix.totalPages - out.numPages();
       freeNonContiguous(out);
       numAllocated_.fetch_sub(failedPages);
-      if (reservationCB != nullptr) {
-        reservationCB(AllocationTraits::pageBytes(mix.totalPages), false);
-      }
       return false;
     }
   }
@@ -148,13 +130,14 @@ bool MmapAllocator::allocateNonContiguousWithoutRetry(
     return true;
   }
 
-  VELOX_MEM_LOG(WARNING) << "Could not advise away enough for " << newMapsNeeded
-                         << " pages with total allocation of << "
-                         << mix.totalPages << " pages";
+  const std::string errorMsg = fmt::format(
+      "Could not advise away enough for {} pages for total allocation "
+      "of {} pages",
+      newMapsNeeded,
+      sizeMix.totalPages);
+  VELOX_MEM_LOG(WARNING) << errorMsg;
+  setAllocatorFailureMessage(errorMsg);
   freeNonContiguous(out);
-  if (reservationCB != nullptr) {
-    reservationCB(AllocationTraits::pageBytes(mix.totalPages), false);
-  }
   return false;
 }
 
@@ -172,7 +155,6 @@ bool MmapAllocator::ensureEnoughMappedPages(int32_t newMappedNeeded) {
   // We need to advise away a number of pages or we fail the alloc.
   const auto target = totalMaps - capacity_;
   const auto numAdvised = adviseAway(target);
-  numAdvisedPages_ += numAdvised;
   if (numAdvised >= target) {
     numMapped_.fetch_sub(numAdvised);
     return true;
@@ -182,13 +164,21 @@ bool MmapAllocator::ensureEnoughMappedPages(int32_t newMappedNeeded) {
 }
 
 int64_t MmapAllocator::freeNonContiguous(Allocation& allocation) {
-  const auto numFreed = freeInternal(allocation);
+  const auto numFreed = freeNonContiguousInternal(allocation);
   numAllocated_.fetch_sub(numFreed);
   return AllocationTraits::pageBytes(numFreed);
 }
 
-MachinePageCount MmapAllocator::freeInternal(Allocation& allocation) {
-  MachinePageCount numFreed = 0;
+MachinePageCount MmapAllocator::unmap(MachinePageCount targetPages) {
+  std::lock_guard<std::mutex> l(sizeClassBalanceMutex_);
+  const auto numAdvised = adviseAway(targetPages);
+  numMapped_.fetch_sub(numAdvised);
+  return numAdvised;
+}
+
+MachinePageCount MmapAllocator::freeNonContiguousInternal(
+    Allocation& allocation) {
+  MachinePageCount numFreed{0};
   if (allocation.empty()) {
     return numFreed;
   }
@@ -219,12 +209,10 @@ bool MmapAllocator::allocateContiguousWithoutRetry(
     MachinePageCount numPages,
     Allocation* collateral,
     ContiguousAllocation& allocation,
-    ReservationCallback reservationCB,
     MachinePageCount maxPages) {
   bool result;
   stats_.recordAllocate(AllocationTraits::pageBytes(numPages), 1, [&]() {
-    result = allocateContiguousImpl(
-        numPages, collateral, allocation, reservationCB, maxPages);
+    result = allocateContiguousImpl(numPages, collateral, allocation, maxPages);
   });
   return result;
 }
@@ -233,7 +221,6 @@ bool MmapAllocator::allocateContiguousImpl(
     MachinePageCount numPages,
     Allocation* collateral,
     ContiguousAllocation& allocation,
-    ReservationCallback reservationCB,
     MachinePageCount maxPages) {
   if (maxPages == 0) {
     maxPages = numPages;
@@ -257,7 +244,7 @@ bool MmapAllocator::allocateContiguousImpl(
   // 'allocation' cover the new size, as other threads might grab the
   // transiently free pages.
   if (collateral != nullptr) {
-    numCollateralPages = freeInternal(*collateral);
+    numCollateralPages = freeNonContiguousInternal(*collateral);
   }
   const auto numLargeCollateralPages = allocation.numPages();
   if (numLargeCollateralPages > 0) {
@@ -275,34 +262,12 @@ bool MmapAllocator::allocateContiguousImpl(
   }
   const auto totalCollateralPages =
       numCollateralPages + numLargeCollateralPages;
-  const auto totalCollateralBytes =
-      AllocationTraits::pageBytes(totalCollateralPages);
   if (numPages == 0) {
-    if (totalCollateralBytes != 0 && reservationCB != nullptr) {
-      reservationCB(totalCollateralBytes, false);
-    }
     return true;
   }
 
   const auto numCollateralUnmap = numLargeCollateralPages;
   const int64_t newPages = numPages - totalCollateralPages;
-  if (reservationCB != nullptr) {
-    try {
-      reservationCB(AllocationTraits::pageBytes(newPages), true);
-    } catch (const std::exception& e) {
-      VELOX_MEM_LOG_EVERY_MS(WARNING, 1000)
-          << "Exceeded memory reservation limit when reserve " << newPages
-          << " new pages when allocate " << numPages << " pages";
-      numAllocated_ -= totalCollateralPages;
-      numMapped_ -= numCollateralUnmap;
-      numExternalMapped_ -= numCollateralUnmap;
-
-      // We failed to grow by 'newPages. So we record the freeing off the whole
-      // collateral and the unmap of former 'allocation'.
-      reservationCB(totalCollateralBytes, false);
-      std::rethrow_exception(std::current_exception());
-    }
-  }
 
   // Rolls back the counters on failure. 'mappedDecrement' is subtracted from
   // 'numMapped_' on top of other adjustment.
@@ -315,10 +280,6 @@ bool MmapAllocator::allocateContiguousImpl(
     // were never allocated.
     numExternalMapped_ -= numPages;
     numMapped_ -= numCollateralUnmap + mappedDecrement;
-
-    if (reservationCB != nullptr) {
-      reservationCB(AllocationTraits::pageBytes(numPages), false);
-    }
   };
 
   numExternalMapped_ += numPages - numCollateralUnmap;
@@ -329,10 +290,15 @@ bool MmapAllocator::allocateContiguousImpl(
   if (newPages > 0 &&
       (numAllocated > capacity_ ||
        testingHasInjectedFailure(InjectedFailure::kCap))) {
-    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000)
-        << "Exceeded memory allocator limit when allocate " << newPages
-        << " new pages for total allocation of " << numPages
-        << " pages, the memory allocator capacity is " << capacity_ << " pages";
+    const std::string errorMsg = fmt::format(
+        "Exceeded memory allocator limit when allocating {} new pages for "
+        "total allocation of {} pages, the memory allocator capacity is"
+        " {} pages",
+        newPages,
+        numPages,
+        capacity_);
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
     rollbackAllocation(0);
     return false;
   }
@@ -341,9 +307,13 @@ bool MmapAllocator::allocateContiguousImpl(
   const int64_t numToMap = numPages - numCollateralUnmap;
   if (numToMap > 0) {
     if (!ensureEnoughMappedPages(numToMap)) {
-      VELOX_MEM_LOG(WARNING)
-          << "Could not advise away enough for " << numToMap
-          << " pages for total allocation of " << numPages << " pages";
+      const std::string errorMsg = fmt::format(
+          "Could not advise away enough for {} pages for total allocation "
+          "of {} pages",
+          numToMap,
+          numPages);
+      VELOX_MEM_LOG(WARNING) << errorMsg;
+      setAllocatorFailureMessage(errorMsg);
       rollbackAllocation(0);
       return false;
     }
@@ -369,11 +339,15 @@ bool MmapAllocator::allocateContiguousImpl(
           0);
     }
   }
-  // TODO: add handling of MAP_FAILED.
-  if (data == nullptr) {
-    VELOX_MEM_LOG(ERROR) << "Mmap failed with " << numPages
-                         << " pages, use MmapArena "
-                         << (useMmapArena_ ? "true" : "false");
+  if (data == nullptr || data == MAP_FAILED) {
+    const std::string errorMsg = fmt::format(
+        "Mmap failed with {} pages use MmapArena {}, errno {}, Mmap Allocator: {}",
+        numPages,
+        (useMmapArena_ ? "true" : "false"),
+        folly::errnoStr(errno),
+        toString());
+    VELOX_MEM_LOG(ERROR) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
     // If the mmap failed, we have unmapped former 'allocation' and the extra to
     // be mapped.
     rollbackAllocation(numToMap);
@@ -414,38 +388,33 @@ void MmapAllocator::freeContiguousImpl(ContiguousAllocation& allocation) {
 
 bool MmapAllocator::growContiguousWithoutRetry(
     MachinePageCount increment,
-    ContiguousAllocation& allocation,
-    ReservationCallback reservationCB) {
-  VELOX_CHECK_LE(
-      allocation.size() + increment * AllocationTraits::kPageSize,
-      allocation.maxSize());
-  if (reservationCB != nullptr) {
-    // May throw. If does, there is nothing to revert.
-    reservationCB(AllocationTraits::pageBytes(increment), true);
-  }
+    ContiguousAllocation& allocation) {
   auto numAllocated = numAllocated_.fetch_add(increment) + increment;
   if (numAllocated > capacity_ ||
       testingHasInjectedFailure(InjectedFailure::kCap)) {
-    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000)
-        << "Exceeded memory allocator limit when adding " << increment
-        << " new pages for total allocation of " << allocation.numPages()
-        << " pages, the memory allocator capacity is " << capacity_ << " pages";
+    const std::string errorMsg = fmt::format(
+        "Exceeded memory allocator limit when allocating {} new pages for "
+        "total allocation of {} pages, the memory allocator capacity is"
+        " {} pages",
+        increment,
+        allocation.numPages(),
+        capacity_);
+    VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
     numAllocated_ -= increment;
-    if (reservationCB != nullptr) {
-      reservationCB(AllocationTraits::pageBytes(increment), false);
-    }
     return false;
   }
 
   // Check if need to advise away
-  if (!ensureEnoughMappedPages(increment) ||
-      testingHasInjectedFailure(InjectedFailure::kMmap)) {
-    VELOX_MEM_LOG(WARNING) << "Could not advise away enough for " << increment
-                           << " pages for growing allocation of "
-                           << allocation.numPages() << " pages";
-    if (reservationCB != nullptr) {
-      reservationCB(AllocationTraits::pageBytes(increment), false);
-    }
+  if (testingHasInjectedFailure(InjectedFailure::kMmap) ||
+      !ensureEnoughMappedPages(increment)) {
+    const std::string errorMsg = fmt::format(
+        "Could not advise away enough for {} pages for growing allocation "
+        "of {} pages",
+        increment,
+        allocation.numPages());
+    VELOX_MEM_LOG(WARNING) << errorMsg;
+    setAllocatorFailureMessage(errorMsg);
     numAllocated_.fetch_sub(increment);
     return false;
   }
@@ -470,7 +439,7 @@ void* MmapAllocator::allocateBytesWithoutRetry(
       VELOX_MEM_LOG(ERROR) << "Failed to allocateBytes " << bytes
                            << " bytes with " << alignment << " alignment";
     } else {
-      numMallocBytes_.fetch_add(bytes);
+      numMallocBytes_ += bytes;
     }
     return result;
   }
@@ -478,8 +447,8 @@ void* MmapAllocator::allocateBytesWithoutRetry(
   if (bytes <= AllocationTraits::pageBytes(sizeClassSizes_.back())) {
     Allocation allocation;
     const auto numPages = roundUpToSizeClassSize(bytes, sizeClassSizes_);
-    if (!allocateNonContiguousWithoutRetry(
-            numPages, allocation, nullptr, numPages)) {
+    const SizeMix mix = allocationSize(numPages, numPages);
+    if (!allocateNonContiguousWithoutRetry(mix, allocation)) {
       return nullptr;
     }
     auto run = allocation.runAt(0);
@@ -492,8 +461,7 @@ void* MmapAllocator::allocateBytesWithoutRetry(
   }
 
   ContiguousAllocation allocation;
-  auto numPages = bits::roundUp(bytes, AllocationTraits::kPageSize) /
-      AllocationTraits::kPageSize;
+  auto numPages = AllocationTraits::numPages(bytes);
   if (!allocateContiguousWithoutRetry(numPages, nullptr, allocation)) {
     return nullptr;
   }
@@ -506,7 +474,7 @@ void* MmapAllocator::allocateBytesWithoutRetry(
 void MmapAllocator::freeBytes(void* p, uint64_t bytes) noexcept {
   if (useMalloc(bytes)) {
     ::free(p); // NOLINT
-    numMallocBytes_.fetch_sub(bytes);
+    numMallocBytes_ -= bytes;
     return;
   }
 
@@ -537,6 +505,7 @@ MachinePageCount MmapAllocator::adviseAway(MachinePageCount target) {
       break;
     }
   }
+  numAdvisedPages_ += numAway;
   return numAway;
 }
 
@@ -625,20 +594,23 @@ std::string MmapAllocator::SizeClass::toString() const {
   int count = 0;
   int mappedCount = 0;
   int mappedFreeCount = 0;
-  for (int i = 0; i < pageBitmapSize_; ++i) {
-    count += __builtin_popcountll(pageAllocated_[i]);
-    mappedCount += __builtin_popcountll(pageMapped_[i]);
-    mappedFreeCount +=
-        __builtin_popcountll(~pageAllocated_[i] & pageMapped_[i]);
-  }
-  auto mb = (AllocationTraits::pageBytes(count * unitSize_)) >> 20;
-  out << "[size " << unitSize_ << ": " << count << "(" << mb << "MB) allocated "
-      << mappedCount << " mapped";
-  if (mappedFreeCount != numMappedFreePages_) {
-    out << "Mismatched count of mapped free pages "
-        << ". Actual= " << mappedFreeCount
-        << " vs recorded= " << numMappedFreePages_
-        << ". Total mapped=" << mappedCount;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    for (int i = 0; i < pageBitmapSize_; ++i) {
+      count += __builtin_popcountll(pageAllocated_[i]);
+      mappedCount += __builtin_popcountll(pageMapped_[i]);
+      mappedFreeCount +=
+          __builtin_popcountll(~pageAllocated_[i] & pageMapped_[i]);
+    }
+    auto mb = (AllocationTraits::pageBytes(count * unitSize_)) >> 20;
+    out << "[size " << unitSize_ << ": " << count << "(" << mb
+        << "MB) allocated " << mappedCount << " mapped";
+    if (mappedFreeCount != numMappedFreePages_) {
+      out << "Mismatched count of mapped free pages "
+          << ". Actual= " << mappedFreeCount
+          << " vs recorded= " << numMappedFreePages_
+          << ". Total mapped=" << mappedCount;
+    }
   }
   out << "]";
   return out.str();
@@ -909,10 +881,10 @@ MachinePageCount MmapAllocator::SizeClass::free(Allocation& allocation) {
     const int firstBit =
         (runAddress - address_) / (AllocationTraits::kPageSize * unitSize_);
     for (auto page = firstBit; page < firstBit + numPages; ++page) {
-      if (!bits::isBitSet(pageAllocated_.data(), page)) {
-        // TODO: change this to a velox failure to catch the bug.
+      if (FOLLY_UNLIKELY(!bits::isBitSet(pageAllocated_.data(), page))) {
         VELOX_MEM_LOG(ERROR)
             << "Double free: page = " << page << " sizeclass = " << unitSize_;
+        RECORD_METRIC_VALUE(kMetricMemoryAllocatorDoubleFreeCount);
         continue;
       }
       if (bits::isBitSet(pageMapped_.data(), page)) {
@@ -985,8 +957,13 @@ bool MmapAllocator::useMalloc(uint64_t bytes) {
 
 std::string MmapAllocator::toString() const {
   std::stringstream out;
-  out << "Memory Allocator[" << kindString(kind_) << " capacity "
-      << ((capacity_ == kMaxMemory) ? "UNLIMITED" : succinctBytes(capacity_))
+  out << "Memory Allocator[" << kindString(kind_) << " total capacity "
+      << ((capacity_ == kMaxMemory) ? "UNLIMITED" : succinctBytes(capacity()))
+      << " free capacity "
+      << ((capacity_ == kMaxMemory)
+              ? "UNLIMITED"
+              : succinctBytes(
+                    capacity() - AllocationTraits::pageBytes(numAllocated())))
       << " allocated pages " << numAllocated_ << " mapped pages " << numMapped_
       << " external mapped pages " << numExternalMapped_ << std::endl;
   for (auto& sizeClass : sizeClasses_) {
diff --git a/velox/common/memory/MmapAllocator.h b/velox/common/memory/MmapAllocator.h
index 40e9ca35cb544..fd17ee8fa765b 100644
--- a/velox/common/memory/MmapAllocator.h
+++ b/velox/common/memory/MmapAllocator.h
@@ -24,8 +24,11 @@
 #include <mutex>
 #include <unordered_set>
 
+#include <folly/ThreadCachedInt.h>
+
 #include "velox/common/base/SimdUtil.h"
 #include "velox/common/memory/MemoryAllocator.h"
+#include "velox/common/memory/MemoryPool.h"
 #include "velox/common/memory/MmapArena.h"
 
 namespace facebook::velox::memory {
@@ -50,7 +53,9 @@ class MmapAllocator : public MemoryAllocator {
  public:
   struct Options {
     ///  Capacity in bytes, default unlimited.
-    uint64_t capacity = kDefaultCapacityBytes;
+    uint64_t capacity{kMaxMemory};
+
+    int32_t largestSizeClass{256};
 
     /// If set true, allocations larger than largest size class size will be
     /// delegated to ManagedMmapArena. Otherwise a system mmap call will be
@@ -102,13 +107,14 @@ class MmapAllocator : public MemoryAllocator {
 
   bool growContiguousWithoutRetry(
       MachinePageCount increment,
-      ContiguousAllocation& allocation,
-      ReservationCallback reservationCB = nullptr) override;
+      ContiguousAllocation& allocation) override;
 
   void freeContiguous(ContiguousAllocation& allocation) override;
 
   int64_t freeNonContiguous(Allocation& allocation) override;
 
+  MachinePageCount unmap(MachinePageCount targetPages) override;
+
   void freeBytes(void* p, uint64_t bytes) noexcept override;
 
   /// Checks internal consistency of allocation data structures. Returns true if
@@ -128,7 +134,7 @@ class MmapAllocator : public MemoryAllocator {
   }
 
   size_t totalUsedBytes() const override {
-    return numMallocBytes_ + AllocationTraits::pageBytes(numAllocated_);
+    return numMallocBytes() + AllocationTraits::pageBytes(numAllocated_);
   }
 
   MachinePageCount numAllocated() const override {
@@ -144,7 +150,7 @@ class MmapAllocator : public MemoryAllocator {
   }
 
   uint64_t numMallocBytes() const {
-    return numMallocBytes_;
+    return numMallocBytes_.readFull();
   }
 
   Stats stats() const override {
@@ -275,7 +281,7 @@ class MmapAllocator : public MemoryAllocator {
     const int32_t pageBitmapSize_;
 
     // Serializes access to all data members and private methods.
-    std::mutex mutex_;
+    mutable std::mutex mutex_;
 
     // Start of address range.
     uint8_t* address_;
@@ -313,23 +319,19 @@ class MmapAllocator : public MemoryAllocator {
   };
 
   bool allocateNonContiguousWithoutRetry(
-      MachinePageCount numPages,
-      Allocation& out,
-      ReservationCallback reservationCB = nullptr,
-      MachinePageCount minSizeClass = 0) override;
+      const SizeMix& sizeMix,
+      Allocation& out) override;
 
   bool allocateContiguousWithoutRetry(
       MachinePageCount numPages,
       Allocation* collateral,
       ContiguousAllocation& allocation,
-      ReservationCallback reservationCB = nullptr,
       MachinePageCount maxPages = 0) override;
 
   bool allocateContiguousImpl(
       MachinePageCount numPages,
       Allocation* collateral,
       ContiguousAllocation& allocation,
-      ReservationCallback reservationCB,
       MachinePageCount maxPages);
 
   void freeContiguousImpl(ContiguousAllocation& allocation);
@@ -360,7 +362,7 @@ class MmapAllocator : public MemoryAllocator {
 
   // Frees 'allocation and returns the number of freed pages. Does not
   // update 'numAllocated'.
-  MachinePageCount freeInternal(Allocation& allocation);
+  MachinePageCount freeNonContiguousInternal(Allocation& allocation);
 
   void markAllMapped(const Allocation& allocation);
 
@@ -412,7 +414,7 @@ class MmapAllocator : public MemoryAllocator {
   std::atomic<uint64_t> numAllocations_ = 0;
   std::atomic<uint64_t> numAllocatedPages_ = 0;
   std::atomic<uint64_t> numAdvisedPages_ = 0;
-  std::atomic<uint64_t> numMallocBytes_ = 0;
+  folly::ThreadCachedInt<int64_t, MmapAllocator> numMallocBytes_;
 
   // Allocations that are larger than largest size classes will be delegated to
   // ManagedMmapArenas, to avoid calling mmap on every allocation.
diff --git a/velox/common/memory/MmapArena.cpp b/velox/common/memory/MmapArena.cpp
index 9511f1ea14453..d72559972cac3 100644
--- a/velox/common/memory/MmapArena.cpp
+++ b/velox/common/memory/MmapArena.cpp
@@ -46,7 +46,7 @@ MmapArena::MmapArena(size_t capacityBytes) : byteSize_(capacityBytes) {
         capacityBytes);
   }
   address_ = reinterpret_cast<uint8_t*>(ptr);
-  addFreeBlock(reinterpret_cast<uint64_t>(address_), byteSize_);
+  addFreeBlock(reinterpret_cast<uintptr_t>(address_), byteSize_);
   freeBytes_ = byteSize_;
 }
 
@@ -60,7 +60,7 @@ void* MmapArena::allocate(uint64_t bytes) {
   }
   bytes = roundBytes(bytes);
 
-  // First match in the list that can give this many bytes
+  // First match in the list that can give this many bytes.
   auto lookupItr = freeLookup_.lower_bound(bytes);
   if (lookupItr == freeLookup_.end()) {
     VELOX_MEM_LOG_EVERY_MS(WARNING, 1000)
@@ -71,8 +71,8 @@ void* MmapArena::allocate(uint64_t bytes) {
   }
 
   freeBytes_ -= bytes;
-  auto address = *(lookupItr->second.begin());
   auto curFreeBytes = lookupItr->first;
+  auto address = *(lookupItr->second.begin());
   void* result = reinterpret_cast<void*>(address);
   if (curFreeBytes == bytes) {
     removeFreeBlock(address, curFreeBytes);
@@ -92,10 +92,10 @@ void MmapArena::free(void* address, uint64_t bytes) {
   ::madvise(address, bytes, MADV_DONTNEED);
   freeBytes_ += bytes;
 
-  const auto curAddr = reinterpret_cast<uint64_t>(address);
+  const auto curAddr = reinterpret_cast<uintptr_t>(address);
   auto curIter = addFreeBlock(curAddr, bytes);
   auto prevIter = freeList_.end();
-  uint64_t prevAddr;
+  uintptr_t prevAddr;
   uint64_t prevBytes;
   bool mergePrev = false;
   if (curIter != freeList_.begin()) {
@@ -106,26 +106,28 @@ void MmapArena::free(void* address, uint64_t bytes) {
     VELOX_CHECK_LE(
         prevEndAddr,
         curAddr,
-        "New free node (addr:{} size:{}) overlaps with previous free node (addr:{} size:{}) in free list",
+        "New free block (addr:{} size:{}) overlaps with previous free block "
+        "(addr:{} size:{}) in free list",
         curAddr,
         bytes,
         prevAddr,
         prevBytes);
-    mergePrev = prevEndAddr == curAddr;
+    mergePrev = (prevEndAddr == curAddr);
   }
 
-  auto nextItr = std::next(curIter);
-  uint64_t nextAddr;
+  auto nextIter = std::next(curIter);
+  uintptr_t nextAddr;
   uint64_t nextBytes;
   bool mergeNext = false;
-  if (nextItr != freeList_.end()) {
-    nextAddr = nextItr->first;
-    nextBytes = nextItr->second;
+  if (nextIter != freeList_.end()) {
+    nextAddr = nextIter->first;
+    nextBytes = nextIter->second;
     auto curEndAddr = curAddr + bytes;
     VELOX_CHECK_LE(
         curEndAddr,
         nextAddr,
-        "New free node (addr:{} size:{}) overlaps with next free node (addr:{} size:{}) in free list",
+        "New free block (addr:{} size:{}) overlaps with next free block "
+        "(addr:{} size:{}) in free list",
         curAddr,
         bytes,
         nextAddr,
@@ -142,38 +144,39 @@ void MmapArena::free(void* address, uint64_t bytes) {
     removeFromLookup(prevAddr, prevBytes);
     auto newFreeSize = curAddr - prevAddr + bytes;
     if (mergeNext) {
-      removeFreeBlock(nextItr);
+      removeFreeBlock(nextIter);
       newFreeSize = nextAddr - prevAddr + nextBytes;
     }
-    freeList_[prevIter->first] = newFreeSize;
+    freeList_[prevAddr] = newFreeSize;
     freeLookup_[newFreeSize].emplace(prevAddr);
     return;
   }
 
   if (mergeNext) {
     VELOX_DCHECK(!mergePrev);
-    removeFreeBlock(nextItr);
+    removeFreeBlock(nextIter);
     removeFromLookup(curAddr, bytes);
     const auto newFreeSize = nextAddr - curAddr + nextBytes;
-    freeList_[curIter->first] = newFreeSize;
+    freeList_[curAddr] = newFreeSize;
     freeLookup_[newFreeSize].emplace(curAddr);
   }
 }
 
-void MmapArena::removeFromLookup(uint64_t addr, uint64_t bytes) {
+void MmapArena::removeFromLookup(uintptr_t addr, uint64_t bytes) {
   freeLookup_[bytes].erase(addr);
   if (freeLookup_[bytes].empty()) {
     freeLookup_.erase(bytes);
   }
 }
 
-std::map<uint64_t, uint64_t>::iterator MmapArena::addFreeBlock(
-    uint64_t address,
+std::map<uintptr_t, uint64_t>::iterator MmapArena::addFreeBlock(
+    uintptr_t address,
     uint64_t bytes) {
   auto insertResult = freeList_.emplace(address, bytes);
   VELOX_CHECK(
       insertResult.second,
-      "Trying to free a memory space that is already freed. Already in free list address {} size {}. Attempted to free address {} size {}",
+      "Trying to free a memory space that is already freed. Already in free "
+      "list address {} size {}. Attempted to free address {} size {}",
       address,
       freeList_[address],
       address,
@@ -182,26 +185,24 @@ std::map<uint64_t, uint64_t>::iterator MmapArena::addFreeBlock(
   return insertResult.first;
 }
 
-void MmapArena::removeFreeBlock(uint64_t addr, uint64_t bytes) {
+void MmapArena::removeFreeBlock(uintptr_t addr, uint64_t bytes) {
   freeList_.erase(addr);
   removeFromLookup(addr, bytes);
 }
 
-void MmapArena::removeFreeBlock(std::map<uint64_t, uint64_t>::iterator& iter) {
+void MmapArena::removeFreeBlock(std::map<uintptr_t, uint64_t>::iterator& iter) {
   removeFromLookup(iter->first, iter->second);
   freeList_.erase(iter);
 }
 
 bool MmapArena::checkConsistency() const {
   uint64_t numErrors = 0;
-  uint64_t bytes = 0;
-  auto arenaEndAddress = reinterpret_cast<uint64_t>(address_) + byteSize_;
+  auto arenaEndAddress = reinterpret_cast<uintptr_t>(address_) + byteSize_;
   auto iter = freeList_.begin();
   auto end = freeList_.end();
-  uint8_t* current = reinterpret_cast<uint8_t*>(address_);
   int64_t freeListTotalBytes = 0;
   while (iter != end) {
-    // Lookup list should contain the address
+    // Lookup list should contain the address.
     auto freeLookupIter = freeLookup_.find(iter->second);
     if (freeLookupIter == freeLookup_.end() ||
         freeLookupIter->second.find(iter->first) ==
@@ -213,7 +214,7 @@ bool MmapArena::checkConsistency() const {
       numErrors++;
     }
 
-    // Verify current free block end
+    // Verify current free block end.
     auto blockEndAddress = iter->first + iter->second;
     if (blockEndAddress > arenaEndAddress) {
       LOG(WARNING)
@@ -223,7 +224,7 @@ bool MmapArena::checkConsistency() const {
       numErrors++;
     }
 
-    // Verify next free block not overlapping
+    // Verify next free block not overlapping.
     auto next = std::next(iter);
     if (next != end && blockEndAddress > next->first) {
       LOG(WARNING)
@@ -238,7 +239,7 @@ bool MmapArena::checkConsistency() const {
     iter++;
   }
 
-  // Check consistency of lookup list
+  // Check consistency of lookup list.
   int64_t freeLookupTotalBytes = 0;
   for (auto iter = freeLookup_.begin(); iter != freeLookup_.end(); iter++) {
     if (iter->second.empty()) {
@@ -251,7 +252,7 @@ bool MmapArena::checkConsistency() const {
     freeLookupTotalBytes += (iter->first * iter->second.size());
   }
 
-  // Check consistency of freeList_ and freeLookup_ in terms of bytes
+  // Check consistency of freeList_ and freeLookup_ in terms of bytes.
   if (freeListTotalBytes != freeLookupTotalBytes ||
       freeListTotalBytes != freeBytes_) {
     LOG(WARNING)
@@ -279,7 +280,7 @@ std::string MmapArena::toString() const {
 ManagedMmapArenas::ManagedMmapArenas(uint64_t singleArenaCapacity)
     : singleArenaCapacity_(singleArenaCapacity) {
   auto arena = std::make_shared<MmapArena>(singleArenaCapacity);
-  arenas_.emplace(reinterpret_cast<uint64_t>(arena->address()), arena);
+  arenas_.emplace(reinterpret_cast<uintptr_t>(arena->address()), arena);
   currentArena_ = arena;
 }
 
@@ -293,14 +294,14 @@ void* ManagedMmapArenas::allocate(uint64_t bytes) {
   // it ever fails again then it means requested bytes is larger than a single
   // MmapArena's capacity. No further attempts will happen.
   auto newArena = std::make_shared<MmapArena>(singleArenaCapacity_);
-  arenas_.emplace(reinterpret_cast<uint64_t>(newArena->address()), newArena);
+  arenas_.emplace(reinterpret_cast<uintptr_t>(newArena->address()), newArena);
   currentArena_ = newArena;
   return currentArena_->allocate(bytes);
 }
 
 void ManagedMmapArenas::free(void* address, uint64_t bytes) {
   VELOX_CHECK(!arenas_.empty());
-  const uint64_t addressU64 = reinterpret_cast<uint64_t>(address);
+  const auto addressU64 = reinterpret_cast<uintptr_t>(address);
   auto iter = arenas_.lower_bound(addressU64);
   if (iter == arenas_.end() || iter->first != addressU64) {
     VELOX_CHECK(iter != arenas_.begin());
diff --git a/velox/common/memory/MmapArena.h b/velox/common/memory/MmapArena.h
index c084509e2a6fa..c1132252d6c18 100644
--- a/velox/common/memory/MmapArena.h
+++ b/velox/common/memory/MmapArena.h
@@ -36,11 +36,12 @@ class MmapArena {
   /// MmapArena capacity should be multiple of kMinGrainSizeBytes.
   static constexpr uint64_t kMinGrainSizeBytes = 1024 * 1024; // 1M
 
-  MmapArena(size_t capacityBytes);
+  explicit MmapArena(size_t capacityBytes);
   ~MmapArena();
 
   void* allocate(uint64_t bytes);
   void free(void* address, uint64_t bytes);
+
   void* address() const {
     return reinterpret_cast<void*>(address_);
   }
@@ -49,11 +50,11 @@ class MmapArena {
     return byteSize_;
   }
 
-  const std::map<uint64_t, uint64_t>& freeList() const {
+  const std::map<uintptr_t, uint64_t>& freeList() const {
     return freeList_;
   }
 
-  const std::map<uint64_t, std::unordered_set<uint64_t>>& freeLookup() const {
+  const std::map<uint64_t, std::unordered_set<uintptr_t>>& freeLookup() const {
     return freeLookup_;
   }
 
@@ -66,7 +67,7 @@ class MmapArena {
   }
 
   /// Checks internal consistency of this MmapArena. Returns true if OK. May
-  /// return false if there are concurrent alocations and frees during the
+  /// return false if there are concurrent allocations and frees during the
   /// consistency check. This is a false positive but not dangerous. This is for
   /// test only
   bool checkConsistency() const;
@@ -91,15 +92,15 @@ class MmapArena {
   // Rounds up size to the next power of 2.
   static uint64_t roundBytes(uint64_t bytes);
 
-  std::map<uint64_t, uint64_t>::iterator addFreeBlock(
-      uint64_t addr,
+  std::map<uintptr_t, uint64_t>::iterator addFreeBlock(
+      uintptr_t addr,
       uint64_t bytes);
 
-  void removeFromLookup(uint64_t addr, uint64_t bytes);
+  void removeFromLookup(uintptr_t addr, uint64_t bytes);
 
-  void removeFreeBlock(uint64_t addr, uint64_t bytes);
+  void removeFreeBlock(uintptr_t addr, uint64_t bytes);
 
-  void removeFreeBlock(std::map<uint64_t, uint64_t>::iterator& itr);
+  void removeFreeBlock(std::map<uintptr_t, uint64_t>::iterator& itr);
 
   // Total capacity size of this arena.
   const uint64_t byteSize_;
@@ -111,11 +112,11 @@ class MmapArena {
 
   // A sorted list with each entry mapping from free block address to size of
   // the free block
-  std::map<uint64_t, uint64_t> freeList_;
+  std::map<uintptr_t, uint64_t> freeList_;
 
-  // A sorted look up structure that stores the block size as key and a set of
+  // A sorted look-up structure that stores the block size as key and a set of
   // addresses of that size as value.
-  std::map<uint64_t, std::unordered_set<uint64_t>> freeLookup_;
+  std::map<uint64_t, std::unordered_set<uintptr_t>> freeLookup_;
 };
 
 /// A class that manages a set of MmapArenas. It is able to adapt itself by
@@ -123,13 +124,13 @@ class MmapArena {
 /// fragmentation happens.
 class ManagedMmapArenas {
  public:
-  ManagedMmapArenas(uint64_t singleArenaCapacity);
+  explicit ManagedMmapArenas(uint64_t singleArenaCapacity);
 
   void* allocate(uint64_t bytes);
 
   void free(void* address, uint64_t bytes);
 
-  const std::map<uint64_t, std::shared_ptr<MmapArena>>& arenas() const {
+  const std::map<uintptr_t, std::shared_ptr<MmapArena>>& arenas() const {
     return arenas_;
   }
 
@@ -138,7 +139,7 @@ class ManagedMmapArenas {
   const uint64_t singleArenaCapacity_;
 
   // A sorted list of MmapArena by its initial address
-  std::map<uint64_t, std::shared_ptr<MmapArena>> arenas_;
+  std::map<uintptr_t, std::shared_ptr<MmapArena>> arenas_;
 
   // All allocations should come from this MmapArena. When it is no longer able
   // to handle allocations it will be updated to a newly created MmapArena.
diff --git a/velox/common/memory/SharedArbitrator.cpp b/velox/common/memory/SharedArbitrator.cpp
index 611e9fa65fea6..beaa9b8cfe430 100644
--- a/velox/common/memory/SharedArbitrator.cpp
+++ b/velox/common/memory/SharedArbitrator.cpp
@@ -15,8 +15,12 @@
  */
 
 #include "velox/common/memory/SharedArbitrator.h"
+#include <mutex>
 
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/config/Config.h"
+#include "velox/common/memory/Memory.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/common/time/Timer.h"
 
@@ -24,11 +28,13 @@ using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::memory {
 
+using namespace facebook::velox::memory;
+
 namespace {
 
 // Returns the max capacity to grow of memory 'pool'. The calculation is based
 // on a memory pool's max capacity and its current capacity.
-uint64_t maxGrowBytes(const MemoryPool& pool) {
+uint64_t maxGrowCapacity(const MemoryPool& pool) {
   return pool.maxCapacity() - pool.capacity();
 }
 
@@ -58,69 +64,297 @@ std::string memoryPoolAbortMessage(
   return out.str();
 }
 
+template <typename T>
+T getConfig(
+    const std::unordered_map<std::string, std::string>& configs,
+    const std::string_view& key,
+    const T& defaultValue) {
+  if (configs.count(std::string(key)) > 0) {
+    try {
+      return folly::to<T>(configs.at(std::string(key)));
+    } catch (const std::exception& e) {
+      VELOX_USER_FAIL(
+          "Failed while parsing SharedArbitrator configs: {}", e.what());
+    }
+  }
+  return defaultValue;
+}
 } // namespace
 
-SharedArbitrator::SharedArbitrator(const MemoryArbitrator::Config& config)
-    : MemoryArbitrator(config), freeCapacity_(capacity_) {
+int64_t SharedArbitrator::ExtraConfig::getReservedCapacity(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return config::toCapacity(
+      getConfig<std::string>(
+          configs, kReservedCapacity, std::string(kDefaultReservedCapacity)),
+      config::CapacityUnit::BYTE);
+}
+
+uint64_t SharedArbitrator::ExtraConfig::getMemoryPoolInitialCapacity(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return config::toCapacity(
+      getConfig<std::string>(
+          configs,
+          kMemoryPoolInitialCapacity,
+          std::string(kDefaultMemoryPoolInitialCapacity)),
+      config::CapacityUnit::BYTE);
+}
+
+uint64_t SharedArbitrator::ExtraConfig::getMemoryPoolReservedCapacity(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return config::toCapacity(
+      getConfig<std::string>(
+          configs,
+          kMemoryPoolReservedCapacity,
+          std::string(kDefaultMemoryPoolReservedCapacity)),
+      config::CapacityUnit::BYTE);
+}
+
+uint64_t SharedArbitrator::ExtraConfig::getMemoryPoolTransferCapacity(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return config::toCapacity(
+      getConfig<std::string>(
+          configs,
+          kMemoryPoolTransferCapacity,
+          std::string(kDefaultMemoryPoolTransferCapacity)),
+      config::CapacityUnit::BYTE);
+}
+
+uint64_t SharedArbitrator::ExtraConfig::getMemoryReclaimMaxWaitTimeMs(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(
+             config::toDuration(getConfig<std::string>(
+                 configs,
+                 kMemoryReclaimMaxWaitTime,
+                 std::string(kDefaultMemoryReclaimMaxWaitTime))))
+      .count();
+}
+
+uint64_t SharedArbitrator::ExtraConfig::getMemoryPoolMinFreeCapacity(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return config::toCapacity(
+      getConfig<std::string>(
+          configs,
+          kMemoryPoolMinFreeCapacity,
+          std::string(kDefaultMemoryPoolMinFreeCapacity)),
+      config::CapacityUnit::BYTE);
+}
+
+double SharedArbitrator::ExtraConfig::getMemoryPoolMinFreeCapacityPct(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return getConfig<double>(
+      configs,
+      kMemoryPoolMinFreeCapacityPct,
+      kDefaultMemoryPoolMinFreeCapacityPct);
+}
+
+bool SharedArbitrator::ExtraConfig::getGlobalArbitrationEnabled(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return getConfig<bool>(
+      configs, kGlobalArbitrationEnabled, kDefaultGlobalArbitrationEnabled);
+}
+
+bool SharedArbitrator::ExtraConfig::getCheckUsageLeak(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return getConfig<bool>(configs, kCheckUsageLeak, kDefaultCheckUsageLeak);
+}
+
+uint64_t
+SharedArbitrator::ExtraConfig::getFastExponentialGrowthCapacityLimitBytes(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return config::toCapacity(
+      getConfig<std::string>(
+          configs,
+          kFastExponentialGrowthCapacityLimit,
+          std::string(kDefaultFastExponentialGrowthCapacityLimit)),
+      config::CapacityUnit::BYTE);
+}
+
+double SharedArbitrator::ExtraConfig::getSlowCapacityGrowPct(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return getConfig<double>(
+      configs, kSlowCapacityGrowPct, kDefaultSlowCapacityGrowPct);
+}
+
+SharedArbitrator::SharedArbitrator(const Config& config)
+    : MemoryArbitrator(config),
+      reservedCapacity_(ExtraConfig::getReservedCapacity(config.extraConfigs)),
+      memoryPoolInitialCapacity_(
+          ExtraConfig::getMemoryPoolInitialCapacity(config.extraConfigs)),
+      memoryPoolReservedCapacity_(
+          ExtraConfig::getMemoryPoolReservedCapacity(config.extraConfigs)),
+      memoryPoolTransferCapacity_(
+          ExtraConfig::getMemoryPoolTransferCapacity(config.extraConfigs)),
+      memoryReclaimWaitMs_(
+          ExtraConfig::getMemoryReclaimMaxWaitTimeMs(config.extraConfigs)),
+      globalArbitrationEnabled_(
+          ExtraConfig::getGlobalArbitrationEnabled(config.extraConfigs)),
+      checkUsageLeak_(ExtraConfig::getCheckUsageLeak(config.extraConfigs)),
+      fastExponentialGrowthCapacityLimit_(
+          ExtraConfig::getFastExponentialGrowthCapacityLimitBytes(
+              config.extraConfigs)),
+      slowCapacityGrowPct_(
+          ExtraConfig::getSlowCapacityGrowPct(config.extraConfigs)),
+      memoryPoolMinFreeCapacity_(
+          ExtraConfig::getMemoryPoolMinFreeCapacity(config.extraConfigs)),
+      memoryPoolMinFreeCapacityPct_(
+          ExtraConfig::getMemoryPoolMinFreeCapacityPct(config.extraConfigs)),
+      freeReservedCapacity_(reservedCapacity_),
+      freeNonReservedCapacity_(capacity_ - freeReservedCapacity_) {
   VELOX_CHECK_EQ(kind_, config.kind);
+  VELOX_CHECK_LE(reservedCapacity_, capacity_);
+  VELOX_CHECK_GE(slowCapacityGrowPct_, 0);
+  VELOX_CHECK_GE(memoryPoolMinFreeCapacityPct_, 0);
+  VELOX_CHECK_LE(memoryPoolMinFreeCapacityPct_, 1);
+  VELOX_CHECK_EQ(
+      fastExponentialGrowthCapacityLimit_ == 0,
+      slowCapacityGrowPct_ == 0,
+      "fastExponentialGrowthCapacityLimit_ {} and slowCapacityGrowPct_ {} "
+      "both need to be set (non-zero) at the same time to enable growth capacity "
+      "adjustment.",
+      fastExponentialGrowthCapacityLimit_,
+      slowCapacityGrowPct_);
+  VELOX_CHECK_EQ(
+      memoryPoolMinFreeCapacity_ == 0,
+      memoryPoolMinFreeCapacityPct_ == 0,
+      "memoryPoolMinFreeCapacity_ {} and memoryPoolMinFreeCapacityPct_ {} both "
+      "need to be set (non-zero) at the same time to enable shrink capacity "
+      "adjustment.",
+      memoryPoolMinFreeCapacity_,
+      memoryPoolMinFreeCapacityPct_);
 }
 
 std::string SharedArbitrator::Candidate::toString() const {
   return fmt::format(
-      "CANDIDATE[{} RECLAIMABLE[{}] RECLAIMABLE_BYTES[{}] FREE_BYTES[{}]]",
-      pool->root()->name(),
-      reclaimable,
+      "CANDIDATE[{}] RECLAIMABLE_BYTES[{}] FREE_BYTES[{}]]",
+      pool->name(),
       succinctBytes(reclaimableBytes),
       succinctBytes(freeBytes));
 }
 
-void SharedArbitrator::sortCandidatesByFreeCapacity(
-    std::vector<Candidate>& candidates) const {
+SharedArbitrator::~SharedArbitrator() {
+  VELOX_CHECK(candidates_.empty());
+  if (freeNonReservedCapacity_ + freeReservedCapacity_ != capacity_) {
+    const std::string errMsg = fmt::format(
+        "Unexpected free capacity leak in arbitrator: freeNonReservedCapacity_[{}] + freeReservedCapacity_[{}] != capacity_[{}])\\n{}",
+        freeNonReservedCapacity_,
+        freeReservedCapacity_,
+        capacity_,
+        toString());
+    if (checkUsageLeak_) {
+      VELOX_FAIL(errMsg);
+    } else {
+      VELOX_MEM_LOG(ERROR) << errMsg;
+    }
+  }
+}
+
+void SharedArbitrator::addPool(const std::shared_ptr<MemoryPool>& pool) {
+  VELOX_CHECK_EQ(pool->capacity(), 0);
+  {
+    std::unique_lock guard{poolLock_};
+    VELOX_CHECK_EQ(candidates_.count(pool.get()), 0);
+    candidates_.emplace(pool.get(), pool);
+  }
+
+  std::lock_guard<std::mutex> l(stateLock_);
+  const uint64_t maxBytesToReserve =
+      std::min(maxGrowCapacity(*pool), memoryPoolInitialCapacity_);
+  const uint64_t minBytesToReserve = minGrowCapacity(*pool);
+  const uint64_t reservedBytes =
+      decrementFreeCapacityLocked(maxBytesToReserve, minBytesToReserve);
+  try {
+    checkedGrow(pool.get(), reservedBytes, 0);
+  } catch (const VeloxRuntimeError&) {
+    incrementFreeCapacityLocked(reservedBytes);
+  }
+}
+
+void SharedArbitrator::removePool(MemoryPool* pool) {
+  VELOX_CHECK_EQ(pool->reservedBytes(), 0);
+  shrinkCapacity(pool);
+
+  std::unique_lock guard{poolLock_};
+  const auto ret = candidates_.erase(pool);
+  VELOX_CHECK_EQ(ret, 1);
+}
+
+void SharedArbitrator::getCandidates(
+    ArbitrationOperation* op,
+    bool freeCapacityOnly) {
+  op->candidates.clear();
+
+  std::shared_lock guard{poolLock_};
+  op->candidates.reserve(candidates_.size());
+  for (const auto& candidate : candidates_) {
+    const bool selfCandidate = op->requestPool == candidate.first;
+    std::shared_ptr<MemoryPool> pool = candidate.second.lock();
+    if (pool == nullptr) {
+      VELOX_CHECK(!selfCandidate);
+      continue;
+    }
+    op->candidates.push_back(
+        {pool,
+         freeCapacityOnly ? 0 : reclaimableUsedCapacity(*pool, selfCandidate),
+         reclaimableFreeCapacity(*pool, selfCandidate),
+         pool->reservedBytes()});
+  }
+  VELOX_CHECK(!op->candidates.empty());
+}
+
+void SharedArbitrator::sortCandidatesByReclaimableFreeCapacity(
+    std::vector<Candidate>& candidates) {
   std::sort(
       candidates.begin(),
       candidates.end(),
-      [&](const Candidate& lhs, const Candidate& rhs) {
+      [&](const SharedArbitrator::Candidate& lhs,
+          const SharedArbitrator::Candidate& rhs) {
         return lhs.freeBytes > rhs.freeBytes;
       });
 
   TestValue::adjust(
-      "facebook::velox::memory::SharedArbitrator::sortCandidatesByFreeCapacity",
+      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableFreeCapacity",
       &candidates);
 }
 
-void SharedArbitrator::sortCandidatesByReclaimableMemory(
-    std::vector<Candidate>& candidates) const {
+void SharedArbitrator::sortCandidatesByReclaimableUsedCapacity(
+    std::vector<Candidate>& candidates) {
   std::sort(
       candidates.begin(),
       candidates.end(),
-      [](const Candidate& lhs, const Candidate& rhs) {
-        if (!lhs.reclaimable) {
-          return false;
-        }
-        if (!rhs.reclaimable) {
-          return true;
-        }
+      [](const SharedArbitrator::Candidate& lhs,
+         const SharedArbitrator::Candidate& rhs) {
         return lhs.reclaimableBytes > rhs.reclaimableBytes;
       });
 
   TestValue::adjust(
-      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableMemory",
+      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableUsedCapacity",
       &candidates);
 }
 
+void SharedArbitrator::sortCandidatesByUsage(
+    std::vector<Candidate>& candidates) {
+  std::sort(
+      candidates.begin(),
+      candidates.end(),
+      [](const SharedArbitrator::Candidate& lhs,
+         const SharedArbitrator::Candidate& rhs) {
+        return lhs.reservedBytes > rhs.reservedBytes;
+      });
+}
+
 const SharedArbitrator::Candidate&
 SharedArbitrator::findCandidateWithLargestCapacity(
     MemoryPool* requestor,
     uint64_t targetBytes,
-    const std::vector<Candidate>& candidates) const {
+    const std::vector<SharedArbitrator::Candidate>& candidates) {
   VELOX_CHECK(!candidates.empty());
   int32_t candidateIdx{-1};
-  int64_t maxCapacity{-1};
+  uint64_t maxCapacity{0};
   for (int32_t i = 0; i < candidates.size(); ++i) {
-    const bool isCandidate = candidates[i].pool == requestor;
+    const bool isCandidate = candidates[i].pool.get() == requestor;
     // For capacity comparison, the requestor's capacity should include both its
     // current capacity and the capacity growth.
-    const int64_t capacity =
+    const uint64_t capacity =
         candidates[i].pool->capacity() + (isCandidate ? targetBytes : 0);
     if (i == 0) {
       candidateIdx = 0;
@@ -145,302 +379,621 @@ SharedArbitrator::findCandidateWithLargestCapacity(
   return candidates[candidateIdx];
 }
 
-SharedArbitrator::~SharedArbitrator() {
-  VELOX_CHECK_EQ(freeCapacity_, capacity_, "{}", toString());
+void SharedArbitrator::updateArbitrationRequestStats() {
+  RECORD_METRIC_VALUE(kMetricArbitratorRequestsCount);
+  ++numRequests_;
 }
 
-void SharedArbitrator::reserveMemory(MemoryPool* pool, uint64_t /*unused*/) {
-  const int64_t bytesToReserve =
-      std::min<int64_t>(maxGrowBytes(*pool), memoryPoolInitCapacity_);
-  std::lock_guard<std::mutex> l(mutex_);
-  if (running_) {
-    // NOTE: if there is a running memory arbitration, then we shall skip
-    // reserving the free memory for the newly created memory pool but let it
-    // grow its capacity on-demand later through the memory arbitration.
-    return;
+void SharedArbitrator::updateArbitrationFailureStats() {
+  RECORD_METRIC_VALUE(kMetricArbitratorFailuresCount);
+  ++numFailures_;
+}
+
+int64_t SharedArbitrator::maxReclaimableCapacity(
+    const MemoryPool& pool,
+    bool isSelfReclaim) const {
+  // Checks if a query memory pool has likely finished processing. It is likely
+  // this pool has finished when it has 0 current usage and non-0 past usage. If
+  // there is a high chance this pool finished, then we don't have to respect
+  // the memory pool reserved capacity limit check.
+  //
+  // NOTE: for query system like Prestissimo, it holds a finished query state in
+  // minutes for query stats fetch request from the Presto coordinator.
+  if (isSelfReclaim || (pool.reservedBytes() == 0 && pool.peakBytes() != 0)) {
+    return pool.capacity();
   }
-  const uint64_t reserveBytes = decrementFreeCapacityLocked(bytesToReserve);
-  pool->grow(reserveBytes);
+  return std::max<int64_t>(0, pool.capacity() - memoryPoolReservedCapacity_);
 }
 
-void SharedArbitrator::releaseMemory(MemoryPool* pool) {
-  std::lock_guard<std::mutex> l(mutex_);
-  const uint64_t freedBytes = pool->shrink(0);
-  incrementFreeCapacityLocked(freedBytes);
+int64_t SharedArbitrator::reclaimableFreeCapacity(
+    const MemoryPool& pool,
+    bool isSelfReclaim) const {
+  const auto freeBytes = pool.freeBytes();
+  if (freeBytes == 0) {
+    return 0;
+  }
+  return std::min<int64_t>(
+      isSelfReclaim ? freeBytes : getCapacityShrinkTarget(pool, freeBytes),
+      maxReclaimableCapacity(pool, isSelfReclaim));
+}
+
+int64_t SharedArbitrator::reclaimableUsedCapacity(
+    const MemoryPool& pool,
+    bool isSelfReclaim) const {
+  const auto maxReclaimableBytes = maxReclaimableCapacity(pool, isSelfReclaim);
+  const auto reclaimableBytes = pool.reclaimableBytes();
+  return std::min<int64_t>(maxReclaimableBytes, reclaimableBytes.value_or(0));
+}
+
+int64_t SharedArbitrator::minGrowCapacity(const MemoryPool& pool) const {
+  return std::max<int64_t>(
+      0,
+      std::min<int64_t>(pool.maxCapacity(), memoryPoolReservedCapacity_) -
+          pool.capacity());
+}
+
+uint64_t SharedArbitrator::decrementFreeCapacity(
+    uint64_t maxBytesToReserve,
+    uint64_t minBytesToReserve) {
+  uint64_t reservedBytes{0};
+  {
+    std::lock_guard<std::mutex> l(stateLock_);
+    reservedBytes =
+        decrementFreeCapacityLocked(maxBytesToReserve, minBytesToReserve);
+  }
+  return reservedBytes;
 }
 
-std::vector<SharedArbitrator::Candidate> SharedArbitrator::getCandidateStats(
-    const std::vector<std::shared_ptr<MemoryPool>>& pools) {
-  std::vector<SharedArbitrator::Candidate> candidates;
-  candidates.reserve(pools.size());
-  for (const auto& pool : pools) {
-    uint64_t reclaimableBytes;
-    const bool reclaimable = pool->reclaimableBytes(reclaimableBytes);
-    candidates.push_back(
-        {reclaimable, reclaimableBytes, pool->freeBytes(), pool.get()});
+uint64_t SharedArbitrator::decrementFreeCapacityLocked(
+    uint64_t maxBytesToReserve,
+    uint64_t minBytesToReserve) {
+  uint64_t allocatedBytes =
+      std::min<uint64_t>(freeNonReservedCapacity_, maxBytesToReserve);
+  freeNonReservedCapacity_ -= allocatedBytes;
+  if (allocatedBytes < minBytesToReserve) {
+    const uint64_t reservedBytes = std::min<uint64_t>(
+        minBytesToReserve - allocatedBytes, freeReservedCapacity_);
+    freeReservedCapacity_ -= reservedBytes;
+    allocatedBytes += reservedBytes;
   }
-  return candidates;
+  return allocatedBytes;
 }
 
-bool SharedArbitrator::growMemory(
+uint64_t SharedArbitrator::getCapacityShrinkTarget(
+    const MemoryPool& pool,
+    uint64_t requestBytes) const {
+  VELOX_CHECK_NE(requestBytes, 0);
+  auto targetBytes = requestBytes;
+  if (memoryPoolMinFreeCapacity_ != 0) {
+    const auto minFreeBytes = std::min(
+        static_cast<uint64_t>(pool.capacity() * memoryPoolMinFreeCapacityPct_),
+        memoryPoolMinFreeCapacity_);
+    const auto maxShrinkBytes = std::max<int64_t>(
+        0LL, pool.freeBytes() - static_cast<int64_t>(minFreeBytes));
+    targetBytes = std::min(targetBytes, static_cast<uint64_t>(maxShrinkBytes));
+  }
+  return targetBytes;
+}
+
+uint64_t SharedArbitrator::shrinkCapacity(
     MemoryPool* pool,
-    const std::vector<std::shared_ptr<MemoryPool>>& candidatePools,
-    uint64_t targetBytes) {
-  ScopedArbitration scopedArbitration(pool, this);
-  MemoryPool* requestor = pool->root();
-  if (FOLLY_UNLIKELY(requestor->aborted())) {
-    ++numFailures_;
-    VELOX_MEM_POOL_ABORTED("The requestor has already been aborted");
-  }
-
-  if (FOLLY_UNLIKELY(!ensureCapacity(requestor, targetBytes))) {
-    ++numFailures_;
-    VELOX_MEM_LOG(ERROR) << "Can't grow " << requestor->name()
+    uint64_t requestBytes) {
+  std::lock_guard<std::mutex> l(stateLock_);
+  ++numShrinks_;
+  const uint64_t freedBytes = shrinkPool(
+      pool,
+      requestBytes == 0 ? 0 : getCapacityShrinkTarget(*pool, requestBytes));
+  incrementFreeCapacityLocked(freedBytes);
+  return freedBytes;
+}
+
+uint64_t SharedArbitrator::shrinkCapacity(
+    uint64_t requestBytes,
+    bool allowSpill,
+    bool allowAbort) {
+  incrementGlobalArbitrationCount();
+  const uint64_t targetBytes = requestBytes == 0 ? capacity_ : requestBytes;
+  ArbitrationOperation op(targetBytes);
+  ScopedArbitration scopedArbitration(this, &op);
+
+  std::lock_guard<std::shared_mutex> exclusiveLock(arbitrationLock_);
+  getCandidates(&op);
+
+  uint64_t reclaimedBytes{0};
+  RECORD_METRIC_VALUE(kMetricArbitratorSlowGlobalArbitrationCount);
+
+  if (allowSpill) {
+    uint64_t freedBytes{0};
+    reclaimUsedMemoryFromCandidatesBySpill(&op, freedBytes);
+    reclaimedBytes += freedBytes;
+    if (freedBytes > 0) {
+      incrementFreeCapacity(freedBytes);
+    }
+    if (reclaimedBytes >= op.requestBytes) {
+      return reclaimedBytes;
+    }
+    if (allowAbort) {
+      // Candidate stats may change after spilling.
+      getCandidates(&op);
+    }
+  }
+
+  if (allowAbort) {
+    uint64_t freedBytes{0};
+    reclaimUsedMemoryFromCandidatesByAbort(&op, freedBytes);
+    reclaimedBytes += freedBytes;
+    if (freedBytes > 0) {
+      incrementFreeCapacity(freedBytes);
+    }
+  }
+  return reclaimedBytes;
+}
+
+void SharedArbitrator::testingFreeCapacity(uint64_t capacity) {
+  std::lock_guard<std::mutex> l(stateLock_);
+  incrementFreeCapacityLocked(capacity);
+}
+
+uint64_t SharedArbitrator::testingNumRequests() const {
+  return numRequests_;
+}
+
+uint64_t SharedArbitrator::getCapacityGrowthTarget(
+    const MemoryPool& pool,
+    uint64_t requestBytes) const {
+  if (fastExponentialGrowthCapacityLimit_ == 0 && slowCapacityGrowPct_ == 0) {
+    return std::max(requestBytes, memoryPoolTransferCapacity_);
+  }
+  uint64_t targetBytes{0};
+  const auto capacity = pool.capacity();
+  if (capacity * 2 <= fastExponentialGrowthCapacityLimit_) {
+    targetBytes = capacity;
+  } else {
+    targetBytes = capacity * slowCapacityGrowPct_;
+  }
+  return std::max(
+      std::max(requestBytes, targetBytes), memoryPoolTransferCapacity_);
+}
+
+bool SharedArbitrator::growCapacity(MemoryPool* pool, uint64_t requestBytes) {
+  // NOTE: we shouldn't trigger the recursive memory capacity growth under
+  // memory arbitration context.
+  VELOX_CHECK(!underMemoryArbitration());
+
+  ArbitrationOperation op(
+      pool, requestBytes, getCapacityGrowthTarget(*pool, requestBytes));
+  ScopedArbitration scopedArbitration(this, &op);
+
+  bool needGlobalArbitration{false};
+  if (!runLocalArbitration(&op, needGlobalArbitration)) {
+    return false;
+  }
+  if (!needGlobalArbitration) {
+    return true;
+  }
+  if (!globalArbitrationEnabled_) {
+    return false;
+  }
+  return runGlobalArbitration(&op);
+}
+
+bool SharedArbitrator::runLocalArbitration(
+    ArbitrationOperation* op,
+    bool& needGlobalArbitration) {
+  needGlobalArbitration = false;
+  const std::chrono::steady_clock::time_point localArbitrationStartTime =
+      std::chrono::steady_clock::now();
+  std::shared_lock<std::shared_mutex> sharedLock(arbitrationLock_);
+  TestValue::adjust(
+      "facebook::velox::memory::SharedArbitrator::runLocalArbitration", this);
+  op->localArbitrationLockWaitTimeUs =
+      std::chrono::duration_cast<std::chrono::microseconds>(
+          std::chrono::steady_clock::now() - localArbitrationStartTime)
+          .count();
+
+  checkIfAborted(op);
+
+  if (maybeGrowFromSelf(op)) {
+    return true;
+  }
+
+  if (!ensureCapacity(op)) {
+    updateArbitrationFailureStats();
+    VELOX_MEM_LOG(ERROR) << "Can't grow " << op->requestPool->name()
                          << " capacity to "
-                         << succinctBytes(requestor->capacity() + targetBytes)
+                         << succinctBytes(
+                                op->requestPool->capacity() + op->requestBytes)
                          << " which exceeds its max capacity "
-                         << succinctBytes(requestor->maxCapacity());
+                         << succinctBytes(op->requestPool->maxCapacity())
+                         << ", current capacity "
+                         << succinctBytes(op->requestPool->capacity())
+                         << ", request " << succinctBytes(op->requestBytes);
     return false;
   }
+  VELOX_CHECK(!op->requestPool->aborted());
+
+  if (maybeGrowFromSelf(op)) {
+    return true;
+  }
+
+  uint64_t maxGrowTarget{0};
+  uint64_t minGrowTarget{0};
+  getGrowTargets(op, maxGrowTarget, minGrowTarget);
+
+  uint64_t freedBytes = decrementFreeCapacity(maxGrowTarget, minGrowTarget);
+  auto freeGuard = folly::makeGuard([&]() {
+    // Returns the unused freed memory capacity back to the arbitrator.
+    if (freedBytes > 0) {
+      incrementFreeCapacity(freedBytes);
+    }
+  });
+  if (freedBytes >= op->requestBytes) {
+    checkedGrow(op->requestPool, freedBytes, op->requestBytes);
+    freedBytes = 0;
+    return true;
+  }
+  VELOX_CHECK_LT(freedBytes, maxGrowTarget);
+
+  getCandidates(op, /*freeCapacityOnly=*/true);
+  freedBytes +=
+      reclaimFreeMemoryFromCandidates(op, maxGrowTarget - freedBytes, true);
+  if (freedBytes >= op->requestBytes) {
+    const uint64_t bytesToGrow = std::min(maxGrowTarget, freedBytes);
+    checkedGrow(op->requestPool, bytesToGrow, op->requestBytes);
+    freedBytes -= bytesToGrow;
+    return true;
+  }
+  VELOX_CHECK_LT(freedBytes, maxGrowTarget);
+
+  if (!globalArbitrationEnabled_) {
+    freedBytes += reclaim(op->requestPool, maxGrowTarget - freedBytes, true);
+  }
+  checkIfAborted(op);
+
+  if (freedBytes >= op->requestBytes) {
+    const uint64_t bytesToGrow = std::min(maxGrowTarget, freedBytes);
+    checkedGrow(op->requestPool, bytesToGrow, op->requestBytes);
+    freedBytes -= bytesToGrow;
+    return true;
+  }
+
+  needGlobalArbitration = true;
+  return true;
+}
+
+bool SharedArbitrator::runGlobalArbitration(ArbitrationOperation* op) {
+  incrementGlobalArbitrationCount();
+  const std::chrono::steady_clock::time_point globalArbitrationStartTime =
+      std::chrono::steady_clock::now();
+  std::lock_guard<std::shared_mutex> exclusiveLock(arbitrationLock_);
+  TestValue::adjust(
+      "facebook::velox::memory::SharedArbitrator::runGlobalArbitration", this);
+  op->globalArbitrationLockWaitTimeUs =
+      std::chrono::duration_cast<std::chrono::microseconds>(
+          std::chrono::steady_clock::now() - globalArbitrationStartTime)
+          .count();
+  checkIfAborted(op);
+
+  if (maybeGrowFromSelf(op)) {
+    return true;
+  }
 
-  std::vector<Candidate> candidates;
-  candidates.reserve(candidatePools.size());
-  int numRetries{0};
-  for (;; ++numRetries) {
-    // Get refreshed stats before the memory arbitration retry.
-    candidates = getCandidateStats(candidatePools);
-    if (arbitrateMemory(requestor, candidates, targetBytes)) {
-      ++numSucceeded_;
+  int32_t attempts = 0;
+  for (;; ++attempts) {
+    if (arbitrateMemory(op)) {
       return true;
     }
-    if (numRetries > 0) {
+    if (attempts > 0) {
       break;
     }
-    VELOX_CHECK(!requestor->aborted());
-    if (!handleOOM(requestor, targetBytes, candidates)) {
+    VELOX_CHECK(!op->requestPool->aborted());
+    if (!handleOOM(op)) {
       break;
     }
   }
   VELOX_MEM_LOG(ERROR)
       << "Failed to arbitrate sufficient memory for memory pool "
-      << requestor->name() << ", request " << succinctBytes(targetBytes)
-      << " after " << numRetries
-      << " retries, Arbitrator state: " << toString();
-  ++numFailures_;
+      << op->requestPool->name() << ", request "
+      << succinctBytes(op->requestBytes) << " after " << attempts
+      << " attempts, Arbitrator state: " << toString();
+  updateArbitrationFailureStats();
   return false;
 }
 
-bool SharedArbitrator::checkCapacityGrowth(
-    const MemoryPool& pool,
-    uint64_t targetBytes) const {
-  return (maxGrowBytes(pool) >= targetBytes) &&
-      (capacityAfterGrowth(pool, targetBytes) <= capacity_);
+void SharedArbitrator::getGrowTargets(
+    ArbitrationOperation* op,
+    uint64_t& maxGrowTarget,
+    uint64_t& minGrowTarget) {
+  VELOX_CHECK(op->targetBytes.has_value());
+  maxGrowTarget =
+      std::min(maxGrowCapacity(*op->requestPool), op->targetBytes.value());
+  minGrowTarget = minGrowCapacity(*op->requestPool);
 }
 
-bool SharedArbitrator::ensureCapacity(
-    MemoryPool* requestor,
-    uint64_t targetBytes) {
-  if ((targetBytes > capacity_) || (targetBytes > requestor->maxCapacity())) {
+void SharedArbitrator::checkIfAborted(ArbitrationOperation* op) {
+  if (op->requestPool->aborted()) {
+    updateArbitrationFailureStats();
+    VELOX_MEM_POOL_ABORTED("The requestor pool has been aborted");
+  }
+}
+
+bool SharedArbitrator::maybeGrowFromSelf(ArbitrationOperation* op) {
+  if (op->requestPool->freeBytes() >= op->requestBytes) {
+    if (growPool(op->requestPool, 0, op->requestBytes)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool SharedArbitrator::checkCapacityGrowth(ArbitrationOperation* op) const {
+  return (maxGrowCapacity(*op->requestPool) >= op->requestBytes) &&
+      (capacityAfterGrowth(*op->requestPool, op->requestBytes) <= capacity_);
+}
+
+bool SharedArbitrator::ensureCapacity(ArbitrationOperation* op) {
+  if ((op->requestBytes > capacity_) ||
+      (op->requestBytes > op->requestPool->maxCapacity())) {
     return false;
   }
-  if (checkCapacityGrowth(*requestor, targetBytes)) {
+  if (checkCapacityGrowth(op)) {
     return true;
   }
-  const uint64_t reclaimedBytes = reclaim(requestor, targetBytes);
+
+  const uint64_t reclaimedBytes =
+      reclaim(op->requestPool, op->requestBytes, true);
   // NOTE: return the reclaimed bytes back to the arbitrator and let the memory
   // arbitration process to grow the requestor's memory capacity accordingly.
   incrementFreeCapacity(reclaimedBytes);
   // Check if the requestor has been aborted in reclaim operation above.
-  if (requestor->aborted()) {
-    ++numFailures_;
+  if (op->requestPool->aborted()) {
+    updateArbitrationFailureStats();
     VELOX_MEM_POOL_ABORTED("The requestor pool has been aborted");
   }
-  return checkCapacityGrowth(*requestor, targetBytes);
+  return checkCapacityGrowth(op);
 }
 
-bool SharedArbitrator::handleOOM(
-    MemoryPool* requestor,
-    uint64_t targetBytes,
-    std::vector<Candidate>& candidates) {
-  MemoryPool* victim =
-      findCandidateWithLargestCapacity(requestor, targetBytes, candidates).pool;
-  if (requestor == victim) {
+bool SharedArbitrator::handleOOM(ArbitrationOperation* op) {
+  MemoryPool* victim = findCandidateWithLargestCapacity(
+                           op->requestPool, op->requestBytes, op->candidates)
+                           .pool.get();
+  if (op->requestPool == victim) {
     VELOX_MEM_LOG(ERROR)
-        << "Requestor memory pool " << requestor->name()
+        << "Requestor memory pool " << op->requestPool->name()
         << " is selected as victim memory pool so fail the memory arbitration";
     return false;
   }
   VELOX_MEM_LOG(WARNING) << "Aborting victim memory pool " << victim->name()
                          << " to free up memory for requestor "
-                         << requestor->name();
+                         << op->requestPool->name();
   try {
-    VELOX_MEM_POOL_ABORTED(
-        memoryPoolAbortMessage(victim, requestor, targetBytes));
-  } catch (VeloxRuntimeError& e) {
+    if (victim == op->requestPool) {
+      VELOX_MEM_POOL_CAP_EXCEEDED(
+          memoryPoolAbortMessage(victim, op->requestPool, op->requestBytes));
+    } else {
+      VELOX_MEM_POOL_ABORTED(
+          memoryPoolAbortMessage(victim, op->requestPool, op->requestBytes));
+    }
+  } catch (VeloxRuntimeError&) {
     abort(victim, std::current_exception());
   }
   // Free up all the unused capacity from the aborted memory pool and gives back
   // to the arbitrator.
-  incrementFreeCapacity(victim->shrink());
+  incrementFreeCapacity(shrinkPool(victim, 0));
   return true;
 }
 
-bool SharedArbitrator::arbitrateMemory(
-    MemoryPool* requestor,
-    std::vector<Candidate>& candidates,
-    uint64_t targetBytes) {
-  VELOX_CHECK(!requestor->aborted());
-
-  const uint64_t growTarget = std::min(
-      maxGrowBytes(*requestor),
-      std::max(memoryPoolTransferCapacity_, targetBytes));
-  uint64_t freedBytes = decrementFreeCapacity(growTarget);
-  if (freedBytes >= targetBytes) {
-    requestor->grow(freedBytes);
-    return true;
-  }
-  VELOX_CHECK_LT(freedBytes, growTarget);
+void SharedArbitrator::checkedGrow(
+    MemoryPool* pool,
+    uint64_t growBytes,
+    uint64_t reservationBytes) {
+  const auto ret = growPool(pool, growBytes, reservationBytes);
+  VELOX_CHECK(
+      ret,
+      "Failed to grow pool {} with {} and commit {} used reservation",
+      pool->name(),
+      succinctBytes(growBytes),
+      succinctBytes(reservationBytes));
+}
+
+bool SharedArbitrator::arbitrateMemory(ArbitrationOperation* op) {
+  VELOX_CHECK(!op->requestPool->aborted());
+  uint64_t maxGrowTarget{0};
+  uint64_t minGrowTarget{0};
+  getGrowTargets(op, maxGrowTarget, minGrowTarget);
 
+  uint64_t freedBytes = decrementFreeCapacity(maxGrowTarget, minGrowTarget);
   auto freeGuard = folly::makeGuard([&]() {
     // Returns the unused freed memory capacity back to the arbitrator.
     if (freedBytes > 0) {
       incrementFreeCapacity(freedBytes);
     }
   });
+  if (freedBytes >= op->requestBytes) {
+    checkedGrow(op->requestPool, freedBytes, op->requestBytes);
+    freedBytes = 0;
+    return true;
+  }
+  VELOX_CHECK_LT(freedBytes, maxGrowTarget);
+
+  // Get refreshed stats before the global memory arbitration run.
+  getCandidates(op);
 
   freedBytes +=
-      reclaimFreeMemoryFromCandidates(candidates, growTarget - freedBytes);
-  if (freedBytes >= targetBytes) {
-    const uint64_t bytesToGrow = std::min(growTarget, freedBytes);
-    requestor->grow(bytesToGrow);
+      reclaimFreeMemoryFromCandidates(op, maxGrowTarget - freedBytes, false);
+  if (freedBytes >= op->requestBytes) {
+    const uint64_t bytesToGrow = std::min(maxGrowTarget, freedBytes);
+    checkedGrow(op->requestPool, bytesToGrow, op->requestBytes);
     freedBytes -= bytesToGrow;
     return true;
   }
+  VELOX_CHECK_LT(freedBytes, maxGrowTarget);
 
-  VELOX_CHECK_LT(freedBytes, growTarget);
-  freedBytes += reclaimUsedMemoryFromCandidates(
-      requestor, candidates, growTarget - freedBytes);
-  if (requestor->aborted()) {
-    ++numFailures_;
-    VELOX_MEM_POOL_ABORTED("The requestor pool has been aborted.");
-  }
-
-  VELOX_CHECK(!requestor->aborted());
+  RECORD_METRIC_VALUE(kMetricArbitratorSlowGlobalArbitrationCount);
+  reclaimUsedMemoryFromCandidatesBySpill(op, freedBytes);
+  checkIfAborted(op);
 
-  if (freedBytes < targetBytes) {
+  if (freedBytes < op->requestBytes) {
     VELOX_MEM_LOG(WARNING)
         << "Failed to arbitrate sufficient memory for memory pool "
-        << requestor->name() << ", request " << succinctBytes(targetBytes)
-        << ", only " << succinctBytes(freedBytes)
+        << op->requestPool->name() << ", request "
+        << succinctBytes(op->requestBytes) << ", only "
+        << succinctBytes(freedBytes)
         << " has been freed, Arbitrator state: " << toString();
     return false;
   }
 
-  const uint64_t bytesToGrow = std::min(freedBytes, growTarget);
-  requestor->grow(bytesToGrow);
+  const uint64_t bytesToGrow = std::min(freedBytes, maxGrowTarget);
+  checkedGrow(op->requestPool, bytesToGrow, op->requestBytes);
   freedBytes -= bytesToGrow;
   return true;
 }
 
 uint64_t SharedArbitrator::reclaimFreeMemoryFromCandidates(
-    std::vector<Candidate>& candidates,
-    uint64_t targetBytes) {
-  // Sort candidate memory pools based on their free capacity.
-  sortCandidatesByFreeCapacity(candidates);
-
-  uint64_t freedBytes{0};
-  for (const auto& candidate : candidates) {
-    VELOX_CHECK_LT(freedBytes, targetBytes);
+    ArbitrationOperation* op,
+    uint64_t reclaimTargetBytes,
+    bool isLocalArbitration) {
+  // Sort candidate memory pools based on their reclaimable free capacity.
+  sortCandidatesByReclaimableFreeCapacity(op->candidates);
+
+  std::lock_guard<std::mutex> l(stateLock_);
+  uint64_t reclaimedBytes{0};
+  for (const auto& candidate : op->candidates) {
+    VELOX_CHECK_LT(reclaimedBytes, reclaimTargetBytes);
     if (candidate.freeBytes == 0) {
       break;
     }
-    const int64_t bytesToShrink =
-        std::min<int64_t>(targetBytes - freedBytes, candidate.freeBytes);
-    if (bytesToShrink <= 0) {
+    if (isLocalArbitration && (candidate.pool.get() != op->requestPool) &&
+        isUnderArbitrationLocked(candidate.pool.get())) {
+      // If the reclamation is for local arbitration and the candidate pool is
+      // also under arbitration processing, then we can't reclaim from the
+      // candidate pool as it might cause concurrent changes to the candidate
+      // pool's capacity.
+      continue;
+    }
+    const int64_t bytesToReclaim = std::min<int64_t>(
+        reclaimTargetBytes - reclaimedBytes,
+        reclaimableFreeCapacity(
+            *candidate.pool, candidate.pool.get() == op->requestPool));
+    if (bytesToReclaim <= 0) {
+      continue;
+    }
+    reclaimedBytes += shrinkPool(candidate.pool.get(), bytesToReclaim);
+    if (reclaimedBytes >= reclaimTargetBytes) {
       break;
     }
-    freedBytes += candidate.pool->shrink(bytesToShrink);
-    if (freedBytes >= targetBytes) {
+  }
+  reclaimedFreeBytes_ += reclaimedBytes;
+  return reclaimedBytes;
+}
+
+void SharedArbitrator::reclaimUsedMemoryFromCandidatesBySpill(
+    ArbitrationOperation* op,
+    uint64_t& freedBytes) {
+  // Sort candidate memory pools based on their reclaimable used capacity.
+  sortCandidatesByReclaimableUsedCapacity(op->candidates);
+
+  for (const auto& candidate : op->candidates) {
+    VELOX_CHECK_LT(freedBytes, op->requestBytes);
+    if (candidate.reclaimableBytes == 0) {
+      break;
+    }
+    freedBytes +=
+        reclaim(candidate.pool.get(), op->requestBytes - freedBytes, false);
+    if ((freedBytes >= op->requestBytes) ||
+        (op->requestPool != nullptr && op->requestPool->aborted())) {
       break;
     }
   }
-  numShrunkBytes_ += freedBytes;
-  return freedBytes;
 }
 
-uint64_t SharedArbitrator::reclaimUsedMemoryFromCandidates(
-    MemoryPool* requestor,
-    std::vector<Candidate>& candidates,
-    uint64_t targetBytes) {
-  // Sort candidate memory pools based on their reclaimable memory.
-  sortCandidatesByReclaimableMemory(candidates);
-
-  int64_t freedBytes{0};
-  for (const auto& candidate : candidates) {
-    VELOX_CHECK_LT(freedBytes, targetBytes);
-    if (!candidate.reclaimable || candidate.reclaimableBytes == 0) {
+void SharedArbitrator::reclaimUsedMemoryFromCandidatesByAbort(
+    ArbitrationOperation* op,
+    uint64_t& freedBytes) {
+  sortCandidatesByUsage(op->candidates);
+
+  for (const auto& candidate : op->candidates) {
+    VELOX_CHECK_LT(freedBytes, op->requestBytes);
+    if (candidate.pool->capacity() == 0) {
       break;
     }
-    const int64_t bytesToReclaim = std::max<int64_t>(
-        targetBytes - freedBytes, memoryPoolTransferCapacity_);
-    VELOX_CHECK_GT(bytesToReclaim, 0);
-    freedBytes += reclaim(candidate.pool, bytesToReclaim);
-    if ((freedBytes >= targetBytes) || requestor->aborted()) {
+    try {
+      VELOX_MEM_POOL_ABORTED(fmt::format(
+          "Memory pool aborted to reclaim used memory, current usage {}, "
+          "memory pool details:\n{}\n{}",
+          succinctBytes(candidate.reservedBytes),
+          candidate.pool->toString(),
+          candidate.pool->treeMemoryUsage()));
+    } catch (VeloxRuntimeError&) {
+      abort(candidate.pool.get(), std::current_exception());
+    }
+    freedBytes += shrinkPool(candidate.pool.get(), 0);
+    if (freedBytes >= op->requestBytes) {
       break;
     }
   }
-  return freedBytes;
 }
 
 uint64_t SharedArbitrator::reclaim(
     MemoryPool* pool,
-    uint64_t targetBytes) noexcept {
+    uint64_t targetBytes,
+    bool isLocalArbitration) noexcept {
+  int64_t bytesToReclaim = std::min<uint64_t>(
+      std::max(targetBytes, memoryPoolTransferCapacity_),
+      maxReclaimableCapacity(*pool, true));
+  if (bytesToReclaim == 0) {
+    return 0;
+  }
   uint64_t reclaimDurationUs{0};
-  uint64_t reclaimedBytes{0};
-  uint64_t freedBytes{0};
+  uint64_t reclaimedUsedBytes{0};
+  uint64_t reclaimedFreeBytes{0};
   MemoryReclaimer::Stats reclaimerStats;
   {
     MicrosecondTimer reclaimTimer(&reclaimDurationUs);
-    const uint64_t oldCapacity = pool->capacity();
     try {
-      freedBytes = pool->shrink(targetBytes);
-      if (freedBytes < targetBytes) {
-        pool->reclaim(targetBytes - freedBytes, reclaimerStats);
+      reclaimedFreeBytes = shrinkPool(pool, bytesToReclaim);
+      bytesToReclaim -= reclaimedFreeBytes;
+      VELOX_CHECK_GE(bytesToReclaim, 0);
+      if (bytesToReclaim > 0) {
+        if (isLocalArbitration) {
+          incrementLocalArbitrationCount();
+        }
+        pool->reclaim(bytesToReclaim, memoryReclaimWaitMs_, reclaimerStats);
       }
     } catch (const std::exception& e) {
       VELOX_MEM_LOG(ERROR) << "Failed to reclaim from memory pool "
-                           << pool->name() << ", aborting it!";
+                           << pool->name() << ", aborting it: " << e.what();
       abort(pool, std::current_exception());
-      // Free up all the free capacity from the aborted pool as the associated
-      // query has failed at this point.
-      pool->shrink();
+      reclaimedUsedBytes = shrinkPool(pool, 0);
     }
-    const uint64_t newCapacity = pool->capacity();
-    VELOX_CHECK_GE(oldCapacity, newCapacity);
-    reclaimedBytes = oldCapacity - newCapacity;
+    reclaimedUsedBytes += shrinkPool(pool, bytesToReclaim);
   }
-  numReclaimedBytes_ += reclaimedBytes - freedBytes;
-  numShrunkBytes_ += freedBytes;
+  reclaimedUsedBytes_ += reclaimedUsedBytes;
+  reclaimedFreeBytes_ += reclaimedFreeBytes;
   reclaimTimeUs_ += reclaimDurationUs;
   numNonReclaimableAttempts_ += reclaimerStats.numNonReclaimableAttempts;
   VELOX_MEM_LOG(INFO) << "Reclaimed from memory pool " << pool->name()
                       << " with target of " << succinctBytes(targetBytes)
-                      << ", actually reclaimed " << succinctBytes(freedBytes)
+                      << ", actually reclaimed "
+                      << succinctBytes(reclaimedFreeBytes)
                       << " free memory and "
-                      << succinctBytes(reclaimedBytes - freedBytes)
-                      << " used memory";
-  return reclaimedBytes;
+                      << succinctBytes(reclaimedUsedBytes)
+                      << " used memory, spent "
+                      << succinctMicros(reclaimDurationUs)
+                      << ", isLocalArbitration: " << isLocalArbitration;
+  return reclaimedUsedBytes + reclaimedFreeBytes;
 }
 
 void SharedArbitrator::abort(
     MemoryPool* pool,
     const std::exception_ptr& error) {
+  RECORD_METRIC_VALUE(kMetricArbitratorAbortedCount);
   ++numAborted_;
   try {
     pool->abort(error);
   } catch (const std::exception& e) {
-    VELOX_MEM_LOG(WARNING) << "Failed to abort memory pool "
-                           << pool->toString();
+    VELOX_MEM_LOG(WARNING) << "Failed to abort memory pool " << pool->toString()
+                           << ", error: " << e.what();
   }
   // NOTE: no matter memory pool abort throws or not, it should have been marked
   // as aborted to prevent any new memory arbitration triggered from the aborted
@@ -448,112 +1001,151 @@ void SharedArbitrator::abort(
   VELOX_CHECK(pool->aborted());
 }
 
-uint64_t SharedArbitrator::decrementFreeCapacity(uint64_t bytes) {
-  std::lock_guard<std::mutex> l(mutex_);
-  return decrementFreeCapacityLocked(bytes);
-}
-
-uint64_t SharedArbitrator::decrementFreeCapacityLocked(uint64_t bytes) {
-  const uint64_t targetBytes = std::min(freeCapacity_, bytes);
-  VELOX_CHECK_LE(targetBytes, freeCapacity_);
-  freeCapacity_ -= targetBytes;
-  return targetBytes;
-}
-
 void SharedArbitrator::incrementFreeCapacity(uint64_t bytes) {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::mutex> l(stateLock_);
   incrementFreeCapacityLocked(bytes);
 }
 
 void SharedArbitrator::incrementFreeCapacityLocked(uint64_t bytes) {
-  freeCapacity_ += bytes;
-  if (FOLLY_UNLIKELY(freeCapacity_ > capacity_)) {
+  incrementFreeReservedCapacityLocked(bytes);
+  freeNonReservedCapacity_ += bytes;
+  if (FOLLY_UNLIKELY(
+          freeNonReservedCapacity_ + freeReservedCapacity_ > capacity_)) {
     VELOX_FAIL(
-        "The free capacity {} is larger than the max capacity {}, {}",
-        succinctBytes(freeCapacity_),
+        "The free capacity {}/{} is larger than the max capacity {}, {}",
+        succinctBytes(freeNonReservedCapacity_),
+        succinctBytes(freeReservedCapacity_),
         succinctBytes(capacity_),
         toStringLocked());
   }
 }
 
+void SharedArbitrator::incrementFreeReservedCapacityLocked(uint64_t& bytes) {
+  VELOX_CHECK_LE(freeReservedCapacity_, reservedCapacity_);
+  const uint64_t freedBytes =
+      std::min(bytes, reservedCapacity_ - freeReservedCapacity_);
+  freeReservedCapacity_ += freedBytes;
+  bytes -= freedBytes;
+}
+
 MemoryArbitrator::Stats SharedArbitrator::stats() const {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::mutex> l(stateLock_);
   return statsLocked();
 }
 
 MemoryArbitrator::Stats SharedArbitrator::statsLocked() const {
   Stats stats;
   stats.numRequests = numRequests_;
-  stats.numSucceeded = numSucceeded_;
   stats.numAborted = numAborted_;
   stats.numFailures = numFailures_;
-  stats.queueTimeUs = queueTimeUs_;
+  stats.queueTimeUs = waitTimeUs_;
   stats.arbitrationTimeUs = arbitrationTimeUs_;
-  stats.numShrunkBytes = numShrunkBytes_;
-  stats.numReclaimedBytes = numReclaimedBytes_;
+  stats.numShrunkBytes = reclaimedFreeBytes_;
+  stats.numReclaimedBytes = reclaimedUsedBytes_;
   stats.maxCapacityBytes = capacity_;
-  stats.freeCapacityBytes = freeCapacity_;
+  stats.freeCapacityBytes = freeNonReservedCapacity_ + freeReservedCapacity_;
+  stats.freeReservedCapacityBytes = freeReservedCapacity_;
   stats.reclaimTimeUs = reclaimTimeUs_;
   stats.numNonReclaimableAttempts = numNonReclaimableAttempts_;
+  stats.numShrinks = numShrinks_;
   return stats;
 }
 
 std::string SharedArbitrator::toString() const {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::mutex> l(stateLock_);
   return toStringLocked();
 }
 
 std::string SharedArbitrator::toStringLocked() const {
   return fmt::format(
-      "ARBITRATOR[{} CAPACITY[{}] {}]",
+      "ARBITRATOR[{} CAPACITY[{}] PENDING[{}] {}]",
       kind_,
       succinctBytes(capacity_),
+      numPending_,
       statsLocked().toString());
 }
 
 SharedArbitrator::ScopedArbitration::ScopedArbitration(
-    MemoryPool* requestor,
-    SharedArbitrator* arbitrator)
-    : requestor_(requestor),
+    SharedArbitrator* arbitrator,
+    ArbitrationOperation* operation)
+    : operation_(operation),
       arbitrator_(arbitrator),
-      startTime_(std::chrono::steady_clock::now()),
-      arbitrationCtx_(*requestor_) {
+      arbitrationCtx_(operation->requestPool),
+      startTime_(std::chrono::steady_clock::now()) {
   VELOX_CHECK_NOT_NULL(arbitrator_);
-  arbitrator_->startArbitration(requestor);
-  if (arbitrator_->arbitrationStateCheckCb_ != nullptr) {
-    arbitrator_->arbitrationStateCheckCb_(*requestor);
+  VELOX_CHECK_NOT_NULL(operation_);
+  if (arbitrator_->arbitrationStateCheckCb_ != nullptr &&
+      operation_->requestPool != nullptr) {
+    arbitrator_->arbitrationStateCheckCb_(*operation_->requestPool);
   }
+  arbitrator_->startArbitration(operation_);
 }
 
 SharedArbitrator::ScopedArbitration::~ScopedArbitration() {
-  requestor_->leaveArbitration();
-  const auto arbitrationTime =
+  arbitrator_->finishArbitration(operation_);
+
+  // Report arbitration operation stats.
+  const auto arbitrationTimeUs =
       std::chrono::duration_cast<std::chrono::microseconds>(
-          std::chrono::steady_clock::now() - startTime_);
-  arbitrator_->arbitrationTimeUs_ += arbitrationTime.count();
-  arbitrator_->finishArbitration();
+          std::chrono::steady_clock::now() - operation_->startTime)
+          .count();
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricArbitratorArbitrationTimeMs, arbitrationTimeUs / 1'000);
+  addThreadLocalRuntimeStat(
+      kMemoryArbitrationWallNanos,
+      RuntimeCounter(arbitrationTimeUs * 1'000, RuntimeCounter::Unit::kNanos));
+  if (operation_->localArbitrationQueueTimeUs != 0) {
+    addThreadLocalRuntimeStat(
+        kLocalArbitrationQueueWallNanos,
+        RuntimeCounter(
+            operation_->localArbitrationQueueTimeUs * 1'000,
+            RuntimeCounter::Unit::kNanos));
+  }
+  if (operation_->localArbitrationLockWaitTimeUs != 0) {
+    addThreadLocalRuntimeStat(
+        kLocalArbitrationLockWaitWallNanos,
+        RuntimeCounter(
+            operation_->localArbitrationLockWaitTimeUs * 1'000,
+            RuntimeCounter::Unit::kNanos));
+  }
+  if (operation_->globalArbitrationLockWaitTimeUs != 0) {
+    addThreadLocalRuntimeStat(
+        kGlobalArbitrationLockWaitWallNanos,
+        RuntimeCounter(
+            operation_->globalArbitrationLockWaitTimeUs * 1'000,
+            RuntimeCounter::Unit::kNanos));
+  }
+  arbitrator_->arbitrationTimeUs_ += arbitrationTimeUs;
+
+  const uint64_t waitTimeUs = operation_->waitTimeUs();
+  if (waitTimeUs != 0) {
+    RECORD_HISTOGRAM_METRIC_VALUE(
+        kMetricArbitratorWaitTimeMs, waitTimeUs / 1'000);
+    arbitrator_->waitTimeUs_ += waitTimeUs;
+  }
 }
 
-void SharedArbitrator::startArbitration(MemoryPool* requestor) {
-  requestor->enterArbitration();
+void SharedArbitrator::startArbitration(ArbitrationOperation* op) {
+  updateArbitrationRequestStats();
   ContinueFuture waitPromise{ContinueFuture::makeEmpty()};
   {
-    std::lock_guard<std::mutex> l(mutex_);
-    ++numRequests_;
-    if (running_) {
-      waitPromises_.emplace_back(fmt::format(
-          "Wait for arbitration, requestor: {}[{}]",
-          requestor->name(),
-          requestor->root()->name()));
-      waitPromise = waitPromises_.back().getSemiFuture();
-    } else {
-      VELOX_CHECK(waitPromises_.empty());
-      running_ = true;
+    std::lock_guard<std::mutex> l(stateLock_);
+    ++numPending_;
+    if (op->requestPool != nullptr) {
+      auto it = arbitrationQueues_.find(op->requestPool);
+      if (it != arbitrationQueues_.end()) {
+        it->second->waitPromises.emplace_back(
+            fmt::format("Wait for arbitration {}", op->requestPool->name()));
+        waitPromise = it->second->waitPromises.back().getSemiFuture();
+      } else {
+        arbitrationQueues_.emplace(
+            op->requestPool, std::make_unique<ArbitrationQueue>(op));
+      }
     }
   }
 
   TestValue::adjust(
-      "facebook::velox::memory::SharedArbitrator::startArbitration", requestor);
+      "facebook::velox::memory::SharedArbitrator::startArbitration", this);
 
   if (waitPromise.valid()) {
     uint64_t waitTimeUs{0};
@@ -561,20 +1153,29 @@ void SharedArbitrator::startArbitration(MemoryPool* requestor) {
       MicrosecondTimer timer(&waitTimeUs);
       waitPromise.wait();
     }
-    queueTimeUs_ += waitTimeUs;
+    op->localArbitrationQueueTimeUs += waitTimeUs;
   }
 }
 
-void SharedArbitrator::finishArbitration() {
+void SharedArbitrator::finishArbitration(ArbitrationOperation* op) {
   ContinuePromise resumePromise{ContinuePromise::makeEmpty()};
   {
-    std::lock_guard<std::mutex> l(mutex_);
-    VELOX_CHECK(running_);
-    if (!waitPromises_.empty()) {
-      resumePromise = std::move(waitPromises_.back());
-      waitPromises_.pop_back();
-    } else {
-      running_ = false;
+    std::lock_guard<std::mutex> l(stateLock_);
+    VELOX_CHECK_GT(numPending_, 0);
+    --numPending_;
+    if (op->requestPool != nullptr) {
+      auto it = arbitrationQueues_.find(op->requestPool);
+      VELOX_CHECK(
+          it != arbitrationQueues_.end(),
+          "{} not found",
+          op->requestPool->name());
+      auto* runningArbitration = it->second.get();
+      if (runningArbitration->waitPromises.empty()) {
+        arbitrationQueues_.erase(it);
+      } else {
+        resumePromise = std::move(runningArbitration->waitPromises.back());
+        runningArbitration->waitPromises.pop_back();
+      }
     }
   }
   if (resumePromise.valid()) {
@@ -582,6 +1183,10 @@ void SharedArbitrator::finishArbitration() {
   }
 }
 
+bool SharedArbitrator::isUnderArbitrationLocked(MemoryPool* pool) const {
+  return arbitrationQueues_.count(pool) != 0;
+}
+
 std::string SharedArbitrator::kind() const {
   return kind_;
 }
@@ -596,4 +1201,16 @@ void SharedArbitrator::registerFactory() {
 void SharedArbitrator::unregisterFactory() {
   MemoryArbitrator::unregisterFactory(kind_);
 }
+
+void SharedArbitrator::incrementGlobalArbitrationCount() {
+  RECORD_METRIC_VALUE(kMetricArbitratorGlobalArbitrationCount);
+  addThreadLocalRuntimeStat(
+      kGlobalArbitrationCount, RuntimeCounter(1, RuntimeCounter::Unit::kNone));
+}
+
+void SharedArbitrator::incrementLocalArbitrationCount() {
+  RECORD_METRIC_VALUE(kMetricArbitratorLocalArbitrationCount);
+  addThreadLocalRuntimeStat(
+      kLocalArbitrationCount, RuntimeCounter(1, RuntimeCounter::Unit::kNone));
+}
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/SharedArbitrator.h b/velox/common/memory/SharedArbitrator.h
index b291b2af3bb13..6c784f5373f29 100644
--- a/velox/common/memory/SharedArbitrator.h
+++ b/velox/common/memory/SharedArbitrator.h
@@ -16,10 +16,14 @@
 
 #pragma once
 
-#include "velox/common/memory/MemoryArbitrator.h"
+#include <shared_mutex>
 
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/GTestMacros.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/future/VeloxPromise.h"
 #include "velox/common/memory/Memory.h"
+#include "velox/common/memory/MemoryArbitrator.h"
 
 namespace facebook::velox::memory {
 
@@ -31,30 +35,148 @@ namespace facebook::velox::memory {
 /// aborting a query. For Prestissimo-on-Spark, we can configure it to
 /// reclaim from a running query through techniques such as disk-spilling,
 /// partial aggregation or persistent shuffle data flushes.
-class SharedArbitrator : public MemoryArbitrator {
+class SharedArbitrator : public memory::MemoryArbitrator {
  public:
-  static void registerFactory();
-
-  static void unregisterFactory();
+  struct ExtraConfig {
+    /// The memory capacity reserved to ensure each running query has minimal
+    /// capacity of 'memoryPoolReservedCapacity' to run.
+    static constexpr std::string_view kReservedCapacity{"reserved-capacity"};
+    static constexpr std::string_view kDefaultReservedCapacity{"0B"};
+    static int64_t getReservedCapacity(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    /// The initial memory capacity to reserve for a newly created query memory
+    /// pool.
+    static constexpr std::string_view kMemoryPoolInitialCapacity{
+        "memory-pool-initial-capacity"};
+    static constexpr std::string_view kDefaultMemoryPoolInitialCapacity{
+        "256MB"};
+    static uint64_t getMemoryPoolInitialCapacity(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    /// The minimal amount of memory capacity reserved for each query to run.
+    static constexpr std::string_view kMemoryPoolReservedCapacity{
+        "memory-pool-reserved-capacity"};
+    static constexpr std::string_view kDefaultMemoryPoolReservedCapacity{"0B"};
+    static uint64_t getMemoryPoolReservedCapacity(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    /// The minimal memory capacity to transfer out of or into a memory pool
+    /// during the memory arbitration.
+    static constexpr std::string_view kMemoryPoolTransferCapacity{
+        "memory-pool-transfer-capacity"};
+    static constexpr std::string_view kDefaultMemoryPoolTransferCapacity{
+        "128MB"};
+    static uint64_t getMemoryPoolTransferCapacity(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    /// Specifies the max time to wait for memory reclaim by arbitration. The
+    /// memory reclaim might fail if the max time has exceeded. This prevents
+    /// the memory arbitration from getting stuck when the memory reclaim waits
+    /// for a hanging query task to pause. If it is zero, then there is no
+    /// timeout.
+    static constexpr std::string_view kMemoryReclaimMaxWaitTime{
+        "memory-reclaim-max-wait-time"};
+    static constexpr std::string_view kDefaultMemoryReclaimMaxWaitTime{"0ms"};
+    static uint64_t getMemoryReclaimMaxWaitTimeMs(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    /// When shrinking capacity, the shrink bytes will be adjusted in a way such
+    /// that AFTER shrink, the stricter (whichever is smaller) of the following
+    /// conditions is met, in order to better fit the pool's current memory
+    /// usage:
+    /// - Free capacity is greater or equal to capacity *
+    /// 'memoryPoolMinFreeCapacityPct'
+    /// - Free capacity is greater or equal to 'memoryPoolMinFreeCapacity'
+    ///
+    /// NOTE: In the conditions when original requested shrink bytes ends up
+    /// with more free capacity than above 2 conditions, the adjusted shrink
+    /// bytes is not respected.
+    ///
+    /// NOTE: Capacity shrink adjustment is enabled when both
+    /// 'memoryPoolMinFreeCapacityPct' and 'memoryPoolMinFreeCapacity' are set.
+    static constexpr std::string_view kMemoryPoolMinFreeCapacity{
+        "memory-pool-min-free-capacity"};
+    static constexpr std::string_view kDefaultMemoryPoolMinFreeCapacity{
+        "128MB"};
+    static uint64_t getMemoryPoolMinFreeCapacity(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    static constexpr std::string_view kMemoryPoolMinFreeCapacityPct{
+        "memory-pool-min-free-capacity-pct"};
+    static constexpr double kDefaultMemoryPoolMinFreeCapacityPct{0.25};
+    static double getMemoryPoolMinFreeCapacityPct(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    /// If true, it allows memory arbitrator to reclaim used memory cross query
+    /// memory pools.
+    static constexpr std::string_view kGlobalArbitrationEnabled{
+        "global-arbitration-enabled"};
+    static constexpr bool kDefaultGlobalArbitrationEnabled{false};
+    static bool getGlobalArbitrationEnabled(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    /// When growing capacity, the growth bytes will be adjusted in the
+    /// following way:
+    ///  - If 2 * current capacity is less than or equal to
+    ///    'fastExponentialGrowthCapacityLimit', grow through fast path by at
+    ///    least doubling the current capacity, when conditions allow (see below
+    ///    NOTE section).
+    ///  - If 2 * current capacity is greater than
+    ///    'fastExponentialGrowthCapacityLimit', grow through slow path by
+    ///    growing capacity by at least 'slowCapacityGrowPct' * current capacity
+    ///    if allowed (see below NOTE section).
+    ///
+    /// NOTE: If original requested growth bytes is larger than the adjusted
+    /// growth bytes or adjusted growth bytes reaches max capacity limit, the
+    /// adjusted growth bytes will not be respected.
+    ///
+    /// NOTE: Capacity growth adjust is only enabled if both
+    /// 'fastExponentialGrowthCapacityLimit' and 'slowCapacityGrowPct' are set,
+    /// otherwise it is disabled.
+    static constexpr std::string_view kFastExponentialGrowthCapacityLimit{
+        "fast-exponential-growth-capacity-limit"};
+    static constexpr std::string_view
+        kDefaultFastExponentialGrowthCapacityLimit{"512MB"};
+    static uint64_t getFastExponentialGrowthCapacityLimitBytes(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    static constexpr std::string_view kSlowCapacityGrowPct{
+        "slow-capacity-grow-pct"};
+    static constexpr double kDefaultSlowCapacityGrowPct{0.25};
+    static double getSlowCapacityGrowPct(
+        const std::unordered_map<std::string, std::string>& configs);
+
+    /// If true, do sanity check on the arbitrator state on destruction.
+    ///
+    /// TODO: deprecate this flag after all the existing memory leak use cases
+    /// have been fixed.
+    static constexpr std::string_view kCheckUsageLeak{"check-usage-leak"};
+    static constexpr bool kDefaultCheckUsageLeak{true};
+    static bool getCheckUsageLeak(
+        const std::unordered_map<std::string, std::string>& configs);
+  };
 
   explicit SharedArbitrator(const Config& config);
 
   ~SharedArbitrator() override;
 
-  void reserveMemory(MemoryPool* pool, uint64_t /*unused*/) final;
+  static void registerFactory();
 
-  void releaseMemory(MemoryPool* pool) final;
+  static void unregisterFactory();
 
-  bool growMemory(
-      MemoryPool* pool,
-      const std::vector<std::shared_ptr<MemoryPool>>& candidatePools,
-      uint64_t targetBytes) final;
+  void addPool(const std::shared_ptr<MemoryPool>& pool) final;
 
-  uint64_t shrinkMemory(
-      const std::vector<std::shared_ptr<MemoryPool>>& /*unused*/,
-      uint64_t /*unused*/) override final {
-    VELOX_NYI("shrinkMemory is not supported by SharedArbitrator");
-  }
+  void removePool(MemoryPool* pool) final;
+
+  bool growCapacity(MemoryPool* pool, uint64_t requestBytes) final;
+
+  uint64_t shrinkCapacity(MemoryPool* pool, uint64_t requestBytes = 0) final;
+
+  uint64_t shrinkCapacity(
+      uint64_t requestBytes,
+      bool allowSpill = true,
+      bool force = false) override final;
 
   Stats stats() const final;
 
@@ -62,12 +184,37 @@ class SharedArbitrator : public MemoryArbitrator {
 
   std::string toString() const final;
 
-  // The candidate memory pool stats used by arbitration.
+  /// Returns 'freeCapacity' back to the arbitrator for testing.
+  void testingFreeCapacity(uint64_t freeCapacity);
+
+  uint64_t testingNumRequests() const;
+
+  /// Enables/disables global arbitration accordingly.
+  void testingSetGlobalArbitration(bool enableGlobalArbitration) {
+    *const_cast<bool*>(&globalArbitrationEnabled_) = enableGlobalArbitration;
+  }
+
+  /// Operator level runtime stats that are reported during a shared arbitration
+  /// attempt.
+  static inline const std::string kMemoryArbitrationWallNanos{
+      "memoryArbitrationWallNanos"};
+  static inline const std::string kGlobalArbitrationCount{
+      "globalArbitrationCount"};
+  static inline const std::string kLocalArbitrationCount{
+      "localArbitrationCount"};
+  static inline const std::string kLocalArbitrationQueueWallNanos{
+      "localArbitrationQueueWallNanos"};
+  static inline const std::string kLocalArbitrationLockWaitWallNanos{
+      "localArbitrationLockWaitWallNanos"};
+  static inline const std::string kGlobalArbitrationLockWaitWallNanos{
+      "globalArbitrationLockWaitWallNanos"};
+
+  /// The candidate memory pool stats used by arbitration.
   struct Candidate {
-    bool reclaimable{false};
-    uint64_t reclaimableBytes{0};
-    uint64_t freeBytes{0};
-    MemoryPool* pool;
+    std::shared_ptr<MemoryPool> pool;
+    int64_t reclaimableBytes{0};
+    int64_t freeBytes{0};
+    int64_t reservedBytes{0};
 
     std::string toString() const;
   };
@@ -76,130 +223,339 @@ class SharedArbitrator : public MemoryArbitrator {
   // The kind string of shared arbitrator.
   inline static const std::string kind_{"SHARED"};
 
+  // Contains the execution state of an arbitration operation.
+  struct ArbitrationOperation {
+    MemoryPool* const requestPool;
+    const uint64_t requestBytes;
+
+    // The adjusted grow bytes based on 'requestBytes'. This 'targetBytes' is a
+    // best effort target, and hence will not be guaranteed. The adjustment is
+    // based on 'SharedArbitrator::fastExponentialGrowthCapacityLimit_'
+    // 'SharedArbitrator::slowCapacityGrowPct_' and
+    // 'MemoryArbitrator::memoryPoolTransferCapacity_'.
+    //
+    // TODO: deprecate 'MemoryArbitrator::memoryPoolTransferCapacity_' once
+    // exponential growth works well in production.
+    const std::optional<uint64_t> targetBytes;
+
+    // The start time of this arbitration operation.
+    const std::chrono::steady_clock::time_point startTime;
+
+    // The candidate memory pools.
+    std::vector<Candidate> candidates;
+
+    // The time that waits in local arbitration queue.
+    uint64_t localArbitrationQueueTimeUs{0};
+
+    // The time that waits to acquire the local arbitration lock.
+    uint64_t localArbitrationLockWaitTimeUs{0};
+
+    // The time that waits to acquire the global arbitration lock.
+    uint64_t globalArbitrationLockWaitTimeUs{0};
+
+    explicit ArbitrationOperation(uint64_t requestBytes)
+        : ArbitrationOperation(nullptr, requestBytes, std::nullopt) {}
+
+    ArbitrationOperation(
+        MemoryPool* _requestor,
+        uint64_t _requestBytes,
+        std::optional<uint64_t> _targetBytes)
+        : requestPool(_requestor),
+          requestBytes(_requestBytes),
+          targetBytes(_targetBytes),
+          startTime(std::chrono::steady_clock::now()) {
+      VELOX_CHECK(requestPool == nullptr || requestPool->isRoot());
+    }
+
+    uint64_t waitTimeUs() const {
+      return localArbitrationQueueTimeUs + localArbitrationLockWaitTimeUs +
+          globalArbitrationLockWaitTimeUs;
+    }
+  };
+
+  // Used to start and finish an arbitration operation initiated from a memory
+  // pool or memory capacity shrink request sent through shrinkPools() API.
   class ScopedArbitration {
    public:
-    ScopedArbitration(MemoryPool* requestor, SharedArbitrator* arbitrator);
+    ScopedArbitration(SharedArbitrator* arbitrator, ArbitrationOperation* op);
 
     ~ScopedArbitration();
 
    private:
-    MemoryPool* const requestor_;
+    ArbitrationOperation* const operation_;
     SharedArbitrator* const arbitrator_;
-    const std::chrono::steady_clock::time_point startTime_;
     const ScopedMemoryArbitrationContext arbitrationCtx_;
+    const std::chrono::steady_clock::time_point startTime_;
+  };
+
+  // The arbitration running queue for arbitration requests from the same query
+  // pool.
+  struct ArbitrationQueue {
+    // Points to the current running arbitration.
+    ArbitrationOperation* current;
+
+    // The promises of the arbitration requests from the same query pool waiting
+    // for the serial execution.
+    std::vector<ContinuePromise> waitPromises;
+
+    explicit ArbitrationQueue(ArbitrationOperation* op) : current(op) {
+      VELOX_CHECK_NOT_NULL(current);
+    }
   };
 
   // Invoked to check if the memory growth will exceed the memory pool's max
   // capacity limit or the arbitrator's node capacity limit.
-  bool checkCapacityGrowth(const MemoryPool& pool, uint64_t targetBytes) const;
+  bool checkCapacityGrowth(ArbitrationOperation* op) const;
+
+  // Invoked to ensure the memory growth request won't exceed the request memory
+  // pool's max capacity as well as the arbitrator's node capacity. If it does,
+  // then we first need to reclaim the used memory from the request memory pool
+  // itself to ensure the memory growth won't exceed the capacity limit, and
+  // then proceed with the memory arbitration process across queries.
+  bool ensureCapacity(ArbitrationOperation* op);
+
+  // Invoked to reclaim the memory from the other query memory pools to grow the
+  // request memory pool's capacity.
+  bool arbitrateMemory(ArbitrationOperation* op);
 
-  // Invoked to ensure the memory growth request won't exceed the requestor's
-  // max capacity as well as the arbitrator's node capacity. If it does, then we
-  // first need to reclaim the used memory from the requestor itself to ensure
-  // the memory growth won't exceed the capacity limit, and then proceed with
-  // the memory arbitration process. The reclaimed memory capacity returns to
-  // the arbitrator, and let the memory arbitration process to grow the
-  // requestor capacity accordingly.
-  bool ensureCapacity(MemoryPool* requestor, uint64_t targetBytes);
+  // Invoked to start next memory arbitration request, and it will wait for
+  // the serialized execution if there is a running or other waiting
+  // arbitration requests.
+  void startArbitration(ArbitrationOperation* op);
 
-  // Invoked to capture the candidate memory pools stats for arbitration.
-  static std::vector<Candidate> getCandidateStats(
-      const std::vector<std::shared_ptr<MemoryPool>>& pools);
+  // Invoked by a finished memory arbitration request to kick off the next
+  // arbitration request execution if there are any ones waiting.
+  void finishArbitration(ArbitrationOperation* op);
+
+  // Invoked to run local arbitration on the request memory pool. It first
+  // ensures the memory growth is within both memory pool and arbitrator
+  // capacity limits. This step might reclaim the used memory from the request
+  // memory pool itself. Then it tries to obtain free capacity from the
+  // arbitrator. At last, it tries to reclaim free memory from itself before it
+  // falls back to the global arbitration. The local arbitration run is
+  // protected by shared lock of 'arbitrationLock_' which can run in parallel
+  // for different query pools. The free memory reclamation is protected by
+  // arbitrator 'mutex_' which is an in-memory fast operation. The function
+  // returns false on failure. Otherwise, it needs to further check if
+  // 'needGlobalArbitration' is true or not. If true, needs to proceed with the
+  // global arbitration run.
+  bool runLocalArbitration(
+      ArbitrationOperation* op,
+      bool& needGlobalArbitration);
+
+  // Invoked to run global arbitration to reclaim free or used memory from the
+  // other queries. The global arbitration run is protected by the exclusive
+  // lock of 'arbitrationLock_' for serial execution mode. The function returns
+  // true on success, false on failure.
+  bool runGlobalArbitration(ArbitrationOperation* op);
+
+  // Gets the mim/max memory capacity growth targets for 'op'. The min and max
+  // targets are calculated based on memoryPoolReservedCapacity_ requirements
+  // and the pool's max capacity.
+  void getGrowTargets(
+      ArbitrationOperation* op,
+      uint64_t& maxGrowTarget,
+      uint64_t& minGrowTarget);
+
+  // Invoked to get or refresh the candidate memory pools for arbitration. If
+  // 'freeCapacityOnly' is true, then we only get free capacity stats for each
+  // candidate memory pool.
+  void getCandidates(ArbitrationOperation* op, bool freeCapacityOnly = false);
+
+  // Sorts 'candidates' based on reclaimable free capacity in descending order.
+  static void sortCandidatesByReclaimableFreeCapacity(
+      std::vector<Candidate>& candidates);
 
-  void sortCandidatesByReclaimableMemory(
-      std::vector<Candidate>& candidates) const;
+  // Sorts 'candidates' based on reclaimable used capacity in descending order.
+  static void sortCandidatesByReclaimableUsedCapacity(
+      std::vector<Candidate>& candidates);
 
-  void sortCandidatesByFreeCapacity(std::vector<Candidate>& candidates) const;
+  // Sorts 'candidates' based on actual used memory in descending order.
+  static void sortCandidatesByUsage(std::vector<Candidate>& candidates);
 
   // Finds the candidate with the largest capacity. For 'requestor', the
   // capacity for comparison including its current capacity and the capacity to
   // grow.
-  const Candidate& findCandidateWithLargestCapacity(
+  static const SharedArbitrator::Candidate& findCandidateWithLargestCapacity(
       MemoryPool* requestor,
       uint64_t targetBytes,
-      const std::vector<Candidate>& candidates) const;
-
-  bool arbitrateMemory(
-      MemoryPool* requestor,
-      std::vector<Candidate>& candidates,
-      uint64_t targetBytes);
+      const std::vector<Candidate>& candidates);
 
-  // Invoked to start next memory arbitration request, and it will wait for the
-  // serialized execution if there is a running or other waiting arbitration
-  // requests.
-  void startArbitration(MemoryPool* requestor);
-
-  // Invoked by a finished memory arbitration request to kick off the next
-  // arbitration request execution if there are any ones waiting.
-  void finishArbitration();
-
-  // Invoked to reclaim free memory capacity from 'candidates' without actually
-  // freeing used memory.
+  // Invoked to reclaim free memory capacity from 'candidates' without
+  // actually freeing used memory.
   //
   // NOTE: the function might sort 'candidates' based on each candidate's free
   // capacity internally.
   uint64_t reclaimFreeMemoryFromCandidates(
-      std::vector<Candidate>& candidates,
-      uint64_t targetBytes);
+      ArbitrationOperation* op,
+      uint64_t reclaimTargetBytes,
+      bool isLocalArbitration);
 
-  // Invoked to reclaim used memory capacity from 'candidates'.
+  // Invoked to reclaim used memory capacity from 'candidates' by spilling.
   //
   // NOTE: the function might sort 'candidates' based on each candidate's
   // reclaimable memory internally.
-  uint64_t reclaimUsedMemoryFromCandidates(
-      MemoryPool* requestor,
-      std::vector<Candidate>& candidates,
-      uint64_t targetBytes);
-
-  // Invoked to reclaim used memory from 'pool' with specified 'targetBytes'.
-  // The function returns the actually freed capacity.
-  uint64_t reclaim(MemoryPool* pool, uint64_t targetBytes) noexcept;
+  void reclaimUsedMemoryFromCandidatesBySpill(
+      ArbitrationOperation* op,
+      uint64_t& freedBytes);
+
+  // Invoked to reclaim used memory capacity from 'candidates' by aborting the
+  // top memory users' queries.
+  void reclaimUsedMemoryFromCandidatesByAbort(
+      ArbitrationOperation* op,
+      uint64_t& freedBytes);
+
+  // Checks if request pool has been aborted or not.
+  void checkIfAborted(ArbitrationOperation* op);
+
+  // Checks if the request pool already has enough free capacity for the growth.
+  // This could happen if there are multiple arbitration operations from the
+  // same query. When the first served operation succeeds, it might have
+  // reserved enough capacity for the followup operations.
+  bool maybeGrowFromSelf(ArbitrationOperation* op);
+
+  // Invoked to grow 'pool' capacity by 'growBytes' and commit used reservation
+  // by 'reservationBytes'. The function throws if the growth fails.
+  void
+  checkedGrow(MemoryPool* pool, uint64_t growBytes, uint64_t reservationBytes);
+
+  // Invoked to reclaim used memory from 'targetPool' with specified
+  // 'targetBytes'. The function returns the actually freed capacity.
+  // 'isLocalArbitration' is true when the reclaim attempt is within a local
+  // arbitration.
+  uint64_t reclaim(
+      MemoryPool* targetPool,
+      uint64_t targetBytes,
+      bool isLocalArbitration) noexcept;
 
   // Invoked to abort memory 'pool'.
   void abort(MemoryPool* pool, const std::exception_ptr& error);
 
   // Invoked to handle the memory arbitration failure to abort the memory pool
   // with the largest capacity to free up memory. The function returns true on
-  // success and false if the requestor itself has been selected as the victim.
-  // We don't abort the requestor itself but just fails the arbitration to let
-  // the user decide to either proceed with the query or fail it.
-  bool handleOOM(
-      MemoryPool* requestor,
-      uint64_t targetBytes,
-      std::vector<Candidate>& candidates);
-
-  // Decrement free capacity from the arbitrator with up to 'bytes'. The
-  // arbitrator might have less free available capacity. The function returns
-  // the actual decremented free capacity bytes.
-  uint64_t decrementFreeCapacity(uint64_t bytes);
-  uint64_t decrementFreeCapacityLocked(uint64_t bytes);
+  // success and false if the requestor itself has been selected as the
+  // victim. We don't abort the requestor itself but just fails the
+  // arbitration to let the user decide to either proceed with the query or
+  // fail it.
+  bool handleOOM(ArbitrationOperation* op);
+
+  // Decrements free capacity from the arbitrator with up to
+  // 'maxBytesToReserve'. The arbitrator might have less free available
+  // capacity. The function returns the actual decremented free capacity
+  // bytes. If 'minBytesToReserve' is not zero and there is less than
+  // 'minBytes' available in non-reserved capacity, then the arbitrator tries
+  // to decrement up to 'minBytes' from the reserved capacity.
+  uint64_t decrementFreeCapacity(
+      uint64_t maxBytesToReserve,
+      uint64_t minBytesToReserve);
+  uint64_t decrementFreeCapacityLocked(
+      uint64_t maxBytesToReserve,
+      uint64_t minBytesToReserve);
 
   // Increment free capacity by 'bytes'.
   void incrementFreeCapacity(uint64_t bytes);
   void incrementFreeCapacityLocked(uint64_t bytes);
+  // Increments the free reserved capacity up to 'bytes' until reaches to the
+  // reserved capacity limit. 'bytes' is updated accordingly.
+  void incrementFreeReservedCapacityLocked(uint64_t& bytes);
+
+  void incrementGlobalArbitrationCount();
+  void incrementLocalArbitrationCount();
 
   std::string toStringLocked() const;
 
   Stats statsLocked() const;
 
-  mutable std::mutex mutex_;
-  uint64_t freeCapacity_{0};
-  // Indicates if there is a running arbitration request or not.
-  bool running_{false};
-
-  // The promises of the arbitration requests waiting for the serialized
-  // execution.
-  std::vector<ContinuePromise> waitPromises_;
-
-  tsan_atomic<uint64_t> numRequests_{0};
-  std::atomic<uint64_t> numSucceeded_{0};
+  // Returns the max reclaimable capacity from 'pool' which includes both used
+  // and free capacities. If 'isSelfReclaim' true, we reclaim memory from the
+  // request pool itself so that we can bypass the reserved free capacity
+  // reclaim restriction.
+  int64_t maxReclaimableCapacity(const MemoryPool& pool, bool isSelfReclaim)
+      const;
+
+  // Returns the free memory capacity that can be reclaimed from 'pool' by
+  // shrink. If 'isSelfReclaim' true, we reclaim memory from the request pool
+  // itself so that we can bypass the reserved free capacity reclaim
+  // restriction.
+  int64_t reclaimableFreeCapacity(const MemoryPool& pool, bool isSelfReclaim)
+      const;
+
+  // Returns the used memory capacity that can be reclaimed from 'pool' by
+  // disk spill. If 'isSelfReclaim' true, we reclaim memory from the request
+  // pool itself so that we can bypass the reserved free capacity reclaim
+  // restriction.
+  int64_t reclaimableUsedCapacity(const MemoryPool& pool, bool isSelfReclaim)
+      const;
+
+  // Returns the minimal amount of memory capacity to grow for 'pool' to have
+  // the reserved capacity as specified by 'memoryPoolReservedCapacity_'.
+  int64_t minGrowCapacity(const MemoryPool& pool) const;
+
+  // The capacity growth target is set to have a coarser granularity. It can
+  // help to reduce the number of future grow calls, and hence reducing the
+  // number of unnecessary memory arbitration requests.
+  uint64_t getCapacityGrowthTarget(
+      const MemoryPool& pool,
+      uint64_t requestBytes) const;
+
+  // The capacity shrink target is adjusted from request shrink bytes to give
+  // the memory pool more headroom free capacity after shrink. It can help to
+  // reduce the number of future grow calls, and hence reducing the number of
+  // unnecessary memory arbitration requests.
+  uint64_t getCapacityShrinkTarget(
+      const MemoryPool& pool,
+      uint64_t requestBytes) const;
+
+  // Returns true if 'pool' is under memory arbitration.
+  bool isUnderArbitrationLocked(MemoryPool* pool) const;
+
+  void updateArbitrationRequestStats();
+
+  void updateArbitrationFailureStats();
+
+  const uint64_t reservedCapacity_;
+  const uint64_t memoryPoolInitialCapacity_;
+  const uint64_t memoryPoolReservedCapacity_;
+  const uint64_t memoryPoolTransferCapacity_;
+  const uint64_t memoryReclaimWaitMs_;
+  const bool globalArbitrationEnabled_;
+  const bool checkUsageLeak_;
+
+  const uint64_t fastExponentialGrowthCapacityLimit_;
+  const double slowCapacityGrowPct_;
+  const uint64_t memoryPoolMinFreeCapacity_;
+  const double memoryPoolMinFreeCapacityPct_;
+
+  mutable folly::SharedMutex poolLock_;
+  std::unordered_map<MemoryPool*, std::weak_ptr<MemoryPool>> candidates_;
+
+  // Lock used to protect the arbitrator state.
+  mutable std::mutex stateLock_;
+  tsan_atomic<uint64_t> freeReservedCapacity_{0};
+  tsan_atomic<uint64_t> freeNonReservedCapacity_{0};
+
+  // Contains the arbitration running queues with one per each query memory
+  // pool.
+  std::unordered_map<MemoryPool*, std::unique_ptr<ArbitrationQueue>>
+      arbitrationQueues_;
+
+  // R/W lock used to control local and global arbitration runs. A local
+  // arbitration run needs to hold a shared lock while the latter needs to hold
+  // an exclusive lock. Hence, multiple local arbitration runs from different
+  // query memory pools can run in parallel but the global ones has to run with
+  // one at a time.
+  mutable std::shared_mutex arbitrationLock_;
+
+  std::atomic_uint64_t numRequests_{0};
+  std::atomic_uint32_t numPending_{0};
   tsan_atomic<uint64_t> numAborted_{0};
-  tsan_atomic<uint64_t> numFailures_{0};
-  tsan_atomic<uint64_t> queueTimeUs_{0};
+  std::atomic_uint64_t numFailures_{0};
+  std::atomic_uint64_t waitTimeUs_{0};
   tsan_atomic<uint64_t> arbitrationTimeUs_{0};
-  tsan_atomic<uint64_t> numShrunkBytes_{0};
-  tsan_atomic<uint64_t> numReclaimedBytes_{0};
+  tsan_atomic<uint64_t> reclaimedFreeBytes_{0};
+  tsan_atomic<uint64_t> reclaimedUsedBytes_{0};
   tsan_atomic<uint64_t> reclaimTimeUs_{0};
   tsan_atomic<uint64_t> numNonReclaimableAttempts_{0};
+  tsan_atomic<uint64_t> numShrinks_{0};
 };
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/StreamArena.cpp b/velox/common/memory/StreamArena.cpp
index 14e5dbc37c11a..1153afbb8cf69 100644
--- a/velox/common/memory/StreamArena.cpp
+++ b/velox/common/memory/StreamArena.cpp
@@ -20,7 +20,10 @@ namespace facebook::velox {
 
 StreamArena::StreamArena(memory::MemoryPool* pool) : pool_(pool) {}
 
-void StreamArena::newRange(int32_t bytes, ByteRange* range) {
+void StreamArena::newRange(
+    int32_t bytes,
+    ByteRange* /*lastRange*/,
+    ByteRange* range) {
   VELOX_CHECK_GT(bytes, 0, "StreamArena::newRange can't be zero length");
   const memory::MachinePageCount numPages =
       memory::AllocationTraits::numPages(bytes);
@@ -62,7 +65,10 @@ void StreamArena::newRange(int32_t bytes, ByteRange* range) {
   }
 }
 
-void StreamArena::newTinyRange(int32_t bytes, ByteRange* range) {
+void StreamArena::newTinyRange(
+    int32_t bytes,
+    ByteRange* /*lastRange*/,
+    ByteRange* range) {
   VELOX_CHECK_GT(bytes, 0, "StreamArena::newTinyRange can't be zero length");
   tinyRanges_.emplace_back();
   tinyRanges_.back().resize(bytes);
@@ -70,4 +76,14 @@ void StreamArena::newTinyRange(int32_t bytes, ByteRange* range) {
   range->buffer = reinterpret_cast<uint8_t*>(tinyRanges_.back().data());
   range->size = bytes;
 }
+void StreamArena::clear() {
+  allocations_.clear();
+  pool_->freeNonContiguous(allocation_);
+  currentRun_ = 0;
+  currentOffset_ = 0;
+  largeAllocations_.clear();
+  size_ = 0;
+  tinyRanges_.clear();
+}
+
 } // namespace facebook::velox
diff --git a/velox/common/memory/StreamArena.h b/velox/common/memory/StreamArena.h
index a9e9f71e1954a..d46f00c436f4c 100644
--- a/velox/common/memory/StreamArena.h
+++ b/velox/common/memory/StreamArena.h
@@ -30,16 +30,28 @@ class StreamArena {
 
   virtual ~StreamArena() = default;
 
-  /// Sets range to the request 'bytes' of writable memory owned by 'this'.
-  /// We allocate non-contiguous memory to store range bytes if requested
-  /// 'bytes' is equal or less than the largest class page size. Otherwise, we
-  /// allocate from contiguous memory.
-  virtual void newRange(int32_t bytes, ByteRange* range);
+  /// Sets range to the request 'bytes' of writable memory owned by
+  /// 'this'.  We allocate non-contiguous memory to store range bytes
+  /// if requested 'bytes' is equal or less than the largest class
+  /// page size. Otherwise, we allocate from contiguous
+  /// memory. 'range' is set to point to the allocated memory. If
+  /// 'lastRange' is non-nullptr, it is the last range of the stream
+  /// to which we are adding the new range. 'lastRange' is nullptr if
+  /// adding the first range to a stream. The memory is stays owned by
+  /// 'this' in all cases. Used by HashStringAllocator when extending
+  /// a multipart entry. The previously last part has its last 8 bytes
+  /// moved to the next part and gets a pointer to the next part as
+  /// its last 8 bytes. When extending, we need to update the entry so
+  /// that the next pointer is not seen when reading the content and
+  /// is also not counted in the payload size of the multipart entry.
+  virtual void newRange(int32_t bytes, ByteRange* lastRange, ByteRange* range);
 
   /// sets 'range' to point to a small piece of memory owned by this. These
   /// always come from the heap. The use case is for headers that may change
-  /// length based on data properties, not for bulk data.
-  virtual void newTinyRange(int32_t bytes, ByteRange* range);
+  /// length based on data properties, not for bulk data. See 'newRange' for the
+  /// meaning of 'lastRange'.
+  virtual void
+  newTinyRange(int32_t bytes, ByteRange* lastRange, ByteRange* range);
 
   /// Returns the Total size in bytes held by all Allocations.
   virtual size_t size() const {
@@ -50,6 +62,10 @@ class StreamArena {
     return pool_;
   }
 
+  /// Restores 'this' to post-construction state. Used in recycling streams for
+  /// serilizers.
+  virtual void clear();
+
  private:
   memory::MemoryPool* const pool_;
   const memory::MachinePageCount allocationQuantum_{2};
diff --git a/velox/common/memory/tests/AllocationPoolTest.cpp b/velox/common/memory/tests/AllocationPoolTest.cpp
index cd116d9de08a2..9713302744e82 100644
--- a/velox/common/memory/tests/AllocationPoolTest.cpp
+++ b/velox/common/memory/tests/AllocationPoolTest.cpp
@@ -14,25 +14,27 @@
  * limitations under the License.
  */
 #include "velox/common/memory/AllocationPool.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/MallocAllocator.h"
 #include "velox/common/memory/Memory.h"
+#include "velox/common/testutil/TestValue.h"
 
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 
 class AllocationPoolTest : public testing::Test {
  protected:
   void SetUp() override {
-    allocator_ = std::make_shared<memory::MallocAllocator>(8L << 30);
-    manager_ =
-        std::make_shared<memory::MemoryManager>(memory::MemoryManagerOptions{
-            .capacity = (int64_t)allocator_->capacity(),
-            .allocator = allocator_.get()});
+    manager_ = std::make_shared<memory::MemoryManager>(
+        memory::MemoryManagerOptions{.allocatorCapacity = 8L << 30});
 
     root_ = manager_->addRootPool("allocationPoolTestRoot");
     pool_ = root_->addLeafChild("leaf");
+
+    TestValue::enable();
   }
 
   // Writes a byte at pointer so we see RSS change.
@@ -40,7 +42,6 @@ class AllocationPoolTest : public testing::Test {
     *reinterpret_cast<char*>(ptr) = 1;
   }
 
-  std::shared_ptr<memory::MemoryAllocator> allocator_;
   std::shared_ptr<memory::MemoryManager> manager_;
   std::shared_ptr<memory::MemoryPool> root_;
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -58,17 +59,17 @@ TEST_F(AllocationPoolTest, hugePages) {
     EXPECT_EQ(1, allocationPool->numRanges());
     EXPECT_EQ(allocationPool->testingFreeAddressableBytes(), 64 << 10);
     allocationPool->newRun(64 << 10);
-    EXPECT_LE(128 << 10, pool_->currentBytes());
+    EXPECT_LE(128 << 10, pool_->usedBytes());
     allocationPool->allocateFixed(64 << 10);
     // Now at end of second 64K range, next will go to huge pages.
     setByte(allocationPool->allocateFixed(11));
     EXPECT_LE((2 << 20) - 11, allocationPool->testingFreeAddressableBytes());
     // The first 2MB of the hugepage run are marked reserved.
-    EXPECT_LE((2048 + 128) << 10, pool_->currentBytes());
+    EXPECT_LE((2048 + 128) << 10, pool_->usedBytes());
 
     // The next allocation starts reserves the next 2MB of the mmapped range.
     setByte(allocationPool->allocateFixed(2 << 20));
-    EXPECT_LE((4096 + 128) << 10, pool_->currentBytes());
+    EXPECT_LE((4096 + 128) << 10, pool_->usedBytes());
 
     // Allocate the rest.
     allocationPool->allocateFixed(
@@ -96,7 +97,7 @@ TEST_F(AllocationPoolTest, hugePages) {
     EXPECT_LE(
         (5UL << 30) + (31 << 20) + (128 << 10),
         allocationPool->allocatedBytes());
-    EXPECT_LE((5UL << 30) + (31 << 20) + (128 << 10), pool_->currentBytes());
+    EXPECT_LE((5UL << 30) + (31 << 20) + (128 << 10), pool_->usedBytes());
 
     if (counter++ >= 1) {
       break;
@@ -105,9 +106,51 @@ TEST_F(AllocationPoolTest, hugePages) {
     // Repeat the above after a clear().
     allocationPool->clear();
     // Should be empty after clear().
-    EXPECT_EQ(0, pool_->currentBytes());
+    EXPECT_EQ(0, pool_->usedBytes());
   }
   allocationPool.reset();
   // Should be empty after destruction.
-  EXPECT_EQ(0, pool_->currentBytes());
+  EXPECT_EQ(0, pool_->usedBytes());
+}
+
+// This test relies on TestValue, so needs to be run in debug mode.
+DEBUG_ONLY_TEST_F(AllocationPoolTest, oomCleanUp) {
+  // Test that when an OOM happens while growing an allocation in the
+  // AllocationPool, the AllocationPool is still in a valid state.
+  auto test = [&](int32_t alignment) {
+    auto allocationPool = std::make_unique<memory::AllocationPool>(pool_.get());
+    // Ensure we're beyond the huge page threshod.
+    allocationPool->setHugePageThreshold(32 << 10);
+    allocationPool->allocateFixed(32 << 10, alignment);
+
+    // Allocate some memory so we have a large allocation.
+    allocationPool->allocateFixed(1 << 20, alignment);
+
+    {
+      static const std::string kErrorMessage = "Simulate OOM for testing.";
+      // Trigger an OOM.
+      SCOPED_TESTVALUE_SET(
+          "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe",
+          std::function<void(memory::MemoryPool*)>(
+              [&](memory::MemoryPool* /*unused*/) {
+                VELOX_FAIL(kErrorMessage);
+              }));
+      VELOX_ASSERT_THROW(
+          allocationPool->allocateFixed(
+              allocationPool->testingFreeAddressableBytes(), alignment),
+          kErrorMessage);
+    }
+
+    // Ensure the last range in the pool is still consistent, e.g.
+    // currentOffset_ isn't pointing into unallocated memory.
+    ASSERT_EQ(
+        allocationPool->rangeAt(allocationPool->numRanges() - 1).size(),
+        1 << 20);
+  };
+
+  // Test with an alignment of 1.
+  test(1);
+  // Test with an alignment of 2 (this goes through a different code path in
+  // allocateFixed).
+  test(2);
 }
diff --git a/velox/common/memory/tests/AllocationTest.cpp b/velox/common/memory/tests/AllocationTest.cpp
index f27618303fa1c..ea6d3e58115f9 100644
--- a/velox/common/memory/tests/AllocationTest.cpp
+++ b/velox/common/memory/tests/AllocationTest.cpp
@@ -85,4 +85,28 @@ TEST_F(AllocationTest, appendMove) {
   allocation.clear();
 }
 
+TEST_F(AllocationTest, maxPageRunLimit) {
+  Allocation allocation;
+  const uint64_t vaildBufAddrValue = 4096;
+  uint8_t* validBufAddr = reinterpret_cast<uint8_t*>(vaildBufAddrValue);
+  allocation.append(validBufAddr, Allocation::PageRun::kMaxPagesInRun);
+  ASSERT_EQ(allocation.numPages(), Allocation::PageRun::kMaxPagesInRun);
+  ASSERT_EQ(allocation.numRuns(), 1);
+
+  const uint64_t invaildBufAddrValue = 4096 * 1024;
+  uint8_t* invalidBufAddr = reinterpret_cast<uint8_t*>(invaildBufAddrValue);
+  VELOX_ASSERT_THROW(
+      allocation.append(
+          invalidBufAddr, Allocation::PageRun::kMaxPagesInRun + 1),
+      "The number of pages to append 65536 exceeds the PageRun limit 65535");
+  VELOX_ASSERT_THROW(
+      allocation.append(
+          invalidBufAddr, Allocation::PageRun::kMaxPagesInRun * 2),
+      "The number of pages to append 131070 exceeds the PageRun limit 65535");
+  ASSERT_EQ(allocation.numPages(), Allocation::PageRun::kMaxPagesInRun);
+  ASSERT_EQ(allocation.numRuns(), 1);
+  LOG(ERROR) << "here";
+  allocation.clear();
+}
+
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/tests/ByteStreamTest.cpp b/velox/common/memory/tests/ByteStreamTest.cpp
index 73f0bbb4d3c0b..ec9e43941b325 100644
--- a/velox/common/memory/tests/ByteStreamTest.cpp
+++ b/velox/common/memory/tests/ByteStreamTest.cpp
@@ -14,8 +14,12 @@
  * limitations under the License.
  */
 #include "velox/common/memory/ByteStream.h"
-#include "velox/common/memory/MemoryAllocator.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileInputStream.h"
+#include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/MmapAllocator.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
@@ -27,29 +31,26 @@ class ByteStreamTest : public testing::Test {
  protected:
   void SetUp() override {
     constexpr uint64_t kMaxMappedMemory = 64 << 20;
-    MmapAllocator::Options options;
-    options.capacity = kMaxMappedMemory;
-    mmapAllocator_ = std::make_shared<MmapAllocator>(options);
-    MemoryAllocator::setDefaultInstance(mmapAllocator_.get());
-    memoryManager_ = std::make_unique<MemoryManager>(MemoryManagerOptions{
-        .capacity = kMaxMappedMemory,
-        .allocator = MemoryAllocator::getInstance()});
+    MemoryManagerOptions options;
+    options.useMmapAllocator = true;
+    options.allocatorCapacity = kMaxMappedMemory;
+    options.arbitratorCapacity = kMaxMappedMemory;
+    options.arbitratorReservedCapacity = 0;
+    memoryManager_ = std::make_unique<MemoryManager>(options);
+    mmapAllocator_ = static_cast<MmapAllocator*>(memoryManager_->allocator());
     pool_ = memoryManager_->addLeafPool("ByteStreamTest");
     rng_.seed(124);
   }
 
-  void TearDown() override {
-    MmapAllocator::testingDestroyInstance();
-    MemoryAllocator::setDefaultInstance(nullptr);
-  }
+  void TearDown() override {}
 
   std::unique_ptr<StreamArena> newArena() {
     return std::make_unique<StreamArena>(pool_.get());
   }
 
   folly::Random::DefaultGenerator rng_;
-  std::shared_ptr<MmapAllocator> mmapAllocator_;
   std::unique_ptr<MemoryManager> memoryManager_;
+  MmapAllocator* mmapAllocator_;
   std::shared_ptr<memory::MemoryPool> pool_;
 };
 
@@ -100,80 +101,6 @@ TEST_F(ByteStreamTest, outputStream) {
   EXPECT_EQ(0, mmapAllocator_->numAllocated());
 }
 
-TEST_F(ByteStreamTest, resetInput) {
-  uint8_t* const kFakeBuffer = reinterpret_cast<uint8_t*>(this);
-  std::vector<ByteRange> byteRanges;
-  size_t totalBytes{0};
-  size_t lastRangeEnd;
-  for (int32_t i = 0; i < 32; ++i) {
-    byteRanges.push_back(ByteRange{kFakeBuffer, 4096 + i, 0});
-    totalBytes += 4096 + i;
-  }
-  lastRangeEnd = byteRanges.back().size;
-  ByteStream byteStream;
-  ASSERT_EQ(byteStream.size(), 0);
-  ASSERT_EQ(byteStream.lastRangeEnd(), 0);
-  byteStream.resetInput(std::move(byteRanges));
-  ASSERT_EQ(byteStream.size(), totalBytes);
-  ASSERT_EQ(byteStream.lastRangeEnd(), lastRangeEnd);
-}
-
-TEST_F(ByteStreamTest, remainingSize) {
-  const int32_t kSize = 100;
-  const int32_t kBufferSize = 4096;
-  std::vector<void*> buffers;
-  std::vector<ByteRange> byteRanges;
-  for (int32_t i = 0; i < kSize; i++) {
-    buffers.push_back(pool_->allocate(kBufferSize));
-    byteRanges.push_back(
-        ByteRange{reinterpret_cast<uint8_t*>(buffers.back()), kBufferSize, 0});
-  }
-  ByteStream byteStream;
-  byteStream.resetInput(std::move(byteRanges));
-  const int32_t kReadBytes = 2048;
-  int32_t remainingSize = kSize * kBufferSize;
-  uint8_t* tempBuffer = reinterpret_cast<uint8_t*>(pool_->allocate(kReadBytes));
-  while (byteStream.remainingSize() > 0) {
-    byteStream.readBytes(tempBuffer, kReadBytes);
-    remainingSize -= kReadBytes;
-    ASSERT_EQ(remainingSize, byteStream.remainingSize());
-  }
-  ASSERT_EQ(0, byteStream.remainingSize());
-  for (int32_t i = 0; i < kSize; i++) {
-    pool_->free(buffers[i], kBufferSize);
-  }
-  pool_->free(tempBuffer, kReadBytes);
-}
-
-TEST_F(ByteStreamTest, toString) {
-  const int32_t kSize = 10;
-  const int32_t kBufferSize = 4096;
-  std::vector<void*> buffers;
-  std::vector<ByteRange> byteRanges;
-  for (int32_t i = 0; i < kSize; i++) {
-    buffers.push_back(pool_->allocate(kBufferSize));
-    byteRanges.push_back(
-        ByteRange{reinterpret_cast<uint8_t*>(buffers.back()), kBufferSize, 0});
-  }
-  ByteStream byteStream;
-  byteStream.resetInput(std::move(byteRanges));
-  const int32_t kReadBytes = 2048;
-  uint8_t* tempBuffer = reinterpret_cast<uint8_t*>(pool_->allocate(kReadBytes));
-  for (int32_t i = 0; i < kSize / 2; i++) {
-    byteStream.readBytes(tempBuffer, kReadBytes);
-  }
-  std::string byteStreamStr = byteStream.toString();
-  EXPECT_EQ(
-      byteStreamStr,
-      "ByteStream[lastRangeEnd 4096, 10 ranges "
-      "(position/size) [(4096/4096),(4096/4096),(2048/4096 current),"
-      "(0/4096),(0/4096),(0/4096),(0/4096),(0/4096),(0/4096),(0/4096)]]");
-  for (int32_t i = 0; i < kSize; i++) {
-    pool_->free(buffers[i], kBufferSize);
-  }
-  pool_->free(tempBuffer, kReadBytes);
-}
-
 TEST_F(ByteStreamTest, newRangeAllocation) {
   const int kPageSize = AllocationTraits::kPageSize;
   struct {
@@ -241,7 +168,7 @@ TEST_F(ByteStreamTest, newRangeAllocation) {
 
     const auto prevAllocCount = pool_->stats().numAllocs;
     auto arena = newArena();
-    ByteStream byteStream(arena.get());
+    ByteOutputStream byteStream(arena.get());
     byteStream.startWrite(0);
     for (int i = 0; i < testData.newRangeSizes.size(); ++i) {
       const auto newRangeSize = testData.newRangeSizes[i];
@@ -249,8 +176,8 @@ TEST_F(ByteStreamTest, newRangeAllocation) {
           "iteration {} allocation size {}",
           i,
           succinctBytes(testData.newRangeSizes[i])));
-      byteStream.appendStringPiece(
-          folly::StringPiece(std::string(newRangeSize, 'a')));
+      std::string value(newRangeSize, 'a');
+      byteStream.appendStringView(value);
       ASSERT_EQ(arena->size(), testData.expectedArenaAllocationSizes[i]);
       ASSERT_EQ(
           pool_->stats().numAllocs - prevAllocCount,
@@ -265,9 +192,9 @@ TEST_F(ByteStreamTest, newRangeAllocation) {
 TEST_F(ByteStreamTest, randomRangeAllocationFromMultiStreamsTest) {
   auto arena = newArena();
   const int numByteStreams = 10;
-  std::vector<std::unique_ptr<ByteStream>> byteStreams;
+  std::vector<std::unique_ptr<ByteOutputStream>> byteStreams;
   for (int i = 0; i < numByteStreams; ++i) {
-    byteStreams.push_back(std::make_unique<ByteStream>(arena.get()));
+    byteStreams.push_back(std::make_unique<ByteOutputStream>(arena.get()));
     byteStreams.back()->startWrite(0);
   }
   const int testIterations = 1000;
@@ -284,9 +211,365 @@ TEST_F(ByteStreamTest, randomRangeAllocationFromMultiStreamsTest) {
       } break;
       case 2: {
         const int size = folly::Random::rand32(rng_) % 8192 + 1;
-        byteStream->appendStringPiece(
-            folly::StringPiece(std::string(size, 'a')));
+        const std::string value(size, 'a');
+        byteStream->appendStringView(value);
       } break;
     }
   }
 }
+
+TEST_F(ByteStreamTest, bits) {
+  std::vector<uint64_t> bits;
+  uint64_t seed = 0x12345689abcdefLLU;
+  for (auto i = 0; i < 1000; ++i) {
+    bits.push_back(seed * (i + 1));
+  }
+  auto arena = newArena();
+  ByteOutputStream bitStream(arena.get(), true);
+  bitStream.startWrite(11);
+  int32_t offset = 0;
+  // Odd number of sizes.
+  std::vector<int32_t> bitSizes = {1, 19, 52, 58, 129};
+  int32_t counter = 0;
+  auto totalBits = bits.size() * 64;
+  while (offset < totalBits) {
+    // Every second uses the fast path for aligned source and append only.
+    auto numBits = std::min<int32_t>(
+        totalBits - offset, bitSizes[counter % bitSizes.size()]);
+    if (counter % 1 == 0) {
+      bitStream.appendBits(bits.data(), offset, offset + numBits);
+    } else {
+      uint64_t aligned[10];
+      bits::copyBits(bits.data(), offset, aligned, 0, numBits);
+      bitStream.appendBitsFresh(aligned, 0, numBits);
+    }
+    offset += numBits;
+    ++counter;
+  }
+  std::stringstream stringStream;
+  OStreamOutputStream out(&stringStream);
+  bitStream.flush(&out);
+  EXPECT_EQ(
+      0,
+      memcmp(
+          stringStream.str().data(),
+          bits.data(),
+          bits.size() * sizeof(bits[0])));
+}
+
+TEST_F(ByteStreamTest, appendWindow) {
+  // A littel over 1MB. We must test appendss that involve multiple extend()
+  // calls for one window.
+  constexpr int32_t kNumWords = 140000;
+  Scratch scratch;
+  std::vector<uint64_t> words;
+  uint64_t seed = 0x12345689abcdefLLU;
+  words.reserve(kNumWords);
+  for (auto i = 0; i < kNumWords; ++i) {
+    words.push_back(seed * (i + 1));
+  }
+  auto arena = newArena();
+
+  ByteOutputStream stream(arena.get());
+  int32_t offset = 0;
+  std::vector<int32_t> sizes = {1, 19, 52, 58, 129};
+  int32_t counter = 0;
+  while (offset < words.size()) {
+    // there is one large window that spans multiple extend() calls.
+    auto numWords = std::min<int32_t>(
+        words.size() - offset,
+        (counter == 2 ? 130000 : sizes[counter % sizes.size()]));
+    int32_t bytes = -1;
+    {
+      AppendWindow<uint64_t> window(stream, scratch);
+      auto ptr = window.get(numWords);
+      bytes = arena->pool()->usedBytes();
+      memcpy(ptr, words.data() + offset, numWords * sizeof(words[0]));
+      offset += numWords;
+      ++counter;
+    }
+    // We check that there is no allocation at exit of AppendWindow block.k
+    EXPECT_EQ(arena->pool()->usedBytes(), bytes);
+  }
+  std::stringstream stringStream;
+  OStreamOutputStream out(&stringStream);
+  stream.flush(&out);
+  EXPECT_EQ(0, memcmp(stringStream.str().data(), words.data(), words.size()));
+}
+
+TEST_F(ByteStreamTest, byteRange) {
+  ByteRange range;
+  range.size = 0;
+  range.position = 1;
+  ASSERT_EQ(range.availableBytes(), 0);
+  range.size = 1;
+  ASSERT_EQ(range.availableBytes(), 0);
+  range.size = 2;
+  ASSERT_EQ(range.availableBytes(), 1);
+}
+
+TEST_F(ByteStreamTest, reuse) {
+  auto arena = newArena();
+  ByteOutputStream stream(arena.get());
+  char bytes[10000] = {};
+  for (auto i = 0; i < 10; ++i) {
+    arena->clear();
+    stream.startWrite(i * 100);
+    stream.appendStringView(std::string_view(bytes, sizeof(bytes)));
+    EXPECT_EQ(sizeof(bytes), stream.size());
+  }
+}
+
+class InputByteStreamTest : public ByteStreamTest,
+                            public testing::WithParamInterface<bool> {
+ protected:
+  static void SetUpTestCase() {
+    filesystems::registerLocalFileSystem();
+  }
+
+  void SetUp() override {
+    ByteStreamTest::SetUp();
+    tempDirPath_ = exec::test::TempDirectoryPath::create();
+    fs_ = filesystems::getFileSystem(tempDirPath_->getPath(), nullptr);
+  }
+
+  std::unique_ptr<ByteInputStream> createStream(
+      const std::vector<ByteRange>& byteRanges,
+      uint32_t bufferSize = 1024) {
+    if (GetParam()) {
+      return std::make_unique<BufferInputStream>(std::move(byteRanges));
+    } else {
+      const auto filePath =
+          fmt::format("{}/{}", tempDirPath_->getPath(), fileId_++);
+      auto writeFile = fs_->openFileForWrite(filePath);
+      for (auto& byteRange : byteRanges) {
+        writeFile->append(std::string_view(
+            reinterpret_cast<char*>(byteRange.buffer), byteRange.size));
+      }
+      writeFile->close();
+      return std::make_unique<common::FileInputStream>(
+          fs_->openFileForRead(filePath), bufferSize, pool_.get());
+    }
+  }
+
+  std::atomic_uint64_t fileId_{0};
+  std::shared_ptr<exec::test::TempDirectoryPath> tempDirPath_;
+  std::shared_ptr<filesystems::FileSystem> fs_;
+};
+
+TEST_P(InputByteStreamTest, inputStream) {
+  uint8_t kFakeBuffer[8192];
+  std::vector<ByteRange> byteRanges;
+  size_t totalBytes{0};
+  for (int32_t i = 0; i < 32; ++i) {
+    byteRanges.push_back(ByteRange{kFakeBuffer, 4096 + i, 0});
+    totalBytes += 4096 + i;
+  }
+  auto byteStream = createStream(byteRanges);
+  ASSERT_EQ(byteStream->size(), totalBytes);
+  ASSERT_FALSE(byteStream->atEnd());
+  byteStream->skip(totalBytes);
+  ASSERT_TRUE(byteStream->atEnd());
+  if (GetParam()) {
+    VELOX_ASSERT_THROW(
+        byteStream->skip(1),
+        "(32 vs. 32) Reading past end of BufferInputStream");
+  } else {
+    VELOX_ASSERT_THROW(
+        byteStream->skip(1),
+        "(1 vs. 0) Skip past the end of FileInputStream: 131568");
+  }
+  ASSERT_TRUE(byteStream->atEnd());
+}
+
+TEST_P(InputByteStreamTest, emptyInputStreamError) {
+  if (GetParam()) {
+    VELOX_ASSERT_THROW(createStream({}), "Empty BufferInputStream");
+  } else {
+    VELOX_ASSERT_THROW(createStream({}), "(0 vs. 0) Empty FileInputStream");
+  }
+}
+
+TEST_P(InputByteStreamTest, remainingSize) {
+  const int32_t kSize = 100;
+  const int32_t kBufferSize = 4096;
+  std::vector<void*> buffers;
+  std::vector<ByteRange> byteRanges;
+  for (int32_t i = 0; i < kSize; i++) {
+    buffers.push_back(pool_->allocate(kBufferSize));
+    byteRanges.push_back(
+        ByteRange{reinterpret_cast<uint8_t*>(buffers.back()), kBufferSize, 0});
+  }
+  auto byteStream = createStream(byteRanges);
+  const int32_t kReadBytes = 2048;
+  int32_t remainingSize = kSize * kBufferSize;
+  ASSERT_EQ(byteStream->remainingSize(), remainingSize);
+  uint8_t* tempBuffer = reinterpret_cast<uint8_t*>(pool_->allocate(kReadBytes));
+  while (byteStream->remainingSize() > 0) {
+    byteStream->readBytes(tempBuffer, kReadBytes);
+    remainingSize -= kReadBytes;
+    ASSERT_EQ(remainingSize, byteStream->remainingSize());
+  }
+  ASSERT_EQ(byteStream->remainingSize(), 0);
+  for (int32_t i = 0; i < kSize; i++) {
+    pool_->free(buffers[i], kBufferSize);
+  }
+  pool_->free(tempBuffer, kReadBytes);
+}
+
+TEST_P(InputByteStreamTest, toString) {
+  const int32_t kSize = 10;
+  const int32_t kBufferSize = 4096;
+  std::vector<void*> buffers;
+  std::vector<ByteRange> byteRanges;
+  for (int32_t i = 0; i < kSize; i++) {
+    buffers.push_back(pool_->allocate(kBufferSize));
+    byteRanges.push_back(
+        ByteRange{reinterpret_cast<uint8_t*>(buffers.back()), kBufferSize, 0});
+  }
+  auto byteStream = createStream(std::move(byteRanges));
+  const int32_t kReadBytes = 2048;
+  uint8_t* tempBuffer = reinterpret_cast<uint8_t*>(pool_->allocate(kReadBytes));
+  for (int32_t i = 0; i < kSize / 2; i++) {
+    byteStream->readBytes(tempBuffer, kReadBytes);
+  }
+
+  if (GetParam()) {
+    ASSERT_EQ(
+        byteStream->toString(),
+        "10 ranges "
+        "(position/size) [(4096/4096),(4096/4096),(2048/4096 current),"
+        "(0/4096),(0/4096),(0/4096),(0/4096),(0/4096),(0/4096),(0/4096)]");
+  } else {
+    ASSERT_EQ(
+        byteStream->toString(),
+        "file (offset 10.00KB/size 40.00KB) current (position 1.00KB/ size 1.00KB)");
+  }
+
+  for (int32_t i = 0; i < kSize; i++) {
+    pool_->free(buffers[i], kBufferSize);
+  }
+  pool_->free(tempBuffer, kReadBytes);
+}
+
+TEST_P(InputByteStreamTest, readBytesNegativeSize) {
+  constexpr int32_t kBufferSize = 4096;
+  uint8_t buffer[kBufferSize];
+  auto byteStream =
+      createStream(std::vector<ByteRange>{ByteRange{buffer, kBufferSize, 0}});
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+  uint8_t outputBuffer[kBufferSize];
+  VELOX_ASSERT_THROW(
+      byteStream->readBytes(outputBuffer, -100),
+      "(-100 vs. 0) Attempting to read negative number of byte");
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+}
+
+TEST_P(InputByteStreamTest, skipNegativeSize) {
+  constexpr int32_t kBufferSize = 4096;
+  uint8_t buffer[kBufferSize];
+  auto byteStream = std::make_unique<BufferInputStream>(
+      std::vector<ByteRange>{ByteRange{buffer, kBufferSize, 0}});
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+  VELOX_ASSERT_THROW(
+      byteStream->skip(-100),
+      "(-100 vs. 0) Attempting to skip negative number of bytes");
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+}
+
+TEST_P(InputByteStreamTest, nextViewNegativeSize) {
+  constexpr int32_t kBufferSize = 4096;
+  uint8_t buffer[kBufferSize];
+  auto byteStream =
+      createStream(std::vector<ByteRange>{ByteRange{buffer, kBufferSize, 0}});
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+  VELOX_ASSERT_THROW(
+      byteStream->nextView(-100),
+      "(-100 vs. 0) Attempting to view negative number of bytes");
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+}
+
+TEST_P(InputByteStreamTest, view) {
+  SCOPED_TRACE(fmt::format("BufferInputStream: {}", GetParam()));
+  constexpr int32_t kBufferSize = 1024;
+  uint8_t buffer[kBufferSize];
+  constexpr int32_t kNumRanges = 10;
+  std::vector<ByteRange> fakeRanges;
+  fakeRanges.reserve(kNumRanges);
+  for (int i = 0; i < kNumRanges; ++i) {
+    fakeRanges.push_back(ByteRange{buffer, kBufferSize, 0});
+  }
+  auto byteStream = createStream(fakeRanges);
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize * kNumRanges);
+  ASSERT_EQ(byteStream->nextView(kBufferSize / 2).size(), kBufferSize / 2);
+  ASSERT_EQ(byteStream->nextView(kBufferSize).size(), kBufferSize / 2);
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize * (kNumRanges - 1));
+  byteStream->skip(byteStream->remainingSize());
+  ASSERT_EQ(byteStream->remainingSize(), 0);
+  ASSERT_TRUE(byteStream->atEnd());
+  ASSERT_EQ(byteStream->nextView(100).size(), 0);
+}
+
+TEST_P(InputByteStreamTest, tellP) {
+  constexpr int32_t kBufferSize = 4096;
+  uint8_t buffer[kBufferSize];
+  auto byteStream =
+      createStream(std::vector<ByteRange>{ByteRange{buffer, kBufferSize, 0}});
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+  byteStream->readBytes(buffer, kBufferSize / 2);
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize / 2);
+  ASSERT_EQ(byteStream->tellp(), kBufferSize / 2);
+  byteStream->skip(kBufferSize / 2);
+  ASSERT_EQ(byteStream->remainingSize(), 0);
+  ASSERT_EQ(byteStream->tellp(), kBufferSize);
+}
+
+TEST_P(InputByteStreamTest, skip) {
+  constexpr int32_t kBufferSize = 4096;
+  uint8_t buffer[kBufferSize];
+  auto byteStream =
+      createStream(std::vector<ByteRange>{ByteRange{buffer, kBufferSize, 0}});
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+  byteStream->skip(0);
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+  byteStream->skip(1);
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize - 1);
+  if (GetParam()) {
+    VELOX_ASSERT_THROW(
+        byteStream->skip(kBufferSize),
+        "(1 vs. 1) Reading past end of BufferInputStream");
+    ASSERT_EQ(byteStream->remainingSize(), 0);
+    ASSERT_TRUE(byteStream->atEnd());
+  } else {
+    VELOX_ASSERT_THROW(
+        byteStream->skip(kBufferSize),
+        "(4096 vs. 4095) Skip past the end of FileInputStream: 4096");
+    ASSERT_EQ(byteStream->remainingSize(), kBufferSize - 1);
+    ASSERT_FALSE(byteStream->atEnd());
+  }
+}
+
+TEST_P(InputByteStreamTest, seekp) {
+  constexpr int32_t kBufferSize = 4096;
+  uint8_t buffer[kBufferSize];
+  auto byteStream =
+      createStream(std::vector<ByteRange>{ByteRange{buffer, kBufferSize, 0}});
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize);
+  byteStream->seekp(kBufferSize / 2);
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize / 2);
+  byteStream->seekp(kBufferSize / 2);
+  ASSERT_EQ(byteStream->remainingSize(), kBufferSize / 2);
+  if (GetParam()) {
+    byteStream->seekp(kBufferSize / 4);
+    ASSERT_EQ(byteStream->remainingSize(), kBufferSize / 2 + kBufferSize / 4);
+  } else {
+    VELOX_ASSERT_THROW(
+        byteStream->seekp(kBufferSize / 4),
+        "(1024 vs. 2048) Backward seek is not supported by FileInputStream");
+  }
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    InputByteStreamTest,
+    InputByteStreamTest,
+    testing::ValuesIn({false, true}));
diff --git a/velox/common/memory/tests/CMakeLists.txt b/velox/common/memory/tests/CMakeLists.txt
index 94821e05f4fd9..8fd55b025f493 100644
--- a/velox/common/memory/tests/CMakeLists.txt
+++ b/velox/common/memory/tests/CMakeLists.txt
@@ -12,13 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 include(GoogleTest)
+
 add_executable(
   velox_memory_test
+  AllocationPoolTest.cpp
   AllocationTest.cpp
   ByteStreamTest.cpp
   CompactDoubleListTest.cpp
   HashStringAllocatorTest.cpp
-  AllocationPoolTest.cpp
   MemoryAllocatorTest.cpp
   MemoryArbitratorTest.cpp
   MemoryCapExceededTest.cpp
@@ -30,33 +31,36 @@ add_executable(
 
 target_link_libraries(
   velox_memory_test
-  PRIVATE velox_caching
-          velox_common_base
-          velox_exception
-          velox_exec
-          velox_exec_test_lib
-          velox_memory
-          velox_temp_path
-          velox_test_util
-          velox_vector_fuzzer
-          Folly::folly
-          gflags::gflags
-          glog::glog
-          gmock
-          gtest
-          gtest_main
-          re2::re2)
+  PRIVATE
+    velox_caching
+    velox_common_base
+    velox_exception
+    velox_exec
+    velox_exec_test_lib
+    velox_memory
+    velox_temp_path
+    velox_test_util
+    velox_vector_fuzzer
+    Folly::folly
+    fmt::fmt
+    gflags::gflags
+    glog::glog
+    GTest::gmock
+    GTest::gtest
+    GTest::gtest_main
+    re2::re2)
 
 gtest_add_tests(velox_memory_test "" AUTO)
 
 add_executable(velox_fragmentation_benchmark FragmentationBenchmark.cpp)
 
 target_link_libraries(
-  velox_fragmentation_benchmark PRIVATE velox_memory Folly::folly
-                                        gflags::gflags glog::glog)
+  velox_fragmentation_benchmark
+  PRIVATE velox_memory Folly::folly gflags::gflags glog::glog)
 
 add_executable(velox_concurrent_allocation_benchmark
                ConcurrentAllocationBenchmark.cpp)
 
-target_link_libraries(velox_concurrent_allocation_benchmark PRIVATE velox_memory
-                                                                    velox_time)
+target_link_libraries(
+  velox_concurrent_allocation_benchmark
+  PRIVATE velox_memory velox_time)
diff --git a/velox/common/memory/tests/ConcurrentAllocationBenchmark.cpp b/velox/common/memory/tests/ConcurrentAllocationBenchmark.cpp
index 5d4623744d19b..406004ccece67 100644
--- a/velox/common/memory/tests/ConcurrentAllocationBenchmark.cpp
+++ b/velox/common/memory/tests/ConcurrentAllocationBenchmark.cpp
@@ -34,6 +34,10 @@ DEFINE_uint32(
     memory_allocator_type,
     0,
     "The type of memory allocator. 0 is malloc allocator, 1 is mmap allocator");
+DEFINE_uint32(
+    memory_allocation_type,
+    0,
+    "The type of memory allocation. 0 is small allocation, 1 non-contiguous allocation");
 DEFINE_uint32(
     num_runs,
     32,
@@ -67,10 +71,17 @@ class MemoryOperator {
   }
 
  private:
-  struct Allocation {
+  struct SmallAllocation {
     void* ptr;
 
-    explicit Allocation(void* _ptr) : ptr(_ptr) {}
+    explicit SmallAllocation(void* _ptr) : ptr(_ptr) {}
+  };
+
+  struct NonContiguousAllocation {
+    std::unique_ptr<memory::Allocation> allocation;
+
+    NonContiguousAllocation()
+        : allocation(std::make_unique<memory::Allocation>()) {}
   };
 
   bool full() const;
@@ -79,18 +90,26 @@ class MemoryOperator {
 
   void free();
 
+  int randomAllocationIndex() const;
+
   void cleanup();
 
+  void freeSmallAllocation(SmallAllocation& allocation);
+
+  void freeNonContiguousAllocation(NonContiguousAllocation& allocation);
+
   static inline int32_t poolId_{0};
 
   const uint64_t maxMemory_;
   const size_t allocationBytes_;
+  const uint32_t allocationType_{FLAGS_memory_allocation_type};
   const uint32_t maxOps_;
   const std::shared_ptr<MemoryPool> pool_;
 
-  folly::Random::DefaultGenerator rng_;
+  mutable folly::Random::DefaultGenerator rng_;
   uint64_t allocatedBytes_{0};
-  std::deque<Allocation> allocations_;
+  std::deque<SmallAllocation> smallAllocations_;
+  std::deque<NonContiguousAllocation> nonContiguousAllocations_;
   uint64_t clockCount_{0};
 };
 
@@ -107,29 +126,70 @@ void MemoryOperator::allocate() {
   }
   {
     ClockTimer cpuTimer(clockCount_);
-    allocations_.emplace_back(pool_->allocate(allocationBytes_));
+    if (allocationType_ == 0) {
+      smallAllocations_.emplace_back(pool_->allocate(allocationBytes_));
+    } else {
+      NonContiguousAllocation nonContiguousAllocation;
+      pool_->allocateNonContiguous(
+          memory::AllocationTraits::numPages(allocationBytes_),
+          *nonContiguousAllocation.allocation);
+      nonContiguousAllocations_.emplace_back(
+          std::move(nonContiguousAllocation));
+    }
   }
   allocatedBytes_ += allocationBytes_;
 }
 
 void MemoryOperator::free() {
-  const int freeIdx = folly::Random::rand32(rng_) % allocations_.size();
-  Allocation freeAllocation = allocations_[freeIdx];
-  allocations_[freeIdx] = allocations_.back();
-  allocations_.pop_back();
+  const int freeIdx = randomAllocationIndex();
+  if (allocationType_ == 0) {
+    SmallAllocation allocation = smallAllocations_[freeIdx];
+    smallAllocations_[freeIdx] = smallAllocations_.back();
+    smallAllocations_.pop_back();
+
+    freeSmallAllocation(allocation);
+  } else {
+    NonContiguousAllocation allocation =
+        std::move(nonContiguousAllocations_[freeIdx]);
+    nonContiguousAllocations_[freeIdx] =
+        std::move(nonContiguousAllocations_.back());
+    nonContiguousAllocations_.pop_back();
+
+    freeNonContiguousAllocation(allocation);
+  }
+}
+
+int MemoryOperator::randomAllocationIndex() const {
+  const int randIdx = folly::Random::rand32(rng_);
+  if (allocationType_ == 0) {
+    return randIdx % smallAllocations_.size();
+  }
+  return randIdx % nonContiguousAllocations_.size();
+}
+
+void MemoryOperator::freeSmallAllocation(SmallAllocation& allocation) {
   {
     ClockTimer cpuTimer(clockCount_);
-    pool_->free(freeAllocation.ptr, allocationBytes_);
+    pool_->free(allocation.ptr, allocationBytes_);
+  }
+  allocatedBytes_ -= allocationBytes_;
+}
+
+void MemoryOperator::freeNonContiguousAllocation(
+    NonContiguousAllocation& alllocation) {
+  {
+    ClockTimer cpuTimer(clockCount_);
+    pool_->freeNonContiguous(*alllocation.allocation);
   }
   allocatedBytes_ -= allocationBytes_;
 }
 
 void MemoryOperator::cleanup() {
-  for (const auto& allocation : allocations_) {
-    {
-      ClockTimer cpuTimer(clockCount_);
-      pool_->free(allocation.ptr, allocationBytes_);
-    }
+  for (auto& allocation : smallAllocations_) {
+    freeSmallAllocation(allocation);
+  }
+  for (auto& allocation : nonContiguousAllocations_) {
+    freeNonContiguousAllocation(allocation);
   }
 }
 
@@ -157,15 +217,12 @@ class MemoryAllocationBenchMark {
     const int64_t maxMemory = options_.maxMemory + (256 << 20);
     switch (options_.allocatorType) {
       case Type::kMmap: {
-        memory::MmapAllocator::Options mmapOptions;
-        mmapOptions.capacity = maxMemory;
-        allocator_ = std::make_shared<MmapAllocator>(mmapOptions);
         manager_ = std::make_shared<MemoryManager>(MemoryManagerOptions{
-            .capacity = maxMemory, .allocator = allocator_.get()});
+            .allocatorCapacity = maxMemory, .useMmapAllocator = true});
       } break;
       case Type::kMalloc:
         manager_ = std::make_shared<MemoryManager>(
-            MemoryManagerOptions{.capacity = maxMemory});
+            MemoryManagerOptions{.allocatorCapacity = maxMemory});
         break;
       default:
         VELOX_USER_FAIL(
@@ -188,7 +245,6 @@ class MemoryAllocationBenchMark {
   };
 
   const Options options_;
-  std::shared_ptr<MmapAllocator> allocator_;
   std::shared_ptr<MemoryManager> manager_;
   std::vector<Result> results_;
 };
diff --git a/velox/common/memory/tests/FragmentationBenchmark.cpp b/velox/common/memory/tests/FragmentationBenchmark.cpp
index 455c4a420ead3..eb9124f2235ca 100644
--- a/velox/common/memory/tests/FragmentationBenchmark.cpp
+++ b/velox/common/memory/tests/FragmentationBenchmark.cpp
@@ -34,19 +34,21 @@ using namespace facebook::velox;
 using namespace facebook::velox::memory;
 
 struct Block {
-  explicit Block(MemoryAllocator& _allocator) : allocator(_allocator) {}
+  explicit Block(MemoryAllocator* _allocator) : allocator(_allocator) {}
 
   ~Block() {
     if (data != nullptr) {
       free(data);
     }
-    if (allocation != nullptr) {
-      allocator.freeNonContiguous(*allocation);
+    if (allocator != nullptr) {
+      if (allocation != nullptr) {
+        allocator->freeNonContiguous(*allocation);
+      }
+      allocator->freeContiguous(contiguous);
     }
-    allocator.freeContiguous(contiguous);
   }
 
-  MemoryAllocator& allocator;
+  MemoryAllocator* allocator;
   size_t size = 0;
   char* data = nullptr;
   std::shared_ptr<Allocation> allocation;
@@ -91,7 +93,7 @@ class FragmentationTest {
   }
 
   void allocate(size_t size) {
-    auto block = std::make_unique<Block>(*memory_);
+    auto block = std::make_unique<Block>(memory_.get());
     block->size = size;
     if (memory_) {
       if (size <= 8 << 20) {
diff --git a/velox/common/memory/tests/HashStringAllocatorTest.cpp b/velox/common/memory/tests/HashStringAllocatorTest.cpp
index 6784eb5e44625..124220d4d57f0 100644
--- a/velox/common/memory/tests/HashStringAllocatorTest.cpp
+++ b/velox/common/memory/tests/HashStringAllocatorTest.cpp
@@ -36,8 +36,12 @@ struct Multipart {
 
 class HashStringAllocatorTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::initialize({});
+  }
+
   void SetUp() override {
-    pool_ = memory::addDefaultLeafMemoryPool();
+    pool_ = memory::memoryManager()->addLeafPool();
     allocator_ = std::make_unique<HashStringAllocator>(pool_.get());
     rng_.seed(1);
   }
@@ -51,7 +55,8 @@ class HashStringAllocatorTest : public testing::Test {
 
   void initializeContents(HSA::Header* header) {
     auto sequence = ++sequence_;
-    int32_t numWords = header->size() / sizeof(void*);
+    int32_t numWords =
+        header->size() / HashStringAllocator::Header::kContinuedPtrSize;
     void** ptr = reinterpret_cast<void**>(header->begin());
     ptr[0] = reinterpret_cast<void*>(sequence);
     for (int32_t offset = 1; offset < numWords; offset++) {
@@ -95,6 +100,48 @@ class HashStringAllocatorTest : public testing::Test {
   folly::Random::DefaultGenerator rng_;
 };
 
+TEST_F(HashStringAllocatorTest, multipleFree) {
+  ASSERT_NO_THROW(allocator_->toString());
+
+  auto h1 = allocate(123);
+  ASSERT_EQ(h1->toString(), "size: 123");
+
+  allocator_->free(h1);
+  // Running free() multiple times on the same memory block should result in an
+  // error.
+  VELOX_ASSERT_THROW(allocator_->free(h1), "");
+}
+
+TEST_F(HashStringAllocatorTest, multipleFreeAncCheckCurrentBytes) {
+  ASSERT_NO_THROW(allocator_->toString());
+
+  auto h1 = allocate(123);
+  auto h2 = allocate(456);
+  auto h3 = allocate(789);
+
+  ASSERT_EQ(h1->toString(), "size: 123");
+  ASSERT_EQ(h2->toString(), "size: 456");
+  ASSERT_EQ(h3->toString(), "size: 789");
+
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+
+  allocator_->free(h3);
+  allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+
+  allocator_->free(h2);
+  allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+
+  allocator_->free(h1);
+  allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+
+  // After all blocks execute free(), the allocated bytes should be equal to 0.
+  ASSERT_EQ(allocator_->currentBytes(), 0);
+}
+
 TEST_F(HashStringAllocatorTest, headerToString) {
   ASSERT_NO_THROW(allocator_->toString());
 
@@ -113,10 +160,10 @@ TEST_F(HashStringAllocatorTest, headerToString) {
 
   ASSERT_NO_THROW(allocator_->toString());
 
-  ByteStream stream(allocator_.get());
+  ByteOutputStream stream(allocator_.get());
   auto h4 = allocator_->newWrite(stream).header;
   std::string data(123'456, 'x');
-  stream.appendStringPiece(folly::StringPiece(data.data(), data.size()));
+  stream.appendStringView(data);
   allocator_->finishWrite(stream, 0);
 
   ASSERT_EQ(h4->toString(), "|multipart| size: 123 [64913, 58436]");
@@ -137,7 +184,8 @@ TEST_F(HashStringAllocatorTest, allocate) {
       headers.push_back(allocate((i % 10) * 10));
     }
     EXPECT_FALSE(allocator_->isEmpty());
-    allocator_->checkConsistency();
+    auto allocatedBytes = allocator_->checkConsistency();
+    ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
     for (int32_t step = 7; step >= 1; --step) {
       for (auto i = 0; i < headers.size(); i += step) {
         if (headers[i]) {
@@ -145,7 +193,8 @@ TEST_F(HashStringAllocatorTest, allocate) {
           headers[i] = nullptr;
         }
       }
-      allocator_->checkConsistency();
+      allocatedBytes = allocator_->checkConsistency();
+      ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
     }
   }
   EXPECT_TRUE(allocator_->isEmpty());
@@ -164,11 +213,11 @@ TEST_F(HashStringAllocatorTest, allocateLarge) {
 }
 
 TEST_F(HashStringAllocatorTest, finishWrite) {
-  ByteStream stream(allocator_.get());
+  ByteOutputStream stream(allocator_.get());
   auto start = allocator_->newWrite(stream);
 
   // Write a short string.
-  stream.appendStringPiece(folly::StringPiece("abc"));
+  stream.appendStringView(std::string_view("abc"));
   auto [firstStart, firstFinish] = allocator_->finishWrite(stream, 0);
 
   ASSERT_EQ(start.header, firstStart.header);
@@ -177,8 +226,8 @@ TEST_F(HashStringAllocatorTest, finishWrite) {
   // Replace short string with a long string that uses two bytes short of
   // available space.
   allocator_->extendWrite(start, stream);
-  auto longString = std::string(start.header->size() - 2, 'x');
-  stream.appendStringPiece(folly::StringPiece(longString));
+  std::string longString(start.header->size() - 2, 'x');
+  stream.appendStringView(longString);
   auto [longStart, longFinish] = allocator_->finishWrite(stream, 0);
 
   ASSERT_EQ(start.header, longStart.header);
@@ -186,7 +235,7 @@ TEST_F(HashStringAllocatorTest, finishWrite) {
 
   // Append another string after the long string.
   allocator_->extendWrite(longFinish, stream);
-  stream.appendStringPiece(folly::StringPiece("abc"));
+  stream.appendStringView(std::string_view("abc"));
   auto [appendStart, appendFinish] = allocator_->finishWrite(stream, 0);
 
   ASSERT_NE(appendStart.header, longFinish.header);
@@ -196,7 +245,7 @@ TEST_F(HashStringAllocatorTest, finishWrite) {
 
   // Replace last string.
   allocator_->extendWrite(appendStart, stream);
-  stream.appendStringPiece(folly::StringPiece("abcd"));
+  stream.appendStringView(std::string_view("abcd"));
   auto [replaceStart, replaceFinish] = allocator_->finishWrite(stream, 0);
 
   ASSERT_EQ(appendStart.header, replaceStart.header);
@@ -205,18 +254,19 @@ TEST_F(HashStringAllocatorTest, finishWrite) {
       replaceStart.offset() + 4);
 
   // Read back long and short strings.
-  HSA::prepareRead(longStart.header, stream);
+  auto inputStream = HSA::prepareRead(longStart.header);
 
   std::string copy;
   copy.resize(longString.size());
-  stream.readBytes(copy.data(), copy.size());
+  inputStream->readBytes(copy.data(), copy.size());
   ASSERT_EQ(copy, longString);
 
   copy.resize(4);
-  stream.readBytes(copy.data(), 4);
+  inputStream->readBytes(copy.data(), 4);
   ASSERT_EQ(copy, "abcd");
 
-  allocator_->checkConsistency();
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
 
   std::vector<int32_t> sizes = {
       50000, 100000, 200000, 1000000, 3000000, 5000000};
@@ -224,15 +274,16 @@ TEST_F(HashStringAllocatorTest, finishWrite) {
     auto largeString = randomString(size);
 
     auto start = allocator_->newWrite(stream);
-    stream.appendStringPiece(folly::StringPiece(largeString));
+    stream.appendStringView(largeString);
     allocator_->finishWrite(stream, 0);
 
-    HSA::prepareRead(start.header, stream);
+    auto inStream = HSA::prepareRead(start.header);
     std::string copy;
     copy.resize(largeString.size());
-    stream.readBytes(copy.data(), copy.size());
+    inStream->readBytes(copy.data(), copy.size());
     ASSERT_EQ(copy, largeString);
-    allocator_->checkConsistency();
+    allocatedBytes = allocator_->checkConsistency();
+    ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
   }
 }
 
@@ -246,7 +297,7 @@ TEST_F(HashStringAllocatorTest, multipart) {
         continue;
       }
       auto chars = randomString();
-      ByteStream stream(allocator_.get());
+      ByteOutputStream stream(allocator_.get());
       if (data[i].start.header) {
         if (rand32() % 5) {
           // 4/5 of cases append to the end.
@@ -263,13 +314,14 @@ TEST_F(HashStringAllocatorTest, multipart) {
         EXPECT_EQ(
             data[i].start.header, HSA::headerOf(stream.ranges()[0].buffer));
       }
-      stream.appendStringPiece(folly::StringPiece(chars.data(), chars.size()));
+      stream.appendStringView(chars);
       auto reserve = rand32() % 100;
       data[i].current = allocator_->finishWrite(stream, reserve).second;
       data[i].reference.insert(
           data[i].reference.end(), chars.begin(), chars.end());
     }
-    allocator_->checkConsistency();
+    auto allocatedBytes = allocator_->checkConsistency();
+    ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
   }
   for (const auto& d : data) {
     if (d.start.isSet()) {
@@ -279,14 +331,48 @@ TEST_F(HashStringAllocatorTest, multipart) {
   for (auto& d : data) {
     if (d.start.isSet()) {
       checkAndFree(d);
-      allocator_->checkConsistency();
+      auto allocatedBytes = allocator_->checkConsistency();
+      ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
     }
   }
-  allocator_->checkConsistency();
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+}
+
+TEST_F(HashStringAllocatorTest, mixedMultipart) {
+  // Create multi-part allocation with a mix of block allocated from Arena and
+  // MemoryPool.
+
+  const std::string shortString(25, 'x');
+  const std::string extraLongString(5'000, 'y');
+
+  ByteOutputStream stream(allocator_.get());
+
+  auto start = allocator_->newWrite(stream);
+  stream.appendStringView(shortString);
+  auto current = allocator_->finishWrite(stream, 0);
+
+  allocator_->extendWrite(current.second, stream);
+
+  ByteRange range;
+  allocator_->newContiguousRange(extraLongString.size(), &range);
+  stream.setRange(range, 0);
+
+  stream.appendStringView(extraLongString);
+  current = allocator_->finishWrite(stream, 0);
+
+  allocator_->extendWrite(current.second, stream);
+  stream.appendStringView(shortString);
+  allocator_->finishWrite(stream, 0);
+
+  allocator_->free(start.header);
+
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
 }
 
 TEST_F(HashStringAllocatorTest, rewrite) {
-  ByteStream stream(allocator_.get());
+  ByteOutputStream stream(allocator_.get());
   auto header = allocator_->allocate(5);
   EXPECT_EQ(16, header->size()); // Rounds up to kMinAlloc.
   HSA::Position current = HSA::Position::atOffset(header, 0);
@@ -310,10 +396,10 @@ TEST_F(HashStringAllocatorTest, rewrite) {
     stream.appendOne(67890LL);
     position = allocator_->finishWrite(stream, 0).second;
     EXPECT_EQ(3 * sizeof(int64_t), HSA::offset(header, position));
-    HSA::prepareRead(header, stream);
-    EXPECT_EQ(123456789012345LL, stream.read<int64_t>());
-    EXPECT_EQ(12345LL, stream.read<int64_t>());
-    EXPECT_EQ(67890LL, stream.read<int64_t>());
+    auto inStream = HSA::prepareRead(header);
+    EXPECT_EQ(123456789012345LL, inStream->read<int64_t>());
+    EXPECT_EQ(12345LL, inStream->read<int64_t>());
+    EXPECT_EQ(67890LL, inStream->read<int64_t>());
   }
   // The stream contains 3 int64_t's.
   auto end = HSA::seek(header, 3 * sizeof(int64_t));
@@ -363,7 +449,8 @@ TEST_F(HashStringAllocatorTest, stlAllocator) {
     }
   }
 
-  allocator_->checkConsistency();
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
 
   // We allow for some overhead for free lists after all is freed.
   EXPECT_LE(allocator_->retainedSize() - allocator_->freeSpace(), 100);
@@ -398,10 +485,11 @@ TEST_F(HashStringAllocatorTest, stlAllocatorWithSet) {
     }
   }
 
-  allocator_->checkConsistency();
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
 
   // We allow for some overhead for free lists after all is freed.
-  EXPECT_LE(allocator_->retainedSize() - allocator_->freeSpace(), 180);
+  EXPECT_LE(allocator_->retainedSize() - allocator_->freeSpace(), 220);
 }
 
 TEST_F(HashStringAllocatorTest, alignedStlAllocatorWithF14Map) {
@@ -435,13 +523,33 @@ TEST_F(HashStringAllocatorTest, alignedStlAllocatorWithF14Map) {
     }
   }
 
-  allocator_->checkConsistency();
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
 
   // We allow for some overhead for free lists after all is freed. Map tends to
   // generate more free blocks at the end, so we loosen the upper bound a bit.
   EXPECT_LE(allocator_->retainedSize() - allocator_->freeSpace(), 130);
 }
 
+TEST_F(HashStringAllocatorTest, alignedStlAllocatorLargeAllocation) {
+  const auto allocateSize = 1ULL << 10;
+
+  // Test large allocation + aligned pool.
+  AlignedStlAllocator<int64_t, 16> alignedAlloc16(allocator_.get());
+  int64_t* ptr = alignedAlloc16.allocate(allocateSize);
+  alignedAlloc16.deallocate(ptr, allocateSize);
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+
+  // Test large allocation + un-aligned pool.
+  ASSERT_LT(allocator_->pool()->alignment(), 128);
+  AlignedStlAllocator<int64_t, 128> alignedAlloc128(allocator_.get());
+  ptr = alignedAlloc128.allocate(allocateSize);
+  alignedAlloc128.deallocate(ptr, allocateSize);
+  allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+}
+
 TEST_F(HashStringAllocatorTest, stlAllocatorOverflow) {
   StlAllocator<int64_t> alloc(allocator_.get());
   VELOX_ASSERT_THROW(alloc.allocate(1ULL << 62), "integer overflow");
@@ -451,60 +559,211 @@ TEST_F(HashStringAllocatorTest, stlAllocatorOverflow) {
 
 TEST_F(HashStringAllocatorTest, externalLeak) {
   constexpr int32_t kSize = HashStringAllocator ::kMaxAlloc * 10;
-  auto root =
-      memory::MemoryManager::getInstance().addRootPool("HSALeakTestRoot");
+  auto root = memory::memoryManager()->addRootPool("HSALeakTestRoot");
   auto pool = root->addLeafChild("HSALeakLeaf");
-  auto initialBytes = pool->currentBytes();
+  auto initialBytes = pool->usedBytes();
   auto allocator = std::make_unique<HashStringAllocator>(pool.get());
 
   for (auto i = 0; i < 100; ++i) {
     allocator->allocate(kSize);
   }
-  EXPECT_LE(100 * kSize, pool->currentBytes());
+  EXPECT_LE(100 * kSize, pool->usedBytes());
 
   StlAllocator<char> stlAlloc(allocator.get());
   for (auto i = 0; i < 100; ++i) {
     stlAlloc.allocate(kSize);
   }
-  EXPECT_LE(200 * kSize, pool->currentBytes());
+  EXPECT_LE(200 * kSize, pool->usedBytes());
   allocator->clear();
-  EXPECT_GE(initialBytes + 1000, pool->currentBytes());
+  EXPECT_GE(initialBytes + 1000, pool->usedBytes());
 
   allocator.reset();
-  EXPECT_EQ(initialBytes, pool->currentBytes());
+  EXPECT_EQ(initialBytes, pool->usedBytes());
 }
 
 TEST_F(HashStringAllocatorTest, freeLists) {
-  auto sizes = HashStringAllocator::freeListSizeClasses();
+  constexpr int kSize = 100'000;
+  constexpr int kSmall = 17;
+  constexpr int kMedium = kSmall + 1;
+  constexpr int kLarge = 128;
   std::vector<HashStringAllocator::Header*> allocations;
-  // We make alternating allocations of different free list size
-  // classes. We free the small ones. We allocate a larger size from
-  // the same size class, This reads the free list and moves to a
-  // larger list. On the second time around, this remembers that the
-  // smaller fre list dies not have entries of that size.
-  auto small = sizes[1] + 2;
-  auto larger = sizes[2] + 2;
-  for (auto i = 0; i < 100; ++i) {
-    allocations.push_back(allocator_->allocate(i == 0 ? small + 10 : small));
-    allocations.push_back(allocator_->allocate(larger));
+  for (int i = 0; i < 2 * kSize; ++i) {
+    allocations.push_back(allocator_->allocate(i < kSize ? kMedium : kSmall));
+    allocations.push_back(allocator_->allocate(kLarge));
   }
-  for (auto i = 0; i < allocations.size(); i += 2) {
+  // Release medium blocks, then small ones.
+  for (int i = 0; i < allocations.size(); i += 2) {
     allocator_->free(allocations[i]);
   }
-  allocations[0] = allocator_->allocate(small);
-  // This comes from head of free list.
-  EXPECT_EQ(0, allocator_->numFreeListNoFit());
-  allocations[2] = allocator_->allocate(small + 10);
-  // Last in free llist fits.
-  EXPECT_EQ(98, allocator_->numFreeListNoFit());
-  allocations[4] = allocator_->allocate(small + 10);
-  // Traverse the free list again but no fit.
-  EXPECT_EQ(2 * 98, allocator_->numFreeListNoFit());
-  allocations[6] = allocator_->allocate(small + 10);
-  // Now we know there is no fit in the list for small, so it is not
-  // retraversed.
-  EXPECT_EQ(2 * 98, allocator_->numFreeListNoFit());
+  // Make sure we don't traverse the whole small free list while looking for
+  // medium free blocks.
+  auto t0 = std::chrono::steady_clock::now();
+  for (int i = 0; i < kSize; ++i) {
+    allocator_->allocate(kSmall + 1);
+  }
+  ASSERT_LT(std::chrono::steady_clock::now() - t0, std::chrono::seconds(30));
+}
+
+TEST_F(HashStringAllocatorTest, strings) {
+  constexpr uint64_t kMagic1 = 0x133788a07;
+  constexpr uint64_t kMagic2 = 0xe7ababe11e;
+  std::vector<std::string> strings;
+  std::vector<StringView> views;
+  for (auto i = 0; i < 20000; ++i) {
+    std::string str;
+    auto freeBytes = allocator_->freeSpace();
+    if (freeBytes > 20 && freeBytes < 120) {
+      // Target the next allocation to take all of the last free block.
+      str.resize(freeBytes - 15);
+    } else {
+      if (i % 11 == 0) {
+        str.resize((i * kMagic1) % 6001);
+      } else {
+        str.resize(24 + (i % 22));
+      }
+    }
+    for (auto c = 0; c < str.size(); ++c) {
+      str[c] = ((c + i) % 64) + 32;
+    }
+    if (i > 0 && i % 3 == 0) {
+      auto freeIdx = ((i * kMagic2) % views.size());
+      if (!strings[freeIdx].empty()) {
+        strings[freeIdx].clear();
+        allocator_->free(HashStringAllocator::headerOf(views[i].data()));
+      }
+    }
+    strings.push_back(str);
+    views.push_back(StringView(str.data(), str.size()));
+    allocator_->copyMultipart(views[i], reinterpret_cast<char*>(&views[i]), 0);
+    if (i % 10 == 0) {
+      auto allocatedBytes = allocator_->checkConsistency();
+      ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+    }
+  }
+  for (auto i = 0; i < strings.size(); ++i) {
+    if (strings[i].empty()) {
+      continue;
+    }
+    std::string temp;
+    ASSERT_TRUE(
+        StringView(strings[i]) ==
+        HashStringAllocator::contiguousString(views[i], temp));
+  }
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
 }
 
+TEST_F(HashStringAllocatorTest, sizeAndPosition) {
+  // We make a stream consisting of multiple non-contiguous ranges
+  // and verify that it is writable and appendable and that its
+  // size() always reflects the number of written bytes, excluding
+  // any overheads.
+
+  // First, we make a free list to make sure things are multipart.
+  constexpr int32_t kUnitSize = 256;
+  std::vector<HashStringAllocator::Header*> pieces;
+  for (auto i = 0; i < 100; ++i) {
+    pieces.push_back(allocator_->allocate(kUnitSize + 30));
+  }
+  for (auto i = 0; i < pieces.size(); i += 2) {
+    allocator_->free(pieces[i]);
+  }
+
+  // We write each nth character of stream to be  n % kunitSize.
+  std::string allChars;
+  allChars.resize(kUnitSize);
+  for (auto i = 0; i < kUnitSize; ++i) {
+    allChars[i] = i;
+  }
+
+  ByteOutputStream stream(allocator_.get());
+  auto position = allocator_->newWrite(stream, 20);
+  // Nothing written yet.
+  EXPECT_EQ(0, stream.size());
+  for (auto i = 0; i < 10; ++i) {
+    stream.appendStringView(allChars);
+    // We check that the size reflects the payload size after each write.
+    EXPECT_EQ((i + 1) * kUnitSize, stream.size());
+  }
+  // We expect a multipart allocation.
+  EXPECT_TRUE(position.header->isContinued());
+  EXPECT_EQ(kUnitSize * 10, stream.tellp());
+
+  // we check and rewrite different offsets in the stream, not to pass past end.
+  for (auto start = 90; start < kUnitSize * 9; start += 125) {
+    stream.seekp(start);
+    EXPECT_EQ(start, stream.tellp());
+    EXPECT_EQ(kUnitSize * 10, stream.size());
+    auto input = stream.inputStream();
+    input->seekp(start);
+    EXPECT_EQ(kUnitSize * 10 - start, input->remainingSize());
+    for (auto c = 0; c < 10; ++c) {
+      uint8_t byte = input->readByte();
+      EXPECT_EQ(byte, (start + c) % kUnitSize);
+    }
+    // Overwrite the bytes just read.
+    stream.seekp(start);
+    stream.appendStringView(std::string_view(allChars.data(), 100));
+    input = stream.inputStream();
+    input->seekp(start);
+    for (auto c = 0; c < 100; ++c) {
+      uint8_t byte = input->readByte();
+      EXPECT_EQ(byte, c % kUnitSize);
+    }
+  }
+  EXPECT_EQ(kUnitSize * 10, stream.size());
+  stream.seekp(kUnitSize * 10 - 100);
+  stream.appendStringView(allChars);
+  // The last write extends the size.
+  EXPECT_EQ(kUnitSize * 11 - 100, stream.size());
+}
+
+TEST_F(HashStringAllocatorTest, storeStringFast) {
+  allocator_->allocate(HashStringAllocator::kMinAlloc);
+  std::string s(
+      allocator_->freeSpace() + HashStringAllocator::Header::kContinuedPtrSize,
+      'x');
+  StringView sv(s);
+  allocator_->copyMultipart(sv, reinterpret_cast<char*>(&sv), 0);
+  ASSERT_NE(sv.data(), s.data());
+  ASSERT_EQ(sv, StringView(s));
+  auto allocatedBytes = allocator_->checkConsistency();
+  ASSERT_EQ(allocatedBytes, allocator_->currentBytes());
+}
+
+TEST_F(HashStringAllocatorTest, clear) {
+  allocator_->allocate(HashStringAllocator::kMinAlloc);
+  allocator_->allocate(HashStringAllocator::kMaxAlloc + 1);
+  EXPECT_GT(allocator_->retainedSize(), 0);
+  allocator_->clear();
+  EXPECT_EQ(allocator_->retainedSize(), 0);
+}
+
+TEST_F(HashStringAllocatorTest, freezeAndExecute) {
+  std::string str = "abc";
+  StringView view(str.data(), str.size());
+  allocator_->copyMultipart(view, reinterpret_cast<char*>(&view), 0);
+
+  str.clear();
+
+  // Freeing memory requires the HashStringAllocator to be mutable.
+  VELOX_ASSERT_THROW(
+      allocator_->freezeAndExecute([&]() {
+        allocator_->free(HashStringAllocator::headerOf(view.data()));
+      }),
+      "The HashStringAllocator is immutable.");
+
+  HashStringAllocator::Header* header;
+
+  // Allocating memory requires the HashStringAllocator to be mutable.
+  VELOX_ASSERT_THROW(
+      allocator_->freezeAndExecute(
+          [&]() { header = allocator_->allocate(24); }),
+      "The HashStringAllocator is immutable.");
+
+  // Simply fetching state should not require the HashStringAllocator to be
+  // mutable.
+  allocator_->freezeAndExecute([&]() { allocator_->currentBytes(); });
+}
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/common/memory/tests/MemoryAllocatorTest.cpp b/velox/common/memory/tests/MemoryAllocatorTest.cpp
index fb582f1ef8662..3c2f48f0c4cc1 100644
--- a/velox/common/memory/tests/MemoryAllocatorTest.cpp
+++ b/velox/common/memory/tests/MemoryAllocatorTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/common/memory/MemoryAllocator.h"
+#include <thread>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/AllocationPool.h"
 #include "velox/common/memory/MallocAllocator.h"
@@ -21,16 +22,18 @@
 #include "velox/common/memory/MmapArena.h"
 #include "velox/common/testutil/TestValue.h"
 
-#include <fstream>
-#include <thread>
-
+#include <fmt/format.h>
 #include <folly/Random.h>
 #include <folly/Range.h>
 #include <gflags/gflags.h>
-#include <glog/logging.h>
+#include <gmock/gmock-matchers.h>
 #include <gtest/gtest.h>
 
-DECLARE_int32(velox_memory_pool_mb);
+#ifdef linux
+#include <fstream>
+#endif // linux
+
+DECLARE_bool(velox_memory_leak_check_enabled);
 
 using namespace facebook::velox::common::testutil;
 
@@ -43,14 +46,15 @@ struct ProcessSize {
 };
 } // namespace
 
-static constexpr uint64_t kCapacityBytes = 256UL * 1024 * 1024;
+static constexpr uint64_t kCapacityBytes = 1ULL << 30;
 static constexpr MachinePageCount kCapacityPages =
     (kCapacityBytes / AllocationTraits::kPageSize);
 
-class MemoryAllocatorTest : public testing::TestWithParam<bool> {
+class MemoryAllocatorTest : public testing::TestWithParam<int> {
  protected:
   static void SetUpTestCase() {
     TestValue::enable();
+    FLAGS_velox_memory_leak_check_enabled = true;
   }
 
   void SetUp() override {
@@ -59,50 +63,55 @@ class MemoryAllocatorTest : public testing::TestWithParam<bool> {
 
   void setupAllocator() {
     pool_.reset();
-    MemoryAllocator::testingDestroyInstance();
-    useMmap_ = GetParam();
+    useMmap_ = GetParam() == 0;
+    enableReservation_ = GetParam() == 2;
     maxMallocBytes_ = 3072;
     if (useMmap_) {
-      MmapAllocator::Options options;
-      options.capacity = kCapacityBytes;
+      MemoryManagerOptions options;
+      options.useMmapAllocator = true;
+      options.allocatorCapacity = kCapacityBytes;
+      options.arbitratorCapacity = kCapacityBytes;
+      options.arbitratorReservedCapacity = 128 << 20;
+      options.memoryPoolReservedCapacity = 1 << 20;
       options.smallAllocationReservePct = 4;
       options.maxMallocBytes = maxMallocBytes_;
-      allocator_ = std::make_shared<MmapAllocator>(options);
-      auto mmapAllocator = std::dynamic_pointer_cast<MmapAllocator>(allocator_);
+      memoryManager_ = std::make_unique<MemoryManager>(options);
       ASSERT_EQ(
-          AllocationTraits::numPages(mmapAllocator->capacity()),
+          AllocationTraits::numPages(memoryManager_->allocator()->capacity()),
           bits::roundUp(
               kCapacityBytes * (100 - options.smallAllocationReservePct) / 100 /
                   AllocationTraits::kPageSize,
-              64 * mmapAllocator->sizeClasses().back()));
-      MemoryAllocator::setDefaultInstance(allocator_.get());
+              64 * memoryManager_->allocator()->sizeClasses().back()));
     } else {
-      allocator_ = std::make_shared<MallocAllocator>(kCapacityBytes);
-      MemoryAllocator::setDefaultInstance(allocator_.get());
+      MemoryManagerOptions options;
+      options.allocatorCapacity = kCapacityBytes;
+      options.arbitratorCapacity = kCapacityBytes;
+      options.arbitratorReservedCapacity = 128 << 20;
+      options.memoryPoolReservedCapacity = 1 << 20;
+      if (!enableReservation_) {
+        options.allocationSizeThresholdWithReservation = 0;
+      }
+      memoryManager_ = std::make_unique<MemoryManager>(options);
     }
-    instance_ = MemoryAllocator::getInstance();
-    memoryManager_ = std::make_unique<MemoryManager>(MemoryManagerOptions{
-        .capacity = (int64_t)instance_->capacity(), .allocator = instance_});
+    instance_ = memoryManager_->allocator();
     pool_ = memoryManager_->addLeafPool("allocatorTest");
     if (useMmap_) {
       ASSERT_EQ(instance_->kind(), MemoryAllocator::Kind::kMmap);
       ASSERT_EQ(
           instance_->toString(),
-          "Memory Allocator[MMAP capacity 64.00KB allocated pages 0 mapped pages 0 external mapped pages 0\n[size 1: 0(0MB) allocated 0 mapped]\n[size 2: 0(0MB) allocated 0 mapped]\n[size 4: 0(0MB) allocated 0 mapped]\n[size 8: 0(0MB) allocated 0 mapped]\n[size 16: 0(0MB) allocated 0 mapped]\n[size 32: 0(0MB) allocated 0 mapped]\n[size 64: 0(0MB) allocated 0 mapped]\n[size 128: 0(0MB) allocated 0 mapped]\n[size 256: 0(0MB) allocated 0 mapped]\n]");
+          "Memory Allocator[MMAP total capacity 1.00GB free capacity 1.00GB allocated pages 0 mapped pages 0 external mapped pages 0\n[size 1: 0(0MB) allocated 0 mapped]\n[size 2: 0(0MB) allocated 0 mapped]\n[size 4: 0(0MB) allocated 0 mapped]\n[size 8: 0(0MB) allocated 0 mapped]\n[size 16: 0(0MB) allocated 0 mapped]\n[size 32: 0(0MB) allocated 0 mapped]\n[size 64: 0(0MB) allocated 0 mapped]\n[size 128: 0(0MB) allocated 0 mapped]\n[size 256: 0(0MB) allocated 0 mapped]\n]");
     } else {
       ASSERT_EQ(instance_->kind(), MemoryAllocator::Kind::kMalloc);
       ASSERT_EQ(
           instance_->toString(),
-          "Memory Allocator[MALLOC capacity 256.00MB allocated bytes 0 allocated pages 0 mapped pages 0]");
+          "Memory Allocator[MALLOC capacity 1.00GB allocated bytes 0 allocated pages 0 mapped pages 0]");
     }
     ASSERT_EQ(
         MemoryAllocator::kindString(static_cast<MemoryAllocator::Kind>(100)),
         "UNKNOWN: 100");
   }
 
-  void TearDown() override {
-    MemoryAllocator::testingDestroyInstance();
-  }
+  void TearDown() override {}
 
   bool allocate(int32_t numPages, Allocation& result) {
     try {
@@ -110,7 +119,7 @@ class MemoryAllocatorTest : public testing::TestWithParam<bool> {
         EXPECT_TRUE(result.empty());
         return false;
       }
-    } catch (const VeloxException& e) {
+    } catch (const VeloxException&) {
       EXPECT_TRUE(result.empty());
       return false;
     }
@@ -338,7 +347,7 @@ class MemoryAllocatorTest : public testing::TestWithParam<bool> {
 
   bool allocateContiguous(
       int numPages,
-      Allocation* FOLLY_NULLABLE collateral,
+      Allocation* collateral,
       ContiguousAllocation& allocation) {
     bool success =
         instance_->allocateContiguous(numPages, collateral, allocation);
@@ -404,8 +413,8 @@ class MemoryAllocatorTest : public testing::TestWithParam<bool> {
   }
 
   bool useMmap_;
+  bool enableReservation_;
   int32_t maxMallocBytes_;
-  std::shared_ptr<MemoryAllocator> allocator_;
   MemoryAllocator* instance_;
   std::unique_ptr<MemoryManager> memoryManager_;
   std::shared_ptr<MemoryPool> pool_;
@@ -621,7 +630,42 @@ TEST_P(MemoryAllocatorTest, allocationClass2) {
   allocation->clear();
 }
 
+TEST_P(MemoryAllocatorTest, stats) {
+  const std::vector<MachinePageCount>& sizes = instance_->sizeClasses();
+  MachinePageCount capacity = kCapacityPages;
+  for (auto i = 0; i < sizes.size(); ++i) {
+    std::unique_ptr<Allocation> allocation = std::make_unique<Allocation>();
+    auto size = sizes[i];
+    ASSERT_TRUE(allocate(size, *allocation));
+    ASSERT_GT(instance_->numAllocated(), 0);
+    instance_->freeNonContiguous(*allocation);
+    auto stats = instance_->stats();
+    ASSERT_EQ(0, stats.sizes[i].clocks());
+    ASSERT_EQ(stats.sizes[i].totalBytes, 0);
+    ASSERT_EQ(stats.sizes[i].numAllocations, 0);
+  }
+
+  gflags::FlagSaver flagSaver;
+  FLAGS_velox_time_allocations = true;
+  for (auto i = 0; i < sizes.size(); ++i) {
+    std::unique_ptr<Allocation> allocation = std::make_unique<Allocation>();
+    auto size = sizes[i];
+    ASSERT_TRUE(allocate(size, *allocation));
+    ASSERT_GT(instance_->numAllocated(), 0);
+    instance_->freeNonContiguous(*allocation);
+    auto stats = instance_->stats();
+    ASSERT_LT(0, stats.sizes[i].clocks());
+    ASSERT_GE(stats.sizes[i].totalBytes, size * AllocationTraits::kPageSize);
+    ASSERT_GE(stats.sizes[i].numAllocations, 1);
+  }
+}
+
 TEST_P(MemoryAllocatorTest, singleAllocation) {
+  if (!useMmap_ && enableReservation_) {
+    return;
+  }
+  gflags::FlagSaver flagSaver;
+  FLAGS_velox_time_allocations = true;
   const std::vector<MachinePageCount>& sizes = instance_->sizeClasses();
   MachinePageCount capacity = kCapacityPages;
   for (auto i = 0; i < sizes.size(); ++i) {
@@ -683,6 +727,9 @@ TEST_P(MemoryAllocatorTest, increasingSize) {
 }
 
 TEST_P(MemoryAllocatorTest, increasingSizeWithThreads) {
+  if (!useMmap_ && enableReservation_) {
+    return;
+  }
   const int32_t numThreads = 20;
   std::vector<std::vector<std::unique_ptr<Allocation>>> allocations;
   allocations.reserve(numThreads);
@@ -727,7 +774,7 @@ TEST_P(MemoryAllocatorTest, externalAdvise) {
   }
   constexpr int32_t kSmallSize = 16;
   constexpr int32_t kLargeSize = 32 * kSmallSize + 1;
-  auto instance = dynamic_cast<MmapAllocator*>(MemoryAllocator::getInstance());
+  auto instance = dynamic_cast<MmapAllocator*>(instance_);
   std::vector<std::unique_ptr<Allocation>> allocations;
   auto numAllocs = kCapacityPages / kSmallSize;
   allocations.reserve(numAllocs);
@@ -776,8 +823,8 @@ TEST_P(MemoryAllocatorTest, nonContiguousFailure) {
     std::string debugString() const {
       return fmt::format(
           "numOldPages:{}, numNewPages:{}, injectedFailure:{}",
-          numOldPages,
-          numNewPages,
+          static_cast<uint64_t>(numOldPages),
+          static_cast<uint64_t>(numNewPages),
           injectedFailure);
     }
   } testSettings[] = {// Cap failure injection.
@@ -839,28 +886,49 @@ TEST_P(MemoryAllocatorTest, nonContiguousFailure) {
                        Allocation::PageRun::kMaxPagesInRun,
                        MemoryAllocator::InjectedFailure::kMadvise},
                       {200, 100, MemoryAllocator::InjectedFailure::kMadvise}};
+  std::unordered_map<MemoryAllocator::InjectedFailure, std::string>
+      expectedErrorMsg = {
+          {MemoryAllocator::InjectedFailure::kAllocate,
+           "Malloc failed to allocate"},
+          {MemoryAllocator::InjectedFailure::kCap,
+           "Exceeded memory allocator limit"}};
+  if (useMmap_) {
+    expectedErrorMsg = {
+        {MemoryAllocator::InjectedFailure::kCap,
+         "Exceeded memory allocator limit"},
+        {MemoryAllocator::InjectedFailure::kMadvise,
+         "Could not advise away enough"},
+        {MemoryAllocator::InjectedFailure::kAllocate,
+         "Failed allocation in size class"}};
+  }
+  // Some error messages are only set when a reservationCB is provided
+  auto dummyReservationCB = [](int64_t /*bytes*/, bool /*preAllocation*/) {};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(
         fmt::format("{}, useMmap:{}", testData.debugString(), useMmap_));
-    if ((testData.injectedFailure !=
-         MemoryAllocator::InjectedFailure::kAllocate) &&
+    if ((testData.injectedFailure ==
+         MemoryAllocator::InjectedFailure::kMadvise) &&
         !useMmap_) {
-      // Non-Allocate failure injection only applies for MmapAllocator.
+      // Madvise failure injection only applies for MmapAllocator.
       continue;
     }
     setupAllocator();
     Allocation allocation;
     if (testData.numOldPages > 0) {
-      allocator_->allocateNonContiguous(testData.numOldPages, allocation);
+      instance_->allocateNonContiguous(testData.numOldPages, allocation);
     }
     ASSERT_GE(allocation.numPages(), testData.numOldPages);
-    allocator_->testingSetFailureInjection(testData.injectedFailure, true);
-    ASSERT_FALSE(
-        allocator_->allocateNonContiguous(testData.numNewPages, allocation));
-    ASSERT_EQ(allocator_->numAllocated(), 0);
-    allocator_->testingClearFailureInjection();
+    instance_->testingSetFailureInjection(testData.injectedFailure, true);
+    ASSERT_FALSE(instance_->allocateNonContiguous(
+        testData.numNewPages, allocation, dummyReservationCB));
+    auto failureMsg = instance_->getAndClearFailureMessage();
+    EXPECT_THAT(
+        failureMsg,
+        testing::HasSubstr(expectedErrorMsg[testData.injectedFailure]));
+    ASSERT_EQ(instance_->numAllocated(), 0);
+    instance_->testingClearFailureInjection();
   }
-  ASSERT_TRUE(allocator_->checkConsistency());
+  ASSERT_TRUE(instance_->checkConsistency());
 }
 
 TEST_P(MemoryAllocatorTest, allocContiguous) {
@@ -914,7 +982,7 @@ TEST_P(MemoryAllocatorTest, allocContiguous) {
       } else {
         ASSERT_EQ(instance_->numMapped(), testData.newContiguousPages);
       }
-      auto mappedAllocator = dynamic_cast<MmapAllocator*>(allocator_.get());
+      auto mappedAllocator = dynamic_cast<MmapAllocator*>(instance_);
       ASSERT_EQ(
           mappedAllocator->numExternalMapped(), testData.newContiguousPages);
     } else {
@@ -930,7 +998,7 @@ TEST_P(MemoryAllocatorTest, allocContiguous) {
       } else {
         ASSERT_EQ(instance_->numMapped(), 0);
       }
-      auto mappedAllocator = dynamic_cast<MmapAllocator*>(allocator_.get());
+      auto mappedAllocator = dynamic_cast<MmapAllocator*>(instance_);
       ASSERT_EQ(mappedAllocator->numExternalMapped(), 0);
     } else {
       ASSERT_EQ(instance_->numMapped(), 0);
@@ -976,9 +1044,16 @@ TEST_P(MemoryAllocatorTest, allocContiguousFail) {
       {100, 0, 100, MemoryAllocator::InjectedFailure::kMadvise},
       {200, 0, 100, MemoryAllocator::InjectedFailure::kMadvise},
       {100, 0, 200, MemoryAllocator::InjectedFailure::kMadvise}};
+
+  std::unordered_map<MemoryAllocator::InjectedFailure, std::string>
+      expectedErrorMsg = {
+          {MemoryAllocator::InjectedFailure::kCap,
+           "Exceeded memory allocator limit"},
+          {MemoryAllocator::InjectedFailure::kMmap, "Mmap failed with"},
+          {MemoryAllocator::InjectedFailure::kMadvise,
+           "Could not advise away enough"}};
   for (const auto& testData : testSettings) {
-    if ((testData.injectedFailure !=
-         MemoryAllocator::InjectedFailure::kAllocate) &&
+    if ((testData.injectedFailure != MemoryAllocator::InjectedFailure::kCap) &&
         !useMmap_) {
       continue;
     }
@@ -1003,13 +1078,17 @@ TEST_P(MemoryAllocatorTest, allocContiguousFail) {
 
     ASSERT_FALSE(instance_->allocateContiguous(
         testData.newContiguousPages, &allocation, contiguousAllocation));
+    auto failureMsg = instance_->getAndClearFailureMessage();
+    EXPECT_THAT(
+        failureMsg,
+        testing::HasSubstr(expectedErrorMsg[testData.injectedFailure]));
     ASSERT_EQ(instance_->numAllocated(), 0);
 
     if (useMmap_) {
       // Mmap allocator doesn't free mapped pages count for the old
       // non-contiguous allocation.
       ASSERT_EQ(instance_->numMapped(), testData.nonContiguousPages);
-      auto mappedAllocator = dynamic_cast<MmapAllocator*>(allocator_.get());
+      auto mappedAllocator = dynamic_cast<MmapAllocator*>(instance_);
       ASSERT_EQ(mappedAllocator->numExternalMapped(), 0);
     } else {
       ASSERT_EQ(instance_->numMapped(), 0);
@@ -1047,7 +1126,19 @@ TEST_P(MemoryAllocatorTest, allocContiguousGrow) {
   EXPECT_TRUE(instance_->allocateContiguous(
       kInitialLarge, nullptr, large, nullptr, kCapacityPages));
   EXPECT_FALSE(instance_->growContiguous(kMinGrow, large));
+  auto failureMsg = instance_->getAndClearFailureMessage();
+  auto expected = "Exceeded memory allocator limit";
+  EXPECT_THAT(failureMsg, testing::HasSubstr(expected));
   freeSmall(kMinGrow);
+  if (useMmap_) {
+    // Also test mmap failure path
+    instance_->testingSetFailureInjection(
+        MemoryAllocator::InjectedFailure::kMmap, false);
+    EXPECT_FALSE(instance_->growContiguous(kMinGrow, large));
+    failureMsg = instance_->getAndClearFailureMessage();
+    expected = "Could not advise away enough";
+    EXPECT_THAT(failureMsg, testing::HasSubstr(expected));
+  }
   EXPECT_TRUE(instance_->growContiguous(kMinGrow, large));
   EXPECT_EQ(instance_->numAllocated(), kCapacityPages);
   freeSmall(4 * kMinGrow);
@@ -1304,16 +1395,18 @@ TEST_P(MemoryAllocatorTest, StlMemoryAllocator) {
   }
 }
 
-TEST_P(MemoryAllocatorTest, badNonContiguousAllocation) {
+TEST_P(MemoryAllocatorTest, nonContiguousAllocationBounds) {
   // Set the num of pages to allocate exceeds one PageRun limit.
   constexpr MachinePageCount kNumPages =
       Allocation::PageRun::kMaxPagesInRun + 1;
   std::unique_ptr<Allocation> allocation(new Allocation());
-  ASSERT_THROW(
-      instance_->allocateNonContiguous(kNumPages, *allocation),
-      VeloxRuntimeError);
+  ASSERT_TRUE(instance_->allocateNonContiguous(kNumPages, *allocation));
+  instance_->freeNonContiguous(*allocation);
   ASSERT_TRUE(instance_->allocateNonContiguous(kNumPages - 1, *allocation));
   instance_->freeNonContiguous(*allocation);
+  ASSERT_TRUE(instance_->allocateNonContiguous(
+      Allocation::PageRun::kMaxPagesInRun * 2, *allocation));
+  instance_->freeNonContiguous(*allocation);
 }
 
 TEST_P(MemoryAllocatorTest, contiguousAllocation) {
@@ -1354,7 +1447,7 @@ TEST_P(MemoryAllocatorTest, contiguousAllocation) {
     ASSERT_EQ(movedAllocation.pool(), pool_.get());
     *allocation = std::move(movedAllocation);
     ASSERT_TRUE(!allocation->empty()); // NOLINT
-    ASSERT_TRUE(movedAllocation.empty());
+    ASSERT_TRUE(movedAllocation.empty()); // NOLINT
     ASSERT_EQ(allocation->pool(), pool_.get());
   }
   ASSERT_THROW(allocation->setPool(pool_.get()), VeloxRuntimeError);
@@ -1379,7 +1472,13 @@ TEST_P(MemoryAllocatorTest, allocatorCapacity) {
     EXPECT_NE(nullptr, preExistingBuf);
 
     EXPECT_EQ(nullptr, instance_->allocateBytes(allocationBytes));
+    EXPECT_THAT(
+        instance_->getAndClearFailureMessage(),
+        testing::HasSubstr("Exceeded memory allocator limit"));
     EXPECT_EQ(nullptr, instance_->allocateZeroFilled(allocationBytes));
+    EXPECT_THAT(
+        instance_->getAndClearFailureMessage(),
+        testing::HasSubstr("Exceeded memory allocator limit"));
     Allocation small;
     if (allocationBytes <= Allocation::PageRun::kMaxPagesInRun) {
       EXPECT_FALSE(instance_->allocateNonContiguous(allocationBytes, small));
@@ -1398,10 +1497,8 @@ TEST_P(MemoryAllocatorTest, allocatorCapacity) {
 TEST_P(MemoryAllocatorTest, allocatorCapacityWithThreads) {
   std::atomic<int64_t> numOps{0};
   const int64_t numMaxOps = 100000;
-  // We need large enough (at least close to capacity) allocations to breach the
-  // capacity limit in this test.
-  EXPECT_GT(Allocation::PageRun::kMaxPagesInRun, kCapacityPages / 4 * 3);
-  const int64_t nonContAllocPages = Allocation::PageRun::kMaxPagesInRun;
+  const int64_t nonContAllocPages =
+      Allocation::PageRun::kMaxPagesInRun / 256 * 256;
 
   std::function<void()> nonContiguousReserveFail = [&, this]() {
     while (numOps < numMaxOps) {
@@ -1512,11 +1609,6 @@ TEST_P(MemoryAllocatorTest, allocatorCapacityWithThreads) {
   EXPECT_EQ(instance_->numAllocated(), 0);
 }
 
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    MemoryAllocatorTests,
-    MemoryAllocatorTest,
-    testing::ValuesIn({false, true}));
-
 class MmapArenaTest : public testing::Test {
  public:
   // 32 MB arena space
@@ -1808,4 +1900,92 @@ TEST_F(MmapArenaTest, managedMmapArenasFreeError) {
     ASSERT_ANY_THROW(managedArenas->free(alloc2, kArenaCapacityBytes));
   }
 }
+
+TEST_P(MemoryAllocatorTest, unmap) {
+  const int smallAllocationSize = 1024;
+  const int largeAllocationSize = 8192;
+  const int numAllocations = 10;
+  std::vector<void*> smallBuffers;
+  std::vector<void*> largeBuffers;
+  for (int i = 0; i < numAllocations; ++i) {
+    smallBuffers.push_back(instance_->allocateBytes(smallAllocationSize));
+    largeBuffers.push_back(instance_->allocateBytes(largeAllocationSize));
+  }
+  const auto numAllocated = instance_->numAllocated();
+  if (useMmap_) {
+    ASSERT_EQ(instance_->numMapped(), numAllocated);
+  } else {
+    ASSERT_EQ(instance_->numAllocated(), 0);
+    ASSERT_EQ(instance_->numMapped(), 0);
+  }
+  // Nothing can be unmapped.
+  ASSERT_EQ(instance_->unmap(numAllocated), 0);
+  for (const auto& smallBuffer : smallBuffers) {
+    instance_->freeBytes(smallBuffer, smallAllocationSize);
+  }
+  for (const auto& largeBuffer : largeBuffers) {
+    instance_->freeBytes(largeBuffer, largeAllocationSize);
+  }
+  ASSERT_EQ(instance_->numAllocated(), 0);
+  if (useMmap_) {
+    ASSERT_EQ(instance_->numMapped(), numAllocated);
+    ASSERT_EQ(instance_->unmap(numAllocated / 2), numAllocated / 2);
+    ASSERT_GT(instance_->unmap(numAllocated), 0);
+    ASSERT_EQ(instance_->numMapped(), 0);
+  } else {
+    ASSERT_EQ(instance_->numMapped(), 0);
+    ASSERT_EQ(instance_->unmap(numAllocated), 0);
+  }
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    MemoryAllocatorTestSuite,
+    MemoryAllocatorTest,
+    testing::ValuesIn({0, 1, 2}));
+
+class MmapConfigTest : public testing::Test {
+ public:
+ protected:
+  void setupAllocator() {
+    constexpr int64_t kCapacityBytes = 900LL << 20; // 900MB.
+    MemoryManagerOptions options;
+    options.useMmapAllocator = true;
+    options.allocatorCapacity = kCapacityBytes;
+    options.largestSizeClassPages = 4096;
+    options.arbitratorCapacity = kCapacityBytes;
+    options.arbitratorReservedCapacity = 128 << 20;
+    options.memoryPoolReservedCapacity = 1 << 20;
+    options.smallAllocationReservePct = 4;
+    options.maxMallocBytes = 3 * 1024;
+    memoryManager_ = std::make_unique<MemoryManager>(options);
+    allocator_ = memoryManager_->allocator();
+    ASSERT_EQ(
+        AllocationTraits::numPages(memoryManager_->allocator()->capacity()),
+        bits::roundUp(
+            kCapacityBytes * (100 - options.smallAllocationReservePct) / 100 /
+                AllocationTraits::kPageSize,
+            64 * allocator_->sizeClasses().back()));
+  }
+
+  std::unique_ptr<MemoryManager> memoryManager_;
+  MemoryAllocator* allocator_;
+};
+
+TEST_F(MmapConfigTest, sizeClasses) {
+  setupAllocator();
+  Allocation result;
+  ASSERT_TRUE(
+      allocator_->allocateNonContiguous(2 * 4096 - 1, result, nullptr, 0));
+  auto g = folly::makeGuard([&]() { allocator_->freeNonContiguous(result); });
+  // Check that the allocation has one page of each size class, largest to
+  // smallest.
+  EXPECT_EQ(4096 * 2 - 1, result.numPages());
+  EXPECT_EQ(13, result.numRuns());
+  int32_t runPages = 4096;
+  for (auto i = 0; i < result.numRuns(); ++i) {
+    EXPECT_EQ(runPages, result.runAt(i).numPages());
+    runPages = runPages / 2;
+  }
+}
+
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/tests/MemoryArbitratorTest.cpp b/velox/common/memory/tests/MemoryArbitratorTest.cpp
index 9913ed7298c9d..848ab33f79603 100644
--- a/velox/common/memory/tests/MemoryArbitratorTest.cpp
+++ b/velox/common/memory/tests/MemoryArbitratorTest.cpp
@@ -32,7 +32,20 @@ constexpr int64_t GB = 1024L * MB;
 
 namespace facebook::velox::memory {
 
-class MemoryArbitrationTest : public testing::Test {};
+class MemoryArbitrationTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() {
+    SharedArbitrator::registerFactory();
+  }
+
+  void TearDown() {
+    SharedArbitrator::unregisterFactory();
+  }
+};
 
 TEST_F(MemoryArbitrationTest, stats) {
   MemoryArbitrator::Stats stats;
@@ -43,11 +56,24 @@ TEST_F(MemoryArbitrationTest, stats) {
   stats.arbitrationTimeUs = 1020;
   stats.numShrunkBytes = 100'000'000;
   stats.numReclaimedBytes = 10'000;
+  stats.freeReservedCapacityBytes = 1000;
+  stats.freeCapacityBytes = 2000;
   stats.reclaimTimeUs = 1'000;
   stats.numNonReclaimableAttempts = 5;
   ASSERT_EQ(
       stats.toString(),
-      "STATS[numRequests 2 numSucceeded 0 numAborted 3 numFailures 100 numNonReclaimableAttempts 5 queueTime 230.00ms arbitrationTime 1.02ms reclaimTime 1.00ms shrunkMemory 95.37MB reclaimedMemory 9.77KB maxCapacity 0B freeCapacity 0B]");
+      "STATS[numRequests 2 numAborted 3 numFailures 100 "
+      "numNonReclaimableAttempts 5 numShrinks 0 "
+      "queueTime 230.00ms arbitrationTime 1.02ms reclaimTime 1.00ms "
+      "shrunkMemory 95.37MB reclaimedMemory 9.77KB "
+      "maxCapacity 0B freeCapacity 1.95KB freeReservedCapacity 1000B]");
+  ASSERT_EQ(
+      fmt::format("{}", stats),
+      "STATS[numRequests 2 numAborted 3 numFailures 100 "
+      "numNonReclaimableAttempts 5 numShrinks 0 "
+      "queueTime 230.00ms arbitrationTime 1.02ms reclaimTime 1.00ms "
+      "shrunkMemory 95.37MB reclaimedMemory 9.77KB "
+      "maxCapacity 0B freeCapacity 1.95KB freeReservedCapacity 1000B]");
 }
 
 TEST_F(MemoryArbitrationTest, create) {
@@ -58,7 +84,7 @@ TEST_F(MemoryArbitrationTest, create) {
   };
   for (const auto& kind : kinds) {
     MemoryArbitrator::Config config;
-    config.capacity = 1 * GB;
+    config.capacity = 8 * GB;
     config.kind = kind;
     if (kind.empty()) {
       auto arbitrator = MemoryArbitrator::create(config);
@@ -75,7 +101,7 @@ TEST_F(MemoryArbitrationTest, create) {
 
 TEST_F(MemoryArbitrationTest, createWithDefaultConf) {
   MemoryArbitrator::Config config;
-  config.capacity = 1 * GB;
+  config.capacity = 8 * GB;
   const auto& arbitrator = MemoryArbitrator::create(config);
   ASSERT_EQ(arbitrator->kind(), "NOOP");
 }
@@ -83,11 +109,11 @@ TEST_F(MemoryArbitrationTest, createWithDefaultConf) {
 TEST_F(MemoryArbitrationTest, queryMemoryCapacity) {
   {
     // Reserved memory is not enforced when no arbitrator is provided.
-    auto allocator = std::make_shared<MallocAllocator>(8L << 20);
-    MemoryManager manager{
-        {.capacity = (int64_t)allocator->capacity(),
-         .queryMemoryCapacity = 4L << 20,
-         .allocator = allocator.get()}};
+    MemoryManagerOptions options;
+    options.allocatorCapacity = 8L << 20;
+    options.arbitratorCapacity = 4L << 20;
+    options.arbitratorReservedCapacity = 2L << 20;
+    MemoryManager manager(options);
     auto rootPool = manager.addRootPool("root-1", 8L << 20);
     auto leafPool = rootPool->addLeafChild("leaf-1.0");
     void* buffer;
@@ -98,32 +124,175 @@ TEST_F(MemoryArbitrationTest, queryMemoryCapacity) {
   }
   {
     // Reserved memory is enforced when SharedMemoryArbitrator is used.
-    SharedArbitrator::registerFactory();
-    auto allocator = std::make_shared<MallocAllocator>(8L << 20);
-    MemoryManager manager{
-        {.capacity = (int64_t)allocator->capacity(),
-         .queryMemoryCapacity = 4L << 20,
-         .allocator = allocator.get(),
-         .arbitratorKind = "SHARED"}};
+    MemoryManagerOptions options;
+    options.allocatorCapacity = 16L << 20;
+    options.arbitratorCapacity = 6L << 20;
+    options.arbitratorReservedCapacity = 2L << 20;
+    options.arbitratorKind = "SHARED";
+    options.memoryPoolInitCapacity = 1 << 20;
+    options.memoryPoolReservedCapacity = 1 << 20;
+    MemoryManager manager(options);
     auto rootPool =
         manager.addRootPool("root-1", 8L << 20, MemoryReclaimer::create());
+    ASSERT_EQ(rootPool->capacity(), 1 << 20);
+    ASSERT_TRUE(manager.arbitrator()->growCapacity(rootPool.get(), 1 << 20));
+    ASSERT_EQ(rootPool->capacity(), 1 << 20);
+    ASSERT_FALSE(manager.arbitrator()->growCapacity(rootPool.get(), 6 << 20));
+    ASSERT_EQ(rootPool->capacity(), 1 << 20);
+    ASSERT_TRUE(manager.arbitrator()->growCapacity(rootPool.get(), 2 << 20));
+    ASSERT_EQ(rootPool->capacity(), 4 << 20);
+    ASSERT_EQ(manager.arbitrator()->stats().freeCapacityBytes, 2 << 20);
+    ASSERT_EQ(manager.arbitrator()->stats().freeReservedCapacityBytes, 2 << 20);
+
     auto leafPool = rootPool->addLeafChild("leaf-1.0");
-    void* buffer;
     VELOX_ASSERT_THROW(
-        buffer = leafPool->allocate(7L << 20),
-        "Exceeded memory pool cap of 4.00MB");
-    ASSERT_NO_THROW(buffer = leafPool->allocate(4L << 20));
-    leafPool->free(buffer, 4L << 20);
-    SharedArbitrator::unregisterFactory();
+        leafPool->allocate(7L << 20),
+        "Exceeded memory pool capacity after attempt to grow capacity through "
+        "arbitration. Requestor pool name 'leaf-1.0', request size 7.00MB, "
+        "memory pool capacity 4.00MB, memory pool max capacity 8.00MB");
+    ASSERT_EQ(manager.arbitrator()->shrinkCapacity(rootPool.get(), 0), 1 << 20);
+    ASSERT_EQ(manager.arbitrator()->shrinkCapacity(leafPool.get(), 0), 0);
+    ASSERT_EQ(manager.arbitrator()->shrinkCapacity(leafPool.get(), 1), 0);
+    ASSERT_EQ(manager.arbitrator()->shrinkCapacity(rootPool.get(), 1), 0);
+    ASSERT_EQ(rootPool->capacity(), 3 << 20);
+    static_cast<MemoryPoolImpl*>(rootPool.get())->testingSetReservation(0);
+    ASSERT_EQ(
+        manager.arbitrator()->shrinkCapacity(leafPool.get(), 1 << 20), 1 << 20);
+    ASSERT_EQ(
+        manager.arbitrator()->shrinkCapacity(rootPool.get(), 1 << 20), 1 << 20);
+    ASSERT_EQ(rootPool->capacity(), 1 << 20);
+    ASSERT_EQ(leafPool->capacity(), 1 << 20);
+    ASSERT_EQ(manager.arbitrator()->shrinkCapacity(leafPool.get(), 0), 1 << 20);
+    ASSERT_EQ(rootPool->capacity(), 0);
+    ASSERT_EQ(leafPool->capacity(), 0);
+  }
+}
+
+TEST_F(MemoryArbitrationTest, memoryPoolCapacityOnCreation) {
+  struct {
+    uint64_t freeNonReservedCapacity;
+    uint64_t freeReservedCapacity;
+    uint64_t poolMaxCapacity;
+    uint64_t poolInitCapacity;
+    uint64_t poolReservedCapacity;
+    uint64_t expectedPoolCapacityOnCreation;
+
+    std::string debugString() const {
+      return fmt::format(
+          "freeNonReservedCapacity {} freeReservedCapacity {} poolMaxCapacity {} poolInitCapacity {} poolReservedCapacity {} expectedPoolCapacityOnCreation {}",
+          freeNonReservedCapacity,
+          freeReservedCapacity,
+          poolMaxCapacity,
+          poolInitCapacity,
+          poolReservedCapacity,
+          expectedPoolCapacityOnCreation);
+    }
+  } testSettings[] = {
+      {1 << 20, 3 << 20, kMaxMemory, 3 << 20, 1 << 20, 1 << 20},
+      {1 << 20, 3 << 20, kMaxMemory, 1 << 20, 1 << 20, 1 << 20},
+      {1 << 20, 3 << 20, kMaxMemory, 8 << 20, 1 << 20, 1 << 20},
+      {0 << 20, 3 << 20, kMaxMemory, 1 << 20, 1 << 20, 1 << 20},
+      {0 << 20, 3 << 20, kMaxMemory, 2 << 20, 1 << 20, 1 << 20},
+      {0 << 20, 3 << 20, kMaxMemory, 8 << 20, 1 << 20, 1 << 20},
+      {0 << 20, 3 << 20, kMaxMemory, 8 << 20, 0 << 20, 0},
+      {1 << 20, 3 << 20, kMaxMemory, 3 << 20, 2 << 20, 2 << 20},
+      {1 << 20, 3 << 20, kMaxMemory, 3 << 20, 3 << 20, 3 << 20},
+      {1 << 20, 3 << 20, kMaxMemory, 3 << 20, 4 << 20, 4 << 20},
+      {1 << 20, 3 << 20, kMaxMemory, 3 << 20, 5 << 20, 4 << 20},
+      {1 << 20, 3 << 20, 3 << 20, 3 << 20, 5 << 20, 4 << 20},
+      {1 << 20, 3 << 20, 3 << 20, 3 << 20, 1 << 20, 1 << 20},
+      {1 << 20, 3 << 20, 3 << 20, 3 << 20, 2 << 20, 2 << 20},
+      {1 << 20, 3 << 20, 3 << 20, 1 << 20, 2 << 20, 2 << 20}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    MemoryManagerOptions options;
+    options.arbitratorKind = "SHARED";
+    options.arbitratorReservedCapacity = testData.freeReservedCapacity;
+    options.arbitratorCapacity =
+        testData.freeReservedCapacity + testData.freeNonReservedCapacity;
+    options.allocatorCapacity = options.arbitratorCapacity;
+    options.memoryPoolInitCapacity = testData.poolInitCapacity;
+    options.memoryPoolReservedCapacity = testData.poolReservedCapacity;
+
+    MemoryManager manager(options);
+    auto rootPool = manager.addRootPool("root-1", kMaxMemory);
+    ASSERT_EQ(rootPool->capacity(), testData.expectedPoolCapacityOnCreation);
   }
 }
 
+TEST_F(MemoryArbitrationTest, reservedCapacityFreeByPoolRelease) {
+  MemoryManagerOptions options;
+  options.arbitratorKind = "SHARED";
+  options.arbitratorReservedCapacity = 4 << 20;
+  options.arbitratorCapacity = 9 << 20;
+  options.allocatorCapacity = options.arbitratorCapacity;
+  options.memoryPoolInitCapacity = 3 << 20;
+  options.memoryPoolReservedCapacity = 1 << 20;
+
+  MemoryManager manager(options);
+  auto* arbitrator = manager.arbitrator();
+  auto pool1 = manager.addRootPool("root-1", kMaxMemory);
+  ASSERT_EQ(pool1->capacity(), 3 << 20);
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 4 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 6 << 20);
+
+  auto pool2 = manager.addRootPool("root-2", kMaxMemory);
+  ASSERT_EQ(pool2->capacity(), 2 << 20);
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 4 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 4 << 20);
+
+  auto pool3 = manager.addRootPool("root-3", kMaxMemory);
+  ASSERT_EQ(pool3->capacity(), 1 << 20);
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 3 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 3 << 20);
+
+  auto pool4 = manager.addRootPool("root-4", kMaxMemory);
+  ASSERT_EQ(pool4->capacity(), 1 << 20);
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 2 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 2 << 20);
+
+  auto pool5 = manager.addRootPool("root-5", kMaxMemory);
+  ASSERT_EQ(pool4->capacity(), 1 << 20);
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 1 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 1 << 20);
+
+  auto pool6 = manager.addRootPool("root-6", kMaxMemory);
+  ASSERT_EQ(pool4->capacity(), 1 << 20);
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 0 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 0 << 20);
+
+  auto pool7 = manager.addRootPool("root-7", kMaxMemory);
+  ASSERT_EQ(pool7->capacity(), 0);
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 0 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 0 << 20);
+
+  pool7.reset();
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 0 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 0 << 20);
+
+  pool6.reset();
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 1 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 1 << 20);
+
+  pool1.reset();
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 4 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 4 << 20);
+
+  pool2.reset();
+  ASSERT_EQ(arbitrator->stats().freeReservedCapacityBytes, 4 << 20);
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 6 << 20);
+}
+
 TEST_F(MemoryArbitrationTest, arbitratorStats) {
   const MemoryArbitrator::Stats emptyStats;
   ASSERT_TRUE(emptyStats.empty());
-  const MemoryArbitrator::Stats anchorStats(5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5);
+  const MemoryArbitrator::Stats anchorStats(
+      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5);
   ASSERT_FALSE(anchorStats.empty());
-  const MemoryArbitrator::Stats largeStats(8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8);
+  const MemoryArbitrator::Stats largeStats(
+      8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8);
   ASSERT_FALSE(largeStats.empty());
   ASSERT_TRUE(!(anchorStats == largeStats));
   ASSERT_TRUE(anchorStats != largeStats);
@@ -132,9 +301,11 @@ TEST_F(MemoryArbitrationTest, arbitratorStats) {
   ASSERT_TRUE(anchorStats <= largeStats);
   ASSERT_TRUE(!(anchorStats >= largeStats));
   const auto delta = largeStats - anchorStats;
-  ASSERT_EQ(delta, MemoryArbitrator::Stats(3, 3, 3, 3, 3, 3, 3, 3, 8, 8, 3, 3));
+  ASSERT_EQ(
+      delta, MemoryArbitrator::Stats(3, 3, 3, 3, 3, 3, 3, 3, 8, 8, 8, 3, 3, 3));
 
-  const MemoryArbitrator::Stats smallStats(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
+  const MemoryArbitrator::Stats smallStats(
+      2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
   ASSERT_TRUE(!(anchorStats == smallStats));
   ASSERT_TRUE(anchorStats != smallStats);
   ASSERT_TRUE(!(anchorStats < smallStats));
@@ -143,13 +314,13 @@ TEST_F(MemoryArbitrationTest, arbitratorStats) {
   ASSERT_TRUE(anchorStats >= smallStats);
 
   const MemoryArbitrator::Stats invalidStats(
-      2, 2, 2, 2, 2, 2, 8, 8, 8, 8, 8, 2);
+      2, 2, 2, 2, 2, 2, 8, 8, 8, 8, 8, 2, 8, 2);
   ASSERT_TRUE(!(anchorStats == invalidStats));
   ASSERT_TRUE(anchorStats != invalidStats);
-  ASSERT_THROW(anchorStats < invalidStats, VeloxException);
-  ASSERT_THROW(anchorStats > invalidStats, VeloxException);
-  ASSERT_THROW(anchorStats <= invalidStats, VeloxException);
-  ASSERT_THROW(anchorStats >= invalidStats, VeloxException);
+  VELOX_ASSERT_THROW(anchorStats < invalidStats, "");
+  VELOX_ASSERT_THROW(anchorStats > invalidStats, "");
+  VELOX_ASSERT_THROW(anchorStats <= invalidStats, "");
+  VELOX_ASSERT_THROW(anchorStats >= invalidStats, "");
 }
 
 namespace {
@@ -159,32 +330,27 @@ class FakeTestArbitrator : public MemoryArbitrator {
       : MemoryArbitrator(
             {.kind = config.kind,
              .capacity = config.capacity,
-             .memoryPoolInitCapacity = config.memoryPoolInitCapacity,
-             .memoryPoolTransferCapacity = config.memoryPoolTransferCapacity}) {
-  }
+             .extraConfigs = config.extraConfigs}) {}
 
-  void reserveMemory(MemoryPool* pool, uint64_t bytes) override {
-    VELOX_NYI();
+  std::string kind() const override {
+    return "USER";
   }
 
-  void releaseMemory(MemoryPool* pool) override {
-    VELOX_NYI();
-  }
+  void addPool(const std::shared_ptr<MemoryPool>& /*unused*/) override {}
 
-  std::string kind() const override {
-    return "USER";
+  void removePool(MemoryPool* /*unused*/) override {}
+
+  bool growCapacity(MemoryPool* /*unused*/, uint64_t /*unused*/) override {
+    VELOX_NYI();
   }
 
-  bool growMemory(
-      MemoryPool* pool,
-      const std::vector<std::shared_ptr<MemoryPool>>& candidatePools,
-      uint64_t targetBytes) override {
+  uint64_t shrinkCapacity(uint64_t /*unused*/, bool /*unused*/, bool /*unused*/)
+      override {
     VELOX_NYI();
   }
 
-  uint64_t shrinkMemory(
-      const std::vector<std::shared_ptr<MemoryPool>>& pools,
-      uint64_t targetBytes) override {
+  uint64_t shrinkCapacity(MemoryPool* /*unused*/, uint64_t /*unused*/)
+      override {
     VELOX_NYI();
   }
 
@@ -203,6 +369,7 @@ class MemoryArbitratorFactoryTest : public testing::Test {
  protected:
   static void SetUpTestCase() {
     MemoryArbitrator::registerFactory(kind_, factory_);
+    memory::MemoryManager::testingSetInstance({});
   }
 
   static void TearDownTestCase() {
@@ -220,7 +387,7 @@ class MemoryArbitratorFactoryTest : public testing::Test {
 TEST_F(MemoryArbitratorFactoryTest, register) {
   VELOX_ASSERT_THROW(
       MemoryArbitrator::registerFactory(kind_, factory_),
-      "Arbitrator factory for kind USER already registered");
+      "Arbitrator factory for kind USER is already registered");
 }
 
 TEST_F(MemoryArbitratorFactoryTest, create) {
@@ -232,6 +399,10 @@ TEST_F(MemoryArbitratorFactoryTest, create) {
 
 class MemoryReclaimerTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   MemoryReclaimerTest() {
     const auto seed =
         std::chrono::system_clock::now().time_since_epoch().count();
@@ -279,7 +450,7 @@ TEST_F(MemoryReclaimerTest, common) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     std::vector<std::shared_ptr<MemoryPool>> pools;
-    auto pool = defaultMemoryManager().addRootPool(
+    auto pool = memory::memoryManager()->addRootPool(
         "shrinkAPIs", kMaxMemory, memory::MemoryReclaimer::create());
     pools.push_back(pool);
 
@@ -312,12 +483,13 @@ TEST_F(MemoryReclaimerTest, common) {
       }
     }
     for (auto& pool : pools) {
-      uint64_t reclaimableBytes;
-      ASSERT_FALSE(pool->reclaimableBytes(reclaimableBytes));
-      ASSERT_EQ(reclaimableBytes, 0);
-      ASSERT_EQ(pool->reclaim(0, stats_), 0);
-      ASSERT_EQ(pool->reclaim(100, stats_), 0);
-      ASSERT_EQ(pool->reclaim(kMaxMemory, stats_), 0);
+      ASSERT_FALSE(pool->reclaimableBytes().has_value());
+      ASSERT_EQ(pool->reclaim(0, 0, stats_), 0);
+      ASSERT_EQ(stats_, MemoryReclaimer::Stats{});
+      ASSERT_EQ(pool->reclaim(100, 0, stats_), 0);
+      ASSERT_EQ(stats_, MemoryReclaimer::Stats{});
+      ASSERT_EQ(pool->reclaim(kMaxMemory, 0, stats_), 0);
+      ASSERT_EQ(stats_, MemoryReclaimer::Stats{});
     }
     ASSERT_EQ(stats_, MemoryReclaimer::Stats{});
     for (const auto& allocation : allocations) {
@@ -328,16 +500,37 @@ TEST_F(MemoryReclaimerTest, common) {
 
 class MockLeafMemoryReclaimer : public MemoryReclaimer {
  public:
-  explicit MockLeafMemoryReclaimer(std::atomic<uint64_t>& totalUsedBytes)
-      : totalUsedBytes_(totalUsedBytes) {}
+  explicit MockLeafMemoryReclaimer(
+      std::atomic<uint64_t>& totalUsedBytes,
+      bool reclaimable = true,
+      bool* underArbitration = nullptr)
+      : reclaimable_(reclaimable),
+        underArbitration_(underArbitration),
+        totalUsedBytes_(totalUsedBytes) {}
 
   ~MockLeafMemoryReclaimer() override {
     VELOX_CHECK(allocations_.empty());
   }
 
+  virtual void enterArbitration() override {
+    if (underArbitration_ != nullptr) {
+      *underArbitration_ = true;
+    }
+  }
+
+  virtual void leaveArbitration() noexcept override {
+    if (underArbitration_ != nullptr) {
+      *underArbitration_ = false;
+    }
+  }
+
   bool reclaimableBytes(const MemoryPool& pool, uint64_t& bytes)
       const override {
     VELOX_CHECK_EQ(pool.name(), pool_->name());
+    if (!reclaimable_) {
+      bytes = 0;
+      return false;
+    }
     bytes = reclaimableBytes();
     return true;
   }
@@ -345,7 +538,12 @@ class MockLeafMemoryReclaimer : public MemoryReclaimer {
   uint64_t reclaim(
       MemoryPool* /*unused*/,
       uint64_t targetBytes,
+      uint64_t /*unused*/,
       Stats& stats) noexcept override {
+    ++reclaimCount_;
+    if (!reclaimable_) {
+      return 0;
+    }
     std::lock_guard<std::mutex> l(mu_);
     uint64_t reclaimedBytes{0};
     while (!allocations_.empty() &&
@@ -354,6 +552,7 @@ class MockLeafMemoryReclaimer : public MemoryReclaimer {
       reclaimedBytes += allocations_.front().size;
       allocations_.pop_front();
     }
+    stats.reclaimedBytes += reclaimedBytes;
     return reclaimedBytes;
   }
 
@@ -369,6 +568,18 @@ class MockLeafMemoryReclaimer : public MemoryReclaimer {
     totalUsedBytes_ += size;
   }
 
+  int reclaimCount() const {
+    return reclaimCount_;
+  }
+
+  void freeAll() {
+    std::lock_guard<std::mutex> l(mu_);
+    while (!allocations_.empty()) {
+      free(allocations_.front());
+      allocations_.pop_front();
+    }
+  }
+
  private:
   struct Allocation {
     void* buffer;
@@ -378,10 +589,11 @@ class MockLeafMemoryReclaimer : public MemoryReclaimer {
   void free(const Allocation& allocation) {
     pool_->free(allocation.buffer, allocation.size);
     totalUsedBytes_ -= allocation.size;
-    VELOX_CHECK_GE(totalUsedBytes_, 0);
+    VELOX_CHECK_GE(static_cast<int>(totalUsedBytes_), 0);
   }
 
   uint64_t reclaimableBytes() const {
+    VELOX_CHECK(reclaimable_);
     uint64_t sumBytes{0};
     std::lock_guard<std::mutex> l(mu_);
     for (const auto& allocation : allocations_) {
@@ -390,7 +602,10 @@ class MockLeafMemoryReclaimer : public MemoryReclaimer {
     return sumBytes;
   }
 
-  std::atomic<uint64_t>& totalUsedBytes_;
+  const bool reclaimable_{true};
+  bool* const underArbitration_{nullptr};
+  std::atomic_uint64_t& totalUsedBytes_;
+  std::atomic_int reclaimCount_{0};
   mutable std::mutex mu_;
   MemoryPool* pool_{nullptr};
   std::deque<Allocation> allocations_;
@@ -402,7 +617,7 @@ TEST_F(MemoryReclaimerTest, mockReclaim) {
   const int numAllocationsPerLeaf = 10;
   const int allocBytes = 10;
   std::atomic<uint64_t> totalUsedBytes{0};
-  auto root = defaultMemoryManager().addRootPool(
+  auto root = memory::memoryManager()->addRootPool(
       "mockReclaim", kMaxMemory, MemoryReclaimer::create());
   std::vector<std::shared_ptr<MemoryPool>> childPools;
   for (int i = 0; i < numChildren; ++i) {
@@ -427,26 +642,29 @@ TEST_F(MemoryReclaimerTest, mockReclaim) {
   ASSERT_EQ(
       numGrandchildren * numChildren * numAllocationsPerLeaf * allocBytes,
       totalUsedBytes);
-  uint64_t reclaimableBytes;
-  ASSERT_TRUE(root->reclaimableBytes(reclaimableBytes));
-  ASSERT_EQ(reclaimableBytes, totalUsedBytes);
+  ASSERT_EQ(root->reclaimableBytes().value(), totalUsedBytes);
   const int numReclaims = 5;
   const int numBytesToReclaim = allocBytes * 3;
   for (int iter = 0; iter < numReclaims; ++iter) {
-    const auto reclaimedBytes = root->reclaim(numBytesToReclaim, stats_);
+    const auto reclaimedBytes = root->reclaim(numBytesToReclaim, 0, stats_);
     ASSERT_EQ(reclaimedBytes, numBytesToReclaim);
-    ASSERT_TRUE(root->reclaimableBytes(reclaimableBytes));
-    ASSERT_EQ(reclaimableBytes, totalUsedBytes);
+    ASSERT_EQ(reclaimedBytes, stats_.reclaimedBytes);
+    ASSERT_EQ(root->reclaimableBytes().value(), totalUsedBytes);
+    stats_.reset();
   }
-  ASSERT_TRUE(root->reclaimableBytes(reclaimableBytes));
-  ASSERT_EQ(totalUsedBytes, reclaimableBytes);
-  ASSERT_EQ(root->reclaim(allocBytes + 1, stats_), 2 * allocBytes);
-  ASSERT_EQ(root->reclaim(allocBytes - 1, stats_), allocBytes);
+
+  ASSERT_EQ(totalUsedBytes, root->reclaimableBytes().value());
+  ASSERT_EQ(root->reclaim(allocBytes + 1, 0, stats_), 2 * allocBytes);
+  ASSERT_EQ(root->reclaim(allocBytes - 1, 0, stats_), allocBytes);
+  ASSERT_EQ(3 * allocBytes, stats_.reclaimedBytes);
+
   const uint64_t expectedReclaimedBytes = totalUsedBytes;
-  ASSERT_EQ(root->reclaim(0, stats_), expectedReclaimedBytes);
+  ASSERT_EQ(root->reclaim(0, 0, stats_), expectedReclaimedBytes);
+  ASSERT_EQ(3 * allocBytes + expectedReclaimedBytes, stats_.reclaimedBytes);
   ASSERT_EQ(totalUsedBytes, 0);
-  ASSERT_TRUE(root->reclaimableBytes(reclaimableBytes));
-  ASSERT_EQ(reclaimableBytes, 0);
+  ASSERT_EQ(root->reclaimableBytes().value(), 0);
+
+  stats_.reset();
   ASSERT_EQ(stats_, MemoryReclaimer::Stats{});
 }
 
@@ -455,7 +673,7 @@ TEST_F(MemoryReclaimerTest, mockReclaimMoreThanAvailable) {
   const int numAllocationsPerLeaf = 10;
   const int allocBytes = 100;
   std::atomic<uint64_t> totalUsedBytes{0};
-  auto root = defaultMemoryManager().addRootPool(
+  auto root = memory::memoryManager()->addRootPool(
       "mockReclaimMoreThanAvailable", kMaxMemory, MemoryReclaimer::create());
   std::vector<std::shared_ptr<MemoryPool>> childPools;
   for (int i = 0; i < numChildren; ++i) {
@@ -473,18 +691,86 @@ TEST_F(MemoryReclaimerTest, mockReclaimMoreThanAvailable) {
     }
   }
   ASSERT_EQ(numChildren * numAllocationsPerLeaf * allocBytes, totalUsedBytes);
-  uint64_t reclaimableBytes;
-  ASSERT_TRUE(root->reclaimableBytes(reclaimableBytes));
+  uint64_t reclaimableBytes = root->reclaimableBytes().value();
   ASSERT_EQ(reclaimableBytes, totalUsedBytes);
   const uint64_t expectedReclaimedBytes = totalUsedBytes;
   ASSERT_EQ(
-      root->reclaim(totalUsedBytes + 100, stats_), expectedReclaimedBytes);
+      root->reclaim(totalUsedBytes + 100, 0, stats_), expectedReclaimedBytes);
+  ASSERT_EQ(expectedReclaimedBytes, stats_.reclaimedBytes);
   ASSERT_EQ(totalUsedBytes, 0);
-  ASSERT_TRUE(root->reclaimableBytes(reclaimableBytes));
+  reclaimableBytes = root->reclaimableBytes().value();
   ASSERT_EQ(reclaimableBytes, 0);
+  stats_.reset();
   ASSERT_EQ(stats_, MemoryReclaimer::Stats{});
 }
 
+TEST_F(MemoryReclaimerTest, scopedReclaimedBytesRecorder) {
+  auto root = memory::memoryManager()->addRootPool(
+      "memoryReclaimRecorder", kMaxMemory, MemoryReclaimer::create());
+  auto childPool = root->addLeafChild("memoryReclaimRecorder", true);
+  ASSERT_EQ(childPool->reservedBytes(), 0);
+  int64_t reclaimedBytes{0};
+  { ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes); }
+  ASSERT_EQ(reclaimedBytes, 0);
+
+  void* buffer = childPool->allocate(1 << 20);
+  ASSERT_EQ(childPool->reservedBytes(), 1 << 20);
+  { ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes); }
+  ASSERT_EQ(reclaimedBytes, 0);
+
+  reclaimedBytes = 0;
+  {
+    ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes);
+    childPool->free(buffer, 1 << 20);
+  }
+  ASSERT_EQ(reclaimedBytes, 1 << 20);
+
+  childPool->maybeReserve(1 << 20);
+  buffer = childPool->allocate(1 << 20);
+  ASSERT_EQ(childPool->reservedBytes(), 8 << 20);
+  reclaimedBytes = 0;
+  {
+    ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes);
+    childPool->free(buffer, 1 << 20);
+  }
+  ASSERT_EQ(reclaimedBytes, 0);
+
+  {
+    ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes);
+    childPool->release();
+  }
+  ASSERT_EQ(reclaimedBytes, 8 << 20);
+
+  // Bad state.
+  reclaimedBytes = 100;
+  VELOX_ASSERT_THROW(
+      ScopedReclaimedBytesRecorder(childPool.get(), &reclaimedBytes),
+      "(100 vs. 0)");
+
+  reclaimedBytes = 0;
+  buffer = childPool->allocate(1 << 20);
+  {
+    const std::string throwMsg("throw");
+    try {
+      ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes);
+      childPool->free(buffer, 1 << 20);
+      VELOX_FAIL(throwMsg);
+    } catch (const VeloxRuntimeError& ex) {
+      ASSERT_EQ(ex.message(), throwMsg);
+    }
+  }
+  ASSERT_EQ(reclaimedBytes, 0);
+
+  // Negative reclaim.
+  reclaimedBytes = 0;
+  {
+    ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes);
+    buffer = childPool->allocate(1 << 20);
+  }
+  ASSERT_EQ(reclaimedBytes, -(1 << 20));
+  childPool->free(buffer, 1 << 20);
+}
+
 TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // Set 1MB unit to avoid memory pool quantized reservation effect.
   const int allocUnitBytes = 1L << 20;
@@ -493,7 +779,7 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   const std::vector<int> initAllocUnitsVec = {10, 11, 8, 16, 5};
   ASSERT_EQ(initAllocUnitsVec.size(), numChildren);
   std::atomic<uint64_t> totalUsedBytes{0};
-  auto root = defaultMemoryManager().addRootPool(
+  auto root = memory::memoryManager()->addRootPool(
       "orderedReclaim", kMaxMemory, MemoryReclaimer::create());
   int totalAllocUnits{0};
   std::vector<std::shared_ptr<MemoryPool>> childPools;
@@ -537,8 +823,9 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // child.
   // So expected reclaimable allocation units are {10, 11, 8, *14*, 5}
   ASSERT_EQ(
-      root->reclaimer()->reclaim(root.get(), 2 * allocUnitBytes, stats_),
+      root->reclaimer()->reclaim(root.get(), 2 * allocUnitBytes, 0, stats_),
       2 * allocUnitBytes);
+  ASSERT_EQ(2 * allocUnitBytes, stats_.reclaimedBytes);
   totalAllocUnits -= 2;
   verify({10, 11, 8, 14, 5});
 
@@ -546,8 +833,9 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // child.
   // So expected reclaimable allocation units are {10, 11, 8, *12*, 5}
   ASSERT_EQ(
-      root->reclaimer()->reclaim(root.get(), 2 * allocUnitBytes, stats_),
+      root->reclaimer()->reclaim(root.get(), 2 * allocUnitBytes, 0, stats_),
       2 * allocUnitBytes);
+  ASSERT_EQ(4 * allocUnitBytes, stats_.reclaimedBytes);
   totalAllocUnits -= 2;
   verify({10, 11, 8, 12, 5});
 
@@ -555,8 +843,9 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // child.
   // So expected reclaimable allocation units are {10, 11, 8, *4*, 5}
   ASSERT_EQ(
-      root->reclaimer()->reclaim(root.get(), 8 * allocUnitBytes, stats_),
+      root->reclaimer()->reclaim(root.get(), 8 * allocUnitBytes, 0, stats_),
       8 * allocUnitBytes);
+  ASSERT_EQ(12 * allocUnitBytes, stats_.reclaimedBytes);
   totalAllocUnits -= 8;
   verify({10, 11, 8, 4, 5});
 
@@ -564,7 +853,7 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // child.
   // So expected reclaimable allocation gunits are {10, *9*, 8, 4, 5}
   ASSERT_EQ(
-      root->reclaimer()->reclaim(root.get(), 2 * allocUnitBytes, stats_),
+      root->reclaimer()->reclaim(root.get(), 2 * allocUnitBytes, 0, stats_),
       2 * allocUnitBytes);
   totalAllocUnits -= 2;
   verify({10, 9, 8, 4, 5});
@@ -573,7 +862,7 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // child.
   // So expected reclaimable allocation units are {*7*, 9, 8, 4, 5}
   ASSERT_EQ(
-      root->reclaimer()->reclaim(root.get(), 3 * allocUnitBytes, stats_),
+      root->reclaimer()->reclaim(root.get(), 3 * allocUnitBytes, 0, stats_),
       3 * allocUnitBytes);
   totalAllocUnits -= 3;
   verify({7, 9, 8, 4, 5});
@@ -582,7 +871,7 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // child and two from 2nd child.
   // So expected reclaimable allocation units are {7, *0*, *6*, 4, 5}
   ASSERT_EQ(
-      root->reclaimer()->reclaim(root.get(), 11 * allocUnitBytes, stats_),
+      root->reclaimer()->reclaim(root.get(), 11 * allocUnitBytes, 0, stats_),
       11 * allocUnitBytes);
   totalAllocUnits -= 11;
   verify({7, 0, 6, 4, 5});
@@ -591,7 +880,7 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // child and three from 2nd child.
   // So expected reclaimable allocation units are {*0*, 0, *3*, 4, 5}
   ASSERT_EQ(
-      root->reclaimer()->reclaim(root.get(), 10 * allocUnitBytes, stats_),
+      root->reclaimer()->reclaim(root.get(), 10 * allocUnitBytes, 0, stats_),
       10 * allocUnitBytes);
   totalAllocUnits -= 10;
   verify({0, 0, 3, 4, 5});
@@ -600,7 +889,7 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // child and 4 from 4th child and 1 from 2nd.
   // So expected reclaimable allocation units are {0, 0, 2, *0*, *0*}
   ASSERT_EQ(
-      root->reclaimer()->reclaim(root.get(), 10 * allocUnitBytes, stats_),
+      root->reclaimer()->reclaim(root.get(), 10 * allocUnitBytes, 0, stats_),
       10 * allocUnitBytes);
   totalAllocUnits -= 10;
   verify({0, 0, 2, 0, 0});
@@ -609,15 +898,88 @@ TEST_F(MemoryReclaimerTest, orderedReclaim) {
   // cleared.
   ASSERT_EQ(
       root->reclaimer()->reclaim(
-          root.get(), totalAllocUnits * allocUnitBytes, stats_),
+          root.get(), totalAllocUnits * allocUnitBytes, 0, stats_),
       totalAllocUnits * allocUnitBytes);
   totalAllocUnits = 0;
   verify({0, 0, 0, 0, 0});
+  stats_.reset();
   ASSERT_EQ(stats_, MemoryReclaimer::Stats{});
 }
 
+TEST_F(MemoryReclaimerTest, skipNonReclaimableChild) {
+  // Set 1MB unit to avoid memory pool quantized reservation effect.
+  const int allocUnitBytes = 1L << 20;
+  const int numChildren = 5;
+  // The initial allocation units per each child pool.
+  const std::vector<int> initAllocUnitsVec = {10, 11, 8, 16, 5};
+  const std::vector<bool> reclaimableChildVec = {
+      true, false, true, false, true};
+  ASSERT_EQ(initAllocUnitsVec.size(), numChildren);
+  std::atomic<uint64_t> totalUsedBytes{0};
+  auto root = memory::memoryManager()->addRootPool(
+      "orderedReclaim", kMaxMemory, MemoryReclaimer::create());
+  int totalAllocUnits{0};
+  std::vector<std::shared_ptr<MemoryPool>> childPools;
+  for (int i = 0; i < numChildren; ++i) {
+    auto childPool = root->addLeafChild(
+        std::to_string(i),
+        true,
+        std::make_unique<MockLeafMemoryReclaimer>(
+            totalUsedBytes, reclaimableChildVec[i]));
+    childPools.push_back(childPool);
+    auto* reclaimer =
+        static_cast<MockLeafMemoryReclaimer*>(childPool->reclaimer());
+    reclaimer->setPool(childPool.get());
+
+    const auto initAllocUnit = initAllocUnitsVec[i];
+    totalAllocUnits += initAllocUnit;
+    for (int j = 0; j < initAllocUnit; ++j) {
+      void* buffer = childPool->allocate(allocUnitBytes);
+      reclaimer->addAllocation(buffer, allocUnitBytes);
+    }
+  }
+
+  uint64_t reclaimableBytes{0};
+  // 'expectedReclaimableUnits' is the expected allocation unit per each child
+  // pool after each round of memory reclaim. And we expect the memory reclaimer
+  // always reclaim from the child with most meomry usage.
+  auto verify = [&](const std::vector<int>& expectedReclaimableUnits) {
+    uint64_t expectedTotalReclaimableBytes{0};
+    for (int i = 0; i < numChildren; ++i) {
+      auto* reclaimer =
+          static_cast<MockLeafMemoryReclaimer*>(childPools[i]->reclaimer());
+      reclaimer->reclaimableBytes(*childPools[i], reclaimableBytes);
+      ASSERT_EQ(reclaimableBytes, expectedReclaimableUnits[i] * allocUnitBytes)
+          << " " << i;
+      expectedTotalReclaimableBytes += reclaimableBytes;
+    }
+    root->reclaimer()->reclaimableBytes(*root, reclaimableBytes);
+    ASSERT_EQ(reclaimableBytes, expectedTotalReclaimableBytes);
+  };
+  const std::vector<int> expectedReclaimableUnits{10, 0, 8, 0, 5};
+  // No reclaim so far so just expect the initial allocation unit distribution.
+  verify(expectedReclaimableUnits);
+
+  // Tries to reclaim all units and only expect to reclaim from reclaimable
+  // child pools.
+  ASSERT_EQ(
+      root->reclaimer()->reclaim(
+          root.get(), totalAllocUnits * allocUnitBytes, 0, stats_),
+      23 * allocUnitBytes);
+  for (int i = 0; i < numChildren; ++i) {
+    auto* reclaimer =
+        static_cast<MockLeafMemoryReclaimer*>(childPools[i]->reclaimer());
+    if (reclaimableChildVec[i]) {
+      ASSERT_EQ(reclaimer->reclaimCount(), 1);
+    } else {
+      ASSERT_EQ(reclaimer->reclaimCount(), 0);
+    }
+    reclaimer->freeAll();
+  }
+}
+
 TEST_F(MemoryReclaimerTest, arbitrationContext) {
-  auto root = defaultMemoryManager().addRootPool(
+  auto root = memory::memoryManager()->addRootPool(
       "arbitrationContext", kMaxMemory, MemoryReclaimer::create());
   ASSERT_FALSE(isSpillMemoryPool(root.get()));
   ASSERT_TRUE(isSpillMemoryPool(spillMemoryPool()));
@@ -627,29 +989,29 @@ TEST_F(MemoryReclaimerTest, arbitrationContext) {
   ASSERT_FALSE(isSpillMemoryPool(leafChild2.get()));
   ASSERT_TRUE(memoryArbitrationContext() == nullptr);
   {
-    ScopedMemoryArbitrationContext arbitrationContext(*leafChild1);
+    ScopedMemoryArbitrationContext arbitrationContext(leafChild1.get());
     ASSERT_TRUE(memoryArbitrationContext() != nullptr);
-    ASSERT_EQ(&memoryArbitrationContext()->requestor, leafChild1.get());
+    ASSERT_EQ(memoryArbitrationContext()->requestor, leafChild1.get());
   }
   ASSERT_TRUE(memoryArbitrationContext() == nullptr);
   {
-    ScopedMemoryArbitrationContext arbitrationContext(*leafChild2);
+    ScopedMemoryArbitrationContext arbitrationContext(leafChild2.get());
     ASSERT_TRUE(memoryArbitrationContext() != nullptr);
-    ASSERT_EQ(&memoryArbitrationContext()->requestor, leafChild2.get());
+    ASSERT_EQ(memoryArbitrationContext()->requestor, leafChild2.get());
   }
   ASSERT_TRUE(memoryArbitrationContext() == nullptr);
   std::thread nonAbitrationThread([&]() {
     ASSERT_TRUE(memoryArbitrationContext() == nullptr);
     {
-      ScopedMemoryArbitrationContext arbitrationContext(*leafChild1);
+      ScopedMemoryArbitrationContext arbitrationContext(leafChild1.get());
       ASSERT_TRUE(memoryArbitrationContext() != nullptr);
-      ASSERT_EQ(&memoryArbitrationContext()->requestor, leafChild1.get());
+      ASSERT_EQ(memoryArbitrationContext()->requestor, leafChild1.get());
     }
     ASSERT_TRUE(memoryArbitrationContext() == nullptr);
     {
-      ScopedMemoryArbitrationContext arbitrationContext(*leafChild2);
+      ScopedMemoryArbitrationContext arbitrationContext(leafChild2.get());
       ASSERT_TRUE(memoryArbitrationContext() != nullptr);
-      ASSERT_EQ(&memoryArbitrationContext()->requestor, leafChild2.get());
+      ASSERT_EQ(memoryArbitrationContext()->requestor, leafChild2.get());
     }
     ASSERT_TRUE(memoryArbitrationContext() == nullptr);
   });
@@ -657,8 +1019,44 @@ TEST_F(MemoryReclaimerTest, arbitrationContext) {
   ASSERT_TRUE(memoryArbitrationContext() == nullptr);
 }
 
+TEST_F(MemoryReclaimerTest, scopedMemoryPoolArbitrationCtx) {
+  auto root = memory::memoryManager()->addRootPool(
+      "scopedArbitration", kMaxMemory, MemoryReclaimer::create());
+  std::atomic<uint64_t> totalUsedBytes{0};
+  bool underArbitration{false};
+  auto leafChild = root->addLeafChild(
+      "scopedArbitration",
+      true,
+      std::make_unique<MockLeafMemoryReclaimer>(
+          totalUsedBytes, true, &underArbitration));
+  ASSERT_FALSE(underArbitration);
+  {
+    ScopedMemoryPoolArbitrationCtx arbitrationCtx(leafChild.get());
+    ASSERT_TRUE(memoryArbitrationContext() == nullptr);
+    ASSERT_TRUE(underArbitration);
+  }
+  ASSERT_FALSE(underArbitration);
+  ASSERT_TRUE(memoryArbitrationContext() == nullptr);
+
+  std::thread abitrationThread([&]() {
+    ASSERT_TRUE(memoryArbitrationContext() == nullptr);
+    {
+      ScopedMemoryPoolArbitrationCtx arbitrationCtx(leafChild.get());
+      ASSERT_TRUE(memoryArbitrationContext() == nullptr);
+      ASSERT_TRUE(underArbitration);
+    }
+    ASSERT_FALSE(underArbitration);
+    ASSERT_TRUE(memoryArbitrationContext() == nullptr);
+  });
+  abitrationThread.join();
+
+  ASSERT_FALSE(underArbitration);
+
+  ASSERT_TRUE(memoryArbitrationContext() == nullptr);
+}
+
 TEST_F(MemoryReclaimerTest, concurrentRandomMockReclaims) {
-  auto root = defaultMemoryManager().addRootPool(
+  auto root = memory::memoryManager()->addRootPool(
       "concurrentRandomMockReclaims", kMaxMemory, MemoryReclaimer::create());
 
   std::atomic<uint64_t> totalUsedBytes{0};
@@ -681,6 +1079,7 @@ TEST_F(MemoryReclaimerTest, concurrentRandomMockReclaims) {
   }
 
   const int32_t kNumReclaims = 100;
+  uint64_t totalReclaimedBytes = 0;
   std::thread reclaimerThread([&]() {
     for (int i = 0; i < kNumReclaims; ++i) {
       const uint64_t oldUsedBytes = totalUsedBytes;
@@ -696,7 +1095,8 @@ TEST_F(MemoryReclaimerTest, concurrentRandomMockReclaims) {
           bytesToReclaim = 0;
         }
       }
-      const auto reclaimedBytes = root->reclaim(bytesToReclaim, stats_);
+      const auto reclaimedBytes = root->reclaim(bytesToReclaim, 0, stats_);
+      totalReclaimedBytes += reclaimedBytes;
       if (reclaimedBytes < bytesToReclaim) {
         ASSERT_GT(bytesToReclaim, oldUsedBytes);
       }
@@ -730,15 +1130,16 @@ TEST_F(MemoryReclaimerTest, concurrentRandomMockReclaims) {
   }
   reclaimerThread.join();
 
-  uint64_t reclaimableBytes;
-  ASSERT_TRUE(root->reclaimableBytes(reclaimableBytes));
+  uint64_t reclaimableBytes = root->reclaimableBytes().value();
   ASSERT_EQ(reclaimableBytes, totalUsedBytes);
 
-  root->reclaim(0, stats_);
+  root->reclaim(0, 0, stats_);
+  ASSERT_EQ(totalReclaimedBytes + reclaimableBytes, stats_.reclaimedBytes);
 
-  ASSERT_TRUE(root->reclaimableBytes(reclaimableBytes));
+  reclaimableBytes = root->reclaimableBytes().value();
   ASSERT_EQ(reclaimableBytes, 0);
   ASSERT_EQ(totalUsedBytes, 0);
+  stats_.reset();
   ASSERT_EQ(stats_, MemoryReclaimer::Stats{});
 }
 
@@ -756,5 +1157,10 @@ TEST_F(MemoryArbitrationTest, reclaimerStats) {
   ASSERT_NE(stats1, stats2);
   stats1.reset();
   ASSERT_EQ(stats1, stats2);
+  MemoryReclaimer::Stats sum{1, 1, 1, 1};
+  MemoryReclaimer::Stats toAdd{1, 1, 1, 1};
+  sum += toAdd;
+  const MemoryReclaimer::Stats expected{2, 2, 2, 2};
+  ASSERT_EQ(sum, expected);
 }
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/tests/MemoryCapExceededTest.cpp b/velox/common/memory/tests/MemoryCapExceededTest.cpp
index 49cbadc9f1647..b334d16a4c054 100644
--- a/velox/common/memory/tests/MemoryCapExceededTest.cpp
+++ b/velox/common/memory/tests/MemoryCapExceededTest.cpp
@@ -68,14 +68,15 @@ TEST_P(MemoryCapExceededTest, singleDriver) {
   // We look for these lines separately, since their order can change (not sure
   // why).
   std::vector<std::string> expectedTexts = {
-      "Exceeded memory pool cap of 5.00MB with max 5.00MB when requesting "
-      "2.00MB, memory manager cap is UNLIMITED, requestor "
-      "'op.2.0.0.Aggregation' with current usage 3.70MB"};
+      "Exceeded memory pool capacity after attempt to grow capacity through "
+      "arbitration. Requestor pool name 'op.2.0.0.Aggregation', request size "
+      "2.00MB, memory pool capacity 5.00MB, memory pool max capacity 5.00MB, "
+      "memory manager capacity 8.00GB, current usage 3.70MB"};
   std::vector<std::string> expectedDetailedTexts = {
-      "node.1 usage 1.00MB peak 1.00MB",
-      "op.1.0.0.FilterProject usage 12.00KB peak 12.00KB",
-      "node.2 usage 4.00MB peak 4.00MB",
-      "op.2.0.0.Aggregation usage 3.70MB peak 3.70MB",
+      "node.1 usage 12.00KB reserved 1.00MB peak 1.00MB",
+      "op.1.0.0.FilterProject usage 12.00KB reserved 1.00MB peak 12.00KB",
+      "node.2 usage 3.70MB reserved 4.00MB peak 4.00MB",
+      "op.2.0.0.Aggregation usage 3.70MB reserved 4.00MB peak 3.70MB",
       "Top 2 leaf memory pool usages:"};
 
   std::vector<RowVectorPtr> data;
@@ -95,10 +96,9 @@ TEST_P(MemoryCapExceededTest, singleDriver) {
                   .singleAggregation({"c0"}, {"sum(p1)"})
                   .orderBy({"c0"}, false)
                   .planNode();
-  auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  queryCtx->testingOverrideMemoryPool(
-      memory::defaultMemoryManager().addRootPool(
-          queryCtx->queryId(), kMaxBytes));
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+      queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
   CursorParameters params;
   params.planNode = plan;
   params.queryCtx = queryCtx;
@@ -154,10 +154,9 @@ TEST_P(MemoryCapExceededTest, multipleDrivers) {
                   .values(data, true)
                   .singleAggregation({"c0"}, {"sum(c1)"})
                   .planNode();
-  auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  queryCtx->testingOverrideMemoryPool(
-      memory::defaultMemoryManager().addRootPool(
-          queryCtx->queryId(), kMaxBytes));
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+      queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
 
   const int32_t numDrivers = 10;
   CursorParameters params;
@@ -184,29 +183,31 @@ TEST_P(MemoryCapExceededTest, multipleDrivers) {
 TEST_P(MemoryCapExceededTest, allocatorCapacityExceededError) {
   // Executes a plan with no memory pool capacity limit but very small memory
   // manager's limit.
-  std::vector<std::pair<
-      std::shared_ptr<memory::MemoryAllocator>,
-      std::vector<std::string>>>
-      allocatorExpectations;
-  allocatorExpectations.push_back(std::pair{
-      std::make_shared<memory::MallocAllocator>(64LL << 20),
-      std::vector<std::string>{
-          "allocateContiguous failed with .* pages",
-          "max capacity 128.00MB unlimited capacity used .* available .*",
-          ".* reservation .used .*MB, reserved .*MB, min 0B. counters",
-          "allocs .*, frees .*, reserves .*, releases .*, collisions .*"}});
-  const memory::MmapAllocator::Options options = {.capacity = 64LL << 20};
-  allocatorExpectations.push_back(std::pair{
-      std::make_shared<memory::MmapAllocator>(options),
-      std::vector<std::string>{
-          "allocateContiguous failed with .* pages",
-          "max capacity 128.00MB unlimited capacity used .* available .*",
-          ".* reservation .used .*MB, reserved .*MB, min .*B. counters",
-          ".*, frees .*, reserves .*, releases .*, collisions .*"}});
-  for (auto& allocExp : allocatorExpectations) {
+  struct {
+    int64_t allocatorCapacity;
+    bool useMmap;
+    std::vector<std::string> expectedErrorMessages;
+  } testSettings[] = {
+      {64LL << 20,
+       false,
+       std::vector<std::string>{
+           "allocateContiguous failed with .* pages",
+           "max capacity 128.00MB unlimited capacity used .* available .*",
+           ".* reservation .used .*MB, reserved .*MB, min 0B. counters",
+           "allocs .*, frees .*, reserves .*, releases .*, collisions .*"}},
+      {64LL << 20,
+       true,
+       std::vector<std::string>{
+           "allocateContiguous failed with .* pages",
+           "max capacity 128.00MB unlimited capacity used .* available .*",
+           ".* reservation .used .*MB, reserved .*MB, min .*B. counters",
+           ".*, frees .*, reserves .*, releases .*, collisions .*"}}};
+  for (const auto& testData : testSettings) {
     memory::MemoryManager manager(
-        {.capacity = (int64_t)allocExp.first->capacity(),
-         .allocator = allocExp.first.get()});
+        {.allocatorCapacity = (int64_t)testData.allocatorCapacity,
+         .useMmapAllocator = testData.useMmap,
+         .arbitratorCapacity = (int64_t)testData.allocatorCapacity,
+         .arbitratorReservedCapacity = 0});
 
     vector_size_t size = 1'024;
     // This limit ensures that only the Aggregation Operator fails.
@@ -229,7 +230,7 @@ TEST_P(MemoryCapExceededTest, allocatorCapacityExceededError) {
                     .singleAggregation({"c0"}, {"sum(p1)"})
                     .orderBy({"c0"}, false)
                     .planNode();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+    auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
         manager.addRootPool(queryCtx->queryId(), kMaxBytes));
     CursorParameters params;
@@ -241,7 +242,7 @@ TEST_P(MemoryCapExceededTest, allocatorCapacityExceededError) {
       FAIL() << "Expected a MEM_CAP_EXCEEDED RuntimeException.";
     } catch (const VeloxException& e) {
       const auto errorMessage = e.message();
-      for (const auto& expectedText : allocExp.second) {
+      for (const auto& expectedText : testData.expectedErrorMessages) {
         ASSERT_TRUE(someLineMatches(errorMessage, expectedText))
             << "Expected error message to contain '" << expectedText
             << "', but received '" << errorMessage << "'.";
diff --git a/velox/common/memory/tests/MemoryManagerTest.cpp b/velox/common/memory/tests/MemoryManagerTest.cpp
index bdeb39b7eb3dc..84bf4a97ea63a 100644
--- a/velox/common/memory/tests/MemoryManagerTest.cpp
+++ b/velox/common/memory/tests/MemoryManagerTest.cpp
@@ -14,24 +14,26 @@
  * limitations under the License.
  */
 
+#include <fmt/format.h>
 #include <gtest/gtest.h>
+#include <vector>
 
+#include <gmock/gmock-matchers.h>
 #include "velox/common/base/VeloxException.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/MallocAllocator.h"
 #include "velox/common/memory/Memory.h"
+#include "velox/common/memory/SharedArbitrator.h"
 
 DECLARE_int32(velox_memory_num_shared_leaf_pools);
 DECLARE_bool(velox_enable_memory_usage_track_in_default_memory_pool);
 
 using namespace ::testing;
 
-namespace facebook {
-namespace velox {
-namespace memory {
+namespace facebook::velox::memory {
 
 namespace {
-constexpr folly::StringPiece kDefaultRootName{"__default_root__"};
+constexpr folly::StringPiece kSysRootName{"__sys_root__"};
 
 MemoryManager& toMemoryManager(MemoryManager& manager) {
   return *static_cast<MemoryManager*>(&manager);
@@ -41,18 +43,18 @@ MemoryManager& toMemoryManager(MemoryManager& manager) {
 class MemoryManagerTest : public testing::Test {
  protected:
   static void SetUpTestCase() {
-    MemoryArbitrator::registerAllFactories();
+    SharedArbitrator::registerFactory();
   }
 
   inline static const std::string arbitratorKind_{"SHARED"};
 };
 
-TEST_F(MemoryManagerTest, Ctor) {
+TEST_F(MemoryManagerTest, ctor) {
   const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools;
   {
     MemoryManager manager{};
-    ASSERT_EQ(manager.numPools(), 0);
-    ASSERT_EQ(manager.capacity(), MemoryAllocator::kDefaultCapacityBytes);
+    ASSERT_EQ(manager.numPools(), 2);
+    ASSERT_EQ(manager.capacity(), kMaxMemory);
     ASSERT_EQ(0, manager.getTotalBytes());
     ASSERT_EQ(manager.alignment(), MemoryAllocator::kMaxAlignment);
     ASSERT_EQ(manager.testingDefaultRoot().alignment(), manager.alignment());
@@ -62,32 +64,36 @@ TEST_F(MemoryManagerTest, Ctor) {
   }
   {
     const auto kCapacity = 8L * 1024 * 1024;
-    auto allocator = std::make_shared<MallocAllocator>(kCapacity);
     MemoryManager manager{
-        {.capacity = kCapacity, .allocator = allocator.get()}};
+        {.allocatorCapacity = kCapacity,
+         .arbitratorCapacity = kCapacity,
+         .arbitratorReservedCapacity = 0}};
     ASSERT_EQ(kCapacity, manager.capacity());
-    ASSERT_EQ(manager.numPools(), 0);
+    ASSERT_EQ(manager.numPools(), 2);
     ASSERT_EQ(manager.testingDefaultRoot().alignment(), manager.alignment());
   }
   {
     const auto kCapacity = 8L * 1024 * 1024;
-    auto allocator = std::make_shared<MallocAllocator>(kCapacity);
     MemoryManager manager{
-        {.alignment = 0, .capacity = kCapacity, .allocator = allocator.get()}};
+        {.alignment = 0,
+         .allocatorCapacity = kCapacity,
+         .arbitratorCapacity = kCapacity,
+         .arbitratorReservedCapacity = 0}};
 
     ASSERT_EQ(manager.alignment(), MemoryAllocator::kMinAlignment);
     ASSERT_EQ(manager.testingDefaultRoot().alignment(), manager.alignment());
     // TODO: replace with root pool memory tracker quota check.
-    ASSERT_EQ(kSharedPoolCount, manager.testingDefaultRoot().getChildCount());
+    ASSERT_EQ(
+        kSharedPoolCount + 2, manager.testingDefaultRoot().getChildCount());
     ASSERT_EQ(kCapacity, manager.capacity());
     ASSERT_EQ(0, manager.getTotalBytes());
   }
   {
     MemoryManagerOptions options;
     const auto kCapacity = 4L << 30;
-    auto allocator = std::make_shared<MallocAllocator>(kCapacity);
-    options.capacity = kCapacity;
-    options.allocator = allocator.get();
+    options.allocatorCapacity = kCapacity;
+    options.arbitratorCapacity = kCapacity;
+    options.arbitratorReservedCapacity = 0;
     std::string arbitratorKind = "SHARED";
     options.arbitratorKind = arbitratorKind;
     MemoryManager manager{options};
@@ -96,50 +102,47 @@ TEST_F(MemoryManagerTest, Ctor) {
     ASSERT_EQ(arbitrator->stats().maxCapacityBytes, kCapacity);
     ASSERT_EQ(
         manager.toString(),
-        "Memory Manager[capacity 4.00GB alignment 64B usedBytes 0B number of pools 0\nList of root pools:\n\t__default_root__\nMemory Allocator[MALLOC capacity 4.00GB allocated bytes 0 allocated pages 0 mapped pages 0]\nARBITRATOR[SHARED CAPACITY[4.00GB] STATS[numRequests 0 numSucceeded 0 numAborted 0 numFailures 0 numNonReclaimableAttempts 0 queueTime 0us arbitrationTime 0us reclaimTime 0us shrunkMemory 0B reclaimedMemory 0B maxCapacity 4.00GB freeCapacity 4.00GB]]]");
-  }
-  {
-    // Test construction failure due to inconsistent allocator capacity setting.
-    MemoryManagerOptions options;
-    const auto kCapacity = 8L * 1024 * 1024;
-    options.capacity = kCapacity;
-    auto allocator = std::make_shared<MallocAllocator>(kCapacity + 1);
-    options.allocator = allocator.get();
-    VELOX_ASSERT_THROW(
-        MemoryManager(options),
-        "MemoryAllocator capacity 8388609 must be the same as MemoryManager capacity 8388608");
+        "Memory Manager[capacity 4.00GB alignment 64B usedBytes 0B number of "
+        "pools 2\nList of root pools:\n\t__sys_root__\n"
+        "Memory Allocator[MALLOC capacity 4.00GB allocated bytes 0 "
+        "allocated pages 0 mapped pages 0]\n"
+        "ARBITRATOR[SHARED CAPACITY[4.00GB] PENDING[0] "
+        "STATS[numRequests 0 numAborted 0 numFailures 0 "
+        "numNonReclaimableAttempts 0 numShrinks 0 queueTime 0us "
+        "arbitrationTime 0us reclaimTime 0us shrunkMemory 0B "
+        "reclaimedMemory 0B maxCapacity 4.00GB freeCapacity 4.00GB freeReservedCapacity 0B]]]");
   }
 }
 
 namespace {
 class FakeTestArbitrator : public MemoryArbitrator {
  public:
-  explicit FakeTestArbitrator(const Config& config)
+  explicit FakeTestArbitrator(
+      const Config& config,
+      bool injectAddPoolFailure = false)
       : MemoryArbitrator(
             {.kind = config.kind,
              .capacity = config.capacity,
-             .memoryPoolInitCapacity = config.memoryPoolInitCapacity,
-             .memoryPoolTransferCapacity = config.memoryPoolTransferCapacity}) {
-  }
+             .extraConfigs = config.extraConfigs}),
+        injectAddPoolFailure_(injectAddPoolFailure) {}
 
-  void reserveMemory(MemoryPool* pool, uint64_t bytes) override {
-    VELOX_NYI();
+  void addPool(const std::shared_ptr<MemoryPool>& /*unused*/) override {
+    VELOX_CHECK(!injectAddPoolFailure_, "Failed to add pool");
   }
 
-  void releaseMemory(MemoryPool* pool) override {
+  void removePool(MemoryPool* /*unused*/) override {}
+
+  bool growCapacity(MemoryPool* /*unused*/, uint64_t /*unused*/) override {
     VELOX_NYI();
   }
 
-  bool growMemory(
-      MemoryPool* pool,
-      const std::vector<std::shared_ptr<MemoryPool>>& candidatePools,
-      uint64_t targetBytes) override {
+  uint64_t shrinkCapacity(uint64_t /*unused*/, bool /*unused*/, bool /*unused*/)
+      override {
     VELOX_NYI();
   }
 
-  uint64_t shrinkMemory(
-      const std::vector<std::shared_ptr<MemoryPool>>& pools,
-      uint64_t targetBytes) override {
+  uint64_t shrinkCapacity(MemoryPool* /*unused*/, uint64_t /*unused*/)
+      override {
     VELOX_NYI();
   }
 
@@ -154,6 +157,9 @@ class FakeTestArbitrator : public MemoryArbitrator {
   std::string kind() const override {
     return "FAKE";
   }
+
+ private:
+  const bool injectAddPoolFailure_{false};
 };
 } // namespace
 
@@ -168,12 +174,27 @@ TEST_F(MemoryManagerTest, createWithCustomArbitrator) {
       [&] { MemoryArbitrator::unregisterFactory(kindString); });
   MemoryManagerOptions options;
   options.arbitratorKind = kindString;
-  options.capacity = 8L << 20;
-  options.queryMemoryCapacity = 256L << 20;
-  auto allocator = std::make_shared<MallocAllocator>(options.capacity);
-  options.allocator = allocator.get();
+  options.allocatorCapacity = 8L << 20;
+  options.arbitratorCapacity = 256L << 20;
+  MemoryManager manager{options};
+  ASSERT_EQ(manager.arbitrator()->capacity(), options.allocatorCapacity);
+  ASSERT_EQ(manager.allocator()->capacity(), options.allocatorCapacity);
+}
+
+TEST_F(MemoryManagerTest, addPoolFailure) {
+  const std::string kindString = "FAKE";
+  MemoryArbitrator::Factory factory =
+      [](const MemoryArbitrator::Config& config) {
+        return std::make_unique<FakeTestArbitrator>(
+            config, /*injectAddPoolFailure*/ true);
+      };
+  MemoryArbitrator::registerFactory(kindString, factory);
+  auto guard = folly::makeGuard(
+      [&] { MemoryArbitrator::unregisterFactory(kindString); });
+  MemoryManagerOptions options;
+  options.arbitratorKind = kindString;
   MemoryManager manager{options};
-  ASSERT_EQ(manager.arbitrator()->capacity(), options.capacity);
+  VELOX_ASSERT_THROW(manager.addRootPool(), "Failed to add pool");
 }
 
 TEST_F(MemoryManagerTest, addPool) {
@@ -206,14 +227,11 @@ TEST_F(MemoryManagerTest, addPool) {
 TEST_F(MemoryManagerTest, addPoolWithArbitrator) {
   MemoryManagerOptions options;
   const auto kCapacity = 32L << 30;
-  auto allocator = std::make_shared<MallocAllocator>(kCapacity);
-  options.allocator = allocator.get();
-  options.capacity = kCapacity;
+  options.allocatorCapacity = kCapacity;
   options.arbitratorKind = arbitratorKind_;
   // The arbitrator capacity will be overridden by the memory manager's
   // capacity.
-  options.capacity = options.capacity;
-  const uint64_t initialPoolCapacity = options.capacity / 32;
+  const uint64_t initialPoolCapacity = options.allocatorCapacity / 32;
   options.memoryPoolInitCapacity = initialPoolCapacity;
   MemoryManager manager{options};
 
@@ -248,13 +266,14 @@ TEST_F(MemoryManagerTest, addPoolWithArbitrator) {
   ASSERT_EQ(aggregationPool->capacity(), initialPoolCapacity);
 }
 
+// TODO: remove this test when remove deprecatedDefaultMemoryManager.
 TEST_F(MemoryManagerTest, defaultMemoryManager) {
-  auto& managerA = toMemoryManager(defaultMemoryManager());
-  auto& managerB = toMemoryManager(defaultMemoryManager());
-  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools;
-  ASSERT_EQ(managerA.numPools(), 0);
+  auto& managerA = toMemoryManager(deprecatedDefaultMemoryManager());
+  auto& managerB = toMemoryManager(deprecatedDefaultMemoryManager());
+  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 2;
+  ASSERT_EQ(managerA.numPools(), 2);
   ASSERT_EQ(managerA.testingDefaultRoot().getChildCount(), kSharedPoolCount);
-  ASSERT_EQ(managerB.numPools(), 0);
+  ASSERT_EQ(managerB.numPools(), 2);
   ASSERT_EQ(managerB.testingDefaultRoot().getChildCount(), kSharedPoolCount);
 
   auto child1 = managerA.addLeafPool("child_1");
@@ -265,53 +284,71 @@ TEST_F(MemoryManagerTest, defaultMemoryManager) {
       kSharedPoolCount + 2, managerA.testingDefaultRoot().getChildCount());
   EXPECT_EQ(
       kSharedPoolCount + 2, managerB.testingDefaultRoot().getChildCount());
-  ASSERT_EQ(managerA.numPools(), 2);
-  ASSERT_EQ(managerB.numPools(), 2);
+  ASSERT_EQ(managerA.numPools(), 4);
+  ASSERT_EQ(managerB.numPools(), 4);
   auto pool = managerB.addRootPool();
-  ASSERT_EQ(managerA.numPools(), 3);
-  ASSERT_EQ(managerB.numPools(), 3);
+  ASSERT_EQ(managerA.numPools(), 5);
+  ASSERT_EQ(managerB.numPools(), 5);
   ASSERT_EQ(
       managerA.toString(),
-      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 3\nList of root pools:\n\t__default_root__\n\tdefault_root_0\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 5\nList of root pools:\n\t__sys_root__\n\tdefault_root_0\n\trefcount 2\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
   ASSERT_EQ(
       managerB.toString(),
-      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 3\nList of root pools:\n\t__default_root__\n\tdefault_root_0\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 5\nList of root pools:\n\t__sys_root__\n\tdefault_root_0\n\trefcount 2\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
   child1.reset();
   EXPECT_EQ(
       kSharedPoolCount + 1, managerA.testingDefaultRoot().getChildCount());
   child2.reset();
   EXPECT_EQ(kSharedPoolCount, managerB.testingDefaultRoot().getChildCount());
-  ASSERT_EQ(managerA.numPools(), 1);
-  ASSERT_EQ(managerB.numPools(), 1);
+  ASSERT_EQ(managerA.numPools(), 3);
+  ASSERT_EQ(managerB.numPools(), 3);
   pool.reset();
-  ASSERT_EQ(managerA.numPools(), 0);
-  ASSERT_EQ(managerB.numPools(), 0);
+  ASSERT_EQ(managerA.numPools(), 2);
+  ASSERT_EQ(managerB.numPools(), 2);
   ASSERT_EQ(
       managerA.toString(),
-      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 0\nList of root pools:\n\t__default_root__\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 2\nList of root pools:\n\t__sys_root__\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
   ASSERT_EQ(
       managerB.toString(),
-      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 0\nList of root pools:\n\t__default_root__\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 2\nList of root pools:\n\t__sys_root__\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+  const std::string detailedManagerStr = managerA.toString(true);
+  ASSERT_THAT(
+      detailedManagerStr,
+      testing::HasSubstr(
+          "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 2\nList of root pools:\n__sys_root__ usage 0B reserved 0B peak 0B\n"));
+  ASSERT_THAT(
+      detailedManagerStr,
+      testing::HasSubstr("__sys_spilling__ usage 0B reserved 0B peak 0B\n"));
+  ASSERT_THAT(
+      detailedManagerStr,
+      testing::HasSubstr("__sys_tracing__ usage 0B reserved 0B peak 0B\n"));
+  for (int i = 0; i < 32; ++i) {
+    ASSERT_THAT(
+        managerA.toString(true),
+        testing::HasSubstr(fmt::format(
+            "__sys_shared_leaf__{} usage 0B reserved 0B peak 0B\n", i)));
+  }
 }
 
+// TODO: remove this test when remove deprecatedAddDefaultLeafMemoryPool.
 TEST(MemoryHeaderTest, addDefaultLeafMemoryPool) {
-  auto& manager = toMemoryManager(defaultMemoryManager());
-  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools;
+  auto& manager = toMemoryManager(deprecatedDefaultMemoryManager());
+  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 2;
   ASSERT_EQ(manager.testingDefaultRoot().getChildCount(), kSharedPoolCount);
   {
-    auto poolA = addDefaultLeafMemoryPool();
+    auto poolA = deprecatedAddDefaultLeafMemoryPool();
     ASSERT_EQ(poolA->kind(), MemoryPool::Kind::kLeaf);
-    auto poolB = addDefaultLeafMemoryPool();
+    auto poolB = deprecatedAddDefaultLeafMemoryPool();
     ASSERT_EQ(poolB->kind(), MemoryPool::Kind::kLeaf);
     EXPECT_EQ(
         kSharedPoolCount + 2, manager.testingDefaultRoot().getChildCount());
     {
-      auto poolC = addDefaultLeafMemoryPool();
+      auto poolC = deprecatedAddDefaultLeafMemoryPool();
       ASSERT_EQ(poolC->kind(), MemoryPool::Kind::kLeaf);
       EXPECT_EQ(
           kSharedPoolCount + 3, manager.testingDefaultRoot().getChildCount());
       {
-        auto poolD = addDefaultLeafMemoryPool();
+        auto poolD = deprecatedAddDefaultLeafMemoryPool();
         ASSERT_EQ(poolD->kind(), MemoryPool::Kind::kLeaf);
         EXPECT_EQ(
             kSharedPoolCount + 4, manager.testingDefaultRoot().getChildCount());
@@ -324,7 +361,7 @@ TEST(MemoryHeaderTest, addDefaultLeafMemoryPool) {
   }
   EXPECT_EQ(kSharedPoolCount, manager.testingDefaultRoot().getChildCount());
 
-  auto namedPool = addDefaultLeafMemoryPool("namedPool");
+  auto namedPool = deprecatedAddDefaultLeafMemoryPool("namedPool");
   ASSERT_EQ(namedPool->name(), "namedPool");
 }
 
@@ -351,7 +388,7 @@ TEST_F(MemoryManagerTest, memoryPoolManagement) {
   MemoryManagerOptions options;
   options.alignment = alignment;
   MemoryManager manager{options};
-  ASSERT_EQ(manager.numPools(), 0);
+  ASSERT_EQ(manager.numPools(), 2);
   const int numPools = 100;
   std::vector<std::shared_ptr<MemoryPool>> userRootPools;
   std::vector<std::shared_ptr<MemoryPool>> userLeafPools;
@@ -376,30 +413,38 @@ TEST_F(MemoryManagerTest, memoryPoolManagement) {
   ASSERT_FALSE(rootUnamedPool->name().empty());
   ASSERT_EQ(rootUnamedPool->kind(), MemoryPool::Kind::kAggregate);
   ASSERT_EQ(rootUnamedPool->parent(), nullptr);
-  ASSERT_EQ(manager.numPools(), numPools + 2);
+  ASSERT_EQ(manager.numPools(), 1 + numPools + 2 + 1);
   userLeafPools.clear();
   leafUnamedPool.reset();
-  ASSERT_EQ(manager.numPools(), numPools / 2 + 1);
+  ASSERT_EQ(manager.numPools(), 1 + numPools / 2 + 1 + 1);
   userRootPools.clear();
-  ASSERT_EQ(manager.numPools(), 1);
+  ASSERT_EQ(manager.numPools(), 1 + 2);
   rootUnamedPool.reset();
-  ASSERT_EQ(manager.numPools(), 0);
+  ASSERT_EQ(manager.numPools(), 2);
 }
 
 // TODO: when run sequentially, e.g. `buck run dwio/memory/...`, this has side
 // effects for other tests using process singleton memory manager. Might need to
 // use folly::Singleton for isolation by tag.
 TEST_F(MemoryManagerTest, globalMemoryManager) {
-  auto& manager = MemoryManager::getInstance();
-  auto& managerII = MemoryManager::getInstance();
-  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools;
+  initializeMemoryManager({});
+  auto* globalManager = memoryManager();
+  ASSERT_TRUE(globalManager != nullptr);
+  VELOX_ASSERT_THROW(initializeMemoryManager({}), "");
+  ASSERT_EQ(memoryManager(), globalManager);
+  MemoryManager::testingSetInstance({});
+  auto* manager = memoryManager();
+  ASSERT_NE(manager, globalManager);
+  ASSERT_EQ(manager, memoryManager());
+  auto* managerII = memoryManager();
+  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 2;
   {
-    auto& rootI = manager.testingDefaultRoot();
+    auto& rootI = manager->testingDefaultRoot();
     const std::string childIName("some_child");
     auto childI = rootI.addLeafChild(childIName);
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 1);
 
-    auto& rootII = managerII.testingDefaultRoot();
+    auto& rootII = managerII->testingDefaultRoot();
     ASSERT_EQ(kSharedPoolCount + 1, rootII.getChildCount());
     std::vector<MemoryPool*> pools{};
     rootII.visitChildren([&pools](MemoryPool* child) {
@@ -415,42 +460,20 @@ TEST_F(MemoryManagerTest, globalMemoryManager) {
     }
     ASSERT_EQ(matchedCount, 1);
 
-    auto childII = manager.addLeafPool("another_child");
+    auto childII = manager->addLeafPool("another_child");
     ASSERT_EQ(childII->kind(), MemoryPool::Kind::kLeaf);
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 2);
-    ASSERT_EQ(childII->parent()->name(), kDefaultRootName.str());
+    ASSERT_EQ(childII->parent()->name(), kSysRootName.str());
     childII.reset();
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 1);
     ASSERT_EQ(rootII.getChildCount(), kSharedPoolCount + 1);
-    auto userRootChild = manager.addRootPool("rootChild");
+    auto userRootChild = manager->addRootPool("rootChild");
     ASSERT_EQ(userRootChild->kind(), MemoryPool::Kind::kAggregate);
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 1);
     ASSERT_EQ(rootII.getChildCount(), kSharedPoolCount + 1);
-    ASSERT_EQ(manager.numPools(), 2);
+    ASSERT_EQ(manager->numPools(), 2 + 2);
   }
-  ASSERT_EQ(manager.numPools(), 0);
-  {
-    auto& manager = MemoryManager::getInstance();
-    auto& defaultManager = defaultMemoryManager();
-    ASSERT_EQ(&manager, &defaultManager);
-    auto pool = addDefaultLeafMemoryPool();
-    ASSERT_EQ(pool->kind(), MemoryPool::Kind::kLeaf);
-    ASSERT_EQ(pool->parent()->name(), kDefaultRootName.str());
-    ASSERT_EQ(manager.numPools(), 1);
-    ASSERT_EQ(
-        manager.testingDefaultRoot().getChildCount(), kSharedPoolCount + 1);
-    pool.reset();
-    ASSERT_EQ(manager.testingDefaultRoot().getChildCount(), kSharedPoolCount);
-  }
-  ASSERT_EQ(manager.numPools(), 0);
-}
-
-TEST_F(MemoryManagerTest, GlobalMemoryManagerQuota) {
-  auto& manager = MemoryManager::getInstance();
-  MemoryManager::getInstance({.alignment = 32});
-
-  auto& coercedManager = MemoryManager::getInstance({.alignment = 64});
-  ASSERT_EQ(manager.alignment(), coercedManager.alignment());
+  ASSERT_EQ(manager->numPools(), 2);
 }
 
 TEST_F(MemoryManagerTest, alignmentOptionCheck) {
@@ -548,9 +571,9 @@ TEST_F(MemoryManagerTest, concurrentPoolAccess) {
   }
   stopCheck = true;
   checkThread.join();
-  ASSERT_EQ(manager.numPools(), pools.size());
+  ASSERT_EQ(manager.numPools(), pools.size() + 2);
   pools.clear();
-  ASSERT_EQ(manager.numPools(), 0);
+  ASSERT_EQ(manager.numPools(), 2);
 }
 
 TEST_F(MemoryManagerTest, quotaEnforcement) {
@@ -576,17 +599,16 @@ TEST_F(MemoryManagerTest, quotaEnforcement) {
       {2 << 20, 0, 768, true}};
 
   for (const auto& testData : testSettings) {
-    auto allocator =
-        std::make_shared<MallocAllocator>(testData.memoryQuotaBytes);
-    MemoryAllocator::setDefaultInstance(allocator.get());
     SCOPED_TRACE(testData.debugString());
-    std::vector<bool> contiguousAllocations = {false, true};
-    for (const auto& contiguousAlloc : contiguousAllocations) {
+    const std::vector<bool> contiguousAllocations = {false, true};
+    for (const auto contiguousAlloc : contiguousAllocations) {
       SCOPED_TRACE(fmt::format("contiguousAlloc {}", contiguousAlloc));
       const int alignment = 32;
       MemoryManagerOptions options;
       options.alignment = alignment;
-      options.capacity = testData.memoryQuotaBytes;
+      options.allocatorCapacity = testData.memoryQuotaBytes;
+      options.arbitratorCapacity = testData.memoryQuotaBytes;
+      options.arbitratorReservedCapacity = 0;
       MemoryManager manager{options};
       auto pool = manager.addLeafPool("quotaEnforcement");
       void* smallBuffer{nullptr};
@@ -626,17 +648,56 @@ TEST_F(MemoryManagerTest, quotaEnforcement) {
   }
 }
 
-TEST_F(MemoryManagerTest, testCheckUsageLeak) {
-  FLAGS_velox_memory_leak_check_enabled = true;
-  auto& manager = MemoryManager::getInstance(
-      memory::MemoryManagerOptions{.checkUsageLeak = false});
+TEST_F(MemoryManagerTest, disableMemoryPoolTracking) {
+  const std::string kSharedKind{"SHARED"};
+  const std::string kNoopKind{""};
+  MemoryManagerOptions options;
+  options.disableMemoryPoolTracking = true;
+  options.allocatorCapacity = 64LL << 20;
+  options.arbitratorCapacity = 64LL << 20;
+  std::vector<std::string> arbitratorKinds{kNoopKind, kSharedKind};
+  for (auto arbitratorKind : arbitratorKinds) {
+    options.arbitratorKind = arbitratorKind;
+    MemoryManager manager{options};
+    auto root0 = manager.addRootPool("root_0", 35LL << 20);
+    auto leaf0 = root0->addLeafChild("leaf_0");
 
-  auto rootPool = manager.addRootPool("duplicateRootPool", kMaxMemory);
-  auto leafPool = manager.addLeafPool("duplicateLeafPool", true);
-  ASSERT_FALSE(rootPool->testingCheckUsageLeak());
-  ASSERT_FALSE(leafPool->testingCheckUsageLeak());
-}
+    // Not throwing since there is no duplicate check.
+    auto root0Dup = manager.addRootPool("root_0", 35LL << 20);
+
+    // 1TB capacity is allowed since there is no capacity check.
+    auto root1 = manager.addRootPool("root_1", 1LL << 40);
+    auto leaf1 = root1->addLeafChild("leaf_1");
 
-} // namespace memory
-} // namespace velox
-} // namespace facebook
+    ASSERT_EQ(root0->capacity(), 35LL << 20);
+    if (arbitratorKind == kSharedKind) {
+      ASSERT_EQ(root0Dup->capacity(), 29LL << 20);
+      ASSERT_EQ(root1->capacity(), 0);
+    } else {
+      ASSERT_EQ(root0Dup->capacity(), 35LL << 20);
+      ASSERT_EQ(root1->capacity(), 1LL << 40);
+    }
+
+    ASSERT_EQ(manager.capacity(), 64LL << 20);
+    ASSERT_EQ(manager.shrinkPools(), 0);
+    // Default 1 system pool with 1 leaf child
+    ASSERT_EQ(manager.numPools(), 2);
+
+    VELOX_ASSERT_THROW(
+        leaf0->allocate(38LL << 20), "Exceeded memory pool capacity");
+    if (arbitratorKind == kSharedKind) {
+      VELOX_ASSERT_THROW(
+          leaf1->allocate(256LL << 20), "Exceeded memory pool capacity");
+    } else {
+      VELOX_ASSERT_THROW(
+          leaf1->allocate(256LL << 20), "Exceeded memory allocator limit");
+    }
+
+    ASSERT_NO_THROW(leaf0.reset());
+    ASSERT_NO_THROW(leaf1.reset());
+    ASSERT_NO_THROW(root0.reset());
+    ASSERT_NO_THROW(root0Dup.reset());
+    ASSERT_NO_THROW(root1.reset());
+  }
+}
+} // namespace facebook::velox::memory
diff --git a/velox/common/memory/tests/MemoryPoolBenchmark.cpp b/velox/common/memory/tests/MemoryPoolBenchmark.cpp
index ae13d673841e5..82296fb7e74fa 100644
--- a/velox/common/memory/tests/MemoryPoolBenchmark.cpp
+++ b/velox/common/memory/tests/MemoryPoolBenchmark.cpp
@@ -239,7 +239,7 @@ BENCHMARK(FlatSticks, iters) {
 }
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/common/memory/tests/MemoryPoolTest.cpp b/velox/common/memory/tests/MemoryPoolTest.cpp
index 2b9c45a64bd27..fdaa7611d506e 100644
--- a/velox/common/memory/tests/MemoryPoolTest.cpp
+++ b/velox/common/memory/tests/MemoryPoolTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <fmt/format.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -22,7 +23,9 @@
 #include "velox/common/caching/SsdCache.h"
 #include "velox/common/memory/MallocAllocator.h"
 #include "velox/common/memory/Memory.h"
+#include "velox/common/memory/MemoryPool.h"
 #include "velox/common/memory/MmapAllocator.h"
+#include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/testutil/TestValue.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
@@ -37,9 +40,7 @@ constexpr int64_t KB = 1024L;
 constexpr int64_t MB = 1024L * KB;
 constexpr int64_t GB = 1024L * MB;
 
-namespace facebook {
-namespace velox {
-namespace memory {
+namespace facebook::velox::memory {
 
 struct TestParam {
   bool useMmap;
@@ -73,7 +74,7 @@ class MemoryPoolTest : public testing::TestWithParam<TestParam> {
  protected:
   static constexpr uint64_t kDefaultCapacity = 8 * GB; // 8GB
   static void SetUpTestCase() {
-    MemoryArbitrator::registerAllFactories();
+    SharedArbitrator::registerFactory();
     FLAGS_velox_memory_leak_check_enabled = true;
     TestValue::enable();
   }
@@ -94,37 +95,22 @@ class MemoryPoolTest : public testing::TestWithParam<TestParam> {
   }
 
   void setupMemory(
-      MemoryManagerOptions options = {.capacity = kDefaultCapacity}) {
-    if (useMmap_) {
-      MmapAllocator::Options opts{(uint64_t)options.capacity};
-      allocator_ = std::make_shared<MmapAllocator>(opts);
-      if (useCache_) {
-        cache_ = AsyncDataCache::create(allocator_.get());
-        MemoryAllocator::setDefaultInstance(allocator_.get());
-      } else {
-        MemoryAllocator::setDefaultInstance(allocator_.get());
-      }
-    } else {
-      allocator_ = std::make_shared<MallocAllocator>(options.capacity);
-      if (useCache_) {
-        cache_ = AsyncDataCache::create(allocator_.get());
-        MemoryAllocator::setDefaultInstance(allocator_.get());
-      } else {
-        MemoryAllocator::setDefaultInstance(allocator_.get());
-      }
-    }
-    options.allocator = allocator_.get();
-    // MemoryAllocator, depending on implementation, might round up capacity.
-    options.capacity = allocator_->capacity();
+      MemoryManagerOptions options = {
+          .debugEnabled = true,
+          .allocatorCapacity = kDefaultCapacity,
+          .arbitratorCapacity = kDefaultCapacity,
+          .arbitratorReservedCapacity = 1LL << 30}) {
+    options.useMmapAllocator = useMmap_;
     manager_ = std::make_shared<MemoryManager>(options);
+    if (useCache_) {
+      cache_ = AsyncDataCache::create(manager_->allocator());
+    }
   }
 
   void TearDown() override {
     if (useCache_) {
       cache_->shutdown();
     }
-    allocator_->testingClearFailureInjection();
-    MmapAllocator::setDefaultInstance(nullptr);
   }
 
   void reset() {
@@ -139,7 +125,7 @@ class MemoryPoolTest : public testing::TestWithParam<TestParam> {
   void abortPool(MemoryPool* pool) {
     try {
       VELOX_FAIL("Manual MemoryPool Abortion");
-    } catch (const VeloxException& error) {
+    } catch (const VeloxException&) {
       pool->abort(std::current_exception());
     }
   }
@@ -149,27 +135,31 @@ class MemoryPoolTest : public testing::TestWithParam<TestParam> {
   const bool useCache_;
   const bool isLeafThreadSafe_;
   folly::Random::DefaultGenerator rng_;
-  std::shared_ptr<MemoryAllocator> allocator_;
   std::shared_ptr<MemoryManager> manager_;
   std::shared_ptr<AsyncDataCache> cache_;
   MemoryReclaimer::Stats stats_;
 };
 
-TEST_P(MemoryPoolTest, Ctor) {
+TEST_P(MemoryPoolTest, ctor) {
   constexpr uint16_t kAlignment = 64;
-  setupMemory({.alignment = 64, .capacity = kDefaultCapacity});
+  setupMemory({.alignment = 64, .allocatorCapacity = kDefaultCapacity});
   MemoryManager& manager = *getMemoryManager();
   const int64_t capacity = 4 * GB;
   auto root = manager.addRootPool("Ctor", 4 * GB);
   ASSERT_EQ(root->kind(), MemoryPool::Kind::kAggregate);
-  ASSERT_EQ(root->currentBytes(), 0);
+  ASSERT_EQ(root->usedBytes(), 0);
+  ASSERT_EQ(root->reservedBytes(), 0);
   ASSERT_EQ(root->parent(), nullptr);
   ASSERT_EQ(root->root(), root.get());
   ASSERT_EQ(root->capacity(), capacity);
+  VELOX_ASSERT_THROW(
+      static_cast<MemoryPoolImpl*>(root.get())
+          ->setDestructionCallback([](MemoryPool*) {}),
+      "");
 
   {
     auto fakeRoot = std::make_shared<MemoryPoolImpl>(
-        &manager, "fake_root", MemoryPool::Kind::kAggregate, nullptr);
+        &manager, "fake_root", MemoryPool::Kind::kAggregate, nullptr, nullptr);
     // We can't construct an aggregate memory pool with non-thread safe.
     ASSERT_ANY_THROW(std::make_shared<MemoryPoolImpl>(
         &manager,
@@ -177,13 +167,12 @@ TEST_P(MemoryPoolTest, Ctor) {
         MemoryPool::Kind::kAggregate,
         nullptr,
         nullptr,
-        nullptr,
         MemoryPool::Options{.threadSafe = false}));
     ASSERT_EQ("fake_root", fakeRoot->name());
     ASSERT_EQ(
         static_cast<MemoryPoolImpl*>(root.get())->testingAllocator(),
         fakeRoot->testingAllocator());
-    ASSERT_EQ(0, fakeRoot->currentBytes());
+    ASSERT_EQ(0, fakeRoot->usedBytes());
     ASSERT_EQ(fakeRoot->parent(), nullptr);
   }
   {
@@ -191,18 +180,26 @@ TEST_P(MemoryPoolTest, Ctor) {
     ASSERT_EQ(child->parent(), root.get());
     ASSERT_EQ(child->root(), root.get());
     ASSERT_EQ(child->capacity(), capacity);
+    VELOX_ASSERT_THROW(
+        static_cast<MemoryPoolImpl*>(child.get())
+            ->setDestructionCallback([](MemoryPool*) {}),
+        "");
     auto& favoriteChild = dynamic_cast<MemoryPoolImpl&>(*child);
     ASSERT_EQ("child", favoriteChild.name());
     ASSERT_EQ(
         static_cast<MemoryPoolImpl*>(root.get())->testingAllocator(),
         favoriteChild.testingAllocator());
-    ASSERT_EQ(favoriteChild.currentBytes(), 0);
+    ASSERT_EQ(favoriteChild.usedBytes(), 0);
   }
   {
     auto aggregateChild = root->addAggregateChild("aggregateChild");
     ASSERT_EQ(aggregateChild->parent(), root.get());
     ASSERT_EQ(aggregateChild->root(), root.get());
     ASSERT_EQ(aggregateChild->capacity(), capacity);
+    VELOX_ASSERT_THROW(
+        static_cast<MemoryPoolImpl*>(aggregateChild.get())
+            ->setDestructionCallback([](MemoryPool*) {}),
+        "");
     auto grandChild = aggregateChild->addLeafChild("child", isLeafThreadSafe_);
     ASSERT_EQ(grandChild->parent(), aggregateChild.get());
     ASSERT_EQ(grandChild->root(), root.get());
@@ -214,7 +211,7 @@ TEST_P(MemoryPoolTest, Ctor) {
       "Memory pool rootWithZeroMaxCapacity max capacity can't be zero");
 }
 
-TEST_P(MemoryPoolTest, AddChild) {
+TEST_P(MemoryPoolTest, addChild) {
   MemoryManager& manager = *getMemoryManager();
   auto root = manager.addRootPool("root");
   ASSERT_EQ(root->parent(), nullptr);
@@ -231,13 +228,36 @@ TEST_P(MemoryPoolTest, AddChild) {
   });
   ASSERT_THAT(
       nodes, UnorderedElementsAreArray({childOne.get(), childTwo.get()}));
+
   // Child pool name collision.
   ASSERT_THROW(root->addAggregateChild("child_one"), VeloxRuntimeError);
   ASSERT_EQ(root->getChildCount(), 2);
+
+  constexpr int64_t kChunkSize{128};
+  void* buff = childOne->allocate(kChunkSize);
+  // Add child when 'reservedBytes != 0', in which case 'usedBytes()' will call
+  // 'visitChildren()'.
+  VELOX_ASSERT_THROW(root->addAggregateChild("child_one"), "");
+  childOne->free(buff, kChunkSize);
+  ASSERT_EQ(root->getChildCount(), 2);
+
   childOne.reset();
   ASSERT_EQ(root->getChildCount(), 1);
   childOne = root->addLeafChild("child_one", isLeafThreadSafe_);
   ASSERT_EQ(root->getChildCount(), 2);
+  ASSERT_EQ(root->treeMemoryUsage(), "root usage 0B reserved 0B peak 1.00MB\n");
+  ASSERT_EQ(
+      root->treeMemoryUsage(true), "root usage 0B reserved 0B peak 1.00MB\n");
+  const std::string treeUsageWithEmptyPool = root->treeMemoryUsage(false);
+  ASSERT_THAT(
+      treeUsageWithEmptyPool,
+      testing::HasSubstr("root usage 0B reserved 0B peak 1.00MB\n"));
+  ASSERT_THAT(
+      treeUsageWithEmptyPool,
+      testing::HasSubstr("child_one usage 0B reserved 0B peak 0B\n"));
+  ASSERT_THAT(
+      treeUsageWithEmptyPool,
+      testing::HasSubstr("child_two usage 0B reserved 0B peak 0B\n"));
 }
 
 TEST_P(MemoryPoolTest, dropChild) {
@@ -298,13 +318,12 @@ MachinePageCount numPagesNeeded(
 }
 
 void testMmapMemoryAllocation(
-    MmapAllocator* mmapAllocator,
+    int64_t capacity,
     MachinePageCount allocPages,
     size_t allocCount,
     bool threadSafe) {
   MemoryManager manager{
-      {.capacity = (int64_t)(mmapAllocator->capacity()),
-       .allocator = mmapAllocator}};
+      {.allocatorCapacity = capacity, .useMmapAllocator = true}};
   const auto kPageSize = 4 * KB;
 
   auto root = manager.addRootPool();
@@ -313,6 +332,7 @@ void testMmapMemoryAllocation(
   std::vector<void*> allocations;
   uint64_t totalPageAllocated = 0;
   uint64_t totalPageMapped = 0;
+  auto* mmapAllocator = static_cast<MmapAllocator*>(manager.allocator());
   const auto pageIncrement = numPagesNeeded(mmapAllocator, allocPages);
   const auto isSizeClassAlloc =
       allocPages <= mmapAllocator->sizeClasses().back();
@@ -347,51 +367,68 @@ void testMmapMemoryAllocation(
   }
 }
 
-TEST_P(MemoryPoolTest, SmallMmapMemoryAllocation) {
-  MmapAllocator::Options options;
-  options.capacity = 8 * GB;
-  auto mmapAllocator = std::make_shared<memory::MmapAllocator>(options);
-  testMmapMemoryAllocation(mmapAllocator.get(), 6, 100, isLeafThreadSafe_);
+TEST_P(MemoryPoolTest, smallMmapMemoryAllocation) {
+  testMmapMemoryAllocation(8 * GB, 6, 100, isLeafThreadSafe_);
 }
 
-TEST_P(MemoryPoolTest, BigMmapMemoryAllocation) {
-  MmapAllocator::Options options;
-  options.capacity = 8 * GB;
-  auto mmapAllocator = std::make_shared<memory::MmapAllocator>(options);
-  testMmapMemoryAllocation(
-      mmapAllocator.get(),
-      mmapAllocator->sizeClasses().back() + 56,
-      20,
-      isLeafThreadSafe_);
+TEST_P(MemoryPoolTest, bigMmapMemoryAllocation) {
+  testMmapMemoryAllocation(8 * GB, 256 + 56, 20, isLeafThreadSafe_);
 }
 
-// Mainly tests how it updates the memory usage in Memorypool->
-TEST_P(MemoryPoolTest, AllocTest) {
+// Mainly tests how it updates the memory usage in memory pool.
+TEST_P(MemoryPoolTest, allocTest) {
   auto manager = getMemoryManager();
   auto root = manager->addRootPool();
 
-  auto child = root->addLeafChild("elastic_quota", isLeafThreadSafe_);
+  auto child = root->addLeafChild("allocTest", isLeafThreadSafe_);
 
   const int64_t kChunkSize{32L * MB};
 
   void* oneChunk = child->allocate(kChunkSize);
   ASSERT_EQ(reinterpret_cast<uint64_t>(oneChunk) % child->alignment(), 0);
-  ASSERT_EQ(kChunkSize, child->currentBytes());
+  ASSERT_EQ(kChunkSize, child->usedBytes());
   ASSERT_EQ(kChunkSize, child->stats().peakBytes);
 
   void* threeChunks = child->allocate(3 * kChunkSize);
-  ASSERT_EQ(4 * kChunkSize, child->currentBytes());
+  ASSERT_EQ(4 * kChunkSize, child->usedBytes());
   ASSERT_EQ(4 * kChunkSize, child->stats().peakBytes);
 
   child->free(threeChunks, 3 * kChunkSize);
-  ASSERT_EQ(kChunkSize, child->currentBytes());
+  ASSERT_EQ(kChunkSize, child->usedBytes());
   ASSERT_EQ(4 * kChunkSize, child->stats().peakBytes);
 
   child->free(oneChunk, kChunkSize);
-  ASSERT_EQ(0, child->currentBytes());
+  ASSERT_EQ(0, child->usedBytes());
   ASSERT_EQ(4 * kChunkSize, child->stats().peakBytes);
 }
 
+TEST_P(MemoryPoolTest, usedBytes) {
+  auto manager = getMemoryManager();
+  auto root = manager->addRootPool();
+
+  auto child1 = root->addLeafChild("usedBytes1", isLeafThreadSafe_);
+  auto child2 = root->addLeafChild("usedBytes2", isLeafThreadSafe_);
+
+  const int64_t kChunkSize{128};
+
+  void* buf1 = child1->allocate(kChunkSize);
+  void* buf2 = child2->allocate(kChunkSize);
+  ASSERT_EQ(child1->reservedBytes(), 1 << 20);
+  ASSERT_EQ(child1->usedBytes(), kChunkSize);
+  ASSERT_EQ(child2->reservedBytes(), 1 << 20);
+  ASSERT_EQ(child2->usedBytes(), kChunkSize);
+
+  ASSERT_EQ(root->reservedBytes(), 2 << 20);
+  ASSERT_EQ(root->usedBytes(), 2 * kChunkSize);
+
+  child1->free(buf1, kChunkSize);
+  ASSERT_EQ(root->reservedBytes(), 1 << 20);
+  ASSERT_EQ(root->usedBytes(), kChunkSize);
+  child2->free(buf2, kChunkSize);
+  ASSERT_EQ(root->reservedBytes(), 0);
+  ASSERT_EQ(root->usedBytes(), 0);
+}
+
 TEST_P(MemoryPoolTest, DISABLED_memoryLeakCheck) {
   gflags::FlagSaver flagSaver;
   testing::FLAGS_gtest_death_test_style = "fast";
@@ -401,29 +438,145 @@ TEST_P(MemoryPoolTest, DISABLED_memoryLeakCheck) {
   auto child = root->addLeafChild("elastic_quota", isLeafThreadSafe_);
   const int64_t kChunkSize{32L * MB};
   void* oneChunk = child->allocate(kChunkSize);
-  FLAGS_velox_memory_leak_check_enabled = true;
   ASSERT_DEATH(child.reset(), "");
   child->free(oneChunk, kChunkSize);
 }
 
-TEST_P(MemoryPoolTest, DISABLED_growBeyondMaxCapacity) {
-  gflags::FlagSaver flagSaver;
-  testing::FLAGS_gtest_death_test_style = "fast";
+TEST_P(MemoryPoolTest, growFailures) {
   auto manager = getMemoryManager();
+  // Grow beyond limit.
   {
     auto poolWithoutLimit = manager->addRootPool("poolWithoutLimit");
     ASSERT_EQ(poolWithoutLimit->capacity(), kMaxMemory);
-    ASSERT_DEATH(
-        poolWithoutLimit->grow(1), "Can't grow with unlimited capacity");
+    ASSERT_EQ(poolWithoutLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithoutLimit->reservedBytes(), 0);
+    VELOX_ASSERT_THROW(
+        poolWithoutLimit->grow(1, 0), "Can't grow with unlimited capacity");
+    ASSERT_EQ(poolWithoutLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithoutLimit->reservedBytes(), 0);
+    VELOX_ASSERT_THROW(
+        poolWithoutLimit->grow(1, 1'000), "Can't grow with unlimited capacity");
+    ASSERT_EQ(poolWithoutLimit->usedBytes(), 0);
   }
   {
     const int64_t capacity = 4 * GB;
     auto poolWithLimit = manager->addRootPool("poolWithLimit", capacity);
     ASSERT_EQ(poolWithLimit->capacity(), capacity);
-    ASSERT_EQ(poolWithLimit->shrink(poolWithLimit->currentBytes()), capacity);
-    ASSERT_EQ(poolWithLimit->grow(capacity / 2), capacity / 2);
-    ASSERT_DEATH(
-        poolWithLimit->grow(capacity), "Can't grow beyond the max capacity");
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->shrink(poolWithLimit->reservedBytes()), capacity);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_TRUE(poolWithLimit->grow(capacity / 2, 0));
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+    ASSERT_FALSE(poolWithLimit->grow(capacity, 0));
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->capacity(), capacity / 2);
+    ASSERT_FALSE(poolWithLimit->grow(capacity, 1'000));
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+  }
+
+  // Insufficient capacity for new reservation.
+  {
+    const int64_t capacity = 4 * GB;
+    auto poolWithLimit = manager->addRootPool("poolWithLimit", capacity);
+    ASSERT_EQ(poolWithLimit->capacity(), capacity);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->shrink(poolWithLimit->capacity()), capacity);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->capacity(), 0);
+
+    ASSERT_FALSE(poolWithLimit->grow(capacity / 2, capacity));
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->capacity(), 0);
+
+    ASSERT_FALSE(poolWithLimit->grow(0, capacity));
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->capacity(), 0);
+    ASSERT_EQ(poolWithLimit->reservedBytes(), 0);
+    ASSERT_EQ(poolWithLimit->usedBytes(), 0);
+  }
+}
+
+TEST_P(MemoryPoolTest, grow) {
+  auto manager = getMemoryManager();
+  const int64_t capacity = 4 * GB;
+  auto root = manager->addRootPool("grow", capacity);
+  root->shrink(capacity / 2);
+  ASSERT_EQ(root->capacity(), capacity / 2);
+
+  auto leaf = root->addLeafChild("leafPool");
+  void* buf = leaf->allocate(1 * MB);
+  ASSERT_EQ(root->capacity(), capacity / 2);
+  ASSERT_EQ(root->reservedBytes(), 1 * MB);
+
+  ASSERT_TRUE(root->grow(0, 2 * MB));
+  ASSERT_EQ(root->reservedBytes(), 3 * MB);
+  ASSERT_EQ(root->capacity(), capacity / 2);
+
+  ASSERT_TRUE(root->grow(0, 4 * MB));
+  ASSERT_EQ(root->reservedBytes(), 7 * MB);
+  ASSERT_EQ(root->capacity(), capacity / 2);
+
+  ASSERT_TRUE(root->grow(1 * MB, 2 * MB));
+  ASSERT_EQ(root->reservedBytes(), 9 * MB);
+  ASSERT_EQ(root->capacity(), capacity / 2 + 1 * MB);
+
+  ASSERT_TRUE(root->grow(6 * MB, 4 * MB));
+  ASSERT_EQ(root->reservedBytes(), 13 * MB);
+  ASSERT_EQ(root->capacity(), capacity / 2 + 7 * MB);
+
+  static_cast<MemoryPoolImpl*>(root.get())->testingSetReservation(1 * MB);
+  leaf->free(buf, 1 * MB);
+}
+
+TEST_P(MemoryPoolTest, releasableMemory) {
+  struct TestParam {
+    int64_t usedBytes;
+    int64_t reservedBytes;
+  };
+  std::vector<TestParam> testParams{
+      {2345, 98760},
+      {1, 1024},
+      {4096, 4096},
+      {1 * MB, 16 * MB},
+      {6 * MB, 7 * MB},
+      {123 * MB, 200 * MB},
+      {100 * MB, 50 * MB}};
+  auto root = getMemoryManager()->addRootPool("releasableMemory", 4 * GB);
+  for (auto i = 0; i < testParams.size() - 1; i++) {
+    auto leaf0 = root->addLeafChild("leafPool-0");
+    leaf0->maybeReserve(testParams[i].reservedBytes);
+    void* buffer0 = leaf0->allocate(testParams[i].usedBytes);
+    const auto reservedBytes0 = leaf0->reservedBytes();
+    const auto releasableBytes0 = leaf0->releasableReservation();
+
+    auto leaf1 = root->addLeafChild("leafPool-1");
+    leaf1->maybeReserve(testParams[i + 1].reservedBytes);
+    void* buffer1 = leaf1->allocate(testParams[i + 1].usedBytes);
+    const auto reservedBytes1 = leaf1->reservedBytes();
+    const auto releasableBytes1 = leaf1->releasableReservation();
+
+    const auto releasableBytesRoot = root->releasableReservation();
+    const auto reservedBytesRoot = root->reservedBytes();
+    ASSERT_EQ(releasableBytesRoot, releasableBytes0 + releasableBytes1);
+
+    leaf0->release();
+    ASSERT_EQ(reservedBytes0 - leaf0->reservedBytes(), releasableBytes0);
+    ASSERT_EQ(reservedBytesRoot - root->reservedBytes(), releasableBytes0);
+    leaf1->release();
+    ASSERT_EQ(reservedBytes1 - leaf1->reservedBytes(), releasableBytes1);
+    ASSERT_EQ(reservedBytesRoot - root->reservedBytes(), releasableBytesRoot);
+
+    leaf0->free(buffer0, testParams[i].usedBytes);
+    leaf1->free(buffer1, testParams[i + 1].usedBytes);
   }
 }
 
@@ -436,17 +589,16 @@ TEST_P(MemoryPoolTest, ReallocTestSameSize) {
   const int64_t kChunkSize{32L * MB};
 
   // Realloc the same size.
-
   void* oneChunk = pool->allocate(kChunkSize);
-  ASSERT_EQ(kChunkSize, pool->currentBytes());
+  ASSERT_EQ(kChunkSize, pool->usedBytes());
   ASSERT_EQ(kChunkSize, pool->stats().peakBytes);
 
   void* anotherChunk = pool->reallocate(oneChunk, kChunkSize, kChunkSize);
-  ASSERT_EQ(kChunkSize, pool->currentBytes());
+  ASSERT_EQ(kChunkSize, pool->usedBytes());
   ASSERT_EQ(2 * kChunkSize, pool->stats().peakBytes);
 
   pool->free(anotherChunk, kChunkSize);
-  ASSERT_EQ(0, pool->currentBytes());
+  ASSERT_EQ(0, pool->usedBytes());
   ASSERT_EQ(2 * kChunkSize, pool->stats().peakBytes);
 }
 
@@ -459,15 +611,15 @@ TEST_P(MemoryPoolTest, ReallocTestHigher) {
   const int64_t kChunkSize{32L * MB};
   // Realloc higher.
   void* oneChunk = pool->allocate(kChunkSize);
-  EXPECT_EQ(kChunkSize, pool->currentBytes());
+  EXPECT_EQ(kChunkSize, pool->usedBytes());
   EXPECT_EQ(kChunkSize, pool->stats().peakBytes);
 
   void* threeChunks = pool->reallocate(oneChunk, kChunkSize, 3 * kChunkSize);
-  EXPECT_EQ(3 * kChunkSize, pool->currentBytes());
+  EXPECT_EQ(3 * kChunkSize, pool->usedBytes());
   EXPECT_EQ(4 * kChunkSize, pool->stats().peakBytes);
 
   pool->free(threeChunks, 3 * kChunkSize);
-  EXPECT_EQ(0, pool->currentBytes());
+  EXPECT_EQ(0, pool->usedBytes());
   EXPECT_EQ(4 * kChunkSize, pool->stats().peakBytes);
 }
 
@@ -479,15 +631,15 @@ TEST_P(MemoryPoolTest, ReallocTestLower) {
   const int64_t kChunkSize{32L * MB};
   // Realloc lower.
   void* threeChunks = pool->allocate(3 * kChunkSize);
-  EXPECT_EQ(3 * kChunkSize, pool->currentBytes());
+  EXPECT_EQ(3 * kChunkSize, pool->usedBytes());
   EXPECT_EQ(3 * kChunkSize, pool->stats().peakBytes);
 
   void* oneChunk = pool->reallocate(threeChunks, 3 * kChunkSize, kChunkSize);
-  EXPECT_EQ(kChunkSize, pool->currentBytes());
+  EXPECT_EQ(kChunkSize, pool->usedBytes());
   EXPECT_EQ(4 * kChunkSize, pool->stats().peakBytes);
 
   pool->free(oneChunk, kChunkSize);
-  EXPECT_EQ(0, pool->currentBytes());
+  EXPECT_EQ(0, pool->usedBytes());
   EXPECT_EQ(4 * kChunkSize, pool->stats().peakBytes);
 }
 
@@ -517,7 +669,7 @@ TEST_P(MemoryPoolTest, allocateZeroFilled) {
   for (int32_t i = 0; i < allocationPtrs.size(); ++i) {
     pool->free(allocationPtrs[i], allocationSizes[i]);
   }
-  ASSERT_EQ(0, pool->currentBytes());
+  ASSERT_EQ(0, pool->usedBytes());
 }
 
 TEST_P(MemoryPoolTest, alignmentCheck) {
@@ -528,7 +680,8 @@ TEST_P(MemoryPoolTest, alignmentCheck) {
       MemoryAllocator::kMaxAlignment};
   for (const auto& alignment : alignments) {
     SCOPED_TRACE(fmt::format("alignment:{}", alignment));
-    setupMemory({.alignment = alignment, .capacity = kDefaultCapacity});
+    setupMemory(
+        {.alignment = alignment, .allocatorCapacity = kDefaultCapacity});
     auto manager = getMemoryManager();
     auto pool = manager->addLeafPool("alignmentCheck");
     ASSERT_EQ(
@@ -543,20 +696,23 @@ TEST_P(MemoryPoolTest, alignmentCheck) {
       }
       pool->free(ptr, bytesToAlloc);
     }
-    ASSERT_EQ(0, pool->currentBytes());
+    ASSERT_EQ(0, pool->usedBytes());
   }
 }
 
-TEST_P(MemoryPoolTest, MemoryCapExceptions) {
+TEST_P(MemoryPoolTest, memoryCapExceptions) {
   const uint64_t kMaxCap = 128L * MB;
-  setupMemory({.capacity = kMaxCap});
+  setupMemory(
+      {.allocatorCapacity = kMaxCap,
+       .arbitratorCapacity = kMaxCap,
+       .arbitratorReservedCapacity = kMaxCap / 2});
   auto manager = getMemoryManager();
   // Capping memory pool.
   {
     auto root = manager->addRootPool("MemoryCapExceptions", kMaxCap);
     auto pool = root->addLeafChild("static_quota", isLeafThreadSafe_);
     {
-      ASSERT_EQ(0, pool->currentBytes());
+      ASSERT_EQ(0, pool->usedBytes());
       try {
         pool->allocate(129L * MB);
       } catch (const velox::VeloxRuntimeError& ex) {
@@ -564,10 +720,11 @@ TEST_P(MemoryPoolTest, MemoryCapExceptions) {
         ASSERT_EQ(error_code::kMemCapExceeded.c_str(), ex.errorCode());
         ASSERT_TRUE(ex.isRetriable());
         ASSERT_EQ(
-            "Exceeded memory pool cap of 128.00MB with max 128.00MB when "
-            "requesting 136.00MB, memory manager cap is 128.00MB, requestor "
-            "'static_quota' with current usage 0B\nMemoryCapExceptions usage "
-            "0B peak 0B\n",
+            "Exceeded memory pool capacity after attempt to grow capacity "
+            "through arbitration. Requestor pool name 'static_quota', request "
+            "size 136.00MB, memory pool capacity 128.00MB, memory pool max "
+            "capacity 128.00MB, memory manager capacity 128.00MB, current "
+            "usage 0B\nMemoryCapExceptions usage 0B reserved 0B peak 0B\n",
             ex.message());
       }
     }
@@ -576,38 +733,83 @@ TEST_P(MemoryPoolTest, MemoryCapExceptions) {
   // Capping allocator.
   {
     auto root =
-        manager->addRootPool("MemoryCapExceptions", 2 * allocator_->capacity());
+        manager->addRootPool("MemoryCapExceptions", 2 * manager->capacity());
     auto pool = root->addLeafChild("static_quota", isLeafThreadSafe_);
     {
-      ASSERT_EQ(0, pool->currentBytes());
+      ASSERT_EQ(0, pool->usedBytes());
       try {
-        pool->allocate(allocator_->capacity() + 1);
+        pool->allocate(manager->capacity() + 1);
       } catch (const velox::VeloxRuntimeError& ex) {
         ASSERT_EQ(error_source::kErrorSourceRuntime.c_str(), ex.errorSource());
         ASSERT_EQ(error_code::kMemAllocError.c_str(), ex.errorCode());
         ASSERT_TRUE(ex.isRetriable());
         if (useMmap_) {
-          ASSERT_EQ(
-              fmt::format(
-                  "allocate failed with 128.00MB from Memory Pool["
-                  "static_quota LEAF root[MemoryCapExceptions] "
-                  "parent[MemoryCapExceptions] MMAP track-usage {}]<max "
-                  "capacity 256.00MB capacity 256.00MB used 0B available 0B "
-                  "reservation [used 0B, reserved 0B, min 0B] counters [allocs "
-                  "1, frees 0, reserves 0, releases 0, collisions 0])>",
-                  isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"),
-              ex.message());
+          if (useCache_) {
+            ASSERT_EQ(
+                fmt::format(
+                    "allocate failed with 128.00MB from Memory Pool["
+                    "static_quota LEAF root[MemoryCapExceptions] "
+                    "parent[MemoryCapExceptions] MMAP track-usage {}]<max "
+                    "capacity 256.00MB capacity 256.00MB used 0B available 0B "
+                    "reservation [used 0B, reserved 0B, min 0B] counters [allocs "
+                    "1, frees 0, reserves 0, releases 0, collisions 0])> Failed to"
+                    " evict from cache state: AsyncDataCache:\nCache size: 0B "
+                    "tinySize: 0B large size: 0B\nCache entries: 0 read pins: "
+                    "0 write pins: 0 pinned shared: 0B pinned exclusive: 0B\n "
+                    "num write wait: 0 empty entries: 0\nCache access miss: 0 "
+                    "hit: 0 hit bytes: 0B eviction: 0 savable eviction: 0 eviction checks: 0 "
+                    "aged out: 0 stales: 0\nPrefetch entries: 0 bytes: 0B\nAlloc Megaclocks 0\n"
+                    "Allocated pages: 0 cached pages: 0\n",
+                    isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"),
+                ex.message());
+          } else {
+            ASSERT_EQ(
+                fmt::format(
+                    "allocate failed with 128.00MB from Memory Pool["
+                    "static_quota LEAF root[MemoryCapExceptions] "
+                    "parent[MemoryCapExceptions] MMAP track-usage {}]<max "
+                    "capacity 256.00MB capacity 256.00MB used 0B available 0B "
+                    "reservation [used 0B, reserved 0B, min 0B] counters [allocs "
+                    "1, frees 0, reserves 0, releases 0, collisions 0])> "
+                    "Exceeded memory allocator limit when allocating 32769 "
+                    "new pages for total allocation of 32769 pages, the memory"
+                    " allocator capacity is 32768 pages",
+                    isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"),
+                ex.message());
+          }
         } else {
-          ASSERT_EQ(
-              fmt::format(
-                  "allocate failed with 128.00MB from Memory Pool"
-                  "[static_quota LEAF root[MemoryCapExceptions] "
-                  "parent[MemoryCapExceptions] MALLOC track-usage {}]"
-                  "<max capacity 256.00MB capacity 256.00MB used 0B available "
-                  "0B reservation [used 0B, reserved 0B, min 0B] counters "
-                  "[allocs 1, frees 0, reserves 0, releases 0, collisions 0])>",
-                  isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"),
-              ex.message());
+          if (useCache_) {
+            ASSERT_EQ(
+                fmt::format(
+                    "allocate failed with 128.00MB from Memory Pool"
+                    "[static_quota LEAF root[MemoryCapExceptions] "
+                    "parent[MemoryCapExceptions] MALLOC track-usage {}]"
+                    "<max capacity 256.00MB capacity 256.00MB used 0B available "
+                    "0B reservation [used 0B, reserved 0B, min 0B] counters "
+                    "[allocs 1, frees 0, reserves 0, releases 0, collisions 0])>"
+                    " Failed to evict from cache state: AsyncDataCache:\nCache "
+                    "size: 0B tinySize: 0B large size: 0B\nCache entries: 0 "
+                    "read pins: 0 write pins: 0 pinned shared: 0B pinned "
+                    "exclusive: 0B\n num write wait: 0 empty entries: 0\nCache "
+                    "access miss: 0 hit: 0 hit bytes: 0B eviction: 0 savable eviction: 0 eviction "
+                    "checks: 0 aged out: 0 stales: 0\nPrefetch entries: 0 bytes: 0B\nAlloc Megaclocks"
+                    " 0\nAllocated pages: 0 cached pages: 0\n",
+                    isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"),
+                ex.message());
+          } else {
+            ASSERT_EQ(
+                fmt::format(
+                    "allocate failed with 128.00MB from Memory Pool"
+                    "[static_quota LEAF root[MemoryCapExceptions] "
+                    "parent[MemoryCapExceptions] MALLOC track-usage {}]"
+                    "<max capacity 256.00MB capacity 256.00MB used 0B available "
+                    "0B reservation [used 0B, reserved 0B, min 0B] counters "
+                    "[allocs 1, frees 0, reserves 0, releases 0, collisions 0])>"
+                    " Failed to allocateBytes 128.00MB: Exceeded memory "
+                    "allocator limit of 128.00MB",
+                    isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"),
+                ex.message());
+          }
         }
       }
     }
@@ -616,42 +818,44 @@ TEST_P(MemoryPoolTest, MemoryCapExceptions) {
 
 TEST(MemoryPoolTest, GetAlignment) {
   {
-    auto allocator = std::make_shared<MallocAllocator>(
-        MemoryAllocator::kDefaultCapacityBytes);
+    MemoryManagerOptions options;
+    options.allocatorCapacity = kMaxMemory;
     EXPECT_EQ(
         MemoryAllocator::kMaxAlignment,
-        MemoryManager{{.allocator = allocator.get()}}
-            .addRootPool()
-            ->alignment());
+        MemoryManager{options}.addRootPool()->alignment());
   }
   {
-    auto allocator = std::make_shared<MallocAllocator>(
-        MemoryAllocator::kDefaultCapacityBytes);
-    MemoryManager manager{{.alignment = 64, .allocator = allocator.get()}};
+    MemoryManagerOptions options;
+    options.allocatorCapacity = kMaxMemory;
+    options.alignment = 64;
+    MemoryManager manager{options};
     EXPECT_EQ(64, manager.addRootPool()->alignment());
   }
 }
 
 TEST_P(MemoryPoolTest, MemoryManagerGlobalCap) {
-  setupMemory({.capacity = 32L * MB});
+  setupMemory(
+      {.allocatorCapacity = 32L * MB,
+       .arbitratorCapacity = 32L * MB,
+       .arbitratorReservedCapacity = 16L * MB});
   auto manager = getMemoryManager();
-  const auto kAllocCap = allocator_->capacity();
+  const auto kAllocCap = manager->capacity();
   auto root = manager->addRootPool();
   auto pool = root->addAggregateChild("unbounded");
   auto child = pool->addLeafChild("unbounded", isLeafThreadSafe_);
   void* oneChunk = child->allocate(kAllocCap);
-  ASSERT_EQ(root->currentBytes(), kAllocCap);
+  ASSERT_EQ(root->reservedBytes(), kAllocCap);
   EXPECT_THROW(child->allocate(kAllocCap), velox::VeloxRuntimeError);
-  ASSERT_EQ(root->currentBytes(), kAllocCap);
+  ASSERT_EQ(root->reservedBytes(), kAllocCap);
   EXPECT_THROW(
       child->reallocate(oneChunk, kAllocCap, 2 * kAllocCap),
       velox::VeloxRuntimeError);
-  ASSERT_EQ(root->currentBytes(), kAllocCap);
+  ASSERT_EQ(root->reservedBytes(), kAllocCap);
   child->free(oneChunk, kAllocCap);
 }
 
 // Tests how child updates itself and its parent's memory usage
-// and what it returns for currentBytes()/getMaxBytes and
+// and what it returns for reservedBytes()/getMaxBytes and
 // with memoryUsageTracker.
 TEST_P(MemoryPoolTest, childUsageTest) {
   MemoryManager& manager = *getMemoryManager();
@@ -659,12 +863,12 @@ TEST_P(MemoryPoolTest, childUsageTest) {
   auto pool = root->addAggregateChild("main_pool");
 
   auto verifyUsage = [](std::vector<std::shared_ptr<MemoryPool>>& tree,
-                        std::vector<int> currentBytes,
+                        std::vector<int> usedBytes,
                         std::vector<int> maxBytes) {
     ASSERT_TRUE(
-        tree.size() == currentBytes.size() && tree.size() == maxBytes.size());
+        tree.size() == usedBytes.size() && tree.size() == maxBytes.size());
     for (unsigned i = 0, e = tree.size(); i != e; ++i) {
-      EXPECT_EQ(tree[i]->currentBytes(), currentBytes[i]) << i;
+      EXPECT_EQ(tree[i]->usedBytes(), usedBytes[i]) << i;
       EXPECT_EQ(tree[i]->stats().peakBytes, maxBytes[i]) << i;
     }
   };
@@ -696,19 +900,17 @@ TEST_P(MemoryPoolTest, childUsageTest) {
 
   void* p3Chunk0 = tree[3]->allocate(16);
   verifyUsage(
-      tree,
-      {1048576, 1048576, 0, 64, 0, 0, 0},
-      {1048576, 1048576, 0, 64, 0, 0, 0});
+      tree, {64, 64, 0, 64, 0, 0, 0}, {1048576, 1048576, 0, 64, 0, 0, 0});
   void* p5Chunk0 = tree[5]->allocate(64);
   verifyUsage(
       tree,
-      {2097152, 1048576, 1048576, 64, 0, 64, 0},
+      {128, 64, 64, 64, 0, 64, 0},
       {2097152, 1048576, 1048576, 64, 0, 64, 0});
 
   tree[3]->free(p3Chunk0, 16);
   verifyUsage(
       tree,
-      {1048576, 0, 1048576, 0, 0, 64, 0},
+      {64, 0, 64, 0, 0, 64, 0},
       {2097152, 1048576, 1048576, 64, 0, 64, 0});
 
   tree[5]->free(p5Chunk0, 64);
@@ -718,12 +920,12 @@ TEST_P(MemoryPoolTest, childUsageTest) {
   // Release all memory pool->
   tree.clear();
 
-  std::vector<int64_t> expectedCurrentBytes({0, 0, 0, 0, 0, 0, 0});
+  std::vector<int64_t> expectedReservedBytes({0, 0, 0, 0, 0, 0, 0});
   std::vector<int64_t> expectedMaxBytes({128, 64, 64, 64, 0, 64, 0});
 
   // Verify the stats still holds the correct stats.
   for (unsigned i = 0, e = tree.size(); i != e; ++i) {
-    ASSERT_GE(tree[i]->currentBytes(), expectedCurrentBytes[i]);
+    ASSERT_GE(tree[i]->reservedBytes(), expectedReservedBytes[i]);
     ASSERT_GE(tree[i]->stats().peakBytes, expectedMaxBytes[i]);
   }
 }
@@ -764,8 +966,7 @@ TEST_P(MemoryPoolTest, allocatorOverflow) {
 TEST_P(MemoryPoolTest, contiguousAllocate) {
   auto manager = getMemoryManager();
   auto pool = manager->addLeafPool("contiguousAllocate");
-  const auto largestSizeClass =
-      MemoryAllocator::getInstance()->largestSizeClass();
+  const auto largestSizeClass = manager->allocator()->largestSizeClass();
   struct {
     MachinePageCount numAllocPages;
     std::string debugString() const {
@@ -823,7 +1024,7 @@ TEST_P(MemoryPoolTest, contiguousAllocate) {
     const MachinePageCount minSizeClass = folly::Random().oneIn(4)
         ? 0
         : std::min(
-              MemoryAllocator::getInstance()->largestSizeClass(),
+              manager->allocator()->largestSizeClass(),
               folly::Random().rand32() % kMaxAllocationPages);
     pool->allocateContiguous(pagesToAllocate, allocation);
     numAllocatedPages += allocation.numPages();
@@ -846,9 +1047,13 @@ TEST_P(MemoryPoolTest, contiguousAllocate) {
 }
 
 TEST_P(MemoryPoolTest, contiguousAllocateExceedLimit) {
-  setupMemory({.capacity = (int64_t)(AllocationTraits::pageBytes(1 << 10))});
+  const auto memCapacity = (int64_t)(AllocationTraits::pageBytes(1 << 10));
+  setupMemory(
+      {.allocatorCapacity = memCapacity,
+       .arbitratorCapacity = memCapacity,
+       .arbitratorReservedCapacity = memCapacity / 2});
   auto manager = getMemoryManager();
-  const auto kMemoryCapBytes = allocator_->capacity();
+  const auto kMemoryCapBytes = manager->capacity();
   const auto kMaxNumPages = AllocationTraits::numPages(kMemoryCapBytes);
   auto root =
       manager->addRootPool("contiguousAllocateExceedLimit", kMemoryCapBytes);
@@ -876,7 +1081,7 @@ TEST_P(MemoryPoolTest, badContiguousAllocation) {
 TEST_P(MemoryPoolTest, nonContiguousAllocate) {
   auto manager = getMemoryManager();
   auto pool = manager->addLeafPool("nonContiguousAllocate");
-  const auto& sizeClasses = MemoryAllocator::getInstance()->sizeClasses();
+  const auto& sizeClasses = manager->allocator()->sizeClasses();
   for (const auto& sizeClass : sizeClasses) {
     SCOPED_TRACE(fmt::format("sizeClass:{}", sizeClass));
     struct {
@@ -917,8 +1122,7 @@ TEST_P(MemoryPoolTest, nonContiguousAllocate) {
           testData.numAllocPages,
           allocation,
           std::min(
-              testData.minSizeClass,
-              MemoryAllocator::getInstance()->largestSizeClass()));
+              testData.minSizeClass, manager->allocator()->largestSizeClass()));
       ASSERT_FALSE(allocation.empty());
       ASSERT_EQ(allocation.pool(), pool.get());
       ASSERT_GT(allocation.numRuns(), 0);
@@ -946,7 +1150,7 @@ TEST_P(MemoryPoolTest, nonContiguousAllocate) {
     const MachinePageCount minSizeClass = folly::Random().oneIn(4)
         ? 0
         : std::min(
-              MemoryAllocator::getInstance()->largestSizeClass(),
+              manager->allocator()->largestSizeClass(),
               folly::Random().rand32() % kMaxAllocationPages);
     pool->allocateNonContiguous(pagesToAllocate, allocation, minSizeClass);
     numAllocatedPages += allocation.numPages();
@@ -960,10 +1164,15 @@ TEST_P(MemoryPoolTest, nonContiguousAllocate) {
 }
 
 TEST_P(MemoryPoolTest, allocationFailStats) {
-  setupMemory({.capacity = 16 * KB});
+  setupMemory(
+      {.allocatorCapacity = 16 * KB,
+       .allocationSizeThresholdWithReservation = false,
+       .arbitratorCapacity = 16 * KB,
+       .arbitratorReservedCapacity = 16 * KB,
+       .memoryPoolReservedCapacity = 16 * KB});
   auto manager = getMemoryManager();
   auto pool = manager->addLeafPool("allocationFailStats");
-  auto allocatorCapacity = allocator_->capacity();
+  auto allocatorCapacity = manager->capacity();
 
   EXPECT_THROW(pool->allocate(allocatorCapacity + 1), VeloxException);
   EXPECT_EQ(1, pool->stats().numAllocs);
@@ -1091,8 +1300,8 @@ TEST_P(MemoryPoolTest, persistentNonContiguousAllocateFailure) {
     std::string debugString() const {
       return fmt::format(
           "numOldPages:{}, numNewPages:{}, injectedFailure:{}",
-          numOldPages,
-          numNewPages,
+          static_cast<uint64_t>(numOldPages),
+          static_cast<uint64_t>(numNewPages),
           injectedFailure);
     }
   } testSettings[] = {// Cap failure injection.
@@ -1177,11 +1386,12 @@ TEST_P(MemoryPoolTest, persistentNonContiguousAllocateFailure) {
       pool->allocateNonContiguous(testData.numOldPages, allocation);
     }
     ASSERT_GE(allocation.numPages(), testData.numOldPages);
-    allocator_->testingSetFailureInjection(testData.injectedFailure, true);
+    manager->allocator()->testingSetFailureInjection(
+        testData.injectedFailure, true);
     ASSERT_THROW(
         pool->allocateNonContiguous(testData.numNewPages, allocation),
         VeloxRuntimeError);
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
@@ -1189,73 +1399,92 @@ TEST_P(MemoryPoolTest, transientNonContiguousAllocateFailure) {
   struct {
     MachinePageCount numOldPages;
     MachinePageCount numNewPages;
+    MachinePageCount expectedAllocatedPages;
     MemoryAllocator::InjectedFailure injectedFailure;
     std::string debugString() const {
       return fmt::format(
-          "numOldPages:{}, numNewPages:{}, injectedFailure:{}",
+          "numOldPages:{}, numNewPages:{}, expectedAllocatedPages:{}, injectedFailure:{}",
           numOldPages,
           numNewPages,
+          expectedAllocatedPages,
           injectedFailure);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      // Allocate failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {200, 100, MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kAllocate},
-                      // Madvise failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMadvise}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {0, 100, 100, MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun + 1,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun + 1,
+       MemoryAllocator::InjectedFailure::kCap},
+      {200, 100, 100, MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       Allocation::PageRun::kMaxPagesInRun + 1,
+       MemoryAllocator::InjectedFailure::kCap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kCap},
+      // Allocate failure injection.
+      {0, 100, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun + 1,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun + 1,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {200, 100, 100, MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       Allocation::PageRun::kMaxPagesInRun + 1,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kAllocate},
+      // Madvise failure injection.
+      {0, 100, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun + 1,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {200, 100, 100, MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(fmt::format(
         "{}, useMmap:{}, useCache:{}",
@@ -1278,16 +1507,16 @@ TEST_P(MemoryPoolTest, transientNonContiguousAllocateFailure) {
       pool->allocateNonContiguous(testData.numOldPages, allocation);
     }
     ASSERT_GE(allocation.numPages(), testData.numOldPages);
-    allocator_->testingSetFailureInjection(testData.injectedFailure);
+    manager->allocator()->testingSetFailureInjection(testData.injectedFailure);
     if (useCache_) {
       pool->allocateNonContiguous(testData.numNewPages, allocation);
-      ASSERT_EQ(allocation.numPages(), testData.numNewPages);
+      ASSERT_EQ(allocation.numPages(), testData.expectedAllocatedPages);
     } else {
       ASSERT_THROW(
           pool->allocateNonContiguous(testData.numNewPages, allocation),
           VeloxRuntimeError);
     }
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
@@ -1435,7 +1664,8 @@ TEST_P(MemoryPoolTest, persistentContiguousAllocateFailure) {
     if (testData.numOldPages > 0) {
       pool->allocateContiguous(testData.numOldPages, allocation);
     }
-    allocator_->testingSetFailureInjection(testData.injectedFailure, true);
+    manager->allocator()->testingSetFailureInjection(
+        testData.injectedFailure, true);
     ASSERT_EQ(allocation.numPages(), testData.numOldPages);
     if ((testData.numOldPages >= testData.numNewPages) &&
         testData.injectedFailure != MemoryAllocator::InjectedFailure::kMmap) {
@@ -1446,7 +1676,7 @@ TEST_P(MemoryPoolTest, persistentContiguousAllocateFailure) {
           pool->allocateContiguous(testData.numNewPages, allocation),
           VeloxRuntimeError);
     }
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
@@ -1556,7 +1786,7 @@ TEST_P(MemoryPoolTest, transientContiguousAllocateFailure) {
     if (testData.numOldPages > 0) {
       pool->allocateContiguous(testData.numOldPages, allocation);
     }
-    allocator_->testingSetFailureInjection(testData.injectedFailure);
+    manager->allocator()->testingSetFailureInjection(testData.injectedFailure);
     ASSERT_EQ(allocation.numPages(), testData.numOldPages);
     // NOTE: AsyncDataCache will retry on the transient memory allocation
     // failures from the underlying allocator.
@@ -1570,14 +1800,17 @@ TEST_P(MemoryPoolTest, transientContiguousAllocateFailure) {
           pool->allocateContiguous(testData.numNewPages, allocation),
           VeloxRuntimeError);
     }
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
 TEST_P(MemoryPoolTest, contiguousAllocateExceedMemoryPoolLimit) {
   const MachinePageCount kMaxNumPages = 1 << 10;
   const auto kMemoryCapBytes = kMaxNumPages * AllocationTraits::kPageSize;
-  setupMemory({.capacity = 1 << 30});
+  setupMemory(
+      {.allocatorCapacity = 1 << 30,
+       .arbitratorCapacity = 1 << 30,
+       .arbitratorReservedCapacity = 128 * MB});
   auto manager = getMemoryManager();
   auto root =
       manager->addRootPool("contiguousAllocateExceedLimit", kMemoryCapBytes);
@@ -1654,7 +1887,8 @@ TEST_P(MemoryPoolTest, persistentContiguousGrowAllocateFailure) {
         testData.numInitialPages,
         allocation,
         testData.numGrowPages + testData.numInitialPages);
-    allocator_->testingSetFailureInjection(testData.injectedFailure, true);
+    manager->allocator()->testingSetFailureInjection(
+        testData.injectedFailure, true);
     ASSERT_EQ(allocation.numPages(), testData.numInitialPages);
     ASSERT_EQ(
         allocation.maxSize(),
@@ -1664,7 +1898,7 @@ TEST_P(MemoryPoolTest, persistentContiguousGrowAllocateFailure) {
         pool->growContiguous(testData.numGrowPages, allocation),
         testData.expectedErrorMessage);
     ASSERT_EQ(allocation.numPages(), testData.numInitialPages);
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
@@ -1709,7 +1943,8 @@ TEST_P(MemoryPoolTest, transientContiguousGrowAllocateFailure) {
         testData.numInitialPages,
         allocation,
         testData.numGrowPages + testData.numInitialPages);
-    allocator_->testingSetFailureInjection(testData.injectedFailure, false);
+    manager->allocator()->testingSetFailureInjection(
+        testData.injectedFailure, false);
     ASSERT_EQ(allocation.numPages(), testData.numInitialPages);
     ASSERT_EQ(
         allocation.maxSize(),
@@ -1732,14 +1967,17 @@ TEST_P(MemoryPoolTest, transientContiguousGrowAllocateFailure) {
           VeloxRuntimeError);
       ASSERT_EQ(allocation.numPages(), testData.numInitialPages);
     }
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
 TEST_P(MemoryPoolTest, contiguousAllocateGrowExceedMemoryPoolLimit) {
   const MachinePageCount kMaxNumPages = 1 << 10;
   const auto kMemoryCapBytes = kMaxNumPages * AllocationTraits::kPageSize;
-  setupMemory({.capacity = 1 << 30});
+  setupMemory(
+      {.allocatorCapacity = 1 << 30,
+       .arbitratorCapacity = 1 << 30,
+       .arbitratorReservedCapacity = 128 * MB});
   auto manager = getMemoryManager();
   auto root = manager->addRootPool(
       "contiguousAllocateGrowExceedMemoryPoolLimit", kMemoryCapBytes);
@@ -1757,9 +1995,9 @@ TEST_P(MemoryPoolTest, contiguousAllocateGrowExceedMemoryPoolLimit) {
   ASSERT_EQ(allocation.numPages(), kMaxNumPages / 2);
 }
 
-TEST_P(MemoryPoolTest, badNonContiguousAllocation) {
+TEST_P(MemoryPoolTest, nonContiguousAllocationBounds) {
   auto manager = getMemoryManager();
-  auto pool = manager->addLeafPool("badNonContiguousAllocation");
+  auto pool = manager->addLeafPool("nonContiguousAllocationBounds");
   Allocation allocation;
   // Bad zero page allocation size.
   ASSERT_THROW(pool->allocateNonContiguous(0, allocation), VeloxRuntimeError);
@@ -1767,23 +2005,25 @@ TEST_P(MemoryPoolTest, badNonContiguousAllocation) {
   // Set the num of pages to allocate exceeds one PageRun limit.
   constexpr MachinePageCount kNumPages =
       Allocation::PageRun::kMaxPagesInRun + 1;
-  ASSERT_THROW(
-      pool->allocateNonContiguous(kNumPages, allocation), VeloxRuntimeError);
+  pool->allocateNonContiguous(kNumPages, allocation);
+  ASSERT_GE(allocation.numPages(), kNumPages);
+  pool->freeNonContiguous(allocation);
   pool->allocateNonContiguous(kNumPages - 1, allocation);
   ASSERT_GE(allocation.numPages(), kNumPages - 1);
   pool->freeNonContiguous(allocation);
+  pool->allocateNonContiguous(
+      Allocation::PageRun::kMaxPagesInRun * 2, allocation);
+  ASSERT_GE(allocation.numPages(), Allocation::PageRun::kMaxPagesInRun * 2);
+  pool->freeNonContiguous(allocation);
 }
 
 TEST_P(MemoryPoolTest, nonContiguousAllocateExceedLimit) {
   const int64_t kMemoryCapBytes = AllocationTraits::pageBytes(1 << 10);
-  std::shared_ptr<MemoryAllocator> allocator;
-  if (useMmap_) {
-    MmapAllocator::Options mmapOpt{.capacity = (uint64_t)kMemoryCapBytes};
-    allocator = std::make_shared<MmapAllocator>(mmapOpt);
-  } else {
-    allocator = std::make_shared<MallocAllocator>(kMemoryCapBytes);
-  }
-  setupMemory({.capacity = kMemoryCapBytes, .allocator = allocator.get()});
+  setupMemory(
+      {.allocatorCapacity = kMemoryCapBytes,
+       .useMmapAllocator = useMmap_,
+       .arbitratorCapacity = kMemoryCapBytes,
+       .arbitratorReservedCapacity = kMemoryCapBytes / 2});
   auto manager = getMemoryManager();
   const MachinePageCount kMaxNumPages =
       AllocationTraits::numPages(kMemoryCapBytes);
@@ -1808,14 +2048,14 @@ TEST_P(MemoryPoolTest, nonContiguousAllocateExceedLimit) {
 TEST_P(MemoryPoolTest, nonContiguousAllocateError) {
   auto manager = getMemoryManager();
   auto pool = manager->addLeafPool("nonContiguousAllocateError");
-  allocator_->testingSetFailureInjection(
+  manager->allocator()->testingSetFailureInjection(
       MemoryAllocator::InjectedFailure::kAllocate, true);
   constexpr MachinePageCount kAllocSize = 8;
   std::unique_ptr<Allocation> allocation(new Allocation());
   ASSERT_THROW(
       pool->allocateNonContiguous(kAllocSize, *allocation), VeloxRuntimeError);
   ASSERT_TRUE(allocation->empty());
-  allocator_->testingClearFailureInjection();
+  manager->allocator()->testingClearFailureInjection();
   pool->allocateNonContiguous(kAllocSize, *allocation);
   pool->freeNonContiguous(*allocation);
   ASSERT_TRUE(allocation->empty());
@@ -1852,7 +2092,7 @@ TEST_P(MemoryPoolTest, mmapAllocatorCapAllocationError) {
     auto pool = root->addLeafChild(
         "mmapAllocatorCapAllocationError", isLeafThreadSafe_);
 
-    allocator_->testingSetFailureInjection(
+    manager->allocator()->testingSetFailureInjection(
         MemoryAllocator::InjectedFailure::kCap,
         testData.persistentErrorInjection);
     // Async data cache will retry transient memory allocation failure.
@@ -1863,7 +2103,7 @@ TEST_P(MemoryPoolTest, mmapAllocatorCapAllocationError) {
     } else {
       ASSERT_THROW(pool->allocate(testData.allocateBytes), VeloxRuntimeError);
     }
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
@@ -1901,7 +2141,7 @@ TEST_P(MemoryPoolTest, mmapAllocatorCapAllocationZeroFilledError) {
     auto pool = root->addLeafChild(
         "mmapAllocatorCapAllocationZeroFilledError", isLeafThreadSafe_);
 
-    allocator_->testingSetFailureInjection(
+    manager->allocator()->testingSetFailureInjection(
         MemoryAllocator::InjectedFailure::kCap,
         testData.persistentErrorInjection);
     // Async data cache will retry transient memory allocation failure.
@@ -1915,7 +2155,7 @@ TEST_P(MemoryPoolTest, mmapAllocatorCapAllocationZeroFilledError) {
           pool->allocateZeroFilled(testData.numEntries, testData.sizeEach),
           VeloxRuntimeError);
     }
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
@@ -1950,7 +2190,7 @@ TEST_P(MemoryPoolTest, mmapAllocatorCapReallocateError) {
     auto pool = root->addLeafChild(
         "mmapAllocatorCapReallocateError", isLeafThreadSafe_);
 
-    allocator_->testingSetFailureInjection(
+    manager->allocator()->testingSetFailureInjection(
         MemoryAllocator::InjectedFailure::kCap,
         testData.persistentErrorInjection);
     // Async data cache will retry transient memory allocation failure.
@@ -1963,7 +2203,7 @@ TEST_P(MemoryPoolTest, mmapAllocatorCapReallocateError) {
           pool->reallocate(nullptr, 0, testData.allocateBytes),
           VeloxRuntimeError);
     }
-    allocator_->testingClearFailureInjection();
+    manager->allocator()->testingClearFailureInjection();
   }
 }
 
@@ -2144,17 +2384,17 @@ TEST_P(MemoryPoolTest, concurrentUpdateToDifferentPools) {
 
   ASSERT_EQ(root->availableReservation(), 0);
   for (auto& child : childPools) {
-    ASSERT_EQ(child->currentBytes(), 0);
+    ASSERT_EQ(child->usedBytes(), 0);
     child->release();
     ASSERT_EQ(child->reservedBytes(), 0);
     ASSERT_EQ(child->availableReservation(), 0);
-    ASSERT_EQ(child->currentBytes(), 0);
+    ASSERT_EQ(child->usedBytes(), 0);
     ASSERT_LE(child->stats().peakBytes, child->stats().cumulativeBytes);
   }
   ASSERT_LE(root->stats().peakBytes, root->stats().cumulativeBytes);
   childPools.clear();
   ASSERT_LE(root->stats().peakBytes, root->stats().cumulativeBytes);
-  ASSERT_EQ(root->stats().currentBytes, 0);
+  ASSERT_EQ(root->stats().usedBytes, 0);
 }
 
 TEST_P(MemoryPoolTest, concurrentUpdatesToTheSamePool) {
@@ -2194,17 +2434,17 @@ TEST_P(MemoryPoolTest, concurrentUpdatesToTheSamePool) {
 
   ASSERT_EQ(root->availableReservation(), 0);
   for (auto& child : childPools) {
-    ASSERT_EQ(child->currentBytes(), 0);
+    ASSERT_EQ(child->usedBytes(), 0);
     child->release();
     ASSERT_EQ(child->reservedBytes(), 0);
     ASSERT_EQ(child->availableReservation(), 0);
-    ASSERT_EQ(child->currentBytes(), 0);
+    ASSERT_EQ(child->usedBytes(), 0);
     ASSERT_LE(child->stats().peakBytes, child->stats().cumulativeBytes);
   }
   ASSERT_LE(root->stats().peakBytes, root->stats().cumulativeBytes);
   childPools.clear();
   ASSERT_LE(root->stats().peakBytes, root->stats().cumulativeBytes);
-  ASSERT_EQ(root->stats().currentBytes, 0);
+  ASSERT_EQ(root->stats().usedBytes, 0);
 }
 
 TEST_P(MemoryPoolTest, concurrentUpdateToSharedPools) {
@@ -2216,7 +2456,7 @@ TEST_P(MemoryPoolTest, concurrentUpdateToSharedPools) {
   folly::Random::DefaultGenerator rng;
   rng.seed(1234);
 
-  const int32_t kNumOpsPerThread = 1'000;
+  const int32_t kNumOpsPerThread = 200;
   std::vector<std::thread> threads;
   threads.reserve(kNumThreads);
   for (size_t i = 0; i < kNumThreads; ++i) {
@@ -2234,7 +2474,7 @@ TEST_P(MemoryPoolTest, concurrentUpdateToSharedPools) {
   }
 
   for (auto pool : manager.testingSharedLeafPools()) {
-    EXPECT_EQ(pool->currentBytes(), 0);
+    EXPECT_EQ(pool->usedBytes(), 0);
   }
 }
 
@@ -2307,9 +2547,9 @@ TEST_P(MemoryPoolTest, concurrentPoolStructureAccess) {
 }
 
 TEST(MemoryPoolTest, visitChildren) {
-  auto allocator =
-      std::make_shared<MallocAllocator>(MemoryAllocator::kDefaultCapacityBytes);
-  MemoryManager manager{{.allocator = allocator.get()}};
+  MemoryManagerOptions options;
+  options.allocatorCapacity = kMaxMemory;
+  MemoryManager manager{options};
   auto root = manager.addRootPool("root");
 
   const int numChildren = 10;
@@ -2355,13 +2595,13 @@ TEST(MemoryPoolTest, debugMode) {
          uint64_t size) {
         for (const auto& pair : records) {
           EXPECT_EQ(pair.second.size, size);
-          EXPECT_FALSE(pair.second.callStack.empty());
         }
       };
 
-  auto allocator =
-      std::make_shared<MallocAllocator>(MemoryAllocator::kDefaultCapacityBytes);
-  MemoryManager manager{{.debugEnabled = true, .allocator = allocator.get()}};
+  MemoryManagerOptions options;
+  options.allocatorCapacity = kMaxMemory;
+  options.debugEnabled = true;
+  MemoryManager manager{options};
   auto pool = manager.addRootPool("root")->addLeafChild("child");
   const auto& allocRecords = std::dynamic_pointer_cast<MemoryPoolImpl>(pool)
                                  ->testingDebugAllocRecords();
@@ -2410,11 +2650,8 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
   const std::vector<int64_t> kAllocSizes = {128, 8 * KB, 2 * MB};
   const std::vector<bool> debugEnabledSet{true, false};
   for (const auto& debugEnabled : debugEnabledSet) {
-    auto allocator = std::make_shared<MallocAllocator>(kMaxMemory);
     MemoryManager manager{
-        {.capacity = kMaxMemory,
-         .debugEnabled = debugEnabled,
-         .allocator = allocator.get()}};
+        {.debugEnabled = debugEnabled, .allocatorCapacity = kMaxMemory}};
 
     // leaf child created from MemoryPool, not match filter
     MemoryPoolImpl::setDebugPoolNameRegex("NO-MATCH");
@@ -2543,7 +2780,7 @@ TEST_P(MemoryPoolTest, shrinkAndGrowAPIs) {
       ASSERT_EQ(aggregationPool->freeBytes(), capacity);
     }
     if (capacity == 0) {
-      ASSERT_ANY_THROW(leafPool->allocate(allocationSize));
+      VELOX_ASSERT_THROW(leafPool->allocate(allocationSize), "");
       ASSERT_EQ(leafPool->shrink(0), 0);
       ASSERT_EQ(leafPool->shrink(allocationSize), 0);
       continue;
@@ -2553,15 +2790,15 @@ TEST_P(MemoryPoolTest, shrinkAndGrowAPIs) {
       ASSERT_EQ(rootPool->freeBytes(), 0);
       ASSERT_EQ(leafPool->freeBytes(), 0);
       ASSERT_EQ(aggregationPool->freeBytes(), 0);
-      ASSERT_ANY_THROW(leafPool->shrink(0));
-      ASSERT_ANY_THROW(leafPool->shrink(allocationSize));
-      ASSERT_ANY_THROW(leafPool->shrink(kMaxMemory));
-      ASSERT_ANY_THROW(aggregationPool->shrink(0));
-      ASSERT_ANY_THROW(aggregationPool->shrink(allocationSize));
-      ASSERT_ANY_THROW(aggregationPool->shrink(kMaxMemory));
-      ASSERT_ANY_THROW(rootPool->shrink(0));
-      ASSERT_ANY_THROW(rootPool->shrink(allocationSize));
-      ASSERT_ANY_THROW(rootPool->shrink(kMaxMemory));
+      VELOX_ASSERT_THROW(leafPool->shrink(0), "");
+      VELOX_ASSERT_THROW(leafPool->shrink(allocationSize), "");
+      VELOX_ASSERT_THROW(leafPool->shrink(kMaxMemory), "");
+      VELOX_ASSERT_THROW(aggregationPool->shrink(0), "");
+      VELOX_ASSERT_THROW(aggregationPool->shrink(allocationSize), "");
+      VELOX_ASSERT_THROW(aggregationPool->shrink(kMaxMemory), "");
+      VELOX_ASSERT_THROW(rootPool->shrink(0), "");
+      VELOX_ASSERT_THROW(rootPool->shrink(allocationSize), "");
+      VELOX_ASSERT_THROW(rootPool->shrink(kMaxMemory), "");
       leafPool->free(buffer, allocationSize);
       continue;
     }
@@ -2627,11 +2864,14 @@ TEST_P(MemoryPoolTest, shrinkAndGrowAPIs) {
     for (int i = 0; i < step; ++i) {
       const int expectedCapacity = (i + 1) * allocationSize;
       if (i % 3 == 0) {
-        ASSERT_EQ(leafPool->grow(allocationSize), expectedCapacity);
+        ASSERT_TRUE(leafPool->grow(allocationSize, 0));
+        ASSERT_EQ(leafPool->capacity(), expectedCapacity);
       } else if (i % 3 == 1) {
-        ASSERT_EQ(aggregationPool->grow(allocationSize), expectedCapacity);
+        ASSERT_TRUE(aggregationPool->grow(allocationSize, 0));
+        ASSERT_EQ(leafPool->capacity(), expectedCapacity);
       } else {
-        ASSERT_EQ(rootPool->grow(allocationSize), expectedCapacity);
+        ASSERT_TRUE(rootPool->grow(allocationSize, 0));
+        ASSERT_EQ(leafPool->capacity(), expectedCapacity);
       }
       ASSERT_EQ(leafPool->capacity(), expectedCapacity);
       ASSERT_EQ(aggregationPool->capacity(), expectedCapacity);
@@ -2776,12 +3016,10 @@ TEST_P(MemoryPoolTest, reclaimAPIsWithDefaultReclaimer) {
       }
     }
     for (auto& pool : pools) {
-      uint64_t reclaimableBytes{100};
-      ASSERT_FALSE(pool->reclaimableBytes(reclaimableBytes));
-      ASSERT_EQ(reclaimableBytes, 0);
-      ASSERT_EQ(pool->reclaim(0, stats_), 0);
-      ASSERT_EQ(pool->reclaim(100, stats_), 0);
-      ASSERT_EQ(pool->reclaim(kMaxMemory, stats_), 0);
+      ASSERT_FALSE(pool->reclaimableBytes().has_value());
+      ASSERT_EQ(pool->reclaim(0, 0, stats_), 0);
+      ASSERT_EQ(pool->reclaim(100, 0, stats_), 0);
+      ASSERT_EQ(pool->reclaim(kMaxMemory, 0, stats_), 0);
     }
     for (const auto& allocation : allocations) {
       allocation.pool->free(allocation.buffer, allocation.size);
@@ -2824,7 +3062,7 @@ TEST_P(MemoryPoolTest, statsAndToString) {
   void* buf1 = leafChild1->allocate(bufferSize);
   ASSERT_EQ(
       leafChild1->stats().toString(),
-      "currentBytes:1.00KB peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:1.00KB reservedBytes:1.00MB peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       leafChild1->toString(),
       fmt::format(
@@ -2833,7 +3071,7 @@ TEST_P(MemoryPoolTest, statsAndToString) {
           isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"));
   ASSERT_EQ(
       leafChild2->stats().toString(),
-      "currentBytes:0B peakBytes:0B cumulativeBytes:0B numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:0B reservedBytes:0B peakBytes:0B cumulativeBytes:0B numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       leafChild1->toString(),
       fmt::format(
@@ -2842,36 +3080,36 @@ TEST_P(MemoryPoolTest, statsAndToString) {
           isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"));
   ASSERT_EQ(
       aggregateChild->stats().toString(),
-      "currentBytes:0B peakBytes:0B cumulativeBytes:0B numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:0B reservedBytes:0B peakBytes:0B cumulativeBytes:0B numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       root->stats().toString(),
-      "currentBytes:1.00MB peakBytes:1.00MB cumulativeBytes:1.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:1.00KB reservedBytes:1.00MB peakBytes:1.00MB cumulativeBytes:1.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   void* buf2 = leafChild2->allocate(bufferSize);
   ASSERT_EQ(
       leafChild1->stats().toString(),
-      "currentBytes:1.00KB peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:1.00KB reservedBytes:1.00MB peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       leafChild2->stats().toString(),
-      "currentBytes:1.00KB peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:1.00KB reservedBytes:1.00MB peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       aggregateChild->stats().toString(),
-      "currentBytes:1.00MB peakBytes:1.00MB cumulativeBytes:1.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:1.00KB reservedBytes:1.00MB peakBytes:1.00MB cumulativeBytes:1.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       root->stats().toString(),
-      "currentBytes:2.00MB peakBytes:2.00MB cumulativeBytes:2.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:2.00KB reservedBytes:2.00MB peakBytes:2.00MB cumulativeBytes:2.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   leafChild1->free(buf1, bufferSize);
   ASSERT_EQ(
       leafChild1->stats().toString(),
-      "currentBytes:0B peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:1 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:0B reservedBytes:0B peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:1 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       leafChild2->stats().toString(),
-      "currentBytes:1.00KB peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:1.00KB reservedBytes:1.00MB peakBytes:1.00KB cumulativeBytes:1.00KB numAllocs:1 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       aggregateChild->stats().toString(),
-      "currentBytes:1.00MB peakBytes:1.00MB cumulativeBytes:1.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:1.00KB reservedBytes:1.00MB peakBytes:1.00MB cumulativeBytes:1.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   ASSERT_EQ(
       root->stats().toString(),
-      "currentBytes:1.00MB peakBytes:2.00MB cumulativeBytes:2.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0");
+      "usedBytes:1.00KB reservedBytes:1.00MB peakBytes:2.00MB cumulativeBytes:2.00MB numAllocs:0 numFrees:0 numReserves:0 numReleases:0 numShrinks:0 numReclaims:0 numCollisions:0 numCapacityGrowths:0");
   leafChild2->free(buf2, bufferSize);
   std::vector<void*> bufs;
   for (int i = 0; i < 10; ++i) {
@@ -2884,14 +3122,16 @@ TEST_P(MemoryPoolTest, statsAndToString) {
   ASSERT_EQ(root->stats().peakBytes, 2097152);
   ASSERT_EQ(root->peakBytes(), 2097152);
   ASSERT_EQ(root->stats().cumulativeBytes, 3145728);
-  ASSERT_EQ(root->stats().currentBytes, 1048576);
+  ASSERT_EQ(root->stats().usedBytes, 10240);
+  ASSERT_EQ(root->stats().numCapacityGrowths, 0);
   ASSERT_EQ(leafChild1->stats().numAllocs, 11);
   ASSERT_EQ(leafChild1->stats().numFrees, 1);
-  ASSERT_EQ(leafChild1->stats().currentBytes, 10240);
+  ASSERT_EQ(leafChild1->stats().usedBytes, 10240);
   ASSERT_EQ(leafChild1->stats().peakBytes, 10240);
   ASSERT_EQ(leafChild1->stats().cumulativeBytes, 11264);
   ASSERT_EQ(leafChild1->stats().numReserves, 0);
   ASSERT_EQ(leafChild1->stats().numReleases, 0);
+  ASSERT_EQ(leafChild1->stats().numCapacityGrowths, 0);
   for (auto* buf : bufs) {
     leafChild1->free(buf, bufferSize);
   }
@@ -2902,32 +3142,36 @@ TEST_P(MemoryPoolTest, statsAndToString) {
   ASSERT_EQ(root->stats().peakBytes, 2097152);
   ASSERT_EQ(root->peakBytes(), 2097152);
   ASSERT_EQ(root->stats().cumulativeBytes, 3145728);
-  ASSERT_EQ(root->stats().currentBytes, 0);
+  ASSERT_EQ(root->stats().usedBytes, 0);
+  ASSERT_EQ(root->stats().numCapacityGrowths, 0);
   ASSERT_EQ(leafChild1->stats().numAllocs, 11);
   ASSERT_EQ(leafChild1->stats().numFrees, 11);
-  ASSERT_EQ(leafChild1->stats().currentBytes, 0);
+  ASSERT_EQ(leafChild1->stats().usedBytes, 0);
   ASSERT_EQ(leafChild1->stats().peakBytes, 10240);
   ASSERT_EQ(leafChild1->stats().cumulativeBytes, 11264);
   ASSERT_EQ(leafChild1->stats().numReserves, 0);
   ASSERT_EQ(leafChild1->stats().numReleases, 0);
+  ASSERT_EQ(leafChild1->stats().numCapacityGrowths, 0);
   leafChild1->maybeReserve(bufferSize);
   ASSERT_EQ(leafChild1->stats().numAllocs, 11);
   ASSERT_EQ(leafChild1->stats().numFrees, 11);
-  ASSERT_EQ(leafChild1->stats().currentBytes, 0);
+  ASSERT_EQ(leafChild1->stats().usedBytes, 0);
   ASSERT_EQ(leafChild1->stats().peakBytes, 10240);
   ASSERT_EQ(leafChild1->peakBytes(), 10240);
   ASSERT_EQ(leafChild1->stats().cumulativeBytes, 11264);
   ASSERT_EQ(leafChild1->stats().numReserves, 1);
   ASSERT_EQ(leafChild1->stats().numReleases, 0);
+  ASSERT_EQ(leafChild1->stats().numCapacityGrowths, 0);
   leafChild1->release();
   ASSERT_EQ(leafChild1->stats().numAllocs, 11);
   ASSERT_EQ(leafChild1->stats().numFrees, 11);
-  ASSERT_EQ(leafChild1->stats().currentBytes, 0);
+  ASSERT_EQ(leafChild1->stats().usedBytes, 0);
   ASSERT_EQ(leafChild1->stats().cumulativeBytes, 11264);
   ASSERT_EQ(leafChild1->stats().peakBytes, 10240);
   ASSERT_EQ(leafChild1->peakBytes(), 10240);
   ASSERT_EQ(leafChild1->stats().numReserves, 1);
   ASSERT_EQ(leafChild1->stats().numReleases, 1);
+  ASSERT_EQ(leafChild1->stats().numCapacityGrowths, 0);
 }
 
 struct Buffer {
@@ -2937,7 +3181,13 @@ struct Buffer {
 
 TEST_P(MemoryPoolTest, memoryUsageUpdateCheck) {
   constexpr int64_t kMaxSize = 1 << 30; // 1GB
-  setupMemory({.capacity = kMaxSize});
+  //  setupMemory({.allocatorCapacity = kMaxSize});
+  setupMemory(
+      {.allocatorCapacity = kMaxSize,
+       .allocationSizeThresholdWithReservation = false,
+       .arbitratorCapacity = kMaxSize,
+       .arbitratorReservedCapacity = 128 << 20});
+
   auto manager = getMemoryManager();
   auto root = manager->addRootPool("memoryUsageUpdate", kMaxSize);
 
@@ -2946,96 +3196,109 @@ TEST_P(MemoryPoolTest, memoryUsageUpdateCheck) {
 
   ASSERT_THROW(child1->allocate(2 * kMaxSize), VeloxRuntimeError);
 
-  ASSERT_EQ(root->stats().currentBytes, 0);
+  ASSERT_EQ(root->stats().usedBytes, 0);
+  ASSERT_EQ(root->stats().reservedBytes, 0);
   ASSERT_EQ(root->stats().cumulativeBytes, 0);
   ASSERT_EQ(root->reservedBytes(), 0);
 
   std::vector<Buffer> buffers;
   buffers.emplace_back(Buffer{child1->allocate(1000), 1000});
   // The memory pool do alignment internally.
-  ASSERT_EQ(child1->stats().currentBytes, 1024);
-  ASSERT_EQ(child1->currentBytes(), 1024);
+  ASSERT_EQ(child1->stats().usedBytes, 1024);
+  ASSERT_EQ(root->stats().reservedBytes, MB);
+  ASSERT_EQ(child1->usedBytes(), 1024);
   ASSERT_EQ(child1->reservedBytes(), MB);
+  ASSERT_EQ(child1->stats().reservedBytes, MB);
   ASSERT_EQ(child1->stats().cumulativeBytes, 1024);
-  ASSERT_EQ(root->currentBytes(), MB);
+  ASSERT_EQ(root->reservedBytes(), MB);
   ASSERT_EQ(root->stats().cumulativeBytes, MB);
   ASSERT_EQ(MB - 1024, child1->availableReservation());
 
   buffers.emplace_back(Buffer{child1->allocate(1000), 1000});
-  ASSERT_EQ(child1->stats().currentBytes, 2048);
-  ASSERT_EQ(child1->currentBytes(), 2048);
-  ASSERT_EQ(root->currentBytes(), MB);
-  ASSERT_EQ(root->stats().currentBytes, MB);
+  ASSERT_EQ(child1->stats().usedBytes, 2048);
+  ASSERT_EQ(child1->usedBytes(), 2048);
+  ASSERT_EQ(child1->stats().reservedBytes, MB);
+  ASSERT_EQ(root->reservedBytes(), MB);
+  ASSERT_EQ(root->stats().usedBytes, 2048);
   ASSERT_EQ(root->stats().cumulativeBytes, MB);
+  ASSERT_EQ(root->stats().reservedBytes, MB);
 
   buffers.emplace_back(Buffer{child1->allocate(MB), MB});
-  ASSERT_EQ(child1->stats().currentBytes, 2048 + MB);
-  ASSERT_EQ(child1->currentBytes(), 2048 + MB);
-  ASSERT_EQ(root->currentBytes(), 2 * MB);
-  ASSERT_EQ(root->stats().currentBytes, 2 * MB);
+  ASSERT_EQ(child1->stats().usedBytes, 2048 + MB);
+  ASSERT_EQ(child1->stats().reservedBytes, 2 * MB);
+  ASSERT_EQ(child1->usedBytes(), 2048 + MB);
+  ASSERT_EQ(root->reservedBytes(), 2 * MB);
+  ASSERT_EQ(root->stats().usedBytes, 2048 + MB);
   ASSERT_EQ(root->stats().cumulativeBytes, 2 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 2 * MB);
 
   buffers.emplace_back(Buffer{child1->allocate(100 * MB), 100 * MB});
-  ASSERT_EQ(child1->currentBytes(), 2048 + 101 * MB);
-  ASSERT_EQ(child1->stats().currentBytes, 2048 + 101 * MB);
+  ASSERT_EQ(child1->usedBytes(), 2048 + 101 * MB);
+  ASSERT_EQ(child1->stats().usedBytes, 2048 + 101 * MB);
+  ASSERT_EQ(child1->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(child1->reservedBytes(), 104 * MB);
   ASSERT_EQ(
       child1->availableReservation(),
-      child1->reservedBytes() - child1->currentBytes());
+      child1->reservedBytes() - child1->usedBytes());
   // Larger sizes round up to next 8MB.
-  ASSERT_EQ(root->currentBytes(), 104 * MB);
-  ASSERT_EQ(root->stats().currentBytes, 104 * MB);
+  ASSERT_EQ(root->reservedBytes(), 104 * MB);
+  ASSERT_EQ(root->stats().usedBytes, 2048 + 101 * MB);
   ASSERT_EQ(root->stats().cumulativeBytes, 104 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   child1->free(buffers[0].data, buffers[0].length);
-  ASSERT_EQ(child1->currentBytes(), 1024 + 101 * MB);
-  ASSERT_EQ(child1->stats().currentBytes, 1024 + 101 * MB);
+  ASSERT_EQ(child1->usedBytes(), 1024 + 101 * MB);
+  ASSERT_EQ(child1->stats().usedBytes, 1024 + 101 * MB);
   ASSERT_EQ(child1->stats().cumulativeBytes, 2048 + 101 * MB);
   ASSERT_EQ(child1->reservedBytes(), 104 * MB);
   ASSERT_EQ(
       child1->availableReservation(),
-      child1->reservedBytes() - child1->currentBytes());
-  ASSERT_EQ(root->currentBytes(), 104 * MB);
-  ASSERT_EQ(root->stats().currentBytes, 104 * MB);
+      child1->reservedBytes() - child1->usedBytes());
+  ASSERT_EQ(root->reservedBytes(), 104 * MB);
+  ASSERT_EQ(root->stats().usedBytes, 1024 + 101 * MB);
   ASSERT_EQ(root->stats().cumulativeBytes, 104 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   child1->free(buffers[2].data, buffers[2].length);
-  ASSERT_EQ(child1->currentBytes(), 1024 + 100 * MB);
-  ASSERT_EQ(child1->stats().currentBytes, 1024 + 100 * MB);
+  ASSERT_EQ(child1->usedBytes(), 1024 + 100 * MB);
+  ASSERT_EQ(child1->stats().usedBytes, 1024 + 100 * MB);
   ASSERT_EQ(child1->stats().cumulativeBytes, 2048 + 101 * MB);
   ASSERT_EQ(child1->reservedBytes(), 104 * MB);
   ASSERT_EQ(
       child1->availableReservation(),
-      child1->reservedBytes() - child1->currentBytes());
-  ASSERT_EQ(root->currentBytes(), 104 * MB);
-  ASSERT_EQ(root->stats().currentBytes, 104 * MB);
+      child1->reservedBytes() - child1->usedBytes());
+  ASSERT_EQ(root->reservedBytes(), 104 * MB);
+  ASSERT_EQ(root->stats().usedBytes, 1024 + 100 * MB);
   ASSERT_EQ(root->stats().cumulativeBytes, 104 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   child1->free(buffers[3].data, buffers[3].length);
-  ASSERT_EQ(child1->currentBytes(), 1024);
-  ASSERT_EQ(child1->stats().currentBytes, 1024);
+  ASSERT_EQ(child1->usedBytes(), 1024);
+  ASSERT_EQ(child1->stats().usedBytes, 1024);
   ASSERT_EQ(child1->stats().cumulativeBytes, 2048 + 101 * MB);
   ASSERT_EQ(child1->reservedBytes(), MB);
   ASSERT_EQ(
       child1->availableReservation(),
-      child1->reservedBytes() - child1->currentBytes());
-  ASSERT_EQ(root->currentBytes(), MB);
-  ASSERT_EQ(root->stats().currentBytes, MB);
+      child1->reservedBytes() - child1->usedBytes());
+  ASSERT_EQ(root->reservedBytes(), MB);
+  ASSERT_EQ(root->stats().usedBytes, 1024);
   ASSERT_EQ(root->stats().cumulativeBytes, 104 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   child1->free(buffers[1].data, buffers[1].length);
-  ASSERT_EQ(child1->currentBytes(), 0);
-  ASSERT_EQ(child1->stats().currentBytes, 0);
+  ASSERT_EQ(child1->usedBytes(), 0);
+  ASSERT_EQ(child1->stats().usedBytes, 0);
   ASSERT_EQ(child1->stats().cumulativeBytes, 2048 + 101 * MB);
   ASSERT_EQ(child1->reservedBytes(), 0);
   ASSERT_EQ(child1->availableReservation(), 0);
-  ASSERT_EQ(root->currentBytes(), 0);
-  ASSERT_EQ(root->stats().currentBytes, 0);
+  ASSERT_EQ(root->reservedBytes(), 0);
+  ASSERT_EQ(root->stats().usedBytes, 0);
   ASSERT_EQ(root->stats().cumulativeBytes, 104 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 0);
   ASSERT_EQ(root->availableReservation(), 0);
 
   ASSERT_EQ(root->stats().numAllocs, 0);
@@ -3057,7 +3320,10 @@ TEST_P(MemoryPoolTest, memoryUsageUpdateCheck) {
 
 TEST_P(MemoryPoolTest, maybeReserve) {
   constexpr int64_t kMaxSize = 1 << 30; // 1GB
-  setupMemory({.capacity = kMaxSize});
+  setupMemory(
+      {.allocatorCapacity = kMaxSize,
+       .arbitratorCapacity = kMaxSize,
+       .arbitratorReservedCapacity = kMaxSize / 8});
   auto manager = getMemoryManager();
   auto root = manager->addRootPool("reserve", kMaxSize);
 
@@ -3068,67 +3334,79 @@ TEST_P(MemoryPoolTest, maybeReserve) {
   child->maybeReserve(100 * MB);
   // The reservation child shows up as a reservation on the child and as an
   // allocation on the parent.
-  ASSERT_EQ(child->currentBytes(), 0);
-  ASSERT_EQ(child->stats().currentBytes, 0);
+  ASSERT_EQ(child->usedBytes(), 0);
+  ASSERT_EQ(child->stats().usedBytes, 0);
   ASSERT_EQ(child->stats().cumulativeBytes, 0);
+  ASSERT_EQ(child->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(child->availableReservation(), 104 * MB);
 
-  ASSERT_EQ(root->currentBytes(), 104 * MB);
-  ASSERT_EQ(root->stats().currentBytes, 104 * MB);
+  ASSERT_EQ(root->reservedBytes(), 104 * MB);
+  ASSERT_EQ(root->stats().usedBytes, 0);
+  ASSERT_EQ(root->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   std::vector<Buffer> buffers;
   buffers.emplace_back(Buffer{child->allocate(60 * MB), 60 * MB});
-  ASSERT_EQ(child->currentBytes(), 60 * MB);
-  ASSERT_EQ(child->stats().currentBytes, 60 * MB);
+  ASSERT_EQ(child->usedBytes(), 60 * MB);
+  ASSERT_EQ(child->stats().usedBytes, 60 * MB);
   ASSERT_EQ(child->reservedBytes(), 104 * MB);
+  ASSERT_EQ(child->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(
       child->availableReservation(),
-      child->reservedBytes() - child->currentBytes());
-  ASSERT_EQ(root->currentBytes(), 104 * MB);
+      child->reservedBytes() - child->usedBytes());
+  ASSERT_EQ(root->reservedBytes(), 104 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   buffers.emplace_back(Buffer{child->allocate(70 * MB), 70 * MB});
-  ASSERT_EQ(child->currentBytes(), 130 * MB);
-  ASSERT_EQ(child->stats().currentBytes, 130 * MB);
+  ASSERT_EQ(child->usedBytes(), 130 * MB);
+  ASSERT_EQ(child->stats().usedBytes, 130 * MB);
   ASSERT_EQ(child->reservedBytes(), 136 * MB);
+  ASSERT_EQ(child->stats().reservedBytes, 136 * MB);
   ASSERT_EQ(
       child->availableReservation(),
-      child->reservedBytes() - child->currentBytes());
+      child->reservedBytes() - child->usedBytes());
   // Extended and rounded up the reservation to then next 8MB.
-  ASSERT_EQ(root->currentBytes(), 136 * MB);
+  ASSERT_EQ(root->reservedBytes(), 136 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 136 * MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   child->free(buffers[0].data, buffers[0].length);
-  ASSERT_EQ(child->currentBytes(), 70 * MB);
-  ASSERT_EQ(child->stats().currentBytes, 70 * MB);
+  ASSERT_EQ(child->usedBytes(), 70 * MB);
+  ASSERT_EQ(child->stats().usedBytes, 70 * MB);
   // Extended and rounded up the reservation to then next 8MB.
   ASSERT_EQ(child->reservedBytes(), 104 * MB);
+  ASSERT_EQ(child->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(
       child->availableReservation(),
-      child->reservedBytes() - child->currentBytes());
-  ASSERT_EQ(root->currentBytes(), 104 * MB);
+      child->reservedBytes() - child->usedBytes());
+  ASSERT_EQ(root->reservedBytes(), 104 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   child->free(buffers[1].data, buffers[1].length);
 
   // The reservation goes down to the explicitly made reservation.
-  ASSERT_EQ(child->currentBytes(), 0);
-  ASSERT_EQ(child->stats().currentBytes, 0);
+  ASSERT_EQ(child->usedBytes(), 0);
+  ASSERT_EQ(child->stats().usedBytes, 0);
   ASSERT_EQ(child->reservedBytes(), 104 * MB);
+  ASSERT_EQ(child->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(
       child->availableReservation(),
-      child->reservedBytes() - child->currentBytes());
-  ASSERT_EQ(root->currentBytes(), 104 * MB);
+      child->reservedBytes() - child->usedBytes());
+  ASSERT_EQ(root->reservedBytes(), 104 * MB);
+  ASSERT_EQ(root->stats().reservedBytes, 104 * MB);
   ASSERT_EQ(root->availableReservation(), 0);
 
   child->release();
-  ASSERT_EQ(child->currentBytes(), 0);
-  ASSERT_EQ(child->stats().currentBytes, 0);
+  ASSERT_EQ(child->usedBytes(), 0);
+  ASSERT_EQ(child->stats().usedBytes, 0);
   ASSERT_EQ(child->reservedBytes(), 0);
+  ASSERT_EQ(child->stats().reservedBytes, 0);
   ASSERT_EQ(child->availableReservation(), 0);
-  ASSERT_EQ(root->currentBytes(), 0);
+  ASSERT_EQ(root->reservedBytes(), 0);
   ASSERT_EQ(root->availableReservation(), 0);
+  ASSERT_EQ(root->stats().reservedBytes, 0);
 
   ASSERT_EQ(root->stats().numAllocs, 0);
   ASSERT_EQ(root->stats().numFrees, 0);
@@ -3149,7 +3427,11 @@ TEST_P(MemoryPoolTest, maybeReserve) {
 
 TEST_P(MemoryPoolTest, maybeReserveFailWithAbort) {
   constexpr int64_t kMaxSize = 1 * GB; // 1GB
-  setupMemory({.capacity = kMaxSize, .arbitratorKind = "SHARED"});
+  setupMemory(
+      {.allocatorCapacity = kMaxSize,
+       .arbitratorCapacity = kMaxSize,
+       .arbitratorReservedCapacity = kMaxSize / 8,
+       .arbitratorKind = "SHARED"});
   MemoryManager& manager = *getMemoryManager();
   auto root = manager.addRootPool(
       "maybeReserveFailWithAbort", kMaxSize, MemoryReclaimer::create());
@@ -3161,39 +3443,17 @@ TEST_P(MemoryPoolTest, maybeReserveFailWithAbort) {
   ASSERT_TRUE(child->aborted());
   ASSERT_TRUE(root->aborted());
   VELOX_ASSERT_THROW(
-      child->maybeReserve(2 * kMaxSize), "This memory pool has been aborted.");
-}
-
-// Model implementation of a GrowCallback.
-bool grow(int64_t size, int64_t hardLimit, MemoryPool& pool) {
-  static std::mutex mutex;
-  // The calls from different threads on the same tracker must be serialized.
-  std::lock_guard<std::mutex> l(mutex);
-  // The total includes the allocation that exceeded the limit. This function's
-  // job is to raise the limit to >= current + size.
-  auto current = pool.reservedBytes();
-  auto limit = pool.capacity();
-  if (current + size <= limit) {
-    // No need to increase. It could be another thread already
-    // increased the cap far enough while this thread was waiting to
-    // enter the lock_guard.
-    return true;
-  }
-  if (current + size > hardLimit) {
-    // The caller will revert the allocation that called this and signal an
-    // error.
-    return false;
-  }
-  // We set the new limit to be the requested size.
-  static_cast<MemoryPoolImpl*>(&pool)->testingSetCapacity(current + size);
-  return true;
+      child->maybeReserve(2 * kMaxSize), "Manual MemoryPool Abortion");
 }
 
 DEBUG_ONLY_TEST_P(MemoryPoolTest, raceBetweenFreeAndFailedAllocation) {
   if (!isLeafThreadSafe_) {
     return;
   }
-  setupMemory({.capacity = 1 * GB});
+  setupMemory(
+      {.allocatorCapacity = 1 * GB,
+       .arbitratorCapacity = 1 * GB,
+       .arbitratorReservedCapacity = 128 * MB});
   auto manager = getMemoryManager();
   auto root = manager->addRootPool("grow", 64 * MB);
   auto child = root->addLeafChild("grow", isLeafThreadSafe_);
@@ -3206,19 +3466,20 @@ DEBUG_ONLY_TEST_P(MemoryPoolTest, raceBetweenFreeAndFailedAllocation) {
       std::function<void(MemoryPool*)>([&](MemoryPool* /*unused*/) {
         ++reservationAttempts;
         // On the first reservation attempt for the second buffer allocation,
-        // trigger to free the first allocated buffer which will cause the first
-        // reservation attempt fails. The quantized reservation size of the
-        // first attempt is 16MB which requires 20MB after the first buffer
-        // free.
+        // trigger to free the first allocated buffer which will cause the
+        // first reservation attempt fails. The quantized reservation size of
+        // the first attempt is 16MB which requires 20MB after the first
+        // buffer free.
         if (reservationAttempts == 1) {
           // Inject to free the first allocated buffer while the
           child->free(buffer1, 17 * MB);
           return;
         }
         // On the second reservation attempt for the second buffer allocation,
-        // reduce the memory pool's capacity to trigger the memory pool capacity
-        // exceeded exception error which might leave unused reservation bytes
-        // but zero used reservation if we don't do the cleanup properly.
+        // reduce the memory pool's capacity to trigger the memory pool
+        // capacity exceeded exception error which might leave unused
+        // reservation bytes but zero used reservation if we don't do the
+        // cleanup properly.
         if (reservationAttempts == 2) {
           static_cast<MemoryPoolImpl*>(root.get())->testingSetCapacity(16 * MB);
           return;
@@ -3312,7 +3573,9 @@ TEST_P(MemoryPoolTest, abortAPI) {
       }
       ASSERT_TRUE(rootPool->aborted());
       {
-        abortPool(rootPool.get());
+        VELOX_ASSERT_THROW(
+            abortPool(rootPool.get()),
+            "Trying to set another abort error on an already aborted pool.");
         ASSERT_TRUE(rootPool->aborted());
       }
       ASSERT_TRUE(rootPool->aborted());
@@ -3374,7 +3637,9 @@ TEST_P(MemoryPoolTest, abortAPI) {
           "aggregateAbortAPI", MemoryReclaimer::create());
       ASSERT_TRUE(aggregatePool->aborted());
       {
-        abortPool(aggregatePool.get());
+        VELOX_ASSERT_THROW(
+            abortPool(aggregatePool.get()),
+            "Trying to set another abort error on an already aborted pool.");
         ASSERT_TRUE(aggregatePool->aborted());
         ASSERT_TRUE(leafPool->aborted());
         ASSERT_TRUE(rootPool->aborted());
@@ -3383,7 +3648,9 @@ TEST_P(MemoryPoolTest, abortAPI) {
       ASSERT_TRUE(leafPool->aborted());
       ASSERT_TRUE(rootPool->aborted());
       {
-        abortPool(rootPool.get());
+        VELOX_ASSERT_THROW(
+            abortPool(rootPool.get()),
+            "Trying to set another abort error on an already aborted pool.");
         ASSERT_TRUE(aggregatePool->aborted());
         ASSERT_TRUE(leafPool->aborted());
         ASSERT_TRUE(rootPool->aborted());
@@ -3526,7 +3793,7 @@ TEST_P(MemoryPoolTest, abort) {
 
       // Allocate some buffer from leaf.
       void* buf1 = leafPool->allocate(128);
-      ASSERT_EQ(leafPool->currentBytes(), 128);
+      ASSERT_EQ(leafPool->usedBytes(), 128);
 
       // Abort the pool.
       ContinueFuture future;
@@ -3554,20 +3821,71 @@ TEST_P(MemoryPoolTest, abort) {
       { VELOX_ASSERT_THROW(leafPool->allocate(capacity * 2), ""); }
       // Allocate without trigger memory reservation increment.
       void* buf2 = leafPool->allocate(128);
-      ASSERT_EQ(leafPool->currentBytes(), 256);
+      ASSERT_EQ(leafPool->usedBytes(), 256);
       leafPool->free(buf1, 128);
       leafPool->free(buf2, 128);
-      ASSERT_EQ(leafPool->currentBytes(), 0);
+      ASSERT_EQ(leafPool->usedBytes(), 0);
       ASSERT_EQ(leafPool->capacity(), capacity);
     }
   }
 }
 
+TEST_P(MemoryPoolTest, overuseUnderArbitration) {
+  constexpr int64_t kMaxSize = 128 * MB; // 1GB
+  setupMemory(
+      {.allocatorCapacity = kMaxSize,
+       .arbitratorCapacity = kMaxSize,
+       .arbitratorReservedCapacity = 4 * MB,
+       .arbitratorKind = "SHARED"});
+  MemoryManager& manager = *getMemoryManager();
+  auto root = manager.addRootPool(
+      "overuseUnderArbitration", kMaxSize, MemoryReclaimer::create());
+  auto child = root->addLeafChild("overuseUnderArbitration");
+  // maybeReserve returns false if reservation fails.
+  ASSERT_FALSE(child->maybeReserve(2 * kMaxSize));
+  ASSERT_EQ(child->usedBytes(), 0);
+  ASSERT_EQ(child->reservedBytes(), 0);
+  ScopedMemoryArbitrationContext scopedMemoryArbitration(child.get());
+  ASSERT_TRUE(underMemoryArbitration());
+  ASSERT_TRUE(child->maybeReserve(2 * kMaxSize));
+  ASSERT_EQ(child->usedBytes(), 0);
+  ASSERT_EQ(child->reservedBytes(), 2 * kMaxSize);
+  child->release();
+  ASSERT_EQ(child->usedBytes(), 0);
+  ASSERT_EQ(child->reservedBytes(), 0);
+}
+
+TEST_P(MemoryPoolTest, allocationWithCoveredCollateral) {
+  // Verify that the memory pool's reservation is correctly updated when an
+  // allocation call is attempted with collateral that covers the allocation
+  // (that is, the collateral is larger than the requested allocation).
+  auto manager = getMemoryManager();
+  auto root = manager->addRootPool("root", kMaxMemory, nullptr);
+  ASSERT_TRUE(root->trackUsage());
+  auto pool =
+      root->addLeafChild("allocationWithCoveredCollateral", isLeafThreadSafe_);
+  ASSERT_TRUE(pool->trackUsage());
+  // Check non-contiguous allocation.
+  ASSERT_EQ(pool->reservedBytes(), 0);
+  Allocation allocation;
+  pool->allocateNonContiguous(100, allocation);
+  auto prevReservedBytes = pool->usedBytes();
+  pool->allocateNonContiguous(50, allocation);
+  ASSERT_LT(pool->usedBytes(), prevReservedBytes);
+  pool->freeNonContiguous(allocation);
+
+  // Check contiguous allocation.
+  ContiguousAllocation contiguousAllocation;
+  pool->allocateContiguous(100, contiguousAllocation);
+  prevReservedBytes = pool->usedBytes();
+  pool->allocateContiguous(50, contiguousAllocation);
+  ASSERT_LT(pool->usedBytes(), prevReservedBytes);
+  pool->freeContiguous(contiguousAllocation);
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     MemoryPoolTestSuite,
     MemoryPoolTest,
     testing::ValuesIn(MemoryPoolTest::getTestParams()));
 
-} // namespace memory
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::memory
diff --git a/velox/common/memory/tests/MockSharedArbitratorTest.cpp b/velox/common/memory/tests/MockSharedArbitratorTest.cpp
index 8f092cc64e204..8860a46562d5f 100644
--- a/velox/common/memory/tests/MockSharedArbitratorTest.cpp
+++ b/velox/common/memory/tests/MockSharedArbitratorTest.cpp
@@ -16,8 +16,10 @@
 
 #include <gtest/gtest.h>
 
+#include <fmt/format.h>
 #include <re2/re2.h>
 #include <deque>
+#include <vector>
 #include "folly/experimental/EventCount.h"
 #include "folly/futures/Barrier.h"
 #include "velox/common/base/tests/GTestUtils.h"
@@ -26,6 +28,7 @@
 #include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 
@@ -39,12 +42,36 @@ using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::memory {
 namespace {
+
+// Class to write runtime stats in the tests to the stats container.
+class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
+ public:
+  explicit TestRuntimeStatWriter(
+      std::unordered_map<std::string, RuntimeMetric>& stats)
+      : stats_{stats} {}
+
+  void addRuntimeStat(const std::string& name, const RuntimeCounter& value)
+      override {
+    addOperatorRuntimeStats(name, value, stats_);
+  }
+
+ private:
+  std::unordered_map<std::string, RuntimeMetric>& stats_;
+};
+
 constexpr int64_t KB = 1024L;
 constexpr int64_t MB = 1024L * KB;
 
 constexpr uint64_t kMemoryCapacity = 512 * MB;
+constexpr uint64_t kReservedMemoryCapacity = 128 * MB;
 constexpr uint64_t kMemoryPoolInitCapacity = 16 * MB;
-constexpr uint64_t kMemoryPoolTransferCapacity = 8 * MB;
+// TODO(jtan6): Remove after complete transfer capacity deprecation
+constexpr uint64_t kMemoryPoolTransferCapacity = 0;
+constexpr uint64_t kMemoryPoolReservedCapacity = 8 * MB;
+constexpr uint64_t kFastExponentialGrowthCapacityLimit = 32 * MB;
+constexpr double kSlowCapacityGrowPct = 0.25;
+constexpr uint64_t kMemoryPoolMinFreeCapacity = 8 * MB;
+constexpr double kMemoryPoolMinFreeCapacityPct = 0.25;
 
 class MemoryReclaimer;
 class MockMemoryOperator;
@@ -161,8 +188,11 @@ class MockMemoryOperator {
       return op_->reclaimableBytes(pool, reclaimableBytes);
     }
 
-    uint64_t reclaim(MemoryPool* pool, uint64_t targetBytes, Stats& stats)
-        override {
+    uint64_t reclaim(
+        MemoryPool* pool,
+        uint64_t targetBytes,
+        uint64_t /*unused*/,
+        Stats& stats) override {
       ++numReclaims_;
       if (!reclaimable_) {
         return 0;
@@ -171,7 +201,9 @@ class MockMemoryOperator {
         reclaimInjectCb_(pool, targetBytes);
       }
       reclaimTargetBytes_.push_back(targetBytes);
-      return op_->reclaim(pool, targetBytes);
+      auto reclaimBytes = op_->reclaim(pool, targetBytes);
+      stats.reclaimedBytes += reclaimBytes;
+      return reclaimBytes;
     }
 
     void enterArbitration() override {
@@ -236,27 +268,25 @@ class MockMemoryOperator {
 
   void free(void* buffer) {
     size_t size;
-    {
-      std::lock_guard<std::mutex> l(mu_);
-      VELOX_CHECK_EQ(allocations_.count(buffer), 1);
-      size = allocations_[buffer];
-      totalBytes_ -= size;
-      allocations_.erase(buffer);
-    }
+    std::lock_guard<std::mutex> l(mu_);
+    VELOX_CHECK_EQ(allocations_.count(buffer), 1);
+    size = allocations_[buffer];
+    totalBytes_ -= size;
+    allocations_.erase(buffer);
     pool_->free(buffer, size);
   }
 
   void freeAll() {
-    std::unordered_map<void*, size_t> allocations;
+    std::unordered_map<void*, size_t> allocationsToFree;
     {
       std::lock_guard<std::mutex> l(mu_);
       for (auto entry : allocations_) {
         totalBytes_ -= entry.second;
       }
-      allocations.swap(allocations_);
       VELOX_CHECK_EQ(totalBytes_, 0);
+      allocationsToFree.swap(allocations_);
     }
-    for (auto entry : allocations) {
+    for (auto entry : allocationsToFree) {
       pool_->free(entry.first, entry.second);
     }
   }
@@ -308,24 +338,22 @@ class MockMemoryOperator {
     for (const auto& allocation : allocationsToFree) {
       pool_->free(allocation.buffer, allocation.size);
     }
-    return pool_->shrink(targetBytes);
+    return bytesReclaimed;
   }
 
   void abort(MemoryPool* pool) {
-    std::vector<Allocation> allocationsToFree;
+    std::unordered_map<void*, size_t> allocationsToFree;
     {
       std::lock_guard<std::mutex> l(mu_);
       VELOX_CHECK_NOT_NULL(pool_);
       VELOX_CHECK_EQ(pool->name(), pool_->name());
-      for (auto allocEntry : allocations_) {
-        allocationsToFree.push_back(
-            Allocation{allocEntry.first, allocEntry.second});
-        totalBytes_ -= allocEntry.second;
+      for (const auto& allocation : allocations_) {
+        totalBytes_ -= allocation.second;
       }
-      allocations_.clear();
+      allocationsToFree.swap(allocations_);
     }
-    for (const auto& allocation : allocationsToFree) {
-      pool_->free(allocation.buffer, allocation.size);
+    for (auto entry : allocationsToFree) {
+      pool_->free(entry.first, entry.second);
     }
   }
 
@@ -397,26 +425,32 @@ class MockSharedArbitrationTest : public testing::Test {
   }
 
   void setupMemory(
-      int64_t memoryCapacity = 0,
-      uint64_t memoryPoolInitCapacity = kMaxMemory,
-      uint64_t memoryPoolTransferCapacity = 0,
-      std::function<void(MemoryPool&)> arbitrationStateCheckCb = nullptr) {
-    if (memoryPoolInitCapacity == kMaxMemory) {
-      memoryPoolInitCapacity = kMemoryPoolInitCapacity;
-    }
-    if (memoryPoolTransferCapacity == 0) {
-      memoryPoolTransferCapacity = kMemoryPoolTransferCapacity;
-    }
-    memoryCapacity = (memoryCapacity != 0) ? memoryCapacity : kMemoryCapacity;
-    allocator_ = std::make_shared<MallocAllocator>(memoryCapacity);
+      int64_t memoryCapacity = kMemoryCapacity,
+      int64_t reservedMemoryCapacity = kReservedMemoryCapacity,
+      uint64_t memoryPoolInitCapacity = kMemoryPoolInitCapacity,
+      uint64_t memoryPoolReserveCapacity = kMemoryPoolReservedCapacity,
+      uint64_t memoryPoolTransferCapacity = kMemoryPoolTransferCapacity,
+      uint64_t fastExponentialGrowthCapacityLimit =
+          kFastExponentialGrowthCapacityLimit,
+      double slowCapacityGrowPct = kSlowCapacityGrowPct,
+      uint64_t memoryPoolMinFreeCapacity = kMemoryPoolMinFreeCapacity,
+      double memoryPoolMinFreeCapacityPct = kMemoryPoolMinFreeCapacityPct,
+      std::function<void(MemoryPool&)> arbitrationStateCheckCb = nullptr,
+      bool globalArtbitrationEnabled = true) {
     MemoryManagerOptions options;
-    options.allocator = allocator_.get();
-    options.capacity = allocator_->capacity();
+    options.allocatorCapacity = memoryCapacity;
+    options.arbitratorReservedCapacity = reservedMemoryCapacity;
     std::string arbitratorKind = "SHARED";
     options.arbitratorKind = arbitratorKind;
-    options.capacity = options.capacity;
     options.memoryPoolInitCapacity = memoryPoolInitCapacity;
+    options.memoryPoolReservedCapacity = memoryPoolReserveCapacity;
     options.memoryPoolTransferCapacity = memoryPoolTransferCapacity;
+    options.fastExponentialGrowthCapacityLimit =
+        fastExponentialGrowthCapacityLimit;
+    options.slowCapacityGrowPct = slowCapacityGrowPct;
+    options.memoryPoolMinFreeCapacity = memoryPoolMinFreeCapacity;
+    options.memoryPoolMinFreeCapacityPct = memoryPoolMinFreeCapacityPct;
+    options.globalArbitrationEnabled = globalArtbitrationEnabled;
     options.arbitrationStateCheckCb = std::move(arbitrationStateCheckCb);
     options.checkUsageLeak = true;
     manager_ = std::make_unique<MemoryManager>(options);
@@ -444,10 +478,11 @@ class MockSharedArbitrationTest : public testing::Test {
     tasks_.clear();
   }
 
-  std::shared_ptr<MemoryAllocator> allocator_;
   std::unique_ptr<MemoryManager> manager_;
   SharedArbitrator* arbitrator_;
   std::vector<std::shared_ptr<MockTask>> tasks_;
+  std::unique_ptr<folly::CPUThreadPoolExecutor> executor_ =
+      std::make_unique<folly::CPUThreadPoolExecutor>(4);
 };
 
 MockMemoryOperator* MockSharedArbitrationTest::addMemoryOp(
@@ -469,20 +504,18 @@ void verifyArbitratorStats(
     const MemoryArbitrator::Stats& stats,
     uint64_t maxCapacityBytes,
     uint64_t freeCapacityBytes = 0,
+    uint64_t freeReservedCapacityBytes = 0,
     uint64_t numRequests = 0,
-    uint64_t numSucceeded = 0,
     uint64_t numFailures = 0,
     uint64_t numReclaimedBytes = 0,
     uint64_t numShrunkBytes = 0,
-    uint64_t arbitrationTimeUs = 0,
-    uint64_t queueTimeUs = 0) {
+    uint64_t arbitrationTimeUs = 0) {
   ASSERT_EQ(stats.numRequests, numRequests);
-  ASSERT_EQ(stats.numSucceeded, numSucceeded);
   ASSERT_EQ(stats.numFailures, numFailures);
   ASSERT_EQ(stats.numReclaimedBytes, numReclaimedBytes);
   ASSERT_EQ(stats.numShrunkBytes, numShrunkBytes);
   ASSERT_GE(stats.arbitrationTimeUs, arbitrationTimeUs);
-  ASSERT_GE(stats.queueTimeUs, queueTimeUs);
+  ASSERT_EQ(stats.freeReservedCapacityBytes, freeReservedCapacityBytes);
   ASSERT_EQ(stats.freeCapacityBytes, freeCapacityBytes);
   ASSERT_EQ(stats.maxCapacityBytes, maxCapacityBytes);
 }
@@ -500,23 +533,128 @@ void verifyReclaimerStats(
   }
 }
 
+TEST_F(MockSharedArbitrationTest, extraConfigs) {
+  // Testing default values
+  std::unordered_map<std::string, std::string> emptyConfigs;
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getReservedCapacity(emptyConfigs), 0);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getReservedCapacity(emptyConfigs), 0);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getMemoryPoolInitialCapacity(emptyConfigs),
+      256 << 20);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getMemoryPoolTransferCapacity(
+          emptyConfigs),
+      128 << 20);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getMemoryReclaimMaxWaitTimeMs(
+          emptyConfigs),
+      0);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getGlobalArbitrationEnabled(emptyConfigs),
+      SharedArbitrator::ExtraConfig::kDefaultGlobalArbitrationEnabled);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getCheckUsageLeak(emptyConfigs),
+      SharedArbitrator::ExtraConfig::kDefaultCheckUsageLeak);
+
+  // Testing custom values
+  std::unordered_map<std::string, std::string> configs;
+  configs[std::string(SharedArbitrator::ExtraConfig::kReservedCapacity)] =
+      "100B";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kMemoryPoolInitialCapacity)] = "512MB";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kMemoryPoolReservedCapacity)] = "200B";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kMemoryPoolTransferCapacity)] = "256MB";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kMemoryReclaimMaxWaitTime)] = "5000ms";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kGlobalArbitrationEnabled)] = "true";
+  configs[std::string(SharedArbitrator::ExtraConfig::kCheckUsageLeak)] =
+      "false";
+  ASSERT_EQ(SharedArbitrator::ExtraConfig::getReservedCapacity(configs), 100);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getMemoryPoolInitialCapacity(configs),
+      512 << 20);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getMemoryPoolReservedCapacity(configs),
+      200);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getMemoryPoolTransferCapacity(configs),
+      256 << 20);
+  ASSERT_EQ(
+      SharedArbitrator::ExtraConfig::getMemoryReclaimMaxWaitTimeMs(configs),
+      5000);
+  ASSERT_TRUE(
+      SharedArbitrator::ExtraConfig::getGlobalArbitrationEnabled(configs));
+  ASSERT_FALSE(SharedArbitrator::ExtraConfig::getCheckUsageLeak(configs));
+
+  // Testing invalid values
+  configs[std::string(SharedArbitrator::ExtraConfig::kReservedCapacity)] =
+      "invalid";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kMemoryPoolInitialCapacity)] = "invalid";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kMemoryPoolReservedCapacity)] = "invalid";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kMemoryPoolTransferCapacity)] = "invalid";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kMemoryReclaimMaxWaitTime)] = "invalid";
+  configs[std::string(
+      SharedArbitrator::ExtraConfig::kGlobalArbitrationEnabled)] = "invalid";
+  configs[std::string(SharedArbitrator::ExtraConfig::kCheckUsageLeak)] =
+      "invalid";
+  VELOX_ASSERT_THROW(
+      SharedArbitrator::ExtraConfig::getReservedCapacity(configs),
+      "Invalid capacity string 'invalid'");
+  VELOX_ASSERT_THROW(
+      SharedArbitrator::ExtraConfig::getMemoryPoolInitialCapacity(configs),
+      "Invalid capacity string 'invalid'");
+  VELOX_ASSERT_THROW(
+      SharedArbitrator::ExtraConfig::getMemoryPoolReservedCapacity(configs),
+      "Invalid capacity string 'invalid'");
+  VELOX_ASSERT_THROW(
+      SharedArbitrator::ExtraConfig::getMemoryPoolTransferCapacity(configs),
+      "Invalid capacity string 'invalid'");
+  VELOX_ASSERT_THROW(
+      SharedArbitrator::ExtraConfig::getMemoryReclaimMaxWaitTimeMs(configs),
+      "Invalid duration 'invalid'");
+  VELOX_ASSERT_THROW(
+      SharedArbitrator::ExtraConfig::getGlobalArbitrationEnabled(configs),
+      "Failed while parsing SharedArbitrator configs");
+  VELOX_ASSERT_THROW(
+      SharedArbitrator::ExtraConfig::getCheckUsageLeak(configs),
+      "Failed while parsing SharedArbitrator configs");
+}
+
 TEST_F(MockSharedArbitrationTest, constructor) {
+  const int reservedCapacity = arbitrator_->stats().freeReservedCapacityBytes;
+  const int nonReservedCapacity =
+      arbitrator_->stats().freeCapacityBytes - reservedCapacity;
   std::vector<std::shared_ptr<MockTask>> tasks;
+  int remainingFreeCapacity = arbitrator_->stats().freeCapacityBytes;
   for (int i = 0; i <= kMemoryCapacity / kMemoryPoolInitCapacity; ++i) {
     auto task = addTask(kMemoryCapacity);
     ASSERT_NE(task->pool()->reclaimer(), nullptr);
-    if (i < kMemoryCapacity / kMemoryPoolInitCapacity) {
+    if (i < nonReservedCapacity / kMemoryPoolInitCapacity) {
       ASSERT_EQ(task->capacity(), kMemoryPoolInitCapacity);
     } else {
-      ASSERT_EQ(task->capacity(), 0);
+      ASSERT_EQ(task->capacity(), kMemoryPoolReservedCapacity) << i;
     }
+    remainingFreeCapacity -= task->capacity();
     tasks.push_back(std::move(task));
   }
   auto stats = arbitrator_->stats();
-  verifyArbitratorStats(stats, kMemoryCapacity);
+  ASSERT_EQ(remainingFreeCapacity, stats.freeCapacityBytes);
+  ASSERT_EQ(remainingFreeCapacity, stats.freeReservedCapacityBytes);
+  verifyArbitratorStats(
+      stats, kMemoryCapacity, remainingFreeCapacity, remainingFreeCapacity);
   tasks.clear();
   stats = arbitrator_->stats();
-  verifyArbitratorStats(stats, kMemoryCapacity, kMemoryCapacity);
+  verifyArbitratorStats(
+      stats, kMemoryCapacity, kMemoryCapacity, reservedCapacity);
 }
 
 TEST_F(MockSharedArbitrationTest, arbitrationStateCheck) {
@@ -524,11 +662,11 @@ TEST_F(MockSharedArbitrationTest, arbitrationStateCheck) {
   const int minPoolCapacity = 32 * MB;
   std::atomic<int> checkCount{0};
   MemoryArbitrationStateCheckCB checkCountCb = [&](MemoryPool& pool) {
-    const std::string re("MockTask.*");
-    ASSERT_TRUE(RE2::FullMatch(pool.name(), re));
+    const std::string re("RootPool.*");
+    ASSERT_TRUE(RE2::FullMatch(pool.name(), re)) << pool.name();
     ++checkCount;
   };
-  setupMemory(memCapacity, 0, 0, checkCountCb);
+  setupMemory(memCapacity, 0, 0, 0, 0, 0, 0, 0, 0, checkCountCb);
 
   const int numTasks{5};
   std::vector<std::shared_ptr<MockTask>> tasks;
@@ -553,31 +691,62 @@ TEST_F(MockSharedArbitrationTest, arbitrationStateCheck) {
   MemoryArbitrationStateCheckCB badCheckCb = [&](MemoryPool& /*unused*/) {
     VELOX_FAIL("bad check");
   };
-  setupMemory(memCapacity, 0, 0, badCheckCb);
+  setupMemory(memCapacity, 0, 0, 0, 0, 0, 0, 0, 0, badCheckCb);
   std::shared_ptr<MockTask> task = addTask(kMemoryCapacity);
   ASSERT_EQ(task->capacity(), 0);
   MockMemoryOperator* memOp = task->addMemoryOp();
   VELOX_ASSERT_THROW(memOp->allocate(128), "bad check");
 }
 
+TEST_F(MockSharedArbitrationTest, asyncArbitrationWork) {
+  const int memoryCapacity = 512 * MB;
+  const int poolCapacity = 256 * MB;
+  setupMemory(memoryCapacity, 0, poolCapacity, 0);
+
+  std::atomic_int reclaimedCount{0};
+  std::shared_ptr<MockTask> task = addTask(poolCapacity);
+  MockMemoryOperator* memoryOp =
+      addMemoryOp(task, true, [&](MemoryPool* pool, uint64_t /*unsed*/) {
+        struct Result {
+          bool succeeded{true};
+
+          explicit Result(bool _succeeded) : succeeded(_succeeded) {}
+        };
+        auto asyncReclaimTask = createAsyncMemoryReclaimTask<Result>([&]() {
+          memoryOp->allocate(poolCapacity);
+          return std::make_unique<Result>(true);
+        });
+        executor_->add([&]() { asyncReclaimTask->prepare(); });
+        std::this_thread::sleep_for(std::chrono::seconds(1)); // NOLINT
+        const auto result = asyncReclaimTask->move();
+        ASSERT_TRUE(result->succeeded);
+        memoryOp->freeAll();
+        ++reclaimedCount;
+      });
+  memoryOp->allocate(poolCapacity);
+  memoryOp->allocate(poolCapacity);
+  ASSERT_EQ(reclaimedCount, 1);
+}
+
 TEST_F(MockSharedArbitrationTest, arbitrationFailsTask) {
-  auto nonReclaimTask = addTask(384 * MB);
-  auto nonReclaimOp = nonReclaimTask->addMemoryOp(false);
-  auto buf = nonReclaimOp->allocate(384 * MB);
+  auto nonReclaimTask = addTask(328 * MB);
+  auto* nonReclaimOp = nonReclaimTask->addMemoryOp(false);
+  auto* buf = nonReclaimOp->allocate(320 * MB);
 
   // growTask is (192 + 128) = 320MB which is less than nonReclaimTask 384MB.
-  // This makes sure nonReclaimTask gets picked as the victim during handleOOM()
-  auto growTask = addTask(192 * MB);
-  auto growOp = growTask->addMemoryOp(false);
-  auto bufGrow = growOp->allocate(128 * MB);
-  EXPECT_NO_THROW(manager_->growPool(growOp->pool(), 64 * MB));
+  // This makes sure nonReclaimTask gets picked as the victim during
+  // handleOOM().
+  auto growTask = addTask(328 * MB);
+  auto* growOp = growTask->addMemoryOp(false);
+  auto* bufGrow1 = growOp->allocate(64 * MB);
+  auto* bufGrow2 = growOp->allocate(128 * MB);
   ASSERT_NE(nonReclaimTask->error(), nullptr);
   try {
     std::rethrow_exception(nonReclaimTask->error());
   } catch (const VeloxRuntimeError& e) {
     ASSERT_EQ(velox::error_code::kMemAborted, e.errorCode());
     ASSERT_TRUE(
-        std::string(e.what()).find("usage 384.00MB peak 384.00MB") !=
+        std::string(e.what()).find("aborted when requestor") !=
         std::string::npos);
   } catch (...) {
     FAIL();
@@ -586,89 +755,1278 @@ TEST_F(MockSharedArbitrationTest, arbitrationFailsTask) {
   growOp->freeAll();
 }
 
-TEST_F(MockSharedArbitrationTest, shrinkMemory) {
-  std::vector<std::shared_ptr<MemoryPool>> pools;
-  ASSERT_THROW(arbitrator_->shrinkMemory(pools, 128), VeloxException);
-}
+TEST_F(MockSharedArbitrationTest, shrinkPools) {
+  const int64_t memoryCapacity = 32 << 20;
+  const int64_t reservedMemoryCapacity = 8 << 20;
+  const uint64_t memoryPoolInitCapacity = 8 << 20;
+  const uint64_t memoryPoolReserveCapacity = 2 << 20;
+  setupMemory(
+      memoryCapacity,
+      reservedMemoryCapacity,
+      memoryPoolInitCapacity,
+      memoryPoolReserveCapacity);
+
+  struct TestTask {
+    uint64_t capacity{0};
+    bool reclaimable{false};
+    uint64_t allocateBytes{0};
+
+    uint64_t expectedInitialCapacity{0};
+    bool expectedAbortAfterShrink{false};
 
-TEST_F(MockSharedArbitrationTest, singlePoolGrowWithoutArbitration) {
-  auto* memOp = addMemoryOp();
-  const int allocateSize = 1 * MB;
-  while (memOp->capacity() < kMemoryCapacity) {
-    memOp->allocate(allocateSize);
+    std::string debugString() const {
+      return fmt::format(
+          "capacity: {}, reclaimable: {}, allocateBytes: {}, expectedInitialCapacity: {}, expectedAbortAfterShrink: {}",
+          succinctBytes(capacity),
+          reclaimable,
+          succinctBytes(allocateBytes),
+          succinctBytes(expectedInitialCapacity),
+          expectedAbortAfterShrink);
+    }
+  };
+
+  struct {
+    std::vector<TestTask> testTasks;
+    uint64_t targetBytes;
+    uint64_t expectedFreedBytes;
+    uint64_t expectedFreeCapacity;
+    uint64_t expectedReservedFreeCapacity;
+    bool allowSpill;
+    bool allowAbort;
+
+    std::string debugString() const {
+      std::stringstream tasksOss;
+      for (const auto& testTask : testTasks) {
+        tasksOss << "[";
+        tasksOss << testTask.debugString();
+        tasksOss << "], \n";
+      }
+      return fmt::format(
+          "testTasks: \n[{}], \ntargetBytes: {}, \nexpectedFreedBytes: {}, "
+          "\nexpectedFreeCapacity: {}, \nexpectedReservedFreeCapacity: {}, \n"
+          "allowSpill: {}, \nallowAbort: {}",
+          tasksOss.str(),
+          succinctBytes(targetBytes),
+          succinctBytes(expectedFreedBytes),
+          succinctBytes(expectedFreeCapacity),
+          succinctBytes(expectedReservedFreeCapacity),
+          allowSpill,
+          allowAbort);
+    }
+  } testSettings[] = {
+      {{{memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         false}},
+       0,
+       0,
+       6 << 20,
+       6 << 20,
+       true,
+       false},
+
+      {{{memoryPoolInitCapacity,
+         true,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         false}},
+       0,
+       8 << 20,
+       14 << 20,
+       reservedMemoryCapacity,
+       true,
+       false},
+
+      {{{memoryPoolInitCapacity,
+         true,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         false}},
+       0,
+       0,
+       6 << 20,
+       6 << 20,
+       false,
+       false},
+
+      {{{memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         false}},
+       0,
+       0,
+       6 << 20,
+       6 << 20,
+       true,
+       false},
+
+      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, true}},
+       0,
+       26 << 20,
+       memoryCapacity,
+       reservedMemoryCapacity,
+       false,
+       true},
+
+      {{{memoryPoolInitCapacity,
+         true,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         true}},
+       0,
+       26 << 20,
+       memoryCapacity,
+       reservedMemoryCapacity,
+       true,
+       true},
+
+      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
+       16 << 20,
+       0,
+       6 << 20,
+       6 << 20,
+       false,
+       false},
+
+      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 1 << 10, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, false, 1 << 10, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
+       16 << 20,
+       16 << 20,
+       22 << 20,
+       reservedMemoryCapacity,
+       true,
+       true},
+
+      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 1 << 10, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, false, 1 << 10, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
+       14 << 20,
+       16 << 20,
+       22 << 20,
+       reservedMemoryCapacity,
+       true,
+       true},
+
+      {{{memoryPoolInitCapacity,
+         true,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         false}},
+       12 << 20,
+       12 << 20,
+       18 << 20,
+       reservedMemoryCapacity,
+       true,
+       false},
+
+      {{{memoryPoolInitCapacity,
+         true,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         true},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         true},
+        {memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         true},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         false}},
+       24 << 20,
+       24 << 20,
+       30 << 20,
+       reservedMemoryCapacity,
+       false,
+       true},
+
+      {{{memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         false,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         false}},
+       14 << 20,
+       0,
+       6 << 20,
+       6 << 20,
+       true,
+       false},
+
+      {{{memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         false,
+         memoryPoolInitCapacity,
+         memoryPoolInitCapacity,
+         false},
+        {memoryPoolInitCapacity,
+         true,
+         memoryPoolReserveCapacity,
+         memoryPoolReserveCapacity,
+         false}},
+       14 << 20,
+       0,
+       6 << 20,
+       6 << 20,
+       true,
+       false}};
+
+  struct MockTaskContainer {
+    std::shared_ptr<MockTask> task;
+    MockMemoryOperator* op;
+    TestTask testTask;
+  };
+
+  std::function<void(MockTask*, bool)> checkTaskException =
+      [](MockTask* task, bool expectedAbort) {
+        if (!expectedAbort) {
+          ASSERT_EQ(task->error(), nullptr);
+          return;
+        }
+        ASSERT_NE(task->error(), nullptr);
+        VELOX_ASSERT_THROW(
+            std::rethrow_exception(task->error()),
+            "Memory pool aborted to reclaim used memory, current usage");
+      };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::vector<MockTaskContainer> taskContainers;
+    for (const auto& testTask : testData.testTasks) {
+      auto task = addTask(testTask.capacity);
+      auto* op = addMemoryOp(task, testTask.reclaimable);
+      ASSERT_EQ(op->capacity(), testTask.expectedInitialCapacity);
+      if (testTask.allocateBytes != 0) {
+        op->allocate(testTask.allocateBytes);
+      }
+      ASSERT_LE(op->capacity(), testTask.capacity);
+      taskContainers.push_back({task, op, testTask});
+    }
+
+    ASSERT_EQ(
+        manager_->shrinkPools(
+            testData.targetBytes, testData.allowSpill, testData.allowAbort),
+        testData.expectedFreedBytes);
+
+    for (const auto& taskContainer : taskContainers) {
+      checkTaskException(
+          taskContainer.task.get(),
+          taskContainer.testTask.expectedAbortAfterShrink);
+    }
+
+    uint64_t totalCapacity{0};
+    for (const auto& taskContainer : taskContainers) {
+      totalCapacity += taskContainer.task->capacity();
+    }
+    ASSERT_EQ(
+        arbitrator_->stats().freeCapacityBytes, testData.expectedFreeCapacity);
+    ASSERT_EQ(
+        arbitrator_->stats().freeReservedCapacityBytes,
+        testData.expectedReservedFreeCapacity);
+    ASSERT_EQ(
+        totalCapacity + arbitrator_->stats().freeCapacityBytes,
+        arbitrator_->capacity());
   }
+}
 
-  verifyArbitratorStats(
-      arbitrator_->stats(),
-      kMemoryCapacity,
+// This test verifies local arbitration runs from the same query has to wait for
+// serial execution mode.
+DEBUG_ONLY_TEST_F(
+    MockSharedArbitrationTest,
+    localArbitrationRunsFromSameQuery) {
+  const int64_t memoryCapacity = 512 << 20;
+  const uint64_t memoryPoolInitCapacity = memoryCapacity / 4;
+  setupMemory(memoryCapacity, 0, memoryPoolInitCapacity, 0);
+  auto runTask = addTask(memoryCapacity);
+  auto* runPool = runTask->addMemoryOp(true);
+  auto* waitPool = runTask->addMemoryOp(true);
+
+  std::atomic_bool allocationWaitFlag{true};
+  folly::EventCount allocationWait;
+  std::atomic_bool localArbitrationWaitFlag{true};
+  folly::EventCount localArbitrationWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::runLocalArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unused*/) {
+            if (!allocationWaitFlag.exchange(false)) {
+              return;
+            }
+            allocationWait.notifyAll();
+            localArbitrationWait.await(
+                [&]() { return !localArbitrationWaitFlag.load(); });
+          })));
+
+  std::atomic_int allocationCount{0};
+  auto runThread = std::thread([&]() {
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    runPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocationCount;
+  });
+
+  auto waitThread = std::thread([&]() {
+    allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    waitPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationLockWaitWallNanos]
+            .count,
+        1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kLocalArbitrationLockWaitWallNanos].sum,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].sum, 1);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocationCount;
+  });
+
+  allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+  std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
+  ASSERT_EQ(allocationCount, 0);
+
+  localArbitrationWaitFlag = false;
+  localArbitrationWait.notifyAll();
+
+  runThread.join();
+  waitThread.join();
+  ASSERT_EQ(allocationCount, 2);
+}
+
+// This test verifies local arbitration runs from different queries don't have
+// to block waiting each other.
+DEBUG_ONLY_TEST_F(
+    MockSharedArbitrationTest,
+    localArbitrationRunsFromDifferentQueries) {
+  const int64_t memoryCapacity = 512 << 20;
+  const uint64_t memoryPoolInitCapacity = memoryCapacity / 4;
+  setupMemory(
+      memoryCapacity,
+      0,
+      memoryPoolInitCapacity,
+      0,
+      0,
+      kFastExponentialGrowthCapacityLimit,
+      kSlowCapacityGrowPct,
       0,
-      (kMemoryCapacity - kMemoryPoolInitCapacity) / kMemoryPoolTransferCapacity,
-      (kMemoryCapacity - kMemoryPoolInitCapacity) /
-          kMemoryPoolTransferCapacity);
+      0);
+  auto runTask = addTask(memoryCapacity);
+  auto* runPool = runTask->addMemoryOp(true);
+  auto waitTask = addTask(memoryCapacity);
+  auto* waitPool = waitTask->addMemoryOp(true);
+
+  std::atomic_bool allocationWaitFlag{true};
+  folly::EventCount allocationWait;
+  std::atomic_bool localArbitrationWaitFlag{true};
+  folly::EventCount localArbitrationWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::runLocalArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unused*/) {
+            if (!allocationWaitFlag.exchange(false)) {
+              return;
+            }
+            allocationWait.notifyAll();
+            localArbitrationWait.await(
+                [&]() { return !localArbitrationWaitFlag.load(); });
+          })));
 
-  verifyReclaimerStats(
-      memOp->reclaimer()->stats(),
+  std::atomic_int allocationCount{0};
+  auto runThread = std::thread([&]() {
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    runPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocationCount;
+  });
+
+  auto waitThread = std::thread([&]() {
+    allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    waitPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocationCount;
+  });
+
+  allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+  waitThread.join();
+  ASSERT_EQ(allocationCount, 1);
+
+  localArbitrationWaitFlag = false;
+  localArbitrationWait.notifyAll();
+
+  runThread.join();
+  ASSERT_EQ(allocationCount, 2);
+}
+
+// This test verifies local arbitration runs can run in parallel with free
+// memory reclamation.
+DEBUG_ONLY_TEST_F(
+    MockSharedArbitrationTest,
+    localArbitrationRunsWithFreeMemoryReclamation) {
+  const int64_t memoryCapacity = 512 << 20;
+  const uint64_t memoryPoolInitCapacity = memoryCapacity / 4;
+  setupMemory(
+      memoryCapacity,
+      0,
+      memoryPoolInitCapacity,
       0,
-      (kMemoryCapacity - kMemoryPoolInitCapacity) /
-          kMemoryPoolTransferCapacity);
+      0,
+      kFastExponentialGrowthCapacityLimit,
+      kSlowCapacityGrowPct,
+      0,
+      0);
+  auto runTask = addTask(memoryCapacity);
+  auto* runPool = runTask->addMemoryOp(true);
+  auto waitTask = addTask(memoryCapacity);
+  auto* waitPool = waitTask->addMemoryOp(true);
+  auto reclaimedTask = addTask(memoryCapacity);
+  auto* reclaimedPool = reclaimedTask->addMemoryOp(true);
+  reclaimedPool->allocate(memoryCapacity / 4);
+  reclaimedPool->allocate(memoryCapacity / 4);
+  reclaimedPool->freeAll();
+
+  std::atomic_bool allocationWaitFlag{true};
+  folly::EventCount allocationWait;
+  std::atomic_bool localArbitrationWaitFlag{true};
+  folly::EventCount localArbitrationWait;
+  std::atomic_int allocationCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::runLocalArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unused*/) {
+            if (!allocationWaitFlag.exchange(false)) {
+              return;
+            }
+            allocationWait.notifyAll();
+            while (allocationCount != 1) {
+              std::this_thread::sleep_for(
+                  std::chrono::milliseconds(200)); // NOLINT
+            }
+          })));
 
-  clearTasks();
-  verifyArbitratorStats(
-      arbitrator_->stats(),
-      kMemoryCapacity,
-      kMemoryCapacity,
-      (kMemoryCapacity - kMemoryPoolInitCapacity) / kMemoryPoolTransferCapacity,
-      (kMemoryCapacity - kMemoryPoolInitCapacity) /
-          kMemoryPoolTransferCapacity);
+  auto runThread = std::thread([&]() {
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    runPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocationCount;
+  });
+
+  auto waitThread = std::thread([&]() {
+    allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    waitPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationLockWaitWallNanos]
+            .count,
+        1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kLocalArbitrationLockWaitWallNanos].sum,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocationCount;
+  });
+
+  allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+  waitThread.join();
+  ASSERT_EQ(allocationCount, 1);
+  runThread.join();
+  ASSERT_EQ(allocationCount, 2);
+}
+
+// This test verifies local arbitration run can't reclaim free memory from
+// memory pool which is also under memory arbitration.
+DEBUG_ONLY_TEST_F(
+    MockSharedArbitrationTest,
+    localArbitrationRunFreeMemoryReclamationCheck) {
+  const int64_t memoryCapacity = 512 << 20;
+  const uint64_t memoryPoolInitCapacity = memoryCapacity / 4;
+  setupMemory(memoryCapacity, 0, memoryPoolInitCapacity, 0);
+  auto runTask = addTask(memoryCapacity);
+  auto* runPool = runTask->addMemoryOp(true);
+  runPool->allocate(memoryCapacity / 4);
+  runPool->allocate(memoryCapacity / 4);
+  auto waitTask = addTask(memoryCapacity);
+  auto* waitPool = waitTask->addMemoryOp(true);
+  waitPool->allocate(memoryCapacity / 4);
+
+  std::atomic_bool allocationWaitFlag{true};
+  folly::EventCount allocationWait;
+  std::atomic_bool localArbitrationWaitFlag{true};
+  folly::EventCount localArbitrationWait;
+  std::atomic_int allocationCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::runLocalArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unused*/) {
+            if (!allocationWaitFlag.exchange(false)) {
+              return;
+            }
+            allocationWait.notifyAll();
+
+            localArbitrationWait.await(
+                [&]() { return !localArbitrationWaitFlag.load(); });
+          })));
+
+  auto runThread = std::thread([&]() {
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    runPool->allocate(memoryCapacity / 4);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocationCount;
+  });
+
+  auto waitThread = std::thread([&]() {
+    allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    waitPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].sum, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos].sum,
+        0);
+    ++allocationCount;
+  });
+
+  allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+  std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
+  ASSERT_EQ(allocationCount, 0);
+
+  localArbitrationWaitFlag = false;
+  localArbitrationWait.notifyAll();
+
+  runThread.join();
+  waitThread.join();
+  ASSERT_EQ(allocationCount, 2);
+  ASSERT_EQ(runTask->capacity(), memoryCapacity / 4);
+  ASSERT_EQ(waitTask->capacity(), memoryCapacity / 4 + memoryCapacity / 2);
+}
+
+DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, multipleGlobalRuns) {
+  const int64_t memoryCapacity = 512 << 20;
+  const uint64_t memoryPoolInitCapacity = memoryCapacity / 2;
+  setupMemory(memoryCapacity, 0, memoryPoolInitCapacity, 0);
+  auto runTask = addTask(memoryCapacity);
+  auto* runPool = runTask->addMemoryOp(true);
+  runPool->allocate(memoryCapacity / 2);
+  auto waitTask = addTask(memoryCapacity);
+  auto* waitPool = waitTask->addMemoryOp(true);
+  waitPool->allocate(memoryCapacity / 2);
+
+  std::atomic_bool allocationWaitFlag{true};
+  folly::EventCount allocationWait;
+
+  std::atomic_bool globalArbitrationWaitFlag{true};
+  folly::EventCount globalArbitrationWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::runGlobalArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unused*/) {
+            if (!allocationWaitFlag.exchange(false)) {
+              return;
+            }
+            allocationWait.notifyAll();
+            globalArbitrationWait.await(
+                [&]() { return !globalArbitrationWaitFlag.load(); });
+          })));
+
+  std::atomic_int allocations{0};
+  auto waitThread = std::thread([&]() {
+    allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    waitPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].sum, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos].sum,
+        0);
+    ++allocations;
+  });
+
+  auto runThread = std::thread([&]() {
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    runPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].sum, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ++allocations;
+  });
+
+  allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+  std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
+  ASSERT_EQ(allocations, 0);
+
+  globalArbitrationWaitFlag = false;
+  globalArbitrationWait.notifyAll();
+
+  runThread.join();
+  waitThread.join();
+  ASSERT_EQ(allocations, 2);
+  ASSERT_EQ(runTask->capacity(), memoryCapacity / 2);
+  ASSERT_EQ(waitTask->capacity(), memoryCapacity / 2);
+}
+
+DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, globalArbitrationEnableCheck) {
+  for (bool globalArbitrationEnabled : {false, true}) {
+    SCOPED_TRACE(
+        fmt::format("globalArbitrationEnabled: {}", globalArbitrationEnabled));
+    const int64_t memoryCapacity = 512 << 20;
+    const uint64_t memoryPoolInitCapacity = memoryCapacity / 2;
+    setupMemory(
+        memoryCapacity,
+        0,
+        memoryPoolInitCapacity,
+        0,
+        0,
+        kFastExponentialGrowthCapacityLimit,
+        kSlowCapacityGrowPct,
+        kMemoryPoolMinFreeCapacity,
+        kMemoryPoolMinFreeCapacityPct,
+        nullptr,
+        globalArbitrationEnabled);
+
+    auto reclaimedTask = addTask(memoryCapacity);
+    auto* reclaimedPool = reclaimedTask->addMemoryOp(true);
+    reclaimedPool->allocate(memoryCapacity / 2);
+    auto requestTask = addTask(memoryCapacity);
+    auto* requestPool = requestTask->addMemoryOp(false);
+    requestPool->allocate(memoryCapacity / 2);
+    if (globalArbitrationEnabled) {
+      requestPool->allocate(memoryCapacity / 2);
+    } else {
+      VELOX_ASSERT_THROW(
+          requestPool->allocate(memoryCapacity / 2),
+          "Exceeded memory pool cap");
+    }
+  }
+}
+
+// This test verifies when a global arbitration is running, the local
+// arbitration run has to wait for the current running global arbitration run
+// to complete.
+DEBUG_ONLY_TEST_F(
+    MockSharedArbitrationTest,
+    localArbitrationWaitForGlobalArbitration) {
+  const int64_t memoryCapacity = 512 << 20;
+  const uint64_t memoryPoolInitCapacity = memoryCapacity / 2;
+  setupMemory(
+      memoryCapacity,
+      0,
+      memoryPoolInitCapacity,
+      0,
+      0,
+      kFastExponentialGrowthCapacityLimit,
+      kSlowCapacityGrowPct,
+      0,
+      0);
+  auto runTask = addTask(memoryCapacity);
+  auto* runPool = runTask->addMemoryOp(true);
+  runPool->allocate(memoryCapacity / 2);
+  auto waitTask = addTask(memoryCapacity);
+  auto* waitPool = waitTask->addMemoryOp(true);
+  waitPool->allocate(memoryCapacity / 4);
+
+  std::atomic_bool allocationWaitFlag{true};
+  folly::EventCount allocationWait;
+
+  std::atomic_bool globalArbitrationWaitFlag{true};
+  folly::EventCount globalArbitrationWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::runGlobalArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unused*/) {
+            if (!allocationWaitFlag.exchange(false)) {
+              return;
+            }
+            allocationWait.notifyAll();
+            globalArbitrationWait.await(
+                [&]() { return !globalArbitrationWaitFlag.load(); });
+          })));
+
+  std::atomic_int allocations{0};
+  auto waitThread = std::thread([&]() {
+    allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    waitPool->allocate(memoryCapacity / 4);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocations;
+  });
+
+  auto runThread = std::thread([&]() {
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    runPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].sum, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ++allocations;
+  });
+
+  allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+  std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
+  ASSERT_EQ(allocations, 0);
+
+  globalArbitrationWaitFlag = false;
+  globalArbitrationWait.notifyAll();
+
+  runThread.join();
+  waitThread.join();
+  ASSERT_EQ(allocations, 2);
+  ASSERT_EQ(runTask->capacity(), memoryCapacity / 2);
+  ASSERT_EQ(waitTask->capacity(), memoryCapacity / 2);
+}
+
+// This test verifies when a local arbitration is running, the global
+// arbitration run have to wait for the current running global arbitration run
+// to complete.
+DEBUG_ONLY_TEST_F(
+    MockSharedArbitrationTest,
+    globalArbitrationWaitForLocalArbitration) {
+  const int64_t memoryCapacity = 512 << 20;
+  const uint64_t memoryPoolInitCapacity = memoryCapacity / 4;
+  setupMemory(memoryCapacity, 0, memoryPoolInitCapacity, 0);
+  auto runTask = addTask(memoryCapacity / 2);
+  auto* runPool = runTask->addMemoryOp(true);
+  runPool->allocate(memoryCapacity / 4);
+  auto waitTask = addTask(memoryCapacity);
+  auto* waitPool = waitTask->addMemoryOp(true);
+  waitPool->allocate(memoryCapacity / 4);
+  waitPool->allocate(memoryCapacity / 4);
+
+  std::atomic_bool allocationWaitFlag{true};
+  folly::EventCount allocationWait;
+  std::atomic_bool localArbitrationWaitFlag{true};
+  folly::EventCount localArbitrationWait;
+  std::atomic_int allocationCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::runLocalArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unused*/) {
+            if (!allocationWaitFlag.exchange(false)) {
+              return;
+            }
+            allocationWait.notifyAll();
+
+            localArbitrationWait.await(
+                [&]() { return !localArbitrationWaitFlag.load(); });
+          })));
+
+  auto runThread = std::thread([&]() {
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    runPool->allocate(memoryCapacity / 4);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        0);
+    ++allocationCount;
+  });
+
+  auto waitThread = std::thread([&]() {
+    allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+    std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+    auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
+    setThreadLocalRunTimeStatWriter(statsWriter.get());
+    waitPool->allocate(memoryCapacity / 2);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kLocalArbitrationQueueWallNanos].count,
+        0);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationCount].count, 1);
+    ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
+    ASSERT_EQ(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos]
+            .count,
+        1);
+    ASSERT_GT(
+        runtimeStats[SharedArbitrator::kGlobalArbitrationLockWaitWallNanos].sum,
+        0);
+    ++allocationCount;
+  });
+
+  allocationWait.await([&]() { return !allocationWaitFlag.load(); });
+  std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
+  ASSERT_EQ(allocationCount, 0);
+
+  localArbitrationWaitFlag = false;
+  localArbitrationWait.notifyAll();
+
+  runThread.join();
+  waitThread.join();
+  ASSERT_EQ(allocationCount, 2);
+  ASSERT_EQ(runTask->capacity(), memoryCapacity / 2);
+  ASSERT_EQ(waitTask->capacity(), memoryCapacity / 2);
+}
+
+TEST_F(MockSharedArbitrationTest, singlePoolShrinkWithoutArbitration) {
+  const int64_t memoryCapacity = 512 * MB;
+  struct TestParam {
+    uint64_t memoryPoolReservedBytes;
+    uint64_t memoryPoolMinFreeCapacity;
+    double memoryPoolMinFreeCapacityPct;
+    uint64_t requestBytes;
+    bool expectThrow;
+    uint64_t expectedCapacity;
+    std::string debugString() const {
+      return fmt::format(
+          "memoryPoolReservedBytes {}, "
+          "memoryPoolMinFreeCapacity {}, "
+          "memoryPoolMinFreeCapacityPct {}, "
+          "requestBytes {}, ",
+          succinctBytes(memoryPoolReservedBytes),
+          succinctBytes(memoryPoolMinFreeCapacity),
+          memoryPoolMinFreeCapacityPct,
+          succinctBytes(requestBytes));
+    }
+  } testParams[] = {
+      {0, 128 * MB, 0, 256 * MB, true, 0},
+      {0, 0, 0.1, 256 * MB, true, 0},
+      {256 * MB, 128 * MB, 0.5, 256 * MB, false, 384 * MB},
+      {256 * MB, 128 * MB, 0.125, 256 * MB, false, 320 * MB},
+      {0, 128 * MB, 0.25, 0 * MB, false, 0},
+      {256 * MB, 128 * MB, 0.125, 0 * MB, false, 256 * MB},
+      {256 * MB, 128 * MB, 0.125, 512 * MB, false, 320 * MB}};
+
+  for (const auto& testParam : testParams) {
+    SCOPED_TRACE(testParam.debugString());
+    if (testParam.expectThrow) {
+      VELOX_ASSERT_THROW(
+          setupMemory(
+              memoryCapacity,
+              0,
+              memoryCapacity,
+              0,
+              0,
+              0,
+              0,
+              testParam.memoryPoolMinFreeCapacity,
+              testParam.memoryPoolMinFreeCapacityPct),
+          "both need to be set (non-zero) at the same time to enable shrink "
+          "capacity adjustment.");
+      continue;
+    } else {
+      setupMemory(
+          memoryCapacity,
+          0,
+          memoryCapacity,
+          0,
+          0,
+          0,
+          0,
+          testParam.memoryPoolMinFreeCapacity,
+          testParam.memoryPoolMinFreeCapacityPct);
+    }
+
+    auto* memOp = addMemoryOp();
+    memOp->allocate(testParam.memoryPoolReservedBytes);
+
+    ASSERT_EQ(
+        memOp->pool()->reservedBytes(), testParam.memoryPoolReservedBytes);
+    arbitrator_->shrinkCapacity(memOp->pool(), testParam.requestBytes);
+    ASSERT_EQ(memOp->pool()->capacity(), testParam.expectedCapacity);
+    clearTasks();
+  }
+}
+
+TEST_F(MockSharedArbitrationTest, singlePoolGrowWithoutArbitration) {
+  const int64_t memoryCapacity = 512 << 20;
+  const uint64_t memoryPoolInitCapacity = 32 << 20;
+  struct TestParam {
+    uint64_t fastExponentialGrowthCapacityLimit;
+    double slowCapacityGrowPct;
+    std::string debugString() const {
+      return fmt::format(
+          "fastExponentialGrowthCapacityLimit {}, "
+          "slowCapacityGrowPct {}",
+          succinctBytes(fastExponentialGrowthCapacityLimit),
+          slowCapacityGrowPct);
+    }
+  };
+
+  // Try to make each test allocation larger than the largest memory pool
+  // quantization(8MB) to not have noise.
+  std::vector<TestParam> testParams{
+      {128 << 20, 0.1},
+      {128 << 20, 0.1},
+      {128 << 20, 0.5},
+  };
+
+  for (const auto& testParam : testParams) {
+    SCOPED_TRACE(testParam.debugString());
+    setupMemory(
+        memoryCapacity,
+        0,
+        memoryPoolInitCapacity,
+        0,
+        0,
+        testParam.fastExponentialGrowthCapacityLimit,
+        testParam.slowCapacityGrowPct);
+
+    auto* memOp = addMemoryOp();
+    const int allocateSize = 1 * MB;
+    while (memOp->capacity() < memoryCapacity) {
+      memOp->allocate(allocateSize);
+    }
+
+    // Computations of expected number of requests depending on capacity grow
+    // strategy (fast path or not).
+    uint64_t expectedNumRequests{0};
+
+    uint64_t simulateCapacity = memoryPoolInitCapacity;
+    while (simulateCapacity * 2 <=
+           testParam.fastExponentialGrowthCapacityLimit) {
+      simulateCapacity += simulateCapacity;
+      expectedNumRequests++;
+    }
+    while (simulateCapacity < memoryCapacity) {
+      auto growth = static_cast<uint64_t>(
+          simulateCapacity * testParam.slowCapacityGrowPct);
+      simulateCapacity += growth;
+      expectedNumRequests++;
+    }
+
+    verifyArbitratorStats(
+        arbitrator_->stats(), memoryCapacity, 0, 0, expectedNumRequests);
+
+    verifyReclaimerStats(memOp->reclaimer()->stats(), 0, expectedNumRequests);
+
+    clearTasks();
+    verifyArbitratorStats(
+        arbitrator_->stats(),
+        memoryCapacity,
+        memoryCapacity,
+        0,
+        expectedNumRequests);
+  }
 }
 
 TEST_F(MockSharedArbitrationTest, maxCapacityReserve) {
   const int memCapacity = 256 * MB;
   const int minPoolCapacity = 32 * MB;
-  setupMemory(memCapacity, minPoolCapacity);
   struct {
-    uint64_t maxCapacity;
-    uint64_t expectedInitialCapacity;
+    uint64_t memCapacity;
+    uint64_t reservedCapacity;
+    uint64_t poolInitCapacity;
+    uint64_t poolReservedCapacity;
+    uint64_t poolMaxCapacity;
+    uint64_t expectedPoolInitCapacity;
 
     std::string debugString() const {
       return fmt::format(
-          "maxCapacity {}, expectedInitialCapacity {}",
-          succinctBytes(maxCapacity),
-          succinctBytes(expectedInitialCapacity));
+          "memCapacity {}, reservedCapacity {}, poolInitCapacity {}, poolReservedCapacity {}, poolMaxCapacity {}, expectedPoolInitCapacity {}",
+          succinctBytes(memCapacity),
+          succinctBytes(reservedCapacity),
+          succinctBytes(poolInitCapacity),
+          succinctBytes(poolReservedCapacity),
+          succinctBytes(poolMaxCapacity),
+          succinctBytes(expectedPoolInitCapacity));
     }
   } testSettings[] = {
-      {minPoolCapacity, minPoolCapacity},
-      {minPoolCapacity / 2, minPoolCapacity / 2},
-      {minPoolCapacity * 2, minPoolCapacity}};
+      {256 << 20, 256 << 20, 128 << 20, 64 << 20, 256 << 20, 64 << 20},
+      {256 << 20, 0, 128 << 20, 64 << 20, 256 << 20, 128 << 20},
+      {256 << 20, 0, 512 << 20, 64 << 20, 256 << 20, 256 << 20},
+      {256 << 20, 0, 128 << 20, 64 << 20, 256 << 20, 128 << 20},
+      {256 << 20, 128 << 20, 128 << 20, 64 << 20, 256 << 20, 128 << 20},
+      {256 << 20, 128 << 20, 256 << 20, 64 << 20, 256 << 20, 128 << 20},
+      {256 << 20, 128 << 20, 256 << 20, 256 << 20, 256 << 20, 256 << 20},
+      {256 << 20, 128 << 20, 256 << 20, 256 << 20, 128 << 20, 128 << 20}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto task = addTask(testData.maxCapacity);
-    ASSERT_EQ(task->pool()->maxCapacity(), testData.maxCapacity);
-    ASSERT_EQ(task->pool()->capacity(), testData.expectedInitialCapacity);
+    setupMemory(
+        testData.memCapacity,
+        testData.reservedCapacity,
+        testData.poolInitCapacity,
+        testData.poolReservedCapacity);
+    auto task = addTask(testData.poolMaxCapacity);
+    ASSERT_EQ(task->pool()->maxCapacity(), testData.poolMaxCapacity);
+    ASSERT_EQ(task->pool()->capacity(), testData.expectedPoolInitCapacity);
   }
 }
 
 TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
   const int memCapacity = 256 * MB;
-  const int minPoolCapacity = 8 * MB;
+  const int poolInitCapacity = 8 * MB;
   struct {
-    uint64_t maxCapacity;
+    uint64_t poolMaxCapacity;
     bool isReclaimable;
     uint64_t allocatedBytes;
     uint64_t requestBytes;
     bool hasOtherTask;
+    uint64_t otherAllocatedBytes;
     bool expectedSuccess;
     bool expectedReclaimFromOther;
 
     std::string debugString() const {
       return fmt::format(
-          "maxCapacity {} isReclaimable {} allocatedBytes {} requestBytes {} hasOtherTask {} expectedSuccess {} expectedReclaimFromOther {}",
-          succinctBytes(maxCapacity),
+          "poolMaxCapacity {} isReclaimable {} allocatedBytes {} requestBytes {} hasOtherTask {} otherAllocatedBytes {} expectedSuccess {} expectedReclaimFromOther {}",
+          succinctBytes(poolMaxCapacity),
           isReclaimable,
           succinctBytes(allocatedBytes),
           succinctBytes(requestBytes),
           hasOtherTask,
+          succinctBytes(otherAllocatedBytes),
           expectedSuccess,
           expectedReclaimFromOther);
     }
@@ -678,6 +2036,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 4,
        memCapacity / 2,
        false,
+       0,
        true,
        false},
       {memCapacity / 2,
@@ -685,6 +2044,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 4,
        memCapacity / 8,
        false,
+       0,
        true,
        false},
       {memCapacity / 2,
@@ -692,6 +2052,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 4,
        memCapacity / 2,
        false,
+       0,
        true,
        false},
       {memCapacity / 2,
@@ -699,6 +2060,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 2,
        memCapacity / 4,
        false,
+       0,
        true,
        false},
       {memCapacity / 2,
@@ -706,6 +2068,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 4,
        memCapacity / 2,
        false,
+       0,
        false,
        false},
       {memCapacity / 2,
@@ -713,6 +2076,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 2,
        memCapacity / 4,
        false,
+       0,
        false,
        false},
       {memCapacity / 2,
@@ -720,6 +2084,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 4,
        memCapacity / 2,
        true,
+       memCapacity - memCapacity / 4,
        true,
        true},
       {memCapacity / 2,
@@ -727,6 +2092,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 4,
        memCapacity / 8,
        true,
+       memCapacity - memCapacity / 4,
        true,
        true},
       {memCapacity / 2,
@@ -734,6 +2100,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 4,
        memCapacity / 2,
        true,
+       memCapacity - memCapacity / 4,
        true,
        true},
       {memCapacity / 2,
@@ -741,6 +2108,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 2,
        memCapacity / 4,
        true,
+       memCapacity - memCapacity / 2,
        true,
        false},
       {memCapacity / 2,
@@ -748,6 +2116,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 4,
        memCapacity / 2,
        true,
+       memCapacity - memCapacity / 4,
        false,
        false},
       {memCapacity / 2,
@@ -755,22 +2124,31 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
        memCapacity / 2,
        memCapacity / 4,
        false,
+       memCapacity - memCapacity / 2,
        false,
        false}};
-
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    setupMemory(memCapacity, minPoolCapacity);
+    setupMemory(
+        memCapacity,
+        0,
+        poolInitCapacity,
+        0,
+        0,
+        kFastExponentialGrowthCapacityLimit,
+        kSlowCapacityGrowPct,
+        0,
+        0);
 
-    auto requestor = addTask(testData.maxCapacity);
-    auto requestorOp = addMemoryOp(requestor, testData.isReclaimable);
+    auto requestor = addTask(testData.poolMaxCapacity);
+    auto* requestorOp = addMemoryOp(requestor, testData.isReclaimable);
     requestorOp->allocate(testData.allocatedBytes);
     std::shared_ptr<MockTask> other;
     MockMemoryOperator* otherOp;
     if (testData.hasOtherTask) {
       other = addTask();
       otherOp = addMemoryOp(other, true);
-      otherOp->allocate(memCapacity - testData.allocatedBytes);
+      otherOp->allocate(testData.otherAllocatedBytes);
     }
     const auto numRequests = arbitrator_->stats().numRequests;
     if (testData.expectedSuccess) {
@@ -778,7 +2156,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
     } else {
       VELOX_ASSERT_THROW(
           requestorOp->allocate(testData.requestBytes),
-          "Exceeded memory pool cap of");
+          "Exceeded memory pool capacity");
     }
     if (testData.expectedReclaimFromOther) {
       ASSERT_GT(otherOp->reclaimer()->stats().numReclaims, 0);
@@ -787,7 +2165,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
     }
     if (testData.expectedSuccess &&
         (((testData.allocatedBytes + testData.requestBytes) >
-          testData.maxCapacity) ||
+          testData.poolMaxCapacity) ||
          testData.hasOtherTask)) {
       ASSERT_GT(arbitrator_->stats().numReclaimedBytes, 0);
     } else {
@@ -809,7 +2187,9 @@ TEST_F(MockSharedArbitrationTest, ensureNodeMaxCapacity) {
 
     std::string debugString() const {
       return fmt::format(
-          "nodeCapacity {} poolMaxCapacity {} isReclaimable {} allocatedBytes {} requestBytes {} expectedSuccess {} expectedReclaimedBytes {}",
+          "nodeCapacity {} poolMaxCapacity {} isReclaimable {} "
+          "allocatedBytes {} requestBytes {} expectedSuccess {} "
+          "expectedReclaimedBytes {}",
           succinctBytes(nodeCapacity),
           succinctBytes(poolMaxCapacity),
           isReclaimable,
@@ -830,10 +2210,10 @@ TEST_F(MockSharedArbitrationTest, ensureNodeMaxCapacity) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    setupMemory(testData.nodeCapacity);
+    setupMemory(testData.nodeCapacity, 0, 0, 0);
 
     auto requestor = addTask(testData.poolMaxCapacity);
-    auto requestorOp = addMemoryOp(requestor, testData.isReclaimable);
+    auto* requestorOp = addMemoryOp(requestor, testData.isReclaimable);
     requestorOp->allocate(testData.allocatedBytes);
     const auto numRequests = arbitrator_->stats().numRequests;
     if (testData.expectedSuccess) {
@@ -855,70 +2235,88 @@ TEST_F(MockSharedArbitrationTest, ensureNodeMaxCapacity) {
 TEST_F(MockSharedArbitrationTest, failedArbitration) {
   const int memCapacity = 256 * MB;
   const int minPoolCapacity = 8 * MB;
-  setupMemory(memCapacity, minPoolCapacity);
-  auto reclaimableOp = addMemoryOp();
+  setupMemory(memCapacity, 0, minPoolCapacity, 0);
+  auto* reclaimableOp = addMemoryOp();
   ASSERT_EQ(reclaimableOp->capacity(), minPoolCapacity);
-  auto nonReclaimableOp = addMemoryOp(nullptr, false);
+  auto* nonReclaimableOp = addMemoryOp(nullptr, false);
   ASSERT_EQ(nonReclaimableOp->capacity(), minPoolCapacity);
-  auto arbitrateOp = addMemoryOp();
+  auto* arbitrateOp = addMemoryOp();
   ASSERT_EQ(arbitrateOp->capacity(), minPoolCapacity);
 
   reclaimableOp->allocate(minPoolCapacity);
   ASSERT_EQ(reclaimableOp->capacity(), minPoolCapacity);
   nonReclaimableOp->allocate(minPoolCapacity);
   ASSERT_EQ(nonReclaimableOp->capacity(), minPoolCapacity);
-  ASSERT_ANY_THROW(arbitrateOp->allocate(memCapacity));
+  VELOX_ASSERT_THROW(
+      arbitrateOp->allocate(memCapacity), "Exceeded memory pool cap");
   verifyReclaimerStats(nonReclaimableOp->reclaimer()->stats());
   verifyReclaimerStats(reclaimableOp->reclaimer()->stats(), 1);
-  verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 1, 1);
+  verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 0, 1);
   verifyArbitratorStats(
-      arbitrator_->stats(), memCapacity, 260046848, 1, 0, 1, 8388608, 8388608);
-  ASSERT_EQ(arbitrator_->stats().queueTimeUs, 0);
+      arbitrator_->stats(), memCapacity, 260046848, 0, 1, 1, 8388608, 8388608);
+  ASSERT_GE(arbitrator_->stats().queueTimeUs, 0);
 }
 
 TEST_F(MockSharedArbitrationTest, singlePoolGrowCapacityWithArbitration) {
-  std::vector<bool> isLeafReclaimables = {true, false};
+  const std::vector<bool> isLeafReclaimables = {true, false};
   for (const auto isLeafReclaimable : isLeafReclaimables) {
     SCOPED_TRACE(fmt::format("isLeafReclaimable {}", isLeafReclaimable));
     setupMemory();
     auto op = addMemoryOp(nullptr, isLeafReclaimable);
     const int allocateSize = MB;
-    while (op->pool()->currentBytes() < kMemoryCapacity) {
+    while (op->pool()->usedBytes() <
+           kMemoryCapacity - kReservedMemoryCapacity) {
       op->allocate(allocateSize);
     }
-    verifyArbitratorStats(arbitrator_->stats(), kMemoryCapacity, 0, 62, 62);
-    verifyReclaimerStats(op->reclaimer()->stats(), 0, 62);
+    verifyArbitratorStats(
+        arbitrator_->stats(),
+        kMemoryCapacity,
+        kReservedMemoryCapacity,
+        kReservedMemoryCapacity,
+        13);
+    verifyReclaimerStats(op->reclaimer()->stats(), 0, 13);
 
     if (!isLeafReclaimable) {
-      ASSERT_ANY_THROW(op->allocate(allocateSize));
+      VELOX_ASSERT_THROW(
+          op->allocate(allocateSize), "Exceeded memory pool cap");
       verifyArbitratorStats(
-          arbitrator_->stats(), kMemoryCapacity, 0, 63, 62, 1);
-      verifyReclaimerStats(op->reclaimer()->stats(), 1, 63);
+          arbitrator_->stats(),
+          kMemoryCapacity,
+          kReservedMemoryCapacity,
+          kReservedMemoryCapacity,
+          14,
+          1);
+      verifyReclaimerStats(op->reclaimer()->stats(), 0, 14);
       continue;
     }
 
     // Do more allocations to trigger arbitration.
-    for (int i = 0; i < kMemoryPoolTransferCapacity / allocateSize; ++i) {
-      op->allocate(allocateSize);
-    }
+    op->allocate(
+        op->pool()->capacity() - op->pool()->root()->reservedBytes() + MB);
     verifyArbitratorStats(
-        arbitrator_->stats(), kMemoryCapacity, 0, 63, 63, 0, 8388608);
-    verifyReclaimerStats(op->reclaimer()->stats(), 1, 63);
+        arbitrator_->stats(),
+        kMemoryCapacity,
+        kReservedMemoryCapacity,
+        kReservedMemoryCapacity,
+        14,
+        0,
+        8388608);
+    verifyReclaimerStats(op->reclaimer()->stats(), 1, 14);
 
     clearTasks();
     verifyArbitratorStats(
         arbitrator_->stats(),
         kMemoryCapacity,
         kMemoryCapacity,
-        63,
-        63,
+        kReservedMemoryCapacity,
+        14,
         0,
         8388608);
   }
 }
 
 TEST_F(MockSharedArbitrationTest, arbitrateWithCapacityShrink) {
-  std::vector<bool> isLeafReclaimables = {true, false};
+  const std::vector<bool> isLeafReclaimables = {true, false};
   for (const auto isLeafReclaimable : isLeafReclaimables) {
     SCOPED_TRACE(fmt::format("isLeafReclaimable {}", isLeafReclaimable));
     setupMemory();
@@ -932,7 +2330,7 @@ TEST_F(MockSharedArbitrationTest, arbitrateWithCapacityShrink) {
     ASSERT_GT(freeCapacity, 0);
     reclaimedOp->freeAll();
     ASSERT_GT(reclaimedOp->pool()->freeBytes(), 0);
-    ASSERT_EQ(reclaimedOp->pool()->currentBytes(), 0);
+    ASSERT_EQ(reclaimedOp->pool()->usedBytes(), 0);
     ASSERT_EQ(arbitrator_->stats().freeCapacityBytes, freeCapacity);
 
     auto* arbitrateOp = addMemoryOp(nullptr, isLeafReclaimable);
@@ -943,8 +2341,8 @@ TEST_F(MockSharedArbitrationTest, arbitrateWithCapacityShrink) {
     ASSERT_GT(arbitratorStats.numShrunkBytes, 0);
     ASSERT_EQ(arbitratorStats.numReclaimedBytes, 0);
 
-    verifyReclaimerStats(reclaimedOp->reclaimer()->stats(), 0, 11);
-    verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 0, 5);
+    verifyReclaimerStats(reclaimedOp->reclaimer()->stats(), 0, 8);
+    verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 0, 1);
 
     clearTasks();
   }
@@ -952,34 +2350,47 @@ TEST_F(MockSharedArbitrationTest, arbitrateWithCapacityShrink) {
 
 TEST_F(MockSharedArbitrationTest, arbitrateWithMemoryReclaim) {
   const uint64_t memoryCapacity = 256 * MB;
-  const uint64_t minPoolCapacity = 8 * MB;
+  const uint64_t reservedMemoryCapacity = 128 * MB;
+  const uint64_t initPoolCapacity = 8 * MB;
+  const uint64_t reservedPoolCapacity = 8 * MB;
   const std::vector<bool> isLeafReclaimables = {true, false};
   for (const auto isLeafReclaimable : isLeafReclaimables) {
     SCOPED_TRACE(fmt::format("isLeafReclaimable {}", isLeafReclaimable));
-    setupMemory(memoryCapacity, minPoolCapacity);
+    setupMemory(
+        memoryCapacity,
+        reservedMemoryCapacity,
+        initPoolCapacity,
+        reservedPoolCapacity);
     auto* reclaimedOp = addMemoryOp(nullptr, isLeafReclaimable);
     const int allocateSize = 8 * MB;
-    while (reclaimedOp->pool()->currentBytes() < memoryCapacity) {
+    while (reclaimedOp->pool()->usedBytes() <
+           memoryCapacity - reservedMemoryCapacity) {
       reclaimedOp->allocate(allocateSize);
     }
     auto* arbitrateOp = addMemoryOp();
     if (!isLeafReclaimable) {
       auto leafTask = tasks().front();
-      ASSERT_NO_THROW(arbitrateOp->allocate(allocateSize));
+      ASSERT_NO_THROW(arbitrateOp->allocate(reservedMemoryCapacity / 2));
+
       ASSERT_NE(leafTask->error(), nullptr);
       ASSERT_EQ(arbitrator_->stats().numFailures, 0);
       continue;
     }
-    arbitrateOp->allocate(allocateSize);
+    arbitrateOp->allocate(reservedMemoryCapacity / 2);
 
     verifyArbitratorStats(
-        arbitrator_->stats(), memoryCapacity, 0, 32, 32, 0, 8388608);
+        arbitrator_->stats(),
+        memoryCapacity,
+        kReservedMemoryCapacity - reservedPoolCapacity,
+        kReservedMemoryCapacity - reservedPoolCapacity,
+        10,
+        0,
+        58720256,
+        10559488);
 
-    verifyReclaimerStats(
-        arbitrateOp->reclaimer()->stats(), 0, 1, kMemoryPoolTransferCapacity);
+    verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 0, 1, 0);
 
-    verifyReclaimerStats(
-        reclaimedOp->reclaimer()->stats(), 1, 31, kMemoryPoolTransferCapacity);
+    verifyReclaimerStats(reclaimedOp->reclaimer()->stats(), 1, 9, 0);
     clearTasks();
   }
 }
@@ -989,29 +2400,34 @@ TEST_F(MockSharedArbitrationTest, arbitrateBySelfMemoryReclaim) {
   for (const auto isLeafReclaimable : isLeafReclaimables) {
     SCOPED_TRACE(fmt::format("isLeafReclaimable {}", isLeafReclaimable));
     const uint64_t memCapacity = 128 * MB;
-    setupMemory(memCapacity);
+    const uint64_t reservedCapacity = 8 * MB;
+    const uint64_t poolReservedCapacity = 4 * MB;
+    setupMemory(
+        memCapacity, reservedCapacity, reservedCapacity, poolReservedCapacity);
     std::shared_ptr<MockTask> task = addTask(kMemoryCapacity);
     auto* memOp = addMemoryOp(task, isLeafReclaimable);
     const int allocateSize = 8 * MB;
-    while (memOp->pool()->currentBytes() < memCapacity / 2) {
+    while (memOp->pool()->usedBytes() < memCapacity / 2) {
       memOp->allocate(allocateSize);
     }
-    ASSERT_EQ(memOp->pool()->freeBytes(), 0);
+    // Extra free bytes due to fast/slow grow strategy
+    ASSERT_EQ(memOp->pool()->freeBytes(), 14811136);
     const int oldNumRequests = arbitrator_->stats().numRequests;
     // Allocate a large chunk of memory to trigger arbitration.
     if (!isLeafReclaimable) {
-      ASSERT_ANY_THROW(memOp->allocate(memCapacity));
+      VELOX_ASSERT_THROW(
+          memOp->allocate(memCapacity), "Exceeded memory pool cap");
       ASSERT_EQ(oldNumRequests + 1, arbitrator_->stats().numRequests);
       ASSERT_EQ(arbitrator_->stats().numFailures, 1);
       continue;
     } else {
-      memOp->allocate(memCapacity);
+      memOp->allocate(memCapacity / 2);
       ASSERT_EQ(oldNumRequests + 1, arbitrator_->stats().numRequests);
       ASSERT_EQ(arbitrator_->stats().numFailures, 0);
-      ASSERT_EQ(arbitrator_->stats().numShrunkBytes, 0);
+      ASSERT_EQ(arbitrator_->stats().numShrunkBytes, 14811136);
       ASSERT_GT(arbitrator_->stats().numReclaimedBytes, 0);
     }
-    ASSERT_EQ(arbitrator_->stats().queueTimeUs, 0);
+    ASSERT_GE(arbitrator_->stats().queueTimeUs, 0);
   }
 }
 
@@ -1060,7 +2476,7 @@ TEST_F(MockSharedArbitrationTest, noAbortOnRequestWhenArbitrationFails) {
 
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, orderedArbitration) {
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::memory::SharedArbitrator::sortCandidatesByFreeCapacity",
+      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableFreeCapacity",
       std::function<void(const std::vector<SharedArbitrator::Candidate>*)>(
           ([&](const std::vector<SharedArbitrator::Candidate>* candidates) {
             for (int i = 1; i < candidates->size(); ++i) {
@@ -1069,7 +2485,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, orderedArbitration) {
             }
           })));
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableMemory",
+      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableUsedCapacity",
       std::function<void(const std::vector<SharedArbitrator::Candidate>*)>(
           ([&](const std::vector<SharedArbitrator::Candidate>* candidates) {
             for (int i = 1; i < candidates->size(); ++i) {
@@ -1078,11 +2494,14 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, orderedArbitration) {
                   (*candidates)[i - 1].reclaimableBytes);
             }
           })));
+
   folly::Random::DefaultGenerator rng;
   rng.seed(512);
   const uint64_t memCapacity = 512 * MB;
-  const uint64_t minPoolCapacity = 32 * MB;
-  const uint64_t minPoolCapacityTransferSize = 8 * MB;
+  const uint64_t reservedMemCapacity = 128 * MB;
+  const uint64_t initPoolCapacity = 32 * MB;
+  const uint64_t reservedPoolCapacity = 8 * MB;
+  const uint64_t baseAllocationSize = 8 * MB;
   const int numTasks = 8;
   struct {
     bool freeCapacity;
@@ -1097,147 +2516,43 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, orderedArbitration) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    setupMemory(memCapacity, minPoolCapacity, minPoolCapacityTransferSize);
+
+    setupMemory(
+        memCapacity,
+        reservedMemCapacity,
+        initPoolCapacity,
+        reservedPoolCapacity);
     std::vector<MockMemoryOperator*> memOps;
-    std::vector<uint64_t> memOpCapacities;
     for (int i = 0; i < numTasks; ++i) {
       auto* memOp = addMemoryOp();
+      ASSERT_GE(memOp->capacity(), reservedPoolCapacity);
       int allocationSize = testData.sameSize ? memCapacity / numTasks
-                                             : minPoolCapacity +
+                                             : baseAllocationSize +
               folly::Random::rand32(rng) %
-                  ((memCapacity / numTasks) - minPoolCapacity);
+                  ((memCapacity / numTasks) - baseAllocationSize);
       allocationSize = allocationSize / MB * MB;
       memOp->allocate(allocationSize);
       if (testData.freeCapacity) {
         memOp->freeAll();
-        ASSERT_EQ(memOp->pool()->currentBytes(), 0);
+        ASSERT_EQ(memOp->pool()->usedBytes(), 0);
       }
       memOps.push_back(memOp);
     }
 
     auto* arbitrateOp = addMemoryOp();
-    arbitrateOp->allocate(memCapacity);
+    arbitrateOp->allocate(memCapacity / 2);
     for (auto* memOp : memOps) {
-      ASSERT_EQ(memOp->capacity(), 0);
+      ASSERT_GE(memOp->capacity(), 0) << memOp->pool()->name();
     }
-    ASSERT_EQ(arbitrator_->stats().queueTimeUs, 0);
+    ASSERT_GE(arbitrator_->stats().queueTimeUs, 0);
     clearTasks();
   }
 }
 
-TEST_F(MockSharedArbitrationTest, poolCapacityTransferWithFreeCapacity) {
-  const uint64_t memCapacity = 512 * MB;
-  const uint64_t minPoolCapacity = 32 * MB;
-  const uint64_t minPoolCapacityTransferSize = 16 * MB;
-  setupMemory(memCapacity, minPoolCapacity, minPoolCapacityTransferSize);
-  auto* memOp = addMemoryOp();
-  ASSERT_EQ(memOp->capacity(), minPoolCapacity);
-  memOp->allocate(minPoolCapacity);
-  ASSERT_EQ(memOp->pool()->freeBytes(), 0);
-  const uint64_t allocationSize = 8 * MB;
-  uint64_t capacity = memOp->pool()->capacity();
-  while (capacity < memCapacity) {
-    memOp->allocate(allocationSize);
-    ASSERT_EQ(capacity + minPoolCapacityTransferSize, memOp->capacity());
-    while (memOp->pool()->freeBytes() > 0) {
-      memOp->allocate(allocationSize);
-    }
-    capacity = memOp->capacity();
-  }
-  const int expectedArbitrationRequests =
-      (memCapacity - minPoolCapacity) / minPoolCapacityTransferSize;
-  verifyReclaimerStats(
-      memOp->reclaimer()->stats(), 0, expectedArbitrationRequests);
-  verifyArbitratorStats(
-      arbitrator_->stats(),
-      memCapacity,
-      0,
-      expectedArbitrationRequests,
-      expectedArbitrationRequests);
-  ASSERT_EQ(arbitrator_->stats().queueTimeUs, 0);
-}
-
-TEST_F(MockSharedArbitrationTest, poolCapacityTransferSizeWithCapacityShrunk) {
-  const int numCandidateOps = 8;
-  const uint64_t minPoolCapacity = 64 * MB;
-  const uint64_t minPoolCapacityTransferSize = 32 * MB;
-  const uint64_t memCapacity = minPoolCapacity * numCandidateOps;
-  setupMemory(memCapacity, minPoolCapacity, minPoolCapacityTransferSize);
-  const int allocationSize = 8 * MB;
-  std::vector<MockMemoryOperator*> candidateOps;
-  for (int i = 0; i < numCandidateOps; ++i) {
-    candidateOps.push_back(addMemoryOp());
-    ASSERT_EQ(candidateOps.back()->capacity(), minPoolCapacity);
-    candidateOps.back()->allocate(allocationSize);
-    ASSERT_EQ(candidateOps.back()->capacity(), minPoolCapacity);
-    ASSERT_GT(candidateOps.back()->pool()->freeBytes(), 0);
-  }
-  auto* arbitrateOp = addMemoryOp();
-  ASSERT_EQ(arbitrateOp->capacity(), 0);
-  arbitrateOp->allocate(allocationSize);
-  ASSERT_EQ(arbitrateOp->capacity(), minPoolCapacityTransferSize);
-  verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 0, 1);
-  ASSERT_EQ(arbitrator_->stats().numShrunkBytes, minPoolCapacityTransferSize);
-  ASSERT_EQ(arbitrator_->stats().numReclaimedBytes, 0);
-  ASSERT_EQ(arbitrator_->stats().numRequests, 1);
-}
-
-TEST_F(MockSharedArbitrationTest, partialPoolCapacityTransferSize) {
-  const int numCandidateOps = 8;
-  const uint64_t minPoolCapacity = 64 * MB;
-  const uint64_t minPoolCapacityTransferSize = 32 * MB;
-  const uint64_t memCapacity = minPoolCapacity * numCandidateOps;
-  setupMemory(memCapacity, minPoolCapacity, minPoolCapacityTransferSize);
-  const int allocationSize = 8 * MB;
-  std::vector<MockMemoryOperator*> candidateOps;
-  for (int i = 0; i < numCandidateOps; ++i) {
-    candidateOps.push_back(addMemoryOp());
-    ASSERT_EQ(candidateOps.back()->capacity(), minPoolCapacity);
-    candidateOps.back()->allocate(allocationSize);
-    ASSERT_EQ(candidateOps.back()->capacity(), minPoolCapacity);
-    ASSERT_GT(candidateOps.back()->pool()->freeBytes(), 0);
-  }
-  auto* arbitrateOp = addMemoryOp();
-  ASSERT_EQ(arbitrateOp->capacity(), 0);
-  arbitrateOp->allocate(allocationSize);
-  ASSERT_EQ(arbitrateOp->capacity(), minPoolCapacityTransferSize);
-  verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 0, 1);
-  ASSERT_EQ(arbitrator_->stats().numShrunkBytes, minPoolCapacityTransferSize);
-  ASSERT_EQ(arbitrator_->stats().numReclaimedBytes, 0);
-  ASSERT_EQ(arbitrator_->stats().numRequests, 1);
-}
-
-TEST_F(MockSharedArbitrationTest, poolCapacityTransferSizeWithMemoryReclaim) {
-  const uint64_t memCapacity = 128 * MB;
-  const uint64_t minPoolCapacity = memCapacity;
-  const uint64_t minPoolCapacityTransferSize = 64 * MB;
-  setupMemory(memCapacity, minPoolCapacity, minPoolCapacityTransferSize);
-  auto* reclaimedOp = addMemoryOp();
-  ASSERT_EQ(reclaimedOp->capacity(), memCapacity);
-  const int allocationSize = 8 * MB;
-  std::vector<std::shared_ptr<MockMemoryOperator>> candidateOps;
-  for (int i = 0; i < memCapacity / allocationSize; ++i) {
-    reclaimedOp->allocate(allocationSize);
-  }
-  ASSERT_EQ(reclaimedOp->pool()->freeBytes(), 0);
-
-  auto* arbitrateOp = addMemoryOp();
-  ASSERT_EQ(arbitrateOp->capacity(), 0);
-  arbitrateOp->allocate(allocationSize);
-  ASSERT_EQ(arbitrateOp->capacity(), minPoolCapacityTransferSize);
-  verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 0, 1);
-  verifyReclaimerStats(reclaimedOp->reclaimer()->stats(), 1);
-  ASSERT_EQ(arbitrator_->stats().numShrunkBytes, 0);
-  ASSERT_EQ(
-      arbitrator_->stats().numReclaimedBytes, minPoolCapacityTransferSize);
-  ASSERT_EQ(arbitrator_->stats().numRequests, 1);
-}
-
 TEST_F(MockSharedArbitrationTest, enterArbitrationException) {
   const uint64_t memCapacity = 128 * MB;
-  const uint64_t minPoolCapacity = memCapacity;
-  const uint64_t minPoolCapacityTransferSize = 64 * MB;
-  setupMemory(memCapacity, minPoolCapacity, minPoolCapacityTransferSize);
+  const uint64_t initPoolCapacity = memCapacity;
+  setupMemory(memCapacity, 0, initPoolCapacity, 0);
   auto* reclaimedOp = addMemoryOp();
   ASSERT_EQ(reclaimedOp->capacity(), memCapacity);
   const int allocationSize = 8 * MB;
@@ -1251,17 +2566,19 @@ TEST_F(MockSharedArbitrationTest, enterArbitrationException) {
     VELOX_FAIL("enterArbitrationException failed");
   });
   ASSERT_EQ(failedArbitrateOp->capacity(), 0);
-  ASSERT_ANY_THROW(failedArbitrateOp->allocate(allocationSize));
+  VELOX_ASSERT_THROW(
+      failedArbitrateOp->allocate(allocationSize),
+      "enterArbitrationException failed");
+  ASSERT_FALSE(failedArbitrateOp->pool()->aborted());
   verifyReclaimerStats(failedArbitrateOp->reclaimer()->stats());
   ASSERT_EQ(failedArbitrateOp->capacity(), 0);
   auto* arbitrateOp = addMemoryOp();
   arbitrateOp->allocate(allocationSize);
-  ASSERT_EQ(arbitrateOp->capacity(), minPoolCapacityTransferSize);
+  ASSERT_EQ(arbitrateOp->capacity(), allocationSize);
   verifyReclaimerStats(arbitrateOp->reclaimer()->stats(), 0, 1);
   verifyReclaimerStats(reclaimedOp->reclaimer()->stats(), 1);
   ASSERT_EQ(arbitrator_->stats().numShrunkBytes, 0);
-  ASSERT_EQ(
-      arbitrator_->stats().numReclaimedBytes, minPoolCapacityTransferSize);
+  ASSERT_EQ(arbitrator_->stats().numReclaimedBytes, allocationSize);
   ASSERT_EQ(arbitrator_->stats().numRequests, 1);
   ASSERT_EQ(arbitrator_->stats().numFailures, 0);
 }
@@ -1285,13 +2602,13 @@ TEST_F(MockSharedArbitrationTest, noArbitratiognFromAbortedPool) {
   // Check we don't allow memory reservation increase or trigger memory
   // arbitration at root memory pool.
   ASSERT_EQ(reclaimedOp->pool()->capacity(), kMemoryPoolInitCapacity);
-  ASSERT_EQ(reclaimedOp->pool()->currentBytes(), 0);
+  ASSERT_EQ(reclaimedOp->pool()->usedBytes(), 0);
   VELOX_ASSERT_THROW(reclaimedOp->allocate(128), "");
-  ASSERT_EQ(reclaimedOp->pool()->currentBytes(), 0);
+  ASSERT_EQ(reclaimedOp->pool()->usedBytes(), 0);
   ASSERT_EQ(reclaimedOp->pool()->capacity(), kMemoryPoolInitCapacity);
   VELOX_ASSERT_THROW(reclaimedOp->allocate(kMemoryPoolInitCapacity * 2), "");
   ASSERT_EQ(reclaimedOp->pool()->capacity(), kMemoryPoolInitCapacity);
-  ASSERT_EQ(reclaimedOp->pool()->currentBytes(), 0);
+  ASSERT_EQ(reclaimedOp->pool()->usedBytes(), 0);
   ASSERT_EQ(arbitrator_->stats().numRequests, 0);
   ASSERT_EQ(arbitrator_->stats().numAborted, 0);
   ASSERT_EQ(arbitrator_->stats().numFailures, 0);
@@ -1352,7 +2669,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromRequestor) {
        0}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    setupMemory();
+    setupMemory(kMemoryCapacity, 0, kMemoryPoolInitCapacity, 0, 0, 0, 0, 0, 0);
 
     std::vector<std::shared_ptr<MockTask>> otherTasks;
     std::vector<MockMemoryOperator*> otherTaskOps;
@@ -1361,7 +2678,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromRequestor) {
       otherTaskOps.push_back(addMemoryOp(otherTasks.back(), false));
       otherTaskOps.back()->allocate(otherTaskMemoryCapacity);
       ASSERT_EQ(
-          otherTasks.back()->pool()->currentBytes(), otherTaskMemoryCapacity);
+          otherTasks.back()->pool()->usedBytes(), otherTaskMemoryCapacity);
     }
     std::shared_ptr<MockTask> failedTask = addTask();
     MockMemoryOperator* failedTaskOp = addMemoryOp(
@@ -1391,12 +2708,12 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromRequestor) {
         numFailedTaskAllocationsAfterAbort + numOtherAllocationsAfterAbort + 1);
     folly::futures::Barrier arbitrationBarrier(
         numFailedTaskAllocationsAfterAbort + numOtherAllocationsAfterAbort + 1);
-    std::atomic<int> testInjectionCount{0};
-    std::atomic<bool> arbitrationStarted{false};
+    std::atomic_int testInjectionCount{0};
+    std::atomic_bool arbitrationStarted{false};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::memory::SharedArbitrator::startArbitration",
-        std::function<void(const MemoryPool*)>(
-            ([&](const MemoryPool* /*unsed*/) {
+        std::function<void(const SharedArbitrator*)>(
+            ([&](const SharedArbitrator* /*unused*/) {
               if (!arbitrationStarted) {
                 return;
               }
@@ -1407,7 +2724,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromRequestor) {
             })));
 
     SCOPED_TESTVALUE_SET(
-        "facebook::velox::memory::SharedArbitrator::sortCandidatesByFreeCapacity",
+        "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableFreeCapacity",
         std::function<void(const std::vector<SharedArbitrator::Candidate>*)>(
             ([&](const std::vector<SharedArbitrator::Candidate>* /*unused*/) {
               if (!arbitrationStarted.exchange(true)) {
@@ -1427,7 +2744,8 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromRequestor) {
         arbitrationStartBarrier.wait().wait();
         if (i < numFailedTaskAllocationsAfterAbort) {
           VELOX_ASSERT_THROW(
-              failedTaskOp->allocate(failedTaskMemoryCapacity), "");
+              failedTaskOp->allocate(failedTaskMemoryCapacity),
+              "The requestor pool has been aborted");
         } else {
           otherTaskOps[i - numFailedTaskAllocationsAfterAbort]->allocate(
               otherTaskMemoryCapacity);
@@ -1436,14 +2754,16 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromRequestor) {
     }
 
     // Trigger memory arbitration to reclaim from itself which throws.
-    VELOX_ASSERT_THROW(failedTaskOp->allocate(failedTaskMemoryCapacity), "");
+    VELOX_ASSERT_THROW(
+        failedTaskOp->allocate(failedTaskMemoryCapacity),
+        "The requestor pool has been aborted");
     // Wait for all the allocation threads to complete.
     for (auto& allocationThread : allocationThreadsAfterAbort) {
       allocationThread.join();
     }
     ASSERT_TRUE(failedTaskOp->pool()->aborted());
     ASSERT_EQ(
-        failedTaskOp->pool()->currentBytes(),
+        failedTaskOp->pool()->usedBytes(),
         testData.expectedFailedTaskMemoryCapacity);
     ASSERT_EQ(
         failedTaskOp->pool()->capacity(),
@@ -1468,8 +2788,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromRequestor) {
       ASSERT_EQ(
           taskOp->pool()->capacity(), testData.expectedOtherTaskMemoryCapacity);
       ASSERT_EQ(
-          taskOp->pool()->currentBytes(),
-          testData.expectedOtherTaskMemoryUsage);
+          taskOp->pool()->usedBytes(), testData.expectedOtherTaskMemoryUsage);
     }
 
     VELOX_ASSERT_THROW(failedTaskOp->allocate(failedTaskMemoryCapacity), "");
@@ -1534,7 +2853,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromOtherTask) {
        nonFailTaskMemoryCapacity}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    setupMemory();
+    setupMemory(kMemoryCapacity, 0, kMemoryPoolInitCapacity, 0, 0, 0, 0, 0, 0);
 
     std::vector<std::shared_ptr<MockTask>> nonFailedTasks;
     std::vector<MockMemoryOperator*> nonFailedTaskOps;
@@ -1543,7 +2862,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromOtherTask) {
       nonFailedTaskOps.push_back(addMemoryOp(nonFailedTasks.back(), false));
       nonFailedTaskOps.back()->allocate(nonFailTaskMemoryCapacity);
       ASSERT_EQ(
-          nonFailedTasks.back()->pool()->currentBytes(),
+          nonFailedTasks.back()->pool()->usedBytes(),
           nonFailTaskMemoryCapacity);
     }
     std::shared_ptr<MockTask> failedTask = addTask();
@@ -1582,8 +2901,8 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromOtherTask) {
     std::atomic<bool> arbitrationStarted{false};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::memory::SharedArbitrator::startArbitration",
-        std::function<void(const MemoryPool*)>(
-            ([&](const MemoryPool* /*unsed*/) {
+        std::function<void(const SharedArbitrator*)>(
+            ([&](const SharedArbitrator* /*unsed*/) {
               if (!arbitrationStarted) {
                 return;
               }
@@ -1594,7 +2913,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromOtherTask) {
             })));
 
     SCOPED_TESTVALUE_SET(
-        "facebook::velox::memory::SharedArbitrator::sortCandidatesByFreeCapacity",
+        "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableFreeCapacity",
         std::function<void(const std::vector<SharedArbitrator::Candidate>*)>(
             ([&](const std::vector<SharedArbitrator::Candidate>* /*unused*/) {
               if (!arbitrationStarted.exchange(true)) {
@@ -1630,7 +2949,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromOtherTask) {
     }
     ASSERT_TRUE(failedTaskOp->pool()->aborted());
     ASSERT_EQ(
-        failedTaskOp->pool()->currentBytes(),
+        failedTaskOp->pool()->usedBytes(),
         testData.expectedFailedTaskMemoryCapacity);
     ASSERT_EQ(
         failedTaskOp->pool()->capacity(),
@@ -1659,7 +2978,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromOtherTask) {
             testData.expectedNonFailedTaskMemoryCapacity +
                 nonFailTaskMemoryCapacity);
         ASSERT_EQ(
-            taskOp->pool()->currentBytes(),
+            taskOp->pool()->usedBytes(),
             testData.expectedNonFailedTaskMemoryUsage +
                 nonFailTaskMemoryCapacity);
       } else {
@@ -1667,7 +2986,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromOtherTask) {
             taskOp->pool()->capacity(),
             testData.expectedNonFailedTaskMemoryCapacity);
         ASSERT_EQ(
-            taskOp->pool()->currentBytes(),
+            taskOp->pool()->usedBytes(),
             testData.expectedNonFailedTaskMemoryUsage);
       }
     }
@@ -1679,6 +2998,16 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, failedToReclaimFromOtherTask) {
 }
 
 TEST_F(MockSharedArbitrationTest, memoryPoolAbortThrow) {
+  setupMemory(
+      kMemoryCapacity,
+      0,
+      kMemoryPoolInitCapacity,
+      0,
+      0,
+      kFastExponentialGrowthCapacityLimit,
+      kSlowCapacityGrowPct,
+      0,
+      0);
   const int numTasks = 4;
   const int smallTaskMemoryCapacity = kMemoryCapacity / 8;
   const int largeTaskMemoryCapacity = kMemoryCapacity / 2;
@@ -1700,7 +3029,9 @@ TEST_F(MockSharedArbitrationTest, memoryPoolAbortThrow) {
   ASSERT_EQ(oldStats.numAborted, 0);
 
   // Trigger memory arbitration to reclaim from itself which throws.
-  VELOX_ASSERT_THROW(largeTaskOp->allocate(largeTaskMemoryCapacity), "");
+  VELOX_ASSERT_THROW(
+      largeTaskOp->allocate(largeTaskMemoryCapacity),
+      "The requestor pool has been aborted");
   const auto newStats = arbitrator_->stats();
   ASSERT_EQ(newStats.numRequests, oldStats.numRequests + 1);
   ASSERT_EQ(newStats.numAborted, 1);
@@ -1720,10 +3051,44 @@ TEST_F(MockSharedArbitrationTest, memoryPoolAbortThrow) {
   ASSERT_EQ(arbitrator_->stats().numAborted, 1);
 }
 
+// This test makes sure the memory capacity grows as expected.
+DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, concurrentArbitrationRequests) {
+  setupMemory(kMemoryCapacity, 0, 0, 0, 128 << 20);
+  std::shared_ptr<MockTask> task = addTask();
+  MockMemoryOperator* op1 = addMemoryOp(task);
+  MockMemoryOperator* op2 = addMemoryOp(task);
+
+  std::atomic_bool arbitrationWaitFlag{true};
+  folly::EventCount arbitrationWait;
+  std::atomic_bool injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::SharedArbitrator::startArbitration",
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* arbitrator) {
+            if (!injectOnce.exchange(false)) {
+              return;
+            }
+            arbitrationWaitFlag = false;
+            arbitrationWait.notifyAll();
+            while (arbitrator->testingNumRequests() != 2) {
+              std::this_thread::sleep_for(std::chrono::seconds(5)); // NOLINT
+            }
+          })));
+
+  std::thread firstArbitrationThread([&]() { op1->allocate(64 << 20); });
+
+  std::thread secondArbitrationThread([&]() { op2->allocate(64 << 20); });
+
+  firstArbitrationThread.join();
+  secondArbitrationThread.join();
+
+  ASSERT_EQ(task->capacity(), 128 << 20);
+}
+
 DEBUG_ONLY_TEST_F(
     MockSharedArbitrationTest,
     freeUnusedCapacityWhenReclaimMemoryPool) {
-  setupMemory(kMemoryCapacity, 0);
+  setupMemory(kMemoryCapacity, 0, 0, 0);
   const int allocationSize = kMemoryCapacity / 4;
   std::shared_ptr<MockTask> reclaimedTask = addTask();
   MockMemoryOperator* reclaimedTaskOp = addMemoryOp(reclaimedTask);
@@ -1738,7 +3103,7 @@ DEBUG_ONLY_TEST_F(
   folly::EventCount reclaimBlock;
   auto reclaimBlockKey = reclaimBlock.prepareWait();
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableMemory",
+      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableUsedCapacity",
       std::function<void(const MemoryPool*)>(([&](const MemoryPool* /*unsed*/) {
         reclaimWait.notify();
         reclaimBlock.wait(reclaimBlockKey);
@@ -1780,10 +3145,11 @@ DEBUG_ONLY_TEST_F(
 
   SCOPED_TESTVALUE_SET(
       "facebook::velox::memory::SharedArbitrator::startArbitration",
-      std::function<void(const MemoryPool*)>(([&](const MemoryPool* /*unsed*/) {
-        arbitrationRun.notify();
-        arbitrationBlock.wait(arbitrationBlockKey);
-      })));
+      std::function<void(const SharedArbitrator*)>(
+          ([&](const SharedArbitrator* /*unsed*/) {
+            arbitrationRun.notify();
+            arbitrationBlock.wait(arbitrationBlockKey);
+          })));
 
   std::thread allocThread([&]() {
     // Allocate more than its capacity to trigger arbitration which is blocked
@@ -1793,11 +3159,11 @@ DEBUG_ONLY_TEST_F(
 
   arbitrationRun.wait(arbitrationRunKey);
 
-  // Allocate a new root memory pool and check its initial memory reservation is
-  // zero.
+  // Allocate a new root memory pool and check it has its initial capacity
+  // allocated.
   std::shared_ptr<MockTask> skipTask = addTask(kMemoryCapacity);
   MockMemoryOperator* skipTaskOp = addMemoryOp(skipTask);
-  ASSERT_EQ(skipTaskOp->pool()->capacity(), 0);
+  ASSERT_EQ(skipTaskOp->pool()->capacity(), kMemoryPoolInitCapacity);
 
   arbitrationBlock.notify();
   allocThread.join();
@@ -1806,7 +3172,6 @@ DEBUG_ONLY_TEST_F(
 TEST_F(MockSharedArbitrationTest, arbitrationFailure) {
   int64_t maxCapacity = 128 * MB;
   int64_t initialCapacity = 0 * MB;
-  int64_t minTransferCapacity = 1 * MB;
   struct {
     int64_t requestorCapacity;
     int64_t requestorRequestBytes;
@@ -1832,7 +3197,7 @@ TEST_F(MockSharedArbitrationTest, arbitrationFailure) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    setupMemory(maxCapacity, initialCapacity, minTransferCapacity);
+    setupMemory(maxCapacity, 0, initialCapacity, 0);
     std::shared_ptr<MockTask> requestorTask = addTask();
     MockMemoryOperator* requestorOp = addMemoryOp(requestorTask, false);
     requestorOp->allocate(testData.requestorCapacity);
diff --git a/velox/common/memory/tests/SharedArbitratorTest.cpp b/velox/common/memory/tests/SharedArbitratorTest.cpp
index 3ffde0fc0a0d8..512a731e7d0fd 100644
--- a/velox/common/memory/tests/SharedArbitratorTest.cpp
+++ b/velox/common/memory/tests/SharedArbitratorTest.cpp
@@ -16,28 +16,29 @@
 
 #include <gtest/gtest.h>
 
-#include <folly/Singleton.h>
 #include <re2/re2.h>
 #include <deque>
 
+#include <folly/init/Init.h>
+#include <functional>
+#include <optional>
 #include "folly/experimental/EventCount.h"
-#include "folly/futures/Barrier.h"
+#include "velox/common/base/Exceptions.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/MallocAllocator.h"
-#include "velox/common/memory/Memory.h"
 #include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/testutil/TestValue.h"
-#include "velox/connectors/hive/HiveDataSink.h"
+#include "velox/connectors/hive/HiveConfig.h"
 #include "velox/core/PlanNode.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/exec/Driver.h"
-#include "velox/exec/HashBuild.h"
+#include "velox/exec/HashAggregation.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/TableWriter.h"
 #include "velox/exec/Values.h"
-#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/exec/tests/utils/SumNonPODAggregate.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
 DECLARE_bool(velox_suppress_memory_capacity_exceeding_error_message);
@@ -48,33 +49,6 @@ using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::memory {
-constexpr int64_t KB = 1024L;
-constexpr int64_t MB = 1024L * KB;
-
-constexpr uint64_t kMemoryCapacity = 512 * MB;
-constexpr uint64_t kMemoryPoolInitCapacity = 16 * MB;
-constexpr uint64_t kMemoryPoolTransferCapacity = 8 * MB;
-
-struct TestAllocation {
-  MemoryPool* pool{nullptr};
-  void* buffer{nullptr};
-  size_t size{0};
-
-  size_t free() {
-    const size_t freedBytes = size;
-    if (pool == nullptr) {
-      VELOX_CHECK_EQ(freedBytes, 0);
-      return freedBytes;
-    }
-    VELOX_CHECK_GT(freedBytes, 0);
-    pool->free(buffer, freedBytes);
-    pool = nullptr;
-    buffer = nullptr;
-    size = 0;
-    return freedBytes;
-  }
-};
-
 // Custom node for the custom factory.
 class FakeMemoryNode : public core::PlanNode {
  public:
@@ -101,8 +75,10 @@ class FakeMemoryNode : public core::PlanNode {
 
 using AllocationCallback = std::function<TestAllocation(Operator* op)>;
 // If return true, the caller will terminate execution and return early.
-using ReclaimInjectionCallback = std::function<
-    bool(MemoryPool* pool, uint64_t targetByte, MemoryReclaimer::Stats& stats)>;
+using ReclaimInjectionCallback = std::function<bool(
+    memory::MemoryPool* pool,
+    uint64_t targetByte,
+    MemoryReclaimer::Stats& stats)>;
 
 // Custom operator for the custom factory.
 class FakeMemoryOperator : public Operator {
@@ -168,7 +144,7 @@ class FakeMemoryOperator : public Operator {
       override {
     VELOX_CHECK(canReclaim());
     auto* driver = operatorCtx_->driver();
-    VELOX_CHECK(!driver->state().isOnThread() || driver->state().isSuspended);
+    VELOX_CHECK(!driver->state().isOnThread() || driver->state().suspended());
     VELOX_CHECK(driver->task()->pauseRequested());
     VELOX_CHECK_GT(targetBytes, 0);
 
@@ -185,17 +161,15 @@ class FakeMemoryOperator : public Operator {
       pool()->free(allocIt->buffer, allocIt->size);
       allocIt = allocations_.erase(allocIt);
     }
-    VELOX_CHECK_GE(totalBytes_, 0);
   }
 
  private:
   void clear() {
     for (auto& allocation : allocations_) {
       totalBytes_ -= allocation.free();
-      VELOX_CHECK_GE(totalBytes_, 0);
     }
     allocations_.clear();
-    VELOX_CHECK_EQ(totalBytes_, 0);
+    VELOX_CHECK_EQ(totalBytes_.load(), 0);
   }
 
   const bool canReclaim_;
@@ -252,38 +226,19 @@ class FakeMemoryOperatorFactory : public Operator::PlanNodeTranslator {
   uint32_t maxDrivers_{1};
 };
 
-class FakeMemoryReclaimer : public MemoryReclaimer {
- public:
-  FakeMemoryReclaimer() = default;
-
-  static std::unique_ptr<MemoryReclaimer> create() {
-    return std::make_unique<FakeMemoryReclaimer>();
-  }
-
-  void enterArbitration() override {
-    auto* driverThreadCtx = driverThreadContext();
-    if (driverThreadCtx == nullptr) {
-      return;
-    }
-    auto* driver = driverThreadCtx->driverCtx.driver;
-    ASSERT_TRUE(driver != nullptr);
-    if (driver->task()->enterSuspended(driver->state()) != StopReason::kNone) {
-      VELOX_FAIL("Terminate detected when entering suspension");
-    }
-  }
+namespace {
+std::unique_ptr<folly::Executor> newParallelExecutor() {
+  return std::make_unique<folly::CPUThreadPoolExecutor>(32);
+}
 
-  void leaveArbitration() noexcept override {
-    auto* driverThreadCtx = driverThreadContext();
-    if (driverThreadCtx == nullptr) {
-      return;
-    }
-    auto* driver = driverThreadCtx->driverCtx.driver;
-    ASSERT_TRUE(driver != nullptr);
-    driver->task()->leaveSuspended(driver->state());
-  }
+struct TestParam {
+  bool isSerialExecutionMode{false};
 };
+} // namespace
 
-class SharedArbitrationTest : public exec::test::HiveConnectorTestBase {
+class SharedArbitrationTest : public testing::WithParamInterface<TestParam>,
+                              public exec::test::HiveConnectorTestBase {
+ public:
  protected:
   static void SetUpTestCase() {
     exec::test::HiveConnectorTestBase::SetUpTestCase();
@@ -308,339 +263,275 @@ class SharedArbitrationTest : public exec::test::HiveConnectorTestBase {
     fuzzerOpts_.stringVariableLength = false;
     fuzzerOpts_.stringLength = 1024;
     fuzzerOpts_.allowLazyVector = false;
-    VectorFuzzer fuzzer(fuzzerOpts_, pool());
-    vector_ = newVector();
-    executor_ = std::make_unique<folly::CPUThreadPoolExecutor>(32);
+    vector_ = makeRowVector(rowType_, fuzzerOpts_);
+    numAddedPools_ = 0;
+    isSerialExecutionMode_ = GetParam().isSerialExecutionMode;
+    if (isSerialExecutionMode_) {
+      executor_ = nullptr;
+    } else {
+      executor_ = newParallelExecutor();
+    }
   }
 
   void TearDown() override {
+    vector_.reset();
     HiveConnectorTestBase::TearDown();
   }
 
   void setupMemory(
       int64_t memoryCapacity = 0,
-      uint64_t memoryPoolInitCapacity = kMemoryPoolInitCapacity,
-      uint64_t memoryPoolTransferCapacity = kMemoryPoolTransferCapacity) {
+      uint64_t memoryPoolInitCapacity = kMemoryPoolInitCapacity) {
     memoryCapacity = (memoryCapacity != 0) ? memoryCapacity : kMemoryCapacity;
-    allocator_ = std::make_shared<MallocAllocator>(memoryCapacity);
-    MemoryManagerOptions options;
-    options.allocator = allocator_.get();
-    options.capacity = allocator_->capacity();
-    options.arbitratorKind = "SHARED";
-    options.capacity = options.capacity;
-    options.memoryPoolInitCapacity = memoryPoolInitCapacity;
-    options.memoryPoolTransferCapacity = memoryPoolTransferCapacity;
-    options.checkUsageLeak = true;
-    options.arbitrationStateCheckCb = memoryArbitrationStateCheck;
-    memoryManager_ = std::make_unique<MemoryManager>(options);
+    memoryManager_ =
+        createMemoryManager(memoryCapacity, memoryPoolInitCapacity);
     ASSERT_EQ(memoryManager_->arbitrator()->kind(), "SHARED");
     arbitrator_ = static_cast<SharedArbitrator*>(memoryManager_->arbitrator());
+    numAddedPools_ = 0;
+  }
+
+  void checkOperatorStatsForArbitration(
+      PlanNodeStats& stats,
+      bool expectGlobalArbitration) {
+    if (expectGlobalArbitration) {
+      VELOX_CHECK_EQ(
+          stats.customStats.count(SharedArbitrator::kGlobalArbitrationCount),
+          1);
+      VELOX_CHECK_GE(
+          stats.customStats.at(SharedArbitrator::kGlobalArbitrationCount).sum,
+          1);
+      VELOX_CHECK_EQ(
+          stats.customStats.count(SharedArbitrator::kLocalArbitrationCount), 0);
+    } else {
+      VELOX_CHECK_EQ(
+          stats.customStats.count(SharedArbitrator::kLocalArbitrationCount), 1);
+      VELOX_CHECK_EQ(
+          stats.customStats.at(SharedArbitrator::kLocalArbitrationCount).sum,
+          1);
+      VELOX_CHECK_EQ(
+          stats.customStats.count(SharedArbitrator::kGlobalArbitrationCount),
+          0);
+    }
   }
 
-  RowVectorPtr newVector() {
-    VectorFuzzer fuzzer(fuzzerOpts_, pool());
-    return fuzzer.fuzzRow(rowType_);
+  AssertQueryBuilder newQueryBuilder() {
+    AssertQueryBuilder builder = AssertQueryBuilder(duckDbQueryRunner_);
+    builder.serialExecution(isSerialExecutionMode_);
+    return builder;
   }
 
-  std::shared_ptr<core::QueryCtx> newQueryCtx(
-      int64_t memoryCapacity = kMaxMemory,
-      std::unique_ptr<MemoryReclaimer>&& reclaimer = nullptr) {
-    std::unordered_map<std::string, std::shared_ptr<Config>> configs;
-    std::shared_ptr<MemoryPool> pool = memoryManager_->addRootPool(
-        "",
-        memoryCapacity,
-        reclaimer != nullptr ? std::move(reclaimer)
-                             : MemoryReclaimer::create());
-    auto queryCtx = std::make_shared<core::QueryCtx>(
-        executor_.get(),
-        core::QueryConfig({}),
-        configs,
-        cache::AsyncDataCache::getInstance(),
-        std::move(pool));
-    return queryCtx;
+  AssertQueryBuilder newQueryBuilder(const core::PlanNodePtr& plan) {
+    AssertQueryBuilder builder = AssertQueryBuilder(plan);
+    builder.serialExecution(isSerialExecutionMode_);
+    return builder;
   }
 
   static inline FakeMemoryOperatorFactory* fakeOperatorFactory_;
-  std::shared_ptr<MemoryAllocator> allocator_;
-  std::unique_ptr<MemoryManager> memoryManager_;
-  SharedArbitrator* arbitrator_;
+  std::unique_ptr<memory::MemoryManager> memoryManager_;
+  SharedArbitrator* arbitrator_{nullptr};
   RowTypePtr rowType_;
   VectorFuzzer::Options fuzzerOpts_;
   RowVectorPtr vector_;
-  std::unique_ptr<folly::CPUThreadPoolExecutor> executor_;
+  std::atomic_uint64_t numAddedPools_{0};
+  bool isSerialExecutionMode_{false};
 };
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimFromOrderBy) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
+/// A test fixture that runs cases within parallel execution mode.
+class SharedArbitrationTestWithParallelExecutionModeOnly
+    : public SharedArbitrationTest {};
+/// A test fixture that runs cases within both serial and
+/// parallel execution modes.
+class SharedArbitrationTestWithThreadingModes : public SharedArbitrationTest {};
+
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithThreadingModes,
+    queryArbitrationStateCheck) {
+  const std::vector<RowVectorPtr> vectors =
+      createVectors(rowType_, 32, 32 << 20);
   createDuckDbTable(vectors);
-  std::vector<bool> sameQueries = {false, true};
-  for (bool sameQuery : sameQueries) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> orderByQueryCtx;
-    if (sameQuery) {
-      orderByQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      orderByQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    folly::EventCount fakeAllocationWait;
-    auto fakeAllocationWaitKey = fakeAllocationWait.prepareWait();
-    folly::EventCount taskPauseWait;
-    auto taskPauseWaitKey = taskPauseWait.prepareWait();
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memory::memoryManager(), executor_.get(), kMemoryCapacity);
 
-    const auto orderByMemoryUsage = 32L << 20;
-    const auto fakeAllocationSize = kMemoryCapacity - orderByMemoryUsage / 2;
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      fakeAllocationWait.wait(fakeAllocationWaitKey);
-      auto buffer = op->pool()->allocate(fakeAllocationSize);
-      return TestAllocation{op->pool(), buffer, fakeAllocationSize};
-    });
+  std::atomic_bool queryCtxStateChecked{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::requestPauseLocked",
+      std::function<void(Task*)>(([&](Task* /*unused*/) {
+        ASSERT_TRUE(queryCtx->testingUnderArbitration());
+        queryCtxStateChecked = true;
+      })));
 
-    std::atomic<bool> injectOrderByOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "OrderBy") {
-            return;
-          }
-          if (op->pool()->capacity() < orderByMemoryUsage) {
-            return;
-          }
-          if (!injectOrderByOnce.exchange(false)) {
-            return;
-          }
-          fakeAllocationWait.notify();
-          // Wait for pause to be triggered.
-          taskPauseWait.wait(taskPauseWaitKey);
-        })));
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  TestScopedSpillInjection scopedSpillInjection(100);
+  core::PlanNodeId aggregationNodeId;
+  newQueryBuilder()
+      .queryCtx(queryCtx)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, "true")
+      .plan(PlanBuilder()
+                .values(vectors)
+                .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                .capturePlanNodeId(aggregationNodeId)
+                .planNode())
+      .assertResults("SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
+  ASSERT_TRUE(queryCtxStateChecked);
+  ASSERT_FALSE(queryCtx->testingUnderArbitration());
+  waitForAllTasksToBeDeleted();
+  ASSERT_FALSE(queryCtx->testingUnderArbitration());
+}
 
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Task::requestPauseLocked",
-        std::function<void(Task*)>(
-            ([&](Task* /*unused*/) { taskPauseWait.notify(); })));
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithThreadingModes,
+    raceBetweenAbortAndArbitrationLeave) {
+  const std::vector<RowVectorPtr> vectors =
+      createVectors(rowType_, 32, 32 << 20);
+  setupMemory(kMemoryCapacity, /*memoryPoolInitCapacity=*/0);
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memoryManager_.get(), executor_.get(), 32 << 20);
+
+  folly::EventCount abortWait;
+  std::atomic_bool abortWaitFlag{true};
+  std::atomic<Task*> task{nullptr};
+  const std::string errorMsg{"injected abort error"};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::leaveSuspended",
+      std::function<void(exec::Task*)>(([&](exec::Task* _task) {
+        if (task.exchange(_task) != nullptr) {
+          return;
+        }
+        abortWaitFlag = false;
+        abortWait.notifyAll();
+        // Let memory pool abort thread to run first. We inject a randomized
+        // delay here to trigger all the potential timing race conditions but
+        // the test result should be the same.
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(folly::Random::rand32() % 1'000));
+      })));
 
-    std::thread orderByThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .spillDirectory(spillDirectory->path)
-              .config(core::QueryConfig::kSpillEnabled, "true")
-              .config(core::QueryConfig::kOrderBySpillEnabled, "true")
-              .queryCtx(orderByQueryCtx)
-              .plan(
-                  PlanBuilder()
-                      .values(vectors)
-                      .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                      .planNode())
-              .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
-      auto stats = task->taskStats().pipelineStats;
-      ASSERT_GT(stats[0].operatorStats[1].spilledBytes, 0);
-    });
+  std::thread queryThread([&] {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    core::PlanNodeId aggregationNodeId;
+    auto plan = PlanBuilder()
+                    .values(vectors)
+                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                    .capturePlanNodeId(aggregationNodeId)
+                    .planNode();
+    VELOX_ASSERT_THROW(
+        newQueryBuilder(plan)
+            .queryCtx(queryCtx)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, "true")
+            .copyResults(pool()),
+        errorMsg);
+  });
 
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
+  abortWait.await([&] { return !abortWaitFlag.load(); });
 
-    orderByThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
+  try {
+    VELOX_FAIL(errorMsg);
+  } catch (...) {
+    task.load()->pool()->abort(std::current_exception());
   }
+  queryThread.join();
+  waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimFromEmptyOrderBy) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  std::shared_ptr<core::QueryCtx> orderByQueryCtx =
-      newQueryCtx(kMemoryCapacity);
-
-  folly::EventCount fakeAllocationWait;
-  auto fakeAllocationWaitKey = fakeAllocationWait.prepareWait();
-  folly::EventCount taskPauseWait;
-  auto taskPauseWaitKey = taskPauseWait.prepareWait();
-
-  std::atomic<int> injectAllocations{0};
-  fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-    const auto injectionCount = ++injectAllocations;
-    if (injectionCount > 2) {
-      return TestAllocation{};
-    }
-    if (injectionCount == 1) {
-      return TestAllocation{
-          op->pool(),
-          op->pool()->allocate(kMemoryCapacity / 2),
-          kMemoryCapacity / 2};
-    }
-    fakeAllocationWait.wait(fakeAllocationWaitKey);
-    EXPECT_ANY_THROW(op->pool()->allocate(kMemoryCapacity));
-    return TestAllocation{};
-  });
-  fakeOperatorFactory_->setCanReclaim(false);
-
-  core::PlanNodeId orderByPlanNodeId;
-  auto orderByPlan =
-      PlanBuilder()
-          .values(vectors)
-          .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-          .capturePlanNodeId(orderByPlanNodeId)
-          .planNode();
-
-  std::atomic<bool> injectDriverBlockOnce{true};
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithThreadingModes,
+    skipNonReclaimableTaskTest) {
+  const std::vector<RowVectorPtr> vectors =
+      createVectors(rowType_, 32, 32 << 20);
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memory::memoryManager(), executor_.get(), kMemoryCapacity);
+  std::unordered_map<std::string, std::string> configs;
+  configs.emplace(core::QueryConfig::kSpillEnabled, "true");
+  queryCtx->testingOverrideConfigUnsafe(std::move(configs));
+
+  std::atomic_bool blockedAggregation{false};
+  std::atomic_bool blockedPartialAggregation{false};
+  folly::EventCount arbitrationWait;
+  std::atomic<bool> arbitrationWaitFlag{true};
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal",
-      std::function<void(Driver*)>(([&](Driver* driver) {
-        Operator* op = driver->findOperator(orderByPlanNodeId);
-        if (op == nullptr) {
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(exec::Operator*)>(([&](exec::Operator* op) {
+        if (op->testingOperatorCtx()->operatorType() != "Aggregation" &&
+            op->testingOperatorCtx()->operatorType() != "PartialAggregation") {
           return;
         }
-        if (op->operatorType() != "OrderBy") {
+        if (op->pool()->usedBytes() == 0) {
           return;
         }
-        if (!injectDriverBlockOnce.exchange(false)) {
-          return;
+        if (op->testingOperatorCtx()->operatorType() == "PartialAggregation") {
+          if (blockedPartialAggregation.exchange(true)) {
+            return;
+          }
+        } else {
+          if (blockedAggregation.exchange(true)) {
+            return;
+          }
         }
-        fakeAllocationWait.notify();
-        // Wait for pause to be triggered.
-        taskPauseWait.wait(taskPauseWaitKey);
+        auto* driver = op->testingOperatorCtx()->driver();
+        SuspendedSection suspendedSection(driver);
+        arbitrationWait.await([&]() { return !arbitrationWaitFlag.load(); });
       })));
 
+  std::atomic_int taskPausedCount{0};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Task::requestPauseLocked",
-      std::function<void(Task*)>(
-          ([&](Task* /*unused*/) { taskPauseWait.notify(); })));
+      std::function<void(Task*)>(([&](Task* /*unused*/) {
+        ASSERT_TRUE(queryCtx->testingUnderArbitration());
+        ++taskPausedCount;
+      })));
 
-  std::thread orderByThread([&]() {
-    std::shared_ptr<Task> task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .spillDirectory(spillDirectory->path)
-            .maxDrivers(1)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kOrderBySpillEnabled, "true")
-            .queryCtx(orderByQueryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                      .planNode())
-            .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
-    // Verify no spill has been triggered.
-    const auto stats = task->taskStats().pipelineStats;
-    ASSERT_EQ(stats[0].operatorStats[1].spilledBytes, 0);
-    ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 0);
+  const auto spillPlan = PlanBuilder()
+                             .values(vectors)
+                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                             .planNode();
+  std::thread spillableThread([&]() {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    newQueryBuilder(spillPlan)
+        .queryCtx(queryCtx)
+        .spillDirectory(spillDirectory->getPath())
+        .copyResults(pool());
   });
 
-  std::thread memThread([&]() {
-    auto task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .queryCtx(orderByQueryCtx)
-            .maxDrivers(1)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .addNode([&](std::string id, core::PlanNodePtr input) {
-                        return std::make_shared<FakeMemoryNode>(id, input);
-                      })
-                      .planNode())
-            .assertResults("SELECT * FROM tmp");
+  const auto nonSpillPlan = PlanBuilder()
+                                .values(vectors)
+                                .aggregation(
+                                    {"c0", "c1"},
+                                    {"array_agg(c2)"},
+                                    {},
+                                    core::AggregationNode::Step::kPartial,
+                                    false)
+                                .planNode();
+  std::thread nonSpillableThread([&]() {
+    newQueryBuilder(nonSpillPlan).queryCtx(queryCtx).copyResults(pool());
   });
 
-  orderByThread.join();
-  memThread.join();
-  waitForAllTasksToBeDeleted();
-}
-
-class TestMemoryReclaimer : public MemoryReclaimer {
- public:
-  TestMemoryReclaimer(std::function<void(MemoryPool*)> reclaimCb)
-      : reclaimCb_(std::move(reclaimCb)) {}
-
-  uint64_t reclaim(MemoryPool* pool, uint64_t targetBytes, Stats& stats)
-      override {
-    if (pool->kind() == MemoryPool::Kind::kLeaf) {
-      return 0;
-    }
-    std::vector<std::shared_ptr<MemoryPool>> children;
-    {
-      children.reserve(pool->children_.size());
-      for (auto& entry : pool->children_) {
-        auto child = entry.second.lock();
-        if (child != nullptr) {
-          children.push_back(std::move(child));
-        }
-      }
-    }
+  while (!blockedPartialAggregation || !blockedAggregation) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
 
-    std::vector<ArbitrationCandidate> candidates(children.size());
-    for (uint32_t i = 0; i < children.size(); ++i) {
-      candidates[i].pool = children[i].get();
-      children[i]->reclaimableBytes(candidates[i].reclaimableBytes);
-    }
-    sortCandidatesByReclaimableMemoryAsc(candidates);
+  testingRunArbitration();
 
-    uint64_t reclaimedBytes{0};
-    for (const auto& candidate : candidates) {
-      const auto bytes = candidate.pool->reclaim(targetBytes, stats);
-      if (reclaimCb_ != nullptr) {
-        reclaimCb_(candidate.pool);
-      }
-      reclaimedBytes += bytes;
-      if (targetBytes != 0) {
-        if (bytes >= targetBytes) {
-          break;
-        }
-        targetBytes -= bytes;
-      }
-    }
-    return reclaimedBytes;
-  }
+  arbitrationWaitFlag = false;
+  arbitrationWait.notifyAll();
 
- private:
-  struct ArbitrationCandidate {
-    uint64_t reclaimableBytes{0};
-    MemoryPool* pool{nullptr};
-  };
-
-  void sortCandidatesByReclaimableMemoryAsc(
-      std::vector<ArbitrationCandidate>& candidates) {
-    std::sort(
-        candidates.begin(),
-        candidates.end(),
-        [](const ArbitrationCandidate& lhs, const ArbitrationCandidate& rhs) {
-          return lhs.reclaimableBytes < rhs.reclaimableBytes;
-        });
-  }
+  spillableThread.join();
+  nonSpillableThread.join();
 
-  std::function<void(MemoryPool*)> reclaimCb_{nullptr};
-};
+  // We shall only reclaim from the reclaimable task but not non-reclaimable
+  // task.
+  ASSERT_EQ(taskPausedCount, 1);
+  ASSERT_FALSE(queryCtx->testingUnderArbitration());
+  waitForAllTasksToBeDeleted();
+  ASSERT_FALSE(queryCtx->testingUnderArbitration());
+  ASSERT_EQ(taskPausedCount, 1);
+}
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimToOrderBy) {
+DEBUG_ONLY_TEST_P(SharedArbitrationTestWithThreadingModes, reclaimToOrderBy) {
   const int numVectors = 32;
   std::vector<RowVectorPtr> vectors;
   for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    vectors.push_back(makeRowVector(rowType_, fuzzerOpts_));
   }
   createDuckDbTable(vectors);
   std::vector<bool> sameQueries = {false, true};
@@ -648,12 +539,15 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimToOrderBy) {
     SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
     const auto oldStats = arbitrator_->stats();
     std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
+        newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
+    ++numAddedPools_;
     std::shared_ptr<core::QueryCtx> orderByQueryCtx;
     if (sameQuery) {
       orderByQueryCtx = fakeMemoryQueryCtx;
     } else {
-      orderByQueryCtx = newQueryCtx(kMemoryCapacity);
+      orderByQueryCtx =
+          newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
+      ++numAddedPools_;
     }
 
     folly::EventCount orderByWait;
@@ -694,21 +588,28 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimToOrderBy) {
             ([&](Task* /*unused*/) { taskPauseWait.notify(); })));
 
     std::thread orderByThread([&]() {
+      core::PlanNodeId orderByNodeId;
       auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
+          newQueryBuilder()
               .queryCtx(orderByQueryCtx)
-              .plan(
-                  PlanBuilder()
-                      .values(vectors)
-                      .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                      .planNode())
+              .serialExecution(isSerialExecutionMode_)
+              .plan(PlanBuilder()
+                        .values(vectors)
+                        .orderBy({"c0 ASC NULLS LAST"}, false)
+                        .capturePlanNodeId(orderByNodeId)
+                        .planNode())
               .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
+      auto taskStats = exec::toPlanStats(task->taskStats());
+      auto& stats = taskStats.at(orderByNodeId);
+      checkOperatorStatsForArbitration(
+          stats, !sameQuery /*expectGlobalArbitration*/);
     });
 
     std::thread memThread([&]() {
       auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
+          newQueryBuilder()
               .queryCtx(fakeMemoryQueryCtx)
+              .serialExecution(isSerialExecutionMode_)
               .plan(PlanBuilder()
                         .values(vectors)
                         .addNode([&](std::string id, core::PlanNodePtr input) {
@@ -724,62 +625,96 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimToOrderBy) {
     const auto newStats = arbitrator_->stats();
     ASSERT_GT(newStats.numReclaimedBytes, oldStats.numReclaimedBytes);
     ASSERT_GT(newStats.reclaimTimeUs, oldStats.reclaimTimeUs);
+    ASSERT_GT(orderByQueryCtx->pool()->stats().numCapacityGrowths, 0);
   }
 }
 
-TEST_F(SharedArbitrationTest, reclaimFromCompletedOrderBy) {
-  const int numVectors = 2;
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithThreadingModes,
+    reclaimToAggregation) {
+  const int numVectors = 32;
   std::vector<RowVectorPtr> vectors;
   for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    vectors.push_back(makeRowVector(rowType_, fuzzerOpts_));
   }
   createDuckDbTable(vectors);
   std::vector<bool> sameQueries = {false, true};
   for (bool sameQuery : sameQueries) {
     SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto oldStats = arbitrator_->stats();
     std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> orderByQueryCtx;
+        newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
+    ++numAddedPools_;
+    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
     if (sameQuery) {
-      orderByQueryCtx = fakeMemoryQueryCtx;
+      aggregationQueryCtx = fakeMemoryQueryCtx;
     } else {
-      orderByQueryCtx = newQueryCtx(kMemoryCapacity);
+      aggregationQueryCtx =
+          newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
+      ++numAddedPools_;
     }
 
-    folly::EventCount fakeAllocationWait;
-    auto fakeAllocationWaitKey = fakeAllocationWait.prepareWait();
+    folly::EventCount aggregationWait;
+    auto aggregationWaitKey = aggregationWait.prepareWait();
+    folly::EventCount taskPauseWait;
+    auto taskPauseWaitKey = taskPauseWait.prepareWait();
 
-    const auto fakeAllocationSize = kMemoryCapacity;
+    const auto fakeAllocationSize = kMemoryCapacity - (32L << 20);
 
     std::atomic<bool> injectAllocationOnce{true};
     fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
       if (!injectAllocationOnce.exchange(false)) {
         return TestAllocation{};
       }
-      fakeAllocationWait.wait(fakeAllocationWaitKey);
       auto buffer = op->pool()->allocate(fakeAllocationSize);
+      aggregationWait.notify();
+      // Wait for pause to be triggered.
+      taskPauseWait.wait(taskPauseWaitKey);
       return TestAllocation{op->pool(), buffer, fakeAllocationSize};
     });
 
-    std::thread orderByThread([&]() {
+    std::atomic<bool> injectAggregationOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "Aggregation") {
+            return;
+          }
+          if (!injectAggregationOnce.exchange(false)) {
+            return;
+          }
+          aggregationWait.wait(aggregationWaitKey);
+        })));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Task::requestPauseLocked",
+        std::function<void(Task*)>(
+            ([&](Task* /*unused*/) { taskPauseWait.notify(); })));
+
+    std::thread aggregationThread([&]() {
+      core::PlanNodeId aggregationNodeId;
       auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(orderByQueryCtx)
-              .plan(
-                  PlanBuilder()
-                      .values(vectors)
-                      .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                      .planNode())
-              .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
-      waitForTaskCompletion(task.get());
-      fakeAllocationWait.notify();
+          newQueryBuilder()
+              .queryCtx(aggregationQueryCtx)
+              .serialExecution(isSerialExecutionMode_)
+              .plan(PlanBuilder()
+                        .values(vectors)
+                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                        .capturePlanNodeId(aggregationNodeId)
+                        .planNode())
+              .assertResults(
+                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
+      auto taskStats = exec::toPlanStats(task->taskStats());
+      auto& stats = taskStats.at(aggregationNodeId);
+      checkOperatorStatsForArbitration(
+          stats, !sameQuery /*expectGlobalArbitration*/);
     });
 
     std::thread memThread([&]() {
       auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
+          newQueryBuilder()
               .queryCtx(fakeMemoryQueryCtx)
+              .serialExecution(isSerialExecutionMode_)
               .plan(PlanBuilder()
                         .values(vectors)
                         .addNode([&](std::string id, core::PlanNodePtr input) {
@@ -789,67 +724,71 @@ TEST_F(SharedArbitrationTest, reclaimFromCompletedOrderBy) {
               .assertResults("SELECT * FROM tmp");
     });
 
-    orderByThread.join();
+    aggregationThread.join();
     memThread.join();
     waitForAllTasksToBeDeleted();
+
+    const auto newStats = arbitrator_->stats();
+    ASSERT_GT(newStats.numReclaimedBytes, oldStats.numReclaimedBytes);
+    ASSERT_GT(newStats.reclaimTimeUs, oldStats.reclaimTimeUs);
   }
 }
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimFromAggregation) {
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithThreadingModes,
+    reclaimToJoinBuilder) {
   const int numVectors = 32;
   std::vector<RowVectorPtr> vectors;
   for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    vectors.push_back(makeRowVector(rowType_, fuzzerOpts_));
   }
   createDuckDbTable(vectors);
   std::vector<bool> sameQueries = {false, true};
   for (bool sameQuery : sameQueries) {
     SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto oldStats = arbitrator_->stats();
     std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
+        newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
+    ++numAddedPools_;
+    std::shared_ptr<core::QueryCtx> joinQueryCtx;
     if (sameQuery) {
-      aggregationQueryCtx = fakeMemoryQueryCtx;
+      joinQueryCtx = fakeMemoryQueryCtx;
     } else {
-      aggregationQueryCtx = newQueryCtx(kMemoryCapacity);
+      joinQueryCtx =
+          newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
+      ++numAddedPools_;
     }
 
-    folly::EventCount fakeAllocationWait;
-    auto fakeAllocationWaitKey = fakeAllocationWait.prepareWait();
+    folly::EventCount joinWait;
+    auto joinWaitKey = joinWait.prepareWait();
     folly::EventCount taskPauseWait;
     auto taskPauseWaitKey = taskPauseWait.prepareWait();
 
-    const auto aggregationMemoryUsage = 32L << 20;
-    const auto fakeAllocationSize =
-        kMemoryCapacity - aggregationMemoryUsage + 1;
+    const auto fakeAllocationSize = kMemoryCapacity - (32L << 20);
 
     std::atomic<bool> injectAllocationOnce{true};
     fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
       if (!injectAllocationOnce.exchange(false)) {
         return TestAllocation{};
       }
-      fakeAllocationWait.wait(fakeAllocationWaitKey);
       auto buffer = op->pool()->allocate(fakeAllocationSize);
+      joinWait.notify();
+      // Wait for pause to be triggered.
+      taskPauseWait.wait(taskPauseWaitKey);
       return TestAllocation{op->pool(), buffer, fakeAllocationSize};
     });
 
-    std::atomic<bool> injectAggregationByOnce{true};
+    std::atomic<bool> injectJoinOnce{true};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::addInput",
         std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "Aggregation") {
-            return;
-          }
-          if (op->pool()->capacity() < aggregationMemoryUsage) {
+          if (op->operatorType() != "HashBuild") {
             return;
           }
-          if (!injectAggregationByOnce.exchange(false)) {
+          if (!injectJoinOnce.exchange(false)) {
             return;
           }
-          fakeAllocationWait.notify();
-          // Wait for pause to be triggered.
-          taskPauseWait.wait(taskPauseWaitKey);
+          joinWait.wait(joinWaitKey);
         })));
 
     SCOPED_TESTVALUE_SET(
@@ -857,1400 +796,69 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimFromAggregation) {
         std::function<void(Task*)>(
             ([&](Task* /*unused*/) { taskPauseWait.notify(); })));
 
-    std::thread aggregationThread([&]() {
+    std::thread joinThread([&]() {
+      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+      core::PlanNodeId joinNodeId;
       auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .spillDirectory(spillDirectory->path)
-              .config(core::QueryConfig::kSpillEnabled, "true")
-              .config(core::QueryConfig::kAggregationSpillEnabled, "true")
-              .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
-              .queryCtx(aggregationQueryCtx)
-              .plan(PlanBuilder()
+          newQueryBuilder()
+              .queryCtx(joinQueryCtx)
+              .serialExecution(isSerialExecutionMode_)
+              .plan(PlanBuilder(planNodeIdGenerator)
                         .values(vectors)
-                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                        .planNode())
-              .assertResults(
-                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
-      auto stats = task->taskStats().pipelineStats;
-      ASSERT_GT(stats[0].operatorStats[1].spilledBytes, 0);
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-
-    aggregationThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimFromAggregationOnNoMoreInput) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-  for (bool sameQuery : {false, true}) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
-    if (sameQuery) {
-      aggregationQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      aggregationQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    std::atomic<bool> fakeAllocationBlocked{true};
-    folly::EventCount fakeAllocationWait;
-
-    std::atomic<MemoryPool*> injectedPool{nullptr};
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      fakeAllocationWait.await([&]() { return !fakeAllocationBlocked.load(); });
-      EXPECT_TRUE(injectedPool != nullptr);
-      const auto fakeAllocationSize =
-          kMemoryCapacity - injectedPool.load()->reservedBytes() + 1;
-      return TestAllocation{
-          op->pool(),
-          op->pool()->allocate(fakeAllocationSize),
-          fakeAllocationSize};
-    });
-
-    folly::EventCount taskPauseWait;
-    std::atomic<bool> taskPaused{false};
-    std::atomic<bool> injectNoMoreInputOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::noMoreInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "Aggregation") {
-            return;
-          }
-          if (!injectNoMoreInputOnce.exchange(false)) {
-            return;
-          }
-          injectedPool = op->pool();
-          fakeAllocationBlocked = false;
-          fakeAllocationWait.notifyAll();
-          taskPauseWait.await([&]() { return taskPaused.load(); });
-        })));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Task::requestPauseLocked",
-        std::function<void(Task*)>(([&](Task* /*unused*/) {
-          taskPaused = true;
-          taskPauseWait.notifyAll();
-        })));
-
-    std::thread aggregationThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .spillDirectory(spillDirectory->path)
-              .config(core::QueryConfig::kSpillEnabled, "true")
-              .config(core::QueryConfig::kAggregationSpillEnabled, "true")
-              .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
-              .queryCtx(aggregationQueryCtx)
-              .maxDrivers(1)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                        .planNode())
-              .assertResults(
-                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
-      auto stats = task->taskStats().pipelineStats;
-      ASSERT_GT(stats[0].operatorStats[1].spilledBytes, 0);
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-
-    aggregationThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimFromAggregationDuringOutput) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  int numRows{0};
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-    numRows += vectors.back()->size();
-  }
-  createDuckDbTable(vectors);
-  for (bool sameQuery : {false, true}) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
-    if (sameQuery) {
-      aggregationQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      aggregationQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    std::atomic<bool> fakeAllocationBlocked{true};
-    folly::EventCount fakeAllocationWait;
-
-    std::atomic<MemoryPool*> injectedPool{nullptr};
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      fakeAllocationWait.await([&]() { return !fakeAllocationBlocked.load(); });
-      EXPECT_TRUE(injectedPool != nullptr);
-      const auto fakeAllocationSize =
-          kMemoryCapacity - injectedPool.load()->reservedBytes() + 1;
-      return TestAllocation{
-          op->pool(),
-          op->pool()->allocate(fakeAllocationSize),
-          fakeAllocationSize};
-    });
-
-    folly::EventCount taskPauseWait;
-    std::atomic<bool> taskPaused{false};
-    std::atomic<int> injectGetOutputCount{0};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::getOutput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "Aggregation") {
-            return;
-          }
-          if (!op->testingNoMoreInput()) {
-            return;
-          }
-          if (++injectGetOutputCount != 3) {
-            return;
-          }
-          injectedPool = op->pool();
-          fakeAllocationBlocked = false;
-          fakeAllocationWait.notifyAll();
-          taskPauseWait.await([&]() { return taskPaused.load(); });
-        })));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Task::requestPauseLocked",
-        std::function<void(Task*)>(([&](Task* /*unused*/) {
-          taskPaused = true;
-          taskPauseWait.notifyAll();
-        })));
-
-    std::thread aggregationThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .spillDirectory(spillDirectory->path)
-              .config(core::QueryConfig::kSpillEnabled, "true")
-              .config(core::QueryConfig::kAggregationSpillEnabled, "true")
-              .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
-              .config(
-                  core::QueryConfig::kPreferredOutputBatchRows,
-                  std::to_string(numRows / 10))
-              .maxDrivers(1)
-              .queryCtx(aggregationQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                        .planNode())
-              .assertResults(
-                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
-      auto stats = task->taskStats().pipelineStats;
-      ASSERT_GT(stats[0].operatorStats[1].spilledBytes, 0);
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-
-    aggregationThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimToAggregation) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-  std::vector<bool> sameQueries = {false, true};
-  for (bool sameQuery : sameQueries) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto oldStats = arbitrator_->stats();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
-    if (sameQuery) {
-      aggregationQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      aggregationQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    folly::EventCount aggregationWait;
-    auto aggregationWaitKey = aggregationWait.prepareWait();
-    folly::EventCount taskPauseWait;
-    auto taskPauseWaitKey = taskPauseWait.prepareWait();
-
-    const auto fakeAllocationSize = kMemoryCapacity - (32L << 20);
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      auto buffer = op->pool()->allocate(fakeAllocationSize);
-      aggregationWait.notify();
-      // Wait for pause to be triggered.
-      taskPauseWait.wait(taskPauseWaitKey);
-      return TestAllocation{op->pool(), buffer, fakeAllocationSize};
-    });
-
-    std::atomic<bool> injectAggregationOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "Aggregation") {
-            return;
-          }
-          if (!injectAggregationOnce.exchange(false)) {
-            return;
-          }
-          aggregationWait.wait(aggregationWaitKey);
-        })));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Task::requestPauseLocked",
-        std::function<void(Task*)>(
-            ([&](Task* /*unused*/) { taskPauseWait.notify(); })));
-
-    std::thread aggregationThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(aggregationQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                        .planNode())
-              .assertResults(
-                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-
-    aggregationThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-
-    const auto newStats = arbitrator_->stats();
-    ASSERT_GT(newStats.numReclaimedBytes, oldStats.numReclaimedBytes);
-    ASSERT_GT(newStats.reclaimTimeUs, oldStats.reclaimTimeUs);
-  }
-}
-
-TEST_F(SharedArbitrationTest, reclaimFromCompletedAggregation) {
-  const int numVectors = 2;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-  std::vector<bool> sameQueries = {false, true};
-  for (bool sameQuery : sameQueries) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
-    if (sameQuery) {
-      aggregationQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      aggregationQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    folly::EventCount fakeAllocationWait;
-    auto fakeAllocationWaitKey = fakeAllocationWait.prepareWait();
-
-    const auto fakeAllocationSize = kMemoryCapacity;
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      fakeAllocationWait.wait(fakeAllocationWaitKey);
-      auto buffer = op->pool()->allocate(fakeAllocationSize);
-      return TestAllocation{op->pool(), buffer, fakeAllocationSize};
-    });
-
-    std::thread aggregationThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(aggregationQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                        .planNode())
-              .assertResults(
-                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
-      waitForTaskCompletion(task.get());
-      fakeAllocationWait.notify();
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-
-    aggregationThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimFromJoinBuilder) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-  std::vector<bool> sameQueries = {false, true};
-  for (bool sameQuery : sameQueries) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> joinQueryCtx;
-    if (sameQuery) {
-      joinQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      joinQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    std::atomic_bool fakeAllocationReady{false};
-    folly::EventCount fakeAllocationWait;
-    std::atomic_bool taskPauseDone{false};
-    folly::EventCount taskPauseWait;
-
-    const auto joinMemoryUsage = 32L << 20;
-    const auto fakeAllocationSize = kMemoryCapacity - joinMemoryUsage / 2;
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      fakeAllocationWait.await([&]() { return fakeAllocationReady.load(); });
-      auto buffer = op->pool()->allocate(fakeAllocationSize);
-      return TestAllocation{op->pool(), buffer, fakeAllocationSize};
-    });
-
-    std::atomic<bool> injectAggregationByOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "HashBuild") {
-            return;
-          }
-          if (op->pool()->currentBytes() < joinMemoryUsage) {
-            return;
-          }
-          if (!injectAggregationByOnce.exchange(false)) {
-            return;
-          }
-          fakeAllocationReady.store(true);
-          fakeAllocationWait.notifyAll();
-          // Wait for pause to be triggered.
-          taskPauseWait.await([&]() { return taskPauseDone.load(); });
-        })));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Task::requestPauseLocked",
-        std::function<void(Task*)>(([&](Task* /*unused*/) {
-          taskPauseDone.store(true);
-          taskPauseWait.notifyAll();
-        })));
-
-    // joinQueryCtx and fakeMemoryQueryCtx may be the same and thus share the
-    // same underlying QueryConfig.  We apply the changes here instead of using
-    // the AssertQueryBuilder to avoid a potential race condition caused by
-    // writing the config in the join thread, and reading it in the memThread.
-    std::unordered_map<std::string, std::string> config{
-        {core::QueryConfig::kSpillEnabled, "true"},
-        {core::QueryConfig::kJoinSpillEnabled, "true"},
-        {core::QueryConfig::kJoinSpillPartitionBits, "2"},
-    };
-    joinQueryCtx->testingOverrideConfigUnsafe(std::move(config));
-
-    std::thread aggregationThread([&]() {
-      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .spillDirectory(spillDirectory->path)
-              .queryCtx(joinQueryCtx)
-              .plan(PlanBuilder(planNodeIdGenerator)
-                        .values(vectors)
-                        .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                        .hashJoin(
-                            {"t0"},
-                            {"u0"},
-                            PlanBuilder(planNodeIdGenerator)
-                                .values(vectors)
-                                .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                                .planNode(),
-                            "",
-                            {"t1"},
-                            core::JoinType::kAnti)
-                        .planNode())
-              .assertResults(
-                  "SELECT c1 FROM tmp WHERE c0 NOT IN (SELECT c0 FROM tmp)");
-      auto stats = task->taskStats().pipelineStats;
-      ASSERT_GT(stats[1].operatorStats[2].spilledBytes, 0);
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-
-    aggregationThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimToJoinBuilder) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-  std::vector<bool> sameQueries = {false, true};
-  for (bool sameQuery : sameQueries) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto oldStats = arbitrator_->stats();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> joinQueryCtx;
-    if (sameQuery) {
-      joinQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      joinQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    folly::EventCount joinWait;
-    auto joinWaitKey = joinWait.prepareWait();
-    folly::EventCount taskPauseWait;
-    auto taskPauseWaitKey = taskPauseWait.prepareWait();
-
-    const auto fakeAllocationSize = kMemoryCapacity - (32L << 20);
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      auto buffer = op->pool()->allocate(fakeAllocationSize);
-      joinWait.notify();
-      // Wait for pause to be triggered.
-      taskPauseWait.wait(taskPauseWaitKey);
-      return TestAllocation{op->pool(), buffer, fakeAllocationSize};
-    });
-
-    std::atomic<bool> injectJoinOnce{true};
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "HashBuild") {
-            return;
-          }
-          if (!injectJoinOnce.exchange(false)) {
-            return;
-          }
-          joinWait.wait(joinWaitKey);
-        })));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Task::requestPauseLocked",
-        std::function<void(Task*)>(
-            ([&](Task* /*unused*/) { taskPauseWait.notify(); })));
-
-    std::thread joinThread([&]() {
-      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(joinQueryCtx)
-              .plan(PlanBuilder(planNodeIdGenerator)
-                        .values(vectors)
-                        .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                        .hashJoin(
-                            {"t0"},
-                            {"u0"},
-                            PlanBuilder(planNodeIdGenerator)
-                                .values(vectors)
-                                .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                                .planNode(),
-                            "",
-                            {"t1"},
-                            core::JoinType::kAnti)
-                        .planNode())
-              .assertResults(
-                  "SELECT c1 FROM tmp WHERE c0 NOT IN (SELECT c0 FROM tmp)");
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-
-    joinThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-
-    const auto newStats = arbitrator_->stats();
-    ASSERT_GT(newStats.numReclaimedBytes, oldStats.numReclaimedBytes);
-    ASSERT_GT(newStats.reclaimTimeUs, oldStats.reclaimTimeUs);
-  }
-}
-
-TEST_F(SharedArbitrationTest, reclaimFromCompletedJoinBuilder) {
-  const int numVectors = 2;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-  std::vector<bool> sameQueries = {false, true};
-  for (bool sameQuery : sameQueries) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    const uint64_t numCreatedTasks = Task::numCreatedTasks();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> joinQueryCtx;
-    if (sameQuery) {
-      joinQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      joinQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    folly::EventCount fakeAllocationWait;
-    auto fakeAllocationWaitKey = fakeAllocationWait.prepareWait();
-
-    const auto fakeAllocationSize = kMemoryCapacity;
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      fakeAllocationWait.wait(fakeAllocationWaitKey);
-      auto buffer = op->pool()->allocate(fakeAllocationSize);
-      return TestAllocation{op->pool(), buffer, fakeAllocationSize};
-    });
-
-    std::thread joinThread([&]() {
-      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(joinQueryCtx)
-              .plan(PlanBuilder(planNodeIdGenerator)
-                        .values(vectors)
-                        .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                        .hashJoin(
-                            {"t0"},
-                            {"u0"},
-                            PlanBuilder(planNodeIdGenerator)
-                                .values(vectors)
-                                .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                                .planNode(),
-                            "",
-                            {"t1"},
-                            core::JoinType::kAnti)
-                        .planNode())
-              .assertResults(
-                  "SELECT c1 FROM tmp WHERE c0 NOT IN (SELECT c0 FROM tmp)");
-      waitForTaskCompletion(task.get());
-      task.reset();
-      // Make sure the join query task has been destroyed.
-      waitForAllTasksToBeDeleted(numCreatedTasks + 1, 3'000'000);
-      fakeAllocationWait.notify();
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-
-    joinThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(
-    SharedArbitrationTest,
-    reclaimFromJoinBuilderWithMultiDrivers) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  fuzzerOpts_.vectorSize = 128;
-  fuzzerOpts_.stringVariableLength = false;
-  fuzzerOpts_.stringLength = 512;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  const int numDrivers = 4;
-  createDuckDbTable(vectors);
-  std::vector<bool> sameQueries = {false, true};
-  for (bool sameQuery : sameQueries) {
-    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-        newQueryCtx(kMemoryCapacity);
-    std::shared_ptr<core::QueryCtx> joinQueryCtx;
-    if (sameQuery) {
-      joinQueryCtx = fakeMemoryQueryCtx;
-    } else {
-      joinQueryCtx = newQueryCtx(kMemoryCapacity);
-    }
-
-    folly::EventCount fakeAllocationWait;
-    auto fakeAllocationWaitKey = fakeAllocationWait.prepareWait();
-    folly::EventCount taskPauseWait;
-
-    const auto joinMemoryUsage = 8L << 20;
-    const auto fakeAllocationSize = kMemoryCapacity - joinMemoryUsage / 2;
-
-    std::atomic<bool> injectAllocationOnce{true};
-    fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-      if (!injectAllocationOnce.exchange(false)) {
-        return TestAllocation{};
-      }
-      fakeAllocationWait.wait(fakeAllocationWaitKey);
-      auto buffer = op->pool()->allocate(fakeAllocationSize);
-      return TestAllocation{op->pool(), buffer, fakeAllocationSize};
-    });
-
-    std::atomic<int> injectCount{0};
-    folly::futures::Barrier builderBarrier(numDrivers);
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* op) {
-          if (op->operatorType() != "HashBuild") {
-            return;
-          }
-          // Check all the hash build operators' memory usage instead of
-          // individual operator.
-          if (op->pool()->parent()->currentBytes() < joinMemoryUsage) {
-            return;
-          }
-          if (++injectCount > numDrivers) {
-            return;
-          }
-          auto future = builderBarrier.wait();
-          if (future.wait().value()) {
-            fakeAllocationWait.notify();
-          }
-
-          auto taskPauseWaitKey = taskPauseWait.prepareWait();
-          // Wait for pause to be triggered.
-          taskPauseWait.wait(taskPauseWaitKey);
-        })));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Task::requestPauseLocked",
-        std::function<void(Task*)>(
-            [&](Task* /*unused*/) { taskPauseWait.notifyAll(); }));
-
-    // joinQueryCtx and fakeMemoryQueryCtx may be the same and thus share the
-    // same underlying QueryConfig.  We apply the changes here instead of using
-    // the AssertQueryBuilder to avoid a potential race condition caused by
-    // writing the config in the join thread, and reading it in the memThread.
-    std::unordered_map<std::string, std::string> config{
-        {core::QueryConfig::kSpillEnabled, "true"},
-        {core::QueryConfig::kJoinSpillEnabled, "true"},
-        {core::QueryConfig::kJoinSpillPartitionBits, "2"},
-        // NOTE: set an extreme large value to avoid non-reclaimable
-        // section in test.
-        {core::QueryConfig::kSpillableReservationGrowthPct, "8000"},
-    };
-    joinQueryCtx->testingOverrideConfigUnsafe(std::move(config));
-
-    std::thread joinThread([&]() {
-      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .spillDirectory(spillDirectory->path)
-              .maxDrivers(numDrivers)
-              .queryCtx(joinQueryCtx)
-              .plan(PlanBuilder(planNodeIdGenerator)
-                        .values(vectors, true)
-                        .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                        .hashJoin(
-                            {"t0"},
-                            {"u1"},
-                            PlanBuilder(planNodeIdGenerator)
-                                .values(vectors, true)
-                                .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                                .planNode(),
-                            "",
-                            {"t1"},
-                            core::JoinType::kInner)
-                        .planNode())
-              .assertResults(
-                  "SELECT t.c1 FROM tmp as t, tmp AS u WHERE t.c0 == u.c1");
-      auto stats = task->taskStats().pipelineStats;
-      ASSERT_GT(stats[1].operatorStats[2].spilledBytes, 0);
-    });
-
-    std::thread memThread([&]() {
-      auto task =
-          AssertQueryBuilder(duckDbQueryRunner_)
-              .queryCtx(fakeMemoryQueryCtx)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
-              .assertResults("SELECT * FROM tmp");
-    });
-    joinThread.join();
-    memThread.join();
-    waitForAllTasksToBeDeleted();
-  }
-}
-
-DEBUG_ONLY_TEST_F(
-    SharedArbitrationTest,
-    failedToReclaimFromHashJoinBuildersInNonReclaimableSection) {
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  fuzzerOpts_.vectorSize = 128;
-  fuzzerOpts_.stringVariableLength = false;
-  fuzzerOpts_.stringLength = 512;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  const int numDrivers = 4;
-  createDuckDbTable(vectors);
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-      newQueryCtx(kMemoryCapacity);
-  std::shared_ptr<core::QueryCtx> joinQueryCtx = newQueryCtx(kMemoryCapacity);
-
-  folly::EventCount allocationWait;
-  auto allocationWaitKey = allocationWait.prepareWait();
-  folly::EventCount allocationDoneWait;
-  auto allocationDoneWaitKey = allocationDoneWait.prepareWait();
-
-  const auto joinMemoryUsage = 8L << 20;
-  const auto fakeAllocationSize = kMemoryCapacity - joinMemoryUsage / 2;
-
-  std::atomic<bool> injectAllocationOnce{true};
-  fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-    if (!injectAllocationOnce.exchange(false)) {
-      return TestAllocation{};
-    }
-    allocationWait.wait(allocationWaitKey);
-    EXPECT_ANY_THROW(op->pool()->allocate(fakeAllocationSize));
-    allocationDoneWait.notify();
-    return TestAllocation{};
-  });
-
-  std::atomic<int> injectCount{0};
-  folly::futures::Barrier builderBarrier(numDrivers);
-  folly::futures::Barrier pauseBarrier(numDrivers + 1);
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::addInput",
-      std::function<void(Operator*)>(([&](Operator* op) {
-        if (op->operatorType() != "HashBuild") {
-          return;
-        }
-        // Check all the hash build operators' memory usage instead of
-        // individual operator.
-        if (op->pool()->parent()->currentBytes() < joinMemoryUsage) {
-          return;
-        }
-        if (++injectCount > numDrivers - 1) {
-          return;
-        }
-        if (builderBarrier.wait().get()) {
-          allocationWait.notify();
-        }
-        pauseBarrier.wait();
-      })));
-
-  std::atomic<bool> injectNonReclaimableSectionOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
-      std::function<void(memory::MemoryPoolImpl*)>(
-          ([&](memory::MemoryPoolImpl* pool) {
-            const std::string re(".*HashBuild");
-            if (!RE2::FullMatch(pool->name(), re)) {
-              return;
-            }
-            if (pool->parent()->currentBytes() < joinMemoryUsage) {
-              return;
-            }
-            if (!injectNonReclaimableSectionOnce.exchange(false)) {
-              return;
-            }
-            if (builderBarrier.wait().get()) {
-              allocationWait.notify();
-            }
-            pauseBarrier.wait();
-            // Suspend the driver to simulate the arbitration.
-            pool->reclaimer()->enterArbitration();
-            allocationDoneWait.wait(allocationDoneWaitKey);
-            pool->reclaimer()->leaveArbitration();
-          })));
-
-  std::atomic<bool> injectPauseOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Task::requestPauseLocked",
-      std::function<void(Task*)>([&](Task* /*unused*/) {
-        if (!injectPauseOnce.exchange(false)) {
-          return;
-        }
-        pauseBarrier.wait();
-      }));
-
-  // Verifies that we only trigger the hash build reclaim once.
-  std::atomic<int> numHashBuildReclaims{0};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::reclaim",
-      std::function<void(Operator*)>([&](Operator* /*unused*/) {
-        ++numHashBuildReclaims;
-        ASSERT_EQ(numHashBuildReclaims, 1);
-      }));
-
-  std::thread joinThread([&]() {
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .spillDirectory(spillDirectory->path)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
-            // NOTE: set an extreme large value to avoid non-reclaimable
-            // section in test.
-            .config(core::QueryConfig::kSpillableReservationGrowthPct, "8000")
-            .maxDrivers(numDrivers)
-            .queryCtx(joinQueryCtx)
-            .plan(PlanBuilder(planNodeIdGenerator)
-                      .values(vectors, true)
-                      .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                      .hashJoin(
-                          {"t0"},
-                          {"u1"},
-                          PlanBuilder(planNodeIdGenerator)
-                              .values(vectors, true)
-                              .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                              .planNode(),
-                          "",
-                          {"t1"},
-                          core::JoinType::kInner)
-                      .planNode())
-            .assertResults(
-                "SELECT t.c1 FROM tmp as t, tmp AS u WHERE t.c0 == u.c1");
-    // We expect the spilling is not triggered because of non-reclaimable
-    // section.
-    auto stats = task->taskStats().pipelineStats;
-    ASSERT_EQ(stats[1].operatorStats[2].spilledBytes, 0);
-  });
-
-  std::thread memThread([&]() {
-    AssertQueryBuilder(duckDbQueryRunner_)
-        .queryCtx(fakeMemoryQueryCtx)
-        .plan(PlanBuilder()
-                  .values(vectors)
-                  .addNode([&](std::string id, core::PlanNodePtr input) {
-                    return std::make_shared<FakeMemoryNode>(id, input);
-                  })
-                  .planNode())
-        .assertResults("SELECT * FROM tmp");
-  });
-  joinThread.join();
-  memThread.join();
-  // We only expect to reclaim from one hash build operator once.
-  ASSERT_EQ(numHashBuildReclaims, 1);
-  waitForAllTasksToBeDeleted();
-  ASSERT_EQ(arbitrator_->stats().numNonReclaimableAttempts, 1);
-}
-
-DEBUG_ONLY_TEST_F(
-    SharedArbitrationTest,
-    reclaimFromJoinBuildWaitForTableBuild) {
-  setupMemory(kMemoryCapacity, 0);
-  const int numVectors = 32;
-  std::vector<RowVectorPtr> vectors;
-  fuzzerOpts_.vectorSize = 128;
-  fuzzerOpts_.stringVariableLength = false;
-  fuzzerOpts_.stringLength = 512;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  const int numDrivers = 4;
-  createDuckDbTable(vectors);
-
-  std::shared_ptr<core::QueryCtx> fakeMemoryQueryCtx =
-      newQueryCtx(kMemoryCapacity);
-  std::shared_ptr<core::QueryCtx> joinQueryCtx = newQueryCtx(kMemoryCapacity);
-
-  folly::EventCount fakeAllocationWait;
-  std::atomic<bool> fakeAllocationUnblock{false};
-  std::atomic<bool> injectFakeAllocationOnce{true};
-
-  fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-    if (!injectFakeAllocationOnce.exchange(false)) {
-      return TestAllocation{};
-    }
-    fakeAllocationWait.await([&]() { return fakeAllocationUnblock.load(); });
-    // Set the fake allocation size to trigger memory reclaim.
-    const auto fakeAllocationSize = arbitrator_->stats().freeCapacityBytes +
-        joinQueryCtx->pool()->freeBytes() + 1;
-    return TestAllocation{
-        op->pool(),
-        op->pool()->allocate(fakeAllocationSize),
-        fakeAllocationSize};
-  });
-
-  folly::futures::Barrier builderBarrier(numDrivers);
-  folly::futures::Barrier pauseBarrier(numDrivers + 1);
-  std::atomic<int> addInputInjectCount{0};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal",
-      std::function<void(Driver*)>(([&](Driver* driver) {
-        // Check if the driver is from join query.
-        if (driver->task()->queryCtx()->pool()->name() !=
-            joinQueryCtx->pool()->name()) {
-          return;
-        }
-        // Check if the driver is from the pipeline with hash build.
-        if (driver->driverCtx()->pipelineId != 1) {
-          return;
-        }
-        if (++addInputInjectCount > numDrivers - 1) {
-          return;
-        }
-        if (builderBarrier.wait().get()) {
-          fakeAllocationUnblock = true;
-          fakeAllocationWait.notifyAll();
-        }
-        // Wait for pause to be triggered.
-        pauseBarrier.wait().get();
-      })));
-
-  std::atomic<bool> injectNoMoreInputOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::noMoreInput",
-      std::function<void(Operator*)>(([&](Operator* op) {
-        if (op->operatorType() != "HashBuild") {
-          return;
-        }
-        if (!injectNoMoreInputOnce.exchange(false)) {
-          return;
-        }
-        if (builderBarrier.wait().get()) {
-          fakeAllocationUnblock = true;
-          fakeAllocationWait.notifyAll();
-        }
-        // Wait for pause to be triggered.
-        pauseBarrier.wait().get();
-      })));
-
-  std::atomic<bool> injectPauseOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Task::requestPauseLocked",
-      std::function<void(Task*)>([&](Task* /*unused*/) {
-        if (!injectPauseOnce.exchange(false)) {
-          return;
-        }
-        pauseBarrier.wait().get();
-      }));
-
-  // Verifies that we only trigger the hash build reclaim once.
-  std::atomic<int> numHashBuildReclaims{0};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::reclaim",
-      std::function<void(Operator*)>(
-          ([&](Operator* /*unused*/) { ++numHashBuildReclaims; })));
-
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  std::thread joinThread([&]() {
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    auto task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .spillDirectory(spillDirectory->path)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
-            // NOTE: set an extreme large value to avoid non-reclaimable
-            // section in test.
-            .config(core::QueryConfig::kSpillableReservationGrowthPct, "8000")
-            .maxDrivers(numDrivers)
-            .queryCtx(joinQueryCtx)
-            .plan(PlanBuilder(planNodeIdGenerator)
-                      .values(vectors, true)
-                      .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                      .hashJoin(
-                          {"t0"},
-                          {"u1"},
-                          PlanBuilder(planNodeIdGenerator)
-                              .values(vectors, true)
-                              .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                              .planNode(),
-                          "",
-                          {"t1"},
-                          core::JoinType::kInner)
-                      .planNode())
-            .assertResults(
-                "SELECT t.c1 FROM tmp as t, tmp AS u WHERE t.c0 == u.c1");
-    // We expect the spilling triggered.
-    auto stats = task->taskStats().pipelineStats;
-    ASSERT_GT(stats[1].operatorStats[2].spilledBytes, 0);
-  });
-
-  std::thread memThread([&]() {
-    AssertQueryBuilder(duckDbQueryRunner_)
-        .queryCtx(fakeMemoryQueryCtx)
-        .plan(PlanBuilder()
-                  .values(vectors)
-                  .addNode([&](std::string id, core::PlanNodePtr input) {
-                    return std::make_shared<FakeMemoryNode>(id, input);
-                  })
-                  .planNode())
-        .assertResults("SELECT * FROM tmp");
-  });
-
-  joinThread.join();
-  memThread.join();
-
-  // We only expect to reclaim from one hash build operator once.
-  ASSERT_EQ(numHashBuildReclaims, 1);
-  waitForAllTasksToBeDeleted();
-}
-
-DEBUG_ONLY_TEST_F(
-    SharedArbitrationTest,
-    arbitrationTriggeredDuringParallelJoinBuild) {
-  const int numVectors = 2;
-  std::vector<RowVectorPtr> vectors;
-  // Build a large vector to trigger memory arbitration.
-  fuzzerOpts_.vectorSize = 10'000;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-
-  std::shared_ptr<core::QueryCtx> joinQueryCtx = newQueryCtx(kMemoryCapacity);
-
-  // Make sure the parallel build has been triggered.
-  std::atomic<bool> parallelBuildTriggered{false};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashTable::parallelJoinBuild",
-      std::function<void(void*)>(
-          [&](void*) { parallelBuildTriggered = true; }));
-
-  // TODO: add driver context to test if the memory allocation is triggered in
-  // driver context or not.
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  AssertQueryBuilder(duckDbQueryRunner_)
-      // Set very low table size threshold to trigger parallel build.
-      .config(
-          core::QueryConfig::kMinTableRowsForParallelJoinBuild,
-          std::to_string(0))
-      // Set multiple hash build drivers to trigger parallel build.
-      .maxDrivers(4)
-      .queryCtx(joinQueryCtx)
-      .plan(PlanBuilder(planNodeIdGenerator)
-                .values(vectors, true)
-                .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                .hashJoin(
-                    {"t0", "t1"},
-                    {"u1", "u0"},
-                    PlanBuilder(planNodeIdGenerator)
-                        .values(vectors, true)
-                        .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                        .planNode(),
-                    "",
-                    {"t1"},
-                    core::JoinType::kInner)
-                .planNode())
-      .assertResults(
-          "SELECT t.c1 FROM tmp as t, tmp AS u WHERE t.c0 == u.c1 AND t.c1 == u.c0");
-  ASSERT_TRUE(parallelBuildTriggered);
-  waitForAllTasksToBeDeleted();
-}
-
-DEBUG_ONLY_TEST_F(
-    SharedArbitrationTest,
-    arbitrationTriggeredByEnsureJoinTableFit) {
-  setupMemory(kMemoryCapacity, 0);
-  const int numVectors = 2;
-  std::vector<RowVectorPtr> vectors;
-  fuzzerOpts_.vectorSize = 10'000;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-
-  std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(kMemoryCapacity);
-  std::shared_ptr<core::QueryCtx> fakeCtx = newQueryCtx(kMemoryCapacity);
-  auto fakePool = fakeCtx->pool()->addLeafChild(
-      "fakePool", true, FakeMemoryReclaimer::create());
-  std::vector<std::unique_ptr<TestAllocation>> injectAllocations;
-  std::atomic<bool> injectAllocationOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::ensureTableFits",
-      std::function<void(HashBuild*)>([&](HashBuild* buildOp) {
-        // Inject the allocation once to ensure the merged table allocation will
-        // trigger memory arbitration.
-        if (!injectAllocationOnce.exchange(false)) {
-          return;
-        }
-        auto* buildPool = buildOp->pool();
-        // Free up available reservation from the leaf build memory pool.
-        uint64_t injectAllocationSize = buildPool->availableReservation();
-        injectAllocations.emplace_back(new TestAllocation{
-            buildPool,
-            buildPool->allocate(injectAllocationSize),
-            injectAllocationSize});
-        // Free up available memory from the system.
-        injectAllocationSize = arbitrator_->stats().freeCapacityBytes +
-            queryCtx->pool()->freeBytes();
-        injectAllocations.emplace_back(new TestAllocation{
-            fakePool.get(),
-            fakePool->allocate(injectAllocationSize),
-            injectAllocationSize});
-      }));
+                        .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
+                        .hashJoin(
+                            {"t0"},
+                            {"u0"},
+                            PlanBuilder(planNodeIdGenerator)
+                                .values(vectors)
+                                .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                                .planNode(),
+                            "",
+                            {"t1"},
+                            core::JoinType::kAnti)
+                        .capturePlanNodeId(joinNodeId)
+                        .planNode())
+              .assertResults(
+                  "SELECT c1 FROM tmp WHERE c0 NOT IN (SELECT c0 FROM tmp)");
+      auto taskStats = exec::toPlanStats(task->taskStats());
+      auto& stats = taskStats.at(joinNodeId);
+      checkOperatorStatsForArbitration(
+          stats, !sameQuery /*expectGlobalArbitration*/);
+    });
 
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashBuild::reclaim",
-      std::function<void(Operator*)>([&](Operator* /*unused*/) {
-        ASSERT_EQ(injectAllocations.size(), 2);
-        for (auto& injectAllocation : injectAllocations) {
-          injectAllocation->free();
-        }
-      }));
+    std::thread memThread([&]() {
+      auto task =
+          newQueryBuilder()
+              .queryCtx(fakeMemoryQueryCtx)
+              .serialExecution(isSerialExecutionMode_)
+              .plan(PlanBuilder()
+                        .values(vectors)
+                        .addNode([&](std::string id, core::PlanNodePtr input) {
+                          return std::make_shared<FakeMemoryNode>(id, input);
+                        })
+                        .planNode())
+              .assertResults("SELECT * FROM tmp");
+    });
 
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  auto task =
-      AssertQueryBuilder(duckDbQueryRunner_)
-          .spillDirectory(spillDirectory->path)
-          .config(core::QueryConfig::kSpillEnabled, "true")
-          .config(core::QueryConfig::kJoinSpillEnabled, "true")
-          .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
-          // Set multiple hash build drivers to trigger parallel build.
-          .maxDrivers(4)
-          .queryCtx(queryCtx)
-          .plan(PlanBuilder(planNodeIdGenerator)
-                    .values(vectors, true)
-                    .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                    .hashJoin(
-                        {"t0", "t1"},
-                        {"u1", "u0"},
-                        PlanBuilder(planNodeIdGenerator)
-                            .values(vectors, true)
-                            .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                            .planNode(),
-                        "",
-                        {"t1"},
-                        core::JoinType::kInner)
-                    .planNode())
-          .assertResults(
-              "SELECT t.c1 FROM tmp as t, tmp AS u WHERE t.c0 == u.c1 AND t.c1 == u.c0");
-  task.reset();
-  waitForAllTasksToBeDeleted();
-  ASSERT_EQ(injectAllocations.size(), 2);
-}
+    joinThread.join();
+    memThread.join();
+    waitForAllTasksToBeDeleted();
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimDuringJoinTableBuild) {
-  setupMemory(kMemoryCapacity, 0);
-  const int numVectors = 2;
-  std::vector<RowVectorPtr> vectors;
-  fuzzerOpts_.vectorSize = 10'000;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    const auto newStats = arbitrator_->stats();
+    ASSERT_GT(newStats.numReclaimedBytes, oldStats.numReclaimedBytes);
+    ASSERT_GT(newStats.reclaimTimeUs, oldStats.reclaimTimeUs);
   }
-  createDuckDbTable(vectors);
-
-  std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(kMemoryCapacity);
-
-  std::atomic<bool> blockTableBuildOpOnce{true};
-  std::atomic<bool> tableBuildBlocked{false};
-  folly::EventCount tableBuildBlockWait;
-  std::atomic<bool> unblockTableBuild{false};
-  folly::EventCount unblockTableBuildWait;
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::HashTable::parallelJoinBuild",
-      std::function<void(MemoryPool*)>(([&](MemoryPool* pool) {
-        if (!blockTableBuildOpOnce.exchange(false)) {
-          return;
-        }
-        tableBuildBlocked = true;
-        tableBuildBlockWait.notifyAll();
-        unblockTableBuildWait.await([&]() { return unblockTableBuild.load(); });
-        void* buffer = pool->allocate(kMemoryCapacity / 4);
-        pool->free(buffer, kMemoryCapacity / 4);
-      })));
-
-  std::thread queryThread([&]() {
-    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    const auto spillDirectory = exec::test::TempDirectoryPath::create();
-    auto task =
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .spillDirectory(spillDirectory->path)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
-            // Set multiple hash build drivers to trigger parallel build.
-            .maxDrivers(4)
-            .queryCtx(queryCtx)
-            .plan(PlanBuilder(planNodeIdGenerator)
-                      .values(vectors, true)
-                      .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
-                      .hashJoin(
-                          {"t0", "t1"},
-                          {"u1", "u0"},
-                          PlanBuilder(planNodeIdGenerator)
-                              .values(vectors, true)
-                              .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
-                              .planNode(),
-                          "",
-                          {"t1"},
-                          core::JoinType::kInner)
-                      .planNode())
-            .assertResults(
-                "SELECT t.c1 FROM tmp as t, tmp AS u WHERE t.c0 == u.c1 AND t.c1 == u.c0");
-  });
-
-  tableBuildBlockWait.await([&]() { return tableBuildBlocked.load(); });
-
-  folly::EventCount taskPauseWait;
-  std::atomic<bool> taskPaused{false};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Task::requestPauseLocked",
-      std::function<void(Task*)>(([&](Task* /*unused*/) {
-        taskPaused = true;
-        taskPauseWait.notifyAll();
-      })));
-
-  std::unique_ptr<TestAllocation> fakeAllocation;
-  std::thread memThread([&]() {
-    std::shared_ptr<core::QueryCtx> fakeCtx = newQueryCtx(kMemoryCapacity);
-    auto fakePool = fakeCtx->pool()->addLeafChild("fakePool");
-    const auto fakeAllocationSize = arbitrator_->stats().freeCapacityBytes +
-        queryCtx->pool()->freeBytes() + 1;
-    VELOX_ASSERT_THROW(
-        fakePool->allocate(fakeAllocationSize), "Exceeded memory pool cap");
-  });
-
-  taskPauseWait.await([&]() { return taskPaused.load(); });
-
-  unblockTableBuild = true;
-  unblockTableBuildWait.notifyAll();
-
-  memThread.join();
-  queryThread.join();
-
-  waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, driverInitTriggeredArbitration) {
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithThreadingModes,
+    driverInitTriggeredArbitration) {
   const int numVectors = 2;
   std::vector<RowVectorPtr> vectors;
   const int vectorSize = 100;
   fuzzerOpts_.vectorSize = vectorSize;
   for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    vectors.push_back(makeRowVector(rowType_, fuzzerOpts_));
   }
   const int expectedResultVectorSize = numVectors * vectorSize;
   const auto expectedVector = makeRowVector(
@@ -2262,12 +870,13 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, driverInitTriggeredArbitration) {
 
   createDuckDbTable(vectors);
   setupMemory(kMemoryCapacity, 0);
-  std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(kMemoryCapacity);
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
   ASSERT_EQ(queryCtx->pool()->capacity(), 0);
   ASSERT_EQ(queryCtx->pool()->maxCapacity(), kMemoryCapacity);
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  AssertQueryBuilder(duckDbQueryRunner_)
+  newQueryBuilder()
       .config(core::QueryConfig::kSpillEnabled, "false")
       .queryCtx(queryCtx)
       .plan(PlanBuilder(planNodeIdGenerator, pool())
@@ -2277,77 +886,26 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, driverInitTriggeredArbitration) {
                 .project({"1+1+4 as t0", "1+3+3 as t1"})
                 .planNode())
       .assertResults(expectedVector);
+  waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, reclaimerStats) {
-  std::vector<RowVectorPtr> vectors;
-  const int vectorSize = 100;
-  fuzzerOpts_.vectorSize = vectorSize;
-  vectors.push_back(newVector());
-
-  createDuckDbTable(vectors);
-  setupMemory(32 * MB, 0);
-  std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(32 * MB);
-  ASSERT_EQ(queryCtx->pool()->capacity(), 0);
-  ASSERT_EQ(queryCtx->pool()->maxCapacity(), 32 * MB);
-  auto additionalCtxLeafPool = queryCtx->pool()->addLeafChild("ctx_leaf");
-  TestAllocation outerAlloc;
-  outerAlloc.buffer = additionalCtxLeafPool->allocate(8 * MB);
-  outerAlloc.pool = additionalCtxLeafPool.get();
-  outerAlloc.size = 8 * MB;
-  fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-    TestAllocation allocation0;
-    TestAllocation allocation1;
-    auto guard = folly::makeGuard([&]() {
-      allocation0.free();
-      allocation1.free();
-    });
-    allocation0.buffer = op->pool()->allocate(16 * MB);
-    allocation0.pool = op->pool();
-    allocation0.size = 16 * MB;
-
-    allocation1.buffer = op->pool()->allocate(16 * MB);
-    allocation1.pool = op->pool();
-    allocation1.size = 16 * MB;
-
-    return TestAllocation{};
-  });
-  fakeOperatorFactory_->setReclaimCallback([&](MemoryPool* /*unused*/,
-                                               uint64_t /*unused*/,
-                                               MemoryReclaimer::Stats& stats) {
-    ++stats.numNonReclaimableAttempts;
-    outerAlloc.free();
-    return true;
-  });
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  AssertQueryBuilder(duckDbQueryRunner_)
-      .queryCtx(queryCtx)
-      .plan(PlanBuilder(planNodeIdGenerator, pool())
-                .values(vectors)
-                .addNode([&](std::string id, core::PlanNodePtr input) {
-                  return std::make_shared<FakeMemoryNode>(id, input);
-                })
-                .planNode())
-      .assertResults(vectors);
-  ASSERT_EQ(arbitrator_->stats().numNonReclaimableAttempts, 1);
-}
-
-DEBUG_ONLY_TEST_F(
-    SharedArbitrationTest,
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithThreadingModes,
     DISABLED_raceBetweenTaskTerminateAndReclaim) {
   setupMemory(kMemoryCapacity, 0);
   const int numVectors = 10;
   std::vector<RowVectorPtr> vectors;
   for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    vectors.push_back(makeRowVector(rowType_, fuzzerOpts_));
   }
   createDuckDbTable(vectors);
 
-  std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(kMemoryCapacity);
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
   ASSERT_EQ(queryCtx->pool()->capacity(), 0);
 
-  // Allocate a large chunk of memory to trigger memory reclaim during the query
-  // execution.
+  // Allocate a large chunk of memory to trigger memory reclaim during the
+  // query execution.
   auto fakeLeafPool = queryCtx->pool()->addLeafChild("fakeLeaf");
   const size_t fakeAllocationSize = kMemoryCapacity / 2;
   TestAllocation fakeAllocation{
@@ -2366,7 +924,7 @@ DEBUG_ONLY_TEST_F(
           return;
         }
         task = values->testingOperatorCtx()->task();
-        MemoryPool* pool = values->pool();
+        memory::MemoryPool* pool = values->pool();
         VELOX_ASSERT_THROW(
             pool->allocate(kMemoryCapacity * 2 / 3),
             "Exceeded memory pool cap");
@@ -2380,7 +938,7 @@ DEBUG_ONLY_TEST_F(
   std::atomic<bool> taskAborted{false};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Operator::MemoryReclaimer::reclaim",
-      std::function<void(MemoryPool*)>(([&](MemoryPool* pool) {
+      std::function<void(memory::MemoryPool*)>(([&](memory::MemoryPool* pool) {
         const std::string re(".*Aggregation");
         if (!RE2::FullMatch(pool->name(), re)) {
           return;
@@ -2395,12 +953,12 @@ DEBUG_ONLY_TEST_F(
   const auto spillDirectory = exec::test::TempDirectoryPath::create();
   std::thread queryThread([&]() {
     VELOX_ASSERT_THROW(
-        AssertQueryBuilder(duckDbQueryRunner_)
+        newQueryBuilder()
             .queryCtx(queryCtx)
-            .spillDirectory(spillDirectory->path)
+            .spillDirectory(spillDirectory->getPath())
             .config(core::QueryConfig::kSpillEnabled, "true")
             .config(core::QueryConfig::kJoinSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
+            .config(core::QueryConfig::kSpillNumPartitionBits, "2")
             .maxDrivers(numDrivers)
             .plan(PlanBuilder()
                       .values(vectors)
@@ -2428,91 +986,28 @@ DEBUG_ONLY_TEST_F(
   waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, raceBetweenMaybeReserveAndTaskAbort) {
-  setupMemory(kMemoryCapacity, 0);
-  const int numVectors = 10;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-
-  auto queryCtx = newQueryCtx(kMemoryCapacity);
-  ASSERT_EQ(queryCtx->pool()->capacity(), 0);
-
-  // Create a fake query to hold some memory to trigger memory arbitration.
-  auto fakeQueryCtx = newQueryCtx(kMemoryCapacity);
-  auto fakeLeafPool = fakeQueryCtx->pool()->addLeafChild(
-      "fakeLeaf", true, FakeMemoryReclaimer::create());
-  TestAllocation fakeAllocation{
-      fakeLeafPool.get(),
-      fakeLeafPool->allocate(kMemoryCapacity / 3),
-      kMemoryCapacity / 3};
-
-  std::unique_ptr<TestAllocation> injectAllocation;
-  std::atomic<bool> injectAllocationOnce{true};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
-      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
-        if (!injectAllocationOnce.exchange(false)) {
-          return;
-        }
-        // The injection memory allocation (with the given size) makes sure that
-        // maybeReserve fails and abort this query itself.
-        const size_t injectAllocationSize =
-            pool->freeBytes() + arbitrator_->stats().freeCapacityBytes;
-        injectAllocation.reset(new TestAllocation{
-            fakeLeafPool.get(),
-            fakeLeafPool->allocate(injectAllocationSize),
-            injectAllocationSize});
-      }));
-
-  const int numDrivers = 1;
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  std::thread queryThread([&]() {
-    VELOX_ASSERT_THROW(
-        AssertQueryBuilder(duckDbQueryRunner_)
-            .queryCtx(queryCtx)
-            .spillDirectory(spillDirectory->path)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillEnabled, "true")
-            .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
-            .maxDrivers(numDrivers)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .localPartition({"c0", "c1"})
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .localPartition(std::vector<std::string>{})
-                      .planNode())
-            .copyResults(pool()),
-        "Exceeded memory pool cap");
-  });
-
-  queryThread.join();
-  fakeAllocation.free();
-  injectAllocation->free();
-  waitForAllTasksToBeDeleted();
-}
-
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, asyncArbitratonFromNonDriverContext) {
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithParallelExecutionModeOnly,
+    asyncArbitratonFromNonDriverContext) {
   setupMemory(kMemoryCapacity, 0);
   const int numVectors = 10;
   std::vector<RowVectorPtr> vectors;
   for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    vectors.push_back(makeRowVector(rowType_, fuzzerOpts_));
   }
   createDuckDbTable(vectors);
-  std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(kMemoryCapacity);
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
   ASSERT_EQ(queryCtx->pool()->capacity(), 0);
 
   folly::EventCount aggregationAllocationWait;
   std::atomic<bool> aggregationAllocationOnce{true};
   folly::EventCount aggregationAllocationUnblockWait;
   std::atomic<bool> aggregationAllocationUnblocked{false};
-  std::atomic<MemoryPool*> injectPool{nullptr};
+  std::atomic<memory::MemoryPool*> injectPool{nullptr};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe",
-      std::function<void(MemoryPool*)>(([&](MemoryPool* pool) {
+      std::function<void(memory::MemoryPool*)>(([&](memory::MemoryPool* pool) {
         const std::string re(".*Aggregation");
         if (!RE2::FullMatch(pool->name(), re)) {
           return;
@@ -2531,12 +1026,12 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, asyncArbitratonFromNonDriverContext) {
   const auto spillDirectory = exec::test::TempDirectoryPath::create();
   std::shared_ptr<Task> task;
   std::thread queryThread([&]() {
-    task = AssertQueryBuilder(duckDbQueryRunner_)
+    task = newQueryBuilder()
                .queryCtx(queryCtx)
-               .spillDirectory(spillDirectory->path)
+               .spillDirectory(spillDirectory->getPath())
                .config(core::QueryConfig::kSpillEnabled, "true")
                .config(core::QueryConfig::kJoinSpillEnabled, "true")
-               .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
+               .config(core::QueryConfig::kSpillNumPartitionBits, "2")
                .plan(PlanBuilder()
                          .values(vectors)
                          .localPartition({"c0", "c1"})
@@ -2551,8 +1046,8 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, asyncArbitratonFromNonDriverContext) {
       [&]() { return !aggregationAllocationOnce.load(); });
   ASSERT_TRUE(injectPool != nullptr);
 
-  // Trigger the memory arbitration with memory pool whose associated driver is
-  // running on driver thread.
+  // Trigger the memory arbitration with memory pool whose associated driver
+  // is running on driver thread.
   const size_t fakeAllocationSize = arbitrator_->stats().freeCapacityBytes / 2;
   TestAllocation fakeAllocation = {
       injectPool.load(),
@@ -2569,152 +1064,105 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, asyncArbitratonFromNonDriverContext) {
   waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(
-    SharedArbitrationTest,
-    allocationMemoryFromNonSpillMemoryPoolUnderArbitration) {
-  setupMemory(kMemoryCapacity, 0);
-  const int numVectors = 10;
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
-  }
-  createDuckDbTable(vectors);
-  std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(kMemoryCapacity);
-  ASSERT_EQ(queryCtx->pool()->capacity(), 0);
-
-  std::atomic<bool> aggregationMaybeReserveInjectionOnce{true};
-  std::atomic<MemoryPool*> injectPool{nullptr};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
-      std::function<void(MemoryPool*)>(([&](MemoryPool* pool) {
-        if (!aggregationMaybeReserveInjectionOnce.exchange(false)) {
-          return;
-        }
-        if (pool->currentBytes() == 0) {
-          return;
-        }
-        injectPool = pool;
-        VELOX_ASSERT_THROW(
-            pool->allocate(kMemoryCapacity - pool->reservedBytes() / 2),
-            "Exceeded memory pool cap");
-      })));
-
-  std::atomic<bool> nonSpillMemoryPoolChecked{false};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Task::requestPauseLocked",
-      std::function<void(Task*)>(([&](Task* /*unused*/) {
-        VELOX_ASSERT_THROW(
-            injectPool.load()->allocate(20L << 20),
-            "Unexpected non-spilling memory reservation");
-        nonSpillMemoryPoolChecked = true;
-      })));
-
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-  AssertQueryBuilder(duckDbQueryRunner_)
-      .queryCtx(queryCtx)
-      .spillDirectory(spillDirectory->path)
-      .config(core::QueryConfig::kSpillEnabled, "true")
-      .config(core::QueryConfig::kJoinSpillEnabled, "true")
-      .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
-      .plan(PlanBuilder()
-                .values(vectors)
-                .localPartition({"c0", "c1"})
-                .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                .localPartition(std::vector<std::string>{})
-                .planNode())
-      .assertResults("SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
-
-  waitForAllTasksToBeDeleted();
-
-  ASSERT_TRUE(injectPool != nullptr);
-  ASSERT_TRUE(nonSpillMemoryPoolChecked);
-}
-
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, arbitrationFromTableWriter) {
-  setupMemory(kMemoryCapacity, 0);
-
-  VectorFuzzer::Options options;
-  const int batchSize = 1000;
-  options.vectorSize = batchSize;
-  VectorFuzzer fuzzer(options, pool());
-  const int numBatches = 10;
+DEBUG_ONLY_TEST_P(SharedArbitrationTestWithThreadingModes, runtimeStats) {
+  const uint64_t memoryCapacity = 128 * MB;
+  setupMemory(memoryCapacity);
+  fuzzerOpts_.vectorSize = 1000;
+  fuzzerOpts_.stringLength = 1024;
+  fuzzerOpts_.stringVariableLength = false;
+  VectorFuzzer fuzzer(fuzzerOpts_, pool());
   std::vector<RowVectorPtr> vectors;
   int numRows{0};
-  for (int i = 0; i < numBatches; ++i) {
-    numRows += batchSize;
-    vectors.push_back(fuzzer.fuzzRow(rowType_));
+  for (int i = 0; i < 10; ++i) {
+    vectors.push_back(fuzzer.fuzzInputRow(rowType_));
+    numRows += vectors.back()->size();
   }
 
-  createDuckDbTable(vectors);
-
-  std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(kMemoryCapacity);
-  ASSERT_EQ(queryCtx->pool()->capacity(), 0);
-
-  std::atomic<bool> injectArbitrationOnce{true};
+  std::atomic<int> outputCount{0};
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe",
-      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
-        const std::string dictPoolRe(".*dictionary");
-        const std::string generalPoolRe(".*general");
-        const std::string compressionPoolRe(".*compression");
-        if (!RE2::FullMatch(pool->name(), dictPoolRe) &&
-            !RE2::FullMatch(pool->name(), generalPoolRe) &&
-            !RE2::FullMatch(pool->name(), compressionPoolRe)) {
-          return;
-        }
-        if (pool->currentBytes() == 0) {
-          return;
-        }
-        if (!injectArbitrationOnce.exchange(false)) {
-          return;
-        }
-        const auto fakeAllocationSize =
-            arbitrator_->stats().maxCapacityBytes - pool->currentBytes();
-        VELOX_ASSERT_THROW(
-            pool->allocate(fakeAllocationSize), "Exceeded memory pool");
-      }));
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const facebook::velox::exec::Values*)>(
+          ([&](const facebook::velox::exec::Values* values) {
+            if (outputCount++ != 5) {
+              return;
+            }
+            const auto fakeAllocationSize =
+                arbitrator_->stats().maxCapacityBytes -
+                values->pool()->capacity() + 1;
+            void* buffer = values->pool()->allocate(fakeAllocationSize);
+            values->pool()->free(buffer, fakeAllocationSize);
+          })));
 
-  auto outputDirectory = TempDirectoryPath::create();
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto outputDirectory = TempDirectoryPath::create();
+  const auto queryCtx =
+      newQueryCtx(memoryManager_.get(), executor_.get(), memoryCapacity);
   auto writerPlan =
       PlanBuilder()
           .values(vectors)
-          .tableWrite(outputDirectory->path)
-          .project({TableWriteTraits::rowCountColumnName()})
+          .tableWrite(outputDirectory->getPath())
           .singleAggregation(
               {},
               {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())})
           .planNode();
-
-  AssertQueryBuilder(duckDbQueryRunner_)
-      .queryCtx(queryCtx)
-      .spillDirectory(outputDirectory->path)
-      .config(core::QueryConfig::kSpillEnabled, "true")
-      .config(core::QueryConfig::kJoinSpillEnabled, "true")
-      .config(core::QueryConfig::kJoinSpillPartitionBits, "2")
-      .plan(std::move(writerPlan))
-      .assertResults(fmt::format("SELECT {}", numRows));
-
-  ASSERT_EQ(arbitrator_->stats().numFailures, 1);
+  {
+    const std::shared_ptr<Task> task =
+        newQueryBuilder()
+            .queryCtx(queryCtx)
+            .maxDrivers(1)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, "true")
+            .config(core::QueryConfig::kWriterSpillEnabled, "true")
+            // Set 0 file writer flush threshold to always trigger flush in
+            // test.
+            .config(core::QueryConfig::kWriterFlushThresholdBytes, "0")
+            // Set stripe size to extreme large to avoid writer internal
+            // triggered flush.
+            .connectorSessionProperty(
+                kHiveConnectorId,
+                connector::hive::HiveConfig::kOrcWriterMaxStripeSizeSession,
+                "1GB")
+            .connectorSessionProperty(
+                kHiveConnectorId,
+                connector::hive::HiveConfig::
+                    kOrcWriterMaxDictionaryMemorySession,
+                "1GB")
+            .plan(std::move(writerPlan))
+            .assertResults(fmt::format("SELECT {}", numRows));
+
+    auto stats = task->taskStats().pipelineStats.front().operatorStats;
+    // TableWrite Operator's stripeSize runtime stats would be updated twice:
+    // - Values Operator's memory allocation triggers TableWrite's memory
+    // reclaim, which triggers data flush.
+    // - TableWrite Operator's close would trigger flush.
+    ASSERT_EQ(stats[1].runtimeStats["stripeSize"].count, 2);
+    // Values Operator won't be set stripeSize in its runtimeStats.
+    ASSERT_EQ(stats[0].runtimeStats["stripeSize"].count, 0);
+  }
+  waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(SharedArbitrationTest, arbitrateMemoryFromOtherOperator) {
+DEBUG_ONLY_TEST_P(
+    SharedArbitrationTestWithParallelExecutionModeOnly,
+    arbitrateMemoryFromOtherOperator) {
   setupMemory(kMemoryCapacity, 0);
   const int numVectors = 10;
   std::vector<RowVectorPtr> vectors;
   for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    vectors.push_back(makeRowVector(rowType_, fuzzerOpts_));
   }
   createDuckDbTable(vectors);
 
   for (bool sameDriver : {false, true}) {
     SCOPED_TRACE(fmt::format("sameDriver {}", sameDriver));
-    std::shared_ptr<core::QueryCtx> queryCtx = newQueryCtx(kMemoryCapacity);
+    std::shared_ptr<core::QueryCtx> queryCtx =
+        newQueryCtx(memoryManager_.get(), executor_.get(), kMemoryCapacity);
     ASSERT_EQ(queryCtx->pool()->capacity(), 0);
 
     std::atomic<bool> injectAllocationOnce{true};
     const int initialBufferLen = 1 << 20;
     std::atomic<void*> buffer{nullptr};
-    std::atomic<MemoryPool*> bufferPool{nullptr};
+    std::atomic<memory::MemoryPool*> bufferPool{nullptr};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Values::getOutput",
         std::function<void(const exec::Values*)>(
@@ -2735,7 +1183,7 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, arbitrateMemoryFromOtherOperator) {
               if (!RE2::FullMatch(pool->name(), re)) {
                 return;
               }
-              if (pool->root()->currentBytes() == 0) {
+              if (pool->root()->usedBytes() == 0) {
                 return;
               }
               if (!injectReallocateOnce.exchange(false)) {
@@ -2752,24 +1200,27 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, arbitrateMemoryFromOtherOperator) {
             })));
 
     std::shared_ptr<Task> task;
+    core::PlanNodeId aggregationNodeId;
     std::thread queryThread([&]() {
       if (sameDriver) {
-        task = AssertQueryBuilder(duckDbQueryRunner_)
+        task = newQueryBuilder()
                    .queryCtx(queryCtx)
                    .plan(PlanBuilder()
                              .values(vectors)
                              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                             .capturePlanNodeId(aggregationNodeId)
                              .localPartition(std::vector<std::string>{})
                              .planNode())
                    .assertResults(
                        "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
       } else {
-        task = AssertQueryBuilder(duckDbQueryRunner_)
+        task = newQueryBuilder()
                    .queryCtx(queryCtx)
                    .plan(PlanBuilder()
                              .values(vectors)
                              .localPartition({"c0", "c1"})
                              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                             .capturePlanNodeId(aggregationNodeId)
                              .planNode())
                    .assertResults(
                        "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
@@ -2777,6 +1228,10 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, arbitrateMemoryFromOtherOperator) {
     });
 
     queryThread.join();
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& aggNodeStats = taskStats.at(aggregationNodeId);
+    checkOperatorStatsForArbitration(
+        aggNodeStats, false /*expectGlobalArbitration*/);
     ASSERT_TRUE(buffer != nullptr);
     ASSERT_TRUE(bufferPool != nullptr);
     bufferPool.load()->free(buffer, initialBufferLen);
@@ -2786,141 +1241,212 @@ DEBUG_ONLY_TEST_F(SharedArbitrationTest, arbitrateMemoryFromOtherOperator) {
   }
 }
 
-TEST_F(SharedArbitrationTest, concurrentArbitration) {
+TEST_P(
+    SharedArbitrationTestWithParallelExecutionModeOnly,
+    concurrentArbitration) {
+  // Tries to replicate an actual workload by concurrently running multiple
+  // query shapes that support spilling (and hence can be forced to abort or
+  // spill by the arbitrator). Also adds an element of randomness by randomly
+  // keeping completed tasks alive (zombie tasks) hence holding on to some
+  // memory. Ensures that arbitration is engaged under memory contention and
+  // failed queries only have errors related to memory or arbitration.
   FLAGS_velox_suppress_memory_capacity_exceeding_error_message = true;
   const int numVectors = 8;
   std::vector<RowVectorPtr> vectors;
   fuzzerOpts_.vectorSize = 32;
   fuzzerOpts_.stringVariableLength = false;
   fuzzerOpts_.stringLength = 32;
+  vectors.reserve(numVectors);
   for (int i = 0; i < numVectors; ++i) {
-    vectors.push_back(newVector());
+    vectors.push_back(makeRowVector(rowType_, fuzzerOpts_));
   }
   const int numDrivers = 4;
-  createDuckDbTable(vectors);
-
-  const auto queryPlan =
-      PlanBuilder()
-          .values(vectors, true)
-          .addNode([&](std::string id, core::PlanNodePtr input) {
-            return std::make_shared<FakeMemoryNode>(id, input);
-          })
-          .planNode();
-  const std::string referenceSQL = "SELECT * FROM tmp";
-
-  std::atomic<bool> stopped{false};
-
-  std::mutex mutex;
-  std::vector<std::shared_ptr<core::QueryCtx>> queries;
-  std::deque<std::shared_ptr<Task>> zombieTasks;
-
-  fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
-    if (folly::Random::oneIn(4)) {
-      auto task = op->testingOperatorCtx()->driverCtx()->task;
-      if (folly::Random::oneIn(3)) {
-        task->requestAbort();
-      } else {
-        task->requestYield();
-      }
+  const auto expectedWriteResult = runWriteTask(
+                                       vectors,
+                                       nullptr,
+                                       isSerialExecutionMode_,
+                                       numDrivers,
+                                       pool(),
+                                       kHiveConnectorId,
+                                       false)
+                                       .data;
+  const auto expectedJoinResult =
+      runHashJoinTask(
+          vectors, nullptr, isSerialExecutionMode_, numDrivers, pool(), false)
+          .data;
+  const auto expectedOrderResult =
+      runOrderByTask(
+          vectors, nullptr, isSerialExecutionMode_, numDrivers, pool(), false)
+          .data;
+  const auto expectedRowNumberResult =
+      runRowNumberTask(
+          vectors, nullptr, isSerialExecutionMode_, numDrivers, pool(), false)
+          .data;
+  const auto expectedTopNResult =
+      runTopNTask(
+          vectors, nullptr, isSerialExecutionMode_, numDrivers, pool(), false)
+          .data;
+
+  struct {
+    uint64_t totalCapacity;
+    uint64_t queryCapacity;
+
+    std::string debugString() const {
+      return fmt::format(
+          "totalCapacity = {}, queryCapacity = {}.",
+          succinctBytes(totalCapacity),
+          succinctBytes(queryCapacity));
     }
-    const size_t allocationSize = std::max(
-        kMemoryCapacity / 16, folly::Random::rand32() % kMemoryCapacity);
-    auto buffer = op->pool()->allocate(allocationSize);
-    return TestAllocation{op->pool(), buffer, allocationSize};
-  });
-  fakeOperatorFactory_->setMaxDrivers(numDrivers);
-  const std::string injectReclaimErrorMessage("Inject reclaim failure");
-  fakeOperatorFactory_->setReclaimCallback(
-      [&](MemoryPool* /*unused*/,
-          uint64_t /*unused*/,
-          MemoryReclaimer::Stats& /*unused*/) {
-        if (folly::Random::oneIn(10)) {
-          VELOX_FAIL(injectReclaimErrorMessage);
-        }
-        return false;
-      });
-
-  const int numThreads = 30;
-  const int maxNumZombieTasks = 128;
-  std::vector<std::thread> queryThreads;
-  for (int i = 0; i < numThreads; ++i) {
-    queryThreads.emplace_back([&, i]() {
-      DuckDbQueryRunner duckDbQueryRunner;
-      folly::Random::DefaultGenerator rng;
-      rng.seed(i);
-      while (!stopped) {
-        std::shared_ptr<core::QueryCtx> query;
-        {
-          std::lock_guard<std::mutex> l(mutex);
-          if (queries.empty()) {
-            queries.emplace_back(newQueryCtx());
-          }
-          const int index = folly::Random::rand32() % queries.size();
-          query = queries[index];
-        }
+  } testSettings[] = {
+      {16 * MB, 128 * MB}, {128 * MB, 16 * MB}, {128 * MB, 128 * MB}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto totalCapacity = testData.totalCapacity;
+    const auto queryCapacity = testData.queryCapacity;
+    setupMemory(totalCapacity);
+
+    std::mutex mutex;
+    std::vector<std::shared_ptr<core::QueryCtx>> queries;
+    std::deque<std::shared_ptr<Task>> zombieTasks;
+
+    const int numThreads = 32;
+    const int maxNumZombieTasks = 8;
+    std::vector<std::thread> queryThreads;
+    queryThreads.reserve(numThreads);
+    TestScopedAbortInjection testScopedAbortInjection(10, numThreads);
+    for (int i = 0; i < numThreads; ++i) {
+      queryThreads.emplace_back([&, i]() {
         std::shared_ptr<Task> task;
         try {
-          task = AssertQueryBuilder(duckDbQueryRunner)
-                     .queryCtx(query)
-                     .plan(PlanBuilder()
-                               .values(vectors)
-                               .addNode([&](std::string id,
-                                            core::PlanNodePtr input) {
-                                 return std::make_shared<FakeMemoryNode>(
-                                     id, input);
-                               })
-                               .planNode())
-                     .assertResults("SELECT * FROM tmp");
+          auto queryCtx =
+              newQueryCtx(memoryManager_.get(), executor_.get(), queryCapacity);
+          if (i == 0) {
+            // Write task contains aggregate node, which does not support
+            // multithread aggregation type resolver, so make sure it is built
+            // in a single thread.
+            task = runWriteTask(
+                       vectors,
+                       queryCtx,
+                       isSerialExecutionMode_,
+                       numDrivers,
+                       pool(),
+                       kHiveConnectorId,
+                       true,
+                       expectedWriteResult)
+                       .task;
+          } else if ((i % 4) == 0) {
+            task = runHashJoinTask(
+                       vectors,
+                       queryCtx,
+                       isSerialExecutionMode_,
+                       numDrivers,
+                       pool(),
+                       true,
+                       expectedJoinResult)
+                       .task;
+          } else if ((i % 4) == 1) {
+            task = runOrderByTask(
+                       vectors,
+                       queryCtx,
+                       isSerialExecutionMode_,
+                       numDrivers,
+                       pool(),
+                       true,
+                       expectedOrderResult)
+                       .task;
+          } else if ((i % 4) == 2) {
+            task = runRowNumberTask(
+                       vectors,
+                       queryCtx,
+                       isSerialExecutionMode_,
+                       numDrivers,
+                       pool(),
+                       true,
+                       expectedRowNumberResult)
+                       .task;
+          } else {
+            task = runTopNTask(
+                       vectors,
+                       queryCtx,
+                       isSerialExecutionMode_,
+                       numDrivers,
+                       pool(),
+                       true,
+                       expectedTopNResult)
+                       .task;
+          }
         } catch (const VeloxException& e) {
-          continue;
+          if (e.errorCode() != error_code::kMemCapExceeded.c_str() &&
+              e.errorCode() != error_code::kMemAborted.c_str() &&
+              e.errorCode() != error_code::kMemAllocError.c_str() &&
+              (e.message() != "Aborted for external error")) {
+            std::rethrow_exception(std::current_exception());
+          }
         }
+
         std::lock_guard<std::mutex> l(mutex);
-        zombieTasks.emplace_back(std::move(task));
+        if (folly::Random().oneIn(3)) {
+          zombieTasks.emplace_back(std::move(task));
+        }
         while (zombieTasks.size() > maxNumZombieTasks) {
           zombieTasks.pop_front();
         }
-      }
-    });
-  }
+      });
+    }
 
-  const int maxNumQueries = 64;
-  std::thread controlThread([&]() {
-    folly::Random::DefaultGenerator rng;
-    rng.seed(1000);
-    while (!stopped) {
-      std::shared_ptr<core::QueryCtx> queryToDelete;
-      {
-        std::lock_guard<std::mutex> l(mutex);
-        if (queries.empty() ||
-            ((queries.size() < maxNumQueries) &&
-             folly::Random::oneIn(4, rng))) {
-          queries.emplace_back(newQueryCtx());
-        } else {
-          const int deleteIndex = folly::Random::rand32(rng) % queries.size();
-          queryToDelete = queries[deleteIndex];
-          queries.erase(queries.begin() + deleteIndex);
-        }
-      }
-      std::this_thread::sleep_for(std::chrono::microseconds(5));
+    for (auto& queryThread : queryThreads) {
+      queryThread.join();
     }
-  });
+    zombieTasks.clear();
+    waitForAllTasksToBeDeleted();
+    ASSERT_GT(arbitrator_->stats().numRequests, 0);
+  }
+}
 
-  std::this_thread::sleep_for(std::chrono::seconds(5));
-  stopped = true;
+TEST_P(SharedArbitrationTestWithThreadingModes, reserveReleaseCounters) {
+  for (int i = 0; i < 37; ++i) {
+    folly::Random::DefaultGenerator rng(i);
+    auto numRootPools = folly::Random::rand32(rng) % 11 + 3;
+    std::vector<std::thread> threads;
+    threads.reserve(numRootPools);
+    std::mutex mutex;
+    setupMemory(kMemoryCapacity, 0);
+    {
+      std::vector<std::shared_ptr<core::QueryCtx>> queries;
+      queries.reserve(numRootPools);
+      for (int j = 0; j < numRootPools; ++j) {
+        threads.emplace_back([&]() {
+          {
+            std::lock_guard<std::mutex> l(mutex);
+            queries.emplace_back(
+                newQueryCtx(memoryManager_.get(), executor_.get()));
+          }
+        });
+      }
 
-  for (auto& queryThread : queryThreads) {
-    queryThread.join();
+      for (auto& queryThread : threads) {
+        queryThread.join();
+      }
+      ASSERT_EQ(arbitrator_->stats().numShrinks, 0);
+    }
+    ASSERT_EQ(arbitrator_->stats().numShrinks, numRootPools);
   }
-  controlThread.join();
 }
 
-// TODO: add more tests.
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    SharedArbitrationTest,
+    SharedArbitrationTestWithParallelExecutionModeOnly,
+    testing::ValuesIn(std::vector<TestParam>{{false}}));
 
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    SharedArbitrationTest,
+    SharedArbitrationTestWithThreadingModes,
+    testing::ValuesIn(std::vector<TestParam>{{false}, {true}}));
 } // namespace facebook::velox::memory
 
 int main(int argc, char** argv) {
-  folly::SingletonVault::singleton()->registrationComplete();
   testing::InitGoogleTest(&argc, argv);
-
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/common/memory/tests/StreamArenaTest.cpp b/velox/common/memory/tests/StreamArenaTest.cpp
index 7d4ee844b8623..3cafe734a320f 100644
--- a/velox/common/memory/tests/StreamArenaTest.cpp
+++ b/velox/common/memory/tests/StreamArenaTest.cpp
@@ -28,29 +28,24 @@ class StreamArenaTest : public testing::Test {
  protected:
   void SetUp() override {
     constexpr uint64_t kMaxMappedMemory = 64 << 20;
-    MmapAllocator::Options options;
-    options.capacity = kMaxMappedMemory;
-    mmapAllocator_ = std::make_shared<MmapAllocator>(options);
-    MemoryAllocator::setDefaultInstance(mmapAllocator_.get());
-    memoryManager_ = std::make_unique<MemoryManager>(MemoryManagerOptions{
-        .capacity = kMaxMappedMemory,
-        .allocator = MemoryAllocator::getInstance()});
+    MemoryManagerOptions options;
+    options.allocatorCapacity = kMaxMappedMemory;
+    options.useMmapAllocator = true;
+    memoryManager_ = std::make_unique<MemoryManager>(options);
+    mmapAllocator_ = static_cast<MmapAllocator*>(memoryManager_->allocator());
     pool_ = memoryManager_->addLeafPool("ByteStreamTest");
     rng_.seed(124);
   }
 
-  void TearDown() override {
-    MmapAllocator::testingDestroyInstance();
-    MemoryAllocator::setDefaultInstance(nullptr);
-  }
+  void TearDown() override {}
 
   std::unique_ptr<StreamArena> newArena() {
     return std::make_unique<StreamArena>(pool_.get());
   }
 
   folly::Random::DefaultGenerator rng_;
-  std::shared_ptr<MmapAllocator> mmapAllocator_;
   std::unique_ptr<MemoryManager> memoryManager_;
+  MmapAllocator* mmapAllocator_;
   std::shared_ptr<memory::MemoryPool> pool_;
 };
 
@@ -107,7 +102,7 @@ TEST_F(StreamArenaTest, newRange) {
     auto arena = newArena();
     ByteRange range;
     for (int i = 0; i < testData.requestRangeSizes.size(); ++i) {
-      arena->newRange(testData.requestRangeSizes[i], &range);
+      arena->newRange(testData.requestRangeSizes[i], nullptr, &range);
       ASSERT_EQ(range.size, testData.expectedRangeSizes[i]) << range.toString();
       ASSERT_EQ(range.position, 0);
       ASSERT_TRUE(range.buffer != nullptr);
@@ -135,18 +130,18 @@ TEST_F(StreamArenaTest, randomRange) {
     if (folly::Random::oneIn(4)) {
       const int requestSize =
           1 + folly::Random::rand32() % (2 * AllocationTraits::kPageSize);
-      arena->newTinyRange(requestSize, &range);
+      arena->newTinyRange(requestSize, nullptr, &range);
       ASSERT_EQ(range.size, requestSize);
     } else if (folly::Random::oneIn(3)) {
       const int requestSize =
           AllocationTraits::pageBytes(pool_->largestSizeClass()) +
           (folly::Random::rand32() % (4 << 20));
-      arena->newRange(requestSize, &range);
+      arena->newRange(requestSize, nullptr, &range);
       ASSERT_EQ(AllocationTraits::roundUpPageBytes(requestSize), range.size);
     } else {
       const int requestSize =
           1 + folly::Random::rand32() % pool_->largestSizeClass();
-      arena->newRange(requestSize, &range);
+      arena->newRange(requestSize, nullptr, &range);
       ASSERT_LE(range.size, AllocationTraits::roundUpPageBytes(requestSize));
     }
     ASSERT_EQ(range.position, 0);
@@ -158,8 +153,9 @@ TEST_F(StreamArenaTest, error) {
   auto arena = newArena();
   ByteRange range;
   VELOX_ASSERT_THROW(
-      arena->newTinyRange(0, &range),
+      arena->newTinyRange(0, nullptr, &range),
       "StreamArena::newTinyRange can't be zero length");
   VELOX_ASSERT_THROW(
-      arena->newRange(0, &range), "StreamArena::newRange can't be zero length");
+      arena->newRange(0, nullptr, &range),
+      "StreamArena::newRange can't be zero length");
 }
diff --git a/velox/common/process/CMakeLists.txt b/velox/common/process/CMakeLists.txt
index 22182ed58f120..0cebd335cb982 100644
--- a/velox/common/process/CMakeLists.txt
+++ b/velox/common/process/CMakeLists.txt
@@ -12,12 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_process ProcessBase.cpp StackTrace.cpp ThreadDebugInfo.cpp
-                          TraceContext.cpp)
+velox_add_library(
+  velox_process
+  ProcessBase.cpp
+  Profiler.cpp
+  StackTrace.cpp
+  ThreadDebugInfo.cpp
+  TraceContext.cpp
+  TraceHistory.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_process
-  PUBLIC velox_flag_definitions Folly::folly
+  PUBLIC velox_file velox_flag_definitions Folly::folly
   PRIVATE fmt::fmt gflags::gflags glog::glog)
 
 if(${VELOX_BUILD_TESTING})
diff --git a/velox/common/process/ProcessBase.h b/velox/common/process/ProcessBase.h
index 990e7a86855e3..34edd6d14676f 100644
--- a/velox/common/process/ProcessBase.h
+++ b/velox/common/process/ProcessBase.h
@@ -18,51 +18,36 @@
 
 #include <pthread.h>
 #include <sys/types.h>
+#include <cstdint>
 #include <string>
 #include <vector>
 
-namespace facebook {
-namespace velox {
-namespace process {
+namespace facebook::velox::process {
 
-/**
- * Current executable's name.
- */
+/// Current executable's name.
 std::string getAppName();
 
-/**
- * This machine'a name.
- */
+/// This machine'a name.
 std::string getHostName();
 
-/**
- * Process identifier.
- */
+/// Process identifier.
 pid_t getProcessId();
 
-/**
- * Current thread's identifier.
- */
+/// Current thread's identifier.
 pthread_t getThreadId();
 
-/**
- * Get current working directory.
- */
+/// Get current working directory.
 std::string getCurrentDirectory();
 
-/**
- * Returns elapsed CPU nanoseconds on the calling thread
- */
+/// Returns elapsed CPU nanoseconds on the calling thread
 uint64_t threadCpuNanos();
 
-// True if the machine has Intel AVX2 instructions and these are not disabled by
-// flag.
+/// True if the machine has Intel AVX2 instructions and these are not disabled
+/// by flag.
 bool hasAvx2();
 
-// True if the machine has Intel BMI2 instructions and these are not disabled by
-// flag.
+/// True if the machine has Intel BMI2 instructions and these are not disabled
+/// by flag.
 bool hasBmi2();
 
-} // namespace process
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::process
diff --git a/velox/common/process/Profiler.cpp b/velox/common/process/Profiler.cpp
new file mode 100644
index 0000000000000..82a5e83652693
--- /dev/null
+++ b/velox/common/process/Profiler.cpp
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/process/Profiler.h"
+#include "velox/common/file/File.h"
+
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+#include <fcntl.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+DEFINE_string(profiler_tmp_dir, "/tmp", "Writable temp for perf.data");
+
+DEFINE_int32(
+    profiler_check_interval_seconds,
+    60,
+    "Frequency of checking CPU load and turning profiling on/off");
+
+DEFINE_int32(
+    profiler_min_cpu_pct,
+    200,
+    "Minimum CPU percent to justify profile. 100 is one core busy");
+
+DEFINE_int32(
+    profiler_min_sample_seconds,
+    60,
+    "Minimum amount of time at above minimum load to justify producing a result file");
+
+DEFINE_int32(
+    profiler_max_sample_seconds,
+    300,
+    "Number of seconds before switching to new file");
+
+DEFINE_string(profiler_perf_flags, "", "Extra flags for Linux perf");
+
+namespace facebook::velox::process {
+
+tsan_atomic<bool> Profiler::profileStarted_;
+std::thread Profiler::profileThread_;
+std::mutex Profiler::profileMutex_;
+std::shared_ptr<velox::filesystems::FileSystem> Profiler::fileSystem_;
+tsan_atomic<bool> Profiler::isSleeping_;
+std::string Profiler::resultPath_;
+tsan_atomic<bool> Profiler::shouldStop_;
+folly::Promise<bool> Profiler::sleepPromise_;
+tsan_atomic<bool> Profiler::shouldSaveResult_;
+tsan_atomic<int64_t> Profiler::sampleStartTime_;
+int64_t Profiler::cpuAtSampleStart_;
+int64_t Profiler::cpuAtLastCheck_;
+std::function<void()> Profiler::startExtra_;
+std::function<std::string()> Profiler::extraReport_;
+
+namespace {
+std::string hostname;
+
+// Check that paths do not have shell escapes.
+void checkSafe(const std::string& str) {
+  if (strchr(str.c_str(), '`') != nullptr ||
+      strchr(str.c_str(), '$') != nullptr) {
+    LOG(ERROR) << "Unsafe path " << str << ". Exiting.";
+    ::exit(1);
+  }
+}
+
+void testWritable(const std::string& dir) {
+  auto testPath = fmt::format("{}/test", dir);
+  int32_t fd =
+      open(testPath.c_str(), O_RDWR | O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO);
+  if (fd < 0) {
+    LOG(ERROR) << "Can't open " << testPath << " for write errno=" << errno;
+    return;
+  }
+  if (4 != write(fd, "test", 4)) {
+    LOG(ERROR) << "Can't write to " << testPath << " errno=" << errno;
+  }
+  close(fd);
+}
+
+// Returns user+system cpu seconds from getrusage()
+int64_t cpuSeconds() {
+  struct rusage ru;
+  getrusage(RUSAGE_SELF, &ru);
+  return ru.ru_utime.tv_sec + ru.ru_stime.tv_sec;
+}
+
+int64_t nowSeconds() {
+  struct timeval tv;
+  struct timezone tz;
+  gettimeofday(&tv, &tz);
+  return tv.tv_sec;
+}
+
+std::string timeString(time_t seconds) {
+  struct tm tm;
+  localtime_r(&seconds, &tm);
+  char temp[100];
+  strftime(temp, sizeof(temp), "%Y-%m-%d_%H:%M:%S", &tm);
+  return std::string(temp);
+}
+} // namespace
+
+void Profiler::copyToResult(const std::string* data) {
+  char* buffer;
+  int32_t resultSize;
+  std::string temp;
+  if (data) {
+    buffer = const_cast<char*>(data->data());
+    resultSize = std::min<int32_t>(data->size(), 400000);
+  } else {
+    testWritable(FLAGS_profiler_tmp_dir);
+    auto reportFile = fmt::format("{}/perf", FLAGS_profiler_tmp_dir);
+    int32_t fd = open(reportFile.c_str(), O_RDONLY);
+    if (fd < 0) {
+      LOG(ERROR) << "PROFILE: << Could not open report file at " << reportFile;
+      return;
+    }
+    auto bufferSize = 400000;
+    temp.resize(400000);
+    buffer = temp.data();
+    resultSize = ::read(fd, buffer, bufferSize);
+    close(fd);
+  }
+
+  std::string dt = timeString(nowSeconds());
+  auto target =
+      fmt::format("{}/prof-{}-{}-{}", resultPath_, hostname, dt, getpid());
+  try {
+    try {
+      fileSystem_->remove(target);
+    } catch (const std::exception&) {
+      // ignore
+    }
+    auto out = fileSystem_->openFileForWrite(target);
+    auto now = nowSeconds();
+    auto elapsed = (now - sampleStartTime_);
+    auto cpu = cpuSeconds();
+    out->append(fmt::format(
+        "Profile from {} to {} at {}% CPU\n\n",
+
+        timeString(sampleStartTime_),
+        timeString(now),
+        100 * (cpu - cpuAtSampleStart_) / std::max<int64_t>(1, elapsed)));
+    out->append(std::string_view(buffer, resultSize));
+    if (extraReport_) {
+      std::string extra = extraReport_();
+      out->append(std::string_view(extra.data(), extra.size()));
+    }
+    out->flush();
+    LOG(INFO) << "PROFILE: Produced result " << target << " " << resultSize
+              << " bytes";
+  } catch (const std::exception& e) {
+    LOG(ERROR) << "PROFILE: Error opening/writing " << target << ":"
+               << e.what();
+  }
+}
+
+void Profiler::makeProfileDir(std::string path) {
+  try {
+    fileSystem_->mkdir(path);
+  } catch (const std::exception& e) {
+    LOG(ERROR) << "PROFILE: Failed to create directory " << path << ":"
+               << e.what();
+  }
+}
+
+std::thread Profiler::startSample() {
+  if (startExtra_) {
+    startExtra_();
+  }
+  std::thread thread([&]() {
+    // We run perf under a shell because running it with fork + rexec
+    // and killing it with SIGINT produces a corrupt perf.data
+    // file. The perf.data file generated when called via system() is
+    // good, though. Unsolved mystery.
+    system(fmt::format(
+               "(cd {}; /usr/bin/perf record --pid {} {};"
+               "perf report --sort symbol > perf ;"
+               "sed --in-place 's/          / /'g perf;"
+               "sed --in-place 's/        / /'g perf; date) "
+               ">> {}/perftrace 2>>{}/perftrace2",
+               FLAGS_profiler_tmp_dir,
+               getpid(),
+               FLAGS_profiler_perf_flags,
+               FLAGS_profiler_tmp_dir,
+               FLAGS_profiler_tmp_dir)
+               .c_str()); // NOLINT
+    if (shouldSaveResult_) {
+      copyToResult();
+    }
+  });
+
+  cpuAtSampleStart_ = cpuSeconds();
+  sampleStartTime_ = nowSeconds();
+  return thread;
+}
+
+bool Profiler::interruptibleSleep(int32_t seconds) {
+  sleepPromise_ = folly::Promise<bool>();
+
+  folly::SemiFuture<bool> sleepFuture(false);
+  {
+    std::lock_guard<std::mutex> l(profileMutex_);
+    isSleeping_ = true;
+    sleepPromise_ = folly::Promise<bool>();
+    sleepFuture = sleepPromise_.getSemiFuture();
+  }
+  if (!shouldStop_) {
+    try {
+      auto& executor = folly::QueuedImmediateExecutor::instance();
+      std::move(sleepFuture)
+          .via(&executor)
+          .wait((std::chrono::seconds(seconds)));
+    } catch (std::exception&) {
+    }
+  }
+  {
+    std::lock_guard<std::mutex> l(profileMutex_);
+    isSleeping_ = false;
+  }
+
+  return shouldStop_;
+}
+
+void Profiler::stopSample(std::thread systemThread) {
+  LOG(INFO) << "PROFILE: Signalling perf";
+
+  system("killall -2 perf");
+  systemThread.join();
+
+  sampleStartTime_ = 0;
+}
+
+void Profiler::threadFunction() {
+  makeProfileDir(resultPath_);
+  cpuAtLastCheck_ = cpuSeconds();
+  std::thread sampleThread;
+  for (int32_t counter = 0;; ++counter) {
+    if (FLAGS_profiler_min_cpu_pct == 0) {
+      sampleThread = startSample();
+      // First two times sleep for one interval and then five intervals.
+      if (interruptibleSleep(
+              FLAGS_profiler_check_interval_seconds * (counter < 2 ? 1 : 5))) {
+        break;
+      }
+      stopSample(std::move(sampleThread)); // NOLINT
+    } else {
+      int64_t now = nowSeconds();
+      int64_t cpuNow = cpuSeconds();
+      int64_t lastPct = counter == 0 ? 0
+                                     : (100 * (cpuNow - cpuAtLastCheck_) /
+                                        FLAGS_profiler_check_interval_seconds);
+      if (sampleStartTime_ != 0) {
+        if (now - sampleStartTime_ > FLAGS_profiler_max_sample_seconds) {
+          shouldSaveResult_ = true;
+          stopSample(std::move(sampleThread)); // NOLINT
+        }
+      }
+      if (lastPct > FLAGS_profiler_min_cpu_pct) {
+        if (sampleStartTime_ == 0) {
+          sampleThread = startSample();
+        }
+      } else {
+        if (sampleStartTime_ != 0) {
+          shouldSaveResult_ =
+              now - sampleStartTime_ >= FLAGS_profiler_min_sample_seconds;
+          stopSample(std::move(sampleThread)); // NOLINT
+        }
+      }
+      cpuAtLastCheck_ = cpuNow;
+      if (interruptibleSleep(FLAGS_profiler_check_interval_seconds)) {
+        break;
+      }
+    }
+  }
+  if (sampleStartTime_ != 0) {
+    auto now = nowSeconds();
+    shouldSaveResult_ =
+        now - sampleStartTime_ >= FLAGS_profiler_min_sample_seconds;
+    stopSample(std::move(sampleThread)); // NOLINT
+  }
+}
+
+bool Profiler::isRunning() {
+  std::lock_guard<std::mutex> l(profileMutex_);
+  return profileStarted_;
+}
+
+void Profiler::start(
+    const std::string& path,
+    std::function<void()> extraStart,
+    std::function<std::string()> extraReport) {
+  {
+#if !defined(linux)
+    VELOX_FAIL("Profiler is only available for Linux");
+#endif
+    resultPath_ = path;
+    startExtra_ = extraStart;
+    extraReport_ = extraReport;
+    std::lock_guard<std::mutex> l(profileMutex_);
+    if (profileStarted_) {
+      return;
+    }
+    profileStarted_ = true;
+  }
+  checkSafe(FLAGS_profiler_tmp_dir);
+  checkSafe(FLAGS_profiler_perf_flags);
+  char temp[1000] = {};
+  gethostname(temp, sizeof(temp) - 1);
+  hostname = std::string(temp);
+  fileSystem_ = velox::filesystems::getFileSystem(path, nullptr);
+  if (!fileSystem_) {
+    LOG(ERROR) << "PROFILE: Failed to find file system for " << path
+               << ". Profiler not started.";
+    return;
+  }
+  makeProfileDir(path);
+  atexit(Profiler::stop);
+  LOG(INFO) << "PROFILE: Starting profiling to " << path;
+  profileThread_ = std::thread([]() { threadFunction(); });
+}
+
+void Profiler::stop() {
+  {
+    std::lock_guard<std::mutex> l(profileMutex_);
+    shouldStop_ = true;
+    if (!profileStarted_) {
+      return;
+    }
+    if (isSleeping_) {
+      sleepPromise_.setValue(true);
+    }
+  }
+  profileThread_.join();
+  {
+    std::lock_guard<std::mutex> l(profileMutex_);
+    profileStarted_ = false;
+  }
+  LOG(INFO) << "Stopped profiling";
+}
+
+} // namespace facebook::velox::process
diff --git a/velox/common/process/Profiler.h b/velox/common/process/Profiler.h
new file mode 100644
index 0000000000000..7626946e8b944
--- /dev/null
+++ b/velox/common/process/Profiler.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/futures/Future.h>
+#include <folly/futures/Promise.h>
+#include <string>
+#include "velox/common/file/FileSystems.h"
+
+DECLARE_int32(profiler_check_interval_seconds);
+DECLARE_int32(profiler_min_cpu_pct);
+DECLARE_int32(profiler_min_sample_seconds);
+DECLARE_int32(profiler_max_sample_seconds);
+
+namespace facebook::velox::process {
+
+class Profiler {
+ public:
+  /// Starts periodic production of perf reports.
+  static void start(
+      const std::string& path,
+      std::function<void()> extraStart = nullptr,
+      std::function<std::string()> extraReport = nullptr);
+
+  // Stops profiling background associated threads. Threads are stopped on
+  // return.
+  static void stop();
+
+  static bool isRunning();
+
+ private:
+  static void copyToResult(const std::string* result = nullptr);
+  static void makeProfileDir(std::string path);
+  static std::thread startSample();
+  // Returns after 'seconds' of wall time or sooner if interrupted by stop().
+  static bool interruptibleSleep(int32_t seconds);
+  static void stopSample(std::thread thread);
+  static void threadFunction();
+
+  static tsan_atomic<bool> profileStarted_;
+  static std::thread profileThread_;
+  static std::mutex profileMutex_;
+  static std::shared_ptr<velox::filesystems::FileSystem> fileSystem_;
+  static tsan_atomic<bool> isSleeping_;
+  static tsan_atomic<bool> shouldStop_;
+  static folly::Promise<bool> sleepPromise_;
+
+  // Directory where results are deposited. Results have unique names within
+  // this.
+  static std::string resultPath_;
+
+  // indicates if the results of the the profile should be saved at stop.
+  static tsan_atomic<bool> shouldSaveResult_;
+
+  // Time of starting the profile. Seconds from epoch.
+  static tsan_atomic<int64_t> sampleStartTime_;
+
+  // CPU time at start of profile.
+  static int64_t cpuAtSampleStart_;
+
+  // CPU time at last periodic check.
+  static int64_t cpuAtLastCheck_;
+
+  static std::function<void()> startExtra_;
+  static std::function<std::string()> extraReport_;
+};
+
+} // namespace facebook::velox::process
diff --git a/velox/common/process/ThreadDebugInfo.cpp b/velox/common/process/ThreadDebugInfo.cpp
index 75db6ed5ac102..ae681a2dcc436 100644
--- a/velox/common/process/ThreadDebugInfo.cpp
+++ b/velox/common/process/ThreadDebugInfo.cpp
@@ -42,24 +42,32 @@ static void printCurrentQueryId() {
     const char* msg2 = " Task Id= ";
     write(STDERR_FILENO, msg2, strlen(msg2));
     write(STDERR_FILENO, info->taskId_.c_str(), info->taskId_.length());
+    if (!fatalSignalProcessed && info->callback_) {
+      fatalSignalProcessed = true;
+      info->callback_();
+    }
   }
   write(STDERR_FILENO, "\n", 1);
-
-  if (!fatalSignalProcessed && info->callback_) {
-    fatalSignalProcessed = true;
-    info->callback_();
-  }
 }
 
 const ThreadDebugInfo* GetThreadDebugInfo() {
   return threadDebugInfo;
 }
+
 ScopedThreadDebugInfo::ScopedThreadDebugInfo(
-    const ThreadDebugInfo& localDebugInfo) {
-  prevThreadDebugInfo_ = threadDebugInfo;
+    const ThreadDebugInfo& localDebugInfo)
+    : prevThreadDebugInfo_(threadDebugInfo) {
   threadDebugInfo = &localDebugInfo;
 }
 
+ScopedThreadDebugInfo::ScopedThreadDebugInfo(
+    const ThreadDebugInfo* localDebugInfo)
+    : prevThreadDebugInfo_(threadDebugInfo) {
+  if (localDebugInfo != nullptr) {
+    threadDebugInfo = localDebugInfo;
+  }
+}
+
 ScopedThreadDebugInfo::~ScopedThreadDebugInfo() {
   threadDebugInfo = prevThreadDebugInfo_;
 }
diff --git a/velox/common/process/ThreadDebugInfo.h b/velox/common/process/ThreadDebugInfo.h
index 058a8a3c8e683..4b3145553106a 100644
--- a/velox/common/process/ThreadDebugInfo.h
+++ b/velox/common/process/ThreadDebugInfo.h
@@ -34,6 +34,9 @@ struct ThreadDebugInfo {
 class ScopedThreadDebugInfo {
  public:
   explicit ScopedThreadDebugInfo(const ThreadDebugInfo& localDebugInfo);
+
+  explicit ScopedThreadDebugInfo(const ThreadDebugInfo* localDebugInfo);
+
   ~ScopedThreadDebugInfo();
 
  private:
@@ -47,9 +50,9 @@ const ThreadDebugInfo* GetThreadDebugInfo();
 
 // Install a signal handler to dump thread local debug information. This should
 // be called before calling folly::symbolizer::installFatalSignalCallbacks()
-// which is usually called at startup via folly::Init(). This is just a default
-// implementation but you can install your own signal handler. Make sure to
-// install one at the start of your program.
+// which is usually called at startup via folly::Init init{}. This is just a
+// default implementation but you can install your own signal handler. Make sure
+// to install one at the start of your program.
 void addDefaultFatalSignalHandler();
 
 } // namespace facebook::velox::process
diff --git a/velox/common/process/ThreadLocalRegistry.h b/velox/common/process/ThreadLocalRegistry.h
new file mode 100644
index 0000000000000..a69b92da02699
--- /dev/null
+++ b/velox/common/process/ThreadLocalRegistry.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <list>
+#include <memory>
+#include <mutex>
+
+namespace facebook::velox::process {
+
+/// A registry for keeping static thread local objects of type T.  Similar to
+/// folly::ThreadLocal but a little bit more efficient in terms of performance
+/// and memory usage, because we do not support thread local with lexical scope.
+///
+/// NOTE: only one instance of ThreadLocalRegistry<T> can be created with each
+/// T.
+template <typename T>
+class ThreadLocalRegistry {
+ public:
+  class Reference;
+
+  /// Access values from all threads.  Takes a global lock and should be used
+  /// with caution.
+  template <typename F>
+  void forAllValues(F f) {
+    std::lock_guard<std::mutex> entriesLock(entriesMutex_);
+    for (auto& entry : entries_) {
+      std::lock_guard<std::mutex> lk(entry->mutex);
+      f(entry->value);
+    }
+  }
+
+ private:
+  struct Entry {
+    std::mutex mutex;
+    T value;
+  };
+
+  std::list<std::unique_ptr<Entry>> entries_;
+  std::mutex entriesMutex_;
+};
+
+/// Reference to one thread local value.  Should be stored in thread local
+/// memory.
+template <typename T>
+class ThreadLocalRegistry<T>::Reference {
+ public:
+  explicit Reference(const std::shared_ptr<ThreadLocalRegistry>& registry)
+      : registry_(registry) {
+    auto entry = std::make_unique<Entry>();
+    std::lock_guard<std::mutex> lk(registry_->entriesMutex_);
+    iterator_ =
+        registry_->entries_.insert(registry_->entries_.end(), std::move(entry));
+  }
+
+  ~Reference() {
+    std::lock_guard<std::mutex> lk(registry_->entriesMutex_);
+    registry_->entries_.erase(iterator_);
+  }
+
+  /// Obtain the thread local value and process it with the functor `f'.
+  template <typename F>
+  auto withValue(F f) {
+    auto* entry = iterator_->get();
+    std::lock_guard<std::mutex> lk(entry->mutex);
+    return f(entry->value);
+  }
+
+ private:
+  std::shared_ptr<ThreadLocalRegistry> const registry_;
+  typename std::list<std::unique_ptr<Entry>>::iterator iterator_;
+};
+
+} // namespace facebook::velox::process
diff --git a/velox/common/process/TraceContext.cpp b/velox/common/process/TraceContext.cpp
index cad158f48ee78..b0ee5b7240970 100644
--- a/velox/common/process/TraceContext.cpp
+++ b/velox/common/process/TraceContext.cpp
@@ -16,23 +16,34 @@
 
 #include "velox/common/process/TraceContext.h"
 
+#include "velox/common/process/TraceHistory.h"
+
 #include <sstream>
 
 namespace facebook::velox::process {
 
 namespace {
-folly::Synchronized<std::unordered_map<std::string, TraceData>>& traceMap() {
-  static folly::Synchronized<std::unordered_map<std::string, TraceData>>
-      staticTraceMap;
-  return staticTraceMap;
-}
+
+// We use thread local instead lock here since the critical path is on write
+// side.
+auto registry = std::make_shared<TraceContext::Registry>();
+thread_local auto threadLocalTraceData =
+    std::make_shared<TraceContext::Registry::Reference>(registry);
+
 } // namespace
 
 TraceContext::TraceContext(std::string label, bool isTemporary)
     : label_(std::move(label)),
       enterTime_(std::chrono::steady_clock::now()),
-      isTemporary_(isTemporary) {
-  traceMap().withWLock([&](auto& counts) {
+      isTemporary_(isTemporary),
+      traceData_(threadLocalTraceData) {
+  TraceHistory::push([&](auto& entry) {
+    entry.time = enterTime_;
+    entry.file = __FILE__;
+    entry.line = __LINE__;
+    snprintf(entry.label, entry.kLabelCapacity, "%s", label_.c_str());
+  });
+  traceData_->withValue([&](auto& counts) {
     auto& data = counts[label_];
     ++data.numThreads;
     if (data.numThreads == 1) {
@@ -43,17 +54,18 @@ TraceContext::TraceContext(std::string label, bool isTemporary)
 }
 
 TraceContext::~TraceContext() {
-  traceMap().withWLock([&](auto& counts) {
-    auto& data = counts[label_];
-    --data.numThreads;
+  traceData_->withValue([&](auto& counts) {
+    auto it = counts.find(label_);
+    auto& data = it->second;
+    if (--data.numThreads == 0 && isTemporary_) {
+      counts.erase(it);
+      return;
+    }
     auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                   std::chrono::steady_clock::now() - enterTime_)
                   .count();
     data.totalMs += ms;
     data.maxMs = std::max<uint64_t>(data.maxMs, ms);
-    if (!data.numThreads && isTemporary_) {
-      counts.erase(label_);
-    }
   });
 }
 
@@ -61,27 +73,39 @@ TraceContext::~TraceContext() {
 std::string TraceContext::statusLine() {
   std::stringstream out;
   auto now = std::chrono::steady_clock::now();
-  traceMap().withRLock([&](auto& counts) {
-    for (auto& pair : counts) {
-      if (pair.second.numThreads) {
-        auto continued = std::chrono::duration_cast<std::chrono::milliseconds>(
-                             now - pair.second.startTime)
-                             .count();
-
-        out << pair.first << "=" << pair.second.numThreads << " entered "
-            << pair.second.numEnters << " avg ms "
-            << (pair.second.totalMs / pair.second.numEnters) << " max ms "
-            << pair.second.maxMs << " continuous for " << continued
-            << std::endl;
-      }
+  auto counts = status();
+  for (auto& [label, data] : counts) {
+    if (data.numThreads > 0) {
+      auto continued = std::chrono::duration_cast<std::chrono::milliseconds>(
+                           now - data.startTime)
+                           .count();
+      out << label << ": numThreads=" << data.numThreads
+          << " numEnters=" << data.numEnters
+          << " avgMs=" << (data.totalMs / data.numEnters)
+          << " maxMs=" << data.maxMs << " continued=" << continued << std::endl;
     }
-  });
+  }
   return out.str();
 }
 
 // static
-std::unordered_map<std::string, TraceData> TraceContext::status() {
-  return traceMap().withRLock([&](auto& map) { return map; });
+folly::F14FastMap<std::string, TraceData> TraceContext::status() {
+  folly::F14FastMap<std::string, TraceData> total;
+  registry->forAllValues([&](auto& counts) {
+    for (auto& [k, v] : counts) {
+      auto& sofar = total[k];
+      if (sofar.numEnters == 0) {
+        sofar.startTime = v.startTime;
+      } else if (v.numEnters > 0) {
+        sofar.startTime = std::min(sofar.startTime, v.startTime);
+      }
+      sofar.numThreads += v.numThreads;
+      sofar.numEnters += v.numEnters;
+      sofar.totalMs += v.totalMs;
+      sofar.maxMs = std::max(sofar.maxMs, v.maxMs);
+    }
+  });
+  return total;
 }
 
 } // namespace facebook::velox::process
diff --git a/velox/common/process/TraceContext.h b/velox/common/process/TraceContext.h
index c3d3a18be1420..6e718515b58d0 100644
--- a/velox/common/process/TraceContext.h
+++ b/velox/common/process/TraceContext.h
@@ -16,11 +16,13 @@
 
 #pragma once
 
+#include "velox/common/process/ThreadLocalRegistry.h"
+
 #include <mutex>
 #include <string>
 #include <unordered_map>
 
-#include <folly/Synchronized.h>
+#include <folly/container/F14Map.h>
 
 namespace facebook::velox::process {
 
@@ -47,6 +49,8 @@ struct TraceData {
 // produces a concise report of what the system is doing at any one
 // time. This is good for diagnosing crashes or hangs which are
 // difficult to figure out from stacks in a core dump.
+//
+// NOTE: TraceContext is not sharable between different threads.
 class TraceContext {
  public:
   // Starts a trace context. isTemporary is false if this is a generic
@@ -56,6 +60,9 @@ class TraceContext {
   // which the record should be dropped once the last thread finishes.
   explicit TraceContext(std::string label, bool isTemporary = false);
 
+  TraceContext(const TraceContext&) = delete;
+  TraceContext& operator=(const TraceContext&) = delete;
+
   ~TraceContext();
 
   // Produces a human readable report of all TraceContexts in existence at the
@@ -63,12 +70,18 @@ class TraceContext {
   static std::string statusLine();
 
   // Returns a copy of the trace status.
-  static std::unordered_map<std::string, TraceData> status();
+  static folly::F14FastMap<std::string, TraceData> status();
+
+  // Implementation detail type.  Made public to be available with
+  // std::make_shared.  Do not use outside this class.
+  using Registry =
+      ThreadLocalRegistry<folly::F14FastMap<std::string, TraceData>>;
 
  private:
   const std::string label_;
   const std::chrono::steady_clock::time_point enterTime_;
   const bool isTemporary_;
+  std::shared_ptr<Registry::Reference> traceData_;
 };
 
 } // namespace facebook::velox::process
diff --git a/velox/common/process/TraceHistory.cpp b/velox/common/process/TraceHistory.cpp
new file mode 100644
index 0000000000000..bf7524590802b
--- /dev/null
+++ b/velox/common/process/TraceHistory.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/process/TraceHistory.h"
+
+#include <folly/system/ThreadId.h>
+
+#include <algorithm>
+
+namespace facebook::velox::process {
+
+namespace {
+auto registry = std::make_shared<ThreadLocalRegistry<TraceHistory>>();
+}
+
+namespace detail {
+thread_local ThreadLocalRegistry<TraceHistory>::Reference traceHistory(
+    registry);
+}
+
+TraceHistory::TraceHistory()
+    : threadId_(std::this_thread::get_id()), osTid_(folly::getOSThreadID()) {}
+
+std::vector<TraceHistory::EntriesWithThreadInfo> TraceHistory::listAll() {
+  std::vector<EntriesWithThreadInfo> results;
+  registry->forAllValues([&](auto& history) {
+    EntriesWithThreadInfo result;
+    result.threadId = history.threadId_;
+    result.osTid = history.osTid_;
+    for (int i = 0; i < kCapacity; ++i) {
+      const int j = (history.index_ + kCapacity - 1 - i) % kCapacity;
+      if (!populated(history.data_[j])) {
+        break;
+      }
+      result.entries.push_back(history.data_[j]);
+    }
+    std::reverse(result.entries.begin(), result.entries.end());
+    results.push_back(std::move(result));
+  });
+  return results;
+}
+
+} // namespace facebook::velox::process
diff --git a/velox/common/process/TraceHistory.h b/velox/common/process/TraceHistory.h
new file mode 100644
index 0000000000000..bcee2cec69d74
--- /dev/null
+++ b/velox/common/process/TraceHistory.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/process/ThreadLocalRegistry.h"
+
+#include <cassert>
+#include <chrono>
+#include <cstdio>
+#include <thread>
+#include <vector>
+
+/// Push an entry to the history ring buffer with a label from format string
+/// (same as printf) and optional arguments.
+#define VELOX_TRACE_HISTORY_PUSH(_format, ...)                             \
+  ::facebook::velox::process::TraceHistory::push([&](auto& entry) {        \
+    entry.time = ::std::chrono::steady_clock::now();                       \
+    entry.file = __FILE__;                                                 \
+    entry.line = __LINE__;                                                 \
+    ::snprintf(entry.label, entry.kLabelCapacity, _format, ##__VA_ARGS__); \
+  })
+
+namespace facebook::velox::process {
+
+class TraceHistory;
+
+namespace detail {
+extern thread_local ThreadLocalRegistry<TraceHistory>::Reference traceHistory;
+}
+
+/// Keep list of labels in a ring buffer that is fixed sized and thread local.
+class TraceHistory {
+ public:
+  TraceHistory();
+
+  /// An entry with tracing information and custom label.
+  struct Entry {
+    std::chrono::steady_clock::time_point time;
+    const char* file;
+    int32_t line;
+
+    static constexpr int kLabelCapacity =
+        64 - sizeof(time) - sizeof(file) - sizeof(line);
+    char label[kLabelCapacity];
+  };
+
+  /// NOTE: usually VELOX_TRACE_HISTORY_PUSH should be used instead of calling
+  /// this function directly.
+  ///
+  /// Add a new entry to the thread local instance.  If there are more than
+  /// `kCapacity' entries, overwrite the oldest ones.  All the mutation on the
+  /// new entry should be done in the functor `init'.
+  template <typename F>
+  static void push(F&& init) {
+    detail::traceHistory.withValue(
+        [init = std::forward<F>(init)](auto& history) {
+          auto& entry = history.data_[history.index_];
+          init(entry);
+          assert(populated(entry));
+          history.index_ = (history.index_ + 1) % kCapacity;
+        });
+  }
+
+  /// All entries in a specific thread.
+  struct EntriesWithThreadInfo {
+    std::thread::id threadId;
+    uint64_t osTid;
+    std::vector<Entry> entries;
+  };
+
+  /// List all entries from all threads.
+  static std::vector<EntriesWithThreadInfo> listAll();
+
+  /// Keep the last `kCapacity' entries per thread.  Must be a power of 2.
+  static constexpr int kCapacity = 16;
+
+ private:
+  static_assert((kCapacity & (kCapacity - 1)) == 0);
+  static_assert(sizeof(Entry) == 64);
+
+  static bool populated(const Entry& entry) {
+    return entry.file != nullptr;
+  }
+
+  alignas(64) Entry data_[kCapacity]{};
+  const std::thread::id threadId_;
+  const uint64_t osTid_;
+  int index_ = 0;
+};
+
+} // namespace facebook::velox::process
diff --git a/velox/common/process/tests/CMakeLists.txt b/velox/common/process/tests/CMakeLists.txt
index d64466568a291..23ef279c21af0 100644
--- a/velox/common/process/tests/CMakeLists.txt
+++ b/velox/common/process/tests/CMakeLists.txt
@@ -12,9 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_process_test TraceContextTest.cpp)
+add_executable(velox_process_test ProfilerTest.cpp ThreadLocalRegistryTest.cpp
+                                  TraceContextTest.cpp TraceHistoryTest.cpp)
 
 add_test(velox_process_test velox_process_test)
 
-target_link_libraries(velox_process_test PRIVATE velox_process fmt::fmt gtest
-                                                 gtest_main)
+target_link_libraries(
+  velox_process_test
+  PRIVATE
+    velox_process
+    fmt::fmt
+    velox_time
+    GTest::gtest
+    GTest::gtest_main)
diff --git a/velox/common/process/tests/ProfilerTest.cpp b/velox/common/process/tests/ProfilerTest.cpp
new file mode 100644
index 0000000000000..788e02ef27d2d
--- /dev/null
+++ b/velox/common/process/tests/ProfilerTest.cpp
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/process/Profiler.h"
+#include <folly/futures/Future.h>
+#include <folly/futures/Promise.h>
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <signal.h>
+#include <thread>
+#include "velox/common/process/TraceContext.h"
+
+using namespace facebook::velox::process;
+using namespace facebook::velox;
+
+namespace {
+int32_t fi(int32_t x) {
+  return x < 2 ? x : fi(x - 1) + fi(x - 2);
+}
+void compute(int32_t seconds) {
+  auto start = getCurrentTimeMs();
+  constexpr int32_t kNumThreads = 10;
+  for (;;) {
+    std::vector<std::thread> threads;
+    threads.reserve(kNumThreads);
+    std::atomic<int32_t> sum = 0;
+    for (int32_t i = 0; i < kNumThreads; ++i) {
+      threads.push_back(std::thread([&]() {
+        sum += fi(40);
+        std::this_thread::sleep_for(std::chrono::milliseconds(3)); // NOLINT
+      }));
+    }
+    for (auto& thread : threads) {
+      thread.join();
+    }
+    LOG(INFO) << "Sum " << sum;
+    if (getCurrentTimeMs() - start > seconds * 1000) {
+      break;
+    }
+  }
+}
+
+} // namespace
+
+TEST(ProfilerTest, basic) {
+#if !defined(linux)
+  return;
+#endif
+  filesystems::registerLocalFileSystem();
+  // We have seconds of busy and idle activity. We set the profiler to
+  // check every second and to trigger after 1s at 200%. A burst of
+  // under 2s is not recorded and a new file is started after every 4s
+  // of cpu busy.
+
+  FLAGS_profiler_check_interval_seconds = 1;
+  FLAGS_profiler_min_cpu_pct = 200;
+  FLAGS_profiler_max_sample_seconds = 4;
+  FLAGS_profiler_max_sample_seconds = 2;
+
+  Profiler::start("/tmp/profilertest");
+  compute(5);
+  std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
+  compute(1);
+  std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
+
+  compute(3);
+  Profiler::stop();
+
+  // We set the profiler to start regardless of load and wait 30s before
+  // producing the next result.
+  FLAGS_profiler_check_interval_seconds = 30;
+  FLAGS_profiler_min_cpu_pct = 0;
+  FLAGS_profiler_min_sample_seconds = 0;
+  Profiler::start("/tmp/profilertest");
+  compute(2);
+  // The test exits during the measurement interval. We expect no
+  // crash on exit if the threads are properly joined.
+}
+
+int main(int argc, char** argv) {
+  // Fork a child process to run all the tests.
+  int32_t pid = fork();
+  if (pid < 0) {
+    LOG(ERROR) << "Failed to fork child";
+    exit(1);
+  }
+  if (pid > 0) {
+    // The parent waits for the child to return. If the child returns
+    // in time, the child's return code is returned. If the child does
+    // not return in time, we return 0 and the test fails silently.
+    std::atomic<bool> timedOut = false;
+    std::atomic<bool> completed = false;
+    auto sleepPromise = folly::Promise<bool>();
+    folly::SemiFuture<bool> sleepFuture(false);
+    sleepFuture = sleepPromise.getSemiFuture();
+    std::thread timer([&]() {
+      try {
+        auto& executor = folly::QueuedImmediateExecutor::instance();
+        // Wait for up to 100 seconds. The test is normally ~20s unless it
+        // hangs.
+        std::move(sleepFuture).via(&executor).wait((std::chrono::seconds(100)));
+      } catch (std::exception&) {
+      }
+      if (completed) {
+        return;
+      }
+      timedOut = true;
+      LOG(INFO) << "Killing the test process for timeout";
+      kill(pid, SIGKILL);
+    });
+
+    int wstatus;
+    int w = waitpid(pid, &wstatus, WUNTRACED | WCONTINUED);
+    LOG(INFO) << "Test completed";
+    completed = true;
+    sleepPromise.setValue(true);
+    timer.join();
+
+    if (timedOut) {
+      return 0;
+    }
+    return WEXITSTATUS(wstatus);
+  }
+
+  testing::InitGoogleTest(&argc, argv);
+  // Signal handler required for ThreadDebugInfoTest
+  folly::Init init(&argc, &argv, false);
+  return RUN_ALL_TESTS();
+  return 0;
+}
diff --git a/velox/common/process/tests/ThreadLocalRegistryTest.cpp b/velox/common/process/tests/ThreadLocalRegistryTest.cpp
new file mode 100644
index 0000000000000..0887f89dd165a
--- /dev/null
+++ b/velox/common/process/tests/ThreadLocalRegistryTest.cpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/process/ThreadLocalRegistry.h"
+
+#include <folly/synchronization/Baton.h>
+#include <folly/synchronization/Latch.h>
+#include <gtest/gtest.h>
+
+#include <atomic>
+
+namespace facebook::velox::process {
+namespace {
+
+template <typename Tag>
+class TestObject {
+ public:
+  static std::atomic_int& count() {
+    static std::atomic_int value;
+    return value;
+  }
+
+  TestObject() : threadId_(std::this_thread::get_id()) {
+    ++count();
+  }
+
+  ~TestObject() {
+    --count();
+  }
+
+  std::thread::id threadId() const {
+    return threadId_;
+  }
+
+ private:
+  const std::thread::id threadId_;
+};
+
+TEST(ThreadLocalRegistryTest, basic) {
+  struct Tag {};
+  using T = TestObject<Tag>;
+  ASSERT_EQ(T::count(), 0);
+  auto registry = std::make_shared<ThreadLocalRegistry<T>>();
+  registry->forAllValues([](const T&) { FAIL(); });
+  thread_local ThreadLocalRegistry<T>::Reference ref(registry);
+  const T* object = ref.withValue([](const T& x) {
+    EXPECT_EQ(T::count(), 1);
+    return &x;
+  });
+  ASSERT_EQ(object->threadId(), std::this_thread::get_id());
+  ref.withValue([&](const T& x) { ASSERT_EQ(&x, object); });
+  int count = 0;
+  registry->forAllValues([&](const T& x) {
+    ++count;
+    ASSERT_EQ(x.threadId(), std::this_thread::get_id());
+  });
+  ASSERT_EQ(count, 1);
+  ASSERT_EQ(T::count(), 1);
+}
+
+TEST(ThreadLocalRegistryTest, multiThread) {
+  struct Tag {};
+  using T = TestObject<Tag>;
+  ASSERT_EQ(T::count(), 0);
+  auto registry = std::make_shared<ThreadLocalRegistry<T>>();
+  constexpr int kNumThreads = 7;
+  std::vector<std::thread> threads;
+  folly::Latch latch(kNumThreads);
+  folly::Baton<> batons[kNumThreads];
+  const T* objects[kNumThreads];
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&, i] {
+      thread_local ThreadLocalRegistry<T>::Reference ref(registry);
+      objects[i] = ref.withValue([](const T& x) { return &x; });
+      latch.count_down();
+      batons[i].wait();
+    });
+  }
+  latch.wait();
+  std::vector<int> indices;
+  registry->forAllValues([&](const T& x) {
+    auto it = std::find(std::begin(objects), std::end(objects), &x);
+    indices.push_back(it - std::begin(objects));
+  });
+  ASSERT_EQ(indices.size(), kNumThreads);
+  std::sort(indices.begin(), indices.end());
+  for (int i = 0; i < kNumThreads; ++i) {
+    ASSERT_EQ(indices[i], i);
+    ASSERT_EQ(objects[i]->threadId(), threads[i].get_id());
+    ASSERT_EQ(T::count(), kNumThreads - i);
+    batons[i].post();
+    threads[i].join();
+  }
+  ASSERT_EQ(T::count(), 0);
+  registry->forAllValues([](const T&) { FAIL(); });
+}
+
+} // namespace
+} // namespace facebook::velox::process
diff --git a/velox/common/process/tests/TraceContextTest.cpp b/velox/common/process/tests/TraceContextTest.cpp
index cfa021432a8a7..130055e568fad 100644
--- a/velox/common/process/tests/TraceContextTest.cpp
+++ b/velox/common/process/tests/TraceContextTest.cpp
@@ -15,33 +15,125 @@
  */
 
 #include "velox/common/process/TraceContext.h"
+#include "velox/common/process/TraceHistory.h"
+
 #include <fmt/format.h>
+#include <folly/futures/Promise.h>
+#include <folly/synchronization/Baton.h>
+#include <folly/synchronization/Latch.h>
 #include <gtest/gtest.h>
+
 #include <thread>
 
-using namespace facebook::velox::process;
+namespace facebook::velox::process {
+namespace {
+
+class TraceContextTest : public testing::Test {
+ public:
+  void SetUp() override {
+    ASSERT_TRUE(TraceContext::status().empty());
+  }
 
-TEST(TraceContextTest, basic) {
-  constexpr int32_t kNumThreads = 10;
+  void TearDown() override {
+    ASSERT_TRUE(TraceContext::status().empty());
+  }
+};
+
+TEST_F(TraceContextTest, basic) {
+  constexpr int kNumThreads = 3;
   std::vector<std::thread> threads;
+  folly::Baton<> batons[2][kNumThreads];
+  folly::Latch latches[2] = {
+      folly::Latch(kNumThreads),
+      folly::Latch(kNumThreads),
+  };
   threads.reserve(kNumThreads);
-  for (int32_t i = 0; i < kNumThreads; ++i) {
-    threads.push_back(std::thread([i]() {
-      TraceContext trace1("process data");
-      TraceContext trace2(fmt::format("Process chunk {}", i), true);
-      std::this_thread::sleep_for(std::chrono::milliseconds(3));
-    }));
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&, i]() {
+      {
+        TraceContext trace1("process data");
+        TraceContext trace2(fmt::format("Process chunk {}", i), true);
+        latches[0].count_down();
+        batons[0][i].wait();
+      }
+      latches[1].count_down();
+      batons[1][i].wait();
+    });
+  }
+  latches[0].wait();
+  auto status = TraceContext::status();
+  ASSERT_EQ(1 + kNumThreads, status.size());
+  ASSERT_EQ(kNumThreads, status.at("process data").numThreads);
+  for (int i = 0; i < kNumThreads; ++i) {
+    ASSERT_EQ(1, status.at(fmt::format("Process chunk {}", i)).numThreads);
   }
-  std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  LOG(INFO) << TraceContext::statusLine();
-  for (auto& thread : threads) {
-    thread.join();
+  for (int i = 0; i < kNumThreads; ++i) {
+    batons[0][i].post();
   }
-  LOG(INFO) << TraceContext::statusLine();
-  // We expect one entry for "process data". The temporary entries
-  // are deleted after the treads complete.
-  auto after = TraceContext::status();
-  EXPECT_EQ(1, after.size());
-  EXPECT_EQ(kNumThreads, after["process data"].numEnters);
-  EXPECT_EQ(0, after["process data"].numThreads);
+  latches[1].wait();
+  status = TraceContext::status();
+  ASSERT_EQ(1, status.size());
+  ASSERT_EQ(0, status.at("process data").numThreads);
+  ASSERT_EQ(kNumThreads, status.at("process data").numEnters);
+  for (int i = 0; i < kNumThreads; ++i) {
+    batons[1][i].post();
+    threads[i].join();
+  }
+}
+
+TEST_F(TraceContextTest, traceHistory) {
+  std::thread([] {
+    TraceContext trace("test");
+    TraceContext trace2(
+        std::string(TraceHistory::Entry::kLabelCapacity + 10, 'x'));
+    auto results = TraceHistory::listAll();
+    ASSERT_EQ(results.size(), 1);
+    ASSERT_EQ(results[0].entries.size(), 2);
+    ASSERT_STREQ(results[0].entries[0].label, "test");
+    ASSERT_EQ(
+        results[0].entries[1].label,
+        std::string(TraceHistory::Entry::kLabelCapacity - 1, 'x'));
+  }).join();
 }
+
+TEST_F(TraceContextTest, transferBetweenThreads) {
+  auto [promise, future] =
+      folly::makePromiseContract<std::unique_ptr<TraceContext>>();
+  folly::Baton<> batons[2];
+  std::chrono::steady_clock::time_point timeLow, timeHigh;
+  std::thread receiver([&, future = std::move(future)]() mutable {
+    auto trace = std::move(future).get(std::chrono::seconds(1));
+    {
+      SCOPE_EXIT {
+        batons[0].post();
+      };
+      auto status = TraceContext::status();
+      ASSERT_EQ(1, status.size());
+      auto& data = status.at("test");
+      ASSERT_EQ(data.numThreads, 1);
+      ASSERT_EQ(data.numEnters, 1);
+      ASSERT_LE(timeLow, data.startTime);
+      ASSERT_LE(data.startTime, timeHigh);
+    }
+    batons[1].wait();
+    auto status = TraceContext::status();
+    ASSERT_EQ(1, status.size());
+    auto& data = status.at("test");
+    ASSERT_EQ(data.numThreads, 1);
+    ASSERT_EQ(data.numEnters, 1);
+    ASSERT_LE(timeLow, data.startTime);
+    ASSERT_LE(data.startTime, timeHigh);
+  });
+  timeLow = std::chrono::steady_clock::now();
+  std::thread([&, promise = std::move(promise)]() mutable {
+    auto trace = std::make_unique<TraceContext>("test");
+    timeHigh = std::chrono::steady_clock::now();
+    promise.setValue(std::move(trace));
+    batons[0].wait();
+  }).join();
+  batons[1].post();
+  receiver.join();
+}
+
+} // namespace
+} // namespace facebook::velox::process
diff --git a/velox/common/process/tests/TraceHistoryTest.cpp b/velox/common/process/tests/TraceHistoryTest.cpp
new file mode 100644
index 0000000000000..754fe6f389c31
--- /dev/null
+++ b/velox/common/process/tests/TraceHistoryTest.cpp
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/process/TraceHistory.h"
+
+#include <fmt/format.h>
+#include <folly/synchronization/Baton.h>
+#include <folly/synchronization/Latch.h>
+#include <gtest/gtest.h>
+
+namespace facebook::velox::process {
+namespace {
+
+class TraceHistoryTest : public testing::Test {
+ public:
+  void SetUp() override {
+    ASSERT_TRUE(TraceHistory::listAll().empty());
+  }
+
+  void TearDown() override {
+    ASSERT_TRUE(TraceHistory::listAll().empty());
+  }
+};
+
+TEST_F(TraceHistoryTest, basic) {
+  std::thread([] {
+    auto timeLow = std::chrono::steady_clock::now();
+    constexpr int kStartLine = __LINE__;
+    for (int i = 0; i < TraceHistory::kCapacity + 10; ++i) {
+      VELOX_TRACE_HISTORY_PUSH("Test %d", i);
+    }
+    auto timeHigh = std::chrono::steady_clock::now();
+    auto results = TraceHistory::listAll();
+    ASSERT_EQ(results.size(), 1);
+    ASSERT_EQ(results[0].threadId, std::this_thread::get_id());
+    ASSERT_EQ(results[0].osTid, folly::getOSThreadID());
+    ASSERT_EQ(results[0].entries.size(), TraceHistory::kCapacity);
+    auto lastTime = timeLow;
+    for (int i = 0; i < TraceHistory::kCapacity; ++i) {
+      auto& entry = results[0].entries[i];
+      ASSERT_EQ(entry.line, kStartLine + 2);
+      ASSERT_STREQ(
+          entry.file + strlen(entry.file) - 20, "TraceHistoryTest.cpp");
+      ASSERT_LE(lastTime, entry.time);
+      lastTime = entry.time;
+      ASSERT_EQ(strncmp(entry.label, "Test ", 5), 0);
+      ASSERT_EQ(atoi(entry.label + 5), i + 10);
+    }
+    ASSERT_LE(lastTime, timeHigh);
+  }).join();
+}
+
+TEST_F(TraceHistoryTest, multiThread) {
+  constexpr int kNumThreads = 3;
+  folly::Latch latch(kNumThreads);
+  folly::Baton<> batons[kNumThreads];
+  std::vector<std::thread> threads;
+  auto timeLow = std::chrono::steady_clock::now();
+  constexpr int kStartLine = __LINE__;
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&, i] {
+      VELOX_TRACE_HISTORY_PUSH("Test");
+      VELOX_TRACE_HISTORY_PUSH("Test %d", i);
+      latch.count_down();
+      batons[i].wait();
+    });
+  }
+  latch.wait();
+  auto timeHigh = std::chrono::steady_clock::now();
+  auto results = TraceHistory::listAll();
+  ASSERT_EQ(results.size(), kNumThreads);
+  for (auto& result : results) {
+    auto threadIndex =
+        std::find_if(
+            threads.begin(),
+            threads.end(),
+            [&](auto& t) { return t.get_id() == result.threadId; }) -
+        threads.begin();
+    ASSERT_EQ(result.entries.size(), 2);
+    ASSERT_EQ(result.entries[0].line, kStartLine + 3);
+    ASSERT_EQ(result.entries[1].line, kStartLine + 4);
+    ASSERT_STREQ(result.entries[0].label, "Test");
+    ASSERT_EQ(result.entries[1].label, fmt::format("Test {}", threadIndex));
+    for (auto& entry : result.entries) {
+      ASSERT_LE(timeLow, entry.time);
+      ASSERT_LE(entry.time, timeHigh);
+      ASSERT_TRUE(entry.file);
+      ASSERT_STREQ(
+          entry.file + strlen(entry.file) - 20, "TraceHistoryTest.cpp");
+    }
+  }
+  for (int i = 0; i < kNumThreads; ++i) {
+    ASSERT_EQ(TraceHistory::listAll().size(), kNumThreads - i);
+    batons[i].post();
+    threads[i].join();
+  }
+}
+
+TEST_F(TraceHistoryTest, largeLabel) {
+  std::thread([] {
+    VELOX_TRACE_HISTORY_PUSH(
+        "%s",
+        std::string(TraceHistory::Entry::kLabelCapacity + 10, 'x').c_str());
+    auto results = TraceHistory::listAll();
+    ASSERT_EQ(results.size(), 1);
+    ASSERT_EQ(results[0].entries.size(), 1);
+    ASSERT_EQ(
+        results[0].entries[0].label,
+        std::string(TraceHistory::Entry::kLabelCapacity - 1, 'x'));
+  }).join();
+}
+
+} // namespace
+} // namespace facebook::velox::process
diff --git a/velox/common/serialization/CMakeLists.txt b/velox/common/serialization/CMakeLists.txt
index 4d5ccaebe7c24..c818597442d2c 100644
--- a/velox/common/serialization/CMakeLists.txt
+++ b/velox/common/serialization/CMakeLists.txt
@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_serialization DeserializationRegistry.cpp)
+velox_add_library(velox_serialization DeserializationRegistry.cpp)
 
-target_link_libraries(velox_serialization PUBLIC velox_exception Folly::folly
-                                                 glog::glog)
+velox_link_libraries(velox_serialization PUBLIC velox_exception Folly::folly
+                                                glog::glog)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/common/serialization/Registry.h b/velox/common/serialization/Registry.h
index 06b51d826d946..a290dd7ecd929 100644
--- a/velox/common/serialization/Registry.h
+++ b/velox/common/serialization/Registry.h
@@ -28,6 +28,7 @@
 
 #include <glog/logging.h>
 #include "folly/Preprocessor.h"
+#include "folly/container/F14Map.h"
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/Metaprogramming.h"
@@ -47,7 +48,7 @@ template <class KeyType, class FunctionSignature>
 class Registry {
  public:
   using Creator = std::function<FunctionSignature>;
-  using CreatorMap = std::unordered_map<KeyType, Creator>;
+  using CreatorMap = folly::F14NodeMap<KeyType, Creator>;
 
   Registry() : Create(creatorMap_) {}
 
diff --git a/velox/common/serialization/Serializable.h b/velox/common/serialization/Serializable.h
index cda8a4593f648..befe526f4b849 100644
--- a/velox/common/serialization/Serializable.h
+++ b/velox/common/serialization/Serializable.h
@@ -21,6 +21,7 @@
 #include "folly/json.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/serialization/DeserializationRegistry.h"
+#include "velox/core/Metaprogramming.h"
 
 namespace facebook {
 namespace velox {
@@ -95,19 +96,27 @@ class ISerializable {
 
   template <
       typename T,
-      typename = std::enable_if_t<has_serialize_type<T>::value>>
-  static folly::dynamic serialize(T& obj) {
+      std::enable_if_t<
+          has_serialize_type<T>::value ||
+          std::is_base_of_v<ISerializable, T>>* = nullptr>
+  static folly::dynamic serialize(const T& obj) {
     return obj.serialize();
   }
 
   template <
       typename T,
-      typename = std::enable_if_t<
-          is_any_of<T, int64_t, double, std::string, bool>::value>>
+      std::enable_if_t<std::is_same_v<T, std::string>>* = nullptr>
   static folly::dynamic serialize(const T& val) {
     return val;
   }
 
+  template <
+      typename T,
+      typename = std::enable_if_t<is_any_of<T, int64_t, double, bool>::value>>
+  static folly::dynamic serialize(T val) {
+    return val;
+  }
+
   static folly::dynamic serialize(int32_t val) {
     return folly::dynamic{(int64_t)val};
   }
@@ -132,7 +141,7 @@ class ISerializable {
   }
 
   template <
-      class T,
+      typename T,
       std::enable_if_t<
           std::is_same_v<T, folly::Optional<typename T::value_type>>>>
   static folly::dynamic serialize(const folly::Optional<T>& val) {
@@ -143,8 +152,8 @@ class ISerializable {
     return serialize(val.value());
   }
 
-  template <class K, class U>
-  static folly::dynamic serialize(const std::map<K, U>& map) {
+  template <typename T, std::enable_if_t<util::is_mappish<T>::value>* = nullptr>
+  static folly::dynamic serialize(const T& map) {
     folly::dynamic keys = folly::dynamic::array;
     folly::dynamic values = folly::dynamic::array;
     for (auto& pair : map) {
@@ -160,11 +169,11 @@ class ISerializable {
   }
 
   template <
-      class T,
+      typename T,
       typename = std::enable_if_t<std::is_base_of_v<ISerializable, T>>>
   static std::shared_ptr<const T> deserialize(
       const folly::dynamic& obj,
-      void* context) {
+      void* context = nullptr) {
     VELOX_USER_CHECK(obj.isObject());
     // use the key to lookup creator and call it.
     // creator generally be a static method in the class.
@@ -192,20 +201,13 @@ class ISerializable {
     return std::dynamic_pointer_cast<const T>(registry.Create(name, obj));
   }
 
-  template <
-      class T,
-      typename = std::enable_if_t<std::is_base_of_v<ISerializable, T>>>
-  static std::shared_ptr<const T> deserialize(const folly::dynamic& obj) {
-    return deserialize<T>(obj, nullptr);
-  }
-
   template <
       typename T,
       typename = std::enable_if_t<has_static_obj_create_type<T>::value>>
   using createReturnType = decltype(T::create(std::declval<folly::dynamic>()));
 
   template <
-      class T,
+      typename T,
       typename = std::enable_if_t<has_static_obj_create_type<T>::value>>
   static createReturnType<T> deserialize(
       const folly::dynamic& obj,
@@ -214,7 +216,7 @@ class ISerializable {
   }
 
   template <
-      class T,
+      typename T,
       typename =
           std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>>>
   static T deserialize(const folly::dynamic& obj, void* context = nullptr) {
@@ -224,12 +226,12 @@ class ISerializable {
     return (T)raw;
   }
 
-  template <class T, typename = std::enable_if_t<std::is_same_v<T, bool>>>
+  template <typename T, typename = std::enable_if_t<std::is_same_v<T, bool>>>
   static bool deserialize(const folly::dynamic& obj, void* context = nullptr) {
     return obj.asBool();
   }
 
-  template <class T, typename = std::enable_if_t<std::is_same_v<T, double>>>
+  template <typename T, typename = std::enable_if_t<std::is_same_v<T, double>>>
   static double deserialize(
       const folly::dynamic& obj,
       void* context = nullptr) {
@@ -237,7 +239,7 @@ class ISerializable {
   }
 
   template <
-      class T,
+      typename T,
       typename = std::enable_if_t<std::is_same_v<T, std::string>>>
   static std::string deserialize(
       const folly::dynamic& obj,
@@ -246,7 +248,7 @@ class ISerializable {
   }
 
   template <
-      class T,
+      typename T,
       typename = std::enable_if_t<
           std::is_same_v<T, folly::Optional<typename T::value_type>>>>
   static folly::Optional<
@@ -268,13 +270,13 @@ class ISerializable {
   using deserializeType =
       decltype(ISerializable::deserialize<T>(std::declval<folly::dynamic>()));
 
-  template <class T, typename = std::enable_if_t<is_vector_type<T>::value>>
+  template <typename T, std::enable_if_t<is_vector_type<T>::value>* = nullptr>
   static auto deserialize(
       const folly::dynamic& array,
       void* context = nullptr) {
     using deserializeValType =
         decltype(ISerializable::deserialize<typename T::value_type>(
-            std::declval<folly::dynamic>(), context));
+            std::declval<folly::dynamic>()));
 
     VELOX_USER_CHECK(array.isArray());
     std::vector<deserializeValType> exprs;
@@ -286,34 +288,44 @@ class ISerializable {
   }
 
   template <
-      class T,
-      typename = std::enable_if_t<std::is_same_v<
+      typename T,
+      std::enable_if_t<std::is_same_v<
           T,
-          std::map<typename T::key_type, typename T::mapped_type>>>>
-  static std::map<
-      decltype(ISerializable::deserialize<typename T::key_type>(
-          std::declval<folly::dynamic>())),
-      decltype(ISerializable::deserialize<typename T::mapped_type>(
-          std::declval<folly::dynamic>()))>
-  deserialize(const folly::dynamic& obj, void* context = nullptr) {
-    using deserializeKeyType =
-        decltype(ISerializable::deserialize<typename T::key_type>(
-            std::declval<folly::dynamic>()));
-
-    using deserializeMappedType =
-        decltype(ISerializable::deserialize<typename T::mapped_type>(
-            std::declval<folly::dynamic>()));
+          std::map<typename T::key_type, typename T::mapped_type>>>* = nullptr>
+  static auto deserialize(const folly::dynamic& obj, void* context = nullptr) {
+    return deserialize<std::map, typename T::key_type, typename T::mapped_type>(
+        obj, context);
+  }
 
-    std::map<deserializeKeyType, deserializeMappedType> map;
+  template <
+      template <typename, typename, typename...>
+      typename TMap,
+      typename TKey,
+      typename TMapped,
+      typename... TArgs,
+      typename = std::enable_if_t<
+          util::is_mappish<TMap<TKey, TMapped, TArgs...>>::value &&
+          std::is_same_v<
+              typename TMap<TKey, TMapped, TArgs...>::key_type,
+              TKey> &&
+          std::is_same_v<
+              typename TMap<TKey, TMapped, TArgs...>::mapped_type,
+              TMapped>>>
+  static auto deserialize(const folly::dynamic& obj, void* context = nullptr) {
+    using deserializeKeyType = decltype(ISerializable::deserialize<TKey>(
+        std::declval<folly::dynamic>()));
+
+    using deserializeMappedType = decltype(ISerializable::deserialize<TMapped>(
+        std::declval<folly::dynamic>()));
+
+    TMap<deserializeKeyType, deserializeMappedType, TArgs...> map;
     const folly::dynamic& keys = obj["keys"];
     const folly::dynamic& values = obj["values"];
     VELOX_USER_CHECK(keys.isArray() && values.isArray());
     VELOX_USER_CHECK_EQ(keys.size(), values.size());
     for (size_t idx = 0; idx < keys.size(); ++idx) {
-      auto first =
-          ISerializable::deserialize<typename T::key_type>(keys[idx], context);
-      auto second = ISerializable::deserialize<typename T::mapped_type>(
-          values[idx], context);
+      auto first = ISerializable::deserialize<TKey>(keys[idx], context);
+      auto second = ISerializable::deserialize<TMapped>(values[idx], context);
       map.insert({first, second});
     }
     return map;
@@ -323,7 +335,7 @@ class ISerializable {
 
  private:
   template <
-      class T,
+      typename T,
       typename = std::enable_if_t<std::is_base_of_v<ISerializable, T>>>
   static auto deserializeAsUniquePtr(const folly::dynamic& obj) {
     auto name = obj["name"].asString();
diff --git a/velox/common/serialization/tests/CMakeLists.txt b/velox/common/serialization/tests/CMakeLists.txt
index d135a48750550..74b2baf630eaf 100644
--- a/velox/common/serialization/tests/CMakeLists.txt
+++ b/velox/common/serialization/tests/CMakeLists.txt
@@ -16,5 +16,11 @@ add_executable(velox_serialization_test TestRegistry.cpp SerializableTest.cpp)
 add_test(velox_serialization_test velox_serialization_test)
 
 target_link_libraries(
-  velox_serialization_test PRIVATE velox_exception velox_serialization
-                                   Folly::folly glog::glog gtest gtest_main)
+  velox_serialization_test
+  PRIVATE
+    velox_exception
+    velox_serialization
+    Folly::folly
+    glog::glog
+    GTest::gtest
+    GTest::gtest_main)
diff --git a/velox/common/serialization/tests/SerializableTest.cpp b/velox/common/serialization/tests/SerializableTest.cpp
index 8ec543d2d262c..90b60852b9b78 100644
--- a/velox/common/serialization/tests/SerializableTest.cpp
+++ b/velox/common/serialization/tests/SerializableTest.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/common/serialization/Serializable.h"
 #include <gtest/gtest.h>
+#include "folly/container/F14Map.h"
 #include "folly/json.h"
 
 using namespace ::facebook::velox;
@@ -158,4 +159,26 @@ TEST(SerializableTest, context) {
   }
 }
 
+template <
+    template <typename, typename, typename...>
+    typename TMap,
+    typename TKey,
+    typename TMapped,
+    typename TIt,
+    typename... TArgs>
+void testMap(TIt first, TIt last) {
+  TMap<TKey, TMapped, TArgs...> map{first, last};
+  auto serialized = ISerializable::serialize(map);
+  auto copy = ISerializable::deserialize<TMap, TKey, TMapped>(serialized);
+  ASSERT_EQ(map, copy);
+}
+
+TEST(SerializableTest, map) {
+  std::vector<std::pair<int32_t, std::string>> vals{
+      {1, "a"}, {2, "b"}, {3, "c"}};
+  testMap<std::map, int32_t, std::string>(vals.begin(), vals.end());
+  testMap<std::unordered_map, int32_t, std::string>(vals.begin(), vals.end());
+  testMap<folly::F14FastMap, int32_t, std::string>(vals.begin(), vals.end());
+}
+
 } // namespace
diff --git a/velox/common/testutil/CMakeLists.txt b/velox/common/testutil/CMakeLists.txt
index 04d43ce5a9fba..f33bb98be06f2 100644
--- a/velox/common/testutil/CMakeLists.txt
+++ b/velox/common/testutil/CMakeLists.txt
@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_test_util TestValue.cpp)
-target_link_libraries(velox_test_util PUBLIC velox_exception)
+velox_add_library(velox_test_util ScopedTestTime.cpp TestValue.cpp)
+velox_link_libraries(velox_test_util PUBLIC velox_exception)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/common/testutil/ScopedTestTime.cpp b/velox/common/testutil/ScopedTestTime.cpp
new file mode 100644
index 0000000000000..ec25f40cfdb5f
--- /dev/null
+++ b/velox/common/testutil/ScopedTestTime.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/testutil/ScopedTestTime.h"
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::common::testutil {
+bool ScopedTestTime::enabled_ = false;
+std::optional<size_t> ScopedTestTime::testTimeUs_ = {};
+
+ScopedTestTime::ScopedTestTime() {
+#ifndef NDEBUG
+  VELOX_CHECK(!enabled_, "Only one ScopedTestTime can be active at a time");
+  enabled_ = true;
+#else
+  VELOX_UNREACHABLE("ScopedTestTime should only be used in debug mode");
+#endif
+}
+
+ScopedTestTime::~ScopedTestTime() {
+  testTimeUs_.reset();
+  enabled_ = false;
+}
+
+void ScopedTestTime::setCurrentTestTimeSec(size_t currentTimeSec) {
+  setCurrentTestTimeMicro(currentTimeSec * 1000000);
+}
+
+void ScopedTestTime::setCurrentTestTimeMs(size_t currentTimeMs) {
+  setCurrentTestTimeMicro(currentTimeMs * 1000);
+}
+
+void ScopedTestTime::setCurrentTestTimeMicro(size_t currentTimeUs) {
+  testTimeUs_ = currentTimeUs;
+}
+
+std::optional<size_t> ScopedTestTime::getCurrentTestTimeSec() {
+  return testTimeUs_.has_value() ? std::make_optional(*testTimeUs_ / 1000000L)
+                                 : testTimeUs_;
+}
+std::optional<size_t> ScopedTestTime::getCurrentTestTimeMs() {
+  return testTimeUs_.has_value() ? std::make_optional(*testTimeUs_ / 1000L)
+                                 : testTimeUs_;
+}
+
+std::optional<size_t> ScopedTestTime::getCurrentTestTimeMicro() {
+  return testTimeUs_;
+}
+} // namespace facebook::velox::common::testutil
diff --git a/velox/common/testutil/ScopedTestTime.h b/velox/common/testutil/ScopedTestTime.h
new file mode 100644
index 0000000000000..3a03a603fb311
--- /dev/null
+++ b/velox/common/testutil/ScopedTestTime.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <optional>
+
+namespace facebook::velox::common::testutil {
+// Used to override the current time for testing purposes.
+class ScopedTestTime {
+ public:
+  ScopedTestTime();
+  ~ScopedTestTime();
+
+  void setCurrentTestTimeSec(size_t currentTimeSec);
+  void setCurrentTestTimeMs(size_t currentTimeMs);
+  void setCurrentTestTimeMicro(size_t currentTimeUs);
+
+  static std::optional<size_t> getCurrentTestTimeSec();
+  static std::optional<size_t> getCurrentTestTimeMs();
+  static std::optional<size_t> getCurrentTestTimeMicro();
+
+ private:
+  // Used to verify only one instance of ScopedTestTime exists at a time.
+  static bool enabled_;
+  // The overridden value of current time only.
+  static std::optional<size_t> testTimeUs_;
+};
+} // namespace facebook::velox::common::testutil
diff --git a/velox/common/testutil/tests/CMakeLists.txt b/velox/common/testutil/tests/CMakeLists.txt
index 02b7ee5f1045b..d164600656a38 100644
--- a/velox/common/testutil/tests/CMakeLists.txt
+++ b/velox/common/testutil/tests/CMakeLists.txt
@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 include(GoogleTest)
-add_executable(velox_test_util_test TestValueTest.cpp SpillConfigTest.cpp)
+add_executable(velox_test_util_test TestScopedTestTime.cpp TestValueTest.cpp)
 gtest_add_tests(velox_test_util_test "" AUTO)
 
 target_link_libraries(
   velox_test_util_test
   PRIVATE
-  velox_test_util
-  velox_exception
-  velox_spill_config
-  velox_exec
-  gtest
-  gtest_main)
+    velox_test_util
+    velox_exception
+    velox_exec
+    velox_time
+    GTest::gtest
+    GTest::gtest_main)
diff --git a/velox/common/testutil/tests/TestScopedTestTime.cpp b/velox/common/testutil/tests/TestScopedTestTime.cpp
new file mode 100644
index 0000000000000..4052ea256729e
--- /dev/null
+++ b/velox/common/testutil/tests/TestScopedTestTime.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/ScopedTestTime.h"
+#include "velox/common/time/Timer.h"
+
+namespace {
+
+using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
+
+// NOTE: we can only construct ScopedTestTime in debug builds.
+DEBUG_ONLY_TEST(TestScopedTestTime, testSetCurrentTimeMs) {
+  {
+    ScopedTestTime scopedTestTime;
+    scopedTestTime.setCurrentTestTimeMs(1);
+    ASSERT_EQ(getCurrentTimeMs(), 1);
+    ASSERT_EQ(getCurrentTimeMicro(), 1000);
+    scopedTestTime.setCurrentTestTimeMs(2);
+    ASSERT_EQ(getCurrentTimeMs(), 2);
+    ASSERT_EQ(getCurrentTimeMicro(), 2000);
+  }
+
+  // This should be the actual time, so we don't know what it is, but it
+  // shouldn't be equal to the overridden value.
+  ASSERT_NE(getCurrentTimeMs(), 2);
+  ASSERT_NE(getCurrentTimeMicro(), 2000);
+}
+
+DEBUG_ONLY_TEST(TestScopedTestTime, testSetCurrentTimeMicro) {
+  {
+    ScopedTestTime scopedTestTime;
+    scopedTestTime.setCurrentTestTimeMicro(1000);
+    ASSERT_EQ(getCurrentTimeMs(), 1);
+    ASSERT_EQ(getCurrentTimeMicro(), 1000);
+    scopedTestTime.setCurrentTestTimeMicro(2000);
+    ASSERT_EQ(getCurrentTimeMs(), 2);
+    ASSERT_EQ(getCurrentTimeMicro(), 2000);
+  }
+
+  // This should be the actual time, so we don't know what it is, but it
+  // shouldn't be equal to the overridden value.
+  ASSERT_NE(getCurrentTimeMs(), 2);
+  ASSERT_NE(getCurrentTimeMicro(), 2000);
+}
+
+DEBUG_ONLY_TEST(TestScopedTestTime, multipleScopedTestTimes) {
+  {
+    ScopedTestTime scopedTestTime;
+    scopedTestTime.setCurrentTestTimeMs(1);
+    ASSERT_EQ(getCurrentTimeMs(), 1);
+    ASSERT_EQ(getCurrentTimeMicro(), 1000);
+  }
+
+  {
+    ScopedTestTime scopedTestTime;
+    // The previous scoped test time should have been cleared.
+    ASSERT_NE(getCurrentTimeMs(), 1);
+    ASSERT_NE(getCurrentTimeMicro(), 1000);
+
+    scopedTestTime.setCurrentTestTimeMs(1);
+    ASSERT_EQ(getCurrentTimeMs(), 1);
+    ASSERT_EQ(getCurrentTimeMicro(), 1000);
+
+    // Trying to create another ScopedTestTime with one already in scope should
+    // fail.
+    auto createScopedTestTime = []() { ScopedTestTime scopedTestTime2; };
+    VELOX_ASSERT_THROW(
+        createScopedTestTime(),
+        "Only one ScopedTestTime can be active at a time");
+  }
+}
+} // namespace
diff --git a/velox/common/time/CMakeLists.txt b/velox/common/time/CMakeLists.txt
index fc5ca7c80403c..8c9e39f518351 100644
--- a/velox/common/time/CMakeLists.txt
+++ b/velox/common/time/CMakeLists.txt
@@ -15,5 +15,6 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-add_library(velox_time Timer.cpp CpuWallTimer.cpp)
-target_link_libraries(velox_time PUBLIC velox_process Folly::folly fmt::fmt)
+velox_add_library(velox_time CpuWallTimer.cpp Timer.cpp)
+velox_link_libraries(velox_time PUBLIC velox_process velox_test_util
+                                       Folly::folly fmt::fmt)
diff --git a/velox/common/time/CpuWallTimer.h b/velox/common/time/CpuWallTimer.h
index 223cde7751246..f60f23c19dc9e 100644
--- a/velox/common/time/CpuWallTimer.h
+++ b/velox/common/time/CpuWallTimer.h
@@ -65,23 +65,28 @@ template <typename F>
 class DeltaCpuWallTimer {
  public:
   explicit DeltaCpuWallTimer(F&& func)
-      : cpuTimeStart_(process::threadCpuNanos()),
-        wallTimeStart_(std::chrono::steady_clock::now()),
+      : wallTimeStart_(std::chrono::steady_clock::now()),
+        cpuTimeStart_(process::threadCpuNanos()),
         func_(std::move(func)) {}
 
   ~DeltaCpuWallTimer() {
-    const CpuWallTiming deltaTiming{
-        1,
-        uint64_t(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                     std::chrono::steady_clock::now() - wallTimeStart_)
-                     .count()),
-        process::threadCpuNanos() - cpuTimeStart_};
+    // NOTE: End the cpu-time timing first, and then end the wall-time timing,
+    // so as to avoid the counter-intuitive phenomenon that the final calculated
+    // cpu-time is slightly larger than the wall-time.
+    uint64_t cpuTimeDuration = process::threadCpuNanos() - cpuTimeStart_;
+    uint64_t wallTimeDuration =
+        std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::steady_clock::now() - wallTimeStart_)
+            .count();
+    const CpuWallTiming deltaTiming{1, wallTimeDuration, cpuTimeDuration};
     func_(deltaTiming);
   }
 
  private:
-  const uint64_t cpuTimeStart_;
+  // NOTE: Put `wallTimeStart_` before `cpuTimeStart_`, so that wall-time starts
+  // counting earlier than cpu-time.
   const std::chrono::steady_clock::time_point wallTimeStart_;
+  const uint64_t cpuTimeStart_;
   F func_;
 };
 
diff --git a/velox/common/time/Timer.cpp b/velox/common/time/Timer.cpp
index be82932f306c5..5598fb0ee6dbb 100644
--- a/velox/common/time/Timer.cpp
+++ b/velox/common/time/Timer.cpp
@@ -16,9 +16,36 @@
 
 #include "velox/common/time/Timer.h"
 
+#include "velox/common/testutil/ScopedTestTime.h"
+
 namespace facebook::velox {
 
 using namespace std::chrono;
+using common::testutil::ScopedTestTime;
+
+#ifndef NDEBUG
+
+size_t getCurrentTimeSec() {
+  return ScopedTestTime::getCurrentTestTimeSec().value_or(
+      duration_cast<seconds>(system_clock::now().time_since_epoch()).count());
+}
+
+size_t getCurrentTimeMs() {
+  return ScopedTestTime::getCurrentTestTimeMs().value_or(
+      duration_cast<milliseconds>(system_clock::now().time_since_epoch())
+          .count());
+}
+
+size_t getCurrentTimeMicro() {
+  return ScopedTestTime::getCurrentTestTimeMicro().value_or(
+      duration_cast<microseconds>(system_clock::now().time_since_epoch())
+          .count());
+}
+#else
+
+size_t getCurrentTimeSec() {
+  return duration_cast<seconds>(system_clock::now().time_since_epoch()).count();
+}
 
 size_t getCurrentTimeMs() {
   return duration_cast<milliseconds>(system_clock::now().time_since_epoch())
@@ -29,5 +56,6 @@ size_t getCurrentTimeMicro() {
   return duration_cast<microseconds>(system_clock::now().time_since_epoch())
       .count();
 }
+#endif
 
 } // namespace facebook::velox
diff --git a/velox/common/time/Timer.h b/velox/common/time/Timer.h
index e3325cbdba25e..ce3d8ceb03860 100644
--- a/velox/common/time/Timer.h
+++ b/velox/common/time/Timer.h
@@ -19,6 +19,7 @@
 #include <folly/chrono/Hardware.h>
 #include <atomic>
 #include <chrono>
+#include <optional>
 
 namespace facebook::velox {
 
@@ -43,6 +44,24 @@ class MicrosecondTimer {
   uint64_t* timer_;
 };
 
+class NanosecondTimer {
+ public:
+  explicit NanosecondTimer(uint64_t* timer) : timer_(timer) {
+    start_ = std::chrono::steady_clock::now();
+  }
+
+  ~NanosecondTimer() {
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+        std::chrono::steady_clock::now() - start_);
+
+    (*timer_) += duration.count();
+  }
+
+ private:
+  std::chrono::steady_clock::time_point start_;
+  uint64_t* timer_;
+};
+
 /// Measures the time between construction and destruction with CPU clock
 /// counter (rdtsc on X86) and increments a user-supplied counter with the cycle
 /// count.
@@ -69,6 +88,9 @@ class ClockTimer {
   uint64_t start_;
 };
 
+// Returns the current epoch time in seconds.
+size_t getCurrentTimeSec();
+
 /// Returns the current epoch time in milliseconds.
 size_t getCurrentTimeMs();
 
diff --git a/velox/common/time/tests/CMakeLists.txt b/velox/common/time/tests/CMakeLists.txt
index 5dd964b97abfc..2b2bc5caa9dc6 100644
--- a/velox/common/time/tests/CMakeLists.txt
+++ b/velox/common/time/tests/CMakeLists.txt
@@ -15,7 +15,8 @@ include(GoogleTest)
 
 add_executable(velox_time_test CpuWallTimerTest.cpp)
 
-target_link_libraries(velox_time_test PRIVATE velox_time glog::glog gtest
-                                              gtest_main)
+target_link_libraries(
+  velox_time_test
+  PRIVATE velox_time glog::glog GTest::gtest GTest::gtest_main)
 
 gtest_add_tests(velox_time_test "" AUTO)
diff --git a/velox/connectors/CMakeLists.txt b/velox/connectors/CMakeLists.txt
index 6bf3f5b5f17a1..3cc600201f6b8 100644
--- a/velox/connectors/CMakeLists.txt
+++ b/velox/connectors/CMakeLists.txt
@@ -11,10 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_connector Connector.cpp)
+velox_add_library(velox_connector Connector.cpp)
 
-target_link_libraries(velox_connector velox_config velox_spill_config
-                      velox_vector)
+velox_link_libraries(velox_connector velox_common_config velox_vector)
 
 add_subdirectory(fuzzer)
 
diff --git a/velox/connectors/Connector.cpp b/velox/connectors/Connector.cpp
index a14e7538b9b5c..ed10fad669d4b 100644
--- a/velox/connectors/Connector.cpp
+++ b/velox/connectors/Connector.cpp
@@ -31,6 +31,18 @@ std::unordered_map<std::string, std::shared_ptr<Connector>>& connectors() {
 }
 } // namespace
 
+bool DataSink::Stats::empty() const {
+  return numWrittenBytes == 0 && numWrittenFiles == 0 && spillStats.empty();
+}
+
+std::string DataSink::Stats::toString() const {
+  return fmt::format(
+      "numWrittenBytes {} numWrittenFiles {} {}",
+      succinctBytes(numWrittenBytes),
+      numWrittenFiles,
+      spillStats.toString());
+}
+
 bool registerConnectorFactory(std::shared_ptr<ConnectorFactory> factory) {
   factory->initialize();
   bool ok =
@@ -42,6 +54,15 @@ bool registerConnectorFactory(std::shared_ptr<ConnectorFactory> factory) {
   return true;
 }
 
+bool hasConnectorFactory(const std::string& connectorName) {
+  return connectorFactories().count(connectorName) == 1;
+}
+
+bool unregisterConnectorFactory(const std::string& connectorName) {
+  auto count = connectorFactories().erase(connectorName);
+  return count == 1;
+}
+
 std::shared_ptr<ConnectorFactory> getConnectorFactory(
     const std::string& connectorName) {
   auto it = connectorFactories().find(connectorName);
diff --git a/velox/connectors/Connector.h b/velox/connectors/Connector.h
index 2f3ec9def722d..6aa1b55c9e2c4 100644
--- a/velox/connectors/Connector.h
+++ b/velox/connectors/Connector.h
@@ -15,38 +15,49 @@
  */
 #pragma once
 
+#include "folly/CancellationToken.h"
 #include "velox/common/base/AsyncSource.h"
+#include "velox/common/base/PrefixSortConfig.h"
 #include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/base/SpillConfig.h"
+#include "velox/common/base/SpillStats.h"
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/caching/ScanTracker.h"
-#include "velox/common/config/SpillConfig.h"
 #include "velox/common/future/VeloxPromise.h"
 #include "velox/core/ExpressionEvaluator.h"
 #include "velox/vector/ComplexVector.h"
 
 #include <folly/Synchronized.h>
 
+namespace facebook::velox {
+class Config;
+}
+namespace facebook::velox::wave {
+class WaveDataSource;
+}
 namespace facebook::velox::common {
 class Filter;
 }
-
-namespace facebook::velox {
-class Config;
+namespace facebook::velox::config {
+class ConfigBase;
 }
 
 namespace facebook::velox::connector {
 
 class DataSource;
 
-// A split represents a chunk of data that a connector should load and return
-// as a RowVectorPtr, potentially after processing pushdowns.
+/// A split represents a chunk of data that a connector should load and return
+/// as a RowVectorPtr, potentially after processing pushdowns.
 struct ConnectorSplit {
   const std::string connectorId;
+  const int64_t splitWeight{0};
 
   std::unique_ptr<AsyncSource<DataSource>> dataSource;
 
-  explicit ConnectorSplit(const std::string& _connectorId)
-      : connectorId(_connectorId) {}
+  explicit ConnectorSplit(
+      const std::string& _connectorId,
+      int64_t _splitWeight = 0)
+      : connectorId(_connectorId), splitWeight(_splitWeight) {}
 
   virtual ~ConnectorSplit() {}
 
@@ -93,19 +104,19 @@ class ConnectorTableHandle : public ISerializable {
 
 using ConnectorTableHandlePtr = std::shared_ptr<const ConnectorTableHandle>;
 
-/**
- * Represents a request for writing to connector
- */
+/// Represents a request for writing to connector
 class ConnectorInsertTableHandle : public ISerializable {
  public:
   virtual ~ConnectorInsertTableHandle() {}
 
-  // Whether multi-threaded write is supported by this connector. Planner uses
-  // this flag to determine number of drivers.
+  /// Whether multi-threaded write is supported by this connector. Planner uses
+  /// this flag to determine number of drivers.
   virtual bool supportsMultiThreading() const {
     return false;
   }
 
+  virtual std::string toString() const = 0;
+
   folly::dynamic serialize() const override {
     VELOX_NYI();
   }
@@ -113,8 +124,10 @@ class ConnectorInsertTableHandle : public ISerializable {
 
 /// Represents the commit strategy for writing to connector.
 enum class CommitStrategy {
-  kNoCommit, // No more commit actions are needed.
-  kTaskCommit // Task level commit is needed.
+  /// No more commit actions are needed.
+  kNoCommit,
+  /// Task level commit is needed.
+  kTaskCommit
 };
 
 /// Return a string encoding of the given commit strategy.
@@ -135,29 +148,34 @@ CommitStrategy stringToCommitStrategy(const std::string& strategy);
 /// to be thread-safe.
 class DataSink {
  public:
+  struct Stats {
+    uint64_t numWrittenBytes{0};
+    uint32_t numWrittenFiles{0};
+    uint64_t writeIOTimeUs{0};
+    common::SpillStats spillStats;
+
+    bool empty() const;
+
+    std::string toString() const;
+  };
+
   virtual ~DataSink() = default;
 
   /// Add the next data (vector) to be written. This call is blocking.
   /// TODO maybe at some point we want to make it async.
   virtual void appendData(RowVectorPtr input) = 0;
 
-  /// Returns the number of bytes written on disk by this data sink so far.
-  virtual int64_t getCompletedBytes() const {
-    return 0;
-  }
-
-  /// Returns the number of files written on disk by this data sink so far.
-  virtual int32_t numWrittenFiles() const {
-    return 0;
-  }
+  /// Returns the stats of this data sink.
+  virtual Stats stats() const = 0;
 
   /// Called once after all data has been added via possibly multiple calls to
   /// appendData(). The function returns the metadata of written data in string
-  /// form on success. If 'success' is false, this function aborts any pending
-  /// data processing inside this data sink.
-  ///
-  /// NOTE: we don't expect any appendData() calls on a closed data sink object.
-  virtual std::vector<std::string> close(bool success) = 0;
+  /// form. We don't expect any appendData() calls on a closed data sink object.
+  virtual std::vector<std::string> close() = 0;
+
+  /// Called to abort this data sink object and we don't expect any appendData()
+  /// calls on an aborted data sink object.
+  virtual void abort() = 0;
 };
 
 class DataSource {
@@ -165,62 +183,71 @@ class DataSource {
   static constexpr int64_t kUnknownRowSize = -1;
   virtual ~DataSource() = default;
 
-  // Add split to process, then call next multiple times to process the split.
-  // A split must be fully processed by next before another split can be
-  // added. Next returns nullptr to indicate that current split is fully
-  // processed.
+  /// Add split to process, then call next multiple times to process the split.
+  /// A split must be fully processed by next before another split can be
+  /// added. Next returns nullptr to indicate that current split is fully
+  /// processed.
   virtual void addSplit(std::shared_ptr<ConnectorSplit> split) = 0;
 
-  // Process a split added via addSplit. Returns nullptr if split has been fully
-  // processed. Returns std::nullopt and sets the 'future' if started
-  // asynchronous work and needs to wait for it to complete to continue
-  // processing. The caller will wait for the 'future' to complete before
-  // calling 'next' again.
+  /// Process a split added via addSplit. Returns nullptr if split has been
+  /// fully processed. Returns std::nullopt and sets the 'future' if started
+  /// asynchronous work and needs to wait for it to complete to continue
+  /// processing. The caller will wait for the 'future' to complete before
+  /// calling 'next' again.
   virtual std::optional<RowVectorPtr> next(
       uint64_t size,
       velox::ContinueFuture& future) = 0;
 
-  // Add dynamically generated filter.
-  // @param outputChannel index into outputType specified in
-  // Connector::createDataSource() that identifies the column this filter
-  // applies to.
+  /// Add dynamically generated filter.
+  /// @param outputChannel index into outputType specified in
+  /// Connector::createDataSource() that identifies the column this filter
+  /// applies to.
   virtual void addDynamicFilter(
       column_index_t outputChannel,
       const std::shared_ptr<common::Filter>& filter) = 0;
 
-  // Returns the number of input bytes processed so far.
+  /// Returns the number of input bytes processed so far.
   virtual uint64_t getCompletedBytes() = 0;
 
-  // Returns the number of input rows processed so far.
+  /// Returns the number of input rows processed so far.
   virtual uint64_t getCompletedRows() = 0;
 
   virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() = 0;
 
-  // Returns true if 'this' has initiated all the prefetch this will
-  // initiate. This means that the caller should schedule next splits
-  // to prefetch in the background. false if the source does not
-  // prefetch.
+  /// Returns true if 'this' has initiated all the prefetch this will initiate.
+  /// This means that the caller should schedule next splits to prefetch in the
+  /// background. false if the source does not prefetch.
   virtual bool allPrefetchIssued() const {
     return false;
   }
 
-  // Initializes this from 'source'. 'source' is effectively moved
-  // into 'this' Adaptation like dynamic filters stay in effect but
-  // the parts dealing with open files, prefetched data etc. are moved. 'source'
-  // is freed after the move.
+  /// Initializes this from 'source'. 'source' is effectively moved into 'this'
+  /// Adaptation like dynamic filters stay in effect but the parts dealing with
+  /// open files, prefetched data etc. are moved. 'source' is freed after the
+  /// move.
   virtual void setFromDataSource(std::unique_ptr<DataSource> /*source*/) {
     VELOX_UNSUPPORTED("setFromDataSource");
   }
 
-  // Returns a connector dependent row size if available. This can be
-  // called after addSplit().  This estimates uncompressed data
-  // sizes. This is better than getCompletedBytes()/getCompletedRows()
-  // since these track sizes before decompression and may include
-  // read-ahead and extra IO from coalescing reads and  will not
-  // fully account for size of sparsely accessed columns.
+  /// Returns a connector dependent row size if available. This can be
+  /// called after addSplit().  This estimates uncompressed data
+  /// sizes. This is better than getCompletedBytes()/getCompletedRows()
+  /// since these track sizes before decompression and may include
+  /// read-ahead and extra IO from coalescing reads and  will not
+  /// fully account for size of sparsely accessed columns.
   virtual int64_t estimatedRowSize() {
     return kUnknownRowSize;
   }
+
+  /// Returns a Wave delegate that implements the Wave Operator
+  /// interface for a GPU table scan. This should be called after
+  /// construction and no other methods should be called on 'this'
+  /// after creating the delegate. Splits, dynamic filters etc.  will
+  /// be added to the WaveDataSource instead of 'this'. 'this' should
+  /// stay live until after the destruction of the delegate.
+  virtual std::shared_ptr<wave::WaveDataSource> toWaveDataSource() {
+    VELOX_UNSUPPORTED();
+  }
 };
 
 /// Collection of context data for use in a DataSource or DataSink. One instance
@@ -232,28 +259,32 @@ class ConnectorQueryCtx {
   ConnectorQueryCtx(
       memory::MemoryPool* operatorPool,
       memory::MemoryPool* connectorPool,
-      memory::SetMemoryReclaimer setMemoryReclaimer,
-      const Config* connectorConfig,
+      const config::ConfigBase* sessionProperties,
       const common::SpillConfig* spillConfig,
+      common::PrefixSortConfig prefixSortConfig,
       std::unique_ptr<core::ExpressionEvaluator> expressionEvaluator,
       cache::AsyncDataCache* cache,
       const std::string& queryId,
       const std::string& taskId,
       const std::string& planNodeId,
-      int driverId)
+      int driverId,
+      const std::string& sessionTimezone,
+      folly::CancellationToken cancellationToken = {})
       : operatorPool_(operatorPool),
         connectorPool_(connectorPool),
-        setMemoryReclaimer_(std::move(setMemoryReclaimer)),
-        config_(connectorConfig),
+        sessionProperties_(sessionProperties),
         spillConfig_(spillConfig),
+        prefixSortConfig_(prefixSortConfig),
         expressionEvaluator_(std::move(expressionEvaluator)),
         cache_(cache),
         scanId_(fmt::format("{}.{}", taskId, planNodeId)),
         queryId_(queryId),
         taskId_(taskId),
         driverId_(driverId),
-        planNodeId_(planNodeId) {
-    VELOX_CHECK_NOT_NULL(connectorConfig);
+        planNodeId_(planNodeId),
+        sessionTimezone_(sessionTimezone),
+        cancellationToken_(std::move(cancellationToken)) {
+    VELOX_CHECK_NOT_NULL(sessionProperties);
   }
 
   /// Returns the associated operator's memory pool which is a leaf kind of
@@ -269,19 +300,16 @@ class ConnectorQueryCtx {
     return connectorPool_;
   }
 
-  /// Returns the callback to set memory pool reclaimer if set. This is used by
-  /// file writer to set memory reclaimer for its internal used memory pools to
-  /// integrate with memory arbitration.
-  const memory::SetMemoryReclaimer& setMemoryReclaimer() const {
-    return setMemoryReclaimer_;
+  const config::ConfigBase* sessionProperties() const {
+    return sessionProperties_;
   }
 
-  const Config* config() const {
-    return config_;
+  const common::SpillConfig* spillConfig() const {
+    return spillConfig_;
   }
 
-  const common::SpillConfig* getSpillConfig() const {
-    return spillConfig_;
+  const common::PrefixSortConfig& prefixSortConfig() const {
+    return prefixSortConfig_;
   }
 
   core::ExpressionEvaluator* expressionEvaluator() const {
@@ -292,10 +320,10 @@ class ConnectorQueryCtx {
     return cache_;
   }
 
-  // This is a combination of task id and the scan's PlanNodeId. This is an id
-  // that allows sharing state between different threads of the same scan. This
-  // is used for locating a scanTracker, which tracks the read density of
-  // columns for prefetch and other memory hierarchy purposes.
+  /// This is a combination of task id and the scan's PlanNodeId. This is an id
+  /// that allows sharing state between different threads of the same scan. This
+  /// is used for locating a scanTracker, which tracks the read density of
+  /// columns for prefetch and other memory hierarchy purposes.
   const std::string& scanId() const {
     return scanId_;
   }
@@ -316,12 +344,32 @@ class ConnectorQueryCtx {
     return planNodeId_;
   }
 
+  /// Session timezone used for reading Timestamp. Stores a string with the
+  /// actual timezone name. If the session timezone is not set in the
+  /// QueryConfig, it will return an empty string.
+  const std::string& sessionTimezone() const {
+    return sessionTimezone_;
+  }
+
+  /// Returns the cancellation token associated with this task.
+  const folly::CancellationToken& cancellationToken() const {
+    return cancellationToken_;
+  }
+
+  bool selectiveNimbleReaderEnabled() const {
+    return selectiveNimbleReaderEnabled_;
+  }
+
+  void setSelectiveNimbleReaderEnabled(bool value) {
+    selectiveNimbleReaderEnabled_ = value;
+  }
+
  private:
   memory::MemoryPool* const operatorPool_;
   memory::MemoryPool* const connectorPool_;
-  const memory::SetMemoryReclaimer setMemoryReclaimer_;
-  const Config* config_;
+  const config::ConfigBase* const sessionProperties_;
   const common::SpillConfig* const spillConfig_;
+  const common::PrefixSortConfig prefixSortConfig_;
   std::unique_ptr<core::ExpressionEvaluator> expressionEvaluator_;
   cache::AsyncDataCache* cache_;
   const std::string scanId_;
@@ -329,14 +377,14 @@ class ConnectorQueryCtx {
   const std::string taskId_;
   const int driverId_;
   const std::string planNodeId_;
+  const std::string sessionTimezone_;
+  const folly::CancellationToken cancellationToken_;
+  bool selectiveNimbleReaderEnabled_{false};
 };
 
 class Connector {
  public:
-  explicit Connector(
-      const std::string& id,
-      std::shared_ptr<const Config> properties)
-      : id_(id), properties_(std::move(properties)) {}
+  explicit Connector(const std::string& id) : id_(id) {}
 
   virtual ~Connector() = default;
 
@@ -344,12 +392,13 @@ class Connector {
     return id_;
   }
 
-  const std::shared_ptr<const Config>& connectorProperties() const {
-    return properties_;
+  virtual const std::shared_ptr<const config::ConfigBase>& connectorConfig()
+      const {
+    VELOX_NYI("connectorConfig is not supported yet");
   }
 
-  // Returns true if this connector would accept a filter dynamically generated
-  // during query execution.
+  /// Returns true if this connector would accept a filter dynamically generated
+  /// during query execution.
   virtual bool canAddDynamicFilter() const {
     return false;
   }
@@ -362,10 +411,10 @@ class Connector {
           std::shared_ptr<connector::ColumnHandle>>& columnHandles,
       ConnectorQueryCtx* connectorQueryCtx) = 0;
 
-  // Returns true if addSplit of DataSource can use 'dataSource' from
-  // ConnectorSplit in addSplit(). If so, TableScan can preload splits
-  // so that file opening and metadata operations are off the Driver'
-  // thread.
+  /// Returns true if addSplit of DataSource can use 'dataSource' from
+  /// ConnectorSplit in addSplit(). If so, TableScan can preload splits
+  /// so that file opening and metadata operations are off the Driver'
+  /// thread.
   virtual bool supportsSplitPreload() {
     return false;
   }
@@ -376,15 +425,15 @@ class Connector {
       ConnectorQueryCtx* connectorQueryCtx,
       CommitStrategy commitStrategy) = 0;
 
-  // Returns a ScanTracker for 'id'. 'id' uniquely identifies the
-  // tracker and different threads will share the same
-  // instance. 'loadQuantum' is the largest single IO for the query
-  // being tracked.
+  /// Returns a ScanTracker for 'id'. 'id' uniquely identifies the
+  /// tracker and different threads will share the same
+  /// instance. 'loadQuantum' is the largest single IO for the query
+  /// being tracked.
   static std::shared_ptr<cache::ScanTracker> getTracker(
       const std::string& scanId,
       int32_t loadQuantum);
 
-  virtual folly::Executor* FOLLY_NULLABLE executor() const {
+  virtual folly::Executor* executor() const {
     return nullptr;
   }
 
@@ -396,8 +445,6 @@ class Connector {
   static folly::Synchronized<
       std::unordered_map<std::string_view, std::weak_ptr<cache::ScanTracker>>>
       trackers_;
-
-  const std::shared_ptr<const Config> properties_;
 };
 
 class ConnectorFactory {
@@ -406,7 +453,7 @@ class ConnectorFactory {
 
   virtual ~ConnectorFactory() = default;
 
-  // Initialize is called during the factory registration.
+  /// Initialize is called during the factory registration.
   virtual void initialize() {}
 
   const std::string& connectorName() const {
@@ -415,8 +462,8 @@ class ConnectorFactory {
 
   virtual std::shared_ptr<Connector> newConnector(
       const std::string& id,
-      std::shared_ptr<const Config> properties,
-      folly::Executor* FOLLY_NULLABLE executor = nullptr) = 0;
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* executor = nullptr) = 0;
 
  private:
   const std::string name_;
@@ -428,6 +475,15 @@ class ConnectorFactory {
 /// FB_ANONYMOUS_VARIABLE.
 bool registerConnectorFactory(std::shared_ptr<ConnectorFactory> factory);
 
+/// Returns true if a connector with the specified name has been registered,
+/// false otherwise.
+bool hasConnectorFactory(const std::string& connectorName);
+
+/// Unregister a connector factory by name.
+/// Returns true if a connector with the specified name has been unregistered,
+/// false otherwise.
+bool unregisterConnectorFactory(const std::string& connectorName);
+
 /// Returns a factory for creating connectors with the specified name. Throws if
 /// factory doesn't exist.
 std::shared_ptr<ConnectorFactory> getConnectorFactory(
diff --git a/velox/connectors/fuzzer/CMakeLists.txt b/velox/connectors/fuzzer/CMakeLists.txt
index 06bc812de021d..a777f8a29a4f5 100644
--- a/velox/connectors/fuzzer/CMakeLists.txt
+++ b/velox/connectors/fuzzer/CMakeLists.txt
@@ -14,8 +14,8 @@
 
 add_library(velox_fuzzer_connector OBJECT FuzzerConnector.cpp)
 
-target_link_libraries(velox_fuzzer_connector velox_connector
-                      velox_vector_fuzzer)
+target_link_libraries(
+  velox_fuzzer_connector velox_connector velox_vector_fuzzer)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/connectors/fuzzer/FuzzerConnector.cpp b/velox/connectors/fuzzer/FuzzerConnector.cpp
index d2f44c6039dbd..7c75c956863a8 100644
--- a/velox/connectors/fuzzer/FuzzerConnector.cpp
+++ b/velox/connectors/fuzzer/FuzzerConnector.cpp
@@ -22,7 +22,7 @@ namespace facebook::velox::connector::fuzzer {
 FuzzerDataSource::FuzzerDataSource(
     const std::shared_ptr<const RowType>& outputType,
     const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-    velox::memory::MemoryPool* FOLLY_NONNULL pool)
+    velox::memory::MemoryPool* pool)
     : outputType_(outputType), pool_(pool) {
   auto fuzzerTableHandle =
       std::dynamic_pointer_cast<FuzzerTableHandle>(tableHandle);
diff --git a/velox/connectors/fuzzer/FuzzerConnector.h b/velox/connectors/fuzzer/FuzzerConnector.h
index 89d544360b517..4e8f665608b40 100644
--- a/velox/connectors/fuzzer/FuzzerConnector.h
+++ b/velox/connectors/fuzzer/FuzzerConnector.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/common/config/Config.h"
 #include "velox/connectors/Connector.h"
 #include "velox/connectors/fuzzer/FuzzerConnectorSplit.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -56,7 +57,7 @@ class FuzzerDataSource : public DataSource {
   FuzzerDataSource(
       const std::shared_ptr<const RowType>& outputType,
       const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-      velox::memory::MemoryPool* FOLLY_NONNULL pool);
+      velox::memory::MemoryPool* pool);
 
   void addSplit(std::shared_ptr<ConnectorSplit> split) override;
 
@@ -96,16 +97,16 @@ class FuzzerDataSource : public DataSource {
   size_t completedRows_{0};
   size_t completedBytes_{0};
 
-  memory::MemoryPool* FOLLY_NONNULL pool_;
+  memory::MemoryPool* pool_;
 };
 
 class FuzzerConnector final : public Connector {
  public:
   FuzzerConnector(
       const std::string& id,
-      std::shared_ptr<const Config> properties,
-      folly::Executor* FOLLY_NULLABLE /*executor*/)
-      : Connector(id, properties) {}
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* /*executor*/)
+      : Connector(id) {}
 
   std::unique_ptr<DataSource> createDataSource(
       const std::shared_ptr<const RowType>& outputType,
@@ -113,7 +114,7 @@ class FuzzerConnector final : public Connector {
       const std::unordered_map<
           std::string,
           std::shared_ptr<connector::ColumnHandle>>& /*columnHandles*/,
-      ConnectorQueryCtx* FOLLY_NONNULL connectorQueryCtx) override final {
+      ConnectorQueryCtx* connectorQueryCtx) override final {
     return std::make_unique<FuzzerDataSource>(
         outputType, tableHandle, connectorQueryCtx->memoryPool());
   }
@@ -130,18 +131,18 @@ class FuzzerConnector final : public Connector {
 
 class FuzzerConnectorFactory : public ConnectorFactory {
  public:
-  static constexpr const char* FOLLY_NONNULL kFuzzerConnectorName{"fuzzer"};
+  static constexpr const char* kFuzzerConnectorName{"fuzzer"};
 
   FuzzerConnectorFactory() : ConnectorFactory(kFuzzerConnectorName) {}
 
-  explicit FuzzerConnectorFactory(const char* FOLLY_NONNULL connectorName)
+  explicit FuzzerConnectorFactory(const char* connectorName)
       : ConnectorFactory(connectorName) {}
 
   std::shared_ptr<Connector> newConnector(
       const std::string& id,
-      std::shared_ptr<const Config> properties,
-      folly::Executor* FOLLY_NULLABLE executor = nullptr) override {
-    return std::make_shared<FuzzerConnector>(id, properties, executor);
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* executor = nullptr) override {
+    return std::make_shared<FuzzerConnector>(id, config, executor);
   }
 };
 
diff --git a/velox/connectors/fuzzer/FuzzerConnectorSplit.h b/velox/connectors/fuzzer/FuzzerConnectorSplit.h
index b82749e0be9b6..11080aa4382e5 100644
--- a/velox/connectors/fuzzer/FuzzerConnectorSplit.h
+++ b/velox/connectors/fuzzer/FuzzerConnectorSplit.h
@@ -28,3 +28,25 @@ struct FuzzerConnectorSplit : public connector::ConnectorSplit {
 };
 
 } // namespace facebook::velox::connector::fuzzer
+
+template <>
+struct fmt::formatter<facebook::velox::connector::fuzzer::FuzzerConnectorSplit>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::fuzzer::FuzzerConnectorSplit s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(s.toString(), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<
+    std::shared_ptr<facebook::velox::connector::fuzzer::FuzzerConnectorSplit>>
+    : formatter<std::string> {
+  auto format(
+      std::shared_ptr<facebook::velox::connector::fuzzer::FuzzerConnectorSplit>
+          s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(s->toString(), ctx);
+  }
+};
diff --git a/velox/connectors/fuzzer/tests/CMakeLists.txt b/velox/connectors/fuzzer/tests/CMakeLists.txt
index 18e5c913fc16e..8036193390975 100644
--- a/velox/connectors/fuzzer/tests/CMakeLists.txt
+++ b/velox/connectors/fuzzer/tests/CMakeLists.txt
@@ -21,5 +21,5 @@ target_link_libraries(
   velox_vector_test_lib
   velox_exec_test_lib
   velox_aggregates
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/connectors/fuzzer/tests/FuzzerConnectorTest.cpp b/velox/connectors/fuzzer/tests/FuzzerConnectorTest.cpp
index fad06218be862..5b5fe277ac595 100644
--- a/velox/connectors/fuzzer/tests/FuzzerConnectorTest.cpp
+++ b/velox/connectors/fuzzer/tests/FuzzerConnectorTest.cpp
@@ -31,8 +31,12 @@ TEST_F(FuzzerConnectorTest, singleSplit) {
   const size_t numRows = 100;
   auto type = ROW({BIGINT(), DOUBLE(), VARCHAR()});
 
-  auto plan =
-      PlanBuilder().tableScan(type, makeFuzzerTableHandle(), {}).planNode();
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(type)
+                  .tableHandle(makeFuzzerTableHandle())
+                  .endTableScan()
+                  .planNode();
 
   exec::test::AssertQueryBuilder(plan)
       .split(makeFuzzerSplit(numRows))
@@ -43,8 +47,12 @@ TEST_F(FuzzerConnectorTest, floatingPoints) {
   const size_t numRows = 1000;
   auto type = ROW({REAL(), DOUBLE()});
 
-  auto plan =
-      PlanBuilder().tableScan(type, makeFuzzerTableHandle(), {}).planNode();
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(type)
+                  .tableHandle(makeFuzzerTableHandle())
+                  .endTableScan()
+                  .planNode();
 
   exec::test::AssertQueryBuilder(plan)
       .split(makeFuzzerSplit(numRows))
@@ -59,8 +67,12 @@ TEST_F(FuzzerConnectorTest, complexTypes) {
       REAL(),
   });
 
-  auto plan =
-      PlanBuilder().tableScan(type, makeFuzzerTableHandle(), {}).planNode();
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(type)
+                  .tableHandle(makeFuzzerTableHandle())
+                  .endTableScan()
+                  .planNode();
 
   exec::test::AssertQueryBuilder(plan)
       .split(makeFuzzerSplit(numRows))
@@ -72,8 +84,12 @@ TEST_F(FuzzerConnectorTest, multipleSplits) {
   const size_t numSplits = 10;
   auto type = ROW({BIGINT(), DOUBLE(), VARCHAR()});
 
-  auto plan =
-      PlanBuilder().tableScan(type, makeFuzzerTableHandle(), {}).planNode();
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(type)
+                  .tableHandle(makeFuzzerTableHandle())
+                  .endTableScan()
+                  .planNode();
 
   exec::test::AssertQueryBuilder(plan)
       .splits(makeFuzzerSplits(rowsPerSplit, numSplits))
@@ -89,8 +105,12 @@ TEST_F(FuzzerConnectorTest, randomTypes) {
   for (size_t i = 0; i < iterations; ++i) {
     auto type = VectorFuzzer({}, pool()).randRowType();
 
-    auto plan =
-        PlanBuilder().tableScan(type, makeFuzzerTableHandle(), {}).planNode();
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .outputType(type)
+                    .tableHandle(makeFuzzerTableHandle())
+                    .endTableScan()
+                    .planNode();
     exec::test::AssertQueryBuilder(plan)
         .splits(makeFuzzerSplits(rowsPerSplit, numSplits))
         .assertTypeAndNumRows(type, rowsPerSplit * numSplits);
@@ -101,14 +121,18 @@ TEST_F(FuzzerConnectorTest, reproducible) {
   const size_t numRows = 100;
   auto type = ROW({BIGINT(), ARRAY(INTEGER()), VARCHAR()});
 
-  auto plan1 =
-      PlanBuilder()
-          .tableScan(type, makeFuzzerTableHandle(/*fuzerSeed=*/1234), {})
-          .planNode();
-  auto plan2 =
-      PlanBuilder()
-          .tableScan(type, makeFuzzerTableHandle(/*fuzerSeed=*/1234), {})
-          .planNode();
+  auto plan1 = PlanBuilder()
+                   .startTableScan()
+                   .outputType(type)
+                   .tableHandle(makeFuzzerTableHandle(/*fuzerSeed=*/1234))
+                   .endTableScan()
+                   .planNode();
+  auto plan2 = PlanBuilder()
+                   .startTableScan()
+                   .outputType(type)
+                   .tableHandle(makeFuzzerTableHandle(/*fuzerSeed=*/1234))
+                   .endTableScan()
+                   .planNode();
 
   auto results1 = exec::test::AssertQueryBuilder(plan1)
                       .split(makeFuzzerSplit(numRows))
@@ -124,6 +148,6 @@ TEST_F(FuzzerConnectorTest, reproducible) {
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init(&argc, &argv, false);
   return RUN_ALL_TESTS();
 }
diff --git a/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h b/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
index 9e7f536157e8a..e47cc810012fb 100644
--- a/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
+++ b/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
@@ -26,10 +26,11 @@ class FuzzerConnectorTestBase : public exec::test::OperatorTestBase {
 
   void SetUp() override {
     OperatorTestBase::SetUp();
+    std::shared_ptr<const config::ConfigBase> config;
     auto fuzzerConnector =
         connector::getConnectorFactory(
             connector::fuzzer::FuzzerConnectorFactory::kFuzzerConnectorName)
-            ->newConnector(kFuzzerConnectorId, nullptr);
+            ->newConnector(kFuzzerConnectorId, config);
     connector::registerConnector(fuzzerConnector);
   }
 
diff --git a/velox/connectors/hive/CMakeLists.txt b/velox/connectors/hive/CMakeLists.txt
index 5fbd19245169e..8beee704f79e6 100644
--- a/velox/connectors/hive/CMakeLists.txt
+++ b/velox/connectors/hive/CMakeLists.txt
@@ -12,15 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_hive_config OBJECT HiveConfig.cpp)
+velox_add_library(velox_hive_config OBJECT HiveConfig.cpp)
+velox_link_libraries(velox_hive_config velox_core velox_exception)
 
-target_link_libraries(velox_hive_config velox_exception)
+add_subdirectory(iceberg)
 
-add_library(
-  velox_hive_connector OBJECT
+velox_add_library(
+  velox_hive_connector
+  OBJECT
   FileHandle.cpp
   HiveConfig.cpp
   HiveConnector.cpp
+  HiveConnectorUtil.cpp
   HiveDataSink.cpp
   HiveDataSource.cpp
   HivePartitionUtil.cpp
@@ -28,24 +31,29 @@ add_library(
   SplitReader.cpp
   TableHandle.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_hive_connector
-  velox_common_io
-  velox_connector
-  velox_dwio_catalog_fbhive
-  velox_dwio_dwrf_reader
-  velox_dwio_dwrf_writer
-  velox_dwio_parquet_reader
-  velox_dwio_parquet_writer
-  velox_file
-  velox_hive_partition_function
-  velox_s3fs
-  velox_hdfs
-  velox_gcs)
-
-add_library(velox_hive_partition_function HivePartitionFunction.cpp)
-
-target_link_libraries(velox_hive_partition_function velox_core velox_exec)
+  PUBLIC velox_hive_iceberg_splitreader
+  PRIVATE
+    velox_common_io
+    velox_connector
+    velox_dwio_catalog_fbhive
+    velox_dwio_dwrf_reader
+    velox_dwio_dwrf_writer
+    velox_dwio_orc_reader
+    velox_dwio_parquet_reader
+    velox_dwio_parquet_writer
+    velox_file
+    velox_hive_partition_function
+    velox_type_tz
+    velox_s3fs
+    velox_hdfs
+    velox_gcs
+    velox_abfs)
+
+velox_add_library(velox_hive_partition_function HivePartitionFunction.cpp)
+
+velox_link_libraries(velox_hive_partition_function velox_core velox_exec)
 
 add_subdirectory(storage_adapters)
 
diff --git a/velox/connectors/hive/FileHandle.cpp b/velox/connectors/hive/FileHandle.cpp
index 44c219b328505..7678fb7a6c35c 100644
--- a/velox/connectors/hive/FileHandle.cpp
+++ b/velox/connectors/hive/FileHandle.cpp
@@ -24,6 +24,12 @@
 
 namespace facebook::velox {
 
+uint64_t FileHandleSizer::operator()(const FileHandle& fileHandle) {
+  // TODO: add to support variable file cache size support when the file system
+  // underneath supports.
+  return 1;
+}
+
 namespace {
 // The group tracking is at the level of the directory, i.e. Hive partition.
 std::string groupName(const std::string& filename) {
@@ -33,25 +39,30 @@ std::string groupName(const std::string& filename) {
 }
 } // namespace
 
-std::shared_ptr<FileHandle> FileHandleGenerator::operator()(
-    const std::string& filename) {
+std::unique_ptr<FileHandle> FileHandleGenerator::operator()(
+    const std::string& filename,
+    const FileProperties* properties) {
   // We have seen cases where drivers are stuck when creating file handles.
   // Adding a trace here to spot this more easily in future.
   process::TraceContext trace("FileHandleGenerator::operator()");
   uint64_t elapsedTimeUs{0};
-  std::shared_ptr<FileHandle> fileHandle;
+  std::unique_ptr<FileHandle> fileHandle;
   {
     MicrosecondTimer timer(&elapsedTimeUs);
-    fileHandle = std::make_shared<FileHandle>();
+    fileHandle = std::make_unique<FileHandle>();
+    filesystems::FileOptions options;
+    if (properties) {
+      options.fileSize = properties->fileSize;
+    }
     fileHandle->file = filesystems::getFileSystem(filename, properties_)
-                           ->openFileForRead(filename);
+                           ->openFileForRead(filename, options);
     fileHandle->uuid = StringIdLease(fileIds(), filename);
     fileHandle->groupId = StringIdLease(fileIds(), groupName(filename));
     VLOG(1) << "Generating file handle for: " << filename
             << " uuid: " << fileHandle->uuid.id();
   }
-  REPORT_ADD_HISTOGRAM_VALUE(
-      kCounterHiveFileHandleGenerateLatencyMs, elapsedTimeUs / 1000);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricHiveFileHandleGenerateLatencyMs, elapsedTimeUs / 1000);
   // TODO: build the hash map/etc per file type -- presumably after reading
   // the appropriate magic number from the file, or perhaps we include the file
   // type in the file handle key.
diff --git a/velox/connectors/hive/FileHandle.h b/velox/connectors/hive/FileHandle.h
index 15edd9d2ac2f4..5db30b1d7f4c3 100644
--- a/velox/connectors/hive/FileHandle.h
+++ b/velox/connectors/hive/FileHandle.h
@@ -25,19 +25,14 @@
 
 #pragma once
 
-#include <cstdint>
-#include <memory>
-#include <string>
-
 #include "velox/common/caching/CachedFactory.h"
 #include "velox/common/caching/FileIds.h"
+#include "velox/common/config/Config.h"
 #include "velox/common/file/File.h"
-#include "velox/dwio/common/InputStream.h"
+#include "velox/connectors/hive/FileProperties.h"
 
 namespace facebook::velox {
 
-class Config;
-
 // See the file comment.
 struct FileHandle {
   std::shared_ptr<ReadFile> file;
@@ -59,24 +54,35 @@ struct FileHandle {
   // first diff we'll not include the map.
 };
 
+/// Estimates the memory usage of a FileHandle object.
+struct FileHandleSizer {
+  uint64_t operator()(const FileHandle& a);
+};
+
 using FileHandleCache = SimpleLRUCache<std::string, FileHandle>;
 
 // Creates FileHandles via the Generator interface the CachedFactory requires.
 class FileHandleGenerator {
  public:
   FileHandleGenerator() {}
-  FileHandleGenerator(std::shared_ptr<const Config> properties)
+  FileHandleGenerator(std::shared_ptr<const config::ConfigBase> properties)
       : properties_(std::move(properties)) {}
-  std::shared_ptr<FileHandle> operator()(const std::string& filename);
+  std::unique_ptr<FileHandle> operator()(
+      const std::string& filename,
+      const FileProperties* properties);
 
  private:
-  const std::shared_ptr<const Config> properties_;
+  const std::shared_ptr<const config::ConfigBase> properties_;
 };
 
 using FileHandleFactory = CachedFactory<
     std::string,
-    std::shared_ptr<FileHandle>,
-    FileHandleGenerator>;
+    FileHandle,
+    FileHandleGenerator,
+    FileProperties,
+    FileHandleSizer>;
+
+using FileHandleCachedPtr = CachedPtr<std::string, FileHandle>;
 
 using FileHandleCacheStats = SimpleLRUCacheStats;
 
diff --git a/velox/connectors/hive/FileProperties.h b/velox/connectors/hive/FileProperties.h
new file mode 100644
index 0000000000000..6e6a0dbe5ccb0
--- /dev/null
+++ b/velox/connectors/hive/FileProperties.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// A FileHandle is a File pointer plus some (optional, file-type-dependent)
+// extra information for speeding up loading columnar data. For example, when
+// we open a file we might build a hash map saying what region(s) on disk
+// correspond to a given column in a given stripe.
+//
+// The FileHandle will normally be used in conjunction with a CachedFactory
+// to speed up queries that hit the same files repeatedly; see the
+// FileHandleCache and FileHandleFactory.
+
+#pragma once
+
+#include <cstdint>
+
+namespace facebook::velox {
+
+struct FileProperties {
+  std::optional<int64_t> fileSize;
+  std::optional<int64_t> modificationTime;
+};
+
+} // namespace facebook::velox
diff --git a/velox/connectors/hive/HiveConfig.cpp b/velox/connectors/hive/HiveConfig.cpp
index 003e4e448166b..27ee4cd8c6338 100644
--- a/velox/connectors/hive/HiveConfig.cpp
+++ b/velox/connectors/hive/HiveConfig.cpp
@@ -15,7 +15,8 @@
  */
 
 #include "velox/connectors/hive/HiveConfig.h"
-#include "velox/core/Config.h"
+#include "velox/common/config/Config.h"
+#include "velox/core/QueryConfig.h"
 
 #include <boost/algorithm/string.hpp>
 
@@ -38,16 +39,6 @@ stringToInsertExistingPartitionsBehavior(const std::string& strValue) {
 
 } // namespace
 
-// static
-HiveConfig::InsertExistingPartitionsBehavior
-HiveConfig::insertExistingPartitionsBehavior(const Config* config) {
-  const auto behavior =
-      config->get<std::string>(kInsertExistingPartitionsBehavior);
-  return behavior.has_value()
-      ? stringToInsertExistingPartitionsBehavior(behavior.value())
-      : InsertExistingPartitionsBehavior::kError;
-}
-
 // static
 std::string HiveConfig::insertExistingPartitionsBehaviorString(
     InsertExistingPartitionsBehavior behavior) {
@@ -61,108 +52,287 @@ std::string HiveConfig::insertExistingPartitionsBehaviorString(
   }
 }
 
-// static
-uint32_t HiveConfig::maxPartitionsPerWriters(const Config* config) {
-  return config->get<uint32_t>(kMaxPartitionsPerWriters, 100);
+HiveConfig::InsertExistingPartitionsBehavior
+HiveConfig::insertExistingPartitionsBehavior(
+    const config::ConfigBase* session) const {
+  return stringToInsertExistingPartitionsBehavior(session->get<std::string>(
+      kInsertExistingPartitionsBehaviorSession,
+      config_->get<std::string>(kInsertExistingPartitionsBehavior, "ERROR")));
 }
 
-// static
-bool HiveConfig::immutablePartitions(const Config* config) {
-  return config->get<bool>(kImmutablePartitions, false);
+uint32_t HiveConfig::maxPartitionsPerWriters(
+    const config::ConfigBase* session) const {
+  return session->get<uint32_t>(
+      kMaxPartitionsPerWritersSession,
+      config_->get<uint32_t>(kMaxPartitionsPerWriters, 100));
 }
 
-// static
-bool HiveConfig::s3UseVirtualAddressing(const Config* config) {
-  return !config->get(kS3PathStyleAccess, false);
+bool HiveConfig::immutablePartitions() const {
+  return config_->get<bool>(kImmutablePartitions, false);
 }
 
-// static
-std::string HiveConfig::s3GetLogLevel(const Config* config) {
-  return config->get(kS3LogLevel, std::string("FATAL"));
+bool HiveConfig::s3UseVirtualAddressing() const {
+  return !config_->get(kS3PathStyleAccess, false);
 }
 
-// static
-bool HiveConfig::s3UseSSL(const Config* config) {
-  return config->get(kS3SSLEnabled, true);
+std::string HiveConfig::s3GetLogLevel() const {
+  return config_->get(kS3LogLevel, std::string("FATAL"));
 }
 
-// static
-bool HiveConfig::s3UseInstanceCredentials(const Config* config) {
-  return config->get(kS3UseInstanceCredentials, false);
+bool HiveConfig::s3UseSSL() const {
+  return config_->get(kS3SSLEnabled, true);
 }
 
-// static
-std::string HiveConfig::s3Endpoint(const Config* config) {
-  return config->get(kS3Endpoint, std::string(""));
+bool HiveConfig::s3UseInstanceCredentials() const {
+  return config_->get(kS3UseInstanceCredentials, false);
 }
 
-// static
-std::optional<std::string> HiveConfig::s3AccessKey(const Config* config) {
-  if (config->isValueExists(kS3AwsAccessKey)) {
-    return config->get(kS3AwsAccessKey).value();
-  }
-  return {};
+std::string HiveConfig::s3Endpoint() const {
+  return config_->get(kS3Endpoint, std::string(""));
 }
 
-// static
-std::optional<std::string> HiveConfig::s3SecretKey(const Config* config) {
-  if (config->isValueExists(kS3AwsSecretKey)) {
-    return config->get(kS3AwsSecretKey).value();
-  }
-  return {};
+std::optional<std::string> HiveConfig::s3AccessKey() const {
+  return static_cast<std::optional<std::string>>(
+      config_->get<std::string>(kS3AwsAccessKey));
 }
 
-// static
-std::optional<std::string> HiveConfig::s3IAMRole(const Config* config) {
-  if (config->isValueExists(kS3IamRole)) {
-    return config->get(kS3IamRole).value();
+std::optional<std::string> HiveConfig::s3SecretKey() const {
+  return static_cast<std::optional<std::string>>(
+      config_->get<std::string>(kS3AwsSecretKey));
+}
+
+std::optional<std::string> HiveConfig::s3IAMRole() const {
+  return static_cast<std::optional<std::string>>(
+      config_->get<std::string>(kS3IamRole));
+}
+
+std::string HiveConfig::s3IAMRoleSessionName() const {
+  return config_->get(kS3IamRoleSessionName, std::string("velox-session"));
+}
+
+std::optional<std::string> HiveConfig::s3ConnectTimeout() const {
+  return static_cast<std::optional<std::string>>(
+      config_->get<std::string>(kS3ConnectTimeout));
+}
+
+std::optional<std::string> HiveConfig::s3SocketTimeout() const {
+  return static_cast<std::optional<std::string>>(
+      config_->get<std::string>(kS3SocketTimeout));
+}
+
+std::optional<uint32_t> HiveConfig::s3MaxConnections() const {
+  return static_cast<std::optional<std::uint32_t>>(
+      config_->get<uint32_t>(kS3MaxConnections));
+}
+
+std::optional<int32_t> HiveConfig::s3MaxAttempts() const {
+  return static_cast<std::optional<std::int32_t>>(
+      config_->get<int32_t>(kS3MaxAttempts));
+}
+
+std::optional<std::string> HiveConfig::s3RetryMode() const {
+  return static_cast<std::optional<std::string>>(
+      config_->get<std::string>(kS3RetryMode));
+}
+
+std::string HiveConfig::gcsEndpoint() const {
+  return config_->get<std::string>(kGCSEndpoint, std::string(""));
+}
+
+std::string HiveConfig::gcsScheme() const {
+  return config_->get<std::string>(kGCSScheme, std::string("https"));
+}
+
+std::string HiveConfig::gcsCredentials() const {
+  return config_->get<std::string>(kGCSCredentials, std::string(""));
+}
+
+std::optional<int> HiveConfig::gcsMaxRetryCount() const {
+  return static_cast<std::optional<int>>(config_->get<int>(kGCSMaxRetryCount));
+}
+
+std::optional<std::string> HiveConfig::gcsMaxRetryTime() const {
+  return static_cast<std::optional<std::string>>(
+      config_->get<std::string>(kGCSMaxRetryTime));
+}
+
+bool HiveConfig::isOrcUseColumnNames(const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kOrcUseColumnNamesSession, config_->get<bool>(kOrcUseColumnNames, false));
+}
+
+bool HiveConfig::isFileColumnNamesReadAsLowerCase(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kFileColumnNamesReadAsLowerCaseSession,
+      config_->get<bool>(kFileColumnNamesReadAsLowerCase, false));
+}
+
+bool HiveConfig::isPartitionPathAsLowerCase(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(kPartitionPathAsLowerCaseSession, true);
+}
+
+bool HiveConfig::allowNullPartitionKeys(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kAllowNullPartitionKeysSession,
+      config_->get<bool>(kAllowNullPartitionKeys, true));
+}
+
+bool HiveConfig::ignoreMissingFiles(const config::ConfigBase* session) const {
+  return session->get<bool>(kIgnoreMissingFilesSession, false);
+}
+
+int64_t HiveConfig::maxCoalescedBytes() const {
+  return config_->get<int64_t>(kMaxCoalescedBytes, 128 << 20);
+}
+
+int32_t HiveConfig::maxCoalescedDistanceBytes() const {
+  return config_->get<int32_t>(kMaxCoalescedDistanceBytes, 512 << 10);
+}
+
+int32_t HiveConfig::prefetchRowGroups() const {
+  return config_->get<int32_t>(kPrefetchRowGroups, 1);
+}
+
+int32_t HiveConfig::loadQuantum() const {
+  return config_->get<int32_t>(kLoadQuantum, 8 << 20);
+}
+
+int32_t HiveConfig::numCacheFileHandles() const {
+  return config_->get<int32_t>(kNumCacheFileHandles, 20'000);
+}
+
+bool HiveConfig::isFileHandleCacheEnabled() const {
+  return config_->get<bool>(kEnableFileHandleCache, true);
+}
+
+uint64_t HiveConfig::orcWriterMaxStripeSize(
+    const config::ConfigBase* session) const {
+  return config::toCapacity(
+      session->get<std::string>(
+          kOrcWriterMaxStripeSizeSession,
+          config_->get<std::string>(kOrcWriterMaxStripeSize, "64MB")),
+      config::CapacityUnit::BYTE);
+}
+
+uint64_t HiveConfig::orcWriterMaxDictionaryMemory(
+    const config::ConfigBase* session) const {
+  return config::toCapacity(
+      session->get<std::string>(
+          kOrcWriterMaxDictionaryMemorySession,
+          config_->get<std::string>(kOrcWriterMaxDictionaryMemory, "16MB")),
+      config::CapacityUnit::BYTE);
+}
+
+bool HiveConfig::isOrcWriterIntegerDictionaryEncodingEnabled(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kOrcWriterIntegerDictionaryEncodingEnabledSession,
+      config_->get<bool>(kOrcWriterIntegerDictionaryEncodingEnabled, true));
+}
+
+bool HiveConfig::isOrcWriterStringDictionaryEncodingEnabled(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kOrcWriterStringDictionaryEncodingEnabledSession,
+      config_->get<bool>(kOrcWriterStringDictionaryEncodingEnabled, true));
+}
+
+bool HiveConfig::orcWriterLinearStripeSizeHeuristics(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kOrcWriterLinearStripeSizeHeuristicsSession,
+      config_->get<bool>(kOrcWriterLinearStripeSizeHeuristics, true));
+}
+
+uint64_t HiveConfig::orcWriterMinCompressionSize(
+    const config::ConfigBase* session) const {
+  return session->get<uint64_t>(
+      kOrcWriterMinCompressionSizeSession,
+      config_->get<uint64_t>(kOrcWriterMinCompressionSize, 1024));
+}
+
+std::optional<uint8_t> HiveConfig::orcWriterCompressionLevel(
+    const config::ConfigBase* session) const {
+  auto sessionProp = session->get<uint8_t>(kOrcWriterCompressionLevelSession);
+
+  if (sessionProp.has_value()) {
+    return sessionProp.value();
+  }
+
+  auto configProp = config_->get<uint8_t>(kOrcWriterCompressionLevel);
+
+  if (configProp.has_value()) {
+    return configProp.value();
   }
-  return {};
+
+  // Presto has a single config controlling this value, but different defaults
+  // depending on the compression kind.
+  return std::nullopt;
 }
 
-// static
-std::string HiveConfig::s3IAMRoleSessionName(const Config* config) {
-  return config->get(kS3IamRoleSessionName, std::string("velox-session"));
+uint8_t HiveConfig::orcWriterZLIBCompressionLevel(
+    const config::ConfigBase* session) const {
+  constexpr uint8_t kDefaultZlibCompressionLevel = 4;
+  return orcWriterCompressionLevel(session).value_or(
+      kDefaultZlibCompressionLevel);
 }
 
-// static
-std::string HiveConfig::gcsEndpoint(const Config* config) {
-  return config->get<std::string>(kGCSEndpoint, std::string(""));
+uint8_t HiveConfig::orcWriterZSTDCompressionLevel(
+    const config::ConfigBase* session) const {
+  constexpr uint8_t kDefaultZstdCompressionLevel = 3;
+  return orcWriterCompressionLevel(session).value_or(
+      kDefaultZstdCompressionLevel);
 }
 
-// static
-std::string HiveConfig::gcsScheme(const Config* config) {
-  return config->get<std::string>(kGCSScheme, std::string("https"));
+std::string HiveConfig::writeFileCreateConfig() const {
+  return config_->get<std::string>(kWriteFileCreateConfig, "");
 }
 
-// static
-std::string HiveConfig::gcsCredentials(const Config* config) {
-  return config->get<std::string>(kGCSCredentials, std::string(""));
+uint32_t HiveConfig::sortWriterMaxOutputRows(
+    const config::ConfigBase* session) const {
+  return session->get<uint32_t>(
+      kSortWriterMaxOutputRowsSession,
+      config_->get<uint32_t>(kSortWriterMaxOutputRows, 1024));
+}
+
+uint64_t HiveConfig::sortWriterMaxOutputBytes(
+    const config::ConfigBase* session) const {
+  return config::toCapacity(
+      session->get<std::string>(
+          kSortWriterMaxOutputBytesSession,
+          config_->get<std::string>(kSortWriterMaxOutputBytes, "10MB")),
+      config::CapacityUnit::BYTE);
 }
 
-// static.
-bool HiveConfig::isOrcUseColumnNames(const Config* config) {
-  return config->get<bool>(kOrcUseColumnNames, false);
+uint64_t HiveConfig::footerEstimatedSize() const {
+  return config_->get<uint64_t>(kFooterEstimatedSize, 1UL << 20);
 }
 
-// static.
-bool HiveConfig::isFileColumnNamesReadAsLowerCase(const Config* config) {
-  return config->get<bool>(kFileColumnNamesReadAsLowerCase, false);
+uint64_t HiveConfig::filePreloadThreshold() const {
+  return config_->get<uint64_t>(kFilePreloadThreshold, 8UL << 20);
 }
 
-// static.
-int64_t HiveConfig::maxCoalescedBytes(const Config* config) {
-  return config->get<int64_t>(kMaxCoalescedBytes, 128 << 20);
+bool HiveConfig::s3UseProxyFromEnv() const {
+  return config_->get<bool>(kS3UseProxyFromEnv, false);
 }
 
-// static.
-int32_t HiveConfig::maxCoalescedDistanceBytes(const Config* config) {
-  return config->get<int32_t>(kMaxCoalescedDistanceBytes, 512 << 10);
+uint8_t HiveConfig::readTimestampUnit(const config::ConfigBase* session) const {
+  const auto unit = session->get<uint8_t>(
+      kReadTimestampUnitSession,
+      config_->get<uint8_t>(kReadTimestampUnit, 3 /*milli*/));
+  VELOX_CHECK(
+      unit == 3 || unit == 6 /*micro*/ || unit == 9 /*nano*/,
+      "Invalid timestamp unit.");
+  return unit;
 }
 
-// static.
-int32_t HiveConfig::numCacheFileHandles(const Config* config) {
-  return config->get<int32_t>(kNumCacheFileHandles, 20'000);
+bool HiveConfig::cacheNoRetention(const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kCacheNoRetentionSession,
+      config_->get<bool>(kCacheNoRetention, /*defaultValue=*/false));
 }
 
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConfig.h b/velox/connectors/hive/HiveConfig.h
index 131081fb4039f..8f572a3dab57f 100644
--- a/velox/connectors/hive/HiveConfig.h
+++ b/velox/connectors/hive/HiveConfig.h
@@ -17,9 +17,10 @@
 
 #include <optional>
 #include <string>
+#include "velox/common/base/Exceptions.h"
 
-namespace facebook::velox {
-class Config;
+namespace facebook::velox::config {
+class ConfigBase;
 }
 
 namespace facebook::velox::connector::hive {
@@ -36,12 +37,19 @@ class HiveConfig {
       InsertExistingPartitionsBehavior behavior);
 
   /// Behavior on insert into existing partitions.
-  static constexpr const char* kInsertExistingPartitionsBehavior =
+  static constexpr const char* kInsertExistingPartitionsBehaviorSession =
       "insert_existing_partitions_behavior";
+  static constexpr const char* kInsertExistingPartitionsBehavior =
+      "insert-existing-partitions-behavior";
 
   /// Maximum number of (bucketed) partitions per a single table writer
   /// instance.
+  ///
+  /// TODO: remove hive_orc_use_column_names since it doesn't exist in presto,
+  /// right now this is only used for testing.
   static constexpr const char* kMaxPartitionsPerWriters =
+      "max-partitions-per-writers";
+  static constexpr const char* kMaxPartitionsPerWritersSession =
       "max_partitions_per_writers";
 
   /// Whether new data can be inserted into an unpartition table.
@@ -81,72 +89,292 @@ class HiveConfig {
   static constexpr const char* kS3IamRoleSessionName =
       "hive.s3.iam-role-session-name";
 
-  // The GCS storage endpoint server.
+  /// Socket connect timeout.
+  static constexpr const char* kS3ConnectTimeout = "hive.s3.connect-timeout";
+
+  /// Socket read timeout.
+  static constexpr const char* kS3SocketTimeout = "hive.s3.socket-timeout";
+
+  /// Maximum concurrent TCP connections for a single http client.
+  static constexpr const char* kS3MaxConnections = "hive.s3.max-connections";
+
+  /// Maximum retry attempts for a single http client.
+  static constexpr const char* kS3MaxAttempts = "hive.s3.max-attempts";
+
+  /// Retry mode for a single http client.
+  static constexpr const char* kS3RetryMode = "hive.s3.retry-mode";
+
+  /// The GCS storage endpoint server.
   static constexpr const char* kGCSEndpoint = "hive.gcs.endpoint";
 
-  // The GCS storage scheme, https for default credentials.
+  /// The GCS storage scheme, https for default credentials.
   static constexpr const char* kGCSScheme = "hive.gcs.scheme";
 
-  // The GCS service account configuration as json string
+  /// The GCS service account configuration as json string
   static constexpr const char* kGCSCredentials = "hive.gcs.credentials";
 
-  // Map table field names to file field names using names, not indices.
+  /// The GCS maximum retry counter of transient errors.
+  static constexpr const char* kGCSMaxRetryCount = "hive.gcs.max-retry-count";
+
+  /// The GCS maximum time allowed to retry transient errors.
+  static constexpr const char* kGCSMaxRetryTime = "hive.gcs.max-retry-time";
+
+  /// Maps table field names to file field names using names, not indices.
+  // TODO: remove hive_orc_use_column_names since it doesn't exist in presto,
+  // right now this is only used for testing.
   static constexpr const char* kOrcUseColumnNames = "hive.orc.use-column-names";
+  static constexpr const char* kOrcUseColumnNamesSession =
+      "hive_orc_use_column_names";
 
-  // Read the source file column name as lower case.
+  /// Reads the source file column name as lower case.
   static constexpr const char* kFileColumnNamesReadAsLowerCase =
+      "file-column-names-read-as-lower-case";
+  static constexpr const char* kFileColumnNamesReadAsLowerCaseSession =
       "file_column_names_read_as_lower_case";
 
-  // Set the max coalesce bytes for a request.
+  static constexpr const char* kPartitionPathAsLowerCaseSession =
+      "partition_path_as_lower_case";
+
+  static constexpr const char* kAllowNullPartitionKeys =
+      "allow-null-partition-keys";
+  static constexpr const char* kAllowNullPartitionKeysSession =
+      "allow_null_partition_keys";
+
+  static constexpr const char* kIgnoreMissingFilesSession =
+      "ignore_missing_files";
+
+  /// The max coalesce bytes for a request.
   static constexpr const char* kMaxCoalescedBytes = "max-coalesced-bytes";
 
-  // Set the max coalesce distance bytes for combining requests.
+  /// The max coalesce distance bytes for combining requests.
   static constexpr const char* kMaxCoalescedDistanceBytes =
       "max-coalesced-distance-bytes";
 
+  /// The number of prefetch rowgroups
+  static constexpr const char* kPrefetchRowGroups = "prefetch-rowgroups";
+
+  /// The total size in bytes for a direct coalesce request. Up to 8MB load
+  /// quantum size is supported when SSD cache is enabled.
+  static constexpr const char* kLoadQuantum = "load-quantum";
+
   /// Maximum number of entries in the file handle cache.
   static constexpr const char* kNumCacheFileHandles = "num_cached_file_handles";
 
-  static InsertExistingPartitionsBehavior insertExistingPartitionsBehavior(
-      const Config* config);
+  /// Enable file handle cache.
+  static constexpr const char* kEnableFileHandleCache =
+      "file-handle-cache-enabled";
+
+  /// The size in bytes to be fetched with Meta data together, used when the
+  /// data after meta data will be used later. Optimization to decrease small IO
+  /// request
+  static constexpr const char* kFooterEstimatedSize = "footer-estimated-size";
+
+  /// The threshold of file size in bytes when the whole file is fetched with
+  /// meta data together. Optimization to decrease the small IO requests
+  static constexpr const char* kFilePreloadThreshold = "file-preload-threshold";
+
+  /// Maximum stripe size in orc writer.
+  static constexpr const char* kOrcWriterMaxStripeSize =
+      "hive.orc.writer.stripe-max-size";
+  static constexpr const char* kOrcWriterMaxStripeSizeSession =
+      "orc_optimized_writer_max_stripe_size";
+
+  /// Maximum dictionary memory that can be used in orc writer.
+  static constexpr const char* kOrcWriterMaxDictionaryMemory =
+      "hive.orc.writer.dictionary-max-memory";
+  static constexpr const char* kOrcWriterMaxDictionaryMemorySession =
+      "orc_optimized_writer_max_dictionary_memory";
+
+  /// Configs to control dictionary encoding.
+  static constexpr const char* kOrcWriterIntegerDictionaryEncodingEnabled =
+      "hive.orc.writer.integer-dictionary-encoding-enabled";
+  static constexpr const char*
+      kOrcWriterIntegerDictionaryEncodingEnabledSession =
+          "orc_optimized_writer_integer_dictionary_encoding_enabled";
+  static constexpr const char* kOrcWriterStringDictionaryEncodingEnabled =
+      "hive.orc.writer.string-dictionary-encoding-enabled";
+  static constexpr const char*
+      kOrcWriterStringDictionaryEncodingEnabledSession =
+          "orc_optimized_writer_string_dictionary_encoding_enabled";
+
+  /// Enables historical based stripe size estimation after compression.
+  static constexpr const char* kOrcWriterLinearStripeSizeHeuristics =
+      "hive.orc.writer.linear-stripe-size-heuristics";
+  static constexpr const char* kOrcWriterLinearStripeSizeHeuristicsSession =
+      "orc_writer_linear_stripe_size_heuristics";
+
+  /// Minimal number of items in an encoded stream.
+  static constexpr const char* kOrcWriterMinCompressionSize =
+      "hive.orc.writer.min-compression-size";
+  static constexpr const char* kOrcWriterMinCompressionSizeSession =
+      "orc_writer_min_compression_size";
+
+  /// The compression level to use with ZLIB and ZSTD.
+  static constexpr const char* kOrcWriterCompressionLevel =
+      "hive.orc.writer.compression-level";
+  static constexpr const char* kOrcWriterCompressionLevelSession =
+      "orc_optimized_writer_compression_level";
+
+  /// Config used to create write files. This config is provided to underlying
+  /// file system through hive connector and data sink. The config is free form.
+  /// The form should be defined by the underlying file system.
+  static constexpr const char* kWriteFileCreateConfig =
+      "hive.write_file_create_config";
+
+  /// Maximum number of rows for sort writer in one batch of output.
+  static constexpr const char* kSortWriterMaxOutputRows =
+      "sort-writer-max-output-rows";
+  static constexpr const char* kSortWriterMaxOutputRowsSession =
+      "sort_writer_max_output_rows";
+
+  /// Maximum bytes for sort writer in one batch of output.
+  static constexpr const char* kSortWriterMaxOutputBytes =
+      "sort-writer-max-output-bytes";
+  static constexpr const char* kSortWriterMaxOutputBytesSession =
+      "sort_writer_max_output_bytes";
+
+  static constexpr const char* kS3UseProxyFromEnv =
+      "hive.s3.use-proxy-from-env";
+
+  // The unit for reading timestamps from files.
+  static constexpr const char* kReadTimestampUnit =
+      "hive.reader.timestamp-unit";
+  static constexpr const char* kReadTimestampUnitSession =
+      "hive.reader.timestamp_unit";
+
+  static constexpr const char* kCacheNoRetention = "cache.no_retention";
+  static constexpr const char* kCacheNoRetentionSession = "cache.no_retention";
+
+  InsertExistingPartitionsBehavior insertExistingPartitionsBehavior(
+      const config::ConfigBase* session) const;
+
+  uint32_t maxPartitionsPerWriters(const config::ConfigBase* session) const;
+
+  bool immutablePartitions() const;
+
+  bool s3UseVirtualAddressing() const;
+
+  std::string s3GetLogLevel() const;
+
+  bool s3UseSSL() const;
+
+  bool s3UseInstanceCredentials() const;
+
+  std::string s3Endpoint() const;
+
+  std::optional<std::string> s3AccessKey() const;
+
+  std::optional<std::string> s3SecretKey() const;
+
+  std::optional<std::string> s3IAMRole() const;
+
+  std::string s3IAMRoleSessionName() const;
+
+  std::optional<std::string> s3ConnectTimeout() const;
+
+  std::optional<std::string> s3SocketTimeout() const;
+
+  std::optional<uint32_t> s3MaxConnections() const;
+
+  std::optional<int32_t> s3MaxAttempts() const;
+
+  std::optional<std::string> s3RetryMode() const;
+
+  std::string gcsEndpoint() const;
+
+  std::string gcsScheme() const;
+
+  std::string gcsCredentials() const;
+
+  std::optional<int> gcsMaxRetryCount() const;
+
+  std::optional<std::string> gcsMaxRetryTime() const;
+
+  bool isOrcUseColumnNames(const config::ConfigBase* session) const;
+
+  bool isFileColumnNamesReadAsLowerCase(
+      const config::ConfigBase* session) const;
+
+  bool isPartitionPathAsLowerCase(const config::ConfigBase* session) const;
+
+  bool allowNullPartitionKeys(const config::ConfigBase* session) const;
+
+  bool ignoreMissingFiles(const config::ConfigBase* session) const;
+
+  int64_t maxCoalescedBytes() const;
+
+  int32_t maxCoalescedDistanceBytes() const;
+
+  int32_t prefetchRowGroups() const;
+
+  int32_t loadQuantum() const;
+
+  int32_t numCacheFileHandles() const;
+
+  bool isFileHandleCacheEnabled() const;
+
+  uint64_t fileWriterFlushThresholdBytes() const;
+
+  uint64_t orcWriterMaxStripeSize(const config::ConfigBase* session) const;
 
-  static uint32_t maxPartitionsPerWriters(const Config* config);
+  uint64_t orcWriterMaxDictionaryMemory(
+      const config::ConfigBase* session) const;
 
-  static bool immutablePartitions(const Config* config);
+  bool isOrcWriterIntegerDictionaryEncodingEnabled(
+      const config::ConfigBase* session) const;
 
-  static bool s3UseVirtualAddressing(const Config* config);
+  bool isOrcWriterStringDictionaryEncodingEnabled(
+      const config::ConfigBase* session) const;
 
-  static std::string s3GetLogLevel(const Config* config);
+  bool orcWriterLinearStripeSizeHeuristics(
+      const config::ConfigBase* session) const;
 
-  static bool s3UseSSL(const Config* config);
+  uint64_t orcWriterMinCompressionSize(const config::ConfigBase* session) const;
 
-  static bool s3UseInstanceCredentials(const Config* config);
+  std::optional<uint8_t> orcWriterCompressionLevel(
+      const config::ConfigBase* session) const;
 
-  static std::string s3Endpoint(const Config* config);
+  uint8_t orcWriterZLIBCompressionLevel(
+      const config::ConfigBase* session) const;
 
-  static std::optional<std::string> s3AccessKey(const Config* config);
+  uint8_t orcWriterZSTDCompressionLevel(
+      const config::ConfigBase* session) const;
 
-  static std::optional<std::string> s3SecretKey(const Config* config);
+  std::string writeFileCreateConfig() const;
 
-  static std::optional<std::string> s3IAMRole(const Config* config);
+  uint32_t sortWriterMaxOutputRows(const config::ConfigBase* session) const;
 
-  static std::string s3IAMRoleSessionName(const Config* config);
+  uint64_t sortWriterMaxOutputBytes(const config::ConfigBase* session) const;
 
-  static std::string gcsEndpoint(const Config* config);
+  uint64_t footerEstimatedSize() const;
 
-  static std::string gcsScheme(const Config* config);
+  uint64_t filePreloadThreshold() const;
 
-  static std::string gcsCredentials(const Config* config);
+  bool s3UseProxyFromEnv() const;
 
-  static bool isOrcUseColumnNames(const Config* config);
+  // Returns the timestamp unit used when reading timestamps from files.
+  uint8_t readTimestampUnit(const config::ConfigBase* session) const;
 
-  static bool isFileColumnNamesReadAsLowerCase(const Config* config);
+  /// Returns true to evict out a query scanned data out of in-memory cache
+  /// right after the access, and also skip staging to the ssd cache. This helps
+  /// to prevent the cache space pollution from the one-time table scan by large
+  /// batch query when mixed running with interactive query which has high data
+  /// locality.
+  bool cacheNoRetention(const config::ConfigBase* session) const;
 
-  static int64_t maxCoalescedBytes(const Config* config);
+  HiveConfig(std::shared_ptr<const config::ConfigBase> config) {
+    VELOX_CHECK_NOT_NULL(
+        config, "Config is null for HiveConfig initialization");
+    config_ = std::move(config);
+    // TODO: add sanity check
+  }
 
-  static int32_t maxCoalescedDistanceBytes(const Config* config);
+  const std::shared_ptr<const config::ConfigBase>& config() const {
+    return config_;
+  }
 
-  static int32_t numCacheFileHandles(const Config* config);
+ private:
+  std::shared_ptr<const config::ConfigBase> config_;
 };
 
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConnector.cpp b/velox/connectors/hive/HiveConnector.cpp
index 522ec99058f4c..4b1a5c608b283 100644
--- a/velox/connectors/hive/HiveConnector.cpp
+++ b/velox/connectors/hive/HiveConnector.cpp
@@ -21,23 +21,18 @@
 #include "velox/connectors/hive/HiveDataSink.h"
 #include "velox/connectors/hive/HiveDataSource.h"
 #include "velox/connectors/hive/HivePartitionFunction.h"
-// Meta's buck build system needs this check.
-#ifdef VELOX_ENABLE_GCS
+#include "velox/dwio/dwrf/RegisterDwrfReader.h"
+#include "velox/dwio/dwrf/RegisterDwrfWriter.h"
+
+#include "velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h" // @manual
 #include "velox/connectors/hive/storage_adapters/gcs/RegisterGCSFileSystem.h" // @manual
-#endif
-#ifdef VELOX_ENABLE_HDFS3
 #include "velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h" // @manual
-#endif
-#ifdef VELOX_ENABLE_S3
 #include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h" // @manual
-#endif
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
-// Meta's buck build system needs this check.
-#ifdef VELOX_ENABLE_PARQUET
+#include "velox/dwio/orc/reader/OrcReader.h"
 #include "velox/dwio/parquet/RegisterParquetReader.h" // @manual
 #include "velox/dwio/parquet/RegisterParquetWriter.h" // @manual
-#endif
 #include "velox/expression/FieldReference.h"
 
 #include <boost/lexical_cast.hpp>
@@ -48,24 +43,27 @@ using namespace facebook::velox::dwrf;
 
 namespace facebook::velox::connector::hive {
 
-int32_t numCachedFileHandles(const Config* properties) {
-  return properties ? HiveConfig::numCacheFileHandles(properties) : 20'000;
-}
-
 HiveConnector::HiveConnector(
     const std::string& id,
-    std::shared_ptr<const Config> properties,
-    folly::Executor* FOLLY_NULLABLE executor)
-    : Connector(id, properties),
+    std::shared_ptr<const config::ConfigBase> config,
+    folly::Executor* executor)
+    : Connector(id),
+      hiveConfig_(std::make_shared<HiveConfig>(config)),
       fileHandleFactory_(
-          std::make_unique<
-              SimpleLRUCache<std::string, std::shared_ptr<FileHandle>>>(
-              numCachedFileHandles(properties.get())),
-          std::make_unique<FileHandleGenerator>(properties)),
+          hiveConfig_->isFileHandleCacheEnabled()
+              ? std::make_unique<SimpleLRUCache<std::string, FileHandle>>(
+                    hiveConfig_->numCacheFileHandles())
+              : nullptr,
+          std::make_unique<FileHandleGenerator>(config)),
       executor_(executor) {
-  LOG(INFO) << "Hive connector " << connectorId() << " created with maximum of "
-            << numCachedFileHandles(properties.get())
-            << " cached file handles.";
+  if (hiveConfig_->isFileHandleCacheEnabled()) {
+    LOG(INFO) << "Hive connector " << connectorId()
+              << " created with maximum of "
+              << hiveConfig_->numCacheFileHandles() << " cached file handles.";
+  } else {
+    LOG(INFO) << "Hive connector " << connectorId()
+              << " created with file handle cache disabled";
+  }
 }
 
 std::unique_ptr<DataSource> HiveConnector::createDataSource(
@@ -75,27 +73,14 @@ std::unique_ptr<DataSource> HiveConnector::createDataSource(
         std::string,
         std::shared_ptr<connector::ColumnHandle>>& columnHandles,
     ConnectorQueryCtx* connectorQueryCtx) {
-  dwio::common::ReaderOptions options(connectorQueryCtx->memoryPool());
-  options.setMaxCoalesceBytes(
-      HiveConfig::maxCoalescedBytes(connectorQueryCtx->config()));
-  options.setMaxCoalesceDistance(
-      HiveConfig::maxCoalescedDistanceBytes(connectorQueryCtx->config()));
-  options.setFileColumnNamesReadAsLowerCase(
-      HiveConfig::isFileColumnNamesReadAsLowerCase(
-          connectorQueryCtx->config()));
-  options.setUseColumnNamesForColumnMapping(
-      HiveConfig::isOrcUseColumnNames(connectorQueryCtx->config()));
-
   return std::make_unique<HiveDataSource>(
       outputType,
       tableHandle,
       columnHandles,
       &fileHandleFactory_,
-      connectorQueryCtx->expressionEvaluator(),
-      connectorQueryCtx->cache(),
-      connectorQueryCtx->scanId(),
       executor_,
-      options);
+      connectorQueryCtx,
+      hiveConfig_);
 }
 
 std::unique_ptr<DataSink> HiveConnector::createDataSink(
@@ -112,7 +97,7 @@ std::unique_ptr<DataSink> HiveConnector::createDataSink(
       hiveInsertHandle,
       connectorQueryCtx,
       commitStrategy,
-      connectorProperties());
+      hiveConfig_);
 }
 
 std::unique_ptr<core::PartitionFunction> HivePartitionFunctionSpec::create(
@@ -136,25 +121,19 @@ std::unique_ptr<core::PartitionFunction> HivePartitionFunctionSpec::create(
 }
 
 void HiveConnectorFactory::initialize() {
-  static bool once = []() {
+  [[maybe_unused]] static bool once = []() {
     dwio::common::registerFileSinks();
     dwrf::registerDwrfReaderFactory();
     dwrf::registerDwrfWriterFactory();
-// Meta's buck build system needs this check.
-#ifdef VELOX_ENABLE_PARQUET
+    orc::registerOrcReaderFactory();
+
     parquet::registerParquetReaderFactory();
     parquet::registerParquetWriterFactory();
-#endif
-// Meta's buck build system needs this check.
-#ifdef VELOX_ENABLE_S3
+
     filesystems::registerS3FileSystem();
-#endif
-#ifdef VELOX_ENABLE_HDFS3
     filesystems::registerHdfsFileSystem();
-#endif
-#ifdef VELOX_ENABLE_GCS
     filesystems::registerGCSFileSystem();
-#endif
+    filesystems::abfs::registerAbfsFileSystem();
     return true;
   }();
 }
diff --git a/velox/connectors/hive/HiveConnector.h b/velox/connectors/hive/HiveConnector.h
index a8740594ad867..c0b0c1bf7013a 100644
--- a/velox/connectors/hive/HiveConnector.h
+++ b/velox/connectors/hive/HiveConnector.h
@@ -17,6 +17,7 @@
 
 #include "velox/connectors/Connector.h"
 #include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConfig.h"
 #include "velox/core/PlanNode.h"
 
 namespace facebook::velox::dwio::common {
@@ -30,8 +31,13 @@ class HiveConnector : public Connector {
  public:
   HiveConnector(
       const std::string& id,
-      std::shared_ptr<const Config> properties,
-      folly::Executor* FOLLY_NULLABLE executor);
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* executor);
+
+  const std::shared_ptr<const config::ConfigBase>& connectorConfig()
+      const override {
+    return hiveConfig_->config();
+  }
 
   bool canAddDynamicFilter() const override {
     return true;
@@ -55,7 +61,7 @@ class HiveConnector : public Connector {
       ConnectorQueryCtx* connectorQueryCtx,
       CommitStrategy commitStrategy) override final;
 
-  folly::Executor* FOLLY_NULLABLE executor() const override {
+  folly::Executor* executor() const override {
     return executor_;
   }
 
@@ -70,19 +76,19 @@ class HiveConnector : public Connector {
   }
 
  protected:
+  const std::shared_ptr<HiveConfig> hiveConfig_;
   FileHandleFactory fileHandleFactory_;
-  folly::Executor* FOLLY_NULLABLE executor_;
+  folly::Executor* executor_;
 };
 
 class HiveConnectorFactory : public ConnectorFactory {
  public:
-  static constexpr const char* FOLLY_NONNULL kHiveConnectorName = "hive";
-  static constexpr const char* FOLLY_NONNULL kHiveHadoop2ConnectorName =
-      "hive-hadoop2";
+  static constexpr const char* kHiveConnectorName = "hive";
+  static constexpr const char* kHiveHadoop2ConnectorName = "hive-hadoop2";
 
   HiveConnectorFactory() : ConnectorFactory(kHiveConnectorName) {}
 
-  explicit HiveConnectorFactory(const char* FOLLY_NONNULL connectorName)
+  explicit HiveConnectorFactory(const char* connectorName)
       : ConnectorFactory(connectorName) {}
 
   /// Register HiveConnector components such as Dwrf, Parquet readers and
@@ -91,9 +97,9 @@ class HiveConnectorFactory : public ConnectorFactory {
 
   std::shared_ptr<Connector> newConnector(
       const std::string& id,
-      std::shared_ptr<const Config> properties,
-      folly::Executor* FOLLY_NULLABLE executor = nullptr) override {
-    return std::make_shared<HiveConnector>(id, properties, executor);
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* executor = nullptr) override {
+    return std::make_shared<HiveConnector>(id, config, executor);
   }
 };
 
diff --git a/velox/connectors/hive/HiveConnectorSplit.h b/velox/connectors/hive/HiveConnectorSplit.h
index 5b46c5329a1ef..9c011ef3aea84 100644
--- a/velox/connectors/hive/HiveConnectorSplit.h
+++ b/velox/connectors/hive/HiveConnectorSplit.h
@@ -18,22 +18,50 @@
 #include <optional>
 #include <unordered_map>
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileProperties.h"
+#include "velox/connectors/hive/TableHandle.h"
 #include "velox/dwio/common/Options.h"
 
 namespace facebook::velox::connector::hive {
 
+/// A bucket conversion that should happen on the split.  This happens when we
+/// increase the bucket count of a table, but the old partitions are still
+/// generated using the old bucket count, so that multiple new buckets can exist
+/// in the same file, and we need to apply extra filter when we read these files
+/// to make sure we read the rows corresponding to the selected bucket number
+/// only.
+struct HiveBucketConversion {
+  int32_t tableBucketCount;
+  int32_t partitionBucketCount;
+  std::vector<std::unique_ptr<HiveColumnHandle>> bucketColumnHandles;
+};
+
 struct HiveConnectorSplit : public connector::ConnectorSplit {
   const std::string filePath;
   dwio::common::FileFormat fileFormat;
   const uint64_t start;
   const uint64_t length;
+
+  /// Mapping from partition keys to values. Values are specified as strings
+  /// formatted the same way as CAST(x as VARCHAR). Null values are specified as
+  /// std::nullopt. Date values must be formatted using ISO 8601 as YYYY-MM-DD.
+  /// All scalar types and date type are supported.
   const std::unordered_map<std::string, std::optional<std::string>>
       partitionKeys;
   std::optional<int32_t> tableBucketNumber;
+  std::optional<HiveBucketConversion> bucketConversion;
   std::unordered_map<std::string, std::string> customSplitInfo;
   std::shared_ptr<std::string> extraFileInfo;
   std::unordered_map<std::string, std::string> serdeParameters;
 
+  /// These represent columns like $file_size, $file_modified_time that are
+  /// associated with the HiveSplit.
+  std::unordered_map<std::string, std::string> infoColumns;
+
+  /// These represent file properties like file size that are used while opening
+  /// the file handle.
+  std::optional<FileProperties> properties;
+
   HiveConnectorSplit(
       const std::string& connectorId,
       const std::string& _filePath,
@@ -45,8 +73,11 @@ struct HiveConnectorSplit : public connector::ConnectorSplit {
       std::optional<int32_t> _tableBucketNumber = std::nullopt,
       const std::unordered_map<std::string, std::string>& _customSplitInfo = {},
       const std::shared_ptr<std::string>& _extraFileInfo = {},
-      const std::unordered_map<std::string, std::string>& _serdeParameters = {})
-      : ConnectorSplit(connectorId),
+      const std::unordered_map<std::string, std::string>& _serdeParameters = {},
+      int64_t _splitWeight = 0,
+      const std::unordered_map<std::string, std::string>& _infoColumns = {},
+      std::optional<FileProperties> _properties = std::nullopt)
+      : ConnectorSplit(connectorId, _splitWeight),
         filePath(_filePath),
         fileFormat(_fileFormat),
         start(_start),
@@ -55,7 +86,9 @@ struct HiveConnectorSplit : public connector::ConnectorSplit {
         tableBucketNumber(_tableBucketNumber),
         customSplitInfo(_customSplitInfo),
         extraFileInfo(_extraFileInfo),
-        serdeParameters(_serdeParameters) {}
+        serdeParameters(_serdeParameters),
+        infoColumns(_infoColumns),
+        properties(_properties) {}
 
   std::string toString() const override {
     if (tableBucketNumber.has_value()) {
diff --git a/velox/connectors/hive/HiveConnectorUtil.cpp b/velox/connectors/hive/HiveConnectorUtil.cpp
new file mode 100644
index 0000000000000..b6de7566dc11a
--- /dev/null
+++ b/velox/connectors/hive/HiveConnectorUtil.cpp
@@ -0,0 +1,1014 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/common/BufferedInput.h"
+#include "velox/dwio/common/CachedBufferedInput.h"
+#include "velox/dwio/common/DirectBufferedInput.h"
+#include "velox/dwio/common/Reader.h"
+#include "velox/dwio/dwrf/common/Config.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+
+#ifdef VELOX_ENABLE_PARQUET
+#include "velox/dwio/parquet/writer/Writer.h" // @manual
+#endif
+
+#include "velox/expression/Expr.h"
+#include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/type/TimestampConversion.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox::connector::hive {
+namespace {
+
+struct SubfieldSpec {
+  const common::Subfield* subfield;
+  bool filterOnly;
+};
+
+template <typename T>
+void deduplicate(std::vector<T>& values) {
+  std::sort(values.begin(), values.end());
+  values.erase(std::unique(values.begin(), values.end()), values.end());
+}
+
+// Floating point map key subscripts are truncated toward 0 in Presto.  For
+// example given `a' as a map with floating point key, if user queries a[0.99],
+// Presto coordinator will generate a required subfield a[0]; for a[-1.99] it
+// will generate a[-1]; for anything larger than 9223372036854775807, it
+// generates a[9223372036854775807]; for anything smaller than
+// -9223372036854775808 it generates a[-9223372036854775808].
+template <typename T>
+std::unique_ptr<common::Filter> makeFloatingPointMapKeyFilter(
+    const std::vector<int64_t>& subscripts) {
+  std::vector<std::unique_ptr<common::Filter>> filters;
+  for (auto subscript : subscripts) {
+    T lower = subscript;
+    T upper = subscript;
+    bool lowerUnbounded = subscript == std::numeric_limits<int64_t>::min();
+    bool upperUnbounded = subscript == std::numeric_limits<int64_t>::max();
+    bool lowerExclusive = false;
+    bool upperExclusive = false;
+    if (lower <= 0 && !lowerUnbounded) {
+      if (lower > subscript - 1) {
+        lower = subscript - 1;
+      } else {
+        lower = std::nextafter(lower, -std::numeric_limits<T>::infinity());
+      }
+      lowerExclusive = true;
+    }
+    if (upper >= 0 && !upperUnbounded) {
+      if (upper < subscript + 1) {
+        upper = subscript + 1;
+      } else {
+        upper = std::nextafter(upper, std::numeric_limits<T>::infinity());
+      }
+      upperExclusive = true;
+    }
+    if (lowerUnbounded && upperUnbounded) {
+      continue;
+    }
+    filters.push_back(std::make_unique<common::FloatingPointRange<T>>(
+        lower,
+        lowerUnbounded,
+        lowerExclusive,
+        upper,
+        upperUnbounded,
+        upperExclusive,
+        false));
+  }
+  if (filters.size() == 1) {
+    return std::move(filters[0]);
+  }
+  return std::make_unique<common::MultiRange>(std::move(filters), false);
+}
+
+// Recursively add subfields to scan spec.
+void addSubfields(
+    const Type& type,
+    std::vector<SubfieldSpec>& subfields,
+    int level,
+    memory::MemoryPool* pool,
+    common::ScanSpec& spec) {
+  int newSize = 0;
+  for (int i = 0; i < subfields.size(); ++i) {
+    if (level < subfields[i].subfield->path().size()) {
+      subfields[newSize++] = subfields[i];
+    } else if (!subfields[i].filterOnly) {
+      spec.addAllChildFields(type);
+      return;
+    }
+  }
+  subfields.resize(newSize);
+  switch (type.kind()) {
+    case TypeKind::ROW: {
+      folly::F14FastMap<std::string, std::vector<SubfieldSpec>> required;
+      for (auto& subfield : subfields) {
+        auto* element = subfield.subfield->path()[level].get();
+        auto* nestedField =
+            dynamic_cast<const common::Subfield::NestedField*>(element);
+        VELOX_CHECK(
+            nestedField,
+            "Unsupported for row subfields pruning: {}",
+            element->toString());
+        required[nestedField->name()].push_back(subfield);
+      }
+      auto& rowType = type.asRow();
+      for (int i = 0; i < rowType.size(); ++i) {
+        auto& childName = rowType.nameOf(i);
+        auto& childType = rowType.childAt(i);
+        auto* child = spec.addField(childName, i);
+        auto it = required.find(childName);
+        if (it == required.end()) {
+          child->setConstantValue(
+              BaseVector::createNullConstant(childType, 1, pool));
+        } else {
+          addSubfields(*childType, it->second, level + 1, pool, *child);
+        }
+      }
+      break;
+    }
+    case TypeKind::MAP: {
+      auto& keyType = type.childAt(0);
+      auto* keys = spec.addMapKeyFieldRecursively(*keyType);
+      addSubfields(
+          *type.childAt(1),
+          subfields,
+          level + 1,
+          pool,
+          *spec.addMapValueField());
+      if (subfields.empty()) {
+        return;
+      }
+      bool stringKey = keyType->isVarchar() || keyType->isVarbinary();
+      std::vector<std::string> stringSubscripts;
+      std::vector<int64_t> longSubscripts;
+      for (auto& subfield : subfields) {
+        auto* element = subfield.subfield->path()[level].get();
+        if (dynamic_cast<const common::Subfield::AllSubscripts*>(element)) {
+          return;
+        }
+        if (stringKey) {
+          auto* subscript =
+              dynamic_cast<const common::Subfield::StringSubscript*>(element);
+          VELOX_CHECK(
+              subscript,
+              "Unsupported for string map pruning: {}",
+              element->toString());
+          stringSubscripts.push_back(subscript->index());
+        } else {
+          auto* subscript =
+              dynamic_cast<const common::Subfield::LongSubscript*>(element);
+          VELOX_CHECK(
+              subscript,
+              "Unsupported for long map pruning: {}",
+              element->toString());
+          longSubscripts.push_back(subscript->index());
+        }
+      }
+      std::unique_ptr<common::Filter> filter;
+      if (stringKey) {
+        deduplicate(stringSubscripts);
+        filter = std::make_unique<common::BytesValues>(stringSubscripts, false);
+        spec.setFlatMapFeatureSelection(std::move(stringSubscripts));
+      } else {
+        deduplicate(longSubscripts);
+        if (keyType->isReal()) {
+          filter = makeFloatingPointMapKeyFilter<float>(longSubscripts);
+        } else if (keyType->isDouble()) {
+          filter = makeFloatingPointMapKeyFilter<double>(longSubscripts);
+        } else {
+          filter = common::createBigintValues(longSubscripts, false);
+        }
+        std::vector<std::string> features;
+        for (auto num : longSubscripts) {
+          features.push_back(std::to_string(num));
+        }
+        spec.setFlatMapFeatureSelection(std::move(features));
+      }
+      keys->setFilter(std::move(filter));
+      break;
+    }
+    case TypeKind::ARRAY: {
+      addSubfields(
+          *type.childAt(0),
+          subfields,
+          level + 1,
+          pool,
+          *spec.addArrayElementField());
+      if (subfields.empty()) {
+        return;
+      }
+      constexpr long kMaxIndex = std::numeric_limits<vector_size_t>::max();
+      long maxIndex = -1;
+      for (auto& subfield : subfields) {
+        auto* element = subfield.subfield->path()[level].get();
+        if (dynamic_cast<const common::Subfield::AllSubscripts*>(element)) {
+          return;
+        }
+        auto* subscript =
+            dynamic_cast<const common::Subfield::LongSubscript*>(element);
+        VELOX_CHECK(
+            subscript,
+            "Unsupported for array pruning: {}",
+            element->toString());
+        VELOX_USER_CHECK_GT(
+            subscript->index(),
+            0,
+            "Non-positive array subscript cannot be push down");
+        maxIndex = std::max(maxIndex, std::min(kMaxIndex, subscript->index()));
+      }
+      spec.setMaxArrayElementsCount(maxIndex);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+inline uint8_t parseDelimiter(const std::string& delim) {
+  for (char const& ch : delim) {
+    if (!std::isdigit(ch)) {
+      return delim[0];
+    }
+  }
+  return stoi(delim);
+}
+
+inline bool isSynthesizedColumn(
+    const std::string& name,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        infoColumns) {
+  return name == kPath || name == kBucket || infoColumns.count(name) != 0;
+}
+
+inline bool isRowIndexColumn(
+    const std::string& name,
+    std::shared_ptr<HiveColumnHandle> rowIndexColumn) {
+  return rowIndexColumn != nullptr && rowIndexColumn->name() == name;
+}
+
+} // namespace
+
+const std::string& getColumnName(const common::Subfield& subfield) {
+  VELOX_CHECK_GT(subfield.path().size(), 0);
+  auto* field = dynamic_cast<const common::Subfield::NestedField*>(
+      subfield.path()[0].get());
+  VELOX_CHECK_NOT_NULL(field);
+  return field->name();
+}
+
+void checkColumnNameLowerCase(const std::shared_ptr<const Type>& type) {
+  switch (type->kind()) {
+    case TypeKind::ARRAY:
+      checkColumnNameLowerCase(type->asArray().elementType());
+      break;
+    case TypeKind::MAP: {
+      checkColumnNameLowerCase(type->asMap().keyType());
+      checkColumnNameLowerCase(type->asMap().valueType());
+
+    } break;
+    case TypeKind::ROW: {
+      for (const auto& outputName : type->asRow().names()) {
+        VELOX_CHECK(
+            !std::any_of(outputName.begin(), outputName.end(), isupper));
+      }
+      for (auto& childType : type->asRow().children()) {
+        checkColumnNameLowerCase(childType);
+      }
+    } break;
+    default:
+      VLOG(1) << "No need to check type lowercase mode" << type->toString();
+  }
+}
+
+void checkColumnNameLowerCase(
+    const SubfieldFilters& filters,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        infoColumns) {
+  for (const auto& filterIt : filters) {
+    const auto name = filterIt.first.toString();
+    if (isSynthesizedColumn(name, infoColumns)) {
+      continue;
+    }
+    const auto& path = filterIt.first.path();
+
+    for (int i = 0; i < path.size(); ++i) {
+      auto* nestedField =
+          dynamic_cast<const common::Subfield::NestedField*>(path[i].get());
+      if (nestedField == nullptr) {
+        continue;
+      }
+      VELOX_CHECK(!std::any_of(
+          nestedField->name().begin(), nestedField->name().end(), isupper));
+    }
+  }
+}
+
+void checkColumnNameLowerCase(const core::TypedExprPtr& typeExpr) {
+  if (typeExpr == nullptr) {
+    return;
+  }
+  checkColumnNameLowerCase(typeExpr->type());
+  for (auto& type : typeExpr->inputs()) {
+    checkColumnNameLowerCase(type);
+  }
+}
+
+namespace {
+
+void processFieldSpec(
+    const RowTypePtr& dataColumns,
+    const TypePtr& outputType,
+    common::ScanSpec& fieldSpec) {
+  fieldSpec.visit(*outputType, [](const Type& type, common::ScanSpec& spec) {
+    if (type.isMap() && !spec.isConstant()) {
+      auto* keys = spec.childByName(common::ScanSpec::kMapKeysFieldName);
+      VELOX_CHECK_NOT_NULL(keys);
+      keys->addFilter(common::IsNotNull());
+    }
+  });
+  if (dataColumns) {
+    auto i = dataColumns->getChildIdxIfExists(fieldSpec.fieldName());
+    if (i.has_value()) {
+      if (dataColumns->childAt(*i)->isMap() && outputType->isRow()) {
+        fieldSpec.setFlatMapAsStruct(true);
+      }
+    }
+  }
+}
+
+} // namespace
+
+std::shared_ptr<common::ScanSpec> makeScanSpec(
+    const RowTypePtr& rowType,
+    const folly::F14FastMap<std::string, std::vector<const common::Subfield*>>&
+        outputSubfields,
+    const SubfieldFilters& filters,
+    const RowTypePtr& dataColumns,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        partitionKeys,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        infoColumns,
+    const std::shared_ptr<HiveColumnHandle>& rowIndexColumn,
+    memory::MemoryPool* pool) {
+  auto spec = std::make_shared<common::ScanSpec>("root");
+  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
+      filterSubfields;
+  std::vector<SubfieldSpec> subfieldSpecs;
+  for (auto& [subfield, _] : filters) {
+    if (auto name = subfield.toString();
+        !isSynthesizedColumn(name, infoColumns) &&
+        !isRowIndexColumn(name, rowIndexColumn) &&
+        partitionKeys.count(name) == 0) {
+      filterSubfields[getColumnName(subfield)].push_back(&subfield);
+    }
+  }
+
+  // Process columns that will be projected out.
+  for (int i = 0; i < rowType->size(); ++i) {
+    auto& name = rowType->nameOf(i);
+    auto& type = rowType->childAt(i);
+    auto it = outputSubfields.find(name);
+    if (it == outputSubfields.end()) {
+      auto* fieldSpec = spec->addFieldRecursively(name, *type, i);
+      if (isRowIndexColumn(name, rowIndexColumn)) {
+        VELOX_CHECK(type->isBigint());
+        fieldSpec->setExplicitRowNumber(true);
+      }
+      processFieldSpec(dataColumns, type, *fieldSpec);
+      filterSubfields.erase(name);
+      continue;
+    }
+    for (auto* subfield : it->second) {
+      subfieldSpecs.push_back({subfield, false});
+    }
+    it = filterSubfields.find(name);
+    if (it != filterSubfields.end()) {
+      for (auto* subfield : it->second) {
+        subfieldSpecs.push_back({subfield, true});
+      }
+      filterSubfields.erase(it);
+    }
+    auto* fieldSpec = spec->addField(name, i);
+    addSubfields(*type, subfieldSpecs, 1, pool, *fieldSpec);
+    processFieldSpec(dataColumns, type, *fieldSpec);
+    subfieldSpecs.clear();
+  }
+
+  // Now process the columns that will not be projected out.
+  if (!filterSubfields.empty()) {
+    VELOX_CHECK_NOT_NULL(dataColumns);
+    for (auto& [fieldName, subfields] : filterSubfields) {
+      for (auto* subfield : subfields) {
+        subfieldSpecs.push_back({subfield, true});
+      }
+      auto& type = dataColumns->findChild(fieldName);
+      auto* fieldSpec = spec->getOrCreateChild(fieldName);
+      addSubfields(*type, subfieldSpecs, 1, pool, *fieldSpec);
+      processFieldSpec(dataColumns, type, *fieldSpec);
+      subfieldSpecs.clear();
+    }
+  }
+
+  for (auto& pair : filters) {
+    const auto name = pair.first.toString();
+    // SelectiveColumnReader doesn't support constant columns with filters,
+    // hence, we can't have a filter for a $path or $bucket column.
+    //
+    // Unfortunately, Presto happens to specify a filter for $path, $file_size,
+    // $file_modified_time or $bucket column. This filter is redundant and needs
+    // to be removed.
+    // TODO Remove this check when Presto is fixed to not specify a filter
+    // on $path and $bucket column.
+    if (isSynthesizedColumn(name, infoColumns)) {
+      continue;
+    }
+    VELOX_CHECK(!isRowIndexColumn(name, rowIndexColumn));
+    auto fieldSpec = spec->getOrCreateChild(pair.first);
+    fieldSpec->addFilter(*pair.second);
+  }
+
+  return spec;
+}
+
+std::unique_ptr<dwio::common::SerDeOptions> parseSerdeParameters(
+    const std::unordered_map<std::string, std::string>& serdeParameters,
+    const std::unordered_map<std::string, std::string>& tableParameters) {
+  auto fieldIt = serdeParameters.find(dwio::common::SerDeOptions::kFieldDelim);
+  if (fieldIt == serdeParameters.end()) {
+    fieldIt = serdeParameters.find("serialization.format");
+  }
+  auto collectionIt =
+      serdeParameters.find(dwio::common::SerDeOptions::kCollectionDelim);
+  if (collectionIt == serdeParameters.end()) {
+    // For collection delimiter, Hive 1.x, 2.x uses "colelction.delim", but
+    // Hive 3.x uses "collection.delim".
+    // See: https://issues.apache.org/jira/browse/HIVE-16922)
+    collectionIt = serdeParameters.find("colelction.delim");
+  }
+  auto mapKeyIt =
+      serdeParameters.find(dwio::common::SerDeOptions::kMapKeyDelim);
+
+  auto escapeCharIt =
+      serdeParameters.find(dwio::common::SerDeOptions::kEscapeChar);
+
+  auto nullStringIt = tableParameters.find(
+      dwio::common::TableParameter::kSerializationNullFormat);
+
+  if (fieldIt == serdeParameters.end() &&
+      collectionIt == serdeParameters.end() &&
+      mapKeyIt == serdeParameters.end() &&
+      escapeCharIt == serdeParameters.end() &&
+      nullStringIt == tableParameters.end()) {
+    return nullptr;
+  }
+
+  uint8_t fieldDelim = '\1';
+  uint8_t collectionDelim = '\2';
+  uint8_t mapKeyDelim = '\3';
+  if (fieldIt != serdeParameters.end()) {
+    fieldDelim = parseDelimiter(fieldIt->second);
+  }
+  if (collectionIt != serdeParameters.end()) {
+    collectionDelim = parseDelimiter(collectionIt->second);
+  }
+  if (mapKeyIt != serdeParameters.end()) {
+    mapKeyDelim = parseDelimiter(mapKeyIt->second);
+  }
+
+  // If escape character is specified then we use it, unless it is empty - in
+  // which case we default to '\\'.
+  // If escape character is not specified (not in the map) we turn escaping off.
+  // Logic is based on apache hive java code:
+  // https://github.com/apache/hive/blob/3f6f940af3f60cc28834268e5d7f5612e3b13c30/serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazySerDeParameters.java#L105-L108
+  uint8_t escapeChar = '\\';
+  const bool hasEscapeChar = (escapeCharIt != serdeParameters.end());
+  if (hasEscapeChar) {
+    if (!escapeCharIt->second.empty()) {
+      // If delim is convertible to uint8_t then we use it as character code,
+      // otherwise we use the 1st character of the string.
+      escapeChar = folly::tryTo<uint8_t>(escapeCharIt->second)
+                       .value_or(escapeCharIt->second[0]);
+    }
+  }
+
+  auto serDeOptions = hasEscapeChar
+      ? std::make_unique<dwio::common::SerDeOptions>(
+            fieldDelim, collectionDelim, mapKeyDelim, escapeChar, true)
+      : std::make_unique<dwio::common::SerDeOptions>(
+            fieldDelim, collectionDelim, mapKeyDelim);
+  if (nullStringIt != tableParameters.end()) {
+    serDeOptions->nullString = nullStringIt->second;
+  }
+  return serDeOptions;
+}
+
+void configureReaderOptions(
+    dwio::common::ReaderOptions& readerOptions,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit) {
+  configureReaderOptions(
+      readerOptions,
+      hiveConfig,
+      connectorQueryCtx,
+      hiveTableHandle->dataColumns(),
+      hiveSplit,
+      hiveTableHandle->tableParameters());
+}
+
+void configureReaderOptions(
+    dwio::common::ReaderOptions& readerOptions,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const RowTypePtr& fileSchema,
+    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const std::unordered_map<std::string, std::string>& tableParameters) {
+  auto sessionProperties = connectorQueryCtx->sessionProperties();
+  readerOptions.setLoadQuantum(hiveConfig->loadQuantum());
+  readerOptions.setMaxCoalesceBytes(hiveConfig->maxCoalescedBytes());
+  readerOptions.setMaxCoalesceDistance(hiveConfig->maxCoalescedDistanceBytes());
+  readerOptions.setFileColumnNamesReadAsLowerCase(
+      hiveConfig->isFileColumnNamesReadAsLowerCase(sessionProperties));
+  readerOptions.setUseColumnNamesForColumnMapping(
+      hiveConfig->isOrcUseColumnNames(sessionProperties));
+  readerOptions.setFileSchema(fileSchema);
+  readerOptions.setFooterEstimatedSize(hiveConfig->footerEstimatedSize());
+  readerOptions.setFilePreloadThreshold(hiveConfig->filePreloadThreshold());
+  readerOptions.setPrefetchRowGroups(hiveConfig->prefetchRowGroups());
+  readerOptions.setNoCacheRetention(
+      hiveConfig->cacheNoRetention(sessionProperties));
+  const auto& sessionTzName = connectorQueryCtx->sessionTimezone();
+  if (!sessionTzName.empty()) {
+    const auto timezone = tz::locateZone(sessionTzName);
+    readerOptions.setSessionTimezone(timezone);
+  }
+  readerOptions.setSelectiveNimbleReaderEnabled(
+      connectorQueryCtx->selectiveNimbleReaderEnabled());
+
+  if (readerOptions.fileFormat() != dwio::common::FileFormat::UNKNOWN) {
+    VELOX_CHECK(
+        readerOptions.fileFormat() == hiveSplit->fileFormat,
+        "HiveDataSource received splits of different formats: {} and {}",
+        dwio::common::toString(readerOptions.fileFormat()),
+        dwio::common::toString(hiveSplit->fileFormat));
+  } else {
+    auto serDeOptions =
+        parseSerdeParameters(hiveSplit->serdeParameters, tableParameters);
+    if (serDeOptions) {
+      readerOptions.setSerDeOptions(*serDeOptions);
+    }
+
+    readerOptions.setFileFormat(hiveSplit->fileFormat);
+  }
+}
+
+void configureRowReaderOptions(
+    const std::unordered_map<std::string, std::string>& tableParameters,
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    const RowTypePtr& rowType,
+    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const config::ConfigBase* sessionProperties,
+    dwio::common::RowReaderOptions& rowReaderOptions) {
+  auto skipRowsIt =
+      tableParameters.find(dwio::common::TableParameter::kSkipHeaderLineCount);
+  if (skipRowsIt != tableParameters.end()) {
+    rowReaderOptions.setSkipRows(folly::to<uint64_t>(skipRowsIt->second));
+  }
+  rowReaderOptions.setScanSpec(scanSpec);
+  rowReaderOptions.setMetadataFilter(std::move(metadataFilter));
+  rowReaderOptions.setRequestedType(rowType);
+  rowReaderOptions.range(hiveSplit->start, hiveSplit->length);
+  if (hiveConfig && sessionProperties) {
+    rowReaderOptions.setTimestampPrecision(static_cast<TimestampPrecision>(
+        hiveConfig->readTimestampUnit(sessionProperties)));
+  }
+}
+
+namespace {
+
+bool applyPartitionFilter(
+    const TypePtr& type,
+    const std::string& partitionValue,
+    common::Filter* filter) {
+  if (type->isDate()) {
+    const auto result = util::fromDateString(
+        StringView(partitionValue), util::ParseMode::kPrestoCast);
+    VELOX_CHECK(!result.hasError());
+    return applyFilter(*filter, result.value());
+  }
+
+  switch (type->kind()) {
+    case TypeKind::BIGINT:
+    case TypeKind::INTEGER:
+    case TypeKind::SMALLINT:
+    case TypeKind::TINYINT: {
+      return applyFilter(*filter, folly::to<int64_t>(partitionValue));
+    }
+    case TypeKind::REAL:
+    case TypeKind::DOUBLE: {
+      return applyFilter(*filter, folly::to<double>(partitionValue));
+    }
+    case TypeKind::BOOLEAN: {
+      return applyFilter(*filter, folly::to<bool>(partitionValue));
+    }
+    case TypeKind::VARCHAR: {
+      return applyFilter(*filter, partitionValue);
+    }
+    default:
+      VELOX_FAIL(
+          "Bad type {} for partition value: {}", type->kind(), partitionValue);
+  }
+}
+
+} // namespace
+
+bool testFilters(
+    const common::ScanSpec* scanSpec,
+    const dwio::common::Reader* reader,
+    const std::string& filePath,
+    const std::unordered_map<std::string, std::optional<std::string>>&
+        partitionKeys,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        partitionKeysHandle) {
+  const auto totalRows = reader->numberOfRows();
+  const auto& fileTypeWithId = reader->typeWithId();
+  const auto& rowType = reader->rowType();
+  for (const auto& child : scanSpec->children()) {
+    if (child->filter()) {
+      const auto& name = child->fieldName();
+      auto iter = partitionKeys.find(name);
+      // By design, the partition key columns for Iceberg tables are included in
+      // the data files to facilitate partition transform and partition
+      // evolution, so we need to test both cases.
+      if (!rowType->containsChild(name) || iter != partitionKeys.end()) {
+        if (iter != partitionKeys.end() && iter->second.has_value()) {
+          const auto handlesIter = partitionKeysHandle.find(name);
+          VELOX_CHECK(handlesIter != partitionKeysHandle.end());
+
+          // This is a non-null partition key
+          return applyPartitionFilter(
+              handlesIter->second->dataType(),
+              iter->second.value(),
+              child->filter());
+        }
+        // Column is missing, most likely due to schema evolution. Or it's a
+        // partition key but the partition value is NULL.
+        if (child->filter()->isDeterministic() &&
+            !child->filter()->testNull()) {
+          VLOG(1) << "Skipping " << filePath
+                  << " because the filter testNull() failed for column "
+                  << child->fieldName();
+          return false;
+        }
+      } else {
+        const auto& typeWithId = fileTypeWithId->childByName(name);
+        const auto columnStats = reader->columnStatistics(typeWithId->id());
+        if (columnStats != nullptr &&
+            !testFilter(
+                child->filter(),
+                columnStats.get(),
+                totalRows.value(),
+                typeWithId->type())) {
+          VLOG(1) << "Skipping " << filePath
+                  << " based on stats and filter for column "
+                  << child->fieldName();
+          return false;
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
+    const FileHandle& fileHandle,
+    const dwio::common::ReaderOptions& readerOpts,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    std::shared_ptr<io::IoStatistics> ioStats,
+    folly::Executor* executor) {
+  if (connectorQueryCtx->cache()) {
+    return std::make_unique<dwio::common::CachedBufferedInput>(
+        fileHandle.file,
+        dwio::common::MetricsLog::voidLog(),
+        fileHandle.uuid.id(),
+        connectorQueryCtx->cache(),
+        Connector::getTracker(
+            connectorQueryCtx->scanId(), readerOpts.loadQuantum()),
+        fileHandle.groupId.id(),
+        ioStats,
+        executor,
+        readerOpts);
+  }
+  return std::make_unique<dwio::common::DirectBufferedInput>(
+      fileHandle.file,
+      dwio::common::MetricsLog::voidLog(),
+      fileHandle.uuid.id(),
+      Connector::getTracker(
+          connectorQueryCtx->scanId(), readerOpts.loadQuantum()),
+      fileHandle.groupId.id(),
+      std::move(ioStats),
+      executor,
+      readerOpts);
+}
+
+namespace {
+
+core::CallTypedExprPtr replaceInputs(
+    const core::CallTypedExpr* call,
+    std::vector<core::TypedExprPtr>&& inputs) {
+  return std::make_shared<core::CallTypedExpr>(
+      call->type(), std::move(inputs), call->name());
+}
+
+bool endWith(const std::string& str, const char* suffix) {
+  int len = strlen(suffix);
+  if (str.size() < len) {
+    return false;
+  }
+  for (int i = 0, j = str.size() - len; i < len; ++i, ++j) {
+    if (str[j] != suffix[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool isNotExpr(
+    const core::TypedExprPtr& expr,
+    const core::CallTypedExpr* call,
+    core::ExpressionEvaluator* evaluator) {
+  if (!endWith(call->name(), "not")) {
+    return false;
+  }
+  auto exprs = evaluator->compile(expr);
+  VELOX_CHECK_EQ(exprs->size(), 1);
+  auto& compiled = exprs->expr(0);
+  return compiled->vectorFunction() &&
+      compiled->vectorFunction()->getCanonicalName() ==
+      exec::FunctionCanonicalName::kNot;
+}
+
+double getPrestoSampleRate(
+    const core::TypedExprPtr& expr,
+    const core::CallTypedExpr* call,
+    core::ExpressionEvaluator* evaluator) {
+  if (!endWith(call->name(), "lt")) {
+    return -1;
+  }
+  VELOX_CHECK_EQ(call->inputs().size(), 2);
+  auto exprs = evaluator->compile(expr);
+  VELOX_CHECK_EQ(exprs->size(), 1);
+  auto& lt = exprs->expr(0);
+  if (!(lt->vectorFunction() &&
+        lt->vectorFunction()->getCanonicalName() ==
+            exec::FunctionCanonicalName::kLt)) {
+    return -1;
+  }
+  auto& rand = lt->inputs()[0];
+  if (!(rand->inputs().empty() && rand->vectorFunction() &&
+        rand->vectorFunction()->getCanonicalName() ==
+            exec::FunctionCanonicalName::kRand)) {
+    return -1;
+  }
+  auto* rate =
+      dynamic_cast<const core::ConstantTypedExpr*>(call->inputs()[1].get());
+  if (!(rate && rate->type()->kind() == TypeKind::DOUBLE)) {
+    return -1;
+  }
+  return std::max(0.0, std::min(1.0, rate->value().value<double>()));
+}
+
+} // namespace
+
+core::TypedExprPtr extractFiltersFromRemainingFilter(
+    const core::TypedExprPtr& expr,
+    core::ExpressionEvaluator* evaluator,
+    bool negated,
+    SubfieldFilters& filters,
+    double& sampleRate) {
+  auto* call = dynamic_cast<const core::CallTypedExpr*>(expr.get());
+  if (call == nullptr) {
+    return expr;
+  }
+  common::Filter* oldFilter = nullptr;
+  try {
+    common::Subfield subfield;
+    if (auto filter = exec::leafCallToSubfieldFilter(
+            *call, subfield, evaluator, negated)) {
+      if (auto it = filters.find(subfield); it != filters.end()) {
+        oldFilter = it->second.get();
+        filter = filter->mergeWith(oldFilter);
+      }
+      filters.insert_or_assign(std::move(subfield), std::move(filter));
+      return nullptr;
+    }
+  } catch (const VeloxException&) {
+    LOG(WARNING) << "Unexpected failure when extracting filter for: "
+                 << expr->toString();
+    if (oldFilter) {
+      LOG(WARNING) << "Merging with " << oldFilter->toString();
+    }
+  }
+
+  if (isNotExpr(expr, call, evaluator)) {
+    auto inner = extractFiltersFromRemainingFilter(
+        call->inputs()[0], evaluator, !negated, filters, sampleRate);
+    return inner ? replaceInputs(call, {inner}) : nullptr;
+  }
+
+  if ((call->name() == "and" && !negated) ||
+      (call->name() == "or" && negated)) {
+    auto lhs = extractFiltersFromRemainingFilter(
+        call->inputs()[0], evaluator, negated, filters, sampleRate);
+    auto rhs = extractFiltersFromRemainingFilter(
+        call->inputs()[1], evaluator, negated, filters, sampleRate);
+    if (!lhs) {
+      return rhs;
+    }
+    if (!rhs) {
+      return lhs;
+    }
+    return replaceInputs(call, {lhs, rhs});
+  }
+  if (!negated) {
+    double rate = getPrestoSampleRate(expr, call, evaluator);
+    if (rate != -1) {
+      sampleRate *= rate;
+      return nullptr;
+    }
+  }
+  return expr;
+}
+
+namespace {
+
+#ifdef VELOX_ENABLE_PARQUET
+std::optional<TimestampUnit> getTimestampUnit(
+    const config::ConfigBase& config,
+    const char* configKey) {
+  if (const auto unit = config.get<uint8_t>(configKey)) {
+    VELOX_CHECK(
+        unit == 0 /*second*/ || unit == 3 /*milli*/ || unit == 6 /*micro*/ ||
+            unit == 9 /*nano*/,
+        "Invalid timestamp unit: {}",
+        unit.value());
+    return std::optional(static_cast<TimestampUnit>(unit.value()));
+  }
+  return std::nullopt;
+}
+
+std::optional<std::string> getTimestampTimeZone(
+    const config::ConfigBase& config,
+    const char* configKey) {
+  if (const auto timezone = config.get<std::string>(configKey)) {
+    return timezone.value();
+  }
+  return std::nullopt;
+}
+
+void updateParquetWriterOptions(
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const config::ConfigBase* sessionProperties,
+    std::shared_ptr<dwio::common::WriterOptions>& writerOptions) {
+  auto parquetWriterOptions =
+      std::dynamic_pointer_cast<parquet::WriterOptions>(writerOptions);
+  VELOX_CHECK_NOT_NULL(
+      parquetWriterOptions,
+      "Parquet writer expected a Parquet WriterOptions object.");
+
+  if (!parquetWriterOptions->parquetWriteTimestampUnit) {
+    parquetWriterOptions->parquetWriteTimestampUnit =
+        getTimestampUnit(
+            *sessionProperties,
+            parquet::WriterOptions::kParquetSessionWriteTimestampUnit)
+            .has_value()
+        ? getTimestampUnit(
+              *sessionProperties,
+              parquet::WriterOptions::kParquetSessionWriteTimestampUnit)
+        : getTimestampUnit(
+              *hiveConfig->config(),
+              parquet::WriterOptions::kParquetSessionWriteTimestampUnit);
+  }
+
+  if (!parquetWriterOptions->parquetWriteTimestampTimeZone) {
+    parquetWriterOptions->parquetWriteTimestampTimeZone =
+        getTimestampTimeZone(
+            *sessionProperties, core::QueryConfig::kSessionTimezone)
+            .has_value()
+        ? getTimestampTimeZone(
+              *sessionProperties, core::QueryConfig::kSessionTimezone)
+        : getTimestampTimeZone(
+              *hiveConfig->config(), core::QueryConfig::kSessionTimezone);
+  }
+
+  writerOptions = std::move(parquetWriterOptions);
+}
+#endif
+
+void updateDWRFWriterOptions(
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const config::ConfigBase* sessionProperties,
+    std::shared_ptr<dwio::common::WriterOptions>& writerOptions) {
+  auto dwrfWriterOptions =
+      std::dynamic_pointer_cast<dwrf::WriterOptions>(writerOptions);
+  VELOX_CHECK_NOT_NULL(
+      dwrfWriterOptions, "DWRF writer expected a DWRF WriterOptions object.");
+  std::map<std::string, std::string> configs;
+
+  if (writerOptions->compressionKind.has_value()) {
+    configs.emplace(
+        dwrf::Config::COMPRESSION.key,
+        std::to_string(writerOptions->compressionKind.value()));
+  }
+
+  configs.emplace(
+      dwrf::Config::STRIPE_SIZE.key,
+      std::to_string(hiveConfig->orcWriterMaxStripeSize(sessionProperties)));
+
+  configs.emplace(
+      dwrf::Config::MAX_DICTIONARY_SIZE.key,
+      std::to_string(
+          hiveConfig->orcWriterMaxDictionaryMemory(sessionProperties)));
+
+  configs.emplace(
+      dwrf::Config::INTEGER_DICTIONARY_ENCODING_ENABLED.key,
+      std::to_string(hiveConfig->isOrcWriterIntegerDictionaryEncodingEnabled(
+          sessionProperties)));
+  configs.emplace(
+      dwrf::Config::STRING_DICTIONARY_ENCODING_ENABLED.key,
+      std::to_string(hiveConfig->isOrcWriterStringDictionaryEncodingEnabled(
+          sessionProperties)));
+
+  configs.emplace(
+      dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN.key,
+      std::to_string(
+          hiveConfig->orcWriterMinCompressionSize(sessionProperties)));
+
+  configs.emplace(
+      dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS.key,
+      std::to_string(
+          hiveConfig->orcWriterLinearStripeSizeHeuristics(sessionProperties)));
+
+  configs.emplace(
+      dwrf::Config::ZLIB_COMPRESSION_LEVEL.key,
+      std::to_string(
+          hiveConfig->orcWriterZLIBCompressionLevel(sessionProperties)));
+
+  configs.emplace(
+      dwrf::Config::ZSTD_COMPRESSION_LEVEL.key,
+      std::to_string(
+          hiveConfig->orcWriterZSTDCompressionLevel(sessionProperties)));
+
+  dwrfWriterOptions->config = dwrf::Config::fromMap(configs);
+  writerOptions = std::move(dwrfWriterOptions);
+}
+
+} // namespace
+
+void updateWriterOptionsFromHiveConfig(
+    dwio::common::FileFormat fileFormat,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const config::ConfigBase* sessionProperties,
+    std::shared_ptr<dwio::common::WriterOptions>& writerOptions) {
+  switch (fileFormat) {
+    case dwio::common::FileFormat::DWRF:
+      updateDWRFWriterOptions(hiveConfig, sessionProperties, writerOptions);
+      break;
+    case dwio::common::FileFormat::PARQUET:
+#ifdef VELOX_ENABLE_PARQUET
+      updateParquetWriterOptions(hiveConfig, sessionProperties, writerOptions);
+#endif
+      break;
+    case dwio::common::FileFormat::NIMBLE:
+      // No-op for now.
+      break;
+    default:
+      VELOX_UNSUPPORTED("{}", fileFormat);
+  }
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConnectorUtil.h b/velox/connectors/hive/HiveConnectorUtil.h
new file mode 100644
index 0000000000000..3b5f25ad82ce0
--- /dev/null
+++ b/velox/connectors/hive/HiveConnectorUtil.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <folly/Executor.h>
+#include <folly/container/F14Map.h>
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/dwio/common/BufferedInput.h"
+#include "velox/dwio/common/Reader.h"
+
+namespace facebook::velox::connector::hive {
+
+class HiveColumnHandle;
+class HiveTableHandle;
+class HiveConfig;
+struct HiveConnectorSplit;
+
+using SubfieldFilters =
+    std::unordered_map<common::Subfield, std::unique_ptr<common::Filter>>;
+
+constexpr const char* kPath = "$path";
+constexpr const char* kBucket = "$bucket";
+
+const std::string& getColumnName(const common::Subfield& subfield);
+
+void checkColumnNameLowerCase(const std::shared_ptr<const Type>& type);
+
+void checkColumnNameLowerCase(
+    const SubfieldFilters& filters,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        infoColumns);
+
+void checkColumnNameLowerCase(const core::TypedExprPtr& typeExpr);
+
+std::shared_ptr<common::ScanSpec> makeScanSpec(
+    const RowTypePtr& rowType,
+    const folly::F14FastMap<std::string, std::vector<const common::Subfield*>>&
+        outputSubfields,
+    const SubfieldFilters& filters,
+    const RowTypePtr& dataColumns,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        partitionKeys,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        infoColumns,
+    const std::shared_ptr<HiveColumnHandle>& rowIndexColumn,
+    memory::MemoryPool* pool);
+
+void configureReaderOptions(
+    dwio::common::ReaderOptions& readerOptions,
+    const std::shared_ptr<const HiveConfig>& config,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit);
+
+void configureReaderOptions(
+    dwio::common::ReaderOptions& readerOptions,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const RowTypePtr& fileSchema,
+    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const std::unordered_map<std::string, std::string>& tableParameters = {});
+
+void configureRowReaderOptions(
+    const std::unordered_map<std::string, std::string>& tableParameters,
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    const RowTypePtr& rowType,
+    const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const config::ConfigBase* sessionProperties,
+    dwio::common::RowReaderOptions& rowReaderOptions);
+
+bool testFilters(
+    const common::ScanSpec* scanSpec,
+    const dwio::common::Reader* reader,
+    const std::string& filePath,
+    const std::unordered_map<std::string, std::optional<std::string>>&
+        partitionKey,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+        partitionKeysHandle);
+
+std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
+    const FileHandle& fileHandle,
+    const dwio::common::ReaderOptions& readerOpts,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    std::shared_ptr<io::IoStatistics> ioStats,
+    folly::Executor* executor);
+
+core::TypedExprPtr extractFiltersFromRemainingFilter(
+    const core::TypedExprPtr& expr,
+    core::ExpressionEvaluator* evaluator,
+    bool negated,
+    SubfieldFilters& filters,
+    double& sampleRate);
+
+/// Updates the file format's WriteOptions based on the HiveConfig.
+void updateWriterOptionsFromHiveConfig(
+    dwio::common::FileFormat fileFormat,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const config::ConfigBase* sessionProperties,
+    std::shared_ptr<dwio::common::WriterOptions>& writerOptions);
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveDataSink.cpp b/velox/connectors/hive/HiveDataSink.cpp
index 4494b2f2ccb70..4c75432b6400e 100644
--- a/velox/connectors/hive/HiveDataSink.cpp
+++ b/velox/connectors/hive/HiveDataSink.cpp
@@ -16,24 +16,63 @@
 
 #include "velox/connectors/hive/HiveDataSink.h"
 
+#include "velox/common/base/Counters.h"
 #include "velox/common/base/Fs.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/connectors/hive/HivePartitionFunction.h"
+#include "velox/connectors/hive/TableHandle.h"
 #include "velox/core/ITypedExpr.h"
 #include "velox/dwio/common/SortingWriter.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
-#include "velox/exec/SortBuffer.h"
-
-#include "velox/connectors/hive/TableHandle.h"
 #include "velox/exec/OperatorUtils.h"
+#include "velox/exec/SortBuffer.h"
 
 #include <boost/lexical_cast.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
 
+using facebook::velox::common::testutil::TestValue;
+
 namespace facebook::velox::connector::hive {
 
 namespace {
+// Returns the type of non-partition data columns.
+RowTypePtr getNonPartitionTypes(
+    const std::vector<column_index_t>& dataCols,
+    const RowTypePtr& inputType) {
+  std::vector<std::string> childNames;
+  std::vector<TypePtr> childTypes;
+  const auto& dataSize = dataCols.size();
+  childNames.reserve(dataSize);
+  childTypes.reserve(dataSize);
+  for (int dataCol : dataCols) {
+    childNames.push_back(inputType->nameOf(dataCol));
+    childTypes.push_back(inputType->childAt(dataCol));
+  }
+
+  return ROW(std::move(childNames), std::move(childTypes));
+}
+
+// Filters out partition columns if there is any.
+RowVectorPtr makeDataInput(
+    const std::vector<column_index_t>& dataCols,
+    const RowVectorPtr& input) {
+  std::vector<VectorPtr> childVectors;
+  childVectors.reserve(dataCols.size());
+  for (int dataCol : dataCols) {
+    childVectors.push_back(input->childAt(dataCol));
+  }
+
+  return std::make_shared<RowVector>(
+      input->pool(),
+      getNonPartitionTypes(dataCols, asRowType(input->type())),
+      input->nulls(),
+      input->size(),
+      std::move(childVectors),
+      input->getNullCount());
+}
 
 // Returns a subset of column indices corresponding to partition keys.
 std::vector<column_index_t> getPartitionChannels(
@@ -50,6 +89,23 @@ std::vector<column_index_t> getPartitionChannels(
   return channels;
 }
 
+// Returns the column indices of non-partition data columns.
+std::vector<column_index_t> getNonPartitionChannels(
+    const std::vector<column_index_t>& partitionChannels,
+    const column_index_t childrenSize) {
+  std::vector<column_index_t> dataChannels;
+  dataChannels.reserve(childrenSize - partitionChannels.size());
+
+  for (column_index_t i = 0; i < childrenSize; i++) {
+    if (std::find(partitionChannels.cbegin(), partitionChannels.cend(), i) ==
+        partitionChannels.cend()) {
+      dataChannels.push_back(i);
+    }
+  }
+
+  return dataChannels;
+}
+
 std::string makePartitionDirectory(
     const std::string& tableDirectory,
     const std::optional<std::string>& partitionSubdirectory) {
@@ -113,6 +169,21 @@ std::string computeBucketedFileName(
   return fmt::format(
       "0{:0>{}}_0_{}", bucketValueStr, kMaxBucketCountPadding, queryId);
 }
+
+std::shared_ptr<memory::MemoryPool> createSinkPool(
+    const std::shared_ptr<memory::MemoryPool>& writerPool) {
+  return writerPool->addLeafChild(fmt::format("{}.sink", writerPool->name()));
+}
+
+std::shared_ptr<memory::MemoryPool> createSortPool(
+    const std::shared_ptr<memory::MemoryPool>& writerPool) {
+  return writerPool->addLeafChild(fmt::format("{}.sort", writerPool->name()));
+}
+
+#define WRITER_NON_RECLAIMABLE_SECTION_GUARD(index)       \
+  memory::NonReclaimableSectionGuard nonReclaimableGuard( \
+      writerInfo_[(index)]->nonReclaimableSectionHolder.get())
+
 } // namespace
 
 const HiveWriterId& HiveWriterId::unpartitionedId() {
@@ -121,14 +192,22 @@ const HiveWriterId& HiveWriterId::unpartitionedId() {
 }
 
 std::string HiveWriterId::toString() const {
-  if (!partitionId.has_value()) {
-    return "UNPARTITIONED";
+  if (partitionId.has_value() && bucketId.has_value()) {
+    return fmt::format("part[{}.{}]", partitionId.value(), bucketId.value());
   }
-  if (bucketId.has_value()) {
-    return fmt::format(
-        "PARTITIONED[{}.{}]", partitionId.value(), bucketId.value());
+
+  if (partitionId.has_value() && !bucketId.has_value()) {
+    return fmt::format("part[{}]", partitionId.value());
   }
-  return fmt::format("PARTITIONED[{}]", partitionId.value());
+
+  // This WriterId is used to add an identifier in the MemoryPools. This could
+  // indicate unpart, but the bucket number needs to be disambiguated. So
+  // creating a new label using bucket.
+  if (!partitionId.has_value() && bucketId.has_value()) {
+    return fmt::format("bucket[{}]", bucketId.value());
+  }
+
+  return "unpart";
 }
 
 const std::string LocationHandle::tableTypeName(
@@ -275,22 +354,28 @@ HiveDataSink::HiveDataSink(
     std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
     const ConnectorQueryCtx* connectorQueryCtx,
     CommitStrategy commitStrategy,
-    const std::shared_ptr<const Config>& connectorProperties)
+    const std::shared_ptr<const HiveConfig>& hiveConfig)
     : inputType_(std::move(inputType)),
       insertTableHandle_(std::move(insertTableHandle)),
       connectorQueryCtx_(connectorQueryCtx),
       commitStrategy_(commitStrategy),
-      connectorProperties_(connectorProperties),
-      maxOpenWriters_(
-          HiveConfig::maxPartitionsPerWriters(connectorQueryCtx_->config())),
+      hiveConfig_(hiveConfig),
+      updateMode_(getUpdateMode()),
+      maxOpenWriters_(hiveConfig_->maxPartitionsPerWriters(
+          connectorQueryCtx->sessionProperties())),
       partitionChannels_(getPartitionChannels(insertTableHandle_)),
       partitionIdGenerator_(
-          !partitionChannels_.empty() ? std::make_unique<PartitionIdGenerator>(
-                                            inputType_,
-                                            partitionChannels_,
-                                            maxOpenWriters_,
-                                            connectorQueryCtx_->memoryPool())
-                                      : nullptr),
+          !partitionChannels_.empty()
+              ? std::make_unique<PartitionIdGenerator>(
+                    inputType_,
+                    partitionChannels_,
+                    maxOpenWriters_,
+                    connectorQueryCtx_->memoryPool(),
+                    hiveConfig_->isPartitionPathAsLowerCase(
+                        connectorQueryCtx->sessionProperties()))
+              : nullptr),
+      dataChannels_(
+          getNonPartitionChannels(partitionChannels_, inputType_->size())),
       bucketCount_(
           insertTableHandle_->bucketProperty() == nullptr
               ? 0
@@ -302,9 +387,7 @@ HiveDataSink::HiveDataSink(
                        : nullptr),
       writerFactory_(dwio::common::getWriterFactory(
           insertTableHandle_->tableStorageFormat())),
-      spillConfig_(connectorQueryCtx->getSpillConfig()) {
-  VELOX_USER_CHECK(
-      !isBucketed() || isPartitioned(), "A bucket table must be partitioned");
+      spillConfig_(connectorQueryCtx->spillConfig()) {
   if (isBucketed()) {
     VELOX_USER_CHECK_LT(
         bucketCount_, maxBucketCount(), "bucketCount exceeds the limit");
@@ -323,30 +406,39 @@ HiveDataSink::HiveDataSink(
     sortColumnIndices_.reserve(sortedProperty.size());
     sortCompareFlags_.reserve(sortedProperty.size());
     for (int i = 0; i < sortedProperty.size(); ++i) {
-      sortColumnIndices_.push_back(
-          inputType_->getChildIdx(sortedProperty.at(i)->sortColumn()));
-      sortCompareFlags_.push_back(
-          {sortedProperty.at(i)->sortOrder().isNullsFirst(),
-           sortedProperty.at(i)->sortOrder().isAscending(),
-           false,
-           CompareFlags::NullHandlingMode::NoStop});
+      auto columnIndex =
+          getNonPartitionTypes(dataChannels_, inputType_)
+              ->getChildIdxIfExists(sortedProperty.at(i)->sortColumn());
+      if (columnIndex.has_value()) {
+        sortColumnIndices_.push_back(columnIndex.value());
+        sortCompareFlags_.push_back(
+            {sortedProperty.at(i)->sortOrder().isNullsFirst(),
+             sortedProperty.at(i)->sortOrder().isAscending(),
+             false,
+             CompareFlags::NullHandlingMode::kNullAsValue});
+      }
     }
   }
 }
 
+bool HiveDataSink::canReclaim() const {
+  // Currently, we only support memory reclaim on dwrf file writer.
+  return (spillConfig_ != nullptr) &&
+      (insertTableHandle_->tableStorageFormat() ==
+       dwio::common::FileFormat::DWRF);
+}
+
 void HiveDataSink::appendData(RowVectorPtr input) {
-  checkNotAborted();
-  checkNotClosed();
+  checkRunning();
 
-  // Write to unpartitioned table.
-  if (!isPartitioned()) {
+  // Write to unpartitioned (and unbucketed) table.
+  if (!isPartitioned() && !isBucketed()) {
     const auto index = ensureWriter(HiveWriterId::unpartitionedId());
-    writers_[index]->write(input);
-    writerInfo_[index]->numWrittenRows += input->size();
+    write(index, input);
     return;
   }
 
-  // Write to partitioned table.
+  // Compute partition and bucket numbers.
   computePartitionAndBucketIds(input);
 
   // Lazy load all the input columns.
@@ -354,12 +446,11 @@ void HiveDataSink::appendData(RowVectorPtr input) {
     input->childAt(i)->loadedVector();
   }
 
-  // All inputs belong to a single non-bucketed partition. The partition id must
-  // be zero.
+  // All inputs belong to a single non-bucketed partition. The partition id
+  // must be zero.
   if (!isBucketed() && partitionIdGenerator_->numPartitions() == 1) {
     const auto index = ensureWriter(HiveWriterId{0});
-    writers_[index]->write(input);
-    writerInfo_[index]->numWrittenRows += input->size();
+    write(index, input);
     return;
   }
 
@@ -374,44 +465,139 @@ void HiveDataSink::appendData(RowVectorPtr input) {
     RowVectorPtr writerInput = partitionSize == input->size()
         ? input
         : exec::wrap(partitionSize, partitionRows_[index], input);
-    writers_[index]->write(writerInput);
-    writerInfo_[index]->numWrittenRows += partitionSize;
+    write(index, writerInput);
+  }
+}
+
+void HiveDataSink::write(size_t index, RowVectorPtr input) {
+  WRITER_NON_RECLAIMABLE_SECTION_GUARD(index);
+  auto dataInput = makeDataInput(dataChannels_, input);
+
+  writers_[index]->write(dataInput);
+  writerInfo_[index]->numWrittenRows += dataInput->size();
+}
+
+std::string HiveDataSink::stateString(State state) {
+  switch (state) {
+    case State::kRunning:
+      return "RUNNING";
+    case State::kClosed:
+      return "CLOSED";
+    case State::kAborted:
+      return "ABORTED";
+    default:
+      VELOX_UNREACHABLE("BAD STATE: {}", static_cast<int>(state));
   }
 }
 
 void HiveDataSink::computePartitionAndBucketIds(const RowVectorPtr& input) {
-  VELOX_CHECK(isPartitioned());
-  partitionIdGenerator_->run(input, partitionIds_);
+  VELOX_CHECK(isPartitioned() || isBucketed());
+  if (isPartitioned()) {
+    if (!hiveConfig_->allowNullPartitionKeys(
+            connectorQueryCtx_->sessionProperties())) {
+      // Check that there are no nulls in the partition keys.
+      for (auto& partitionIdx : partitionChannels_) {
+        auto col = input->childAt(partitionIdx);
+        if (col->mayHaveNulls()) {
+          for (auto i = 0; i < col->size(); ++i) {
+            VELOX_USER_CHECK(
+                !col->isNullAt(i),
+                "Partition key must not be null: {}",
+                input->type()->asRow().nameOf(partitionIdx));
+          }
+        }
+      }
+    }
+    partitionIdGenerator_->run(input, partitionIds_);
+  }
+
   if (isBucketed()) {
     bucketFunction_->partition(*input, bucketIds_);
   }
 }
 
-int64_t HiveDataSink::getCompletedBytes() const {
-  checkNotAborted();
+DataSink::Stats HiveDataSink::stats() const {
+  Stats stats;
+  if (state_ == State::kAborted) {
+    return stats;
+  }
 
-  int64_t completedBytes{0};
+  int64_t numWrittenBytes{0};
+  int64_t writeIOTimeUs{0};
   for (const auto& ioStats : ioStats_) {
-    completedBytes += ioStats->rawBytesWritten();
+    numWrittenBytes += ioStats->rawBytesWritten();
+    writeIOTimeUs += ioStats->writeIOTimeUs();
   }
-  return completedBytes;
+  stats.numWrittenBytes = numWrittenBytes;
+  stats.writeIOTimeUs = writeIOTimeUs;
+
+  if (state_ != State::kClosed) {
+    return stats;
+  }
+
+  stats.numWrittenFiles = writers_.size();
+  for (int i = 0; i < writerInfo_.size(); ++i) {
+    const auto& info = writerInfo_.at(i);
+    VELOX_CHECK_NOT_NULL(info);
+    const auto spillStats = info->spillStats->rlock();
+    if (!spillStats->empty()) {
+      stats.spillStats += *spillStats;
+    }
+  }
+  return stats;
 }
 
-int32_t HiveDataSink::numWrittenFiles() const {
-  return writers_.size();
+std::shared_ptr<memory::MemoryPool> HiveDataSink::createWriterPool(
+    const HiveWriterId& writerId) {
+  auto* connectorPool = connectorQueryCtx_->connectorMemoryPool();
+  return connectorPool->addAggregateChild(
+      fmt::format("{}.{}", connectorPool->name(), writerId.toString()));
 }
 
-std::vector<std::string> HiveDataSink::close(bool success) {
-  closeInternal(!success);
-  if (!success) {
-    VELOX_CHECK(aborted_);
-    return {};
+void HiveDataSink::setMemoryReclaimers(
+    HiveWriterInfo* writerInfo,
+    io::IoStatistics* ioStats) {
+  auto* connectorPool = connectorQueryCtx_->connectorMemoryPool();
+  if (connectorPool->reclaimer() == nullptr) {
+    return;
+  }
+  writerInfo->writerPool->setReclaimer(
+      WriterReclaimer::create(this, writerInfo, ioStats));
+  writerInfo->sinkPool->setReclaimer(exec::MemoryReclaimer::create());
+  // NOTE: we set the memory reclaimer for sort pool when we construct the sort
+  // writer.
+}
+
+void HiveDataSink::setState(State newState) {
+  checkStateTransition(state_, newState);
+  state_ = newState;
+}
+
+/// Validates the state transition from 'oldState' to 'newState'.
+void HiveDataSink::checkStateTransition(State oldState, State newState) {
+  switch (oldState) {
+    case State::kRunning:
+      if (newState == State::kAborted || newState == State::kClosed) {
+        return;
+      }
+      break;
+    case State::kAborted:
+      [[fallthrough]];
+    case State::kClosed:
+      [[fallthrough]];
+    default:
+      break;
   }
-  VELOX_CHECK(closed_);
+  VELOX_FAIL("Unexpected state transition from {} to {}", oldState, newState);
+}
+
+std::vector<std::string> HiveDataSink::close() {
+  checkRunning();
+  state_ = State::kClosed;
+  closeInternal();
 
   std::vector<std::string> partitionUpdates;
   partitionUpdates.reserve(writerInfo_.size());
-
   for (int i = 0; i < writerInfo_.size(); ++i) {
     const auto& info = writerInfo_.at(i);
     VELOX_CHECK_NOT_NULL(info);
@@ -441,27 +627,27 @@ std::vector<std::string> HiveDataSink::close(bool success) {
   return partitionUpdates;
 }
 
-void HiveDataSink::closeInternal(bool abort) {
-  if (closedOrAborted()) {
-    if (abort) {
-      // We can't call abort on a closed data sink.
-      VELOX_CHECK(aborted_, "Can't abort a closed hive data sink");
-    } else {
-      // We can't call close on an aborted data sink.
-      VELOX_CHECK(closed_, "Can't close an aborted hive data sink");
-    }
-    return;
-  }
+void HiveDataSink::abort() {
+  checkRunning();
+  state_ = State::kAborted;
+  closeInternal();
+}
+
+void HiveDataSink::closeInternal() {
+  VELOX_CHECK_NE(state_, State::kRunning);
 
-  if (!abort) {
-    closed_ = true;
-    for (const auto& writer : writers_) {
-      writer->close();
+  TestValue::adjust(
+      "facebook::velox::connector::hive::HiveDataSink::closeInternal", this);
+
+  if (state_ == State::kClosed) {
+    for (int i = 0; i < writers_.size(); ++i) {
+      WRITER_NON_RECLAIMABLE_SECTION_GUARD(i);
+      writers_[i]->close();
     }
   } else {
-    aborted_ = true;
-    for (const auto& writer : writers_) {
-      writer->abort();
+    for (int i = 0; i < writers_.size(); ++i) {
+      WRITER_NON_RECLAIMABLE_SECTION_GUARD(i);
+      writers_[i]->abort();
     }
   }
 }
@@ -492,23 +678,84 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
   auto writerParameters = getWriterParameters(partitionName, id.bucketId);
   const auto writePath = fs::path(writerParameters.writeDirectory()) /
       writerParameters.writeFileName();
-  writerInfo_.emplace_back(
-      std::make_shared<HiveWriterInfo>(std::move(writerParameters)));
-
-  dwio::common::WriterOptions options;
-  options.schema = inputType_;
-  options.memoryPool = connectorQueryCtx_->connectorMemoryPool();
-  options.compressionKind = insertTableHandle_->compressionKind();
-  options.setMemoryReclaimer = connectorQueryCtx_->setMemoryReclaimer();
+  auto writerPool = createWriterPool(id);
+  auto sinkPool = createSinkPool(writerPool);
+  std::shared_ptr<memory::MemoryPool> sortPool{nullptr};
+  if (sortWrite()) {
+    sortPool = createSortPool(writerPool);
+  }
+  writerInfo_.emplace_back(std::make_shared<HiveWriterInfo>(
+      std::move(writerParameters),
+      std::move(writerPool),
+      std::move(sinkPool),
+      std::move(sortPool)));
   ioStats_.emplace_back(std::make_shared<io::IoStatistics>());
+  setMemoryReclaimers(writerInfo_.back().get(), ioStats_.back().get());
+
+  // Take the writer options provided by the user as a starting point, or
+  // allocate a new one.
+  auto options = insertTableHandle_->writerOptions();
+  if (!options) {
+    options = writerFactory_->createWriterOptions();
+  }
+
+  const auto* connectorSessionProperties =
+      connectorQueryCtx_->sessionProperties();
+
+  // Only overwrite options in case they were not already provided.
+  if (options->schema == nullptr) {
+    options->schema = getNonPartitionTypes(dataChannels_, inputType_);
+  }
+
+  if (options->memoryPool == nullptr) {
+    options->memoryPool = writerInfo_.back()->writerPool.get();
+  }
+
+  if (!options->compressionKind) {
+    options->compressionKind = insertTableHandle_->compressionKind();
+  }
+
+  if (options->spillConfig == nullptr && canReclaim()) {
+    options->spillConfig = spillConfig_;
+  }
+
+  if (options->nonReclaimableSection == nullptr) {
+    options->nonReclaimableSection =
+        writerInfo_.back()->nonReclaimableSectionHolder.get();
+  }
+
+  if (options->memoryReclaimerFactory == nullptr ||
+      options->memoryReclaimerFactory() == nullptr) {
+    options->memoryReclaimerFactory = []() {
+      return exec::MemoryReclaimer::create();
+    };
+  }
+
+  if (options->serdeParameters.empty()) {
+    options->serdeParameters = std::map<std::string, std::string>(
+        insertTableHandle_->serdeParameters().begin(),
+        insertTableHandle_->serdeParameters().end());
+  }
+
+  updateWriterOptionsFromHiveConfig(
+      insertTableHandle_->tableStorageFormat(),
+      hiveConfig_,
+      connectorSessionProperties,
+      options);
+
+  // Prevents the memory allocation during the writer creation.
+  WRITER_NON_RECLAIMABLE_SECTION_GUARD(writerInfo_.size() - 1);
   auto writer = writerFactory_->createWriter(
       dwio::common::FileSink::create(
           writePath,
-          {.bufferWrite = false,
-           .connectorProperties = connectorProperties_,
-           .pool = connectorQueryCtx_->memoryPool(),
-           .metricLogger = dwio::common::MetricsLog::voidLog(),
-           .stats = ioStats_.back().get()}),
+          {
+              .bufferWrite = false,
+              .connectorProperties = hiveConfig_->config(),
+              .fileCreateConfig = hiveConfig_->writeFileCreateConfig(),
+              .pool = writerInfo_.back()->sinkPool.get(),
+              .metricLogger = dwio::common::MetricsLog::voidLog(),
+              .stats = ioStats_.back().get(),
+          }),
       options);
   writer = maybeCreateBucketSortWriter(std::move(writer));
   writers_.emplace_back(std::move(writer));
@@ -524,36 +771,57 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
 std::unique_ptr<facebook::velox::dwio::common::Writer>
 HiveDataSink::maybeCreateBucketSortWriter(
     std::unique_ptr<facebook::velox::dwio::common::Writer> writer) {
-  if (sortColumnIndices_.empty()) {
+  if (!sortWrite()) {
     return writer;
   }
+  auto* sortPool = writerInfo_.back()->sortPool.get();
+  VELOX_CHECK_NOT_NULL(sortPool);
   auto sortBuffer = std::make_unique<exec::SortBuffer>(
-      inputType_,
+      getNonPartitionTypes(dataChannels_, inputType_),
       sortColumnIndices_,
       sortCompareFlags_,
-      1000, // todo batch size
-      connectorQueryCtx_->memoryPool(),
-      &nonReclaimableSection_,
-      &numSpillRuns_,
-      spillConfig_);
+      sortPool,
+      writerInfo_.back()->nonReclaimableSectionHolder.get(),
+      connectorQueryCtx_->prefixSortConfig(),
+      spillConfig_,
+      writerInfo_.back()->spillStats.get());
   return std::make_unique<dwio::common::SortingWriter>(
-      std::move(writer), std::move(sortBuffer));
+      std::move(writer),
+      std::move(sortBuffer),
+      hiveConfig_->sortWriterMaxOutputRows(
+          connectorQueryCtx_->sessionProperties()),
+      hiveConfig_->sortWriterMaxOutputBytes(
+          connectorQueryCtx_->sessionProperties()));
 }
 
-void HiveDataSink::splitInputRowsAndEnsureWriters() {
-  VELOX_CHECK(isPartitioned());
+HiveWriterId HiveDataSink::getWriterId(size_t row) const {
+  std::optional<int32_t> partitionId;
+  if (isPartitioned()) {
+    VELOX_CHECK_LT(partitionIds_[row], std::numeric_limits<uint32_t>::max());
+    partitionId = static_cast<uint32_t>(partitionIds_[row]);
+  }
+
+  std::optional<int32_t> bucketId;
   if (isBucketed()) {
+    bucketId = bucketIds_[row];
+  }
+  return HiveWriterId{partitionId, bucketId};
+}
+
+void HiveDataSink::splitInputRowsAndEnsureWriters() {
+  VELOX_CHECK(isPartitioned() || isBucketed());
+  if (isBucketed() && isPartitioned()) {
     VELOX_CHECK_EQ(bucketIds_.size(), partitionIds_.size());
   }
+
   std::fill(partitionSizes_.begin(), partitionSizes_.end(), 0);
 
-  const auto numRows = partitionIds_.size();
+  const auto numRows =
+      isPartitioned() ? partitionIds_.size() : bucketIds_.size();
   for (auto row = 0; row < numRows; ++row) {
-    VELOX_CHECK_LT(partitionIds_[row], std::numeric_limits<uint32_t>::max());
-    const uint32_t partitionId = static_cast<uint32_t>(partitionIds_[row]);
-    const auto id = isBucketed() ? HiveWriterId{partitionId, bucketIds_[row]}
-                                 : HiveWriterId{partitionId};
-    const uint32_t index = ensureWriter(id);
+    auto id = getWriterId(row);
+    uint32_t index = ensureWriter(id);
+
     VELOX_DCHECK_LT(index, partitionSizes_.size());
     VELOX_DCHECK_EQ(partitionSizes_.size(), partitionRows_.size());
     VELOX_DCHECK_EQ(partitionRows_.size(), rawPartitionRows_.size());
@@ -579,12 +847,10 @@ void HiveDataSink::splitInputRowsAndEnsureWriters() {
 HiveWriterParameters HiveDataSink::getWriterParameters(
     const std::optional<std::string>& partition,
     std::optional<uint32_t> bucketId) const {
-  const auto updateMode = getUpdateMode();
-
   auto [targetFileName, writeFileName] = getWriterFileNames(bucketId);
 
   return HiveWriterParameters{
-      updateMode,
+      updateMode_,
       partition,
       targetFileName,
       makePartitionDirectory(
@@ -596,15 +862,17 @@ HiveWriterParameters HiveDataSink::getWriterParameters(
 
 std::pair<std::string, std::string> HiveDataSink::getWriterFileNames(
     std::optional<uint32_t> bucketId) const {
-  std::string targetFileName;
+  auto targetFileName = insertTableHandle_->locationHandle()->targetFileName();
+  const bool generateFileName = targetFileName.empty();
   if (bucketId.has_value()) {
+    VELOX_CHECK(generateFileName);
     // TODO: add hive.file_renaming_enabled support.
     targetFileName = computeBucketedFileName(
         connectorQueryCtx_->queryId(), bucketId.value());
-  } else {
-    // targetFileName includes planNodeId and Uuid. As a result, different table
-    // writers run by the same task driver or the same table writer run in
-    // different task tries would have different targetFileNames.
+  } else if (generateFileName) {
+    // targetFileName includes planNodeId and Uuid. As a result, different
+    // table writers run by the same task driver or the same table writer
+    // run in different task tries would have different targetFileNames.
     targetFileName = fmt::format(
         "{}_{}_{}_{}",
         connectorQueryCtx_->taskId(),
@@ -612,17 +880,25 @@ std::pair<std::string, std::string> HiveDataSink::getWriterFileNames(
         connectorQueryCtx_->planNodeId(),
         makeUuid());
   }
+  VELOX_CHECK(!targetFileName.empty());
   const std::string writeFileName = isCommitRequired()
       ? fmt::format(".tmp.velox.{}_{}", targetFileName, makeUuid())
       : targetFileName;
+  if (generateFileName &&
+      insertTableHandle_->tableStorageFormat() ==
+          dwio::common::FileFormat::PARQUET) {
+    return {
+        fmt::format("{}{}", targetFileName, ".parquet"),
+        fmt::format("{}{}", writeFileName, ".parquet")};
+  }
   return {targetFileName, writeFileName};
 }
 
 HiveWriterParameters::UpdateMode HiveDataSink::getUpdateMode() const {
-  if (insertTableHandle_->isInsertTable()) {
+  if (insertTableHandle_->isExistingTable()) {
     if (insertTableHandle_->isPartitioned()) {
-      const auto insertBehavior = HiveConfig::insertExistingPartitionsBehavior(
-          connectorQueryCtx_->config());
+      const auto insertBehavior = hiveConfig_->insertExistingPartitionsBehavior(
+          connectorQueryCtx_->sessionProperties());
       switch (insertBehavior) {
         case HiveConfig::InsertExistingPartitionsBehavior::kOverwrite:
           return HiveWriterParameters::UpdateMode::kOverwrite;
@@ -638,7 +914,7 @@ HiveWriterParameters::UpdateMode HiveDataSink::getUpdateMode() const {
       if (insertTableHandle_->isBucketed()) {
         VELOX_USER_FAIL("Cannot insert into bucketed unpartitioned Hive table");
       }
-      if (HiveConfig::immutablePartitions(connectorProperties_.get())) {
+      if (hiveConfig_->immutablePartitions()) {
         VELOX_USER_FAIL("Unpartitioned Hive tables are immutable.");
       }
       return HiveWriterParameters::UpdateMode::kAppend;
@@ -663,7 +939,7 @@ bool HiveInsertTableHandle::isBucketed() const {
   return bucketProperty() != nullptr;
 }
 
-bool HiveInsertTableHandle::isInsertTable() const {
+bool HiveInsertTableHandle::isExistingTable() const {
   return locationHandle_->tableType() == LocationHandle::TableType::kExisting;
 }
 
@@ -696,11 +972,22 @@ void HiveInsertTableHandle::registerSerDe() {
 
 std::string HiveInsertTableHandle::toString() const {
   std::ostringstream out;
-  out << "HiveInsertTableHandle [inputColumns: [";
+  out << "HiveInsertTableHandle ["
+      << dwio::common::toString(tableStorageFormat_);
+  if (compressionKind_.has_value()) {
+    out << " " << common::compressionKindToString(compressionKind_.value());
+  } else {
+    out << " none";
+  }
+  out << "], [inputColumns: [";
   for (const auto& i : inputColumns_) {
     out << " " << i->toString();
   }
-  out << " ], locationHandle: " << locationHandle_->toString() << "]";
+  out << " ], locationHandle: " << locationHandle_->toString();
+  if (bucketProperty_) {
+    out << ", bucketProperty: " << bucketProperty_->toString();
+  }
+  out << "]";
   return out.str();
 }
 
@@ -733,4 +1020,69 @@ LocationHandlePtr LocationHandle::create(const folly::dynamic& obj) {
   return std::make_shared<LocationHandle>(targetPath, writePath, tableType);
 }
 
+std::unique_ptr<memory::MemoryReclaimer> HiveDataSink::WriterReclaimer::create(
+    HiveDataSink* dataSink,
+    HiveWriterInfo* writerInfo,
+    io::IoStatistics* ioStats) {
+  return std::unique_ptr<memory::MemoryReclaimer>(
+      new HiveDataSink::WriterReclaimer(dataSink, writerInfo, ioStats));
+}
+
+bool HiveDataSink::WriterReclaimer::reclaimableBytes(
+    const memory::MemoryPool& pool,
+    uint64_t& reclaimableBytes) const {
+  VELOX_CHECK_EQ(pool.name(), writerInfo_->writerPool->name());
+  reclaimableBytes = 0;
+  if (!dataSink_->canReclaim()) {
+    return false;
+  }
+  return exec::MemoryReclaimer::reclaimableBytes(pool, reclaimableBytes);
+}
+
+uint64_t HiveDataSink::WriterReclaimer::reclaim(
+    memory::MemoryPool* pool,
+    uint64_t targetBytes,
+    uint64_t maxWaitMs,
+    memory::MemoryReclaimer::Stats& stats) {
+  VELOX_CHECK_EQ(pool->name(), writerInfo_->writerPool->name());
+  if (!dataSink_->canReclaim()) {
+    return 0;
+  }
+
+  if (*writerInfo_->nonReclaimableSectionHolder.get()) {
+    RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
+    LOG(WARNING) << "Can't reclaim from hive writer pool " << pool->name()
+                 << " which is under non-reclaimable section, "
+                 << " reserved memory: "
+                 << succinctBytes(pool->reservedBytes());
+    ++stats.numNonReclaimableAttempts;
+    return 0;
+  }
+
+  const uint64_t memoryUsageBeforeReclaim = pool->reservedBytes();
+  const std::string memoryUsageTreeBeforeReclaim = pool->treeMemoryUsage();
+  const auto writtenBytesBeforeReclaim = ioStats_->rawBytesWritten();
+  const auto reclaimedBytes =
+      exec::MemoryReclaimer::reclaim(pool, targetBytes, maxWaitMs, stats);
+  const auto earlyFlushedRawBytes =
+      ioStats_->rawBytesWritten() - writtenBytesBeforeReclaim;
+  addThreadLocalRuntimeStat(
+      kEarlyFlushedRawBytes,
+      RuntimeCounter(earlyFlushedRawBytes, RuntimeCounter::Unit::kBytes));
+  if (earlyFlushedRawBytes > 0) {
+    RECORD_METRIC_VALUE(
+        kMetricFileWriterEarlyFlushedRawBytes, earlyFlushedRawBytes);
+  }
+  const uint64_t memoryUsageAfterReclaim = pool->reservedBytes();
+  if (memoryUsageAfterReclaim > memoryUsageBeforeReclaim) {
+    VELOX_FAIL(
+        "Unexpected memory growth after memory reclaim from {}, the memory usage before reclaim: {}, after reclaim: {}\nThe memory tree usage before reclaim:\n{}\nThe memory tree usage after reclaim:\n{}",
+        pool->name(),
+        succinctBytes(memoryUsageBeforeReclaim),
+        succinctBytes(memoryUsageAfterReclaim),
+        memoryUsageTreeBeforeReclaim,
+        pool->treeMemoryUsage());
+  }
+  return reclaimedBytes;
+}
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveDataSink.h b/velox/connectors/hive/HiveDataSink.h
index a18e6c2d87024..1b3d3bd464f49 100644
--- a/velox/connectors/hive/HiveDataSink.h
+++ b/velox/connectors/hive/HiveDataSink.h
@@ -17,16 +17,19 @@
 
 #include "velox/common/compression/Compression.h"
 #include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/PartitionIdGenerator.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/Writer.h"
 #include "velox/dwio/common/WriterFactory.h"
+#include "velox/exec/MemoryReclaimer.h"
 
 namespace facebook::velox::dwrf {
 class Writer;
 }
 
 namespace facebook::velox::connector::hive {
+
 class HiveColumnHandle;
 
 class LocationHandle;
@@ -45,8 +48,10 @@ class LocationHandle : public ISerializable {
   LocationHandle(
       std::string targetPath,
       std::string writePath,
-      TableType tableType)
+      TableType tableType,
+      std::string targetFileName = "")
       : targetPath_(std::move(targetPath)),
+        targetFileName_(std::move(targetFileName)),
         writePath_(std::move(writePath)),
         tableType_(tableType) {}
 
@@ -54,6 +59,10 @@ class LocationHandle : public ISerializable {
     return targetPath_;
   }
 
+  const std::string& targetFileName() const {
+    return targetFileName_;
+  }
+
   const std::string& writePath() const {
     return writePath_;
   }
@@ -77,6 +86,8 @@ class LocationHandle : public ISerializable {
  private:
   // Target directory path.
   const std::string targetPath_;
+  // If non-empty, use this name instead of generating our own.
+  const std::string targetFileName_;
   // Staging directory path.
   const std::string writePath_;
   // Whether the table to be written is new, already existing or temporary.
@@ -184,9 +195,7 @@ FOLLY_ALWAYS_INLINE std::ostream& operator<<(
 class HiveInsertTableHandle;
 using HiveInsertTableHandlePtr = std::shared_ptr<HiveInsertTableHandle>;
 
-/**
- * Represents a request for Hive write.
- */
+/// Represents a request for Hive write.
 class HiveInsertTableHandle : public ConnectorInsertTableHandle {
  public:
   HiveInsertTableHandle(
@@ -195,16 +204,21 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
       dwio::common::FileFormat tableStorageFormat =
           dwio::common::FileFormat::DWRF,
       std::shared_ptr<HiveBucketProperty> bucketProperty = nullptr,
-      std::optional<common::CompressionKind> compressionKind = {})
+      std::optional<common::CompressionKind> compressionKind = {},
+      const std::unordered_map<std::string, std::string>& serdeParameters = {},
+      const std::shared_ptr<dwio::common::WriterOptions>& writerOptions =
+          nullptr)
       : inputColumns_(std::move(inputColumns)),
         locationHandle_(std::move(locationHandle)),
         tableStorageFormat_(tableStorageFormat),
         bucketProperty_(std::move(bucketProperty)),
-        compressionKind_(compressionKind) {
+        compressionKind_(compressionKind),
+        serdeParameters_(serdeParameters),
+        writerOptions_(writerOptions) {
     if (compressionKind.has_value()) {
       VELOX_CHECK(
           compressionKind.value() != common::CompressionKind_MAX,
-          "Unsupported compression type: CompressionKind_MAX")
+          "Unsupported compression type: CompressionKind_MAX");
     }
   }
 
@@ -227,6 +241,14 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
     return tableStorageFormat_;
   }
 
+  const std::unordered_map<std::string, std::string>& serdeParameters() const {
+    return serdeParameters_;
+  }
+
+  const std::shared_ptr<dwio::common::WriterOptions>& writerOptions() const {
+    return writerOptions_;
+  }
+
   bool supportsMultiThreading() const override {
     return true;
   }
@@ -237,7 +259,7 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
 
   const HiveBucketProperty* bucketProperty() const;
 
-  bool isInsertTable() const;
+  bool isExistingTable() const;
 
   folly::dynamic serialize() const override;
 
@@ -245,7 +267,7 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
 
   static void registerSerDe();
 
-  std::string toString() const;
+  std::string toString() const override;
 
  private:
   const std::vector<std::shared_ptr<const HiveColumnHandle>> inputColumns_;
@@ -253,6 +275,8 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
   const dwio::common::FileFormat tableStorageFormat_;
   const std::shared_ptr<HiveBucketProperty> bucketProperty_;
   const std::optional<common::CompressionKind> compressionKind_;
+  const std::unordered_map<std::string, std::string> serdeParameters_;
+  const std::shared_ptr<dwio::common::WriterOptions> writerOptions_;
 };
 
 /// Parameters for Hive writers.
@@ -339,10 +363,26 @@ class HiveWriterParameters {
 };
 
 struct HiveWriterInfo {
-  explicit HiveWriterInfo(HiveWriterParameters parameters)
-      : writerParameters(std::move(parameters)) {}
+  HiveWriterInfo(
+      HiveWriterParameters parameters,
+      std::shared_ptr<memory::MemoryPool> _writerPool,
+      std::shared_ptr<memory::MemoryPool> _sinkPool,
+      std::shared_ptr<memory::MemoryPool> _sortPool)
+      : writerParameters(std::move(parameters)),
+        nonReclaimableSectionHolder(new tsan_atomic<bool>(false)),
+        spillStats(std::make_unique<folly::Synchronized<common::SpillStats>>()),
+        writerPool(std::move(_writerPool)),
+        sinkPool(std::move(_sinkPool)),
+        sortPool(std::move(_sortPool)) {}
 
   const HiveWriterParameters writerParameters;
+  const std::unique_ptr<tsan_atomic<bool>> nonReclaimableSectionHolder;
+  /// Collects the spill stats from sort writer if the spilling has been
+  /// triggered.
+  const std::unique_ptr<folly::Synchronized<common::SpillStats>> spillStats;
+  const std::shared_ptr<memory::MemoryPool> writerPool;
+  const std::shared_ptr<memory::MemoryPool> sinkPool;
+  const std::shared_ptr<memory::MemoryPool> sortPool;
   int64_t numWrittenRows = 0;
 };
 
@@ -353,13 +393,13 @@ struct HiveWriterId {
 
   HiveWriterId() = default;
 
-  explicit HiveWriterId(uint32_t _partitionId)
-      : HiveWriterId(_partitionId, std::nullopt) {}
-
-  HiveWriterId(uint32_t _partitionId, std::optional<uint32_t> _bucketId)
+  HiveWriterId(
+      std::optional<uint32_t> _partitionId,
+      std::optional<uint32_t> _bucketId = std::nullopt)
       : partitionId(_partitionId), bucketId(_bucketId) {}
 
-  /// Returns the special writer id for the un-partitioned table.
+  /// Returns the special writer id for the un-partitioned (and non-bucketed)
+  /// table.
   static const HiveWriterId& unpartitionedId();
 
   std::string toString() const;
@@ -386,12 +426,15 @@ struct HiveWriterIdEq {
 
 class HiveDataSink : public DataSink {
  public:
+  /// The list of runtime stats reported by hive data sink
+  static constexpr const char* kEarlyFlushedRawBytes = "earlyFlushedRawBytes";
+
   HiveDataSink(
       RowTypePtr inputType,
       std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
       const ConnectorQueryCtx* connectorQueryCtx,
       CommitStrategy commitStrategy,
-      const std::shared_ptr<const Config>& connectorProperties);
+      const std::shared_ptr<const HiveConfig>& hiveConfig);
 
   static uint32_t maxBucketCount() {
     static const uint32_t kMaxBucketCount = 100'000;
@@ -400,13 +443,65 @@ class HiveDataSink : public DataSink {
 
   void appendData(RowVectorPtr input) override;
 
-  int64_t getCompletedBytes() const override;
+  Stats stats() const override;
 
-  int32_t numWrittenFiles() const override;
+  std::vector<std::string> close() override;
 
-  std::vector<std::string> close(bool success) override;
+  void abort() override;
+
+  bool canReclaim() const;
 
  private:
+  enum class State { kRunning = 0, kAborted = 1, kClosed = 2 };
+  friend struct fmt::formatter<
+      facebook::velox::connector::hive::HiveDataSink::State>;
+
+  static std::string stateString(State state);
+
+  // Validates the state transition from 'oldState' to 'newState'.
+  void checkStateTransition(State oldState, State newState);
+  void setState(State newState);
+
+  class WriterReclaimer : public exec::MemoryReclaimer {
+   public:
+    static std::unique_ptr<memory::MemoryReclaimer> create(
+        HiveDataSink* dataSink,
+        HiveWriterInfo* writerInfo,
+        io::IoStatistics* ioStats);
+
+    bool reclaimableBytes(
+        const memory::MemoryPool& pool,
+        uint64_t& reclaimableBytes) const override;
+
+    uint64_t reclaim(
+        memory::MemoryPool* pool,
+        uint64_t targetBytes,
+        uint64_t maxWaitMs,
+        memory::MemoryReclaimer::Stats& stats) override;
+
+   private:
+    WriterReclaimer(
+        HiveDataSink* dataSink,
+        HiveWriterInfo* writerInfo,
+        io::IoStatistics* ioStats)
+        : exec::MemoryReclaimer(),
+          dataSink_(dataSink),
+          writerInfo_(writerInfo),
+          ioStats_(ioStats) {
+      VELOX_CHECK_NOT_NULL(dataSink_);
+      VELOX_CHECK_NOT_NULL(writerInfo_);
+      VELOX_CHECK_NOT_NULL(ioStats_);
+    }
+
+    HiveDataSink* const dataSink_;
+    HiveWriterInfo* const writerInfo_;
+    io::IoStatistics* const ioStats_;
+  };
+
+  FOLLY_ALWAYS_INLINE bool sortWrite() const {
+    return !sortColumnIndices_.empty();
+  }
+
   // Returns true if the table is partitioned.
   FOLLY_ALWAYS_INLINE bool isPartitioned() const {
     return partitionIdGenerator_ != nullptr;
@@ -421,9 +516,20 @@ class HiveDataSink : public DataSink {
     return commitStrategy_ != CommitStrategy::kNoCommit;
   }
 
+  std::shared_ptr<memory::MemoryPool> createWriterPool(
+      const HiveWriterId& writerId);
+
+  void setMemoryReclaimers(
+      HiveWriterInfo* writerInfo,
+      io::IoStatistics* ioStats);
+
   // Compute the partition id and bucket id for each row in 'input'.
   void computePartitionAndBucketIds(const RowVectorPtr& input);
 
+  // Get the HiveWriter corresponding to the row
+  // from partitionIds and bucketIds.
+  FOLLY_ALWAYS_INLINE HiveWriterId getWriterId(size_t row) const;
+
   // Computes the number of input rows as well as the actual input row indices
   // to each corresponding (bucketed) partition based on the partition and
   // bucket ids calculated by 'computePartitionAndBucketIds'. The function also
@@ -458,29 +564,26 @@ class HiveDataSink : public DataSink {
 
   HiveWriterParameters::UpdateMode getUpdateMode() const;
 
-  FOLLY_ALWAYS_INLINE bool closedOrAborted() const {
-    VELOX_CHECK(!(closed_ && aborted_));
-    return closed_ || aborted_;
+  FOLLY_ALWAYS_INLINE void checkRunning() const {
+    VELOX_CHECK_EQ(state_, State::kRunning, "Hive data sink is not running");
   }
 
-  FOLLY_ALWAYS_INLINE void checkNotClosed() const {
-    VELOX_CHECK(!closed_, "Hive data sink has been closed");
-  }
+  // Invoked to write 'input' to the specified file writer.
+  void write(size_t index, RowVectorPtr input);
 
-  FOLLY_ALWAYS_INLINE void checkNotAborted() const {
-    VELOX_CHECK(!aborted_, "Hive data sink hash been aborted");
-  }
-
-  void closeInternal(bool abort);
+  void closeInternal();
 
   const RowTypePtr inputType_;
   const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle_;
   const ConnectorQueryCtx* const connectorQueryCtx_;
   const CommitStrategy commitStrategy_;
-  const std::shared_ptr<const Config> connectorProperties_;
+  const std::shared_ptr<const HiveConfig> hiveConfig_;
+  const HiveWriterParameters::UpdateMode updateMode_;
   const uint32_t maxOpenWriters_;
   const std::vector<column_index_t> partitionChannels_;
   const std::unique_ptr<PartitionIdGenerator> partitionIdGenerator_;
+  // Indices of dataChannel are stored in ascending order
+  const std::vector<column_index_t> dataChannels_;
   const int32_t bucketCount_{0};
   const std::unique_ptr<core::PartitionFunction> bucketFunction_;
   const std::shared_ptr<dwio::common::WriterFactory> writerFactory_;
@@ -489,10 +592,8 @@ class HiveDataSink : public DataSink {
   std::vector<column_index_t> sortColumnIndices_;
   std::vector<CompareFlags> sortCompareFlags_;
 
-  bool closed_{false};
-  bool aborted_{false};
+  State state_{State::kRunning};
 
-  uint32_t numSpillRuns_{0};
   tsan_atomic<bool> nonReclaimableSection_{false};
 
   // The map from writer id to the writer index in 'writers_' and 'writerInfo_'.
@@ -519,3 +620,24 @@ class HiveDataSink : public DataSink {
 };
 
 } // namespace facebook::velox::connector::hive
+
+template <>
+struct fmt::formatter<facebook::velox::connector::hive::HiveDataSink::State>
+    : formatter<int> {
+  auto format(
+      facebook::velox::connector::hive::HiveDataSink::State s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<
+    facebook::velox::connector::hive::LocationHandle::TableType>
+    : formatter<int> {
+  auto format(
+      facebook::velox::connector::hive::LocationHandle::TableType s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/connectors/hive/HiveDataSource.cpp b/velox/connectors/hive/HiveDataSource.cpp
index e120f63759821..3f41f23b2f530 100644
--- a/velox/connectors/hive/HiveDataSource.cpp
+++ b/velox/connectors/hive/HiveDataSource.cpp
@@ -16,14 +16,18 @@
 
 #include "velox/connectors/hive/HiveDataSource.h"
 
+#include <fmt/ranges.h>
 #include <string>
 #include <unordered_map>
 
-#include "velox/dwio/common/CachedBufferedInput.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/dwio/common/ReaderFactory.h"
-#include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/expression/FieldReference.h"
 
+using facebook::velox::common::testutil::TestValue;
+
 namespace facebook::velox::connector::hive {
 
 class HiveTableHandle;
@@ -31,321 +35,28 @@ class HiveColumnHandle;
 
 namespace {
 
-struct SubfieldSpec {
-  const common::Subfield* subfield;
-  bool filterOnly;
-};
-
-template <typename T>
-void deduplicate(std::vector<T>& values) {
-  std::sort(values.begin(), values.end());
-  values.erase(std::unique(values.begin(), values.end()), values.end());
-}
-
-// Floating point map key subscripts are truncated toward 0 in Presto.  For
-// example given `a' as a map with floating point key, if user queries a[0.99],
-// Presto coordinator will generate a required subfield a[0]; for a[-1.99] it
-// will generate a[-1]; for anything larger than 9223372036854775807, it
-// generates a[9223372036854775807]; for anything smaller than
-// -9223372036854775808 it generates a[-9223372036854775808].
-template <typename T>
-std::unique_ptr<common::Filter> makeFloatingPointMapKeyFilter(
-    const std::vector<int64_t>& subscripts) {
-  std::vector<std::unique_ptr<common::Filter>> filters;
-  for (auto subscript : subscripts) {
-    T lower = subscript;
-    T upper = subscript;
-    bool lowerUnbounded = subscript == std::numeric_limits<int64_t>::min();
-    bool upperUnbounded = subscript == std::numeric_limits<int64_t>::max();
-    bool lowerExclusive = false;
-    bool upperExclusive = false;
-    if (lower <= 0 && !lowerUnbounded) {
-      if (lower > subscript - 1) {
-        lower = subscript - 1;
-      } else {
-        lower = std::nextafter(lower, -std::numeric_limits<T>::infinity());
-      }
-      lowerExclusive = true;
-    }
-    if (upper >= 0 && !upperUnbounded) {
-      if (upper < subscript + 1) {
-        upper = subscript + 1;
-      } else {
-        upper = std::nextafter(upper, std::numeric_limits<T>::infinity());
-      }
-      upperExclusive = true;
-    }
-    if (lowerUnbounded && upperUnbounded) {
-      continue;
-    }
-    filters.push_back(std::make_unique<common::FloatingPointRange<T>>(
-        lower,
-        lowerUnbounded,
-        lowerExclusive,
-        upper,
-        upperUnbounded,
-        upperExclusive,
-        false));
-  }
-  if (filters.size() == 1) {
-    return std::move(filters[0]);
-  }
-  return std::make_unique<common::MultiRange>(std::move(filters), false, false);
-}
-
-// Recursively add subfields to scan spec.
-void addSubfields(
-    const Type& type,
-    std::vector<SubfieldSpec>& subfields,
-    int level,
-    memory::MemoryPool* pool,
-    common::ScanSpec& spec) {
-  int newSize = 0;
-  for (int i = 0; i < subfields.size(); ++i) {
-    if (level < subfields[i].subfield->path().size()) {
-      subfields[newSize++] = subfields[i];
-    } else if (!subfields[i].filterOnly) {
-      spec.addAllChildFields(type);
-      return;
-    }
-  }
-  subfields.resize(newSize);
-  switch (type.kind()) {
-    case TypeKind::ROW: {
-      folly::F14FastMap<std::string, std::vector<SubfieldSpec>> required;
-      for (auto& subfield : subfields) {
-        auto* element = subfield.subfield->path()[level].get();
-        auto* nestedField =
-            dynamic_cast<const common::Subfield::NestedField*>(element);
-        VELOX_CHECK(
-            nestedField,
-            "Unsupported for row subfields pruning: {}",
-            element->toString());
-        required[nestedField->name()].push_back(subfield);
-      }
-      auto& rowType = type.asRow();
-      for (int i = 0; i < rowType.size(); ++i) {
-        auto& childName = rowType.nameOf(i);
-        auto& childType = rowType.childAt(i);
-        auto* child = spec.addField(childName, i);
-        auto it = required.find(childName);
-        if (it == required.end()) {
-          child->setConstantValue(
-              BaseVector::createNullConstant(childType, 1, pool));
-        } else {
-          addSubfields(*childType, it->second, level + 1, pool, *child);
-        }
-      }
-      break;
-    }
-    case TypeKind::MAP: {
-      auto& keyType = type.childAt(0);
-      auto* keys = spec.addMapKeyFieldRecursively(*keyType);
-      addSubfields(
-          *type.childAt(1),
-          subfields,
-          level + 1,
-          pool,
-          *spec.addMapValueField());
-      if (subfields.empty()) {
-        return;
-      }
-      bool stringKey = keyType->isVarchar() || keyType->isVarbinary();
-      std::vector<std::string> stringSubscripts;
-      std::vector<int64_t> longSubscripts;
-      for (auto& subfield : subfields) {
-        auto* element = subfield.subfield->path()[level].get();
-        if (dynamic_cast<const common::Subfield::AllSubscripts*>(element)) {
-          return;
-        }
-        if (stringKey) {
-          auto* subscript =
-              dynamic_cast<const common::Subfield::StringSubscript*>(element);
-          VELOX_CHECK(
-              subscript,
-              "Unsupported for string map pruning: {}",
-              element->toString());
-          stringSubscripts.push_back(subscript->index());
-        } else {
-          auto* subscript =
-              dynamic_cast<const common::Subfield::LongSubscript*>(element);
-          VELOX_CHECK(
-              subscript,
-              "Unsupported for long map pruning: {}",
-              element->toString());
-          longSubscripts.push_back(subscript->index());
-        }
-      }
-      std::unique_ptr<common::Filter> filter;
-      if (stringKey) {
-        deduplicate(stringSubscripts);
-        filter = std::make_unique<common::BytesValues>(stringSubscripts, false);
-      } else {
-        deduplicate(longSubscripts);
-        if (keyType->isReal()) {
-          filter = makeFloatingPointMapKeyFilter<float>(longSubscripts);
-        } else if (keyType->isDouble()) {
-          filter = makeFloatingPointMapKeyFilter<double>(longSubscripts);
-        } else {
-          filter = common::createBigintValues(longSubscripts, false);
-        }
-      }
-      keys->setFilter(std::move(filter));
-      break;
-    }
-    case TypeKind::ARRAY: {
-      addSubfields(
-          *type.childAt(0),
-          subfields,
-          level + 1,
-          pool,
-          *spec.addArrayElementField());
-      if (subfields.empty()) {
-        return;
-      }
-      constexpr long kMaxIndex = std::numeric_limits<vector_size_t>::max();
-      long maxIndex = -1;
-      for (auto& subfield : subfields) {
-        auto* element = subfield.subfield->path()[level].get();
-        if (dynamic_cast<const common::Subfield::AllSubscripts*>(element)) {
-          return;
-        }
-        auto* subscript =
-            dynamic_cast<const common::Subfield::LongSubscript*>(element);
-        VELOX_CHECK(
-            subscript,
-            "Unsupported for array pruning: {}",
-            element->toString());
-        maxIndex = std::max(maxIndex, std::min(kMaxIndex, subscript->index()));
-      }
-      spec.setMaxArrayElementsCount(maxIndex);
-      break;
-    }
-    default:
-      break;
-  }
-}
-
-core::CallTypedExprPtr replaceInputs(
-    const core::CallTypedExpr* call,
-    std::vector<core::TypedExprPtr>&& inputs) {
-  return std::make_shared<core::CallTypedExpr>(
-      call->type(), std::move(inputs), call->name());
+bool isMember(
+    const std::vector<exec::FieldReference*>& fields,
+    const exec::FieldReference& field) {
+  return std::find(fields.begin(), fields.end(), &field) != fields.end();
 }
 
-void checkColumnNameLowerCase(const std::shared_ptr<const Type>& type) {
-  switch (type->kind()) {
-    case TypeKind::ARRAY:
-      checkColumnNameLowerCase(type->asArray().elementType());
-      break;
-    case TypeKind::MAP: {
-      checkColumnNameLowerCase(type->asMap().keyType());
-      checkColumnNameLowerCase(type->asMap().valueType());
-
-    } break;
-    case TypeKind::ROW: {
-      for (auto& outputName : type->asRow().names()) {
-        VELOX_CHECK(
-            !std::any_of(outputName.begin(), outputName.end(), isupper));
-      }
-      for (auto& childType : type->asRow().children()) {
-        checkColumnNameLowerCase(childType);
-      }
-    } break;
-    default:
-      VLOG(1) << "No need to check type lowercase mode" << type->toString();
+bool shouldEagerlyMaterialize(
+    const exec::Expr& remainingFilter,
+    const exec::FieldReference& field) {
+  if (!remainingFilter.evaluatesArgumentsOnNonIncreasingSelection()) {
+    return true;
   }
-}
-
-void checkColumnNameLowerCase(const SubfieldFilters& filters) {
-  for (auto& pair : filters) {
-    if (auto name = pair.first.toString(); name == kPath || name == kBucket) {
-      continue;
+  for (auto& input : remainingFilter.inputs()) {
+    if (isMember(input->distinctFields(), field) && input->hasConditionals()) {
+      return true;
     }
-    auto& path = pair.first.path();
-
-    for (int i = 0; i < path.size(); ++i) {
-      auto nestedField =
-          dynamic_cast<const common::Subfield::NestedField*>(path[i].get());
-      if (nestedField == nullptr) {
-        continue;
-      }
-      VELOX_CHECK(!std::any_of(
-          nestedField->name().begin(), nestedField->name().end(), isupper));
-    }
-  }
-}
-
-void checkColumnNameLowerCase(const core::TypedExprPtr& typeExpr) {
-  if (typeExpr == nullptr) {
-    return;
-  }
-  checkColumnNameLowerCase(typeExpr->type());
-  for (auto& type : typeExpr->inputs()) {
-    checkColumnNameLowerCase(type);
   }
-}
-
-const std::string& getColumnName(const common::Subfield& subfield) {
-  VELOX_CHECK_GT(subfield.path().size(), 0);
-  auto* field = dynamic_cast<const common::Subfield::NestedField*>(
-      subfield.path()[0].get());
-  VELOX_CHECK(field);
-  return field->name();
+  return false;
 }
 
 } // namespace
 
-core::TypedExprPtr HiveDataSource::extractFiltersFromRemainingFilter(
-    const core::TypedExprPtr& expr,
-    core::ExpressionEvaluator* evaluator,
-    bool negated,
-    SubfieldFilters& filters) {
-  auto* call = dynamic_cast<const core::CallTypedExpr*>(expr.get());
-  if (!call) {
-    return expr;
-  }
-  common::Filter* oldFilter = nullptr;
-  try {
-    common::Subfield subfield;
-    if (auto filter = exec::leafCallToSubfieldFilter(
-            *call, subfield, evaluator, negated)) {
-      if (auto it = filters.find(subfield); it != filters.end()) {
-        oldFilter = it->second.get();
-        filter = filter->mergeWith(oldFilter);
-      }
-      filters.insert_or_assign(std::move(subfield), std::move(filter));
-      return nullptr;
-    }
-  } catch (const VeloxException&) {
-    LOG(WARNING) << "Unexpected failure when extracting filter for: "
-                 << expr->toString();
-    if (oldFilter) {
-      LOG(WARNING) << "Merging with " << oldFilter->toString();
-    }
-  }
-  if (call->name() == "not") {
-    auto inner = extractFiltersFromRemainingFilter(
-        call->inputs()[0], evaluator, !negated, filters);
-    return inner ? replaceInputs(call, {inner}) : nullptr;
-  }
-  if ((call->name() == "and" && !negated) ||
-      (call->name() == "or" && negated)) {
-    auto lhs = extractFiltersFromRemainingFilter(
-        call->inputs()[0], evaluator, negated, filters);
-    auto rhs = extractFiltersFromRemainingFilter(
-        call->inputs()[1], evaluator, negated, filters);
-    if (!lhs) {
-      return rhs;
-    }
-    if (!rhs) {
-      return lhs;
-    }
-    return replaceInputs(call, {lhs, rhs});
-  }
-  return expr;
-}
-
 HiveDataSource::HiveDataSource(
     const RowTypePtr& outputType,
     const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
@@ -353,37 +64,41 @@ HiveDataSource::HiveDataSource(
         std::string,
         std::shared_ptr<connector::ColumnHandle>>& columnHandles,
     FileHandleFactory* fileHandleFactory,
-    core::ExpressionEvaluator* expressionEvaluator,
-    cache::AsyncDataCache* cache,
-    const std::string& scanId,
     folly::Executor* executor,
-    const dwio::common::ReaderOptions& options)
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<HiveConfig>& hiveConfig)
     : fileHandleFactory_(fileHandleFactory),
-      readerOpts_(options),
-      pool_(&options.getMemoryPool()),
+      executor_(executor),
+      connectorQueryCtx_(connectorQueryCtx),
+      hiveConfig_(hiveConfig),
+      pool_(connectorQueryCtx->memoryPool()),
       outputType_(outputType),
-      expressionEvaluator_(expressionEvaluator),
-      cache_(cache),
-      scanId_(scanId),
-      executor_(executor) {
+      expressionEvaluator_(connectorQueryCtx->expressionEvaluator()) {
   // Column handled keyed on the column alias, the name used in the query.
   for (const auto& [canonicalizedName, columnHandle] : columnHandles) {
     auto handle = std::dynamic_pointer_cast<HiveColumnHandle>(columnHandle);
-    VELOX_CHECK(
-        handle != nullptr,
+    VELOX_CHECK_NOT_NULL(
+        handle,
         "ColumnHandle must be an instance of HiveColumnHandle for {}",
         canonicalizedName);
 
     if (handle->columnType() == HiveColumnHandle::ColumnType::kPartitionKey) {
       partitionKeys_.emplace(handle->name(), handle);
     }
+
+    if (handle->columnType() == HiveColumnHandle::ColumnType::kSynthesized) {
+      infoColumns_.emplace(handle->name(), handle);
+    }
+
+    if (handle->columnType() == HiveColumnHandle::ColumnType::kRowIndex) {
+      VELOX_CHECK_NULL(rowIndexColumn_);
+      rowIndexColumn_ = handle;
+    }
   }
 
-  std::vector<std::string> readerRowNames;
-  auto readerRowTypes = outputType_->children();
-  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
-      subfields;
-  for (auto& outputName : outputType_->names()) {
+  std::vector<std::string> readColumnNames;
+  auto readColumnTypes = outputType_->children();
+  for (const auto& outputName : outputType_->names()) {
     auto it = columnHandles.find(outputName);
     VELOX_CHECK(
         it != columnHandles.end(),
@@ -391,77 +106,61 @@ HiveDataSource::HiveDataSource(
         outputName);
 
     auto* handle = static_cast<const HiveColumnHandle*>(it->second.get());
-    readerRowNames.push_back(handle->name());
+    readColumnNames.push_back(handle->name());
     for (auto& subfield : handle->requiredSubfields()) {
       VELOX_USER_CHECK_EQ(
           getColumnName(subfield),
           handle->name(),
           "Required subfield does not match column name");
-      subfields[handle->name()].push_back(&subfield);
+      subfields_[handle->name()].push_back(&subfield);
     }
   }
 
   hiveTableHandle_ = std::dynamic_pointer_cast<HiveTableHandle>(tableHandle);
-  VELOX_CHECK(
-      hiveTableHandle_ != nullptr,
-      "TableHandle must be an instance of HiveTableHandle");
-  if (readerOpts_.isFileColumnNamesReadAsLowerCase()) {
+  VELOX_CHECK_NOT_NULL(
+      hiveTableHandle_, "TableHandle must be an instance of HiveTableHandle");
+  if (hiveConfig_->isFileColumnNamesReadAsLowerCase(
+          connectorQueryCtx->sessionProperties())) {
     checkColumnNameLowerCase(outputType_);
-    checkColumnNameLowerCase(hiveTableHandle_->subfieldFilters());
+    checkColumnNameLowerCase(hiveTableHandle_->subfieldFilters(), infoColumns_);
     checkColumnNameLowerCase(hiveTableHandle_->remainingFilter());
   }
 
-  SubfieldFilters filters;
-  core::TypedExprPtr remainingFilter;
-  if (hiveTableHandle_->isFilterPushdownEnabled()) {
-    for (auto& [k, v] : hiveTableHandle_->subfieldFilters()) {
-      filters.emplace(k.clone(), v->clone());
-    }
-    remainingFilter = extractFiltersFromRemainingFilter(
-        hiveTableHandle_->remainingFilter(),
-        expressionEvaluator_,
-        false,
-        filters);
-  } else {
-    for (auto& [field, _] : hiveTableHandle_->subfieldFilters()) {
-      VELOX_USER_CHECK_EQ(
-          field.path().size(),
-          1,
-          "Unexpected filter on table {}, field {}",
-          hiveTableHandle_->tableName(),
-          field.toString());
-      auto* nestedField = dynamic_cast<const common::Subfield::NestedField*>(
-          field.path()[0].get());
-      VELOX_USER_CHECK_NOT_NULL(
-          nestedField,
-          "Unexpected filter on table {}, field {}",
-          hiveTableHandle_->tableName(),
-          field.toString());
-      VELOX_USER_CHECK_GT(
-          partitionKeys_.count(nestedField->name()),
-          0,
-          "Unexpected filter on table {}, field {}",
-          hiveTableHandle_->tableName(),
-          field.toString());
-    }
-    remainingFilter = hiveTableHandle_->remainingFilter();
+  for (const auto& [k, v] : hiveTableHandle_->subfieldFilters()) {
+    filters_.emplace(k.clone(), v->clone());
+  }
+  double sampleRate = 1;
+  auto remainingFilter = extractFiltersFromRemainingFilter(
+      hiveTableHandle_->remainingFilter(),
+      expressionEvaluator_,
+      false,
+      filters_,
+      sampleRate);
+  if (sampleRate != 1) {
+    randomSkip_ = std::make_shared<random::RandomSkipTracker>(sampleRate);
   }
 
   std::vector<common::Subfield> remainingFilterSubfields;
   if (remainingFilter) {
     remainingFilterExprSet_ = expressionEvaluator_->compile(remainingFilter);
     auto& remainingFilterExpr = remainingFilterExprSet_->expr(0);
-    folly::F14FastSet<std::string> columnNames(
-        readerRowNames.begin(), readerRowNames.end());
+    folly::F14FastMap<std::string, column_index_t> columnNames;
+    for (int i = 0; i < readColumnNames.size(); ++i) {
+      columnNames[readColumnNames[i]] = i;
+    }
     for (auto& input : remainingFilterExpr->distinctFields()) {
-      if (columnNames.count(input->field()) > 0) {
+      auto it = columnNames.find(input->field());
+      if (it != columnNames.end()) {
+        if (shouldEagerlyMaterialize(*remainingFilterExpr, *input)) {
+          multiReferencedFields_.push_back(it->second);
+        }
         continue;
       }
       // Remaining filter may reference columns that are not used otherwise,
       // e.g. are not being projected out and are not used in range filters.
       // Make sure to add these columns to readerOutputType_.
-      readerRowNames.push_back(input->field());
-      readerRowTypes.push_back(input->type());
+      readColumnNames.push_back(input->field());
+      readColumnTypes.push_back(input->type());
     }
     remainingFilterSubfields = remainingFilterExpr->extractSubfields();
     if (VLOG_IS_ON(1)) {
@@ -470,129 +169,176 @@ HiveDataSource::HiveDataSource(
           fmt::join(remainingFilterSubfields, ", "));
     }
     for (auto& subfield : remainingFilterSubfields) {
-      auto& name = getColumnName(subfield);
-      auto it = subfields.find(name);
-      if (it != subfields.end()) {
+      const auto& name = getColumnName(subfield);
+      auto it = subfields_.find(name);
+      if (it != subfields_.end()) {
         // Only subfields of the column are projected out.
         it->second.push_back(&subfield);
       } else if (columnNames.count(name) == 0) {
         // Column appears only in remaining filter.
-        subfields[name].push_back(&subfield);
+        subfields_[name].push_back(&subfield);
       }
     }
   }
 
-  readerOutputType_ = ROW(std::move(readerRowNames), std::move(readerRowTypes));
+  readerOutputType_ =
+      ROW(std::move(readColumnNames), std::move(readColumnTypes));
   scanSpec_ = makeScanSpec(
       readerOutputType_,
-      subfields,
-      filters,
+      subfields_,
+      filters_,
       hiveTableHandle_->dataColumns(),
+      partitionKeys_,
+      infoColumns_,
+      rowIndexColumn_,
       pool_);
   if (remainingFilter) {
     metadataFilter_ = std::make_shared<common::MetadataFilter>(
         *scanSpec_, *remainingFilter, expressionEvaluator_);
   }
 
-  readerOpts_.setFileSchema(hiveTableHandle_->dataColumns());
   ioStats_ = std::make_shared<io::IoStatistics>();
 }
 
-inline uint8_t parseDelimiter(const std::string& delim) {
-  for (char const& ch : delim) {
-    if (!std::isdigit(ch)) {
-      return delim[0];
-    }
-  }
-  return stoi(delim);
-}
-
-void HiveDataSource::parseSerdeParameters(
-    const std::unordered_map<std::string, std::string>& serdeParameters) {
-  auto fieldIt = serdeParameters.find(dwio::common::SerDeOptions::kFieldDelim);
-  if (fieldIt == serdeParameters.end()) {
-    fieldIt = serdeParameters.find("serialization.format");
-  }
-  auto collectionIt =
-      serdeParameters.find(dwio::common::SerDeOptions::kCollectionDelim);
-  if (collectionIt == serdeParameters.end()) {
-    // For collection delimiter, Hive 1.x, 2.x uses "colelction.delim", but
-    // Hive 3.x uses "collection.delim".
-    // See: https://issues.apache.org/jira/browse/HIVE-16922)
-    collectionIt = serdeParameters.find("colelction.delim");
-  }
-  auto mapKeyIt =
-      serdeParameters.find(dwio::common::SerDeOptions::kMapKeyDelim);
-
-  if (fieldIt == serdeParameters.end() &&
-      collectionIt == serdeParameters.end() &&
-      mapKeyIt == serdeParameters.end()) {
-    return;
-  }
-
-  uint8_t fieldDelim = '\1';
-  uint8_t collectionDelim = '\2';
-  uint8_t mapKeyDelim = '\3';
-  if (fieldIt != serdeParameters.end()) {
-    fieldDelim = parseDelimiter(fieldIt->second);
-  }
-  if (collectionIt != serdeParameters.end()) {
-    collectionDelim = parseDelimiter(collectionIt->second);
-  }
-  if (mapKeyIt != serdeParameters.end()) {
-    mapKeyDelim = parseDelimiter(mapKeyIt->second);
-  }
-  dwio::common::SerDeOptions serDeOptions(
-      fieldDelim, collectionDelim, mapKeyDelim);
-  readerOpts_.setSerDeOptions(serDeOptions);
-}
-
 std::unique_ptr<SplitReader> HiveDataSource::createSplitReader() {
   return SplitReader::create(
-      split_, readerOutputType_, partitionKeys_, scanSpec_, pool_);
+      split_,
+      hiveTableHandle_,
+      &partitionKeys_,
+      connectorQueryCtx_,
+      hiveConfig_,
+      readerOutputType_,
+      ioStats_,
+      fileHandleFactory_,
+      executor_,
+      scanSpec_);
+}
+
+std::unique_ptr<HivePartitionFunction> HiveDataSource::setupBucketConversion() {
+  VELOX_CHECK_NE(
+      split_->bucketConversion->tableBucketCount,
+      split_->bucketConversion->partitionBucketCount);
+  VELOX_CHECK(split_->tableBucketNumber.has_value());
+  VELOX_CHECK_NOT_NULL(hiveTableHandle_->dataColumns());
+  ++numBucketConversion_;
+  bool rebuildScanSpec = false;
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  std::vector<column_index_t> bucketChannels;
+  for (auto& handle : split_->bucketConversion->bucketColumnHandles) {
+    VELOX_CHECK(handle->columnType() == HiveColumnHandle::ColumnType::kRegular);
+    if (subfields_.erase(handle->name()) > 0) {
+      rebuildScanSpec = true;
+    }
+    auto index = readerOutputType_->getChildIdxIfExists(handle->name());
+    if (!index.has_value()) {
+      if (names.empty()) {
+        names = readerOutputType_->names();
+        types = readerOutputType_->children();
+      }
+      index = names.size();
+      names.push_back(handle->name());
+      types.push_back(
+          hiveTableHandle_->dataColumns()->findChild(handle->name()));
+      rebuildScanSpec = true;
+    }
+    bucketChannels.push_back(*index);
+  }
+  if (!names.empty()) {
+    readerOutputType_ = ROW(std::move(names), std::move(types));
+  }
+  if (rebuildScanSpec) {
+    auto newScanSpec = makeScanSpec(
+        readerOutputType_,
+        subfields_,
+        filters_,
+        hiveTableHandle_->dataColumns(),
+        partitionKeys_,
+        infoColumns_,
+        rowIndexColumn_,
+        pool_);
+    newScanSpec->moveAdaptationFrom(*scanSpec_);
+    scanSpec_ = std::move(newScanSpec);
+  }
+  return std::make_unique<HivePartitionFunction>(
+      split_->bucketConversion->tableBucketCount, std::move(bucketChannels));
 }
 
 void HiveDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
-  VELOX_CHECK(
-      split_ == nullptr,
+  VELOX_CHECK_NULL(
+      split_,
       "Previous split has not been processed yet. Call next to process the split.");
   split_ = std::dynamic_pointer_cast<HiveConnectorSplit>(split);
-  VELOX_CHECK(split_, "Wrong type of split");
+  VELOX_CHECK_NOT_NULL(split_, "Wrong type of split");
 
   VLOG(1) << "Adding split " << split_->toString();
 
-  if (readerOpts_.getFileFormat() != dwio::common::FileFormat::UNKNOWN) {
-    VELOX_CHECK(
-        readerOpts_.getFileFormat() == split_->fileFormat,
-        "HiveDataSource received splits of different formats: {} and {}",
-        toString(readerOpts_.getFileFormat()),
-        toString(split_->fileFormat));
+  if (splitReader_) {
+    splitReader_.reset();
+  }
+
+  if (split_->bucketConversion.has_value()) {
+    partitionFunction_ = setupBucketConversion();
   } else {
-    parseSerdeParameters(split_->serdeParameters);
-    readerOpts_.setFileFormat(split_->fileFormat);
+    partitionFunction_.reset();
   }
 
-  auto fileHandle = fileHandleFactory_->generate(split_->filePath).second;
-  auto input = createBufferedInput(*fileHandle, readerOpts_);
+  splitReader_ = createSplitReader();
+  // Split reader subclasses may need to use the reader options in prepareSplit
+  // so we initialize it beforehand.
+  splitReader_->configureReaderOptions(randomSkip_);
+  splitReader_->prepareSplit(metadataFilter_, runtimeStats_, rowIndexColumn_);
+}
 
-  if (splitReader_) {
-    splitReader_.reset();
+vector_size_t HiveDataSource::applyBucketConversion(
+    const RowVectorPtr& rowVector,
+    BufferPtr& indices) {
+  partitions_.clear();
+  partitionFunction_->partition(*rowVector, partitions_);
+  const auto bucketToKeep = *split_->tableBucketNumber;
+  const auto partitionBucketCount =
+      split_->bucketConversion->partitionBucketCount;
+  for (vector_size_t i = 0; i < rowVector->size(); ++i) {
+    VELOX_CHECK_EQ((partitions_[i] - bucketToKeep) % partitionBucketCount, 0);
+  }
+
+  if (remainingFilterExprSet_) {
+    for (vector_size_t i = 0; i < rowVector->size(); ++i) {
+      if (partitions_[i] != bucketToKeep) {
+        filterRows_.setValid(i, false);
+      }
+    }
+    filterRows_.updateBounds();
+    return filterRows_.countSelected();
+  }
+  vector_size_t size = 0;
+  for (vector_size_t i = 0; i < rowVector->size(); ++i) {
+    size += partitions_[i] == bucketToKeep;
+  }
+  if (size == 0) {
+    return 0;
+  }
+  indices = allocateIndices(size, pool_);
+  size = 0;
+  auto* rawIndices = indices->asMutable<vector_size_t>();
+  for (vector_size_t i = 0; i < rowVector->size(); ++i) {
+    if (partitions_[i] == bucketToKeep) {
+      rawIndices[size++] = i;
+    }
   }
-  splitReader_ = createSplitReader();
-  splitReader_->prepareSplit(
-      hiveTableHandle_,
-      readerOpts_,
-      std::move(input),
-      metadataFilter_,
-      runtimeStats_);
+  return size;
 }
 
 std::optional<RowVectorPtr> HiveDataSource::next(
     uint64_t size,
     velox::ContinueFuture& /*future*/) {
   VELOX_CHECK(split_ != nullptr, "No split to process. Call addSplit first.");
+  VELOX_CHECK_NOT_NULL(splitReader_, "No split reader present");
 
-  if (splitReader_ && splitReader_->emptySplit()) {
+  TestValue::adjust(
+      "facebook::velox::connector::hive::HiveDataSource::next", this);
+
+  if (splitReader_->emptySplit()) {
     resetSplit();
     return nullptr;
   }
@@ -601,67 +347,76 @@ std::optional<RowVectorPtr> HiveDataSource::next(
     output_ = BaseVector::create(readerOutputType_, 0, pool_);
   }
 
-  // TODO Check if remaining filter has a conjunct that doesn't depend on
-  // any column, e.g. rand() < 0.1. Evaluate that conjunct first, then scan
-  // only rows that passed.
-
-  auto rowsScanned = splitReader_->next(size, output_);
+  const auto rowsScanned = splitReader_->next(size, output_);
   completedRows_ += rowsScanned;
+  if (rowsScanned == 0) {
+    splitReader_->updateRuntimeStats(runtimeStats_);
+    resetSplit();
+    return nullptr;
+  }
 
-  if (rowsScanned) {
-    VELOX_CHECK(
-        !output_->mayHaveNulls(), "Top-level row vector cannot have nulls");
-    auto rowsRemaining = output_->size();
+  VELOX_CHECK(
+      !output_->mayHaveNulls(), "Top-level row vector cannot have nulls");
+  auto rowsRemaining = output_->size();
+  if (rowsRemaining == 0) {
+    // no rows passed the pushed down filters.
+    return getEmptyOutput();
+  }
+
+  auto rowVector = std::dynamic_pointer_cast<RowVector>(output_);
+
+  // In case there is a remaining filter that excludes some but not all
+  // rows, collect the indices of the passing rows. If there is no filter,
+  // or it passes on all rows, leave this as null and let exec::wrap skip
+  // wrapping the results.
+  BufferPtr remainingIndices;
+  if (remainingFilterExprSet_) {
+    if (numBucketConversion_ > 0) {
+      filterRows_.resizeFill(rowVector->size());
+    } else {
+      filterRows_.resize(rowVector->size());
+    }
+  }
+  if (partitionFunction_) {
+    rowsRemaining = applyBucketConversion(rowVector, remainingIndices);
     if (rowsRemaining == 0) {
-      // no rows passed the pushed down filters.
       return getEmptyOutput();
     }
+  }
 
-    auto rowVector = std::dynamic_pointer_cast<RowVector>(output_);
-
-    // In case there is a remaining filter that excludes some but not all
-    // rows, collect the indices of the passing rows. If there is no filter,
-    // or it passes on all rows, leave this as null and let exec::wrap skip
-    // wrapping the results.
-    BufferPtr remainingIndices;
-    if (remainingFilterExprSet_) {
-      rowsRemaining = evaluateRemainingFilter(rowVector);
-      VELOX_CHECK_LE(rowsRemaining, rowsScanned);
-      if (rowsRemaining == 0) {
-        // No rows passed the remaining filter.
-        return getEmptyOutput();
-      }
-
-      if (rowsRemaining < rowVector->size()) {
-        // Some, but not all rows passed the remaining filter.
-        remainingIndices = filterEvalCtx_.selectedIndices;
-      }
+  if (remainingFilterExprSet_) {
+    rowsRemaining = evaluateRemainingFilter(rowVector);
+    VELOX_CHECK_LE(rowsRemaining, rowsScanned);
+    if (rowsRemaining == 0) {
+      // No rows passed the remaining filter.
+      return getEmptyOutput();
     }
 
-    if (outputType_->size() == 0) {
-      return exec::wrap(rowsRemaining, remainingIndices, rowVector);
+    if (rowsRemaining < rowVector->size()) {
+      // Some, but not all rows passed the remaining filter.
+      remainingIndices = filterEvalCtx_.selectedIndices;
     }
+  }
 
-    std::vector<VectorPtr> outputColumns;
-    outputColumns.reserve(outputType_->size());
-    for (int i = 0; i < outputType_->size(); i++) {
-      auto& child = rowVector->childAt(i);
-      if (remainingIndices) {
-        // Disable dictionary values caching in expression eval so that we
-        // don't need to reallocate the result for every batch.
-        child->disableMemo();
-      }
-      outputColumns.emplace_back(
-          exec::wrapChild(rowsRemaining, remainingIndices, child));
-    }
+  if (outputType_->size() == 0) {
+    return exec::wrap(rowsRemaining, remainingIndices, rowVector);
+  }
 
-    return std::make_shared<RowVector>(
-        pool_, outputType_, BufferPtr(nullptr), rowsRemaining, outputColumns);
+  std::vector<VectorPtr> outputColumns;
+  outputColumns.reserve(outputType_->size());
+  for (int i = 0; i < outputType_->size(); ++i) {
+    auto& child = rowVector->childAt(i);
+    if (remainingIndices) {
+      // Disable dictionary values caching in expression eval so that we
+      // don't need to reallocate the result for every batch.
+      child->disableMemo();
+    }
+    outputColumns.emplace_back(
+        exec::wrapChild(rowsRemaining, remainingIndices, child));
   }
 
-  splitReader_->updateRuntimeStats(runtimeStats_);
-  resetSplit();
-  return nullptr;
+  return std::make_shared<RowVector>(
+      pool_, outputType_, BufferPtr(nullptr), rowsRemaining, outputColumns);
 }
 
 void HiveDataSource::addDynamicFilter(
@@ -695,34 +450,46 @@ std::unordered_map<std::string, RuntimeCounter> HiveDataSource::runtimeStats() {
        {"totalScanTime",
         RuntimeCounter(
             ioStats_->totalScanTime(), RuntimeCounter::Unit::kNanos)},
-       {"ioWaitNanos",
+       {"totalRemainingFilterTime",
+        RuntimeCounter(
+            totalRemainingFilterTime_.load(std::memory_order_relaxed),
+            RuntimeCounter::Unit::kNanos)},
+       {"ioWaitWallNanos",
         RuntimeCounter(
             ioStats_->queryThreadIoLatency().sum() * 1000,
             RuntimeCounter::Unit::kNanos)},
+       {"maxSingleIoWaitWallNanos",
+        RuntimeCounter(
+            ioStats_->queryThreadIoLatency().max() * 1000,
+            RuntimeCounter::Unit::kNanos)},
        {"overreadBytes",
         RuntimeCounter(
-            ioStats_->rawOverreadBytes(), RuntimeCounter::Unit::kBytes)},
-       {"queryThreadIoLatency",
-        RuntimeCounter(ioStats_->queryThreadIoLatency().count())}});
+            ioStats_->rawOverreadBytes(), RuntimeCounter::Unit::kBytes)}});
+  if (numBucketConversion_ > 0) {
+    res.insert({"numBucketConversion", RuntimeCounter(numBucketConversion_)});
+  }
   return res;
 }
 
 void HiveDataSource::setFromDataSource(
     std::unique_ptr<DataSource> sourceUnique) {
   auto source = dynamic_cast<HiveDataSource*>(sourceUnique.get());
-  VELOX_CHECK(source, "Bad DataSource type");
+  VELOX_CHECK_NOT_NULL(source, "Bad DataSource type");
 
   split_ = std::move(source->split_);
-  if (source->splitReader_ && source->splitReader_->emptySplit()) {
-    return;
-  }
+  runtimeStats_.skippedSplits += source->runtimeStats_.skippedSplits;
+  runtimeStats_.skippedSplitBytes += source->runtimeStats_.skippedSplitBytes;
+  readerOutputType_ = std::move(source->readerOutputType_);
   source->scanSpec_->moveAdaptationFrom(*scanSpec_);
   scanSpec_ = std::move(source->scanSpec_);
   splitReader_ = std::move(source->splitReader_);
+  splitReader_->setConnectorQueryCtx(connectorQueryCtx_);
   // New io will be accounted on the stats of 'source'. Add the existing
   // balance to that.
   source->ioStats_->merge(*ioStats_);
   ioStats_ = std::move(source->ioStats_);
+  numBucketConversion_ += source->numBucketConversion_;
+  partitionFunction_ = std::move(source->partitionFunction_);
 }
 
 int64_t HiveDataSource::estimatedRowSize() {
@@ -732,109 +499,26 @@ int64_t HiveDataSource::estimatedRowSize() {
   return splitReader_->estimatedRowSize();
 }
 
-std::shared_ptr<common::ScanSpec> HiveDataSource::makeScanSpec(
-    const RowTypePtr& rowType,
-    const folly::F14FastMap<std::string, std::vector<const common::Subfield*>>&
-        outputSubfields,
-    const SubfieldFilters& filters,
-    const RowTypePtr& dataColumns,
-    memory::MemoryPool* pool) {
-  auto spec = std::make_shared<common::ScanSpec>("root");
-  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
-      filterSubfields;
-  std::vector<SubfieldSpec> subfieldSpecs;
-  for (auto& [subfield, _] : filters) {
-    if (auto name = subfield.toString(); name != kPath && name != kBucket) {
-      filterSubfields[getColumnName(subfield)].push_back(&subfield);
-    }
-  }
-
-  // Process columns that will be projected out.
-  for (int i = 0; i < rowType->size(); ++i) {
-    auto& name = rowType->nameOf(i);
-    auto& type = rowType->childAt(i);
-    auto it = outputSubfields.find(name);
-    if (it == outputSubfields.end()) {
-      spec->addFieldRecursively(name, *type, i);
-      filterSubfields.erase(name);
-      continue;
-    }
-    for (auto* subfield : it->second) {
-      subfieldSpecs.push_back({subfield, false});
-    }
-    it = filterSubfields.find(name);
-    if (it != filterSubfields.end()) {
-      for (auto* subfield : it->second) {
-        subfieldSpecs.push_back({subfield, true});
-      }
-      filterSubfields.erase(it);
-    }
-    addSubfields(*type, subfieldSpecs, 1, pool, *spec->addField(name, i));
-    subfieldSpecs.clear();
-  }
-
-  // Now process the columns that will not be projected out.
-  if (!filterSubfields.empty()) {
-    VELOX_CHECK_NOT_NULL(dataColumns);
-    for (auto& [fieldName, subfields] : filterSubfields) {
-      for (auto* subfield : subfields) {
-        subfieldSpecs.push_back({subfield, true});
-      }
-      auto& type = dataColumns->findChild(fieldName);
-      auto* fieldSpec = spec->getOrCreateChild(common::Subfield(fieldName));
-      addSubfields(*type, subfieldSpecs, 1, pool, *fieldSpec);
-      subfieldSpecs.clear();
-    }
-  }
-
-  for (auto& pair : filters) {
-    // SelectiveColumnReader doesn't support constant columns with filters,
-    // hence, we can't have a filter for a $path or $bucket column.
-    //
-    // Unfortunately, Presto happens to specify a filter for $path or
-    // $bucket column. This filter is redundant and needs to be removed.
-    // TODO Remove this check when Presto is fixed to not specify a filter
-    // on $path and $bucket column.
-    if (auto name = pair.first.toString(); name == kPath || name == kBucket) {
-      continue;
-    }
-    auto fieldSpec = spec->getOrCreateChild(pair.first);
-    fieldSpec->addFilter(*pair.second);
-  }
-
-  return spec;
-}
-
-std::unique_ptr<dwio::common::BufferedInput>
-HiveDataSource::createBufferedInput(
-    const FileHandle& fileHandle,
-    const dwio::common::ReaderOptions& readerOpts) {
-  if (cache_) {
-    return std::make_unique<dwio::common::CachedBufferedInput>(
-        fileHandle.file,
-        dwio::common::MetricsLog::voidLog(),
-        fileHandle.uuid.id(),
-        cache_,
-        Connector::getTracker(scanId_, readerOpts.loadQuantum()),
-        fileHandle.groupId.id(),
-        ioStats_,
-        executor_,
-        readerOpts);
-  }
-  return std::make_unique<dwio::common::BufferedInput>(
-      fileHandle.file,
-      readerOpts.getMemoryPool(),
-      dwio::common::MetricsLog::voidLog(),
-      ioStats_.get());
-}
-
 vector_size_t HiveDataSource::evaluateRemainingFilter(RowVectorPtr& rowVector) {
-  filterRows_.resize(output_->size());
-
-  expressionEvaluator_->evaluate(
-      remainingFilterExprSet_.get(), filterRows_, *rowVector, filterResult_);
-  return exec::processFilterResults(
-      filterResult_, filterRows_, filterEvalCtx_, pool_);
+  for (auto fieldIndex : multiReferencedFields_) {
+    LazyVector::ensureLoadedRows(
+        rowVector->childAt(fieldIndex),
+        filterRows_,
+        filterLazyDecoded_,
+        filterLazyBaseRows_);
+  }
+  uint64_t filterTimeUs{0};
+  vector_size_t rowsRemaining{0};
+  {
+    MicrosecondTimer timer(&filterTimeUs);
+    expressionEvaluator_->evaluate(
+        remainingFilterExprSet_.get(), filterRows_, *rowVector, filterResult_);
+    rowsRemaining = exec::processFilterResults(
+        filterResult_, filterRows_, filterEvalCtx_, pool_);
+  }
+  totalRemainingFilterTime_.fetch_add(
+      filterTimeUs * 1000, std::memory_order_relaxed);
+  return rowsRemaining;
 }
 
 void HiveDataSource::resetSplit() {
@@ -843,4 +527,31 @@ void HiveDataSource::resetSplit() {
   // Keep readers around to hold adaptation.
 }
 
+HiveDataSource::WaveDelegateHookFunction HiveDataSource::waveDelegateHook_;
+
+std::shared_ptr<wave::WaveDataSource> HiveDataSource::toWaveDataSource() {
+  VELOX_CHECK_NOT_NULL(waveDelegateHook_);
+  if (!waveDataSource_) {
+    waveDataSource_ = waveDelegateHook_(
+        hiveTableHandle_,
+        scanSpec_,
+        readerOutputType_,
+        &partitionKeys_,
+        fileHandleFactory_,
+        executor_,
+        connectorQueryCtx_,
+        hiveConfig_,
+        ioStats_,
+        remainingFilterExprSet_.get(),
+        metadataFilter_);
+  }
+  return waveDataSource_;
+}
+
+//  static
+void HiveDataSource::registerWaveDelegateHook(WaveDelegateHookFunction hook) {
+  waveDelegateHook_ = hook;
+}
+std::shared_ptr<wave::WaveDataSource> toWaveDataSource();
+
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveDataSource.h b/velox/connectors/hive/HiveDataSource.h
index ab8eeb452f254..b7ca9bcb63444 100644
--- a/velox/connectors/hive/HiveDataSource.h
+++ b/velox/connectors/hive/HiveDataSource.h
@@ -15,20 +15,25 @@
  */
 #pragma once
 
+#include "velox/common/base/RandomUtil.h"
 #include "velox/common/io/IoStatistics.h"
 #include "velox/connectors/Connector.h"
 #include "velox/connectors/hive/FileHandle.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HivePartitionFunction.h"
 #include "velox/connectors/hive/SplitReader.h"
 #include "velox/connectors/hive/TableHandle.h"
-#include "velox/dwio/common/BufferedInput.h"
-#include "velox/dwio/common/Reader.h"
-#include "velox/dwio/common/ScanSpec.h"
+#include "velox/dwio/common/Statistics.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/expression/Expr.h"
 
 namespace facebook::velox::connector::hive {
 
+class HiveConfig;
+
+using SubfieldFilters =
+    std::unordered_map<common::Subfield, std::unique_ptr<common::Filter>>;
+
 class HiveDataSource : public DataSource {
  public:
   HiveDataSource(
@@ -38,11 +43,9 @@ class HiveDataSource : public DataSource {
           std::string,
           std::shared_ptr<connector::ColumnHandle>>& columnHandles,
       FileHandleFactory* fileHandleFactory,
-      core::ExpressionEvaluator* expressionEvaluator,
-      cache::AsyncDataCache* cache,
-      const std::string& scanId,
       folly::Executor* executor,
-      const dwio::common::ReaderOptions& options);
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<HiveConfig>& hiveConfig);
 
   void addSplit(std::shared_ptr<ConnectorSplit> split) override;
 
@@ -71,37 +74,43 @@ class HiveDataSource : public DataSource {
 
   int64_t estimatedRowSize() override;
 
-  // Internal API, made public to be accessible in unit tests.  Do not use in
-  // other places.
-  static std::shared_ptr<common::ScanSpec> makeScanSpec(
-      const RowTypePtr& rowType,
-      const folly::F14FastMap<
-          std::string,
-          std::vector<const common::Subfield*>>& outputSubfields,
-      const SubfieldFilters& filters,
-      const RowTypePtr& dataColumns,
-      memory::MemoryPool* pool);
-
-  // Internal API, made public to be accessible in unit tests.  Do not use in
-  // other places.
-  static core::TypedExprPtr extractFiltersFromRemainingFilter(
-      const core::TypedExprPtr& expr,
-      core::ExpressionEvaluator* evaluator,
-      bool negated,
-      SubfieldFilters& filters);
+  std::shared_ptr<wave::WaveDataSource> toWaveDataSource() override;
+
+  using WaveDelegateHookFunction =
+      std::function<std::shared_ptr<wave::WaveDataSource>(
+          const std::shared_ptr<HiveTableHandle>& hiveTableHandle,
+          const std::shared_ptr<common::ScanSpec>& scanSpec,
+          const RowTypePtr& readerOutputType,
+          std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
+              partitionKeys,
+          FileHandleFactory* fileHandleFactory,
+          folly::Executor* executor,
+          const ConnectorQueryCtx* connectorQueryCtx,
+          const std::shared_ptr<HiveConfig>& hiveConfig,
+          const std::shared_ptr<io::IoStatistics>& ioStats,
+          const exec::ExprSet* remainingFilter,
+          std::shared_ptr<common::MetadataFilter> metadataFilter)>;
+
+  static WaveDelegateHookFunction waveDelegateHook_;
+
+  static void registerWaveDelegateHook(WaveDelegateHookFunction hook);
+
+  const ConnectorQueryCtx* testingConnectorQueryCtx() const {
+    return connectorQueryCtx_;
+  }
 
  protected:
   virtual std::unique_ptr<SplitReader> createSplitReader();
 
-  std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
-      const FileHandle&,
-      const dwio::common::ReaderOptions&);
+  FileHandleFactory* const fileHandleFactory_;
+  folly::Executor* const executor_;
+  const ConnectorQueryCtx* const connectorQueryCtx_;
+  const std::shared_ptr<HiveConfig> hiveConfig_;
+  memory::MemoryPool* const pool_;
 
   std::shared_ptr<HiveConnectorSplit> split_;
-  FileHandleFactory* fileHandleFactory_;
-  dwio::common::ReaderOptions readerOpts_;
+  std::shared_ptr<HiveTableHandle> hiveTableHandle_;
   std::shared_ptr<common::ScanSpec> scanSpec_;
-  memory::MemoryPool* pool_;
   VectorPtr output_;
   std::unique_ptr<SplitReader> splitReader_;
 
@@ -115,7 +124,15 @@ class HiveDataSource : public DataSource {
   std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>
       partitionKeys_;
 
+  std::shared_ptr<io::IoStatistics> ioStats_;
+  std::shared_ptr<HiveColumnHandle> rowIndexColumn_;
+
  private:
+  std::unique_ptr<HivePartitionFunction> setupBucketConversion();
+  vector_size_t applyBucketConversion(
+      const RowVectorPtr& rowVector,
+      BufferPtr& indices);
+
   // Evaluates remainingFilter_ on the specified vector. Returns number of rows
   // passed. Populates filterEvalCtx_.selectedIndices and selectedBits if only
   // some rows passed the filter. If none or all rows passed
@@ -126,9 +143,6 @@ class HiveDataSource : public DataSource {
   // hold adaptation.
   void resetSplit();
 
-  void parseSerdeParameters(
-      const std::unordered_map<std::string, std::string>& serdeParameters);
-
   const RowVectorPtr& getEmptyOutput() {
     if (!emptyOutput_) {
       emptyOutput_ = RowVector::createEmpty(outputType_, pool_);
@@ -136,26 +150,42 @@ class HiveDataSource : public DataSource {
     return emptyOutput_;
   }
 
-  std::shared_ptr<HiveTableHandle> hiveTableHandle_;
-
-  // The row type for the data source output, not including filter only columns
+  // The row type for the data source output, not including filter-only columns
   const RowTypePtr outputType_;
-  std::shared_ptr<io::IoStatistics> ioStats_;
+  core::ExpressionEvaluator* const expressionEvaluator_;
+
+  // Column handles for the Split info columns keyed on their column names.
+  std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>
+      infoColumns_;
+  folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
+      subfields_;
+  SubfieldFilters filters_;
   std::shared_ptr<common::MetadataFilter> metadataFilter_;
   std::unique_ptr<exec::ExprSet> remainingFilterExprSet_;
   RowVectorPtr emptyOutput_;
   dwio::common::RuntimeStatistics runtimeStats_;
-  core::ExpressionEvaluator* expressionEvaluator_;
+  std::atomic<uint64_t> totalRemainingFilterTime_{0};
   uint64_t completedRows_ = 0;
 
+  // Field indices referenced in both remaining filter and output type. These
+  // columns need to be materialized eagerly to avoid missing values in output.
+  std::vector<column_index_t> multiReferencedFields_;
+
+  std::shared_ptr<random::RandomSkipTracker> randomSkip_;
+
+  int64_t numBucketConversion_ = 0;
+  std::unique_ptr<HivePartitionFunction> partitionFunction_;
+  std::vector<uint32_t> partitions_;
+
   // Reusable memory for remaining filter evaluation.
   VectorPtr filterResult_;
   SelectivityVector filterRows_;
+  DecodedVector filterLazyDecoded_;
+  SelectivityVector filterLazyBaseRows_;
   exec::FilterEvalCtx filterEvalCtx_;
 
-  cache::AsyncDataCache* const cache_{nullptr};
-  const std::string& scanId_;
-  folly::Executor* executor_;
+  // Remembers the WaveDataSource. Successive calls to toWaveDataSource() will
+  // return the same.
+  std::shared_ptr<wave::WaveDataSource> waveDataSource_;
 };
-
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HivePartitionFunction.cpp b/velox/connectors/hive/HivePartitionFunction.cpp
index 117b4992b731b..8f583164c1a6d 100644
--- a/velox/connectors/hive/HivePartitionFunction.cpp
+++ b/velox/connectors/hive/HivePartitionFunction.cpp
@@ -46,63 +46,68 @@ int32_t hashTimestamp(const Timestamp& ts) {
 }
 
 template <TypeKind kind>
-inline uint32_t hashOne(
-    const typename TypeTraits<kind>::NativeType& /* value */) {
+inline uint32_t hashOne(typename TypeTraits<kind>::NativeType /* value */) {
   VELOX_UNSUPPORTED(
       "Hive partitioning function doesn't support {} type",
       TypeTraits<kind>::name);
+  return 0; // Make compiler happy.
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::BOOLEAN>(const bool& value) {
+inline uint32_t hashOne<TypeKind::BOOLEAN>(bool value) {
   return value ? 1 : 0;
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::TINYINT>(const int8_t& value) {
+inline uint32_t hashOne<TypeKind::TINYINT>(int8_t value) {
   return static_cast<uint32_t>(value);
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::SMALLINT>(const int16_t& value) {
+inline uint32_t hashOne<TypeKind::SMALLINT>(int16_t value) {
   return static_cast<uint32_t>(value);
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::INTEGER>(const int32_t& value) {
+inline uint32_t hashOne<TypeKind::INTEGER>(int32_t value) {
   return static_cast<uint32_t>(value);
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::REAL>(const float& value) {
+inline uint32_t hashOne<TypeKind::REAL>(float value) {
   return static_cast<uint32_t>(*reinterpret_cast<const int32_t*>(&value));
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::BIGINT>(const int64_t& value) {
+inline uint32_t hashOne<TypeKind::BIGINT>(int64_t value) {
   return hashInt64(value);
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::DOUBLE>(const double& value) {
+inline uint32_t hashOne<TypeKind::DOUBLE>(double value) {
   return hashInt64(*reinterpret_cast<const int64_t*>(&value));
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::VARCHAR>(const StringView& value) {
+inline uint32_t hashOne<TypeKind::VARCHAR>(StringView value) {
   return hashBytes(value, 0);
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::VARBINARY>(const StringView& value) {
+inline uint32_t hashOne<TypeKind::VARBINARY>(StringView value) {
   return hashBytes(value, 0);
 }
 
 template <>
-inline uint32_t hashOne<TypeKind::TIMESTAMP>(const Timestamp& value) {
+inline uint32_t hashOne<TypeKind::TIMESTAMP>(Timestamp value) {
   return hashTimestamp(value);
 }
 
+template <>
+inline uint32_t hashOne<TypeKind::UNKNOWN>(UnknownValue /*value*/) {
+  VELOX_FAIL("Unknown values cannot be non-NULL");
+}
+
 template <TypeKind kind>
 void hashPrimitive(
     const DecodedVector& values,
@@ -245,6 +250,26 @@ void HivePartitionFunction::hashTyped<TypeKind::TIMESTAMP>(
   hashPrimitive<TypeKind::TIMESTAMP>(values, rows, mix, hashes);
 }
 
+template <>
+void HivePartitionFunction::hashTyped<TypeKind::UNKNOWN>(
+    const DecodedVector& values,
+    const SelectivityVector& rows,
+    bool mix,
+    std::vector<uint32_t>& hashes,
+    size_t /* poolIndex */) {
+  hashPrimitive<TypeKind::UNKNOWN>(values, rows, mix, hashes);
+}
+
+template <>
+void HivePartitionFunction::hashTyped<TypeKind::OPAQUE>(
+    const DecodedVector& /*values*/,
+    const SelectivityVector& /*rows*/,
+    bool /*mix*/,
+    std::vector<uint32_t>& /*hashes*/,
+    size_t /* poolIndex */) {
+  VELOX_UNSUPPORTED("Hive partitioning function doesn't support OPAQUE type");
+}
+
 template <>
 void HivePartitionFunction::hashTyped<TypeKind::ARRAY>(
     const DecodedVector& values,
@@ -426,7 +451,7 @@ void HivePartitionFunction::hash(
   // gets implemented, this function will need to change
   // significantly.
 
-  VELOX_DYNAMIC_TYPE_DISPATCH(
+  VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
       hashTyped, typeKind, values, rows, mix, hashes, poolIndex);
 }
 
diff --git a/velox/connectors/hive/HivePartitionUtil.cpp b/velox/connectors/hive/HivePartitionUtil.cpp
index 3adf9d38a82b8..cbc53c79b5eaf 100644
--- a/velox/connectors/hive/HivePartitionUtil.cpp
+++ b/velox/connectors/hive/HivePartitionUtil.cpp
@@ -51,13 +51,23 @@ template <TypeKind Kind>
 std::pair<std::string, std::string> makePartitionKeyValueString(
     const BaseVector* partitionVector,
     vector_size_t row,
-    const std::string& name) {
+    const std::string& name,
+    bool isDate) {
   using T = typename TypeTraits<Kind>::NativeType;
+  if (partitionVector->as<SimpleVector<T>>()->isNullAt(row)) {
+    return std::make_pair(name, "");
+  }
+  if (isDate) {
+    return std::make_pair(
+        name,
+        DATE()->toString(
+            partitionVector->as<SimpleVector<int32_t>>()->valueAt(row)));
+  }
   return std::make_pair(
       name,
       makePartitionValueString(
           partitionVector->as<SimpleVector<T>>()->valueAt(row)));
-};
+}
 
 } // namespace
 
@@ -66,21 +76,13 @@ std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
     vector_size_t row) {
   std::vector<std::pair<std::string, std::string>> partitionKeyValues;
   for (auto i = 0; i < partitionsVector->childrenSize(); i++) {
-    if (partitionsVector->childAt(i)->type()->isDate()) {
-      auto partitionVector = partitionsVector->childAt(i)->loadedVector();
-      auto partitionName = asRowType(partitionsVector->type())->nameOf(i);
-      partitionKeyValues.push_back(
-          {partitionName,
-           DATE()->toString(
-               partitionVector->as<SimpleVector<int32_t>>()->valueAt(row))});
-    } else {
-      partitionKeyValues.push_back(PARTITION_TYPE_DISPATCH(
-          makePartitionKeyValueString,
-          partitionsVector->childAt(i)->typeKind(),
-          partitionsVector->childAt(i)->loadedVector(),
-          row,
-          asRowType(partitionsVector->type())->nameOf(i)));
-    }
+    partitionKeyValues.push_back(PARTITION_TYPE_DISPATCH(
+        makePartitionKeyValueString,
+        partitionsVector->childAt(i)->typeKind(),
+        partitionsVector->childAt(i)->loadedVector(),
+        row,
+        asRowType(partitionsVector->type())->nameOf(i),
+        partitionsVector->childAt(i)->type()->isDate()));
   }
   return partitionKeyValues;
 }
diff --git a/velox/connectors/hive/PartitionIdGenerator.cpp b/velox/connectors/hive/PartitionIdGenerator.cpp
index e795a08962b18..deec8dc5b005c 100644
--- a/velox/connectors/hive/PartitionIdGenerator.cpp
+++ b/velox/connectors/hive/PartitionIdGenerator.cpp
@@ -27,9 +27,11 @@ PartitionIdGenerator::PartitionIdGenerator(
     const RowTypePtr& inputType,
     std::vector<column_index_t> partitionChannels,
     uint32_t maxPartitions,
-    memory::MemoryPool* pool)
+    memory::MemoryPool* pool,
+    bool partitionPathAsLowerCase)
     : partitionChannels_(std::move(partitionChannels)),
-      maxPartitions_(maxPartitions) {
+      maxPartitions_(maxPartitions),
+      partitionPathAsLowerCase_(partitionPathAsLowerCase) {
   VELOX_USER_CHECK(
       !partitionChannels_.empty(), "There must be at least one partition key.");
   for (auto channel : partitionChannels_) {
@@ -64,8 +66,6 @@ void PartitionIdGenerator::run(
   const auto numRows = input->size();
   result.resize(numRows);
 
-  // TODO Check that there are no nulls in the partition keys.
-
   // Compute value IDs using VectorHashers and store these in 'result'.
   computeValueIds(input, result);
 
@@ -98,7 +98,8 @@ void PartitionIdGenerator::run(
 
 std::string PartitionIdGenerator::partitionName(uint64_t partitionId) const {
   return FileUtils::makePartName(
-      extractPartitionKeyValues(partitionValues_, partitionId));
+      extractPartitionKeyValues(partitionValues_, partitionId),
+      partitionPathAsLowerCase_);
 }
 
 void PartitionIdGenerator::computeValueIds(
@@ -109,6 +110,9 @@ void PartitionIdGenerator::computeValueIds(
 
   bool rehash = false;
   for (auto& hasher : hashers_) {
+    // NOTE: for boolean column type, computeValueIds() always returns true and
+    // this might cause problem in case of multiple boolean partition columns as
+    // we might not set the multiplier properly.
     auto partitionVector = input->childAt(hasher->channel())->loadedVector();
     hasher->decode(*partitionVector, allRows_);
     if (!hasher->computeValueIds(allRows_, valueIds)) {
@@ -116,12 +120,13 @@ void PartitionIdGenerator::computeValueIds(
     }
   }
 
-  if (!rehash) {
+  if (!rehash && hasMultiplierSet_) {
     return;
   }
 
   uint64_t multiplier = 1;
   for (auto& hasher : hashers_) {
+    hasMultiplierSet_ = true;
     multiplier = hasher->typeKind() == TypeKind::BOOLEAN
         ? hasher->enableValueRange(multiplier, 50)
         : hasher->enableValueIds(multiplier, 50);
diff --git a/velox/connectors/hive/PartitionIdGenerator.h b/velox/connectors/hive/PartitionIdGenerator.h
index 1a4844398b0e4..01b638c0f3ad4 100644
--- a/velox/connectors/hive/PartitionIdGenerator.h
+++ b/velox/connectors/hive/PartitionIdGenerator.h
@@ -20,8 +20,7 @@
 
 namespace facebook::velox::connector::hive {
 /// Generate sequential integer IDs for distinct partition values, which could
-/// be used as vector index. Only single partition key is supported at the
-/// moment.
+/// be used as vector index.
 class PartitionIdGenerator {
  public:
   /// @param inputType RowType of the input.
@@ -30,11 +29,14 @@ class PartitionIdGenerator {
   /// @param maxPartitions The max number of distinct partitions.
   /// @param pool Memory pool. Used to allocate memory for storing unique
   /// partition key values.
+  /// @param partitionPathAsLowerCase Used to control whether the partition path
+  /// need to convert to lower case.
   PartitionIdGenerator(
       const RowTypePtr& inputType,
       std::vector<column_index_t> partitionChannels,
       uint32_t maxPartitions,
-      memory::MemoryPool* pool);
+      memory::MemoryPool* pool,
+      bool partitionPathAsLowerCase);
 
   /// Generate sequential partition IDs for input vector.
   /// @param input Input RowVector.
@@ -77,7 +79,10 @@ class PartitionIdGenerator {
 
   const uint32_t maxPartitions_;
 
+  const bool partitionPathAsLowerCase_;
+
   std::vector<std::unique_ptr<exec::VectorHasher>> hashers_;
+  bool hasMultiplierSet_ = false;
 
   // A mapping from value ID produced by VectorHashers to a partition ID.
   std::unordered_map<uint64_t, uint64_t> partitionIds_;
diff --git a/velox/connectors/hive/SplitReader.cpp b/velox/connectors/hive/SplitReader.cpp
index a42b64e37141b..dcdb9441fc3d5 100644
--- a/velox/connectors/hive/SplitReader.cpp
+++ b/velox/connectors/hive/SplitReader.cpp
@@ -16,234 +16,153 @@
 
 #include "velox/connectors/hive/SplitReader.h"
 
+#include "velox/common/caching/CacheTTLController.h"
+#include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/connectors/hive/TableHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergSplitReader.h"
+#include "velox/dwio/common/CachedBufferedInput.h"
 #include "velox/dwio/common/ReaderFactory.h"
+#include "velox/type/TimestampConversion.h"
 
 namespace facebook::velox::connector::hive {
-
 namespace {
 
-bool applyPartitionFilter(
-    TypeKind kind,
-    const std::string& partitionValue,
-    common::Filter* filter) {
-  switch (kind) {
-    case TypeKind::BIGINT:
-    case TypeKind::INTEGER:
-    case TypeKind::SMALLINT:
-    case TypeKind::TINYINT: {
-      return applyFilter(*filter, folly::to<int64_t>(partitionValue));
-    }
-    case TypeKind::REAL:
-    case TypeKind::DOUBLE: {
-      return applyFilter(*filter, folly::to<double>(partitionValue));
-    }
-    case TypeKind::BOOLEAN: {
-      return applyFilter(*filter, folly::to<bool>(partitionValue));
-    }
-    case TypeKind::VARCHAR: {
-      return applyFilter(*filter, partitionValue);
-    }
-    default:
-      VELOX_FAIL("Bad type {} for partition value: {}", kind, partitionValue);
-      break;
+template <TypeKind kind>
+VectorPtr newConstantFromString(
+    const TypePtr& type,
+    const std::optional<std::string>& value,
+    vector_size_t size,
+    velox::memory::MemoryPool* pool) {
+  using T = typename TypeTraits<kind>::NativeType;
+  if (!value.has_value()) {
+    return std::make_shared<ConstantVector<T>>(pool, size, true, type, T());
   }
-}
 
-bool testFilters(
-    common::ScanSpec* scanSpec,
-    dwio::common::Reader* reader,
-    const std::string& filePath,
-    const std::unordered_map<std::string, std::optional<std::string>>&
-        partitionKey,
-    std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
-        partitionKeysHandle) {
-  auto totalRows = reader->numberOfRows();
-  const auto& fileTypeWithId = reader->typeWithId();
-  const auto& rowType = reader->rowType();
-  for (const auto& child : scanSpec->children()) {
-    if (child->filter()) {
-      const auto& name = child->fieldName();
-      if (!rowType->containsChild(name)) {
-        // If missing column is partition key.
-        auto iter = partitionKey.find(name);
-        if (iter != partitionKey.end() && iter->second.has_value()) {
-          return applyPartitionFilter(
-              partitionKeysHandle[name]->dataType()->kind(),
-              iter->second.value(),
-              child->filter());
-        }
-        // Column is missing. Most likely due to schema evolution.
-        if (child->filter()->isDeterministic() &&
-            !child->filter()->testNull()) {
-          return false;
-        }
-      } else {
-        const auto& typeWithId = fileTypeWithId->childByName(name);
-        auto columnStats = reader->columnStatistics(typeWithId->id());
-        if (columnStats != nullptr &&
-            !testFilter(
-                child->filter(),
-                columnStats.get(),
-                totalRows.value(),
-                typeWithId->type())) {
-          VLOG(1) << "Skipping " << filePath
-                  << " based on stats and filter for column "
-                  << child->fieldName();
-          return false;
-        }
-      }
-    }
+  if (type->isDate()) {
+    auto days = DATE()->toDays((folly::StringPiece)value.value());
+    return std::make_shared<ConstantVector<int32_t>>(
+        pool, size, false, type, std::move(days));
   }
 
-  return true;
-}
-
-template <TypeKind ToKind>
-velox::variant convertFromString(const std::optional<std::string>& value) {
-  if (value.has_value()) {
-    if constexpr (ToKind == TypeKind::VARCHAR) {
-      return velox::variant(value.value());
-    }
-    if constexpr (ToKind == TypeKind::VARBINARY) {
-      return velox::variant::binary((value.value()));
+  if constexpr (std::is_same_v<T, StringView>) {
+    return std::make_shared<ConstantVector<StringView>>(
+        pool, size, false, type, StringView(value.value()));
+  } else {
+    auto copy = velox::util::Converter<kind>::tryCast(value.value())
+                    .thenOrThrow(folly::identity, [&](const Status& status) {
+                      VELOX_USER_FAIL("{}", status.message());
+                    });
+    if constexpr (kind == TypeKind::TIMESTAMP) {
+      copy.toGMT(Timestamp::defaultTimezone());
     }
-    auto result = velox::util::Converter<ToKind>::cast(value.value());
-
-    return velox::variant(result);
+    return std::make_shared<ConstantVector<T>>(
+        pool, size, false, type, std::move(copy));
   }
-  return velox::variant(ToKind);
 }
-
 } // namespace
 
 std::unique_ptr<SplitReader> SplitReader::create(
-    std::shared_ptr<velox::connector::hive::HiveConnectorSplit> hiveSplit,
-    const RowTypePtr readerOutputType,
-    std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+    const std::shared_ptr<hive::HiveConnectorSplit>& hiveSplit,
+    const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
         partitionKeys,
-    std::shared_ptr<common::ScanSpec> scanSpec,
-    memory::MemoryPool* pool) {
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const RowTypePtr& readerOutputType,
+    const std::shared_ptr<io::IoStatistics>& ioStats,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* executor,
+    const std::shared_ptr<common::ScanSpec>& scanSpec) {
   //  Create the SplitReader based on hiveSplit->customSplitInfo["table_format"]
-  return std::make_unique<SplitReader>(
-      hiveSplit, readerOutputType, partitionKeys, scanSpec, pool);
+  if (hiveSplit->customSplitInfo.count("table_format") > 0 &&
+      hiveSplit->customSplitInfo["table_format"] == "hive-iceberg") {
+    return std::make_unique<iceberg::IcebergSplitReader>(
+        hiveSplit,
+        hiveTableHandle,
+        partitionKeys,
+        connectorQueryCtx,
+        hiveConfig,
+        readerOutputType,
+        ioStats,
+        fileHandleFactory,
+        executor,
+        scanSpec);
+  } else {
+    return std::unique_ptr<SplitReader>(new SplitReader(
+        hiveSplit,
+        hiveTableHandle,
+        partitionKeys,
+        connectorQueryCtx,
+        hiveConfig,
+        readerOutputType,
+        ioStats,
+        fileHandleFactory,
+        executor,
+        scanSpec));
+  }
 }
 
 SplitReader::SplitReader(
-    std::shared_ptr<velox::connector::hive::HiveConnectorSplit> hiveSplit,
-    const RowTypePtr readerOutputType,
-    std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+    const std::shared_ptr<const hive::HiveConnectorSplit>& hiveSplit,
+    const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
         partitionKeys,
-    std::shared_ptr<common::ScanSpec> scanSpec,
-    memory::MemoryPool* pool)
-    : hiveSplit_(std::move(hiveSplit)),
-      readerOutputType_(readerOutputType),
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const RowTypePtr& readerOutputType,
+    const std::shared_ptr<io::IoStatistics>& ioStats,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* executor,
+    const std::shared_ptr<common::ScanSpec>& scanSpec)
+    : hiveSplit_(hiveSplit),
+      hiveTableHandle_(hiveTableHandle),
       partitionKeys_(partitionKeys),
-      scanSpec_(std::move(scanSpec)),
-      pool_(pool) {}
+      connectorQueryCtx_(connectorQueryCtx),
+      hiveConfig_(hiveConfig),
+      readerOutputType_(readerOutputType),
+      ioStats_(ioStats),
+      fileHandleFactory_(fileHandleFactory),
+      executor_(executor),
+      pool_(connectorQueryCtx->memoryPool()),
+      scanSpec_(scanSpec),
+      baseReaderOpts_(connectorQueryCtx->memoryPool()),
+      emptySplit_(false) {}
+
+void SplitReader::configureReaderOptions(
+    std::shared_ptr<velox::random::RandomSkipTracker> randomSkip) {
+  hive::configureReaderOptions(
+      baseReaderOpts_,
+      hiveConfig_,
+      connectorQueryCtx_,
+      hiveTableHandle_,
+      hiveSplit_);
+  baseReaderOpts_.setRandomSkip(std::move(randomSkip));
+  baseReaderOpts_.setScanSpec(scanSpec_);
+}
 
 void SplitReader::prepareSplit(
-    const std::shared_ptr<HiveTableHandle>& hiveTableHandle,
-    const dwio::common::ReaderOptions& readerOptions,
-    std::unique_ptr<dwio::common::BufferedInput> baseFileInput,
     std::shared_ptr<common::MetadataFilter> metadataFilter,
-    dwio::common::RuntimeStatistics& runtimeStats) {
-  baseReader_ = dwio::common::getReaderFactory(readerOptions.getFileFormat())
-                    ->createReader(std::move(baseFileInput), readerOptions);
-
-  // Note that this doesn't apply to Hudi tables.
-  emptySplit_ = false;
-  if (baseReader_->numberOfRows() == 0) {
-    emptySplit_ = true;
-    return;
-  }
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const std::shared_ptr<HiveColumnHandle>& rowIndexColumn) {
+  createReader(std::move(metadataFilter), rowIndexColumn);
 
-  // Check filters and see if the whole split can be skipped. Note that this
-  // doesn't apply to Hudi tables.
-  if (!testFilters(
-          scanSpec_.get(),
-          baseReader_.get(),
-          hiveSplit_->filePath,
-          hiveSplit_->partitionKeys,
-          partitionKeys_)) {
-    emptySplit_ = true;
-    ++runtimeStats.skippedSplits;
-    runtimeStats.skippedSplitBytes += hiveSplit_->length;
+  if (checkIfSplitIsEmpty(runtimeStats)) {
+    VELOX_CHECK(emptySplit_);
     return;
   }
 
-  auto& fileType = baseReader_->rowType();
-  auto columnTypes = adaptColumns(fileType, readerOptions.getFileSchema());
-
-  auto skipRowsIt = hiveTableHandle->tableParameters().find(
-      dwio::common::TableParameter::kSkipHeaderLineCount);
-  if (skipRowsIt != hiveTableHandle->tableParameters().end()) {
-    rowReaderOpts_.setSkipRows(folly::to<uint64_t>(skipRowsIt->second));
-  }
-
-  rowReaderOpts_.setScanSpec(scanSpec_);
-  rowReaderOpts_.setMetadataFilter(metadataFilter);
-  configureRowReaderOptions(
-      rowReaderOpts_,
-      ROW(std::vector<std::string>(fileType->names()), std::move(columnTypes)));
-  // NOTE: we firstly reset the finished 'baseRowReader_' of previous split
-  // before setting up for the next one to avoid doubling the peak memory usage.
-  baseRowReader_.reset();
-  baseRowReader_ = baseReader_->createRowReader(rowReaderOpts_);
+  createRowReader();
 }
 
-std::vector<TypePtr> SplitReader::adaptColumns(
-    const RowTypePtr& fileType,
-    const std::shared_ptr<const velox::RowType>& tableSchema) {
-  // Keep track of schema types for columns in file, used by ColumnSelector.
-  std::vector<TypePtr> columnTypes = fileType->children();
-
-  auto& childrenSpecs = scanSpec_->children();
-  for (size_t i = 0; i < childrenSpecs.size(); ++i) {
-    auto* childSpec = childrenSpecs[i].get();
-    const std::string& fieldName = childSpec->fieldName();
-
-    auto iter = hiveSplit_->partitionKeys.find(fieldName);
-    if (iter != hiveSplit_->partitionKeys.end()) {
-      setPartitionValue(childSpec, fieldName, iter->second);
-    } else if (fieldName == kPath) {
-      setConstantValue(
-          childSpec, VARCHAR(), velox::variant(hiveSplit_->filePath));
-    } else if (fieldName == kBucket) {
-      if (hiveSplit_->tableBucketNumber.has_value()) {
-        setConstantValue(
-            childSpec,
-            INTEGER(),
-            velox::variant(hiveSplit_->tableBucketNumber.value()));
-      }
-    } else {
-      auto fileTypeIdx = fileType->getChildIdxIfExists(fieldName);
-      if (!fileTypeIdx.has_value()) {
-        // Column is missing. Most likely due to schema evolution.
-        VELOX_CHECK(tableSchema);
-        setNullConstantValue(childSpec, tableSchema->findChild(fieldName));
-      } else {
-        // Column no longer missing, reset constant value set on the spec.
-        childSpec->setConstantValue(nullptr);
-        auto outputTypeIdx = readerOutputType_->getChildIdxIfExists(fieldName);
-        if (outputTypeIdx.has_value()) {
-          // We know the fieldName exists in the file, make the type at that
-          // position match what we expect in the output.
-          columnTypes[fileTypeIdx.value()] =
-              readerOutputType_->childAt(*outputTypeIdx);
-        }
-      }
-    }
+uint64_t SplitReader::next(uint64_t size, VectorPtr& output) {
+  if (!baseReaderOpts_.randomSkip()) {
+    return baseRowReader_->next(size, output);
   }
-
-  scanSpec_->resetCachedValues(false);
-
-  return columnTypes;
-}
-
-uint64_t SplitReader::next(int64_t size, VectorPtr& output) {
-  return baseRowReader_->next(size, output);
+  dwio::common::Mutation mutation;
+  mutation.randomSkip = baseReaderOpts_.randomSkip().get();
+  return baseRowReader_->next(size, output, &mutation);
 }
 
 void SplitReader::resetFilterCaches() {
@@ -265,11 +184,8 @@ int64_t SplitReader::estimatedRowSize() const {
     return DataSource::kUnknownRowSize;
   }
 
-  auto size = baseRowReader_->estimatedRowSize();
-  if (size.has_value()) {
-    return size.value();
-  }
-  return DataSource::kUnknownRowSize;
+  const auto size = baseRowReader_->estimatedRowSize();
+  return size.value_or(DataSource::kUnknownRowSize);
 }
 
 void SplitReader::updateRuntimeStats(
@@ -283,61 +199,17 @@ bool SplitReader::allPrefetchIssued() const {
   return baseRowReader_ && baseRowReader_->allPrefetchIssued();
 }
 
-void SplitReader::setConstantValue(
-    common::ScanSpec* spec,
-    const TypePtr& type,
-    const velox::variant& value) const {
-  spec->setConstantValue(BaseVector::createConstant(type, value, 1, pool_));
-}
-
-void SplitReader::setNullConstantValue(
-    common::ScanSpec* spec,
-    const TypePtr& type) const {
-  spec->setConstantValue(BaseVector::createNullConstant(type, 1, pool_));
-}
-
-void SplitReader::setPartitionValue(
-    common::ScanSpec* spec,
-    const std::string& partitionKey,
-    const std::optional<std::string>& value) const {
-  auto it = partitionKeys_.find(partitionKey);
-  VELOX_CHECK(
-      it != partitionKeys_.end(),
-      "ColumnHandle is missing for partition key {}",
-      partitionKey);
-  auto constValue = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-      convertFromString, it->second->dataType()->kind(), value);
-  setConstantValue(spec, it->second->dataType(), constValue);
-}
-
-void SplitReader::configureRowReaderOptions(
-    dwio::common::RowReaderOptions& options,
-    const RowTypePtr& rowType) {
-  std::vector<std::string> columnNames;
-  for (auto& spec : scanSpec_->children()) {
-    if (!spec->isConstant()) {
-      columnNames.push_back(spec->fieldName());
-    }
-  }
-  std::shared_ptr<dwio::common::ColumnSelector> cs;
-  if (columnNames.empty()) {
-    static const RowTypePtr kEmpty{ROW({}, {})};
-    cs = std::make_shared<dwio::common::ColumnSelector>(kEmpty);
-  } else {
-    cs = std::make_shared<dwio::common::ColumnSelector>(rowType, columnNames);
-  }
-  options.select(cs).range(hiveSplit_->start, hiveSplit_->length);
+void SplitReader::setConnectorQueryCtx(
+    const ConnectorQueryCtx* connectorQueryCtx) {
+  connectorQueryCtx_ = connectorQueryCtx;
 }
 
 std::string SplitReader::toString() const {
   std::string partitionKeys;
   std::for_each(
-      partitionKeys_.begin(),
-      partitionKeys_.end(),
-      [&](std::pair<
-          const std::string,
-          std::shared_ptr<facebook::velox::connector::hive::HiveColumnHandle>>
-              column) { partitionKeys += " " + column.second->toString(); });
+      partitionKeys_->begin(), partitionKeys_->end(), [&](const auto& column) {
+        partitionKeys += " " + column.second->toString();
+      });
   return fmt::format(
       "SplitReader: hiveSplit_{} scanSpec_{} readerOutputType_{} partitionKeys_{} reader{} rowReader{}",
       hiveSplit_->toString(),
@@ -348,4 +220,205 @@ std::string SplitReader::toString() const {
       static_cast<const void*>(baseRowReader_.get()));
 }
 
+void SplitReader::createReader(
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    const std::shared_ptr<HiveColumnHandle>& rowIndexColumn) {
+  VELOX_CHECK_NE(
+      baseReaderOpts_.fileFormat(), dwio::common::FileFormat::UNKNOWN);
+
+  FileHandleCachedPtr fileHandleCachePtr;
+  try {
+    fileHandleCachePtr = fileHandleFactory_->generate(
+        hiveSplit_->filePath,
+        hiveSplit_->properties.has_value() ? &*hiveSplit_->properties
+                                           : nullptr);
+    VELOX_CHECK_NOT_NULL(fileHandleCachePtr.get());
+  } catch (const VeloxRuntimeError& e) {
+    if (e.errorCode() == error_code::kFileNotFound &&
+        hiveConfig_->ignoreMissingFiles(
+            connectorQueryCtx_->sessionProperties())) {
+      emptySplit_ = true;
+      return;
+    }
+    throw;
+  }
+
+  // Here we keep adding new entries to CacheTTLController when new fileHandles
+  // are generated, if CacheTTLController was created. Creator of
+  // CacheTTLController needs to make sure a size control strategy was available
+  // such as removing aged out entries.
+  if (auto* cacheTTLController = cache::CacheTTLController::getInstance()) {
+    cacheTTLController->addOpenFileInfo(fileHandleCachePtr->uuid.id());
+  }
+  auto baseFileInput = createBufferedInput(
+      *fileHandleCachePtr,
+      baseReaderOpts_,
+      connectorQueryCtx_,
+      ioStats_,
+      executor_);
+
+  baseReader_ = dwio::common::getReaderFactory(baseReaderOpts_.fileFormat())
+                    ->createReader(std::move(baseFileInput), baseReaderOpts_);
+
+  auto& fileType = baseReader_->rowType();
+  auto columnTypes = adaptColumns(fileType, baseReaderOpts_.fileSchema());
+  auto columnNames = fileType->names();
+  if (rowIndexColumn != nullptr) {
+    bool isExplicit = scanSpec_->childByName(rowIndexColumn->name()) != nullptr;
+    setRowIndexColumn(rowIndexColumn, isExplicit);
+  }
+  configureRowReaderOptions(
+      hiveTableHandle_->tableParameters(),
+      scanSpec_,
+      std::move(metadataFilter),
+      ROW(std::move(columnNames), std::move(columnTypes)),
+      hiveSplit_,
+      hiveConfig_,
+      connectorQueryCtx_->sessionProperties(),
+      baseRowReaderOpts_);
+}
+
+bool SplitReader::checkIfSplitIsEmpty(
+    dwio::common::RuntimeStatistics& runtimeStats) {
+  // emptySplit_ may already be set if the data file is not found. In this case
+  // we don't need to test further.
+  if (emptySplit_) {
+    return true;
+  }
+
+  if (!baseReader_ || baseReader_->numberOfRows() == 0) {
+    emptySplit_ = true;
+  } else {
+    // Check filters and see if the whole split can be skipped. Note that this
+    // doesn't apply to Hudi tables.
+    if (!testFilters(
+            scanSpec_.get(),
+            baseReader_.get(),
+            hiveSplit_->filePath,
+            hiveSplit_->partitionKeys,
+            *partitionKeys_)) {
+      ++runtimeStats.skippedSplits;
+      runtimeStats.skippedSplitBytes += hiveSplit_->length;
+      emptySplit_ = true;
+    }
+  }
+
+  return emptySplit_;
+}
+
+void SplitReader::createRowReader() {
+  VELOX_CHECK_NULL(baseRowReader_);
+  baseRowReader_ = baseReader_->createRowReader(baseRowReaderOpts_);
+}
+
+void SplitReader::setRowIndexColumn(
+    const std::shared_ptr<HiveColumnHandle>& rowIndexColumn,
+    bool isExplicit) {
+  dwio::common::RowNumberColumnInfo rowNumberColumnInfo;
+  rowNumberColumnInfo.insertPosition =
+      readerOutputType_->getChildIdx(rowIndexColumn->name());
+  rowNumberColumnInfo.name = rowIndexColumn->name();
+  rowNumberColumnInfo.isExplicit = isExplicit;
+  baseRowReaderOpts_.setRowNumberColumnInfo(std::move(rowNumberColumnInfo));
+}
+
+std::vector<TypePtr> SplitReader::adaptColumns(
+    const RowTypePtr& fileType,
+    const std::shared_ptr<const velox::RowType>& tableSchema) {
+  // Keep track of schema types for columns in file, used by ColumnSelector.
+  std::vector<TypePtr> columnTypes = fileType->children();
+
+  auto& childrenSpecs = scanSpec_->children();
+  for (size_t i = 0; i < childrenSpecs.size(); ++i) {
+    auto* childSpec = childrenSpecs[i].get();
+    const std::string& fieldName = childSpec->fieldName();
+
+    if (auto it = hiveSplit_->partitionKeys.find(fieldName);
+        it != hiveSplit_->partitionKeys.end()) {
+      setPartitionValue(childSpec, fieldName, it->second);
+    } else if (fieldName == kPath) {
+      auto constantVec = std::make_shared<ConstantVector<StringView>>(
+          connectorQueryCtx_->memoryPool(),
+          1,
+          false,
+          VARCHAR(),
+          StringView(hiveSplit_->filePath));
+      childSpec->setConstantValue(constantVec);
+    } else if (fieldName == kBucket) {
+      if (hiveSplit_->tableBucketNumber.has_value()) {
+        int32_t bucket = hiveSplit_->tableBucketNumber.value();
+        auto constantVec = std::make_shared<ConstantVector<int32_t>>(
+            connectorQueryCtx_->memoryPool(),
+            1,
+            false,
+            INTEGER(),
+            std::move(bucket));
+        childSpec->setConstantValue(constantVec);
+      }
+    } else if (auto iter = hiveSplit_->infoColumns.find(fieldName);
+               iter != hiveSplit_->infoColumns.end()) {
+      auto infoColumnType =
+          readerOutputType_->childAt(readerOutputType_->getChildIdx(fieldName));
+      auto constant = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+          newConstantFromString,
+          infoColumnType->kind(),
+          infoColumnType,
+          iter->second,
+          1,
+          connectorQueryCtx_->memoryPool());
+      childSpec->setConstantValue(constant);
+    } else if (!childSpec->isExplicitRowNumber()) {
+      auto fileTypeIdx = fileType->getChildIdxIfExists(fieldName);
+      if (!fileTypeIdx.has_value()) {
+        // Column is missing. Most likely due to schema evolution.
+        VELOX_CHECK(tableSchema);
+        childSpec->setConstantValue(BaseVector::createNullConstant(
+            tableSchema->findChild(fieldName),
+            1,
+            connectorQueryCtx_->memoryPool()));
+      } else {
+        // Column no longer missing, reset constant value set on the spec.
+        childSpec->setConstantValue(nullptr);
+        auto outputTypeIdx = readerOutputType_->getChildIdxIfExists(fieldName);
+        if (outputTypeIdx.has_value()) {
+          auto& outputType = readerOutputType_->childAt(*outputTypeIdx);
+          auto& columnType = columnTypes[*fileTypeIdx];
+          if (childSpec->isFlatMapAsStruct()) {
+            // Flat map column read as struct.  Leave the schema type as MAP.
+            VELOX_CHECK(outputType->isRow() && columnType->isMap());
+          } else {
+            // We know the fieldName exists in the file, make the type at that
+            // position match what we expect in the output.
+            columnType = outputType;
+          }
+        }
+      }
+    }
+  }
+
+  scanSpec_->resetCachedValues(false);
+
+  return columnTypes;
+}
+
+void SplitReader::setPartitionValue(
+    common::ScanSpec* spec,
+    const std::string& partitionKey,
+    const std::optional<std::string>& value) const {
+  auto it = partitionKeys_->find(partitionKey);
+  VELOX_CHECK(
+      it != partitionKeys_->end(),
+      "ColumnHandle is missing for partition key {}",
+      partitionKey);
+  auto type = it->second->dataType();
+  auto constant = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+      newConstantFromString,
+      type->kind(),
+      type,
+      value,
+      1,
+      connectorQueryCtx_->memoryPool());
+  spec->setConstantValue(constant);
+}
+
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/SplitReader.h b/velox/connectors/hive/SplitReader.h
index 0cac6c4f9d6a3..02509a75abc54 100644
--- a/velox/connectors/hive/SplitReader.h
+++ b/velox/connectors/hive/SplitReader.h
@@ -16,53 +16,72 @@
 
 #pragma once
 
-#include "velox/dwio/common/Reader.h"
-#include "velox/type/Type.h"
+#include "velox/common/base/RandomUtil.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/dwio/common/Options.h"
+
+namespace facebook::velox {
+class BaseVector;
+class variant;
+using VectorPtr = std::shared_ptr<BaseVector>;
+} // namespace facebook::velox
+
+namespace facebook::velox::common {
+class MetadataFilter;
+class ScanSpec;
+} // namespace facebook::velox::common
+
+namespace facebook::velox::connector {
+class ConnectorQueryCtx;
+} // namespace facebook::velox::connector
 
 namespace facebook::velox::dwio::common {
-class BufferedInput;
+class Reader;
+class RowReader;
+struct RuntimeStatistics;
+} // namespace facebook::velox::dwio::common
+
+namespace facebook::velox::memory {
+class MemoryPool;
 }
 
 namespace facebook::velox::connector::hive {
 
-constexpr const char* kPath = "$path";
-constexpr const char* kBucket = "$bucket";
-
 struct HiveConnectorSplit;
 class HiveTableHandle;
 class HiveColumnHandle;
+class HiveConfig;
 
 class SplitReader {
  public:
   static std::unique_ptr<SplitReader> create(
-      std::shared_ptr<velox::connector::hive::HiveConnectorSplit> hiveSplit,
-      const RowTypePtr readerOutputType,
-      std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
+      const std::shared_ptr<hive::HiveConnectorSplit>& hiveSplit,
+      const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+      const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
           partitionKeys,
-      std::shared_ptr<common::ScanSpec> scanSpec,
-      memory::MemoryPool* pool);
-
-  SplitReader(
-      std::shared_ptr<velox::connector::hive::HiveConnectorSplit> hiveSplit,
-      const RowTypePtr readerOutputType,
-      std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
-          partitionKeys,
-      std::shared_ptr<common::ScanSpec> scanSpec,
-      memory::MemoryPool* pool);
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const RowTypePtr& readerOutputType,
+      const std::shared_ptr<io::IoStatistics>& ioStats,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* executor,
+      const std::shared_ptr<common::ScanSpec>& scanSpec);
 
   virtual ~SplitReader() = default;
 
+  void configureReaderOptions(
+      std::shared_ptr<random::RandomSkipTracker> randomSkip);
+
   /// This function is used by different table formats like Iceberg and Hudi to
   /// do additional preparations before reading the split, e.g. Open delete
-  /// files or log files, and add column adapatations for metadata columns
+  /// files or log files, and add column adapatations for metadata columns. It
+  /// would be called only once per incoming split
   virtual void prepareSplit(
-      const std::shared_ptr<HiveTableHandle>& hiveTableHandle,
-      const dwio::common::ReaderOptions& readerOptions,
-      std::unique_ptr<dwio::common::BufferedInput> baseFileInput,
       std::shared_ptr<common::MetadataFilter> metadataFilter,
-      dwio::common::RuntimeStatistics& runtimeStats);
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const std::shared_ptr<HiveColumnHandle>& rowIndexColumn);
 
-  virtual uint64_t next(int64_t size, VectorPtr& output);
+  virtual uint64_t next(uint64_t size, VectorPtr& output);
 
   void resetFilterCaches();
 
@@ -76,44 +95,76 @@ class SplitReader {
 
   bool allPrefetchIssued() const;
 
+  void setConnectorQueryCtx(const ConnectorQueryCtx* connectorQueryCtx);
+
   std::string toString() const;
 
  protected:
-  // Different table formats may have different meatadata columns. This function
-  // will be used to update the scanSpec for these columns.
+  SplitReader(
+      const std::shared_ptr<const hive::HiveConnectorSplit>& hiveSplit,
+      const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+      const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
+          partitionKeys,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const RowTypePtr& readerOutputType,
+      const std::shared_ptr<io::IoStatistics>& ioStats,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* executor,
+      const std::shared_ptr<common::ScanSpec>& scanSpec);
+
+  /// Create the dwio::common::Reader object baseReader_, which will be used to
+  /// read the data file's metadata and schema
+  void createReader(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      const std::shared_ptr<HiveColumnHandle>& rowIndexColumn);
+
+  /// Check if the hiveSplit_ is empty. The split is considered empty when
+  ///   1) The data file is missing but the user chooses to ignore it
+  ///   2) The file does not contain any rows
+  ///   3) The data in the file does not pass the filters. The test is based on
+  ///      the file metadata and partition key values
+  /// This function needs to be called after baseReader_ is created.
+  bool checkIfSplitIsEmpty(dwio::common::RuntimeStatistics& runtimeStats);
+
+  /// Create the dwio::common::RowReader object baseRowReader_, which owns the
+  /// ColumnReaders that will be used to read the data
+  void createRowReader();
+
+  /// Different table formats may have different meatadata columns.
+  /// This function will be used to update the scanSpec for these columns.
   virtual std::vector<TypePtr> adaptColumns(
       const RowTypePtr& fileType,
       const std::shared_ptr<const velox::RowType>& tableSchema);
 
-  void setConstantValue(
-      common::ScanSpec* FOLLY_NONNULL spec,
-      const TypePtr& type,
-      const velox::variant& value) const;
-
-  void setNullConstantValue(
-      common::ScanSpec* FOLLY_NONNULL spec,
-      const TypePtr& type) const;
+  void setRowIndexColumn(
+      const std::shared_ptr<HiveColumnHandle>& rowIndexColumn,
+      bool isExplicit);
 
   void setPartitionValue(
-      common::ScanSpec* FOLLY_NONNULL spec,
+      common::ScanSpec* spec,
       const std::string& partitionKey,
       const std::optional<std::string>& value) const;
 
-  std::shared_ptr<HiveConnectorSplit> hiveSplit_;
-  RowTypePtr readerOutputType_;
-  std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
-      partitionKeys_;
+  std::shared_ptr<const HiveConnectorSplit> hiveSplit_;
+  const std::shared_ptr<const HiveTableHandle> hiveTableHandle_;
+  const std::unordered_map<
+      std::string,
+      std::shared_ptr<HiveColumnHandle>>* const partitionKeys_;
+  const ConnectorQueryCtx* connectorQueryCtx_;
+  const std::shared_ptr<const HiveConfig> hiveConfig_;
+
+  const RowTypePtr readerOutputType_;
+  const std::shared_ptr<io::IoStatistics> ioStats_;
+  FileHandleFactory* const fileHandleFactory_;
+  folly::Executor* const executor_;
+  memory::MemoryPool* const pool_;
+
   std::shared_ptr<common::ScanSpec> scanSpec_;
-  memory::MemoryPool* pool_;
   std::unique_ptr<dwio::common::Reader> baseReader_;
-  dwio::common::RowReaderOptions rowReaderOpts_;
   std::unique_ptr<dwio::common::RowReader> baseRowReader_;
-
- private:
-  void configureRowReaderOptions(
-      dwio::common::RowReaderOptions& options,
-      const RowTypePtr& rowType);
-
+  dwio::common::ReaderOptions baseReaderOpts_;
+  dwio::common::RowReaderOptions baseRowReaderOpts_;
   bool emptySplit_;
 };
 
diff --git a/velox/connectors/hive/TableHandle.cpp b/velox/connectors/hive/TableHandle.cpp
index d03b2f57e43d0..77088ca754a46 100644
--- a/velox/connectors/hive/TableHandle.cpp
+++ b/velox/connectors/hive/TableHandle.cpp
@@ -73,8 +73,8 @@ std::string HiveColumnHandle::toString() const {
       columnTypeName(columnType_),
       dataType_->toString());
   out << " requiredSubfields: [";
-  for (const auto& s : requiredSubfields_) {
-    out << " " << s.toString();
+  for (const auto& subfield : requiredSubfields_) {
+    out << " " << subfield.toString();
   }
   out << " ]]";
   return out.str();
diff --git a/velox/connectors/hive/TableHandle.h b/velox/connectors/hive/TableHandle.h
index ee62a0892d7cc..cfc9295bd4055 100644
--- a/velox/connectors/hive/TableHandle.h
+++ b/velox/connectors/hive/TableHandle.h
@@ -28,7 +28,14 @@ using SubfieldFilters =
 
 class HiveColumnHandle : public ColumnHandle {
  public:
-  enum class ColumnType { kPartitionKey, kRegular, kSynthesized };
+  enum class ColumnType {
+    kPartitionKey,
+    kRegular,
+    kSynthesized,
+    /// A zero-based row number of type BIGINT auto-generated by the connector.
+    /// Rows numbers are unique within a single file only.
+    kRowIndex
+  };
 
   /// NOTE: 'dataType' is the column type in target write table. 'hiveType' is
   /// converted type of the corresponding column in source table which might not
@@ -69,20 +76,20 @@ class HiveColumnHandle : public ColumnHandle {
     return hiveType_;
   }
 
-  // Applies to columns of complex types: arrays, maps and structs.  When a
-  // query uses only some of the subfields, the engine provides the complete
-  // list of required subfields and the connector is free to prune the rest.
-  //
-  // Examples:
-  //  - SELECT a[1], b['x'], x.y FROM t
-  //  - SELECT a FROM t WHERE b['y'] > 10
-  //
-  // Pruning a struct means populating some of the members with null values.
-  //
-  // Pruning a map means dropping keys not listed in the required subfields.
-  //
-  // Pruning arrays means dropping values with indices larger than maximum
-  // required index.
+  /// Applies to columns of complex types: arrays, maps and structs.  When a
+  /// query uses only some of the subfields, the engine provides the complete
+  /// list of required subfields and the connector is free to prune the rest.
+  ///
+  /// Examples:
+  ///  - SELECT a[1], b['x'], x.y FROM t
+  ///  - SELECT a FROM t WHERE b['y'] > 10
+  ///
+  /// Pruning a struct means populating some of the members with null values.
+  ///
+  /// Pruning a map means dropping keys not listed in the required subfields.
+  ///
+  /// Pruning arrays means dropping values with indices larger than maximum
+  /// required index.
   const std::vector<common::Subfield>& requiredSubfields() const {
     return requiredSubfields_;
   }
diff --git a/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp b/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
index 9d016cae7f7c0..a3eec393b000f 100644
--- a/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
+++ b/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
@@ -329,9 +329,9 @@ BENCHMARK_DRAW_LINE();
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
-
+  memory::MemoryManager::initialize({});
   benchmarkFew = std::make_unique<HivePartitionFunctionBenchmark>(1'000);
   benchmarkMany = std::make_unique<HivePartitionFunctionBenchmark>(10'000);
 
diff --git a/velox/connectors/hive/iceberg/CMakeLists.txt b/velox/connectors/hive/iceberg/CMakeLists.txt
new file mode 100644
index 0000000000000..bc78005c91bb1
--- /dev/null
+++ b/velox/connectors/hive/iceberg/CMakeLists.txt
@@ -0,0 +1,23 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(velox_hive_iceberg_splitreader IcebergSplitReader.cpp
+                  IcebergSplit.cpp PositionalDeleteFileReader.cpp)
+
+velox_link_libraries(velox_hive_iceberg_splitreader velox_connector
+                     Folly::folly)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/connectors/hive/iceberg/IcebergDeleteFile.h b/velox/connectors/hive/iceberg/IcebergDeleteFile.h
new file mode 100644
index 0000000000000..2f9206dfc2649
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDeleteFile.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "velox/dwio/common/Options.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+enum class FileContent {
+  kData,
+  kPositionalDeletes,
+  kEqualityDeletes,
+};
+
+struct IcebergDeleteFile {
+  FileContent content;
+  const std::string filePath;
+  dwio::common::FileFormat fileFormat;
+  uint64_t recordCount;
+  uint64_t fileSizeInBytes;
+  // The field ids for the delete columns for equality delete files
+  std::vector<int32_t> equalityFieldIds;
+  // The lower bounds of the in-file positions for the deleted rows, identified
+  // by each column's field id. E.g. The deleted rows for a column with field id
+  // 1 is in range [10, 50], where 10 and 50 are the deleted row positions in
+  // the data file, then lowerBounds would contain entry <1, "10">
+  std::unordered_map<int32_t, std::string> lowerBounds;
+  // The upper bounds of the in-file positions for the deleted rows, identified
+  // by each column's field id. E.g. The deleted rows for a column with field id
+  // 1 is in range [10, 50], then upperBounds will contain entry <1, "50">
+  std::unordered_map<int32_t, std::string> upperBounds;
+
+  IcebergDeleteFile(
+      FileContent _content,
+      const std::string& _filePath,
+      dwio::common::FileFormat _fileFormat,
+      uint64_t _recordCount,
+      uint64_t _fileSizeInBytes,
+      std::vector<int32_t> _equalityFieldIds = {},
+      std::unordered_map<int32_t, std::string> _lowerBounds = {},
+      std::unordered_map<int32_t, std::string> _upperBounds = {})
+      : content(_content),
+        filePath(_filePath),
+        fileFormat(_fileFormat),
+        recordCount(_recordCount),
+        fileSizeInBytes(_fileSizeInBytes),
+        equalityFieldIds(_equalityFieldIds),
+        lowerBounds(_lowerBounds),
+        upperBounds(_upperBounds) {}
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergMetadataColumns.h b/velox/connectors/hive/iceberg/IcebergMetadataColumns.h
new file mode 100644
index 0000000000000..4cbf2a7862b30
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergMetadataColumns.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+struct IcebergMetadataColumn {
+  int id;
+  std::string name;
+  std::shared_ptr<const Type> type;
+  std::string doc;
+
+  IcebergMetadataColumn(
+      int _id,
+      const std::string& _name,
+      std::shared_ptr<const Type> _type,
+      const std::string& _doc)
+      : id(_id), name(_name), type(_type), doc(_doc) {}
+
+  static std::shared_ptr<IcebergMetadataColumn> icebergDeleteFilePathColumn() {
+    return std::make_shared<IcebergMetadataColumn>(
+        2147483546,
+        "file_path",
+        VARCHAR(),
+        "Path of a file in which a deleted row is stored");
+  }
+
+  static std::shared_ptr<IcebergMetadataColumn> icebergDeletePosColumn() {
+    return std::make_shared<IcebergMetadataColumn>(
+        2147483545,
+        "pos",
+        BIGINT(),
+        "Ordinal position of a deleted row in the data file");
+  }
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplit.cpp b/velox/connectors/hive/iceberg/IcebergSplit.cpp
new file mode 100644
index 0000000000000..6ac3abf4e4dd0
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergSplit.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+HiveIcebergSplit::HiveIcebergSplit(
+    const std::string& _connectorId,
+    const std::string& _filePath,
+    dwio::common::FileFormat _fileFormat,
+    uint64_t _start,
+    uint64_t _length,
+    const std::unordered_map<std::string, std::optional<std::string>>&
+        _partitionKeys,
+    std::optional<int32_t> _tableBucketNumber,
+    const std::unordered_map<std::string, std::string>& _customSplitInfo,
+    const std::shared_ptr<std::string>& _extraFileInfo,
+    const std::unordered_map<std::string, std::string>& _infoColumns,
+    std::optional<FileProperties> _properties)
+    : HiveConnectorSplit(
+          _connectorId,
+          _filePath,
+          _fileFormat,
+          _start,
+          _length,
+          _partitionKeys,
+          _tableBucketNumber,
+          _customSplitInfo,
+          _extraFileInfo,
+          {},
+          0,
+          _infoColumns,
+          _properties) {
+  // TODO: Deserialize _extraFileInfo to get deleteFiles;
+}
+
+// For tests only
+HiveIcebergSplit::HiveIcebergSplit(
+    const std::string& _connectorId,
+    const std::string& _filePath,
+    dwio::common::FileFormat _fileFormat,
+    uint64_t _start,
+    uint64_t _length,
+    const std::unordered_map<std::string, std::optional<std::string>>&
+        _partitionKeys,
+    std::optional<int32_t> _tableBucketNumber,
+    const std::unordered_map<std::string, std::string>& _customSplitInfo,
+    const std::shared_ptr<std::string>& _extraFileInfo,
+    std::vector<IcebergDeleteFile> _deletes,
+    const std::unordered_map<std::string, std::string>& _infoColumns,
+    std::optional<FileProperties> _properties)
+    : HiveConnectorSplit(
+          _connectorId,
+          _filePath,
+          _fileFormat,
+          _start,
+          _length,
+          _partitionKeys,
+          _tableBucketNumber,
+          _customSplitInfo,
+          _extraFileInfo,
+          {},
+          0,
+          _infoColumns,
+          _properties),
+      deleteFiles(_deletes) {}
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplit.h b/velox/connectors/hive/iceberg/IcebergSplit.h
new file mode 100644
index 0000000000000..6c1f4cc6bc3f3
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergSplit.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+struct IcebergDeleteFile;
+
+struct HiveIcebergSplit : public connector::hive::HiveConnectorSplit {
+  std::vector<IcebergDeleteFile> deleteFiles;
+
+  HiveIcebergSplit(
+      const std::string& connectorId,
+      const std::string& _filePath,
+      dwio::common::FileFormat _fileFormat,
+      uint64_t _start = 0,
+      uint64_t _length = std::numeric_limits<uint64_t>::max(),
+      const std::unordered_map<std::string, std::optional<std::string>>&
+          _partitionKeys = {},
+      std::optional<int32_t> _tableBucketNumber = std::nullopt,
+      const std::unordered_map<std::string, std::string>& _customSplitInfo = {},
+      const std::shared_ptr<std::string>& _extraFileInfo = {},
+      const std::unordered_map<std::string, std::string>& _infoColumns = {},
+      std::optional<FileProperties> fileProperties = std::nullopt);
+
+  // For tests only
+  HiveIcebergSplit(
+      const std::string& connectorId,
+      const std::string& _filePath,
+      dwio::common::FileFormat _fileFormat,
+      uint64_t _start = 0,
+      uint64_t _length = std::numeric_limits<uint64_t>::max(),
+      const std::unordered_map<std::string, std::optional<std::string>>&
+          _partitionKeys = {},
+      std::optional<int32_t> _tableBucketNumber = std::nullopt,
+      const std::unordered_map<std::string, std::string>& _customSplitInfo = {},
+      const std::shared_ptr<std::string>& _extraFileInfo = {},
+      std::vector<IcebergDeleteFile> deletes = {},
+      const std::unordered_map<std::string, std::string>& _infoColumns = {},
+      std::optional<FileProperties> fileProperties = std::nullopt);
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplitReader.cpp b/velox/connectors/hive/iceberg/IcebergSplitReader.cpp
new file mode 100644
index 0000000000000..b7c1f6b523408
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergSplitReader.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergSplitReader.h"
+
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+#include "velox/dwio/common/BufferUtil.h"
+
+using namespace facebook::velox::dwio::common;
+
+namespace facebook::velox::connector::hive::iceberg {
+
+IcebergSplitReader::IcebergSplitReader(
+    const std::shared_ptr<const hive::HiveConnectorSplit>& hiveSplit,
+    const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
+        partitionKeys,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const RowTypePtr& readerOutputType,
+    const std::shared_ptr<io::IoStatistics>& ioStats,
+    FileHandleFactory* const fileHandleFactory,
+    folly::Executor* executor,
+    const std::shared_ptr<common::ScanSpec>& scanSpec)
+    : SplitReader(
+          hiveSplit,
+          hiveTableHandle,
+          partitionKeys,
+          connectorQueryCtx,
+          hiveConfig,
+          readerOutputType,
+          ioStats,
+          fileHandleFactory,
+          executor,
+          scanSpec),
+      baseReadOffset_(0),
+      splitOffset_(0),
+      deleteBitmap_(nullptr),
+      deleteBitmapBitOffset_(0) {}
+
+void IcebergSplitReader::prepareSplit(
+    std::shared_ptr<common::MetadataFilter> metadataFilter,
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const std::shared_ptr<HiveColumnHandle>& rowIndexColumn) {
+  createReader(std::move(metadataFilter), rowIndexColumn);
+
+  if (checkIfSplitIsEmpty(runtimeStats)) {
+    VELOX_CHECK(emptySplit_);
+    return;
+  }
+
+  createRowReader();
+
+  std::shared_ptr<const HiveIcebergSplit> icebergSplit =
+      std::dynamic_pointer_cast<const HiveIcebergSplit>(hiveSplit_);
+  baseReadOffset_ = 0;
+  splitOffset_ = baseRowReader_->nextRowNumber();
+  positionalDeleteFileReaders_.clear();
+
+  const auto& deleteFiles = icebergSplit->deleteFiles;
+  for (const auto& deleteFile : deleteFiles) {
+    if (deleteFile.content == FileContent::kPositionalDeletes) {
+      if (deleteFile.recordCount > 0) {
+        positionalDeleteFileReaders_.push_back(
+            std::make_unique<PositionalDeleteFileReader>(
+                deleteFile,
+                hiveSplit_->filePath,
+                fileHandleFactory_,
+                connectorQueryCtx_,
+                executor_,
+                hiveConfig_,
+                ioStats_,
+                runtimeStats,
+                splitOffset_,
+                hiveSplit_->connectorId));
+      }
+    } else {
+      VELOX_NYI();
+    }
+  }
+}
+
+uint64_t IcebergSplitReader::next(uint64_t size, VectorPtr& output) {
+  Mutation mutation;
+  mutation.randomSkip = baseReaderOpts_.randomSkip().get();
+  mutation.deletedRows = nullptr;
+
+  if (deleteBitmap_ && deleteBitmapBitOffset_ > 0) {
+    // There are unconsumed bits from last batch
+    if (deleteBitmapBitOffset_ < deleteBitmap_->size() * 8) {
+      bits::copyBits(
+          deleteBitmap_->as<uint64_t>(),
+          deleteBitmapBitOffset_,
+          deleteBitmap_->asMutable<uint64_t>(),
+          0,
+          deleteBitmap_->size() * 8 - deleteBitmapBitOffset_);
+
+      uint64_t newBitMapSizeInBytes =
+          deleteBitmap_->size() - deleteBitmapBitOffset_ / 8;
+      if (deleteBitmapBitOffset_ % 8 != 0) {
+        newBitMapSizeInBytes--;
+      }
+      deleteBitmap_->setSize(newBitMapSizeInBytes);
+    } else {
+      // All bits were consumed, reset to 0 for all bits
+      std::memset(
+          (void*)(deleteBitmap_->asMutable<int8_t>()),
+          0L,
+          deleteBitmap_->size());
+    }
+  }
+
+  if (!positionalDeleteFileReaders_.empty()) {
+    auto numBytes = bits::nbytes(size);
+    dwio::common::ensureCapacity<int8_t>(
+        deleteBitmap_, numBytes, connectorQueryCtx_->memoryPool(), true, true);
+
+    for (auto iter = positionalDeleteFileReaders_.begin();
+         iter != positionalDeleteFileReaders_.end();) {
+      (*iter)->readDeletePositions(baseReadOffset_, size, deleteBitmap_);
+
+      if ((*iter)->noMoreData()) {
+        iter = positionalDeleteFileReaders_.erase(iter);
+      } else {
+        ++iter;
+      }
+    }
+  }
+
+  mutation.deletedRows = deleteBitmap_ && deleteBitmap_->size() > 0
+      ? deleteBitmap_->as<uint64_t>()
+      : nullptr;
+
+  auto rowsScanned = baseRowReader_->next(size, output, &mutation);
+  baseReadOffset_ += rowsScanned;
+  deleteBitmapBitOffset_ = rowsScanned;
+
+  return rowsScanned;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplitReader.h b/velox/connectors/hive/iceberg/IcebergSplitReader.h
new file mode 100644
index 0000000000000..b5ab7da64480a
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergSplitReader.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/SplitReader.h"
+#include "velox/connectors/hive/iceberg/PositionalDeleteFileReader.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+struct IcebergDeleteFile;
+
+class IcebergSplitReader : public SplitReader {
+ public:
+  IcebergSplitReader(
+      const std::shared_ptr<const hive::HiveConnectorSplit>& hiveSplit,
+      const std::shared_ptr<const HiveTableHandle>& hiveTableHandle,
+      const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
+          partitionKeys,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const RowTypePtr& readerOutputType,
+      const std::shared_ptr<io::IoStatistics>& ioStats,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* executor,
+      const std::shared_ptr<common::ScanSpec>& scanSpec);
+
+  ~IcebergSplitReader() override = default;
+
+  void prepareSplit(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const std::shared_ptr<HiveColumnHandle>& rowIndexColumn) override;
+
+  uint64_t next(uint64_t size, VectorPtr& output) override;
+
+ private:
+  // The read offset to the beginning of the split in number of rows for the
+  // current batch for the base data file
+  uint64_t baseReadOffset_;
+  // The file position for the first row in the split
+  uint64_t splitOffset_;
+  std::list<std::unique_ptr<PositionalDeleteFileReader>>
+      positionalDeleteFileReaders_;
+  BufferPtr deleteBitmap_;
+  // The offset in bits of the deleteBitmap_ starting from where the bits shall
+  // be consumed
+  uint64_t deleteBitmapBitOffset_;
+};
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp
new file mode 100644
index 0000000000000..94828d136e6bb
--- /dev/null
+++ b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/PositionalDeleteFileReader.h"
+
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+#include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
+#include "velox/dwio/common/ReaderFactory.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+PositionalDeleteFileReader::PositionalDeleteFileReader(
+    const IcebergDeleteFile& deleteFile,
+    const std::string& baseFilePath,
+    FileHandleFactory* fileHandleFactory,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    folly::Executor* executor,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::shared_ptr<io::IoStatistics>& ioStats,
+    dwio::common::RuntimeStatistics& runtimeStats,
+    uint64_t splitOffset,
+    const std::string& connectorId)
+    : deleteFile_(deleteFile),
+      baseFilePath_(baseFilePath),
+      fileHandleFactory_(fileHandleFactory),
+      executor_(executor),
+      hiveConfig_(hiveConfig),
+      ioStats_(ioStats),
+      pool_(connectorQueryCtx->memoryPool()),
+      filePathColumn_(IcebergMetadataColumn::icebergDeleteFilePathColumn()),
+      posColumn_(IcebergMetadataColumn::icebergDeletePosColumn()),
+      splitOffset_(splitOffset),
+      deleteSplit_(nullptr),
+      deleteRowReader_(nullptr),
+      deletePositionsOutput_(nullptr),
+      deletePositionsOffset_(0),
+      totalNumRowsScanned_(0) {
+  VELOX_CHECK(deleteFile_.content == FileContent::kPositionalDeletes);
+  VELOX_CHECK(deleteFile_.recordCount);
+
+  // TODO: check if the lowerbounds and upperbounds in deleteFile overlap with
+  //  this batch. If not, no need to proceed.
+
+  // Create the ScanSpec for this delete file
+  auto scanSpec = std::make_shared<common::ScanSpec>("<root>");
+  scanSpec->addField(posColumn_->name, 0);
+  auto* pathSpec = scanSpec->getOrCreateChild(filePathColumn_->name);
+  pathSpec->setFilter(std::make_unique<common::BytesValues>(
+      std::vector<std::string>({baseFilePath_}), false));
+
+  // Create the file schema (in RowType) and split that will be used by readers
+  std::vector<std::string> deleteColumnNames(
+      {filePathColumn_->name, posColumn_->name});
+  std::vector<std::shared_ptr<const Type>> deleteColumnTypes(
+      {filePathColumn_->type, posColumn_->type});
+  RowTypePtr deleteFileSchema =
+      ROW(std::move(deleteColumnNames), std::move(deleteColumnTypes));
+
+  deleteSplit_ = std::make_shared<HiveConnectorSplit>(
+      connectorId,
+      deleteFile_.filePath,
+      deleteFile_.fileFormat,
+      0,
+      deleteFile_.fileSizeInBytes);
+
+  // Create the Reader and RowReader
+
+  dwio::common::ReaderOptions deleteReaderOpts(pool_);
+  configureReaderOptions(
+      deleteReaderOpts,
+      hiveConfig_,
+      connectorQueryCtx,
+      deleteFileSchema,
+      deleteSplit_);
+
+  auto deleteFileHandleCachePtr =
+      fileHandleFactory_->generate(deleteFile_.filePath);
+  auto deleteFileInput = createBufferedInput(
+      *deleteFileHandleCachePtr,
+      deleteReaderOpts,
+      connectorQueryCtx,
+      ioStats_,
+      executor_);
+
+  auto deleteReader =
+      dwio::common::getReaderFactory(deleteReaderOpts.fileFormat())
+          ->createReader(std::move(deleteFileInput), deleteReaderOpts);
+
+  // Check if the whole delete file split can be skipped. This could happen when
+  // 1) the delete file doesn't contain the base file that is being read; 2) The
+  // delete file does not contain the positions in the current batch for the
+  // base file.
+  if (!testFilters(
+          scanSpec.get(),
+          deleteReader.get(),
+          deleteSplit_->filePath,
+          deleteSplit_->partitionKeys,
+          {})) {
+    // We only count the number of base splits skipped as skippedSplits runtime
+    // statistics in Velox.  Skipped delta split is only counted as skipped
+    // bytes.
+    runtimeStats.skippedSplitBytes += deleteSplit_->length;
+    deleteSplit_.reset();
+    return;
+  }
+
+  dwio::common::RowReaderOptions deleteRowReaderOpts;
+  configureRowReaderOptions(
+      {},
+      scanSpec,
+      nullptr,
+      deleteFileSchema,
+      deleteSplit_,
+      nullptr,
+      nullptr,
+      deleteRowReaderOpts);
+
+  deleteRowReader_.reset();
+  deleteRowReader_ = deleteReader->createRowReader(deleteRowReaderOpts);
+}
+
+void PositionalDeleteFileReader::readDeletePositions(
+    uint64_t baseReadOffset,
+    uint64_t size,
+    BufferPtr deleteBitmapBuffer) {
+  // We are going to read to the row number up to the end of the batch. For the
+  // same base file, the deleted rows are in ascending order in the same delete
+  // file. rowNumberUpperBound is the upperbound for the row number in this
+  // batch, excluding boundaries
+  int64_t rowNumberUpperBound = splitOffset_ + baseReadOffset + size;
+
+  // Finish unused delete positions from last batch. Note that at this point we
+  // don't know how many rows the base row reader would scan yet.
+  if (deletePositionsOutput_ &&
+      deletePositionsOffset_ < deletePositionsOutput_->size()) {
+    updateDeleteBitmap(
+        std::dynamic_pointer_cast<RowVector>(deletePositionsOutput_)
+            ->childAt(0),
+        baseReadOffset,
+        rowNumberUpperBound,
+        deleteBitmapBuffer);
+
+    if (readFinishedForBatch(rowNumberUpperBound)) {
+      return;
+    }
+  }
+
+  if (!deleteRowReader_ || !deleteSplit_) {
+    return;
+  }
+
+  // Read the new delete positions for this batch into deletePositionsOutput_
+  // and update the delete bitmap
+
+  auto outputType = posColumn_->type;
+  RowTypePtr outputRowType = ROW({posColumn_->name}, {posColumn_->type});
+  if (!deletePositionsOutput_) {
+    deletePositionsOutput_ = BaseVector::create(outputRowType, 0, pool_);
+  }
+
+  do {
+    auto rowsScanned = deleteRowReader_->next(size, deletePositionsOutput_);
+    totalNumRowsScanned_ += rowsScanned;
+
+    if (rowsScanned > 0) {
+      VELOX_CHECK(
+          !deletePositionsOutput_->mayHaveNulls(),
+          "Iceberg delete file pos column cannot have nulls");
+
+      auto numDeletedRows = deletePositionsOutput_->size();
+      if (numDeletedRows > 0) {
+        deletePositionsOutput_->loadedVector();
+        deletePositionsOffset_ = 0;
+
+        // Convert the row numbers to set bits, up to rowNumberUpperBound.
+        // Beyond that the buffer of deleteBitMap is not available.
+        updateDeleteBitmap(
+            std::dynamic_pointer_cast<RowVector>(deletePositionsOutput_)
+                ->childAt(0),
+            baseReadOffset,
+            rowNumberUpperBound,
+            deleteBitmapBuffer);
+      }
+    } else {
+      // Reaching the end of the file
+      deleteSplit_.reset();
+      break;
+    }
+  } while (!readFinishedForBatch(rowNumberUpperBound));
+}
+
+bool PositionalDeleteFileReader::noMoreData() {
+  return totalNumRowsScanned_ >= deleteFile_.recordCount &&
+      deletePositionsOutput_ &&
+      deletePositionsOffset_ >= deletePositionsOutput_->size();
+}
+
+void PositionalDeleteFileReader::updateDeleteBitmap(
+    VectorPtr deletePositionsVector,
+    uint64_t baseReadOffset,
+    int64_t rowNumberUpperBound,
+    BufferPtr deleteBitmapBuffer) {
+  auto deleteBitmap = deleteBitmapBuffer->asMutable<uint8_t>();
+
+  // Convert the positions in file into positions relative to the start of the
+  // split.
+  const int64_t* deletePositions =
+      deletePositionsVector->as<FlatVector<int64_t>>()->rawValues();
+  int64_t offset = baseReadOffset + splitOffset_;
+
+  while (deletePositionsOffset_ < deletePositionsVector->size() &&
+         deletePositions[deletePositionsOffset_] < rowNumberUpperBound) {
+    bits::setBit(
+        deleteBitmap, deletePositions[deletePositionsOffset_] - offset);
+    deletePositionsOffset_++;
+  }
+
+  // There might be multiple delete files for a single base file. The size of
+  // the deleteBitmapBuffer should be the largest position among all delte files
+  deleteBitmapBuffer->setSize(std::max(
+      (uint64_t)deleteBitmapBuffer->size(),
+      deletePositionsOffset_ == 0 ||
+              (deletePositionsOffset_ < deletePositionsVector->size() &&
+               deletePositions[deletePositionsOffset_] > rowNumberUpperBound)
+          ? 0
+          : bits::nbytes(
+                deletePositions[deletePositionsOffset_ - 1] + 1 - offset)));
+}
+
+bool PositionalDeleteFileReader::readFinishedForBatch(
+    int64_t rowNumberUpperBound) {
+  VELOX_CHECK_NOT_NULL(deletePositionsOutput_);
+
+  auto deletePositionsVector =
+      std::dynamic_pointer_cast<RowVector>(deletePositionsOutput_)->childAt(0);
+  const int64_t* deletePositions =
+      deletePositionsVector->as<FlatVector<int64_t>>()->rawValues();
+
+  // We've read enough of the delete positions from this delete file when 1) it
+  // reaches the end of the file, or 2) the last read delete position is greater
+  // than the largest base file row number that is going to be read in this
+  // batch
+  if (totalNumRowsScanned_ >= deleteFile_.recordCount ||
+      (deletePositionsVector->size() != 0 &&
+       (deletePositionsOffset_ < deletePositionsVector->size() &&
+        deletePositions[deletePositionsOffset_] >= rowNumberUpperBound))) {
+    return true;
+  }
+  return false;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/PositionalDeleteFileReader.h b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.h
new file mode 100644
index 0000000000000..ba98845eb6393
--- /dev/null
+++ b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Executor.h>
+#include <memory>
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/common/Reader.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+struct IcebergDeleteFile;
+struct IcebergMetadataColumn;
+
+using SubfieldFilters =
+    std::unordered_map<common::Subfield, std::unique_ptr<common::Filter>>;
+
+class PositionalDeleteFileReader {
+ public:
+  PositionalDeleteFileReader(
+      const IcebergDeleteFile& deleteFile,
+      const std::string& baseFilePath,
+      FileHandleFactory* fileHandleFactory,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      folly::Executor* executor,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const std::shared_ptr<io::IoStatistics>& ioStats,
+      dwio::common::RuntimeStatistics& runtimeStats,
+      uint64_t splitOffset,
+      const std::string& connectorId);
+
+  void readDeletePositions(
+      uint64_t baseReadOffset,
+      uint64_t size,
+      BufferPtr deleteBitmap);
+
+  bool noMoreData();
+
+ private:
+  void updateDeleteBitmap(
+      VectorPtr deletePositionsVector,
+      uint64_t baseReadOffset,
+      int64_t rowNumberUpperBound,
+      BufferPtr deleteBitmapBuffer);
+
+  bool readFinishedForBatch(int64_t rowNumberUpperBound);
+
+  const IcebergDeleteFile& deleteFile_;
+  const std::string& baseFilePath_;
+  FileHandleFactory* const fileHandleFactory_;
+  folly::Executor* const executor_;
+  const std::shared_ptr<const HiveConfig> hiveConfig_;
+  const std::shared_ptr<io::IoStatistics> ioStats_;
+  memory::MemoryPool* const pool_;
+
+  std::shared_ptr<IcebergMetadataColumn> filePathColumn_;
+  std::shared_ptr<IcebergMetadataColumn> posColumn_;
+  uint64_t splitOffset_;
+
+  std::shared_ptr<HiveConnectorSplit> deleteSplit_;
+  std::unique_ptr<dwio::common::RowReader> deleteRowReader_;
+  // The vector to hold the delete positions read from the positional delete
+  // file. These positions are relative to the start of the whole base data
+  // file.
+  VectorPtr deletePositionsOutput_;
+  // The index of deletePositionsOutput_ that indicates up to where the delete
+  // positions have been converted into the bitmap
+  uint64_t deletePositionsOffset_;
+  // Total number of rows read from this positional delete file reader,
+  // including the rows filtered out from filters on both filePathColumn_ and
+  // posColumn_.
+  uint64_t totalNumRowsScanned_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/CMakeLists.txt b/velox/connectors/hive/iceberg/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..5808b640af64c
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/CMakeLists.txt
@@ -0,0 +1,61 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+add_library(velox_dwio_iceberg_reader_benchmark_lib
+            IcebergSplitReaderBenchmark.cpp)
+target_link_libraries(
+  velox_dwio_iceberg_reader_benchmark_lib
+  velox_exec_test_lib
+  velox_exec
+  velox_hive_connector
+  Folly::folly
+  ${FOLLY_BENCHMARK}
+  ${TEST_LINK_LIBS})
+
+add_executable(velox_dwio_iceberg_reader_benchmark
+               IcebergSplitReaderBenchmarkMain.cpp)
+target_link_libraries(
+  velox_dwio_iceberg_reader_benchmark
+  velox_dwio_iceberg_reader_benchmark_lib
+  velox_dwio_dwrf_proto
+  velox_exec_test_lib
+  velox_exec
+  velox_hive_connector
+  Folly::folly
+  ${FOLLY_BENCHMARK}
+  ${TEST_LINK_LIBS})
+
+if(NOT VELOX_DISABLE_GOOGLETEST)
+
+  add_executable(velox_hive_iceberg_test IcebergReadTest.cpp
+                                         IcebergSplitReaderBenchmarkTest.cpp)
+  add_test(velox_hive_iceberg_test velox_hive_iceberg_test)
+
+  target_link_libraries(
+    velox_hive_iceberg_test
+    velox_dwio_iceberg_reader_benchmark_lib
+    velox_hive_connector
+    velox_hive_iceberg_splitreader
+    velox_hive_partition_function
+    velox_dwio_common_exception
+    velox_dwio_common_test_utils
+    velox_dwio_dwrf_proto
+    velox_vector_test_lib
+    velox_exec
+    velox_exec_test_lib
+    Folly::folly
+    ${FOLLY_BENCHMARK}
+    GTest::gtest
+    GTest::gtest_main)
+
+endif()
diff --git a/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp
new file mode 100644
index 0000000000000..d79e21b733439
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp
@@ -0,0 +1,662 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+#include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+#include <folly/Singleton.h>
+
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::connector::hive::iceberg {
+
+class HiveIcebergTest : public HiveConnectorTestBase {
+ public:
+  HiveIcebergTest()
+      : config_{std::make_shared<facebook::velox::dwrf::Config>()} {
+    // Make the writers flush per batch so that we can create non-aligned
+    // RowGroups between the base data files and delete files
+    flushPolicyFactory_ = []() {
+      return std::make_unique<dwrf::LambdaFlushPolicy>([]() { return true; });
+    };
+  }
+
+  /// Create 1 base data file data_file_1 with 2 RowGroups of 10000 rows each.
+  /// Also create 1 delete file delete_file_1 which contains delete positions
+  /// for data_file_1.
+  void assertSingleBaseFileSingleDeleteFile(
+      const std::vector<int64_t>& deletePositionsVec) {
+    std::map<std::string, std::vector<int64_t>> rowGroupSizesForFiles = {
+        {"data_file_1", {10000, 10000}}};
+    std::unordered_map<
+        std::string,
+        std::multimap<std::string, std::vector<int64_t>>>
+        deleteFilesForBaseDatafiles = {
+            {"delete_file_1", {{"data_file_1", deletePositionsVec}}}};
+
+    assertPositionalDeletes(
+        rowGroupSizesForFiles, deleteFilesForBaseDatafiles, 0);
+  }
+
+  /// Create 3 base data files, where the first file data_file_0 has 500 rows,
+  /// the second file data_file_1 contains 2 RowGroups of 10000 rows each, and
+  /// the third file data_file_2 contains 500 rows. It creates 1 positional
+  /// delete file delete_file_1, which contains delete positions for
+  /// data_file_1.
+  void assertMultipleBaseFileSingleDeleteFile(
+      const std::vector<int64_t>& deletePositionsVec) {
+    int64_t previousFileRowCount = 500;
+    int64_t afterFileRowCount = 500;
+
+    assertPositionalDeletes(
+        {
+            {"data_file_0", {previousFileRowCount}},
+            {"data_file_1", {10000, 10000}},
+            {"data_file_2", {afterFileRowCount}},
+        },
+        {{"delete_file_1", {{"data_file_1", deletePositionsVec}}}},
+        0);
+  }
+
+  /// Create 1 base data file data_file_1 with 2 RowGroups of 10000 rows each.
+  /// Create multiple delete files with name data_file_1, data_file_2, and so on
+  void assertSingleBaseFileMultipleDeleteFiles(
+      const std::vector<std::vector<int64_t>>& deletePositionsVecs) {
+    std::map<std::string, std::vector<int64_t>> rowGroupSizesForFiles = {
+        {"data_file_1", {10000, 10000}}};
+
+    std::unordered_map<
+        std::string,
+        std::multimap<std::string, std::vector<int64_t>>>
+        deleteFilesForBaseDatafiles;
+    for (int i = 0; i < deletePositionsVecs.size(); i++) {
+      std::string deleteFileName = fmt::format("delete_file_{}", i);
+      deleteFilesForBaseDatafiles[deleteFileName] = {
+          {"data_file_1", deletePositionsVecs[i]}};
+    }
+    assertPositionalDeletes(
+        rowGroupSizesForFiles, deleteFilesForBaseDatafiles, 0);
+  }
+
+  void assertMultipleSplits(
+      const std::vector<int64_t>& deletePositions,
+      int32_t splitCount,
+      int32_t numPrefetchSplits) {
+    std::map<std::string, std::vector<int64_t>> rowGroupSizesForFiles;
+    for (int32_t i = 0; i < splitCount; i++) {
+      std::string dataFileName = fmt::format("data_file_{}", i);
+      rowGroupSizesForFiles[dataFileName] = {rowCount};
+    }
+
+    std::unordered_map<
+        std::string,
+        std::multimap<std::string, std::vector<int64_t>>>
+        deleteFilesForBaseDatafiles;
+    for (int i = 0; i < splitCount; i++) {
+      std::string deleteFileName = fmt::format("delete_file_{}", i);
+      deleteFilesForBaseDatafiles[deleteFileName] = {
+          {fmt::format("data_file_{}", i), deletePositions}};
+    }
+
+    assertPositionalDeletes(
+        rowGroupSizesForFiles, deleteFilesForBaseDatafiles, numPrefetchSplits);
+  }
+
+  std::vector<int64_t> makeRandomIncreasingValues(int64_t begin, int64_t end) {
+    VELOX_CHECK(begin < end);
+
+    std::mt19937 gen{0};
+    std::vector<int64_t> values;
+    values.reserve(end - begin);
+    for (int i = begin; i < end; i++) {
+      if (folly::Random::rand32(0, 10, gen) > 8) {
+        values.push_back(i);
+      }
+    }
+    return values;
+  }
+
+  std::vector<int64_t> makeContinuousIncreasingValues(
+      int64_t begin,
+      int64_t end) {
+    std::vector<int64_t> values;
+    values.resize(end - begin);
+    std::iota(values.begin(), values.end(), begin);
+    return values;
+  }
+
+  /// @rowGroupSizesForFiles The key is the file name, and the value is a vector
+  /// of RowGroup sizes
+  /// @deleteFilesForBaseDatafiles The key is the delete file name, and the
+  /// value contains the information about the content of this delete file.
+  /// e.g. {
+  ///         "delete_file_1",
+  ///         {
+  ///             {"data_file_1", {1, 2, 3}},
+  ///             {"data_file_1", {4, 5, 6}},
+  ///             {"data_file_2", {0, 2, 4}}
+  ///         }
+  ///     }
+  /// represents one delete file called delete_file_1, which contains delete
+  /// positions for data_file_1 and data_file_2. THere are 3 RowGroups in this
+  /// delete file, the first two contain positions for data_file_1, and the last
+  /// contain positions for data_file_2
+  void assertPositionalDeletes(
+      const std::map<std::string, std::vector<int64_t>>& rowGroupSizesForFiles,
+      const std::unordered_map<
+          std::string,
+          std::multimap<std::string, std::vector<int64_t>>>&
+          deleteFilesForBaseDatafiles,
+      int32_t numPrefetchSplits = 0) {
+    // Keep the reference to the deleteFilePath, otherwise the corresponding
+    // file will be deleted.
+    std::map<std::string, std::shared_ptr<TempFilePath>> dataFilePaths =
+        writeDataFiles(rowGroupSizesForFiles);
+    std::unordered_map<
+        std::string,
+        std::pair<int64_t, std::shared_ptr<TempFilePath>>>
+        deleteFilePaths = writePositionDeleteFiles(
+            deleteFilesForBaseDatafiles, dataFilePaths);
+
+    std::vector<std::shared_ptr<ConnectorSplit>> splits;
+
+    for (const auto& dataFile : dataFilePaths) {
+      std::string baseFileName = dataFile.first;
+      std::string baseFilePath = dataFile.second->getPath();
+
+      std::vector<IcebergDeleteFile> deleteFiles;
+
+      for (auto const& deleteFile : deleteFilesForBaseDatafiles) {
+        std::string deleteFileName = deleteFile.first;
+        std::multimap<std::string, std::vector<int64_t>> deleteFileContent =
+            deleteFile.second;
+
+        if (deleteFileContent.count(baseFileName) != 0) {
+          // If this delete file contains rows for the target base file, then
+          // add it to the split
+          auto deleteFilePath =
+              deleteFilePaths[deleteFileName].second->getPath();
+          IcebergDeleteFile deleteFile(
+              FileContent::kPositionalDeletes,
+              deleteFilePath,
+              fileFomat_,
+              deleteFilePaths[deleteFileName].first,
+              testing::internal::GetFileSize(
+                  std::fopen(deleteFilePath.c_str(), "r")));
+          deleteFiles.push_back(deleteFile);
+        }
+      }
+
+      splits.emplace_back(makeIcebergSplit(baseFilePath, deleteFiles));
+    }
+
+    std::string duckdbSql =
+        getDuckDBQuery(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+    auto plan = tableScanNode();
+    auto task = HiveConnectorTestBase::assertQuery(
+        plan, splits, duckdbSql, numPrefetchSplits);
+
+    auto planStats = toPlanStats(task->taskStats());
+    auto scanNodeId = plan->id();
+    auto it = planStats.find(scanNodeId);
+    ASSERT_TRUE(it != planStats.end());
+    ASSERT_TRUE(it->second.peakMemoryBytes > 0);
+  }
+
+  const static int rowCount = 20000;
+
+ private:
+  std::map<std::string, std::shared_ptr<TempFilePath>> writeDataFiles(
+      std::map<std::string, std::vector<int64_t>> rowGroupSizesForFiles) {
+    std::map<std::string, std::shared_ptr<TempFilePath>> dataFilePaths;
+
+    std::vector<RowVectorPtr> dataVectorsJoined;
+    dataVectorsJoined.reserve(rowGroupSizesForFiles.size());
+
+    int64_t startingValue = 0;
+    for (auto& dataFile : rowGroupSizesForFiles) {
+      dataFilePaths[dataFile.first] = TempFilePath::create();
+
+      // We make the values are continuously increasing even across base data
+      // files. This is to make constructing DuckDB queries easier
+      std::vector<RowVectorPtr> dataVectors =
+          makeVectors(dataFile.second, startingValue);
+      writeToFile(
+          dataFilePaths[dataFile.first]->getPath(),
+          dataVectors,
+          config_,
+          flushPolicyFactory_);
+
+      for (int i = 0; i < dataVectors.size(); i++) {
+        dataVectorsJoined.push_back(dataVectors[i]);
+      }
+    }
+
+    createDuckDbTable(dataVectorsJoined);
+    return dataFilePaths;
+  }
+
+  /// Input is like <"deleteFile1", <"dataFile1", {pos_RG1, pos_RG2,..}>,
+  /// <"dataFile2", {pos_RG1, pos_RG2,..}>
+  std::unordered_map<
+      std::string,
+      std::pair<int64_t, std::shared_ptr<TempFilePath>>>
+  writePositionDeleteFiles(
+      const std::unordered_map<
+          std::string, // delete file name
+          std::multimap<
+              std::string,
+              std::vector<int64_t>>>&
+          deleteFilesForBaseDatafiles, // <base file name, delete position
+                                       // vector for all RowGroups>
+      std::map<std::string, std::shared_ptr<TempFilePath>> baseFilePaths) {
+    std::unordered_map<
+        std::string,
+        std::pair<int64_t, std::shared_ptr<TempFilePath>>>
+        deleteFilePaths;
+    deleteFilePaths.reserve(deleteFilesForBaseDatafiles.size());
+
+    for (auto& deleteFile : deleteFilesForBaseDatafiles) {
+      auto deleteFileName = deleteFile.first;
+      auto deleteFileContent = deleteFile.second;
+      auto deleteFilePath = TempFilePath::create();
+
+      std::vector<RowVectorPtr> deleteFileVectors;
+      int64_t totalPositionsInDeleteFile = 0;
+
+      for (auto& deleteFileRowGroup : deleteFileContent) {
+        auto baseFileName = deleteFileRowGroup.first;
+        auto baseFilePath = baseFilePaths[baseFileName]->getPath();
+        auto positionsInRowGroup = deleteFileRowGroup.second;
+
+        auto filePathVector = makeFlatVector<std::string>(
+            static_cast<vector_size_t>(positionsInRowGroup.size()),
+            [&](vector_size_t row) { return baseFilePath; });
+        auto deletePosVector = makeFlatVector<int64_t>(positionsInRowGroup);
+
+        RowVectorPtr deleteFileVector = makeRowVector(
+            {pathColumn_->name, posColumn_->name},
+            {filePathVector, deletePosVector});
+
+        deleteFileVectors.push_back(deleteFileVector);
+        totalPositionsInDeleteFile += positionsInRowGroup.size();
+      }
+
+      writeToFile(
+          deleteFilePath->getPath(),
+          deleteFileVectors,
+          config_,
+          flushPolicyFactory_);
+
+      deleteFilePaths[deleteFileName] =
+          std::make_pair(totalPositionsInDeleteFile, deleteFilePath);
+    }
+
+    return deleteFilePaths;
+  }
+
+  std::vector<RowVectorPtr> makeVectors(
+      std::vector<int64_t> vectorSizes,
+      int64_t& startingValue) {
+    std::vector<RowVectorPtr> vectors;
+    vectors.reserve(vectorSizes.size());
+
+    vectors.reserve(vectorSizes.size());
+    for (int j = 0; j < vectorSizes.size(); j++) {
+      auto data = makeContinuousIncreasingValues(
+          startingValue, startingValue + vectorSizes[j]);
+      VectorPtr c0 = vectorMaker_.flatVector<int64_t>(data);
+      vectors.push_back(makeRowVector({"c0"}, {c0}));
+      startingValue += vectorSizes[j];
+    }
+
+    return vectors;
+  }
+
+  std::shared_ptr<ConnectorSplit> makeIcebergSplit(
+      const std::string& dataFilePath,
+      const std::vector<IcebergDeleteFile>& deleteFiles = {}) {
+    std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+    std::unordered_map<std::string, std::string> customSplitInfo;
+    customSplitInfo["table_format"] = "hive-iceberg";
+
+    auto file = filesystems::getFileSystem(dataFilePath, nullptr)
+                    ->openFileForRead(dataFilePath);
+    const int64_t fileSize = file->size();
+
+    return std::make_shared<HiveIcebergSplit>(
+        kHiveConnectorId,
+        dataFilePath,
+        fileFomat_,
+        0,
+        fileSize,
+        partitionKeys,
+        std::nullopt,
+        customSplitInfo,
+        nullptr,
+        deleteFiles);
+  }
+
+  std::string getDuckDBQuery(
+      const std::map<std::string, std::vector<int64_t>>& rowGroupSizesForFiles,
+      const std::unordered_map<
+          std::string,
+          std::multimap<std::string, std::vector<int64_t>>>&
+          deleteFilesForBaseDatafiles) {
+    int64_t totalNumRowsInAllBaseFiles = 0;
+    std::map<std::string, int64_t> baseFileSizes;
+    for (auto rowGroupSizesInFile : rowGroupSizesForFiles) {
+      // Sum up the row counts in all RowGroups in each base file
+      baseFileSizes[rowGroupSizesInFile.first] += std::accumulate(
+          rowGroupSizesInFile.second.begin(),
+          rowGroupSizesInFile.second.end(),
+          0LL);
+      totalNumRowsInAllBaseFiles += baseFileSizes[rowGroupSizesInFile.first];
+    }
+
+    // Group the delete vectors by baseFileName
+    std::map<std::string, std::vector<std::vector<int64_t>>>
+        deletePosVectorsForAllBaseFiles;
+    for (auto deleteFile : deleteFilesForBaseDatafiles) {
+      auto deleteFileContent = deleteFile.second;
+      for (auto rowGroup : deleteFileContent) {
+        auto baseFileName = rowGroup.first;
+        deletePosVectorsForAllBaseFiles[baseFileName].push_back(
+            rowGroup.second);
+      }
+    }
+
+    // Flatten and deduplicate the delete position vectors in
+    // deletePosVectorsForAllBaseFiles from previous step, and count the total
+    // number of distinct delete positions for all base files
+    std::map<std::string, std::vector<int64_t>>
+        flattenedDeletePosVectorsForAllBaseFiles;
+    int64_t totalNumDeletePositions = 0;
+    for (auto deleteVectorsForBaseFile : deletePosVectorsForAllBaseFiles) {
+      auto baseFileName = deleteVectorsForBaseFile.first;
+      auto deletePositionVectors = deleteVectorsForBaseFile.second;
+      std::vector<int64_t> deletePositionVector =
+          flattenAndDedup(deletePositionVectors, baseFileSizes[baseFileName]);
+      flattenedDeletePosVectorsForAllBaseFiles[baseFileName] =
+          deletePositionVector;
+      totalNumDeletePositions += deletePositionVector.size();
+    }
+
+    // Now build the DuckDB queries
+    if (totalNumDeletePositions == 0) {
+      return "SELECT * FROM tmp";
+    } else if (totalNumDeletePositions >= totalNumRowsInAllBaseFiles) {
+      return "SELECT * FROM tmp WHERE 1 = 0";
+    } else {
+      // Convert the delete positions in all base files into column values
+      std::vector<int64_t> allDeleteValues;
+
+      int64_t numRowsInPreviousBaseFiles = 0;
+      for (auto baseFileSize : baseFileSizes) {
+        auto deletePositions =
+            flattenedDeletePosVectorsForAllBaseFiles[baseFileSize.first];
+
+        if (numRowsInPreviousBaseFiles > 0) {
+          for (int64_t& deleteValue : deletePositions) {
+            deleteValue += numRowsInPreviousBaseFiles;
+          }
+        }
+
+        allDeleteValues.insert(
+            allDeleteValues.end(),
+            deletePositions.begin(),
+            deletePositions.end());
+
+        numRowsInPreviousBaseFiles += baseFileSize.second;
+      }
+
+      return fmt::format(
+          "SELECT * FROM tmp WHERE c0 NOT IN ({})",
+          makeNotInList(allDeleteValues));
+    }
+  }
+
+  std::vector<int64_t> flattenAndDedup(
+      const std::vector<std::vector<int64_t>>& deletePositionVectors,
+      int64_t baseFileSize) {
+    std::vector<int64_t> deletePositionVector;
+    for (auto vec : deletePositionVectors) {
+      for (auto pos : vec) {
+        if (pos >= 0 && pos < baseFileSize) {
+          deletePositionVector.push_back(pos);
+        }
+      }
+    }
+
+    std::sort(deletePositionVector.begin(), deletePositionVector.end());
+    auto last =
+        std::unique(deletePositionVector.begin(), deletePositionVector.end());
+    deletePositionVector.erase(last, deletePositionVector.end());
+
+    return deletePositionVector;
+  }
+
+  std::string makeNotInList(const std::vector<int64_t>& deletePositionVector) {
+    if (deletePositionVector.empty()) {
+      return "";
+    }
+
+    return std::accumulate(
+        deletePositionVector.begin() + 1,
+        deletePositionVector.end(),
+        std::to_string(deletePositionVector[0]),
+        [](const std::string& a, int64_t b) {
+          return a + ", " + std::to_string(b);
+        });
+  }
+
+  core::PlanNodePtr tableScanNode() {
+    return PlanBuilder(pool_.get()).tableScan(rowType_).planNode();
+  }
+
+  dwio::common::FileFormat fileFomat_{dwio::common::FileFormat::DWRF};
+  std::shared_ptr<dwrf::Config> config_;
+  std::function<std::unique_ptr<dwrf::DWRFFlushPolicy>()> flushPolicyFactory_;
+
+  RowTypePtr rowType_{ROW({"c0"}, {BIGINT()})};
+  std::shared_ptr<IcebergMetadataColumn> pathColumn_ =
+      IcebergMetadataColumn::icebergDeleteFilePathColumn();
+  std::shared_ptr<IcebergMetadataColumn> posColumn_ =
+      IcebergMetadataColumn::icebergDeletePosColumn();
+};
+
+/// This test creates one single data file and one delete file. The parameter
+/// passed to assertSingleBaseFileSingleDeleteFile is the delete positions.
+TEST_F(HiveIcebergTest, singleBaseFileSinglePositionalDeleteFile) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  assertSingleBaseFileSingleDeleteFile({{0, 1, 2, 3}});
+  // Delete the first and last row in each batch (10000 rows per batch)
+  assertSingleBaseFileSingleDeleteFile({{0, 9999, 10000, 19999}});
+  // Delete several rows in the second batch (10000 rows per batch)
+  assertSingleBaseFileSingleDeleteFile({{10000, 10002, 19999}});
+  // Delete random rows
+  assertSingleBaseFileSingleDeleteFile({makeRandomIncreasingValues(0, 20000)});
+  // Delete 0 rows
+  assertSingleBaseFileSingleDeleteFile({});
+  // Delete all rows
+  assertSingleBaseFileSingleDeleteFile(
+      {makeContinuousIncreasingValues(0, 20000)});
+  // Delete rows that don't exist
+  assertSingleBaseFileSingleDeleteFile({{20000, 29999}});
+}
+
+/// This test creates 3 base data files, only the middle one has corresponding
+/// delete positions. The parameter passed to
+/// assertSingleBaseFileSingleDeleteFile is the delete positions.for the middle
+/// base file.
+TEST_F(HiveIcebergTest, MultipleBaseFilesSinglePositionalDeleteFile) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  assertMultipleBaseFileSingleDeleteFile({0, 1, 2, 3});
+  assertMultipleBaseFileSingleDeleteFile({0, 9999, 10000, 19999});
+  assertMultipleBaseFileSingleDeleteFile({10000, 10002, 19999});
+  assertMultipleBaseFileSingleDeleteFile({10000, 10002, 19999});
+  assertMultipleBaseFileSingleDeleteFile(
+      makeRandomIncreasingValues(0, rowCount));
+  assertMultipleBaseFileSingleDeleteFile({});
+  assertMultipleBaseFileSingleDeleteFile(
+      makeContinuousIncreasingValues(0, rowCount));
+}
+
+/// This test creates one base data file/split with multiple delete files. The
+/// parameter passed to assertSingleBaseFileMultipleDeleteFiles is the vector of
+/// delete files. Each leaf vector represents the delete positions in that
+/// delete file.
+TEST_F(HiveIcebergTest, singleBaseFileMultiplePositionalDeleteFiles) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  // Delete row 0, 1, 2, 3 from the first batch out of two.
+  assertSingleBaseFileMultipleDeleteFiles({{1}, {2}, {3}, {4}});
+  // Delete the first and last row in each batch (10000 rows per batch).
+  assertSingleBaseFileMultipleDeleteFiles({{0}, {9999}, {10000}, {19999}});
+
+  assertSingleBaseFileMultipleDeleteFiles({{500, 21000}});
+
+  assertSingleBaseFileMultipleDeleteFiles(
+      {makeRandomIncreasingValues(0, 10000),
+       makeRandomIncreasingValues(10000, 20000),
+       makeRandomIncreasingValues(5000, 15000)});
+
+  assertSingleBaseFileMultipleDeleteFiles(
+      {makeContinuousIncreasingValues(0, 10000),
+       makeContinuousIncreasingValues(10000, 20000)});
+
+  assertSingleBaseFileMultipleDeleteFiles(
+      {makeContinuousIncreasingValues(0, 10000),
+       makeContinuousIncreasingValues(10000, 20000),
+       makeRandomIncreasingValues(5000, 15000)});
+
+  assertSingleBaseFileMultipleDeleteFiles(
+      {makeContinuousIncreasingValues(0, 20000),
+       makeContinuousIncreasingValues(0, 20000)});
+
+  assertSingleBaseFileMultipleDeleteFiles(
+      {makeRandomIncreasingValues(0, 20000),
+       {},
+       makeRandomIncreasingValues(5000, 15000)});
+
+  assertSingleBaseFileMultipleDeleteFiles({{}, {}});
+}
+
+/// This test creates 2 base data files, and 1 or 2 delete files, with unaligned
+/// RowGroup boundaries
+TEST_F(HiveIcebergTest, multipleBaseFileMultiplePositionalDeleteFiles) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  std::map<std::string, std::vector<int64_t>> rowGroupSizesForFiles;
+  std::unordered_map<
+      std::string,
+      std::multimap<std::string, std::vector<int64_t>>>
+      deleteFilesForBaseDatafiles;
+
+  // Create two data files, each with two RowGroups
+  rowGroupSizesForFiles["data_file_1"] = {100, 85};
+  rowGroupSizesForFiles["data_file_2"] = {99, 1};
+
+  // Delete 3 rows from the first RowGroup in data_file_1
+  deleteFilesForBaseDatafiles["delete_file_1"] = {{"data_file_1", {0, 1, 99}}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+
+  // Delete 3 rows from the second RowGroup in data_file_1
+  deleteFilesForBaseDatafiles["delete_file_1"] = {
+      {"data_file_1", {100, 101, 184}}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+
+  // Delete random rows from the both RowGroups in data_file_1
+  deleteFilesForBaseDatafiles["delete_file_1"] = {
+      {"data_file_1", makeRandomIncreasingValues(0, 185)}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+
+  // Delete all rows in data_file_1
+  deleteFilesForBaseDatafiles["delete_file_1"] = {
+      {"data_file_1", makeContinuousIncreasingValues(0, 185)}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+  //
+  // Delete non-existent rows from data_file_1
+  deleteFilesForBaseDatafiles["delete_file_1"] = {
+      {"data_file_1", makeRandomIncreasingValues(186, 300)}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+
+  // Delete several rows from both RowGroups in both data files
+  deleteFilesForBaseDatafiles.clear();
+  deleteFilesForBaseDatafiles["delete_file_1"] = {
+      {"data_file_1", {0, 100, 102, 184}}, {"data_file_2", {1, 98, 99}}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+
+  // The delete file delete_file_1 contains 3 RowGroups itself, with the first 3
+  // deleting some repeating rows in data_file_1, and the last 2 RowGroups
+  // deleting some  repeating rows in data_file_2
+  deleteFilesForBaseDatafiles.clear();
+  deleteFilesForBaseDatafiles["delete_file_1"] = {
+      {"data_file_1", {0, 1, 2, 3}},
+      {"data_file_1", {1, 2, 3, 4}},
+      {"data_file_1", makeRandomIncreasingValues(0, 185)},
+      {"data_file_2", {1, 3, 5, 7}},
+      {"data_file_2", makeRandomIncreasingValues(0, 100)}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+
+  // delete_file_2 contains non-overlapping delete rows for each data files in
+  // each RowGroup
+  deleteFilesForBaseDatafiles.clear();
+  deleteFilesForBaseDatafiles["delete_file_1"] = {
+      {"data_file_1", {0, 1, 2, 3}}, {"data_file_2", {1, 3, 5, 7}}};
+  deleteFilesForBaseDatafiles["delete_file_2"] = {
+      {"data_file_1", {1, 2, 3, 4}},
+      {"data_file_1", {98, 99, 100, 101, 184}},
+      {"data_file_2", {3, 5, 7, 9}},
+      {"data_file_2", {98, 99, 100}}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+
+  // Two delete files each containing overlapping delete rows for both data
+  // files
+  deleteFilesForBaseDatafiles.clear();
+  deleteFilesForBaseDatafiles["delete_file_1"] = {
+      {"data_file_1", makeRandomIncreasingValues(0, 185)},
+      {"data_file_2", makeRandomIncreasingValues(0, 100)}};
+  deleteFilesForBaseDatafiles["delete_file_2"] = {
+      {"data_file_1", makeRandomIncreasingValues(10, 120)},
+      {"data_file_2", makeRandomIncreasingValues(50, 100)}};
+  assertPositionalDeletes(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
+}
+
+TEST_F(HiveIcebergTest, positionalDeletesMultipleSplits) {
+  folly::SingletonVault::singleton()->registrationComplete();
+
+  assertMultipleSplits({1, 2, 3, 4}, 10, 5);
+  assertMultipleSplits({1, 2, 3, 4}, 10, 0);
+  assertMultipleSplits({1, 2, 3, 4}, 10, 10);
+  assertMultipleSplits({0, 9999, 10000, 19999}, 10, 3);
+  assertMultipleSplits(makeRandomIncreasingValues(0, 20000), 10, 3);
+  assertMultipleSplits(makeContinuousIncreasingValues(0, 20000), 10, 3);
+  assertMultipleSplits({}, 10, 3);
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp
new file mode 100644
index 0000000000000..e0b2a6c31f853
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp
@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h"
+#include <filesystem>
+#include "velox/exec/tests/utils/PrefixSortUtils.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::dwio;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwrf;
+using namespace facebook::velox::connector::hive;
+using namespace facebook::velox::connector::hive::iceberg;
+using namespace facebook::velox::memory;
+
+namespace facebook::velox::iceberg::reader::test {
+void IcebergSplitReaderBenchmark::writeToFile(
+    const std::vector<RowVectorPtr>& batches) {
+  auto path = fileFolder_->getPath() + "/" + fileName_;
+  auto localWriteFile = std::make_unique<LocalWriteFile>(path, true, false);
+  auto sink = std::make_unique<WriteFileSink>(std::move(localWriteFile), path);
+  dwrf::WriterOptions options;
+  options.memoryPool = rootPool_.get();
+  options.schema = batches[0]->type();
+  dwrf::Writer dataFilewriter{std::move(sink), options};
+  for (auto& batch : batches) {
+    dataFilewriter.write(batch);
+  }
+  dataFilewriter.flush();
+  dataFilewriter.close();
+}
+
+void IcebergSplitReaderBenchmark::writeToPositionDeleteFile(
+    const std::string& filePath,
+    const std::vector<RowVectorPtr>& vectors) {
+  auto localPosWriteFile =
+      std::make_unique<LocalWriteFile>(filePath, true, false);
+  auto posDeletesink =
+      std::make_unique<WriteFileSink>(std::move(localPosWriteFile), filePath);
+  dwrf::WriterOptions options;
+  options.memoryPool = rootPool_.get();
+  options.schema = vectors[0]->type();
+  dwrf::Writer posDeletewriter{std::move(posDeletesink), options};
+  for (size_t i = 0; i < vectors.size(); ++i) {
+    posDeletewriter.write(vectors[i]);
+  }
+  posDeletewriter.close();
+}
+
+std::vector<int64_t> IcebergSplitReaderBenchmark::makeRandomDeleteRows(
+    int32_t deleteRowsCount) {
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  int64_t totalDataRows = kNumBatches * kNumRowsPerBatch;
+  std::uniform_int_distribution<> dis(0, totalDataRows - 1);
+  std::set<int64_t> uniqueDeleteRows;
+  while (uniqueDeleteRows.size() < deleteRowsCount) {
+    uniqueDeleteRows.insert(dis(gen));
+  }
+  std::vector<int64_t> deleteRows(
+      uniqueDeleteRows.begin(), uniqueDeleteRows.end());
+  return deleteRows;
+}
+
+std::vector<int64_t> IcebergSplitReaderBenchmark::makeSequenceRows(
+    int32_t maxRowNumber) {
+  std::vector<int64_t> deleteRows;
+  deleteRows.resize(maxRowNumber);
+  std::iota(deleteRows.begin(), deleteRows.end(), 0);
+  return deleteRows;
+}
+
+std::vector<std::string> IcebergSplitReaderBenchmark::listFiles(
+    const std::string& dirPath) {
+  std::vector<std::string> files;
+  for (auto& dirEntry :
+       std::filesystem::recursive_directory_iterator(dirPath)) {
+    if (dirEntry.is_regular_file()) {
+      files.push_back(dirEntry.path().string());
+    }
+  }
+  return files;
+}
+
+std::shared_ptr<HiveConnectorSplit>
+IcebergSplitReaderBenchmark::makeIcebergSplit(
+    const std::string& dataFilePath,
+    const std::vector<IcebergDeleteFile>& deleteFiles) {
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+  std::unordered_map<std::string, std::string> customSplitInfo;
+  customSplitInfo["table_format"] = "hive-iceberg";
+
+  auto readFile = std::make_shared<LocalReadFile>(dataFilePath);
+  const int64_t fileSize = readFile->size();
+
+  return std::make_shared<HiveIcebergSplit>(
+      kHiveConnectorId,
+      dataFilePath,
+      fileFomat_,
+      0,
+      fileSize,
+      partitionKeys,
+      std::nullopt,
+      customSplitInfo,
+      nullptr,
+      deleteFiles);
+}
+
+std::string IcebergSplitReaderBenchmark::writePositionDeleteFile(
+    const std::string& dataFilePath,
+    int64_t numDeleteRows) {
+  facebook::velox::test::VectorMaker vectorMaker{leafPool_.get()};
+  auto filePathVector =
+      vectorMaker.flatVector<StringView>(numDeleteRows, [&](auto row) {
+        if (row < numDeleteRows) {
+          return StringView(dataFilePath);
+        } else {
+          return StringView();
+        }
+      });
+
+  std::vector<int64_t> deleteRowsVec;
+  deleteRowsVec.reserve(numDeleteRows);
+  auto deleteRows = makeRandomDeleteRows(numDeleteRows);
+  deleteRowsVec.insert(
+      deleteRowsVec.end(), deleteRows.begin(), deleteRows.end());
+
+  auto deletePositionsVector = vectorMaker.flatVector<int64_t>(deleteRowsVec);
+
+  std::shared_ptr<IcebergMetadataColumn> pathColumn =
+      IcebergMetadataColumn::icebergDeleteFilePathColumn();
+  std::shared_ptr<IcebergMetadataColumn> posColumn =
+      IcebergMetadataColumn::icebergDeletePosColumn();
+  RowVectorPtr deleteFileVectors = vectorMaker.rowVector(
+      {pathColumn->name, posColumn->name},
+      {filePathVector, deletePositionsVector});
+
+  auto deleteFilePath = deleteFileFolder_->getPath() + "/" + "posDelete.data";
+  writeToPositionDeleteFile(deleteFilePath, std::vector{deleteFileVectors});
+
+  return deleteFilePath;
+}
+
+std::vector<std::shared_ptr<HiveConnectorSplit>>
+IcebergSplitReaderBenchmark::createIcebergSplitsWithPositionalDelete(
+    int32_t deleteRowsPercentage,
+    int32_t deleteFilesCount) {
+  std::vector<std::shared_ptr<HiveConnectorSplit>> splits;
+
+  std::vector<std::string> deleteFilePaths;
+  std::vector<std::string> dataFilePaths = listFiles(fileFolder_->getPath());
+
+  for (const auto& dataFilePath : dataFilePaths) {
+    std::vector<IcebergDeleteFile> deleteFiles;
+    int64_t deleteRowsCount =
+        kNumBatches * kNumRowsPerBatch * deleteRowsPercentage * 0.01;
+    deleteFiles.reserve(deleteRowsCount);
+    for (int i = 0; i < deleteFilesCount; i++) {
+      std::string deleteFilePath =
+          writePositionDeleteFile(dataFilePath, deleteRowsCount);
+
+      IcebergDeleteFile deleteFile(
+          FileContent::kPositionalDeletes,
+          deleteFilePath,
+          fileFomat_,
+          deleteRowsCount,
+          testing::internal::GetFileSize(
+              std::fopen(deleteFilePath.c_str(), "r")));
+      deleteFilePaths.emplace_back(deleteFilePath);
+      deleteFiles.emplace_back(deleteFile);
+    }
+    splits.emplace_back(makeIcebergSplit(dataFilePath, deleteFiles));
+  }
+  return splits;
+}
+
+FilterSpec IcebergSplitReaderBenchmark::createFilterSpec(
+    const std::string& columnName,
+    float startPct,
+    float selectPct,
+    const TypePtr& type,
+    bool isForRowGroupSkip,
+    bool allowNulls) {
+  switch (type->childAt(0)->kind()) {
+    case TypeKind::BIGINT:
+    case TypeKind::INTEGER:
+      return FilterSpec(
+          columnName,
+          startPct,
+          selectPct,
+          FilterKind::kBigintRange,
+          isForRowGroupSkip,
+          allowNulls);
+    default:
+      VELOX_FAIL("Unsupported Data Type {}", type->childAt(0)->toString());
+  }
+  return FilterSpec(columnName, startPct, selectPct, FilterKind(), false);
+}
+
+std::shared_ptr<ScanSpec> IcebergSplitReaderBenchmark::createScanSpec(
+    const std::vector<RowVectorPtr>& batches,
+    RowTypePtr& rowType,
+    const std::vector<FilterSpec>& filterSpecs,
+    std::vector<uint64_t>& hitRows,
+    std::unordered_map<Subfield, std::unique_ptr<Filter>>& filters) {
+  std::unique_ptr<FilterGenerator> filterGenerator =
+      std::make_unique<FilterGenerator>(rowType, 0);
+  filters = filterGenerator->makeSubfieldFilters(
+      filterSpecs, batches, nullptr, hitRows);
+  auto scanSpec = filterGenerator->makeScanSpec(std::move(filters));
+  return scanSpec;
+}
+
+// This method is the place where we do the read operations using
+// icebergSplitReader. scanSpec contains the setting of filters. e.g.
+// filterRateX100 = 30 means it would filter out 70% of rows and 30% remain.
+// deleteRateX100 = 30 means it would delete 30% of overall data rows and 70%
+// remain. Return the number of rows after the filter and delete.
+int IcebergSplitReaderBenchmark::read(
+    const RowTypePtr& rowType,
+    uint32_t nextSize,
+    std::unique_ptr<IcebergSplitReader> icebergSplitReader) {
+  runtimeStats_ = RuntimeStatistics();
+  icebergSplitReader->resetFilterCaches();
+  int resultSize = 0;
+  auto result = BaseVector::create(rowType, 0, leafPool_.get());
+  while (true) {
+    bool hasData = icebergSplitReader->next(nextSize, result);
+    if (!hasData) {
+      break;
+    }
+    auto rowsRemaining = result->size();
+    resultSize += rowsRemaining;
+  }
+  icebergSplitReader->updateRuntimeStats(runtimeStats_);
+  return resultSize;
+}
+
+void IcebergSplitReaderBenchmark::readSingleColumn(
+    const std::string& columnName,
+    const TypePtr& type,
+    float startPct,
+    float selectPct,
+    float deletePct,
+    uint32_t nextSize) {
+  folly::BenchmarkSuspender suspender;
+  auto rowType = ROW({columnName}, {type});
+
+  auto batches =
+      dataSetBuilder_->makeDataset(rowType, kNumBatches, kNumRowsPerBatch)
+          .withRowGroupSpecificData(kNumRowsPerRowGroup)
+          .withNullsForField(Subfield(columnName), 0)
+          .build();
+  writeToFile(*batches);
+  std::vector<FilterSpec> filterSpecs;
+
+  filterSpecs.emplace_back(
+      createFilterSpec(columnName, startPct, selectPct, rowType, false, false));
+
+  std::vector<uint64_t> hitRows;
+  std::unordered_map<Subfield, std::unique_ptr<Filter>> filters;
+  auto scanSpec =
+      createScanSpec(*batches, rowType, filterSpecs, hitRows, filters);
+
+  std::vector<std::shared_ptr<HiveConnectorSplit>> splits =
+      createIcebergSplitsWithPositionalDelete(deletePct, 1);
+
+  core::TypedExprPtr remainingFilterExpr;
+
+  std::shared_ptr<HiveTableHandle> hiveTableHandle =
+      std::make_shared<HiveTableHandle>(
+          "kHiveConnectorId",
+          "tableName",
+          false,
+          std::move(filters),
+          remainingFilterExpr,
+          rowType);
+
+  std::shared_ptr<HiveConfig> hiveConfig =
+      std::make_shared<HiveConfig>(std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>(), true));
+  const RowTypePtr readerOutputType;
+  const std::shared_ptr<io::IoStatistics> ioStats =
+      std::make_shared<io::IoStatistics>();
+
+  std::shared_ptr<memory::MemoryPool> root =
+      memory::memoryManager()->addRootPool(
+          "IcebergSplitReader", kMaxMemory, MemoryReclaimer::create());
+  std::shared_ptr<memory::MemoryPool> opPool = root->addLeafChild("operator");
+  std::shared_ptr<memory::MemoryPool> connectorPool =
+      root->addAggregateChild(kHiveConnectorId, MemoryReclaimer::create());
+  std::shared_ptr<config::ConfigBase> connectorSessionProperties_ =
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>());
+
+  std::unique_ptr<connector::ConnectorQueryCtx> connectorQueryCtx_ =
+      std::make_unique<connector::ConnectorQueryCtx>(
+          opPool.get(),
+          connectorPool.get(),
+          connectorSessionProperties_.get(),
+          nullptr,
+          exec::test::defaultPrefixSortConfig(),
+          nullptr,
+          nullptr,
+          "query.IcebergSplitReader",
+          "task.IcebergSplitReader",
+          "planNodeId.IcebergSplitReader",
+          0,
+          "");
+
+  FileHandleFactory fileHandleFactory(
+      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(
+          hiveConfig->numCacheFileHandles()),
+      std::make_unique<FileHandleGenerator>(connectorSessionProperties_));
+
+  suspender.dismiss();
+
+  uint64_t resultSize = 0;
+  for (std::shared_ptr<HiveConnectorSplit> split : splits) {
+    scanSpec->resetCachedValues(true);
+    std::unique_ptr<IcebergSplitReader> icebergSplitReader =
+        std::make_unique<IcebergSplitReader>(
+            split,
+            hiveTableHandle,
+            nullptr,
+            connectorQueryCtx_.get(),
+            hiveConfig,
+            rowType,
+            ioStats,
+            &fileHandleFactory,
+            nullptr,
+            scanSpec);
+
+    std::shared_ptr<random::RandomSkipTracker> randomSkip;
+    icebergSplitReader->configureReaderOptions(randomSkip);
+    icebergSplitReader->prepareSplit(nullptr, runtimeStats_, nullptr);
+
+    // Filter range is generated from a small sample data of 4096 rows. So the
+    // upperBound and lowerBound are introduced to estimate the result size.
+    resultSize += read(rowType, nextSize, std::move(icebergSplitReader));
+  }
+  // Calculate the expected number of rows after the filters.
+  // Add one to expected to avoid 0 in calculating upperBound and lowerBound.
+  int expected = kNumBatches * kNumRowsPerBatch * ((double)selectPct / 100) *
+          (1 - (double)deletePct / 100) +
+      1;
+
+  // Make the upperBound and lowerBound large enough to avoid very small
+  // resultSize and expected size, where the diff ratio is relatively very
+  // large.
+  int upperBound = expected * (1 + kFilterErrorMargin) + 1;
+  int lowerBound = expected * (1 - kFilterErrorMargin) - 1;
+  upperBound = std::max(16, upperBound);
+  lowerBound = std::max(0, lowerBound);
+
+  VELOX_CHECK(
+      resultSize <= upperBound && resultSize >= lowerBound,
+      "Result Size {} and Expected Size {} Mismatch",
+      resultSize,
+      expected);
+}
+
+void run(
+    uint32_t,
+    const std::string& columnName,
+    const TypePtr& type,
+    float filterRateX100,
+    float deleteRateX100,
+    uint32_t nextSize) {
+  RowTypePtr rowType = ROW({columnName}, {type});
+  IcebergSplitReaderBenchmark benchmark;
+  BIGINT()->toString();
+  benchmark.readSingleColumn(
+      columnName, type, 0, filterRateX100, deleteRateX100, nextSize);
+}
+
+} // namespace facebook::velox::iceberg::reader::test
diff --git a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h
new file mode 100644
index 0000000000000..37b057e72dfa7
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
+#include "velox/connectors/hive/iceberg/IcebergMetadataColumns.h"
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+#include "velox/connectors/hive/iceberg/IcebergSplitReader.h"
+#include "velox/dwio/common/tests/utils/DataSetBuilder.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+namespace facebook::velox::iceberg::reader::test {
+
+constexpr uint32_t kNumRowsPerBatch = 20000;
+constexpr uint32_t kNumBatches = 50;
+constexpr uint32_t kNumRowsPerRowGroup = 10000;
+constexpr double kFilterErrorMargin = 0.2;
+
+class IcebergSplitReaderBenchmark {
+ public:
+  explicit IcebergSplitReaderBenchmark() {
+    rootPool_ =
+        memory::memoryManager()->addRootPool("IcebergSplitReaderBenchmark");
+    leafPool_ = rootPool_->addLeafChild("IcebergSplitReaderBenchmark");
+    dataSetBuilder_ =
+        std::make_unique<facebook::velox::test::DataSetBuilder>(*leafPool_, 0);
+    filesystems::registerLocalFileSystem();
+  }
+
+  ~IcebergSplitReaderBenchmark() {}
+
+  void writeToFile(const std::vector<RowVectorPtr>& batches);
+
+  void writeToPositionDeleteFile(
+      const std::string& filePath,
+      const std::vector<RowVectorPtr>& vectors);
+
+  dwio::common::FilterSpec createFilterSpec(
+      const std::string& columnName,
+      float startPct,
+      float selectPct,
+      const TypePtr& type,
+      bool isForRowGroupSkip,
+      bool allowNulls);
+
+  std::shared_ptr<dwio::common::ScanSpec> createScanSpec(
+      const std::vector<RowVectorPtr>& batches,
+      RowTypePtr& rowType,
+      const std::vector<dwio::common::FilterSpec>& filterSpecs,
+      std::vector<uint64_t>& hitRows,
+      std::unordered_map<
+          facebook::velox::common::Subfield,
+          std::unique_ptr<facebook::velox::common::Filter>>& filters);
+
+  int read(
+      const RowTypePtr& rowType,
+      uint32_t nextSize,
+      std::unique_ptr<connector::hive::iceberg::IcebergSplitReader>
+          icebergSplitReader);
+
+  void readSingleColumn(
+      const std::string& columnName,
+      const TypePtr& type,
+      float startPct,
+      float selectPct,
+      float deleteRate,
+      uint32_t nextSize);
+
+  std::vector<std::shared_ptr<connector::hive::HiveConnectorSplit>>
+  createIcebergSplitsWithPositionalDelete(
+      int32_t deleteRowsPercentage,
+      int32_t deleteFilesCount);
+
+  std::vector<std::string> listFiles(const std::string& dirPath);
+
+  std::shared_ptr<connector::hive::HiveConnectorSplit> makeIcebergSplit(
+      const std::string& dataFilePath,
+      const std::vector<connector::hive::iceberg::IcebergDeleteFile>&
+          deleteFiles = {});
+
+  std::vector<int64_t> makeRandomDeleteRows(int32_t deleteRowsCount);
+
+  std::vector<int64_t> makeSequenceRows(int32_t maxRowNumber);
+
+  std::string writePositionDeleteFile(
+      const std::string& dataFilePath,
+      int64_t numDeleteRows);
+
+ private:
+  const std::string fileName_ = "test.data";
+  const std::shared_ptr<exec::test::TempDirectoryPath> fileFolder_ =
+      exec::test::TempDirectoryPath::create();
+  const std::shared_ptr<exec::test::TempDirectoryPath> deleteFileFolder_ =
+      exec::test::TempDirectoryPath::create();
+
+  std::unique_ptr<facebook::velox::test::DataSetBuilder> dataSetBuilder_;
+  std::shared_ptr<memory::MemoryPool> rootPool_;
+  std::shared_ptr<memory::MemoryPool> leafPool_;
+  std::unique_ptr<dwrf::Writer> writer_;
+  dwio::common::RuntimeStatistics runtimeStats_;
+
+  dwio::common::FileFormat fileFomat_{dwio::common::FileFormat::DWRF};
+  const std::string kHiveConnectorId = "hive-iceberg";
+};
+
+void run(
+    uint32_t,
+    const std::string& columnName,
+    const TypePtr& type,
+    float filterRateX100,
+    float deleteRateX100,
+    uint32_t nextSize);
+
+} // namespace facebook::velox::iceberg::reader::test
diff --git a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmarkMain.cpp b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmarkMain.cpp
new file mode 100644
index 0000000000000..2efb3700bd233
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmarkMain.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::dwio;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwrf;
+using namespace facebook::velox::iceberg::reader::test;
+using namespace facebook::velox::test;
+
+#define PARQUET_BENCHMARKS_FILTER_DELETES(_type_, _name_, _filter_, _deletes_) \
+  BENCHMARK_NAMED_PARAM(                                                       \
+      run,                                                                     \
+      _name_##_Filter_##_filter_##_Delete_##_deletes_##_next_5k,               \
+      #_name_,                                                                 \
+      _type_,                                                                  \
+      _filter_,                                                                \
+      _deletes_,                                                               \
+      5000);                                                                   \
+  BENCHMARK_NAMED_PARAM(                                                       \
+      run,                                                                     \
+      _name_##_Filter_##_filter_##_Delete_##_deletes_##_next_10k,              \
+      #_name_,                                                                 \
+      _type_,                                                                  \
+      _filter_,                                                                \
+      _deletes_,                                                               \
+      10000);                                                                  \
+  BENCHMARK_DRAW_LINE();
+
+#define PARQUET_BENCHMARKS_FILTERS(_type_, _name_, _filter_)      \
+  PARQUET_BENCHMARKS_FILTER_DELETES(_type_, _name_, _filter_, 0)  \
+  PARQUET_BENCHMARKS_FILTER_DELETES(_type_, _name_, _filter_, 20) \
+  PARQUET_BENCHMARKS_FILTER_DELETES(_type_, _name_, _filter_, 50) \
+  PARQUET_BENCHMARKS_FILTER_DELETES(_type_, _name_, _filter_, 70) \
+  PARQUET_BENCHMARKS_FILTER_DELETES(_type_, _name_, _filter_, 100)
+
+#define PARQUET_BENCHMARKS(_type_, _name_)        \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 0)   \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 20)  \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 50)  \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 70)  \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 100) \
+  BENCHMARK_DRAW_LINE();
+
+PARQUET_BENCHMARKS(BIGINT(), BigInt);
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmarkTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmarkTest.cpp
new file mode 100644
index 0000000000000..d8d0f99fe8b89
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmarkTest.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h"
+#include <gtest/gtest.h>
+
+namespace facebook::velox::iceberg::reader::test {
+namespace {
+TEST(IcebergSplitReaderBenchmarkTest, basic) {
+  memory::MemoryManager::testingSetInstance({});
+  run(1, "BigInt", BIGINT(), 20, 0, 500);
+  run(1, "BigInt", BIGINT(), 50, 20, 500);
+  run(1, "BigInt", BIGINT(), 100, 20, 500);
+  run(1, "BigInt", BIGINT(), 100, 100, 500);
+}
+} // namespace
+} // namespace facebook::velox::iceberg::reader::test
diff --git a/velox/connectors/hive/storage_adapters/CMakeLists.txt b/velox/connectors/hive/storage_adapters/CMakeLists.txt
index 9c2e046a0b870..bd7c37f816405 100644
--- a/velox/connectors/hive/storage_adapters/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/CMakeLists.txt
@@ -15,3 +15,4 @@
 add_subdirectory(s3fs)
 add_subdirectory(hdfs)
 add_subdirectory(gcs)
+add_subdirectory(abfs)
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.cpp
new file mode 100644
index 0000000000000..681d26b35e768
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.cpp
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h"
+
+#include <azure/storage/blobs/blob_client.hpp>
+#include <fmt/format.h>
+#include <folly/executors/IOThreadPoolExecutor.h>
+#include <glog/logging.h>
+
+#include "velox/common/config/Config.h"
+#include "velox/common/file/File.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h"
+
+namespace facebook::velox::filesystems::abfs {
+using namespace Azure::Storage::Blobs;
+
+class AbfsConfig {
+ public:
+  AbfsConfig(const config::ConfigBase* config) : config_(config) {}
+
+  std::string connectionString(const std::string& path) const {
+    auto abfsAccount = AbfsAccount(path);
+    auto key = abfsAccount.credKey();
+    VELOX_USER_CHECK(
+        config_->valueExists(key), "Failed to find storage credentials");
+
+    return abfsAccount.connectionString(config_->get<std::string>(key).value());
+  }
+
+ private:
+  const config::ConfigBase* config_;
+};
+
+class AbfsReadFile::Impl {
+  constexpr static uint64_t kNaturalReadSize = 4 << 20; // 4M
+  constexpr static uint64_t kReadConcurrency = 8;
+
+ public:
+  explicit Impl(const std::string& path, const std::string& connectStr) {
+    auto abfsAccount = AbfsAccount(path);
+    fileName_ = abfsAccount.filePath();
+    fileClient_ =
+        std::make_unique<BlobClient>(BlobClient::CreateFromConnectionString(
+            connectStr, abfsAccount.fileSystem(), fileName_));
+  }
+
+  void initialize(const FileOptions& options) {
+    if (options.fileSize.has_value()) {
+      VELOX_CHECK_GE(
+          options.fileSize.value(), 0, "File size must be non-negative");
+      length_ = options.fileSize.value();
+    }
+
+    if (length_ != -1) {
+      return;
+    }
+
+    try {
+      auto properties = fileClient_->GetProperties();
+      length_ = properties.Value.BlobSize;
+    } catch (Azure::Storage::StorageException& e) {
+      throwStorageExceptionWithOperationDetails("GetProperties", fileName_, e);
+    }
+
+    VELOX_CHECK_GE(length_, 0);
+  }
+
+  std::string_view pread(uint64_t offset, uint64_t length, void* buffer) const {
+    preadInternal(offset, length, static_cast<char*>(buffer));
+    return {static_cast<char*>(buffer), length};
+  }
+
+  std::string pread(uint64_t offset, uint64_t length) const {
+    std::string result(length, 0);
+    preadInternal(offset, length, result.data());
+    return result;
+  }
+
+  uint64_t preadv(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers) const {
+    size_t length = 0;
+    auto size = buffers.size();
+    for (auto& range : buffers) {
+      length += range.size();
+    }
+    std::string result(length, 0);
+    preadInternal(offset, length, static_cast<char*>(result.data()));
+    size_t resultOffset = 0;
+    for (auto range : buffers) {
+      if (range.data()) {
+        memcpy(range.data(), &(result.data()[resultOffset]), range.size());
+      }
+      resultOffset += range.size();
+    }
+
+    return length;
+  }
+
+  uint64_t preadv(
+      folly::Range<const common::Region*> regions,
+      folly::Range<folly::IOBuf*> iobufs) const {
+    size_t length = 0;
+    VELOX_CHECK_EQ(regions.size(), iobufs.size());
+    for (size_t i = 0; i < regions.size(); ++i) {
+      const auto& region = regions[i];
+      auto& output = iobufs[i];
+      output = folly::IOBuf(folly::IOBuf::CREATE, region.length);
+      pread(region.offset, region.length, output.writableData());
+      output.append(region.length);
+      length += region.length;
+    }
+
+    return length;
+  }
+
+  uint64_t size() const {
+    return length_;
+  }
+
+  uint64_t memoryUsage() const {
+    return 3 * sizeof(std::string) + sizeof(int64_t);
+  }
+
+  bool shouldCoalesce() const {
+    return false;
+  }
+
+  std::string getName() const {
+    return fileName_;
+  }
+
+  uint64_t getNaturalReadSize() const {
+    return kNaturalReadSize;
+  }
+
+ private:
+  void preadInternal(uint64_t offset, uint64_t length, char* position) const {
+    // Read the desired range of bytes.
+    Azure::Core::Http::HttpRange range;
+    range.Offset = offset;
+    range.Length = length;
+
+    Azure::Storage::Blobs::DownloadBlobOptions blob;
+    blob.Range = range;
+
+    auto response = fileClient_->Download(blob);
+    response.Value.BodyStream->ReadToCount(
+        reinterpret_cast<uint8_t*>(position), length);
+  }
+
+  std::string fileName_;
+  std::unique_ptr<BlobClient> fileClient_;
+
+  int64_t length_ = -1;
+};
+
+AbfsReadFile::AbfsReadFile(
+    const std::string& path,
+    const std::string& connectStr) {
+  impl_ = std::make_shared<Impl>(path, connectStr);
+}
+
+void AbfsReadFile::initialize(const FileOptions& options) {
+  return impl_->initialize(options);
+}
+
+std::string_view
+AbfsReadFile::pread(uint64_t offset, uint64_t length, void* buffer) const {
+  return impl_->pread(offset, length, buffer);
+}
+
+std::string AbfsReadFile::pread(uint64_t offset, uint64_t length) const {
+  return impl_->pread(offset, length);
+}
+
+uint64_t AbfsReadFile::preadv(
+    uint64_t offset,
+    const std::vector<folly::Range<char*>>& buffers) const {
+  return impl_->preadv(offset, buffers);
+}
+
+uint64_t AbfsReadFile::preadv(
+    folly::Range<const common::Region*> regions,
+    folly::Range<folly::IOBuf*> iobufs) const {
+  return impl_->preadv(regions, iobufs);
+}
+
+uint64_t AbfsReadFile::size() const {
+  return impl_->size();
+}
+
+uint64_t AbfsReadFile::memoryUsage() const {
+  return impl_->memoryUsage();
+}
+
+bool AbfsReadFile::shouldCoalesce() const {
+  return false;
+}
+
+std::string AbfsReadFile::getName() const {
+  return impl_->getName();
+}
+
+uint64_t AbfsReadFile::getNaturalReadSize() const {
+  return impl_->getNaturalReadSize();
+}
+
+class AbfsFileSystem::Impl {
+ public:
+  explicit Impl(const config::ConfigBase* config) : abfsConfig_(config) {
+    LOG(INFO) << "Init Azure Blob file system";
+  }
+
+  ~Impl() {
+    LOG(INFO) << "Dispose Azure Blob file system";
+  }
+
+  const std::string connectionString(const std::string& path) const {
+    // Extract account name
+    return abfsConfig_.connectionString(path);
+  }
+
+ private:
+  const AbfsConfig abfsConfig_;
+  std::shared_ptr<folly::Executor> ioExecutor_;
+};
+
+AbfsFileSystem::AbfsFileSystem(
+    const std::shared_ptr<const config::ConfigBase>& config)
+    : FileSystem(config) {
+  impl_ = std::make_shared<Impl>(config.get());
+}
+
+std::string AbfsFileSystem::name() const {
+  return "ABFS";
+}
+
+std::unique_ptr<ReadFile> AbfsFileSystem::openFileForRead(
+    std::string_view path,
+    const FileOptions& options) {
+  auto abfsfile = std::make_unique<AbfsReadFile>(
+      std::string(path), impl_->connectionString(std::string(path)));
+  abfsfile->initialize(options);
+  return abfsfile;
+}
+
+std::unique_ptr<WriteFile> AbfsFileSystem::openFileForWrite(
+    std::string_view path,
+    const FileOptions& /*unused*/) {
+  auto abfsfile = std::make_unique<AbfsWriteFile>(
+      std::string(path), impl_->connectionString(std::string(path)));
+  abfsfile->initialize();
+  return abfsfile;
+}
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h b/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h
new file mode 100644
index 0000000000000..319a85b7a382c
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+
+namespace facebook::velox::filesystems::abfs {
+
+/// Implementation of the ABS (Azure Blob Storage) filesystem and file
+/// interface. We provide a registration method for reading and writing files so
+/// that the appropriate type of file can be constructed based on a filename.
+/// The supported schema is `abfs(s)://` to align with the valid scheme
+/// identifiers used in the Hadoop Filesystem ABFS driver when integrating with
+/// Azure Blob Storage. One key difference here is that the ABFS Hadoop client
+/// driver always uses Transport Layer Security (TLS) regardless of the
+/// authentication method chosen when using the `abfss` schema, but not mandated
+/// when using the `abfs` schema. In our implementation, we always use the HTTPS
+/// protocol, regardless of whether the schema is `abfs://` or `abfss://`. The
+/// legacy wabs(s):// schema is not supported as it has been deprecated already
+/// by Azure Storage team. Reference document -
+/// https://learn.microsoft.com/en-us/azure/databricks/storage/azure-storage.
+class AbfsFileSystem : public FileSystem {
+ public:
+  explicit AbfsFileSystem(
+      const std::shared_ptr<const config::ConfigBase>& config);
+
+  std::string name() const override;
+
+  std::unique_ptr<ReadFile> openFileForRead(
+      std::string_view path,
+      const FileOptions& options = {}) override;
+
+  std::unique_ptr<WriteFile> openFileForWrite(
+      std::string_view path,
+      const FileOptions& options = {}) override;
+
+  void rename(
+      std::string_view path,
+      std::string_view newPath,
+      bool overWrite = false) override {
+    VELOX_UNSUPPORTED("rename for abfs not implemented");
+  }
+
+  void remove(std::string_view path) override {
+    VELOX_UNSUPPORTED("remove for abfs not implemented");
+  }
+
+  bool exists(std::string_view path) override {
+    VELOX_UNSUPPORTED("exists for abfs not implemented");
+  }
+
+  std::vector<std::string> list(std::string_view path) override {
+    VELOX_UNSUPPORTED("list for abfs not implemented");
+  }
+
+  void mkdir(std::string_view path) override {
+    VELOX_UNSUPPORTED("mkdir for abfs not implemented");
+  }
+
+  void rmdir(std::string_view path) override {
+    VELOX_UNSUPPORTED("rmdir for abfs not implemented");
+  }
+
+ protected:
+  class Impl;
+  std::shared_ptr<Impl> impl_;
+};
+
+void registerAbfsFileSystem();
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h
new file mode 100644
index 0000000000000..d7c0374d1651e
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/executors/ThreadedExecutor.h>
+#include <folly/futures/Future.h>
+#include "velox/common/file/File.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+
+namespace facebook::velox::filesystems::abfs {
+class AbfsReadFile final : public ReadFile {
+ public:
+  explicit AbfsReadFile(const std::string& path, const std::string& connectStr);
+
+  void initialize(const FileOptions& options);
+
+  std::string_view pread(uint64_t offset, uint64_t length, void* buf)
+      const final;
+
+  std::string pread(uint64_t offset, uint64_t length) const final;
+
+  uint64_t preadv(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers) const final;
+
+  uint64_t preadv(
+      folly::Range<const common::Region*> regions,
+      folly::Range<folly::IOBuf*> iobufs) const final;
+
+  uint64_t size() const final;
+
+  uint64_t memoryUsage() const final;
+
+  bool shouldCoalesce() const final;
+
+  std::string getName() const final;
+
+  uint64_t getNaturalReadSize() const final;
+
+ protected:
+  class Impl;
+  std::shared_ptr<Impl> impl_;
+};
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h
new file mode 100644
index 0000000000000..2af0f42390095
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <azure/storage/common/storage_exception.hpp>
+#include "velox/common/file/File.h"
+
+#include <fmt/format.h>
+#include <regex>
+
+namespace facebook::velox::filesystems::abfs {
+namespace {
+constexpr std::string_view kAbfsScheme{"abfs://"};
+constexpr std::string_view kAbfssScheme{"abfss://"};
+} // namespace
+
+inline bool isAbfsFile(const std::string_view filename) {
+  return filename.find(kAbfsScheme) == 0 || filename.find(kAbfssScheme) == 0;
+}
+
+class AbfsAccount {
+ public:
+  explicit AbfsAccount(const std::string path);
+
+  const std::string accountNameWithSuffix() const;
+
+  const std::string scheme() const;
+
+  const std::string accountName() const;
+
+  const std::string endpointSuffix() const;
+
+  const std::string fileSystem() const;
+
+  const std::string filePath() const;
+
+  const std::string credKey() const;
+
+  const std::string connectionString(const std::string accountKey) const;
+
+ private:
+  std::string scheme_;
+  std::string accountName_;
+  std::string endpointSuffix_;
+  std::string accountNameWithSuffix_;
+  std::string fileSystem_;
+  std::string filePath_;
+  std::string path_;
+  std::string credKey_;
+};
+
+inline const std::string throwStorageExceptionWithOperationDetails(
+    std::string operation,
+    std::string path,
+    Azure::Storage::StorageException& error) {
+  const auto errMsg = fmt::format(
+      "Operation '{}' to path '{}' encountered azure storage exception, Details: '{}'.",
+      operation,
+      path,
+      error.what());
+  if (error.StatusCode == Azure::Core::Http::HttpStatusCode::NotFound) {
+    VELOX_FILE_NOT_FOUND_ERROR(errMsg);
+  }
+  VELOX_FAIL(errMsg);
+}
+
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsUtils.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsUtils.cpp
new file mode 100644
index 0000000000000..700cfd915bbff
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsUtils.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+
+namespace facebook::velox::filesystems::abfs {
+AbfsAccount::AbfsAccount(const std::string path) {
+  auto file = std::string("");
+  if (path.find(kAbfssScheme) == 0) {
+    file = std::string(path.substr(8));
+    scheme_ = kAbfssScheme.substr(0, 5);
+  } else {
+    file = std::string(path.substr(7));
+    scheme_ = kAbfsScheme.substr(0, 4);
+  }
+
+  auto firstAt = file.find_first_of("@");
+  fileSystem_ = std::string(file.substr(0, firstAt));
+  auto firstSep = file.find_first_of("/");
+  filePath_ = std::string(file.substr(firstSep + 1));
+
+  accountNameWithSuffix_ = file.substr(firstAt + 1, firstSep - firstAt - 1);
+  auto firstDot = accountNameWithSuffix_.find_first_of(".");
+  accountName_ = accountNameWithSuffix_.substr(0, firstDot);
+  endpointSuffix_ = accountNameWithSuffix_.substr(firstDot + 5);
+  credKey_ = fmt::format("fs.azure.account.key.{}", accountNameWithSuffix_);
+}
+
+const std::string AbfsAccount::accountNameWithSuffix() const {
+  return accountNameWithSuffix_;
+}
+
+const std::string AbfsAccount::scheme() const {
+  return scheme_;
+}
+
+const std::string AbfsAccount::accountName() const {
+  return accountName_;
+}
+
+const std::string AbfsAccount::endpointSuffix() const {
+  return endpointSuffix_;
+}
+
+const std::string AbfsAccount::fileSystem() const {
+  return fileSystem_;
+}
+
+const std::string AbfsAccount::filePath() const {
+  return filePath_;
+}
+
+const std::string AbfsAccount::credKey() const {
+  return credKey_;
+}
+
+const std::string AbfsAccount::connectionString(
+    const std::string accountKey) const {
+  return fmt::format(
+      "DefaultEndpointsProtocol=https;AccountName={};AccountKey={};EndpointSuffix={}",
+      accountName(),
+      accountKey,
+      endpointSuffix());
+}
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.cpp
new file mode 100644
index 0000000000000..1e390ea729e4e
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h"
+
+#include <azure/storage/files/datalake.hpp>
+
+namespace facebook::velox::filesystems::abfs {
+class BlobStorageFileClient final : public IBlobStorageFileClient {
+ public:
+  BlobStorageFileClient(std::unique_ptr<DataLakeFileClient> client)
+      : client_(std::move(client)) {}
+
+  void create() override {
+    client_->Create();
+  }
+
+  PathProperties getProperties() override {
+    return client_->GetProperties().Value;
+  }
+
+  void append(const uint8_t* buffer, size_t size, uint64_t offset) override {
+    auto bodyStream = Azure::Core::IO::MemoryBodyStream(buffer, size);
+    client_->Append(bodyStream, offset);
+  }
+
+  void flush(uint64_t position) override {
+    client_->Flush(position);
+  }
+
+  void close() override {
+    // do nothing.
+  }
+
+ private:
+  const std::unique_ptr<DataLakeFileClient> client_;
+};
+
+class AbfsWriteFile::Impl {
+ public:
+  explicit Impl(const std::string& path, const std::string& connectStr)
+      : path_(path), connectStr_(connectStr) {
+    // Make it a no-op if invoked twice.
+    if (position_ != -1) {
+      return;
+    }
+    position_ = 0;
+  }
+
+  void initialize() {
+    if (!blobStorageFileClient_) {
+      auto abfsAccount = AbfsAccount(path_);
+      blobStorageFileClient_ = std::make_unique<BlobStorageFileClient>(
+          std::make_unique<DataLakeFileClient>(
+              DataLakeFileClient::CreateFromConnectionString(
+                  connectStr_,
+                  abfsAccount.fileSystem(),
+                  abfsAccount.filePath())));
+    }
+
+    VELOX_CHECK(!checkIfFileExists(), "File already exists");
+    blobStorageFileClient_->create();
+  }
+
+  void testingSetFileClient(
+      const std::shared_ptr<IBlobStorageFileClient>& blobStorageManager) {
+    blobStorageFileClient_ = blobStorageManager;
+  }
+
+  void close() {
+    if (!closed_) {
+      flush();
+      blobStorageFileClient_->close();
+      closed_ = true;
+    }
+  }
+
+  void flush() {
+    if (!closed_) {
+      blobStorageFileClient_->flush(position_);
+    }
+  }
+
+  void append(std::string_view data) {
+    VELOX_CHECK(!closed_, "File is not open");
+    if (data.size() == 0) {
+      return;
+    }
+    append(data.data(), data.size());
+  }
+
+  uint64_t size() const {
+    return blobStorageFileClient_->getProperties().FileSize;
+  }
+
+  void append(const char* buffer, size_t size) {
+    blobStorageFileClient_->append(
+        reinterpret_cast<const uint8_t*>(buffer), size, position_);
+    position_ += size;
+  }
+
+ private:
+  bool checkIfFileExists() {
+    try {
+      blobStorageFileClient_->getProperties();
+      return true;
+    } catch (Azure::Storage::StorageException& e) {
+      if (e.StatusCode != Azure::Core::Http::HttpStatusCode::NotFound) {
+        throwStorageExceptionWithOperationDetails("GetProperties", path_, e);
+      }
+      return false;
+    }
+  }
+
+  const std::string path_;
+  const std::string connectStr_;
+  std::string fileSystem_;
+  std::string fileName_;
+  std::shared_ptr<IBlobStorageFileClient> blobStorageFileClient_;
+
+  uint64_t position_ = -1;
+  bool closed_ = false;
+};
+
+AbfsWriteFile::AbfsWriteFile(
+    const std::string& path,
+    const std::string& connectStr) {
+  impl_ = std::make_shared<Impl>(path, connectStr);
+}
+
+void AbfsWriteFile::initialize() {
+  impl_->initialize();
+}
+
+void AbfsWriteFile::close() {
+  impl_->close();
+}
+
+void AbfsWriteFile::flush() {
+  impl_->flush();
+}
+
+void AbfsWriteFile::append(std::string_view data) {
+  impl_->append(data);
+}
+
+uint64_t AbfsWriteFile::size() const {
+  return impl_->size();
+}
+
+void AbfsWriteFile::testingSetFileClient(
+    const std::shared_ptr<IBlobStorageFileClient>& fileClient) {
+  impl_->testingSetFileClient(fileClient);
+}
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h b/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h
new file mode 100644
index 0000000000000..acb701ac91ff9
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/file/File.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+
+namespace Azure::Storage::Files::DataLake::Models {
+class PathProperties;
+}
+
+namespace facebook::velox::filesystems::abfs {
+using namespace Azure::Storage::Files::DataLake;
+using namespace Azure::Storage::Files::DataLake::Models;
+
+/*
+ * We are using the DFS (Data Lake Storage) endpoint for Azure Blob File write
+ * operations because the DFS endpoint is designed to be compatible with file
+ * operation semantics, such as `Append` to a file and file `Flush` operations.
+ * The legacy Blob endpoint can only be used for blob level append and flush
+ * operations. When using the Blob endpoint, we would need to manually manage
+ * the creation, appending, and committing of file-related blocks.
+ *
+ * However, the Azurite Simulator does not yet support the DFS endpoint.
+ * (For more information, see https://github.com/Azure/Azurite/issues/553 and
+ * https://github.com/Azure/Azurite/issues/409).
+ * You can find a comparison between DFS and Blob endpoints here:
+ * https://github.com/Azure/Azurite/wiki/ADLS-Gen2-Implementation-Guidance
+ *
+ * To facilitate unit testing of file write scenarios, we define the
+ * IBlobStorageFileClient here, which can be mocked during testing.
+ */
+class IBlobStorageFileClient {
+ public:
+  virtual ~IBlobStorageFileClient() {}
+
+  virtual void create() = 0;
+  virtual PathProperties getProperties() = 0;
+  virtual void append(const uint8_t* buffer, size_t size, uint64_t offset) = 0;
+  virtual void flush(uint64_t position) = 0;
+  virtual void close() = 0;
+};
+
+/// Implementation of abfs write file. Nothing written to the file should be
+/// read back until it is closed.
+class AbfsWriteFile : public WriteFile {
+ public:
+  constexpr static uint64_t kNaturalWriteSize = 8 << 20; // 8M
+  /// The constructor.
+  /// @param path The file path to write.
+  /// @param connectStr the connection string used to auth the storage account.
+  AbfsWriteFile(const std::string& path, const std::string& connectStr);
+
+  /// check any issue reading file.
+  void initialize();
+
+  /// Get the file size.
+  uint64_t size() const override;
+
+  /// Flush the data.
+  void flush() override;
+
+  /// Write the data by append mode.
+  void append(std::string_view data) override;
+
+  /// Close the file.
+  void close() override;
+
+  /// Used by tests to override the FileSystem client.
+  void testingSetFileClient(
+      const std::shared_ptr<IBlobStorageFileClient>& fileClient);
+
+ protected:
+  class Impl;
+  std::shared_ptr<Impl> impl_;
+};
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt
new file mode 100644
index 0000000000000..ec71a1353ccdd
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt
@@ -0,0 +1,41 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# for generated headers
+
+velox_add_library(velox_abfs RegisterAbfsFileSystem.cpp)
+
+if(VELOX_ENABLE_ABFS)
+  velox_sources(
+    velox_abfs
+    PRIVATE
+    AbfsFileSystem.cpp
+    AbfsUtils.cpp
+    AbfsWriteFile.cpp)
+  velox_link_libraries(
+    velox_abfs
+    PUBLIC velox_file
+           velox_core
+           velox_hive_config
+           velox_dwio_common_exception
+           Azure::azure-storage-blobs
+           Azure::azure-storage-files-datalake
+           Folly::folly
+           glog::glog
+           fmt::fmt)
+
+  if(${VELOX_BUILD_TESTING})
+    add_subdirectory(tests)
+  endif()
+endif()
diff --git a/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp
new file mode 100644
index 0000000000000..a8b0df52a6dba
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef VELOX_ENABLE_ABFS
+#include "velox/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h" // @manual
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h" // @manual
+#endif
+
+namespace facebook::velox::filesystems::abfs {
+
+#ifdef VELOX_ENABLE_ABFS
+folly::once_flag abfsInitiationFlag;
+
+std::shared_ptr<FileSystem> abfsFileSystemGenerator(
+    std::shared_ptr<const config::ConfigBase> properties,
+    std::string_view filePath) {
+  static std::shared_ptr<FileSystem> filesystem;
+  folly::call_once(abfsInitiationFlag, [&properties]() {
+    filesystem = std::make_shared<AbfsFileSystem>(properties);
+  });
+  return filesystem;
+}
+#endif
+
+void registerAbfsFileSystem() {
+#ifdef VELOX_ENABLE_ABFS
+  LOG(INFO) << "Register ABFS";
+  registerFileSystem(isAbfsFile, std::function(abfsFileSystemGenerator));
+#endif
+}
+
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h
new file mode 100644
index 0000000000000..e725e084fa3ed
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace facebook::velox::filesystems::abfs {
+
+// Register the ABFS filesystem.
+void registerAbfsFileSystem();
+
+} // namespace facebook::velox::filesystems::abfs
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp
new file mode 100644
index 0000000000000..926f064ce28e4
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <atomic>
+#include <filesystem>
+#include <random>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h"
+#include "velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h"
+#include "velox/connectors/hive/storage_adapters/abfs/tests/MockBlobStorageFileClient.h"
+#include "velox/exec/tests/utils/PortUtil.h"
+#include "velox/exec/tests/utils/TempFilePath.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::filesystems;
+using namespace facebook::velox::filesystems::abfs;
+using ::facebook::velox::common::Region;
+
+constexpr int kOneMB = 1 << 20;
+static const std::string filePath = "test_file.txt";
+static const std::string fullFilePath =
+    filesystems::test::AzuriteABFSEndpoint + filePath;
+
+class AbfsFileSystemTest : public testing::Test {
+ public:
+  static std::shared_ptr<const config::ConfigBase> hiveConfig(
+      const std::unordered_map<std::string, std::string> configOverride = {}) {
+    std::unordered_map<std::string, std::string> config({});
+
+    // Update the default config map with the supplied configOverride map
+    for (const auto& item : configOverride) {
+      config[item.first] = item.second;
+      std::cout << "config " + item.first + " value " + item.second
+                << std::endl;
+    }
+
+    return std::make_shared<const config::ConfigBase>(std::move(config));
+  }
+
+ public:
+  std::shared_ptr<filesystems::test::AzuriteServer> azuriteServer;
+
+  static void SetUpTestCase() {
+    registerAbfsFileSystem();
+  }
+
+  void SetUp() override {
+    auto port = facebook::velox::exec::test::getFreePort();
+    azuriteServer = std::make_shared<filesystems::test::AzuriteServer>(port);
+    azuriteServer->start();
+    auto tempFile = createFile();
+    azuriteServer->addFile(tempFile->getPath(), filePath);
+  }
+
+  void TearDown() override {
+    azuriteServer->stop();
+  }
+
+  std::unique_ptr<WriteFile> openFileForWrite(
+      std::string_view path,
+      std::shared_ptr<filesystems::test::MockBlobStorageFileClient> client) {
+    auto abfsfile = std::make_unique<AbfsWriteFile>(
+        std::string(path), azuriteServer->connectionStr());
+    abfsfile->testingSetFileClient(client);
+    abfsfile->initialize();
+    return abfsfile;
+  }
+
+  static std::string generateRandomData(int size) {
+    static const char charset[] =
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+    std::string data(size, ' ');
+
+    for (int i = 0; i < size; ++i) {
+      int index = rand() % (sizeof(charset) - 1);
+      data[i] = charset[index];
+    }
+
+    return data;
+  }
+
+ private:
+  static std::shared_ptr<::exec::test::TempFilePath> createFile(
+      uint64_t size = -1) {
+    auto tempFile = exec::test::TempFilePath::create();
+    if (size == -1) {
+      tempFile->append("aaaaa");
+      tempFile->append("bbbbb");
+      tempFile->append(std::string(kOneMB, 'c'));
+      tempFile->append("ddddd");
+    } else {
+      const uint64_t totalSize = size * 1024 * 1024;
+      const uint64_t chunkSize = 5 * 1024 * 1024;
+      uint64_t remainingSize = totalSize;
+      while (remainingSize > 0) {
+        uint64_t dataSize = std::min(remainingSize, chunkSize);
+        std::string randomData = generateRandomData(dataSize);
+        tempFile->append(randomData);
+        remainingSize -= dataSize;
+      }
+    }
+    return tempFile;
+  }
+};
+
+void readData(ReadFile* readFile) {
+  ASSERT_EQ(readFile->size(), 15 + kOneMB);
+  char buffer1[5];
+  ASSERT_EQ(readFile->pread(10 + kOneMB, 5, &buffer1), "ddddd");
+  char buffer2[10];
+  ASSERT_EQ(readFile->pread(0, 10, &buffer2), "aaaaabbbbb");
+  auto buffer3 = new char[kOneMB];
+  ASSERT_EQ(readFile->pread(10, kOneMB, buffer3), std::string(kOneMB, 'c'));
+  delete[] buffer3;
+  ASSERT_EQ(readFile->size(), 15 + kOneMB);
+  char buffer4[10];
+  const std::string_view arf = readFile->pread(5, 10, &buffer4);
+  const std::string zarf = readFile->pread(kOneMB, 15);
+  auto buf = std::make_unique<char[]>(8);
+  const std::string_view warf = readFile->pread(4, 8, buf.get());
+  const std::string_view warfFromBuf(buf.get(), 8);
+  ASSERT_EQ(arf, "bbbbbccccc");
+  ASSERT_EQ(zarf, "ccccccccccddddd");
+  ASSERT_EQ(warf, "abbbbbcc");
+  ASSERT_EQ(warfFromBuf, "abbbbbcc");
+
+  char buff1[10];
+  char buff2[10];
+  std::vector<folly::Range<char*>> buffers = {
+      folly::Range<char*>(buff1, 10),
+      folly::Range<char*>(nullptr, kOneMB - 5),
+      folly::Range<char*>(buff2, 10)};
+  ASSERT_EQ(10 + kOneMB - 5 + 10, readFile->preadv(0, buffers));
+  ASSERT_EQ(std::string_view(buff1, sizeof(buff1)), "aaaaabbbbb");
+  ASSERT_EQ(std::string_view(buff2, sizeof(buff2)), "cccccddddd");
+
+  std::vector<folly::IOBuf> iobufs(2);
+  std::vector<Region> regions = {{0, 10}, {10, 5}};
+  ASSERT_EQ(
+      10 + 5,
+      readFile->preadv(
+          {regions.data(), regions.size()}, {iobufs.data(), iobufs.size()}));
+  ASSERT_EQ(
+      std::string_view(
+          reinterpret_cast<const char*>(iobufs[0].writableData()),
+          iobufs[0].length()),
+      "aaaaabbbbb");
+  ASSERT_EQ(
+      std::string_view(
+          reinterpret_cast<const char*>(iobufs[1].writableData()),
+          iobufs[1].length()),
+      "ccccc");
+}
+
+TEST_F(AbfsFileSystemTest, readFile) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  auto readFile = abfs.openFileForRead(fullFilePath);
+  readData(readFile.get());
+}
+
+TEST_F(AbfsFileSystemTest, openFileForReadWithOptions) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  FileOptions options;
+  options.fileSize = 15 + kOneMB;
+  auto readFile = abfs.openFileForRead(fullFilePath, options);
+  readData(readFile.get());
+}
+
+TEST_F(AbfsFileSystemTest, openFileForReadWithInvalidOptions) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  FileOptions options;
+  options.fileSize = -kOneMB;
+  VELOX_ASSERT_THROW(
+      abfs.openFileForRead(fullFilePath, options),
+      "File size must be non-negative");
+}
+
+TEST_F(AbfsFileSystemTest, fileHandleWithProperties) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  FileHandleFactory factory(
+      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(1),
+      std::make_unique<FileHandleGenerator>(hiveConfig));
+  FileProperties properties = {15 + kOneMB, 1};
+  auto fileHandleProperties = factory.generate(fullFilePath, &properties);
+  readData(fileHandleProperties->file.get());
+
+  auto fileHandleWithoutProperties = factory.generate(fullFilePath);
+  readData(fileHandleWithoutProperties->file.get());
+}
+
+TEST_F(AbfsFileSystemTest, multipleThreadsWithReadFile) {
+  std::atomic<bool> startThreads = false;
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+
+  std::vector<std::thread> threads;
+  std::mt19937 generator(std::random_device{}());
+  std::vector<int> sleepTimesInMicroseconds = {0, 500, 5000};
+  std::uniform_int_distribution<std::size_t> distribution(
+      0, sleepTimesInMicroseconds.size() - 1);
+  for (int i = 0; i < 10; i++) {
+    auto thread = std::thread([&] {
+      int index = distribution(generator);
+      while (!startThreads) {
+        std::this_thread::yield();
+      }
+      std::this_thread::sleep_for(
+          std::chrono::microseconds(sleepTimesInMicroseconds[index]));
+      auto readFile = abfs.openFileForRead(fullFilePath);
+      readData(readFile.get());
+    });
+    threads.emplace_back(std::move(thread));
+  }
+  startThreads = true;
+  for (auto& thread : threads) {
+    thread.join();
+  }
+}
+
+TEST_F(AbfsFileSystemTest, missingFile) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  const std::string abfsFile =
+      facebook::velox::filesystems::test::AzuriteABFSEndpoint + "test.txt";
+  AbfsFileSystem abfs{hiveConfig};
+  VELOX_ASSERT_RUNTIME_THROW_CODE(
+      abfs.openFileForRead(abfsFile), error_code::kFileNotFound, "404");
+}
+
+TEST_F(AbfsFileSystemTest, OpenFileForWriteTest) {
+  const std::string abfsFile =
+      filesystems::test::AzuriteABFSEndpoint + "writetest.txt";
+  auto mockClient =
+      std::make_shared<filesystems::test::MockBlobStorageFileClient>(
+          filesystems::test::MockBlobStorageFileClient());
+  auto abfsWriteFile = openFileForWrite(abfsFile, mockClient);
+  EXPECT_EQ(abfsWriteFile->size(), 0);
+  std::string dataContent = "";
+  uint64_t totalSize = 0;
+  std::string randomData =
+      AbfsFileSystemTest::generateRandomData(1 * 1024 * 1024);
+  for (int i = 0; i < 8; ++i) {
+    abfsWriteFile->append(randomData);
+    dataContent += randomData;
+  }
+  totalSize = randomData.size() * 8;
+  abfsWriteFile->flush();
+  EXPECT_EQ(abfsWriteFile->size(), totalSize);
+
+  randomData = AbfsFileSystemTest::generateRandomData(9 * 1024 * 1024);
+  dataContent += randomData;
+  abfsWriteFile->append(randomData);
+  totalSize += randomData.size();
+  randomData = AbfsFileSystemTest::generateRandomData(2 * 1024 * 1024);
+  dataContent += randomData;
+  totalSize += randomData.size();
+  abfsWriteFile->append(randomData);
+  abfsWriteFile->flush();
+  EXPECT_EQ(abfsWriteFile->size(), totalSize);
+  abfsWriteFile->flush();
+  abfsWriteFile->close();
+  VELOX_ASSERT_THROW(abfsWriteFile->append("abc"), "File is not open");
+  VELOX_ASSERT_THROW(
+      openFileForWrite(abfsFile, mockClient), "File already exists");
+  std::string fileContent = mockClient->readContent();
+  ASSERT_EQ(fileContent.size(), dataContent.size());
+  ASSERT_EQ(fileContent, dataContent);
+}
+
+TEST_F(AbfsFileSystemTest, renameNotImplemented) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  VELOX_ASSERT_THROW(
+      abfs.rename("text", "text2"), "rename for abfs not implemented");
+}
+
+TEST_F(AbfsFileSystemTest, removeNotImplemented) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  VELOX_ASSERT_THROW(abfs.remove("text"), "remove for abfs not implemented");
+}
+
+TEST_F(AbfsFileSystemTest, existsNotImplemented) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  VELOX_ASSERT_THROW(abfs.exists("text"), "exists for abfs not implemented");
+}
+
+TEST_F(AbfsFileSystemTest, listNotImplemented) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  VELOX_ASSERT_THROW(abfs.list("dir"), "list for abfs not implemented");
+}
+
+TEST_F(AbfsFileSystemTest, mkdirNotImplemented) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  VELOX_ASSERT_THROW(abfs.mkdir("dir"), "mkdir for abfs not implemented");
+}
+
+TEST_F(AbfsFileSystemTest, rmdirNotImplemented) {
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig(
+      {{"fs.azure.account.key.test.dfs.core.windows.net",
+        azuriteServer->connectionStr()}});
+  AbfsFileSystem abfs{hiveConfig};
+  VELOX_ASSERT_THROW(abfs.rmdir("dir"), "rmdir for abfs not implemented");
+}
+
+TEST_F(AbfsFileSystemTest, credNotFOund) {
+  const std::string abfsFile =
+      std::string("abfs://test@test1.dfs.core.windows.net/test");
+  auto hiveConfig = AbfsFileSystemTest::hiveConfig({});
+  AbfsFileSystem abfs{hiveConfig};
+  VELOX_ASSERT_THROW(
+      abfs.openFileForRead(abfsFile), "Failed to find storage credentials");
+}
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AbfsUtilTest.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsUtilTest.cpp
new file mode 100644
index 0000000000000..c97aecb6b8e3d
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsUtilTest.cpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+
+#include "gtest/gtest.h"
+
+using namespace facebook::velox::filesystems::abfs;
+
+TEST(AbfsUtilsTest, isAbfsFile) {
+  EXPECT_FALSE(isAbfsFile("abfs:"));
+  EXPECT_FALSE(isAbfsFile("abfss:"));
+  EXPECT_FALSE(isAbfsFile("abfs:/"));
+  EXPECT_FALSE(isAbfsFile("abfss:/"));
+  EXPECT_TRUE(isAbfsFile("abfs://test@test.dfs.core.windows.net/test"));
+  EXPECT_TRUE(isAbfsFile("abfss://test@test.dfs.core.windows.net/test"));
+}
+
+TEST(AbfsUtilsTest, abfsAccount) {
+  auto abfsAccount = AbfsAccount("abfs://test@test.dfs.core.windows.net/test");
+  EXPECT_EQ(abfsAccount.accountNameWithSuffix(), "test.dfs.core.windows.net");
+  EXPECT_EQ(abfsAccount.accountName(), "test");
+  EXPECT_EQ(abfsAccount.endpointSuffix(), "core.windows.net");
+  EXPECT_EQ(abfsAccount.fileSystem(), "test");
+  EXPECT_EQ(abfsAccount.filePath(), "test");
+  EXPECT_EQ(
+      abfsAccount.credKey(), "fs.azure.account.key.test.dfs.core.windows.net");
+  EXPECT_EQ(
+      abfsAccount.connectionString("123"),
+      "DefaultEndpointsProtocol=https;AccountName=test;AccountKey=123;EndpointSuffix=core.windows.net");
+
+  auto abfssAccount = AbfsAccount(
+      "abfss://test@test.dfs.core.windows.net/sf_1/store_sales/ss_sold_date_sk=2450816/part-00002-a29c25f1-4638-494e-8428-a84f51dcea41.c000.snappy.parquet");
+  EXPECT_EQ(abfssAccount.scheme(), "abfss");
+  EXPECT_EQ(abfssAccount.accountNameWithSuffix(), "test.dfs.core.windows.net");
+  EXPECT_EQ(abfssAccount.accountName(), "test");
+  EXPECT_EQ(abfssAccount.endpointSuffix(), "core.windows.net");
+  EXPECT_EQ(abfssAccount.fileSystem(), "test");
+  EXPECT_EQ(
+      abfssAccount.filePath(),
+      "sf_1/store_sales/ss_sold_date_sk=2450816/part-00002-a29c25f1-4638-494e-8428-a84f51dcea41.c000.snappy.parquet");
+  EXPECT_EQ(
+      abfssAccount.credKey(), "fs.azure.account.key.test.dfs.core.windows.net");
+
+  // test with special characters
+  auto abfssAccountWithSpecialCharacters = AbfsAccount(
+      "abfss://test@test.dfs.core.windows.net/main@dir/sub dir/test.txt");
+  EXPECT_EQ(abfssAccountWithSpecialCharacters.scheme(), "abfss");
+  EXPECT_EQ(
+      abfssAccountWithSpecialCharacters.accountNameWithSuffix(),
+      "test.dfs.core.windows.net");
+  EXPECT_EQ(abfssAccountWithSpecialCharacters.accountName(), "test");
+  EXPECT_EQ(
+      abfssAccountWithSpecialCharacters.endpointSuffix(), "core.windows.net");
+  EXPECT_EQ(abfssAccountWithSpecialCharacters.fileSystem(), "test");
+  EXPECT_EQ(
+      abfssAccountWithSpecialCharacters.filePath(),
+      "main@dir/sub dir/test.txt");
+  EXPECT_EQ(
+      abfssAccountWithSpecialCharacters.credKey(),
+      "fs.azure.account.key.test.dfs.core.windows.net");
+
+  // china cloud
+  auto abfsChinaCloudAccount =
+      AbfsAccount("abfs://test@test.dfs.core.chinacloudapi.cn/test");
+  EXPECT_EQ(abfsChinaCloudAccount.scheme(), "abfs");
+  EXPECT_EQ(
+      abfsChinaCloudAccount.accountNameWithSuffix(),
+      "test.dfs.core.chinacloudapi.cn");
+  EXPECT_EQ(abfsChinaCloudAccount.accountName(), "test");
+  EXPECT_EQ(abfsChinaCloudAccount.endpointSuffix(), "core.chinacloudapi.cn");
+  EXPECT_EQ(abfsChinaCloudAccount.fileSystem(), "test");
+  EXPECT_EQ(abfsChinaCloudAccount.filePath(), "test");
+  EXPECT_EQ(
+      abfsChinaCloudAccount.credKey(),
+      "fs.azure.account.key.test.dfs.core.chinacloudapi.cn");
+
+  // us gov cloud
+  auto abfsUsGovCloudAccount =
+      AbfsAccount("abfs://test@test.dfs.core.usgovcloudapi.net/test");
+  EXPECT_EQ(abfsUsGovCloudAccount.scheme(), "abfs");
+  EXPECT_EQ(
+      abfsUsGovCloudAccount.accountNameWithSuffix(),
+      "test.dfs.core.usgovcloudapi.net");
+  EXPECT_EQ(abfsUsGovCloudAccount.accountName(), "test");
+  EXPECT_EQ(abfsUsGovCloudAccount.endpointSuffix(), "core.usgovcloudapi.net");
+  EXPECT_EQ(abfsUsGovCloudAccount.fileSystem(), "test");
+  EXPECT_EQ(abfsUsGovCloudAccount.filePath(), "test");
+  EXPECT_EQ(
+      abfsUsGovCloudAccount.credKey(),
+      "fs.azure.account.key.test.dfs.core.usgovcloudapi.net");
+
+  // germany cloud
+  auto abfsGermanyCloudAccount =
+      AbfsAccount("abfs://test@test.dfs.core.cloudapi.de/test");
+  EXPECT_EQ(abfsGermanyCloudAccount.scheme(), "abfs");
+  EXPECT_EQ(
+      abfsGermanyCloudAccount.accountNameWithSuffix(),
+      "test.dfs.core.cloudapi.de");
+  EXPECT_EQ(abfsGermanyCloudAccount.accountName(), "test");
+  EXPECT_EQ(abfsGermanyCloudAccount.endpointSuffix(), "core.cloudapi.de");
+  EXPECT_EQ(abfsGermanyCloudAccount.fileSystem(), "test");
+  EXPECT_EQ(abfsGermanyCloudAccount.filePath(), "test");
+  EXPECT_EQ(
+      abfsGermanyCloudAccount.credKey(),
+      "fs.azure.account.key.test.dfs.core.cloudapi.de");
+}
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.cpp
new file mode 100644
index 0000000000000..83461b2c58f24
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h"
+
+namespace facebook::velox::filesystems::test {
+const std::string AzuriteServer::connectionStr() const {
+  return fmt::format(
+      "DefaultEndpointsProtocol=http;AccountName={};AccountKey={};BlobEndpoint=http://127.0.0.1:{}/{};",
+      AzuriteAccountName,
+      AzuriteAccountKey,
+      port_,
+      AzuriteAccountName);
+}
+
+void AzuriteServer::start() {
+  try {
+    serverProcess_ = std::make_unique<boost::process::child>(
+        env_, exePath_, commandOptions_);
+    serverProcess_->wait_for(std::chrono::duration<int, std::milli>(5000));
+    VELOX_CHECK_EQ(
+        serverProcess_->exit_code(),
+        383,
+        "AzuriteServer process exited, code: ",
+        serverProcess_->exit_code());
+  } catch (const std::exception& e) {
+    VELOX_FAIL("Failed to launch Azurite server: {}", e.what());
+  }
+}
+
+void AzuriteServer::stop() {
+  if (serverProcess_ && serverProcess_->valid()) {
+    serverProcess_->terminate();
+    serverProcess_->wait();
+    serverProcess_.reset();
+  }
+}
+
+bool AzuriteServer::isRunning() {
+  if (serverProcess_) {
+    return true;
+  }
+  return false;
+}
+
+// requires azurite executable to be on the PATH
+AzuriteServer::AzuriteServer(int64_t port) : port_(port) {
+  std::string dataLocation = fmt::format("/tmp/azurite_{}", port);
+  std::string logFilePath = fmt::format("/tmp/azurite/azurite_{}.log", port);
+  std::printf(
+      "Launch azurite instance with port - %s, data location - %s, log file path - %s\n",
+      std::to_string(port).c_str(),
+      dataLocation.c_str(),
+      logFilePath.c_str());
+  commandOptions_ = {
+      "--silent",
+      "--blobPort",
+      std::to_string(port),
+      "--location",
+      dataLocation,
+      "--debug",
+      logFilePath,
+  };
+  env_ = (boost::process::environment)boost::this_process::environment();
+  env_["PATH"] = env_["PATH"].to_string() + AzuriteSearchPath;
+  env_["AZURITE_ACCOUNTS"] =
+      fmt::format("{}:{}", AzuriteAccountName, AzuriteAccountKey);
+  auto path = env_["PATH"].to_vector();
+  exePath_ = boost::process::search_path(
+      AzuriteServerExecutableName,
+      std::vector<boost::filesystem::path>(path.begin(), path.end()));
+  std::printf("AzuriteServer executable path: %s\n", exePath_.c_str());
+  if (exePath_.empty()) {
+    VELOX_FAIL(
+        "Failed to find azurite executable {}'", AzuriteServerExecutableName);
+  }
+}
+
+void AzuriteServer::addFile(std::string source, std::string destination) {
+  auto containerClient = BlobContainerClient::CreateFromConnectionString(
+      connectionStr(), AzuriteContainerName);
+  containerClient.CreateIfNotExists();
+  auto blobClient = containerClient.GetBlockBlobClient(destination);
+  blobClient.UploadFrom(source);
+}
+
+AzuriteServer::~AzuriteServer() {
+  // stop();
+}
+} // namespace facebook::velox::filesystems::test
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h b/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h
new file mode 100644
index 0000000000000..67a4f434cb4d3
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+
+#include <azure/storage/blobs/blob_container_client.hpp>
+#include <azure/storage/blobs/block_blob_client.hpp>
+#include <fmt/format.h>
+#include <pwd.h>
+#include <unistd.h>
+#include <iostream>
+#include "boost/process.hpp"
+
+namespace facebook::velox::filesystems::test {
+using namespace Azure::Storage::Blobs;
+static const std::string AzuriteServerExecutableName{"azurite-blob"};
+static const std::string AzuriteSearchPath{":/usr/bin/azurite"};
+static const std::string AzuriteAccountName{"test"};
+static const std::string AzuriteContainerName{"test"};
+// the default key of Azurite Server used for connection
+static const std::string AzuriteAccountKey{
+    "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw=="};
+static const std::string AzuriteABFSEndpoint = fmt::format(
+    "abfs://{}@{}.dfs.core.windows.net/",
+    AzuriteContainerName,
+    AzuriteAccountName);
+
+class AzuriteServer {
+ public:
+  AzuriteServer(int64_t port);
+
+  const std::string connectionStr() const;
+
+  void start();
+
+  void stop();
+
+  bool isRunning();
+
+  void addFile(std::string source, std::string destination);
+
+  virtual ~AzuriteServer();
+
+ private:
+  int64_t port_;
+  std::vector<std::string> commandOptions_;
+  std::unique_ptr<::boost::process::child> serverProcess_;
+  boost::filesystem::path exePath_;
+  boost::process::environment env_;
+};
+} // namespace facebook::velox::filesystems::test
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..0bb2d428ca1ca
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_abfs_test AbfsFileSystemTest.cpp AbfsUtilTest.cpp
+                               AzuriteServer.cpp MockBlobStorageFileClient.cpp)
+add_test(velox_abfs_test velox_abfs_test)
+target_link_libraries(
+  velox_abfs_test
+  PRIVATE
+    velox_file
+    velox_abfs
+    velox_core
+    velox_exec_test_lib
+    velox_hive_connector
+    velox_dwio_common_exception
+    velox_exec
+    GTest::gtest
+    GTest::gtest_main
+    Azure::azure-storage-blobs
+    Azure::azure-storage-files-datalake)
+
+target_compile_options(velox_abfs_test PRIVATE -Wno-deprecated-declarations)
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/MockBlobStorageFileClient.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/MockBlobStorageFileClient.cpp
new file mode 100644
index 0000000000000..5f0cf9fa1efd6
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/MockBlobStorageFileClient.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/tests/MockBlobStorageFileClient.h"
+
+#include <filesystem>
+
+#include <azure/storage/files/datalake.hpp>
+
+using namespace Azure::Storage::Files::DataLake;
+namespace facebook::velox::filesystems::test {
+void MockBlobStorageFileClient::create() {
+  fileStream_ = std::ofstream(
+      filePath_,
+      std::ios_base::out | std::ios_base::binary | std::ios_base::app);
+}
+
+PathProperties MockBlobStorageFileClient::getProperties() {
+  if (!std::filesystem::exists(filePath_)) {
+    Azure::Storage::StorageException exp(filePath_ + "doesn't exists");
+    exp.StatusCode = Azure::Core::Http::HttpStatusCode::NotFound;
+    throw exp;
+  }
+  std::ifstream file(filePath_, std::ios::binary | std::ios::ate);
+  uint64_t size = static_cast<uint64_t>(file.tellg());
+  PathProperties ret;
+  ret.FileSize = size;
+  return ret;
+}
+
+void MockBlobStorageFileClient::append(
+    const uint8_t* buffer,
+    size_t size,
+    uint64_t offset) {
+  fileStream_.seekp(offset);
+  fileStream_.write(reinterpret_cast<const char*>(buffer), size);
+}
+
+void MockBlobStorageFileClient::flush(uint64_t position) {
+  fileStream_.flush();
+}
+
+void MockBlobStorageFileClient::close() {
+  fileStream_.flush();
+  fileStream_.close();
+}
+} // namespace facebook::velox::filesystems::test
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/MockBlobStorageFileClient.h b/velox/connectors/hive/storage_adapters/abfs/tests/MockBlobStorageFileClient.h
new file mode 100644
index 0000000000000..1ef79b31c8b70
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/MockBlobStorageFileClient.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h"
+
+#include "velox/exec/tests/utils/TempFilePath.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::filesystems::abfs;
+
+namespace facebook::velox::filesystems::test {
+// A mocked blob storage file client backend with local file store.
+class MockBlobStorageFileClient : public IBlobStorageFileClient {
+ public:
+  MockBlobStorageFileClient() {
+    auto tempFile = ::exec::test::TempFilePath::create();
+    filePath_ = tempFile->getPath();
+  }
+
+  void create() override;
+  PathProperties getProperties() override;
+  void append(const uint8_t* buffer, size_t size, uint64_t offset) override;
+  void flush(uint64_t position) override;
+  void close() override;
+
+  // for testing purpose to verify the written content if correct.
+  std::string readContent() {
+    std::ifstream inputFile(filePath_);
+    std::string content;
+    inputFile.seekg(0, std::ios::end);
+    std::streamsize fileSize = inputFile.tellg();
+    inputFile.seekg(0, std::ios::beg);
+    content.resize(fileSize);
+    inputFile.read(&content[0], fileSize);
+    inputFile.close();
+    return content;
+  }
+
+ private:
+  std::string filePath_;
+  std::ofstream fileStream_;
+};
+} // namespace facebook::velox::filesystems::test
diff --git a/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
index 02d3035ff7a46..c5ac37c73fd52 100644
--- a/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
@@ -14,20 +14,17 @@
 
 # for generated headers
 
-add_library(velox_gcs RegisterGCSFileSystem.cpp)
+velox_add_library(velox_gcs RegisterGCSFileSystem.cpp)
 
 if(VELOX_ENABLE_GCS)
-  target_sources(velox_gcs PRIVATE GCSFileSystem.cpp GCSUtil.cpp)
-  target_link_libraries(velox_gcs Folly::folly google-cloud-cpp::storage)
+  velox_sources(velox_gcs PRIVATE GCSFileSystem.cpp GCSUtil.cpp)
+  velox_link_libraries(velox_gcs velox_exception Folly::folly
+                       google-cloud-cpp::storage)
 
   if(${VELOX_BUILD_TESTING})
     add_subdirectory(tests)
   endif()
 
-  if(${VELOX_ENABLE_BENCHMARKS})
-    add_subdirectory(benchmark)
-  endif()
-
   if(${VELOX_ENABLE_EXAMPLES})
     add_subdirectory(examples)
   endif()
diff --git a/velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.cpp b/velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.cpp
index e628bbf10fd02..bd4ccfa907ba1 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.cpp
@@ -15,10 +15,12 @@
  */
 
 #include "velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/config/Config.h"
 #include "velox/common/file/File.h"
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GCSUtil.h"
-#include "velox/core/Config.h"
+#include "velox/core/QueryConfig.h"
 
 #include <fmt/format.h>
 #include <glog/logging.h>
@@ -47,14 +49,17 @@ inline void checkGCSStatus(
     const std::string& bucket,
     const std::string& key) {
   if (!outcome.ok()) {
-    auto error = outcome.error_info();
-    VELOX_FAIL(
+    const auto errMsg = fmt::format(
         "{} due to: Path:'{}', SDK Error Type:{}, GCS Status Code:{},  Message:'{}'",
         errorMsgPrefix,
         gcsURI(bucket, key),
-        error.domain(),
+        outcome.error_info().domain(),
         getErrorStringFromGCSError(outcome.code()),
         outcome.message());
+    if (outcome.code() == gc::StatusCode::kNotFound) {
+      VELOX_FILE_NOT_FOUND_ERROR(errMsg);
+    }
+    VELOX_FAIL(errMsg);
   }
 }
 
@@ -68,7 +73,13 @@ class GCSReadFile final : public ReadFile {
 
   // Gets the length of the file.
   // Checks if there are any issues reading the file.
-  void initialize() {
+  void initialize(const filesystems::FileOptions& options) {
+    if (options.fileSize.has_value()) {
+      VELOX_CHECK_GE(
+          options.fileSize.value(), 0, "File size must be non-negative");
+      length_ = options.fileSize.value();
+    }
+
     // Make it a no-op if invoked twice.
     if (length_ != -1) {
       return;
@@ -247,14 +258,16 @@ auto constexpr kGCSInvalidPath = "File {} is not a valid gcs file";
 
 class GCSFileSystem::Impl {
  public:
-  Impl(const Config* config) : config_(config) {}
+  Impl(const config::ConfigBase* config)
+      : hiveConfig_(std::make_shared<HiveConfig>(
+            std::make_shared<config::ConfigBase>(config->rawConfigsCopy()))) {}
 
   ~Impl() = default;
 
   // Use the input Config parameters and initialize the GCSClient.
   void initializeClient() {
     auto options = gc::Options{};
-    auto scheme = HiveConfig::gcsScheme(config_);
+    auto scheme = hiveConfig_->gcsScheme();
     if (scheme == "https") {
       options.set<gc::UnifiedCredentialsOption>(
           gc::MakeGoogleDefaultCredentials());
@@ -263,12 +276,26 @@ class GCSFileSystem::Impl {
     }
     options.set<gcs::UploadBufferSizeOption>(kUploadBufferSize);
 
-    auto endpointOverride = HiveConfig::gcsEndpoint(config_);
+    auto max_retry_count = hiveConfig_->gcsMaxRetryCount();
+    if (max_retry_count) {
+      options.set<gcs::RetryPolicyOption>(
+          gcs::LimitedErrorCountRetryPolicy(max_retry_count.value()).clone());
+    }
+
+    auto max_retry_time = hiveConfig_->gcsMaxRetryTime();
+    if (max_retry_time) {
+      auto retry_time = std::chrono::duration_cast<std::chrono::milliseconds>(
+          facebook::velox::config::toDuration(max_retry_time.value()));
+      options.set<gcs::RetryPolicyOption>(
+          gcs::LimitedTimeRetryPolicy(retry_time).clone());
+    }
+
+    auto endpointOverride = hiveConfig_->gcsEndpoint();
     if (!endpointOverride.empty()) {
       options.set<gcs::RestEndpointOption>(scheme + "://" + endpointOverride);
     }
 
-    auto cred = HiveConfig::gcsCredentials(config_);
+    auto cred = hiveConfig_->gcsCredentials();
     if (!cred.empty()) {
       auto credentials = gc::MakeServiceAccountCredentials(cred);
       options.set<gc::UnifiedCredentialsOption>(credentials);
@@ -284,11 +311,11 @@ class GCSFileSystem::Impl {
   }
 
  private:
-  const Config* FOLLY_NONNULL config_;
+  const std::shared_ptr<HiveConfig> hiveConfig_;
   std::shared_ptr<gcs::Client> client_;
 };
 
-GCSFileSystem::GCSFileSystem(std::shared_ptr<const Config> config)
+GCSFileSystem::GCSFileSystem(std::shared_ptr<const config::ConfigBase> config)
     : FileSystem(config) {
   impl_ = std::make_shared<Impl>(config.get());
 }
@@ -299,10 +326,10 @@ void GCSFileSystem::initializeClient() {
 
 std::unique_ptr<ReadFile> GCSFileSystem::openFileForRead(
     std::string_view path,
-    const FileOptions& /*unused*/) {
+    const FileOptions& options) {
   const auto gcspath = gcsPath(path);
   auto gcsfile = std::make_unique<GCSReadFile>(gcspath, impl_->getClient());
-  gcsfile->initialize();
+  gcsfile->initialize(options);
   return gcsfile;
 }
 
@@ -400,5 +427,5 @@ void GCSFileSystem::rmdir(std::string_view path) {
   VELOX_UNSUPPORTED("rmdir for GCS not implemented");
 }
 
-}; // namespace filesystems
-}; // namespace facebook::velox
+} // namespace filesystems
+} // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h b/velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h
index 5cd98ed0fd724..0d80cacd9df13 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h
@@ -26,7 +26,7 @@ namespace facebook::velox::filesystems {
 /// (register|generate)ReadFile and (register|generate)WriteFile functions.
 class GCSFileSystem : public FileSystem {
  public:
-  explicit GCSFileSystem(std::shared_ptr<const Config> config);
+  explicit GCSFileSystem(std::shared_ptr<const config::ConfigBase> config);
 
   /// Initialize the google::cloud::storage::Client from the input Config
   /// parameters.
diff --git a/velox/connectors/hive/storage_adapters/gcs/RegisterGCSFileSystem.cpp b/velox/connectors/hive/storage_adapters/gcs/RegisterGCSFileSystem.cpp
index 4c76478dfca21..3474c8d4dfb9b 100644
--- a/velox/connectors/hive/storage_adapters/gcs/RegisterGCSFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/RegisterGCSFileSystem.cpp
@@ -15,9 +15,9 @@
  */
 
 #ifdef VELOX_ENABLE_GCS
-#include "velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h"
-#include "velox/connectors/hive/storage_adapters/gcs/GCSUtil.h"
-#include "velox/core/Config.h"
+#include "velox/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h" // @manual
+#include "velox/connectors/hive/storage_adapters/gcs/GCSUtil.h" // @manual
 #endif
 
 namespace facebook::velox::filesystems {
@@ -26,28 +26,30 @@ namespace facebook::velox::filesystems {
 folly::once_flag GCSInstantiationFlag;
 
 std::function<std::shared_ptr<
-    FileSystem>(std::shared_ptr<const Config>, std::string_view)>
+    FileSystem>(std::shared_ptr<const config::ConfigBase>, std::string_view)>
 gcsFileSystemGenerator() {
-  static auto filesystemGenerator = [](std::shared_ptr<const Config> properties,
-                                       std::string_view filePath) {
-    // Only one instance of GCSFileSystem is supported for now (follow S3 for
-    // now).
-    // TODO: Support multiple GCSFileSystem instances using a cache
-    // Initialize on first access and reuse after that.
-    static std::shared_ptr<FileSystem> gcsfs;
-    folly::call_once(GCSInstantiationFlag, [&properties]() {
-      std::shared_ptr<GCSFileSystem> fs;
-      if (properties != nullptr) {
-        fs = std::make_shared<GCSFileSystem>(properties);
-      } else {
-        fs = std::make_shared<GCSFileSystem>(
-            std::make_shared<core::MemConfig>());
-      }
-      fs->initializeClient();
-      gcsfs = fs;
-    });
-    return gcsfs;
-  };
+  static auto filesystemGenerator =
+      [](std::shared_ptr<const config::ConfigBase> properties,
+         std::string_view filePath) {
+        // Only one instance of GCSFileSystem is supported for now (follow S3
+        // for now).
+        // TODO: Support multiple GCSFileSystem instances using a cache
+        // Initialize on first access and reuse after that.
+        static std::shared_ptr<FileSystem> gcsfs;
+        folly::call_once(GCSInstantiationFlag, [&properties]() {
+          std::shared_ptr<GCSFileSystem> fs;
+          if (properties != nullptr) {
+            fs = std::make_shared<GCSFileSystem>(properties);
+          } else {
+            fs = std::make_shared<GCSFileSystem>(
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
+          }
+          fs->initializeClient();
+          gcsfs = fs;
+        });
+        return gcsfs;
+      };
   return filesystemGenerator;
 }
 #endif
diff --git a/velox/connectors/hive/storage_adapters/gcs/benchmark/CMakeLists.txt b/velox/connectors/hive/storage_adapters/gcs/benchmark/CMakeLists.txt
deleted file mode 100644
index 0eb61670736cd..0000000000000
--- a/velox/connectors/hive/storage_adapters/gcs/benchmark/CMakeLists.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_executable(velox_gcsread_benchmark GCSReadBenchmark.cpp
-                                       GCSReadBenchmarkMain.cpp)
-
-target_link_libraries(
-  velox_gcsread_benchmark
-  velox_read_benchmark_lib
-  velox_gcs
-  velox_exception
-  velox_exec_test_lib
-  fmt::fmt
-  Folly::folly)
diff --git a/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmark.cpp b/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmark.cpp
deleted file mode 100644
index 5093a04f32ba3..0000000000000
--- a/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmark.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmark.h"
-#include "velox/core/Config.h"
-
-#include <fstream>
-
-DEFINE_string(gcs_config, "", "Path of GCS config file");
-
-namespace facebook::velox {
-
-// From presto-cpp
-std::shared_ptr<Config> readConfig(const std::string& filePath) {
-  std::ifstream configFile(filePath);
-  if (!configFile.is_open()) {
-    throw std::runtime_error(
-        fmt::format("Couldn't open config file {} for reading.", filePath));
-  }
-
-  std::unordered_map<std::string, std::string> properties;
-  std::string line;
-  while (getline(configFile, line)) {
-    line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());
-    if (line[0] == '#' || line.empty()) {
-      continue;
-    }
-    auto delimiterPos = line.find('=');
-    auto name = line.substr(0, delimiterPos);
-    auto value = line.substr(delimiterPos + 1);
-    properties.emplace(name, value);
-  }
-
-  return std::make_shared<facebook::velox::core::MemConfig>(properties);
-}
-
-} // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmark.h b/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmark.h
deleted file mode 100644
index 5de1e852bf273..0000000000000
--- a/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmark.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/common/file/benchmark/ReadBenchmark.h"
-#include "velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h"
-
-DECLARE_string(gcs_config);
-
-namespace facebook::velox {
-
-std::shared_ptr<Config> readConfig(const std::string& filePath);
-
-class GCSReadBenchmark : public ReadBenchmark {
- public:
-  // Initialize a GCSReadFile instance for the specified 'path'.
-  void initialize() override {
-    executor_ =
-        std::make_unique<folly::IOThreadPoolExecutor>(FLAGS_num_threads);
-
-    std::shared_ptr<Config> config;
-    if (!FLAGS_gcs_config.empty()) {
-      config = readConfig(FLAGS_gcs_config);
-    }
-    auto gcsfs = filesystems::getFileSystem(FLAGS_path, config);
-    readFile_ = gcsfs->openFileForRead(FLAGS_path);
-
-    fileSize_ = readFile_->size();
-    if (FLAGS_file_size_gb) {
-      fileSize_ = std::min<uint64_t>(FLAGS_file_size_gb << 30, fileSize_);
-    }
-
-    if (fileSize_ <= FLAGS_measurement_size) {
-      LOG(ERROR) << "File size " << fileSize_
-                 << " is <= then --measurement_size " << FLAGS_measurement_size;
-      exit(1);
-    }
-    if (FLAGS_seed) {
-      rng_.seed(FLAGS_seed);
-    }
-  }
-};
-
-} // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmarkMain.cpp b/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmarkMain.cpp
deleted file mode 100644
index f18437f9e490b..0000000000000
--- a/velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmarkMain.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/connectors/hive/storage_adapters/gcs/benchmark/GCSReadBenchmark.h"
-
-using namespace facebook::velox;
-
-// This benchmark measures the throughput of an GCS compatible FileSystem for
-// various ReadFile APIs. The output helps us understand the maximum possible
-// gains for queries. Example: If a single thread requires reading 1GB of data
-// and the IO throughput is 100 MBps, then it takes 10 seconds to just read the
-// data.
-int main(int argc, char** argv) {
-  folly::init(&argc, &argv, false);
-  GCSReadBenchmark bm;
-  bm.initialize();
-  bm.run();
-}
diff --git a/velox/connectors/hive/storage_adapters/gcs/examples/GCSFileSystemExample.cpp b/velox/connectors/hive/storage_adapters/gcs/examples/GCSFileSystemExample.cpp
index 5495e560bc2ff..ee026a86e0db9 100644
--- a/velox/connectors/hive/storage_adapters/gcs/examples/GCSFileSystemExample.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/examples/GCSFileSystemExample.cpp
@@ -13,22 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/config/Config.h"
 #include "velox/common/file/File.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h"
-#include "velox/core/Config.h"
 
 #include <folly/init/Init.h>
-
 #include <gflags/gflags.h>
-
 #include <iostream>
 
 DEFINE_string(gcs_path, "", "Path of GCS bucket");
+DEFINE_string(gcs_max_retry_count, "", "Max retry count");
+DEFINE_string(gcs_max_retry_time, "", "Max retry time");
 
 auto newConfiguration() {
   using namespace facebook::velox;
   std::unordered_map<std::string, std::string> configOverride = {};
-  return std::make_shared<const core::MemConfig>(std::move(configOverride));
+  if (!FLAGS_gcs_max_retry_count.empty()) {
+    configOverride.emplace(
+        "hive.gcs.max-retry-count", FLAGS_gcs_max_retry_count);
+  }
+  if (!FLAGS_gcs_max_retry_time.empty()) {
+    configOverride.emplace("hive.gcs.max-retry-time", FLAGS_gcs_max_retry_time);
+  }
+  return std::make_shared<const config::ConfigBase>(std::move(configOverride));
 }
 
 int main(int argc, char** argv) {
@@ -40,7 +47,7 @@ int main(int argc, char** argv) {
   }
   filesystems::GCSFileSystem gcfs(newConfiguration());
   gcfs.initializeClient();
-  std::cout << "Opening file " << FLAGS_gcs_path << std::endl;
+  std::cout << "Opening file for read " << FLAGS_gcs_path << std::endl;
   std::unique_ptr<ReadFile> file_read = gcfs.openFileForRead(FLAGS_gcs_path);
   std::size_t file_size = file_read->size();
   std::cout << "File size = " << file_size << std::endl;
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
index b44aa355c09fc..edf4c69eeffd8 100644
--- a/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
@@ -22,6 +22,6 @@ target_link_libraries(
   velox_hive_connector
   velox_dwio_common_exception
   velox_exec
-  gmock
-  gtest
-  gtest_main)
+  GTest::gmock
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/GCSFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/gcs/tests/GCSFileSystemTest.cpp
index a0cb3c7c5222c..5293901f61f92 100644
--- a/velox/connectors/hive/storage_adapters/gcs/tests/GCSFileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/GCSFileSystemTest.cpp
@@ -16,10 +16,10 @@
 
 #include "velox/connectors/hive/storage_adapters/gcs/GCSFileSystem.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/config/Config.h"
 #include "velox/common/file/File.h"
 #include "velox/connectors/hive/FileHandle.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GCSUtil.h"
-#include "velox/core/Config.h"
 #include "velox/exec/tests/utils/TempFilePath.h"
 
 #include <boost/process.hpp>
@@ -139,12 +139,13 @@ class GCSFileSystemTest : public testing::Test {
                              << ">, status=" << object.status();
   }
 
-  std::shared_ptr<const Config> testGcsOptions() const {
+  std::shared_ptr<const config::ConfigBase> testGcsOptions() const {
     std::unordered_map<std::string, std::string> configOverride = {};
 
     configOverride["hive.gcs.scheme"] = "http";
     configOverride["hive.gcs.endpoint"] = "localhost:" + testbench_->port();
-    return std::make_shared<const core::MemConfig>(std::move(configOverride));
+    return std::make_shared<const config::ConfigBase>(
+        std::move(configOverride));
   }
 
   std::string preexistingBucketName() {
@@ -285,30 +286,20 @@ TEST_F(GCSFileSystemTest, missingFile) {
   const std::string gcsFile = gcsURI(preexistingBucketName(), file);
   filesystems::GCSFileSystem gcfs(testGcsOptions());
   gcfs.initializeClient();
-  try {
-    gcfs.openFileForRead(gcsFile);
-    FAIL() << "Expected VeloxException";
-  } catch (VeloxException const& err) {
-    EXPECT_THAT(
-        err.message(),
-        ::testing::HasSubstr(
-            "\\\"message\\\": \\\"Live version of object test1-gcs/newTest.txt does not exist.\\\""));
-  }
+  VELOX_ASSERT_RUNTIME_THROW_CODE(
+      gcfs.openFileForRead(gcsFile),
+      error_code::kFileNotFound,
+      "\\\"message\\\": \\\"Live version of object test1-gcs/newTest.txt does not exist.\\\"");
 }
 
 TEST_F(GCSFileSystemTest, missingBucket) {
   filesystems::GCSFileSystem gcfs(testGcsOptions());
   gcfs.initializeClient();
-  try {
-    const char* gcsFile = "gs://dummy/foo.txt";
-    gcfs.openFileForRead(gcsFile);
-    FAIL() << "Expected VeloxException";
-  } catch (VeloxException const& err) {
-    EXPECT_THAT(
-        err.message(),
-        ::testing::HasSubstr(
-            "\\\"message\\\": \\\"Bucket dummy does not exist.\\\""));
-  }
+  const char* gcsFile = "gs://dummy/foo.txt";
+  VELOX_ASSERT_RUNTIME_THROW_CODE(
+      gcfs.openFileForRead(gcsFile),
+      error_code::kFileNotFound,
+      "\\\"message\\\": \\\"Bucket dummy does not exist.\\\"");
 }
 
 TEST_F(GCSFileSystemTest, credentialsConfig) {
@@ -355,8 +346,8 @@ TEST_F(GCSFileSystemTest, credentialsConfig) {
   })""";
   configOverride["hive.gcs.scheme"] = "http";
   configOverride["hive.gcs.endpoint"] = "localhost:" + testbench_->port();
-  std::shared_ptr<const Config> conf =
-      std::make_shared<const core::MemConfig>(std::move(configOverride));
+  std::shared_ptr<const config::ConfigBase> conf =
+      std::make_shared<const config::ConfigBase>(std::move(configOverride));
 
   filesystems::GCSFileSystem gcfs(conf);
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
index d6363d9e71c55..6c1e84aec4040 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
@@ -14,12 +14,16 @@
 
 # for generated headers
 
-add_library(velox_hdfs RegisterHdfsFileSystem.cpp)
+velox_add_library(velox_hdfs RegisterHdfsFileSystem.cpp)
 
 if(VELOX_ENABLE_HDFS)
-  target_sources(velox_hdfs PRIVATE HdfsFileSystem.cpp HdfsReadFile.cpp
-                                    HdfsWriteFile.cpp)
-  target_link_libraries(velox_hdfs Folly::folly ${LIBHDFS3} xsimd)
+  velox_sources(
+    velox_hdfs
+    PRIVATE
+    HdfsFileSystem.cpp
+    HdfsReadFile.cpp
+    HdfsWriteFile.cpp)
+  velox_link_libraries(velox_hdfs Folly::folly ${LIBHDFS3} xsimd)
 
   if(${VELOX_BUILD_TESTING})
     add_subdirectory(tests)
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp
index ff49163bba9f9..4e7b9ddc0ec52 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp
@@ -16,9 +16,9 @@
 #include "velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h"
 #include <hdfs/hdfs.h>
 #include <mutex>
+#include "velox/common/config/Config.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.h"
-#include "velox/core/Config.h"
 
 namespace facebook::velox::filesystems {
 std::string_view HdfsFileSystem::kScheme("hdfs://");
@@ -26,16 +26,19 @@ std::string_view HdfsFileSystem::kScheme("hdfs://");
 class HdfsFileSystem::Impl {
  public:
   // Keep config here for possible use in the future.
-  explicit Impl(const Config* config, const HdfsServiceEndpoint& endpoint) {
+  explicit Impl(
+      const config::ConfigBase* config,
+      const HdfsServiceEndpoint& endpoint) {
     auto builder = hdfsNewBuilder();
     hdfsBuilderSetNameNode(builder, endpoint.host.c_str());
     hdfsBuilderSetNameNodePort(builder, atoi(endpoint.port.data()));
     hdfsClient_ = hdfsBuilderConnect(builder);
+    hdfsFreeBuilder(builder);
     VELOX_CHECK_NOT_NULL(
         hdfsClient_,
         "Unable to connect to HDFS: {}, got error: {}.",
         endpoint.identity(),
-        hdfsGetLastError())
+        hdfsGetLastError());
   }
 
   ~Impl() {
@@ -56,7 +59,7 @@ class HdfsFileSystem::Impl {
 };
 
 HdfsFileSystem::HdfsFileSystem(
-    const std::shared_ptr<const Config>& config,
+    const std::shared_ptr<const config::ConfigBase>& config,
     const HdfsServiceEndpoint& endpoint)
     : FileSystem(config) {
   impl_ = std::make_shared<Impl>(config.get(), endpoint);
@@ -93,17 +96,17 @@ bool HdfsFileSystem::isHdfsFile(const std::string_view filePath) {
 /// fixed one from configuration.
 HdfsServiceEndpoint HdfsFileSystem::getServiceEndpoint(
     const std::string_view filePath,
-    const Config* config) {
+    const config::ConfigBase* config) {
   auto endOfIdentityInfo = filePath.find('/', kScheme.size());
   std::string hdfsIdentity{
       filePath.data(), kScheme.size(), endOfIdentityInfo - kScheme.size()};
   if (hdfsIdentity.empty()) {
     // Fall back to get a fixed endpoint from config.
-    auto hdfsHost = config->get("hive.hdfs.host");
+    auto hdfsHost = config->get<std::string>("hive.hdfs.host");
     VELOX_CHECK(
         hdfsHost.hasValue(),
         "hdfsHost is empty, configuration missing for hdfs host");
-    auto hdfsPort = config->get("hive.hdfs.port");
+    auto hdfsPort = config->get<std::string>("hive.hdfs.port");
     VELOX_CHECK(
         hdfsPort.hasValue(),
         "hdfsPort is empty, configuration missing for hdfs port");
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
index 295df6f8f0f67..25602a470f169 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
@@ -43,7 +43,7 @@ struct HdfsServiceEndpoint {
 class HdfsFileSystem : public FileSystem {
  public:
   explicit HdfsFileSystem(
-      const std::shared_ptr<const Config>& config,
+      const std::shared_ptr<const config::ConfigBase>& config,
       const HdfsServiceEndpoint& endpoint);
 
   std::string name() const override;
@@ -61,7 +61,7 @@ class HdfsFileSystem : public FileSystem {
   virtual void rename(
       std::string_view path,
       std::string_view newPath,
-      bool overWrite = false) {
+      bool overWrite = false) override {
     VELOX_UNSUPPORTED("rename for HDFs not implemented");
   }
 
@@ -88,7 +88,7 @@ class HdfsFileSystem : public FileSystem {
   /// will be used.
   static HdfsServiceEndpoint getServiceEndpoint(
       const std::string_view filePath,
-      const Config* config);
+      const config::ConfigBase* config);
 
   static std::string_view kScheme;
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
index 84bbd217d4741..dedc2bb4a4c9a 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
@@ -23,11 +23,17 @@ namespace facebook::velox {
 HdfsReadFile::HdfsReadFile(hdfsFS hdfs, const std::string_view path)
     : hdfsClient_(hdfs), filePath_(path) {
   fileInfo_ = hdfsGetPathInfo(hdfsClient_, filePath_.data());
-  VELOX_CHECK_NOT_NULL(
-      fileInfo_,
-      "Unable to get file path info for file: {}. got error: {}",
-      filePath_,
-      hdfsGetLastError());
+  if (fileInfo_ == nullptr) {
+    auto error = hdfsGetLastError();
+    auto errMsg = fmt::format(
+        "Unable to get file path info for file: {}. got error: {}",
+        filePath_,
+        error);
+    if (std::strstr(error, "FileNotFoundException") != nullptr) {
+      VELOX_FILE_NOT_FOUND_ERROR(errMsg);
+    }
+    VELOX_FAIL(errMsg);
+  }
 }
 
 HdfsReadFile::~HdfsReadFile() {
@@ -85,6 +91,6 @@ void HdfsReadFile::checkFileReadParameters(uint64_t offset, uint64_t length)
       "Cannot read HDFS file beyond its size: {}, offset: {}, end point: {}",
       fileSize,
       offset,
-      endPoint)
+      endPoint);
 }
 } // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
index 2bd94bf9c8aa5..1d531956f0eee 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
@@ -50,7 +50,7 @@ struct HdfsFile {
 
   int32_t read(char* pos, uint64_t length) const {
     auto bytesRead = hdfsRead(client_, handle_, pos, length);
-    VELOX_CHECK(bytesRead >= 0, "Read failure in HDFSReadFile::preadInternal.")
+    VELOX_CHECK(bytesRead >= 0, "Read failure in HDFSReadFile::preadInternal.");
     return bytesRead;
   }
 };
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp b/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
index 883ab1f649042..60f98a88c972b 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
@@ -25,6 +25,12 @@ HdfsWriteFile::HdfsWriteFile(
     short replication,
     int blockSize)
     : hdfsClient_(hdfsClient), filePath_(path) {
+  auto pos = filePath_.rfind("/");
+  auto parentDir = filePath_.substr(0, pos + 1);
+  if (hdfsExists(hdfsClient_, parentDir.c_str()) == -1) {
+    hdfsCreateDirectory(hdfsClient_, parentDir.c_str());
+  }
+
   hdfsFile_ = hdfsOpenFile(
       hdfsClient_,
       filePath_.c_str(),
diff --git a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
index 47734838838f8..bdff4a7a4fdc7 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
@@ -17,9 +17,9 @@
 #ifdef VELOX_ENABLE_HDFS3
 #include "folly/concurrency/ConcurrentHashMap.h"
 
-#include "velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h"
-#include "velox/connectors/hive/storage_adapters/hdfs/HdfsUtil.h"
-#include "velox/core/Config.h"
+#include "velox/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h" // @manual
+#include "velox/connectors/hive/storage_adapters/hdfs/HdfsUtil.h" // @manual
 #include "velox/dwio/common/FileSink.h"
 #endif
 
@@ -29,9 +29,10 @@ namespace facebook::velox::filesystems {
 std::mutex mtx;
 
 std::function<std::shared_ptr<
-    FileSystem>(std::shared_ptr<const Config>, std::string_view)>
+    FileSystem>(std::shared_ptr<const config::ConfigBase>, std::string_view)>
 hdfsFileSystemGenerator() {
-  static auto filesystemGenerator = [](std::shared_ptr<const Config> properties,
+  static auto filesystemGenerator = [](std::shared_ptr<const config::ConfigBase>
+                                           properties,
                                        std::string_view filePath) {
     static folly::ConcurrentHashMap<std::string, std::shared_ptr<FileSystem>>
         filesystems;
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
index f0bb039ac7137..6c3067e2de481 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
@@ -26,6 +26,9 @@ target_link_libraries(
   velox_hive_connector
   velox_dwio_common_exception
   velox_exec
-  gtest
-  gtest_main
-  gmock)
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock)
+
+target_compile_options(velox_hdfs_file_test
+                       PRIVATE -Wno-deprecated-declarations)
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
index 51d933167333c..da65d8e03478d 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
@@ -46,7 +46,7 @@ class HdfsFileSystemTest : public testing::Test {
       miniCluster = std::make_shared<filesystems::test::HdfsMiniCluster>();
       miniCluster->start();
       auto tempFile = createFile();
-      miniCluster->addFile(tempFile->path, destinationPath);
+      miniCluster->addFile(tempFile->getPath(), destinationPath);
     }
   }
 
@@ -64,7 +64,7 @@ class HdfsFileSystemTest : public testing::Test {
 
  private:
   static std::shared_ptr<::exec::test::TempFilePath> createFile() {
-    auto tempFile = ::exec::test::TempFilePath::create();
+    auto tempFile = exec::test::TempFilePath::create();
     tempFile->append("aaaaa");
     tempFile->append("bbbbb");
     tempFile->append(std::string(kOneMB, 'c'));
@@ -100,10 +100,11 @@ void readData(ReadFile* readFile) {
 }
 
 std::unique_ptr<WriteFile> openFileForWrite(std::string_view path) {
-  auto memConfig = std::make_shared<const core::MemConfig>(configurationValues);
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
   std::string hdfsFilePath =
       "hdfs://" + localhost + ":" + hdfsPort + std::string(path);
-  auto hdfsFileSystem = filesystems::getFileSystem(hdfsFilePath, memConfig);
+  auto hdfsFileSystem = filesystems::getFileSystem(hdfsFilePath, config);
   return hdfsFileSystem->openFileForWrite(path);
 }
 
@@ -156,12 +157,12 @@ void verifyFailures(hdfsFS hdfs) {
   HdfsFileSystemTest::miniCluster->stop();
   checkReadErrorMessages(&readFile2, readFailErrorMessage, 1);
   try {
-    auto memConfig =
-        std::make_shared<const core::MemConfig>(configurationValues);
+    auto config = std::make_shared<const config::ConfigBase>(
+        std::unordered_map<std::string, std::string>(configurationValues));
     filesystems::HdfsFileSystem hdfsFileSystem(
-        memConfig,
+        config,
         filesystems::HdfsFileSystem::getServiceEndpoint(
-            simpleDestinationPath, memConfig.get()));
+            simpleDestinationPath, config.get()));
     FAIL() << "expected VeloxException";
   } catch (VeloxException const& error) {
     EXPECT_THAT(error.message(), testing::HasSubstr(builderErrorMessage));
@@ -178,18 +179,18 @@ TEST_F(HdfsFileSystemTest, read) {
 }
 
 TEST_F(HdfsFileSystemTest, viaFileSystem) {
-  auto memConfig = std::make_shared<const core::MemConfig>(configurationValues);
-  auto hdfsFileSystem =
-      filesystems::getFileSystem(fullDestinationPath, memConfig);
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
+  auto hdfsFileSystem = filesystems::getFileSystem(fullDestinationPath, config);
   auto readFile = hdfsFileSystem->openFileForRead(fullDestinationPath);
   readData(readFile.get());
 }
 
 TEST_F(HdfsFileSystemTest, initializeFsWithEndpointInfoInFilePath) {
   // Without host/port configured.
-  auto memConfig = std::make_shared<const core::MemConfig>();
-  auto hdfsFileSystem =
-      filesystems::getFileSystem(fullDestinationPath, memConfig);
+  auto config = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>());
+  auto hdfsFileSystem = filesystems::getFileSystem(fullDestinationPath, config);
   auto readFile = hdfsFileSystem->openFileForRead(fullDestinationPath);
   readData(readFile.get());
 
@@ -197,14 +198,15 @@ TEST_F(HdfsFileSystemTest, initializeFsWithEndpointInfoInFilePath) {
   const std::string wrongFullDestinationPath =
       "hdfs://not_exist_host:" + hdfsPort + destinationPath;
   VELOX_ASSERT_THROW(
-      filesystems::getFileSystem(wrongFullDestinationPath, memConfig),
+      filesystems::getFileSystem(wrongFullDestinationPath, config),
       "Unable to connect to HDFS");
 }
 
 TEST_F(HdfsFileSystemTest, fallbackToUseConfig) {
-  auto memConfig = std::make_shared<const core::MemConfig>(configurationValues);
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
   auto hdfsFileSystem =
-      filesystems::getFileSystem(simpleDestinationPath, memConfig);
+      filesystems::getFileSystem(simpleDestinationPath, config);
   auto readFile = hdfsFileSystem->openFileForRead(simpleDestinationPath);
   readData(readFile.get());
 }
@@ -218,32 +220,26 @@ TEST_F(HdfsFileSystemTest, oneFsInstanceForOneEndpoint) {
 }
 
 TEST_F(HdfsFileSystemTest, missingFileViaFileSystem) {
-  try {
-    auto memConfig =
-        std::make_shared<const core::MemConfig>(configurationValues);
-    auto hdfsFileSystem =
-        filesystems::getFileSystem(fullDestinationPath, memConfig);
-    auto readFile = hdfsFileSystem->openFileForRead(
-        "hdfs://localhost:7777/path/that/does/not/exist");
-    FAIL() << "expected VeloxException";
-  } catch (VeloxException const& error) {
-    EXPECT_THAT(
-        error.message(),
-        testing::HasSubstr(
-            "Unable to get file path info for file: /path/that/does/not/exist. got error: FileNotFoundException: Path /path/that/does/not/exist does not exist."));
-  }
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
+  auto hdfsFileSystem = filesystems::getFileSystem(fullDestinationPath, config);
+  VELOX_ASSERT_RUNTIME_THROW_CODE(
+      hdfsFileSystem->openFileForRead(
+          "hdfs://localhost:7777/path/that/does/not/exist"),
+      error_code::kFileNotFound,
+      "Unable to get file path info for file: /path/that/does/not/exist. got error: FileNotFoundException: Path /path/that/does/not/exist does not exist.");
 }
 
 TEST_F(HdfsFileSystemTest, missingHost) {
   try {
     std::unordered_map<std::string, std::string> missingHostConfiguration(
         {{"hive.hdfs.port", hdfsPort}});
-    auto memConfig =
-        std::make_shared<const core::MemConfig>(missingHostConfiguration);
+    auto config = std::make_shared<const config::ConfigBase>(
+        std::move(missingHostConfiguration));
     filesystems::HdfsFileSystem hdfsFileSystem(
-        memConfig,
+        config,
         filesystems::HdfsFileSystem::getServiceEndpoint(
-            simpleDestinationPath, memConfig.get()));
+            simpleDestinationPath, config.get()));
     FAIL() << "expected VeloxException";
   } catch (VeloxException const& error) {
     EXPECT_THAT(
@@ -257,12 +253,12 @@ TEST_F(HdfsFileSystemTest, missingPort) {
   try {
     std::unordered_map<std::string, std::string> missingPortConfiguration(
         {{"hive.hdfs.host", localhost}});
-    auto memConfig =
-        std::make_shared<const core::MemConfig>(missingPortConfiguration);
+    auto config = std::make_shared<const config::ConfigBase>(
+        std::move(missingPortConfiguration));
     filesystems::HdfsFileSystem hdfsFileSystem(
-        memConfig,
+        config,
         filesystems::HdfsFileSystem::getServiceEndpoint(
-            simpleDestinationPath, memConfig.get()));
+            simpleDestinationPath, config.get()));
     FAIL() << "expected VeloxException";
   } catch (VeloxException const& error) {
     EXPECT_THAT(
@@ -306,10 +302,10 @@ TEST_F(HdfsFileSystemTest, schemeMatching) {
 
 TEST_F(HdfsFileSystemTest, writeNotSupported) {
   try {
-    auto memConfig =
-        std::make_shared<const core::MemConfig>(configurationValues);
+    auto config = std::make_shared<const config::ConfigBase>(
+        std::unordered_map<std::string, std::string>(configurationValues));
     auto hdfsFileSystem =
-        filesystems::getFileSystem(fullDestinationPath, memConfig);
+        filesystems::getFileSystem(fullDestinationPath, config);
     hdfsFileSystem->openFileForWrite("/path");
   } catch (VeloxException const& error) {
     EXPECT_EQ(error.message(), "Write to HDFS is unsupported");
@@ -318,10 +314,10 @@ TEST_F(HdfsFileSystemTest, writeNotSupported) {
 
 TEST_F(HdfsFileSystemTest, removeNotSupported) {
   try {
-    auto memConfig =
-        std::make_shared<const core::MemConfig>(configurationValues);
+    auto config = std::make_shared<const config::ConfigBase>(
+        std::unordered_map<std::string, std::string>(configurationValues));
     auto hdfsFileSystem =
-        filesystems::getFileSystem(fullDestinationPath, memConfig);
+        filesystems::getFileSystem(fullDestinationPath, config);
     hdfsFileSystem->remove("/path");
   } catch (VeloxException const& error) {
     EXPECT_EQ(error.message(), "Does not support removing files from hdfs");
@@ -361,9 +357,9 @@ TEST_F(HdfsFileSystemTest, multipleThreadsWithReadFile) {
 
 TEST_F(HdfsFileSystemTest, multipleThreadsWithFileSystem) {
   startThreads = false;
-  auto memConfig = std::make_shared<const core::MemConfig>(configurationValues);
-  auto hdfsFileSystem =
-      filesystems::getFileSystem(fullDestinationPath, memConfig);
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
+  auto hdfsFileSystem = filesystems::getFileSystem(fullDestinationPath, config);
 
   std::vector<std::thread> threads;
   std::mt19937 generator(std::random_device{}());
@@ -429,6 +425,20 @@ TEST_F(HdfsFileSystemTest, writeFlushFailures) {
       "Cannot flush HDFS file because file handle is null, file path: /a.txt");
 }
 
+TEST_F(HdfsFileSystemTest, writeWithParentDirNotExist) {
+  std::string path = "/parent/directory/that/does/not/exist/a.txt";
+  auto writeFile = openFileForWrite(path);
+  std::string data = "abcdefghijk";
+  writeFile->append(data);
+  writeFile->flush();
+  ASSERT_EQ(writeFile->size(), 0);
+  writeFile->append(data);
+  writeFile->append(data);
+  writeFile->flush();
+  writeFile->close();
+  ASSERT_EQ(writeFile->size(), data.size() * 3);
+}
+
 TEST_F(HdfsFileSystemTest, readFailures) {
   struct hdfsBuilder* builder = hdfsNewBuilder();
   hdfsBuilderSetNameNode(builder, localhost.c_str());
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.cpp b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.cpp
index 10ee508ba638c..c262bad3d1d1e 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.cpp
@@ -38,7 +38,7 @@ void HdfsMiniCluster::start() {
         serverProcess_->exit_code(),
         383,
         "Minicluster process exited, code: ",
-        serverProcess_->exit_code())
+        serverProcess_->exit_code());
   } catch (const std::exception& e) {
     VELOX_FAIL("Failed to launch Minicluster server: {}", e.what());
   }
@@ -91,7 +91,7 @@ void HdfsMiniCluster::addFile(std::string source, std::string destination) {
   if (!isExited) {
     VELOX_FAIL(
         "Failed to add file to hdfs, exit code: {}",
-        filePutProcess->exit_code())
+        filePutProcess->exit_code());
   }
 }
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
index 55c0e3d8ba2e6..9571bb3c63790 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
@@ -23,10 +23,10 @@
 
 namespace facebook::velox::filesystems::test {
 static const std::string miniClusterExecutableName{"hadoop"};
-static const std::string hadoopSearchPath{":/usr/local/hadoop-2.10.1/bin"};
+static const std::string hadoopSearchPath{":/usr/local/hadoop/bin"};
 static const std::string jarCommand{"jar"};
 static const std::string miniclusterJar{
-    "/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-2.10.1-tests.jar"};
+    "/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.3.0-tests.jar"};
 static const std::string miniclusterCommand{"minicluster"};
 static const std::string noMapReduceOption{"-nomr"};
 static const std::string formatNameNodeOption{"-format"};
diff --git a/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
index ac84135d2b039..96d6031c1728d 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
@@ -14,18 +14,15 @@
 
 # for generated headers
 
-add_library(velox_s3fs RegisterS3FileSystem.cpp)
+velox_add_library(velox_s3fs RegisterS3FileSystem.cpp)
 if(VELOX_ENABLE_S3)
-  target_sources(velox_s3fs PRIVATE S3FileSystem.cpp S3Util.cpp)
+  velox_sources(velox_s3fs PRIVATE S3FileSystem.cpp S3Util.cpp)
 
-  target_include_directories(velox_s3fs PUBLIC ${AWSSDK_INCLUDE_DIRS})
-  target_link_libraries(velox_s3fs velox_dwio_common_exception Folly::folly
-                        ${AWSSDK_LIBRARIES} xsimd)
+  velox_include_directories(velox_s3fs PUBLIC ${AWSSDK_INCLUDE_DIRS})
+  velox_link_libraries(velox_s3fs velox_dwio_common Folly::folly
+                       ${AWSSDK_LIBRARIES})
 
   if(${VELOX_BUILD_TESTING})
     add_subdirectory(tests)
   endif()
-  if(${VELOX_ENABLE_BENCHMARKS})
-    add_subdirectory(benchmark)
-  endif()
 endif()
diff --git a/velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.cpp b/velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.cpp
index 5e8a9fd650c2d..6f746b1c1bc4d 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.cpp
@@ -15,84 +15,102 @@
  */
 
 #ifdef VELOX_ENABLE_S3
-#include "velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h"
-#include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
-#include "velox/core/Config.h"
+#include "velox/connectors/hive/HiveConfig.h" // @manual
+#include "velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h" // @manual
+#include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h" // @manual
 #include "velox/dwio/common/FileSink.h"
 #endif
 
-#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h" // @manual
 
 namespace facebook::velox::filesystems {
 
 #ifdef VELOX_ENABLE_S3
-folly::once_flag S3FSInstantiationFlag;
+using FileSystemMap = folly::Synchronized<
+    std::unordered_map<std::string, std::shared_ptr<FileSystem>>>;
 
-// Only one instance of S3FileSystem is supported for now.
-// TODO: Support multiple S3FileSystem instances using a cache
-static std::shared_ptr<S3FileSystem> s3fs = nullptr;
+/// Multiple S3 filesystems are supported.
+/// Key is the endpoint value specified in the config using hive.s3.endpoint.
+/// If the endpoint is empty, it will default to AWS S3.
+FileSystemMap& fileSystems() {
+  static FileSystemMap instances;
+  return instances;
+}
 
-std::function<std::shared_ptr<
-    FileSystem>(std::shared_ptr<const Config>, std::string_view)>
-fileSystemGenerator() {
-  static auto filesystemGenerator = [](std::shared_ptr<const Config> properties,
-                                       std::string_view filePath) {
-    folly::call_once(S3FSInstantiationFlag, [&properties]() {
-      std::shared_ptr<S3FileSystem> fs;
-      if (properties != nullptr) {
-        initializeS3(properties.get());
-        fs = std::make_shared<S3FileSystem>(properties);
-      } else {
-        auto config = std::make_shared<core::MemConfig>();
-        initializeS3(config.get());
-        fs = std::make_shared<S3FileSystem>(config);
-      }
-      s3fs = fs;
-    });
-    return s3fs;
-  };
-  return filesystemGenerator;
+std::string getS3Identity(const std::shared_ptr<config::ConfigBase>& config) {
+  HiveConfig hiveConfig = HiveConfig(config);
+  auto endpoint = hiveConfig.s3Endpoint();
+  if (!endpoint.empty()) {
+    // The identity is the endpoint.
+    return endpoint;
+  }
+  // Default key value.
+  return "aws-s3-key";
 }
 
-std::function<std::unique_ptr<velox::dwio::common::FileSink>(
-    const std::string&,
-    const velox::dwio::common::FileSink::Options& options)>
-s3WriteFileSinkGenerator() {
-  static auto s3WriteFileSink =
-      [](const std::string& fileURI,
-         const velox::dwio::common::FileSink::Options& options)
-      -> std::unique_ptr<dwio::common::WriteFileSink> {
-    if (isS3File(fileURI)) {
-      auto fileSystem =
-          filesystems::getFileSystem(fileURI, options.connectorProperties);
-      return std::make_unique<dwio::common::WriteFileSink>(
-          fileSystem->openFileForWrite(fileURI, {{}, options.pool}),
-          fileURI,
-          options.metricLogger,
-          options.stats);
-    }
-    return nullptr;
-  };
+std::shared_ptr<FileSystem> fileSystemGenerator(
+    std::shared_ptr<const config::ConfigBase> properties,
+    std::string_view /*filePath*/) {
+  std::shared_ptr<config::ConfigBase> config =
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>());
+  if (properties) {
+    config = std::make_shared<config::ConfigBase>(properties->rawConfigsCopy());
+  }
+  const auto s3Identity = getS3Identity(config);
 
-  return s3WriteFileSink;
+  return fileSystems().withWLock(
+      [&](auto& instanceMap) -> std::shared_ptr<FileSystem> {
+        initializeS3(config.get());
+        auto iterator = instanceMap.find(s3Identity);
+        if (iterator == instanceMap.end()) {
+          auto fs = std::make_shared<S3FileSystem>(properties);
+          instanceMap.insert({s3Identity, fs});
+          return fs;
+        }
+        return iterator->second;
+      });
+}
+
+std::unique_ptr<velox::dwio::common::FileSink> s3WriteFileSinkGenerator(
+    const std::string& fileURI,
+    const velox::dwio::common::FileSink::Options& options) {
+  if (isS3File(fileURI)) {
+    auto fileSystem =
+        filesystems::getFileSystem(fileURI, options.connectorProperties);
+    return std::make_unique<dwio::common::WriteFileSink>(
+        fileSystem->openFileForWrite(fileURI, {{}, options.pool, std::nullopt}),
+        fileURI,
+        options.metricLogger,
+        options.stats);
+  }
+  return nullptr;
 }
 #endif
 
 void registerS3FileSystem() {
 #ifdef VELOX_ENABLE_S3
-  if (!s3fs) {
-    registerFileSystem(isS3File, fileSystemGenerator());
-    dwio::common::FileSink::registerFactory(s3WriteFileSinkGenerator());
-  }
+  fileSystems().withWLock([&](auto& instanceMap) {
+    if (instanceMap.empty()) {
+      registerFileSystem(isS3File, std::function(fileSystemGenerator));
+      dwio::common::FileSink::registerFactory(
+          std::function(s3WriteFileSinkGenerator));
+    }
+  });
 #endif
 }
 
 void finalizeS3FileSystem() {
 #ifdef VELOX_ENABLE_S3
-  VELOX_CHECK(
-      !s3fs || (s3fs && s3fs.use_count() == 1),
-      "Cannot finalize S3FileSystem while in use");
-  s3fs.reset();
+  bool singleUseCount = true;
+  fileSystems().withWLock([&](auto& instanceMap) {
+    for (const auto& [id, fs] : instanceMap) {
+      singleUseCount &= (fs.use_count() == 1);
+    }
+    VELOX_CHECK(singleUseCount, "Cannot finalize S3FileSystem while in use");
+    instanceMap.clear();
+  });
+
   finalizeS3();
 #endif
 }
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
index 13f170da92923..7126774cea1fc 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
@@ -15,11 +15,12 @@
  */
 
 #include "velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h"
+#include "velox/common/config/Config.h"
 #include "velox/common/file/File.h"
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.h"
-#include "velox/core/Config.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/dwio/common/DataBuffer.h"
 
 #include <fmt/format.h>
@@ -29,6 +30,8 @@
 
 #include <aws/core/Aws.h>
 #include <aws/core/auth/AWSCredentialsProviderChain.h>
+#include <aws/core/client/AdaptiveRetryStrategy.h>
+#include <aws/core/client/DefaultRetryStrategy.h>
 #include <aws/core/http/HttpResponse.h>
 #include <aws/core/utils/logging/ConsoleLogSystem.h>
 #include <aws/core/utils/stream/PreallocatedStreamBuf.h>
@@ -69,7 +72,6 @@ Aws::IOStreamFactory AwsWriteableStreamFactory(void* data, int64_t nbytes) {
   return [=]() { return Aws::New<StringViewStream>("", data, nbytes); };
 }
 
-// TODO: Implement retry on failure.
 class S3ReadFile final : public ReadFile {
  public:
   S3ReadFile(const std::string& path, Aws::S3::S3Client* client)
@@ -79,7 +81,13 @@ class S3ReadFile final : public ReadFile {
 
   // Gets the length of the file.
   // Checks if there are any issues reading the file.
-  void initialize() {
+  void initialize(const filesystems::FileOptions& options) {
+    if (options.fileSize.has_value()) {
+      VELOX_CHECK_GE(
+          options.fileSize.value(), 0, "File size must be non-negative");
+      length_ = options.fileSize.value();
+    }
+
     // Make it a no-op if invoked twice.
     if (length_ != -1) {
       return;
@@ -255,6 +263,10 @@ class S3WriteFile::Impl {
       /// (https://github.com/apache/arrow/issues/11934). So we instead default
       /// to application/octet-stream which is less misleading.
       request.SetContentType(kApplicationOctetStream);
+      // The default algorithm used is MD5. However, MD5 is not supported with
+      // fips and can cause a SIGSEGV. Set CRC32 instead which is a standard for
+      // checksum computation and is not restricted by fips.
+      request.SetChecksumAlgorithm(Aws::S3::Model::ChecksumAlgorithm::CRC32);
 
       auto outcome = client_->CreateMultipartUpload(request);
       VELOX_CHECK_AWS_OUTCOME(
@@ -369,6 +381,10 @@ class S3WriteFile::Impl {
       request.SetContentLength(part.size());
       request.SetBody(
           std::make_shared<StringViewStream>(part.data(), part.size()));
+      // The default algorithm used is MD5. However, MD5 is not supported with
+      // fips and can cause a SIGSEGV. Set CRC32 instead which is a standard for
+      // checksum computation and is not restricted by fips.
+      request.SetChecksumAlgorithm(Aws::S3::Model::ChecksumAlgorithm::CRC32);
       auto outcome = client_->UploadPart(request);
       VELOX_CHECK_AWS_OUTCOME(outcome, "Failed to upload", bucket_, key_);
       // Append ETag and part number for this uploaded part.
@@ -378,6 +394,11 @@ class S3WriteFile::Impl {
 
       part.SetPartNumber(uploadState_.partNumber);
       part.SetETag(result.GetETag());
+      // Don't add the checksum to the part if the checksum is empty.
+      // Some filesystems such as IBM COS require this to be not set.
+      if (!result.GetChecksumCRC32().empty()) {
+        part.SetChecksumCRC32(result.GetChecksumCRC32());
+      }
       uploadState_.completedParts.push_back(std::move(part));
     }
   }
@@ -430,7 +451,7 @@ struct AwsInstance {
   }
 
   // Returns true iff the instance was newly initialized with config.
-  bool initialize(const Config* config) {
+  bool initialize(const config::ConfigBase* config) {
     if (isFinalized_.load()) {
       VELOX_FAIL("Attempt to initialize S3 after it has been finalized.");
     }
@@ -468,9 +489,11 @@ struct AwsInstance {
   }
 
  private:
-  void doInitialize(const Config* config) {
+  void doInitialize(const config::ConfigBase* config) {
+    std::shared_ptr<HiveConfig> hiveConfig = std::make_shared<HiveConfig>(
+        std::make_shared<config::ConfigBase>(config->rawConfigsCopy()));
     awsOptions_.loggingOptions.logLevel =
-        inferS3LogLevel(HiveConfig::s3GetLogLevel(config));
+        inferS3LogLevel(hiveConfig->s3GetLogLevel());
     // In some situations, curl triggers a SIGPIPE signal causing the entire
     // process to be terminated without any notification.
     // This behavior is seen via Prestissimo on AmazonLinux2 on AWS EC2.
@@ -493,7 +516,7 @@ AwsInstance* getAwsInstance() {
   return instance.get();
 }
 
-bool initializeS3(const Config* config) {
+bool initializeS3(const config::ConfigBase* config) {
   return getAwsInstance()->initialize(config);
 }
 
@@ -506,24 +529,65 @@ void finalizeS3() {
 
 class S3FileSystem::Impl {
  public:
-  Impl(const Config* config) : config_(config) {
+  Impl(const config::ConfigBase* config) {
+    hiveConfig_ = std::make_shared<HiveConfig>(
+        std::make_shared<config::ConfigBase>(config->rawConfigsCopy()));
     VELOX_CHECK(getAwsInstance()->isInitialized(), "S3 is not initialized");
     Aws::Client::ClientConfiguration clientConfig;
-    clientConfig.endpointOverride = HiveConfig::s3Endpoint(config_);
+    clientConfig.endpointOverride = hiveConfig_->s3Endpoint();
+
+    if (hiveConfig_->s3UseProxyFromEnv()) {
+      auto proxyConfig = S3ProxyConfigurationBuilder(hiveConfig_->s3Endpoint())
+                             .useSsl(hiveConfig_->s3UseSSL())
+                             .build();
+      if (proxyConfig.has_value()) {
+        clientConfig.proxyScheme = Aws::Http::SchemeMapper::FromString(
+            proxyConfig.value().scheme().c_str());
+        clientConfig.proxyHost = awsString(proxyConfig.value().host());
+        clientConfig.proxyPort = proxyConfig.value().port();
+        clientConfig.proxyUserName = awsString(proxyConfig.value().username());
+        clientConfig.proxyPassword = awsString(proxyConfig.value().password());
+      }
+    }
 
-    if (HiveConfig::s3UseSSL(config_)) {
+    if (hiveConfig_->s3UseSSL()) {
       clientConfig.scheme = Aws::Http::Scheme::HTTPS;
     } else {
       clientConfig.scheme = Aws::Http::Scheme::HTTP;
     }
 
+    if (hiveConfig_->s3ConnectTimeout().has_value()) {
+      clientConfig.connectTimeoutMs =
+          std::chrono::duration_cast<std::chrono::milliseconds>(
+              facebook::velox::config::toDuration(
+                  hiveConfig_->s3ConnectTimeout().value()))
+              .count();
+    }
+
+    if (hiveConfig_->s3SocketTimeout().has_value()) {
+      clientConfig.requestTimeoutMs =
+          std::chrono::duration_cast<std::chrono::milliseconds>(
+              facebook::velox::config::toDuration(
+                  hiveConfig_->s3SocketTimeout().value()))
+              .count();
+    }
+
+    if (hiveConfig_->s3MaxConnections().has_value()) {
+      clientConfig.maxConnections = hiveConfig_->s3MaxConnections().value();
+    }
+
+    auto retryStrategy = getRetryStrategy();
+    if (retryStrategy.has_value()) {
+      clientConfig.retryStrategy = retryStrategy.value();
+    }
+
     auto credentialsProvider = getCredentialsProvider();
 
     client_ = std::make_shared<Aws::S3::S3Client>(
         credentialsProvider,
         clientConfig,
         Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never,
-        HiveConfig::s3UseVirtualAddressing(config_));
+        hiveConfig_->s3UseVirtualAddressing());
     ++fileSystemCount;
   }
 
@@ -560,9 +624,9 @@ class S3FileSystem::Impl {
   // Return an AWSCredentialsProvider based on the config.
   std::shared_ptr<Aws::Auth::AWSCredentialsProvider> getCredentialsProvider()
       const {
-    auto accessKey = HiveConfig::s3AccessKey(config_);
-    auto secretKey = HiveConfig::s3SecretKey(config_);
-    const auto iamRole = HiveConfig::s3IAMRole(config_);
+    auto accessKey = hiveConfig_->s3AccessKey();
+    auto secretKey = hiveConfig_->s3SecretKey();
+    const auto iamRole = hiveConfig_->s3IAMRole();
 
     int keyCount = accessKey.has_value() + secretKey.has_value();
     // keyCount=0 means both are not specified
@@ -573,7 +637,7 @@ class S3FileSystem::Impl {
         "Invalid configuration: both access key and secret key must be specified");
 
     int configCount = (accessKey.has_value() && secretKey.has_value()) +
-        iamRole.has_value() + HiveConfig::s3UseInstanceCredentials(config_);
+        iamRole.has_value() + hiveConfig_->s3UseInstanceCredentials();
     VELOX_USER_CHECK(
         (configCount <= 1),
         "Invalid configuration: specify only one among 'access/secret keys', 'use instance credentials', 'IAM role'");
@@ -583,18 +647,70 @@ class S3FileSystem::Impl {
           accessKey.value(), secretKey.value());
     }
 
-    if (HiveConfig::s3UseInstanceCredentials(config_)) {
+    if (hiveConfig_->s3UseInstanceCredentials()) {
       return getDefaultCredentialsProvider();
     }
 
     if (iamRole.has_value()) {
       return getIAMRoleCredentialsProvider(
-          iamRole.value(), HiveConfig::s3IAMRoleSessionName(config_));
+          iamRole.value(), hiveConfig_->s3IAMRoleSessionName());
     }
 
     return getDefaultCredentialsProvider();
   }
 
+  // Return a client RetryStrategy based on the config.
+  std::optional<std::shared_ptr<Aws::Client::RetryStrategy>> getRetryStrategy()
+      const {
+    auto retryMode = hiveConfig_->s3RetryMode();
+    auto maxAttempts = hiveConfig_->s3MaxAttempts();
+    if (retryMode.has_value()) {
+      if (retryMode.value() == "standard") {
+        if (maxAttempts.has_value()) {
+          VELOX_USER_CHECK_GE(
+              maxAttempts.value(),
+              0,
+              "Invalid configuration: specified 'hive.s3.max-attempts' value {} is < 0.",
+              maxAttempts.value());
+          return std::make_shared<Aws::Client::StandardRetryStrategy>(
+              maxAttempts.value());
+        } else {
+          // Otherwise, use default value 3.
+          return std::make_shared<Aws::Client::StandardRetryStrategy>();
+        }
+      } else if (retryMode.value() == "adaptive") {
+        if (maxAttempts.has_value()) {
+          VELOX_USER_CHECK_GE(
+              maxAttempts.value(),
+              0,
+              "Invalid configuration: specified 'hive.s3.max-attempts' value {} is < 0.",
+              maxAttempts.value());
+          return std::make_shared<Aws::Client::AdaptiveRetryStrategy>(
+              maxAttempts.value());
+        } else {
+          // Otherwise, use default value 3.
+          return std::make_shared<Aws::Client::AdaptiveRetryStrategy>();
+        }
+      } else if (retryMode.value() == "legacy") {
+        if (maxAttempts.has_value()) {
+          VELOX_USER_CHECK_GE(
+              maxAttempts.value(),
+              0,
+              "Invalid configuration: specified 'hive.s3.max-attempts' value {} is < 0.",
+              maxAttempts.value());
+          return std::make_shared<Aws::Client::DefaultRetryStrategy>(
+              maxAttempts.value());
+        } else {
+          // Otherwise, use default value maxRetries = 10, scaleFactor = 25
+          return std::make_shared<Aws::Client::DefaultRetryStrategy>();
+        }
+      } else {
+        VELOX_USER_FAIL("Invalid retry mode for S3: {}", retryMode.value());
+      }
+    }
+    return std::nullopt;
+  }
+
   // Make it clear that the S3FileSystem instance owns the S3Client.
   // Once the S3FileSystem is destroyed, the S3Client fails to work
   // due to the Aws::ShutdownAPI invocation in the destructor.
@@ -607,11 +723,11 @@ class S3FileSystem::Impl {
   }
 
  private:
-  const Config* config_;
+  std::shared_ptr<HiveConfig> hiveConfig_;
   std::shared_ptr<Aws::S3::S3Client> client_;
 };
 
-S3FileSystem::S3FileSystem(std::shared_ptr<const Config> config)
+S3FileSystem::S3FileSystem(std::shared_ptr<const config::ConfigBase> config)
     : FileSystem(config) {
   impl_ = std::make_shared<Impl>(config.get());
 }
@@ -622,10 +738,10 @@ std::string S3FileSystem::getLogLevelName() const {
 
 std::unique_ptr<ReadFile> S3FileSystem::openFileForRead(
     std::string_view path,
-    const FileOptions& /*unused*/) {
+    const FileOptions& options) {
   const auto file = s3Path(path);
   auto s3file = std::make_unique<S3ReadFile>(file, impl_->s3Client());
-  s3file->initialize();
+  s3file->initialize(options);
   return s3file;
 }
 
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h
index 4240451ea2caa..088575760f991 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h
@@ -17,10 +17,12 @@
 #pragma once
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConfig.h"
 
 namespace facebook::velox::filesystems {
+using namespace facebook::velox::connector::hive;
 
-bool initializeS3(const Config* config);
+bool initializeS3(const config::ConfigBase* config);
 
 void finalizeS3();
 
@@ -29,7 +31,7 @@ void finalizeS3();
 /// type of file can be constructed based on a filename.
 class S3FileSystem : public FileSystem {
  public:
-  explicit S3FileSystem(std::shared_ptr<const Config> config);
+  explicit S3FileSystem(std::shared_ptr<const config::ConfigBase> config);
 
   std::string name() const override;
 
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3Util.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3Util.cpp
index 2df80d356cc4a..e312ca30ca51d 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3Util.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3Util.cpp
@@ -19,6 +19,8 @@
 // type of file can be constructed based on a filename. See the
 // (register|generate)ReadFile and (register|generate)WriteFile functions.
 
+#include "folly/IPAddress.h"
+
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
 
 namespace facebook::velox {
@@ -43,4 +45,107 @@ std::string getErrorStringFromS3Error(
   }
 }
 
+/// The noProxyList is a comma separated list of subdomains, domains or IP
+/// ranges (using CIDR). For a given hostname check if it has a matching
+/// subdomain, domain or IP range in the noProxyList.
+bool isHostExcludedFromProxy(
+    const std::string& hostname,
+    const std::string& noProxyList) {
+  std::vector<std::string> noProxyListElements{};
+
+  if (noProxyList.empty()) {
+    return false;
+  }
+
+  auto hostAsIp = folly::IPAddress::tryFromString(hostname);
+  folly::split(',', noProxyList, noProxyListElements);
+  for (auto elem : noProxyListElements) {
+    // Elem contains "/" which separates IP and subnet mask e.g. 192.168.1.0/24.
+    if (elem.find("/") != std::string::npos && hostAsIp.hasValue()) {
+      return hostAsIp.value().inSubnet(elem);
+    }
+    // Match subdomain, domain names and IP address strings.
+    else if (
+        elem.length() < hostname.length() && elem[0] == '.' &&
+        !hostname.compare(
+            hostname.length() - elem.length(), elem.length(), elem)) {
+      return true;
+    } else if (
+        elem.length() < hostname.length() && elem[0] == '*' && elem[1] == '.' &&
+        !hostname.compare(
+            hostname.length() - elem.length() + 1,
+            elem.length() - 1,
+            elem.substr(1))) {
+      return true;
+    } else if (elem.length() == hostname.length() && !hostname.compare(elem)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/// Reading the various proxy related environment variables.
+/// There is a lacking standard. The environment variables can be
+/// defined lower case or upper case. The lower case values are checked
+/// first and, if set, returned, therefore taking precendence.
+/// Note, the envVar input is expected to be lower case.
+namespace {
+std::string readProxyEnvVar(std::string envVar) {
+  auto httpProxy = getenv(envVar.c_str());
+  if (httpProxy) {
+    return std::string(httpProxy);
+  }
+
+  std::transform(envVar.begin(), envVar.end(), envVar.begin(), ::toupper);
+  httpProxy = getenv(envVar.c_str());
+  if (httpProxy) {
+    return std::string(httpProxy);
+  }
+  return "";
+};
+} // namespace
+
+std::string getHttpProxyEnvVar() {
+  return readProxyEnvVar("http_proxy");
+}
+
+std::string getHttpsProxyEnvVar() {
+  return readProxyEnvVar("https_proxy");
+};
+
+std::string getNoProxyEnvVar() {
+  return readProxyEnvVar("no_proxy");
+};
+
+std::optional<folly::Uri> S3ProxyConfigurationBuilder::build() {
+  std::string proxyUrl;
+  if (useSsl_) {
+    proxyUrl = getHttpsProxyEnvVar();
+  } else {
+    proxyUrl = getHttpProxyEnvVar();
+  }
+
+  if (proxyUrl.empty()) {
+    return std::nullopt;
+  }
+  folly::Uri proxyUri(proxyUrl);
+
+  /// The endpoint is usually a domain with port or an
+  /// IP address with port. It is assumed that there are
+  /// 2 parts separated by a colon.
+  std::vector<std::string> endpointElements{};
+  folly::split(':', s3Endpoint_, endpointElements);
+  if (FOLLY_UNLIKELY(endpointElements.size() > 2)) {
+    LOG(ERROR) << fmt::format(
+        "Too many parts in S3 endpoint URI {} ", s3Endpoint_);
+    return std::nullopt;
+  }
+
+  auto noProxy = getNoProxyEnvVar();
+  if (isHostExcludedFromProxy(endpointElements[0], noProxy)) {
+    return std::nullopt;
+  }
+  return proxyUri;
+}
+
 } // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3Util.h b/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
index c5a51d28c7afd..399b5c2740e69 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
@@ -23,9 +23,12 @@
 
 #include <aws/s3/S3Errors.h>
 #include <aws/s3/model/HeadObjectResult.h>
+#include <folly/Uri.h>
 
 #include "velox/common/base/Exceptions.h"
 
+#include <fmt/format.h>
+
 namespace facebook::velox {
 
 namespace {
@@ -154,21 +157,63 @@ inline std::string getRequestID(
 } // namespace
 
 /// Only Amazon (amz) and Alibaba (oss) request IDs are supported.
-#define VELOX_CHECK_AWS_OUTCOME(outcome, errorMsgPrefix, bucket, key)                                                          \
-  {                                                                                                                            \
-    if (!outcome.IsSuccess()) {                                                                                                \
-      auto error = outcome.GetError();                                                                                         \
-      VELOX_FAIL(                                                                                                              \
-          "{} due to: '{}'. Path:'{}', SDK Error Type:{}, HTTP Status Code:{}, S3 Service:'{}', Message:'{}', RequestID:'{}'", \
-          errorMsgPrefix,                                                                                                      \
-          getErrorStringFromS3Error(error),                                                                                    \
-          s3URI(bucket, key),                                                                                                  \
-          error.GetErrorType(),                                                                                                \
-          error.GetResponseCode(),                                                                                             \
-          getS3BackendService(error.GetResponseHeaders()),                                                                     \
-          error.GetMessage(),                                                                                                  \
-          getRequestID(error.GetResponseHeaders()))                                                                            \
-    }                                                                                                                          \
+#define VELOX_CHECK_AWS_OUTCOME(outcome, errorMsgPrefix, bucket, key)                                                           \
+  {                                                                                                                             \
+    if (!outcome.IsSuccess()) {                                                                                                 \
+      auto error = outcome.GetError();                                                                                          \
+      auto errMsg = fmt::format(                                                                                                \
+          "{} due to: '{}'. Path:'{}', SDK Error Type:{}, HTTP Status Code:{}, S3 Service:'{}', Message:'{}', RequestID:'{}'.", \
+          errorMsgPrefix,                                                                                                       \
+          getErrorStringFromS3Error(error),                                                                                     \
+          s3URI(bucket, key),                                                                                                   \
+          static_cast<int>(error.GetErrorType()),                                                                               \
+          error.GetResponseCode(),                                                                                              \
+          getS3BackendService(error.GetResponseHeaders()),                                                                      \
+          error.GetMessage(),                                                                                                   \
+          getRequestID(error.GetResponseHeaders()));                                                                            \
+      if (IsRetryableHttpResponseCode(error.GetResponseCode())) {                                                               \
+        auto retryHint = fmt::format(                                                                                           \
+            " Request failed after retrying {} times. Try increasing the value of 'hive.s3.max-attempts'.",                     \
+            outcome.GetRetryCount());                                                                                           \
+        errMsg.append(retryHint);                                                                                               \
+      }                                                                                                                         \
+      if (error.GetResponseCode() == Aws::Http::HttpResponseCode::NOT_FOUND) {                                                  \
+        VELOX_FILE_NOT_FOUND_ERROR(errMsg);                                                                                     \
+      }                                                                                                                         \
+      VELOX_FAIL(errMsg);                                                                                                       \
+    }                                                                                                                           \
+  }
+
+bool isHostExcludedFromProxy(
+    const std::string& hostname,
+    const std::string& noProxyList);
+
+std::string getHttpProxyEnvVar();
+std::string getHttpsProxyEnvVar();
+std::string getNoProxyEnvVar();
+
+class S3ProxyConfigurationBuilder {
+ public:
+  S3ProxyConfigurationBuilder(const std::string& s3Endpoint)
+      : s3Endpoint_(s3Endpoint){};
+
+  S3ProxyConfigurationBuilder& useSsl(const bool& useSsl) {
+    useSsl_ = useSsl;
+    return *this;
   }
 
+  std::optional<folly::Uri> build();
+
+ private:
+  const std::string s3Endpoint_;
+  bool useSsl_;
+};
+
 } // namespace facebook::velox
+
+template <>
+struct fmt::formatter<Aws::Http::HttpResponseCode> : formatter<int> {
+  auto format(Aws::Http::HttpResponseCode s, format_context& ctx) {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/connectors/hive/storage_adapters/s3fs/benchmark/CMakeLists.txt b/velox/connectors/hive/storage_adapters/s3fs/benchmark/CMakeLists.txt
deleted file mode 100644
index b3614d0f3d113..0000000000000
--- a/velox/connectors/hive/storage_adapters/s3fs/benchmark/CMakeLists.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_executable(velox_s3read_benchmark S3ReadBenchmark.cpp
-                                      S3ReadBenchmarkMain.cpp)
-
-target_link_libraries(
-  velox_s3read_benchmark
-  velox_read_benchmark_lib
-  velox_s3fs
-  velox_exception
-  velox_exec_test_lib
-  fmt::fmt
-  Folly::folly)
diff --git a/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmark.cpp b/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmark.cpp
deleted file mode 100644
index 8720f13c0b519..0000000000000
--- a/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmark.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmark.h"
-#include "velox/core/Config.h"
-
-#include <fstream>
-
-DEFINE_string(s3_config, "", "Path of S3 config file");
-
-namespace facebook::velox {
-
-// From presto-cpp
-std::shared_ptr<Config> readConfig(const std::string& filePath) {
-  std::ifstream configFile(filePath);
-  if (!configFile.is_open()) {
-    throw std::runtime_error(
-        fmt::format("Couldn't open config file {} for reading.", filePath));
-  }
-
-  std::unordered_map<std::string, std::string> properties;
-  std::string line;
-  while (getline(configFile, line)) {
-    line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());
-    if (line[0] == '#' || line.empty()) {
-      continue;
-    }
-    auto delimiterPos = line.find('=');
-    auto name = line.substr(0, delimiterPos);
-    auto value = line.substr(delimiterPos + 1);
-    properties.emplace(name, value);
-  }
-
-  return std::make_shared<facebook::velox::core::MemConfig>(properties);
-}
-
-} // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmark.h b/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmark.h
deleted file mode 100644
index 0f95f0f1ed62a..0000000000000
--- a/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmark.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/common/file/benchmark/ReadBenchmark.h"
-#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
-#include "velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h"
-
-DECLARE_string(s3_config);
-
-namespace facebook::velox {
-
-std::shared_ptr<Config> readConfig(const std::string& filePath);
-
-class S3ReadBenchmark : public ReadBenchmark {
- public:
-  // Initialize a S3ReadFile instance for the specified 'path'.
-  void initialize() override {
-    executor_ =
-        std::make_unique<folly::IOThreadPoolExecutor>(FLAGS_num_threads);
-
-    filesystems::registerS3FileSystem();
-    std::shared_ptr<Config> config;
-    if (!FLAGS_s3_config.empty()) {
-      config = readConfig(FLAGS_s3_config);
-    }
-    auto s3fs = filesystems::getFileSystem(FLAGS_path, config);
-    readFile_ = s3fs->openFileForRead(FLAGS_path);
-
-    fileSize_ = readFile_->size();
-    if (FLAGS_file_size_gb) {
-      fileSize_ = std::min<uint64_t>(FLAGS_file_size_gb << 30, fileSize_);
-    }
-
-    if (fileSize_ <= FLAGS_measurement_size) {
-      LOG(ERROR) << "File size " << fileSize_
-                 << " is <= then --measurement_size " << FLAGS_measurement_size;
-      exit(1);
-    }
-    if (FLAGS_seed) {
-      rng_.seed(FLAGS_seed);
-    }
-  }
-};
-
-} // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmarkMain.cpp b/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmarkMain.cpp
deleted file mode 100644
index 5b9d233f56f15..0000000000000
--- a/velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmarkMain.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/connectors/hive/storage_adapters/s3fs/benchmark/S3ReadBenchmark.h"
-
-using namespace facebook::velox;
-
-// This benchmark measures the throughput of an S3 compatible FileSystem for
-// various ReadFile APIs. The output helps us understand the maximum possible
-// gains for queries. Example: If a single thread requires reading 1GB of data
-// and the IO throughput is 100 MBps, then it takes 10 seconds to just read the
-// data.
-int main(int argc, char** argv) {
-  folly::init(&argc, &argv, false);
-  S3ReadBenchmark bm;
-  bm.initialize();
-  bm.run();
-}
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
index 21e70c1e3d1d3..852038c483b2c 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_s3file_test S3UtilTest.cpp S3FileSystemTest.cpp)
+add_executable(velox_s3file_test S3FileSystemTest.cpp S3UtilTest.cpp)
 add_test(velox_s3file_test velox_s3file_test)
 target_link_libraries(
   velox_s3file_test
@@ -23,8 +23,8 @@ target_link_libraries(
   velox_exec_test_lib
   velox_dwio_common_exception
   velox_exec
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(velox_s3registration_test S3FileSystemRegistrationTest.cpp)
 add_test(velox_s3registration_test velox_s3registration_test)
@@ -37,8 +37,8 @@ target_link_libraries(
   velox_exec_test_lib
   velox_dwio_common_exception
   velox_exec
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(velox_s3finalize_test S3FileSystemFinalizeTest.cpp)
 add_test(velox_s3finalize_test velox_s3finalize_test)
@@ -48,8 +48,8 @@ target_link_libraries(
   velox_hive_config
   velox_file
   velox_core
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(velox_s3insert_test S3InsertTest.cpp)
 add_test(velox_s3insert_test velox_s3insert_test)
@@ -62,5 +62,36 @@ target_link_libraries(
   velox_exec_test_lib
   velox_dwio_common_exception
   velox_exec
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
+
+add_executable(velox_s3read_test S3ReadTest.cpp)
+add_test(
+  NAME velox_s3read_test
+  COMMAND velox_s3read_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(
+  velox_s3read_test
+  velox_file
+  velox_s3fs
+  velox_hive_config
+  velox_core
+  velox_exec_test_lib
+  velox_dwio_common_exception
+  velox_exec
+  GTest::gtest
+  GTest::gtest_main)
+
+add_executable(velox_s3multiendpoints_test S3MultipleEndpointsTest.cpp)
+add_test(velox_s3multiendpoints_test velox_s3multiendpoints_test)
+target_link_libraries(
+  velox_s3multiendpoints_test
+  velox_file
+  velox_s3fs
+  velox_hive_config
+  velox_core
+  velox_exec_test_lib
+  velox_dwio_common_exception
+  velox_exec
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h b/velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h
index 64cf52b45b584..591ed403f350a 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h
@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-#include "velox/core/Config.h"
+#pragma once
+
+#include "velox/common/config/Config.h"
+#include "velox/exec/tests/utils/PortUtil.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include "boost/process.hpp"
@@ -22,7 +25,7 @@
 using namespace facebook::velox;
 
 namespace {
-constexpr char const* kMinioExecutableName{"minio"};
+constexpr char const* kMinioExecutableName{"minio-2022-05-26"};
 constexpr char const* kMinioAccessKey{"minio"};
 constexpr char const* kMinioSecretKey{"miniopass"};
 } // namespace
@@ -31,24 +34,27 @@ constexpr char const* kMinioSecretKey{"miniopass"};
 // Adapted from the Apache Arrow library.
 class MinioServer {
  public:
-  MinioServer(const std::string_view& connectionString)
-      : tempPath_(::exec::test::TempDirectoryPath::create()),
-        connectionString_(connectionString) {}
+  MinioServer() : tempPath_(::exec::test::TempDirectoryPath::create()) {
+    constexpr auto kHostAddressTemplate = "127.0.0.1:{}";
+    auto ports = facebook::velox::exec::test::getFreePorts(2);
+    connectionString_ = fmt::format(kHostAddressTemplate, ports[0]);
+    consoleAddress_ = fmt::format(kHostAddressTemplate, ports[1]);
+  }
 
   void start();
 
   void stop();
 
   void addBucket(const char* bucket) {
-    const std::string path = tempPath_->path + "/" + bucket;
+    const std::string path = tempPath_->getPath() + "/" + bucket;
     mkdir(path.c_str(), S_IRWXU | S_IRWXG);
   }
 
   std::string path() const {
-    return tempPath_->path;
+    return tempPath_->getPath();
   }
 
-  std::shared_ptr<const Config> hiveConfig(
+  std::shared_ptr<const config::ConfigBase> hiveConfig(
       const std::unordered_map<std::string, std::string> configOverride = {})
       const {
     std::unordered_map<std::string, std::string> config({
@@ -64,12 +70,13 @@ class MinioServer {
       config[configName] = configValue;
     }
 
-    return std::make_shared<const core::MemConfig>(std::move(config));
+    return std::make_shared<const config::ConfigBase>(std::move(config));
   }
 
  private:
   const std::shared_ptr<exec::test::TempDirectoryPath> tempPath_;
-  const std::string connectionString_;
+  std::string connectionString_;
+  std::string consoleAddress_;
   const std::string accessKey_ = kMinioAccessKey;
   const std::string secretKey_ = kMinioSecretKey;
   std::shared_ptr<::boost::process::child> serverProcess_;
@@ -85,6 +92,7 @@ void MinioServer::start() {
     VELOX_FAIL("Failed to find minio executable {}'", kMinioExecutableName);
   }
 
+  const auto path = tempPath_->getPath();
   try {
     serverProcess_ = std::make_shared<boost::process::child>(
         env,
@@ -94,7 +102,9 @@ void MinioServer::start() {
         "--compat",
         "--address",
         connectionString_,
-        tempPath_->path.c_str());
+        "--console-address",
+        consoleAddress_,
+        path.c_str());
   } catch (const std::exception& e) {
     VELOX_FAIL("Failed to launch Minio server: {}", e.what());
   }
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemFinalizeTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemFinalizeTest.cpp
index 1d713553e260f..1ee0387faa0ec 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemFinalizeTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemFinalizeTest.cpp
@@ -15,15 +15,17 @@
  */
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/config/Config.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h"
-#include "velox/core/Config.h"
 
 #include "gtest/gtest.h"
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
 
 TEST(S3FileSystemFinalizeTest, finalize) {
-  auto s3Config = std::make_shared<core::MemConfig>();
+  auto s3Config = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>());
   ASSERT_TRUE(filesystems::initializeS3(s3Config.get()));
   ASSERT_FALSE(filesystems::initializeS3(s3Config.get()));
   {
@@ -36,3 +38,6 @@ TEST(S3FileSystemFinalizeTest, finalize) {
       filesystems::initializeS3(s3Config.get()),
       "Attempt to initialize S3 after it has been finalized.");
 }
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemRegistrationTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemRegistrationTest.cpp
index 60b8fabb3e887..c247a74309438 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemRegistrationTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemRegistrationTest.cpp
@@ -17,28 +17,21 @@
 #include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h"
 
-using namespace facebook::velox;
-
-static constexpr std::string_view kMinioConnectionString = "127.0.0.1:8000";
+namespace facebook::velox {
+namespace {
 
 class S3FileSystemRegistrationTest : public S3Test {
  protected:
-  static void SetUpTestSuite() {
-    if (minioServer_ == nullptr) {
-      minioServer_ = std::make_shared<MinioServer>(kMinioConnectionString);
-      minioServer_->start();
-    }
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
     filesystems::registerS3FileSystem();
   }
 
-  static void TearDownTestSuite() {
+  static void TearDownTestCase() {
     filesystems::finalizeS3FileSystem();
-    if (minioServer_ != nullptr) {
-      minioServer_->stop();
-      minioServer_ = nullptr;
-    }
   }
 };
+} // namespace
 
 TEST_F(S3FileSystemRegistrationTest, readViaRegistry) {
   const char* bucketName = "data2";
@@ -71,11 +64,10 @@ TEST_F(S3FileSystemRegistrationTest, fileHandle) {
   }
   auto hiveConfig = minioServer_->hiveConfig();
   FileHandleFactory factory(
-      std::make_unique<
-          SimpleLRUCache<std::string, std::shared_ptr<FileHandle>>>(1000),
+      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(1000),
       std::make_unique<FileHandleGenerator>(hiveConfig));
-  auto fileHandle = factory.generate(s3File).second;
-  readData(fileHandle->file.get());
+  auto fileHandleCachePtr = factory.generate(s3File);
+  readData(fileHandleCachePtr->file.get());
 }
 
 TEST_F(S3FileSystemRegistrationTest, finalize) {
@@ -85,3 +77,4 @@ TEST_F(S3FileSystemRegistrationTest, finalize) {
       filesystems::finalizeS3FileSystem(),
       "Cannot finalize S3FileSystem while in use");
 }
+} // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
index d74ba33d2c6ae..1b92147d5b88d 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
@@ -20,31 +20,31 @@
 
 #include <gtest/gtest.h>
 
-using namespace facebook::velox;
-
-static constexpr std::string_view kMinioConnectionString = "127.0.0.1:9000";
+namespace facebook::velox {
+namespace {
 
 class S3FileSystemTest : public S3Test {
  protected:
-  static void SetUpTestSuite() {
-    if (minioServer_ == nullptr) {
-      minioServer_ = std::make_shared<MinioServer>(kMinioConnectionString);
-      minioServer_->start();
-    }
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    S3Test::SetUp();
     auto hiveConfig = minioServer_->hiveConfig({{"hive.s3.log-level", "Info"}});
     filesystems::initializeS3(hiveConfig.get());
   }
 
   static void TearDownTestSuite() {
-    if (minioServer_ != nullptr) {
-      minioServer_->stop();
-      minioServer_ = nullptr;
-    }
     filesystems::finalizeS3();
   }
 };
+} // namespace
 
 TEST_F(S3FileSystemTest, writeAndRead) {
+  /// The hive config used for Minio defaults to turning
+  /// off using proxy settings if the environment provides them.
+  setenv("HTTP_PROXY", "http://test:test@127.0.0.1:8888", 1);
   const char* bucketName = "data";
   const char* file = "test.txt";
   const std::string filename = localPath(bucketName) + "/" + file;
@@ -62,11 +62,11 @@ TEST_F(S3FileSystemTest, writeAndRead) {
 
 TEST_F(S3FileSystemTest, invalidCredentialsConfig) {
   {
-    const std::unordered_map<std::string, std::string> config(
+    std::unordered_map<std::string, std::string> config(
         {{"hive.s3.use-instance-credentials", "true"},
          {"hive.s3.iam-role", "dummy-iam-role"}});
     auto hiveConfig =
-        std::make_shared<const core::MemConfig>(std::move(config));
+        std::make_shared<const config::ConfigBase>(std::move(config));
 
     // Both instance credentials and iam-role cannot be specified
     VELOX_ASSERT_THROW(
@@ -74,34 +74,34 @@ TEST_F(S3FileSystemTest, invalidCredentialsConfig) {
         "Invalid configuration: specify only one among 'access/secret keys', 'use instance credentials', 'IAM role'");
   }
   {
-    const std::unordered_map<std::string, std::string> config(
+    std::unordered_map<std::string, std::string> config(
         {{"hive.s3.aws-secret-key", "dummy-key"},
          {"hive.s3.aws-access-key", "dummy-key"},
          {"hive.s3.iam-role", "dummy-iam-role"}});
     auto hiveConfig =
-        std::make_shared<const core::MemConfig>(std::move(config));
+        std::make_shared<const config::ConfigBase>(std::move(config));
     // Both access/secret keys and iam-role cannot be specified
     VELOX_ASSERT_THROW(
         filesystems::S3FileSystem(hiveConfig),
         "Invalid configuration: specify only one among 'access/secret keys', 'use instance credentials', 'IAM role'");
   }
   {
-    const std::unordered_map<std::string, std::string> config(
+    std::unordered_map<std::string, std::string> config(
         {{"hive.s3.aws-secret-key", "dummy"},
          {"hive.s3.aws-access-key", "dummy"},
          {"hive.s3.use-instance-credentials", "true"}});
     auto hiveConfig =
-        std::make_shared<const core::MemConfig>(std::move(config));
+        std::make_shared<const config::ConfigBase>(std::move(config));
     // Both access/secret keys and instance credentials cannot be specified
     VELOX_ASSERT_THROW(
         filesystems::S3FileSystem(hiveConfig),
         "Invalid configuration: specify only one among 'access/secret keys', 'use instance credentials', 'IAM role'");
   }
   {
-    const std::unordered_map<std::string, std::string> config(
+    std::unordered_map<std::string, std::string> config(
         {{"hive.s3.aws-secret-key", "dummy"}});
     auto hiveConfig =
-        std::make_shared<const core::MemConfig>(std::move(config));
+        std::make_shared<const config::ConfigBase>(std::move(config));
     // Both access key and secret key must be specified
     VELOX_ASSERT_THROW(
         filesystems::S3FileSystem(hiveConfig),
@@ -116,16 +116,18 @@ TEST_F(S3FileSystemTest, missingFile) {
   addBucket(bucketName);
   auto hiveConfig = minioServer_->hiveConfig();
   filesystems::S3FileSystem s3fs(hiveConfig);
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_RUNTIME_THROW_CODE(
       s3fs.openFileForRead(s3File),
+      error_code::kFileNotFound,
       "Failed to get metadata for S3 object due to: 'Resource not found'. Path:'s3://data1/i-do-not-exist.txt', SDK Error Type:16, HTTP Status Code:404, S3 Service:'MinIO', Message:'No response body.'");
 }
 
 TEST_F(S3FileSystemTest, missingBucket) {
   auto hiveConfig = minioServer_->hiveConfig();
   filesystems::S3FileSystem s3fs(hiveConfig);
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_RUNTIME_THROW_CODE(
       s3fs.openFileForRead(kDummyPath),
+      error_code::kFileNotFound,
       "Failed to get metadata for S3 object due to: 'Resource not found'. Path:'s3://dummy/foo.txt', SDK Error Type:16, HTTP Status Code:404, S3 Service:'MinIO', Message:'No response body.'");
 }
 
@@ -165,7 +167,8 @@ TEST_F(S3FileSystemTest, noBackendServer) {
 TEST_F(S3FileSystemTest, logLevel) {
   std::unordered_map<std::string, std::string> config;
   auto checkLogLevelName = [&config](std::string_view expected) {
-    auto s3Config = std::make_shared<const core::MemConfig>(config);
+    auto s3Config =
+        std::make_shared<const config::ConfigBase>(std::move(config));
     filesystems::S3FileSystem s3fs(s3Config);
     EXPECT_EQ(s3fs.getLogLevelName(), expected);
   };
@@ -187,8 +190,9 @@ TEST_F(S3FileSystemTest, writeFileAndRead) {
 
   auto hiveConfig = minioServer_->hiveConfig();
   filesystems::S3FileSystem s3fs(hiveConfig);
-  auto pool = memory::defaultMemoryManager().addLeafPool("S3FileSystemTest");
-  auto writeFile = s3fs.openFileForWrite(s3File, {{}, pool.get()});
+  auto pool = memory::memoryManager()->addLeafPool("S3FileSystemTest");
+  auto writeFile =
+      s3fs.openFileForWrite(s3File, {{}, pool.get(), std::nullopt});
   auto s3WriteFile = dynamic_cast<filesystems::S3WriteFile*>(writeFile.get());
   std::string dataContent =
       "Dance me to your beauty with a burning violin"
@@ -250,3 +254,13 @@ TEST_F(S3FileSystemTest, writeFileAndRead) {
   // Verify the last chunk.
   ASSERT_EQ(readFile->pread(contentSize * 250'000, contentSize), dataContent);
 }
+
+TEST_F(S3FileSystemTest, invalidConnectionSettings) {
+  auto hiveConfig =
+      minioServer_->hiveConfig({{"hive.s3.connect-timeout", "400"}});
+  VELOX_ASSERT_THROW(filesystems::S3FileSystem(hiveConfig), "Invalid duration");
+
+  hiveConfig = minioServer_->hiveConfig({{"hive.s3.socket-timeout", "abc"}});
+  VELOX_ASSERT_THROW(filesystems::S3FileSystem(hiveConfig), "Invalid duration");
+}
+} // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3InsertTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3InsertTest.cpp
index 57dfcded14c07..727b62f98e178 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3InsertTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3InsertTest.cpp
@@ -15,62 +15,46 @@
  */
 
 #include <folly/init/Init.h>
+#include <gtest/gtest.h>
 
-#include "gtest/gtest.h"
-#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/Memory.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
-#include "velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h"
-#include "velox/dwio/parquet/reader/ParquetReader.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h"
 #include "velox/exec/TableWriter.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
-using namespace facebook::velox;
-using namespace facebook::velox::core;
-using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
-using namespace facebook::velox::connector;
-using namespace facebook::velox::connector::hive;
-using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::test;
-using namespace facebook::velox::filesystems;
-
-class S3InsertTest : public testing::Test, public VectorTestBase {
- public:
-  static constexpr char const* kMinioConnectionString{"127.0.0.1:7000"};
-  /// We use static initialization because we want a single version of the
-  /// Minio server running.
-  /// Each test must use a unique bucket to avoid concurrency issues.
-  static void SetUpTestSuite() {
-    minioServer_ = std::make_shared<MinioServer>(kMinioConnectionString);
-    minioServer_->start();
-
-    ioExecutor_ = std::make_unique<folly::IOThreadPoolExecutor>(3);
+
+namespace facebook::velox {
+namespace {
+
+class S3InsertTest : public S3Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    S3Test::SetUp();
     filesystems::registerS3FileSystem();
     auto hiveConnector =
         connector::getConnectorFactory(
             connector::hive::HiveConnectorFactory::kHiveConnectorName)
             ->newConnector(
-                kHiveConnectorId,
+                ::exec::test::kHiveConnectorId,
                 minioServer_->hiveConfig(),
                 ioExecutor_.get());
     connector::registerConnector(hiveConnector);
   }
 
-  static void TearDownTestSuite() {
+  void TearDown() override {
+    connector::unregisterConnector(::exec::test::kHiveConnectorId);
+    S3Test::TearDown();
     filesystems::finalizeS3FileSystem();
-    unregisterConnector(kHiveConnectorId);
-    minioServer_->stop();
-    minioServer_ = nullptr;
   }
-
-  static std::shared_ptr<MinioServer> minioServer_;
-  static std::unique_ptr<folly::IOThreadPoolExecutor> ioExecutor_;
 };
-std::shared_ptr<MinioServer> S3InsertTest::minioServer_ = nullptr;
-std::unique_ptr<folly::IOThreadPoolExecutor> S3InsertTest::ioExecutor_ =
-    nullptr;
+} // namespace
 
 TEST_F(S3InsertTest, s3InsertTest) {
   const int64_t kExpectedRows = 1'000;
@@ -100,14 +84,14 @@ TEST_F(S3InsertTest, s3InsertTest) {
 
   // First column has number of rows written in the first row and nulls in other
   // rows.
-  auto rowCount = results->childAt(TableWriteTraits::kRowCountChannel)
+  auto rowCount = results->childAt(exec::TableWriteTraits::kRowCountChannel)
                       ->as<FlatVector<int64_t>>();
   ASSERT_FALSE(rowCount->isNullAt(0));
   ASSERT_EQ(kExpectedRows, rowCount->valueAt(0));
   ASSERT_TRUE(rowCount->isNullAt(1));
 
   // Second column contains details about written files.
-  auto details = results->childAt(TableWriteTraits::kFragmentChannel)
+  auto details = results->childAt(exec::TableWriteTraits::kFragmentChannel)
                      ->as<FlatVector<StringView>>();
   ASSERT_TRUE(details->isNullAt(0));
   ASSERT_FALSE(details->isNullAt(1));
@@ -122,16 +106,19 @@ TEST_F(S3InsertTest, s3InsertTest) {
   // Read from 'writeFileName' and verify the data matches the original.
   plan = PlanBuilder().tableScan(rowType).planNode();
 
-  auto splits = HiveConnectorTestBase::makeHiveConnectorSplits(
-      fmt::format("{}/{}", kOutputDirectory, writeFileName),
-      1,
-      dwio::common::FileFormat::PARQUET);
-  auto copy = AssertQueryBuilder(plan).split(splits[0]).copyResults(pool());
+  auto filePath = fmt::format("{}{}", kOutputDirectory, writeFileName);
+  const int64_t fileSize = fileWriteInfos[0]["fileSize"].asInt();
+  auto split = HiveConnectorSplitBuilder(filePath)
+                   .fileFormat(dwio::common::FileFormat::PARQUET)
+                   .length(fileSize)
+                   .build();
+  auto copy = AssertQueryBuilder(plan).split(split).copyResults(pool());
   assertEqualResults({input}, {copy});
 }
+} // namespace facebook::velox
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp
new file mode 100644
index 0000000000000..6e87626bf675d
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+
+#include "gtest/gtest.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h"
+#include "velox/exec/TableWriter.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+static const std::string_view kConnectorId1 = "test-hive1";
+static const std::string_view kConnectorId2 = "test-hive2";
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox {
+namespace {
+
+class S3MultipleEndpoints : public S3Test {
+ public:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    S3Test::SetUp();
+    filesystems::registerS3FileSystem();
+    auto hiveConnector1 =
+        connector::getConnectorFactory(
+            connector::hive::HiveConnectorFactory::kHiveConnectorName)
+            ->newConnector(
+                std::string(kConnectorId1),
+                minioServer_->hiveConfig(),
+                ioExecutor_.get());
+    connector::registerConnector(hiveConnector1);
+    minioSecondServer_ = std::make_unique<MinioServer>();
+    minioSecondServer_->start();
+    auto hiveConnector2 =
+        connector::getConnectorFactory(
+            connector::hive::HiveConnectorFactory::kHiveConnectorName)
+            ->newConnector(
+                std::string(kConnectorId2),
+                minioSecondServer_->hiveConfig(),
+                ioExecutor_.get());
+    connector::registerConnector(hiveConnector2);
+  }
+
+  void TearDown() override {
+    connector::unregisterConnector(std::string(kConnectorId1));
+    connector::unregisterConnector(std::string(kConnectorId2));
+    S3Test::TearDown();
+    filesystems::finalizeS3FileSystem();
+  }
+
+  folly::dynamic writeData(
+      const RowVectorPtr input,
+      const std::string& outputDirectory,
+      const std::string& connectorId) {
+    auto plan = PlanBuilder()
+                    .values({input})
+                    .tableWrite(
+                        outputDirectory.data(),
+                        {},
+                        0,
+                        {},
+                        {},
+                        dwio::common::FileFormat::PARQUET,
+                        {},
+                        connectorId)
+                    .planNode();
+    // Execute the write plan.
+    auto results = AssertQueryBuilder(plan).copyResults(pool());
+    // Second column contains details about written files.
+    auto details = results->childAt(exec::TableWriteTraits::kFragmentChannel)
+                       ->as<FlatVector<StringView>>();
+    folly::dynamic obj = folly::parseJson(details->valueAt(1));
+    return obj["fileWriteInfos"];
+  }
+
+  std::shared_ptr<connector::hive::HiveConnectorSplit> createSplit(
+      folly::dynamic tableWriteInfo,
+      std::string outputDirectory,
+      std::string connectorId) {
+    auto writeFileName = tableWriteInfo[0]["writeFileName"].asString();
+    auto filePath = fmt::format("{}{}", outputDirectory, writeFileName);
+    const int64_t fileSize = tableWriteInfo[0]["fileSize"].asInt();
+
+    return HiveConnectorSplitBuilder(filePath)
+        .connectorId(connectorId)
+        .fileFormat(dwio::common::FileFormat::PARQUET)
+        .length(fileSize)
+        .build();
+  }
+
+  std::unique_ptr<MinioServer> minioSecondServer_;
+};
+} // namespace
+
+TEST_F(S3MultipleEndpoints, s3Join) {
+  const int64_t kExpectedRows = 1'000;
+  const std::string_view kOutputDirectory{"s3://writedata/"};
+
+  auto rowType1 = ROW(
+      {"a0", "a1", "a2", "a3"}, {BIGINT(), INTEGER(), SMALLINT(), DOUBLE()});
+  auto rowType2 = ROW(
+      {"b0", "b1", "b2", "b3"}, {BIGINT(), INTEGER(), SMALLINT(), DOUBLE()});
+
+  auto input1 = makeRowVector(
+      rowType1->names(),
+      {makeFlatVector<int64_t>(kExpectedRows, [](auto row) { return row; }),
+       makeFlatVector<int32_t>(kExpectedRows, [](auto row) { return row; }),
+       makeFlatVector<int16_t>(kExpectedRows, [](auto row) { return row; }),
+       makeFlatVector<double>(kExpectedRows, [](auto row) { return row; })});
+  auto input2 = makeRowVector(rowType2->names(), input1->children());
+  minioServer_->addBucket("writedata");
+  minioSecondServer_->addBucket("writedata");
+
+  // Insert input data into both tables.
+  auto table1WriteInfo =
+      writeData(input1, kOutputDirectory.data(), std::string(kConnectorId1));
+  auto table2WriteInfo =
+      writeData(input2, kOutputDirectory.data(), std::string(kConnectorId2));
+
+  // Inner Join both the tables.
+  core::PlanNodeId scan1, scan2;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto table1Scan = PlanBuilder(planNodeIdGenerator, pool())
+                        .startTableScan()
+                        .tableName("hive_table1")
+                        .outputType(rowType1)
+                        .connectorId(std::string(kConnectorId1))
+                        .endTableScan()
+                        .capturePlanNodeId(scan1)
+                        .planNode();
+  auto join =
+      PlanBuilder(planNodeIdGenerator, pool())
+          .startTableScan()
+          .tableName("hive_table1")
+          .outputType(rowType2)
+          .connectorId(std::string(kConnectorId2))
+          .endTableScan()
+          .capturePlanNodeId(scan2)
+          .hashJoin({"b0"}, {"a0"}, table1Scan, "", {"a0", "a1", "a2", "a3"})
+          .planNode();
+
+  auto split1 = createSplit(
+      table1WriteInfo, kOutputDirectory.data(), std::string(kConnectorId1));
+  auto split2 = createSplit(
+      table2WriteInfo, kOutputDirectory.data(), std::string(kConnectorId2));
+  auto results = AssertQueryBuilder(join)
+                     .split(scan1, split1)
+                     .split(scan2, split2)
+                     .copyResults(pool());
+  assertEqualResults({input1}, {results});
+}
+} // namespace facebook::velox
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::Init init{&argc, &argv, false};
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp
new file mode 100644
index 0000000000000..c53d08764ecbc
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h"
+#include "velox/dwio/common/tests/utils/DataFiles.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox {
+namespace {
+
+class S3ReadTest : public S3Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    S3Test::SetUp();
+    filesystems::registerS3FileSystem();
+    auto hiveConnector =
+        connector::getConnectorFactory(
+            connector::hive::HiveConnectorFactory::kHiveConnectorName)
+            ->newConnector(kHiveConnectorId, minioServer_->hiveConfig());
+    connector::registerConnector(hiveConnector);
+  }
+
+  void TearDown() override {
+    filesystems::finalizeS3FileSystem();
+    connector::unregisterConnector(kHiveConnectorId);
+    S3Test::TearDown();
+  }
+};
+} // namespace
+
+TEST_F(S3ReadTest, s3ReadTest) {
+  const auto sourceFile = test::getDataFilePath(
+      "velox/connectors/hive/storage_adapters/s3fs/tests",
+      "../../../../../dwio/parquet/tests/examples/int.parquet");
+  const char* bucketName = "data";
+  const auto destinationFile = S3Test::localPath(bucketName) + "/int.parquet";
+  minioServer_->addBucket(bucketName);
+  std::ifstream src(sourceFile, std::ios::binary);
+  std::ofstream dest(destinationFile, std::ios::binary);
+  // Copy source file to destination bucket.
+  dest << src.rdbuf();
+  ASSERT_GT(dest.tellp(), 0) << "Unable to copy from source " << sourceFile;
+  dest.close();
+
+  // Read the parquet file via the S3 bucket.
+  const auto readDirectory{s3URI(bucketName)};
+  auto rowType = ROW({"int", "bigint"}, {INTEGER(), BIGINT()});
+  auto plan = PlanBuilder().tableScan(rowType).planNode();
+  auto split = HiveConnectorSplitBuilder(
+                   fmt::format("{}/{}", readDirectory, "int.parquet"))
+                   .fileFormat(dwio::common::FileFormat::PARQUET)
+                   .build();
+  auto copy = AssertQueryBuilder(plan).split(split).copyResults(pool());
+
+  // expectedResults is the data in int.parquet file.
+  const int64_t kExpectedRows = 10;
+  auto expectedResults = makeRowVector(
+      {makeFlatVector<int32_t>(
+           kExpectedRows, [](auto row) { return row + 100; }),
+       makeFlatVector<int64_t>(
+           kExpectedRows, [](auto row) { return row + 1000; })});
+  assertEqualResults({expectedResults}, {copy});
+}
+} // namespace facebook::velox
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::Init init{&argc, &argv, false};
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h b/velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h
index ef43f899468f5..cc7f003ee877d 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h
@@ -20,6 +20,7 @@
 #include "velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/tests/MinioServer.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/TempFilePath.h"
 
 #include "gtest/gtest.h"
@@ -30,8 +31,18 @@ constexpr int kOneMB = 1 << 20;
 
 static constexpr std::string_view kDummyPath = "s3://dummy/foo.txt";
 
-class S3Test : public testing::Test {
+class S3Test : public testing::Test, public ::test::VectorTestBase {
  protected:
+  void SetUp() override {
+    minioServer_ = std::make_unique<MinioServer>();
+    minioServer_->start();
+    ioExecutor_ = std::make_unique<folly::IOThreadPoolExecutor>(3);
+  }
+
+  void TearDown() override {
+    minioServer_->stop();
+  }
+
   void addBucket(const char* bucket) {
     minioServer_->addBucket(bucket);
   }
@@ -76,7 +87,8 @@ class S3Test : public testing::Test {
         folly::Range<char*>(middle, sizeof(middle)),
         folly::Range<char*>(
             nullptr,
-            (char*)(uint64_t)(15 + kOneMB - 500000 - sizeof(head) - sizeof(middle) - sizeof(tail))),
+            (char*)(uint64_t)(15 + kOneMB - 500000 - sizeof(head) -
+                              sizeof(middle) - sizeof(tail))),
         folly::Range<char*>(tail, sizeof(tail))};
     ASSERT_EQ(15 + kOneMB, readFile->preadv(0, buffers));
     ASSERT_EQ(std::string_view(head, sizeof(head)), "aaaaabbbbbcc");
@@ -84,7 +96,6 @@ class S3Test : public testing::Test {
     ASSERT_EQ(std::string_view(tail, sizeof(tail)), "ccddddd");
   }
 
-  static std::shared_ptr<MinioServer> minioServer_;
+  std::unique_ptr<MinioServer> minioServer_;
+  std::unique_ptr<folly::IOThreadPoolExecutor> ioExecutor_;
 };
-
-std::shared_ptr<MinioServer> S3Test::minioServer_ = nullptr;
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3UtilTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3UtilTest.cpp
index 9501781bcda9d..eb3b5dbff450d 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3UtilTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3UtilTest.cpp
@@ -18,7 +18,7 @@
 
 #include "gtest/gtest.h"
 
-using namespace facebook::velox;
+namespace facebook::velox {
 
 // TODO: Each prefix should be implemented as its own filesystem.
 TEST(S3UtilTest, isS3File) {
@@ -108,3 +108,142 @@ TEST(S3UtilTest, bucketAndKeyFromS3Path) {
   EXPECT_EQ(bucket, "bucket");
   EXPECT_EQ(key, "file.txt");
 }
+
+TEST(S3UtilTest, isDomainExcludedFromProxy) {
+  auto hostname = "test.foobar.com";
+
+  std::vector<std::pair<std::string, bool>> tests = {
+      {"localhost,.foobar.com", true},
+      {"localhost,.,foobar.com,.com", true},
+      {"localhost,test.foobar.com", true},
+      {"localhost,foobar.com,*.com", true},
+      {"localhost,*.foobar.com", true},
+      {"localhost", false},
+      {"localhost,foobar.com", false},
+      {"", false},
+  };
+
+  for (auto pair : tests) {
+    EXPECT_EQ(isHostExcludedFromProxy(hostname, pair.first), pair.second);
+  }
+}
+
+TEST(S3UtilTest, isIpExcludedFromProxy) {
+  auto hostname = "127.0.0.1";
+
+  std::vector<std::pair<std::string, bool>> tests = {
+      {"localhost,127.0.0.1,.foobar.com", true},
+      {"localhost,127.0.0.0/24,.foobar.com", true},
+      {"localhost,foobar.com,127.0.0.0/16,.1,.com", true},
+      {"localhost,foobar.com,.1,.com", true},
+      {"localhost,test.foobar.com", false},
+      {"localhost,foobar.com,*.1,*.com", true},
+      {"localhost", false},
+      {"localhost,127.1.0.1", false},
+      {"", false},
+  };
+
+  for (auto pair : tests) {
+    EXPECT_EQ(isHostExcludedFromProxy(hostname, pair.first), pair.second)
+        << pair.first;
+  }
+}
+
+class S3UtilProxyTest : public ::testing::TestWithParam<bool> {};
+
+TEST_P(S3UtilProxyTest, proxyBuilderBadEndpoint) {
+  auto s3Endpoint = "http://127.0.0.1:8888";
+  auto useSsl = GetParam();
+
+  setenv("HTTP_PROXY", "http://127.0.0.1:12345", 1);
+  setenv("HTTPS_PROXY", "http://127.0.0.1:12345", 1);
+  EXPECT_FALSE(S3ProxyConfigurationBuilder(s3Endpoint)
+                   .useSsl(useSsl)
+                   .build()
+                   .has_value());
+}
+
+TEST_P(S3UtilProxyTest, proxyBuilderNoProxy) {
+  auto s3Endpoint = "127.0.0.1:8888";
+  auto useSsl = GetParam();
+
+  setenv("HTTP_PROXY", "", 1);
+  setenv("HTTPS_PROXY", "", 1);
+  EXPECT_FALSE(S3ProxyConfigurationBuilder(s3Endpoint)
+                   .useSsl(useSsl)
+                   .build()
+                   .has_value());
+}
+
+TEST_P(S3UtilProxyTest, proxyBuilderSameHttpProxy) {
+  auto s3Endpoint = "192.168.0.1:12345";
+  auto useSsl = GetParam();
+
+  setenv("HTTP_PROXY", "http://127.0.0.1:8888", 1);
+  setenv("HTTPS_PROXY", "http://127.0.0.1:8888", 1);
+  auto proxyConfig =
+      S3ProxyConfigurationBuilder(s3Endpoint).useSsl(useSsl).build();
+  ASSERT_TRUE(proxyConfig.has_value());
+  EXPECT_EQ(proxyConfig.value().scheme(), "http");
+  EXPECT_EQ(proxyConfig.value().host(), "127.0.0.1");
+  EXPECT_EQ(proxyConfig.value().port(), 8888);
+  EXPECT_EQ(proxyConfig.value().username(), "");
+  EXPECT_EQ(proxyConfig.value().password(), "");
+}
+
+TEST_P(S3UtilProxyTest, proxyBuilderMixProxy) {
+  auto s3Endpoint = "192.168.0.1:12345";
+  auto useSsl = GetParam();
+
+  const std::string httpProxy = "https://test1:testpw1@80.67.3.1:35631";
+  setenv("HTTP_PROXY", httpProxy.c_str(), 1);
+  EXPECT_EQ(getHttpProxyEnvVar(), httpProxy)
+      << "HTTP_PROXY environment variable not set.";
+  const std::string httpsProxy = "http://test2:testpw2@80.80.5.1:45631";
+  setenv("HTTPS_PROXY", httpsProxy.c_str(), 1);
+  EXPECT_EQ(getHttpsProxyEnvVar(), httpsProxy)
+      << "HTTPS_PROXY environment variable not set.";
+  auto proxyConfig =
+      S3ProxyConfigurationBuilder(s3Endpoint).useSsl(useSsl).build();
+  ASSERT_TRUE(proxyConfig.has_value());
+  EXPECT_EQ(proxyConfig.value().scheme(), (useSsl ? "http" : "https"));
+  EXPECT_EQ(proxyConfig.value().host(), (useSsl ? "80.80.5.1" : "80.67.3.1"));
+  EXPECT_EQ(proxyConfig.value().port(), (useSsl ? 45631 : 35631));
+  EXPECT_EQ(proxyConfig.value().username(), (useSsl ? "test2" : "test1"));
+  EXPECT_EQ(proxyConfig.value().password(), (useSsl ? "testpw2" : "testpw1"));
+}
+
+TEST_P(S3UtilProxyTest, proxyBuilderMixProxyLowerCase) {
+  auto s3Endpoint = "192.168.0.1:12345";
+  auto useSsl = GetParam();
+
+  const std::string lcHttpProxy = "https://lctest1:lctestpw1@80.67.3.1:35631";
+  const std::string ucHttpProxy = "https://uctest1:uctestpw1@80.67.3.2:35632";
+  setenv("http_proxy", lcHttpProxy.c_str(), 1);
+  setenv("HTTP_PROXY", ucHttpProxy.c_str(), 1);
+  // Lower case value takes precedence.
+  EXPECT_EQ(getHttpProxyEnvVar(), lcHttpProxy)
+      << "http_proxy environment variable not set.";
+  const std::string lcHttpsProxy = "http://lctest2:lctestpw2@80.80.5.1:45631";
+  const std::string ucHttpsProxy = "http://uctest2:uctestpw2@80.80.5.2:45632";
+  setenv("https_proxy", lcHttpsProxy.c_str(), 1);
+  setenv("HTTPS_PROXY", ucHttpsProxy.c_str(), 1);
+  EXPECT_EQ(getHttpsProxyEnvVar(), lcHttpsProxy)
+      << "https_proxy environment variable not set.";
+  auto proxyConfig =
+      S3ProxyConfigurationBuilder(s3Endpoint).useSsl(useSsl).build();
+  ASSERT_TRUE(proxyConfig.has_value());
+  EXPECT_EQ(proxyConfig.value().scheme(), (useSsl ? "http" : "https"));
+  EXPECT_EQ(proxyConfig.value().host(), (useSsl ? "80.80.5.1" : "80.67.3.1"));
+  EXPECT_EQ(proxyConfig.value().port(), (useSsl ? 45631 : 35631));
+  EXPECT_EQ(proxyConfig.value().username(), (useSsl ? "lctest2" : "lctest1"));
+  EXPECT_EQ(
+      proxyConfig.value().password(), (useSsl ? "lctestpw2" : "lctestpw1"));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    S3UtilTest,
+    S3UtilProxyTest,
+    ::testing::Values(true, false));
+
+} // namespace facebook::velox
diff --git a/velox/connectors/hive/tests/CMakeLists.txt b/velox/connectors/hive/tests/CMakeLists.txt
index f3b348ca1767b..f4235cfa13c05 100644
--- a/velox/connectors/hive/tests/CMakeLists.txt
+++ b/velox/connectors/hive/tests/CMakeLists.txt
@@ -13,12 +13,14 @@
 # limitations under the License.
 add_executable(
   velox_hive_connector_test
-  HiveDataSinkTest.cpp
-  HivePartitionFunctionTest.cpp
   FileHandleTest.cpp
-  HivePartitionUtilTest.cpp
+  HiveConfigTest.cpp
+  HiveDataSinkTest.cpp
   HiveConnectorTest.cpp
+  HiveConnectorUtilTest.cpp
   HiveConnectorSerDeTest.cpp
+  HivePartitionFunctionTest.cpp
+  HivePartitionUtilTest.cpp
   PartitionIdGeneratorTest.cpp
   TableHandleTest.cpp)
 add_test(velox_hive_connector_test velox_hive_connector_test)
@@ -32,5 +34,14 @@ target_link_libraries(
   velox_vector_test_lib
   velox_exec
   velox_exec_test_lib
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
+
+if(VELOX_ENABLE_PARQUET)
+
+  target_include_directories(velox_hive_connector_test
+                             PUBLIC ${ARROW_PREFIX}/install/include)
+  target_link_libraries(velox_hive_connector_test
+                        velox_dwio_native_parquet_reader)
+
+endif()
diff --git a/velox/connectors/hive/tests/FileHandleTest.cpp b/velox/connectors/hive/tests/FileHandleTest.cpp
index 659f0299f9eeb..e641cb3916270 100644
--- a/velox/connectors/hive/tests/FileHandleTest.cpp
+++ b/velox/connectors/hive/tests/FileHandleTest.cpp
@@ -27,8 +27,8 @@ using namespace facebook::velox;
 TEST(FileHandleTest, localFile) {
   filesystems::registerLocalFileSystem();
 
-  auto tempFile = ::exec::test::TempFilePath::create();
-  const auto& filename = tempFile->path;
+  auto tempFile = exec::test::TempFilePath::create();
+  const auto& filename = tempFile->getPath();
   remove(filename.c_str());
 
   {
@@ -37,10 +37,35 @@ TEST(FileHandleTest, localFile) {
   }
 
   FileHandleFactory factory(
-      std::make_unique<
-          SimpleLRUCache<std::string, std::shared_ptr<FileHandle>>>(1000),
+      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(1000),
       std::make_unique<FileHandleGenerator>());
-  auto fileHandle = factory.generate(filename).second;
+  auto fileHandle = factory.generate(filename);
+  ASSERT_EQ(fileHandle->file->size(), 3);
+  char buffer[3];
+  ASSERT_EQ(fileHandle->file->pread(0, 3, &buffer), "foo");
+
+  // Clean up
+  remove(filename.c_str());
+}
+
+TEST(FileHandleTest, localFileWithProperties) {
+  filesystems::registerLocalFileSystem();
+
+  auto tempFile = exec::test::TempFilePath::create();
+  const auto& filename = tempFile->getPath();
+  remove(filename.c_str());
+
+  {
+    LocalWriteFile writeFile(filename);
+    writeFile.append("foo");
+  }
+
+  FileHandleFactory factory(
+      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(1000),
+      std::make_unique<FileHandleGenerator>());
+  FileProperties properties = {
+      tempFile->fileSize(), tempFile->fileModifiedTime()};
+  auto fileHandle = factory.generate(filename, &properties);
   ASSERT_EQ(fileHandle->file->size(), 3);
   char buffer[3];
   ASSERT_EQ(fileHandle->file->pread(0, 3, &buffer), "foo");
diff --git a/velox/connectors/hive/tests/HiveConfigTest.cpp b/velox/connectors/hive/tests/HiveConfigTest.cpp
new file mode 100644
index 0000000000000..b7bbfdbc7904b
--- /dev/null
+++ b/velox/connectors/hive/tests/HiveConfigTest.cpp
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/HiveConfig.h"
+#include "gtest/gtest.h"
+#include "velox/common/config/Config.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::connector::hive;
+using facebook::velox::connector::hive::HiveConfig;
+
+TEST(HiveConfigTest, defaultConfig) {
+  HiveConfig hiveConfig(std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>()));
+  const auto emptySession = std::make_unique<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>());
+  ASSERT_EQ(
+      hiveConfig.insertExistingPartitionsBehavior(emptySession.get()),
+      facebook::velox::connector::hive::HiveConfig::
+          InsertExistingPartitionsBehavior::kError);
+  ASSERT_EQ(hiveConfig.maxPartitionsPerWriters(emptySession.get()), 100);
+  ASSERT_EQ(hiveConfig.immutablePartitions(), false);
+  ASSERT_EQ(hiveConfig.s3UseVirtualAddressing(), true);
+  ASSERT_EQ(hiveConfig.s3GetLogLevel(), "FATAL");
+  ASSERT_EQ(hiveConfig.s3UseSSL(), true);
+  ASSERT_EQ(hiveConfig.s3UseInstanceCredentials(), false);
+  ASSERT_EQ(hiveConfig.s3Endpoint(), "");
+  ASSERT_EQ(hiveConfig.s3AccessKey(), std::nullopt);
+  ASSERT_EQ(hiveConfig.s3SecretKey(), std::nullopt);
+  ASSERT_EQ(hiveConfig.s3IAMRole(), std::nullopt);
+  ASSERT_EQ(hiveConfig.s3IAMRoleSessionName(), "velox-session");
+  ASSERT_EQ(hiveConfig.gcsEndpoint(), "");
+  ASSERT_EQ(hiveConfig.gcsScheme(), "https");
+  ASSERT_EQ(hiveConfig.gcsCredentials(), "");
+  ASSERT_EQ(hiveConfig.isOrcUseColumnNames(emptySession.get()), false);
+  ASSERT_EQ(
+      hiveConfig.isFileColumnNamesReadAsLowerCase(emptySession.get()), false);
+
+  ASSERT_EQ(hiveConfig.maxCoalescedBytes(), 128 << 20);
+  ASSERT_EQ(hiveConfig.maxCoalescedDistanceBytes(), 512 << 10);
+  ASSERT_EQ(hiveConfig.numCacheFileHandles(), 20'000);
+  ASSERT_EQ(hiveConfig.isFileHandleCacheEnabled(), true);
+  ASSERT_EQ(
+      hiveConfig.orcWriterMaxStripeSize(emptySession.get()),
+      64L * 1024L * 1024L);
+  ASSERT_EQ(
+      hiveConfig.orcWriterMaxDictionaryMemory(emptySession.get()),
+      16L * 1024L * 1024L);
+  ASSERT_EQ(
+      hiveConfig.isOrcWriterIntegerDictionaryEncodingEnabled(
+          emptySession.get()),
+      true);
+  ASSERT_EQ(
+      hiveConfig.isOrcWriterStringDictionaryEncodingEnabled(emptySession.get()),
+      true);
+  ASSERT_EQ(hiveConfig.sortWriterMaxOutputRows(emptySession.get()), 1024);
+  ASSERT_EQ(
+      hiveConfig.sortWriterMaxOutputBytes(emptySession.get()), 10UL << 20);
+  ASSERT_EQ(hiveConfig.isPartitionPathAsLowerCase(emptySession.get()), true);
+  ASSERT_EQ(hiveConfig.allowNullPartitionKeys(emptySession.get()), true);
+  ASSERT_EQ(hiveConfig.orcWriterMinCompressionSize(emptySession.get()), 1024);
+  ASSERT_EQ(
+      hiveConfig.orcWriterCompressionLevel(emptySession.get()), std::nullopt);
+  ASSERT_EQ(
+      hiveConfig.orcWriterLinearStripeSizeHeuristics(emptySession.get()), true);
+  ASSERT_FALSE(hiveConfig.cacheNoRetention(emptySession.get()));
+}
+
+TEST(HiveConfigTest, overrideConfig) {
+  std::unordered_map<std::string, std::string> configFromFile = {
+      {HiveConfig::kInsertExistingPartitionsBehavior, "OVERWRITE"},
+      {HiveConfig::kMaxPartitionsPerWriters, "120"},
+      {HiveConfig::kImmutablePartitions, "true"},
+      {HiveConfig::kS3PathStyleAccess, "true"},
+      {HiveConfig::kS3LogLevel, "Warning"},
+      {HiveConfig::kS3SSLEnabled, "false"},
+      {HiveConfig::kS3UseInstanceCredentials, "true"},
+      {HiveConfig::kS3Endpoint, "hey"},
+      {HiveConfig::kS3AwsAccessKey, "hello"},
+      {HiveConfig::kS3AwsSecretKey, "hello"},
+      {HiveConfig::kS3IamRole, "hello"},
+      {HiveConfig::kS3IamRoleSessionName, "velox"},
+      {HiveConfig::kGCSEndpoint, "hey"},
+      {HiveConfig::kGCSScheme, "http"},
+      {HiveConfig::kGCSCredentials, "hey"},
+      {HiveConfig::kOrcUseColumnNames, "true"},
+      {HiveConfig::kFileColumnNamesReadAsLowerCase, "true"},
+      {HiveConfig::kAllowNullPartitionKeys, "false"},
+      {HiveConfig::kMaxCoalescedBytes, "100"},
+      {HiveConfig::kMaxCoalescedDistanceBytes, "100"},
+      {HiveConfig::kNumCacheFileHandles, "100"},
+      {HiveConfig::kEnableFileHandleCache, "false"},
+      {HiveConfig::kOrcWriterMaxStripeSize, "100MB"},
+      {HiveConfig::kOrcWriterMaxDictionaryMemory, "100MB"},
+      {HiveConfig::kOrcWriterIntegerDictionaryEncodingEnabled, "false"},
+      {HiveConfig::kOrcWriterStringDictionaryEncodingEnabled, "false"},
+      {HiveConfig::kSortWriterMaxOutputRows, "100"},
+      {HiveConfig::kSortWriterMaxOutputBytes, "100MB"},
+      {HiveConfig::kOrcWriterLinearStripeSizeHeuristics, "false"},
+      {HiveConfig::kOrcWriterMinCompressionSize, "512"},
+      {HiveConfig::kOrcWriterCompressionLevel, "1"},
+      {HiveConfig::kCacheNoRetention, "true"}};
+  HiveConfig hiveConfig(
+      std::make_shared<config::ConfigBase>(std::move(configFromFile)));
+  auto emptySession = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>());
+  ASSERT_EQ(
+      hiveConfig.insertExistingPartitionsBehavior(emptySession.get()),
+      facebook::velox::connector::hive::HiveConfig::
+          InsertExistingPartitionsBehavior::kOverwrite);
+  ASSERT_EQ(hiveConfig.maxPartitionsPerWriters(emptySession.get()), 120);
+  ASSERT_EQ(hiveConfig.immutablePartitions(), true);
+  ASSERT_EQ(hiveConfig.s3UseVirtualAddressing(), false);
+  ASSERT_EQ(hiveConfig.s3GetLogLevel(), "Warning");
+  ASSERT_EQ(hiveConfig.s3UseSSL(), false);
+  ASSERT_EQ(hiveConfig.s3UseInstanceCredentials(), true);
+  ASSERT_EQ(hiveConfig.s3Endpoint(), "hey");
+  ASSERT_EQ(hiveConfig.s3AccessKey(), std::optional("hello"));
+  ASSERT_EQ(hiveConfig.s3SecretKey(), std::optional("hello"));
+  ASSERT_EQ(hiveConfig.s3IAMRole(), std::optional("hello"));
+  ASSERT_EQ(hiveConfig.s3IAMRoleSessionName(), "velox");
+  ASSERT_EQ(hiveConfig.gcsEndpoint(), "hey");
+  ASSERT_EQ(hiveConfig.gcsScheme(), "http");
+  ASSERT_EQ(hiveConfig.gcsCredentials(), "hey");
+  ASSERT_EQ(hiveConfig.isOrcUseColumnNames(emptySession.get()), true);
+  ASSERT_EQ(
+      hiveConfig.isFileColumnNamesReadAsLowerCase(emptySession.get()), true);
+  ASSERT_EQ(hiveConfig.allowNullPartitionKeys(emptySession.get()), false);
+  ASSERT_EQ(hiveConfig.maxCoalescedBytes(), 100);
+  ASSERT_EQ(hiveConfig.maxCoalescedDistanceBytes(), 100);
+  ASSERT_EQ(hiveConfig.numCacheFileHandles(), 100);
+  ASSERT_EQ(hiveConfig.isFileHandleCacheEnabled(), false);
+  ASSERT_EQ(
+      hiveConfig.orcWriterMaxStripeSize(emptySession.get()),
+      100L * 1024L * 1024L);
+  ASSERT_EQ(
+      hiveConfig.orcWriterMaxDictionaryMemory(emptySession.get()),
+      100L * 1024L * 1024L);
+  ASSERT_EQ(
+      hiveConfig.isOrcWriterIntegerDictionaryEncodingEnabled(
+          emptySession.get()),
+      false);
+  ASSERT_EQ(
+      hiveConfig.isOrcWriterStringDictionaryEncodingEnabled(emptySession.get()),
+      false);
+  ASSERT_EQ(hiveConfig.sortWriterMaxOutputRows(emptySession.get()), 100);
+  ASSERT_EQ(
+      hiveConfig.sortWriterMaxOutputBytes(emptySession.get()), 100UL << 20);
+  ASSERT_EQ(hiveConfig.orcWriterMinCompressionSize(emptySession.get()), 512);
+  ASSERT_EQ(hiveConfig.orcWriterCompressionLevel(emptySession.get()), 1);
+  ASSERT_EQ(
+      hiveConfig.orcWriterLinearStripeSizeHeuristics(emptySession.get()),
+      false);
+  ASSERT_TRUE(hiveConfig.cacheNoRetention(emptySession.get()));
+}
+
+TEST(HiveConfigTest, overrideSession) {
+  HiveConfig hiveConfig(std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>()));
+  std::unordered_map<std::string, std::string> sessionOverride = {
+      {HiveConfig::kInsertExistingPartitionsBehaviorSession, "OVERWRITE"},
+      {HiveConfig::kOrcUseColumnNamesSession, "true"},
+      {HiveConfig::kFileColumnNamesReadAsLowerCaseSession, "true"},
+      {HiveConfig::kOrcWriterMaxStripeSizeSession, "22MB"},
+      {HiveConfig::kOrcWriterMaxDictionaryMemorySession, "22MB"},
+      {HiveConfig::kOrcWriterIntegerDictionaryEncodingEnabledSession, "false"},
+      {HiveConfig::kOrcWriterStringDictionaryEncodingEnabledSession, "false"},
+      {HiveConfig::kSortWriterMaxOutputRowsSession, "20"},
+      {HiveConfig::kSortWriterMaxOutputBytesSession, "20MB"},
+      {HiveConfig::kPartitionPathAsLowerCaseSession, "false"},
+      {HiveConfig::kAllowNullPartitionKeysSession, "false"},
+      {HiveConfig::kIgnoreMissingFilesSession, "true"},
+      {HiveConfig::kOrcWriterMinCompressionSizeSession, "512"},
+      {HiveConfig::kOrcWriterCompressionLevelSession, "1"},
+      {HiveConfig::kOrcWriterLinearStripeSizeHeuristicsSession, "false"},
+      {HiveConfig::kCacheNoRetentionSession, "true"}};
+  const auto session =
+      std::make_unique<config::ConfigBase>(std::move(sessionOverride));
+  ASSERT_EQ(
+      hiveConfig.insertExistingPartitionsBehavior(session.get()),
+      facebook::velox::connector::hive::HiveConfig::
+          InsertExistingPartitionsBehavior::kOverwrite);
+  ASSERT_EQ(hiveConfig.maxPartitionsPerWriters(session.get()), 100);
+  ASSERT_EQ(hiveConfig.immutablePartitions(), false);
+  ASSERT_EQ(hiveConfig.s3UseVirtualAddressing(), true);
+  ASSERT_EQ(hiveConfig.s3GetLogLevel(), "FATAL");
+  ASSERT_EQ(hiveConfig.s3UseSSL(), true);
+  ASSERT_EQ(hiveConfig.s3UseInstanceCredentials(), false);
+  ASSERT_EQ(hiveConfig.s3Endpoint(), "");
+  ASSERT_EQ(hiveConfig.s3AccessKey(), std::nullopt);
+  ASSERT_EQ(hiveConfig.s3SecretKey(), std::nullopt);
+  ASSERT_EQ(hiveConfig.s3IAMRole(), std::nullopt);
+  ASSERT_EQ(hiveConfig.s3IAMRoleSessionName(), "velox-session");
+  ASSERT_EQ(hiveConfig.gcsEndpoint(), "");
+  ASSERT_EQ(hiveConfig.gcsScheme(), "https");
+  ASSERT_EQ(hiveConfig.gcsCredentials(), "");
+  ASSERT_EQ(hiveConfig.isOrcUseColumnNames(session.get()), true);
+  ASSERT_EQ(hiveConfig.isFileColumnNamesReadAsLowerCase(session.get()), true);
+
+  ASSERT_EQ(hiveConfig.maxCoalescedBytes(), 128 << 20);
+  ASSERT_EQ(hiveConfig.maxCoalescedDistanceBytes(), 512 << 10);
+  ASSERT_EQ(hiveConfig.numCacheFileHandles(), 20'000);
+  ASSERT_EQ(hiveConfig.isFileHandleCacheEnabled(), true);
+  ASSERT_EQ(
+      hiveConfig.orcWriterMaxStripeSize(session.get()), 22L * 1024L * 1024L);
+  ASSERT_EQ(
+      hiveConfig.orcWriterMaxDictionaryMemory(session.get()),
+      22L * 1024L * 1024L);
+  ASSERT_EQ(
+      hiveConfig.isOrcWriterIntegerDictionaryEncodingEnabled(session.get()),
+      false);
+  ASSERT_EQ(
+      hiveConfig.isOrcWriterStringDictionaryEncodingEnabled(session.get()),
+      false);
+  ASSERT_EQ(hiveConfig.sortWriterMaxOutputRows(session.get()), 20);
+  ASSERT_EQ(hiveConfig.sortWriterMaxOutputBytes(session.get()), 20UL << 20);
+  ASSERT_EQ(hiveConfig.isPartitionPathAsLowerCase(session.get()), false);
+  ASSERT_EQ(hiveConfig.allowNullPartitionKeys(session.get()), false);
+  ASSERT_EQ(hiveConfig.ignoreMissingFiles(session.get()), true);
+  ASSERT_EQ(
+      hiveConfig.orcWriterLinearStripeSizeHeuristics(session.get()), false);
+  ASSERT_EQ(hiveConfig.orcWriterMinCompressionSize(session.get()), 512);
+  ASSERT_EQ(hiveConfig.orcWriterCompressionLevel(session.get()), 1);
+  ASSERT_TRUE(hiveConfig.cacheNoRetention(session.get()));
+}
diff --git a/velox/connectors/hive/tests/HiveConnectorTest.cpp b/velox/connectors/hive/tests/HiveConnectorTest.cpp
index b0becde79d98a..49f12ac6a113b 100644
--- a/velox/connectors/hive/tests/HiveConnectorTest.cpp
+++ b/velox/connectors/hive/tests/HiveConnectorTest.cpp
@@ -17,8 +17,9 @@
 #include <gtest/gtest.h>
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/connectors/hive/HiveConfig.h"
-#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/connectors/hive/HiveDataSource.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 
@@ -31,7 +32,7 @@ using namespace facebook::velox::exec::test;
 class HiveConnectorTest : public exec::test::HiveConnectorTestBase {
  protected:
   std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::addDefaultLeafMemoryPool();
+      memory::memoryManager()->addLeafPool();
 };
 
 void validateNullConstant(const ScanSpec& spec, const Type& type) {
@@ -62,6 +63,11 @@ groupSubfields(const std::vector<Subfield>& subfields) {
   return grouped;
 }
 
+bool mapKeyIsNotNull(const ScanSpec& mapSpec) {
+  return dynamic_cast<IsNotNull*>(
+      mapSpec.childByName(ScanSpec::kMapKeysFieldName)->filter());
+}
+
 TEST_F(HiveConnectorTest, hiveConfig) {
   ASSERT_EQ(
       HiveConfig::insertExistingPartitionsBehaviorString(
@@ -85,8 +91,15 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_multilevel) {
             VARCHAR(), ROW({{"c0c1c0", BIGINT()}, {"c0c1c1", BIGINT()}})))}});
   auto rowType = ROW({{"c0", columnType}});
   auto subfields = makeSubfields({"c0.c0c1[3][\"foo\"].c0c1c0"});
-  auto scanSpec = HiveDataSource::makeScanSpec(
-      rowType, groupSubfields(subfields), {}, nullptr, pool_.get());
+  auto scanSpec = makeScanSpec(
+      rowType,
+      groupSubfields(subfields),
+      {},
+      nullptr,
+      {},
+      {},
+      nullptr,
+      pool_.get());
   auto* c0c0 = scanSpec->childByName("c0")->childByName("c0c0");
   validateNullConstant(*c0c0, *BIGINT());
   auto* c0c1 = scanSpec->childByName("c0")->childByName("c0c1");
@@ -114,12 +127,15 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_mergeFields) {
              {"c0c0c2", BIGINT()}})},
        {"c0c1", ROW({{"c0c1c0", BIGINT()}, {"c0c1c1", BIGINT()}})}});
   auto rowType = ROW({{"c0", columnType}});
-  auto scanSpec = HiveDataSource::makeScanSpec(
+  auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields(
           {"c0.c0c0.c0c0c0", "c0.c0c0.c0c0c2", "c0.c0c1", "c0.c0c1.c0c1c0"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   auto* c0c0 = scanSpec->childByName("c0")->childByName("c0c0");
   ASSERT_FALSE(c0c0->childByName("c0c0c0")->isConstant());
@@ -136,32 +152,53 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_mergeArray) {
   auto columnType =
       ARRAY(ROW({{"c0c0", BIGINT()}, {"c0c1", BIGINT()}, {"c0c2", BIGINT()}}));
   auto rowType = ROW({{"c0", columnType}});
-  auto scanSpec = HiveDataSource::makeScanSpec(
+  auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[1].c0c0", "c0[2].c0c2"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
   ASSERT_EQ(c0->maxArrayElementsCount(), 2);
+  ASSERT_TRUE(c0->flatMapFeatureSelection().empty());
   auto* elements = c0->childByName(ScanSpec::kArrayElementsFieldName);
   ASSERT_FALSE(elements->childByName("c0c0")->isConstant());
   ASSERT_FALSE(elements->childByName("c0c2")->isConstant());
   validateNullConstant(*elements->childByName("c0c1"), *BIGINT());
 }
 
+TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_mergeArrayNegative) {
+  auto columnType =
+      ARRAY(ROW({{"c0c0", BIGINT()}, {"c0c1", BIGINT()}, {"c0c2", BIGINT()}}));
+  auto rowType = ROW({{"c0", columnType}});
+  auto subfields = makeSubfields({"c0[1].c0c0", "c0[-1].c0c2"});
+  auto groupedSubfields = groupSubfields(subfields);
+  VELOX_ASSERT_USER_THROW(
+      makeScanSpec(
+          rowType, groupedSubfields, {}, nullptr, {}, {}, nullptr, pool_.get()),
+      "Non-positive array subscript cannot be push down");
+}
+
 TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_mergeMap) {
   auto columnType =
       MAP(BIGINT(),
           ROW({{"c0c0", BIGINT()}, {"c0c1", BIGINT()}, {"c0c2", BIGINT()}}));
   auto rowType = ROW({{"c0", columnType}});
-  auto scanSpec = HiveDataSource::makeScanSpec(
+  auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[10].c0c0", "c0[20].c0c2"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
+  ASSERT_EQ(
+      c0->flatMapFeatureSelection(), std::vector<std::string>({"10", "20"}));
   auto* keysFilter = c0->childByName(ScanSpec::kMapKeysFieldName)->filter();
   ASSERT_TRUE(keysFilter);
   ASSERT_TRUE(applyFilter(*keysFilter, 10));
@@ -179,14 +216,18 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_allSubscripts) {
   auto rowType = ROW({{"c0", columnType}});
   for (auto* path : {"c0", "c0[*]", "c0[*][*]"}) {
     SCOPED_TRACE(path);
-    auto scanSpec = HiveDataSource::makeScanSpec(
+    auto scanSpec = makeScanSpec(
         rowType,
         groupSubfields(makeSubfields({path})),
         {},
         nullptr,
+        {},
+        {},
+        nullptr,
         pool_.get());
     auto* c0 = scanSpec->childByName("c0");
-    ASSERT_FALSE(c0->childByName(ScanSpec::kMapKeysFieldName)->filter());
+    ASSERT_TRUE(c0->flatMapFeatureSelection().empty());
+    ASSERT_TRUE(mapKeyIsNotNull(*c0));
     auto* values = c0->childByName(ScanSpec::kMapValuesFieldName);
     ASSERT_EQ(
         values->maxArrayElementsCount(),
@@ -196,14 +237,17 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_allSubscripts) {
     ASSERT_FALSE(elements->childByName("c0c0")->isConstant());
     ASSERT_FALSE(elements->childByName("c0c1")->isConstant());
   }
-  auto scanSpec = HiveDataSource::makeScanSpec(
+  auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[*][*].c0c0"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
-  ASSERT_FALSE(c0->childByName(ScanSpec::kMapKeysFieldName)->filter());
+  ASSERT_TRUE(mapKeyIsNotNull(*c0));
   auto* values = c0->childByName(ScanSpec::kMapValuesFieldName);
   ASSERT_EQ(
       values->maxArrayElementsCount(),
@@ -217,11 +261,14 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_allSubscripts) {
 TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_doubleMapKey) {
   auto rowType =
       ROW({{"c0", MAP(REAL(), BIGINT())}, {"c1", MAP(DOUBLE(), BIGINT())}});
-  auto scanSpec = HiveDataSource::makeScanSpec(
+  auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[0]", "c1[-1]"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   auto* keysFilter = scanSpec->childByName("c0")
                          ->childByName(ScanSpec::kMapKeysFieldName)
@@ -242,12 +289,15 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_doubleMapKey) {
   ASSERT_FALSE(applyFilter(*keysFilter, -2.0));
 
   // Integer min and max means infinities.
-  scanSpec = HiveDataSource::makeScanSpec(
+  scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields(
           {"c0[-9223372036854775808]", "c1[9223372036854775807]"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   keysFilter = scanSpec->childByName("c0")
                    ->childByName(ScanSpec::kMapKeysFieldName)
@@ -259,12 +309,15 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_doubleMapKey) {
                    ->filter();
   ASSERT_TRUE(applyFilter(*keysFilter, 1e100));
   ASSERT_FALSE(applyFilter(*keysFilter, 9223372036854700000.0));
-  scanSpec = HiveDataSource::makeScanSpec(
+  scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields(
           {"c0[9223372036854775807]", "c0[-9223372036854775808]"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   keysFilter = scanSpec->childByName("c0")
                    ->childByName(ScanSpec::kMapKeysFieldName)
@@ -274,11 +327,14 @@ TEST_F(HiveConnectorTest, makeScanSpec_requiredSubfields_doubleMapKey) {
   ASSERT_TRUE(applyFilter(*keysFilter, 1e30f));
 
   // Unrepresentable values.
-  scanSpec = HiveDataSource::makeScanSpec(
+  scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields({"c0[-100000000]", "c0[100000000]"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   keysFilter = scanSpec->childByName("c0")
                    ->childByName(ScanSpec::kMapKeysFieldName)
@@ -308,11 +364,14 @@ TEST_F(HiveConnectorTest, makeScanSpec_filtersNotInRequiredSubfields) {
   filters.emplace(Subfield("c0.c0c2"), exec::isNotNull());
   filters.emplace(Subfield("c0.c0c3"), exec::isNotNull());
   filters.emplace(Subfield("c1.c1c0.c1c0c0"), exec::equal(43));
-  auto scanSpec = HiveDataSource::makeScanSpec(
+  auto scanSpec = makeScanSpec(
       ROW({{"c0", c0Type}}),
       groupSubfields(makeSubfields({"c0.c0c1", "c0.c0c3"})),
       filters,
       ROW({{"c0", c0Type}, {"c1", c1Type}}),
+      {},
+      {},
+      nullptr,
       pool_.get());
   auto c0 = scanSpec->childByName("c0");
   ASSERT_FALSE(c0->isConstant());
@@ -350,12 +409,15 @@ TEST_F(HiveConnectorTest, makeScanSpec_duplicateSubfields) {
   auto c0Type = MAP(BIGINT(), MAP(BIGINT(), BIGINT()));
   auto c1Type = MAP(VARCHAR(), MAP(BIGINT(), BIGINT()));
   auto rowType = ROW({{"c0", c0Type}, {"c1", c1Type}});
-  auto scanSpec = HiveDataSource::makeScanSpec(
+  auto scanSpec = makeScanSpec(
       rowType,
       groupSubfields(makeSubfields(
           {"c0[10][1]", "c0[10][2]", "c1[\"foo\"][1]", "c1[\"foo\"][2]"})),
       {},
       nullptr,
+      {},
+      {},
+      nullptr,
       pool_.get());
   auto* c0 = scanSpec->childByName("c0");
   ASSERT_EQ(c0->children().size(), 2);
@@ -363,24 +425,65 @@ TEST_F(HiveConnectorTest, makeScanSpec_duplicateSubfields) {
   ASSERT_EQ(c1->children().size(), 2);
 }
 
+// For TEXTFILE, partition key is not included in data columns.
+TEST_F(HiveConnectorTest, makeScanSpec_filterPartitionKey) {
+  auto rowType = ROW({{"c0", BIGINT()}});
+  SubfieldFilters filters;
+  filters.emplace(Subfield("ds"), exec::equal("2023-10-13"));
+  auto scanSpec = makeScanSpec(
+      rowType,
+      {},
+      filters,
+      rowType,
+      {{"ds", nullptr}},
+      {},
+      nullptr,
+      pool_.get());
+  ASSERT_TRUE(scanSpec->childByName("c0")->projectOut());
+  ASSERT_FALSE(scanSpec->childByName("ds")->projectOut());
+}
+
+TEST_F(HiveConnectorTest, makeScanSpec_prunedMapNonNullMapKey) {
+  auto rowType =
+      ROW({"c0"},
+          {ROW(
+              {{"c0c0", MAP(BIGINT(), MAP(BIGINT(), BIGINT()))},
+               {"c0c1", BIGINT()}})});
+  auto scanSpec = makeScanSpec(
+      rowType,
+      groupSubfields(makeSubfields({"c0.c0c1"})),
+      {},
+      nullptr,
+      {},
+      {},
+      nullptr,
+      pool_.get());
+  auto* c0 = scanSpec->childByName("c0");
+  ASSERT_EQ(c0->children().size(), 2);
+  ASSERT_TRUE(c0->childByName("c0c0")->isConstant());
+}
+
 TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
-  core::QueryCtx queryCtx;
-  exec::SimpleExpressionEvaluator evaluator(&queryCtx, pool_.get());
+  auto queryCtx = core::QueryCtx::create();
+  exec::SimpleExpressionEvaluator evaluator(queryCtx.get(), pool_.get());
   auto rowType = ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), DECIMAL(20, 0)});
 
   auto expr = parseExpr("not (c0 > 0 or c1 > 0)", rowType);
   SubfieldFilters filters;
-  auto remaining = HiveDataSource::extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters);
+  double sampleRate = 1;
+  auto remaining = extractFiltersFromRemainingFilter(
+      expr, &evaluator, false, filters, sampleRate);
   ASSERT_FALSE(remaining);
+  ASSERT_EQ(sampleRate, 1);
   ASSERT_EQ(filters.size(), 2);
   ASSERT_GT(filters.count(Subfield("c0")), 0);
   ASSERT_GT(filters.count(Subfield("c1")), 0);
 
   expr = parseExpr("not (c0 > 0 or c1 > c0)", rowType);
   filters.clear();
-  remaining = HiveDataSource::extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters);
+  remaining = extractFiltersFromRemainingFilter(
+      expr, &evaluator, false, filters, sampleRate);
+  ASSERT_EQ(sampleRate, 1);
   ASSERT_EQ(filters.size(), 1);
   ASSERT_GT(filters.count(Subfield("c0")), 0);
   ASSERT_TRUE(remaining);
@@ -389,8 +492,9 @@ TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
   expr = parseExpr(
       "not (c2 > 1::decimal(20, 0) or c2 < 0::decimal(20, 0))", rowType);
   filters.clear();
-  remaining = HiveDataSource::extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters);
+  remaining = extractFiltersFromRemainingFilter(
+      expr, &evaluator, false, filters, sampleRate);
+  ASSERT_EQ(sampleRate, 1);
   ASSERT_GT(filters.count(Subfield("c2")), 0);
   // Change these once HUGEINT filter merge is fixed.
   ASSERT_TRUE(remaining);
@@ -398,5 +502,49 @@ TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
       remaining->toString(), "not(lt(ROW[\"c2\"],cast 0 as DECIMAL(20, 0)))");
 }
 
+TEST_F(HiveConnectorTest, prestoTableSampling) {
+  auto queryCtx = core::QueryCtx::create();
+  exec::SimpleExpressionEvaluator evaluator(queryCtx.get(), pool_.get());
+  auto rowType = ROW({"c0"}, {BIGINT()});
+
+  auto expr = parseExpr("rand() < 0.5", rowType);
+  SubfieldFilters filters;
+  double sampleRate = 1;
+  auto remaining = extractFiltersFromRemainingFilter(
+      expr, &evaluator, false, filters, sampleRate);
+  ASSERT_FALSE(remaining);
+  ASSERT_EQ(sampleRate, 0.5);
+  ASSERT_TRUE(filters.empty());
+
+  expr = parseExpr("c0 > 0 and rand() < 0.5", rowType);
+  filters.clear();
+  sampleRate = 1;
+  remaining = extractFiltersFromRemainingFilter(
+      expr, &evaluator, false, filters, sampleRate);
+  ASSERT_FALSE(remaining);
+  ASSERT_EQ(sampleRate, 0.5);
+  ASSERT_EQ(filters.size(), 1);
+  ASSERT_GT(filters.count(Subfield("c0")), 0);
+
+  expr = parseExpr("rand() < 0.5 and rand() < 0.5", rowType);
+  filters.clear();
+  sampleRate = 1;
+  remaining = extractFiltersFromRemainingFilter(
+      expr, &evaluator, false, filters, sampleRate);
+  ASSERT_FALSE(remaining);
+  ASSERT_EQ(sampleRate, 0.25);
+  ASSERT_TRUE(filters.empty());
+
+  expr = parseExpr("c0 > 0 or rand() < 0.5", rowType);
+  filters.clear();
+  sampleRate = 1;
+  remaining = extractFiltersFromRemainingFilter(
+      expr, &evaluator, false, filters, sampleRate);
+  ASSERT_TRUE(remaining);
+  ASSERT_EQ(*remaining, *expr);
+  ASSERT_EQ(sampleRate, 1);
+  ASSERT_TRUE(filters.empty());
+}
+
 } // namespace
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp b/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp
new file mode 100644
index 0000000000000..394304b7951d9
--- /dev/null
+++ b/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp
@@ -0,0 +1,420 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include <gtest/gtest.h>
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PrefixSortUtils.h"
+
+#include "velox/dwio/dwrf/writer/Writer.h"
+
+#ifdef VELOX_ENABLE_PARQUET
+#include "velox/dwio/parquet/writer/Writer.h"
+#endif
+
+namespace facebook::velox::connector {
+
+using namespace dwio::common;
+
+class HiveConnectorUtilTest : public exec::test::HiveConnectorTestBase {
+ protected:
+  static bool compareSerDeOptions(
+      const SerDeOptions& l,
+      const SerDeOptions& r) {
+    return l.isEscaped == r.isEscaped && l.escapeChar == r.escapeChar &&
+        l.lastColumnTakesRest == r.lastColumnTakesRest &&
+        l.nullString == r.nullString && l.separators == r.separators;
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_ =
+      memory::memoryManager()->addLeafPool();
+};
+
+TEST_F(HiveConnectorUtilTest, configureReaderOptions) {
+  config::ConfigBase sessionProperties({});
+  auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+      pool_.get(),
+      pool_.get(),
+      &sessionProperties,
+      nullptr,
+      exec::test::defaultPrefixSortConfig(),
+      nullptr,
+      nullptr,
+      "query.HiveConnectorUtilTest",
+      "task.HiveConnectorUtilTest",
+      "planNodeId.HiveConnectorUtilTest",
+      0,
+      "");
+  auto hiveConfig =
+      std::make_shared<hive::HiveConfig>(std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+  const std::unordered_map<std::string, std::optional<std::string>>
+      partitionKeys;
+  const std::unordered_map<std::string, std::string> customSplitInfo;
+
+  // Dynamic parameters.
+  dwio::common::ReaderOptions readerOptions(pool_.get());
+  FileFormat fileFormat{FileFormat::DWRF};
+  std::unordered_map<std::string, std::string> tableParameters;
+  std::unordered_map<std::string, std::string> serdeParameters;
+  SerDeOptions expectedSerDe;
+
+  auto createTableHandle = [&]() {
+    return std::make_shared<hive::HiveTableHandle>(
+        "testConnectorId",
+        "testTable",
+        false,
+        hive::SubfieldFilters{},
+        nullptr,
+        nullptr,
+        tableParameters);
+  };
+
+  auto createSplit = [&]() {
+    return std::make_shared<hive::HiveConnectorSplit>(
+        "testConnectorId",
+        "/tmp/",
+        fileFormat,
+        0UL,
+        std::numeric_limits<uint64_t>::max(),
+        partitionKeys,
+        std::nullopt,
+        customSplitInfo,
+        nullptr,
+        serdeParameters);
+  };
+
+  auto performConfigure = [&]() {
+    auto tableHandle = createTableHandle();
+    auto split = createSplit();
+    configureReaderOptions(
+        readerOptions, hiveConfig, connectorQueryCtx.get(), tableHandle, split);
+  };
+
+  auto clearDynamicParameters = [&](FileFormat newFileFormat) {
+    readerOptions = dwio::common::ReaderOptions(pool_.get());
+    fileFormat = newFileFormat;
+    tableParameters.clear();
+    serdeParameters.clear();
+    expectedSerDe = SerDeOptions{};
+  };
+
+  // Default.
+  performConfigure();
+  EXPECT_EQ(readerOptions.fileFormat(), fileFormat);
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+  EXPECT_EQ(readerOptions.loadQuantum(), hiveConfig->loadQuantum());
+  EXPECT_EQ(readerOptions.maxCoalesceBytes(), hiveConfig->maxCoalescedBytes());
+  EXPECT_EQ(
+      readerOptions.maxCoalesceDistance(),
+      hiveConfig->maxCoalescedDistanceBytes());
+  EXPECT_EQ(
+      readerOptions.fileColumnNamesReadAsLowerCase(),
+      hiveConfig->isFileColumnNamesReadAsLowerCase(&sessionProperties));
+  EXPECT_EQ(
+      readerOptions.useColumnNamesForColumnMapping(),
+      hiveConfig->isOrcUseColumnNames(&sessionProperties));
+  EXPECT_EQ(
+      readerOptions.footerEstimatedSize(), hiveConfig->footerEstimatedSize());
+  EXPECT_EQ(
+      readerOptions.filePreloadThreshold(), hiveConfig->filePreloadThreshold());
+  EXPECT_EQ(readerOptions.prefetchRowGroups(), hiveConfig->prefetchRowGroups());
+
+  // Modify field delimiter and change the file format.
+  clearDynamicParameters(FileFormat::TEXT);
+  serdeParameters[SerDeOptions::kFieldDelim] = '\t';
+  expectedSerDe.separators[size_t(SerDeSeparator::FIELD_DELIM)] = '\t';
+  performConfigure();
+  EXPECT_EQ(readerOptions.fileFormat(), fileFormat);
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Modify collection delimiter.
+  clearDynamicParameters(FileFormat::TEXT);
+  serdeParameters[SerDeOptions::kCollectionDelim] = '=';
+  expectedSerDe.separators[size_t(SerDeSeparator::COLLECTION_DELIM)] = '=';
+  performConfigure();
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Modify map key delimiter.
+  clearDynamicParameters(FileFormat::TEXT);
+  serdeParameters[SerDeOptions::kMapKeyDelim] = '&';
+  expectedSerDe.separators[size_t(SerDeSeparator::MAP_KEY_DELIM)] = '&';
+  performConfigure();
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Modify null string.
+  clearDynamicParameters(FileFormat::TEXT);
+  tableParameters[TableParameter::kSerializationNullFormat] = "x-x";
+  expectedSerDe.nullString = "x-x";
+  performConfigure();
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Empty escape delim means default escape char.
+  clearDynamicParameters(FileFormat::TEXT);
+  serdeParameters[SerDeOptions::kEscapeChar] = "";
+  expectedSerDe.escapeChar = '\\';
+  expectedSerDe.isEscaped = true;
+  performConfigure();
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Convertible to byte escape char - use it.
+  clearDynamicParameters(FileFormat::TEXT);
+  serdeParameters[SerDeOptions::kEscapeChar] = "38";
+  expectedSerDe.escapeChar = '&';
+  expectedSerDe.isEscaped = true;
+  performConfigure();
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Overflow byte escape char - fall back to the 1st character of the string.
+  clearDynamicParameters(FileFormat::TEXT);
+  serdeParameters[SerDeOptions::kEscapeChar] = "381";
+  expectedSerDe.escapeChar = '3';
+  expectedSerDe.isEscaped = true;
+  performConfigure();
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Not convertible string - fall back to the 1st character of the string.
+  clearDynamicParameters(FileFormat::TEXT);
+  serdeParameters[SerDeOptions::kEscapeChar] = "7!";
+  expectedSerDe.escapeChar = '7';
+  expectedSerDe.isEscaped = true;
+  performConfigure();
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Modify all previous together.
+  clearDynamicParameters(FileFormat::TEXT);
+  serdeParameters[SerDeOptions::kFieldDelim] = '~';
+  expectedSerDe.separators[size_t(SerDeSeparator::FIELD_DELIM)] = '~';
+  serdeParameters[SerDeOptions::kCollectionDelim] = '$';
+  expectedSerDe.separators[size_t(SerDeSeparator::COLLECTION_DELIM)] = '$';
+  serdeParameters[SerDeOptions::kMapKeyDelim] = '*';
+  expectedSerDe.separators[size_t(SerDeSeparator::MAP_KEY_DELIM)] = '*';
+  serdeParameters[SerDeOptions::kEscapeChar] = '*';
+  expectedSerDe.escapeChar = '*';
+  expectedSerDe.isEscaped = true;
+  tableParameters[TableParameter::kSerializationNullFormat] = "";
+  expectedSerDe.nullString = "";
+  performConfigure();
+  EXPECT_TRUE(compareSerDeOptions(readerOptions.serDeOptions(), expectedSerDe));
+
+  // Tests other custom reader options.
+  clearDynamicParameters(FileFormat::TEXT);
+  std::unordered_map<std::string, std::string> customHiveConfigProps;
+  customHiveConfigProps[hive::HiveConfig::kLoadQuantum] = "321";
+  customHiveConfigProps[hive::HiveConfig::kMaxCoalescedBytes] = "129";
+  customHiveConfigProps[hive::HiveConfig::kMaxCoalescedDistanceBytes] = "513";
+  customHiveConfigProps[hive::HiveConfig::kFileColumnNamesReadAsLowerCase] =
+      "true";
+  customHiveConfigProps[hive::HiveConfig::kOrcUseColumnNames] = "true";
+  customHiveConfigProps[hive::HiveConfig::kFooterEstimatedSize] = "1111";
+  customHiveConfigProps[hive::HiveConfig::kFilePreloadThreshold] = "9999";
+  customHiveConfigProps[hive::HiveConfig::kPrefetchRowGroups] = "10";
+  hiveConfig = std::make_shared<hive::HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(customHiveConfigProps)));
+  performConfigure();
+  EXPECT_EQ(readerOptions.loadQuantum(), hiveConfig->loadQuantum());
+  EXPECT_EQ(readerOptions.maxCoalesceBytes(), hiveConfig->maxCoalescedBytes());
+  EXPECT_EQ(
+      readerOptions.maxCoalesceDistance(),
+      hiveConfig->maxCoalescedDistanceBytes());
+  EXPECT_EQ(
+      readerOptions.fileColumnNamesReadAsLowerCase(),
+      hiveConfig->isFileColumnNamesReadAsLowerCase(&sessionProperties));
+  EXPECT_EQ(
+      readerOptions.useColumnNamesForColumnMapping(),
+      hiveConfig->isOrcUseColumnNames(&sessionProperties));
+  EXPECT_EQ(
+      readerOptions.footerEstimatedSize(), hiveConfig->footerEstimatedSize());
+  EXPECT_EQ(
+      readerOptions.filePreloadThreshold(), hiveConfig->filePreloadThreshold());
+  EXPECT_EQ(readerOptions.prefetchRowGroups(), hiveConfig->prefetchRowGroups());
+}
+
+TEST_F(HiveConnectorUtilTest, configureRowReaderOptions) {
+  auto split =
+      std::make_shared<hive::HiveConnectorSplit>("", "", FileFormat::UNKNOWN);
+  auto rowType = ROW({{"float_features", MAP(INTEGER(), REAL())}});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*rowType);
+  auto* float_features = spec->childByName("float_features");
+  float_features->childByName(common::ScanSpec::kMapKeysFieldName)
+      ->setFilter(common::createBigintValues({1, 3}, false));
+  float_features->setFlatMapFeatureSelection({"1", "3"});
+}
+
+TEST_F(
+    HiveConnectorUtilTest,
+    updateWriterOptionsFromHiveConfigDWRFWithoutSessionProperties) {
+  auto fileFormat = dwio::common::FileFormat::DWRF;
+  std::unordered_map<std::string, std::string> connectorConfig = {
+      {hive::HiveConfig::kOrcWriterMaxStripeSize, "100MB"},
+      {hive::HiveConfig::kOrcWriterMaxDictionaryMemory, "128MB"},
+      {hive::HiveConfig::kOrcWriterIntegerDictionaryEncodingEnabled, "true"},
+      {hive::HiveConfig::kOrcWriterStringDictionaryEncodingEnabled, "false"},
+      {hive::HiveConfig::kOrcWriterLinearStripeSizeHeuristics, "true"},
+      {hive::HiveConfig::kOrcWriterMinCompressionSize, "512"},
+      {hive::HiveConfig::kOrcWriterCompressionLevel, "1"}};
+  auto hiveConfig = std::make_shared<hive::HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+  std::shared_ptr<config::ConfigBase> connectorSessionProperties =
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>());
+  std::shared_ptr<dwio::common::WriterOptions> options =
+      std::make_shared<dwrf::WriterOptions>();
+  options->compressionKind = velox::common::CompressionKind_ZLIB;
+
+  updateWriterOptionsFromHiveConfig(
+      fileFormat, hiveConfig, connectorSessionProperties.get(), options);
+
+  auto dwrfOptions = std::dynamic_pointer_cast<dwrf::WriterOptions>(options);
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(dwrf::Config::COMPRESSION.key),
+      "1");
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(dwrf::Config::STRIPE_SIZE.key),
+      std::to_string(100 * 1024 * 1024));
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(
+          dwrf::Config::MAX_DICTIONARY_SIZE.key),
+      std::to_string(128 * 1024 * 1024));
+  ASSERT_EQ(
+      dwrfOptions->config->get<bool>(
+          dwrf::Config::INTEGER_DICTIONARY_ENCODING_ENABLED.key),
+      true);
+  ASSERT_EQ(
+      dwrfOptions->config->get<bool>(
+          dwrf::Config::STRING_DICTIONARY_ENCODING_ENABLED.key),
+      false);
+  ASSERT_EQ(
+      dwrfOptions->config->get<bool>(
+          dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS.key),
+      true);
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(
+          dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN.key),
+      "512");
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(
+          dwrf::Config::ZLIB_COMPRESSION_LEVEL.key),
+      "1");
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(
+          dwrf::Config::ZSTD_COMPRESSION_LEVEL.key),
+      "1");
+}
+
+TEST_F(
+    HiveConnectorUtilTest,
+    updateWriterOptionsFromHiveConfigDWRFWithSessionProperties) {
+  auto fileFormat = dwio::common::FileFormat::DWRF;
+  std::unordered_map<std::string, std::string> connectorConfig = {
+      {hive::HiveConfig::kOrcWriterMaxStripeSize, "100MB"},
+      {hive::HiveConfig::kOrcWriterMaxDictionaryMemory, "128MB"},
+      {hive::HiveConfig::kOrcWriterIntegerDictionaryEncodingEnabled, "true"},
+      {hive::HiveConfig::kOrcWriterStringDictionaryEncodingEnabled, "false"},
+      {hive::HiveConfig::kOrcWriterLinearStripeSizeHeuristics, "true"},
+      {hive::HiveConfig::kOrcWriterMinCompressionSize, "512"},
+      {hive::HiveConfig::kOrcWriterCompressionLevel, "1"}};
+  auto hiveConfig = std::make_shared<hive::HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+
+  std::unordered_map<std::string, std::string> sessionConfig = {
+      {hive::HiveConfig::kOrcWriterMaxStripeSizeSession, "128MB"},
+      {hive::HiveConfig::kOrcWriterMaxDictionaryMemorySession, "100MB"},
+      {hive::HiveConfig::kOrcWriterIntegerDictionaryEncodingEnabledSession,
+       "false"},
+      {hive::HiveConfig::kOrcWriterStringDictionaryEncodingEnabledSession,
+       "true"},
+      {hive::HiveConfig::kOrcWriterLinearStripeSizeHeuristicsSession, "false"},
+      {hive::HiveConfig::kOrcWriterMinCompressionSizeSession, "1024"},
+      {hive::HiveConfig::kOrcWriterCompressionLevelSession, "2"}};
+
+  std::shared_ptr<config::ConfigBase> connectorSessionProperties =
+      std::make_shared<config::ConfigBase>(std::move(sessionConfig));
+  std::shared_ptr<dwio::common::WriterOptions> options =
+      std::make_shared<dwrf::WriterOptions>();
+  options->compressionKind = velox::common::CompressionKind_ZLIB;
+
+  updateWriterOptionsFromHiveConfig(
+      fileFormat, hiveConfig, connectorSessionProperties.get(), options);
+
+  auto dwrfOptions = std::dynamic_pointer_cast<dwrf::WriterOptions>(options);
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(dwrf::Config::COMPRESSION.key),
+      "1");
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(dwrf::Config::STRIPE_SIZE.key),
+      std::to_string(128 * 1024 * 1024));
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(
+          dwrf::Config::MAX_DICTIONARY_SIZE.key),
+      std::to_string(100 * 1024 * 1024));
+  ASSERT_EQ(
+      dwrfOptions->config->get<bool>(
+          dwrf::Config::INTEGER_DICTIONARY_ENCODING_ENABLED.key),
+      false);
+  ASSERT_EQ(
+      dwrfOptions->config->get<bool>(
+          dwrf::Config::STRING_DICTIONARY_ENCODING_ENABLED.key),
+      true);
+  ASSERT_EQ(
+      dwrfOptions->config->get<bool>(
+          dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS.key),
+      false);
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(
+          dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN.key),
+      "1024");
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(
+          dwrf::Config::ZLIB_COMPRESSION_LEVEL.key),
+      "2");
+  ASSERT_EQ(
+      dwrfOptions->config->get<std::string>(
+          dwrf::Config::ZSTD_COMPRESSION_LEVEL.key),
+      "2");
+}
+
+#ifdef VELOX_ENABLE_PARQUET
+TEST_F(HiveConnectorUtilTest, updateWriterOptionsFromHiveConfigParquet) {
+  auto fileFormat = dwio::common::FileFormat::PARQUET;
+  std::unordered_map<std::string, std::string> connectorConfig = {
+      {parquet::WriterOptions::kParquetSessionWriteTimestampUnit, "3"},
+      {core::QueryConfig::kSessionTimezone, "UTC"}};
+  auto hiveConfig = std::make_shared<hive::HiveConfig>(
+      std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+  std::shared_ptr<config::ConfigBase> connectorSessionProperties =
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>());
+  std::shared_ptr<dwio::common::WriterOptions> options =
+      std::make_shared<parquet::WriterOptions>();
+  options->compressionKind = velox::common::CompressionKind_ZLIB;
+
+  updateWriterOptionsFromHiveConfig(
+      fileFormat, hiveConfig, connectorSessionProperties.get(), options);
+
+  auto parquetOptions =
+      std::dynamic_pointer_cast<parquet::WriterOptions>(options);
+  ASSERT_EQ(
+      parquetOptions->parquetWriteTimestampUnit.value(), TimestampUnit::kMilli);
+  ASSERT_EQ(parquetOptions->parquetWriteTimestampTimeZone.value(), "UTC");
+}
+#endif
+
+} // namespace facebook::velox::connector
diff --git a/velox/connectors/hive/tests/HiveDataSinkTest.cpp b/velox/connectors/hive/tests/HiveDataSinkTest.cpp
index 2504d068e000e..e464e14784ef9 100644
--- a/velox/connectors/hive/tests/HiveDataSinkTest.cpp
+++ b/velox/connectors/hive/tests/HiveDataSinkTest.cpp
@@ -18,11 +18,23 @@
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 
 #include <folly/init/Init.h>
+#include <re2/re2.h>
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/core/Config.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/dwio/common/BufferedInput.h"
 #include "velox/dwio/common/Options.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/dwio/dwrf/writer/FlushPolicy.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+
+#ifdef VELOX_ENABLE_PARQUET
+#include "velox/dwio/parquet/reader/ParquetReader.h"
+#include "velox/dwio/parquet/writer/Writer.h"
+#endif
+
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/PrefixSortUtils.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
@@ -31,62 +43,141 @@ namespace {
 
 using namespace facebook::velox::common;
 using namespace facebook::velox::exec::test;
-
-constexpr const char* kHiveConnectorId = "test-hive";
+using namespace facebook::velox::common::testutil;
 
 class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
  protected:
   void SetUp() override {
+    HiveConnectorTestBase::SetUp();
     Type::registerSerDe();
     HiveSortingColumn::registerSerDe();
     HiveBucketProperty::registerSerDe();
 
     rowType_ =
-        ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
-            {BIGINT(), INTEGER(), SMALLINT(), REAL(), DOUBLE(), VARCHAR()});
+        ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6"},
+            {BIGINT(),
+             INTEGER(),
+             SMALLINT(),
+             REAL(),
+             DOUBLE(),
+             VARCHAR(),
+             BOOLEAN()});
+
+    setupMemoryPools();
+
+    spillExecutor_ = std::make_unique<folly::IOThreadPoolExecutor>(
+        std::thread::hardware_concurrency());
+  }
+
+  void TearDown() override {
+    connectorQueryCtx_.reset();
+    connectorPool_.reset();
+    opPool_.reset();
+    root_.reset();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  std::vector<RowVectorPtr> createVectors(int vectorSize, int numVectors) {
+    VectorFuzzer::Options options;
+    options.vectorSize = vectorSize;
+    VectorFuzzer fuzzer(options, pool());
+    std::vector<RowVectorPtr> vectors;
+    for (int i = 0; i < numVectors; ++i) {
+      vectors.push_back(fuzzer.fuzzInputRow(rowType_));
+    }
+    return vectors;
+  }
+
+  std::unique_ptr<SpillConfig> getSpillConfig(
+      const std::string& spillPath,
+      uint64_t writerFlushThreshold) {
+    return std::make_unique<SpillConfig>(
+        [spillPath]() -> const std::string& { return spillPath; },
+        [&](uint64_t) {},
+        "",
+        0,
+        0,
+        /*readBufferSize=*/1 << 20,
+        spillExecutor_.get(),
+        10,
+        20,
+        0,
+        0,
+        0,
+        0,
+        writerFlushThreshold,
+        "none");
+  }
+
+  void setupMemoryPools() {
+    connectorQueryCtx_.reset();
+    connectorPool_.reset();
+    opPool_.reset();
+    root_.reset();
+
+    root_ = memory::memoryManager()->addRootPool(
+        "HiveDataSinkTest", 1L << 30, exec::MemoryReclaimer::create());
+    opPool_ = root_->addLeafChild("operator");
+    connectorPool_ =
+        root_->addAggregateChild("connector", exec::MemoryReclaimer::create());
+
     connectorQueryCtx_ = std::make_unique<connector::ConnectorQueryCtx>(
         opPool_.get(),
         connectorPool_.get(),
+        connectorSessionProperties_.get(),
         nullptr,
-        connectorConfig_.get(),
-        nullptr,
+        exec::test::defaultPrefixSortConfig(),
         nullptr,
         nullptr,
         "query.HiveDataSinkTest",
         "task.HiveDataSinkTest",
         "planNodeId.HiveDataSinkTest",
-        0);
-
-    auto hiveConnector =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(kHiveConnectorId, nullptr);
-    connector::registerConnector(std::move(hiveConnector));
+        0,
+        "");
   }
 
   std::shared_ptr<connector::hive::HiveInsertTableHandle>
   createHiveInsertTableHandle(
       const RowTypePtr& outputRowType,
-      const std::string& outputDirectoryPath) {
+      const std::string& outputDirectoryPath,
+      dwio::common::FileFormat fileFormat = dwio::common::FileFormat::DWRF,
+      const std::vector<std::string>& partitionedBy = {},
+      const std::shared_ptr<connector::hive::HiveBucketProperty>&
+          bucketProperty = nullptr,
+      const std::shared_ptr<dwio::common::WriterOptions>& writerOptions =
+          nullptr) {
     return makeHiveInsertTableHandle(
         outputRowType->names(),
         outputRowType->children(),
-        {},
-        nullptr,
+        partitionedBy,
+        bucketProperty,
         makeLocationHandle(
             outputDirectoryPath,
             std::nullopt,
             connector::hive::LocationHandle::TableType::kNew),
-        dwio::common::FileFormat::DWRF,
-        CompressionKind::CompressionKind_ZSTD);
+        fileFormat,
+        CompressionKind::CompressionKind_ZSTD,
+        writerOptions);
   }
 
   std::shared_ptr<HiveDataSink> createDataSink(
       const RowTypePtr& rowType,
-      const std::string& outputDirectoryPath) {
+      const std::string& outputDirectoryPath,
+      dwio::common::FileFormat fileFormat = dwio::common::FileFormat::DWRF,
+      const std::vector<std::string>& partitionedBy = {},
+      const std::shared_ptr<connector::hive::HiveBucketProperty>&
+          bucketProperty = nullptr,
+      const std::shared_ptr<dwio::common::WriterOptions>& writerOptions =
+          nullptr) {
     return std::make_shared<HiveDataSink>(
         rowType,
-        createHiveInsertTableHandle(rowType, outputDirectoryPath),
+        createHiveInsertTableHandle(
+            rowType,
+            outputDirectoryPath,
+            fileFormat,
+            partitionedBy,
+            bucketProperty,
+            writerOptions),
         connectorQueryCtx_.get(),
         CommitStrategy::kNoCommit,
         connectorConfig_);
@@ -102,28 +193,39 @@ class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
     return files;
   }
 
-  void verifyWrittenData(const std::string& dirPath) {
+  void verifyWrittenData(const std::string& dirPath, int32_t numFiles = 1) {
     const std::vector<std::string> filePaths = listFiles(dirPath);
-    ASSERT_EQ(filePaths.size(), 1);
+    ASSERT_EQ(filePaths.size(), numFiles);
+    std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
+    std::for_each(filePaths.begin(), filePaths.end(), [&](auto filePath) {
+      splits.push_back(makeHiveConnectorSplit(filePath));
+    });
     HiveConnectorTestBase::assertQuery(
         PlanBuilder().tableScan(rowType_).planNode(),
-        {makeHiveConnectorSplit(filePaths[0])},
+        splits,
         fmt::format("SELECT * FROM tmp"));
   }
 
+  void setConnectorQueryContext(
+      std::unique_ptr<ConnectorQueryCtx> connectorQueryCtx) {
+    connectorQueryCtx_ = std::move(connectorQueryCtx);
+  }
+
   const std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::addDefaultLeafMemoryPool();
-  const std::shared_ptr<memory::MemoryPool> root_ =
-      memory::defaultMemoryManager().addRootPool("HiveDataSinkTest");
-  const std::shared_ptr<memory::MemoryPool> opPool_ =
-      root_->addLeafChild("operator");
-  const std::shared_ptr<memory::MemoryPool> connectorPool_ =
-      root_->addAggregateChild("connector");
-  const std::shared_ptr<const Config> connectorConfig_{
-      std::make_unique<core::MemConfig>()};
+      memory::memoryManager()->addLeafPool();
 
+  std::shared_ptr<memory::MemoryPool> root_;
+  std::shared_ptr<memory::MemoryPool> opPool_;
+  std::shared_ptr<memory::MemoryPool> connectorPool_;
   RowTypePtr rowType_;
+  std::shared_ptr<config::ConfigBase> connectorSessionProperties_ =
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>());
   std::unique_ptr<ConnectorQueryCtx> connectorQueryCtx_;
+  std::shared_ptr<HiveConfig> connectorConfig_ =
+      std::make_shared<HiveConfig>(std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+  std::unique_ptr<folly::IOThreadPoolExecutor> spillExecutor_;
 };
 
 TEST_F(HiveDataSinkTest, hiveSortingColumn) {
@@ -397,58 +499,116 @@ TEST_F(HiveDataSinkTest, hiveBucketProperty) {
 }
 
 TEST_F(HiveDataSinkTest, basic) {
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+  auto stats = dataSink->stats();
+  ASSERT_TRUE(stats.empty()) << stats.toString();
+  ASSERT_EQ(
+      stats.toString(),
+      "numWrittenBytes 0B numWrittenFiles 0 spillRuns[0] spilledInputBytes[0B] "
+      "spilledBytes[0B] spilledRows[0] spilledPartitions[0] spilledFiles[0] "
+      "spillFillTimeNanos[0ns] spillSortTimeNanos[0ns] spillSerializationTimeNanos[0ns] "
+      "spillWrites[0] spillFlushTimeNanos[0ns] spillWriteTimeNanos[0ns] "
+      "maxSpillExceededLimitCount[0] spillReadBytes[0B] spillReads[0] "
+      "spillReadTimeNanos[0ns] spillReadDeserializationTimeNanos[0ns]");
+
   const int numBatches = 10;
+  const auto vectors = createVectors(500, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+  stats = dataSink->stats();
+  ASSERT_FALSE(stats.empty());
+  ASSERT_GT(stats.numWrittenBytes, 0);
+  ASSERT_EQ(stats.numWrittenFiles, 0);
+
+  const auto partitions = dataSink->close();
+  stats = dataSink->stats();
+  ASSERT_FALSE(stats.empty());
+  ASSERT_EQ(partitions.size(), 1);
+
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath());
+}
+
+TEST_F(HiveDataSinkTest, basicBucket) {
   const auto outputDirectory = TempDirectoryPath::create();
-  auto dataSink = createDataSink(rowType_, outputDirectory->path);
-
-  VectorFuzzer::Options options;
-  options.vectorSize = 500;
-  VectorFuzzer fuzzer(options, pool());
-  std::vector<RowVectorPtr> vectors;
-  for (int i = 0; i < numBatches; ++i) {
-    vectors.push_back(fuzzer.fuzzRow(rowType_));
-    dataSink->appendData(vectors.back());
+
+  const int32_t numBuckets = 4;
+  auto bucketProperty = std::make_shared<HiveBucketProperty>(
+      HiveBucketProperty::Kind::kHiveCompatible,
+      numBuckets,
+      std::vector<std::string>{"c0"},
+      std::vector<TypePtr>{BIGINT()},
+      std::vector<std::shared_ptr<const HiveSortingColumn>>{
+          std::make_shared<HiveSortingColumn>(
+              "c1", core::SortOrder{false, false})});
+  auto dataSink = createDataSink(
+      rowType_,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::DWRF,
+      {},
+      bucketProperty);
+  auto stats = dataSink->stats();
+  ASSERT_TRUE(stats.empty()) << stats.toString();
+  ASSERT_EQ(
+      stats.toString(),
+      "numWrittenBytes 0B numWrittenFiles 0 spillRuns[0] spilledInputBytes[0B] "
+      "spilledBytes[0B] spilledRows[0] spilledPartitions[0] spilledFiles[0] "
+      "spillFillTimeNanos[0ns] spillSortTimeNanos[0ns] spillSerializationTimeNanos[0ns] "
+      "spillWrites[0] spillFlushTimeNanos[0ns] spillWriteTimeNanos[0ns] "
+      "maxSpillExceededLimitCount[0] spillReadBytes[0B] spillReads[0] "
+      "spillReadTimeNanos[0ns] spillReadDeserializationTimeNanos[0ns]");
+
+  const int numBatches = 10;
+  const auto vectors = createVectors(500, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
   }
-  const auto results = dataSink->close(true);
-  ASSERT_EQ(results.size(), 1);
+  stats = dataSink->stats();
+  ASSERT_FALSE(stats.empty());
+  ASSERT_GT(stats.numWrittenBytes, 0);
+  ASSERT_EQ(stats.numWrittenFiles, 0);
+
+  const auto partitions = dataSink->close();
+  stats = dataSink->stats();
+  ASSERT_FALSE(stats.empty());
+  ASSERT_EQ(partitions.size(), numBuckets);
 
   createDuckDbTable(vectors);
-  verifyWrittenData(outputDirectory->path);
+  verifyWrittenData(outputDirectory->getPath(), numBuckets);
 }
 
 TEST_F(HiveDataSinkTest, close) {
   for (bool empty : {true, false}) {
     SCOPED_TRACE(fmt::format("Data sink is empty: {}", empty));
     const auto outputDirectory = TempDirectoryPath::create();
-    auto dataSink = createDataSink(rowType_, outputDirectory->path);
+    auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+
+    auto vectors = createVectors(500, 1);
 
-    std::vector<RowVectorPtr> vectors;
-    VectorFuzzer::Options options;
-    options.vectorSize = 1;
-    VectorFuzzer fuzzer(options, pool());
-    vectors.push_back(fuzzer.fuzzRow(rowType_));
     if (!empty) {
-      dataSink->appendData(vectors.back());
-      ASSERT_GT(dataSink->getCompletedBytes(), 0);
+      dataSink->appendData(vectors[0]);
+      ASSERT_GT(dataSink->stats().numWrittenBytes, 0);
     } else {
-      ASSERT_EQ(dataSink->getCompletedBytes(), 0);
+      ASSERT_EQ(dataSink->stats().numWrittenBytes, 0);
     }
-    const auto results = dataSink->close(true);
+    const auto partitions = dataSink->close();
     // Can't append after close.
     VELOX_ASSERT_THROW(
-        dataSink->appendData(vectors.back()), "Hive data sink has been closed");
-    ASSERT_EQ(dataSink->close(true), results);
-    VELOX_ASSERT_THROW(
-        dataSink->close(false), "Can't abort a closed hive data sink");
+        dataSink->appendData(vectors.back()), "Hive data sink is not running");
+    VELOX_ASSERT_THROW(dataSink->close(), "Hive data sink is not running");
+    VELOX_ASSERT_THROW(dataSink->abort(), "Hive data sink is not running");
 
+    const auto stats = dataSink->stats();
     if (!empty) {
-      ASSERT_EQ(results.size(), 1);
-      ASSERT_GT(dataSink->getCompletedBytes(), 0);
+      ASSERT_EQ(partitions.size(), 1);
+      ASSERT_GT(stats.numWrittenBytes, 0);
       createDuckDbTable(vectors);
-      verifyWrittenData(outputDirectory->path);
+      verifyWrittenData(outputDirectory->getPath());
     } else {
-      ASSERT_TRUE(results.empty());
-      ASSERT_EQ(dataSink->getCompletedBytes(), 0);
+      ASSERT_TRUE(partitions.empty());
+      ASSERT_EQ(stats.numWrittenBytes, 0);
     }
   }
 }
@@ -457,33 +617,467 @@ TEST_F(HiveDataSinkTest, abort) {
   for (bool empty : {true, false}) {
     SCOPED_TRACE(fmt::format("Data sink is empty: {}", empty));
     const auto outputDirectory = TempDirectoryPath::create();
-    auto dataSink = createDataSink(rowType_, outputDirectory->path);
+    auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
 
-    std::vector<RowVectorPtr> vectors;
-    VectorFuzzer::Options options;
-    options.vectorSize = 1;
-    VectorFuzzer fuzzer(options, pool());
-    vectors.push_back(fuzzer.fuzzRow(rowType_));
+    auto vectors = createVectors(1, 1);
     int initialBytes = 0;
     if (!empty) {
       dataSink->appendData(vectors.back());
-      initialBytes = dataSink->getCompletedBytes();
+      initialBytes = dataSink->stats().numWrittenBytes;
       ASSERT_GT(initialBytes, 0);
     } else {
-      initialBytes = dataSink->getCompletedBytes();
+      initialBytes = dataSink->stats().numWrittenBytes;
       ASSERT_EQ(initialBytes, 0);
     }
-    ASSERT_TRUE(dataSink->close(false).empty());
+    dataSink->abort();
+    const auto stats = dataSink->stats();
+    ASSERT_TRUE(stats.empty());
     // Can't close after abort.
-    VELOX_ASSERT_THROW(
-        dataSink->close(true), "Can't close an aborted hive data sink");
-    ASSERT_TRUE(dataSink->close(false).empty());
+    VELOX_ASSERT_THROW(dataSink->close(), "Hive data sink is not running");
+    VELOX_ASSERT_THROW(dataSink->abort(), "Hive data sink is not running");
     // Can't append after abort.
     VELOX_ASSERT_THROW(
-        dataSink->appendData(vectors.back()),
-        "Hive data sink hash been aborted");
+        dataSink->appendData(vectors.back()), "Hive data sink is not running");
+  }
+}
+
+DEBUG_ONLY_TEST_F(HiveDataSinkTest, memoryReclaim) {
+  const int numBatches = 200;
+  auto vectors = createVectors(500, 200);
+
+  struct {
+    dwio::common::FileFormat format;
+    bool sortWriter;
+    bool writerSpillEnabled;
+    uint64_t writerFlushThreshold;
+    bool expectedWriterReclaimEnabled;
+    bool expectedWriterReclaimed;
+
+    std::string debugString() const {
+      return fmt::format(
+          "format: {}, sortWriter: {}, writerSpillEnabled: {}, writerFlushThreshold: {}, expectedWriterReclaimEnabled: {}, expectedWriterReclaimed: {}",
+          dwio::common::toString(format),
+          sortWriter,
+          writerSpillEnabled,
+          succinctBytes(writerFlushThreshold),
+          expectedWriterReclaimEnabled,
+          expectedWriterReclaimed);
+    }
+  } testSettings[] = {
+      {dwio::common::FileFormat::DWRF, true, true, 1 << 30, true, true},
+      {dwio::common::FileFormat::DWRF, true, true, 1, true, true},
+      {dwio::common::FileFormat::DWRF, true, false, 1 << 30, false, false},
+      {dwio::common::FileFormat::DWRF, true, false, 1, false, false},
+      {dwio::common::FileFormat::DWRF, false, true, 1 << 30, true, false},
+      {dwio::common::FileFormat::DWRF, false, true, 1, true, true},
+      {dwio::common::FileFormat::DWRF, false, false, 1 << 30, false, false},
+      {dwio::common::FileFormat::DWRF, false, false, 1, false, false},
+  // Add Parquet with https://github.com/facebookincubator/velox/issues/5560
+#if 0
+      {dwio::common::FileFormat::PARQUET, true, true, 1 << 30, false, false},
+      {dwio::common::FileFormat::PARQUET, true, true, 1, false, false},
+      {dwio::common::FileFormat::PARQUET, true, false, 1 << 30, false, false},
+      {dwio::common::FileFormat::PARQUET, true, false, 1, false, false},
+      {dwio::common::FileFormat::PARQUET, false, true, 1 << 30, false, false},
+      {dwio::common::FileFormat::PARQUET, false, true, 1, false, false},
+      {dwio::common::FileFormat::PARQUET, false, false, 1 << 30, false, false},
+      {dwio::common::FileFormat::PARQUET, false, false, 1, false, false}
+#endif
+  };
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::MemoryReclaimer::reclaimableBytes",
+      std::function<void(dwrf::Writer*)>([&](dwrf::Writer* writer) {
+        // Release before reclaim to make it not able to reclaim from reserved
+        // memory.
+        writer->getContext().releaseMemoryReservation();
+      }));
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    setupMemoryPools();
+
+    const auto outputDirectory = TempDirectoryPath::create();
+    std::shared_ptr<HiveBucketProperty> bucketProperty;
+    std::vector<std::string> partitionBy;
+    if (testData.sortWriter) {
+      partitionBy = {"c6"};
+      bucketProperty = std::make_shared<HiveBucketProperty>(
+          HiveBucketProperty::Kind::kHiveCompatible,
+          4,
+          std::vector<std::string>{"c0"},
+          std::vector<TypePtr>{BIGINT()},
+          std::vector<std::shared_ptr<const HiveSortingColumn>>{
+              std::make_shared<HiveSortingColumn>(
+                  "c1", core::SortOrder{false, false})});
+    }
+    std::shared_ptr<TempDirectoryPath> spillDirectory;
+    std::unique_ptr<SpillConfig> spillConfig;
+    if (testData.writerSpillEnabled) {
+      spillDirectory = exec::test::TempDirectoryPath::create();
+      spillConfig = getSpillConfig(
+          spillDirectory->getPath(), testData.writerFlushThreshold);
+      auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+          opPool_.get(),
+          connectorPool_.get(),
+          connectorSessionProperties_.get(),
+          spillConfig.get(),
+          exec::test::defaultPrefixSortConfig(),
+          nullptr,
+          nullptr,
+          "query.HiveDataSinkTest",
+          "task.HiveDataSinkTest",
+          "planNodeId.HiveDataSinkTest",
+          0,
+          "");
+      setConnectorQueryContext(std::move(connectorQueryCtx));
+    } else {
+      auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+          opPool_.get(),
+          connectorPool_.get(),
+          connectorSessionProperties_.get(),
+          nullptr,
+          exec::test::defaultPrefixSortConfig(),
+          nullptr,
+          nullptr,
+          "query.HiveDataSinkTest",
+          "task.HiveDataSinkTest",
+          "planNodeId.HiveDataSinkTest",
+          0,
+          "");
+      setConnectorQueryContext(std::move(connectorQueryCtx));
+    }
+
+    auto dataSink = createDataSink(
+        rowType_,
+        outputDirectory->getPath(),
+        testData.format,
+        partitionBy,
+        bucketProperty);
+    auto* hiveDataSink = static_cast<HiveDataSink*>(dataSink.get());
+    ASSERT_EQ(
+        hiveDataSink->canReclaim(), testData.expectedWriterReclaimEnabled);
+    for (int i = 0; i < numBatches; ++i) {
+      dataSink->appendData(vectors[i]);
+    }
+    memory::MemoryArbitrator::Stats oldStats =
+        memory::memoryManager()->arbitrator()->stats();
+    uint64_t reclaimableBytes{0};
+    if (testData.expectedWriterReclaimed) {
+      reclaimableBytes = root_->reclaimableBytes().value();
+      ASSERT_GT(reclaimableBytes, 0);
+      memory::testingRunArbitration();
+      memory::MemoryArbitrator::Stats curStats =
+          memory::memoryManager()->arbitrator()->stats();
+      ASSERT_GT(curStats.reclaimTimeUs - oldStats.reclaimTimeUs, 0);
+      ASSERT_GT(curStats.numReclaimedBytes - oldStats.numReclaimedBytes, 0);
+      // We expect dwrf writer set numNonReclaimableAttempts counter.
+      ASSERT_LE(
+          curStats.numNonReclaimableAttempts -
+              oldStats.numNonReclaimableAttempts,
+          1);
+    } else {
+      ASSERT_FALSE(root_->reclaimableBytes().has_value());
+      memory::testingRunArbitration();
+      memory::MemoryArbitrator::Stats curStats =
+          memory::memoryManager()->arbitrator()->stats();
+      ASSERT_EQ(curStats.reclaimTimeUs - oldStats.reclaimTimeUs, 0);
+      ASSERT_EQ(curStats.numReclaimedBytes - oldStats.numReclaimedBytes, 0);
+    }
+    const auto partitions = dataSink->close();
+    if (testData.sortWriter && testData.expectedWriterReclaimed) {
+      ASSERT_FALSE(dataSink->stats().spillStats.empty());
+    } else {
+      ASSERT_TRUE(dataSink->stats().spillStats.empty());
+    }
+    ASSERT_GE(partitions.size(), 1);
+  }
+}
+
+TEST_F(HiveDataSinkTest, memoryReclaimAfterClose) {
+  const int numBatches = 10;
+  const auto vectors = createVectors(500, 10);
+
+  struct {
+    dwio::common::FileFormat format;
+    bool sortWriter;
+    bool writerSpillEnabled;
+    bool close;
+    bool expectedWriterReclaimEnabled;
+
+    std::string debugString() const {
+      return fmt::format(
+          "format: {}, sortWriter: {}, writerSpillEnabled: {}, close: {}, expectedWriterReclaimEnabled: {}",
+          dwio::common::toString(format),
+          sortWriter,
+          writerSpillEnabled,
+          close,
+          expectedWriterReclaimEnabled);
+    }
+  } testSettings[] = {
+      {dwio::common::FileFormat::DWRF, true, true, true, true},
+      {dwio::common::FileFormat::DWRF, true, false, true, false},
+      {dwio::common::FileFormat::DWRF, true, true, false, true},
+      {dwio::common::FileFormat::DWRF, true, false, false, false},
+      {dwio::common::FileFormat::DWRF, false, true, true, true},
+      {dwio::common::FileFormat::DWRF, false, false, true, false},
+      {dwio::common::FileFormat::DWRF, false, true, false, true},
+      {dwio::common::FileFormat::DWRF, false, false, false, false}
+      // Add parquet file format after fix
+      // https://github.com/facebookincubator/velox/issues/5560
+  };
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::unordered_map<std::string, std::string> connectorConfig;
+    // Always allow memory reclaim from the file writer/
+    connectorConfig.emplace(
+        "file_writer_flush_threshold_bytes", folly::to<std::string>(0));
+    // Avoid internal the stripe flush while data write.
+    connectorConfig.emplace("hive.orc.writer.stripe-max-size", "1GB");
+    connectorConfig.emplace("hive.orc.writer.dictionary-max-memory", "1GB");
+
+    connectorConfig_ = std::make_shared<HiveConfig>(
+        std::make_shared<config::ConfigBase>(std::move(connectorConfig)));
+    const auto outputDirectory = TempDirectoryPath::create();
+    std::shared_ptr<HiveBucketProperty> bucketProperty;
+    std::vector<std::string> partitionBy;
+    if (testData.sortWriter) {
+      partitionBy = {"c6"};
+      bucketProperty = std::make_shared<HiveBucketProperty>(
+          HiveBucketProperty::Kind::kHiveCompatible,
+          4,
+          std::vector<std::string>{"c0"},
+          std::vector<TypePtr>{BIGINT()},
+          std::vector<std::shared_ptr<const HiveSortingColumn>>{
+              std::make_shared<HiveSortingColumn>(
+                  "c1", core::SortOrder{false, false})});
+    }
+    std::shared_ptr<TempDirectoryPath> spillDirectory;
+    std::unique_ptr<SpillConfig> spillConfig;
+    if (testData.writerSpillEnabled) {
+      spillDirectory = exec::test::TempDirectoryPath::create();
+      spillConfig = getSpillConfig(spillDirectory->getPath(), 0);
+      auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+          opPool_.get(),
+          connectorPool_.get(),
+          connectorSessionProperties_.get(),
+          spillConfig.get(),
+          exec::test::defaultPrefixSortConfig(),
+          nullptr,
+          nullptr,
+          "query.HiveDataSinkTest",
+          "task.HiveDataSinkTest",
+          "planNodeId.HiveDataSinkTest",
+          0,
+          "");
+      setConnectorQueryContext(std::move(connectorQueryCtx));
+    } else {
+      auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+          opPool_.get(),
+          connectorPool_.get(),
+          connectorSessionProperties_.get(),
+          nullptr,
+          exec::test::defaultPrefixSortConfig(),
+          nullptr,
+          nullptr,
+          "query.HiveDataSinkTest",
+          "task.HiveDataSinkTest",
+          "planNodeId.HiveDataSinkTest",
+          0,
+          "");
+      setConnectorQueryContext(std::move(connectorQueryCtx));
+    }
+
+    auto dataSink = createDataSink(
+        rowType_,
+        outputDirectory->getPath(),
+        testData.format,
+        partitionBy,
+        bucketProperty);
+    auto* hiveDataSink = static_cast<HiveDataSink*>(dataSink.get());
+    ASSERT_EQ(
+        hiveDataSink->canReclaim(), testData.expectedWriterReclaimEnabled);
+
+    for (int i = 0; i < numBatches; ++i) {
+      dataSink->appendData(vectors[i]);
+    }
+    if (testData.close) {
+      const auto partitions = dataSink->close();
+      ASSERT_GE(partitions.size(), 1);
+    } else {
+      dataSink->abort();
+      ASSERT_TRUE(dataSink->stats().empty());
+    }
+
+    memory::MemoryReclaimer::Stats stats;
+    uint64_t reclaimableBytes{0};
+    if (testData.expectedWriterReclaimEnabled) {
+      reclaimableBytes = root_->reclaimableBytes().value();
+      if (testData.close) {
+        // NOTE: file writer might not release all the memory on close
+        // immediately.
+        ASSERT_GE(reclaimableBytes, 0);
+      } else {
+        ASSERT_EQ(reclaimableBytes, 0);
+      }
+    } else {
+      ASSERT_FALSE(root_->reclaimableBytes().has_value());
+    }
+    ASSERT_EQ(root_->reclaim(1L << 30, 0, stats), 0);
+    ASSERT_EQ(stats.reclaimExecTimeUs, 0);
+    ASSERT_EQ(stats.reclaimedBytes, 0);
+    if (testData.expectedWriterReclaimEnabled) {
+      ASSERT_GE(stats.numNonReclaimableAttempts, 0);
+    } else {
+      ASSERT_EQ(stats.numNonReclaimableAttempts, 0);
+    }
   }
 }
+
+DEBUG_ONLY_TEST_F(HiveDataSinkTest, sortWriterFailureTest) {
+  auto vectors = createVectors(500, 10);
+
+  const auto outputDirectory = TempDirectoryPath::create();
+  const std::vector<std::string> partitionBy{"c6"};
+  const auto bucketProperty = std::make_shared<HiveBucketProperty>(
+      HiveBucketProperty::Kind::kHiveCompatible,
+      4,
+      std::vector<std::string>{"c0"},
+      std::vector<TypePtr>{BIGINT()},
+      std::vector<std::shared_ptr<const HiveSortingColumn>>{
+          std::make_shared<HiveSortingColumn>(
+              "c1", core::SortOrder{false, false})});
+  const std::shared_ptr<TempDirectoryPath> spillDirectory =
+      exec::test::TempDirectoryPath::create();
+  std::unique_ptr<SpillConfig> spillConfig =
+      getSpillConfig(spillDirectory->getPath(), 0);
+  // Triggers the memory reservation in sort buffer.
+  spillConfig->minSpillableReservationPct = 1'000;
+  auto connectorQueryCtx = std::make_unique<connector::ConnectorQueryCtx>(
+      opPool_.get(),
+      connectorPool_.get(),
+      connectorSessionProperties_.get(),
+      spillConfig.get(),
+      exec::test::defaultPrefixSortConfig(),
+      nullptr,
+      nullptr,
+      "query.HiveDataSinkTest",
+      "task.HiveDataSinkTest",
+      "planNodeId.HiveDataSinkTest",
+      0,
+      "");
+  setConnectorQueryContext(std::move(connectorQueryCtx));
+
+  auto dataSink = createDataSink(
+      rowType_,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::DWRF,
+      partitionBy,
+      bucketProperty);
+  for (auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::write",
+      std::function<void(memory::MemoryPool*)>(
+          [&](memory::MemoryPool* pool) { VELOX_FAIL("inject failure"); }));
+
+  VELOX_ASSERT_THROW(dataSink->close(), "inject failure");
+}
+
+TEST_F(HiveDataSinkTest, insertTableHandleToString) {
+  const int32_t numBuckets = 4;
+  auto bucketProperty = std::make_shared<HiveBucketProperty>(
+      HiveBucketProperty::Kind::kHiveCompatible,
+      numBuckets,
+      std::vector<std::string>{"c5"},
+      std::vector<TypePtr>{VARCHAR()},
+      std::vector<std::shared_ptr<const HiveSortingColumn>>{
+          std::make_shared<HiveSortingColumn>(
+              "c5", core::SortOrder{false, false})});
+  auto insertTableHandle = createHiveInsertTableHandle(
+      rowType_,
+      "/path/to/test",
+      dwio::common::FileFormat::DWRF,
+      {"c5", "c6"},
+      bucketProperty);
+  ASSERT_EQ(
+      insertTableHandle->toString(),
+      "HiveInsertTableHandle [dwrf zstd], [inputColumns: [ HiveColumnHandle [name: c0, columnType: Regular, dataType: BIGINT, requiredSubfields: [ ]] HiveColumnHandle [name: c1, columnType: Regular, dataType: INTEGER, requiredSubfields: [ ]] HiveColumnHandle [name: c2, columnType: Regular, dataType: SMALLINT, requiredSubfields: [ ]] HiveColumnHandle [name: c3, columnType: Regular, dataType: REAL, requiredSubfields: [ ]] HiveColumnHandle [name: c4, columnType: Regular, dataType: DOUBLE, requiredSubfields: [ ]] HiveColumnHandle [name: c5, columnType: PartitionKey, dataType: VARCHAR, requiredSubfields: [ ]] HiveColumnHandle [name: c6, columnType: PartitionKey, dataType: BOOLEAN, requiredSubfields: [ ]] ], locationHandle: LocationHandle [targetPath: /path/to/test, writePath: /path/to/test, tableType: kNew,, bucketProperty: \nHiveBucketProperty[<HIVE_COMPATIBLE 4>\n\tBucket Columns:\n\t\tc5\n\tBucket Types:\n\t\tVARCHAR\n\tSortedBy Columns:\n\t\t[COLUMN[c5] ORDER[DESC NULLS LAST]]\n]\n]");
+}
+
+#ifdef VELOX_ENABLE_PARQUET
+TEST_F(HiveDataSinkTest, flushPolicyWithParquet) {
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto flushPolicyFactory = []() {
+    return std::make_unique<parquet::DefaultFlushPolicy>(1234, 0);
+  };
+  auto writeOptions = std::make_shared<parquet::WriterOptions>();
+  writeOptions->flushPolicyFactory = flushPolicyFactory;
+  auto dataSink = createDataSink(
+      rowType_,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::PARQUET,
+      {},
+      nullptr,
+      writeOptions);
+
+  const int numBatches = 10;
+  const auto vectors = createVectors(500, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+  dataSink->close();
+
+  dwio::common::ReaderOptions readerOpts{pool_.get()};
+  const std::vector<std::string> filePaths =
+      listFiles(outputDirectory->getPath());
+  auto bufferedInput = std::make_unique<dwio::common::BufferedInput>(
+      std::make_shared<LocalReadFile>(filePaths[0]), readerOpts.memoryPool());
+
+  auto reader = std::make_unique<facebook::velox::parquet::ParquetReader>(
+      std::move(bufferedInput), readerOpts);
+  auto fileMeta = reader->fileMetaData();
+  EXPECT_EQ(fileMeta.numRowGroups(), 10);
+  EXPECT_EQ(fileMeta.rowGroup(0).numRows(), 500);
+}
+#endif
+
+TEST_F(HiveDataSinkTest, flushPolicyWithDWRF) {
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto flushPolicyFactory = []() {
+    return std::make_unique<dwrf::DefaultFlushPolicy>(1234, 0);
+  };
+
+  auto writeOptions = std::make_shared<dwrf::WriterOptions>();
+  writeOptions->flushPolicyFactory = flushPolicyFactory;
+  auto dataSink = createDataSink(
+      rowType_,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::DWRF,
+      {},
+      nullptr,
+      writeOptions);
+
+  const int numBatches = 10;
+  const auto vectors = createVectors(500, numBatches);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+  dataSink->close();
+
+  dwio::common::ReaderOptions readerOpts{pool_.get()};
+  const std::vector<std::string> filePaths =
+      listFiles(outputDirectory->getPath());
+  auto bufferedInput = std::make_unique<dwio::common::BufferedInput>(
+      std::make_shared<LocalReadFile>(filePaths[0]), readerOpts.memoryPool());
+
+  auto reader = std::make_unique<facebook::velox::dwrf::DwrfReader>(
+      readerOpts, std::move(bufferedInput));
+  EXPECT_EQ(reader->getNumberOfStripes(), 10);
+  EXPECT_EQ(reader->getRowsPerStripe()[0], 500);
+}
+
 } // namespace
 } // namespace facebook::velox::connector::hive
 
@@ -492,6 +1086,6 @@ int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   // Signal handler required for ThreadDebugInfoTest
   facebook::velox::process::addDefaultFatalSignalHandler();
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp b/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
index 0b35f596bb545..eee2eb8139c49 100644
--- a/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
+++ b/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
@@ -25,6 +25,10 @@ using namespace facebook::velox;
 class HivePartitionFunctionTest : public ::testing::Test,
                                   public test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void assertPartitions(
       const VectorPtr& vector,
       int bucketCount,
@@ -315,23 +319,17 @@ TEST_F(HivePartitionFunctionTest, arrayElementsEncoded) {
   auto rawSizes = sizesBuffer->asMutable<vector_size_t>();
   auto rawNulls = nullsBuffer->asMutable<uint64_t>();
 
-  // Make the elements overlap and have gaps.
+  // Make the elements have gaps.
   // Set the values in position 2 to be invalid since that Array should be null.
   std::vector<vector_size_t> offsets{
-      0, 2, std::numeric_limits<int32_t>().max(), 1, 8};
+      0, 2, std::numeric_limits<int32_t>().max(), 4, 8};
   std::vector<vector_size_t> sizes{
-      4, 3, std::numeric_limits<int32_t>().max(), 5, 2};
+      2, 1, std::numeric_limits<int32_t>().max(), 3, 2};
   memcpy(rawOffsets, offsets.data(), size * sizeof(vector_size_t));
   memcpy(rawSizes, sizes.data(), size * sizeof(vector_size_t));
 
   bits::setNull(rawNulls, 2);
 
-  // Produces arrays that look like:
-  // [9, NULL, 7, 6]
-  // [7, 6, 5]
-  // NULL
-  // [NULL, 7, 6, 5, NULL]
-  // [1, NULL]
   auto values = std::make_shared<ArrayVector>(
       pool_.get(),
       ARRAY(elements->type()),
@@ -342,9 +340,9 @@ TEST_F(HivePartitionFunctionTest, arrayElementsEncoded) {
       encodedElements);
 
   assertPartitions(values, 1, {0, 0, 0, 0, 0});
-  assertPartitions(values, 2, {0, 0, 0, 0, 1});
-  assertPartitions(values, 500, {342, 418, 0, 458, 31});
-  assertPartitions(values, 997, {149, 936, 0, 103, 31});
+  assertPartitions(values, 2, {1, 1, 0, 0, 1});
+  assertPartitions(values, 500, {279, 7, 0, 308, 31});
+  assertPartitions(values, 997, {279, 7, 0, 820, 31});
 
   assertPartitionsWithConstChannel(values, 1);
   assertPartitionsWithConstChannel(values, 2);
@@ -424,23 +422,17 @@ TEST_F(HivePartitionFunctionTest, mapEntriesEncoded) {
   auto rawSizes = sizesBuffer->asMutable<vector_size_t>();
   auto rawNulls = nullsBuffer->asMutable<uint64_t>();
 
-  // Make the elements overlap and have gaps.
+  // Make the elements have gaps.
   // Set the values in position 2 to be invalid since that Map should be null.
   std::vector<vector_size_t> offsets{
-      0, 2, std::numeric_limits<int32_t>().max(), 1, 8};
+      0, 2, std::numeric_limits<int32_t>().max(), 4, 8};
   std::vector<vector_size_t> sizes{
-      4, 3, std::numeric_limits<int32_t>().max(), 5, 2};
+      2, 1, std::numeric_limits<int32_t>().max(), 3, 2};
   memcpy(rawOffsets, offsets.data(), size * sizeof(vector_size_t));
   memcpy(rawSizes, sizes.data(), size * sizeof(vector_size_t));
 
   bits::setNull(rawNulls, 2);
 
-  // Produces maps that look like:
-  // {key_0: 9, key_3: NULL, key_6: 7, key_9: 6}
-  // {key_6: 7, key_9: 6, key_2: 5}
-  // NULL
-  // {key_3: NULL, key_6: 7, key_9: 6, key_2: 5, key_5: NULL}
-  // {key_4: 1, key_7: NULL}
   auto values = std::make_shared<MapVector>(
       pool_.get(),
       MAP(mapKeys->type(), mapValues->type()),
@@ -453,8 +445,8 @@ TEST_F(HivePartitionFunctionTest, mapEntriesEncoded) {
 
   assertPartitions(values, 1, {0, 0, 0, 0, 0});
   assertPartitions(values, 2, {0, 1, 0, 1, 0});
-  assertPartitions(values, 500, {176, 259, 0, 91, 336});
-  assertPartitions(values, 997, {694, 24, 0, 365, 345});
+  assertPartitions(values, 500, {336, 413, 0, 259, 336});
+  assertPartitions(values, 997, {345, 666, 0, 24, 345});
 
   assertPartitionsWithConstChannel(values, 1);
   assertPartitionsWithConstChannel(values, 2);
@@ -727,3 +719,17 @@ TEST_F(HivePartitionFunctionTest, function) {
     }
   }
 }
+
+TEST_F(HivePartitionFunctionTest, unknown) {
+  auto values = makeAllNullFlatVector<UnknownValue>(4);
+
+  assertPartitions(values, 1, {0, 0, 0, 0});
+  assertPartitions(values, 2, {0, 0, 0, 0});
+  assertPartitions(values, 500, {0, 0, 0, 0});
+  assertPartitions(values, 997, {0, 0, 0, 0});
+
+  assertPartitionsWithConstChannel(values, 1);
+  assertPartitionsWithConstChannel(values, 2);
+  assertPartitionsWithConstChannel(values, 500);
+  assertPartitionsWithConstChannel(values, 997);
+}
diff --git a/velox/connectors/hive/tests/HivePartitionUtilTest.cpp b/velox/connectors/hive/tests/HivePartitionUtilTest.cpp
index 7bd16286dec5b..187e5c49b9755 100644
--- a/velox/connectors/hive/tests/HivePartitionUtilTest.cpp
+++ b/velox/connectors/hive/tests/HivePartitionUtilTest.cpp
@@ -92,8 +92,10 @@ TEST_F(HivePartitionUtilTest, partitionName) {
       std::iota(partitionChannels.begin(), partitionChannels.end(), 0);
 
       EXPECT_EQ(
-          FileUtils::makePartName(extractPartitionKeyValues(
-              makePartitionsVector(input, partitionChannels), 0)),
+          FileUtils::makePartName(
+              extractPartitionKeyValues(
+                  makePartitionsVector(input, partitionChannels), 0),
+              true),
           folly::join(
               "/",
               std::vector<std::string>(
@@ -112,8 +114,40 @@ TEST_F(HivePartitionUtilTest, partitionName) {
     std::vector<column_index_t> partitionChannels{0};
 
     VELOX_ASSERT_THROW(
-        FileUtils::makePartName(extractPartitionKeyValues(
-            makePartitionsVector(input, partitionChannels), 0)),
+        FileUtils::makePartName(
+            extractPartitionKeyValues(
+                makePartitionsVector(input, partitionChannels), 0),
+            true),
         "Unsupported partition type: MAP");
   }
 }
+
+TEST_F(HivePartitionUtilTest, partitionNameForNull) {
+  std::vector<std::string> partitionColumnNames{
+      "flat_bool_col",
+      "flat_tinyint_col",
+      "flat_smallint_col",
+      "flat_int_col",
+      "flat_bigint_col",
+      "flat_string_col",
+      "const_date_col"};
+
+  RowVectorPtr input = makeRowVector(
+      partitionColumnNames,
+      {makeNullableFlatVector<bool>({std::nullopt}),
+       makeNullableFlatVector<int8_t>({std::nullopt}),
+       makeNullableFlatVector<int16_t>({std::nullopt}),
+       makeNullableFlatVector<int32_t>({std::nullopt}),
+       makeNullableFlatVector<int64_t>({std::nullopt}),
+       makeNullableFlatVector<StringView>({std::nullopt}),
+       makeConstant<int32_t>(std::nullopt, 1, DATE())});
+
+  for (auto i = 0; i < partitionColumnNames.size(); i++) {
+    std::vector<column_index_t> partitionChannels = {(column_index_t)i};
+    auto partitionEntries = extractPartitionKeyValues(
+        makePartitionsVector(input, partitionChannels), 0);
+    EXPECT_EQ(1, partitionEntries.size());
+    EXPECT_EQ(partitionColumnNames[i], partitionEntries[0].first);
+    EXPECT_EQ("", partitionEntries[0].second);
+  }
+}
diff --git a/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp b/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
index a366a8b38f362..7f980cffe7b52 100644
--- a/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
+++ b/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
@@ -23,12 +23,17 @@
 namespace facebook::velox::connector::hive {
 
 class PartitionIdGeneratorTest : public ::testing::Test,
-                                 public test::VectorTestBase {};
+                                 public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 TEST_F(PartitionIdGeneratorTest, consecutiveIdsSingleKey) {
   auto numPartitions = 100;
 
-  PartitionIdGenerator idGenerator(ROW({VARCHAR()}), {0}, 100, pool());
+  PartitionIdGenerator idGenerator(ROW({VARCHAR()}), {0}, 100, pool(), true);
 
   auto input = makeRowVector(
       {makeFlatVector<StringView>(numPartitions * 3, [&](auto row) {
@@ -50,7 +55,7 @@ TEST_F(PartitionIdGeneratorTest, consecutiveIdsSingleKey) {
 
 TEST_F(PartitionIdGeneratorTest, consecutiveIdsMultipleKeys) {
   PartitionIdGenerator idGenerator(
-      ROW({VARCHAR(), INTEGER()}), {0, 1}, 100, pool());
+      ROW({VARCHAR(), INTEGER()}), {0, 1}, 100, pool(), true);
 
   auto input = makeRowVector({
       makeFlatVector<StringView>(
@@ -75,8 +80,35 @@ TEST_F(PartitionIdGeneratorTest, consecutiveIdsMultipleKeys) {
       numPartitions - 1);
 }
 
+TEST_F(PartitionIdGeneratorTest, multipleBoolKeys) {
+  PartitionIdGenerator idGenerator(
+      ROW({BOOLEAN(), BOOLEAN()}), {0, 1}, 100, pool(), true);
+
+  auto input = makeRowVector({
+      makeFlatVector<bool>(
+          1'000, [](vector_size_t row) { return row < 50; }, nullEvery(7)),
+      makeFlatVector<bool>(
+          1'000,
+          [](vector_size_t row) { return (row % 2) == 0; },
+          nullEvery(3)),
+  });
+
+  raw_vector<uint64_t> ids;
+  idGenerator.run(input, ids);
+
+  // distinctIds contains 9 ids.
+  const auto numPartitions = 9;
+
+  std::unordered_set<uint64_t> distinctIds(ids.begin(), ids.end());
+  EXPECT_EQ(distinctIds.size(), numPartitions);
+  EXPECT_EQ(*std::min_element(distinctIds.begin(), distinctIds.end()), 0);
+  EXPECT_EQ(
+      *std::max_element(distinctIds.begin(), distinctIds.end()),
+      numPartitions - 1);
+}
+
 TEST_F(PartitionIdGeneratorTest, stableIdsSingleKey) {
-  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool());
+  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool(), true);
 
   auto numPartitions = 40;
   auto input = makeRowVector({
@@ -103,7 +135,7 @@ TEST_F(PartitionIdGeneratorTest, stableIdsSingleKey) {
 
 TEST_F(PartitionIdGeneratorTest, stableIdsMultipleKeys) {
   PartitionIdGenerator idGenerator(
-      ROW({BIGINT(), VARCHAR(), INTEGER()}), {1, 2}, 100, pool());
+      ROW({BIGINT(), VARCHAR(), INTEGER()}), {1, 2}, 100, pool(), true);
 
   const vector_size_t size = 1'000;
   auto input = makeRowVector({
@@ -140,8 +172,23 @@ TEST_F(PartitionIdGeneratorTest, stableIdsMultipleKeys) {
   }
 }
 
+TEST_F(PartitionIdGeneratorTest, partitionKeysCaseSensitive) {
+  PartitionIdGenerator idGenerator(
+      ROW({"cc0", "Cc1"}, {BIGINT(), VARCHAR()}), {1}, 100, pool(), false);
+
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<std::string>({"apple", "orange", "apple"}),
+  });
+
+  raw_vector<uint64_t> firstTimeIds;
+  idGenerator.run(input, firstTimeIds);
+  EXPECT_EQ("Cc1=apple", idGenerator.partitionName(0));
+  EXPECT_EQ("Cc1=orange", idGenerator.partitionName(1));
+}
+
 TEST_F(PartitionIdGeneratorTest, numPartitions) {
-  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool());
+  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool(), true);
 
   // First run to process partition 0,..,9. Total num of partitions processed by
   // far is 10.
@@ -176,7 +223,7 @@ TEST_F(PartitionIdGeneratorTest, limitOfPartitionNumber) {
   auto maxPartitions = 100;
 
   PartitionIdGenerator idGenerator(
-      ROW({INTEGER()}), {0}, maxPartitions, pool());
+      ROW({INTEGER()}), {0}, maxPartitions, pool(), true);
 
   auto input = makeRowVector({
       makeFlatVector<int32_t>(maxPartitions + 1, [](auto row) { return row; }),
@@ -204,7 +251,8 @@ TEST_F(PartitionIdGeneratorTest, supportedPartitionKeyTypes) {
         }),
         {0, 1, 2, 3, 4, 5, 6},
         100,
-        pool());
+        pool(),
+        true);
 
     auto input = makeRowVector({
         makeNullableFlatVector<StringView>(
@@ -238,7 +286,8 @@ TEST_F(PartitionIdGeneratorTest, supportedPartitionKeyTypes) {
 
     for (column_index_t i = 1; i < input->childrenSize(); i++) {
       VELOX_ASSERT_THROW(
-          PartitionIdGenerator(asRowType(input->type()), {i}, 100, pool()),
+          PartitionIdGenerator(
+              asRowType(input->type()), {i}, 100, pool(), true),
           fmt::format(
               "Unsupported partition type: {}.",
               input->childAt(i)->type()->toString()));
diff --git a/velox/connectors/tests/CMakeLists.txt b/velox/connectors/tests/CMakeLists.txt
index c024da41b3e05..4475ce474ee8f 100644
--- a/velox/connectors/tests/CMakeLists.txt
+++ b/velox/connectors/tests/CMakeLists.txt
@@ -17,8 +17,8 @@ add_test(velox_connector_test velox_connector_test)
 target_link_libraries(
   velox_connector_test
   velox_connector
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   glog::glog
   gflags::gflags
   Folly::folly)
diff --git a/velox/connectors/tests/ConnectorTest.cpp b/velox/connectors/tests/ConnectorTest.cpp
index ba54bceed625b..5681bc80cb04e 100644
--- a/velox/connectors/tests/ConnectorTest.cpp
+++ b/velox/connectors/tests/ConnectorTest.cpp
@@ -15,6 +15,9 @@
  */
 
 #include "velox/connectors/Connector.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/config/Config.h"
+
 #include <gtest/gtest.h>
 
 namespace facebook::velox::connector {
@@ -25,7 +28,7 @@ namespace {
 
 class TestConnector : public connector::Connector {
  public:
-  TestConnector(const std::string& id) : connector::Connector(id, nullptr) {}
+  TestConnector(const std::string& id) : connector::Connector(id) {}
 
   std::unique_ptr<connector::DataSource> createDataSource(
       const RowTypePtr& /* outputType */,
@@ -47,13 +50,36 @@ class TestConnector : public connector::Connector {
   }
 };
 
+class TestConnectorFactory : public connector::ConnectorFactory {
+ public:
+  static constexpr const char* kConnectorFactoryName = "test-factory";
+
+  TestConnectorFactory() : ConnectorFactory(kConnectorFactoryName) {}
+
+  std::shared_ptr<Connector> newConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> /*config*/,
+      folly::Executor* /*executor*/ = nullptr) override {
+    return std::make_shared<TestConnector>(id);
+  }
+};
+
 } // namespace
 
 TEST_F(ConnectorTest, getAllConnectors) {
+  registerConnectorFactory(std::make_shared<TestConnectorFactory>());
+  VELOX_ASSERT_THROW(
+      registerConnectorFactory(std::make_shared<TestConnectorFactory>()),
+      "ConnectorFactory with name 'test-factory' is already registered");
+  EXPECT_TRUE(hasConnectorFactory(TestConnectorFactory::kConnectorFactoryName));
   const int32_t numConnectors = 10;
   for (int32_t i = 0; i < numConnectors; i++) {
     registerConnector(
-        std::make_shared<TestConnector>(fmt::format("connector-{}", i)));
+        getConnectorFactory(TestConnectorFactory::kConnectorFactoryName)
+            ->newConnector(
+                fmt::format("connector-{}", i),
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>())));
   }
   const auto& connectors = getAllConnectors();
   EXPECT_EQ(connectors.size(), numConnectors);
@@ -64,5 +90,9 @@ TEST_F(ConnectorTest, getAllConnectors) {
     unregisterConnector(fmt::format("connector-{}", i));
   }
   EXPECT_EQ(getAllConnectors().size(), 0);
+  EXPECT_TRUE(
+      unregisterConnectorFactory(TestConnectorFactory::kConnectorFactoryName));
+  EXPECT_FALSE(
+      unregisterConnectorFactory(TestConnectorFactory::kConnectorFactoryName));
 }
 } // namespace facebook::velox::connector
diff --git a/velox/connectors/tpch/CMakeLists.txt b/velox/connectors/tpch/CMakeLists.txt
index b7123f2f6f0e8..b8373349e7d00 100644
--- a/velox/connectors/tpch/CMakeLists.txt
+++ b/velox/connectors/tpch/CMakeLists.txt
@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_tpch_connector OBJECT TpchConnector.cpp)
+velox_add_library(velox_tpch_connector OBJECT TpchConnector.cpp)
 
-target_link_libraries(velox_tpch_connector velox_connector velox_tpch_gen)
+velox_link_libraries(velox_tpch_connector velox_connector velox_tpch_gen
+                     fmt::fmt)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/connectors/tpch/TpchConnector.cpp b/velox/connectors/tpch/TpchConnector.cpp
index 1bf4eac4c5901..41df3e7251c28 100644
--- a/velox/connectors/tpch/TpchConnector.cpp
+++ b/velox/connectors/tpch/TpchConnector.cpp
@@ -63,7 +63,7 @@ TpchDataSource::TpchDataSource(
     const std::unordered_map<
         std::string,
         std::shared_ptr<connector::ColumnHandle>>& columnHandles,
-    velox::memory::MemoryPool* FOLLY_NONNULL pool)
+    velox::memory::MemoryPool* pool)
     : pool_(pool) {
   auto tpchTableHandle =
       std::dynamic_pointer_cast<TpchTableHandle>(tableHandle);
diff --git a/velox/connectors/tpch/TpchConnector.h b/velox/connectors/tpch/TpchConnector.h
index 8f25c4649c914..babcda8e5cb01 100644
--- a/velox/connectors/tpch/TpchConnector.h
+++ b/velox/connectors/tpch/TpchConnector.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/common/config/Config.h"
 #include "velox/connectors/Connector.h"
 #include "velox/connectors/tpch/TpchConnectorSplit.h"
 #include "velox/tpch/gen/TpchGen.h"
@@ -75,7 +76,7 @@ class TpchDataSource : public DataSource {
       const std::unordered_map<
           std::string,
           std::shared_ptr<connector::ColumnHandle>>& columnHandles,
-      velox::memory::MemoryPool* FOLLY_NONNULL pool);
+      velox::memory::MemoryPool* pool);
 
   void addSplit(std::shared_ptr<ConnectorSplit> split) override;
 
@@ -123,16 +124,16 @@ class TpchDataSource : public DataSource {
   size_t completedRows_{0};
   size_t completedBytes_{0};
 
-  memory::MemoryPool* FOLLY_NONNULL pool_;
+  memory::MemoryPool* pool_;
 };
 
 class TpchConnector final : public Connector {
  public:
   TpchConnector(
       const std::string& id,
-      std::shared_ptr<const Config> properties,
-      folly::Executor* FOLLY_NULLABLE /*executor*/)
-      : Connector(id, properties) {}
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* /*executor*/)
+      : Connector(id) {}
 
   std::unique_ptr<DataSource> createDataSource(
       const std::shared_ptr<const RowType>& outputType,
@@ -140,7 +141,7 @@ class TpchConnector final : public Connector {
       const std::unordered_map<
           std::string,
           std::shared_ptr<connector::ColumnHandle>>& columnHandles,
-      ConnectorQueryCtx* FOLLY_NONNULL connectorQueryCtx) override final {
+      ConnectorQueryCtx* connectorQueryCtx) override final {
     return std::make_unique<TpchDataSource>(
         outputType,
         tableHandle,
@@ -160,18 +161,18 @@ class TpchConnector final : public Connector {
 
 class TpchConnectorFactory : public ConnectorFactory {
  public:
-  static constexpr const char* FOLLY_NONNULL kTpchConnectorName{"tpch"};
+  static constexpr const char* kTpchConnectorName{"tpch"};
 
   TpchConnectorFactory() : ConnectorFactory(kTpchConnectorName) {}
 
-  explicit TpchConnectorFactory(const char* FOLLY_NONNULL connectorName)
+  explicit TpchConnectorFactory(const char* connectorName)
       : ConnectorFactory(connectorName) {}
 
   std::shared_ptr<Connector> newConnector(
       const std::string& id,
-      std::shared_ptr<const Config> properties,
-      folly::Executor* FOLLY_NULLABLE executor = nullptr) override {
-    return std::make_shared<TpchConnector>(id, properties, executor);
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* executor = nullptr) override {
+    return std::make_shared<TpchConnector>(id, config, executor);
   }
 };
 
diff --git a/velox/connectors/tpch/TpchConnectorSplit.h b/velox/connectors/tpch/TpchConnectorSplit.h
index 298a36ac85df5..47588ab6d44a0 100644
--- a/velox/connectors/tpch/TpchConnectorSplit.h
+++ b/velox/connectors/tpch/TpchConnectorSplit.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <fmt/format.h>
 #include "velox/connectors/Connector.h"
 
 namespace facebook::velox::connector::tpch {
@@ -40,3 +41,24 @@ struct TpchConnectorSplit : public connector::ConnectorSplit {
 };
 
 } // namespace facebook::velox::connector::tpch
+
+template <>
+struct fmt::formatter<facebook::velox::connector::tpch::TpchConnectorSplit>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::tpch::TpchConnectorSplit s,
+      format_context& ctx) {
+    return formatter<std::string>::format(s.toString(), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<
+    std::shared_ptr<facebook::velox::connector::tpch::TpchConnectorSplit>>
+    : formatter<std::string> {
+  auto format(
+      std::shared_ptr<facebook::velox::connector::tpch::TpchConnectorSplit> s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(s->toString(), ctx);
+  }
+};
diff --git a/velox/connectors/tpch/tests/CMakeLists.txt b/velox/connectors/tpch/tests/CMakeLists.txt
index 3071da3eb57c0..5474de3cfa906 100644
--- a/velox/connectors/tpch/tests/CMakeLists.txt
+++ b/velox/connectors/tpch/tests/CMakeLists.txt
@@ -21,10 +21,15 @@ target_link_libraries(
   velox_vector_test_lib
   velox_exec_test_lib
   velox_aggregates
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(velox_tpch_speed_test SpeedTest.cpp)
 
-target_link_libraries(velox_tpch_speed_test velox_tpch_connector velox_exec
-                      velox_exec_test_lib velox_memory fmt::fmt)
+target_link_libraries(
+  velox_tpch_speed_test
+  velox_tpch_connector
+  velox_exec
+  velox_exec_test_lib
+  velox_memory
+  fmt::fmt)
diff --git a/velox/connectors/tpch/tests/SpeedTest.cpp b/velox/connectors/tpch/tests/SpeedTest.cpp
index 7df845877df62..8bb713c9c69b1 100644
--- a/velox/connectors/tpch/tests/SpeedTest.cpp
+++ b/velox/connectors/tpch/tests/SpeedTest.cpp
@@ -59,7 +59,10 @@ class TpchSpeedTest {
     auto tpchConnector =
         connector::getConnectorFactory(
             connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(kTpchConnectorId_, nullptr);
+            ->newConnector(
+                kTpchConnectorId_,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
     connector::registerConnector(tpchConnector);
   }
 
@@ -74,7 +77,7 @@ class TpchSpeedTest {
     core::PlanNodeId scanId;
     auto plan =
         PlanBuilder()
-            .tableScan(
+            .tpchTableScan(
                 table, folly::copy(getTableSchema(table)->names()), scaleFactor)
             .capturePlanNodeId(scanId)
             .planNode();
@@ -91,19 +94,18 @@ class TpchSpeedTest {
     params.planNode = plan;
     params.maxDrivers = FLAGS_max_drivers;
 
-    TaskCursor taskCursor(params);
-    taskCursor.start();
+    auto taskCursor = TaskCursor::create(params);
+    taskCursor->start();
 
-    auto task = taskCursor.task();
+    auto task = taskCursor->task();
     addSplits(*task, scanId, numSplits);
 
-    while (taskCursor.moveNext()) {
-      processBatch(taskCursor.current());
+    while (taskCursor->moveNext()) {
+      processBatch(taskCursor->current());
     }
 
     // Wait for the task to finish.
-    auto& inlineExecutor = folly::QueuedImmediateExecutor::instance();
-    task->taskCompletionFuture(0).via(&inlineExecutor).wait();
+    task->taskCompletionFuture().wait();
 
     std::chrono::duration<double> elapsed = system_clock::now() - startTime;
     LOG(INFO) << "Summary:";
@@ -179,7 +181,7 @@ class TpchSpeedTest {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
 
   TpchSpeedTest speedTest;
   speedTest.run(
diff --git a/velox/connectors/tpch/tests/TpchConnectorTest.cpp b/velox/connectors/tpch/tests/TpchConnectorTest.cpp
index 7685bebf516bd..04f4199d348a8 100644
--- a/velox/connectors/tpch/tests/TpchConnectorTest.cpp
+++ b/velox/connectors/tpch/tests/TpchConnectorTest.cpp
@@ -39,7 +39,10 @@ class TpchConnectorTest : public exec::test::OperatorTestBase {
     auto tpchConnector =
         connector::getConnectorFactory(
             connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(kTpchConnectorId, nullptr);
+            ->newConnector(
+                kTpchConnectorId,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
     connector::registerConnector(tpchConnector);
   }
 
@@ -68,7 +71,7 @@ class TpchConnectorTest : public exec::test::OperatorTestBase {
 // Simple scan of first 5 rows of "nation".
 TEST_F(TpchConnectorTest, simple) {
   auto plan = PlanBuilder()
-                  .tableScan(
+                  .tpchTableScan(
                       Table::TBL_NATION,
                       {"n_nationkey", "n_name", "n_regionkey", "n_comment"})
                   .limit(0, 5, false)
@@ -102,7 +105,8 @@ TEST_F(TpchConnectorTest, simple) {
 
 // Extract single column from "nation".
 TEST_F(TpchConnectorTest, singleColumn) {
-  auto plan = PlanBuilder().tableScan(Table::TBL_NATION, {"n_name"}).planNode();
+  auto plan =
+      PlanBuilder().tpchTableScan(Table::TBL_NATION, {"n_name"}).planNode();
 
   auto output = getResults(plan, {makeTpchSplit()});
   auto expected = makeRowVector({makeFlatVector<StringView>({
@@ -125,16 +129,17 @@ TEST_F(TpchConnectorTest, singleColumnWithAlias) {
   auto outputType = ROW({aliasedName}, {VARCHAR()});
   auto plan =
       PlanBuilder()
-          .tableScan(
-              outputType,
-              std::make_shared<TpchTableHandle>(
-                  kTpchConnectorId, Table::TBL_NATION),
-              {
-                  {aliasedName, std::make_shared<TpchColumnHandle>("n_name")},
-                  {"other_name", std::make_shared<TpchColumnHandle>("n_name")},
-                  {"third_column",
-                   std::make_shared<TpchColumnHandle>("n_regionkey")},
-              })
+          .startTableScan()
+          .outputType(outputType)
+          .tableHandle(std::make_shared<TpchTableHandle>(
+              kTpchConnectorId, Table::TBL_NATION))
+          .assignments({
+              {aliasedName, std::make_shared<TpchColumnHandle>("n_name")},
+              {"other_name", std::make_shared<TpchColumnHandle>("n_name")},
+              {"third_column",
+               std::make_shared<TpchColumnHandle>("n_regionkey")},
+          })
+          .endTableScan()
           .limit(0, 1, false)
           .planNode();
 
@@ -150,11 +155,11 @@ TEST_F(TpchConnectorTest, singleColumnWithAlias) {
 
 void TpchConnectorTest::runScaleFactorTest(double scaleFactor) {
   auto plan = PlanBuilder()
-                  .tableScan(
-                      ROW({}, {}),
-                      std::make_shared<TpchTableHandle>(
-                          kTpchConnectorId, Table::TBL_SUPPLIER, scaleFactor),
-                      {})
+                  .startTableScan()
+                  .outputType(ROW({}, {}))
+                  .tableHandle(std::make_shared<TpchTableHandle>(
+                      kTpchConnectorId, Table::TBL_SUPPLIER, scaleFactor))
+                  .endTableScan()
                   .singleAggregation({}, {"count(1)"})
                   .planNode();
 
@@ -179,11 +184,11 @@ TEST_F(TpchConnectorTest, lineitemTinyRowCount) {
   // Lineitem row count depends on the orders.
   // Verify against Java tiny result.
   auto plan = PlanBuilder()
-                  .tableScan(
-                      ROW({}, {}),
-                      std::make_shared<TpchTableHandle>(
-                          kTpchConnectorId, Table::TBL_LINEITEM, 0.01),
-                      {})
+                  .startTableScan()
+                  .outputType(ROW({}, {}))
+                  .tableHandle(std::make_shared<TpchTableHandle>(
+                      kTpchConnectorId, Table::TBL_LINEITEM, 0.01))
+                  .endTableScan()
                   .singleAggregation({}, {"count(1)"})
                   .planNode();
 
@@ -195,7 +200,7 @@ TEST_F(TpchConnectorTest, unknownColumn) {
   EXPECT_THROW(
       {
         PlanBuilder()
-            .tableScan(Table::TBL_NATION, {"does_not_exist"})
+            .tpchTableScan(Table::TBL_NATION, {"does_not_exist"})
             .planNode();
       },
       VeloxUserError);
@@ -205,7 +210,7 @@ TEST_F(TpchConnectorTest, unknownColumn) {
 // same dataset in the end.
 TEST_F(TpchConnectorTest, multipleSplits) {
   auto plan = PlanBuilder()
-                  .tableScan(
+                  .tpchTableScan(
                       Table::TBL_NATION,
                       {"n_nationkey", "n_name", "n_regionkey", "n_comment"})
                   .planNode();
@@ -237,14 +242,14 @@ TEST_F(TpchConnectorTest, join) {
   core::PlanNodeId regionScanId;
   auto plan =
       PlanBuilder(planNodeIdGenerator)
-          .tableScan(
+          .tpchTableScan(
               tpch::Table::TBL_NATION, {"n_regionkey"}, 1.0 /*scaleFactor*/)
           .capturePlanNodeId(nationScanId)
           .hashJoin(
               {"n_regionkey"},
               {"r_regionkey"},
               PlanBuilder(planNodeIdGenerator)
-                  .tableScan(
+                  .tpchTableScan(
                       tpch::Table::TBL_REGION,
                       {"r_regionkey", "r_name"},
                       1.0 /*scaleFactor*/)
@@ -271,7 +276,7 @@ TEST_F(TpchConnectorTest, join) {
 
 TEST_F(TpchConnectorTest, orderDateCount) {
   auto plan = PlanBuilder()
-                  .tableScan(Table::TBL_ORDERS, {"o_orderdate"}, 0.01)
+                  .tpchTableScan(Table::TBL_ORDERS, {"o_orderdate"}, 0.01)
                   .filter("o_orderdate = '1992-01-01'::DATE")
                   .limit(0, 10, false)
                   .planNode();
@@ -287,6 +292,6 @@ TEST_F(TpchConnectorTest, orderDateCount) {
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/core/CMakeLists.txt b/velox/core/CMakeLists.txt
index eb4c18cdbe802..33c2bb5370435 100644
--- a/velox/core/CMakeLists.txt
+++ b/velox/core/CMakeLists.txt
@@ -15,17 +15,20 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-add_library(velox_config Config.cpp)
-target_link_libraries(velox_config PUBLIC velox_exception Folly::folly)
-
-add_library(velox_core Expressions.cpp PlanFragment.cpp PlanNode.cpp
-                       QueryConfig.cpp QueryCtx.cpp SimpleFunctionMetadata.cpp)
+velox_add_library(
+  velox_core
+  Expressions.cpp
+  PlanFragment.cpp
+  PlanNode.cpp
+  QueryConfig.cpp
+  QueryCtx.cpp
+  SimpleFunctionMetadata.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_core
   PUBLIC velox_arrow_bridge
          velox_caching
-         velox_config
+         velox_common_config
          velox_connector
          velox_exception
          velox_expression_functions
@@ -34,4 +37,5 @@ target_link_libraries(
          velox_vector
          Boost::headers
          Folly::folly
+         fmt::fmt
   PRIVATE velox_encode)
diff --git a/velox/core/Config.cpp b/velox/core/Config.cpp
deleted file mode 100644
index 8ccd7a8ccbd28..0000000000000
--- a/velox/core/Config.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/core/Config.h"
-
-namespace facebook::velox::core {
-
-folly::Optional<std::string> MemConfig::get(const std::string& key) const {
-  folly::Optional<std::string> val;
-  auto it = values_.find(key);
-  if (it != values_.end()) {
-    val = it->second;
-  }
-  return val;
-}
-
-bool MemConfig::isValueExists(const std::string& key) const {
-  return values_.find(key) != values_.end();
-}
-
-folly::Optional<std::string> MemConfigMutable::get(
-    const std::string& key) const {
-  auto lockedValues = values_.rlock();
-  folly::Optional<std::string> val;
-  auto it = lockedValues->find(key);
-  if (it != lockedValues->end()) {
-    val = it->second;
-  }
-  return val;
-}
-
-bool MemConfigMutable::isValueExists(const std::string& key) const {
-  auto lockedValues = values_.rlock();
-  return lockedValues->find(key) != lockedValues->end();
-}
-
-} // namespace facebook::velox::core
diff --git a/velox/core/Config.h b/velox/core/Config.h
deleted file mode 100644
index 11ccea060588d..0000000000000
--- a/velox/core/Config.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <folly/Conv.h>
-#include <folly/Optional.h>
-#include <folly/Synchronized.h>
-#include <mutex>
-#include <set>
-#include <typeindex>
-#include <unordered_map>
-#include "velox/common/base/Exceptions.h"
-
-namespace facebook::velox {
-
-class Config {
- public:
-  virtual ~Config() = default;
-
-  virtual folly::Optional<std::string> get(const std::string& key) const = 0;
-  // virtual const string operator[](const std::string& key) = 0;
-  // overload and disable not supported cases.
-
-  template <typename T>
-  folly::Optional<T> get(const std::string& key) const {
-    auto val = get(key);
-    if (val.hasValue()) {
-      return folly::to<T>(val.value());
-    } else {
-      return folly::none;
-    }
-  }
-
-  template <typename T>
-  T get(const std::string& key, const T& defaultValue) const {
-    auto val = get(key);
-    if (val.hasValue()) {
-      return folly::to<T>(val.value());
-    } else {
-      return defaultValue;
-    }
-  }
-
-  virtual bool isValueExists(const std::string& key) const = 0;
-
-  virtual const std::unordered_map<std::string, std::string>& values() const {
-    VELOX_UNSUPPORTED("method values() is not supported by this config");
-  }
-
-  virtual std::unordered_map<std::string, std::string> valuesCopy() const {
-    VELOX_UNSUPPORTED("method valuesCopy() is not supported by this config");
-  }
-};
-
-namespace core {
-
-class MemConfig : public Config {
- public:
-  explicit MemConfig(const std::unordered_map<std::string, std::string>& values)
-      : values_(values) {}
-
-  explicit MemConfig() : values_{} {}
-
-  explicit MemConfig(std::unordered_map<std::string, std::string>&& values)
-      : values_(std::move(values)) {}
-
-  folly::Optional<std::string> get(const std::string& key) const override;
-
-  bool isValueExists(const std::string& key) const override;
-
-  const std::unordered_map<std::string, std::string>& values() const override {
-    return values_;
-  }
-
-  std::unordered_map<std::string, std::string> valuesCopy() const override {
-    return values_;
-  }
-
- private:
-  std::unordered_map<std::string, std::string> values_;
-};
-
-/// In-memory config allowing changing properties at runtime.
-class MemConfigMutable : public Config {
- public:
-  explicit MemConfigMutable(
-      const std::unordered_map<std::string, std::string>& values)
-      : values_(values) {}
-
-  explicit MemConfigMutable() : values_{} {}
-
-  explicit MemConfigMutable(
-      std::unordered_map<std::string, std::string>&& values)
-      : values_(std::move(values)) {}
-
-  folly::Optional<std::string> get(const std::string& key) const override;
-
-  bool isValueExists(const std::string& key) const override;
-
-  const std::unordered_map<std::string, std::string>& values() const override {
-    VELOX_UNSUPPORTED(
-        "Mutable config cannot return unprotected reference to values.");
-    return *values_.rlock();
-  }
-
-  std::unordered_map<std::string, std::string> valuesCopy() const override {
-    return *values_.rlock();
-  }
-
-  /// Adds or replaces value at the given key. Can be used by debugging or
-  /// testing code.
-  void setValue(const std::string& key, const std::string& value) {
-    (*values_.wlock())[key] = value;
-  }
-
- private:
-  folly::Synchronized<std::unordered_map<std::string, std::string>> values_;
-};
-
-} // namespace core
-} // namespace facebook::velox
diff --git a/velox/core/Expressions.h b/velox/core/Expressions.h
index e2036ceb35fe4..e9e9fa65f32fa 100644
--- a/velox/core/Expressions.h
+++ b/velox/core/Expressions.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <iomanip>
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/ITypedExpr.h"
 #include "velox/vector/BaseVector.h"
@@ -23,8 +24,7 @@ namespace facebook::velox::core {
 
 class InputTypedExpr : public ITypedExpr {
  public:
-  InputTypedExpr(std::shared_ptr<const Type> type)
-      : ITypedExpr{std::move(type)} {}
+  explicit InputTypedExpr(TypePtr type) : ITypedExpr{std::move(type)} {}
 
   bool operator==(const ITypedExpr& other) const final {
     const auto* casted = dynamic_cast<const InputTypedExpr*>(&other);
@@ -55,7 +55,7 @@ class ConstantTypedExpr : public ITypedExpr {
  public:
   // Creates constant expression. For complex types, only
   // variant::null() value is supported.
-  ConstantTypedExpr(std::shared_ptr<const Type> type, variant value)
+  ConstantTypedExpr(TypePtr type, variant value)
       : ITypedExpr{std::move(type)}, value_{std::move(value)} {}
 
   // Creates constant expression of scalar or complex type. The value comes from
@@ -87,7 +87,7 @@ class ConstantTypedExpr : public ITypedExpr {
     return valueVector_ != nullptr;
   }
 
-  // Returns scalar value as variant if hasValueVector() is false.
+  /// Returns scalar value as variant if hasValueVector() is false.
   const variant& value() const {
     return value_;
   }
@@ -161,14 +161,48 @@ class ConstantTypedExpr : public ITypedExpr {
   const VectorPtr valueVector_;
 };
 
+using ConstantTypedExprPtr = std::shared_ptr<const ConstantTypedExpr>;
+
+/// Evaluates a scalar function or a special form.
+///
+/// Supported special forms are: and, or, cast, try_cast, coalesce, if, switch,
+/// try. See registerFunctionCallToSpecialForms in
+/// expression/RegisterSpecialForm.h for the up-to-date list.
+///
+/// Regular functions have the following properties: (1) return type is fully
+/// defined by function name and input types; (2) during evaluation all function
+/// arguments are evaluated first before the function itself is evaluated on the
+/// results, a failure to evaluate function argument prevents the function from
+/// being evaluated.
+///
+/// Special forms are different from regular scalar functions as they do not
+/// always have the above properties.
+///
+/// - CAST doesn't have (1): return type is not defined by input type as it is
+/// possible to cast VARCHAR to INTEGER, BOOLEAN, and many other types.
+/// - Conjuncts AND, OR don't have (2): these have logic to stop evaluating
+/// arguments if the outcome is already decided. For example, a > 10 AND b < 3
+/// applied to a = 0 and b = 0 is fully decided after evaluating a > 10. The
+/// result is FALSE. This is important not only from efficiency standpoint, but
+/// semantically as well. Not evaluating unnecessary arguments implicitly
+/// suppresses the errors that might have happened if evaluation proceeded. For
+/// example, a > 10 AND b / a > 1 would fail if both expressions were evaluated
+/// on a = 0.
+/// - Coalesce, if, switch also don't have (2): these also have logic to stop
+/// evaluating arguments if the outcome is already decided.
+/// - TRY doesn't have (2) either: it needs to capture and suppress errors
+/// received while evaluating the input.
 class CallTypedExpr : public ITypedExpr {
  public:
+  /// @param type Return type.
+  /// @param inputs List of input expressions. May be empty.
+  /// @param name Name of the function or special form.
   CallTypedExpr(
-      std::shared_ptr<const Type> type,
+      TypePtr type,
       std::vector<TypedExprPtr> inputs,
-      std::string funcName)
+      std::string name)
       : ITypedExpr{std::move(type), std::move(inputs)},
-        name_(std::move(funcName)) {}
+        name_(std::move(name)) {}
 
   virtual const std::string& name() const {
     return name_;
@@ -206,17 +240,21 @@ class CallTypedExpr : public ITypedExpr {
     if (!casted) {
       return false;
     }
-    if (casted->name() != this->name()) {
+    return operator==(*casted);
+  }
+
+  bool operator==(const CallTypedExpr& other) const {
+    if (other.name() != this->name()) {
       return false;
     }
-    if (*casted->type() != *this->type()) {
+    if (*other.type() != *this->type()) {
       return false;
     }
     return std::equal(
         this->inputs().begin(),
         this->inputs().end(),
-        casted->inputs().begin(),
-        casted->inputs().end(),
+        other.inputs().begin(),
+        other.inputs().end(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -282,12 +320,15 @@ class FieldAccessTypedExpr : public ITypedExpr {
   }
 
   std::string toString() const override {
+    std::stringstream ss;
+    ss << std::quoted(name(), '"', '"');
     if (inputs().empty()) {
-      return fmt::format("{}", std::quoted(name(), '"', '"'));
+      return fmt::format("{}", ss.str());
+      ;
     }
 
-    return fmt::format(
-        "{}[{}]", inputs()[0]->toString(), std::quoted(name(), '"', '"'));
+    return fmt::format("{}[{}]", inputs()[0]->toString(), ss.str());
+    ;
   }
 
   size_t localHash() const override {
@@ -301,17 +342,21 @@ class FieldAccessTypedExpr : public ITypedExpr {
     if (!casted) {
       return false;
     }
-    if (casted->name_ != this->name_) {
+    return operator==(*casted);
+  }
+
+  bool operator==(const FieldAccessTypedExpr& other) const {
+    if (other.name_ != this->name_) {
       return false;
     }
-    if (*casted->type() != *this->type()) {
+    if (*other.type() != *this->type()) {
       return false;
     }
     return std::equal(
         this->inputs().begin(),
         this->inputs().end(),
-        casted->inputs().begin(),
-        casted->inputs().end(),
+        other.inputs().begin(),
+        other.inputs().end(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -360,8 +405,7 @@ class DereferenceTypedExpr : public ITypedExpr {
   }
 
   std::string toString() const override {
-    return fmt::format(
-        "{}[{}]", inputs()[0]->toString(), std::quoted(name(), '"', '"'));
+    return fmt::format("{}[{}]", inputs()[0]->toString(), name());
   }
 
   size_t localHash() const override {
@@ -375,14 +419,18 @@ class DereferenceTypedExpr : public ITypedExpr {
     if (!casted) {
       return false;
     }
-    if (casted->index_ != this->index_) {
+    return operator==(*casted);
+  }
+
+  bool operator==(const DereferenceTypedExpr& other) const {
+    if (other.index_ != this->index_) {
       return false;
     }
     return std::equal(
         this->inputs().begin(),
         this->inputs().end(),
-        casted->inputs().begin(),
-        casted->inputs().end(),
+        other.inputs().begin(),
+        other.inputs().end(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -396,9 +444,7 @@ class DereferenceTypedExpr : public ITypedExpr {
 
 using DereferenceTypedExprPtr = std::shared_ptr<const DereferenceTypedExpr>;
 
-/*
- * Evaluates a list of expressions to produce a row.
- */
+/// Evaluates a list of expressions to produce a row.
 class ConcatTypedExpr : public ITypedExpr {
  public:
   ConcatTypedExpr(
@@ -437,14 +483,18 @@ class ConcatTypedExpr : public ITypedExpr {
     if (!casted) {
       return false;
     }
-    if (*casted->type() != *this->type()) {
+    return operator==(*casted);
+  }
+
+  bool operator==(const ConcatTypedExpr& other) const {
+    if (*other.type() != *this->type()) {
       return false;
     }
     return std::equal(
         this->inputs().begin(),
         this->inputs().end(),
-        casted->inputs().begin(),
-        casted->inputs().end(),
+        other.inputs().begin(),
+        other.inputs().end(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -453,10 +503,10 @@ class ConcatTypedExpr : public ITypedExpr {
   static TypedExprPtr create(const folly::dynamic& obj, void* context);
 
  private:
-  static std::shared_ptr<const Type> toType(
+  static TypePtr toType(
       const std::vector<std::string>& names,
       const std::vector<TypedExprPtr>& expressions) {
-    std::vector<std::shared_ptr<const Type>> children{};
+    std::vector<TypePtr> children{};
     std::vector<std::string> namesCopy{};
     for (size_t i = 0; i < names.size(); ++i) {
       namesCopy.push_back(names.at(i));
@@ -470,7 +520,7 @@ class LambdaTypedExpr : public ITypedExpr {
  public:
   LambdaTypedExpr(RowTypePtr signature, TypedExprPtr body)
       : ITypedExpr(std::make_shared<FunctionType>(
-            std::vector<std::shared_ptr<const Type>>(signature->children()),
+            std::vector<TypePtr>(signature->children()),
             body->type())),
         signature_(signature),
         body_(body) {}
@@ -527,13 +577,28 @@ class LambdaTypedExpr : public ITypedExpr {
 
 using LambdaTypedExprPtr = std::shared_ptr<const LambdaTypedExpr>;
 
+/// Converts input values to specified type.
 class CastTypedExpr : public ITypedExpr {
  public:
+  /// @param type Type to convert to. This is the return type of the CAST
+  /// expresion.
+  /// @param input Single input. The type of input is referred to as from-type
+  /// and expected to be different from to-type.
+  /// @param nullOnFailure Whether to suppress cast errors and return null.
   CastTypedExpr(
-      const std::shared_ptr<const Type>& type,
+      const TypePtr& type,
+      const TypedExprPtr& input,
+      bool nullOnFailure)
+      : ITypedExpr{type, {input}}, nullOnFailure_(nullOnFailure) {}
+
+  CastTypedExpr(
+      const TypePtr& type,
       const std::vector<TypedExprPtr>& inputs,
       bool nullOnFailure)
-      : ITypedExpr{type, inputs}, nullOnFailure_(nullOnFailure) {}
+      : ITypedExpr{type, inputs}, nullOnFailure_(nullOnFailure) {
+    VELOX_USER_CHECK_EQ(
+        1, inputs.size(), "Cast expression requires exactly one input");
+  }
 
   TypedExprPtr rewriteInputNames(
       const std::unordered_map<std::string, TypedExprPtr>& mapping)
@@ -580,9 +645,45 @@ class CastTypedExpr : public ITypedExpr {
   static TypedExprPtr create(const folly::dynamic& obj, void* context);
 
  private:
-  // This flag prevents throws and instead returns
-  // null on cast failure
+  // Suppress exception and return null on failure to cast.
   const bool nullOnFailure_;
 };
 
+using CastTypedExprPtr = std::shared_ptr<const CastTypedExpr>;
+
+/// A collection of convenience methods for working with expressions.
+class TypedExprs {
+ public:
+  /// Returns true if 'expr' is a field access expression.
+  static bool isFieldAccess(const TypedExprPtr& expr) {
+    return dynamic_cast<const FieldAccessTypedExpr*>(expr.get()) != nullptr;
+  }
+
+  /// Returns 'expr' as FieldAccessTypedExprPtr or null if not field access
+  /// expression.
+  static FieldAccessTypedExprPtr asFieldAccess(const TypedExprPtr& expr) {
+    return std::dynamic_pointer_cast<const FieldAccessTypedExpr>(expr);
+  }
+
+  /// Returns true if 'expr' is a constant expression.
+  static bool isConstant(const TypedExprPtr& expr) {
+    return dynamic_cast<const ConstantTypedExpr*>(expr.get()) != nullptr;
+  }
+
+  /// Returns 'expr' as ConstantTypedExprPtr or null if not a constant
+  /// expression.
+  static ConstantTypedExprPtr asConstant(const TypedExprPtr& expr) {
+    return std::dynamic_pointer_cast<const ConstantTypedExpr>(expr);
+  }
+
+  /// Returns true if 'expr' is a lambda expression.
+  static bool isLambda(const TypedExprPtr& expr) {
+    return dynamic_cast<const LambdaTypedExpr*>(expr.get()) != nullptr;
+  }
+
+  /// Returns 'expr' as LambdaTypedExprPtr or null if not a lambda expression.
+  static LambdaTypedExprPtr asLambda(const TypedExprPtr& expr) {
+    return std::dynamic_pointer_cast<const LambdaTypedExpr>(expr);
+  }
+};
 } // namespace facebook::velox::core
diff --git a/velox/core/ITypedExpr.h b/velox/core/ITypedExpr.h
index 8a8066ddb06c4..0e573507d5637 100644
--- a/velox/core/ITypedExpr.h
+++ b/velox/core/ITypedExpr.h
@@ -24,16 +24,15 @@ class ITypedExpr;
 
 using TypedExprPtr = std::shared_ptr<const ITypedExpr>;
 
-/* a strongly-typed expression, such as literal, function call, etc... */
+/// Strongly-typed expression, e.g. literal, function call, etc.
 class ITypedExpr : public ISerializable {
  public:
-  explicit ITypedExpr(std::shared_ptr<const Type> type)
-      : type_{std::move(type)}, inputs_{} {}
+  explicit ITypedExpr(TypePtr type) : type_{std::move(type)}, inputs_{} {}
 
-  ITypedExpr(std::shared_ptr<const Type> type, std::vector<TypedExprPtr> inputs)
+  ITypedExpr(TypePtr type, std::vector<TypedExprPtr> inputs)
       : type_{std::move(type)}, inputs_{std::move(inputs)} {}
 
-  const std::shared_ptr<const Type>& type() const {
+  const TypePtr& type() const {
     return type_;
   }
 
@@ -44,12 +43,12 @@ class ITypedExpr : public ISerializable {
   }
 
   /// Returns a copy of this expression with input fields replaced according
-  /// to specified 'mapping'. Fields specified in the 'mapping are replaced
+  /// to specified 'mapping'. Fields specified in the 'mapping' are replaced
   /// by the corresponding expression in 'mapping'.
   /// Fields not present in 'mapping' are left unmodified.
   ///
   /// Used to bind inputs to lambda functions.
-  virtual std::shared_ptr<const ITypedExpr> rewriteInputNames(
+  virtual TypedExprPtr rewriteInputNames(
       const std::unordered_map<std::string, TypedExprPtr>& mapping) const = 0;
 
   virtual std::string toString() const = 0;
@@ -64,9 +63,9 @@ class ITypedExpr : public ISerializable {
     return hash;
   }
 
-  // Returns true if other is recursively equal to 'this'. We do not
-  // overload == because this is overloaded in a subclass for a
-  // different purpose.
+  /// Returns true if other is recursively equal to 'this'. We do not
+  /// overload == because this is overloaded in a subclass for a
+  /// different purpose.
   bool equals(const ITypedExpr& other) const {
     if (type_ != other.type_ || inputs_.size() != other.inputs_.size()) {
       return false;
@@ -104,8 +103,8 @@ class ITypedExpr : public ISerializable {
     return false;
   }
 
-  std::shared_ptr<const Type> type_;
-  std::vector<std::shared_ptr<const ITypedExpr>> inputs_;
+  TypePtr type_;
+  std::vector<TypedExprPtr> inputs_;
 };
 
 } // namespace facebook::velox::core
diff --git a/velox/core/Metaprogramming.h b/velox/core/Metaprogramming.h
index d50a153932506..317837bfb98a2 100644
--- a/velox/core/Metaprogramming.h
+++ b/velox/core/Metaprogramming.h
@@ -124,10 +124,11 @@ template <typename C, class TResolver, typename TRet, typename... TArgs>
 struct has_method {
  private:
   template <typename T>
-  static constexpr auto check(T*) -> typename std::is_same<
-      decltype(std::declval<TResolver>().template resolve<T>(
-          std::declval<TArgs>()...)),
-      TRet>::type {
+  static constexpr auto check(T*) ->
+      typename std::is_same<
+          decltype(std::declval<TResolver>().template resolve<T>(
+              std::declval<TArgs>()...)),
+          TRet>::type {
     return {};
   }
 
diff --git a/velox/core/PlanFragment.cpp b/velox/core/PlanFragment.cpp
index 338860ab2c9de..4fa862cbcc7c1 100644
--- a/velox/core/PlanFragment.cpp
+++ b/velox/core/PlanFragment.cpp
@@ -28,4 +28,14 @@ bool PlanFragment::canSpill(const QueryConfig& queryConfig) const {
              }) != nullptr;
 }
 
+std::string executionStrategyToString(ExecutionStrategy strategy) {
+  switch (strategy) {
+    case ExecutionStrategy::kGrouped:
+      return "GROUPED";
+    case ExecutionStrategy::kUngrouped:
+      return "UNGROUPED";
+    default:
+      return fmt::format("UNKNOWN: {}", static_cast<int>(strategy));
+  }
+}
 } // namespace facebook::velox::core
diff --git a/velox/core/PlanFragment.h b/velox/core/PlanFragment.h
index a2990a7eda23c..365234495b3c8 100644
--- a/velox/core/PlanFragment.h
+++ b/velox/core/PlanFragment.h
@@ -35,6 +35,8 @@ enum class ExecutionStrategy {
   kGrouped,
 };
 
+std::string executionStrategyToString(ExecutionStrategy strategy);
+
 /// Contains some information on how to execute the fragment of a plan.
 /// Used to construct Task.
 struct PlanFragment {
@@ -81,3 +83,13 @@ struct PlanFragment {
 };
 
 } // namespace facebook::velox::core
+
+template <>
+struct fmt::formatter<facebook::velox::core::ExecutionStrategy>
+    : formatter<int> {
+  auto format(
+      const facebook::velox::core::ExecutionStrategy& s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/core/PlanNode.cpp b/velox/core/PlanNode.cpp
index 0903fe85bf670..f1e56ed7cfd62 100644
--- a/velox/core/PlanNode.cpp
+++ b/velox/core/PlanNode.cpp
@@ -13,13 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/core/PlanNode.h"
+#include <folly/container/F14Set.h>
+
 #include "velox/common/encode/Base64.h"
+#include "velox/core/PlanNode.h"
 #include "velox/vector/VectorSaver.h"
 
 namespace facebook::velox::core {
 
 namespace {
+
+void appendComma(int32_t i, std::stringstream& sql) {
+  if (i > 0) {
+    sql << ", ";
+  }
+}
+
 std::vector<PlanNodePtr> deserializeSources(
     const folly::dynamic& obj,
     void* context) {
@@ -76,8 +85,7 @@ RowTypePtr getAggregationOutputType(
   std::vector<TypePtr> types;
 
   for (auto& key : groupingKeys) {
-    auto field =
-        std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(key);
+    auto field = TypedExprs::asFieldAccess(key);
     VELOX_CHECK(field, "Grouping key must be a field reference");
     names.push_back(field->name());
     types.push_back(field->type());
@@ -90,6 +98,7 @@ RowTypePtr getAggregationOutputType(
 
   return std::make_shared<RowType>(std::move(names), std::move(types));
 }
+
 } // namespace
 
 AggregationNode::AggregationNode(
@@ -99,6 +108,8 @@ AggregationNode::AggregationNode(
     const std::vector<FieldAccessTypedExprPtr>& preGroupedKeys,
     const std::vector<std::string>& aggregateNames,
     const std::vector<Aggregate>& aggregates,
+    const std::vector<vector_size_t>& globalGroupingSets,
+    const std::optional<FieldAccessTypedExprPtr>& groupId,
     bool ignoreNullKeys,
     PlanNodePtr source)
     : PlanNode(id),
@@ -108,6 +119,8 @@ AggregationNode::AggregationNode(
       aggregateNames_(aggregateNames),
       aggregates_(aggregates),
       ignoreNullKeys_(ignoreNullKeys),
+      groupId_(groupId),
+      globalGroupingSets_(globalGroupingSets),
       sources_{source},
       outputType_(getAggregationOutputType(
           groupingKeys_,
@@ -134,16 +147,53 @@ AggregationNode::AggregationNode(
         "Pre-grouped key must be one of the grouping keys: {}.",
         key->name());
   }
+
+  if (groupId_.has_value()) {
+    VELOX_USER_CHECK_GT(
+        groupingKeyNames.count(groupId_.value()->name()),
+        0,
+        "GroupId key {} must be one of the grouping keys",
+        groupId_.value()->name());
+
+    VELOX_USER_CHECK(
+        !globalGroupingSets_.empty(),
+        "GroupId key {} must have global grouping sets",
+        groupId_.value()->name());
+  }
+
+  if (!globalGroupingSets_.empty()) {
+    VELOX_USER_CHECK(
+        groupId_.has_value(), "Global grouping sets require GroupId key");
+  }
 }
 
+AggregationNode::AggregationNode(
+    const PlanNodeId& id,
+    Step step,
+    const std::vector<FieldAccessTypedExprPtr>& groupingKeys,
+    const std::vector<FieldAccessTypedExprPtr>& preGroupedKeys,
+    const std::vector<std::string>& aggregateNames,
+    const std::vector<Aggregate>& aggregates,
+    bool ignoreNullKeys,
+    PlanNodePtr source)
+    : AggregationNode(
+          id,
+          step,
+          groupingKeys,
+          preGroupedKeys,
+          aggregateNames,
+          aggregates,
+          {},
+          std::nullopt,
+          ignoreNullKeys,
+          source) {}
+
 namespace {
 void addFields(
     std::stringstream& stream,
     const std::vector<FieldAccessTypedExprPtr>& keys) {
   for (auto i = 0; i < keys.size(); ++i) {
-    if (i > 0) {
-      stream << ", ";
-    }
+    appendComma(i, stream);
     stream << keys[i]->name();
   }
 }
@@ -151,15 +201,10 @@ void addFields(
 void addKeys(std::stringstream& stream, const std::vector<TypedExprPtr>& keys) {
   for (auto i = 0; i < keys.size(); ++i) {
     const auto& expr = keys[i];
-    if (i > 0) {
-      stream << ", ";
-    }
-    if (auto field =
-            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(expr)) {
+    appendComma(i, stream);
+    if (auto field = TypedExprs::asFieldAccess(expr)) {
       stream << field->name();
-    } else if (
-        auto constant =
-            std::dynamic_pointer_cast<const core::ConstantTypedExpr>(expr)) {
+    } else if (auto constant = TypedExprs::asConstant(expr)) {
       stream << constant->toString();
     } else {
       stream << expr->toString();
@@ -172,17 +217,33 @@ void addSortingKeys(
     const std::vector<SortOrder>& sortingOrders,
     std::stringstream& stream) {
   for (auto i = 0; i < sortingKeys.size(); ++i) {
-    if (i > 0) {
-      stream << ", ";
-    }
+    appendComma(i, stream);
     stream << sortingKeys[i]->name() << " " << sortingOrders[i].toString();
   }
 }
 } // namespace
 
+bool AggregationNode::canSpill(const QueryConfig& queryConfig) const {
+  // TODO: Add spilling for aggregations over distinct inputs.
+  // https://github.com/facebookincubator/velox/issues/7454
+  for (const auto& aggregate : aggregates_) {
+    if (aggregate.distinct) {
+      return false;
+    }
+  }
+  // TODO: add spilling for pre-grouped aggregation later:
+  // https://github.com/facebookincubator/velox/issues/3264
+  return (isFinal() || isSingle()) && preGroupedKeys().empty() &&
+      queryConfig.aggregationSpillEnabled();
+}
+
 void AggregationNode::addDetails(std::stringstream& stream) const {
   stream << stepName(step_) << " ";
 
+  if (isPreGrouped()) {
+    stream << "STREAMING ";
+  }
+
   if (!groupingKeys_.empty()) {
     stream << "[";
     addFields(stream, groupingKeys_);
@@ -190,9 +251,7 @@ void AggregationNode::addDetails(std::stringstream& stream) const {
   }
 
   for (auto i = 0; i < aggregateNames_.size(); ++i) {
-    if (i > 0) {
-      stream << ", ";
-    }
+    appendComma(i, stream);
     const auto& aggregate = aggregates_[i];
     stream << aggregateNames_[i] << " := " << aggregate.call->toString();
     if (aggregate.distinct) {
@@ -208,6 +267,15 @@ void AggregationNode::addDetails(std::stringstream& stream) const {
       addSortingKeys(aggregate.sortingKeys, aggregate.sortingOrders, stream);
     }
   }
+
+  if (!globalGroupingSets_.empty()) {
+    stream << " global group IDs: [ " << folly::join(", ", globalGroupingSets_)
+           << " ]";
+  }
+
+  if (groupId_.has_value()) {
+    stream << " Group Id key: " << groupId_.value()->name();
+  }
 }
 
 namespace {
@@ -253,6 +321,14 @@ folly::dynamic AggregationNode::serialize() const {
     obj["aggregates"].push_back(aggregate.serialize());
   }
 
+  obj["globalGroupingSets"] = folly::dynamic::array;
+  for (const auto& globalGroup : globalGroupingSets_) {
+    obj["globalGroupingSets"].push_back(globalGroup);
+  }
+
+  if (groupId_.has_value()) {
+    obj["groupId"] = ISerializable::serialize(groupId_.value());
+  }
   obj["ignoreNullKeys"] = ignoreNullKeys_;
   return obj;
 }
@@ -342,6 +418,17 @@ PlanNodePtr AggregationNode::create(const folly::dynamic& obj, void* context) {
     aggregates.push_back(Aggregate::deserialize(aggregate, context));
   }
 
+  std::vector<vector_size_t> globalGroupingSets;
+  for (const auto& globalSet : obj["globalGroupingSets"]) {
+    globalGroupingSets.push_back(globalSet.asInt());
+  }
+
+  std::optional<FieldAccessTypedExprPtr> groupId;
+  if (obj.count("groupId")) {
+    groupId = ISerializable::deserialize<FieldAccessTypedExpr>(
+        obj["groupId"], context);
+  }
+
   return std::make_shared<AggregationNode>(
       deserializePlanNodeId(obj),
       stepFromName(obj["step"].asString()),
@@ -349,10 +436,111 @@ PlanNodePtr AggregationNode::create(const folly::dynamic& obj, void* context) {
       preGroupedKeys,
       aggregateNames,
       aggregates,
+      globalGroupingSets,
+      groupId,
       obj["ignoreNullKeys"].asBool(),
       deserializeSingleSource(obj, context));
 }
 
+namespace {
+RowTypePtr getExpandOutputType(
+    const std::vector<std::vector<TypedExprPtr>>& projections,
+    std::vector<std::string> names) {
+  VELOX_USER_CHECK(!names.empty());
+  VELOX_USER_CHECK(!projections.empty());
+  VELOX_USER_CHECK_GT(names.size(), 0);
+  VELOX_USER_CHECK_GT(projections.size(), 0);
+
+  for (int32_t i = 0; i < projections.size(); i++) {
+    VELOX_USER_CHECK_EQ(names.size(), projections[i].size());
+  }
+
+  std::vector<TypePtr> types;
+  types.reserve(names.size());
+  for (const auto& projection : projections[0]) {
+    types.push_back(projection->type());
+  }
+
+  folly::F14FastSet<std::string> uniqueNames;
+  for (const auto& name : names) {
+    auto result = uniqueNames.insert(name);
+    VELOX_USER_CHECK(
+        result.second,
+        "Found duplicate column name in Expand plan node: {}.",
+        name);
+  }
+
+  return ROW(std::move(names), std::move(types));
+}
+} // namespace
+
+ExpandNode::ExpandNode(
+    PlanNodeId id,
+    std::vector<std::vector<TypedExprPtr>> projections,
+    std::vector<std::string> names,
+    PlanNodePtr source)
+    : PlanNode(std::move(id)),
+      sources_{source},
+      outputType_(getExpandOutputType(projections, std::move(names))),
+      projections_(std::move(projections)) {
+  const auto& projectionNames = outputType_->names();
+  const auto numColumns = projectionNames.size();
+  const auto numRows = projections_.size();
+
+  for (const auto& rowProjection : projections_) {
+    for (const auto& columnProjection : rowProjection) {
+      VELOX_USER_CHECK(
+          TypedExprs::isFieldAccess(columnProjection) ||
+              TypedExprs::isConstant(columnProjection),
+          "Unsupported projection expression in Expand plan node. Expected field reference or constant. Got: {} ",
+          columnProjection->toString());
+    }
+  }
+
+  for (int i = 0; i < numColumns; ++i) {
+    const auto& type = outputType_->childAt(i);
+    for (int j = 1; j < numRows; ++j) {
+      VELOX_USER_CHECK(
+          projections_[j][i]->type()->equivalent(*type),
+          "The projections type does not match across different rows in the same column. Got: {}, {}",
+          projections_[j][i]->type()->toString(),
+          type->toString());
+    }
+  }
+}
+
+void ExpandNode::addDetails(std::stringstream& stream) const {
+  for (auto i = 0; i < projections_.size(); ++i) {
+    appendComma(i, stream);
+    stream << "[";
+    addKeys(stream, projections_[i]);
+    stream << "]";
+  }
+}
+
+folly::dynamic ExpandNode::serialize() const {
+  auto obj = PlanNode::serialize();
+  obj["projections"] = ISerializable::serialize(projections_);
+  obj["names"] = ISerializable::serialize(outputType_->names());
+
+  return obj;
+}
+
+// static
+PlanNodePtr ExpandNode::create(const folly::dynamic& obj, void* context) {
+  auto source = deserializeSingleSource(obj, context);
+  auto names =
+      ISerializable::deserialize<std::vector<std::string>>(obj["names"]);
+  auto projections =
+      ISerializable::deserialize<std::vector<std::vector<ITypedExpr>>>(
+          obj["projections"], context);
+  return std::make_shared<ExpandNode>(
+      deserializePlanNodeId(obj),
+      std::move(projections),
+      std::move(names),
+      std::move(source));
+}
+
 namespace {
 RowTypePtr getGroupIdOutputType(
     const std::vector<GroupIdNode::GroupingKeyInfo>& groupingKeyInfos,
@@ -385,56 +573,8 @@ RowTypePtr getGroupIdOutputType(
   return ROW(std::move(names), std::move(types));
 }
 
-std::vector<std::vector<std::string>> getGroupingSets(
-    const std::vector<std::vector<FieldAccessTypedExprPtr>>& groupingSetFields,
-    const std::vector<GroupIdNode::GroupingKeyInfo>& groupingKeyInfos) {
-  std::unordered_map<std::string, std::string> inputToOutputGroupingKeyMap;
-  for (const auto& groupKeyInfo : groupingKeyInfos) {
-    inputToOutputGroupingKeyMap[groupKeyInfo.input->name()] =
-        groupKeyInfo.output;
-  }
-
-  // Prestissimo passes grouping keys with their input column name to Velox.
-  // But Velox expects the output column name for the grouping key.
-  std::vector<std::vector<std::string>> groupingSets;
-  groupingSets.reserve(groupingSetFields.size());
-  for (const auto& groupFields : groupingSetFields) {
-    std::vector<std::string> groupingKeys;
-    groupingKeys.reserve(groupFields.size());
-    for (const auto& groupingField : groupFields) {
-      groupingKeys.push_back(
-          inputToOutputGroupingKeyMap[groupingField->name()]);
-    }
-    groupingSets.push_back(groupingKeys);
-  }
-  return groupingSets;
-}
-
 } // namespace
 
-GroupIdNode::GroupIdNode(
-    PlanNodeId id,
-    std::vector<std::vector<FieldAccessTypedExprPtr>> groupingSets,
-    std::vector<GroupIdNode::GroupingKeyInfo> groupingKeyInfos,
-    std::vector<FieldAccessTypedExprPtr> aggregationInputs,
-    std::string groupIdName,
-    PlanNodePtr source)
-    : PlanNode(std::move(id)),
-      sources_{source},
-      outputType_(getGroupIdOutputType(
-          groupingKeyInfos,
-          aggregationInputs,
-          groupIdName)),
-      groupingSets_(getGroupingSets(groupingSets, groupingKeyInfos)),
-      groupingKeyInfos_(std::move(groupingKeyInfos)),
-      aggregationInputs_(std::move(aggregationInputs)),
-      groupIdName_(std::move(groupIdName)) {
-  VELOX_USER_CHECK_GE(
-      groupingSets_.size(),
-      2,
-      "GroupIdNode requires two or more grouping sets.");
-}
-
 GroupIdNode::GroupIdNode(
     PlanNodeId id,
     std::vector<std::vector<std::string>> groupingSets,
@@ -460,14 +600,10 @@ GroupIdNode::GroupIdNode(
 
 void GroupIdNode::addDetails(std::stringstream& stream) const {
   for (auto i = 0; i < groupingSets_.size(); ++i) {
-    if (i > 0) {
-      stream << ", ";
-    }
+    appendComma(i, stream);
     stream << "[";
     for (auto j = 0; j < groupingSets_[i].size(); j++) {
-      if (j > 0) {
-        stream << ", ";
-      }
+      appendComma(j, stream);
       stream << groupingSets_[i][j];
     }
     stream << "]";
@@ -580,9 +716,7 @@ void ProjectNode::addDetails(std::stringstream& stream) const {
   stream << "expressions: ";
   for (auto i = 0; i < projections_.size(); i++) {
     auto& projection = projections_[i];
-    if (i > 0) {
-      stream << ", ";
-    }
+    appendComma(i, stream);
     stream << "(" << names_[i] << ":" << projection->type()->toString() << ", "
            << projection->toString() << ")";
   }
@@ -959,10 +1093,51 @@ PlanNodePtr HashJoinNode::create(const folly::dynamic& obj, void* context) {
       outputType);
 }
 
+MergeJoinNode::MergeJoinNode(
+    const PlanNodeId& id,
+    JoinType joinType,
+    const std::vector<FieldAccessTypedExprPtr>& leftKeys,
+    const std::vector<FieldAccessTypedExprPtr>& rightKeys,
+    TypedExprPtr filter,
+    PlanNodePtr left,
+    PlanNodePtr right,
+    RowTypePtr outputType)
+    : AbstractJoinNode(
+          id,
+          joinType,
+          leftKeys,
+          rightKeys,
+          std::move(filter),
+          std::move(left),
+          std::move(right),
+          std::move(outputType)) {
+  VELOX_USER_CHECK(
+      isSupported(joinType_),
+      "The join type is not supported by merge join: ",
+      joinTypeName(joinType_));
+}
+
 folly::dynamic MergeJoinNode::serialize() const {
   return serializeBase();
 }
 
+// static
+bool MergeJoinNode::isSupported(core::JoinType joinType) {
+  switch (joinType) {
+    case core::JoinType::kInner:
+    case core::JoinType::kLeft:
+    case core::JoinType::kRight:
+    case core::JoinType::kLeftSemiFilter:
+    case core::JoinType::kRightSemiFilter:
+    case core::JoinType::kAnti:
+    case core::JoinType::kFull:
+      return true;
+
+    default:
+      return false;
+  }
+}
+
 // static
 PlanNodePtr MergeJoinNode::create(const folly::dynamic& obj, void* context) {
   auto sources = deserializeSources(obj, context);
@@ -1002,9 +1177,8 @@ NestedLoopJoinNode::NestedLoopJoinNode(
       sources_({std::move(left), std::move(right)}),
       outputType_(std::move(outputType)) {
   VELOX_USER_CHECK(
-      core::isInnerJoin(joinType_) || core::isLeftJoin(joinType_) ||
-          core::isRightJoin(joinType_) || core::isFullJoin(joinType_),
-      "{} unsupported, NestedLoopJoin only supports inner and outer join",
+      isSupported(joinType_),
+      "The join type is not supported by nested loop join: ",
       joinTypeName(joinType_));
 
   auto leftType = sources_[0]->outputType();
@@ -1036,6 +1210,20 @@ NestedLoopJoinNode::NestedLoopJoinNode(
           right,
           outputType) {}
 
+// static
+bool NestedLoopJoinNode::isSupported(core::JoinType joinType) {
+  switch (joinType) {
+    case core::JoinType::kInner:
+    case core::JoinType::kLeft:
+    case core::JoinType::kRight:
+    case core::JoinType::kFull:
+      return true;
+
+    default:
+      return false;
+  }
+}
+
 void NestedLoopJoinNode::addDetails(std::stringstream& stream) const {
   stream << joinTypeName(joinType_);
   if (joinCondition_) {
@@ -1139,6 +1327,9 @@ void addWindowFunction(
     std::stringstream& stream,
     const WindowNode::Function& windowFunction) {
   stream << windowFunction.functionCall->toString() << " ";
+  if (windowFunction.ignoreNulls) {
+    stream << "IGNORE NULLS ";
+  }
   auto frame = windowFunction.frame;
   if (frame.startType == WindowNode::BoundType::kUnboundedFollowing) {
     VELOX_USER_FAIL("Window frame start cannot be UNBOUNDED FOLLOWING");
@@ -1190,30 +1381,61 @@ WindowNode::WindowNode(
       sortingKeys_.size(),
       sortingOrders_.size(),
       "Number of sorting keys must be equal to the number of sorting orders");
+
+  std::unordered_set<std::string> keyNames;
+  for (const auto& key : partitionKeys_) {
+    VELOX_USER_CHECK(
+        keyNames.insert(key->name()).second,
+        "Partitioning keys must be unique. Found duplicate key: {}",
+        key->name());
+  }
+
+  for (const auto& key : sortingKeys_) {
+    VELOX_USER_CHECK(
+        keyNames.insert(key->name()).second,
+        "Sorting keys must be unique and not overlap with partitioning keys. Found duplicate key: {}",
+        key->name());
+  }
+
+  for (const auto& windowFunction : windowFunctions_) {
+    if (windowFunction.frame.type == WindowType::kRange) {
+      if (windowFunction.frame.startValue || windowFunction.frame.endValue) {
+        // This is RANGE frame with a k limit bound like
+        // RANGE BETWEEN 5 PRECEDING AND CURRENT ROW.
+        // Such frames require that the ORDER BY have a single sorting key
+        // for comparison.
+        VELOX_USER_CHECK_EQ(
+            sortingKeys_.size(),
+            1,
+            "Window frame of type RANGE PRECEDING or FOLLOWING requires single sorting key in ORDER BY.");
+      }
+    }
+  }
 }
 
 void WindowNode::addDetails(std::stringstream& stream) const {
-  stream << "partition by [";
+  if (inputsSorted_) {
+    stream << "STREAMING ";
+  }
+
   if (!partitionKeys_.empty()) {
+    stream << "partition by [";
     addFields(stream, partitionKeys_);
+    stream << "] ";
   }
-  stream << "] ";
-
-  stream << "order by [";
-  addSortingKeys(sortingKeys_, sortingOrders_, stream);
-  stream << "] ";
 
-  auto numInputCols = sources_[0]->outputType()->size();
-  auto numOutputCols = outputType_->size();
-  for (auto i = numInputCols; i < numOutputCols; i++) {
-    if (i >= numInputCols + 1) {
-      stream << ", ";
-    }
-    stream << outputType_->names()[i] << " := ";
-    addWindowFunction(stream, windowFunctions_[i - numInputCols]);
+  if (!sortingKeys_.empty()) {
+    stream << "order by [";
+    addSortingKeys(sortingKeys_, sortingOrders_, stream);
+    stream << "] ";
   }
 
-  stream << " inputsSorted [" << inputsSorted_ << "]";
+  const auto numInputs = inputType()->size();
+  for (auto i = 0; i < windowFunctions_.size(); i++) {
+    appendComma(i, stream);
+    stream << outputType_->names()[i + numInputs] << " := ";
+    addWindowFunction(stream, windowFunctions_[i]);
+  }
 }
 
 namespace {
@@ -1385,7 +1607,7 @@ MarkDistinctNode::MarkDistinctNode(
       sources_{std::move(source)},
       outputType_(
           getMarkDistinctOutputType(sources_[0]->outputType(), markerName_)) {
-  VELOX_USER_CHECK_GT(markerName_.size(), 0)
+  VELOX_USER_CHECK_GT(markerName_.size(), 0);
   VELOX_USER_CHECK_GT(distinctKeys_.size(), 0);
 }
 
@@ -1521,6 +1743,23 @@ TopNRowNumberNode::TopNRowNumberNode(
       sortingKeys_.size(),
       0,
       "Number of sorting keys must be greater than zero");
+
+  VELOX_USER_CHECK_GT(limit, 0, "Limit must be greater than zero");
+
+  std::unordered_set<std::string> keyNames;
+  for (const auto& key : partitionKeys_) {
+    VELOX_USER_CHECK(
+        keyNames.insert(key->name()).second,
+        "Partitioning keys must be unique. Found duplicate key: {}",
+        key->name());
+  }
+
+  for (const auto& key : sortingKeys_) {
+    VELOX_USER_CHECK(
+        keyNames.insert(key->name()).second,
+        "Sorting keys must be unique and not overlap with partitioning keys. Found duplicate key: {}",
+        key->name());
+  }
 }
 
 void TopNRowNumberNode::addDetails(std::stringstream& stream) const {
@@ -1598,7 +1837,9 @@ PlanNodePtr LocalMergeNode::create(const folly::dynamic& obj, void* context) {
       std::move(sources));
 }
 
-void TableWriteNode::addDetails(std::stringstream& /*unused*/) const {}
+void TableWriteNode::addDetails(std::stringstream& stream) const {
+  stream << insertTableHandle_->connectorInsertTableHandle()->toString();
+}
 
 folly::dynamic TableWriteNode::serialize() const {
   auto obj = PlanNode::serialize();
@@ -1637,7 +1878,7 @@ PlanNodePtr TableWriteNode::create(const folly::dynamic& obj, void* context) {
   auto outputType = deserializeRowType(obj["outputType"]);
   auto commitStrategy =
       connector::stringToCommitStrategy(obj["commitStrategy"].asString());
-  auto source = ISerializable::deserialize<PlanNode>(obj["sources"]);
+  auto source = ISerializable::deserialize<PlanNode>(obj["sources"], context);
   return std::make_shared<TableWriteNode>(
       id,
       columns,
@@ -1668,7 +1909,7 @@ folly::dynamic TableWriteMergeNode::serialize() const {
 // static
 PlanNodePtr TableWriteMergeNode::create(
     const folly::dynamic& obj,
-    void* /*unused*/) {
+    void* context) {
   auto id = obj["id"].asString();
   auto outputType = deserializeRowType(obj["outputType"]);
   std::shared_ptr<AggregationNode> aggregationNode;
@@ -1676,7 +1917,7 @@ PlanNodePtr TableWriteMergeNode::create(
     aggregationNode = std::const_pointer_cast<AggregationNode>(
         ISerializable::deserialize<AggregationNode>(obj["aggregationNode"]));
   }
-  auto source = ISerializable::deserialize<PlanNode>(obj["sources"]);
+  auto source = ISerializable::deserialize<PlanNode>(obj["sources"], context);
   return std::make_shared<TableWriteMergeNode>(
       id, outputType, aggregationNode, source);
 }
@@ -1851,6 +2092,36 @@ PlanNodePtr PartitionedOutputNode::create(
       deserializeSingleSource(obj, context));
 }
 
+TopNNode::TopNNode(
+    const PlanNodeId& id,
+    const std::vector<FieldAccessTypedExprPtr>& sortingKeys,
+    const std::vector<SortOrder>& sortingOrders,
+    int32_t count,
+    bool isPartial,
+    const PlanNodePtr& source)
+    : PlanNode(id),
+      sortingKeys_(sortingKeys),
+      sortingOrders_(sortingOrders),
+      count_(count),
+      isPartial_(isPartial),
+      sources_{source} {
+  VELOX_USER_CHECK(!sortingKeys.empty(), "TopN must specify sorting keys");
+  VELOX_USER_CHECK_EQ(
+      sortingKeys.size(),
+      sortingOrders.size(),
+      "Number of sorting keys and sorting orders in TopN must be the same");
+  VELOX_USER_CHECK_GT(
+      count, 0, "TopN must specify greater than zero number of rows to keep");
+  folly::F14FastSet<std::string> sortingKeyNames;
+  for (const auto& sortingKey : sortingKeys_) {
+    auto result = sortingKeyNames.insert(sortingKey->name());
+    VELOX_USER_CHECK(
+        result.second,
+        "TopN must specify unique sorting keys. Found duplicate key: {}",
+        *result.first);
+  }
+}
+
 void TopNNode::addDetails(std::stringstream& stream) const {
   if (isPartial_) {
     stream << "PARTIAL ";
@@ -1952,13 +2223,13 @@ void PlanNode::toString(
     bool detailed,
     bool recursive,
     size_t indentationSize,
-    std::function<void(
+    const std::function<void(
         const PlanNodeId& planNodeId,
         const std::string& indentation,
-        std::stringstream& stream)> addContext) const {
+        std::stringstream& stream)>& addContext) const {
   const std::string indentation(indentationSize, ' ');
 
-  stream << indentation << "-- " << name();
+  stream << indentation << "-- " << name() << "[" << id() << "]";
 
   if (detailed) {
     stream << "[";
@@ -1972,7 +2243,7 @@ void PlanNode::toString(
   if (addContext) {
     auto contextIndentation = indentation + "   ";
     stream << contextIndentation;
-    addContext(id_, contextIndentation, stream);
+    addContext(id(), contextIndentation, stream);
     stream << std::endl;
   }
 
@@ -2012,6 +2283,7 @@ void PlanNode::registerSerDe() {
   registry.Register("AssignUniqueIdNode", AssignUniqueIdNode::create);
   registry.Register("EnforceSingleRowNode", EnforceSingleRowNode::create);
   registry.Register("ExchangeNode", ExchangeNode::create);
+  registry.Register("ExpandNode", ExpandNode::create);
   registry.Register("FilterNode", FilterNode::create);
   registry.Register("GroupIdNode", GroupIdNode::create);
   registry.Register("HashJoinNode", HashJoinNode::create);
diff --git a/velox/core/PlanNode.h b/velox/core/PlanNode.h
index e561c015f0db2..f3ff68e802fb1 100644
--- a/velox/core/PlanNode.h
+++ b/velox/core/PlanNode.h
@@ -15,20 +15,19 @@
  */
 #pragma once
 
+#include <fmt/format.h>
+
 #include "velox/connectors/Connector.h"
 #include "velox/core/Expressions.h"
 #include "velox/core/QueryConfig.h"
 
-#include "velox/vector/arrow/Abi.h"
-#include "velox/vector/arrow/Bridge.h"
+struct ArrowArrayStream;
 
 namespace facebook::velox::core {
 
 typedef std::string PlanNodeId;
 
-/**
- * Generic representation of InsertTable
- */
+/// Generic representation of InsertTable
 struct InsertTableHandle {
  public:
   InsertTableHandle(
@@ -157,17 +156,17 @@ class PlanNode : public ISerializable {
   /// 'addContext' is not null.
   ///
   /// @param addContext Optional lambda to add context for a given plan node.
-  /// Receives plan node ID, indentation and std::stringstring where to append
+  /// Receives plan node ID, indentation and std::stringstream where to append
   /// the context. Use indentation for second and subsequent lines of a
-  /// mult-line context. Do not use indentation for single-line context. Do not
+  /// multi-line context. Do not use indentation for single-line context. Do not
   /// add trailing new-line character for the last or only line of context.
   std::string toString(
       bool detailed = false,
       bool recursive = false,
-      std::function<void(
+      const std::function<void(
           const PlanNodeId& planNodeId,
           const std::string& indentation,
-          std::stringstream& stream)> addContext = nullptr) const {
+          std::stringstream& stream)>& addContext = nullptr) const {
     std::stringstream stream;
     toString(stream, detailed, recursive, 0, addContext);
     return stream.str();
@@ -210,10 +209,10 @@ class PlanNode : public ISerializable {
       bool detailed,
       bool recursive,
       size_t indentationSize,
-      std::function<void(
+      const std::function<void(
           const PlanNodeId& planNodeId,
           const std::string& indentation,
-          std::stringstream& stream)> addContext) const;
+          std::stringstream& stream)>& addContext) const;
 
   const std::string id_;
 };
@@ -500,8 +499,6 @@ class AggregationNode : public PlanNode {
     /// Raw input types used to properly identify aggregate function. These
     /// might be different from the input types specified in 'call' when
     /// aggregation step is kIntermediate or kFinal.
-    ///
-    /// Note: not used yet.
     std::vector<TypePtr> rawInputTypes;
 
     /// Optional name of input column to use as a mask. Column type must be
@@ -534,6 +531,27 @@ class AggregationNode : public PlanNode {
       bool ignoreNullKeys,
       PlanNodePtr source);
 
+  /// @param globalGroupingSets Group IDs of the global grouping sets produced
+  /// by the preceding GroupId node
+  /// @param groupId Group ID key produced by the preceding GroupId node. Must
+  /// be set if globalGroupingSets is not empty. Must not be set otherwise. Must
+  /// be one of the groupingKeys.
+
+  /// GlobalGroupingSets and groupId trigger special handling when the input
+  /// data set is empty (no rows). In that case, aggregation generates a single
+  /// row with the default global aggregate value per global grouping set.
+  AggregationNode(
+      const PlanNodeId& id,
+      Step step,
+      const std::vector<FieldAccessTypedExprPtr>& groupingKeys,
+      const std::vector<FieldAccessTypedExprPtr>& preGroupedKeys,
+      const std::vector<std::string>& aggregateNames,
+      const std::vector<Aggregate>& aggregates,
+      const std::vector<vector_size_t>& globalGroupingSets,
+      const std::optional<FieldAccessTypedExprPtr>& groupId,
+      bool ignoreNullKeys,
+      PlanNodePtr source);
+
   const std::vector<PlanNodePtr>& sources() const override {
     return sources_;
   }
@@ -554,6 +572,19 @@ class AggregationNode : public PlanNode {
     return preGroupedKeys_;
   }
 
+  bool isPreGrouped() const {
+    return !preGroupedKeys_.empty() &&
+        std::equal(
+            preGroupedKeys_.begin(),
+            preGroupedKeys_.end(),
+            groupingKeys_.begin(),
+            groupingKeys_.end(),
+            [](const FieldAccessTypedExprPtr& x,
+               const FieldAccessTypedExprPtr& y) -> bool {
+              return (*x == *y);
+            });
+  }
+
   const std::vector<std::string>& aggregateNames() const {
     return aggregateNames_;
   }
@@ -566,18 +597,19 @@ class AggregationNode : public PlanNode {
     return ignoreNullKeys_;
   }
 
+  const std::vector<vector_size_t>& globalGroupingSets() const {
+    return globalGroupingSets_;
+  }
+
+  std::optional<FieldAccessTypedExprPtr> groupId() const {
+    return groupId_;
+  }
+
   std::string_view name() const override {
     return "Aggregation";
   }
 
-  bool canSpill(const QueryConfig& queryConfig) const override {
-    // NOTE: as for now, we don't allow spilling for distinct aggregation
-    // (https://github.com/facebookincubator/velox/issues/3263) and pre-grouped
-    // aggregation (https://github.com/facebookincubator/velox/issues/3264). We
-    // will add support later to re-enable.
-    return (isFinal() || isSingle()) && !(aggregates().empty()) &&
-        preGroupedKeys().empty() && queryConfig.aggregationSpillEnabled();
-  }
+  bool canSpill(const QueryConfig& queryConfig) const override;
 
   bool isFinal() const {
     return step_ == Step::kFinal;
@@ -600,6 +632,10 @@ class AggregationNode : public PlanNode {
   const std::vector<std::string> aggregateNames_;
   const std::vector<Aggregate> aggregates_;
   const bool ignoreNullKeys_;
+
+  std::optional<FieldAccessTypedExprPtr> groupId_;
+  std::vector<vector_size_t> globalGroupingSets_;
+
   const std::vector<PlanNodePtr> sources_;
   const RowTypePtr outputType_;
 };
@@ -699,6 +735,10 @@ class TableWriteNode : public PlanNode {
     return aggregationNode_;
   }
 
+  bool canSpill(const QueryConfig& queryConfig) const override {
+    return queryConfig.writerSpillEnabled();
+  }
+
   std::string_view name() const override {
     return "TableWrite";
   }
@@ -725,17 +765,6 @@ class TableWriteMergeNode : public PlanNode {
   /// 'outputType' specifies the type to store the metadata of table write
   /// output which contains the following columns: 'numWrittenRows', 'fragment'
   /// and 'tableCommitContext'.
-#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-  TableWriteMergeNode(
-      const PlanNodeId& id,
-      RowTypePtr outputType,
-      PlanNodePtr source)
-      : PlanNode(id),
-        aggregationNode_(nullptr),
-        sources_{std::move(source)},
-        outputType_(std::move(outputType)) {}
-#endif
-
   TableWriteMergeNode(
       const PlanNodeId& id,
       RowTypePtr outputType,
@@ -775,6 +804,56 @@ class TableWriteMergeNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+/// For each input row, generates N rows with M columns according to
+/// specified 'projections'. 'projections' is an N x M matrix of expressions: a
+/// vector of N rows each having M columns. Each expression is either a column
+/// reference or a constant. Both null and non-null constants are allowed.
+/// 'names' is a list of M new column names. The semantic of this operator
+/// matches Spark.
+class ExpandNode : public PlanNode {
+ public:
+  ExpandNode(
+      PlanNodeId id,
+      std::vector<std::vector<TypedExprPtr>> projections,
+      std::vector<std::string> names,
+      PlanNodePtr source);
+
+  const RowTypePtr& outputType() const override {
+    return outputType_;
+  }
+
+  const RowTypePtr& inputType() const {
+    return sources_[0]->outputType();
+  }
+
+  const std::vector<PlanNodePtr>& sources() const override {
+    return sources_;
+  }
+
+  const std::vector<std::vector<TypedExprPtr>>& projections() const {
+    return projections_;
+  }
+
+  const std::vector<std::string>& names() const {
+    return outputType_->names();
+  }
+
+  std::string_view name() const override {
+    return "Expand";
+  }
+
+  folly::dynamic serialize() const override;
+
+  static PlanNodePtr create(const folly::dynamic& obj, void* context);
+
+ private:
+  void addDetails(std::stringstream& stream) const override;
+
+  const std::vector<PlanNodePtr> sources_;
+  const RowTypePtr outputType_;
+  const std::vector<std::vector<TypedExprPtr>> projections_;
+};
+
 /// Plan node used to implement aggregations over grouping sets. Duplicates the
 /// aggregation input for each set of grouping keys. The output contains one
 /// column for each grouping key, followed by aggregation inputs, followed by a
@@ -792,25 +871,6 @@ class GroupIdNode : public PlanNode {
     folly::dynamic serialize() const;
   };
 
-  /// @param id Plan node ID.
-  /// @param groupingSets A list of grouping key sets. Grouping keys within the
-  /// set must be unique, but grouping keys across sets may repeat.
-  /// @param groupingKeyInfos The names and order of the grouping keys in the
-  /// output.
-  /// @param aggregationInputs Columns that contain inputs to the aggregate
-  /// functions.
-  /// @param groupIdName Name of the column that will contain the grouping set
-  /// ID (a zero based integer).
-  /// @param source Input plan node.
-  /// NOTE: THIS FUNCTION IS DEPRECATED. PLEASE DO NOT USE.
-  GroupIdNode(
-      PlanNodeId id,
-      std::vector<std::vector<FieldAccessTypedExprPtr>> groupingSets,
-      std::vector<GroupingKeyInfo> groupingKeyInfos,
-      std::vector<FieldAccessTypedExprPtr> aggregationInputs,
-      std::string groupIdName,
-      PlanNodePtr source);
-
   /// @param id Plan node ID.
   /// @param groupingSets A list of grouping key sets. Grouping keys within the
   /// set must be unique, but grouping keys across sets may repeat.
@@ -850,7 +910,7 @@ class GroupIdNode : public PlanNode {
     return aggregationInputs_;
   }
 
-  const std::string& groupIdName() {
+  const std::string& groupIdName() const {
     return groupIdName_;
   }
 
@@ -1296,16 +1356,16 @@ FOLLY_ALWAYS_INLINE std::ostream& operator<<(
 enum class JoinType {
   // For each row on the left, find all matching rows on the right and return
   // all combinations.
-  kInner,
+  kInner = 0,
   // For each row on the left, find all matching rows on the right and return
   // all combinations. In addition, return all rows from the left that have no
   // match on the right with right-side columns filled with nulls.
-  kLeft,
+  kLeft = 1,
   // Opposite of kLeft. For each row on the right, find all matching rows on the
   // left and return all combinations. In addition, return all rows from the
   // right that have no match on the left with left-side columns filled with
   // nulls.
-  kRight,
+  kRight = 2,
   // A "union" of kLeft and kRight. For each row on the left, find all matching
   // rows on the right and return all combinations. In addition, return all rows
   // from the left that have no
@@ -1313,11 +1373,11 @@ enum class JoinType {
   // all rows from the
   // right that have no match on the left with left-side columns filled with
   // nulls.
-  kFull,
+  kFull = 3,
   // Return a subset of rows from the left side which have a match on the right
   // side. For this join type, cardinality of the output is less than or equal
   // to the cardinality of the left side.
-  kLeftSemiFilter,
+  kLeftSemiFilter = 4,
   // Return each row from the left side with a boolean flag indicating whether
   // there exists a match on the right side. For this join type, cardinality of
   // the output equals the cardinality of the left side.
@@ -1326,11 +1386,11 @@ enum class JoinType {
   // 'nullAware' boolean specified separately.
   //
   // Null-aware join follows IN semantic. Regular join follows EXISTS semantic.
-  kLeftSemiProject,
+  kLeftSemiProject = 5,
   // Opposite of kLeftSemiFilter. Return a subset of rows from the right side
   // which have a match on the left side. For this join type, cardinality of the
   // output is less than or equal to the cardinality of the right side.
-  kRightSemiFilter,
+  kRightSemiFilter = 6,
   // Opposite of kLeftSemiProject. Return each row from the right side with a
   // boolean flag indicating whether there exists a match on the left side. For
   // this join type, cardinality of the output equals the cardinality of the
@@ -1340,7 +1400,7 @@ enum class JoinType {
   // 'nullAware' boolean specified separately.
   //
   // Null-aware join follows IN semantic. Regular join follows EXISTS semantic.
-  kRightSemiProject,
+  kRightSemiProject = 7,
   // Return each row from the left side which has no match on the right side.
   // The handling of the rows with nulls in the join key depends on the
   // 'nullAware' boolean specified separately.
@@ -1354,7 +1414,8 @@ enum class JoinType {
   // Regular anti join follows NOT EXISTS semantic:
   // (1) ignore right-side rows with nulls in the join keys;
   // (2) unconditionally return left side rows with nulls in the join keys.
-  kAnti,
+  kAnti = 8,
+  kNumJoinTypes = 9,
 };
 
 const char* joinTypeName(JoinType joinType);
@@ -1465,6 +1526,10 @@ class AbstractJoinNode : public PlanNode {
     return joinType_ == JoinType::kAnti;
   }
 
+  bool isPreservingProbeOrder() const {
+    return isInnerJoin() || isLeftJoin() || isAntiJoin();
+  }
+
   const std::vector<FieldAccessTypedExprPtr>& leftKeys() const {
     return leftKeys_;
   }
@@ -1526,7 +1591,7 @@ class HashJoinNode : public AbstractJoinNode {
     if (nullAware) {
       VELOX_USER_CHECK(
           isNullAwareSupported(joinType),
-          "Null-aware flag is supported only for semi and anti joins");
+          "Null-aware flag is supported only for semi project and anti joins");
       VELOX_USER_CHECK_EQ(
           1, leftKeys_.size(), "Null-aware joins allow only one join key");
 
@@ -1580,16 +1645,7 @@ class MergeJoinNode : public AbstractJoinNode {
       TypedExprPtr filter,
       PlanNodePtr left,
       PlanNodePtr right,
-      RowTypePtr outputType)
-      : AbstractJoinNode(
-            id,
-            joinType,
-            leftKeys,
-            rightKeys,
-            std::move(filter),
-            std::move(left),
-            std::move(right),
-            std::move(outputType)) {}
+      RowTypePtr outputType);
 
   std::string_view name() const override {
     return "MergeJoin";
@@ -1597,6 +1653,9 @@ class MergeJoinNode : public AbstractJoinNode {
 
   folly::dynamic serialize() const override;
 
+  /// If merge join supports this join type.
+  static bool isSupported(core::JoinType joinType);
+
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
 };
 
@@ -1604,9 +1663,10 @@ class MergeJoinNode : public AbstractJoinNode {
 /// exec::NestedLoopJoinProbe and exec::NestedLoopJoinBuild. A separate pipeline
 /// is produced for the build side when generating exec::Operators.
 ///
-/// Nested loop join supports both equal and non-equal joins. Expressions
+/// Nested loop join (NLJ) supports both equal and non-equal joins. Expressions
 /// specified in joinCondition are evaluated on every combination of left/right
-/// tuple, to emit result.
+/// tuple, to emit result. Results are emitted following the same input order of
+/// probe rows for inner and left joins, for each thread of execution.
 ///
 /// To create Cartesian product of the left/right's output, use the constructor
 /// without `joinType` and `joinCondition` parameter.
@@ -1648,6 +1708,9 @@ class NestedLoopJoinNode : public PlanNode {
 
   folly::dynamic serialize() const override;
 
+  /// If nested loop join supports this join type.
+  static bool isSupported(core::JoinType joinType);
+
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
 
  private:
@@ -1678,6 +1741,15 @@ class OrderByNode : public PlanNode {
         sortingKeys.size(),
         sortingOrders.size(),
         "Number of sorting keys and sorting orders in OrderBy must be the same");
+    // Reject duplicate sorting keys.
+    std::unordered_set<std::string> uniqueKeys;
+    for (const auto& sortKey : sortingKeys) {
+      VELOX_USER_CHECK_NOT_NULL(sortKey, "Sorting key cannot be null");
+      VELOX_USER_CHECK(
+          uniqueKeys.insert(sortKey->name()).second,
+          "Duplicate sorting keys are not allowed: {}",
+          sortKey->name());
+    }
   }
 
   const std::vector<FieldAccessTypedExprPtr>& sortingKeys() const {
@@ -1732,21 +1804,7 @@ class TopNNode : public PlanNode {
       const std::vector<SortOrder>& sortingOrders,
       int32_t count,
       bool isPartial,
-      const PlanNodePtr& source)
-      : PlanNode(id),
-        sortingKeys_(sortingKeys),
-        sortingOrders_(sortingOrders),
-        count_(count),
-        isPartial_(isPartial),
-        sources_{source} {
-    VELOX_USER_CHECK(!sortingKeys.empty(), "TopN must specify sorting keys");
-    VELOX_USER_CHECK_EQ(
-        sortingKeys.size(),
-        sortingOrders.size(),
-        "Number of sorting keys and sorting orders in TopN must be the same");
-    VELOX_USER_CHECK_GT(
-        count, 0, "TopN must specify greater than zero number of rows to keep");
-  }
+      const PlanNodePtr& source);
 
   const std::vector<FieldAccessTypedExprPtr>& sortingKeys() const {
     return sortingKeys_;
@@ -1797,8 +1855,8 @@ class LimitNode : public PlanNode {
   // nodes.
   LimitNode(
       const PlanNodeId& id,
-      int32_t offset,
-      int32_t count,
+      int64_t offset,
+      int64_t count,
       bool isPartial,
       const PlanNodePtr& source)
       : PlanNode(id),
@@ -1820,11 +1878,11 @@ class LimitNode : public PlanNode {
     return sources_;
   }
 
-  int32_t offset() const {
+  int64_t offset() const {
     return offset_;
   }
 
-  int32_t count() const {
+  int64_t count() const {
     return count_;
   }
 
@@ -1843,8 +1901,8 @@ class LimitNode : public PlanNode {
  private:
   void addDetails(std::stringstream& stream) const override;
 
-  const int32_t offset_;
-  const int32_t count_;
+  const int64_t offset_;
+  const int64_t count_;
   const bool isPartial_;
   const std::vector<PlanNodePtr> sources_;
 };
@@ -1982,7 +2040,7 @@ class AssignUniqueIdNode : public PlanNode {
 
   const std::shared_ptr<std::atomic_int64_t>& uniqueIdCounter() const {
     return uniqueIdCounter_;
-  };
+  }
 
   folly::dynamic serialize() const override;
 
@@ -2036,7 +2094,6 @@ class WindowNode : public PlanNode {
   /// Frame bounds can be CURRENT ROW, UNBOUNDED PRECEDING(FOLLOWING)
   /// and k PRECEDING(FOLLOWING). K could be a constant or column.
   ///
-  /// k PRECEDING(FOLLOWING) is only supported for ROW frames now.
   /// k has to be of integer or bigint type.
   struct Frame {
     WindowType type;
@@ -2073,26 +2130,6 @@ class WindowNode : public PlanNode {
       bool inputsSorted,
       PlanNodePtr source);
 
-#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-  WindowNode(
-      PlanNodeId id,
-      std::vector<FieldAccessTypedExprPtr> partitionKeys,
-      std::vector<FieldAccessTypedExprPtr> sortingKeys,
-      std::vector<SortOrder> sortingOrders,
-      std::vector<std::string> windowColumnNames,
-      std::vector<Function> windowFunctions,
-      PlanNodePtr source)
-      : WindowNode(
-            id,
-            partitionKeys,
-            sortingKeys,
-            sortingOrders,
-            windowColumnNames,
-            windowFunctions,
-            false,
-            source){};
-#endif
-
   const std::vector<PlanNodePtr>& sources() const override {
     return sources_;
   }
@@ -2103,6 +2140,18 @@ class WindowNode : public PlanNode {
     return outputType_;
   }
 
+  bool canSpill(const QueryConfig& queryConfig) const override {
+    // No partitioning keys means the whole input is one big partition. In this
+    // case, spilling is not helpful because we need to have a full partition in
+    // memory to produce results.
+    return !partitionKeys_.empty() && !inputsSorted_ &&
+        queryConfig.windowSpillEnabled();
+  }
+
+  const RowTypePtr& inputType() const {
+    return sources_[0]->outputType();
+  }
+
   const std::vector<FieldAccessTypedExprPtr>& partitionKeys() const {
     return partitionKeys_;
   }
@@ -2176,6 +2225,10 @@ class RowNumberNode : public PlanNode {
     return outputType_;
   }
 
+  bool canSpill(const QueryConfig& queryConfig) const override {
+    return !partitionKeys_.empty() && queryConfig.rowNumberSpillEnabled();
+  }
+
   const std::vector<FieldAccessTypedExprPtr>& partitionKeys() const {
     return partitionKeys_;
   }
@@ -2265,6 +2318,9 @@ class MarkDistinctNode : public PlanNode {
 class TopNRowNumberNode : public PlanNode {
  public:
   /// @param partitionKeys Partitioning keys. May be empty.
+  /// @param sortingKeys Sorting keys. May not be empty and may not intersect
+  /// with 'partitionKeys'.
+  /// @param sortingOrders Sorting orders, one per sorting key.
   /// @param rowNumberColumnName Optional name of the column containing row
   /// numbers. If not specified, the output doesn't include 'row number' column.
   /// This is used when computing partial results.
@@ -2288,6 +2344,14 @@ class TopNRowNumberNode : public PlanNode {
     return outputType_;
   }
 
+  bool canSpill(const QueryConfig& queryConfig) const override {
+    return !partitionKeys_.empty() && queryConfig.topNRowNumberSpillEnabled();
+  }
+
+  const RowTypePtr& inputType() const {
+    return sources_[0]->outputType();
+  }
+
   const std::vector<FieldAccessTypedExprPtr>& partitionKeys() const {
     return partitionKeys_;
   }
@@ -2332,3 +2396,21 @@ class TopNRowNumberNode : public PlanNode {
 };
 
 } // namespace facebook::velox::core
+
+template <>
+struct fmt::formatter<facebook::velox::core::PartitionedOutputNode::Kind>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::core::PartitionedOutputNode::Kind s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::core::PartitionedOutputNode::kindString(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::core::JoinType> : formatter<int> {
+  auto format(facebook::velox::core::JoinType s, format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/core/QueryConfig.cpp b/velox/core/QueryConfig.cpp
index 7fb09d3f65797..3d5b25ff94878 100644
--- a/velox/core/QueryConfig.cpp
+++ b/velox/core/QueryConfig.cpp
@@ -16,102 +16,46 @@
 
 #include <re2/re2.h>
 
+#include "velox/common/config/Config.h"
 #include "velox/core/QueryConfig.h"
+#include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::core {
 
-double toBytesPerCapacityUnit(CapacityUnit unit) {
-  switch (unit) {
-    case CapacityUnit::BYTE:
-      return 1;
-    case CapacityUnit::KILOBYTE:
-      return exp2(10);
-    case CapacityUnit::MEGABYTE:
-      return exp2(20);
-    case CapacityUnit::GIGABYTE:
-      return exp2(30);
-    case CapacityUnit::TERABYTE:
-      return exp2(40);
-    case CapacityUnit::PETABYTE:
-      return exp2(50);
-    default:
-      VELOX_USER_FAIL("Invalid capacity unit '{}'", (int)unit);
-  }
-}
-
-CapacityUnit valueOfCapacityUnit(const std::string& unitStr) {
-  if (unitStr == "B") {
-    return CapacityUnit::BYTE;
-  }
-  if (unitStr == "kB") {
-    return CapacityUnit::KILOBYTE;
-  }
-  if (unitStr == "MB") {
-    return CapacityUnit::MEGABYTE;
-  }
-  if (unitStr == "GB") {
-    return CapacityUnit::GIGABYTE;
-  }
-  if (unitStr == "TB") {
-    return CapacityUnit::TERABYTE;
-  }
-  if (unitStr == "PB") {
-    return CapacityUnit::PETABYTE;
-  }
-  VELOX_USER_FAIL("Invalid capacity unit '{}'", unitStr);
+QueryConfig::QueryConfig(
+    const std::unordered_map<std::string, std::string>& values)
+    : config_{std::make_unique<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>(values))} {
+  validateConfig();
 }
 
-// Convert capacity string with unit to the capacity number in the specified
-// units
-uint64_t toCapacity(const std::string& from, CapacityUnit to) {
-  static const RE2 kPattern(R"(^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]+)\s*$)");
-  double value;
-  std::string unit;
-  if (!RE2::FullMatch(from, kPattern, &value, &unit)) {
-    VELOX_USER_FAIL("Invalid capacity string '{}'", from);
-  }
-
-  return value *
-      (toBytesPerCapacityUnit(valueOfCapacityUnit(unit)) /
-       toBytesPerCapacityUnit(to));
+QueryConfig::QueryConfig(std::unordered_map<std::string, std::string>&& values)
+    : config_{std::make_unique<config::ConfigBase>(std::move(values))} {
+  validateConfig();
 }
 
-std::chrono::duration<double> toDuration(const std::string& str) {
-  static const RE2 kPattern(R"(^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]+)\s*)");
-
-  double value;
-  std::string unit;
-  if (!RE2::FullMatch(str, kPattern, &value, &unit)) {
-    VELOX_USER_FAIL("Invalid duration {}", str);
+void QueryConfig::validateConfig() {
+  // Validate if timezone name can be recognized.
+  if (config_->valueExists(QueryConfig::kSessionTimezone)) {
+    VELOX_USER_CHECK(
+        tz::getTimeZoneID(
+            config_->get<std::string>(QueryConfig::kSessionTimezone).value(),
+            false) != -1,
+        fmt::format(
+            "session '{}' set with invalid value '{}'",
+            QueryConfig::kSessionTimezone,
+            config_->get<std::string>(QueryConfig::kSessionTimezone).value()));
   }
-  if (unit == "ns") {
-    return std::chrono::duration<double, std::nano>(value);
-  } else if (unit == "us") {
-    return std::chrono::duration<double, std::micro>(value);
-  } else if (unit == "ms") {
-    return std::chrono::duration<double, std::milli>(value);
-  } else if (unit == "s") {
-    return std::chrono::duration<double>(value);
-  } else if (unit == "m") {
-    return std::chrono::duration<double, std::ratio<60>>(value);
-  } else if (unit == "h") {
-    return std::chrono::duration<double, std::ratio<60 * 60>>(value);
-  } else if (unit == "d") {
-    return std::chrono::duration<double, std::ratio<60 * 60 * 24>>(value);
-  }
-  VELOX_USER_FAIL("Invalid duration {}", str);
 }
 
-QueryConfig::QueryConfig(
-    const std::unordered_map<std::string, std::string>& values)
-    : config_{std::make_unique<MemConfig>(values)} {}
-
-QueryConfig::QueryConfig(std::unordered_map<std::string, std::string>&& values)
-    : config_{std::make_unique<MemConfig>(std::move(values))} {}
-
 void QueryConfig::testingOverrideConfigUnsafe(
     std::unordered_map<std::string, std::string>&& values) {
-  config_ = std::make_unique<MemConfig>(std::move(values));
+  config_ = std::make_unique<config::ConfigBase>(std::move(values));
+}
+
+std::unordered_map<std::string, std::string> QueryConfig::rawConfigsCopy()
+    const {
+  return config_->rawConfigsCopy();
 }
 
 } // namespace facebook::velox::core
diff --git a/velox/core/QueryConfig.h b/velox/core/QueryConfig.h
index c243d3cf736c0..304e1fd370bbc 100644
--- a/velox/core/QueryConfig.h
+++ b/velox/core/QueryConfig.h
@@ -15,29 +15,12 @@
  */
 #pragma once
 
-#include "velox/core/Config.h"
+#include "velox/common/config/Config.h"
+#include "velox/vector/TypeAliases.h"
 
 namespace facebook::velox::core {
-enum class CapacityUnit {
-  BYTE,
-  KILOBYTE,
-  MEGABYTE,
-  GIGABYTE,
-  TERABYTE,
-  PETABYTE
-};
-
-double toBytesPerCapacityUnit(CapacityUnit unit);
-
-CapacityUnit valueOfCapacityUnit(const std::string& unitStr);
-
-/// Convert capacity string with unit to the capacity number in the specified
-/// units
-uint64_t toCapacity(const std::string& from, CapacityUnit to);
-
-std::chrono::duration<double> toDuration(const std::string& str);
 
-/// A simple wrapper around velox::Config. Defines constants for query
+/// A simple wrapper around velox::ConfigBase. Defines constants for query
 /// config properties and accessor methods.
 /// Create per query context. Does not have a singleton instance.
 /// Does not allow altering properties on the fly. Only at creation time.
@@ -48,17 +31,31 @@ class QueryConfig {
 
   explicit QueryConfig(std::unordered_map<std::string, std::string>&& values);
 
+#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
   static constexpr const char* kCodegenEnabled = "codegen.enabled";
 
-  /// Maximum memory that a query can use on a single host.
-  static constexpr const char* kQueryMaxMemoryPerNode =
-      "query_max_memory_per_node";
-
   static constexpr const char* kCodegenConfigurationFilePath =
       "codegen.configuration_file_path";
 
   static constexpr const char* kCodegenLazyLoading = "codegen.lazy_loading";
 
+  bool codegenEnabled() const {
+    return get<bool>(kCodegenEnabled, false);
+  }
+
+  std::string codegenConfigurationFilePath() const {
+    return get<std::string>(kCodegenConfigurationFilePath, "");
+  }
+
+  bool codegenLazyLoading() const {
+    return get<bool>(kCodegenLazyLoading, true);
+  }
+#endif
+
+  /// Maximum memory that a query can use on a single host.
+  static constexpr const char* kQueryMaxMemoryPerNode =
+      "query_max_memory_per_node";
+
   /// User provided session timezone. Stores a string with the actual timezone
   /// name, e.g: "America/Los_Angeles".
   static constexpr const char* kSessionTimezone = "session_timezone";
@@ -94,30 +91,13 @@ class QueryConfig {
 
   /// Flags used to configure the CAST operator:
 
+  static constexpr const char* kLegacyCast = "legacy_cast";
+
   /// This flag makes the Row conversion to by applied in a way that the casting
   /// row field are matched by name instead of position.
   static constexpr const char* kCastMatchStructByName =
       "cast_match_struct_by_name";
 
-  /// If set, cast from float/double/decimal/string to integer truncates the
-  /// decimal part, otherwise rounds.
-  static constexpr const char* kCastToIntByTruncate = "cast_to_int_by_truncate";
-
-  /// If set, cast from string to date allows only ISO 8601 formatted strings:
-  /// [+-](YYYY-MM-DD). Otherwise, allows all patterns supported by Spark:
-  /// `[+-]yyyy*`
-  /// `[+-]yyyy*-[m]m`
-  /// `[+-]yyyy*-[m]m-[d]d`
-  /// `[+-]yyyy*-[m]m-[d]d *`
-  /// `[+-]yyyy*-[m]m-[d]dT*`
-  /// The asterisk `*` in `yyyy*` stands for any numbers.
-  /// For the last two patterns, the trailing `*` can represent none or any
-  /// sequence of characters, e.g:
-  ///   "1970-01-01 123"
-  ///   "1970-01-01 (BC)"
-  static constexpr const char* kCastStringToDateIsIso8601 =
-      "cast_string_to_date_is_iso_8601";
-
   /// Used for backpressure to block local exchange producers when the local
   /// exchange buffer reaches or exceeds this size.
   static constexpr const char* kMaxLocalExchangeBufferSize =
@@ -128,6 +108,11 @@ class QueryConfig {
   static constexpr const char* kMaxExchangeBufferSize =
       "exchange.max_buffer_size";
 
+  /// Maximum size in bytes to accumulate among all sources of the merge
+  /// exchange. Enforced approximately, not strictly.
+  static constexpr const char* kMaxMergeExchangeBufferSize =
+      "merge_exchange.max_buffer_size";
+
   static constexpr const char* kMaxPartialAggregationMemory =
       "max_partial_aggregation_memory";
 
@@ -140,9 +125,17 @@ class QueryConfig {
   static constexpr const char* kAbandonPartialAggregationMinPct =
       "abandon_partial_aggregation_min_pct";
 
+  static constexpr const char* kAbandonPartialTopNRowNumberMinRows =
+      "abandon_partial_topn_row_number_min_rows";
+
+  static constexpr const char* kAbandonPartialTopNRowNumberMinPct =
+      "abandon_partial_topn_row_number_min_pct";
+
   static constexpr const char* kMaxPartitionedOutputBufferSize =
       "max_page_partitioning_buffer_size";
 
+  static constexpr const char* kMaxOutputBufferSize = "max_output_buffer_size";
+
   /// Preferred size of batches in bytes to be returned by operators from
   /// Operator::getOutput. It is used when an estimate of average row size is
   /// known. Otherwise kPreferredOutputBatchRows is used.
@@ -162,6 +155,12 @@ class QueryConfig {
   /// output rows.
   static constexpr const char* kMaxOutputBatchRows = "max_output_batch_rows";
 
+  /// TableScan operator will exit getOutput() method after this many
+  /// milliseconds even if it has no data to return yet. Zero means 'no time
+  /// limit'.
+  static constexpr const char* kTableScanGetOutputTimeLimitMs =
+      "table_scan_getoutput_time_limit_ms";
+
   /// If false, the 'group by' code is forced to use generic hash mode
   /// hashtable.
   static constexpr const char* kHashAdaptivityEnabled =
@@ -185,22 +184,33 @@ class QueryConfig {
   /// OrderBy spilling flag, only applies if "spill_enabled" flag is set.
   static constexpr const char* kOrderBySpillEnabled = "order_by_spill_enabled";
 
-  /// The max memory that a final aggregation can use before spilling. If it 0,
-  /// then there is no limit.
-  static constexpr const char* kAggregationSpillMemoryThreshold =
-      "aggregation_spill_memory_threshold";
+  /// Window spilling flag, only applies if "spill_enabled" flag is set.
+  static constexpr const char* kWindowSpillEnabled = "window_spill_enabled";
+
+  /// If true, the memory arbitrator will reclaim memory from table writer by
+  /// flushing its buffered data to disk.
+  static constexpr const char* kWriterSpillEnabled = "writer_spill_enabled";
 
-  /// The max memory that a hash join can use before spilling. If it 0, then
-  /// there is no limit.
-  static constexpr const char* kJoinSpillMemoryThreshold =
-      "join_spill_memory_threshold";
+  /// RowNumber spilling flag, only applies if "spill_enabled" flag is set.
+  static constexpr const char* kRowNumberSpillEnabled =
+      "row_number_spill_enabled";
 
-  /// The max memory that an order by can use before spilling. If it 0, then
-  /// there is no limit.
-  static constexpr const char* kOrderBySpillMemoryThreshold =
-      "order_by_spill_memory_threshold";
+  /// TopNRowNumber spilling flag, only applies if "spill_enabled" flag is set.
+  static constexpr const char* kTopNRowNumberSpillEnabled =
+      "topn_row_number_spill_enabled";
 
-  static constexpr const char* kTestingSpillPct = "testing.spill_pct";
+  /// The max row numbers to fill and spill for each spill run. This is used to
+  /// cap the memory used for spilling. If it is zero, then there is no limit
+  /// and spilling might run out of memory.
+  /// Based on offline test results, the default value is set to 12 million rows
+  /// which uses ~128MB memory when to fill a spill run.
+  static constexpr const char* kMaxSpillRunRows = "max_spill_run_rows";
+
+  /// The max spill bytes limit set for each query. This is used to cap the
+  /// storage used for spilling. If it is zero, then there is no limit and
+  /// spilling might exhaust the storage or takes too long to run. The default
+  /// value is set to 100 GB.
+  static constexpr const char* kMaxSpillBytes = "max_spill_bytes";
 
   /// The max allowed spilling level with zero being the initial spilling level.
   /// This only applies for hash build spilling which might trigger recursive
@@ -214,15 +224,6 @@ class QueryConfig {
   /// The max allowed spill file size. If it is zero, then there is no limit.
   static constexpr const char* kMaxSpillFileSize = "max_spill_file_size";
 
-  /// The min spill run size limit used to select partitions for spilling. The
-  /// spiller tries to spill a previously spilled partitions if its data size
-  /// exceeds this limit, otherwise it spills the partition with most data.
-  /// If the limit is zero, then the spiller always spill a previously spilled
-  /// partition if it has any data. This is to avoid spill from a partition with
-  /// a small amount of data which might result in generating too many small
-  /// spilled files.
-  static constexpr const char* kMinSpillRunSize = "min_spill_run_size";
-
   static constexpr const char* kSpillCompressionKind =
       "spill_compression_codec";
 
@@ -233,47 +234,59 @@ class QueryConfig {
   static constexpr const char* kSpillWriteBufferSize =
       "spill_write_buffer_size";
 
+  /// Specifies the buffer size in bytes to read from one spilled file. If the
+  /// underlying filesystem supports async read, we do read-ahead with double
+  /// buffering, which doubles the buffer used to read from each spill file.
+  static constexpr const char* kSpillReadBufferSize = "spill_read_buffer_size";
+
+  /// Config used to create spill files. This config is provided to underlying
+  /// file system and the config is free form. The form should be defined by the
+  /// underlying file system.
+  static constexpr const char* kSpillFileCreateConfig =
+      "spill_file_create_config";
+
+  /// Default offset spill start partition bit.
   static constexpr const char* kSpillStartPartitionBit =
       "spiller_start_partition_bit";
 
+  /// Default number of spill partition bits.
+  static constexpr const char* kSpillNumPartitionBits =
+      "spiller_num_partition_bits";
+
+  /// !!! DEPRECATED: do not use.
   static constexpr const char* kJoinSpillPartitionBits =
       "join_spiller_partition_bits";
 
-  static constexpr const char* kAggregationSpillPartitionBits =
-      "aggregation_spiller_partition_bits";
-
-  /// If true and spilling has been triggered during the input processing, the
-  /// spiller will spill all the remaining in-memory state to disk before output
-  /// processing. This is to simplify the aggregation query OOM prevention in
-  /// output processing stage.
-  static constexpr const char* kAggregationSpillAll = "aggregation_spill_all";
-
   static constexpr const char* kMinSpillableReservationPct =
       "min_spillable_reservation_pct";
 
   static constexpr const char* kSpillableReservationGrowthPct =
       "spillable_reservation_growth_pct";
 
+  /// Minimum memory footprint size required to reclaim memory from a file
+  /// writer by flushing its buffered data to disk.
+  static constexpr const char* kWriterFlushThresholdBytes =
+      "writer_flush_threshold_bytes";
+
   /// If true, array_agg() aggregation function will ignore nulls in the input.
   static constexpr const char* kPrestoArrayAggIgnoreNulls =
       "presto.array_agg.ignore_nulls";
 
-  /// If false, size function returns null for null input.
-  static constexpr const char* kSparkLegacySizeOfNull =
-      "spark.legacy_size_of_null";
-
   // The default number of expected items for the bloomfilter.
   static constexpr const char* kSparkBloomFilterExpectedNumItems =
       "spark.bloom_filter.expected_num_items";
 
-  // The default number of bits to use for the bloom filter.
+  /// The default number of bits to use for the bloom filter.
   static constexpr const char* kSparkBloomFilterNumBits =
       "spark.bloom_filter.num_bits";
 
-  // The max number of bits to use for the bloom filter.
+  /// The max number of bits to use for the bloom filter.
   static constexpr const char* kSparkBloomFilterMaxNumBits =
       "spark.bloom_filter.max_num_bits";
 
+  /// The current spark partition id.
+  static constexpr const char* kSparkPartitionId = "spark.partition_id";
+
   /// The number of local parallel table writer operators per task.
   static constexpr const char* kTaskWriterCount = "task_writer_count";
 
@@ -308,9 +321,93 @@ class QueryConfig {
   static constexpr const char* kEnableExpressionEvaluationCache =
       "enable_expression_evaluation_cache";
 
+  // For a given shared subexpression, the maximum distinct sets of inputs we
+  // cache results for. Lambdas can call the same expression with different
+  // inputs many times, causing the results we cache to explode in size. Putting
+  // a limit contains the memory usage.
+  static constexpr const char* kMaxSharedSubexprResultsCached =
+      "max_shared_subexpr_results_cached";
+
+  /// Maximum number of splits to preload. Set to 0 to disable preloading.
+  static constexpr const char* kMaxSplitPreloadPerDriver =
+      "max_split_preload_per_driver";
+
+  /// If not zero, specifies the cpu time slice limit in ms that a driver thread
+  /// can continuously run without yielding. If it is zero, then there is no
+  /// limit.
+  static constexpr const char* kDriverCpuTimeSliceLimitMs =
+      "driver_cpu_time_slice_limit_ms";
+
+  /// Maximum number of bytes to use for the normalized key in prefix-sort. Use
+  /// 0 to disable prefix-sort.
+  static constexpr const char* kPrefixSortNormalizedKeyMaxBytes =
+      "prefixsort_normalized_key_max_bytes";
+
+  /// Minimum number of rows to use prefix-sort. The default value has been
+  /// derived using micro-benchmarking.
+  static constexpr const char* kPrefixSortMinRows = "prefixsort_min_rows";
+
+  /// Enable query tracing flag.
+  static constexpr const char* kQueryTraceEnabled = "query_trace_enabled";
+
+  /// Base dir of a query to store tracing data.
+  static constexpr const char* kQueryTraceDir = "query_trace_dir";
+
+  /// A comma-separated list of plan node ids whose input data will be traced.
+  /// Empty string if only want to trace the query metadata.
+  static constexpr const char* kQueryTraceNodeIds = "query_trace_node_ids";
+
+  /// Disable optimization in expression evaluation to peel common dictionary
+  /// layer from inputs.
+  static constexpr const char* kDebugDisableExpressionWithPeeling =
+      "debug_disable_expression_with_peeling";
+
+  /// Disable optimization in expression evaluation to re-use cached results for
+  /// common sub-expressions.
+  static constexpr const char* kDebugDisableCommonSubExpressions =
+      "debug_disable_common_sub_expressions";
+
+  /// Disable optimization in expression evaluation to re-use cached results
+  /// between subsequent input batches that are dictionary encoded and have the
+  /// same alphabet(underlying flat vector).
+  static constexpr const char* kDebugDisableExpressionWithMemoization =
+      "debug_disable_expression_with_memoization";
+
+  /// Disable optimization in expression evaluation to delay loading of lazy
+  /// inputs unless required.
+  static constexpr const char* kDebugDisableExpressionWithLazyInputs =
+      "debug_disable_expression_with_lazy_inputs";
+
+  /// Temporary flag to control whether selective Nimble reader should be used
+  /// in this query or not.  Will be removed after the selective Nimble reader
+  /// is fully rolled out.
+  static constexpr const char* kSelectiveNimbleReaderEnabled =
+      "selective_nimble_reader_enabled";
+
+  bool selectiveNimbleReaderEnabled() const {
+    return get<bool>(kSelectiveNimbleReaderEnabled, false);
+  }
+
+  bool debugDisableExpressionsWithPeeling() const {
+    return get<bool>(kDebugDisableExpressionWithPeeling, false);
+  }
+
+  bool debugDisableCommonSubExpressions() const {
+    return get<bool>(kDebugDisableCommonSubExpressions, false);
+  }
+
+  bool debugDisableExpressionsWithMemoization() const {
+    return get<bool>(kDebugDisableExpressionWithMemoization, false);
+  }
+
+  bool debugDisableExpressionsWithLazyInputs() const {
+    return get<bool>(kDebugDisableExpressionWithLazyInputs, false);
+  }
+
   uint64_t queryMaxMemoryPerNode() const {
-    return toCapacity(
-        get<std::string>(kQueryMaxMemoryPerNode, "0B"), CapacityUnit::BYTE);
+    return config::toCapacity(
+        get<std::string>(kQueryMaxMemoryPerNode, "0B"),
+        config::CapacityUnit::BYTE);
   }
 
   uint64_t maxPartialAggregationMemoryUsage() const {
@@ -331,30 +428,45 @@ class QueryConfig {
     return get<int32_t>(kAbandonPartialAggregationMinPct, 80);
   }
 
-  uint64_t aggregationSpillMemoryThreshold() const {
-    static constexpr uint64_t kDefault = 0;
-    return get<uint64_t>(kAggregationSpillMemoryThreshold, kDefault);
+  int32_t abandonPartialTopNRowNumberMinRows() const {
+    return get<int32_t>(kAbandonPartialTopNRowNumberMinRows, 100'000);
+  }
+
+  int32_t abandonPartialTopNRowNumberMinPct() const {
+    return get<int32_t>(kAbandonPartialTopNRowNumberMinPct, 80);
   }
 
-  uint64_t joinSpillMemoryThreshold() const {
-    static constexpr uint64_t kDefault = 0;
-    return get<uint64_t>(kJoinSpillMemoryThreshold, kDefault);
+  uint64_t maxSpillRunRows() const {
+    static constexpr uint64_t kDefault = 12UL << 20;
+    return get<uint64_t>(kMaxSpillRunRows, kDefault);
   }
 
-  uint64_t orderBySpillMemoryThreshold() const {
-    static constexpr uint64_t kDefault = 0;
-    return get<uint64_t>(kOrderBySpillMemoryThreshold, kDefault);
+  uint64_t maxSpillBytes() const {
+    static constexpr uint64_t kDefault = 100UL << 30;
+    return get<uint64_t>(kMaxSpillBytes, kDefault);
   }
 
-  // Returns the target size for a Task's buffered output. The
-  // producer Drivers are blocked when the buffered size exceeds
-  // this. The Drivers are resumed when the buffered size goes below
-  // PartitionedOutputBufferManager::kContinuePct % of this.
+  /// Returns the maximum number of bytes to buffer in PartitionedOutput
+  /// operator to avoid creating tiny SerializedPages.
+  ///
+  /// For PartitionedOutputNode::Kind::kPartitioned, PartitionedOutput operator
+  /// would buffer up to that number of bytes / number of destinations for each
+  /// destination before producing a SerializedPage.
   uint64_t maxPartitionedOutputBufferSize() const {
     static constexpr uint64_t kDefault = 32UL << 20;
     return get<uint64_t>(kMaxPartitionedOutputBufferSize, kDefault);
   }
 
+  /// Returns the maximum size in bytes for the task's buffered output.
+  ///
+  /// The producer Drivers are blocked when the buffered size exceeds
+  /// this. The Drivers are resumed when the buffered size goes below
+  /// OutputBufferManager::kContinuePct % of this.
+  uint64_t maxOutputBufferSize() const {
+    static constexpr uint64_t kDefault = 32UL << 20;
+    return get<uint64_t>(kMaxOutputBufferSize, kDefault);
+  }
+
   uint64_t maxLocalExchangeBufferSize() const {
     static constexpr uint64_t kDefault = 32UL << 20;
     return get<uint64_t>(kMaxLocalExchangeBufferSize, kDefault);
@@ -365,17 +477,31 @@ class QueryConfig {
     return get<uint64_t>(kMaxExchangeBufferSize, kDefault);
   }
 
+  uint64_t maxMergeExchangeBufferSize() const {
+    static constexpr uint64_t kDefault = 128UL << 20;
+    return get<uint64_t>(kMaxMergeExchangeBufferSize, kDefault);
+  }
+
   uint64_t preferredOutputBatchBytes() const {
     static constexpr uint64_t kDefault = 10UL << 20;
     return get<uint64_t>(kPreferredOutputBatchBytes, kDefault);
   }
 
-  uint32_t preferredOutputBatchRows() const {
-    return get<uint32_t>(kPreferredOutputBatchRows, 1024);
+  vector_size_t preferredOutputBatchRows() const {
+    const uint32_t batchRows = get<uint32_t>(kPreferredOutputBatchRows, 1024);
+    VELOX_USER_CHECK_LE(batchRows, std::numeric_limits<vector_size_t>::max());
+    return batchRows;
+  }
+
+  vector_size_t maxOutputBatchRows() const {
+    const uint32_t maxBatchRows = get<uint32_t>(kMaxOutputBatchRows, 10'000);
+    VELOX_USER_CHECK_LE(
+        maxBatchRows, std::numeric_limits<vector_size_t>::max());
+    return maxBatchRows;
   }
 
-  uint32_t maxOutputBatchRows() const {
-    return get<uint32_t>(kMaxOutputBatchRows, 10'000);
+  uint32_t tableScanGetOutputTimeLimitMs() const {
+    return get<uint64_t>(kTableScanGetOutputTimeLimitMs, 5'000);
   }
 
   bool hashAdaptivityEnabled() const {
@@ -396,28 +522,12 @@ class QueryConfig {
     return get<bool>(kAdaptiveFilterReorderingEnabled, true);
   }
 
-  bool isMatchStructByName() const {
-    return get<bool>(kCastMatchStructByName, false);
-  }
-
-  bool isCastToIntByTruncate() const {
-    return get<bool>(kCastToIntByTruncate, false);
+  bool isLegacyCast() const {
+    return get<bool>(kLegacyCast, false);
   }
 
-  bool isIso8601() const {
-    return get<bool>(kCastStringToDateIsIso8601, true);
-  }
-
-  bool codegenEnabled() const {
-    return get<bool>(kCodegenEnabled, false);
-  }
-
-  std::string codegenConfigurationFilePath() const {
-    return get<std::string>(kCodegenConfigurationFilePath, "");
-  }
-
-  bool codegenLazyLoading() const {
-    return get<bool>(kCodegenLazyLoading, true);
+  bool isMatchStructByName() const {
+    return get<bool>(kCastMatchStructByName, false);
   }
 
   bool adjustTimestampToTimezone() const {
@@ -455,14 +565,32 @@ class QueryConfig {
     return get<bool>(kOrderBySpillEnabled, true);
   }
 
-  // Returns a percentage of aggregation or join input batches that
-  // will be forced to spill for testing. 0 means no extra spilling.
-  int32_t testingSpillPct() const {
-    return get<int32_t>(kTestingSpillPct, 0);
+  /// Returns true if spilling is enabled for Window operator. Must also
+  /// check the spillEnabled()!
+  bool windowSpillEnabled() const {
+    return get<bool>(kWindowSpillEnabled, true);
+  }
+
+  /// Returns 'is writer spilling enabled' flag. Must also check the
+  /// spillEnabled()!
+  bool writerSpillEnabled() const {
+    return get<bool>(kWriterSpillEnabled, true);
+  }
+
+  /// Returns true if spilling is enabled for RowNumber operator. Must also
+  /// check the spillEnabled()!
+  bool rowNumberSpillEnabled() const {
+    return get<bool>(kRowNumberSpillEnabled, true);
+  }
+
+  /// Returns true if spilling is enabled for TopNRowNumber operator. Must also
+  /// check the spillEnabled()!
+  bool topNRowNumberSpillEnabled() const {
+    return get<bool>(kTopNRowNumberSpillEnabled, true);
   }
 
   int32_t maxSpillLevel() const {
-    return get<int32_t>(kMaxSpillLevel, 4);
+    return get<int32_t>(kMaxSpillLevel, 1);
   }
 
   /// Returns the start partition bit which is used with
@@ -470,36 +598,36 @@ class QueryConfig {
   /// calculate the spilling partition number for join spill or aggregation
   /// spill.
   uint8_t spillStartPartitionBit() const {
-    constexpr uint8_t kDefaultStartBit = 29;
+    constexpr uint8_t kDefaultStartBit = 48;
     return get<uint8_t>(kSpillStartPartitionBit, kDefaultStartBit);
   }
 
-  /// Returns the number of bits used to calculate the spilling partition
-  /// number for hash join. The number of spilling partitions will be power of
-  /// two.
+  /// Returns the number of bits used to calculate the spill partition number
+  /// for hash join. The number of spill partitions will be power of two.
   ///
   /// NOTE: as for now, we only support up to 8-way spill partitioning.
+  ///
+  /// DEPRECATED.
   uint8_t joinSpillPartitionBits() const {
-    constexpr uint8_t kDefaultBits = 2;
+    constexpr uint8_t kDefaultBits = 3;
     constexpr uint8_t kMaxBits = 3;
     return std::min(
         kMaxBits, get<uint8_t>(kJoinSpillPartitionBits, kDefaultBits));
   }
 
-  /// Returns the number of bits used to calculate the spilling partition
-  /// number for hash join. The number of spilling partitions will be power of
-  /// two.
-  ///
+  /// Returns the number of bits used to calculate the spill partition number
+  /// for hash join and RowNumber. The number of spill partitions will be power
+  /// of tow.
   /// NOTE: as for now, we only support up to 8-way spill partitioning.
-  uint8_t aggregationSpillPartitionBits() const {
-    constexpr uint8_t kDefaultBits = 0;
+  uint8_t spillNumPartitionBits() const {
+    constexpr uint8_t kDefaultBits = 3;
     constexpr uint8_t kMaxBits = 3;
     return std::min(
-        kMaxBits, get<uint8_t>(kAggregationSpillPartitionBits, kDefaultBits));
+        kMaxBits, get<uint8_t>(kSpillNumPartitionBits, kDefaultBits));
   }
 
-  bool aggregationSpillAll() const {
-    return get<bool>(kAggregationSpillAll, true);
+  uint64_t writerFlushThresholdBytes() const {
+    return get<uint64_t>(kWriterFlushThresholdBytes, 96L << 20);
   }
 
   uint64_t maxSpillFileSize() const {
@@ -507,11 +635,6 @@ class QueryConfig {
     return get<uint64_t>(kMaxSpillFileSize, kDefaultMaxFileSize);
   }
 
-  uint64_t minSpillRunSize() const {
-    constexpr uint64_t kDefaultMinSpillRunSize = 256 << 20; // 256MB.
-    return get<uint64_t>(kMinSpillRunSize, kDefaultMinSpillRunSize);
-  }
-
   std::string spillCompressionKind() const {
     return get<std::string>(kSpillCompressionKind, "none");
   }
@@ -521,6 +644,15 @@ class QueryConfig {
     return get<uint64_t>(kSpillWriteBufferSize, 1L << 20);
   }
 
+  uint64_t spillReadBufferSize() const {
+    // The default read buffer size set to 1MB.
+    return get<uint64_t>(kSpillReadBufferSize, 1L << 20);
+  }
+
+  std::string spillFileCreateConfig() const {
+    return get<std::string>(kSpillFileCreateConfig, "");
+  }
+
   /// Returns the minimal available spillable memory reservation in percentage
   /// of the current memory usage. Suppose the current memory usage size of M,
   /// available memory reservation size of N and min reservation percentage of
@@ -542,9 +674,19 @@ class QueryConfig {
     return get<int32_t>(kSpillableReservationGrowthPct, kDefaultPct);
   }
 
-  bool sparkLegacySizeOfNull() const {
-    constexpr bool kDefault{true};
-    return get<bool>(kSparkLegacySizeOfNull, kDefault);
+  /// Returns true if query tracing is enabled.
+  bool queryTraceEnabled() const {
+    return get<bool>(kQueryTraceEnabled, false);
+  }
+
+  std::string queryTraceDir() const {
+    // The default query trace dir, empty by default.
+    return get<std::string>(kQueryTraceDir, "");
+  }
+
+  std::string queryTraceNodeIds() const {
+    // The default query trace nodes, empty by default.
+    return get<std::string>(kQueryTraceNodeIds, "");
   }
 
   bool prestoArrayAggIgnoreNulls() const {
@@ -574,6 +716,14 @@ class QueryConfig {
     return value;
   }
 
+  int32_t sparkPartitionId() const {
+    auto id = get<int32_t>(kSparkPartitionId);
+    VELOX_CHECK(id.has_value(), "Spark partition id is not set.");
+    auto value = id.value();
+    VELOX_CHECK_GE(value, 0, "Invalid Spark partition id.");
+    return value;
+  }
+
   bool exprTrackCpuUsage() const {
     return get<bool>(kExprTrackCpuUsage, false);
   }
@@ -592,7 +742,7 @@ class QueryConfig {
   }
 
   bool hashProbeFinishEarlyOnEmptyBuild() const {
-    return get<bool>(kHashProbeFinishEarlyOnEmptyBuild, true);
+    return get<bool>(kHashProbeFinishEarlyOnEmptyBuild, false);
   }
 
   uint32_t minTableRowsForParallelJoinBuild() const {
@@ -607,6 +757,38 @@ class QueryConfig {
     return get<bool>(kEnableExpressionEvaluationCache, true);
   }
 
+  uint32_t maxSharedSubexprResultsCached() const {
+    // 10 was chosen as a default as there are cases where a shared
+    // subexpression can be called in 2 different places and a particular
+    // argument may be peeled in one and not peeled in another. 10 is large
+    // enough to handle this happening for a few arguments in different
+    // combinations.
+    //
+    // For example, when the UDF at the root of a shared subexpression does not
+    // have default null behavior and takes an input that is dictionary encoded
+    // with nulls set in the DictionaryVector. That dictionary
+    // encoding may be peeled depending on whether or not there is a UDF above
+    // it in the expression tree that has default null behavior and takes the
+    // same input as an argument.
+    return get<uint32_t>(kMaxSharedSubexprResultsCached, 10);
+  }
+
+  int32_t maxSplitPreloadPerDriver() const {
+    return get<int32_t>(kMaxSplitPreloadPerDriver, 2);
+  }
+
+  uint32_t driverCpuTimeSliceLimitMs() const {
+    return get<uint32_t>(kDriverCpuTimeSliceLimitMs, 0);
+  }
+
+  int64_t prefixSortNormalizedKeyMaxBytes() const {
+    return get<int64_t>(kPrefixSortNormalizedKeyMaxBytes, 128);
+  }
+
+  int32_t prefixSortMinRows() const {
+    return get<int32_t>(kPrefixSortMinRows, 130);
+  }
+
   template <typename T>
   T get(const std::string& key, const T& defaultValue) const {
     return config_->get<T>(key, defaultValue);
@@ -621,7 +803,11 @@ class QueryConfig {
   void testingOverrideConfigUnsafe(
       std::unordered_map<std::string, std::string>&& values);
 
+  std::unordered_map<std::string, std::string> rawConfigsCopy() const;
+
  private:
-  std::unique_ptr<velox::Config> config_;
+  void validateConfig();
+
+  std::unique_ptr<velox::config::ConfigBase> config_;
 };
 } // namespace facebook::velox::core
diff --git a/velox/core/QueryCtx.cpp b/velox/core/QueryCtx.cpp
index f3ac8bfc57ff5..e0392252ee74f 100644
--- a/velox/core/QueryCtx.cpp
+++ b/velox/core/QueryCtx.cpp
@@ -13,59 +13,51 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/core/QueryCtx.h"
+#include "velox/common/base/SpillConfig.h"
+#include "velox/common/config/Config.h"
 
 namespace facebook::velox::core {
 
-QueryCtx::QueryCtx(
+// static
+std::shared_ptr<QueryCtx> QueryCtx::create(
     folly::Executor* executor,
-    std::unordered_map<std::string, std::string> queryConfigValues,
-    std::unordered_map<std::string, std::shared_ptr<Config>> connectorConfigs,
+    QueryConfig&& queryConfig,
+    std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
+        connectorConfigs,
     cache::AsyncDataCache* cache,
     std::shared_ptr<memory::MemoryPool> pool,
-    std::shared_ptr<folly::Executor> spillExecutor,
-    const std::string& queryId)
-    : queryId_(queryId),
-      connectorConfigs_(connectorConfigs),
-      cache_(cache),
-      pool_(std::move(pool)),
-      executor_(executor),
-      queryConfig_{std::move(queryConfigValues)},
-      spillExecutor_(std::move(spillExecutor)) {
-  initPool(queryId);
+    folly::Executor* spillExecutor,
+    const std::string& queryId) {
+  std::shared_ptr<QueryCtx> queryCtx(new QueryCtx(
+      executor,
+      std::move(queryConfig),
+      std::move(connectorConfigs),
+      cache,
+      std::move(pool),
+      spillExecutor,
+      queryId));
+  queryCtx->maybeSetReclaimer();
+  return queryCtx;
 }
 
 QueryCtx::QueryCtx(
     folly::Executor* executor,
     QueryConfig&& queryConfig,
-    std::unordered_map<std::string, std::shared_ptr<Config>> connectorConfigs,
+    std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
+        connectorSessionProperties,
     cache::AsyncDataCache* cache,
     std::shared_ptr<memory::MemoryPool> pool,
-    std::shared_ptr<folly::Executor> spillExecutor,
+    folly::Executor* spillExecutor,
     const std::string& queryId)
     : queryId_(queryId),
-      connectorConfigs_(connectorConfigs),
-      cache_(cache),
-      pool_(std::move(pool)),
       executor_(executor),
-      queryConfig_{std::move(queryConfig)},
-      spillExecutor_(std::move(spillExecutor)) {
-  initPool(queryId);
-}
-
-QueryCtx::QueryCtx(
-    folly::Executor::KeepAlive<> executorKeepalive,
-    std::unordered_map<std::string, std::string> queryConfigValues,
-    std::unordered_map<std::string, std::shared_ptr<Config>> connectorConfigs,
-    cache::AsyncDataCache* cache,
-    std::shared_ptr<memory::MemoryPool> pool,
-    const std::string& queryId)
-    : queryId_(queryId),
-      connectorConfigs_(connectorConfigs),
+      spillExecutor_(spillExecutor),
       cache_(cache),
+      connectorSessionProperties_(connectorSessionProperties),
       pool_(std::move(pool)),
-      executorKeepalive_(std::move(executorKeepalive)),
-      queryConfig_{std::move(queryConfigValues)} {
+      queryConfig_{std::move(queryConfig)} {
   initPool(queryId);
 }
 
@@ -76,4 +68,78 @@ QueryCtx::QueryCtx(
   return fmt::format("query.{}.{}", queryId.c_str(), seqNum++);
 }
 
+void QueryCtx::maybeSetReclaimer() {
+  VELOX_CHECK_NOT_NULL(pool_);
+  VELOX_CHECK(!underArbitration_);
+  if (pool_->reclaimer() != nullptr) {
+    return;
+  }
+  pool_->setReclaimer(QueryCtx::MemoryReclaimer::create(this, pool_.get()));
+}
+
+void QueryCtx::updateSpilledBytesAndCheckLimit(uint64_t bytes) {
+  const auto numSpilledBytes = numSpilledBytes_.fetch_add(bytes) + bytes;
+  if (queryConfig_.maxSpillBytes() > 0 &&
+      numSpilledBytes > queryConfig_.maxSpillBytes()) {
+    VELOX_SPILL_LIMIT_EXCEEDED(fmt::format(
+        "Query exceeded per-query local spill limit of {}",
+        succinctBytes(queryConfig_.maxSpillBytes())));
+  }
+}
+
+std::unique_ptr<memory::MemoryReclaimer> QueryCtx::MemoryReclaimer::create(
+    QueryCtx* queryCtx,
+    memory::MemoryPool* pool) {
+  return std::unique_ptr<memory::MemoryReclaimer>(
+      new QueryCtx::MemoryReclaimer(queryCtx->shared_from_this(), pool));
+}
+
+uint64_t QueryCtx::MemoryReclaimer::reclaim(
+    memory::MemoryPool* pool,
+    uint64_t targetBytes,
+    uint64_t maxWaitMs,
+    memory::MemoryReclaimer::Stats& stats) {
+  auto queryCtx = ensureQueryCtx();
+  if (queryCtx == nullptr) {
+    return 0;
+  }
+  VELOX_CHECK_EQ(pool->name(), pool_->name());
+
+  const auto leaveGuard =
+      folly::makeGuard([&]() { queryCtx->finishArbitration(); });
+  queryCtx->startArbitration();
+  return memory::MemoryReclaimer::reclaim(pool, targetBytes, maxWaitMs, stats);
+}
+
+bool QueryCtx::checkUnderArbitration(ContinueFuture* future) {
+  VELOX_CHECK_NOT_NULL(future);
+  std::lock_guard<std::mutex> l(mutex_);
+  if (!underArbitration_) {
+    VELOX_CHECK(arbitrationPromises_.empty());
+    return false;
+  }
+  arbitrationPromises_.emplace_back("QueryCtx::waitArbitration");
+  *future = arbitrationPromises_.back().getSemiFuture();
+  return true;
+}
+
+void QueryCtx::startArbitration() {
+  std::lock_guard<std::mutex> l(mutex_);
+  VELOX_CHECK(!underArbitration_);
+  VELOX_CHECK(arbitrationPromises_.empty());
+  underArbitration_ = true;
+}
+
+void QueryCtx::finishArbitration() {
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(underArbitration_);
+    underArbitration_ = false;
+    promises.swap(arbitrationPromises_);
+  }
+  for (auto& promise : promises) {
+    promise.setValue();
+  }
+}
 } // namespace facebook::velox::core
diff --git a/velox/core/QueryCtx.h b/velox/core/QueryCtx.h
index 653b2769e7ec1..89ff229e3a488 100644
--- a/velox/core/QueryCtx.h
+++ b/velox/core/QueryCtx.h
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #pragma once
 
 #include <folly/Executor.h>
@@ -23,10 +24,18 @@
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/VectorPool.h"
 
+namespace facebook::velox {
+class Config;
+};
+
 namespace facebook::velox::core {
 
-class QueryCtx {
+class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
  public:
+  ~QueryCtx() {
+    VELOX_CHECK(!underArbitration_);
+  }
+
   /// QueryCtx is used in different places. When used with `Task::start()`, it's
   /// required that the caller supplies the executor and ensure its lifetime
   /// outlives the tasks that use it. In contrast, when used in expression
@@ -34,39 +43,14 @@ class QueryCtx {
   /// mode, executor is not needed. Hence, we don't require executor to always
   /// be passed in here, but instead, ensure that executor exists when actually
   /// being used.
-  // TODO(jtan6): Deprecate this constructor after external dependencies are
-  //   migrated
-  QueryCtx(
-      folly::Executor* executor,
-      std::unordered_map<std::string, std::string> queryConfigValues,
-      std::unordered_map<std::string, std::shared_ptr<Config>>
-          connectorConfigs = {},
-      cache::AsyncDataCache* cache = cache::AsyncDataCache::getInstance(),
-      std::shared_ptr<memory::MemoryPool> pool = nullptr,
-      std::shared_ptr<folly::Executor> spillExecutor = nullptr,
-      const std::string& queryId = "");
-
-  QueryCtx(
+  static std::shared_ptr<QueryCtx> create(
       folly::Executor* executor = nullptr,
       QueryConfig&& queryConfig = QueryConfig{{}},
-      std::unordered_map<std::string, std::shared_ptr<Config>>
-          connectorConfigs = {},
-      cache::AsyncDataCache* cache = cache::AsyncDataCache::getInstance(),
-      std::shared_ptr<memory::MemoryPool> pool = nullptr,
-      std::shared_ptr<folly::Executor> spillExecutor = nullptr,
-      const std::string& queryId = "");
-
-  /// Constructor to block the destruction of executor while this
-  /// object is alive.
-  ///
-  /// This constructor does not keep the ownership of executor.
-  explicit QueryCtx(
-      folly::Executor::KeepAlive<> executorKeepalive,
-      std::unordered_map<std::string, std::string> queryConfigValues = {},
-      std::unordered_map<std::string, std::shared_ptr<Config>>
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
           connectorConfigs = {},
       cache::AsyncDataCache* cache = cache::AsyncDataCache::getInstance(),
       std::shared_ptr<memory::MemoryPool> pool = nullptr,
+      folly::Executor* spillExecutor = nullptr,
       const std::string& queryId = "");
 
   static std::string generatePoolName(const std::string& queryId);
@@ -80,26 +64,31 @@ class QueryCtx {
   }
 
   folly::Executor* executor() const {
-    if (executor_ != nullptr) {
-      return executor_;
-    }
-    auto executor = executorKeepalive_.get();
-    VELOX_CHECK(executor, "Executor was not supplied.");
-    return executor;
+    return executor_;
+  }
+
+  bool isExecutorSupplied() const {
+    return executor_ != nullptr;
   }
 
   const QueryConfig& queryConfig() const {
     return queryConfig_;
   }
 
-  Config* getConnectorConfig(const std::string& connectorId) const {
-    auto it = connectorConfigs_.find(connectorId);
-    if (it == connectorConfigs_.end()) {
+  config::ConfigBase* connectorSessionProperties(
+      const std::string& connectorId) const {
+    auto it = connectorSessionProperties_.find(connectorId);
+    if (it == connectorSessionProperties_.end()) {
       return getEmptyConfig();
     }
     return it->second.get();
   }
 
+  const std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>&
+  connectorSessionProperties() const {
+    return connectorSessionProperties_;
+  }
+
   /// Overrides the previous configuration. Note that this function is NOT
   /// thread-safe and should probably only be used in tests.
   void testingOverrideConfigUnsafe(
@@ -109,48 +98,129 @@ class QueryCtx {
 
   // Overrides the previous connector-specific configuration. Note that this
   // function is NOT thread-safe and should probably only be used in tests.
-  void setConnectorConfigOverridesUnsafe(
+  void setConnectorSessionOverridesUnsafe(
       const std::string& connectorId,
       std::unordered_map<std::string, std::string>&& configOverrides) {
-    connectorConfigs_[connectorId] =
-        std::make_shared<MemConfig>(std::move(configOverrides));
+    connectorSessionProperties_[connectorId] =
+        std::make_shared<config::ConfigBase>(std::move(configOverrides));
   }
 
   folly::Executor* spillExecutor() const {
-    return spillExecutor_.get();
+    return spillExecutor_;
   }
 
   const std::string& queryId() const {
     return queryId_;
   }
 
+  /// Checks if the associated query is under memory arbitration or not. The
+  /// function returns true if it is and set future which is fulfilled when the
+  /// the memory arbiration finishes.
+  bool checkUnderArbitration(ContinueFuture* future);
+
+  /// Updates the aggregated spill bytes of this query, and and throws if
+  /// exceeds the max spill bytes limit.
+  void updateSpilledBytesAndCheckLimit(uint64_t bytes);
+
   void testingOverrideMemoryPool(std::shared_ptr<memory::MemoryPool> pool) {
     pool_ = std::move(pool);
   }
 
+  /// Indicates if the query is under memory arbitration or not.
+  bool testingUnderArbitration() const {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(underArbitration_ || arbitrationPromises_.empty());
+    return underArbitration_;
+  }
+
  private:
-  static Config* getEmptyConfig() {
-    static const std::unique_ptr<Config> kEmptyConfig =
-        std::make_unique<MemConfig>();
+  /// QueryCtx is used in different places. When used with `Task::start()`, it's
+  /// required that the caller supplies the executor and ensure its lifetime
+  /// outlives the tasks that use it. In contrast, when used in expression
+  /// evaluation through `ExecCtx` or 'Task::next()' for single thread execution
+  /// mode, executor is not needed. Hence, we don't require executor to always
+  /// be passed in here, but instead, ensure that executor exists when actually
+  /// being used.
+  QueryCtx(
+      folly::Executor* executor = nullptr,
+      QueryConfig&& queryConfig = QueryConfig{{}},
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
+          connectorConfigs = {},
+      cache::AsyncDataCache* cache = cache::AsyncDataCache::getInstance(),
+      std::shared_ptr<memory::MemoryPool> pool = nullptr,
+      folly::Executor* spillExecutor = nullptr,
+      const std::string& queryId = "");
+
+  class MemoryReclaimer : public memory::MemoryReclaimer {
+   public:
+    static std::unique_ptr<memory::MemoryReclaimer> create(
+        QueryCtx* queryCtx,
+        memory::MemoryPool* pool);
+
+    uint64_t reclaim(
+        memory::MemoryPool* pool,
+        uint64_t targetBytes,
+        uint64_t maxWaitMs,
+        memory::MemoryReclaimer::Stats& stats) override;
+
+   protected:
+    MemoryReclaimer(
+        const std::shared_ptr<QueryCtx>& queryCtx,
+        memory::MemoryPool* pool)
+        : queryCtx_(queryCtx), pool_(pool) {
+      VELOX_CHECK_NOT_NULL(pool_);
+    }
+
+    // Gets the shared pointer to the associated query ctx to ensure its
+    // liveness during the query memory reclaim operation.
+    //
+    // NOTE: an operator's memory pool can outlive its operator.
+    std::shared_ptr<QueryCtx> ensureQueryCtx() const {
+      return queryCtx_.lock();
+    }
+
+    const std::weak_ptr<QueryCtx> queryCtx_;
+    memory::MemoryPool* const pool_;
+  };
+
+  static config::ConfigBase* getEmptyConfig() {
+    static const std::unique_ptr<config::ConfigBase> kEmptyConfig =
+        std::make_unique<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>());
     return kEmptyConfig.get();
   }
 
   void initPool(const std::string& queryId) {
     if (pool_ == nullptr) {
-      pool_ = memory::defaultMemoryManager().addRootPool(
-          QueryCtx::generatePoolName(queryId));
+      pool_ = memory::memoryManager()->addRootPool(
+          QueryCtx::generatePoolName(queryId), memory::kMaxMemory);
     }
   }
 
+  // Setup the memory reclaimer for arbitration if user provided memory pool
+  // hasn't set it.
+  void maybeSetReclaimer();
+
+  // Invoked to start memory arbitration on this query.
+  void startArbitration();
+  // Invoked to stop memory arbitration on this query.
+  void finishArbitration();
+
   const std::string queryId_;
+  folly::Executor* const executor_{nullptr};
+  folly::Executor* const spillExecutor_{nullptr};
+  cache::AsyncDataCache* const cache_;
 
-  std::unordered_map<std::string, std::shared_ptr<Config>> connectorConfigs_;
-  cache::AsyncDataCache* cache_;
+  std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
+      connectorSessionProperties_;
   std::shared_ptr<memory::MemoryPool> pool_;
-  folly::Executor* executor_;
-  folly::Executor::KeepAlive<> executorKeepalive_;
   QueryConfig queryConfig_;
-  std::shared_ptr<folly::Executor> spillExecutor_;
+  std::atomic<uint64_t> numSpilledBytes_{0};
+
+  mutable std::mutex mutex_;
+  // Indicates if this query is under memory arbitration or not.
+  bool underArbitration_{false};
+  std::vector<ContinuePromise> arbitrationPromises_;
 };
 
 // Represents the state of one thread of query execution.
@@ -159,12 +229,53 @@ class ExecCtx {
   ExecCtx(memory::MemoryPool* pool, QueryCtx* queryCtx)
       : pool_(pool),
         queryCtx_(queryCtx),
-        exprEvalCacheEnabled_(
-            !queryCtx ||
-            queryCtx->queryConfig().isExpressionEvaluationCacheEnabled()),
+        optimizationParams_(queryCtx),
         vectorPool_(
-            exprEvalCacheEnabled_ ? std::make_unique<VectorPool>(pool)
-                                  : nullptr) {}
+            optimizationParams_.exprEvalCacheEnabled
+                ? std::make_unique<VectorPool>(pool)
+                : nullptr) {}
+
+  struct OptimizationParams {
+    explicit OptimizationParams(QueryCtx* queryCtx) {
+      const core::QueryConfig defaultQueryConfig = core::QueryConfig({});
+
+      const core::QueryConfig& queryConfig =
+          queryCtx ? queryCtx->queryConfig() : defaultQueryConfig;
+
+      exprEvalCacheEnabled = queryConfig.isExpressionEvaluationCacheEnabled();
+      dictionaryMemoizationEnabled =
+          !queryConfig.debugDisableExpressionsWithMemoization() &&
+          exprEvalCacheEnabled;
+      peelingEnabled = !queryConfig.debugDisableExpressionsWithPeeling();
+      sharedSubExpressionReuseEnabled =
+          !queryConfig.debugDisableCommonSubExpressions();
+      deferredLazyLoadingEnabled =
+          !queryConfig.debugDisableExpressionsWithLazyInputs();
+      maxSharedSubexprResultsCached =
+          queryConfig.maxSharedSubexprResultsCached();
+    }
+
+    /// True if caches in expression evaluation used for performance are
+    /// enabled, including VectorPool, DecodedVectorPool, SelectivityVectorPool
+    /// and dictionary memoization.
+    bool exprEvalCacheEnabled;
+    /// True if dictionary memoization optimization is enabled during experssion
+    /// evaluation, whichallows the reuse of results between consecutive input
+    /// batches if they are dictionary encoded and have the same
+    /// alphabet(undelying flat vector).
+    bool dictionaryMemoizationEnabled;
+    /// True if peeling is enabled during experssion evaluation.
+    bool peelingEnabled;
+    /// True if shared subexpression reuse is enabled during experssion
+    /// evaluation.
+    bool sharedSubExpressionReuseEnabled;
+    /// True if loading lazy inputs are deferred till they need to be
+    /// accessed during experssion evaluation.
+    bool deferredLazyLoadingEnabled;
+    /// The maximum number of distinct inputs to cache results in a
+    /// given shared subexpression during experssion evaluation.
+    uint32_t maxSharedSubexprResultsCached;
+  };
 
   velox::memory::MemoryPool* pool() const {
     return pool_;
@@ -181,7 +292,9 @@ class ExecCtx {
   /// Prefer using LocalSelectivityVector which takes care of returning the
   /// vector to the pool on destruction.
   std::unique_ptr<SelectivityVector> getSelectivityVector(int32_t size) {
-    VELOX_CHECK(exprEvalCacheEnabled_ || selectivityVectorPool_.empty());
+    VELOX_CHECK(
+        optimizationParams_.exprEvalCacheEnabled ||
+        selectivityVectorPool_.empty());
     if (selectivityVectorPool_.empty()) {
       return std::make_unique<SelectivityVector>(size);
     }
@@ -195,7 +308,9 @@ class ExecCtx {
   // content. The caller is responsible for setting the size and
   // assigning the contents.
   std::unique_ptr<SelectivityVector> getSelectivityVector() {
-    VELOX_CHECK(exprEvalCacheEnabled_ || selectivityVectorPool_.empty());
+    VELOX_CHECK(
+        optimizationParams_.exprEvalCacheEnabled ||
+        selectivityVectorPool_.empty());
     if (selectivityVectorPool_.empty()) {
       return std::make_unique<SelectivityVector>();
     }
@@ -206,7 +321,7 @@ class ExecCtx {
 
   // Returns true if the vector was moved into the pool.
   bool releaseSelectivityVector(std::unique_ptr<SelectivityVector>&& vector) {
-    if (exprEvalCacheEnabled_) {
+    if (optimizationParams_.exprEvalCacheEnabled) {
       selectivityVectorPool_.push_back(std::move(vector));
       return true;
     }
@@ -214,7 +329,8 @@ class ExecCtx {
   }
 
   std::unique_ptr<DecodedVector> getDecodedVector() {
-    VELOX_CHECK(exprEvalCacheEnabled_ || decodedVectorPool_.empty());
+    VELOX_CHECK(
+        optimizationParams_.exprEvalCacheEnabled || decodedVectorPool_.empty());
     if (decodedVectorPool_.empty()) {
       return std::make_unique<DecodedVector>();
     }
@@ -225,7 +341,7 @@ class ExecCtx {
 
   // Returns true if the vector was moved into the pool.
   bool releaseDecodedVector(std::unique_ptr<DecodedVector>&& vector) {
-    if (exprEvalCacheEnabled_) {
+    if (optimizationParams_.exprEvalCacheEnabled) {
       decodedVectorPool_.push_back(std::move(vector));
       return true;
     }
@@ -264,8 +380,8 @@ class ExecCtx {
     return 0;
   }
 
-  bool exprEvalCacheEnabled() const {
-    return exprEvalCacheEnabled_;
+  const OptimizationParams& optimizationParams() const {
+    return optimizationParams_;
   }
 
  private:
@@ -273,8 +389,9 @@ class ExecCtx {
   memory::MemoryPool* const pool_;
   QueryCtx* const queryCtx_;
 
-  const bool exprEvalCacheEnabled_;
-  // A pool of preallocated DecodedVectors for use by expressions and operators.
+  const OptimizationParams optimizationParams_;
+  // A pool of preallocated DecodedVectors for use by expressions and
+  // operators.
   std::vector<std::unique_ptr<DecodedVector>> decodedVectorPool_;
   // A pool of preallocated SelectivityVectors for use by expressions
   // and operators.
diff --git a/velox/core/SimpleFunctionMetadata.h b/velox/core/SimpleFunctionMetadata.h
index 73d1978facefa..0d9cc0f8b4bcd 100644
--- a/velox/core/SimpleFunctionMetadata.h
+++ b/velox/core/SimpleFunctionMetadata.h
@@ -17,13 +17,16 @@
 
 #include <boost/algorithm/string.hpp>
 #include <folly/Likely.h>
+#include <optional>
 
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/Status.h"
 #include "velox/core/CoreTypeSystem.h"
 #include "velox/core/Metaprogramming.h"
 #include "velox/core/QueryConfig.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/expression/SignatureBinder.h"
+#include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 #include "velox/type/Variant.h"
 
@@ -65,6 +68,20 @@ struct udf_help<T, util::detail::void_t<decltype(T::help)>> {
   }
 };
 
+// Canonical name of the function.
+template <class T, class = void>
+struct udf_canonical_name {
+  static constexpr exec::FunctionCanonicalName value =
+      exec::FunctionCanonicalName::kUnknown;
+};
+
+template <class T>
+struct udf_canonical_name<
+    T,
+    util::detail::void_t<decltype(T::canonical_name)>> {
+  static constexpr exec::FunctionCanonicalName value = T::canonical_name;
+};
+
 // Has the value true, unless a Variadic Type appears anywhere but at the end
 // of the parameters.
 template <typename... TArgs>
@@ -153,11 +170,26 @@ struct TypeAnalysisResults {
     }
   } stats;
 
-  // String representaion of the type in the FunctionSignatureBuilder.
+  void addVariable(exec::SignatureVariable&& variable) {
+    if (!variablesInformation.count(variable.name())) {
+      variablesInformation.emplace(variable.name(), variable);
+    } else {
+      VELOX_CHECK(
+          variable == variablesInformation.at(variable.name()),
+          "Cant assign different properties to the same variable {}",
+          variable.name());
+    }
+  }
+
+  /// String representation of the type in the FunctionSignatureBuilder.
   std::ostringstream out;
 
-  // Set of generic variables used in the type.
-  std::set<std::string> variables;
+  /// Physical type, e.g. BIGINT() for Date and ARRAY(BIGINT()) for
+  // Array<Date>. UNKNOWN() if type is generic or opaque.
+  TypePtr physicalType;
+
+  /// Set of generic variables used in the type.
+  std::map<std::string, exec::SignatureVariable> variablesInformation;
 
   std::string typeAsString() {
     return out.str();
@@ -193,20 +225,66 @@ struct TypeAnalysis {
     results.stats.concreteCount++;
     results.out << detail::strToLowerCopy(
         std::string(SimpleTypeTrait<T>::name));
+    if constexpr (
+        SimpleTypeTrait<T>::typeKind == TypeKind::OPAQUE ||
+        SimpleTypeTrait<T>::typeKind == TypeKind::UNKNOWN) {
+      results.physicalType = UNKNOWN();
+    } else {
+      results.physicalType = createScalarType(SimpleTypeTrait<T>::typeKind);
+    }
   }
 };
 
-template <typename T>
-struct TypeAnalysis<Generic<T>> {
+template <typename T, bool comparable, bool orderable>
+struct TypeAnalysis<Generic<T, comparable, orderable>> {
   void run(TypeAnalysisResults& results) {
     if constexpr (std::is_same_v<T, AnyType>) {
       results.out << "any";
     } else {
-      auto variableType = fmt::format("__user_T{}", T::getId());
-      results.out << variableType;
-      results.variables.insert(variableType);
+      auto typeVariableName = fmt::format("__user_T{}", T::getId());
+      results.out << typeVariableName;
+      results.addVariable(exec::SignatureVariable(
+          typeVariableName,
+          std::nullopt,
+          exec::ParameterType::kTypeParameter,
+          false,
+          orderable,
+          comparable));
     }
     results.stats.hasGeneric = true;
+    results.physicalType = UNKNOWN();
+  }
+};
+
+template <typename P, typename S>
+struct TypeAnalysis<ShortDecimal<P, S>> {
+  void run(TypeAnalysisResults& results) {
+    results.stats.concreteCount++;
+
+    const auto p = P::name();
+    const auto s = S::name();
+    results.out << fmt::format("decimal({},{})", p, s);
+    results.addVariable(exec::SignatureVariable(
+        p, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.addVariable(exec::SignatureVariable(
+        s, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.physicalType = BIGINT();
+  }
+};
+
+template <typename P, typename S>
+struct TypeAnalysis<LongDecimal<P, S>> {
+  void run(TypeAnalysisResults& results) {
+    results.stats.concreteCount++;
+
+    const auto p = P::name();
+    const auto s = S::name();
+    results.out << fmt::format("decimal({},{})", p, s);
+    results.addVariable(exec::SignatureVariable(
+        p, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.addVariable(exec::SignatureVariable(
+        s, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.physicalType = HUGEINT();
   }
 };
 
@@ -216,9 +294,12 @@ struct TypeAnalysis<Map<K, V>> {
     results.stats.concreteCount++;
     results.out << "map(";
     TypeAnalysis<K>().run(results);
+    auto keyType = results.physicalType;
     results.out << ", ";
     TypeAnalysis<V>().run(results);
+    auto valueType = results.physicalType;
     results.out << ")";
+    results.physicalType = MAP(keyType, valueType);
   }
 };
 
@@ -237,8 +318,11 @@ struct TypeAnalysis<Variadic<V>> {
         tmp.stats.hasGeneric || results.stats.hasVariadicOfGeneric;
 
     results.stats.concreteCount += tmp.stats.concreteCount;
-    results.variables.insert(tmp.variables.begin(), tmp.variables.end());
+    for (auto& [_, variable] : tmp.variablesInformation) {
+      results.addVariable(std::move(variable));
+    }
     results.out << tmp.typeAsString();
+    results.physicalType = tmp.physicalType;
   }
 };
 
@@ -249,6 +333,7 @@ struct TypeAnalysis<Array<V>> {
     results.out << "array(";
     TypeAnalysis<V>().run(results);
     results.out << ")";
+    results.physicalType = ARRAY(results.physicalType);
   }
 };
 
@@ -262,6 +347,7 @@ struct TypeAnalysis<Row<T...>> {
   void run(TypeAnalysisResults& results) {
     results.stats.concreteCount++;
     results.out << "row(";
+    std::vector<TypePtr> fieldTypes;
     // This expression applies the lambda for each row child type.
     bool first = true;
     (
@@ -271,9 +357,11 @@ struct TypeAnalysis<Row<T...>> {
           }
           first = false;
           TypeAnalysis<T>().run(results);
+          fieldTypes.push_back(results.physicalType);
         }(),
         ...);
     results.out << ")";
+    results.physicalType = ROW(std::move(fieldTypes));
   }
 };
 
@@ -282,20 +370,30 @@ struct TypeAnalysis<CustomType<T>> {
   void run(TypeAnalysisResults& results) {
     results.stats.concreteCount++;
     results.out << T::typeName;
+
+    TypeAnalysisResults tmp;
+    TypeAnalysis<typename T::type>().run(tmp);
+    results.physicalType = tmp.physicalType;
   }
 };
 
 class ISimpleFunctionMetadata {
  public:
+  virtual ~ISimpleFunctionMetadata() = default;
+
   // Return the return type of the function if its independent on the input
   // types, otherwise return null.
   virtual TypePtr tryResolveReturnType() const = 0;
   virtual std::string getName() const = 0;
   virtual bool isDeterministic() const = 0;
+  virtual bool defaultNullBehavior() const = 0;
   virtual uint32_t priority() const = 0;
   virtual const std::shared_ptr<exec::FunctionSignature> signature() const = 0;
+  virtual const TypePtr& resultPhysicalType() const = 0;
+  virtual const std::vector<TypePtr>& argPhysicalTypes() const = 0;
+  virtual bool physicalSignatureEquals(
+      const ISimpleFunctionMetadata& other) const = 0;
   virtual std::string helpMessage(const std::string& name) const = 0;
-  virtual ~ISimpleFunctionMetadata() = default;
 };
 
 template <typename T, typename = int32_t>
@@ -304,7 +402,11 @@ struct udf_has_name : std::false_type {};
 template <typename T>
 struct udf_has_name<T, decltype(&T::name, 0)> : std::true_type {};
 
-template <typename Fun, typename TReturn, typename... Args>
+template <
+    typename Fun,
+    typename TReturn,
+    typename ConstantChecker,
+    typename... Args>
 class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
  public:
   using return_type = TReturn;
@@ -356,6 +458,10 @@ class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
     return udf_is_deterministic<Fun>();
   }
 
+  bool defaultNullBehavior() const final {
+    return defaultNullBehavior_;
+  }
+
   static constexpr bool isVariadic() {
     if constexpr (num_args == 0) {
       return false;
@@ -364,10 +470,16 @@ class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
     }
   }
 
-  explicit SimpleFunctionMetadata() {
-    auto analysis = analyzeSignatureTypes();
+  explicit SimpleFunctionMetadata(
+      bool defaultNullBehavior,
+      const std::vector<exec::SignatureVariable>& constraints)
+      : defaultNullBehavior_{defaultNullBehavior} {
+    auto analysis = analyzeSignatureTypes(constraints);
+
     buildSignature(analysis);
     priority_ = analysis.stats.computePriority();
+    resultPhysicalType_ = analysis.resultPhysicalType;
+    argPhysicalTypes_ = analysis.argPhysicalTypes;
   }
 
   ~SimpleFunctionMetadata() override = default;
@@ -376,6 +488,33 @@ class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
     return signature_;
   }
 
+  const TypePtr& resultPhysicalType() const override {
+    return resultPhysicalType_;
+  }
+
+  const std::vector<TypePtr>& argPhysicalTypes() const override {
+    return argPhysicalTypes_;
+  }
+
+  bool physicalSignatureEquals(
+      const ISimpleFunctionMetadata& other) const override {
+    if (!resultPhysicalType_->kindEquals(other.resultPhysicalType())) {
+      return false;
+    }
+
+    if (argPhysicalTypes_.size() != other.argPhysicalTypes().size()) {
+      return false;
+    }
+
+    for (auto i = 0; i < argPhysicalTypes_.size(); ++i) {
+      if (!argPhysicalTypes_[i]->kindEquals(other.argPhysicalTypes()[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   std::string helpMessage(const std::string& name) const final {
     // return fmt::format("{}({})", name, signature_->toString());
     std::string s{name};
@@ -401,16 +540,21 @@ class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
   struct SignatureTypesAnalysisResults {
     std::vector<std::string> argsTypes;
     std::string outputType;
-    std::set<std::string> variables;
+    std::map<std::string, exec::SignatureVariable> variables;
     TypeAnalysisResults::Stats stats;
+    TypePtr resultPhysicalType;
+    std::vector<TypePtr> argPhysicalTypes;
   };
 
-  SignatureTypesAnalysisResults analyzeSignatureTypes() {
+  SignatureTypesAnalysisResults analyzeSignatureTypes(
+      const std::vector<exec::SignatureVariable>& constraints) {
     std::vector<std::string> argsTypes;
 
     TypeAnalysisResults results;
     TypeAnalysis<return_type>().run(results);
     std::string outputType = results.typeAsString();
+    const auto resultPhysicalType = results.physicalType;
+    std::vector<TypePtr> argPhysicalTypes;
 
     (
         [&]() {
@@ -419,27 +563,44 @@ class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
           results.resetTypeString();
           TypeAnalysis<Args>().run(results);
           argsTypes.push_back(results.typeAsString());
+          argPhysicalTypes.push_back(results.physicalType);
         }(),
         ...);
 
+    for (const auto& constraint : constraints) {
+      VELOX_CHECK(
+          !constraint.constraint().empty(),
+          "Constraint must be set for variable {}",
+          constraint.name());
+
+      results.variablesInformation.erase(constraint.name());
+      results.variablesInformation.emplace(constraint.name(), constraint);
+    }
+
     return SignatureTypesAnalysisResults{
         std::move(argsTypes),
         std::move(outputType),
-        std::move(results.variables),
-        std::move(results.stats)};
+        std::move(results.variablesInformation),
+        std::move(results.stats),
+        resultPhysicalType,
+        argPhysicalTypes};
   }
 
   void buildSignature(const SignatureTypesAnalysisResults& analysis) {
     auto builder = exec::FunctionSignatureBuilder();
 
     builder.returnType(analysis.outputType);
-
+    int32_t position = 0;
     for (const auto& arg : analysis.argsTypes) {
-      builder.argumentType(arg);
+      if (ConstantChecker::isConstant[position++]) {
+        builder.constantArgumentType(arg);
+      } else {
+        builder.argumentType(arg);
+      }
     }
 
-    for (const auto& variable : analysis.variables) {
-      builder.typeVariable(variable);
+    for (const auto& [_, variable] : analysis.variables) {
+      builder.variable(variable);
     }
 
     if (isVariadic()) {
@@ -448,20 +609,34 @@ class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
     signature_ = builder.build();
   }
 
+  const bool defaultNullBehavior_;
   exec::FunctionSignaturePtr signature_;
   uint32_t priority_;
+  TypePtr resultPhysicalType_;
+  std::vector<TypePtr> argPhysicalTypes_;
 };
 
 // wraps a UDF object to provide the inheritance
 // this is basically just boilerplate-avoidance
-template <typename Fun, typename Exec, typename TReturn, typename... TArgs>
-class UDFHolder final
-    : public core::SimpleFunctionMetadata<Fun, TReturn, TArgs...> {
+template <
+    typename Fun,
+    typename Exec,
+    typename TReturn,
+    typename ConstantChecker,
+    typename... TArgs>
+class UDFHolder {
   Fun instance_;
 
  public:
+  using return_type = TReturn;
+  using arg_types = std::tuple<TArgs...>;
+  template <size_t N>
+  using type_at = typename std::tuple_element<N, arg_types>::type;
+  static constexpr int num_args = std::tuple_size<arg_types>::value;
+
   using udf_struct_t = Fun;
-  using Metadata = core::SimpleFunctionMetadata<Fun, TReturn, TArgs...>;
+  using Metadata =
+      core::SimpleFunctionMetadata<Fun, TReturn, ConstantChecker, TArgs...>;
 
   template <typename T>
   using exec_resolver = typename Exec::template resolver<T>;
@@ -491,15 +666,19 @@ class UDFHolder final
   DECLARE_METHOD_RESOLVER(callAscii_method_resolver, callAscii);
   DECLARE_METHOD_RESOLVER(initialize_method_resolver, initialize);
 
-  // Check which flavor of the call() method is provided by the UDF object. UDFs
-  // are required to provide at least one of the following methods:
+  // Check which flavor of the call()/callNullable()/callNullFree() method is
+  // provided by the UDF object. UDFs are required to provide at least one of
+  // the following methods:
   //
-  // - bool|void call(...)
-  // - bool|void callNullable(...)
-  // - bool|void callNullFree(...)
+  // - bool|void|Status call(...)
+  // - bool|void|Status callNullable(...)
+  // - bool|void|Status callNullFree(...)
   //
-  // Each of these methods can return either bool or void. Returning void means
-  // that the UDF is assumed never to return null values.
+  // Each of these methods can return bool, void or Status. Returning void
+  // means that the UDF is assumed never to return null values. Returning
+  // Status to hold success or error outcome of the function call, and it
+  // implies result is not null. If you need to return null as result, please
+  // use bool return type.
   //
   // Optionally, UDFs can also provide the following methods:
   //
@@ -513,17 +692,29 @@ class UDFHolder final
       bool,
       exec_return_type,
       const exec_arg_type<TArgs>&...>::value;
+
   static constexpr bool udf_has_call_return_void = util::has_method<
       Fun,
       call_method_resolver,
       void,
       exec_return_type,
       const exec_arg_type<TArgs>&...>::value;
-  static constexpr bool udf_has_call =
-      udf_has_call_return_bool | udf_has_call_return_void;
+
+  static constexpr bool udf_has_call_return_status = util::has_method<
+      Fun,
+      call_method_resolver,
+      Status,
+      exec_return_type,
+      const exec_arg_type<TArgs>&...>::value;
+
+  static constexpr bool udf_has_call = udf_has_call_return_bool |
+      udf_has_call_return_void | udf_has_call_return_status;
+
   static_assert(
-      !(udf_has_call_return_bool && udf_has_call_return_void),
-      "Provided call() methods need to return either void OR bool.");
+      udf_has_call_return_void + udf_has_call_return_bool +
+              udf_has_call_return_status <=
+          1,
+      "Provided call() methods need to only return void, bool OR Status.");
 
   // callNullable():
   static constexpr bool udf_has_callNullable_return_bool = util::has_method<
@@ -538,11 +729,21 @@ class UDFHolder final
       void,
       exec_return_type,
       const exec_arg_type<TArgs>*...>::value;
+  static constexpr bool udf_has_callNullable_return_status = util::has_method<
+      Fun,
+      callNullable_method_resolver,
+      Status,
+      exec_return_type,
+      const exec_arg_type<TArgs>*...>::value;
   static constexpr bool udf_has_callNullable =
-      udf_has_callNullable_return_bool | udf_has_callNullable_return_void;
+      udf_has_callNullable_return_bool | udf_has_callNullable_return_void |
+      udf_has_callNullable_return_status;
+
   static_assert(
-      !(udf_has_callNullable_return_bool && udf_has_callNullable_return_void),
-      "Provided callNullable() methods need to return either void OR bool.");
+      udf_has_callNullable_return_void + udf_has_callNullable_return_bool +
+              udf_has_callNullable_return_status <=
+          1,
+      "Provided callNullable() methods need to only return void, bool OR Status.");
 
   // callNullFree():
   static constexpr bool udf_has_callNullFree_return_bool = util::has_method<
@@ -557,11 +758,21 @@ class UDFHolder final
       void,
       exec_return_type,
       const exec_no_nulls_arg_type<TArgs>&...>::value;
+  static constexpr bool udf_has_callNullFree_return_status = util::has_method<
+      Fun,
+      callNullFree_method_resolver,
+      Status,
+      exec_return_type,
+      const exec_no_nulls_arg_type<TArgs>&...>::value;
   static constexpr bool udf_has_callNullFree =
-      udf_has_callNullFree_return_bool | udf_has_callNullFree_return_void;
+      udf_has_callNullFree_return_bool | udf_has_callNullFree_return_void |
+      udf_has_callNullFree_return_status;
+
   static_assert(
-      !(udf_has_callNullFree_return_bool && udf_has_callNullFree_return_void),
-      "Provided callNullFree() methods need to return either void OR bool.");
+      udf_has_callNullFree_return_void + udf_has_callNullFree_return_bool +
+              udf_has_callNullFree_return_status <=
+          1,
+      "Provided callNullFree() methods need to only return void, bool OR Status.");
 
   // callAscii():
   static constexpr bool udf_has_callAscii_return_bool = util::has_method<
@@ -593,9 +804,22 @@ class UDFHolder final
       Fun,
       initialize_method_resolver,
       void,
+      const std::vector<TypePtr>&,
       const core::QueryConfig&,
       const exec_arg_type<TArgs>*...>::value;
 
+  // TODO Remove
+  static constexpr bool udf_has_legacy_initialize = util::has_method<
+      Fun,
+      initialize_method_resolver,
+      void,
+      const core::QueryConfig&,
+      const exec_arg_type<TArgs>*...>::value;
+
+  static_assert(
+      !udf_has_legacy_initialize,
+      "Legacy initialize method! Upgrade.");
+
   static_assert(
       udf_has_call || udf_has_callNullable || udf_has_callNullFree,
       "UDF must implement at least one of `call`, `callNullable`, or `callNullFree` functions.\n"
@@ -649,23 +873,41 @@ class UDFHolder final
   template <size_t N>
   using exec_type_at = typename std::tuple_element<N, exec_arg_types>::type;
 
-  explicit UDFHolder() : Metadata(), instance_{} {}
+  explicit UDFHolder() : instance_{} {}
+
+  exec::FunctionCanonicalName getCanonicalName() const {
+    return udf_canonical_name<Fun>::value;
+  }
+
+  bool isDeterministic() const {
+    return udf_is_deterministic<Fun>();
+  }
+
+  static constexpr bool isVariadic() {
+    if constexpr (num_args == 0) {
+      return false;
+    } else {
+      return isVariadicType<type_at<num_args - 1>>::value;
+    }
+  }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
       const typename exec_resolver<TArgs>::in_type*... constantArgs) {
     if constexpr (udf_has_initialize) {
-      return instance_.initialize(config, constantArgs...);
+      return instance_.initialize(inputTypes, config, constantArgs...);
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE Status call(
       exec_return_type& out,
+      bool& notNull,
       const typename exec_resolver<TArgs>::in_type&... args) {
     if constexpr (udf_has_call) {
-      return callImpl(out, args...);
+      return callImpl(out, notNull, args...);
     } else if constexpr (udf_has_callNullable) {
-      return callNullableImpl(out, (&args)...);
+      return callNullableImpl(out, notNull, (&args)...);
     } else {
       VELOX_UNREACHABLE(
           "call should never be called if the UDF does not "
@@ -673,18 +915,20 @@ class UDFHolder final
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool callNullable(
+  FOLLY_ALWAYS_INLINE Status callNullable(
       exec_return_type& out,
+      bool& notNull,
       const typename exec_resolver<TArgs>::in_type*... args) {
     if constexpr (udf_has_callNullable) {
-      return callNullableImpl(out, args...);
+      return callNullableImpl(out, notNull, args...);
     } else if constexpr (udf_has_call) {
       // Default null behavior.
       const bool isAllSet = (args && ...);
       if (LIKELY(isAllSet)) {
-        return callImpl(out, (*args)...);
+        return callImpl(out, notNull, (*args)...);
       } else {
-        return false;
+        notNull = false;
+        return Status::OK();
       }
     } else {
       VELOX_UNREACHABLE(
@@ -693,21 +937,23 @@ class UDFHolder final
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool callAscii(
+  FOLLY_ALWAYS_INLINE Status callAscii(
       exec_return_type& out,
+      bool& notNull,
       const typename exec_resolver<TArgs>::in_type&... args) {
     if constexpr (udf_has_callAscii) {
-      return callAsciiImpl(out, args...);
+      return callAsciiImpl(out, notNull, args...);
     } else {
-      return call(out, args...);
+      return call(out, notNull, args...);
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool callNullFree(
+  FOLLY_ALWAYS_INLINE Status callNullFree(
       exec_return_type& out,
+      bool& notNull,
       const exec_no_nulls_arg_type<TArgs>&... args) {
     if constexpr (udf_has_callNullFree) {
-      return callNullFreeImpl(out, args...);
+      return callNullFreeImpl(out, notNull, args...);
     } else {
       VELOX_UNREACHABLE(
           "callNullFree should never be called if the UDF does not implement callNullFree.");
@@ -716,52 +962,73 @@ class UDFHolder final
 
   // Helper functions to handle void vs bool return type.
 
-  FOLLY_ALWAYS_INLINE bool callImpl(
+  FOLLY_ALWAYS_INLINE Status callImpl(
       typename Exec::template resolver<TReturn>::out_type& out,
+      bool& notNull,
       const typename Exec::template resolver<TArgs>::in_type&... args) {
     static_assert(udf_has_call);
-    if constexpr (udf_has_call_return_bool) {
+
+    if constexpr (udf_has_call_return_status) {
+      notNull = true;
       return instance_.call(out, args...);
+    } else if constexpr (udf_has_call_return_bool) {
+      notNull = instance_.call(out, args...);
+      return Status::OK();
     } else {
       instance_.call(out, args...);
-      return true;
+      notNull = true;
+      return Status::OK();
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool callNullableImpl(
+  FOLLY_ALWAYS_INLINE Status callNullableImpl(
       exec_return_type& out,
+      bool& notNull,
       const typename Exec::template resolver<TArgs>::in_type*... args) {
     static_assert(udf_has_callNullable);
-    if constexpr (udf_has_callNullable_return_bool) {
+
+    if constexpr (udf_has_callNullable_return_status) {
+      notNull = true;
       return instance_.callNullable(out, args...);
+    } else if constexpr (udf_has_callNullable_return_bool) {
+      notNull = instance_.callNullable(out, args...);
+      return Status::OK();
     } else {
       instance_.callNullable(out, args...);
-      return true;
+      notNull = true;
+      return Status::OK();
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool callAsciiImpl(
+  FOLLY_ALWAYS_INLINE Status callAsciiImpl(
       typename Exec::template resolver<TReturn>::out_type& out,
+      bool& notNull,
       const typename Exec::template resolver<TArgs>::in_type&... args) {
     static_assert(udf_has_callAscii);
     if constexpr (udf_has_callAscii_return_bool) {
-      return instance_.callAscii(out, args...);
+      notNull = instance_.callAscii(out, args...);
     } else {
       instance_.callAscii(out, args...);
-      return true;
+      notNull = true;
     }
+    return Status::OK();
   }
 
-  FOLLY_ALWAYS_INLINE bool callNullFreeImpl(
+  FOLLY_ALWAYS_INLINE Status callNullFreeImpl(
       typename Exec::template resolver<TReturn>::out_type& out,
+      bool& notNull,
       const exec_no_nulls_arg_type<TArgs>&... args) {
     static_assert(udf_has_callNullFree);
-    if constexpr (udf_has_callNullFree_return_bool) {
+    if constexpr (udf_has_callNullFree_return_status) {
+      notNull = true;
       return instance_.callNullFree(out, args...);
+    } else if constexpr (udf_has_callNullFree_return_bool) {
+      notNull = instance_.callNullFree(out, args...);
     } else {
       instance_.callNullFree(out, args...);
-      return true;
+      notNull = true;
     }
+    return Status::OK();
   }
 };
 
diff --git a/velox/core/tests/CMakeLists.txt b/velox/core/tests/CMakeLists.txt
index 5065c7f2705e4..6092bb4b98f63 100644
--- a/velox/core/tests/CMakeLists.txt
+++ b/velox/core/tests/CMakeLists.txt
@@ -26,11 +26,12 @@ add_test(velox_core_test velox_core_test)
 
 target_link_libraries(
   velox_core_test
-  PRIVATE velox_core
-          velox_exception
-          velox_exec_test_lib
-          velox_presto_types
-          velox_type
-          velox_vector_test_lib
-          gtest
-          gtest_main)
+  PRIVATE
+    velox_core
+    velox_exception
+    velox_exec_test_lib
+    velox_presto_types
+    velox_type
+    velox_vector_test_lib
+    GTest::gtest
+    GTest::gtest_main)
diff --git a/velox/core/tests/ConstantTypedExprTest.cpp b/velox/core/tests/ConstantTypedExprTest.cpp
index b5ad1dad19d4e..cba32ed7da05b 100644
--- a/velox/core/tests/ConstantTypedExprTest.cpp
+++ b/velox/core/tests/ConstantTypedExprTest.cpp
@@ -47,12 +47,8 @@ TEST(ConstantTypedExprTest, null) {
   EXPECT_FALSE(*makeNull(HYPERLOGLOG()) == *makeNull(VARBINARY()));
   EXPECT_FALSE(*makeNull(VARBINARY()) == *makeNull(HYPERLOGLOG()));
 
-  EXPECT_FALSE(
-      *makeNull(TIMESTAMP_WITH_TIME_ZONE()) ==
-      *makeNull(ROW({BIGINT(), SMALLINT()})));
-  EXPECT_FALSE(
-      *makeNull(ROW({BIGINT(), SMALLINT()})) ==
-      *makeNull(TIMESTAMP_WITH_TIME_ZONE()));
+  EXPECT_FALSE(*makeNull(TIMESTAMP_WITH_TIME_ZONE()) == *makeNull(BIGINT()));
+  EXPECT_FALSE(*makeNull(BIGINT()) == *makeNull(TIMESTAMP_WITH_TIME_ZONE()));
 
   EXPECT_TRUE(*makeNull(DOUBLE()) == *makeNull(DOUBLE()));
   EXPECT_TRUE(*makeNull(ARRAY(DOUBLE())) == *makeNull(ARRAY(DOUBLE())));
diff --git a/velox/core/tests/PlanFragmentTest.cpp b/velox/core/tests/PlanFragmentTest.cpp
index ca48ea07e0982..5116970d695c3 100644
--- a/velox/core/tests/PlanFragmentTest.cpp
+++ b/velox/core/tests/PlanFragmentTest.cpp
@@ -27,6 +27,10 @@ using facebook::velox::exec::test::PlanBuilder;
 namespace {
 class PlanFragmentTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
     rowType_ = ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), BIGINT()});
     rowTypeWithProjection_ = ROW(
@@ -63,7 +67,7 @@ class PlanFragmentTest : public testing::Test {
         {QueryConfig::kOrderBySpillEnabled,
          orderBySpillEnabled ? "true" : "false"},
     });
-    return std::make_shared<QueryCtx>(nullptr, std::move(configData));
+    return QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
   }
 
   RowTypePtr rowType_;
@@ -74,9 +78,10 @@ class PlanFragmentTest : public testing::Test {
   RowTypePtr probeTypeWithProjection_;
   std::vector<RowVectorPtr> emptyProbeVectors_;
   std::shared_ptr<PlanNode> probeValueNode_;
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
-}; // namespace
+} // namespace
 
 TEST_F(PlanFragmentTest, orderByCanSpill) {
   struct {
@@ -100,7 +105,8 @@ TEST_F(PlanFragmentTest, orderByCanSpill) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    const std::vector<FieldAccessTypedExprPtr> sortingKeys{nullptr};
+    const std::vector<FieldAccessTypedExprPtr> sortingKeys{
+        std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")};
     const std::vector<SortOrder> sortingOrders{{true, true}};
     auto orderBy = std::make_shared<OrderByNode>(
         "orderBy", sortingKeys, sortingOrders, false, valueNode_);
@@ -144,7 +150,7 @@ TEST_F(PlanFragmentTest, aggregationCanSpill) {
     std::string debugString() const {
       return fmt::format(
           "aggregationStep:{} isSpillEnabled:{} isAggregationSpillEnabled:{} isDistinct:{} hasPreAggregation:{} expectedCanSpill:{}",
-          aggregationStep,
+          AggregationNode::stepName(aggregationStep),
           isSpillEnabled,
           isAggregationSpillEnabled,
           isDistinct,
@@ -154,7 +160,7 @@ TEST_F(PlanFragmentTest, aggregationCanSpill) {
   } testSettings[] = {
       {AggregationNode::Step::kSingle, false, true, false, false, false},
       {AggregationNode::Step::kSingle, true, false, false, false, false},
-      {AggregationNode::Step::kSingle, true, true, true, false, false},
+      {AggregationNode::Step::kSingle, true, true, true, false, true},
       {AggregationNode::Step::kSingle, true, true, false, true, false},
       {AggregationNode::Step::kSingle, true, true, false, false, true},
       {AggregationNode::Step::kIntermediate, false, true, false, false, false},
@@ -167,11 +173,11 @@ TEST_F(PlanFragmentTest, aggregationCanSpill) {
       {AggregationNode::Step::kPartial, true, true, true, false, false},
       {AggregationNode::Step::kPartial, true, true, false, true, false},
       {AggregationNode::Step::kPartial, true, true, false, false, false},
-      {AggregationNode::Step::kSingle, false, true, false, false, false},
-      {AggregationNode::Step::kSingle, true, false, false, false, false},
-      {AggregationNode::Step::kSingle, true, true, true, false, false},
-      {AggregationNode::Step::kSingle, true, true, false, true, false},
-      {AggregationNode::Step::kSingle, true, true, false, false, true}};
+      {AggregationNode::Step::kFinal, false, true, false, false, false},
+      {AggregationNode::Step::kFinal, true, false, false, false, false},
+      {AggregationNode::Step::kFinal, true, true, true, false, true},
+      {AggregationNode::Step::kFinal, true, true, false, true, false},
+      {AggregationNode::Step::kFinal, true, true, false, false, true}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
@@ -317,3 +323,14 @@ TEST_F(PlanFragmentTest, hashJoin) {
         testData.expectedCanSpill);
   }
 }
+
+TEST_F(PlanFragmentTest, executionStrategyToString) {
+  ASSERT_EQ(
+      executionStrategyToString(core::ExecutionStrategy::kUngrouped),
+      "UNGROUPED");
+  ASSERT_EQ(
+      executionStrategyToString(core::ExecutionStrategy::kGrouped), "GROUPED");
+  ASSERT_EQ(
+      executionStrategyToString(static_cast<core::ExecutionStrategy>(999)),
+      "UNKNOWN: 999");
+}
diff --git a/velox/core/tests/PlanNodeTest.cpp b/velox/core/tests/PlanNodeTest.cpp
index 6acd586f10080..961d1dd86c221 100644
--- a/velox/core/tests/PlanNodeTest.cpp
+++ b/velox/core/tests/PlanNodeTest.cpp
@@ -15,6 +15,7 @@
  */
 #include <gtest/gtest.h>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/PlanNode.h"
 
 using namespace ::facebook::velox;
@@ -97,3 +98,17 @@ TEST(TestPlanNode, sortOrder) {
     }
   }
 }
+
+TEST(TestPlanNode, duplicateSortKeys) {
+  auto sortingKeys = std::vector<FieldAccessTypedExprPtr>{
+      std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0"),
+      std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c1"),
+      std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0"),
+  };
+  auto sortingOrders =
+      std::vector<SortOrder>{{true, true}, {false, false}, {true, true}};
+  VELOX_ASSERT_USER_THROW(
+      std::make_shared<OrderByNode>(
+          "orderBy", sortingKeys, sortingOrders, false, nullptr),
+      "Duplicate sorting keys are not allowed: c0");
+}
diff --git a/velox/core/tests/QueryConfigTest.cpp b/velox/core/tests/QueryConfigTest.cpp
index 27b938b6e0d7c..c89d44d2fdfad 100644
--- a/velox/core/tests/QueryConfigTest.cpp
+++ b/velox/core/tests/QueryConfigTest.cpp
@@ -21,74 +21,39 @@
 
 namespace facebook::velox::core::test {
 
-TEST(TestQueryConfig, emptyConfig) {
-  std::unordered_map<std::string, std::string> configData;
-  auto queryCtx = std::make_shared<QueryCtx>(nullptr, std::move(configData));
+class QueryConfigTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(QueryConfigTest, emptyConfig) {
+  auto queryCtx = QueryCtx::create(nullptr, QueryConfig{{}});
   const QueryConfig& config = queryCtx->queryConfig();
 
-  ASSERT_FALSE(config.codegenEnabled());
-  ASSERT_EQ(config.codegenConfigurationFilePath(), "");
-  ASSERT_FALSE(config.isCastToIntByTruncate());
+  ASSERT_FALSE(config.isLegacyCast());
 }
 
-TEST(TestQueryConfig, setConfig) {
-  std::string path = "/tmp/CodeGenConfig";
+TEST_F(QueryConfigTest, setConfig) {
+  std::string path = "/tmp/setConfig";
   std::unordered_map<std::string, std::string> configData(
-      {{QueryConfig::kCodegenEnabled, "true"},
-       {QueryConfig::kCodegenConfigurationFilePath, path}});
-  auto queryCtx = std::make_shared<QueryCtx>(nullptr, std::move(configData));
+      {{QueryConfig::kLegacyCast, "true"}});
+  auto queryCtx = QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
   const QueryConfig& config = queryCtx->queryConfig();
 
-  ASSERT_TRUE(config.codegenEnabled());
-  ASSERT_EQ(config.codegenConfigurationFilePath(), path);
-  ASSERT_FALSE(config.isCastToIntByTruncate());
+  ASSERT_TRUE(config.isLegacyCast());
 }
 
-TEST(TestQueryConfig, memConfig) {
-  const std::string tz = "timezone1";
-  const std::unordered_map<std::string, std::string> configData(
-      {{QueryConfig::kCodegenEnabled, "true"},
-       {QueryConfig::kSessionTimezone, tz}});
-
-  {
-    MemConfig cfg{configData};
-    MemConfig cfg2{};
-    auto configDataCopy = configData;
-    MemConfig cfg3{std::move(configDataCopy)};
-    ASSERT_TRUE(cfg.Config::get<bool>(QueryConfig::kCodegenEnabled));
-    ASSERT_TRUE(cfg3.Config::get<bool>(QueryConfig::kCodegenEnabled));
-    ASSERT_EQ(
-        tz,
-        cfg.Config::get<std::string>(QueryConfig::kSessionTimezone).value());
-    ASSERT_FALSE(cfg.Config::get<std::string>("missing-entry").has_value());
-    ASSERT_EQ(configData, cfg.values());
-    ASSERT_EQ(configData, cfg.valuesCopy());
-  }
-
-  {
-    MemConfigMutable cfg{configData};
-    MemConfigMutable cfg2{};
-    auto configDataCopy = configData;
-    MemConfigMutable cfg3{std::move(configDataCopy)};
-    ASSERT_TRUE(cfg.Config::get<bool>(QueryConfig::kCodegenEnabled).value());
-    ASSERT_TRUE(cfg3.Config::get<bool>(QueryConfig::kCodegenEnabled).value());
-    ASSERT_EQ(
-        tz,
-        cfg.Config::get<std::string>(QueryConfig::kSessionTimezone).value());
-    ASSERT_FALSE(cfg.Config::get<std::string>("missing-entry").has_value());
-    ASSERT_NO_THROW(cfg.setValue(QueryConfig::kCodegenEnabled, "false"));
-    ASSERT_FALSE(cfg.Config::get<bool>(QueryConfig::kCodegenEnabled).value());
-    const std::string tz2 = "timezone2";
-    ASSERT_NO_THROW(cfg.setValue(QueryConfig::kSessionTimezone, tz2));
-    ASSERT_EQ(
-        tz2,
-        cfg.Config::get<std::string>(QueryConfig::kSessionTimezone).value());
-    ASSERT_THROW(cfg.values(), VeloxException);
-    ASSERT_EQ(configData, cfg3.valuesCopy());
-  }
+TEST_F(QueryConfigTest, invalidConfig) {
+  std::unordered_map<std::string, std::string> configData(
+      {{QueryConfig::kSessionTimezone, "invalid"}});
+  VELOX_ASSERT_USER_THROW(
+      QueryCtx::create(nullptr, QueryConfig{std::move(configData)}),
+      "session 'session_timezone' set with invalid value 'invalid'");
 }
 
-TEST(TestQueryConfig, taskWriterCountConfig) {
+TEST_F(QueryConfigTest, taskWriterCountConfig) {
   struct {
     std::optional<int> numWriterCounter;
     std::optional<int> numPartitionedWriterCounter;
@@ -126,7 +91,8 @@ TEST(TestQueryConfig, taskWriterCountConfig) {
           QueryConfig::kTaskPartitionedWriterCount,
           std::to_string(testConfig.numPartitionedWriterCounter.value()));
     }
-    auto queryCtx = std::make_shared<QueryCtx>(nullptr, std::move(configData));
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
     const QueryConfig& config = queryCtx->queryConfig();
     ASSERT_EQ(config.taskWriterCount(), testConfig.expectedWriterCounter);
     ASSERT_EQ(
@@ -135,29 +101,33 @@ TEST(TestQueryConfig, taskWriterCountConfig) {
   }
 }
 
-TEST(TestQueryConfig, enableExpressionEvaluationCacheConfig) {
-  std::shared_ptr<memory::MemoryPool> rootPool_{
-      memory::defaultMemoryManager().addRootPool()};
-  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild("leaf")};
+TEST_F(QueryConfigTest, enableExpressionEvaluationCacheConfig) {
+  std::shared_ptr<memory::MemoryPool> rootPool{
+      memory::memoryManager()->addRootPool()};
+  std::shared_ptr<memory::MemoryPool> pool{rootPool->addLeafChild("leaf")};
 
   auto testConfig = [&](bool enableExpressionEvaluationCache) {
     std::unordered_map<std::string, std::string> configData(
         {{core::QueryConfig::kEnableExpressionEvaluationCache,
           enableExpressionEvaluationCache ? "true" : "false"}});
     auto queryCtx =
-        std::make_shared<core::QueryCtx>(nullptr, std::move(configData));
+        core::QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
     const core::QueryConfig& config = queryCtx->queryConfig();
     ASSERT_EQ(
         config.isExpressionEvaluationCacheEnabled(),
         enableExpressionEvaluationCache);
 
-    auto execCtx = std::make_shared<core::ExecCtx>(pool_.get(), queryCtx.get());
-    ASSERT_EQ(execCtx->exprEvalCacheEnabled(), enableExpressionEvaluationCache);
+    auto execCtx = std::make_shared<core::ExecCtx>(pool.get(), queryCtx.get());
+    ASSERT_EQ(
+        execCtx->optimizationParams().exprEvalCacheEnabled,
+        enableExpressionEvaluationCache);
     ASSERT_EQ(
         execCtx->vectorPool() != nullptr, enableExpressionEvaluationCache);
 
     auto evalCtx = std::make_shared<exec::EvalCtx>(execCtx.get());
-    ASSERT_EQ(evalCtx->cacheEnabled(), enableExpressionEvaluationCache);
+    ASSERT_EQ(
+        evalCtx->dictionaryMemoizationEnabled(),
+        enableExpressionEvaluationCache);
 
     // Test ExecCtx::selectivityVectorPool_.
     auto rows = execCtx->getSelectivityVector(100);
@@ -178,63 +148,58 @@ TEST(TestQueryConfig, enableExpressionEvaluationCacheConfig) {
   testConfig(false);
 }
 
-TEST(TestQueryConfig, capacityConversion) {
-  folly::Random::DefaultGenerator rng;
-  rng.seed(1);
-
-  std::unordered_map<CapacityUnit, std::string> unitStrLookup{
-      {CapacityUnit::BYTE, "B"},
-      {CapacityUnit::KILOBYTE, "kB"},
-      {CapacityUnit::MEGABYTE, "MB"},
-      {CapacityUnit::GIGABYTE, "GB"},
-      {CapacityUnit::TERABYTE, "TB"},
-      {CapacityUnit::PETABYTE, "PB"}};
-
-  std::vector<std::pair<CapacityUnit, double>> units{
-      {CapacityUnit::BYTE, 1},
-      {CapacityUnit::KILOBYTE, 1024},
-      {CapacityUnit::MEGABYTE, 1024 * 1024},
-      {CapacityUnit::GIGABYTE, 1024 * 1024 * 1024},
-      {CapacityUnit::TERABYTE, 1024ll * 1024 * 1024 * 1024},
-      {CapacityUnit::PETABYTE, 1024ll * 1024 * 1024 * 1024 * 1024}};
-  for (int32_t i = 0; i < units.size(); i++) {
-    for (int32_t j = 0; j < units.size(); j++) {
-      // We use this diffRatio to prevent float conversion overflow when
-      // converting from one unit to another.
-      uint64_t diffRatio = i < j ? units[j].second / units[i].second
-                                 : units[i].second / units[j].second;
-      uint64_t randNumber = folly::Random::rand64(rng);
-      uint64_t testNumber = i > j ? randNumber / diffRatio : randNumber;
-      ASSERT_EQ(
-          toCapacity(
-              std::string(
-                  std::to_string(testNumber) + unitStrLookup[units[i].first]),
-              units[j].first),
-          (uint64_t)(testNumber * (units[i].second / units[j].second)));
-    }
-  }
-}
+TEST_F(QueryConfigTest, expressionEvaluationRelatedConfigs) {
+  // Verify that the expression evaluation related configs are porpogated
+  // correctly to ExprCtx which is used during expression evaluation. Each
+  // config is individually set and verified.
+  std::shared_ptr<memory::MemoryPool> rootPool{
+      memory::memoryManager()->addRootPool()};
+  std::shared_ptr<memory::MemoryPool> pool{rootPool->addLeafChild("leaf")};
+
+  auto testConfig =
+      [&](std::unordered_map<std::string, std::string> configData) {
+        auto queryCtx =
+            core::QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+        const auto& queryConfig = queryCtx->queryConfig();
+        auto execCtx =
+            std::make_shared<core::ExecCtx>(pool.get(), queryCtx.get());
+        auto evalCtx = std::make_shared<exec::EvalCtx>(execCtx.get());
+
+        ASSERT_EQ(
+            evalCtx->peelingEnabled(),
+            !queryConfig.debugDisableExpressionsWithPeeling());
+        ASSERT_EQ(
+            evalCtx->sharedSubExpressionReuseEnabled(),
+            !queryConfig.debugDisableCommonSubExpressions());
+        ASSERT_EQ(
+            evalCtx->dictionaryMemoizationEnabled(),
+            !queryConfig.debugDisableExpressionsWithMemoization());
+        ASSERT_EQ(
+            evalCtx->deferredLazyLoadingEnabled(),
+            !queryConfig.debugDisableExpressionsWithLazyInputs());
+      };
+
+  auto createConfig = [&](bool debugDisableExpressionsWithPeeling,
+                          bool debugDisableCommonSubExpressions,
+                          bool debugDisableExpressionsWithMemoization,
+                          bool debugDisableExpressionsWithLazyInputs) -> auto {
+    std::unordered_map<std::string, std::string> configData(
+        {{core::QueryConfig::kDebugDisableExpressionWithPeeling,
+          std::to_string(debugDisableExpressionsWithPeeling)},
+         {core::QueryConfig::kDebugDisableCommonSubExpressions,
+          std::to_string(debugDisableCommonSubExpressions)},
+         {core::QueryConfig::kDebugDisableExpressionWithMemoization,
+          std::to_string(debugDisableExpressionsWithMemoization)},
+         {core::QueryConfig::kDebugDisableExpressionWithLazyInputs,
+          std::to_string(debugDisableExpressionsWithLazyInputs)}});
+    return configData;
+  };
 
-TEST(TestQueryConfig, durationConversion) {
-  folly::Random::DefaultGenerator rng;
-  rng.seed(1);
-
-  std::vector<std::pair<std::string, uint64_t>> units{
-      {"ns", 1},
-      {"us", 1000},
-      {"ms", 1000 * 1000},
-      {"s", 1000ll * 1000 * 1000},
-      {"m", 1000ll * 1000 * 1000 * 60},
-      {"h", 1000ll * 1000 * 1000 * 60 * 60},
-      {"d", 1000ll * 1000 * 1000 * 60 * 60 * 24}};
-  for (uint32_t i = 0; i < units.size(); i++) {
-    auto testNumber = folly::Random::rand32(rng) % 10000;
-    auto duration =
-        toDuration(std::string(std::to_string(testNumber) + units[i].first));
-    ASSERT_EQ(
-        testNumber * units[i].second,
-        std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count());
-  }
+  testConfig({}); // Verify default config.
+  testConfig(createConfig(true, false, false, false));
+  testConfig(createConfig(false, true, false, false));
+  testConfig(createConfig(false, false, true, false));
+  testConfig(createConfig(false, false, false, true));
 }
 
 } // namespace facebook::velox::core::test
diff --git a/velox/core/tests/TypeAnalysisTest.cpp b/velox/core/tests/TypeAnalysisTest.cpp
index a00896fc3a0e9..6e361d4bfe0c6 100644
--- a/velox/core/tests/TypeAnalysisTest.cpp
+++ b/velox/core/tests/TypeAnalysisTest.cpp
@@ -17,6 +17,8 @@
 #include <gtest/gtest.h>
 
 #include "velox/core/SimpleFunctionMetadata.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/type/Type.h"
 
 // Test for simple function type analysis.
@@ -70,10 +72,18 @@ class TypeAnalysisTest : public testing::Test {
   }
 
   template <typename... Args>
-  void testVariables(const std::set<std::string>& expected) {
+  void testPhysicalType(const TypePtr& expected) {
     TypeAnalysisResults results;
     (TypeAnalysis<Args>().run(results), ...);
-    ASSERT_EQ(expected, results.variables);
+    ASSERT_EQ(expected->toString(), results.physicalType->toString());
+  }
+
+  template <typename... Args>
+  void testVariables(
+      const std::map<std::string, exec::SignatureVariable>& expected) {
+    TypeAnalysisResults results;
+    (TypeAnalysis<Args>().run(results), ...);
+    ASSERT_EQ(expected, results.variablesInformation);
   }
 
   template <typename... Args>
@@ -99,6 +109,11 @@ TEST_F(TypeAnalysisTest, hasGeneric) {
 
   testHasGeneric<Map<Array<Any>, Array<int32_t>>>(true);
   testHasGeneric<Map<Array<Generic<T1>>, Array<int32_t>>>(true);
+  testHasGeneric<Map<Array<Generic<T1, true, true>>, Array<int32_t>>>(true);
+  testHasGeneric<Map<Array<Generic<T1, true, false>>, Array<int32_t>>>(true);
+  testHasGeneric<Map<Array<Comparable<T1>>, Array<int32_t>>>(true);
+  testHasGeneric<Map<Array<Orderable<T1>>, Array<int32_t>>>(true);
+
   testHasGeneric<Map<Array<int32_t>, Any>>(true);
   testHasGeneric<Variadic<Any>>(true);
   testHasGeneric<Any>(true);
@@ -130,6 +145,9 @@ TEST_F(TypeAnalysisTest, hasVariadicOfGeneric) {
   testHasVariadicOfGeneric<Any, Variadic<int32_t>>(false);
 
   testHasVariadicOfGeneric<Variadic<Any>>(true);
+  testHasVariadicOfGeneric<Variadic<Comparable<T2>>>(true);
+  testHasVariadicOfGeneric<Variadic<Generic<T2, true, false>>>(true);
+
   testHasVariadicOfGeneric<Variadic<Any>, int32_t>(true);
   testHasVariadicOfGeneric<int32_t, Variadic<Array<Any>>>(true);
   testHasVariadicOfGeneric<int32_t, Variadic<Map<int64_t, Array<Generic<T1>>>>>(
@@ -143,6 +161,9 @@ TEST_F(TypeAnalysisTest, countConcrete) {
   testCountConcrete<int32_t, int32_t, double>(3);
   testCountConcrete<Any>(0);
   testCountConcrete<Generic<T1>>(0);
+  testCountConcrete<Generic<T1, true, false>>(0);
+  testCountConcrete<Orderable<T1>>(0);
+
   testCountConcrete<Variadic<Any>>(0);
   testCountConcrete<Variadic<int32_t>>(1);
   testCountConcrete<Variadic<Array<Any>>>(1);
@@ -165,6 +186,10 @@ TEST_F(TypeAnalysisTest, testStringType) {
   testStringType<int64_t>({"bigint"});
   testStringType<double>({"double"});
   testStringType<float>({"real"});
+  testStringType<Date>({"date"});
+
+  testStringType<ShortDecimal<P1, S1>>({"decimal(i1,i5)"});
+  testStringType<LongDecimal<P1, S1>>({"decimal(i1,i5)"});
 
   testStringType<Array<int32_t>>({"array(integer)"});
   testStringType<Map<Any, int32_t>>({"map(any, integer)"});
@@ -181,21 +206,127 @@ TEST_F(TypeAnalysisTest, testStringType) {
       "map(array(integer), __user_T2)",
   });
 
+  testStringType<int32_t, int64_t, Map<Array<int32_t>, Orderable<T2>>>({
+      "integer",
+      "bigint",
+      "map(array(integer), __user_T2)",
+  });
+  testStringType<int32_t, int64_t, Map<Array<int32_t>, Comparable<T2>>>({
+      "integer",
+      "bigint",
+      "map(array(integer), __user_T2)",
+  });
   testStringType<Array<int32_t>>({"array(integer)"});
   testStringType<Map<int64_t, double>>({"map(bigint, double)"});
   testStringType<Row<Any, double, Generic<T1>>>(
       {"row(any, double, __user_T1)"});
+
+  testStringType<Json>({"json"});
+  testStringType<Array<Json>>({"array(json)"});
 }
 
 TEST_F(TypeAnalysisTest, testVariables) {
   testVariables<int32_t>({});
   testVariables<Array<int32_t>>({});
   testVariables<Any>({});
-  testVariables<Generic<T1>>({"__user_T1"});
+
+  testVariables<Generic<T1>>(
+      {{"__user_T1",
+        exec::SignatureVariable(
+            "__user_T1",
+            std::nullopt,
+            exec::ParameterType::kTypeParameter,
+            false,
+            false,
+            false)}});
+
+  testVariables<Orderable<T1>>(
+      {{"__user_T1",
+        exec::SignatureVariable(
+            "__user_T1",
+            std::nullopt,
+            exec::ParameterType::kTypeParameter,
+            false,
+            true /*orderableTypesOnly*/,
+            true)}});
+
+  testVariables<Generic<T1, true, true>>(
+      {{"__user_T1",
+        exec::SignatureVariable(
+            "__user_T1",
+            std::nullopt,
+            exec::ParameterType::kTypeParameter,
+            false,
+            true /*orderableTypesOnly*/,
+            true /*comparableTypesOnly*/)}});
+
+  testVariables<Comparable<T1>>(
+      {{"__user_T1",
+        exec::SignatureVariable(
+            "__user_T1",
+            std::nullopt,
+            exec::ParameterType::kTypeParameter,
+            false,
+            false /*orderableTypesOnly*/,
+            true /*comparableTypesOnly*/)}});
+
   testVariables<Map<Any, int32_t>>({});
   testVariables<Variadic<int32_t>>({});
-  testVariables<int32_t, Generic<T5>, Map<Array<int32_t>, Generic<T2>>>(
-      {"__user_T2", "__user_T5"});
+  testVariables<int32_t, Generic<T5>, Map<Array<int32_t>, Orderable<T2>>>(
+      {{"__user_T5",
+        exec::SignatureVariable(
+            "__user_T5",
+            std::nullopt,
+            exec::ParameterType::kTypeParameter,
+            false,
+            false /*orderableTypesOnly*/,
+            false /*comparableTypesOnly*/)},
+       {"__user_T2",
+        exec::SignatureVariable(
+            "__user_T2",
+            std::nullopt,
+            exec::ParameterType::kTypeParameter,
+            false,
+            true /*orderableTypesOnly*/,
+            true /*comparableTypesOnly*/)}});
+
+  testVariables<LongDecimal<P1, S1>>({
+      {"i1",
+       exec::SignatureVariable(
+           "i1",
+           std::nullopt,
+           exec::ParameterType::kIntegerParameter,
+           false,
+           false /*orderableTypesOnly*/,
+           false /*comparableTypesOnly*/)},
+      {"i5",
+       exec::SignatureVariable(
+           "i5",
+           std::nullopt,
+           exec::ParameterType::kIntegerParameter,
+           false,
+           false /*orderableTypesOnly*/,
+           false /*comparableTypesOnly*/)},
+  });
+
+  testVariables<ShortDecimal<P2, S2>>({
+      {"i2",
+       exec::SignatureVariable(
+           "i2",
+           std::nullopt,
+           exec::ParameterType::kIntegerParameter,
+           false,
+           false /*orderableTypesOnly*/,
+           false /*comparableTypesOnly*/)},
+      {"i6",
+       exec::SignatureVariable(
+           "i6",
+           std::nullopt,
+           exec::ParameterType::kIntegerParameter,
+           false,
+           false /*orderableTypesOnly*/,
+           false /*comparableTypesOnly*/)},
+  });
 }
 
 TEST_F(TypeAnalysisTest, testRank) {
@@ -210,12 +341,15 @@ TEST_F(TypeAnalysisTest, testRank) {
   testRank<Any>(3);
   testRank<Array<int32_t>, Any, Variadic<int32_t>>(3);
   testRank<Array<int32_t>, Generic<T2>>(3);
+  testRank<Array<int32_t>, Comparable<T2>>(3);
+
   testRank<Array<Any>, Generic<T2>>(3);
   testRank<Array<Any>, int32_t>(3);
   testRank<Array<int32_t>, Any, Any>(3);
 
   testRank<Variadic<Any>>(4);
   testRank<Array<int32_t>, Any, Variadic<Array<Any>>>(4);
+  testRank<Array<int32_t>, Any, Variadic<Array<Generic<T2, true, true>>>>(4);
 }
 
 TEST_F(TypeAnalysisTest, testPriority) {
@@ -239,5 +373,45 @@ TEST_F(TypeAnalysisTest, testPriority) {
       getPriority<Any, Variadic<Array<Any>>>(),
       getPriority<Any, Variadic<Any>>());
 }
+
+TEST_F(TypeAnalysisTest, physicalType) {
+  testPhysicalType<bool>(BOOLEAN());
+  testPhysicalType<int32_t>(INTEGER());
+  testPhysicalType<int64_t>(BIGINT());
+  testPhysicalType<float>(REAL());
+  testPhysicalType<double>(DOUBLE());
+  testPhysicalType<Date>(INTEGER());
+  testPhysicalType<Timestamp>(TIMESTAMP());
+  testPhysicalType<Varchar>(VARCHAR());
+  testPhysicalType<Varbinary>(VARBINARY());
+
+  testPhysicalType<ShortDecimal<P1, S1>>(BIGINT());
+  testPhysicalType<LongDecimal<P1, S1>>(HUGEINT());
+
+  testPhysicalType<Array<int32_t>>(ARRAY(INTEGER()));
+  testPhysicalType<Array<Date>>(ARRAY(INTEGER()));
+  testPhysicalType<Array<Array<float>>>(ARRAY(ARRAY(REAL())));
+  testPhysicalType<Array<Generic<T1>>>(ARRAY(UNKNOWN()));
+  testPhysicalType<Array<Array<Generic<T1>>>>(ARRAY(ARRAY(UNKNOWN())));
+  testPhysicalType<Array<ShortDecimal<P1, S1>>>(ARRAY(BIGINT()));
+
+  testPhysicalType<Map<int32_t, Varchar>>(MAP(INTEGER(), VARCHAR()));
+  testPhysicalType<Map<int32_t, Array<Date>>>(MAP(INTEGER(), ARRAY(INTEGER())));
+  testPhysicalType<Map<Generic<T1>, Generic<T2>>>(MAP(UNKNOWN(), UNKNOWN()));
+  testPhysicalType<Map<Generic<T1>, Array<Generic<T2>>>>(
+      MAP(UNKNOWN(), ARRAY(UNKNOWN())));
+  testPhysicalType<Map<int32_t, LongDecimal<P1, S1>>>(
+      MAP(INTEGER(), HUGEINT()));
+
+  testPhysicalType<Row<int32_t, Array<double>, Variadic<bool>>>(
+      ROW({INTEGER(), ARRAY(DOUBLE()), BOOLEAN()}));
+
+  testPhysicalType<Json>(VARCHAR());
+  testPhysicalType<Array<Json>>(ARRAY(VARCHAR()));
+
+  testPhysicalType<Any>(UNKNOWN());
+  testPhysicalType<Row<Date, Any>>(ROW({INTEGER(), UNKNOWN()}));
+}
+
 } // namespace
 } // namespace facebook::velox::core
diff --git a/velox/core/tests/TypedExprSerdeTest.cpp b/velox/core/tests/TypedExprSerdeTest.cpp
index 81d9a1eb18a04..d8110fd613119 100644
--- a/velox/core/tests/TypedExprSerdeTest.cpp
+++ b/velox/core/tests/TypedExprSerdeTest.cpp
@@ -23,6 +23,10 @@ namespace facebook::velox::core::test {
 class TypedExprSerDeTest : public testing::Test,
                            public velox::test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   TypedExprSerDeTest() {
     Type::registerSerDe();
 
@@ -54,6 +58,7 @@ TEST_F(TypedExprSerDeTest, fieldAccess) {
   std::shared_ptr<ITypedExpr> expression =
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a");
   testSerde(expression);
+  ASSERT_EQ(expression->toString(), "\"a\"");
 
   expression = std::make_shared<DereferenceTypedExpr>(
       VARCHAR(),
@@ -61,6 +66,7 @@ TEST_F(TypedExprSerDeTest, fieldAccess) {
           ROW({"a", "b"}, {VARCHAR(), BOOLEAN()}), "ab"),
       0);
   testSerde(expression);
+  ASSERT_EQ(expression->toString(), "\"ab\"[a]");
 }
 
 TEST_F(TypedExprSerDeTest, constant) {
@@ -113,19 +119,11 @@ TEST_F(TypedExprSerDeTest, call) {
 
 TEST_F(TypedExprSerDeTest, cast) {
   auto expression = std::make_shared<CastTypedExpr>(
-      BIGINT(),
-      std::vector<TypedExprPtr>{
-          std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "a"),
-      },
-      false);
+      BIGINT(), std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "a"), false);
   testSerde(expression);
 
   expression = std::make_shared<CastTypedExpr>(
-      VARCHAR(),
-      std::vector<TypedExprPtr>{
-          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a"),
-      },
-      true);
+      VARCHAR(), std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a"), true);
   testSerde(expression);
 }
 
diff --git a/velox/docs/README.md b/velox/docs/README.md
index 284a6b002abdd..a46cfaec06894 100644
--- a/velox/docs/README.md
+++ b/velox/docs/README.md
@@ -10,16 +10,9 @@ To install Sphinx: `easy_install -U sphinx`
 
 `sphinx-quickstart` command was used to generate the initial Makefile and config.
 
-### Building PyVelox Components
-
-If you're using a conda environment, it can be easily installed by `conda install` command.
-
-Pandoc is also used to generate `.rst` files from existing markdown files. Refer to installation
-instructions [here](https://pandoc.org/installing.html).
-
 To build the documentation, e.g. generate HTML files from .rst files:
 
-Run the `./scripts/gen-docs.sh` script from the base directory.
+Run `make html` from velox/docs.
 
 Navigate to
 `velox/docs/_build/html/index.html` in your browser to view the documentation.
@@ -39,7 +32,7 @@ directory to the top-level docs folder and push to gh-pages branch.
 git checkout -b update-docs main
 
 # Generate the documentation.
-./scripts/gen-docs.sh
+cd velox/docs && make html
 
 # Copy documentation files to the top-level docs folder.
 cp -R _build/html/* ../../docs
diff --git a/velox/docs/conf.py b/velox/docs/conf.py
index 119f90866aa4c..f2563eb218cd9 100644
--- a/velox/docs/conf.py
+++ b/velox/docs/conf.py
@@ -54,7 +54,6 @@
     "sphinx.ext.doctest",
     "sphinx.ext.mathjax",
     "sphinx.ext.viewcode",
-    "sphinx.ext.imgmath",
     "sphinx.ext.todo",
     "sphinx.ext.intersphinx",
     "sphinx.ext.autosummary",
diff --git a/velox/docs/configs.rst b/velox/docs/configs.rst
index 9a9b24f13bae2..bdcd28d054a8e 100644
--- a/velox/docs/configs.rst
+++ b/velox/docs/configs.rst
@@ -27,16 +27,26 @@ Generic Configuration
      - 10000
      - Max number of rows that could be return by operators from Operator::getOutput. It is used when an estimate of
        average row size is known and preferred_output_batch_bytes is used to compute the number of output rows.
+   * - table_scan_getoutput_time_limit_ms
+     - integer
+     - 5000
+     - TableScan operator will exit getOutput() method after this many milliseconds even if it has no data to return yet. Zero means 'no time limit'.
    * - abandon_partial_aggregation_min_rows
      - integer
      - 100,000
-     - Min number of rows when we check if a partial aggregation is not reducing the cardinality well and might be
-       a subject to being abandoned.
+     - Number of input rows to receive before starting to check whether to abandon partial aggregation.
    * - abandon_partial_aggregation_min_pct
      - integer
      - 80
-     - If a partial aggregation's number of output rows constitues this or highler percentage of the number of input rows,
-       then this partial aggregation will be a subject to being abandoned.
+     - Abandons partial aggregation if number of groups equals or exceeds this percentage of the number of input rows.
+   * - abandon_partial_topn_row_number_min_rows
+     - integer
+     - 100,000
+     - Number of input rows to receive before starting to check whether to abandon partial TopNRowNumber.
+   * - abandon_partial_topn_row_number_min_pct
+     - integer
+     - 80
+     - Abandons partial TopNRowNumber if number of output rows equals or exceeds this percentage of the number of input rows.
    * - session_timezone
      - string
      -
@@ -72,11 +82,27 @@ Generic Configuration
      - Size of buffer in the exchange client that holds data fetched from other nodes before it is processed.
        A larger buffer can increase network throughput for larger clusters and thus decrease query processing time
        at the expense of reducing the amount of memory available for other usage.
+   * - merge_exchange.max_buffer_size
+     - integer
+     - 128MB
+     - The aggregate buffer size (in bytes) across all exchange clients generated by the merge exchange operator,
+       responsible for storing data retrieved from various nodes prior to processing. It is divided
+       equally among all clients and has an upper and lower limit of 32MB and 1MB, respectively, per
+       client. Enforced approximately, not strictly. A larger size can increase network throughput
+       for larger clusters and thus decrease query processing time at the expense of reducing the
+       amount of memory available for other usage.
    * - max_page_partitioning_buffer_size
      - integer
      - 32MB
-     - The target size for a Task's buffered output. The producer Drivers are blocked when the buffered size exceeds this.
-       The Drivers are resumed when the buffered size goes below PartitionedOutputBufferManager::kContinuePct (90)% of this.
+     - The maximum size in bytes for the task's buffered output when output is partitioned using hash of partitioning keys. See PartitionedOutputNode::Kind::kPartitioned.
+       The producer Drivers are blocked when the buffered size exceeds this.
+       The Drivers are resumed when the buffered size goes below OutputBufferManager::kContinuePct (90)% of this.
+   * - max_output_buffer_size
+     - integer
+     - 32MB
+     - The maximum size in bytes for the task's buffered output.
+       The producer Drivers are blocked when the buffered size exceeds this.
+       The Drivers are resumed when the buffered size goes below OutputBufferManager::kContinuePct (90)% of this.
    * - min_table_rows_for_parallel_join_build
      - integer
      - 1000
@@ -92,6 +118,25 @@ Generic Configuration
      - true
      - Whether to enable caches in expression evaluation. If set to true, optimizations including vector pools and
        evalWithMemo are enabled.
+   * - max_shared_subexpr_results_cached
+     - integer
+     - 10
+     - For a given shared subexpression, the maximum distinct sets of inputs we cache results for. Lambdas can call
+       the same expression with different inputs many times, causing the results we cache to explode in size. Putting
+       a limit contains the memory usage.
+   * - driver_cpu_time_slice_limit_ms
+     - integer
+     - 0
+     - If it is not zero, specifies the time limit that a driver can continuously
+       run on a thread before yield. If it is zero, then it no limit.
+   * - prefixsort_normalized_key_max_bytes
+     - integer
+     - 128
+     - Maximum number of bytes to use for the normalized key in prefix-sort. Use 0 to disable prefix-sort.
+   * - prefixsort_min_rows
+     - integer
+     - 130
+     - Minimum number of rows to use prefix-sort. The default value has been derived using micro-benchmarking.
 
 .. _expression-evaluation-conf:
 
@@ -114,29 +159,31 @@ Expression Evaluation Configuration
      - false
      - Whether to track CPU usage for individual expressions (supported by call and cast expressions). Can be expensive
        when processing small batches, e.g. < 10K rows.
+   * - legacy_cast
+     - bool
+     - false
+     - Enables legacy CAST semantics if set to true. CAST(timestamp AS varchar) uses 'T' as separator between date and
+       time (instead of a space), and the year part is not padded.
    * - cast_match_struct_by_name
      - bool
      - false
      - This flag makes the Row conversion to by applied in a way that the casting row field are matched by name instead of position.
-   * - cast_to_int_by_truncate
+   * - debug_disable_expression_with_peeling
      - bool
      - false
-     - This flags forces the cast from float/double/decimal/string to integer to be performed by truncating the decimal part instead of rounding.
-   * - cast_string_to_date_is_iso_8601
+     - Disable optimization in expression evaluation to peel common dictionary layer from inputs. Should only be used for debugging.
+   * - debug_disable_common_sub_expressions
      - bool
-     - true
-     - If set, cast from string to date allows only ISO 8601 formatted strings: ``[+-](YYYY-MM-DD)``.
-       Otherwise, allows all patterns supported by Spark:
-         * ``[+-]yyyy*``
-         * ``[+-]yyyy*-[m]m``
-         * ``[+-]yyyy*-[m]m-[d]d``
-         * ``[+-]yyyy*-[m]m-[d]d *``
-         * ``[+-]yyyy*-[m]m-[d]dT*``
-       The asterisk ``*`` in ``yyyy*`` stands for any numbers.
-       For the last two patterns, the trailing ``*`` can represent none or any sequence of characters, e.g:
-         * "1970-01-01 123"
-         * "1970-01-01 (BC)"
-       Regardless of this setting's value, leading spaces will be trimmed.
+     - false
+     - Disable optimization in expression evaluation to re-use cached results for common sub-expressions. Should only be used for debugging.
+   * - debug_disable_expression_with_memoization
+     - bool
+     - false
+     - Disable optimization in expression evaluation to re-use cached results between subsequent input batches that are dictionary encoded and have the same alphabet(underlying flat vector). Should only be used for debugging.
+   * - debug_disable_expression_with_lazy_inputs
+     - bool
+     - false
+     - Disable optimization in expression evaluation to delay loading of lazy inputs unless required. Should only be used for debugging.
 
 Memory Management
 -----------------
@@ -182,29 +229,37 @@ Spilling
      - Spill memory to disk to avoid exceeding memory limits for the query.
    * - aggregation_spill_enabled
      - boolean
-     - false
-     - When `spill_enabled` is true, determines whether to spill memory to disk for aggregations to avoid exceeding
-       memory limits for the query.
+     - true
+     - When `spill_enabled` is true, determines whether HashAggregation operator can spill to disk under memory pressure.
    * - join_spill_enabled
      - boolean
-     - false
-     - When `spill_enabled` is true, determines whether to spill memory to disk for hash joins to avoid exceeding memory
-       limits for the query.
+     - true
+     - When `spill_enabled` is true, determines whether HashBuild and HashProbe operators can spill to disk under memory pressure.
    * - order_by_spill_enabled
      - boolean
-     - false
-     - When `spill_enabled` is true, determines whether to spill memory to disk for order by to avoid exceeding memory
-       limits for the query.
+     - true
+     - When `spill_enabled` is true, determines whether OrderBy operator can spill to disk under memory pressure.
+   * - window_spill_enabled
+     - boolean
+     - true
+     - When `spill_enabled` is true, determines whether Window operator can spill to disk under memory pressure.
+   * - row_number_spill_enabled
+     - boolean
+     - true
+     - When `spill_enabled` is true, determines whether RowNumber operator can spill to disk under memory pressure.
+   * - topn_row_number_spill_enabled
+     - boolean
+     - true
+     - When `spill_enabled` is true, determines whether TopNRowNumber operator can spill to disk under memory pressure.
+   * - writer_spill_enabled
+     - boolean
+     - true
+     - When `writer_spill_enabled` is true, determines whether TableWriter operator can flush the buffered data to disk
+       under memory pressure.
    * - aggregation_spill_memory_threshold
      - integer
      - 0
      - Maximum amount of memory in bytes that a final aggregation can use before spilling. 0 means unlimited.
-   * - aggregation_spill_all
-     - boolean
-     - false
-     - If true and spilling has been triggered during the input processing, the spiller will spill all the remaining
-     - in-memory state to disk before output processing. This is to simplify the aggregation query OOM prevention in
-     - output processing stage.
    * - join_spill_memory_threshold
      - integer
      - 0
@@ -213,6 +268,10 @@ Spilling
      - integer
      - 0
      - Maximum amount of memory in bytes that an order by can use before spilling. 0 means unlimited.
+   * - writer_flush_threshold_bytes
+     - integer
+     - 96MB
+     - Minimum memory footprint size required to reclaim memory from a file writer by flushing its buffered data to disk.
    * - min_spillable_reservation_pct
      - integer
      - 5
@@ -230,20 +289,41 @@ Spilling
        reservation grows along a series of powers of (1 + N / 100). If the memory reservation fails, it starts spilling.
    * - max_spill_level
      - integer
-     - 4
+     - 1
      - The maximum allowed spilling level with zero being the initial spilling level. Applies to hash join build
        spilling which might use recursive spilling when the build table is very large. -1 means unlimited.
        In this case an extremely large query might run out of spilling partition bits. The max spill level
        can be used to prevent a query from using too much io and cpu resources.
+   * - max_spill_run_rows
+     - integer
+     - 12582912
+     - The max number of rows to fill and spill for each spill run. This is used to cap the memory used for spilling.
+       If it is zero, then there is no limit and spilling might run out of memory. Based on offline test results, the
+       default value is set to 12 million rows which uses ~128MB memory when to fill a spill run.
+       Relation between spill rows and memory usage are as follows:
+         * ``12 million rows: 128 MB``
+         * ``30 million rows: 256 MB``
+         * ``60 million rows: 512 MB``
    * - max_spill_file_size
      - integer
      - 0
      - The maximum allowed spill file size. Zero means unlimited.
+   * - max_spill_bytes
+     - integer
+     - 107374182400
+     - The max spill bytes limit set for each query. This is used to cap the storage used for spilling.
+       If it is zero, then there is no limit and spilling might exhaust the storage or takes too long to run.
+       The default value is set to 100 GB.
    * - spill_write_buffer_size
      - integer
      - 4MB
      - The maximum size in bytes to buffer the serialized spill data before write to disk for IO efficiency.
        If set to zero, buffering is disabled.
+   * - spill_read_buffer_size
+     - integer
+     - 1MB
+     - The buffer size in bytes to read from one spilled file. If the underlying filesystem supports async
+       read, we do read-ahead with double buffering, which doubles the buffer used to read from each spill file.
    * - min_spill_run_size
      - integer
      - 256MB
@@ -262,22 +342,17 @@ Spilling
      - integer
      - 29
      - The start partition bit which is used with `spiller_partition_bits` together to calculate the spilling partition number.
-   * - join_spiller_partition_bits
-     - integer
-     - 2
-     - The number of bits (N) used to calculate the spilling partition number for hash join: 2 ^ N. At the moment the maximum
-       value is 3, meaning we only support up to 8-way spill partitioning.
-   * - aggregation_spiller_partition_bits
+   * - spiller_num_partition_bits
      - integer
-     - 0
-     - The number of bits (N) used to calculate the spilling partition number for hash aggregation: 2 ^ N. At the moment the
-       maximum value is 3, meaning we only support up to 8-way spill partitioning.
+     - 3
+     - The number of bits (N) used to calculate the spilling partition number for hash join and RowNumber: 2 ^ N. At the moment the maximum
+       value is 3, meaning we only support up to 8-way spill partitioning.ing.
    * - testing.spill_pct
      - integer
      - 0
      - Percentage of aggregation or join input batches that will be forced to spill for testing. 0 means no extra spilling.
 
-Table Writer
+Table Scan
 ------------
 .. list-table::
    :widths: 20 10 10 70
@@ -287,17 +362,13 @@ Table Writer
      - Type
      - Default Value
      - Description
-   * - task_writer_count
+   * - max_split_preload_per_driver
      - integer
-     - 1
-     - The number of parallel table writer threads per task.
-   * - task_partitioned_writer_count
-     - integer
-     - task_writer_count
-     - The number of parallel table writer threads per task for bucketed table writes. If not set, use 'task_writer_count' as default.
+     - 2
+     - Maximum number of splits to preload per driver. Set to 0 to disable preloading.
 
-Codegen Configuration
----------------------
+Table Writer
+------------
 .. list-table::
    :widths: 20 10 10 70
    :header-rows: 1
@@ -306,34 +377,36 @@ Codegen Configuration
      - Type
      - Default Value
      - Description
-   * - codegen.enabled
-     - boolean
-     - false
-     - Along with `codegen.configuration_file_path` enables codegen in task execution path.
-   * - codegen.configuration_file_path
-     - string
-     -
-     - A path to the file contaning codegen options.
-   * - codegen.lazy_loading
-     - boolean
-     - true
-     - Triggers codegen initialization tests upon loading if false. Otherwise skips them.
+   * - task_writer_count
+     - integer
+     - 1
+     - The number of parallel table writer threads per task.
+   * - task_partitioned_writer_count
+     - integer
+     - task_writer_count
+     - The number of parallel table writer threads per task for bucketed table writes. If not set, use 'task_writer_count' as default.
 
 Hive Connector
 --------------
+Hive Connector config is initialized on velox runtime startup and is shared among queries as the default config.
+Each query can override the config by setting corresponding query session properties such as in Prestissimo.
+
 .. list-table::
-   :widths: 20 10 10 70
+   :widths: 20 20 10 10 70
    :header-rows: 1
 
-   * - Property Name
+   * - Configuration Property Name
+     - Session Property Name
      - Type
      - Default Value
      - Description
-   * - max_partitions_per_writers
+   * - hive.max-partitions-per-writers
+     -
      - integer
      - 100
      - Maximum number of (bucketed) partitions per a single table writer instance.
-   * - insert_existing_partitions_behavior
+   * - insert-existing-partitions-behavior
+     - insert_existing_partitions_behavior
      - string
      - ERROR
      - **Allowed values:** ``OVERWRITE``, ``ERROR``. The behavior on insert existing partitions. This property only derives
@@ -341,23 +414,133 @@ Hive Connector
        sets the update mode to indicate overwriting a partition if exists. ``ERROR`` sets the update mode to indicate
        error throwing if writing to an existing partition.
    * - hive.immutable-partitions
+     -
      - bool
      - false
      - True if appending data to an existing unpartitioned table is allowed. Currently this configuration does not
        support appending to existing partitions.
-   * - file_column_names_read_as_lower_case
+   * - file-column-names-read-as-lower-case
+     -
      - bool
      - false
      - True if reading the source file column names as lower case, and planner should guarantee
        the input column name and filter is also lower case to achive case-insensitive read.
+   * - partition_path_as_lower_case
+     -
+     - bool
+     - true
+     - If true, the partition directory will be converted to lowercase when executing a table write operation.
+   * - allow-null-partition-keys
+     - allow_null_partition_keys
+     - bool
+     - true
+     - Determines whether null values for partition keys are allowed or not. If not, fails with "Partition key must
+       not be null" error message when writing data with null partition key.
+       Null check for partitioning key should be used only when partitions are generated dynamically during query execution.
+       For queries that write to fixed partitions, this check should happen much earlier before the Velox execution even starts.
+   * - ignore_missing_files
+     -
+     - bool
+     - false
+     - If true, splits that refer to missing files don't generate errors and are processed as empty splits.
    * - max-coalesced-bytes
+     -
      - integer
-     - 512KB
+     - 128MB
      - Maximum size in bytes to coalesce requests to be fetched in a single request.
    * - max-coalesced-distance-bytes
+     -
      - integer
-     - 128MB
+     - 512KB
      - Maximum distance in bytes between chunks to be fetched that may be coalesced into a single request.
+   * - load-quantum
+     -
+     - integer
+     - 8MB
+     - Define the size of each coalesce load request. E.g. in Parquet scan, if it's bigger than rowgroup size then the whole row group can be fetched together. Otherwise, the row group will be fetched column chunk by column chunk
+   * - num-cached-file-handles
+     -
+     - integer
+     - 20000
+     - Maximum number of entries in the file handle cache. The value must be non-negative. Zero value
+       indicates infinite cache capacity.
+   * - file-handle-cache-enabled
+     -
+     - bool
+     - true
+     - Enables caching of file handles if true. Disables caching if false. File handle cache should be
+       disabled if files are not immutable, i.e. file content may change while file path stays the same.
+   * - sort-writer-max-output-rows
+     - sort_writer_max_output_rows
+     - integer
+     - 1024
+     - Maximum number of rows for sort writer in one batch of output. This is to limit the memory usage of sort writer.
+   * - sort-writer-max-output-bytes
+     - sort_writer_max_output_bytes
+     - string
+     - 10MB
+     - Maximum bytes for sort writer in one batch of output. This is to limit the memory usage of sort writer.
+   * - file-preload-threshold
+     -
+     - integer
+     - 8MB
+     - Usually Velox fetches the meta data firstly then fetch the rest of file. But if the file is very small, Velox can fetch the whole file directly to avoid multiple IO requests.
+       The parameter controls the threshold when whole file is fetched.
+   * - footer-estimated-size
+     -
+     - integer
+     - 1MB
+     - Define the estimation of footer size in ORC and Parquet format. The footer data includes version, schema, and meta data for every columns which may or may not need to be fetched later.
+       The parameter controls the size when footer is fetched each time. Bigger value can decrease the IO requests but may fetch more useless meta data.
+   * - hive.orc.writer.stripe-max-size
+     - orc_optimized_writer_max_stripe_size
+     - string
+     - 64M
+     - Maximum stripe size in orc writer.
+   * - hive.orc.writer.dictionary-max-memory
+     - orc_optimized_writer_max_dictionary_memory
+     - string
+     - 16M
+     - Maximum dictionary memory that can be used in orc writer.
+   * - hive.orc.writer.integer-dictionary-encoding-enabled
+     - orc_optimized_writer_integer_dictionary_encoding_enabled
+     - bool
+     - true
+     - Whether or not dictionary encoding of integer types should be used by the ORC writer.
+   * - hive.orc.writer.string-dictionary-encoding-enabled
+     - orc_optimized_writer_string_dictionary_encoding_enabled
+     - bool
+     - true
+     - Whether or not dictionary encoding of string types should be used by the ORC writer.
+   * - hive.parquet.writer.timestamp-unit
+     - hive.parquet.writer.timestamp_unit
+     - tinyint
+     - 9
+     - Timestamp unit used when writing timestamps into Parquet through Arrow bridge.
+       Valid values are 0 (second), 3 (millisecond), 6 (microsecond), 9 (nanosecond).
+   * - hive.orc.writer.linear-stripe-size-heuristics
+     - orc_writer_linear_stripe_size_heuristics
+     - bool
+     - true
+     - Enables historical based stripe size estimation after compression.
+   * - hive.orc.writer.min-compression-size
+     - orc_writer_min_compression_size
+     - integer
+     - 1024
+     - Minimal number of items in an encoded stream.
+   * - hive.orc.writer.compression-level
+     - orc_optimized_writer_compression_level
+     - tinyint
+     - 3 for ZSTD and 4 for ZLIB
+     - The compression level to use with ZLIB and ZSTD.
+   * - cache.no_retention
+     - cache.no_retention
+     - bool
+     - false
+     - If true, evict out a query scanned data out of in-memory cache right after the access,
+       and also skip staging to the ssd cache. This helps to prevent the cache space pollution
+       from the one-time table scan by large batch query when mixed running with interactive
+       query which has high data locality.
 
 
 ``Amazon S3 Configuration``
@@ -372,7 +555,7 @@ Hive Connector
      - Description
    * - hive.s3.use-instance-credentials
      - bool
-     - true
+     - false
      - Use the EC2 metadata service to retrieve API credentials. This works with IAM roles in EC2.
    * - hive.s3.aws-access-key
      - string
@@ -408,7 +591,34 @@ Hive Connector
      - string
      - velox-session
      - Session name associated with the IAM role.
-
+   * - hive.s3.use-proxy-from-env
+     - bool
+     - false
+     - Utilize the configuration of the environment variables http_proxy, https_proxy, and no_proxy for use with the S3 API.
+   * - hive.s3.connect-timeout
+     - string
+     -
+     - Socket connect timeout.
+   * - hive.s3.socket-timeout
+     - string
+     -
+     - Socket read timeout.
+   * - hive.s3.max-connections
+     - integer
+     -
+     - Maximum concurrent TCP connections for a single http client.
+   * - hive.s3.max-attempts
+     - integer
+     -
+     - Maximum attempts for connections to a single http client, work together with retry-mode. By default, it's 3 for standard/adaptive mode
+       and 10 for legacy mode.
+   * - hive.s3.retry-mode
+     - string
+     -
+     - **Allowed values:** "standard", "adaptive", "legacy". By default it's empty, S3 client will be created with RetryStrategy.
+       Legacy mode only enables throttled retry for transient errors.
+       Standard mode is built on top of legacy mode and has throttled retry enabled for throttling errors apart from transient errors.
+       Adaptive retry mode dynamically limits the rate of AWS requests to maximize success rate.
 ``Google Cloud Storage Configuration``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 .. list-table::
@@ -431,6 +641,31 @@ Hive Connector
      - string
      -
      - The GCS service account configuration as json string.
+   * - hive.gcs.max-retry-count
+     - integer
+     -
+     - The GCS maximum retry counter of transient errors.
+   * - hive.gcs.max-retry-time
+     - string
+     -
+     - The GCS maximum time allowed to retry transient errors.
+
+``Azure Blob Storage Configuration``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. list-table::
+   :widths: 30 10 10 60
+   :header-rows: 1
+
+   * - Property Name
+     - Type
+     - Default Value
+     - Description
+   * - fs.azure.account.key.<storage-account>.dfs.core.windows.net
+     - string
+     -
+     -  The credentials to access the specific Azure Blob Storage account, replace <storage-account> with the name of your Azure Storage account.
+        This property aligns with how Spark configures Azure account key credentials for accessing Azure storage, by setting this property multiple
+        times with different storage account names, you can access multiple Azure storage accounts.
 
 Presto-specific Configuration
 -----------------------------
@@ -474,3 +709,31 @@ Spark-specific Configuration
      - 4194304
      - The maximum number of bits to use for the bloom filter in :spark:func:`bloom_filter_agg` function,
        the value of this config can not exceed the default value.
+   * - spark.partition_id
+     - integer
+     -
+     - The current task's Spark partition ID. It's set by the query engine (Spark) prior to task execution.
+
+Tracing
+--------
+.. list-table::
+   :widths: 30 10 10 70
+   :header-rows: 1
+
+   * - Property Name
+     - Type
+     - Default Value
+     - Description
+   * - query_trace_enabled
+     - bool
+     - true
+     - If true, enable query tracing.
+   * - query_trace_dir
+     - string
+     -
+     - The root directory to store the tracing data and metadata for a query.
+   * - query_trace_node_ids
+     - string
+     -
+     - A comma-separated list of plan node ids whose input data will be trace. If it is empty, then we only trace the
+       query metadata which includes the query plan and configs etc.
diff --git a/velox/docs/develop.rst b/velox/docs/develop.rst
index 1d0fc590f00d3..eedaed1eb8894 100644
--- a/velox/docs/develop.rst
+++ b/velox/docs/develop.rst
@@ -11,10 +11,12 @@ This guide is intended for Velox contributors and developers of Velox-based appl
     develop/vectors
     develop/scalar-functions
     develop/aggregate-functions
+    develop/view-and-writer-types
     develop/lambda-functions
     develop/expression-evaluation
     develop/dictionary-encoding
     develop/arena
+    develop/hash-table
     develop/aggregations
     develop/connectors
     develop/joins
@@ -22,8 +24,11 @@ This guide is intended for Velox contributors and developers of Velox-based appl
     develop/operators
     develop/task
     develop/simd
+    develop/memory
     develop/spilling
     develop/serde
+    develop/timestamp
     develop/testing
     develop/debugging
     develop/TpchBenchmark
+    develop/window
diff --git a/velox/docs/develop/TpchBenchmark.rst b/velox/docs/develop/TpchBenchmark.rst
index 778d27248bff1..23ba28b5d02a5 100644
--- a/velox/docs/develop/TpchBenchmark.rst
+++ b/velox/docs/develop/TpchBenchmark.rst
@@ -16,7 +16,7 @@ following command line to do the build with S3 support:
 
 .. code:: shell
 
-   $ make release EXTRA_CMAKE_FLAGS="-DVELOX_BUILD_BENCHMARKS=ON -DVELOX_ENABLE_S3=ON"
+   $ make benchmarks-build EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_S3=ON"
 
 ----
 
diff --git a/velox/docs/develop/aggregate-functions.rst b/velox/docs/develop/aggregate-functions.rst
index ed5007b336202..8c60890dfcf47 100644
--- a/velox/docs/develop/aggregate-functions.rst
+++ b/velox/docs/develop/aggregate-functions.rst
@@ -109,24 +109,337 @@ accordingly.  Data is stored in the following order:
 .. image:: images/aggregation-layout.png
   :width: 600
 
-Aggregate class
----------------
-
-To add an aggregate function,
+To add an aggregate function, there are two options: implementing it as a
+simple function or as a vector function. The simple-function interface allows
+the author to write methods that process input data one row at a time and not
+handle input vector encodings themselves. However, the simple-function
+interface currently has certain limitations, such as not allowing for advanced
+performance optimization on constant inputs. Aggregation functions that
+require such functionalities can be implemented through the vector-function
+interface. With the vector-function interface, the author writes methods that
+process one vector at a time and handles input vector encodings by themselves.
 
 * Prepare:
     * Figure out what are the input, intermediate and final types.
     * Figure out what are partial and final calculations.
     * Design the accumulator. Make sure the same accumulator can accept both raw
       inputs and intermediate results.
-    * Create a new class that extends velox::exec::Aggregate base class
+    * If implementing a simple function, create a class for the function according
+      to instructions below; If implementing a vector function,
+      create a new class that extends velox::exec::Aggregate base class
       (see velox/exec/Aggregate.h) and implement virtual methods.
 * Register the new function using exec::registerAggregateFunction(...).
 * Add tests.
 * Write documentation.
 
+Simple Function Interface
+-------------------------
+
+This section describes the main concepts and the simple interface of
+aggregation functions. Examples of aggregation functions implemented through
+the simple-function interface can be found at velox/exec/tests/SimpleAverageAggregate.cpp
+and velox/exec/tests/SimpleArrayAggAggregate.cpp.
+
+A simple aggregation function is implemented as a class as the following.
+
+.. code-block:: c++
+
+  // array_agg(T) -> array(T) -> array(T)
+  class ArrayAggAggregate {
+   public:
+    // Type(s) of input vector(s) wrapped in Row.
+    using InputType = Row<Generic<T1>>;
+    using IntermediateType = Array<Generic<T1>>;
+    using OutputType = Array<Generic<T1>>;
+
+    // Optional. Default is true.
+    static constexpr bool default_null_behavior_ = false;
+
+    // Optional.
+    static bool toIntermediate(
+      exec::out_type<Array<Generic<T1>>>& out,
+      exec::optional_arg_type<Generic<T1>> in);
+
+    struct AccumulatorType { ... };
+  };
+
+The author declares the function's input type, intermediate type, and output
+type in the simple aggregation function class. The input type must be the
+function's argument type(s) wrapped in a Row<> even if the function only takes
+one argument. This is needed for the SimpleAggregateAdapter to parse input
+types for arbitrary aggregation functions properly.
+
+The author can define an optional flag `default_null_behavior_` indicating
+whether the aggregation function has default-null behavior. This flag is true
+by default. Next, the class can have an optional method `toIntermediate()`
+that converts the aggregation function's raw input directly to its intermediate
+states. Finally, the author must define a struct named `AccumulatorType` in
+the aggregation function class. We explain each part in more details below.
+
+Default-Null Behavior
+^^^^^^^^^^^^^^^^^^^^^
+
+When adding raw inputs or intermediate states to accumulators, aggregation
+functions of default-null behavior ignore the input values that are nulls. For
+raw inputs that consist of multiple columns, an entire row is ignored if at
+least one column is null at this row. Below is an example.
+
+.. code-block:: sql
+
+  SELECT sum(c0) FROM (values (cast(NULL as bigint), 10), (NULL, 20), (NULL, 30)) AS t(c0, c1); -- NULL
+
+When generating intermediate or final output results from accumulators,
+aggregation functions of default-null behavior produce nulls for groups of no
+input row or only null rows. Another example is given below.
+
+.. code-block:: sql
+
+  SELECT sum(c0) FROM (values (1, 10), (2, 20), (3, 30)) AS t(c0, c1) WHERE c1 > 40; -- NULL
+
+Most aggregation functions have default-null behavior. An example is in
+SimpleAverageAggregate.cpp. On the other hand, SimpleArrayAggAggregate.cpp has
+an example of non-default-null behavior.
+
+This flag affects the C++ function signatures of `toIntermediate()` and methods
+in the `AccumulatorType` struct.
+
+toIntermediate
+^^^^^^^^^^^^^^
+
+The author can optionally define a static method `toIntermediate()` that
+converts a raw input to an intermediate state. If defined, this function is
+used in query plans that abandon the partial aggregation step. If the aggregaiton function has
+default-null behavior, the toIntermediate() function has an out-parameter
+of the type `exec::out_type<IntermediateType>&` followed by in-parameters of
+the type `exec::arg_type<T>` for each `T` wrapped inside InputType . If the
+aggregation function has non-default null behavior, the in-parameters of
+toIntermediate() are of the type `exec::optional_arg_type<T>` instead.
+
+When `T` is a primitive type except Varchar and Varbinary, `exec::arg_type<T>`
+is simply `T` itself and `exec::out_type<T>` is `T&`. `exec::optional_arg_type<T>`
+is `std::optional<T>`.
+
+When `T` is Varchar, Varbinary, or a complex type, `exec::arg_type<T>`,
+`exec::optional_arg_type<T>`, and `exec::out_type<T>` are the corresponding
+view and writer types of `T`. A detailed explanation can be found in :doc:`view-and-writer-types`.
+
+.. list-table::
+   :widths: 25 25
+   :header-rows: 1
+
+   * - Default-Null Behavior
+     - Non-Default-Null Behavior
+   * - static bool SimpleAverageAggregate::toIntermediate(
+          exec::out_type<Row<double, int64_t>>& out,
+          exec::arg_type<T> in);
+     - static bool SimpleArrayAggAggregate::toIntermediate(
+          exec::out_type<Array<Generic<T1>>>& out,
+          exec::optional_arg_type<Generic<T1>> in);
+
+AccumulatorType of Default-Null Behavior
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+For aggregaiton functions of default-null behavior, the author defines an
+`AccumulatorType` struct as follows.
+
+.. code-block:: c++
+
+  struct AccumulatorType {
+    // Author defines data members
+    ...
+
+    // Optional. Default is true.
+    static constexpr bool is_fixed_size_ = false;
+
+    // Optional. Default is false.
+    static constexpr bool use_external_memory_ = true;
+
+    // Optional. Default is false.
+    static constexpr bool is_aligned_ = true;
+
+    explicit AccumulatorType(HashStringAllocator* allocator);
+
+    void addInput(HashStringAllocator* allocator, exec::arg_type<T1> value1, ...);
+
+    void combine(
+        HashStringAllocator* allocator,
+        exec::arg_type<IntermediateType> other);
+
+    bool writeIntermediateResult(exec::out_type<IntermediateType>& out);
+
+    bool writeFinalResult(exec::out_type<OutputType>& out);
+
+    // Optional. Called during destruction.
+    void destroy(HashStringAllocator* allocator);
+  };
+
+The author defines an optional flag `is_fixed_size_` indicating whether the
+every accumulator takes fixed amount of memory. This flag is true by default.
+Next, the author defines another optional flag `use_external_memory_`
+indicating whether the accumulator uses memory that is not tracked by Velox.
+This flag is false by default. Then, the author can define an optional flag
+`is_aligned_` indicating whether the accumulator requires aligned
+access. This flag is false by default.
+
+The author defines a constructor that takes a single argument of
+`HashStringAllocator*`. This constructor is called before aggregation starts to
+initialize all accumulators.
+
+The author can also optionally define a `destroy` function that is called when
+*this* accumulator object is destructed.
+
+Notice that `writeIntermediateResult` and `writeFinalResult` are expected to not
+modify contents in the accumulator.
+
+addInput
+""""""""
+
+This method adds raw input values to *this* accumulator. It receives a
+`HashStringAllocator*` followed by `exec::arg_type<T1>`-typed values, one for
+each argument type `Ti` wrapped in InputType.
+
+With default-null behavior, raw-input rows where at least one column is null are
+ignored before `addInput` is called. After `addInput` is called, *this*
+accumulator is assumed to be non-null.
+
+combine
+"""""""
+
+This method adds an input intermediate state to *this* accumulator. It receives
+a `HashStringAllocator*` and one `exec::arg_type<IntermediateType>` value. With
+default-null behavior, nulls among the input intermediate states are ignored
+before `combine` is called. After `combine` is called, *this*  accumulator is
+assumed to be non-null.
+
+writeIntermediateResult
+"""""""""""""""""""""""
+
+This method writes *this* accumulator out to an intermediate state vector. It
+has an out-parameter of the type `exec::out_type<IntermediateType>&`. This
+method returns true if it writes a non-null value to `out`, or returns false
+meaning a null should be written to the intermediate state vector. Accumulators
+that are nulls (i.e., no value has been added to them) automatically become
+nulls in the intermediate state vector without `writeIntermediateResult` being
+called.
+
+writeFinalResult
+""""""""""""""""
+
+This method writes *this* accumulator out to a final result vector. It
+has an out-parameter of the type `exec::out_type<OutputType>&`. This
+method returns true if it writes a non-null value to `out`, or returns false
+meaning a null should be written to the final result vector. Accumulators
+that are nulls (i.e., no value has been added to them) automatically become
+nulls in the final result vector without `writeFinalResult` being called.
+
+AccumulatorType of Non-Default-Null Behavior
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+For aggregaiton functions of non-default-null behavior, the author defines an
+`AccumulatorType` struct as follows.
+
+.. code-block:: c++
+
+  struct AccumulatorType {
+    // Author defines data members
+    ...
+
+    // Optional. Default is true.
+    static constexpr bool is_fixed_size_ = false;
+
+    // Optional. Default is false.
+    static constexpr bool use_external_memory_ = true;
+
+    // Optional. Default is false.
+    static constexpr bool is_aligned_ = true;
+
+    explicit AccumulatorType(HashStringAllocator* allocator);
+
+    bool addInput(HashStringAllocator* allocator, exec::optional_arg_type<T1> value1, ...);
+
+    bool combine(
+        HashStringAllocator* allocator,
+        exec::optional_arg_type<IntermediateType> other);
+
+    bool writeIntermediateResult(bool nonNullGroup, exec::out_type<IntermediateType>& out);
+
+    bool writeFinalResult(bool nonNullGroup, exec::out_type<OutputType>& out);
+
+    // Optional.
+    void destroy(HashStringAllocator* allocator);
+  };
+
+The definition of `is_fixed_size_`, `use_external_memory_`,
+`is_aligned_`, the constructor, and the `destroy` method are exactly
+the same as those for default-null behavior.
+
+On the other hand, the C++ function signatures of `addInput`, `combine`,
+`writeIntermediateResult`, and `writeFinalResult` are different.
+
+Same as the case for default-null behavior, `writeIntermediateResult` and
+`writeFinalResult` are expected to not modify contents in the accumulator.
+
+addInput
+""""""""
+
+This method receives a `HashStringAllocator*` followed by
+`exec::optional_arg_type<T1>` values, one for each argument type `Ti` wrapped
+in InputType.
+
+This method is called on all raw-input rows even if some columns may be null.
+It returns a boolean meaning whether *this* accumulator is non-null after the
+call. All accumulators are initialized to *null* before aggregation starts. An
+accumulator that is originally null can be turned to non-null. But an
+accumulator that's already non-null remains non-null regardless of the return
+value of `addInput`.
+
+combine
+"""""""
+
+This method receives a `HashStringAllocator*` and an
+`exec::optional_arg_type<IntermediateType>` value. This method is called on
+all intermediate states even if some are nulls. Same as `addInput`, this method
+returns a boolean meaning whether *this* accumulator is non-null after the call.
+
+writeIntermediateResult
+"""""""""""""""""""""""
+
+This method has an out-parameter of the type `exec::out_type<IntermediateType>&`
+and a boolean flag `nonNullGroup` indicating whether *this* accumulator is
+non-null. This method returns true if it writes a non-null value to `out`, or
+return false meaning a null should be written to the intermediate state vector.
+
+writeFinalResult
+""""""""""""""""
+
+This method writes *this* accumulator out to a final result vector. It has an
+out-parameter of the type `exec::out_type<OutputType>&` and a boolean flag
+`nonNullGroup` indicating whether *this* accumulator is non-null. This method
+returns true if it writes a non-null value to `out`, or return false meaning a
+null should be written to the final result vector.
+
+Limitations
+^^^^^^^^^^^
+
+The simple aggregation function interface currently has three limitations.
+
+1. All values read or written by the aggrgeaiton function must be part of the
+   accumulators. This means that there cannot be function-level states kept
+   outside of accumulators.
+
+2. Optimizations on constant inputs is not supported. I.e., constant input
+   arguments are processed once per row in the same way as non-constant inputs.
+
+3. Aggregation pushdown to table scan is not supported yet. We're planning to
+   add this support.
+
+Vector Function Interface
+-------------------------
+
+Aggregation functions that cannot use the simple-function interface can be written as vector funcitons.
+
 Accumulator size
-----------------
+^^^^^^^^^^^^^^^^
 
 The implementation of the velox::exec::Aggregate interface can start with *accumulatorFixedWidthSize()* method.
 
@@ -158,7 +471,21 @@ location of the accumulator.
       // @param offset Offset in bytes from the start of the row of the accumulator
       // @param nullByte Offset in bytes from the start of the row of the null flag
       // @param nullMask The specific bit in the nullByte that stores the null flag
-      void setOffsets(int32_t offset, int32_t nullByte, uint8_t nullMask)
+      // @param initializedByte Offset in bytes from the start of the row of the
+      // initialized flag
+      // @param initializedMask The specific bit in the initializedByte that stores
+      // the initialized flag
+      // @param rowSizeOffset The offset of a uint32_t row size from the start of
+      // the row. Only applies to accumulators that store variable size data out of
+      // line. Fixed length accumulators do not use this. 0 if the row does not have
+      // a size field.
+      void setOffsets(
+        int32_t offset,
+        int32_t nullByte,
+        uint8_t nullMask,
+        int32_t initializedByte,
+        int8_t initializedMask,
+        int32_t rowSizeOffset)
 
 The base class implements the setOffsets method by storing the offsets in member variables.
 
@@ -167,9 +494,20 @@ The base class implements the setOffsets method by storing the offsets in member
       // Byte position of null flag in group row.
       int32_t nullByte_;
       uint8_t nullMask_;
+      // Byte position of the initialized flag in group row.
+      int32_t initializedByte_;
+      uint8_t initializedMask_;
       // Offset of fixed length accumulator state in group row.
       int32_t offset_;
 
+      // Offset of uint32_t row byte size of row. 0 if there are no
+      // variable width fields or accumulators on the row.  The size is
+      // capped at 4G and will stay at 4G and not wrap around if growing
+      // past this. This serves to track the batch size when extracting
+      // rows. A size in excess of 4G would finish the batch in any case,
+      // so larger values need not be represented.
+      int32_t rowSizeOffset_ = 0;
+
 Typically, an aggregate function doesn’t use the offsets directly. Instead, it uses helper methods from the base class.
 
 To access the accumulator:
@@ -194,25 +532,25 @@ To manipulate the null flags:
       inline bool clearNull(char* group);
 
 Initialization
---------------
+^^^^^^^^^^^^^^
 
-Once you have accumulatorFixedWidthSize(), the next method to implement is initializeNewGroups().
+Once you have accumulatorFixedWidthSize(), the next method to implement is initializeNewGroupsInternal().
 
 .. code-block:: c++
 
       // Initializes null flags and accumulators for newly encountered groups.
       // @param groups Pointers to the start of the new group rows.
       // @param indices Indices into 'groups' of the new entries.
-      virtual void initializeNewGroups(
+      virtual void initializeNewGroupsInternal(
           char** groups,
           folly::Range<const vector_size_t*> indices) = 0;
 
 This method is called by the HashAggregation operator every time it encounters new combinations of the grouping keys. This method should initialize the accumulators for the new groups. For example, partial “count” and “sum” aggregates would set the accumulators to zero. Many aggregate functions would set null flags to true by calling the exec::Aggregate::setAllNulls(groups, indices) helper method.
 
 GroupBy aggregation
--------------------
+^^^^^^^^^^^^^^^^^^^
 
-At this point you have accumulatorFixedWidthSize() and initializeNewGroups() methods implemented. Now, we can proceed to implementing the end-to-end group-by aggregation. We need the following pieces:
+At this point you have accumulatorFixedWidthSize() and initializeNewGroupsInternal() methods implemented. Now, we can proceed to implementing the end-to-end group-by aggregation. We need the following pieces:
 
 * Logic for adding raw input to the accumulator:
     * addRawInput() method.
@@ -306,6 +644,7 @@ After implementing the addRawInput() method, we proceed to adding logic for extr
 .. code-block:: c++
 
       // Extracts partial results (used for partial and intermediate aggregations).
+      // This method is expected to not modify contents in accumulators.
       // @param groups Pointers to the start of the group rows.
       // @param numGroups Number of groups to extract results from.
       // @param result The result vector to store the results in.
@@ -326,7 +665,8 @@ Next, we implement the extractValues() method that extracts final results from t
 
 .. code-block:: c++
 
-      // Extracts final results (used for final and single aggregations).
+      // Extracts final results (used for final and single aggregations). This method
+      // is expected to not modify contents in accumulators.
       // @param groups Pointers to the start of the group rows.
       // @param numGroups Number of groups to extract results from.
       // @param result The result vector to store the results in.
@@ -393,7 +733,7 @@ implement toIntermediate() method which simply returns the input unmodified.
 GroupBy aggregation code path is done. We proceed to global aggregation.
 
 Global aggregation
-------------------
+^^^^^^^^^^^^^^^^^^
 
 Global aggregation is similar to group-by aggregation, but there is only one
 group and one accumulator. After implementing group-by aggregation, the only
@@ -485,11 +825,11 @@ input type and result type.
 
 .. code-block:: c++
 
-        bool registerApproxPercentile(const std::string& name) {
-          std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+        exec::AggregateRegistrationResult registerApproxPercentile(const std::string& name) {
+            std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
           ...
 
-          exec::registerAggregateFunction(
+          return exec::registerAggregateFunction(
               name,
               std::move(signatures),
               [name](
@@ -514,12 +854,38 @@ input type and result type.
                   ...
                 }
               });
-          return true;
         }
 
         static bool FB_ANONYMOUS_VARIABLE(g_AggregateFunction) =
             registerApproxPercentile(kApproxPercentile);
 
+If the aggregation function is implemented through the simple-function
+interface, use `SimpleAggregateAdapter<FunctionClassName>` when creating the
+unique pointers. Below is an example.
+
+.. code-block:: c++
+
+  exec::AggregateRegistrationResult registerSimpleArrayAggAggregate(
+      const std::string& name) {
+    ...
+
+    return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step /*step*/,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(
+            argTypes.size(), 1, "{} takes at most one argument", name);
+        return std::make_unique<SimpleAggregateAdapter<SimpleArrayAggAggregate>>(
+            resultType);
+      });
+}
+
+
 Use FunctionSignatureBuilder to create FunctionSignature instances which
 describe supported signatures. Each signature includes zero or more input
 types, an intermediate result type and final result type.
@@ -610,8 +976,7 @@ The following query plans are being tested.
   final aggregation with forced spilling. Query runs using 4 threads.
 
 Query run with forced spilling is enabled only for group-by aggregations and
-only if `allowInputShuffle_` flag is enabled by calling allowInputShuffle
-() method from the SetUp(). Spill testing requires multiple batches of input.
+only if aggregate functions are not order-sensitive. Spill testing requires multiple batches of input.
 To split input data into multiple batches we add local exchange with
 round-robin repartitioning before the partial aggregation. This changes the order
 in which aggregation inputs are processed, hence, query results with spilling
diff --git a/velox/docs/develop/arena.rst b/velox/docs/develop/arena.rst
index f6abb785903f3..5e601509012bd 100644
--- a/velox/docs/develop/arena.rst
+++ b/velox/docs/develop/arena.rst
@@ -2,7 +2,7 @@
 Arena Allocation
 ================
 
-exec::HashStringAllocator implements an arena backed by MappedMemory::Allocation
+exec::HashStringAllocator implements an arena backed by memory::Allocation
 and supports contiguous and non-contiguous allocations. It is used to store
 variable width accumulators for the aggregate functions, hash tables for joins
 and aggregations. It is also used to back byte streams used to serialize and
@@ -75,19 +75,19 @@ non-contiguous allocation, it frees all the blocks in that allocation.
 
       // Allocates 'size' contiguous bytes preceded by a Header. Returns
       // the address of Header.
-      Header* FOLLY_NONNULL allocate(int32_t size);
+      Header* allocate(int32_t size);
 
       // Adds the allocation of 'header' and any extensions (if header has
       // kContinued set) to the free list.
-      void free(Header* FOLLY_NONNULL header);
+      void free(Header* header);
 
 StlAllocator, an allocator backed by HashStringAllocator that can be used with
 STL containers, is implemented using the above allocate() and free() methods.
 
 NewWrite(), extendWrite() and finishWrite() methods allow for serializing
-variable width data whose size is not known in advance using ByteStream. When
-using ByteStream, the underlying data may come from multiple non-contiguous
-blocks. ByteStream transparently manages allocation of additional blocks by
+variable width data whose size is not known in advance using ByteOutputStream. When
+using ByteOutputStream, the underlying data may come from multiple non-contiguous
+blocks. ByteOutputStream transparently manages allocation of additional blocks by
 calling HashStringAllocator::newRange() method.
 
 .. code-block:: c++
@@ -97,27 +97,27 @@ calling HashStringAllocator::newRange() method.
       // kMinContiguous bytes of contiguous space. finishWrite finalizes
       // the allocation information after the write is done.
       // Returns the position at the start of the allocated block.
-      Position newWrite(ByteStream& stream, int32_t preferredSize = kMinContiguous);
+      Position newWrite(ByteOutputStream& stream, int32_t preferredSize = kMinContiguous);
 
       // Completes a write prepared with newWrite or
       // extendWrite. Up to 'numReserveBytes' unused bytes, if available, are left
       // after the end of the write to accommodate another write. Returns the
       // position immediately after the last written byte.
-      Position finishWrite(ByteStream& stream, int32_t numReserveBytes);
+      Position finishWrite(ByteOutputStream& stream, int32_t numReserveBytes);
 
       // Sets 'stream' to write starting at 'position'. If new ranges have to
       // be allocated when writing, headers will be updated accordingly.
-      void extendWrite(Position position, ByteStream& stream);
+      void extendWrite(Position position, ByteOutputStream& stream);
 
-The prepareRead() method allows deserializing the data using ByteStream.
+The prepareRead() method allows deserializing the data using ByteInputStream.
 
 .. code-block:: c++
 
     // Sets 'stream' to range over the data in the range of 'header' and
     // possible continuation ranges.
     static void prepareRead(
-        const Header* FOLLY_NONNULL header,
-        ByteStream& stream);
+        const Header* header,
+        ByteInputStream& stream);
 
 Examples of Usage
 -----------------
@@ -139,22 +139,22 @@ The accumulator calls finishWrite() after writing the value.
 .. code-block:: c++
 
         // Write first value
-        ByteStream stream(allocator);
+        ByteOutputStream stream(allocator);
         auto begin = allocator->newWrite(stream);
         // ... write to the stream
         allocator->finishWrite(stream);
 
         // Update the value
-        ByteStream stream(allocator);
+        ByteOutputStream stream(allocator);
         auto begin = allocator->extendWrite(begin, stream);
         // ... write to the stream
         allocator->finishWrite(stream);
 
-The accumulator uses prepareRead() to read the data back using ByteStream.
+The accumulator uses prepareRead() to read the data back using ByteInputStream.
 
 .. code-block:: c++
 
-        ByteStream stream;
+        ByteInputStream stream;
         exec::HashStringAllocator::prepareRead(begin, stream);
         // … read from the stream
 
@@ -174,13 +174,13 @@ write.
 .. code-block:: c++
 
         // Write first value
-        ByteStream stream(allocator);
+        ByteOutputStream stream(allocator);
         auto begin = allocator->newWrite(stream);
         // ... write to the stream
         auto current = allocator->finishWrite(stream);
 
         // Update the value
-        ByteStream stream(allocator);
+        ByteOutputStream stream(allocator);
         auto begin = allocator->extendWrite(current, stream);
         // ... write to the stream
         allocator->finishWrite(stream);
diff --git a/velox/docs/develop/connectors.rst b/velox/docs/develop/connectors.rst
index fd1bacde3bc38..2d7ac8a011f33 100644
--- a/velox/docs/develop/connectors.rst
+++ b/velox/docs/develop/connectors.rst
@@ -82,6 +82,9 @@ Storage Adapters
 Hive Connector allows reading and writing files from a variety of distributed storage systems.
 The supported storage API are S3, HDFS, GCS, Linux FS.
 
+If file is not found when reading, `openFileForRead` API throws `VeloxRuntimeError` with `error_code::kFileNotFound`.
+This behavior is necessary to support the `ignore_missing_files` configuration property.
+
 S3 is supported using the `AWS SDK for C++ <https://github.com/aws/aws-sdk-cpp>`_ library.
 S3 supported schemes are `s3://` (Amazon S3, Minio), `s3a://` (Hadoop 3.x), `s3n://` (Deprecated in Hadoop 3.x),
 `oss://` (Alibaba cloud storage), and `cos://`, `cosn://` (Tencent cloud storage).
@@ -92,4 +95,29 @@ are `hdfs://`.
 
 GCS is supported using the
 `Google Cloud Platform C++ Client Libraries <https://github.com/googleapis/google-cloud-cpp>`_. GCS supported schemes
-are `gs://`.
\ No newline at end of file
+are `gs://`.
+
+ABS (Azure Blob Storage) is supported using the
+`Azure SDK for C++ <https://github.com/Azure/azure-sdk-for-cpp>`_ library. ABS supported schemes are `abfs(s)://`.
+
+S3 Storage adapter using a proxy
+********************************
+
+By default, the C++ AWS S3 client does not honor the configuration of the
+environment variables http_proxy, https_proxy, and no_proxy.
+The Java AWS S3 client supports this.
+The environment variables can be specified as lower case, upper case or both.
+In order to enable the use of a proxy the hive connector configuration variable
+`hive.s3.use-proxy-from-env` must be set to `true`. By default, the value
+is `false`.
+
+This is the behavior when the proxy settings are enabled:
+
+1. http_proxy/HTTP_PROXY, https_proxy/HTTPS_PROXY and no_proxy/NO_PROXY
+   environment variables are read. If lower case and upper case variables are set
+   lower case variables take precendence.
+2. The no_proxy/NO_PROXY content is scanned for exact and suffix matches.
+3. IP addresses, domains, subdomains, or IP ranges (CIDR) can be specified in no_proxy/NO_PROXY.
+4. The no_proxy/NO_PROXY list is comma separated.
+5. Use . or \*. to indicate domain suffix matching, e.g. `.foobar.com` will
+   match `test.foobar.com` or `foo.foobar.com`.
diff --git a/velox/docs/develop/debugging/print-plan-with-stats.rst b/velox/docs/develop/debugging/print-plan-with-stats.rst
index 5cbe05f621bbb..52bd5e6bb7f99 100644
--- a/velox/docs/develop/debugging/print-plan-with-stats.rst
+++ b/velox/docs/develop/debugging/print-plan-with-stats.rst
@@ -133,6 +133,7 @@ Here is the output for the join query from above.
               skippedStrides            sum: 0, count: 1, min: 0, max: 0
               storageReadBytes          sum: 150.25KB, count: 1, min: 150.25KB, max: 150.25KB
               totalScanTime             sum: 0ns, count: 1, min: 0ns, max: 0ns
+              totalRemainingFilterTime  sum: 0ns, count: 1, min: 0ns, max: 0ns
               queryThreadIoLatency      sum: 0, count: 1, min: 0, max: 0
         -> Project[expressions: (u_c0:INTEGER, ROW["c0"]), (u_c1:BIGINT, ROW["c1"])]
            Output: 100 rows (1.31KB), Cpu time: 21.50us, Blocked wall time: 0ns, Peak memory: 0B, Threads: 1
@@ -174,6 +175,7 @@ And this is the output for the aggregation query from above.
             skippedStrides             sum: 0, count: 1, min: 0, max: 0
             storageReadBytes           sum: 61.53KB, count: 1, min: 61.53KB, max: 61.53KB
             totalScanTime              sum: 0ns, count: 1, min: 0ns, max: 0ns
+            totalRemainingFilterTime   sum: 0ns, count: 1, min: 0ns, max: 0ns
             queryThreadIoLatency       sum: 0, count: 1, min: 0, max: 0
 
 Common operator statistics
@@ -247,6 +249,7 @@ groups were skipped via stats-based pruning.
            skippedStrides            sum: 0, count: 1, min: 0, max: 0
            storageReadBytes          sum: 150.25KB, count: 1, min: 150.25KB, max: 150.25KB
            totalScanTime             sum: 0ns, count: 1, min: 0ns, max: 0ns
+           totalRemainingFilterTime  sum: 0ns, count: 1, min: 0ns, max: 0ns
            queryThreadIoLatency      sum: 0, count: 1, min: 0, max: 0
 
 HashBuild operator reports range and number of distinct values for the join keys.
diff --git a/velox/docs/develop/expression-evaluation.rst b/velox/docs/develop/expression-evaluation.rst
index 37204af58da6e..ec9ef94a76bc8 100644
--- a/velox/docs/develop/expression-evaluation.rst
+++ b/velox/docs/develop/expression-evaluation.rst
@@ -241,8 +241,8 @@ This is calculated by Expr::computeMetadata() virtual methods and stored in
 member variables of the exec::Expr class.
 
 * *distinctFields_* - List of distinct input columns.
-* *multiplyReferencedFields_* - Subset of distinctFields_ that are used as inputs by multiple subexpressions.
-* *sameAsParentDistinctFields_* - True if distinctFields_ matches one of the parent's distinctFields_ (parents to refer expressions that have this expression as input).
+* *multiplyReferencedFields_* - Subset of `distinctFields_` that are used as inputs by multiple subexpressions.
+* *sameAsParentDistinctFields_* - True if `distinctFields_` matches one of the parent's `distinctFields_` (parents to refer expressions that have this expression as input).
 * *propagatesNulls_* - Boolean indicating whether a null in any of the input columns causes this expression to always return null for the row.
 * *deterministic_* - Boolean indicating whether this expression and all its children are deterministic.
 * *hasConditionals_* - Boolean indicating whether this expression or any of its children is an IF, SWITCH, AND or OR expression.
@@ -313,7 +313,7 @@ vector has 1’000 entries. These are represented with an indices buffer of 1000
 values in the range of [0, 2] and an inner flat vector of size 3: [red, green,
 blue]. When evaluating **upper(color)** expression, Expr::peelEncodings
 () method is used to peel off a dictionary and produce a new set of inputs:
-inner flat vector or size 3 and a set of indices into that vector: [0, 1, 2].
+inner flat vector of size 3 and a set of indices into that vector: [0, 1, 2].
 Then, “upper” function is applied to 3 values - [red, green, blue] - to produce
 another flat vector of size 3: [RED, GREEN, BLUE]. Finally, the result is
 wrapped in a dictionary vector using the original indices to produce a
diff --git a/velox/docs/develop/hash-table.rst b/velox/docs/develop/hash-table.rst
new file mode 100644
index 0000000000000..1d82a1427ca39
--- /dev/null
+++ b/velox/docs/develop/hash-table.rst
@@ -0,0 +1,148 @@
+.. role:: raw-html(raw)
+    :format: html
+
+.. role:: m(math)
+
+==========
+Hash table
+==========
+
+The hash table used in Velox is similar to the
+`F14 hash table <https://engineering.fb.com/2019/04/25/developer-tools/f14/>`_.
+The main difference is that the Velox hash table allows vectorized inserts and lookups, while F14 doesn't.
+
+
+Layout
+------
+
+The hash table is implemented as an array of buckets. It is a linear data structure.
+Each bucket uses 128 bytes (2 * 64 = 2 cache lines) and contains 16 slots.
+Each hash table entry occupies one slot. The hash table’s capacity is the total number of slots: total
+number of buckets * 16. The hash table’s capacity is always a power of 2.
+
+Each slot consists of 2 pieces: a tag (7 bits) and a pointer (6 bytes).
+There are a total of 16 tags and 16 pointers in a bucket. These are stored tags first, followed by
+pointers. Each tag occupies 1 byte (only 7 bits are used). 16 tags occupy 16 bytes. Each pointer
+occupies 6 bytes. 16 pointers occupy 96 bytes. There are 16 bytes left unused at the end of the bucket.
+These are referred to as padding.
+
+.. image:: images/ht-layout.png
+    :align: center
+
+A hash table is never full. There are always some empty slots. Velox allows the hash table to fill up to
+:raw-html:`<text style="font-size:1.2em;background-color:none">⅞</text>` of capacity before resizing.
+On resize the hash table’s capacity doubles.
+
+Individual buckets may be completely empty, partially filled or full. Buckets are filled left to right.
+If a bucket is partially full, then first N tags and N pointers are filled and the rest are free (N < 16).
+
+
+Inserting an entry
+------------------
+
+To insert a new entry we need to figure out which slot to put it in.
+A slot is identified by bucket and offset within the bucket. First, we compute a hash of the entry.
+Then, we compute a tag and a bucket number from the hash.
+
+We use 7 bits of the hash for the tag: bits 38-44 inclusive. We use N bits of the hash for the bucket
+starting from bit 8.
+
+The number of bits used for the bucket is decided based on the hash table capacity.
+Remember that capacity is always a power of 2: :m:`2^n`. Each bucket stores 16 entries, hence, we
+need :m:`2^{(n-4)}` buckets to store :m:`2^n` entries. Hence, we need to use n-4 bits of the hash for the bucket.
+
+Let's say we have a hash table that can store a million entries: :m:`2^{20}` = 1,048,576. Here, n = 20 and
+N = n - 4 = 16. We will use 16 bits for the bucket.
+
+Given hash number:
+
+01011011 11001010 011\ :raw-html:`<text style="background-color:orange">11100 01</text>`\101001 10110111
+1\ :raw-html:`<text style="background-color:#ADD8E6">0010100 11111000 1</text>`\ 1001110
+
+We compute the tag as 1\ :raw-html:`<text style="background-color:orange">1110001</text>` and bucket offset
+as 1,374,336 (00000000 00000000 00000000 00000000 00000000
+0\ :raw-html:`<text style="background-color:#ADD8E6">0010100 11111000 1</text>`\ 0000000).
+Bucket offset is the number of bytes from the start of the hash table.
+
+.. code-block:: c++
+
+    bucket offset = bucket number * 128
+    bucket number = bucket offset / 128
+
+The bucket offset is used to get to the bucket, in this case bucket number 10737.
+The candidate bucket can be empty, partially filled or full.
+
+**The bucket is empty.**
+
+.. image:: images/ht-empty.png
+    :align: center
+
+In this case, we simply insert our entry into the first slot of the bucket.
+We store only the tag (7 bits of the hash value) in the hash table. The hash number itself is not stored.
+The pointer refers to memory outside of the hash table where the complete value is stored.
+This is usually a row in a RowContainer. The hash table can be viewed as an index on top of a RowContainer
+that helps locate records with matching keys faster. The hash table itself doesn’t store data or keys.
+
+.. image:: images/ht-insert1.png
+    :align: center
+
+**The bucket is partially filled.**
+
+For example, the bucket has one slot occupied (like above).
+In this case there is a possibility that the new entry is a duplicate of the one already stored.
+Hence, we compare the tag of the new entry with tags stored in the bucket.
+If none match, this entry is not a duplicate, so we store it in the next available slot in the bucket.
+
+.. image:: images/ht-insert2.png
+    :align: center
+
+However, if one or more existing tags match the tag of the new entry, we follow the pointers to compare
+the keys to determine whether there is a match or not. If there is no match we insert a new entry.
+Otherwise, there is a duplicate. The row is chained to the row list pointed to by the row entry
+and no new entry is inserted.
+
+**The bucket is full.**
+
+.. image:: images/ht-full.png
+    :align: center
+
+First, we need to check if the new entry is a duplicate of one of the 16 entries stored in the bucket.
+We compare tags and if necessary follow the pointers to compare the keys.
+If there is a match, the row is chained to the row list pointed to by the row entry
+and no new entry is inserted. If there is no match, we go to the
+next bucket and repeat the process. In rare cases, we may end up checking many buckets until we find a
+duplicate existing entry or an empty slot for the new entry. That’s why it is important to ensure that
+the hash table is never full and there are enough gaps in the form of empty slots.
+
+Resizing
+--------
+
+If the hash table fills up beyond :raw-html:`<text style="font-size:1.2em;background-color:none">⅞</text>`
+of capacity, it needs to be resized. Each resize doubles the capacity.
+A new hash table is allocated and all existing entries inserted using the “Inserting an entry” process.
+Since we know that all entries are unique, the “Inserting an entry” process can be simplified to
+eliminate the logic for checking whether a new entry is a duplicate of an existing one. Hence, to
+insert an entry, we compute a hash, extract tag and bucket number, go to the bucket and insert the
+entry if there is space. If the bucket is full, we proceed to the next bucket and continue until we
+find a bucket with an empty slot. We insert the new entry there.
+
+Use Cases
+---------
+
+The main use cases for the hash table are `Join <joins.html>`_ and
+`Aggregation <aggregations.html>`_ operators.
+
+The HashBuild operator builds the hash table to store unique values of the join keys found on the build
+side of the join. The HashProbe operator looks up entries in the hash table using join keys from the
+probe side. The HashProbe operator does not insert new entries into the hash table and never triggers
+a resize. The pointers in the hash table refer to rows in a RowContainer that store individual
+rows for the build side of the join.
+
+The HashAggregation operator stores unique grouping keys in the hash table. The pointers in the hash table
+refer to rows in a RowContainer that store grouping keys along with accumulators of the aggregate
+functions.
+
+Implementation
+--------------
+
+The hash table is implemented by the ``HashTable`` class in namespace ``facebook::velox::exec``.
diff --git a/velox/docs/develop/images/empty_frames.png b/velox/docs/develop/images/empty_frames.png
new file mode 100644
index 0000000000000..017c41155f476
Binary files /dev/null and b/velox/docs/develop/images/empty_frames.png differ
diff --git a/velox/docs/develop/images/ht-empty.png b/velox/docs/develop/images/ht-empty.png
new file mode 100644
index 0000000000000..f8c17b4288e1f
Binary files /dev/null and b/velox/docs/develop/images/ht-empty.png differ
diff --git a/velox/docs/develop/images/ht-full.png b/velox/docs/develop/images/ht-full.png
new file mode 100644
index 0000000000000..d4611b42efe69
Binary files /dev/null and b/velox/docs/develop/images/ht-full.png differ
diff --git a/velox/docs/develop/images/ht-insert1.png b/velox/docs/develop/images/ht-insert1.png
new file mode 100644
index 0000000000000..58867e918d800
Binary files /dev/null and b/velox/docs/develop/images/ht-insert1.png differ
diff --git a/velox/docs/develop/images/ht-insert2.png b/velox/docs/develop/images/ht-insert2.png
new file mode 100644
index 0000000000000..515f06be3614a
Binary files /dev/null and b/velox/docs/develop/images/ht-insert2.png differ
diff --git a/velox/docs/develop/images/ht-layout.png b/velox/docs/develop/images/ht-layout.png
new file mode 100644
index 0000000000000..ad47e9d727455
Binary files /dev/null and b/velox/docs/develop/images/ht-layout.png differ
diff --git a/velox/docs/develop/images/memory-arbitration.png b/velox/docs/develop/images/memory-arbitration.png
new file mode 100644
index 0000000000000..cb712ecf5c99d
Binary files /dev/null and b/velox/docs/develop/images/memory-arbitration.png differ
diff --git a/velox/docs/develop/images/memory-function.png b/velox/docs/develop/images/memory-function.png
new file mode 100644
index 0000000000000..daa5b1aaab57c
Binary files /dev/null and b/velox/docs/develop/images/memory-function.png differ
diff --git a/velox/docs/develop/images/memory-manager.png b/velox/docs/develop/images/memory-manager.png
new file mode 100644
index 0000000000000..9f95b7fabe68d
Binary files /dev/null and b/velox/docs/develop/images/memory-manager.png differ
diff --git a/velox/docs/develop/images/memory-pool.png b/velox/docs/develop/images/memory-pool.png
new file mode 100644
index 0000000000000..c70d8270a22eb
Binary files /dev/null and b/velox/docs/develop/images/memory-pool.png differ
diff --git a/velox/docs/develop/images/memory-system.png b/velox/docs/develop/images/memory-system.png
new file mode 100644
index 0000000000000..cff7d16d30ec8
Binary files /dev/null and b/velox/docs/develop/images/memory-system.png differ
diff --git a/velox/docs/develop/images/size-class.png b/velox/docs/develop/images/size-class.png
new file mode 100644
index 0000000000000..3513989891fa8
Binary files /dev/null and b/velox/docs/develop/images/size-class.png differ
diff --git a/velox/docs/develop/joins.rst b/velox/docs/develop/joins.rst
index 1bedfc6626373..e879f51a2264f 100644
--- a/velox/docs/develop/joins.rst
+++ b/velox/docs/develop/joins.rst
@@ -110,7 +110,8 @@ data by probing the hash table and continues execution as specified by
 downstream plan nodes. HashJoinNode is translated into two separate operators:
 HashProbe and HashBuild. HashProbe operator becomes part of the probe-side
 pipeline. HashBuild operator is installed as the last operator of the
-build-side pipeline. The output of the HashBuild operator is a hash table which
+build-side pipeline. The output of the HashBuild operator is a
+`hash table <hash-table.html>`_ which
 HashProbe operator gets access to via a special mechanism: JoinBridge.
 
 .. image:: images/join-pipelines.png
@@ -118,7 +119,7 @@ HashProbe operator gets access to via a special mechanism: JoinBridge.
     :align: center
 
 Both HashBuild and HashAggregation operators use the same data structure for the
-hash table: velox::exec::HashTable. The payload, the non-join key columns
+hash table: `velox::exec::HashTable <hash-table.html>`_. The payload, the non-join key columns
 referred to as dependent columns, are stored row-wise in the RowContainer.
 
 Using the hash table in join and aggregation allows for a future optimization
@@ -183,7 +184,7 @@ join key values on the build side are unique it is possible to replace the join
 completely with the pushed down filter. Velox detects such opportunities and
 turns the join into a no-op after pushing the filter down.
 
-Dynamic filter pushdown optimization is enabled for inner, left semi, and 
+Dynamic filter pushdown optimization is enabled for inner, left semi, and
 right semi joins.
 
 Broadcast Join
@@ -197,7 +198,7 @@ the join is executed using broadcast or partitioned strategy has no effect on
 the join execution itself. The only difference is that broadcast execution
 allows for dynamic filter pushdown while partitioned execution does not.
 
-PartitionedOutput operator and PartitionedOutputBufferManager support
+PartitionedOutput operator and OutputBufferManager support
 broadcasting the results of the plan evaluation. This functionality is enabled
 by setting boolean flag "broadcast" in the PartitionedOutputNode to true.
 
@@ -362,11 +363,11 @@ right side whose values need to match, and an optional filter to apply to join
 results.
 
 To execute a plan with a merge join, Velox creates two separate pipelines. One
-pipeline processes the right side data and puts it into JoinMergeSource. The
+pipeline processes the right side data and puts it into MergeJoinSource. The
 other pipeline processes the data on the left side, joins it with the right
 side data and continues execution as specified by downstream plan nodes.
 MergeJoinNode is translated into MergeJoin operator and a CallbackSink backed
-by JoinMergeSource. MergeJoin operator becomes part of the left-side
+by MergeJoinSource. MergeJoin operator becomes part of the left-side
 pipeline. CallbackSink is installed at the end of the right-side pipeline.
 
 .. image:: images/merge-join-pipelines.png
diff --git a/velox/docs/develop/lambda-functions.rst b/velox/docs/develop/lambda-functions.rst
index 19dd2e258395c..7f66c7c826603 100644
--- a/velox/docs/develop/lambda-functions.rst
+++ b/velox/docs/develop/lambda-functions.rst
@@ -200,32 +200,16 @@ the signature of the "filter" function:
 Testing
 -------
 
-Testing framework doesn't support Presto SQL lambda expressions, e.g. one cannot
-evaluate "filter(a, x - >x >= b)" expression directly. Instead, use the
-registerLambda helper method of the FunctionBaseTest class to register lambda
-expression and give it a name, then use that name to specify the lambda
-parameter. Here is an example that evaluates "filter(a, x ->x >= b)" expression
-in a test:
+Testing framework fully supports evaluating lambda expression. Just write
+an expression as you would in Presto SQL:
 
 .. code-block:: c++
 
-  auto rowType = ROW({"a", "b"}, {ARRAY(BIGINT()), BIGINT()});
+  auto result = evaluate("filter(a, x -> (x >= b))", data);
 
-  registerLambda("lambda", ROW({"x"}, {BIGINT()}), rowType, "x >= b"));
+In the above, 'data' is expected to have a column "a" of type array and
+column "b" of type matching array element type. For example, "a" can be
+an array(integer) and "b" an integer.
 
-  auto result =
-      evaluate<BaseVector>("filter(a, function('lambda'))", data);
-
-The first argument to registerLambda is the name for the lambda. This name can
-later be used to refer to the lambda in a function call.
-
-The second argument is the signature of the lambda, e.g. the list of lambda
-parameters along with their names and types.
-
-The third argument is the type of the input data to the overall expression. This
-is used to resolve the types of captures.
-
-The last argument is the lambda body as SQL expression.
-
-To specify lambda expression as an argument of a lambda function use function
-(‘<lambda-name>’) syntax.
+The only caveat is you need to put lambda body in parentheses.
+`x -> (x >= b)` works, but `x -> x >= b` doesn't.
diff --git a/velox/docs/develop/memory.rst b/velox/docs/develop/memory.rst
new file mode 100644
index 0000000000000..c5ed4a63fe279
--- /dev/null
+++ b/velox/docs/develop/memory.rst
@@ -0,0 +1,905 @@
+=================
+Memory Management
+=================
+
+Background
+----------
+
+The Velox memory system is built on top of the `std::mmap <https://man7.org/linux/man-pages/man2/mmap.2.html>`_ library to avoid the
+`memory fragmentation issue <https://stackoverflow.com/questions/3770457/what-is-memory-fragmentation>`_ with std::malloc. It provides the basic
+memory allocation functions for query execution as well as the advanced
+memory management functions such as fair memory sharing, transparent file cache
+and server out-of-memory (OOM) prevention.
+
+Velox provides the large contiguous and noncontiguous buffer allocation
+functions to optimize the query memory allocation patterns. For example, a
+query can allocate a large contiguous memory for a hash table
+(*HashTable::allocateTables*) by using std::mmap to allocate physical memory from
+the OS directly. For small buffer allocations, a query can allocate a large
+chunk of non-contiguous memory, and then use `memory arena technique <https://nullprogram.com/blog/2023/09/27/>`_ like
+*StreamArena* or *HashStringAllocator* to provide the small allocations on top of
+it to reduce the number of expensive actual memory allocations.
+
+Velox provides fair memory sharing among running queries by adjusting their
+memory capacities at runtime in response to their memory usage changes. This
+process is called memory arbitration. It ensures the total allocated memory
+capacity of all the queries is within the system configured query memory limit.
+It also prevents each individual query from running out of the user configured
+per-query memory limit. When a query tries to allocate more memory than its
+current capacity, the memory arbitration either increases the query’s capacity
+by reclaiming the used memory from the other queries with larger capacities, or
+reclaiming from the query itself if it exceeds per-query memory limit, to free
+up space within its current capacity. The memory reclaim is achieved through
+techniques like `disk spilling <https://facebookincubator.github.io/velox/develop/spilling.html>`_.
+
+Velox provides transparent file cache to accelerate table scan through the hot
+data reuse and prefetch. The file cache is integrated with the memory system to
+achieve dynamic memory sharing between file cache and query memory. When a
+query fails to allocate memory, we retry the allocation by shrinking the file
+cache. Therefore, the file cache size is automatically adjusted in response to
+the query memory usage change.
+
+Velox provides server out of memory (OOM) prevention by managing the physical
+memory allocation on its own through the std::mmap library. This allows us to
+enforce explicit control on `Resident Set Size (RSS) <https://en.wikipedia.org/wiki/Resident_set_size#:~:text=In%20computing%2C%20resident%20set%20size,in%20main%20memory%20(RAM).>`_ of Velox memory usage. The
+memory allocator in Velox handles all the memory allocations from both file
+cache and query memory. It ensures the total allocated memory won’t exceed the
+system memory limit configured for Velox to use. To further handle the spiky
+memory usage from the non-Velox components, Velox provides a generic server
+memory pushback mechanism to automatically shrink the file cache to return the
+unused Velox memory back to the OS when the server is detected under low memory
+condition.
+
+Overall Design
+--------------
+
+Velox memory system consists of the following major memory components: memory
+manager (*MemoryManager*), memory allocator (*MemoryAllocator*), file cache
+(*AsyncDataCache*), memory arbitrator (*MemoryArbitrator*) and a number of memory
+pools (*MemoryPool*). The memory manager creates all the other components. It
+creates the memory allocator and memory arbitrator when initializing the memory
+system, and creates the memory pool on-demand for query execution.
+
+.. image:: images/memory-system.png
+    :width: 600
+    :align: center
+
+When a query starts execution, it first creates a root memory pool (query pool)
+from the memory manager, and then creates a tree of child memory pools from the
+root according to the query plan: a child memory pool for each query task
+(task pool), a grandchild memory pool for each plan node (node pool) and a
+great-grandchild memory pool for each operator instance (operator pool). During
+the query execution, it allocates memory from the leaf operator pools and
+propagates the memory usage up to the root query pool. If the aggregated memory
+usage at the root exceeds the current query memory capacity, the query pool
+sends a request to the memory arbitrator to grow its capacity. The memory
+arbitrator either grows the requestor query pool’s capacity by reclaiming the
+used memory from the other queries which has the largest capacity in the
+system, or reclaiming from the request query pool itself to free up space
+within its current capacity if it exceeds the per-query memory limit or it has
+the largest capacity in the system. The used memory reclaim is achieved through
+techniques like `disk spilling <https://facebookincubator.github.io/velox/develop/spilling.html>`_. If the memory arbitration succeeds, the leaf
+operator pool can proceed with the actual memory allocation from memory
+allocator. However, if the memory arbitration fails, then the query which has
+the largest capacity in the system is chosen to fail with query memory capacity
+exceeded error (local OOM). The failed query may or may not be the requestor
+query pool itself.
+
+The memory allocator does the actual memory allocation from its own managed
+memory space in units of machine pages (4KB). It tracks the amount of allocated
+memory, and returns an error if an allocation request exceeds the system memory
+limit. This enables explicit control on RSS of Velox memory usage to help
+prevent the server OOM.
+
+The file cache provides the in-memory hot data cache and prefetch functions
+when the user query accesses the remote storage. It allocates memory from the
+memory allocator directly which is not counted in query memory usage. To
+prevent the memory allocation failure because of excessive file cache memory
+usage, the file cache retries the allocation failure by shrinking the file
+cache. This achieves dynamic memory sharing between file cache and query memory
+in response to the user query workload changes.
+
+.. image:: images/memory-function.png
+    :width: 800
+    :align: center
+    :alt: Memory Management Functions
+
+To summarize, the memory manager manages the memory pools and coordinates the
+accesses between different memory components. The memory pool tracks a query’s
+memory usage and interacts with the memory arbitrator to adjust the memory
+capacity allocations among running queries to achieve fair memory sharing. The
+memory allocator manages the physical memory allocations to prevent server OOM,
+and interacts with file cache to achieve dynamic memory sharing between query
+memory and file cache to maximize the memory efficiency. The rest of the
+document describes each memory component in detail.
+
+Memory Manager
+--------------
+
+.. image:: images/memory-manager.png
+    :width: 600
+    :align: center
+    :alt: Memory Manager
+
+The memory manager is created on server startup with the provided
+*MemoryManagerOption*. It creates a memory allocator instance to manage the
+physical memory allocations for both query memory allocated through memory pool
+and cache memory allocated through the file cache. It ensures the total
+allocated memory is within the system memory limit (specified by
+*MemoryManagerOptions::allocatorCapacity*). The memory manager also creates a
+memory arbitrator instance to arbitrate the memory capacity among running
+queries. It ensures the total allocated query memory capacity is within the
+query memory limit (specified by *MemoryManagerOptions::arbitratorCapacity*). The
+memory arbitrator also prevents each individual query running out of its
+per-query memory limit (specified by *QueryConfig::query_max_memory_per_node*) by
+reclaiming overused memory through `disk spilling <https://facebookincubator.github.io/velox/develop/spilling.html>`_ (refer to `memory arbitrator
+section <#memory-arbitrator>`_ for details).
+
+After setting up the Velox memory system, the memory manager manages the memory
+pools for query execution. When a query starts, it creates a root query pool
+from the memory manager, and then creates a tree of child pools from the query
+pool according to the query plan (see `memory pool section <#memory-pool>`_ for detail) for
+memory allocations and usage tracking.
+
+The memory manager keeps track of all the live query pools for the memory
+arbitration process. When a query pool sends a request to the memory manager to
+grow its capacity (*MemoryManager::growPool*), the memory manager forwards the
+request to the memory arbitrator with the list of alive query pools as the
+arbitration candidates. The memory arbitrator reclaims the used memory from the
+candidates with the largest capacity first, and increases the requestor pool’s
+capacity with the freed memory space accordingly. If the requestor pool already
+has the largest capacity among all the candidates, then the memory arbitrator
+reclaims memory from the requestor itself to free up space within its current
+capacity. See `memory arbitration process section <#memory-arbitration-process>`_ for detailed description of
+the memory arbitration process.
+
+The memory manager doesn’t have ownership of user created query pools but only
+tracks their liveness through *MemoryManager::dropPool* method which is invoked
+by the query pool’s destructor to remove itself from the tracked list
+(*MemoryManager::pools_*). The *QueryCtx* object owns the query pool which stays
+alive until the query finishes.
+
+The memory manager creates and owns a system root pool for Velox internal
+operations such as `disk spilling <https://facebookincubator.github.io/velox/develop/spilling.html>`_. The difference between system root pool and
+user created query root pool is that there is no per-query memory limit for the
+system root pool so it doesn’t participate in the memory arbitration. The
+reason is that the system operations are not executed on behalf of a particular
+user query. Take `disk spilling <https://facebookincubator.github.io/velox/develop/spilling.html>`_ for example, it is triggered by memory
+arbitration to free up used memory from the queries. We don’t expect
+significant memory usage during a system operation, and eventually the memory
+allocator guarantees the actual allocated memory are within the system memory
+limit no matter if it is for system operation or for user query execution. In
+practice, we shall reserve some space from the memory allocator to compensate
+for such system memory usage. We can do that by configuring the query
+memory limit (*MemoryManagerOptions::arbitratorCapacity*) to be smaller than the system memory
+limit (*MemoryManagerOptions::allocatorCapacity*) (refer to `OOM prevention section <#server-oom-prevention>`_
+for detail).
+
+Memory System Setup
+^^^^^^^^^^^^^^^^^^^
+
+Here is the code block from Prestissimo that initializes the Velox memory system:
+
+.. code-block:: c++
+  :linenos:
+
+   void PrestoServer::initializeVeloxMemory() {
+     auto* systemConfig = SystemConfig::instance();
+     const uint64_t memoryGb = systemConfig->systemMemoryGb();
+     MemoryManagerOptions options;
+     options.allocatorCapacity = memoryGb << 30;
+     options.useMmapAllocator = systemConfig->useMmapAllocator();
+     if (!systemConfig->memoryArbitratorKind().empty()) {
+       options.arbitratorKind = systemConfig->memoryArbitratorKind();
+       const uint64_t queryMemoryGb = systemConfig->queryMemoryGb();
+       options.queryMemoryCapacity = queryMemoryGb << 30;
+       ...
+     }
+     memory::initializeMemoryManager(options);
+
+     if (systemConfig->asyncDataCacheEnabled()) {
+       ...
+       cache_ = std::make_shared<cache::AsyncDataCache>(
+          memoryManager()->allocator(), memoryBytes, std::move(ssd));
+     }
+     ...
+   }
+
+* L5: set the memory allocator capacity (system memory limit) from
+  the Prestissimo system config
+* L6: set the memory allocator type from the Prestissimo system config. If
+  *useMmapAllocator* is true, we use *MmapAllocator*, otherwise use
+  *MallocAllocator*. `Memory Allocator section <#memory-allocator>`_ describes these two
+  types of allocators
+* L8: set the memory arbitrator kind from the Prestissimo system config.
+  Currently, we only support the *“SHARED”* arbitrator kind (see `memory arbitrator section <#memory-arbitrator>`_).
+  *“NOOP”* arbitrator kind will be deprecated soon (`#8220 <https://github.com/facebookincubator/velox/issues/8220>`_)
+* L10: set the memory arbitrator capacity (query memory limit) from the
+  Prestissimo system config
+* L13: creates the process-wide memory manager which creates memory
+  allocator and arbitrator inside based on MemoryManagerOptions initialized from previous steps
+* L15-19: creates the file cache if it is enabled in Prestissimo system
+  config
+
+Memory Pool
+-----------
+
+The memory pool provides memory allocation functions for query execution. It
+also tracks a query’s memory usage for per-query memory limit enforcement.
+As shown in the Query Memory Pool Hierarchy figure, a query creates a tree of
+memory pools that mirrors the query plan to have a fine-grained tracking of
+memory usage for figuring out which task(s) or operator(s) use most of the
+memory. At the root of the tree, *QueryCtx* creates a root query pool from the
+memory manager. Each query task creates a child task pool from the query pool.
+A query task executes a fragment of the query plan (e.g. an execution stage in
+a distributed query execution plan in Prestissimo). Each plan node in a task’s
+plan fragment creates a child node pool from the task pool
+(*Task::getOrAddNodePool*). Each plan node belongs to one or more task
+execution pipelines. Each pipeline might have multiple driver instances running
+in parallel. Each driver instance consists of a pipeline of query operators,
+and an operator is an instantiation of a query plan node in a driver. Hence
+each operator creates a child operator pool from the node pool
+(*Task::addOperatorPool*).
+
+.. image:: images/memory-pool.png
+    :width: 500
+    :align: center
+    :alt: Memory Pool
+
+Query allocates memory from the operator pool at the leaf of the tree and
+propagates the memory usage all the way up to the query pool at the root of the
+tree to check if the memory usage has exceeded the per-query memory limit or
+not. The memory allocation always happens at the leaf operator pool, the
+intermediate pools only aggregate the memory usage (node pool and task pool),
+and it is the root query pool that enforces the per-query memory limit. Given
+that, we introduce two memory pool types (defined by *MemoryPool::Kind*) to
+simplify the memory pool management: one is *LEAF* type which only allows the
+memory allocations and the other is *AGGREGATE* type which aggregates the
+memory usage from all its children but is not allowed to allocate memory
+directly. Hence, the operator pool is *LEAF* type and all the others are
+*AGGREGATE* type. We only enforce the memory limit check at the root query
+pool.
+
+Memory Usage Tracking
+^^^^^^^^^^^^^^^^^^^^^
+
+To track query memory usage, a leaf operator pool needs to propagate the memory
+usage all the way up to the root query pool and check the memory limit for
+every allocation, but this would be slow. Hence, memory pool uses a memory
+reservation mechanism to track the query memory usage. A memory reservation is
+made in 1MB or larger chunks to avoid excessive locking, propagating and
+checking memory usage for every single allocation (see *MemoryPool::quantizedSize*
+description below). A leaf operator pool maintains two counters for memory
+reservation: one is the actual used memory (*MemoryPoolImpl::usedReservationBytes_*)
+and the other is the memory reserved from the root query pool
+(*MemoryPoolImpl::reservationBytes_*). The difference between the two counters
+is the available memory for a leaf operator pool to use.
+
+The intermediate pools only use *reservationBytes_* to count the aggregated memory
+reservations held by all its child pools. The root query pool has two additional
+counters for memory limit check: one is its current memory capacity
+(*MemoryPoolImpl::capacity_*) which is the amount of memory available for the
+query to use. The memory arbitrator sets this based on how many queries are
+running, the total query memory limit and how much memory each query needs. The
+other is max capacity (*MemoryPool::maxCapacity_*) which is the max capacity that
+a query can grow up to. It is set by the user and is fixed during a query’s
+lifetime (*QueryConfig::kQueryMaxMemoryPerNode*). The memory arbitrator can’t
+set a query’s *capacity_* beyond its *maxCapacity_* limit.
+
+When the root query pool receives a new memory reservation request, it increases
+*reservationBytes_* and checks if it is within its current *capacity_* limit. If
+it does, the root query pool accepts the request. If not, the root query pool
+asks the memory arbitrator (via memory manager) to grow its capacity through the
+memory arbitration (see `memory arbitrator section <#memory-arbitrator>`_ for details).
+If the memory arbitration fails, the root query pool fails the request with a
+query memory capacity exceeded error (local OOM error).
+
+*MemoryPool::reserve* and *MemoryPool::release* are the two methods used by the
+memory pool for memory reservation. The memory reservation is thread-safe and
+*MemoryPool::reserveThreadSafe* is the main function that implements the memory
+reservation logic:
+
+#. The leaf memory pool calls *MemoryPool::reservationSizeLocked* to calculate
+   the new required reservation (*incrementBytes*). It is based on the memory
+   allocation size, and available memory reservation
+   (*reservationBytes_ -  usedReservationBytes_*).
+
+#. If *incrementBytes* is zero, the leaf memory pool has sufficient available
+   reservation so it doesn’t need new reservation and just update
+   *usedReservationBytes_* to reflect the new memory usage.
+
+#. If *incrementBytes* is not zero, the leaf memory pool needs to call
+   *MemoryPool::incrementReservationThreadSafe* (see below) to propagate the
+   increment all the way up to the root memory pool to check if the new
+   reservation request exceeds the query’s current capacity or not. If not,
+   accept the reservation by incrementing *reservationBytes_* accordingly.
+
+   Note that if *MemoryPool::incrementReservationThreadSafe* fails, it throws an
+   exception to fail the memory allocation request with a local OOM error.
+
+#. The leaf memory pool goes back to step-1 to check if there is sufficient
+   available reservation for the allocation request after the reservation
+   succeeds.
+
+   Note that the concurrent allocation requests to the same leaf memory pool
+   might steal away the reservation made in step-3 so we have to check again.
+   We don’t hold the leaf memory pool’s lock while making a reservation from
+   the root memory pool, which could be a blocking operation if memory
+   arbitration is involved. Therefore, there could be a race condition if there
+   are two concurrent memory reservation requests from the same leaf memory
+   pool. But we don’t expect it to happen very often in practice.
+
+As mentioned above, to avoid frequent concurrent memory reservations to the
+root memory pool to reduce the cpu cost, the leaf memory pool does quantized
+memory reservation. It rounds up the actual reservation bytes to the next large
+quantized reservation value (MemoryPool::quantizedSize):
+
+- round up to next MB if size < 16MB
+- round up to next 4MB if size < 64MB
+- round up to next 8MB if size >= 64MB
+
+With the quantized reservation, we never reserve less than 1 MB of memory. Even
+if we only need 1KB, we’ll have to reserve 1MB and if there is not enough
+memory available the query will fail. It also means that if we run at
+concurrency of 15, each driver thread will reserve at least 1MB and therefore
+the query would require at least 15 MB of memory even if it uses just a few KB.
+
+The implementation of MemoryPool::incrementReservationThreadSafe:
+
+#. A non-root memory pool calls its parent pool’s *incrementReservationThreadSafe*
+   method recursively to propagate the reservation request all the way up to
+   the root memory pool
+
+#. Check *MemoryPool::incrementReservationThreadSafe* result from the parent pool:
+
+   a. If the function returns true, the reservation succeeds from the root
+      memory pool and proceeds to accept the reservation (Step-3)
+   b. If the function returns false, then reservation succeeds but has conflicts
+      with other concurrent reservation requests detected at the root memory
+      pool. We need to retry from the leaf memory pool again by returning false
+      to *MemoryPoolImpl::reserveThreadSafe*
+   c. If the memory reservation fails at the root memory pool, the function
+      expects a query memory capacity exceeded exception thrown and the memory
+      allocation fails
+
+#. Call *MemoryPool::maybeIncrementReservation* to try to increment the
+   reservation and check the result:
+
+   a. For a non-root memory pool, this should always succeed as we only check
+      capacity at the root memory pool
+   b. For a root memory pool, the function might return false if the reservation
+      request exceeds its current capacity and goes to step-4 to request memory
+      arbitration
+
+#. The root memory pool calls *MemoryManager::growPool* to grow its capacity.
+   This triggers the memory arbitration process inside the memory arbitrator
+
+#. If *MemoryManager::growPool* returns true, then we succeed in growing memory
+   capacity (or reducing the memory usage within its current capacity). The
+   function calls *MemoryPool::maybeIncrementReservation* again to check if the
+   memory reservation can be satisfied or not. If not, then there should be a
+   concurrent memory reservation request that takes away the grown memory
+   capacity. Returns false to retry from the leaf memory pool again in this case
+   (step2-b). Otherwise, returns true (step2-a).
+
+#. If *MemoryManager::growPool* returns false, then we fail to grow capacity
+   from the memory arbitrator and throws an query memory capacity exceeded error
+   (step2-c)
+
+Memory Pool APIs
+^^^^^^^^^^^^^^^^
+
+Memory pool has three sets of APIs for memory pool management, memory allocation
+and memory arbitration. The following is a list of the major APIs to use in each
+of the three sets.
+
+Memory Pool Management
+""""""""""""""""""""""
+
+.. code-block:: c++
+
+  /// Creates a root memory pool with specified 'name' and 'maxCapacity'.
+  /// 'reclaimer' is provided for memory arbitration process.
+  std::shared_ptr<MemoryPool> MemoryManager::addRootPool(
+     const std::string& name = "",
+     int64_t maxCapacity = kMaxMemory,
+     std::unique_ptr<MemoryReclaimer> reclaimer = nullptr);
+
+  /// Create an aggregate child memory pool which allows to create child memory
+  /// pools from it, and it used to aggregate memory usage from its child pools.
+  /// Aggregate memory pool is not allowed to allocate memory directly.
+  virtual std::shared_ptr<MemoryPool> MemoryPool::addAggregateChild(
+     const std::string& name);
+
+  /// Create a leaf child memory pool which allows to allocate memory but are not
+  /// allowed to create child pools.
+  virtual std::shared_ptr<MemoryPool> MemoryPool::addLeafChild(
+     const std::string& name);
+
+  /// Creates new instance of MemoryPool for an operator, stores it in the task
+  /// to ensure lifetime and returns a raw pointer.
+  velox::memory::MemoryPool* Task::addOperatorPool(
+     const core::PlanNodeId& planNodeId,
+     int pipelineId,
+     uint32_t driverId,
+     const std::string& operatorType);
+
+  /// Creates new instance of MemoryPool for a plan node, stores it in the task
+  /// to ensure lifetime and returns a raw pointer.
+  memory::MemoryPool* Task::getOrAddNodePool(
+     const core::PlanNodeId& planNodeId);
+
+Memory Allocation
+"""""""""""""""""
+
+The memory pool provides three types of memory allocations. If a user needs a
+large chunk of buffer allocation and the allocated buffer doesn’t need to be
+contiguous, then it can use *MemoryPool::allocateNonContiguous* to allocate a
+number of variable sized buffers (see `non-contiguous allocation section <#non-contiguous-allocation>`_ for details). Velox uses this allocation for
+*RowContainer*, *StreamArena*/*HashStringAllocator* and *AsyncDataCache* etc. If a user
+needs a large contiguous buffer allocation with size > 1MB, then it can use
+*MemoryPool::allocateContiguous* to allocate a large chunk of physical memory
+from the OS directly through std::mmap (see `contiguous allocation section <#contiguous-allocation>`_ for
+details). Velox uses this allocation for *HashTable*. For any other ad hoc
+allocations, we can use *MemoryPool::allocate*. The memory allocator determines
+how to allocate memory based on the actual allocation size (see
+`small allocation section <#small-allocation>`_ for details).
+
+.. code-block:: c++
+
+  /// Allocates a buffer with specified 'size'. If the memory allocation is
+  /// smaller than a predefined threshold, then we delegate the allocation to
+  /// std::malloc (MmapAllocator::Options::maxMallocBytes).
+  virtual void* MemoryPool::allocate(int64_t size) = 0;
+
+  /// Frees an allocated buffer.
+  virtual void MemoryPool::free(void* p, int64_t size) = 0;
+
+  /// Allocates one or more runs that add up to at least 'numPages', with the
+  /// smallest run being at least 'minSizeClass' pages. 'minSizeClass' must
+  /// be <= the size of the largest size class (see non-contiguous allocation
+  /// section for size class definition). The new memory is returned in 'out' on
+  /// success and any memory formerly referenced by 'out' is freed. The function
+  /// throws if allocation fails and 'out' references no memory and any partially
+  /// allocated memory is freed.
+  virtual void MemoryPool::allocateNonContiguous(
+     MachinePageCount numPages,
+     Allocation& out,
+     MachinePageCount minSizeClass = 0) = 0;
+
+  /// Frees non-contiguous 'allocation'. 'allocation' is empty on return.
+  virtual void MemoryPool::freeNonContiguous(Allocation& allocation) = 0;
+
+  /// Makes a large contiguous mmap of 'numPages'. The new mapped pages are
+  /// returned in 'out' on success. Any formly mapped pages referenced by 'out'
+  /// is unmapped in all the cases even if the allocation fails.
+  virtual void MemoryPool::allocateContiguous(
+     MachinePageCount numPages,
+     ContiguousAllocation& out) = 0;
+
+  /// Frees contiguous 'allocation'. 'allocation' is empty on return.
+  virtual void MemoryPool::freeContiguous(ContiguousAllocation& allocation) = 0;
+
+Memory Arbitration
+""""""""""""""""""
+
+The `memory arbitrator section <#memory-arbitrator>`_ below discusses how these memory arbitration
+related methods are used in the memory arbitration and reclaim process.
+
+.. code-block:: c++
+
+  /// Returns the number of bytes that haven't been reserved for use, and can be
+  /// freed by reducing this memory pool's limit.
+  virtual uint64_t MemoryPool::freeBytes() const = 0;
+
+  /// Invoked to bump up the memory pool's capacity by 'bytes'. The function
+  /// returns the memory pool's new capacity after the grow.
+  virtual uint64_t MemoryPool::grow(uint64_t bytes) = 0;
+
+  /// Invoked to free up to the specified amount of unused memory reservations by
+  /// reducing this memory pool's capacity without actually freeing up any
+  /// used memory. The function returns the actually freed memory bytes. If
+  /// 'targetBytes' is zero, the function frees all the unused memory reservation
+  /// bytes.
+  virtual uint64_t MemoryPool::shrink(uint64_t targetBytes = 0) = 0;
+
+  /// Invoked by the memory arbitrator to enter memory arbitration processing. It
+  /// is a noop if 'reclaimer_' is not set, otherwise invoke the reclaimer's
+  /// corresponding method.
+  virtual void MemoryPool::enterArbitration();
+
+  /// Invoked by the memory arbitrator to leave memory arbitration processing. It
+  /// is a noop if 'reclaimer_' is not set, otherwise invoke the reclaimer's
+  /// corresponding method.
+  virtual void MemoryPool::leaveArbitration();
+
+  /// Function estimates the number of reclaimable bytes and returns in
+  /// 'reclaimableBytes'. If the 'reclaimer' is not set, the function returns
+  /// std::nullopt. Otherwise, it will invoke the corresponding method of the
+  /// reclaimer.
+  virtual std::optional<uint64_t> reclaimableBytes() const = 0;
+
+  /// Invoked by the memory arbitrator to reclaim memory from this memory pool
+  /// with specified reclaim target bytes. If 'targetBytes' is zero, then it
+  /// tries to reclaim all the reclaimable memory from the memory pool. It is
+  /// noop if the reclaimer is not set, otherwise invoke the reclaimer's
+  /// corresponding method.
+  virtual uint64_t MemoryPool::reclaim(uint64_t targetBytes);
+
+Memory Arbitrator
+-----------------
+
+The memory arbitrator is used to arbitrate the memory capacity across running
+queries to achieve fair memory sharing and prevent a query from running out of
+its memory limit. To arbitrate memory capacity between running queries, the
+memory arbitrator needs to be able to reclaim the used memory from a query
+through techniques such as `disk spilling <https://facebookincubator.github.io/velox/develop/spilling.html>`_, and then transfer the freed memory
+between queries by adjusting their memory pool’s capacities accordingly (see
+`memory arbitration process section <#memory-arbitration-process>`_ for detail).
+
+The *MemoryArbitrator* is defined to support different implementations for
+different query systems. As for now, we implement *SharedArbitrator* for both
+Prestissimo and Prestissimo-on-Spark. `Gulten <https://github.com/oap-project/gluten>`_ implements its own memory
+arbitrator to integrate with the `Spark memory system <https://www.linkedin.com/pulse/apache-spark-memory-management-deep-dive-deepak-rajak/>`_. *SharedArbitrator*
+ensures the total allocated memory capacity is within the query memory limit
+(*MemoryManagerOptions::arbitratorCapacity*), and also ensures each individual
+query’s capacity is within the per-query memory limit (*MemoryPool::maxCapacity_*).
+When a query needs to grow its capacity, *SharedArbitrator* either reclaims the
+used memory from the query itself if it has exceeded its max memory capacity,
+or increases its capacity by reclaiming used memory from the other queries with
+the largest memory capacity in the system.
+
+Memory Arbitration Process
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. image:: images/memory-arbitration.png
+    :width: 800
+    :align: center
+    :alt: Memory Arbitration Process
+
+The end-to-end memory arbitration process in *SharedArbitrator* works as follows:
+
+#. The query operator A allocates memory from its leaf operator pool (operator
+   pool A)
+#. The operator pool A sends the memory reservation request to the root query
+   pool (query pool A)
+#. The query pool A is the root memory pool and it checks if the memory
+   reservation request is within the current capacity or not
+   (*MemoryPoolImpl::capacity_*). Let’s assume the request has exceeded the
+   current capacity to trigger memory arbitration
+#. The query pool A sends a request to the memory manager to grow its capacity
+   for the new reservation (*MemoryManager::growPool*)
+#. The memory manager forwards the request to the memory arbitrator
+   (*MemoryArbitrator::growCapacity*) with the requestor memory pool plus the list
+   of the root query pools as the memory arbitration candidates. The memory
+   manager keeps the candidate query pools alive during the memory arbitration
+   process
+#. The memory arbitrator serializes the memory arbitration processing with one
+   request at a time to ensure a consistent view of memory capacity allocated
+   among queries. The memory arbitrator might receive concurrent arbitration
+   requests from different queries or even from different driver threads of the
+   same query. For each memory arbitration request:
+
+   a. The memory arbitrator invokes *MemoryPool::enterArbitration* method of the
+      requestor memory pool before starting memory arbitration. The request
+      memory pool here is the operator pool A which initiates the memory
+      reservation request. It calls *MemoryReclaimer::enterArbitration* method of
+      the associated operator reclaimer (*Operator::MemoryReclaimer*). The
+      operator reclaimer puts the driver thread into the suspension state
+      (*Task::enterSuspended*). To reclaim memory from a query task, we need to
+      first pause the task to stop all its driver threads to avoid any
+      concurrent updates to its operator states during the memory reclamation.
+      If the query task of the request memory pool is chosen to reclaim memory,
+      then we have to put its driver thread into suspension state, otherwise
+      the query task will never be paused as the request driver thread is under
+      the memory arbitration process. Note a suspended driver thread is not
+      counted as running in task pause processing.
+
+   b. The memory arbitrator calls *SharedArbitrator::ensureCapacity* to check if
+      the requestor query pool exceeds its max memory capacity limit with the
+      new reservation or not (*MemoryPool::maxCapacity_*). If not, proceed to
+      step-6-c. Otherwise, the memory arbitrator tries to reclaim used memory
+      from the requestor pool itself. If memory reclamation has freed up
+      sufficient memory from the requestor pool for the new reservation within
+      its current capacity, then memory arbitration succeeds. If the requestor
+      pool still exceeds the max memory capacity limit, then memory arbitration
+      fails. Otherwise proceed to step-6-c.
+
+   c. The memory arbitrator runs the fast path
+      (*SharedArbitrator::reclaimFreeMemoryFromCandidates*) to reclaim the unused
+      memory reservations from the candidate query pools without actually
+      freeing the used memory. It first tries to reclaim from itself and then
+      from the candidate pools which have the most free capacity
+      (*MemoryPool::freeBytes*) until it reaches the memory reclaim target. Note
+      that we set the memory reclaim target to a large value
+      (*MemoryManagerOptions::memoryPoolTransferCapacity*) which could be more
+      than the actual needed size, to avoid the frequent memory arbitrations.
+
+   d. If the memory arbitrator hasn’t reclaimed enough free memory on fast
+      path, it runs the slow path
+      (*SharedArbitrator::reclaimUsedMemoryFromCandidates*) to reclaim the used
+      memory from the candidate pools with the most reclaimable memory (see
+      `memory reclaim process section <#memory-reclaim-process>`_ for the detailed memory
+      reclaim process within a query).
+
+   e. If the memory arbitrator has reclaimed enough memory, it grants the
+      reclaimed memory to the requestor pool by increasing its memory capacity
+      (*MemoryPool::grow*). If not, the memory arbitrator has to call
+      *SharedArbitrator::handleOOM* to send the memory pool abort
+      (*MemoryPool::abort*) request to the candidate memory pool with the largest
+      capacity as victim to free up memory to let the other running queries
+      with enough memory proceed. The memory pool abort fails the query
+      execution and waits for its completion to release all the held memory
+      resources.
+
+   f. If the victim query pool is the requestor pool itself, then memory
+      arbitration fails. Otherwise, go back to step-6-c to retry the memory
+      arbitration one more time before giving up.
+
+   g. The memory arbitrator invokes *MemoryPool::leaveArbitration* method of the
+      requestor memory pool at the end of memory arbitration. The operator
+      reclaimer moves its driver thread out of suspension state
+      (*Task::leaveSuspended*).
+
+Memory Reclaim Process
+^^^^^^^^^^^^^^^^^^^^^^
+
+Here is the memory reclaim process within a query:
+
+#. The memory arbitrator invokes *MemoryPool::reclaim* method of a candidate
+   query pool with a reclaim target in bytes, which calls the corresponding
+   method of the associated memory reclaimer object (*MemoryReclaimer::reclaim*).
+   The query pool uses the default implementation which sorts its child task
+   pools based on the reclaimable bytes (*MemoryPool::reclaimableBytes*), and
+   reclaim from the task with the most reclaimable bytes until reaches the
+   reclaim target
+
+#. The query pool invokes the reclaim method of the task pool which in turn
+   calls into the associated task reclaimer (*Task::MemoryReclaimer*). The
+   latter first pauses the task execution (*Task::requestPause*), and then
+   sorts its child node pools based on the reclaimable bytes and reclaims
+   memory from the node pools with the most reclaimable bytes. After reaching
+   the reclaim target or having reclaimed from all the node pools, task
+   reclaimer resumes the task execution (*Task::resume*)
+
+#. The task pool invokes the reclaim method of the node pool which reclaim
+   memory from its child operator pool with the most reclaimable bytes
+
+#. The node pool eventually calls the operator pool to do the actual memory
+   reclamation (*Operator::MemoryReclaimer*). Currently we support memory
+   reclamation through disk spilling and table writer flush. *Operator::reclaim*
+   is added to support memory reclamation with the default implementation does
+   nothing. Only spillable operators override that method: *OrderBy*, *HashBuild*,
+   *HashAggregation*, *RowNumber*, *TopNRowNumber*, *Window* and *TableWriter*.
+   As for now, we simply spill everything from the spillable operator’s row
+   container to free up memory. After we add memory compaction support for row
+   containers, we could leverage fine-grained disk spilling features in Velox
+   to only spill and free the required amounts of memory.
+
+Note memory arbitrator can’t reclaim from a spillable operator if it has
+triggered memory arbitration in the middle of data processing even after it
+has stopped its query task execution. To prevent this, we added
+*Operator::nonReclaimableSection_* to indicate if an operator is under a
+non-reclaimable section or not, and the memory arbitrator can’t reclaim memory
+from an operator which is under a non-reclaimable section. The driver execution
+framework sets a running operator in the non-reclaimable section by default.
+The spillable operator chooses to clear the non-reclaimable section at specific
+call sites such as the memory reservation (*MemoryPool::maybeReserve*) before the
+actual data processing to allow the memory arbitrator to reclaim memory.
+
+Memory Allocator
+----------------
+
+The memory allocator manages the physical memory allocations for both query
+memory allocated through memory pool and cache memory allocated directly from
+file cache. The memory allocator ensures the total allocated memory is always
+within the system memory limit. *MemoryAllocator* defines the memory allocator
+interface. We have two allocator implementations: *MallocAllocator* delegates
+all the memory allocations to std::malloc which is simple and reliable. We
+provide it as the default option but we believe it has the issue with RSS
+variation caused by memory fragmentation. Therefore we built *MMapAllocator* to
+manage the physical memory allocations using the std::mmap to have explicit
+control on RSS. We haven't yet confirmed whether *MmapAllocator* works better
+than *MallocAllocator*, but we are able to run a sizable Prestissimo workload
+using it. We will compare that workload using two allocators to determine which
+one is better in the future. Users can choose the allocator for their
+application by setting *MemoryManagerOptions::useMmapAllocator* (see
+`memory system setup section <#memory-system-setup>`_ for example).
+
+Non-Contiguous Allocation
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. image:: images/size-class.png
+    :width: 500
+    :align: center
+    :alt: Size Class
+
+A non-contiguous allocation is defined as an *Allocation* object which consists
+of a number of PageRun(s). Each page run contains a contiguous buffer and the
+buffers from different page runs don’t have to be contiguous. *MMapAllocator*
+defines *MmapAllocator::SizeClass* data structure (similar to the one used in
+`Umbra <https://db.in.tum.de/~freitag/papers/p29-neumann-cidr20.pdf>`_) to manage the non-contiguous allocation. A *SizeClass* object provides
+allocation of a fixed size buffer (class page) which is a power of 2 of a
+machine page size. *MMapAllocator* creates 9 different *SizeClass* objects with
+class page size ranging from 1 machine page (4KB) to 256 machine pages (1MB).
+To allocate a large number of machines pages, *MmapAllocator* calls
+*MemoryAllocator::allocationSize* to build the allocation plan
+(*MemoryAllocator::SizeMix*) which consists of a list of chosen *SizeClass* objects
+and the number of class pages to allocate from each of them.
+
+*MemoryAllocator::allocationSize* generates the allocation plan by searching from
+the largest fit *SizeClass* to the min *SizeClass* as specified by the user. If min
+*SizeClass* is not 1, there could be waste of memory in the last allocated class
+page. As the example in the diagram, for an allocation request of 150 pages and
+min *SizeClass* of 4, we choose to allocate 2 class pages from *SizeClass/64*, 1
+from *SizeClass/16* and 2 from *SizeClass/4*. The total number of allocated machine
+pages is 152. There are two machine pages wasted in the last allocated class
+page from *SizeClass/4*. The memory allocator allocates memory from each of the
+chosen *SizeClass* objects based on the allocation plan. The allocation result is
+returned in an *Allocation* object which consists of 4 page runs: two runs from
+*SizeClass/64* (the two allocated class pages are not contiguous in memory), one
+from *SizeClass/16* and one from *SizeClass/4* (the two allocated class pages are
+contiguous in memory).
+
+Each *SizeClass* object sets up its own memory space using std::mmap with the
+same size of the system memory limit. The setup memory space doesn’t cause any
+memory allocation from the OS (or have backing memory) until the user writes
+into the allocated memory space. The SizeClass object divides its own memory
+space into a number of class pages, and uses *SizeClass::pageAllocated_* bitmap
+to track if a class page is allocated or not. It uses the other bitmap
+*SizeClass::pageMapped_* to track if a class page has backing memory or not
+(mapped class page). To ensure RSS of Velox memory usage is within the system
+memory limit, we assume an allocated class page always has backing memory, and
+a freed class page also has backing memory until we call std::madvise to free
+it back to the OS. To free a class page, we just clear the allocation bit in
+*pageAllocated_* bitmap but we don’t call std::madvise to free the backing memory
+immediately as std::madvise is an expensive OS call. We also expect a freed
+class page is very likely to be reused again. Given that, we only remove
+backing memory of a freed class page for new allocation if the total number of
+mapped class pages reaches the system memory limit. *numMappedFreePages_* is used
+to track the number of freed class pages that still have backing memory in each
+*SizeClass* object. *SizeClass::adviseAway* implements the lazy backing memory
+free control logic.
+
+We apply two optimizations to accelerate the free class page lookup. One is to
+use an aggregated bitmap (*mappedFreeLookup_*) to track the free class pages in
+a group. Each bit in *mappedFreeLookup_* corresponds to 512 bits (8 words) in
+*pageAllocated_*. If a bit is set in *mappedFreeLookup_*, then at least one of 512
+bits in *pageAllocated_* is not set. The other is to use simd instruction to
+operate on the bitmap to further accelerate the cpu execution.
+
+The simplified *MmapAllocator::allocateNonContiguous* implementation:
+
+.. code-block:: c++
+
+  bool MmapAllocator::allocateNonContiguous(
+      MachinePageCount numPages,
+      Allocation& out,
+      ReservationCallback reservationCB,
+      MachinePageCount minSizeClass) override;
+
+#. calls *MemoryAllocator::allocationSize* with *numPages* and *minSizeClass*.
+   *numPages* specifies the number of machine pages to allocate. *minSizeClass*
+   specifies the minimum class page size to allocate from. The function returns
+   the number of class pages to allocate from each chosen *SizeClass* in
+   *MemoryAllocator::SizeMix*. The sum of machine pages to allocate from all
+   *SizeClass* objects should be no less than the requested *numPages*.
+
+#. increase the memory allocator’s memory usage and check if it exceeds the
+   system memory limit (*MemoryAllocator::capacity_*). If it exceeds, then fails
+   the allocation and reverts the memory usage update. Otherwise, proceeds to
+   make reservation in memory pool in step-3.
+
+   * *MMapAllocator* uses *MallocAllocator::numAllocated_* to count the allocated
+     memory in units of machines pages
+   * *MMapAllocator* allocations are wrapped by *AsyncDataCache::makeSpace* which
+     retries the allocation failure by shrinking the file cache for a number of
+     times before giving up. Each retry takes a backoff delay and make it
+     harder to evict from cache
+   * *AsyncDataCache::makeSpace* not only retries the allocation from the memory
+     pool but also from the file cache itself. In the latter case, the old
+     cache entries will be evicted out to make space for new cache data
+
+#. invokes *reservationCB* to increase the memory pool’s reservation to check if
+   the new allocation exceeds the query memory limit or not. If it exceeds, we
+   revert the memory usage update made in step-2 and re-throws the query memory
+   capacity exceeded exception caught from *reservationCB*. The *reservationCB* is
+   null if the allocation is from file cache.
+
+#. allocates class pages from each of chosen SizeClass objects. If any one of
+   the *SizeClass* allocation fails, then the entire allocation fails. We free
+   the succeeded *SizeClass* allocations, and revert the memory pool reservation
+   (step-3) and memory usage (step-2) updates.
+
+#. The class page allocations return the number of machine pages needed to set
+   up backing memory. This refers to the allocated class pages which don’t have
+   the backing memory and the corresponding bits in *SizeClass::pageMapped_* are
+   not set. We call *MmapAllocator::ensureEnoughMappedPages* to ensure the total
+   number of mapped class pages that have backing memory with this new
+   allocation doesn’t exceed the system memory limit. If it exceeds, we call
+   *MmapAllocator::adviseAway* to remove the backing memory of the freed class
+   pages. If *MmapAllocator::adviseAway* call fails, then we fail the allocation
+   and revert all the changes made in previous steps for this allocation.
+
+#. calls *MmapAllocator::markAllMapped* to set all the allocated class pages as
+   mapped in *SizeClass::pageMapped_* and the allocation succeeds.
+
+Contiguous Allocation
+^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: c++
+
+  virtual bool MemoryAllocator::allocateContiguous(
+     MachinePageCount numPages,
+     Allocation* collateral,
+     ContiguousAllocation& allocation,
+     ReservationCallback reservationCB = nullptr) = 0;
+
+Contiguous allocation is defined as a *ContiguousAllocation* object which
+contains a large contiguous buffer. It is used for very large contiguous buffer
+allocation (>1MB) like allocating a hash table. Its implementation is very
+simple. It calls std::mmap to allocate a contiguous chunk of physical memory
+from the OS directly. Similar to non-contiguous allocation, it needs to call
+*MmapAllocator::ensureEnoughMappedPages* to ensure the size of the mapped
+memory space is within the system memory limit. To free a contiguous
+allocation, the memory allocator calls std::munmap to return the physical
+memory back to the OS right away.
+
+Small Allocation
+^^^^^^^^^^^^^^^^
+
+.. code-block:: c++
+
+  void* MmapAllocator::allocateBytes(
+     uint64_t bytes,
+     uint16_t alignment = kMinAlignment) override;
+
+*MmapAllocator::allocateBytes* allocate memory in three different ways based on
+the actual allocation size (bytes). If the allocation size is smaller than a
+configured threshold (*MmapAllocator::Options::maxMallocBytes*), *MmapAllocator*
+delegates the allocation to std::malloc. If the allocation size is within class
+page size range (<= 1MB), it allocates the buffer as a class page from one of
+*SizeClass* objects. Otherwise, it allocates the buffer as a large contiguous
+allocation.
+
+We don’t expect many small memory allocations from the query systems using
+*MmapAllocator*. In Prestissimo, only very few small memory allocations are
+delegated to std::malloc. The large in-memory state such as *RowContainer* and
+*HashTable* allocate either contiguous or non-contiguous allocations. As for now,
+we don’t cap the memory allocations delegated to std::malloc in the
+*MmapAllocator*. We provide an option
+(*MmapAllocator::Options::smallAllocationReservePct*) for the query system to
+reserve a small amount of memory capacity in *MmapAllocator* to compensate for
+these ad-hoc small allocations in practice.
+
+Server OOM Prevention
+---------------------
+
+The memory allocator ensures all the memory usage from Velox doesn’t exceed
+system memory limit. This is critical to prevent the server from running out
+of memory as we expect Velox to use a significant portion of the server memory
+in operation. For instance, Prestissimo in Meta configures 80% of server memory
+for Velox and the rest 20% for the non-Velox components such as program binary,
+http streaming shuffle and remote storage client etc.
+
+However, the memory capacity enforcement in Velox itself is not sufficient to
+prevent the server from running out of memory in face of spiky memory usage
+from non-Velox components. For instance, we found in Prestissimo that the http
+streaming shuffle in a large Prestissimo setup (>400 workers) can cause very
+high spiky memory usage that easily leads to Prestissimo worker OOMs. In a
+large cluster, each worker (*PrestoExchangeSource*) might receive the streaming
+data from a large number of sources at the same time. The memory profiles
+collected at times close to OOM show that >50% of non-Velox memory are allocated
+from http proxygen. To prevent server OOM caused by http streaming shuffle, we
+added throttle control in Prestissimo streaming shuffle to limit the number of
+sources to read at a time to cap the streaming shuffle memory usage.
+
+In addition to building the throttle mechanism specific to each non-Velox
+component, we also provide a generic server memory pushback mechanism in Meta
+Prestissimo to collaborate with Velox to handle the spiky memory usage from
+non-Velox components. A *PeriodicMemoryChecker* is running in the background to
+check the system memory usage periodically. Whenever the system memory usage
+exceeds a certain threshold, it tries to free up memory from Velox by shrinking
+the file cache (*AsyncDataCache::shrink*), and returns the freed cache memory
+back to the OS. This way we can automatically shrink the file cache in response
+to the transient spiky memory usage from non-Velox components in a query system.
diff --git a/velox/docs/develop/operators.rst b/velox/docs/develop/operators.rst
index b1431e3101403..b7cac0c915e2b 100644
--- a/velox/docs/develop/operators.rst
+++ b/velox/docs/develop/operators.rst
@@ -50,6 +50,7 @@ TableWriteNode              TableWrite
 TableWriteMergeNode         TableWriteMerge
 PartitionedOutputNode       PartitionedOutput
 ExchangeNode                Exchange                                         Y
+ExpandNode                  Expand
 MergeExchangeNode           MergeExchange                                    Y
 ValuesNode                  Values                                           Y
 LocalMergeNode              LocalMerge
@@ -167,6 +168,10 @@ individual measures are sorted and de-duplicated.
      - One or more measures to compute. Each measure specifies an expression, e.g. count(1), sum(a), avg(b), optional boolean input column that's used to mask out rows for this particular measure, optional list of input columns to sort by before computing the measure, an optional flag to indicate that inputs must be deduplicated before computing the measure. Expressions must be in the form of aggregate function calls over input columns directly, e.g. sum(c) is ok, but sum(c + d) is not.
    * - ignoreNullKeys
      - A boolean flag indicating whether the aggregation should drop rows with nulls in any of the grouping keys. Used to avoid unnecessary processing for an aggregation followed by an inner join on the grouping keys.
+   * - globalGroupingSets
+     - If the AggregationNode is over a GroupIdNode, then some groups could be global groups which have only GroupId grouping key values. These represent global aggregate values.
+   * - groupId
+     - GroupId is the grouping key in the AggregationNode for the groupId column generated by an underlying GroupIdNode. It must be of BIGINT type.
 
 Properties of individual measures.
 
@@ -200,7 +205,7 @@ accumulators. This requires more memory as compared to when inputs do not need
 to be de-duplicated.
 
 Furthermore, many aggregate functions produce same results on sorted and
-unsorted inputs, e.g. func:`min`, func:`max`, :func:`count`, :func:`sum`.
+unsorted inputs, e.g. :func:`min`, :func:`max`, :func:`count`, :func:`sum`.
 The query planner should avoid generating plans that request sorted inputs
 for such aggregate functions. Some examples of aggregate functions that are
 sensitive to the order of inputs include :func:`array_agg` and :func:`min_by`
@@ -214,6 +219,211 @@ aggregate functions.
 Finally, note that computing measures over sorted input is only possible if
 aggregation step is 'single'. Such computations cannot be split into partial + final.
 
+To illustrate the need for globalGroupingSets and groupIdColumn, we examine the following SQL
+
+.. code-block:: sql
+
+  SELECT orderkey, sum(total_quantity) FROM orders GROUP BY CUBE (orderkey);
+
+This is equivalent to the following SQL with GROUPING SETS
+
+.. code-block:: sql
+
+  SELECT orderkey, sum(total_quantity) FROM orders GROUP BY GROUPING SETS ((orderkey), ());
+
+The SQL gives sub-totals of total_quantity for each orderkey along with the global sum (from the empty grouping set).
+
+The optimizer plans the above query as an Aggregation over a GroupId node.
+
+Lets say the orders table has 5 rows:
+
+.. code-block::
+
+  orderkey   total_quantity
+     1            5
+     2            6
+     2            7
+     3            8
+     4            9
+
+After GroupId for the grouping sets ((orderkey), ()) the table has the following 10 rows
+
+.. code-block::
+
+  orderkey   total_quantity    group_id
+     1            5                0
+     2            6                0
+     2            7                0
+     3            8                0
+     4            9                0
+     null         5                1
+     null         6                1
+     null         7                1
+     null         8                1
+     null         9                1
+
+A subsequent aggregation with grouping keys (orderkey, group_id) gives the sub-totals for the query
+
+.. code-block::
+
+  orderkey   total_quantity     group_id
+    1           5                  0
+    2           13                 0
+    3           8                  0
+    4           9                  0
+    null        35                 1
+
+If there were no input rows for this GROUP BY CUBE, then the expected result is a single row with the default value for the
+global aggregation. For the above query that would be:
+
+.. code-block::
+
+  orderkey   total_quantity      group_id
+    null           null             1
+
+To generate this special row the AggregationNode needs the groupId for the global grouping set (1 in this case) and it
+returns a single row for it with the aggregates default value.
+
+Note: Presto allows multiple global grouping sets in a single SQL query.
+
+.. code-block:: sql
+
+  SELECT orderkey, sum(total_quantity) FROM orders GROUP BY GROUPING SETS ((), ());
+
+Hence, globalGroupingSets is a vector of groupIds.
+
+.. _ExpandNode:
+
+ExpandNode
+~~~~~~~~~~~
+
+For each input row, generates N rows with M columns according to specified 'projections'.
+'projections' is an N x M matrix of expressions: a vector of N rows each having M columns.
+Each expression is either a column reference or a constant. Both null and non-null constants are allowed.
+'names' is a list of M new column names. The semantic of this operator matches Spark. Using project and unnest can be
+employed to implement the expand functionality. However, the performance is suboptimal when creating an array
+constructor within the Project operation.
+
+.. list-table::
+   :widths: 10 30
+   :align: left
+   :header-rows: 1
+
+   * - Property
+     - Description
+   * - projections
+     - A vector of N rows each having M columns. Each expression is either a column reference or a constant.
+   * - names
+     - A list of new column names.
+
+ExpandNode is typically used to compute GROUPING SETS, CUBE, ROLLUP and COUNT DISTINCT.   
+
+To illustrate how ExpandNode works lets examine the following SQL query:
+
+.. code-block:: sql
+
+  SELECT l_orderkey, l_partkey, count(l_suppkey) FROM lineitem GROUP BY ROLLUP(l_orderkey, l_partkey);
+
+In the planning phase, Spark generates an Expand operator with the following projection list:
+
+.. code-block::
+
+  [l_suppkey, l_orderkey, l_partkey, 0],
+  [l_suppkey, l_orderkey, null,      1],
+  [l_suppkey, null,       null,      3]
+
+Note: The last column serves as a special group ID, indicating the grouping set to which each row belongs. In Spark, this ID is calculated using a bitmask. If a certain column is selected, the bit value is assigned as 0; otherwise, it is assigned as 1. Therefore, the binary representation of the first row is (000), resulting in 0. The binary representation of the second row is (001), resulting in 1. The binary representation of the third row is (011), resulting in 3.
+
+For example, if the input rows are:
+
+.. code-block::
+
+  l_suppkey l_orderkey l_partkey
+  93        1          673
+  75        2          674
+  38        3          22
+
+After the computation by the ExpandNode, each row will generate 3 rows of data. So there will be a total of 9 rows:
+
+.. code-block::
+
+  l_suppkey l_orderkey l_partkey grouping_id_0 
+  93        1          673       0
+  93        1          null      1
+  93        null       null      3
+  75        2          674       0
+  75        2          null      1
+  75        null       null      3
+  38        3          22        0
+  38        3          null      1
+  38        null       null      3
+
+Aggregation operator that follows, groups these 9 rows by (l_orderkey, l_partkey, grouping_id_0) and computes count(l_suppkey):
+
+.. code-block::
+
+  l_orderkey l_partkey count(l_suppkey)
+  1          673       1
+  null       null      3
+  1          null      1
+  2          null      1
+  2          674       1
+  3          null      1
+  3          22        1
+
+Another example would be COUNT DISTINCT query.
+
+.. code-block:: sql
+
+  SELECT COUNT(DISTINCT l_suppkey), COUNT(DISTINCT l_partkey) FROM lineitem;
+
+In the planning phase, Spark generates an Expand operator with the following projection list:
+
+.. code-block::
+
+  [l_suppkey, null,      1],
+  [null,      l_partkey, 2]
+
+For example, if the input rows are:
+
+.. code-block::
+
+  l_suppkey l_partkey
+  93        673     
+  75        674      
+  38        22
+
+After the computation by the ExpandNode, each row will generate 2 rows of data. So there will be a total of 6 rows:
+
+.. code-block::
+
+  l_suppkey l_partkey grouping_id_0 
+  93        null      1
+  null      673       2
+  75        null      1
+  null      674       2
+  38        null      1
+  null      22        2
+
+Aggregation operator that follows, groups these rows by (l_suppkey, l_partkey, grouping_id_0) and produces:
+
+.. code-block::
+
+  l_suppkey l_partkey grouping_id_0 
+  93        null      1
+  75        null      1
+  38        null      1
+  null      673       2
+  null      674       2
+  null      22        2
+
+Another Aggregation operator that follows, computes global count(l_suppkey) and count(l_partkey) producing final result:
+
+.. code-block::
+
+  COUNT(DISTINCT l_suppkey) COUNT(DISTINCT l_partkey)
+  3                         3
+
 .. _GroupIdNode:
 
 GroupIdNode
@@ -233,8 +443,7 @@ followed by the group ID column. The type of group ID column is BIGINT.
    * - Property
      - Description
    * - groupingSets
-     - List of grouping key sets. Keys within each set must be unique, but keys can repeat across the sets.
-     - Grouping keys are specified with their output names.
+     - List of grouping key sets. Keys within each set must be unique, but keys can repeat across the sets. Grouping keys are specified with their output names.
    * - groupingKeyInfos
      - The names and order of the grouping key columns in the output.
    * - aggregationInputs
@@ -353,7 +562,9 @@ NestedLoopJoinNode
 NestedLoopJoinNode represents an implementation that iterates through each row from
 the left side of the join and, for each row, iterates through all rows from the right
 side of the join, comparing them based on the join condition to find matching rows
-and emitting results. Nested loop join supports non-equality join.
+and emitting results. Nested loop join supports non-equality joins, and emit output
+rows in the same order as the probe input (for inner and left outer joins) for each
+thread of execution.
 
 .. list-table::
    :widths: 10 30
@@ -383,7 +594,7 @@ identified sort fields as well as a sorting order.
    * - Property
      - Description
    * - sortingKeys
-     - List of one of more input columns to sort by.
+     - List of one of more input columns to sort by. Sorting keys must be unique.
    * - sortingOrders
      - Sorting order for each of the soring keys. The supported orders are: ascending nulls first, ascending nulls last, descending nulls first, descending nulls last.
    * - isPartial
@@ -406,7 +617,7 @@ operations.
    * - Property
      - Description
    * - sortingKeys
-     - List of one of more input columns to sort by.
+     - List of one of more input columns to sort by. Must not be empty and must not contain duplicates.
    * - sortingOrders
      - Sorting order for each of the soring keys. See OrderBy for the list of supported orders.
    * - count
@@ -523,7 +734,7 @@ distribution fields.
    * - keys
      - Zero or more input fields to use for calculating a partition for each row.
    * - numPartitions
-     - Number of partitions to split the data into.g
+     - Number of partitions to split the data into.
    * - replicateNullsAndAny
      - Boolean flag indicating whether rows with nulls in the keys should be sent to all partitions and, in case there are no such rows, whether a single arbitrarily chosen row should be sent to all partitions. Used to provide global-scope information necessary to implement anti join semantics on a single node.
    * - partitionFunctionFactory
@@ -707,7 +918,7 @@ next batch of input.
 
 This operator accumulates state: a hash table mapping partition keys to total
 number of rows seen in this partition so far. Returning the row numbers as
-a column in the output is optional. This operator doesn't support spilling yet.
+a column in the output is optional. This operator supports spilling.
 
 This operator is equivalent to a WindowNode followed by
 FilterNode(row_number <= limit), but it uses less memory and CPU and makes
@@ -752,9 +963,9 @@ FilterNode(row_number <= limit), but it uses less memory and CPU.
   * - Property
     - Description
   * - partitionKeys
-    - Partition by columns for the window functions.
+    - Partition by columns for the window functions. May be empty.
   * - sortingKeys
-    - Order by columns for the window functions.
+    - Order by columns for the window functions. Must not be empty and must not overlap with 'partitionKeys'.
   * - sortingOrders
     - Sorting order for each sorting key above. The supported sort orders are asc nulls first, asc nulls last, desc nulls first and desc nulls last.
   * - rowNumberColumnName
diff --git a/velox/docs/develop/scalar-functions.rst b/velox/docs/develop/scalar-functions.rst
index 52c3dd795e2a0..b1e79bbd0aa68 100644
--- a/velox/docs/develop/scalar-functions.rst
+++ b/velox/docs/develop/scalar-functions.rst
@@ -15,8 +15,10 @@ ceil function can be implemented as:
 
 .. code-block:: c++
 
-  template <typename TExecParams>
+  template <typename TExec>
   struct CeilFunction {
+    VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
     template <typename T>
     FOLLY_ALWAYS_INLINE void call(T& result, const T& a) {
       result = std::ceil(a);
@@ -36,22 +38,25 @@ function to be called on different input types, e.g. float and double. Note
 that template instantiation will only happen during function registration,
 described in the "Registration" section below.
 
-Please avoid using the obsolete VELOX_UDF_BEGIN/VELOX_UDF_END macros.
+Do not use legacy VELOX_UDF_BEGIN and VELOX_UDF_END macros.
 
 The "call" function (or one of its variations) may return (a) void indicating
 the function never returns null values, or (b) boolean indicating whether
-the result of the computation is null. True means the result is not null;
-false means the result is null. If "ceil(0)" were to return null, the function
-above could be re-written as follows:
+the result of the computation is null. The meaning of the returned boolean is
+"result was set", i.e. true means non-null result was populated, false means
+no (null) result. If "ceil(0)" were to return a null, the function could be
+re-written as follows:
 
 .. code-block:: c++
 
-  template <typename TExecParams>
+  template <typename TExec>
   struct NullableCeilFunction {
+    VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
     template <typename T>
     FOLLY_ALWAYS_INLINE bool call(T& result, const T& a) {
       result = std::ceil(a);
-      return a != 0;
+      return a != 0; // Return NULL if input is zero.
     }
   };
 
@@ -60,28 +65,56 @@ The argument list must start with an output parameter “result” followed by t
 function arguments. The “result” argument must be a reference. Function
 arguments must be const references. The C++ types of the function arguments and
 the result argument must match :doc:`Velox types</develop/types>`.
-Since the result argument must be a reference, some of the types listed below
-have a different result argument type:
 
 ==========  ==============================  =============================
 Velox Type  C++ Argument Type               C++ Result Type
 ==========  ==============================  =============================
-VARCHAR     StringView                      out_type<Varchar>
-VARBINARY   StringView                      out_type<Varbinary>
+BOOLEAN     arg_type<bool>                  out_type<bool>
+TINYINT     arg_type<int8_t>                out_type<int8_t>
+SMALLINT    arg_type<int16_t>               out_type<int16_t>
+INTEGER     arg_type<int32_t>               out_type<int32_t>
+BIGINT      arg_type<int64_t>               out_type<int64_t>
+REAL        arg_type<float>                 out_type<float>
+DOUBLE      arg_type<double>                out_type<double>
+TIMESTAMP   arg_type<Timestamp>             out_type<Timestamp>
+DATE        arg_type<Date>                  out_type<Date>
+VARCHAR     arg_type<Varchar>               out_type<Varchar>
+VARBINARY   arg_type<Varbinary>             out_type<Varbinary>
 ARRAY       arg_type<Array<E>>              out_type<Array<E>>
 MAP         arg_type<Map<K,V>>              out_type<Map<K, V>>
 ROW         arg_type<Row<T1, T2, T3,...>>   out_type<Row<T1, T2, T3,...>>
 ==========  ==============================  =============================
 
-arg_type and out_type templates are defined by using the
-VELOX_DEFINE_FUNCTION_TYPES(TExecParams) macro in the class definition. These
-types provide interfaces similar to std::string, std::vector, std::unordered_map
-and std::tuple. The underlying implementations are optimized to read and write
-from and to the columnar representation without extra copying.
+arg_type and out_type templates are defined by the
+VELOX_DEFINE_FUNCTION_TYPES(TExec) macro in the struct definition. For
+primitive types, arg_type<T> is the same as out_type<T> and the same as T.
+This holds for boolean, integers, floating point types and timestamp.
+For DATE, arg_type<Date> is the same as out_type<Date> and is defined as int32_t.
+
+A signature of a function that takes an integer and a double and returns
+a double would look like this:
+
+.. code-block:: c++
+
+    void call(arg_type<double>& result, const arg_type<int32_t>& a, const arg_type<double>& b)
+
+Which is equivalent to
+
+.. code-block:: c++
+
+    void call(double& result, const int32_t& a, const double& b)
+
+For strings, arg_type<Varchar> is defined as StringView, while out_type<Varchar>
+is defined as StringWriter.
+
+arg_type and out_type for Varchar, Array, Map and Row provide interfaces similar
+to std::string, std::vector, std::unordered_map and std::tuple. The underlying
+implementations are optimized to read and write from and to the columnar
+representation without extra copying. More explanation and the APIs of the arg_type
+and out_type for string and complex types can be found in :doc:`view-and-writer-types`.
 
 Note: Do not pay too much attention to complex type mappings at the moment.
-They are included here for completeness, but require a whole separate
-discussion.
+They are included here for completeness.
 
 Null Behavior
 ^^^^^^^^^^^^^
@@ -95,7 +128,7 @@ an artificial example of a ceil function that returns 0 for null input:
 
 .. code-block:: c++
 
-  template <typename TExecParams>
+  template <typename TExec>
   struct CeilFunction {
     template <typename T>
     FOLLY_ALWAYS_INLINE void callNullable(T& result, const T* a) {
@@ -133,9 +166,9 @@ an array:
 
 .. code-block:: c++
 
-  template <typename TExecParams>
+  template <typename TExec>
   struct ArrayMinFunction {
-    VELOX_DEFINE_FUNCTION_TYPES(TExecParams);
+    VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
     template <typename TInput>
     FOLLY_ALWAYS_INLINE bool callNullFree(
@@ -173,7 +206,7 @@ An example of such function is rand():
 
 .. code-block:: c++
 
-  template <typename TExecParams>
+  template <typename TExec>
   struct RandFunction {
     static constexpr bool is_deterministic = false;
 
@@ -205,9 +238,9 @@ Here is an example of a trim function:
 
 .. code-block:: c++
 
-  template <typename TExecParams>
+  template <typename TExec>
   struct TrimFunction {
-    VELOX_DEFINE_FUNCTION_TYPES(TExecParams);
+    VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
     // ASCII input always produces ASCII result.
     static constexpr bool is_default_ascii_behavior = true;
@@ -241,11 +274,39 @@ not go away prematurely. The output types can be scalar strings (varchar and
 varbinaries), but also complex types containing strings, such as arrays, maps,
 and rows.
 
+The setNoCopy method of the out_type template can be used to set the result
+to a string in the input argument without copying. The setEmpty method
+can be used to set the result to an empty string.
+
 .. code-block:: c++
 
   // Results refer to strings in the first argument.
   static constexpr int32_t reuse_strings_from_arg = 0;
 
+
+Here is an example of a zero-copy function:
+
+.. code-block:: c++
+
+  template <typename TExec>
+  struct TrimFunction {
+    VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+    // Results refer to strings in the first argument.
+    static constexpr int32_t reuse_strings_from_arg = 0;
+
+    FOLLY_ALWAYS_INLINE void call(
+        out_type<Varchar>& result,
+        const arg_type<Varchar>& input) {
+      if (input.size() == 0) {
+        result.setEmpty();
+        return;
+      }
+      result.setNoCopy(stringImpl::trimUnicodeWhiteSpace(input));
+    }
+  };
+
+
 Access to Session Properties and Constant Inputs
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -267,13 +328,14 @@ properties and using it when processing inputs.
 
 .. code-block:: c++
 
-  template <typename TExecParams>
+  template <typename TExec>
   struct HourFunction {
-    VELOX_DEFINE_FUNCTION_TYPES(TExecParams);
+    VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
-    const date::time_zone* timeZone_ = nullptr;
+    const tz::TimeZone* timeZone_ = nullptr;
 
     FOLLY_ALWAYS_INLINE void initialize(
+        const std::vector<TypePtr>& inputTypes,
         const core::QueryConfig& config,
         const arg_type<Timestamp>* /*timestamp*/) {
       timeZone_ = getTimeZoneFromConfig(config);
@@ -296,14 +358,15 @@ individual rows.
 
 .. code-block:: c++
 
-  template <typename TExecParams>
+  template <typename TExec>
   struct DateTruncFunction {
-    VELOX_DEFINE_FUNCTION_TYPES(TExecParams);
+    VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
-    const date::time_zone* timeZone_ = nullptr;
+    const tz::TimeZone* timeZone_ = nullptr;
     std::optional<DateTimeUnit> unit_;
 
     FOLLY_ALWAYS_INLINE void initialize(
+        const std::vector<TypePtr>& inputTypes,
         const core::QueryConfig& config,
         const arg_type<Varchar>* unitString,
         const arg_type<Timestamp>* /*timestamp*/) {
@@ -359,356 +422,68 @@ we need to call registerFunction again:
 
 We need to call registerFunction for each signature we want to support.
 
-Codegen
-^^^^^^^
-
-To allow the function to be used in the codegen, extract the “kernel” of the
-function into a header file and call that from the “call” or “callNullable”.
-Here is an example with ceil function.
-
-.. code-block:: c++
-
-  #include "velox/functions/prestosql/ArithmeticImpl.h"
-
-  template <typename TExecParams>
-  struct CeilFunction {
-    template <typename T>
-    FOLLY_ALWAYS_INLINE bool call(T& result, const T& a) {
-      result = ceil(a);
-      return true;
-    }
-  };
-
-velox/functions/prestosql/ArithmeticImpl.h:
+Here is a mapping from Velox types to C++ types that should be used for
+argument and return types during registration.
+
+==========  =====================
+Velox Type  C++ Type
+==========  =====================
+BOOLEAN     bool
+TINYINT     int8_t
+SMALLINT    int16_t
+INTEGER     int32_t
+BIGINT      int64_t
+REAL        float
+DOUBLE      double
+TIMESTAMP   Timestamp
+DATE        Date
+VARCHAR     Varchar
+VARBINARY   Varbinary
+ARRAY       Array<E>
+MAP         Map<K,V>
+ROW         Row<T1, T2, T3,...>
+==========  =====================
+
+For example, to register array_min function for string inputs:
 
 .. code-block:: c++
 
-  template <typename T>
-  T ceil(const T& arg) {
-    T results = std::ceil(arg);
-    return results;
-  }
-
-Make sure the header files that define the “kernels” are free of dependencies
-as much as possible to allow for faster compilation in codegen.
+    registerFunction<ArrayMinFunction, Varchar, Array<Varchar>>({"array_min"});
 
-Complex Types
-^^^^^^^^^^^^^
-
-Inputs (View Types)
-*******************
-Input complex types are represented in the simple function interface using light-weight lazy
-access abstractions that enable efficient direct access to the underlying data in Velox
-vectors.
-As mentioned earlier, the helper aliases arg_type and null_free_arg_type can be used in function's signatures to
-map Velox types to the corresponding input types. The table below shows the actual types that are
-used to represent inputs of different complex types.
-
-==============================    =========================   ==============================
- C++ Argument Type                 C++ Actual Argument Type   Corresponding `std` type
-==============================    =========================   ==============================
-arg_type<Array<E>>                NullableArrayView<E>>       std::vector<std::optional<V>>
-arg_type<Map<K,V>>                NullableMapView<K, V>       std::map<K, std::optional<V>>
-arg_type<Row<T...>>               NullableRowView<T...>       std::tuple<std::optional<T>...
-null_free_arg_type<Array<E>>      NullFreeArrayView<E>        std::vector<V>
-null_free_arg_type<Map<K,V>>      NullFreeMapView<K, V>       std::map<K, V>
-null_free_arg_type<Row<T...>>>    NullFreeRowView<T...>       std::tuple<T...>
-==============================    =========================   ==============================
-
-The view types are designed to have interfaces similar to those of std::containers, in fact in most cases
-they can be used as a drop in replacement. The table above shows the mapping between the Velox type and
-the corresponding std type. For example: a *Map<Row<int, int>, Array<float>>* corresponds to const
-*std::map<std:::tuple<int, int>, std::vector<float>>*.
-
-All views types are cheap to copy objects, for example the size of ArrayView is 16 bytes at max.
-
-**OptionalAccessor<E>**:
-
-OptionalAccessor is an *std::optional* like object that provides lazy access to the nullity and
-value of the underlying Velox vector at a specific index. Currently, it is used to represent elements of nullable input arrays
-and values of nullable input maps. Note that keys in the map are assumed to be always not nullable in Velox.
-
-The object supports the following methods:
-
-- arg_type<E> value()      : unchecked access to the underlying value.
-
-- arg_type<E> operator \*() : unchecked access to the underlying value.
-
-- bool has_value()         : return true if the value is not null.
-
-- bool operator()          : return true if the value is not null.
-
-The nullity and the value accesses are decoupled, and hence if someone knows inputs are null-free,
-accessing the value does not have the overhead of checking the nullity. So is checking the nullity.
-Note that, unlike std::container, function calls to value() and operator* are r-values (temporaries) and not l-values,
-they can bind to const references and l-values but not references.
-
-OptionalAccessor<E> is assignable to and comparable with std::optional<arg_type<E>> for primitive types.
-The following expressions are valid, where array[0] is an optional accessor.
+To register array_min function for arrays of any type, use Generic<T1> for the element type:
 
 .. code-block:: c++
 
-    std::optional<int> = array[0];
-    if(array[0] == std::nullopt) ...
-    if(std::nullopt == array[0]) ...
-    if(array[0]== std::optional<int>{1}) ...
+    registerFunction<ArrayMinFunction, Generic<T1>, Array<Generic<T1>>>({"array_min"});
 
-**NullableArrayView<T> and NullFreeArrayView<T>**
-
-NullableArrayView and NullFreeArrayView have interfaces similar to that of *std::vector<std::optional<V>>* and *std::vector<V>*,
-the code below shows the function arraySum, a range loop is used to iterate over the values.
+Since array_min needs to sort the elements to find the smallest, the element
+type needs to be orderable. You can restrict array elements to orderable types
+using Orderable<T1>.
 
 .. code-block:: c++
 
-  template <typename T>
-  struct ArraySum {
-    VELOX_DEFINE_FUNCTION_TYPES(T);
-
-    bool call(const int64_t& output, const arg_type<Array<int64_t>>& array) {
-      output = 0;
-      for(const auto& element : array) {
-        if (element.has_value()) {
-          output += element.value();
-        }
-      }
-      return true;
-    }
-  };
-
-
-ArrayView supports the following:
-
-- size_t size() : return the number of elements in the array.
+    registerFunction<ArrayMinFunction, Orderable<T1>, Array<Orderable<T1>>>({"array_min"});
 
-- operator[](size_t index) : access element at index. It returns either null_free_arg_type<T> or OptionalAccessor<T>.
-
-- ArrayView<T>::Iterator begin() : iterator to the first element.
-
-- ArrayView<T>::Iterator end() : iterator indicating end of iteration.
-
-- bool mayHaveNulls() : constant time check on the underlying vector nullity. When it returns false, there are definitely no nulls, a true does not guarantee null existence.
-
-- ArrayView<T>::SkipNullsContainer SkipNulls() : return an iterable container that provides direct access to non-null values in the underlying array. For example, the function above can be written as:
+You can use multiple generic types in a function signature. For example, to register
+map_top_n function:
 
 .. code-block:: c++
 
-  template <typename T>
-  struct ArraySum {
-    VELOX_DEFINE_FUNCTION_TYPES(T);
+    registerFunction<
+        MapTopNFunction,
+        Map<Generic<T1>, Orderable<T2>>,    // result map type
+        Map<Generic<T1>, Orderable<T2>>,    // input map type
+        int64_t                             // type of N argument
+    >({"map_top_n"});
 
-    bool call(const int64_t& output, const arg_type<Array<int64_t>>& array) {
-      output = 0;
-      for (const auto& value : array.skipNulls()) {
-        output += value;
-      }
-      return true;
-    }
-  };
+Generic types must use T1, T2, T3... naming.
 
-The skipNulls iterator will check the nullity at each index and skip nulls, a more performant implementation
-would skip reading the nullity when mayHaveNulls() is false.
+Finally, you can specify that an argument must be constant using Constant<T>.
+For example, to specify rand signature with a constant seed argument:
 
 .. code-block:: c++
 
-  template <typename T>
-  struct ArraySum {
-      VELOX_DEFINE_FUNCTION_TYPES(T);
-
-      bool call(const int64_t& output, const arg_type<Array<int64_t>>& array) {
-        output = 0;
-        if (array.mayHaveNulls()) {
-          for(const auto& value : array.skipNulls()) {
-            output += value;
-          }
-          return true;
-        }
-
-        // No nulls, skip reading nullity.
-        for (const auto& element : array) {
-          output += element.value();
-        }
-        return true;
-      }
-  };
-
-Note: calls to operator[], iterator de-referencing, and iterator pointer de-referencing are r-values (temporaries),
-versus l-values in STD containers. Hence those can be bound to const references or l-values but not normal references.
-
-**NullableMapView<K, V> and  NullFreeMapView<K, V>**
-
-NullableMapView and NullFreeMapView has an interfaces similar to std::map<K, std::optional<V>> and std::map<K, V>,
-the code below shows an example function mapSum, sums up the keys and values.
-
-.. code-block:: c++
-
-  template <typename T>
-  struct MapSum{
-    bool call(const int64_t& output, const arg_type<Map<int64_t, int64_t>>& map) {
-      output = 0;
-      for (const auto& [key, value] : map) {
-        output += key;
-        if (value.has_value()) {
-          value += value.value();
-        }
-      }
-      return true;
-    }
-  };
-
-MapView supports the following:
-
-- MapView<K,V>::Element begin() : iterator to the first map element.
-
-- MapView<K,V>::Element end()   : iterator that indicates end of iteration.
-
-- size_t size()                 : number of elements in the map.
-
-- MapView<K,V>::Iterator find(const key_t& key): performs a linear search for the key, and returns iterator to the element if found otherwise returns end(). Only supported for primitive key types.
-
-- MapView<K,V>::Iterator operator[](const key_t& key): same as find, throws an exception if element not found.
-
-- MapView<K,V>::Element
-
-MapView<K, V>::Element is the type returned by dereferencing MapView<K, V>::Iterator. It has two members:
-
-- first : arg_type<K> | null_free_arg_type<K>
-
-- second: OptionalAccessor<V> | null_free_arg_type<V>
-
-- MapView<K, V>::Element participates in struct binding: auto [v, k] = \*map.begin();
-
-Note: iterator de-referencing and iterator pointer de-referencing result in temporaries. Hence those can be bound to
-const references or value variables but not normal references.
-
-
-**Temporaries lifetime C++**
-
-While c++ allows temporaries(r-values) to bound to const references by extending their lifetime, one must be careful and
-know that only the assigned temporary lifetime is extended but not all temporaries in the RHS expression chain.
-In other words, the lifetime of any temporary within an expression is not extended.
-
-For example, for the expression const auto& x = map.begin()->first.
-c++ does not extend the lifetime of the result of map.begin() since it's not what is being
-assigned. And in such a case, the assignment has undefined behavior.
-
-.. code-block:: c++
-
-     // Safe assignments. single rhs temporary.
-     const auto& a = array[0];
-     const auto& b = *a;
-     const auto& c = map.begin();
-     const auto& d = c->first;
-
-     // Unsafe assignments. (undefined behaviours)
-     const auto& a = map.begin()->first;
-     const auto& b = **it;
-
-     // Safe and cheap to assign to value.
-     const auto a = map.begin()->first;
-     const auto b = **it;
-
-Note that in the range-loop, the range expression is assigned to a universal reference. Thus, the above concern applies to it.
-
-.. code-block:: c++
-
-     // Unsafe range loop.
-     for(const auto& e : **it){..}
-
-     // Safe range loop.
-     auto itt = *it;
-     for(const auto& e : *itt){..}
-
-.. _outputs-write:
-
-Outputs (Writer Types)
-**********************
-
-Outputs of complex types are represented using special writers that are designed in a way that
-minimizes data copying by writing directly to Velox vectors.
-
-**ArrayWriter<V>**
-
-- out_type<V>& add_item() : add non-null item and return the writer of the added value.
-- add_null(): add null item.
-- reserve(vector_size_t size): make sure space for `size` items is allocated in the underlying vector.
-- vector_size_t size(): get the length of the array.
-- resize(vector_size_t size): change the size of the array reserving space for the new elements if needed.
-
-- void add_items(const T& data): append data from any container with std::vector-like interface.
-- void copy_from(const T& data): assign data to match that of any container with std::vector-like interface.
-
-- void add_items(const NullFreeArrayView<V>& data): append data from array view (faster than item by item).
-- void copy_from(const NullFreeArrayView<V>& data): assign data from array view (faster than item by item).
-
-- void add_items(const NullableArrayView<V>& data): append data from array view (faster than item by item).
-- void copy_from(const NullableArrayView<V>& data): assign data from array view (faster than item by item).
-
-When V is primitive, the following functions are available, making the writer usable as std::vector<V>.
-
-- push_back(std::optional<V>): add item or null.
-- PrimitiveWriter<V> operator[](vector_size_t index): return a primitive writer that is assignable to std::optional<V> for the item at index (should be called after a resize).
-- PrimitiveWriter<V> back(): return a primitive writer that is assignable to std::optional<V> for the item at index length -1.
-
-
-**MapWriter<K, V>**
-
-- reserve(vector_size_t size): make sure space for `size` entries is allocated in the underlying vector.
-- std::tuple<out_type<K>&, out_type<V>&> add_item(): add non-null item and return the writers of key and value as tuple.
-- out_type<K>& add_null(): add null item and return the key writer.
-- vector_size_t size(): return the length of the array.
-
-- void add_items(const T& data): append data from any container with std::vector<tuple<K, V>> like interface.
-- void copy_from(const NullFreeMapView<V>& data): assign data from array view (faster than item by item).
-- void copy_from(const NullableMapView<V>& data): assign data from array view (faster than item by item).
-
-When K and V are primitives, the following functions are available, making the writer usable as std::vector<std::tuple<K, V>>.
-
-- resize(vector_size_t size): change the size.
-- emplace(K, std::optional<V>): add element to the map.
-- std::tuple<K&, PrimitiveWriter<V>> operator[](vector_size_t index): returns pair of writers for element at index. Key writer is assignable to K. while value writer is assignable to std::optional<V>.
-
-**RowWriter<T...>**
-
-- template<vector_size_t I> set_null_at(): set null for row item at index I.
-- template<vector_size_t I> get_writer_at(): set not null for row item at index I, and return writer to to the row element at index I.
-
-When all types T... are primitives, the following functions are available.
-
-- void operator=(const std::tuple<T...>& inputs): assignable to std::tuple<T...>.
-- void operator=(const std::tuple<std::optional<T>...>& inputs): assignable to std::tuple<std::optional<T>...>.
-- void copy_from(const std::tuple<K...>& inputs): similar as the above.
-
-When a given Ti is primitive, the following is valid.
-
-- PrimitiveWriter<Ti> exec::get<I>(RowWriter<T...>): return a primitive writer for item at index I that is assignable to std::optional.
-
-**PrimitiveWriter<T>**
-
-Assignable to std::optional<T> allows writing null or value to the primitive. Returned by complex writers when writing nullable
-primitives.
-
-**StringWriter<>**:
-
-- void reserve(size_t newCapacity) : Reserve a space for the output string with size of at least newCapacity.
-- void resize(size_t newCapacity) : Set the size of the string.
-- char* data(): returns pointer to the first char of the string, can be written to directly (safe to write to index at capacity()-1).
-- vector_size_t capacity(): returns the capacity of the string.
-- vector_size_t size(): returns the size of the string.
-- operator+=(const T& input): append data from char* or any type with data() and size().
-- append(const T& input): append data from char* or any type with data() and size().
-- copy_from(const T& input): append data from char* or any type with data() and size().
-
-When Zero-copy optimization is enabled (see zero-copy-string-result section above), the following functions can be used.
-
-- void setEmpty(): set to empty string.
-- void setNoCopy(const StringView& value): set string to an input string without performing deep copy.
-
-
-Limitations
-***********
-1. If a function throws an exception while writing a complex type, then the output of the
-row being written as well as the output of the next row are undefined. Hence, it's recommended
-to avoid throwing exceptions after writing has started for a complex output within the function.
+    registerFunction<RandFunction, double, Constant<int32_t>>({"rand"});
 
 Variadic Arguments
 ^^^^^^^^^^^^^^^^^^
@@ -768,7 +543,10 @@ Vector Functions
 
 Simple functions process a single row and produce a single value as a result.
 Vector functions process a batch or rows and produce a vector of results.
-Some of the defining features of these functions are:
+When implementing a function, simple function is preferred unless the implementation
+of vector function provides a significant performance gain which can be demonstrated
+with a benchmark.
+Some of the defining features of vector functions are:
 
 - take vectors as inputs and produce vectors as a result;
 - have access to vector encodings and metadata;
@@ -805,15 +583,9 @@ The “rows” parameter specifies the set of rows in the incoming batch to
 process. This set may not include all the rows. By default, a vector function
 is assumed to have the default null behavior, e.g. null in any input produces
 a null result. In this case, the expression evaluation engine will exclude
-rows with nulls from the “rows” specified in the call to “apply”. If a
-function has a different behavior for null inputs, it must override the
-isDefaultNullBehavior method to return false.
-
-.. code-block:: c++
-
-    bool isDefaultNullBehavior() const override {
-      return false;
-    }
+rows with nulls from the “rows” specified in the call to “apply”. If a function
+has a different behavior for null inputs, it must specify that during registration.
+See :ref:`vector function registration<Registration>` for more details.
 
 In this case, the “rows” parameter will include rows with null inputs and the
 function will need to handle these. By default, the function can assume that
@@ -866,14 +638,9 @@ of the function arguments. These vectors are not necessarily flat and may be
 dictionary or constant encoded. However, a deterministic function that takes
 a single argument and has default null behavior is guaranteed to receive its
 only input as a flat or constant vector. By default, a function is assumed to
-be deterministic. If that’s not the case, the function must override
-isDeterministic method to return false.
-
-.. code-block:: c++
-
-    bool isDeterministic() const override {
-      return false;
-    }
+be deterministic. If that’s not the case, it must specify the non-deterministic
+behavior during registration. See :ref:`vector function registration<Registration>`
+for more details.
 
 Note that :ref:`decoded-vector` can be used to get a flat vector-like interface to any
 vector. A helper class exec::DecodedArgs can be used to decode multiple arguments.
@@ -999,8 +766,8 @@ and eliminate the overhead of calling DecodedVector::valueAt template.
 .. code-block:: c++
 
     if (base->isIdentityMapping() && exp->isIdentityMapping()) {
-      auto baseValues = base->values<double>();
-      auto expValues = exp->values<double>();
+      auto baseValues = base->data<double>();
+      auto expValues = exp->data<double>();
       rows.applyToSelected([&](int row) {
         rawResults[row] = std::pow(baseValues[row], expValues[row]);
       });
@@ -1017,13 +784,13 @@ exponent.
 .. code-block:: c++
 
     if (base->isIdentityMapping() && exp->isIdentityMapping()) {
-      auto baseValues = base->values<double>();
-      auto expValues = exp->values<double>();
+      auto baseValues = base->data<double>();
+      auto expValues = exp->data<double>();
       rows.applyToSelected([&](int row) {
         rawResults[row] = std::pow(baseValues[row], expValues[row]);
       });
     } else if (base->isIdentityMapping() && exp->isConstantMapping()) {
-      auto baseValues = base->values<double>();
+      auto baseValues = base->data<double>();
       auto expValue = exp->valueAt<double>(0);
       rows.applyToSelected([&](int row) {
         rawResults[row] = std::pow(baseValues[row], expValue);
@@ -1084,6 +851,8 @@ Simple functions are compatible with the TRY expression by default. The framewor
 wraps the “call” and “callNullable” methods in a try-catch and reports errors
 using context.setError.
 
+.. _Registration:
+
 Registration
 ^^^^^^^^^^^^
 
@@ -1095,12 +864,22 @@ Use exec::registerVectorFunction to register a stateless vector function.
         const std::string& name,
         std::vector<FunctionSignaturePtr> signatures,
         std::unique_ptr<VectorFunction> func,
+        VectorFunctionMetadata metadata = {},
         bool overwrite = true)
 
 exec::registerVectorFunction takes a name, a list of supported signatures
-and unique_ptr to an instance of the function. An optional “overwrite” flag
-specifies whether to overwrite a function if a function with the specified
-name already exists.
+and unique_ptr to an instance of the function. It takes an optional 'metadata'
+parameter that specifies whether a function is deterministic, has default null
+behavior, and other properties. A helper VectorFunctionMetadataBuilder class
+allows to easily construct 'metadata'. For example,
+
+.. code-block:: c++
+
+    VectorFunctionMetadataBuilder().defaultNullBehavior(false).build();
+
+
+An optional “overwrite” flag specifies whether to overwrite a function if a function
+with the specified name already exists.
 
 Use exec::registerStatefulVectorFunction to register a stateful vector
 function.
@@ -1115,6 +894,7 @@ to a vector function over an equivalent simple function.
         const std::string& name,
         std::vector<FunctionSignaturePtr> signatures,
         VectorFunctionFactory factory,
+        VectorFunctionMetadata metadata = {},
         bool overwrite = true)
 
 exec::registerStatefulVectorFunction takes a name, a list of supported
@@ -1182,15 +962,14 @@ argument in order.
 
 The concat function takes an arbitrary number of varchar inputs and returns a
 varchar. FunctionSignatureBuilder allows specifying that the last augment may
-appear zero or more times by calling variableArity() method.
+appear zero or more times by calling variableArity("varchar") method.
 
 .. code-block:: c++
 
     // varchar... -> varchar
     exec::FunctionSignatureBuilder()
         .returnType("varchar")
-        .argumentType("varchar")
-        .variableArity()
+        .variableArity("varchar")
         .build()
 
 The map_keys function takes any map and returns an array of map keys.
diff --git a/velox/docs/develop/simd.rst b/velox/docs/develop/simd.rst
index 7c8eb09582480..69653d16f90c9 100644
--- a/velox/docs/develop/simd.rst
+++ b/velox/docs/develop/simd.rst
@@ -178,4 +178,4 @@ mask.
 
 Note when the data type is 16 bits long, we need to do the process in 2 batches
 (``loadIndices(0)`` and ``loadIndices(1)``), because the indices are 32 bits
-long and one SIME vector is not large enough to contain all the indices needed.
+long and one SIMD vector is not large enough to contain all the indices needed.
diff --git a/velox/docs/develop/spilling.rst b/velox/docs/develop/spilling.rst
index 2f67e74f09f1a..6a96afe07c265 100644
--- a/velox/docs/develop/spilling.rst
+++ b/velox/docs/develop/spilling.rst
@@ -7,7 +7,8 @@ Background
 
 Spilling in Velox allows a query to succeed using a limited amount of memory
 when some operators are accumulating large state. For example, a hash
-aggregation operator stores the intermediate aggregation state in a hash table,
+aggregation operator stores the intermediate aggregation state in a
+`hash table <hash-table.html>`_,
 and it starts to produce the results after processing all the input.  In high
 cardinality workloads (large number of groups) the size of the hash table
 exceeds the query’s memory limit.
@@ -167,7 +168,7 @@ partition to create a sorted reader to restore the spilled partition state.
     std::unique_ptr<TreeOfLosers<SpillMergeStream>> Spiller::startMerge(
         int32_t partition);
 
-**unsorted spill restore**: Used by order by hash build and hash probe
+**unsorted spill restore**: Used by hash build and hash probe
 operators. The operator first calls Spiller::finishSpill() to mark the
 completion of spilling. The Spiller collects metadata for the spilled
 partitioned and returns these to the operator. The operator processes the
@@ -209,22 +210,6 @@ spillable operators. The latter in turn frees up memory by spilling out (part)
 of its memory state to disk. The integration of spilling with the memory
 management system is under development.
 
-Velox can be configured to trigger spilling if the spillable operator's memory
-usage exceeds a configurable limit:
-
-.. code-block:: c++
-
-  uint64_t QueryConfig::aggregationSpillMemoryThreshold() const;
-
-  uint64_t QueryConfig::orderBySpillMemoryThreshold() const;
-
-  uint64_t QueryConfig::joinSpillMemoryThreshold() const;
-
-This allows us to run queries using limited amount of memory without the memory
-arbitration support. Note that the spilling itself can’t totally prevent out of
-memory as the last memory allocation that exceeds the memory limit, can be made
-from any operator in a query plan not always from the spillable one.
-
 Spill Parameters
 ----------------
 Spill File Size
@@ -368,14 +353,7 @@ other to ensure all operators spill the same set of partitions. If operators
 spill independently, it is possible to end up with all partitions being
 spilled. To build a hash table, we need all rows from one or more partitions.
 Unlike hash aggregation and order by, the hash join spilling is explicitly
-controlled by the hash build operators. A SpillOperatorGroup object coordinates
-the spilling on all the operators. The SpillOperatorGroup object is shared by
-all the hash build operators. It implements a recurring barrier function. When
-spilling gets triggered, the object starts a barrier to stop all the hash build
-operators executions. The last operator reaching the barrier acts as the
-coordinator. It collects spillable stats from the Spillers of all the
-operators, chooses a set of partitions to spill, and runs spilling on all the
-Spillers with the selected partitions.
+controlled by the hash build operators.
 
 .. image:: images/spill-hash-join-probe.png
    :width: 400
diff --git a/velox/docs/develop/testing.rst b/velox/docs/develop/testing.rst
index 1cce1fdae7fe1..ce18009466880 100644
--- a/velox/docs/develop/testing.rst
+++ b/velox/docs/develop/testing.rst
@@ -7,3 +7,7 @@ Testing Tools
 
     testing/fuzzer
     testing/join-fuzzer
+    testing/memory-arbitration-fuzzer
+    testing/row-number-fuzzer
+    testing/writer-fuzzer
+    testing/spark-query-runner.rst
diff --git a/velox/docs/develop/testing/async-data-cache-fuzzer.rst b/velox/docs/develop/testing/async-data-cache-fuzzer.rst
new file mode 100644
index 0000000000000..1259064724d57
--- /dev/null
+++ b/velox/docs/develop/testing/async-data-cache-fuzzer.rst
@@ -0,0 +1,63 @@
+============
+Cache Fuzzer
+============
+
+Cache fuzzer is designed to test the correctness and the reliability of the
+in-memory async data cache and the durable local SSD cache, and their
+interactions such as staging from async data cache to SSD cache, and load the
+cache miss data from SSD cache into async data cache.
+
+During each iteration, the fuzzer performs the following actions steps by steps:
+1. Creating a set of data files on local file system with varying sizes as source data files.
+2. Setting up the async data cache with and without SSD using a specific configuration.
+3. Performing parallel random reads from the source data files created in step1.
+
+How to run
+----------
+
+Use velox_cache_fuzzer_test binary to run cache fuzzer:
+
+::
+
+    velox/exec/tests/velox_cache_fuzzer_test
+
+By default, the fuzzer will go through 10 interations. Use --steps
+or --duration-sec flag to run fuzzer for longer. Use --seed to
+reproduce fuzzer failures.
+
+Here is a full list of supported command line arguments.
+
+* ``–-steps``: How many iterations to run. Each iteration generates and
+  evaluates one tale writer plan. Default is 10.
+
+* ``–-duration_sec``: For how long to run in seconds. If both ``-–steps``
+  and ``-–duration_sec`` are specified, –duration_sec takes precedence.
+
+* ``–-seed``: The seed to generate random expressions and input vectors with.
+
+* ``–-num_threads``: Number of read threads.
+
+* ``–-read_iteration_sec``: For how long each read thread should run (in seconds).
+
+* ``–-num_source_files``: Number of data files to be created.
+
+* ``–-min_source_file_bytes``: Minimum source file size in bytes.
+
+* ``–-max_source_file_bytes``: Maximum source file size in bytes.
+
+* ``–-memory_cache_bytes``: Memory cache size in bytes.
+
+* ``–-ssd_cache_bytes``: Ssd cache size in bytes.
+
+* ``–-num_ssd_cache_shards``: Number of SSD cache shards.
+
+* ``–-ssd_checkpoint_interval_bytes``: Checkpoint after every
+  ``--ssd_checkpoint_interval_bytes``/``--num_ssd_cache_shards`` written into
+  each file. 0 means no checkpointing.
+
+* ``–-enable_checksum``: Enable checksum write to SSD.
+
+* ``–-enable_checksum_read_verification``: Enable checksum read verification
+  from SSD.
+
+If running from CLion IDE, add ``--logtostderr=1`` to see the full output.
diff --git a/velox/docs/develop/testing/fuzzer.rst b/velox/docs/develop/testing/fuzzer.rst
index cb883f69e4b1d..97dd226698a84 100644
--- a/velox/docs/develop/testing/fuzzer.rst
+++ b/velox/docs/develop/testing/fuzzer.rst
@@ -1,6 +1,9 @@
-=================================
-Expression and Aggregation Fuzzer
-=================================
+==========================================
+Expression, Aggregation, and Window Fuzzer
+==========================================
+
+Expression Fuzzer
+-----------------
 
 Velox allows users to define UDFs (user-defined functions) and UDAFs
 (user-defined aggregate functions) and provides a fuzzer tools to test the
@@ -18,13 +21,19 @@ expression fuzzer evaluates each expression twice and asserts the results to be
 the same: using regular evaluation path and using simplified evaluation that
 flattens all input vectors before evaluating an expression.
 
+Aggregation Fuzzer
+------------------
+
 The Aggregation Fuzzer tests the HashAggregation operator, the StreamingAggregation
 operator and UDAFs by generating random aggregations and evaluating these on
 random input vectors.
 
 The Aggregation Fuzzer tests global aggregations (no grouping keys), group-by
 aggregations (one or more grouping keys), distinct aggregations(no aggregates),
-aggregations with and without masks.
+aggregations with and without masks, aggregations over sorted and distinct inputs.
+
+The Aggregation Fuzzer includes testing of spilling and abandoning partial
+aggregation.
 
 The results of aggregations using functions supported by DuckDB are compared
 with DuckDB results.
@@ -52,11 +61,72 @@ using OrderBy and StreamingAggregation.
 Fuzzer iterations alternate between generating plans using Values or TableScan
 nodes.
 
+Many functions work well with random input data. However, some functions have
+restrictions on the input values and random data tend to violate these causing
+failures and preventing the fuzzer from exercising the aggregation beyond the
+initial sanity checks.
+
+For example, “min” function has 2 signatures:
+
+.. code-block::
+
+    min(x) → [same as x]
+    Returns the minimum value of all input values.
+
+    min(x, n) → array<[same as x]>
+    Returns n smallest values of all input values of x. n must be a positive integer and not exceed 10,000.
+
+The second signature, let's call it min_n, has 2 arguments. The first argument
+is the value and the second is a constant number of minimum values to return.
+Most of the time, randomly generated value for the second argument doesn’t fall
+into [1, 10’000] range and aggregation fails:
+
+.. code-block::
+
+    VeloxUserError
+    Error Source: USER
+    Error Code: INVALID_ARGUMENT
+    Reason: (3069436511015786487 vs. 10000) second argument of max/min must be less than or equal to 10000
+    Retriable: False
+    Expression: newN <= 10'000
+    Function: checkAndSetN
+    File: /Users/mbasmanova/cpp/velox-1/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
+    Line: 574
+
+Similarly, approx_distinct function has a signature that allows to specify max
+standard error in the range of [0.0040625, 0.26000]. Random values for 'e' have
+near zero chance to fall into this range.
+
+To enable effective testing of these functions, Aggregation Fuzzer allows
+registering custom input generators for individual functions.
+
 When testing aggregate functions whose results depend on the order of inputs
 (e.g. map_agg, map_union, arbitrary, etc.), the Fuzzer verifies that all plans
 succeed or fail with compatible user exceptions. When plans succeed, the Fuzzer
 verifies that number of result rows is the same across all plans.
 
+Additionally, Fuzzer tests order-sensitive functions using aggregations over
+sorted inputs. When inputs are sorted, the results are deterministic and therefore
+can be verified.
+
+Fuzzer also supports specifying custom result verifiers. For example, array_agg
+results can be verified by first sorting the result arrays. Similarly, map_agg
+results can be partially verified by transforming result maps into sorted arrays
+of map keys. approx_distinct can be verified by comparing the results with
+count(distinct).
+
+A custom verifier may work by comparing results of executing two logically
+equivalent Velox plans or results of executing Velox plan and equivalent query
+in Reference DB. These verifiers using transform the results to make them
+deterministic, then compare. This is used to verify array_agg, set_agg,
+set_union, map_agg, and similar functions.
+
+A custom verifier may also work by analyzing the results of single execution
+of a Velox plan. For example, approx_distinct verifies the results by
+computing count(distinct) on input data and checking whether the results
+of approx_distinct are within expected error bound. Verifier for approx_percentile
+works similarly.
+
 At the end of the run, Fuzzer prints out statistics that show what has been
 tested:
 
@@ -71,6 +141,27 @@ tested:
     Total aggregations verified against DuckDB: 2537 (44.63%)
     Total failed aggregations: 1061 (18.67%)
 
+.. _window-fuzzer:
+
+Window Fuzzer
+-------------
+
+The Window fuzzer tests the Window operator with window and aggregation
+functions by generating random window queries and evaluating them on
+random input vectors. Results of the window queries can be compared to
+Presto as the source of truth.
+
+For each window operation, fuzzer generates multiple logically equivalent
+plans and verifies that results match. These plans include
+
+- Values -> Window
+- TableScan -> PartitionBy -> Window
+- Values -> OrderBy -> Window (streaming)
+- TableScan -> OrderBy -> Window (streaming)
+
+Window fuzzer currently doesn't use any custom result verifiers. Functions
+that require custom result verifiers are left unverified.
+
 How to integrate
 ---------------------------------------
 
@@ -89,23 +180,25 @@ aggregate functions supported by the engine, and call
 ``AggregationFuzzerRunner::run()`` defined in `AggregationFuzzerRunner.h`_. See
 `AggregationFuzzerTest.cpp`_.
 
-.. _AggregationFuzzerRunner.h: https://github.com/facebookincubator/velox/blob/main/velox/exec/tests/AggregationFuzzer.h
+.. _AggregationFuzzerRunner.h: https://github.com/facebookincubator/velox/blob/main/velox/exec/fuzzer/AggregationFuzzer.h
 
-.. _AggregationFuzzerTest.cpp: https://github.com/facebookincubator/velox/blob/main/velox/exec/tests/AggregationFuzzerTest.cpp
+.. _AggregationFuzzerTest.cpp: https://github.com/facebookincubator/velox/blob/main/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
 
 Aggregation Fuzzer allows to indicate functions whose results depend on the
-order of inputs and optionally provide an expression to apply to the result to
-make it stable. For example, the results of array_agg can be stabilized by
-applying array_sort on top: array_sort(array_map(x)) and the results of map_agg
-can be stabilized using array_sort(map_keys(map_agg(k, v))). Order-dependent
-functions are tested to ensure no crashes or failures. The results of
-order-dependent functions with stabilizing expressions are further verified for
-correctness by ensuring that results of logically equivalent plans match.
+order of inputs and optionally provide custom result verifiers. The Fuzzer
+also allows to provide custom input generators for individual functions.
+
+Integration with the Window Fuzzer is similar to Aggregation Fuzzer. See
+`WindowFuzzerRunner.h`_ and `WindowFuzzerTest.cpp`_.
+
+.. _WindowFuzzerRunner.h: https://github.com/facebookincubator/velox/blob/main/velox/exec/fuzzer/WindowFuzzer.h
+
+.. _WindowFuzzerTest.cpp: https://github.com/facebookincubator/velox/blob/main/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
 
 How to run
 ----------------------------
 
-Fuzzers support a number of powerful command line arguments.
+All fuzzers support a number of powerful command line arguments.
 
 * ``–-steps``: How many iterations to run. Each iteration generates and evaluates one expression or aggregation. Default is 10.
 
@@ -119,7 +212,11 @@ Fuzzers support a number of powerful command line arguments.
 
 * ``–-batch_size``: The size of input vectors to generate. Default is 100.
 
-There are also arguments that toggle certain fuzzer features:
+* ``--null_ratio``: Chance of adding a null constant to the plan, or null value in a vector (expressed as double from 0 to 1). Default is 0.1.
+
+* ``--max_num_varargs``: The maximum number of variadic arguments fuzzer will generate for functions that accept variadic arguments. Fuzzer will generate up to max_num_varargs arguments for the variadic list in addition to the required arguments by the function. Default is 10.
+
+Below are arguments that toggle certain fuzzer features in Expression Fuzzer:
 
 * ``--retry_with_try``: Retry failed expressions by wrapping it using a try() statement. Default is false.
 
@@ -131,6 +228,8 @@ There are also arguments that toggle certain fuzzer features:
 
 * ``--velox_fuzzer_enable_complex_types``: Enable testing of function signatures with complex argument or return types. Default is false.
 
+* ``--velox_fuzzer_enable_decimal_type``: Enable testing of function signatures with decimal argument or return type. Default is false.
+
 * ``--lazy_vector_generation_ratio``: Specifies the probability with which columns in the input row vector will be selected to be wrapped in lazy encoding (expressed as double from 0 to 1). Default is 0.0.
 
 * ``--velox_fuzzer_enable_column_reuse``: Enable generation of expressions where one input column can be used by multiple subexpressions. Default is false.
@@ -141,21 +240,19 @@ There are also arguments that toggle certain fuzzer features:
 
 * ``--max_expression_trees_per_step``: This sets an upper limit on the number of expression trees to generate per step. These trees would be executed in the same ExprSet and can re-use already generated columns and subexpressions (if re-use is enabled). Default is 1.
 
-In addition, Aggregation Fuzzer also supports tuning parameters:
-
-* ``--num_batches``: The number of input vectors of size `--batch_size` to generate. Default is 10.
+* ``--velox_fuzzer_max_level_of_nesting``: Max levels of expression nesting. Default is 10 and minimum is 1.
 
-* ``--max_num_varargs``: The maximum number of variadic arguments fuzzer will generate for functions that accept variadic arguments. Fuzzer will generate up to max_num_varargs arguments for the variadic list in addition to the required arguments by the function. Default is 10.
+In addition, Aggregation Fuzzer supports the tuning parameter:
 
-* ``--null_ratio``: Chance of adding a null constant to the plan, or null value in a vector (expressed as double from 0 to 1). Default is 0.1.
+* ``--num_batches``: The number of input vectors of size `--batch_size` to generate. Default is 10.
 
-* ``--velox_fuzzer_max_level_of_nesting``: Max levels of expression nesting. Default is 10 and minimum is 1.
+Window Fuzzer supports verifying window query results against reference DB:
 
-* ``--num_batches``: The number of input vectors of size `--batch_size` to generate. Default is 10.
+* ``--enable_window_reference_verification``: When true, the results of the window aggregation are compared to reference DB results. Default is false.
 
 If running from CLion IDE, add ``--logtostderr=1`` to see the full output.
 
-An example set of arguments to run the fuzzer with all features enabled is as follows:
+An example set of arguments to run the expression fuzzer with all features enabled is as follows:
 ``--duration_sec 60
 --enable_variadic_signatures
 --lazy_vector_generation_ratio 0.2
@@ -169,6 +266,21 @@ An example set of arguments to run the fuzzer with all features enabled is as fo
 --repro_persist_path=<a_valid_local_path>
 --logtostderr=1``
 
+
+`WindowFuzzerTest.cpp`_ and `AggregationFuzzerTest.cpp`_ allow results to be
+verified against Presto. To setup Presto as a reference DB, please follow these
+`instructions`_. The following flags control the connection to the presto
+cluster; ``--presto_url`` which is the http server url along with its port number
+and ``--req_timeout_ms`` which sets the request timeout in milliseconds. The
+timeout is set to 1000 ms by default but can be increased if this time is
+insufficient for certain queries. Example command:
+
+::
+
+    velox/functions/prestosql/fuzzer:velox_window_fuzzer_test --enable_window_reference_verification --presto_url="http://127.0.0.1:8080" --req_timeout_ms=2000 --duration_sec=60 --logtostderr=1 --minloglevel=0
+
+.. _instructions: https://github.com/facebookincubator/velox/issues/8111
+
 How to reproduce failures
 -------------------------------------
 
@@ -176,7 +288,7 @@ When Fuzzer test fails, a seed number and the evaluated expression are
 printed to the log. An example is given below. Developers can use ``--seed``
 with this seed number to rerun the exact same expression with the same inputs,
 and use a debugger to investigate the issue. For the example below, the command
-to reproduce the error would be ``velox/expression/tests/velox_expression_fuzzer_test --seed 1188545576``.
+to reproduce the error would be ``velox/expression/fuzzer/velox_expression_fuzzer_test --seed 1188545576``.
 
 ::
 
@@ -235,6 +347,8 @@ ExpressionRunner supports the following flags:
 
 * ``--sql_path`` path to expression SQL that was created by the Fuzzer
 
+* ``--registry`` function registry to use for evaluating expression. One of "presto" (default) or "spark".
+
 * ``--complex_constant_path`` optional path to complex constants that aren't accurately expressable in SQL (Array, Map, Structs, ...). This is used with SQL file to reproduce the exact expression, not needed when the expression doesn't contain complex constants.
 
 * ``--lazy_column_list_path`` optional path for the file stored on-disk which contains a vector of column indices that specify which columns of the input row vector should be wrapped in lazy. This is used when the failing test included input columns that were lazy vector.
@@ -255,6 +369,10 @@ ExpressionRunner supports the following flags:
 
 * ``--store_result_path`` optional directory path for storing the results of evaluating SQL expression or query in 'common', 'simplified' or 'query' modes.
 
+* ``--findMinimalSubExpression`` optional Whether to find minimum failing subexpression on result mismatch. Set to false by default.
+
+* ``--useSeperatePoolForInput`` optional If true (default), expression evaluator and input vectors use different memory pools. This helps trigger code-paths that can depend on vectors having different pools. For eg, when copying a flat string vector copies of the strings stored in the string buffers need to be created. If however, the pools were the same between the vectors then the buffers can simply be shared between them instead.
+
 Example command:
 
 ::
diff --git a/velox/docs/develop/testing/join-fuzzer.rst b/velox/docs/develop/testing/join-fuzzer.rst
index be7d61a467bfc..3e16434e986d4 100644
--- a/velox/docs/develop/testing/join-fuzzer.rst
+++ b/velox/docs/develop/testing/join-fuzzer.rst
@@ -15,7 +15,7 @@ combined with randomly generated payload. When generating the join plan node,
 fuzzer shuffles join keys and output columns and randomly drops some columns
 from the output.
 
-The fuzzer runs the query plan and compares the results with DuckDB.
+The fuzzer runs the query plan and compares the results with the reference (DuckDB or Presto) as the expected result.
 
 The fuzzer then generates a set of different but logically equivalent plans,
 runs them and verifies that results are the same. Each plan runs twice: with
@@ -42,7 +42,7 @@ Use velox_join_fuzzer_test binary to run join fuzzer:
 
     velox/exec/tests/velox_join_fuzzer_test
 
-By default, the fuzzer will go through 10 interations. Use --steps
+By default, the fuzzer will go through 10 iterations. Use --steps
 or --duration-sec flag to run fuzzer for longer. Use --seed to
 reproduce fuzzer failures.
 
@@ -65,4 +65,8 @@ Here is a full list of supported command line arguments.
 
 * ``--enable_spill``: Whether to test with spilling or not. Default is true.
 
+* ``--arbitrator_capacity``: Arbitrator capacity in bytes. Default is 6L << 30.
+
+* ``--allocator_capacity``: Allocator capacity in bytes. Default is 8L << 30.
+
 If running from CLion IDE, add ``--logtostderr=1`` to see the full output.
diff --git a/velox/docs/develop/testing/memory-arbitration-fuzzer.rst b/velox/docs/develop/testing/memory-arbitration-fuzzer.rst
new file mode 100644
index 0000000000000..2895138a6faff
--- /dev/null
+++ b/velox/docs/develop/testing/memory-arbitration-fuzzer.rst
@@ -0,0 +1,57 @@
+=========================
+MemoryArbitration Fuzzer
+=========================
+
+The MemoryArbitrationFuzzer is a test tool designed to automatically generate and execute multiple query plans
+in parallel with tight total memory budget. It aims to stress the memory arbitration processing, and validate there is
+no crash or hanging in a concurrent query execution mode. The query either succeeds or failed with expected errors.
+It works as follows:
+
+1. Data Generation: It starts by generating a random set of input data, also known as a vector. This data can
+   have a variety of encodings and data layouts to ensure thorough testing.
+2. Plan Generation: Generate multiple plans with different query shapes. Currently, it supports HashJoin and
+   HashAggregation plans.
+3. Query Execution: Create multiple threads, each thread randomly picks a plan with spill enabled or not, and repeatedly
+   running this process until ${iteration_duration_sec} seconds. The query thread expects query to succeed or fail with
+   query OOM or abort errors, otherwise it throws.
+4. Iteration: This process is repeated multiple times to ensure reliability and robustness.
+
+How to run
+----------
+
+Use velox_memory_arbitration_fuzzer_test binary to run this fuzzer:
+
+::
+
+    velox/exec/tests/velox_memory_arbitration_fuzzer_test --seed 123 --duration_sec 60
+
+By default, the fuzzer will go through 10 iterations. Use --steps
+or --duration-sec flag to run fuzzer for longer. Use --seed to
+reproduce fuzzer failures.
+
+Here is a full list of supported command line arguments.
+
+* ``–-steps``: How many iterations to run. Each iteration generates and
+  evaluates one expression or aggregation. Default is 10.
+
+* ``–-duration_sec``: For how long to run in seconds. If both ``-–steps``
+  and ``-–duration_sec`` are specified, –duration_sec takes precedence.
+
+* ``–-seed``: The seed to generate random expressions and input vectors with.
+
+* ``–-v``: Verbose logging (from `Google Logging Library <https://github.com/google/glog#setting-flags>`_).
+
+* ``–-batch_size``: The size of input vectors to generate. Default is 100.
+
+* ``--num_batches``: The number of input vectors of size `--batch_size` to
+  generate. Default is 5.
+
+* ``--iteration_duration_sec``: For how long it should run (in seconds) per iteration.
+
+* ``--arbitrator_capacity``: Arbitrator capacity in bytes.
+
+* ``--allocator_capacity``: Allocator capacity in bytes.
+
+* ``--num_threads``: Number of threads running queries in parallel per iteration.
+
+If running from CLion IDE, add ``--logtostderr=1`` to see the full output.
diff --git a/velox/docs/develop/testing/row-number-fuzzer.rst b/velox/docs/develop/testing/row-number-fuzzer.rst
new file mode 100644
index 0000000000000..381c4813e9855
--- /dev/null
+++ b/velox/docs/develop/testing/row-number-fuzzer.rst
@@ -0,0 +1,59 @@
+================
+RowNumber Fuzzer
+================
+
+The RowNumberFuzzer is a testing tool that automatically generate equivalent query plans and then executes these plans
+to validate the consistency of the results. It works as follows:
+
+1. Data Generation: It starts by generating a random set of input data, also known as a vector. This data can
+   have a variety of encodings and data layouts to ensure thorough testing.
+2. Plan Generation: Generate two equivalent query plans, one is row-number over ValuesNode as the base plan.
+   and the other is over TableScanNode as the alter plan.
+3. Query Execution: Executes those equivalent query plans using the generated data and asserts that the results are
+   consistent across different plans.
+  i. Execute the base plan, compare the result with the reference (DuckDB or Presto) and use it as the expected result.
+  #. Execute the alter plan multiple times with and without spill, and compare each result with the
+     expected result.
+4. Iteration: This process is repeated multiple times to ensure reliability and robustness.
+
+How to run
+----------
+
+Use velox_row_number_fuzzer_test binary to run rowNumber fuzzer:
+
+::
+
+    velox/exec/tests/velox_row_number_fuzzer_test --seed 123 --duration_sec 60
+
+By default, the fuzzer will go through 10 iterations. Use --steps
+or --duration-sec flag to run fuzzer for longer. Use --seed to
+reproduce fuzzer failures.
+
+Here is a full list of supported command line arguments.
+
+* ``–-steps``: How many iterations to run. Each iteration generates and
+  evaluates one expression or aggregation. Default is 10.
+
+* ``–-duration_sec``: For how long to run in seconds. If both ``-–steps``
+  and ``-–duration_sec`` are specified, –duration_sec takes precedence.
+
+* ``–-seed``: The seed to generate random expressions and input vectors with.
+
+* ``–-v=1``: Verbose logging (from `Google Logging Library <https://github.com/google/glog#setting-flags>`_).
+
+* ``–-batch_size``: The size of input vectors to generate. Default is 100.
+
+* ``--num_batches``: The number of input vectors of size `--batch_size` to
+  generate. Default is 5.
+
+* ``--enable_spill``: Whether to test with spilling or not. Default is true.
+
+* ``--presto_url`` The PrestoQueryRunner url along with its port number.
+
+* ``--req_timeout_ms`` Timeout in milliseconds of an HTTP request to the PrestoQueryRunner.
+
+* ``--arbitrator_capacity``: Arbitrator capacity in bytes. Default is 6L << 30.
+
+* ``--allocator_capacity``: Allocator capacity in bytes. Default is 8L << 30.
+
+If running from CLion IDE, add ``--logtostderr=1`` to see the full output.
diff --git a/velox/docs/develop/testing/spark-query-runner.rst b/velox/docs/develop/testing/spark-query-runner.rst
new file mode 100644
index 0000000000000..b72880fede115
--- /dev/null
+++ b/velox/docs/develop/testing/spark-query-runner.rst
@@ -0,0 +1,75 @@
+==================
+Spark Query Runner
+==================
+
+Introduction
+------------
+
+The Spark Query Runner is a tool designed to facilitate the testing of Velox.
+It helps ensure the correctness of Velox's computing against Spark and
+provides a method for identifying potential issues in Velox's implementation.
+Spark Query Runner is designed to run against Spark-3.5.1.
+
+How It Works
+------------
+
+The Spark Query Runner operates by executing given SQL queries on Spark and
+returning results as Velox data format, which allows the comparison of results
+between Velox and Spark.
+
+Since Spark 3.4, Spark Connect has introduced a decoupled client-server architecture
+for Spark that allows remote connectivity to Spark clusters. From the client
+perspective, Spark Connect mostly behaves as any other gRPC client, which is polyglot
+and cross-platforms. During execution, the Spark Connect endpoint embedded on the
+Spark Server receives and parses queries into Spark’s logical plan operators.
+From there, the standard Spark execution process kicks in, ensuring that Spark
+Connect leverages all of Spark’s optimizations and enhancements. Results are
+streamed back to the client through gRPC as Arrow-encoded row batches.
+
+In the Spark Query Runner, we use Spark Connect to submit queries to Spark and fetch
+the results back to Velox. The steps for this process are as follows:
+
+1. Provide the Spark SQL query to be executed. The query could be generated from Velox
+   plan node or manually written.
+2. Create a protobuf message `ExecutePlanRequest` from the SQL query. The protocols
+   used by Spark Connect are defined in `Apache Spark <https://github.com/apache/spark/tree/v3.5.1/connector/connect/common/src/main/protobuf/spark/connect>`_.
+3. Submit the message to SparkConnectService through gRPC API `ExecutePlan`.
+4. Fetch Spark's results from execution response. Results are in Arrow IPC stream format,
+   and can be read as Arrow RecordBatch by `arrow::ipc::RecordBatchReader`.
+5. Convert Arrow RecordBatch as Velox vector for the comparison with Velox's results.
+
+Usage
+-----
+
+To use the Spark Query Runner, you will need to deploy an executable Spark and start the
+Spark Connect server with below command.
+
+.. code-block::
+
+    "$SPARK_HOME"/sbin/start-connect-server.sh --jars "$JAR_PATH"/spark-connect_2.12-3.5.1.jar
+
+
+The jar of Spark Connect could be downloaded from `maven repository <https://repo1.maven.org/maven2/org/apache/spark/spark-connect_2.12/3.5.1/>`_.
+If Spark Connect server is started successfully, you can see log as below. The server will
+be started at `localhost:15002`.
+
+.. code-block::
+
+    INFO SparkConnectServer: Spark Connect server started at: 0:0:0:0:0:0:0:0%0:15002
+
+Another option is to use Spark Query Runner in the docker image `ghcr.io/facebookincubator/velox-dev:spark-server`
+provided by Velox. It includes an executable Spark and the start script. You can download
+the image and run below command to start Spark connect server in it.
+
+.. code-block::
+
+    bash /opt/start-spark.sh
+
+You can then provide the Spark Query Runner with the SQL query and the data to run the
+query on. The tool will execute the query on Spark and return results as Velox data format.
+
+Currently to use Spark as reference DB is only supported in aggregate fuzzer test, in which
+the results from Velox and Spark are compared to check for any differences. If the results
+match, it indicates that Velox is producing the correct output. If the results differ, it
+suggests a potential issue in Velox that needs to be investigated. You can trigger its test
+referring to :doc:`Fuzzer <fuzzer>`.
diff --git a/velox/docs/develop/testing/writer-fuzzer.rst b/velox/docs/develop/testing/writer-fuzzer.rst
new file mode 100644
index 0000000000000..ab78732a1e549
--- /dev/null
+++ b/velox/docs/develop/testing/writer-fuzzer.rst
@@ -0,0 +1,48 @@
+=============
+Writer Fuzzer
+=============
+
+Writer fuzzer tests table write plan with up to 5 regular columns, up to
+3 partition keys, up to 3 bucket columns, up to 3 sorted columns.
+
+At each iteration, fuzzer randomly generates a table write plan with different
+table properties including un-partitioned and partitioned, non-bucketed and bucketed,
+sorted and unsorted.
+
+The fuzzer then generates inputs and runs the query plan and compares the
+results with PrestoDB.
+As of now, we compare:
+1. How many rows were written.
+2. Output directories have the same directory layout and hierarchy.
+3. Same data were written by velox and prestoDB including bucket number.
+4. Data of sorted columns is in the same order if table is sorted.
+
+How to run
+----------
+
+Use velox_writer_fuzzer_test binary to run join fuzzer:
+
+::
+
+    velox/exec/tests/velox_writer_fuzzer_test
+
+By default, the fuzzer will go through 10 interations. Use --steps
+or --duration-sec flag to run fuzzer for longer. Use --seed to
+reproduce fuzzer failures.
+
+Here is a full list of supported command line arguments.
+
+* ``–-steps``: How many iterations to run. Each iteration generates and
+  evaluates one tale writer plan. Default is 10.
+
+* ``–-duration_sec``: For how long to run in seconds. If both ``-–steps``
+  and ``-–duration_sec`` are specified, –duration_sec takes precedence.
+
+* ``–-seed``: The seed to generate random expressions and input vectors with.
+
+* ``–-batch_size``: The size of input vectors to generate. Default is 100.
+
+* ``--num_batches``: The number of input vectors of size `--batch_size` to
+  generate. Default is 5.
+
+If running from CLion IDE, add ``--logtostderr=1`` to see the full output.
diff --git a/velox/docs/develop/timestamp.rst b/velox/docs/develop/timestamp.rst
new file mode 100644
index 0000000000000..b29577dea25e9
--- /dev/null
+++ b/velox/docs/develop/timestamp.rst
@@ -0,0 +1,241 @@
+=================================
+Timestamp and Timezone Management
+=================================
+
+Concepts
+--------
+
+Following ANSI SQL semantics, TIMESTAMP is a data type that represents a
+reading of a wall clock and a calendar, e.g, ``2024-04-09 18:25:00``. Note that
+a TIMESTAMP does not represent an absolute point in time, as the exact same
+wall clock time may be read in different instants in time depending on where
+one is situated on Earth. For example, ``2024-04-09 18:25:00`` in California
+and in China were perceived at different absolute points in time, about 15
+hours apart.  
+
+To represent absolute points in time, SQL defines a TIMESTAMP WITH TIMEZONE
+type, which conceptually represents a pair of a wall time and calendar read
+(say, ``2024-04-09 18:25:00``), and a timezone (``PDT``, or
+``America/Los_Angeles``). With these two values, one can unambiguously
+represent an absolute instant in time. 
+
+Naturally, a TIMESTAMP WITH TIMEZONE can be cast into a TIMESTAMP by just
+ignoring the timezone and keeping the timestamp wall time, and a TIMESTAMP can
+be cast into a TIMESTAMP WITH TIMEZONE by associating a timezone to it. The
+timezone can either be explicitly specified by the users, or implicitly taken
+from the user system or session information. 
+
+Physical Representation
+-----------------------
+
+Representing timestamps in memory as a string or a set of values for year,
+month, day, hour, and so on, is inefficient. Therefore, timestamps are usually
+stored in a columnar layout as a 64 bit integer representing the number of
+seconds elapsed since ``1970-01-01 00:00:00``. Negative values represent time
+prior to that. 
+
+However, note that the physical representation of the timestamp is orthogonal
+to its logical meaning. For example, the timestamp represented by the ``0``
+integer was perceived at different absolute points in time depending on the
+observer’s timezone, and does not necessarily imply that it was observed in the
+UTC timezone. When a timestamp represents the number of seconds in UTC
+specifically (at that exact absolute instant in time), it may be called a *unix
+epoch* or *unix time*.
+
+Velox Classes and APIs
+----------------------
+
+Velox provides a few classes and APIs to allow developers to store, process,
+and convert timestamps across timezones:
+
+**Timestamp:** In Velox, timestamps are represented by the `Timestamp
+<https://github.com/facebookincubator/velox/blob/main/velox/type/Timestamp.h>`_
+class. The Timestamp class stores two 64 bit integers, one containing the
+number of seconds from ``1970-01-01 00:00:00``, and one containing the
+nanoseconds offset in that particular second, in order to provide nanosecond
+precision. A few more observations:
+
+* While “seconds” can be negative to represent time before ``1970-01-01
+  00:00:00``, “nanoseconds” are always positive.
+
+* Although Velox supports nanoseconds precision, engines like Presto and Spark
+  may only need milliseconds or microsecond precision.
+
+* The Timestamp class only offers a physical representation of timestamps, but
+  does not carry logical information about its timezone. In other words, it
+  cannot, by itself, represent an absolute point in time.
+
+**Timezone IDs:** To physically represent timezones, Velox provides the
+`TimezoneMap.h <https://github.com/facebookincubator/velox/blob/main/velox/type/tz/TimeZoneMap.h>`_
+API. This API provides a 1:1 mapping from each available timezone to a
+monotonically increasing integer (a timezone ID), such that this integer can be
+used to efficiently represent timezones, preventing the use of inefficient
+timezone string names like ``America/Los_Angeles``. Considering there are about
+2k valid timezone definitions, 12 bits are enough to represent timezone IDs. 
+
+Timezone IDs in Velox are based on the id map used by Presto and are 
+`available here <https://github.com/prestodb/presto/blob/master/presto-common/src/main/resources/com/facebook/presto/common/type/zone-index.properties>`_. 
+They are automatically generated using `this script <https://github.com/facebookincubator/velox/blob/main/velox/type/tz/gen_timezone_database.py>`_. 
+While timezone IDs are an implementation detail and ideally should not leak
+outside of Velox execution, they are exposed if data containing
+TimestampWithTimezones are serialized, for example.
+
+**TimestampWithTimezone:** To represent an absolute point in time, Velox provides
+`TimestampWithTimezone <https://github.com/facebookincubator/velox/blob/main/velox/functions/prestosql/types/TimestampWithTimeZoneType.h>`_.
+This abstraction implements the TIMESTAMP WITH TIMEZONE SQL semantic discussed
+above, and is based on Presto’s implementation - therefore only supporting
+millisecond-precision.
+
+TimestampWithTimezone physically packs two integers in a single 64 word, using
+12 bits for timezone ID, and 52 bits for a millisecond-precision timestamp.
+
+Note that to accelerate timestamp conversion functions, the timestamps stored
+in a TimestampWithTimezone are **always relative to UTC** - they are unix epochs.
+This means that converting a TimestampWithTimezone across timezones is
+efficiently done by just overwriting the 12 bits, and that comparisons can be
+done by just comparing the 52 bits relative to timestamp (ignoring the timezone
+ID).
+
+However, unpacking/converting a TimestampWithTimezone into an absolute time
+definition requires a
+`timezone conversion <https://github.com/facebookincubator/velox/blob/main/velox/functions/prestosql/DateTimeFunctions.h#L74-L84>`_. 
+
+Conversions Across Timezones
+----------------------------
+
+A common operation required when processing timestamps and timezone is finding
+the wall clock and calendar read in a specific timezone given an absolute point
+in time described by a wall clock and calendar read in a different timezone.
+For example, at the exact point in time when UTC hits ``1970-01-01 00:00:00``,
+what was the wall clock read in China?
+
+Timezone conversions are tricky since they are non-linear and depend on
+daylight savings time schedules and other local regulations, and these change
+over time. To enable such conversions, `IANA <https://www.iana.org/time-zones>`_
+periodically publishes a global source of authority database for timezone
+conversions, which is periodically pushed to systems using packages like tzdata
+for Linux. 
+
+In Velox, Timezone conversions are done using std::chrono. Starting in C++20,
+std::chrono `supports conversion of timestamp across timezones <https://en.cppreference.com/w/cpp/chrono/time_zone>`_.
+To support older versions of the C++ standard, in Velox we vendor an
+implementation of this API at `velox/external/date/ <https://github.com/facebookincubator/velox/tree/main/velox/external/date>`_.
+This class handles timezone conversions by leveraging APIs provided by the
+operating system, based on the tzdata database installed locally. If systems
+happen to have inconsistent or older versions of the tzdata database, Velox’s
+conversions may produce inconsistent results. 
+
+On Linux, you can check the tzdata installed in your system by:
+
+.. code-block:: bash
+
+  $ rpm -qa | grep tzdata
+  tzdata-2024a-1.fc38.noarch
+
+Timezone conversions are done using special methods in the Timestamp class:
+``Timestamp::toGMT()`` and ``Timestamp::toTimezone()``. They can take either a
+timezone ID or a tz::TimeZone pointer. Providing a tz::TimeZone is
+generally more efficient, but std::chrono does not handle time zone offsets
+such as ``+09:00``.  Timezone offsets are only supported in the API version
+that takes a timezone ID.
+
+Casts
+-----
+
+This section describes examples of timestamp casts following ANSI SQL
+semantics, using `Presto as a reference implementation <https://prestodb.io/docs/current/functions/datetime.html>`_,
+using ``set session legacy_timestamp = false;`` (see the section below for
+details).
+
+Timestamp literals are created based on whether time zone information is found
+on the string on not:
+
+::
+
+  SELECT typeof(TIMESTAMP '1970-01-01 00:00:00'); -- timestamp
+  SELECT typeof(TIMESTAMP '1970-01-01 00:00:00 UTC'); -- timestamp with time zone 
+
+Converting a TimestampWithTimezone into a Timestamp works by dropping the
+timezone information and returning only the timestamp portion:
+
+::
+
+  SELECT cast(TIMESTAMP '1970-01-01 00:00:00 UTC' as timestamp); -- 1970-01-01 00:00:00.000 
+  SELECT cast(TIMESTAMP '1970-01-01 00:00:00 America/New_York' as timestamp); -- 1970-01-01 00:00:00.000 
+
+To convert a Timestamp into a TimestampWithTimezone, one needs to specify a
+timezone. In Presto, the session timezone is used by default:
+
+::
+
+  SELECT current_timezone(); -- America/Los_Angeles
+  SELECT cast(TIMESTAMP '1970-01-01 00:00:00' as timestamp with time zone); -- 1970-01-01 00:00:00.000 America/Los_Angeles 
+
+Conversion across TimestampWithTimezone can be done using the AT TIME ZONE
+construct. 
+
+The semantic of this operation is: at the absolute point in time described by
+the source TimestampWithTimezone (``1970-01-01 00:00:00 UTC``), what would be
+the clock/calendar read at the target timezone (Los Angeles)?
+
+::
+
+  SELECT TIMESTAMP '1970-01-01 00:00:00 UTC' AT TIME ZONE 'America/Los_Angeles'; -- 1969-12-31 16:00:00.000 America/Los_Angeles 
+  SELECT TIMESTAMP '1970-01-01 00:00:00 UTC' AT TIME ZONE 'UTC'; -- 1970-01-01 00:00:00.000 UTC 
+
+Strings can be converted into Timestamp and TimestampWithTimezone:
+
+::
+
+  SELECT cast('1970-01-01 00:00:00' as timestamp); -- 1970-01-01 00:00:00.000 
+  SELECT cast('1970-01-01 00:00:00 America/Los_Angeles' as timestamp with time zone); -- 1970-01-01 00:00:00.000 America/Los_Angeles 
+
+One can also convert a TimestampWithTimezone into a unix epoch/time. The
+semantic of this operation is: at the absolute point in time described by the
+timestamp with timezone taken as a parameter, what was the unix epoch? Remember
+that unix epoch is the number of seconds since ``1970-01-01 00:00:00`` in UTC:
+
+::
+
+  SELECT to_unixtime(TIMESTAMP '1970-01-01 00:00:00 UTC'); -- 0.0 
+  SELECT to_unixtime(TIMESTAMP '1970-01-01 00:00:00 America/Los_Angeles'); -- 28800.0 
+
+The opposite conversion can be achieved using ``from_unixtime()``. The function
+may take an optional second parameter to specify the timezone, having the same
+semantic as AT TIME ZONE described above:
+
+::
+
+  SELECT from_unixtime(0); -- 1970-01-01 00:00:00.000 
+  SELECT from_unixtime(0, 'UTC'); -- 1970-01-01 00:00:00.000 UTC 
+  SELECT from_unixtime(0, 'America/Los_Angeles'); -- 1969-12-31 16:00:00.000 America/Los_Angeles
+
+Presto Cast Legacy Behavior
+---------------------------
+
+For historical reasons, Presto used to interpret a TIMESTAMP as an absolute
+point in time at the user’s time zone, instead of a timezone-less wall clock
+reading as the ANSII SQL defines it. More information
+`can be found here <https://github.com/prestodb/presto/issues/7122>`_. 
+
+Although this has been fixed in newer versions, a ``legacy_timestamp`` session
+flag was added  to preserve backwards compatibility. When this flag is set,
+timestamps have a different semantic:
+
+::
+
+  SET SESSION legacy_timestamp = true;
+  SELECT cast(TIMESTAMP '1970-01-01 00:00:00 UTC' as timestamp); -- 1969-12-31 16:00:00.000 
+  SELECT cast('1970-01-01 00:00:00 UTC' as timestamp); -- 1969-12-31 16:00:00.000 
+
+To support the two timestamp semantics, the
+``core::QueryConfig::kAdjustTimestampToTimezone`` query flag was added to Velox.
+When this flag is set, Velox will convert the timestamp into the user’s session
+time zone to follow the expected semantic, although non-ANSI SQL compliant.
+
+Other Resources
+---------------
+
+* https://github.com/prestodb/presto/issues/7122
+* https://github.com/a0x8o/presto/blob/master/presto-docs/src/main/sphinx/language/timestamp.rst
+* https://github.com/facebookincubator/velox/issues/8037
diff --git a/velox/docs/develop/types.rst b/velox/docs/develop/types.rst
index 5613ba7397854..80c94020f23a7 100644
--- a/velox/docs/develop/types.rst
+++ b/velox/docs/develop/types.rst
@@ -64,6 +64,7 @@ unsigned integer for nanoseconds. Nanoseconds represent the high-precision part
 the timestamp, which is less than 1 second. Valid range of nanoseconds is [0, 10^9).
 Timestamps before the epoch are specified using negative values for the seconds.
 Examples:
+
 * Timestamp(0, 0) represents 1970-01-0 T00:00:00 (epoch).
 * Timestamp(10*24*60*60 + 125, 0) represents 1970-01-11 00:02:05 (10 days 125 seconds after epoch).
 * Timestamp(19524*24*60*60 + 500, 38726411) represents 2023-06-16 08:08:20.038726411
@@ -72,6 +73,33 @@ Examples:
 * Timestamp(-5000*24*60*60 - 1000, 123456) represents 1956-04-24 07:43:20.000123456
   (5000 days 1000 seconds before epoch plus 123456 nanoseconds).
 
+Floating point types (REAL, DOUBLE) have special values negative infinity, positive infinity, and
+not-a-number (NaN).
+
+For NaN the semantics are different than the C++ standard floating point semantics:
+
+* The different types of NaN (+/-, signaling/quiet) are treated as canonical NaN (+, quiet).
+* `NaN = NaN` returns true.
+* NaN is treated as a normal numerical value in join and group-by keys.
+* When sorting, NaN values are considered larger than any other value. When sorting in ascending order, NaN values appear last. When sorting in descending order, NaN values appear first.
+* For a number N: `N > NaN` is false and `NaN > N` is true.
+
+For negative infinity and positive infinity the following C++ standard floating point semantics apply:
+
+Given N is a positive finite number.
+
+* +inf * N = +inf
+* -inf * N = -inf
+* +inf * -N = -inf
+* -inf * -N = +inf
+* +inf * 0 = NaN
+* -inf * 0 = NaN
+* +inf = +inf returns true.
+* -inf = -inf returns true.
+* Positive infinity and negative infinity are treated as normal numerical values in join and group-by keys.
+* Positive infinity sorts lower than NaN and higher than any other value.
+* Negative infinity sorts lower than any other value.
+
 Logical Types
 ~~~~~~~~~~~~~
 Logical types are backed by a physical type and include additional semantics.
@@ -96,8 +124,8 @@ point in a number. For example, the number `123.45` has a precision of `5` and a
 scale of `2`. DECIMAL types are backed by `BIGINT` and `HUGEINT` physical types,
 which store the unscaled value. For example, the unscaled value of decimal
 `123.45` is `12345`. `BIGINT` is used upto 18 precision, and has a range of
-[:math:`-10^{18} + 1, +10^{18} - 1`]. `HUGEINT` is used starting from 19 precision
-upto 38 precision, with a range of [:math:`-10^{38} + 1, +10^{38} - 1`].
+:math:`[-10^{18} + 1, +10^{18} - 1]`. `HUGEINT` is used starting from 19 precision
+upto 38 precision, with a range of :math:`[-10^{38} + 1, +10^{38} - 1]`.
 
 All the three values, precision, scale, unscaled value are required to represent a
 decimal value.
@@ -109,6 +137,14 @@ the existing physical types. For example, Presto Types described below are imple
 by extending the physical types.
 An OPAQUE type must be used when there is no physical type available to back the logical type.
 
+When extending an existing physical type, if different compare and/or hash semantics are
+needed instead of those provided by the underlying native C++ type, this can be achieved by
+doing the following:
+* Pass `true` for the `providesCustomComparison` argument in the custom type's base class's constructor.
+* Override the `compare` and `hash` functions inherited from the `TypeBase` class (you must implement both).
+Note that this is currently only supported for custom types that extend physical types that
+are primitive and fixed width.
+
 Complex Types
 ~~~~~~~~~~~~~
 Velox supports the ARRAY, MAP, and ROW complex types.
@@ -133,10 +169,60 @@ Presto Type               Physical Type
 ========================  =====================
 HYPERLOGLOG               VARBINARY
 JSON                      VARCHAR
-TIMESTAMP WITH TIME ZONE  ROW<BIGINT, SMALLINT>
+TIMESTAMP WITH TIME ZONE  BIGINT
+UUID                      HUGEINT
+IPADDRESS                 HUGEINT
 ========================  =====================
 
 TIMESTAMP WITH TIME ZONE represents a time point in milliseconds precision
-from UNIX epoch with timezone information. Its physical type contains one 64-bit
-signed integer for milliseconds and another 16-bit signed integer for timezone ID.
-Valid range of timezone ID is [1, 1680], its definition can be found in ``TimeZoneDatabase.cpp``.
\ No newline at end of file
+from UNIX epoch with timezone information. Its physical type is BIGINT.
+The high 52 bits of bigint store signed integer for milliseconds in UTC.
+Supported range of milliseconds is [0xFFF8000000000000L, 0x7FFFFFFFFFFFF]
+(or [-69387-04-22T03:45:14.752, 73326-09-11T20:14:45.247]). The low 12 bits
+store timezone ID. Supported range of timezone ID is [1, 1680].
+The definition of timezone IDs can be found in ``TimeZoneDatabase.cpp``.
+
+IPADDRESS represents an IPV6 or IPV4 formatted IPV6 address. Its physical
+type is HUGEINT. The format that the address is stored in is defined as part of `(RFC 4291#section-2.5.5.2) <https://datatracker.ietf.org/doc/html/rfc4291.html#section-2.5.5.2>`_
+As Velox is run on Little Endian systems and the standard is network byte(Big Endian)
+order, we reverse the bytes to allow for masking and other bit operations
+used in IPADDRESS/IPPREFIX related functions. This type can be used to
+create IPPREFIX networks as well as to check IPADDRESS validity within
+IPPREFIX networks.
+
+Spark Types
+~~~~~~~~~~~~
+The `data types <https://spark.apache.org/docs/latest/sql-ref-datatypes.html>`_ in Spark have some semantic differences compared to those in
+Presto. These differences require us to implement the same functions
+separately for each system in Velox, such as min, max and collect_set. The
+key differences are listed below.
+
+* Spark operates on timestamps with "microsecond" precision while Presto with
+  "millisecond" precision.
+  Example::
+
+      SELECT min(ts)
+      FROM (
+          VALUES
+              (cast('2014-03-08 09:00:00.123456789' as timestamp)),
+              (cast('2014-03-08 09:00:00.012345678' as timestamp))
+      ) AS t(ts);
+      -- 2014-03-08 09:00:00.012345
+
+* In function comparisons, nested null values are handled as values.
+  Example::
+
+      SELECT equalto(ARRAY[1, null], ARRAY[1, null]); -- true
+
+      SELECT min(a)
+      FROM (
+          VALUES
+              (ARRAY[1, 2]),
+              (ARRAY[1, null])
+      ) AS t(a);
+      -- ARRAY[1, null]
+
+* MAP type is not comparable and not orderable in Spark. In Presto, MAP type is
+  also not orderable, but it is comparable if both key and value types are
+  comparable. The implication is that MAP type cannot be used as a join, group
+  by or order by key in Spark.
diff --git a/velox/docs/develop/vectors.rst b/velox/docs/develop/vectors.rst
index b2b1f16d4edda..1a3cb0b0b6a41 100644
--- a/velox/docs/develop/vectors.rst
+++ b/velox/docs/develop/vectors.rst
@@ -175,10 +175,10 @@ std::shared_ptr using the FlatVectorPtr alias.
     template <typename T>
     using FlatVectorPtr = std::shared_ptr<FlatVector<T>>;
 
-The following diagram shows a flat vector of type INTEGER with 11 values. This
+The following diagram shows a flat vector of type INTEGER with 12 values. This
 vector is represented as FlatVector<int32_t>. The `values_` buffer has space for
-at least 11 consecutive entries of 4 bytes each. Nulls buffer has space for at
-least 11 consecutive entries of 1 bit each.  Values in positions 2,7, 11 are
+at least 12 consecutive entries of 4 bytes each. Nulls buffer has space for at
+least 12 consecutive entries of 1 bit each.  Values in positions 2,7, 11 are
 null, e.g. bits 2, 7, 11 in `nulls_` buffer are 0. The rest of the bits in the
 `nulls_` buffer are 1. Entries 2, 7, 11 in `values_` buffer contain garbage.
 
@@ -215,9 +215,9 @@ Strings in the string buffers appear not necessarily in order and there can be
 gaps between individual strings. A single vector may use one or more string
 buffers.
 
-The following diagram shows a vector of type VARCHAR with 7 values. This vector
+The following diagram shows a vector of type VARCHAR with 8 values. This vector
 is represented as FlatVector<StringView>. `values_` buffer has space for at least
-7 entries 16 bytes each. `stringBuffers_` array has one entry containing a
+8 entries 16 bytes each. `stringBuffers_` array has one entry containing a
 concatenation of non-inlined strings. Each entry in `values_` buffer uses 4 bytes
 to store the size of the string.
 
@@ -277,12 +277,13 @@ characters.
     bool isNull_ = false;
     BufferPtr stringBuffer_;
 
-BaseVector::wrapInConstant() static method can be used to create a constant
+BaseVector::createConstant() static method can be used to create a constant
 vector from a scalar value.
 
 .. code-block:: c++
 
     static std::shared_ptr<BaseVector> createConstant(
+        const TypePtr& type,
         variant value,
         vector_size_t size,
         velox::memory::MemoryPool* pool);
@@ -322,9 +323,9 @@ Multiple dictionary vectors can refer to the same base vector. We are saying
 that the dictionary vector wraps the base vector.
 
 Here is a dictionary of type INTEGER that represents a result of a filter: n % 2
-= 0. The base vector contains 11 entries. Only 5 of these entries passed the
-filter, hence, the size of the dictionary vector is 5. The indices buffer
-contains 5 entries referring to positions in the original vector that passed
+= 0. The base vector contains 12 entries. Only 6 of these entries passed the
+filter, hence, the size of the dictionary vector is 6. The indices buffer
+contains 6 entries referring to positions in the original vector that passed
 the filter.
 
 .. image:: images/dictionary-subset2.png
@@ -385,8 +386,9 @@ ArrayVector
 ~~~~~~~~~~~
 
 ArrayVector stores values of type ARRAY. In addition to nulls buffer, it
-contains offsets and sizes buffers and an elements vector. Offsets and sizes
-are 32-bit integers.
+contains offsets and sizes buffers and an elements vector. Offsets and sizes are
+32-bit integers. The non-null non-empty ranges formed by offsets and sizes in a
+vector is not allowed to overlap with each other.
 
 .. code-block:: c++
 
@@ -442,8 +444,9 @@ MapVector
 ~~~~~~~~~
 
 MapVector stores values of type MAP. In addition to nulls buffer, it contains
-offsets and sizes buffers, keys and values vectors. Offsets and sizes are
-32-bit integers.
+offsets and sizes buffers, keys and values vectors. Offsets and sizes are 32-bit
+integers. The non-null non-empty ranges formed by offsets and sizes in a vector
+is not allowed to overlap with each other.
 
 .. code-block:: c++
 
diff --git a/velox/docs/develop/view-and-writer-types.rst b/velox/docs/develop/view-and-writer-types.rst
new file mode 100644
index 0000000000000..5c8bf89ee1169
--- /dev/null
+++ b/velox/docs/develop/view-and-writer-types.rst
@@ -0,0 +1,335 @@
+=====================
+View and Writer Types
+=====================
+
+View types and writer types are used as the input and output parameter types
+respectively for complex and string types in the simple function interface of
+both scalar and aggregate functions.
+
+Inputs (View Types)
+-------------------
+
+Input complex types are represented in the simple function interface using light-weight lazy
+access abstractions that enable efficient direct access to the underlying data in Velox
+vectors.
+As mentioned earlier, the helper aliases arg_type and null_free_arg_type can be used in function's signatures to
+map Velox types to the corresponding input types. The table below shows the actual types that are
+used to represent inputs of different complex types.
+
+==============================    =========================   ==============================
+ C++ Argument Type                 C++ Actual Argument Type   Corresponding `std` type
+==============================    =========================   ==============================
+arg_type<Array<E>>                NullableArrayView<E>>       std::vector<std::optional<V>>
+arg_type<Map<K,V>>                NullableMapView<K, V>       std::map<K, std::optional<V>>
+arg_type<Row<T...>>               NullableRowView<T...>       std::tuple<std::optional<T>...
+null_free_arg_type<Array<E>>      NullFreeArrayView<E>        std::vector<V>
+null_free_arg_type<Map<K,V>>      NullFreeMapView<K, V>       std::map<K, V>
+null_free_arg_type<Row<T...>>>    NullFreeRowView<T...>       std::tuple<T...>
+==============================    =========================   ==============================
+
+The view types are designed to have interfaces similar to those of std::containers, in fact in most cases
+they can be used as a drop in replacement. The table above shows the mapping between the Velox type and
+the corresponding std type. For example: a *Map<Row<int, int>, Array<float>>* corresponds to const
+*std::map<std:::tuple<int, int>, std::vector<float>>*.
+
+All views types are cheap to copy objects, for example the size of ArrayView is 16 bytes at max.
+
+**OptionalAccessor<E>**:
+
+OptionalAccessor is an *std::optional* like object that provides lazy access to the nullity and
+value of the underlying Velox vector at a specific index. Currently, it is used to represent elements of nullable input arrays
+and values of nullable input maps. Note that keys in the map are assumed to be always not nullable in Velox.
+
+The object supports the following methods:
+
+- arg_type<E> value()      : unchecked access to the underlying value.
+
+- arg_type<E> operator \*() : unchecked access to the underlying value.
+
+- bool has_value()         : return true if the value is not null.
+
+- bool operator()          : return true if the value is not null.
+
+The nullity and the value accesses are decoupled, and hence if someone knows inputs are null-free,
+accessing the value does not have the overhead of checking the nullity. So is checking the nullity.
+Note that, unlike std::container, function calls to value() and operator* are r-values (temporaries) and not l-values,
+they can bind to const references and l-values but not references.
+
+OptionalAccessor<E> is assignable to and comparable with std::optional<arg_type<E>> for primitive types.
+The following expressions are valid, where array[0] is an optional accessor.
+
+.. code-block:: c++
+
+    std::optional<int> = array[0];
+    if(array[0] == std::nullopt) ...
+    if(std::nullopt == array[0]) ...
+    if(array[0]== std::optional<int>{1}) ...
+
+**NullableArrayView<T> and NullFreeArrayView<T>**
+
+NullableArrayView and NullFreeArrayView have interfaces similar to that of *std::vector<std::optional<V>>* and *std::vector<V>*,
+the code below shows the function arraySum, a range loop is used to iterate over the values.
+
+.. code-block:: c++
+
+  template <typename T>
+  struct ArraySum {
+    VELOX_DEFINE_FUNCTION_TYPES(T);
+
+    bool call(const int64_t& output, const arg_type<Array<int64_t>>& array) {
+      output = 0;
+      for(const auto& element : array) {
+        if (element.has_value()) {
+          output += element.value();
+        }
+      }
+      return true;
+    }
+  };
+
+
+ArrayView supports the following:
+
+- size_t **size** () : return the number of elements in the array.
+
+- **operator[]** (size_t index) : access element at index. It returns either null_free_arg_type<T> or OptionalAccessor<T>.
+
+- ArrayView<T>::Iterator **begin** () : iterator to the first element.
+
+- ArrayView<T>::Iterator **end** () : iterator indicating end of iteration.
+
+- bool **mayHaveNulls** () : constant time check on the underlying vector nullity. When it returns false, there are definitely no nulls, a true does not guarantee null existence.
+
+- ArrayView<T>::SkipNullsContainer **skipNulls** () : return an iterable container that provides direct access to non-null values in the underlying array. For example, the function above can be written as:
+
+.. code-block:: c++
+
+  template <typename T>
+  struct ArraySum {
+    VELOX_DEFINE_FUNCTION_TYPES(T);
+
+    bool call(const int64_t& output, const arg_type<Array<int64_t>>& array) {
+      output = 0;
+      for (const auto& value : array.skipNulls()) {
+        output += value;
+      }
+      return true;
+    }
+  };
+
+The skipNulls iterator will check the nullity at each index and skip nulls, a more performant implementation
+would skip reading the nullity when mayHaveNulls() is false.
+
+.. code-block:: c++
+
+  template <typename T>
+  struct ArraySum {
+      VELOX_DEFINE_FUNCTION_TYPES(T);
+
+      bool call(const int64_t& output, const arg_type<Array<int64_t>>& array) {
+        output = 0;
+        if (array.mayHaveNulls()) {
+          for(const auto& value : array.skipNulls()) {
+            output += value;
+          }
+          return true;
+        }
+
+        // No nulls, skip reading nullity.
+        for (const auto& element : array) {
+          output += element.value();
+        }
+        return true;
+      }
+  };
+
+Note: calls to operator[], iterator de-referencing, and iterator pointer de-referencing are r-values (temporaries),
+versus l-values in STD containers. Hence those can be bound to const references or l-values but not normal references.
+
+**NullableMapView<K, V> and  NullFreeMapView<K, V>**
+
+NullableMapView and NullFreeMapView has an interfaces similar to std::map<K, std::optional<V>> and std::map<K, V>,
+the code below shows an example function mapSum, sums up the keys and values.
+
+.. code-block:: c++
+
+  template <typename T>
+  struct MapSum{
+    bool call(const int64_t& output, const arg_type<Map<int64_t, int64_t>>& map) {
+      output = 0;
+      for (const auto& [key, value] : map) {
+        output += key;
+        if (value.has_value()) {
+          value += value.value();
+        }
+      }
+      return true;
+    }
+  };
+
+MapView supports the following:
+
+- MapView<K,V>::Element **begin** () : iterator to the first map element.
+
+- MapView<K,V>::Element **end** ()   : iterator that indicates end of iteration.
+
+- size_t **size** ()                 : number of elements in the map.
+
+- MapView<K,V>::Iterator **find** (const key_t& key): performs a linear search for the key, and returns iterator to the element if found otherwise returns end(). Only supported for primitive key types.
+
+- MapView<K,V>::Iterator **operator[]** (const key_t& key): same as find, throws an exception if element not found.
+
+- MapView<K,V>::Element
+
+MapView<K, V>::Element is the type returned by dereferencing MapView<K, V>::Iterator. It has two members:
+
+- first : arg_type<K> | null_free_arg_type<K>
+
+- second: OptionalAccessor<V> | null_free_arg_type<V>
+
+- MapView<K, V>::Element participates in struct binding: auto [v, k] = \*map.begin();
+
+Note: iterator de-referencing and iterator pointer de-referencing result in temporaries. Hence those can be bound to
+const references or value variables but not normal references.
+
+Generic<T1> input types are implemented using GenericView that supports the following:
+
+- uint64_t **hash** () const : returns a hash of the value; used to define std::hash<GenericView>(); allows GenericView's to be stored in folly::F14 sets and maps as well as STL's sets and maps.
+- bool **isNull** () const   : returns true if the value is NULL
+- bool **operator==** (const GenericView& other) const : equality comparison with another GenericView
+- std::optional<int64_t> **compare** (const GenericView& other, const CompareFlags flags) const : comparison with another GenericView
+- TypeKind **kind** () const : returns TypeKind of the value
+- const TypePtr& **type** () const : returns Velox type of the value
+- std::string **toString** () const : returns string representaion of the value for logging and debugging
+- template <typename ToType> typename VectorReader<ToType>::exec_in_t **castTo** () const : cast to concrete view type
+- template <typename ToType> std::optional<typename VectorReader<ToType>::exec_in_t> **tryCastTo** () const : best-effort attempt to cast to a concrete view type
+
+**Temporaries lifetime C++**
+
+While c++ allows temporaries(r-values) to bound to const references by extending their lifetime, one must be careful and
+know that only the assigned temporary lifetime is extended but not all temporaries in the RHS expression chain.
+In other words, the lifetime of any temporary within an expression is not extended.
+
+For example, for the expression const auto& x = map.begin()->first.
+c++ does not extend the lifetime of the result of map.begin() since it's not what is being
+assigned. And in such a case, the assignment has undefined behavior.
+
+.. code-block:: c++
+
+     // Safe assignments. single rhs temporary.
+     const auto& a = array[0];
+     const auto& b = *a;
+     const auto& c = map.begin();
+     const auto& d = c->first;
+
+     // Unsafe assignments. (undefined behaviours)
+     const auto& a = map.begin()->first;
+     const auto& b = **it;
+
+     // Safe and cheap to assign to value.
+     const auto a = map.begin()->first;
+     const auto b = **it;
+
+Note that in the range-loop, the range expression is assigned to a universal reference. Thus, the above concern applies to it.
+
+.. code-block:: c++
+
+     // Unsafe range loop.
+     for(const auto& e : **it){..}
+
+     // Safe range loop.
+     auto itt = *it;
+     for(const auto& e : *itt){..}
+
+.. _outputs-write:
+
+Outputs (Writer Types)
+----------------------
+
+Outputs of complex types are represented using special writers that are designed in a way that
+minimizes data copying by writing directly to Velox vectors.
+
+**ArrayWriter<V>**
+
+- out_type<V>& **add_item** () : add non-null item and return the writer of the added value.
+- **add_null** (): add null item.
+- **reserve** (vector_size_t size): make sure space for `size` items is allocated in the underlying vector.
+- vector_size_t **size** (): return the length of the array.
+- **resize** (vector_size_t size): change the size of the array reserving space for the new elements if needed.
+
+- void **add_items** (const T& data): append data from any container with std::vector-like interface.
+- void **copy_from** (const T& data): assign data to match that of any container with std::vector-like interface.
+
+- void **add_items** (const NullFreeArrayView<V>& data): append data from array view (faster than item by item).
+- void **copy_from** (const NullFreeArrayView<V>& data): assign data from array view (faster than item by item).
+
+- void **add_items** (const NullableArrayView<V>& data): append data from array view (faster than item by item).
+- void **copy_from** (const NullableArrayView<V>& data): assign data from array view (faster than item by item).
+
+When V is primitive, the following functions are available, making the writer usable as std::vector<V>.
+
+- **push_back** (std::optional<V>): add item or null.
+- PrimitiveWriter<V> **operator[]** (vector_size_t index): return a primitive writer that is assignable to std::optional<V> for the item at index (should be called after a resize).
+- PrimitiveWriter<V> **back** (): return a primitive writer that is assignable to std::optional<V> for the item at index length -1.
+
+
+**MapWriter<K, V>**
+
+- **reserve** (vector_size_t size): make sure space for `size` entries is allocated in the underlying vector.
+- std::tuple<out_type<K>&, out_type<V>&> **add_item()** : add non-null item and return the writers of key and value as tuple.
+- out_type<K>& **add_null()** : add null item and return the key writer.
+- vector_size_t **size** (): return the length of the map.
+
+- void **add_items** (const T& data): append data from any container with std::vector<tuple<K, V>> like interface.
+- void **copy_from** (const NullFreeMapView<V>& data): assign data from map view (faster than item by item).
+- void **copy_from** (const NullableMapView<V>& data): assign data from map view (faster than item by item).
+
+When K and V are primitives, the following functions are available, making the writer usable as std::vector<std::tuple<K, V>>.
+
+- **resize** (vector_size_t size): change the size.
+- **emplace** (K, std::optional<V>): add element to the map.
+- std::tuple<K&, PrimitiveWriter<V>> **operator[]** (vector_size_t index): returns pair of writers for element at index. Key writer is assignable to K. while value writer is assignable to std::optional<V>.
+
+**RowWriter<T...>**
+
+- template<vector_size_t I> **set_null_at** (): set null for row item at index I.
+- template<vector_size_t I> **get_writer_at** (): set not null for row item at index I, and return writer to the row element at index I.
+
+When all types T... are primitives, the following functions are available.
+
+- void **operator=** (const std::tuple<T...>& inputs): assignable to std::tuple<T...>.
+- void **operator=** (const std::tuple<std::optional<T>...>& inputs): assignable to std::tuple<std::optional<T>...>.
+- void **copy_from** (const std::tuple<K...>& inputs): similar as the above.
+
+When a given Ti is primitive, the following is valid.
+
+- PrimitiveWriter<Ti> exec::get<I>(RowWriter<T...>): return a primitive writer for item at index I that is assignable to std::optional.
+
+**PrimitiveWriter<T>**
+
+Assignable to std::optional<T> allows writing null or value to the primitive. Returned by complex writers when writing nullable
+primitives.
+
+**StringWriter<>**
+
+- void **reserve** (size_t newCapacity) : Reserve a space for the output string with size of at least newCapacity.
+- void **resize** (size_t newCapacity) : Set the size of the string.
+- char* **data** (): returns pointer to the first char of the string, can be written to directly (safe to write to index at capacity()-1).
+- vector_size_t **capacity** (): returns the capacity of the string.
+- vector_size_t **size** (): returns the size of the string.
+- **operator+=** (const T& input): append data from char* or any type with data() and size().
+- **append** (const T& input): append data from char* or any type with data() and size().
+- **copy_from** (const T& input): append data from char* or any type with data() and size().
+
+When Zero-copy optimization is enabled (see zero-copy-string-result section above), the following functions can be used.
+
+- void **setEmpty** (): set to empty string.
+- void **setNoCopy** (const StringView& value): set string to an input string without performing deep copy.
+
+**GenericWriter**
+
+- TypeKind **kind** () const : returns TypeKind of the value
+- const TypePtr& **type** () const : returns Velox type of the value
+- void **copy_from** (const GenericView& view) : assign data from another GenericView
+- template <typename ToType> typename VectorWriter<ToType, void>::exec_out_t& **castTo** () : cast to concrete writer type
+- template <typename ToType> typename VectorWriter<ToType, void>::exec_out_t* **tryCastTo** () : best-effort attempt to cast to a concrete writer type
diff --git a/velox/docs/develop/window.rst b/velox/docs/develop/window.rst
new file mode 100644
index 0000000000000..6abd407504054
--- /dev/null
+++ b/velox/docs/develop/window.rst
@@ -0,0 +1,320 @@
+================
+Window functions
+================
+
+Velox supports window function evaluation using Window operator. In this guide
+we will discuss some intricate design problems in this operator.
+
+This doc assumes familiarity with Window functions described in
+:doc:`../functions/presto/window`.
+
+
+Window frames
+-------------
+
+Window functions can optionally include a FRAME clause. The FRAME clause
+can be thought of as a spec for a sliding window of rows which bound
+the window function computation for the given row.
+
+Not all window functions are bound by the FRAME clause.
+
+- Aggregates computed as window functions and value functions :func:`first_value`,
+  :func:`last_value` and :func:`nth_value` honor window frames.
+- Rank functions :func:`row_number`, :func:`rank`, :func:`dense_rank`,
+  :func:`percent_rank`, :func:`ntile`, :func:`cume_dist` and value functions
+  :func:`lead` and :func:`lag` are not affected by window frames.
+
+A frame can be ROWS type or RANGE type, and it runs from frame_start to
+frame_end. A FRAME clause is one of
+
+.. code-block::
+
+   {RANGE|ROWS} frame_start
+   {RANGE|ROWS} BETWEEN frame_start AND frame_end
+
+frame_start and frame_end can be any of:
+
+.. code-block::
+
+   UNBOUNDED PRECEDING
+   expression PRECEDING
+   CURRENT ROW
+   expression FOLLOWING
+   UNBOUNDED FOLLOWING
+
+**ROWS mode**
+
+ROWS mode can be interpreted as indices of the rows in the order in which they
+appear in the window partition. This ordering is determined by the ORDER BY
+clause. In ROWS mode, CURRENT ROW refers to the present row at which the
+function is being evaluated. Each consecutive row has increasing frame number.
+The frame numbers start at 0 and increase by 1 for each row.
+
+**RANGE mode**
+
+In RANGE mode, all peer rows have the same frame number.
+Rows are peers if they have the same values for the ORDER BY field.
+A frame start of CURRENT ROW refers to the first peer row of the current row,
+while a frame end of CURRENT ROW refers to the last peer row of the current row.
+If no ORDER BY is specified, all rows are considered peers of the current row.
+
+**Misc**
+
+UNBOUNDED PRECEDING and UNBOUNDED FOLLOWING always refer to the first and
+last rows of the partition in either mode.
+
+
+Window frame indices
+--------------------
+
+As window functions are evaluated for each row, the Window operator provides
+each function a buffer of frame_start and frame_end indices at each
+WindowFunction::apply call.
+
+**Note**: Its possible during calculations that the frame indices are values
+before or after the partition rows. In this case, the frame indices get bound
+to the first and last rows of the partition.
+
+As an example, for frame *ROWS BETWEEEN 2 PRECEDING AND 2 FOLLOWING*, the
+frame indices will be as follows:
+
+.. code-block::
+
+  row_index    partition_col        order_by_col        frame_start         frame_end
+       0            1                     1                   0                 2
+       1            1                     2                   0                 3
+       2            1                     2                   0                 4
+       3            1                     3                   1                 5
+       4            1                     4                   2                 6
+       5            1                     4                   3                 7
+       6            1                     4                   4                 7
+       7            1                     5                   5                 7
+
+On the other hand, for frame *RANGE BETWEEEN 2 PRECEDING AND 2 FOLLOWING*,
+the frame indices will be as follows
+
+.. code-block::
+
+  row_index    partition_col        order_by_col        frame_start         frame_end
+       0            1                     1                   0                 3
+       1            1                     2                   0                 6
+       2            1                     2                   0                 6
+       3            1                     3                   0                 7
+       4            1                     4                   1                 7
+       5            1                     4                   1                 7
+       6            1                     4                   1                 7
+       7            1                     5                   3                 7
+
+k Range frames
+--------------
+
+K range window frames are a special value based window frame.
+
+An example of a k range frame is *RANGE BETWEEEN 5 PRECEDING AND 2 FOLLOWING*.
+This frame includes all rows whose order_by keys are values between
+*(current_row order_by key - 5)* to *(current_row order_by key + 2)*.
+
+Elaborating with an example table:
+
+.. code-block::
+
+  row_index    partition_col    order_by_col    start_frame   end_frame    frame_start    frame_end
+       0            1                2               -3           4             0             1
+       1            1                3               -2           5             0             2
+       2            1                5                0           7             0             3
+       3            1                5                0           7             0             3
+       4            1                9                4           11            2             5
+       5            1                10               5           12            2             5
+       6            1                15               10          17            5             6
+       7            1                21               16          23            7             7
+There are some more aspects to consider when calculating the frame indices.
+
+One of the subtle nuances is related to *PRECEDING* and *FOLLOWING* usage.
+
+- *PRECEDING* range means search in the rows from current row to partition start.
+- *FOLLOWING* range means search in the rows from current row to partition end.
+
+This implies:
+
+- If an ORDER BY clause is *ASCENDING*,  preceding rows have values < current row
+  and following rows have values > current row.
+  So the frame *RANGE BETWEEN 5 PRECEDING AND 2 FOLLOWING* is for values
+  between [order_by - 5] to [order_by + 2].
+  The previous table is an example of such a frame.
+
+- However, if the ORDER BY clause is *DESCENDING* then preceding rows have
+  values > current row and following rows have values < current row
+
+  So for the same frame *RANGE BETWEEN 5 PRECEDING AND 2 FOLLOWING* with
+  descending the values are between [order_by + 5] to [order_by - 2].
+
+Flipping the previous example for a descending order will result in the following
+table.
+
+.. code-block::
+
+  row_index    partition_col    order_by_col    start_frame    end_frame    frame_start    frame_end
+       0            1                21              26            19            0             0
+       1            1                15              20            13            1             1
+       2            1                10              15             8            1             2
+       3            1                9               14             7            2             3
+       4            1                5               10             3            2             6
+       5            1                5               10             3            2             6
+       6            1                3               8              1            4             7
+       7            1                2               7             -1            4             7
+
+**k** in the range frames can be a constant, column reference or expression (like for date ranges
+the bound can be date + some interval). Velox defers computing the start_value and end_value bounds
+to a prior project node and expects the user to send these computed values in the column reference
+for k range frames. Even if k is a constant value, the user is expected to compute the start_value
+and end_value columns for the WindowNode.
+
+In WindowNode a kRange frame would look as follows :
+
+.. code-block::
+
+    struct Frame {
+      WindowType type;
+      BoundType startType;
+      TypedExprPtr startValue;
+      BoundType endType;
+      TypedExprPtr endValue;
+    };
+    Frame kRange = { kRange, kPreceding, start_value_col, kFollowing, end_value_col};
+
+
+The following validations are performed for k Range frames:
+
+- There is a single ORDER BY column to compare the k Range value.
+
+- start(or end)Value in WindowNode::Frame cannot be constants if the bound type is kPreceding
+  or kFollowing respectively.
+
+- The type of the start(end)Value TypedExprPtr must be the same type as the ORDER BY column.
+
+The Velox Window operator computes the frame indices buffer by searching start(end)Value in the
+ORDER BY column and passes the buffer in the WindowFunction::apply() call.
+
+**Null values in RANGE frames**
+
+The ORDER BY column could have NULL values. NULL values match only other NULLs for Range frames.
+
+NULL values are placed at the beginning or end of the ORDER BY column based on the
+*NULLS FIRST/LAST* mode used. So for a row with a NULL value, the frame_start index is first
+peer row with a NULL and the frame_end index is the last peer row with a NULL value.
+
+Rows with NULL values do not participate in the frames of the other rows.
+
+
+Empty frames
+------------
+Window frames can be valid, partial or empty during window function processing.
+
+Valid frames are the default case when all the rows in the window frame in order
+from frame_start to frame_end are within the partition boundaries. However, it is
+possible that window frames of certain rows are only partially filled or are empty.
+While partial frames don't need any special treatment from the function author,
+empty frames need some consideration.
+
+Empty frames occur when :
+
+* Both frame_start and frame_end fall before the first partition row.
+
+  E.g. in frame *ROWS BETWEEN 5 PRECEDING and 2 PRECEDING* the first 2 rows
+  have both frame bounds before the first partition row.
+
+* Both frame_start and frame_end fall after the partition end row.
+
+  E.g. in frame *ROWS BETWEEN 2 FOLLOWING and 5 FOLLOWING* the last 2 rows
+  have both frame bounds beyond the last partition row.
+
+* frame_start > frame_end row (as frame range is defined from frame_start to
+  frame_end).
+
+  E.g. In frame *ROWS BETWEEN UNBOUNDED PRECEDING AND 2 PRECEDING* the intent
+  is to compute aggregation from the partition start row to 2 rows prior
+  the current one. However, for the first 2 rows the frameStart
+  (frame index 0 for unbounded preceding) is ahead of 2 preceding
+  (indices -2 and -1).
+
+* For frames like *ROWS BETWEEN 2 PRECEDING AND 5 PRECEDING* or
+  *ROWS BETWEEN 5 FOLLOWING AND 2 FOLLOWING*, frame_start > frame_end for
+  all rows. So all frames are empty.
+
+**Partial frames**
+
+Like illustrated in the examples above, rows could have partial window frames.
+
+A partial frame occurs when:
+
+- frame_start < frame_end (so it's not an empty frame)
+- One frame end is within partition bounds and the other end outside of it.
+
+  This means either :
+
+  - frame_start is before the first partition row while frame_end is within
+    the partition. In this case, frame_start is clamped to the first partition
+    row.
+  - frame_start is within the partition while frame_end is beyond the partition.
+    In this case, the frame_end is clamped to the last partition row.
+
+Partial frames usually follow empty frames in a sliding window.
+
+E.g. In frame *ROWS BETWEEN 5 PRECEDING AND 2 PRECEDING*, the first 2 rows have
+frame_start and frame_end before the first partition row, so they are empty.
+But from 3rd - 5th row, the 5 preceding frame_start bound is outside the
+partition, but 2 preceding frame_end is within the partition. So for these
+3 rows frame_start is clamped to the first partition row.
+
+Similarly for frame *ROWS BETWEEN 2 FOLLOWING AND 5 FOLLOWING*, the last 3-5th rows
+have frame_start within the partition, but frame_end beyond. So they are partial
+frames. The last 2 rows have both bounds outside the partition and are empty frames..
+
+Empty, partial and valid window frames can be visualized as below
+
+.. image:: images/empty_frames.png
+    :width: 600
+    :align: center
+
+Frames with constant frame bounds (like 2 preceding) have strict sliding behavior.
+So the empty frames, partial frames and valid frames cluster together and follow
+(or precede) each other.
+
+Adhoc frames that use column values for bounds (like c1 preceding) can have
+empty, partial or valid frames at any points in the partition rows.
+
+**Handling empty frames in window functions**
+
+As mentioned before, only value and aggregate window functions use frames in
+their evaluation. Value functions return null values for empty frames.
+Aggregate functions return the default aggregate value for empty frames.
+Rank functions are not affected by empty frames.
+
+The most naive approach to handle empty frames is to check in the window
+function logic if the frame indices are an empty frame (based on the
+conditions previously described) and return the null output. However,
+this could be repetitive to implement in all functions.
+
+To aid the calculations, the Window operator computes a
+*SelectivityVector* for the rows with valid frames in each
+WindowFunction::apply(..) call. The function logic can
+iterate over the rows with set bits in this SelectivityVector
+for evaluations.
+
+This SelectivityVector is passed in the validFrames argument in
+the WindowFunction::apply() signature
+
+.. code-block::
+
+    virtual void apply(
+       const BufferPtr& peerGroupStarts,
+       const BufferPtr& peerGroupEnds,
+       const BufferPtr& frameStarts,
+       const BufferPtr& frameEnds,
+       const SelectivityVector& validFrames,
+       vector_size_t resultOffset,
+       const VectorPtr& result) = 0;
+
+The Window operator also clamps *partial* window frame indices to
+the first or final partition row before passing them to the function.
+So the Window function doesn't need any special logic for partial frames.
diff --git a/velox/docs/functions.rst b/velox/docs/functions.rst
index f11bf3a627e72..57ea32d5691d2 100644
--- a/velox/docs/functions.rst
+++ b/velox/docs/functions.rst
@@ -6,6 +6,7 @@ Presto Functions
     :maxdepth: 1
 
     functions/presto/math
+    functions/presto/decimal
     functions/presto/bitwise
     functions/presto/comparison
     functions/presto/string
@@ -20,6 +21,8 @@ Presto Functions
     functions/presto/aggregate
     functions/presto/window
     functions/presto/hyperloglog
+    functions/presto/uuid
+    functions/presto/misc
 
 Here is a list of all scalar and aggregate Presto functions available in Velox.
 Function names link to function descriptions. Check out coverage maps
@@ -62,77 +65,88 @@ for :doc:`all <functions/presto/coverage>` and :doc:`most used
     ======================================  ======================================  ======================================  ==  ======================================  ==  ======================================
     Scalar Functions                                                                                                            Aggregate Functions                         Window Functions
     ======================================================================================================================  ==  ======================================  ==  ======================================
-    :func:`abs`                             :func:`eq`                              :func:`power`                               :func:`approx_distinct`                     :func:`cume_dist`
-    :func:`acos`                            :func:`exp`                             :func:`quarter`                             :func:`approx_most_frequent`                :func:`dense_rank`
-    :func:`all_match`                       :func:`filter`                          :func:`radians`                             :func:`approx_percentile`                   :func:`first_value`
-    :func:`any_match`                       :func:`flatten`                         :func:`rand`                                :func:`approx_set`                          :func:`lag`
-    :func:`array_average`                   :func:`floor`                           :func:`random`                              :func:`arbitrary`                           :func:`last_value`
-    :func:`array_constructor`               :func:`format_datetime`                 :func:`reduce`                              :func:`array_agg`                           :func:`lead`
-    :func:`array_distinct`                  :func:`from_base`                       :func:`regexp_extract`                      :func:`avg`                                 :func:`nth_value`
-    :func:`array_duplicates`                :func:`from_base64`                     :func:`regexp_extract_all`                  :func:`bitwise_and_agg`                     :func:`ntile`
-    :func:`array_except`                    :func:`from_base64url`                  :func:`regexp_like`                         :func:`bitwise_or_agg`                      :func:`percent_rank`
-    :func:`array_frequency`                 :func:`from_big_endian_32`              :func:`regexp_replace`                      :func:`bool_and`                            :func:`rank`
-    :func:`array_has_duplicates`            :func:`from_big_endian_64`              :func:`repeat`                              :func:`bool_or`                             :func:`row_number`
-    :func:`array_intersect`                 :func:`from_hex`                        :func:`replace`                             :func:`checksum`
-    :func:`array_join`                      :func:`from_unixtime`                   :func:`reverse`                             :func:`corr`
-    :func:`array_max`                       :func:`from_utf8`                       :func:`round`                               :func:`count`
-    :func:`array_min`                       :func:`greatest`                        :func:`rpad`                                :func:`count_if`
-    :func:`array_normalize`                 :func:`gt`                              :func:`rtrim`                               :func:`covar_pop`
-    :func:`array_position`                  :func:`gte`                             :func:`second`                              :func:`covar_samp`
-    :func:`array_sort`                      :func:`hmac_md5`                        :func:`sequence`                            :func:`entropy`
-    :func:`array_sort_desc`                 :func:`hmac_sha1`                       :func:`sha1`                                :func:`every`
-    :func:`array_sum`                       :func:`hmac_sha256`                     :func:`sha256`                              :func:`histogram`
-    :func:`array_union`                     :func:`hmac_sha512`                     :func:`sha512`                              :func:`kurtosis`
-    :func:`arrays_overlap`                  :func:`hour`                            :func:`shuffle`                             :func:`map_agg`
-    :func:`asin`                            in                                      :func:`sign`                                :func:`map_union`
-    :func:`atan`                            :func:`infinity`                        :func:`sin`                                 :func:`map_union_sum`
-    :func:`atan2`                           :func:`inverse_beta_cdf`                :func:`slice`                               :func:`max`
-    :func:`beta_cdf`                        :func:`is_finite`                       :func:`split`                               :func:`max_by`
-    :func:`between`                         :func:`is_infinite`                     :func:`split_part`                          :func:`max_data_size_for_stats`
-    :func:`binomial_cdf`                    :func:`is_json_scalar`                  :func:`spooky_hash_v2_32`                   :func:`merge`
-    :func:`bit_count`                       :func:`is_nan`                          :func:`spooky_hash_v2_64`                   :func:`min`
-    :func:`bitwise_and`                     :func:`is_null`                         :func:`sqrt`                                :func:`min_by`
-    :func:`bitwise_arithmetic_shift_right`  :func:`json_array_contains`             :func:`strpos`                              :func:`regr_intercept`
-    :func:`bitwise_left_shift`              :func:`json_array_length`               :func:`strrpos`                             :func:`regr_slope`
-    :func:`bitwise_logical_shift_right`     :func:`json_extract`                    :func:`subscript`                           :func:`set_agg`
-    :func:`bitwise_not`                     :func:`json_extract_scalar`             :func:`substr`                              :func:`set_union`
-    :func:`bitwise_or`                      :func:`json_format`                     :func:`tan`                                 :func:`skewness`
-    :func:`bitwise_right_shift`             :func:`json_parse`                      :func:`tanh`                                :func:`stddev`
-    :func:`bitwise_right_shift_arithmetic`  :func:`json_size`                       :func:`timezone_hour`                       :func:`stddev_pop`
-    :func:`bitwise_shift_left`              :func:`least`                           :func:`timezone_minute`                     :func:`stddev_samp`
-    :func:`bitwise_xor`                     :func:`length`                          :func:`to_base`                             :func:`sum`
-    :func:`cardinality`                     :func:`like`                            :func:`to_base64`                           :func:`sum_data_size_for_stats`
-    :func:`cauchy_cdf`                      :func:`ln`                              :func:`to_base64url`                        :func:`var_pop`
-    :func:`cbrt`                            :func:`log10`                           :func:`to_big_endian_32`                    :func:`var_samp`
-    :func:`ceil`                            :func:`log2`                            :func:`to_big_endian_64`                    :func:`variance`
-    :func:`ceiling`                         :func:`lower`                           :func:`to_hex`
-    :func:`chi_squared_cdf`                 :func:`lpad`                            :func:`to_ieee754_64`
-    :func:`chr`                             :func:`lt`                              :func:`to_unixtime`
-    :func:`clamp`                           :func:`lte`                             :func:`to_utf8`
-    :func:`codepoint`                       :func:`ltrim`                           :func:`transform`
-    :func:`combinations`                    :func:`map`                             :func:`transform_keys`
-    :func:`concat`                          :func:`map_concat`                      :func:`transform_values`
-    :func:`contains`                        :func:`map_entries`                     :func:`trim`
-    :func:`cos`                             :func:`map_filter`                      :func:`trim_array`
-    :func:`cosh`                            :func:`map_from_entries`                :func:`truncate`
-    :func:`crc32`                           :func:`map_keys`                        :func:`upper`
-    :func:`current_date`                    :func:`map_values`                      :func:`url_decode`
-    :func:`date`                            :func:`map_zip_with`                    :func:`url_encode`
-    :func:`date_add`                        :func:`md5`                             :func:`url_extract_fragment`
-    :func:`date_diff`                       :func:`millisecond`                     :func:`url_extract_host`
-    :func:`date_format`                     :func:`minus`                           :func:`url_extract_parameter`
-    :func:`date_parse`                      :func:`minute`                          :func:`url_extract_path`
-    :func:`date_trunc`                      :func:`mod`                             :func:`url_extract_port`
-    :func:`day`                             :func:`month`                           :func:`url_extract_protocol`
-    :func:`day_of_month`                    :func:`multiply`                        :func:`url_extract_query`
-    :func:`day_of_week`                     :func:`nan`                             :func:`week`
-    :func:`day_of_year`                     :func:`negate`                          :func:`week_of_year`
-    :func:`degrees`                         :func:`neq`                             :func:`width_bucket`
-    :func:`distinct_from`                   :func:`none_match`                      :func:`xxhash64`
-    :func:`divide`                          :func:`normal_cdf`                      :func:`year`
-    :func:`dow`                             not                                     :func:`year_of_week`
-    :func:`doy`                             :func:`parse_datetime`                  :func:`yow`
-    :func:`e`                               :func:`pi`                              :func:`zip`
-    :func:`element_at`                      :func:`plus`                            :func:`zip_with`
-    :func:`empty_approx_set`                :func:`pow`
+    :func:`abs`                             :func:`find_first_index`                :func:`plus`                                :func:`any_value`                           :func:`cume_dist`
+    :func:`acos`                            :func:`flatten`                         :func:`poisson_cdf`                         :func:`approx_distinct`                     :func:`dense_rank`
+    :func:`all_keys_match`                  :func:`floor`                           :func:`pow`                                 :func:`approx_most_frequent`                :func:`first_value`
+    :func:`all_match`                       :func:`format_datetime`                 :func:`power`                               :func:`approx_percentile`                   :func:`lag`
+    :func:`any_keys_match`                  :func:`from_base`                       :func:`quarter`                             :func:`approx_set`                          :func:`last_value`
+    :func:`any_match`                       :func:`from_base64`                     :func:`radians`                             :func:`arbitrary`                           :func:`lead`
+    :func:`any_values_match`                :func:`from_base64url`                  :func:`rand`                                :func:`array_agg`                           :func:`nth_value`
+    :func:`array_average`                   :func:`from_big_endian_32`              :func:`random`                              :func:`avg`                                 :func:`ntile`
+    :func:`array_constructor`               :func:`from_big_endian_64`              :func:`reduce`                              :func:`bitwise_and_agg`                     :func:`percent_rank`
+    :func:`array_distinct`                  :func:`from_hex`                        :func:`regexp_extract`                      :func:`bitwise_or_agg`                      :func:`rank`
+    :func:`array_duplicates`                :func:`from_ieee754_32`                 :func:`regexp_extract_all`                  :func:`bitwise_xor_agg`                     :func:`row_number`
+    :func:`array_except`                    :func:`from_ieee754_64`                 :func:`regexp_like`                         :func:`bool_and`
+    :func:`array_frequency`                 :func:`from_iso8601_date`               :func:`regexp_replace`                      :func:`bool_or`
+    :func:`array_has_duplicates`            :func:`from_unixtime`                   :func:`remove_nulls`                        :func:`checksum`
+    :func:`array_intersect`                 :func:`from_utf8`                       :func:`repeat`                              :func:`corr`
+    :func:`array_join`                      :func:`gamma_cdf`                       :func:`replace`                             :func:`count`
+    :func:`array_max`                       :func:`greatest`                        :func:`reverse`                             :func:`count_if`
+    :func:`array_min`                       :func:`gt`                              :func:`round`                               :func:`covar_pop`
+    :func:`array_normalize`                 :func:`gte`                             :func:`rpad`                                :func:`covar_samp`
+    :func:`array_position`                  :func:`hamming_distance`                :func:`rtrim`                               :func:`entropy`
+    :func:`array_remove`                    :func:`hmac_md5`                        :func:`second`                              :func:`every`
+    :func:`array_sort`                      :func:`hmac_sha1`                       :func:`sequence`                            :func:`geometric_mean`
+    :func:`array_sort_desc`                 :func:`hmac_sha256`                     :func:`sha1`                                :func:`histogram`
+    :func:`array_sum`                       :func:`hmac_sha512`                     :func:`sha256`                              :func:`kurtosis`
+    :func:`array_union`                     :func:`hour`                            :func:`sha512`                              :func:`map_agg`
+    :func:`arrays_overlap`                  in                                      :func:`shuffle`                             :func:`map_union`
+    :func:`asin`                            :func:`infinity`                        :func:`sign`                                :func:`map_union_sum`
+    :func:`atan`                            :func:`inverse_beta_cdf`                :func:`sin`                                 :func:`max`
+    :func:`atan2`                           :func:`is_finite`                       :func:`slice`                               :func:`max_by`
+    :func:`beta_cdf`                        :func:`is_infinite`                     :func:`split`                               :func:`max_data_size_for_stats`
+    :func:`between`                         :func:`is_json_scalar`                  :func:`split_part`                          :func:`merge`
+    :func:`binomial_cdf`                    :func:`is_nan`                          :func:`split_to_map`                        :func:`min`
+    :func:`bit_count`                       :func:`is_null`                         :func:`spooky_hash_v2_32`                   :func:`min_by`
+    :func:`bitwise_and`                     :func:`json_array_contains`             :func:`spooky_hash_v2_64`                   :func:`multimap_agg`
+    :func:`bitwise_arithmetic_shift_right`  :func:`json_array_length`               :func:`sqrt`                                :func:`reduce_agg`
+    :func:`bitwise_left_shift`              :func:`json_extract`                    :func:`starts_with`                         :func:`regr_avgx`
+    :func:`bitwise_logical_shift_right`     :func:`json_extract_scalar`             :func:`strpos`                              :func:`regr_avgy`
+    :func:`bitwise_not`                     :func:`json_format`                     :func:`strrpos`                             :func:`regr_count`
+    :func:`bitwise_or`                      :func:`json_parse`                      :func:`subscript`                           :func:`regr_intercept`
+    :func:`bitwise_right_shift`             :func:`json_size`                       :func:`substr`                              :func:`regr_r2`
+    :func:`bitwise_right_shift_arithmetic`  :func:`laplace_cdf`                     :func:`tan`                                 :func:`regr_slope`
+    :func:`bitwise_shift_left`              :func:`last_day_of_month`               :func:`tanh`                                :func:`regr_sxx`
+    :func:`bitwise_xor`                     :func:`least`                           :func:`timezone_hour`                       :func:`regr_sxy`
+    :func:`cardinality`                     :func:`length`                          :func:`timezone_minute`                     :func:`regr_syy`
+    :func:`cauchy_cdf`                      :func:`levenshtein_distance`            :func:`to_base`                             :func:`set_agg`
+    :func:`cbrt`                            :func:`like`                            :func:`to_base64`                           :func:`set_union`
+    :func:`ceil`                            :func:`ln`                              :func:`to_base64url`                        :func:`skewness`
+    :func:`ceiling`                         :func:`log10`                           :func:`to_big_endian_32`                    :func:`stddev`
+    :func:`chi_squared_cdf`                 :func:`log2`                            :func:`to_big_endian_64`                    :func:`stddev_pop`
+    :func:`chr`                             :func:`lower`                           :func:`to_hex`                              :func:`stddev_samp`
+    :func:`clamp`                           :func:`lpad`                            :func:`to_ieee754_32`                       :func:`sum`
+    :func:`codepoint`                       :func:`lt`                              :func:`to_ieee754_64`                       :func:`sum_data_size_for_stats`
+    :func:`combinations`                    :func:`lte`                             :func:`to_unixtime`                         :func:`var_pop`
+    :func:`concat`                          :func:`ltrim`                           :func:`to_utf8`                             :func:`var_samp`
+    :func:`contains`                        :func:`map`                             :func:`transform`                           :func:`variance`
+    :func:`cos`                             :func:`map_concat`                      :func:`transform_keys`
+    :func:`cosh`                            :func:`map_entries`                     :func:`transform_values`
+    :func:`cosine_similarity`               :func:`map_filter`                      :func:`trim`
+    :func:`crc32`                           :func:`map_from_entries`                :func:`trim_array`
+    :func:`current_date`                    :func:`map_keys`                        :func:`truncate`
+    :func:`date`                            :func:`map_normalize`                   :func:`typeof`
+    :func:`date_add`                        :func:`map_subset`                      :func:`upper`
+    :func:`date_diff`                       :func:`map_top_n`                       :func:`url_decode`
+    :func:`date_format`                     :func:`map_values`                      :func:`url_encode`
+    :func:`date_parse`                      :func:`map_zip_with`                    :func:`url_extract_fragment`
+    :func:`date_trunc`                      :func:`md5`                             :func:`url_extract_host`
+    :func:`day`                             :func:`millisecond`                     :func:`url_extract_parameter`
+    :func:`day_of_month`                    :func:`minus`                           :func:`url_extract_path`
+    :func:`day_of_week`                     :func:`minute`                          :func:`url_extract_port`
+    :func:`day_of_year`                     :func:`mod`                             :func:`url_extract_protocol`
+    :func:`degrees`                         :func:`month`                           :func:`url_extract_query`
+    :func:`distinct_from`                   :func:`multimap_from_entries`           :func:`week`
+    :func:`divide`                          :func:`multiply`                        :func:`week_of_year`
+    :func:`dow`                             :func:`nan`                             :func:`weibull_cdf`
+    :func:`doy`                             :func:`negate`                          :func:`width_bucket`
+    :func:`e`                               :func:`neq`                             :func:`wilson_interval_lower`
+    :func:`element_at`                      :func:`ngrams`                          :func:`wilson_interval_upper`
+    :func:`empty_approx_set`                :func:`no_keys_match`                   :func:`xxhash64`
+    :func:`ends_with`                       :func:`no_values_match`                 :func:`year`
+    :func:`eq`                              :func:`none_match`                      :func:`year_of_week`
+    :func:`exp`                             :func:`normal_cdf`                      :func:`yow`
+    :func:`f_cdf`                           not                                     :func:`zip`
+    :func:`filter`                          :func:`parse_datetime`                  :func:`zip_with`
+    :func:`find_first`                      :func:`pi`
     ======================================  ======================================  ======================================  ==  ======================================  ==  ======================================
diff --git a/velox/docs/functions/presto/aggregate.rst b/velox/docs/functions/presto/aggregate.rst
index 4fdbfd0aca615..c8443653857f7 100644
--- a/velox/docs/functions/presto/aggregate.rst
+++ b/velox/docs/functions/presto/aggregate.rst
@@ -21,6 +21,10 @@ General Aggregate Functions
 
     Returns an arbitrary non-null value of ``x``, if one exists.
 
+.. function:: any_value(x) -> [same as x]
+
+    This is an alias for :func:`arbitrary`.
+
 .. function:: array_agg(x) -> array<[same as x]>
 
     Returns an array created from the input ``x`` elements. Ignores null
@@ -82,15 +86,16 @@ General Aggregate Functions
     each input value occurs. Supports integral, floating-point,
     boolean, timestamp, and date input types.
 
-.. function:: geometric_mean(x) -> double
+.. function:: geometric_mean(bigint) -> double
+              geometric_mean(double) -> double
+              geometric_mean(real) -> real
 
     Returns the `geometric mean <https://en.wikipedia.org/wiki/Geometric_mean>`_ of all input values.
 
-    Supported types are BIGINT and DOUBLE.
-
 .. function:: max_by(x, y) -> [same as x]
 
     Returns the value of ``x`` associated with the maximum value of ``y`` over all input values.
+    ``y`` must be an orderable type.
 
 .. function:: max_by(x, y, n) -> array([same as x])
     :noindex:
@@ -100,6 +105,7 @@ General Aggregate Functions
 .. function:: min_by(x, y) -> [same as x]
 
     Returns the value of ``x`` associated with the minimum value of ``y`` over all input values.
+    ``y`` must be an orderable type.
 
 .. function:: min_by(x, y, n) -> array([same as x])
     :noindex:
@@ -110,23 +116,35 @@ General Aggregate Functions
 
     Returns the maximum value of all input values.
     ``x`` must not contain nulls when it is complex type.
+    ``x`` must be an orderable type.
+    Nulls are ignored if there are any non-null inputs.
+    For REAL and DOUBLE types, NaN is considered greater than Infinity.
 
 .. function:: max(x, n) -> array<[same as x]>
     :noindex:
 
     Returns ``n`` largest values of all input values of ``x``.
     ``n`` must be a positive integer and not exceed 10'000.
+    Currently not supported for ARRAY, MAP, and ROW input types.
+    Nulls are not included in the output array.
+    For REAL and DOUBLE types, NaN is considered greater than Infinity.
 
 .. function:: min(x) -> [same as x]
 
     Returns the minimum value of all input values.
     ``x`` must not contain nulls when it is complex type.
+    ``x`` must be an orderable type.
+    Nulls are ignored if there are any non-null inputs.
+    For REAL and DOUBLE types, NaN is considered greater than Infinity.
 
 .. function:: min(x, n) -> array<[same as x]>
     :noindex:
 
     Returns ``n`` smallest values of all input values of ``x``.
     ``n`` must be a positive integer and not exceed 10'000.
+    Currently not supported for ARRAY, MAP, and ROW input types.
+    Nulls are not included in output array.
+    For REAL and DOUBLE types, NaN is considered greater than Infinity.
 
 .. function:: multimap_agg(K key, V value) -> map(K,array(V))
 
@@ -143,6 +161,27 @@ General Aggregate Functions
     The final state is returned. Throws an error if ``initialState`` is NULL or
     ``inputFunction`` or ``combineFunction`` returns a NULL.
 
+    Take care when designing ``initialState``, ``inputFunction`` and ``combineFunction``.
+    These need to support evaluating aggregation in a distributed manner using partial
+    aggregation on many nodes, followed by shuffle over group-by keys, followed by
+    final aggregation. Given a set of all possible values of state, make sure that
+    combineFunction is `commutative <https://en.wikipedia.org/wiki/Commutative_property>`_
+    and `associative <https://en.wikipedia.org/wiki/Associative_property>`_
+    operation with initialState as the
+    `identity <https://en.wikipedia.org/wiki/Identity_element>`_ value.
+
+     combineFunction(s, initialState) = s for any s
+
+     combineFunction(s1, s2) = combineFunction(s2, s1) for any s1 and s2
+
+     combineFunction(s1, combineFunction(s2, s3)) = combineFunction(combineFunction(s1, s2), s3) for any s1, s2, s3
+
+    In addition, make sure that the following holds for the inputFunction:
+
+     inputFunction(inputFunction(initialState, x), y) = combineFunction(inputFunction(initialState, x), inputFunction(initialState, y)) for any x and y
+
+    Check out `blog post about reduce_agg <https://velox-lib.io/blog/reduce-agg>`_ for more context.
+
     Note that reduce_agg doesn't support evaluation over sorted inputs.::
 
         -- Compute sum (for illustration purposes only; use SUM aggregate function in production queries).
@@ -295,6 +334,9 @@ Approximate Aggregate Functions
     value is a map containing the top elements with corresponding estimated
     frequency.
 
+    For BOOLEAN 'value', this function always returns 'perfect' result.
+    'bucket' and 'capacity' arguments are ignored in this case.
+
     The error of the function depends on the permutation of the values and its
     cardinality.  We can set the capacity same as the cardinality of the
     underlying data to achieve the least error.
@@ -395,23 +437,59 @@ Statistical Aggregate Functions
 
    where :math:`\mu` is the mean, and :math:`\sigma` is the standard deviation.
 
+.. function:: regr_avgx(y, x) -> double
+
+    Returns the average of the independent value in a group. ``y`` is the dependent
+    value. ``x`` is the independent value.
+
+.. function:: regr_avgy(y, x) -> double
+
+    Returns the average of the dependent value in a group. ``y`` is the dependent
+    value. ``x`` is the independent value.
+
+.. function:: regr_count(y, x) -> double
+
+    Returns the number of non-null pairs of input values. ``y`` is the dependent
+    value. ``x`` is the independent value.
+
 .. function:: regr_intercept(y, x) -> double
 
     Returns linear regression intercept of input values. ``y`` is the dependent
     value. ``x`` is the independent value.
 
+.. function:: regr_r2(y, x) -> double
+
+    Returns the coefficient of determination of the linear regression. ``y`` is the dependent
+    value. ``x`` is the independent value. If regr_sxx(y, x) is 0, result is null. If regr_syy(y, x) is 0
+    and regr_sxx(y, x) isn't 0, result is 1.
+
 .. function:: regr_slope(y, x) -> double
 
     Returns linear regression slope of input values. ``y`` is the dependent
     value. ``x`` is the independent value.
 
+.. function:: regr_sxx(y, x) -> double
+
+    Returns the sum of the squares of the independent values in a group. ``y`` is the dependent
+    value. ``x`` is the independent value.
+
+.. function:: regr_sxy(y, x) -> double
+
+    Returns the sum of the product of the dependent and independent values in a group. ``y`` is the dependent
+    value. ``x`` is the independent value.
+
+.. function:: regr_syy(y, x) -> double
+
+    Returns the sum of the squares of the dependent values in a group. ``y`` is the dependent
+    value. ``x`` is the independent value.
+
 .. function:: skewness(x) -> double
 
     Returns the skewness of all input values.
 
 .. function:: stddev(x) -> double
 
-    This is an alias for stddev_samp().
+    This is an alias for :func:`stddev_samp`.
 
 .. function:: stddev_pop(x) -> double
 
@@ -423,7 +501,7 @@ Statistical Aggregate Functions
 
 .. function:: variance(x) -> double
 
-    This is an alias for var_samp().
+    This is an alias for :func:`var_samp`.
 
 .. function:: var_pop(x) -> double
 
diff --git a/velox/docs/functions/presto/array.rst b/velox/docs/functions/presto/array.rst
index ce92411930a66..3edd19c7731e4 100644
--- a/velox/docs/functions/presto/array.rst
+++ b/velox/docs/functions/presto/array.rst
@@ -33,14 +33,26 @@ Array Functions
 
     Returns the average of all non-null elements of the array. If there are no non-null elements, returns null.
 
+.. function:: array_cum_sum(array(T)) -> array(T)
+    Returns the array whose elements are the cumulative sum of the input array, i.e. result[i] = input[1] + input[2] +
+    … + input[i]. If there there is null elements in the array, the cumulative sum at and after the element is null. ::
+
+        SELECT array_cum_sum(ARRAY [1, 2, 3]) -- array[1, 3, 6]
+        SELECT array_cum_sum(ARRAY [1, 2, null, 3]) -- array[1, 3, null, null]
+
 .. function:: array_distinct(array(E)) -> array(E)
 
-    Remove duplicate values from the input array. ::
+    Remove duplicate values from the input array.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
 
         SELECT array_distinct(ARRAY [1, 2, 3]); -- [1, 2, 3]
         SELECT array_distinct(ARRAY [1, 2, 1]); -- [1, 2]
         SELECT array_distinct(ARRAY [1, NULL, NULL]); -- [1, NULL]
 
+.. function:: array_dupes(array(E)) -> boolean
+
+    This is an alias for :func:`array_duplicates(array(E))`
+
 .. function:: array_duplicates(array(E)) -> array(E)
 
     Returns a set of elements that occur more than once in array.
@@ -50,7 +62,8 @@ Array Functions
 
 .. function:: array_except(array(E) x, array(E) y) -> array(E)
 
-    Returns an array of the elements in array ``x`` but not in array ``y``, without duplicates. ::
+    Returns an array of the elements in array ``x`` but not in array ``y``, without duplicates.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
 
         SELECT array_except(ARRAY [1, 2, 3], ARRAY [4, 5, 6]); -- [1, 2, 3]
         SELECT array_except(ARRAY [1, 2, 3], ARRAY [1, 2]); -- [3]
@@ -68,6 +81,10 @@ Array Functions
         SELECT array_frequency(ARRAY ["knock", "knock", "who", "?"]); -- {"knock" -> 2, "who" -> 1, "?" -> 1}
         SELECT array_frequency(ARRAY []); -- {}
 
+.. function:: array_has_dupes(array(E)) -> boolean
+
+    This is an alias for :func:`array_has_duplicates(array(E))`.
+
 .. function:: array_has_duplicates(array(E)) -> boolean
 
     Returns a boolean: whether array has any elements that occur more than once.
@@ -77,7 +94,8 @@ Array Functions
 
 .. function:: array_intersect(array(E) x, array(E) y) -> array(E)
 
-    Returns an array of the elements in the intersection of array ``x`` and array ``y``, without duplicates. ::
+    Returns an array of the elements in the intersection of array ``x`` and array ``y``, without duplicates.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
 
         SELECT array_intersect(ARRAY [1, 2, 3], ARRAY[4, 5, 6]); -- []
         SELECT array_intersect(ARRAY [1, 2, 2], ARRAY[1, 1, 2]); -- [1, 2]
@@ -93,21 +111,31 @@ Array Functions
 
 .. function:: array_max(array(E)) -> E
 
-    Returns the maximum value of input array. ::
+    Returns the maximum value of input array.
+    NaN is considered to be greater than Infinity.
+    Returns NULL if array contains a NULL value. ::
 
         SELECT array_max(ARRAY [1, 2, 3]); -- 3
         SELECT array_max(ARRAY [-1, -2, -2]); -- -1
         SELECT array_max(ARRAY [-1, -2, NULL]); -- NULL
         SELECT array_max(ARRAY []); -- NULL
+        SELECT array_max(ARRAY [-1, nan(), NULL]); -- NULL
+        SELECT array_max(ARRAY[{-1, -2, -3, nan()]); -- NaN
+        SELECT array_max(ARRAY[{infinity(), nan()]); -- NaN
 
 .. function:: array_min(array(E)) -> E
 
-    Returns the minimum value of input array. ::
+    Returns the minimum value of input array.
+    NaN is considered to be greater than Infinity.
+    Returns NULL if array contains a NULL value. ::
 
         SELECT array_min(ARRAY [1, 2, 3]); -- 1
         SELECT array_min(ARRAY [-1, -2, -2]); -- -2
         SELECT array_min(ARRAY [-1, -2, NULL]); -- NULL
         SELECT array_min(ARRAY []); -- NULL
+        SELECT array_min(ARRAY [-1, nan(), NULL]); -- NULL
+        SELECT array_min(ARRAY[{-1, -2, -3, nan()]); -- -1
+        SELECT array_min(ARRAY[{infinity(), nan()]); -- Infinity
 
 .. function:: array_normalize(array(E), E) -> array(E)
 
@@ -117,56 +145,83 @@ Array Functions
 
     Tests if arrays ``x`` and ``y`` have any non-null elements in common.
     Returns null if there are no non-null elements in common but either array contains null.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
+
+.. function:: arrays_union(x, y) -> array
+
+    Returns an array of the elements in the union of x and y, without duplicates.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
 
 .. function:: array_position(x, element) -> bigint
 
     Returns the position of the first occurrence of the ``element`` in array ``x`` (or 0 if not found).
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
 
 .. function:: array_position(x, element, instance) -> bigint
     :noindex:
 
     If ``instance > 0``, returns the position of the ``instance``-th occurrence of the ``element`` in array ``x``. If ``instance < 0``, returns the position of the ``instance``-to-last occurrence of the ``element`` in array ``x``. If no matching element instance is found, 0 is returned.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
 
 .. function:: array_remove(x, element) -> array
 
     Remove all elements that equal ``element`` from array ``x``.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal.
 
         SELECT array_remove(ARRAY [1, 2, 3], 3); -- [1, 2]
         SELECT array_remove(ARRAY [2, 1, NULL], 1); -- [2, NULL]
+        SELECT array_remove(ARRAY [2.1, 1.1, nan()], nan()); -- [2.1, 1.1]
 
 .. function:: array_sort(array(E)) -> array(E)
 
-    Returns an array which has the sorted order of the input array x. The elements of x must
-    be orderable. Null elements will be placed at the end of the returned array.::
+    Returns an array which has the sorted order of the input array x. E must be
+    an orderable type. Null elements will be placed at the end of the returned array.
+    May throw if E is and ARRAY or ROW type and input values contain nested nulls.
+    Throws if deciding the order of elements would require comparing nested null values. ::
 
         SELECT array_sort(ARRAY [1, 2, 3]); -- [1, 2, 3]
         SELECT array_sort(ARRAY [3, 2, 1]); -- [1, 2, 3]
+        SELECT array_sort(ARRAY [infinity(), -1.1, nan(), 1.1, -Infinity(), 0])); -- [-Infinity, -1.1, 0, 1.1, Infinity, NaN]
         SELECT array_sort(ARRAY [2, 1, NULL]; -- [1, 2, NULL]
         SELECT array_sort(ARRAY [NULL, 1, NULL]); -- [1, NULL, NULL]
         SELECT array_sort(ARRAY [NULL, 2, 1]); -- [1, 2, NULL]
+        SELECT array_sort(ARRAY [ARRAY [1, 2], ARRAY [2, null]]); -- [[1, 2], [2, null]]
+        SELECT array_sort(ARRAY [ARRAY [1, 2], ARRAY [1, null]]); -- failed: Ordering nulls is not supported
 
 .. function:: array_sort(array(T), function(T,U)) -> array(T)
+    :noindex:
 
     Returns the array sorted by values computed using specified lambda in ascending
-    order. Null elements will be placed at the end of the returned array. ::
+    order. U must be an orderable type. Null elements will be placed at the end of
+    the returned array. May throw if E is and ARRAY or ROW type and input values contain
+    nested nulls. Throws if deciding the order of elements would require comparing nested
+    null values. ::
 
         SELECT array_sort(ARRAY ['cat', 'leopard', 'mouse'], x -> length(x)); -- ['cat', 'mouse', 'leopard']
 
 .. function:: array_sort_desc(array(E)) -> array(E)
 
-    Returns the array sorted in the descending order. The elements of the array must
-    be orderable. Null elements will be placed at the end of the returned array.::
+    Returns the array sorted in the descending order. E must be an orderable type.
+    Null elements will be placed at the end of the returned array.
+    May throw if E is and ARRAY or ROW type and input values contain nested nulls.
+    Throws if deciding the order of elements would require comparing nested null values. ::
 
         SELECT array_sort_desc(ARRAY [1, 2, 3]); -- [3, 2, 1]
         SELECT array_sort_desc(ARRAY [3, 2, 1]); -- [3, 2, 1]
         SELECT array_sort_desc(ARRAY [2, 1, NULL]; -- [2, 1, NULL]
         SELECT array_sort_desc(ARRAY [NULL, 1, NULL]); -- [1, NULL, NULL]
         SELECT array_sort_desc(ARRAY [NULL, 2, 1]); -- [2, 1, NULL]
+        SELECT array_sort(ARRAY [ARRAY [1, 2], ARRAY [2, null]]); -- [[1, 2], [2, null]]
+        SELECT array_sort(ARRAY [ARRAY [1, 2], ARRAY [1, null]]); -- failed: Ordering nulls is not supported
 
 .. function:: array_sort_desc(array(T), function(T,U)) -> array(T)
+    :noindex:
 
     Returns the array sorted by values computed using specified lambda in descending
-    order. Null elements will be placed at the end of the returned array. ::
+    order. U must be an orderable type. Null elements will be placed at the end of
+    the returned array. May throw if E is and ARRAY or ROW type and input values contain
+    nested nulls. Throws if deciding the order of elements would require comparing nested
+    null values. ::
 
         SELECT array_sort_desc(ARRAY ['cat', 'leopard', 'mouse'], x -> length(x)); -- ['leopard', 'mouse', 'cat']
 
@@ -194,6 +249,14 @@ Array Functions
 .. function:: contains(x, element) -> boolean
 
     Returns true if the array ``x`` contains the ``element``.
+    When 'element' is of complex type, throws if 'x' or 'element' contains nested nulls
+    and these need to be compared to produce a result.
+    For REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
+
+        SELECT contains(ARRAY [2.1, 1.1, nan()], nan()); -- true.
+        SELECT contains(ARRAY[ARRAY[1, 3]], ARRAY[2, null]); -- false.
+        SELECT contains(ARRAY[ARRAY[2, 3]], ARRAY[2, null]); -- failed: contains does not support arrays with elements that are null or contain null
+        SELECT contains(ARRAY[ARRAY[2, null]], ARRAY[2, 1]); -- failed: contains does not support arrays with elements that are null or contain null
 
 .. function:: element_at(array(E), index) -> E
 
@@ -217,6 +280,7 @@ Array Functions
     for no-match and first-match-is-null cases.
 
 .. function:: find_first(array(T), index, function(T,boolean)) -> E
+    :noindex:
 
     Returns the first element of ``array`` that matches the predicate.
     Returns ``NULL`` if no element matches the predicate.
@@ -238,6 +302,7 @@ Array Functions
     Returns ``NULL`` if no such element exists.
 
 .. function:: find_first_index(array(T), index, function(T,boolean)) -> BIGINT
+    :noindex:
 
     Returns the 1-based index of the first element of ``array`` that matches the predicate.
     Returns ``NULL`` if no such element exists.
@@ -245,15 +310,28 @@ Array Functions
     If ``index`` < 0, the search for element starts at position ``abs(index)`` counting from
     the end of the array, until the start of the array. ::
 
-        SELECT find_first(ARRAY[3, 4, 5, 6], 2, x -> x > 0); -- 2
-        SELECT find_first(ARRAY[3, 4, 5, 6], -2, x -> x > 0); -- 3
-        SELECT find_first(ARRAY[3, 4, 5, 6], 2, x -> x < 4); -- NULL
-        SELECT find_first(ARRAY[3, 4, 5, 6], -2, x -> x > 5); -- NULL
+        SELECT find_first_index(ARRAY[3, 4, 5, 6], 2, x -> x > 0); -- 2
+        SELECT find_first_index(ARRAY[3, 4, 5, 6], -2, x -> x > 0); -- 3
+        SELECT find_first_index(ARRAY[3, 4, 5, 6], 2, x -> x < 4); -- NULL
+        SELECT find_first_index(ARRAY[3, 4, 5, 6], -2, x -> x > 5); -- NULL
 
 .. function:: flatten(array(array(T))) -> array(T)
 
     Flattens an ``array(array(T))`` to an ``array(T)`` by concatenating the contained arrays.
 
+.. function:: ngrams(array(T), n) -> array(array(T))
+
+    Returns `n-grams <https://en.wikipedia.org/wiki/N-gram>`_  for the array.
+    Throws if n is zero or negative. If n is greater or equal to input array,
+    result array contains input array as the only item. ::
+
+        SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 2); -- [['foo', 'bar'], ['bar', 'baz'], ['baz', 'foo']]
+        SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 3); -- [['foo', 'bar', 'baz'], ['bar', 'baz', 'foo']]
+        SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 4); -- [['foo', 'bar', 'baz', 'foo']]
+        SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 5); -- [['foo', 'bar', 'baz', 'foo']]
+        SELECT ngrams(ARRAY[1, 2, 3, 4], 2); -- [[1, 2], [2, 3], [3, 4]]
+        SELECT ngrams(ARRAY["foo", NULL, "bar"], 2); -- [["foo", NULL], [NULL, "bar"]]
+
 .. function:: reduce(array(T), initialState S, inputFunction(S,T,S), outputFunction(S,R)) -> R
 
     Returns a single value reduced from ``array``. ``inputFunction`` will
@@ -261,7 +339,9 @@ Array Functions
     the element, ``inputFunction`` takes the current state, initially
     ``initialState``, and returns the new state. ``outputFunction`` will be
     invoked to turn the final state into the result value. It may be the
-    identity function (``i -> i``). ::
+    identity function (``i -> i``).
+
+    Throws if array has more than 10,000 elements. ::
 
         SELECT reduce(ARRAY [], 0, (s, x) -> s + x, s -> s); -- 0
         SELECT reduce(ARRAY [5, 20, 50], 0, (s, x) -> s + x, s -> s); -- 75
@@ -284,7 +364,7 @@ Array Functions
 
 .. function:: shuffle(array(E)) -> array(E)
 
-    Generate a random permutation of the given ``array``::
+    Generate a random permutation of the given ``array`` ::
 
         SELECT shuffle(ARRAY [1, 2, 3]); -- [3, 1, 2] or any other random permutation
         SELECT shuffle(ARRAY [0, 0, 0]); -- [0, 0, 0]
@@ -330,6 +410,14 @@ Array Functions
         SELECT trim_array(ARRAY[1, 2, 3, 4], 2); -- [1, 2]
         SELECT trim_array(ARRAY[1, 2, 3, 4], 4); -- []
 
+.. function:: remove_nulls(x) -> array
+
+    Remove null values from an array ``array`` ::
+
+        SELECT remove_nulls(ARRAY[1, NULL, 3, NULL]); -- [1, 3]
+        SELECT remove_nulls(ARRAY[true, false, NULL]); -- [true, false]
+        SELECT remove_nulls(ARRAY[ARRAY[1, 2], NULL, ARRAY[1, NULL, 3]]); -- [[1, 2], [1, null, 3]]
+
 .. function:: zip(array(T), array(U),..) -> array(row(T,U, ...))
 
     Returns the merge of the given arrays, element-wise into a single array of rows.
@@ -341,7 +429,8 @@ Array Functions
 .. function:: zip_with(array(T), array(U), function(T,U,R)) -> array(R)
 
     Merges the two given arrays, element-wise, into a single array using ``function``.
-    If one array is shorter, nulls are appended at the end to match the length of the longer array, before applying ``function``::
+    If one array is shorter, nulls are appended at the end to match the length of the
+    longer array, before applying ``function`` ::
 
         SELECT zip_with(ARRAY[1, 3, 5], ARRAY['a', 'b', 'c'], (x, y) -> (y, x)); -- [ROW('a', 1), ROW('b', 3), ROW('c', 5)]
         SELECT zip_with(ARRAY[1, 2], ARRAY[3, 4], (x, y) -> x + y); -- [4, 6]
diff --git a/velox/docs/functions/presto/binary.rst b/velox/docs/functions/presto/binary.rst
index 47c7ea7205b7b..8b4ddc26832ea 100644
--- a/velox/docs/functions/presto/binary.rst
+++ b/velox/docs/functions/presto/binary.rst
@@ -8,7 +8,26 @@ Binary Functions
 
 .. function:: from_base64(string) -> varbinary
 
-    Decodes binary data from the base64 encoded ``string``.
+    Decodes a Base64-encoded ``string`` back into its original binary form. 
+    This function is capable of handling both fully padded and non-padded Base64 encoded strings. 
+    Partially padded Base64 strings are not supported and will result in an error.
+
+    Examples
+    --------
+    Query with padded Base64 string:
+    ::
+        SELECT from_base64('SGVsbG8gV29ybGQ='); -- [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
+
+    Query with non-padded Base64 string:
+    ::
+        SELECT from_base64('SGVsbG8gV29ybGQ'); -- [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
+
+    Query with partial-padded Base64 string:
+    ::
+        SELECT from_base64('SGVsbG8gV29ybGQgZm9yIHZlbG94IQ='); -- Error : Base64::decode() - invalid input string: string length is not a multiple of 4.
+
+    In the above examples, both the fully padded and non-padded Base64 strings ('SGVsbG8gV29ybGQ=' and 'SGVsbG8gV29ybGQ') decode to the binary representation of the text 'Hello World'.
+    While, partial-padded Base64 string 'SGVsbG8gV29ybGQgZm9yIHZlbG94IQ=' will lead to an velox error.
 
 .. function:: from_base64url(string) -> varbinary
 
@@ -26,6 +45,16 @@ Binary Functions
 
     Decodes binary data from the hex encoded ``string``.
 
+.. function:: from_ieee754_32(binary) -> real
+
+    Decodes the 32-bit big-endian ``binary`` in IEEE 754 single-precision floating-point format.
+    Throws a user error if input size is shorter / longer than 32 bits.
+
+.. function:: from_ieee754_64(binary) -> double
+
+    Decodes the 64-bit big-endian ``binary`` in IEEE 754 double-precision floating-point format.
+    Throws a user error if input size is shorter / longer than 64 bits.
+
 .. function:: hmac_md5(binary, key) -> varbinary
 
     Computes the HMAC with md5 of ``binary`` with the given ``key``.
@@ -46,10 +75,30 @@ Binary Functions
 
     Returns the length of ``binary`` in bytes.
 
+.. function:: lpad(binary, size, padbinary) -> varbinary
+    :noindex:
+    
+    Left pads ``binary`` to ``size`` bytes with ``padbinary``.
+    If ``size`` is less than the length of ``binary``, the result is
+    truncated to ``size`` characters. ``size`` must not be negative
+    and ``padbinary`` must be non-empty. ``size`` has a maximum value of 1 MiB.
+    In the case of ``size`` being smaller than the length of ``binary``, 
+    ``binary`` will be truncated from the right to fit the ``size``.
+
 .. function:: md5(binary) -> varbinary
 
     Computes the md5 hash of ``binary``.
 
+.. function:: rpad(binary, size, padbinary) -> varbinary
+    :noindex:
+
+    Right pads ``binary`` to ``size`` bytes with ``padbinary``.
+    If ``size`` is less than the length of ``binary``, the result is
+    truncated to ``size`` characters. ``size`` must not be negative
+    and ``padbinary`` must be non-empty. ``size`` has a maximum value of 1 MiB.
+    In the case of ``size`` being smaller than the length of ``binary``, 
+    ``binary`` will be truncated from the right to fit the ``size``.
+    
 .. function:: sha1(binary) -> varbinary
 
     Computes the SHA-1 hash of ``binary``.
@@ -90,6 +139,10 @@ Binary Functions
 
     Encodes ``binary`` into a hex string representation.
 
+.. function:: to_ieee754_32(real) -> varbinary
+
+    Encodes ``real`` in a 32-bit big-endian binary according to IEEE 754 single-precision floating-point format.
+
 .. function:: to_ieee754_64(double) -> varbinary
 
     Encodes ``double`` in a 64-bit big-endian binary according to IEEE 754 double-precision floating-point format.
diff --git a/velox/docs/functions/presto/bitwise.rst b/velox/docs/functions/presto/bitwise.rst
index e2657f07dcb1f..c22445bdec3ea 100644
--- a/velox/docs/functions/presto/bitwise.rst
+++ b/velox/docs/functions/presto/bitwise.rst
@@ -12,42 +12,51 @@ Bitwise Functions
         SELECT bit_count(-7, 64); -- 62
         SELECT bit_count(-7, 8); -- 6
 
-.. function:: bitwise_and(x, y) -> [bigint]
+.. function:: bitwise_and(x, y) -> bigint
 
     Returns the bitwise AND of ``x`` and ``y`` in 2's complement representation.
 
-.. function:: bitwise_arithmetic_shift_right(x, shift) -> [bigint]``
+.. function:: bitwise_arithmetic_shift_right(x, shift) -> bigint
 
     Returns the arithmetic right shift operation on ``x`` shifted by ``shift`` in 2’s complement representation.
+    ``shift`` must not be negative.
 
-.. function:: bitwise_left_shift(x, shift) -> [bigint]``
+.. function:: bitwise_left_shift(x, shift) -> [same as x]
 
-    Returns the left shifted value of ``x``. Here x can be of type ``TINYINT`` , ``SMALLINT``, ``INTEGER`` and ``BIGINT``.
+    Returns the left shifted value of ``x``.
+    Supported types of x are: ``TINYINT`` , ``SMALLINT``, ``INTEGER`` and ``BIGINT``.
+    ``shift`` is an ``INTEGER``.
 
-.. function:: bitwise_logical_shift_right(x, shift, bits) -> [bigint]``
+.. function:: bitwise_logical_shift_right(x, shift, bits) -> bigint
 
     Returns the logical right shift operation on ``x`` (treated as ``bits``-bit integer) shifted by ``shift``.
+    ``shift`` must not be negative.
 
-.. function:: bitwise_not(x) -> [bigint]
+.. function:: bitwise_not(x) -> bigint
 
     Returns the bitwise NOT of ``x`` in 2's complement representation.
 
-.. function:: bitwise_or(x, y) -> [bigint]
+.. function:: bitwise_or(x, y) -> bigint
 
     Returns the bitwise OR of ``x`` and ``y`` in 2's complement representation.
 
-.. function:: bitwise_right_shift(x, shift) -> [bigint]``
+.. function:: bitwise_right_shift(x, shift) -> [same as x]
 
-    Returns the logical right shifted value of ``x``. Here x can be of type ``TINYINT``, ``SMALLINT``, ``INTEGER`` and ``BIGINT``.
+    Returns the logical right shifted value of ``x``.
+    Supported types of x are: ``TINYINT``, ``SMALLINT``, ``INTEGER`` and ``BIGINT``.
+    ``shift`` is an ``INTEGER``.
 
-.. function:: bitwise_right_shift_arithmetic(x, shift) -> [bigint]``
+.. function:: bitwise_right_shift_arithmetic(x, shift) -> [same as x]
 
     Returns the arithmetic right shift value of ``x``.
+    Supported types of x are: ``TINYINT``, ``SMALLINT``, ``INTEGER`` and ``BIGINT``.
+    ``shift`` is an ``INTEGER``.
 
-.. function:: bitwise_shift_left(x, shift, bits) -> [bigint]``
+.. function:: bitwise_shift_left(x, shift, bits) -> bigint
 
     Returns the left shift operation on ``x`` (treated as ``bits``-bit integer) shifted by ``shift``.
+    ``shift`` must not be negative.
 
-.. function:: bitwise_xor(x, y) -> [bigint]``
+.. function:: bitwise_xor(x, y) -> bigint
 
     Returns the bitwise XOR of ``x`` and ``y`` in 2's complement representation.
diff --git a/velox/docs/functions/presto/conversion.rst b/velox/docs/functions/presto/conversion.rst
index 099af8c2f9d21..b24117ae3068a 100644
--- a/velox/docs/functions/presto/conversion.rst
+++ b/velox/docs/functions/presto/conversion.rst
@@ -30,7 +30,7 @@ are supported if the conversion of their element types are supported. In additio
 supported conversions to/from JSON are listed in :doc:`json`.
 
 .. list-table::
-   :widths: 25 25 25 25 25 25 25 25 25 25 25 25 25
+   :widths: 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25
    :header-rows: 1
 
    * -
@@ -42,10 +42,13 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - real
      - double
      - varchar
+     - varbinary
      - timestamp
      - timestamp with time zone
      - date
+     - interval day to second
      - decimal
+     - ipaddress
    * - tinyint
      - Y
      - Y
@@ -55,10 +58,13 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
+     -
      -
      -
      -
      - Y
+     - 
    * - smallint
      - Y
      - Y
@@ -68,10 +74,13 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
+     -
      -
      -
      -
      - Y
+     - 
    * - integer
      - Y
      - Y
@@ -81,10 +90,13 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
+     -
      -
      -
      -
      - Y
+     - 
    * - bigint
      - Y
      - Y
@@ -94,10 +106,13 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
+     -
      -
      -
      -
      - Y
+     - 
    * - boolean
      - Y
      - Y
@@ -107,10 +122,13 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
      -
      -
      -
      -
+     - Y
+     - 
    * - real
      - Y
      - Y
@@ -120,10 +138,13 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
      -
      -
      -
      -
+     - Y
+     - 
    * - double
      - Y
      - Y
@@ -133,10 +154,13 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
      -
      -
      -
      -
+     - Y
+     - 
    * - varchar
      - Y
      - Y
@@ -146,10 +170,29 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
+     - Y
+     - Y
      - Y
      -
      - Y
+     - Y
+   * - varbinary
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
      -
+     - 
+     - Y
    * - timestamp
      -
      -
@@ -159,12 +202,14 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      - Y
+     - 
      - Y
      - Y
      - Y
      -
-   * - timestamp with time zone
      -
+     - 
+   * - timestamp with time zone
      -
      -
      -
@@ -173,11 +218,30 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      - Y
+     - 
+     - Y
+     -
      - Y
      -
      -
+     -
    * - date
      -
+     -
+     -
+     -
+     -
+     -
+     -
+     - Y
+     - 
+     - Y
+     - Y
+     -
+     -
+     -
+     -
+   * - interval day to second
      -
      -
      -
@@ -186,6 +250,10 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      - Y
+     - 
+     -
+     -
+     -
      -
      -
      -
@@ -198,10 +266,29 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     - 
+     -
+     -
      -
      -
+     - Y
      -
+   * - ipaddress
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
+     - 
+     - Y
      - Y
+     -
+     -
+     -
+     -
+     - 
+     - 
 
 Cast to Integral Types
 ----------------------
@@ -263,16 +350,12 @@ supported cases.
   SELECT cast(nan() as bigint); -- 0
 
 
-From strings
+From VARCHAR
 ^^^^^^^^^^^^
 
 Casting a string to an integral type is allowed if the string represents an
 integral number within the range of the result type. By default, casting from
 strings that represent floating-point numbers is not allowed.
-
-If cast_to_int_by_truncate is set to true, and the string represents a floating-point number,
-the decimal part will be truncated for casting to an integer.
-
 Casting from invalid input values throws.
 
 Valid examples
@@ -283,36 +366,12 @@ Valid examples
   SELECT cast('+1' as tinyint); -- 1
   SELECT cast('-1' as tinyint); -- -1
 
-Valid examples if cast_to_int_by_truncate=true
-
-::
-
-  SELECT cast('12345.67' as tinyint); -- 12345
-  SELECT cast('1.2' as tinyint); -- 1
-  SELECT cast('-1.8' as tinyint); -- -1
-  SELECT cast('1.' as tinyint); -- 1
-  SELECT cast('-1.' as tinyint); -- -1
-  SELECT cast('0.' as tinyint); -- 0
-  SELECT cast('.' as tinyint); -- 0
-  SELECT cast('-.' as tinyint); -- 0
-
 Invalid examples
 
-::
-
-  SELECT cast('1234567' as tinyint); -- Out of range
-  SELECT cast('1a' as tinyint); -- Invalid argument
-  SELECT cast('' as tinyint); -- Invalid argument
-  SELECT cast('1,234,567' as bigint); -- Invalid argument
-  SELECT cast('1'234'567' as bigint); -- Invalid argument
-  SELECT cast('nan' as bigint); -- Invalid argument
-  SELECT cast('infinity' as bigint); -- Invalid argument
-
-Invalid examples if cast_to_int_by_truncate=false
-
 ::
 
   SELECT cast('12345.67' as tinyint); -- Invalid argument
+  SELECT cast('12345.67' as bigint); -- Invalid argument
   SELECT cast('1.2' as tinyint); -- Invalid argument
   SELECT cast('-1.8' as tinyint); -- Invalid argument
   SELECT cast('1.' as tinyint); -- Invalid argument
@@ -324,20 +383,19 @@ Invalid examples if cast_to_int_by_truncate=false
 From decimal
 ^^^^^^^^^^^^
 
-By default, the decimal part is rounded. If cast_to_int_by_truncate is enabled, the decimal part will be truncated for casting to an integer.
+The decimal part is rounded.
 
 Valid examples
 
 ::
 
-  SELECT cast(2.56 decimal(6, 2) as integer); -- 2 /* cast_to_int_by_truncate enabled */
-  SELECT cast(2.56 decimal(6, 2) as integer); -- 3 /* cast_to_int_by_truncate disabled */
+  SELECT cast(2.56 decimal(6, 2) as integer); -- 3
   SELECT cast(3.46 decimal(6, 2) as integer); -- 3
 
 Invalid examples
 
 ::
-  
+
   SELECT cast(214748364890 decimal(12, 2) as integer); -- Out of range
 
 Cast to Boolean
@@ -363,11 +421,14 @@ Valid examples
   SELECT cast(nan() as boolean); -- true
   SELECT cast(infinity() as boolean); -- true
   SELECT cast(0.0000000000001 as boolean); -- true
+  SELECT cast(0.5 as boolean); -- true
+  SELECT cast(-0.5 as boolean); -- true
 
-From strings
+From VARCHAR
 ^^^^^^^^^^^^
 
-There is a set of strings allowed to be casted to boolean. Casting from other strings to boolean throws.
+The strings `t, f, 1, 0, true, false` and their upper case equivalents are allowed to be casted to boolean.
+Casting from other strings to boolean throws.
 
 Valid examples
 
@@ -379,6 +440,8 @@ Valid examples
   SELECT cast('true' as boolean); -- true (case insensitive)
   SELECT cast('f' as boolean); -- false (case insensitive)
   SELECT cast('false' as boolean); -- false (case insensitive)
+  SELECT cast('F' as boolean); -- false (case insensitive)
+  SELECT cast('T' as boolean); -- true (case insensitive)
 
 Invalid examples
 
@@ -391,6 +454,7 @@ Invalid examples
   SELECT cast('-1' as boolean); -- Invalid argument
   SELECT cast('tr' as boolean); -- Invalid argument
   SELECT cast('tru' as boolean); -- Invalid argument
+  SELECT cast('No' as boolean); -- Invalid argument
 
 Cast to Floating-Point Types
 ----------------------------
@@ -416,7 +480,7 @@ behavior.
   SELECT cast(1.7E308 as real); -- Presto returns Infinity but Velox throws
   SELECT cast(-1.7E308 as real); -- Presto returns -Infinity but Velox throws
 
-From strings
+From VARCHAR
 ^^^^^^^^^^^^
 
 Casting a string to real is allowed if the string represents an integral or
@@ -429,27 +493,32 @@ Valid examples
   SELECT cast('1.' as real); -- 1.0
   SELECT cast('1' as real); -- 1.0
   SELECT cast('1.7E308' as real); -- Infinity
-  SELECT cast('infinity' as real); -- Infinity (case insensitive)
-  SELECT cast('-infinity' as real); -- -Infinity (case insensitive)
-  SELECT cast('nan' as real); -- NaN (case insensitive)
+  SELECT cast('Infinity' as real); -- Infinity (case sensitive)
+  SELECT cast('-Infinity' as real); -- -Infinity (case sensitive)
+  SELECT cast('NaN' as real); -- NaN (case sensitive)
 
 Invalid examples
 
 ::
 
-  SELECT cast('1.7E308' as real); -- Out of range
   SELECT cast('1.2a' as real); -- Invalid argument
   SELECT cast('1.2.3' as real); -- Invalid argument
+  SELECT cast('infinity' as real); -- Invalid argument
+  SELECT cast('-infinity' as real); -- -Invalid argument
+  SELECT cast('inf' as real); -- Invalid argument
+  SELECT cast('InfiNiTy' as real); -- Invalid argument
+  SELECT cast('INFINITY' as real); -- Invalid argument
+  SELECT cast('nAn' as real); -- Invalid argument
+  SELECT cast('nan' as real); -- Invalid argument
 
-There are a few corner cases where Velox behaves differently from Presto.
-Presto throws INVALID_CAST_ARGUMENT on these queries, while Velox allows these
-conversions. We keep the Velox behaivor by intention because it is more
-consistent with other supported cases of cast.
+Below cases are supported in Presto, but throw in Velox.
 
 ::
 
-  SELECT cast('InfiNiTy' as real); -- Infinity
-  SELECT cast('nAn' as real); -- NaN
+  SELECT cast('1.2f' as real); -- 1.2
+  SELECT cast('1.2f' as double); -- 1.2
+  SELECT cast('1.2d' as real); -- 1.2
+  SELECT cast('1.2d' as double); -- 1.2
 
 From decimal
 ^^^^^^^^^^^^
@@ -468,9 +537,11 @@ Invalid example
 
   SELECT cast(decimal '300.001' as tinyint); -- Out of range
 
-Cast to String
+Cast to VARCHAR
 --------------
 
+Casting from scalar types to string is allowed.
+
 Valid examples
 
 ::
@@ -481,38 +552,225 @@ Valid examples
   SELECT cast(nan() as varchar); -- 'NaN'
   SELECT cast(infinity() as varchar); -- 'Infinity'
   SELECT cast(true as varchar); -- 'true'
-  SELECT cast(timestamp '1970-01-01 00:00:00' as varchar); -- '1970-01-01T00:00:00.000'
+  SELECT cast(timestamp '1970-01-01 00:00:00' as varchar); -- '1970-01-01 00:00:00.000'
+  SELECT cast(timestamp '2024-06-01 11:37:15.123 America/New_York' as varchar); -- '2024-06-01 11:37:15.123 America/New_York'
   SELECT cast(cast(22.51 as DECIMAL(5, 3)) as varchar); -- '22.510'
   SELECT cast(cast(-22.51 as DECIMAL(4, 2)) as varchar); -- '-22.51'
   SELECT cast(cast(0.123 as DECIMAL(3, 3)) as varchar); -- '0.123'
   SELECT cast(cast(1 as DECIMAL(6, 2)) as varchar); -- '1.00'
+  SELECT cast(cast(0 as DECIMAL(6, 2)) as varchar); -- '0.00'
+
+From Floating-Point Types
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+By default, casting a real or double to string returns standard notation if the magnitude of input value is greater than
+or equal to 10 :superscript:`-3` but less than 10 :superscript:`7`, and returns scientific notation otherwise.
+
+Positive zero returns '0.0' and negative zero returns '-0.0'. Positive infinity returns 'Infinity' and negative infinity
+returns '-Infinity'. Positive and negative NaN returns 'NaN'.
+
+If legacy_cast configuration property is true, the result is standard notation for all input value.
+
+Valid examples if legacy_cast = false,
+
+::
+
+  SELECT cast(double '123456789.01234567' as varchar); -- '1.2345678901234567E8'
+  SELECT cast(double '10000000.0' as varchar); -- '1.0E7'
+  SELECT cast(double '12345.0' as varchar); -- '12345.0'
+  SELECT cast(double '-0.001' as varchar); -- '-0.001'
+  SELECT cast(double '-0.00012' as varchar); -- '-1.2E-4'
+  SELECT cast(double '0.0' as varchar); -- '0.0'
+  SELECT cast(double '-0.0' as varchar); -- '-0.0'
+  SELECT cast(infinity() as varchar); -- 'Infinity'
+  SELECT cast(-infinity() as varchar); -- '-Infinity'
+  SELECT cast(nan() as varchar); -- 'NaN'
+  SELECT cast(-nan() as varchar); -- 'NaN'
+
+  SELECT cast(real '123456780.0' as varchar); -- '1.2345678E8'
+  SELECT cast(real '10000000.0' as varchar); -- '1.0E7'
+  SELECT cast(real '12345.0' as varchar); -- '12345.0'
+  SELECT cast(real '-0.001' as varchar); -- '-0.001'
+  SELECT cast(real '-0.00012' as varchar); -- '-1.2E-4'
+  SELECT cast(real '0.0' as varchar); -- '0.0'
+  SELECT cast(real '-0.0' as varchar); -- '-0.0'
+
+Valid examples if legacy_cast = true,
+
+::
+
+  SELECT cast(double '123456789.01234567' as varchar); -- '123456789.01234567'
+  SELECT cast(double '10000000.0' as varchar); -- '10000000.0'
+  SELECT cast(double '-0.001' as varchar); -- '-0.001'
+  SELECT cast(double '-0.00012' as varchar); -- '-0.00012'
+
+  SELECT cast(real '123456780.0' as varchar); -- '123456784.0'
+  SELECT cast(real '10000000.0' as varchar); -- '10000000.0'
+  SELECT cast(real '12345.0' as varchar); -- '12345.0'
+  SELECT cast(real '-0.00012' as varchar); -- '-0.00011999999696854502'
+
+
+From DATE
+^^^^^^^^^
+
+Casting DATE to VARCHAR returns an ISO-8601 formatted string: YYYY-MM-DD.
+
+::
+
+    SELECT cast(date('2024-03-14') as varchar); -- '2024-03-14'
+
+
+From TIMESTAMP
+^^^^^^^^^^^^^^
+
+By default, casting a timestamp to a string returns ISO 8601 format with space as separator
+between date and time, and the year part is padded with zeros to 4 characters.
+
+If legacy_cast configuration property is true, the result string uses character 'T'
+as separator between date and time and the year part is not padded.
+
+Valid examples if legacy_cast = false,
+
+::
+
+  SELECT cast(timestamp '1970-01-01 00:00:00' as varchar); -- '1970-01-01 00:00:00.000'
+  SELECT cast(timestamp '2000-01-01 12:21:56.129' as varchar); -- '2000-01-01 12:21:56.129'
+  SELECT cast(timestamp '384-01-01 08:00:00.000' as varchar); -- '0384-01-01 08:00:00.000'
+  SELECT cast(timestamp '10000-02-01 16:00:00.000' as varchar); -- '10000-02-01 16:00:00.000'
+  SELECT cast(timestamp '-10-02-01 10:00:00.000' as varchar); -- '-0010-02-01 10:00:00.000'
+
+Valid examples if legacy_cast = true,
+
+::
+
+  SELECT cast(timestamp '1970-01-01 00:00:00' as varchar); -- '1970-01-01T00:00:00.000'
+  SELECT cast(timestamp '2000-01-01 12:21:56.129' as varchar); -- '2000-01-01T12:21:56.129'
+  SELECT cast(timestamp '384-01-01 08:00:00.000' as varchar); -- '384-01-01T08:00:00.000'
+  SELECT cast(timestamp '-10-02-01 10:00:00.000' as varchar); -- '-10-02-01T10:00:00.000'
+
+From INTERVAL DAY TO SECOND
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Casting INTERVAL DAY TO SECOND to VARCHAR returns a string formatted as
+'[sign]D HH:MM:SS.ZZZ', where 'sign' is an optional '-' sign if interval is negative, D
+is the number of whole days in the interval, HH is then number of hours between 00 and
+24, MM is the number of minutes between 00 and 59, SS is the number of seconds between
+00 and 59, and zzz is the number of milliseconds between 000 and 999.
+
+::
+
+    SELECT cast(interval '1' day as varchar); -- '1 00:00:00.000'
+    SELECT cast(interval '123456' second as varchar); -- '1 10:17:36.000'
+    SELECT cast(now() - date('2024-03-01') as varchar); -- '35 09:15:54.092'
+    SELECT cast(date('2024-03-01') - now() as varchar); -- '-35 09:16:20.598'
+
+From IPADDRESS
+^^^^^^^^^^^^^^
+
+Casting from IPADDRESS to VARCHAR returns a string formatted as x.x.x.x for IPV4 formatted IPV6 addresses.
+For all other IPV6 addresses it will be formatted in compressed alternate form IPV6 defined in `RFC 4291#section-2.2 <https://datatracker.ietf.org/doc/html/rfc4291.html#section-2.2>`_
+
+IPV4:
+
+::
+
+  SELECT cast(ipaddress '1.2.3.4' as varchar); -- '1.2.3.4'
+
+IPV6:
+
+::
+
+  SELECT cast(ipaddress '2001:0db8:0000:0000:0000:ff00:0042:8329' as varchar); -- '2001:db8::ff00:42:8329'
+  SELECT cast(ipaddress '0:0:0:0:0:0:13.1.68.3' as varchar); -- '::13.1.68.3'
+
+IPV4 mapped IPV6:
+
+::
+
+  SELECT cast(ipaddress '::ffff:ffff:ffff' as varchar); -- '255.255.255.255'
+
+Cast to VARBINARY
+-----------------
+
+From IPADDRESS
+^^^^^^^^^^^^^^
+
+Returns the IPV6 address as a 16 byte varbinary string in network byte order.
+
+Internally, the type is a pure IPv6 address. Support for IPv4 is handled using the IPv4-mapped IPv6 address range `(RFC 4291#section-2.5.5.2) <https://datatracker.ietf.org/doc/html/rfc4291.html#section-2.5.5.2>`_.
+When creating an IPADDRESS, IPv4 addresses will be mapped into that range.
+
+IPV6:
+
+::
+
+  SELECT cast(ipaddress '2001:0db8:0000:0000:0000:ff00:0042:8329' as varbinary); -- 0x20010db8000000000000ff0000428329
+
+IPV4:
+
+::
+
+  SELECT cast('1.2.3.4' as ipaddress); -- 0x00000000000000000000ffff01020304
+
+IPV4 mapped IPV6:
+
+::
+
+  SELECT cast('::ffff:ffff:ffff' as ipaddress); -- 0x00000000000000000000ffffffffffff
 
 Cast to TIMESTAMP
 -----------------
 
-From strings
+From VARCHAR
 ^^^^^^^^^^^^
 
 Casting from a string to timestamp is allowed if the string represents a
-timestamp in the format `YYYY-MM-DD` followed by an optional `hh:mm:ssZZ`.
-Casting from invalid input values throws.
+timestamp in the format `YYYY-MM-DD` followed by an optional `hh:mm:ss.MS`.
+Seconds and milliseconds are optional. Casting from invalid input values throws.
 
-Valid examples
+Valid examples:
 
 ::
 
   SELECT cast('1970-01-01' as timestamp); -- 1970-01-01 00:00:00
-  SELECT cast('1970-01-01 00:00:00' as timestamp); -- 1970-01-01 00:00:00
+  SELECT cast('1970-01-01 00:00:00.123' as timestamp); -- 1970-01-01 00:00:00.123
   SELECT cast('1970-01-01 02:01' as timestamp); -- 1970-01-01 02:01:00
   SELECT cast('1970-01-01 00:00:00-02:00' as timestamp); -- 1970-01-01 02:00:00
 
-Invalid example
+Invalid example:
 
 ::
 
   SELECT cast('2012-Oct-23' as timestamp); -- Invalid argument
 
-From date
+Optionally, strings may also contain timezone information at the end. Timezone
+information may be offsets in the format `+01:00` or `-02:00`, for example, or
+timezone names, like `UTC`, `Z`, `America/Los_Angeles` and others,
+`as defined here <https://github.com/facebookincubator/velox/blob/main/velox/type/tz/TimeZoneDatabase.cpp>`_.
+
+For example, these strings contain valid timezone information:
+
+::
+
+  SELECT cast('1970-01-01 00:00:00 +09:00' as timestamp);
+  SELECT cast('1970-01-01 00:00:00 UTC' as timestamp);
+  SELECT cast('1970-01-01 00:00:00 America/Sao_Paulo' as timestamp);
+
+If timezone information is specified in the string, the returned timestamp
+is adjusted to the corresponding timezone. Otherwise, the timestamp is
+assumed to be in the client session timezone, and adjusted accordingly
+based on the value of `adjust_timestamp_to_session_timezone`, as described below.
+
+The space between the hour and timezone definition is optional.
+
+::
+
+  SELECT cast('1970-01-01 00:00 Z' as timestamp);
+  SELECT cast('1970-01-01 00:00Z' as timestamp);
+
+Are both valid.
+
+From DATE
 ^^^^^^^^^
 
 Casting from date to timestamp is allowed.
@@ -530,26 +788,26 @@ From TIMESTAMP WITH TIME ZONE
 The results depend on whether configuration property `adjust_timestamp_to_session_timezone` is set or not.
 
 If set to true, input timezone is ignored and timestamp is returned as is. For example,
-"1970-01-01 00:00:00.000 America/Los_Angeles" becomes "1970-01-01 00:00:00.000".
+"1970-01-01 00:00:00.000 America/Los_Angeles" becomes "1970-01-01 08:00:00.000".
 
 Otherwise, timestamp is shifted by the offset of the timezone. For example,
-"1970-01-01 00:00:00.000 America/Los_Angeles" becomes "1969-12-31 16:00:00.000".
+"1970-01-01 00:00:00.000 America/Los_Angeles" becomes "1970-01-01 00:00:00.000".
 
 Valid examples
 
 ::
 
   -- `adjust_timestamp_to_session_timezone` is true
-  SELECT cast(timestamp '1970-01-01 00:00:00 America/Los_Angeles' as timestamp); -- 1970-01-01 00:00:00.000
-  SELECT cast(timestamp '2012-03-09 10:00:00 Asia/Chongqing' as timestamp); -- 2012-03-09 10:00:00.000
-  SELECT cast(from_unixtime(0, '+06:00') as timestamp); -- 1970-01-01 00:00:00.000
-  SELECT cast(from_unixtime(0, '-02:00') as timestamp); -- 1970-01-01 00:00:00.000
+  SELECT to_unixtime(cast(timestamp '1970-01-01 00:00:00 America/Los_Angeles' as timestamp)); -- 28800.0 (1970-01-01 08:00:00.000)
+  SELECT to_unixtime(cast(timestamp '2012-03-09 10:00:00 Asia/Chongqing' as timestamp)); -- 1.3312584E9 (2012-03-09 02:00:00.000)
+  SELECT to_unixtime(cast(from_unixtime(0, '+06:00') as timestamp)); -- 0.0 (1970-01-01 00:00:00.000)
+  SELECT to_unixtime(cast(from_unixtime(0, '-02:00') as timestamp)); -- 0.0 (1970-01-01 00:00:00.000)
 
   -- `adjust_timestamp_to_session_timezone` is false
-  SELECT cast(timestamp '1970-01-01 00:00:00 America/Los_Angeles' as timestamp); -- 1969-12-31 16:00:00.000
-  SELECT cast(timestamp '2012-03-09 10:00:00 Asia/Chongqing' as timestamp); -- 2012-03-09 18:00:00.000
-  SELECT cast(from_unixtime(0, '+06:00') as timestamp); -- 1970-01-01 06:00:00.000
-  SELECT cast(from_unixtime(0, '-02:00') as timestamp); -- 1969-12-31 22:00:00.000
+  SELECT to_unixtime(cast(timestamp '1970-01-01 00:00:00 America/Los_Angeles' as timestamp)); -- 0.0 (1970-01-01 00:00:00.000)
+  SELECT to_unixtime(cast(timestamp '2012-03-09 10:00:00 Asia/Chongqing' as timestamp)); -- 1.3312872E9 (2012-03-09 10:00:00.000)
+  SELECT to_unixtime(cast(from_unixtime(0, '+06:00') as timestamp)); -- 21600.0 (1970-01-01 06:00:00.000)
+  SELECT to_unixtime(cast(from_unixtime(0, '-02:00') as timestamp)); -- -7200.0 (1969-12-31 22:00:00.000)
 
 Cast to TIMESTAMP WITH TIME ZONE
 --------------------------------
@@ -580,43 +838,37 @@ Valid examples
   SELECT cast(timestamp '2012-03-09 10:00:00' as timestamp with time zone); -- 2012-03-09 10:00:00.000 America/Los_Angeles
   SELECT cast(from_unixtime(0) as timestamp with time zone); -- 1970-01-01 00:00:00.000 America/Los_Angeles
 
-Cast to Date
-------------
+From DATE
+^^^^^^^^^
 
-From strings
-^^^^^^^^^^^^
+The results depend on `session_timestamp`.
 
-By default, only ISO 8601 strings are supported: `[+-]YYYY-MM-DD`.
+Valid examples
 
-If cast_string_to_date_is_iso_8601 is set to false, all Spark supported patterns are allowed.
-See the documentation for cast_string_to_date_is_iso_8601 in :ref:`Expression Evaluation Configuration<expression-evaluation-conf>`
-for the full list of supported patterns.
+::
 
-Casting from invalid input values throws.
+    -- session_timezone = America/Los_Angeles
+    SELECT cast(date '2024-06-01' as timestamp with time zone); -- 2024-06-01 00:00:00.000 America/Los_Angeles
 
-Valid examples
+    -- session_timezone = Asia/Shanghai
+    SELECT cast(date '2024-06-01' as timestamp with time zone); -- 2024-06-01 00:00:00.000 Asia/Shanghai
 
-**cast_string_to_date_is_iso_8601=true**
+Cast to Date
+------------
 
-::
+From VARCHAR
+^^^^^^^^^^^^
 
-  SELECT cast('1970-01-01' as date); -- 1970-01-01
+Only ISO 8601 strings are supported: `[+-]YYYY-MM-DD`. Casting from invalid input values throws.
 
-**cast_string_to_date_is_iso_8601=false**
+Valid examples
 
 ::
 
-  SELECT cast('1970' as date); -- 1970-01-01
-  SELECT cast('1970-01' as date); -- 1970-01-01
   SELECT cast('1970-01-01' as date); -- 1970-01-01
-  SELECT cast('1970-01-01T123' as date); -- 1970-01-01
-  SELECT cast('1970-01-01 ' as date); -- 1970-01-01
-  SELECT cast('1970-01-01 (BC)' as date); -- 1970-01-01
 
 Invalid examples
 
-**cast_string_to_date_is_iso_8601=true**
-
 ::
 
   SELECT cast('2012' as date); -- Invalid argument
@@ -628,14 +880,6 @@ Invalid examples
   SELECT cast('2012.10.23' as date); -- Invalid argument
   SELECT cast('2012-10-23 ' as date); -- Invalid argument
 
-**cast_string_to_date_is_iso_8601=false**
-
-::
-
-  SELECT cast('2012-Oct-23' as date); -- Invalid argument
-  SELECT cast('2012/10/23' as date); -- Invalid argument
-  SELECT cast('2012.10.23' as date); -- Invalid argument
-
 From TIMESTAMP
 ^^^^^^^^^^^^^^
 
@@ -649,13 +893,40 @@ Valid examples
   SELECT cast(timestamp '1970-01-01 00:00:00' as date); -- 1970-01-01
   SELECT cast(timestamp '1970-01-01 23:59:59' as date); -- 1970-01-01
 
+From TIMESTAMP WITH TIME ZONE
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Casting from TIMESTAMP WITH TIME ZONE to DATE is allowed. If present,
+the part of `hh:mm:ss` in the input is ignored.
+
+Session time zone does not affect the result.
+
+Valid examples
+
+::
+
+  SELECT CAST(timestamp '2024-06-01 01:38:00 America/New_York' as DATE); -- 2024-06-01
+
 Cast to Decimal
 ---------------
 
+From boolean type
+^^^^^^^^^^^^^^^^^
+
+Casting a boolean number to decimal of given precision and scale is allowed.
+True value is converted to 1 and false to 0.
+
+Valid examples
+
+::
+
+  SELECT cast(true as decimal(4, 2)); -- decimal '1.00'
+  SELECT cast(false as decimal(8, 2)); -- decimal '0'
+
 From integral types
 ^^^^^^^^^^^^^^^^^^^
 
-Casting an integral numberto a decimal of given precision and scale is allowed
+Casting an integral number to a decimal of given precision and scale is allowed
 if the input value can be represented by the precision and scale. Casting from
 invalid input values throws.
 
@@ -674,6 +945,33 @@ Invalid examples
   SELECT cast(123 as decimal(6, 4)); -- Out of range
   SELECT cast(123 as decimal(4, 2)); -- Out of range
 
+From floating-point types
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Casting a floating-point number to a decimal of given precision and scale is allowed
+if the input value can be represented by the precision and scale. When the given
+scale is less than the number of decimal places, the floating-point value is rounded.
+The conversion precision is up to 15 for double and 6 for real according to the
+significant decimal digits precision they provide. Casting from NaN or infinite value
+throws.
+
+Valid example
+
+::
+
+  SELECT cast(0.12 as decimal(4, 4)); -- decimal '0.1200'
+  SELECT cast(0.12 as decimal(4, 1)); -- decimal '0.1'
+  SELECT cast(0.19 as decimal(4, 1)); -- decimal '0.2'
+  SELECT cast(0.123456789123123 as decimal(38, 18)); -- decimal '0.123456789123123000'
+  SELECT cast(real '0.123456' as decimal(38, 18)); -- decimal '0.123456000000000000'
+
+Invalid example
+
+::
+
+  SELECT cast(123.12 as decimal(6, 4)); -- Out of range
+  SELECT cast(99999.99 as decimal(6, 2)); -- Out of range
+
 From decimal
 ^^^^^^^^^^^^
 
@@ -694,3 +992,149 @@ Invalid example
 
   SELECT cast(decimal '-1000.000' as decimal(6, 4)); -- Out of range
   SELECT cast(decimal '123456789' as decimal(9, 1)); -- Out of range
+
+From varchar
+^^^^^^^^^^^^
+
+Casting varchar to a decimal of given precision and scale is allowed
+if the input value can be represented by the precision and scale. When casting from
+a larger scale to a smaller one, the fraction part is rounded. Casting from invalid input value throws.
+
+Valid example
+
+::
+
+  SELECT cast('9999999999.99' as decimal(12, 2)); -- decimal '9999999999.99'
+  SELECT cast('1.556' as decimal(12, 2)); -- decimal '1.56'
+  SELECT cast('1.554' as decimal(12, 2)); -- decimal '1.55'
+  SELECT cast('-1.554' as decimal(12, 2)); -- decimal '-1.55'
+  SELECT cast('+09' as decimal(12, 2)); -- decimal '9.00'
+  SELECT cast('9.' as decimal(12, 2)); -- decimal '9.00'
+  SELECT cast('.9' as decimal(12, 2)); -- decimal '0.90'
+  SELECT cast('3E+2' as decimal(12, 2)); -- decimal '300.00'
+  SELECT cast('3E+00002' as decimal(12, 2)); -- decimal '300.00'
+  SELECT cast('3e+2' as decimal(12, 2)); -- decimal '300.00'
+  SELECT cast('31.423e+2' as decimal(12, 2)); -- decimal '3142.30'
+  SELECT cast('1.2e-2' as decimal(12, 2)); -- decimal '0.01'
+  SELECT cast('1.2e-5' as decimal(12, 2)); -- decimal '0.00'
+  SELECT cast('0000.123' as decimal(12, 2)); -- decimal '0.12'
+  SELECT cast('.123000000' as decimal(12, 2)); -- decimal '0.12'
+
+Invalid example
+
+::
+
+  SELECT cast('1.23e67' as decimal(38, 0)); -- Value too large
+  SELECT cast('0.0446a' as decimal(9, 1)); -- Value is not a number
+  SELECT cast('' as decimal(9, 1)); -- Value is not a number
+  SELECT cast('23e-5d' as decimal(9, 1)); -- Value is not a number
+  SELECT cast('1.23 ' as decimal(38, 0)); -- Value is not a number
+  SELECT cast(' -3E+2' as decimal(12, 2)); -- Value is not a number
+  SELECT cast('-3E+2.1' as decimal(12, 2)); -- Value is not a number
+  SELECT cast('3E+' as decimal(12, 2)); -- Value is not a number
+
+Cast to IPADDRESS
+-----------------
+
+From VARCHAR
+^^^^^^^^^^^^
+
+To cast a varchar to IPAddress input string must be in the form of either
+IPV4 or IPV6.
+
+For IPV4 it must be in the form of:
+x.x.x.x where each x is an integer value between 0-255.
+
+For IPV6 it must follow any of the forms defined in `RFC 4291#section-2.2 <https://datatracker.ietf.org/doc/html/rfc4291.html#section-2.2>`_.
+
+Full form:
+
+::
+
+   2001:0DB8:0000:0000:0008:0800:200C:417A
+   2001:DB8:0:0:8:800:200C:417A
+
+Compressed form:
+::
+  2001:DB8::8:800:200C:417A
+
+Alternate form:
+::
+  0:0:0:0:0:0:13.1.68.3
+  ::13.1.68.3
+
+Internally, the type is a pure IPv6 address. Support for IPv4 is handled using the IPv4-mapped IPv6 address range `(RFC 4291#section-2.5.5.2) <https://datatracker.ietf.org/doc/html/rfc4291.html#section-2.5.5.2>`_.
+When creating an IPADDRESS, IPv4 addresses will be mapped into that range.
+
+When formatting an IPADDRESS, any address within the mapped range will be formatted as an IPv4 address.
+Other addresses will be formatted as IPv6 using the canonical format defined in `RFC 5952 <https://datatracker.ietf.org/doc/html/rfc5952.html>`_.
+
+Valid examples:
+
+::
+
+  SELECT cast('2001:0db8:0000:0000:0000:ff00:0042:8329' as ipaddress); -- ipaddress '2001:db8::ff00:42:8329'
+  SELECT cast('1.2.3.4' as ipaddress); -- ipaddress '1.2.3.4'
+  SELECT cast('::ffff:ffff:ffff' as ipaddress); -- ipaddress '255.255.255.255'
+
+Invalid examples:
+
+::
+
+  SELECT cast('2001:db8::1::1' as ipaddress); -- Invalid IP address '2001:db8::1::1'
+  SELECT cast('789.1.1.1' as ipaddress); -- Invalid IP address '789.1.1.1'
+
+From VARBINARY
+^^^^^^^^^^^^^^
+
+To cast a varbinary to IPAddress it must be either IPV4(4 Bytes)
+or IPV6(16 Bytes) in network byte order.
+
+IPV4:
+
+::
+
+[01, 02, 03, 04] -> 1.2.3.4
+
+IPV6:
+
+::
+
+[0x20, 0x01, 0x0d, 0xb8 0x00, 0x00, 0x00, 0x00 0x00 0x00, 0xff, 0x00, 0x00, 0x42, 0x83, 0x29] -> 2001:db8::ff00:42:8329
+
+Internally, the type is a pure IPv6 address. Support for IPv4 is handled using the IPv4-mapped IPv6 address range `(RFC 4291#section-2.5.5.2) <https://datatracker.ietf.org/doc/html/rfc4291.html#section-2.5.5.2>`_.
+When creating an IPADDRESS, IPv4 addresses will be mapped into that range.
+
+When formatting an IPADDRESS, any address within the mapped range will be formatted as an IPv4 address.
+Other addresses will be formatted as IPv6 using the canonical format defined in `RFC 5952 <https://datatracker.ietf.org/doc/html/rfc5952.html>`_.
+
+IPV6 mapped IPV4 address:
+
+::
+
+[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x02, 0x03, 0x04] -> 1.2.3.4
+
+Valid examples:
+
+::
+
+  SELECT cast(from_hex('20010db8000000000000ff0000428329') as ipaddress); -- ipaddress '2001:db8::ff00:42:8329'
+  SELECT cast(from_hex('01020304') as ipaddress); -- ipaddress '1.2.3.4'
+  SELECT cast(from_hex('00000000000000000000ffff01020304') as ipaddress); -- ipaddress '1.2.3.4'
+
+Invalid examples:
+
+::
+
+  SELECT cast(from_hex('f000001100') as ipaddress); -- Invalid IP address binary length: 5
+
+Miscellaneous
+-------------
+
+.. function:: typeof(x) -> varchar
+
+    Returns the name of the type of x::
+
+        SELECT typeof(123); -- integer
+        SELECT typeof(1.5); -- double
+        SELECT typeof(array[1,2,3]); -- array(integer)
diff --git a/velox/docs/functions/presto/coverage.rst b/velox/docs/functions/presto/coverage.rst
index 91bb1c791a075..127297b7e197e 100644
--- a/velox/docs/functions/presto/coverage.rst
+++ b/velox/docs/functions/presto/coverage.rst
@@ -29,6 +29,7 @@ Here is a list of all scalar and aggregate Presto functions with functions that
     table.coverage tr:nth-child(3) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(3) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(3) td:nth-child(9) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(4) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(4) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(4) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(4) td:nth-child(4) {background-color: #6BA81E;}
@@ -38,6 +39,7 @@ Here is a list of all scalar and aggregate Presto functions with functions that
     table.coverage tr:nth-child(5) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(5) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(5) td:nth-child(9) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(6) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(6) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(6) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(6) td:nth-child(9) {background-color: #6BA81E;}
@@ -47,6 +49,7 @@ Here is a list of all scalar and aggregate Presto functions with functions that
     table.coverage tr:nth-child(7) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(7) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(8) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(1) {background-color: #6BA81E;}
@@ -69,107 +72,119 @@ Here is a list of all scalar and aggregate Presto functions with functions that
     table.coverage tr:nth-child(12) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(12) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(12) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(12) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(12) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(13) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(14) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(14) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(14) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(14) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(15) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(15) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(15) td:nth-child(4) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(16) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(16) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(16) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(16) td:nth-child(4) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(18) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(17) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(17) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(17) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(17) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(18) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(18) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(18) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(19) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(19) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(19) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(19) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(19) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(19) td:nth-child(7) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(20) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(20) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(20) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(20) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(20) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(20) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(21) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(21) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(21) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(21) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(21) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(22) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(22) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(22) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(22) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(22) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(23) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(23) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(23) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(23) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(23) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(23) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(24) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(24) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(24) td:nth-child(4) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(24) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(25) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(25) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(25) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(25) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(25) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(26) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(26) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(26) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(26) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(26) td:nth-child(5) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(27) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(27) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(27) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(27) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(27) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(27) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(28) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(28) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(28) td:nth-child(4) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(28) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(28) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(29) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(29) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(29) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(29) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(30) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(30) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(30) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(30) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(30) td:nth-child(7) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(31) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(31) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(31) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(31) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(31) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(32) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(32) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(32) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(32) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(32) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(32) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(33) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(33) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(34) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(33) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(34) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(34) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(34) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(34) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(35) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(35) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(35) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(35) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(36) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(36) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(36) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(36) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(37) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(37) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(38) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(38) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(38) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(38) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(38) td:nth-child(7) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(39) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(39) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(39) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(40) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(40) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(40) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(40) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(41) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(41) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(41) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(41) td:nth-child(7) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(42) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(42) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(42) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(42) td:nth-child(7) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(43) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(43) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(43) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(43) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(43) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(44) td:nth-child(1) {background-color: #6BA81E;}
@@ -177,91 +192,118 @@ Here is a list of all scalar and aggregate Presto functions with functions that
     table.coverage tr:nth-child(44) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(44) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(45) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(45) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(46) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(46) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(46) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(46) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(46) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(47) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(47) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(47) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(48) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(48) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(48) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(49) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(49) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(49) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(50) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(51) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(51) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(51) td:nth-child(5) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(51) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(52) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(52) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(52) td:nth-child(5) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(52) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(53) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(53) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(53) td:nth-child(5) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(53) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(54) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(54) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(54) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(54) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(55) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(55) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(55) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(55) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(56) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(56) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(56) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(56) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(56) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(57) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(57) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(58) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(58) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(58) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(58) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(58) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(59) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(59) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(59) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(59) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(59) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(60) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(61) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(61) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(61) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(61) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(61) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(62) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(62) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(62) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(62) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(62) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(63) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(63) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(64) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(64) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(64) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(64) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(64) td:nth-child(7) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(65) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(65) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(65) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(65) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(65) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(66) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(66) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(66) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(67) td:nth-child(1) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(67) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(67) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(68) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(68) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(68) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(68) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(69) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(69) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(69) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(70) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(70) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(70) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(70) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(71) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(71) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(71) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(71) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(72) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(72) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(72) td:nth-child(5) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(73) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(73) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(73) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(73) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(74) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(75) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(74) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(74) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(75) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(76) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(75) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(75) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(76) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(76) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(78) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(78) td:nth-child(3) {background-color: #6BA81E;}
     </style>
 
 .. table::
@@ -271,81 +313,82 @@ Here is a list of all scalar and aggregate Presto functions with functions that
     ========================================  ========================================  ========================================  ========================================  ========================================  ==  ========================================  ==  ========================================
     Scalar Functions                                                                                                                                                                                                      Aggregate Functions                           Window Functions
     ================================================================================================================================================================================================================  ==  ========================================  ==  ========================================
-    :func:`abs`                               :func:`date_format`                       :func:`is_finite`                         :func:`regexp_extract`                    st_point                                      :func:`approx_distinct`                       :func:`cume_dist`
-    :func:`acos`                              :func:`date_parse`                        :func:`is_infinite`                       :func:`regexp_extract_all`                st_pointn                                     :func:`approx_most_frequent`                  :func:`dense_rank`
-    :func:`all_match`                         :func:`date_trunc`                        :func:`is_json_scalar`                    :func:`regexp_like`                       st_points                                     :func:`approx_percentile`                     :func:`first_value`
-    any_keys_match                            :func:`day`                               :func:`is_nan`                            :func:`regexp_replace`                    st_polygon                                    :func:`approx_set`                            :func:`lag`
-    :func:`any_match`                         :func:`day_of_month`                      is_subnet_of                              regexp_split                              st_relate                                     :func:`arbitrary`                             :func:`last_value`
-    any_values_match                          :func:`day_of_week`                       jaccard_index                             regress                                   st_startpoint                                 :func:`array_agg`                             :func:`lead`
-    :func:`array_average`                     :func:`day_of_year`                       :func:`json_array_contains`               reidentification_potential                st_symdifference                              :func:`avg`                                   :func:`nth_value`
-    array_cum_sum                             :func:`degrees`                           json_array_get                            remove_nulls                              st_touches                                    :func:`bitwise_and_agg`                       :func:`ntile`
-    :func:`array_distinct`                    :func:`dow`                               :func:`json_array_length`                 render                                    st_union                                      :func:`bitwise_or_agg`                        :func:`percent_rank`
-    :func:`array_duplicates`                  :func:`doy`                               :func:`json_extract`                      :func:`repeat`                            st_within                                     :func:`bool_and`                              :func:`rank`
-    :func:`array_except`                      :func:`e`                                 :func:`json_extract_scalar`               :func:`replace`                           st_x                                          :func:`bool_or`                               :func:`row_number`
-    :func:`array_frequency`                   :func:`element_at`                        :func:`json_format`                       :func:`reverse`                           st_xmax                                       :func:`checksum`
-    :func:`array_has_duplicates`              :func:`empty_approx_set`                  :func:`json_parse`                        rgb                                       st_xmin                                       classification_fall_out
-    :func:`array_intersect`                   ends_with                                 :func:`json_size`                         :func:`round`                             st_y                                          classification_miss_rate
-    :func:`array_join`                        enum_key                                  key_sampling_percent                      :func:`rpad`                              st_ymax                                       classification_precision
-    :func:`array_max`                         :func:`exp`                               laplace_cdf                               :func:`rtrim`                             st_ymin                                       classification_recall
-    array_max_by                              expand_envelope                           last_day_of_month                         scale_qdigest                             starts_with                                   classification_thresholds
-    :func:`array_min`                         f_cdf                                     :func:`least`                             :func:`second`                            :func:`strpos`                                convex_hull_agg
-    array_min_by                              features                                  :func:`length`                            secure_random                             :func:`strrpos`                               :func:`corr`
-    :func:`array_normalize`                   :func:`filter`                            levenshtein_distance                      :func:`sequence`                          :func:`substr`                                :func:`count`
-    :func:`array_position`                    :func:`filter`                            line_interpolate_point                    :func:`sha1`                              :func:`tan`                                   :func:`count_if`
-    array_remove                              find_first                                line_locate_point                         :func:`sha256`                            :func:`tanh`                                  :func:`covar_pop`
-    :func:`array_sort`                        find_first_index                          :func:`ln`                                :func:`sha512`                            tdigest_agg                                   :func:`covar_samp`
-    :func:`array_sort_desc`                   :func:`flatten`                           localtime                                 :func:`shuffle`                           :func:`timezone_hour`                         differential_entropy
-    :func:`array_sum`                         flatten_geometry_collections              localtimestamp                            :func:`sign`                              :func:`timezone_minute`                       :func:`entropy`
-    :func:`array_union`                       :func:`floor`                             :func:`log10`                             simplify_geometry                         :func:`to_base`                               evaluate_classifier_predictions
-    :func:`arrays_overlap`                    fnv1_32                                   :func:`log2`                              :func:`sin`                               :func:`to_base64`                             :func:`every`
-    :func:`asin`                              fnv1_64                                   :func:`lower`                             :func:`slice`                             :func:`to_base64url`                          geometric_mean
-    :func:`atan`                              fnv1a_32                                  :func:`lpad`                              spatial_partitions                        :func:`to_big_endian_32`                      geometry_union_agg
-    :func:`atan2`                             fnv1a_64                                  :func:`ltrim`                             :func:`split`                             :func:`to_big_endian_64`                      :func:`histogram`
-    bar                                       :func:`format_datetime`                   :func:`map`                               :func:`split_part`                        to_geometry                                   khyperloglog_agg
-    :func:`beta_cdf`                          :func:`from_base`                         :func:`map_concat`                        split_to_map                              :func:`to_hex`                                :func:`kurtosis`
-    bing_tile                                 from_base32                               :func:`map_entries`                       split_to_multimap                         to_ieee754_32                                 learn_classifier
-    bing_tile_at                              :func:`from_base64`                       :func:`map_filter`                        :func:`spooky_hash_v2_32`                 :func:`to_ieee754_64`                         learn_libsvm_classifier
-    bing_tile_children                        :func:`from_base64url`                    :func:`map_from_entries`                  :func:`spooky_hash_v2_64`                 to_iso8601                                    learn_libsvm_regressor
-    bing_tile_coordinates                     :func:`from_big_endian_32`                :func:`map_keys`                          :func:`sqrt`                              to_milliseconds                               learn_regressor
-    bing_tile_parent                          :func:`from_big_endian_64`                map_normalize                             st_area                                   to_spherical_geography                        make_set_digest
-    bing_tile_polygon                         :func:`from_hex`                          map_remove_null_values                    st_asbinary                               :func:`to_unixtime`                           :func:`map_agg`
-    bing_tile_quadkey                         from_ieee754_32                           map_subset                                st_astext                                 :func:`to_utf8`                               :func:`map_union`
-    bing_tile_zoom_level                      from_ieee754_64                           map_top_n                                 st_boundary                               :func:`transform`                             :func:`map_union_sum`
-    bing_tiles_around                         from_iso8601_date                         map_top_n_keys                            st_buffer                                 :func:`transform_keys`                        :func:`max`
-    :func:`binomial_cdf`                      from_iso8601_timestamp                    map_top_n_values                          st_centroid                               :func:`transform_values`                      :func:`max_by`
-    :func:`bit_count`                         :func:`from_unixtime`                     :func:`map_values`                        st_contains                               :func:`trim`                                  :func:`merge`
-    :func:`bitwise_and`                       :func:`from_utf8`                         :func:`map_zip_with`                      st_convexhull                             :func:`trim_array`                            merge_set_digest
-    :func:`bitwise_arithmetic_shift_right`    gamma_cdf                                 :func:`md5`                               st_coorddim                               :func:`truncate`                              :func:`min`
-    :func:`bitwise_left_shift`                geometry_as_geojson                       merge_hll                                 st_crosses                                typeof                                        :func:`min_by`
-    :func:`bitwise_logical_shift_right`       geometry_from_geojson                     merge_khll                                st_difference                             uniqueness_distribution                       multimap_agg
-    :func:`bitwise_not`                       geometry_invalid_reason                   :func:`millisecond`                       st_dimension                              :func:`upper`                                 numeric_histogram
-    :func:`bitwise_or`                        geometry_nearest_points                   :func:`minute`                            st_disjoint                               :func:`url_decode`                            qdigest_agg
-    :func:`bitwise_right_shift`               geometry_to_bing_tiles                    :func:`mod`                               st_distance                               :func:`url_encode`                            reduce_agg
-    :func:`bitwise_right_shift_arithmetic`    geometry_to_dissolved_bing_tiles          :func:`month`                             st_endpoint                               :func:`url_extract_fragment`                  :func:`regr_intercept`
-    :func:`bitwise_shift_left`                geometry_union                            multimap_from_entries                     st_envelope                               :func:`url_extract_host`                      :func:`regr_slope`
-    :func:`bitwise_xor`                       great_circle_distance                     murmur3_x64_128                           st_envelopeaspts                          :func:`url_extract_parameter`                 :func:`set_agg`
-    :func:`cardinality`                       :func:`greatest`                          myanmar_font_encoding                     st_equals                                 :func:`url_extract_path`                      :func:`set_union`
-    :func:`cauchy_cdf`                        hamming_distance                          myanmar_normalize_unicode                 st_exteriorring                           :func:`url_extract_port`                      :func:`skewness`
-    :func:`cbrt`                              hash_counts                               :func:`nan`                               st_geometries                             :func:`url_extract_protocol`                  spatial_partitioning
-    :func:`ceil`                              :func:`hmac_md5`                          ngrams                                    st_geometryfromtext                       :func:`url_extract_query`                     :func:`stddev`
-    :func:`ceiling`                           :func:`hmac_sha1`                         no_keys_match                             st_geometryn                              uuid                                          :func:`stddev_pop`
-    :func:`chi_squared_cdf`                   :func:`hmac_sha256`                       no_values_match                           st_geometrytype                           value_at_quantile                             :func:`stddev_samp`
-    :func:`chr`                               :func:`hmac_sha512`                       :func:`none_match`                        st_geomfrombinary                         values_at_quantiles                           :func:`sum`
-    classify                                  :func:`hour`                              :func:`normal_cdf`                        st_interiorringn                          :func:`week`                                  tdigest_agg
-    :func:`codepoint`                         :func:`infinity`                          normalize                                 st_interiorrings                          :func:`week_of_year`                          :func:`var_pop`
-    color                                     intersection_cardinality                  now                                       st_intersection                           weibull_cdf                                   :func:`var_samp`
-    :func:`combinations`                      :func:`inverse_beta_cdf`                  :func:`parse_datetime`                    st_intersects                             :func:`width_bucket`                          :func:`variance`
-    :func:`concat`                            inverse_binomial_cdf                      parse_duration                            st_isclosed                               wilson_interval_lower
-    :func:`contains`                          inverse_cauchy_cdf                        parse_presto_data_size                    st_isempty                                wilson_interval_upper
-    :func:`cos`                               inverse_chi_squared_cdf                   :func:`pi`                                st_isring                                 word_stem
-    :func:`cosh`                              inverse_f_cdf                             pinot_binary_decimal_to_double            st_issimple                               :func:`xxhash64`
-    cosine_similarity                         inverse_gamma_cdf                         poisson_cdf                               st_isvalid                                :func:`year`
-    :func:`crc32`                             inverse_laplace_cdf                       :func:`pow`                               st_length                                 :func:`year_of_week`
-    :func:`current_date`                      inverse_normal_cdf                        :func:`power`                             st_linefromtext                           :func:`yow`
-    current_time                              inverse_poisson_cdf                       quantile_at_value                         st_linestring                             :func:`zip`
-    current_timestamp                         inverse_weibull_cdf                       :func:`quarter`                           st_multipoint                             :func:`zip_with`
-    current_timezone                          ip_prefix                                 :func:`radians`                           st_numgeometries
-    :func:`date`                              ip_subnet_max                             :func:`rand`                              st_numinteriorring
-    :func:`date_add`                          ip_subnet_min                             :func:`random`                            st_numpoints
-    :func:`date_diff`                         ip_subnet_range                           :func:`reduce`                            st_overlaps
+    :func:`abs`                               :func:`date_diff`                         :func:`is_finite`                         :func:`regexp_extract`                    st_overlaps                                   :func:`approx_distinct`                       :func:`cume_dist`
+    :func:`acos`                              :func:`date_format`                       :func:`is_infinite`                       :func:`regexp_extract_all`                st_point                                      :func:`approx_most_frequent`                  :func:`dense_rank`
+    :func:`all_match`                         :func:`date_parse`                        :func:`is_json_scalar`                    :func:`regexp_like`                       st_pointn                                     :func:`approx_percentile`                     :func:`first_value`
+    :func:`any_keys_match`                    :func:`date_trunc`                        :func:`is_nan`                            :func:`regexp_replace`                    st_points                                     :func:`approx_set`                            :func:`lag`
+    :func:`any_match`                         :func:`day`                               is_subnet_of                              regexp_split                              st_polygon                                    :func:`arbitrary`                             :func:`last_value`
+    :func:`any_values_match`                  :func:`day_of_month`                      jaccard_index                             regress                                   st_relate                                     :func:`array_agg`                             :func:`lead`
+    :func:`array_average`                     :func:`day_of_week`                       :func:`json_array_contains`               reidentification_potential                st_startpoint                                 :func:`avg`                                   :func:`nth_value`
+    array_cum_sum                             :func:`day_of_year`                       json_array_get                            :func:`remove_nulls`                      st_symdifference                              :func:`bitwise_and_agg`                       :func:`ntile`
+    :func:`array_distinct`                    :func:`degrees`                           :func:`json_array_length`                 render                                    st_touches                                    :func:`bitwise_or_agg`                        :func:`percent_rank`
+    :func:`array_duplicates`                  :func:`dow`                               :func:`json_extract`                      :func:`repeat`                            st_union                                      :func:`bool_and`                              :func:`rank`
+    :func:`array_except`                      :func:`doy`                               :func:`json_extract_scalar`               :func:`replace`                           st_within                                     :func:`bool_or`                               :func:`row_number`
+    :func:`array_frequency`                   :func:`e`                                 :func:`json_format`                       replace_first                             st_x                                          :func:`checksum`
+    :func:`array_has_duplicates`              :func:`element_at`                        :func:`json_parse`                        :func:`reverse`                           st_xmax                                       classification_fall_out
+    :func:`array_intersect`                   :func:`empty_approx_set`                  :func:`json_size`                         rgb                                       st_xmin                                       classification_miss_rate
+    :func:`array_join`                        :func:`ends_with`                         key_sampling_percent                      :func:`round`                             st_y                                          classification_precision
+    array_least_frequent                      enum_key                                  :func:`laplace_cdf`                       :func:`rpad`                              st_ymax                                       classification_recall
+    :func:`array_max`                         :func:`exp`                               :func:`last_day_of_month`                 :func:`rtrim`                             st_ymin                                       classification_thresholds
+    array_max_by                              expand_envelope                           :func:`least`                             scale_qdigest                             :func:`starts_with`                           convex_hull_agg
+    :func:`array_min`                         :func:`f_cdf`                             :func:`length`                            :func:`second`                            :func:`strpos`                                :func:`corr`
+    array_min_by                              features                                  :func:`levenshtein_distance`              secure_rand                               :func:`strrpos`                               :func:`count`
+    :func:`array_normalize`                   :func:`filter`                            line_interpolate_point                    secure_random                             :func:`substr`                                :func:`count_if`
+    :func:`array_position`                    :func:`filter`                            line_locate_point                         :func:`sequence`                          :func:`tan`                                   :func:`covar_pop`
+    :func:`array_remove`                      :func:`find_first`                        :func:`ln`                                :func:`sha1`                              :func:`tanh`                                  :func:`covar_samp`
+    :func:`array_sort`                        :func:`find_first_index`                  localtime                                 :func:`sha256`                            tdigest_agg                                   differential_entropy
+    :func:`array_sort_desc`                   :func:`flatten`                           localtimestamp                            :func:`sha512`                            :func:`timezone_hour`                         :func:`entropy`
+    :func:`array_sum`                         flatten_geometry_collections              :func:`log10`                             :func:`shuffle`                           :func:`timezone_minute`                       evaluate_classifier_predictions
+    array_top_n                               :func:`floor`                             :func:`log2`                              :func:`sign`                              :func:`to_base`                               :func:`every`
+    :func:`array_union`                       fnv1_32                                   :func:`lower`                             simplify_geometry                         to_base32                                     :func:`geometric_mean`
+    :func:`arrays_overlap`                    fnv1_64                                   :func:`lpad`                              :func:`sin`                               :func:`to_base64`                             geometry_union_agg
+    :func:`asin`                              fnv1a_32                                  :func:`ltrim`                             :func:`slice`                             :func:`to_base64url`                          :func:`histogram`
+    :func:`atan`                              fnv1a_64                                  :func:`map`                               spatial_partitions                        :func:`to_big_endian_32`                      khyperloglog_agg
+    :func:`atan2`                             :func:`format_datetime`                   :func:`map_concat`                        :func:`split`                             :func:`to_big_endian_64`                      :func:`kurtosis`
+    bar                                       :func:`from_base`                         :func:`map_entries`                       :func:`split_part`                        to_geometry                                   learn_classifier
+    :func:`beta_cdf`                          from_base32                               :func:`map_filter`                        :func:`split_to_map`                      :func:`to_hex`                                learn_libsvm_classifier
+    bing_tile                                 :func:`from_base64`                       :func:`map_from_entries`                  split_to_multimap                         :func:`to_ieee754_32`                         learn_libsvm_regressor
+    bing_tile_at                              :func:`from_base64url`                    :func:`map_keys`                          :func:`spooky_hash_v2_32`                 :func:`to_ieee754_64`                         learn_regressor
+    bing_tile_children                        :func:`from_big_endian_32`                map_keys_by_top_n_values                  :func:`spooky_hash_v2_64`                 to_iso8601                                    make_set_digest
+    bing_tile_coordinates                     :func:`from_big_endian_64`                :func:`map_normalize`                     :func:`sqrt`                              to_milliseconds                               :func:`map_agg`
+    bing_tile_parent                          :func:`from_hex`                          map_remove_null_values                    st_area                                   to_spherical_geography                        :func:`map_union`
+    bing_tile_polygon                         :func:`from_ieee754_32`                   :func:`map_subset`                        st_asbinary                               :func:`to_unixtime`                           :func:`map_union_sum`
+    bing_tile_quadkey                         :func:`from_ieee754_64`                   :func:`map_top_n`                         st_astext                                 :func:`to_utf8`                               :func:`max`
+    bing_tile_zoom_level                      :func:`from_iso8601_date`                 map_top_n_keys                            st_boundary                               trail                                         :func:`max_by`
+    bing_tiles_around                         from_iso8601_timestamp                    map_top_n_values                          st_buffer                                 :func:`transform`                             :func:`merge`
+    :func:`binomial_cdf`                      :func:`from_unixtime`                     :func:`map_values`                        st_centroid                               :func:`transform_keys`                        merge_set_digest
+    :func:`bit_count`                         :func:`from_utf8`                         :func:`map_zip_with`                      st_contains                               :func:`transform_values`                      :func:`min`
+    :func:`bitwise_and`                       :func:`gamma_cdf`                         :func:`md5`                               st_convexhull                             :func:`trim`                                  :func:`min_by`
+    :func:`bitwise_arithmetic_shift_right`    geometry_as_geojson                       merge_hll                                 st_coorddim                               :func:`trim_array`                            :func:`multimap_agg`
+    :func:`bitwise_left_shift`                geometry_from_geojson                     merge_khll                                st_crosses                                :func:`truncate`                              noisy_avg_gaussian
+    :func:`bitwise_logical_shift_right`       geometry_invalid_reason                   :func:`millisecond`                       st_difference                             :func:`typeof`                                noisy_count_gaussian
+    :func:`bitwise_not`                       geometry_nearest_points                   :func:`minute`                            st_dimension                              uniqueness_distribution                       noisy_count_if_gaussian
+    :func:`bitwise_or`                        geometry_to_bing_tiles                    :func:`mod`                               st_disjoint                               :func:`upper`                                 noisy_sum_gaussian
+    :func:`bitwise_right_shift`               geometry_to_dissolved_bing_tiles          :func:`month`                             st_distance                               :func:`url_decode`                            numeric_histogram
+    :func:`bitwise_right_shift_arithmetic`    geometry_union                            :func:`multimap_from_entries`             st_endpoint                               :func:`url_encode`                            qdigest_agg
+    :func:`bitwise_shift_left`                great_circle_distance                     murmur3_x64_128                           st_envelope                               :func:`url_extract_fragment`                  :func:`reduce_agg`
+    :func:`bitwise_xor`                       :func:`greatest`                          myanmar_font_encoding                     st_envelopeaspts                          :func:`url_extract_host`                      :func:`regr_avgx`
+    :func:`cardinality`                       :func:`hamming_distance`                  myanmar_normalize_unicode                 st_equals                                 :func:`url_extract_parameter`                 :func:`regr_avgy`
+    :func:`cauchy_cdf`                        hash_counts                               :func:`nan`                               st_exteriorring                           :func:`url_extract_path`                      :func:`regr_count`
+    :func:`cbrt`                              :func:`hmac_md5`                          :func:`ngrams`                            st_geometries                             :func:`url_extract_port`                      :func:`regr_intercept`
+    :func:`ceil`                              :func:`hmac_sha1`                         :func:`no_keys_match`                     st_geometryfromtext                       :func:`url_extract_protocol`                  :func:`regr_r2`
+    :func:`ceiling`                           :func:`hmac_sha256`                       :func:`no_values_match`                   st_geometryn                              :func:`url_extract_query`                     :func:`regr_slope`
+    :func:`chi_squared_cdf`                   :func:`hmac_sha512`                       :func:`none_match`                        st_geometrytype                           uuid                                          :func:`regr_sxx`
+    :func:`chr`                               :func:`hour`                              :func:`normal_cdf`                        st_geomfrombinary                         value_at_quantile                             :func:`regr_sxy`
+    classify                                  :func:`infinity`                          normalize                                 st_interiorringn                          values_at_quantiles                           :func:`regr_syy`
+    :func:`codepoint`                         intersection_cardinality                  now                                       st_interiorrings                          :func:`week`                                  :func:`set_agg`
+    color                                     :func:`inverse_beta_cdf`                  :func:`parse_datetime`                    st_intersection                           :func:`week_of_year`                          :func:`set_union`
+    :func:`combinations`                      inverse_binomial_cdf                      parse_duration                            st_intersects                             :func:`weibull_cdf`                           :func:`skewness`
+    :func:`concat`                            inverse_cauchy_cdf                        parse_presto_data_size                    st_isclosed                               :func:`width_bucket`                          spatial_partitioning
+    :func:`contains`                          inverse_chi_squared_cdf                   :func:`pi`                                st_isempty                                :func:`wilson_interval_lower`                 :func:`stddev`
+    :func:`cos`                               inverse_f_cdf                             pinot_binary_decimal_to_double            st_isring                                 :func:`wilson_interval_upper`                 :func:`stddev_pop`
+    :func:`cosh`                              inverse_gamma_cdf                         :func:`poisson_cdf`                       st_issimple                               word_stem                                     :func:`stddev_samp`
+    :func:`cosine_similarity`                 inverse_laplace_cdf                       :func:`pow`                               st_isvalid                                :func:`xxhash64`                              :func:`sum`
+    :func:`crc32`                             inverse_normal_cdf                        :func:`power`                             st_length                                 :func:`year`                                  tdigest_agg
+    :func:`current_date`                      inverse_poisson_cdf                       quantile_at_value                         st_linefromtext                           :func:`year_of_week`                          :func:`var_pop`
+    current_time                              inverse_weibull_cdf                       :func:`quarter`                           st_linestring                             :func:`yow`                                   :func:`var_samp`
+    current_timestamp                         ip_prefix                                 :func:`radians`                           st_multipoint                             :func:`zip`                                   :func:`variance`
+    current_timezone                          ip_subnet_max                             :func:`rand`                              st_numgeometries                          :func:`zip_with`
+    :func:`date`                              ip_subnet_min                             :func:`random`                            st_numinteriorring
+    :func:`date_add`                          ip_subnet_range                           :func:`reduce`                            st_numpoints
     ========================================  ========================================  ========================================  ========================================  ========================================  ==  ========================================  ==  ========================================
diff --git a/velox/docs/functions/presto/datetime.rst b/velox/docs/functions/presto/datetime.rst
index 4d4e459875eb2..516da0d778a25 100644
--- a/velox/docs/functions/presto/datetime.rst
+++ b/velox/docs/functions/presto/datetime.rst
@@ -1,7 +1,89 @@
 =====================================
-Date and Time Functions
+Date and Time Functions and Operators
 =====================================
 
+Date and Time Operators
+-----------------------
+
+.. list-table::
+   :widths: 15 60 25
+   :header-rows: 1
+
+   * - Operator
+     - Example
+     - Result
+   * - ``+``
+     - ``interval '1' second + interval '1' hour``
+     - ``0 01:00:01.000``
+   * - ``+``
+     - ``timestamp '1970-01-01 00:00:00.000' + interval '1' second``
+     - ``1970-01-01 00:00:01.000``
+   * - ``-``
+     - ``interval '1' hour - interval '1' second``
+     - ``0 00:59:59.000``
+   * - ``-``
+     - ``timestamp '1970-01-01 00:00:00.000' - interval '1' second``
+     - ``1969-12-31 23:59:59.000``
+   * - ``*``
+     - ``interval '1' second * 2``
+     - ``0 00:00:02.000``
+   * - ``*``
+     - ``2 * interval '1' second``
+     - ``0 00:00:02.000``
+   * - ``*``
+     - ``interval '1' second * 0.001``
+     - ``0 00:00:00.001``
+   * - ``*``
+     - ``0.001 * interval '1' second``
+     - ``0 00:00:00.001``
+   * - ``/``
+     - ``interval '15' second / 1.5``
+     - ``0 00:00:10.000``
+
+.. function:: plus(x, y) -> [same as x]
+
+    Returns the sum of ``x`` and ``y``. Both ``x`` and ``y`` are intervals day
+    to second or one of them can be timestamp. For addition of two intervals day to
+    second, returns ``-106751991167 07:12:55.808`` when the addition overflows
+    in positive and returns ``106751991167 07:12:55.807`` when the addition
+    overflows in negative. When addition of a timestamp with an interval day to
+    second, overflowed results are wrapped around.
+
+.. function:: minus(x, y) -> [same as x]
+
+    Returns the result of subtracting ``y`` from ``x``. Both ``x`` and ``y``
+    are intervals day to second or ``x`` can be timestamp. For subtraction of
+    two intervals day to second, returns ``-106751991167 07:12:55.808`` when
+    the subtraction overflows in positive and returns ``106751991167 07:12:55.807``
+    when the subtraction overflows in negative. For subtraction of an interval
+    day to second from a timestamp, overflowed results are wrapped around.
+
+.. function:: multiply(interval day to second, x) -> interval day to second
+
+    Returns the result of multiplying ``interval day to second`` by ``x``.
+    ``x`` can be a bigint or double. Returns ``0`` when ``x`` is NaN. Returns
+    ``106751991167 07:12:55.807`` when ``x`` is infinity or when the
+    multiplication overflow in positive. Returns ``-106751991167 07:12:55.808``
+    when ``x`` is -infinity or when the multiplication overflow in negiative.
+
+.. function:: multiply(x, interval day to second) -> interval day to second
+
+    Returns the result of multiplying ``x`` by ``interval day to second``.
+    Same as ``multiply(interval day to second, x)``.
+
+.. function:: divide(interval day to second, x) -> interval day to second
+
+    Returns the result of ``interval day to second`` divided by ``x``. ``x`` is
+    a double. Returns ``0`` when ``x`` is NaN or is infinity. Returns
+    ``106751991167 07:12:55.807`` when ``x`` is ``0.0`` and
+    ``interval day to second`` is not ``0``, or when the division overflows in
+    positive. Returns ``-106751991167 07:12:55.808`` when ``x`` is ``-0.0`` and
+    ``interval day to second`` is not ``0``, or when the division overflows in
+    negiative.
+
+Date and Time Functions
+-----------------------
+
 .. function:: current_date() -> date
 
     Returns the current date.
@@ -10,6 +92,56 @@ Date and Time Functions
 
     This is an alias for ``CAST(x AS date)``.
 
+.. function:: from_iso8601_date(string) -> date
+
+    Parses the ISO 8601 formatted ``string`` into a ``date``.
+
+    Accepts formats described by the following syntax::
+
+       date = yyyy ['-' MM ['-' dd]]
+
+    Examples of valid input strings:
+
+    * '2012'
+    * '2012-4'
+    * '2012-04'
+    * '2012-4-7'
+    * '2012-04-07'
+    * '2012-04-07   '
+
+.. function:: from_iso8601_timestamp(string) -> timestamp with time zone
+
+    Parses the ISO 8601 formatted string into a timestamp with time zone.
+
+    Accepts formats described by the following syntax::
+
+        datetime          = time | date-opt-time
+        time              = 'T' time-element [offset]
+        date-opt-time     = date-element ['T' [time-element] [offset]]
+        date-element      = yyyy ['-' MM ['-' dd]]
+        time-element      = HH [minute-element] | [fraction]
+        minute-element    = ':' mm [second-element] | [fraction]
+        second-element    = ':' ss [fraction]
+        fraction          = ('.' | ',') digit+
+        offset            = 'Z' | (('+' | '-') HH [':' mm [':' ss [('.' | ',') SSS]]])
+
+    Examples of valid input strings:
+
+    * '2012'
+    * '2012-4'
+    * '2012-04'
+    * '2012-4-7'
+    * '2012-04-07'
+    * '2012-04-07   '
+    * '2012-04T01:02'
+    * 'T01:02:34'
+    * 'T01:02:34,123'
+    * '2012-04-07T01:02:34'
+    * '2012-04-07T01:02:34.123'
+    * '2012-04-07T01:02:34,123'
+    * '2012-04-07T01:02:34.123Z'
+    * '2012-04-07T01:02:34.123-05:00'
+
 .. function:: from_unixtime(unixtime) -> timestamp
 
     Returns the UNIX timestamp ``unixtime`` as a timestamp.
@@ -20,6 +152,27 @@ Date and Time Functions
     Returns the UNIX timestamp ``unixtime`` as a timestamp with time zone
     using ``string`` for the time zone.
 
+.. function:: from_unixtime(unixtime, hours, minutes) -> timestamp with time zone
+
+    Returns the UNIX timestamp ``unixtime`` as a timestamp with time zone
+    using ``hours`` and ``minutes`` for the time zone offset.
+    The offset must be in [-14:00, 14:00] range.
+
+.. function:: to_iso8601(x) -> varchar
+
+    Formats ``x`` as an ISO 8601 string. Supported types for ``x`` are:
+    DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE.
+
+    Example results::
+
+        SELECT to_iso8601(current_date); -- 2024-06-06
+        SELECT to_iso8601(now()); -- 2024-06-06T20:25:46.726-07:00
+        SELECT to_iso8601(now() + interval '6' month); -- 2024-12-06T20:27:11.992-08:00
+
+.. function:: to_milliseconds(interval) -> bigint
+
+    Returns the day-to-second ``interval`` as milliseconds.
+
 .. function:: to_unixtime(timestamp) -> double
 
     Returns ``timestamp`` as a UNIX timestamp.
@@ -61,6 +214,7 @@ Unit            Description
 ``minute``      ``Minutes``
 ``hour``        ``Hours``
 ``day``         ``Days``
+``week``        ``Weeks``
 ``month``       ``Months``
 ``quarter``     ``Quarters of a year``
 ``year``        ``Years``
@@ -141,7 +295,16 @@ The functions in this section leverage a native cpp implementation that follows
 a format string compatible with JodaTime’s `DateTimeFormat
 <http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html>`_
 pattern format. The symbols currently supported are ``y``, ``Y``, ``M`` , ``d``,
-``H``, ``m``, ``s``, ``S``, and ``Z``.
+``H``, ``m``, ``s``, ``S``, ``z`` and ``Z``.
+
+``z`` represents a timezone name (3-letter format), and ``Z`` a timezone offset
+specified using the format ``+00``, ``+00:00`` or ``+0000`` (or ``-``). ``Z``
+also accepts ``UTC``,  ``UCT``, ``GMT``, and ``GMT0`` as valid representations
+of GMT.
+
+.. function:: format_datetime(timestamp, format) -> varchar
+
+    Formats ``timestamp`` as a string using ``format``.
 
 .. function:: parse_datetime(string, format) -> timestamp with time zone
 
@@ -161,6 +324,8 @@ arbitrary large timestamps.
 
     Returns the day of the month from ``x``.
 
+    The supported types for ``x`` are DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, INTERVAL DAY TO SECOND.
+
 .. function:: day_of_month(x) -> bigint
 
     This is an alias for :func:`day`.
@@ -186,6 +351,8 @@ arbitrary large timestamps.
 .. function:: hour(x) -> bigint
 
     Returns the hour of the day from ``x``. The value ranges from 0 to 23.
+    Supported types for ``x`` are: DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE,
+    INTERVAL DAY TO SECOND¶.
 
 .. function:: last_day_of_month(x) -> date
 
@@ -193,15 +360,18 @@ arbitrary large timestamps.
 
 .. function:: millisecond(x) -> int64
 
-    Returns the millisecond of the second from ``x``.
+    Returns the millisecond of the second from ``x``. Supported types for ``x`` are:
+    DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, INTERVAL DAY TO SECOND¶.
 
 .. function:: minute(x) -> bigint
 
-    Returns the minute of the hour from ``x``.
+    Returns the minute of the hour from ``x``. Supported types for ``x`` are:
+    DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, INTERVAL DAY TO SECOND¶.
 
 .. function:: month(x) -> bigint
 
-    Returns the month of the year from ``x``.
+    Returns the month of the year from ``x``. Supported types for ``x`` are:
+    DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, INTERVAL YEAR TO MONTH.
 
 .. function:: quarter(x) -> bigint
 
@@ -209,7 +379,8 @@ arbitrary large timestamps.
 
 .. function:: second(x) -> bigint
 
-    Returns the second of the minute from ``x``.
+    Returns the second of the minute from ``x``. Supported types for ``x`` are:
+    DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, INTERVAL DAY TO SECOND¶.
 
 .. function:: timezone_hour(timestamp) -> bigint
 
@@ -231,7 +402,8 @@ arbitrary large timestamps.
 
 .. function:: year(x) -> bigint
 
-    Returns the year from ``x``.
+    Returns the year from ``x``. Supported types for ``x`` are:
+    DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, INTERVAL YEAR TO MONTH.
 
 .. function:: year_of_week(x) -> bigint
 
@@ -240,3 +412,60 @@ arbitrary large timestamps.
 .. function:: yow(x) -> bigint
 
     This is an alias for :func:`year_of_week`.
+
+.. _presto-time-zones:
+
+Time Zones
+----------
+
+Velox has full support for time zone rules, which are needed to perform date/time
+calculations correctly. Typically, the session time zone is used for temporal
+calculations. This is the time zone of the client computer that submits the query, if
+available. Otherwise, it is the time zone of the server running the Presto coordinator.
+
+Queries that operate with time zones that follow daylight saving can produce unexpected
+results. For example, if we run the following query in the `America/Los Angeles` time
+zone: ::
+
+        SELECT date_add('hour', 24, cast('2014-03-08 09:00:00' as timestamp));
+        -- 2014-03-09 10:00:00.000
+
+The timestamp appears to only advance 23 hours. This is because on March 9th clocks in
+`America/Los Angeles` are turned forward 1 hour, so March 9th only has 23 hours. To
+advance the day part of the timestamp, use the `day` unit instead: ::
+
+        SELECT date_add('day', 1, cast('2014-03-08 09:00:00' as timestamp));
+        -- 2014-03-09 09:00:00.000
+
+This works because the :func:`date_add` function treats the timestamp as list of fields, adds
+the value to the specified field and then rolls any overflow into the next higher field.
+
+Time zones are also necessary for parsing and printing timestamps. Queries that use this
+functionality can also produce unexpected results. For example, on the same machine: ::
+
+        SELECT cast('2014-03-09 02:30:00' as timestamp);
+
+The above query causes an error because there was no 2:30 AM on March 9th in
+`America/Los_Angeles` due to a daylight saving time transition.
+
+Similarly, the following query has two possible outcomes due to a daylight saving time
+transition: ::
+
+        SELECT cast('2014-11-02 01:30:00' as timestamp);
+        -- 2014-11-02 08:30:00.000
+
+It can be interpreted as `2014-11-02 01:30:00 PDT`, or `2014-11-02 01:30:00 PST`, which are
+`2014-11-02 08:30:00 UTC` or `2014-11-02 09:30:00 UTC` respectively. The former one is
+picked to be consistent with Presto.
+
+**Timezone Name Parsing**: When parsing strings that contain timezone names, the
+list of supported timezones follow the definition `here
+<https://en.wikipedia.org/wiki/List_of_tz_database_time_zones>`_.
+
+**Timezone Conversion**: The ``AT TIME ZONE`` operator sets the time zone of a timestamp: ::
+
+        SELECT timestamp '2012-10-31 01:00 UTC';
+        -- 2012-10-31 01:00:00.000 UTC
+
+        SELECT timestamp '2012-10-31 01:00 UTC' AT TIME ZONE 'America/Los_Angeles';
+        -- 2012-10-30 18:00:00.000 America/Los_Angeles
diff --git a/velox/docs/functions/presto/decimal.rst b/velox/docs/functions/presto/decimal.rst
new file mode 100644
index 0000000000000..539398e71242f
--- /dev/null
+++ b/velox/docs/functions/presto/decimal.rst
@@ -0,0 +1,370 @@
+=================
+Decimal Operators
+=================
+
+DECIMAL type is designed to represent floating point numbers precisely.
+Mathematical operations on decimal values are exact, except for division. On
+the other hand, DOUBLE and REAL types are designed to represent floating point
+numbers approximately. Mathematical operations on double and real values are
+approximate.
+
+For example, the number 5,000,000,000,000,000 can be represented using DOUBLE.
+However, the number 5,000,000,000,000,000.15 cannot be represented using
+DOUBLE, but it can be represented using DECIMAL. See
+https://en.wikipedia.org/wiki/Double-precision_floating-point_format for more
+details.
+
+DECIMAL type has 2 parameters: precision and scale. Precision is the total
+number of digits used to represent the number. Scale is the number of digits
+after the decimal point. Naturally, scale must not exceed precision. In
+addition, precision cannot exceed 38.
+
+::
+
+	decimal(p, s)
+
+	p >= 1 && p <= 38
+	s >= 0 && s <= p
+
+The number 5,000,000,000,000,000.15 can be represented using DECIMAL(18, 2).
+This number needs at least 18 digits (precision) of which at least 2 digits
+must appear after the decimal point (scale). This number can be represented
+using any DECIMAL type where scale >= 2 and precision is >= scale + 16.
+
+Note: This definition of precision and scale may appear counterintuitive. It is
+not uncommon to think about the number of digits after the decimal point as
+precision and the number of digits before the decimal point as scale.
+
+Addition and Subtraction
+------------------------
+
+To represent the results of adding two decimal numbers we need to use max
+(s1, s2) digits after the decimal point and max(p1 - s1, p2 - s2) + 1 digits
+before the decimal point.
+
+::
+
+	p = max(p1 - s1, p2 - s2) + 1 + max(s1, s2)
+	s = max(s1, s2)
+
+It is easiest to understand this formula by thinking about column addition where
+we place two numbers one under the other and line up decimal points.
+
+::
+
+        1.001
+     9999.5
+   -----------
+    10000.501
+
+We can see that the result needs max(s1, s2) digits after the decimal point and
+max(p1 - s1, p2 - s2) + 1 digits before the decimal point.
+
+The precision of the result may exceed 38. There are two options. One option is
+to say that addition and subtraction is supported as long as p <= 38 and reject
+operations that produce p > 38. Another option is to cap p at 38 and allow the
+operation to succeed as long as the actual result can be represented using 38
+digits. In this case, users experience runtime errors when the actual result
+cannot be represented using 38 digits. Presto implements the second option. Velox
+implementation matches Presto.
+
+Multiplication
+--------------
+
+To represent the results of multiplying two decimal numbers we need s1 + s2
+digits after the decimal point and p1 + p2 digits overall.
+
+::
+
+	p = p1 + p2
+	s = s1 + s2
+
+To multiply two numbers we can multiply them as integers ignoring the decimal
+points, then add up the number of digits after the decimal point in the
+original numbers and place the decimal point that many digits away in the
+result.
+
+To multiply 0.01 with 0.001, we can multiply 1 with 1, then place the decimal
+point 5 digits to the left: 0.00001. Hence, the scale of the result is the sum
+of scales of the inputs.
+
+When multiplying two integers with p1 and p2 digits respectively we get a result
+that is strictly less than 10^p1 * 10^p2 = 10^(p1 + p2). Hence, we need at most
+p1 + p2 digits to represent the result.
+
+Both scale and precision of the result may exceed 38. There are two options
+again. One option is to say that multiplication is supported as long as p <=
+38 (by definition, s does not exceed p and therefore does not exceed 38 if p <=
+38). Another option is to cap p and s at 38 and allow operation to succeed as
+long as the actual result can be represented as a decimal(38, s). In this case,
+users experience runtime errors when the actual result cannot be represented as a
+decimal(38, s). Presto implements a third option. Reject the operation if s
+exceeds 38 and cap p at 38 when s <= 38. In this case some operations are rejected
+outright while others are allowed to proceed, but may produce runtime errors. Velox
+implementation matches Presto.
+
+Division
+--------
+
+Perfect division is not possible. For example, 1 / 3 cannot be represented as a
+decimal value.
+
+When dividing a number with p1 digits over a number of s2 scale, the biggest result requires s2 extra digits before the
+decimal point. To get the largest number we must divide by 0.0000001, which effectively is a multiplication by 10^s2.
+Hence, precision of the result needs to be at least p1 + s2.
+
+Presto also chooses to extend the scale of the result to a maximum of scales of
+the inputs.
+
+::
+
+	s = max(s1, s2)
+
+To support increased scale, the result precision needs to be extended by the
+difference in s1 and s.
+
+::
+
+	p = p1 + s2 + max(0, s2 - s1)
+
+Like in Addition, the precision of the result may exceed 38. The choices are the
+same. Presto chooses to cap p at 38 and allow runtime errors.
+
+Let’s say `a` is of type decimal(p1, s1) with unscaled value `A` and `b` is of
+type decimal(p2, s2) with unscaled value B.
+
+::
+
+    a = A / 10^s1
+    b = B / 10^s2
+
+The result type precision and scale are:
+
+::
+
+	s = max(s1, s2)
+	p = p1 + s2 + max(0, s2 - s1)
+
+The result 'r' has 's' digits after the decimal point and unscaled value R. We
+derive the value of R as follows:
+
+::
+
+   r = a / b = (A / 10^s1) / (B / 10^s2) = A * 10^(s2 - s1) / B
+   r = R / 10^s
+   R = r * 10^s = A * 10^(s + s2 - s1) / B
+
+To compute R, first rescale A using the rescale factor :code:`(s + s2 - s1)`,
+then divide by B and round to the nearest whole. This method works as long as
+rescale factor does not exceed 38. If :code:`s + s2 - s1` exceeds 38, an error
+is raised.
+
+The formula for the scale of the result is a choice. Presto chose max(s1, s2).
+Other systems made different choices.
+
+It is not clear why Presto chose max(s1, s2). Perhaps, the thinking was to
+assume that user's desired accuracy is the max of input scales. However, one
+could also say that desired accuracy is the scale of the dividend. In SQL,
+literal values get their types assigned by the actual number of digits after
+the decimal point. Hence, in the following SQL 1.2 has scale 1 and 0.01 has
+scale 2. One may argue that user's intention is to work with accuracy of 2
+digits after the decimal point, hence, max(s1, s2).
+
+::
+
+    SELECT 1.2 / 0.01
+
+Modulus
+-------
+
+For the modulus operation :code:`a % b`, when a and b are integers, the result
+`r` is less than `b` and less than or equal to `a`. Hence the number of digits
+needed to represent `r` is no more than the minimum of the number of digits
+needed to represent `a` or `b`. We can extend this to decimal inputs `a` and
+`b` by computing the modulus of their unscaled values. However, we should
+first make sure that `a` and `b` have the same scale. This can be achieved by
+scaling up the input with lesser scale by the difference in the inputs' scales,
+so both `a` and `b` have scale s. Once `a` and `b` have the same scale, we
+compute the modulus of their unscaled values, A and B. `r` has s digits after
+the decimal point, and since `r` does not need any more digits than the
+minimum number of digits needed to represent `a` or `b`, the result precision
+needs to be increased by the smaller of the differences in the precision and
+scale of either inputs. Hence the result type precision and scale are:
+
+::
+
+    s = max(s1, s2)
+    p = min(p2 - s2, p1 - s1) + max(s1, s2)
+
+To compute R, we first rescale A and B to 's':
+
+::
+
+    A = a * 10^s1
+    B = b * 10^s2
+
+    A' = a * 10^s
+    B' = b * 10^s
+
+Then we compute modulus of the rescaled values:
+
+::
+
+    R = A' % B' = r * 10^s
+
+For example, say `a` = 12.3 and `b` = 1.21, `r` = :code:`a % b` is calculated
+as follows:
+
+::
+
+    s = max(1, 2) = 2
+    p = min(2, 1) + s = 3
+
+    A = 12.3 * 10^1 = 123
+    B = 1.21 * 10^2 = 121
+
+    A' = 12.3 * 10^2 = 1230
+    B' = 1.21 * 10^2 = 121
+
+    R = 1230 % 121 = 20 = 0.20 * 100
+
+Decimal Functions
+-----------------
+
+.. function:: abs(x: decimal(p, s)) -> r: decimal(p, s)
+
+    Returns absolute value of x (r = `|x|`).
+
+.. function:: divide(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p, s)
+
+    Returns the result of dividing x by y (r = x / y).
+
+    x and y are decimal values with possibly different precisions and scales. The
+    precision and scale of the result are calculated as follows:
+    ::
+
+        p = min(38, p1 + s2 + max(0, s2 - s1))
+        s = max(s1, s2)
+
+    Throws if y is zero, or result cannot be represented using precision calculated
+    above, or rescale factor `max(s1, s2) - s1 + s2` exceeds 38.
+
+.. function:: floor(x: decimal(p, s)) -> r: decimal(pr, 0)
+
+    Returns 'x' rounded down to the nearest integer. The scale of the result is 0.
+    The precision is calculated as:
+    ::
+
+        pr = min(38, p - s + min(s, 1))
+
+.. function:: minus(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p, s)
+
+    Returns the result of subtracting y from x (r = x - y).
+
+    x and y are decimal values with possibly different precisions and scales. The
+    precision and scale of the result are calculated as follows:
+    ::
+
+        p = min(38, max(p1 - s1, p2 - s2) + 1 + max(s1, s2))
+        s = max(s1, s2)
+
+    Throws if result cannot be represented using precision calculated above.
+
+.. function:: modulus(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p, s)
+
+    Returns the remainder from division of x by y (r = x % y).
+
+    x and y are decimal values with possibly different precisions and scales. The
+    precision and scale of the result are calculated as follows:
+    ::
+
+        p = min(p2 - s2, p1 - s1) + max(s1, s2)
+        s = max(s1, s2)
+
+    Throws if y is zero.
+
+.. function:: multiply(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p, s)
+
+    Returns the result of multiplying x by y (r = x * y).
+
+    x and y are decimal values with possibly different precisions and scales. The
+    precision and scale of the result are calculated as follows:
+    ::
+
+        p = min(38, p1 + p2)
+        s = s1 + s2
+
+    The operation is not supported if s1 + s2 exceeds 38.
+
+    Throws if result cannot be represented using precision calculated above.
+
+.. function:: negate(x: decimal(p, s)) -> r: decimal(p, s)
+
+    Returns negated value of x (r = -x).
+
+.. function:: plus(x: decimal(p1, s1), y: decimal(p2, s2)) -> r: decimal(p, s)
+
+    Returns the result of adding x to y (r = x + y).
+
+    x and y are decimal values with possibly different precisions and scales. The
+    precision and scale of the result are calculated as follows:
+    ::
+
+        p = min(38, max(p1 - s1, p2 - s2) + 1 + max(s1, s2))
+        s = max(s1, s2)
+
+    Throws if result cannot be represented using precision calculated above.
+
+.. function:: round(x: decimal(p, s)) -> r: decimal(rp, 0)
+
+    Returns 'x' rounded to the nearest integer. The scale of the result is 0.
+    The precision is calculated as:
+    ::
+
+        pr = min(38, p - s + min(s, 1))
+
+.. function:: round(x: decimal(p, s), d: integer) -> r: decimal(rp, s)
+
+    Returns 'x' rounded to 'd' decimal places. The scale of the result is
+    the same as the scale of the input. The precision is calculated as:
+    ::
+
+        p = min(38, p + 1)
+
+    'd' can be positive, zero or negative. Returns 'x' unmodified if 'd' exceeds
+    the scale of the input.
+
+    ::
+
+        SELECT round(123.45, 0); -- 123.00
+        SELECT round(123.45, 1); -- 123.50
+        SELECT round(123.45, 2); -- 123.45
+        SELECT round(123.45, 3); -- 123.45
+        SELECT round(123.45, -1); -- 120.00
+        SELECT round(123.45, -2); -- 100.00
+        SELECT round(123.45, -10); -- 0.00
+
+.. function:: truncate(x: decimal(p, s)) -> r: decimal(rp, 0)
+
+    Returns 'x' rounded to integer by dropping digits after decimal point.
+    The scale of the result is 0. The precision is calculated as:
+    ::
+
+        pr = max(p - s, 1)
+
+.. function:: truncate(x: decimal(p, s), d: integer) -> r: decimal(rp, s)
+
+    Returns ``x`` truncated to ``d`` decimal places.
+    The precision and scale of the result are the same as the precision and scale of the input.
+    ``d`` can be positive, zero or negative.
+    When ``d`` is negative truncates ``-d`` digits left of the decimal point.
+    Returns ``x`` unmodified if ``d`` exceeds the scale of the input.
+    ::
+
+        SELECT truncate(999.45, 0); -- 999.00
+        SELECT truncate(999.45, 1); -- 999.40
+        SELECT truncate(999.45, 2); -- 999.45
+        SELECT truncate(999.45, 3); -- 999.45
+        SELECT truncate(999.45, -1); -- 990.00
+        SELECT truncate(999.45, -2); -- 900.00
+        SELECT truncate(999.45, -10); -- 0.00
diff --git a/velox/docs/functions/presto/json.rst b/velox/docs/functions/presto/json.rst
index 18a8a47ec31ec..36cc09ce8255e 100644
--- a/velox/docs/functions/presto/json.rst
+++ b/velox/docs/functions/presto/json.rst
@@ -37,6 +37,8 @@ be JSON. Behaviors of the casts are shown with the examples below:
     SELECT CAST('abc' AS JSON); -- JSON '"abc"'
     SELECT CAST(true AS JSON); -- JSON 'true'
     SELECT CAST(1.234 AS JSON); -- JSON '1.234'
+    SELECT CAST(-0.00012 AS JSON); -- JSON '-1.2E-4'
+    SELECT CAST(10000000.0 AS JSON); -- JSON '1.0E7'
     SELECT CAST(ARRAY[1, 23, 456] AS JSON); -- JSON '[1,23,456]'
     SELECT CAST(ARRAY[1, NULL, 456] AS JSON); -- JSON '[1,null,456]'
     SELECT CAST(ARRAY[ARRAY[1, 23], ARRAY[456]] AS JSON); -- JSON '[[1,23],[456]]'
@@ -52,6 +54,12 @@ Another thing to be aware of is that when casting from ROW to JSON, the
 result is a JSON array rather than a JSON object. This is because positions
 are more important than names for rows in SQL.
 
+Also note that casting from REAL or DOUBLE returns the JSON text represented
+in standard notation if the magnitude of input value is greater than or equal
+to 10 :superscript:`-3` but less than 10 :superscript:`7`, and returns the JSON
+text in scientific notation otherwise. The standard and scientific notation
+always has the fractional part, such as ``10.0``.
+
 Finally, keep in mind that casting a VARCHAR string to JSON does not directly
 turn the original string into JSON type. Instead, it creates a JSON text
 representing the original string. This JSON text is different from the original
@@ -110,6 +118,29 @@ JSON Functions
 
         SELECT json_array_contains('[1, 2, 3]', 2);
 
+.. function:: json_array_get(json_array, index) -> json
+
+   Returns the element at the specified index into the ``json_array``.
+   The index is zero-based::
+
+        SELECT json_array_get('[1, 2, 3]', 0); -- JSON '1'
+        SELECT json_array_get('[1, 2, 3]', 1); -- JSON '2'
+
+   This function also supports negative indexes for fetching element indexed
+   from the end of an array::
+
+        SELECT json_array_get('[1, 2, 3]', -1); -- JSON '3'
+        SELECT json_array_get('[1, 2, 3]', -2); -- JSON '2'
+
+   If the element at the specified index doesn't exist, the function returns null::
+
+        SELECT json_array_get('[1, 2, 3]', 10); -- NULL
+        SELECT json_array_get('[1, 2, 3]', -10); -- NULL
+
+   If ``json_array`` is not an array, the function returns null::
+
+        SELECT json_array_get('{"a": 10, "b": 11}', 1); -- NULL
+
 .. function:: json_array_length(json) -> bigint
 
     Returns the array length of ``json`` (a string containing a JSON
diff --git a/velox/docs/functions/presto/map.rst b/velox/docs/functions/presto/map.rst
index f6a0c81d6f724..f0cade6e121af 100644
--- a/velox/docs/functions/presto/map.rst
+++ b/velox/docs/functions/presto/map.rst
@@ -39,7 +39,8 @@ Map Functions
 .. function:: map(array(K), array(V)) -> map(K,V)
    :noindex:
 
-    Returns a map created using the given key/value arrays. Keys are not allowed to be null or to contain nulls. ::
+    Returns a map created using the given key/value arrays. Keys are not allowed to be null or to contain nulls.
+    For REAL and DOUBLE, NaNs (Not-a-Number) are considered equal. ::
 
         SELECT map(ARRAY[1,3], ARRAY[2,4]); -- {1 -> 2, 3 -> 4}
 
@@ -70,6 +71,58 @@ Map Functions
 
         SELECT map_from_entries(ARRAY[(1, 'x'), (2, 'y')]); -- {1 -> 'x', 2 -> 'y'}
 
+.. function:: map_normalize(map(varchar,double)) -> map(varchar,double)
+
+    Returns the map with the same keys but all non-null values scaled proportionally
+    so that the sum of values becomes 1. Map entries with null values remain unchanged.
+
+    When total sum of non-null values is zero, null values remain null,
+    zero, NaN, Infinity and -Infinity values become NaN,
+    positive values become Infinity, negative values become -Infinity.::
+
+        SELECT map_normalize(map(array['a', 'b', 'c'], array[1, 4, 5])); -- {a=0.1, b=0.4, c=0.5}
+        SELECT map_normalize(map(array['a', 'b', 'c', 'd'], array[1, null, 4, 5])); -- {a=0.1, b=null, c=0.4, d=0.5}
+        SELECT map_normalize(map(array['a', 'b', 'c'], array[1, 0, -1])); -- {a=Infinity, b=NaN, c=-Infinity}
+
+.. function:: map_remove_null_values(map(K,V)) -> map(K,V)
+
+    Returns a map by removing all the keys in input map with null values. If input
+    is null, output is null. If input map is empty, output map is empty.
+
+        SELECT map_remove_null_values(MAP(ARRAY['ab', 'bc', 'cd'], ARRAY[null, null, null])); -- {}
+        SELECT map_remove_null_values(MAP(ARRAY[], ARRAY[])); -- {}
+        SELECT map_remove_null_values(MAP(ARRAY[1, 2, 3], ARRAY[3, 4, NULL])); -- {1=3, 2=4}
+        SELECT map_remove_null_values(NULL); -- NULL
+
+.. function:: map_subset(map(K,V), array(k)) -> map(K,V)
+
+    Constructs a map from those entries of ``map`` for which the key is in the array given
+    For keys containing REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
+
+        SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[10]); -- {}
+        SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1]); -- {1->'a'}
+        SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1,3]); -- {1->'a'}
+        SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[]); -- {}
+        SELECT map_subset(MAP(ARRAY[], ARRAY[]), ARRAY[1,2]); -- {}
+
+.. function:: map_top_n(map(K,V), n) -> map(K, V)
+
+    Truncates map items. Keeps only the top N elements by value. Keys are used to break ties with the max key being chosen. Both keys and values should be orderable.
+
+    ``n`` must be a non-negative BIGINT value.::
+
+        SELECT map_top_n(map(ARRAY['a', 'b', 'c'], ARRAY[2, 3, 1]), 2) --- {'b' -> 3, 'a' -> 2}
+        SELECT map_top_n(map(ARRAY['a', 'b', 'c'], ARRAY[NULL, 3, NULL]), 2) --- {'b' -> 3, 'a' -> NULL}
+
+.. function:: map_top_n_keys(map(K,V), n) -> array(K)
+
+    Constructs an array of the top N keys. Keys should be orderable.
+
+    ``n`` must be a non-negative BIGINT value.::
+
+        SELECT map_top_n_keys(map(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]), 2) --- ['c', 'b']
+        SELECT map_top_n_keys(map(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]), 0) --- []
+
 .. function:: map_keys(x(K,V)) -> array(K)
 
     Returns all the keys in the map ``x``.
@@ -93,6 +146,12 @@ Map Functions
                             MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]),
                             (k, v1, v2) -> k || CAST(v1/v2 AS VARCHAR));
 
+.. function:: multimap_from_entries(array(row(K,V))) -> map(K,array(V))
+
+    Returns a multimap created from the given array of entries. Each key can be associated with multiple values. ::
+
+        SELECT multimap_from_entries(ARRAY[(1, 'x'), (2, 'y'), (1, 'z')]); -- {1 -> ['x', 'z'], 2 -> ['y']}
+
 .. function:: no_keys_match(x(K,V), function(K, boolean)) -> boolean
 
     Returns whether no keys of a map match the given predicate. Returns true if none of the keys match the predicate (a special case is when the map is empty); false if one or more keys match; NULL if the predicate function returns NULL for one or more keys and false for all other keys. ::
@@ -108,7 +167,8 @@ Map Functions
 .. function:: subscript(map(K, V), key) -> V
    :noindex:
 
-    Returns value for given ``key``. Throws if the key is not contained in the map.
+    Returns value for given ``key``. Return null if the key is not contained in the map.
+    For REAL and DOUBLE, NaNs (Not-a-Number) are considered equal and can be used as keys.
     Corresponds to SQL subscript operator [].
 
     SELECT name_to_age_map['Bob'] AS bob_age;
diff --git a/velox/docs/functions/presto/math.rst b/velox/docs/functions/presto/math.rst
index 9077da198b566..c394182c66151 100644
--- a/velox/docs/functions/presto/math.rst
+++ b/velox/docs/functions/presto/math.rst
@@ -27,6 +27,17 @@ Mathematical Functions
     verified for performance reasons. Returns ``high`` for all values of ``x``
     when ``low`` is greater than ``high``.
 
+.. function:: cosine_similarity(map(varchar, double), map(varchar, double)) -> double
+
+    Returns the `cosine similarity <https://en.wikipedia.org/wiki/Cosine_similarity>`_ between the vectors represented as map(varchar, double).
+    If any input map is empty, the function returns NaN.
+
+        SELECT cosine_similarity(MAP(ARRAY['a'], ARRAY[1.0]), MAP(ARRAY['a'], ARRAY[2.0])); -- 1.0
+
+        SELECT cosine_similarity(MAP(ARRAY['a', 'b'], ARRAY[1.0, 2.0]), MAP(ARRAY['a', 'b'], ARRAY[NULL, 3.0])); -- NULL
+
+        SELECT cosine_similarity(MAP(ARRAY[], ARRAY[]), MAP(ARRAY['a', 'b'], ARRAY[2, 3])); -- NaN
+
 .. function:: degrees(x) -> double
 
     Converts angle x in radians to degrees.
@@ -128,6 +139,18 @@ Mathematical Functions
 
     Returns ``x`` rounded to ``d`` decimal places.
 
+.. function:: secure_rand() -> double
+
+    This is an alias for :func:`secure_random()`.
+
+.. function:: secure_random() -> double
+
+    Returns a cryptographically secure random value in the range 0.0 <= x < 1.0.
+
+.. function:: secure_random(lower, upper) -> [same as input]
+
+    Returns a cryptographically secure random value in the range lower <= x < upper, where lower < upper.
+
 .. function:: sign(x) -> [same as x]
 
     Returns the signum function of ``x``. For both integer and floating point arguments, it returns:
@@ -148,14 +171,17 @@ Mathematical Functions
 
     Returns the base-``radix`` representation of ``x``. ``radix`` must be between 2 and 36.
 
-.. function:: truncate(x) -> double
+.. function:: truncate(x) -> [same as x]
 
     Returns x rounded to integer by dropping digits after decimal point.
+    Supported types of ``x`` are: REAL and DOUBLE.
 
-.. function:: truncate(x, n) -> double
+.. function:: truncate(x, n) -> [same as x]
    :noindex:
 
     Returns x truncated to n decimal places. n can be negative to truncate n digits left of the decimal point.
+    Supported types of ``x`` are: REAL and DOUBLE.
+    ``n`` is an INTEGER.
 
 .. function:: width_bucket(x, bound1, bound2, n) -> bigint
 
@@ -275,6 +301,13 @@ Probability Functions: cdf
     Compute the Gamma cdf with given shape and scale parameters: P(N < value; shape, scale).
     The shape and scale parameters must be positive real numbers. The value must be a non-negative real number.
 
+.. function:: inverse_normal_cdf(mean, sd, p) -> double
+
+    Compute the inverse of the Normal cdf with given mean and standard
+    deviation (sd) for the cumulative probability (p): P(N < n). The mean must be
+    a real value and the standard deviation must be a real and positive value (both of type DOUBLE).
+    The probability p must lie on the interval (0, 1).
+
 .. function:: laplace_cdf(mean, scale, value) -> double
 
      Compute the Laplace cdf with given mean and scale parameters: P(N < value; mean, scale).
@@ -293,6 +326,11 @@ Probability Functions: cdf
     The lambda parameter must be a positive real number (of type DOUBLE) and value must be a non-negative integer.
 
 
+.. function:: weibull_cdf(a, b, value) -> double
+
+    Compute the Weibull cdf with given parameters a, b: P(N <= value). The ``a``
+    and ``b`` parameters must be positive doubles and ``value`` must also be a double.
+
 ====================================
 Probability Functions: inverse_cdf
 ====================================
@@ -303,6 +341,22 @@ Probability Functions: inverse_cdf
     probability (p): P(N < n). The a, b parameters must be positive real values (all of type DOUBLE).
     The probability p must lie on the interval [0, 1].
 
+.. function:: inverse_weibull_cdf(a, b, p) -> double
+
+    Compute the inverse of the Weibull cdf with given parameters ``a``, ``b`` for the probability ``p``.
+    The ``a``, ``b`` parameters must be positive double values. The probability ``p`` must be a double
+    on the interval [0, 1].
+
+.. function:: inverse_cauchy_cdf(median, scale, p) -> double
+
+    Compute the inverse of the Cauchy cdf with given parameters ``median`` and ``scale`` (gamma) for the probability p.
+    The scale parameter must be a positive double. The probability ``p`` must be a double on the interval [0, 1].
+
+.. function:: inverse_laplace_cdf(mean, scale, p) -> double
+
+    Compute the inverse of the Laplace cdf with given ``mean`` and ``scale`` parameters for the cumulative probability (p): P(N < n).
+    The mean must be a real value and the scale must be a positive real value (both of type DOUBLE).
+    The probability ``p`` must lie on the interval [0, 1].
 
 ====================================
 Statistical Functions
diff --git a/velox/docs/functions/presto/misc.rst b/velox/docs/functions/presto/misc.rst
new file mode 100644
index 0000000000000..f9de2a4f0df27
--- /dev/null
+++ b/velox/docs/functions/presto/misc.rst
@@ -0,0 +1,20 @@
+=======================
+Miscellaneous Functions
+=======================
+
+.. function:: fail(message)
+
+    Throws user error with the specified message.
+
+.. function:: fail(code, message)
+
+    Throws user error with the specified message. Ignores 'code' argument.
+
+.. function:: fail(json)
+
+    Throws user error with the message specified in 'message' field of the JSON.
+
+.. function:: fail(code, message)
+
+    Throws user error with the message specified in 'message' field of the JSON.
+    Ignores 'code' argument.
diff --git a/velox/docs/functions/presto/most_used_coverage.rst b/velox/docs/functions/presto/most_used_coverage.rst
index 7b5bbc65e3380..9a9e42a40a924 100644
--- a/velox/docs/functions/presto/most_used_coverage.rst
+++ b/velox/docs/functions/presto/most_used_coverage.rst
@@ -83,6 +83,7 @@ Here is a list of most used scalar and aggregate Presto functions with functions
     table.coverage tr:nth-child(12) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(13) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(7) {background-color: #6BA81E;}
@@ -131,7 +132,7 @@ Here is a list of most used scalar and aggregate Presto functions with functions
     :func:`length`               :func:`date`                 :func:`date_trunc`           :func:`date_parse`           st_y                             :func:`approx_percentile`
     :func:`from_unixtime`        :func:`is_nan`               :func:`date_diff`            bing_tile_at                 st_x                             :func:`avg`
     :func:`transform`            :func:`rand`                 :func:`array_max`            :func:`array_union`          now                              :func:`map_agg`
-    :func:`to_unixtime`          :func:`filter`               from_iso8601_date            :func:`reverse`              :func:`truncate`                 :func:`min_by`
+    :func:`to_unixtime`          :func:`filter`               :func:`from_iso8601_date`    :func:`reverse`              :func:`truncate`                 :func:`min_by`
     :func:`regexp_like`          :func:`sqrt`                 :func:`json_extract`         :func:`array_intersect`                                       :func:`stddev`
     :func:`array_join`           :func:`least`                :func:`mod`                  :func:`repeat`                                                :func:`set_agg`
     :func:`replace`              :func:`json_parse`           :func:`array_distinct`       st_geometryfromtext                                           :func:`histogram`
diff --git a/velox/docs/functions/presto/regexp.rst b/velox/docs/functions/presto/regexp.rst
index c032413fb3e5c..d7d41eb8361d3 100644
--- a/velox/docs/functions/presto/regexp.rst
+++ b/velox/docs/functions/presto/regexp.rst
@@ -7,21 +7,27 @@ supports only a subset of PCRE syntax and in particular does not support
 backtracking and associated features (e.g. back references).
 See https://github.com/google/re2/wiki/Syntax for more information.
 
+Compiling regular expressions is CPU intensive. Hence, each function is
+limited to 20 different expressions per instance and thread of execution.
+
 .. function:: like(string, pattern) -> boolean
               like(string, pattern, escape) -> boolean
 
     Evaluates if the ``string`` matches the ``pattern``. Patterns can contain
     regular characters as well as wildcards. Wildcard characters can be escaped
-    using the single character specified for the ``escape`` parameter.
-    Matching is case sensitive.
+    using the single character specified for the ``escape`` parameter. Only ASCII
+    characters are supported for the ``escape`` parameter. Matching is case sensitive.
 
     Note: The wildcard '%' represents 0, 1 or multiple characters and the
     wildcard '_' represents exactly one character.
 
     Note: Each function instance allow for a maximum of 20 regular expressions to
-    be compiled throughout the lifetime of the query. Not all Patterns requires
-    compilation of regular expressions; for example a pattern 'aa' does not.
-    Only those that require the compilation of regular expressions are counted.
+    be compiled per thread of execution. Not all patterns require
+    compilation of regular expressions. Patterns 'hello', 'hello%', '_hello__%',
+    '%hello', '%__hello_', '%hello%', where 'hello', 'velox'
+    contains only regular characters and '_' wildcards are evaluated without
+    using regular expressions. Only those patterns that require the compilation of
+    regular expressions are counted towards the limit.
 
         SELECT like('abc', '%b%'); -- true
         SELECT like('a_c', '%#_%', '#'); -- true
@@ -34,14 +40,22 @@ See https://github.com/google/re2/wiki/Syntax for more information.
         SELECT regexp_extract('1a 2b 14m', '\d+'); -- 1
 
 .. function:: regexp_extract(string, pattern, group) -> varchar
-   :noindex:
+    :noindex:
 
     Finds the first occurrence of the regular expression ``pattern`` in
     ``string`` and returns the capturing group number ``group``::
 
         SELECT regexp_extract('1a 2b 14m', '(\d+)([a-z]+)', 2); -- 'a'
 
-.. function:: regexp_extract_all(string, pattern, group) -> array(varchar)
+.. function:: regexp_extract_all(string, pattern) -> array(varchar):
+
+    Returns the substring(s) matched by the regular expression ``pattern``
+    in ``string``::
+
+        SELECT regexp_extract_all('1a 2b 14m', '\d+'); -- [1, 2, 14]
+
+.. function:: regexp_extract_all(string, pattern, group) -> array(varchar):
+    :noindex:
 
     Finds all occurrences of the regular expression ``pattern`` in
     ``string`` and returns the capturing group number ``group``::
@@ -69,7 +83,7 @@ See https://github.com/google/re2/wiki/Syntax for more information.
         SELECT regexp_replace('1a 2b 14m', '\d+[ab] '); -- '14m'
 
 .. function:: regexp_replace(string, pattern, replacement) -> varchar
-   :noindex:
+    :noindex:
 
     Replaces every instance of the substring matched by the regular expression
     ``pattern`` in ``string`` with ``replacement``. Capturing groups can be referenced in
@@ -78,3 +92,20 @@ See https://github.com/google/re2/wiki/Syntax for more information.
     backslash (``\$``)::
 
         SELECT regexp_replace('1a 2b 14m', '(\d+)([ab]) ', '3c$2 '); -- '3ca 3cb 14m'
+
+.. function:: regexp_replace(string, pattern, function) -> varchar
+
+    Replaces every instance of the substring matched by the regular expression
+    ``pattern`` in ``string`` using ``function``. The lambda expression
+    ``function`` is invoked for each match with the capturing groups passed as an
+    array. Capturing group numbers start at 1; there is no group for the entire match
+    (if you need this, surround the entire expression with parenthesis). ::
+
+        SELECT regexp_replace('new york', '(\w)(\w*)', x -> upper(x[1]) || lower(x[2])); --'New York'
+
+.. function:: regexp_split(string, pattern) -> array(varchar):
+
+    Splits ``string`` using the regular expression ``pattern`` and returns an
+    array. Trailing empty strings are preserved::
+
+        SELECT regexp_split('1a 2b 14m', '\s*[a-z]+\s*'); -- [1, 2, 14, ]
diff --git a/velox/docs/functions/presto/string.rst b/velox/docs/functions/presto/string.rst
index cf2e19c972f71..9040b382f31e9 100644
--- a/velox/docs/functions/presto/string.rst
+++ b/velox/docs/functions/presto/string.rst
@@ -40,15 +40,25 @@ String Functions
 .. function:: from_utf8(binary) -> varchar
 
     Decodes a UTF-8 encoded string from ``binary``. Invalid UTF-8 sequences
-    are replaced with the Unicode replacement character ``U+FFFD``.
+    are replaced with the Unicode replacement character ``U+FFFD``. Each
+    invalid UTF-8 codepoint, including those of multi-byte long, is replaced
+    with one replacement character.
 
 .. function:: from_utf8(binary, replace) -> varchar
     :noindex:
 
     Decodes a UTF-8 encoded string from ``binary``. Invalid UTF-8 sequences are
-    replaced with `replace`. The `replace` argument can be either Unicode code
-    point (bigint), a single character or empty string. When `replace` is an
-    empty string invalid characters are removed.
+    replaced with `replace`. Each invalid UTF-8 codepoint, including those of
+    multi-byte long, is replaced with one replacement character. The `replace`
+    argument can be either Unicode code point (bigint), a single character or
+    empty string. When `replace` is an empty string invalid characters are
+    removed.
+
+.. function:: hamming_distance(string1, string2) -> bigint
+
+    Returns the Hamming distance of ``string1`` and ``string2``,
+    i.e. the number of positions at which the corresponding characters are different.
+    Note that the two strings must have the same length.
 
 .. function:: length(string) -> bigint
 
@@ -98,7 +108,12 @@ String Functions
 .. function:: reverse(string) -> varchar
     :noindex:
 
-    Reverses ``string``.
+    Returns input string with characters in reverse order.
+
+.. function:: reverse(varbinary) -> varbinary
+    :noindex:
+
+    Returns input binary with bytes in reversed order.
 
 .. function:: rpad(string, size, padstring) -> varchar
 
@@ -146,10 +161,25 @@ String Functions
     each pair into key and value. Note that ``entryDelimiter`` and ``keyValueDelimiter`` are
     interpreted literally, i.e., as full string matches.
 
-    entryDelimiter and keyValueDelimiter must not be empty and must not be the same.
+    ``entryDelimiter`` and ``keyValueDelimiter`` must not be empty and must not be the same.
+    ``entryDelimiter`` is allowed to be the trailing character.
 
     Raises an error if there are duplicate keys.
 
+.. function:: split_to_map(string, entryDelimiter, keyValueDelimiter, function(K,V1,V2,R)) -> map<varchar, varchar>
+
+    Splits ``string`` by ``entryDelimiter`` and ``keyValueDelimiter`` and returns a map.
+    ``entryDelimiter`` splits ``string`` into key-value pairs. ``keyValueDelimiter`` splits
+    each pair into key and value. Note that ``entryDelimiter`` and ``keyValueDelimiter`` are
+    interpreted literally, i.e., as full string matches.
+
+    ``function(K,V1,V2,R)`` is used to decide whether to keep first or last value for
+    duplicate keys. (k, v1, v2) -> v1 keeps first value. (k, v1, v2) -> v2 keeps last
+    value. Arbitrary functions are not supported. ::
+
+        SELECT(split_to_map('a:1;b:2;a:3', ';', ':', (k, v1, v2) -> v1)); -- {"a": "1", "b": "2"}
+        SELECT(split_to_map('a:1;b:2;a:3', ';', ':', (k, v1, v2) -> v2)); -- {"a": "3", "b": "2"}
+
 .. function:: starts_with(string, substring) -> boolean
 
     Returns whether ``string`` starts with ``substring``.
@@ -181,7 +211,7 @@ String Functions
     ``instance`` must be a positive number.
     Positions start with ``1``. If not found, ``0`` is returned.
     It takes into account overlapping strings when counting occurrences. ::
-        
+
         SELECT strrpos('aaa', 'aa', 2); -- 1
 
 .. function:: substr(string, start) -> varchar
@@ -239,9 +269,70 @@ String Functions
 
     Converts ``string`` to uppercase.
 
+.. function:: word_stem(word) -> varchar
+
+    Returns the stem of ``word`` in the English language. If the ``word`` is not an English word,
+    the ``word`` in lowercase is returned.
+
+.. function:: word_stem(word, lang) -> varchar
+
+    Returns the stem of ``word`` in the ``lang`` language. This function supports the following languages:
+
+    =========== ================
+    lang        Language
+    =========== ================
+    ``ca``      ``Catalan``
+    ``da``      ``Danish``
+    ``de``      ``German``
+    ``en``      ``English``
+    ``es``      ``Spanish``
+    ``eu``      ``Basque``
+    ``fi``      ``Finnish``
+    ``fr``      ``French``
+    ``hu``      ``Hungarian``
+    ``hy``      ``Armenian``
+    ``ir``      ``Irish``
+    ``it``      ``Italian``
+    ``lt``      ``Lithuanian``
+    ``nl``      ``Dutch``
+    ``no``      ``Norwegian``
+    ``pt``      ``Portuguese``
+    ``ro``      ``Romanian``
+    ``ru``      ``Russian``
+    ``sv``      ``Swedish``
+    ``tr``      ``Turkish``
+    =========== ================
+
+    If the specified ``lang`` is not supported, this function throws a user error.
+
+
 Unicode Functions
 -----------------
 
+.. function:: normalize(string) -> varchar
+
+    Transforms ``string`` with NFC normalization form.
+
+.. function:: normalize(string, form) -> varchar
+
+    Reference: https://unicode.org/reports/tr15/#Norm_Forms
+    Transforms ``string`` with the specified normalization form.
+    ``form`` must be be one of the following keywords:
+
+    ======== ===========
+    Form     Description
+    ======== ===========
+    ``NFD``  Canonical Decomposition
+    ``NFC``  Canonical Decomposition, followed by Canonical Composition
+    ``NFKD`` Compatibility Decomposition
+    ``NFKC`` Compatibility Decomposition, followed by Canonical Composition
+    ======== ===========
+
+    .. note::
+
+        This SQL-standard function has special syntax and requires
+        specifying ``form`` as a keyword, not as a string.
+
 .. function:: to_utf8(string) -> varbinary
 
     Encodes ``string`` into a UTF-8 varbinary representation.
diff --git a/velox/docs/functions/presto/url.rst b/velox/docs/functions/presto/url.rst
index 183b81503d328..01b590dbe6cb1 100644
--- a/velox/docs/functions/presto/url.rst
+++ b/velox/docs/functions/presto/url.rst
@@ -2,10 +2,10 @@
 URL Functions
 =============
 
-Extraction Functions
---------------------
+Introduction
+------------
 
-The URL extraction functions extract components from HTTP URLs (or any valid URIs conforming to `RFC 2396 <https://tools.ietf.org/html/rfc2396.html>`_). The following syntax is supported:
+The URL extraction functions extract components from HTTP URLs (or any valid URIs conforming to `RFC 3986 <https://tools.ietf.org/html/rfc3986.html>`_). The following syntax is supported:
 
 .. code-block:: bash
 
@@ -14,6 +14,40 @@ The URL extraction functions extract components from HTTP URLs (or any valid URI
 
 The extracted components do not contain URI syntax separators such as ``:`` , ``?`` and ``#``.
 
+Consider for example the below URI:
+
+.. code-block::
+
+    http://www.ics.uci.edu/pub/ietf/uri/?k1=v1#Related
+
+    scheme    = http
+    authority = www.ics.uci.edu
+    path      = /pub/ietf/uri/
+    query     = k1=v1
+    fragment  = Related
+
+
+Invalid URI's
+-------------
+
+Well formed URI's should not contain ascii whitespace. `Percent-encoded URI's <https://www.rfc-editor.org/rfc/rfc3986#section-2.1>`_ should be followed by two hexadecimal
+digits after the percent character "%". All the url extract functions will return null when passed an invalid uri.
+
+.. code-block::
+
+    # Examples of url functions with Invalid URI's.
+
+    # Invalid URI due to whitespace
+    SELECT url_extract_path('foo '); -- NULL (1 row)
+    SELECT url_extract_host('http://www.foo.com '); -- NULL (1 row)
+
+    # Invalid URI due to improper escaping of '%'
+    SELECT url_extract_path('https://www.ucu.edu.uy/agenda/evento/%%UCUrlCompartir%%'); -- NULL (1 row)
+    SELECT url_extract_host('https://www.ucu.edu.uy/agenda/evento/%%UCUrlCompartir%%'); -- NULL (1 row)
+
+Extraction Functions
+--------------------
+
 .. function:: url_extract_fragment(url) -> varchar
 
     Returns the fragment identifier from ``url``.
@@ -32,7 +66,7 @@ The extracted components do not contain URI syntax separators such as ``:`` , ``
 
 .. function:: url_extract_port(url) -> bigint
 
-    Returns the port number from ``url``.
+    Returns the port number from ``url``. Returns NULL if port is missing.
 
 .. function:: url_extract_protocol(url) -> varchar
 
diff --git a/velox/docs/functions/presto/uuid.rst b/velox/docs/functions/presto/uuid.rst
new file mode 100644
index 0000000000000..a8cbdc5be511a
--- /dev/null
+++ b/velox/docs/functions/presto/uuid.rst
@@ -0,0 +1,7 @@
+==============
+UUID Functions
+==============
+
+.. function:: uuid() -> uuid
+
+    Returns a pseudo randomly generated UUID (type 4).
diff --git a/velox/docs/functions/presto/window.rst b/velox/docs/functions/presto/window.rst
index e0549ec942302..6d25073cb6788 100644
--- a/velox/docs/functions/presto/window.rst
+++ b/velox/docs/functions/presto/window.rst
@@ -62,6 +62,8 @@ More details:
 
   If no frame is specified, a default frame of RANGE UNBOUNDED PRECEDING is used.
 
+  More details about window frames can be found at :doc:`/develop/window`
+
 SQL Example
 ___________
 
@@ -116,6 +118,12 @@ within the window partition.
 Value functions
 _______________
 
+Value functions provide an option to specify how null values should be treated when evaluating the
+function. Nulls can either be ignored (``IGNORE NULLS``) or respected (``RESPECT NULLS``). By default,
+null values are respected. If ``IGNORE NULLS`` is specified, all rows where the value expression is
+null are excluded from the calculation. If ``IGNORE NULLS`` is specified and the value expression is
+null for all rows, the ``default_value`` is returned, or if it is not specified, ``null`` is returned.
+
 .. function:: first_value(x) -> [same as input]
 
 Returns the first value of the window.
@@ -130,19 +138,31 @@ Returns the value at the specified offset from the beginning of the window. Offs
 can be any scalar expression. If the offset is null or greater than the number of values in the window, null is
 returned. It is an error for the offset to be zero or negative.
 
-.. function:: lag(x[, offset [, default_value]]) -> [same as input]
+.. function:: lag(x[, offset[, default_value]]) -> [same as input]
+
+Returns the value at ``offset`` rows before the current row in the window partition.
+Offsets start at ``0``, which is the current row. The default ``offset`` is ``1``.
+The offset can be a constant value or a column reference. If the offset is ``null``, ``null`` is
+returned. If the offset refers to a row that is not within the partition, the
+``default_value`` is returned, or if ``default_value`` is not specified ``null``
+is returned.
+
+If ``IGNORE NULLS`` is specified, ``null`` values are ignored during offset counting.
+If not enough non-null values are found during offset counting, ``default_value``
+is returned.
 
-Returns the value at ``offset`` rows before the current row in the partition. If
-there is no such row, the ``default_value`` is returned, or if it is not
-specified ``null`` is returned. Offsets start at ``0``, which is the current
-row. The default ``offset`` is ``1``.
+.. function:: lead(x[, offset[, default_value]]) -> [same as input]
 
-.. function:: lead(x[, offset [, default_value]]) -> [same as input]
+Returns the value at ``offset`` rows after the current row in the window partition.
+Offsets start at ``0``, which is the current row. The default ``offset`` is ``1``.
+The offset can be a constant value or a column reference. If the offset is ``null``, ``null`` is
+returned. If the offset refers to a row that is not within the partition, the
+``default_value`` is returned, or if ``default_value`` is not specified ``null``
+is returned.
 
-Returns the value at ``offset`` rows after the current row in the partition. If
-there is no such row, the ``default_value`` is returned, or if it is not
-specified ``null`` is returned. Offsets start at ``0``, which is the current
-row. The default ``offset`` is ``1``.
+If ``IGNORE NULLS`` is specified, ``null`` values are ignored during offset counting.
+If not enough non-null values are found during offset counting, ``default_value``
+is returned.
 
 Aggregate functions
 ___________________
diff --git a/velox/docs/functions/spark/aggregate.rst b/velox/docs/functions/spark/aggregate.rst
index 6a2ed2427f706..b81c05460081c 100644
--- a/velox/docs/functions/spark/aggregate.rst
+++ b/velox/docs/functions/spark/aggregate.rst
@@ -53,6 +53,34 @@ General Aggregate Functions
 
     ``hash`` cannot be null.
 
+.. spark:function:: collect_list(x) -> array<[same as x]>
+
+    Returns an array created from the input ``x`` elements. Ignores null
+    inputs, and returns an empty array when all inputs are null.
+
+.. spark:function:: collect_set(x) -> array<[same as x]>
+
+    Returns an array consisting of all unique values from the input ``x`` elements excluding NULLs.
+    Returns empty array if input is empty or all NULL.
+
+    Example::
+
+        SELECT collect_set(i)
+        FROM (
+            VALUES
+                (1),
+                (null)
+        ) AS t(i);
+        -- ARRAY[1]
+
+        SELECT collect_set(elements)
+        FROM (
+            VALUES
+                ARRAY[1, 2],
+                ARRAY[1, null]
+        ) AS t(elements);
+        -- ARRAY[ARRAY[1, 2], ARRAY[1, null]]
+
 .. spark:function:: first(x) -> x
 
     Returns the first value of `x`.
@@ -61,6 +89,12 @@ General Aggregate Functions
 
     Returns the first non-null value of `x`.
 
+.. spark:function:: kurtosis(x) -> double
+
+    Returns the Pearson's kurtosis of all input values. When the count of `x` is not empty,
+    a non-null output will be generated. When the value of `m2` in the accumulator is 0, a null
+    output will be generated.
+
 .. spark:function:: last(x) -> x
 
     Returns the last value of `x`.
@@ -69,16 +103,104 @@ General Aggregate Functions
 
     Returns the last non-null value of `x`.
 
-.. spark:function:: max_by(x, y) -> x
+.. spark:function:: max(x) -> [same as x]
+
+    Returns the maximum value of ``x``.
+    ``x`` must be an orderable type.
+
+.. spark:function:: max_by(x, y) -> [same as x]
 
     Returns the value of `x` associated with the maximum value of `y`.
     Note: Spark provides a non-strictly comparator which is greater than or equals to.
-    Eg. SELECT max_by(x, y) FROM VALUES (('a', 10)), (('b', 50)), (('c', 50)) AS tab(x, y);
-        > c
 
-.. spark:function:: min_by(x, y) -> x
+    Example::
+
+        SELECT max_by(x, y)
+        FROM (
+            VALUES
+                ('a', 10),
+                ('b', 50),
+                ('c', 50)
+        ) AS t(x, y);
+
+    Returns c
+
+.. spark:function:: min(x) -> [same as x]
+
+    Returns the minimum value of ``x``.
+    ``x`` must be an orderable type.
+
+.. spark:function:: min_by(x, y) -> [same as x]
 
     Returns the value of `x` associated with the minimum value of `y`.
     Note: Spark provides a non-strictly comparator which is less than or equals to.
-    Eg. SELECT min_by(x, y) FROM VALUES (('a', 10)), (('b', 10)), (('c', 50)) AS tab(x, y);
-        > b
\ No newline at end of file
+
+    Example::
+
+        SELECT min_by(x, y)
+        FROM (
+            VALUES
+                ('a', 10),
+                ('b', 10),
+                ('c', 50)
+        ) AS t(x, y);
+
+    Returns b
+
+.. spark:function:: mode(x) -> [same as x]
+
+    Returns the most frequent value for the values within ``x``.
+    NULL values are ignored. If all the values are NULL, or
+    there are 0 rows, returns NULL.
+    If multiple values have the same greatest frequency, the 
+    return value could be any one of them.
+
+    Example::
+    
+        SELECT mode(x)
+        FROM (
+            VALUES
+                (0), (10), (10), (null), (null), (null)
+        ) AS t(x);
+
+    Returns 10
+
+.. spark:function:: regr_replacement(x) -> double
+
+    Returns the `m2` (the sum of the second central moment) of input values.
+
+.. spark:function:: skewness(x) -> double
+
+    Returns the skewness of all input values. When the count of `x` is greater than or equal to 1,
+    a non-null output will be generated. When the value of `m2` in the accumulator is 0, a null
+    output will be generated.
+
+.. spark:function:: sum(x) -> bigint|double|real
+
+    Returns the sum of `x`.
+
+    Supported types are TINYINT, SMALLINT, INTEGER, BIGINT, REAL, DOUBLE and DECIMAL.
+
+    When x is of type DOUBLE, the result type is DOUBLE.
+    When x is of type REAL, the result type is REAL.
+    When x is of type DECIMAL(p, s), the result type is DECIMAL(p + 10, s), where (p + 10) is capped at 38.
+
+    For all other input types, the result type is BIGINT.
+
+    Note:
+    When all input values is NULL, for all input types, the result is NULL.
+
+    For DECIMAL type, when an overflow occurs in the accumulation, it returns NULL. For REAL and DOUBLE type, it
+    returns Infinity. For all other input types, when the sum of input values exceeds its limit, it cycles to the
+    overflowed value rather than raising an error.
+
+    Example::
+
+        SELECT SUM(x)
+        FROM (
+            VALUES
+                (9223372036854775807L),
+                (1L)
+        ) AS t(x);
+
+    Returns -9223372036854775808
diff --git a/velox/docs/functions/spark/array.rst b/velox/docs/functions/spark/array.rst
index 2183f4f301c24..356232e96639d 100644
--- a/velox/docs/functions/spark/array.rst
+++ b/velox/docs/functions/spark/array.rst
@@ -21,46 +21,125 @@ Array Functions
 
         SELECT array_contains(array(1, 2, 3), 2); -- true
 
+.. spark:function:: array_distinct(array(E)) -> array(E)
+
+    Remove duplicate values from the input array. ::
+
+        SELECT array_distinct(ARRAY [1, 2, 3]); -- [1, 2, 3]
+        SELECT array_distinct(ARRAY [1, 2, 1]); -- [1, 2]
+        SELECT array_distinct(ARRAY [1, NULL, NULL]); -- [1, NULL]
+
+.. spark:function:: array_except(array(E) x, array(E) y) -> array(E)
+
+    Returns an array of the elements in array ``x`` but not in array ``y``, without duplicates. ::
+
+        SELECT array_except(ARRAY [1, 2, 3], ARRAY [4, 5, 6]); -- [1, 2, 3]
+        SELECT array_except(ARRAY [1, 2, 3], ARRAY [1, 2]); -- [3]
+        SELECT array_except(ARRAY [1, 2, 2], ARRAY [1, 1, 2]); -- []
+        SELECT array_except(ARRAY [1, 2, 2], ARRAY [1, 3, 4]); -- [2]
+        SELECT array_except(ARRAY [1, NULL, NULL], ARRAY [1, 1, NULL]); -- []
+
+.. spark:function:: array_insert(array(E), pos, E, legacyNegativeIndex) -> array(E)
+
+    Places new element into index ``pos`` of the input ``array``. Returns NULL if the input ``array`` or
+    ``pos`` is NULL. Array indices are 1-based and exception is thrown when ``pos`` is 0. The maximum
+    negative index is -1. When ``legacyNegativeIndex`` is true, -1 points to the last but one position.
+    Otherwise, -1 points to the last position. Index above array size appends the array or prepends the
+    array if index is negative, with 'null' elements. ::
+
+        SELECT array_insert(NULL, 1, 0, false); -- NULL
+        SELECT array_insert(NULL, 1, 0, true); -- NULL
+        SELECT array_insert(array(1, 2), NULL, 0, false); -- NULL
+        SELECT array_insert(array(1, 2), NULL, 0, true); -- NULL
+        SELECT array_insert(array(1, 2), 1, 0, false); -- [0, 1, 2]
+        SELECT array_insert(array(1, 2), 1, 0, true); -- [0, 1, 2]
+        SELECT array_insert(array(1, 2), 4, 0, false); -- [1, 2, NULL, 0]
+        SELECT array_insert(array(1, 2), 4, 0, true); -- [1, 2, NULL, 0]
+        SELECT array_insert(array(1, 2), -1, 0, false); -- [1, 2, 0]
+        SELECT array_insert(array(1, 2), -1, 0, true); -- [1, 0, 2]
+        SELECT array_insert(array(1, 2), -4, 0, false); -- [0, NULL, 1, 2]
+        SELECT array_insert(array(1, 2), -4, 0, true); -- [0, NULL, NULL, 1, 2]
+
 .. spark:function:: array_intersect(array(E), array(E1)) -> array(E2)
 
     Returns an array of the elements in the intersection of array1 and array2, without duplicates. ::
 
         SELECT array_intersect(array(1, 2, 3), array(1, 3, 5)); -- [1,3]
 
-.. function:: array_max(array(E)) -> E
+.. spark:function:: array_max(array(E)) -> E
 
     Returns maximum non-NULL element of the array. Returns NULL if array is empty or all elements are NULL.
     When E is DOUBLE or REAL, returns NaN if any element is NaN. ::
 
-        SELECT array_max(ARRAY [1, 2, 3]); -- 3
-        SELECT array_max(ARRAY [-1, -2, -2]); -- -1
-        SELECT array_max(ARRAY [-1, -2, NULL]); -- -1
-        SELECT array_max(ARRAY []); -- NULL
-        SELECT array_max(ARRAY [-0.0001, -0.0002, -0.0003, float('nan')]); -- NaN
+        SELECT array_max(array(1, 2, 3)); -- 3
+        SELECT array_max(array(-1, -2, -2)); -- -1
+        SELECT array_max(array(-1, -2, NULL)); -- -1
+        SELECT array_max(array()); -- NULL
+        SELECT array_max(array(-0.0001, -0.0002, -0.0003, float('nan'))); -- NaN
 
-.. function:: array_min(array(E)) -> E
+.. spark:function:: array_min(array(E)) -> E
 
     Returns minimum non-NULL element of the array. Returns NULL if array is empty or all elements are NULL.
     When E is DOUBLE or REAL, NaN value is considered greater than any non-NaN value. ::
 
-        SELECT array_min(ARRAY [1, 2, 3]); -- 1
-        SELECT array_min(ARRAY [-1, -2, -2]); -- -2
-        SELECT array_min(ARRAY [-1, -2, NULL]); -- -2
-        SELECT array_min(ARRAY [NULL, NULL]); -- NULL
-        SELECT array_min(ARRAY []); -- NULL
-        SELECT array_min(ARRAY [4.0, float('nan')]); -- 4.0
-        SELECT array_min(ARRAY [NULL, float('nan')]); -- NaN
+        SELECT array_min(array(1, 2, 3）); -- 1
+        SELECT array_min(array(-1, -2, -2）); -- -2
+        SELECT array_min(array(-1, -2, NULL)); -- -2
+        SELECT array_min(array(NULL, NULL)); -- NULL
+        SELECT array_min(array()); -- NULL
+        SELECT array_min(array(4.0, float('nan')]); -- 4.0
+        SELECT array_min(array(NULL, float('nan'))); -- NaN
+
+.. spark:function:: array_position(x, element) -> bigint
+
+    Returns the position (1-based) of the first occurrence of the ``element`` in array ``x`` (or 0 if not found). ::
+
+        SELECT array_position(array(1, 2, 3), 2); -- 2
+        SELECT array_position(array(1, 2, 3), 4); -- 0
+        SELECT array_position(array(1, 2, 3, 2), 2); -- 2
+
+.. spark:function:: array_remove(x, element) -> array
+
+    Remove all elements that equal ``element`` from array ``x``. Returns NULL as result if ``element`` is NULL.
+    If array ``x`` is empty array, returns empty array. If all elements in array ``x`` are NULL but ``element`` is not NULL,
+    returns array ``x``. ::
+
+        SELECT array_remove(array(1, 2, 3), 3); -- [1, 2]
+        SELECT array_remove(array(2, 1, NULL), 1); -- [2, NULL]
+        SELECT array_remove(array(1, 2, NULL), NULL); -- NULL
+        SELECT array_remove(array(), 1); -- []
+        SELECT array_remove(array(NULL, NULL), -1); -- [NULL, NULL]
+
+.. spark:function:: array_repeat(element, count) -> array(E)
+
+    Returns an array containing ``element`` ``count`` times. If ``count`` is negative or zero,
+    returns empty array. If ``element`` is NULL, returns an array containing ``count`` NULLs.
+    If ``count`` is NULL, returns NULL as result. Throws an exception if ``count`` exceeds 10'000. ::
+
+        SELECT array_repeat(100, 3); -- [100, 100, 100]
+        SELECT array_repeat(NULL, 3); -- [NULL, NULL, NULL]
+        SELECT array_repeat(100, NULL); -- NULL
+        SELECT array_repeat(100, 0); -- []
+        SELECT array_repeat(100, -1); -- []
 
 .. spark:function:: array_sort(array(E)) -> array(E)
 
     Returns an array which has the sorted order of the input array(E). The elements of array(E) must
     be orderable. Null elements will be placed at the end of the returned array. ::
 
-        SELECT array_sort(ARRAY [1, 2, 3]); -- [1, 2, 3]
-        SELECT array_sort(ARRAY [3, 2, 1]); -- [1, 2, 3]
-        SELECT array_sort(ARRAY [2, 1, NULL]; -- [1, 2, NULL]
-        SELECT array_sort(ARRAY [NULL, 1, NULL]); -- [1, NULL, NULL]
-        SELECT array_sort(ARRAY [NULL, 2, 1]); -- [1, 2, NULL]
+        SELECT array_sort(array(1, 2, 3)); -- [1, 2, 3]
+        SELECT array_sort(array(3, 2, 1)); -- [1, 2, 3]
+        SELECT array_sort(array(2, 1, NULL); -- [1, 2, NULL]
+        SELECT array_sort(array(NULL, 1, NULL)); -- [1, NULL, NULL]
+        SELECT array_sort(array(NULL, 2, 1)); -- [1, 2, NULL]
+
+.. spark::function:: arrays_zip(array(T), array(U),..) -> array(row(T,U, ...))
+
+    Returns the merge of the given arrays, element-wise into a single array of rows.
+    The M-th element of the N-th argument will be the N-th field of the M-th output element.
+    If the arguments have an uneven length, missing values are filled with ``NULL`` ::
+
+        SELECT arrays_zip(ARRAY[1, 2], ARRAY['1b', null, '3b']); -- [ROW(1, '1b'), ROW(2, null), ROW(null, '3b')]
 
 .. spark:function:: concat(array(E), array(E1), ..., array(En)) -> array(E, E1, ..., En)
 
@@ -68,6 +147,15 @@ Array Functions
 
         SELECT concat(array(1, 2, 3), array(4, 5), array(6)); -- [1, 2, 3, 4, 5, 6]
 
+.. spark:function:: exists(array(T), function(T, boolean)) → boolean
+
+    Returns whether at least one element of an array matches the given predicate.
+
+        Returns true if one or more elements match the predicate;
+        Returns false if none of the elements matches (a special case is when the array is empty);
+        Returns NULL if the predicate function returns NULL for one or more elements and false for all other elements.
+        Throws an exception if the predicate fails for one or more elements and returns false or NULL for the rest.
+
 .. spark:function:: filter(array(E), func) -> array(E)
 
     Filters the input array using the given predicate. ::
@@ -76,24 +164,81 @@ Array Functions
         SELECT filter(array(0, 2, 3), (x, i) -> x > i); -- [2, 3]
         SELECT filter(array(0, null, 2, 3, null), x -> x IS NOT NULL); -- [0, 2, 3]
 
+.. spark:function:: flatten(array(array(E))) -> array(E)
+
+    Transforms an array of arrays into a single array.
+    Returns NULL if the input is NULL or any of the nested arrays is NULL. ::
+
+        SELECT flatten(array(array(1, 2), array(3, 4))); -- [1, 2, 3, 4]
+        SELECT flatten(array(array(1, 2), array(3, NULL))); -- [1, 2, 3, NULL]
+        SELECT flatten(array(array(1, 2), NULL, array(3, 4))); -- NULL
+
+.. spark:function:: forall(array(T), function(T, boolean)) → boolean
+
+    Returns whether all elements of an array match the given predicate.
+
+        Returns true if all the elements match the predicate (a special case is when the array is empty);
+        Returns false if one or more elements don’t match;
+        Returns NULL if the predicate function returns NULL for one or more elements and true for all other elements.
+        Throws an exception if the predicate fails for one or more elements and returns true or NULL for the rest.
+
+.. spark:function:: get(array(E), index) -> E
+
+    Returns an element of the array at the specified 0-based index.
+    Returns NULL if index points outside of the array boundaries. ::
+
+        SELECT get(array(1, 2, 3), 0); -- 1
+        SELECT get(array(1, 2, 3), 3); -- NULL
+        SELECT get(array(1, 2, 3), -1); -- NULL
+        SELECT get(array(1, 2, 3), NULL); -- NULL
+        SELECT get(array(1, 2, NULL), 2); -- NULL
+
 .. spark:function:: in(value, array(E)) -> boolean
 
     Returns true if value matches at least one of the elements of the array.
     Supports BOOLEAN, REAL, DOUBLE, BIGINT, VARCHAR, TIMESTAMP, DATE input types.
 
-.. spark:function:: size(array(E)) -> bigint
+.. spark:function:: shuffle(array(E), seed) -> array(E)
 
-    Returns the size of the array. Returns null for null input
-    if :doc:`spark.legacy_size_of_null <../../configs>` is set to false.
-    Otherwise, returns -1 for null input.
+    Generates a random permutation of the given ``array`` using a seed derived 
+    from the parameter ``seed`` and the configuration `spark.partition_id`.
+    ``seed`` must be constant. ::
+
+        SELECT shuffle(array(1, 2, 3), 0); -- [3, 1, 2]
+        SELECT shuffle(array(0, 0, 0), 0); -- [0, 0, 0]
+        SELECT shuffle(array(1, NULL, 1, NULL, 2), 0); -- [2, 1, NULL, NULL, 1]
+
+.. spark:function:: size(array(E), legacySizeOfNull) -> integer
+
+    Returns the size of the array. Returns null for null input if `legacySizeOfNull`
+    is set to false. Otherwise, returns -1 for null input. ::
+
+        SELECT size(array(1, 2, 3), true); -- 3
+        SELECT size(NULL, true); -- -1
+        SELECT size(NULL, false); -- NULL
+
+.. spark:function:: slice(array(E), start, length) -> array(E)
+
+    Returns a subarray starting at 1-based index ``start`` or from end if negative, with ``length`` elements.
+    Returns elements between ``start`` and the end of the array if ``start + length`` is outside of the array.
+    Returns empty array if ``start`` point outside of the array or ``length`` is 0.
+    Throws exception if ``start`` is 0 or ``length`` is negative. ::
+
+        SELECT slice(array(1, 2, 3, 4), 2, 2); -- [2, 3]
+        SELECT slice(array(1, 2, 3, 4), -2, 2); -- [3, 4]
+        SELECT slice(array(1, 2, 3, 4), 5, 1); -- []
+        SELECT slice(array(1, 2, 3, 4), 2, 5); -- [2, 3, 4]
+        SELECT slice(array(1, 2, 3, 4), 2, 0); -- []
+        SELECT slice(array(1, 2, 3, 4), 1, -1); -- error: The value of length argument of slice() function should not be negative
+        SELECT slice(array(1, 2, 3, 4), 0, 1); -- error: SQL array indices start at 1
 
 .. spark:function:: sort_array(array(E)) -> array(E)
 
     Returns an array which has the sorted order of the input array. The elements of array must
     be orderable. Null elements will be placed at the beginning of the returned array. ::
 
-        SELECT sort_array(ARRAY [1, 2, 3]); -- [1, 2, 3]
-        SELECT sort_array(ARRAY [NULL, 2, 1]); -- [NULL, 1, 2]
+        SELECT sort_array(array(1, 2, 3)); -- [1, 2, 3]
+        SELECT sort_array(array(NULL, 2, 1)); -- [NULL, 1, 2]
 
 .. spark:function:: sort_array(array(E), ascendingOrder) -> array(E)
    :noindex:
@@ -102,9 +247,9 @@ Array Functions
     be orderable. Null elements will be placed at the beginning of the returned array in ascending
     order or at the end of the returned array in descending order. ::
 
-        SELECT sort_array(ARRAY [3, 2, 1], true); -- [1, 2, 3]
-        SELECT sort_array(ARRAY [2, 1, NULL, true]; -- [NULL, 1, 2]
-        SELECT sort_array(ARRAY [NULL, 1, NULL], false); -- [1, NULL, NULL]
+        SELECT sort_array(array(3, 2, 1), true); -- [1, 2, 3]
+        SELECT sort_array(array(2, 1, NULL, true); -- [NULL, 1, 2]
+        SELECT sort_array(array(NULL, 1, NULL), false); -- [1, NULL, NULL]
 
 .. spark:function:: transform(array(E), function) -> array(E)
 
@@ -112,3 +257,14 @@ Array Functions
 
         SELECT transform(array(1, 2, 3), x -> x + 1); -- [2,3,4]
         SELECT transform(array(1, 2, 3), (x, i) -> x + i); -- [1,3,5]
+
+.. spark:function:: zip_with(array(T), array(U), function(T,U,R)) -> array(R)
+
+    Merges the two given arrays, element-wise, into a single array using ``function``.
+    If one array is shorter, nulls are appended at the end to match the length of the
+    longer array, before applying ``function`` ::
+
+        SELECT zip_with(ARRAY[1, 3, 5], ARRAY['a', 'b', 'c'], (x, y) -> (y, x)); -- [ROW('a', 1), ROW('b', 3), ROW('c', 5)]
+        SELECT zip_with(ARRAY[1, 2], ARRAY[3, 4], (x, y) -> x + y); -- [4, 6]
+        SELECT zip_with(ARRAY['a', 'b', 'c'], ARRAY['d', 'e', 'f'], (x, y) -> concat(x, y)); -- ['ad', 'be', 'cf']
+        SELECT zip_with(ARRAY['a'], ARRAY['d', null, 'f'], (x, y) -> coalesce(x, y)); -- ['a', null, 'f']
diff --git a/velox/docs/functions/spark/binary.rst b/velox/docs/functions/spark/binary.rst
index 7d6b30c2dad89..48ce669467f5d 100644
--- a/velox/docs/functions/spark/binary.rst
+++ b/velox/docs/functions/spark/binary.rst
@@ -2,21 +2,29 @@
 Binary Functions
 ================
 
+.. spark:function:: crc32(binary) -> bigint
+
+    Computes the crc32 checksum of ``binary``.
+
 .. spark:function:: hash(x, ...) -> integer
 
-    Computes the hash of one or more input values using seed value of 42.
+    Computes the hash of one or more input values using seed value of 42. For
+    multiple arguments, their types can be different.
 
 .. spark:function:: hash_with_seed(seed, x, ...) -> integer
 
-    Computes the hash of one or more input values using specified seed.
+    Computes the hash of one or more input values using specified seed. For
+    multiple arguments, their types can be different.
 
 .. spark:function:: xxhash64(x, ...) -> bigint
 
     Computes the xxhash64 of one or more input values using seed value of 42.
+    For multiple arguments, their types can be different.
 
 .. spark:function:: xxhash64_with_seed(seed, x, ...) -> bigint
 
-    Computes the xxhash64 of one or more input values using specified seed.
+    Computes the xxhash64 of one or more input values using specified seed. For
+    multiple arguments, their types can be different.
 
 .. spark:function:: md5(x) -> varbinary
 
@@ -26,7 +34,7 @@ Binary Functions
 
    Returns TRUE if ``bloomFilter`` might contain ``value``. 
 
-   ``bloomFilter`` is a VARBINARY computed using ::spark::function::`bloom_filter_agg` aggregate function. 
+   ``bloomFilter`` is a VARBINARY computed using ::spark:function::`bloom_filter_agg` aggregate function. 
    ``value`` is a BIGINT.
 
 .. spark:function:: sha1(x) -> varchar
diff --git a/velox/docs/functions/spark/bitwise.rst b/velox/docs/functions/spark/bitwise.rst
index 2dac8234fe9bb..5924b36aa428c 100644
--- a/velox/docs/functions/spark/bitwise.rst
+++ b/velox/docs/functions/spark/bitwise.rst
@@ -6,11 +6,25 @@ Bitwise Functions
 
     Returns the bitwise AND of ``x`` and ``y`` in 2's complement representation. 
     Corresponds to Spark's operator ``&``.
+    Supported types are: TINYINT, SMALLINT, INTEGER and BIGINT.
+
+.. spark:function:: bitwise_not(x) -> [same as input]
+
+    Returns the bitwise NOT of ``x`` in 2's complement representation.
+    Corresponds to Spark's operator ``~``.
+    Supported types are: TINYINT, SMALLINT, INTEGER and BIGINT.
 
 .. spark:function:: bitwise_or(x, y) -> [same as input]
 
     Returns the bitwise OR of ``x`` and ``y`` in 2's complement representation.
+    Corresponds to Spark's operator ``|``.
+    Supported types are: TINYINT, SMALLINT, INTEGER and BIGINT.
+
+.. spark:function:: bitwise_xor(x, y) -> [same as input]
+
+    Returns the bitwise exclusive OR of ``x`` and ``y`` in 2's complement representation.
     Corresponds to Spark's operator ``^``.
+    Supported types are: TINYINT, SMALLINT, INTEGER and BIGINT.
 
 .. spark:function:: bit_count(x) -> integer
 
diff --git a/velox/docs/functions/spark/comparison.rst b/velox/docs/functions/spark/comparison.rst
index 0985e4dab7db2..9b62e68c918b0 100644
--- a/velox/docs/functions/spark/comparison.rst
+++ b/velox/docs/functions/spark/comparison.rst
@@ -10,18 +10,27 @@ Comparison Functions
 
 .. spark:function:: equalnullsafe(x, y) -> boolean
 
-    Returns true if x is equal to y. Supports all scalar types. The
-    types of x and y must be the same. Unlike :spark:func:`equalto` returns true if both inputs
-    are NULL and false if one of the inputs is NULL.
+    Returns true if ``x`` is equal to ``y``. Supports all scalar and complex types. The
+    types of ``x`` and ``y`` must be the same. Unlike :spark:func:`equalto` returns true if both inputs
+    are NULL and false if one of the inputs is NULL. Nested nulls are compared as values.
     Corresponds to Spark's operator ``<=>``.
     Note that NaN in Spark is handled differently from standard floating point semantics.
     It is considered larger than any other numeric values. This rule is applied for functions
-    "equalnullsafe", "equalto", "greaterthan", "greaterthanorequal", "lessthan", "lessthanorequal".
+    "equalnullsafe", "equalto", "greaterthan", "greaterthanorequal", "lessthan", "lessthanorequal". ::
+
+        SELECT equalnullsafe(null, null); -- true
+        SELECT equalnullsafe(null, ARRAY[1]); -- false
+        SELECT equalnullsafe(ARRAY[1, null], ARRAY[1, null]); -- true
 
 .. spark:function:: equalto(x, y) -> boolean
 
-    Returns true if x is equal to y. Supports all scalar types. The
+    Returns true if x is equal to y. Supports all scalar and complex types. The
     types of x and y must be the same. Corresponds to Spark's operators ``=`` and ``==``.
+    Returns NULL for any NULL input, but nested nulls are compared as values. ::
+    
+        SELECT equalto(null, null); -- null
+        SELECT equalto(null, ARRAY[1]); -- null
+        SELECT equalto(ARRAY[1, null], ARRAY[1, null]); -- true
 
 .. spark:function:: greaterthan(x, y) -> boolean
 
@@ -78,5 +87,32 @@ Comparison Functions
     Returns true if x is not equal to y. Supports all scalar types. The types
     of x and y must be the same. Corresponds to Spark's operator ``!=``.
 
+.. spark:function:: decimal_lessthan(x, y) -> boolean
+
+    Returns true if x is less than y. Supports decimal types with different precisions and scales.
+    Corresponds to Spark's operator ``<``.
+
+.. spark:function:: decimal_lessthanorequal(x, y) -> boolean
+
+    Returns true if x is less than y or x is equal to y. Supports decimal types with different precisions and scales.
+    Corresponds to Spark's operator ``<=``.
+
+.. spark:function:: decimal_equalto(x, y) -> boolean
+
+    Returns true if x is equal to y. Supports decimal types with different precisions and scales.
+    Corresponds to Spark's operator ``==``.
+
+.. spark:function:: decimal_notequalto(x, y) -> boolean
+
+    Returns true if x is not equal to y. Supports decimal types with different precisions and scales.
+    Corresponds to Spark's operator ``!=``.
+
+.. spark:function:: decimal_greaterthan(x, y) -> boolean
+
+    Returns true if x is greater than y. Supports decimal types with different precisions and scales.
+    Corresponds to Spark's operator ``>``.
 
+.. spark:function:: decimal_greaterthanorequal(x, y) -> boolean
 
+    Returns true if x is greater than y or x is equal to y. Supports decimal types with different precisions and scales.
+    Corresponds to Spark's operator ``>=``.
diff --git a/velox/docs/functions/spark/conversion.rst b/velox/docs/functions/spark/conversion.rst
new file mode 100644
index 0000000000000..037e3baebf5a8
--- /dev/null
+++ b/velox/docs/functions/spark/conversion.rst
@@ -0,0 +1,241 @@
+====================
+Conversion Functions
+====================
+
+Casting from UNKNOWN type to all other scalar types is supported, e.g., cast(NULL as int).
+
+Cast to Integral Types
+----------------------
+
+Integral types include bigint, integer, smallint, and tinyint.
+
+From integral types
+^^^^^^^^^^^^^^^^^^^
+
+Casting one integral type to another is allowed. When the input value exceeds the range of result type,
+a value of the result type is created forcedly with the input value.
+
+Valid examples:
+
+::
+
+  SELECT cast(1234567 as bigint); -- 1234567
+  SELECT cast(12 as tinyint); -- 12
+  SELECT cast(1234 as tinyint); -- -46
+  SELECT cast(1234567 as smallint); -- -10617
+
+From floating-point types
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Casting from floating-point input to an integral type truncates the input value.
+It is allowed when the truncated result exceeds the range of result type.
+
+Valid examples
+
+::
+
+  SELECT cast(12345.12 as bigint); -- 12345
+  SELECT cast(12345.67 as bigint); -- 12345
+  SELECT cast(127.1 as tinyint); -- 127
+  SELECT cast(127.8 as tinyint); -- 127
+  SELECT cast(1234567.89 as smallint); -- -10617
+  SELECT cast(cast('inf' as double) as bigint); -- 9223372036854775807
+  SELECT cast(cast('nan' as double) as integer); -- 0
+  SELECT cast(cast('nan' as double) as smallint); -- 0
+  SELECT cast(cast('nan' as double) as tinyint); -- 0
+  SELECT cast(cast('nan' as double) as bigint); -- 0
+
+From strings
+^^^^^^^^^^^^
+
+Casting a string to an integral type is allowed if the string represents a number within the range of result type.
+Casting from strings that represent floating-point numbers truncates the decimal part of the input value.
+Casting from invalid input values throws.
+
+Valid examples
+
+::
+
+  SELECT cast('12345' as bigint); -- 12345
+  SELECT cast('+1' as tinyint); -- 1
+  SELECT cast('-1' as tinyint); -- -1
+  SELECT cast('12345.67' as bigint); -- 12345
+  SELECT cast('1.2' as tinyint); -- 1
+  SELECT cast('-1.8' as tinyint); -- -1
+  SELECT cast('+1' as tinyint); -- 1
+  SELECT cast('1.' as tinyint); -- 1
+  SELECT cast('-1' as tinyint); -- -1
+  SELECT cast('-1.' as tinyint); -- -1
+  SELECT cast('0.' as tinyint); -- 0
+  SELECT cast('.' as tinyint); -- 0
+  SELECT cast('-.' as tinyint); -- 0
+
+Invalid examples
+
+::
+
+  SELECT cast('1234567' as tinyint); -- Out of range
+  SELECT cast('1a' as tinyint); -- Invalid argument
+  SELECT cast('' as tinyint); -- Invalid argument
+  SELECT cast('1,234,567' as bigint); -- Invalid argument
+  SELECT cast('1'234'567' as bigint); -- Invalid argument
+  SELECT cast('nan' as bigint); -- Invalid argument
+  SELECT cast('infinity' as bigint); -- Invalid argument
+
+From decimal
+^^^^^^^^^^^^
+
+The decimal part will be truncated for casting to an integer.
+It is allowed when the truncated result exceeds the range of result type.
+
+Valid examples
+
+::
+
+  SELECT cast(cast(2.56 as DECIMAL(6, 2)) as bigint); -- 2
+  SELECT cast(cast(3.46 as DECIMAL(6, 2)) as bigint); -- 3
+  SELECT cast(cast(5500.0 as DECIMAL(5, 1)) as tinyint); -- 124
+  SELECT cast(cast(2147483648.90 as DECIMAL(12, 2)) as tinyint); -- 0
+  SELECT cast(cast(2147483648.90 as DECIMAL(12, 2)) as integer); -- -2147483648
+  SELECT cast(cast(2147483648.90 as DECIMAL(12, 2)) as bigint); -- 2147483648
+
+Cast to Boolean
+---------------
+
+From VARCHAR
+^^^^^^^^^^^^
+
+The strings `t, f, y, n, 1, 0, yes, no, true, false` and their upper case equivalents are allowed to be casted to boolean.
+Casting from other strings to boolean throws.
+
+Valid examples
+
+::
+
+  SELECT cast('1' as boolean); -- true
+  SELECT cast('0' as boolean); -- false
+  SELECT cast('t' as boolean); -- true (case insensitive)
+  SELECT cast('true' as boolean); -- true (case insensitive)
+  SELECT cast('f' as boolean); -- false (case insensitive)
+  SELECT cast('false' as boolean); -- false (case insensitive)
+  SELECT cast('y' as boolean); -- true (case insensitive)
+  SELECT cast('yes' as boolean); -- true (case insensitive)
+  SELECT cast('n' as boolean); -- false (case insensitive)
+  SELECT cast('no' as boolean); -- false (case insensitive)
+
+Invalid examples
+
+::
+
+  SELECT cast('1.7E308' as boolean); -- Invalid argument
+  SELECT cast('nan' as boolean); -- Invalid argument
+  SELECT cast('infinity' as boolean); -- Invalid argument
+  SELECT cast('12' as boolean); -- Invalid argument
+  SELECT cast('-1' as boolean); -- Invalid argument
+  SELECT cast('tr' as boolean); -- Invalid argument
+  SELECT cast('tru' as boolean); -- Invalid argument
+
+Cast to String
+--------------
+
+From TIMESTAMP
+^^^^^^^^^^^^^^
+
+Casting a timestamp to a string returns ISO 8601 format with space as separator between date and time,
+and the year part is padded with zeros to 4 characters.
+The conversion precision is microsecond, and trailing zeros are not appended.
+When the year exceeds 9999, a positive sign is added.
+
+Valid examples
+
+::
+
+  SELECT cast(cast('1970-01-01 00:00:00' as timestamp) as string); -- '1970-01-01 00:00:00'
+  SELECT cast(cast('2000-01-01 12:21:56.129' as timestamp) as string); -- '2000-01-01 12:21:56.129'
+  SELECT cast(cast('2000-01-01 12:21:56.100000' as timestamp) as string); -- '2000-01-01 12:21:56.1'
+  SELECT cast(cast('2000-01-01 12:21:56.129900' as timestamp) as string); -- '2000-01-01 12:21:56.1299'
+  SELECT cast(cast('10000-02-01 16:00:00.000' as timestamp) as string); -- '+10000-02-01 16:00:00'
+  SELECT cast(cast('0384-01-01 08:00:00.000' as timestamp) as string); -- '0384-01-01 08:00:00'
+  SELECT cast(cast('-0010-02-01 10:00:00.000' as timestamp) as string); -- '-0010-02-01 10:00:00'
+
+Cast to Date
+------------
+
+From strings
+^^^^^^^^^^^^
+
+All Spark supported patterns are allowed:
+  
+  * ``[+-](YYYY-MM-DD)``
+  * ``[+-]yyyy*``
+  * ``[+-]yyyy*-[m]m``
+  * ``[+-]yyyy*-[m]m-[d]d``
+  * ``[+-]yyyy*-[m]m-[d]d *``
+  * ``[+-]yyyy*-[m]m-[d]dT*``
+
+The asterisk ``*`` in ``yyyy*`` stands for any numbers.
+For the last two patterns, the trailing ``*`` can represent none or any sequence of characters, e.g:
+  
+  * "1970-01-01 123"
+  * "1970-01-01 (BC)"
+  
+All leading and trailing UTF8 white-spaces will be trimmed before cast.
+Casting from invalid input values throws.
+
+Valid examples
+
+::
+
+  SELECT cast('1970' as date); -- 1970-01-01
+  SELECT cast('1970-01' as date); -- 1970-01-01
+  SELECT cast('1970-01-01' as date); -- 1970-01-01
+  SELECT cast('1970-01-01T123' as date); -- 1970-01-01
+  SELECT cast('1970-01-01 ' as date); -- 1970-01-01
+  SELECT cast('1970-01-01 (BC)' as date); -- 1970-01-01
+
+Invalid examples
+
+::
+
+  SELECT cast('2012-Oct-23' as date); -- Invalid argument
+  SELECT cast('2012/10/23' as date); -- Invalid argument
+  SELECT cast('2012.10.23' as date); -- Invalid argument
+
+Cast to Decimal
+---------------
+
+From varchar
+^^^^^^^^^^^^
+
+Casting varchar to a decimal of given precision and scale is allowed.
+The behavior is similar with Presto except Spark allows leading and trailing white-spaces in input varchars.
+
+Valid example
+
+::
+
+  SELECT cast(' 1.23' as decimal(38, 0)); -- 1
+  SELECT cast('1.23 ' as decimal(38, 0)); -- 1
+  SELECT cast('  1.23  ' as decimal(38, 0)); -- 1
+  SELECT cast(' -3E+2' as decimal(12, 2)); -- -300.00
+  SELECT cast('-3E+2 ' as decimal(12, 2)); -- -300.00
+  SELECT cast('  -3E+2  ' as decimal(12, 2)); -- -300.00
+
+Cast to Varbinary
+-----------------
+
+From integral types
+^^^^^^^^^^^^^^^^^^^
+
+Casting integral value to varbinary type is allowed.
+Bytes of input value are converted into an array of bytes in little-endian order.
+Supported types are tinyint, smallint, integer and bigint.
+
+Valid example
+
+::
+
+  SELECT cast(cast(18 as tinyint) as binary); -- [12]
+  SELECT cast(cast(180 as smallint) as binary); -- [00 B4]
+  SELECT cast(cast(180000 as integer) as binary); -- [00 02 BF 20]
+  SELECT cast(cast(180000 as bigint) as binary); -- [00 00 00 00 00 02 BF 20]
diff --git a/velox/docs/functions/spark/datetime.rst b/velox/docs/functions/spark/datetime.rst
index fca04f0a62720..85ca72628933b 100644
--- a/velox/docs/functions/spark/datetime.rst
+++ b/velox/docs/functions/spark/datetime.rst
@@ -7,11 +7,49 @@ Convenience Extraction Functions
 
 These functions support TIMESTAMP and DATE input types.
 
+.. spark:function:: add_months(startDate, numMonths) -> date
+
+    Returns the date that is ``numMonths`` after ``startDate``.
+    Adjusts result to a valid one, considering months have different total days, and especially
+    February has 28 days in common year but 29 days in leap year.
+    For example, add_months('2015-01-30', 1) returns '2015-02-28', because 28th is the last day
+    in February of 2015.
+    ``numMonths`` can be zero or negative. Throws an error when inputs lead to int overflow,
+    e.g., add_months('2023-07-10', -2147483648). ::
+
+        SELECT add_months('2015-01-01', 10); -- '2015-11-01'
+        SELECT add_months('2015-01-30', 1); -- '2015-02-28'
+        SELECT add_months('2015-01-30', 0); -- '2015-01-30'
+        SELECT add_months('2015-01-30', -2); -- '2014-11-30'
+        SELECT add_months('2015-03-31', -1); -- '2015-02-28'
+
 .. spark:function:: date_add(start_date, num_days) -> date
 
-    Returns the date that is num_days after start_date.
-    If num_days is a negative value then these amount of days will be
-    deducted from start_date.
+    Returns the date that is ``num_days`` after ``start_date``. According to the inputs,
+    the returned date will wrap around between the minimum negative date and
+    maximum positive date. date_add('1969-12-31', 2147483647) get 5881580-07-10,
+    and date_add('2024-01-22', 2147483647) get -5877587-07-12.
+
+    If ``num_days`` is a negative value then these amount of days will be
+    deducted from ``start_date``.
+    Supported types for ``num_days`` are: TINYINT, SMALLINT, INTEGER.
+
+.. spark:function:: date_from_unix_date(integer) -> date
+
+    Creates date from the number of days since 1970-01-01 in either direction. Returns null when input is null.
+
+        SELECT date_from_unix_date(1); -- '1970-01-02'
+        SELECT date_from_unix_date(-1); -- '1969-12-31'
+
+.. spark:function:: date_sub(start_date, num_days) -> date
+
+    Returns the date that is ``num_days`` before ``start_date``. According to the inputs,
+    the returned date will wrap around between the minimum negative date and
+    maximum positive date. date_sub('1969-12-31', -2147483648) get 5881580-07-11,
+    and date_sub('2023-07-10', -2147483648) get -5877588-12-29.
+
+    ``num_days`` can be positive or negative.
+    Supported types for ``num_days`` are: TINYINT, SMALLINT, INTEGER.
 
 .. spark:function:: datediff(endDate, startDate) -> integer
 
@@ -21,38 +59,70 @@ These functions support TIMESTAMP and DATE input types.
         SELECT datediff('2009-07-31', '2009-07-30'); -- 1
         SELECT datediff('2009-07-30', '2009-07-31'); -- -1
 
-.. spark:function:: date_sub(start_date, num_days) -> date
+.. spark:function:: dayofmonth(date) -> integer
 
-    Returns the date that is num_days before start_date. According to the inputs,
-    the returned date will wrap around between the minimum negative date and
-    maximum positive date. date_sub('1969-12-31', -2147483648) get 5881580-07-11,
-    and date_sub('2023-07-10', -2147483648) get -5877588-12-29.
+    Returns the day of month of the date. ::
 
-    num_days can be positive or negative.
+        SELECT dayofmonth('2009-07-30'); -- 30
 
 .. spark:function:: dayofyear(date) -> integer
 
-    Returns Returns the day of year of the date/timestamp. ::
+    Returns the day of year of the date. ::
 
-    SELECT dayofyear('2016-04-09'); -- 100
+        SELECT dayofyear('2016-04-09'); -- 100
 
-.. spark:function:: dayofmonth(date) -> integer
+.. spark:function:: dayofweek(date) -> integer
+
+    Returns the day of the week for date (1 = Sunday, 2 = Monday, ..., 7 = Saturday).
 
-    Returns the day of month of the date/timestamp. ::
+        SELECT dayofweek('2009-07-30'); -- 5
+        SELECT dayofweek('2023-08-22'); -- 3
 
-    SELECT dayofmonth('2009-07-30'); -- 30
+.. spark:function:: from_unixtime(unixTime, format) -> string
 
-.. spark:function:: dayofweek(date/timestamp) -> integer
+    Adjusts ``unixTime`` (elapsed seconds since UNIX epoch) to configured session timezone, then
+    converts it to a formatted time string according to ``format``. Only supports BIGINT type for
+    ``unixTime``.
+    `Valid patterns for date format
+    <https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html>`_. Throws exception for
+    invalid ``format``. This function will convert input to milliseconds, and integer overflow is
+    allowed in the conversion, which aligns with Spark. See the below third example where INT64_MAX
+    is used, -1000 milliseconds are produced by INT64_MAX * 1000 due to integer overflow. ::
 
-    Returns the day of the week for date/timestamp (1 = Sunday, 2 = Monday, ..., 7 = Saturday).
-    We can use `dow` as alias for ::
+        SELECT from_unixtime(100, 'yyyy-MM-dd HH:mm:ss'); -- '1970-01-01 00:01:40'
+        SELECT from_unixtime(3600, 'yyyy'); -- '1970'
+        SELECT from_unixtime(9223372036854775807, "yyyy-MM-dd HH:mm:ss");  -- '1969-12-31 23:59:59'
 
-    SELECT dayofweek('2009-07-30'); -- 5
-    SELECT dayofweek('2023-08-22 11:23:00.100'); -- 3
+    If we run the following query in the `Asia/Shanghai` time zone: ::
 
-.. function:: dow(x) -> integer
+        SELECT from_unixtime(100, 'yyyy-MM-dd HH:mm:ss'); -- '1970-01-01 08:01:40'
+        SELECT from_unixtime(3600, 'yyyy'); -- '1970'
+        SELECT from_unixtime(9223372036854775807, "yyyy-MM-dd HH:mm:ss");  -- '1970-01-01 07:59:59'
 
-    This is an alias for :func:`day_of_week`.
+.. spark:function:: from_utc_timestamp(timestamp, string) -> timestamp
+
+    Returns the timestamp value from UTC timezone to the given timezone. ::
+
+        SELECT from_utc_timestamp('2015-07-24 07:00:00', 'America/Los_Angeles'); -- '2015-07-24 00:00:00'
+
+.. spark:function:: get_timestamp(string, dateFormat) -> timestamp
+
+    Returns timestamp by parsing ``string`` according to the specified ``dateFormat``.
+    The format follows Spark's
+    `Datetime patterns
+    <https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html>`_.
+    Returns NULL for parsing error or NULL input. Throws exception for invalid format. ::
+
+        SELECT get_timestamp('1970-01-01', 'yyyy-MM-dd);  -- timestamp `1970-01-01`
+        SELECT get_timestamp('1970-01-01', 'yyyy-MM');  -- NULL (parsing error)
+        SELECT get_timestamp('1970-01-01', null);  -- NULL
+        SELECT get_timestamp('2020-06-10', 'A');  -- (throws exception)
+
+.. spark:function:: hour(timestamp) -> integer
+
+    Returns the hour of ``timestamp``.::
+
+        SELECT hour('2009-07-30 12:58:59'); -- 12
 
 .. spark:function:: last_day(date) -> date
 
@@ -69,6 +139,108 @@ These functions support TIMESTAMP and DATE input types.
     ``day`` need to be from 1 to 31, and matches the number of days in each month.
     days of ``year-month-day - 1970-01-01`` need to be in the range of INTEGER type.
 
+.. spark:function:: make_ym_interval([years[, months]]) -> interval year to month
+
+    Make year-month interval from ``years`` and ``months`` fields.
+    Returns the actual year-month with month in the range of [0, 11].
+    Both ``years`` and ``months`` can be zero, positive or negative.
+    Throws an error when inputs lead to int overflow,
+    e.g., make_ym_interval(178956970, 8). ::
+
+        SELECT make_ym_interval(1, 2); -- 1-2
+        SELECT make_ym_interval(1, 0); -- 1-0
+        SELECT make_ym_interval(-1, 1); -- -0-11
+        SELECT make_ym_interval(1, 100); -- 9-4
+        SELECT make_ym_interval(1, 12); -- 2-0
+        SELECT make_ym_interval(1, -12); -- 0-0
+        SELECT make_ym_interval(2); -- 2-0
+        SELECT make_ym_interval(); -- 0-0
+
+.. spark:function:: minute(timestamp) -> integer
+
+    Returns the minutes of ``timestamp``.::
+
+        SELECT minute('2009-07-30 12:58:59'); -- 58
+
+.. spark:function:: quarter(date) -> integer
+
+    Returns the quarter of ``date``. The value ranges from ``1`` to ``4``. ::
+
+        SELECT quarter('2009-07-30'); -- 3
+
+.. spark:function:: make_timestamp(year, month, day, hour, minute, second[, timezone]) -> timestamp
+
+    Create timestamp from ``year``, ``month``, ``day``, ``hour``, ``minute`` and ``second`` fields.
+    If the ``timezone`` parameter is provided,
+    the function interprets the input time components as being in the specified ``timezone``.
+    Otherwise the function assumes the inputs are in the session's configured time zone.
+    Requires ``session_timezone`` to be set, or an exceptions will be thrown.
+
+    Arguments:
+        * year - the year to represent, within the Joda datetime
+        * month - the month-of-year to represent, from 1 (January) to 12 (December)
+        * day - the day-of-month to represent, from 1 to 31
+        * hour - the hour-of-day to represent, from 0 to 23
+        * minute - the minute-of-hour to represent, from 0 to 59
+        * second - the second-of-minute and its micro-fraction to represent, from 0 to 60.
+          The value can be either an integer like 13, or a fraction like 13.123.
+          The fractional part can have up to 6 digits to represent microseconds.
+          If the sec argument equals to 60, the seconds field is set
+          to 0 and 1 minute is added to the final timestamp.
+        * timezone - the time zone identifier. For example, CET, UTC and etc.
+
+    Returns the timestamp adjusted to the GMT time zone.
+    Returns NULL for invalid or NULL input. ::
+
+        SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887); -- 2014-12-28 06:30:45.887
+        SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET'); -- 2014-12-28 05:30:45.887
+        SELECT make_timestamp(2019, 6, 30, 23, 59, 60); -- 2019-07-01 00:00:00
+        SELECT make_timestamp(2019, 6, 30, 23, 59, 1); -- 2019-06-30 23:59:01
+        SELECT make_timestamp(null, 7, 22, 15, 30, 0); -- NULL
+        SELECT make_timestamp(2014, 12, 28, 6, 30, 60.000001); -- NULL
+        SELECT make_timestamp(2014, 13, 28, 6, 30, 45.887); -- NULL
+
+.. spark:function:: month(date) -> integer
+
+    Returns the month of ``date``. ::
+
+        SELECT month('2009-07-30'); -- 7
+
+.. spark:function:: next_day(startDate, dayOfWeek) -> date
+
+    Returns the first date which is later than ``startDate`` and named as ``dayOfWeek``.
+    Returns null if ``dayOfWeek`` is invalid.
+    ``dayOfWeek`` is case insensitive and must be one of the following:
+    ``SU``, ``SUN``, ``SUNDAY``, ``MO``, ``MON``, ``MONDAY``, ``TU``, ``TUE``, ``TUESDAY``,
+    ``WE``, ``WED``, ``WEDNESDAY``, ``TH``, ``THU``, ``THURSDAY``, ``FR``, ``FRI``, ``FRIDAY``,
+    ``SA``, ``SAT``, ``SATURDAY``. ::
+
+        SELECT next_day('2015-07-23', "Mon"); -- '2015-07-27'
+        SELECT next_day('2015-07-23', "mo"); -- '2015-07-27'
+        SELECT next_day('2015-07-23', "Tue"); -- '2015-07-28'
+        SELECT next_day('2015-07-23', "tu"); -- '2015-07-28'
+        SELECT next_day('2015-07-23', "we"); -- '2015-07-29'
+
+.. spark:function:: second(timestamp) -> integer
+
+    Returns the seconds of ``timestamp``. ::
+
+        SELECT second('2009-07-30 12:58:59'); -- 59
+
+.. spark:function:: timestamp_micros(x) -> timestamp
+
+    Returns timestamp from the number of microseconds since UTC epoch.
+    Supported types are: TINYINT, SMALLINT, INTEGER and BIGINT.::
+
+        SELECT timestamp_micros(1230219000123123); -- '2008-12-25 15:30:00.123123'
+
+.. spark:function:: timestamp_millis(x) -> timestamp
+
+    Returns timestamp from the number of milliseconds since UTC epoch.
+    Supported types are: TINYINT, SMALLINT, INTEGER and BIGINT.::
+
+        SELECT timestamp_millis(1230219000123); -- '2008-12-25 15:30:00.123'
+
 .. spark:function:: to_unix_timestamp(string) -> integer
 
     Alias for ``unix_timestamp(string) -> integer``.
@@ -78,6 +250,39 @@ These functions support TIMESTAMP and DATE input types.
 
     Alias for ``unix_timestamp(string, format) -> integer``.
 
+.. spark:function:: to_utc_timestamp(timestamp, string) -> timestamp
+
+    Returns the timestamp value from the given timezone to UTC timezone. ::
+
+        SELECT to_utc_timestamp('2015-07-24 00:00:00', 'America/Los_Angeles'); -- '2015-07-24 07:00:00'
+
+.. spark:function:: unix_date(date) -> integer
+
+    Returns the number of days since 1970-01-01. ::
+
+        SELECT unix_date('1970-01-01'); -- '0'
+        SELECT unix_date('1970-01-02'); -- '1'
+        SELECT unix_date('1969-12-31'); -- '-1'
+
+.. spark:function:: unix_micros(timestamp) -> bigint
+
+    Returns the number of microseconds since 1970-01-01 00:00:00 UTC.::
+
+        SELECT unix_micros('1970-01-01 00:00:01'); -- 1000000
+
+.. spark:function:: unix_millis(timestamp) -> bigint
+
+    Returns the number of milliseconds since 1970-01-01 00:00:00 UTC. Truncates
+    higher levels of precision.::
+
+        SELECT unix_millis('1970-01-01 00:00:01'); -- 1000
+
+.. spark:function:: unix_seconds(timestamp) -> bigint
+    
+    Returns the number of seconds since 1970-01-01 00:00:00 UTC. ::
+
+        SELECT unix_seconds('1970-01-01 00:00:01'); -- 1
+
 .. spark:function:: unix_timestamp() -> integer
 
     Returns the current UNIX timestamp in seconds.
@@ -104,8 +309,22 @@ These functions support TIMESTAMP and DATE input types.
     Returns the `ISO-Week`_ of the year from x. The value ranges from ``1`` to ``53``.
     A week is considered to start on a Monday and week 1 is the first week with >3 days.
 
+.. function:: weekday(date) -> integer
+
+    Returns the day of the week for date (0 = Monday, 1 = Tuesday, …, 6 = Sunday). ::
+
+        SELECT weekday('2015-04-08'); -- 2
+        SELECT weekday('2024-02-10'); -- 5
+
 .. _ISO-Week: https://en.wikipedia.org/wiki/ISO_week_date
 
 .. spark:function:: year(x) -> integer
 
     Returns the year from ``x``.
+
+.. spark:function:: year_of_week(x) -> integer
+
+    Returns the ISO week-numbering year that ``x`` falls in. For example, 2005-01-02 is
+    part of the 53rd week of year 2004, so the result is 2004. Only supports DATE type.
+
+        SELECT year_of_week('2005-01-02'); -- 2004
diff --git a/velox/docs/functions/spark/decimal.rst b/velox/docs/functions/spark/decimal.rst
new file mode 100644
index 0000000000000..19eee325f4b31
--- /dev/null
+++ b/velox/docs/functions/spark/decimal.rst
@@ -0,0 +1,103 @@
+=================
+Decimal Operators
+=================
+
+When calculating the result precision and scale of arithmetic operators,
+the formulas follow Hive which is based on the SQL standard and MS SQL:
+
+https://cwiki.apache.org/confluence/download/attachments/27362075/Hive_Decimal_Precision_Scale_Support.pdf
+
+https://msdn.microsoft.com/en-us/library/ms190476.aspx
+
+Addition and Subtraction
+------------------------
+
+::
+
+	p = max(p1 - s1, p2 - s2) + max(s1, s2) + 1
+	s = max(s1, s2)
+
+Multiplication
+--------------
+
+::
+
+	p = p1 + p2 + 1
+	s = s1 + s2
+
+Division
+--------
+
+::
+
+    p = p1 - s1 + s2 + max(6, s1 + p2 + 1)
+    s = max(6, s1 + p2 + 1)
+
+For above arithmetic operators, when the precision of result exceeds 38,
+caps p at 38 and reduces the scale, in order to prevent the truncation of
+the integer part of the decimals. Below formula illustrates how the result
+precision and scale are adjusted.
+
+::
+
+    precision = 38
+    scale = max(38 - (p - s), min(s, 6))
+
+Users experience runtime errors when the actual result cannot be represented
+with the calculated decimal type.
+
+Decimal Functions
+-----------------
+
+.. spark:function:: unscaled_value(x) -> bigint
+
+    Return the unscaled bigint value of a short decimal ``x``.
+    Supported type is: SHORT_DECIMAL.
+
+Decimal Special Forms
+---------------------
+
+.. spark:function:: make_decimal(x[, nullOnOverflow]) -> decimal
+
+    Create ``decimal`` of requsted precision and scale from an unscaled bigint value ``x``.
+    By default, the value of ``nullOnOverflow`` is true, and null will be returned when ``x`` is too large for the result precision.
+    Otherwise, exception will be thrown when ``x`` overflows.
+
+.. spark:function:: decimal_round(decimal[, scale]) -> [decimal]
+
+    Returns ``decimal`` rounded to a new scale using HALF_UP rounding mode. In HALF_UP rounding, the digit 5 is rounded up.
+    ``scale`` is the new scale to be rounded to. It is 0 by default, and integer in [INT_MIN, INT_MAX] is allowed to be its value.
+    When the absolute value of scale exceeds the maximum precision of long decimal (38), the round logic is equivalent to the case where it is 38 as we cannot exceed the maximum precision. 
+    The result precision and scale are decided with the precision and scale of input ``decimal`` and ``scale``.
+    After rounding we may need one more digit in the integral part.
+    
+    ::
+        SELECT (round(cast (9.9 as decimal(2, 1)), 0)); -- decimal 10
+        SELECT (round(cast (99 as decimal(2, 0)), -1)); -- decimal 100
+
+    When ``scale`` is negative, we need to adjust ``-scale`` number of digits before the decimal point,
+    which means we need at least ``-scale + 1`` digits after rounding, and the result scale is 0.
+
+    ::
+
+        SELECT round(cast (0.856 as DECIMAL(3, 3)), -1); -- decimal 0
+        SELECT round(cast (85.6 as DECIMAL(3, 1)), -1); -- decimal 90
+        SELECT round(cast (85.6 as DECIMAL(3, 1)), -2); -- decimal 100
+        SELECT round(cast (85.6 as DECIMAL(3, 1)), -99);  -- decimal 0
+        SELECT round(cast (12345678901234.56789 as DECIMAL(32, 5)), -9); -- decimal 12346000000000
+
+    When ``scale`` is 0, the result scale is 0.
+
+    ::
+
+        SELECT round(cast (85.6 as DECIMAL(3, 1))); -- decimal 86
+        SELECT round(cast (0.856 as DECIMAL(3, 3)), 0); -- decimal 1
+
+    When ``scale`` is positive, the result scale is the minor one of input scale and ``scale``.
+    The result precision is decided with the number of integral digits and the result scale, but cannot exceed the max precision of decimal.
+
+    ::
+
+        SELECT round(cast (85.681 as DECIMAL(5, 3)), 1); -- decimal 85.7
+        SELECT round(cast (85.681 as DECIMAL(5, 3)), 999); -- decimal 85.681
+        SELECT round(cast (0.1234567890123456789 as DECIMAL(19, 19)), 14); -- decimal 0.12345678901235
diff --git a/velox/docs/functions/spark/json.rst b/velox/docs/functions/spark/json.rst
index 07f4f3a75ace2..8004873986880 100644
--- a/velox/docs/functions/spark/json.rst
+++ b/velox/docs/functions/spark/json.rst
@@ -2,26 +2,12 @@
 JSON Functions
 ==============
 
-JSON Format
------------
+.. spark:function:: json_object_keys(jsonString) -> array(string)
 
-JSON is a language-independent data format that represents data as
-human-readable text. A JSON text can represent a number, a boolean, a
-string, an array, an object, or a null, with slightly different grammar.
-For instance, a JSON text representing a string must escape all characters
-and enclose the string in double quotes, such as ``"123\n"``, whereas a JSON
-text representing a number does not need to, such as ``123``. A JSON text
-representing an array must enclose the array elements in square brackets,
-such as ``[1,2,3]``. More detailed grammar can be found in
-`this JSON introduction`_.
+    Returns all the keys of the outermost JSON object as an array if a valid JSON object is given.  If it is any other valid JSON string, an invalid JSON string or an empty string, the function returns null. ::
 
-.. _this JSON introduction: https://www.json.org
-
-JSON Functions
---------------
-
-.. spark:function:: get_json_object(json, path) -> varchar
-
-    Extracts a json object from path::
-
-        SELECT get_json_object('{"a":"b"}', '$.a'); -- b
\ No newline at end of file
+        SELECT json_object_keys('{}'); -- []
+        SELECT json_object_keys('{"name": "Alice", "age": 5, "id": "001"}'); -- ['name', 'age', 'id']
+        SELECT json_object_keys(''); -- NULL
+        SELECT json_object_keys(1); -- NULL
+        SELECT json_object_keys('"hello"'); -- NULL
diff --git a/velox/docs/functions/spark/map.rst b/velox/docs/functions/spark/map.rst
index 9234c377a7fdc..74735e9d5fe08 100644
--- a/velox/docs/functions/spark/map.rst
+++ b/velox/docs/functions/spark/map.rst
@@ -6,18 +6,19 @@ Map Functions
 
     Returns value for given ``key``, or ``NULL`` if the key is not contained in the map.
 
-.. spark:function:: map() -> map(unknown, unknown)
+.. spark:function:: map(K, V, K, V, ...) -> map(K,V)
 
-    Returns an empty map. ::
+    Returns a map created using the given key/value pairs. Keys are not allowed to be null. ::
 
-        SELECT map(); -- {}
+        SELECT map(1, 2, 3, 4); -- {1 -> 2, 3 -> 4}
 
-.. spark:function:: map(array(K), array(V)) -> map(K,V)
-   :noindex:
+        SELECT map(array(1, 2), array(3, 4)); -- {[1, 2] -> [3, 4]}
+
+.. spark:function:: map_entries(map(K,V)) -> array(row(K,V))
 
-    Returns a map created using the given key/value arrays. Duplicate map key will cause exception. ::
+    Returns an array of all entries in the given map. ::
 
-        SELECT map(ARRAY[1,3], ARRAY[2,4]); -- {1 -> 2, 3 -> 4}
+        SELECT map_entries(MAP(ARRAY[1, 2], ARRAY['x', 'y'])); -- [ROW(1, 'x'), ROW(2, 'y')]
 
 .. spark:function:: map_filter(map(K,V), func) -> map(K,V)
 
@@ -32,9 +33,35 @@ Map Functions
 
         SELECT map_from_arrays(array(1.0, 3.0), array('2', '4')); -- {1.0 -> 2, 3.0 -> 4}
 
-.. spark:function:: size(map(K,V)) -> bigint
+.. spark:function:: map_keys(x(K,V)) -> array(K)
+
+    Returns all the keys in the map ``x``.
+
+.. spark:function:: map_values(x(K,V)) -> array(V)
+
+    Returns all the values in the map ``x``.
+
+.. spark:function:: map_zip_with(map(K,V1), map(K,V2), function(K,V1,V2,V3)) -> map(K,V3)
+
+    Merges the two given maps into a single map by applying ``function`` to the pair of values with the same key.
+    For keys only presented in one map, NULL will be passed as the value for the missing key. ::
+
+        SELECT map_zip_with(MAP(ARRAY[1, 2, 3], ARRAY['a', 'b', 'c']), -- {1 -> ad, 2 -> be, 3 -> cf}
+                            MAP(ARRAY[1, 2, 3], ARRAY['d', 'e', 'f']),
+                            (k, v1, v2) -> concat(v1, v2));
+        SELECT map_zip_with(MAP(ARRAY['k1', 'k2'], ARRAY[1, 2]), -- {k1 -> ROW(1, null), k2 -> ROW(2, 4), k3 -> ROW(null, 9)}
+                            MAP(ARRAY['k2', 'k3'], ARRAY[4, 9]),
+                            (k, v1, v2) -> (v1, v2));
+        SELECT map_zip_with(MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 8, 27]), -- {a -> a1, b -> b4, c -> c9}
+                            MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]),
+                            (k, v1, v2) -> k || CAST(v1/v2 AS VARCHAR));
+
+.. spark:function:: size(map(K,V), legacySizeOfNull) -> integer
    :noindex:
 
-    Returns the size of the input map. Returns null for null input
-    if :doc:`spark.legacy_size_of_null <../../configs>` is set to false.
-    Otherwise, returns -1 for null input.
+    Returns the size of the input map. Returns null for null input if ``legacySizeOfNull``
+    is set to false. Otherwise, returns -1 for null input. ::
+
+        SELECT size(map(array(1, 2), array(3, 4)), true); -- 2
+        SELECT size(NULL, true); -- -1
+        SELECT size(NULL, false); -- NULL
diff --git a/velox/docs/functions/spark/math.rst b/velox/docs/functions/spark/math.rst
index 06b671c27ee1c..99b23144d1d13 100644
--- a/velox/docs/functions/spark/math.rst
+++ b/velox/docs/functions/spark/math.rst
@@ -14,10 +14,26 @@ Mathematical Functions
 
     Returns inverse hyperbolic cosine of ``x``.
 
+.. spark:function:: asin(x) -> double
+
+    Returns the arc sine of ``x``.
+
 .. spark:function:: asinh(x) -> double
 
     Returns inverse hyperbolic sine of ``x``.
 
+.. spark:function:: atan(x) -> double
+
+    Returns the arc tangent of ``x``.
+
+.. spark:function:: atan2(y, x) -> double
+
+    Returns the arc tangent of ``y / x``. For compatibility with Spark, returns 0 for the following corner cases:
+    * atan2(0.0, 0.0)
+    * atan2(-0.0, -0.0)
+    * atan2(-0.0, 0.0)
+    * atan2(0.0, -0.0)
+
 .. spark:function:: atanh(x) -> double
 
     Returns inverse hyperbolic tangent of ``x``.
@@ -25,7 +41,21 @@ Mathematical Functions
 .. spark:function:: add(x, y) -> [same as x]
 
     Returns the result of adding x to y. The types of x and y must be the same.
-    For integral types, overflow results in an error. Corresponds to sparks's operator ``+``.
+    Corresponds to sparks's operator ``+``.
+
+.. spark:function:: add(x, y) -> decimal
+
+    Returns the result of adding ``x`` to ``y``. The argument types should be DECIMAL, and can have different precisions and scales.
+    Fast path is implemented for cases that should not overflow. For the others, the whole parts and fractional parts of input decimals are added separately and combined finally.
+    The result type is calculated with the max precision of input precisions, the max scale of input scales, and one extra digit for possible carrier.
+    Overflow results in null output. Corresponds to Spark's operator ``+``.
+    
+    ::
+
+        SELECT CAST(1.1232100 as DECIMAL(38, 7)) + CAST(1 as DECIMAL(10, 0)); -- DECIMAL(38, 6) 2.123210
+        SELECT CAST(-999999999999999999999999999.999 as DECIMAL(30, 3)) + CAST(-999999999999999999999999999.999 as DECIMAL(30, 3)); -- DECIMAL(31, 3) -1999999999999999999999999999.998
+        SELECT CAST(99999999999999999999999999999999.99998 as DECIMAL(38, 6)) + CAST(-99999999999999999999999999999999.99999 as DECIMAL(38, 5)); -- DECIMAL(38, 6) -0.000010
+        SELECT CAST(-99999999999999999999999999999999990.0 as DECIMAL(38, 3)) + CAST(-0.00001 as DECIMAL(38, 7)); -- DECIMAL(38, 6) NULL
 
 .. spark:function:: bin(x) -> varchar
 
@@ -36,6 +66,30 @@ Mathematical Functions
     Returns ``x`` rounded up to the nearest integer.  
     Supported types are: BIGINT and DOUBLE.
 
+.. function:: checked_add(x, y) -> [same as x]
+
+    Returns the result of adding x to y. The types of x and y must be the same.
+    For integral types, overflow results in an error. Corresponds to Spark's operator ``+`` with ``failOnError`` as true.
+
+.. function:: checked_divide(x, y) -> [same as x]
+
+    Returns the results of dividing x by y. The types of x and y must be the same.
+    Division by zero results in an error. Corresponds to Spark's operator ``/`` with ``failOnError`` as true.
+
+.. function:: checked_multiply(x, y) -> [same as x]
+
+    Returns the result of multiplying x by y. The types of x and y must be the same.
+    For integral types, overflow results in an error. Corresponds to Spark's operator ``*`` with ``failOnError`` as true.
+
+.. function:: checked_subtract(x, y) -> [same as x]
+
+    Returns the result of subtracting y from x. The types of x and y must be the same.
+    For integral types, overflow results in an error. Corresponds to Spark's operator ``-`` with ``failOnError`` as true.
+
+.. spark:function:: cos(x) -> double
+
+    Returns the cosine of ``x``.
+
 .. spark:function:: cosh(x) -> double
 
     Returns the hyperbolic cosine of ``x``.
@@ -48,33 +102,80 @@ Mathematical Functions
 
     Returns the cosecant of ``x``.
 
+.. spark:function:: degrees(x) -> double
+
+    Converts angle x in radians to degrees.
+
 .. spark:function:: divide(x, y) -> double
 
     Returns the results of dividing x by y. Performs floating point division.
+    Supported type is DOUBLE.
     Corresponds to Spark's operator ``/``. ::
 
         SELECT 3 / 2; -- 1.5
         SELECT 2L / 2L; -- 1.0
         SELECT 3 / 0; -- NULL
 
+.. spark:function:: divide(x, y) -> decimal
+
+    Returns the results of dividing x by y.
+    Supported type is DECIMAL which can be different precision and scale.
+    Performs floating point division.
+    The result type depends on the precision and scale of x and y.
+    Overflow results return null. Corresponds to Spark's operator ``/``. ::
+
+        SELECT CAST(1 as DECIMAL(17, 3)) / CAST(2 as DECIMAL(17, 3)); -- decimal 0.500000000000000000000
+        SELECT CAST(1 as DECIMAL(20, 3)) / CAST(20 as DECIMAL(20, 2)); -- decimal 0.0500000000000000000
+        SELECT CAST(1 as DECIMAL(20, 3)) / CAST(0 as DECIMAL(20, 3)); -- NULL
+
 .. spark:function:: exp(x) -> double
 
     Returns Euler's number raised to the power of ``x``.
 
+.. spark:function:: expm1(x) -> double
+
+    Returns Euler's number raised to the power of ``x``, minus 1, which is ``exp(x) - 1`` in math. This function expm1(x) is more accurate than ``exp(x) - 1``, when ``x`` is close to zero.
+    If the argument is NaN, the result is NaN.
+    If the argument is positive infinity, then the result is positive infinity.
+    If the argument is negative infinity, then the result is -1.0.
+    If the argument is zero, then the result is a zero with the same sign as the argument.
+
 .. spark:function:: floor(x) -> [same as x]
 
     Returns ``x`` rounded down to the nearest integer.
     Supported types are: BIGINT and DOUBLE.
 
+.. spark:function:: hex(x) -> varchar
+
+    Converts ``x`` to hexadecimal.
+    Supported types are: BIGINT, VARBINARY and VARCHAR.
+    If the argument is a VARCHAR or VARBINARY, the result is string where each input byte is represented using 2 hex characters.
+    If the argument is a positive BIGINT, the result is a hex representation of the number (up to 16 characters),
+    if the argument is a negative BIGINT, the result is a hex representation of the number which will be treated as two's complement. ::
+
+        SELECT hex("Spark SQL"); -- 537061726B2053514C
+        SELECT hex(17); -- 11
+        SELECT hex(-1); -- FFFFFFFFFFFFFFFF
+
+
 .. spark:function:: hypot(a, b) -> double
 
     Returns the square root of `a` squared plus `b` squared.
 
+.. spark:function:: isnan(x) -> boolean
+
+    Returns true if x is Nan, or false otherwise. Returns false is x is NULL.
+    Supported types are: REAL, DOUBLE.
+
+.. spark:function:: log(base, expr) -> double
 
-.. function:: log1p(x) -> double
+    Returns the logarithm of ``expr`` with ``base``.
+    Returns NULL if either ``expr`` or ``base`` is less than or equal to 0.
+
+.. spark:function:: log1p(x) -> double
 
     Returns the natural logarithm of the “given value ``x`` plus one”.
-    Return NULL if x is less than or equal to -1.
+    Returns NULL if x is less than or equal to -1.
 
 .. spark:function:: log2(x) -> double
 
@@ -87,7 +188,18 @@ Mathematical Functions
 .. spark:function:: multiply(x, y) -> [same as x]
 
     Returns the result of multiplying x by y. The types of x and y must be the same.
-    For integral types, overflow results in an error. Corresponds to Spark's operator ``*``.
+    Corresponds to Spark's operator ``*``.
+
+.. spark:function:: multiply(x, y) -> [decimal]
+
+    Returns the result of multiplying x by y. The types of x and y must be decimal which can be different precision and scale.
+    The result type depends on the precision and scale of x and y.
+    Overflow results return null. Corresponds to Spark's operator ``*``. ::
+
+        SELECT CAST(1 as DECIMAL(17, 3)) * CAST(2 as DECIMAL(17, 3)); -- decimal 2.000000
+        SELECT CAST(1 as DECIMAL(20, 3)) * CAST(20 as DECIMAL(20, 2)); -- decimal 20.00000
+        SELECT CAST(1 as DECIMAL(20, 3)) * CAST(0 as DECIMAL(20, 3)); -- decimal 0.000000
+        SELECT CAST(201e-38 as DECIMAL(38, 38)) * CAST(301e-38 as DECIMAL(38, 38)); -- decimal 0.0000000000000000000000000000000000000
 
 .. spark:function:: not(x) -> boolean
 
@@ -100,7 +212,7 @@ Mathematical Functions
 .. spark:function:: pmod(n, m) -> [same as n]
 
     Returns the positive remainder of n divided by m.
-    Supported types are: TINYINT, SMALLINT, INTEGER, BIGINT, FLOAT and DOUBLE.
+    Supported types are: TINYINT, SMALLINT, INTEGER, BIGINT, REAL and DOUBLE.
 
 .. spark:function:: power(x, p) -> double
 
@@ -112,14 +224,13 @@ Mathematical Functions
 
         SELECT rand(); -- 0.9629742951434543
 
-.. spark:function:: rand(seed, partitionIndex) -> double
+.. spark:function:: rand(seed) -> double
 
     Returns a random value with uniformly distributed values in [0, 1) using a seed formed
-    by combining user-specified ``seed`` and framework provided ``partitionIndex``. The
+    by combining user-specified ``seed`` and the configuration `spark.partition_id`. The
     framework is responsible for deterministic partitioning of the data and assigning unique
-    ``partitionIndex`` to each thread (in a deterministic way).
-    ``seed`` must be constant. NULL ``seed`` is identical to zero ``seed``. ``partitionIndex``
-    cannot be NULL. ::
+    `spark.partition_id` to each thread (in a deterministic way) .
+    ``seed`` must be constant. NULL ``seed`` is identical to zero ``seed``. ::
 
         SELECT rand(0);    -- 0.5488135024422883
         SELECT rand(NULL); -- 0.5488135024422883
@@ -128,18 +239,28 @@ Mathematical Functions
 
     An alias for ``rand()``.
 
-.. spark:function:: random(seed, partitionIndex) -> double
+.. spark:function:: random(seed) -> double
 
-    An alias for ``rand(seed, partitionIndex)``.
+    An alias for ``rand(seed)``.
 
 .. spark:function:: remainder(n, m) -> [same as n]
 
     Returns the modulus (remainder) of ``n`` divided by ``m``. Corresponds to Spark's operator ``%``.
+    Supported types are: TINYINT, SMALLINT, INTEGER, BIGINT, REAL and DOUBLE.
+
+.. spark:function:: rint(x) -> double
+
+    Returns the double value that is closest in value to the argument and is 
+    equal to a mathematical integer.
+    Returns ``x`` if ``x`` is a positive or negative infinity or a NaN. ::
+
+        SELECT rint(12.3456); -- 12.0
 
 .. spark:function:: round(x, d) -> [same as x]
 
     Returns ``x`` rounded to ``d`` decimal places using HALF_UP rounding mode. 
     In HALF_UP rounding, the digit 5 is rounded up.
+    Supported types for ``x`` are integral and floating point types.
 
 .. spark:function:: sec(x) -> double
 
@@ -152,8 +273,55 @@ Mathematical Functions
 .. spark:function:: subtract(x, y) -> [same as x]
 
     Returns the result of subtracting y from x. The types of x and y must be the same.
-    For integral types, overflow results in an error. Corresponds to Spark's operator ``-``.
+    Corresponds to Spark's operator ``-``.
+
+.. spark:function:: subtract(x, y) -> decimal
+
+    Returns the result of subtracting ``y`` from ``x``. Reuses the logic of add function for decimal type.
+    Corresponds to Spark's operator ``-``.
+    
+    ::
+
+        SELECT CAST(1.1232100 as DECIMAL(38, 7)) - CAST(1 as DECIMAL(10, 0)); -- DECIMAL(38, 6) 0.123210
+        SELECT CAST(-999999999999999999999999999.999 as DECIMAL(30, 3)) - CAST(-999999999999999999999999999.999 as DECIMAL(30, 3)); -- DECIMAL(31, 3) 0.000
+        SELECT CAST(99999999999999999999999999999999.99998 as DECIMAL(38, 6)) - CAST(-0.00001 as DECIMAL(38, 5)); -- DECIMAL(38, 6) 99999999999999999999999999999999.999990
+        SELECT CAST(-99999999999999999999999999999999990.0 as DECIMAL(38, 3)) - CAST(0.00001 as DECIMAL(38, 7)); -- DECIMAL(38, 6) NULL
 
 .. spark:function:: unaryminus(x) -> [same as x]
 
     Returns the negative of `x`.  Corresponds to Spark's operator ``-``.
+
+.. spark:function:: unhex(x) -> varbinary
+
+    Converts hexadecimal varchar ``x`` to varbinary.
+    ``x`` is considered case insensitive and expected to contain only hexadecimal characters 0-9 and A-F.
+    If ``x`` contains non-hexadecimal character, the function returns NULL.
+    When ``x`` contains an even number of characters, each pair is converted to a single byte. The number of bytes in the result is half the number of bytes in the input.
+    When ``x`` contains an odd number of characters, the first character is decoded into the first byte of the result and the remaining pairs of characters are decoded into subsequent bytes. This behavior matches Spark 3.3.2 and newer. ::
+
+        SELECT unhex("23"); -- #
+        SELECT unhex("f"); -- \x0F
+        SELECT unhex("b2323"); -- \x0B##
+        SELECT unhex("G"); -- NULL
+        SELECT unhex("G23"); -- NULL
+
+.. spark:function:: width_bucket(x, bound1, bound2, n) -> bigint
+
+    Returns the zero-based bucket number to which ``x`` would be assigned in an equiwidth histogram with ``n`` buckets,
+    in the range ``bound1`` to ``bound2``.
+    `bound1` can be greater than `bound2`.
+    If `bound1` less than `bound2`, if `x` less than `bound1` return 0, if `x` greater than or equal to `bound2` return n + 1.
+    If `bound1` greater than `bound2`, if `x` greater than `bound1` return 0, if `x` less than or equal to `bound2` return n + 1.
+    `n` must be a positive integral value. `x`, `bound1`, and `bound2` cannot be NaN. `bound1`, and `bound2` must be finite.
+    `bound1` cannot equal `bound2`;
+    Otherwise, the function will return NULL.
+
+    ::
+        
+        SELECT width_bucket(-1.0, 0.0, 10.0, 5); -- 0
+        SELECT width_bucket(0.1, 0.0, 10.0, 5); -- 1
+        SELECT width_bucket(10.1, 0.0, 10.0, 5); -- 6
+        SELECT width_bucket(-1.0, 10.0, 0.0, 5); -- 6
+        SELECT width_bucket(0.1, 10.0, 0.0, 5); -- 5
+        SELECT width_bucket(10.1, 10.0, 0.0, 5); -- 0
+        SELECT width_bucket(10.1, 10.0, 10.0, 5); -- NULL
diff --git a/velox/docs/functions/spark/misc.rst b/velox/docs/functions/spark/misc.rst
new file mode 100644
index 0000000000000..0238d8018adc2
--- /dev/null
+++ b/velox/docs/functions/spark/misc.rst
@@ -0,0 +1,38 @@
+====================================
+Miscellaneous Functions
+====================================
+
+.. spark:function:: monotonically_increasing_id() -> bigint
+
+    Returns monotonically increasing 64-bit integers. The generated ID is
+    guaranteed to be monotonically increasing and unique, but not consecutive.
+    The current implementation puts the partition ID in the upper 31 bits, and
+    the lower 33 bits represent the record number within each partition.
+    The assumption is that the data frame has less than 1 billion partitions,
+    and each partition has less than 8 billion records.
+    The function relies on partition IDs, which are provided by the framework
+    via the configuration 'spark.partition_id'.
+
+.. spark:function:: raise_error(message)
+
+    Throws a user error with the specified ``message``.
+    If ``message`` is NULL, throws a user error with empty message.
+
+.. spark:function:: spark_partition_id() -> integer
+
+    Returns the current partition id.
+    The framework provides partition id through the configuration
+    'spark.partition_id'.
+    It ensures deterministic data partitioning and assigns a unique partition
+    id to each task in a deterministic way. Consequently, this function is
+    marked as deterministic, enabling Velox to perform constant folding on it.
+
+.. spark:function:: uuid(seed) -> string
+
+    Returns an universally unique identifier (UUID) string. The value is
+    returned as a canonical UUID 36-character string. The UUID is generated
+    from Pseudo-Random Numbers with the seed by combining user-specified
+    ``seed`` and the configuration `spark.partition_id`.
+    ``seed`` must be constant. ::
+
+        SELECT uuid(0);    -- "8c7f0aac-97c4-4a2f-b716-a675d821ccc0"
diff --git a/velox/docs/functions/spark/regexp.rst b/velox/docs/functions/spark/regexp.rst
index 28b58cfa072a0..23778a5e2cd41 100644
--- a/velox/docs/functions/spark/regexp.rst
+++ b/velox/docs/functions/spark/regexp.rst
@@ -5,12 +5,45 @@ Regular Expression Functions
 Regular expression functions use RE2 as the regex engine. RE2 is fast, but
 supports only a subset of PCRE syntax and in particular does not support
 backtracking and associated features (e.g. back references).
+Java and RE2 regex output can diverage and users should be cautious that
+the patterns they are using perform similarly between RE2 and Java.
+For example, character class unions, intersections, and differences
+``([a[b]], [a&&[b]], [a&&[^b]])`` are intepreted as a single character class
+that contain ``[, &, and ^`` rather than union, intersection, or
+difference of the character classes.
+
+
 See https://github.com/google/re2/wiki/Syntax for more information.
 
+.. spark:function:: like(string, pattern) -> boolean
+                     like(string, pattern, escape) -> boolean
+
+    Evaluates if the ``string`` matches the ``pattern``. Patterns can contain
+    regular characters as well as wildcards. Wildcard characters can be escaped
+    using the single character specified for the ``escape`` parameter. Only ASCII
+    characters are supported for the ``escape`` parameter. Matching is case sensitive.
+
+    Note: The wildcard '%' represents 0, 1 or multiple characters and the
+    wildcard '_' represents exactly one character.
+
+    Note: Each function instance allow for a maximum of 20 regular expressions to
+    be compiled per thread of execution. Not all patterns require
+    compilation of regular expressions. Patterns 'hello', 'hello%', '_hello__%',
+    '%hello', '%__hello_', '%hello%', where 'hello', 'velox'
+    contains only regular characters and '_' wildcards are evaluated without
+    using regular expressions. Only those patterns that require the compilation of
+    regular expressions are counted towards the limit.
+
+        SELECT like('abc', '%b%'); -- true
+        SELECT like('a_c', '%#_%', '#'); -- true
+
 .. spark:function:: regexp_extract(string, pattern) -> varchar
 
     Returns the first substring matched by the regular expression ``pattern``
-    in ``string``. ::
+    in ``string``.
+
+    regexp_extract does not support column references for the ``pattern`` argument.
+    Patterns must be constant values. ::
 
         SELECT regexp_extract('1a 2b 14m', '\d+'); -- 1
 
@@ -18,10 +51,28 @@ See https://github.com/google/re2/wiki/Syntax for more information.
    :noindex:
 
     Finds the first occurrence of the regular expression ``pattern`` in
-    ``string`` and returns the capturing group number ``group``. ::
+    ``string`` and returns the capturing group number ``group``.
+
+    regexp_extract does not support column references for the ``pattern`` argument.
+    Patterns must be constant values. ::
 
         SELECT regexp_extract('1a 2b 14m', '(\d+)([a-z]+)', 2); -- 'a'
 
+.. spark:function:: regexp_extract_all(string, pattern) -> array(varchar):
+
+    Returns the substring(s) matched by the regular expression ``pattern``
+    in ``string``::
+
+        SELECT regexp_extract_all('1a 2b 14m', '\d+'); -- [1, 2, 14]
+
+.. spark:function:: regexp_extract_all(string, pattern, group) -> array(varchar):
+    :noindex:
+
+    Finds all occurrences of the regular expression ``pattern`` in
+    ``string`` and returns the capturing group number ``group``::
+
+        SELECT regexp_extract_all('1a 2b 14m', '(\d+)([a-z]+)', 2); -- ['a', 'b', 'm']
+
 .. spark:function:: rlike(string, pattern) -> boolean
 
     Evaluates the regular expression ``pattern`` and determines if it is
@@ -31,6 +82,52 @@ See https://github.com/google/re2/wiki/Syntax for more information.
     pattern only needs to be contained within ``string``, rather than
     needing to match all of ``string``. In other words, this performs a
     *contains* operation rather than a *match* operation. You can match
-    the entire string by anchoring the pattern using ``^`` and ``$``. ::
+    the entire string by anchoring the pattern using ``^`` and ``$``.
+
+    rlike does not support column references for the ``pattern`` argument.
+    Patterns must be constant values. ::
 
         SELECT rlike('1a 2b 14m', '\d+b'); -- true
+
+.. spark:function:: regexp_replace(string, pattern, overwrite) -> varchar
+
+    Replaces all substrings in ``string`` that match the regular expression ``pattern`` with the string ``overwrite``. If no match is found, the original string is returned as is.
+    There is a limit to the number of unique regexes to be compiled per function call, which is 20. If this limit is exceeded the function will throw an exception.
+
+    Parameters:
+
+    - **string**: The string to be searched.
+    - **pattern**: The regular expression pattern that is searched for in the string.
+    - **overwrite**: The string that replaces the substrings in ``string`` that match the ``pattern``.
+
+    Examples:
+
+    ::
+
+        SELECT regexp_replace('Hello, World!', 'l', 'L'); -- 'HeLLo, WorLd!'
+        SELECT regexp_replace('300-300', '(\\d+)-(\\d+)', '400'); -- '400'
+        SELECT regexp_replace('300-300', '(\\d+)', '400'); -- '400-400'
+
+.. spark:function:: regexp_replace(string, pattern, overwrite, position) -> varchar
+    :noindex:
+
+    Replaces all substrings in ``string`` that match the regular expression ``pattern`` with the string ``overwrite`` starting from the specified ``position``.  If no match is found, the original string is returned as is. If the ``position`` is less than one, the function throws an exception. If ``position`` is greater than the length of ``string``, the function returns the original ``string`` without any modifications.
+    There is a limit to the number of unique regexes to be compiled per function call, which is 20. If this limit is exceeded the function will throw an exception.
+
+    This function is 1-indexed, meaning the position of the first character is 1.
+    Parameters:
+
+    - **string**: The string to be searched.
+    - **pattern**: The regular expression pattern that is searched for in the string.
+    - **overwrite**: The string that replaces the substrings in ``string`` that match the ``pattern``.
+    - **position**: The position to start from in terms of number of characters. 1 means to start from the beginning of the string. 3 means to start from the 3rd character. Positions less than one, the function will throw an error. If ``position`` is greater than the length of ``string``, the function returns the original ``string`` without any modifications.
+
+    Examples:
+
+    ::
+
+        SELECT regexp_replace('Hello, World!', 'l', 'L', 6); -- 'Hello, WorLd!'
+
+        SELECT regexp_replace('Hello, World!', 'l', 'L', 5); -- 'Hello, World!'
+
+        SELECT regexp_replace('Hello, World!', 'l', 'L', 100); -- 'Hello, World!'
diff --git a/velox/docs/functions/spark/string.rst b/velox/docs/functions/spark/string.rst
index ed8c49b38de52..d241714601e6b 100644
--- a/velox/docs/functions/spark/string.rst
+++ b/velox/docs/functions/spark/string.rst
@@ -2,12 +2,23 @@
 String Functions
 ====================================
 
-Unless specified otherwise, all functions return NULL if at least one of the arguments is NULL.
+.. note::
+    
+    Unless specified otherwise, all functions return NULL if at least one of the arguments is NULL.
+    
+    These functions assume that input strings contain valid UTF-8 encoded Unicode code points.
+    The behavior is undefined if they are not.
 
 .. spark:function:: ascii(string) -> integer
 
     Returns unicode code point of the first character of ``string``. Returns 0 if ``string`` is empty.
 
+.. spark:function:: bit_length(string/binary) -> integer
+
+    Returns the bit length for the specified string column. ::
+        
+        SELECT bit_length('123'); -- 24
+
 .. spark:function:: chr(n) -> varchar
 
     Returns the Unicode code point ``n`` as a single character string.
@@ -23,6 +34,39 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
         SELECT contains('Spark SQL', null); -- NULL
         SELECT contains(x'537061726b2053514c', x'537061726b'); -- true
 
+.. spark:function:: conv(number, fromBase, toBase) -> varchar
+
+    Converts ``number`` represented as a string from ``fromBase`` to ``toBase``.
+    ``fromBase`` must be an INTEGER value between 2 and 36 inclusively. ``toBase`` must
+    be an INTEGER value between 2 and 36 inclusively or between -36 and -2 inclusively.
+    Otherwise, returns NULL.
+    Returns a signed number if ``toBase`` is negative. Otherwise, returns an unsigned one.
+    Returns NULL if ``number`` is empty.
+    Skips leading spaces. ``number`` may contain other characters not valid for ``fromBase``.
+    All characters starting from the first invalid character till the end of the string are
+    ignored. Only converts valid characters even though ``fromBase`` = ``toBase``. Returns
+    '0' if no valid character is found. ::
+
+        SELECT conv('100', 2, 10); -- '4'
+        SELECT conv('-10', 16, -10); -- '-16'
+        SELECT conv("-1", 10, 16); -- 'FFFFFFFFFFFFFFFF'
+        SELECT conv("123", 10, 39); -- NULL
+        SELECT conv('', 16, 10); -- NULL
+        SELECT conv(' ', 2, 10); -- NULL
+        SELECT conv("11", 10, 16); -- 'B'
+        SELECT conv("11ABC", 10, 16); -- 'B'
+        SELECT conv("11abc", 10, 10); -- '11'
+        SELECT conv('H016F', 16, 10); -- '0'
+
+.. spark:function:: empty2null(input) -> varchar
+
+    Returns NULL if ``input`` is empty. Otherwise, returns ``input``.
+    Note: it's an internal Spark function used to convert empty value of a partition column,
+    which is then converted to Hive default partition value ``__HIVE_DEFAULT_PARTITION__``. ::
+
+        SELECT empty2null(''); -- NULL
+        SELECT empty2null('abc'); -- 'abc'
+
 .. spark:function:: endswith(left, right) -> boolean
 
     Returns true if 'left' ends with 'right'. Otherwise, returns false. ::
@@ -31,6 +75,20 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
         SELECT endswith('js SQL', 'js'); -- false
         SELECT endswith('js SQL', NULL); -- NULL
 
+.. spark:function:: find_in_set(str, strArray) -> integer
+
+    Returns 1-based index of the given string ``str`` in the comma-delimited list ``strArray``.
+    Returns 0, if the string was not found or if the given string ``str`` contains a comma. ::
+
+        SELECT find_in_set('ab', 'abc,b,ab,c,def'); -- 3
+        SELECT find_in_set('ab,', 'abc,b,ab,c,def'); -- 0
+        SELECT find_in_set('dfg', 'abc,b,ab,c,def'); -- 0
+        SELECT find_in_set('', ''); -- 1
+        SELECT find_in_set('', '123,'); -- 2
+        SELECT find_in_set('', ',123'); -- 1
+        SELECT find_in_set(NULL, ',123'); -- NULL
+        SELECT find_in_set("abc", NULL); -- NULL
+
 .. spark:function:: instr(string, substring) -> integer
 
     Returns the starting position of the first instance of ``substring`` in
@@ -45,6 +103,15 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
 
     Returns the length of ``string`` in characters.
 
+.. spark:function:: levenshtein(string1, string2[, threshold]) -> integer
+
+    Returns the `Levenshtein distance <https://en.wikipedia.org/wiki/Levenshtein_distance>`_ between the two given strings.
+    If the provided ``threshold`` is negative, or the levenshtein distance exceeds ``threshold``, returns -1. ::
+
+        SELECT levenshtein('kitten', 'sitting'); -- 3
+        SELECT levenshtein('kitten', 'sitting', 10); -- 3
+        SELECT levenshtein('kitten', 'sitting', 2); -- -1
+
 .. spark:function:: lower(string) -> string
 
     Returns string with all characters changed to lowercase. ::
@@ -77,6 +144,30 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
 
         SELECT ltrim('ps', 'spark'); -- "ark"
 
+.. spark:function:: mask(string[, upperChar, lowerChar, digitChar, otherChar]) -> string
+
+    Returns a masked version of the input ``string``.
+    ``string``: string value to mask.
+    ``upperChar``: A single character string used to substitute upper case characters. The default is 'X'. If NULL, upper case characters remain unmasked.
+    ``lowerChar``: A single character string used to substitute lower case characters. The default is 'x'. If NULL, lower case characters remain unmasked.
+    ``digitChar``: A single character string used to substitute digits. The default is 'n'. If NULL, digits remain unmasked.
+    ``otherChar``: A single character string used to substitute any other character. The default is NULL, which leaves these characters unmasked.
+    Any invalid UTF-8 characters present in the input string will be treated as a single other character. ::
+
+        SELECT mask('abcd-EFGH-8765-4321');  -- "xxxx-XXXX-nnnn-nnnn"
+        SELECT mask('abcd-EFGH-8765-4321', 'Q');  -- "xxxx-QQQQ-nnnn-nnnn"
+        SELECT mask('AbCD123-@$#');  -- "XxXXnnn-@$#"
+        SELECT mask('AbCD123-@$#', 'Q');  -- "QxQQnnn-@$#"
+        SELECT mask('AbCD123-@$#', 'Q', 'q');  -- "QqQQnnn-@$#"
+        SELECT mask('AbCD123-@$#', 'Q', 'q', 'd');  -- "QqQQddd-@$#"
+        SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o');  -- "QqQQdddoooo"
+        SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o'); -- "AqCDdddoooo"
+        SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o'); -- "AbCDdddoooo"
+        SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o'); -- "AbCD123oooo"
+        SELECT mask(NULL, NULL, NULL, NULL, 'o'); -- NULL
+        SELECT mask(NULL); -- NULL
+        SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL); -- "AbCD123-@$#"
+
 .. spark:function:: overlay(input, replace, pos, len) -> same as input
 
     Replace a substring of ``input`` starting at ``pos`` character with ``replace`` and
@@ -97,12 +188,35 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
         SELECT overlay('Spark SQL', 'tructured', 2, 4); -- "Structured SQL"
         SELECT overlay('Spark SQL', '_', -6, 3); -- "_Sql"
 
-.. spark:function:: replace(string, search, replace) -> string
+.. spark:function:: repeat(input, n) -> varchar
+
+    Returns the string which repeats ``input`` ``n`` times. 
+    Result size must be less than or equal to 1MB.
+    If ``n`` is less than or equal to 0, empty string is returned. ::
+
+        SELECT repeat('123', 2); -- 123123
 
-    Replaces all occurrences of `search` with `replace`. ::
+.. spark:function:: replace(input, replaced) -> varchar
 
+    Removes all instances of ``replaced`` from ``input``.
+    If ``replaced`` is an empty string, returns the original ``input`` string. ::
+
+        SELECT replace('ABCabc', ''); -- ABCabc
+        SELECT replace('ABCabc', 'bc'); -- ABCc
+
+.. spark:function:: replace(input, replaced, replacement) -> varchar
+
+    Replaces all instances of ``replaced`` with ``replacement`` in ``input``.
+    If ``replaced`` is an empty string, returns the original ``input`` string. ::
+
+        SELECT replace('ABCabc', '', 'DEF'); -- ABCabc
+        SELECT replace('ABCabc', 'abc', ''); -- ABC
         SELECT replace('ABCabc', 'abc', 'DEF'); -- ABCDEF
 
+.. spark:function:: reverse(string) -> varchar
+
+    Returns input string with characters in reverse order.
+
 .. spark:function:: rpad(string, len, pad) -> string
     
     Returns ``string``, right-padded with ``pad`` to a length of ``len``. 
@@ -129,22 +243,33 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
 
         SELECT rtrim('kr', 'spark'); -- "spa"
 
-.. spark:function:: split(string, delimiter) -> array(string)
+.. spark:function:: soundex(string) -> string
 
-    Splits ``string`` on ``delimiter`` and returns an array. ::
+    Returns `Soundex code <https://en.wikipedia.org/wiki/Soundex>`_ of the string. If first character of ``string`` is not
+    a letter, ``string`` is returned. ::
 
-        SELECT split('oneAtwoBthreeC', '[ABC]'); -- ["one","two","three",""]
-        SELECT split('one', ''); -- ["o", "n", "e", ""]
-        SELECT split('one', '1'); -- ["one"]
+        SELECT soundex('Miller'); -- "M460"
 
-.. spark:function:: split(string, delimiter, limit) -> array(string)
-   :noindex:
+.. spark:function:: split(string, delimiter[, limit]) -> array(string)
 
-    Splits ``string`` on ``delimiter`` and returns an array of size at most ``limit``. ::
+    Splits ``string`` around occurrences that match ``delimiter`` and returns an array with a length of
+    at most ``limit``. ``delimiter`` is a string representing regular expression. ``limit`` is an integer
+    which controls the number of times the regex is applied. By default, ``limit`` is -1. When ``limit`` > 0,
+    the resulting array's length will not be more than ``limit``, and the resulting array's last entry will
+    contain all input beyond the last matched regex. When ``limit`` <= 0, ``regex`` will be applied as many
+    times as possible, and the resulting array can be of any size. When ``delimiter`` is empty, if ``limit``
+    is smaller than the size of ``string``, the resulting array only contains ``limit`` number of single characters
+    splitting from ``string``, if ``limit`` is not provided or is larger than the size of ``string``, the resulting 
+    array contains all the single characters of ``string`` and does not include an empty tail character.
+    The split function align with vanilla spark 3.4+ split function. ::
 
-        SELECT split('oneAtwoBthreeC', '[ABC]', -1); -- ["one","two","three",""]
-        SELECT split('oneAtwoBthreeC', '[ABC]', 0); -- ["one", "two", "three", ""]
+        SELECT split('oneAtwoBthreeC', '[ABC]'); -- ["one","two","three",""]
         SELECT split('oneAtwoBthreeC', '[ABC]', 2); -- ["one","twoBthreeC"]
+        SELECT split('oneAtwoBthreeC', '[ABC]', 5); -- ["one","two","three",""]
+        SELECT split('one', '1'); -- ["one"]
+        SELECT split('abcd', ''); -- ["a","b","c","d"]
+        SELECT split('abcd', '', 3); -- ["a","b","c"]
+        SELECT split('abcd', '', 5); -- ["a","b","c","d"]
 
 .. spark:function:: startswith(left, right) -> boolean
 
@@ -154,6 +279,20 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
         SELECT startswith('js SQL', 'SQL'); -- false
         SELECT startswith('js SQL', null); -- NULL
 
+.. spark:function:: str_to_map(string, entryDelimiter, keyValueDelimiter) -> map(string, string)
+
+    Returns a map by splitting ``string`` into entries with ``entryDelimiter`` and splitting
+    each entry into key/value with ``keyValueDelimiter``.
+    ``entryDelimiter`` and ``keyValueDelimiter`` must be constant strings with single ascii
+    character. Allows ``keyValueDelimiter`` not found when splitting an entry. Throws exception
+    when duplicate map keys are found for single row's result, consistent with Spark's default
+    behavior. ::
+
+        SELECT str_to_map('a:1,b:2,c:3', ',', ':'); -- {"a":"1","b":"2","c":"3"}
+        SELECT str_to_map('a', ',', ':'); -- {"a":NULL}
+        SELECT str_to_map('', ',', ':'); -- {"":NULL}
+        SELECT str_to_map('a:1,b:2,c:3', ',', ','); -- {"a:1":NULL,"b:2":NULL,"c:3":NULL}
+
 .. spark:function:: substring(string, start) -> varchar
 
     Returns the rest of ``string`` from the starting position ``start``.
@@ -179,6 +318,30 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
         SELECT substring('Spark SQL', -10, 3); -- "Sp"
         SELECT substring('Spark SQL', -20, 3); -- ""
 
+.. spark:function:: substring_index(string, delim, count) -> [same as string]
+
+    Returns the substring from ``string`` before ``count`` occurrences of the delimiter ``delim``.
+    Here the ``string`` can be VARCHAR or VARBINARY and return type matches type of ``string``.
+    If ``count`` is positive, returns everything to the left of the final delimiter
+    (counting from the left). If ``count`` is negative, returns everything to the right
+    of the final delimiter (counting from the right). If ``count`` is 0, returns empty string.
+    If ``delim`` is not found or found fewer times than ``count``, returns the original input string.
+    ``delim`` is case-sensitive. It also takes into account overlapping strings. ::
+
+        SELECT substring_index('Spark.SQL', '.', 1); -- "Spark"
+        SELECT substring_index('Spark.SQL', '.', 0); -- ""
+        SELECT substring_index('Spark.SQL', '.', -1); -- "SQL"
+        SELECT substring_index('TEST.Spark.SQL', '.',2); -- "TEST.Spark"
+        SELECT substring_index('TEST.Spark.SQL', '', 0); -- ""
+        SELECT substring_index('TEST.Spark.SQL', '.', -2); -- "Spark.SQL"
+        SELECT substring_index('TEST.Spark.SQL', '.', 10); -- "TEST.Spark.SQL"
+        SELECT substring_index('TEST.Spark.SQL', '.', -12); -- "TEST.Spark.SQL"
+        SELECT substring_index('aaaaa', 'aa', 2); -- "a"
+        SELECT substring_index('aaaaa', 'aa', -4); -- "aaa"
+        SELECT substring_index('aaaaa', 'aa', 0); -- ""
+        SELECT substring_index('aaaaa', 'aa', 5); -- "aaaaa"
+        SELECT substring_index('aaaaa', 'aa', -5); -- "aaaaa"
+
 .. spark:function:: translate(string, match, replace) -> varchar
 
     Returns a new translated string. It translates the character in ``string`` by a
@@ -188,7 +351,9 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
     size is larger than ``replace's``, the extra characters in ``match`` will be
     removed from ``string``. In addition, this function only considers the first
     occurrence of a character in ``match`` and uses its corresponding character in
-    ``replace`` for translation. ::
+    ``replace`` for translation. 
+    Any invalid UTF-8 characters present in the input string will be treated as a 
+    single character.::
 
         SELECT translate('spark', 'sa', '12');  -- "1p2rk"
         SELECT translate('spark', 'sa', '1');   -- "1prk"
@@ -213,4 +378,4 @@ Unless specified otherwise, all functions return NULL if at least one of the arg
 
     Returns string with all characters changed to uppercase. ::
 
-        SELECT upper('SparkSql'); -- SPARKSQL
\ No newline at end of file
+        SELECT upper('SparkSql'); -- SPARKSQL
diff --git a/velox/docs/functions/spark/url.rst b/velox/docs/functions/spark/url.rst
new file mode 100644
index 0000000000000..a6eaf70edba9a
--- /dev/null
+++ b/velox/docs/functions/spark/url.rst
@@ -0,0 +1,66 @@
+=============
+URL Functions
+=============
+
+Introduction
+------------
+
+The URL extraction functions extract components from HTTP URLs (or any valid URIs conforming to `RFC 3986 <https://tools.ietf.org/html/rfc3986.html>`_). The following syntax is supported:
+
+.. code-block:: bash
+
+    [protocol:][//host[:port]][path][?query][#fragment]
+
+
+The extracted components do not contain URI syntax separators such as ``:`` , ``?`` and ``#``.
+
+Consider for example the below URI:
+
+.. code-block::
+
+    http://www.ics.uci.edu/pub/ietf/uri/?k1=v1#Related
+
+    scheme    = http
+    authority = www.ics.uci.edu
+    path      = /pub/ietf/uri/
+    query     = k1=v1
+    fragment  = Related
+
+
+Invalid URI's
+-------------
+
+Well formed URI's should not contain ascii whitespace. `Percent-encoded URI's <https://www.rfc-editor.org/rfc/rfc3986#section-2.1>`_ should be followed by two hexadecimal
+digits after the percent character "%". All the url extract functions will return null when passed an invalid uri.
+
+.. code-block::
+
+    # Examples of url functions with Invalid URI's.
+
+    # Invalid URI due to whitespace
+    SELECT url_extract_path('foo '); -- NULL (1 row)
+    SELECT url_extract_host('http://www.foo.com '); -- NULL (1 row)
+
+    # Invalid URI due to improper escaping of '%'
+    SELECT url_extract_path('https://www.ucu.edu.uy/agenda/evento/%%UCUrlCompartir%%'); -- NULL (1 row)
+    SELECT url_extract_host('https://www.ucu.edu.uy/agenda/evento/%%UCUrlCompartir%%'); -- NULL (1 row)
+
+Encoding Functions
+------------------
+
+.. spark:function:: url_encode(value) -> varchar
+
+    Escapes ``value`` by encoding it so that it can be safely included in
+    URL query parameter names and values:
+
+    * Alphanumeric characters are not encoded.
+    * The characters ``.``, ``-``, ``*`` and ``_`` are not encoded.
+    * The ASCII space character is encoded as ``+``.
+    * All other characters are converted to UTF-8 and the bytes are encoded
+      as the string ``%XX`` where ``XX`` is the uppercase hexadecimal
+      value of the UTF-8 byte.
+
+.. spark:function:: url_decode(value) -> varchar
+
+    Unescapes the URL encoded ``value``.
+    This function is the inverse of :spark:func:`url_encode`.
diff --git a/velox/docs/functions/spark/window.rst b/velox/docs/functions/spark/window.rst
index 50804d9ff5c18..2a4d7921c95a5 100644
--- a/velox/docs/functions/spark/window.rst
+++ b/velox/docs/functions/spark/window.rst
@@ -3,6 +3,7 @@ Window functions
 ================
 
 Spark window functions can be used to compute SQL window functions.
+More details about window functions can be found at :doc:`/develop/window`
 
 Value functions
 ---------------
@@ -29,3 +30,8 @@ Returns the rank of a value in a group of values. The rank is one plus the numbe
 
 Returns the rank of a value in a group of values. This is similar to rank(), except that tie values do not produce gaps in the sequence.
 
+.. spark:function:: ntile(n) -> integer
+
+Divides the rows for each window partition into n buckets ranging from 1 to at most ``n``. Bucket values will differ by at most 1. If the number of rows in the partition does not divide evenly into the number of buckets, then the remainder values are distributed one per bucket, starting with the first bucket.
+
+For example, with 6 rows and 4 buckets, the bucket values would be as follows: ``1 1 2 2 3 4``
diff --git a/velox/docs/index.rst b/velox/docs/index.rst
index 9bec57eb9c250..17d5ce21173d7 100644
--- a/velox/docs/index.rst
+++ b/velox/docs/index.rst
@@ -10,6 +10,7 @@ Velox Documentation
     functions
     spark_functions
     configs
+    monitoring
     bindings/python/README_generated_pyvelox
     develop
     programming-guide
diff --git a/velox/docs/monitoring.rst b/velox/docs/monitoring.rst
new file mode 100644
index 0000000000000..b92026f9b6373
--- /dev/null
+++ b/velox/docs/monitoring.rst
@@ -0,0 +1,9 @@
+**********
+Monitoring
+**********
+
+.. toctree::
+    :maxdepth: 1
+
+    monitoring/metrics.rst
+    monitoring/stats.rst
\ No newline at end of file
diff --git a/velox/docs/monitoring/metrics.rst b/velox/docs/monitoring/metrics.rst
new file mode 100644
index 0000000000000..53f256c6beb11
--- /dev/null
+++ b/velox/docs/monitoring/metrics.rst
@@ -0,0 +1,531 @@
+===============
+Runtime Metrics
+===============
+
+Runtime metrics are used to collect the metrics of important velox runtime events
+for monitoring purpose. The collected metrics can provide insights into the
+continuous availability and performance analysis of a Velox runtime system. For
+instance, the collected data can help automatically generate alerts at an
+outage. Velox provides a framework to collect the metrics which consists of
+three steps:
+
+**Define**: define the name and type for the metric through DEFINE_METRIC and
+DEFINE_HISTOGRAM_METRIC macros. DEFINE_HISTOGRAM_METRIC is used for histogram
+metric type and DEFINE_METRIC is used for the other types (see metric type
+definition below). BaseStatsReporter provides methods for metric definition.
+Register metrics during startup using registerVeloxMetrics() API.
+
+**Record**: record the metric data point using RECORD_METRIC_VALUE and
+RECORD_HISTOGRAM_METRIC_VALUE macros when the corresponding event happens.
+BaseStatsReporter provides methods for metric recording.
+
+**Export**: aggregates the collected data points based on the defined metrics,
+and periodically exports to the backend monitoring service, such as ODS used by
+Meta, Apache projects `OpenCensus <https://opencensus.io/>`_  and `Prometheus <https://prometheus.io/>`_ provided by OSS. A derived
+implementation of BaseStatsReporter is required to integrate with a specific
+monitoring service. The metric aggregation granularity and export interval are
+also configured based on the actual used monitoring service.
+
+Velox supports five metric types:
+
+**Count**: tracks the count of events, such as the number of query failures.
+
+**Sum**: tracks the sum of event data point values, such as sum of query scan
+read bytes.
+
+**Avg**: tracks the average of event data point values, such as average of query
+execution time.
+
+**Rate**: tracks the sum of event data point values per second, such as the
+number of shuffle requests per second.
+
+**Histogram**: tracks the distribution of event data point values, such as query
+execution time distribution. The histogram metric divides the entire data range
+into a series of adjacent equal-sized intervals or buckets, and then count how
+many data values fall into each bucket. DEFINE_HISTOGRAM_METRIC specifies the data
+range by min/max values, and the number of buckets. Any collected data value
+less than min is counted in min bucket, and any one larger than max is counted
+in max bucket. It also allows to specify the value percentiles to report for
+monitoring. This allows BaseStatsReporter and the backend monitoring service to
+optimize the aggregated data storage.
+
+Task Execution
+--------------
+.. list-table::
+   :widths: 40 10 50
+   :header-rows: 1
+
+   * - Metric Name
+     - Type
+     - Description
+   * - driver_yield_count
+     - Count
+     - The number of times that a driver has yielded from the thread when it
+       hits the per-driver cpu time slice limit if enforced.
+   * - driver_queue_time_ms
+     - Histogram
+     - The distribution of driver queue latency in range of [0, 10s] with
+       20 buckets. It is configured to report the latency at P50, P90, P99,
+       and P100 percentiles.
+   * - driver_exec_time_ms
+     - Histogram
+     - The distribution of driver execution time in range of [0, 30s] with
+       30 buckets. It is configured to report the latency at P50, P90, P99,
+       and P100 percentiles.
+
+Memory Management
+-----------------
+
+.. list-table::
+   :widths: 40 10 50
+   :header-rows: 1
+
+   * - Metric Name
+     - Type
+     - Description
+   * - cache_shrink_count
+     - Count
+     - The number of times that in-memory data cache has been shrunk under
+       memory pressure.
+   * - cache_shrink_ms
+     - Histogram
+     - The distribution of cache shrink latency in range of [0, 100s] with 10
+       buckets. It is configured to report the latency at P50, P90, P99, and
+       P100 percentiles.
+   * - memory_reclaim_count
+     - Count
+     - The count of operator memory reclaims.
+   * - memory_reclaim_exec_ms
+     - Histogram
+     - The distribution of memory reclaim execution time in range of [0, 600s]
+       with 20 buckets. It is configured to report latency at P50, P90, P99, and
+       P100 percentiles.
+   * - memory_reclaim_bytes
+     - Histogram
+     - The distribution of reclaimed bytes in range of [0, 4GB] with 64 buckets
+       and reports P50, P90, P99, and P100.
+   * - task_memory_reclaim_count
+     - Count
+     - The count of task memory reclaims.
+   * - task_memory_reclaim_wait_ms
+     - Histogram
+     - The distribution of task memory reclaim wait time in range of [0, 60s]
+       with 60 buckets. It is configured to report latency at P50, P90, P99,
+       and P100 percentiles.
+   * - task_memory_reclaim_exec_ms
+     - Histogram
+     - The distribution of task memory execution time in range of [0, 240s]
+       with 60 buckets. It is configured to report latency at P50, P90, P99,
+       and P100 percentiles.
+   * - task_memory_reclaim_wait_timeout_count
+     - Count
+     - The number of times that the task memory reclaim wait timeouts.
+   * - memory_non_reclaimable_count
+     - Count
+     - The number of times that the memory reclaim fails because the operator is executing a
+       non-reclaimable section where it is expected to have reserved enough memory to execute
+       without asking for more. Therefore, it is an indicator that the memory reservation
+       is not sufficient. It excludes counting instances where the operator is in a
+       non-reclaimable state due to currently being on-thread and running or being already
+       cancelled.
+   * - arbitrator_requests_count
+     - Count
+     - The number of times a memory arbitration request was initiated by a
+       memory pool attempting to grow its capacity.
+   * - arbitrator_local_arbitration_count
+     - Count
+     - The number of arbitration that reclaims the used memory from the query which initiates
+       the memory arbitration request itself. It ensures the memory arbitration request won't
+       exceed its per-query memory capacity limit.
+   * - arbitrator_global_arbitration_count
+     - Count
+     - The number of arbitration which ensures the total allocated query capacity won't exceed
+       the arbitrator capacity limit. It may or may not reclaim memory from the query which
+       initiate the memory arbitration request. This indicates the velox runtime doesn't have
+       enough memory to run all the queries at their peak memory usage. We have to trigger
+       spilling to let them run through completion.
+   * - arbitrator_slow_global_arbitration_count
+     - Count
+     - The number of global arbitration that reclaims used memory by slow disk spilling.
+   * - arbitrator_aborted_count
+     - Count
+     - The number of times a query level memory pool is aborted as a result of
+       a memory arbitration process. The memory pool aborted will eventually
+       result in a cancelling the original query.
+   * - arbitrator_failures_count
+     - Count
+     - The number of times a memory arbitration request failed. This may occur
+       either because the requester was terminated during the processing of
+       its request, the arbitration request would surpass the maximum allowed
+       capacity for the requester, or the arbitration process couldn't release
+       the requested amount of memory.
+   * - arbitrator_wait_time_ms
+     - Histogram
+     - The distribution of the amount of time an arbitration request stays in
+       arbitration queues and waits the arbitration r/w locks in range of [0, 600s]
+       with 20 buckets. It is configured to report the latency at P50, P90, P99,
+       and P100 percentiles.
+   * - arbitrator_arbitration_time_ms
+     - Histogram
+     - The distribution of the amount of time it take to complete a single
+       arbitration request stays queued in range of [0, 600s] with 20
+       buckets. It is configured to report the latency at P50, P90, P99,
+       and P100 percentiles.
+   * - arbitrator_free_capacity_bytes
+     - Average
+     - The average of total free memory capacity which is managed by the
+       memory arbitrator.
+   * - arbitrator_free_reserved_capacity_bytes
+     - Average
+     - The average of free memory capacity reserved to ensure each query has
+       the minimal required capacity to run.
+   * - memory_pool_initial_capacity_bytes
+     - Histogram
+     - The distribution of a root memory pool's initial capacity in range of [0 256MB]
+       with 32 buckets. It is configured to report the capacity at P50, P90, P99,
+       and P100 percentiles.
+   * - memory_pool_capacity_growth_count
+     - Histogram
+     - The distribution of a root memory pool cappacity growth attemps through
+       memory arbitration in range of [0, 256] with 32 buckets. It is configured
+       to report the count at P50, P90, P99, and P100 percentiles.
+   * - memory_pool_usage_leak_bytes
+     - Sum
+     - The leaf memory pool usage leak in bytes.
+   * - memory_pool_reservation_leak_bytes
+     - Sum
+     - The leaf memory pool reservation leak in bytes.
+   * - memory_pool_capacity_leak_bytes
+     - Sum
+     - The root memory pool reservation leak in bytes.
+   * - memory_allocator_double_free_count
+     - Count
+     - Tracks the count of double frees in memory allocator, indicating the
+       possibility of buffer ownership issues when a buffer is freed more
+       than once.
+   * - memory_allocator_mapped_bytes
+     - Avg
+     - Number of bytes currently mapped in MemoryAllocator. These bytes represent
+       the bytes that are either currently being allocated or were in the past
+       allocated, not yet been returned back to the operating system, in the
+       form of 'Allocation' or 'ContiguousAllocation'.
+   * - memory_allocator_alloc_bytes
+     - Avg
+     - Number of bytes currently allocated (used) from MemoryAllocator in the form
+       of 'Allocation' or 'ContiguousAllocation'.
+   * - mmap_allocator_external_mapped_bytes
+     - Avg
+     - Number of bytes currently mapped in MmapAllocator, in the form of
+       'ContiguousAllocation'.
+       NOTE: This applies only to MmapAllocator
+   * - mmap_allocator_delegated_alloc_bytes
+     - Avg
+     - Number of bytes currently allocated from MmapAllocator directly from raw
+       allocateBytes() interface, and internally allocated by malloc. Only small
+       chunks of memory are delegated to malloc
+       NOTE: This applies only to MmapAllocator
+
+Cache
+--------------
+
+.. list-table::
+   :widths: 40 10 50
+   :header-rows: 1
+
+   * - Metric Name
+     - Type
+     - Description
+   * - cache_max_age_secs
+     - Avg
+     - Max possible age of AsyncDataCache and SsdCache entries since the raw file
+       was opened to load the cache.
+   * - memory_cache_num_entries
+     - Avg
+     - Total number of cache entries.
+   * - memory_cache_num_empty_entries
+     - Avg
+     - Total number of cache entries that do not cache anything.
+   * - memory_cache_num_shared_entries
+     - Avg
+     - Total number of cache entries that are pinned for shared access.
+   * - memory_cache_num_exclusive_entries
+     - Avg
+     - Total number of cache entries that are pinned for exclusive access.
+   * - memory_cache_num_prefetched_entries
+     - Avg
+     - Total number of cache entries that are being or have been prefetched but
+       have not been hit.
+   * - memory_cache_total_tiny_bytes
+     - Avg
+     - Total number of bytes of the cached data that is much smaller than kTinyDataSize.
+   * - memory_cache_total_large_bytes
+     - Avg
+     - Total number of bytes of the cached data excluding 'memory_cache_total_tiny_bytes'
+   * - memory_cache_total_tiny_padding_bytes
+     - Avg
+     - Total unused capacity bytes in 'memory_cache_total_tiny_bytes'.
+   * - memory_cache_total_large_padding_bytes
+     - Avg
+     - Total unused capacity bytes in 'memory_cache_total_large_bytes'.
+   * - memory_cache_total_prefetched_bytes
+     - Avg
+     - Total bytes of cache entries in prefetch state.
+   * - memory_cache_sum_evict_score
+     - Sum
+     - Sum of scores of evicted entries. This serves to infer an average lifetime
+       for entries in cache.
+   * - memory_cache_num_hits
+     - Sum
+     - Number of hits (saved IO) since last counter retrieval. The first hit to a
+       prefetched entry does not count.
+   * - memory_cache_hit_bytes
+     - Sum
+     - Amount of hit bytes (saved IO) since last counter retrieval. The first hit
+       to a prefetched entry does not count.
+   * - memory_cache_num_new
+     - Sum
+     - Number of new entries created since last counter retrieval.
+   * - memory_cache_num_evicts
+     - Sum
+     - Number of times a valid entry was removed in order to make space, since
+       last counter retrieval.
+   * - memory_cache_num_savable_evicts
+     - Sum
+     - Number of times a valid entry was removed in order to make space but has not
+       been saved to SSD yet, since last counter retrieval.
+   * - memory_cache_num_evict_checks
+     - Sum
+     - Number of entries considered for evicting, since last counter retrieval.
+   * - memory_cache_num_wait_exclusive
+     - Sum
+     - Number of times a user waited for an entry to transit from exclusive to
+       shared mode, since last counter retrieval.
+   * - memory_cache_num_alloc_clocks
+     - Sum
+     - Clocks spent in allocating or freeing memory for backing cache entries,
+       since last counter retrieval
+   * - memory_cache_num_aged_out_entries
+     - Sum
+     - Number of AsyncDataCache entries that are aged out and evicted.
+       given configured TTL.
+   * - memory_cache_num_stale_entries
+     - Count
+     - Number of AsyncDataCache entries that are stale because of cache request
+       size mismatch.
+   * - ssd_cache_cached_regions
+     - Avg
+     - Number of regions currently cached by SSD.
+   * - ssd_cache_cached_entries
+     - Avg
+     - Number of entries currently cached by SSD.
+   * - ssd_cache_cached_bytes
+     - Avg
+     - Total bytes currently cached by SSD.
+   * - ssd_cache_read_entries
+     - Sum
+     - Total number of entries read from SSD.
+   * - ssd_cache_read_bytes
+     - Sum
+     - Total number of bytes read from SSD.
+   * - ssd_cache_written_entries
+     - Sum
+     - Total number of entries written to SSD.
+   * - ssd_cache_written_bytes
+     - Sum
+     - Total number of bytes written to SSD.
+   * - ssd_cache_aged_out_entries
+     - Sum
+     - Total number of SsdCache entries that are aged out and evicted given
+       configured TTL.
+   * - ssd_cache_aged_out_regions
+     - Sum
+     - Total number of SsdCache regions that are aged out and evicted given
+       configured TTL.
+   * - ssd_cache_open_ssd_errors
+     - Sum
+     - Total number of SSD file open errors.
+   * - ssd_cache_open_checkpoint_errors
+     - Sum
+     - Total number of SSD checkpoint file open errors.
+   * - ssd_cache_open_log_errors
+     - Sum
+     - Total number of SSD evict log file open errors.
+   * - ssd_cache_delete_checkpoint_errors
+     - Sum
+     - Total number of errors while deleting SSD checkpoint files.
+   * - ssd_cache_read_without_checksum
+     - Sum
+     - Total number of SSD cache reads without checksum verification
+       due to SSD cache request size mismatch
+   * - ssd_cache_grow_file_errors
+     - Sum
+     - Total number of errors while growing SSD cache files.
+   * - ssd_cache_write_ssd_errors
+     - Sum
+     - Total number of error while writing to SSD cache files.
+   * - ssd_cache_write_ssd_dropped
+     - Sum
+     - Total number of writes dropped due to no cache space.
+   * - ssd_cache_write_checkpoint_errors
+     - Sum
+     - Total number of errors while writing SSD checkpoint file.
+   * - ssd_cache_read_corruptions
+     - Sum
+     - Total number of corrupted SSD data read detected by checksum.
+   * - ssd_cache_read_ssd_errors
+     - Sum
+     - Total number of errors while reading from SSD cache files.
+   * - ssd_cache_read_checkpoint_errors
+     - Sum
+     - Total number of errors while reading from SSD checkpoint files.
+   * - ssd_cache_checkpoints_read
+     - Sum
+     - Total number of checkpoints read.
+   * - ssd_cache_checkpoints_written
+     - Sum
+     - Total number of checkpoints written.
+   * - ssd_cache_regions_evicted
+     - Sum
+     - Total number of cache regions evicted.
+   * - ssd_cache_recovered_entries
+     - Sum
+     - Total number of cache entries recovered from checkpoint.
+
+Storage
+-------
+
+.. list-table::
+   :widths: 40 10 50
+   :header-rows: 1
+
+   * - Metric Name
+     - Type
+     - Description
+   * - storage_throttled_duration_ms
+     - Histogram
+     - The time distribution of storage IO throttled duration in range of [0, 30s]
+       with 30 buckets. It is configured to report the capacity at P50, P90, P99,
+       and P100 percentiles.
+   * - storage_local_throttled_count
+     - Count
+     - The number of times that storage IOs get throttled in a storage directory.
+   * - storage_global_throttled_count
+     - Count
+     - The number of times that storage IOs get throttled in a storage cluster.
+
+Spilling
+--------
+
+.. list-table::
+   :widths: 40 10 50
+   :header-rows: 1
+
+   * - Metric Name
+     - Type
+     - Description
+   * - spill_max_level_exceeded_count
+     - Count
+     - The number of times that a spill-able operator hits the max spill level
+       limit.
+   * - spill_input_bytes
+     - Sum
+     - The number of bytes in memory to spill.
+   * - spill_bytes
+     - Sum
+     - The number of bytes spilled to disk which can be the number of compressed
+       bytes if compression is enabled.
+   * - spill_rows_count
+     - Count
+     - The number of spilled rows.
+   * - spill_files_count
+     - Count
+     - The number of spilled files.
+   * - spill_fill_time_ms
+     - Histogram
+     - The distribution of the amount of time spent on filling rows for spilling
+       in range of [0, 600s] with 20 buckets. It is configured to report the
+       latency at P50, P90, P99, and P100 percentiles.
+   * - spill_sort_time_ms
+     - Histogram
+     - The distribution of the amount of time spent on sorting rows for spilling
+       in range of [0, 600s] with 20 buckets. It is configured to report the
+       latency at P50, P90, P99, and P100 percentiles.
+   * - spill_serialization_time_ms
+     - Histogram
+     - The distribution of the amount of time spent on serializing rows for
+       spilling in range of [0, 600s] with 20 buckets. It is configured to report
+       the latency at P50, P90, P99, and P100 percentiles.
+   * - spill_disk_writes_count
+     - Count
+     - The number of disk writes to spill rows.
+   * - spill_flush_time_ms
+     - Histogram
+     - The distribution of the amount of time spent on copy out serialized
+       rows for disk write in range of [0, 600s] with 20 buckets. It is configured
+       to report the latency at P50, P90, P99, and P100 percentiles. Note:  If
+       compression is enabled, this includes the compression time.
+   * - spill_write_time_ms
+     - Histogram
+     - The distribution of the amount of time spent on writing spilled rows to
+       disk in range of [0, 600s] with 20 buckets. It is configured to report the
+       latency at P50, P90, P99, and P100 percentiles.
+   * - file_writer_early_flushed_raw_bytes
+     - Sum
+     - Number of bytes pre-maturely flushed from file writers because of memory reclaiming.
+   * - spill_memory_bytes
+     - Avg
+     - The current spilling memory usage in bytes.
+   * - spill_peak_memory_bytes
+     - Avg
+     - The peak spilling memory usage in bytes.
+
+Exchange
+--------
+
+.. list-table::
+   :widths: 40 10 50
+   :header-rows: 1
+
+   * - Metric Name
+     - Type
+     - Description
+   * - exchange_data_time_ms
+     - Histogram
+     - The distribution of data exchange latency in range of [0, 50s] with 50
+       buckets. It is configured to report latency at P50, P90, P99, and P100
+       percentiles.
+   * - exchange_data_bytes
+     - Sum
+     - The exchange data size in bytes.
+   * - exchange_data_size
+     - Histogram
+     - The distribution of exchange data size in range of [0, 128MB] with 128
+       buckets. It is configured to report the capacity at P50, P90, P99, and P100
+       percentiles.
+   * - exchange_data_count
+     - Count
+     - The number of data exchange requests.
+   * - exchange_data_size_time_ms
+     - Histogram
+     - The distribution of data exchange size latency in range of [0, 5s] with 50
+       buckets. It is configured to report latency at P50, P90, P99, and P100
+       percentiles.
+   * - exchange_data_size_count
+     - Count
+     - The number of data size exchange requests.
+
+Hive Connector
+--------------
+
+.. list-table::
+   :widths: 40 10 50
+   :header-rows: 1
+
+   * - Metric Name
+     - Type
+     - Description
+   * - hive_file_handle_generate_latency_ms
+     - Histogram
+     - The distribution of hive file open latency in range of [0, 100s] with 10
+       buckets. It is configured to report latency at P50, P90, P99, and P100
+       percentiles.
diff --git a/velox/docs/monitoring/stats.rst b/velox/docs/monitoring/stats.rst
new file mode 100644
index 0000000000000..f8a75f295cf95
--- /dev/null
+++ b/velox/docs/monitoring/stats.rst
@@ -0,0 +1,156 @@
+=============
+Runtime Stats
+=============
+
+Runtime stats are used to collect the per-query velox runtime events for
+offline query analysis purpose. The collected stats can provide insights into
+the operator level query execution internals, such as how much time a query
+operator spent in disk spilling. The collected stats are organized in a
+free-form key-value for easy extension. The key is the event name and the
+value is defined as RuntimeCounter which is used to store and aggregate a
+particular event occurrences during the operator execution. RuntimeCounter has
+three types: kNone used to record event count, kNanos used to record event time
+in nanoseconds and kBytes used to record memory or storage size in bytes. It
+records the count of events, and the min/max/sum of the event values. The stats
+are stored in OperatorStats structure. The query system can aggregate the
+operator level stats collected from each driver by pipeline and task for
+analysis.
+
+Memory Arbitration
+------------------
+These stats are reported by all operators.
+
+.. list-table::
+   :widths: 50 25 50
+   :header-rows: 1
+
+   * - Stats
+     - Unit
+     - Description
+   * - memoryReclaimCount
+     -
+     - The number of times that the memory arbitration to reclaim memory from
+       an spillable operator.
+       This stats only applies for spillable operators.
+   * - memoryReclaimWallNanos
+     - nanos
+     - The memory reclaim execution time of an operator during the memory
+       arbitration. It collects time spent on disk spilling or file write.
+       This stats only applies for spillable operators.
+   * - reclaimedMemoryBytes
+     - bytes
+     - The reclaimed memory bytes of an operator during the memory arbitration.
+       This stats only applies for spillable operators.
+   * - globalArbitrationCount
+     -
+     - The number of times a request for more memory hit the arbitrator's
+       capacity limit and initiated a global arbitration attempt where
+       memory is reclaimed from viable candidates chosen among all running
+       queries based on a criterion.
+   * - localArbitrationCount
+     -
+     - The number of times a request for more memory hit the query memory
+       limit and initiated a local arbitration attempt where memory is
+       reclaimed from the requestor itself.
+   * - localArbitrationQueueWallNanos
+     -
+     - The time of an operator waiting in local arbitration queue.
+   * - localArbitrationLockWaitWallNanos
+     -
+     - The time of an operator waiting to acquire the local arbitration lock.
+   * - globalArbitrationLockWaitWallNanos
+     -
+     - The time of an operator waiting to acquire the global arbitration lock.
+
+HashBuild, HashAggregation
+--------------------------
+These stats are reported only by HashBuild and HashAggregation operators.
+
+.. list-table::
+   :widths: 50 25 50
+   :header-rows: 1
+
+   * - Stats
+     - Unit
+     - Description
+   * - hashtable.capacity
+     -
+     - Number of slots across all buckets in the hash table.
+   * - hashtable.numRehashes
+     -
+     - Number of rehash() calls.
+   * - hashtable.numDistinct
+     -
+     - Number of distinct keys in the hash table.
+   * - hashtable.numTombstones
+     -
+     - Number of tombstone slots in the hash table.
+   * - hashtable.buildWallNanos
+     - nanos
+     - Time spent on building the hash table from rows collected by all the
+       hash build operators. This stat is only reported by the HashBuild operator.
+
+TableWriter
+-----------
+These stats are reported only by TableWriter operator
+
+.. list-table::
+   :widths: 50 25 50
+   :header-rows: 1
+
+   * - Stats
+     - Unit
+     - Description
+   * - earlyFlushedRawBytes
+     - bytes
+     - Number of bytes pre-maturely flushed from file writers because of memory reclaiming.
+
+Spilling
+--------
+These stats are reported by operators that support spilling.
+
+.. list-table::
+   :widths: 50 25 50
+   :header-rows: 1
+
+   * - Stats
+     - Unit
+     - Description
+   * - spillFillWallNanos
+     - nanos
+     - The time spent on filling rows for spilling.
+   * - spillSortWallNanos
+     - nanos
+     - The time spent on sorting rows for spilling.
+   * - spillSerializationWallNanos
+     - nanos
+     - The time spent on serializing rows for spilling.
+   * - spillFlushWallNanos
+     - nanos
+     - The time spent on copy out serialized rows for disk write. If compression
+       is enabled, this includes the compression time.
+   * - spillWrites
+     -
+     - The number of spill writer flushes, equivalent to number of write calls to
+       underlying filesystem.
+   * - spillWriteWallNanos
+     - nanos
+     - The time spent on writing spilled rows to disk.
+   * - spillRuns
+     -
+     - The number of times that spilling runs on an operator.
+   * - exceededMaxSpillLevel
+     -
+     - The number of times that an operator exceeds the max spill limit.
+   * - spillReadBytes
+     - bytes
+     - The number of bytes read from spilled files.
+   * - spillReads
+     -
+     - The number of spill reader reads, equivalent to the number of read calls to the underlying filesystem.
+   * - spillReadWallNanos
+     - nanos
+     - The time spent on read data from spilled files.
+   * - spillDeserializationWallNanos
+     - nanos
+     - The time spent on deserializing rows read from spilled files.
diff --git a/velox/docs/monthly-updates.rst b/velox/docs/monthly-updates.rst
index bfbe28127b180..ed635b80c307d 100644
--- a/velox/docs/monthly-updates.rst
+++ b/velox/docs/monthly-updates.rst
@@ -5,14 +5,11 @@ Monthly Updates
 .. toctree::
     :maxdepth: 1
 
-    monthly-updates/september-2023
-    monthly-updates/august-2023
-    monthly-updates/july-2023
-    monthly-updates/june-2023
-    monthly-updates/may-2023
-    monthly-updates/april-2023
-    monthly-updates/march-2023
-    monthly-updates/february-2023
-    monthly-updates/january-2023
+    monthly-updates/may-2024
+    monthly-updates/april-2024
+    monthly-updates/march-2024
+    monthly-updates/february-2024
+    monthly-updates/january-2024
+    monthly-updates/2023/index
     monthly-updates/2022/index
     monthly-updates/2021/index
diff --git a/velox/docs/monthly-updates/april-2023.rst b/velox/docs/monthly-updates/2023/april-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/april-2023.rst
rename to velox/docs/monthly-updates/2023/april-2023.rst
diff --git a/velox/docs/monthly-updates/august-2023.rst b/velox/docs/monthly-updates/2023/august-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/august-2023.rst
rename to velox/docs/monthly-updates/2023/august-2023.rst
diff --git a/velox/docs/monthly-updates/2023/december-2023.rst b/velox/docs/monthly-updates/2023/december-2023.rst
new file mode 100644
index 0000000000000..8f4df40a953b0
--- /dev/null
+++ b/velox/docs/monthly-updates/2023/december-2023.rst
@@ -0,0 +1,99 @@
+********************
+December 2023 Update
+********************
+
+Documentation
+=============
+
+* Add documentation for :doc:`Runtime Metrics</metrics>`.
+
+Core Library
+============
+
+* Add support for ``k range frames`` in ``Window`` operator.
+* Add support for aggregations over sorted inputs to ``StreamingAggregation``.
+* Add support for TTL in AsyncDataCache and SsdCache. :pr:`6412`
+* Add support for TypeSignature Parser using Flex and Bison. This is used to parse function signatures.
+* Add support for spilling during the output processing stage of the ``OrderBy`` operator.
+* Add support for metrics related to memory arbitration and spilling. :pr:`7940`, :pr:`8025`
+* Add config ``max_spill_bytes`` to bound the storage used for spilling. The default value is set to 100GB.
+  If it is set to zero, then there is no limit.
+* Add ``Status`` class that can be used to carry the success or error state of an operation.
+  This is similar to `arrow::Status <https://arrow.apache.org/docs/cpp/api/support.html#_CPPv4N5arrow6StatusE>`_.
+* Add :ref:`Expand <ExpandNode>` operator.
+* Add config ``max_arbitrary_buffer_size`` to set the maximum size in bytes for a task's buffered
+  output when the output is distributed randomly among consumers. The producer drivers are blocked
+  when the buffer size exceeds this config.
+* Fix reclaiming memory from hash build operators in grouped execution mode. :pr:`8178`
+* Fix non-termination of hash join in certain conditions. :pr:`7925`, :pr:`8012`.
+* Fix non-termination of the distinct aggregation in certain conditions. :pr:`7968`.
+* Fix ``LimitNode`` offset and count values from overflowing.
+
+Presto Functions
+================
+
+* Add support for TIMESTAMP WITH TIME ZONE input type to :func:`format_datetime` function.
+* Add support for UNKNOWN key type to :func:`map_keys` and :func:`map_values` functions.
+* Add support for DECIMAL types to :func:`approx_distinct` aggregate function.
+* Add support for ``cast(double|real as varchar)`` to return scientific notation when magnitude
+  of the input value is greater than or equal to 10^7, or less than 10^-3.
+* Fix :func:`find_first` to return NULL when the input ArrayVector is NULL but
+  has non-zero offsets and sizes.
+* Fix :func:`find_first` to support input ArrayVectors that are only NULL or empty.
+* Fix :func:`find_first` to return NULL for inputs NULL array and 0 index.
+* Fix :func:`find_first` to throw an error for inputs empty array and invalid start index.
+* Fix :func:`array_sort` to fail gracefully if the specified comparator lambda
+  is not supported.
+* Fix :func:`transform_keys` to check new keys for NULLs.
+* Fix :func:`set_union`, :func:`set_agg` to preserve the order of inputs.
+* Fix :func:`map` to produce the correct output if input arrays have NULL rows but with
+  invalid offsets and sizes.
+* Fix accuracy of the DECIMAL type average computation. :pr:`7944`
+
+Spark Functions
+===============
+
+* Add :spark:func:`str_to_map`, :spark:func:`next_day`, :spark:func:`atan2` functions.
+* Add support for DECIMAL types to :spark:func:`add` and :spark:func:`subtract` functions.
+
+Hive Connector
+==============
+
+* Add support for multiple S3 FileSystems. :pr:`7388`
+* Add support to write dictionary and constant encoded vectors to Parquet by flattening them.
+* Add support to specify a schema when writing Parquet files. :pr:`6074`
+* Add config ``max_split_preload_per_driver`` and remove the ``split_preload_per_driver`` flag.
+* Fix memory leak in HdfsBuilder.
+
+Arrow
+=====
+
+* Fix exporting an REE array by setting the child name to the canonical name defined in the Arrow spec. :pr:`7802`
+
+Performance and Correctness
+===========================
+
+* Add support for lambda functions to ExpressionFuzzer.
+* Add ExchangeFuzzer.
+
+Build
+=====
+
+* Add support for docker image with Presto.
+* Add support for `azure-storage-files-datalake
+  <https://github.com/Azure/azure-sdk-for-cpp/releases/tag/azure-storage-files-datalake_12.8.0>`_ version 12.8.0.
+* Allow specifying a custom curl version for the cpr library. :pr:`7853`
+* Update aws-sdk-cpp version to 1.11.169 (from 1.10.57).
+
+Credits
+=======
+
+Aditi Pandit, Amit Dutta, Bikramjeet Vig, Chengcheng Jin, Christian Zentgraf, Daniel Munoz,
+Deepak Majeti, Ge Gao, Harvey Hunt, HolyLow, Hongze Zhang, Jacob Wujciak-Jens, Jia, Jia Ke,
+Jialiang Tan, Jimmy Lu, Jubin Chheda, Karteekmurthys, Ke, Kevin Wilfong, Krishna Pai,
+Krishna-Prasad-P-V, Laith Sakka, Ma-Jian1, Masha Basmanova, Orri Erling, PHILO-HE,
+Patrick Sullivan, Pedro Eugenio Rocha Pedreira, Pedro Pedreira, Pramod,Ravi Rahman,
+Richard Barnes, Sergey Pershin, Srikrishna Gopu, Wei He, Xiaoxuan Meng, Yangyang Gao,
+Yedidya Feldblum, Zac, aditi-pandit, binwei, duanmeng, hengjiang.ly, joey.ljy, rui-mo,
+shangjing.cxw, soumyaduriseti, xiaoxmeng, xiyu.zk, xumingming, yan ma, yangchuan ,yingsu00,
+zhli, zhli1142015, 高阳阳
\ No newline at end of file
diff --git a/velox/docs/monthly-updates/february-2023.rst b/velox/docs/monthly-updates/2023/february-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/february-2023.rst
rename to velox/docs/monthly-updates/2023/february-2023.rst
diff --git a/velox/docs/monthly-updates/2023/index.rst b/velox/docs/monthly-updates/2023/index.rst
new file mode 100644
index 0000000000000..849058503e4a7
--- /dev/null
+++ b/velox/docs/monthly-updates/2023/index.rst
@@ -0,0 +1,19 @@
+***************
+2023
+***************
+
+.. toctree::
+    :maxdepth: 1
+
+    december-2023
+    november-2023
+    october-2023
+    september-2023
+    august-2023
+    july-2023
+    june-2023
+    may-2023
+    april-2023
+    march-2023
+    february-2023
+    january-2023
diff --git a/velox/docs/monthly-updates/january-2023.rst b/velox/docs/monthly-updates/2023/january-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/january-2023.rst
rename to velox/docs/monthly-updates/2023/january-2023.rst
diff --git a/velox/docs/monthly-updates/july-2023.rst b/velox/docs/monthly-updates/2023/july-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/july-2023.rst
rename to velox/docs/monthly-updates/2023/july-2023.rst
diff --git a/velox/docs/monthly-updates/june-2023.rst b/velox/docs/monthly-updates/2023/june-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/june-2023.rst
rename to velox/docs/monthly-updates/2023/june-2023.rst
diff --git a/velox/docs/monthly-updates/march-2023.rst b/velox/docs/monthly-updates/2023/march-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/march-2023.rst
rename to velox/docs/monthly-updates/2023/march-2023.rst
diff --git a/velox/docs/monthly-updates/may-2023.rst b/velox/docs/monthly-updates/2023/may-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/may-2023.rst
rename to velox/docs/monthly-updates/2023/may-2023.rst
diff --git a/velox/docs/monthly-updates/2023/november-2023.rst b/velox/docs/monthly-updates/2023/november-2023.rst
new file mode 100644
index 0000000000000..40bbf2525bc8a
--- /dev/null
+++ b/velox/docs/monthly-updates/2023/november-2023.rst
@@ -0,0 +1,105 @@
+********************
+November 2023 Update
+********************
+
+Core Library
+============
+
+* Add spilling support for aggregations over distinct or sorted inputs. :pr:`7305`, :pr:`7526`
+* Add support to lazily create the spill directory. :pr:`7660`
+* Add config ``merge_exchange.max_buffer_size`` to limit the total memory used by exchange clients. :pr:`7410`
+* Add configs ``sort_writer_max_output_rows`` and ``sort_writer_max_output_bytes`` to limit memory usage of sort writer. :pr:`7339`
+* Add termination time to TaskStats. This is the time when the downstream workers finish consuming results. Clients such
+  as Prestissimo can use this metric to clean up tasks. :pr:`7479`
+* Add Presto Type Parser based on Flex and Bison. This can be used by a Presto verifier to parse types in the response
+  from the Presto server :pr:`7568`
+* Add support for named row fields in type signature and binding. Example: ``row(foo bigint)`` in a signature only
+  binds to inputs whose type is row with a single BIGINT field named `foo`. :pr:`7523`
+* Add support to shrink cache if clients such as Prestissimo detect high memory usage on a worker. :pr:`7547`, :pr:`7645`
+* Fix distinct aggregations with global grouping sets on empty input. Instead of empty results, for global grouping sets,
+  the expected result is a row per global grouping set with the groupId as the key value. :pr:`7353`
+* Fix incorrect runtime stats reporting when memory arbitration is triggered. :pr:`7394`
+* Fix ``Timestamp::toMillis()`` to overflow only if the final result overflows. :pr:`7506`
+
+Presto Functions
+================
+
+* Add :func:`cosine_similarity` scalar function.
+* Add support for INTERVAL DAY TO SECOND type input to :func:`plus`, :func:`minus`, :func:`multiply` functions.
+* Add support for combination of TIMESTAMP, INTERVAL DAY TO SECOND type inputs to :func:`plus`, :func:`minus` functions.
+* Add support for INTERVAL DAY TO SECOND, DOUBLE input arguments to :func:`divide` function.
+* Add support to allow non-constant IN list in IN Presto predicate. :pr:`7497`
+* Register :func:`array_frequency` function for all primitive types.
+* Fix :doc:`bitwise shift functions</functions/presto/bitwise>` to accept shift value `0`.
+* Fix :doc:`url_extract_*</functions/presto/url>` functions to return null on malformed inputs and support absolute URIs.
+* Fix :func:`from_utf8` handling of invalid UTF-8 codepoint. :pr:`7442`
+* Fix :func:`entropy` aggregate function to return `0.0` on null inputs.
+* Fix :func:`array_sort` function from producing invalid dictionary vectors. :pr:`7800`
+* Fix :func:`lead`, :func:`lag` window functions to return null when the offset is null. :pr:`7254`
+* Fix DECIMAL to VARCHAR cast by adding trailing zeros when the value is `0`. :pr:`7588`
+
+Spark Functions
+===============
+
+* Add :spark:func:`month`, :spark:func:`quarter`, :spark:func:`unscaled_value`, :spark:func:`regex_replace`
+  scalar functions.
+* Add :spark:func:`make_decimal`, :spark:func:`decimal_round` special form functions.
+* Add support for DECIMAL compare with arguments of different precision and scale. :pr:`6207`
+* Add support for complex type inputs to :spark:func:`map` function.
+* Fix :spark:func:`dayofmonth` and :spark:func:`dayofyear` to allow only DATE type as input and return an INTEGER type.
+* Fix :spark:func:`map` function from throwing an exception when used inside an if or switch statement. :pr:`7727`
+
+Hive Connector
+==============
+
+* Add DirectBufferedInput: a selective BufferedInput without caching. :pr:`7217`
+* Add support for reading UNSIGNED INTEGER types in Parquet format. :pr:`6728`
+* Add spill support for DWRF sort writer. :pr:`7326`
+* Add ``file_handle_cache_enabled`` :doc:`Hive Config</configs>` to enable or disable caching file handles.
+* Add documentation for ``num_cached_file_handles`` :doc:`configuration property</configs>`.
+* Add support for DECIMAL and VARCHAR types in BenchmarkParquetReader. :pr:`6275`
+
+Arrow
+=====
+
+* Add support to export constant vector as `Arrow REE
+  array <https://arrow.apache.org/docs/format/Columnar.html#run-end-encoded-layout>`_. :pr:`7327`, :pr:`7398`
+* Add support for TIMESTAMP type in Arrow bridge. :pr:`7435`
+* Fix Arrow bridge to ensure the null_count is always set and add support for null constants. :pr:`7411`
+
+Performance and Correctness
+===========================
+
+* Add PrestoQueryRunner that can be used to verify test results against Presto. :pr:`7628`
+* Add support for plans with TableScan in Join Fuzzer. :pr:`7571`
+* Add support for custom input generators in Aggregation Fuzzer. :pr:`7594`
+* Add support for aggregations over sorted inputs in AggregationFuzzer :pr:`7620`
+* Add support for custom result verifiers in AggregationFuzzer. :pr:`7674`
+* Add custom verifiers for :func:`approx_percentile` and :func:`approx_distinct` in AggregationFuzzer. :pr:`7654`
+* Optimize map subscript by caching input keys in a hash map. :pr:`7191`
+* Optimize `FlatVector<StringView>::copy()` slow path using a DecodedVector and pre-allocated the string buffer. :pr:`7357`
+* Optimize `element_at` for maps with complex type keys by sorting the keys and using binary search. :pr:`7365`
+* Optimize :func:`concat` by adding a fast path for primitive values. :pr:`7393`
+* Optimize :func:`json_parse` function exception handling by switching to simdjson. :pr:`7658`
+* Optimize :ref:`add_items<outputs-write>` for VARCHAR type by avoiding a deep copy. :pr:`7395`
+* Optimize remaining filter by lazily evaluating multi-referenced fields. :pr:`7433`
+* Optimize ``TopN::addInput()`` by deferring copying of the non-key columns. :pr:`7172`
+* Optimize by sorting the inputs once when multiple aggregations share sorting keys and orders. :pr:`7452`
+* Optimize Exchange operator by allowing merging of small batches of data into larger vectors. :pr:`7404`
+
+Build
+=====
+
+* Add DuckDB version 0.8.1 as an external dependency and remove DuckDB amalgamation. :pr:`6725`
+* Add `libcpr <https://github.com/libcpr/cpr>`_ a lightweight http client. :pr:`7385`
+* Upgrade Arrow dependency to 14.0.1 from 13.0.0.
+
+Credits
+=======
+
+Alex Hornby, Amit Dutta, Andrii Rosa, Austin Dickey Bikramjeet Vig, Cheng Huang, Chengcheng Jin, Christopher Ponce de Leon,
+Daniel Munoz, Deepak Majeti, Ge Gao, Genevieve (Genna) Helsel, Harvey Hunt, Jake Jung, Jia, Jia Ke, Jialiang Tan,
+Jimmy Lu, John Elliott, Karteekmurthys, Ke, Kevin Wilfong, Krishna Pai, Laith Sakka, Masha Basmanova, Orri Erling,
+PHILO-HE, Patrick Sullivan, Pedro Eugenio Rocha Pedreira, Pramod, Richard Barnes, Schierbeck, Cody, Sergey Pershin,
+Wei He, Zhenyuan Zhao, aditi-pandit, curt, duanmeng, joey.ljy, lingbin, rui-mo, usurai, vibhatha, wypb, xiaoxmeng,
+xumingming, yangchuan, yaqi-zhao, yingsu00, yiweiHeOSS, youxiduo, zhli, 高阳阳
\ No newline at end of file
diff --git a/velox/docs/monthly-updates/2023/october-2023.rst b/velox/docs/monthly-updates/2023/october-2023.rst
new file mode 100644
index 0000000000000..5fadd9b55e82c
--- /dev/null
+++ b/velox/docs/monthly-updates/2023/october-2023.rst
@@ -0,0 +1,98 @@
+*******************
+October 2023 Update
+*******************
+
+Documentation
+=============
+
+* Add documentation for simple UDAF interface.
+* Add blog post about `reduce_agg <https://velox-lib.io/blog/reduce-agg>`_ lambda aggregate function.
+* Extend documentation for datetime Presto functions to explain handling of :ref:`time zones <presto-time-zones>`.
+* Extend documentation for :func:`reduce_agg` Presto lambda aggregate function.
+
+Core Library
+============
+
+* Add spill support to Window, RowNumber and TopNRowNumber operators.
+* Add spill support after receiving all input to HashAggregation operator. :pr:`6903`
+* Add spill stats to the output of printPlanWithStats.
+* Add logic to adaptively abandon partial TopNRowNumber if cardinality reduction is not sufficient. :pr:`7195`
+* Add optimized version of Window operator for the case when inputs are already partitioned and sorted. :pr:`5437`
+* Add support for order-able and comparable arguments to function signatures.
+* Add support for order-able and comparable arguments to the Simple Function interface. :pr:`7293`
+* Fix Unnest operator to honor `preferred_output_batch_rows` configuration property and avoid producing huge vectors. :pr:`7051`
+
+Presto Functions
+================
+
+* Add :func:`find_first` and :func:`find_first_index` scalar lambda functions.
+* Add :func:`any_match`, :func:`all_match`, :func:`none_match` scalar lambda functions.
+* Add :func:`all_keys_match`, :func:`any_keys_match`, :func:`any_values_match`,
+  :func:`no_keys_match`, :func:`no_values_match` scalar lambda functions.
+* Add :func:`remove_nulls` scalar function.
+* Add :func:`ends_with` and :func:`starts_with` scalar functions.
+* Add :func:`to_ieee754_32` scalar function.
+* Add support for non-constant patterns and escape characters to :func:`like` function. :pr:`6917`
+* Add support for BOOLEAN inputs to :func:`least` and :func:`greatest` scalar functions.
+* Add support for INTEGER inputs to :func:`poisson_cdf` and :func:`binomial_cdf` scalar functions.
+* Add support for maps with keys of UNKNOWN type in :func:`map_filter` scalar lambda function.
+* Add support for REAL inputs to :func:`geometric_mean` aggregate function.
+* Add support for floating point keys to :func:`map_union_sum` aggregate function.
+* Add support for CAST to and from complex types with nested JSON values. :pr:`7256`
+* Fix 1ms-off issue in :func:`from_unixtime` scalar function. :pr:`7047`
+* Fix :func:`array_min` and :func:`array_max` for floating point numbers to match Presto. :pr:`7128`
+* Fix :func:`checksum` aggregate function. :pr:`6910`
+* Fix :func:`array_sort` and :func:`contains` scalar functions to reject inputs with nested nulls.
+* Fix :func:`map_agg`, :func:`set_agg`, :func:`min_by` and :func:`max_by` aggregate functions to
+  reject inputs with nested nulls.
+* Fix :func:`array_sort` and :func:`array_sort_desc` to restrict inputs to order-able types. :pr:`6928`
+* Fix :func:`min`, :func:`min_by`, :func:`max`, :func:`max_by` aggregate functions to restrict inputs to order-able types. :pr:`7232`
+* Fix CAST(VARCHAR as JSON) for Unicode characters. :pr:`7119`
+* Fix CAST(JSON as ROW) to use case-insensitive match for keys. :pr:`7016`
+
+Spark Functions
+===============
+
+* Add :spark:func:`array_min`, :spark:func:`array_max`, :spark:func:`add_months`,
+  :spark:func:`conv`, :spark:func:`substring_index`, :spark:func:`datediff` scalar functions.
+* Add support for DECIMAL inputs to :spark:func:`multiply` and :spark:func:`divide`.
+* Fix :spark:func:`sum` aggregate function for BIGINT inputs to allow overflow.
+
+Hive Connector
+==============
+
+* Add support for reading from Azure Storage. :pr:`6675`
+
+Performance and Correctness
+===========================
+
+* Optimize spilling by switching to `gfx::timsort <https://github.com/timsort/cpp-TimSort>`_ (from std::sort). :pr:`6745`.
+* Add support for disabling caching in expression evaluation to reduce memory usage via `enable_expression_evaluation_cache` configuration property. :pr:`6898`
+* Add support for validating output of every operator via `debug.validate_output_from_operators` configuration property. :pr:`6687`
+* Add support for order-able function arguments to the Fuzzer. :pr:`6950`
+* Fix edge cases in datetime processing during daylight saving transition. :pr:`7011`
+* Fix comparisons of complex types values using floating point numbers in the RowContainer. :pr:`5833`
+* Fix window aggregations for empty frames. :pr:`6872`
+* Fix GroupID operator with duplicate grouping keys in the output. :pr:`6738`
+* Fix global grouping set aggregations for empty inputs. :pr:`7112`
+* Fix aggregation function framework to require raw input types for all aggregates to avoid confusion and incorrect results. :pr:`7037`
+
+Build Systems
+=============
+
+* Add support for Conda Environments. :pr:`6282`
+
+Credits
+=======
+
+Alex, Alex Hornby, Amit Dutta, Ann Rose Benny, Bikramjeet Vig, Chengcheng Jin,
+Christian Zentgraf, Cody Ohlsen, Daniel Munoz, David Tolnay, Deepak Majeti,
+Genevieve (Genna) Helsel, Huameng (Michael) Jiang, Jacob Wujciak-Jens, Jaihari
+Loganathan, Jason Sylka, Jia Ke, Jialiang Tan, Jimmy Lu, John Elliott, Jubin
+Chheda, Karteekmurthys, Ke, Kevin Wilfong, Krishna Pai, Krishna-Prasad-P-V,
+Laith Sakka, Ma-Jian1, Mahadevuni Naveen Kumar, Mark Shroyer, Masha Basmanova,
+Orri Erling, PHILO-HE, Patrick Sullivan, Pedro Eugenio Rocha Pedreira, Pramod,
+Prasoon Telang, Pratik Joseph Dabre, Pratyush Verma, Rong Ma, Sergey Pershin,
+Wei He, Zac, aditi-pandit, dependabot[bot], duanmeng, joey.ljy, lingbin,
+rrando901, rui-mo, usurai, wypb, xiaoxmeng, xumingming, yan ma, yangchuan,
+yingsu00, zhejiangxiaomai, 高阳阳
diff --git a/velox/docs/monthly-updates/september-2023.rst b/velox/docs/monthly-updates/2023/september-2023.rst
similarity index 100%
rename from velox/docs/monthly-updates/september-2023.rst
rename to velox/docs/monthly-updates/2023/september-2023.rst
diff --git a/velox/docs/monthly-updates/april-2024.rst b/velox/docs/monthly-updates/april-2024.rst
new file mode 100644
index 0000000000000..919e8551bdbb1
--- /dev/null
+++ b/velox/docs/monthly-updates/april-2024.rst
@@ -0,0 +1,63 @@
+*****************
+April 2024 Update
+*****************
+
+Documentation
+=============
+
+* Document operations on decimals for :doc:`Presto </functions/presto/decimal>`
+  and :doc:`Spark </functions/spark/decimal>`.
+* Document spill write stats. :pr:`9326`
+
+Core Library
+============
+
+* Fix bugs in Window operator. :pr:`9476`, :pr:`9271`, :pr:`9257`
+
+Presto Functions
+================
+
+* Add :func:`word_stem` and :func:`to_iso8601` scalar functions.
+* Add support for DECIMAL inputs to :func:`arbitrary`, :func:`min` and :func:`max` aggregate functions.
+* Fix :func:`json_extract` for paths with wildcards.
+
+Spark Functions
+===============
+
+* Add :spark:func:`array_size`, :spark:func:`flatten`, :spark:func:`year_of_week` scalar functions.
+* Add :spark:func:`collect_list` and :spark:func:`regr_replacement` aggregate functions.
+
+Hive Connector
+==============
+
+* Add support for storing decimal as integer in Parquet writer.
+* Add hive.s3.connect-timeout, hive.s3.socket-timeout and hive.s3.max-connections configs. :pr:`9472`
+* Fix complex type handing in Parquet reader. :pr:`9187`
+* Fix DWRF reader to skip null map keys.
+
+Performance and Correctness
+===========================
+
+* Add aggregation and window fuzzer runs to every PR.
+* Add nightly run of window fuzzer.
+* Add check for aggregate function signature changes to every PR.
+* Add biased aggregation fuzzer run for newly added aggregate functions to every PR.
+
+Build System
+============
+
+* Add nightly job to track build metrics.
+
+Credits
+=======
+
+Andres Suarez, Andrii Rosa, Ankita Victor, Ashwin Krishna Kumar, Bikramjeet Vig,
+Christian Zentgraf, Daniel Munoz, David McKnight, Deepak Majeti, Hengzhi Chen,
+Huameng (Michael) Jiang, Jacob Wujciak-Jens, Jeongseok Lee, Jialiang Tan, Jimmy
+Lu, Karteekmurthys, Ke, Kevin Wilfong, Krishna Pai, Lu Niu, Ludovic Henry, Ma,
+Rong, Mahadevuni Naveen Kumar, Masha Basmanova, Mike Lui, Minhan Cao, PHILO-HE,
+Pedro Eugenio Rocha Pedreira, Pedro Pedreira, Pramod, Qian Sun, Richard Barnes,
+Sergey Pershin, Shabab Ayub, Tengfei Huang, Terry Wang, Wei He, Weitao Wan,
+Wills Feng, Yang Zhang, Yihong Wang, Yoav Helfman, Zac Wen, Zhenyuan Zhao,
+aditi-pandit, chliang, cindyyyang, duanmeng, jay.narale, joey.ljy, mohsaka,
+rui-mo, svm1, willsfeng, wutiangan, wypb, xiaoxmeng, yingsu00, zhli1142015
diff --git a/velox/docs/monthly-updates/february-2024.rst b/velox/docs/monthly-updates/february-2024.rst
new file mode 100644
index 0000000000000..18704d2bb5ac4
--- /dev/null
+++ b/velox/docs/monthly-updates/february-2024.rst
@@ -0,0 +1,68 @@
+********************
+February 2024 Update
+********************
+
+Core Library
+============
+
+* Add support for aggregations over distinct inputs to StreamingAggregation.
+* Add support for deserializing a single column in Presto page format.
+* Add support for deserializing an all-null column serialized as UNKNOWN type in Presto page format.
+* Add stats for null skew in join operator.
+* Convert TIMESTAMP_WITH_TIME_ZONE type to a primitive type.
+* Add background profiler that starts Linux perf on the Velox process.
+* Fix ``out of range in dynamic array`` error in Task::toJson.
+* Delete unused ``max_arbitrary_buffer_size`` config.
+
+Presto Functions
+================
+
+* Add :func:`typeof`, :func:`from_iso8601_date` scalar functions.
+* Add support for DECIMAL input type to :func:`set_agg` and :func:`set_union` aggregate functions.
+* Add support for UNKNOWN input type to :func:`checksum` aggregate function.
+* Add support for DATE +/- INTERVAL YEAR MONTH functions.
+* Add support for ``UCT|UCT|GMT|GMT0`` as ``Z`` to :func:`parse_datetime` scalar function.
+
+Spark Functions
+===============
+
+* Add :spark:func:`array_repeat`, :spark:func:`date_from_unix_date`, :spark:func:`weekday`, :spark:func:`minute`, :spark:func:`second` scalar functions.
+* Add :spark:func:`ntile` window function.
+
+Hive Connector
+==============
+
+* Add ``ignore_missing_files`` config.
+* Add write support to ABFS file system.
+* Add support for proxy to S3 file system.
+
+Arrow
+=====
+
+* Add support to export UNKNOWN type to Arrow array.
+* Add support to convert Arrow REE arrays to Velox Vectors.
+
+Performance and Correctness
+===========================
+
+* Add FieldReference benchmark.
+* Add :ref:`Window fuzzer <window-fuzzer>`.
+* Fix ``Too many open files`` error in Join fuzzer.
+
+Build System
+============
+
+* Add ``VELOX_BUILD_MINIMAL_WITH_DWIO`` CMake option.
+* Move documentation, header and format check to Github Action.
+
+Credits
+=======
+
+Aaron Feldman, Ankita Victor, Bikramjeet Vig, Christian Zentgraf, Daniel Munoz,
+David McKnight, Deepak Majeti, Ge Gao, Hongze Zhang, Jacob Wujciak-Jens, Jia Ke,
+Jialiang Tan, Jimmy Lu, Kevin Wilfong, Krishna Pai, Lu Niu, Masha Basmanova,
+Nick Terrell, Orri Erling, PHILO-HE, Pedro Pedreira, Pramod, Pranjal Shankhdhar,
+Richard Barnes, Schierbeck, Cody, Sergey Pershin, Wei He, Yedidya Feldblum,
+Zac Wen, Zhenyuan Zhao, aditi-pandit, duanmeng, gayangya, hengjiang.ly, hitarth,
+lingbin, mwish, rrando901, rui-mo, xiaodou, xiaoxmeng, xumingming, yingsu00,
+zhli1142015, 高阳阳
diff --git a/velox/docs/monthly-updates/january-2024.rst b/velox/docs/monthly-updates/january-2024.rst
new file mode 100644
index 0000000000000..dc917581e8e67
--- /dev/null
+++ b/velox/docs/monthly-updates/january-2024.rst
@@ -0,0 +1,84 @@
+********************
+January 2024 Update
+********************
+
+Documentation
+=============
+
+* Add documentation about :doc:`Hash Table </develop/hash-table>`.
+* Add documentation about :doc:`memory management </develop/memory>`.
+
+Core Library
+============
+
+* Add metrics to track time spent in memory arbitration. :pr:`8497`, :pr:`8482`
+* Add metric to track average buffer time for exchange. :pr:`8534`
+* Optimize count(distinct x) when x is of complex type. :pr:`8560`
+* Optimize latency for exchange that uses arbitrary buffer. :pr:`8532`, :pr:`8480`
+* Optimize MallocAllocator to reduce lock contention. :pr:`8477`
+* Fix aggregation over all-null keys with ignoreNullKeys = true. :pr:`8422`
+* Fix race condition in task completion that caused `Output buffers for task not found` failures. :pr:`8357`
+* Fix evaluation of CAST expression under TRY. :pr:`8365`
+* Fix `FlatVector<StringView>::copy` for vectors with more than 2GB of data. :pr:`8516`
+* Fix crash in `FlatVector<bool>::ensureWritable`. :pr:`8450`
+* Fix interaction of spilling and yielding in Hash Join operator. :pr:`8520`
+* Fix rawInputPositions metrics in Exchange operator. :pr:`8370`
+
+Presto Functions
+================
+
+* Add :func:`from_ieee754_64`, :func:`multimap_from_entries`, :func:`ngrams` functions.
+* Add support for VARBINARY inputs to :func:`reverse` function.
+* Add support for arrays of complex types to :func:`array_min` and :func:`array_max` functions.
+* Add support for casting DOUBLE and VARCHAR as DECIMAL.
+* Add support for UNKNOWN key to :func:`map_agg` function.
+* Add support for timezone offsets to :func:`timezone_hour` and :func:`timezone_minute` functions. :pr:`8269`
+* Optimize cast from JSON by using simdjson. :pr:`8216`
+* Fix handling of timestamps with timezone in :func:`date_diff` function. :pr:`8540`
+* Fix :func:`json_parse` for inputs with very large numbers. :pr:`8455`
+* Fix kAtLeastN and kExactlyN fast paths in LIKE for inputs with multi-byte characters. :pr:`8150`
+* Fix :func:`approx_distinct` aggregate function for TIMESTAMP inputs. :pr:`8164`
+* Fix :func:`min` and :func:`max` when used in Window operator. :pr:`8311`
+
+Spark Functions
+===============
+
+* Add :spark:func:`from_unixtime`, :spark:func:`find_in_set`, :spark:func:`get_timestamp`,
+  :spark:func:`hour`, :spark:func:`hex`, :spark:func:`isnan`, :spark:func:`replace` functions.
+* Add support for TINYINT and SMALLINT inputs to :spark:func:`date_add` and :spark:func:`date_sub` functions.
+* Add support for casting DOUBLE and VARCHAR as DECIMAL.
+* Fix crash in :spark:func:`conv` function. :pr:`8046`
+
+Hive Connector
+==============
+
+* Fix crash in Parquet reader when processing empty row groups. :pr:`8000`
+* Fix data sink to avoid writing partition columns to files. :pr:`8089`
+
+Performance and Correctness
+===========================
+
+* Add support for aggregations over distinct inputs to AggregationFuzzer.
+* Reduce memory usage of histogram metrics. :pr:`8458`
+* Add Join Fuzzer run to CI that runs on each PR.
+* Add Aggregation Fuzzer run using Presto as source of truth to experimental CI.
+
+Build System
+============
+
+* Upgrade folly to v2023.12.04.00 (from v2022.11.14.00).
+* Upgrade fmt to 10.1.1 (from 8.0.1).
+
+Credits
+=======
+
+Amit Dutta, Benwei Shi, Bikramjeet Vig, Chen Zhang, Chengcheng Jin, Christian
+Zentgraf, Deepak Majeti, Ge Gao, Hongze Zhang, Jacob Wujciak-Jens, Jia Ke,
+Jialiang Tan, Jimmy Lu, Ke, Kevin Wilfong, Krishna Pai, Laith Sakka, Lu Niu,
+Ma, Rong, Masha Basmanova, Mike Lui, Orri Erling, PHILO-HE, Pedro Eugenio
+Rocha Pedreira, Pratik Joseph Dabre, Ravi Rahman, Richard Barnes, Schierbeck,
+Cody, Sergey Pershin, Sitao Lv, Taras Galkovskyi, Wei He, Yedidya Feldblum,
+Yuan Zhou, Yuping Fan, Zac Wen, aditi-pandit, binwei, duanmeng, hengjiang.ly,
+icejoywoo, lingbin, mwish, rui-mo, wypb, xiaoxmeng, xumingming, yangchuan,
+yingsu00, youxiduo, yuling.sh, zhli1142015, zky.zhoukeyong, zwangsheng
+
diff --git a/velox/docs/monthly-updates/march-2024.rst b/velox/docs/monthly-updates/march-2024.rst
new file mode 100644
index 0000000000000..636f52ed3a4f4
--- /dev/null
+++ b/velox/docs/monthly-updates/march-2024.rst
@@ -0,0 +1,79 @@
+*****************
+March 2024 Update
+*****************
+
+Documentation
+=============
+
+* Document `design philosophy <https://velox-lib.io/docs/community/design-philosophy/>`_
+* Document custom input generators and verifiers supported in the Aggregation Fuzzer.
+* Document runtime stats reported by the HashTable. :pr:`9255`
+* Document usage of generic types in Simple Function API. :pr:`9084`
+
+Core Library
+============
+
+* Add prefix-sort for fixed width sorting keys.
+* Add null behavior and determinism scalar function metadata to the registry. :pr:`9209`
+* Add order-sensitive aggregate function metadata to the registry. :pr:`9050`
+* Add support for DECIMAL type to Simple Function API. :pr:`9096`
+* Add support for lambda functions (reduce_agg) to StreamingAggregation.
+* Deprecate threshold based spilling in Aggregation and OrderBy.
+* Optimize Exchange protocol used by Presto for latency. :pr:`8845`
+
+Presto Functions
+================
+
+* Add :func:`day`, :func:`from_ieee754_32`, :func:`hamming_distance`, :func:`map_normalize`,
+  :func:`map_top_n` scalar functions.
+* Add support for DECIMAL input type to :func:`floor` function.
+* Add support for timestamp +/- IntervalYearMonth.
+* Add :func:`regr_avgx`, :func:`regr_avgy`, :func:`regr_count`, :func:`regr_r2`,
+  :func:`regr_sxx`, :func:`regr_sxy`, and :func:`regr_syy` aggregation functions.
+
+Spark Functions
+===============
+
+* Add :spark:func:`array_remove`, :spark:func:`bit_length`, :spark:func:`bitwise_xor`,
+  :spark:func:`bitwise_not`, :spark:func:`make_ym_interval`, :spark:func:`from_utc_timestamp`,
+  :spark:func:`to_utc_timestamp`, :spark:func:`make_timestamp`, :spark:func:`map_subset`,
+  :spark:func:`unhex`, :spark:func:`unix_date`, :spark:func:`uuid` functions.
+* Add :spark:func:`regexp_replace` function.
+* Add :spark:func:`monotonically_increasing_id`, :spark:func:`spark_partition_id` functions.
+* Add :spark:func:`kurtosis` and :spark:func:`skewness` aggregation functions.
+* Add support for DECIMAL inputs to :spark:func:`sum` aggregation function.
+* Add CAST(real as decimal).
+* Add configuration property 'spark.partition_id'.
+
+Hive Connector
+==============
+
+* Add support for S3 client no_proxy CIDR expression. :pr:`9160`
+* Add support for synthetic columns '$file_size' and '$file_modified_time'.
+* Optimize reading a small sample of rows. :pr:`8920`.
+* Fix Parquet reader for files with different encodings across row groups. :pr:`9129`
+
+Performance and Correctness
+===========================
+
+* Add nightly run of Aggregation fuzzer using Presto as source of truth.
+* Add nightly run of Exchange fuzzer.
+* Add utility to randomly trigger OOMs and integrate it into Aggregation and Join fuzzers.
+* Add group execution mode to Join fuzzer.
+* Add support for random frame clause generation to Window fuzzer.
+* Add custom input generator for map_union_sum Presto aggregation function.
+* Add custom result verifier for arbitrary Presto aggregation function.
+
+Credits
+=======
+
+8dukongjian, Amit Dutta, Ankita Victor, Bikramjeet Vig, Christian Zentgraf,
+Daniel Munoz, Deepak Majeti, Ge Gao, InitialZJ, Jacob Wujciak-Jens, Jake Jung,
+Jialiang Tan, Jimmy Lu, Karteekmurthys, Kevin Wilfong, Krishna Pai, Ma,  Rong,
+Mahadevuni Naveen Kumar, Marcus D. Hanwell, Masha Basmanova, Nicholas Ormrod,
+Nick Terrell, Orri Erling, PHILO-HE, Patrick Sullivan, Pedro Pedreira, Pramod,
+Pratik Joseph Dabre, Qian Sun, Richard Barnes, Sandino Flores, Schierbeck,
+Cody, Sergey Pershin, Ubuntu, Wei He, Yang Zhang, Zac Wen, aditi-pandit,
+duanmeng, f0rest9999, hengjiang.ly, joey.ljy, lingbin, mwish, rexan, rui-mo,
+willsfeng, wypb, xiaodai1002, xiaoxmeng, xumingming, youxiduo, yuling.sh,
+zhli1142015, zky.zhoukeyong
diff --git a/velox/docs/monthly-updates/may-2024.rst b/velox/docs/monthly-updates/may-2024.rst
new file mode 100644
index 0000000000000..9768ce5840b72
--- /dev/null
+++ b/velox/docs/monthly-updates/may-2024.rst
@@ -0,0 +1,87 @@
+***************
+May 2024 Update
+***************
+
+Documentation
+=============
+
+* Publish blog post about `optimizing TRY and TRY_CAST <https://velox-lib.io/blog/optimize-try-more>`_
+* Publish `Technical Governance <https://velox-lib.io/docs/community/technical-governance>`_.
+
+Core Library
+============
+
+* Optimize TRY and TRY_CAST for cases when many rows fail.
+* Add support for LEFT SEMI FILTER and RIGHT SEMI FILTER merge joins.
+* Add support for DECIMAL input to aggregations over distinct values. :pr:`9850`
+* Add support for specifying overwrite behavior when registering simple scalar functions. :pr:`9158`
+* Fix LEFT merge join with extra filter. :pr:`9862`
+* Fix Nested Loop join with empty build and extra filter. :pr:`9892`
+* Fix crash when copying complex vectors. :pr:`9725`
+* Fix reuse of LazyVectors in TableScan to avoid crashes in downstream operators. :pr:`9811`
+* Add support for including metadata identifying the operator that generated an error in error messages to ease troubleshooting. :pr:`9695`
+
+Presto Functions
+================
+
+* Add :func:`at_timezone` function.
+* Add support for VARBINARY input to :func:`approx_distinct` aggregate function.
+* Add support for CAST(varchar AS timestamp with time zone).
+* Add support for DECIMAL inputs to :func:`min_by` and :func:`max_by` aggregate functions.
+* Fix :func:`arrays_overlap` function for empty arrays. :pr:`9922`
+* Fix :func:`map_top_n` function to break ties by comparing keys.
+* Fix CAST(IntervalDayTime AS Varchar) for negative intervals. :pr:`9871`
+* Fix :func:`from_base64` for inputs without padding. :pr:`8647`
+* Fix handling of equality and total ordering of NaN (Not-a-Number) floating point
+  values in :func:`array_min`, :func:`array_sort`, :func:`array_distinct`,
+  :func:`array_except`, :func:`array_intersect`, :func:`array_union`,
+  :func:`array_position`, :func:`array_remove`, :func:`arrays_overlap`, :func:`contains`,
+  map subscript and :func:`multimap_agg`.
+
+Spark Functions
+===============
+
+* Add :spark:func:`expm1`, :spark:func:`get`, :spark:func:`rint`, :spark:func:`shuffle`,
+  :spark:func:`soundex`, :func:`unix_seconds`, :spark:func:`width_bucket` functions.
+* Add support for complex type inputs to :spark:func:`hash` and :spark:func:`xxhash64` functions.
+* Fix CAST(tinyint/smallint/integer/bigint as varbinary). :pr:`9819`
+* Fix return type for :spark:func:`sum` aggregate function with REAL input. :pr:`9818`
+
+Hive Connector
+==============
+
+* Add support for projecting synthesized row-number column from Table Scan. :pr:`9174`
+
+Performance and Correctness
+===========================
+
+* Optimize memory arbitration to avoid interference between queries to reduce overall query execution time.
+* Add cache expiration function to simple LRU cache to support remote IO throttling.
+* Add Fuzzers for TableWriter and RowNumber operators.
+* Add support for Nested Loop joins to Join Fuzzer.
+* Add support for testing different sorting flags to Window Fuzzer.
+* Add custom argument type generators for Presto decimal functions. :pr:`9715`
+* Add support for logical input types in the evaluateOnce() unit test helper method. :pr:`9708`
+* Re-enable testing of merge joins in Join Fuzzer.
+
+Build System
+============
+
+* Upgrade aws-sdk-cpp to 1.11.321 (from 1.11.169).
+* Upgrade cmake to 3.28.3 (from 3.14).
+* Upgrade simdjson to 3.9.3 (from 3.8.0).
+* Add support for docker image with Spark Connect server to use with Fuzzer. :pr:`9759`
+* Add dashboard with `build time metrics <https://facebookincubator.github.io/velox/bm-report/>`_.
+
+Credits
+=======
+
+Ankita Victor, Ashwin Krishna Kumar, Bikramjeet Vig, Bradley Dice, Daniel Munoz,
+Deepak Majeti, Giuseppe Ottaviano, Jacob Wujciak-Jens, Jia Ke, Jialiang Tan,
+Jimmy Lu, Joe Abraham, Karteekmurthys, Ke, Kevin Wilfong, Kk Pulla, Krishna
+Pai, Ma,  Rong, Masha Basmanova, NEUpanning, PHILO-HE, Patrick Sullivan, Pedro
+Eugenio Rocha Pedreira, Richard Barnes, Sandino Flores, Sergey Pershin, Ubuntu,
+Wei He, Weihan Tang, Yang Zhang, Zac Wen, Zuyu ZHANG, aditi-pandit, chliang,
+duanmeng, gaoyangxiaozhu, jay.narale, joey.ljy, kevin, kikimo, lingbin, rui-mo,
+svm1, xiaoxmeng, xumingming, yan ma, yanngyoung, yingsu00, zhli1142015,
+zhouyifan279, zjuwangg, zky.zhoukeyong, 高阳阳
diff --git a/velox/docs/programming-guide/chapter01.rst b/velox/docs/programming-guide/chapter01.rst
index 3f4f9e56e0234..a7b6cb303629b 100644
--- a/velox/docs/programming-guide/chapter01.rst
+++ b/velox/docs/programming-guide/chapter01.rst
@@ -15,7 +15,7 @@ Let’s start by getting access to a MemoryPool:
 
     #include "velox/common/memory/Memory.h"
 
-    auto pool = memory::addDefaultLeafMemoryPool();
+    auto pool = memory::memoryManager()->addLeafPool();
 
 `pool` is a std::shared_ptr<velox::memory::MemoryPool>. We can use it to
 allocate buffers.
diff --git a/velox/docs/spark_functions.rst b/velox/docs/spark_functions.rst
index f8ba812160829..24c825ac1ef59 100644
--- a/velox/docs/spark_functions.rst
+++ b/velox/docs/spark_functions.rst
@@ -2,21 +2,27 @@
 Spark Functions
 ***********************
 
+The semantics of Spark functions match Spark 3.5 with ANSI OFF.
+
 .. toctree::
     :maxdepth: 1
 
     functions/spark/math
     functions/spark/bitwise
+    functions/spark/decimal
     functions/spark/comparison
     functions/spark/string
     functions/spark/datetime
     functions/spark/array
     functions/spark/map
+    functions/spark/misc
     functions/spark/regexp
     functions/spark/binary
-    functions/spark/json
     functions/spark/aggregate
     functions/spark/window
+    functions/spark/conversion
+    functions/spark/url
+    functions/spark/json
 
 Here is a list of all scalar and aggregate Spark functions available in Velox.
 Function names link to function descriptions. Check out coverage maps
@@ -58,32 +64,32 @@ for :doc:`all <functions/spark/coverage>` functions.
     ================================  ================================  ================================  ==  ================================  ==  ================================
     Scalar Functions                                                                                          Aggregate Functions                   Window Functions
     ====================================================================================================  ==  ================================  ==  ================================
-    :spark:func:`abs`                 :spark:func:`floor`               :spark:func:`power`                   :spark:func:`bit_xor`                 :spark:func:`nth_value`         
-    :spark:func:`acos`                :spark:func:`get_json_object`     :spark:func:`rand`                    :spark:func:`first`                                                   
-    :spark:func:`acosh`               :spark:func:`greaterthan`         :spark:func:`regexp_extract`          :spark:func:`first_ignore_null`                                       
-    :spark:func:`add`                 :spark:func:`greaterthanorequal`  :spark:func:`remainder`               :spark:func:`last`                                                    
-    :spark:func:`aggregate`           :spark:func:`greatest`            :spark:func:`replace`                 :spark:func:`last_ignore_null`                                        
-    :spark:func:`array`               :spark:func:`hash`                :spark:func:`rlike`                                                                                         
-    :spark:func:`array_contains`      :spark:func:`hypot`               :spark:func:`round`                                                                                         
-    :spark:func:`array_intersect`     :spark:func:`in`                  :spark:func:`rtrim`                                                                                         
-    :spark:func:`array_sort`          :spark:func:`instr`               :spark:func:`sec`                                                                                           
-    :spark:func:`ascii`               :spark:func:`isnotnull`           :spark:func:`sha1`                                                                                          
-    :spark:func:`asinh`               :spark:func:`isnull`              :spark:func:`sha2`                                                                                          
-    :spark:func:`atanh`               :spark:func:`least`               :spark:func:`shiftleft`                                                                                     
-    :spark:func:`between`             :spark:func:`left`                :spark:func:`shiftright`                                                                                    
-    :spark:func:`bin`                 :spark:func:`length`              :spark:func:`sinh`                                                                                          
-    :spark:func:`bitwise_and`         :spark:func:`lessthan`            :spark:func:`size`                                                                                          
-    :spark:func:`bitwise_or`          :spark:func:`lessthanorequal`     :spark:func:`sort_array`                                                                                    
-    :spark:func:`ceil`                :spark:func:`log1p`               :spark:func:`split`                                                                                         
-    :spark:func:`chr`                 :spark:func:`lower`               :spark:func:`startswith`                                                                                    
-    :spark:func:`concat`              :spark:func:`ltrim`               :spark:func:`substring`                                                                                     
-    :spark:func:`contains`            :spark:func:`map`                 :spark:func:`subtract`                                                                                      
-    :spark:func:`csc`                 :spark:func:`map_filter`          :spark:func:`to_unix_timestamp`                                                                             
-    :spark:func:`divide`              :spark:func:`map_from_arrays`     :spark:func:`transform`                                                                                     
-    :spark:func:`element_at`          :spark:func:`md5`                 :spark:func:`trim`                                                                                          
-    :spark:func:`endswith`            :spark:func:`might_contain`       :spark:func:`unaryminus`                                                                                    
-    :spark:func:`equalnullsafe`       :spark:func:`multiply`            :spark:func:`unix_timestamp`                                                                                
-    :spark:func:`equalto`             :spark:func:`not`                 :spark:func:`upper`                                                                                         
-    :spark:func:`exp`                 :spark:func:`notequalto`          :spark:func:`xxhash64`                                                                                      
-    :spark:func:`filter`              :spark:func:`pmod`                :spark:func:`year`                                                                                          
+    :spark:func:`abs`                 :spark:func:`floor`               :spark:func:`power`                   :spark:func:`bit_xor`                 :spark:func:`nth_value`
+    :spark:func:`acos`                :spark:func:`get_json_object`     :spark:func:`rand`                    :spark:func:`first`
+    :spark:func:`acosh`               :spark:func:`greaterthan`         :spark:func:`regexp_extract`          :spark:func:`first_ignore_null`
+    :spark:func:`add`                 :spark:func:`greaterthanorequal`  :spark:func:`remainder`               :spark:func:`last`
+    :spark:func:`aggregate`           :spark:func:`greatest`            :spark:func:`replace`                 :spark:func:`last_ignore_null`
+    :spark:func:`array`               :spark:func:`hash`                :spark:func:`rlike`
+    :spark:func:`array_contains`      :spark:func:`hypot`               :spark:func:`round`
+    :spark:func:`array_intersect`     :spark:func:`in`                  :spark:func:`rtrim`
+    :spark:func:`array_sort`          :spark:func:`instr`               :spark:func:`sec`
+    :spark:func:`ascii`               :spark:func:`isnotnull`           :spark:func:`sha1`
+    :spark:func:`asinh`               :spark:func:`isnull`              :spark:func:`sha2`
+    :spark:func:`atanh`               :spark:func:`least`               :spark:func:`shiftleft`
+    :spark:func:`between`             :spark:func:`left`                :spark:func:`shiftright`
+    :spark:func:`bin`                 :spark:func:`length`              :spark:func:`sinh`
+    :spark:func:`bitwise_and`         :spark:func:`lessthan`            :spark:func:`size`
+    :spark:func:`bitwise_or`          :spark:func:`lessthanorequal`     :spark:func:`sort_array`
+    :spark:func:`ceil`                :spark:func:`log1p`               :spark:func:`split`
+    :spark:func:`chr`                 :spark:func:`lower`               :spark:func:`startswith`
+    :spark:func:`concat`              :spark:func:`ltrim`               :spark:func:`substring`
+    :spark:func:`contains`            :spark:func:`map`                 :spark:func:`subtract`
+    :spark:func:`csc`                 :spark:func:`map_filter`          :spark:func:`to_unix_timestamp`
+    :spark:func:`divide`              :spark:func:`map_from_arrays`     :spark:func:`transform`
+    :spark:func:`element_at`          :spark:func:`md5`                 :spark:func:`trim`
+    :spark:func:`endswith`            :spark:func:`might_contain`       :spark:func:`unaryminus`
+    :spark:func:`equalnullsafe`       :spark:func:`multiply`            :spark:func:`unix_timestamp`
+    :spark:func:`equalto`             :spark:func:`not`                 :spark:func:`upper`
+    :spark:func:`exp`                 :spark:func:`notequalto`          :spark:func:`xxhash64`
+    :spark:func:`filter`              :spark:func:`pmod`                :spark:func:`year`
     ================================  ================================  ================================  ==  ================================  ==  ================================
diff --git a/velox/docs/velox-in-10-min.rst b/velox/docs/velox-in-10-min.rst
index fe769250eba1b..9d202c77951a8 100644
--- a/velox/docs/velox-in-10-min.rst
+++ b/velox/docs/velox-in-10-min.rst
@@ -324,7 +324,7 @@ provide a split.
 .. code-block:: c++
 
   plan = PlanBuilder()
-             .tableScan(
+             .tpchTableScan(
                  tpch::Table::TBL_NATION,
                  {"n_nationkey", "n_name"},
                  1 /*scaleFactor*/)
@@ -367,14 +367,14 @@ IDs.
   core::PlanNodeId nationScanId;
   core::PlanNodeId regionScanId;
   plan = PlanBuilder(planNodeIdGenerator)
-             .tableScan(
+             .tpchTableScan(
                  tpch::Table::TBL_NATION, {"n_regionkey"}, 1 /*scaleFactor*/)
              .capturePlanNodeId(nationScanId)
              .hashJoin(
                  {"n_regionkey"},
                  {"r_regionkey"},
                  PlanBuilder(planNodeIdGenerator)
-                     .tableScan(
+                     .tpchTableScan(
                          tpch::Table::TBL_REGION,
                          {"r_regionkey", "r_name"},
                          1 /*scaleFactor*/)
diff --git a/velox/duckdb/README.md b/velox/duckdb/README.md
index 0302b7bbf903a..ea1d19ddea2c2 100644
--- a/velox/duckdb/README.md
+++ b/velox/duckdb/README.md
@@ -15,10 +15,6 @@ Then copy the generated files to velox/external/duckdb:
     export VELOX_PATH="<path/to/velox>"
     rsync -vrh src/amalgamation/duckdb* ${VELOX_PATH}/velox/external/duckdb/
 
-We also maintain a copy of TPC-H dataset generators that need to be updated:
-
-    rsync -vrh --exclude={'CMakeLists.txt','LICENSE','*.py','dbgen/queries','dbgen/answers'} extension/tpch/ ${VELOX_PATH}/velox/external/duckdb/tpch/
-
 After the new files are copied, ensure that the new code compiles and that it
 doesn't break any tests. Velox relies on many internal APIs, so there is a good
 chance that this will not work out-of-the-box and that you will have to dig in
diff --git a/velox/duckdb/conversion/CMakeLists.txt b/velox/duckdb/conversion/CMakeLists.txt
index ebf7f4fcb8bdb..8361cb68e20f1 100644
--- a/velox/duckdb/conversion/CMakeLists.txt
+++ b/velox/duckdb/conversion/CMakeLists.txt
@@ -11,15 +11,15 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_duckdb_conversion DuckConversion.cpp DuckWrapper.cpp)
+velox_add_library(velox_duckdb_conversion DuckConversion.cpp)
 
-target_link_libraries(velox_duckdb_conversion velox_core velox_vector duckdb
-                      tpch_extension)
+velox_link_libraries(velox_duckdb_conversion velox_core velox_vector
+                     duckdb_static)
 
-add_library(velox_duckdb_parser DuckParser.cpp)
+velox_add_library(velox_duckdb_parser DuckParser.cpp)
 
-target_link_libraries(velox_duckdb_parser velox_duckdb_conversion duckdb
-                      velox_parse_expression)
+velox_link_libraries(velox_duckdb_parser velox_duckdb_conversion
+                     velox_parse_expression duckdb_static)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/duckdb/conversion/DuckConversion.cpp b/velox/duckdb/conversion/DuckConversion.cpp
index 7764b3b99b041..63c99b97031b1 100644
--- a/velox/duckdb/conversion/DuckConversion.cpp
+++ b/velox/duckdb/conversion/DuckConversion.cpp
@@ -33,7 +33,7 @@ using ::duckdb::string_t;
 using ::duckdb::timestamp_t;
 
 variant decimalVariant(const Value& val) {
-  VELOX_DCHECK(val.type().id() == LogicalTypeId::DECIMAL)
+  VELOX_DCHECK(val.type().id() == LogicalTypeId::DECIMAL);
   switch (val.type().InternalType()) {
     case ::duckdb::PhysicalType::INT128: {
       auto unscaledValue = val.GetValueUnsafe<::duckdb::hugeint_t>();
@@ -140,6 +140,12 @@ TypePtr toVeloxType(LogicalType type, bool fileColumnNamesReadAsLowerCase) {
       return DATE();
     case LogicalTypeId::TIMESTAMP:
       return TIMESTAMP();
+    case LogicalTypeId::TIMESTAMP_TZ: {
+      if (auto customType = getCustomType("TIMESTAMP WITH TIME ZONE")) {
+        return customType;
+      }
+      [[fallthrough]];
+    }
     case LogicalTypeId::INTERVAL:
       return INTERVAL_DAY_TIME();
     case LogicalTypeId::BLOB:
@@ -175,6 +181,19 @@ TypePtr toVeloxType(LogicalType type, bool fileColumnNamesReadAsLowerCase) {
       }
       return ROW(std::move(names), std::move(types));
     }
+    case LogicalTypeId::UUID: {
+      if (auto customType = getCustomType("UUID")) {
+        return customType;
+      }
+      [[fallthrough]];
+    }
+    case LogicalTypeId::USER: {
+      const auto name = ::duckdb::UserType::GetTypeName(type);
+      if (auto customType = getCustomType(name)) {
+        return customType;
+      }
+      [[fallthrough]];
+    }
     default:
       throw std::runtime_error(
           "unsupported type for duckdb -> velox conversion: " +
diff --git a/velox/duckdb/conversion/DuckConversion.h b/velox/duckdb/conversion/DuckConversion.h
index de5d2fc4fdf7c..9888a0cb66a87 100644
--- a/velox/duckdb/conversion/DuckConversion.h
+++ b/velox/duckdb/conversion/DuckConversion.h
@@ -15,9 +15,10 @@
  */
 #pragma once
 
-#include "velox/external/duckdb/duckdb.hpp"
 #include "velox/type/Type.h"
 
+#include <duckdb.hpp> // @manual
+
 namespace facebook::velox {
 class variant;
 }
diff --git a/velox/duckdb/conversion/DuckParser.cpp b/velox/duckdb/conversion/DuckParser.cpp
index 3e57f1330c1da..a3ce0702b67df 100644
--- a/velox/duckdb/conversion/DuckParser.cpp
+++ b/velox/duckdb/conversion/DuckParser.cpp
@@ -17,10 +17,23 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/PlanNode.h"
 #include "velox/duckdb/conversion/DuckConversion.h"
-#include "velox/external/duckdb/duckdb.hpp"
 #include "velox/parse/Expressions.h"
 #include "velox/type/Variant.h"
 
+#include <duckdb.hpp> // @manual
+#include <duckdb/parser/expression/between_expression.hpp> // @manual
+#include <duckdb/parser/expression/case_expression.hpp> // @manual
+#include <duckdb/parser/expression/cast_expression.hpp> // @manual
+#include <duckdb/parser/expression/comparison_expression.hpp> // @manual
+#include <duckdb/parser/expression/conjunction_expression.hpp> // @manual
+#include <duckdb/parser/expression/constant_expression.hpp> // @manual
+#include <duckdb/parser/expression/function_expression.hpp> // @manual
+#include <duckdb/parser/expression/lambda_expression.hpp> // @manual
+#include <duckdb/parser/expression/operator_expression.hpp> // @manual
+#include <duckdb/parser/expression/window_expression.hpp> // @manual
+#include <duckdb/parser/parser.hpp> // @manual
+#include <duckdb/parser/parser_options.hpp> // @manual
+
 namespace facebook::velox::duckdb {
 
 using ::duckdb::BetweenExpression;
@@ -387,8 +400,8 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
             ExpressionType::VALUE_CONSTANT) {
           auto constExpr =
               dynamic_cast<ConstantExpression*>(castExpr->child.get());
-          auto value =
-              constExpr->value.CastAs(castExpr->cast_type, !castExpr->try_cast);
+          auto value = constExpr->value.DefaultCastAs(
+              castExpr->cast_type, !castExpr->try_cast);
           values.emplace_back(duckValueToVariant(value));
           valueType = toVeloxType(castExpr->cast_type);
           continue;
@@ -557,7 +570,7 @@ std::shared_ptr<const core::IExpr> parseLambdaExpr(
     const ParseOptions& options) {
   const auto& lambdaExpr = dynamic_cast<::duckdb::LambdaExpression&>(expr);
   auto capture = parseExpr(*lambdaExpr.lhs, options);
-  auto body = parseExpr(*lambdaExpr.rhs, options);
+  auto body = parseExpr(*lambdaExpr.expr, options);
 
   // capture is either a core::FieldAccessExpr or a 'row' core::CallExpr with 2
   // or more core::FieldAccessExpr inputs.
@@ -581,7 +594,7 @@ std::shared_ptr<const core::IExpr> parseLambdaExpr(
   } else {
     VELOX_FAIL(
         "Unexpected left-hand-side expression for the lambda expression: {}",
-        capture->toString())
+        capture->toString());
   }
 
   return std::make_shared<const core::LambdaExpr>(
@@ -629,8 +642,8 @@ std::shared_ptr<const core::IExpr> parseExpr(
   }
 }
 
-std::vector<std::unique_ptr<::duckdb::ParsedExpression>> parseExpression(
-    const std::string& exprString) {
+::duckdb::vector<::duckdb::unique_ptr<::duckdb::ParsedExpression>>
+parseExpression(const std::string& exprString) {
   ParserOptions options;
   options.preserve_identifier_case = false;
 
@@ -682,7 +695,7 @@ bool isAscending(::duckdb::OrderType orderType, const std::string& exprString) {
       return true;
     case ::duckdb::OrderType::INVALID:
     default:
-      VELOX_FAIL("Cannot parse ORDER BY clause: {}", exprString)
+      VELOX_FAIL("Cannot parse ORDER BY clause: {}", exprString);
   }
 }
 
@@ -699,7 +712,7 @@ bool isNullsFirst(
       return false;
     case ::duckdb::OrderByNullType::INVALID:
     default:
-      VELOX_FAIL("Cannot parse ORDER BY clause: {}", exprString)
+      VELOX_FAIL("Cannot parse ORDER BY clause: {}", exprString);
   }
 
   VELOX_UNREACHABLE();
@@ -758,8 +771,7 @@ AggregateExpr parseAggregateExpr(
 
 namespace {
 WindowType parseWindowType(const WindowExpression& expr) {
-  auto windowType =
-      [&](const ::duckdb::WindowBoundary& boundary) -> WindowType {
+  auto windowType = [&](const WindowBoundary& boundary) -> WindowType {
     if (boundary == WindowBoundary::CURRENT_ROW_ROWS ||
         boundary == WindowBoundary::EXPR_FOLLOWING_ROWS ||
         boundary == WindowBoundary::EXPR_PRECEDING_ROWS) {
diff --git a/velox/duckdb/conversion/DuckWrapper.cpp b/velox/duckdb/conversion/DuckWrapper.cpp
deleted file mode 100644
index 5e6bd9bc59b84..0000000000000
--- a/velox/duckdb/conversion/DuckWrapper.cpp
+++ /dev/null
@@ -1,356 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/duckdb/conversion/DuckWrapper.h"
-#include "velox/common/base/BitUtil.h"
-#include "velox/duckdb/conversion/DuckConversion.h"
-#include "velox/external/duckdb/duckdb.hpp"
-#include "velox/external/duckdb/tpch/include/tpch-extension.hpp"
-#include "velox/vector/FlatVector.h"
-
-namespace facebook::velox::duckdb {
-using ::duckdb::Connection;
-using ::duckdb::DataChunk;
-using ::duckdb::DuckDB;
-using ::duckdb::Hugeint;
-using ::duckdb::hugeint_t;
-using ::duckdb::LogicalTypeId;
-using ::duckdb::PhysicalType;
-using ::duckdb::QueryResult;
-
-namespace {
-
-class DuckDBBufferReleaser {
- public:
-  explicit DuckDBBufferReleaser(
-      ::duckdb::buffer_ptr<::duckdb::VectorBuffer> buffer)
-      : buffer_(std::move(buffer)) {}
-
-  void addRef() const {}
-  void release() const {}
-
- private:
-  const ::duckdb::buffer_ptr<::duckdb::VectorBuffer> buffer_;
-};
-
-class DuckDBValidityReleaser {
- public:
-  explicit DuckDBValidityReleaser(const ::duckdb::ValidityMask& validity)
-      : validity_(validity) {}
-
-  void addRef() const {}
-  void release() const {}
-
- private:
-  const ::duckdb::ValidityMask validity_;
-};
-
-} // namespace
-
-DuckDBWrapper::DuckDBWrapper(core::ExecCtx* context, const char* path)
-    : context_(context) {
-  db_ = std::make_unique<DuckDB>(path);
-  connection_ = std::make_unique<Connection>(*db_);
-  db_->LoadExtension<::duckdb::TPCHExtension>();
-}
-
-DuckDBWrapper::~DuckDBWrapper() {}
-
-std::unique_ptr<DuckResult> DuckDBWrapper::execute(const std::string& query) {
-  auto duckResult = connection_->Query(query);
-  return std::make_unique<DuckResult>(context_, std::move(duckResult));
-}
-
-void DuckDBWrapper::print(const std::string& query) {
-  auto result = connection_->Query(query);
-  result->Print();
-}
-
-DuckResult::DuckResult(
-    core::ExecCtx* context,
-    std::unique_ptr<QueryResult> queryResult)
-    : context_(context), queryResult_(std::move(queryResult)) {
-  auto columnCount = queryResult_->types.size();
-
-  std::vector<std::string> names;
-  std::vector<TypePtr> types;
-  names.reserve(columnCount);
-  types.reserve(columnCount);
-  for (auto i = 0; i < columnCount; i++) {
-    types.push_back(getType(i));
-    names.push_back(getName(i));
-  }
-  type_ = std::make_shared<RowType>(std::move(names), std::move(types));
-}
-
-DuckResult::~DuckResult() {}
-
-bool DuckResult::success() {
-  return queryResult_->success;
-}
-
-std::string DuckResult::errorMessage() {
-  return queryResult_->error;
-}
-
-RowVectorPtr DuckResult::getVector() {
-  auto rowType = getType();
-  std::vector<VectorPtr> outputColumns;
-  outputColumns.reserve(columnCount());
-  for (auto i = 0; i < columnCount(); i++) {
-    outputColumns.push_back(getVector(i));
-  }
-
-  return std::make_shared<RowVector>(
-      context_->pool(),
-      rowType,
-      BufferPtr(nullptr),
-      currentChunk_->size(),
-      outputColumns);
-}
-
-TypePtr DuckResult::getType(size_t columnIdx) {
-  assert(columnIdx < queryResult_->types.size());
-  return toVeloxType(queryResult_->types[columnIdx]);
-}
-
-std::string DuckResult::getName(size_t columnIdx) {
-  assert(columnIdx < queryResult_->names.size());
-  return queryResult_->names[columnIdx];
-}
-
-inline bool isZeroCopyEligible(const ::duckdb::LogicalType& duckType) {
-  if (duckType.id() == LogicalTypeId::DECIMAL) {
-    if (duckType.InternalType() == PhysicalType::INT64 ||
-        duckType.InternalType() == PhysicalType::INT128) {
-      return true;
-    }
-    return false;
-  }
-
-  if (duckType.id() == LogicalTypeId::HUGEINT ||
-      duckType.id() == LogicalTypeId::TIMESTAMP ||
-      duckType.id() == LogicalTypeId::BOOLEAN ||
-      duckType.id() == LogicalTypeId::BLOB ||
-      duckType.id() == LogicalTypeId::VARCHAR) {
-    return false;
-  }
-  return true;
-}
-
-template <class OP>
-VectorPtr convert(
-    ::duckdb::Vector& duckVector,
-    const TypePtr& veloxType,
-    size_t size,
-    memory::MemoryPool* pool,
-    uint8_t* validity = nullptr) {
-  auto vectorType = duckVector.GetVectorType();
-  switch (vectorType) {
-    case ::duckdb::VectorType::FLAT_VECTOR: {
-      VectorPtr result;
-      auto& duckValidity = ::duckdb::FlatVector::Validity(duckVector);
-      auto* duckData =
-          ::duckdb::FlatVector::GetData<typename OP::DUCK_TYPE>(duckVector);
-
-      // Some DuckDB vectors have different internal layout and cannot be
-      // trivially copied.
-      if (!isZeroCopyEligible(duckVector.GetType())) {
-        // TODO Figure out how to perform a zero-copy conversion.
-        result = BaseVector::create(veloxType, size, pool);
-        auto flatResult = result->as<FlatVector<typename OP::VELOX_TYPE>>();
-
-        for (auto i = 0; i < size; i++) {
-          if (duckValidity.RowIsValid(i) &&
-              (!validity || bits::isBitSet(validity, i))) {
-            flatResult->set(i, OP::toVelox(duckData[i]));
-          }
-        }
-
-        if (!duckValidity.AllValid()) {
-          auto rawNulls = flatResult->mutableRawNulls();
-          memcpy(rawNulls, duckValidity.GetData(), bits::nbytes(size));
-        }
-      } else {
-        auto valuesView = BufferView<DuckDBBufferReleaser>::create(
-            reinterpret_cast<const uint8_t*>(duckData),
-            size * sizeof(typename OP::VELOX_TYPE),
-            DuckDBBufferReleaser(duckVector.GetBuffer()));
-
-        BufferPtr nullsView(nullptr);
-        if (!duckValidity.AllValid()) {
-          nullsView = BufferView<DuckDBValidityReleaser>::create(
-              reinterpret_cast<const uint8_t*>(duckValidity.GetData()),
-              bits::nbytes(size),
-              DuckDBValidityReleaser(duckValidity));
-        }
-
-        result = std::make_shared<FlatVector<typename OP::VELOX_TYPE>>(
-            pool,
-            veloxType,
-            nullsView,
-            size,
-            valuesView,
-            std::vector<BufferPtr>());
-      }
-
-      return result;
-    }
-    case ::duckdb::VectorType::DICTIONARY_VECTOR: {
-      auto& child = ::duckdb::DictionaryVector::Child(duckVector);
-      auto& selection = ::duckdb::DictionaryVector::SelVector(duckVector);
-
-      // DuckDB vectors doesn't tell what their size is. We are going to use max
-      // index + 1 instead as the vector is guaranteed to be at least that
-      // large.
-      vector_size_t maxIndex = 0;
-      for (auto i = 0; i < size; i++) {
-        maxIndex = std::max(maxIndex, (vector_size_t)selection.get_index(i));
-      }
-      VectorPtr base;
-      // Unused dictionary elements can be uninitialized. That can cause
-      // errors if we try to decode them. Here we create a bitmap of
-      // used values to avoid that.
-      if (child.GetType() == LogicalTypeId::HUGEINT ||
-          child.GetType() == LogicalTypeId::TIMESTAMP ||
-          child.GetType() == LogicalTypeId::VARCHAR) {
-        std::vector<uint8_t> validityVector(bits::nbytes(maxIndex + 1), 0);
-        auto validity_ptr = validityVector.data();
-        for (auto i = 0; i < size; i++) {
-          bits::setBit(validity_ptr, selection.get_index(i));
-        }
-        base = convert<OP>(child, veloxType, maxIndex + 1, pool, validity_ptr);
-      } else {
-        base = convert<OP>(child, veloxType, maxIndex + 1, pool);
-      }
-
-      auto indices = AlignedBuffer::allocate<vector_size_t>(size, pool);
-      memcpy(
-          indices->asMutable<vector_size_t>(),
-          selection.data(),
-          size * sizeof(vector_size_t));
-
-      return BaseVector::wrapInDictionary(
-          BufferPtr(nullptr), indices, size, base);
-    }
-    default:
-      VELOX_UNSUPPORTED(
-          "Unsupported DuckDB vector encoding: {}",
-          ::duckdb::VectorTypeToString(vectorType));
-  }
-}
-
-struct NumericCastToDouble {
-  template <class T>
-  static double operation(T input) {
-    return double(input);
-  }
-};
-
-template <>
-double NumericCastToDouble::operation(hugeint_t input) {
-  return Hugeint::Cast<double>(input);
-}
-
-VectorPtr toVeloxVector(
-    int32_t size,
-    ::duckdb::Vector& duckVector,
-    const TypePtr& veloxType,
-    memory::MemoryPool* pool) {
-  VectorPtr veloxFlatVector;
-
-  auto type = duckVector.GetType();
-  switch (type.id()) {
-    case LogicalTypeId::BOOLEAN:
-      return convert<DuckNumericConversion<bool>>(
-          duckVector, veloxType, size, pool);
-    case LogicalTypeId::TINYINT:
-      return convert<DuckNumericConversion<int8_t>>(
-          duckVector, veloxType, size, pool);
-    case LogicalTypeId::SMALLINT:
-      return convert<DuckNumericConversion<int16_t>>(
-          duckVector, veloxType, size, pool);
-    case LogicalTypeId::INTEGER:
-      return convert<DuckNumericConversion<int32_t>>(
-          duckVector, veloxType, size, pool);
-    case LogicalTypeId::BIGINT:
-      return convert<DuckNumericConversion<int64_t>>(
-          duckVector, veloxType, size, pool);
-    case LogicalTypeId::HUGEINT:
-      return convert<DuckHugeintConversion>(duckVector, veloxType, size, pool);
-    case LogicalTypeId::FLOAT:
-      return convert<DuckNumericConversion<float>>(
-          duckVector, veloxType, size, pool);
-    case LogicalTypeId::DOUBLE:
-      return convert<DuckNumericConversion<double>>(
-          duckVector, veloxType, size, pool);
-    case LogicalTypeId::DECIMAL: {
-      uint8_t width;
-      uint8_t scale;
-      type.GetDecimalProperties(width, scale);
-      switch (type.InternalType()) {
-        case PhysicalType::INT16:
-          return convert<DuckInt16DecimalConversion>(
-              duckVector, veloxType, size, pool);
-        case PhysicalType::INT32:
-          return convert<DuckInt32DecimalConversion>(
-              duckVector, veloxType, size, pool);
-        case PhysicalType::INT64:
-          return convert<DuckInt64DecimalConversion>(
-              duckVector, veloxType, size, pool);
-        case PhysicalType::INT128:
-          return convert<DuckLongDecimalConversion>(
-              duckVector, veloxType, size, pool);
-        default:
-          throw std::runtime_error(
-              "unrecognized internal type for decimal (this shouldn't happen");
-      }
-    }
-    case LogicalTypeId::VARCHAR:
-      return convert<DuckStringConversion>(duckVector, veloxType, size, pool);
-    case LogicalTypeId::BLOB:
-      return convert<DuckBlobConversion>(duckVector, veloxType, size, pool);
-    case LogicalTypeId::DATE:
-      return convert<DuckDateConversion>(duckVector, veloxType, size, pool);
-    case LogicalTypeId::TIMESTAMP:
-      return convert<DuckTimestampConversion>(
-          duckVector, veloxType, size, pool);
-    default:
-      throw std::runtime_error(
-          "Unsupported vector type for conversion: " + type.ToString());
-  }
-}
-
-VectorPtr DuckResult::getVector(size_t columnIdx) {
-  VELOX_CHECK_LT(columnIdx, columnCount());
-  VELOX_CHECK(
-      currentChunk_,
-      "no chunk available: did you call next() and did it return true?");
-  auto& duckVector = currentChunk_->data[columnIdx];
-  auto resultType = getType(columnIdx);
-  return toVeloxVector(
-      currentChunk_->size(), duckVector, resultType, context_->pool());
-}
-
-bool DuckResult::next() {
-  currentChunk_ = queryResult_->Fetch();
-  if (!currentChunk_) {
-    return false;
-  }
-  currentChunk_->Normalify();
-  return currentChunk_->size() > 0;
-}
-
-} // namespace facebook::velox::duckdb
diff --git a/velox/duckdb/conversion/DuckWrapper.h b/velox/duckdb/conversion/DuckWrapper.h
deleted file mode 100644
index 5465caf4a23cd..0000000000000
--- a/velox/duckdb/conversion/DuckWrapper.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <memory>
-#include <string>
-#include "velox/core/QueryCtx.h"
-#include "velox/type/Type.h"
-#include "velox/vector/BaseVector.h"
-#include "velox/vector/ComplexVector.h"
-
-namespace duckdb {
-class DuckDB;
-class Connection;
-class DataChunk;
-class QueryResult;
-class Vector;
-} // namespace duckdb
-
-namespace facebook::velox::duckdb {
-
-class DuckResult;
-
-class DuckDBWrapper {
- public:
-  //! Opens a DuckDB database object with an optional path to the physical
-  //! database (default: in-memory only)
-  explicit DuckDBWrapper(core::ExecCtx* context, const char* path = nullptr);
-  ~DuckDBWrapper();
-
-  //! Execute a SQL query in the loaded database, and return the result as a
-  //! DuckResult
-  std::unique_ptr<DuckResult> execute(const std::string& query);
-
-  //! Execute a SQL query in the loaded database and print the result to stdout
-  void print(const std::string& query);
-
- private:
-  core::ExecCtx* context_;
-  std::unique_ptr<::duckdb::DuckDB> db_;
-  std::unique_ptr<::duckdb::Connection> connection_;
-};
-
-class DuckResult {
- public:
-  DuckResult(
-      core::ExecCtx* context,
-      std::unique_ptr<::duckdb::QueryResult> query_result);
-  ~DuckResult();
-
- public:
-  //! Returns true if the query succeeded, or false if it failed
-  bool success();
-
-  //! Returns the error message in case the query failed
-  std::string errorMessage();
-
-  //! Returns the number of columns in the result
-  size_t columnCount() {
-    return type_ ? type_->size() : 0;
-  }
-
-  //! Get the type of the result as a row
-  std::shared_ptr<const RowType> getType() {
-    return type_;
-  }
-
-  //! Gets a vector of the query result; returns nullptr if the result has no
-  //! data (i.e. when next() has returned false, or when next() has not been
-  //! called yet)
-  RowVectorPtr getVector();
-
-  //! Fetches the next chunk from the result set; returns true if there is more
-  //! data, or false if finished Next needs to be called before any data is
-  //! fetched from the result
-  bool next();
-
- private:
-  core::ExecCtx* context_;
-  std::shared_ptr<const RowType> type_;
-
-  std::unique_ptr<::duckdb::QueryResult> queryResult_;
-  std::unique_ptr<::duckdb::DataChunk> currentChunk_;
-
- private:
-  //! Returns the type of the column at the specified column index; index should
-  //! be in range [0, column_count)
-  TypePtr getType(size_t columnIdx);
-
-  //! Returns the name of the column at the specified column index; index should
-  //! be in range [0, column_count)
-  std::string getName(size_t columnIdx);
-
-  //! Fetch a single vector of the result; index should
-  //! be in range [0, column_count)
-  VectorPtr getVector(size_t columnIdx);
-};
-
-VectorPtr toVeloxVector(
-    int32_t size,
-    ::duckdb::Vector& duckVector,
-    const TypePtr& veloxType,
-    memory::MemoryPool* pool);
-
-} // namespace facebook::velox::duckdb
diff --git a/velox/duckdb/conversion/tests/CMakeLists.txt b/velox/duckdb/conversion/tests/CMakeLists.txt
index 1ee92eac424a9..3a4607dd8a898 100644
--- a/velox/duckdb/conversion/tests/CMakeLists.txt
+++ b/velox/duckdb/conversion/tests/CMakeLists.txt
@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_duckdb_conversion_test
-               DuckConversionTest.cpp DuckParserTest.cpp DuckWrapperTest.cpp)
+add_executable(velox_duckdb_conversion_test DuckConversionTest.cpp
+                                            DuckParserTest.cpp)
 
 add_test(velox_duckdb_conversion_test velox_duckdb_conversion_test)
 
@@ -24,6 +24,6 @@ target_link_libraries(
   velox_functions_prestosql
   velox_functions_lib
   velox_functions_test_lib
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags)
diff --git a/velox/duckdb/conversion/tests/DuckConversionTest.cpp b/velox/duckdb/conversion/tests/DuckConversionTest.cpp
index c53c956bc297c..d73f222b81872 100644
--- a/velox/duckdb/conversion/tests/DuckConversionTest.cpp
+++ b/velox/duckdb/conversion/tests/DuckConversionTest.cpp
@@ -16,7 +16,6 @@
 #include "velox/duckdb/conversion/DuckConversion.h"
 #include <gtest/gtest.h>
 #include <limits>
-#include "velox/external/duckdb/duckdb.hpp"
 #include "velox/type/Variant.h"
 
 using namespace facebook::velox;
@@ -86,12 +85,18 @@ TEST(DuckConversionTest, duckValueToVariant) {
 }
 
 TEST(DuckConversionTest, duckValueToVariantUnsupported) {
+  /// We use ::duckdb::TransformStringToLogicalType() for scalar types instead
+  /// of LogicalType:: due this bug in GCC
+  /// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101957. The scalar types are
+  /// defined as static constexpr const causing a double definition only in the
+  /// debug build.
   std::vector<LogicalType> unsupported = {
-      LogicalType::TIME,
-      LogicalType::INTERVAL,
-      LogicalType::LIST({LogicalType::INTEGER}),
+      ::duckdb::TransformStringToLogicalType("time"),
+      ::duckdb::TransformStringToLogicalType("interval"),
+      LogicalType::LIST({::duckdb::TransformStringToLogicalType("integer")}),
       LogicalType::STRUCT(
-          {{"a", LogicalType::INTEGER}, {"b", LogicalType::TINYINT}})};
+          {{"a", ::duckdb::TransformStringToLogicalType("integer")},
+           {"b", ::duckdb::TransformStringToLogicalType("tinyint")}})};
 
   for (const auto& i : unsupported) {
     EXPECT_THROW(duckValueToVariant(Value(i)), std::runtime_error);
@@ -135,10 +140,10 @@ TEST(DuckConversionTest, createTable) {
 
   auto testCreateTable = [&](const RowTypePtr& rowType) {
     auto result = con.Query("DROP TABLE IF EXISTS t");
-    VELOX_CHECK(result->success, "{}", result->error);
+    VELOX_CHECK(!result->HasError(), "{}", result->GetError());
 
     result = con.Query(makeCreateTableSql("t", *rowType));
-    VELOX_CHECK(result->success, "{}", result->error);
+    VELOX_CHECK(!result->HasError(), "{}", result->GetError());
   };
 
   testCreateTable(
diff --git a/velox/duckdb/conversion/tests/DuckParserTest.cpp b/velox/duckdb/conversion/tests/DuckParserTest.cpp
index ab72297239a1e..b3608e6a571af 100644
--- a/velox/duckdb/conversion/tests/DuckParserTest.cpp
+++ b/velox/duckdb/conversion/tests/DuckParserTest.cpp
@@ -16,6 +16,8 @@
 #include "velox/duckdb/conversion/DuckParser.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/PlanNode.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/parse/Expressions.h"
 
 using namespace facebook::velox;
@@ -367,6 +369,22 @@ TEST(DuckParserTest, cast) {
       parseExpr("cast(c0 as struct(a bigint, b real, c varchar))")->toString());
 }
 
+TEST(DuckParserTest, castToJson) {
+  registerJsonType();
+  EXPECT_EQ("cast(\"c0\", JSON)", parseExpr("cast(c0 as json)")->toString());
+  EXPECT_EQ("cast(\"c0\", JSON)", parseExpr("cast(c0 as JSON)")->toString());
+}
+
+TEST(DuckParserTest, castToTimestampWithTimeZone) {
+  registerTimestampWithTimeZoneType();
+  EXPECT_EQ(
+      "cast(\"c0\", TIMESTAMP WITH TIME ZONE)",
+      parseExpr("cast(c0 as timestamp with time zone)")->toString());
+  EXPECT_EQ(
+      "cast(\"c0\", TIMESTAMP WITH TIME ZONE)",
+      parseExpr("cast(c0 as TIMESTAMP WITH TIME ZONE)")->toString());
+}
+
 TEST(DuckParserTest, ifCase) {
   EXPECT_EQ("if(99,1,0)", parseExpr("if(99, 1, 0)")->toString());
   EXPECT_EQ(
diff --git a/velox/duckdb/conversion/tests/DuckWrapperTest.cpp b/velox/duckdb/conversion/tests/DuckWrapperTest.cpp
deleted file mode 100644
index 52b00bbb9e8ab..0000000000000
--- a/velox/duckdb/conversion/tests/DuckWrapperTest.cpp
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/duckdb/conversion/DuckWrapper.h"
-#include "velox/external/duckdb/duckdb.hpp"
-#include "velox/vector/tests/utils/VectorMaker.h"
-
-#include <gtest/gtest.h>
-
-using namespace facebook::velox;
-using namespace facebook::velox::duckdb;
-
-class BaseDuckWrapperTest : public testing::Test {
- public:
-  template <class T>
-  void verifyUnaryResult(
-      const std::string& query,
-      const std::vector<T>& expectedOutput,
-      const std::vector<bool>& nulls) {
-    auto result = db_->execute(query);
-    ASSERT_EQ(result->success(), true)
-        << "Query failed: " << result->errorMessage();
-    ASSERT_EQ(result->columnCount(), 1);
-    size_t currentOffset = 0;
-    while (result->next()) {
-      auto rowVector = result->getVector();
-      auto simpleVector = rowVector->childAt(0)->as<SimpleVector<T>>();
-      ASSERT_NE(simpleVector, nullptr);
-      for (auto i = 0; i < simpleVector->size(); i++) {
-        auto rowNr = currentOffset + i;
-        ASSERT_LE(rowNr, expectedOutput.size());
-        if (nulls[rowNr]) {
-          ASSERT_EQ(simpleVector->isNullAt(i), true);
-        } else {
-          ASSERT_EQ(simpleVector->isNullAt(i), false);
-          ASSERT_EQ(simpleVector->valueAt(i), expectedOutput[rowNr]);
-        }
-      }
-      currentOffset += simpleVector->size();
-    }
-    ASSERT_EQ(currentOffset, expectedOutput.size());
-  }
-
-  template <class T>
-  void verifyUnaryResult(
-      const std::string& query,
-      const std::vector<T>& expectedOutput) {
-    std::vector<bool> nulls(expectedOutput.size(), false);
-    verifyUnaryResult<T>(
-        std::move(query), std::move(expectedOutput), std::move(nulls));
-  }
-
-  template <class T>
-  void verifyDuckToVeloxDecimal(
-      const std::string& query,
-      const std::vector<std::optional<T>>& expected) {
-    auto result = db_->execute(query);
-    ASSERT_EQ(result->success(), true)
-        << "Query failed: " << result->errorMessage();
-    ASSERT_EQ(result->columnCount(), 1);
-    size_t currentOffset = 0;
-    while (result->next()) {
-      auto rowVector = result->getVector();
-      auto simpleVector = rowVector->childAt(0)->as<SimpleVector<T>>();
-      ASSERT_NE(simpleVector, nullptr);
-      for (auto i = 0; i < simpleVector->size(); i++) {
-        if (simpleVector->isNullAt(i)) {
-          ASSERT_FALSE(expected[i].has_value());
-          continue;
-        }
-        ASSERT_EQ(simpleVector->valueAt(i), expected[i]);
-      }
-    }
-  }
-
-  void execute(const std::string& query) {
-    auto result = db_->execute(query);
-    ASSERT_EQ(result->success(), true)
-        << "Query failed: " << result->errorMessage();
-  }
-
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  std::unique_ptr<core::ExecCtx> execCtx_{
-      std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
-  std::unique_ptr<DuckDBWrapper> db_{
-      std::make_unique<DuckDBWrapper>(execCtx_.get())};
-};
-
-TEST_F(BaseDuckWrapperTest, simpleSelect) {
-  // scalar query
-  verifyUnaryResult<int32_t>("SELECT 42::INTEGER", {42});
-
-  // bit more complex
-  verifyUnaryResult<int32_t>(
-      "SELECT a::INTEGER FROM (VALUES (1), (2), (3)) tbl(a)", {1, 2, 3});
-
-  // now with a table
-  execute("CREATE TABLE integers(i INTEGER)");
-  execute("INSERT INTO integers VALUES (1), (2), (3), (NULL)");
-
-  verifyUnaryResult<int32_t>(
-      "SELECT * FROM integers", {1, 2, 3, 0}, {false, false, false, true});
-}
-
-TEST_F(BaseDuckWrapperTest, scalarTypes) {
-  // test various types
-  // boolean types
-  execute("CREATE TABLE booleans(i BOOLEAN)");
-  execute("INSERT INTO booleans VALUES (true), (true), (false), (false)");
-  verifyUnaryResult<bool>("SELECT * FROM booleans", {true, true, false, false});
-
-  // integer types
-  verifyUnaryResult<int8_t>("SELECT 42::TINYINT", {42});
-  verifyUnaryResult<int16_t>("SELECT 42::SMALLINT", {42});
-  verifyUnaryResult<int32_t>("SELECT 42::INTEGER", {42});
-  verifyUnaryResult<int64_t>("SELECT 42::BIGINT", {42});
-
-  // hugeint is cast to double
-  verifyUnaryResult<double>("SELECT 42::HUGEINT", {42});
-
-  // numeric types
-  verifyUnaryResult<float>("SELECT 1::FLOAT", {1.0});
-  verifyUnaryResult<double>("SELECT 1::DOUBLE", {1.0});
-
-  // date/timestamp
-  verifyUnaryResult<int32_t>("SELECT DATE '1992-01-01'", {8035});
-  verifyUnaryResult<Timestamp>(
-      "SELECT TIMESTAMP '1992-01-01 13:04:20'", {Timestamp(694271060, 0)});
-
-  // varchar
-  verifyUnaryResult<StringView>("SELECT 'shortstr'", {StringView("shortstr")});
-  verifyUnaryResult<StringView>(
-      "SELECT '12characters'", {StringView("12characters")});
-  verifyUnaryResult<StringView>(
-      "SELECT 'this is a long, non-inlined, example string'",
-      {StringView("this is a long, non-inlined, example string")});
-
-  // blob
-  verifyUnaryResult<StringView>("SELECT '\\xFF'::BLOB", {StringView("\xFF")});
-}
-
-TEST_F(BaseDuckWrapperTest, types) {
-  // test various types
-  // integer types
-  verifyUnaryResult<int8_t>(
-      "SELECT i::TINYINT FROM (VALUES (1), (2), (3), (NULL)) tbl(i)",
-      {1, 2, 3, 0},
-      {false, false, false, true});
-  verifyUnaryResult<int16_t>(
-      "SELECT i::SMALLINT FROM (VALUES (1), (2), (3), (NULL)) tbl(i)",
-      {1, 2, 3, 0},
-      {false, false, false, true});
-  verifyUnaryResult<int32_t>(
-      "SELECT i::INTEGER FROM (VALUES (1), (2), (3), (NULL)) tbl(i)",
-      {1, 2, 3, 0},
-      {false, false, false, true});
-  verifyUnaryResult<int64_t>(
-      "SELECT i::BIGINT FROM (VALUES (1), (2), (3), (NULL)) tbl(i)",
-      {1, 2, 3, 0},
-      {false, false, false, true});
-
-  // hugeint is cast to double
-  verifyUnaryResult<double>(
-      "SELECT i::HUGEINT FROM (VALUES (1), (2), (4), (NULL)) tbl(i)",
-      {1, 2, 4, 0},
-      {false, false, false, true});
-
-  // numeric types
-  verifyUnaryResult<float>(
-      "SELECT i::FLOAT FROM (VALUES (1), (2), (4), (NULL)) tbl(i)",
-      {1, 2, 4, 0},
-      {false, false, false, true});
-  verifyUnaryResult<double>(
-      "SELECT i::DOUBLE FROM (VALUES (1), (2), (4), (NULL)) tbl(i)",
-      {1, 2, 4, 0},
-      {false, false, false, true});
-
-  // date/timestamp
-  verifyUnaryResult<int32_t>(
-      "SELECT i FROM (VALUES (DATE '1992-01-01'), (NULL)) tbl(i)",
-      {8035, 0},
-      {false, true});
-  verifyUnaryResult<Timestamp>(
-      "SELECT i FROM (VALUES (TIMESTAMP '1992-01-01 13:04:20'), (NULL)) tbl(i)",
-      {Timestamp(694271060, 0), Timestamp(0, 0)},
-      {false, true});
-
-  // varchar
-  verifyUnaryResult<StringView>(
-      "SELECT * FROM (VALUES ('shortstr'), ('12characters'), ('this is a long, non-inlined, example string'), (NULL)) tbl(i)",
-      {StringView("shortstr"),
-       StringView("12characters"),
-       StringView("this is a long, non-inlined, example string"),
-       StringView("")},
-      {false, false, false, true});
-}
-
-TEST_F(BaseDuckWrapperTest, tpchEmpty) {
-  // test TPC-H loading and querying with an empty database
-  execute("CALL dbgen(sf=0)");
-  verifyUnaryResult<int32_t>(
-      "SELECT l_orderkey FROM lineitem WHERE l_orderkey=1", {});
-}
-
-TEST_F(BaseDuckWrapperTest, tpchSF1) {
-  // test TPC-H loading and querying SF0.01
-  execute("CALL dbgen(sf=0.01)");
-  // test conversion of date, decimal and string
-  verifyUnaryResult<int64_t>("SELECT l_discount FROM lineitem LIMIT 1", {4});
-  verifyUnaryResult<int32_t>("SELECT l_shipdate FROM lineitem LIMIT 1", {9568});
-  verifyUnaryResult<StringView>(
-      "SELECT l_comment FROM lineitem LIMIT 1",
-      {StringView("egular courts above the")});
-}
-
-TEST_F(BaseDuckWrapperTest, duckToVeloxDecimal) {
-  // Test SMALLINT decimal to UnscaledShortDecimal conversion.
-  verifyDuckToVeloxDecimal<int64_t>(
-      "select * from (values (NULL), ('1.2'::decimal(2,1)),"
-      "('2.2'::decimal(2,1)),('-4.2'::decimal(2,1)), (NULL))",
-      {std::nullopt, 12, 22, -42, std::nullopt});
-
-  // Test INTEGER decimal to UnscaledShortDecimal conversion.
-  verifyDuckToVeloxDecimal<int64_t>(
-      "select * from (values ('1111.1111'::decimal(8,4)),"
-      "('2222.2222'::decimal(8,4)),('-3333.3333'::decimal(8,4)))",
-      {11111111, 22222222, -33333333});
-
-  // Test BIGINT decimal to UnscaledLongDecimal conversion.
-  verifyDuckToVeloxDecimal<int64_t>(
-      "select * from (values ('-111111.111111'::decimal(12,6)),"
-      "('222222.222222'::decimal(12,6)),('333333.333333'::decimal(12,6)))",
-      {-111111111111, 222222222222, 333333333333});
-
-  verifyDuckToVeloxDecimal<int128_t>(
-      "select * from (values (NULL),"
-      "('12345678901234.789'::decimal(18,3) * 10000.555::decimal(20,3)),"
-      "('-55555555555555.789'::decimal(18,3) * 10000.555::decimal(20,3)), (NULL),"
-      "('-22222222222222.789'::decimal(18,3) * 10000.555::decimal(20,3)))",
-      {std::nullopt,
-       HugeInt::build(0X1a24, 0Xfa35bb8777ffff77),
-       HugeInt::build(0XFFFFFFFFFFFF8A59, 0X99FC706655BFAC11),
-       std::nullopt,
-       HugeInt::build(0XFFFFFFFFFFFFD0F0, 0XA3FE935B081D8D69)});
-}
-
-TEST_F(BaseDuckWrapperTest, decimalDictCoversion) {
-  constexpr int32_t size = 6;
-  ::duckdb::LogicalType* duckDecimalType =
-      static_cast<::duckdb::LogicalType*>(duckdb_create_decimal_type(4, 2));
-  ::duckdb::Vector data(*duckDecimalType, size);
-  auto dataPtr = reinterpret_cast<int16_t*>(data.GetBuffer()->GetData());
-  // Make dirty data which shouldn't be accessed.
-  memset(dataPtr, 0xAB, sizeof(int16_t) * size);
-  dataPtr[0] = 5000;
-  dataPtr[2] = 1000;
-  dataPtr[4] = 2000;
-  // Turn vector into dictionary.
-  ::duckdb::SelectionVector sel(size);
-  sel.set_index(0, 2);
-  sel.set_index(1, 4);
-  sel.set_index(2, 0);
-  sel.set_index(3, 4);
-  sel.set_index(4, 2);
-  sel.set_index(5, 0);
-  data.Slice(sel, size);
-
-  auto decimalType = DECIMAL(4, 2);
-  auto actual = toVeloxVector(size, data, decimalType, pool_.get());
-  std::vector<int64_t> expectedData({1000, 2000, 5000, 2000, 1000, 5000});
-
-  test::VectorMaker maker(pool_.get());
-  auto expectedFlatVector = maker.flatVector<int64_t>(size, decimalType);
-
-  for (auto i = 0; i < expectedData.size(); ++i) {
-    expectedFlatVector->set(i, expectedData[i]);
-  }
-
-  for (auto i = 0; i < actual->size(); i++) {
-    ASSERT_TRUE(expectedFlatVector->equalValueAt(actual.get(), i, i));
-  }
-  delete duckDecimalType;
-}
-
-TEST_F(BaseDuckWrapperTest, dictConversion) {
-  ::duckdb::Vector data(::duckdb::LogicalTypeId::VARCHAR, 5);
-  auto dataPtr =
-      reinterpret_cast<::duckdb::string_t*>(data.GetBuffer()->GetData());
-  // Make dirty data which shouldn't be accessed.
-  memset(dataPtr, 0xAB, sizeof(::duckdb::string_t) * 5);
-  dataPtr[2] = ::duckdb::string_t("value1");
-  dataPtr[4] = ::duckdb::string_t("value2");
-
-  // Turn vector into dictionary.
-  ::duckdb::SelectionVector sel(5);
-  sel.set_index(0, 2);
-  sel.set_index(1, 4);
-  sel.set_index(2, 2);
-  sel.set_index(3, 4);
-  sel.set_index(4, 2);
-  data.Slice(sel, 5);
-
-  auto actual = toVeloxVector(5, data, VarcharType::create(), pool_.get());
-
-  test::VectorMaker maker(pool_.get());
-  std::vector<std::string> expectedData(
-      {"value1", "value2", "value1", "value2", "value1"});
-  auto expected = maker.flatVector(expectedData);
-  for (auto i = 0; i < actual->size(); i++) {
-    ASSERT_TRUE(expected->equalValueAt(actual.get(), i, i));
-  }
-}
diff --git a/velox/dwio/CMakeLists.txt b/velox/dwio/CMakeLists.txt
index 2dd3ea5fac27f..efcb3c06bebe3 100644
--- a/velox/dwio/CMakeLists.txt
+++ b/velox/dwio/CMakeLists.txt
@@ -11,25 +11,27 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_link_libs INTERFACE)
-target_link_libraries(
+velox_add_library(velox_link_libs INTERFACE)
+velox_link_libraries(
   velox_link_libs
-  INTERFACE velox_caching
-            velox_dwio_catalog_fbhive
-            velox_dwio_common
-            velox_dwio_common_exception
-            velox_encode
-            velox_exception
-            velox_memory
-            velox_process
-            velox_serialization
-            velox_type
-            velox_type_fbhive
-            velox_vector
-            Folly::folly
-            fmt::fmt)
+  INTERFACE
+    velox_caching
+    velox_dwio_catalog_fbhive
+    velox_dwio_common
+    velox_dwio_common_exception
+    velox_encode
+    velox_exception
+    velox_memory
+    velox_process
+    velox_serialization
+    velox_type
+    velox_type_fbhive
+    velox_vector
+    Folly::folly
+    fmt::fmt)
 
 add_subdirectory(common)
 add_subdirectory(catalog)
 add_subdirectory(dwrf)
+add_subdirectory(orc)
 add_subdirectory(parquet)
diff --git a/velox/dwio/catalog/fbhive/CMakeLists.txt b/velox/dwio/catalog/fbhive/CMakeLists.txt
index f901b5727b335..e892107323684 100644
--- a/velox/dwio/catalog/fbhive/CMakeLists.txt
+++ b/velox/dwio/catalog/fbhive/CMakeLists.txt
@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_dwio_catalog_fbhive FileUtils.cpp)
-target_link_libraries(velox_dwio_catalog_fbhive velox_dwio_common_exception
-                      fmt::fmt Folly::folly)
+velox_add_library(velox_dwio_catalog_fbhive FileUtils.cpp)
+velox_link_libraries(velox_dwio_catalog_fbhive velox_dwio_common_exception
+                     fmt::fmt Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(test)
diff --git a/velox/dwio/catalog/fbhive/FileUtils.cpp b/velox/dwio/catalog/fbhive/FileUtils.cpp
index 792679d15abe1..94c75dffd995b 100644
--- a/velox/dwio/catalog/fbhive/FileUtils.cpp
+++ b/velox/dwio/catalog/fbhive/FileUtils.cpp
@@ -15,9 +15,12 @@
  */
 
 #include "FileUtils.h"
-#include <fmt/core.h>
+
 #include <bitset>
-#include "folly/container/Array.h"
+
+#include <fmt/core.h>
+#include <folly/container/Array.h>
+
 #include "velox/dwio/common/exception/Exception.h"
 
 namespace facebook {
@@ -29,7 +32,6 @@ namespace fbhive {
 namespace {
 
 constexpr size_t HEX_WIDTH = 2;
-const std::string DEFAULT_PARTITION_VALUE{"__HIVE_DEFAULT_PARTITION__"};
 
 constexpr auto charsToEscape = folly::make_array(
     '"',
@@ -94,7 +96,7 @@ std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
     parserFunc(part, entries);
   }
   return entries;
-};
+}
 
 // Strong assumption that all expressions in the form of a=b means a partition
 // key value pair in '/' separated tokens. We could have stricter validation
@@ -158,7 +160,8 @@ std::string FileUtils::unescapePathName(const std::string& data) {
 }
 
 std::string FileUtils::makePartName(
-    const std::vector<std::pair<std::string, std::string>>& entries) {
+    const std::vector<std::pair<std::string, std::string>>& entries,
+    bool partitionPathAsLowerCase) {
   size_t size = 0;
   size_t escapeCount = 0;
   std::for_each(entries.begin(), entries.end(), [&](auto& pair) {
@@ -166,9 +169,10 @@ std::string FileUtils::makePartName(
     DWIO_ENSURE_GT(keySize, 0);
     size += keySize;
     escapeCount += countEscape(pair.first);
+
     auto valSize = pair.second.size();
     if (valSize == 0) {
-      size += DEFAULT_PARTITION_VALUE.size();
+      size += kDefaultPartitionValue.size();
     } else {
       size += valSize;
       escapeCount += countEscape(pair.second);
@@ -182,10 +186,15 @@ std::string FileUtils::makePartName(
     if (ret.size() > 0) {
       ret += "/";
     }
-    ret += escapePathName(toLower(pair.first));
+    if (partitionPathAsLowerCase) {
+      ret += escapePathName(toLower(pair.first));
+    } else {
+      ret += escapePathName(pair.first);
+    }
+
     ret += "=";
     if (pair.second.size() == 0) {
-      ret += DEFAULT_PARTITION_VALUE;
+      ret += kDefaultPartitionValue;
     } else {
       ret += escapePathName(pair.second);
     }
@@ -211,7 +220,7 @@ std::vector<std::pair<std::string, std::string>> FileUtils::parsePartKeyValues(
 
 std::string FileUtils::extractPartitionName(const std::string& filePath) {
   const auto& partitionParts = extractPartitionKeyValues(filePath);
-  return partitionParts.empty() ? "" : makePartName(partitionParts);
+  return partitionParts.empty() ? "" : makePartName(partitionParts, false);
 }
 
 } // namespace fbhive
diff --git a/velox/dwio/catalog/fbhive/FileUtils.h b/velox/dwio/catalog/fbhive/FileUtils.h
index 1c759ffb19e03..a8ca8bf07efdf 100644
--- a/velox/dwio/catalog/fbhive/FileUtils.h
+++ b/velox/dwio/catalog/fbhive/FileUtils.h
@@ -40,7 +40,8 @@ class FileUtils {
   /// Creates the partition directory path from the list of partition key/value
   /// pairs, will do url-encoding when needed.
   static std::string makePartName(
-      const std::vector<std::pair<std::string, std::string>>& entries);
+      const std::vector<std::pair<std::string, std::string>>& entries,
+      bool partitionPathAsLowerCase);
 
   /// Converts the hive-metastore-compliant path name back to the corresponding
   /// partition key/value pairs.
@@ -49,6 +50,9 @@ class FileUtils {
 
   /// Converts a path name to a hive-metastore-compliant path name.
   static std::string extractPartitionName(const std::string& filePath);
+
+  inline static const std::string kDefaultPartitionValue =
+      "__HIVE_DEFAULT_PARTITION__";
 };
 
 } // namespace fbhive
diff --git a/velox/dwio/catalog/fbhive/test/CMakeLists.txt b/velox/dwio/catalog/fbhive/test/CMakeLists.txt
index b3dc1b7d6211e..34b279ffdb8c8 100644
--- a/velox/dwio/catalog/fbhive/test/CMakeLists.txt
+++ b/velox/dwio/catalog/fbhive/test/CMakeLists.txt
@@ -14,5 +14,10 @@
 
 add_executable(file_utils_test FileUtilsTests.cpp)
 add_test(file_utils_test file_utils_test)
-target_link_libraries(file_utils_test velox_dwio_catalog_fbhive
-                      velox_dwio_common_exception gtest gtest_main gmock)
+target_link_libraries(
+  file_utils_test
+  velox_dwio_catalog_fbhive
+  velox_dwio_common_exception
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock)
diff --git a/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp b/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
index 4abe1c4905e09..b2909cc0da368 100644
--- a/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
+++ b/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
@@ -27,8 +27,11 @@ TEST(FileUtilsTests, MakePartName) {
   std::vector<std::pair<std::string, std::string>> pairs{
       {"ds", "2016-01-01"}, {"FOO", ""}, {"a\nb:c", "a#b=c"}};
   ASSERT_EQ(
-      FileUtils::makePartName(pairs),
+      FileUtils::makePartName(pairs, true),
       "ds=2016-01-01/foo=__HIVE_DEFAULT_PARTITION__/a%0Ab%3Ac=a%23b%3Dc");
+  ASSERT_EQ(
+      FileUtils::makePartName(pairs, false),
+      "ds=2016-01-01/FOO=__HIVE_DEFAULT_PARTITION__/a%0Ab%3Ac=a%23b%3Dc");
 }
 
 TEST(FileUtilsTests, ParsePartKeyValues) {
diff --git a/velox/dwio/common/BitConcatenation.cpp b/velox/dwio/common/BitConcatenation.cpp
index 2a2e86a45ec96..5f37053f66a6e 100644
--- a/velox/dwio/common/BitConcatenation.cpp
+++ b/velox/dwio/common/BitConcatenation.cpp
@@ -19,7 +19,7 @@
 namespace facebook::velox::dwio::common {
 
 void BitConcatenation::append(
-    const uint64_t* FOLLY_NULLABLE bits,
+    const uint64_t* bits,
     int32_t begin,
     int32_t end) {
   int32_t numBits = end - begin;
@@ -46,7 +46,7 @@ void BitConcatenation::appendOnes(int32_t numOnes) {
   }
 }
 
-uint64_t* FOLLY_NONNULL BitConcatenation::ensureSpace(int32_t numBits) {
+uint64_t* BitConcatenation::ensureSpace(int32_t numBits) {
   if (!*buffer_) {
     *buffer_ = AlignedBuffer::allocate<bool>(numBits_ + numBits, &pool_, true);
   } else if (numBits_ + numBits > (*buffer_)->capacity() * 8) {
diff --git a/velox/dwio/common/BitConcatenation.h b/velox/dwio/common/BitConcatenation.h
index cc812035d8b82..18109114ae665 100644
--- a/velox/dwio/common/BitConcatenation.h
+++ b/velox/dwio/common/BitConcatenation.h
@@ -38,7 +38,7 @@ class BitConcatenation {
 
   /// Appends  'bits' between bit offset 'begin' and 'end' to the result.
   /// A nullptr 'bits' is treated as a bit range with all bits set.
-  void append(const uint64_t* FOLLY_NULLABLE bits, int32_t begin, int32_t end);
+  void append(const uint64_t* bits, int32_t begin, int32_t end);
 
   /// Appends 'numOnes' ones.
   void appendOnes(int32_t numOnes);
@@ -55,16 +55,16 @@ class BitConcatenation {
  private:
   // Allocates or reallocates '*buffer' to have space for 'numBits_ + newBits'
   // bits. Retuns a pointer to the first word of 'buffer_'.
-  uint64_t* FOLLY_NONNULL ensureSpace(int32_t newBits);
+  uint64_t* ensureSpace(int32_t newBits);
 
   void setSize() {
     if (*buffer_) {
-      (*buffer_)->setSize(bits::roundUp(numBits_, 8) / 8);
+      (*buffer_)->setSize(bits::divRoundUp(numBits_, 8));
     }
   }
 
   memory::MemoryPool& pool_;
-  BufferPtr* FOLLY_NULLABLE buffer_{nullptr};
+  BufferPtr* buffer_{nullptr};
   int32_t numBits_{0};
   bool hasZeros_{false};
 };
diff --git a/velox/dwio/common/BitPackDecoder.cpp b/velox/dwio/common/BitPackDecoder.cpp
index b8f9b3aadd259..917b0ab972c60 100644
--- a/velox/dwio/common/BitPackDecoder.cpp
+++ b/velox/dwio/common/BitPackDecoder.cpp
@@ -35,7 +35,7 @@ auto as4x64(__m256i x) {
 }
 
 template <typename T>
-void store8Ints(__m256i eightInts, int32_t i, T* FOLLY_NONNULL result) {
+void store8Ints(__m256i eightInts, int32_t i, T* result) {
   if (sizeof(T) == 4) {
     _mm256_storeu_si256(reinterpret_cast<__m256i*>(result + i), eightInts);
   } else {
@@ -200,7 +200,7 @@ void unpack(
   bitOffset -= rowBias * bitWidth;
   if (bitOffset < 0) {
     // Decrement the pointer by enough bytes to have a non-negative bitOffset.
-    auto bytes = bits::roundUp(-bitOffset, 8) / 8;
+    auto bytes = bits::divRoundUp(-bitOffset, 8);
     bitOffset += bytes * 8;
     bits = reinterpret_cast<const uint64_t*>(
         reinterpret_cast<const char*>(bits) - bytes);
@@ -213,12 +213,11 @@ void unpack(
     }
     return;
   }
-  auto FOLLY_NONNULL lastSafe = bufferEnd - sizeof(uint64_t);
   int32_t numSafeRows = numRows;
   bool anyUnsafe = false;
   if (bufferEnd) {
     const char* endByte = reinterpret_cast<const char*>(bits) +
-        bits::roundUp(bitOffset + (rows.back() + 1) * bitWidth, 8) / 8;
+        bits::divRoundUp(bitOffset + (rows.back() + 1) * bitWidth, 8);
     // redzone is the number of bytes at the end of the accessed range that
     // could overflow the buffer if accessed 64 its wide.
     int64_t redZone =
@@ -281,15 +280,15 @@ void unpack(
   if (anyUnsafe) {
     auto lastSafeWord = bufferEnd - sizeof(uint64_t);
     VELOX_DCHECK(lastSafeWord);
-    for (auto i = numSafeRows; i < numRows; ++i) {
-      auto bit = bitOffset + (rows[i]) * bitWidth;
+    for (auto i_2 = numSafeRows; i_2 < numRows; ++i_2) {
+      auto bit = bitOffset + (rows[i_2]) * bitWidth;
       auto byte = bit / 8;
       auto shift = bit & 7;
-      result[i] = safeLoadBits(
-                      reinterpret_cast<const char*>(bits) + byte,
-                      shift,
-                      bitWidth,
-                      lastSafeWord) &
+      result[i_2] = safeLoadBits(
+                        reinterpret_cast<const char*>(bits) + byte,
+                        shift,
+                        bitWidth,
+                        lastSafeWord) &
           mask;
     }
   }
diff --git a/velox/dwio/common/BitPackDecoder.h b/velox/dwio/common/BitPackDecoder.h
index fc87fc369e121..2aa785e2d29fe 100644
--- a/velox/dwio/common/BitPackDecoder.h
+++ b/velox/dwio/common/BitPackDecoder.h
@@ -21,7 +21,7 @@
 #include "velox/vector/TypeAliases.h"
 
 #include <folly/Range.h>
-#include <xsimd/config/xsimd_config.hpp> // @manual
+#include <xsimd/config/xsimd_config.hpp>
 
 namespace facebook::velox::dwio::common {
 
@@ -90,13 +90,13 @@ static const uint32_t BITPACK_MASKS[] = {
 /// stay under 'bufferEnd'.
 template <typename T>
 void unpack(
-    const uint64_t* FOLLY_NULLABLE bits,
+    const uint64_t* bits,
     int32_t bitOffset,
     RowSet rows,
     int32_t rowBias,
     uint8_t bitWidth,
-    const char* FOLLY_NULLABLE bufferEnd,
-    T* FOLLY_NONNULL result);
+    const char* bufferEnd,
+    T* result);
 
 /// Unpack numValues number of input values from inputBuffer. The results
 /// will be written to result. numValues must be a multiple of 8. The
@@ -793,17 +793,17 @@ inline void unpack<uint32_t>(
 // sure not to access bytes past lastSafeWord + 7. The definition is put here
 // because it's inlined.
 inline uint64_t safeLoadBits(
-    const char* FOLLY_NONNULL ptr,
+    const char* ptr,
     int32_t bitOffset,
     uint8_t bitWidth,
-    const char* FOLLY_NONNULL lastSafeWord) {
+    const char* lastSafeWord) {
   VELOX_DCHECK_GE(7, bitOffset);
   VELOX_DCHECK_GE(56, bitWidth);
   if (ptr < lastSafeWord) {
     return *reinterpret_cast<const uint64_t*>(ptr) >> bitOffset;
   }
   int32_t byteWidth =
-      facebook::velox::bits::roundUp(bitOffset + bitWidth, 8) / 8;
+      facebook::velox::bits::divRoundUp(bitOffset + bitWidth, 8);
   return facebook::velox::bits::loadPartialWord(
              reinterpret_cast<const uint8_t*>(ptr), byteWidth) >>
       bitOffset;
diff --git a/velox/dwio/common/BufferUtil.h b/velox/dwio/common/BufferUtil.h
index 92b468b0e5bcf..738d81efa1672 100644
--- a/velox/dwio/common/BufferUtil.h
+++ b/velox/dwio/common/BufferUtil.h
@@ -24,10 +24,30 @@ template <typename T>
 inline void ensureCapacity(
     BufferPtr& data,
     size_t capacity,
-    velox::memory::MemoryPool* pool) {
-  if (!data || !data->isMutable() ||
-      data->capacity() < BaseVector::byteSize<T>(capacity)) {
+    velox::memory::MemoryPool* pool,
+    bool preserveOldData = false,
+    bool clearBits = false) {
+  size_t oldSize = 0;
+  if (!data) {
     data = AlignedBuffer::allocate<T>(capacity, pool);
+  } else {
+    oldSize = data->size();
+    if (!data->isMutable() ||
+        data->capacity() < BaseVector::byteSize<T>(capacity)) {
+      auto newData = AlignedBuffer::allocate<T>(capacity, pool);
+      if (preserveOldData) {
+        std::memcpy(
+            newData->template asMutable<uint8_t>(),
+            data->as<uint8_t>(),
+            oldSize);
+      }
+      data = newData;
+    }
+  }
+
+  if (clearBits) {
+    std::memset(
+        (void*)(data->asMutable<int8_t>() + oldSize), 0L, capacity - oldSize);
   }
 }
 
diff --git a/velox/dwio/common/BufferedInput.cpp b/velox/dwio/common/BufferedInput.cpp
index 3b89140aeff41..8791e418f49e1 100644
--- a/velox/dwio/common/BufferedInput.cpp
+++ b/velox/dwio/common/BufferedInput.cpp
@@ -15,6 +15,8 @@
  */
 
 #include <fmt/format.h>
+#include <numeric>
+#include <utility>
 
 #include "folly/io/Cursor.h"
 #include "velox/dwio/common/BufferedInput.h"
@@ -25,6 +27,23 @@ using ::facebook::velox::common::Region;
 
 namespace facebook::velox::dwio::common {
 
+static_assert(std::is_move_constructible<BufferedInput>());
+
+namespace {
+void copyIOBufToMemory(folly::IOBuf&& iobuf, folly::Range<char*> allocated) {
+  folly::io::Cursor cursor(&iobuf);
+  VELOX_CHECK_EQ(cursor.totalLength(), allocated.size(), "length mismatch.");
+  cursor.pull(allocated.data(), allocated.size());
+}
+} // namespace
+
+uint64_t BufferedInput::nextFetchSize() const {
+  return std::accumulate(
+      regions_.cbegin(), regions_.cend(), 0L, [](uint64_t a, const Region& b) {
+        return a + b.length;
+      });
+}
+
 void BufferedInput::load(const LogType logType) {
   // no regions to load
   if (regions_.size() == 0) {
@@ -47,38 +66,44 @@ void BufferedInput::load(const LogType logType) {
     std::vector<folly::IOBuf> iobufs(regions_.size());
     input_->vread(regions_, {iobufs.data(), iobufs.size()}, logType);
     for (size_t i = 0; i < regions_.size(); ++i) {
-      const auto& region = regions_[i];
-      auto iobuf = std::move(iobufs[i]);
-
-      auto allocated = allocate(region);
-      folly::io::Cursor cursor(&iobuf);
-      DWIO_ENSURE_EQ(
-          cursor.totalLength(), allocated.size(), "length mismatch.");
-      cursor.pull(allocated.data(), allocated.size());
+      copyIOBufToMemory(std::move(iobufs[i]), allocate(regions_[i]));
     }
-
   } else {
     for (const auto& region : regions_) {
-      auto allocated = allocate(region);
-      input_->read(allocated.data(), allocated.size(), region.offset, logType);
+      readToBuffer(region.offset, allocate(region), logType);
     }
   }
 
-  // clear the loaded regions
+  // clear the loaded regions.
   regions_.clear();
 }
 
+void BufferedInput::readToBuffer(
+    uint64_t offset,
+    folly::Range<char*> allocated,
+    const LogType logType) {
+  uint64_t usec = 0;
+  {
+    MicrosecondTimer timer(&usec);
+    input_->read(allocated.data(), allocated.size(), offset, logType);
+  }
+  if (auto* stats = input_->getStats()) {
+    stats->read().increment(allocated.size());
+    stats->queryThreadIoLatency().increment(usec);
+  }
+}
+
 std::unique_ptr<SeekableInputStream> BufferedInput::enqueue(
     Region region,
-    const dwio::common::StreamIdentifier* /*si*/) {
+    const dwio::common::StreamIdentifier* /*sid*/) {
   if (region.length == 0) {
     return std::make_unique<SeekableArrayInputStream>(
         static_cast<const char*>(nullptr), 0);
   }
 
-  // if the region is already in buffer - such as metadata
+  // If the region is already in buffer - such as metadata.
   auto ret = readBuffer(region.offset, region.length);
-  if (ret) {
+  if (ret != nullptr) {
     return ret;
   }
 
@@ -88,7 +113,13 @@ std::unique_ptr<SeekableInputStream> BufferedInput::enqueue(
       // Save "i", the position in which this region was enqueued. This will
       // help faster lookup using enqueuedToBufferOffset_ later.
       [region, this, i = regions_.size() - 1]() {
-        return readInternal(region.offset, region.length, i);
+        auto result = readInternal(region.offset, region.length, i);
+        VELOX_CHECK(
+            std::get<1>(result) != MAX_UINT64,
+            "Fail to read region offset={} length={}",
+            region.offset,
+            region.length);
+        return result;
       });
 }
 
@@ -129,8 +160,8 @@ void BufferedInput::sortRegions() {
 
 void BufferedInput::mergeRegions() {
   auto& r = regions_;
+  VELOX_CHECK(!r.empty(), "Assumes that there's at least one region");
   auto& e = enqueuedToBufferOffset_;
-  size_t ia = 0;
   // We want to map here where each region ended in the final merged regions
   // vector.
   // For example, if this is the regions vector: {{6, 3}, {24, 3}, {3, 3}, {0,
@@ -141,13 +172,12 @@ void BufferedInput::mergeRegions() {
   // position 0. The original region 1, became region 1, and original region 4
   // became region 2
   std::vector<size_t> te(e.size());
-
-  DWIO_ENSURE(!r.empty(), "Assumes that there's at least one region");
-  DWIO_ENSURE_GT(r[ia].length, 0, "invalid region");
-
   te[e[0]] = 0;
+
+  size_t ia = 0;
+  VELOX_CHECK_GT(r[ia].length, 0, "invalid region");
   for (size_t ib = 1; ib < r.size(); ++ib) {
-    DWIO_ENSURE_GT(r[ib].length, 0, "invalid region");
+    VELOX_CHECK_GT(r[ib].length, 0, "invalid region");
     if (!tryMerge(r[ia], r[ib])) {
       r[++ia] = r[ib];
     }
@@ -159,7 +189,7 @@ void BufferedInput::mergeRegions() {
 }
 
 bool BufferedInput::tryMerge(Region& first, const Region& second) {
-  DWIO_ENSURE_GE(second.offset, first.offset, "regions should be sorted.");
+  VELOX_CHECK_GE(second.offset, first.offset, "regions should be sorted.");
   const int64_t gap = second.offset - first.offset - first.length;
 
   // Duplicate regions (extension==0) is the only case allowed to merge for
@@ -178,10 +208,8 @@ bool BufferedInput::tryMerge(Region& first, const Region& second) {
         input_->getStats()->incRawOverreadBytes(gap);
       }
     }
-
     return true;
   }
-
   return false;
 }
 
@@ -189,12 +217,10 @@ std::unique_ptr<SeekableInputStream> BufferedInput::readBuffer(
     uint64_t offset,
     uint64_t length) const {
   const auto result = readInternal(offset, length);
-
-  auto size = std::get<1>(result);
+  const auto size = std::get<1>(result);
   if (size == MAX_UINT64) {
     return {};
   }
-
   return std::make_unique<SeekableArrayInputStream>(std::get<0>(result), size);
 }
 
@@ -209,7 +235,7 @@ std::tuple<const char*, uint64_t> BufferedInput::readInternal(
 
   std::optional<size_t> index;
   if (i.has_value()) {
-    auto vi = i.value();
+    const auto vi = i.value();
     // There's a possibility that our user enqueued, then tried to read before
     // calling load(). In that case, enqueuedToBufferOffset_ will be empty or
     // have the values from a previous load. So I want to make sure that he ends
@@ -218,14 +244,16 @@ std::tuple<const char*, uint64_t> BufferedInput::readInternal(
     if (vi < enqueuedToBufferOffset_.size() &&
         enqueuedToBufferOffset_[vi] < offsets_.size() &&
         offsets_[enqueuedToBufferOffset_[vi]] <= offset) {
-      index = enqueuedToBufferOffset_[i.value()];
+      index = enqueuedToBufferOffset_[vi];
     }
   }
+
   if (!index.has_value()) {
     // Binary search to get the first fileOffset for which: offset < fileOffset
-    auto it = std::upper_bound(offsets_.cbegin(), offsets_.cend(), offset);
+    const auto it =
+        std::upper_bound(offsets_.cbegin(), offsets_.cend(), offset);
     // If the first element was already greater than the target offset we don't
-    // have it
+    // have it.
     if (it != offsets_.cbegin()) {
       index = std::distance(offsets_.cbegin(), it) - 1;
     }
@@ -235,14 +263,13 @@ std::tuple<const char*, uint64_t> BufferedInput::readInternal(
     const uint64_t bufferOffset = offsets_[index.value()];
     const auto& buffer = buffers_[index.value()];
     if (bufferOffset + buffer.size() >= offset + length) {
-      DWIO_ENSURE_LE(bufferOffset, offset, "Invalid offset for readInternal");
-      DWIO_ENSURE_LE(
+      VELOX_CHECK_LE(bufferOffset, offset, "Invalid offset for readInternal");
+      VELOX_CHECK_LE(
           (offset - bufferOffset) + length,
           buffer.size(),
           "Invalid readOffset for read Internal ",
           fmt::format(
               "{} {} {} {}", offset, bufferOffset, length, buffer.size()));
-
       return std::make_tuple(buffer.data() + (offset - bufferOffset), length);
     }
   }
diff --git a/velox/dwio/common/BufferedInput.h b/velox/dwio/common/BufferedInput.h
index 9adf325789ddc..7b12f601183f3 100644
--- a/velox/dwio/common/BufferedInput.h
+++ b/velox/dwio/common/BufferedInput.h
@@ -33,25 +33,25 @@ class BufferedInput {
       std::shared_ptr<ReadFile> readFile,
       memory::MemoryPool& pool,
       const MetricsLogPtr& metricsLog = MetricsLog::voidLog(),
-      IoStatistics* FOLLY_NULLABLE stats = nullptr,
+      IoStatistics* stats = nullptr,
       uint64_t maxMergeDistance = kMaxMergeDistance,
       std::optional<bool> wsVRLoad = std::nullopt)
-      : input_{std::make_shared<ReadFileInputStream>(
-            std::move(readFile),
-            metricsLog,
-            stats)},
-        pool_{pool},
-        maxMergeDistance_{maxMergeDistance},
-        wsVRLoad_{wsVRLoad},
-        allocPool_{std::make_unique<memory::AllocationPool>(&pool)} {}
+      : BufferedInput(
+            std::make_shared<ReadFileInputStream>(
+                std::move(readFile),
+                metricsLog,
+                stats),
+            pool,
+            maxMergeDistance,
+            wsVRLoad) {}
 
   BufferedInput(
       std::shared_ptr<ReadFileInputStream> input,
       memory::MemoryPool& pool,
       uint64_t maxMergeDistance = kMaxMergeDistance,
       std::optional<bool> wsVRLoad = std::nullopt)
-      : input_(std::move(input)),
-        pool_(pool),
+      : input_{std::move(input)},
+        pool_{&pool},
         maxMergeDistance_{maxMergeDistance},
         wsVRLoad_{wsVRLoad},
         allocPool_{std::make_unique<memory::AllocationPool>(&pool)} {}
@@ -67,17 +67,21 @@ class BufferedInput {
     return input_->getName();
   }
 
-  // The previous API was taking a vector of regions
-  // Now we allow callers to enqueue region any time/place
-  // and we do final load into buffer in 2 steps (enqueue....load)
-  // 'si' allows tracking which streams actually get read. This may control
-  // read-ahead and caching for BufferedInput implementations supporting
-  // these.
+  /// The previous API was taking a vector of regions. Now we allow callers to
+  /// enqueue region any time/place and we do final load into buffer in 2 steps
+  /// (enqueue....load). 'si' allows tracking which streams actually get read.
+  /// This may control read-ahead and caching for BufferedInput implementations
+  /// supporting these.
   virtual std::unique_ptr<SeekableInputStream> enqueue(
       velox::common::Region region,
-      const StreamIdentifier* FOLLY_NULLABLE si = nullptr);
+      const StreamIdentifier* sid = nullptr);
 
-  // load all regions to be read in an optimized way (IO efficiency)
+  /// Returns true if load synchronously.
+  virtual bool supportSyncLoad() const {
+    return true;
+  }
+
+  /// load all regions to be read in an optimized way (IO efficiency)
   virtual void load(const LogType);
 
   virtual bool isBuffered(uint64_t offset, uint64_t length) const {
@@ -87,15 +91,15 @@ class BufferedInput {
   virtual std::unique_ptr<SeekableInputStream>
   read(uint64_t offset, uint64_t length, LogType logType) const {
     std::unique_ptr<SeekableInputStream> ret = readBuffer(offset, length);
-    if (!ret) {
-      VLOG(1) << "Unplanned read. Offset: " << offset << ", Length: " << length;
-      // We cannot do enqueue/load here because load() clears previously
-      // loaded data. TODO: figure out how we can use the data cache for
-      // this access.
-      ret = std::make_unique<SeekableFileInputStream>(
-          input_, offset, length, pool_, logType, input_->getNaturalReadSize());
+    if (ret != nullptr) {
+      return ret;
     }
-    return ret;
+    VLOG(1) << "Unplanned read. Offset: " << offset << ", Length: " << length;
+    // We cannot do enqueue/load here because load() clears previously
+    // loaded data. TODO: figure out how we can use the data cache for
+    // this access.
+    return std::make_unique<SeekableFileInputStream>(
+        input_, offset, length, *pool_, logType, input_->getNaturalReadSize());
   }
 
   // True if there is free memory for prefetching the stripe. This is
@@ -119,7 +123,8 @@ class BufferedInput {
   // Create a new (clean) instance of BufferedInput sharing the same
   // underlying file and memory pool.  The enqueued regions are NOT copied.
   virtual std::unique_ptr<BufferedInput> clone() const {
-    return std::make_unique<BufferedInput>(input_, pool_);
+    return std::make_unique<BufferedInput>(
+        input_, *pool_, maxMergeDistance_, wsVRLoad_);
   }
 
   std::unique_ptr<SeekableInputStream> loadCompleteFile() {
@@ -137,45 +142,31 @@ class BufferedInput {
     return input_;
   }
 
-  virtual folly::Executor* FOLLY_NULLABLE executor() const {
+  virtual folly::Executor* executor() const {
     return nullptr;
   }
 
-  virtual int64_t prefetchSize() const {
-    return 0;
-  }
+  virtual uint64_t nextFetchSize() const;
 
  protected:
-  std::shared_ptr<ReadFileInputStream> input_;
-  memory::MemoryPool& pool_;
+  const std::shared_ptr<ReadFileInputStream> input_;
+  memory::MemoryPool* const pool_;
 
  private:
-  uint64_t maxMergeDistance_;
-  std::optional<bool> wsVRLoad_;
-  std::unique_ptr<memory::AllocationPool> allocPool_;
-
-  // Regions enqueued for reading
-  std::vector<velox::common::Region> regions_;
-
-  // Offsets in the file to which the corresponding Region belongs
-  std::vector<uint64_t> offsets_;
-
-  // Buffers allocated for reading each Region.
-  std::vector<folly::Range<char*>> buffers_;
-
-  // Maps the position in which the Region was originally enqueued to the
-  // position that it went to after sorting and merging. Thus this maps from the
-  // enqueued position to its corresponding buffer offset.
-  std::vector<size_t> enqueuedToBufferOffset_;
-
   std::unique_ptr<SeekableInputStream> readBuffer(
       uint64_t offset,
       uint64_t length) const;
+
   std::tuple<const char*, uint64_t> readInternal(
       uint64_t offset,
       uint64_t length,
       std::optional<size_t> i = std::nullopt) const;
 
+  void readToBuffer(
+      uint64_t offset,
+      folly::Range<char*> allocated,
+      const LogType logType);
+
   folly::Range<char*> allocate(const velox::common::Region& region) {
     // Save the file offset and the buffer to which we'll read it
     offsets_.push_back(region.offset);
@@ -192,6 +183,24 @@ class BufferedInput {
   bool tryMerge(
       velox::common::Region& first,
       const velox::common::Region& second);
+
+  uint64_t maxMergeDistance_;
+  std::optional<bool> wsVRLoad_;
+  std::unique_ptr<memory::AllocationPool> allocPool_;
+
+  // Regions enqueued for reading
+  std::vector<velox::common::Region> regions_;
+
+  // Offsets in the file to which the corresponding Region belongs
+  std::vector<uint64_t> offsets_;
+
+  // Buffers allocated for reading each Region.
+  std::vector<folly::Range<char*>> buffers_;
+
+  // Maps the position in which the Region was originally enqueued to the
+  // position that it went to after sorting and merging. Thus this maps from the
+  // enqueued position to its corresponding buffer offset.
+  std::vector<size_t> enqueuedToBufferOffset_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/CMakeLists.txt b/velox/dwio/common/CMakeLists.txt
index dc7d02ada034d..55fadf6c2f210 100644
--- a/velox/dwio/common/CMakeLists.txt
+++ b/velox/dwio/common/CMakeLists.txt
@@ -21,55 +21,64 @@ elseif(${VELOX_BUILD_TEST_UTILS})
   add_subdirectory(tests/utils)
 endif()
 
-add_library(
+velox_add_library(
   velox_dwio_common
   BitConcatenation.cpp
   BitPackDecoder.cpp
   BufferedInput.cpp
-  CachedBufferedInput.cpp
   CacheInputStream.cpp
+  CachedBufferedInput.cpp
+  ColumnLoader.cpp
   ColumnSelector.cpp
   DataBufferHolder.cpp
   DecoderUtil.cpp
+  DirectBufferedInput.cpp
   DirectDecoder.cpp
+  DirectInputStream.cpp
   DwioMetricsLog.cpp
+  ExecutorBarrier.cpp
   FileSink.cpp
   FlatMapHelper.cpp
+  OnDemandUnitLoader.cpp
   InputStream.cpp
   IntDecoder.cpp
   MetadataFilter.cpp
   Options.cpp
   OutputStream.cpp
+  ParallelFor.cpp
   Range.cpp
   Reader.cpp
   ReaderFactory.cpp
   ScanSpec.cpp
-  ColumnLoader.cpp
+  SeekableInputStream.cpp
   SelectiveByteRleColumnReader.cpp
   SelectiveColumnReader.cpp
   SelectiveRepeatedColumnReader.cpp
   SelectiveStructColumnReader.cpp
-  SeekableInputStream.cpp
+  SortingWriter.cpp
+  SortingWriter.h
+  Throttler.cpp
   TypeUtils.cpp
   TypeWithId.cpp
-  WriterFactory.cpp
-  SortingWriter.cpp
-  SortingWriter.h)
+  Writer.cpp
+  WriterFactory.cpp)
 
-target_include_directories(velox_dwio_common PRIVATE ${Protobuf_INCLUDE_DIRS})
+velox_include_directories(velox_dwio_common PRIVATE ${Protobuf_INCLUDE_DIRS})
 
-target_link_libraries(
+velox_link_libraries(
   velox_dwio_common
   velox_buffer
   velox_caching
   velox_common_io
   velox_common_compression
+  velox_common_config
   velox_dwio_common_encryption
   velox_dwio_common_exception
   velox_exception
   velox_expression
   velox_memory
-  velox_exec
+  velox_type_tz
   Boost::regex
   Folly::folly
-  glog::glog)
+  glog::glog
+  protobuf::libprotobuf)
diff --git a/velox/dwio/common/CacheInputStream.cpp b/velox/dwio/common/CacheInputStream.cpp
index c9665926a4eb4..ca05a178e3b63 100644
--- a/velox/dwio/common/CacheInputStream.cpp
+++ b/velox/dwio/common/CacheInputStream.cpp
@@ -35,20 +35,42 @@ CacheInputStream::CacheInputStream(
     const Region& region,
     std::shared_ptr<ReadFileInputStream> input,
     uint64_t fileNum,
+    bool noCacheRetention,
     std::shared_ptr<ScanTracker> tracker,
     TrackingId trackingId,
     uint64_t groupId,
     int32_t loadQuantum)
     : bufferedInput_(bufferedInput),
       cache_(bufferedInput_->cache()),
-      ioStats_(ioStats),
-      input_(std::move(input)),
+      noCacheRetention_(noCacheRetention),
       region_(region),
       fileNum_(fileNum),
       tracker_(std::move(tracker)),
       trackingId_(trackingId),
       groupId_(groupId),
-      loadQuantum_(loadQuantum) {}
+      loadQuantum_(loadQuantum),
+      ioStats_(ioStats),
+      input_(std::move(input)) {}
+
+CacheInputStream::~CacheInputStream() {
+  clearCachePin();
+  makeCacheEvictable();
+}
+
+void CacheInputStream::makeCacheEvictable() {
+  if (!noCacheRetention_) {
+    return;
+  }
+  // Walks through the potential prefetch or access cache space of this cache
+  // input stream, and marks those exist cache entries as immediate evictable.
+  uint64_t position = 0;
+  while (position < region_.length) {
+    const auto nextRegion = nextQuantizedLoadRegion(position);
+    const cache::RawFileCacheKey key{fileNum_, nextRegion.offset};
+    cache_->makeEvictable(key);
+    position = nextRegion.offset + nextRegion.length;
+  }
+}
 
 bool CacheInputStream::Next(const void** buffer, int32_t* size) {
   if (position_ >= region_.length) {
@@ -60,56 +82,58 @@ bool CacheInputStream::Next(const void** buffer, int32_t* size) {
     *size = 0;
     return false;
   }
+
   loadPosition();
 
   *buffer = reinterpret_cast<const void**>(run_ + offsetInRun_);
   *size = runSize_ - offsetInRun_;
   if (window_.has_value()) {
-    auto window = window_.value();
-    if (position_ + *size > window.offset + window.length) {
-      *size = window.offset + window.length - position_;
+    if (position_ + *size > window_->offset + window_->length) {
+      *size = window_->offset + window_->length - position_;
     }
   }
   if (position_ + *size > region_.length) {
     *size = region_.length - position_;
   }
   offsetInRun_ += *size;
+
   if (prefetchPct_ < 100) {
-    auto offsetInQuantum = position_ % loadQuantum_;
-    auto nextQuantum = position_ - offsetInQuantum + loadQuantum_;
-    auto prefetchThreshold = loadQuantum_ * prefetchPct_ / 100;
-    if (!prefetchStarted_ && offsetInQuantum + *size > prefetchThreshold &&
-        position_ - offsetInQuantum + loadQuantum_ < region_.length) {
+    const auto offsetInQuantum = position_ % loadQuantum_;
+    const auto nextQuantumOffset = position_ - offsetInQuantum + loadQuantum_;
+    const auto prefetchThreshold = loadQuantum_ * prefetchPct_ / 100;
+    if (!prefetchStarted_ && (offsetInQuantum + *size > prefetchThreshold) &&
+        (position_ - offsetInQuantum + loadQuantum_ < region_.length)) {
       // We read past 'prefetchPct_' % of the current load quantum and the
       // current load quantum is not the last in the region. Prefetch the next
       // load quantum.
-      auto prefetchSize =
-          std::min(region_.length, nextQuantum + loadQuantum_) - nextQuantum;
+      const auto prefetchSize =
+          std::min(region_.length, nextQuantumOffset + loadQuantum_) -
+          nextQuantumOffset;
       prefetchStarted_ = bufferedInput_->prefetch(
-          Region{region_.offset + nextQuantum, prefetchSize});
+          Region{region_.offset + nextQuantumOffset, prefetchSize});
     }
   }
   position_ += *size;
 
-  if (tracker_) {
+  if (tracker_ != nullptr) {
     tracker_->recordRead(trackingId_, *size, fileNum_, groupId_);
   }
   return true;
 }
 
 void CacheInputStream::BackUp(int32_t count) {
-  DWIO_ENSURE_GE(count, 0, "can't backup negative distances");
+  VELOX_CHECK_GE(count, 0, "can't backup negative distances");
 
-  uint64_t unsignedCount = static_cast<uint64_t>(count);
-  DWIO_ENSURE(unsignedCount <= offsetInRun_, "Can't backup that much!");
+  const uint64_t unsignedCount = static_cast<uint64_t>(count);
+  VELOX_CHECK_LE(unsignedCount, offsetInRun_, "Can't backup that much!");
   position_ -= unsignedCount;
 }
 
-bool CacheInputStream::Skip(int32_t count) {
+bool CacheInputStream::SkipInt64(int64_t count) {
   if (count < 0) {
     return false;
   }
-  uint64_t unsignedCount = static_cast<uint64_t>(count);
+  const uint64_t unsignedCount = static_cast<uint64_t>(count);
   if (unsignedCount + position_ <= region_.length) {
     position_ += unsignedCount;
     return true;
@@ -127,7 +151,13 @@ void CacheInputStream::seekToPosition(PositionProvider& seekPosition) {
 }
 
 std::string CacheInputStream::getName() const {
-  return fmt::format("CacheInputStream {} of {}", position_, region_.length);
+  std::string result =
+      fmt::format("CacheInputStream {} of {}", position_, region_.length);
+  const auto ssdFile = ssdFileName();
+  if (!ssdFile.empty()) {
+    result += fmt::format(" ssdFile={}", ssdFile);
+  }
+  return result;
 }
 
 size_t CacheInputStream::positionSize() {
@@ -162,85 +192,96 @@ std::vector<folly::Range<char*>> makeRanges(
   return buffers;
 }
 } // namespace
-void CacheInputStream::loadSync(Region region) {
-  // rawBytesRead is the number of bytes touched. Whether they come
-  // from disk, ssd or memory is itemized in different counters. A
+
+void CacheInputStream::loadSync(const Region& region) {
   process::TraceContext trace("loadSync");
   int64_t hitSize = region.length;
   if (window_.has_value()) {
-    int64_t regionEnd = region.offset + region.length;
-    int64_t windowStart = region_.offset + window_.value().offset;
-    int64_t windowEnd =
+    const int64_t regionEnd = region.offset + region.length;
+    const int64_t windowStart = region_.offset + window_.value().offset;
+    const int64_t windowEnd =
         region_.offset + window_.value().offset + window_.value().length;
     hitSize = std::min(windowEnd, regionEnd) -
         std::max<int64_t>(windowStart, region.offset);
   }
 
-  // coalesced read from InputStream removes itself from this count
-  // so as not to double count when the individual parts are
-  // hit.
+  // rawBytesRead is the number of bytes touched. Whether they come from disk,
+  // ssd or memory is itemized in different counters. A coalesced read from
+  // InputStream removes itself from this count so as not to double count when
+  // the individual parts are hit.
   ioStats_->incRawBytesRead(hitSize);
   prefetchStarted_ = false;
   do {
-    folly::SemiFuture<bool> wait(false);
+    folly::SemiFuture<bool> cacheLoadWait(false);
     cache::RawFileCacheKey key{fileNum_, region.offset};
-    if (noRetention_ && !pin_.empty()) {
-      pin_.checkedEntry()->makeEvictable();
-    }
-    pin_.clear();
-    pin_ = cache_->findOrCreate(key, region.length, &wait);
+    clearCachePin();
+    pin_ = cache_->findOrCreate(key, region.length, &cacheLoadWait);
     if (pin_.empty()) {
-      VELOX_CHECK(wait.valid());
-      auto& exec = folly::QueuedImmediateExecutor::instance();
-      uint64_t usec = 0;
+      VELOX_CHECK(cacheLoadWait.valid());
+      uint64_t waitUs{0};
       {
-        MicrosecondTimer timer(&usec);
-        std::move(wait).via(&exec).wait();
+        MicrosecondTimer timer(&waitUs);
+        std::move(cacheLoadWait)
+            .via(&folly::QueuedImmediateExecutor::instance())
+            .wait();
       }
-      ioStats_->queryThreadIoLatency().increment(usec);
+      ioStats_->queryThreadIoLatency().increment(waitUs);
       continue;
     }
-    auto entry = pin_.checkedEntry();
-    if (entry->isExclusive()) {
-      // Missed memory cache. Trying to load from ssd cache, and if again
-      // missed, fall back to remote fetching.
-      entry->setGroupId(groupId_);
-      entry->setTrackingId(trackingId_);
-      if (loadFromSsd(region, *entry)) {
-        return;
-      }
-      auto ranges = makeRanges(entry, region.length);
-      uint64_t usec = 0;
-      {
-        MicrosecondTimer timer(&usec);
-        input_->read(ranges, region.offset, LogType::FILE);
-      }
-      ioStats_->read().increment(region.length);
-      ioStats_->queryThreadIoLatency().increment(usec);
-      entry->setExclusiveToShared();
-    } else {
+
+    auto* entry = pin_.checkedEntry();
+    if (!entry->getAndClearFirstUseFlag()) {
       // Hit memory cache.
-      if (!entry->getAndClearFirstUseFlag()) {
-        ioStats_->ramHit().increment(hitSize);
-      }
+      ioStats_->ramHit().increment(hitSize);
+    }
+    if (!entry->isExclusive()) {
+      return;
+    }
+
+    // Missed memory cache. Trying to load from ssd cache, and if again
+    // missed, fall back to remote fetching.
+    entry->setGroupId(groupId_);
+    entry->setTrackingId(trackingId_);
+    if (loadFromSsd(region, *entry)) {
       return;
     }
+    const auto ranges = makeRanges(entry, region.length);
+    uint64_t storageReadUs{0};
+    {
+      MicrosecondTimer timer(&storageReadUs);
+      input_->read(ranges, region.offset, LogType::FILE);
+    }
+    ioStats_->read().increment(region.length);
+    ioStats_->queryThreadIoLatency().increment(storageReadUs);
+    ioStats_->incTotalScanTime(storageReadUs * 1'000);
+    entry->setExclusiveToShared(!noCacheRetention_);
   } while (pin_.empty());
 }
 
+void CacheInputStream::clearCachePin() {
+  if (pin_.empty()) {
+    return;
+  }
+  if (noCacheRetention_) {
+    pin_.checkedEntry()->makeEvictable();
+  }
+  pin_.clear();
+}
+
 bool CacheInputStream::loadFromSsd(
-    Region region,
+    const Region& region,
     cache::AsyncDataCacheEntry& entry) {
-  auto ssdCache = cache_->ssdCache();
-  if (!ssdCache) {
+  auto* ssdCache = cache_->ssdCache();
+  if (ssdCache == nullptr) {
     return false;
   }
+
   auto& file = ssdCache->file(fileNum_);
   auto ssdPin = file.find(cache::RawFileCacheKey{fileNum_, region.offset});
-
   if (ssdPin.empty()) {
     return false;
   }
+
   if (ssdPin.run().size() < entry.size()) {
     LOG(INFO) << fmt::format(
         "IOERR: Ssd entry for {} shorter than requested {}",
@@ -248,79 +289,83 @@ bool CacheInputStream::loadFromSsd(
         ssdPin.run().size());
     return false;
   }
-  uint64_t usec = 0;
-  // SsdFile::load wants vectors of pins. Put the pins in a
-  // temp vector and then put 'pin_' back in 'this'. 'pin_'
-  // is exclusive and not movable.
+
+  uint64_t ssdLoadUs{0};
+  // SsdFile::load wants vectors of pins. Put the pins in a temp vector and then
+  // put 'pin_' back in 'this'. 'pin_' is exclusive and not movable.
   std::vector<cache::SsdPin> ssdPins;
   ssdPins.push_back(std::move(ssdPin));
   std::vector<cache::CachePin> pins;
   pins.push_back(std::move(pin_));
   try {
-    MicrosecondTimer timer(&usec);
+    MicrosecondTimer timer(&ssdLoadUs);
     file.load(ssdPins, pins);
   } catch (const std::exception& e) {
-    try {
-      LOG(ERROR) << "IOERR: Failed SSD loadSync " << entry.toString()
-                 << e.what() << process::TraceContext::statusLine()
-                 << fmt::format(
-                        "stream region {} {}b, start of load {} file {}",
-                        region_.offset,
-                        region_.length,
-                        region.offset - region_.offset,
-                        fileIds().string(fileNum_));
-      // Remove the non-loadable entry so that next access goes to
-      // storage.
-      file.erase(cache::RawFileCacheKey{fileNum_, region.offset});
-    } catch (const std::exception&) {
-      // Ignore error inside logging the error.
-    }
-    throw;
+    LOG(ERROR) << "IOERR: Failed SSD loadSync " << entry.toString() << ' '
+               << e.what() << process::TraceContext::statusLine()
+               << fmt::format(
+                      "stream region {} {}b, start of load {} file {}",
+                      region_.offset,
+                      region_.length,
+                      region.offset - region_.offset,
+                      fileIds().string(fileNum_));
+    // Remove the non-loadable entry so that next access goes to storage.
+    file.erase(cache::RawFileCacheKey{fileNum_, region.offset});
+    pin_ = std::move(pins[0]);
+    return false;
   }
+
+  VELOX_CHECK(pin_.empty());
   pin_ = std::move(pins[0]);
   ioStats_->ssdRead().increment(region.length);
-  ioStats_->queryThreadIoLatency().increment(usec);
+  ioStats_->queryThreadIoLatency().increment(ssdLoadUs);
+  // Skip no-cache retention setting as data is loaded from ssd.
   entry.setExclusiveToShared();
   return true;
 }
 
+std::string CacheInputStream::ssdFileName() const {
+  auto ssdCache = cache_->ssdCache();
+  if (!ssdCache) {
+    return "";
+  }
+  return ssdCache->file(fileNum_).fileName();
+}
+
 void CacheInputStream::loadPosition() {
-  auto offset = region_.offset;
+  const auto offset = region_.offset;
   if (pin_.empty()) {
     auto load = bufferedInput_->coalescedLoad(this);
-    if (load) {
+    if (load != nullptr) {
       folly::SemiFuture<bool> waitFuture(false);
-      uint64_t usec = 0;
+      uint64_t loadUs{0};
       {
-        MicrosecondTimer timer(&usec);
+        MicrosecondTimer timer(&loadUs);
         try {
-          if (!load->loadOrFuture(&waitFuture)) {
-            auto& exec = folly::QueuedImmediateExecutor::instance();
-            std::move(waitFuture).via(&exec).wait();
+          if (!load->loadOrFuture(&waitFuture, !noCacheRetention_)) {
+            waitFuture.wait();
           }
         } catch (const std::exception& e) {
-          // Log the error and continue. The error, if it persists,  will be hit
+          // Log the error and continue. The error, if it persists, will be hit
           // again in looking up the specific entry and thrown from there.
           LOG(ERROR) << "IOERR: error in coalesced load " << e.what();
         }
       }
-      ioStats_->queryThreadIoLatency().increment(usec);
+      ioStats_->queryThreadIoLatency().increment(loadUs);
     }
-    auto loadRegion = region_;
-    // Quantize position to previous multiple of 'loadQuantum_'.
-    loadRegion.offset += (position_ / loadQuantum_) * loadQuantum_;
-    // Set length to be the lesser of 'loadQuantum_' and distance to end of
-    // 'region_'
-    loadRegion.length = std::min<int32_t>(
-        loadQuantum_, region_.length - (loadRegion.offset - region_.offset));
-    loadSync(loadRegion);
+
+    const auto nextLoadRegion = nextQuantizedLoadRegion(position_);
+    // There is no need to update the metric in the loadData method because
+    // loadSync is always executed regardless and updates the metric.
+    loadSync(nextLoadRegion);
   }
+
   auto* entry = pin_.checkedEntry();
-  uint64_t positionInFile = offset + position_;
+  const uint64_t positionInFile = offset + position_;
   if (entry->offset() <= positionInFile &&
       entry->offset() + entry->size() > positionInFile) {
     // The position is inside the range of 'entry'.
-    auto offsetInEntry = positionInFile - entry->offset();
+    const auto offsetInEntry = positionInFile - entry->offset();
     if (entry->data().numPages() == 0) {
       run_ = reinterpret_cast<uint8_t*>(entry->tinyData());
       runSize_ = entry->size();
@@ -329,16 +374,28 @@ void CacheInputStream::loadPosition() {
     } else {
       entry->data().findRun(offsetInEntry, &runIndex_, &offsetInRun_);
       offsetOfRun_ = offsetInEntry - offsetInRun_;
-      auto run = entry->data().runAt(runIndex_);
+      const auto run = entry->data().runAt(runIndex_);
       run_ = run.data();
-      runSize_ = run.numPages() * memory::AllocationTraits::kPageSize;
+      runSize_ = memory::AllocationTraits::pageBytes(run.numPages());
       if (offsetOfRun_ + runSize_ > entry->size()) {
         runSize_ = entry->size() - offsetOfRun_;
       }
     }
   } else {
-    pin_.clear();
+    clearCachePin();
     loadPosition();
   }
 }
+
+velox::common::Region CacheInputStream::nextQuantizedLoadRegion(
+    uint64_t prevLoadedPosition) const {
+  auto nextRegion = region_;
+  // Quantize position to previous multiple of 'loadQuantum_'.
+  nextRegion.offset += (prevLoadedPosition / loadQuantum_) * loadQuantum_;
+  // Set length to be the lesser of 'loadQuantum_' and distance to end of
+  // 'region_'
+  nextRegion.length = std::min<int32_t>(
+      loadQuantum_, region_.length - (nextRegion.offset - region_.offset));
+  return nextRegion;
+}
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/CacheInputStream.h b/velox/dwio/common/CacheInputStream.h
index 141396d91d524..54650d9ebc435 100644
--- a/velox/dwio/common/CacheInputStream.h
+++ b/velox/dwio/common/CacheInputStream.h
@@ -35,29 +35,31 @@ class CacheInputStream : public SeekableInputStream {
       const velox::common::Region& region,
       std::shared_ptr<ReadFileInputStream> input,
       uint64_t fileNum,
+      bool noCacheRetention,
       std::shared_ptr<cache::ScanTracker> tracker,
       cache::TrackingId trackingId,
       uint64_t groupId,
       int32_t loadQuantum);
 
+  ~CacheInputStream() override;
+
   bool Next(const void** data, int* size) override;
   void BackUp(int count) override;
-  bool Skip(int count) override;
+  bool SkipInt64(int64_t count) override;
   google::protobuf::int64 ByteCount() const override;
   void seekToPosition(PositionProvider& position) override;
   std::string getName() const override;
   size_t positionSize() override;
 
-  /// Returns a copy of 'this', ranging over the same bytes. The clone
-  /// is initially positioned at the position of 'this' and can be
-  /// moved independently within 'region_'.  This is used for first
-  /// caching a range of bytes from a file and then giving out
-  /// delimited subranges of this to callers. skip() and
-  /// setRemainingBytes() set the bounds of the window exposed by the
-  /// clone. In specific, reading protocol buffers requires a stream
-  /// that begins and ends at the exact start and end of the
-  /// serialization. Reading these from cache requires an exactly
-  /// delimited stream.
+  /// Returns a copy of 'this', ranging over the same bytes. The clone is
+  /// initially positioned at the position of 'this' and can be moved
+  /// independently within 'region_'.  This is used for first caching a range of
+  /// bytes from a file and then giving out delimited subranges of this to
+  /// callers. skip() and setRemainingBytes() set the bounds of the window
+  /// exposed by the clone. In specific, reading protocol buffers requires a
+  /// stream that begins and ends at the exact start and end of the
+  /// serialization. Reading these from cache requires an exactly delimited
+  /// stream.
   std::unique_ptr<CacheInputStream> clone() {
     auto copy = std::make_unique<CacheInputStream>(
         bufferedInput_,
@@ -65,6 +67,7 @@ class CacheInputStream : public SeekableInputStream {
         region_,
         input_,
         fileNum_,
+        noCacheRetention_,
         tracker_,
         trackingId_,
         groupId_,
@@ -76,7 +79,7 @@ class CacheInputStream : public SeekableInputStream {
   /// Sets the stream to range over a window that starts at the current position
   /// and is 'remainingBytes' bytes in size. 'remainingBytes' must be <=
   /// 'region_.length - position_'. The stream cannot be used for reading
-  /// outside of the window. Use together wiht clone() and skip().
+  /// outside of the window. Use together with clone() and skip().
   void setRemainingBytes(uint64_t remainingBytes);
 
   /// Causes the next load quantum to be scheduled for read-ahead when
@@ -90,33 +93,47 @@ class CacheInputStream : public SeekableInputStream {
     prefetchPct_ = pct;
   }
 
-  /// Enables a mode where cache entries are made immediately evictable after
-  /// unpinning.
-  void setNoRetention() {
-    noRetention_ = true;
+  bool testingNoCacheRetention() const {
+    return noCacheRetention_;
   }
 
  private:
   // Ensures that the current position is covered by 'pin_'.
   void loadPosition();
 
+  // Returns the next quantized region to load with given loaded position.
+  velox::common::Region nextQuantizedLoadRegion(
+      uint64_t prevLoadedPosition) const;
+
   // Synchronously sets 'pin_' to cover 'region'.
-  void loadSync(velox::common::Region region);
+  void loadSync(const velox::common::Region& region);
 
   // Returns true if there is an SSD cache and 'entry' is present there and
   // successfully loaded.
   bool loadFromSsd(
-      velox::common::Region region,
+      const velox::common::Region& region,
       cache::AsyncDataCacheEntry& entry);
 
+  // Invoked to clear the cache pin of the accessed cache entry and mark it as
+  // immediate evictable if 'noCacheRetention_' flag is set.
+  void clearCachePin();
+
+  void makeCacheEvictable();
+
+  // Return SSD cache file path if exists; return empty string if no SSD cache
+  // file.
+  std::string ssdFileName() const;
+
   CachedBufferedInput* const bufferedInput_;
   cache::AsyncDataCache* const cache_;
-  IoStatistics* ioStats_;
-  std::shared_ptr<ReadFileInputStream> input_;
+  // True if a pin should be set to the lowest retention score after
+  // unpinning. This applies to sequential reads where second access
+  // to the page is not expected.
+  const bool noCacheRetention_;
   // The region of 'input' 'this' ranges over.
   const velox::common::Region region_;
   const uint64_t fileNum_;
-  std::shared_ptr<cache::ScanTracker> tracker_;
+  const std::shared_ptr<cache::ScanTracker> tracker_;
   const cache::TrackingId trackingId_;
   const uint64_t groupId_;
 
@@ -124,6 +141,9 @@ class CacheInputStream : public SeekableInputStream {
   // pin_.entry()->size().
   const int32_t loadQuantum_;
 
+  IoStatistics* const ioStats_;
+  const std::shared_ptr<ReadFileInputStream> input_;
+
   // Handle of cache entry.
   cache::CachePin pin_;
 
@@ -143,21 +163,16 @@ class CacheInputStream : public SeekableInputStream {
   uint64_t position_ = 0;
 
   // A restricted view over 'region'. offset is relative to 'region_'. A cloned
-  // CacheInputStream can cover a subrange of the range of the original.
+  // CacheInputStream can cover a sub-range of the range of the original.
   std::optional<velox::common::Region> window_;
 
   // Percentage of 'loadQuantum_' at which the next load quantum gets scheduled.
   // Over 100 means no prefetch.
   int32_t prefetchPct_{200};
 
-  // True if prefetch f the next 'loadQuantum_' has been started. Cleared when
+  // True if prefetch the next 'loadQuantum_' has been started. Cleared when
   // moving to the next load quantum.
   bool prefetchStarted_{false};
-
-  // True if a pin should be set to lowest retention score after
-  // unpinning. This applies to sequential reads where a second access
-  // to the page is not expected.
-  bool noRetention_{false};
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/CachedBufferedInput.cpp b/velox/dwio/common/CachedBufferedInput.cpp
index 87f537552243e..d734663360328 100644
--- a/velox/dwio/common/CachedBufferedInput.cpp
+++ b/velox/dwio/common/CachedBufferedInput.cpp
@@ -39,20 +39,20 @@ using memory::MemoryAllocator;
 
 std::unique_ptr<SeekableInputStream> CachedBufferedInput::enqueue(
     Region region,
-    const StreamIdentifier* si = nullptr) {
+    const StreamIdentifier* sid = nullptr) {
   if (region.length == 0) {
     return std::make_unique<SeekableArrayInputStream>(
         static_cast<const char*>(nullptr), 0);
   }
 
   TrackingId id;
-  if (si) {
-    id = TrackingId(si->getId());
+  if (sid != nullptr) {
+    id = TrackingId(sid->getId());
   }
   VELOX_CHECK_LE(region.offset + region.length, fileSize_);
   requests_.emplace_back(
       RawFileCacheKey{fileNum_, region.offset}, region.length, id);
-  if (tracker_) {
+  if (tracker_ != nullptr) {
     tracker_->recordReference(id, region.length, fileNum_, groupId_);
   }
   auto stream = std::make_unique<CacheInputStream>(
@@ -61,6 +61,7 @@ std::unique_ptr<SeekableInputStream> CachedBufferedInput::enqueue(
       region,
       input_,
       fileNum_,
+      options_.noCacheRetention(),
       tracker_,
       id,
       groupId_,
@@ -75,26 +76,25 @@ bool CachedBufferedInput::isBuffered(uint64_t /*offset*/, uint64_t /*length*/)
 }
 
 bool CachedBufferedInput::shouldPreload(int32_t numPages) {
-  // True if after scheduling this for preload, half the capacity
-  // would be in a loading but not yet accessed state.
-  if (requests_.empty() && !numPages) {
+  // True if after scheduling this for preload, half the capacity would be in a
+  // loading but not yet accessed state.
+  if (requests_.empty() && (numPages == 0)) {
     return false;
   }
-  for (auto& request : requests_) {
-    numPages += bits::roundUp(
-                    std::min<int32_t>(request.size, options_.loadQuantum()),
-                    memory::AllocationTraits::kPageSize) /
-        memory::AllocationTraits::kPageSize;
+  for (const auto& request : requests_) {
+    numPages += memory::AllocationTraits::numPages(
+        std::min<int32_t>(request.size, options_.loadQuantum()));
   }
-  auto cachePages = cache_->incrementCachedPages(0);
-  auto allocator = cache_->allocator();
-  auto maxPages = memory::AllocationTraits::numPages(allocator->capacity());
-  auto allocatedPages = allocator->numAllocated();
+  const auto cachePages = cache_->incrementCachedPages(0);
+  auto* allocator = cache_->allocator();
+  const auto maxPages =
+      memory::AllocationTraits::numPages(allocator->capacity());
+  const auto allocatedPages = allocator->numAllocated();
   if (numPages < maxPages - allocatedPages) {
     // There is free space for the read-ahead.
     return true;
   }
-  auto prefetchPages = cache_->incrementPrefetchPages(0);
+  const auto prefetchPages = cache_->incrementPrefetchPages(0);
   if (numPages + prefetchPages < cachePages / 2) {
     // The planned prefetch plus other prefetches are under half the cache.
     return true;
@@ -103,7 +103,6 @@ bool CachedBufferedInput::shouldPreload(int32_t numPages) {
 }
 
 namespace {
-
 bool isPrefetchPct(int32_t pct) {
   return pct >= FLAGS_cache_prefetch_min_pct;
 }
@@ -120,17 +119,17 @@ std::vector<CacheRequest*> makeRequestParts(
   // Large columns will be part of coalesced reads if the access frequency
   // qualifies for read ahead and if over 80% of the column gets accessed. Large
   // metadata columns (empty no trackingData) always coalesce.
-  bool prefetchOne =
+  const bool prefetchOne =
       request.trackingId.id() == StreamIdentifier::sequentialFile().id_;
-  auto readPct =
+  const auto readPct =
       (100 * trackingData.numReads) / (1 + trackingData.numReferences);
-  auto readDensity =
+  const auto readDensity =
       (100 * trackingData.readBytes) / (1 + trackingData.referencedBytes);
-  bool prefetch = trackingData.referencedBytes > 0 &&
+  const bool prefetch = trackingData.referencedBytes > 0 &&
       (isPrefetchPct(readPct) && readDensity >= 80);
   std::vector<CacheRequest*> parts;
   for (uint64_t offset = 0; offset < request.size; offset += loadQuantum) {
-    int32_t size = std::min<int32_t>(loadQuantum, request.size - offset);
+    const int32_t size = std::min<int32_t>(loadQuantum, request.size - offset);
     extraRequests.push_back(std::make_unique<CacheRequest>(
         RawFileCacheKey{request.key.fileNum, request.key.offset + offset},
         size,
@@ -154,21 +153,21 @@ int32_t adjustedReadPct(const cache::TrackingData& trackingData) {
 }
 } // namespace
 
-void CachedBufferedInput::load(const LogType) {
+void CachedBufferedInput::load(const LogType /*unused*/) {
   // 'requests_ is cleared on exit.
   auto requests = std::move(requests_);
-  cache::SsdFile* FOLLY_NULLABLE ssdFile = nullptr;
-  auto ssdCache = cache_->ssdCache();
-  if (ssdCache) {
+  cache::SsdFile* ssdFile{nullptr};
+  auto* ssdCache = cache_->ssdCache();
+  if (ssdCache != nullptr) {
     ssdFile = &ssdCache->file(fileNum_);
   }
-  // Extra requests made for preloadable regions that are larger then
+
+  // Extra requests made for pre-loadable regions that are larger than
   // 'loadQuantum'.
   std::vector<std::unique_ptr<CacheRequest>> extraRequests;
-  // We loop over access frequency buckets. For example readPct 80
-  // will get all streams where 80% or more of the referenced data is
-  // actually loaded.
-  for (auto readPct : std::vector<int32_t>{80, 50, 20, 0}) {
+  // We loop over access frequency buckets. For example readPct 80 will get all
+  // streams where 80% or more of the referenced data is actually loaded.
+  for (const auto readPct : std::vector<int32_t>{80, 50, 20, 0}) {
     std::vector<CacheRequest*> storageLoad;
     std::vector<CacheRequest*> ssdLoad;
     for (auto& request : requests) {
@@ -176,9 +175,9 @@ void CachedBufferedInput::load(const LogType) {
         continue;
       }
       cache::TrackingData trackingData;
-      bool prefetchAnyway = request.trackingId.empty() ||
+      const bool prefetchAnyway = request.trackingId.empty() ||
           request.trackingId.id() == StreamIdentifier::sequentialFile().id_;
-      if (!prefetchAnyway && tracker_) {
+      if (!prefetchAnyway && (tracker_ != nullptr)) {
         trackingData = tracker_->trackingData(request.trackingId);
       }
       if (prefetchAnyway || adjustedReadPct(trackingData) >= readPct) {
@@ -189,7 +188,7 @@ void CachedBufferedInput::load(const LogType) {
           if (cache_->exists(part->key)) {
             continue;
           }
-          if (ssdFile) {
+          if (ssdFile != nullptr) {
             part->ssdPin = ssdFile->find(part->key);
             if (!part->ssdPin.empty() &&
                 part->ssdPin.run().size() < part->size) {
@@ -217,8 +216,8 @@ void CachedBufferedInput::makeLoads(
   if (requests.empty() || (requests.size() < 2 && !prefetch)) {
     return;
   }
-  bool isSsd = !requests[0]->ssdPin.empty();
-  int32_t maxDistance = isSsd ? 20000 : options_.maxCoalesceDistance();
+  const bool isSsd = !requests[0]->ssdPin.empty();
+  const int32_t maxDistance = isSsd ? 20000 : options_.maxCoalesceDistance();
   std::sort(
       requests.begin(),
       requests.end(),
@@ -229,21 +228,21 @@ void CachedBufferedInput::makeLoads(
           return left->key.offset < right->key.offset;
         }
       });
-  // Combine adjacent short reads.
 
+  // Combine adjacent short reads.
   int32_t numNewLoads = 0;
   int64_t coalescedBytes = 0;
   coalesceIo<CacheRequest*, CacheRequest*>(
       requests,
       maxDistance,
-      // Break batches up. Better load more short ones i parallel.
+      // Break batches up. Better load more short ones in parallel.
       40,
       [&](int32_t index) {
         return isSsd ? requests[index]->ssdPin.run().offset()
                      : requests[index]->key.offset;
       },
       [&](int32_t index) {
-        auto size = requests[index]->size;
+        const auto size = requests[index]->size;
         coalescedBytes += size;
         return size;
       },
@@ -266,20 +265,22 @@ void CachedBufferedInput::makeLoads(
         ++numNewLoads;
         readRegion(ranges, prefetch);
       });
-  if (prefetch && executor_) {
+
+  if (prefetch && (executor_ != nullptr)) {
     std::vector<int32_t> doneIndices;
     for (auto i = 0; i < allCoalescedLoads_.size(); ++i) {
       auto& load = allCoalescedLoads_[i];
       if (load->state() == CoalescedLoad::State::kPlanned) {
-        prefetchSize_ += load->size();
-        executor_->add([pendingLoad = load]() {
-          process::TraceContext trace("Read Ahead");
-          pendingLoad->loadOrFuture(nullptr);
-        });
+        executor_->add(
+            [pendingLoad = load, ssdSavable = !options_.noCacheRetention()]() {
+              process::TraceContext trace("Read Ahead");
+              pendingLoad->loadOrFuture(nullptr, ssdSavable);
+            });
       } else {
         doneIndices.push_back(i);
       }
     }
+
     // Remove the loads that were complete. There can be done loads if the same
     // CachedBufferedInput has multiple cycles of enqueues and loads.
     for (int32_t i = doneIndices.size() - 1; i >= 0; --i) {
@@ -302,7 +303,8 @@ class DwioCoalescedLoadBase : public cache::CoalescedLoad {
         cache_(cache),
         ioStats_(std::move(ioStats)),
         groupId_(groupId) {
-    for (auto& request : requests) {
+    requests_.reserve(requests.size());
+    for (const auto& request : requests) {
       size_ += request->size;
       requests_.push_back(std::move(*request));
     }
@@ -318,31 +320,33 @@ class DwioCoalescedLoadBase : public cache::CoalescedLoad {
 
   std::string toString() const override {
     int32_t payload = 0;
-    assert(!requests_.empty());
+    VELOX_CHECK(!requests_.empty());
+
     int32_t total = requests_.back().key.offset + requests_.back().size -
         requests_[0].key.offset;
-    for (auto& request : requests_) {
+    for (const auto& request : requests_) {
       payload += request.size;
     }
     return fmt::format(
         "<CoalescedLoad: {} entries, {} total {} extra>",
         requests_.size(),
-        total,
-        total - payload);
+        succinctBytes(total),
+        succinctBytes(total - payload));
   }
 
  protected:
-  void updateStats(const CoalesceIoStats& stats, bool isPrefetch, bool isSsd) {
-    if (ioStats_) {
-      ioStats_->incRawOverreadBytes(stats.extraBytes);
-      if (isSsd) {
-        ioStats_->ssdRead().increment(stats.payloadBytes);
-      } else {
-        ioStats_->read().increment(stats.payloadBytes);
-      }
-      if (isPrefetch) {
-        ioStats_->prefetch().increment(stats.payloadBytes);
-      }
+  void updateStats(const CoalesceIoStats& stats, bool prefetch, bool ssd) {
+    if (ioStats_ == nullptr) {
+      return;
+    }
+    ioStats_->incRawOverreadBytes(stats.extraBytes);
+    if (ssd) {
+      ioStats_->ssdRead().increment(stats.payloadBytes);
+    } else {
+      ioStats_->read().increment(stats.payloadBytes);
+    }
+    if (prefetch) {
+      ioStats_->prefetch().increment(stats.payloadBytes);
     }
   }
 
@@ -386,14 +390,14 @@ class DwioCoalescedLoad : public DwioCoalescedLoadBase {
         input_(std::move(input)),
         maxCoalesceDistance_(maxCoalesceDistance) {}
 
-  std::vector<CachePin> loadData(bool isPrefetch) override {
+  std::vector<CachePin> loadData(bool prefetch) override {
     std::vector<CachePin> pins;
     pins.reserve(keys_.size());
     cache_.makePins(
         keys_,
         [&](int32_t index) { return sizes_[index]; },
         [&](int32_t /*index*/, CachePin pin) {
-          if (isPrefetch) {
+          if (prefetch) {
             pin.checkedEntry()->setPrefetch(true);
           }
           pins.push_back(std::move(pin));
@@ -413,7 +417,7 @@ class DwioCoalescedLoad : public DwioCoalescedLoadBase {
             const std::vector<folly::Range<char*>>& buffers) {
           input_->read(buffers, offset, LogType::FILE);
         });
-    updateStats(stats, isPrefetch, false);
+    updateStats(stats, prefetch, false);
     return pins;
   }
 
@@ -431,14 +435,14 @@ class SsdLoad : public DwioCoalescedLoadBase {
       std::vector<CacheRequest*> requests)
       : DwioCoalescedLoadBase(cache, ioStats, groupId, std::move(requests)) {}
 
-  std::vector<CachePin> loadData(bool isPrefetch) override {
+  std::vector<CachePin> loadData(bool prefetch) override {
     std::vector<SsdPin> ssdPins;
     std::vector<CachePin> pins;
     cache_.makePins(
         keys_,
         [&](int32_t index) { return sizes_[index]; },
         [&](int32_t index, CachePin pin) {
-          if (isPrefetch) {
+          if (prefetch) {
             pin.checkedEntry()->setPrefetch(true);
           }
           pins.push_back(std::move(pin));
@@ -448,8 +452,8 @@ class SsdLoad : public DwioCoalescedLoadBase {
       return pins;
     }
     assert(!ssdPins.empty()); // for lint.
-    auto stats = ssdPins[0].file()->load(ssdPins, pins);
-    updateStats(stats, isPrefetch, true);
+    const auto stats = ssdPins[0].file()->load(ssdPins, pins);
+    updateStats(stats, prefetch, true);
     return pins;
   }
 };
@@ -457,11 +461,12 @@ class SsdLoad : public DwioCoalescedLoadBase {
 } // namespace
 
 void CachedBufferedInput::readRegion(
-    std::vector<CacheRequest*> requests,
+    const std::vector<CacheRequest*>& requests,
     bool prefetch) {
   if (requests.empty() || (requests.size() == 1 && !prefetch)) {
     return;
   }
+
   std::shared_ptr<cache::CoalescedLoad> load;
   if (!requests[0]->ssdPin.empty()) {
     load = std::make_shared<SsdLoad>(*cache_, ioStats_, groupId_, requests);
@@ -491,7 +496,7 @@ std::shared_ptr<cache::CoalescedLoad> CachedBufferedInput::coalescedLoad(
           return nullptr;
         }
         auto load = std::move(it->second);
-        auto dwioLoad = dynamic_cast<DwioCoalescedLoadBase*>(load.get());
+        auto* dwioLoad = dynamic_cast<DwioCoalescedLoadBase*>(load.get());
         for (auto& request : dwioLoad->requests()) {
           loads.erase(request.stream);
         }
@@ -510,6 +515,7 @@ std::unique_ptr<SeekableInputStream> CachedBufferedInput::read(
       Region{offset, length},
       input_,
       fileNum_,
+      options_.noCacheRetention(),
       nullptr,
       TrackingId(),
       0,
@@ -517,9 +523,7 @@ std::unique_ptr<SeekableInputStream> CachedBufferedInput::read(
 }
 
 bool CachedBufferedInput::prefetch(Region region) {
-  int32_t numPages =
-      bits::roundUp(region.length, memory::AllocationTraits::kPageSize) /
-      memory::AllocationTraits::kPageSize;
+  const int32_t numPages = memory::AllocationTraits::numPages(region.length);
   if (!shouldPreload(numPages)) {
     return false;
   }
diff --git a/velox/dwio/common/CachedBufferedInput.h b/velox/dwio/common/CachedBufferedInput.h
index 5a8280e06fa8c..89f9a9aee0eb4 100644
--- a/velox/dwio/common/CachedBufferedInput.h
+++ b/velox/dwio/common/CachedBufferedInput.h
@@ -46,12 +46,12 @@ struct CacheRequest {
 
   bool processed{false};
 
-  // True if this should be coalesced into a CoalescedLoad with other
-  // nearby requests with a similar load probability. This is false
-  // for sparsely accessed large columns where hitting one piece
-  // should not load the adjacent pieces.
+  /// True if this should be coalesced into a CoalescedLoad with other nearby
+  /// requests with a similar load probability. This is false for sparsely
+  /// accessed large columns where hitting one piece should not load the
+  /// adjacent pieces.
   bool coalesces{true};
-  const SeekableInputStream* FOLLY_NONNULL stream;
+  const SeekableInputStream* stream;
 };
 
 class CachedBufferedInput : public BufferedInput {
@@ -60,15 +60,15 @@ class CachedBufferedInput : public BufferedInput {
       std::shared_ptr<ReadFile> readFile,
       const MetricsLogPtr& metricsLog,
       uint64_t fileNum,
-      cache::AsyncDataCache* FOLLY_NONNULL cache,
+      cache::AsyncDataCache* cache,
       std::shared_ptr<cache::ScanTracker> tracker,
       uint64_t groupId,
       std::shared_ptr<IoStatistics> ioStats,
-      folly::Executor* FOLLY_NULLABLE executor,
+      folly::Executor* executor,
       const io::ReaderOptions& readerOptions)
       : BufferedInput(
             std::move(readFile),
-            readerOptions.getMemoryPool(),
+            readerOptions.memoryPool(),
             metricsLog),
         cache_(cache),
         fileNum_(fileNum),
@@ -77,18 +77,20 @@ class CachedBufferedInput : public BufferedInput {
         ioStats_(std::move(ioStats)),
         executor_(executor),
         fileSize_(input_->getLength()),
-        options_(readerOptions) {}
+        options_(readerOptions) {
+    checkLoadQuantum();
+  }
 
   CachedBufferedInput(
       std::shared_ptr<ReadFileInputStream> input,
       uint64_t fileNum,
-      cache::AsyncDataCache* FOLLY_NONNULL cache,
+      cache::AsyncDataCache* cache,
       std::shared_ptr<cache::ScanTracker> tracker,
       uint64_t groupId,
       std::shared_ptr<IoStatistics> ioStats,
-      folly::Executor* FOLLY_NULLABLE executor,
+      folly::Executor* executor,
       const io::ReaderOptions& readerOptions)
-      : BufferedInput(std::move(input), readerOptions.getMemoryPool()),
+      : BufferedInput(std::move(input), readerOptions.memoryPool()),
         cache_(cache),
         fileNum_(fileNum),
         tracker_(std::move(tracker)),
@@ -96,7 +98,9 @@ class CachedBufferedInput : public BufferedInput {
         ioStats_(std::move(ioStats)),
         executor_(executor),
         fileSize_(input_->getLength()),
-        options_(readerOptions) {}
+        options_(readerOptions) {
+    checkLoadQuantum();
+  }
 
   ~CachedBufferedInput() override {
     for (auto& load : allCoalescedLoads_) {
@@ -106,11 +110,15 @@ class CachedBufferedInput : public BufferedInput {
 
   std::unique_ptr<SeekableInputStream> enqueue(
       velox::common::Region region,
-      const StreamIdentifier* FOLLY_NULLABLE si) override;
+      const StreamIdentifier* sid) override;
 
-  void load(const LogType) override;
+  bool supportSyncLoad() const override {
+    return false;
+  }
 
-  bool isBuffered(uint64_t offset, uint64_t length) const override;
+  void load(const LogType /*unused*/) override;
+
+  bool isBuffered(uint64_t /*unused*/, uint64_t /*unused*/) const override;
 
   std::unique_ptr<SeekableInputStream>
   read(uint64_t offset, uint64_t length, LogType logType) const override;
@@ -144,23 +152,22 @@ class CachedBufferedInput : public BufferedInput {
         options_);
   }
 
-  cache::AsyncDataCache* FOLLY_NONNULL cache() const {
+  cache::AsyncDataCache* cache() const {
     return cache_;
   }
 
-  // Returns the CoalescedLoad that contains the correlated loads for
-  // 'stream' or nullptr if none. Returns nullptr on all but first
-  // call for 'stream' since the load is to be triggered by the first
-  // access.
+  /// Returns the CoalescedLoad that contains the correlated loads for 'stream'
+  /// or nullptr if none. Returns nullptr on all but first call for 'stream'
+  /// since the load is to be triggered by the first access.
   std::shared_ptr<cache::CoalescedLoad> coalescedLoad(
-      const SeekableInputStream* FOLLY_NONNULL stream);
+      const SeekableInputStream* stream);
 
-  folly::Executor* FOLLY_NULLABLE executor() const override {
+  folly::Executor* executor() const override {
     return executor_;
   }
 
-  int64_t prefetchSize() const override {
-    return prefetchSize_;
+  uint64_t nextFetchSize() const override {
+    VELOX_NYI();
   }
 
  private:
@@ -168,19 +175,31 @@ class CachedBufferedInput : public BufferedInput {
   // is true, starts background loading.
   void makeLoads(std::vector<CacheRequest*> requests, bool prefetch);
 
-  // Makes a CoalescedLoad for 'requests' to be read together, coalescing
-  // IO is appropriate. If 'prefetch' is set, schedules the CoalescedLoad
-  // on 'executor_'. Links the CoalescedLoad  to all CacheInputStreams that it
+  // Makes a CoalescedLoad for 'requests' to be read together, coalescing IO is
+  // appropriate. If 'prefetch' is set, schedules the CoalescedLoad on
+  // 'executor_'. Links the CoalescedLoad to all CacheInputStreams that it
   // concerns.
+  void readRegion(const std::vector<CacheRequest*>& requests, bool prefetch);
+
+  // We only support up to 8MB load quantum size on SSD and there is no need for
+  // larger SSD read size performance wise.
+  void checkLoadQuantum() {
+    if (cache_->ssdCache() != nullptr) {
+      VELOX_CHECK_LE(
+          options_.loadQuantum(),
+          1 << cache::SsdRun::kSizeBits,
+          "Load quantum exceeded SSD cache entry size limit.");
+    }
+  }
 
-  void readRegion(std::vector<CacheRequest*> requests, bool prefetch);
-
-  cache::AsyncDataCache* FOLLY_NONNULL cache_;
+  cache::AsyncDataCache* const cache_;
   const uint64_t fileNum_;
-  std::shared_ptr<cache::ScanTracker> tracker_;
+  const std::shared_ptr<cache::ScanTracker> tracker_;
   const uint64_t groupId_;
-  std::shared_ptr<IoStatistics> ioStats_;
-  folly::Executor* const FOLLY_NULLABLE executor_;
+  const std::shared_ptr<IoStatistics> ioStats_;
+  folly::Executor* const executor_;
+  const uint64_t fileSize_;
+  const io::ReaderOptions options_;
 
   // Regions that are candidates for loading.
   std::vector<CacheRequest> requests_;
@@ -193,10 +212,6 @@ class CachedBufferedInput : public BufferedInput {
 
   // Distinct coalesced loads in 'coalescedLoads_'.
   std::vector<std::shared_ptr<cache::CoalescedLoad>> allCoalescedLoads_;
-
-  const uint64_t fileSize_;
-  int64_t prefetchSize_{0};
-  io::ReaderOptions options_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/Closeable.h b/velox/dwio/common/Closeable.h
index 4572e08cf98a1..bdb8254378891 100644
--- a/velox/dwio/common/Closeable.h
+++ b/velox/dwio/common/Closeable.h
@@ -18,10 +18,7 @@
 
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 // Base class for closeable object which need to be explicitly closed before
 // being destructed
@@ -67,7 +64,4 @@ class Closeable {
   bool closed_;
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ColumnLoader.cpp b/velox/dwio/common/ColumnLoader.cpp
index c04cb74db2715..8fd859f7a2b83 100644
--- a/velox/dwio/common/ColumnLoader.cpp
+++ b/velox/dwio/common/ColumnLoader.cpp
@@ -16,6 +16,8 @@
 
 #include "velox/dwio/common/ColumnLoader.h"
 
+#include "velox/common/process/TraceContext.h"
+
 namespace facebook::velox::dwio::common {
 
 // Wraps '*result' in a dictionary to make the contiguous values
@@ -45,13 +47,14 @@ void ColumnLoader::loadInternal(
     ValueHook* hook,
     vector_size_t resultSize,
     VectorPtr* result) {
+  process::TraceContext trace("ColumnLoader::loadInternal");
   VELOX_CHECK_EQ(
       version_,
       structReader_->numReads(),
       "Loading LazyVector after the enclosing reader has moved");
-  auto offset = structReader_->lazyVectorReadOffset();
-  auto incomingNulls = structReader_->nulls();
-  auto outputRows = structReader_->outputRows();
+  const auto offset = structReader_->lazyVectorReadOffset();
+  const auto* incomingNulls = structReader_->nulls();
+  const auto outputRows = structReader_->outputRows();
   raw_vector<vector_size_t> selectedRows;
   RowSet effectiveRows;
   ExceptionContextSetter exceptionContext(
diff --git a/velox/dwio/common/ColumnLoader.h b/velox/dwio/common/ColumnLoader.h
index 4234ff32578da..ed883d23a143f 100644
--- a/velox/dwio/common/ColumnLoader.h
+++ b/velox/dwio/common/ColumnLoader.h
@@ -38,8 +38,8 @@ class ColumnLoader : public velox::VectorLoader {
       VectorPtr* result) override;
 
  private:
-  SelectiveStructColumnReaderBase* structReader_;
-  SelectiveColumnReader* fieldReader_;
+  SelectiveStructColumnReaderBase* const structReader_;
+  SelectiveColumnReader* const fieldReader_;
   // This is checked against the version of 'structReader' on load. If
   // these differ, 'structReader' has been advanced since the creation
   // of 'this' and 'this' is no longer loadable.
diff --git a/velox/dwio/common/ColumnSelector.cpp b/velox/dwio/common/ColumnSelector.cpp
index 48d2030a658cd..ef57fff7ab0f6 100644
--- a/velox/dwio/common/ColumnSelector.cpp
+++ b/velox/dwio/common/ColumnSelector.cpp
@@ -91,7 +91,7 @@ FilterTypePtr ColumnSelector::buildNode(
   // column selector filter tree
   nodes_.reserve(nodes_.size() + type->size());
   if (node.node == 0) {
-    auto rowType = type->asRow();
+    auto& rowType = type->asRow();
     for (size_t i = 0, size = type->size(); i < size; ++i) {
       bool inData = contentType && i < contentType->size();
       current->addChild(buildNode(
@@ -163,20 +163,17 @@ void ColumnSelector::copy(
   }
 }
 
-/**
- * Copy the selector tree and apply file schema to handle schema mismatch
- */
 ColumnSelector ColumnSelector::apply(
     const std::shared_ptr<ColumnSelector>& origin,
     const std::shared_ptr<const RowType>& fileSchema) {
-  // current instance maybe null
+  // current instance maybe null.
   if (origin == nullptr) {
     return ColumnSelector(fileSchema);
   }
 
   // if selector has no schema, we just build a new tree with file schema
   // selector.getProjection will carry all logic information including nodes
-  auto onlyFilter = !origin->hasSchema();
+  const bool onlyFilter = !origin->hasSchema();
   ColumnSelector cs(
       onlyFilter ? fileSchema : origin->getSchema(),
       origin->getNodeFilter(),
@@ -318,15 +315,15 @@ const FilterTypePtr& ColumnSelector::process(const std::string& column, bool) {
 std::pair<std::string_view, std::string_view> extractColumnName(
     const std::string_view& name) {
   // right now this is the only supported expression for MAP key filter
-  auto pos = name.find('#');
-  if (pos != std::string::npos) {
-    // special map column handling
-    auto colName = name.substr(0, pos);
-    auto expr = name.substr(pos + 1);
-    return std::make_pair(colName, expr);
+  const auto pos = name.find('#');
+  if (pos == std::string::npos) {
+    return std::make_pair(name, "");
   }
 
-  return std::make_pair(name, "");
+  // Special map column handling.
+  const auto colName = name.substr(0, pos);
+  const auto expr = name.substr(pos + 1);
+  return std::make_pair(colName, expr);
 }
 
 void ColumnSelector::logFilter() const {
@@ -342,4 +339,27 @@ void ColumnSelector::logFilter() const {
   getLog()->logColumnFilter(filter_, numColumns, numNodes, hasSchema());
 }
 
+std::shared_ptr<ColumnSelector> ColumnSelector::fromScanSpec(
+    const velox::common::ScanSpec& spec,
+    const RowTypePtr& rowType) {
+  std::vector<std::string> columnNames;
+  for (auto& child : spec.children()) {
+    if (child->isConstant()) {
+      continue;
+    }
+    std::string name = child->fieldName();
+    if (!child->flatMapFeatureSelection().empty()) {
+      name += "#[";
+      name += folly::join(',', child->flatMapFeatureSelection());
+      name += ']';
+    }
+    columnNames.push_back(std::move(name));
+  }
+  if (columnNames.empty()) {
+    static const RowTypePtr kEmpty{ROW({}, {})};
+    return std::make_shared<ColumnSelector>(kEmpty);
+  }
+  return std::make_shared<ColumnSelector>(rowType, columnNames);
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ColumnSelector.h b/velox/dwio/common/ColumnSelector.h
index b5bca13905f2f..62408e55a2134 100644
--- a/velox/dwio/common/ColumnSelector.h
+++ b/velox/dwio/common/ColumnSelector.h
@@ -18,6 +18,7 @@
 
 #include "velox/dwio/common/FilterNode.h"
 #include "velox/dwio/common/MetricsLog.h"
+#include "velox/dwio/common/ScanSpec.h"
 #include "velox/dwio/common/TypeWithId.h"
 
 namespace facebook::velox::dwio::common {
@@ -133,8 +134,8 @@ class ColumnSelector {
     checkSelectColNonDuplicate(fileColumnNamesReadAsLowerCase);
   }
 
-  // set a specific node to read state
-  // only means we only enable exact the node only.
+  /// Sets a specific node to read state
+  /// only means we only enable exact the node only.
   void setRead(const FilterTypePtr& node, bool only = false);
 
   /**
@@ -144,7 +145,8 @@ class ColumnSelector {
    * @return the id in the tree
    */
   const FilterTypePtr& getNode(size_t id) const {
-    DWIO_ENSURE(inRange(id), "node is out of range");
+    VELOX_CHECK(
+        inRange(id), "node: {} is out of range of {}", id, nodes_.size());
     return nodes_[id];
   }
 
@@ -251,23 +253,23 @@ class ColumnSelector {
     return FilterType::getInvalid();
   }
 
-  // build selected schema based on current filter
+  /// Builds selected schema based on current filter.
   std::shared_ptr<const TypeWithId> buildSelected() const;
 
-  // build selected schema based on current filter and reorder columns according
-  // to what filter specifies
+  /// Builds selected schema based on current filter and reorder columns
+  /// according to what filter specifies.
   std::shared_ptr<const velox::RowType> buildSelectedReordered() const;
 
-  // build a column filter out of filter tree
-  // This only returns top columns today and can be extended to node level
+  /// Build a column filter out of filter tree.
+  /// This only returns top columns today and can be extended to node level
   const ColumnFilter& getProjection() const;
 
-  // a filter lambda function accept column index for query
+  /// A filter lambda function accept column index for query.
   std::function<bool(uint64_t)> getFilter() const {
     return [this](uint64_t column) { return shouldReadColumn(column); };
   }
 
-  // this is essentially the effective schema when column selector was built
+  /// This is essentially the effective schema when column selector was built.
   bool hasSchema() const {
     return schema_ != nullptr;
   }
@@ -287,11 +289,15 @@ class ColumnSelector {
       const std::vector<std::string>& keys,
       const std::vector<std::string>& values);
 
-  // Create a file selector based on a logic selector and disk schema
+  /// Creates a file selector based on a logic selector and disk schema.
   static ColumnSelector apply(
       const std::shared_ptr<ColumnSelector>& origin,
       const std::shared_ptr<const velox::RowType>& fileSchema);
 
+  static std::shared_ptr<ColumnSelector> fromScanSpec(
+      const velox::common::ScanSpec& spec,
+      const RowTypePtr& rowType);
+
  private:
   // visit the tree with disk type
   static void copy(
diff --git a/velox/dwio/common/ColumnVisitors.h b/velox/dwio/common/ColumnVisitors.h
index 3ac3d5e219f74..346a44bf69e1d 100644
--- a/velox/dwio/common/ColumnVisitors.h
+++ b/velox/dwio/common/ColumnVisitors.h
@@ -49,29 +49,32 @@ struct DropValues {
   }
 };
 
-template <typename TReader>
-struct ExtractToReader {
+class ExtractToReader {
+ public:
   using HookType = dwio::common::NoHook;
   static constexpr bool kSkipNulls = false;
-  explicit ExtractToReader(TReader* readerIn) : reader(readerIn) {}
+  explicit ExtractToReader(SelectiveColumnReader* reader) : reader_(reader) {}
 
   bool acceptsNulls() const {
     return true;
   }
 
   template <typename T>
-  void addNull(vector_size_t rowIndex);
+  void addNull(vector_size_t /*rowIndex*/) {
+    reader_->template addNull<T>();
+  }
 
   template <typename V>
   void addValue(vector_size_t /*rowIndex*/, V value) {
-    reader->addValue(value);
+    reader_->addValue(value);
   }
 
-  TReader* reader;
-
   dwio::common::NoHook& hook() {
     return noHook();
   }
+
+ private:
+  SelectiveColumnReader* const reader_;
 };
 
 template <typename THook>
@@ -94,7 +97,7 @@ class ExtractToHook {
 
   template <typename V>
   void addValue(vector_size_t rowIndex, V value) {
-    hook_.addValue(rowIndex, &value);
+    hook_.addValueTyped(rowIndex, value);
   }
 
   auto& hook() {
@@ -123,7 +126,7 @@ class ExtractToGenericHook {
 
   template <typename V>
   void addValue(vector_size_t rowIndex, V value) {
-    hook_->addValue(rowIndex, &value);
+    hook_->addValueTyped(rowIndex, value);
   }
 
   ValueHook& hook() {
@@ -150,6 +153,11 @@ class ColumnVisitor {
   using DataType = T;
   static constexpr bool dense = isDense;
   static constexpr bool kHasBulkPath = true;
+  static constexpr bool kHasFilter =
+      !std::is_same_v<FilterType, velox::common::AlwaysTrue>;
+  static constexpr bool kHasHook = !std::is_same_v<HookType, NoHook>;
+  static constexpr bool kFilterOnly = std::is_same_v<Extract, DropValues>;
+
   ColumnVisitor(
       TFilter& filter,
       SelectiveColumnReader* reader,
@@ -269,7 +277,7 @@ class ColumnVisitor {
     }
     if (++rowIndex_ >= numRows_) {
       atEnd = true;
-      return rows_[numRows_ - 1] - previous;
+      return rowAt(numRows_ - 1) - previous;
     }
     if (TFilter::deterministic && isDense) {
       return 0;
@@ -301,12 +309,12 @@ class ColumnVisitor {
     if (isDense) {
       return 0;
     }
-    return currentRow() - rows_[rowIndex_ - 1] - 1;
+    return currentRow() - rowAt(rowIndex_ - 1) - 1;
   }
 
   FOLLY_ALWAYS_INLINE vector_size_t process(T value, bool& atEnd) {
     if (!TFilter::deterministic) {
-      auto previous = currentRow();
+      const auto previous = currentRow();
       if (velox::common::applyFilter(filter_, value)) {
         filterPassed(value);
       } else {
@@ -314,10 +322,11 @@ class ColumnVisitor {
       }
       if (++rowIndex_ >= numRows_) {
         atEnd = true;
-        return rows_[numRows_ - 1] - previous;
+        return rowAt(numRows_ - 1) - previous;
       }
       return currentRow() - previous - 1;
     }
+
     // The filter passes or fails and we go to the next row if any.
     if (velox::common::applyFilter(filter_, value)) {
       filterPassed(value);
@@ -331,7 +340,7 @@ class ColumnVisitor {
     if (isDense) {
       return 0;
     }
-    return currentRow() - rows_[rowIndex_ - 1] - 1;
+    return currentRow() - rowAt(rowIndex_ - 1) - 1;
   }
 
   // Returns space for 'size' items of T for a scan to fill. The scan
@@ -341,26 +350,34 @@ class ColumnVisitor {
     return reader_->mutableValues<T>(size);
   }
 
-  int32_t numRows() const {
-    return reader_->numRows();
-  }
-
   SelectiveColumnReader& reader() const {
     return *reader_;
   }
 
-  inline vector_size_t rowAt(vector_size_t index) {
+  inline vector_size_t rowAt(vector_size_t index) const {
     if (isDense) {
       return index;
     }
     return rows_[index];
   }
 
-  bool atEnd() {
+  vector_size_t rowIndex() const {
+    return rowIndex_;
+  }
+
+  void setRowIndex(vector_size_t index) {
+    rowIndex_ = index;
+  }
+
+  void addRowIndex(vector_size_t size) {
+    rowIndex_ += size;
+  }
+
+  bool atEnd() const {
     return rowIndex_ >= numRows_;
   }
 
-  vector_size_t currentRow() {
+  vector_size_t currentRow() const {
     if (isDense) {
       return rowIndex_;
     }
@@ -371,7 +388,7 @@ class ColumnVisitor {
     return rows_;
   }
 
-  vector_size_t numRows() {
+  vector_size_t numRows() const {
     return numRows_;
   }
 
@@ -402,6 +419,10 @@ class ColumnVisitor {
     return reader_->mutableOutputRows(size);
   }
 
+  int32_t numValuesBias() const {
+    return numValuesBias_;
+  }
+
   void setNumValuesBias(int32_t bias) {
     numValuesBias_ = bias;
   }
@@ -413,6 +434,14 @@ class ColumnVisitor {
     }
   }
 
+  void addNumValues(int size) {
+    auto numValues = reader_->numValues() + size;
+    reader_->setNumValues(numValues);
+    if constexpr (kHasFilter) {
+      reader_->setNumRows(numValues);
+    }
+  }
+
   ExtractValues extractValues() const {
     return values_;
   }
@@ -456,8 +485,8 @@ class ColumnVisitor {
   StringDictionaryColumnVisitor<TFilter, ExtractValues, isDense>
   toStringDictionaryColumnVisitor();
 
-  // Use for replacing *coall rows with non-null rows for fast path with
-  // processRun and processRle.
+  // Use for replacing all rows with non-null rows for fast path with processRun
+  // and processRle.
   void setRows(folly::Range<const int32_t*> newRows) {
     rows_ = newRows.data();
     numRows_ = newRows.size();
@@ -477,8 +506,8 @@ class ColumnVisitor {
 template <typename T, typename TFilter, typename ExtractValues, bool isDense>
 FOLLY_ALWAYS_INLINE void
 ColumnVisitor<T, TFilter, ExtractValues, isDense>::filterFailed() {
-  auto preceding = filter_.getPrecedingPositionsToFail();
-  auto succeeding = filter_.getSucceedingPositionsToFail();
+  const auto preceding = filter_.getPrecedingPositionsToFail();
+  const auto succeeding = filter_.getSucceedingPositionsToFail();
   if (preceding) {
     reader_->dropResults(preceding);
   }
@@ -490,12 +519,12 @@ ColumnVisitor<T, TFilter, ExtractValues, isDense>::filterFailed() {
 template <typename T, typename TFilter, typename ExtractValues, bool isDense>
 inline void ColumnVisitor<T, TFilter, ExtractValues, isDense>::addResult(
     T value) {
-  values_.addValue(rowIndex_, value);
+  values_.addValue(rowIndex_ + numValuesBias_, value);
 }
 
 template <typename T, typename TFilter, typename ExtractValues, bool isDense>
 inline void ColumnVisitor<T, TFilter, ExtractValues, isDense>::addNull() {
-  values_.template addNull<T>(rowIndex_);
+  values_.template addNull<T>(rowIndex_ + numValuesBias_);
 }
 
 template <typename T, typename TFilter, typename ExtractValues, bool isDense>
@@ -504,12 +533,6 @@ inline void ColumnVisitor<T, TFilter, ExtractValues, isDense>::addOutputRow(
   reader_->addOutputRow(row);
 }
 
-template <typename TReader>
-template <typename T>
-void ExtractToReader<TReader>::addNull(vector_size_t /*rowIndex*/) {
-  reader->template addNull<T>();
-}
-
 enum FilterResult { kUnknown = 0x40, kSuccess = 0x80, kFailure = 0 };
 
 namespace detail {
@@ -699,18 +722,18 @@ class DictionaryColumnVisitor
   DictionaryColumnVisitor(
       TFilter& filter,
       SelectiveColumnReader* reader,
-      RowSet rows,
+      const RowSet& rows,
       ExtractValues values)
       : ColumnVisitor<T, TFilter, ExtractValues, isDense>(
             filter,
             reader,
             rows,
             values),
-        state_(reader->scanState().rawState),
         width_(
             reader->fileType().type()->kind() == TypeKind::BIGINT        ? 8
                 : reader->fileType().type()->kind() == TypeKind::INTEGER ? 4
-                                                                         : 2) {}
+                                                                         : 2),
+        state_(reader->scanState().rawState) {}
 
   FOLLY_ALWAYS_INLINE bool isInDict() {
     if (inDict()) {
@@ -735,10 +758,11 @@ class DictionaryColumnVisitor
       }
       return super::process(signedValue, atEnd);
     }
-    vector_size_t previous =
+
+    const vector_size_t previous =
         isDense && TFilter::deterministic ? 0 : super::currentRow();
-    T valueInDictionary = dict()[value];
-    if (std::is_same_v<TFilter, velox::common::AlwaysTrue>) {
+    const T valueInDictionary = dict()[value];
+    if constexpr (!hasFilter()) {
       super::filterPassed(valueInDictionary);
     } else {
       // check the dictionary cache
@@ -763,6 +787,7 @@ class DictionaryColumnVisitor
         }
       }
     }
+
     if (++super::rowIndex_ >= super::numRows_) {
       atEnd = true;
       return (isDense && TFilter::deterministic)
@@ -793,30 +818,43 @@ class DictionaryColumnVisitor
       T* values,
       int32_t& numValues) {
     DCHECK_EQ(input, values + numValues);
-    if (!hasFilter) {
+    if constexpr (!DictionaryColumnVisitor::hasFilter()) {
       if (hasHook) {
         translateByDict(input, numInput, values);
         super::values_.hook().addValues(
             scatter ? scatterRows + super::rowIndex_
-                    : velox::iota(super::numRows_, super::innerNonNullRows()) +
+                    : velox::iota(
+                          super::numRows_,
+                          super::innerNonNullRows(),
+                          super::numValuesBias_) +
                     super::rowIndex_,
             values,
-            numInput,
-            sizeof(T));
+            numInput);
         super::rowIndex_ += numInput;
         return;
       }
-      if (inDict()) {
-        translateScatter<true, scatter>(
-            input, numInput, scatterRows, numValues, values);
+      if constexpr (std::is_same_v<TFilter, velox::common::IsNotNull>) {
+        auto* begin = (scatter ? scatterRows : super::rows_) + super::rowIndex_;
+        std::copy(begin, begin + numInput, filterHits + numValues);
+        if constexpr (!super::kFilterOnly) {
+          translateByDict(input, numInput, values + numValues);
+        }
+        numValues += numInput;
       } else {
-        translateScatter<false, scatter>(
-            input, numInput, scatterRows, numValues, values);
+        if (inDict()) {
+          translateScatter<true, scatter>(
+              input, numInput, scatterRows, numValues, values);
+        } else {
+          translateScatter<false, scatter>(
+              input, numInput, scatterRows, numValues, values);
+        }
+        numValues = scatter ? scatterRows[super::rowIndex_ + numInput - 1] + 1
+                            : numValues + numInput;
       }
       super::rowIndex_ += numInput;
-      numValues = scatter ? scatterRows[super::rowIndex_ - 1] + 1
-                          : numValues + numInput;
       return;
+    } else {
+      static_assert(hasFilter);
     }
     // The filter path optionally extracts values but always sets
     // filterHits. It first loads a vector of indices. It translates
@@ -828,8 +866,7 @@ class DictionaryColumnVisitor
     // written, the passing bitmap is used to load a permute mask to
     // permute the passing values to the left of a vector register and
     // write  the whole register to the end of 'values'
-    constexpr bool kFilterOnly =
-        std::is_same_v<typename super::Extract, DropValues>;
+    constexpr bool kFilterOnly = super::kFilterOnly;
     constexpr int32_t kWidth = xsimd::batch<int32_t>::size;
     int32_t last = numInput & ~(kWidth - 1);
     for (auto i = 0; i < numInput; i += kWidth) {
@@ -1074,8 +1111,15 @@ class DictionaryColumnVisitor
     return state_.filterCache;
   }
 
-  RawScanState state_;
+  static constexpr bool hasFilter() {
+    // Dictionary values cannot be null.  See the explanation in
+    // `DictionaryValues::hasFilter'.
+    return !std::is_same_v<TFilter, velox::common::AlwaysTrue> &&
+        !std::is_same_v<TFilter, velox::common::IsNotNull>;
+  }
+
   const uint8_t width_;
+  RawScanState state_;
 };
 
 template <typename T, typename TFilter, typename ExtractValues, bool isDense>
@@ -1124,7 +1168,7 @@ class StringDictionaryColumnVisitor
     }
     vector_size_t previous =
         isDense && TFilter::deterministic ? 0 : super::currentRow();
-    if (std::is_same_v<TFilter, velox::common::AlwaysTrue>) {
+    if constexpr (!DictSuper::hasFilter()) {
       super::filterPassed(index);
     } else {
       // check the dictionary cache
@@ -1137,7 +1181,7 @@ class StringDictionaryColumnVisitor
         super::filterFailed();
       } else {
         if (velox::common::applyFilter(
-                super::filter_, valueInDictionary(value, inStrideDict))) {
+                super::filter_, valueInDictionary(index))) {
           super::filterPassed(index);
           if (TFilter::deterministic) {
             DictSuper::filterCache()[index] = FilterResult::kSuccess;
@@ -1177,25 +1221,30 @@ class StringDictionaryColumnVisitor
       int32_t& numValues) {
     DCHECK(input == values + numValues);
     setByInDict(values + numValues, numInput);
-    if (!hasFilter) {
+    if constexpr (!DictSuper::hasFilter()) {
       if (hasHook) {
         for (auto i = 0; i < numInput; ++i) {
-          auto value = input[i];
           super::values_.addValue(
               scatterRows ? scatterRows[super::rowIndex_ + i]
                           : super::rowIndex_ + i,
-              value);
+              valueInDictionary(input[i]));
         }
       }
-      DCHECK_EQ(input, values + numValues);
-      if (scatter) {
+      if constexpr (std::is_same_v<TFilter, velox::common::IsNotNull>) {
+        auto* begin = (scatter ? scatterRows : super::rows_) + super::rowIndex_;
+        std::copy(begin, begin + numInput, filterHits + numValues);
+        numValues += numInput;
+      } else if constexpr (scatter) {
         dwio::common::scatterDense(
             input, scatterRows + super::rowIndex_, numInput, values);
+        numValues = scatterRows[super::rowIndex_ + numInput - 1] + 1;
+      } else {
+        numValues += numInput;
       }
-      numValues = scatter ? scatterRows[super::rowIndex_ + numInput - 1] + 1
-                          : numValues + numInput;
       super::rowIndex_ += numInput;
       return;
+    } else {
+      static_assert(hasFilter);
     }
     constexpr bool filterOnly =
         std::is_same_v<typename super::Extract, DropValues>;
@@ -1223,16 +1272,7 @@ class StringDictionaryColumnVisitor
         while (bits) {
           int index = bits::getAndClearLastSetBit(bits);
           int32_t value = input[i + index];
-          bool result;
-          if (value >= DictSuper::dictionarySize()) {
-            result = applyFilter(
-                super::filter_,
-                valueInDictionary(value - DictSuper::dictionarySize(), true));
-          } else {
-            result =
-                applyFilter(super::filter_, valueInDictionary(value, false));
-          }
-          if (result) {
+          if (applyFilter(super::filter_, valueInDictionary(value))) {
             DictSuper::filterCache()[value] = FilterResult::kSuccess;
             passed |= 1 << index;
           } else {
@@ -1312,67 +1352,17 @@ class StringDictionaryColumnVisitor
     }
   }
 
-  folly::StringPiece valueInDictionary(int64_t index, bool inStrideDict) {
-    if (inStrideDict) {
-      return folly::StringPiece(reinterpret_cast<const StringView*>(
-          DictSuper::state_.dictionary2.values)[index]);
+  folly::StringPiece valueInDictionary(int64_t index) {
+    auto stripeDictSize = DictSuper::state_.dictionary.numValues;
+    if (index < stripeDictSize) {
+      return reinterpret_cast<const StringView*>(
+          DictSuper::state_.dictionary.values)[index];
     }
-    return folly::StringPiece(reinterpret_cast<const StringView*>(
-        DictSuper::state_.dictionary.values)[index]);
+    return reinterpret_cast<const StringView*>(
+        DictSuper::state_.dictionary2.values)[index - stripeDictSize];
   }
 };
 
-class ExtractStringDictionaryToGenericHook {
- public:
-  static constexpr bool kSkipNulls = true;
-  using HookType = ValueHook;
-
-  ExtractStringDictionaryToGenericHook(
-      ValueHook* hook,
-      RowSet rows,
-      RawScanState state)
-
-      : hook_(hook), rows_(rows), state_(state) {}
-
-  bool acceptsNulls() {
-    return hook_->acceptsNulls();
-  }
-
-  template <typename T>
-  void addNull(vector_size_t rowIndex) {
-    hook_->addNull(rowIndex);
-  }
-
-  void addValue(vector_size_t rowIndex, int32_t value) {
-    // We take the string from the stripe or stride dictionary
-    // according to the index. Stride dictionary indices are offset up
-    // by the stripe dict size.
-    if (value < dictionarySize()) {
-      auto view = folly::StringPiece(
-          reinterpret_cast<const StringView*>(state_.dictionary.values)[value]);
-      hook_->addValue(rowIndex, &view);
-    } else {
-      VELOX_DCHECK(state_.inDictionary);
-      auto view = folly::StringPiece(reinterpret_cast<const StringView*>(
-          state_.dictionary2.values)[value - dictionarySize()]);
-      hook_->addValue(rowIndex, &view);
-    }
-  }
-
-  ValueHook& hook() {
-    return *hook_;
-  }
-
- private:
-  int32_t dictionarySize() const {
-    return state_.dictionary.numValues;
-  }
-
-  ValueHook* const hook_;
-  RowSet const rows_;
-  RawScanState state_;
-};
-
 template <typename T, typename TFilter, typename ExtractValues, bool isDense>
 class DirectRleColumnVisitor
     : public ColumnVisitor<T, TFilter, ExtractValues, isDense> {
@@ -1390,13 +1380,6 @@ class DirectRleColumnVisitor
             rows,
             values) {}
 
-  // Use for replacing all rows with non-null rows for fast path with
-  // processRun and processRle.
-  void setRows(folly::Range<const int32_t*> newRows) {
-    super::rows_ = newRows.data();
-    super::numRows_ = newRows.size();
-  }
-
   // Processes 'numInput' T's in 'input'. Sets 'values' and
   // 'numValues'' to the resulting values. 'scatterRows' may be
   // non-null if there is no filter and the decoded values should be
@@ -1479,4 +1462,115 @@ class DirectRleColumnVisitor
   }
 };
 
+template <bool kEncodingHasNulls, bool kDictionary>
+class StringColumnReadWithVisitorHelper {
+ public:
+  StringColumnReadWithVisitorHelper(SelectiveColumnReader& reader, RowSet rows)
+      : reader_(reader), rows_(rows) {}
+
+  template <typename F>
+  auto operator()(F&& readWithVisitor) {
+    const bool isDense = rows_.back() == rows_.size() - 1;
+    if (reader_.scanSpec()->keepValues()) {
+      if (auto* hook = reader_.scanSpec()->valueHook()) {
+        if (isDense) {
+          readHelper<velox::common::AlwaysTrue, true>(
+              &alwaysTrue(),
+              ExtractToGenericHook(hook),
+              std::forward<F>(readWithVisitor));
+        } else {
+          readHelper<velox::common::AlwaysTrue, false>(
+              &alwaysTrue(),
+              ExtractToGenericHook(hook),
+              std::forward<F>(readWithVisitor));
+        }
+      } else {
+        if (isDense) {
+          processFilter<true>(
+              ExtractToReader(&reader_), std::forward<F>(readWithVisitor));
+        } else {
+          processFilter<false>(
+              ExtractToReader(&reader_), std::forward<F>(readWithVisitor));
+        }
+      }
+    } else {
+      if (isDense) {
+        processFilter<true>(DropValues(), std::forward<F>(readWithVisitor));
+      } else {
+        processFilter<false>(DropValues(), std::forward<F>(readWithVisitor));
+      }
+    }
+  }
+
+ private:
+  template <typename TFilter, bool kIsDense, typename ExtractValues, typename F>
+  void readHelper(
+      velox::common::Filter* filter,
+      ExtractValues extractValues,
+      F readWithVisitor) {
+    readWithVisitor(
+        ColumnVisitor<folly::StringPiece, TFilter, ExtractValues, kIsDense>(
+            *static_cast<TFilter*>(filter), &reader_, rows_, extractValues));
+  }
+
+  template <bool kIsDense, typename ExtractValues, typename F>
+  void processFilter(ExtractValues extractValues, F&& readWithVisitor) {
+    using FilterValueT =
+        std::conditional_t<kDictionary, vector_size_t, StringView>;
+    auto* filter = reader_.scanSpec()->filter();
+    if (filter == nullptr) {
+      readHelper<velox::common::AlwaysTrue, kIsDense>(
+          &alwaysTrue(), extractValues, std::forward<F>(readWithVisitor));
+      return;
+    }
+    switch (filter->kind()) {
+      case velox::common::FilterKind::kAlwaysTrue:
+        readHelper<velox::common::AlwaysTrue, kIsDense>(
+            filter, extractValues, std::forward<F>(readWithVisitor));
+        break;
+      case velox::common::FilterKind::kIsNull:
+        if constexpr (kEncodingHasNulls) {
+          reader_.filterNulls<FilterValueT>(
+              rows_, true, !std::is_same_v<ExtractValues, DropValues>);
+        } else {
+          readHelper<velox::common::IsNull, kIsDense>(
+              filter, extractValues, std::forward<F>(readWithVisitor));
+        }
+        break;
+      case velox::common::FilterKind::kIsNotNull:
+        if constexpr (
+            kEncodingHasNulls && std::is_same_v<ExtractValues, DropValues>) {
+          reader_.filterNulls<FilterValueT>(rows_, false, false);
+        } else {
+          readHelper<velox::common::IsNotNull, kIsDense>(
+              filter, extractValues, std::forward<F>(readWithVisitor));
+        }
+        break;
+      case velox::common::FilterKind::kBytesRange:
+        readHelper<velox::common::BytesRange, kIsDense>(
+            filter, extractValues, std::forward<F>(readWithVisitor));
+        break;
+      case velox::common::FilterKind::kNegatedBytesRange:
+        readHelper<velox::common::NegatedBytesRange, kIsDense>(
+            filter, extractValues, std::forward<F>(readWithVisitor));
+        break;
+      case velox::common::FilterKind::kBytesValues:
+        readHelper<velox::common::BytesValues, kIsDense>(
+            filter, extractValues, std::forward<F>(readWithVisitor));
+        break;
+      case velox::common::FilterKind::kNegatedBytesValues:
+        readHelper<velox::common::NegatedBytesValues, kIsDense>(
+            filter, extractValues, std::forward<F>(readWithVisitor));
+        break;
+      default:
+        readHelper<velox::common::Filter, kIsDense>(
+            filter, extractValues, std::forward<F>(readWithVisitor));
+        break;
+    }
+  }
+
+  SelectiveColumnReader& reader_;
+  const RowSet rows_;
+};
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/DecoderUtil.cpp b/velox/dwio/common/DecoderUtil.cpp
index 7cdf943db3902..7b47fb2b9adbd 100644
--- a/velox/dwio/common/DecoderUtil.cpp
+++ b/velox/dwio/common/DecoderUtil.cpp
@@ -54,7 +54,7 @@ bool nonNullRowsFromSparse(
     RowSet rows,
     raw_vector<int32_t>& innerRows,
     raw_vector<int32_t>& outerRows,
-    uint64_t* resultNulls,
+    uint8_t* resultNullBytes,
     int32_t& tailSkip) {
   constexpr int32_t kStep = xsimd::batch<int32_t>::size;
   bool anyNull = false;
@@ -66,7 +66,6 @@ bool nonNullRowsFromSparse(
   int32_t numNulls = 0;
   int32_t numInner = 0;
   int32_t lastNonNull = -1;
-  auto resultNullBytes = reinterpret_cast<uint8_t*>(resultNulls);
 
   // Returns the index in terms of non-null rows for
   // 'rows[i]'. Assumes that i is increasing between calls.
@@ -92,16 +91,7 @@ bool nonNullRowsFromSparse(
     if (isDense(rows.data() + i, width)) {
       uint16_t flags = load8Bits(nulls, rows[i]) & widthMask;
       if (outputNulls) {
-        if constexpr (kStep == 8) {
-          resultNullBytes[i / 8] = flags;
-        } else {
-          VELOX_DCHECK_EQ(kStep, 4);
-          if (i % 8 == 0) {
-            resultNullBytes[i / 8] = flags;
-          } else {
-            resultNullBytes[i / 8] |= flags << 4;
-          }
-        }
+        bits::storeBitsToByte<kStep>(flags, resultNullBytes, i);
         anyNull |= flags != widthMask;
       }
       if (!flags) {
@@ -131,16 +121,7 @@ bool nonNullRowsFromSparse(
       auto next8Rows = xsimd::load_unaligned(rows.data() + i);
       uint16_t flags = simd::gather8Bits(nulls, next8Rows, width);
       if (outputNulls) {
-        if constexpr (kStep == 8) {
-          resultNullBytes[i / 8] = flags;
-        } else {
-          VELOX_DCHECK_EQ(kStep, 4);
-          if (i % 8 == 0) {
-            resultNullBytes[i / 8] = flags;
-          } else {
-            resultNullBytes[i / 8] |= flags << 4;
-          }
-        }
+        bits::storeBitsToByte<kStep>(flags, resultNullBytes, i);
         anyNull |= flags != widthMask;
       }
       if (!flags) {
@@ -176,7 +157,7 @@ template bool nonNullRowsFromSparse<true, false>(
     RowSet rows,
     raw_vector<int32_t>& innerRows,
     raw_vector<int32_t>& outerRows,
-    uint64_t* resultNulls,
+    uint8_t* resultNullBytes,
     int32_t& tailSkip);
 
 template bool nonNullRowsFromSparse<false, true>(
@@ -184,7 +165,7 @@ template bool nonNullRowsFromSparse<false, true>(
     RowSet rows,
     raw_vector<int32_t>& innerRows,
     raw_vector<int32_t>& outerRows,
-    uint64_t* resultNulls,
+    uint8_t* resultNullBytes,
     int32_t& tailSkip);
 
 template bool nonNullRowsFromSparse<false, false>(
@@ -192,7 +173,7 @@ template bool nonNullRowsFromSparse<false, false>(
     RowSet rows,
     raw_vector<int32_t>& innerRows,
     raw_vector<int32_t>& outerRows,
-    uint64_t* resultNulls,
+    uint8_t* resultNullBytes,
     int32_t& tailSkip);
 
 template <typename T>
diff --git a/velox/dwio/common/DecoderUtil.h b/velox/dwio/common/DecoderUtil.h
index dd393e452b7ad..34822647fc3b7 100644
--- a/velox/dwio/common/DecoderUtil.h
+++ b/velox/dwio/common/DecoderUtil.h
@@ -180,7 +180,7 @@ void fixedWidthScan(
       [&](T value, int32_t rowIndex) {
         if (!hasFilter) {
           if (hasHook) {
-            hook.addValue(scatterRows[rowIndex], &value);
+            hook.addValueTyped(scatterRows[rowIndex], value);
           } else {
             auto targetRow = scatter ? scatterRows[rowIndex] : rowIndex;
             rawValues[targetRow] = value;
@@ -214,8 +214,7 @@ void fixedWidthScan(
                   hook.addValues(
                       scatterRows + rowIndex,
                       buffer + firstRow - rowOffset,
-                      kStep,
-                      sizeof(T));
+                      kStep);
                 } else {
                   if (scatter) {
                     scatterDense(
@@ -266,7 +265,9 @@ void fixedWidthScan(
                 if (!hasFilter) {
                   if (hasHook) {
                     hook.addValues(
-                        scatterRows + rowIndex, &values, kWidth, sizeof(T));
+                        scatterRows + rowIndex,
+                        reinterpret_cast<T*>(&values),
+                        kWidth);
                   } else {
                     if (scatter) {
                       scatterDense<T>(
@@ -321,8 +322,9 @@ void fixedWidthScan(
                 }
                 if (!hasFilter) {
                   if (hasHook) {
-                    hook.addValues(
-                        scatterRows + rowIndex, &values, width, sizeof(T));
+                    T values2[values.size];
+                    values.store_unaligned(values2);
+                    hook.addValues(scatterRows + rowIndex, values2, width);
                   } else {
                     if (scatter) {
                       scatterDense<T>(
@@ -385,15 +387,28 @@ bool nonNullRowsFromSparse(
     RowSet rows,
     raw_vector<int32_t>& innerRows,
     raw_vector<int32_t>& outerRows,
-    uint64_t* resultNulls,
+    uint8_t* resultNulls,
     int32_t& tailSkip);
 
+template <bool isFilter, bool outputNulls>
+bool nonNullRowsFromSparse(
+    const uint64_t* nulls,
+    RowSet rows,
+    raw_vector<int32_t>& innerRows,
+    raw_vector<int32_t>& outerRows,
+    uint64_t* resultNulls,
+    int32_t& tailSkip) {
+  auto* resultNullBytes = reinterpret_cast<uint8_t*>(resultNulls);
+  return nonNullRowsFromSparse<isFilter, outputNulls>(
+      nulls, rows, innerRows, outerRows, resultNullBytes, tailSkip);
+}
+
 // See SelectiveColumnReader::useBulkPath.
 template <typename Visitor, bool hasNulls>
 bool useFastPath(Visitor& visitor) {
-  return (!std::is_same_v<typename Visitor::DataType, int128_t>)&&process::
-             hasAvx2() &&
-      Visitor::FilterType::deterministic && Visitor::kHasBulkPath &&
+  return (!std::is_same_v<typename Visitor::DataType, int128_t>) &&
+      process::hasAvx2() && Visitor::FilterType::deterministic &&
+      Visitor::kHasBulkPath &&
       (std::
            is_same_v<typename Visitor::FilterType, velox::common::AlwaysTrue> ||
        !hasNulls || !visitor.allowNulls()) &&
@@ -401,6 +416,12 @@ bool useFastPath(Visitor& visitor) {
        Visitor::HookType::kSkipNulls);
 }
 
+template <typename Visitor>
+bool useFastPath(Visitor& visitor, bool hasNulls) {
+  return hasNulls ? useFastPath<Visitor, true>(visitor)
+                  : useFastPath<Visitor, false>(visitor);
+}
+
 // Scatters 'numValues' elements of 'data' starting at data[sourceBegin] to
 // indices given starting with target[targetBegin]. The scatter is done from
 // last to first so as not to overwrite source data when copying from lower to
@@ -454,7 +475,7 @@ void processFixedWidthRun(
   constexpr bool hasHook = !std::is_same_v<THook, NoHook>;
   if (!hasFilter) {
     if (hasHook) {
-      hook.addValues(scatterRows + rowIndex, values, rows.size(), sizeof(T));
+      hook.addValues(scatterRows + rowIndex, values, rows.size());
     } else if (scatter) {
       scatterNonNulls(rowIndex, numInput, numValues, scatterRows, values);
       numValues = scatterRows[rowIndex + numInput - 1] + 1;
diff --git a/velox/dwio/common/DirectBufferedInput.cpp b/velox/dwio/common/DirectBufferedInput.cpp
new file mode 100644
index 0000000000000..caf6678580809
--- /dev/null
+++ b/velox/dwio/common/DirectBufferedInput.cpp
@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/DirectBufferedInput.h"
+#include "velox/common/memory/Allocation.h"
+#include "velox/common/process/TraceContext.h"
+#include "velox/dwio/common/DirectInputStream.h"
+
+DECLARE_int32(cache_prefetch_min_pct);
+
+using ::facebook::velox::common::Region;
+
+namespace facebook::velox::dwio::common {
+
+using cache::CoalescedLoad;
+using cache::ScanTracker;
+using cache::TrackingId;
+
+std::unique_ptr<SeekableInputStream> DirectBufferedInput::enqueue(
+    Region region,
+    const StreamIdentifier* sid = nullptr) {
+  if (!coalescedLoads_.empty()) {
+    // Results of previous load are no more available here.
+    coalescedLoads_.clear();
+    streamToCoalescedLoad_.wlock()->clear();
+  }
+  if (region.length == 0) {
+    return std::make_unique<SeekableArrayInputStream>(
+        static_cast<const char*>(nullptr), 0);
+  }
+
+  TrackingId id;
+  if (sid != nullptr) {
+    id = TrackingId(sid->getId());
+  }
+  VELOX_CHECK_LE(region.offset + region.length, fileSize_);
+  requests_.emplace_back(region, id);
+  if (tracker_) {
+    tracker_->recordReference(id, region.length, fileNum_, groupId_);
+  }
+  auto stream = std::make_unique<DirectInputStream>(
+      this,
+      ioStats_.get(),
+      region,
+      input_,
+      fileNum_,
+      tracker_,
+      id,
+      groupId_,
+      options_.loadQuantum());
+  requests_.back().stream = stream.get();
+  return stream;
+}
+
+bool DirectBufferedInput::isBuffered(uint64_t /*offset*/, uint64_t /*length*/)
+    const {
+  return false;
+}
+
+bool DirectBufferedInput::shouldPreload(int32_t numPages) {
+  return false;
+}
+
+namespace {
+
+// True if the percentage is high enough to warrant prefetch.
+bool isPrefetchablePct(int32_t pct) {
+  return pct >= FLAGS_cache_prefetch_min_pct;
+}
+
+int32_t adjustedReadPct(const cache::TrackingData& trackingData) {
+  // When called, there will be one more reference that read, since references
+  // are counted before reading.
+  if (trackingData.numReferences < 2) {
+    return 0;
+  }
+  return (100 * trackingData.numReads) / (trackingData.numReferences - 1);
+}
+} // namespace
+
+void DirectBufferedInput::load(const LogType /*unused*/) {
+  // After load, new requests cannot be merged into pre-load ones.
+  auto requests = std::move(requests_);
+
+  // We loop over access frequency buckets. For example readPct 80
+  // will get all streams where 80% or more of the referenced data is
+  // actually loaded.
+  for (auto readPct : std::vector<int32_t>{80, 50, 20, 0}) {
+    std::vector<LoadRequest*> storageLoad;
+    for (auto& request : requests) {
+      if (request.processed) {
+        continue;
+      }
+      cache::TrackingData trackingData;
+      const bool prefetchAnyway = request.trackingId.empty() ||
+          request.trackingId.id() == StreamIdentifier::sequentialFile().id_;
+      if (!prefetchAnyway && tracker_) {
+        trackingData = tracker_->trackingData(request.trackingId);
+      }
+      if (prefetchAnyway || adjustedReadPct(trackingData) >= readPct) {
+        request.processed = true;
+        storageLoad.push_back(&request);
+      }
+    }
+    makeLoads(std::move(storageLoad), isPrefetchablePct(readPct));
+  }
+}
+
+void DirectBufferedInput::makeLoads(
+    std::vector<LoadRequest*> requests,
+    bool prefetch) {
+  if (requests.empty() || (requests.size() < 2 && !prefetch)) {
+    // A single request has no other requests to coalesce with and is not
+    // eligible to prefetch. This will be loaded by itself on first use.
+    return;
+  }
+  const int32_t maxDistance = options_.maxCoalesceDistance();
+  const auto loadQuantum = options_.loadQuantum();
+  // If reading densely accessed, coalesce into large for best throughput, if
+  // for sparse, coalesce to quantum to reduce overread. Not all sparse access
+  // is correlated.
+  const auto maxCoalesceBytes =
+      prefetch ? options_.maxCoalesceBytes() : loadQuantum;
+  std::sort(
+      requests.begin(),
+      requests.end(),
+      [&](const LoadRequest* left, const LoadRequest* right) {
+        return left->region.offset < right->region.offset;
+      });
+
+  // Combine adjacent short reads.
+  int32_t numNewLoads = 0;
+  int64_t coalescedBytes = 0;
+  coalesceIo<LoadRequest*, LoadRequest*>(
+      requests,
+      maxDistance,
+      // Break batches up. Better load more short ones i parallel.
+      1000, // limit coalesce by size, not count.
+      [&](int32_t index) { return requests[index]->region.offset; },
+      [&](int32_t index) -> int32_t {
+        auto size = requests[index]->region.length;
+        if (size > loadQuantum) {
+          coalescedBytes += loadQuantum;
+          return loadQuantum;
+        }
+        coalescedBytes += size;
+        return size;
+      },
+      [&](int32_t index) {
+        if (coalescedBytes > maxCoalesceBytes) {
+          coalescedBytes = 0;
+          return kNoCoalesce;
+        }
+        return 1;
+      },
+      [&](LoadRequest* request, std::vector<LoadRequest*>& ranges) {
+        ranges.push_back(request);
+      },
+      [&](int32_t /*gap*/, std::vector<LoadRequest*> /*ranges*/) { /*no op*/ },
+      [&](const std::vector<LoadRequest*>& /*requests*/,
+          int32_t /*begin*/,
+          int32_t /*end*/,
+          uint64_t /*offset*/,
+          const std::vector<LoadRequest*>& ranges) {
+        ++numNewLoads;
+        readRegion(ranges, prefetch);
+      });
+  if (prefetch && executor_) {
+    for (auto i = 0; i < coalescedLoads_.size(); ++i) {
+      auto& load = coalescedLoads_[i];
+      if (load->state() == CoalescedLoad::State::kPlanned) {
+        executor_->add([pendingLoad = load]() {
+          process::TraceContext trace("Read Ahead");
+          pendingLoad->loadOrFuture(nullptr);
+        });
+      }
+    }
+  }
+}
+
+void DirectBufferedInput::readRegion(
+    std::vector<LoadRequest*> requests,
+    bool prefetch) {
+  if (requests.empty() || (requests.size() == 1 && !prefetch)) {
+    return;
+  }
+  auto load = std::make_shared<DirectCoalescedLoad>(
+      input_, ioStats_, groupId_, requests, *pool_, options_.loadQuantum());
+  coalescedLoads_.push_back(load);
+  streamToCoalescedLoad_.withWLock([&](auto& loads) {
+    for (auto& request : requests) {
+      loads[request->stream] = load;
+    }
+  });
+}
+
+std::shared_ptr<DirectCoalescedLoad> DirectBufferedInput::coalescedLoad(
+    const SeekableInputStream* stream) {
+  return streamToCoalescedLoad_.withWLock(
+      [&](auto& loads) -> std::shared_ptr<DirectCoalescedLoad> {
+        auto it = loads.find(stream);
+        if (it == loads.end()) {
+          return nullptr;
+        }
+        auto load = std::move(it->second);
+        loads.erase(it);
+        return load;
+      });
+}
+
+std::unique_ptr<SeekableInputStream> DirectBufferedInput::read(
+    uint64_t offset,
+    uint64_t length,
+    LogType /*logType*/) const {
+  VELOX_CHECK_LE(offset + length, fileSize_);
+  return std::make_unique<DirectInputStream>(
+      const_cast<DirectBufferedInput*>(this),
+      ioStats_.get(),
+      Region{offset, length},
+      input_,
+      fileNum_,
+      nullptr,
+      TrackingId(),
+      0,
+      options_.loadQuantum());
+}
+
+namespace {
+void appendRanges(
+    memory::Allocation& allocation,
+    size_t length,
+    std::vector<folly::Range<char*>>& buffers) {
+  uint64_t offsetInRuns = 0;
+  for (int i = 0; i < allocation.numRuns(); ++i) {
+    auto run = allocation.runAt(i);
+    const uint64_t bytes = memory::AllocationTraits::pageBytes(run.numPages());
+    const uint64_t readSize = std::min(bytes, length - offsetInRuns);
+    buffers.push_back(folly::Range<char*>(run.data<char>(), readSize));
+    offsetInRuns += readSize;
+  }
+}
+} // namespace
+
+std::vector<cache::CachePin> DirectCoalescedLoad::loadData(bool prefetch) {
+  std::vector<folly::Range<char*>> buffers;
+  int64_t lastEnd = requests_[0].region.offset;
+  int64_t size = 0;
+  int64_t overread = 0;
+
+  for (auto& request : requests_) {
+    const auto& region = request.region;
+    if (region.offset > lastEnd) {
+      buffers.push_back(folly::Range<char*>(
+          nullptr,
+          reinterpret_cast<char*>(
+              static_cast<uint64_t>(region.offset - lastEnd))));
+      overread += buffers.back().size();
+    }
+
+    if (region.length > DirectBufferedInput::kTinySize) {
+      if (&request != &requests_.back()) {
+        // Case where request is a little over quantum but is followed by
+        // another within the max distance. Coalesces and allows reading the
+        // region of max quantum + max distance in one piece.
+        request.loadSize = region.length;
+      } else {
+        request.loadSize = std::min<int32_t>(region.length, loadQuantum_);
+      }
+      const auto numPages =
+          memory::AllocationTraits::numPages(request.loadSize);
+      pool_.allocateNonContiguous(numPages, request.data);
+      appendRanges(request.data, request.loadSize, buffers);
+    } else {
+      request.loadSize = region.length;
+      request.tinyData.resize(region.length);
+      buffers.push_back(folly::Range(request.tinyData.data(), region.length));
+    }
+    lastEnd = region.offset + request.loadSize;
+    size += request.loadSize;
+  }
+
+  uint64_t usecs = 0;
+  {
+    MicrosecondTimer timer(&usecs);
+    input_->read(buffers, requests_[0].region.offset, LogType::FILE);
+  }
+
+  ioStats_->read().increment(size + overread);
+  ioStats_->incRawBytesRead(size);
+  ioStats_->incTotalScanTime(usecs * 1'000);
+  ioStats_->queryThreadIoLatency().increment(usecs);
+  ioStats_->incRawOverreadBytes(overread);
+  if (prefetch) {
+    ioStats_->prefetch().increment(size + overread);
+  }
+  return {};
+}
+
+int32_t DirectCoalescedLoad::getData(
+    int64_t offset,
+    memory::Allocation& data,
+    std::string& tinyData) {
+  for (auto& request : requests_) {
+    if (request.region.offset == offset) {
+      data = std::move(request.data);
+      tinyData = std::move(request.tinyData);
+      return request.loadSize;
+    }
+  }
+  return 0;
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/DirectBufferedInput.h b/velox/dwio/common/DirectBufferedInput.h
new file mode 100644
index 0000000000000..561b2d795f595
--- /dev/null
+++ b/velox/dwio/common/DirectBufferedInput.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Executor.h>
+
+#include "velox/common/caching/AsyncDataCache.h"
+#include "velox/common/caching/FileGroupStats.h"
+#include "velox/common/caching/ScanTracker.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/io/Options.h"
+#include "velox/dwio/common/BufferedInput.h"
+#include "velox/dwio/common/CacheInputStream.h"
+#include "velox/dwio/common/InputStream.h"
+
+namespace facebook::velox::dwio::common {
+
+struct LoadRequest {
+  LoadRequest() = default;
+  LoadRequest(velox::common::Region& _region, cache::TrackingId _trackingId)
+      : region(_region), trackingId(_trackingId) {}
+
+  velox::common::Region region;
+  cache::TrackingId trackingId;
+  bool processed{false};
+
+  const SeekableInputStream* stream;
+
+  /// Buffers to be handed to 'stream' after load.
+  memory::Allocation data;
+  std::string tinyData;
+  /// Number of bytes in 'data/tinyData'.
+  int32_t loadSize{0};
+};
+
+/// Represents planned loads that should be performed as a single IO.
+class DirectCoalescedLoad : public cache::CoalescedLoad {
+ public:
+  DirectCoalescedLoad(
+      std::shared_ptr<ReadFileInputStream> input,
+      std::shared_ptr<IoStatistics> ioStats,
+      uint64_t groupId,
+      const std::vector<LoadRequest*>& requests,
+      memory::MemoryPool& pool,
+      int32_t loadQuantum)
+      : CoalescedLoad({}, {}),
+        ioStats_(ioStats),
+        groupId_(groupId),
+        input_(std::move(input)),
+        loadQuantum_(loadQuantum),
+        pool_(pool) {
+    requests_.reserve(requests.size());
+    for (auto i = 0; i < requests.size(); ++i) {
+      requests_.push_back(std::move(*requests[i]));
+    }
+  };
+
+  /// Loads the regions. Returns {} since no cache entries are made. The loaded
+  /// data is retrieved with getData().
+  std::vector<cache::CachePin> loadData(bool prefetch) override;
+
+  /// Returns the buffer for 'region' in either 'data' or 'tinyData'. 'region'
+  /// must match a region given to DirectBufferedInput::enqueue().
+  int32_t
+  getData(int64_t offset, memory::Allocation& data, std::string& tinyData);
+
+  const std::vector<LoadRequest>& requests() {
+    return requests_;
+  }
+
+  int64_t size() const override {
+    int64_t size = 0;
+    for (auto& request : requests_) {
+      size += request.region.length;
+    }
+    return size;
+  }
+
+ private:
+  const std::shared_ptr<IoStatistics> ioStats_;
+  const uint64_t groupId_;
+  const std::shared_ptr<ReadFileInputStream> input_;
+  const int32_t loadQuantum_;
+  memory::MemoryPool& pool_;
+  std::vector<LoadRequest> requests_;
+};
+
+class DirectBufferedInput : public BufferedInput {
+ public:
+  static constexpr int32_t kTinySize = 2'000;
+
+  DirectBufferedInput(
+      std::shared_ptr<ReadFile> readFile,
+      const MetricsLogPtr& metricsLog,
+      uint64_t fileNum,
+      std::shared_ptr<cache::ScanTracker> tracker,
+      uint64_t groupId,
+      std::shared_ptr<IoStatistics> ioStats,
+      folly::Executor* executor,
+      const io::ReaderOptions& readerOptions)
+      : BufferedInput(
+            std::move(readFile),
+            readerOptions.memoryPool(),
+            metricsLog),
+        fileNum_(fileNum),
+        tracker_(std::move(tracker)),
+        groupId_(groupId),
+        ioStats_(std::move(ioStats)),
+        executor_(executor),
+        fileSize_(input_->getLength()),
+        options_(readerOptions) {}
+
+  ~DirectBufferedInput() override {
+    for (auto& load : coalescedLoads_) {
+      load->cancel();
+    }
+  }
+
+  std::unique_ptr<SeekableInputStream> enqueue(
+      velox::common::Region region,
+      const StreamIdentifier* sid) override;
+
+  bool supportSyncLoad() const override {
+    return false;
+  }
+
+  void load(const LogType /*unused*/) override;
+
+  bool isBuffered(uint64_t offset, uint64_t length) const override;
+
+  bool shouldPreload(int32_t numPages = 0) override;
+
+  bool shouldPrefetchStripes() const override {
+    return false;
+  }
+
+  void setNumStripes(int32_t numStripes) override {
+    auto* stats = tracker_->fileGroupStats();
+    if (stats) {
+      stats->recordFile(fileNum_, groupId_, numStripes);
+    }
+  }
+
+  virtual std::unique_ptr<BufferedInput> clone() const override {
+    return std::unique_ptr<DirectBufferedInput>(new DirectBufferedInput(
+        input_, fileNum_, tracker_, groupId_, ioStats_, executor_, options_));
+  }
+
+  memory::MemoryPool* pool() const {
+    return pool_;
+  }
+
+  /// Returns the CoalescedLoad that contains the correlated loads for
+  /// 'stream' or nullptr if none. Returns nullptr on all but first
+  /// call for 'stream' since the load is to be triggered by the first
+  /// access.
+  std::shared_ptr<DirectCoalescedLoad> coalescedLoad(
+      const SeekableInputStream* stream);
+
+  std::unique_ptr<SeekableInputStream>
+  read(uint64_t offset, uint64_t length, LogType logType) const override;
+
+  folly::Executor* executor() const override {
+    return executor_;
+  }
+
+  uint64_t nextFetchSize() const override {
+    VELOX_NYI();
+  }
+
+ private:
+  /// Constructor used by clone().
+  DirectBufferedInput(
+      std::shared_ptr<ReadFileInputStream> input,
+      uint64_t fileNum,
+      std::shared_ptr<cache::ScanTracker> tracker,
+      uint64_t groupId,
+      std::shared_ptr<IoStatistics> ioStats,
+      folly::Executor* executor,
+      const io::ReaderOptions& readerOptions)
+      : BufferedInput(std::move(input), readerOptions.memoryPool()),
+        fileNum_(fileNum),
+        tracker_(std::move(tracker)),
+        groupId_(groupId),
+        ioStats_(std::move(ioStats)),
+        executor_(executor),
+        fileSize_(input_->getLength()),
+        options_(readerOptions) {}
+
+  // Sorts requests and makes CoalescedLoads for nearby requests. If 'prefetch'
+  // is true, starts background loading.
+  void makeLoads(std::vector<LoadRequest*> requests, bool prefetch);
+
+  // Makes a CoalescedLoad for 'requests' to be read together, coalescing IO if
+  // appropriate. If 'prefetch' is set, schedules the CoalescedLoad on
+  // 'executor_'. Links the CoalescedLoad  to all DirectInputStreams that it
+  // covers.
+  void readRegion(std::vector<LoadRequest*> requests, bool prefetch);
+
+  const uint64_t fileNum_;
+  const std::shared_ptr<cache::ScanTracker> tracker_;
+  const uint64_t groupId_;
+  const std::shared_ptr<IoStatistics> ioStats_;
+  folly::Executor* const executor_;
+  const uint64_t fileSize_;
+
+  // Regions that are candidates for loading.
+  std::vector<LoadRequest> requests_;
+
+  // Coalesced loads spanning multiple streams in one IO.
+  folly::Synchronized<folly::F14FastMap<
+      const SeekableInputStream*,
+      std::shared_ptr<DirectCoalescedLoad>>>
+      streamToCoalescedLoad_;
+
+  // Distinct coalesced loads in 'coalescedLoads_'.
+  std::vector<std::shared_ptr<cache::CoalescedLoad>> coalescedLoads_;
+
+  io::ReaderOptions options_;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/DirectDecoder.cpp b/velox/dwio/common/DirectDecoder.cpp
index 8365a5ec21e1c..69a631b2b94d4 100644
--- a/velox/dwio/common/DirectDecoder.cpp
+++ b/velox/dwio/common/DirectDecoder.cpp
@@ -23,10 +23,11 @@ namespace facebook::velox::dwio::common {
 template <bool isSigned>
 void DirectDecoder<isSigned>::seekToRowGroup(
     dwio::common::PositionProvider& location) {
-  // move the input stream
-  IntDecoder<isSigned>::inputStream->seekToPosition(location);
-  // force a re-read from the stream
-  IntDecoder<isSigned>::bufferEnd = IntDecoder<isSigned>::bufferStart;
+  // Moves the input stream.
+  IntDecoder<isSigned>::inputStream_->seekToPosition(location);
+  // Forces a re-read from the stream.
+  IntDecoder<isSigned>::bufferEnd_ = IntDecoder<isSigned>::bufferStart_;
+  this->pendingSkip_ = 0;
 }
 
 template void DirectDecoder<true>::seekToRowGroup(
@@ -34,20 +35,13 @@ template void DirectDecoder<true>::seekToRowGroup(
 template void DirectDecoder<false>::seekToRowGroup(
     dwio::common::PositionProvider& location);
 
-template <bool isSigned>
-void DirectDecoder<isSigned>::skip(uint64_t numValues) {
-  IntDecoder<isSigned>::skipLongs(numValues);
-}
-
-template void DirectDecoder<true>::skip(uint64_t numValues);
-template void DirectDecoder<false>::skip(uint64_t numValues);
-
 template <bool isSigned>
 template <typename T>
 void DirectDecoder<isSigned>::nextValues(
     T* data,
     uint64_t numValues,
     const uint64_t* nulls) {
+  skipPending();
   uint64_t position = 0;
   // skipNulls()
   if (nulls) {
@@ -60,7 +54,7 @@ void DirectDecoder<isSigned>::nextValues(
   // this is gross and very not DRY, but helps avoid branching
   if (position < numValues) {
     if (nulls) {
-      if (!IntDecoder<isSigned>::useVInts) {
+      if (!IntDecoder<isSigned>::useVInts_) {
         if constexpr (std::is_same_v<T, int128_t>) {
           VELOX_NYI();
         }
@@ -77,7 +71,7 @@ void DirectDecoder<isSigned>::nextValues(
         }
       }
     } else {
-      if (!IntDecoder<isSigned>::useVInts) {
+      if (!IntDecoder<isSigned>::useVInts_) {
         if constexpr (std::is_same_v<T, int128_t>) {
           VELOX_NYI();
         }
diff --git a/velox/dwio/common/DirectDecoder.h b/velox/dwio/common/DirectDecoder.h
index 71831eced02fe..644e41348c45b 100644
--- a/velox/dwio/common/DirectDecoder.h
+++ b/velox/dwio/common/DirectDecoder.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include "velox/common/base/Nulls.h"
 #include "velox/dwio/common/DecoderUtil.h"
 #include "velox/dwio/common/IntDecoder.h"
 
@@ -36,40 +35,27 @@ class DirectDecoder : public IntDecoder<isSigned> {
 
   void seekToRowGroup(dwio::common::PositionProvider&) override;
 
-  void skip(uint64_t numValues) override;
+  using IntDecoder<isSigned>::skip;
+
+  void skipPending() final {
+    const auto toSkip = this->pendingSkip_;
+    this->pendingSkip_ = 0;
+    this->skipLongs(toSkip);
+  }
 
   template <typename T>
-  void nextValues(
-      T* FOLLY_NONNULL data,
-      uint64_t numValues,
-      const uint64_t* FOLLY_NULLABLE nulls);
+  void nextValues(T* data, uint64_t numValues, const uint64_t* nulls);
 
-  void next(
-      int64_t* FOLLY_NONNULL data,
-      uint64_t numValues,
-      const uint64_t* FOLLY_NULLABLE nulls) override {
+  void next(int64_t* data, uint64_t numValues, const uint64_t* nulls) override {
     nextValues<int64_t>(data, numValues, nulls);
   }
 
-  template <bool hasNulls>
-  inline void skip(
-      int32_t numValues,
-      int32_t current,
-      const uint64_t* FOLLY_NULLABLE nulls) {
-    if (!numValues) {
-      return;
-    }
-    if (hasNulls) {
-      numValues = bits::countNonNulls(nulls, current, current + numValues);
-    }
-    IntDecoder<isSigned>::skipLongsFast(numValues);
-  }
-
   template <bool hasNulls, typename Visitor>
   void readWithVisitor(
-      const uint64_t* FOLLY_NULLABLE nulls,
+      const uint64_t* nulls,
       Visitor visitor,
       bool useFastPath = true) {
+    skipPending();
     if constexpr (!std::is_same_v<typename Visitor::DataType, int128_t>) {
       if (useFastPath &&
           dwio::common::useFastPath<Visitor, hasNulls>(visitor)) {
@@ -77,8 +63,9 @@ class DirectDecoder : public IntDecoder<isSigned> {
         return;
       }
     }
+
     int32_t current = visitor.start();
-    skip<hasNulls>(current, 0, nulls);
+    this->template skip<hasNulls>(current, 0, nulls);
     const bool allowNulls = hasNulls && visitor.allowNulls();
     for (;;) {
       bool atEnd = false;
@@ -87,7 +74,7 @@ class DirectDecoder : public IntDecoder<isSigned> {
         if (!allowNulls) {
           toSkip = visitor.checkAndSkipNulls(nulls, current, atEnd);
           if (!Visitor::dense) {
-            skip<false>(toSkip, current, nullptr);
+            this->template skip<false>(toSkip, current, nullptr);
           }
           if (atEnd) {
             return;
@@ -110,10 +97,11 @@ class DirectDecoder : public IntDecoder<isSigned> {
       } else {
         toSkip = visitor.process(super::template readInt<int64_t>(), atEnd);
       }
+
     skip:
       ++current;
       if (toSkip) {
-        skip<hasNulls>(toSkip, current, nulls);
+        this->template skip<hasNulls>(toSkip, current, nulls);
         current += toSkip;
       }
       if (atEnd) {
@@ -140,23 +128,24 @@ class DirectDecoder : public IntDecoder<isSigned> {
   // Returns a pointer to the next element of 'size' bytes in the
   // buffer. If the element would straddle buffers, it is copied to
   // *temp and temp is returned.
-  const void* FOLLY_NONNULL readFixed(int32_t size, void* FOLLY_NONNULL temp) {
-    auto ptr = super::bufferStart;
-    if (ptr && ptr + size <= super::bufferEnd) {
-      super::bufferStart += size;
+  const void* readFixed(int32_t size, void* temp) {
+    skipPending();
+    auto ptr = super::bufferStart_;
+    if (ptr && ptr + size <= super::bufferEnd_) {
+      super::bufferStart_ += size;
       return ptr;
     }
     readBytes(
         size,
-        super::inputStream.get(),
+        super::inputStream_.get(),
         temp,
-        super::bufferStart,
-        super::bufferEnd);
+        super::bufferStart_,
+        super::bufferEnd_);
     return temp;
   }
 
   template <bool hasNulls, typename Visitor>
-  void fastPath(const uint64_t* FOLLY_NULLABLE nulls, Visitor& visitor) {
+  void fastPath(const uint64_t* nulls, Visitor& visitor) {
     using T = typename Visitor::DataType;
     constexpr bool hasFilter =
         !std::
@@ -200,18 +189,23 @@ class DirectDecoder : public IntDecoder<isSigned> {
           visitor.setHasNulls();
         }
         if (innerVector->empty()) {
-          skip<false>(tailSkip, 0, nullptr);
+          this->template skip<false>(tailSkip, 0, nullptr);
           visitor.setAllNull(hasFilter ? 0 : numRows);
           return;
         }
       }
-      if (super::useVInts) {
+      if (hasHook && visitor.numValuesBias() > 0) {
+        for (auto& row : *outerVector) {
+          row += visitor.numValuesBias();
+        }
+      }
+      if (super::useVInts_) {
         if (Visitor::dense) {
           super::bulkRead(numNonNull, data);
         } else {
           super::bulkReadRows(*innerVector, data);
         }
-        skip<false>(tailSkip, 0, nullptr);
+        this->template skip<false>(tailSkip, 0, nullptr);
         auto dataRows = innerVector
             ? folly::Range<const int*>(innerVector->data(), innerVector->size())
             : folly::Range<const int32_t*>(rows, outerVector->size());
@@ -234,15 +228,15 @@ class DirectDecoder : public IntDecoder<isSigned> {
             visitor.rawValues(numRows),
             hasFilter ? visitor.outputRows(numRows) : nullptr,
             numValues,
-            *super::inputStream,
-            super::bufferStart,
-            super::bufferEnd,
+            *super::inputStream_,
+            super::bufferStart_,
+            super::bufferEnd_,
             visitor.filter(),
             visitor.hook());
-        skip<false>(tailSkip, 0, nullptr);
+        this->template skip<false>(tailSkip, 0, nullptr);
       }
     } else {
-      if (super::useVInts) {
+      if (super::useVInts_) {
         if (Visitor::dense) {
           super::bulkRead(numRows, visitor.rawValues(numRows));
         } else {
@@ -255,7 +249,10 @@ class DirectDecoder : public IntDecoder<isSigned> {
                 rowsAsRange,
                 0,
                 rowsAsRange.size(),
-                hasHook ? velox::iota(numRows, visitor.innerNonNullRows())
+                hasHook ? velox::iota(
+                              numRows,
+                              visitor.innerNonNullRows(),
+                              visitor.numValuesBias())
                         : nullptr,
                 visitor.rawValues(numRows),
                 hasFilter ? visitor.outputRows(numRows) : nullptr,
@@ -265,14 +262,17 @@ class DirectDecoder : public IntDecoder<isSigned> {
       } else {
         dwio::common::fixedWidthScan<T, filterOnly, false>(
             rowsAsRange,
-            hasHook ? velox::iota(numRows, visitor.innerNonNullRows())
+            hasHook ? velox::iota(
+                          numRows,
+                          visitor.innerNonNullRows(),
+                          visitor.numValuesBias())
                     : nullptr,
             visitor.rawValues(numRows),
             hasFilter ? visitor.outputRows(numRows) : nullptr,
             numValues,
-            *super::inputStream,
-            super::bufferStart,
-            super::bufferEnd,
+            *super::inputStream_,
+            super::bufferStart_,
+            super::bufferEnd_,
             visitor.filter(),
             visitor.hook());
       }
diff --git a/velox/dwio/common/DirectInputStream.cpp b/velox/dwio/common/DirectInputStream.cpp
new file mode 100644
index 0000000000000..3d8c8a13f636c
--- /dev/null
+++ b/velox/dwio/common/DirectInputStream.cpp
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/executors/QueuedImmediateExecutor.h>
+
+#include "velox/common/process/TraceContext.h"
+#include "velox/common/time/Timer.h"
+#include "velox/dwio/common/DirectBufferedInput.h"
+#include "velox/dwio/common/DirectInputStream.h"
+
+using ::facebook::velox::common::Region;
+
+namespace facebook::velox::dwio::common {
+
+using velox::cache::ScanTracker;
+using velox::cache::TrackingId;
+using velox::memory::MemoryAllocator;
+
+DirectInputStream::DirectInputStream(
+    DirectBufferedInput* bufferedInput,
+    IoStatistics* ioStats,
+    const Region& region,
+    std::shared_ptr<ReadFileInputStream> input,
+    uint64_t fileNum,
+    std::shared_ptr<ScanTracker> tracker,
+    TrackingId trackingId,
+    uint64_t groupId,
+    int32_t loadQuantum)
+    : bufferedInput_(bufferedInput),
+      ioStats_(ioStats),
+      input_(std::move(input)),
+      region_(region),
+      fileNum_(fileNum),
+      tracker_(std::move(tracker)),
+      trackingId_(trackingId),
+      groupId_(groupId),
+      loadQuantum_(loadQuantum) {}
+
+bool DirectInputStream::Next(const void** buffer, int32_t* size) {
+  if (offsetInRegion_ >= region_.length) {
+    *size = 0;
+    return false;
+  }
+  loadPosition();
+
+  *buffer = reinterpret_cast<const void**>(run_ + offsetInRun_);
+  *size = runSize_ - offsetInRun_;
+  if (offsetInRegion_ + *size > region_.length) {
+    *size = region_.length - offsetInRegion_;
+  }
+  offsetInRun_ += *size;
+  offsetInRegion_ += *size;
+
+  if (tracker_) {
+    tracker_->recordRead(trackingId_, *size, fileNum_, groupId_);
+  }
+  return true;
+}
+
+void DirectInputStream::BackUp(int32_t count) {
+  VELOX_CHECK_GE(count, 0, "can't backup negative distances");
+
+  const uint64_t unsignedCount = static_cast<uint64_t>(count);
+  VELOX_CHECK_LE(unsignedCount, offsetInRun_, "Can't backup that much!");
+  offsetInRegion_ -= unsignedCount;
+}
+
+bool DirectInputStream::SkipInt64(int64_t count) {
+  if (count < 0) {
+    return false;
+  }
+  const uint64_t unsignedCount = static_cast<uint64_t>(count);
+  if (unsignedCount + offsetInRegion_ <= region_.length) {
+    offsetInRegion_ += unsignedCount;
+    return true;
+  }
+  offsetInRegion_ = region_.length;
+  return false;
+}
+
+google::protobuf::int64 DirectInputStream::ByteCount() const {
+  return static_cast<google::protobuf::int64>(offsetInRegion_);
+}
+
+void DirectInputStream::seekToPosition(PositionProvider& seekPosition) {
+  offsetInRegion_ = seekPosition.next();
+  VELOX_CHECK_LE(offsetInRegion_, region_.length);
+}
+
+std::string DirectInputStream::getName() const {
+  return fmt::format(
+      "DirectInputStream {} of {}", offsetInRegion_, region_.length);
+}
+
+size_t DirectInputStream::positionSize() {
+  // not compressed, so only need 1 position (uncompressed position)
+  return 1;
+}
+
+namespace {
+std::vector<folly::Range<char*>>
+makeRanges(size_t size, memory::Allocation& data, std::string& tinyData) {
+  std::vector<folly::Range<char*>> buffers;
+  if (data.numPages() > 0) {
+    buffers.reserve(data.numRuns());
+    uint64_t offsetInRuns = 0;
+    for (int i = 0; i < data.numRuns(); ++i) {
+      auto run = data.runAt(i);
+      uint64_t bytes = memory::AllocationTraits::pageBytes(run.numPages());
+      uint64_t readSize = std::min(bytes, size - offsetInRuns);
+      buffers.push_back(folly::Range<char*>(run.data<char>(), readSize));
+      offsetInRuns += readSize;
+    }
+  } else {
+    buffers.push_back(folly::Range<char*>(tinyData.data(), size));
+  }
+  return buffers;
+}
+} // namespace
+
+void DirectInputStream::loadSync() {
+  if (region_.length < DirectBufferedInput::kTinySize &&
+      data_.numPages() == 0) {
+    tinyData_.resize(region_.length);
+  } else {
+    const auto numPages =
+        memory::AllocationTraits::numPages(loadedRegion_.length);
+    if (numPages > data_.numPages()) {
+      bufferedInput_->pool()->allocateNonContiguous(numPages, data_);
+    }
+  }
+
+  process::TraceContext trace("DirectInputStream::loadSync");
+
+  ioStats_->incRawBytesRead(loadedRegion_.length);
+  auto ranges = makeRanges(loadedRegion_.length, data_, tinyData_);
+  uint64_t usecs = 0;
+  {
+    MicrosecondTimer timer(&usecs);
+    input_->read(ranges, loadedRegion_.offset, LogType::FILE);
+  }
+  ioStats_->read().increment(loadedRegion_.length);
+  ioStats_->queryThreadIoLatency().increment(usecs);
+  ioStats_->incTotalScanTime(usecs * 1'000);
+}
+
+void DirectInputStream::loadPosition() {
+  VELOX_CHECK_LT(offsetInRegion_, region_.length);
+  if (!loaded_) {
+    loaded_ = true;
+    auto load = bufferedInput_->coalescedLoad(this);
+    if (load != nullptr) {
+      folly::SemiFuture<bool> waitFuture(false);
+      uint64_t loadUs = 0;
+      {
+        MicrosecondTimer timer(&loadUs);
+        if (!load->loadOrFuture(&waitFuture)) {
+          waitFuture.wait();
+        }
+        loadedRegion_.offset = region_.offset;
+        loadedRegion_.length = load->getData(region_.offset, data_, tinyData_);
+      }
+      ioStats_->queryThreadIoLatency().increment(loadUs);
+    } else {
+      // Standalone stream, not part of coalesced load.
+      loadedRegion_.offset = 0;
+      loadedRegion_.length = 0;
+    }
+  }
+
+  // Check if position outside of loaded bounds.
+  if (loadedRegion_.length == 0 ||
+      region_.offset + offsetInRegion_ < loadedRegion_.offset ||
+      region_.offset + offsetInRegion_ >=
+          loadedRegion_.offset + loadedRegion_.length) {
+    loadedRegion_.offset = region_.offset + offsetInRegion_;
+    loadedRegion_.length = (offsetInRegion_ + loadQuantum_ <= region_.length)
+        ? loadQuantum_
+        : (region_.length - offsetInRegion_);
+
+    // Since the loadSync method updates the metric, but it is conditionally
+    // executed, we also need to update the metric in the loadData method.
+    loadSync();
+  }
+
+  const auto offsetInData =
+      offsetInRegion_ - (loadedRegion_.offset - region_.offset);
+  if (data_.numPages() == 0) {
+    run_ = reinterpret_cast<uint8_t*>(tinyData_.data());
+    runSize_ = tinyData_.size();
+    offsetInRun_ = offsetInData;
+    offsetOfRun_ = 0;
+  } else {
+    data_.findRun(offsetInData, &runIndex_, &offsetInRun_);
+    offsetOfRun_ = offsetInData - offsetInRun_;
+    auto run = data_.runAt(runIndex_);
+    run_ = run.data();
+    runSize_ = memory::AllocationTraits::pageBytes(run.numPages());
+    if (offsetOfRun_ + runSize_ > loadedRegion_.length) {
+      runSize_ = loadedRegion_.length - offsetOfRun_;
+    }
+  }
+  VELOX_CHECK_LT(offsetInRun_, runSize_);
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/DirectInputStream.h b/velox/dwio/common/DirectInputStream.h
new file mode 100644
index 0000000000000..3715da6666822
--- /dev/null
+++ b/velox/dwio/common/DirectInputStream.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/caching/FileIds.h"
+#include "velox/common/caching/ScanTracker.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/dwio/common/InputStream.h"
+#include "velox/dwio/common/SeekableInputStream.h"
+
+namespace facebook::velox::dwio::common {
+
+class DirectBufferedInput;
+
+/// An input stream over possibly coalesced loads. Created by
+/// DirectBufferedInput. Similar to CacheInputStream but does not use cache.
+class DirectInputStream : public SeekableInputStream {
+ public:
+  DirectInputStream(
+      DirectBufferedInput* bufferedInput,
+      IoStatistics* ioStats,
+      const velox::common::Region& region,
+      std::shared_ptr<ReadFileInputStream> input,
+      uint64_t fileNum,
+      std::shared_ptr<cache::ScanTracker> tracker,
+      cache::TrackingId trackingId,
+      uint64_t groupId,
+      int32_t loadQuantum);
+
+  bool Next(const void** data, int* size) override;
+  void BackUp(int count) override;
+  bool SkipInt64(int64_t count) override;
+  google::protobuf::int64 ByteCount() const override;
+
+  void seekToPosition(PositionProvider& position) override;
+  std::string getName() const override;
+  size_t positionSize() override;
+
+  /// Testing function to access loaded state.
+  void testingData(
+      velox::common::Region& loadedRegion,
+      memory::Allocation*& data,
+      std::string*& tinyData) {
+    loadedRegion = loadedRegion_;
+    data = &data_;
+    tinyData = &tinyData_;
+  }
+
+ private:
+  // Ensures that the current position is covered by 'data_'.
+  void loadPosition();
+
+  // Synchronously sets 'data_' to cover loadedRegion_'.
+  void loadSync();
+
+  DirectBufferedInput* const bufferedInput_;
+  IoStatistics* const ioStats_;
+  const std::shared_ptr<ReadFileInputStream> input_;
+  // The region of 'input' 'this' ranges over.
+  const velox::common::Region region_;
+  const uint64_t fileNum_;
+  std::shared_ptr<cache::ScanTracker> tracker_;
+  const cache::TrackingId trackingId_;
+  const uint64_t groupId_;
+
+  // Maximum number of bytes read from 'input' at a time.
+  const int32_t loadQuantum_;
+
+  // The part of 'region_' that is loaded into 'data_'/'tinyData_'. Relative to
+  // file start.
+  velox::common::Region loadedRegion_;
+
+  // Allocation with loaded data. Has space for region.length or loadQuantum_
+  // bytes, whichever is less.
+  memory::Allocation data_;
+
+  // Contains the data if the range is too small for Allocation.
+  std::string tinyData_;
+
+  // Pointer  to start of current run in 'entry->data()' or
+  // 'entry->tinyData()'.
+  uint8_t* run_{nullptr};
+
+  // Offset of current run from start of 'data_'
+  uint64_t offsetOfRun_;
+
+  // Position of stream relative to 'run_'.
+  int offsetInRun_{0};
+
+  // Index of run in 'data_'
+  int runIndex_ = -1;
+
+  // Number of valid bytes starting at 'run_'
+  uint32_t runSize_ = 0;
+  // Position relative to 'region_.offset'.
+  uint64_t offsetInRegion_ = 0;
+
+  // Set to true when data is first loaded.
+  bool loaded_{false};
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ExecutorBarrier.cpp b/velox/dwio/common/ExecutorBarrier.cpp
new file mode 100644
index 0000000000000..4d5d106f6dccb
--- /dev/null
+++ b/velox/dwio/common/ExecutorBarrier.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/ExecutorBarrier.h"
+
+namespace facebook::velox::dwio::common {
+
+namespace {
+
+class BarrierElement {
+ public:
+  BarrierElement(size_t& count, std::mutex& mutex, std::condition_variable& cv)
+      : count_{count}, mutex_{&mutex}, cv_{cv} {
+    std::lock_guard lock{*mutex_};
+    ++count_;
+  }
+
+  BarrierElement(BarrierElement&& other) noexcept
+      : count_{other.count_}, mutex_{other.mutex_}, cv_{other.cv_} {
+    // Move away
+    other.mutex_ = nullptr;
+  }
+
+  BarrierElement(const BarrierElement& other) = delete;
+  BarrierElement& operator=(BarrierElement&& other) = delete;
+  BarrierElement& operator=(const BarrierElement& other) = delete;
+
+  ~BarrierElement() {
+    // If this object wasn't moved away
+    if (mutex_) {
+      std::lock_guard lock{*mutex_};
+      if (--count_ == 0) {
+        cv_.notify_all();
+      }
+    }
+  }
+
+ private:
+  size_t& count_;
+  std::mutex* mutex_;
+  std::condition_variable& cv_;
+};
+
+} // namespace
+
+auto ExecutorBarrier::wrapMethod(folly::Func f) {
+  return [f = std::move(f),
+          this,
+          barrierElement = BarrierElement(count_, mutex_, cv_)]() mutable {
+    try {
+      f();
+    } catch (...) {
+      std::lock_guard lock{mutex_};
+      if (!exception_.has_exception_ptr()) {
+        exception_ = folly::exception_wrapper(std::current_exception());
+      }
+    }
+  };
+}
+
+void ExecutorBarrier::add(folly::Func f) {
+  executor_.add(wrapMethod(std::move(f)));
+}
+
+void ExecutorBarrier::addWithPriority(folly::Func f, int8_t priority) {
+  executor_.addWithPriority(wrapMethod(std::move(f)), priority);
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ExecutorBarrier.h b/velox/dwio/common/ExecutorBarrier.h
new file mode 100644
index 0000000000000..c3004ea1e489a
--- /dev/null
+++ b/velox/dwio/common/ExecutorBarrier.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+
+#include "folly/ExceptionWrapper.h"
+#include "folly/Executor.h"
+
+namespace facebook::velox::dwio::common {
+
+class ExecutorBarrier : public folly::Executor {
+ public:
+  explicit ExecutorBarrier(folly::Executor& executor)
+      : executor_{executor}, count_{0} {}
+
+  explicit ExecutorBarrier(std::shared_ptr<folly::Executor> executor)
+      : owned_{std::move(executor)}, executor_{*owned_}, count_{0} {}
+
+  ~ExecutorBarrier() override {
+    // If this object gets destroyed while there are still tasks pending, those
+    // tasks will try to access invalid memory addresses in the current object.
+    std::unique_lock lock{mutex_};
+    cv_.wait(lock, [&]() { return count_ == 0; });
+    // We won't throw from the destructor so we don't check for exceptions
+    // Also, I don't need to clear the exception because this is the destructor.
+  }
+
+  /// Enqueue a function to be executed by this executor. This and all
+  /// variants must be threadsafe.
+  void add(folly::Func) override;
+
+  /// Enqueue a function with a given priority, where 0 is the medium priority
+  /// This is up to the implementation to enforce
+  void addWithPriority(folly::Func, int8_t priority) override;
+
+  uint8_t getNumPriorities() const override {
+    return executor_.getNumPriorities();
+  }
+
+  void waitAll() {
+    std::unique_lock lock{mutex_};
+    cv_.wait(lock, [&]() { return count_ == 0; });
+    if (exception_.has_exception_ptr()) {
+      folly::exception_wrapper ew;
+      // Clear the exception for the next time
+      std::swap(ew, exception_);
+      ew.throw_exception();
+    }
+  }
+
+ private:
+  auto wrapMethod(folly::Func f);
+
+  std::shared_ptr<folly::Executor> owned_;
+  folly::Executor& executor_;
+  size_t count_;
+  std::mutex mutex_;
+  std::condition_variable cv_;
+  folly::exception_wrapper exception_;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/FileSink.cpp b/velox/dwio/common/FileSink.cpp
index 26873abbfc040..cebfe54c3bbf2 100644
--- a/velox/dwio/common/FileSink.cpp
+++ b/velox/dwio/common/FileSink.cpp
@@ -66,13 +66,20 @@ void FileSink::writeImpl(
     std::vector<DataBuffer<char>>& buffers,
     const std::function<uint64_t(const DataBuffer<char>&)>& callback) {
   DWIO_ENSURE(!isClosed(), "Cannot write to closed sink.");
-  uint64_t size = 0;
-  for (auto& buf : buffers) {
-    size += callback(buf);
+  const uint64_t oldSize = size_;
+  uint64_t writeTimeUs{0};
+  {
+    MicrosecondTimer timer(&writeTimeUs);
+    for (auto& buf : buffers) {
+      // NOTE: we need to update 'size_' after each 'callback' invocation as
+      // some file sink implementation like MemorySink depends on the updated
+      // 'size_' for new write.
+      size_ += callback(buf);
+    }
   }
-  size_ += size;
   if (stats_ != nullptr) {
-    stats_->incRawBytesWritten(size);
+    stats_->incRawBytesWritten(size_ - oldSize);
+    stats_->incWriteIOTimeUs(writeTimeUs);
   }
   // Writing buffer is treated as transferring ownership. So clearing the
   // buffers after all buffers are written.
@@ -184,8 +191,7 @@ MemorySink::MemorySink(size_t capacity, const Options& options)
 void MemorySink::write(std::vector<DataBuffer<char>>& buffers) {
   writeImpl(buffers, [&](auto& buffer) {
     const auto size = buffer.size();
-    DWIO_ENSURE_LE(size_ + size, data_.capacity());
-    ::memcpy(data_.data() + size_, buffer.data(), size);
+    data_.extendAppend(size_, buffer.data(), size);
     return size;
   });
 }
diff --git a/velox/dwio/common/FileSink.h b/velox/dwio/common/FileSink.h
index f37120a284d52..fd9fec9fa8602 100644
--- a/velox/dwio/common/FileSink.h
+++ b/velox/dwio/common/FileSink.h
@@ -18,16 +18,13 @@
 
 #include <chrono>
 
+#include "velox/common/config/Config.h"
 #include "velox/common/file/File.h"
 #include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/Closeable.h"
 #include "velox/dwio/common/DataBuffer.h"
 #include "velox/dwio/common/MetricsLog.h"
 
-namespace facebook::velox {
-class Config;
-}
-
 namespace facebook::velox::dwio::common {
 using namespace facebook::velox::io;
 
@@ -40,7 +37,12 @@ class FileSink : public Closeable {
     bool bufferWrite{true};
     /// Connector properties are required to create a FileSink on FileSystems
     /// such as S3.
-    const std::shared_ptr<const Config>& connectorProperties{nullptr};
+    const std::shared_ptr<const config::ConfigBase>& connectorProperties{
+        nullptr};
+    /// Config used to create sink files. This config is provided to underlying
+    /// file system and the config is free form. The form should be defined by
+    /// the underlying file system.
+    const std::string fileCreateConfig{""};
     memory::MemoryPool* pool{nullptr};
     MetricsLogPtr metricLogger{MetricsLog::voidLog()};
     IoStatistics* stats{nullptr};
@@ -107,7 +109,7 @@ class FileSink : public Closeable {
       const std::function<uint64_t(const DataBuffer<char>&)>& callback);
 
   const std::string name_;
-  const std::shared_ptr<const Config> connectorProperties_;
+  const std::shared_ptr<const config::ConfigBase> connectorProperties_;
   memory::MemoryPool* const pool_;
   const MetricsLogPtr metricLogger_;
   IoStatistics* const stats_;
@@ -152,10 +154,6 @@ class WriteFileSink final : public FileSink {
 class LocalFileSink : public FileSink {
  public:
   LocalFileSink(const std::string& name, const Options& options);
-#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-  LocalFileSink(const std::string& name, MetricsLogPtr metricLogger)
-      : LocalFileSink(name, {.metricLogger = std::move(metricLogger)}) {}
-#endif
 
   ~LocalFileSink() override {
     destroy();
diff --git a/velox/dwio/common/FilterNode.h b/velox/dwio/common/FilterNode.h
index dd4696d3ae86e..5aafd0964e283 100644
--- a/velox/dwio/common/FilterNode.h
+++ b/velox/dwio/common/FilterNode.h
@@ -102,14 +102,14 @@ struct FilterNode {
     return name == other.name;
   }
 
-  bool match(const std::string_view& name) const {
+  bool match(const std::string_view& name_to_match_2) const {
     // no match if any is invalid
     if (!valid()) {
       // even current is invlaid
       return false;
     }
 
-    return this->name == name;
+    return name == name_to_match_2;
   }
 
   // expect the incoming list has all valid nodes
@@ -117,8 +117,8 @@ struct FilterNode {
   std::vector<FilterNode>::const_iterator in(
       const std::vector<FilterNode>& list) const {
     return std::find_if(
-        list.cbegin(), list.cend(), [this](const FilterNode& node) {
-          return node.match(*this);
+        list.cbegin(), list.cend(), [this](const FilterNode& filter_node_2) {
+          return filter_node_2.match(*this);
         });
   }
 
@@ -155,21 +155,6 @@ using ColumnFilter = std::vector<velox::dwio::common::FilterNode>;
 class FilterType;
 using FilterTypePtr = std::shared_ptr<FilterType>;
 class FilterType {
- private:
-  const FilterNode node_;
-  const std::weak_ptr<FilterType> parent_;
-  std::vector<FilterTypePtr> children_;
-  // a flat to decide if current node is needed
-  bool read_;
-  // a flag to indicate if current node is in content
-  bool inContent_;
-  // request type in the filter tree node
-  std::shared_ptr<const velox::Type> requestType_;
-  // data type in the filter tree node
-  std::shared_ptr<const velox::Type> dataType_;
-  // sequence filter for given node - empty if no filter
-  SeqFilter seqFilter_;
-
  public:
   // a single value indicating not found (invalid node)
   static const FilterTypePtr& getInvalid() {
@@ -191,7 +176,7 @@ class FilterType {
         read_{node.node == 0},
         inContent_{inContent},
         requestType_{std::move(type)},
-        dataType_{std::move(contentType)},
+        fileType_{std::move(contentType)},
         seqFilter_{std::make_shared<std::unordered_set<size_t>>()} {}
 
   FilterType(
@@ -214,7 +199,6 @@ class FilterType {
     return node_;
   }
 
- public:
   inline void setRead() {
     read_ = true;
   }
@@ -236,11 +220,11 @@ class FilterType {
   }
 
   inline const std::shared_ptr<const velox::Type>& getDataType() const {
-    return dataType_;
+    return fileType_;
   }
 
-  inline void setDataType(const std::shared_ptr<const velox::Type>& dataType) {
-    dataType_ = dataType;
+  inline void setDataType(const std::shared_ptr<const velox::Type>& fileType) {
+    fileType_ = fileType;
   }
 
   inline bool valid() const {
@@ -256,10 +240,10 @@ class FilterType {
     return requestType_->kind();
   }
 
-  // return node ID in the type tree
+  /// Returns node ID in the type tree
   inline uint64_t getId() const {
     // Cannot get ID for invalid node
-    DWIO_ENSURE_EQ(valid(), true);
+    VELOX_CHECK(valid());
     return node_.node;
   }
 
@@ -267,8 +251,8 @@ class FilterType {
     return node_.node == 0;
   }
 
-  inline void addChild(const FilterTypePtr& child) {
-    children_.push_back(child);
+  inline void addChild(FilterTypePtr child) {
+    children_.push_back(std::move(child));
   }
 
   inline void setSequenceFilter(const SeqFilter& seqFilter) {
@@ -287,6 +271,21 @@ class FilterType {
     return seqFilter_->empty() ||
         seqFilter_->find(sequence) != seqFilter_->end();
   }
+
+ private:
+  const FilterNode node_;
+  const std::weak_ptr<FilterType> parent_;
+  std::vector<FilterTypePtr> children_;
+  // a flat to decide if current node is needed
+  bool read_;
+  // a flag to indicate if current node is in content
+  bool inContent_;
+  // request type in the filter tree node
+  std::shared_ptr<const velox::Type> requestType_;
+  // data type in the filter tree node
+  std::shared_ptr<const velox::Type> fileType_;
+  // sequence filter for given node - empty if no filter
+  SeqFilter seqFilter_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/FlatMapHelper.cpp b/velox/dwio/common/FlatMapHelper.cpp
index 7abc8ee3ac6b9..8f97779efc206 100644
--- a/velox/dwio/common/FlatMapHelper.cpp
+++ b/velox/dwio/common/FlatMapHelper.cpp
@@ -43,6 +43,7 @@ void reset(VectorPtr& vector, vector_size_t size, bool hasNulls) {
 
 void initializeStringVector(
     VectorPtr& vector,
+    const TypePtr& type,
     memory::MemoryPool& pool,
     const std::vector<const BaseVector*>& vectors) {
   vector_size_t size = 0;
@@ -64,7 +65,7 @@ void initializeStringVector(
     }
   }
   initializeFlatVector<StringView>(
-      vector, pool, VARCHAR(), size, hasNulls, std::move(buffers));
+      vector, pool, type, size, hasNulls, std::move(buffers));
 }
 
 } // namespace detail
@@ -103,19 +104,19 @@ void initializeVectorImpl(
 template <>
 void initializeVectorImpl<TypeKind::VARCHAR>(
     VectorPtr& vector,
-    const TypePtr& /* type */,
+    const TypePtr& type,
     memory::MemoryPool& pool,
     const std::vector<const BaseVector*>& vectors) {
-  detail::initializeStringVector(vector, pool, vectors);
+  detail::initializeStringVector(vector, type, pool, vectors);
 }
 
 template <>
 void initializeVectorImpl<TypeKind::VARBINARY>(
     VectorPtr& vector,
-    const TypePtr& /* type */,
+    const TypePtr& type,
     memory::MemoryPool& pool,
     const std::vector<const BaseVector*>& vectors) {
-  detail::initializeStringVector(vector, pool, vectors);
+  detail::initializeStringVector(vector, type, pool, vectors);
 }
 
 namespace {
diff --git a/velox/dwio/common/FlatMapHelper.h b/velox/dwio/common/FlatMapHelper.h
index ad67f12aeade4..ac97b5c3b1347 100644
--- a/velox/dwio/common/FlatMapHelper.h
+++ b/velox/dwio/common/FlatMapHelper.h
@@ -37,14 +37,6 @@ void resetIfNotWritable(VectorPtr& vector, const T&... buffer) {
   FOLLY_POP_WARNING
 }
 
-// Initialize string vector.
-void initializeStringVector(
-    VectorPtr& vector,
-    memory::MemoryPool& pool,
-    vector_size_t size,
-    bool hasNulls,
-    std::vector<BufferPtr>&& stringBuffers);
-
 } // namespace detail
 
 // Struct for keeping track flatmap key stream metrics.
diff --git a/velox/dwio/common/FormatData.h b/velox/dwio/common/FormatData.h
index 369e899effcfe..bff3c420bc507 100644
--- a/velox/dwio/common/FormatData.h
+++ b/velox/dwio/common/FormatData.h
@@ -17,9 +17,8 @@
 #pragma once
 
 #include "velox/common/memory/Memory.h"
-#include "velox/dwio/common/ColumnSelector.h"
+#include "velox/dwio/common/PositionProvider.h"
 #include "velox/dwio/common/ScanSpec.h"
-#include "velox/dwio/common/SeekableInputStream.h"
 #include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/common/TypeWithId.h"
 #include "velox/type/Filter.h"
@@ -34,14 +33,14 @@ class FormatData {
 
   template <typename T>
   T& as() {
-    return *reinterpret_cast<T*>(this);
+    return *static_cast<T*>(this);
   }
 
   /// Reads nulls if the format has nulls separate from the encoded
   /// data. If there are no nulls, 'nulls' is set to nullptr, else to
   /// a suitable sized and padded Buffer. 'incomingNulls' may be given
   /// if there are enclosing level nulls that should be merged into
-  /// the read reasult. If provided, this has 'numValues' bits and
+  /// the read result. If provided, this has 'numValues' bits and
   /// each zero marks an incoming null for which no bit is read from
   /// the nulls stream of 'this'. For Parquet, 'nulls' is always set
   /// to nullptr because nulls are represented by the data pages
@@ -51,7 +50,7 @@ class FormatData {
   /// of a column are of interest, e.g. is null filter.
   virtual void readNulls(
       vector_size_t numValues,
-      const uint64_t* FOLLY_NULLABLE incomingNulls,
+      const uint64_t* incomingNulls,
       BufferPtr& nulls,
       bool nullsOnly = false) = 0;
 
diff --git a/velox/dwio/common/InputStream.cpp b/velox/dwio/common/InputStream.cpp
index afd76c7cb6add..e2dd496c16d88 100644
--- a/velox/dwio/common/InputStream.cpp
+++ b/velox/dwio/common/InputStream.cpp
@@ -16,15 +16,10 @@
 
 #include "velox/dwio/common/InputStream.h"
 
-#include <fcntl.h>
 #include <folly/container/F14Map.h>
 #include <gflags/gflags.h>
 #include <glog/logging.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <cerrno>
 #include <cstdint>
-#include <cstring>
 #include <functional>
 #include <istream>
 #include <numeric>
@@ -39,6 +34,16 @@ using ::facebook::velox::common::Region;
 
 namespace facebook::velox::dwio::common {
 
+namespace {
+int64_t totalBufferSize(const std::vector<folly::Range<char*>>& buffers) {
+  int64_t bufferSize = 0;
+  for (auto& buffer : buffers) {
+    bufferSize += buffer.size();
+  }
+  return bufferSize;
+}
+} // namespace
+
 folly::SemiFuture<uint64_t> InputStream::readAsync(
     const std::vector<folly::Range<char*>>& buffers,
     uint64_t offset,
@@ -67,50 +72,43 @@ void ReadFileInputStream::read(
     uint64_t length,
     uint64_t offset,
     MetricsLog::MetricsType purpose) {
-  if (!buf) {
-    throw std::invalid_argument("Buffer is null");
-  }
+  VELOX_CHECK_NOT_NULL(buf);
   logRead(offset, length, purpose);
-  auto readStartMicros = getCurrentTimeMicro();
-  std::string_view data_read = readFile_->pread(offset, length, buf);
+  uint64_t readTimeUs{0};
+  std::string_view readData;
+  {
+    MicrosecondTimer timer(&readTimeUs);
+    readData = readFile_->pread(offset, length, buf);
+  }
   if (stats_) {
     stats_->incRawBytesRead(length);
-    stats_->incTotalScanTime((getCurrentTimeMicro() - readStartMicros) * 1000);
+    stats_->incTotalScanTime(readTimeUs * 1'000);
   }
 
-  DWIO_ENSURE_EQ(
-      data_read.size(),
+  VELOX_CHECK_EQ(
+      readData.size(),
       length,
-      "Should read exactly as requested. File name: ",
+      "Should read exactly as requested. File name: {}, offset: {}, length: {}, read: {}",
       getName(),
-      ", offset: ",
       offset,
-      ", length: ",
       length,
-      ", read: ",
-      data_read.size());
+      readData.size());
 }
 
 void ReadFileInputStream::read(
     const std::vector<folly::Range<char*>>& buffers,
     uint64_t offset,
     LogType logType) {
-  int64_t bufferSize = 0;
-  for (auto& buffer : buffers) {
-    bufferSize += buffer.size();
-  }
+  const int64_t bufferSize = totalBufferSize(buffers);
   logRead(offset, bufferSize, logType);
-  auto size = readFile_->preadv(offset, buffers);
-  DWIO_ENSURE_EQ(
+  const auto size = readFile_->preadv(offset, buffers);
+  VELOX_CHECK_EQ(
       size,
       bufferSize,
-      "Should read exactly as requested. File name: ",
+      "Should read exactly as requested. File name: {}, offset: {}, length: {}, read: {}",
       getName(),
-      ", offset: ",
       offset,
-      ", length: ",
       bufferSize,
-      ", read: ",
       size);
 }
 
@@ -118,10 +116,7 @@ folly::SemiFuture<uint64_t> ReadFileInputStream::readAsync(
     const std::vector<folly::Range<char*>>& buffers,
     uint64_t offset,
     LogType logType) {
-  int64_t bufferSize = 0;
-  for (auto& buffer : buffers) {
-    bufferSize += buffer.size();
-  }
+  const int64_t bufferSize = totalBufferSize(buffers);
   logRead(offset, bufferSize, logType);
   return readFile_->preadvAsync(offset, buffers);
 }
@@ -134,18 +129,18 @@ void ReadFileInputStream::vread(
     folly::Range<const velox::common::Region*> regions,
     folly::Range<folly::IOBuf*> iobufs,
     const LogType purpose) {
-  DWIO_ENSURE_GT(regions.size(), 0, "regions to read can't be empty");
+  VELOX_CHECK_GT(regions.size(), 0, "regions to read can't be empty");
   const size_t length = std::accumulate(
       regions.cbegin(),
       regions.cend(),
       size_t(0),
       [&](size_t acc, const auto& r) { return acc + r.length; });
   logRead(regions[0].offset, length, purpose);
-  auto readStartMs = getCurrentTimeMs();
+  auto readStartMicros = getCurrentTimeMicro();
   readFile_->preadv(regions, iobufs);
   if (stats_) {
     stats_->incRawBytesRead(length);
-    stats_->incTotalScanTime(getCurrentTimeMs() - readStartMs);
+    stats_->incTotalScanTime((getCurrentTimeMicro() - readStartMicros) * 1000);
   }
 }
 
diff --git a/velox/dwio/common/InputStream.h b/velox/dwio/common/InputStream.h
index 4c1753cdc7f04..19bf4dcccda0e 100644
--- a/velox/dwio/common/InputStream.h
+++ b/velox/dwio/common/InputStream.h
@@ -46,7 +46,7 @@ class InputStream {
   explicit InputStream(
       const std::string& path,
       const MetricsLogPtr& metricsLog = MetricsLog::voidLog(),
-      IoStatistics* FOLLY_NULLABLE stats = nullptr)
+      IoStatistics* stats = nullptr)
       : path_{path}, metricsLog_{metricsLog}, stats_(stats) {}
 
   virtual ~InputStream() = default;
@@ -54,7 +54,7 @@ class InputStream {
   /**
    * Get the stats object
    */
-  IoStatistics* FOLLY_NULLABLE getStats() const {
+  IoStatistics* getStats() const {
     return stats_;
   }
 
@@ -76,7 +76,7 @@ class InputStream {
    * @param length the number of bytes to read.
    * @param offset the position in the stream to read from.
    */
-  virtual void read(void* FOLLY_NONNULL, uint64_t, uint64_t, LogType) = 0;
+  virtual void read(void*, uint64_t, uint64_t, LogType) = 0;
 
   /**
    * Read starting at offset into buffers, filling the buffers left to right. A
@@ -124,9 +124,6 @@ class InputStream {
       folly::Range<folly::IOBuf*> iobufs,
       const LogType purpose) = 0;
 
-  // case insensitive find
-  static uint32_t ifind(const std::string& src, const std::string& target);
-
   const std::string& getName() const;
 
   virtual void logRead(uint64_t offset, uint64_t length, LogType purpose);
@@ -134,19 +131,19 @@ class InputStream {
  protected:
   std::string path_;
   MetricsLogPtr metricsLog_;
-  IoStatistics* FOLLY_NULLABLE stats_;
+  IoStatistics* stats_;
 };
 
-// An input stream that reads from an already opened ReadFile.
+/// An input stream that reads from an already opened ReadFile.
 class ReadFileInputStream final : public InputStream {
  public:
-  // Take shared ownership of |readFile|.
+  /// Takes shared ownership of |readFile|.
   explicit ReadFileInputStream(
       std::shared_ptr<velox::ReadFile>,
       const MetricsLogPtr& metricsLog = MetricsLog::voidLog(),
-      IoStatistics* FOLLY_NULLABLE stats = nullptr);
+      IoStatistics* stats = nullptr);
 
-  virtual ~ReadFileInputStream() {}
+  ~ReadFileInputStream() override = default;
 
   uint64_t getLength() const final override {
     return readFile_->size();
@@ -156,7 +153,7 @@ class ReadFileInputStream final : public InputStream {
     return readFile_->getNaturalReadSize();
   }
 
-  void read(void* FOLLY_NONNULL, uint64_t, uint64_t, LogType) override;
+  void read(void*, uint64_t, uint64_t, LogType) override;
 
   void read(
       const std::vector<folly::Range<char*>>& buffers,
diff --git a/velox/dwio/common/IntDecoder.cpp b/velox/dwio/common/IntDecoder.cpp
index a8e1243ca339c..9ee24dd7cf77c 100644
--- a/velox/dwio/common/IntDecoder.cpp
+++ b/velox/dwio/common/IntDecoder.cpp
@@ -30,21 +30,23 @@ FOLLY_ALWAYS_INLINE void IntDecoder<isSigned>::skipVarints(uint64_t items) {
 template <bool isSigned>
 FOLLY_ALWAYS_INLINE uint64_t
 IntDecoder<isSigned>::skipVarintsInBuffer(uint64_t items) {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
   static constexpr uint64_t kVarintMask = 0x8080808080808080L;
-  if (bufferStart == bufferEnd) {
+  if (bufferStart_ == bufferEnd_) {
     const void* bufferPointer;
     int32_t size;
-    if (!inputStream->Next(&bufferPointer, &size)) {
-      VELOX_CHECK(false, "Skipping past end of strean");
+    if (!inputStream_->Next(&bufferPointer, &size)) {
+      VELOX_FAIL("Skipping past end of strean");
     }
-    bufferStart = static_cast<const char*>(bufferPointer);
-    bufferEnd = bufferStart + size;
+    bufferStart_ = static_cast<const char*>(bufferPointer);
+    bufferEnd_ = bufferStart_ + size;
   }
+
   uint64_t toSkip = items;
-  while (bufferEnd - bufferStart >= sizeof(uint64_t)) {
+  while (bufferEnd_ - bufferStart_ >= sizeof(uint64_t)) {
     uint64_t controlBits =
-        (~*reinterpret_cast<const uint64_t*>(bufferStart) & kVarintMask);
-    auto endCount = __builtin_popcountll(controlBits);
+        (~*reinterpret_cast<const uint64_t*>(bufferStart_) & kVarintMask);
+    const auto endCount = __builtin_popcountll(controlBits);
     if (endCount >= toSkip) {
       // The range to skip ends within 'word'. Clear all but the
       // last end marker bits and count trailing zeros to see what
@@ -52,71 +54,74 @@ IntDecoder<isSigned>::skipVarintsInBuffer(uint64_t items) {
       for (int32_t i = 1; i < toSkip; ++i) {
         controlBits &= controlBits - 1;
       }
-      auto zeros = __builtin_ctzll(controlBits);
-      bufferStart += (zeros + 1) / 8;
+      const auto tailingZeros = __builtin_ctzll(controlBits);
+      bufferStart_ += (tailingZeros + 1) / 8;
       return items;
     }
     toSkip -= endCount;
-    bufferStart += sizeof(uint64_t);
+    bufferStart_ += sizeof(uint64_t);
   }
 
-  while (toSkip && bufferEnd > bufferStart) {
-    if ((*reinterpret_cast<const uint8_t*>(bufferStart) & 0x80) == 0) {
+  while ((toSkip > 0) && bufferEnd_ > bufferStart_) {
+    if ((*reinterpret_cast<const uint8_t*>(bufferStart_) & 0x80) == 0) {
       --toSkip;
     }
-    ++bufferStart;
+    ++bufferStart_;
   }
   return items - toSkip;
 }
 
 template <bool isSigned>
-void IntDecoder<isSigned>::skipLongsFast(uint64_t numValues) {
-  if (useVInts) {
+void IntDecoder<isSigned>::skipLongs(uint64_t numValues) {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
+  if (useVInts_) {
     skipVarints(numValues);
   } else {
-    skipBytes(numValues * numBytes, inputStream.get(), bufferStart, bufferEnd);
+    skipBytes(
+        numValues * numBytes_, inputStream_.get(), bufferStart_, bufferEnd_);
   }
 }
 
-template void IntDecoder<true>::skipLongsFast(uint64_t numValues);
-template void IntDecoder<false>::skipLongsFast(uint64_t numValues);
+template void IntDecoder<true>::skipLongs(uint64_t numValues);
+template void IntDecoder<false>::skipLongs(uint64_t numValues);
 
 template <bool isSigned>
 template <typename T>
 void IntDecoder<isSigned>::bulkReadFixed(uint64_t size, T* result) {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
   if (isSigned) {
-    switch (numBytes) {
+    switch (numBytes_) {
       case 2:
         dwio::common::readContiguous<int16_t>(
-            size, *inputStream, result, bufferStart, bufferEnd);
+            size, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       case 4:
         dwio::common::readContiguous<int32_t>(
-            size, *inputStream, result, bufferStart, bufferEnd);
+            size, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       case 8:
         dwio::common::readContiguous<int64_t>(
-            size, *inputStream, result, bufferStart, bufferEnd);
+            size, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       default:
-        VELOX_FAIL("Bad fixed width {}", numBytes);
+        VELOX_FAIL("Bad fixed width {}", numBytes_);
     }
   } else {
-    switch (numBytes) {
+    switch (numBytes_) {
       case 2:
         dwio::common::readContiguous<uint16_t>(
-            size, *inputStream, result, bufferStart, bufferEnd);
+            size, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       case 4:
         dwio::common::readContiguous<uint32_t>(
-            size, *inputStream, result, bufferStart, bufferEnd);
+            size, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       case 8:
         dwio::common::readContiguous<uint64_t>(
-            size, *inputStream, result, bufferStart, bufferEnd);
+            size, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       default:
-        VELOX_FAIL("Bad fixed width {}", numBytes);
+        VELOX_FAIL("Bad fixed width {}", numBytes_);
     }
   }
 }
@@ -127,39 +132,40 @@ void IntDecoder<isSigned>::bulkReadRowsFixed(
     RowSet rows,
     int32_t initialRow,
     T* result) {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
   if (isSigned) {
-    switch (numBytes) {
+    switch (numBytes_) {
       case 2:
         dwio::common::readRows<int16_t>(
-            rows, initialRow, *inputStream, result, bufferStart, bufferEnd);
+            rows, initialRow, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       case 4:
         dwio::common::readRows<int32_t>(
-            rows, initialRow, *inputStream, result, bufferStart, bufferEnd);
+            rows, initialRow, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       case 8:
         dwio::common::readRows<int64_t>(
-            rows, initialRow, *inputStream, result, bufferStart, bufferEnd);
+            rows, initialRow, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       default:
-        VELOX_FAIL("Bad fixed width {}", numBytes);
+        VELOX_FAIL("Bad fixed width {}", numBytes_);
     }
   } else {
-    switch (numBytes) {
+    switch (numBytes_) {
       case 2:
         dwio::common::readRows<uint16_t>(
-            rows, initialRow, *inputStream, result, bufferStart, bufferEnd);
+            rows, initialRow, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       case 4:
         dwio::common::readRows<uint32_t>(
-            rows, initialRow, *inputStream, result, bufferStart, bufferEnd);
+            rows, initialRow, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       case 8:
         dwio::common::readRows<uint64_t>(
-            rows, initialRow, *inputStream, result, bufferStart, bufferEnd);
+            rows, initialRow, *inputStream_, result, bufferStart_, bufferEnd_);
         break;
       default:
-        VELOX_FAIL("Bad fixed width {}", numBytes);
+        VELOX_FAIL("Bad fixed width {}", numBytes_);
     }
   }
 }
@@ -915,7 +921,8 @@ FOLLY_ALWAYS_INLINE void varintSwitch(
 template <bool isSigned>
 template <typename T>
 void IntDecoder<isSigned>::bulkRead(uint64_t size, T* result) {
-  if (!useVInts) {
+  skipPending();
+  if (!useVInts_) {
     bulkReadFixed(size, result);
     return;
   }
@@ -924,14 +931,14 @@ void IntDecoder<isSigned>::bulkRead(uint64_t size, T* result) {
   uint64_t carryover = 0;
   int32_t carryoverBits = 0;
   auto output = result;
-  const char* pos = bufferStart;
+  const char* pos = bufferStart_;
   auto end = result + size;
   if (pos) {
     // Decrement only if non-null to avoid asan error.
     pos -= maskSize;
   }
   while (output < end) {
-    while (end >= output + 8 && bufferEnd - pos >= 8 + maskSize) {
+    while (end >= output + 8 && bufferEnd_ - pos >= 8 + maskSize) {
       pos += maskSize;
       const auto word = folly::loadUnaligned<uint64_t>(pos);
       const uint64_t controlBits = bits::extractBits<uint64_t>(word, mask);
@@ -940,16 +947,16 @@ void IntDecoder<isSigned>::bulkRead(uint64_t size, T* result) {
     if (pos) {
       pos += maskSize;
     }
-    bufferStart = pos;
+    bufferStart_ = pos;
     if (output < end) {
       *output++ = (readVuLong() << carryoverBits) | carryover;
       carryover = 0;
       carryoverBits = 0;
       while (output < end) {
         *output++ = readVuLong();
-        if (output + 8 <= end && bufferEnd - bufferStart > 8 + maskSize) {
+        if (output + 8 <= end && bufferEnd_ - bufferStart_ > 8 + maskSize) {
           // Go back to fast loop after refilling the buffer.
-          pos = bufferStart - maskSize;
+          pos = bufferStart_ - maskSize;
           break;
         }
       }
@@ -966,7 +973,8 @@ void IntDecoder<isSigned>::bulkReadRows(
     RowSet rows,
     T* result,
     int32_t initialRow) {
-  if (!useVInts) {
+  skipPending();
+  if (!useVInts_) {
     bulkReadRowsFixed(rows, initialRow, result);
     return;
   }
@@ -975,7 +983,7 @@ void IntDecoder<isSigned>::bulkReadRows(
   uint64_t carryover = 0;
   int32_t carryoverBits = 0;
   auto output = result;
-  const char* pos = bufferStart;
+  const char* pos = bufferStart_;
   int32_t nextRowIndex = 0;
   int32_t nextRow = rows[0];
   int32_t row = initialRow;
@@ -986,7 +994,7 @@ void IntDecoder<isSigned>::bulkReadRows(
     pos -= maskSize;
   }
   while (nextRowIndex < rows.size()) {
-    while (row + 8 <= endRow && bufferEnd - pos >= 8 + maskSize) {
+    while (row + 8 <= endRow && bufferEnd_ - pos >= 8 + maskSize) {
       pos += maskSize;
       const auto word = folly::loadUnaligned<uint64_t>(pos);
       if (nextRow >= row + 8) {
@@ -2305,7 +2313,7 @@ void IntDecoder<isSigned>::bulkReadRows(
     if (pos) {
       pos += maskSize;
     }
-    bufferStart = pos;
+    bufferStart_ = pos;
     DCHECK(!carryover || row == nextRow);
     while (nextRowIndex < endRowIndex) {
       skipVarints(nextRow - row);
@@ -2317,9 +2325,9 @@ void IntDecoder<isSigned>::bulkReadRows(
       }
       row = nextRow + 1;
       nextRow = rows[nextRowIndex];
-      if (endRow - row >= 8 && bufferEnd - bufferStart > 8 + maskSize) {
+      if (endRow - row >= 8 && bufferEnd_ - bufferStart_ > 8 + maskSize) {
         // Go back to fast loop after refilling the buffer.
-        pos = bufferStart - maskSize;
+        pos = bufferStart_ - maskSize;
         break;
       }
     }
diff --git a/velox/dwio/common/IntDecoder.h b/velox/dwio/common/IntDecoder.h
index 118bde04280cd..016e8b1f8244d 100644
--- a/velox/dwio/common/IntDecoder.h
+++ b/velox/dwio/common/IntDecoder.h
@@ -19,6 +19,7 @@
 #include <folly/Likely.h>
 #include <folly/Range.h>
 #include <folly/Varint.h>
+#include "velox/common/base/Nulls.h"
 #include "velox/common/encode/Coding.h"
 #include "velox/dwio/common/IntCodecCommon.h"
 #include "velox/dwio/common/SeekableInputStream.h"
@@ -38,46 +39,43 @@ class IntDecoder {
       bool useVInts,
       uint32_t numBytes,
       bool bigEndian = false)
-      : inputStream(std::move(input)),
-        bufferStart(nullptr),
-        bufferEnd(bufferStart),
-        useVInts(useVInts),
-        numBytes(numBytes),
-        bigEndian(bigEndian) {}
+      : inputStream_(std::move(input)),
+        bufferStart_(nullptr),
+        bufferEnd_(bufferStart_),
+        useVInts_(useVInts),
+        numBytes_(numBytes),
+        bigEndian_(bigEndian) {}
 
-  // Constructs for use in Parquet /Alphawhere the buffer is always preloaded.
-  IntDecoder(const char* FOLLY_NONNULL start, const char* FOLLY_NONNULL end)
-      : bufferStart(start), bufferEnd(end), useVInts(false), numBytes(0) {}
+  /// Constructs for use in Parquet /Alphawhere the buffer is always preloaded.
+  IntDecoder(const char* start, const char* end)
+      : bufferStart_(start), bufferEnd_(end), useVInts_(false), numBytes_(0) {}
 
   virtual ~IntDecoder() = default;
 
-  /**
-   * Seek to a specific row group.
-   */
+  /// Seeks to a specific row group.  Should not read the underlying input
+  /// stream to avoid decoding same data multiple times.
   virtual void seekToRowGroup(
       dwio::common::PositionProvider& positionProvider) = 0;
 
-  /**
-   * Seek over a given number of values.
-   */
-  virtual void skip(uint64_t numValues) = 0;
+  /// Seeks over a given number of values.  Does not decode the underlying input
+  /// stream.
+  void skip(uint64_t numValues) {
+    pendingSkip_ += numValues;
+  }
 
   /**
-   * Read a number of values into the batch.
+   * Read a number of values into the batch.  Should call skipPending() in the
+   * beginning.
+   *
    * @param data the array to read into
    * @param numValues the number of values to read
    * @param nulls If the pointer is null, all values are read. If the
    *    pointer is not null, positions that are true are skipped.
    */
-  virtual void next(
-      int64_t* FOLLY_NONNULL data,
-      uint64_t numValues,
-      const uint64_t* FOLLY_NULLABLE nulls) = 0;
-
-  virtual void next(
-      int32_t* FOLLY_NONNULL data,
-      uint64_t numValues,
-      const uint64_t* FOLLY_NULLABLE nulls) {
+  virtual void
+  next(int64_t* data, uint64_t numValues, const uint64_t* nulls) = 0;
+
+  virtual void next(int32_t* data, uint64_t numValues, const uint64_t* nulls) {
     if (numValues <= 4) {
       int64_t temp[4];
       next(temp, numValues, nulls);
@@ -93,23 +91,17 @@ class IntDecoder {
     }
   }
 
-  virtual void nextInts(
-      int32_t* FOLLY_NONNULL data,
-      uint64_t numValues,
-      const uint64_t* FOLLY_NULLABLE nulls) {
+  virtual void
+  nextInts(int32_t* data, uint64_t numValues, const uint64_t* nulls) {
     narrow(data, numValues, nulls);
   }
 
-  virtual void nextShorts(
-      int16_t* FOLLY_NONNULL data,
-      uint64_t numValues,
-      const uint64_t* FOLLY_NULLABLE nulls) {
+  virtual void
+  nextShorts(int16_t* data, uint64_t numValues, const uint64_t* nulls) {
     narrow(data, numValues, nulls);
   }
 
-  virtual void nextLengths(
-      int32_t* FOLLY_NONNULL /*values*/,
-      int32_t /*numValues*/) {
+  virtual void nextLengths(int32_t* /*values*/, int32_t /*numValues*/) {
     VELOX_FAIL("A length decoder should be a RLEv1");
   }
 
@@ -117,37 +109,43 @@ class IntDecoder {
    * Load RowIndex values for the stream being read.
    * @return updated start index after this stream's index values.
    */
-  size_t loadIndices(size_t startIndex) {
-    return inputStream->positionSize() + startIndex + 1;
+  size_t loadIndices(size_t startIndex) const {
+    return inputStream_->positionSize() + startIndex + 1;
   }
 
-  void skipLongs(uint64_t numValues) {
-    skipLongsFast(numValues);
-  }
-
-  // Optimized variant of skipLongs using popcnt. Used on selective
-  // path only pending validation.
-  void skipLongsFast(uint64_t numValues);
-
   // Reads 'size' consecutive T' and stores then in 'result'.
   template <typename T>
-  void bulkRead(uint64_t size, T* FOLLY_NONNULL result);
+  void bulkRead(uint64_t size, T* result);
 
   // Reads data at positions 'rows' to 'result'. 'initialRow' is the
   // row number of the first unread element of 'this'. if rows is {10}
   // and 'initialRow' is 9, then this skips one element and reads the
   // next element into 'result'.
   template <typename T>
-  void
-  bulkReadRows(RowSet rows, T* FOLLY_NONNULL result, int32_t initialRow = 0);
+  void bulkReadRows(RowSet rows, T* result, int32_t initialRow = 0);
 
  protected:
+  // Actually skip the pending entries.
+  virtual void skipPending() = 0;
+
+  template <bool kHasNulls>
+  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
+    if constexpr (kHasNulls) {
+      numValues = bits::countNonNulls(nulls, current, current + numValues);
+    }
+    pendingSkip_ += numValues;
+    if (pendingSkip_ > 0) {
+      skipPending();
+    }
+  }
+
+  void skipLongs(uint64_t numValues);
+
   template <typename T>
-  void bulkReadFixed(uint64_t size, T* FOLLY_NONNULL result);
+  void bulkReadFixed(uint64_t size, T* result);
 
   template <typename T>
-  void
-  bulkReadRowsFixed(RowSet rows, int32_t initialRow, T* FOLLY_NONNULL result);
+  void bulkReadRowsFixed(RowSet rows, int32_t initialRow, T* result);
 
   template <typename T>
   T readInt();
@@ -163,75 +161,66 @@ class IntDecoder {
   template <typename cppType>
   cppType readLittleEndianFromBigEndian();
 
-  // Applies 'visitor to 'numRows' consecutive values.
-  template <typename Visitor>
-  void readDense(int32_t numRows, Visitor& visitor) {
-    auto data = visitor.mutableValues(numRows);
-    bulkRead(numRows, data);
-    visitor.processN(data, numRows);
-  }
-
  private:
   uint64_t skipVarintsInBuffer(uint64_t items);
   void skipVarints(uint64_t items);
   int128_t readVsHugeInt();
   uint128_t readVuHugeInt();
 
- protected:
-  // note: there is opportunity for performance gains here by avoiding
-  //       this by directly supporting deserialization into the correct
-  //       target data type
+  // NOTE: there is opportunity for performance gains here by avoiding this by
+  // directly supporting deserialization into the correct target data type
   template <typename T>
-  void narrow(
-      T* FOLLY_NONNULL const data,
-      const uint64_t numValues,
-      const uint64_t* FOLLY_NULLABLE const nulls) {
-    DWIO_ENSURE_LE(numBytes, sizeof(T))
+  void narrow(T* data, uint64_t numValues, const uint64_t* nulls) {
+    VELOX_CHECK_LE(numBytes_, sizeof(T));
     std::array<int64_t, 64> buf;
     uint64_t remain = numValues;
     T* dataPtr = data;
     const uint64_t* nullsPtr = nulls;
-    while (remain != 0) {
-      uint64_t num = std::min(remain, static_cast<uint64_t>(buf.size()));
+    while (remain > 0) {
+      const uint64_t num = std::min(remain, static_cast<uint64_t>(buf.size()));
       next(buf.data(), num, nullsPtr);
       for (uint64_t i = 0; i < num; ++i) {
         *(dataPtr++) = (T)buf[i];
       }
       remain -= num;
       if (remain != 0 && nullsPtr) {
-        DWIO_ENSURE(num % 64 == 0);
+        VELOX_CHECK_EQ(num % 64, 0);
         nullsPtr += num / 64;
       }
     }
   }
 
-  const std::unique_ptr<dwio::common::SeekableInputStream> inputStream;
-  const char* FOLLY_NULLABLE bufferStart;
-  const char* FOLLY_NULLABLE bufferEnd;
-  const bool useVInts;
-  const uint32_t numBytes;
-  bool bigEndian;
+ protected:
+  const std::unique_ptr<dwio::common::SeekableInputStream> inputStream_;
+  const char* bufferStart_;
+  const char* bufferEnd_;
+  const bool useVInts_;
+  const uint32_t numBytes_;
+  const bool bigEndian_;
+  int64_t pendingSkip_{0};
 };
 
 template <bool isSigned>
 FOLLY_ALWAYS_INLINE signed char IntDecoder<isSigned>::readByte() {
-  if (UNLIKELY(bufferStart == bufferEnd)) {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
+
+  if (UNLIKELY(bufferStart_ == bufferEnd_)) {
     int32_t bufferLength;
     const void* bufferPointer;
-    DWIO_ENSURE(
-        inputStream->Next(&bufferPointer, &bufferLength),
-        "bad read in readByte, ",
-        inputStream->getName());
-    bufferStart = static_cast<const char*>(bufferPointer);
-    bufferEnd = bufferStart + bufferLength;
+    const bool ret = inputStream_->Next(&bufferPointer, &bufferLength);
+    VELOX_CHECK(ret, "bad read in readByte, ", inputStream_->getName());
+    bufferStart_ = static_cast<const char*>(bufferPointer);
+    bufferEnd_ = bufferStart_ + bufferLength;
   }
-  return *(bufferStart++);
+  return *(bufferStart_++);
 }
 
 template <bool isSigned>
 FOLLY_ALWAYS_INLINE uint64_t IntDecoder<isSigned>::readVuLong() {
-  if (LIKELY(bufferEnd - bufferStart >= folly::kMaxVarintLength64)) {
-    const char* p = bufferStart;
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
+
+  if (LIKELY(bufferEnd_ - bufferStart_ >= folly::kMaxVarintLength64)) {
+    const char* p = bufferStart_;
     uint64_t val;
     do {
       int64_t b;
@@ -285,29 +274,30 @@ FOLLY_ALWAYS_INLINE uint64_t IntDecoder<isSigned>::readVuLong() {
       if (LIKELY(b >= 0)) {
         break;
       } else {
-        DWIO_RAISE(fmt::format(
+        VELOX_FAIL(
             "Invalid encoding: likely corrupt data.  bytes remaining: {} , useVInts: {}, numBytes: {}, Input Stream Name: {}, byte: {}, val: {}",
-            bufferEnd - bufferStart,
-            useVInts,
-            numBytes,
-            inputStream->getName(),
+            bufferEnd_ - bufferStart_,
+            useVInts_,
+            numBytes_,
+            inputStream_->getName(),
             b,
-            val));
+            val);
       }
     } while (false);
-    bufferStart = p;
+
+    bufferStart_ = p;
     return val;
-  } else {
-    int64_t result = 0;
-    int64_t offset = 0;
-    signed char ch;
-    do {
-      ch = readByte();
-      result |= (ch & BASE_128_MASK) << offset;
-      offset += 7;
-    } while (ch < 0);
-    return result;
   }
+
+  int64_t result = 0;
+  int64_t offset = 0;
+  signed char ch;
+  do {
+    ch = readByte();
+    result |= (ch & BASE_128_MASK) << offset;
+    offset += 7;
+  } while (ch < 0);
+  return result;
 }
 
 template <bool isSigned>
@@ -317,39 +307,41 @@ FOLLY_ALWAYS_INLINE int64_t IntDecoder<isSigned>::readVsLong() {
 
 template <bool isSigned>
 inline int64_t IntDecoder<isSigned>::readLongLE() {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
   int64_t result = 0;
-  if (bufferStart && bufferStart + sizeof(int64_t) <= bufferEnd) {
-    bufferStart += numBytes;
-    if (numBytes == 8) {
-      return *reinterpret_cast<const int64_t*>(bufferStart - 8);
+  if (bufferStart_ && bufferStart_ + sizeof(int64_t) <= bufferEnd_) {
+    bufferStart_ += numBytes_;
+    if (numBytes_ == 8) {
+      return *reinterpret_cast<const int64_t*>(bufferStart_ - 8);
     }
-    if (numBytes == 4) {
+    if (numBytes_ == 4) {
       if (isSigned) {
-        return *reinterpret_cast<const int32_t*>(bufferStart - 4);
+        return *reinterpret_cast<const int32_t*>(bufferStart_ - 4);
       }
-      return *reinterpret_cast<const uint32_t*>(bufferStart - 4);
+      return *reinterpret_cast<const uint32_t*>(bufferStart_ - 4);
     }
     if (isSigned) {
-      return *reinterpret_cast<const int16_t*>(bufferStart - 2);
+      return *reinterpret_cast<const int16_t*>(bufferStart_ - 2);
     }
-    return *reinterpret_cast<const uint16_t*>(bufferStart - 2);
+    return *reinterpret_cast<const uint16_t*>(bufferStart_ - 2);
   }
+
   char b;
   int64_t offset = 0;
-  for (uint32_t i = 0; i < numBytes; ++i) {
+  for (uint32_t i = 0; i < numBytes_; ++i) {
     b = readByte();
     result |= (b & BASE_256_MASK) << offset;
     offset += 8;
   }
 
-  if (isSigned && numBytes < 8) {
-    if (numBytes == 2) {
+  if (isSigned && numBytes_ < 8) {
+    if (numBytes_ == 2) {
       return static_cast<int16_t>(result);
     }
-    if (numBytes == 4) {
+    if (numBytes_ == 4) {
       return static_cast<int32_t>(result);
     }
-    DCHECK(false) << "Bad width for signed fixed width: " << numBytes;
+    VELOX_DCHECK(false, "Bad width for signed fixed width: {}", numBytes_);
   }
   return result;
 }
@@ -357,19 +349,22 @@ inline int64_t IntDecoder<isSigned>::readLongLE() {
 template <bool isSigned>
 template <typename cppType>
 inline cppType IntDecoder<isSigned>::readLittleEndianFromBigEndian() {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
+
   cppType bigEndianValue = 0;
   // Input is in Big Endian layout of size numBytes.
-  if (bufferStart && bufferStart + sizeof(int64_t) <= bufferEnd) {
-    bufferStart += numBytes;
-    auto valueOffset = bufferStart - numBytes;
+  if (bufferStart_ && (bufferStart_ + sizeof(int64_t) <= bufferEnd_)) {
+    bufferStart_ += numBytes_;
+    const auto valueOffset = bufferStart_ - numBytes_;
     // Use first byte to initialize bigEndianValue.
     bigEndianValue =
         *(reinterpret_cast<const int8_t*>(valueOffset)) >= 0 ? 0 : -1;
     // Copy numBytes input to the bigEndianValue.
-    memcpy(
-        reinterpret_cast<char*>(&bigEndianValue) + (sizeof(cppType) - numBytes),
+    ::memcpy(
+        reinterpret_cast<char*>(&bigEndianValue) +
+            (sizeof(cppType) - numBytes_),
         reinterpret_cast<const char*>(valueOffset),
-        numBytes);
+        numBytes_);
     // Convert bigEndianValue to little endian value and return.
     if constexpr (sizeof(cppType) == 16) {
       return bits::builtin_bswap128(bigEndianValue);
@@ -377,11 +372,12 @@ inline cppType IntDecoder<isSigned>::readLittleEndianFromBigEndian() {
       return __builtin_bswap64(bigEndianValue);
     }
   }
+
   char b;
   cppType offset = 0;
   cppType numBytesBigEndian = 0;
   // Read numBytes input into numBytesBigEndian.
-  for (uint32_t i = 0; i < numBytes; ++i) {
+  for (uint32_t i = 0; i < numBytes_; ++i) {
     b = readByte();
     if constexpr (sizeof(cppType) == 16) {
       numBytesBigEndian |= (b & INT128_BASE_256_MASK) << offset;
@@ -394,10 +390,10 @@ inline cppType IntDecoder<isSigned>::readLittleEndianFromBigEndian() {
   bigEndianValue =
       (reinterpret_cast<const int8_t*>(&numBytesBigEndian)[0]) >= 0 ? 0 : -1;
   // Copy numBytes input to the bigEndianValue.
-  memcpy(
-      reinterpret_cast<char*>(&bigEndianValue) + (sizeof(cppType) - numBytes),
+  ::memcpy(
+      reinterpret_cast<char*>(&bigEndianValue) + (sizeof(cppType) - numBytes_),
       reinterpret_cast<const char*>(&numBytesBigEndian),
-      numBytes);
+      numBytes_);
   // Convert bigEndianValue to little endian value and return.
   if constexpr (sizeof(cppType) == 16) {
     return bits::builtin_bswap128(bigEndianValue);
@@ -413,6 +409,8 @@ inline int128_t IntDecoder<isSigned>::readVsHugeInt() {
 
 template <bool isSigned>
 inline uint128_t IntDecoder<isSigned>::readVuHugeInt() {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
+
   uint128_t value = 0;
   uint128_t work;
   uint32_t offset = 0;
@@ -433,10 +431,10 @@ inline uint128_t IntDecoder<isSigned>::readVuHugeInt() {
 template <bool isSigned>
 template <typename T>
 inline T IntDecoder<isSigned>::readInt() {
-  if (useVInts) {
+  if (useVInts_) {
     return readVInt<T>();
   }
-  if (bigEndian) {
+  if (bigEndian_) {
     return readLittleEndianFromBigEndian<T>();
   } else {
     if constexpr (std::is_same_v<T, int128_t>) {
@@ -466,9 +464,7 @@ inline T IntDecoder<isSigned>::readVInt() {
 
 template <>
 template <>
-inline void IntDecoder<false>::bulkRead(
-    uint64_t /*size*/,
-    double* FOLLY_NONNULL /*result*/) {
+inline void IntDecoder<false>::bulkRead(uint64_t /*size*/, double* /*result*/) {
   VELOX_UNREACHABLE();
 }
 
@@ -476,16 +472,14 @@ template <>
 template <>
 inline void IntDecoder<false>::bulkReadRows(
     RowSet /*rows*/,
-    double* FOLLY_NONNULL /*result*/,
+    double* /*result*/,
     int32_t /*initialRow*/) {
   VELOX_UNREACHABLE();
 }
 
 template <>
 template <>
-inline void IntDecoder<true>::bulkRead(
-    uint64_t /*size*/,
-    double* FOLLY_NONNULL /*result*/) {
+inline void IntDecoder<true>::bulkRead(uint64_t /*size*/, double* /*result*/) {
   VELOX_UNREACHABLE();
 }
 
@@ -493,16 +487,14 @@ template <>
 template <>
 inline void IntDecoder<true>::bulkReadRows(
     RowSet /*rows*/,
-    double* FOLLY_NONNULL /*result*/,
+    double* /*result*/,
     int32_t /*initialRow*/) {
   VELOX_UNREACHABLE();
 }
 
 template <>
 template <>
-inline void IntDecoder<false>::bulkRead(
-    uint64_t /*size*/,
-    float* FOLLY_NONNULL /*result*/) {
+inline void IntDecoder<false>::bulkRead(uint64_t /*size*/, float* /*result*/) {
   VELOX_UNREACHABLE();
 }
 
@@ -510,16 +502,14 @@ template <>
 template <>
 inline void IntDecoder<false>::bulkReadRows(
     RowSet /*rows*/,
-    float* FOLLY_NONNULL /*result*/,
+    float* /*result*/,
     int32_t /*initialRow*/) {
   VELOX_UNREACHABLE();
 }
 
 template <>
 template <>
-inline void IntDecoder<true>::bulkRead(
-    uint64_t /*size*/,
-    float* FOLLY_NONNULL /*result*/) {
+inline void IntDecoder<true>::bulkRead(uint64_t /*size*/, float* /*result*/) {
   VELOX_UNREACHABLE();
 }
 
@@ -527,7 +517,7 @@ template <>
 template <>
 inline void IntDecoder<true>::bulkReadRows(
     RowSet /*rows*/,
-    float* FOLLY_NONNULL /*result*/,
+    float* /*result*/,
     int32_t /*initialRow*/) {
   VELOX_UNREACHABLE();
 }
@@ -536,7 +526,7 @@ template <>
 template <>
 inline void IntDecoder<false>::bulkRead(
     uint64_t /*size*/,
-    int128_t* FOLLY_NONNULL /*result*/) {
+    int128_t* /*result*/) {
   VELOX_UNREACHABLE();
 }
 
@@ -544,7 +534,7 @@ template <>
 template <>
 inline void IntDecoder<false>::bulkReadRows(
     RowSet /*rows*/,
-    int128_t* FOLLY_NONNULL /*result*/,
+    int128_t* /*result*/,
     int32_t /*initialRow*/) {
   VELOX_UNREACHABLE();
 }
@@ -553,7 +543,7 @@ template <>
 template <>
 inline void IntDecoder<true>::bulkRead(
     uint64_t /*size*/,
-    int128_t* FOLLY_NONNULL /*result*/) {
+    int128_t* /*result*/) {
   VELOX_UNREACHABLE();
 }
 
@@ -561,7 +551,7 @@ template <>
 template <>
 inline void IntDecoder<true>::bulkReadRows(
     RowSet /*rows*/,
-    int128_t* FOLLY_NONNULL /*result*/,
+    int128_t* /*result*/,
     int32_t /*initialRow*/) {
   VELOX_UNREACHABLE();
 }
diff --git a/velox/dwio/common/MeasureTime.h b/velox/dwio/common/MeasureTime.h
new file mode 100644
index 0000000000000..c4eaf1281f379
--- /dev/null
+++ b/velox/dwio/common/MeasureTime.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <functional>
+#include <optional>
+
+namespace facebook {
+namespace velox {
+namespace dwio {
+namespace common {
+
+class MeasureTime {
+ public:
+  explicit MeasureTime(
+      const std::function<void(std::chrono::high_resolution_clock::duration)>&
+          callback)
+      : callback_{callback},
+        startTime_{std::chrono::high_resolution_clock::now()} {}
+
+  MeasureTime(const MeasureTime&) = delete;
+  MeasureTime(MeasureTime&&) = delete;
+  MeasureTime& operator=(const MeasureTime&) = delete;
+  MeasureTime& operator=(MeasureTime&& other) = delete;
+
+  ~MeasureTime() {
+    callback_(std::chrono::high_resolution_clock::now() - startTime_);
+  }
+
+ private:
+  const std::function<void(std::chrono::high_resolution_clock::duration)>&
+      callback_;
+  const std::chrono::time_point<std::chrono::high_resolution_clock> startTime_;
+};
+
+// Make sure you don't pass a lambda to this function, because that will cause a
+// std::function to be created on the fly (implicitly), and when we return from
+// this function that std::function won't exist anymore. So when MeasureTime is
+// destroyed, it will try to access a non-existing std::function.
+inline std::optional<MeasureTime> measureTimeIfCallback(
+    const std::function<void(std::chrono::high_resolution_clock::duration)>&
+        callback) {
+  if (callback) {
+    return std::make_optional<MeasureTime>(callback);
+  }
+  return std::nullopt;
+}
+
+} // namespace common
+} // namespace dwio
+} // namespace velox
+} // namespace facebook
diff --git a/velox/dwio/common/MetadataFilter.cpp b/velox/dwio/common/MetadataFilter.cpp
index 6b5d943d92536..62bf79107e10a 100644
--- a/velox/dwio/common/MetadataFilter.cpp
+++ b/velox/dwio/common/MetadataFilter.cpp
@@ -149,13 +149,6 @@ struct MetadataFilter::OrNode : Node {
 
 namespace {
 
-const core::FieldAccessTypedExpr* asField(
-    const core::ITypedExpr* expr,
-    int index) {
-  return dynamic_cast<const core::FieldAccessTypedExpr*>(
-      expr->inputs()[index].get());
-}
-
 const core::CallTypedExpr* asCall(const core::ITypedExpr* expr) {
   return dynamic_cast<const core::CallTypedExpr*>(expr);
 }
@@ -221,6 +214,7 @@ void MetadataFilter::eval(
   if (!root_) {
     return;
   }
+
   LeafResults leafResults;
   for (auto& [leaf, result] : leafNodeResults) {
     VELOX_CHECK_EQ(
@@ -233,7 +227,7 @@ void MetadataFilter::eval(
         "Duplicate results: {}",
         leaf->field().toString());
   }
-  auto bitCount = finalResult.size() * 64;
+  const auto bitCount = finalResult.size() * 64;
   if (auto* combined = root_->eval(leafResults, bitCount)) {
     bits::orBits(finalResult.data(), combined, 0, bitCount);
   }
diff --git a/velox/dwio/common/MetadataFilter.h b/velox/dwio/common/MetadataFilter.h
index b44ae69cbd554..62b604b14407d 100644
--- a/velox/dwio/common/MetadataFilter.h
+++ b/velox/dwio/common/MetadataFilter.h
@@ -49,9 +49,9 @@ class MetadataFilter {
   std::string toString() const;
 
  private:
-  class Node;
-  class AndNode;
-  class OrNode;
+  struct Node;
+  struct AndNode;
+  struct OrNode;
 
   std::shared_ptr<Node> root_;
 };
diff --git a/velox/dwio/common/MetricsLog.h b/velox/dwio/common/MetricsLog.h
index 3c1d9f26594b2..555e92f24d63a 100644
--- a/velox/dwio/common/MetricsLog.h
+++ b/velox/dwio/common/MetricsLog.h
@@ -72,7 +72,7 @@ class MetricsLog {
   };
 
   // read path logging methods
-  virtual void logRead(const ReadMetrics& metrics) const {};
+  virtual void logRead(const ReadMetrics& metrics) const {}
 
   virtual void logColumnFilter(
       const ColumnFilter& filter,
diff --git a/velox/dwio/common/Mutation.h b/velox/dwio/common/Mutation.h
index a3181df0e11a2..de5ff469c71a7 100644
--- a/velox/dwio/common/Mutation.h
+++ b/velox/dwio/common/Mutation.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include "velox/common/base/RandomUtil.h"
+
 #include <cstdint>
 
 namespace facebook::velox::dwio::common {
@@ -23,6 +25,12 @@ namespace facebook::velox::dwio::common {
 struct Mutation {
   /// Bit masks for row numbers to be deleted.
   const uint64_t* deletedRows = nullptr;
+
+  random::RandomSkipTracker* randomSkip = nullptr;
 };
 
+inline bool hasDeletion(const Mutation* mutation) {
+  return mutation && (mutation->deletedRows || mutation->randomSkip);
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/OnDemandUnitLoader.cpp b/velox/dwio/common/OnDemandUnitLoader.cpp
new file mode 100644
index 0000000000000..d4ef4f0a5ef29
--- /dev/null
+++ b/velox/dwio/common/OnDemandUnitLoader.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/OnDemandUnitLoader.h"
+
+#include <numeric>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/dwio/common/MeasureTime.h"
+#include "velox/dwio/common/UnitLoaderTools.h"
+
+using facebook::velox::dwio::common::measureTimeIfCallback;
+
+namespace facebook::velox::dwio::common {
+
+namespace {
+
+class OnDemandUnitLoader : public UnitLoader {
+ public:
+  OnDemandUnitLoader(
+      std::vector<std::unique_ptr<LoadUnit>> loadUnits,
+      std::function<void(std::chrono::high_resolution_clock::duration)>
+          blockedOnIoCallback)
+      : loadUnits_{std::move(loadUnits)},
+        blockedOnIoCallback_{std::move(blockedOnIoCallback)} {}
+
+  ~OnDemandUnitLoader() override = default;
+
+  LoadUnit& getLoadedUnit(uint32_t unit) override {
+    VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
+
+    if (loadedUnit_.has_value()) {
+      if (loadedUnit_.value() == unit) {
+        return *loadUnits_[unit];
+      }
+
+      loadUnits_[*loadedUnit_]->unload();
+      loadedUnit_.reset();
+    }
+
+    {
+      auto measure = measureTimeIfCallback(blockedOnIoCallback_);
+      loadUnits_[unit]->load();
+    }
+    loadedUnit_ = unit;
+
+    return *loadUnits_[unit];
+  }
+
+  void onRead(uint32_t unit, uint64_t rowOffsetInUnit, uint64_t /* rowCount */)
+      override {
+    VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
+    VELOX_CHECK_LT(
+        rowOffsetInUnit, loadUnits_[unit]->getNumRows(), "Row out of range");
+  }
+
+  void onSeek(uint32_t unit, uint64_t rowOffsetInUnit) override {
+    VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
+    VELOX_CHECK_LE(
+        rowOffsetInUnit, loadUnits_[unit]->getNumRows(), "Row out of range");
+  }
+
+ private:
+  const std::vector<std::unique_ptr<LoadUnit>> loadUnits_;
+  const std::function<void(std::chrono::high_resolution_clock::duration)>
+      blockedOnIoCallback_;
+  std::optional<uint32_t> loadedUnit_;
+};
+
+} // namespace
+
+std::unique_ptr<UnitLoader> OnDemandUnitLoaderFactory::create(
+    std::vector<std::unique_ptr<LoadUnit>> loadUnits,
+    uint64_t rowsToSkip) {
+  const auto totalRows = std::accumulate(
+      loadUnits.cbegin(), loadUnits.cend(), 0UL, [](uint64_t sum, auto& unit) {
+        return sum + unit->getNumRows();
+      });
+  VELOX_CHECK_LE(
+      rowsToSkip,
+      totalRows,
+      "Can only skip up to the past-the-end row of the file.");
+  return std::make_unique<OnDemandUnitLoader>(
+      std::move(loadUnits), blockedOnIoCallback_);
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/OnDemandUnitLoader.h b/velox/dwio/common/OnDemandUnitLoader.h
new file mode 100644
index 0000000000000..e2d6d4ab3efe5
--- /dev/null
+++ b/velox/dwio/common/OnDemandUnitLoader.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <functional>
+
+#include "velox/dwio/common/UnitLoader.h"
+
+namespace facebook::velox::dwio::common {
+
+class OnDemandUnitLoaderFactory
+    : public velox::dwio::common::UnitLoaderFactory {
+ public:
+  explicit OnDemandUnitLoaderFactory(
+      std::function<void(std::chrono::high_resolution_clock::duration)>
+          blockedOnIoCallback)
+      : blockedOnIoCallback_{std::move(blockedOnIoCallback)} {}
+  ~OnDemandUnitLoaderFactory() override = default;
+
+  std::unique_ptr<velox::dwio::common::UnitLoader> create(
+      std::vector<std::unique_ptr<velox::dwio::common::LoadUnit>> loadUnits,
+      uint64_t rowsToSkip) override;
+
+ private:
+  std::function<void(std::chrono::high_resolution_clock::duration)>
+      blockedOnIoCallback_;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/Options.cpp b/velox/dwio/common/Options.cpp
index 32672da0d88d9..faab7802a42e4 100644
--- a/velox/dwio/common/Options.cpp
+++ b/velox/dwio/common/Options.cpp
@@ -16,12 +16,9 @@
 
 #include "velox/dwio/common/Options.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
-FileFormat toFileFormat(std::string s) {
+FileFormat toFileFormat(std::string_view s) {
   if (s == "dwrf") {
     return FileFormat::DWRF;
   } else if (s == "rc") {
@@ -36,15 +33,15 @@ FileFormat toFileFormat(std::string s) {
     return FileFormat::JSON;
   } else if (s == "parquet") {
     return FileFormat::PARQUET;
-  } else if (s == "alpha") {
-    return FileFormat::ALPHA;
+  } else if (s == "nimble" || s == "alpha") {
+    return FileFormat::NIMBLE;
   } else if (s == "orc") {
     return FileFormat::ORC;
   }
   return FileFormat::UNKNOWN;
 }
 
-std::string toString(FileFormat fmt) {
+std::string_view toString(FileFormat fmt) {
   switch (fmt) {
     case FileFormat::DWRF:
       return "dwrf";
@@ -60,8 +57,8 @@ std::string toString(FileFormat fmt) {
       return "json";
     case FileFormat::PARQUET:
       return "parquet";
-    case FileFormat::ALPHA:
-      return "alpha";
+    case FileFormat::NIMBLE:
+      return "nimble";
     case FileFormat::ORC:
       return "orc";
     default:
@@ -69,7 +66,4 @@ std::string toString(FileFormat fmt) {
   }
 }
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/Options.h b/velox/dwio/common/Options.h
index 0a66bd7b5a9bf..0a4a9dbcff36e 100644
--- a/velox/dwio/common/Options.h
+++ b/velox/dwio/common/Options.h
@@ -20,7 +20,10 @@
 #include <unordered_set>
 
 #include <folly/Executor.h>
+#include "velox/common/base/RandomUtil.h"
+#include "velox/common/base/SpillConfig.h"
 #include "velox/common/compression/Compression.h"
+#include "velox/common/config/Config.h"
 #include "velox/common/io/Options.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/dwio/common/ColumnSelector.h"
@@ -29,12 +32,12 @@
 #include "velox/dwio/common/FlushPolicy.h"
 #include "velox/dwio/common/InputStream.h"
 #include "velox/dwio/common/ScanSpec.h"
+#include "velox/dwio/common/UnitLoader.h"
 #include "velox/dwio/common/encryption/Encryption.h"
+#include "velox/type/Timestamp.h"
+#include "velox/type/tz/TimeZoneMap.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 enum class FileFormat {
   UNKNOWN = 0,
@@ -45,12 +48,12 @@ enum class FileFormat {
   TEXT = 5,
   JSON = 6,
   PARQUET = 7,
-  ALPHA = 8,
+  NIMBLE = 8,
   ORC = 9,
 };
 
-FileFormat toFileFormat(std::string s);
-std::string toString(FileFormat fmt);
+FileFormat toFileFormat(std::string_view s);
+std::string_view toString(FileFormat fmt);
 
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
     std::ostream& output,
@@ -59,9 +62,7 @@ FOLLY_ALWAYS_INLINE std::ostream& operator<<(
   return output;
 }
 
-/**
- * Formatting options for serialization.
- */
+/// Formatting options for serialization.
 enum class SerDeSeparator {
   FIELD_DELIM = 0,
   COLLECTION_DELIM = 1,
@@ -79,6 +80,7 @@ class SerDeOptions {
   inline static const std::string kFieldDelim{"field.delim"};
   inline static const std::string kCollectionDelim{"collection.delim"};
   inline static const std::string kMapKeyDelim{"mapkey.delim"};
+  inline static const std::string kEscapeChar{"escape.delim"};
 
   explicit SerDeOptions(
       uint8_t fieldDelim = '\1',
@@ -95,177 +97,156 @@ class SerDeOptions {
 };
 
 struct TableParameter {
+  /// If present in the table parameters, the option is passed to the row reader
+  /// to instruct it to skip the number of rows from the current position. Used
+  /// to skip the column header row(s).
   static constexpr const char* kSkipHeaderLineCount = "skip.header.line.count";
+  /// If present in the table parameters, the option overrides the default value
+  /// of the SerDeOptions::nullString. It causes any field read from the file
+  /// (usually of the TEXT format) to be considered NULL if it is equal to this
+  /// string.
+  static constexpr const char* kSerializationNullFormat =
+      "serialization.null.format";
 };
 
-/**
- * Options for creating a RowReader.
- */
-class RowReaderOptions {
- private:
-  uint64_t dataStart;
-  uint64_t dataLength;
-  bool preloadStripe;
-  bool projectSelectedType;
-  bool returnFlatVector_ = false;
-  ErrorTolerance errorTolerance_;
-  std::shared_ptr<ColumnSelector> selector_;
-  std::shared_ptr<velox::common::ScanSpec> scanSpec_ = nullptr;
-  std::shared_ptr<velox::common::MetadataFilter> metadataFilter_;
-  // Node id for map column to a list of keys to be projected as a struct.
-  std::unordered_map<uint32_t, std::vector<std::string>> flatmapNodeIdAsStruct_;
-  // Optional executors to enable internal reader parallelism.
-  // 'decodingExecutor' allow parallelising the vector decoding process.
-  // 'ioExecutor' enables parallelism when performing file system read
-  // operations.
-  std::shared_ptr<folly::Executor> decodingExecutor_;
-  bool appendRowNumberColumn_ = false;
-  // Function to populate metrics related to feature projection stats
-  // in Koski. This gets fired in FlatMapColumnReader.
-  // This is a bit of a hack as there is (by design) no good way
-  // To propogate information from column reader to Koski
-  std::function<void(
-      facebook::velox::dwio::common::flatmap::FlatMapKeySelectionStats)>
-      keySelectionCallback_;
-  bool eagerFirstStripeLoad = true;
-  uint64_t skipRows_ = 0;
+struct RowNumberColumnInfo {
+  column_index_t insertPosition;
+  std::string name;
+  // This flag is used to distinguish the explicit and implicit use cases. In
+  // explicit case, row index column is declared in the output type or used in
+  // subfield filters or remaining filter. In implicit case, it's not declared
+  // in the output columns but only in the split reader.
+  bool isExplicit;
+};
+
+class FormatSpecificOptions {
+ public:
+  virtual ~FormatSpecificOptions() = default;
+};
 
+/// Options for creating a RowReader.
+class RowReaderOptions {
  public:
   RowReaderOptions() noexcept
-      : dataStart(0),
-        dataLength(std::numeric_limits<uint64_t>::max()),
-        preloadStripe(false),
-        projectSelectedType(false) {}
-
-  /**
-   * For files that have structs as the top-level object, select the fields
-   * to read. The first field is 0, the second 1, and so on. By default,
-   * all columns are read. This option clears any previous setting of
-   * the selected columns.
-   * @param include a list of fields to read
-   * @return this
-   */
+      : dataStart_(0),
+        dataLength_(std::numeric_limits<uint64_t>::max()),
+        preloadStripe_(false),
+        projectSelectedType_(false) {}
+
+  /// For files that have structs as the top-level object, select the fields
+  /// to read. The first field is 0, the second 1, and so on. By default,
+  /// all columns are read. This option clears any previous setting of
+  /// the selected columns.
+  /// @param include a list of fields to read
+  /// @return this
   RowReaderOptions& select(const std::shared_ptr<ColumnSelector>& selector) {
     selector_ = selector;
+    if (selector) {
+      VELOX_CHECK_NULL(requestedType_);
+      requestedType_ = selector->getSchema();
+    }
     return *this;
   }
 
-  /**
-   * Set the section of the file to process.
-   * @param offset the starting byte offset
-   * @param length the number of bytes to read
-   * @return this
-   */
+  /// Sets the section of the file to process.
+  /// @param offset the starting byte offset
+  /// @param length the number of bytes to read
+  /// @return this
   RowReaderOptions& range(uint64_t offset, uint64_t length) {
-    dataStart = offset;
-    dataLength = length;
+    dataStart_ = offset;
+    dataLength_ = length;
     return *this;
   }
 
-  /**
-   * Get the list of selected field or type ids to read.
-   */
-  const std::shared_ptr<ColumnSelector>& getSelector() const {
+  /// Gets the list of selected field or type ids to read.
+  const std::shared_ptr<ColumnSelector>& selector() const {
     return selector_;
   }
 
-  /**
-   * Get the start of the range for the data being processed.
-   * @return if not set, return 0
-   */
-  uint64_t getOffset() const {
-    return dataStart;
+  /// Gets the start of the range for the data being processed.
+  /// @return if not set, return 0
+  uint64_t offset() const {
+    return dataStart_;
   }
 
-  /**
-   * Get the length of the range for the data being processed.
-   * @return if not set, return the maximum unsigned long.
-   */
-  uint64_t getLength() const {
-    return dataLength;
+  /// Gets the length of the range for the data being processed.
+  /// @return if not set, return the maximum unsigned long.
+  uint64_t length() const {
+    return dataLength_;
   }
 
-  /**
-   * Get the limit of the range (lowest offset not in the range).
-   * @return if not set, return the maximum unsigned long.
-   */
-  uint64_t getLimit() const {
-    return ((std::numeric_limits<uint64_t>::max() - dataStart) > dataLength)
-        ? (dataStart + dataLength)
+  /// Gets the limit of the range (lowest offset not in the range).
+  /// @return if not set, return the maximum unsigned long.
+  uint64_t limit() const {
+    return ((std::numeric_limits<uint64_t>::max() - dataStart_) > dataLength_)
+        ? (dataStart_ + dataLength_)
         : std::numeric_limits<uint64_t>::max();
   }
 
-  /**
-   * Request that stripes be pre-loaded.
-   */
+  /// Requests that stripes be pre-loaded.
   void setPreloadStripe(bool preload) {
-    preloadStripe = preload;
+    preloadStripe_ = preload;
   }
 
-  /**
-   * Are stripes to be pre-loaded?
-   */
-  bool getPreloadStripe() const {
-    return preloadStripe;
+  /// Are stripes to be pre-loaded?
+  bool preloadStripe() const {
+    return preloadStripe_;
   }
 
-  /*
-   * Will load the first stripe on RowReader creation, if true.
-   * This behavior is already happening in DWRF, but isn't desired for some use
-   * cases. So this flag allows us to turn it off.
-   */
+  /// Will load the first stripe on RowReader creation, if true.
+  /// This behavior is already happening in DWRF, but isn't desired for some use
+  /// cases. So this flag allows us to turn it off.
   void setEagerFirstStripeLoad(bool load) {
-    eagerFirstStripeLoad = load;
+    eagerFirstStripeLoad_ = load;
   }
 
-  /*
-   * Will load the first stripe on RowReader creation, if true.
-   * This behavior is already happening in DWRF, but isn't desired for some use
-   * cases. So this flag allows us to turn it off.
-   */
-  bool getEagerFirstStripeLoad() const {
-    return eagerFirstStripeLoad;
+  /// Will load the first stripe on RowReader creation, if true.
+  /// This behavior is already happening in DWRF, but isn't desired for some use
+  /// cases. So this flag allows us to turn it off.
+  bool eagerFirstStripeLoad() const {
+    return eagerFirstStripeLoad_;
   }
 
-  // For flat map, return flat vector representation
-  bool getReturnFlatVector() const {
+  /// For flat map, return flat vector representation
+  bool returnFlatVector() const {
     return returnFlatVector_;
   }
 
-  // For flat map, request that flat vector representation is used
+  /// For flat map, request that flat vector representation is used
   void setReturnFlatVector(bool value) {
     returnFlatVector_ = value;
   }
 
-  /**
-   * Request that the selected type be projected.
-   */
-  void setProjectSelectedType(bool vProjectSelectedType) {
-    projectSelectedType = vProjectSelectedType;
+  /// Requests that the selected type be projected.
+  void setProjectSelectedType(bool value) {
+    projectSelectedType_ = value;
   }
 
-  /**
-   * Is the selected type to be projected?
-   */
-  bool getProjectSelectedType() const {
-    return projectSelectedType;
+  /// Is the selected type to be projected?
+  bool projectSelectedType() const {
+    return projectSelectedType_;
   }
 
-  /**
-   * set RowReader error tolerance.
-   */
+  /// Set RowReader error tolerance.
   void setErrorTolerance(const ErrorTolerance& errorTolerance) {
     errorTolerance_ = errorTolerance;
   }
 
-  /**
-   * get RowReader error tolerance.
-   */
-  const ErrorTolerance& getErrorTolerance() const {
+  /// Get RowReader error tolerance.
+  const ErrorTolerance& errorTolerance() const {
     return errorTolerance_;
   }
 
-  const std::shared_ptr<velox::common::ScanSpec>& getScanSpec() const {
+  const RowTypePtr& requestedType() const {
+    return requestedType_;
+  }
+
+  void setRequestedType(RowTypePtr requestedType) {
+    VELOX_CHECK_NULL(selector_);
+    requestedType_ = std::move(requestedType);
+  }
+
+  const std::shared_ptr<velox::common::ScanSpec>& scanSpec() const {
     return scanSpec_;
   }
 
@@ -273,8 +254,7 @@ class RowReaderOptions {
     scanSpec_ = std::move(scanSpec);
   }
 
-  const std::shared_ptr<velox::common::MetadataFilter>& getMetadataFilter()
-      const {
+  const std::shared_ptr<velox::common::MetadataFilter>& metadataFilter() const {
     return metadataFilter_;
   }
 
@@ -296,7 +276,7 @@ class RowReaderOptions {
   }
 
   const std::unordered_map<uint32_t, std::vector<std::string>>&
-  getMapColumnIdAsStruct() const {
+  mapColumnIdAsStruct() const {
     return flatmapNodeIdAsStruct_;
   }
 
@@ -304,18 +284,17 @@ class RowReaderOptions {
     decodingExecutor_ = executor;
   }
 
-  /*
-   * Set to true, if you want to add a new column to the results containing the
-   * row numbers.  These row numbers are relative to the beginning of file (0 as
-   * first row) and does not affected by filtering or deletion during the read
-   * (it always counts all rows in the file).
-   */
-  void setAppendRowNumberColumn(bool value) {
-    appendRowNumberColumn_ = value;
+  void setDecodingParallelismFactor(size_t factor) {
+    decodingParallelismFactor_ = factor;
   }
 
-  bool getAppendRowNumberColumn() const {
-    return appendRowNumberColumn_;
+  void setRowNumberColumnInfo(
+      std::optional<RowNumberColumnInfo> rowNumberColumnInfo) {
+    rowNumberColumnInfo_ = std::move(rowNumberColumnInfo);
+  }
+
+  const std::optional<RowNumberColumnInfo>& rowNumberColumnInfo() const {
+    return rowNumberColumnInfo_;
   }
 
   void setKeySelectionCallback(
@@ -327,114 +306,168 @@ class RowReaderOptions {
 
   const std::function<
       void(facebook::velox::dwio::common::flatmap::FlatMapKeySelectionStats)>
-  getKeySelectionCallback() const {
+  keySelectionCallback() const {
     return keySelectionCallback_;
   }
 
+  void setBlockedOnIoCallback(
+      std::function<void(std::chrono::high_resolution_clock::duration)>
+          blockedOnIoCallback) {
+    blockedOnIoCallback_ = std::move(blockedOnIoCallback);
+  }
+
+  const std::function<void(std::chrono::high_resolution_clock::duration)>
+  blockedOnIoCallback() const {
+    return blockedOnIoCallback_;
+  }
+
+  void setDecodingTimeCallback(
+      std::function<void(std::chrono::high_resolution_clock::duration)>
+          decodingTime) {
+    decodingTimeCallback_ = std::move(decodingTime);
+  }
+
+  std::function<void(std::chrono::high_resolution_clock::duration)>
+  decodingTimeCallback() const {
+    return decodingTimeCallback_;
+  }
+
+  void setStripeCountCallback(
+      std::function<void(uint16_t)> stripeCountCallback) {
+    stripeCountCallback_ = std::move(stripeCountCallback);
+  }
+
+  std::function<void(uint16_t)> stripeCountCallback() const {
+    return stripeCountCallback_;
+  }
+
   void setSkipRows(uint64_t skipRows) {
     skipRows_ = skipRows;
   }
 
-  bool getSkipRows() const {
+  uint64_t skipRows() const {
     return skipRows_;
   }
 
-  const std::shared_ptr<folly::Executor>& getDecodingExecutor() const {
+  void setUnitLoaderFactory(
+      std::shared_ptr<UnitLoaderFactory> unitLoaderFactory) {
+    unitLoaderFactory_ = std::move(unitLoaderFactory);
+  }
+
+  const std::shared_ptr<UnitLoaderFactory>& unitLoaderFactory() const {
+    return unitLoaderFactory_;
+  }
+
+  const std::shared_ptr<folly::Executor>& decodingExecutor() const {
     return decodingExecutor_;
   }
-};
 
-/**
- * Options for creating a Reader.
- */
-class ReaderOptions : public io::ReaderOptions {
+  size_t decodingParallelismFactor() const {
+    return decodingParallelismFactor_;
+  }
+
+  TimestampPrecision timestampPrecision() const {
+    return timestampPrecision_;
+  }
+
+  void setTimestampPrecision(TimestampPrecision precision) {
+    timestampPrecision_ = precision;
+  }
+
+  const std::shared_ptr<FormatSpecificOptions>& formatSpecificOptions() const {
+    return formatSpecificOptions_;
+  }
+
+  void setFormatSpecificOptions(
+      std::shared_ptr<FormatSpecificOptions> options) {
+    formatSpecificOptions_ = std::move(options);
+  }
+
  private:
-  uint64_t tailLocation;
-  FileFormat fileFormat;
-  RowTypePtr fileSchema;
-  SerDeOptions serDeOptions;
-  std::shared_ptr<encryption::DecrypterFactory> decrypterFactory_;
-  uint64_t directorySizeGuess{kDefaultDirectorySizeGuess};
-  uint64_t filePreloadThreshold{kDefaultFilePreloadThreshold};
-  bool fileColumnNamesReadAsLowerCase{false};
-  bool useColumnNamesForColumnMapping_{false};
-  std::shared_ptr<folly::Executor> ioExecutor_;
+  uint64_t dataStart_;
+  uint64_t dataLength_;
+  bool preloadStripe_;
+  bool projectSelectedType_;
+  bool returnFlatVector_ = false;
+  ErrorTolerance errorTolerance_;
+  std::shared_ptr<ColumnSelector> selector_;
+  RowTypePtr requestedType_;
+  std::shared_ptr<velox::common::ScanSpec> scanSpec_{nullptr};
+  std::shared_ptr<velox::common::MetadataFilter> metadataFilter_;
+  // Node id for map column to a list of keys to be projected as a struct.
+  std::unordered_map<uint32_t, std::vector<std::string>> flatmapNodeIdAsStruct_;
+  // Optional executors to enable internal reader parallelism.
+  // 'decodingExecutor' allow parallelising the vector decoding process.
+  // 'ioExecutor' enables parallelism when performing file system read
+  // operations.
+  std::shared_ptr<folly::Executor> decodingExecutor_;
+  size_t decodingParallelismFactor_{0};
+  std::optional<RowNumberColumnInfo> rowNumberColumnInfo_{std::nullopt};
 
+  // Function to populate metrics related to feature projection stats
+  // in Koski. This gets fired in FlatMapColumnReader.
+  // This is a bit of a hack as there is (by design) no good way
+  // To propogate information from column reader to Koski
+  std::function<void(
+      facebook::velox::dwio::common::flatmap::FlatMapKeySelectionStats)>
+      keySelectionCallback_;
+
+  // Function to track how much time we spend waiting on IO before reading rows
+  // (in dwrf row reader). todo: encapsulate this and keySelectionCallBack_ in a
+  // struct
+  std::function<void(std::chrono::high_resolution_clock::duration)>
+      blockedOnIoCallback_;
+  std::function<void(std::chrono::high_resolution_clock::duration)>
+      decodingTimeCallback_;
+  std::function<void(uint16_t)> stripeCountCallback_;
+  bool eagerFirstStripeLoad_{true};
+  uint64_t skipRows_{0};
+
+  std::shared_ptr<UnitLoaderFactory> unitLoaderFactory_;
+
+  TimestampPrecision timestampPrecision_ = TimestampPrecision::kMilliseconds;
+
+  std::shared_ptr<FormatSpecificOptions> formatSpecificOptions_;
+};
+
+/// Options for creating a Reader.
+class ReaderOptions : public io::ReaderOptions {
  public:
-  static constexpr uint64_t kDefaultDirectorySizeGuess = 1024 * 1024; // 1MB
+  static constexpr uint64_t kDefaultFooterEstimatedSize = 1024 * 1024; // 1MB
   static constexpr uint64_t kDefaultFilePreloadThreshold =
       1024 * 1024 * 8; // 8MB
 
   explicit ReaderOptions(velox::memory::MemoryPool* pool)
       : io::ReaderOptions(pool),
-        tailLocation(std::numeric_limits<uint64_t>::max()),
-        fileFormat(FileFormat::UNKNOWN),
-        fileSchema(nullptr) {}
-
-  ReaderOptions& operator=(const ReaderOptions& other) {
-    io::ReaderOptions::operator=(other);
-    tailLocation = other.tailLocation;
-    fileFormat = other.fileFormat;
-    if (other.fileSchema != nullptr) {
-      fileSchema = other.getFileSchema();
-    } else {
-      fileSchema = nullptr;
-    }
-    serDeOptions = other.serDeOptions;
-    decrypterFactory_ = other.decrypterFactory_;
-    directorySizeGuess = other.directorySizeGuess;
-    filePreloadThreshold = other.filePreloadThreshold;
-    fileColumnNamesReadAsLowerCase = other.fileColumnNamesReadAsLowerCase;
-    useColumnNamesForColumnMapping_ = other.useColumnNamesForColumnMapping_;
-    return *this;
-  }
+        tailLocation_(std::numeric_limits<uint64_t>::max()),
+        fileFormat_(FileFormat::UNKNOWN),
+        fileSchema_(nullptr) {}
 
-  ReaderOptions(const ReaderOptions& other)
-      : io::ReaderOptions(other),
-        tailLocation(other.tailLocation),
-        fileFormat(other.fileFormat),
-        fileSchema(other.fileSchema),
-        serDeOptions(other.serDeOptions),
-        decrypterFactory_(other.decrypterFactory_),
-        directorySizeGuess(other.directorySizeGuess),
-        filePreloadThreshold(other.filePreloadThreshold),
-        fileColumnNamesReadAsLowerCase(other.fileColumnNamesReadAsLowerCase),
-        useColumnNamesForColumnMapping_(other.useColumnNamesForColumnMapping_) {
-  }
-
-  /**
-   * Set the format of the file, such as "rc" or "dwrf".  The
-   * default is "dwrf".
-   */
+  /// Sets the format of the file, such as "rc" or "dwrf". The default is
+  /// "dwrf".
   ReaderOptions& setFileFormat(FileFormat format) {
-    fileFormat = format;
+    fileFormat_ = format;
     return *this;
   }
 
-  /**
-   * Set the schema of the file (a Type tree).
-   * For "dwrf" format, a default schema is derived from the file.
-   * For "rc" format, there is no default schema.
-   */
+  /// Sets the schema of the file (a Type tree).  For "dwrf" format, a default
+  /// schema is derived from the file. For "rc" format, there is no default
+  /// schema.
   ReaderOptions& setFileSchema(const RowTypePtr& schema) {
-    fileSchema = schema;
+    fileSchema_ = schema;
     return *this;
   }
 
-  /**
-   * Set the location of the tail as defined by the logical length of the
-   * file.
-   */
+  /// Sets the location of the tail as defined by the logical length of the
+  /// file.
   ReaderOptions& setTailLocation(uint64_t offset) {
-    tailLocation = offset;
+    tailLocation_ = offset;
     return *this;
   }
 
-  /**
-   * Modify the serialization-deserialization options.
-   */
-  ReaderOptions& setSerDeOptions(const SerDeOptions& sdo) {
-    serDeOptions = sdo;
+  /// Modifies the serialization-deserialization options.
+  ReaderOptions& setSerDeOptions(const SerDeOptions& serdeOpts) {
+    serDeOptions_ = serdeOpts;
     return *this;
   }
 
@@ -444,18 +477,18 @@ class ReaderOptions : public io::ReaderOptions {
     return *this;
   }
 
-  ReaderOptions& setDirectorySizeGuess(uint64_t size) {
-    directorySizeGuess = size;
+  ReaderOptions& setFooterEstimatedSize(uint64_t size) {
+    footerEstimatedSize_ = size;
     return *this;
   }
 
   ReaderOptions& setFilePreloadThreshold(uint64_t threshold) {
-    filePreloadThreshold = threshold;
+    filePreloadThreshold_ = threshold;
     return *this;
   }
 
   ReaderOptions& setFileColumnNamesReadAsLowerCase(bool flag) {
-    fileColumnNamesReadAsLowerCase = flag;
+    fileColumnNamesReadAsLowerCase_ = flag;
     return *this;
   }
 
@@ -469,70 +502,151 @@ class ReaderOptions : public io::ReaderOptions {
     return *this;
   }
 
-  /**
-   * Get the desired tail location.
-   * @return if not set, return the maximum long.
-   */
-  uint64_t getTailLocation() const {
-    return tailLocation;
+  ReaderOptions& setSessionTimezone(const tz::TimeZone* sessionTimezone) {
+    sessionTimezone_ = sessionTimezone;
+    return *this;
   }
 
-  /**
-   * Get the file format.
-   */
-  FileFormat getFileFormat() const {
-    return fileFormat;
+  /// Gets the desired tail location.
+  uint64_t tailLocation() const {
+    return tailLocation_;
   }
 
-  /**
-   * Get the file schema.
-   */
-  const std::shared_ptr<const velox::RowType>& getFileSchema() const {
-    return fileSchema;
+  /// Gets the file format.
+  FileFormat fileFormat() const {
+    return fileFormat_;
   }
 
-  SerDeOptions& getSerDeOptions() {
-    return serDeOptions;
+  /// Gets the file schema.
+  const std::shared_ptr<const velox::RowType>& fileSchema() const {
+    return fileSchema_;
   }
 
-  const SerDeOptions& getSerDeOptions() const {
-    return serDeOptions;
+  SerDeOptions& serDeOptions() {
+    return serDeOptions_;
   }
 
-  const std::shared_ptr<encryption::DecrypterFactory> getDecrypterFactory()
-      const {
+  const SerDeOptions& serDeOptions() const {
+    return serDeOptions_;
+  }
+
+  const std::shared_ptr<encryption::DecrypterFactory> decrypterFactory() const {
     return decrypterFactory_;
   }
 
-  uint64_t getDirectorySizeGuess() const {
-    return directorySizeGuess;
+  uint64_t footerEstimatedSize() const {
+    return footerEstimatedSize_;
   }
 
-  uint64_t getFilePreloadThreshold() const {
-    return filePreloadThreshold;
+  uint64_t filePreloadThreshold() const {
+    return filePreloadThreshold_;
   }
 
-  const std::shared_ptr<folly::Executor>& getIOExecutor() const {
+  const std::shared_ptr<folly::Executor>& ioExecutor() const {
     return ioExecutor_;
   }
 
-  bool isFileColumnNamesReadAsLowerCase() const {
-    return fileColumnNamesReadAsLowerCase;
+  const tz::TimeZone* getSessionTimezone() const {
+    return sessionTimezone_;
   }
 
-  bool isUseColumnNamesForColumnMapping() const {
+  bool fileColumnNamesReadAsLowerCase() const {
+    return fileColumnNamesReadAsLowerCase_;
+  }
+
+  bool useColumnNamesForColumnMapping() const {
     return useColumnNamesForColumnMapping_;
   }
+
+  const std::shared_ptr<random::RandomSkipTracker>& randomSkip() const {
+    return randomSkip_;
+  }
+
+  void setRandomSkip(std::shared_ptr<random::RandomSkipTracker> randomSkip) {
+    randomSkip_ = std::move(randomSkip);
+  }
+
+  bool noCacheRetention() const {
+    return noCacheRetention_;
+  }
+
+  void setNoCacheRetention(bool noCacheRetention) {
+    noCacheRetention_ = noCacheRetention;
+  }
+
+  const std::shared_ptr<velox::common::ScanSpec>& scanSpec() const {
+    return scanSpec_;
+  }
+
+  void setScanSpec(std::shared_ptr<velox::common::ScanSpec> scanSpec) {
+    scanSpec_ = std::move(scanSpec);
+  }
+
+  bool selectiveNimbleReaderEnabled() const {
+    return selectiveNimbleReaderEnabled_;
+  }
+
+  void setSelectiveNimbleReaderEnabled(bool value) {
+    selectiveNimbleReaderEnabled_ = value;
+  }
+
+ private:
+  uint64_t tailLocation_;
+  FileFormat fileFormat_;
+  RowTypePtr fileSchema_;
+  SerDeOptions serDeOptions_;
+  std::shared_ptr<encryption::DecrypterFactory> decrypterFactory_;
+  uint64_t footerEstimatedSize_{kDefaultFooterEstimatedSize};
+  uint64_t filePreloadThreshold_{kDefaultFilePreloadThreshold};
+  bool fileColumnNamesReadAsLowerCase_{false};
+  bool useColumnNamesForColumnMapping_{false};
+  std::shared_ptr<folly::Executor> ioExecutor_;
+  std::shared_ptr<random::RandomSkipTracker> randomSkip_;
+  std::shared_ptr<velox::common::ScanSpec> scanSpec_;
+  const tz::TimeZone* sessionTimezone_{nullptr};
+  bool selectiveNimbleReaderEnabled_{false};
 };
 
 struct WriterOptions {
-  TypePtr schema;
-  velox::memory::MemoryPool* memoryPool;
-  velox::memory::SetMemoryReclaimer setMemoryReclaimer{nullptr};
+  TypePtr schema{nullptr};
+  velox::memory::MemoryPool* memoryPool{nullptr};
+  const velox::common::SpillConfig* spillConfig{nullptr};
+  tsan_atomic<bool>* nonReclaimableSection{nullptr};
+
+  /// A ready-to-use default memory reclaimer factory. It shall be provided by
+  /// the system that creates writers to ensure a smooth memory system
+  /// integration (e.g. graceful suspension upon arbitration request). Writer
+  /// can choose to implement its custom memory reclaimer if needed and not use
+  /// this default one.
+  std::function<std::unique_ptr<velox::memory::MemoryReclaimer>()>
+      memoryReclaimerFactory{[]() { return nullptr; }};
+
   std::optional<velox::common::CompressionKind> compressionKind;
+  std::optional<uint64_t> orcMinCompressionSize{std::nullopt};
+  std::optional<uint64_t> maxStripeSize{std::nullopt};
+  std::optional<bool> orcLinearStripeSizeHeuristics{std::nullopt};
+  std::optional<uint64_t> maxDictionaryMemory{std::nullopt};
+  std::optional<bool> orcWriterIntegerDictionaryEncodingEnabled{std::nullopt};
+  std::optional<bool> orcWriterStringDictionaryEncodingEnabled{std::nullopt};
+  std::map<std::string, std::string> serdeParameters;
+  std::optional<uint8_t> zlibCompressionLevel;
+  std::optional<uint8_t> zstdCompressionLevel;
+
+  std::function<std::unique_ptr<dwio::common::FlushPolicy>()>
+      flushPolicyFactory;
+
+  virtual ~WriterOptions() = default;
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
+
+template <>
+struct fmt::formatter<facebook::velox::dwio::common::FileFormat>
+    : fmt::formatter<std::string_view> {
+  template <typename FormatContext>
+  auto format(facebook::velox::dwio::common::FileFormat fmt, FormatContext& ctx)
+      const {
+    return formatter<std::string_view>::format(
+        facebook::velox::dwio::common::toString(fmt), ctx);
+  }
+};
diff --git a/velox/dwio/common/ParallelFor.cpp b/velox/dwio/common/ParallelFor.cpp
new file mode 100644
index 0000000000000..793b2f486acfe
--- /dev/null
+++ b/velox/dwio/common/ParallelFor.cpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/ParallelFor.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/dwio/common/ExecutorBarrier.h"
+
+namespace facebook::velox::dwio::common {
+
+namespace {
+
+std::vector<std::pair<size_t, size_t>>
+splitRange(size_t from, size_t to, size_t factor) {
+  VELOX_CHECK_LE(from, to);
+  std::vector<std::pair<size_t, size_t>> ranges;
+
+  if (from == to) {
+    return ranges;
+  }
+
+  if (factor <= 1) {
+    ranges.emplace_back(from, to);
+    return ranges;
+  }
+
+  auto rangeSize = to - from;
+  auto chunkSize = rangeSize / factor;
+  auto remainder = rangeSize % factor;
+  auto start = from;
+  for (size_t i = 0; i < factor; ++i) {
+    auto end = start + chunkSize;
+    if (remainder > 0) {
+      --remainder;
+      ++end;
+    }
+    // If `factor > (to - from)`, the rest of the chunks will be empty
+    if (end > start) {
+      ranges.emplace_back(start, end);
+    } else {
+      break;
+    }
+    start = end;
+  }
+  return ranges;
+}
+
+} // namespace
+
+ParallelFor::ParallelFor(
+    folly::Executor* executor,
+    size_t from,
+    size_t to,
+    size_t parallelismFactor)
+    : executor_(executor),
+      ranges_{splitRange(from, to, (executor_ ? parallelismFactor : 0))} {}
+
+ParallelFor::ParallelFor(
+    std::shared_ptr<folly::Executor> executor,
+    size_t from,
+    size_t to,
+    size_t parallelismFactor)
+    : ParallelFor{executor.get(), from, to, parallelismFactor} {
+  owned_ = std::move(executor);
+}
+
+void ParallelFor::execute(std::function<void(size_t)> func) {
+  // Otherwise from == to
+  if (ranges_.empty()) {
+    return;
+  }
+  if (ranges_.size() == 1) {
+    for (size_t i = ranges_[0].first, end = ranges_[0].second; i < end; ++i) {
+      func(i);
+    }
+  } else {
+    VELOX_CHECK(
+        executor_,
+        "Executor wasn't provided so we shouldn't have more than 1 range");
+    ExecutorBarrier barrier(*executor_);
+    const size_t last = ranges_.size() - 1;
+    // First N-1 ranges in executor threads
+    for (size_t r = 0; r < last; ++r) {
+      auto& range = ranges_[r];
+      barrier.add([begin = range.first, end = range.second, &func]() {
+        for (size_t i = begin; i < end; ++i) {
+          func(i);
+        }
+      });
+    }
+    // Last range in calling thread
+    auto& range = ranges_[last];
+    for (size_t i = range.first, end = range.second; i < end; ++i) {
+      func(i);
+    }
+    barrier.waitAll();
+  }
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ParallelFor.h b/velox/dwio/common/ParallelFor.h
new file mode 100644
index 0000000000000..f6debc9f14fdc
--- /dev/null
+++ b/velox/dwio/common/ParallelFor.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <vector>
+#include "folly/Executor.h"
+
+namespace facebook::velox::dwio::common {
+
+/*
+ * A helper class that allows to run a function on a range of indices in
+ * multiple threads.
+ * The range (from, to] is split into equal-sized chunks and each chunk is
+ * scheduled in a different thread. The number of threads is: parallelismFactor
+ * It means that if parallelismFactor == 1 (or 0), the function will be executed
+ * in the calling thread for the entire range. If parallelismFactor == 2, the
+ * function will be called for half of the range in one thread in the executor,
+ * and for the last half in the calling thread (and so on). If no executor is
+ * passed (nullptr), the function will be executed in the calling thread for the
+ * entire range.
+ */
+class ParallelFor {
+ public:
+  ParallelFor(
+      folly::Executor* executor,
+      size_t from, // start index
+      size_t to, // past end index
+      // number of threads.
+      size_t parallelismFactor);
+
+  ParallelFor(
+      std::shared_ptr<folly::Executor> executor,
+      size_t from, // start index
+      size_t to, // past end index
+      // number of threads
+      size_t parallelismFactor);
+
+  void execute(std::function<void(size_t)> func);
+
+ private:
+  std::shared_ptr<folly::Executor> owned_;
+  folly::Executor* executor_;
+  std::vector<std::pair<size_t, size_t>> ranges_;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/PositionProvider.h b/velox/dwio/common/PositionProvider.h
new file mode 100644
index 0000000000000..7be3bc7a16029
--- /dev/null
+++ b/velox/dwio/common/PositionProvider.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <vector>
+
+namespace facebook::velox::dwio::common {
+
+class PositionProvider {
+ public:
+  explicit PositionProvider(const std::vector<uint64_t>& positions)
+      : position_{positions.begin()}, end_{positions.end()} {}
+
+  uint64_t next();
+
+  bool hasNext() const;
+
+ private:
+  std::vector<uint64_t>::const_iterator position_;
+  std::vector<uint64_t>::const_iterator end_;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/RandGen.h b/velox/dwio/common/RandGen.h
index f84f0c666576c..b83743bbcca18 100644
--- a/velox/dwio/common/RandGen.h
+++ b/velox/dwio/common/RandGen.h
@@ -27,7 +27,7 @@ namespace common {
 class RandGen {
  public:
   RandGen()
-      : rand_{}, mt_{rand_()}, dist_(0, std::numeric_limits<int32_t>::max()){};
+      : rand_{}, mt_{rand_()}, dist_(0, std::numeric_limits<int32_t>::max()) {}
 
   template <typename T>
   T gen(int32_t max) {
diff --git a/velox/dwio/common/Range.cpp b/velox/dwio/common/Range.cpp
index ff4e5fa66d4d6..509fba4f36225 100644
--- a/velox/dwio/common/Range.cpp
+++ b/velox/dwio/common/Range.cpp
@@ -18,12 +18,13 @@
 
 namespace facebook::velox::common {
 
-Ranges Ranges::filter(std::function<bool(size_t)> func) const {
+Ranges Ranges::filter(const std::function<bool(size_t)>& func) const {
   Ranges ret;
-  for (auto& r : ranges_) {
+  for (auto& range : ranges_) {
     bool inRun = false;
     size_t runStart = 0;
-    for (auto cur = std::get<0>(r), end = std::get<1>(r); cur != end; ++cur) {
+    for (auto cur = std::get<0>(range), end = std::get<1>(range); cur != end;
+         ++cur) {
       if (func(cur)) {
         if (!inRun) {
           inRun = true;
@@ -35,9 +36,10 @@ Ranges Ranges::filter(std::function<bool(size_t)> func) const {
         inRun = false;
       }
     }
+
     if (inRun) {
-      ret.ranges_.emplace_back(runStart, std::get<1>(r));
-      ret.size_ += (std::get<1>(r) - runStart);
+      ret.ranges_.emplace_back(runStart, std::get<1>(range));
+      ret.size_ += (std::get<1>(range) - runStart);
     }
   }
   return ret;
diff --git a/velox/dwio/common/Range.h b/velox/dwio/common/Range.h
index 71445f33941bc..8f12abff182f6 100644
--- a/velox/dwio/common/Range.h
+++ b/velox/dwio/common/Range.h
@@ -16,33 +16,31 @@
 
 #pragma once
 
+#include "velox/common/base/Exceptions.h"
 #include "velox/common/base/GTestMacros.h"
-#include "velox/dwio/common/exception/Exception.h"
 
 namespace facebook::velox::common {
 
-/** Utility class to represent ranges of input used by DWRF writer.
-This class does not dedepe overlapping ranges because for encoded input, the
-overlapping range should be processed the same amount of time as specified
-rather than just once.
-This class does not support representing empty ranges. It
-is the Caller's responsibility to avoid using the class when empty ranges are
-possible.
-*/
+/// Utility class to represent ranges of input used by DWRF writer.This class
+/// does not dedepe overlapping ranges because for encoded input, the
+/// overlapping range should be processed the same amount of time as specified
+/// rather than just once. This class does not support representing empty
+/// ranges. It is the Caller's responsibility to avoid using the class when
+/// empty ranges are possible.
 class Ranges {
  public:
   void add(size_t begin, size_t end) {
     if (begin == end) {
       return;
     }
-    DWIO_ENSURE_LT(begin, end);
+    VELOX_CHECK_LT(begin, end);
     size_ += (end - begin);
-    if (ranges_.size()) {
-      // try merge with last
+    if (!ranges_.empty()) {
+      // try merge with last.
       auto& last = ranges_.back();
-      auto& e = std::get<1>(last);
-      if (e == begin) {
-        e = end;
+      auto& lastEnd = std::get<1>(last);
+      if (lastEnd == begin) {
+        lastEnd = end;
         return;
       }
     }
@@ -51,22 +49,23 @@ class Ranges {
     ranges_.emplace_back(begin, end);
   }
 
-  // returns another instance with ranges meet the filter criteria
-  Ranges filter(std::function<bool(size_t)> func) const;
+  /// Returns another instance with ranges meet the filter criteria
+  Ranges filter(const std::function<bool(size_t)>& func) const;
 
   class Iterator {
    public:
     Iterator(
         std::vector<std::tuple<size_t, size_t>>::const_iterator cur,
         std::vector<std::tuple<size_t, size_t>>::const_iterator end)
-        : cur_{cur}, end_{end}, val_{0} {
+        : end_{end}, cur_{cur}, val_{0} {
       if (cur_ != end_) {
         val_ = std::get<0>(*cur_);
       }
     }
 
     bool operator==(const Iterator& other) const {
-      return cur_ == other.cur_ && end_ == other.end_ && val_ == other.val_;
+      return std::tie(cur_, end_, val_) ==
+          std::tie(other.cur_, other.end_, other.val_);
     }
 
     bool operator!=(const Iterator& other) const {
@@ -74,7 +73,7 @@ class Ranges {
     }
 
     Iterator& operator++() {
-      DCHECK(cur_ != end_);
+      VELOX_DCHECK(cur_ != end_);
       if (++val_ == std::get<1>(*cur_)) {
         val_ = (++cur_ != end_ ? std::get<0>(*cur_) : 0);
       }
@@ -82,13 +81,13 @@ class Ranges {
     }
 
     const size_t& operator*() const {
-      DCHECK(cur_ != end_);
+      VELOX_DCHECK(cur_ != end_);
       return val_;
     }
 
    private:
+    const std::vector<std::tuple<size_t, size_t>>::const_iterator end_;
     std::vector<std::tuple<size_t, size_t>>::const_iterator cur_;
-    std::vector<std::tuple<size_t, size_t>>::const_iterator end_;
     size_t val_;
   };
 
@@ -114,9 +113,9 @@ class Ranges {
   }
 
   static Ranges of(size_t begin, size_t end) {
-    Ranges r;
-    r.add(begin, end);
-    return r;
+    Ranges ranges;
+    ranges.add(begin, end);
+    return ranges;
   }
 
  private:
diff --git a/velox/dwio/common/Reader.cpp b/velox/dwio/common/Reader.cpp
index 85e56bc44c8b0..1beec1b02491c 100644
--- a/velox/dwio/common/Reader.cpp
+++ b/velox/dwio/common/Reader.cpp
@@ -18,9 +18,73 @@
 
 namespace facebook::velox::dwio::common {
 
+using namespace velox::common;
+
+namespace {
+
+template <TypeKind kKind>
+bool filterSimpleVectorRow(
+    const BaseVector& vector,
+    Filter& filter,
+    vector_size_t index) {
+  using T = typename TypeTraits<kKind>::NativeType;
+  auto* simpleVector = vector.asUnchecked<SimpleVector<T>>();
+  return applyFilter(filter, simpleVector->valueAt(index));
+}
+
+bool filterRow(const BaseVector& vector, Filter& filter, vector_size_t index) {
+  if (vector.isNullAt(index)) {
+    return filter.testNull();
+  }
+  switch (vector.typeKind()) {
+    case TypeKind::ARRAY:
+    case TypeKind::MAP:
+    case TypeKind::ROW:
+      VELOX_USER_CHECK(
+          filter.kind() == FilterKind::kIsNull ||
+              filter.kind() == FilterKind::kIsNotNull,
+          "Complex type can only take null filter, got {}",
+          filter.toString());
+      return filter.testNonNull();
+    default:
+      return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          filterSimpleVectorRow, vector.typeKind(), vector, filter, index);
+  }
+}
+
+void applyFilter(
+    const BaseVector& vector,
+    const ScanSpec& spec,
+    uint64_t* result) {
+  if (spec.filter()) {
+    bits::forEachSetBit(result, 0, vector.size(), [&](auto i) {
+      if (!filterRow(vector, *spec.filter(), i)) {
+        bits::clearBit(result, i);
+      }
+    });
+  }
+  if (!vector.type()->isRow()) {
+    // Filter on MAP or ARRAY children are pruning, and won't affect correctness
+    // of the result.
+    return;
+  }
+  auto& rowType = vector.type()->asRow();
+  auto* rowVector = vector.as<RowVector>();
+  // Should not have any lazy from non-selective reader.
+  VELOX_CHECK_NOT_NULL(rowVector);
+  for (auto& childSpec : spec.children()) {
+    auto child =
+        rowVector->childAt(rowType.getChildIdx(childSpec->fieldName()));
+    applyFilter(*child, *childSpec, result);
+  }
+}
+
+} // namespace
+
 VectorPtr RowReader::projectColumns(
     const VectorPtr& input,
-    const velox::common::ScanSpec& spec) {
+    const ScanSpec& spec,
+    const Mutation* mutation) {
   auto* inputRow = input->as<RowVector>();
   VELOX_CHECK_NOT_NULL(inputRow);
   auto& inputRowType = input->type()->asRow();
@@ -31,27 +95,175 @@ VectorPtr RowReader::projectColumns(
   std::vector<std::string> names(numColumns);
   std::vector<TypePtr> types(numColumns);
   std::vector<VectorPtr> children(numColumns);
+  std::vector<uint64_t> passed(bits::nwords(input->size()), -1);
+  if (mutation) {
+    if (mutation->deletedRows) {
+      bits::andWithNegatedBits(
+          passed.data(), mutation->deletedRows, 0, input->size());
+    }
+    if (mutation->randomSkip) {
+      bits::forEachSetBit(passed.data(), 0, input->size(), [&](auto i) {
+        if (!mutation->randomSkip->testOne()) {
+          bits::clearBit(passed.data(), i);
+        }
+      });
+    }
+  }
   for (auto& childSpec : spec.children()) {
+    VectorPtr child;
+    if (childSpec->isConstant()) {
+      child = BaseVector::wrapInConstant(
+          input->size(), 0, childSpec->constantValue());
+    } else {
+      child =
+          inputRow->childAt(inputRowType.getChildIdx(childSpec->fieldName()));
+      applyFilter(*child, *childSpec, passed.data());
+    }
     if (!childSpec->projectOut()) {
       continue;
     }
     auto i = childSpec->channel();
     names[i] = childSpec->fieldName();
-    if (childSpec->isConstant()) {
-      children[i] = BaseVector::wrapInConstant(
-          input->size(), 0, childSpec->constantValue());
-    } else {
-      children[i] =
-          inputRow->childAt(inputRowType.getChildIdx(childSpec->fieldName()));
+    types[i] = child->type();
+    children[i] = std::move(child);
+  }
+  auto rowType = ROW(std::move(names), std::move(types));
+  auto size = bits::countBits(passed.data(), 0, input->size());
+  if (size == 0) {
+    return RowVector::createEmpty(rowType, input->pool());
+  }
+  if (size < input->size()) {
+    auto indices = allocateIndices(size, input->pool());
+    auto* rawIndices = indices->asMutable<vector_size_t>();
+    vector_size_t j = 0;
+    bits::forEachSetBit(
+        passed.data(), 0, input->size(), [&](auto i) { rawIndices[j++] = i; });
+    for (auto& child : children) {
+      child->disableMemo();
+      child = BaseVector::wrapInDictionary(
+          nullptr, indices, size, std::move(child));
     }
-    types[i] = children[i]->type();
   }
   return std::make_shared<RowVector>(
-      input->pool(),
-      ROW(std::move(names), std::move(types)),
-      nullptr,
-      input->size(),
-      std::move(children));
+      input->pool(), rowType, nullptr, size, std::move(children));
+}
+
+namespace {
+void fillRowNumberVector(
+    VectorPtr& rowNumVector,
+    bool contiguousRowNumbers,
+    uint64_t previousRow,
+    uint64_t rowsToRead,
+    const dwio::common::SelectiveColumnReader* columnReader,
+    VectorPtr& result) {
+  FlatVector<int64_t>* flatRowNum{nullptr};
+  if (rowNumVector && BaseVector::isVectorWritable(rowNumVector)) {
+    flatRowNum = rowNumVector->asFlatVector<int64_t>();
+  }
+  if (flatRowNum) {
+    flatRowNum->clearAllNulls();
+    flatRowNum->resize(result->size());
+  } else {
+    rowNumVector = std::make_shared<FlatVector<int64_t>>(
+        result->pool(),
+        BIGINT(),
+        nullptr,
+        result->size(),
+        AlignedBuffer::allocate<int64_t>(result->size(), result->pool()),
+        std::vector<BufferPtr>());
+    flatRowNum = rowNumVector->asUnchecked<FlatVector<int64_t>>();
+  }
+  auto* rawRowNum = flatRowNum->mutableRawValues();
+  if (contiguousRowNumbers) {
+    VELOX_DCHECK_EQ(rowsToRead, result->size());
+    std::iota(rawRowNum, rawRowNum + rowsToRead, previousRow);
+  } else {
+    const auto rowOffsets = columnReader->outputRows();
+    VELOX_DCHECK_EQ(rowOffsets.size(), result->size());
+    for (int i = 0; i < rowOffsets.size(); ++i) {
+      rawRowNum[i] = previousRow + rowOffsets[i];
+    }
+  }
+}
+} // namespace
+
+void RowReader::readWithRowNumber(
+    std::unique_ptr<dwio::common::SelectiveColumnReader>& columnReader,
+    const dwio::common::RowReaderOptions& options,
+    uint64_t previousRow,
+    uint64_t rowsToRead,
+    const dwio::common::Mutation* mutation,
+    VectorPtr& result) {
+  const auto& rowNumberColumnInfo = options.rowNumberColumnInfo();
+  VELOX_CHECK(rowNumberColumnInfo.has_value());
+  const auto rowNumberColumnIndex = rowNumberColumnInfo->insertPosition;
+  const auto& rowNumberColumnName = rowNumberColumnInfo->name;
+  column_index_t numChildren{0};
+  column_index_t numNotReadFromFileChildren{0};
+  for (auto& column : options.scanSpec()->children()) {
+    if (column->projectOut()) {
+      ++numChildren;
+      if (column->isConstant() || column->isExplicitRowNumber()) {
+        ++numNotReadFromFileChildren;
+      }
+    }
+  }
+  VELOX_CHECK_LE(rowNumberColumnIndex, numChildren);
+  const bool contiguousRowNumbers =
+      (numChildren == numNotReadFromFileChildren) && !hasDeletion(mutation);
+  if (rowNumberColumnInfo->isExplicit) {
+    columnReader->next(rowsToRead, result, mutation);
+    fillRowNumberVector(
+        result->asUnchecked<RowVector>()->childAt(rowNumberColumnIndex),
+        contiguousRowNumbers,
+        previousRow,
+        rowsToRead,
+        columnReader.get(),
+        result);
+  } else {
+    auto* rowVector = result->asUnchecked<RowVector>();
+    VectorPtr rowNumVector;
+    if (rowVector->childrenSize() != numChildren) {
+      VELOX_CHECK_EQ(rowVector->childrenSize(), numChildren + 1);
+      rowNumVector = rowVector->childAt(rowNumberColumnIndex);
+      const auto& rowType = rowVector->type()->asRow();
+      auto names = rowType.names();
+      auto types = rowType.children();
+      auto children = rowVector->children();
+      VELOX_DCHECK(!names.empty() && !types.empty() && !children.empty());
+      names.erase(names.begin() + rowNumberColumnIndex);
+      types.erase(types.begin() + rowNumberColumnIndex);
+      children.erase(children.begin() + rowNumberColumnIndex);
+      result = std::make_shared<RowVector>(
+          rowVector->pool(),
+          ROW(std::move(names), std::move(types)),
+          rowVector->nulls(),
+          rowVector->size(),
+          std::move(children));
+    }
+    columnReader->next(rowsToRead, result, mutation);
+    fillRowNumberVector(
+        rowNumVector,
+        contiguousRowNumbers,
+        previousRow,
+        rowsToRead,
+        columnReader.get(),
+        result);
+    rowVector = result->asUnchecked<RowVector>();
+    auto& rowType = rowVector->type()->asRow();
+    auto names = rowType.names();
+    auto types = rowType.children();
+    auto children = rowVector->children();
+    names.insert(names.begin() + rowNumberColumnIndex, rowNumberColumnName);
+    types.insert(types.begin() + rowNumberColumnIndex, BIGINT());
+    children.insert(children.begin() + rowNumberColumnIndex, rowNumVector);
+    result = std::make_shared<RowVector>(
+        rowVector->pool(),
+        ROW(std::move(names), std::move(types)),
+        rowVector->nulls(),
+        rowVector->size(),
+        std::move(children));
+  }
 }
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/Reader.h b/velox/dwio/common/Reader.h
index 9587acd8badcd..0c3da77d29ce8 100644
--- a/velox/dwio/common/Reader.h
+++ b/velox/dwio/common/Reader.h
@@ -24,6 +24,7 @@
 #include "velox/dwio/common/InputStream.h"
 #include "velox/dwio/common/Mutation.h"
 #include "velox/dwio/common/Options.h"
+#include "velox/dwio/common/SelectiveColumnReader.h"
 #include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/common/TypeWithId.h"
 #include "velox/type/Type.h"
@@ -136,15 +137,24 @@ class RowReader {
    */
   virtual std::optional<std::vector<PrefetchUnit>> prefetchUnits() {
     return std::nullopt;
-  };
+  }
 
   /**
    * Helper function used by non-selective reader to project top level columns
-   * according to the scan spec.
+   * according to the scan spec and mutations.
    */
   static VectorPtr projectColumns(
       const VectorPtr& input,
-      const velox::common::ScanSpec&);
+      const velox::common::ScanSpec& spec,
+      const Mutation* mutation);
+
+  static void readWithRowNumber(
+      std::unique_ptr<dwio::common::SelectiveColumnReader>& columnReader,
+      const dwio::common::RowReaderOptions& options,
+      uint64_t previousRow,
+      uint64_t rowsToRead,
+      const dwio::common::Mutation*,
+      VectorPtr& result);
 };
 
 /**
diff --git a/velox/dwio/common/ReaderFactory.cpp b/velox/dwio/common/ReaderFactory.cpp
index dcb120aab9076..56599c620fd92 100644
--- a/velox/dwio/common/ReaderFactory.cpp
+++ b/velox/dwio/common/ReaderFactory.cpp
@@ -31,7 +31,8 @@ ReaderFactoriesMap& readerFactories() {
 } // namespace
 
 bool registerReaderFactory(std::shared_ptr<ReaderFactory> factory) {
-  bool ok = readerFactories().insert({factory->fileFormat(), factory}).second;
+  [[maybe_unused]] const bool ok =
+      readerFactories().insert({factory->fileFormat(), factory}).second;
   // NOTE: re-enable this check after Prestissimo has updated dwrf registration.
 #if 0
   VELOX_CHECK(
diff --git a/velox/dwio/common/Retry.h b/velox/dwio/common/Retry.h
index a7e7f7c3cd5c2..d4d52c120f280 100644
--- a/velox/dwio/common/Retry.h
+++ b/velox/dwio/common/Retry.h
@@ -57,10 +57,12 @@ using RetryDuration =
     std::chrono::duration<float, std::chrono::milliseconds::period>;
 
 namespace retrypolicy {
+
 class IRetryPolicy {
  public:
   virtual ~IRetryPolicy() = default;
   virtual folly::Optional<RetryDuration> nextWaitTime() = 0;
+  virtual void start() {}
 };
 
 class KAttempts : public IRetryPolicy {
@@ -68,7 +70,7 @@ class KAttempts : public IRetryPolicy {
   explicit KAttempts(std::vector<RetryDuration> durations)
       : index_(0), durations_(std::move(durations)) {}
 
-  folly::Optional<RetryDuration> nextWaitTime() {
+  folly::Optional<RetryDuration> nextWaitTime() override {
     if (index_ < durations_.size()) {
       return folly::Optional<RetryDuration>(durations_[index_++]);
     } else {
@@ -86,26 +88,32 @@ class ExponentialBackoff : public IRetryPolicy {
   ExponentialBackoff(
       RetryDuration start,
       RetryDuration max,
-      uint64_t maxRetries = std::numeric_limits<uint64_t>::max(),
-      RetryDuration maxTotal = RetryDuration::zero())
+      uint64_t maxRetries,
+      RetryDuration maxTotal,
+      bool countExecutionTime)
       : maxWait_(max),
         maxTotal_(maxTotal),
+        countExecutionTime_(countExecutionTime),
         nextWait_(start),
-        total_(0),
+        totalWait_(0),
         retriesLeft_(maxRetries) {
     DWIO_ENSURE_LE(start.count(), max.count());
     DWIO_ENSURE(maxTotal_.count() == 0 || maxTotal_.count() > start.count());
   }
 
-  folly::Optional<RetryDuration> nextWaitTime() {
-    if (retriesLeft_ == 0 || (maxTotal_.count() > 0 && total_ >= maxTotal_)) {
+  void start() override {
+    startTime_ = std::chrono::system_clock::now();
+  }
+
+  folly::Optional<RetryDuration> nextWaitTime() override {
+    if (retriesLeft_ == 0 || (maxTotal_.count() > 0 && total() >= maxTotal_)) {
       return folly::Optional<RetryDuration>();
     }
 
     RetryDuration waitTime = nextWait_ + jitter();
     nextWait_ = std::min(nextWait_ + nextWait_, maxWait_);
     --retriesLeft_;
-    total_ += waitTime;
+    totalWait_ += waitTime;
     return folly::Optional<RetryDuration>(waitTime);
   }
 
@@ -114,10 +122,17 @@ class ExponentialBackoff : public IRetryPolicy {
     return RetryDuration(rand_.gen(folly::to<int64_t>(nextWait_.count()) / 2));
   }
 
+  RetryDuration total() const {
+    return countExecutionTime_ ? std::chrono::system_clock::now() - startTime_
+                               : totalWait_;
+  }
+
   const RetryDuration maxWait_;
   const RetryDuration maxTotal_;
+  const bool countExecutionTime_;
+  std::chrono::system_clock::time_point startTime_;
   RetryDuration nextWait_;
-  RetryDuration total_;
+  RetryDuration totalWait_;
   uint64_t retriesLeft_;
   RandGen rand_;
 };
@@ -142,27 +157,30 @@ class KAttemptsPolicyFactory : public IRetryPolicyFactory {
 };
 
 class ExponentialBackoffPolicyFactory : public IRetryPolicyFactory {
- private:
-  const RetryDuration start_;
-  const RetryDuration maxWait_;
-  const uint64_t maxRetries_;
-  const RetryDuration maxTotal_;
-
  public:
   ExponentialBackoffPolicyFactory(
       RetryDuration start,
       RetryDuration maxWait,
       uint64_t maxRetries = std::numeric_limits<uint64_t>::max(),
-      RetryDuration maxTotal = RetryDuration::zero())
+      RetryDuration maxTotal = RetryDuration::zero(),
+      bool countExecutionTime = false)
       : start_(start),
         maxWait_(maxWait),
         maxRetries_(maxRetries),
-        maxTotal_(maxTotal) {}
+        maxTotal_(maxTotal),
+        countExecutionTime_(countExecutionTime) {}
 
   std::unique_ptr<IRetryPolicy> getRetryPolicy() const {
     return std::make_unique<ExponentialBackoff>(
-        start_, maxWait_, maxRetries_, maxTotal_);
+        start_, maxWait_, maxRetries_, maxTotal_, countExecutionTime_);
   }
+
+ private:
+  const RetryDuration start_;
+  const RetryDuration maxWait_;
+  const uint64_t maxRetries_;
+  const RetryDuration maxTotal_;
+  const bool countExecutionTime_;
 };
 
 } // namespace retrypolicy
@@ -174,6 +192,7 @@ class RetryModule {
       F func,
       std::unique_ptr<retrypolicy::IRetryPolicy> policy,
       std::function<bool()> abortFunc = nullptr) {
+    policy->start();
     do {
       try {
         // If abort signal is triggered before func, no ops.
diff --git a/velox/dwio/common/ScanSpec.cpp b/velox/dwio/common/ScanSpec.cpp
index 4845b3242a773..a37cbc98ec6ab 100644
--- a/velox/dwio/common/ScanSpec.cpp
+++ b/velox/dwio/common/ScanSpec.cpp
@@ -19,52 +19,31 @@
 
 namespace facebook::velox::common {
 
-ScanSpec& ScanSpec::operator=(const ScanSpec& other) {
-  if (this != &other) {
-    numReads_ = other.numReads_;
-    subscript_ = other.subscript_;
-    fieldName_ = other.fieldName_;
-    channel_ = other.channel_;
-    constantValue_ = other.constantValue_;
-    projectOut_ = other.projectOut_;
-    extractValues_ = other.extractValues_;
-    makeFlat_ = other.makeFlat_;
-    filter_ = other.filter_;
-    metadataFilters_ = other.metadataFilters_;
-    selectivity_ = other.selectivity_;
-    enableFilterReorder_ = other.enableFilterReorder_;
-    children_ = other.children_;
-    stableChildren_ = other.stableChildren_;
-    childByFieldName_ = other.childByFieldName_;
-    valueHook_ = other.valueHook_;
-    isArrayElementOrMapEntry_ = other.isArrayElementOrMapEntry_;
-    maxArrayElementsCount_ = other.maxArrayElementsCount_;
-  }
-  return *this;
+ScanSpec* ScanSpec::getOrCreateChild(const std::string& name) {
+  if (auto it = this->childByFieldName_.find(name);
+      it != this->childByFieldName_.end()) {
+    return it->second;
+  }
+  this->children_.push_back(std::make_unique<ScanSpec>(name));
+  auto* child = this->children_.back().get();
+  this->childByFieldName_[child->fieldName()] = child;
+  return child;
 }
 
 ScanSpec* ScanSpec::getOrCreateChild(const Subfield& subfield) {
-  auto container = this;
-  auto& path = subfield.path();
+  auto* container = this;
+  const auto& path = subfield.path();
   for (size_t depth = 0; depth < path.size(); ++depth) {
-    auto element = path[depth].get();
+    const auto element = path[depth].get();
     VELOX_CHECK_EQ(element->kind(), kNestedField);
     auto* nestedField = static_cast<const Subfield::NestedField*>(element);
-    auto it = container->childByFieldName_.find(nestedField->name());
-    if (it != container->childByFieldName_.end()) {
-      container = it->second;
-    } else {
-      container->children_.push_back(std::make_unique<ScanSpec>(*element));
-      auto* child = container->children_.back().get();
-      container->childByFieldName_[child->fieldName()] = child;
-      container = child;
-    }
+    container = container->getOrCreateChild(nestedField->name());
   }
   return container;
 }
 
 uint64_t ScanSpec::newRead() {
-  if (!numReads_) {
+  if (numReads_ == 0) {
     reorder();
   } else if (enableFilterReorder_) {
     for (auto i = 1; i < children_.size(); ++i) {
@@ -78,13 +57,14 @@ uint64_t ScanSpec::newRead() {
       }
     }
   }
-  return numReads_++;
+  return ++numReads_;
 }
 
 void ScanSpec::reorder() {
   if (children_.empty()) {
     return;
   }
+
   // Make sure 'stableChildren_' is initialized.
   stableChildren();
   std::sort(
@@ -153,36 +133,34 @@ bool ScanSpec::hasFilter() const {
   return false;
 }
 
+bool ScanSpec::testNull() const {
+  if (filter_ && !filter_->testNull()) {
+    return false;
+  }
+  for (auto& child : children_) {
+    if (!child->isArrayElementOrMapEntry_ && !child->testNull()) {
+      return false;
+    }
+  }
+  return true;
+}
+
 void ScanSpec::moveAdaptationFrom(ScanSpec& other) {
   // moves the filters and filter order from 'other'.
-  std::vector<std::shared_ptr<ScanSpec>> newChildren;
-  childByFieldName_.clear();
-  for (auto& otherChild : other.children_) {
-    bool found = false;
-    for (auto& child : children_) {
-      if (child && child->fieldName_ == otherChild->fieldName_) {
-        if (!child->isConstant() && !otherChild->isConstant()) {
-          // If other child is constant, a possible filter on a
-          // constant will have been evaluated at split start time. If
-          // 'child' is constant there is no adaptation that can be
-          // received.
-          child->filter_ = std::move(otherChild->filter_);
-          child->selectivity_ = otherChild->selectivity_;
-        }
-        childByFieldName_[child->fieldName_] = child.get();
-        newChildren.push_back(std::move(child));
-        found = true;
-        break;
-      }
+  for (auto& child : children_) {
+    auto it = other.childByFieldName_.find(child->fieldName_);
+    if (it == other.childByFieldName_.end()) {
+      continue;
+    }
+    auto* otherChild = it->second;
+    if (!child->isConstant() && !otherChild->isConstant()) {
+      // If other child is constant, a possible filter on a
+      // constant will have been evaluated at split start time. If
+      // 'child' is constant there is no adaptation that can be
+      // received.
+      child->filter_ = std::move(otherChild->filter_);
+      child->selectivity_ = otherChild->selectivity_;
     }
-    VELOX_CHECK(found);
-  }
-  children_ = std::move(newChildren);
-  stableChildren_.clear();
-  for (auto& otherChild : other.stableChildren_) {
-    auto child = childByName(otherChild->fieldName_);
-    VELOX_CHECK(child);
-    stableChildren_.push_back(child);
   }
 }
 
@@ -290,8 +268,8 @@ bool testStringFilter(
 bool testBoolFilter(
     common::Filter* filter,
     dwio::common::BooleanColumnStatistics* boolStats) {
-  auto trueCount = boolStats->getTrueCount();
-  auto falseCount = boolStats->getFalseCount();
+  const auto trueCount = boolStats->getTrueCount();
+  const auto falseCount = boolStats->getFalseCount();
   if (trueCount.has_value() && falseCount.has_value()) {
     if (trueCount.value() == 0) {
       if (!filter->testBool(false)) {
@@ -313,7 +291,7 @@ bool testFilter(
     dwio::common::ColumnStatistics* stats,
     uint64_t totalRows,
     const TypePtr& type) {
-  bool mayHaveNull = true;
+  bool mayHaveNull{true};
 
   // Has-null statistics is often not set. Hence, we supplement it with
   // number-of-values statistic to detect no-null columns more often.
@@ -331,6 +309,7 @@ bool testFilter(
     // IS NULL filter cannot pass.
     return false;
   }
+
   if (mayHaveNull && filter->testNull()) {
     return true;
   }
@@ -342,23 +321,23 @@ bool testFilter(
     case TypeKind::INTEGER:
     case TypeKind::SMALLINT:
     case TypeKind::TINYINT: {
-      auto intStats =
+      auto* intStats =
           dynamic_cast<dwio::common::IntegerColumnStatistics*>(stats);
       return testIntFilter(filter, intStats, mayHaveNull);
     }
     case TypeKind::REAL:
     case TypeKind::DOUBLE: {
-      auto doubleStats =
+      auto* doubleStats =
           dynamic_cast<dwio::common::DoubleColumnStatistics*>(stats);
       return testDoubleFilter(filter, doubleStats, mayHaveNull);
     }
     case TypeKind::BOOLEAN: {
-      auto boolStats =
+      auto* boolStats =
           dynamic_cast<dwio::common::BooleanColumnStatistics*>(stats);
       return testBoolFilter(filter, boolStats);
     }
     case TypeKind::VARCHAR: {
-      auto stringStats =
+      auto* stringStats =
           dynamic_cast<dwio::common::StringColumnStatistics*>(stats);
       return testStringFilter(filter, stringStats, mayHaveNull);
     }
@@ -402,24 +381,12 @@ std::string ScanSpec::toString() const {
   return out.str();
 }
 
-std::shared_ptr<ScanSpec> ScanSpec::removeChild(const ScanSpec* child) {
-  for (auto it = children_.begin(); it != children_.end(); ++it) {
-    if (it->get() == child) {
-      auto removed = std::move(*it);
-      children_.erase(it);
-      childByFieldName_.erase(removed->fieldName());
-      return removed;
-    }
-  }
-  return nullptr;
-}
-
 void ScanSpec::addFilter(const Filter& filter) {
   filter_ = filter_ ? filter_->mergeWith(&filter) : filter.clone();
 }
 
 ScanSpec* ScanSpec::addField(const std::string& name, column_index_t channel) {
-  auto child = getOrCreateChild(Subfield(name));
+  auto child = getOrCreateChild(name);
   child->setProjectOut(true);
   child->setChannel(channel);
   return child;
diff --git a/velox/dwio/common/ScanSpec.h b/velox/dwio/common/ScanSpec.h
index e03b33963d0c8..14f4db86b9f93 100644
--- a/velox/dwio/common/ScanSpec.h
+++ b/velox/dwio/common/ScanSpec.h
@@ -44,24 +44,8 @@ class ScanSpec {
   static constexpr const char* kMapValuesFieldName = "values";
   static constexpr const char* kArrayElementsFieldName = "elements";
 
-  explicit ScanSpec(const Subfield::PathElement& element) {
-    if (element.kind() == kNestedField) {
-      auto field = reinterpret_cast<const Subfield::NestedField*>(&element);
-      fieldName_ = field->name();
-
-    } else {
-      VELOX_CHECK(false, "Only nested fields are supported");
-    }
-  }
-
   explicit ScanSpec(const std::string& name) : fieldName_(name) {}
 
-  ScanSpec(const ScanSpec& other) {
-    *this = other;
-  }
-
-  ScanSpec& operator=(const ScanSpec&);
-
   // Filter to apply. If 'this' corresponds to a struct/list/map, this
   // can only be isNull or isNotNull, other filtering is given by
   // 'children'.
@@ -117,6 +101,14 @@ class ScanSpec {
     return constantValue_ != nullptr;
   }
 
+  void setExplicitRowNumber(bool isExplicitRowNumber) {
+    isExplicitRowNumber_ = isExplicitRowNumber;
+  }
+
+  bool isExplicitRowNumber() const {
+    return isExplicitRowNumber_;
+  }
+
   // Name of the value in its container, i.e. field name in struct or
   // string key in map. Not all fields of 'this' apply in list/map
   // value cases but the overhead is manageable, the space taken is
@@ -202,6 +194,10 @@ class ScanSpec {
   // each level of struct is mandatory.
   uint64_t newRead();
 
+  /// Returns the ScanSpec corresponding to 'name'. Creates it if needed without
+  /// any intermediate level.
+  ScanSpec* getOrCreateChild(const std::string& name);
+
   // Returns the ScanSpec corresponding to 'subfield'. Creates it if
   // needed, including any intermediate levels. This is used at
   // TableScan initialization to create the ScanSpec tree that
@@ -216,10 +212,6 @@ class ScanSpec {
     return it->second;
   }
 
-  // Remove a child from this scan spec, returning the removed child.  This is
-  // used for example to transform a flatmap scan spec into a struct scan spec.
-  std::shared_ptr<ScanSpec> removeChild(const ScanSpec* child);
-
   SelectivityInfo& selectivity() {
     return selectivity_;
   }
@@ -232,9 +224,11 @@ class ScanSpec {
     valueHook_ = valueHook;
   }
 
-  // Returns true if the corresponding reader only needs to reference
-  // the nulls stream. True if filter is is-null with or without value
-  // extraction or if filter is is-not-null and no value is extracted.
+  // Returns true if the corresponding reader only needs to reference the nulls
+  // stream.  True if filter is is-null with or without value extraction or if
+  // filter is is-not-null and no value is extracted.  Note that this does not
+  // apply to Nimble format leaf nodes, because nulls are mixed in the encoding
+  // with actual values.
   bool readsNullsOnly() const {
     if (filter_) {
       if (filter_->kind() == FilterKind::kIsNull) {
@@ -263,6 +257,12 @@ class ScanSpec {
   // This may change as a result of runtime adaptation.
   bool hasFilter() const;
 
+  /// Assume this field is read as null constant vector (usually due to missing
+  /// field), check if any filter in the struct subtree would make the whole
+  /// vector to be filtered out.  Return false when the whole vector should be
+  /// filtered out.
+  bool testNull() const;
+
   // Resets cached values after this or children were updated, e.g. a new filter
   // was added or existing filter was modified.
   void resetCachedValues(bool doReorder) {
@@ -324,6 +324,26 @@ class ScanSpec {
   // projected out.
   void addAllChildFields(const Type&);
 
+  const std::vector<std::string>& flatMapFeatureSelection() const {
+    return flatMapFeatureSelection_;
+  }
+
+  void setFlatMapFeatureSelection(std::vector<std::string> features) {
+    flatMapFeatureSelection_ = std::move(features);
+  }
+
+  /// Invoke the function provided on each node of the ScanSpec tree.
+  template <typename F>
+  void visit(const Type& type, F&& f);
+
+  bool isFlatMapAsStruct() const {
+    return isFlatMapAsStruct_;
+  }
+
+  void setFlatMapAsStruct(bool value) {
+    isFlatMapAsStruct_ = value;
+  }
+
  private:
   void reorder();
 
@@ -351,10 +371,12 @@ class ScanSpec {
   VectorPtr constantValue_;
   bool projectOut_ = false;
   bool extractValues_ = false;
+
+  bool isExplicitRowNumber_ = false;
   // True if a string dictionary or flat map in this field should be
   // returned as flat.
   bool makeFlat_ = false;
-  std::shared_ptr<common::Filter> filter_;
+  std::unique_ptr<common::Filter> filter_;
 
   // Filters that will be only used for row group filtering based on metadata.
   // The conjunctions among these filters are tracked in MetadataFilter, with
@@ -400,8 +422,44 @@ class ScanSpec {
   // Only take the first maxArrayElementsCount_ elements from each array.
   vector_size_t maxArrayElementsCount_ =
       std::numeric_limits<vector_size_t>::max();
+
+  // Used only for bulk reader to project flat map features.
+  std::vector<std::string> flatMapFeatureSelection_;
+
+  // This node represents a flat map column that need to be read as struct,
+  // i.e. in table schema it is a MAP, but in result vector it is ROW.
+  bool isFlatMapAsStruct_ = false;
 };
 
+template <typename F>
+void ScanSpec::visit(const Type& type, F&& f) {
+  f(type, *this);
+  if (isConstant()) {
+    // Child specs are not populated in this case.
+    return;
+  }
+  switch (type.kind()) {
+    case TypeKind::ROW:
+      for (auto& child : children_) {
+        VELOX_CHECK_NE(child->channel(), kNoChannel);
+        child->visit(*type.childAt(child->channel()), std::forward<F>(f));
+      }
+      break;
+    case TypeKind::MAP:
+      childByName(kMapKeysFieldName)
+          ->visit(*type.childAt(0), std::forward<F>(f));
+      childByName(kMapValuesFieldName)
+          ->visit(*type.childAt(1), std::forward<F>(f));
+      break;
+    case TypeKind::ARRAY:
+      childByName(kArrayElementsFieldName)
+          ->visit(*type.childAt(0), std::forward<F>(f));
+      break;
+    default:
+      break;
+  }
+}
+
 // Returns false if no value from a range defined by stats can pass the
 // filter. True, otherwise.
 bool testFilter(
diff --git a/velox/dwio/common/SeekableInputStream.cpp b/velox/dwio/common/SeekableInputStream.cpp
index 5a514e50c8f95..7773445dea5d3 100644
--- a/velox/dwio/common/SeekableInputStream.cpp
+++ b/velox/dwio/common/SeekableInputStream.cpp
@@ -37,7 +37,7 @@ void printBuffer(std::ostream& out, const char* buffer, uint64_t length) {
 }
 
 uint64_t PositionProvider::next() {
-  uint64_t result = *position_;
+  const uint64_t result = *position_;
   ++position_;
   return result;
 }
@@ -47,18 +47,18 @@ bool PositionProvider::hasNext() const {
 }
 
 void SeekableInputStream::readFully(char* buffer, size_t bufferSize) {
-  size_t posn = 0;
+  size_t pos = 0;
   size_t readLength = 0;
   size_t bytesToCopy = 0;
-  while (posn < bufferSize) {
+  while (pos < bufferSize) {
     const void* chunk;
     int32_t length;
-    DWIO_ENSURE(Next(&chunk, &length), "bad read in readFully");
+    VELOX_CHECK(Next(&chunk, &length), "bad read in readFully");
     readLength = static_cast<size_t>(length);
-    bytesToCopy = std::min(readLength, bufferSize - posn);
-    auto bytes = reinterpret_cast<const char*>(chunk);
-    std::copy(bytes, bytes + bytesToCopy, buffer + posn);
-    posn += bytesToCopy;
+    bytesToCopy = std::min(readLength, bufferSize - pos);
+    auto* bytes = reinterpret_cast<const char*>(chunk);
+    std::copy(bytes, bytes + bytesToCopy, buffer + pos);
+    pos += bytesToCopy;
   }
   // return remaining bytes back to stream
   if (bytesToCopy < readLength) {
@@ -70,64 +70,67 @@ SeekableArrayInputStream::SeekableArrayInputStream(
     const unsigned char* values,
     uint64_t size,
     uint64_t blkSize)
-    : data(reinterpret_cast<const char*>(values)), dataRead{nullptr} {
-  length = size;
-  position = 0;
-  blockSize = blkSize == 0 ? length : blkSize;
+    : data_(reinterpret_cast<const char*>(values)), dataRead_{nullptr} {
+  length_ = size;
+  position_ = 0;
+  blockSize_ = blkSize == 0 ? length_ : blkSize;
 }
 
 SeekableArrayInputStream::SeekableArrayInputStream(
     const char* values,
     uint64_t size,
     uint64_t blkSize)
-    : data(values), dataRead{nullptr} {
-  length = size;
-  position = 0;
-  blockSize = blkSize == 0 ? length : blkSize;
+    : data_(values), dataRead_{nullptr} {
+  length_ = size;
+  position_ = 0;
+  blockSize_ = blkSize == 0 ? length_ : blkSize;
 }
 
 SeekableArrayInputStream::SeekableArrayInputStream(
     std::unique_ptr<char[]> values,
     uint64_t size,
     uint64_t blkSize)
-    : ownedData(std::move(values)), data(ownedData.get()), dataRead{nullptr} {
-  length = size;
-  position = 0;
-  blockSize = blkSize == 0 ? length : blkSize;
+    : ownedData_(std::move(values)),
+      data_(ownedData_.get()),
+      dataRead_{nullptr} {
+  length_ = size;
+  position_ = 0;
+  blockSize_ = blkSize == 0 ? length_ : blkSize;
 }
 
 SeekableArrayInputStream::SeekableArrayInputStream(
     std::function<std::tuple<const char*, uint64_t>()> read,
     uint64_t blkSize)
-    : data(nullptr), dataRead{read} {
-  position = 0;
-  length = 0;
-  blockSize = blkSize;
+    : data_(nullptr), dataRead_{std::move(read)} {
+  position_ = 0;
+  length_ = 0;
+  blockSize_ = blkSize;
 }
 
 void SeekableArrayInputStream::loadIfAvailable() {
-  if (UNLIKELY(!!dataRead)) {
-    const auto result = dataRead();
-    auto size = std::get<1>(result);
-    DWIO_ENSURE_LT(size, MAX_UINT64, "invalid data size");
-    data = std::get<0>(result);
-    length = size;
-    if (blockSize == 0) {
-      blockSize = length;
-    }
-
-    // just load once
-    dataRead = nullptr;
+  if (FOLLY_LIKELY(dataRead_ == nullptr)) {
+    return;
+  }
+  const auto result = dataRead_();
+  auto size = std::get<1>(result);
+  VELOX_CHECK_LT(size, MAX_UINT64, "invalid data size");
+  data_ = std::get<0>(result);
+  length_ = size;
+  if (blockSize_ == 0) {
+    blockSize_ = length_;
   }
+  // just load once
+  dataRead_ = nullptr;
 }
 
 bool SeekableArrayInputStream::Next(const void** buffer, int32_t* size) {
   loadIfAvailable();
-  uint64_t currentSize = std::min(length - position, blockSize);
+  const uint64_t currentSize = std::min(length_ - position_, blockSize_);
   if (currentSize > 0) {
-    *buffer = data + position;
+    *buffer = data_ + position_;
     *size = static_cast<int32_t>(currentSize);
-    position += currentSize;
+    position_ += currentSize;
+    totalRead_ += currentSize;
     return true;
   }
 
@@ -139,40 +142,38 @@ void SeekableArrayInputStream::BackUp(int32_t count) {
   loadIfAvailable();
 
   if (count >= 0) {
-    uint64_t unsignedCount = static_cast<uint64_t>(count);
-    DWIO_ENSURE(
-        unsignedCount <= blockSize && unsignedCount <= position,
-        "Can't backup that much!");
-    position -= unsignedCount;
+    const uint64_t unsignedCount = static_cast<uint64_t>(count);
+    VELOX_CHECK_LE(unsignedCount, blockSize_, "Can't backup that much!");
+    VELOX_CHECK_LE(unsignedCount, position_, "Can't backup that much!");
+    position_ -= unsignedCount;
   }
 }
 
-bool SeekableArrayInputStream::Skip(int32_t count) {
+bool SeekableArrayInputStream::SkipInt64(int64_t count) {
   loadIfAvailable();
 
   if (count >= 0) {
-    uint64_t unsignedCount = static_cast<uint64_t>(count);
-    if (unsignedCount + position <= length) {
-      position += unsignedCount;
+    const uint64_t unsignedCount = static_cast<uint64_t>(count);
+    if (unsignedCount + position_ <= length_) {
+      position_ += unsignedCount;
       return true;
-    } else {
-      position = length;
     }
+    position_ = length_;
   }
   return false;
 }
 
 google::protobuf::int64 SeekableArrayInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(position);
+  return static_cast<google::protobuf::int64>(position_);
 }
 
 void SeekableArrayInputStream::seekToPosition(PositionProvider& position) {
-  this->position = position.next();
+  position_ = position.next();
 }
 
 std::string SeekableArrayInputStream::getName() const {
   return folly::to<std::string>(
-      "SeekableArrayInputStream ", position, " of ", length);
+      "SeekableArrayInputStream ", position_, " of ", length_);
 }
 
 size_t SeekableArrayInputStream::positionSize() {
@@ -188,71 +189,72 @@ SeekableFileInputStream::SeekableFileInputStream(
     std::shared_ptr<ReadFileInputStream> input,
     uint64_t offset,
     uint64_t byteCount,
-    memory::MemoryPool& _pool,
+    memory::MemoryPool& pool,
     LogType logType,
-    uint64_t _blockSize)
-    : pool(_pool),
-      input(std::move(input)),
-      logType(logType),
-      start(offset),
-      length(byteCount),
-      blockSize(computeBlock(_blockSize, length)),
-      buffer{pool} {
-  position = 0;
-  pushBack = 0;
+    uint64_t blockSize)
+    : input_(std::move(input)),
+      logType_(logType),
+      start_(offset),
+      length_(byteCount),
+      blockSize_(computeBlock(blockSize, length_)),
+      pool_(&pool),
+      buffer_{pool} {
+  position_ = 0;
+  pushback_ = 0;
 }
 
 bool SeekableFileInputStream::Next(const void** data, int32_t* size) {
   uint64_t bytesRead;
-  if (pushBack != 0) {
-    *data = buffer.data() + (buffer.size() - pushBack);
-    bytesRead = pushBack;
+  if (pushback_ != 0) {
+    *data = buffer_.data() + (buffer_.size() - pushback_);
+    bytesRead = pushback_;
   } else {
-    bytesRead = std::min(length - position, blockSize);
-    buffer.resize(bytesRead);
+    bytesRead = std::min(length_ - position_, blockSize_);
+    buffer_.resize(bytesRead);
     if (bytesRead > 0) {
-      input->read(buffer.data(), bytesRead, start + position, logType);
-      *data = static_cast<void*>(buffer.data());
+      input_->read(buffer_.data(), bytesRead, start_ + position_, logType_);
+      *data = static_cast<void*>(buffer_.data());
     }
   }
-  position += bytesRead;
-  pushBack = 0;
+  position_ += bytesRead;
+  pushback_ = 0;
   *size = static_cast<int32_t>(bytesRead);
   return bytesRead != 0;
 }
 
 void SeekableFileInputStream::BackUp(int32_t signedCount) {
-  DWIO_ENSURE_GE(signedCount, 0, "can't backup negative distances");
-  uint64_t count = static_cast<uint64_t>(signedCount);
-  DWIO_ENSURE_EQ(pushBack, 0, "can't backup unless we just called Next");
-  DWIO_ENSURE(count <= blockSize && count <= position, "can't backup that far");
-  pushBack = static_cast<uint64_t>(count);
-  position -= pushBack;
+  VELOX_CHECK_GE(signedCount, 0, "can't backup negative distances");
+  VELOX_CHECK_EQ(pushback_, 0, "can't backup unless we just called Next");
+  const uint64_t count = static_cast<uint64_t>(signedCount);
+  VELOX_CHECK_LE(count, blockSize_, "can't backup that far");
+  VELOX_CHECK_LE(count, position_, "can't backup that far");
+  pushback_ = static_cast<uint64_t>(count);
+  position_ -= pushback_;
 }
 
-bool SeekableFileInputStream::Skip(int32_t signedCount) {
+bool SeekableFileInputStream::SkipInt64(int64_t signedCount) {
   if (signedCount < 0) {
     return false;
   }
-  uint64_t count = static_cast<uint64_t>(signedCount);
-  position = std::min(position + count, length);
-  pushBack = 0;
-  return position < length;
+  const uint64_t count = static_cast<uint64_t>(signedCount);
+  position_ = std::min(position_ + count, length_);
+  pushback_ = 0;
+  return position_ < length_;
 }
 
 google::protobuf::int64 SeekableFileInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(position);
+  return static_cast<google::protobuf::int64>(position_);
 }
 
 void SeekableFileInputStream::seekToPosition(PositionProvider& location) {
-  position = location.next();
-  DWIO_ENSURE_LE(position, length, "seek too far");
-  pushBack = 0;
+  position_ = location.next();
+  VELOX_CHECK_LE(position_, length_, "seek too far");
+  pushback_ = 0;
 }
 
 std::string SeekableFileInputStream::getName() const {
   return folly::to<std::string>(
-      input->getName(), " from ", start, " for ", length);
+      input_->getName(), " from ", start_, " for ", length_);
 }
 
 size_t SeekableFileInputStream::positionSize() {
diff --git a/velox/dwio/common/SeekableInputStream.h b/velox/dwio/common/SeekableInputStream.h
index 53bdb0b1fb4cc..ab402753b8c56 100644
--- a/velox/dwio/common/SeekableInputStream.h
+++ b/velox/dwio/common/SeekableInputStream.h
@@ -16,30 +16,15 @@
 
 #pragma once
 
-#include <vector>
-
 #include "velox/dwio/common/DataBuffer.h"
 #include "velox/dwio/common/InputStream.h"
+#include "velox/dwio/common/PositionProvider.h"
 #include "velox/dwio/common/wrap/zero-copy-stream-wrapper.h"
 
 namespace facebook::velox::dwio::common {
 
 void printBuffer(std::ostream& out, const char* buffer, uint64_t length);
 
-class PositionProvider {
- public:
-  explicit PositionProvider(const std::vector<uint64_t>& positions)
-      : position_{positions.begin()}, end_{positions.end()} {}
-
-  uint64_t next();
-
-  bool hasNext() const;
-
- private:
-  std::vector<uint64_t>::const_iterator position_;
-  std::vector<uint64_t>::const_iterator end_;
-};
-
 /**
  * A subclass of Google's ZeroCopyInputStream that supports seek.
  * By extending Google's class, we get the ability to pass it directly
@@ -57,6 +42,12 @@ class SeekableInputStream : public google::protobuf::io::ZeroCopyInputStream {
   // ORC/DWRF stream address.
   virtual size_t positionSize() = 0;
 
+  virtual bool SkipInt64(int64_t count) = 0;
+
+  bool Skip(int32_t count) final override {
+    return SkipInt64(count);
+  }
+
   void readFully(char* buffer, size_t bufferSize);
 };
 
@@ -64,16 +55,6 @@ class SeekableInputStream : public google::protobuf::io::ZeroCopyInputStream {
  * Create a seekable input stream based on a memory range.
  */
 class SeekableArrayInputStream : public SeekableInputStream {
- private:
-  // data may optionally be owned by *this via ownedData.
-  std::unique_ptr<char[]> ownedData;
-  const char* data;
-  std::function<std::tuple<const char*, uint64_t>()> dataRead;
-  uint64_t length;
-  uint64_t position;
-  uint64_t blockSize;
-  void loadIfAvailable();
-
  public:
   SeekableArrayInputStream(
       const unsigned char* list,
@@ -94,30 +75,38 @@ class SeekableArrayInputStream : public SeekableInputStream {
       uint64_t block_size = 0);
 
   ~SeekableArrayInputStream() override = default;
+
   virtual bool Next(const void** data, int32_t* size) override;
   virtual void BackUp(int32_t count) override;
-  virtual bool Skip(int32_t count) override;
+  virtual bool SkipInt64(int64_t count) override;
   virtual google::protobuf::int64 ByteCount() const override;
   virtual void seekToPosition(PositionProvider& position) override;
   virtual std::string getName() const override;
   virtual size_t positionSize() override;
+
+  /// Return the total number of bytes returned from Next() calls.  Intended to
+  /// be used for test validation.
+  int64_t totalRead() const {
+    return totalRead_;
+  }
+
+ private:
+  void loadIfAvailable();
+
+  // data may optionally be owned by *this via ownedData.
+  const std::unique_ptr<char[]> ownedData_;
+  const char* data_;
+  std::function<std::tuple<const char*, uint64_t>()> dataRead_;
+  uint64_t length_;
+  uint64_t position_;
+  uint64_t blockSize_;
+  int64_t totalRead_ = 0;
 };
 
 /**
  * Create a seekable input stream based on an io stream.
  */
 class SeekableFileInputStream : public SeekableInputStream {
- private:
-  memory::MemoryPool& pool;
-  std::shared_ptr<ReadFileInputStream> input;
-  LogType logType;
-  const uint64_t start;
-  const uint64_t length;
-  const uint64_t blockSize;
-  DataBuffer<char> buffer;
-  uint64_t position;
-  uint64_t pushBack;
-
  public:
   SeekableFileInputStream(
       std::shared_ptr<ReadFileInputStream> input,
@@ -130,11 +119,23 @@ class SeekableFileInputStream : public SeekableInputStream {
 
   virtual bool Next(const void** data, int32_t* size) override;
   virtual void BackUp(int32_t count) override;
-  virtual bool Skip(int32_t count) override;
+  virtual bool SkipInt64(int64_t count) override;
   virtual google::protobuf::int64 ByteCount() const override;
   virtual void seekToPosition(PositionProvider& position) override;
   virtual std::string getName() const override;
   virtual size_t positionSize() override;
+
+ private:
+  const std::shared_ptr<ReadFileInputStream> input_;
+  const LogType logType_;
+  const uint64_t start_;
+  const uint64_t length_;
+  const uint64_t blockSize_;
+  memory::MemoryPool* const pool_;
+
+  DataBuffer<char> buffer_;
+  uint64_t position_;
+  uint64_t pushback_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveByteRleColumnReader.cpp b/velox/dwio/common/SelectiveByteRleColumnReader.cpp
index e649a1d425f0f..97b00a71e1535 100644
--- a/velox/dwio/common/SelectiveByteRleColumnReader.cpp
+++ b/velox/dwio/common/SelectiveByteRleColumnReader.cpp
@@ -18,7 +18,9 @@
 
 namespace facebook::velox::dwio::common {
 
-void SelectiveByteRleColumnReader::getValues(RowSet rows, VectorPtr* result) {
+void SelectiveByteRleColumnReader::getValues(
+    const RowSet& rows,
+    VectorPtr* result) {
   switch (requestedType_->kind()) {
     case TypeKind::BOOLEAN:
       getFlatValues<int8_t, bool>(rows, result, requestedType_);
diff --git a/velox/dwio/common/SelectiveByteRleColumnReader.h b/velox/dwio/common/SelectiveByteRleColumnReader.h
index ed9a7e050dca3..43b5e3181bda0 100644
--- a/velox/dwio/common/SelectiveByteRleColumnReader.h
+++ b/velox/dwio/common/SelectiveByteRleColumnReader.h
@@ -24,29 +24,33 @@ class SelectiveByteRleColumnReader : public SelectiveColumnReader {
  public:
   SelectiveByteRleColumnReader(
       const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       dwio::common::FormatParams& params,
-      velox::common::ScanSpec& scanSpec,
-      std::shared_ptr<const dwio::common::TypeWithId> type)
+      velox::common::ScanSpec& scanSpec)
       : SelectiveColumnReader(
             requestedType,
+            std::move(fileType),
             params,
-            scanSpec,
-            std::move(type)) {}
+            scanSpec) {}
 
   bool hasBulkPath() const override {
     return false;
   }
 
-  void getValues(RowSet rows, VectorPtr* result) override;
+  void getValues(const RowSet& rows, VectorPtr* result) override;
 
-  template <typename Reader, bool isDense, typename ExtractValues>
+  template <
+      typename Reader,
+      bool isDense,
+      bool kEncodingHasNulls,
+      typename ExtractValues>
   void processFilter(
       velox::common::Filter* filter,
       ExtractValues extractValues,
-      RowSet rows);
+      const RowSet& rows);
 
   template <typename Reader, bool isDense>
-  void processValueHook(RowSet rows, ValueHook* hook);
+  void processValueHook(const RowSet& rows, ValueHook* hook);
 
   template <
       typename Reader,
@@ -55,12 +59,14 @@ class SelectiveByteRleColumnReader : public SelectiveColumnReader {
       typename ExtractValues>
   void readHelper(
       velox::common::Filter* filter,
-      RowSet rows,
+      const RowSet& rows,
       ExtractValues extractValues);
 
-  template <typename Reader>
-  void
-  readCommon(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls);
+  template <typename Reader, bool kEncodingHasNulls>
+  void readCommon(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls);
 };
 
 template <
@@ -70,7 +76,7 @@ template <
     typename ExtractValues>
 void SelectiveByteRleColumnReader::readHelper(
     velox::common::Filter* filter,
-    RowSet rows,
+    const RowSet& rows,
     ExtractValues extractValues) {
   reinterpret_cast<Reader*>(this)->readWithVisitor(
       rows,
@@ -78,11 +84,15 @@ void SelectiveByteRleColumnReader::readHelper(
           *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
 }
 
-template <typename Reader, bool isDense, typename ExtractValues>
+template <
+    typename Reader,
+    bool isDense,
+    bool kEncodingHasNulls,
+    typename ExtractValues>
 void SelectiveByteRleColumnReader::processFilter(
     velox::common::Filter* filter,
     ExtractValues extractValues,
-    RowSet rows) {
+    const RowSet& rows) {
   using velox::common::FilterKind;
   switch (filter ? filter->kind() : FilterKind::kAlwaysTrue) {
     case FilterKind::kAlwaysTrue:
@@ -90,13 +100,20 @@ void SelectiveByteRleColumnReader::processFilter(
           filter, rows, extractValues);
       break;
     case FilterKind::kIsNull:
-      filterNulls<int8_t>(
-          rows,
-          true,
-          !std::is_same_v<decltype(extractValues), dwio::common::DropValues>);
+      if constexpr (kEncodingHasNulls) {
+        filterNulls<int8_t>(
+            rows,
+            true,
+            !std::is_same_v<decltype(extractValues), dwio::common::DropValues>);
+      } else {
+        readHelper<Reader, velox::common::IsNull, isDense>(
+            filter, rows, extractValues);
+      }
       break;
     case FilterKind::kIsNotNull:
-      if (std::is_same_v<decltype(extractValues), dwio::common::DropValues>) {
+      if constexpr (
+          kEncodingHasNulls &&
+          std::is_same_v<decltype(extractValues), dwio::common::DropValues>) {
         filterNulls<int8_t>(rows, false, false);
       } else {
         readHelper<Reader, velox::common::IsNotNull, isDense>(
@@ -130,31 +147,27 @@ void SelectiveByteRleColumnReader::processFilter(
 
 template <typename Reader, bool isDense>
 void SelectiveByteRleColumnReader::processValueHook(
-    RowSet rows,
+    const RowSet& rows,
     ValueHook* hook) {
   using namespace facebook::velox::aggregate;
   switch (hook->kind()) {
-    case aggregate::AggregationHook::kSumBigintToBigint:
+    case aggregate::AggregationHook::kBigintSum:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
-          &dwio::common::alwaysTrue(),
-          rows,
-          dwio::common::ExtractToHook<SumHook<int64_t, int64_t>>(hook));
+          &alwaysTrue(), rows, ExtractToHook<SumHook<int64_t>>(hook));
       break;
     default:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
-          &dwio::common::alwaysTrue(),
-          rows,
-          dwio::common::ExtractToGenericHook(hook));
+          &alwaysTrue(), rows, ExtractToGenericHook(hook));
   }
 }
 
-template <typename Reader>
+template <typename Reader, bool kEncodingHasNulls>
 void SelectiveByteRleColumnReader::readCommon(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   prepareRead<int8_t>(offset, rows, incomingNulls);
-  bool isDense = rows.back() == rows.size() - 1;
+  const bool isDense = rows.back() == rows.size() - 1;
   velox::common::Filter* filter =
       scanSpec_->filter() ? scanSpec_->filter() : &dwio::common::alwaysTrue();
   if (scanSpec_->keepValues()) {
@@ -167,17 +180,19 @@ void SelectiveByteRleColumnReader::readCommon(
       return;
     }
     if (isDense) {
-      processFilter<Reader, true>(
+      processFilter<Reader, true, kEncodingHasNulls>(
           filter, dwio::common::ExtractToReader(this), rows);
     } else {
-      processFilter<Reader, false>(
+      processFilter<Reader, false, kEncodingHasNulls>(
           filter, dwio::common::ExtractToReader(this), rows);
     }
   } else {
     if (isDense) {
-      processFilter<Reader, true>(filter, dwio::common::DropValues(), rows);
+      processFilter<Reader, true, kEncodingHasNulls>(
+          filter, dwio::common::DropValues(), rows);
     } else {
-      processFilter<Reader, false>(filter, dwio::common::DropValues(), rows);
+      processFilter<Reader, false, kEncodingHasNulls>(
+          filter, dwio::common::DropValues(), rows);
     }
   }
 }
diff --git a/velox/dwio/common/SelectiveColumnReader.cpp b/velox/dwio/common/SelectiveColumnReader.cpp
index d4411b80727e7..c7a3ad67a4e2b 100644
--- a/velox/dwio/common/SelectiveColumnReader.cpp
+++ b/velox/dwio/common/SelectiveColumnReader.cpp
@@ -43,14 +43,14 @@ void ScanState::updateRawState() {
 
 SelectiveColumnReader::SelectiveColumnReader(
     const TypePtr& requestedType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     dwio::common::FormatParams& params,
-    velox::common::ScanSpec& scanSpec,
-    std::shared_ptr<const dwio::common::TypeWithId> type)
-    : memoryPool_(params.pool()),
-      fileType_(type),
-      formatData_(params.toFormatData(type, scanSpec)),
-      scanSpec_(&scanSpec),
-      requestedType_(requestedType) {}
+    velox::common::ScanSpec& scanSpec)
+    : memoryPool_(&params.pool()),
+      requestedType_(requestedType),
+      fileType_(fileType),
+      formatData_(params.toFormatData(fileType, scanSpec)),
+      scanSpec_(&scanSpec) {}
 
 void SelectiveColumnReader::filterRowGroups(
     uint64_t rowGroupSize,
@@ -70,13 +70,13 @@ void SelectiveColumnReader::seekTo(vector_size_t offset, bool readsNullsOnly) {
     return;
   }
   if (readOffset_ < offset) {
-    if (numParentNulls_) {
+    if (numParentNulls_ > 0) {
       VELOX_CHECK_LE(
           parentNullsRecordedTo_,
           offset,
           "Must not seek to before parentNullsRecordedTo_");
     }
-    auto distance = offset - readOffset_ - numParentNulls_;
+    const auto distance = offset - readOffset_ - numParentNulls_;
     numParentNulls_ = 0;
     parentNullsRecordedTo_ = 0;
     if (readsNullsOnly) {
@@ -86,47 +86,54 @@ void SelectiveColumnReader::seekTo(vector_size_t offset, bool readsNullsOnly) {
     }
     readOffset_ = offset;
   } else {
-    VELOX_FAIL("Seeking backward on a ColumnReader");
+    VELOX_FAIL(
+        "Seeking backward on a ColumnReader from {} to {}",
+        readOffset_,
+        offset);
+  }
+}
+
+void SelectiveColumnReader::initReturnReaderNulls(const RowSet& rows) {
+  if (useBulkPath() && !scanSpec_->hasFilter()) {
+    anyNulls_ = nullsInReadRange_ != nullptr;
+    const bool isDense = rows.back() == rows.size() - 1;
+    returnReaderNulls_ = anyNulls_ && isDense;
+  } else {
+    returnReaderNulls_ = false;
   }
 }
 
 void SelectiveColumnReader::prepareNulls(
-    RowSet rows,
+    const RowSet& rows,
     bool hasNulls,
     int32_t extraRows) {
   if (!hasNulls) {
     anyNulls_ = false;
     return;
   }
-  auto numRows = rows.size() + extraRows;
-  if (useBulkPath()) {
-    bool isDense = rows.back() == rows.size() - 1;
-    if (!scanSpec_->hasFilter()) {
-      anyNulls_ = nullsInReadRange_ != nullptr;
-      returnReaderNulls_ = anyNulls_ && isDense;
-      // No need for null flags if fast path
-      if (returnReaderNulls_) {
-        return;
-      }
-    }
+
+  initReturnReaderNulls(rows);
+  if (returnReaderNulls_) {
+    // No need for null flags if fast path.
+    return;
   }
+
+  const auto numRows = rows.size() + extraRows;
   if (resultNulls_ && resultNulls_->unique() &&
       resultNulls_->capacity() >= bits::nbytes(numRows) + simd::kPadding) {
-    // Clear whole capacity because future uses could hit
-    // uncleared data between capacity() and 'numBytes'.
-    simd::memset(rawResultNulls_, bits::kNotNullByte, resultNulls_->capacity());
-    anyNulls_ = false;
-    return;
+    resultNulls_->setSize(bits::nbytes(numRows));
+  } else {
+    resultNulls_ = AlignedBuffer::allocate<bool>(
+        numRows + (simd::kPadding * 8), memoryPool_);
+    rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
   }
-
   anyNulls_ = false;
-  resultNulls_ = AlignedBuffer::allocate<bool>(
-      numRows + (simd::kPadding * 8), &memoryPool_);
-  rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
+  // Clear whole capacity because future uses could hit uncleared data between
+  // capacity() and 'numBytes'.
   simd::memset(rawResultNulls_, bits::kNotNullByte, resultNulls_->capacity());
 }
 
-const uint64_t* SelectiveColumnReader::shouldMoveNulls(RowSet rows) {
+const uint64_t* SelectiveColumnReader::shouldMoveNulls(const RowSet& rows) {
   if (rows.size() == numValues_ || !anyNulls_) {
     // Nulls will only be moved if there is a selection on values. A cast
     // alone does not move nulls.
@@ -137,7 +144,7 @@ const uint64_t* SelectiveColumnReader::shouldMoveNulls(RowSet rows) {
     if (!(resultNulls_ && resultNulls_->unique() &&
           resultNulls_->capacity() >= rows.size() + simd::kPadding)) {
       resultNulls_ = AlignedBuffer::allocate<bool>(
-          rows.size() + (simd::kPadding * 8), &memoryPool_);
+          rows.size() + (simd::kPadding * 8), memoryPool_);
       rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
     }
     moveFrom = nullsInReadRange_->as<uint64_t>();
@@ -149,8 +156,40 @@ const uint64_t* SelectiveColumnReader::shouldMoveNulls(RowSet rows) {
   return moveFrom;
 }
 
+void SelectiveColumnReader::setComplexNulls(
+    const RowSet& rows,
+    VectorPtr& result) const {
+  if (!nullsInReadRange_) {
+    if (result->isNullsWritable()) {
+      result->clearNulls(0, rows.size());
+    } else {
+      result->resetNulls();
+    }
+    return;
+  }
+
+  const bool dense = 1 + rows.back() == rows.size();
+  auto& nulls = result->nulls();
+  if (dense &&
+      !(nulls && nulls->isMutable() &&
+        nulls->capacity() >= bits::nbytes(rows.size()))) {
+    result->setNulls(nullsInReadRange_);
+    return;
+  }
+
+  auto* readerNulls = nullsInReadRange_->as<uint64_t>();
+  auto* resultNulls = result->mutableNulls(rows.size())->asMutable<uint64_t>();
+  if (dense) {
+    bits::copyBits(readerNulls, 0, resultNulls, 0, rows.size());
+    return;
+  }
+  for (vector_size_t i = 0; i < rows.size(); ++i) {
+    bits::setBit(resultNulls, i, bits::isBitSet(readerNulls, rows[i]));
+  }
+}
+
 void SelectiveColumnReader::getIntValues(
-    RowSet rows,
+    const RowSet& rows,
     const TypePtr& requestedType,
     VectorPtr* result) {
   switch (requestedType->kind()) {
@@ -220,9 +259,78 @@ void SelectiveColumnReader::getIntValues(
   }
 }
 
+void SelectiveColumnReader::getUnsignedIntValues(
+    const RowSet& rows,
+    const TypePtr& requestedType,
+    VectorPtr* result) {
+  switch (requestedType->kind()) {
+    case TypeKind::TINYINT:
+      switch (valueSize_) {
+        case 1:
+          getFlatValues<uint8_t, uint8_t>(rows, result, requestedType);
+          break;
+        case 4:
+          getFlatValues<uint32_t, uint8_t>(rows, result, requestedType);
+          break;
+        default:
+          VELOX_FAIL("Unsupported value size: {}", valueSize_);
+      }
+      break;
+    case TypeKind::SMALLINT:
+      switch (valueSize_) {
+        case 2:
+          getFlatValues<uint16_t, uint16_t>(rows, result, requestedType);
+          break;
+        case 4:
+          getFlatValues<uint32_t, uint16_t>(rows, result, requestedType);
+          break;
+        default:
+          VELOX_FAIL("Unsupported value size: {}", valueSize_);
+      }
+      break;
+    case TypeKind::INTEGER:
+      switch (valueSize_) {
+        case 4:
+          getFlatValues<uint32_t, uint32_t>(rows, result, requestedType);
+          break;
+        default:
+          VELOX_FAIL("Unsupported value size: {}", valueSize_);
+      }
+      break;
+    case TypeKind::BIGINT:
+      switch (valueSize_) {
+        case 4:
+          getFlatValues<uint32_t, uint64_t>(rows, result, requestedType);
+          break;
+        case 8:
+          getFlatValues<uint64_t, uint64_t>(rows, result, requestedType);
+          break;
+        default:
+          VELOX_FAIL("Unsupported value size: {}", valueSize_);
+      }
+      break;
+    case TypeKind::HUGEINT:
+      switch (valueSize_) {
+        case 8:
+          getFlatValues<uint64_t, uint128_t>(rows, result, requestedType);
+          break;
+        case 16:
+          getFlatValues<uint128_t, uint128_t>(rows, result, requestedType);
+          break;
+        default:
+          VELOX_FAIL("Unsupported value size: {}", valueSize_);
+      }
+      break;
+    default:
+      VELOX_FAIL(
+          "Not a valid type for unsigned integer reader: {}",
+          requestedType->toString());
+  }
+}
+
 template <>
 void SelectiveColumnReader::getFlatValues<int8_t, bool>(
-    RowSet rows,
+    const RowSet& rows,
     VectorPtr* result,
     const TypePtr& type,
     bool isFinal) {
@@ -230,7 +338,7 @@ void SelectiveColumnReader::getFlatValues<int8_t, bool>(
   VELOX_CHECK_EQ(valueSize_, sizeof(int8_t));
   compactScalarValues<int8_t, int8_t>(rows, isFinal);
   auto boolValues =
-      AlignedBuffer::allocate<bool>(numValues_, &memoryPool_, false);
+      AlignedBuffer::allocate<bool>(numValues_, memoryPool_, false);
   auto rawBytes = values_->as<int8_t>();
   auto zero = xsimd::broadcast<int8_t>(0);
   if constexpr (kWidth == 32) {
@@ -248,7 +356,7 @@ void SelectiveColumnReader::getFlatValues<int8_t, bool>(
     }
   }
   *result = std::make_shared<FlatVector<bool>>(
-      &memoryPool_,
+      memoryPool_,
       type,
       resultNulls(),
       numValues_,
@@ -258,7 +366,7 @@ void SelectiveColumnReader::getFlatValues<int8_t, bool>(
 
 template <>
 void SelectiveColumnReader::compactScalarValues<bool, bool>(
-    RowSet rows,
+    const RowSet& rows,
     bool isFinal) {
   if (!values_ || rows.size() == numValues_) {
     if (values_) {
@@ -275,7 +383,7 @@ void SelectiveColumnReader::compactScalarValues<bool, bool>(
       continue;
     }
 
-    VELOX_DCHECK(outputRows_[i] == nextRow);
+    VELOX_DCHECK_EQ(outputRows_[i], nextRow);
 
     bits::setBit(rawBits, rowIndex, bits::isBitSet(rawBits, i));
     if (moveNullsFrom && rowIndex != i) {
@@ -299,7 +407,7 @@ char* SelectiveColumnReader::copyStringValue(folly::StringPiece value) {
   uint64_t size = value.size();
   if (stringBuffers_.empty() || rawStringUsed_ + size > rawStringSize_) {
     auto bytes = std::max(size, kStringBufferSize);
-    BufferPtr buffer = AlignedBuffer::allocate<char>(bytes, &memoryPool_);
+    BufferPtr buffer = AlignedBuffer::allocate<char>(bytes, memoryPool_);
     // Use the preferred size instead of the requested one to improve memory
     // efficiency.
     buffer->setSize(buffer->capacity());
@@ -322,17 +430,6 @@ void SelectiveColumnReader::addStringValue(folly::StringPiece value) {
       StringView(copy, value.size());
 }
 
-bool SelectiveColumnReader::readsNullsOnly() const {
-  auto filter = scanSpec_->filter();
-  if (filter) {
-    auto kind = filter->kind();
-    return kind == velox::common::FilterKind::kIsNull ||
-        (!scanSpec_->keepValues() &&
-         kind == velox::common::FilterKind::kIsNotNull);
-  }
-  return false;
-}
-
 void SelectiveColumnReader::setNulls(BufferPtr resultNulls) {
   resultNulls_ = resultNulls;
   rawResultNulls_ = resultNulls ? resultNulls->asMutable<uint64_t>() : nullptr;
@@ -360,8 +457,8 @@ void SelectiveColumnReader::resetFilterCaches() {
 void SelectiveColumnReader::addParentNulls(
     int32_t firstRowInNulls,
     const uint64_t* nulls,
-    RowSet rows) {
-  int32_t firstNullIndex =
+    const RowSet& rows) {
+  const int32_t firstNullIndex =
       readOffset_ < firstRowInNulls ? 0 : readOffset_ - firstRowInNulls;
   numParentNulls_ +=
       nulls ? bits::countNulls(nulls, firstNullIndex, rows.back() + 1) : 0;
diff --git a/velox/dwio/common/SelectiveColumnReader.h b/velox/dwio/common/SelectiveColumnReader.h
index 4dab2518501dd..053db8884884f 100644
--- a/velox/dwio/common/SelectiveColumnReader.h
+++ b/velox/dwio/common/SelectiveColumnReader.h
@@ -18,7 +18,7 @@
 #include "velox/common/base/RawVector.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/common/process/ProcessBase.h"
-#include "velox/dwio/common/ColumnSelector.h"
+#include "velox/common/process/TraceHistory.h"
 #include "velox/dwio/common/FormatData.h"
 #include "velox/dwio/common/IntDecoder.h"
 #include "velox/dwio/common/Mutation.h"
@@ -27,20 +27,20 @@
 
 namespace facebook::velox::dwio::common {
 
-// Generalized representation of a set of distinct values for dictionary
-// encodings.
+/// Generalized representation of a set of distinct values for dictionary
+/// encodings.
 struct DictionaryValues {
-  // Array of values for dictionary. StringViews for string values.
+  /// Array of values for dictionary. StringViews for string values.
   BufferPtr values;
 
-  // For a string dictionary, holds the characters that are pointed to by
-  // StringViews in 'values'.
+  /// For a string dictionary, holds the characters that are pointed to by
+  /// StringViews in 'values'.
   BufferPtr strings;
 
-  // Number of valid elements in 'values'.
+  /// Number of valid elements in 'values'.
   int32_t numValues{0};
 
-  // True if values are in ascending order.
+  /// True if values are in ascending order.
   bool sorted{false};
 
   void clear() {
@@ -49,10 +49,21 @@ struct DictionaryValues {
     numValues = 0;
     sorted = false;
   }
+
+  /// Whether the dictionary values have filter on it.
+  static bool hasFilter(const velox::common::Filter* filter) {
+    // Dictionary values cannot be null.  It's by design not possible in ORC and
+    // Parquet; in other formats even when it is possible in theory, it should
+    // not be used in a normal file because outside dictionary we only need 1
+    // bit to encode a null, but if we move it inside dictionary, we would need
+    // 1 integer to encode a null.  A sanity check can be added on encoding
+    // metadata for such formats.
+    return filter && filter->kind() != velox::common::FilterKind::kIsNotNull;
+  }
 };
 
 struct RawDictionaryState {
-  const void* FOLLY_NULLABLE values{nullptr};
+  const void* values{nullptr};
   int32_t numValues{0};
 };
 
@@ -63,22 +74,21 @@ struct RawScanState {
 
   // See comment in  ScanState below.
   RawDictionaryState dictionary2;
-  const uint64_t* __restrict FOLLY_NULLABLE inDictionary{nullptr};
-  uint8_t* __restrict FOLLY_NULLABLE filterCache;
+  const uint64_t* __restrict inDictionary{nullptr};
+  uint8_t* __restrict filterCache;
 };
 
-// Maintains state for encoding between calls to readWithVisitor of
-// individual readers. DWRF sets up encoding information at the
-// start of a stripe and dictionaries at the start of stripes and
-// optionally row groups. Other encodings can set dictionaries and
-// encoding types at any time during processing a stripe.
+// Maintains state for encoding between calls to readWithVisitor of individual
+// readers. DWRF sets up encoding information at the start of a stripe and
+// dictionaries at the start of stripes and optionally row groups. Other
+// encodings can set dictionaries and encoding types at any time during
+// processing a stripe.
 //
-//  This is the union of the state elements that the supported
-//  encodings require for keeping state. This may be augmented when
-//  adding formats. This is however inlined in the reader superclass
-//  ad not for example nodeled as a class hierarchy with virtual
-//  functions because this needs to be trivially and branchlessly
-//  accessible.
+// This is the union of the state elements that the supported encodings require
+// for keeping state. This may be augmented when adding formats. This is however
+// inlined in the reader superclass and not for example modeled as a class
+// hierarchy with virtual functions because this needs to be trivially and
+// branchlessly accessible.
 struct ScanState {
   // Copies the owned values of 'this' into 'rawState'.
   void updateRawState();
@@ -94,14 +104,14 @@ struct ScanState {
   DictionaryValues dictionary;
 
   // If the format, like ORC/DWRF has a base dictionary completed by
-  // local delta dictionaries over the furst one, this represents the
+  // local delta dictionaries over the first one, this represents the
   // local values, e.g. row group dictionary in ORC. TBD: If there is
   // a pattern of dictionaries completed by more dictionaries in other
   // formats, this will be modeled as an vector of n DictionaryValues.
   DictionaryValues dictionary2;
 
   // Bits selecting between dictionary and dictionary2 or dictionary and
-  // literal. OR/DWRFC only.
+  // literal. ORC/DWRF only.
   BufferPtr inDictionary;
 
   // Copy of Visitor::rows_ adjusted to start at the current encoding
@@ -124,9 +134,9 @@ class SelectiveColumnReader {
 
   SelectiveColumnReader(
       const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       dwio::common::FormatParams& params,
-      velox::common::ScanSpec& scanSpec,
-      std::shared_ptr<const dwio::common::TypeWithId> type);
+      velox::common::ScanSpec& scanSpec);
 
   virtual ~SelectiveColumnReader() = default;
 
@@ -140,7 +150,7 @@ class SelectiveColumnReader {
   /**
    * Read the next group of values into a RowVector.
    * @param numValues the number of values to read
-   * @param vector to read into
+   * @param result vector to read into
    */
   virtual void
   next(uint64_t /*numValues*/, VectorPtr& /*result*/, const Mutation*) {
@@ -159,23 +169,23 @@ class SelectiveColumnReader {
   // between this and the next call to read.
   virtual void read(
       vector_size_t offset,
-      RowSet rows,
-      const uint64_t* FOLLY_NULLABLE incomingNulls) = 0;
+      const RowSet& rows,
+      const uint64_t* incomingNulls) = 0;
 
   virtual uint64_t skip(uint64_t numValues) {
     return formatData_->skip(numValues);
   }
 
-  // Extracts the values at 'rows' into '*result'. May rewrite or
-  // reallocate '*result'. 'rows' must be the same set or a subset of
-  // 'rows' passed to the last 'read().
-  virtual void getValues(RowSet rows, VectorPtr* FOLLY_NONNULL result) = 0;
+  /// Extracts the values at 'rows' into '*result'. May rewrite or reallocate
+  /// '*result'. 'rows' must be the same set or a subset of 'rows' passed to the
+  /// last 'read().
+  virtual void getValues(const RowSet& rows, VectorPtr* result) = 0;
 
   // Returns the rows that were selected/visited by the last
   // read(). If 'this' has no filter, returns 'rows' passed to last
   // read().
   const RowSet outputRows() const {
-    if (scanSpec_->hasFilter() || hasMutation()) {
+    if (scanSpec_->hasFilter() || hasDeletion()) {
       return outputRows_;
     }
     return inputRows_;
@@ -185,11 +195,12 @@ class SelectiveColumnReader {
   // offset-th from the start of stripe.
   virtual void seekTo(vector_size_t offset, bool readsNullsOnly);
 
-  // Positions this at the start of 'index'th row
-  // group. Interpretation of 'index' depends on format. Clears counts
-  // of skipped enclosing struct nulls for formats where nulls are
-  // recorded at each nesting level, i.e. not rep-def.
-  virtual void seekToRowGroup(uint32_t /*index*/) {
+  /// Positions this at the start of 'index'th row group. Interpretation of
+  /// 'index' depends on format. Clears counts of skipped enclosing struct nulls
+  /// for formats where nulls are recorded at each nesting level, i.e. not
+  /// rep-def.
+  virtual void seekToRowGroup(uint32_t index) {
+    VELOX_TRACE_HISTORY_PUSH("seekToRowGroup %u", index);
     numParentNulls_ = 0;
     parentNullsRecordedTo_ = 0;
   }
@@ -202,32 +213,41 @@ class SelectiveColumnReader {
     return *fileType_;
   }
 
-  // The below functions are called from ColumnVisitor to fill the result set.
+  /// The below functions are called from ColumnVisitor to fill the result set.
   inline void addOutputRow(vector_size_t row) {
     outputRows_.push_back(row);
   }
 
   // Returns a pointer to output rows  with at least 'size' elements available.
-  vector_size_t* FOLLY_NONNULL mutableOutputRows(int32_t size) {
-    numOutConfirmed_ = outputRows_.size();
-    outputRows_.resize(numOutConfirmed_ + size);
-    return outputRows_.data() + numOutConfirmed_;
+  vector_size_t* mutableOutputRows(int32_t size) {
+    auto numOutConfirmed = outputRows_.size();
+    outputRows_.resize(numOutConfirmed + size);
+    return outputRows_.data() + numOutConfirmed;
+  }
+
+  void* rawValues() {
+    return rawValues_;
   }
 
   template <typename T>
-  T* FOLLY_NONNULL mutableValues(int32_t size) {
+  T* mutableValues(int32_t size) {
     DCHECK(values_->capacity() >= (numValues_ + size) * sizeof(T));
     return reinterpret_cast<T*>(rawValues_) + numValues_;
   }
 
+  uint64_t valuesCapacity() const {
+    VELOX_DCHECK_NOT_NULL(values_);
+    return values_->capacity();
+  }
+
   // Returns a mutable pointer to start of result nulls
   // bitmap. Ensures that this has at least 'numValues_' + 'size'
   // capacity and is unique. If extending existing buffer, preserves
   // previous contents.
-  uint64_t* FOLLY_NONNULL mutableNulls(int32_t size) {
+  uint64_t* mutableNulls(int32_t size) {
     if (!resultNulls_->unique()) {
       resultNulls_ = AlignedBuffer::allocate<bool>(
-          numValues_ + size, &memoryPool_, bits::kNotNull);
+          numValues_ + size, memoryPool_, bits::kNotNull);
       rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
     }
     if (resultNulls_->capacity() * 8 < numValues_ + size) {
@@ -242,6 +262,10 @@ class SelectiveColumnReader {
     return rawResultNulls_;
   }
 
+  uint64_t* rawResultNulls() {
+    return rawResultNulls_;
+  }
+
   // True if this reads contiguous rows starting at 0 and may have
   // nulls. If so, the nulls decoded from the nulls in encoded data
   // can be returned directly in the vector in getValues().
@@ -249,6 +273,8 @@ class SelectiveColumnReader {
     return returnReaderNulls_;
   }
 
+  void initReturnReaderNulls(const RowSet& rows);
+
   void setNumValues(vector_size_t size) {
     numValues_ = size;
   }
@@ -279,6 +305,10 @@ class SelectiveColumnReader {
     }
   }
 
+  bool hasNulls() const {
+    return anyNulls_;
+  }
+
   void setHasNulls() {
     anyNulls_ = true;
   }
@@ -294,30 +324,28 @@ class SelectiveColumnReader {
   template <typename T>
   inline void addNull() {
     VELOX_DCHECK_NE(valueSize_, kNoValueSize);
-    VELOX_DCHECK_LE(
-        rawResultNulls_ && rawValues_ && (numValues_ + 1) * valueSize_,
-        values_->capacity());
+    VELOX_DCHECK(rawResultNulls_ && rawValues_);
+    VELOX_DCHECK_LE((numValues_ + 1) * valueSize_, values_->capacity());
 
     anyNulls_ = true;
     bits::setNull(rawResultNulls_, numValues_);
-    // Set the default value at the nominal width of the reader but
-    // calculate the index based on the actual width of the
-    // data. These may differ for integer and dictionary readers.
-    auto valuesAsChar = reinterpret_cast<char*>(rawValues_);
+    // Set the default value at the nominal width of the reader but calculate
+    // the index based on the actual width of the data. These may differ for
+    // integer and dictionary readers.
+    auto* valuesAsChar = reinterpret_cast<char*>(rawValues_);
     *reinterpret_cast<T*>(valuesAsChar + valueSize_ * numValues_) = T();
-    numValues_++;
+    ++numValues_;
   }
 
   template <typename T>
-  inline void addValue(const T value) {
-    // @lint-ignore-every HOWTOEVEN ConstantArgumentPassByValue
+  inline void addValue(T value) {
     static_assert(
         std::is_pod_v<T>,
         "General case of addValue is only for primitive types");
-    VELOX_DCHECK_LE(
-        rawValues_ && (numValues_ + 1) * sizeof(T), values_->capacity());
+    VELOX_DCHECK_NOT_NULL(rawValues_);
+    VELOX_DCHECK_LE((numValues_ + 1) * sizeof(T), values_->capacity());
     reinterpret_cast<T*>(rawValues_)[numValues_] = value;
-    numValues_++;
+    ++numValues_;
   }
 
   void dropResults(vector_size_t count) {
@@ -325,7 +353,7 @@ class SelectiveColumnReader {
     numValues_ -= count;
   }
 
-  velox::common::ScanSpec* FOLLY_NONNULL scanSpec() const {
+  velox::common::ScanSpec* scanSpec() const {
     return scanSpec_;
   }
 
@@ -341,8 +369,8 @@ class SelectiveColumnReader {
     setReadOffset(readOffset);
   }
 
-  // Recursively sets 'isTopLevel_'. Recurses down non-nullable structs,
-  // otherwise only sets 'isTopLevel_' of 'this'
+  /// Recursively sets 'isTopLevel_'. Recurses down non-nullable structs,
+  /// otherwise only sets 'isTopLevel_' of 'this'
   virtual void setIsTopLevel() {
     isTopLevel_ = true;
   }
@@ -376,12 +404,15 @@ class SelectiveColumnReader {
     return nullsInReadRange_;
   }
 
-  // Returns true if no filters or deterministic filters/hooks that
-  // discard nulls. This is used at read prepare time. useFastPath()
-  // in DecoderUtil.h is used at read time and is expected to produce
-  // the same result.
-  virtual bool useBulkPath() const {
-    auto filter = scanSpec_->filter();
+  const uint64_t* rawNullsInReadRange() const {
+    return nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
+  }
+
+  /// Returns true if no filters or deterministic filters/hooks that discard
+  /// nulls. This is used at read prepare time. useFastPath() in DecoderUtil.h
+  /// is used at read time and is expected to produce the same result.
+  bool useBulkPath() const {
+    auto* filter = scanSpec_->filter();
     return hasBulkPath() && process::hasAvx2() &&
         (!filter ||
          (filter->isDeterministic() &&
@@ -409,18 +440,17 @@ class SelectiveColumnReader {
   // converts to direct in mid-read.
   virtual void dedictionarize() {}
 
-  // A reader nested inside nullable containers has fewer rows than
-  // the top level table. addParentNulls records how many parent nulls
-  // there are between the position of 'this' and 'rows.back() + 1',
-  // i.e. the position of the scan in top level rows. 'firstRowInNulls' is
-  // the top level row corresponding to the first bit in
-  // 'nulls'. 'nulls' is in terms of top level rows and represents all
-  // null parents at any enclosing level. 'nulls' is nullptr if there are no
-  // parent nulls.
+  /// A reader nested inside nullable containers has fewer rows than the top
+  /// level table. addParentNulls records how many parent nulls there are
+  /// between the position of 'this' and 'rows.back() + 1', i.e. the position of
+  /// the scan in top level rows. 'firstRowInNulls' is the top level row
+  /// corresponding to the first bit in 'nulls'. 'nulls' is in terms of top
+  /// level rows and represents all null parents at any enclosing level. 'nulls'
+  /// is nullptr if there are no parent nulls.
   void addParentNulls(
       int32_t firstRowInNulls,
-      const uint64_t* FOLLY_NULLABLE nulls,
-      RowSet rows);
+      const uint64_t* nulls,
+      const RowSet& rows);
 
   // When skipping rows in a struct, records how many parent nulls at
   // any level there are between top level row 'from' and 'to'. If
@@ -432,44 +462,81 @@ class SelectiveColumnReader {
   static constexpr int8_t kNoValueSize = -1;
   static constexpr uint32_t kRowGroupNotSet = ~0;
 
-  // True if we have an is null filter and optionally return column
-  // values or we have an is not null filter and do not return column
-  // values. This means that only null flags need be accessed.
-  bool readsNullsOnly() const;
-
   template <typename T>
   void ensureValuesCapacity(vector_size_t numRows);
 
   // Prepares the result buffer for nulls for reading 'rows'. Leaves
   // 'extraSpace' bits worth of space in the nulls buffer.
-  void prepareNulls(RowSet rows, bool hasNulls, int32_t extraRows = 0);
+  void prepareNulls(const RowSet& rows, bool hasNulls, int32_t extraRows = 0);
 
- protected:
-  // Filters 'rows' according to 'is_null'. Only applies to cases where
-  // readsNullsOnly() is true.
+  void setIsFlatMapValue(bool value) {
+    isFlatMapValue_ = value;
+  }
+
+  /// Filters 'rows' according to 'isNull'. Only applies to cases where
+  /// scanSpec_->readsNullsOnly() is true.
   template <typename T>
-  void filterNulls(RowSet rows, bool isNull, bool extractValues);
+  void filterNulls(const RowSet& rows, bool isNull, bool extractValues);
+
+  // Temporary method for estimate total in-memory byte size and row count of
+  // current encoding chunk on this column for Nimble.  Will be removed once
+  // column statistics are added for Nimble.  Note that the estimations are
+  // based on current encoding chunk, so in multi-chunk stripe this is not
+  // accurate.  Other formats should not use this.
+  virtual bool estimateMaterializedSize(
+      size_t& /*byteSize*/,
+      size_t& /*rowCount*/) const {
+    return false;
+  }
+
+  StringView copyStringValueIfNeed(folly::StringPiece value) {
+    if (value.size() <= StringView::kInlineSize) {
+      return StringView(value);
+    }
+    auto* data = copyStringValue(value);
+    return StringView(data, value.size());
+  }
+
+  // Whether output rows should be filled when there is no column projected out
+  // and there is delete mutation.  Used for row number generation.  The case
+  // for no delete mutation is handled more efficiently outside column reader in
+  // `RowReader::readWithRowNumber'.
+  virtual void setFillMutatedOutputRows(bool /*value*/) {
+    VELOX_UNREACHABLE("Only struct reader supports this method");
+  }
 
+ protected:
   template <typename T>
   void prepareRead(
       vector_size_t offset,
-      RowSet rows,
-      const uint64_t* FOLLY_NULLABLE incomingNulls);
+      const RowSet& rows,
+      const uint64_t* incomingNulls);
+
+  virtual bool readsNullsOnly() const {
+    return scanSpec_->readsNullsOnly();
+  }
 
-  void setOutputRows(RowSet rows) {
+  void setOutputRows(const RowSet& rows) {
     outputRows_.resize(rows.size());
-    if (!rows.size()) {
+    if (rows.empty()) {
       return;
     }
-    memcpy(outputRows_.data(), &rows[0], rows.size() * sizeof(vector_size_t));
+    ::memcpy(outputRows_.data(), &rows[0], rows.size() * sizeof(vector_size_t));
   }
 
-  // Returns integer values for 'rows' cast to the width of
-  // 'requestedType' in '*result'.
+  /// Returns integer values for 'rows' cast to the width of 'requestedType' in
+  /// '*result'.
   void getIntValues(
-      RowSet rows,
+      const RowSet& rows,
       const TypePtr& requestedType,
-      VectorPtr* FOLLY_NONNULL result);
+      VectorPtr* result);
+
+  /// Returns integer values for 'rows' cast to the width of 'requestedType' in
+  /// '*result', the related fileDataType is unsigned int type.
+  void getUnsignedIntValues(
+      const RowSet& rows,
+      const TypePtr& requestedType,
+      VectorPtr* result);
 
   // Returns read values for 'rows' in 'vector'. This can be called
   // multiple times for consecutive subsets of 'rows'. If 'isFinal' is
@@ -477,37 +544,34 @@ class SelectiveColumnReader {
   // to rows. TODO: Consider isFinal as template parameter.
   template <typename T, typename TVector>
   void getFlatValues(
-      RowSet rows,
-      VectorPtr* FOLLY_NONNULL result,
+      const RowSet& rows,
+      VectorPtr* result,
       const TypePtr& type,
       bool isFinal = false);
 
   template <typename T, typename TVector>
-  void compactScalarValues(RowSet rows, bool isFinal);
-
-  // Compacts values extracted for a complex type column with
-  // filter. The values for 'rows' are shifted to be consecutive at
-  // indices [0..rows.size() - 1]'. 'move' is a function that takes
-  // two indices source and target and moves the value at source to
-  // target. target is <= source for all calls.
-  template <typename Move>
-  void compactComplexValues(RowSet rows, Move move, bool isFinal);
+  void compactScalarValues(const RowSet& rows, bool isFinal);
 
   template <typename T, typename TVector>
-  void upcastScalarValues(RowSet rows);
+  void upcastScalarValues(const RowSet& rows);
+
+  // For complex type column, we need to compact only nulls if the rows are
+  // shrinked.  Child fields are handled recursively in their own column
+  // readers.
+  void setComplexNulls(const RowSet& rows, VectorPtr& result) const;
 
   // Return the source null bits if compactScalarValues and upcastScalarValues
   // should move null flags.  Return nullptr if nulls does not need to be moved.
   // Checks consistency of nulls-related state.
-  const uint64_t* shouldMoveNulls(RowSet rows);
+  const uint64_t* shouldMoveNulls(const RowSet& rows);
 
   void addStringValue(folly::StringPiece value);
 
   // Copies 'value' to buffers owned by 'this' and returns the start of the
   // copy.
-  char* FOLLY_NONNULL copyStringValue(folly::StringPiece value);
+  char* copyStringValue(folly::StringPiece value);
 
-  virtual bool hasMutation() const {
+  virtual bool hasDeletion() const {
     return false;
   }
 
@@ -515,8 +579,8 @@ class SelectiveColumnReader {
   void decodeWithVisitor(
       IntDecoder<Decoder::kIsSigned>* intDecoder,
       ColumnVisitor& visitor) {
-    auto decoder = dynamic_cast<Decoder*>(intDecoder);
-    VELOX_CHECK(
+    auto* decoder = dynamic_cast<Decoder*>(intDecoder);
+    VELOX_CHECK_NOT_NULL(
         decoder,
         "Unexpected Decoder type, Expected: {}",
         typeid(Decoder).name());
@@ -536,21 +600,21 @@ class SelectiveColumnReader {
                              : resultNulls_;
   }
 
-  memory::MemoryPool& memoryPool_;
+  memory::MemoryPool* const memoryPool_;
+
+  // The requested data type
+  const TypePtr requestedType_;
 
   // The file data type
-  std::shared_ptr<const dwio::common::TypeWithId> fileType_;
+  const std::shared_ptr<const dwio::common::TypeWithId> fileType_;
 
   // Format specific state and functions.
-  std::unique_ptr<dwio::common::FormatData> formatData_;
+  const std::unique_ptr<dwio::common::FormatData> formatData_;
 
   // Specification of filters, value extraction, pruning etc. The
   // spec is assigned at construction and the contents may change at
   // run time based on adaptation. Owned by caller.
-  velox::common::ScanSpec* FOLLY_NONNULL scanSpec_;
-
-  // The requested data type
-  TypePtr requestedType_;
+  velox::common::ScanSpec* const scanSpec_;
 
   // Row number after last read row, relative to the ORC stripe or Parquet
   // Rowgroup start.
@@ -568,15 +632,12 @@ class SelectiveColumnReader {
   // The rows to process in read(). References memory supplied by
   // caller. The values must remain live until the next call to read().
   RowSet inputRows_;
-  // Rows passing the filter in readWithVisitor. Must stay
-  // constant between consecutive calls to read().
+  // Rows passing the filter in readWithVisitor. Must stay constant between
+  // consecutive calls to read().
   raw_vector<vector_size_t> outputRows_;
-  // Index of last set value in outputRows. Values between this and
-  // size() can be used as scratchpad inside read().
-  vector_size_t numOutConfirmed_;
-  // The row number
-  // corresponding to each element in 'values_'
+  // The row number corresponding to each element in 'values_'
   raw_vector<vector_size_t> valueRows_;
+
   // The set of all nulls in the range of read(). Created when first
   // needed and then reused. May be referenced by result if all rows are
   // selected.
@@ -584,11 +645,11 @@ class SelectiveColumnReader {
   // Nulls buffer for readWithVisitor. Not set if no nulls. 'numValues'
   // is the index of the first non-set bit.
   BufferPtr resultNulls_;
-  uint64_t* FOLLY_NULLABLE rawResultNulls_ = nullptr;
+  uint64_t* rawResultNulls_ = nullptr;
   // Buffer for gathering scalar values in readWithVisitor.
   BufferPtr values_;
   // Writable content in 'values'
-  void* FOLLY_NULLABLE rawValues_ = nullptr;
+  void* rawValues_ = nullptr;
   vector_size_t numValues_ = 0;
   // Size of fixed width value in 'rawValues'. For integers, values
   // are read at 64 bit width and can be compacted or extracted at a
@@ -598,11 +659,10 @@ class SelectiveColumnReader {
   // true if 'this' is in a state where gatValues can be called.
   bool mayGetValues_ = false;
 
-  // True if row numbers of 'this' correspond 1:1 to row numbers in
-  // the file. This is false inside lists, maps and nullable
-  // structs. If true, a skip of n rows can use row group indices to
-  // skip long distances. Lazy vectors will only be made for results
-  // of top level readers.
+  // True if row numbers of 'this' correspond 1:1 to row numbers in the file.
+  // This is false inside lists, maps and nullable structs. If true, a skip of n
+  // rows can use row group indices to skip long distances. Lazy vectors will
+  // only be made for results of top level readers.
   bool isTopLevel_{false};
 
   // Maps from position in non-null rows to a position in value
@@ -614,12 +674,12 @@ class SelectiveColumnReader {
   // Buffers backing the StringViews in 'values' when reading strings.
   std::vector<BufferPtr> stringBuffers_;
   // Writable contents of 'stringBuffers_.back()'.
-  char* FOLLY_NULLABLE rawStringBuffer_ = nullptr;
+  char* rawStringBuffer_ = nullptr;
   // True if a vector can acquire a pin to a stream's buffer and refer
   // to that as its values.
   bool mayUseStreamBuffer_ = false;
-  // True if nulls and everything selected, so that nullsInReadRange
-  // can be returned as the null flags of the vector in getValues().
+  // True if nulls and everything selected, so that nullsInReadRange can be
+  // returned as the null flags of the vector in getValues().
   bool returnReaderNulls_ = false;
   // Total writable bytes in 'rawStringBuffer_'.
   int32_t rawStringSize_ = 0;
@@ -636,6 +696,19 @@ class SelectiveColumnReader {
 
   // Encoding-related state to keep between reads, e.g. dictionaries.
   ScanState scanState_;
+
+  // Whether this column reader is for a flatmap value column and the result is
+  // an ordinary map.  If this is true, the nullsInReadRange_ and value_ will
+  // never be shared outside file reader and we can reuse them regardless of
+  // refcounts.
+  bool isFlatMapValue_ = false;
+
+  // When isFlatMapValue_ is true, these fields are used to hold
+  // nullsInReadRange_ and value_ memory that can be reused when they switch
+  // between null and non-null values.
+  BufferPtr flatMapValueNullsInReadRange_;
+  VectorPtr flatMapValueFlatValues_;
+  VectorPtr flatMapValueConstantNullValues_;
 };
 
 template <>
@@ -656,14 +729,24 @@ inline void SelectiveColumnReader::addValue(const folly::StringPiece value) {
   addStringValue(value);
 }
 
+velox::common::AlwaysTrue& alwaysTrue();
+
 } // namespace facebook::velox::dwio::common
 
 namespace facebook::velox::dwio::common {
+
 // Template parameter to indicate no hook in fast scan path. This is
 // referenced in decoders, thus needs to be declared in a header.
-struct NoHook : public ValueHook {
-  void addValue(vector_size_t /*row*/, const void* FOLLY_NULLABLE /*value*/)
-      override {}
+struct NoHook final : public ValueHook {
+  void addValue(vector_size_t /*row*/, int64_t /*value*/) final {}
+
+  void addValue(vector_size_t /*row*/, int128_t /*value*/) final {}
+
+  void addValue(vector_size_t /*row*/, float /*value*/) final {}
+
+  void addValue(vector_size_t /*row*/, double /*value*/) final {}
+
+  void addValue(vector_size_t /*row*/, folly::StringPiece /*value*/) final {}
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveColumnReaderInternal.h b/velox/dwio/common/SelectiveColumnReaderInternal.h
index e4df3ebcb958b..689f54b5e818b 100644
--- a/velox/dwio/common/SelectiveColumnReaderInternal.h
+++ b/velox/dwio/common/SelectiveColumnReaderInternal.h
@@ -31,46 +31,41 @@
 
 namespace facebook::velox::dwio::common {
 
-velox::common::AlwaysTrue& alwaysTrue();
-
-class Timer {
- public:
-  Timer() : startClocks_{folly::hardware_timestamp()} {}
-
-  uint64_t elapsedClocks() const {
-    return folly::hardware_timestamp() - startClocks_;
-  }
-
- private:
-  const uint64_t startClocks_;
-};
-
 template <typename T>
 void SelectiveColumnReader::ensureValuesCapacity(vector_size_t numRows) {
-  if (values_ && values_->unique() &&
+  if (values_ && (isFlatMapValue_ || values_->unique()) &&
       values_->capacity() >=
           BaseVector::byteSize<T>(numRows) + simd::kPadding) {
     return;
   }
   values_ = AlignedBuffer::allocate<T>(
-      numRows + (simd::kPadding / sizeof(T)), &memoryPool_);
+      numRows + (simd::kPadding / sizeof(T)), memoryPool_);
   rawValues_ = values_->asMutable<char>();
 }
 
 template <typename T>
 void SelectiveColumnReader::prepareRead(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
-  seekTo(offset, scanSpec_->readsNullsOnly());
-  vector_size_t numRows = rows.back() + 1;
+  const bool readsNullsOnly = this->readsNullsOnly();
+  seekTo(offset, readsNullsOnly);
 
-  // Do not re-use unless singly-referenced.
-  if (nullsInReadRange_ && !nullsInReadRange_->unique()) {
+  const vector_size_t numRows = rows.back() + 1;
+  if (isFlatMapValue_) {
+    if (!nullsInReadRange_) {
+      nullsInReadRange_ = std::move(flatMapValueNullsInReadRange_);
+    }
+  } else if (nullsInReadRange_ && !nullsInReadRange_->unique()) {
     nullsInReadRange_.reset();
   }
+
   formatData_->readNulls(
-      numRows, incomingNulls, nullsInReadRange_, readsNullsOnly());
+      numRows, incomingNulls, nullsInReadRange_, readsNullsOnly);
+  if (isFlatMapValue_ && nullsInReadRange_) {
+    flatMapValueNullsInReadRange_ = nullsInReadRange_;
+  }
+
   // We check for all nulls and no nulls. We expect both calls to
   // bits::isAllSet to fail early in the common case. We could do a
   // single traversal of null bits counting the bits and then compare
@@ -85,18 +80,19 @@ void SelectiveColumnReader::prepareRead(
           nullsInReadRange_->as<uint64_t>(), 0, numRows, bits::kNotNull)) {
     nullsInReadRange_ = nullptr;
   }
+
   innerNonNullRows_.clear();
   outerNonNullRows_.clear();
   outputRows_.clear();
-  // is part of read() and after read returns getValues may be called.
+  // Is part of read() and after read returns getValues may be called.
   mayGetValues_ = true;
-  numOutConfirmed_ = 0;
   numValues_ = 0;
   valueSize_ = sizeof(T);
   inputRows_ = rows;
-  if (scanSpec_->filter() || hasMutation()) {
+  if (scanSpec_->filter() || hasDeletion()) {
     outputRows_.reserve(rows.size());
   }
+
   ensureValuesCapacity<T>(rows.size());
   if (scanSpec_->keepValues() && !scanSpec_->valueHook()) {
     valueRows_.clear();
@@ -106,7 +102,7 @@ void SelectiveColumnReader::prepareRead(
 
 template <typename T, typename TVector>
 void SelectiveColumnReader::getFlatValues(
-    RowSet rows,
+    const RowSet& rows,
     VectorPtr* result,
     const TypePtr& type,
     bool isFinal) {
@@ -115,17 +111,24 @@ void SelectiveColumnReader::getFlatValues(
   if (isFinal) {
     mayGetValues_ = false;
   }
+
   if (allNull_) {
-    *result = std::make_shared<ConstantVector<TVector>>(
-        &memoryPool_,
-        rows.size(),
-        true,
-        type,
-        T(),
-        SimpleVectorStats<TVector>{},
-        sizeof(TVector) * rows.size());
+    if (isFlatMapValue_) {
+      if (flatMapValueConstantNullValues_) {
+        flatMapValueConstantNullValues_->resize(rows.size());
+      } else {
+        flatMapValueConstantNullValues_ =
+            std::make_shared<ConstantVector<TVector>>(
+                memoryPool_, rows.size(), true, type, T());
+      }
+      *result = flatMapValueConstantNullValues_;
+    } else {
+      *result = std::make_shared<ConstantVector<TVector>>(
+          memoryPool_, rows.size(), true, type, T());
+    }
     return;
   }
+
   if (valueSize_ == sizeof(TVector)) {
     compactScalarValues<TVector, TVector>(rows, isFinal);
   } else if (sizeof(T) >= sizeof(TVector)) {
@@ -134,24 +137,43 @@ void SelectiveColumnReader::getFlatValues(
     upcastScalarValues<T, TVector>(rows);
   }
   valueSize_ = sizeof(TVector);
-  *result = std::make_shared<FlatVector<TVector>>(
-      &memoryPool_,
-      type,
-      resultNulls(),
-      numValues_,
-      values_,
-      std::move(stringBuffers_));
+  if (isFlatMapValue_) {
+    if (flatMapValueFlatValues_) {
+      auto* flat = flatMapValueFlatValues_->asUnchecked<FlatVector<TVector>>();
+      flat->unsafeSetSize(numValues_);
+      flat->setNulls(resultNulls());
+      flat->unsafeSetValues(values_);
+      flat->setStringBuffers(std::move(stringBuffers_));
+    } else {
+      flatMapValueFlatValues_ = std::make_shared<FlatVector<TVector>>(
+          memoryPool_,
+          type,
+          resultNulls(),
+          numValues_,
+          values_,
+          std::move(stringBuffers_));
+    }
+    *result = flatMapValueFlatValues_;
+  } else {
+    *result = std::make_shared<FlatVector<TVector>>(
+        memoryPool_,
+        type,
+        resultNulls(),
+        numValues_,
+        values_,
+        std::move(stringBuffers_));
+  }
 }
 
 template <>
 void SelectiveColumnReader::getFlatValues<int8_t, bool>(
-    RowSet rows,
+    const RowSet& rows,
     VectorPtr* result,
     const TypePtr& type,
     bool isFinal);
 
 template <typename T, typename TVector>
-void SelectiveColumnReader::upcastScalarValues(RowSet rows) {
+void SelectiveColumnReader::upcastScalarValues(const RowSet& rows) {
   VELOX_CHECK_LE(rows.size(), numValues_);
   VELOX_CHECK(!rows.empty());
   if (!values_) {
@@ -206,7 +228,9 @@ void SelectiveColumnReader::upcastScalarValues(RowSet rows) {
 }
 
 template <typename T, typename TVector>
-void SelectiveColumnReader::compactScalarValues(RowSet rows, bool isFinal) {
+void SelectiveColumnReader::compactScalarValues(
+    const RowSet& rows,
+    bool isFinal) {
   VELOX_CHECK_LE(rows.size(), numValues_);
   VELOX_CHECK(!rows.empty());
   if (!values_ || (rows.size() == numValues_ && sizeof(T) == sizeof(TVector))) {
@@ -215,6 +239,7 @@ void SelectiveColumnReader::compactScalarValues(RowSet rows, bool isFinal) {
     }
     return;
   }
+
   VELOX_CHECK_LE(sizeof(TVector), sizeof(T));
   T* typedSourceValues = reinterpret_cast<T*>(rawValues_);
   TVector* typedDestValues = reinterpret_cast<TVector*>(rawValues_);
@@ -233,15 +258,16 @@ void SelectiveColumnReader::compactScalarValues(RowSet rows, bool isFinal) {
   if (valueRows_.empty()) {
     valueRows_.resize(rows.size());
   }
+
   vector_size_t rowIndex = 0;
   auto nextRow = rows[rowIndex];
-  auto* moveNullsFrom = shouldMoveNulls(rows);
-  for (size_t i = 0; i < numValues_; i++) {
+  const auto* moveNullsFrom = shouldMoveNulls(rows);
+  for (size_t i = 0; i < numValues_; ++i) {
     if (sourceRows[i] < nextRow) {
       continue;
     }
 
-    VELOX_DCHECK(sourceRows[i] == nextRow);
+    VELOX_DCHECK_EQ(sourceRows[i], nextRow);
     typedDestValues[rowIndex] = typedSourceValues[i];
     if (moveNullsFrom && rowIndex != i) {
       bits::setBit(rawResultNulls_, rowIndex, bits::isBitSet(moveNullsFrom, i));
@@ -249,12 +275,13 @@ void SelectiveColumnReader::compactScalarValues(RowSet rows, bool isFinal) {
     if (!isFinal) {
       valueRows_[rowIndex] = nextRow;
     }
-    rowIndex++;
+    ++rowIndex;
     if (rowIndex >= rows.size()) {
       break;
     }
     nextRow = rows[rowIndex];
   }
+
   numValues_ = rows.size();
   valueRows_.resize(numValues_);
   values_->setSize(numValues_ * sizeof(TVector));
@@ -262,7 +289,7 @@ void SelectiveColumnReader::compactScalarValues(RowSet rows, bool isFinal) {
 
 template <>
 void SelectiveColumnReader::compactScalarValues<bool, bool>(
-    RowSet rows,
+    const RowSet& rows,
     bool isFinal);
 
 inline int32_t sizeOfIntKind(TypeKind kind) {
@@ -274,72 +301,20 @@ inline int32_t sizeOfIntKind(TypeKind kind) {
     case TypeKind::BIGINT:
       return 8;
     default:
-      VELOX_FAIL("Not an integer TypeKind");
+      VELOX_FAIL("Not an integer TypeKind: {}", static_cast<int>(kind));
   }
 }
 
-template <typename Move>
-void SelectiveColumnReader::compactComplexValues(
-    RowSet rows,
-    Move move,
-    bool isFinal) {
-  VELOX_CHECK_LE(rows.size(), outputRows_.size());
-  VELOX_CHECK(!rows.empty());
-  if (rows.size() == outputRows_.size()) {
-    return;
-  }
-  RowSet sourceRows;
-  // The row numbers corresponding to elements in 'values_' are in
-  // 'valueRows_' if values have been accessed before. Otherwise
-  // they are in 'outputRows_' if these are non-empty (there is a
-  // filter) and in 'inputRows_' otherwise.
-  if (!valueRows_.empty()) {
-    sourceRows = valueRows_;
-  } else if (!outputRows_.empty()) {
-    sourceRows = outputRows_;
-  } else {
-    sourceRows = inputRows_;
-  }
-  if (valueRows_.empty()) {
-    valueRows_.resize(rows.size());
-  }
-  vector_size_t rowIndex = 0;
-  auto nextRow = rows[rowIndex];
-  auto* moveNullsFrom = shouldMoveNulls(rows);
-  for (size_t i = 0; i < numValues_; i++) {
-    if (sourceRows[i] < nextRow) {
-      continue;
-    }
-
-    VELOX_DCHECK(sourceRows[i] == nextRow);
-    // The value at i is moved to be the value at 'rowIndex'.
-    move(i, rowIndex);
-    if (moveNullsFrom && rowIndex != i) {
-      bits::setBit(rawResultNulls_, rowIndex, bits::isBitSet(moveNullsFrom, i));
-    }
-    if (!isFinal) {
-      valueRows_[rowIndex] = nextRow;
-    }
-    rowIndex++;
-    if (rowIndex >= rows.size()) {
-      break;
-    }
-    nextRow = rows[rowIndex];
-  }
-  numValues_ = rows.size();
-  valueRows_.resize(numValues_);
-}
-
 template <typename T>
 void SelectiveColumnReader::filterNulls(
-    RowSet rows,
+    const RowSet& rows,
     bool isNull,
     bool extractValues) {
-  bool isDense = rows.back() == rows.size() - 1;
+  const bool isDense = rows.back() == rows.size() - 1;
   // We decide is (not) null based on 'nullsInReadRange_'. This may be
   // set due to nulls in enclosing structs even if the column itself
   // does not add nulls.
-  auto rawNulls =
+  auto* rawNulls =
       nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
   if (isNull) {
     if (!rawNulls) {
@@ -362,7 +337,6 @@ void SelectiveColumnReader::filterNulls(
         }
       }
     }
-
     return;
   }
 
diff --git a/velox/dwio/common/SelectiveFloatingPointColumnReader.h b/velox/dwio/common/SelectiveFloatingPointColumnReader.h
index 2e71d7aebc2fb..97eb1e7583562 100644
--- a/velox/dwio/common/SelectiveFloatingPointColumnReader.h
+++ b/velox/dwio/common/SelectiveFloatingPointColumnReader.h
@@ -26,26 +26,28 @@ class SelectiveFloatingPointColumnReader : public SelectiveColumnReader {
   using ValueType = TRequested;
   SelectiveFloatingPointColumnReader(
       const TypePtr& requestedType,
-      std::shared_ptr<const dwio::common::TypeWithId> dataType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       FormatParams& params,
       velox::common::ScanSpec& scanSpec)
       : SelectiveColumnReader(
             requestedType,
+            std::move(fileType),
             params,
-            scanSpec,
-            std::move(dataType)) {}
+            scanSpec) {}
 
   // Offers fast path only if data and result widths match.
   bool hasBulkPath() const override {
     return std::is_same_v<TData, TRequested>;
   }
 
-  template <typename Reader>
-  void
-  readCommon(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls);
+  template <typename Reader, bool kEncodingHasNulls>
+  void readCommon(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls);
 
-  void getValues(RowSet rows, VectorPtr* result) override {
-    getFlatValues<TRequested, TRequested>(rows, result, requestedType_);
+  void getValues(const RowSet& rows, VectorPtr* result) override {
+    getFlatValues<TData, TRequested>(rows, result, requestedType_);
   }
 
  protected:
@@ -54,17 +56,23 @@ class SelectiveFloatingPointColumnReader : public SelectiveColumnReader {
       typename TFilter,
       bool isDense,
       typename ExtractValues>
-  void
-  readHelper(velox::common::Filter* filter, RowSet rows, ExtractValues values);
+  void readHelper(
+      velox::common::Filter* filter,
+      const RowSet& rows,
+      ExtractValues values);
 
-  template <typename Reader, bool isDense, typename ExtractValues>
+  template <
+      typename Reader,
+      bool isDense,
+      bool kEncodingHasNulls,
+      typename ExtractValues>
   void processFilter(
       velox::common::Filter* filter,
-      RowSet rows,
+      const RowSet& rows,
       ExtractValues extractValues);
 
   template <typename Reader, bool isDense>
-  void processValueHook(RowSet rows, ValueHook* hook);
+  void processValueHook(const RowSet& rows, ValueHook* hook);
 };
 
 template <typename TData, typename TRequested>
@@ -75,31 +83,48 @@ template <
     typename ExtractValues>
 void SelectiveFloatingPointColumnReader<TData, TRequested>::readHelper(
     velox::common::Filter* filter,
-    RowSet rows,
+    const RowSet& rows,
     ExtractValues extractValues) {
   reinterpret_cast<Reader*>(this)->readWithVisitor(
       rows,
-      ColumnVisitor<TRequested, TFilter, ExtractValues, isDense>(
+      ColumnVisitor<TData, TFilter, ExtractValues, isDense>(
           *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
 }
 
 template <typename TData, typename TRequested>
-template <typename Reader, bool isDense, typename ExtractValues>
+template <
+    typename Reader,
+    bool isDense,
+    bool kEncodingHasNulls,
+    typename ExtractValues>
 void SelectiveFloatingPointColumnReader<TData, TRequested>::processFilter(
     velox::common::Filter* filter,
-    RowSet rows,
+    const RowSet& rows,
     ExtractValues extractValues) {
-  switch (filter ? filter->kind() : velox::common::FilterKind::kAlwaysTrue) {
+  if (filter == nullptr) {
+    readHelper<Reader, velox::common::AlwaysTrue, isDense>(
+        &dwio::common::alwaysTrue(), rows, extractValues);
+    return;
+  }
+
+  switch (filter->kind()) {
     case velox::common::FilterKind::kAlwaysTrue:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
           filter, rows, extractValues);
       break;
     case velox::common::FilterKind::kIsNull:
-      filterNulls<TRequested>(
-          rows, true, !std::is_same_v<decltype(extractValues), DropValues>);
+      if constexpr (kEncodingHasNulls) {
+        filterNulls<TRequested>(
+            rows, true, !std::is_same_v<decltype(extractValues), DropValues>);
+      } else {
+        readHelper<Reader, velox::common::IsNull, isDense>(
+            filter, rows, extractValues);
+      }
       break;
     case velox::common::FilterKind::kIsNotNull:
-      if (std::is_same_v<decltype(extractValues), DropValues>) {
+      if constexpr (
+          kEncodingHasNulls &&
+          std::is_same_v<decltype(extractValues), DropValues>) {
         filterNulls<TRequested>(rows, false, false);
       } else {
         readHelper<Reader, velox::common::IsNotNull, isDense>(
@@ -121,30 +146,20 @@ void SelectiveFloatingPointColumnReader<TData, TRequested>::processFilter(
 template <typename TData, typename TRequested>
 template <typename Reader, bool isDense>
 void SelectiveFloatingPointColumnReader<TData, TRequested>::processValueHook(
-    RowSet rows,
+    const RowSet& rows,
     ValueHook* hook) {
   switch (hook->kind()) {
-    case aggregate::AggregationHook::kSumFloatToDouble:
-      readHelper<Reader, velox::common::AlwaysTrue, isDense>(
-          &alwaysTrue(),
-          rows,
-          ExtractToHook<aggregate::SumHook<float, double>>(hook));
-      break;
-    case aggregate::AggregationHook::kSumDoubleToDouble:
+    case aggregate::AggregationHook::kDoubleSum:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
-          &alwaysTrue(),
-          rows,
-          ExtractToHook<aggregate::SumHook<double, double>>(hook));
+          &alwaysTrue(), rows, ExtractToHook<aggregate::SumHook<double>>(hook));
       break;
-    case aggregate::AggregationHook::kFloatMax:
-    case aggregate::AggregationHook::kDoubleMax:
+    case aggregate::AggregationHook::kFloatingPointMax:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
           &alwaysTrue(),
           rows,
           ExtractToHook<aggregate::MinMaxHook<TRequested, false>>(hook));
       break;
-    case aggregate::AggregationHook::kFloatMin:
-    case aggregate::AggregationHook::kDoubleMin:
+    case aggregate::AggregationHook::kFloatingPointMin:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
           &alwaysTrue(),
           rows,
@@ -157,12 +172,12 @@ void SelectiveFloatingPointColumnReader<TData, TRequested>::processValueHook(
 }
 
 template <typename TData, typename TRequested>
-template <typename Reader>
+template <typename Reader, bool kEncodingHasNulls>
 void SelectiveFloatingPointColumnReader<TData, TRequested>::readCommon(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
-  prepareRead<TRequested>(offset, rows, incomingNulls);
+  prepareRead<TData>(offset, rows, incomingNulls);
   bool isDense = rows.back() == rows.size() - 1;
   if (scanSpec_->keepValues()) {
     if (scanSpec_->valueHook()) {
@@ -173,18 +188,20 @@ void SelectiveFloatingPointColumnReader<TData, TRequested>::readCommon(
       }
     } else {
       if (isDense) {
-        processFilter<Reader, true>(
+        processFilter<Reader, true, kEncodingHasNulls>(
             scanSpec_->filter(), rows, ExtractToReader(this));
       } else {
-        processFilter<Reader, false>(
+        processFilter<Reader, false, kEncodingHasNulls>(
             scanSpec_->filter(), rows, ExtractToReader(this));
       }
     }
   } else {
     if (isDense) {
-      processFilter<Reader, true>(scanSpec_->filter(), rows, DropValues());
+      processFilter<Reader, true, kEncodingHasNulls>(
+          scanSpec_->filter(), rows, DropValues());
     } else {
-      processFilter<Reader, false>(scanSpec_->filter(), rows, DropValues());
+      processFilter<Reader, false, kEncodingHasNulls>(
+          scanSpec_->filter(), rows, DropValues());
     }
   }
 }
diff --git a/velox/dwio/common/SelectiveIntegerColumnReader.h b/velox/dwio/common/SelectiveIntegerColumnReader.h
index cb88227d1c2bd..2716f800bba83 100644
--- a/velox/dwio/common/SelectiveIntegerColumnReader.h
+++ b/velox/dwio/common/SelectiveIntegerColumnReader.h
@@ -20,37 +20,41 @@
 
 namespace facebook::velox::dwio::common {
 
-// Abstract class for format and encoding-independent parts of reading ingeger
-// columns.
+/// Abstract class for format and encoding-independent parts of reading integer
+/// columns.
 class SelectiveIntegerColumnReader : public SelectiveColumnReader {
  public:
   SelectiveIntegerColumnReader(
       const TypePtr& requestedType,
       dwio::common::FormatParams& params,
       velox::common::ScanSpec& scanSpec,
-      std::shared_ptr<const dwio::common::TypeWithId> type)
+      std::shared_ptr<const dwio::common::TypeWithId> fileType)
       : SelectiveColumnReader(
             requestedType,
+            std::move(fileType),
             params,
-            scanSpec,
-            std::move(type)) {}
+            scanSpec) {}
 
-  void getValues(RowSet rows, VectorPtr* result) override {
+  void getValues(const RowSet& rows, VectorPtr* result) override {
     getIntValues(rows, requestedType_, result);
   }
 
  protected:
   // Switches based on filter type between different readHelper instantiations.
-  template <typename Reader, bool isDense, typename ExtractValues>
+  template <
+      typename Reader,
+      bool isDense,
+      bool kEncodingHasNulls,
+      typename ExtractValues>
   void processFilter(
       velox::common::Filter* filter,
       ExtractValues extractValues,
-      RowSet rows);
+      const RowSet& rows);
 
   // Switches based on the type of ValueHook between different readWithVisitor
   // instantiations.
-  template <typename Reader, bool isDence>
-  void processValueHook(RowSet rows, ValueHook* hook);
+  template <typename Reader, bool isDense>
+  void processValueHook(const RowSet& rows, ValueHook* hook);
 
   // Instantiates a Visitor based on type, isDense, value processing.
   template <
@@ -60,14 +64,14 @@ class SelectiveIntegerColumnReader : public SelectiveColumnReader {
       typename ExtractValues>
   void readHelper(
       velox::common::Filter* filter,
-      RowSet rows,
+      const RowSet& rows,
       ExtractValues extractValues);
 
   // The common part of integer reading. calls the appropriate
   // instantiation of processValueHook or processFilter based on
   // possible value hook, filter and denseness.
-  template <typename Reader>
-  void readCommon(RowSet rows);
+  template <typename Reader, bool kEncodingHasNulls>
+  void readCommon(const RowSet& rows);
 };
 
 template <
@@ -77,7 +81,7 @@ template <
     typename ExtractValues>
 void SelectiveIntegerColumnReader::readHelper(
     velox::common::Filter* filter,
-    RowSet rows,
+    const RowSet& rows,
     ExtractValues extractValues) {
   switch (valueSize_) {
     case 2:
@@ -113,22 +117,39 @@ void SelectiveIntegerColumnReader::readHelper(
   }
 }
 
-template <typename Reader, bool isDense, typename ExtractValues>
+template <
+    typename Reader,
+    bool isDense,
+    bool kEncodingHasNulls,
+    typename ExtractValues>
 void SelectiveIntegerColumnReader::processFilter(
     velox::common::Filter* filter,
     ExtractValues extractValues,
-    RowSet rows) {
-  switch (filter ? filter->kind() : velox::common::FilterKind::kAlwaysTrue) {
+    const RowSet& rows) {
+  if (filter == nullptr) {
+    readHelper<Reader, velox::common::AlwaysTrue, isDense>(
+        &dwio::common::alwaysTrue(), rows, extractValues);
+    return;
+  }
+
+  switch (filter->kind()) {
     case velox::common::FilterKind::kAlwaysTrue:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
           filter, rows, extractValues);
       break;
     case velox::common::FilterKind::kIsNull:
-      filterNulls<int64_t>(
-          rows, true, !std::is_same_v<decltype(extractValues), DropValues>);
+      if constexpr (kEncodingHasNulls) {
+        filterNulls<int64_t>(
+            rows, true, !std::is_same_v<decltype(extractValues), DropValues>);
+      } else {
+        readHelper<Reader, velox::common::IsNull, isDense>(
+            filter, rows, extractValues);
+      }
       break;
     case velox::common::FilterKind::kIsNotNull:
-      if (std::is_same_v<decltype(extractValues), DropValues>) {
+      if constexpr (
+          kEncodingHasNulls &&
+          std::is_same_v<decltype(extractValues), DropValues>) {
         filterNulls<int64_t>(rows, false, false);
       } else {
         readHelper<Reader, velox::common::IsNotNull, isDense>(
@@ -172,14 +193,20 @@ void SelectiveIntegerColumnReader::processFilter(
 
 template <typename Reader, bool isDense>
 void SelectiveIntegerColumnReader::processValueHook(
-    RowSet rows,
+    const RowSet& rows,
     ValueHook* hook) {
   switch (hook->kind()) {
-    case aggregate::AggregationHook::kSumBigintToBigint:
+    case aggregate::AggregationHook::kBigintSum:
+      readHelper<Reader, velox::common::AlwaysTrue, isDense>(
+          &alwaysTrue(),
+          rows,
+          ExtractToHook<aggregate::SumHook<int64_t, false>>(hook));
+      break;
+    case aggregate::AggregationHook::kBigintSumOverflow:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
           &alwaysTrue(),
           rows,
-          ExtractToHook<aggregate::SumHook<int64_t, int64_t>>(hook));
+          ExtractToHook<aggregate::SumHook<int64_t, true>>(hook));
       break;
     case aggregate::AggregationHook::kBigintMax:
       readHelper<Reader, velox::common::AlwaysTrue, isDense>(
@@ -199,9 +226,9 @@ void SelectiveIntegerColumnReader::processValueHook(
   }
 }
 
-template <typename Reader>
-void SelectiveIntegerColumnReader::readCommon(RowSet rows) {
-  bool isDense = rows.back() == rows.size() - 1;
+template <typename Reader, bool kEncodingHasNulls>
+void SelectiveIntegerColumnReader::readCommon(const RowSet& rows) {
+  const bool isDense = rows.back() == rows.size() - 1;
   velox::common::Filter* filter =
       scanSpec_->filter() ? scanSpec_->filter() : &alwaysTrue();
   if (scanSpec_->keepValues()) {
@@ -213,16 +240,20 @@ void SelectiveIntegerColumnReader::readCommon(RowSet rows) {
       }
     } else {
       if (isDense) {
-        processFilter<Reader, true>(filter, ExtractToReader(this), rows);
+        processFilter<Reader, true, kEncodingHasNulls>(
+            filter, ExtractToReader(this), rows);
       } else {
-        processFilter<Reader, false>(filter, ExtractToReader(this), rows);
+        processFilter<Reader, false, kEncodingHasNulls>(
+            filter, ExtractToReader(this), rows);
       }
     }
   } else {
     if (isDense) {
-      processFilter<Reader, true>(filter, DropValues(), rows);
+      processFilter<Reader, true, kEncodingHasNulls>(
+          filter, DropValues(), rows);
     } else {
-      processFilter<Reader, false>(filter, DropValues(), rows);
+      processFilter<Reader, false, kEncodingHasNulls>(
+          filter, DropValues(), rows);
     }
   }
 }
diff --git a/velox/dwio/common/SelectiveRepeatedColumnReader.cpp b/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
index 3afbc525d698d..ce2a4a002eab0 100644
--- a/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
+++ b/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
@@ -75,21 +75,32 @@ void prepareResult(
   // makeOffsetsAndSizes.  Child vectors are handled in child column readers.
 }
 
+vector_size_t
+advanceNestedRows(const RowSet& rows, vector_size_t i, vector_size_t last) {
+  while (i + 16 < rows.size() && rows[i + 16] < last) {
+    i += 16;
+  }
+  while (i < rows.size() && rows[i] < last) {
+    ++i;
+  }
+  return i;
+}
+
 } // namespace
 
 void SelectiveRepeatedColumnReader::makeNestedRowSet(
-    RowSet rows,
+    const RowSet& rows,
     int32_t maxRow) {
   if (!allLengthsHolder_ ||
       allLengthsHolder_->capacity() < (maxRow + 1) * sizeof(vector_size_t)) {
-    allLengthsHolder_ = allocateIndices(maxRow + 1, &memoryPool_);
+    allLengthsHolder_ = allocateIndices(maxRow + 1, memoryPool_);
     allLengths_ = allLengthsHolder_->asMutable<vector_size_t>();
   }
-  auto nulls = nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
+  auto* nulls = nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
   // Reads the lengths, leaves an uninitialized gap for a null
   // map/list. Reading these checks the null mask.
   readLengths(allLengths_, maxRow + 1, nulls);
-  vector_size_t nestedLength = 0;
+  vector_size_t nestedLength{0};
   for (auto row : rows) {
     if (!nulls || !bits::isBitNull(nulls, row)) {
       nestedLength +=
@@ -97,11 +108,12 @@ void SelectiveRepeatedColumnReader::makeNestedRowSet(
     }
   }
   nestedRowsHolder_.resize(nestedLength);
+
   vector_size_t currentRow = 0;
   vector_size_t nestedRow = 0;
   vector_size_t nestedOffset = 0;
   for (auto rowIndex = 0; rowIndex < rows.size(); ++rowIndex) {
-    auto row = rows[rowIndex];
+    const auto row = rows[rowIndex];
     // Add up the lengths of non-null rows skipped since the last
     // non-null.
     nestedOffset += sumLengths(allLengths_, nulls, currentRow, row);
@@ -109,7 +121,7 @@ void SelectiveRepeatedColumnReader::makeNestedRowSet(
     if (nulls && bits::isBitNull(nulls, row)) {
       continue;
     }
-    auto lengthAtRow =
+    const auto lengthAtRow =
         std::min(scanSpec_->maxArrayElementsCount(), allLengths_[row]);
     std::iota(
         nestedRowsHolder_.data() + nestedRow,
@@ -124,7 +136,7 @@ void SelectiveRepeatedColumnReader::makeNestedRowSet(
 }
 
 void SelectiveRepeatedColumnReader::makeOffsetsAndSizes(
-    RowSet rows,
+    const RowSet& rows,
     ArrayVectorBase& result) {
   auto* rawOffsets =
       result.mutableOffsets(rows.size())->asMutable<vector_size_t>();
@@ -134,33 +146,27 @@ void SelectiveRepeatedColumnReader::makeOffsetsAndSizes(
   vector_size_t currentOffset = 0;
   vector_size_t nestedRowIndex = 0;
   for (int i = 0; i < rows.size(); ++i) {
-    auto row = rows[i];
+    const auto row = rows[i];
     currentOffset += sumLengths(allLengths_, nulls, currentRow, row);
     currentRow = row + 1;
-    while (nestedRowIndex < nestedRows_.size() &&
-           nestedRows_[nestedRowIndex] < currentOffset) {
-      ++nestedRowIndex;
-    }
+    nestedRowIndex =
+        advanceNestedRows(nestedRows_, nestedRowIndex, currentOffset);
     rawOffsets[i] = nestedRowIndex;
     if (nulls && bits::isBitNull(nulls, row)) {
       rawSizes[i] = 0;
-      bits::setNull(rawResultNulls_, i);
       anyNulls_ = true;
     } else {
-      vector_size_t length = 0;
       currentOffset += allLengths_[row];
-      while (nestedRowIndex < nestedRows_.size() &&
-             nestedRows_[nestedRowIndex] < currentOffset) {
-        ++length;
-        ++nestedRowIndex;
-      }
-      rawSizes[i] = length;
+      const auto newNestedRowIndex =
+          advanceNestedRows(nestedRows_, nestedRowIndex, currentOffset);
+      rawSizes[i] = newNestedRowIndex - nestedRowIndex;
+      nestedRowIndex = newNestedRowIndex;
     }
   }
   numValues_ = rows.size();
 }
 
-RowSet SelectiveRepeatedColumnReader::applyFilter(RowSet rows) {
+RowSet SelectiveRepeatedColumnReader::applyFilter(const RowSet& rows) {
   if (!scanSpec_->filter()) {
     return rows;
   }
@@ -180,26 +186,13 @@ RowSet SelectiveRepeatedColumnReader::applyFilter(RowSet rows) {
   return outputRows_;
 }
 
-void SelectiveRepeatedColumnReader::setResultNulls(BaseVector& result) {
-  if (anyNulls_) {
-    resultNulls_->setSize(bits::nbytes(result.size()));
-    result.setNulls(resultNulls_);
-  } else {
-    result.resetNulls();
-  }
-}
-
 SelectiveListColumnReader::SelectiveListColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     FormatParams& params,
     velox::common::ScanSpec& scanSpec)
-    : SelectiveRepeatedColumnReader(
-          dataType->type(),
-          params,
-          scanSpec,
-          dataType),
-      requestedType_{requestedType} {}
+    : SelectiveRepeatedColumnReader(requestedType, params, scanSpec, fileType) {
+}
 
 uint64_t SelectiveListColumnReader::skip(uint64_t numValues) {
   numValues = formatData_->skipNulls(numValues);
@@ -226,7 +219,7 @@ uint64_t SelectiveListColumnReader::skip(uint64_t numValues) {
 
 void SelectiveListColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   // Catch up if the child is behind the length stream.
   child_->seekTo(childTargetReadOffset_, false);
@@ -240,39 +233,37 @@ void SelectiveListColumnReader::read(
   readOffset_ = offset + rows.back() + 1;
 }
 
-void SelectiveListColumnReader::getValues(RowSet rows, VectorPtr* result) {
+void SelectiveListColumnReader::getValues(
+    const RowSet& rows,
+    VectorPtr* result) {
   VELOX_DCHECK_NOT_NULL(result);
-  prepareResult(*result, requestedType_->type(), rows.size(), &memoryPool_);
+  prepareResult(*result, requestedType_, rows.size(), memoryPool_);
   auto* resultArray = result->get()->asUnchecked<ArrayVector>();
   makeOffsetsAndSizes(rows, *resultArray);
-  setResultNulls(**result);
+  setComplexNulls(rows, *result);
   if (child_ && !nestedRows_.empty()) {
     auto& elements = resultArray->elements();
-    prepareStructResult(requestedType_->type()->childAt(0), &elements);
+    prepareStructResult(requestedType_->childAt(0), &elements);
     child_->getValues(nestedRows_, &elements);
   }
 }
 
 SelectiveMapColumnReader::SelectiveMapColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     FormatParams& params,
     velox::common::ScanSpec& scanSpec)
-    : SelectiveRepeatedColumnReader(
-          dataType->type(),
-          params,
-          scanSpec,
-          dataType),
-      requestedType_{requestedType} {}
+    : SelectiveRepeatedColumnReader(requestedType, params, scanSpec, fileType) {
+}
 
 uint64_t SelectiveMapColumnReader::skip(uint64_t numValues) {
   numValues = formatData_->skipNulls(numValues);
   if (keyReader_ || elementReader_) {
     std::array<int32_t, kBufferSize> buffer;
-    uint64_t childElements = 0;
-    uint64_t lengthsRead = 0;
+    uint64_t childElements{0};
+    uint64_t lengthsRead{0};
     while (lengthsRead < numValues) {
-      uint64_t chunk =
+      const uint64_t chunk =
           std::min(numValues - lengthsRead, static_cast<uint64_t>(kBufferSize));
       readLengths(buffer.data(), chunk, nullptr);
       for (size_t i = 0; i < chunk; ++i) {
@@ -280,6 +271,7 @@ uint64_t SelectiveMapColumnReader::skip(uint64_t numValues) {
       }
       lengthsRead += chunk;
     }
+
     if (keyReader_) {
       keyReader_->seekTo(keyReader_->readOffset() + childElements, false);
     }
@@ -288,7 +280,6 @@ uint64_t SelectiveMapColumnReader::skip(uint64_t numValues) {
           elementReader_->readOffset() + childElements, false);
     }
     childTargetReadOffset_ += childElements;
-
   } else {
     VELOX_FAIL("repeated reader with no children");
   }
@@ -297,7 +288,7 @@ uint64_t SelectiveMapColumnReader::skip(uint64_t numValues) {
 
 void SelectiveMapColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   // Catch up if child readers are behind the length stream.
   if (keyReader_) {
@@ -308,7 +299,7 @@ void SelectiveMapColumnReader::read(
   }
 
   prepareRead<char>(offset, rows, incomingNulls);
-  auto activeRows = applyFilter(rows);
+  const auto activeRows = applyFilter(rows);
   makeNestedRowSet(activeRows, rows.back());
   if (keyReader_ && elementReader_ && !nestedRows_.empty()) {
     keyReader_->read(keyReader_->readOffset(), nestedRows_, nullptr);
@@ -321,12 +312,18 @@ void SelectiveMapColumnReader::read(
   readOffset_ = offset + rows.back() + 1;
 }
 
-void SelectiveMapColumnReader::getValues(RowSet rows, VectorPtr* result) {
+void SelectiveMapColumnReader::getValues(
+    const RowSet& rows,
+    VectorPtr* result) {
   VELOX_DCHECK_NOT_NULL(result);
-  prepareResult(*result, requestedType_->type(), rows.size(), &memoryPool_);
+  VELOX_CHECK(
+      !result->get() || result->get()->type()->isMap(),
+      "Expect MAP result vector, got {}",
+      result->get()->type()->toString());
+  prepareResult(*result, requestedType_, rows.size(), memoryPool_);
   auto* resultMap = result->get()->asUnchecked<MapVector>();
   makeOffsetsAndSizes(rows, *resultMap);
-  setResultNulls(**result);
+  setComplexNulls(rows, *result);
   VELOX_CHECK(
       keyReader_ && elementReader_,
       "keyReader_ and elementReaer_ must exist in "
@@ -334,7 +331,7 @@ void SelectiveMapColumnReader::getValues(RowSet rows, VectorPtr* result) {
   if (!nestedRows_.empty()) {
     keyReader_->getValues(nestedRows_, &resultMap->mapKeys());
     auto& values = resultMap->mapValues();
-    prepareStructResult(requestedType_->type()->childAt(1), &values);
+    prepareStructResult(requestedType_->childAt(1), &values);
     elementReader_->getValues(nestedRows_, &values);
   }
 }
diff --git a/velox/dwio/common/SelectiveRepeatedColumnReader.h b/velox/dwio/common/SelectiveRepeatedColumnReader.h
index 31175e1261196..c5a60d8b5e6cb 100644
--- a/velox/dwio/common/SelectiveRepeatedColumnReader.h
+++ b/velox/dwio/common/SelectiveRepeatedColumnReader.h
@@ -24,10 +24,6 @@ namespace facebook::velox::dwio::common {
 // logic for dealing with mapping between enclosing and nested rows.
 class SelectiveRepeatedColumnReader : public SelectiveColumnReader {
  public:
-  bool useBulkPath() const override {
-    return false;
-  }
-
   const std::vector<SelectiveColumnReader*>& children() const override {
     return children_;
   }
@@ -43,41 +39,35 @@ class SelectiveRepeatedColumnReader : public SelectiveColumnReader {
       std::shared_ptr<const dwio::common::TypeWithId> type)
       : SelectiveColumnReader(
             requestedType,
+            std::move(type),
             params,
-            scanSpec,
-            std::move(type)) {}
+            scanSpec) {}
 
   /// Reads 'numLengths' next lengths into 'result'. If 'nulls' is
   /// non-null, each kNull bit signifies a null with a length of 0 to
   /// be inserted at the corresponding position in the result. 'nulls'
   /// is expected to be null flags for 'numRows' next rows at the
   /// level of this reader.
-  virtual void readLengths(
-      int32_t* FOLLY_NONNULL lengths,
-      int32_t numLengths,
-      const uint64_t* FOLLY_NULLABLE nulls) = 0;
-
-  // Create row set for child columns based on the row set of parent column.
-  void makeNestedRowSet(RowSet rows, int32_t maxRow);
-
-  // Compute the offsets and lengths based on the current filtered rows passed
-  // in.
-  void makeOffsetsAndSizes(RowSet rows, ArrayVectorBase&);
-
-  // Creates a struct if '*result' is empty and 'type' is a row.
-  void prepareStructResult(
-      const TypePtr& type,
-      VectorPtr* FOLLY_NULLABLE result) {
+  virtual void
+  readLengths(int32_t* lengths, int32_t numLengths, const uint64_t* nulls) = 0;
+
+  /// Create row set for child columns based on the row set of parent column.
+  void makeNestedRowSet(const RowSet& rows, int32_t maxRow);
+
+  /// Compute the offsets and lengths based on the current filtered rows passed
+  /// in.
+  void makeOffsetsAndSizes(const RowSet& rows, ArrayVectorBase&);
+
+  /// Creates a struct if '*result' is empty and 'type' is a row.
+  void prepareStructResult(const TypePtr& type, VectorPtr* result) {
     if (!*result && type->kind() == TypeKind::ROW) {
-      *result = BaseVector::create(type, 0, &memoryPool_);
+      *result = BaseVector::create(type, 0, memoryPool_);
     }
   }
 
   // Apply filter on parent level.  Child filtering should be handled separately
   // in subclasses.
-  RowSet applyFilter(RowSet rows);
-
-  void setResultNulls(BaseVector& result);
+  RowSet applyFilter(const RowSet& rows);
 
   BufferPtr allLengthsHolder_;
   vector_size_t* allLengths_;
@@ -95,8 +85,8 @@ class SelectiveRepeatedColumnReader : public SelectiveColumnReader {
 class SelectiveListColumnReader : public SelectiveRepeatedColumnReader {
  public:
   SelectiveListColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       FormatParams& params,
       velox::common::ScanSpec& scanSpec);
 
@@ -108,21 +98,20 @@ class SelectiveListColumnReader : public SelectiveRepeatedColumnReader {
 
   void read(
       vector_size_t offset,
-      RowSet rows,
-      const uint64_t* FOLLY_NULLABLE incomingNulls) override;
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
-  void getValues(RowSet rows, VectorPtr* FOLLY_NULLABLE result) override;
+  void getValues(const RowSet& rows, VectorPtr* result) override;
 
  protected:
   std::unique_ptr<SelectiveColumnReader> child_;
-  const std::shared_ptr<const dwio::common::TypeWithId> requestedType_;
 };
 
 class SelectiveMapColumnReader : public SelectiveRepeatedColumnReader {
  public:
   SelectiveMapColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       FormatParams& params,
       velox::common::ScanSpec& scanSpec);
 
@@ -135,14 +124,14 @@ class SelectiveMapColumnReader : public SelectiveRepeatedColumnReader {
 
   void read(
       vector_size_t offset,
-      RowSet rows,
-      const uint64_t* FOLLY_NULLABLE incomingNulls) override;
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
-  void getValues(RowSet rows, VectorPtr* FOLLY_NULLABLE result) override;
+  void getValues(const RowSet& rows, VectorPtr* result) override;
 
+ protected:
   std::unique_ptr<SelectiveColumnReader> keyReader_;
   std::unique_ptr<SelectiveColumnReader> elementReader_;
-  const std::shared_ptr<const dwio::common::TypeWithId> requestedType_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveStructColumnReader.cpp b/velox/dwio/common/SelectiveStructColumnReader.cpp
index 6702e58602363..cbe5388ce27f1 100644
--- a/velox/dwio/common/SelectiveStructColumnReader.cpp
+++ b/velox/dwio/common/SelectiveStructColumnReader.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/dwio/common/SelectiveStructColumnReader.h"
 
+#include "velox/common/process/TraceContext.h"
 #include "velox/dwio/common/ColumnLoader.h"
 
 namespace facebook::velox::dwio::common {
@@ -52,72 +53,127 @@ uint64_t SelectiveStructColumnReaderBase::skip(uint64_t numValues) {
   return numValues;
 }
 
+void SelectiveStructColumnReaderBase::fillOutputRowsFromMutation(
+    vector_size_t size) {
+  if (mutation_->deletedRows) {
+    bits::forEachUnsetBit(mutation_->deletedRows, 0, size, [&](auto i) {
+      if ((mutation_->randomSkip == nullptr) ||
+          mutation_->randomSkip->testOne()) {
+        addOutputRow(i);
+      }
+    });
+  } else {
+    VELOX_CHECK_NOT_NULL(mutation_->randomSkip);
+    vector_size_t i = 0;
+    while (i < size) {
+      const auto skip = mutation_->randomSkip->nextSkip();
+      const auto remaining = size - i;
+      if (skip >= remaining) {
+        mutation_->randomSkip->consume(remaining);
+        break;
+      }
+      i += skip;
+      addOutputRow(i++);
+      mutation_->randomSkip->consume(skip + 1);
+    }
+  }
+}
+
+namespace {
+
+bool testFilterOnConstant(const velox::common::ScanSpec& spec) {
+  if (spec.isConstant() && !spec.constantValue()->isNullAt(0)) {
+    // Non-null constant is known value during split scheduling and filters on
+    // them should not be handled at execution level.
+    return true;
+  }
+  // Check filter on missing field.
+  return !spec.hasFilter() || spec.testNull();
+}
+
+} // namespace
+
 void SelectiveStructColumnReaderBase::next(
     uint64_t numValues,
     VectorPtr& result,
     const Mutation* mutation) {
+  process::TraceContext trace("SelectiveStructColumnReaderBase::next");
+  mutation_ = mutation;
+  hasDeletion_ = common::hasDeletion(mutation);
   if (children_.empty()) {
-    if (mutation && mutation->deletedRows) {
-      numValues -= bits::countBits(mutation->deletedRows, 0, numValues);
+    if (hasDeletion_) {
+      if (fillMutatedOutputRows_) {
+        fillOutputRowsFromMutation(numValues);
+        numValues = outputRows_.size();
+      } else {
+        if (mutation->deletedRows) {
+          numValues -= bits::countBits(mutation->deletedRows, 0, numValues);
+        }
+        if (mutation->randomSkip) {
+          numValues *= mutation->randomSkip->sampleRate();
+        }
+      }
+    }
+    for (const auto& childSpec : scanSpec_->children()) {
+      if (isChildConstant(*childSpec) && !testFilterOnConstant(*childSpec)) {
+        numValues = 0;
+        break;
+      }
     }
 
-    // no readers
+    // No readers
     // This can be either count(*) query or a query that select only
     // constant columns (partition keys or columns missing from an old file
-    // due to schema evolution)
-    result->resize(numValues);
-
+    // due to schema evolution) or row number column.
     auto resultRowVector = std::dynamic_pointer_cast<RowVector>(result);
-    auto& childSpecs = scanSpec_->children();
-    for (auto& childSpec : childSpecs) {
-      VELOX_CHECK(childSpec->isConstant());
-      if (childSpec->projectOut()) {
-        auto channel = childSpec->channel();
+    resultRowVector->unsafeResize(numValues);
+
+    for (auto& childSpec : scanSpec_->children()) {
+      VELOX_CHECK(childSpec->isConstant() || childSpec->isExplicitRowNumber());
+      if (childSpec->projectOut() && childSpec->isConstant()) {
+        const auto channel = childSpec->channel();
         resultRowVector->childAt(channel) = BaseVector::wrapInConstant(
             numValues, 0, childSpec->constantValue());
       }
     }
     return;
   }
-  auto oldSize = rows_.size();
+
+  const auto oldSize = rows_.size();
   rows_.resize(numValues);
   if (numValues > oldSize) {
     std::iota(&rows_[oldSize], &rows_[rows_.size()], oldSize);
   }
-  mutation_ = mutation;
-  hasMutation_ = mutation && mutation->deletedRows;
   read(readOffset_, rows_, nullptr);
   getValues(outputRows(), &result);
 }
 
 void SelectiveStructColumnReaderBase::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   numReads_ = scanSpec_->newRead();
   prepareRead<char>(offset, rows, incomingNulls);
   RowSet activeRows = rows;
-  if (hasMutation_) {
+  if (hasDeletion_) {
     // We handle the mutation after prepareRead so that output rows and format
     // specific initializations (e.g. RepDef in Parquet) are done properly.
-    VELOX_DCHECK(!nullsInReadRange_, "Only top level can have mutation");
+    VELOX_DCHECK_NULL(nullsInReadRange_, "Only top level can have mutation");
     VELOX_DCHECK_EQ(
         rows.back(), rows.size() - 1, "Top level should have a dense row set");
-    bits::forEachUnsetBit(
-        mutation_->deletedRows, 0, rows.back() + 1, [&](auto i) {
-          addOutputRow(i);
-        });
+    fillOutputRowsFromMutation(rows.size());
     if (outputRows_.empty()) {
       readOffset_ = offset + rows.back() + 1;
       return;
     }
     activeRows = outputRows_;
   }
+
   const uint64_t* structNulls =
       nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
-  // a struct reader may have a null/non-null filter
+  // A struct reader may have a null/non-null filter
   if (scanSpec_->filter()) {
-    auto kind = scanSpec_->filter()->kind();
+    const auto kind = scanSpec_->filter()->kind();
     VELOX_CHECK(
         kind == velox::common::FilterKind::kIsNull ||
         kind == velox::common::FilterKind::kIsNotNull);
@@ -132,20 +188,31 @@ void SelectiveStructColumnReaderBase::read(
     activeRows = outputRows_;
   }
 
-  auto& childSpecs = scanSpec_->children();
+  const auto& childSpecs = scanSpec_->children();
   VELOX_CHECK(!childSpecs.empty());
   for (size_t i = 0; i < childSpecs.size(); ++i) {
-    auto& childSpec = childSpecs[i];
+    const auto& childSpec = childSpecs[i];
+    VELOX_TRACE_HISTORY_PUSH("read %s", childSpec->fieldName().c_str());
     if (isChildConstant(*childSpec)) {
+      if (!testFilterOnConstant(*childSpec)) {
+        activeRows = {};
+        break;
+      }
       continue;
     }
-    auto fieldIndex = childSpec->subscript();
-    auto reader = children_.at(fieldIndex);
+
+    if (childSpec->isExplicitRowNumber()) {
+      continue;
+    }
+
+    const auto fieldIndex = childSpec->subscript();
+    auto* reader = children_.at(fieldIndex);
     if (reader->isTopLevel() && childSpec->projectOut() &&
         !childSpec->hasFilter() && !childSpec->extractValues()) {
       // Will make a LazyVector.
       continue;
     }
+
     advanceFieldReader(reader, offset);
     if (childSpec->hasFilter()) {
       {
@@ -181,18 +248,22 @@ void SelectiveStructColumnReaderBase::read(
 
 void SelectiveStructColumnReaderBase::recordParentNullsInChildren(
     vector_size_t offset,
-    RowSet rows) {
+    const RowSet& rows) {
   if (formatData_->parentNullsInLeaves()) {
     return;
   }
-  auto& childSpecs = scanSpec_->children();
+  const auto& childSpecs = scanSpec_->children();
   for (auto i = 0; i < childSpecs.size(); ++i) {
-    auto& childSpec = childSpecs[i];
+    const auto& childSpec = childSpecs[i];
     if (isChildConstant(*childSpec)) {
       continue;
     }
-    auto fieldIndex = childSpec->subscript();
-    auto reader = children_.at(fieldIndex);
+    if (childSpec->isExplicitRowNumber()) {
+      continue;
+    }
+
+    const auto fieldIndex = childSpec->subscript();
+    auto* reader = children_.at(fieldIndex);
     reader->addParentNulls(
         offset,
         nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr,
@@ -284,24 +355,27 @@ void setConstantField(
   }
 }
 
-void setNullField(vector_size_t size, VectorPtr& field) {
+void setNullField(
+    vector_size_t size,
+    VectorPtr& field,
+    const TypePtr& type,
+    memory::MemoryPool* pool) {
   if (field && field->isConstantEncoding() && field.unique() &&
       field->size() > 0 && field->isNullAt(0)) {
     field->resize(size);
   } else {
-    field = BaseVector::createNullConstant(field->type(), size, field->pool());
+    field = BaseVector::createNullConstant(type, size, pool);
   }
 }
 
 } // namespace
 
 void SelectiveStructColumnReaderBase::getValues(
-    RowSet rows,
+    const RowSet& rows,
     VectorPtr* result) {
   VELOX_CHECK(!scanSpec_->children().empty());
-  VELOX_CHECK(
-      *result != nullptr,
-      "SelectiveStructColumnReaderBase expects a non-null result");
+  VELOX_CHECK_NOT_NULL(
+      *result, "SelectiveStructColumnReaderBase expects a non-null result");
   VELOX_CHECK(
       result->get()->type()->isRow(),
       "Struct reader expects a result of type ROW.");
@@ -320,43 +394,47 @@ void SelectiveStructColumnReaderBase::getValues(
         0,
         std::move(children));
   }
+
   auto* resultRow = static_cast<RowVector*>(result->get());
-  resultRow->resize(rows.size());
-  if (!rows.size()) {
+  resultRow->unsafeResize(rows.size());
+  if (rows.empty()) {
     return;
   }
-  if (nullsInReadRange_) {
-    auto readerNulls = nullsInReadRange_->as<uint64_t>();
-    auto* nulls = resultRow->mutableNulls(rows.size())->asMutable<uint64_t>();
-    for (size_t i = 0; i < rows.size(); ++i) {
-      bits::setBit(nulls, i, bits::isBitSet(readerNulls, rows[i]));
-    }
-  } else {
-    resultRow->clearNulls(0, rows.size());
-  }
+
+  setComplexNulls(rows, *result);
   bool lazyPrepared = false;
-  for (auto& childSpec : scanSpec_->children()) {
+  for (const auto& childSpec : scanSpec_->children()) {
+    VELOX_TRACE_HISTORY_PUSH("getValues %s", childSpec->fieldName().c_str());
     if (!childSpec->projectOut()) {
       continue;
     }
-    auto channel = childSpec->channel();
+
+    if (childSpec->isExplicitRowNumber()) {
+      // Row number data is generated after, skip data loading for it.
+      continue;
+    }
+    const auto channel = childSpec->channel();
     auto& childResult = resultRow->childAt(channel);
     if (childSpec->isConstant()) {
       setConstantField(childSpec->constantValue(), rows.size(), childResult);
       continue;
     }
-    auto index = childSpec->subscript();
+
+    const auto index = childSpec->subscript();
     // Set missing fields to be null constant, if we're in the top level struct
     // missing columns should already be a null constant from the check above.
     if (index == kConstantChildSpecSubscript) {
-      setNullField(rows.size(), childResult);
+      const auto& childType = rowType.childAt(channel);
+      setNullField(rows.size(), childResult, childType, resultRow->pool());
       continue;
     }
+
     if (childSpec->extractValues() || childSpec->hasFilter() ||
         !children_[index]->isTopLevel()) {
       children_[index]->getValues(rows, &childResult);
       continue;
     }
+
     // LazyVector result.
     if (!lazyPrepared) {
       if (rows.size() != outputRows_.size()) {
@@ -364,21 +442,41 @@ void SelectiveStructColumnReaderBase::getValues(
       }
       lazyPrepared = true;
     }
-    auto loader =
+    auto lazyLoader =
         std::make_unique<ColumnLoader>(this, children_[index], numReads_);
     if (childResult && childResult->isLazy() && childResult.unique()) {
       static_cast<LazyVector&>(*childResult)
-          .reset(std::move(loader), rows.size());
+          .reset(std::move(lazyLoader), rows.size());
     } else {
       childResult = std::make_shared<LazyVector>(
-          &memoryPool_,
+          memoryPool_,
           resultRow->type()->childAt(channel),
           rows.size(),
-          std::move(loader),
+          std::move(lazyLoader),
           std::move(childResult));
     }
   }
   resultRow->updateContainsLazyNotLoaded();
 }
 
+namespace detail {
+
+#if XSIMD_WITH_AVX2
+
+xsimd::batch<int32_t> bitsToInt32s[256];
+
+__attribute__((constructor)) void initBitsToInt32s() {
+  for (int i = 0; i < 256; ++i) {
+    int32_t data[8];
+    for (int j = 0; j < 8; ++j) {
+      data[j] = bits::isBitSet(&i, j);
+    }
+    bitsToInt32s[i] = xsimd::load_unaligned(data);
+  }
+}
+
+#endif
+
+} // namespace detail
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveStructColumnReader.h b/velox/dwio/common/SelectiveStructColumnReader.h
index af5ea07ae288d..6f15b321391c1 100644
--- a/velox/dwio/common/SelectiveStructColumnReader.h
+++ b/velox/dwio/common/SelectiveStructColumnReader.h
@@ -20,6 +20,9 @@
 
 namespace facebook::velox::dwio::common {
 
+template <typename T, typename KeyNode, typename FormatData>
+class SelectiveFlatMapColumnReaderHelper;
+
 class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
  public:
   void resetFilterCaches() override {
@@ -37,10 +40,12 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
       const dwio::common::StatsContext& context,
       FormatData::FilterRowGroupsResult&) const override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override;
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
-  void getValues(RowSet rows, VectorPtr* result) override;
+  void getValues(const RowSet& rows, VectorPtr* result) override;
 
   uint64_t numReads() const {
     return numReads_;
@@ -95,38 +100,55 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
     return debugString_;
   }
 
+  void setFillMutatedOutputRows(bool value) final {
+    fillMutatedOutputRows_ = value;
+  }
+
  protected:
+  template <typename T, typename KeyNode, typename FormatData>
+  friend class SelectiveFlatMapColumnReaderHelper;
+
   // The subscript of childSpecs will be set to this value if the column is
   // constant (either explicitly or because it's missing).
   static constexpr int32_t kConstantChildSpecSubscript = -1;
 
   SelectiveStructColumnReaderBase(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       FormatParams& params,
       velox::common::ScanSpec& scanSpec,
       bool isRoot = false)
-      : SelectiveColumnReader(dataType->type(), params, scanSpec, dataType),
-        requestedType_(requestedType),
+      : SelectiveColumnReader(requestedType, fileType, params, scanSpec),
         debugString_(
             getExceptionContext().message(VeloxException::Type::kSystem)),
         isRoot_(isRoot) {}
 
-  // Records the number of nulls added by 'this' between the end
-  // position of each child reader and the end of the range of
-  // 'read(). This must be done also if a child is not read so that we
-  // know how much to skip when seeking forward within the row group.
-  void recordParentNullsInChildren(vector_size_t offset, RowSet rows);
+  /// Records the number of nulls added by 'this' between the end position of
+  /// each child reader and the end of the range of 'read(). This must be done
+  /// also if a child is not read so that we know how much to skip when seeking
+  /// forward within the row group.
+  void recordParentNullsInChildren(vector_size_t offset, const RowSet& rows);
 
-  bool hasMutation() const override {
-    return hasMutation_;
+  bool hasDeletion() const final {
+    return hasDeletion_;
   }
 
   // Returns true if we'll return a constant for that childSpec (i.e. we don't
   // need to read it).
   bool isChildConstant(const velox::common::ScanSpec& childSpec) const;
 
-  const std::shared_ptr<const dwio::common::TypeWithId> requestedType_;
+  void fillOutputRowsFromMutation(vector_size_t size);
+
+  // Context information obtained from ExceptionContext. Stored here
+  // so that LazyVector readers under this can add this to their
+  // ExceptionContext. Allows contextualizing reader errors to split
+  // and query. Set at construction, which takes place on first
+  // use. If no ExceptionContext is in effect, this is "".
+  const std::string debugString_;
+
+  // Whether or not this is the root Struct that represents entire rows of the
+  // table.
+  const bool isRoot_;
 
   std::vector<SelectiveColumnReader*> children_;
 
@@ -143,21 +165,13 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
 
   // After read() call mutation_ could go out of scope.  Need to keep this
   // around for lazy columns.
-  bool hasMutation_ = false;
+  bool hasDeletion_ = false;
 
-  // Context information obtained from ExceptionContext. Stored here
-  // so that LazyVector readers under this can add this to their
-  // ExceptionContext. Allows contextualizing reader errors to split
-  // and query. Set at construction, which takes place on first
-  // use. If no ExceptionContext is in effect, this is "".
-  const std::string debugString_;
-
-  // Whether or not this is the root Struct that represents entire rows of the
-  // table.
-  const bool isRoot_;
+  bool fillMutatedOutputRows_ = false;
 };
 
-struct SelectiveStructColumnReader : SelectiveStructColumnReaderBase {
+class SelectiveStructColumnReader : public SelectiveStructColumnReaderBase {
+ public:
   using SelectiveStructColumnReaderBase::SelectiveStructColumnReaderBase;
 
   void addChild(std::unique_ptr<SelectiveColumnReader> child) {
@@ -171,4 +185,369 @@ struct SelectiveStructColumnReader : SelectiveStructColumnReaderBase {
   std::vector<std::unique_ptr<SelectiveColumnReader>> childrenOwned_;
 };
 
+namespace detail {
+
+template <typename ValueType>
+struct FlatMapDirectCopyHelper {
+  ValueType* targetValues;
+  uint64_t* targetNulls;
+  const ValueType* sourceValues;
+  const uint64_t* sourceNulls;
+};
+
+} // namespace detail
+
+// Helper class to implement reading FLATMAP column into MAP type vector.
+template <typename T, typename KeyNode, typename FormatData>
+class SelectiveFlatMapColumnReaderHelper {
+ public:
+  SelectiveFlatMapColumnReaderHelper(
+      SelectiveStructColumnReaderBase& reader,
+      std::vector<KeyNode>&& keyNodes)
+      : reader_(reader), keyNodes_(std::move(keyNodes)) {
+    reader_.children_.resize(keyNodes_.size());
+    for (int i = 0; i < keyNodes_.size(); ++i) {
+      reader_.children_[i] = keyNodes_[i].reader.get();
+      reader_.children_[i]->setIsFlatMapValue(true);
+    }
+    if (auto type = reader_.requestedType_->childAt(1); type->isRow()) {
+      childValues_ = BaseVector::create(type, 0, reader_.memoryPool_);
+    }
+  }
+
+  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls);
+
+  void getValues(RowSet rows, VectorPtr* result);
+
+ private:
+  MapVector& prepareResult(VectorPtr& result, vector_size_t size) {
+    if (result && result->encoding() == VectorEncoding::Simple::MAP &&
+        result.unique()) {
+      result->resetDataDependentFlags(nullptr);
+      result->resize(size);
+    } else {
+      VLOG(1) << "Reallocating result MAP vector of size " << size;
+      result =
+          BaseVector::create(reader_.requestedType_, size, reader_.memoryPool_);
+    }
+    return *result->asUnchecked<MapVector>();
+  }
+
+  static void readInMapDense(
+      const uint64_t* inMap,
+      vector_size_t size,
+      uint64_t* columnBits,
+      vector_size_t* sizes);
+
+  vector_size_t
+  calculateOffsets(RowSet rows, vector_size_t* offsets, vector_size_t* sizes);
+
+  template <bool kDirectCopy, bool kIdentityMapping, typename ValueType>
+  void copyValuesImpl(
+      vector_size_t* rawOffsets,
+      T* rawKeys,
+      detail::FlatMapDirectCopyHelper<ValueType>& directCopy,
+      T key,
+      const uint64_t* columnBits,
+      vector_size_t size);
+
+  template <TypeKind kKind>
+  void copyValues(
+      RowSet rows,
+      FlatVector<T>* flatKeys,
+      vector_size_t* rawOffsets,
+      BaseVector& values);
+
+  SelectiveStructColumnReaderBase& reader_;
+  std::vector<KeyNode> keyNodes_;
+  VectorPtr childValues_;
+  DecodedVector decodedChildValues_;
+  std::vector<uint64_t> columnRowBits_;
+  int columnBitsWords_;
+  std::vector<BaseVector::CopyRange> copyRanges_;
+};
+
+template <typename T, typename KeyNode, typename FormatData>
+void SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::read(
+    vector_size_t offset,
+    RowSet rows,
+    const uint64_t* incomingNulls) {
+  reader_.numReads_ = reader_.scanSpec_->newRead();
+  reader_.prepareRead<char>(offset, rows, incomingNulls);
+  VELOX_DCHECK(!reader_.hasDeletion());
+  auto activeRows = rows;
+  auto* mapNulls = reader_.nullsInReadRange_
+      ? reader_.nullsInReadRange_->as<uint64_t>()
+      : nullptr;
+  if (reader_.scanSpec_->filter()) {
+    auto kind = reader_.scanSpec_->filter()->kind();
+    VELOX_CHECK(
+        kind == velox::common::FilterKind::kIsNull ||
+        kind == velox::common::FilterKind::kIsNotNull);
+    reader_.filterNulls<int32_t>(
+        rows, kind == velox::common::FilterKind::kIsNull, false);
+    if (reader_.outputRows_.empty()) {
+      for (auto* child : reader_.children_) {
+        child->addParentNulls(offset, mapNulls, rows);
+      }
+      return;
+    }
+    activeRows = reader_.outputRows_;
+  }
+  // Separate the loop to be cache friendly.
+  for (auto* child : reader_.children_) {
+    reader_.advanceFieldReader(child, offset);
+  }
+  for (auto* child : reader_.children_) {
+    child->read(offset, activeRows, mapNulls);
+    child->addParentNulls(offset, mapNulls, rows);
+  }
+  reader_.lazyVectorReadOffset_ = offset;
+  reader_.readOffset_ = offset + rows.back() + 1;
+}
+
+namespace detail {
+#if XSIMD_WITH_AVX2
+// Convert 8 bits to 8 int32s.  Used to increase map sizes according to in-map
+// bits.
+extern xsimd::batch<int32_t> bitsToInt32s[256];
+#endif
+} // namespace detail
+
+// Optimized function to copy contiguous range of `inMap' bits into
+// `columnBits', and at same time increase values in `sizes' so that they will
+// contain map sizes after we iterate over all inMap streams.
+template <typename T, typename KeyNode, typename FormatData>
+void SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::readInMapDense(
+    const uint64_t* inMap,
+    vector_size_t size,
+    uint64_t* columnBits,
+    vector_size_t* sizes) {
+#if XSIMD_WITH_AVX2
+  bits::copyBits(inMap, 0, columnBits, 0, size);
+  auto* inMapBytes = reinterpret_cast<const uint8_t*>(inMap);
+  int i = 0;
+  for (int end = size / 8; i < end; ++i) {
+    auto* data = sizes + i * 8;
+    (xsimd::load_unaligned(data) + detail::bitsToInt32s[inMapBytes[i]])
+        .store_unaligned(data);
+  }
+  i *= 8;
+  for (; i < size; ++i) {
+    if (bits::isBitSet(inMap, i)) {
+      ++sizes[i];
+    }
+  }
+#else
+  for (vector_size_t i = 0; i < size; ++i) {
+    if (bits::isBitSet(inMap, i)) {
+      bits::setBit(columnBits, i);
+      ++sizes[i];
+    }
+  }
+#endif
+}
+
+// Calculate the offsets and sizes of each map entry in the result.
+template <typename T, typename KeyNode, typename FormatData>
+vector_size_t
+SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::calculateOffsets(
+    RowSet rows,
+    vector_size_t* offsets,
+    vector_size_t* sizes) {
+  auto* nulls = reader_.nullsInReadRange_
+      ? reader_.nullsInReadRange_->as<uint64_t>()
+      : nullptr;
+  columnBitsWords_ = bits::nwords(rows.size());
+  columnRowBits_.resize(columnBitsWords_ * reader_.children_.size());
+  std::fill(columnRowBits_.begin(), columnRowBits_.end(), 0);
+  std::fill(sizes, sizes + rows.size(), 0);
+  const bool dense = rows.back() == rows.size() - 1;
+  for (int k = 0; k < reader_.children_.size(); ++k) {
+    auto* inMap =
+        static_cast<const FormatData&>(reader_.children_[k]->formatData())
+            .inMap();
+    if (!inMap) {
+      inMap = nulls;
+    }
+    auto* columnBits = columnRowBits_.data() + k * columnBitsWords_;
+    if (inMap) {
+      if (dense) {
+        readInMapDense(inMap, rows.size(), columnBits, sizes);
+      } else {
+        for (vector_size_t i = 0; i < rows.size(); ++i) {
+          if (bits::isBitSet(inMap, rows[i])) {
+            bits::setBit(columnBits, i);
+            ++sizes[i];
+          }
+        }
+      }
+    } else {
+      bits::fillBits(columnBits, 0, rows.size(), true);
+      for (vector_size_t i = 0; i < rows.size(); ++i) {
+        ++sizes[i];
+      }
+    }
+  }
+  vector_size_t numNestedRows = 0;
+  for (vector_size_t i = 0; i < rows.size(); ++i) {
+    if (!reader_.returnReaderNulls_ && nulls &&
+        bits::isBitNull(nulls, rows[i])) {
+      reader_.anyNulls_ = true;
+    }
+    offsets[i] = numNestedRows;
+    numNestedRows += sizes[i];
+  }
+  return numNestedRows;
+}
+
+// When `kDirectCopy' is true, copy the values directly into the target vector.
+// Otherwise store the copy ranges and they will be copied after calling this
+// function.
+template <typename T, typename KeyNode, typename FormatData>
+template <bool kDirectCopy, bool kIdentityMapping, typename ValueType>
+void SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::copyValuesImpl(
+    vector_size_t* rawOffsets,
+    T* rawKeys,
+    detail::FlatMapDirectCopyHelper<ValueType>& directCopy,
+    T key,
+    const uint64_t* columnBits,
+    vector_size_t size) {
+  bits::forEachSetBit(columnBits, 0, size, [&](vector_size_t i) {
+    auto j = rawOffsets[i]++;
+    rawKeys[j] = key;
+    if constexpr (!kDirectCopy) {
+      copyRanges_.push_back({
+          .sourceIndex = i,
+          .targetIndex = j,
+          .count = 1,
+      });
+    } else if constexpr (kIdentityMapping) {
+      directCopy.targetValues[j] = directCopy.sourceValues[i];
+      // Nulls in identity mapping are handled more efficiently later in the
+      // code after calling this function.
+    } else {
+      directCopy.targetValues[j] = decodedChildValues_.valueAt<ValueType>(i);
+      if (decodedChildValues_.isNullAt(i)) {
+        bits::setNull(directCopy.targetNulls, j);
+      }
+    }
+  });
+}
+
+// Copy the values and nulls bits from source child values into the target
+// values.  When `kDirectCopy' is true, copy the values directly into the target
+// vector, and if the source values are flat (almost always the case), we
+// optimize the nulls copy by avoiding copying the bits where in-map is false.
+template <typename T, typename KeyNode, typename FormatData>
+template <TypeKind kKind>
+void SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::copyValues(
+    RowSet rows,
+    FlatVector<T>* flatKeys,
+    vector_size_t* rawOffsets,
+    BaseVector& values) {
+  // String values are not copied directly because currently we don't have
+  // them in production so no need to optimize.
+  constexpr bool kDirectCopy =
+      TypeKind::TINYINT <= kKind && kKind <= TypeKind::DOUBLE;
+  using ValueType = typename TypeTraits<kKind>::NativeType;
+  T* rawKeys = flatKeys->mutableRawValues();
+  [[maybe_unused]] size_t strKeySize;
+  [[maybe_unused]] char* rawStrKeyBuffer;
+  if constexpr (std::is_same_v<T, StringView>) {
+    strKeySize = 0;
+    for (int k = 0; k < reader_.children_.size(); ++k) {
+      if (!keyNodes_[k].key.get().isInline()) {
+        strKeySize += keyNodes_[k].key.get().size();
+      }
+    }
+    if (strKeySize > 0) {
+      auto buf = AlignedBuffer::allocate<char>(strKeySize, reader_.memoryPool_);
+      rawStrKeyBuffer = buf->template asMutable<char>();
+      flatKeys->addStringBuffer(buf);
+      strKeySize = 0;
+      for (int k = 0; k < reader_.children_.size(); ++k) {
+        auto& s = keyNodes_[k].key.get();
+        if (!s.isInline()) {
+          memcpy(&rawStrKeyBuffer[strKeySize], s.data(), s.size());
+          strKeySize += s.size();
+        }
+      }
+      strKeySize = 0;
+    }
+  }
+  detail::FlatMapDirectCopyHelper<ValueType> directCopy;
+  if constexpr (kDirectCopy) {
+    VELOX_CHECK(values.isFlatEncoding());
+    auto* flat = values.asUnchecked<FlatVector<ValueType>>();
+    directCopy.targetValues = flat->mutableRawValues();
+    directCopy.targetNulls = flat->mutableRawNulls();
+    bits::fillBits(directCopy.targetNulls, 0, flat->size(), bits::kNotNull);
+  }
+  for (int k = 0; k < reader_.children_.size(); ++k) {
+    T key;
+    if constexpr (std::is_same_v<T, StringView>) {
+      key = keyNodes_[k].key.get();
+      if (!key.isInline()) {
+        key = {&rawStrKeyBuffer[strKeySize], static_cast<int32_t>(key.size())};
+        strKeySize += key.size();
+      }
+    } else {
+      key = keyNodes_[k].key.get();
+    }
+    reader_.children_[k]->getValues(rows, &childValues_);
+    if constexpr (kDirectCopy) {
+      decodedChildValues_.decode(*childValues_);
+      if (decodedChildValues_.isIdentityMapping()) {
+        directCopy.sourceValues = decodedChildValues_.data<ValueType>();
+        directCopy.sourceNulls = decodedChildValues_.nulls();
+      }
+    }
+    auto* columnBits = columnRowBits_.data() + k * columnBitsWords_;
+    if (decodedChildValues_.isIdentityMapping()) {
+      copyValuesImpl<kDirectCopy, true>(
+          rawOffsets, rawKeys, directCopy, key, columnBits, rows.size());
+    } else {
+      copyValuesImpl<kDirectCopy, false>(
+          rawOffsets, rawKeys, directCopy, key, columnBits, rows.size());
+    }
+    if constexpr (kDirectCopy) {
+      if (directCopy.sourceNulls && decodedChildValues_.isIdentityMapping()) {
+        bits::andWithNegatedBits(
+            columnBits, directCopy.sourceNulls, 0, rows.size());
+        bits::forEachSetBit(columnBits, 0, rows.size(), [&](vector_size_t i) {
+          bits::setNull(directCopy.targetNulls, rawOffsets[i] - 1);
+        });
+      }
+    } else {
+      values.copyRanges(childValues_.get(), copyRanges_);
+      copyRanges_.clear();
+    }
+  }
+}
+
+template <typename T, typename KeyNode, typename FormatData>
+void SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::getValues(
+    RowSet rows,
+    VectorPtr* result) {
+  auto& mapResult = prepareResult(*result, rows.size());
+  auto* rawOffsets = mapResult.mutableOffsets(rows.size())
+                         ->template asMutable<vector_size_t>();
+  auto* rawSizes =
+      mapResult.mutableSizes(rows.size())->template asMutable<vector_size_t>();
+  auto numNestedRows = calculateOffsets(rows, rawOffsets, rawSizes);
+  auto& keys = mapResult.mapKeys();
+  auto& values = mapResult.mapValues();
+  BaseVector::prepareForReuse(keys, numNestedRows);
+  BaseVector::prepareForReuse(values, numNestedRows);
+  auto* flatKeys = keys->template asFlatVector<T>();
+  VELOX_DYNAMIC_TYPE_DISPATCH(
+      copyValues, values->typeKind(), rows, flatKeys, rawOffsets, *values);
+  VELOX_CHECK_EQ(rawOffsets[rows.size() - 1], numNestedRows);
+  std::copy_backward(
+      rawOffsets, rawOffsets + rows.size() - 1, rawOffsets + rows.size());
+  rawOffsets[0] = 0;
+  reader_.setComplexNulls(rows, *result);
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SortingWriter.cpp b/velox/dwio/common/SortingWriter.cpp
index 813f333e6319f..0243db048bbcd 100644
--- a/velox/dwio/common/SortingWriter.cpp
+++ b/velox/dwio/common/SortingWriter.cpp
@@ -20,28 +20,138 @@ namespace facebook::velox::dwio::common {
 
 SortingWriter::SortingWriter(
     std::unique_ptr<Writer> writer,
-    std::unique_ptr<exec::SortBuffer> sortBuffer)
-    : outputWriter_(std::move(writer)), sortBuffer_(std::move(sortBuffer)) {}
+    std::unique_ptr<exec::SortBuffer> sortBuffer,
+    vector_size_t maxOutputRowsConfig,
+    uint64_t maxOutputBytesConfig)
+    : outputWriter_(std::move(writer)),
+      maxOutputRowsConfig_(maxOutputRowsConfig),
+      maxOutputBytesConfig_(maxOutputBytesConfig),
+      sortPool_(sortBuffer->pool()),
+      canReclaim_(sortBuffer->canSpill()),
+      sortBuffer_(std::move(sortBuffer)) {
+  VELOX_CHECK_GT(maxOutputRowsConfig_, 0);
+  VELOX_CHECK_GT(maxOutputBytesConfig_, 0);
+  if (sortPool_->parent()->reclaimer() != nullptr) {
+    sortPool_->setReclaimer(MemoryReclaimer::create(this));
+  }
+  setState(State::kRunning);
+}
+
+SortingWriter::~SortingWriter() {
+  sortPool_->release();
+}
 
 void SortingWriter::write(const VectorPtr& data) {
+  checkRunning();
   sortBuffer_->addInput(data);
 }
 
-void SortingWriter::flush() {}
+void SortingWriter::flush() {
+  checkRunning();
+  outputWriter_->flush();
+}
 
 void SortingWriter::close() {
+  setState(State::kClosed);
+
   sortBuffer_->noMoreInput();
-  RowVectorPtr output = sortBuffer_->getOutput();
+  const auto maxOutputBatchRows = outputBatchRows();
+  RowVectorPtr output = sortBuffer_->getOutput(maxOutputBatchRows);
   while (output != nullptr) {
     outputWriter_->write(output);
-    output = sortBuffer_->getOutput();
+    output = sortBuffer_->getOutput(maxOutputBatchRows);
   }
+
+  sortBuffer_.reset();
+  sortPool_->release();
   outputWriter_->close();
 }
 
 void SortingWriter::abort() {
+  setState(State::kAborted);
+
   sortBuffer_.reset();
+  sortPool_->release();
   outputWriter_->abort();
 }
 
+bool SortingWriter::canReclaim() const {
+  return canReclaim_;
+}
+
+uint64_t SortingWriter::reclaim(
+    uint64_t targetBytes,
+    memory::MemoryReclaimer::Stats& stats) {
+  if (!canReclaim_) {
+    return 0;
+  }
+
+  if (!isRunning()) {
+    LOG(WARNING) << "Can't reclaim from a not running hive sort writer pool: "
+                 << sortPool_->name() << ", state: " << state()
+                 << "used memory: " << succinctBytes(sortPool_->usedBytes())
+                 << ", reserved memory: "
+                 << succinctBytes(sortPool_->reservedBytes());
+    ++stats.numNonReclaimableAttempts;
+    return 0;
+  }
+  VELOX_CHECK_NOT_NULL(sortBuffer_);
+
+  return memory::MemoryReclaimer::run(
+      [&]() {
+        int64_t reclaimedBytes{0};
+        {
+          memory::ScopedReclaimedBytesRecorder recorder(
+              sortPool_, &reclaimedBytes);
+          sortBuffer_->spill();
+          sortPool_->release();
+        }
+        return reclaimedBytes;
+      },
+      stats);
+}
+
+vector_size_t SortingWriter::outputBatchRows() {
+  vector_size_t estimatedMaxOutputRows =
+      std::numeric_limits<vector_size_t>::max();
+  if (sortBuffer_->estimateOutputRowSize().has_value() &&
+      sortBuffer_->estimateOutputRowSize().value() != 0) {
+    const uint64_t maxOutputRows =
+        maxOutputBytesConfig_ / sortBuffer_->estimateOutputRowSize().value();
+    if (UNLIKELY(maxOutputRows > std::numeric_limits<vector_size_t>::max())) {
+      return maxOutputRowsConfig_;
+    }
+
+    estimatedMaxOutputRows = maxOutputRows;
+  }
+  return std::min(estimatedMaxOutputRows, maxOutputRowsConfig_);
+}
+
+std::unique_ptr<memory::MemoryReclaimer> SortingWriter::MemoryReclaimer::create(
+    SortingWriter* writer) {
+  return std::unique_ptr<memory::MemoryReclaimer>(new MemoryReclaimer(writer));
+}
+
+bool SortingWriter::MemoryReclaimer::reclaimableBytes(
+    const memory::MemoryPool& pool,
+    uint64_t& reclaimableBytes) const {
+  VELOX_CHECK_EQ(pool.name(), writer_->sortPool_->name());
+
+  reclaimableBytes = 0;
+  if (!writer_->canReclaim()) {
+    return false;
+  }
+  reclaimableBytes = pool.usedBytes();
+  return true;
+}
+
+uint64_t SortingWriter::MemoryReclaimer::reclaim(
+    memory::MemoryPool* pool,
+    uint64_t targetBytes,
+    uint64_t /*unused*/,
+    memory::MemoryReclaimer::Stats& stats) {
+  VELOX_CHECK_EQ(pool->name(), writer_->sortPool_->name());
+
+  return writer_->reclaim(targetBytes, stats);
+}
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SortingWriter.h b/velox/dwio/common/SortingWriter.h
index f07b2d9e67f0a..d7b70f09032d2 100644
--- a/velox/dwio/common/SortingWriter.h
+++ b/velox/dwio/common/SortingWriter.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "velox/dwio/common/Writer.h"
+#include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/SortBuffer.h"
 
 namespace facebook::velox::dwio::common {
@@ -26,19 +27,60 @@ class SortingWriter : public Writer {
  public:
   SortingWriter(
       std::unique_ptr<Writer> writer,
-      std::unique_ptr<exec::SortBuffer> sortBuffer);
+      std::unique_ptr<exec::SortBuffer> sortBuffer,
+      vector_size_t maxOutputRowsConfig,
+      uint64_t maxOutputBytesConfig);
 
-  virtual void write(const VectorPtr& data) override;
+  ~SortingWriter() override;
+
+  void write(const VectorPtr& data) override;
 
   /// No action because we need to accumulate all data and sort before data can
   /// be flushed
-  virtual void flush() override;
+  void flush() override;
+
+  void close() override;
+
+  void abort() override;
+
+ private:
+  class MemoryReclaimer : public exec::MemoryReclaimer {
+   public:
+    static std::unique_ptr<memory::MemoryReclaimer> create(
+        SortingWriter* writer);
+
+    bool reclaimableBytes(
+        const memory::MemoryPool& pool,
+        uint64_t& reclaimableBytes) const override;
 
-  virtual void close() override;
+    uint64_t reclaim(
+        memory::MemoryPool* pool,
+        uint64_t targetBytes,
+        uint64_t maxWaitMs,
+        memory::MemoryReclaimer::Stats& stats) override;
 
-  virtual void abort() override;
+   private:
+    explicit MemoryReclaimer(SortingWriter* writer)
+        : exec::MemoryReclaimer(),
+          writer_(writer),
+          canReclaim_(writer_->sortBuffer_->canSpill()) {}
+
+    SortingWriter* const writer_;
+    const bool canReclaim_;
+  };
+
+  bool canReclaim() const;
+
+  uint64_t reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats);
+
+  vector_size_t outputBatchRows();
 
   const std::unique_ptr<Writer> outputWriter_;
+  const vector_size_t maxOutputRowsConfig_;
+  const uint64_t maxOutputBytesConfig_;
+  memory::MemoryPool* const sortPool_;
+  const bool canReclaim_;
+
   std::unique_ptr<exec::SortBuffer> sortBuffer_;
 };
 
diff --git a/velox/dwio/common/Throttler.cpp b/velox/dwio/common/Throttler.cpp
new file mode 100644
index 0000000000000..55dce7003166d
--- /dev/null
+++ b/velox/dwio/common/Throttler.cpp
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/Throttler.h"
+
+#include <boost/random/uniform_int_distribution.hpp>
+
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/base/SuccinctPrinter.h"
+
+namespace facebook::velox::dwio::common {
+namespace {
+// Builds key in local throttled cache to make it unique across storage
+// clusters.
+std::string localThrottleCacheKey(
+    const std::string& cluster,
+    const std::string& directory) {
+  return fmt::format("{}:{}", cluster, directory);
+}
+} // namespace
+
+Throttler::Config::Config(
+    bool _throttleEnabled,
+    uint64_t _minThrottleBackoffMs,
+    uint64_t _maxThrottleBackoffMs,
+    double _backoffScaleFactor,
+    uint32_t _minLocalThrottledSignals,
+    uint32_t _minGlobalThrottledSignals,
+    uint32_t _maxCacheEntries,
+    uint32_t _cacheTTLMs)
+    : throttleEnabled(_throttleEnabled),
+      minThrottleBackoffMs(_minThrottleBackoffMs),
+      maxThrottleBackoffMs(_maxThrottleBackoffMs),
+      backoffScaleFactor(_backoffScaleFactor),
+      minLocalThrottledSignals(_minLocalThrottledSignals),
+      minGlobalThrottledSignals(_minGlobalThrottledSignals),
+      maxCacheEntries(_maxCacheEntries),
+      cacheTTLMs(_cacheTTLMs) {}
+
+std::string Throttler::Config::toString() const {
+  return fmt::format(
+      "throttleEnabled:{} minThrottleBackoffMs:{} maxThrottleBackoffMs:{} backoffScaleFactor:{} minLocalThrottledSignals:{} minGlobalThrottledSignals:{} maxCacheEntries:{} cacheTTLMs:{}",
+      throttleEnabled,
+      succinctMillis(minThrottleBackoffMs),
+      succinctMillis(maxThrottleBackoffMs),
+      backoffScaleFactor,
+      minLocalThrottledSignals,
+      minGlobalThrottledSignals,
+      maxCacheEntries,
+      succinctMillis(cacheTTLMs));
+};
+
+std::string Throttler::signalTypeName(SignalType type) {
+  switch (type) {
+    case SignalType::kNone:
+      return "None";
+    case SignalType::kLocal:
+      return "Local";
+    case SignalType::kGlobal:
+      return "Global";
+    default:
+      return fmt::format("Unknown Signal Type: {}", static_cast<int>(type));
+  }
+}
+
+std::ostream& operator<<(std::ostream& os, Throttler::SignalType type) {
+  os << Throttler::signalTypeName(type);
+  return os;
+}
+
+void Throttler::init(const Config& config) {
+  std::unique_lock guard{instanceLock()};
+  auto& instance = instanceRef();
+  VELOX_CHECK_NULL(instance, "Throttler has already been set");
+  instance = std::unique_ptr<Throttler>(new Throttler(config));
+}
+
+Throttler* Throttler::instance() {
+  std::shared_lock guard{instanceLock()};
+  auto& instance = instanceRef();
+  if (instance == nullptr) {
+    return nullptr;
+  }
+  return instance.get();
+}
+
+Throttler::Throttler(const Config& config)
+    : throttleEnabled_(config.throttleEnabled),
+      minThrottleBackoffDurationMs_(config.minThrottleBackoffMs),
+      maxThrottleBackoffDurationMs_(config.maxThrottleBackoffMs),
+      backoffScaleFactor_(config.backoffScaleFactor),
+      minLocalThrottledSignalsToBackoff_(config.minLocalThrottledSignals),
+      minGlobalThrottledSignalsToBackoff_(config.minGlobalThrottledSignals),
+      localThrottleCache_(
+          !throttleEnabled_
+              ? nullptr
+              : new ThrottleSignalFactory{std::make_unique<SimpleLRUCache<std::string, ThrottleSignal>>(
+                     config.maxCacheEntries,
+                     config.cacheTTLMs),
+                 std::unique_ptr<ThrottleSignalGenerator>{
+                     new ThrottleSignalGenerator{}}}),
+      globalThrottleCache_(
+          !throttleEnabled_
+              ? nullptr
+              : new ThrottleSignalFactory{std::make_unique<SimpleLRUCache<std::string, ThrottleSignal>>(
+                                              config.maxCacheEntries,
+                                              config.cacheTTLMs),
+                                          std::unique_ptr<ThrottleSignalGenerator>{
+                                              new ThrottleSignalGenerator{}}}) {
+  LOG(INFO) << "IO throttler config: " << config.toString();
+}
+
+uint64_t Throttler::throttleBackoff(
+    SignalType type,
+    const std::string& cluster,
+    const std::string& directory) {
+  if (!throttleEnabled() || type == SignalType::kNone) {
+    return kNoBackOffMs_;
+  }
+
+  const uint64_t backOffDurationMs =
+      calculateBackoffDurationAndUpdateThrottleCache(type, cluster, directory);
+  if (backOffDurationMs == kNoBackOffMs_) {
+    return kNoBackOffMs_;
+  }
+
+  updateThrottleStats(type, backOffDurationMs);
+
+  std::this_thread::sleep_for(
+      std::chrono::milliseconds(backOffDurationMs)); // NOLINT
+  return backOffDurationMs;
+}
+
+void Throttler::updateThrottleStats(SignalType type, uint64_t backoffDelayMs) {
+  stats_.backOffDelay.increment(backoffDelayMs);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricStorageThrottledDurationMs, backoffDelayMs);
+  if (type == SignalType::kLocal) {
+    ++stats_.localThrottled;
+    RECORD_METRIC_VALUE(kMetricStorageLocalThrottled);
+  } else {
+    ++stats_.globalThrottled;
+    RECORD_METRIC_VALUE(kMetricStorageGlobalThrottled);
+  }
+}
+
+void Throttler::updateThrottleCacheLocked(
+    SignalType type,
+    const std::string& cluster,
+    const std::string& directory,
+    CachedThrottleSignalPtr& localSignal,
+    CachedThrottleSignalPtr& globalSignal) {
+  VELOX_CHECK(throttleEnabled());
+
+  if (type == SignalType::kLocal) {
+    if (localSignal.get() == nullptr) {
+      localThrottleCache_->generate(localThrottleCacheKey(cluster, directory));
+    } else {
+      ++localSignal->count;
+    }
+  } else {
+    if (globalSignal.get() == nullptr) {
+      globalThrottleCache_->generate(cluster);
+    } else {
+      ++globalSignal->count;
+    }
+  }
+}
+
+uint64_t Throttler::calculateBackoffDurationAndUpdateThrottleCache(
+    SignalType type,
+    const std::string& cluster,
+    const std::string& directoy) {
+  std::lock_guard<std::mutex> l(mu_);
+  // Gets maximum count of local and global throttle signals in Cache.
+  auto localThrottleCachePtr =
+      localThrottleCache_->get(localThrottleCacheKey(cluster, directoy));
+  int64_t localThrottleCount =
+      (localThrottleCachePtr.get() != nullptr ? localThrottleCachePtr->count
+                                              : 0) +
+      (type == SignalType::kLocal ? 1 : 0) - minLocalThrottledSignalsToBackoff_;
+  auto globalThrottleCachePtr = globalThrottleCache_->get(cluster);
+  const int64_t globalThrottleCount =
+      (globalThrottleCachePtr.get() != nullptr ? globalThrottleCachePtr->count
+                                               : 0) +
+      (type == SignalType::kGlobal ? 1 : 0) -
+      minGlobalThrottledSignalsToBackoff_;
+  // Update throttling signal cache.
+  updateThrottleCacheLocked(
+      type, cluster, directoy, localThrottleCachePtr, globalThrottleCachePtr);
+
+  const int64_t throttleAttempts =
+      std::max(localThrottleCount, globalThrottleCount);
+
+  // Calculates the delay with exponential backoff
+  if (throttleAttempts <= 0) {
+    return kNoBackOffMs_;
+  }
+
+  const uint64_t backoffDelayMs = std::round(
+      minThrottleBackoffDurationMs_ *
+      pow(backoffScaleFactor_, throttleAttempts - 1));
+
+  // Adds some casualness so requests can be waken up at different timestamp
+  return std::min(
+      backoffDelayMs +
+          boost::random::uniform_int_distribution<uint64_t>(
+              1, std::max<uint64_t>(1, (uint64_t)(backoffDelayMs * 0.1)))(rng_),
+      maxThrottleBackoffDurationMs_);
+}
+
+std::unique_ptr<Throttler::ThrottleSignal>
+Throttler::ThrottleSignalGenerator::operator()(
+    const std::string& /*unused*/,
+    const void* /*unused*/) {
+  return std::unique_ptr<ThrottleSignal>(new ThrottleSignal{1});
+}
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/Throttler.h b/velox/dwio/common/Throttler.h
new file mode 100644
index 0000000000000..eb5667a59287a
--- /dev/null
+++ b/velox/dwio/common/Throttler.h
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdint.h>
+#include <mutex>
+#include <random>
+
+#include "velox/common/caching/CachedFactory.h"
+#include "velox/common/caching/SimpleLRUCache.h"
+#include "velox/common/io/IoStatistics.h"
+
+#pragma once
+
+namespace facebook::velox::dwio::common {
+
+/// A throttler that can be used to backoff IO when the storage is overloaded.
+class Throttler {
+ public:
+  /// The configuration of the throttler.
+  struct Config {
+    /// If true, enables throttling of IO.
+    bool throttleEnabled;
+
+    /// The minimum backoff duration in milliseconds.
+    uint64_t minThrottleBackoffMs;
+
+    /// The maximum backoff duration in milliseconds.
+    uint64_t maxThrottleBackoffMs;
+
+    /// The backoff duration scale factor.
+    double backoffScaleFactor;
+
+    /// The minimum number of received local throttled signals before starting
+    /// backoff.
+    uint32_t minLocalThrottledSignals;
+
+    /// The minimum number of received global throttled signals before starting
+    /// backoff.
+    uint32_t minGlobalThrottledSignals;
+
+    /// The maximum number of entries in the throttled signal cache. There is
+    /// one cache for each throttle signal type. For local throttle signal
+    /// cache, each cache entry corresponds to a unqiue file direcotry in a
+    /// storage system. For global throttle signal cache, each entry corresponds
+    /// to a unique storage system.
+    uint32_t maxCacheEntries;
+
+    /// The TTL of the throttled signal cache entries in milliseconds. We only
+    /// track the recently throtted signals.
+    uint32_t cacheTTLMs;
+
+    static constexpr bool kThrottleEnabledDefault{true};
+    static constexpr uint64_t kMinThrottleBackoffMsDefault{200};
+    static constexpr uint64_t kMaxThrottleBackoffMsDefault{30'000};
+    static constexpr double kBackoffScaleFactorDefault{2.0};
+    static constexpr uint32_t kMinLocalThrottledSignalsDefault{1'000};
+    static constexpr uint32_t kMinGlobalThrottledSignalsDefault{100'000};
+    static constexpr uint32_t kMaxCacheEntriesDefault{10'000};
+    static constexpr uint32_t kCacheTTLMsDefault{3 * 60 * 1'000};
+
+    Config(
+        bool throttleEnabled = kThrottleEnabledDefault,
+        uint64_t minThrottleBackoffMs = kMinThrottleBackoffMsDefault,
+        uint64_t maxThrottleBackoffMs = kMaxThrottleBackoffMsDefault,
+        double backoffScaleFactor = kBackoffScaleFactorDefault,
+        uint32_t minLocalThrottledSignals = kMinLocalThrottledSignalsDefault,
+        uint32_t minGlobalThrottledSignals = kMinGlobalThrottledSignalsDefault,
+        uint32_t maxCacheEntries = kMaxCacheEntriesDefault,
+        uint32_t cacheTTLMs = kCacheTTLMsDefault);
+
+    std::string toString() const;
+  };
+
+  /// The throttler stats.
+  struct Stats {
+    std::atomic_uint64_t localThrottled{0};
+    std::atomic_uint64_t globalThrottled{0};
+    /// Counts the backoff delay in milliseconds.
+    io::IoCounter backOffDelay;
+  };
+
+  static void init(const Config& config);
+
+  static Throttler* instance();
+
+  /// The type of throttle signal type.
+  enum class SignalType {
+    /// No throttled signal.
+    kNone,
+    /// A file directory throttled signal.
+    kLocal,
+    /// A cluster-wise throttled signal.
+    kGlobal,
+  };
+  static std::string signalTypeName(SignalType type);
+
+  /// Invoked to backoff when received a throttled signal on a particular
+  /// storage location. 'type' specifies the throttled signal type received from
+  /// the storage system. 'cluster' specifies the storage system. A query system
+  /// might access data from different storage systems. 'directory' specifies
+  /// the file directory within the storage system. The function returns the
+  /// actual throttled duration in milliseconds. It returns zero if not
+  /// throttled.
+  uint64_t throttleBackoff(
+      SignalType type,
+      const std::string& cluster,
+      const std::string& directory);
+
+  const Stats& stats() const {
+    return stats_;
+  }
+
+  static void testingReset() {
+    instanceRef().reset();
+  }
+
+ private:
+  static folly::SharedMutex& instanceLock() {
+    static folly::SharedMutex mu;
+    return mu;
+  }
+
+  static std::unique_ptr<Throttler>& instanceRef() {
+    static std::unique_ptr<Throttler> instance;
+    return instance;
+  }
+
+  explicit Throttler(const Config& config);
+
+  bool throttleEnabled() const {
+    return throttleEnabled_;
+  }
+
+  // Calculates the delay in milliseconds with exponential backoff for a storage
+  // location, using the signal counters in cache and flags in config, and
+  // update the throttle signal caches.
+  uint64_t calculateBackoffDurationAndUpdateThrottleCache(
+      SignalType type,
+      const std::string& cluster,
+      const std::string& directory);
+
+  struct ThrottleSignal {
+    uint64_t count{0};
+
+    explicit ThrottleSignal(uint64_t _count) : count(_count) {}
+  };
+
+  // Creates ThrottleSignal via the Generator interface the CachedFactory
+  // requires.
+  class ThrottleSignalGenerator {
+   public:
+    ThrottleSignalGenerator() = default;
+
+    std::unique_ptr<ThrottleSignal> operator()(
+        const std::string& /*unused*/,
+        const void* /*unused*/);
+  };
+
+  using CachedThrottleSignalPtr = CachedPtr<std::string, ThrottleSignal>;
+
+  using ThrottleSignalFactory = facebook::velox::
+      CachedFactory<std::string, ThrottleSignal, ThrottleSignalGenerator>;
+
+  void updateThrottleCacheLocked(
+      SignalType type,
+      const std::string& cluster,
+      const std::string& directory,
+      CachedThrottleSignalPtr& localSignal,
+      CachedThrottleSignalPtr& globalSignal);
+
+  void updateThrottleStats(SignalType type, uint64_t backoffDelayMs);
+
+  static const uint64_t kNoBackOffMs_{0};
+
+  const bool throttleEnabled_;
+  const uint64_t minThrottleBackoffDurationMs_;
+  const uint64_t maxThrottleBackoffDurationMs_;
+  const double backoffScaleFactor_;
+  const uint32_t minLocalThrottledSignalsToBackoff_;
+  const uint32_t minGlobalThrottledSignalsToBackoff_;
+  const std::unique_ptr<ThrottleSignalFactory> localThrottleCache_;
+  const std::unique_ptr<ThrottleSignalFactory> globalThrottleCache_;
+
+  mutable std::mutex mu_;
+
+  std::mt19937 rng_;
+  Stats stats_;
+};
+
+std::ostream& operator<<(std::ostream& os, Throttler::SignalType type);
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/TypeUtils.cpp b/velox/dwio/common/TypeUtils.cpp
index b5d0d046ced5c..29e22046196fe 100644
--- a/velox/dwio/common/TypeUtils.cpp
+++ b/velox/dwio/common/TypeUtils.cpp
@@ -39,49 +39,53 @@ void checkChildrenSelected(
   }
 }
 
-std::shared_ptr<const TypeWithId> visit(
+std::unique_ptr<TypeWithId> visit(
     const std::shared_ptr<const TypeWithId>& typeWithId,
     const std::function<bool(size_t)>& selector) {
   if (typeWithId->type()->isPrimitiveType()) {
-    return typeWithId;
+    return std::make_unique<TypeWithId>(
+        typeWithId->type(),
+        std::vector<std::unique_ptr<TypeWithId>>(),
+        typeWithId->id(),
+        typeWithId->maxId(),
+        typeWithId->column());
   }
   if (typeWithId->type()->isRow()) {
     std::vector<std::string> names;
-    std::vector<std::shared_ptr<const TypeWithId>> typesWithId;
+    std::vector<std::unique_ptr<TypeWithId>> selectedChildren;
     std::vector<std::shared_ptr<const Type>> types;
     auto& row = typeWithId->type()->asRow();
     for (auto i = 0; i < typeWithId->size(); ++i) {
       auto& child = typeWithId->childAt(i);
       if (selector(child->id())) {
         names.push_back(row.nameOf(i));
-        std::shared_ptr<const TypeWithId> twid;
-        twid = visit(child, selector);
-        typesWithId.push_back(twid);
-        types.push_back(twid->type());
+        auto newChild = visit(child, selector);
+        types.push_back(newChild->type());
+        selectedChildren.push_back(std::move(newChild));
       }
     }
     VELOX_USER_CHECK(
         !types.empty(), "selected nothing from row: " + row.toString());
-    return std::make_shared<TypeWithId>(
+    return std::make_unique<TypeWithId>(
         ROW(std::move(names), std::move(types)),
-        std::move(typesWithId),
+        std::move(selectedChildren),
         typeWithId->id(),
         typeWithId->maxId(),
         typeWithId->column());
   } else {
     checkChildrenSelected(typeWithId, selector);
-    std::vector<std::shared_ptr<const TypeWithId>> typesWithId;
+    std::vector<std::unique_ptr<TypeWithId>> selectedChildren;
     std::vector<std::shared_ptr<const Type>> types;
     for (auto i = 0; i < typeWithId->size(); ++i) {
       auto& child = typeWithId->childAt(i);
-      std::shared_ptr<const TypeWithId> twid = visit(child, selector);
-      typesWithId.push_back(twid);
-      types.push_back(twid->type());
+      auto newChild = visit(child, selector);
+      types.push_back(newChild->type());
+      selectedChildren.push_back(std::move(newChild));
     }
     auto type = createType(typeWithId->type()->kind(), std::move(types));
-    return std::make_shared<TypeWithId>(
+    return std::make_unique<TypeWithId>(
         type,
-        std::move(typesWithId),
+        std::move(selectedChildren),
         typeWithId->id(),
         typeWithId->maxId(),
         typeWithId->column());
@@ -108,6 +112,7 @@ std::unordered_set<uint32_t> makeCompatibilityMap() {
   compat.insert(getKey(TypeKind::SMALLINT, TypeKind::INTEGER));
   compat.insert(getKey(TypeKind::SMALLINT, TypeKind::BIGINT));
   compat.insert(getKey(TypeKind::INTEGER, TypeKind::BIGINT));
+  compat.insert(getKey(TypeKind::BIGINT, TypeKind::HUGEINT));
   compat.insert(getKey(TypeKind::REAL, TypeKind::DOUBLE));
   return compat;
 }
@@ -134,7 +139,7 @@ void checkTypeCompatibility(
   }
 
   if (recurse) {
-    uint64_t childCount = std::min(from.size(), to.size());
+    const uint64_t childCount = std::min(from.size(), to.size());
     for (uint64_t i = 0; i < childCount; ++i) {
       checkTypeCompatibility(
           *from.childAt(i),
diff --git a/velox/dwio/common/TypeWithId.cpp b/velox/dwio/common/TypeWithId.cpp
index 6436aa25f55fb..03328024ef67f 100644
--- a/velox/dwio/common/TypeWithId.cpp
+++ b/velox/dwio/common/TypeWithId.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/dwio/common/TypeWithId.h"
+
 #include "velox/dwio/common/exception/Exception.h"
 
 namespace facebook::velox::dwio::common {
@@ -22,9 +23,21 @@ namespace facebook::velox::dwio::common {
 using velox::Type;
 using velox::TypeKind;
 
+namespace {
+std::vector<std::shared_ptr<const TypeWithId>> toShared(
+    std::vector<std::unique_ptr<TypeWithId>> nodes) {
+  std::vector<std::shared_ptr<const TypeWithId>> result;
+  result.reserve(nodes.size());
+  for (auto&& node : nodes) {
+    result.emplace_back(std::move(node));
+  }
+  return result;
+}
+} // namespace
+
 TypeWithId::TypeWithId(
     std::shared_ptr<const Type> type,
-    std::vector<std::shared_ptr<const TypeWithId>>&& children,
+    std::vector<std::unique_ptr<TypeWithId>>&& children,
     uint32_t id,
     uint32_t maxId,
     uint32_t column)
@@ -33,18 +46,49 @@ TypeWithId::TypeWithId(
       id_{id},
       maxId_{maxId},
       column_{column},
-      children_{std::move(children)} {
+      children_{toShared(std::move(children))} {
   for (auto& child : children_) {
-    const_cast<const TypeWithId*&>(child->parent_) = this;
+    if (child) {
+      const_cast<const TypeWithId*&>(child->parent_) = this;
+    }
   }
 }
 
-std::shared_ptr<const TypeWithId> TypeWithId::create(
+std::unique_ptr<TypeWithId> TypeWithId::create(
     const std::shared_ptr<const Type>& root,
     uint32_t next) {
   return create(root, next, 0);
 }
 
+namespace {
+
+int countNodes(const TypePtr& type) {
+  int count = 1;
+  for (auto& child : *type) {
+    count += countNodes(child);
+  }
+  return count;
+}
+
+} // namespace
+
+std::unique_ptr<TypeWithId> TypeWithId::create(
+    const RowTypePtr& type,
+    const velox::common::ScanSpec& spec) {
+  uint32_t next = 1;
+  std::vector<std::unique_ptr<TypeWithId>> children(type->size());
+  for (int i = 0, size = type->size(); i < size; ++i) {
+    auto* childSpec = spec.childByName(type->nameOf(i));
+    if (childSpec && !childSpec->isConstant()) {
+      children[i] = create(type->childAt(i), next, i);
+    } else {
+      next += countNodes(type->childAt(i));
+    }
+  }
+  return std::make_unique<TypeWithId>(
+      type, std::move(children), 0, next - 1, 0);
+}
+
 uint32_t TypeWithId::size() const {
   return children_.size();
 }
@@ -54,13 +98,13 @@ const std::shared_ptr<const TypeWithId>& TypeWithId::childAt(
   return children_.at(idx);
 }
 
-std::shared_ptr<const TypeWithId> TypeWithId::create(
+std::unique_ptr<TypeWithId> TypeWithId::create(
     const std::shared_ptr<const Type>& type,
     uint32_t& next,
     uint32_t column) {
   DWIO_ENSURE_NOT_NULL(type);
   const uint32_t myId = next++;
-  std::vector<std::shared_ptr<const TypeWithId>> children{};
+  std::vector<std::unique_ptr<TypeWithId>> children;
   children.reserve(type->size());
   auto offset = 0;
   for (const auto& child : *type) {
@@ -70,8 +114,58 @@ std::shared_ptr<const TypeWithId> TypeWithId::create(
         (myId == 0 && type->kind() == TypeKind::ROW) ? offset++ : column));
   }
   const uint32_t maxId = next - 1;
-  return std::make_shared<const TypeWithId>(
+  return std::make_unique<TypeWithId>(
       type, std::move(children), myId, maxId, column);
 }
 
+std::string TypeWithId::fullName() const {
+  std::vector<std::string> path;
+  auto* child = this;
+  while (auto* parent = child->parent_) {
+    switch (parent->type()->kind()) {
+      case TypeKind::ROW: {
+        auto& siblings = parent->children_;
+        bool found = false;
+        for (int i = 0; i < siblings.size(); ++i) {
+          if (siblings[i].get() == child) {
+            path.push_back('.' + parent->type()->asRow().nameOf(i));
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          VELOX_FAIL(
+              "Child {} not found in parent {}",
+              child->type()->toString(),
+              parent->type()->toString());
+        }
+        break;
+      }
+      case TypeKind::ARRAY:
+        break;
+      case TypeKind::MAP:
+        if (child == parent->children_.at(0).get()) {
+          path.push_back(".<keys>");
+        } else {
+          VELOX_CHECK(child == parent->children_.at(1).get());
+          path.push_back(".<values>");
+        }
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+    child = parent;
+  }
+  std::string ans;
+  for (int i = path.size() - 1; i >= 0; --i) {
+    if (i == path.size() - 1) {
+      VELOX_CHECK_EQ(path[i][0], '.');
+      ans += path[i].substr(1);
+    } else {
+      ans += path[i];
+    }
+  }
+  return ans;
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/TypeWithId.h b/velox/dwio/common/TypeWithId.h
index 953ac87b2b8c3..a147cfe5066fc 100644
--- a/velox/dwio/common/TypeWithId.h
+++ b/velox/dwio/common/TypeWithId.h
@@ -18,23 +18,35 @@
 
 #include <memory>
 #include <vector>
+#include "velox/dwio/common/ScanSpec.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::dwio::common {
 
 class TypeWithId : public velox::Tree<std::shared_ptr<const TypeWithId>> {
  public:
+  /// NOTE: This constructor will re-parent the children.
   TypeWithId(
       std::shared_ptr<const velox::Type> type,
-      std::vector<std::shared_ptr<const TypeWithId>>&& children,
+      std::vector<std::unique_ptr<TypeWithId>>&& children,
       uint32_t id,
       uint32_t maxId,
       uint32_t column);
 
-  static std::shared_ptr<const TypeWithId> create(
+  TypeWithId(const TypeWithId&) = delete;
+  TypeWithId& operator=(const TypeWithId&) = delete;
+
+  static std::unique_ptr<TypeWithId> create(
       const std::shared_ptr<const velox::Type>& root,
       uint32_t next = 0);
 
+  /// Create TypeWithId node but leave all the unselected children as nullptr.
+  /// The ids are set correctly even when some of the previous nodes are not
+  /// selected.
+  static std::unique_ptr<TypeWithId> create(
+      const RowTypePtr& type,
+      const velox::common::ScanSpec& spec);
+
   uint32_t size() const override;
 
   const std::shared_ptr<const velox::Type>& type() const {
@@ -69,8 +81,10 @@ class TypeWithId : public velox::Tree<std::shared_ptr<const TypeWithId>> {
     return children_;
   }
 
+  std::string fullName() const;
+
  private:
-  static std::shared_ptr<const TypeWithId> create(
+  static std::unique_ptr<TypeWithId> create(
       const std::shared_ptr<const velox::Type>& type,
       uint32_t& next,
       uint32_t column);
diff --git a/velox/dwio/common/UnitLoader.h b/velox/dwio/common/UnitLoader.h
new file mode 100644
index 0000000000000..d3125dacc4be6
--- /dev/null
+++ b/velox/dwio/common/UnitLoader.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace facebook::velox::dwio::common {
+
+class LoadUnit {
+ public:
+  virtual ~LoadUnit() = default;
+
+  /// Perform the IO (read)
+  virtual void load() = 0;
+
+  /// Unload the unit to free memory
+  virtual void unload() = 0;
+
+  /// Number of rows in the unit
+  virtual uint64_t getNumRows() = 0;
+
+  /// Number of bytes that the IO will read
+  virtual uint64_t getIoSize() = 0;
+};
+
+class UnitLoader {
+ public:
+  virtual ~UnitLoader() = default;
+
+  /// Must block until the unit is loaded. This call could unload other units.
+  /// So the returned LoadUnit& is only guaranteed to remain loaded until the
+  /// next call.
+  virtual LoadUnit& getLoadedUnit(uint32_t unit) = 0;
+
+  /// Reader reports progress calling this method. The call must be done
+  /// **after** getLoadedUnit for unit.
+  virtual void
+  onRead(uint32_t unit, uint64_t rowOffsetInUnit, uint64_t rowCount) = 0;
+
+  /// Reader reports seek calling this method. The call must be done **before**
+  /// getLoadedUnit for the new unit.
+  virtual void onSeek(uint32_t unit, uint64_t rowOffsetInUnit) = 0;
+};
+
+class UnitLoaderFactory {
+ public:
+  virtual ~UnitLoaderFactory() = default;
+  virtual std::unique_ptr<UnitLoader> create(
+      std::vector<std::unique_ptr<LoadUnit>> loadUnits,
+      uint64_t rowsToSkip) = 0;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/UnitLoaderTools.h b/velox/dwio/common/UnitLoaderTools.h
new file mode 100644
index 0000000000000..2b25eb87e112a
--- /dev/null
+++ b/velox/dwio/common/UnitLoaderTools.h
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "folly/synchronization/CallOnce.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::dwio::common::unit_loader_tools {
+
+// This class can create many callbacks that can be distributed to unit loader
+// factories. Only when the last created callback is activated, this class will
+// emit the original callback.
+// If the callback objects created are never explicitly called (because of an
+// exception for example), the callback object will do the call in the
+// destructor, guaranteeting the call.
+class CallbackOnLastSignal {
+  class Callable {
+   public:
+    virtual ~Callable() {}
+    virtual void call() = 0;
+  };
+
+  class CallableFunction : public Callable {
+   public:
+    explicit CallableFunction(std::function<void()> cb) : cb_{std::move(cb)} {}
+
+    void call() override {
+      if (cb_) {
+        // Could be null
+        cb_();
+      }
+    }
+
+   private:
+    std::function<void()> cb_;
+  };
+
+  // This class will ensure that the contained callback is only called once.
+  class CallOnce : public Callable {
+   public:
+    explicit CallOnce(std::shared_ptr<Callable> cb) : cb_{std::move(cb)} {}
+
+    CallOnce(const CallOnce& other) = delete;
+    CallOnce(CallOnce&& other) = delete;
+    CallOnce& operator=(const CallOnce& other) = delete;
+    CallOnce& operator=(CallOnce&& other) noexcept = delete;
+
+    void call() override {
+      folly::call_once(called_, [&]() { cb_->call(); });
+    }
+
+   private:
+    std::shared_ptr<Callable> cb_;
+    folly::once_flag called_;
+  };
+
+  // This class will ensure that only the call from the last caller will go
+  // through.
+  class CallOnCountZero : public Callable {
+   public:
+    CallOnCountZero(
+        std::shared_ptr<std::atomic_size_t> callsLeft,
+        std::shared_ptr<Callable> cb)
+        : callsLeft_{std::move(callsLeft)}, cb_{std::move(cb)} {}
+
+    CallOnCountZero(const CallOnCountZero& other) = delete;
+    CallOnCountZero(CallOnCountZero&& other) = delete;
+    CallOnCountZero& operator=(const CallOnCountZero& other) = delete;
+    CallOnCountZero& operator=(CallOnCountZero&& other) noexcept = delete;
+
+    void call() override {
+      if (*callsLeft_ > 0) {
+        --*(callsLeft_);
+      }
+      if (*callsLeft_ == 0) {
+        cb_->call();
+      }
+    }
+
+   private:
+    std::shared_ptr<std::atomic_size_t> callsLeft_;
+    std::shared_ptr<Callable> cb_;
+  };
+
+  // This class will ensure that the contained callback is called when the
+  // operator() is invoked, or when the object is destructed, whatever comes
+  // first.
+  class EnsureCall : public Callable {
+   public:
+    explicit EnsureCall(std::shared_ptr<Callable> cb)
+        : cb_{std::make_shared<CallOnce>(std::move(cb))} {}
+
+    EnsureCall(const EnsureCall& other) = delete;
+    EnsureCall(EnsureCall&& other) = delete;
+    EnsureCall& operator=(const EnsureCall& other) = delete;
+    EnsureCall& operator=(EnsureCall&& other) noexcept = delete;
+
+    ~EnsureCall() override {
+      cb_->call();
+    }
+
+    void call() override {
+      cb_->call();
+    }
+
+   private:
+    std::shared_ptr<Callable> cb_;
+  };
+
+  class CountCaller {
+   public:
+    CountCaller(
+        std::shared_ptr<Callable> cb,
+        std::shared_ptr<std::atomic_size_t> callsLeft)
+        : cb_{std::move(cb)} {
+      ++(*callsLeft);
+    }
+
+    void operator()() {
+      cb_->call();
+    }
+
+   private:
+    std::shared_ptr<Callable> cb_;
+  };
+
+ public:
+  explicit CallbackOnLastSignal(std::function<void()> cb)
+      : callsLeft_{std::make_shared<std::atomic_size_t>(0)},
+        cb_{cb ? std::make_shared<CallOnCountZero>(
+                     callsLeft_,
+                     std::make_shared<CallOnce>(std::make_shared<EnsureCall>(
+                         std::make_shared<CallableFunction>(std::move(cb)))))
+               : nullptr} {}
+
+  std::function<void()> getCallback() const {
+    if (!cb_) {
+      return nullptr;
+    }
+    return CountCaller{
+        std::make_shared<CallOnce>(std::make_shared<EnsureCall>(cb_)),
+        callsLeft_};
+  }
+
+ private:
+  std::shared_ptr<std::atomic_size_t> callsLeft_;
+  std::shared_ptr<Callable> cb_;
+};
+
+template <typename NumRowsIter>
+std::pair<uint32_t, uint64_t>
+howMuchToSkip(uint64_t rowsToSkip, NumRowsIter begin, NumRowsIter end) {
+  uint64_t rowsLeftToSkip = rowsToSkip;
+  uint32_t unitsToSkip = 0;
+  for (NumRowsIter it = begin; it != end; ++it) {
+    const auto rowsInUnit = *it;
+    if (rowsLeftToSkip < rowsInUnit) {
+      return {unitsToSkip, rowsLeftToSkip};
+    }
+    rowsLeftToSkip -= rowsInUnit;
+    ++unitsToSkip;
+  }
+
+  VELOX_CHECK_EQ(
+      rowsLeftToSkip,
+      0,
+      "Can't skip more rows than all the rows in all the units");
+
+  return {unitsToSkip, rowsLeftToSkip};
+}
+
+} // namespace facebook::velox::dwio::common::unit_loader_tools
diff --git a/velox/dwio/common/Writer.cpp b/velox/dwio/common/Writer.cpp
new file mode 100644
index 0000000000000..52ff1848f0a09
--- /dev/null
+++ b/velox/dwio/common/Writer.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/Writer.h"
+
+namespace facebook::velox::dwio::common {
+
+void Writer::checkStateTransition(State oldState, State newState) {
+  switch (oldState) {
+    case State::kInit:
+      if (newState == State::kRunning) {
+        return;
+      }
+      break;
+    case State::kRunning:
+      if (newState == State::kAborted || newState == State::kClosed) {
+        return;
+      }
+      break;
+    case State::kAborted:
+      [[fallthrough]];
+    case State::kClosed:
+      [[fallthrough]];
+    default:
+      break;
+  }
+  VELOX_FAIL(
+      "Unexpected state transition from {} to {}",
+      Writer::stateString(oldState),
+      Writer::stateString(newState));
+}
+
+std::string Writer::stateString(State state) {
+  switch (state) {
+    case State::kInit:
+      return "INIT";
+    case State::kRunning:
+      return "RUNNING";
+    case State::kClosed:
+      return "CLOSED";
+    case State::kAborted:
+      return "ABORTED";
+    default:
+      VELOX_UNREACHABLE("BAD STATE: {}", static_cast<int>(state));
+  }
+}
+
+bool Writer::isRunning() const {
+  return state_ == State::kRunning;
+}
+
+void Writer::checkRunning() const {
+  VELOX_CHECK_EQ(
+      static_cast<int>(state_),
+      static_cast<int>(State::kRunning),
+      "Writer is not running: {}",
+      Writer::stateString(state_));
+}
+
+void Writer::setState(State state) {
+  checkStateTransition(state_, state);
+  state_ = state;
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/Writer.h b/velox/dwio/common/Writer.h
index 78e75a7c42429..011e9f156162b 100644
--- a/velox/dwio/common/Writer.h
+++ b/velox/dwio/common/Writer.h
@@ -25,41 +25,64 @@
 
 namespace facebook::velox::dwio::common {
 
-/**
- * Abstract writer class.
- *
- * Writer object is used to write a single file.
- *
- * Writer objects are created through factories implementing
- * WriterFactory interface.
- */
+/// Abstract writer class.
+///
+/// Writer object is used to write a single file.
+///
+/// Writer objects are created through factories implementing
+/// WriterFactory interface.
 class Writer {
  public:
+  /// Defines the states of a file writer.
+  enum class State {
+    kInit = 0,
+    kRunning = 1,
+    kAborted = 2,
+    kClosed = 3,
+  };
+  static std::string stateString(State state);
+
   virtual ~Writer() = default;
 
-  /**
-   * Appends 'data' to writer. Data might still be in memory and not
-   * yet written to the file.
-   */
+  State state() const {
+    return state_;
+  }
+
+  /// Appends 'data' to writer. Data might still be in memory and not
+  /// yet written to the file.
   virtual void write(const VectorPtr& data) = 0;
 
-  /**
-   * Forces the writer to flush data to the file.
-   * Does not close the writer.
-   */
+  /// Forces the writer to flush data to the file.
+  /// Does not close the writer.
   virtual void flush() = 0;
 
-  /**
-   *  Invokes flush and closes the writer.
-   *  Data can no longer be written.
-   */
+  /// Invokes flush and closes the writer.
+  ///  Data can no longer be written.
   virtual void close() = 0;
 
-  /**
-   *  Aborts the writing by closing the writer and dropping everything.
-   *  Data can no longer be written.
-   */
+  /// Aborts the writing by closing the writer and dropping everything.
+  /// Data can no longer be written.
   virtual void abort() = 0;
+
+ protected:
+  bool isRunning() const;
+
+  void checkRunning() const;
+
+  /// Invoked to set writer 'state_' to new 'state'.
+  void setState(State state);
+
+  /// Validates the state transition from 'oldState' to 'newState'.
+  static void checkStateTransition(State oldState, State newState);
+
+  State state_{State::kInit};
 };
 
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    Writer::State state) {
+  os << Writer::stateString(state);
+  return os;
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/WriterFactory.cpp b/velox/dwio/common/WriterFactory.cpp
index 47d255851b5a1..f88b36b3b3e44 100644
--- a/velox/dwio/common/WriterFactory.cpp
+++ b/velox/dwio/common/WriterFactory.cpp
@@ -17,7 +17,6 @@
 #include "velox/dwio/common/WriterFactory.h"
 
 namespace facebook::velox::dwio::common {
-
 namespace {
 
 using WriterFactoriesMap =
@@ -31,7 +30,7 @@ WriterFactoriesMap& writerFactories() {
 } // namespace
 
 bool registerWriterFactory(std::shared_ptr<WriterFactory> factory) {
-  const bool ok =
+  [[maybe_unused]] const bool ok =
       writerFactories().insert({factory->fileFormat(), factory}).second;
 // TODO: enable the check after Prestissimo adds to register the dwrf writer.
 #if 0
@@ -49,10 +48,10 @@ bool unregisterWriterFactory(FileFormat format) {
 
 std::shared_ptr<WriterFactory> getWriterFactory(FileFormat format) {
   auto it = writerFactories().find(format);
-  VELOX_CHECK(
-      it != writerFactories().end(),
-      "WriterFactory is not registered for format {}",
-      toString(format));
+  if (it == writerFactories().end()) {
+    VELOX_UNSUPPORTED(
+        "WriterFactory is not registered for format {}", toString(format));
+  }
   return it->second;
 }
 
diff --git a/velox/dwio/common/WriterFactory.h b/velox/dwio/common/WriterFactory.h
index 97c644d95d663..c04d5688a6aaf 100644
--- a/velox/dwio/common/WriterFactory.h
+++ b/velox/dwio/common/WriterFactory.h
@@ -24,74 +24,62 @@
 
 namespace facebook::velox::dwio::common {
 
-/**
- * Writer factory interface.
- *
- * Implement this interface to provide a factory of writers
- * for a particular file format. Factory objects should be
- * registered using registerWriteFactory method to become
- * available for connectors. Only a single writer factory
- * per file format is allowed.
- */
+/// Writer factory interface.
+///
+/// Implement this interface to provide a factory of writers
+/// for a particular file format. Factory objects should be
+/// registered using registerWriteFactory method to become
+/// available for connectors. Only a single writer factory
+/// per file format is allowed.
 class WriterFactory {
  public:
-  /**
-   * Constructor.
-   * @param format File format this factory is designated to.
-   */
+  /// Constructor.
+  /// @param format File format this factory is designated to.
   explicit WriterFactory(FileFormat format) : format_(format) {}
 
   virtual ~WriterFactory() = default;
 
-  /**
-   * Get the file format ths factory is designated to.
-   */
+  /// Get the file format ths factory is designated to.
   FileFormat fileFormat() const {
     return format_;
   }
 
-  /**
-   * Create a writer object.
-   * @param sink output sink
-   * @param options writer options
-   * @return writer object
-   */
+  /// Create a writer object.
+  /// @param sink output sink
+  /// @param options writer options
+  /// @return writer object
   virtual std::unique_ptr<Writer> createWriter(
       std::unique_ptr<dwio::common::FileSink> sink,
-      const dwio::common::WriterOptions& options) = 0;
+      const std::shared_ptr<dwio::common::WriterOptions>& options) = 0;
+
+  /// Creates a polymorphic writer options object.
+  virtual std::unique_ptr<dwio::common::WriterOptions>
+  createWriterOptions() = 0;
 
  private:
   const FileFormat format_;
 };
 
-/**
- * Register a writer factory. Only a single factory can be registered
- * for each file format. An attempt to register multiple factories for
- * a single file format would cause a failure.
- * @return true
- */
+/// Register a writer factory. Only a single factory can be registered
+/// for each file format. An attempt to register multiple factories for
+/// a single file format would cause a failure.
+// @return true
 bool registerWriterFactory(std::shared_ptr<WriterFactory> factory);
 
-/**
- * Unregister a writer factory for a specified file format.
- * @return true for unregistered factory and false for a
- * missing factory for the specified format.
- */
+/// Unregister a writer factory for a specified file format.
+/// @return true for unregistered factory and false for a
+/// missing factory for the specified format.
 bool unregisterWriterFactory(FileFormat format);
 
-/**
- * Get writer factory object for a specified file format. Results in
- * a failure if there is no registered factory for this format.
- * @return WriterFactory object
- */
+/// Get writer factory object for a specified file format. Results in
+/// a failure if there is no registered factory for this format.
+/// @return WriterFactory object
 std::shared_ptr<WriterFactory> getWriterFactory(FileFormat format);
 
-/**
- * Check if a writer factory object exists for a specified file format.
- * Returns true if there is a registered factory for this format, false
- * otherwise.
- * @return true
- */
+/// Check if a writer factory object exists for a specified file format.
+/// Returns true if there is a registered factory for this format, false
+/// otherwise.
+/// @return true
 bool hasWriterFactory(FileFormat format);
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/compression/CMakeLists.txt b/velox/dwio/common/compression/CMakeLists.txt
index 20bceedbc576d..b3bc9f4687ca2 100644
--- a/velox/dwio/common/compression/CMakeLists.txt
+++ b/velox/dwio/common/compression/CMakeLists.txt
@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_dwio_common_compression Compression.cpp PagedInputStream.cpp
-                                          PagedOutputStream.cpp)
+velox_add_library(velox_dwio_common_compression Compression.cpp
+                  PagedInputStream.cpp PagedOutputStream.cpp)
 
-target_link_libraries(velox_dwio_common_compression velox_dwio_common xsimd
-                      gtest Folly::folly)
+velox_link_libraries(velox_dwio_common_compression velox_dwio_common xsimd
+                     Folly::folly)
diff --git a/velox/dwio/common/compression/Compression.cpp b/velox/dwio/common/compression/Compression.cpp
index 79f8bb2d0f07b..e0f2597cc699a 100644
--- a/velox/dwio/common/compression/Compression.cpp
+++ b/velox/dwio/common/compression/Compression.cpp
@@ -15,10 +15,9 @@
  */
 
 #include "velox/dwio/common/compression/Compression.h"
-
 #include "velox/common/compression/LzoDecompressor.h"
+#include "velox/dwio/common/IntCodecCommon.h"
 #include "velox/dwio/common/compression/PagedInputStream.h"
-#include "velox/dwio/common/compression/PagedOutputStream.h"
 
 #include <folly/logging/xlog.h>
 #include <lz4.h>
@@ -194,14 +193,159 @@ uint64_t ZlibDecompressor::decompress(
   return destLength - zstream_.avail_out;
 }
 
-class LzoDecompressor : public Decompressor {
+class LzoAndLz4DecompressorCommon : public Decompressor {
  public:
-  explicit LzoDecompressor(
+  explicit LzoAndLz4DecompressorCommon(
       uint64_t blockSize,
+      const CompressionKind& kind,
+      bool isHadoopFrameFormat,
       const std::string& streamDebugInfo)
-      : Decompressor{blockSize, streamDebugInfo} {}
+      : Decompressor{blockSize, streamDebugInfo},
+        kind_(kind),
+        isHadoopFrameFormat_(isHadoopFrameFormat) {}
 
   uint64_t decompress(
+      const char* src,
+      uint64_t srcLength,
+      char* dest,
+      uint64_t destLength) override;
+
+  virtual uint64_t decompressInternal(
+      const char* src,
+      uint64_t srcLength,
+      char* dest,
+      uint64_t destLength) = 0;
+
+ protected:
+  CompressionKind kind_;
+  // When compressor creates multiple compressed blocks, this will be
+  // 'true', e.g., parquet uses this, whereas dwrf/orc creates single
+  // compressed block.
+  bool isHadoopFrameFormat_;
+};
+
+uint64_t LzoAndLz4DecompressorCommon::decompress(
+    const char* src,
+    uint64_t srcLength,
+    char* dest,
+    uint64_t destLength) {
+  if (!isHadoopFrameFormat_) {
+    return decompressInternal(src, srcLength, dest, destLength);
+  }
+
+  // For parquet, the format could be frame format, try to decompress that
+  // format.
+  uint32_t decompressedTotalSize = 0;
+  auto* inputPtr = src;
+  auto* outPtr = dest;
+  uint64_t compressedSize = srcLength;
+  auto uncompressedSize = destLength;
+
+  while (compressedSize > 0) {
+    DWIO_ENSURE_GE(
+        compressedSize,
+        dwio::common::INT_BYTE_SIZE,
+        "{} decompression failed, input len is too small: {}",
+        kind_,
+        compressedSize);
+
+    uint32_t decompressedBlockSize =
+        folly::Endian::big(folly::loadUnaligned<uint32_t>(inputPtr));
+    inputPtr += dwio::common::INT_BYTE_SIZE;
+    compressedSize -= dwio::common::INT_BYTE_SIZE;
+    uint32_t remainingOutputSize = uncompressedSize - decompressedTotalSize;
+
+    DWIO_ENSURE_GE(
+        remainingOutputSize,
+        decompressedBlockSize,
+        "{} decompression failed, remainingOutputSize is less than "
+        "decompressedBlockSize, remainingOutputSize: {}, "
+        "decompressedBlockSize: {}",
+        kind_,
+        remainingOutputSize,
+        decompressedBlockSize);
+
+    if (compressedSize <= 0) {
+      break;
+    }
+
+    do {
+      // Check that input length should not be negative.
+      DWIO_ENSURE_GE(
+          compressedSize,
+          dwio::common::INT_BYTE_SIZE,
+          "{} decompression failed, input len is too small: {}",
+          kind_,
+          compressedSize);
+      // Read the length of the next lz4/lzo compressed block.
+      uint32_t compressedBlockSize =
+          folly::Endian::big(folly::loadUnaligned<uint32_t>(inputPtr));
+      inputPtr += dwio::common::INT_BYTE_SIZE;
+      compressedSize -= dwio::common::INT_BYTE_SIZE;
+
+      if (compressedBlockSize == 0) {
+        continue;
+      }
+
+      DWIO_ENSURE_LE(
+          compressedBlockSize,
+          compressedSize,
+          "{} decompression failed, compressedBlockSize is greater than compressedSize, "
+          "compressedBlockSize: {}, compressedSize: {}",
+          kind_,
+          compressedBlockSize,
+          compressedSize);
+
+      // Decompress this block.
+      remainingOutputSize = uncompressedSize - decompressedTotalSize;
+      uint64_t decompressedSize = decompressInternal(
+          inputPtr,
+          static_cast<int32_t>(compressedBlockSize),
+          outPtr,
+          static_cast<int32_t>(remainingOutputSize));
+
+      DWIO_ENSURE_LE(
+          decompressedSize,
+          remainingOutputSize,
+          "{} decompression failed, decompressedSize is not less than or equal to remainingOutputSize, "
+          "decompressedSize: {}, remainingOutputSize: {}",
+          ::facebook::velox::common::compressionKindToString(kind_),
+          decompressedSize,
+          remainingOutputSize);
+
+      outPtr += decompressedSize;
+      inputPtr += compressedBlockSize;
+      compressedSize -= compressedBlockSize;
+      decompressedBlockSize -= decompressedSize;
+      decompressedTotalSize += decompressedSize;
+    } while (decompressedBlockSize > 0);
+  }
+
+  DWIO_ENSURE_EQ(
+      decompressedTotalSize,
+      uncompressedSize,
+      "{} decompression failed, decompressedTotalSize is not equal to uncompressedSize, "
+      "decompressedTotalSize: {}, uncompressedSize: {}",
+      kind_,
+      decompressedTotalSize,
+      uncompressedSize);
+
+  return decompressedTotalSize;
+}
+
+class LzoDecompressor : public LzoAndLz4DecompressorCommon {
+ public:
+  explicit LzoDecompressor(
+      uint64_t blockSize,
+      bool isHadoopFrameFormat,
+      const std::string& streamDebugInfo)
+      : LzoAndLz4DecompressorCommon{
+            blockSize,
+            velox::common::CompressionKind_LZO,
+            isHadoopFrameFormat,
+            streamDebugInfo} {}
+
+  uint64_t decompressInternal(
       const char* src,
       uint64_t srcLength,
       char* dest,
@@ -211,21 +355,26 @@ class LzoDecompressor : public Decompressor {
   }
 };
 
-class Lz4Decompressor : public Decompressor {
+class Lz4Decompressor : public LzoAndLz4DecompressorCommon {
  public:
   explicit Lz4Decompressor(
       uint64_t blockSize,
+      bool isHadoopFrameFormat,
       const std::string& streamDebugInfo)
-      : Decompressor{blockSize, streamDebugInfo} {}
+      : LzoAndLz4DecompressorCommon{
+            blockSize,
+            velox::common::CompressionKind_LZ4,
+            isHadoopFrameFormat,
+            streamDebugInfo} {}
 
-  uint64_t decompress(
+  uint64_t decompressInternal(
       const char* src,
       uint64_t srcLength,
       char* dest,
       uint64_t destLength) override;
 };
 
-uint64_t Lz4Decompressor::decompress(
+uint64_t Lz4Decompressor::decompressInternal(
     const char* src,
     uint64_t srcLength,
     char* dest,
@@ -461,36 +610,25 @@ bool ZlibDecompressionStream::readOrSkip(const void** data, int32_t* size) {
 
 } // namespace
 
-std::unique_ptr<BufferedOutputStream> createCompressor(
+std::unique_ptr<Compressor> createCompressor(
     CompressionKind kind,
-    CompressionBufferPool& bufferPool,
-    DataBufferHolder& bufferHolder,
-    uint8_t pageHeaderSize,
-    const CompressionOptions& options,
-    const Encrypter* encrypter) {
-  std::unique_ptr<Compressor> compressor;
+    const CompressionOptions& options) {
   switch (kind) {
     case CompressionKind::CompressionKind_NONE:
-      if (!encrypter) {
-        return std::make_unique<BufferedOutputStream>(bufferHolder);
-      }
-      // compressor remain as nullptr
-      break;
+      return nullptr;
     case CompressionKind::CompressionKind_ZLIB: {
-      compressor = std::make_unique<ZlibCompressor>(
-          options.format.zlib.compressionLevel);
       XLOG_FIRST_N(INFO, 1) << fmt::format(
           "Initialized zlib compressor with compression level {}",
           options.format.zlib.compressionLevel);
-      break;
+      return std::make_unique<ZlibCompressor>(
+          options.format.zlib.compressionLevel);
     }
     case CompressionKind::CompressionKind_ZSTD: {
-      compressor = std::make_unique<ZstdCompressor>(
-          options.format.zstd.compressionLevel);
       XLOG_FIRST_N(INFO, 1) << fmt::format(
           "Initialized zstd compressor with compression level {}",
           options.format.zstd.compressionLevel);
-      break;
+      return std::make_unique<ZstdCompressor>(
+          options.format.zstd.compressionLevel);
     }
     case CompressionKind::CompressionKind_SNAPPY:
     case CompressionKind::CompressionKind_LZO:
@@ -499,13 +637,7 @@ std::unique_ptr<BufferedOutputStream> createCompressor(
       VELOX_UNSUPPORTED(
           "Unsupported compression type: {}", compressionKindToString(kind));
   }
-  return std::make_unique<PagedOutputStream>(
-      bufferPool,
-      bufferHolder,
-      options.compressionThreshold,
-      pageHeaderSize,
-      std::move(compressor),
-      encrypter);
+  return nullptr;
 }
 
 std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
@@ -565,12 +697,16 @@ std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
           std::make_unique<SnappyDecompressor>(blockSize, streamDebugInfo);
       break;
     case CompressionKind::CompressionKind_LZO:
-      decompressor =
-          std::make_unique<LzoDecompressor>(blockSize, streamDebugInfo);
+      decompressor = std::make_unique<LzoDecompressor>(
+          blockSize,
+          options.format.lz4_lzo.isHadoopFrameFormat,
+          streamDebugInfo);
       break;
     case CompressionKind::CompressionKind_LZ4:
-      decompressor =
-          std::make_unique<Lz4Decompressor>(blockSize, streamDebugInfo);
+      decompressor = std::make_unique<Lz4Decompressor>(
+          blockSize,
+          options.format.lz4_lzo.isHadoopFrameFormat,
+          streamDebugInfo);
       break;
     case CompressionKind::CompressionKind_ZSTD:
       decompressor =
diff --git a/velox/dwio/common/compression/Compression.h b/velox/dwio/common/compression/Compression.h
index 2209ac52f20fd..3d26b3af98a42 100644
--- a/velox/dwio/common/compression/Compression.h
+++ b/velox/dwio/common/compression/Compression.h
@@ -17,9 +17,7 @@
 #pragma once
 
 #include "velox/common/compression/Compression.h"
-#include "velox/dwio/common/OutputStream.h"
 #include "velox/dwio/common/SeekableInputStream.h"
-#include "velox/dwio/common/compression/CompressionBufferPool.h"
 #include "velox/dwio/common/encryption/Encryption.h"
 
 namespace facebook::velox::dwio::common::compression {
@@ -82,6 +80,10 @@ struct CompressionOptions {
     struct {
       int32_t compressionLevel;
     } zstd;
+
+    struct {
+      bool isHadoopFrameFormat;
+    } lz4_lzo;
   } format;
 
   uint32_t compressionThreshold;
@@ -111,18 +113,10 @@ std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
 /**
  * Create a compressor for the given compression kind.
  * @param kind The compression type to implement
- * @param bufferPool Pool for compression buffer
- * @param bufferHolder Buffer holder that handles buffer allocation and
- * collection
- * @param pageHeaderSize Header size of compressed block
  * @param options The compression options to use
  */
-std::unique_ptr<BufferedOutputStream> createCompressor(
+std::unique_ptr<Compressor> createCompressor(
     facebook::velox::common::CompressionKind kind,
-    CompressionBufferPool& bufferPool,
-    DataBufferHolder& bufferHolder,
-    uint8_t pageHeaderSize,
-    const CompressionOptions& options,
-    const dwio::common::encryption::Encrypter* encrypter = nullptr);
+    const CompressionOptions& options);
 
 } // namespace facebook::velox::dwio::common::compression
diff --git a/velox/dwio/common/compression/PagedInputStream.cpp b/velox/dwio/common/compression/PagedInputStream.cpp
index 2cbed38f40a94..08357298cf57a 100644
--- a/velox/dwio/common/compression/PagedInputStream.cpp
+++ b/velox/dwio/common/compression/PagedInputStream.cpp
@@ -213,6 +213,7 @@ bool PagedInputStream::readOrSkip(const void** data, int32_t* size) {
 }
 
 void PagedInputStream::BackUp(int32_t count) {
+  VELOX_CHECK_GE(count, 0);
   if (pendingSkip_ > 0) {
     auto len = std::min<int64_t>(count, pendingSkip_);
     pendingSkip_ -= len;
@@ -257,7 +258,8 @@ bool PagedInputStream::skipAllPending() {
   return true;
 }
 
-bool PagedInputStream::Skip(int32_t count) {
+bool PagedInputStream::SkipInt64(int64_t count) {
+  VELOX_CHECK_GE(count, 0);
   pendingSkip_ += count;
   // We never use the return value of this function so this is OK.
   return true;
@@ -269,6 +271,8 @@ void PagedInputStream::clearDecompressionState() {
   remainingLength_ = 0;
   inputBufferPtr_ = nullptr;
   inputBufferPtrEnd_ = nullptr;
+  lastHeaderOffset_ = input_->ByteCount();
+  bytesReturnedAtLastHeaderOffset_ = bytesReturned_;
 }
 
 void PagedInputStream::seekToPosition(
@@ -280,8 +284,7 @@ void PagedInputStream::seekToPosition(
   // to the beginning of the last view or last header, whichever is
   // later. If we are returning views into the decompression buffer,
   // we can backup to the beginning of the decompressed buffer
-  auto alreadyRead =
-      bytesReturned_ - bytesReturnedAtLastHeaderOffset_ + pendingSkip_;
+  auto alreadyRead = bytesReturned_ - bytesReturnedAtLastHeaderOffset_;
 
   // outsideOriginalWindow is true if we are returning views into
   // the input stream's buffer and we are seeking below the start of the last
@@ -300,6 +303,7 @@ void PagedInputStream::seekToPosition(
     clearDecompressionState();
     pendingSkip_ = uncompressedOffset;
   } else {
+    alreadyRead += pendingSkip_;
     if (uncompressedOffset < alreadyRead) {
       BackUp(alreadyRead - uncompressedOffset);
     } else {
diff --git a/velox/dwio/common/compression/PagedInputStream.h b/velox/dwio/common/compression/PagedInputStream.h
index 54faced08eaa9..b7ecd99fd4c94 100644
--- a/velox/dwio/common/compression/PagedInputStream.h
+++ b/velox/dwio/common/compression/PagedInputStream.h
@@ -54,7 +54,7 @@ class PagedInputStream : public dwio::common::SeekableInputStream {
   void BackUp(int32_t count) override;
 
   // NOTE: This always returns true.
-  bool Skip(int32_t count) override;
+  bool SkipInt64(int64_t count) override;
 
   google::protobuf::int64 ByteCount() const override {
     return bytesReturned_ + pendingSkip_;
diff --git a/velox/dwio/common/compression/PagedOutputStream.cpp b/velox/dwio/common/compression/PagedOutputStream.cpp
index 9b83e84deff37..18d993bf74f05 100644
--- a/velox/dwio/common/compression/PagedOutputStream.cpp
+++ b/velox/dwio/common/compression/PagedOutputStream.cpp
@@ -93,7 +93,9 @@ uint64_t PagedOutputStream::flush() {
     auto buffers = createPage();
     const auto cleanup = folly::makeGuard([this]() {
       resetBuffers();
-      // Reset input buffers.
+      // Reset input buffers. clear() forces the buffer to shrink.
+      // Not doing so lead to very high flush memory overhead.
+      buffer_.clear();
       buffer_.resize(pageHeaderSize_);
     });
     bufferHolder_.take(std::move(buffers));
diff --git a/velox/dwio/common/compression/PagedOutputStream.h b/velox/dwio/common/compression/PagedOutputStream.h
index f15e22908690a..498bba3c781c3 100644
--- a/velox/dwio/common/compression/PagedOutputStream.h
+++ b/velox/dwio/common/compression/PagedOutputStream.h
@@ -16,7 +16,9 @@
 
 #pragma once
 
+#include "velox/dwio/common/OutputStream.h"
 #include "velox/dwio/common/compression/Compression.h"
+#include "velox/dwio/common/compression/CompressionBufferPool.h"
 
 namespace facebook::velox::dwio::common::compression {
 
diff --git a/velox/dwio/common/encryption/CMakeLists.txt b/velox/dwio/common/encryption/CMakeLists.txt
index b6c55051e38f9..610ebb4684af7 100644
--- a/velox/dwio/common/encryption/CMakeLists.txt
+++ b/velox/dwio/common/encryption/CMakeLists.txt
@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_dwio_common_encryption Encryption.cpp)
+velox_add_library(velox_dwio_common_encryption Encryption.cpp)
 
-target_link_libraries(velox_dwio_common_encryption Folly::folly)
+velox_link_libraries(velox_dwio_common_encryption Folly::folly)
diff --git a/velox/dwio/common/encryption/TestProvider.h b/velox/dwio/common/encryption/TestProvider.h
index f1bd5a029d55b..7ef41de8e5743 100644
--- a/velox/dwio/common/encryption/TestProvider.h
+++ b/velox/dwio/common/encryption/TestProvider.h
@@ -58,7 +58,7 @@ class TestEncryption {
 
  private:
   std::string key_;
-  mutable size_t count_;
+  mutable std::atomic<size_t> count_;
 };
 
 class TestEncrypter : public TestEncryption, public Encrypter {
diff --git a/velox/dwio/common/exception/CMakeLists.txt b/velox/dwio/common/exception/CMakeLists.txt
index 325c2c1a94f16..43d2d8a067b21 100644
--- a/velox/dwio/common/exception/CMakeLists.txt
+++ b/velox/dwio/common/exception/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_dwio_common_exception Exception.cpp Exceptions.cpp)
+velox_add_library(velox_dwio_common_exception Exception.cpp Exceptions.cpp)
 
-target_link_libraries(velox_dwio_common_exception velox_exception Folly::folly
-                      glog::glog)
+velox_link_libraries(velox_dwio_common_exception velox_exception Folly::folly
+                     glog::glog)
diff --git a/velox/dwio/common/exception/Exceptions.cpp b/velox/dwio/common/exception/Exceptions.cpp
index c3074064535ae..6aaadef3a31a4 100644
--- a/velox/dwio/common/exception/Exceptions.cpp
+++ b/velox/dwio/common/exception/Exceptions.cpp
@@ -44,7 +44,7 @@ void verify(bool c, std::string fmt...) {
   }
 }
 
-void corrupt(std::string fmt...) {
+[[noreturn]] void corrupt(std::string fmt...) {
   va_list ap;
   va_start(ap, fmt);
   auto s = error_string(fmt, ap);
diff --git a/velox/dwio/common/exception/Exceptions.h b/velox/dwio/common/exception/Exceptions.h
index 67a31ed90c479..d6963468ea40a 100644
--- a/velox/dwio/common/exception/Exceptions.h
+++ b/velox/dwio/common/exception/Exceptions.h
@@ -89,7 +89,7 @@ void verify_range(uint64_t v, uint64_t rangeMask);
 
 void verify(bool c, std::string fmt...);
 
-void corrupt(std::string fmt...);
+[[noreturn]] void corrupt(std::string fmt...);
 
 std::string error_string(std::string fmt, va_list ap);
 std::string format_error_string(std::string fmt...);
diff --git a/velox/dwio/common/tests/BitConcatenationTest.cpp b/velox/dwio/common/tests/BitConcatenationTest.cpp
index 8ace181321e1b..2529d03b471de 100644
--- a/velox/dwio/common/tests/BitConcatenationTest.cpp
+++ b/velox/dwio/common/tests/BitConcatenationTest.cpp
@@ -22,7 +22,8 @@ using namespace facebook::velox;
 using namespace facebook::velox::dwio::common;
 
 TEST(BitConcatenationTests, basic) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+  memory::MemoryManager::testingSetInstance({});
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
   BitConcatenation bits(*pool);
   BufferPtr result;
 
diff --git a/velox/dwio/common/tests/BitPackDecoderBenchmark.cpp b/velox/dwio/common/tests/BitPackDecoderBenchmark.cpp
index 62d847fd99ecf..19072dd2a55e9 100644
--- a/velox/dwio/common/tests/BitPackDecoderBenchmark.cpp
+++ b/velox/dwio/common/tests/BitPackDecoderBenchmark.cpp
@@ -22,13 +22,14 @@
 #include "velox/dwio/common/tests/Lemire/bmipacking32.h"
 #endif
 
-#include "velox/external/duckdb/duckdb-fastpforlib.hpp"
+#include "velox/dwio/common/tests/Lemire/FastPFor/bitpackinghelpers.h"
 
 #include <arrow/util/rle_encoding.h>
 #include <folly/Benchmark.h>
 #include <folly/Random.h>
 #include <folly/init/Init.h>
-#include "velox/external/duckdb/duckdb.hpp"
+
+#include <duckdb.hpp> // @manual
 
 using namespace folly;
 using namespace facebook::velox;
@@ -37,7 +38,7 @@ using RowSet = folly::Range<const facebook::velox::vector_size_t*>;
 
 static const uint64_t kNumValues = 1024768 * 8;
 
-namespace duckdb {
+namespace facebook::velox::parquet {
 
 class ByteBuffer { // on to the 10 thousandth impl
  public:
@@ -64,7 +65,7 @@ class ByteBuffer { // on to the 10 thousandth impl
   template <class T>
   T get() {
     available(sizeof(T));
-    T val = Load<T>((data_ptr_t)ptr);
+    T val = duckdb::Load<T>((duckdb::data_ptr_t)ptr);
     return val;
   }
 
@@ -103,7 +104,7 @@ class ParquetDecodeUtils {
       uint32_t count,
       uint8_t width) {
     if (width >= ParquetDecodeUtils::BITPACK_MASKS_SIZE) {
-      throw InvalidInputException(
+      throw duckdb::InvalidInputException(
           "The width (%d) of the bitpacked data exceeds the supported max width (%d), "
           "the file might be corrupted.",
           width,
@@ -144,9 +145,9 @@ class ParquetDecodeUtils {
     return result;
   }
 };
-} // namespace duckdb
+} // namespace facebook::velox::parquet
 
-const uint64_t duckdb::ParquetDecodeUtils::BITPACK_MASKS[] = {
+const uint64_t facebook::velox::parquet::ParquetDecodeUtils::BITPACK_MASKS[] = {
     0,
     1,
     3,
@@ -213,10 +214,11 @@ const uint64_t duckdb::ParquetDecodeUtils::BITPACK_MASKS[] = {
     9223372036854775807,
     18446744073709551615ULL};
 
-const uint64_t duckdb::ParquetDecodeUtils::BITPACK_MASKS_SIZE =
-    sizeof(ParquetDecodeUtils::BITPACK_MASKS) / sizeof(uint64_t);
+const uint64_t
+    facebook::velox::parquet::ParquetDecodeUtils::BITPACK_MASKS_SIZE =
+        sizeof(ParquetDecodeUtils::BITPACK_MASKS) / sizeof(uint64_t);
 
-const uint8_t duckdb::ParquetDecodeUtils::BITPACK_DLEN = 8;
+const uint8_t facebook::velox::parquet::ParquetDecodeUtils::BITPACK_DLEN = 8;
 
 // Array of bit packed representations of randomInts_u32. The array at index i
 // is packed i bits wide and the values come from the low bits of
@@ -244,18 +246,18 @@ std::vector<char> buffer_u64;
 
 template <typename T>
 void naiveDecodeBitsLE(
-    const uint64_t* FOLLY_NONNULL bits,
+    const uint64_t* bits,
     int32_t bitOffset,
     RowSet rows,
     int32_t rowBias,
     uint8_t bitWidth,
     const char* bufferEnd,
-    T* FOLLY_NONNULL result);
+    T* result);
 
 template <typename T>
 void legacyUnpackNaive(RowSet rows, uint8_t bitWidth, T* result) {
   auto data = bitPackedData[bitWidth].data();
-  auto numBytes = bits::roundUp((rows.back() + 1) * bitWidth, 8) / 8;
+  auto numBytes = bits::divRoundUp((rows.back() + 1) * bitWidth, 8);
   auto end = reinterpret_cast<const char*>(data) + numBytes;
   naiveDecodeBitsLE(data, 0, rows, 0, bitWidth, end, result32.data());
 }
@@ -263,7 +265,7 @@ void legacyUnpackNaive(RowSet rows, uint8_t bitWidth, T* result) {
 template <typename T>
 void legacyUnpackFast(RowSet rows, uint8_t bitWidth, T* result) {
   auto data = bitPackedData[bitWidth].data();
-  auto numBytes = bits::roundUp((rows.back() + 1) * bitWidth, 8) / 8;
+  auto numBytes = bits::divRoundUp((rows.back() + 1) * bitWidth, 8);
   auto end = reinterpret_cast<const char*>(data) + numBytes;
   facebook::velox::dwio::common::unpack(
       data,
@@ -289,7 +291,7 @@ void fastpforlib(uint8_t bitWidth, T* result) {
   auto inputBuffer = reinterpret_cast<const T*>(bitPackedData[bitWidth].data());
   for (auto i = 0; i < numBatches; i++) {
     // Read 4 bytes and unpack 32 values
-    duckdb_fastpforlib::fastunpack(
+    velox::fastpforlib::fastunpack(
         inputBuffer + i * 4, result + i * 32, bitWidth);
   }
 }
@@ -315,11 +317,11 @@ void arrowBitUnpack(uint8_t bitWidth, T* result) {
 
 template <typename T>
 void duckdbBitUnpack(uint8_t bitWidth, T* result) {
-  duckdb::ByteBuffer duckInputBuffer(
+  facebook::velox::parquet::ByteBuffer duckInputBuffer(
       reinterpret_cast<char*>(bitPackedData[bitWidth].data()),
       BYTES(kNumValues, bitWidth));
   uint8_t bitpack_pos = 0;
-  duckdb::ParquetDecodeUtils::BitUnpack<T>(
+  facebook::velox::parquet::ParquetDecodeUtils::BitUnpack<T>(
       duckInputBuffer, bitpack_pos, result, kNumValues, bitWidth);
 }
 
@@ -501,7 +503,7 @@ BENCHMARK_UNPACK_ODDROWS_CASE_32(31)
 void populateBitPacked() {
   bitPackedData.resize(33);
   for (auto bitWidth = 1; bitWidth <= 32; ++bitWidth) {
-    auto numWords = bits::roundUp(randomInts_u32.size() * bitWidth, 64) / 64;
+    auto numWords = bits::divRoundUp(randomInts_u32.size() * bitWidth, 64);
     bitPackedData[bitWidth].resize(numWords);
     auto source = reinterpret_cast<uint64_t*>(randomInts_u32.data());
     auto destination =
@@ -526,13 +528,13 @@ void populateBitPacked() {
 // Naive unpacking, original version of IntDecoder::unpack.
 template <typename T>
 void naiveDecodeBitsLE(
-    const uint64_t* FOLLY_NONNULL bits,
+    const uint64_t* bits,
     int32_t bitOffset,
     RowSet rows,
     int32_t rowBias,
     uint8_t bitWidth,
     const char* bufferEnd,
-    T* FOLLY_NONNULL result) {
+    T* result) {
   uint64_t mask = bits::lowMask(bitWidth);
   auto numRows = rows.size();
   if (bitWidth > 56) {
@@ -542,13 +544,12 @@ void naiveDecodeBitsLE(
     }
     return;
   }
-  auto FOLLY_NONNULL lastSafe = bufferEnd - sizeof(uint64_t);
+  auto lastSafe = bufferEnd - sizeof(uint64_t);
   int32_t numSafeRows = numRows;
   bool anyUnsafe = false;
   if (bufferEnd) {
     const char* endByte = reinterpret_cast<const char*>(bits) +
-        bits::roundUp(bitOffset + (rows.back() - rowBias + 1) * bitWidth, 8) /
-            8;
+        bits::divRoundUp(bitOffset + (rows.back() - rowBias + 1) * bitWidth, 8);
     // redzone is the number of bytes at the end of the accessed range that
     // could overflow the buffer if accessed 64 its wide.
     int64_t redZone =
@@ -592,7 +593,7 @@ void naiveDecodeBitsLE(
 }
 
 int32_t main(int32_t argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   // Populate uint32 buffer
 
diff --git a/velox/dwio/common/tests/BitPackDecoderTest.cpp b/velox/dwio/common/tests/BitPackDecoderTest.cpp
index 945a11caba9f3..271fe8533784a 100644
--- a/velox/dwio/common/tests/BitPackDecoderTest.cpp
+++ b/velox/dwio/common/tests/BitPackDecoderTest.cpp
@@ -45,7 +45,7 @@ class BitPackDecoderTest : public testing::Test {
   void populateBitPackedData() {
     bitPackedData_.resize(33);
     for (auto bitWidth = 1; bitWidth <= 32; ++bitWidth) {
-      auto numWords = bits::roundUp(randomInts_.size() * bitWidth, 64) / 64;
+      auto numWords = bits::divRoundUp(randomInts_.size() * bitWidth, 64);
       bitPackedData_[bitWidth].resize(numWords);
       auto source = randomInts_.data();
       auto destination =
diff --git a/velox/dwio/common/tests/CMakeLists.txt b/velox/dwio/common/tests/CMakeLists.txt
index 4487b18ce4411..f413dcdab12e9 100644
--- a/velox/dwio/common/tests/CMakeLists.txt
+++ b/velox/dwio/common/tests/CMakeLists.txt
@@ -22,57 +22,62 @@ add_executable(
   ColumnSelectorTests.cpp
   DataBufferTests.cpp
   DecoderUtilTest.cpp
+  ExecutorBarrierTest.cpp
+  OnDemandUnitLoaderTests.cpp
   LocalFileSinkTest.cpp
+  MemorySinkTest.cpp
   LoggedExceptionTest.cpp
+  MeasureTimeTests.cpp
+  ParallelForTest.cpp
   RangeTests.cpp
   ReadFileInputStreamTests.cpp
+  ReaderTest.cpp
   RetryTests.cpp
   TestBufferedInput.cpp
-  TypeTests.cpp)
+  ThrottlerTest.cpp
+  TypeTests.cpp
+  UnitLoaderToolsTests.cpp
+  WriterTest.cpp
+  OptionsTests.cpp)
 add_test(velox_dwio_common_test velox_dwio_common_test)
 target_link_libraries(
   velox_dwio_common_test
   velox_dwio_common_test_utils
   velox_temp_path
+  velox_vector_test_lib
   Boost::regex
   velox_link_libs
   Folly::folly
   ${TEST_LINK_LIBS}
   gflags::gflags
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   glog::glog
-  fmt::fmt)
+  fmt::fmt
+  protobuf::libprotobuf)
 
 add_executable(velox_dwio_common_data_buffer_benchmark DataBufferBenchmark.cpp)
 
 target_link_libraries(
-  velox_dwio_common_data_buffer_benchmark velox_dwio_common velox_memory
-  velox_dwio_common_exception Folly::folly ${FOLLY_BENCHMARK})
+  velox_dwio_common_data_buffer_benchmark
+  velox_dwio_common
+  velox_memory
+  velox_dwio_common_exception
+  Folly::folly
+  ${FOLLY_BENCHMARK})
 
 add_executable(velox_dwio_common_int_decoder_benchmark IntDecoderBenchmark.cpp)
 target_link_libraries(
-  velox_dwio_common_int_decoder_benchmark velox_dwio_common_exception
-  velox_exception velox_dwio_dwrf_common Folly::folly ${FOLLY_BENCHMARK})
-
-add_library(velox_e2e_filter_test_base E2EFilterTestBase.cpp)
-
-target_link_libraries(
-  velox_e2e_filter_test_base
-  velox_functions_prestosql
-  velox_parse_parser
-  velox_vector_test_lib
-  velox_link_libs
+  velox_dwio_common_int_decoder_benchmark
+  velox_dwio_common_exception
+  velox_exception
+  velox_dwio_dwrf_common
   Folly::folly
-  fmt::fmt
-  lz4::lz4
-  lzo2::lzo2
-  zstd::zstd
-  ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${FOLLY_BENCHMARK})
 
-if(VELOX_ENABLE_ARROW)
+if(VELOX_ENABLE_ARROW AND VELOX_ENABLE_BENCHMARKS)
+  add_subdirectory(Lemire/FastPFor)
   add_executable(velox_dwio_common_bitpack_decoder_benchmark
                  BitPackDecoderBenchmark.cpp)
 
@@ -80,6 +85,11 @@ if(VELOX_ENABLE_ARROW)
                          PRIVATE -Wno-deprecated-declarations)
 
   target_link_libraries(
-    velox_dwio_common_bitpack_decoder_benchmark velox_dwio_common arrow duckdb
-    Folly::folly ${FOLLY_BENCHMARK})
+    velox_dwio_common_bitpack_decoder_benchmark
+    velox_dwio_common
+    arrow
+    velox_fastpforlib
+    duckdb_static
+    Folly::folly
+    ${FOLLY_BENCHMARK})
 endif()
diff --git a/velox/dwio/common/tests/ChainedBufferTests.cpp b/velox/dwio/common/tests/ChainedBufferTests.cpp
index 46bb292681e3f..a83fbcf69fd56 100644
--- a/velox/dwio/common/tests/ChainedBufferTests.cpp
+++ b/velox/dwio/common/tests/ChainedBufferTests.cpp
@@ -16,6 +16,8 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include "velox/common/memory/Memory.h"
+#include "velox/common/memory/MemoryPool.h"
 #include "velox/dwio/common/ChainedBuffer.h"
 
 using namespace ::testing;
@@ -25,25 +27,33 @@ namespace velox {
 namespace dwio {
 namespace common {
 
-TEST(ChainedBufferTests, testCreate) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  ChainedBuffer<int32_t> buf{*pool, 128, 1024};
+class ChainedBufferTests : public Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+};
+
+TEST_F(ChainedBufferTests, testCreate) {
+  ChainedBuffer<int32_t> buf{*pool_, 128, 1024};
   ASSERT_EQ(buf.capacity(), 128);
   ASSERT_EQ(buf.pages_.size(), 1);
-  ChainedBuffer<int32_t> buf2{*pool, 256, 1024};
+  ChainedBuffer<int32_t> buf2{*pool_, 256, 1024};
   ASSERT_EQ(buf2.capacity(), 256);
   ASSERT_EQ(buf2.pages_.size(), 1);
-  ChainedBuffer<int32_t> buf3{*pool, 257, 1024};
+  ChainedBuffer<int32_t> buf3{*pool_, 257, 1024};
   ASSERT_EQ(buf3.capacity(), 512);
   ASSERT_EQ(buf3.pages_.size(), 2);
 
   ASSERT_THROW(
-      (ChainedBuffer<int32_t>{*pool, 256, 257}), exception::LoggedException);
+      (ChainedBuffer<int32_t>{*pool_, 256, 257}), exception::LoggedException);
 }
 
-TEST(ChainedBufferTests, testReserve) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  ChainedBuffer<int32_t> buf{*pool, 16, 1024};
+TEST_F(ChainedBufferTests, testReserve) {
+  ChainedBuffer<int32_t> buf{*pool_, 16, 1024};
   buf.reserve(16);
   buf.reserve(17);
   ASSERT_EQ(buf.capacity(), 32);
@@ -59,9 +69,8 @@ TEST(ChainedBufferTests, testReserve) {
   ASSERT_EQ(buf.pages_.size(), 5);
 }
 
-TEST(ChainedBufferTests, testAppend) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  ChainedBuffer<int32_t> buf{*pool, 16, 64};
+TEST_F(ChainedBufferTests, testAppend) {
+  ChainedBuffer<int32_t> buf{*pool_, 16, 64};
   for (size_t i = 0; i < 16; ++i) {
     buf.unsafeAppend(i);
     ASSERT_EQ(buf.capacity(), 16);
@@ -84,29 +93,27 @@ TEST(ChainedBufferTests, testAppend) {
   ASSERT_EQ(buf[buf.size() - 1], 100);
 }
 
-TEST(ChainedBufferTests, testClear) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  ChainedBuffer<int32_t> buf{*pool, 128, 1024};
+TEST_F(ChainedBufferTests, testClear) {
+  ChainedBuffer<int32_t> buf{*pool_, 128, 1024};
   buf.clear();
   ASSERT_EQ(buf.capacity(), 128);
   ASSERT_EQ(buf.size(), 0);
   ASSERT_EQ(buf.pages_.size(), 1);
 
-  ChainedBuffer<int32_t> buf2{*pool, 1024, 1024};
+  ChainedBuffer<int32_t> buf2{*pool_, 1024, 1024};
   buf2.clear();
   ASSERT_EQ(buf2.capacity(), 256);
   ASSERT_EQ(buf2.size(), 0);
   ASSERT_EQ(buf2.pages_.size(), 1);
 }
 
-TEST(ChainedBufferTests, testApplyRange) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+TEST_F(ChainedBufferTests, testApplyRange) {
   std::vector<std::tuple<uint64_t, uint64_t, int32_t>> result;
   auto fn = [&](auto ptr, auto begin, auto end) {
     result.push_back({begin, end, *ptr});
   };
 
-  ChainedBuffer<int32_t> buf{*pool, 64, 64};
+  ChainedBuffer<int32_t> buf{*pool_, 64, 64};
   for (size_t i = 0; i < 64 / 16; ++i) {
     for (size_t j = 0; j < 16; ++j) {
       buf.unsafeAppend(i);
@@ -153,9 +160,8 @@ TEST(ChainedBufferTests, testApplyRange) {
           std::tuple<uint64_t, uint64_t, int32_t>{0, 16, 3}));
 }
 
-TEST(ChainedBufferTests, testGetPage) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  ChainedBuffer<int32_t> buf{*pool, 1024, 1024};
+TEST_F(ChainedBufferTests, testGetPage) {
+  ChainedBuffer<int32_t> buf{*pool_, 1024, 1024};
   ASSERT_EQ(
       std::addressof(buf.getPageUnsafe(0)), std::addressof(buf.pages_.at(0)));
   ASSERT_EQ(
@@ -166,7 +172,7 @@ TEST(ChainedBufferTests, testGetPage) {
       std::addressof(buf.getPageUnsafe(1023)),
       std::addressof(buf.pages_.at(3)));
 
-  ChainedBuffer<int64_t> buf2{*pool, 1024, 1024};
+  ChainedBuffer<int64_t> buf2{*pool_, 1024, 1024};
   ASSERT_EQ(
       std::addressof(buf2.getPageUnsafe(0)), std::addressof(buf2.pages_.at(0)));
   ASSERT_EQ(
@@ -180,9 +186,8 @@ TEST(ChainedBufferTests, testGetPage) {
       std::addressof(buf2.pages_.at(7)));
 }
 
-TEST(ChainedBufferTests, testGetPageIndex) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  ChainedBuffer<int8_t> buf{*pool, 1024, 1024};
+TEST_F(ChainedBufferTests, testGetPageIndex) {
+  ChainedBuffer<int8_t> buf{*pool_, 1024, 1024};
   ASSERT_EQ(buf.getPageIndex(0), 0);
   ASSERT_EQ(buf.getPageIndex(256), 0);
   ASSERT_EQ(buf.getPageIndex(1023), 0);
@@ -190,7 +195,7 @@ TEST(ChainedBufferTests, testGetPageIndex) {
   ASSERT_EQ(buf.getPageIndex(4095), 3);
   ASSERT_EQ(buf.getPageIndex(4096), 4);
 
-  ChainedBuffer<int32_t> buf2{*pool, 1024, 1024};
+  ChainedBuffer<int32_t> buf2{*pool_, 1024, 1024};
   ASSERT_EQ(buf2.getPageIndex(0), 0);
   ASSERT_EQ(buf2.getPageIndex(255), 0);
   ASSERT_EQ(buf2.getPageIndex(256), 1);
@@ -198,9 +203,8 @@ TEST(ChainedBufferTests, testGetPageIndex) {
   ASSERT_EQ(buf2.getPageIndex(4096), 16);
 }
 
-TEST(ChainedBufferTests, testGetPageOffset) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  ChainedBuffer<int8_t> buf{*pool, 1024, 1024};
+TEST_F(ChainedBufferTests, testGetPageOffset) {
+  ChainedBuffer<int8_t> buf{*pool_, 1024, 1024};
   ASSERT_EQ(buf.getPageOffset(0), 0);
   ASSERT_EQ(buf.getPageOffset(256), 256);
   ASSERT_EQ(buf.getPageOffset(1023), 1023);
@@ -208,7 +212,7 @@ TEST(ChainedBufferTests, testGetPageOffset) {
   ASSERT_EQ(buf.getPageOffset(4095), 1023);
   ASSERT_EQ(buf.getPageOffset(4096), 0);
 
-  ChainedBuffer<int32_t> buf2{*pool, 1024, 1024};
+  ChainedBuffer<int32_t> buf2{*pool_, 1024, 1024};
   ASSERT_EQ(buf2.getPageOffset(0), 0);
   ASSERT_EQ(buf2.getPageOffset(255), 255);
   ASSERT_EQ(buf2.getPageOffset(256), 0);
@@ -216,14 +220,14 @@ TEST(ChainedBufferTests, testGetPageOffset) {
   ASSERT_EQ(buf2.getPageOffset(4096), 0);
 }
 
-TEST(ChainedBufferTests, testBitCount) {
+TEST_F(ChainedBufferTests, testBitCount) {
   ASSERT_EQ(ChainedBuffer<int32_t>::bitCount(0), 0);
   ASSERT_EQ(ChainedBuffer<int32_t>::bitCount(1), 1);
   ASSERT_EQ(ChainedBuffer<int32_t>::bitCount(4), 1);
   ASSERT_EQ(ChainedBuffer<int32_t>::bitCount(15), 4);
 }
 
-TEST(ChainedBufferTests, testTrailingZeros) {
+TEST_F(ChainedBufferTests, testTrailingZeros) {
   ASSERT_EQ(ChainedBuffer<int32_t>::trailingZeros(1), 0);
   ASSERT_EQ(ChainedBuffer<int32_t>::trailingZeros(12), 2);
   ASSERT_EQ(ChainedBuffer<int32_t>::trailingZeros(1u << 31), 31);
@@ -231,7 +235,7 @@ TEST(ChainedBufferTests, testTrailingZeros) {
       ChainedBuffer<int32_t>::trailingZeros(0), exception::LoggedException);
 }
 
-TEST(ChainedBufferTests, testPowerOf2) {
+TEST_F(ChainedBufferTests, testPowerOf2) {
   ASSERT_EQ(ChainedBuffer<int32_t>::trailingZeros(1), 0);
   ASSERT_EQ(ChainedBuffer<int32_t>::trailingZeros(12), 2);
   ASSERT_EQ(ChainedBuffer<int32_t>::trailingZeros(1u << 31), 31);
diff --git a/velox/dwio/common/tests/DataBufferBenchmark.cpp b/velox/dwio/common/tests/DataBufferBenchmark.cpp
index 4890f184a7383..42397b3e837d2 100644
--- a/velox/dwio/common/tests/DataBufferBenchmark.cpp
+++ b/velox/dwio/common/tests/DataBufferBenchmark.cpp
@@ -24,7 +24,7 @@ using namespace facebook::velox::dwio;
 using namespace facebook::velox::dwio::common;
 
 BENCHMARK(DataBufferOps, iters) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
   constexpr size_t size = 1024 * 1024 * 16;
   for (size_t i = 0; i < iters; ++i) {
     DataBuffer<int32_t> buf{*pool};
@@ -39,7 +39,7 @@ BENCHMARK(DataBufferOps, iters) {
 }
 
 BENCHMARK(ChainedBufferOps, iters) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
   constexpr size_t size = 1024 * 1024 * 16;
   for (size_t i = 0; i < iters; ++i) {
     ChainedBuffer<int32_t> buf{*pool, size, size * 4};
@@ -53,7 +53,8 @@ BENCHMARK(ChainedBufferOps, iters) {
 }
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   folly::runBenchmarks();
+  facebook::velox::memory::MemoryManager::initialize({});
   return 0;
 }
diff --git a/velox/dwio/common/tests/DataBufferTests.cpp b/velox/dwio/common/tests/DataBufferTests.cpp
index 36a59a7297586..b46cad8ed622e 100644
--- a/velox/dwio/common/tests/DataBufferTests.cpp
+++ b/velox/dwio/common/tests/DataBufferTests.cpp
@@ -28,10 +28,18 @@ using namespace facebook::velox::memory;
 using namespace testing;
 using MemoryPool = facebook::velox::memory::MemoryPool;
 
-TEST(DataBuffer, ZeroOut) {
+class DataBufferTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  const std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+
+TEST_F(DataBufferTest, ZeroOut) {
   const uint8_t VALUE = 13;
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  DataBuffer<uint8_t> buffer(*pool, 16);
+  DataBuffer<uint8_t> buffer(*pool_, 16);
   for (auto i = 0; i < buffer.size(); i++) {
     auto data = buffer.data();
     ASSERT_EQ(data[i], 0);
@@ -57,10 +65,8 @@ TEST(DataBuffer, ZeroOut) {
   }
 }
 
-TEST(DataBuffer, At) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-
-  DataBuffer<uint8_t> buffer{*pool};
+TEST_F(DataBufferTest, At) {
+  DataBuffer<uint8_t> buffer{*pool_};
   for (auto i = 0; i != 15; ++i) {
     buffer.append(i);
   }
@@ -79,10 +85,8 @@ TEST(DataBuffer, At) {
   }
 }
 
-TEST(DataBuffer, Reset) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-
-  DataBuffer<uint8_t> buffer{*pool};
+TEST_F(DataBufferTest, Reset) {
+  DataBuffer<uint8_t> buffer{*pool_};
   buffer.reserve(16);
   for (auto i = 0; i != 15; ++i) {
     buffer.append(i);
@@ -135,10 +139,9 @@ TEST(DataBuffer, Reset) {
   }
 }
 
-TEST(DataBuffer, Wrap) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+TEST_F(DataBufferTest, Wrap) {
   auto size = 26;
-  auto buffer = velox::AlignedBuffer::allocate<char>(size, pool.get());
+  auto buffer = velox::AlignedBuffer::allocate<char>(size, pool_.get());
   auto raw = buffer->asMutable<char>();
   for (size_t i = 0; i < size; ++i) {
     raw[i] = 'a' + i;
@@ -152,25 +155,24 @@ TEST(DataBuffer, Wrap) {
   }
 }
 
-TEST(DataBuffer, Move) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+TEST_F(DataBufferTest, Move) {
   {
-    DataBuffer<uint8_t> buffer{*pool};
+    DataBuffer<uint8_t> buffer{*pool_};
     buffer.reserve(16);
     for (auto i = 0; i != 15; ++i) {
       buffer.append(i);
     }
     ASSERT_EQ(15, buffer.size());
     ASSERT_EQ(16, buffer.capacity());
-    const auto usedBytes = pool->currentBytes();
+    const auto usedBytes = pool_->usedBytes();
 
     // Expect no double freeing from memory pool.
     DataBuffer<uint8_t> newBuffer{std::move(buffer)};
     ASSERT_EQ(15, newBuffer.size());
     ASSERT_EQ(16, newBuffer.capacity());
-    ASSERT_EQ(usedBytes, pool->currentBytes());
+    ASSERT_EQ(usedBytes, pool_->usedBytes());
   }
-  ASSERT_EQ(0, pool->currentBytes());
+  ASSERT_EQ(0, pool_->usedBytes());
 }
 } // namespace common
 } // namespace dwio
diff --git a/velox/dwio/common/tests/DecoderUtilTest.cpp b/velox/dwio/common/tests/DecoderUtilTest.cpp
index a3fc69db4f6de..f142d2baf4645 100644
--- a/velox/dwio/common/tests/DecoderUtilTest.cpp
+++ b/velox/dwio/common/tests/DecoderUtilTest.cpp
@@ -166,9 +166,8 @@ namespace facebook::velox::dwio::common {
 struct NoHook {
   void addValues(
       const int32_t* /*rows*/,
-      const void* /*values*/,
-      int32_t /*size*/,
-      uint8_t /*valueWidth*/) {}
+      const int32_t* /*values*/,
+      int32_t /*size*/) {}
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/ExecutorBarrierTest.cpp b/velox/dwio/common/tests/ExecutorBarrierTest.cpp
new file mode 100644
index 0000000000000..0eb528c0bef9c
--- /dev/null
+++ b/velox/dwio/common/tests/ExecutorBarrierTest.cpp
@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "folly/executors/CPUThreadPoolExecutor.h"
+#include "velox/dwio/common/ExecutorBarrier.h"
+
+using namespace ::testing;
+using namespace ::facebook::velox::dwio::common;
+
+TEST(ExecutorBarrierTest, GetNumPriorities) {
+  const uint8_t kNumPriorities = 5;
+  auto executor =
+      std::make_shared<folly::CPUThreadPoolExecutor>(10, kNumPriorities);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+  EXPECT_EQ(barrier->getNumPriorities(), kNumPriorities);
+}
+
+TEST(ExecutorBarrierTest, CanOwn) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  {
+    auto barrier = std::make_shared<ExecutorBarrier>(executor);
+    EXPECT_EQ(executor.use_count(), 2);
+  }
+  EXPECT_EQ(executor.use_count(), 1);
+}
+
+TEST(ExecutorBarrierTest, CanAwaitMultipleTimes) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+  for (int time = 0, multipleTimes = 10; time < multipleTimes; ++time) {
+    barrier->waitAll();
+  }
+}
+
+TEST(ExecutorBarrierTest, AddCanBeReused) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([&]() { ++count; });
+  }
+  barrier->waitAll();
+  EXPECT_EQ(count, kCalls);
+
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([&]() { ++count; });
+  }
+  barrier->waitAll();
+  EXPECT_EQ(count, (2 * kCalls));
+}
+
+TEST(ExecutorBarrierTest, AddWithPriorityCanBeReused) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  const int8_t kPriority = 4;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority([&]() { ++count; }, kPriority);
+  }
+  barrier->waitAll();
+  EXPECT_EQ(count, kCalls);
+
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority([&]() { ++count; }, kPriority);
+  }
+  barrier->waitAll();
+  EXPECT_EQ(count, (2 * kCalls));
+}
+
+TEST(ExecutorBarrierTest, AddCanBeReusedAfterException) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([&count]() {
+      ++count;
+      throw std::runtime_error("");
+    });
+  }
+  EXPECT_THROW(barrier->waitAll(), std::runtime_error);
+  EXPECT_EQ(count, kCalls);
+
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([&]() { ++count; });
+  }
+  barrier->waitAll();
+  EXPECT_EQ(count, (2 * kCalls));
+}
+
+TEST(ExecutorBarrierTest, AddWithPriorityCanBeReusedAfterException) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  const int8_t kPriority = 4;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority(
+        [&count]() {
+          ++count;
+          throw std::runtime_error("");
+        },
+        kPriority);
+  }
+  EXPECT_THROW(barrier->waitAll(), std::runtime_error);
+  EXPECT_EQ(count, kCalls);
+
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority([&]() { ++count; }, kPriority);
+  }
+  barrier->waitAll();
+  EXPECT_EQ(count, (2 * kCalls));
+}
+
+TEST(ExecutorBarrierTest, Add) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([&]() { ++count; });
+  }
+  barrier->waitAll();
+  EXPECT_EQ(count, kCalls);
+}
+
+TEST(ExecutorBarrierTest, AddWithPriority) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  const int8_t kPriority = 4;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority([&]() { ++count; }, kPriority);
+  }
+  barrier->waitAll();
+  EXPECT_EQ(count, kCalls);
+}
+
+TEST(ExecutorBarrierTest, AddCanIgnore) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([]() {});
+  }
+  // Discard: barrier->waitAll();
+}
+
+TEST(ExecutorBarrierTest, AddWithPriorityCanIgnore) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority([]() {}, i);
+  }
+  // Discard: barrier->waitAll();
+}
+
+TEST(ExecutorBarrierTest, DestructorDoesntThrow) {
+  const int kCalls = 30;
+  std::atomic<int> count{0};
+  {
+    auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+    auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+    for (int i = 0; i < kCalls; ++i) {
+      barrier->add([shouldThrow = (i == 0), &count]() {
+        ++count;
+        if (shouldThrow) {
+          throw std::runtime_error("");
+        }
+      });
+    }
+  } // executor awaits but doesn't throw
+  EXPECT_EQ(count, kCalls);
+}
+
+TEST(ExecutorBarrierTest, AddException) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([shouldThrow = (i == 0), &count]() {
+      ++count;
+      if (shouldThrow) {
+        throw std::runtime_error("");
+      }
+    });
+  }
+  EXPECT_THROW(barrier->waitAll(), std::runtime_error);
+  EXPECT_EQ(count, kCalls);
+}
+
+TEST(ExecutorBarrierTest, AddWithPriorityException) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  const int8_t kPriority = 4;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority(
+        [shouldThrow = (i == 0), &count]() {
+          ++count;
+          if (shouldThrow) {
+            throw std::runtime_error("");
+          }
+        },
+        kPriority);
+  }
+  EXPECT_THROW(barrier->waitAll(), std::runtime_error);
+  EXPECT_EQ(count, kCalls);
+}
+
+TEST(ExecutorBarrierTest, AddNonStdException) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([shouldThrow = (i == 0), &count]() {
+      ++count;
+      if (shouldThrow) {
+        // @lint-ignore CLANGTIDY facebook-hte-ThrowNonStdExceptionIssue
+        throw 1;
+      }
+    });
+  }
+  EXPECT_THROW(barrier->waitAll(), int);
+  EXPECT_EQ(count, kCalls);
+}
+
+TEST(ExecutorBarrierTest, AddWithPriorityNonStdException) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  const int8_t kPriority = 4;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority(
+        [shouldThrow = (i == 0), &count]() {
+          ++count;
+          if (shouldThrow) {
+            // @lint-ignore CLANGTIDY facebook-hte-ThrowNonStdExceptionIssue
+            throw 1;
+          }
+        },
+        kPriority);
+  }
+  EXPECT_THROW(barrier->waitAll(), int);
+  EXPECT_EQ(count, kCalls);
+}
+
+TEST(ExecutorBarrierTest, AddExceptions) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->add([&]() {
+      ++count;
+      throw std::runtime_error("");
+    });
+  }
+  EXPECT_THROW(barrier->waitAll(), std::runtime_error);
+  EXPECT_EQ(count, kCalls);
+}
+
+TEST(ExecutorBarrierTest, AddWithPriorityExceptions) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(10);
+  auto barrier = std::make_shared<ExecutorBarrier>(*executor);
+
+  const int kCalls = 30;
+  const int8_t kPriority = 4;
+  std::atomic<int> count{0};
+  for (int i = 0; i < kCalls; ++i) {
+    barrier->addWithPriority(
+        [&]() {
+          ++count;
+          throw std::runtime_error("");
+        },
+        kPriority);
+  }
+  EXPECT_THROW(barrier->waitAll(), std::runtime_error);
+  EXPECT_EQ(count, kCalls);
+}
diff --git a/velox/dwio/common/tests/IntDecoderBenchmark.cpp b/velox/dwio/common/tests/IntDecoderBenchmark.cpp
index fab234c025b28..48e61768a2277 100644
--- a/velox/dwio/common/tests/IntDecoderBenchmark.cpp
+++ b/velox/dwio/common/tests/IntDecoderBenchmark.cpp
@@ -939,7 +939,7 @@ BENCHMARK_RELATIVE(decodeNew_64) {
 }
 
 int32_t main(int32_t argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   // Populate uint16 buffer
   buffer_u16.resize(kNumElements);
diff --git a/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt b/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt
new file mode 100644
index 0000000000000..5f6ff7652e326
--- /dev/null
+++ b/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+add_library(velox_fastpforlib STATIC bitpacking.cpp)
+
+target_include_directories(
+  velox_fastpforlib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
diff --git a/velox/dwio/common/tests/Lemire/FastPFor/LICENSE b/velox/dwio/common/tests/Lemire/FastPFor/LICENSE
new file mode 100644
index 0000000000000..8405e89a0b120
--- /dev/null
+++ b/velox/dwio/common/tests/Lemire/FastPFor/LICENSE
@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
\ No newline at end of file
diff --git a/velox/dwio/common/tests/Lemire/FastPFor/bitpacking.cpp b/velox/dwio/common/tests/Lemire/FastPFor/bitpacking.cpp
new file mode 100644
index 0000000000000..d2c3dbaa1da33
--- /dev/null
+++ b/velox/dwio/common/tests/Lemire/FastPFor/bitpacking.cpp
@@ -0,0 +1,1320 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+
+#include <cstdint>
+#include <type_traits>
+
+namespace velox::fastpforlib {
+namespace internal {
+
+// Used for uint8_t, uint16_t and uint32_t
+template <
+    uint8_t DELTA,
+    uint8_t SHR,
+    class TYPE,
+    uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<(DELTA + SHR) < TYPE_SIZE>::type unpack_single_out(
+    const TYPE* __restrict in,
+    TYPE* __restrict out) {
+  *out = ((*in) >> SHR) % (1 << DELTA);
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <
+    uint8_t DELTA,
+    uint8_t SHR,
+    class TYPE,
+    uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<(DELTA + SHR) >= TYPE_SIZE>::type unpack_single_out(
+    const TYPE* __restrict& in,
+    TYPE* __restrict out) {
+  *out = (*in) >> SHR;
+  ++in;
+
+  static const TYPE NEXT_SHR = SHR + DELTA - TYPE_SIZE;
+  *out |= ((*in) % (1U << NEXT_SHR)) << (TYPE_SIZE - SHR);
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) < 32>::type unpack_single_out(
+    const uint32_t* __restrict in,
+    uint64_t* __restrict out) {
+  *out = ((static_cast<uint64_t>(*in)) >> SHR) % (1ULL << DELTA);
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) >= 32 && (DELTA + SHR) < 64>::type
+unpack_single_out(const uint32_t* __restrict& in, uint64_t* __restrict out) {
+  *out = static_cast<uint64_t>(*in) >> SHR;
+  ++in;
+  if (DELTA + SHR > 32) {
+    static const uint8_t NEXT_SHR = SHR + DELTA - 32;
+    *out |= static_cast<uint64_t>((*in) % (1U << NEXT_SHR)) << (32 - SHR);
+  }
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) >= 64>::type unpack_single_out(
+    const uint32_t* __restrict& in,
+    uint64_t* __restrict out) {
+  *out = static_cast<uint64_t>(*in) >> SHR;
+  ++in;
+
+  *out |= static_cast<uint64_t>(*in) << (32 - SHR);
+  ++in;
+
+  if (DELTA + SHR > 64) {
+    static const uint8_t NEXT_SHR = DELTA + SHR - 64;
+    *out |= static_cast<uint64_t>((*in) % (1U << NEXT_SHR)) << (64 - SHR);
+  }
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <
+    class TYPE,
+    uint16_t DELTA,
+    uint16_t SHL,
+    TYPE MASK,
+    uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+    typename std::enable_if < DELTA +
+        SHL<TYPE_SIZE>::type pack_single_in(
+                                  const TYPE in,
+                                  TYPE* __restrict out) {
+  if (SHL == 0) {
+    *out = in & MASK;
+  } else {
+    *out |= (in & MASK) << SHL;
+  }
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <
+    class TYPE,
+    uint16_t DELTA,
+    uint16_t SHL,
+    TYPE MASK,
+    uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<DELTA + SHL >= TYPE_SIZE>::type pack_single_in(
+    const TYPE in,
+    TYPE* __restrict& out) {
+  *out |= in << SHL;
+  ++out;
+
+  if (DELTA + SHL > TYPE_SIZE) {
+    *out = (in & MASK) >> (TYPE_SIZE - SHL);
+  }
+}
+
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+    typename std::enable_if < DELTA +
+        SHL<32>::type pack_single_in64(
+                                  const uint64_t in,
+                                  uint32_t* __restrict out) {
+  if (SHL == 0) {
+    *out = static_cast<uint32_t>(in & MASK);
+  } else {
+    *out |= (in & MASK) << SHL;
+  }
+}
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+        typename std::enable_if < DELTA + SHL >= 32 &&
+    DELTA +
+        SHL<64>::type pack_single_in64(
+            const uint64_t in,
+            uint32_t* __restrict& out) {
+  if (SHL == 0) {
+    *out = static_cast<uint32_t>(in & MASK);
+  } else {
+    *out |= (in & MASK) << SHL;
+  }
+
+  ++out;
+
+  if (DELTA + SHL > 32) {
+    *out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
+  }
+}
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+typename std::enable_if<DELTA + SHL >= 64>::type pack_single_in64(
+    const uint64_t in,
+    uint32_t* __restrict& out) {
+  *out |= in << SHL;
+  ++out;
+
+  *out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
+  ++out;
+
+  if (DELTA + SHL > 64) {
+    *out = (in & MASK) >> (64 - SHL);
+  }
+}
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller8 {
+  static void Unpack(const uint8_t* __restrict& in, uint8_t* __restrict out) {
+    unpack_single_out<DELTA, (DELTA * OINDEX) % 8>(in, out + OINDEX);
+
+    Unroller8<DELTA, OINDEX + 1>::Unpack(in, out);
+  }
+
+  static void Pack(const uint8_t* __restrict in, uint8_t* __restrict out) {
+    pack_single_in<uint8_t, DELTA, (DELTA * OINDEX) % 8, (1U << DELTA) - 1>(
+        in[OINDEX], out);
+
+    Unroller8<DELTA, OINDEX + 1>::Pack(in, out);
+  }
+};
+template <uint16_t DELTA>
+struct Unroller8<DELTA, 7> {
+  enum { SHIFT = (DELTA * 7) % 8 };
+
+  static void Unpack(const uint8_t* __restrict in, uint8_t* __restrict out) {
+    out[7] = (*in) >> SHIFT;
+  }
+
+  static void Pack(const uint8_t* __restrict in, uint8_t* __restrict out) {
+    *out |= (in[7] << SHIFT);
+  }
+};
+
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller16 {
+  static void Unpack(const uint16_t* __restrict& in, uint16_t* __restrict out) {
+    unpack_single_out<DELTA, (DELTA * OINDEX) % 16>(in, out + OINDEX);
+
+    Unroller16<DELTA, OINDEX + 1>::Unpack(in, out);
+  }
+
+  static void Pack(const uint16_t* __restrict in, uint16_t* __restrict out) {
+    pack_single_in<uint16_t, DELTA, (DELTA * OINDEX) % 16, (1U << DELTA) - 1>(
+        in[OINDEX], out);
+
+    Unroller16<DELTA, OINDEX + 1>::Pack(in, out);
+  }
+};
+
+template <uint16_t DELTA>
+struct Unroller16<DELTA, 15> {
+  enum { SHIFT = (DELTA * 15) % 16 };
+
+  static void Unpack(const uint16_t* __restrict in, uint16_t* __restrict out) {
+    out[15] = (*in) >> SHIFT;
+  }
+
+  static void Pack(const uint16_t* __restrict in, uint16_t* __restrict out) {
+    *out |= (in[15] << SHIFT);
+  }
+};
+
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller {
+  static void Unpack(const uint32_t* __restrict& in, uint32_t* __restrict out) {
+    unpack_single_out<DELTA, (DELTA * OINDEX) % 32>(in, out + OINDEX);
+
+    Unroller<DELTA, OINDEX + 1>::Unpack(in, out);
+  }
+
+  static void Unpack(const uint32_t* __restrict& in, uint64_t* __restrict out) {
+    unpack_single_out<DELTA, (DELTA * OINDEX) % 32>(in, out + OINDEX);
+
+    Unroller<DELTA, OINDEX + 1>::Unpack(in, out);
+  }
+
+  static void Pack(const uint32_t* __restrict in, uint32_t* __restrict out) {
+    pack_single_in<uint32_t, DELTA, (DELTA * OINDEX) % 32, (1U << DELTA) - 1>(
+        in[OINDEX], out);
+
+    Unroller<DELTA, OINDEX + 1>::Pack(in, out);
+  }
+
+  static void Pack(const uint64_t* __restrict in, uint32_t* __restrict out) {
+    pack_single_in64<DELTA, (DELTA * OINDEX) % 32, (1ULL << DELTA) - 1>(
+        in[OINDEX], out);
+
+    Unroller<DELTA, OINDEX + 1>::Pack(in, out);
+  }
+};
+
+template <uint16_t DELTA>
+struct Unroller<DELTA, 31> {
+  enum { SHIFT = (DELTA * 31) % 32 };
+
+  static void Unpack(const uint32_t* __restrict in, uint32_t* __restrict out) {
+    out[31] = (*in) >> SHIFT;
+  }
+
+  static void Unpack(const uint32_t* __restrict in, uint64_t* __restrict out) {
+    out[31] = (*in) >> SHIFT;
+    if (DELTA > 32) {
+      ++in;
+      out[31] |= static_cast<uint64_t>(*in) << (32 - SHIFT);
+    }
+  }
+
+  static void Pack(const uint32_t* __restrict in, uint32_t* __restrict out) {
+    *out |= (in[31] << SHIFT);
+  }
+
+  static void Pack(const uint64_t* __restrict in, uint32_t* __restrict out) {
+    *out |= (in[31] << SHIFT);
+    if (DELTA > 32) {
+      ++out;
+      *out = static_cast<uint32_t>(in[31] >> (32 - SHIFT));
+    }
+  }
+};
+
+// Special cases
+void __fastunpack0(const uint8_t* __restrict, uint8_t* __restrict out) {
+  for (uint8_t i = 0; i < 8; ++i)
+    *(out++) = 0;
+}
+
+void __fastunpack0(const uint16_t* __restrict, uint16_t* __restrict out) {
+  for (uint16_t i = 0; i < 16; ++i)
+    *(out++) = 0;
+}
+
+void __fastunpack0(const uint32_t* __restrict, uint32_t* __restrict out) {
+  for (uint32_t i = 0; i < 32; ++i)
+    *(out++) = 0;
+}
+
+void __fastunpack0(const uint32_t* __restrict, uint64_t* __restrict out) {
+  for (uint32_t i = 0; i < 32; ++i)
+    *(out++) = 0;
+}
+
+void __fastpack0(const uint8_t* __restrict, uint8_t* __restrict) {}
+void __fastpack0(const uint16_t* __restrict, uint16_t* __restrict) {}
+void __fastpack0(const uint32_t* __restrict, uint32_t* __restrict) {}
+void __fastpack0(const uint64_t* __restrict, uint32_t* __restrict) {}
+
+// fastunpack for 8 bits
+void __fastunpack1(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  for (uint8_t outer = 0; outer < 4; ++outer) {
+    for (uint8_t inwordpointer = 0; inwordpointer < 8; inwordpointer += 4)
+      *(out++) = ((*in) >> inwordpointer) % (1U << 4);
+    ++in;
+  }
+}
+
+void __fastunpack5(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  for (int k = 0; k < 8; ++k)
+    out[k] = in[k];
+}
+
+// fastunpack for 16 bits
+void __fastunpack1(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  for (uint16_t outer = 0; outer < 4; ++outer) {
+    for (uint16_t inwordpointer = 0; inwordpointer < 16; inwordpointer += 4)
+      *(out++) = ((*in) >> inwordpointer) % (1U << 4);
+    ++in;
+  }
+}
+
+void __fastunpack5(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  for (uint16_t outer = 0; outer < 8; ++outer) {
+    for (uint16_t inwordpointer = 0; inwordpointer < 16; inwordpointer += 8)
+      *(out++) = ((*in) >> inwordpointer) % (1U << 8);
+    ++in;
+  }
+}
+
+void __fastunpack9(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  for (int k = 0; k < 16; ++k)
+    out[k] = in[k];
+}
+
+// fastunpack for 32 bits
+void __fastunpack1(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  for (uint32_t outer = 0; outer < 4; ++outer) {
+    for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
+      *(out++) = ((*in) >> inwordpointer) % (1U << 4);
+    ++in;
+  }
+}
+
+void __fastunpack5(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  for (uint32_t outer = 0; outer < 8; ++outer) {
+    for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 8)
+      *(out++) = ((*in) >> inwordpointer) % (1U << 8);
+    ++in;
+  }
+}
+
+void __fastunpack9(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  for (uint32_t outer = 0; outer < 16; ++outer) {
+    for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
+      *(out++) = ((*in) >> inwordpointer) % (1U << 16);
+    ++in;
+  }
+}
+
+void __fastunpack17(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<17>::Unpack(in, out);
+}
+
+void __fastunpack18(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<18>::Unpack(in, out);
+}
+
+void __fastunpack19(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<19>::Unpack(in, out);
+}
+
+void __fastunpack20(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<20>::Unpack(in, out);
+}
+
+void __fastunpack21(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<21>::Unpack(in, out);
+}
+
+void __fastunpack22(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<22>::Unpack(in, out);
+}
+
+void __fastunpack23(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<23>::Unpack(in, out);
+}
+
+void __fastunpack24(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<24>::Unpack(in, out);
+}
+
+void __fastunpack25(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<25>::Unpack(in, out);
+}
+
+void __fastunpack26(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<26>::Unpack(in, out);
+}
+
+void __fastunpack27(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<27>::Unpack(in, out);
+}
+
+void __fastunpack28(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<28>::Unpack(in, out);
+}
+
+void __fastunpack29(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<29>::Unpack(in, out);
+}
+
+void __fastunpack30(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<30>::Unpack(in, out);
+}
+
+void __fastunpack31(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<31>::Unpack(in, out);
+}
+
+void __fastunpack32(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  for (int k = 0; k < 32; ++k)
+    out[k] = in[k];
+}
+
+// fastupack for 64 bits
+void __fastunpack1(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  for (uint32_t outer = 0; outer < 4; ++outer) {
+    for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
+      *(out++) = ((*in) >> inwordpointer) % (1U << 4);
+    ++in;
+  }
+}
+
+void __fastunpack5(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  for (uint32_t outer = 0; outer < 8; ++outer) {
+    for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 8) {
+      *(out++) = ((*in) >> inwordpointer) % (1U << 8);
+    }
+    ++in;
+  }
+}
+
+void __fastunpack9(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  for (uint32_t outer = 0; outer < 16; ++outer) {
+    for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
+      *(out++) = ((*in) >> inwordpointer) % (1U << 16);
+    ++in;
+  }
+}
+
+void __fastunpack17(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<17>::Unpack(in, out);
+}
+
+void __fastunpack18(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<18>::Unpack(in, out);
+}
+
+void __fastunpack19(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<19>::Unpack(in, out);
+}
+
+void __fastunpack20(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<20>::Unpack(in, out);
+}
+
+void __fastunpack21(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<21>::Unpack(in, out);
+}
+
+void __fastunpack22(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<22>::Unpack(in, out);
+}
+
+void __fastunpack23(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<23>::Unpack(in, out);
+}
+
+void __fastunpack24(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<24>::Unpack(in, out);
+}
+
+void __fastunpack25(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<25>::Unpack(in, out);
+}
+
+void __fastunpack26(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<26>::Unpack(in, out);
+}
+
+void __fastunpack27(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<27>::Unpack(in, out);
+}
+
+void __fastunpack28(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<28>::Unpack(in, out);
+}
+
+void __fastunpack29(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<29>::Unpack(in, out);
+}
+
+void __fastunpack30(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<30>::Unpack(in, out);
+}
+
+void __fastunpack31(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<31>::Unpack(in, out);
+}
+
+void __fastunpack32(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  for (int k = 0; k < 32; ++k)
+    out[k] = in[k];
+}
+
+void __fastunpack33(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<33>::Unpack(in, out);
+}
+
+void __fastunpack34(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<34>::Unpack(in, out);
+}
+
+void __fastunpack35(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<35>::Unpack(in, out);
+}
+
+void __fastunpack36(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<36>::Unpack(in, out);
+}
+
+void __fastunpack37(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<37>::Unpack(in, out);
+}
+
+void __fastunpack38(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<38>::Unpack(in, out);
+}
+
+void __fastunpack39(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<39>::Unpack(in, out);
+}
+
+void __fastunpack40(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<40>::Unpack(in, out);
+}
+
+void __fastunpack41(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<41>::Unpack(in, out);
+}
+
+void __fastunpack42(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<42>::Unpack(in, out);
+}
+
+void __fastunpack43(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<43>::Unpack(in, out);
+}
+
+void __fastunpack44(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<44>::Unpack(in, out);
+}
+
+void __fastunpack45(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<45>::Unpack(in, out);
+}
+
+void __fastunpack46(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<46>::Unpack(in, out);
+}
+
+void __fastunpack47(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<47>::Unpack(in, out);
+}
+
+void __fastunpack48(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<48>::Unpack(in, out);
+}
+
+void __fastunpack49(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<49>::Unpack(in, out);
+}
+
+void __fastunpack50(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<50>::Unpack(in, out);
+}
+
+void __fastunpack51(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<51>::Unpack(in, out);
+}
+
+void __fastunpack52(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<52>::Unpack(in, out);
+}
+
+void __fastunpack53(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<53>::Unpack(in, out);
+}
+
+void __fastunpack54(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<54>::Unpack(in, out);
+}
+
+void __fastunpack55(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<55>::Unpack(in, out);
+}
+
+void __fastunpack56(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<56>::Unpack(in, out);
+}
+
+void __fastunpack57(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<57>::Unpack(in, out);
+}
+
+void __fastunpack58(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<58>::Unpack(in, out);
+}
+
+void __fastunpack59(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<59>::Unpack(in, out);
+}
+
+void __fastunpack60(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<60>::Unpack(in, out);
+}
+
+void __fastunpack61(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<61>::Unpack(in, out);
+}
+
+void __fastunpack62(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<62>::Unpack(in, out);
+}
+
+void __fastunpack63(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  Unroller<63>::Unpack(in, out);
+}
+
+void __fastunpack64(const uint32_t* __restrict in, uint64_t* __restrict out) {
+  for (int k = 0; k < 32; ++k) {
+    out[k] = in[k * 2];
+    out[k] |= static_cast<uint64_t>(in[k * 2 + 1]) << 32;
+  }
+}
+
+// fastpack for 8 bits
+
+void __fastpack1(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  Unroller8<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint8_t* __restrict in, uint8_t* __restrict out) {
+  for (int k = 0; k < 8; ++k)
+    out[k] = in[k];
+}
+
+// fastpack for 16 bits
+
+void __fastpack1(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  Unroller16<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint16_t* __restrict in, uint16_t* __restrict out) {
+  for (int k = 0; k < 16; ++k)
+    out[k] = in[k];
+}
+
+// fastpack for 32 bits
+
+void __fastpack1(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<16>::Pack(in, out);
+}
+
+void __fastpack17(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<17>::Pack(in, out);
+}
+
+void __fastpack18(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<18>::Pack(in, out);
+}
+
+void __fastpack19(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<19>::Pack(in, out);
+}
+
+void __fastpack20(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<20>::Pack(in, out);
+}
+
+void __fastpack21(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<21>::Pack(in, out);
+}
+
+void __fastpack22(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<22>::Pack(in, out);
+}
+
+void __fastpack23(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<23>::Pack(in, out);
+}
+
+void __fastpack24(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<24>::Pack(in, out);
+}
+
+void __fastpack25(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<25>::Pack(in, out);
+}
+
+void __fastpack26(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<26>::Pack(in, out);
+}
+
+void __fastpack27(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<27>::Pack(in, out);
+}
+
+void __fastpack28(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<28>::Pack(in, out);
+}
+
+void __fastpack29(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<29>::Pack(in, out);
+}
+
+void __fastpack30(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<30>::Pack(in, out);
+}
+
+void __fastpack31(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<31>::Pack(in, out);
+}
+
+void __fastpack32(const uint32_t* __restrict in, uint32_t* __restrict out) {
+  for (int k = 0; k < 32; ++k)
+    out[k] = in[k];
+}
+
+// fastpack for 64 bits
+
+void __fastpack1(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<16>::Pack(in, out);
+}
+
+void __fastpack17(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<17>::Pack(in, out);
+}
+
+void __fastpack18(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<18>::Pack(in, out);
+}
+
+void __fastpack19(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<19>::Pack(in, out);
+}
+
+void __fastpack20(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<20>::Pack(in, out);
+}
+
+void __fastpack21(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<21>::Pack(in, out);
+}
+
+void __fastpack22(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<22>::Pack(in, out);
+}
+
+void __fastpack23(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<23>::Pack(in, out);
+}
+
+void __fastpack24(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<24>::Pack(in, out);
+}
+
+void __fastpack25(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<25>::Pack(in, out);
+}
+
+void __fastpack26(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<26>::Pack(in, out);
+}
+
+void __fastpack27(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<27>::Pack(in, out);
+}
+
+void __fastpack28(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<28>::Pack(in, out);
+}
+
+void __fastpack29(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<29>::Pack(in, out);
+}
+
+void __fastpack30(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<30>::Pack(in, out);
+}
+
+void __fastpack31(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<31>::Pack(in, out);
+}
+
+void __fastpack32(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  for (int k = 0; k < 32; ++k) {
+    out[k] = static_cast<uint32_t>(in[k]);
+  }
+}
+
+void __fastpack33(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<33>::Pack(in, out);
+}
+
+void __fastpack34(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<34>::Pack(in, out);
+}
+
+void __fastpack35(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<35>::Pack(in, out);
+}
+
+void __fastpack36(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<36>::Pack(in, out);
+}
+
+void __fastpack37(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<37>::Pack(in, out);
+}
+
+void __fastpack38(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<38>::Pack(in, out);
+}
+
+void __fastpack39(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<39>::Pack(in, out);
+}
+
+void __fastpack40(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<40>::Pack(in, out);
+}
+
+void __fastpack41(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<41>::Pack(in, out);
+}
+
+void __fastpack42(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<42>::Pack(in, out);
+}
+
+void __fastpack43(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<43>::Pack(in, out);
+}
+
+void __fastpack44(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<44>::Pack(in, out);
+}
+
+void __fastpack45(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<45>::Pack(in, out);
+}
+
+void __fastpack46(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<46>::Pack(in, out);
+}
+
+void __fastpack47(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<47>::Pack(in, out);
+}
+
+void __fastpack48(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<48>::Pack(in, out);
+}
+
+void __fastpack49(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<49>::Pack(in, out);
+}
+
+void __fastpack50(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<50>::Pack(in, out);
+}
+
+void __fastpack51(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<51>::Pack(in, out);
+}
+
+void __fastpack52(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<52>::Pack(in, out);
+}
+
+void __fastpack53(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<53>::Pack(in, out);
+}
+
+void __fastpack54(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<54>::Pack(in, out);
+}
+
+void __fastpack55(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<55>::Pack(in, out);
+}
+
+void __fastpack56(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<56>::Pack(in, out);
+}
+
+void __fastpack57(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<57>::Pack(in, out);
+}
+
+void __fastpack58(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<58>::Pack(in, out);
+}
+
+void __fastpack59(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<59>::Pack(in, out);
+}
+
+void __fastpack60(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<60>::Pack(in, out);
+}
+
+void __fastpack61(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<61>::Pack(in, out);
+}
+
+void __fastpack62(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<62>::Pack(in, out);
+}
+
+void __fastpack63(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  Unroller<63>::Pack(in, out);
+}
+
+void __fastpack64(const uint64_t* __restrict in, uint32_t* __restrict out) {
+  for (int i = 0; i < 32; ++i) {
+    out[2 * i] = static_cast<uint32_t>(in[i]);
+    out[2 * i + 1] = in[i] >> 32;
+  }
+}
+} // namespace internal
+} // namespace velox::fastpforlib
diff --git a/velox/dwio/common/tests/Lemire/FastPFor/bitpacking.h b/velox/dwio/common/tests/Lemire/FastPFor/bitpacking.h
new file mode 100644
index 0000000000000..e1675eb24712c
--- /dev/null
+++ b/velox/dwio/common/tests/Lemire/FastPFor/bitpacking.h
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+
+#pragma once
+#include <cinttypes>
+#include <string>
+
+namespace velox::fastpforlib {
+namespace internal {
+
+// Unpacks 8 uint8_t values
+void __fastunpack0(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastunpack1(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastunpack2(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastunpack3(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastunpack4(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastunpack5(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastunpack6(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastunpack7(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastunpack8(const uint8_t* __restrict in, uint8_t* __restrict out);
+
+// Unpacks 16 uint16_t values
+void __fastunpack0(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack1(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack2(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack3(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack4(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack5(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack6(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack7(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack8(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack9(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack10(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack11(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack12(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack13(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack14(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack15(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastunpack16(const uint16_t* __restrict in, uint16_t* __restrict out);
+
+// Unpacks 32 uint32_t values
+void __fastunpack0(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack1(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack2(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack3(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack4(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack5(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack6(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack7(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack8(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack9(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack10(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack11(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack12(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack13(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack14(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack15(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack16(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack17(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack18(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack19(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack20(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack21(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack22(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack23(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack24(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack25(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack26(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack27(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack28(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack29(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack30(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack31(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastunpack32(const uint32_t* __restrict in, uint32_t* __restrict out);
+
+// Unpacks 32 uint64_t values
+void __fastunpack0(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack1(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack2(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack3(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack4(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack5(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack6(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack7(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack8(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack9(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack10(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack11(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack12(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack13(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack14(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack15(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack16(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack17(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack18(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack19(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack20(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack21(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack22(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack23(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack24(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack25(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack26(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack27(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack28(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack29(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack30(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack31(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack32(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack33(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack34(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack35(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack36(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack37(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack38(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack39(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack40(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack41(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack42(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack43(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack44(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack45(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack46(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack47(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack48(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack49(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack50(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack51(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack52(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack53(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack54(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack55(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack56(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack57(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack58(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack59(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack60(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack61(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack62(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack63(const uint32_t* __restrict in, uint64_t* __restrict out);
+void __fastunpack64(const uint32_t* __restrict in, uint64_t* __restrict out);
+
+// Packs 8 int8_t values
+void __fastpack0(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastpack1(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastpack2(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastpack3(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastpack4(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastpack5(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastpack6(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastpack7(const uint8_t* __restrict in, uint8_t* __restrict out);
+void __fastpack8(const uint8_t* __restrict in, uint8_t* __restrict out);
+
+// Packs 16 int16_t values
+void __fastpack0(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack1(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack2(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack3(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack4(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack5(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack6(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack7(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack8(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack9(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack10(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack11(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack12(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack13(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack14(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack15(const uint16_t* __restrict in, uint16_t* __restrict out);
+void __fastpack16(const uint16_t* __restrict in, uint16_t* __restrict out);
+
+// Packs 32 int32_t values
+void __fastpack0(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack1(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack2(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack3(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack4(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack5(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack6(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack7(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack8(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack9(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack10(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack11(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack12(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack13(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack14(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack15(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack16(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack17(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack18(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack19(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack20(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack21(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack22(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack23(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack24(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack25(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack26(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack27(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack28(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack29(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack30(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack31(const uint32_t* __restrict in, uint32_t* __restrict out);
+void __fastpack32(const uint32_t* __restrict in, uint32_t* __restrict out);
+
+// Packs 32 int64_t values
+void __fastpack0(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack1(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack2(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack3(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack4(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack5(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack6(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack7(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack8(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack9(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack10(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack11(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack12(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack13(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack14(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack15(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack16(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack17(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack18(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack19(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack20(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack21(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack22(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack23(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack24(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack25(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack26(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack27(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack28(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack29(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack30(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack31(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack32(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack33(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack34(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack35(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack36(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack37(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack38(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack39(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack40(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack41(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack42(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack43(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack44(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack45(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack46(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack47(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack48(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack49(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack50(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack51(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack52(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack53(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack54(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack55(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack56(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack57(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack58(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack59(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack60(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack61(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack62(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack63(const uint64_t* __restrict in, uint32_t* __restrict out);
+void __fastpack64(const uint64_t* __restrict in, uint32_t* __restrict out);
+} // namespace internal
+} // namespace velox::fastpforlib
diff --git a/velox/dwio/common/tests/Lemire/FastPFor/bitpackinghelpers.h b/velox/dwio/common/tests/Lemire/FastPFor/bitpackinghelpers.h
new file mode 100644
index 0000000000000..f49f7bc563db7
--- /dev/null
+++ b/velox/dwio/common/tests/Lemire/FastPFor/bitpackinghelpers.h
@@ -0,0 +1,900 @@
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://lemire.me/en/
+ */
+
+#pragma once
+#include "bitpacking.h"
+
+#include <stdexcept>
+
+namespace velox::fastpforlib {
+
+namespace internal {
+
+// Note that this only packs 8 values
+inline void fastunpack_quarter(
+    const uint8_t* __restrict in,
+    uint8_t* __restrict out,
+    const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+    case 0:
+      internal::__fastunpack0(in, out);
+      break;
+    case 1:
+      internal::__fastunpack1(in, out);
+      break;
+    case 2:
+      internal::__fastunpack2(in, out);
+      break;
+    case 3:
+      internal::__fastunpack3(in, out);
+      break;
+    case 4:
+      internal::__fastunpack4(in, out);
+      break;
+    case 5:
+      internal::__fastunpack5(in, out);
+      break;
+    case 6:
+      internal::__fastunpack6(in, out);
+      break;
+    case 7:
+      internal::__fastunpack7(in, out);
+      break;
+    case 8:
+      internal::__fastunpack8(in, out);
+      break;
+    default:
+      throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+// Note that this only packs 8 values
+inline void fastpack_quarter(
+    const uint8_t* __restrict in,
+    uint8_t* __restrict out,
+    const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+    case 0:
+      internal::__fastpack0(in, out);
+      break;
+    case 1:
+      internal::__fastpack1(in, out);
+      break;
+    case 2:
+      internal::__fastpack2(in, out);
+      break;
+    case 3:
+      internal::__fastpack3(in, out);
+      break;
+    case 4:
+      internal::__fastpack4(in, out);
+      break;
+    case 5:
+      internal::__fastpack5(in, out);
+      break;
+    case 6:
+      internal::__fastpack6(in, out);
+      break;
+    case 7:
+      internal::__fastpack7(in, out);
+      break;
+    case 8:
+      internal::__fastpack8(in, out);
+      break;
+    default:
+      throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+// Note that this only packs 16 values
+inline void fastunpack_half(
+    const uint16_t* __restrict in,
+    uint16_t* __restrict out,
+    const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+    case 0:
+      internal::__fastunpack0(in, out);
+      break;
+    case 1:
+      internal::__fastunpack1(in, out);
+      break;
+    case 2:
+      internal::__fastunpack2(in, out);
+      break;
+    case 3:
+      internal::__fastunpack3(in, out);
+      break;
+    case 4:
+      internal::__fastunpack4(in, out);
+      break;
+    case 5:
+      internal::__fastunpack5(in, out);
+      break;
+    case 6:
+      internal::__fastunpack6(in, out);
+      break;
+    case 7:
+      internal::__fastunpack7(in, out);
+      break;
+    case 8:
+      internal::__fastunpack8(in, out);
+      break;
+    case 9:
+      internal::__fastunpack9(in, out);
+      break;
+    case 10:
+      internal::__fastunpack10(in, out);
+      break;
+    case 11:
+      internal::__fastunpack11(in, out);
+      break;
+    case 12:
+      internal::__fastunpack12(in, out);
+      break;
+    case 13:
+      internal::__fastunpack13(in, out);
+      break;
+    case 14:
+      internal::__fastunpack14(in, out);
+      break;
+    case 15:
+      internal::__fastunpack15(in, out);
+      break;
+    case 16:
+      internal::__fastunpack16(in, out);
+      break;
+    default:
+      throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+// Note that this only packs 16 values
+inline void fastpack_half(
+    const uint16_t* __restrict in,
+    uint16_t* __restrict out,
+    const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+    case 0:
+      internal::__fastpack0(in, out);
+      break;
+    case 1:
+      internal::__fastpack1(in, out);
+      break;
+    case 2:
+      internal::__fastpack2(in, out);
+      break;
+    case 3:
+      internal::__fastpack3(in, out);
+      break;
+    case 4:
+      internal::__fastpack4(in, out);
+      break;
+    case 5:
+      internal::__fastpack5(in, out);
+      break;
+    case 6:
+      internal::__fastpack6(in, out);
+      break;
+    case 7:
+      internal::__fastpack7(in, out);
+      break;
+    case 8:
+      internal::__fastpack8(in, out);
+      break;
+    case 9:
+      internal::__fastpack9(in, out);
+      break;
+    case 10:
+      internal::__fastpack10(in, out);
+      break;
+    case 11:
+      internal::__fastpack11(in, out);
+      break;
+    case 12:
+      internal::__fastpack12(in, out);
+      break;
+    case 13:
+      internal::__fastpack13(in, out);
+      break;
+    case 14:
+      internal::__fastpack14(in, out);
+      break;
+    case 15:
+      internal::__fastpack15(in, out);
+      break;
+    case 16:
+      internal::__fastpack16(in, out);
+      break;
+    default:
+      throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+} // namespace internal
+
+inline void fastunpack(
+    const uint8_t* __restrict in,
+    uint8_t* __restrict out,
+    const uint32_t bit) {
+  for (uint8_t i = 0; i < 4; i++) {
+    internal::fastunpack_quarter(in + (i * bit), out + (i * 8), bit);
+  }
+}
+
+inline void fastunpack(
+    const uint16_t* __restrict in,
+    uint16_t* __restrict out,
+    const uint32_t bit) {
+  internal::fastunpack_half(in, out, bit);
+  internal::fastunpack_half(in + bit, out + 16, bit);
+}
+
+inline void fastunpack(
+    const uint32_t* __restrict in,
+    uint32_t* __restrict out,
+    const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+    case 0:
+      internal::__fastunpack0(in, out);
+      break;
+    case 1:
+      internal::__fastunpack1(in, out);
+      break;
+    case 2:
+      internal::__fastunpack2(in, out);
+      break;
+    case 3:
+      internal::__fastunpack3(in, out);
+      break;
+    case 4:
+      internal::__fastunpack4(in, out);
+      break;
+    case 5:
+      internal::__fastunpack5(in, out);
+      break;
+    case 6:
+      internal::__fastunpack6(in, out);
+      break;
+    case 7:
+      internal::__fastunpack7(in, out);
+      break;
+    case 8:
+      internal::__fastunpack8(in, out);
+      break;
+    case 9:
+      internal::__fastunpack9(in, out);
+      break;
+    case 10:
+      internal::__fastunpack10(in, out);
+      break;
+    case 11:
+      internal::__fastunpack11(in, out);
+      break;
+    case 12:
+      internal::__fastunpack12(in, out);
+      break;
+    case 13:
+      internal::__fastunpack13(in, out);
+      break;
+    case 14:
+      internal::__fastunpack14(in, out);
+      break;
+    case 15:
+      internal::__fastunpack15(in, out);
+      break;
+    case 16:
+      internal::__fastunpack16(in, out);
+      break;
+    case 17:
+      internal::__fastunpack17(in, out);
+      break;
+    case 18:
+      internal::__fastunpack18(in, out);
+      break;
+    case 19:
+      internal::__fastunpack19(in, out);
+      break;
+    case 20:
+      internal::__fastunpack20(in, out);
+      break;
+    case 21:
+      internal::__fastunpack21(in, out);
+      break;
+    case 22:
+      internal::__fastunpack22(in, out);
+      break;
+    case 23:
+      internal::__fastunpack23(in, out);
+      break;
+    case 24:
+      internal::__fastunpack24(in, out);
+      break;
+    case 25:
+      internal::__fastunpack25(in, out);
+      break;
+    case 26:
+      internal::__fastunpack26(in, out);
+      break;
+    case 27:
+      internal::__fastunpack27(in, out);
+      break;
+    case 28:
+      internal::__fastunpack28(in, out);
+      break;
+    case 29:
+      internal::__fastunpack29(in, out);
+      break;
+    case 30:
+      internal::__fastunpack30(in, out);
+      break;
+    case 31:
+      internal::__fastunpack31(in, out);
+      break;
+    case 32:
+      internal::__fastunpack32(in, out);
+      break;
+    default:
+      throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+inline void fastunpack(
+    const uint32_t* __restrict in,
+    uint64_t* __restrict out,
+    const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+    case 0:
+      internal::__fastunpack0(in, out);
+      break;
+    case 1:
+      internal::__fastunpack1(in, out);
+      break;
+    case 2:
+      internal::__fastunpack2(in, out);
+      break;
+    case 3:
+      internal::__fastunpack3(in, out);
+      break;
+    case 4:
+      internal::__fastunpack4(in, out);
+      break;
+    case 5:
+      internal::__fastunpack5(in, out);
+      break;
+    case 6:
+      internal::__fastunpack6(in, out);
+      break;
+    case 7:
+      internal::__fastunpack7(in, out);
+      break;
+    case 8:
+      internal::__fastunpack8(in, out);
+      break;
+    case 9:
+      internal::__fastunpack9(in, out);
+      break;
+    case 10:
+      internal::__fastunpack10(in, out);
+      break;
+    case 11:
+      internal::__fastunpack11(in, out);
+      break;
+    case 12:
+      internal::__fastunpack12(in, out);
+      break;
+    case 13:
+      internal::__fastunpack13(in, out);
+      break;
+    case 14:
+      internal::__fastunpack14(in, out);
+      break;
+    case 15:
+      internal::__fastunpack15(in, out);
+      break;
+    case 16:
+      internal::__fastunpack16(in, out);
+      break;
+    case 17:
+      internal::__fastunpack17(in, out);
+      break;
+    case 18:
+      internal::__fastunpack18(in, out);
+      break;
+    case 19:
+      internal::__fastunpack19(in, out);
+      break;
+    case 20:
+      internal::__fastunpack20(in, out);
+      break;
+    case 21:
+      internal::__fastunpack21(in, out);
+      break;
+    case 22:
+      internal::__fastunpack22(in, out);
+      break;
+    case 23:
+      internal::__fastunpack23(in, out);
+      break;
+    case 24:
+      internal::__fastunpack24(in, out);
+      break;
+    case 25:
+      internal::__fastunpack25(in, out);
+      break;
+    case 26:
+      internal::__fastunpack26(in, out);
+      break;
+    case 27:
+      internal::__fastunpack27(in, out);
+      break;
+    case 28:
+      internal::__fastunpack28(in, out);
+      break;
+    case 29:
+      internal::__fastunpack29(in, out);
+      break;
+    case 30:
+      internal::__fastunpack30(in, out);
+      break;
+    case 31:
+      internal::__fastunpack31(in, out);
+      break;
+    case 32:
+      internal::__fastunpack32(in, out);
+      break;
+    case 33:
+      internal::__fastunpack33(in, out);
+      break;
+    case 34:
+      internal::__fastunpack34(in, out);
+      break;
+    case 35:
+      internal::__fastunpack35(in, out);
+      break;
+    case 36:
+      internal::__fastunpack36(in, out);
+      break;
+    case 37:
+      internal::__fastunpack37(in, out);
+      break;
+    case 38:
+      internal::__fastunpack38(in, out);
+      break;
+    case 39:
+      internal::__fastunpack39(in, out);
+      break;
+    case 40:
+      internal::__fastunpack40(in, out);
+      break;
+    case 41:
+      internal::__fastunpack41(in, out);
+      break;
+    case 42:
+      internal::__fastunpack42(in, out);
+      break;
+    case 43:
+      internal::__fastunpack43(in, out);
+      break;
+    case 44:
+      internal::__fastunpack44(in, out);
+      break;
+    case 45:
+      internal::__fastunpack45(in, out);
+      break;
+    case 46:
+      internal::__fastunpack46(in, out);
+      break;
+    case 47:
+      internal::__fastunpack47(in, out);
+      break;
+    case 48:
+      internal::__fastunpack48(in, out);
+      break;
+    case 49:
+      internal::__fastunpack49(in, out);
+      break;
+    case 50:
+      internal::__fastunpack50(in, out);
+      break;
+    case 51:
+      internal::__fastunpack51(in, out);
+      break;
+    case 52:
+      internal::__fastunpack52(in, out);
+      break;
+    case 53:
+      internal::__fastunpack53(in, out);
+      break;
+    case 54:
+      internal::__fastunpack54(in, out);
+      break;
+    case 55:
+      internal::__fastunpack55(in, out);
+      break;
+    case 56:
+      internal::__fastunpack56(in, out);
+      break;
+    case 57:
+      internal::__fastunpack57(in, out);
+      break;
+    case 58:
+      internal::__fastunpack58(in, out);
+      break;
+    case 59:
+      internal::__fastunpack59(in, out);
+      break;
+    case 60:
+      internal::__fastunpack60(in, out);
+      break;
+    case 61:
+      internal::__fastunpack61(in, out);
+      break;
+    case 62:
+      internal::__fastunpack62(in, out);
+      break;
+    case 63:
+      internal::__fastunpack63(in, out);
+      break;
+    case 64:
+      internal::__fastunpack64(in, out);
+      break;
+    default:
+      throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+inline void fastpack(
+    const uint8_t* __restrict in,
+    uint8_t* __restrict out,
+    const uint32_t bit) {
+  for (uint8_t i = 0; i < 4; i++) {
+    internal::fastpack_quarter(in + (i * 8), out + (i * bit), bit);
+  }
+}
+
+inline void fastpack(
+    const uint16_t* __restrict in,
+    uint16_t* __restrict out,
+    const uint32_t bit) {
+  internal::fastpack_half(in, out, bit);
+  internal::fastpack_half(in + 16, out + bit, bit);
+}
+
+inline void fastpack(
+    const uint32_t* __restrict in,
+    uint32_t* __restrict out,
+    const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+    case 0:
+      internal::__fastpack0(in, out);
+      break;
+    case 1:
+      internal::__fastpack1(in, out);
+      break;
+    case 2:
+      internal::__fastpack2(in, out);
+      break;
+    case 3:
+      internal::__fastpack3(in, out);
+      break;
+    case 4:
+      internal::__fastpack4(in, out);
+      break;
+    case 5:
+      internal::__fastpack5(in, out);
+      break;
+    case 6:
+      internal::__fastpack6(in, out);
+      break;
+    case 7:
+      internal::__fastpack7(in, out);
+      break;
+    case 8:
+      internal::__fastpack8(in, out);
+      break;
+    case 9:
+      internal::__fastpack9(in, out);
+      break;
+    case 10:
+      internal::__fastpack10(in, out);
+      break;
+    case 11:
+      internal::__fastpack11(in, out);
+      break;
+    case 12:
+      internal::__fastpack12(in, out);
+      break;
+    case 13:
+      internal::__fastpack13(in, out);
+      break;
+    case 14:
+      internal::__fastpack14(in, out);
+      break;
+    case 15:
+      internal::__fastpack15(in, out);
+      break;
+    case 16:
+      internal::__fastpack16(in, out);
+      break;
+    case 17:
+      internal::__fastpack17(in, out);
+      break;
+    case 18:
+      internal::__fastpack18(in, out);
+      break;
+    case 19:
+      internal::__fastpack19(in, out);
+      break;
+    case 20:
+      internal::__fastpack20(in, out);
+      break;
+    case 21:
+      internal::__fastpack21(in, out);
+      break;
+    case 22:
+      internal::__fastpack22(in, out);
+      break;
+    case 23:
+      internal::__fastpack23(in, out);
+      break;
+    case 24:
+      internal::__fastpack24(in, out);
+      break;
+    case 25:
+      internal::__fastpack25(in, out);
+      break;
+    case 26:
+      internal::__fastpack26(in, out);
+      break;
+    case 27:
+      internal::__fastpack27(in, out);
+      break;
+    case 28:
+      internal::__fastpack28(in, out);
+      break;
+    case 29:
+      internal::__fastpack29(in, out);
+      break;
+    case 30:
+      internal::__fastpack30(in, out);
+      break;
+    case 31:
+      internal::__fastpack31(in, out);
+      break;
+    case 32:
+      internal::__fastpack32(in, out);
+      break;
+    default:
+      throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+inline void fastpack(
+    const uint64_t* __restrict in,
+    uint32_t* __restrict out,
+    const uint32_t bit) {
+  switch (bit) {
+    case 0:
+      internal::__fastpack0(in, out);
+      break;
+    case 1:
+      internal::__fastpack1(in, out);
+      break;
+    case 2:
+      internal::__fastpack2(in, out);
+      break;
+    case 3:
+      internal::__fastpack3(in, out);
+      break;
+    case 4:
+      internal::__fastpack4(in, out);
+      break;
+    case 5:
+      internal::__fastpack5(in, out);
+      break;
+    case 6:
+      internal::__fastpack6(in, out);
+      break;
+    case 7:
+      internal::__fastpack7(in, out);
+      break;
+    case 8:
+      internal::__fastpack8(in, out);
+      break;
+    case 9:
+      internal::__fastpack9(in, out);
+      break;
+    case 10:
+      internal::__fastpack10(in, out);
+      break;
+    case 11:
+      internal::__fastpack11(in, out);
+      break;
+    case 12:
+      internal::__fastpack12(in, out);
+      break;
+    case 13:
+      internal::__fastpack13(in, out);
+      break;
+    case 14:
+      internal::__fastpack14(in, out);
+      break;
+    case 15:
+      internal::__fastpack15(in, out);
+      break;
+    case 16:
+      internal::__fastpack16(in, out);
+      break;
+    case 17:
+      internal::__fastpack17(in, out);
+      break;
+    case 18:
+      internal::__fastpack18(in, out);
+      break;
+    case 19:
+      internal::__fastpack19(in, out);
+      break;
+    case 20:
+      internal::__fastpack20(in, out);
+      break;
+    case 21:
+      internal::__fastpack21(in, out);
+      break;
+    case 22:
+      internal::__fastpack22(in, out);
+      break;
+    case 23:
+      internal::__fastpack23(in, out);
+      break;
+    case 24:
+      internal::__fastpack24(in, out);
+      break;
+    case 25:
+      internal::__fastpack25(in, out);
+      break;
+    case 26:
+      internal::__fastpack26(in, out);
+      break;
+    case 27:
+      internal::__fastpack27(in, out);
+      break;
+    case 28:
+      internal::__fastpack28(in, out);
+      break;
+    case 29:
+      internal::__fastpack29(in, out);
+      break;
+    case 30:
+      internal::__fastpack30(in, out);
+      break;
+    case 31:
+      internal::__fastpack31(in, out);
+      break;
+    case 32:
+      internal::__fastpack32(in, out);
+      break;
+    case 33:
+      internal::__fastpack33(in, out);
+      break;
+    case 34:
+      internal::__fastpack34(in, out);
+      break;
+    case 35:
+      internal::__fastpack35(in, out);
+      break;
+    case 36:
+      internal::__fastpack36(in, out);
+      break;
+    case 37:
+      internal::__fastpack37(in, out);
+      break;
+    case 38:
+      internal::__fastpack38(in, out);
+      break;
+    case 39:
+      internal::__fastpack39(in, out);
+      break;
+    case 40:
+      internal::__fastpack40(in, out);
+      break;
+    case 41:
+      internal::__fastpack41(in, out);
+      break;
+    case 42:
+      internal::__fastpack42(in, out);
+      break;
+    case 43:
+      internal::__fastpack43(in, out);
+      break;
+    case 44:
+      internal::__fastpack44(in, out);
+      break;
+    case 45:
+      internal::__fastpack45(in, out);
+      break;
+    case 46:
+      internal::__fastpack46(in, out);
+      break;
+    case 47:
+      internal::__fastpack47(in, out);
+      break;
+    case 48:
+      internal::__fastpack48(in, out);
+      break;
+    case 49:
+      internal::__fastpack49(in, out);
+      break;
+    case 50:
+      internal::__fastpack50(in, out);
+      break;
+    case 51:
+      internal::__fastpack51(in, out);
+      break;
+    case 52:
+      internal::__fastpack52(in, out);
+      break;
+    case 53:
+      internal::__fastpack53(in, out);
+      break;
+    case 54:
+      internal::__fastpack54(in, out);
+      break;
+    case 55:
+      internal::__fastpack55(in, out);
+      break;
+    case 56:
+      internal::__fastpack56(in, out);
+      break;
+    case 57:
+      internal::__fastpack57(in, out);
+      break;
+    case 58:
+      internal::__fastpack58(in, out);
+      break;
+    case 59:
+      internal::__fastpack59(in, out);
+      break;
+    case 60:
+      internal::__fastpack60(in, out);
+      break;
+    case 61:
+      internal::__fastpack61(in, out);
+      break;
+    case 62:
+      internal::__fastpack62(in, out);
+      break;
+    case 63:
+      internal::__fastpack63(in, out);
+      break;
+    case 64:
+      internal::__fastpack64(in, out);
+      break;
+    default:
+      throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+} // namespace velox::fastpforlib
diff --git a/velox/dwio/common/tests/LocalFileSinkTest.cpp b/velox/dwio/common/tests/LocalFileSinkTest.cpp
index 641dfe62b3bae..17ac1869474fb 100644
--- a/velox/dwio/common/tests/LocalFileSinkTest.cpp
+++ b/velox/dwio/common/tests/LocalFileSinkTest.cpp
@@ -26,26 +26,35 @@ using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::dwio::common {
 
-void runTest() {
-  auto root = TempDirectoryPath::create();
-  auto filePath = fs::path(root->path) / "xxx/yyy/zzz/test_file.ext";
+class LocalFileSinkTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
 
-  ASSERT_FALSE(fs::exists(filePath.string()));
+  void runTest() {
+    auto root = TempDirectoryPath::create();
+    auto filePath = fs::path(root->getPath()) / "xxx/yyy/zzz/test_file.ext";
 
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  auto localFileSink = FileSink::create(
-      fmt::format("file:{}", filePath.string()), {.pool = pool.get()});
-  ASSERT_TRUE(localFileSink->isBuffered());
-  localFileSink->close();
+    ASSERT_FALSE(fs::exists(filePath.string()));
 
-  EXPECT_TRUE(fs::exists(filePath.string()));
-}
+    auto localFileSink = FileSink::create(
+        fmt::format("file:{}", filePath.string()), {.pool = pool_.get()});
+    ASSERT_TRUE(localFileSink->isBuffered());
+    localFileSink->close();
+
+    EXPECT_TRUE(fs::exists(filePath.string()));
+  }
+
+  std::shared_ptr<velox::memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+};
 
-TEST(LocalFileSinkTest, missingRegistration) {
+TEST_F(LocalFileSinkTest, missingRegistration) {
   VELOX_ASSERT_THROW(runTest(), "FileSink is not registered for file:");
 }
 
-TEST(LocalFileSinkTest, create) {
+TEST_F(LocalFileSinkTest, create) {
   LocalFileSink::registerFactory();
   runTest();
 }
diff --git a/velox/dwio/common/tests/MeasureTimeTests.cpp b/velox/dwio/common/tests/MeasureTimeTests.cpp
new file mode 100644
index 0000000000000..a3749df4bd6e8
--- /dev/null
+++ b/velox/dwio/common/tests/MeasureTimeTests.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/dwio/common/MeasureTime.h"
+
+using namespace ::testing;
+using namespace ::facebook::velox::dwio::common;
+
+TEST(MeasureTimeTests, DoesntCreateMeasureIfNoCallback) {
+  EXPECT_FALSE(measureTimeIfCallback(nullptr).has_value());
+}
+
+TEST(MeasureTimeTests, CreatesMeasureIfCallback) {
+  auto callback =
+      std::function<void(std::chrono::high_resolution_clock::duration)>(
+          [](const auto&) {});
+  EXPECT_TRUE(measureTimeIfCallback(callback).has_value());
+}
+
+TEST(MeasureTimeTests, MeasuresTime) {
+  bool measured{false};
+  {
+    auto callback =
+        std::function<void(std::chrono::high_resolution_clock::duration)>(
+            [&measured](const auto&) { measured = true; });
+    auto measure = measureTimeIfCallback(callback);
+    EXPECT_TRUE(measure.has_value());
+    EXPECT_FALSE(measured);
+  }
+  EXPECT_TRUE(measured);
+}
diff --git a/velox/dwio/common/tests/MemorySinkTest.cpp b/velox/dwio/common/tests/MemorySinkTest.cpp
new file mode 100644
index 0000000000000..4f348811d938e
--- /dev/null
+++ b/velox/dwio/common/tests/MemorySinkTest.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/FileSink.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::dwio::common {
+
+class MemorySinkTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<velox::memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+};
+
+TEST_F(MemorySinkTest, create) {
+  std::string chars("abcdefghijklmnopqrst");
+  std::vector<DataBuffer<char>> buffers;
+
+  // Add 'abcdefghij' to first buffer
+  buffers.emplace_back(*pool_);
+  buffers.back().append(0, chars.data(), 10);
+
+  // Add 'klmnopqrst' to second buffer
+  buffers.emplace_back(*pool_);
+  buffers.back().append(0, chars.data() + 10, 10);
+
+  ASSERT_EQ(buffers.size(), 2);
+
+  auto memorySink = std::make_unique<MemorySink>(
+      1024, dwio::common::FileSink::Options{.pool = pool_.get()});
+
+  ASSERT_TRUE(memorySink->isBuffered());
+  // Write data to MemorySink.
+  memorySink->write(buffers);
+  ASSERT_EQ(memorySink->size(), chars.length());
+  ASSERT_EQ(memorySink->data(), chars);
+  memorySink->close();
+}
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp b/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp
new file mode 100644
index 0000000000000..50ac96c623d05
--- /dev/null
+++ b/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "velox/dwio/common/OnDemandUnitLoader.h"
+#include "velox/dwio/common/UnitLoaderTools.h"
+#include "velox/dwio/common/tests/utils/UnitLoaderTestTools.h"
+
+using namespace ::testing;
+using facebook::velox::dwio::common::LoadUnit;
+using facebook::velox::dwio::common::OnDemandUnitLoaderFactory;
+using facebook::velox::dwio::common::UnitLoader;
+using facebook::velox::dwio::common::UnitLoaderFactory;
+using facebook::velox::dwio::common::test::getUnitsLoadedWithFalse;
+using facebook::velox::dwio::common::test::LoadUnitMock;
+using facebook::velox::dwio::common::test::ReaderMock;
+
+TEST(OnDemandUnitLoaderTests, LoadsCorrectlyWithReader) {
+  size_t blockedOnIoCount = 0;
+  OnDemandUnitLoaderFactory factory([&](auto) { ++blockedOnIoCount; });
+  ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, false}));
+  EXPECT_EQ(blockedOnIoCount, 0);
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 0-2, load(0)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
+  EXPECT_EQ(blockedOnIoCount, 1);
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 3-5
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
+  EXPECT_EQ(blockedOnIoCount, 1);
+
+  EXPECT_TRUE(readerMock.read(4)); // Unit: 0, rows: 6-9
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
+  EXPECT_EQ(blockedOnIoCount, 1);
+
+  EXPECT_TRUE(readerMock.read(14)); // Unit: 1, rows: 0-13, unload(0), load(1)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, true, false}));
+  EXPECT_EQ(blockedOnIoCount, 2);
+
+  // will only read 5 rows, no more rows in unit 1
+  EXPECT_TRUE(readerMock.read(10)); // Unit: 1, rows: 14-19
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, true, false}));
+  EXPECT_EQ(blockedOnIoCount, 2);
+
+  EXPECT_TRUE(readerMock.read(30)); // Unit: 2, rows: 0-29, unload(1), load(2)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, true}));
+  EXPECT_EQ(blockedOnIoCount, 3);
+
+  EXPECT_FALSE(readerMock.read(30)); // No more data
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, true}));
+  EXPECT_EQ(blockedOnIoCount, 3);
+}
+
+TEST(OnDemandUnitLoaderTests, LoadsCorrectlyWithNoCallback) {
+  OnDemandUnitLoaderFactory factory(nullptr);
+  ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, false}));
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 0-2, load(0)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 3-5
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
+
+  EXPECT_TRUE(readerMock.read(4)); // Unit: 0, rows: 6-9
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
+
+  EXPECT_TRUE(readerMock.read(14)); // Unit: 1, rows: 0-13, unload(2), load(1)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, true, false}));
+
+  // will only read 5 rows, no more rows in unit 1
+  EXPECT_TRUE(readerMock.read(10)); // Unit: 1, rows: 14-19
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, true, false}));
+
+  EXPECT_TRUE(readerMock.read(30)); // Unit: 2, rows: 0-29, unload(1), load(2)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, true}));
+
+  EXPECT_FALSE(readerMock.read(30)); // No more data
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, true}));
+}
+
+TEST(OnDemandUnitLoaderTests, CanSeek) {
+  size_t blockedOnIoCount = 0;
+  OnDemandUnitLoaderFactory factory([&](auto) { ++blockedOnIoCount; });
+  ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, false}));
+  EXPECT_EQ(blockedOnIoCount, 0);
+
+  EXPECT_NO_THROW(readerMock.seek(10););
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 1, rows: 0-2, load(1)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, true, false}));
+  EXPECT_EQ(blockedOnIoCount, 1);
+
+  EXPECT_NO_THROW(readerMock.seek(0););
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 0-2, load(0), unload(1)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
+  EXPECT_EQ(blockedOnIoCount, 2);
+
+  EXPECT_NO_THROW(readerMock.seek(30););
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 2, rows: 0-2, load(2), unload(0)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, true}));
+  EXPECT_EQ(blockedOnIoCount, 3);
+
+  EXPECT_NO_THROW(readerMock.seek(5););
+
+  EXPECT_TRUE(readerMock.read(5)); // Unit: 0, rows: 5-9, load(0), unload(1)
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, false, false}));
+  EXPECT_EQ(blockedOnIoCount, 4);
+}
+
+TEST(OnDemandUnitLoaderTests, SeekOutOfRangeReaderError) {
+  size_t blockedOnIoCount = 0;
+  OnDemandUnitLoaderFactory factory([&](auto) { ++blockedOnIoCount; });
+  ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, false, false}));
+  EXPECT_EQ(blockedOnIoCount, 0);
+  readerMock.seek(59);
+
+  readerMock.seek(60);
+
+  EXPECT_THAT(
+      [&]() { readerMock.seek(61); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr("Can't seek to possition 61 in file. Must be up to 60."))));
+}
+
+TEST(OnDemandUnitLoaderTests, SeekOutOfRange) {
+  OnDemandUnitLoaderFactory factory(nullptr);
+  std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
+  std::vector<std::unique_ptr<LoadUnit>> units;
+  units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
+
+  auto unitLoader = factory.create(std::move(units), 0);
+
+  unitLoader->onSeek(0, 10);
+
+  EXPECT_THAT(
+      [&]() { unitLoader->onSeek(0, 11); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr("Row out of range"))));
+}
+
+TEST(OnDemandUnitLoaderTests, UnitOutOfRange) {
+  OnDemandUnitLoaderFactory factory(nullptr);
+  std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
+  std::vector<std::unique_ptr<LoadUnit>> units;
+  units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
+
+  auto unitLoader = factory.create(std::move(units), 0);
+  unitLoader->getLoadedUnit(0);
+  EXPECT_THAT(
+      [&]() { unitLoader->getLoadedUnit(1); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr("Unit out of range"))));
+}
+
+TEST(OnDemandUnitLoaderTests, CanRequestUnitMultipleTimes) {
+  OnDemandUnitLoaderFactory factory(nullptr);
+  std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
+  std::vector<std::unique_ptr<LoadUnit>> units;
+  units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
+
+  auto unitLoader = factory.create(std::move(units), 0);
+  unitLoader->getLoadedUnit(0);
+  unitLoader->getLoadedUnit(0);
+  unitLoader->getLoadedUnit(0);
+}
+
+TEST(OnDemandUnitLoaderTests, InitialSkip) {
+  auto getFactoryWithSkip = [](uint64_t skipToRow) {
+    auto factory = std::make_unique<OnDemandUnitLoaderFactory>(nullptr);
+    std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(1));
+    std::vector<std::unique_ptr<LoadUnit>> units;
+    units.push_back(std::make_unique<LoadUnitMock>(10, 0, unitsLoaded, 0));
+    units.push_back(std::make_unique<LoadUnitMock>(20, 0, unitsLoaded, 1));
+    units.push_back(std::make_unique<LoadUnitMock>(30, 0, unitsLoaded, 2));
+    factory->create(std::move(units), skipToRow);
+  };
+
+  EXPECT_NO_THROW(getFactoryWithSkip(0));
+  EXPECT_NO_THROW(getFactoryWithSkip(1));
+  EXPECT_NO_THROW(getFactoryWithSkip(9));
+  EXPECT_NO_THROW(getFactoryWithSkip(10));
+  EXPECT_NO_THROW(getFactoryWithSkip(11));
+  EXPECT_NO_THROW(getFactoryWithSkip(29));
+  EXPECT_NO_THROW(getFactoryWithSkip(30));
+  EXPECT_NO_THROW(getFactoryWithSkip(31));
+  EXPECT_NO_THROW(getFactoryWithSkip(59));
+  EXPECT_NO_THROW(getFactoryWithSkip(60));
+  EXPECT_THAT(
+      [&]() { getFactoryWithSkip(61); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr("Can only skip up to the past-the-end row of the file."))));
+  EXPECT_THAT(
+      [&]() { getFactoryWithSkip(100); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr("Can only skip up to the past-the-end row of the file."))));
+}
+
+TEST(OnDemandUnitLoaderTests, NoUnitButSkip) {
+  OnDemandUnitLoaderFactory factory(nullptr);
+  std::vector<std::unique_ptr<LoadUnit>> units;
+
+  EXPECT_NO_THROW(factory.create(std::move(units), 0));
+
+  std::vector<std::unique_ptr<LoadUnit>> units2;
+  EXPECT_THAT(
+      [&]() { factory.create(std::move(units2), 1); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr("Can only skip up to the past-the-end row of the file."))));
+}
diff --git a/velox/dwio/common/tests/OptionsTests.cpp b/velox/dwio/common/tests/OptionsTests.cpp
index f46834cb91457..4492a62420d0a 100644
--- a/velox/dwio/common/tests/OptionsTests.cpp
+++ b/velox/dwio/common/tests/OptionsTests.cpp
@@ -19,24 +19,37 @@
 using namespace ::testing;
 using namespace facebook::velox::dwio::common;
 
-TEST(OptionsTests, defaultAppendRowNumberColumnTest) {
+TEST(OptionsTests, defaultRowNumberColumnInfoTest) {
   // appendRowNumberColumn flag should be false by default
   RowReaderOptions rowReaderOptions;
-  ASSERT_EQ(false, rowReaderOptions.getAppendRowNumberColumn());
+  ASSERT_EQ(std::nullopt, rowReaderOptions.rowNumberColumnInfo());
 }
 
-TEST(OptionsTests, setAppendRowNumberColumnToTrueTest) {
+TEST(OptionsTests, setRowNumberColumnInfoTest) {
   RowReaderOptions rowReaderOptions;
-  rowReaderOptions.setAppendRowNumberColumn(true);
-  ASSERT_EQ(true, rowReaderOptions.getAppendRowNumberColumn());
+  RowNumberColumnInfo rowNumberColumnInfo;
+  rowNumberColumnInfo.insertPosition = 0;
+  rowNumberColumnInfo.name = "test";
+  rowNumberColumnInfo.isExplicit = true;
+  rowReaderOptions.setRowNumberColumnInfo(rowNumberColumnInfo);
+  auto rowNumberColumn = rowReaderOptions.rowNumberColumnInfo().value();
+  ASSERT_EQ(rowNumberColumnInfo.insertPosition, rowNumberColumn.insertPosition);
+  ASSERT_EQ(rowNumberColumnInfo.name, rowNumberColumn.name);
+  ASSERT_EQ(rowNumberColumnInfo.isExplicit, rowNumberColumn.isExplicit);
 }
 
-TEST(OptionsTests, testAppendRowNumberColumnInCopy) {
+TEST(OptionsTests, testRowNumberColumnInfoInCopy) {
   RowReaderOptions rowReaderOptions;
   RowReaderOptions rowReaderOptionsCopy{rowReaderOptions};
-  ASSERT_EQ(false, rowReaderOptionsCopy.getAppendRowNumberColumn());
+  ASSERT_EQ(std::nullopt, rowReaderOptionsCopy.rowNumberColumnInfo());
 
-  rowReaderOptions.setAppendRowNumberColumn(true);
+  RowNumberColumnInfo rowNumberColumnInfo;
+  rowNumberColumnInfo.insertPosition = 0;
+  rowNumberColumnInfo.name = "test";
+  rowReaderOptions.setRowNumberColumnInfo(rowNumberColumnInfo);
   RowReaderOptions rowReaderOptionsSecondCopy{rowReaderOptions};
-  ASSERT_EQ(true, rowReaderOptionsSecondCopy.getAppendRowNumberColumn());
+  auto rowNumberColumn =
+      rowReaderOptionsSecondCopy.rowNumberColumnInfo().value();
+  ASSERT_EQ(rowNumberColumnInfo.insertPosition, rowNumberColumn.insertPosition);
+  ASSERT_EQ(rowNumberColumnInfo.name, rowNumberColumn.name);
 }
diff --git a/velox/dwio/common/tests/ParallelForTest.cpp b/velox/dwio/common/tests/ParallelForTest.cpp
new file mode 100644
index 0000000000000..023dd6f5278f3
--- /dev/null
+++ b/velox/dwio/common/tests/ParallelForTest.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/ParallelFor.h"
+#include "folly/Executor.h"
+#include "folly/executors/CPUThreadPoolExecutor.h"
+#include "folly/executors/InlineExecutor.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "velox/common/base/VeloxException.h"
+
+using namespace ::testing;
+using namespace ::facebook::velox::dwio::common;
+
+namespace {
+
+class CountingExecutor : public folly::Executor {
+ public:
+  explicit CountingExecutor(folly::Executor& executor)
+      : executor_(executor), count_(0) {}
+
+  void add(folly::Func f) override {
+    executor_.add(std::move(f));
+    ++count_;
+  }
+
+  size_t getCount() const {
+    return count_;
+  }
+
+ private:
+  folly::Executor& executor_;
+  size_t count_;
+};
+
+void testParallelFor(
+    folly::Executor* executor,
+    size_t from,
+    size_t to,
+    size_t parallelismFactor) {
+  std::optional<CountingExecutor> countedExecutor;
+  std::ostringstream oss;
+  oss << "ParallelFor(executor: " << executor << ", from: " << from
+      << ", to: " << to << ", parallelismFactor: " << parallelismFactor << ")";
+  SCOPED_TRACE(oss.str());
+  if (executor) {
+    countedExecutor.emplace(*executor);
+    executor = &countedExecutor.value();
+  }
+
+  std::unordered_map<size_t, std::atomic<size_t>> indexInvoked;
+  for (size_t i = from; i < to; ++i) {
+    indexInvoked[i] = 0UL;
+  }
+
+  ParallelFor(executor, from, to, parallelismFactor)
+      .execute([&indexInvoked](size_t i) {
+        auto it = indexInvoked.find(i);
+        ASSERT_NE(it, indexInvoked.end());
+        ++it->second;
+      });
+
+  // Parallel For should have thrown otherwise
+  ASSERT_LE(from, to);
+
+  // The method was called for each index just once, and didn't call out of
+  // bounds indices.
+  EXPECT_EQ(indexInvoked.size(), (to - from));
+  for (auto& [i, count] : indexInvoked) {
+    if (i < from || i >= to) {
+      EXPECT_EQ(indexInvoked[i], 0);
+    } else {
+      EXPECT_EQ(indexInvoked[i], 1);
+    }
+  }
+
+  if (countedExecutor) {
+    const auto extraThreadsUsed = countedExecutor->getCount();
+    const auto numTasks = to - from;
+    const auto expectedExtraThreads = std::min(
+        parallelismFactor > 0 ? parallelismFactor - 1 : 0,
+        numTasks > 0 ? numTasks - 1 : 0);
+    EXPECT_EQ(extraThreadsUsed, expectedExtraThreads);
+  }
+}
+
+} // namespace
+
+TEST(ParallelForTest, E2E) {
+  auto inlineExecutor = folly::InlineExecutor::instance();
+  for (size_t parallelism = 0; parallelism < 25; ++parallelism) {
+    for (size_t begin = 0; begin < 25; ++begin) {
+      for (size_t end = 0; end < 25; ++end) {
+        if (begin <= end) {
+          testParallelFor(&inlineExecutor, begin, end, parallelism);
+        } else {
+          EXPECT_THROW(
+              testParallelFor(&inlineExecutor, begin, end, parallelism),
+              facebook::velox::VeloxRuntimeError);
+        }
+      }
+    }
+  }
+}
+
+TEST(ParallelForTest, E2EParallel) {
+  for (size_t parallelism = 1; parallelism < 2; ++parallelism) {
+    folly::CPUThreadPoolExecutor executor(parallelism);
+    for (size_t begin = 0; begin < 25; ++begin) {
+      for (size_t end = 0; end < 25; ++end) {
+        if (begin <= end) {
+          testParallelFor(&executor, begin, end, parallelism);
+        } else {
+          EXPECT_THROW(
+              testParallelFor(&executor, begin, end, parallelism),
+              facebook::velox::VeloxRuntimeError);
+        }
+      }
+    }
+  }
+}
+
+TEST(ParallelForTest, CanOwnExecutor) {
+  auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(2);
+  const size_t indexInvokedSize = 100;
+  std::unordered_map<size_t, std::atomic<size_t>> indexInvoked;
+  indexInvoked.reserve(indexInvokedSize);
+  for (size_t i = 0; i < indexInvokedSize; ++i) {
+    indexInvoked[i] = 0UL;
+  }
+
+  ParallelFor pf(executor, 0, indexInvokedSize, 9);
+  pf.execute([&indexInvoked](size_t i) { ++indexInvoked[i]; });
+
+  EXPECT_EQ(indexInvoked.size(), indexInvokedSize);
+  for (size_t i = 0; i < indexInvokedSize; ++i) {
+    EXPECT_EQ(indexInvoked[i], 1);
+  }
+}
diff --git a/velox/dwio/common/tests/RangeTests.cpp b/velox/dwio/common/tests/RangeTests.cpp
index a603445f3602f..1488c95fe2e60 100644
--- a/velox/dwio/common/tests/RangeTests.cpp
+++ b/velox/dwio/common/tests/RangeTests.cpp
@@ -16,16 +16,16 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/Range.h"
 
 using namespace ::testing;
-using namespace facebook::velox::dwio::common;
 
 namespace facebook::velox::common {
 
 TEST(RangeTests, Add) {
   Ranges ranges;
-  ASSERT_THROW(ranges.add(2, 1), exception::LoggedException);
+  VELOX_ASSERT_THROW(ranges.add(2, 1), "");
   ranges.add(2, 2);
   ranges.add(1, 3);
   ASSERT_THAT(ranges.ranges_, ElementsAre(std::tuple<size_t, size_t>{1, 3}));
diff --git a/velox/dwio/common/tests/ReadFileInputStreamTests.cpp b/velox/dwio/common/tests/ReadFileInputStreamTests.cpp
index 4beab04458474..273b523549f77 100644
--- a/velox/dwio/common/tests/ReadFileInputStreamTests.cpp
+++ b/velox/dwio/common/tests/ReadFileInputStreamTests.cpp
@@ -35,8 +35,8 @@ class ReadFileInputStreamTest : public testing::Test {
 };
 
 TEST_F(ReadFileInputStreamTest, LocalReadFile) {
-  auto tempFile = ::exec::test::TempFilePath::create();
-  const auto& filename = tempFile->path;
+  auto tempFile = exec::test::TempFilePath::create();
+  const auto& filename = tempFile->getPath();
   remove(filename.c_str());
   {
     LocalWriteFile writeFile(filename);
diff --git a/velox/dwio/common/tests/ReaderTest.cpp b/velox/dwio/common/tests/ReaderTest.cpp
new file mode 100644
index 0000000000000..cd4840f84ba7b
--- /dev/null
+++ b/velox/dwio/common/tests/ReaderTest.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/Reader.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::dwio::common {
+namespace {
+
+using namespace facebook::velox::common;
+
+class ReaderTest : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(ReaderTest, getOrCreateChild) {
+  constexpr int kSize = 5;
+  auto input = makeRowVector(
+      {"c.0", "c.1"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<int64_t>({2, 4, 6, 7, 8}),
+      });
+
+  common::ScanSpec spec("<root>");
+  spec.addField("c.0", 0);
+  // Create child from name.
+  spec.getOrCreateChild("c.1")->setFilter(
+      common::createBigintValues({2, 4, 6}, false));
+
+  auto actual = RowReader::projectColumns(input, spec, nullptr);
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+  });
+  test::assertEqualVectors(expected, actual);
+
+  // Create child from subfield.
+  spec.getOrCreateChild(common::Subfield("c.1"))
+      ->setFilter(common::createBigintValues({2, 4, 6}, false));
+  VELOX_ASSERT_USER_THROW(
+      RowReader::projectColumns(input, spec, nullptr),
+      "Field not found: c. Available fields are: c.0, c.1.");
+}
+
+TEST_F(ReaderTest, projectColumnsFilterStruct) {
+  constexpr int kSize = 10;
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeRowVector({
+          makeFlatVector<int64_t>(kSize, folly::identity),
+      }),
+  });
+  common::ScanSpec spec("<root>");
+  spec.addField("c0", 0);
+  spec.getOrCreateChild(common::Subfield("c1.c0"))
+      ->setFilter(common::createBigintValues({2, 4, 6}, false));
+  auto actual = RowReader::projectColumns(input, spec, nullptr);
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({2, 4, 6}),
+  });
+  test::assertEqualVectors(expected, actual);
+}
+
+TEST_F(ReaderTest, projectColumnsFilterArray) {
+  constexpr int kSize = 10;
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeArrayVector<int64_t>(
+          kSize,
+          [](auto) { return 1; },
+          [](auto i) { return i; },
+          [](auto i) { return i % 2 != 0; }),
+  });
+  common::ScanSpec spec("<root>");
+  spec.addField("c0", 0);
+  auto* c1 = spec.getOrCreateChild(common::Subfield("c1"));
+  {
+    SCOPED_TRACE("IS NULL");
+    c1->setFilter(std::make_unique<common::IsNull>());
+    auto actual = RowReader::projectColumns(input, spec, nullptr);
+    auto expected = makeRowVector({
+        makeFlatVector<int64_t>({1, 3, 5, 7, 9}),
+    });
+    test::assertEqualVectors(expected, actual);
+  }
+  {
+    SCOPED_TRACE("IS NOT NULL");
+    c1->setFilter(std::make_unique<common::IsNotNull>());
+    auto actual = RowReader::projectColumns(input, spec, nullptr);
+    auto expected = makeRowVector({
+        makeFlatVector<int64_t>({0, 2, 4, 6, 8}),
+    });
+    test::assertEqualVectors(expected, actual);
+  }
+}
+
+TEST_F(ReaderTest, projectColumnsMutation) {
+  constexpr int kSize = 10;
+  auto input = makeRowVector({makeFlatVector<int64_t>(kSize, folly::identity)});
+  common::ScanSpec spec("<root>");
+  spec.addAllChildFields(*input->type());
+  std::vector<uint64_t> deleted(bits::nwords(kSize));
+  bits::setBit(deleted.data(), 2);
+  Mutation mutation;
+  mutation.deletedRows = deleted.data();
+  auto actual = RowReader::projectColumns(input, spec, &mutation);
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 3, 4, 5, 6, 7, 8, 9}),
+  });
+  test::assertEqualVectors(expected, actual);
+  random::setSeed(42);
+  random::RandomSkipTracker randomSkip(0.5);
+  mutation.randomSkip = &randomSkip;
+  actual = RowReader::projectColumns(input, spec, &mutation);
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 3, 5, 6, 8}),
+  });
+  test::assertEqualVectors(expected, actual);
+}
+
+} // namespace
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/RetryTests.cpp b/velox/dwio/common/tests/RetryTests.cpp
index f02544c6fe839..dc6f5bdf2e425 100644
--- a/velox/dwio/common/tests/RetryTests.cpp
+++ b/velox/dwio/common/tests/RetryTests.cpp
@@ -21,14 +21,14 @@ using namespace std::chrono_literals;
 using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::dwio::common::retrypolicy;
 
-template <uint8_t ExceptionCount>
 class Raise {
  public:
-  Raise() : count_(0) {}
+  explicit Raise(uint8_t exceptionCount)
+      : exceptionCount_(exceptionCount), count_(0) {}
 
   template <typename T>
   T call(const T& value) {
-    if (count_++ < ExceptionCount) {
+    if (count_++ < exceptionCount_) {
       throw retriable_error(std::runtime_error("Bad!!!"));
     }
 
@@ -42,11 +42,12 @@ class Raise {
   ~Raise() = default;
 
  private:
+  const uint8_t exceptionCount_;
   uint8_t count_;
 };
 
 TEST(RetryModuleTests, retryUntilSuccessDefault) {
-  Raise<4> raise;
+  Raise raise(4);
   std::function<int8_t()> retriable = [&raise]() {
     return raise.call<int8_t>(10);
   };
@@ -64,7 +65,7 @@ TEST(RetryModuleTests, retryUntilSuccessDefault) {
 }
 
 TEST(RetryModuleTests, retryUntilSuccessBackoff) {
-  Raise<4> raise;
+  Raise raise(4);
   std::function<int8_t()> retriable = [&raise]() {
     return raise.call<int8_t>(10);
   };
@@ -82,7 +83,7 @@ TEST(RetryModuleTests, retryUntilSuccessBackoff) {
 }
 
 TEST(RetryModuleTests, retryCapMaxDelay) {
-  Raise<4> raise;
+  Raise raise(4);
   std::function<int8_t()> retriable = [&raise]() {
     return raise.call<int8_t>(10);
   };
@@ -100,7 +101,7 @@ TEST(RetryModuleTests, retryCapMaxDelay) {
 }
 
 TEST(RetryModuleTests, failOnRetriesExceededDefault) {
-  Raise<6> raise;
+  Raise raise(6);
   std::function<int8_t()> retriable = [&raise]() {
     return raise.call<int8_t>(10);
   };
@@ -113,7 +114,7 @@ TEST(RetryModuleTests, failOnRetriesExceededDefault) {
 }
 
 TEST(RetryModuleTests, failOnRetriesExceededBackoff) {
-  Raise<6> raise;
+  Raise raise(6);
   std::function<int8_t()> retriable = [&raise]() {
     return raise.call<int8_t>(10);
   };
@@ -126,7 +127,7 @@ TEST(RetryModuleTests, failOnRetriesExceededBackoff) {
 }
 
 TEST(RetryModuleTests, failOnRetriesExceededTotalBackoff) {
-  Raise<100> raise;
+  Raise raise(100);
   std::function<int8_t()> retriable = [&raise]() {
     return raise.call<int8_t>(10);
   };
@@ -143,7 +144,7 @@ TEST(RetryModuleTests, failOnRetriesExceededTotalBackoff) {
 }
 
 TEST(RetryModuleTests, defineDifferentUnit) {
-  Raise<1> raise;
+  Raise raise(1);
   std::function<int8_t()> retriable = [&raise]() {
     return raise.call<int8_t>(11);
   };
@@ -172,3 +173,15 @@ TEST(RetryModuleTests, testJitter) {
 
   ASSERT_GT(wait.count(), nextWait);
 }
+
+TEST(RetryModuleTests, exponentialBackOffCountExecutionTime) {
+  Raise raise(1);
+  auto retriable = [&raise]() {
+    std::this_thread::sleep_for(20ms);
+    return raise.call<int8_t>(10);
+  };
+  ExponentialBackoffPolicyFactory policyFactory(1ms, 1ms, 5, 10ms, true);
+  ASSERT_THROW(
+      RetryModule::withRetry(retriable, policyFactory.getRetryPolicy()),
+      retries_exhausted);
+}
diff --git a/velox/dwio/common/tests/TestBufferedInput.cpp b/velox/dwio/common/tests/TestBufferedInput.cpp
index 042986fbfc7e2..c0795e3c07601 100644
--- a/velox/dwio/common/tests/TestBufferedInput.cpp
+++ b/velox/dwio/common/tests/TestBufferedInput.cpp
@@ -20,6 +20,7 @@
 
 using namespace facebook::velox::dwio::common;
 using facebook::velox::common::Region;
+using namespace facebook::velox::memory;
 using namespace ::testing;
 
 namespace {
@@ -31,7 +32,7 @@ class ReadFileMock : public ::facebook::velox::ReadFile {
   MOCK_METHOD(
       std::string_view,
       pread,
-      (uint64_t offset, uint64_t length, void* FOLLY_NONNULL buf),
+      (uint64_t offset, uint64_t length, void* buf),
       (const, override));
 
   MOCK_METHOD(bool, shouldCoalesce, (), (const, override));
@@ -40,7 +41,7 @@ class ReadFileMock : public ::facebook::velox::ReadFile {
   MOCK_METHOD(std::string, getName, (), (const, override));
   MOCK_METHOD(uint64_t, getNaturalReadSize, (), (const, override));
   MOCK_METHOD(
-      void,
+      uint64_t,
       preadv,
       (folly::Range<const Region*> regions, folly::Range<folly::IOBuf*> iobufs),
       (const, override));
@@ -73,26 +74,31 @@ void expectPreadvs(
   EXPECT_CALL(file, size()).WillRepeatedly(Return(content.size()));
   EXPECT_CALL(file, preadv(_, _))
       .Times(1)
-      .WillOnce([content, reads](
-                    folly::Range<const Region*> regions,
-                    folly::Range<folly::IOBuf*> iobufs) {
-        ASSERT_EQ(regions.size(), reads.size());
-        for (size_t i = 0; i < reads.size(); ++i) {
-          const auto& region = regions[i];
-          const auto& read = reads[i];
-          auto& iobuf = iobufs[i];
-          ASSERT_EQ(region.offset, read.offset);
-          ASSERT_EQ(region.length, read.length);
-          if (!read.label.empty()) {
-            EXPECT_EQ(read.label, region.label);
-          }
-          ASSERT_LE(region.offset + region.length, content.size());
-          iobuf = folly::IOBuf(
-              folly::IOBuf::COPY_BUFFER,
-              content.data() + region.offset,
-              region.length);
-        }
-      });
+      .WillOnce(
+          [content, reads](
+              folly::Range<const Region*> regions,
+              folly::Range<folly::IOBuf*> iobufs) -> uint64_t {
+            EXPECT_EQ(regions.size(), reads.size());
+            uint64_t length = 0;
+            for (size_t i = 0; i < reads.size(); ++i) {
+              const auto& region = regions[i];
+              const auto& read = reads[i];
+              auto& iobuf = iobufs[i];
+              length += region.length;
+              EXPECT_EQ(region.offset, read.offset);
+              EXPECT_EQ(region.length, read.length);
+              if (!read.label.empty()) {
+                EXPECT_EQ(read.label, region.label);
+              }
+              EXPECT_LE(region.offset + region.length, content.size());
+              iobuf = folly::IOBuf(
+                  folly::IOBuf::COPY_BUFFER,
+                  content.data() + region.offset,
+                  region.length);
+            }
+
+            return length;
+          });
 }
 
 std::optional<std::string> getNext(SeekableInputStream& input) {
@@ -106,21 +112,22 @@ std::optional<std::string> getNext(SeekableInputStream& input) {
   }
 }
 
-} // namespace
+class TestBufferedInput : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
 
-TEST(TestBufferedInput, AllowMoveConstructor) {
-  auto readFileMock = std::make_shared<ReadFileMock>();
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  BufferedInput a(readFileMock, *pool);
-  BufferedInput b(std::move(a));
-}
+  const std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+} // namespace
 
-TEST(TestBufferedInput, ZeroLengthStream) {
+TEST_F(TestBufferedInput, ZeroLengthStream) {
   auto readFile =
       std::make_shared<facebook::velox::InMemoryReadFile>(std::string());
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  BufferedInput input(readFile, *pool);
+  BufferedInput input(readFile, *pool_);
   auto ret = input.enqueue({0, 0});
+  EXPECT_EQ(input.nextFetchSize(), 0);
   EXPECT_NE(ret, nullptr);
   const void* buf = nullptr;
   int32_t size = 1;
@@ -128,15 +135,14 @@ TEST(TestBufferedInput, ZeroLengthStream) {
   EXPECT_EQ(size, 0);
 }
 
-TEST(TestBufferedInput, UseRead) {
+TEST_F(TestBufferedInput, UseRead) {
   std::string content = "hello";
   auto readFileMock = std::make_shared<ReadFileMock>();
   expectPreads(*readFileMock, content, {{0, 5}});
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
   // Use read
   BufferedInput input(
       readFileMock,
-      *pool,
+      *pool_,
       MetricsLog::voidLog(),
       nullptr,
       10,
@@ -144,6 +150,7 @@ TEST(TestBufferedInput, UseRead) {
   auto ret = input.enqueue({0, 5});
   ASSERT_NE(ret, nullptr);
 
+  EXPECT_EQ(input.nextFetchSize(), 5);
   input.load(LogType::TEST);
 
   auto next = getNext(*ret);
@@ -151,15 +158,14 @@ TEST(TestBufferedInput, UseRead) {
   EXPECT_EQ(next.value(), content);
 }
 
-TEST(TestBufferedInput, UseVRead) {
+TEST_F(TestBufferedInput, UseVRead) {
   std::string content = "hello";
   auto readFileMock = std::make_shared<ReadFileMock>();
   expectPreadvs(*readFileMock, content, {{0, 5}});
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
   // Use vread
   BufferedInput input(
       readFileMock,
-      *pool,
+      *pool_,
       MetricsLog::voidLog(),
       nullptr,
       10,
@@ -167,6 +173,7 @@ TEST(TestBufferedInput, UseVRead) {
   auto ret = input.enqueue({0, 5});
   ASSERT_NE(ret, nullptr);
 
+  EXPECT_EQ(input.nextFetchSize(), 5);
   input.load(LogType::TEST);
 
   auto next = getNext(*ret);
@@ -174,7 +181,7 @@ TEST(TestBufferedInput, UseVRead) {
   EXPECT_EQ(next.value(), content);
 }
 
-TEST(TestBufferedInput, WillMerge) {
+TEST_F(TestBufferedInput, WillMerge) {
   std::string content = "hello world";
   auto readFileMock = std::make_shared<ReadFileMock>();
 
@@ -182,10 +189,9 @@ TEST(TestBufferedInput, WillMerge) {
   // Expect only one call.
   expectPreads(*readFileMock, content, {{0, 11}});
 
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
   BufferedInput input(
       readFileMock,
-      *pool,
+      *pool_,
       MetricsLog::voidLog(),
       nullptr,
       10, // Will merge if distance <= 10
@@ -196,6 +202,7 @@ TEST(TestBufferedInput, WillMerge) {
   ASSERT_NE(ret1, nullptr);
   ASSERT_NE(ret2, nullptr);
 
+  EXPECT_EQ(input.nextFetchSize(), 10);
   input.load(LogType::TEST);
 
   auto next1 = getNext(*ret1);
@@ -207,7 +214,7 @@ TEST(TestBufferedInput, WillMerge) {
   EXPECT_EQ(next2.value(), "world");
 }
 
-TEST(TestBufferedInput, WontMerge) {
+TEST_F(TestBufferedInput, WontMerge) {
   std::string content = "hello  world"; // two spaces
   auto readFileMock = std::make_shared<ReadFileMock>();
 
@@ -215,10 +222,9 @@ TEST(TestBufferedInput, WontMerge) {
   // Expect two calls
   expectPreads(*readFileMock, content, {{0, 5}, {7, 5}});
 
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
   BufferedInput input(
       readFileMock,
-      *pool,
+      *pool_,
       MetricsLog::voidLog(),
       nullptr,
       1, // Will merge if distance <= 1
@@ -229,6 +235,7 @@ TEST(TestBufferedInput, WontMerge) {
   ASSERT_NE(ret1, nullptr);
   ASSERT_NE(ret2, nullptr);
 
+  EXPECT_EQ(input.nextFetchSize(), 10);
   input.load(LogType::TEST);
 
   auto next1 = getNext(*ret1);
@@ -240,16 +247,15 @@ TEST(TestBufferedInput, WontMerge) {
   EXPECT_EQ(next2.value(), "world");
 }
 
-TEST(TestBufferedInput, ReadSorting) {
+TEST_F(TestBufferedInput, ReadSorting) {
   std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
   std::vector<Region> regions = {{6, 3}, {24, 3}, {3, 3}, {0, 3}, {29, 3}};
 
   auto readFileMock = std::make_shared<ReadFileMock>();
   expectPreads(*readFileMock, content, {{0, 9}, {24, 3}, {29, 3}});
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
   BufferedInput input(
       readFileMock,
-      *pool,
+      *pool_,
       MetricsLog::voidLog(),
       nullptr,
       1, // Will merge if distance <= 1
@@ -258,13 +264,16 @@ TEST(TestBufferedInput, ReadSorting) {
   std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
       result;
   result.reserve(regions.size());
+  int64_t bytesToRead = 0;
   for (auto& region : regions) {
+    bytesToRead += region.length;
     auto ret = input.enqueue(region);
     ASSERT_NE(ret, nullptr);
     result.push_back(
         {std::move(ret), content.substr(region.offset, region.length)});
   }
 
+  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
   input.load(LogType::TEST);
 
   for (auto& r : result) {
@@ -274,17 +283,16 @@ TEST(TestBufferedInput, ReadSorting) {
   }
 }
 
-TEST(TestBufferedInput, VReadSorting) {
+TEST_F(TestBufferedInput, VReadSorting) {
   std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
   std::vector<Region> regions = {{6, 3}, {24, 3}, {3, 3}, {0, 3}, {29, 3}};
 
   auto readFileMock = std::make_shared<ReadFileMock>();
   expectPreadvs(
       *readFileMock, content, {{0, 3}, {3, 3}, {6, 3}, {24, 3}, {29, 3}});
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
   BufferedInput input(
       readFileMock,
-      *pool,
+      *pool_,
       MetricsLog::voidLog(),
       nullptr,
       1, // Will merge if distance <= 1
@@ -293,13 +301,16 @@ TEST(TestBufferedInput, VReadSorting) {
   std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
       result;
   result.reserve(regions.size());
+  int64_t bytesToRead = 0;
   for (auto& region : regions) {
+    bytesToRead += region.length;
     auto ret = input.enqueue(region);
     ASSERT_NE(ret, nullptr);
     result.push_back(
         {std::move(ret), content.substr(region.offset, region.length)});
   }
 
+  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
   input.load(LogType::TEST);
 
   for (auto& r : result) {
@@ -309,7 +320,7 @@ TEST(TestBufferedInput, VReadSorting) {
   }
 }
 
-TEST(TestBufferedInput, VReadSortingWithLabels) {
+TEST_F(TestBufferedInput, VReadSortingWithLabels) {
   std::string content = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqq";
   std::vector<std::string> l = {"a", "b", "c", "d", "e"};
   std::vector<Region> regions = {
@@ -320,10 +331,9 @@ TEST(TestBufferedInput, VReadSortingWithLabels) {
       *readFileMock,
       content,
       {{0, 3, l[0]}, {3, 3, l[1]}, {6, 3, l[2]}, {24, 3, l[3]}, {29, 3, l[4]}});
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
   BufferedInput input(
       readFileMock,
-      *pool,
+      *pool_,
       MetricsLog::voidLog(),
       nullptr,
       1, // Will merge if distance <= 1
@@ -332,13 +342,16 @@ TEST(TestBufferedInput, VReadSortingWithLabels) {
   std::vector<std::pair<std::unique_ptr<SeekableInputStream>, std::string>>
       result;
   result.reserve(regions.size());
+  int64_t bytesToRead = 0;
   for (auto& region : regions) {
+    bytesToRead += region.length;
     auto ret = input.enqueue(region);
     ASSERT_NE(ret, nullptr);
     result.push_back(
         {std::move(ret), content.substr(region.offset, region.length)});
   }
 
+  EXPECT_EQ(input.nextFetchSize(), bytesToRead);
   input.load(LogType::TEST);
 
   for (auto& r : result) {
diff --git a/velox/dwio/common/tests/ThrottlerTest.cpp b/velox/dwio/common/tests/ThrottlerTest.cpp
new file mode 100644
index 0000000000000..6a3b62e1f5103
--- /dev/null
+++ b/velox/dwio/common/tests/ThrottlerTest.cpp
@@ -0,0 +1,558 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/Throttler.h"
+
+#include <gtest/gtest.h>
+
+#include "folly/Random.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+namespace facebook::velox::dwio::common {
+namespace {
+
+class ThrottlerTest : public testing::Test {
+ protected:
+  static Throttler::Config throttleConfig(uint32_t cacheTTLMs = 3'600 * 1'000) {
+    return Throttler::Config(true, 1, 4, 2.0, 10, 40, 4, cacheTTLMs);
+  }
+
+  void SetUp() override {
+    Throttler::testingReset();
+  }
+};
+
+TEST_F(ThrottlerTest, config) {
+  const auto config = throttleConfig();
+  ASSERT_EQ(
+      config.toString(),
+      "throttleEnabled:true minThrottleBackoffMs:1ms maxThrottleBackoffMs:4ms backoffScaleFactor:2 minLocalThrottledSignals:10 minGlobalThrottledSignals:40 maxCacheEntries:4 cacheTTLMs:1h 0m 0s");
+}
+
+TEST_F(ThrottlerTest, signalType) {
+  ASSERT_EQ(Throttler::signalTypeName(Throttler::SignalType::kLocal), "Local");
+  ASSERT_EQ(
+      Throttler::signalTypeName(Throttler::SignalType::kGlobal), "Global");
+  ASSERT_EQ(Throttler::signalTypeName(Throttler::SignalType::kNone), "None");
+  ASSERT_EQ(
+      Throttler::signalTypeName(static_cast<Throttler::SignalType>(100)),
+      "Unknown Signal Type: 100");
+}
+
+TEST_F(ThrottlerTest, init) {
+  ASSERT_EQ(Throttler::instance(), nullptr);
+  Throttler::init(throttleConfig());
+  auto* instance = Throttler::instance();
+  ASSERT_NE(instance, nullptr);
+  ASSERT_EQ(instance, Throttler::instance());
+  VELOX_ASSERT_THROW(
+      Throttler::init(throttleConfig()), "Throttler has already been set");
+  ASSERT_EQ(instance, Throttler::instance());
+}
+
+TEST_F(ThrottlerTest, throttleDisabled) {
+  Throttler::init(Throttler::Config(false));
+  const std::string cluster{"throttleDisabled"};
+  const std::string directory{"throttleDisabled"};
+  auto* instance = Throttler::instance();
+  for (int i = 1; i <= 100; ++i) {
+    ASSERT_EQ(
+        instance->throttleBackoff(
+            i % 2 ? Throttler::SignalType::kLocal
+                  : Throttler::SignalType::kGlobal,
+            cluster,
+            directory),
+        0);
+  }
+  const auto& stats = instance->stats();
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 0);
+}
+
+TEST_F(ThrottlerTest, noThrottlerSignal) {
+  Throttler::init(Throttler::Config(true, 100, 200, 2.0, 10, 1'000));
+  const std::string cluster{"noThrottlerSignal"};
+  const std::string directory{"noThrottlerSignal"};
+  auto* instance = Throttler::instance();
+  for (int i = 1; i <= 100; ++i) {
+    ASSERT_EQ(
+        instance->throttleBackoff(
+            Throttler::SignalType::kNone, cluster, directory),
+        0);
+  }
+  const auto& stats = instance->stats();
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 0);
+}
+
+TEST_F(ThrottlerTest, throttle) {
+  const uint64_t minThrottleBackoffMs = 1'000;
+  const uint64_t maxThrottleBackoffMs = 2'000;
+  for (const bool global : {true, false}) {
+    SCOPED_TRACE(fmt::format("global {}", global));
+
+    Throttler::testingReset();
+    Throttler::init(Throttler::Config(
+        true,
+        minThrottleBackoffMs,
+        maxThrottleBackoffMs,
+        2.0,
+        global ? 1'0000 : 2,
+        global ? 2 : 1'0000));
+    auto* instance = Throttler::instance();
+    const auto& stats = instance->stats();
+    ASSERT_EQ(stats.localThrottled, 0);
+    ASSERT_EQ(stats.globalThrottled, 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+    const Throttler::SignalType type =
+        global ? Throttler::SignalType::kGlobal : Throttler::SignalType::kLocal;
+    const std::string cluster{"throttle"};
+    const std::string directory{"throttle"};
+    ASSERT_EQ(instance->throttleBackoff(type, cluster, directory), 0);
+    ASSERT_EQ(instance->throttleBackoff(type, cluster, directory), 0);
+
+    ASSERT_EQ(stats.localThrottled, 0);
+    ASSERT_EQ(stats.globalThrottled, 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+    uint64_t measuredBackOffMs{0};
+    uint64_t firstBackoffMs{0};
+    {
+      MicrosecondTimer timer(&measuredBackOffMs);
+      firstBackoffMs = instance->throttleBackoff(type, cluster, directory);
+    }
+    ASSERT_LE(firstBackoffMs, maxThrottleBackoffMs);
+    ASSERT_GE(firstBackoffMs, minThrottleBackoffMs);
+    ASSERT_GE(measuredBackOffMs, firstBackoffMs);
+
+    ASSERT_EQ(stats.localThrottled, global ? 0 : 1);
+    ASSERT_EQ(stats.globalThrottled, global ? 1 : 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 1);
+    ASSERT_EQ(stats.backOffDelay.sum(), firstBackoffMs);
+
+    measuredBackOffMs = 0;
+    uint64_t secondBackoffMs{0};
+    {
+      MicrosecondTimer timer(&measuredBackOffMs);
+      secondBackoffMs = instance->throttleBackoff(type, cluster, directory);
+    }
+    ASSERT_LE(secondBackoffMs, maxThrottleBackoffMs);
+    ASSERT_GE(secondBackoffMs, minThrottleBackoffMs);
+    ASSERT_GE(measuredBackOffMs, secondBackoffMs);
+    ASSERT_LT(firstBackoffMs, secondBackoffMs);
+
+    ASSERT_EQ(stats.localThrottled, global ? 0 : 2);
+    ASSERT_EQ(stats.globalThrottled, global ? 2 : 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 2);
+    ASSERT_EQ(stats.backOffDelay.sum(), firstBackoffMs + secondBackoffMs);
+  }
+}
+
+TEST_F(ThrottlerTest, expire) {
+  const uint64_t minThrottleBackoffMs = 1'00;
+  const uint64_t maxThrottleBackoffMs = 2'00;
+  for (const bool global : {true, false}) {
+    SCOPED_TRACE(fmt::format("global {}", global));
+    Throttler::testingReset();
+    Throttler::init(Throttler::Config(
+        true,
+        minThrottleBackoffMs,
+        maxThrottleBackoffMs,
+        2.0,
+        global ? 1'0000 : 2,
+        global ? 2 : 1'0000,
+        1'000,
+        1'000));
+    auto* instance = Throttler::instance();
+    const auto& stats = instance->stats();
+    ASSERT_EQ(stats.localThrottled, 0);
+    ASSERT_EQ(stats.globalThrottled, 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+    const Throttler::SignalType type =
+        global ? Throttler::SignalType::kGlobal : Throttler::SignalType::kLocal;
+    const std::string cluster{"expire"};
+    const std::string directory{"expire"};
+    ASSERT_EQ(instance->throttleBackoff(type, cluster, directory), 0);
+    ASSERT_EQ(instance->throttleBackoff(type, cluster, directory), 0);
+
+    ASSERT_EQ(stats.localThrottled, 0);
+    ASSERT_EQ(stats.globalThrottled, 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+    std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
+
+    ASSERT_EQ(instance->throttleBackoff(type, cluster, directory), 0);
+    ASSERT_EQ(instance->throttleBackoff(type, cluster, directory), 0);
+
+    ASSERT_EQ(stats.localThrottled, 0);
+    ASSERT_EQ(stats.globalThrottled, 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 0);
+  }
+}
+
+TEST_F(ThrottlerTest, differentLocals) {
+  const uint64_t minThrottleBackoffMs = 1'000;
+  const uint64_t maxThrottleBackoffMs = 2'000;
+  Throttler::init(Throttler::Config(
+      true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 2, 1'0000));
+  auto* instance = Throttler::instance();
+  const auto& stats = instance->stats();
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+  const std::string cluster1{"differentLocals1"};
+  const std::string directory1{"differentLocals1"};
+  ASSERT_EQ(
+      instance->throttleBackoff(
+          Throttler::SignalType::kLocal, cluster1, directory1),
+      0);
+  ASSERT_EQ(
+      instance->throttleBackoff(
+          Throttler::SignalType::kLocal, cluster1, directory1),
+      0);
+
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+  const std::string directory2{"differentLocals2"};
+  ASSERT_EQ(
+      instance->throttleBackoff(
+          Throttler::SignalType::kLocal, cluster1, directory2),
+      0);
+  ASSERT_EQ(
+      instance->throttleBackoff(
+          Throttler::SignalType::kLocal, cluster1, directory2),
+      0);
+
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+  const auto path1firstBackoffMs = instance->throttleBackoff(
+      Throttler::SignalType::kLocal, cluster1, directory1);
+  ASSERT_GT(path1firstBackoffMs, 0);
+  ASSERT_LT(path1firstBackoffMs, maxThrottleBackoffMs);
+
+  ASSERT_EQ(stats.localThrottled, 1);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 1);
+  ASSERT_EQ(stats.backOffDelay.sum(), path1firstBackoffMs);
+
+  const auto path2firstBackoffMs = instance->throttleBackoff(
+      Throttler::SignalType::kLocal, cluster1, directory2);
+  ASSERT_GT(path2firstBackoffMs, 0);
+  ASSERT_LT(path2firstBackoffMs, maxThrottleBackoffMs);
+
+  ASSERT_EQ(stats.localThrottled, 2);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 2);
+  ASSERT_EQ(
+      stats.backOffDelay.sum(), path1firstBackoffMs + path2firstBackoffMs);
+
+  const auto path1SecondBackoffMs = instance->throttleBackoff(
+      Throttler::SignalType::kLocal, cluster1, directory1);
+  ASSERT_EQ(path1SecondBackoffMs, maxThrottleBackoffMs);
+
+  ASSERT_EQ(stats.localThrottled, 3);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 3);
+  ASSERT_EQ(
+      stats.backOffDelay.sum(),
+      path1firstBackoffMs + path2firstBackoffMs + path1SecondBackoffMs);
+
+  const auto path2SecondBackoffMs = instance->throttleBackoff(
+      Throttler::SignalType::kLocal, cluster1, directory2);
+  ASSERT_EQ(path2SecondBackoffMs, maxThrottleBackoffMs);
+
+  ASSERT_EQ(stats.localThrottled, 4);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 4);
+  ASSERT_EQ(
+      stats.backOffDelay.sum(),
+      path1firstBackoffMs + path2firstBackoffMs + path1SecondBackoffMs +
+          path2SecondBackoffMs);
+}
+
+TEST_F(ThrottlerTest, differentGlobals) {
+  const uint64_t minThrottleBackoffMs = 1'000;
+  const uint64_t maxThrottleBackoffMs = 2'000;
+  Throttler::init(Throttler::Config(
+      true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 1'0000, 2));
+  auto* instance = Throttler::instance();
+  const auto& stats = instance->stats();
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+  const std::string cluster1{"differentGlobals1"};
+  const std::string directory1{"differentGlobals1"};
+  ASSERT_EQ(
+      instance->throttleBackoff(
+          Throttler::SignalType::kGlobal, cluster1, directory1),
+      0);
+  ASSERT_EQ(
+      instance->throttleBackoff(
+          Throttler::SignalType::kGlobal, cluster1, directory1),
+      0);
+
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+  const std::string cluster2{"differentGlobals2"};
+  const std::string directory2{"differentGlobals1"};
+  ASSERT_EQ(
+      instance->throttleBackoff(
+          Throttler::SignalType::kGlobal, cluster2, directory2),
+      0);
+  ASSERT_EQ(
+      instance->throttleBackoff(
+          Throttler::SignalType::kGlobal, cluster2, directory2),
+      0);
+
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 0);
+  ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+  const auto path1firstBackoffMs = instance->throttleBackoff(
+      Throttler::SignalType::kGlobal, cluster1, directory1);
+  ASSERT_GT(path1firstBackoffMs, 0);
+  ASSERT_LT(path1firstBackoffMs, maxThrottleBackoffMs);
+
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 1);
+  ASSERT_EQ(stats.backOffDelay.count(), 1);
+  ASSERT_EQ(stats.backOffDelay.sum(), path1firstBackoffMs);
+
+  const auto path2firstBackoffMs = instance->throttleBackoff(
+      Throttler::SignalType::kGlobal, cluster2, directory2);
+  ASSERT_GT(path2firstBackoffMs, 0);
+  ASSERT_LT(path2firstBackoffMs, maxThrottleBackoffMs);
+
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 2);
+  ASSERT_EQ(stats.backOffDelay.count(), 2);
+  ASSERT_EQ(
+      stats.backOffDelay.sum(), path1firstBackoffMs + path2firstBackoffMs);
+
+  const auto path1SecondBackoffMs = instance->throttleBackoff(
+      Throttler::SignalType::kGlobal, cluster1, directory1);
+  ASSERT_EQ(path1SecondBackoffMs, maxThrottleBackoffMs);
+
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 3);
+  ASSERT_EQ(stats.backOffDelay.count(), 3);
+  ASSERT_EQ(
+      stats.backOffDelay.sum(),
+      path1firstBackoffMs + path2firstBackoffMs + path1SecondBackoffMs);
+
+  const auto path2SecondBackoffMs = instance->throttleBackoff(
+      Throttler::SignalType::kGlobal, cluster2, directory2);
+  ASSERT_EQ(path2SecondBackoffMs, maxThrottleBackoffMs);
+
+  ASSERT_EQ(stats.localThrottled, 0);
+  ASSERT_EQ(stats.globalThrottled, 4);
+  ASSERT_EQ(stats.backOffDelay.count(), 4);
+  ASSERT_EQ(
+      stats.backOffDelay.sum(),
+      path1firstBackoffMs + path2firstBackoffMs + path1SecondBackoffMs +
+          path2SecondBackoffMs);
+}
+
+TEST_F(ThrottlerTest, maxOfGlobalAndLocal) {
+  const uint64_t minThrottleBackoffMs = 1'000;
+  const uint64_t maxThrottleBackoffMs = 2'000;
+  for (const bool localFirst : {false, true}) {
+    SCOPED_TRACE(fmt::format("localFirst: {}", localFirst));
+    Throttler::testingReset();
+    Throttler::init(Throttler::Config(
+        true, minThrottleBackoffMs, maxThrottleBackoffMs, 2.0, 2, 2));
+    auto* instance = Throttler::instance();
+    const auto& stats = instance->stats();
+    ASSERT_EQ(stats.localThrottled, 0);
+    ASSERT_EQ(stats.globalThrottled, 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+    const std::string cluster1{"maxOfGlobalAndLocal1"};
+    const std::string directory1{"maxOfGlobalAndLocal1"};
+    ASSERT_EQ(
+        instance->throttleBackoff(
+            localFirst ? Throttler::SignalType::kLocal
+                       : Throttler::SignalType::kGlobal,
+            cluster1,
+            directory1),
+        0);
+    ASSERT_EQ(
+        instance->throttleBackoff(
+            localFirst ? Throttler::SignalType::kLocal
+                       : Throttler::SignalType::kGlobal,
+            cluster1,
+            directory1),
+        0);
+
+    ASSERT_EQ(stats.localThrottled, 0);
+    ASSERT_EQ(stats.globalThrottled, 0);
+    ASSERT_EQ(stats.backOffDelay.count(), 0);
+
+    auto backoffMs = instance->throttleBackoff(
+        localFirst ? Throttler::SignalType::kLocal
+                   : Throttler::SignalType::kGlobal,
+        cluster1,
+        directory1);
+    ASSERT_GT(backoffMs, 0);
+    ASSERT_LT(backoffMs, maxThrottleBackoffMs);
+
+    backoffMs = instance->throttleBackoff(
+        localFirst ? Throttler::SignalType::kGlobal
+                   : Throttler::SignalType::kLocal,
+        cluster1,
+        directory1);
+    ASSERT_GT(backoffMs, 0);
+    ASSERT_LT(backoffMs, maxThrottleBackoffMs);
+
+    backoffMs = instance->throttleBackoff(
+        localFirst ? Throttler::SignalType::kGlobal
+                   : Throttler::SignalType::kLocal,
+        cluster1,
+        directory1);
+    ASSERT_GT(backoffMs, 0);
+    ASSERT_LT(backoffMs, maxThrottleBackoffMs);
+
+    backoffMs = instance->throttleBackoff(
+        localFirst ? Throttler::SignalType::kLocal
+                   : Throttler::SignalType::kGlobal,
+        cluster1,
+        directory1);
+    ASSERT_EQ(backoffMs, maxThrottleBackoffMs);
+
+    const std::string cluster2{"maxOfGlobalAndLocal2"};
+    const std::string directory2{"maxOfGlobalAndLocal1"};
+    ASSERT_EQ(
+        instance->throttleBackoff(
+            localFirst ? Throttler::SignalType::kGlobal
+                       : Throttler::SignalType::kLocal,
+            cluster2,
+            directory2),
+        0);
+    ASSERT_EQ(
+        instance->throttleBackoff(
+            localFirst ? Throttler::SignalType::kGlobal
+                       : Throttler::SignalType::kLocal,
+            cluster2,
+            directory2),
+        0);
+
+    backoffMs = instance->throttleBackoff(
+        localFirst ? Throttler::SignalType::kGlobal
+                   : Throttler::SignalType::kLocal,
+        cluster2,
+        directory2);
+    ASSERT_GT(backoffMs, 0);
+    ASSERT_LT(backoffMs, maxThrottleBackoffMs);
+
+    const std::string directory3{"maxOfGlobalAndLocal3"};
+    backoffMs = instance->throttleBackoff(
+        Throttler::SignalType::kGlobal, cluster1, directory3);
+    if (localFirst) {
+      ASSERT_GT(backoffMs, 0);
+      ASSERT_LT(backoffMs, maxThrottleBackoffMs);
+    } else {
+      ASSERT_EQ(backoffMs, maxThrottleBackoffMs);
+    }
+
+    if (localFirst) {
+      ASSERT_EQ(stats.localThrottled, 2);
+      ASSERT_EQ(stats.globalThrottled, 4);
+    } else {
+      ASSERT_EQ(stats.localThrottled, 3);
+      ASSERT_EQ(stats.globalThrottled, 3);
+    }
+    ASSERT_EQ(stats.backOffDelay.count(), 6);
+  }
+}
+
+TEST_F(ThrottlerTest, fuzz) {
+  const uint64_t minThrottleBackoffMs = 1;
+  const uint64_t maxThrottleBackoffMs = 8;
+  const double backoffScaleFactor = 2.0;
+  const uint32_t minLocalThrottledSignals = 10;
+  const uint32_t minGlobalThrottledSignals = 20;
+  const uint32_t maxCacheEntries = 64;
+  const uint32_t cacheTTLMs = 10;
+  Throttler::testingReset();
+  Throttler::init(Throttler::Config(
+      true,
+      minThrottleBackoffMs,
+      maxThrottleBackoffMs,
+      backoffScaleFactor,
+      minLocalThrottledSignals,
+      minGlobalThrottledSignals,
+      maxCacheEntries,
+      cacheTTLMs));
+  auto* instance = Throttler::instance();
+
+  const auto seed = getCurrentTimeMs();
+  LOG(INFO) << "Random seed: " << getCurrentTimeMs();
+
+  const int numDirectories = 4096;
+  std::vector<std::string> directories;
+  directories.reserve(numDirectories);
+  for (int i = 0; i < numDirectories; ++i) {
+    directories.emplace_back(fmt::format("fuzz-{}", i));
+  }
+  const int numClusters = 128;
+  std::vector<std::string> clusters;
+  clusters.reserve(numClusters);
+  for (int i = 0; i < numClusters; ++i) {
+    clusters.emplace_back(fmt::format("fuzz-{}", i));
+  }
+
+  std::atomic_bool stopped{false};
+
+  const int numThreads = 64;
+  std::vector<std::thread> threads;
+  threads.reserve(numThreads);
+  for (int i = 0; i < numThreads; ++i) {
+    threads.emplace_back([&]() {
+      folly::Random::DefaultGenerator rng(seed);
+      while (!stopped) {
+        const Throttler::SignalType type = folly::Random::oneIn(3)
+            ? Throttler::SignalType::kGlobal
+            : Throttler::SignalType::kLocal;
+        const int directoryIndex = folly::Random::rand32(rng) % numDirectories;
+        const int clusterIndex = directoryIndex % numClusters;
+        instance->throttleBackoff(
+            type, clusters[clusterIndex], directories[directoryIndex]);
+      }
+    });
+  }
+
+  // Test for 5 seconds.
+  std::this_thread::sleep_for(std::chrono::seconds(5)); // NOLINT
+  stopped = true;
+  for (auto& thread : threads) {
+    thread.join();
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/TypeTests.cpp b/velox/dwio/common/tests/TypeTests.cpp
index f4ad3f635259f..d33673daca3ab 100644
--- a/velox/dwio/common/tests/TypeTests.cpp
+++ b/velox/dwio/common/tests/TypeTests.cpp
@@ -29,6 +29,28 @@ using namespace facebook::velox::dwio::common::typeutils;
 using facebook::velox::type::fbhive::HiveTypeParser;
 using facebook::velox::type::fbhive::HiveTypeSerializer;
 
+void assertEqualTypeWithId(
+    std::shared_ptr<const TypeWithId>& actual,
+    std::shared_ptr<const TypeWithId>& expected) {
+  EXPECT_EQ(actual->size(), expected->size());
+  for (auto idx = 0; idx < actual->size(); idx++) {
+    auto actualTypeChild = actual->childAt(idx);
+    auto expectedTypeChild = expected->childAt(idx);
+    EXPECT_TRUE(actualTypeChild->type()->kindEquals(expectedTypeChild->type()));
+    EXPECT_EQ(actualTypeChild->id(), expectedTypeChild->id());
+    EXPECT_EQ(actualTypeChild->column(), expectedTypeChild->column());
+    assertEqualTypeWithId(actualTypeChild, expectedTypeChild);
+  }
+}
+
+void assertValidTypeWithId(
+    const std::shared_ptr<const TypeWithId>& typeWithId) {
+  for (auto idx = 0; idx < typeWithId->size(); idx++) {
+    EXPECT_EQ(typeWithId->childAt(idx)->parent(), typeWithId.get());
+    assertValidTypeWithId(typeWithId->childAt(idx));
+  }
+}
+
 TEST(TestType, selectedType) {
   auto type = HiveTypeParser().parse(
       "struct<col0:tinyint,col1:smallint,col2:array<string>,"
@@ -39,15 +61,31 @@ TEST(TestType, selectedType) {
       "col3:map<float,double>,col4:float,"
       "col5:int,col6:bigint,col7:string>",
       HiveTypeSerializer::serialize(type).c_str());
-  auto typeWithId = TypeWithId::create(type);
+  std::shared_ptr<const TypeWithId> typeWithId = TypeWithId::create(type);
   EXPECT_EQ(0, typeWithId->id());
   EXPECT_EQ(11, typeWithId->maxId());
 
+  auto copySelector = [](size_t index) { return true; };
+
+  // The following two lines verify that the original type tree's children are
+  // not re-parented by the buildSelectedType method when copying. If it is
+  // re-parented, then this test would crash with SIGSEGV. The return type is
+  // deliberately ignored so the copied type will be deallocated upon return.
+  buildSelectedType(typeWithId, copySelector);
+  EXPECT_EQ(typeWithId->childAt(1)->parent()->type()->kind(), TypeKind::ROW);
+
+  auto cutType = buildSelectedType(typeWithId, copySelector);
+  assertEqualTypeWithId(cutType, typeWithId);
+  assertValidTypeWithId(typeWithId);
+  assertValidTypeWithId(cutType);
+
   std::vector<bool> selected(12);
   selected[0] = true;
   selected[2] = true;
   auto selector = [&selected](size_t index) { return selected[index]; };
-  auto cutType = buildSelectedType(typeWithId, selector);
+  cutType = buildSelectedType(typeWithId, selector);
+  assertValidTypeWithId(typeWithId);
+  assertValidTypeWithId(cutType);
   EXPECT_STREQ(
       "struct<col1:smallint>",
       HiveTypeSerializer::serialize(cutType->type()).c_str());
@@ -57,6 +95,8 @@ TEST(TestType, selectedType) {
 
   selected.assign(12, true);
   cutType = buildSelectedType(typeWithId, selector);
+  assertValidTypeWithId(typeWithId);
+  assertValidTypeWithId(cutType);
   EXPECT_STREQ(
       "struct<col0:tinyint,col1:smallint,col2:array<string>,"
       "col3:map<float,double>,col4:float,"
@@ -69,6 +109,8 @@ TEST(TestType, selectedType) {
   selected[0] = true;
   selected[8] = true;
   cutType = buildSelectedType(typeWithId, selector);
+  assertValidTypeWithId(typeWithId);
+  assertValidTypeWithId(cutType);
   EXPECT_STREQ(
       "struct<col4:float>",
       HiveTypeSerializer::serialize(cutType->type()).c_str());
@@ -91,6 +133,8 @@ TEST(TestType, selectedType) {
   selected[3] = true;
   selected[4] = true;
   cutType = buildSelectedType(typeWithId, selector);
+  assertValidTypeWithId(typeWithId);
+  assertValidTypeWithId(cutType);
   EXPECT_STREQ(
       "struct<col2:array<string>>",
       HiveTypeSerializer::serialize(cutType->type()).c_str());
@@ -106,6 +150,8 @@ TEST(TestType, selectedType) {
   selected[6] = true;
   selected[7] = true;
   cutType = buildSelectedType(typeWithId, selector);
+  assertValidTypeWithId(typeWithId);
+  assertValidTypeWithId(cutType);
   EXPECT_STREQ(
       "struct<col3:map<float,double>>",
       HiveTypeSerializer::serialize(cutType->type()).c_str());
@@ -135,6 +181,9 @@ TEST(TestType, selectedType) {
   selected[1] = true;
   selected[11] = true;
   cutType = buildSelectedType(typeWithId, selector);
+  assertValidTypeWithId(typeWithId);
+  assertValidTypeWithId(cutType);
+
   EXPECT_STREQ(
       "struct<col0:tinyint,col7:string>",
       HiveTypeSerializer::serialize(cutType->type()).c_str());
diff --git a/velox/dwio/common/tests/UnitLoaderToolsTests.cpp b/velox/dwio/common/tests/UnitLoaderToolsTests.cpp
new file mode 100644
index 0000000000000..36707554ad850
--- /dev/null
+++ b/velox/dwio/common/tests/UnitLoaderToolsTests.cpp
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "velox/dwio/common/UnitLoaderTools.h"
+
+using namespace ::testing;
+using namespace ::facebook::velox::dwio::common;
+using namespace ::facebook::velox::dwio::common::unit_loader_tools;
+
+TEST(UnitLoaderToolsTests, NoCallbacksCreated) {
+  std::atomic_size_t callCount = 0;
+  {
+    CallbackOnLastSignal callback([&callCount]() { ++callCount; });
+    EXPECT_EQ(callCount, 0);
+  }
+  EXPECT_EQ(callCount, 1);
+}
+
+TEST(UnitLoaderToolsTests, SupportsNullCallbacks) {
+  CallbackOnLastSignal callback(nullptr);
+  auto cb = callback.getCallback();
+  EXPECT_TRUE(cb == nullptr);
+}
+
+TEST(UnitLoaderToolsTests, NoExplicitCalls) {
+  std::atomic_size_t callCount = 0;
+  {
+    CallbackOnLastSignal callback([&callCount]() { ++callCount; });
+    EXPECT_EQ(callCount, 0);
+    {
+      auto c1 = callback.getCallback();
+      auto c4 = callback.getCallback();
+      EXPECT_EQ(callCount, 0);
+
+      auto c2 = std::move(c1);
+      auto c3(c2);
+      EXPECT_EQ(callCount, 0);
+
+      auto c5 = std::move(c4);
+      auto c6(c5);
+      EXPECT_EQ(callCount, 0);
+    }
+    EXPECT_EQ(callCount, 1);
+  }
+  EXPECT_EQ(callCount, 1);
+}
+
+TEST(UnitLoaderToolsTests, NoExplicitCallsFactoryDeletedFirst) {
+  std::atomic_size_t callCount = 0;
+  {
+    std::function<void()> c1, c2;
+    {
+      CallbackOnLastSignal callback([&callCount]() { ++callCount; });
+      EXPECT_EQ(callCount, 0);
+
+      c1 = callback.getCallback();
+      c2 = callback.getCallback();
+      EXPECT_EQ(callCount, 0);
+    }
+    EXPECT_EQ(callCount, 0);
+  }
+  EXPECT_EQ(callCount, 1);
+}
+
+TEST(UnitLoaderToolsTests, ExplicitCalls) {
+  std::atomic_size_t callCount = 0;
+  {
+    CallbackOnLastSignal callback([&callCount]() { ++callCount; });
+    EXPECT_EQ(callCount, 0);
+    {
+      auto c1 = callback.getCallback();
+      auto c4 = callback.getCallback();
+      EXPECT_EQ(callCount, 0);
+
+      c1();
+      auto c2 = std::move(c1);
+      c2();
+      auto c3(c2);
+      c3();
+      EXPECT_EQ(callCount, 0);
+
+      c4();
+      EXPECT_EQ(callCount, 1);
+      auto c5 = std::move(c4);
+      c5();
+      auto c6(c2);
+      c6();
+      EXPECT_EQ(callCount, 1);
+    }
+    EXPECT_EQ(callCount, 1);
+  }
+  EXPECT_EQ(callCount, 1);
+}
+
+TEST(UnitLoaderToolsTests, WillOnlyCallbackOnce) {
+  std::atomic_size_t callCount = 0;
+  {
+    CallbackOnLastSignal callback([&callCount]() { ++callCount; });
+    EXPECT_EQ(callCount, 0);
+    {
+      auto c1 = callback.getCallback();
+      auto c4 = callback.getCallback();
+      EXPECT_EQ(callCount, 0);
+
+      c1();
+      auto c2 = std::move(c1);
+      c2();
+      auto c3(c2);
+      c3();
+      EXPECT_EQ(callCount, 0);
+
+      c4();
+      EXPECT_EQ(callCount, 1);
+      auto c5 = std::move(c4);
+      c5();
+      auto c6(c2);
+      c6();
+      EXPECT_EQ(callCount, 1);
+
+      // This won't emit a new call
+      auto c7 = callback.getCallback();
+      c7();
+      EXPECT_EQ(callCount, 1);
+    }
+    EXPECT_EQ(callCount, 1);
+  }
+  EXPECT_EQ(callCount, 1);
+}
+
+TEST(UnitLoaderToolsTests, HowMuchToSkip) {
+  // Helpers
+  auto testSkip = [](uint64_t rowsToSkip, std::vector<uint64_t> rowCount) {
+    return howMuchToSkip(rowsToSkip, rowCount.cbegin(), rowCount.cend());
+  };
+
+  auto result = [](uint32_t unitsToSkip, uint64_t rowsToSkip) {
+    return std::make_pair(unitsToSkip, rowsToSkip);
+  };
+
+  static const char* kErrorMessage =
+      "Can't skip more rows than all the rows in all the units";
+
+  // Test cases
+  EXPECT_EQ(testSkip(0, {}), result(0, 0));
+  EXPECT_THAT(
+      [&]() { testSkip(1, {}); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr(kErrorMessage))));
+
+  EXPECT_EQ(testSkip(0, {0}), result(1, 0));
+  EXPECT_THAT(
+      [&]() { testSkip(1, {0}); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr(kErrorMessage))));
+
+  EXPECT_EQ(testSkip(0, {1}), result(0, 0));
+  EXPECT_EQ(testSkip(1, {1}), result(1, 0));
+  EXPECT_THAT(
+      [&]() { testSkip(2, {1}); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr(kErrorMessage))));
+
+  std::vector<uint64_t> rowCount = {2, 1, 2};
+  EXPECT_EQ(testSkip(0, rowCount), result(0, 0));
+  EXPECT_EQ(testSkip(1, rowCount), result(0, 1));
+  EXPECT_EQ(testSkip(2, rowCount), result(1, 0));
+  EXPECT_EQ(testSkip(3, rowCount), result(2, 0));
+  EXPECT_EQ(testSkip(4, rowCount), result(2, 1));
+  EXPECT_EQ(testSkip(5, rowCount), result(3, 0));
+  EXPECT_THAT(
+      [&]() { testSkip(6, rowCount); },
+      Throws<facebook::velox::VeloxRuntimeError>(Property(
+          &facebook::velox::VeloxRuntimeError::message,
+          HasSubstr(kErrorMessage))));
+}
diff --git a/velox/dwio/common/tests/WriterTest.cpp b/velox/dwio/common/tests/WriterTest.cpp
new file mode 100644
index 0000000000000..b35f1ba09fbf0
--- /dev/null
+++ b/velox/dwio/common/tests/WriterTest.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/Writer.h"
+#include <gtest/gtest.h>
+
+using namespace ::testing;
+
+namespace facebook::velox::dwio::common {
+namespace {
+TEST(WriterTest, stateString) {
+  ASSERT_EQ(Writer::stateString(Writer::State::kInit), "INIT");
+  ASSERT_EQ(Writer::stateString(Writer::State::kRunning), "RUNNING");
+  ASSERT_EQ(Writer::stateString(Writer::State::kClosed), "CLOSED");
+  ASSERT_EQ(Writer::stateString(Writer::State::kAborted), "ABORTED");
+}
+} // namespace
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/utils/BatchMaker.cpp b/velox/dwio/common/tests/utils/BatchMaker.cpp
index a458a5031c017..603f363ca820f 100644
--- a/velox/dwio/common/tests/utils/BatchMaker.cpp
+++ b/velox/dwio/common/tests/utils/BatchMaker.cpp
@@ -48,17 +48,14 @@ VectorPtr createScalar(
   BufferPtr values = AlignedBuffer::allocate<T>(size, &pool);
   auto valuesPtr = values->asMutableRange<T>();
 
-  BufferPtr nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), &pool);
+  BufferPtr nulls = allocateNulls(size, &pool);
   auto* nullsPtr = nulls->asMutable<uint64_t>();
 
-  size_t nullCount = 0;
   for (size_t i = 0; i < size; ++i) {
     auto notNull = isNotNull(gen, i, isNullAt);
     bits::setNull(nullsPtr, i, !notNull);
     if (notNull) {
       valuesPtr[i] = val();
-    } else {
-      nullCount++;
     }
   }
 
@@ -68,7 +65,7 @@ VectorPtr createScalar(
 
 template <TypeKind KIND>
 VectorPtr BatchMaker::createVector(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t /* unused */,
     memory::MemoryPool& /* unused */,
     std::mt19937& /* unused */,
@@ -78,7 +75,7 @@ VectorPtr BatchMaker::createVector(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::BOOLEAN>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -93,7 +90,7 @@ VectorPtr BatchMaker::createVector<TypeKind::BOOLEAN>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::TINYINT>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -108,7 +105,7 @@ VectorPtr BatchMaker::createVector<TypeKind::TINYINT>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::SMALLINT>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -123,7 +120,7 @@ VectorPtr BatchMaker::createVector<TypeKind::SMALLINT>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::INTEGER>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& type,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -133,12 +130,13 @@ VectorPtr BatchMaker::createVector<TypeKind::INTEGER>(
       gen,
       [&gen]() { return static_cast<int32_t>(Random::rand32(gen)); },
       pool,
-      isNullAt);
+      isNullAt,
+      type);
 }
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::BIGINT>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /*type*/,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -149,7 +147,7 @@ VectorPtr BatchMaker::createVector<TypeKind::BIGINT>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::REAL>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -164,7 +162,7 @@ VectorPtr BatchMaker::createVector<TypeKind::REAL>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::DOUBLE>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -179,16 +177,24 @@ VectorPtr BatchMaker::createVector<TypeKind::DOUBLE>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::HUGEINT>(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
     std::function<bool(vector_size_t /*index*/)> isNullAt) {
+  int bitsToMove = 0;
+  // Generate proper bits of random value for LongDecimalType tests.
+  if (type->isLongDecimal()) {
+    auto [precision, scale] = getDecimalPrecisionScale(*type);
+    // Round up if the bit number is not the multiples of 8 (1 byte).
+    bitsToMove = 128 - ceil(log2(std::pow(10, precision)) / 8) * 8;
+  }
   return createScalar<int128_t>(
       size,
       gen,
-      [&gen]() {
-        return HugeInt::build(Random::rand32(gen), Random::rand32(gen));
+      [&gen, bitsToMove]() {
+        return HugeInt::build(Random::rand64(gen), Random::rand64(gen)) >>
+            bitsToMove;
       },
       pool,
       isNullAt,
@@ -241,7 +247,7 @@ VectorPtr createBinary(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::VARCHAR>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -251,7 +257,7 @@ VectorPtr BatchMaker::createVector<TypeKind::VARCHAR>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::VARBINARY>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -261,7 +267,7 @@ VectorPtr BatchMaker::createVector<TypeKind::VARBINARY>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::TIMESTAMP>(
-    const std::shared_ptr<const Type>& /* unused */,
+    const TypePtr& /* unused */,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -281,7 +287,7 @@ VectorPtr BatchMaker::createVector<TypeKind::TIMESTAMP>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::ROW>(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -289,7 +295,7 @@ VectorPtr BatchMaker::createVector<TypeKind::ROW>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::ARRAY>(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -297,14 +303,14 @@ VectorPtr BatchMaker::createVector<TypeKind::ARRAY>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::MAP>(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
     std::function<bool(vector_size_t /*index*/)> isNullAt);
 
 VectorPtr createRows(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     size_t size,
     bool allowNulls,
     MemoryPool& pool,
@@ -314,7 +320,7 @@ VectorPtr createRows(
   size_t nullCount = 0;
 
   if (allowNulls) {
-    nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), &pool);
+    nulls = allocateNulls(size, &pool);
     auto* nullsPtr = nulls->asMutable<uint64_t>();
     for (size_t i = 0; i < size; ++i) {
       auto notNull = isNotNull(gen, i, isNullAt);
@@ -345,7 +351,7 @@ VectorPtr createRows(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::ROW>(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
@@ -355,18 +361,18 @@ VectorPtr BatchMaker::createVector<TypeKind::ROW>(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::ARRAY>(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
     std::function<bool(vector_size_t /*index*/)> isNullAt) {
-  BufferPtr offsets = AlignedBuffer::allocate<int32_t>(size, &pool);
+  BufferPtr offsets = allocateOffsets(size, &pool);
   auto* offsetsPtr = offsets->asMutable<int32_t>();
 
-  BufferPtr lengths = AlignedBuffer::allocate<vector_size_t>(size, &pool);
+  BufferPtr lengths = allocateSizes(size, &pool);
   auto* lengthsPtr = lengths->asMutable<vector_size_t>();
 
-  BufferPtr nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), &pool);
+  BufferPtr nulls = allocateNulls(size, &pool);
   auto* nullsPtr = nulls->asMutable<uint64_t>();
 
   size_t nullCount = 0;
@@ -556,18 +562,18 @@ VectorPtr createMapKeys(
 
 template <>
 VectorPtr BatchMaker::createVector<TypeKind::MAP>(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     size_t size,
     MemoryPool& pool,
     std::mt19937& gen,
     std::function<bool(vector_size_t /*index*/)> isNullAt) {
-  BufferPtr offsets = AlignedBuffer::allocate<vector_size_t>(size, &pool);
+  BufferPtr offsets = allocateOffsets(size, &pool);
   auto* offsetsPtr = offsets->asMutable<vector_size_t>();
 
-  BufferPtr lengths = AlignedBuffer::allocate<vector_size_t>(size, &pool);
+  BufferPtr lengths = allocateSizes(size, &pool);
   auto* lengthsPtr = lengths->asMutable<vector_size_t>();
 
-  BufferPtr nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), &pool);
+  BufferPtr nulls = allocateNulls(size, &pool);
   auto* nullsPtr = nulls->asMutable<uint64_t>();
 
   size_t nullCount = 0;
@@ -605,7 +611,7 @@ VectorPtr BatchMaker::createVector<TypeKind::MAP>(
 }
 
 VectorPtr BatchMaker::createBatch(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     uint64_t capacity,
     MemoryPool& memoryPool,
     std::mt19937& gen,
@@ -617,7 +623,7 @@ VectorPtr BatchMaker::createBatch(
 }
 
 VectorPtr BatchMaker::createBatch(
-    const std::shared_ptr<const Type>& type,
+    const TypePtr& type,
     uint64_t capacity,
     MemoryPool& memoryPool,
     std::function<bool(vector_size_t /*index*/)> isNullAt,
diff --git a/velox/dwio/common/tests/utils/BatchMaker.h b/velox/dwio/common/tests/utils/BatchMaker.h
index 10588f30702d0..4a15cbbc4fc41 100644
--- a/velox/dwio/common/tests/utils/BatchMaker.h
+++ b/velox/dwio/common/tests/utils/BatchMaker.h
@@ -31,14 +31,14 @@ void propagateNullsRecursive(BaseVector& vector);
 
 struct BatchMaker {
   static VectorPtr createBatch(
-      const std::shared_ptr<const Type>& type,
+      const TypePtr& type,
       uint64_t capacity,
       memory::MemoryPool& memoryPool,
       std::mt19937& gen,
       std::function<bool(vector_size_t /*index*/)> isNullAt = nullptr);
 
   static VectorPtr createBatch(
-      const std::shared_ptr<const Type>& type,
+      const TypePtr& type,
       uint64_t capacity,
       memory::MemoryPool& memoryPool,
       std::function<bool(vector_size_t /*index*/)> isNullAt = nullptr,
@@ -46,7 +46,7 @@ struct BatchMaker {
 
   template <TypeKind KIND>
   static VectorPtr createVector(
-      const std::shared_ptr<const Type>& type,
+      const TypePtr& type,
       size_t size,
       memory::MemoryPool& pool,
       std::mt19937& gen,
@@ -54,7 +54,7 @@ struct BatchMaker {
 
   template <TypeKind KIND>
   static VectorPtr createVector(
-      const std::shared_ptr<const Type>& type,
+      const TypePtr& type,
       size_t size,
       memory::MemoryPool& pool,
       std::function<bool(vector_size_t /*index*/)> isNullAt = nullptr,
diff --git a/velox/dwio/common/tests/utils/CMakeLists.txt b/velox/dwio/common/tests/utils/CMakeLists.txt
index cc34ffe08ae9f..7b3a5722165df 100644
--- a/velox/dwio/common/tests/utils/CMakeLists.txt
+++ b/velox/dwio/common/tests/utils/CMakeLists.txt
@@ -12,19 +12,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_dwio_common_test_utils BatchMaker.cpp DataFiles.cpp
-                                         FilterGenerator.cpp DataSetBuilder.cpp)
+add_library(
+  velox_dwio_common_test_utils
+  BatchMaker.cpp
+  DataFiles.cpp
+  DataSetBuilder.cpp
+  FilterGenerator.cpp
+  UnitLoaderTestTools.cpp
+  E2EFilterTestBase.cpp)
 
 target_link_libraries(
   velox_dwio_common_test_utils
   Folly::folly
+  fmt::fmt
+  glog::glog
+  gflags::gflags
+  GTest::gtest
   velox_dwio_common
   velox_dwio_common_exception
   velox_exception
+  velox_functions_prestosql
   velox_memory
+  velox_parse_parser
   velox_type
   velox_type_fbhive
-  velox_vector)
+  velox_vector
+  velox_vector_test_lib)
 
 # older versions of GCC need it to allow std::filesystem
 if(CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9)
diff --git a/velox/dwio/common/tests/utils/DataSetBuilder.cpp b/velox/dwio/common/tests/utils/DataSetBuilder.cpp
index f300d602d19e9..07b6b245003ff 100644
--- a/velox/dwio/common/tests/utils/DataSetBuilder.cpp
+++ b/velox/dwio/common/tests/utils/DataSetBuilder.cpp
@@ -37,7 +37,8 @@ RowTypePtr DataSetBuilder::makeRowType(
 DataSetBuilder& DataSetBuilder::makeDataset(
     RowTypePtr rowType,
     const size_t batchCount,
-    const size_t numRows) {
+    const size_t numRows,
+    const bool withRecursiveNulls) {
   if (batches_) {
     batches_->clear();
   } else {
@@ -45,8 +46,18 @@ DataSetBuilder& DataSetBuilder::makeDataset(
   }
 
   for (size_t i = 0; i < batchCount; ++i) {
-    batches_->push_back(std::static_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType, numRows, pool_, nullptr, i)));
+    if (withRecursiveNulls) {
+      batches_->push_back(std::static_pointer_cast<RowVector>(
+          BatchMaker::createBatch(rowType, numRows, pool_, nullptr, i)));
+    } else {
+      batches_->push_back(
+          std::static_pointer_cast<RowVector>(BatchMaker::createBatch(
+              rowType,
+              numRows,
+              pool_,
+              [](vector_size_t /*index*/) { return false; },
+              i)));
+    }
   }
 
   return *this;
@@ -106,7 +117,7 @@ DataSetBuilder& DataSetBuilder::withAllNullsForField(
   for (RowVectorPtr batch : *batches_) {
     auto fieldValues = getChildBySubfield(batch.get(), field);
     SelectivityVector rows(fieldValues->size());
-    fieldValues->addNulls(nullptr, rows);
+    fieldValues->addNulls(rows);
   }
 
   return *this;
@@ -122,7 +133,7 @@ DataSetBuilder& DataSetBuilder::withNullsForField(
     if (nullsPercent == 0) {
       fieldValues->clearNulls(rows);
     } else if (nullsPercent >= 100) {
-      fieldValues->addNulls(nullptr, rows);
+      fieldValues->addNulls(rows);
     } else {
       std::vector<vector_size_t> nonNullRows =
           getSomeNonNullRowNumbers(fieldValues, 23);
diff --git a/velox/dwio/common/tests/utils/DataSetBuilder.h b/velox/dwio/common/tests/utils/DataSetBuilder.h
index d60dc158f7928..4893c28336f62 100644
--- a/velox/dwio/common/tests/utils/DataSetBuilder.h
+++ b/velox/dwio/common/tests/utils/DataSetBuilder.h
@@ -43,7 +43,8 @@ class DataSetBuilder {
   DataSetBuilder& makeDataset(
       RowTypePtr rowType,
       const size_t batchCount,
-      const size_t numRows);
+      const size_t numRows,
+      const bool withRecursiveNulls = true);
 
   // Adds high values to 'batches_' so that these values occur only in some row
   // groups. Tests skipping row groups based on row group stats.
@@ -115,6 +116,54 @@ class DataSetBuilder {
     return *this;
   }
 
+  template <typename T>
+  DataSetBuilder& withIntRleForField(const common::Subfield& field) {
+    constexpr int kMinRun = 5;
+    constexpr int kMaxRun = 101;
+    int remaining = 0;
+    T value;
+    auto vec = *batches_;
+    for (auto& batch : vec) {
+      auto numbers = dwio::common::getChildBySubfield(batch.get(), field)
+                         ->as<FlatVector<T>>();
+      for (auto row = 0; row < numbers->size(); ++row) {
+        if (numbers->isNullAt(row)) {
+          continue;
+        }
+        if (remaining == 0) {
+          value = numbers->valueAt(row);
+          remaining =
+              kMinRun + folly::Random::rand32(rng_) % (kMaxRun - kMinRun);
+        }
+        numbers->set(row, value);
+        --remaining;
+      }
+    }
+    return *this;
+  }
+
+  template <typename T>
+  DataSetBuilder& withIntMainlyConstantForField(const common::Subfield& field) {
+    for (auto& batch : *batches_) {
+      std::optional<T> value;
+      auto* numbers = dwio::common::getChildBySubfield(batch.get(), field)
+                          ->as<FlatVector<T>>();
+      for (auto row = 0; row < numbers->size(); ++row) {
+        if (numbers->isNullAt(row)) {
+          continue;
+        }
+        if (folly::Random::randDouble01(rng_) < 0.95) {
+          if (!value.has_value()) {
+            value = numbers->valueAt(row);
+          } else {
+            numbers->set(row, *value);
+          }
+        }
+      }
+    }
+    return *this;
+  }
+
   template <typename T>
   DataSetBuilder& withQuantizedFloatForField(
       const common::Subfield& field,
diff --git a/velox/dwio/common/tests/E2EFilterTestBase.cpp b/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
similarity index 95%
rename from velox/dwio/common/tests/E2EFilterTestBase.cpp
rename to velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
index fd04f523e3315..287d245c84085 100644
--- a/velox/dwio/common/tests/E2EFilterTestBase.cpp
+++ b/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/dwio/common/tests/E2EFilterTestBase.h"
+#include "velox/dwio/common/tests/utils/E2EFilterTestBase.h"
 
 #include "velox/dwio/common/tests/utils/DataSetBuilder.h"
 #include "velox/expression/Expr.h"
@@ -30,7 +30,6 @@
 // Set FLAGS_logtostderr = true to log messages to stderr instead of logfiles
 // Set FLAGS_timing_repeats = n to run timing filter tests n times
 DEFINE_int32(timing_repeats, 0, "Count of repeats for timing filter tests");
-DEFINE_bool(use_random_seed, false, "");
 
 namespace facebook::velox::dwio::common {
 
@@ -47,12 +46,14 @@ using velox::common::Subfield;
 
 std::vector<RowVectorPtr> E2EFilterTestBase::makeDataset(
     std::function<void()> customize,
-    bool forRowGroupSkip) {
+    bool forRowGroupSkip,
+    bool withRecursiveNulls) {
   if (!dataSetBuilder_) {
     dataSetBuilder_ = std::make_unique<DataSetBuilder>(*leafPool_, 0);
   }
 
-  dataSetBuilder_->makeDataset(rowType_, batchCount_, batchSize_);
+  dataSetBuilder_->makeDataset(
+      rowType_, batchCount_, batchSize_, withRecursiveNulls);
 
   if (forRowGroupSkip) {
     dataSetBuilder_->withRowGroupSpecificData(kRowsInGroup);
@@ -94,9 +95,8 @@ void E2EFilterTestBase::readWithoutFilter(
     uint64_t& time) {
   dwio::common::ReaderOptions readerOpts{leafPool_.get()};
   dwio::common::RowReaderOptions rowReaderOpts;
-  std::string_view data(sinkPtr_->data(), sinkPtr_->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), readerOpts.getMemoryPool());
+      std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
 
   // The spec must stay live over the lifetime of the reader.
@@ -111,7 +111,9 @@ void E2EFilterTestBase::readWithoutFilter(
     bool hasData;
     {
       MicrosecondTimer timer(&time);
-      hasData = rowReader->next(1000, resultBatch);
+      auto rowsScanned = rowReader->next(1000, resultBatch);
+      VLOG(1) << "rowsScanned=" << rowsScanned;
+      hasData = rowsScanned > 0;
     }
     if (!hasData) {
       break;
@@ -146,13 +148,16 @@ void E2EFilterTestBase::readWithFilter(
     bool skipCheck) {
   dwio::common::ReaderOptions readerOpts{leafPool_.get()};
   dwio::common::RowReaderOptions rowReaderOpts;
-  std::string_view data(sinkPtr_->data(), sinkPtr_->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), readerOpts.getMemoryPool());
+      std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
 
   // The spec must stay live over the lifetime of the reader.
   setUpRowReaderOptions(rowReaderOpts, spec);
+  VLOG(1) << "spec: " << spec->toString();
+  if (!mutationSpec.deletedRows.empty()) {
+    VLOG(1) << "numDeletedRows=" << mutationSpec.deletedRows.size();
+  }
   OwnershipChecker ownershipChecker;
   auto rowReader = reader->createRowReader(rowReaderOpts);
   runtimeStats_ = dwio::common::RuntimeStatistics();
@@ -190,6 +195,7 @@ void E2EFilterTestBase::readWithFilter(
       if (haveDelete) {
         mutation.deletedRows = isDeleted.data();
       }
+      VLOG(1) << "readSize=" << readSize;
       auto rowsScanned = rowReader->next(readSize, resultBatch, &mutation);
       ASSERT_EQ(rowsScanned, readSize);
       if (resultBatch->size() == 0) {
@@ -404,24 +410,21 @@ void E2EFilterTestBase::testScenario(
     std::function<void()> customize,
     bool wrapInStruct,
     const std::vector<std::string>& filterable,
-    int32_t numCombinations) {
+    int32_t numCombinations,
+    bool withRecursiveNulls) {
   rowType_ = DataSetBuilder::makeRowType(columns, wrapInStruct);
+  filterGenerator_ = std::make_unique<FilterGenerator>(rowType_, seed_);
 
-  uint32_t seed = 1;
-  if (FLAGS_use_random_seed) {
-    seed = folly::Random::secureRand32();
-    LOG(INFO) << "Random seed: " << seed;
-  }
-  filterGenerator_ = std::make_unique<FilterGenerator>(rowType_, seed);
-
-  auto batches = makeDataset(customize, false);
+  auto batches = makeDataset(customize, false, withRecursiveNulls);
   writeToMemory(rowType_, batches, false);
   testNoRowGroupSkip(batches, filterable, numCombinations);
   testPruningWithFilter(batches, filterable);
 
-  batches = makeDataset(customize, true);
-  writeToMemory(rowType_, batches, true);
-  testRowGroupSkip(batches, filterable);
+  if (testRowGroupSkip_) {
+    batches = makeDataset(customize, true, withRecursiveNulls);
+    writeToMemory(rowType_, batches, true);
+    testRowGroupSkip(batches, filterable);
+  }
 }
 
 void E2EFilterTestBase::testMetadataFilterImpl(
@@ -453,9 +456,8 @@ void E2EFilterTestBase::testMetadataFilterImpl(
   specC->setChannel(0);
   ReaderOptions readerOpts{leafPool_.get()};
   RowReaderOptions rowReaderOpts;
-  std::string_view data(sinkPtr_->data(), sinkPtr_->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), readerOpts.getMemoryPool());
+      std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
   setUpRowReaderOptions(rowReaderOpts, spec);
   rowReaderOpts.setMetadataFilter(metadataFilter);
@@ -501,8 +503,8 @@ void E2EFilterTestBase::testMetadataFilter() {
   test::VectorMaker vectorMaker(leafPool_.get());
   functions::prestosql::registerAllScalarFunctions();
   parse::registerTypeResolver();
-  core::QueryCtx queryCtx;
-  exec::SimpleExpressionEvaluator evaluator(&queryCtx, leafPool_.get());
+  auto queryCtx = core::QueryCtx::create();
+  exec::SimpleExpressionEvaluator evaluator(queryCtx.get(), leafPool_.get());
 
   // a: bigint, b: struct<c: bigint>
   std::vector<RowVectorPtr> batches;
@@ -650,9 +652,8 @@ void E2EFilterTestBase::testSubfieldsPruning() {
       ->setFilter(common::createBigintValues({1}, false));
   ReaderOptions readerOpts{leafPool_.get()};
   RowReaderOptions rowReaderOpts;
-  std::string_view data(sinkPtr_->data(), sinkPtr_->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), readerOpts.getMemoryPool());
+      std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
   setUpRowReaderOptions(rowReaderOpts, spec);
   auto rowReader = reader->createRowReader(rowReaderOpts);
@@ -715,9 +716,8 @@ void E2EFilterTestBase::testMutationCornerCases() {
   auto& rowType = batches[0]->type();
   writeToMemory(rowType, batches, false);
   ReaderOptions readerOpts{leafPool_.get()};
-  std::string_view data(sinkPtr_->data(), sinkPtr_->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), readerOpts.getMemoryPool());
+      std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
 
   // 1. Interleave batches with and without deletions.
diff --git a/velox/dwio/common/tests/E2EFilterTestBase.h b/velox/dwio/common/tests/utils/E2EFilterTestBase.h
similarity index 82%
rename from velox/dwio/common/tests/E2EFilterTestBase.h
rename to velox/dwio/common/tests/utils/E2EFilterTestBase.h
index 4d361c8f1fb70..d0659280b4f6b 100644
--- a/velox/dwio/common/tests/E2EFilterTestBase.h
+++ b/velox/dwio/common/tests/utils/E2EFilterTestBase.h
@@ -39,22 +39,42 @@ class TestingHook : public ValueHook {
  public:
   explicit TestingHook(FlatVector<T>* result) : result_(result) {}
 
-  void addValue(vector_size_t row, const void* value) override {
-    result_->set(row, *reinterpret_cast<const T*>(value));
+  void addValue(vector_size_t row, int64_t value) override {
+    if constexpr (std::is_integral_v<T>) {
+      result_->set(row, value);
+    } else {
+      VELOX_FAIL();
+    }
+  }
+
+  void addValue(vector_size_t row, float value) override {
+    if constexpr (std::is_same_v<T, float>) {
+      result_->set(row, value);
+    } else {
+      VELOX_FAIL();
+    }
+  }
+
+  void addValue(vector_size_t row, double value) override {
+    if constexpr (std::is_same_v<T, double>) {
+      result_->set(row, value);
+    } else {
+      VELOX_FAIL();
+    }
+  }
+
+  void addValue(vector_size_t row, folly::StringPiece value) override {
+    if constexpr (std::is_same_v<T, StringView>) {
+      result_->set(row, StringView(value));
+    } else {
+      VELOX_FAIL();
+    }
   }
 
  private:
   FlatVector<T>* result_;
 };
 
-template <>
-inline void TestingHook<StringView>::addValue(
-    vector_size_t row,
-    const void* value) {
-  result_->set(
-      row, StringView(*reinterpret_cast<const folly::StringPiece*>(value)));
-}
-
 // Utility for checking that a subsequent batch of output does not
 // overwrite internals of a possibly retained previous batch.
 class OwnershipChecker {
@@ -78,19 +98,36 @@ class E2EFilterTestBase : public testing::Test {
  protected:
   static constexpr int32_t kRowsInGroup = 10'000;
 
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  static bool useRandomSeed() {
+    // Check environment variable because `buck test` does not allow pass in
+    // command line arguments.
+    const char* env = getenv("VELOX_TEST_USE_RANDOM_SEED");
+    return !env ? false : folly::to<bool>(env);
+  }
+
   void SetUp() override {
-    rootPool_ = memory::defaultMemoryManager().addRootPool("E2EFilterTestBase");
+    rootPool_ = memory::memoryManager()->addRootPool("E2EFilterTestBase");
     leafPool_ = rootPool_->addLeafChild("E2EFilterTestBase");
+    if (useRandomSeed()) {
+      seed_ = folly::Random::secureRand32();
+      LOG(INFO) << "Random seed: " << seed_;
+    }
   }
 
   static bool typeKindSupportsValueHook(TypeKind kind) {
     return kind != TypeKind::TIMESTAMP && kind != TypeKind::ARRAY &&
-        kind != TypeKind::ROW && kind != TypeKind::MAP;
+        kind != TypeKind::ROW && kind != TypeKind::MAP &&
+        kind != TypeKind::HUGEINT;
   }
 
   std::vector<RowVectorPtr> makeDataset(
       std::function<void()> customize,
-      bool forRowGroupSkip);
+      bool forRowGroupSkip,
+      bool withRecursiveNulls);
 
   void makeAllNulls(const std::string& fieldName);
 
@@ -124,6 +161,16 @@ class E2EFilterTestBase : public testing::Test {
         keepNulls);
   }
 
+  template <typename T>
+  void makeIntRle(const std::string& fieldName) {
+    dataSetBuilder_->withIntRleForField<T>(Subfield(fieldName));
+  }
+
+  template <typename T>
+  void makeIntMainlyConstant(const std::string& fieldName) {
+    dataSetBuilder_->withIntMainlyConstantForField<T>(Subfield(fieldName));
+  }
+
   template <typename T>
   void makeQuantizedFloat(
       const std::string& fieldName,
@@ -180,6 +227,7 @@ class E2EFilterTestBase : public testing::Test {
       dwio::common::RowReaderOptions& opts,
       const std::shared_ptr<ScanSpec>& spec) {
     opts.setScanSpec(spec);
+    opts.setTimestampPrecision(TimestampPrecision::kNanoseconds);
   }
 
   void readWithoutFilter(
@@ -210,7 +258,7 @@ class E2EFilterTestBase : public testing::Test {
     for (int32_t i = 0; i < 5 && i < batch->size(); ++i) {
       rows.push_back(i);
     }
-    for (int32_t i = 5; i < 5 && i < batch->size(); i += 2) {
+    for (int32_t i = 5; i < batch->size(); i += 2) {
       rows.push_back(i);
     }
     auto result = std::static_pointer_cast<FlatVector<T>>(
@@ -271,7 +319,8 @@ class E2EFilterTestBase : public testing::Test {
       std::function<void()> customize,
       bool wrapInStruct,
       const std::vector<std::string>& filterable,
-      int32_t numCombinations);
+      int32_t numCombinations,
+      bool withRecursiveNulls = true);
 
  private:
   void testMetadataFilterImpl(
@@ -310,7 +359,7 @@ class E2EFilterTestBase : public testing::Test {
   std::shared_ptr<memory::MemoryPool> rootPool_;
   std::shared_ptr<memory::MemoryPool> leafPool_;
   std::shared_ptr<const RowType> rowType_;
-  dwio::common::MemorySink* sinkPtr_;
+  std::string sinkData_;
   bool useVInts_ = true;
   dwio::common::RuntimeStatistics runtimeStats_;
   // Number of calls to flush policy between starting new stripes.
@@ -319,6 +368,8 @@ class E2EFilterTestBase : public testing::Test {
   std::vector<int32_t> readSizes_;
   int32_t batchCount_ = kBatchCount;
   int32_t batchSize_ = kBatchSize;
+  bool testRowGroupSkip_ = true;
+  uint32_t seed_ = 1;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/utils/FilterGenerator.cpp b/velox/dwio/common/tests/utils/FilterGenerator.cpp
index cae952986c528..78ed8c790b5b7 100644
--- a/velox/dwio/common/tests/utils/FilterGenerator.cpp
+++ b/velox/dwio/common/tests/utils/FilterGenerator.cpp
@@ -46,7 +46,7 @@ VectorPtr getChildBySubfield(
     const RowTypePtr& rootType) {
   const Type* type = rootType ? rootType.get() : rowVector->type().get();
   auto& path = subfield.path();
-  VELOX_CHECK(!path.empty())
+  VELOX_CHECK(!path.empty());
   auto* rowType = &type->asRow();
   auto* field = dynamic_cast<const Subfield::NestedField*>(path[0].get());
   VELOX_CHECK(field);
@@ -158,6 +158,19 @@ std::unique_ptr<Filter> ColumnStats<double>::makeRangeFilter(
       filterSpec.selectPct > 25);
 }
 
+template <>
+std::unique_ptr<Filter> ColumnStats<int128_t>::makeRangeFilter(
+    const FilterSpec& filterSpec) {
+  if (values_.empty()) {
+    return std::make_unique<velox::common::IsNull>();
+  }
+  int128_t lower = valueAtPct(filterSpec.startPct);
+  int128_t upper = valueAtPct(filterSpec.startPct + filterSpec.selectPct);
+
+  return std::make_unique<velox::common::HugeintRange>(
+      lower, upper, filterSpec.allowNulls_);
+}
+
 template <>
 std::unique_ptr<Filter> ColumnStats<StringView>::makeRangeFilter(
     const FilterSpec& filterSpec) {
@@ -165,6 +178,40 @@ std::unique_ptr<Filter> ColumnStats<StringView>::makeRangeFilter(
     return std::make_unique<velox::common::IsNull>();
   }
 
+  int32_t lowerIndex;
+  int32_t upperIndex;
+  StringView lower = valueAtPct(filterSpec.startPct, &lowerIndex);
+  StringView upper =
+      valueAtPct(filterSpec.startPct + filterSpec.selectPct, &upperIndex);
+
+  // When the filter rate is 0%, we should not allow the value at the boundary.
+  if (filterSpec.selectPct == 0) {
+    return std::make_unique<velox::common::BytesRange>(
+        std::string(lower),
+        false,
+        true,
+        std::string(upper),
+        false,
+        true,
+        filterSpec.allowNulls_);
+  }
+  return std::make_unique<velox::common::BytesRange>(
+      std::string(lower),
+      false,
+      false,
+      std::string(upper),
+      false,
+      false,
+      filterSpec.allowNulls_);
+}
+
+template <>
+std::unique_ptr<Filter> ColumnStats<StringView>::makeRandomFilter(
+    const FilterSpec& filterSpec) {
+  if (values_.empty()) {
+    return std::make_unique<velox::common::IsNull>();
+  }
+
   // used to determine if we can test a values filter reasonably
   int32_t lowerIndex;
   int32_t upperIndex;
@@ -452,6 +499,9 @@ SubfieldFilters FilterGenerator::makeSubfieldFilters(
       case TypeKind::BIGINT:
         stats = makeStats<TypeKind::BIGINT>(vector->type(), rowType_);
         break;
+      case TypeKind::HUGEINT:
+        stats = makeStats<TypeKind::HUGEINT>(vector->type(), rowType_);
+        break;
       case TypeKind::VARCHAR:
         stats = makeStats<TypeKind::VARCHAR>(vector->type(), rowType_);
         break;
diff --git a/velox/dwio/common/tests/utils/FilterGenerator.h b/velox/dwio/common/tests/utils/FilterGenerator.h
index bfc35b151d224..c0fdad28fa528 100644
--- a/velox/dwio/common/tests/utils/FilterGenerator.h
+++ b/velox/dwio/common/tests/utils/FilterGenerator.h
@@ -153,9 +153,16 @@ class ColumnStats : public AbstractColumnStats {
       case FilterKind::kIsNotNull:
         filter = std::make_unique<velox::common::IsNotNull>();
         break;
-      default:
+      case FilterKind::kBytesRange:
         filter = makeRangeFilter(filterSpec);
         break;
+      default:
+        if (type_->kind() == TypeKind::VARCHAR) {
+          filter = makeRandomFilter(filterSpec);
+        } else {
+          filter = makeRangeFilter(filterSpec);
+        }
+        break;
     }
 
     size_t numHits = 0;
@@ -334,6 +341,10 @@ class ColumnStats : public AbstractColumnStats {
         getIntegerValue(max), getIntegerValue(max), false);
   }
 
+  std::unique_ptr<Filter> makeRandomFilter(const FilterSpec& filterSpec) {
+    VELOX_FAIL("This method is only used in specific types.");
+  }
+
   // The sample size is 65536.
   static constexpr size_t kUniquesMask = 0xffff;
   std::vector<T> values_;
@@ -415,6 +426,10 @@ class ComplexColumnStats : public AbstractColumnStats {
     VELOX_FAIL("N/A in ComplexType");
   }
 
+  std::unique_ptr<Filter> makeRandomFilter(const FilterSpec&) {
+    VELOX_FAIL("N/A in ComplexType");
+  }
+
   std::unique_ptr<Filter> makeRowGroupSkipRangeFilter(
       const std::vector<RowVectorPtr>& batches,
       const Subfield& subfield) {
@@ -434,6 +449,14 @@ template <>
 std::unique_ptr<Filter> ColumnStats<double>::makeRangeFilter(
     const FilterSpec& filterSpec);
 
+template <>
+std::unique_ptr<Filter> ColumnStats<int128_t>::makeRangeFilter(
+    const FilterSpec& filterSpec);
+
+template <>
+std::unique_ptr<Filter> ColumnStats<StringView>::makeRandomFilter(
+    const FilterSpec& filterSpec);
+
 template <>
 std::unique_ptr<Filter> ColumnStats<StringView>::makeRangeFilter(
     const FilterSpec& filterSpec);
diff --git a/velox/dwio/common/tests/utils/MapBuilder.h b/velox/dwio/common/tests/utils/MapBuilder.h
index 300645a46d71d..b31e7d0e5d873 100644
--- a/velox/dwio/common/tests/utils/MapBuilder.h
+++ b/velox/dwio/common/tests/utils/MapBuilder.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 #include "velox/vector/ComplexVector.h"
 
@@ -55,7 +56,6 @@ class MapBuilder {
 
     BufferPtr valueNulls = allocateNulls(items, &pool);
     auto* valueNullsPtr = valueNulls->asMutable<uint64_t>();
-    size_t valueNullCount = 0;
 
     auto i = 0;
     auto offset = 0;
@@ -73,7 +73,6 @@ class MapBuilder {
             valuesPtr[offset] = *pair.second;
             bits::clearNull(valueNullsPtr, offset);
           } else {
-            valueNullCount++;
             bits::setNull(valueNullsPtr, offset);
           }
           ++offset;
diff --git a/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp b/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp
new file mode 100644
index 0000000000000..e2ec87ae605cd
--- /dev/null
+++ b/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/tests/utils/UnitLoaderTestTools.h"
+#include "velox/dwio/common/UnitLoaderTools.h"
+
+using facebook::velox::dwio::common::LoadUnit;
+
+namespace facebook::velox::dwio::common::test {
+
+ReaderMock::ReaderMock(
+    std::vector<uint64_t> rowsPerUnit,
+    std::vector<uint64_t> ioSizes,
+    UnitLoaderFactory& factory,
+    uint64_t rowsToSkip)
+    : rowsPerUnit_{std::move(rowsPerUnit)},
+      ioSizes_{std::move(ioSizes)},
+      unitsLoaded_(std::vector<std::atomic_bool>(rowsPerUnit_.size())),
+      loader_{factory.create(getUnits(), rowsToSkip)},
+      currentUnit_{0},
+      currentRowInUnit_{0} {
+  VELOX_CHECK(rowsPerUnit_.size() == ioSizes_.size());
+  auto [currentUnit, currentRowInUnit] = unit_loader_tools::howMuchToSkip(
+      rowsToSkip, rowsPerUnit_.cbegin(), rowsPerUnit_.cend());
+  currentUnit_ = currentUnit;
+  currentRowInUnit_ = currentRowInUnit;
+}
+
+bool ReaderMock::read(uint64_t maxRows) {
+  if (!loadUnit()) {
+    return false;
+  }
+  const auto rowsToRead =
+      std::min(maxRows, rowsPerUnit_[currentUnit_] - currentRowInUnit_);
+  loader_->onRead(currentUnit_, currentRowInUnit_, rowsToRead);
+  currentRowInUnit_ += rowsToRead;
+  return true;
+}
+
+void ReaderMock::seek(uint64_t rowNumber) {
+  uint64_t totalRows = 0;
+  uint64_t rowsLeft = rowNumber;
+  for (size_t unit = 0; unit < rowsPerUnit_.size(); ++unit) {
+    const uint64_t rowCount = rowsPerUnit_[unit];
+    if (rowsLeft < rowCount) {
+      currentUnit_ = unit;
+      currentRowInUnit_ = rowsLeft;
+      loader_->onSeek(currentUnit_, currentRowInUnit_);
+      return;
+    }
+    rowsLeft -= rowCount;
+    totalRows += rowCount;
+  }
+  VELOX_CHECK_EQ(
+      rowsLeft,
+      0,
+      "Can't seek to possition {} in file. Must be up to {}.",
+      rowNumber,
+      totalRows);
+}
+
+bool ReaderMock::loadUnit() {
+  VELOX_CHECK(currentRowInUnit_ <= rowsPerUnit_[currentUnit_]);
+  if (currentRowInUnit_ == rowsPerUnit_[currentUnit_]) {
+    currentRowInUnit_ = 0;
+    ++currentUnit_;
+    if (currentUnit_ >= rowsPerUnit_.size()) {
+      return false;
+    }
+  }
+  auto& unit = loader_->getLoadedUnit(currentUnit_);
+  auto& unitMock = dynamic_cast<LoadUnitMock&>(unit);
+  VELOX_CHECK(unitMock.isLoaded());
+  return true;
+}
+
+std::vector<std::unique_ptr<LoadUnit>> ReaderMock::getUnits() {
+  std::vector<std::unique_ptr<LoadUnit>> units;
+  for (size_t i = 0; i < rowsPerUnit_.size(); ++i) {
+    units.emplace_back(std::make_unique<LoadUnitMock>(
+        rowsPerUnit_[i], ioSizes_[i], unitsLoaded_, i));
+  }
+  return units;
+}
+
+std::vector<std::atomic_bool> getUnitsLoadedWithFalse(size_t count) {
+  std::vector<std::atomic_bool> unitsLoaded(count);
+  for (auto& unit : unitsLoaded) {
+    unit = false;
+  }
+  return unitsLoaded;
+}
+
+} // namespace facebook::velox::dwio::common::test
diff --git a/velox/dwio/common/tests/utils/UnitLoaderTestTools.h b/velox/dwio/common/tests/utils/UnitLoaderTestTools.h
new file mode 100644
index 0000000000000..9eae97f575c25
--- /dev/null
+++ b/velox/dwio/common/tests/utils/UnitLoaderTestTools.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/dwio/common/UnitLoader.h"
+
+namespace facebook::velox::dwio::common::test {
+
+class LoadUnitMock : public LoadUnit {
+ public:
+  LoadUnitMock(
+      uint64_t rowCount,
+      uint64_t ioSize,
+      std::vector<std::atomic_bool>& unitsLoaded,
+      size_t unitId)
+      : rowCount_{rowCount},
+        ioSize_{ioSize},
+        unitsLoaded_{unitsLoaded},
+        unitId_{unitId} {}
+
+  ~LoadUnitMock() override = default;
+
+  void load() override {
+    VELOX_CHECK(!isLoaded());
+    unitsLoaded_[unitId_] = true;
+  }
+
+  void unload() override {
+    VELOX_CHECK(isLoaded());
+    unitsLoaded_[unitId_] = false;
+  }
+
+  uint64_t getNumRows() override {
+    return rowCount_;
+  }
+
+  uint64_t getIoSize() override {
+    return ioSize_;
+  }
+
+  bool isLoaded() const {
+    return unitsLoaded_[unitId_];
+  }
+
+ private:
+  uint64_t rowCount_;
+  uint64_t ioSize_;
+  std::vector<std::atomic_bool>& unitsLoaded_;
+  size_t unitId_;
+};
+
+class ReaderMock {
+ public:
+  ReaderMock(
+      std::vector<uint64_t> rowsPerUnit,
+      std::vector<uint64_t> ioSizes,
+      UnitLoaderFactory& factory,
+      uint64_t rowsToSkip);
+
+  bool read(uint64_t maxRows);
+
+  void seek(uint64_t rowNumber);
+
+  std::vector<bool> unitsLoaded() const {
+    return {unitsLoaded_.begin(), unitsLoaded_.end()};
+  }
+
+ private:
+  bool loadUnit();
+
+  std::vector<std::unique_ptr<LoadUnit>> getUnits();
+
+  std::vector<uint64_t> rowsPerUnit_;
+  std::vector<uint64_t> ioSizes_;
+  std::vector<std::atomic_bool> unitsLoaded_;
+  std::unique_ptr<UnitLoader> loader_;
+  size_t currentUnit_;
+  size_t currentRowInUnit_;
+  std::optional<size_t> lastUnitLoaded_;
+};
+
+std::vector<std::atomic_bool> getUnitsLoadedWithFalse(size_t count);
+
+} // namespace facebook::velox::dwio::common::test
diff --git a/velox/dwio/dwrf/RegisterDwrfReader.h b/velox/dwio/dwrf/RegisterDwrfReader.h
new file mode 100644
index 0000000000000..ae15ac80965a3
--- /dev/null
+++ b/velox/dwio/dwrf/RegisterDwrfReader.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace facebook::velox::dwrf {
+
+void registerDwrfReaderFactory();
+
+void unregisterDwrfReaderFactory();
+
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/RegisterDwrfWriter.h b/velox/dwio/dwrf/RegisterDwrfWriter.h
new file mode 100644
index 0000000000000..6888da424887f
--- /dev/null
+++ b/velox/dwio/dwrf/RegisterDwrfWriter.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace facebook::velox::dwrf {
+
+void registerDwrfWriterFactory();
+
+void unregisterDwrfWriterFactory();
+
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/common/ByteRLE.cpp b/velox/dwio/dwrf/common/ByteRLE.cpp
index ba4b972b4d597..c07f96f87c7c8 100644
--- a/velox/dwio/dwrf/common/ByteRLE.cpp
+++ b/velox/dwio/dwrf/common/ByteRLE.cpp
@@ -340,56 +340,42 @@ std::unique_ptr<ByteRleEncoder> createBooleanRleEncoder(
 }
 
 void ByteRleDecoder::nextBuffer() {
+  VELOX_DCHECK_EQ(pendingSkip_, 0);
+
   int32_t bufferLength;
   const void* bufferPointer;
-  DWIO_ENSURE(
-      inputStream->Next(&bufferPointer, &bufferLength),
-      "bad read in nextBuffer ",
+  const auto ret = inputStream_->Next(&bufferPointer, &bufferLength);
+  VELOX_CHECK(
+      ret,
+      "bad read in nextBuffer {}, {}",
       encodingKey_.toString(),
-      ", ",
-      inputStream->getName());
-  bufferStart = static_cast<const char*>(bufferPointer);
-  bufferEnd = bufferStart + bufferLength;
+      inputStream_->getName());
+  bufferStart_ = static_cast<const char*>(bufferPointer);
+  bufferEnd_ = bufferStart_ + bufferLength;
 }
 
 void ByteRleDecoder::seekToRowGroup(
     dwio::common::PositionProvider& positionProvider) {
-  // move the input stream
-  inputStream->seekToPosition(positionProvider);
-  // force a re-read from the stream
-  bufferEnd = bufferStart;
-  // force reading a new header
-  remainingValues = 0;
-  // skip ahead the given number of records
-  ByteRleDecoder::skip(positionProvider.next());
+  // Move the input stream
+  inputStream_->seekToPosition(positionProvider);
+  // Force a re-read from the stream
+  bufferEnd_ = bufferStart_;
+  // Force reading a new header
+  remainingValues_ = 0;
+  // Skip ahead the given number of records
+  pendingSkip_ = positionProvider.next();
 }
 
 void ByteRleDecoder::skipBytes(size_t count) {
-  if (bufferStart < bufferEnd) {
-    size_t skipSize = std::min(
+  if (bufferStart_ < bufferEnd_) {
+    const size_t skipSize = std::min(
         static_cast<size_t>(count),
-        static_cast<size_t>(bufferEnd - bufferStart));
-    bufferStart += skipSize;
+        static_cast<size_t>(bufferEnd_ - bufferStart_));
+    bufferStart_ += skipSize;
     count -= skipSize;
   }
   if (count > 0) {
-    inputStream->Skip(count);
-  }
-}
-
-void ByteRleDecoder::skip(uint64_t numValues) {
-  while (numValues > 0) {
-    if (remainingValues == 0) {
-      readHeader();
-    }
-    size_t count = std::min(static_cast<size_t>(numValues), remainingValues);
-    remainingValues -= count;
-    numValues -= count;
-    // for literals we need to skip over count bytes, which may involve
-    // reading from the underlying stream
-    if (!repeating) {
-      skipBytes(count);
-    }
+    inputStream_->Skip(count);
   }
 }
 
@@ -397,30 +383,33 @@ void ByteRleDecoder::next(
     char* data,
     uint64_t numValues,
     const uint64_t* nulls) {
+  skipPending();
+
   uint64_t position = 0;
   // skip over null values
   while (nulls && position < numValues && bits::isBitNull(nulls, position)) {
-    position += 1;
+    ++position;
   }
+
   while (position < numValues) {
-    // if we are out of values, read more
-    if (remainingValues == 0) {
+    // If we are out of values, read more.
+    if (remainingValues_ == 0) {
       readHeader();
     }
-    // how many do we read out of this block?
-    size_t count =
-        std::min(static_cast<size_t>(numValues - position), remainingValues);
-    uint64_t consumed = 0;
-    if (repeating) {
+    // How many do we read out of this block?
+    const size_t count =
+        std::min(static_cast<size_t>(numValues - position), remainingValues_);
+    uint64_t consumed{0};
+    if (repeating_) {
       if (nulls) {
         for (uint64_t i = 0; i < count; ++i) {
           if (!bits::isBitNull(nulls, position + i)) {
-            data[position + i] = value;
-            consumed += 1;
+            data[position + i] = value_;
+            ++consumed;
           }
         }
       } else {
-        memset(data + position, value, count);
+        ::memset(data + position, value_, count);
         consumed = count;
       }
     } else {
@@ -428,30 +417,31 @@ void ByteRleDecoder::next(
         for (uint64_t i = 0; i < count; ++i) {
           if (!bits::isBitNull(nulls, position + i)) {
             data[position + i] = readByte();
-            consumed += 1;
+            ++consumed;
           }
         }
       } else {
         uint64_t i = 0;
         while (i < count) {
-          if (bufferStart == bufferEnd) {
+          if (bufferStart_ == bufferEnd_) {
             nextBuffer();
           }
-          uint64_t copyBytes = std::min(
+          const uint64_t copyBytes = std::min(
               static_cast<uint64_t>(count - i),
-              static_cast<uint64_t>(bufferEnd - bufferStart));
-          std::copy(bufferStart, bufferStart + copyBytes, data + position + i);
-          bufferStart += copyBytes;
+              static_cast<uint64_t>(bufferEnd_ - bufferStart_));
+          std::copy(
+              bufferStart_, bufferStart_ + copyBytes, data + position + i);
+          bufferStart_ += copyBytes;
           i += copyBytes;
         }
         consumed = count;
       }
     }
-    remainingValues -= consumed;
+    remainingValues_ -= consumed;
     position += count;
     // skip over any null values
     while (nulls && position < numValues && bits::isBitNull(nulls, position)) {
-      position += 1;
+      ++position;
     }
   }
 }
@@ -465,38 +455,34 @@ std::unique_ptr<ByteRleDecoder> createByteRleDecoder(
 void BooleanRleDecoder::seekToRowGroup(
     dwio::common::PositionProvider& positionProvider) {
   ByteRleDecoder::seekToRowGroup(positionProvider);
-  uint64_t consumed = positionProvider.next();
-  DWIO_ENSURE_LE(
+  const uint64_t consumed = positionProvider.next();
+  VELOX_CHECK_LE(
       consumed,
       8,
       "bad position ",
       encodingKey_.toString(),
       ", ",
-      inputStream->getName());
-  if (consumed != 0) {
-    remainingBits = 8 - consumed;
-    ByteRleDecoder::next(
-        reinterpret_cast<char*>(&reversedLastByte), 1, nullptr);
-    bits::reverseBits(&reversedLastByte, 1);
-  } else {
-    remainingBits = 0;
-  }
+      inputStream_->getName());
+  pendingSkip_ = 8 * pendingSkip_ + consumed;
+  remainingBits_ = 0;
 }
 
-void BooleanRleDecoder::skip(uint64_t numValues) {
-  if (numValues <= remainingBits) {
-    remainingBits -= numValues;
+void BooleanRleDecoder::skipPending() {
+  auto numValues = pendingSkip_;
+  pendingSkip_ = 0;
+  if (numValues <= remainingBits_) {
+    remainingBits_ -= numValues;
   } else {
-    numValues -= remainingBits;
-    remainingBits = 0;
-    uint64_t bytesSkipped = numValues / 8;
-    ByteRleDecoder::skip(bytesSkipped);
+    numValues -= remainingBits_;
+    remainingBits_ = 0;
+    pendingSkip_ = numValues / 8;
+    ByteRleDecoder::skipPending();
     uint64_t bitsToSkip = numValues % 8;
     if (bitsToSkip) {
       ByteRleDecoder::next(
-          reinterpret_cast<char*>(&reversedLastByte), 1, nullptr);
-      bits::reverseBits(&reversedLastByte, 1);
-      remainingBits = 8 - bitsToSkip;
+          reinterpret_cast<char*>(&reversedLastByte_), 1, nullptr);
+      bits::reverseBits(&reversedLastByte_, 1);
+      remainingBits_ = 8 - bitsToSkip;
     }
   }
 }
@@ -505,6 +491,8 @@ void BooleanRleDecoder::next(
     char* data,
     uint64_t numValues,
     const uint64_t* nulls) {
+  skipPending();
+
   uint64_t nonNulls = numValues;
   if (nulls) {
     nonNulls = bits::countNonNulls(nulls, 0, numValues);
@@ -512,62 +500,63 @@ void BooleanRleDecoder::next(
 
   const uint32_t outputBytes = (numValues + 7) / 8;
   if (nonNulls == 0) {
-    memset(data, 0, outputBytes);
+    ::memset(data, 0, outputBytes);
     return;
   }
 
-  if (remainingBits >= nonNulls) {
+  if (remainingBits_ >= nonNulls) {
     // The remaining bits from last round is enough for this round, and we don't
     // need to read new data. Since remainingBits should be less than or equal
     // to 8, therefore nonNulls must be less than 8.
-    data[0] = reversedLastByte >> (8 - remainingBits) & 0xff >> (8 - nonNulls);
-    remainingBits -= nonNulls;
+    data[0] =
+        reversedLastByte_ >> (8 - remainingBits_) & 0xff >> (8 - nonNulls);
+    remainingBits_ -= nonNulls;
   } else {
-    // Put the remaining bits, if any, into previousByte
-    uint8_t previousByte = 0;
-    if (remainingBits > 0) {
-      previousByte = reversedLastByte >> (8 - remainingBits);
+    // Put the remaining bits, if any, into previousByte.
+    uint8_t previousByte{0};
+    if (remainingBits_ > 0) {
+      previousByte = reversedLastByte_ >> (8 - remainingBits_);
     }
 
     // We need to read in (nonNulls - remainingBits) values and it must be a
     // positive number if nonNulls is positive
-    const uint64_t bytesRead = ((nonNulls - remainingBits) + 7) / 8;
+    const uint64_t bytesRead = bits::divRoundUp(nonNulls - remainingBits_, 8);
     ByteRleDecoder::next(data, bytesRead, nullptr);
 
     bits::reverseBits(reinterpret_cast<uint8_t*>(data), bytesRead);
-    reversedLastByte = data[bytesRead - 1];
+    reversedLastByte_ = data[bytesRead - 1];
 
     // Now shift the data in place
-    if (remainingBits > 0) {
+    if (remainingBits_ > 0) {
       uint64_t nonNullDWords = nonNulls / 64;
       // Shift 64 bits a time when there're enough data. Note that the data
       // buffer was created 64-bits aligned so there won't be performance
       // degradation shifting it in 64-bit unit.
-      for (uint64_t i = 0; i < nonNullDWords; i++) {
+      for (uint64_t i = 0; i < nonNullDWords; ++i) {
         uint64_t tmp = reinterpret_cast<uint64_t*>(data)[i];
         reinterpret_cast<uint64_t*>(data)[i] =
-            previousByte | tmp << remainingBits; // previousByte is LSB
-        previousByte = (tmp >> (64 - remainingBits)) & 0xff;
+            previousByte | tmp << remainingBits_; // previousByte is LSB
+        previousByte = (tmp >> (64 - remainingBits_)) & 0xff;
       }
 
       // Shift 8 bits a time for the remaining bits
       const uint64_t nonNullOutputBytes = (nonNulls + 7) / 8;
-      for (int32_t i = nonNullDWords * 8; i < nonNullOutputBytes; i++) {
+      for (int32_t i = nonNullDWords * 8; i < nonNullOutputBytes; ++i) {
         uint8_t tmp = data[i]; // already reversed
-        data[i] = previousByte | tmp << remainingBits; // previousByte is LSB
-        previousByte = tmp >> (8 - remainingBits);
+        data[i] = previousByte | tmp << remainingBits_; // previousByte is LSB
+        previousByte = tmp >> (8 - remainingBits_);
       }
     }
-    remainingBits = bytesRead * 8 + remainingBits - nonNulls;
+    remainingBits_ = bytesRead * 8 + remainingBits_ - nonNulls;
   }
 
-  // unpack data for nulls
+  // Unpack data for nulls.
   if (numValues > nonNulls) {
     bits::scatterBits(nonNulls, numValues, data, nulls, data);
   }
 
-  // clear the most significant bits in the last byte which will be processed in
-  // the next round
+  // Clear the most significant bits in the last byte which will be processed in
+  // the next round.
   data[outputBytes - 1] &= 0xff >> (outputBytes * 8 - numValues);
 }
 
diff --git a/velox/dwio/dwrf/common/ByteRLE.h b/velox/dwio/dwrf/common/ByteRLE.h
index 11aa3765c06fd..ea7ff790e843f 100644
--- a/velox/dwio/dwrf/common/ByteRLE.h
+++ b/velox/dwio/dwrf/common/ByteRLE.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <glog/logging.h>
 #include <memory>
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Nulls.h"
@@ -100,25 +101,29 @@ class ByteRleDecoder {
   ByteRleDecoder(
       std::unique_ptr<dwio::common::SeekableInputStream> input,
       EncodingKey ek)
-      : inputStream{std::move(input)},
-        remainingValues{0},
-        value{0},
-        bufferStart{nullptr},
-        bufferEnd{nullptr},
-        repeating{false},
-        encodingKey_{ek} {}
+      : inputStream_{std::move(input)},
+        encodingKey_{ek},
+        remainingValues_{0},
+        value_{0},
+        bufferStart_{nullptr},
+        bufferEnd_{nullptr},
+        repeating_{false} {}
 
   virtual ~ByteRleDecoder() = default;
 
   /**
-   * Seek to a specific row group.
+   * Seek to a specific row group.  Should not read the underlying input stream
+   * to avoid decoding same data multiple times.
    */
   virtual void seekToRowGroup(dwio::common::PositionProvider& positionProvider);
 
   /**
-   * Seek over a given number of values.
+   * Seek over a given number of values.  Does not decode the underlying input
+   * stream.
    */
-  virtual void skip(uint64_t numValues);
+  void skip(uint64_t numValues) {
+    pendingSkip_ += numValues;
+  }
 
   /**
    * Read a number of values into the batch.
@@ -133,35 +138,18 @@ class ByteRleDecoder {
    * Load the RowIndex values for the stream this is reading.
    */
   virtual size_t loadIndices(size_t startIndex) {
-    return inputStream->positionSize() + startIndex + 1;
+    return inputStream_->positionSize() + startIndex + 1;
   }
 
   void skipBytes(size_t bytes);
 
-  template <bool hasNulls>
-  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
-    if (hasNulls) {
-      numValues = bits::countNonNulls(nulls, current, current + numValues);
-    }
-    while (numValues > 0) {
-      if (remainingValues == 0) {
-        readHeader();
-      }
-      uint64_t count = std::min<int32_t>(numValues, remainingValues);
-      remainingValues -= count;
-      numValues -= count;
-      if (!repeating) {
-        skipBytes(count);
-      }
-    }
-  }
-
   template <bool hasNulls, typename Visitor>
   void readWithVisitor(const uint64_t* nulls, Visitor visitor) {
+    skipPending();
     int32_t current = visitor.start();
     skip<hasNulls>(current, 0, nulls);
-    int32_t toSkip;
-    bool atEnd = false;
+    int32_t toSkip{0};
+    bool atEnd{false};
     const bool allowNulls = hasNulls && visitor.allowNulls();
     for (;;) {
       if (hasNulls && allowNulls && bits::isBitNull(nulls, current)) {
@@ -177,16 +165,16 @@ class ByteRleDecoder {
           }
         }
         // We are at a non-null value on a row to visit.
-        if (!remainingValues) {
+        if (!remainingValues_) {
           readHeader();
         }
-        if (repeating) {
-          toSkip = visitor.process(value, atEnd);
+        if (repeating_) {
+          toSkip = visitor.process(value_, atEnd);
         } else {
-          value = readByte();
-          toSkip = visitor.process(value, atEnd);
+          value_ = readByte();
+          toSkip = visitor.process(value_, atEnd);
         }
-        --remainingValues;
+        --remainingValues_;
       }
       ++current;
       if (toSkip) {
@@ -203,31 +191,60 @@ class ByteRleDecoder {
   void nextBuffer();
 
   inline signed char readByte() {
-    if (bufferStart == bufferEnd) {
+    if (bufferStart_ == bufferEnd_) {
       nextBuffer();
     }
-    return *(bufferStart++);
+    return *(bufferStart_++);
   }
 
   inline void readHeader() {
-    signed char ch = readByte();
+    const signed char ch = readByte();
     if (ch < 0) {
-      remainingValues = static_cast<size_t>(-ch);
-      repeating = false;
+      remainingValues_ = static_cast<size_t>(-ch);
+      repeating_ = false;
     } else {
-      remainingValues = static_cast<size_t>(ch) + RLE_MINIMUM_REPEAT;
-      repeating = true;
-      value = readByte();
+      remainingValues_ = static_cast<size_t>(ch) + RLE_MINIMUM_REPEAT;
+      repeating_ = true;
+      value_ = readByte();
     }
   }
 
-  std::unique_ptr<dwio::common::SeekableInputStream> inputStream;
-  size_t remainingValues;
-  char value;
-  const char* bufferStart;
-  const char* bufferEnd;
-  bool repeating;
-  EncodingKey encodingKey_;
+  virtual void skipPending() {
+    auto numValues = pendingSkip_;
+    pendingSkip_ = 0;
+    while (numValues > 0) {
+      if (remainingValues_ == 0) {
+        readHeader();
+      }
+      const auto count = std::min<int64_t>(numValues, remainingValues_);
+      remainingValues_ -= count;
+      numValues -= count;
+      if (!repeating_) {
+        skipBytes(count);
+      }
+    }
+  }
+
+  const std::unique_ptr<dwio::common::SeekableInputStream> inputStream_;
+  const EncodingKey encodingKey_;
+  size_t remainingValues_;
+  char value_;
+  const char* bufferStart_;
+  const char* bufferEnd_;
+  bool repeating_;
+  int64_t pendingSkip_{0};
+
+ private:
+  template <bool kHasNulls>
+  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
+    if constexpr (kHasNulls) {
+      numValues = bits::countNonNulls(nulls, current, current + numValues);
+    }
+    pendingSkip_ += numValues;
+    if (pendingSkip_ > 0) {
+      skipPending();
+    }
+  }
 };
 
 /**
@@ -250,23 +267,25 @@ std::unique_ptr<ByteRleEncoder> createBooleanRleEncoder(
  */
 std::unique_ptr<ByteRleDecoder> createByteRleDecoder(
     std::unique_ptr<dwio::common::SeekableInputStream> input,
-    const EncodingKey& ek);
+    const EncodingKey& encodingKey);
 
 class BooleanRleDecoder : public ByteRleDecoder {
  public:
   BooleanRleDecoder(
       std::unique_ptr<dwio::common::SeekableInputStream> input,
-      const EncodingKey& ek)
-      : ByteRleDecoder{std::move(input), ek},
-        remainingBits{0},
-        reversedLastByte{0} {}
+      const EncodingKey& encodingKey)
+      : ByteRleDecoder{std::move(input), encodingKey},
+        remainingBits_{0},
+        reversedLastByte_{0} {}
 
   ~BooleanRleDecoder() override = default;
 
   void seekToRowGroup(
       dwio::common::PositionProvider& positionProvider) override;
 
-  void skip(uint64_t numValues) override;
+  void skip(uint64_t numValues) {
+    pendingSkip_ += numValues;
+  }
 
   void next(char* data, uint64_t numValues, const uint64_t* nulls) override;
 
@@ -274,22 +293,9 @@ class BooleanRleDecoder : public ByteRleDecoder {
     return ByteRleDecoder::loadIndices(startIndex) + 1;
   }
 
-  // Advances 'dataPosition' by 'numValue' non-nulls, where 'current'
-  // is the position in 'nulls'.
-  template <bool hasNulls>
-  void skip(
-      int32_t numValues,
-      int32_t current,
-      const uint64_t* nulls,
-      int32_t& dataPosition) {
-    if (hasNulls) {
-      numValues = bits::countNonNulls(nulls, current, current + numValues);
-    }
-    dataPosition += numValues;
-  }
-
   template <bool hasNulls, typename Visitor>
   void readWithVisitor(const uint64_t* nulls, Visitor visitor) {
+    skipPending();
     int32_t end = visitor.rowAt(visitor.numRows() - 1) + 1;
     int32_t totalNulls = 0;
     // Reads all the non-null bits between 0 and last row into 'bits',
@@ -298,9 +304,9 @@ class BooleanRleDecoder : public ByteRleDecoder {
     if (hasNulls) {
       totalNulls = bits::countNulls(nulls, 0, end);
     }
-    bits.resize(bits::nwords(end - totalNulls));
+    bits_.resize(bits::nwords(end - totalNulls));
     if (end > totalNulls) {
-      next(reinterpret_cast<char*>(bits.data()), end - totalNulls, nullptr);
+      next(reinterpret_cast<char*>(bits_.data()), end - totalNulls, nullptr);
     }
     int32_t dataPosition = 0;
     int32_t current = visitor.start();
@@ -326,7 +332,7 @@ class BooleanRleDecoder : public ByteRleDecoder {
         }
       }
       toSkip =
-          visitor.process(bits::isBitSet(bits.data(), dataPosition), atEnd);
+          visitor.process(bits::isBitSet(bits_.data(), dataPosition), atEnd);
       ++dataPosition;
     skip:
       ++current;
@@ -340,11 +346,28 @@ class BooleanRleDecoder : public ByteRleDecoder {
     }
   }
 
+ private:
+  // Advances 'dataPosition' by 'numValue' non-nulls, where 'current'
+  // is the position in 'nulls'.
+  template <bool hasNulls>
+  static void skip(
+      int32_t numValues,
+      int32_t current,
+      const uint64_t* nulls,
+      int32_t& dataPosition) {
+    if (hasNulls) {
+      numValues = bits::countNonNulls(nulls, current, current + numValues);
+    }
+    dataPosition += numValues;
+  }
+
+  void skipPending() override;
+
  protected:
-  size_t remainingBits;
-  uint8_t reversedLastByte;
-  char buffer;
-  std::vector<uint64_t> bits;
+  size_t remainingBits_;
+  uint8_t reversedLastByte_;
+  char buffer_;
+  std::vector<uint64_t> bits_;
 };
 
 /**
diff --git a/velox/dwio/dwrf/common/CMakeLists.txt b/velox/dwio/dwrf/common/CMakeLists.txt
index 0856576e6845e..427e2a294386b 100644
--- a/velox/dwio/dwrf/common/CMakeLists.txt
+++ b/velox/dwio/dwrf/common/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(
   velox_dwio_dwrf_common
   ByteRLE.cpp
   Common.cpp
@@ -28,12 +28,15 @@ add_library(
   wrap/dwrf-proto-wrapper.cpp
   wrap/orc-proto-wrapper.cpp)
 
-add_dependencies(velox_dwio_dwrf_common velox_dwio_dwrf_proto)
+if(NOT VELOX_MONO_LIBRARY)
+  add_dependencies(velox_dwio_dwrf_common velox_dwio_dwrf_proto)
+endif()
 
-target_link_libraries(
+velox_link_libraries(
   velox_dwio_dwrf_common
   velox_common_base
   velox_common_compression
+  velox_common_config
   velox_dwio_common
   velox_dwio_common_compression
   velox_dwio_dwrf_proto
diff --git a/velox/dwio/dwrf/common/Common.cpp b/velox/dwio/dwrf/common/Common.cpp
index 786abac66ee66..5cf0f8929e100 100644
--- a/velox/dwio/dwrf/common/Common.cpp
+++ b/velox/dwio/dwrf/common/Common.cpp
@@ -83,26 +83,4 @@ DwrfStreamIdentifier EncodingKey::forKind(const proto::Stream_Kind kind) const {
   return DwrfStreamIdentifier(node_, sequence_, 0, kind);
 }
 
-namespace {
-using common::CompressionKind;
-
-CompressionKind orcCompressionToCompressionKind(
-    proto::orc::CompressionKind compression) {
-  switch (compression) {
-    case proto::orc::CompressionKind::NONE:
-      return CompressionKind::CompressionKind_NONE;
-    case proto::orc::CompressionKind::ZLIB:
-      return CompressionKind::CompressionKind_ZLIB;
-    case proto::orc::CompressionKind::SNAPPY:
-      return CompressionKind::CompressionKind_SNAPPY;
-    case proto::orc::CompressionKind::LZO:
-      return CompressionKind::CompressionKind_LZO;
-    case proto::orc::CompressionKind::LZ4:
-      return CompressionKind::CompressionKind_LZ4;
-    case proto::orc::CompressionKind::ZSTD:
-      return CompressionKind::CompressionKind_ZSTD;
-  }
-  return CompressionKind::CompressionKind_NONE;
-}
-} // namespace
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/common/Common.h b/velox/dwio/dwrf/common/Common.h
index f03bff24a11a2..de52dbc5ca42d 100644
--- a/velox/dwio/dwrf/common/Common.h
+++ b/velox/dwio/dwrf/common/Common.h
@@ -129,7 +129,7 @@ class EncodingKey {
   }
 
   bool valid() const {
-    return node_ != dwio::common::MAX_UINT32 && sequence_ >= 0;
+    return node_ != dwio::common::MAX_UINT32;
   }
 
   std::string toString() const {
diff --git a/velox/dwio/dwrf/common/Compression.h b/velox/dwio/dwrf/common/Compression.h
index ce69430b52e06..1444137ae5c8d 100644
--- a/velox/dwio/dwrf/common/Compression.h
+++ b/velox/dwio/dwrf/common/Compression.h
@@ -17,8 +17,11 @@
 #pragma once
 
 #include "velox/common/compression/Compression.h"
+#include "velox/dwio/common/OutputStream.h"
 #include "velox/dwio/common/SeekableInputStream.h"
 #include "velox/dwio/common/compression/Compression.h"
+#include "velox/dwio/common/compression/CompressionBufferPool.h"
+#include "velox/dwio/common/compression/PagedOutputStream.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/common/Config.h"
 #include "velox/dwio/dwrf/common/Decryption.h"
@@ -30,7 +33,7 @@ using namespace dwio::common::compression;
 
 constexpr uint8_t PAGE_HEADER_SIZE = 3;
 
-static const CompressionOptions getDwrfOrcCompressionOptions(
+inline CompressionOptions getDwrfOrcCompressionOptions(
     velox::common::CompressionKind kind,
     uint32_t compressionThreshold,
     int32_t zlibCompressionLevel,
@@ -38,7 +41,8 @@ static const CompressionOptions getDwrfOrcCompressionOptions(
   CompressionOptions options;
   options.compressionThreshold = compressionThreshold;
 
-  if (kind == velox::common::CompressionKind_ZLIB) {
+  if (kind == velox::common::CompressionKind_ZLIB ||
+      kind == velox::common::CompressionKind_GZIP) {
     options.format.zlib.windowBits = Compressor::DWRF_ORC_ZLIB_WINDOW_BITS;
     options.format.zlib.compressionLevel = zlibCompressionLevel;
   } else if (kind == velox::common::CompressionKind_ZSTD) {
@@ -55,7 +59,7 @@ static const CompressionOptions getDwrfOrcCompressionOptions(
  * collection
  * @param config The compression options to use
  */
-static std::unique_ptr<dwio::common::BufferedOutputStream> createCompressor(
+inline std::unique_ptr<dwio::common::BufferedOutputStream> createCompressor(
     common::CompressionKind kind,
     CompressionBufferPool& bufferPool,
     dwio::common::DataBufferHolder& bufferHolder,
@@ -66,19 +70,32 @@ static std::unique_ptr<dwio::common::BufferedOutputStream> createCompressor(
       config.get(Config::COMPRESSION_THRESHOLD),
       config.get(Config::ZLIB_COMPRESSION_LEVEL),
       config.get(Config::ZSTD_COMPRESSION_LEVEL));
-
-  return createCompressor(
-      kind,
+  auto compressor = createCompressor(kind, dwrfOrcCompressionOptions);
+  if (!compressor) {
+    if (!encrypter && kind == common::CompressionKind::CompressionKind_NONE) {
+      return std::make_unique<dwio::common::BufferedOutputStream>(bufferHolder);
+    }
+  }
+  return std::make_unique<PagedOutputStream>(
       bufferPool,
       bufferHolder,
+      dwrfOrcCompressionOptions.compressionThreshold,
       PAGE_HEADER_SIZE,
-      dwrfOrcCompressionOptions,
+      std::move(compressor),
       encrypter);
 }
 
-static const CompressionOptions getDwrfOrcDecompressionOptions() {
+inline CompressionOptions getDwrfOrcDecompressionOptions(
+    common::CompressionKind kind) {
   CompressionOptions options;
-  options.format.zlib.windowBits = Compressor::DWRF_ORC_ZLIB_WINDOW_BITS;
+  if (kind == common::CompressionKind_ZLIB ||
+      kind == common::CompressionKind_GZIP) {
+    options.format.zlib.windowBits = Compressor::DWRF_ORC_ZLIB_WINDOW_BITS;
+  } else if (
+      kind == common::CompressionKind_LZ4 ||
+      kind == common::CompressionKind_LZO) {
+    options.format.lz4_lzo.isHadoopFrameFormat = false;
+  }
   return options;
 }
 
@@ -89,14 +106,14 @@ static const CompressionOptions getDwrfOrcDecompressionOptions() {
  * @param bufferSize The maximum size of the buffer
  * @param pool The memory pool
  */
-static std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
+inline std::unique_ptr<dwio::common::SeekableInputStream> createDecompressor(
     facebook::velox::common::CompressionKind kind,
     std::unique_ptr<dwio::common::SeekableInputStream> input,
     uint64_t bufferSize,
     memory::MemoryPool& pool,
     const std::string& streamDebugInfo,
     const dwio::common::encryption::Decrypter* decryptr = nullptr) {
-  const CompressionOptions& options = getDwrfOrcDecompressionOptions();
+  const CompressionOptions& options = getDwrfOrcDecompressionOptions(kind);
   return createDecompressor(
       kind,
       std::move(input),
diff --git a/velox/dwio/dwrf/common/Config.cpp b/velox/dwio/dwrf/common/Config.cpp
index cda606466b184..8ce1ad5f21550 100644
--- a/velox/dwio/dwrf/common/Config.cpp
+++ b/velox/dwio/dwrf/common/Config.cpp
@@ -188,10 +188,22 @@ Config::Entry<uint64_t> Config::MAX_DICTIONARY_SIZE(
     "hive.exec.orc.max.dictionary.size",
     80L * 1024L * 1024L);
 
+Config::Entry<bool> Config::INTEGER_DICTIONARY_ENCODING_ENABLED(
+    "hive.exec.orc.integer.dictionary.encoding.enabled",
+    true);
+
+Config::Entry<bool> Config::STRING_DICTIONARY_ENCODING_ENABLED(
+    "hive.exec.orc.string.dictionary.encoding.enabled",
+    true);
+
 Config::Entry<uint64_t> Config::STRIPE_SIZE(
     "hive.exec.orc.stripe.size",
     256L * 1024L * 1024L);
 
+Config::Entry<bool> Config::LINEAR_STRIPE_SIZE_HEURISTICS(
+    "hive.exec.orc.linear.stripe.size.heuristics",
+    true);
+
 Config::Entry<bool> Config::FORCE_LOW_MEMORY_MODE(
     "hive.exec.orc.low.memory",
     false);
diff --git a/velox/dwio/dwrf/common/Config.h b/velox/dwio/dwrf/common/Config.h
index 8c040f0bfdcdb..7b001700bb690 100644
--- a/velox/dwio/dwrf/common/Config.h
+++ b/velox/dwio/dwrf/common/Config.h
@@ -24,10 +24,10 @@
 
 namespace facebook::velox::dwrf {
 
-class Config : public common::ConfigBase<Config> {
+class Config : public config::ConfigBase {
  public:
   template <typename T>
-  using Entry = common::ConfigBase<Config>::Entry<T>;
+  using Entry = config::ConfigBase::Entry<T>;
 
   static Entry<WriterVersion> WRITER_VERSION;
   static Entry<common::CompressionKind> COMPRESSION;
@@ -61,7 +61,10 @@ class Config : public common::ConfigBase<Config> {
       MAP_FLAT_COLS_STRUCT_KEYS;
   static Entry<uint32_t> MAP_FLAT_MAX_KEYS;
   static Entry<uint64_t> MAX_DICTIONARY_SIZE;
+  static Entry<bool> INTEGER_DICTIONARY_ENCODING_ENABLED;
+  static Entry<bool> STRING_DICTIONARY_ENCODING_ENABLED;
   static Entry<uint64_t> STRIPE_SIZE;
+  static Entry<bool> LINEAR_STRIPE_SIZE_HEURISTICS;
   /// With this config, we don't even try the more memory intensive encodings on
   /// writer start up.
   static Entry<bool> FORCE_LOW_MEMORY_MODE;
@@ -77,9 +80,17 @@ class Config : public common::ConfigBase<Config> {
 
   static std::shared_ptr<Config> fromMap(
       const std::map<std::string, std::string>& map) {
-    auto ret = std::make_shared<Config>();
-    ret->configs_.insert(map.cbegin(), map.cend());
-    return ret;
+    auto config = std::make_shared<Config>();
+    for (const auto& pair : map) {
+      config->set(pair.first, pair.second);
+    }
+    return config;
+  }
+
+  Config() : ConfigBase({}, true) {}
+
+  std::map<std::string, std::string> toSerdeParams() {
+    return std::map{configs_.cbegin(), configs_.cend()};
   }
 };
 
diff --git a/velox/dwio/dwrf/common/DecoderUtil.h b/velox/dwio/dwrf/common/DecoderUtil.h
index 9c269a62f7102..f1b100773d68f 100644
--- a/velox/dwio/dwrf/common/DecoderUtil.h
+++ b/velox/dwio/dwrf/common/DecoderUtil.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/base/Exceptions.h"
 #include "velox/dwio/common/DirectDecoder.h"
 #include "velox/dwio/common/IntDecoder.h"
 #include "velox/dwio/dwrf/common/RLEv1.h"
@@ -42,7 +43,7 @@ std::unique_ptr<dwio::common::IntDecoder<isSigned>> createRleDecoder(
     case RleVersion_2:
       return std::make_unique<RleDecoderV2<isSigned>>(std::move(input), pool);
     default:
-      DWIO_ENSURE(false, "not supported");
+      VELOX_UNSUPPORTED("Not supported: {}", static_cast<int64_t>(version));
       return {};
   }
 }
diff --git a/velox/dwio/dwrf/common/FileMetadata.cpp b/velox/dwio/dwrf/common/FileMetadata.cpp
index 07a687b63ace3..ccb9f6faa7f50 100644
--- a/velox/dwio/dwrf/common/FileMetadata.cpp
+++ b/velox/dwio/dwrf/common/FileMetadata.cpp
@@ -102,9 +102,9 @@ TypeKind TypeWrapper::kind() const {
     }
     case proto::orc::Type_Kind_CHAR:
     case proto::orc::Type_Kind_TIMESTAMP_INSTANT:
-      DWIO_RAISE(
+      VELOX_FAIL(fmt::format(
           "{} not supported yet.",
-          proto::orc::Type_Kind_Name(orcPtr()->kind()));
+          proto::orc::Type_Kind_Name(orcPtr()->kind())));
     default:
       VELOX_FAIL("Unknown type kind: {}", Type_Kind_Name(orcPtr()->kind()));
   }
diff --git a/velox/dwio/dwrf/common/FileMetadata.h b/velox/dwio/dwrf/common/FileMetadata.h
index 2ea21628a595a..bee7c0acfabb1 100644
--- a/velox/dwio/dwrf/common/FileMetadata.h
+++ b/velox/dwio/dwrf/common/FileMetadata.h
@@ -31,13 +31,6 @@ enum class DwrfFormat : uint8_t {
 };
 
 class ProtoWrapperBase {
- protected:
-  ProtoWrapperBase(DwrfFormat format, const void* impl)
-      : format_{format}, impl_{impl} {}
-
-  DwrfFormat format_;
-  const void* impl_;
-
  public:
   DwrfFormat format() const {
     return format_;
@@ -46,6 +39,13 @@ class ProtoWrapperBase {
   inline const void* rawProtoPtr() const {
     return impl_;
   }
+
+ protected:
+  ProtoWrapperBase(DwrfFormat format, const void* impl)
+      : format_{format}, impl_{impl} {}
+
+  const DwrfFormat format_;
+  const void* const impl_;
 };
 
 /***
@@ -336,6 +336,334 @@ class UserMetadataItemWrapper : public ProtoWrapperBase {
   }
 };
 
+class IntegerStatisticsWrapper : public ProtoWrapperBase {
+ public:
+  explicit IntegerStatisticsWrapper(
+      const proto::IntegerStatistics* intStatistics)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, intStatistics) {}
+
+  explicit IntegerStatisticsWrapper(
+      const proto::orc::IntegerStatistics* intStatistics)
+      : ProtoWrapperBase(DwrfFormat::kOrc, intStatistics) {}
+
+  bool hasMinimum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_minimum()
+                                        : orcPtr()->has_minimum();
+  }
+
+  int64_t minimum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->minimum()
+                                        : orcPtr()->minimum();
+  }
+
+  bool hasMaximum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_maximum()
+                                        : orcPtr()->has_maximum();
+  }
+
+  int64_t maximum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->maximum()
+                                        : orcPtr()->maximum();
+  }
+
+  bool hasSum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_sum()
+                                        : orcPtr()->has_sum();
+  }
+
+  int64_t sum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->sum() : orcPtr()->sum();
+  }
+
+ private:
+  // private helper with no format checking
+  inline const proto::IntegerStatistics* dwrfPtr() const {
+    return reinterpret_cast<const proto::IntegerStatistics*>(rawProtoPtr());
+  }
+  inline const proto::orc::IntegerStatistics* orcPtr() const {
+    return reinterpret_cast<const proto::orc::IntegerStatistics*>(
+        rawProtoPtr());
+  }
+};
+
+class DoubleStatisticsWrapper : public ProtoWrapperBase {
+ public:
+  explicit DoubleStatisticsWrapper(
+      const proto::DoubleStatistics* doubleStatistics)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, doubleStatistics) {}
+
+  explicit DoubleStatisticsWrapper(
+      const proto::orc::DoubleStatistics* doubleStatistics)
+      : ProtoWrapperBase(DwrfFormat::kOrc, doubleStatistics) {}
+
+  bool hasMinimum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_minimum()
+                                        : orcPtr()->has_minimum();
+  }
+
+  double minimum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->minimum()
+                                        : orcPtr()->minimum();
+  }
+
+  bool hasMaximum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_maximum()
+                                        : orcPtr()->has_maximum();
+  }
+
+  double maximum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->maximum()
+                                        : orcPtr()->maximum();
+  }
+
+  bool hasSum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_sum()
+                                        : orcPtr()->has_sum();
+  }
+
+  double sum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->sum() : orcPtr()->sum();
+  }
+
+ private:
+  // private helper with no format checking
+  inline const proto::DoubleStatistics* dwrfPtr() const {
+    return reinterpret_cast<const proto::DoubleStatistics*>(rawProtoPtr());
+  }
+  inline const proto::orc::DoubleStatistics* orcPtr() const {
+    return reinterpret_cast<const proto::orc::DoubleStatistics*>(rawProtoPtr());
+  }
+};
+
+class StringStatisticsWrapper : public ProtoWrapperBase {
+ public:
+  explicit StringStatisticsWrapper(
+      const proto::StringStatistics* stringStatistics)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, stringStatistics) {}
+
+  explicit StringStatisticsWrapper(
+      const proto::orc::StringStatistics* stringStatistics)
+      : ProtoWrapperBase(DwrfFormat::kOrc, stringStatistics) {}
+
+  bool hasMinimum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_minimum()
+                                        : orcPtr()->has_minimum();
+  }
+
+  const std::string& minimum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->minimum()
+                                        : orcPtr()->minimum();
+  }
+
+  bool hasMaximum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_maximum()
+                                        : orcPtr()->has_maximum();
+  }
+
+  const std::string& maximum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->maximum()
+                                        : orcPtr()->maximum();
+  }
+
+  bool hasSum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_sum()
+                                        : orcPtr()->has_sum();
+  }
+
+  int64_t sum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->sum() : orcPtr()->sum();
+  }
+
+ private:
+  // private helper with no format checking
+  inline const proto::StringStatistics* dwrfPtr() const {
+    return reinterpret_cast<const proto::StringStatistics*>(rawProtoPtr());
+  }
+  inline const proto::orc::StringStatistics* orcPtr() const {
+    return reinterpret_cast<const proto::orc::StringStatistics*>(rawProtoPtr());
+  }
+};
+
+class BucketStatisticsWrapper : public ProtoWrapperBase {
+ public:
+  explicit BucketStatisticsWrapper(
+      const proto::BucketStatistics* bucketStatistics)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, bucketStatistics) {}
+
+  explicit BucketStatisticsWrapper(
+      const proto::orc::BucketStatistics* bucketStatistics)
+      : ProtoWrapperBase(DwrfFormat::kOrc, bucketStatistics) {}
+
+  int countSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->count_size()
+                                        : orcPtr()->count_size();
+  }
+
+  uint64_t count(int index) const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->count(index)
+                                        : orcPtr()->count(index);
+  }
+
+ private:
+  // private helper with no format checking
+  inline const proto::BucketStatistics* dwrfPtr() const {
+    return reinterpret_cast<const proto::BucketStatistics*>(rawProtoPtr());
+  }
+  inline const proto::orc::BucketStatistics* orcPtr() const {
+    return reinterpret_cast<const proto::orc::BucketStatistics*>(rawProtoPtr());
+  }
+};
+
+class BinaryStatisticsWrapper : public ProtoWrapperBase {
+ public:
+  explicit BinaryStatisticsWrapper(
+      const proto::BinaryStatistics* binaryStatistics)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, binaryStatistics) {}
+
+  explicit BinaryStatisticsWrapper(
+      const proto::orc::BinaryStatistics* binaryStatistics)
+      : ProtoWrapperBase(DwrfFormat::kOrc, binaryStatistics) {}
+
+  bool hasSum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_sum()
+                                        : orcPtr()->has_sum();
+  }
+
+  int64_t sum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->sum() : orcPtr()->sum();
+  }
+
+ private:
+  // private helper with no format checking
+  inline const proto::BinaryStatistics* dwrfPtr() const {
+    return reinterpret_cast<const proto::BinaryStatistics*>(rawProtoPtr());
+  }
+  inline const proto::orc::BinaryStatistics* orcPtr() const {
+    return reinterpret_cast<const proto::orc::BinaryStatistics*>(rawProtoPtr());
+  }
+};
+
+class ColumnStatisticsWrapper : public ProtoWrapperBase {
+ public:
+  explicit ColumnStatisticsWrapper(
+      const proto::ColumnStatistics* columnStatistics)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, columnStatistics) {}
+
+  explicit ColumnStatisticsWrapper(
+      const proto::orc::ColumnStatistics* columnStatistics)
+      : ProtoWrapperBase(DwrfFormat::kOrc, columnStatistics) {}
+
+  bool hasNumberOfValues() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_numberofvalues()
+                                        : orcPtr()->has_numberofvalues();
+  }
+
+  uint64_t numberOfValues() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->numberofvalues()
+                                        : orcPtr()->numberofvalues();
+  }
+
+  bool hasHasNull() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_hasnull()
+                                        : orcPtr()->has_hasnull();
+  }
+
+  bool hasNull() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->hasnull()
+                                        : orcPtr()->hasnull();
+  }
+
+  bool hasRawSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_rawsize() : false;
+  }
+
+  uint64_t rawSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->rawsize() : 0;
+  }
+
+  bool hasSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_size() : false;
+  }
+
+  uint64_t size() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->size() : 0;
+  }
+
+  bool hasIntStatistics() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_intstatistics()
+                                        : orcPtr()->has_intstatistics();
+  }
+
+  IntegerStatisticsWrapper intStatistics() const {
+    return format_ == DwrfFormat::kDwrf
+        ? IntegerStatisticsWrapper(&dwrfPtr()->intstatistics())
+        : IntegerStatisticsWrapper(&orcPtr()->intstatistics());
+  }
+
+  bool hasDoubleStatistics() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_doublestatistics()
+                                        : orcPtr()->has_doublestatistics();
+  }
+
+  DoubleStatisticsWrapper doubleStatistics() const {
+    return format_ == DwrfFormat::kDwrf
+        ? DoubleStatisticsWrapper(&dwrfPtr()->doublestatistics())
+        : DoubleStatisticsWrapper(&orcPtr()->doublestatistics());
+  }
+
+  bool hasStringStatistics() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_stringstatistics()
+                                        : orcPtr()->has_stringstatistics();
+  }
+
+  StringStatisticsWrapper stringStatistics() const {
+    return format_ == DwrfFormat::kDwrf
+        ? StringStatisticsWrapper(&dwrfPtr()->stringstatistics())
+        : StringStatisticsWrapper(&orcPtr()->stringstatistics());
+  }
+
+  bool hasBucketStatistics() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_bucketstatistics()
+                                        : orcPtr()->has_bucketstatistics();
+  }
+
+  BucketStatisticsWrapper bucketStatistics() const {
+    return format_ == DwrfFormat::kDwrf
+        ? BucketStatisticsWrapper(&dwrfPtr()->bucketstatistics())
+        : BucketStatisticsWrapper(&orcPtr()->bucketstatistics());
+  }
+
+  bool hasBinaryStatistics() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_binarystatistics()
+                                        : orcPtr()->has_binarystatistics();
+  }
+
+  BinaryStatisticsWrapper binaryStatistics() const {
+    return format_ == DwrfFormat::kDwrf
+        ? BinaryStatisticsWrapper(&dwrfPtr()->binarystatistics())
+        : BinaryStatisticsWrapper(&orcPtr()->binarystatistics());
+  }
+
+  bool hasMapStatistics() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_mapstatistics()
+                                        : false;
+  }
+
+  const ::facebook::velox::dwrf::proto::MapStatistics& mapStatistics() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->mapstatistics();
+  }
+
+ private:
+  // private helper with no format checking
+  inline const proto::ColumnStatistics* dwrfPtr() const {
+    return reinterpret_cast<const proto::ColumnStatistics*>(rawProtoPtr());
+  }
+  inline const proto::orc::ColumnStatistics* orcPtr() const {
+    return reinterpret_cast<const proto::orc::ColumnStatistics*>(rawProtoPtr());
+  }
+};
+
 class FooterWrapper : public ProtoWrapperBase {
  public:
   explicit FooterWrapper(const proto::Footer* footer)
@@ -424,9 +752,9 @@ class FooterWrapper : public ProtoWrapperBase {
     return dwrfPtr()->stripecacheoffsets();
   }
 
-  // TODO: ORC has not supported column statistics yet
   int statisticsSize() const {
-    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->statistics_size() : 0;
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->statistics_size()
+                                        : orcPtr()->statistics_size();
   }
 
   const ::google::protobuf::RepeatedPtrField<
@@ -436,12 +764,18 @@ class FooterWrapper : public ProtoWrapperBase {
     return dwrfPtr()->statistics();
   }
 
-  const ::facebook::velox::dwrf::proto::ColumnStatistics& statistics(
+  const ::facebook::velox::dwrf::proto::ColumnStatistics& dwrfStatistics(
       int index) const {
     VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
     return dwrfPtr()->statistics(index);
   }
 
+  ColumnStatisticsWrapper statistics(int index) const {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnStatisticsWrapper(&dwrfPtr()->statistics(index))
+        : ColumnStatisticsWrapper(&orcPtr()->statistics(index));
+  }
+
   // TODO: ORC has not supported encryption yet
   bool hasEncryption() const {
     return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_encryption() : false;
@@ -495,3 +829,10 @@ class FooterWrapper : public ProtoWrapperBase {
 };
 
 } // namespace facebook::velox::dwrf
+
+template <>
+struct fmt::formatter<facebook::velox::dwrf::DwrfFormat> : formatter<int> {
+  auto format(facebook::velox::dwrf::DwrfFormat s, format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/dwio/dwrf/common/FloatingPointDecoder.h b/velox/dwio/dwrf/common/FloatingPointDecoder.h
index ccc0e1ba53841..7261371cb5ce2 100644
--- a/velox/dwio/dwrf/common/FloatingPointDecoder.h
+++ b/velox/dwio/dwrf/common/FloatingPointDecoder.h
@@ -24,20 +24,20 @@ namespace facebook::velox::dwrf {
 
 struct DropValues;
 
-template <typename TData, typename TRequested>
+template <typename TFile, typename TRequested>
 class FloatingPointDecoder {
  public:
   FloatingPointDecoder(
       std::unique_ptr<dwio::common::SeekableInputStream>&& input)
       : input_(std::move(input)) {}
 
-  TData readValue() {
-    if (bufferEnd_ - bufferStart_ >= sizeof(TData)) {
-      TData value = *reinterpret_cast<const TData*>(bufferStart_);
-      bufferStart_ += sizeof(TData);
+  TFile readValue() {
+    if (bufferEnd_ - bufferStart_ >= sizeof(TFile)) {
+      TFile value = *reinterpret_cast<const TFile*>(bufferStart_);
+      bufferStart_ += sizeof(TFile);
       return value;
     }
-    TData temp;
+    TFile temp;
     readBytes(sizeof(temp), input_.get(), &temp, bufferStart_, bufferEnd_);
     return temp;
   }
@@ -49,7 +49,7 @@ class FloatingPointDecoder {
 
   void skip(uint64_t numValues) {
     skipBytes(
-        numValues * sizeof(TData), input_.get(), bufferStart_, bufferEnd_);
+        numValues * sizeof(TFile), input_.get(), bufferStart_, bufferEnd_);
   }
 
   template <bool hasNulls>
@@ -58,12 +58,12 @@ class FloatingPointDecoder {
       numValues = bits::countNonNulls(nulls, current, current + numValues);
     }
     skipBytes(
-        numValues * sizeof(TData), input_.get(), bufferStart_, bufferEnd_);
+        numValues * sizeof(TFile), input_.get(), bufferStart_, bufferEnd_);
   }
 
   template <bool hasNulls, typename Visitor>
   void readWithVisitor(const uint64_t* nulls, Visitor visitor) {
-    if (std::is_same_v<TData, TRequested> &&
+    if (std::is_same_v<TFile, TRequested> &&
         dwio::common::useFastPath<Visitor, hasNulls>(visitor)) {
       fastPath<hasNulls>(nulls, visitor);
       return;
@@ -141,7 +141,7 @@ class FloatingPointDecoder {
           return;
         }
       }
-      dwio::common::fixedWidthScan<TData, filterOnly, true>(
+      dwio::common::fixedWidthScan<TFile, filterOnly, true>(
           innerVector ? folly::Range<const int32_t*>(*innerVector)
                       : folly::Range<const int32_t*>(rows, outerVector->size()),
           outerVector->data(),
@@ -155,7 +155,7 @@ class FloatingPointDecoder {
           visitor.hook());
       skip<false>(tailSkip, 0, nullptr);
     } else {
-      dwio::common::fixedWidthScan<TData, filterOnly, false>(
+      dwio::common::fixedWidthScan<TFile, filterOnly, false>(
           folly::Range<const int32_t*>(rows, numRows),
           hasHook ? velox::iota(numRows, visitor.innerNonNullRows()) : nullptr,
           visitor.rawValues(numRows),
diff --git a/velox/dwio/dwrf/common/RLEv1.cpp b/velox/dwio/dwrf/common/RLEv1.cpp
index 3ef54f85a8136..1b903a1cc3920 100644
--- a/velox/dwio/dwrf/common/RLEv1.cpp
+++ b/velox/dwio/dwrf/common/RLEv1.cpp
@@ -22,42 +22,45 @@ namespace facebook::velox::dwrf {
 
 template <bool isSigned>
 void RleEncoderV1<isSigned>::writeValues() {
-  if (numLiterals != 0) {
-    if (repeat) {
-      IntEncoder<isSigned>::writeByte(
-          static_cast<char>(numLiterals - RLE_MINIMUM_REPEAT));
-      IntEncoder<isSigned>::writeByte(static_cast<char>(delta));
-      if (!IntEncoder<isSigned>::useVInts_) {
-        IntEncoder<isSigned>::writeLongLE(literals[0]);
+  if (numLiterals_ == 0) {
+    return;
+  }
+
+  if (repeat_) {
+    IntEncoder<isSigned>::writeByte(
+        static_cast<char>(numLiterals_ - RLE_MINIMUM_REPEAT));
+    IntEncoder<isSigned>::writeByte(static_cast<char>(delta_));
+    if (!IntEncoder<isSigned>::useVInts_) {
+      IntEncoder<isSigned>::writeLongLE(literals_[0]);
+    } else {
+      if constexpr (isSigned) {
+        IntEncoder<isSigned>::writeVslong(literals_[0]);
       } else {
-        if constexpr (isSigned) {
-          IntEncoder<isSigned>::writeVslong(literals[0]);
-        } else {
-          IntEncoder<isSigned>::writeVulong(literals[0]);
-        }
+        IntEncoder<isSigned>::writeVulong(literals_[0]);
+      }
+    }
+  } else {
+    IntEncoder<isSigned>::writeByte(static_cast<char>(-numLiterals_));
+    if (!IntEncoder<isSigned>::useVInts_) {
+      for (int32_t i = 0; i < numLiterals_; ++i) {
+        IntEncoder<isSigned>::writeLongLE(literals_[i]);
       }
     } else {
-      IntEncoder<isSigned>::writeByte(static_cast<char>(-numLiterals));
-      if (!IntEncoder<isSigned>::useVInts_) {
-        for (int32_t i = 0; i < numLiterals; ++i) {
-          IntEncoder<isSigned>::writeLongLE(literals[i]);
+      if constexpr (isSigned) {
+        for (int32_t i = 0; i < numLiterals_; ++i) {
+          IntEncoder<isSigned>::writeVslong(literals_[i]);
         }
       } else {
-        if constexpr (isSigned) {
-          for (int32_t i = 0; i < numLiterals; ++i) {
-            IntEncoder<isSigned>::writeVslong(literals[i]);
-          }
-        } else {
-          for (int32_t i = 0; i < numLiterals; ++i) {
-            IntEncoder<isSigned>::writeVulong(literals[i]);
-          }
+        for (int32_t i = 0; i < numLiterals_; ++i) {
+          IntEncoder<isSigned>::writeVulong(literals_[i]);
         }
       }
     }
-    repeat = false;
-    numLiterals = 0;
-    tailRunLength = 0;
   }
+
+  repeat_ = false;
+  numLiterals_ = 0;
+  tailRunLength_ = 0;
 }
 
 template void RleEncoderV1<true>::writeValues();
@@ -66,15 +69,15 @@ template void RleEncoderV1<false>::writeValues();
 template <bool isSigned>
 void RleDecoderV1<isSigned>::seekToRowGroup(
     dwio::common::PositionProvider& location) {
-  // move the input stream
-  dwio::common::IntDecoder<isSigned>::inputStream->seekToPosition(location);
-  // force a re-read from the stream
-  dwio::common::IntDecoder<isSigned>::bufferEnd =
-      dwio::common::IntDecoder<isSigned>::bufferStart;
-  // force reading a new header
-  remainingValues = 0;
-  // skip ahead the given number of records
-  skip(location.next());
+  // Move the input stream.
+  dwio::common::IntDecoder<isSigned>::inputStream_->seekToPosition(location);
+  // Force a re-read from the stream.
+  dwio::common::IntDecoder<isSigned>::bufferEnd_ =
+      dwio::common::IntDecoder<isSigned>::bufferStart_;
+  // Force reading a new header.
+  remainingValues_ = 0;
+  // Skip ahead the given number of records.
+  this->pendingSkip_ = location.next();
 }
 
 template void RleDecoderV1<true>::seekToRowGroup(
@@ -83,30 +86,34 @@ template void RleDecoderV1<false>::seekToRowGroup(
     dwio::common::PositionProvider& location);
 
 template <bool isSigned>
-void RleDecoderV1<isSigned>::skip(uint64_t numValues) {
+void RleDecoderV1<isSigned>::skipPending() {
+  uint64_t numValues = this->pendingSkip_;
+  this->pendingSkip_ = 0;
   while (numValues > 0) {
-    if (remainingValues == 0) {
+    if (remainingValues_ == 0) {
       readHeader();
     }
-    uint64_t count = std::min(numValues, remainingValues);
-    remainingValues -= count;
+    const uint64_t count = std::min(numValues, remainingValues_);
+    remainingValues_ -= count;
     numValues -= count;
-    if (repeating) {
-      value += delta * static_cast<int64_t>(count);
+    if (repeating_) {
+      value_ += delta_ * static_cast<int64_t>(count);
     } else {
       dwio::common::IntDecoder<isSigned>::skipLongs(count);
     }
   }
 }
 
-template void RleDecoderV1<true>::skip(uint64_t numValues);
-template void RleDecoderV1<false>::skip(uint64_t numValues);
+template void RleDecoderV1<true>::skipPending();
+template void RleDecoderV1<false>::skipPending();
 
 template <bool isSigned>
 void RleDecoderV1<isSigned>::next(
-    int64_t* const data,
+    int64_t* data,
     const uint64_t numValues,
     const uint64_t* const nulls) {
+  skipPending();
+
   uint64_t position = 0;
   // skipNulls()
   if (nulls) {
@@ -117,83 +124,85 @@ void RleDecoderV1<isSigned>::next(
   }
   while (position < numValues) {
     // If we are out of values, read more.
-    if (remainingValues == 0) {
+    if (remainingValues_ == 0) {
       readHeader();
     }
     // How many do we read out of this block?
-    uint64_t count = std::min(numValues - position, remainingValues);
+    const uint64_t count = std::min(numValues - position, remainingValues_);
     uint64_t consumed = 0;
-    if (repeating) {
+    if (repeating_) {
       if (nulls) {
         for (uint64_t i = 0; i < count; ++i) {
           if (!bits::isBitNull(nulls, position + i)) {
-            data[position + i] = value + static_cast<int64_t>(consumed) * delta;
-            consumed += 1;
+            data[position + i] =
+                value_ + static_cast<int64_t>(consumed) * delta_;
+            ++consumed;
           }
         }
       } else {
         for (uint64_t i = 0; i < count; ++i) {
-          data[position + i] = value + static_cast<int64_t>(i) * delta;
+          data[position + i] = value_ + static_cast<int64_t>(i) * delta_;
         }
         consumed = count;
       }
-      value += static_cast<int64_t>(consumed) * delta;
+      value_ += static_cast<int64_t>(consumed) * delta_;
     } else {
-      int64_t* datap = data + position;
-      int64_t* const datapEnd = datap + count;
+      int64_t* next = data + position;
+      int64_t* const end = next + count;
       if (nulls) {
-        int32_t idx = position;
-        if (!dwio::common::IntDecoder<isSigned>::useVInts) {
-          while (datap != datapEnd) {
-            if (LIKELY(!bits::isBitNull(nulls, idx++))) {
-              *(datap++) = dwio::common::IntDecoder<isSigned>::readLongLE();
+        int32_t index = position;
+        if (!dwio::common::IntDecoder<isSigned>::useVInts_) {
+          while (next != end) {
+            if (LIKELY(!bits::isBitNull(nulls, index++))) {
+              *(next++) = dwio::common::IntDecoder<isSigned>::readLongLE();
               ++consumed;
             } else {
-              *(datap++) = 0;
+              *(next++) = 0;
             }
           }
         } else if constexpr (isSigned) {
-          while (datap != datapEnd) {
-            if (LIKELY(!bits::isBitNull(nulls, idx++))) {
-              *(datap++) = dwio::common::IntDecoder<isSigned>::readVsLong();
+          while (next != end) {
+            if (LIKELY(!bits::isBitNull(nulls, index++))) {
+              *(next++) = dwio::common::IntDecoder<isSigned>::readVsLong();
               ++consumed;
             } else {
-              *(datap++) = 0;
+              *(next++) = 0;
             }
           }
         } else {
-          while (datap != datapEnd) {
-            if (LIKELY(!bits::isBitNull(nulls, idx++))) {
-              *(datap++) = static_cast<int64_t>(
+          while (next != end) {
+            if (LIKELY(!bits::isBitNull(nulls, index++))) {
+              *(next++) = static_cast<int64_t>(
                   dwio::common::IntDecoder<isSigned>::readVuLong());
               ++consumed;
             } else {
-              *(datap++) = 0;
+              *(next++) = 0;
             }
           }
         }
       } else {
-        if (!dwio::common::IntDecoder<isSigned>::useVInts) {
-          while (datap != datapEnd) {
-            *(datap++) = dwio::common::IntDecoder<isSigned>::readLongLE();
+        if (!dwio::common::IntDecoder<isSigned>::useVInts_) {
+          while (next != end) {
+            *(next++) = dwio::common::IntDecoder<isSigned>::readLongLE();
           }
         } else if constexpr (isSigned) {
-          while (datap != datapEnd) {
-            *(datap++) = dwio::common::IntDecoder<isSigned>::readVsLong();
+          while (next != end) {
+            *(next++) = dwio::common::IntDecoder<isSigned>::readVsLong();
           }
         } else {
-          while (datap != datapEnd) {
-            *(datap++) = static_cast<int64_t>(
+          while (next != end) {
+            *(next++) = static_cast<int64_t>(
                 dwio::common::IntDecoder<isSigned>::readVuLong());
           }
         }
         consumed = count;
       }
     }
-    remainingValues -= consumed;
+
+    remainingValues_ -= consumed;
     position += count;
 
-    // skipNulls()
+    // skipNulls().
     if (nulls) {
       // Skip over null values.
       while (position < numValues && bits::isBitNull(nulls, position)) {
@@ -206,36 +215,38 @@ void RleDecoderV1<isSigned>::next(
 template void RleDecoderV1<true>::next(
     int64_t* const data,
     const uint64_t numValues,
-    const uint64_t* const nulls);
+    const uint64_t* nulls);
 template void RleDecoderV1<false>::next(
     int64_t* const data,
     const uint64_t numValues,
-    const uint64_t* const nulls);
+    const uint64_t* nulls);
 
 template <bool isSigned>
-void RleDecoderV1<isSigned>::nextLengths(
-    int32_t* const data,
-    const int32_t numValues) {
+void RleDecoderV1<isSigned>::nextLengths(int32_t* data, int32_t numValues) {
+  skipPending();
+
   uint32_t position = 0;
   while (position < numValues) {
     // If we are out of values, read more.
-    if (remainingValues == 0) {
+    if (remainingValues_ == 0) {
       readHeader();
     }
+
     // How many do we read out of this block?
-    int32_t count = std::min<int32_t>(numValues - position, remainingValues);
+    const int32_t count =
+        std::min<int32_t>(numValues - position, remainingValues_);
     uint64_t consumed = 0;
-    if (repeating) {
+    if (repeating_) {
       for (uint32_t i = 0; i < count; ++i) {
-        data[position + i] = value + i * delta;
+        data[position + i] = value_ + i * delta_;
       }
       consumed = count;
-      value += static_cast<int64_t>(consumed) * delta;
+      value_ += static_cast<int64_t>(consumed) * delta_;
     } else {
       dwio::common::IntDecoder<isSigned>::bulkRead(count, data + position);
       consumed = count;
     }
-    remainingValues -= consumed;
+    remainingValues_ -= consumed;
     position += count;
   }
 }
diff --git a/velox/dwio/dwrf/common/RLEv1.h b/velox/dwio/dwrf/common/RLEv1.h
index 2a0340a31edde..082b57c10e08f 100644
--- a/velox/dwio/dwrf/common/RLEv1.h
+++ b/velox/dwio/dwrf/common/RLEv1.h
@@ -17,7 +17,6 @@
 #pragma once
 
 #include "velox/common/base/GTestMacros.h"
-#include "velox/common/base/Nulls.h"
 #include "velox/dwio/common/Adaptor.h"
 #include "velox/dwio/common/DecoderUtil.h"
 #include "velox/dwio/common/IntDecoder.h"
@@ -38,15 +37,15 @@ class RleEncoderV1 : public IntEncoder<isSigned> {
       bool useVInts,
       uint32_t numBytes)
       : IntEncoder<isSigned>{std::move(outStream), useVInts, numBytes},
-        numLiterals{0},
-        delta{0},
-        repeat{false},
-        tailRunLength{0},
-        isOverflow{false} {}
-
-  // For 64 bit Integers, only signed type is supported. writeVuLong only
-  // supports int64_t and it needs to support uint64_t before this method
-  // can support uint64_t overload.
+        numLiterals_{0},
+        delta_{0},
+        repeat_{false},
+        tailRunLength_{0},
+        overflow_{false} {}
+
+  /// For 64 bit Integers, only signed type is supported. writeVuLong only
+  /// supports int64_t and it needs to support uint64_t before this method
+  /// can support uint64_t overload.
   uint64_t add(
       const int64_t* data,
       const common::Ranges& ranges,
@@ -82,7 +81,7 @@ class RleEncoderV1 : public IntEncoder<isSigned> {
     return addImpl(data, ranges, nulls);
   }
 
-  void writeValue(const int64_t value) override {
+  void writeValue(int64_t value) override {
     write(value);
   }
 
@@ -94,65 +93,59 @@ class RleEncoderV1 : public IntEncoder<isSigned> {
   void recordPosition(PositionRecorder& recorder, int32_t strideIndex = -1)
       const override {
     IntEncoder<isSigned>::recordPosition(recorder, strideIndex);
-    recorder.add(static_cast<uint64_t>(numLiterals), strideIndex);
+    recorder.add(static_cast<uint64_t>(numLiterals_), strideIndex);
   }
 
  private:
   constexpr static int32_t MAX_DELTA = 127;
   constexpr static int32_t MIN_DELTA = -128;
 
-  std::array<int64_t, RLE_MAX_LITERAL_SIZE> literals;
-  int32_t numLiterals;
-  int64_t delta;
-  bool repeat;
-  int32_t tailRunLength;
-  bool isOverflow;
-
   template <typename T>
   void write(T value) {
-    if (numLiterals == 0) {
+    if (numLiterals_ == 0) {
       // Starting new sequence of run or literals.
-      literals[numLiterals++] = value;
-      tailRunLength = 1;
+      literals_[numLiterals_++] = value;
+      tailRunLength_ = 1;
       return;
     }
 
-    if (repeat) {
+    if (repeat_) {
       if (isRunRepeating(value)) {
-        numLiterals += 1;
-        if (numLiterals == RLE_MAXIMUM_REPEAT) {
+        ++numLiterals_;
+        if (numLiterals_ == RLE_MAXIMUM_REPEAT) {
           writeValues();
         }
       } else {
         writeValues();
-        literals[numLiterals++] = value;
-        tailRunLength = 1;
+        literals_[numLiterals_++] = value;
+        tailRunLength_ = 1;
       }
       return;
     }
 
-    if (tailRunLength == 1) {
+    if (tailRunLength_ == 1) {
       computeDeltaAndTailRunLength(value);
     } else if (isRunStarting(value)) {
-      tailRunLength += 1;
+      ++tailRunLength_;
     } else {
       computeDeltaAndTailRunLength(value);
     }
-    if (tailRunLength == RLE_MINIMUM_REPEAT) {
-      if (numLiterals + 1 == RLE_MINIMUM_REPEAT) {
-        numLiterals += 1;
+
+    if (tailRunLength_ == RLE_MINIMUM_REPEAT) {
+      if (numLiterals_ + 1 == RLE_MINIMUM_REPEAT) {
+        ++numLiterals_;
       } else {
-        numLiterals -= (RLE_MINIMUM_REPEAT - 1);
-        int64_t base = literals[numLiterals];
+        numLiterals_ -= (RLE_MINIMUM_REPEAT - 1);
+        const int64_t base = literals_[numLiterals_];
         writeValues();
-        literals[0] = base;
-        numLiterals = RLE_MINIMUM_REPEAT;
+        literals_[0] = base;
+        numLiterals_ = RLE_MINIMUM_REPEAT;
       }
-      // set repeat, so that next call call to write can be special cased.
-      repeat = true;
+      // Set repeat, so that next call call to write can be special cased.
+      repeat_ = true;
     } else {
-      literals[numLiterals++] = value;
-      if (numLiterals == RLE_MAX_LITERAL_SIZE) {
+      literals_[numLiterals_++] = value;
+      if (numLiterals_ == RLE_MAX_LITERAL_SIZE) {
         writeValues();
       }
     }
@@ -166,48 +159,55 @@ class RleEncoderV1 : public IntEncoder<isSigned> {
 
   template <typename Integer>
   FOLLY_ALWAYS_INLINE bool isRunRepeating(const Integer& value) {
-    if constexpr (sizeof(Integer) == sizeof(delta)) {
+    if constexpr (sizeof(Integer) == sizeof(delta_)) {
       int64_t nextRunValue;
-      isOverflow = __builtin_add_overflow(
-          literals[0], delta * numLiterals, &nextRunValue);
-      return value == nextRunValue && !isOverflow;
+      overflow_ = __builtin_add_overflow(
+          literals_[0], delta_ * numLiterals_, &nextRunValue);
+      return value == nextRunValue && !overflow_;
     } else {
-      return value == literals[0] + delta * numLiterals;
+      return value == literals_[0] + delta_ * numLiterals_;
     }
   }
 
   template <typename Integer>
   FOLLY_ALWAYS_INLINE bool isRunStarting(const Integer& value) {
-    if constexpr (sizeof(Integer) == sizeof(delta)) {
+    if constexpr (sizeof(Integer) == sizeof(delta_)) {
       int64_t nextRunValue;
-      isOverflow = __builtin_add_overflow(
-          literals[numLiterals - 1], delta, &nextRunValue);
-      return value == nextRunValue && !isOverflow;
+      overflow_ = __builtin_add_overflow(
+          literals_[numLiterals_ - 1], delta_, &nextRunValue);
+      return value == nextRunValue && !overflow_;
     } else {
-      return value == literals[numLiterals - 1] + delta;
+      return value == literals_[numLiterals_ - 1] + delta_;
     }
   }
 
   template <typename Integer>
   FOLLY_ALWAYS_INLINE void computeDeltaAndTailRunLength(const Integer& value) {
-    if constexpr (sizeof(Integer) == sizeof(delta)) {
-      isOverflow =
-          __builtin_sub_overflow(value, literals[numLiterals - 1], &delta);
-      if (UNLIKELY(isOverflow)) {
-        tailRunLength = 1;
+    if constexpr (sizeof(Integer) == sizeof(delta_)) {
+      overflow_ =
+          __builtin_sub_overflow(value, literals_[numLiterals_ - 1], &delta_);
+      if (UNLIKELY(overflow_)) {
+        tailRunLength_ = 1;
         return;
       }
     } else {
-      delta = value - literals[numLiterals - 1];
+      delta_ = value - literals_[numLiterals_ - 1];
     }
 
-    if (delta < MIN_DELTA || delta > MAX_DELTA) {
-      tailRunLength = 1;
+    if (delta_ < MIN_DELTA || delta_ > MAX_DELTA) {
+      tailRunLength_ = 1;
     } else {
-      tailRunLength = 2;
+      tailRunLength_ = 2;
     }
   }
 
+  std::array<int64_t, RLE_MAX_LITERAL_SIZE> literals_;
+  int32_t numLiterals_;
+  int64_t delta_;
+  bool repeat_;
+  int32_t tailRunLength_;
+  bool overflow_;
+
   VELOX_FRIEND_TEST(RleEncoderV1Test, encodeMinAndMax);
   VELOX_FRIEND_TEST(RleEncoderV1Test, encodeMinAndMaxint32);
 };
@@ -246,48 +246,28 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
       uint32_t numBytes)
       : dwio::common::IntDecoder<
             isSigned>{std::move(input), useVInts, numBytes},
-        remainingValues(0),
-        value(0),
-        delta(0),
-        repeating(false) {}
+        remainingValues_(0),
+        value_(0),
+        delta_(0),
+        repeating_(false) {}
 
   void seekToRowGroup(
       dwio::common::PositionProvider& positionProvider) override;
 
-  void skip(uint64_t numValues) override;
-
   void next(int64_t* data, uint64_t numValues, const uint64_t* nulls) override;
 
   void nextLengths(int32_t* data, int32_t numValues) override;
 
-  template <bool hasNulls>
-  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
-    if (hasNulls) {
-      numValues = bits::countNonNulls(nulls, current, current + numValues);
-    }
-    while (numValues > 0) {
-      if (remainingValues == 0) {
-        readHeader();
-      }
-      uint64_t count = std::min<int>(numValues, remainingValues);
-      remainingValues -= count;
-      numValues -= count;
-      if (repeating) {
-        value += delta * static_cast<int64_t>(count);
-      } else {
-        dwio::common::IntDecoder<isSigned>::skipLongsFast(count);
-      }
-    }
-  }
-
   template <bool hasNulls, typename Visitor>
   void readWithVisitor(const uint64_t* nulls, Visitor visitor) {
+    skipPending();
     if (dwio::common::useFastPath<Visitor, hasNulls>(visitor)) {
       fastPath<hasNulls>(nulls, visitor);
       return;
     }
+
     int32_t current = visitor.start();
-    skip<hasNulls>(current, 0, nulls);
+    this->template skip<hasNulls>(current, 0, nulls);
     int32_t toSkip;
     bool atEnd = false;
     const bool allowNulls = hasNulls && visitor.allowNulls();
@@ -298,7 +278,7 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
         if (hasNulls && !allowNulls) {
           toSkip = visitor.checkAndSkipNulls(nulls, current, atEnd);
           if (!Visitor::dense) {
-            skip<false>(toSkip, current, nullptr);
+            this->template skip<false>(toSkip, current, nullptr);
           }
           if (atEnd) {
             return;
@@ -306,22 +286,22 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
         }
 
         // We are at a non-null value on a row to visit.
-        if (!remainingValues) {
+        if (remainingValues_ == 0) {
           readHeader();
         }
-        if (repeating) {
-          toSkip = visitor.process(value, atEnd);
-          value += delta;
+        if (repeating_) {
+          toSkip = visitor.process(value_, atEnd);
+          value_ += delta_;
         } else {
-          value =
+          value_ =
               dwio::common::IntDecoder<isSigned>::template readInt<int64_t>();
-          toSkip = visitor.process(value, atEnd);
+          toSkip = visitor.process(value_, atEnd);
         }
-        --remainingValues;
+        --remainingValues_;
       }
       ++current;
-      if (toSkip) {
-        skip<hasNulls>(toSkip, current, nulls);
+      if (toSkip > 0) {
+        this->template skip<hasNulls>(toSkip, current, nulls);
         current += toSkip;
       }
       if (atEnd) {
@@ -369,13 +349,13 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
           visitor.setHasNulls();
         }
         if (innerVector->empty()) {
-          skip<false>(tailSkip, 0, nullptr);
+          this->template skip<false>(tailSkip, 0, nullptr);
           visitor.setAllNull(hasFilter ? 0 : numRows);
           return;
         }
         bulkScan<hasFilter, hasHook, true>(
             *innerVector, outerVector->data(), visitor);
-        skip<false>(tailSkip, 0, nullptr);
+        this->template skip<false>(tailSkip, 0, nullptr);
       }
     } else {
       bulkScan<hasFilter, hasHook, false>(rowsAsRange, nullptr, visitor);
@@ -410,31 +390,34 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
         numValues);
   }
 
-  // Returns 1. how many of 'rows' are in the current run 2. the
-  // distance in rows from the current row to the first row after the
-  // last in rows that falls in the current run.
+  /// Returns 1. how many of 'rows' are in the current run; 2. the distance in
+  /// rows from the current row to the first row after the last in rows that
+  /// falls in the current run.
   template <bool dense>
   std::pair<int32_t, std::int32_t> findNumInRun(
       const int32_t* rows,
       int32_t rowIndex,
       int32_t numRows,
       int32_t currentRow) {
-    DCHECK_LT(rowIndex, numRows);
+    VELOX_DCHECK_LT(rowIndex, numRows);
     if (dense) {
-      auto left = std::min<int32_t>(remainingValues, numRows - rowIndex);
+      const auto left = std::min<int32_t>(remainingValues_, numRows - rowIndex);
       return std::make_pair(left, left);
     }
-    if (rows[rowIndex] - currentRow >= remainingValues) {
+
+    if (rows[rowIndex] - currentRow >= remainingValues_) {
       return std::make_pair(0, 0);
     }
-    if (rows[numRows - 1] - currentRow < remainingValues) {
+
+    if (rows[numRows - 1] - currentRow < remainingValues_) {
       return std::pair(numRows - rowIndex, rows[numRows - 1] - currentRow + 1);
     }
-    auto range = folly::Range<const int32_t*>(
+
+    const auto range = folly::Range<const int32_t*>(
         rows + rowIndex,
-        std::min<int32_t>(remainingValues, numRows - rowIndex));
-    auto endOfRun = currentRow + remainingValues;
-    auto bound = std::lower_bound(range.begin(), range.end(), endOfRun);
+        std::min<int32_t>(remainingValues_, numRows - rowIndex));
+    const auto endOfRun = currentRow + remainingValues_;
+    const auto bound = std::lower_bound(range.begin(), range.end(), endOfRun);
     return std::make_pair(bound - range.begin(), bound[-1] - currentRow + 1);
   }
 
@@ -453,23 +436,23 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
     auto filterHits = hasFilter ? visitor.outputRows(numRows) : nullptr;
     int32_t numValues = 0;
     for (;;) {
-      if (remainingValues) {
+      if (remainingValues_ > 0) {
         auto [numInRun, numAdvanced] =
             findNumInRun<Visitor::dense>(rows, rowIndex, numRows, currentRow);
         if (!numInRun) {
           // We are not at end and the next row of interest is after this run.
           VELOX_CHECK(!numAdvanced, "Would advance past end of RLEv1 run");
-        } else if (repeating) {
+        } else if (repeating_) {
           visitor.template processRle<hasFilter, hasHook, scatter>(
-              value,
-              delta,
+              value_,
+              delta_,
               numInRun,
               currentRow,
               scatterRows,
               filterHits,
               values,
               numValues);
-          value += numAdvanced * delta;
+          value_ += numAdvanced * delta_;
         } else {
           processRun<hasFilter, hasHook, scatter>(
               rows,
@@ -482,16 +465,16 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
               numValues,
               visitor);
         }
-        remainingValues -= numAdvanced;
+        remainingValues_ -= numAdvanced;
         currentRow += numAdvanced;
         rowIndex += numInRun;
         if (visitor.atEnd()) {
           visitor.setNumValues(hasFilter ? numValues : numAllRows);
           return;
         }
-        if (remainingValues) {
-          currentRow += remainingValues;
-          skip<false>(remainingValues, -1, nullptr);
+        if (remainingValues_ > 0) {
+          currentRow += remainingValues_;
+          this->template skip<false>(remainingValues_, -1, nullptr);
         }
       }
       readHeader();
@@ -499,22 +482,24 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
   }
 
   inline void readHeader() {
-    signed char ch = dwio::common::IntDecoder<isSigned>::readByte();
+    const signed char ch = dwio::common::IntDecoder<isSigned>::readByte();
     if (ch < 0) {
-      remainingValues = static_cast<uint64_t>(-ch);
-      repeating = false;
+      remainingValues_ = static_cast<uint64_t>(-ch);
+      repeating_ = false;
     } else {
-      remainingValues = static_cast<uint64_t>(ch) + RLE_MINIMUM_REPEAT;
-      repeating = true;
-      delta = dwio::common::IntDecoder<isSigned>::readByte();
-      value = dwio::common::IntDecoder<isSigned>::template readInt<int64_t>();
+      remainingValues_ = static_cast<uint64_t>(ch) + RLE_MINIMUM_REPEAT;
+      repeating_ = true;
+      delta_ = dwio::common::IntDecoder<isSigned>::readByte();
+      value_ = dwio::common::IntDecoder<isSigned>::template readInt<int64_t>();
     }
   }
 
-  uint64_t remainingValues;
-  int64_t value;
-  int64_t delta;
-  bool repeating;
+  void skipPending() override;
+
+  uint64_t remainingValues_;
+  int64_t value_;
+  int64_t delta_;
+  bool repeating_;
 };
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/common/RLEv2.cpp b/velox/dwio/dwrf/common/RLEv2.cpp
index fc6470480d7f2..a61c763eaa63b 100644
--- a/velox/dwio/dwrf/common/RLEv2.cpp
+++ b/velox/dwio/dwrf/common/RLEv2.cpp
@@ -112,7 +112,7 @@ int64_t RleDecoderV2<isSigned>::readLongBE(uint64_t bsz) {
   int64_t ret = 0, val;
   uint64_t n = bsz;
   while (n > 0) {
-    n--;
+    --n;
     val = readByte();
     ret |= (val << (n * 8));
   }
@@ -124,28 +124,26 @@ RleDecoderV2<isSigned>::RleDecoderV2(
     std::unique_ptr<dwio::common::SeekableInputStream> input,
     MemoryPool& pool)
     : dwio::common::IntDecoder<isSigned>{std::move(input), false, 0},
-      firstByte(0),
-      runLength(0),
-      runRead(0),
-      deltaBase(0),
-      byteSize(0),
-      firstValue(0),
-      prevValue(0),
-      bitSize(0),
-      bitsLeft(0),
-      curByte(0),
-      patchBitSize(0),
-      unpackedIdx(0),
-      patchIdx(0),
-      base(0),
-      curGap(0),
-      curPatch(0),
-      patchMask(0),
-      actualGap(0),
-      unpacked(pool, 0),
-      unpackedPatch(pool, 0) {
-  // PASS
-}
+      firstByte_(0),
+      runLength_(0),
+      runRead_(0),
+      deltaBase_(0),
+      byteSize_(0),
+      firstValue_(0),
+      prevValue_(0),
+      bitSize_(0),
+      bitsLeft_(0),
+      curByte_(0),
+      patchBitSize_(0),
+      unpackedIdx_(0),
+      patchIdx_(0),
+      base_(0),
+      curGap_(0),
+      curPatch_(0),
+      patchMask_(0),
+      actualGap_(0),
+      unpacked_(pool, 0),
+      unpackedPatch_(pool, 0) {}
 
 template RleDecoderV2<true>::RleDecoderV2(
     std::unique_ptr<dwio::common::SeekableInputStream> input,
@@ -158,13 +156,14 @@ template <bool isSigned>
 void RleDecoderV2<isSigned>::seekToRowGroup(
     dwio::common::PositionProvider& location) {
   // move the input stream
-  dwio::common::IntDecoder<isSigned>::inputStream->seekToPosition(location);
+  dwio::common::IntDecoder<isSigned>::inputStream_->seekToPosition(location);
   // clear state
-  dwio::common::IntDecoder<isSigned>::bufferEnd =
-      dwio::common::IntDecoder<isSigned>::bufferStart = 0;
-  runRead = runLength = 0;
+  dwio::common::IntDecoder<isSigned>::bufferStart_ = nullptr;
+  dwio::common::IntDecoder<isSigned>::bufferEnd_ = nullptr;
+  runRead_ = 0;
+  runLength_ = 0;
   // skip ahead the given number of records
-  skip(location.next());
+  this->pendingSkip_ = location.next();
 }
 
 template void RleDecoderV2<true>::seekToRowGroup(
@@ -173,27 +172,37 @@ template void RleDecoderV2<false>::seekToRowGroup(
     dwio::common::PositionProvider& location);
 
 template <bool isSigned>
-void RleDecoderV2<isSigned>::skip(uint64_t numValues) {
+void RleDecoderV2<isSigned>::skipPending() {
   // simple for now, until perf tests indicate something encoding specific is
   // needed
-  const uint64_t N = 64;
+  constexpr int64_t N = 64;
   int64_t dummy[N];
-
+  auto numValues = this->pendingSkip_;
+  this->pendingSkip_ = 0;
   while (numValues) {
     uint64_t nRead = std::min(N, numValues);
-    next(dummy, nRead, nullptr);
+    doNext(dummy, nRead, nullptr);
     numValues -= nRead;
   }
 }
 
-template void RleDecoderV2<true>::skip(uint64_t numValues);
-template void RleDecoderV2<false>::skip(uint64_t numValues);
+template void RleDecoderV2<true>::skipPending();
+template void RleDecoderV2<false>::skipPending();
 
 template <bool isSigned>
 void RleDecoderV2<isSigned>::next(
     int64_t* const data,
     const uint64_t numValues,
     const uint64_t* const nulls) {
+  skipPending();
+  doNext(data, numValues, nulls);
+}
+
+template <bool isSigned>
+void RleDecoderV2<isSigned>::doNext(
+    int64_t* const data,
+    const uint64_t numValues,
+    const uint64_t* const nulls) {
   uint64_t nRead = 0;
 
   while (nRead < numValues) {
@@ -204,13 +213,13 @@ void RleDecoderV2<isSigned>::next(
       }
     }
 
-    if (runRead == runLength) {
+    if (runRead_ == runLength_) {
       resetRun();
     }
 
     uint64_t offset = nRead, length = numValues - nRead;
 
-    switch (type) {
+    switch (type_) {
       case SHORT_REPEAT:
         nRead += nextShortRepeats(data, offset, length, nulls);
         break;
@@ -224,57 +233,58 @@ void RleDecoderV2<isSigned>::next(
         nRead += nextDelta(data, offset, length, nulls);
         break;
       default:
-        DWIO_RAISE("unknown encoding");
+        VELOX_FAIL("unknown encoding: {}", static_cast<int>(type_));
     }
   }
 }
 
-template void RleDecoderV2<true>::next(
+template void RleDecoderV2<true>::doNext(
     int64_t* const data,
     const uint64_t numValues,
     const uint64_t* const nulls);
-template void RleDecoderV2<false>::next(
+template void RleDecoderV2<false>::doNext(
     int64_t* const data,
     const uint64_t numValues,
     const uint64_t* const nulls);
 
 template <bool isSigned>
 uint64_t RleDecoderV2<isSigned>::nextShortRepeats(
-    int64_t* const data,
+    int64_t* data,
     uint64_t offset,
     uint64_t numValues,
-    const uint64_t* const nulls) {
-  if (runRead == runLength) {
+    const uint64_t* nulls) {
+  if (runRead_ == runLength_) {
     // extract the number of fixed bytes
-    byteSize = (firstByte >> 3) & 0x07;
-    byteSize += 1;
+    byteSize_ = (firstByte_ >> 3) & 0x07;
+    byteSize_ += 1;
 
-    runLength = firstByte & 0x07;
+    runLength_ = firstByte_ & 0x07;
     // run lengths values are stored only after MIN_REPEAT value is met
-    runLength += RLE_MINIMUM_REPEAT;
-    runRead = 0;
+    runLength_ += RLE_MINIMUM_REPEAT;
+    runRead_ = 0;
 
     // read the repeated value which is store using fixed bytes
-    firstValue = readLongBE(byteSize);
+    firstValue_ = readLongBE(byteSize_);
 
     if (isSigned) {
-      firstValue = ZigZag::decode<uint64_t>(static_cast<uint64_t>(firstValue));
+      firstValue_ =
+          ZigZag::decode<uint64_t>(static_cast<uint64_t>(firstValue_));
     }
   }
 
-  uint64_t nRead = std::min(runLength - runRead, numValues);
+  uint64_t nRead = std::min(runLength_ - runRead_, numValues);
 
   if (nulls) {
     for (uint64_t pos = offset; pos < offset + nRead; ++pos) {
       if (!bits::isBitNull(nulls, pos)) {
-        data[pos] = firstValue;
-        ++runRead;
+        data[pos] = firstValue_;
+        ++runRead_;
       }
     }
   } else {
     for (uint64_t pos = offset; pos < offset + nRead; ++pos) {
-      data[pos] = firstValue;
-      ++runRead;
+      data[pos] = firstValue_;
+      ++runRead_;
     }
   }
 
@@ -282,38 +292,38 @@ uint64_t RleDecoderV2<isSigned>::nextShortRepeats(
 }
 
 template uint64_t RleDecoderV2<true>::nextShortRepeats(
-    int64_t* const data,
+    int64_t* data,
     uint64_t offset,
     uint64_t numValues,
-    const uint64_t* const nulls);
+    const uint64_t* nulls);
 template uint64_t RleDecoderV2<false>::nextShortRepeats(
-    int64_t* const data,
+    int64_t* data,
     uint64_t offset,
     uint64_t numValues,
-    const uint64_t* const nulls);
+    const uint64_t* nulls);
 
 template <bool isSigned>
 uint64_t RleDecoderV2<isSigned>::nextDirect(
-    int64_t* const data,
+    int64_t* data,
     uint64_t offset,
     uint64_t numValues,
-    const uint64_t* const nulls) {
-  if (runRead == runLength) {
+    const uint64_t* nulls) {
+  if (runRead_ == runLength_) {
     // extract the number of fixed bits
-    unsigned char fbo = (firstByte >> 1) & 0x1f;
-    bitSize = decodeBitWidth(fbo);
+    unsigned char fbo = (firstByte_ >> 1) & 0x1f;
+    bitSize_ = decodeBitWidth(fbo);
 
     // extract the run length
-    runLength = static_cast<uint64_t>(firstByte & 0x01) << 8;
-    runLength |= readByte();
+    runLength_ = static_cast<uint64_t>(firstByte_ & 0x01) << 8;
+    runLength_ |= readByte();
     // runs are one off
-    runLength += 1;
-    runRead = 0;
+    runLength_ += 1;
+    runRead_ = 0;
   }
 
-  uint64_t nRead = std::min(runLength - runRead, numValues);
+  uint64_t nRead = std::min(runLength_ - runRead_, numValues);
 
-  runRead += readLongs(data, offset, nRead, bitSize, nulls);
+  runRead_ += readLongs(data, offset, nRead, bitSize_, nulls);
 
   if (isSigned) {
     if (nulls) {
@@ -350,27 +360,27 @@ uint64_t RleDecoderV2<isSigned>::nextPatched(
     uint64_t offset,
     uint64_t numValues,
     const uint64_t* const nulls) {
-  if (runRead == runLength) {
+  if (runRead_ == runLength_) {
     // extract the number of fixed bits
-    unsigned char fbo = (firstByte >> 1) & 0x1f;
-    bitSize = decodeBitWidth(fbo);
+    unsigned char fbo = (firstByte_ >> 1) & 0x1f;
+    bitSize_ = decodeBitWidth(fbo);
 
     // extract the run length
-    runLength = static_cast<uint64_t>(firstByte & 0x01) << 8;
-    runLength |= readByte();
+    runLength_ = static_cast<uint64_t>(firstByte_ & 0x01) << 8;
+    runLength_ |= readByte();
     // runs are one off
-    runLength += 1;
-    runRead = 0;
+    runLength_ += 1;
+    runRead_ = 0;
 
     // extract the number of bytes occupied by base
     uint64_t thirdByte = readByte();
-    byteSize = (thirdByte >> 5) & 0x07;
+    byteSize_ = (thirdByte >> 5) & 0x07;
     // base width is one off
-    byteSize += 1;
+    byteSize_ += 1;
 
     // extract patch width
     uint32_t pwo = thirdByte & 0x1f;
-    patchBitSize = decodeBitWidth(pwo);
+    patchBitSize_ = decodeBitWidth(pwo);
 
     // read fourth byte and extract patch gap width
     uint64_t fourthByte = readByte();
@@ -380,79 +390,79 @@ uint64_t RleDecoderV2<isSigned>::nextPatched(
 
     // extract the length of the patch list
     size_t pl = fourthByte & 0x1f;
-    DWIO_ENSURE_NE(
+    VELOX_CHECK_NE(
         pl,
         0,
         "Corrupt PATCHED_BASE encoded data (pl==0)! ",
-        dwio::common::IntDecoder<isSigned>::inputStream->getName());
+        dwio::common::IntDecoder<isSigned>::inputStream_->getName());
 
     // read the next base width number of bytes to extract base value
-    base = readLongBE(byteSize);
-    int64_t mask = (static_cast<int64_t>(1) << ((byteSize * 8) - 1));
+    base_ = readLongBE(byteSize_);
+    int64_t mask = (static_cast<int64_t>(1) << ((byteSize_ * 8) - 1));
     // if mask of base value is 1 then base is negative value else positive
-    if ((base & mask) != 0) {
-      base = base & ~mask;
-      base = -base;
+    if ((base_ & mask) != 0) {
+      base_ = base_ & ~mask;
+      base_ = -base_;
     }
 
     // TODO: something more efficient than resize
-    unpacked.resize(runLength);
-    unpackedIdx = 0;
-    readLongs(unpacked.data(), 0, runLength, bitSize);
+    unpacked_.resize(runLength_);
+    unpackedIdx_ = 0;
+    readLongs(unpacked_.data(), 0, runLength_, bitSize_);
     // any remaining bits are thrown out
     resetReadLongs();
 
     // TODO: something more efficient than resize
-    unpackedPatch.resize(pl);
-    patchIdx = 0;
+    unpackedPatch_.resize(pl);
+    patchIdx_ = 0;
     // TODO: Skip corrupt?
     //    if ((patchBitSize + pgw) > 64 && !skipCorrupt) {
-    DWIO_ENSURE_LE(
-        (patchBitSize + pgw),
+    VELOX_CHECK_LE(
+        (patchBitSize_ + pgw),
         64,
         "Corrupt PATCHED_BASE encoded data (patchBitSize + pgw > 64)! ",
-        dwio::common::IntDecoder<isSigned>::inputStream->getName());
-    uint32_t cfb = getClosestFixedBits(patchBitSize + pgw);
-    readLongs(unpackedPatch.data(), 0, pl, cfb);
+        dwio::common::IntDecoder<isSigned>::inputStream_->getName());
+    uint32_t cfb = getClosestFixedBits(patchBitSize_ + pgw);
+    readLongs(unpackedPatch_.data(), 0, pl, cfb);
     // any remaining bits are thrown out
     resetReadLongs();
 
     // apply the patch directly when decoding the packed data
-    patchMask = ((static_cast<int64_t>(1) << patchBitSize) - 1);
+    patchMask_ = ((static_cast<int64_t>(1) << patchBitSize_) - 1);
 
     adjustGapAndPatch();
   }
 
-  uint64_t nRead = std::min(runLength - runRead, numValues);
+  uint64_t nRead = std::min(runLength_ - runRead_, numValues);
 
   for (uint64_t pos = offset; pos < offset + nRead; ++pos) {
     // skip null positions
     if (nulls && bits::isBitNull(nulls, pos)) {
       continue;
     }
-    if (static_cast<int64_t>(unpackedIdx) != actualGap) {
+    if (static_cast<int64_t>(unpackedIdx_) != actualGap_) {
       // no patching required. add base to unpacked value to get final value
-      data[pos] = base + unpacked[unpackedIdx];
+      data[pos] = base_ + unpacked_[unpackedIdx_];
     } else {
       // extract the patch value
-      int64_t patchedVal = unpacked[unpackedIdx] | (curPatch << bitSize);
+      int64_t patchedVal = unpacked_[unpackedIdx_] | (curPatch_ << bitSize_);
 
       // add base to patched value
-      data[pos] = base + patchedVal;
+      data[pos] = base_ + patchedVal;
 
       // increment the patch to point to next entry in patch list
-      ++patchIdx;
+      ++patchIdx_;
 
-      if (patchIdx < unpackedPatch.size()) {
+      if (patchIdx_ < unpackedPatch_.size()) {
         adjustGapAndPatch();
 
         // next gap is relative to the current gap
-        actualGap += unpackedIdx;
+        actualGap_ += unpackedIdx_;
       }
     }
 
-    ++runRead;
-    ++unpackedIdx;
+    ++runRead_;
+    ++unpackedIdx_;
   }
 
   return nRead;
@@ -476,37 +486,37 @@ uint64_t RleDecoderV2<isSigned>::nextDelta(
     uint64_t offset,
     uint64_t numValues,
     const uint64_t* const nulls) {
-  if (runRead == runLength) {
+  if (runRead_ == runLength_) {
     // extract the number of fixed bits
-    unsigned char fbo = (firstByte >> 1) & 0x1f;
+    unsigned char fbo = (firstByte_ >> 1) & 0x1f;
     if (fbo != 0) {
-      bitSize = decodeBitWidth(fbo);
+      bitSize_ = decodeBitWidth(fbo);
     } else {
-      bitSize = 0;
+      bitSize_ = 0;
     }
 
     // extract the run length
-    runLength = static_cast<uint64_t>(firstByte & 0x01) << 8;
-    runLength |= readByte();
-    ++runLength; // account for first value
-    runRead = deltaBase = 0;
+    runLength_ = static_cast<uint64_t>(firstByte_ & 0x01) << 8;
+    runLength_ |= readByte();
+    ++runLength_; // account for first value
+    runRead_ = deltaBase_ = 0;
 
     // read the first value stored as vint
     if constexpr (isSigned) {
-      firstValue = dwio::common::IntDecoder<isSigned>::readVsLong();
+      firstValue_ = dwio::common::IntDecoder<isSigned>::readVsLong();
     } else {
-      firstValue = static_cast<int64_t>(
+      firstValue_ = static_cast<int64_t>(
           dwio::common::IntDecoder<isSigned>::readVuLong());
     }
 
-    prevValue = firstValue;
+    prevValue_ = firstValue_;
 
     // read the fixed delta value stored as vint (deltas can be negative even
     // if all number are positive)
-    deltaBase = dwio::common::IntDecoder<isSigned>::readVsLong();
+    deltaBase_ = dwio::common::IntDecoder<isSigned>::readVsLong();
   }
 
-  uint64_t nRead = std::min(runLength - runRead, numValues);
+  uint64_t nRead = std::min(runLength_ - runRead_, numValues);
 
   uint64_t pos = offset;
   for (; pos < offset + nRead; ++pos) {
@@ -515,20 +525,20 @@ uint64_t RleDecoderV2<isSigned>::nextDelta(
       break;
     }
   }
-  if (runRead == 0 && pos < offset + nRead) {
-    data[pos++] = firstValue;
-    ++runRead;
+  if (runRead_ == 0 && pos < offset + nRead) {
+    data[pos++] = firstValue_;
+    ++runRead_;
   }
 
-  if (bitSize == 0) {
+  if (bitSize_ == 0) {
     // add fixed deltas to adjacent values
     for (; pos < offset + nRead; ++pos) {
       // skip null positions
       if (nulls && bits::isBitNull(nulls, pos)) {
         continue;
       }
-      prevValue = data[pos] = prevValue + deltaBase;
-      ++runRead;
+      prevValue_ = data[pos] = prevValue_ + deltaBase_;
+      ++runRead_;
     }
   } else {
     for (; pos < offset + nRead; ++pos) {
@@ -537,25 +547,25 @@ uint64_t RleDecoderV2<isSigned>::nextDelta(
         break;
       }
     }
-    if (runRead < 2 && pos < offset + nRead) {
+    if (runRead_ < 2 && pos < offset + nRead) {
       // add delta base and first value
-      prevValue = data[pos++] = firstValue + deltaBase;
-      ++runRead;
+      prevValue_ = data[pos++] = firstValue_ + deltaBase_;
+      ++runRead_;
     }
 
     // write the unpacked values, add it to previous value and store final
     // value to result buffer. if the delta base value is negative then it
     // is a decreasing sequence else an increasing sequence
     uint64_t remaining = (offset + nRead) - pos;
-    runRead += readLongs(data, pos, remaining, bitSize, nulls);
+    runRead_ += readLongs(data, pos, remaining, bitSize_, nulls);
 
-    if (deltaBase < 0) {
+    if (deltaBase_ < 0) {
       for (; pos < offset + nRead; ++pos) {
         // skip null positions
         if (nulls && bits::isBitNull(nulls, pos)) {
           continue;
         }
-        prevValue = data[pos] = prevValue - data[pos];
+        prevValue_ = data[pos] = prevValue_ - data[pos];
       }
     } else {
       for (; pos < offset + nRead; ++pos) {
@@ -563,7 +573,7 @@ uint64_t RleDecoderV2<isSigned>::nextDelta(
         if (nulls && bits::isBitNull(nulls, pos)) {
           continue;
         }
-        prevValue = data[pos] = prevValue + data[pos];
+        prevValue_ = data[pos] = prevValue_ + data[pos];
       }
     }
   }
@@ -584,13 +594,13 @@ template uint64_t RleDecoderV2<false>::nextDelta(
 
 template <bool isSigned>
 int64_t RleDecoderV2<isSigned>::readValue() {
-  if (runRead == runLength) {
+  if (runRead_ == runLength_) {
     resetRun();
   }
 
   uint64_t nRead = 0;
   int64_t value = 0;
-  switch (type) {
+  switch (type_) {
     case SHORT_REPEAT:
       nRead = nextShortRepeats(&value, 0, 1, nullptr);
       break;
@@ -604,9 +614,9 @@ int64_t RleDecoderV2<isSigned>::readValue() {
       nRead = nextDelta(&value, 0, 1, nullptr);
       break;
     default:
-      DWIO_RAISE("unknown encoding");
+      VELOX_FAIL("unknown encoding: {}", static_cast<int>(type_));
   }
-  VELOX_CHECK(nRead == (uint64_t)1);
+  VELOX_CHECK_EQ(nRead, (uint64_t)1);
   return value;
 }
 
diff --git a/velox/dwio/dwrf/common/RLEv2.h b/velox/dwio/dwrf/common/RLEv2.h
index e15bc3e143faf..9feef3c748258 100644
--- a/velox/dwio/dwrf/common/RLEv2.h
+++ b/velox/dwio/dwrf/common/RLEv2.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include "velox/common/base/Nulls.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/dwio/common/Adaptor.h"
 #include "velox/dwio/common/DataBuffer.h"
@@ -46,10 +45,7 @@ class RleDecoderV2 : public dwio::common::IntDecoder<isSigned> {
    */
   void seekToRowGroup(dwio::common::PositionProvider&) override;
 
-  /**
-   * Seek over a given number of values.
-   */
-  void skip(uint64_t numValues) override;
+  void skipPending() override;
 
   /**
    * Read a number of values into the batch.
@@ -57,23 +53,17 @@ class RleDecoderV2 : public dwio::common::IntDecoder<isSigned> {
   void next(int64_t* data, uint64_t numValues, const uint64_t* nulls) override;
 
   void nextLengths(int32_t* const data, const int32_t numValues) override {
+    skipPending();
     for (int i = 0; i < numValues; ++i) {
       data[i] = readValue();
     }
   }
 
-  template <bool hasNulls>
-  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
-    if constexpr (hasNulls) {
-      numValues = bits::countNonNulls(nulls, current, current + numValues);
-    }
-    skip(numValues);
-  }
-
   template <bool hasNulls, typename Visitor>
   void readWithVisitor(const uint64_t* nulls, Visitor visitor) {
+    skipPending();
     int32_t current = visitor.start();
-    skip<hasNulls>(current, 0, nulls);
+    this->template skip<hasNulls>(current, 0, nulls);
 
     int32_t toSkip;
     bool atEnd = false;
@@ -86,7 +76,7 @@ class RleDecoderV2 : public dwio::common::IntDecoder<isSigned> {
         if (hasNulls && !allowNulls) {
           toSkip = visitor.checkAndSkipNulls(nulls, current, atEnd);
           if (!Visitor::dense) {
-            skip<false>(toSkip, current, nullptr);
+            this->template skip<false>(toSkip, current, nullptr);
           }
           if (atEnd) {
             return;
@@ -100,7 +90,7 @@ class RleDecoderV2 : public dwio::common::IntDecoder<isSigned> {
 
       ++current;
       if (toSkip) {
-        skip<hasNulls>(toSkip, current, nulls);
+        this->template skip<hasNulls>(toSkip, current, nulls);
         current += toSkip;
       }
       if (atEnd) {
@@ -112,52 +102,54 @@ class RleDecoderV2 : public dwio::common::IntDecoder<isSigned> {
  private:
   // Used by PATCHED_BASE
   void adjustGapAndPatch() {
-    curGap = static_cast<uint64_t>(unpackedPatch[patchIdx]) >> patchBitSize;
-    curPatch = unpackedPatch[patchIdx] & patchMask;
-    actualGap = 0;
+    curGap_ = static_cast<uint64_t>(unpackedPatch_[patchIdx_]) >> patchBitSize_;
+    curPatch_ = unpackedPatch_[patchIdx_] & patchMask_;
+    actualGap_ = 0;
 
     // special case: gap is >255 then patch value will be 0.
     // if gap is <=255 then patch value cannot be 0
-    while (curGap == 255 && curPatch == 0) {
-      actualGap += 255;
-      ++patchIdx;
-      curGap = static_cast<uint64_t>(unpackedPatch[patchIdx]) >> patchBitSize;
-      curPatch = unpackedPatch[patchIdx] & patchMask;
+    while (curGap_ == 255 && curPatch_ == 0) {
+      actualGap_ += 255;
+      ++patchIdx_;
+      curGap_ =
+          static_cast<uint64_t>(unpackedPatch_[patchIdx_]) >> patchBitSize_;
+      curPatch_ = unpackedPatch_[patchIdx_] & patchMask_;
     }
     // add the left over gap
-    actualGap += curGap;
+    actualGap_ += curGap_;
   }
 
   void resetReadLongs() {
-    bitsLeft = 0;
-    curByte = 0;
+    bitsLeft_ = 0;
+    curByte_ = 0;
   }
 
   void resetRun() {
     resetReadLongs();
-    bitSize = 0;
-    firstByte = readByte();
-    type = static_cast<EncodingType>((firstByte >> 6) & 0x03);
+    bitSize_ = 0;
+    firstByte_ = readByte();
+    type_ = static_cast<EncodingType>((firstByte_ >> 6) & 0x03);
   }
 
   unsigned char readByte() {
-    if (dwio::common::IntDecoder<isSigned>::bufferStart ==
-        dwio::common::IntDecoder<isSigned>::bufferEnd) {
+    if (dwio::common::IntDecoder<isSigned>::bufferStart_ ==
+        dwio::common::IntDecoder<isSigned>::bufferEnd_) {
       int32_t bufferLength;
       const void* bufferPointer;
-      DWIO_ENSURE(
-          dwio::common::IntDecoder<isSigned>::inputStream->Next(
-              &bufferPointer, &bufferLength),
+      const bool ret = dwio::common::IntDecoder<isSigned>::inputStream_->Next(
+          &bufferPointer, &bufferLength);
+      VELOX_CHECK(
+          ret,
           "bad read in RleDecoderV2::readByte, ",
-          dwio::common::IntDecoder<isSigned>::inputStream->getName());
-      dwio::common::IntDecoder<isSigned>::bufferStart =
+          dwio::common::IntDecoder<isSigned>::inputStream_->getName());
+      dwio::common::IntDecoder<isSigned>::bufferStart_ =
           static_cast<const char*>(bufferPointer);
-      dwio::common::IntDecoder<isSigned>::bufferEnd =
-          dwio::common::IntDecoder<isSigned>::bufferStart + bufferLength;
+      dwio::common::IntDecoder<isSigned>::bufferEnd_ =
+          dwio::common::IntDecoder<isSigned>::bufferStart_ + bufferLength;
     }
 
     unsigned char result = static_cast<unsigned char>(
-        *dwio::common::IntDecoder<isSigned>::bufferStart++);
+        *dwio::common::IntDecoder<isSigned>::bufferStart_++);
     return result;
   }
 
@@ -178,19 +170,19 @@ class RleDecoderV2 : public dwio::common::IntDecoder<isSigned> {
       }
       uint64_t result = 0;
       uint64_t bitsLeftToRead = fb;
-      while (bitsLeftToRead > bitsLeft) {
-        result <<= bitsLeft;
-        result |= curByte & ((1 << bitsLeft) - 1);
-        bitsLeftToRead -= bitsLeft;
-        curByte = readByte();
-        bitsLeft = 8;
+      while (bitsLeftToRead > bitsLeft_) {
+        result <<= bitsLeft_;
+        result |= curByte_ & ((1 << bitsLeft_) - 1);
+        bitsLeftToRead -= bitsLeft_;
+        curByte_ = readByte();
+        bitsLeft_ = 8;
       }
 
       // handle the left over bits
       if (bitsLeftToRead > 0) {
         result <<= bitsLeftToRead;
-        bitsLeft -= static_cast<uint32_t>(bitsLeftToRead);
-        result |= (curByte >> bitsLeft) & ((1 << bitsLeftToRead) - 1);
+        bitsLeft_ -= static_cast<uint32_t>(bitsLeftToRead);
+        result |= (curByte_ >> bitsLeft_) & ((1 << bitsLeftToRead) - 1);
       }
       data[i] = static_cast<int64_t>(result);
       ++ret;
@@ -222,27 +214,32 @@ class RleDecoderV2 : public dwio::common::IntDecoder<isSigned> {
 
   int64_t readValue();
 
-  unsigned char firstByte;
-  uint64_t runLength;
-  uint64_t runRead;
-  int64_t deltaBase; // Used by DELTA
-  uint64_t byteSize; // Used by SHORT_REPEAT and PATCHED_BASE
-  int64_t firstValue; // Used by SHORT_REPEAT and DELTA
-  int64_t prevValue; // Used by DELTA
-  uint32_t bitSize; // Used by DIRECT, PATCHED_BASE and DELTA
-  uint32_t bitsLeft; // Used by anything that uses readLongs
-  uint32_t curByte; // Used by anything that uses readLongs
-  uint32_t patchBitSize; // Used by PATCHED_BASE
-  uint64_t unpackedIdx; // Used by PATCHED_BASE
-  uint64_t patchIdx; // Used by PATCHED_BASE
-  int64_t base; // Used by PATCHED_BASE
-  uint64_t curGap; // Used by PATCHED_BASE
-  int64_t curPatch; // Used by PATCHED_BASE
-  int64_t patchMask; // Used by PATCHED_BASE
-  int64_t actualGap; // Used by PATCHED_BASE
-  EncodingType type;
-  dwio::common::DataBuffer<int64_t> unpacked; // Used by PATCHED_BASE
-  dwio::common::DataBuffer<int64_t> unpackedPatch; // Used by PATCHED_BASE
+  void doNext(
+      int64_t* const data,
+      const uint64_t numValues,
+      const uint64_t* const nulls);
+
+  unsigned char firstByte_;
+  uint64_t runLength_;
+  uint64_t runRead_;
+  int64_t deltaBase_; // Used by DELTA
+  uint64_t byteSize_; // Used by SHORT_REPEAT and PATCHED_BASE
+  int64_t firstValue_; // Used by SHORT_REPEAT and DELTA
+  int64_t prevValue_; // Used by DELTA
+  uint32_t bitSize_; // Used by DIRECT, PATCHED_BASE and DELTA
+  uint32_t bitsLeft_; // Used by anything that uses readLongs
+  uint32_t curByte_; // Used by anything that uses readLongs
+  uint32_t patchBitSize_; // Used by PATCHED_BASE
+  uint64_t unpackedIdx_; // Used by PATCHED_BASE
+  uint64_t patchIdx_; // Used by PATCHED_BASE
+  int64_t base_; // Used by PATCHED_BASE
+  uint64_t curGap_; // Used by PATCHED_BASE
+  int64_t curPatch_; // Used by PATCHED_BASE
+  int64_t patchMask_; // Used by PATCHED_BASE
+  int64_t actualGap_; // Used by PATCHED_BASE
+  EncodingType type_;
+  dwio::common::DataBuffer<int64_t> unpacked_; // Used by PATCHED_BASE
+  dwio::common::DataBuffer<int64_t> unpackedPatch_; // Used by PATCHED_BASE
 };
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/common/Statistics.cpp b/velox/dwio/dwrf/common/Statistics.cpp
index af4bddcc8692e..57d8cea80c6fd 100644
--- a/velox/dwio/dwrf/common/Statistics.cpp
+++ b/velox/dwio/dwrf/common/Statistics.cpp
@@ -21,74 +21,77 @@ namespace facebook::velox::dwrf {
 using namespace dwio::common;
 
 std::unique_ptr<ColumnStatistics> buildColumnStatisticsFromProto(
-    const proto::ColumnStatistics& s,
+    const ColumnStatisticsWrapper& stats,
     const StatsContext& statsContext) {
   ColumnStatistics colStats(
-      s.has_numberofvalues() ? std::optional(s.numberofvalues()) : std::nullopt,
-      s.has_hasnull() ? std::optional(s.hasnull()) : std::nullopt,
-      s.has_rawsize() ? std::optional(s.rawsize()) : std::nullopt,
-      s.has_size() ? std::optional(s.size()) : std::nullopt);
+      stats.hasNumberOfValues() ? std::optional(stats.numberOfValues())
+                                : std::nullopt,
+      stats.hasHasNull() ? std::optional(stats.hasNull()) : std::nullopt,
+      stats.hasRawSize() ? std::optional(stats.rawSize()) : std::nullopt,
+      stats.hasSize() ? std::optional(stats.size()) : std::nullopt);
 
   // detailed stats is only defined when has non-null value
-  if (!s.has_numberofvalues() || s.numberofvalues() > 0) {
-    if (s.has_intstatistics()) {
-      const auto& intStats = s.intstatistics();
+  if (!stats.hasNumberOfValues() || stats.numberOfValues() > 0) {
+    if (stats.hasIntStatistics()) {
+      const auto& intStats = stats.intStatistics();
       return std::make_unique<IntegerColumnStatistics>(
           colStats,
-          intStats.has_minimum() ? std::optional(intStats.minimum())
-                                 : std::nullopt,
-          intStats.has_maximum() ? std::optional(intStats.maximum())
-                                 : std::nullopt,
-          intStats.has_sum() ? std::optional(intStats.sum()) : std::nullopt);
-    } else if (s.has_doublestatistics()) {
-      const auto& dStats = s.doublestatistics();
+          intStats.hasMinimum() ? std::optional(intStats.minimum())
+                                : std::nullopt,
+          intStats.hasMaximum() ? std::optional(intStats.maximum())
+                                : std::nullopt,
+          intStats.hasSum() ? std::optional(intStats.sum()) : std::nullopt);
+    } else if (stats.hasDoubleStatistics()) {
+      const auto& doubleStats = stats.doubleStatistics();
       // Comparing against NaN doesn't make sense, and to prevent downstream
       // from incorrectly using it, need to make sure min/max/sum doens't have
       // NaN.
-      auto hasNan = (dStats.has_minimum() && std::isnan(dStats.minimum())) ||
-          (dStats.has_maximum() && std::isnan(dStats.maximum())) ||
-          (dStats.has_sum() && std::isnan(dStats.sum()));
+      const auto hasNan =
+          (doubleStats.hasMinimum() && std::isnan(doubleStats.minimum())) ||
+          (doubleStats.hasMaximum() && std::isnan(doubleStats.maximum())) ||
+          (doubleStats.hasSum() && std::isnan(doubleStats.sum()));
       if (!hasNan) {
         return std::make_unique<DoubleColumnStatistics>(
             colStats,
-            dStats.has_minimum() ? std::optional(dStats.minimum())
-                                 : std::nullopt,
-            dStats.has_maximum() ? std::optional(dStats.maximum())
-                                 : std::nullopt,
-            dStats.has_sum() ? std::optional(dStats.sum()) : std::nullopt);
+            doubleStats.hasMinimum() ? std::optional(doubleStats.minimum())
+                                     : std::nullopt,
+            doubleStats.hasMaximum() ? std::optional(doubleStats.maximum())
+                                     : std::nullopt,
+            doubleStats.hasSum() ? std::optional(doubleStats.sum())
+                                 : std::nullopt);
       }
-    } else if (s.has_stringstatistics()) {
+    } else if (stats.hasStringStatistics()) {
       // DWRF_5_0 is the first version that string stats are saved as UTF8
       // bytes, hence only process string stats for version >= DWRF_5_0
       if (statsContext.writerVersion >= WriterVersion::DWRF_5_0 ||
           statsContext.writerName == kPrestoWriter ||
           statsContext.writerName == kDwioWriter) {
-        const auto& strStats = s.stringstatistics();
+        const auto& strStats = stats.stringStatistics();
         return std::make_unique<StringColumnStatistics>(
             colStats,
-            strStats.has_minimum() ? std::optional(strStats.minimum())
-                                   : std::nullopt,
-            strStats.has_maximum() ? std::optional(strStats.maximum())
-                                   : std::nullopt,
+            strStats.hasMinimum() ? std::optional(strStats.minimum())
+                                  : std::nullopt,
+            strStats.hasMaximum() ? std::optional(strStats.maximum())
+                                  : std::nullopt,
             // In proto, length(sum) is defined as sint. We need to make sure
             // length is not negative
-            (strStats.has_sum() && strStats.sum() >= 0)
+            (strStats.hasSum() && strStats.sum() >= 0)
                 ? std::optional(strStats.sum())
                 : std::nullopt);
       }
-    } else if (s.has_bucketstatistics()) {
-      const auto& bucketStats = s.bucketstatistics();
+    } else if (stats.hasBucketStatistics()) {
+      const auto& bucketStats = stats.bucketStatistics();
       // Need to make sure there is at least one bucket. True count is saved in
       // bucket 0
-      if (bucketStats.count_size() > 0) {
+      if (bucketStats.countSize() > 0) {
         return std::make_unique<BooleanColumnStatistics>(
             colStats, bucketStats.count(0));
       }
-    } else if (s.has_binarystatistics()) {
-      const auto& binStats = s.binarystatistics();
+    } else if (stats.hasBinaryStatistics()) {
+      const auto& binStats = stats.binaryStatistics();
       // In proto, length(sum) is defined as sint. We need to make sure length
       // is not negative
-      if (binStats.has_sum() && binStats.sum() >= 0) {
+      if (binStats.hasSum() && binStats.sum() >= 0) {
         return std::make_unique<BinaryColumnStatistics>(
             colStats, static_cast<uint64_t>(binStats.sum()));
       }
diff --git a/velox/dwio/dwrf/common/Statistics.h b/velox/dwio/dwrf/common/Statistics.h
index 0f26682fe1db0..864fb08db3721 100644
--- a/velox/dwio/dwrf/common/Statistics.h
+++ b/velox/dwio/dwrf/common/Statistics.h
@@ -18,6 +18,7 @@
 
 #include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/dwrf/common/Common.h"
+#include "velox/dwio/dwrf/common/FileMetadata.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 
 namespace facebook::velox::dwrf {
@@ -39,7 +40,7 @@ struct StatsContext : public dwio::common::StatsContext {
 };
 
 std::unique_ptr<dwio::common::ColumnStatistics> buildColumnStatisticsFromProto(
-    const proto::ColumnStatistics& stats,
+    const ColumnStatisticsWrapper& stats,
     const StatsContext& statsContext);
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/proto/CMakeLists.txt b/velox/dwio/dwrf/proto/CMakeLists.txt
index 02ff2c8d7fc5c..299587a1f4158 100644
--- a/velox/dwio/dwrf/proto/CMakeLists.txt
+++ b/velox/dwio/dwrf/proto/CMakeLists.txt
@@ -30,20 +30,27 @@ endforeach()
 set(PROTO_OUTPUT_FILES ${PROTO_HDRS} ${PROTO_SRCS})
 set_source_files_properties(${PROTO_OUTPUT_FILES} PROPERTIES GENERATED TRUE)
 
+# Ensure that the option --proto_path is not given an empty argument
+foreach(PROTO_PATH ${CMAKE_SOURCE_DIR} ${Protobuf_INCLUDE_DIRS})
+  list(APPEND PROTO_PATH_ARGS --proto_path=${PROTO_PATH})
+endforeach()
+
 add_custom_command(
   OUTPUT ${PROTO_OUTPUT_FILES}
-  COMMAND
-    ${Protobuf_PROTOC_EXECUTABLE} --proto_path ${CMAKE_SOURCE_DIR}/ --proto_path
-    ${Protobuf_INCLUDE_DIRS} --cpp_out ${CMAKE_BINARY_DIR} ${PROTO_FILES_FULL}
-  DEPENDS ${Protobuf_PROTOC_EXECUTABLE}
+  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${CMAKE_BINARY_DIR}
+          ${PROTO_FILES_FULL}
+  DEPENDS protobuf::protoc
   COMMENT "Running PROTO compiler"
   VERBATIM)
 add_custom_target(dwio_proto ALL DEPENDS ${PROTO_OUTPUT_FILES})
 
-add_library(velox_dwio_dwrf_proto ${PROTO_HDRS} ${PROTO_SRCS})
+if(VELOX_MONO_LIBRARY)
+  add_dependencies(velox dwio_proto)
+endif()
+velox_add_library(velox_dwio_dwrf_proto ${PROTO_HDRS} ${PROTO_SRCS})
 
 # Access generated proto file with.
 #
 # #include "velox/dwio/dwrf/proto/dwrf_proto.pb.h"
-target_link_libraries(velox_dwio_dwrf_proto ${Protobuf_LIBRARIES})
-target_include_directories(velox_dwio_dwrf_proto PUBLIC ${PROJECT_BINARY_DIR})
+velox_link_libraries(velox_dwio_dwrf_proto protobuf::libprotobuf)
+velox_include_directories(velox_dwio_dwrf_proto PUBLIC ${PROJECT_BINARY_DIR})
diff --git a/velox/dwio/dwrf/reader/BinaryStreamReader.cpp b/velox/dwio/dwrf/reader/BinaryStreamReader.cpp
index d7f5fafa398bc..9d8f5a5bf05f4 100644
--- a/velox/dwio/dwrf/reader/BinaryStreamReader.cpp
+++ b/velox/dwio/dwrf/reader/BinaryStreamReader.cpp
@@ -32,13 +32,17 @@ BinaryStripeStreams::BinaryStripeStreams(
     const dwio::common::ColumnSelector& selector,
     const uint32_t stripeIndex)
     : preload_(true), // TODO: is preload required ?
-      stripeInfo_{stripeReader.loadStripe(stripeIndex, preload_)},
+      stripeReadState_{std::make_shared<StripeReadState>(
+          stripeReader.readerBaseShared(),
+          stripeReader.fetchStripe(stripeIndex, preload_))},
       stripeStreams_{
-          stripeReader,
-          selector,
+          stripeReadState_,
+          &selector,
+          nullptr,
           options_,
-          stripeInfo_.offset(),
-          static_cast<int64_t>(stripeInfo_.numberOfRows()),
+          stripeReadState_->stripeMetadata->stripeInfo.offset(),
+          static_cast<int64_t>(
+              stripeReadState_->stripeMetadata->stripeInfo.numberOfRows()),
           UnsupportedStrideIndexProvider(),
           stripeIndex} {
   if (!preload_) {
@@ -81,16 +85,16 @@ std::vector<DwrfStreamIdentifier> BinaryStripeStreams::getStreamIdentifiers(
 BinaryStreamReader::BinaryStreamReader(
     const std::shared_ptr<ReaderBase>& reader,
     const std::vector<uint64_t>& columnIds)
-    : stripeReaderBase_{reader},
-      columnSelector_{reader->getSchema(), columnIds},
-      stripeIndex_{0},
-      numStripes{folly::to<uint32_t>(reader->getFooter().stripesSize())} {
-  DWIO_ENSURE(!reader->getFooter().hasEncryption(), "encryption not supported");
-  DWIO_ENSURE(!columnIds.empty(), "Atleast one column expected to be read");
+    : columnSelector_{reader->schema(), columnIds},
+      numStripes_{folly::to<uint32_t>(reader->footer().stripesSize())},
+      stripeReaderBase_{reader},
+      stripeIndex_{0} {
+  VELOX_CHECK(!reader->footer().hasEncryption(), "encryption not supported");
+  VELOX_CHECK(!columnIds.empty(), "Atleast one column expected to be read");
 }
 
 std::unique_ptr<BinaryStripeStreams> BinaryStreamReader::next() {
-  if (stripeIndex_ >= numStripes) {
+  if (stripeIndex_ >= numStripes_) {
     return nullptr;
   }
   return std::make_unique<BinaryStripeStreams>(
@@ -101,12 +105,12 @@ std::unordered_map<uint32_t, proto::ColumnStatistics>
 BinaryStreamReader::getStatistics() const {
   std::unordered_map<uint32_t, proto::ColumnStatistics> stats;
   auto footerStatsSize =
-      stripeReaderBase_.getReader().getFooter().statisticsSize();
-  auto typesSize = stripeReaderBase_.getReader().getFooter().typesSize();
+      stripeReaderBase_.getReader().footer().statisticsSize();
+  auto typesSize = stripeReaderBase_.getReader().footer().typesSize();
 
   if (footerStatsSize == 0) {
-    DWIO_ENSURE_EQ(
-        numStripes,
+    VELOX_CHECK_EQ(
+        numStripes_,
         0,
         "Corrupted file detected, Footer stats are missing, but stripes are present");
     for (auto node = 0; node < typesSize; node++) {
@@ -115,14 +119,14 @@ BinaryStreamReader::getStatistics() const {
       }
     }
   } else {
-    DWIO_ENSURE_EQ(
+    VELOX_CHECK_EQ(
         footerStatsSize, typesSize, "different number of nodes and statistics");
     // Node 0 is always selected by ColumnSelector, though this can be
     // disabled for the current use cases.
     for (auto node = 0; node < footerStatsSize; node++) {
       if (columnSelector_.shouldReadNode(node)) {
         stats[node] =
-            stripeReaderBase_.getReader().getFooter().statistics(node);
+            stripeReaderBase_.getReader().footer().dwrfStatistics(node);
       }
     }
   }
@@ -130,7 +134,7 @@ BinaryStreamReader::getStatistics() const {
 }
 
 uint32_t BinaryStreamReader::getStrideLen() const {
-  return stripeReaderBase_.getReader().getFooter().rowIndexStride();
+  return stripeReaderBase_.getReader().footer().rowIndexStride();
 }
 
 } // namespace facebook::velox::dwrf::detail
diff --git a/velox/dwio/dwrf/reader/BinaryStreamReader.h b/velox/dwio/dwrf/reader/BinaryStreamReader.h
index fb6cca972ab67..d418bfa48c1fb 100644
--- a/velox/dwio/dwrf/reader/BinaryStreamReader.h
+++ b/velox/dwio/dwrf/reader/BinaryStreamReader.h
@@ -52,12 +52,12 @@ class BinaryStripeStreams {
   }
 
   const StripeInformationWrapper& getStripeInfo() const {
-    return stripeInfo_;
+    return stripeReadState_->stripeMetadata->stripeInfo;
   }
 
  private:
   bool preload_;
-  StripeInformationWrapper stripeInfo_;
+  std::shared_ptr<StripeReadState> stripeReadState_;
   dwio::common::RowReaderOptions options_;
   StripeStreamsImpl stripeStreams_;
   folly::F14FastMap<uint32_t, std::vector<uint32_t>> encodingKeys_;
@@ -67,7 +67,7 @@ class BinaryStripeStreams {
 
 class BinaryStreamReader {
  public:
-  explicit BinaryStreamReader(
+  BinaryStreamReader(
       const std::shared_ptr<ReaderBase>& reader,
       const std::vector<uint64_t>& columnIds);
 
@@ -81,13 +81,15 @@ class BinaryStreamReader {
     return stripeIndex_;
   }
 
+  uint32_t numStripes() const {
+    return numStripes_;
+  }
+
  private:
-  StripeReaderBase stripeReaderBase_;
   const dwio::common::ColumnSelector columnSelector_;
+  const uint32_t numStripes_;
+  StripeReaderBase stripeReaderBase_;
   uint32_t stripeIndex_;
-
- public:
-  const uint32_t numStripes;
 };
 
 } // namespace facebook::velox::dwrf::detail
diff --git a/velox/dwio/dwrf/reader/CMakeLists.txt b/velox/dwio/dwrf/reader/CMakeLists.txt
index 360d88bc1cf9a..cae8fcc24bbe1 100644
--- a/velox/dwio/dwrf/reader/CMakeLists.txt
+++ b/velox/dwio/dwrf/reader/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(
   velox_dwio_dwrf_reader
   BinaryStreamReader.cpp
   ColumnReader.cpp
@@ -35,6 +35,11 @@ add_library(
   StripeReaderBase.cpp
   StripeStream.cpp)
 
-target_link_libraries(
-  velox_dwio_dwrf_reader velox_dwio_common velox_dwio_dwrf_common velox_caching
-  velox_dwio_dwrf_utils fmt::fmt)
+velox_link_libraries(
+  velox_dwio_dwrf_reader
+  velox_dwio_common
+  velox_dwio_dwrf_common
+  velox_caching
+  velox_dwio_dwrf_utils
+  velox_test_util
+  fmt::fmt)
diff --git a/velox/dwio/dwrf/reader/ColumnReader.cpp b/velox/dwio/dwrf/reader/ColumnReader.cpp
index 4e5f10e6bd67b..9a11e9ebb5679 100644
--- a/velox/dwio/dwrf/reader/ColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/ColumnReader.cpp
@@ -17,6 +17,7 @@
 #include "velox/dwio/dwrf/reader/ColumnReader.h"
 #include "velox/dwio/common/IntCodecCommon.h"
 #include "velox/dwio/common/IntDecoder.h"
+#include "velox/dwio/common/ParallelFor.h"
 #include "velox/dwio/common/TypeUtils.h"
 #include "velox/dwio/common/exception/Exceptions.h"
 #include "velox/dwio/dwrf/common/DecoderUtil.h"
@@ -133,14 +134,14 @@ void ColumnReader::readNulls(
 }
 
 ColumnReader::ColumnReader(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     FlatMapContext flatMapContext)
-    : nodeType_(std::move(nodeType)),
+    : fileType_(std::move(fileType)),
       memoryPool_(stripe.getMemoryPool()),
       flatMapContext_(std::move(flatMapContext)) {
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   std::unique_ptr<dwio::common::SeekableInputStream> stream = stripe.getStream(
       encodingKey.forKind(proto::Stream_Kind_PRESENT),
       streamLabels.label(),
@@ -195,15 +196,15 @@ std::enable_if_t<std::is_same_v<From, int8_t>> expandBytes(
   }
 }
 
-template <typename DataType, typename RequestedType>
+template <typename FileType, typename RequestedType>
 class ByteRleColumnReader : public ColumnReader {
  private:
   std::unique_ptr<ByteRleDecoder> rle;
 
  public:
   ByteRleColumnReader(
-      std::shared_ptr<const dwio::common::TypeWithId> nodeType,
       TypePtr requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       std::function<std::unique_ptr<ByteRleDecoder>(
@@ -211,12 +212,12 @@ class ByteRleColumnReader : public ColumnReader {
           const EncodingKey&)> creator,
       FlatMapContext flatMapContext)
       : ColumnReader(
-            std::move(nodeType),
+            std::move(fileType),
             stripe,
             streamLabels,
             std::move(flatMapContext)),
         requestedType_{std::move(requestedType)} {
-    EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+    EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
     rle = creator(
         stripe.getStream(
             encodingKey.forKind(proto::Stream_Kind_DATA),
@@ -235,8 +236,8 @@ class ByteRleColumnReader : public ColumnReader {
   const TypePtr requestedType_;
 };
 
-template <typename DataType, typename RequestedType>
-uint64_t ByteRleColumnReader<DataType, RequestedType>::skip(
+template <typename FileType, typename RequestedType>
+uint64_t ByteRleColumnReader<FileType, RequestedType>::skip(
     uint64_t numValues) {
   numValues = ColumnReader::skip(numValues);
   rle->skip(numValues);
@@ -257,8 +258,8 @@ VectorPtr makeFlatVector(
   return flatVector;
 }
 
-template <typename DataType, typename RequestedType>
-void ByteRleColumnReader<DataType, RequestedType>::next(
+template <typename FileType, typename RequestedType>
+void ByteRleColumnReader<FileType, RequestedType>::next(
     uint64_t numValues,
     VectorPtr& result,
     const uint64_t* incomingNulls) {
@@ -299,10 +300,10 @@ void ByteRleColumnReader<DataType, RequestedType>::next(
 
   // Handle upcast
   if constexpr (
-      !std::is_same_v<DataType, RequestedType> &&
-      (std::is_same_v<DataType, bool> ||
-       sizeof(DataType) < sizeof(RequestedType))) {
-    expandBytes<DataType>(valuesPtr, numValues);
+      !std::is_same_v<FileType, RequestedType> &&
+      (std::is_same_v<FileType, bool> ||
+       sizeof(FileType) < sizeof(RequestedType))) {
+    expandBytes<FileType>(valuesPtr, numValues);
   }
 }
 
@@ -333,17 +334,6 @@ struct TemplatedReadHelper<IntDecoderT, int32_t> {
   }
 };
 
-template <class IntDecoderT>
-struct TemplatedReadHelper<IntDecoderT, Date> {
-  static void nextValues(
-      IntDecoderT& decoder,
-      Date* data,
-      uint64_t numValues,
-      const uint64_t* nulls) {
-    decoder.nextInts(reinterpret_cast<int32_t*>(data), numValues, nulls);
-  }
-};
-
 template <class IntDecoderT>
 struct TemplatedReadHelper<IntDecoderT, int64_t> {
   static void nextValues(
@@ -377,8 +367,8 @@ class DecimalColumnReader : public ColumnReader {
 
  public:
   DecimalColumnReader(
-      std::shared_ptr<const dwio::common::TypeWithId> nodeType,
       TypePtr requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       FlatMapContext flatMapContext);
@@ -393,18 +383,18 @@ class DecimalColumnReader : public ColumnReader {
 
 template <typename DataT>
 DecimalColumnReader<DataT>::DecimalColumnReader(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
     TypePtr requestedType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     FlatMapContext flatMapContext)
     : ColumnReader(
-          std::move(nodeType),
+          std::move(fileType),
           stripe,
           streamLabels,
           std::move(flatMapContext)),
       requestedType_(std::move(requestedType)) {
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   if constexpr (std::is_same_v<DataT, std::int64_t>) {
     scale_ = requestedType_->asShortDecimal().scale();
   } else {
@@ -483,8 +473,8 @@ template <class ReqT>
 class IntegerDirectColumnReader : public ColumnReader {
  public:
   IntegerDirectColumnReader(
-      std::shared_ptr<const dwio::common::TypeWithId> nodeType,
       TypePtr requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       uint32_t numBytes,
@@ -504,19 +494,19 @@ class IntegerDirectColumnReader : public ColumnReader {
 
 template <class ReqT>
 IntegerDirectColumnReader<ReqT>::IntegerDirectColumnReader(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
     TypePtr requestedType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     uint32_t numBytes,
     FlatMapContext flatMapContext)
     : ColumnReader(
-          std::move(nodeType),
+          std::move(fileType),
           stripe,
           streamLabels,
           std::move(flatMapContext)),
       requestedType_{std::move(requestedType)} {
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   auto data = encodingKey.forKind(proto::Stream_Kind_DATA);
   bool dataVInts = stripe.getUseVInts(data);
   if (stripe.format() == DwrfFormat::kDwrf) {
@@ -580,8 +570,8 @@ template <class ReqT>
 class IntegerDictionaryColumnReader : public ColumnReader {
  public:
   IntegerDictionaryColumnReader(
-      std::shared_ptr<const dwio::common::TypeWithId> nodeType,
       TypePtr requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       uint32_t numBytes,
@@ -648,19 +638,19 @@ class IntegerDictionaryColumnReader : public ColumnReader {
 
 template <class ReqT>
 IntegerDictionaryColumnReader<ReqT>::IntegerDictionaryColumnReader(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
     TypePtr requestedType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     uint32_t numBytes,
     FlatMapContext flatMapContext)
     : ColumnReader(
-          std::move(nodeType),
+          std::move(fileType),
           stripe,
           streamLabels,
           std::move(flatMapContext)),
       requestedType_{std::move(requestedType)} {
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   auto encoding = stripe.getEncoding(encodingKey);
   dictionarySize = encoding.dictionarysize();
 
@@ -767,7 +757,7 @@ class TimestampColumnReader : public ColumnReader {
 
  public:
   TimestampColumnReader(
-      std::shared_ptr<const dwio::common::TypeWithId> nodeType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       FlatMapContext flatMapContext);
@@ -780,16 +770,16 @@ class TimestampColumnReader : public ColumnReader {
 };
 
 TimestampColumnReader::TimestampColumnReader(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     FlatMapContext flatMapContext)
     : ColumnReader(
-          std::move(nodeType),
+          std::move(fileType),
           stripe,
           streamLabels,
           std::move(flatMapContext)) {
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   RleVersion vers = convertRleVersion(stripe.getEncoding(encodingKey).kind());
   auto data = encodingKey.forKind(proto::Stream_Kind_DATA);
   bool vints = stripe.getUseVInts(data);
@@ -873,8 +863,8 @@ template <class DataT, class ReqT>
 class FloatingPointColumnReader : public ColumnReader {
  public:
   FloatingPointColumnReader(
-      std::shared_ptr<const dwio::common::TypeWithId> nodeType,
       TypePtr requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       FlatMapContext flatMapContext);
@@ -927,19 +917,19 @@ class FloatingPointColumnReader : public ColumnReader {
 
 template <class DataT, class ReqT>
 FloatingPointColumnReader<DataT, ReqT>::FloatingPointColumnReader(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
     TypePtr requestedType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     FlatMapContext flatMapContext)
     : ColumnReader(
-          std::move(nodeType),
+          std::move(fileType),
           stripe,
           streamLabels,
           std::move(flatMapContext)),
       requestedType_{std::move(requestedType)},
       inputStream(stripe.getStream(
-          EncodingKey{nodeType_->id(), flatMapContext_.sequence}.forKind(
+          EncodingKey{fileType_->id(), flatMapContext_.sequence}.forKind(
               proto::Stream_Kind_DATA),
           streamLabels.label(),
           true)),
@@ -956,7 +946,7 @@ uint64_t FloatingPointColumnReader<DataT, ReqT>::skip(uint64_t numValues) {
   if (remaining >= toSkip) {
     bufferPointer += toSkip;
   } else {
-    inputStream->Skip(static_cast<int32_t>(toSkip - remaining));
+    inputStream->SkipInt64(toSkip - remaining);
     bufferEnd = nullptr;
     bufferPointer = nullptr;
   }
@@ -1118,7 +1108,6 @@ class StringDictionaryColumnReader : public ColumnReader {
   std::unique_ptr<dwio::common::SeekableInputStream> strideDictStream_;
   std::unique_ptr<dwio::common::IntDecoder</*isSigned*/ false>>
       strideDictLengthDecoder_;
-
   FlatVectorPtr<StringView> combinedDictionaryValues_;
   FlatVectorPtr<StringView> dictionaryValues_;
 
@@ -1140,14 +1129,14 @@ class StringDictionaryColumnReader : public ColumnReader {
 };
 
 StringDictionaryColumnReader::StringDictionaryColumnReader(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     const EncodingKey& encodingKey,
     const RleVersion& rleVersion,
     FlatMapContext flatMapContext)
     : ColumnReader(
-          std::move(nodeType),
+          std::move(fileType),
           stripe,
           streamLabels,
           std::move(flatMapContext)),
@@ -1158,7 +1147,7 @@ StringDictionaryColumnReader::StringDictionaryColumnReader(
           encodingKey.forKind(proto::Stream_Kind_DICTIONARY_DATA),
           streamLabels.label(),
           false)),
-      returnFlatVector_(stripe.getRowReaderOptions().getReturnFlatVector()) {
+      returnFlatVector_(stripe.rowReaderOptions().returnFlatVector()) {
   MakeRleDecoderParams params{
       .encodingKey = encodingKey,
       .stripe = stripe,
@@ -1424,7 +1413,7 @@ void StringDictionaryColumnReader::readDictionaryVector(
 
       combinedDictionaryValues_ = std::make_shared<FlatVector<StringView>>(
           &memoryPool_,
-          nodeType_->type(),
+          fileType_->type(),
           BufferPtr(nullptr), // TODO nulls
           dictionaryCount_ + strideDictCount_ /*length*/,
           values,
@@ -1446,7 +1435,7 @@ void StringDictionaryColumnReader::readDictionaryVector(
 
       dictionaryValues_ = std::make_shared<FlatVector<StringView>>(
           &memoryPool_,
-          nodeType_->type(),
+          fileType_->type(),
           BufferPtr(nullptr), // TODO nulls
           dictionaryCount_ /*length*/,
           values,
@@ -1618,7 +1607,7 @@ class StringDirectColumnReader : public ColumnReader {
 
  public:
   StringDirectColumnReader(
-      std::shared_ptr<const dwio::common::TypeWithId> nodeType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       FlatMapContext flatMapContext);
@@ -1631,16 +1620,16 @@ class StringDirectColumnReader : public ColumnReader {
 };
 
 StringDirectColumnReader::StringDirectColumnReader(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     FlatMapContext flatMapContext)
     : ColumnReader(
-          std::move(nodeType),
+          std::move(fileType),
           stripe,
           streamLabels,
           std::move(flatMapContext)) {
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   RleVersion rleVersion =
       convertRleVersion(stripe.getEncoding(encodingKey).kind());
   auto lenId = encodingKey.forKind(proto::Stream_Kind_LENGTH);
@@ -1667,7 +1656,7 @@ uint64_t StringDirectColumnReader::skip(uint64_t numValues) {
     totalBytes += computeSize(buffer.data(), nullptr, step);
     done += step;
   }
-  blobStream->Skip(static_cast<int32_t>(totalBytes));
+  blobStream->SkipInt64(static_cast<int64_t>(totalBytes));
   return numValues;
 }
 
@@ -1751,7 +1740,7 @@ void StringDirectColumnReader::next(
   } else {
     result = std::make_shared<FlatVector<StringView>>(
         &memoryPool_,
-        nodeType_->type(),
+        fileType_->type(),
         nulls,
         numValues,
         values,
@@ -1764,14 +1753,19 @@ class StructColumnReader : public ColumnReader {
  private:
   const std::shared_ptr<const dwio::common::TypeWithId> requestedType_;
   std::vector<std::unique_ptr<ColumnReader>> children_;
+  folly::Executor* executor_;
+  std::unique_ptr<dwio::common::ParallelFor> parallelForOnChildren_;
 
  public:
   StructColumnReader(
       const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
-      FlatMapContext flatMapContext);
+      folly::Executor* executor,
+      size_t decodingParallelismFactor,
+      FlatMapContext flatMapContext,
+      ColumnReaderFactory& factory);
   ~StructColumnReader() override = default;
 
   uint64_t skip(uint64_t numValues) override;
@@ -1794,39 +1788,50 @@ FlatMapContext makeCopyWithNullDecoder(FlatMapContext& original) {
 // that consumes current column projection which is to be refactored
 StructColumnReader::StructColumnReader(
     const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
-    FlatMapContext flatMapContext)
-    : ColumnReader(dataType, stripe, streamLabels, std::move(flatMapContext)),
-      requestedType_{requestedType} {
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    FlatMapContext flatMapContext,
+    ColumnReaderFactory& factory)
+    : ColumnReader(fileType, stripe, streamLabels, std::move(flatMapContext)),
+      requestedType_{requestedType},
+      executor_{executor} {
   DWIO_ENSURE_EQ(
-      nodeType_->id(),
-      dataType->id(),
-      "nodeType and dataType id mismatch in StructColumnReader#init");
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+      fileType_->id(),
+      fileType->id(),
+      "fileType and fileType id mismatch in StructColumnReader#init");
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   auto encoding = static_cast<int64_t>(stripe.getEncoding(encodingKey).kind());
   DWIO_ENSURE_EQ(
       encoding,
       proto::ColumnEncoding_Kind_DIRECT,
       "Unknown encoding for StructColumnReader");
 
+  // Can parallelize if top level and doesn't have any flatmap children
+  bool canParallelize = fileType->parent() == nullptr; // isTopLevel ?
+
   // count the number of selected sub-columns
   const auto& cs = stripe.getColumnSelector();
-  auto project = stripe.getRowReaderOptions().getProjectSelectedType();
+  auto project = stripe.rowReaderOptions().projectSelectedType();
   for (uint64_t i = 0; i < requestedType_->size(); ++i) {
     auto& child = requestedType_->childAt(i);
 
     // if the requested field is not in file, we either return null reader
     // or constant reader based on its expression
     if (cs.shouldReadNode(child->id())) {
-      if (i < nodeType_->size()) {
-        children_.push_back(ColumnReader::build(
+      if (i < fileType_->size()) {
+        auto childColumnReader = factory.build(
             child,
-            nodeType_->childAt(i),
+            fileType_->childAt(i),
             stripe,
             streamLabels.append(folly::to<std::string>(i)),
-            makeCopyWithNullDecoder(flatMapContext_)));
+            executor,
+            decodingParallelismFactor,
+            makeCopyWithNullDecoder(flatMapContext_));
+        canParallelize = canParallelize && !childColumnReader->isFlatMap();
+        children_.push_back(std::move(childColumnReader));
       } else {
         children_.push_back(
             std::make_unique<NullColumnReader>(stripe, child->type()));
@@ -1835,6 +1840,12 @@ StructColumnReader::StructColumnReader(
       children_.emplace_back();
     }
   }
+
+  parallelForOnChildren_ = std::make_unique<dwio::common::ParallelFor>(
+      executor,
+      0,
+      children_.size(),
+      canParallelize ? decodingParallelismFactor : 0);
 }
 
 uint64_t StructColumnReader::skip(uint64_t numValues) {
@@ -1858,10 +1869,9 @@ void StructColumnReader::next(
     // the parent vector.
     childrenVectors = rowVector->children();
     DWIO_ENSURE_GE(childrenVectors.size(), children_.size());
-  }
 
-  if (result) {
-    result->resize(numValues, false);
+    // Resize rowVector
+    rowVector->unsafeResize(numValues, false);
   }
 
   BufferPtr nulls = readNulls(numValues, result, incomingNulls);
@@ -1879,12 +1889,14 @@ void StructColumnReader::next(
     childrenVectorsPtr = &childrenVectors;
   }
 
-  for (uint64_t i = 0; i < children_.size(); ++i) {
-    auto& reader = children_[i];
-    if (reader) {
-      reader->next(numValues, (*childrenVectorsPtr)[i], nullsPtr);
-    }
-  }
+  VELOX_CHECK(parallelForOnChildren_, "ParallelFor should be initialized");
+  parallelForOnChildren_->execute(
+      [this, numValues, childrenVectorsPtr, nullsPtr](size_t i) {
+        auto& reader = children_[i];
+        if (reader) {
+          reader->next(numValues, (*childrenVectorsPtr)[i], nullsPtr);
+        }
+      });
 
   if (result) {
     result->setNullCount(nullCount);
@@ -1922,10 +1934,13 @@ class ListColumnReader : public ColumnReader {
  public:
   ListColumnReader(
       const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
-      FlatMapContext flatMapContext);
+      FlatMapContext flatMapContext,
+      folly::Executor* executor,
+      size_t decodingParallelismFactor,
+      ColumnReaderFactory& factory);
   ~ListColumnReader() override = default;
 
   uint64_t skip(uint64_t numValues) override;
@@ -1936,14 +1951,17 @@ class ListColumnReader : public ColumnReader {
 
 ListColumnReader::ListColumnReader(
     const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
-    FlatMapContext flatMapContext)
-    : ColumnReader(dataType, stripe, streamLabels, std::move(flatMapContext)),
+    FlatMapContext flatMapContext,
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    ColumnReaderFactory& factory)
+    : ColumnReader(fileType, stripe, streamLabels, std::move(flatMapContext)),
       requestedType_{requestedType} {
-  DWIO_ENSURE_EQ(nodeType_->id(), dataType->id(), "working on the same node");
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  DWIO_ENSURE_EQ(fileType_->id(), fileType->id(), "working on the same node");
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   // count the number of selected sub-columns
   RleVersion vers = convertRleVersion(stripe.getEncoding(encodingKey).kind());
 
@@ -1959,11 +1977,13 @@ ListColumnReader::ListColumnReader(
   const auto& cs = stripe.getColumnSelector();
   auto& childType = requestedType_->childAt(0);
   if (cs.shouldReadNode(childType->id())) {
-    child = ColumnReader::build(
+    child = factory.build(
         childType,
-        nodeType_->childAt(0),
+        fileType_->childAt(0),
         stripe,
         streamLabels,
+        executor,
+        decodingParallelismFactor,
         makeCopyWithNullDecoder(flatMapContext_));
   }
 }
@@ -2087,10 +2107,13 @@ class MapColumnReader : public ColumnReader {
  public:
   MapColumnReader(
       const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
-      FlatMapContext flatMapContext);
+      FlatMapContext flatMapContext,
+      folly::Executor* executor,
+      size_t decodingParallelismFactor,
+      ColumnReaderFactory& factory);
   ~MapColumnReader() override = default;
 
   uint64_t skip(uint64_t numValues) override;
@@ -2101,14 +2124,17 @@ class MapColumnReader : public ColumnReader {
 
 MapColumnReader::MapColumnReader(
     const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
-    FlatMapContext flatMapContext)
-    : ColumnReader(dataType, stripe, streamLabels, std::move(flatMapContext)),
+    FlatMapContext flatMapContext,
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    ColumnReaderFactory& factory)
+    : ColumnReader(fileType, stripe, streamLabels, std::move(flatMapContext)),
       requestedType_{requestedType} {
-  DWIO_ENSURE_EQ(nodeType_->id(), dataType->id(), "working on the same node");
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  DWIO_ENSURE_EQ(fileType_->id(), fileType->id(), "working on the same node");
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   // Determine if the key and/or value columns are selected
   RleVersion vers = convertRleVersion(stripe.getEncoding(encodingKey).kind());
 
@@ -2124,25 +2150,29 @@ MapColumnReader::MapColumnReader(
   const auto& cs = stripe.getColumnSelector();
   auto& keyType = requestedType_->childAt(0);
   if (cs.shouldReadNode(keyType->id())) {
-    keyReader = ColumnReader::build(
+    keyReader = factory.build(
         keyType,
-        nodeType_->childAt(0),
+        fileType_->childAt(0),
         stripe,
         streamLabels,
+        executor,
+        decodingParallelismFactor,
         makeCopyWithNullDecoder(flatMapContext_));
   }
 
   auto& valueType = requestedType_->childAt(1);
   if (cs.shouldReadNode(valueType->id())) {
-    elementReader = ColumnReader::build(
+    elementReader = factory.build(
         valueType,
-        nodeType_->childAt(1),
+        fileType_->childAt(1),
         stripe,
         streamLabels,
+        executor,
+        decodingParallelismFactor,
         makeCopyWithNullDecoder(flatMapContext_));
   }
 
-  VLOG(1) << "[Map] Initialized map column reader for node " << nodeType_->id();
+  VLOG(1) << "[Map] Initialized map column reader for node " << fileType_->id();
 }
 
 uint64_t MapColumnReader::skip(uint64_t numValues) {
@@ -2278,48 +2308,48 @@ struct RleDecoderFactory<int8_t> {
 
 template <typename DataT>
 std::unique_ptr<ColumnReader> buildByteRleColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
     TypePtr requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     FlatMapContext flatMapContext) {
   switch (requestedType->kind()) {
     case TypeKind::BOOLEAN:
       return std::make_unique<ByteRleColumnReader<DataT, bool>>(
-          nodeType,
           std::move(requestedType),
+          fileType,
           stripe,
           streamLabels,
           RleDecoderFactory<DataT>::get(),
           std::move(flatMapContext));
     case TypeKind::TINYINT:
       return std::make_unique<ByteRleColumnReader<DataT, int8_t>>(
-          nodeType,
           std::move(requestedType),
+          fileType,
           stripe,
           streamLabels,
           RleDecoderFactory<DataT>::get(),
           std::move(flatMapContext));
     case TypeKind::SMALLINT:
       return std::make_unique<ByteRleColumnReader<DataT, int16_t>>(
-          nodeType,
           std::move(requestedType),
+          fileType,
           stripe,
           streamLabels,
           RleDecoderFactory<DataT>::get(),
           std::move(flatMapContext));
     case TypeKind::INTEGER:
       return std::make_unique<ByteRleColumnReader<DataT, int32_t>>(
-          nodeType,
           std::move(requestedType),
+          fileType,
           stripe,
           streamLabels,
           RleDecoderFactory<DataT>::get(),
           std::move(flatMapContext));
     case TypeKind::BIGINT:
       return std::make_unique<ByteRleColumnReader<DataT, int64_t>>(
-          nodeType,
           std::move(requestedType),
+          fileType,
           stripe,
           streamLabels,
           RleDecoderFactory<DataT>::get(),
@@ -2332,8 +2362,8 @@ std::unique_ptr<ColumnReader> buildByteRleColumnReader(
 
 template <template <class> class IntegerColumnReaderT>
 std::unique_ptr<ColumnReader> buildTypedIntegerColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
     TypePtr requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     FlatMapContext flatMapContext,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
@@ -2343,24 +2373,24 @@ std::unique_ptr<ColumnReader> buildTypedIntegerColumnReader(
   switch (requestedType->kind()) {
     case TypeKind::INTEGER:
       return std::make_unique<IntegerColumnReaderT<int32_t>>(
-          nodeType,
           requestedType,
+          fileType,
           stripe,
           streamLabels,
           numBytes,
           std::move(flatMapContext));
     case TypeKind::BIGINT:
       return std::make_unique<IntegerColumnReaderT<int64_t>>(
-          nodeType,
           requestedType,
+          fileType,
           stripe,
           streamLabels,
           numBytes,
           std::move(flatMapContext));
     case TypeKind::SMALLINT:
       return std::make_unique<IntegerColumnReaderT<int16_t>>(
-          nodeType,
           requestedType,
+          fileType,
           stripe,
           streamLabels,
           numBytes,
@@ -2373,19 +2403,19 @@ std::unique_ptr<ColumnReader> buildTypedIntegerColumnReader(
 }
 
 std::unique_ptr<ColumnReader> buildIntegerReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
     TypePtr requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     uint32_t numBytes,
     FlatMapContext flatMapContext,
     StripeStreams& stripe,
     const StreamLabels& streamLabels) {
-  EncodingKey ek{nodeType->id(), flatMapContext.sequence};
+  EncodingKey ek{fileType->id(), flatMapContext.sequence};
   switch (static_cast<int64_t>(stripe.getEncoding(ek).kind())) {
     case proto::ColumnEncoding_Kind_DICTIONARY:
     case proto::ColumnEncoding_Kind_DICTIONARY_V2:
       return buildTypedIntegerColumnReader<IntegerDictionaryColumnReader>(
-          nodeType,
           requestedType,
+          fileType,
           std::move(flatMapContext),
           stripe,
           streamLabels,
@@ -2393,8 +2423,8 @@ std::unique_ptr<ColumnReader> buildIntegerReader(
     case proto::ColumnEncoding_Kind_DIRECT:
     case proto::ColumnEncoding_Kind_DIRECT_V2:
       return buildTypedIntegerColumnReader<IntegerDirectColumnReader>(
-          nodeType,
           requestedType,
+          fileType,
           std::move(flatMapContext),
           stripe,
           streamLabels,
@@ -2406,34 +2436,37 @@ std::unique_ptr<ColumnReader> buildIntegerReader(
 
 std::unique_ptr<ColumnReader> ColumnReader::build(
     const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
-    FlatMapContext flatMapContext) {
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    FlatMapContext flatMapContext,
+    ColumnReaderFactory& factory) {
   dwio::common::typeutils::checkTypeCompatibility(
-      *dataType->type(), *requestedType->type());
-  EncodingKey ek{dataType->id(), flatMapContext.sequence};
-  switch (dataType->type()->kind()) {
+      *fileType->type(), *requestedType->type());
+  EncodingKey ek{fileType->id(), flatMapContext.sequence};
+  switch (fileType->type()->kind()) {
     case TypeKind::INTEGER:
       return buildIntegerReader(
-          dataType,
           requestedType->type(),
+          fileType,
           dwio::common::INT_BYTE_SIZE,
           std::move(flatMapContext),
           stripe,
           streamLabels);
     case TypeKind::BIGINT:
-      if (dataType->type()->isDecimal()) {
+      if (fileType->type()->isDecimal()) {
         return std::make_unique<DecimalColumnReader<int64_t>>(
-            dataType,
             requestedType->type(),
+            fileType,
             stripe,
             streamLabels,
             std::move(flatMapContext));
       } else {
         return buildIntegerReader(
-            dataType,
             requestedType->type(),
+            fileType,
             dwio::common::LONG_BYTE_SIZE,
             std::move(flatMapContext),
             stripe,
@@ -2441,8 +2474,8 @@ std::unique_ptr<ColumnReader> ColumnReader::build(
       }
     case TypeKind::SMALLINT:
       return buildIntegerReader(
-          dataType,
           requestedType->type(),
+          fileType,
           dwio::common::SHORT_BYTE_SIZE,
           std::move(flatMapContext),
           stripe,
@@ -2453,11 +2486,11 @@ std::unique_ptr<ColumnReader> ColumnReader::build(
         case proto::ColumnEncoding_Kind_DICTIONARY:
         case proto::ColumnEncoding_Kind_DICTIONARY_V2: {
           const EncodingKey encodingKey(
-              dataType->id(), flatMapContext.sequence);
+              fileType->id(), flatMapContext.sequence);
           RleVersion rleVersion =
               convertRleVersion(stripe.getEncoding(encodingKey).kind());
           return std::make_unique<StringDictionaryColumnReader>(
-              dataType,
+              fileType,
               stripe,
               streamLabels,
               encodingKey,
@@ -2467,85 +2500,97 @@ std::unique_ptr<ColumnReader> ColumnReader::build(
         case proto::ColumnEncoding_Kind_DIRECT:
         case proto::ColumnEncoding_Kind_DIRECT_V2:
           return std::make_unique<StringDirectColumnReader>(
-              dataType, stripe, streamLabels, std::move(flatMapContext));
+              fileType, stripe, streamLabels, std::move(flatMapContext));
         default:
           DWIO_RAISE("buildReader unhandled string encoding");
       }
     case TypeKind::BOOLEAN:
       return buildByteRleColumnReader<bool>(
-          dataType,
           requestedType->type(),
+          fileType,
           stripe,
           streamLabels,
           std::move(flatMapContext));
     case TypeKind::TINYINT:
       return buildByteRleColumnReader<int8_t>(
-          dataType,
           requestedType->type(),
+          fileType,
           stripe,
           streamLabels,
           std::move(flatMapContext));
     case TypeKind::ARRAY:
       return std::make_unique<ListColumnReader>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
-          std::move(flatMapContext));
+          std::move(flatMapContext),
+          executor,
+          decodingParallelismFactor,
+          factory);
     case TypeKind::MAP:
       if (stripe.getEncoding(ek).kind() ==
           proto::ColumnEncoding_Kind_MAP_FLAT) {
         return FlatMapColumnReaderFactory::create(
             requestedType,
-            dataType,
+            fileType,
             stripe,
             streamLabels,
-            std::move(flatMapContext));
+            executor,
+            decodingParallelismFactor,
+            std::move(flatMapContext),
+            factory);
       }
       return std::make_unique<MapColumnReader>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
-          std::move(flatMapContext));
+          std::move(flatMapContext),
+          executor,
+          decodingParallelismFactor,
+          factory);
     case TypeKind::ROW:
       return std::make_unique<StructColumnReader>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
-          std::move(flatMapContext));
+          executor,
+          decodingParallelismFactor,
+          std::move(flatMapContext),
+          factory);
     case TypeKind::REAL:
       if (requestedType->type()->kind() == TypeKind::REAL) {
         return std::make_unique<FloatingPointColumnReader<float, float>>(
-            dataType,
             requestedType->type(),
+            fileType,
             stripe,
             streamLabels,
             std::move(flatMapContext));
       } else {
         return std::make_unique<FloatingPointColumnReader<float, double>>(
-            dataType,
             requestedType->type(),
+            fileType,
             stripe,
             streamLabels,
             std::move(flatMapContext));
       }
     case TypeKind::DOUBLE:
       return std::make_unique<FloatingPointColumnReader<double, double>>(
-          dataType,
           requestedType->type(),
+          fileType,
           stripe,
           streamLabels,
           std::move(flatMapContext));
     case TypeKind::TIMESTAMP:
       return std::make_unique<TimestampColumnReader>(
-          dataType, stripe, streamLabels, std::move(flatMapContext));
+          fileType, stripe, streamLabels, std::move(flatMapContext));
     case TypeKind::HUGEINT:
-      if (dataType->type()->isDecimal()) {
+      if (fileType->type()->isDecimal()) {
         return std::make_unique<DecimalColumnReader<int128_t>>(
-            dataType,
             requestedType->type(),
+            fileType,
             stripe,
             streamLabels,
             std::move(flatMapContext));
@@ -2556,10 +2601,29 @@ std::unique_ptr<ColumnReader> ColumnReader::build(
   }
 }
 
+std::unique_ptr<ColumnReader> ColumnReaderFactory::build(
+    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+    StripeStreams& stripe,
+    const StreamLabels& streamLabels,
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    FlatMapContext flatMapContext) {
+  return ColumnReader::build(
+      requestedType,
+      fileType,
+      stripe,
+      streamLabels,
+      executor,
+      decodingParallelismFactor,
+      std::move(flatMapContext),
+      *this);
+}
+
 // static
-ColumnReaderFactory* ColumnReaderFactory::baseFactory() {
+ColumnReaderFactory& ColumnReaderFactory::defaultFactory() {
   static auto instance = std::make_unique<ColumnReaderFactory>();
-  return instance.get();
+  return *instance;
 }
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/ColumnReader.h b/velox/dwio/dwrf/reader/ColumnReader.h
index d3119f841dd93..47d9ec3a667f4 100644
--- a/velox/dwio/dwrf/reader/ColumnReader.h
+++ b/velox/dwio/dwrf/reader/ColumnReader.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "folly/Executor.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/dwio/common/ColumnSelector.h"
 #include "velox/dwio/common/TypeWithId.h"
@@ -29,16 +30,34 @@
 
 namespace facebook::velox::dwrf {
 
+// Foward declaration
+class ColumnReader;
+
+class ColumnReaderFactory {
+ public:
+  virtual ~ColumnReaderFactory() = default;
+  virtual std::unique_ptr<ColumnReader> build(
+      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      StripeStreams& stripe,
+      const StreamLabels& streamLabels,
+      folly::Executor* executor,
+      size_t decodingParallelismFactor,
+      FlatMapContext flatMapContext = {});
+
+  static ColumnReaderFactory& defaultFactory();
+};
+
 /**
  * The interface for reading ORC data types.
  */
 class ColumnReader {
  protected:
-  explicit ColumnReader(
+  ColumnReader(
       memory::MemoryPool& memoryPool,
       const std::shared_ptr<const dwio::common::TypeWithId>& type)
       : notNullDecoder_{},
-        nodeType_{type},
+        fileType_{type},
         memoryPool_{memoryPool},
         flatMapContext_{} {}
 
@@ -60,7 +79,7 @@ class ColumnReader {
       const uint64_t* incomingNulls);
 
   std::unique_ptr<ByteRleDecoder> notNullDecoder_;
-  const std::shared_ptr<const dwio::common::TypeWithId> nodeType_;
+  const std::shared_ptr<const dwio::common::TypeWithId> fileType_;
   memory::MemoryPool& memoryPool_;
   FlatMapContext flatMapContext_;
 
@@ -106,35 +125,22 @@ class ColumnReader {
     VELOX_NYI();
   }
 
+  virtual bool isFlatMap() const {
+    return false;
+  }
+
   /**
    * Create a reader for the given stripe.
    */
   static std::unique_ptr<ColumnReader> build(
       const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
-      FlatMapContext flatMapContext = {});
-};
-
-class ColumnReaderFactory {
- public:
-  virtual ~ColumnReaderFactory() = default;
-  virtual std::unique_ptr<ColumnReader> build(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
-      StripeStreams& stripe,
-      const StreamLabels& streamLabels,
-      FlatMapContext flatMapContext = {}) {
-    return ColumnReader::build(
-        requestedType,
-        dataType,
-        stripe,
-        streamLabels,
-        std::move(flatMapContext));
-  }
-
-  static ColumnReaderFactory* baseFactory();
+      folly::Executor* executor,
+      size_t decodingParallelismFactor,
+      FlatMapContext flatMapContext = {},
+      ColumnReaderFactory& factory = ColumnReaderFactory::defaultFactory());
 };
 
 namespace detail {
diff --git a/velox/dwio/dwrf/reader/ConstantColumnReader.h b/velox/dwio/dwrf/reader/ConstantColumnReader.h
index b9950fc4d9f31..7e237dd8036b9 100644
--- a/velox/dwio/dwrf/reader/ConstantColumnReader.h
+++ b/velox/dwio/dwrf/reader/ConstantColumnReader.h
@@ -42,7 +42,7 @@ class NullColumnReader : public ColumnReader {
       // If vector already exists and contains the right value, resize.
       result->resize(numValues);
     } else {
-      auto valueVector = BaseVector::create(nodeType_->type(), 1, &memoryPool_);
+      auto valueVector = BaseVector::create(fileType_->type(), 1, &memoryPool_);
       valueVector->setNull(0, true);
       result = BaseVector::wrapInConstant(numValues, 0, valueVector);
     }
diff --git a/velox/dwio/dwrf/reader/DwrfData.cpp b/velox/dwio/dwrf/reader/DwrfData.cpp
index 12e116c8e0d04..26116449e10ac 100644
--- a/velox/dwio/dwrf/reader/DwrfData.cpp
+++ b/velox/dwio/dwrf/reader/DwrfData.cpp
@@ -21,16 +21,16 @@
 namespace facebook::velox::dwrf {
 
 DwrfData::DwrfData(
-    std::shared_ptr<const dwio::common::TypeWithId> nodeType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     FlatMapContext flatMapContext)
     : memoryPool_(stripe.getMemoryPool()),
-      nodeType_(std::move(nodeType)),
+      fileType_(std::move(fileType)),
       flatMapContext_(std::move(flatMapContext)),
       stripeRows_{stripe.stripeRows()},
       rowsPerRowGroup_{stripe.rowsPerRowGroup()} {
-  EncodingKey encodingKey{nodeType_->id(), flatMapContext_.sequence};
+  EncodingKey encodingKey{fileType_->id(), flatMapContext_.sequence};
   std::unique_ptr<dwio::common::SeekableInputStream> stream = stripe.getStream(
       encodingKey.forKind(proto::Stream_Kind_PRESENT),
       streamLabels.label(),
@@ -39,11 +39,10 @@ DwrfData::DwrfData(
     notNullDecoder_ = createBooleanRleDecoder(std::move(stream), encodingKey);
   }
 
-  // We always initialize indexStream_ because indices are needed as
-  // soon as there is a single filter that can trigger row group skips
-  // anywhere in the reader tree. This is not known at construct time
-  // because the first filter can come from a hash join or other run
-  // time pushdown.
+  // We always initialize indexStream_ because indices are needed as soon as
+  // there is a single filter that can trigger row group skips anywhere in the
+  // reader tree. This is not known at construct time because the first filter
+  // can come from a hash join or other run time push-down.
   indexStream_ = stripe.getStream(
       encodingKey.forKind(proto::Stream_Kind_ROW_INDEX),
       streamLabels.label(),
@@ -54,23 +53,25 @@ uint64_t DwrfData::skipNulls(uint64_t numValues, bool /*nullsOnly*/) {
   if (!notNullDecoder_ && !flatMapContext_.inMapDecoder) {
     return numValues;
   }
+
   // Page through the values that we want to skip and count how many are
   // non-null.
   constexpr uint64_t kBufferBytes = 1024;
   constexpr auto kBitCount = kBufferBytes * 8;
-  auto countNulls = [](ByteRleDecoder& decoder, size_t size) {
+  const auto countNulls = [](ByteRleDecoder& decoder, size_t size) {
     char buffer[kBufferBytes];
     decoder.next(buffer, size, nullptr);
     return bits::countNulls(reinterpret_cast<const uint64_t*>(buffer), 0, size);
   };
+
   uint64_t remaining = numValues;
   while (remaining > 0) {
-    uint64_t chunkSize = std::min(remaining, kBitCount);
-    uint64_t nullCount;
-    if (flatMapContext_.inMapDecoder) {
+    const uint64_t chunkSize = std::min(remaining, kBitCount);
+    uint64_t nullCount{0};
+    if (flatMapContext_.inMapDecoder != nullptr) {
       nullCount = countNulls(*flatMapContext_.inMapDecoder, chunkSize);
       if (notNullDecoder_) {
-        if (auto inMapSize = chunkSize - nullCount; inMapSize > 0) {
+        if (const auto inMapSize = chunkSize - nullCount; inMapSize > 0) {
           nullCount += countNulls(*notNullDecoder_, inMapSize);
         }
       }
@@ -92,8 +93,9 @@ void DwrfData::ensureRowGroupIndex() {
 
 dwio::common::PositionProvider DwrfData::seekToRowGroup(uint32_t index) {
   ensureRowGroupIndex();
-  tempPositions_ = toPositionsInner(index_->entry(index));
-  dwio::common::PositionProvider positionProvider(tempPositions_);
+
+  positionsHolder_ = toPositionsInner(index_->entry(index));
+  dwio::common::PositionProvider positionProvider(positionsHolder_);
   if (flatMapContext_.inMapDecoder) {
     flatMapContext_.inMapDecoder->seekToRowGroup(positionProvider);
   }
@@ -107,18 +109,20 @@ dwio::common::PositionProvider DwrfData::seekToRowGroup(uint32_t index) {
 
 void DwrfData::readNulls(
     vector_size_t numValues,
-    const uint64_t* FOLLY_NULLABLE incomingNulls,
+    const uint64_t* incomingNulls,
     BufferPtr& nulls,
     bool /*nullsOnly*/) {
   if (!notNullDecoder_ && !flatMapContext_.inMapDecoder && !incomingNulls) {
     nulls = nullptr;
     return;
   }
-  auto numBytes = bits::nbytes(numValues);
+
+  const auto numBytes = bits::nbytes(numValues);
   if (!nulls || nulls->capacity() < numBytes) {
     nulls = AlignedBuffer::allocate<char>(numBytes, &memoryPool_);
   }
   nulls->setSize(numBytes);
+
   auto* nullsPtr = nulls->asMutable<char>();
   if (flatMapContext_.inMapDecoder) {
     if (notNullDecoder_) {
@@ -133,7 +137,7 @@ void DwrfData::readNulls(
   } else if (notNullDecoder_) {
     notNullDecoder_->next(nullsPtr, numValues, incomingNulls);
   } else {
-    memcpy(nullsPtr, incomingNulls, numBytes);
+    ::memcpy(nullsPtr, incomingNulls, numBytes);
   }
 }
 
@@ -145,37 +149,41 @@ void DwrfData::filterRowGroups(
   if (!index_ && !indexStream_) {
     return;
   }
+
   ensureRowGroupIndex();
-  auto filter = scanSpec.filter();
-  auto dwrfContext = reinterpret_cast<const StatsContext*>(&writerContext);
+  auto* filter = scanSpec.filter();
+  auto* dwrfContext = reinterpret_cast<const StatsContext*>(&writerContext);
   result.totalCount = std::max(result.totalCount, index_->entry_size());
-  auto nwords = bits::nwords(result.totalCount);
+  const auto nwords = bits::nwords(result.totalCount);
   if (result.filterResult.size() < nwords) {
     result.filterResult.resize(nwords);
   }
-  auto metadataFiltersStartIndex = result.metadataFilterResults.size();
+
+  const auto metadataFiltersStartIndex = result.metadataFilterResults.size();
   for (int i = 0; i < scanSpec.numMetadataFilters(); ++i) {
     result.metadataFilterResults.emplace_back(
         scanSpec.metadataFilterNodeAt(i), std::vector<uint64_t>(nwords));
   }
-  for (auto i = 0; i < index_->entry_size(); i++) {
+
+  for (auto i = 0; i < index_->entry_size(); ++i) {
     const auto& entry = index_->entry(i);
-    auto columnStats =
-        buildColumnStatisticsFromProto(entry.statistics(), *dwrfContext);
+    const auto columnStats = buildColumnStatisticsFromProto(
+        ColumnStatisticsWrapper(&entry.statistics()), *dwrfContext);
     if (filter &&
         !testFilter(
-            filter, columnStats.get(), rowGroupSize, nodeType_->type())) {
+            filter, columnStats.get(), rowGroupSize, fileType_->type())) {
       VLOG(1) << "Drop stride " << i << " on " << scanSpec.toString();
       bits::setBit(result.filterResult.data(), i);
       continue;
     }
+
     for (int j = 0; j < scanSpec.numMetadataFilters(); ++j) {
       auto* metadataFilter = scanSpec.metadataFilterAt(j);
       if (!testFilter(
               metadataFilter,
               columnStats.get(),
               rowGroupSize,
-              nodeType_->type())) {
+              fileType_->type())) {
         bits::setBit(
             result.metadataFilterResults[metadataFiltersStartIndex + j]
                 .second.data(),
diff --git a/velox/dwio/dwrf/reader/DwrfData.h b/velox/dwio/dwrf/reader/DwrfData.h
index bbb21c5a4cd86..995cc80ac4100 100644
--- a/velox/dwio/dwrf/reader/DwrfData.h
+++ b/velox/dwio/dwrf/reader/DwrfData.h
@@ -17,7 +17,6 @@
 #pragma once
 
 #include "velox/common/memory/Memory.h"
-#include "velox/dwio/common/ColumnSelector.h"
 #include "velox/dwio/common/FormatData.h"
 #include "velox/dwio/common/TypeWithId.h"
 #include "velox/dwio/common/compression/Compression.h"
@@ -34,14 +33,14 @@ namespace facebook::velox::dwrf {
 class DwrfData : public dwio::common::FormatData {
  public:
   DwrfData(
-      std::shared_ptr<const dwio::common::TypeWithId> nodeType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       FlatMapContext flatMapContext);
 
   void readNulls(
       vector_size_t numValues,
-      const uint64_t* FOLLY_NULLABLE incomingNulls,
+      const uint64_t* incomingNulls,
       BufferPtr& nulls,
       bool nullsOnly = false) override;
 
@@ -55,13 +54,13 @@ class DwrfData : public dwio::common::FormatData {
       const common::ScanSpec& scanSpec,
       uint64_t rowsPerRowGroup,
       const dwio::common::StatsContext& writerContext,
-      FilterRowGroupsResult&) override;
+      FilterRowGroupsResult& result) override;
 
   bool hasNulls() const override {
     return notNullDecoder_ != nullptr;
   }
 
-  auto* FOLLY_NULLABLE notNullDecoder() const {
+  auto* notNullDecoder() const {
     return notNullDecoder_.get();
   }
 
@@ -69,12 +68,12 @@ class DwrfData : public dwio::common::FormatData {
     return flatMapContext_;
   }
 
-  const uint64_t* FOLLY_NULLABLE inMap() const {
+  const uint64_t* inMap() const {
     return flatMapContext_.inMapDecoder ? inMap_->as<uint64_t>() : nullptr;
   }
 
-  // seeks possible flat map in map streams and nulls to the row group
-  // and returns a PositionsProvider for the other streams.
+  /// Seeks possible flat map in map streams and nulls to the row group
+  /// and returns a PositionsProvider for the other streams.
   dwio::common::PositionProvider seekToRowGroup(uint32_t index) override;
 
   int64_t stripeRows() const {
@@ -101,9 +100,9 @@ class DwrfData : public dwio::common::FormatData {
   }
 
   memory::MemoryPool& memoryPool_;
-  const std::shared_ptr<const dwio::common::TypeWithId> nodeType_;
+  const std::shared_ptr<const dwio::common::TypeWithId> fileType_;
   FlatMapContext flatMapContext_;
-  std::unique_ptr<ByteRleDecoder> notNullDecoder_;
+  std::unique_ptr<BooleanRleDecoder> notNullDecoder_;
   std::unique_ptr<dwio::common::SeekableInputStream> indexStream_;
   std::unique_ptr<proto::RowIndex> index_;
   int64_t stripeRows_;
@@ -112,13 +111,13 @@ class DwrfData : public dwio::common::FormatData {
 
   // Storage for positions backing a PositionProvider returned from
   // seekToRowGroup().
-  std::vector<uint64_t> tempPositions_;
+  std::vector<uint64_t> positionsHolder_;
 
   // In map bitmap used in flat map encoding.
   BufferPtr inMap_;
 };
 
-// DWRF specific initialization.
+/// DWRF specific initialization.
 class DwrfParams : public dwio::common::FormatParams {
  public:
   explicit DwrfParams(
@@ -127,9 +126,9 @@ class DwrfParams : public dwio::common::FormatParams {
       dwio::common::ColumnReaderStatistics& stats,
       FlatMapContext context = {})
       : FormatParams(stripeStreams.getMemoryPool(), stats),
+        streamLabels_(streamLabels),
         stripeStreams_(stripeStreams),
-        flatMapContext_(context),
-        streamLabels_(streamLabels) {}
+        flatMapContext_(context) {}
 
   std::unique_ptr<dwio::common::FormatData> toFormatData(
       const std::shared_ptr<const dwio::common::TypeWithId>& type,
@@ -151,9 +150,9 @@ class DwrfParams : public dwio::common::FormatParams {
   }
 
  private:
+  const StreamLabels& streamLabels_;
   StripeStreams& stripeStreams_;
   FlatMapContext flatMapContext_;
-  const StreamLabels& streamLabels_;
 };
 
 inline RleVersion convertRleVersion(proto::ColumnEncoding_Kind kind) {
@@ -165,7 +164,9 @@ inline RleVersion convertRleVersion(proto::ColumnEncoding_Kind kind) {
     case proto::ColumnEncoding_Kind_DICTIONARY_V2:
       return RleVersion_2;
     default:
-      DWIO_RAISE("Unknown encoding in convertRleVersion");
+      VELOX_FAIL(
+          "Unknown encoding in convertRleVersion: {}",
+          static_cast<int64_t>(kind));
   }
 }
 
diff --git a/velox/dwio/dwrf/reader/DwrfReader.cpp b/velox/dwio/dwrf/reader/DwrfReader.cpp
index 76035c03b2f44..d20d67bbb0a94 100644
--- a/velox/dwio/dwrf/reader/DwrfReader.cpp
+++ b/velox/dwio/dwrf/reader/DwrfReader.cpp
@@ -15,6 +15,10 @@
  */
 
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
+
+#include <chrono>
+
+#include "velox/dwio/common/OnDemandUnitLoader.h"
 #include "velox/dwio/common/TypeUtils.h"
 #include "velox/dwio/common/exception/Exception.h"
 #include "velox/dwio/dwrf/reader/ColumnReader.h"
@@ -25,73 +29,314 @@ namespace facebook::velox::dwrf {
 
 using dwio::common::ColumnSelector;
 using dwio::common::FileFormat;
-using dwio::common::InputStream;
+using dwio::common::LoadUnit;
 using dwio::common::ReaderOptions;
 using dwio::common::RowReaderOptions;
+using dwio::common::UnitLoader;
+using dwio::common::UnitLoaderFactory;
+
+class DwrfUnit : public LoadUnit {
+ public:
+  DwrfUnit(
+      const StripeReaderBase& stripeReaderBase,
+      const StrideIndexProvider& strideIndexProvider,
+      dwio::common::ColumnReaderStatistics& columnReaderStatistics,
+      uint32_t stripeIndex,
+      std::shared_ptr<dwio::common::ColumnSelector> columnSelector,
+      const std::shared_ptr<BitSet>& projectedNodes,
+      RowReaderOptions options)
+      : stripeReaderBase_{stripeReaderBase},
+        strideIndexProvider_{strideIndexProvider},
+        columnReaderStatistics_{&columnReaderStatistics},
+        stripeIndex_{stripeIndex},
+        columnSelector_{std::move(columnSelector)},
+        projectedNodes_{projectedNodes},
+        options_{std::move(options)},
+        stripeInfo_{
+            stripeReaderBase.getReader().footer().stripes(stripeIndex_)} {}
+
+  ~DwrfUnit() override = default;
+
+  /// Performs the IO (read)
+  void load() override;
+
+  /// Unloads the unit to free memory
+  void unload() override;
+
+  /// Number of rows in the unit
+  uint64_t getNumRows() override;
+
+  /// Number of bytes that the IO will read
+  uint64_t getIoSize() override;
+
+  std::unique_ptr<ColumnReader>& getColumnReader() {
+    return columnReader_;
+  }
+
+  std::unique_ptr<dwio::common::SelectiveColumnReader>&
+  getSelectiveColumnReader() {
+    return selectiveColumnReader_;
+  }
+
+ private:
+  void ensureDecoders();
+  void loadDecoders();
+
+  // Immutables
+  const StripeReaderBase& stripeReaderBase_;
+  const StrideIndexProvider& strideIndexProvider_;
+  dwio::common::ColumnReaderStatistics* const columnReaderStatistics_;
+  const uint32_t stripeIndex_;
+  const std::shared_ptr<dwio::common::ColumnSelector> columnSelector_;
+  const std::shared_ptr<BitSet> projectedNodes_;
+  const RowReaderOptions options_;
+  const StripeInformationWrapper stripeInfo_;
+
+  // Mutables
+  bool preloaded_;
+  std::optional<uint64_t> cachedIoSize_;
+  std::shared_ptr<StripeReadState> stripeReadState_;
+  std::unique_ptr<StripeStreamsImpl> stripeStreams_;
+  std::unique_ptr<ColumnReader> columnReader_;
+  std::unique_ptr<dwio::common::SelectiveColumnReader> selectiveColumnReader_;
+  std::shared_ptr<StripeDictionaryCache> stripeDictionaryCache_;
+};
+
+void DwrfUnit::load() {
+  ensureDecoders();
+  loadDecoders();
+}
+
+void DwrfUnit::unload() {
+  cachedIoSize_.reset();
+  stripeStreams_.reset();
+  columnReader_.reset();
+  selectiveColumnReader_.reset();
+  stripeDictionaryCache_.reset();
+  stripeReadState_.reset();
+}
+
+uint64_t DwrfUnit::getNumRows() {
+  return stripeInfo_.numberOfRows();
+}
+
+uint64_t DwrfUnit::getIoSize() {
+  if (cachedIoSize_) {
+    return *cachedIoSize_;
+  }
+  ensureDecoders();
+  cachedIoSize_ =
+      stripeReadState_->stripeMetadata->stripeInput->nextFetchSize();
+  return *cachedIoSize_;
+}
+
+void DwrfUnit::ensureDecoders() {
+  if (columnReader_ || selectiveColumnReader_) {
+    return;
+  }
+
+  preloaded_ = options_.preloadStripe();
+
+  stripeReadState_ = std::make_shared<StripeReadState>(
+      stripeReaderBase_.readerBaseShared(),
+      stripeReaderBase_.fetchStripe(stripeIndex_, preloaded_));
+
+  stripeStreams_ = std::make_unique<StripeStreamsImpl>(
+      stripeReadState_,
+      columnSelector_.get(),
+      projectedNodes_,
+      options_,
+      stripeInfo_.offset(),
+      stripeInfo_.numberOfRows(),
+      strideIndexProvider_,
+      stripeIndex_);
+
+  auto* scanSpec = options_.scanSpec().get();
+  const auto& fileType = stripeReaderBase_.getReader().schemaWithId();
+  FlatMapContext flatMapContext;
+  flatMapContext.keySelectionCallback = options_.keySelectionCallback();
+  memory::AllocationPool pool(&stripeReaderBase_.getReader().memoryPool());
+  StreamLabels streamLabels(pool);
+
+  if (scanSpec) {
+    selectiveColumnReader_ = SelectiveDwrfReader::build(
+        options_.requestedType() ? options_.requestedType() : fileType->type(),
+        fileType,
+        *stripeStreams_,
+        streamLabels,
+        *columnReaderStatistics_,
+        scanSpec,
+        flatMapContext,
+        /*isRoot=*/true);
+    selectiveColumnReader_->setIsTopLevel();
+    selectiveColumnReader_->setFillMutatedOutputRows(
+        options_.rowNumberColumnInfo().has_value());
+  } else {
+    auto requestedType = columnSelector_->getSchemaWithId();
+    auto factory = &ColumnReaderFactory::defaultFactory();
+    if (auto formatOptions = std::dynamic_pointer_cast<DwrfOptions>(
+            options_.formatSpecificOptions())) {
+      factory = formatOptions->columnReaderFactory().get();
+    }
+    columnReader_ = factory->build(
+        requestedType,
+        fileType,
+        *stripeStreams_,
+        streamLabels,
+        options_.decodingExecutor().get(),
+        options_.decodingParallelismFactor(),
+        flatMapContext);
+  }
+
+  VELOX_CHECK_NE(
+      columnReader_ != nullptr,
+      selectiveColumnReader_ != nullptr,
+      "ColumnReader was not created");
+}
+
+void DwrfUnit::loadDecoders() {
+  // load data plan according to its updated selector during column reader
+  // construction if planReads is off which means stripe data loaded as whole.
+  if (!preloaded_) {
+    VLOG(1) << "[DWRF] Load read plan for stripe " << stripeIndex_;
+    stripeStreams_->loadReadPlan();
+  }
+
+  stripeDictionaryCache_ = stripeStreams_->getStripeDictionaryCache();
+}
+
+namespace {
+
+DwrfUnit* castDwrfUnit(LoadUnit* unit) {
+  VELOX_CHECK_NOT_NULL(unit);
+  auto* dwrfUnit = dynamic_cast<DwrfUnit*>(unit);
+  VELOX_CHECK_NOT_NULL(dwrfUnit);
+  return dwrfUnit;
+}
+
+void makeProjectedNodes(
+    const dwio::common::TypeWithId& fileType,
+    BitSet& projectedNodes) {
+  projectedNodes.insert(fileType.id());
+  for (auto& child : fileType.getChildren()) {
+    if (child) {
+      makeProjectedNodes(*child, projectedNodes);
+    }
+  }
+}
+
+} // namespace
 
 DwrfRowReader::DwrfRowReader(
     const std::shared_ptr<ReaderBase>& reader,
     const RowReaderOptions& opts)
     : StripeReaderBase(reader),
       options_(opts),
-      columnSelector_{std::make_shared<ColumnSelector>(
-          ColumnSelector::apply(opts.getSelector(), reader->getSchema()))} {
-  auto& footer = getReader().getFooter();
-  uint32_t numberOfStripes = footer.stripesSize();
-  currentStripe = numberOfStripes;
-  lastStripe = 0;
-  currentRowInStripe = 0;
-  newStripeReadyForRead = false;
-  rowsInCurrentStripe = 0;
-  uint64_t rowTotal = 0;
-
-  firstRowOfStripe.reserve(numberOfStripes);
+      columnSelector_{
+          options_.scanSpec() != nullptr
+              ? nullptr
+              : std::make_shared<ColumnSelector>(ColumnSelector::apply(
+                    options_.selector(),
+                    reader->schema()))},
+      decodingTimeCallback_{options_.decodingTimeCallback()},
+      strideIndex_{0},
+      currentUnit_{nullptr} {
+  const auto& fileFooter = getReader().footer();
+  const uint32_t numberOfStripes = fileFooter.stripesSize();
+  currentStripe_ = numberOfStripes;
+  stripeCeiling_ = 0;
+  currentRowInStripe_ = 0;
+  rowsInCurrentStripe_ = 0;
+
+  uint64_t numRows{0};
+  firstRowOfStripe_.reserve(numberOfStripes);
   for (uint32_t i = 0; i < numberOfStripes; ++i) {
-    firstRowOfStripe.push_back(rowTotal);
-    auto stripeInfo = footer.stripes(i);
-    rowTotal += stripeInfo.numberOfRows();
-    if ((stripeInfo.offset() >= opts.getOffset()) &&
-        (stripeInfo.offset() < opts.getLimit())) {
-      if (i < currentStripe) {
-        currentStripe = i;
-      }
-      if (i >= lastStripe) {
-        lastStripe = i + 1;
-      }
+    firstRowOfStripe_.push_back(numRows);
+    const auto stripeInfo = fileFooter.stripes(i);
+    numRows += stripeInfo.numberOfRows();
+    if ((stripeInfo.offset() >= options_.offset()) &&
+        (stripeInfo.offset() < options_.limit())) {
+      currentStripe_ = std::min(currentStripe_, i);
+      stripeCeiling_ = std::max(stripeCeiling_, i + 1);
     }
   }
-  firstStripe = currentStripe;
+  firstStripe_ = currentStripe_;
+
+  // stripeCeiling_ will only be 0 here in cases where the passed
+  // RowReaderOptions has an [offset,length] not found in the file. In this
+  // case, set stripeCeiling_ == firstStripe_ == numberOfStripes
+  if (stripeCeiling_ == 0) {
+    stripeCeiling_ = firstStripe_;
+  }
+
+  const auto stripeCountCallback = options_.stripeCountCallback();
+  if (stripeCountCallback) {
+    stripeCountCallback(stripeCeiling_ - firstStripe_);
+  }
 
-  if (currentStripe == 0) {
-    previousRow = std::numeric_limits<uint64_t>::max();
-  } else if (currentStripe == numberOfStripes) {
-    previousRow = footer.numberOfRows();
+  if (currentStripe_ == 0) {
+    previousRow_ = std::numeric_limits<uint64_t>::max();
+  } else if (currentStripe_ == numberOfStripes) {
+    previousRow_ = fileFooter.numberOfRows();
   } else {
-    previousRow = firstRowOfStripe[firstStripe] - 1;
+    previousRow_ = firstRowOfStripe_[firstStripe_] - 1;
   }
 
   // Validate the requested type is compatible with what's in the file
   std::function<std::string()> createExceptionContext = [&]() {
-    std::string exceptionMessageContext = fmt::format(
+    return fmt::format(
         "The schema loaded in the reader does not match the schema in the file footer."
         "Input Name: {},\n"
         "File Footer Schema (without partition columns): {},\n"
         "Input Table Schema (with partition columns): {}\n",
-        getReader().getBufferedInput().getName(),
-        getReader().getSchema()->toString(),
-        getType()->toString());
-    return exceptionMessageContext;
+        getReader().bufferedInput().getName(),
+        getReader().schema()->toString(),
+        type()->toString());
   };
 
-  dwio::common::typeutils::checkTypeCompatibility(
-      *getReader().getSchema(), *columnSelector_, createExceptionContext);
+  if (columnSelector_) {
+    dwio::common::typeutils::checkTypeCompatibility(
+        *getReader().schema(), *columnSelector_, createExceptionContext);
+  } else {
+    projectedNodes_ = std::make_shared<BitSet>(0);
+    makeProjectedNodes(*getReader().schemaWithId(), *projectedNodes_);
+  }
+
+  unitLoader_ = getUnitLoader();
+}
+
+std::unique_ptr<ColumnReader>& DwrfRowReader::getColumnReader() {
+  VELOX_DCHECK_NOT_NULL(currentUnit_);
+  return currentUnit_->getColumnReader();
+}
+
+std::unique_ptr<dwio::common::SelectiveColumnReader>&
+DwrfRowReader::getSelectiveColumnReader() {
+  VELOX_DCHECK(currentUnit_ != nullptr);
+  return currentUnit_->getSelectiveColumnReader();
+}
 
-  stripeLoadBatons_.reserve(numberOfStripes);
-  for (int i = 0; i < numberOfStripes; i++) {
-    stripeLoadBatons_.emplace_back(std::make_unique<folly::Baton<>>());
+std::unique_ptr<dwio::common::UnitLoader> DwrfRowReader::getUnitLoader() {
+  std::vector<std::unique_ptr<LoadUnit>> loadUnits;
+  loadUnits.reserve(stripeCeiling_ - firstStripe_);
+  for (auto stripe = firstStripe_; stripe < stripeCeiling_; ++stripe) {
+    loadUnits.emplace_back(std::make_unique<DwrfUnit>(
+        /*stripeReaderBase=*/*this,
+        /*strideIndexProvider=*/*this,
+        columnReaderStatistics_,
+        stripe,
+        columnSelector_,
+        projectedNodes_,
+        options_));
+  }
+  std::shared_ptr<UnitLoaderFactory> unitLoaderFactory =
+      options_.unitLoaderFactory();
+  if (!unitLoaderFactory) {
+    unitLoaderFactory =
+        std::make_shared<dwio::common::OnDemandUnitLoaderFactory>(
+            options_.blockedOnIoCallback());
   }
-  stripeLoadStatuses_ = folly::Synchronized(
-      std::vector<FetchStatus>(numberOfStripes, FetchStatus::NOT_STARTED));
+  return unitLoaderFactory->create(std::move(loadUnits), 0);
 }
 
 uint64_t DwrfRowReader::seekToRow(uint64_t rowNumber) {
@@ -99,72 +344,83 @@ uint64_t DwrfRowReader::seekToRow(uint64_t rowNumber) {
   if (isEmptyFile()) {
     return 0;
   }
-
-  DWIO_ENSURE(
-      !prefetchHasOccurred_,
-      "Prefetch already called. Currently, seek after prefetch is disallowed in DwrfRowReader");
-
-  // If we are reading only a portion of the file
-  // (bounded by firstStripe and lastStripe),
-  // seeking before or after the portion of interest should return no data.
-  // Implement this by setting previousRow to the number of rows in the file.
-
-  // seeking past lastStripe
-  auto& footer = getReader().getFooter();
-  uint32_t num_stripes = footer.stripesSize();
-  if ((lastStripe == num_stripes && rowNumber >= footer.numberOfRows()) ||
-      (lastStripe < num_stripes && rowNumber >= firstRowOfStripe[lastStripe])) {
-    VLOG(1) << "Trying to seek past lastStripe, total rows: "
-            << footer.numberOfRows() << " num_stripes: " << num_stripes;
-
-    currentStripe = num_stripes;
-
-    previousRow = footer.numberOfRows();
-    return previousRow;
+  nextRowNumber_.reset();
+
+  // If we are reading only a portion of the file (bounded by firstStripe_ and
+  // stripeCeiling_), seeking before or after the portion of interest should
+  // return no data. Implement this by setting previousRow_ to the number of
+  // rows in the file.
+
+  // seeking past stripeCeiling_.
+  const auto& fileFooter = getReader().footer();
+  const uint32_t numStripes = fileFooter.stripesSize();
+  if ((stripeCeiling_ == numStripes &&
+       rowNumber >= fileFooter.numberOfRows()) ||
+      (stripeCeiling_ < numStripes &&
+       rowNumber >= firstRowOfStripe_[stripeCeiling_])) {
+    VLOG(1) << "Trying to seek past stripeCeiling_, total rows: "
+            << fileFooter.numberOfRows() << " num_stripes: " << numStripes;
+
+    currentStripe_ = numStripes;
+    previousRow_ = fileFooter.numberOfRows();
+    return previousRow_;
   }
 
   uint32_t seekToStripe = 0;
-  while (seekToStripe + 1 < lastStripe &&
-         firstRowOfStripe[seekToStripe + 1] <= rowNumber) {
-    seekToStripe++;
+  while (seekToStripe + 1 < stripeCeiling_ &&
+         firstRowOfStripe_[seekToStripe + 1] <= rowNumber) {
+    ++seekToStripe;
   }
 
   // seeking before the first stripe
-  if (seekToStripe < firstStripe) {
-    currentStripe = num_stripes;
-    previousRow = footer.numberOfRows();
-    return previousRow;
+  if (seekToStripe < firstStripe_) {
+    currentStripe_ = numStripes;
+    previousRow_ = fileFooter.numberOfRows();
+    return previousRow_;
   }
 
-  currentStripe = seekToStripe;
-  currentRowInStripe = rowNumber - firstRowOfStripe[currentStripe];
-  previousRow = rowNumber;
-
-  // Reset baton, since seek flow can load a stripe more than once and is
-  // synchronous for now.
-  VLOG(1) << "Resetting baton at " << currentStripe;
-  stripeLoadBatons_[currentStripe] = std::make_unique<folly::Baton<>>();
-  stripeLoadStatuses_.wlock()->operator[](currentStripe) =
-      FetchStatus::NOT_STARTED;
-
-  VLOG(1) << "rowNumber: " << rowNumber << " currentStripe: " << currentStripe
-          << " firstStripe: " << firstStripe << " lastStripe: " << lastStripe;
-
-  // Because prefetch and seek are currently incompatible, there should only
-  // ever be 1 stripe fetched at this point.
-  VLOG(1) << "Erasing " << currentStripe << " from prefetched_";
-  prefetchedStripeStates_.wlock()->erase(currentStripe);
-  freeStripeAt(currentStripe);
-  newStripeReadyForRead = false;
-  startNextStripe();
-
-  if (selectiveColumnReader_) {
-    selectiveColumnReader_->skip(currentRowInStripe);
-  } else {
-    columnReader_->skip(currentRowInStripe);
-  }
+  const auto previousStripe = currentStripe_;
+  const auto previousRowInStripe = currentRowInStripe_;
+  currentStripe_ = seekToStripe;
+  currentRowInStripe_ = rowNumber - firstRowOfStripe_[currentStripe_];
+  previousRow_ = rowNumber;
+
+  const auto loadUnitIdx = currentStripe_ - firstStripe_;
+  unitLoader_->onSeek(loadUnitIdx, currentRowInStripe_);
+
+  if (currentStripe_ != previousStripe) {
+    // Different stripe. Let's load the new stripe.
+    currentUnit_ = nullptr;
+    loadCurrentStripe();
+    if (currentRowInStripe_ > 0) {
+      skip(currentRowInStripe_);
+    }
+  } else if (currentRowInStripe_ < previousRowInStripe) {
+    // Same stripe but we have to seek backwards.
+    if (currentUnit_) {
+      // We had a loaded stripe, we have to reload.
+      LOG(WARNING) << "Reloading stripe " << currentStripe_
+                   << " because we have to seek backwards on it from row "
+                   << previousRowInStripe << " to row " << currentRowInStripe_;
+      currentUnit_->unload();
+      currentUnit_->load();
+    } else {
+      // We had no stripe loaded. Let's load the current one.
+      loadCurrentStripe();
+    }
+    if (currentRowInStripe_ > 0) {
+      skip(currentRowInStripe_);
+    }
+  } else if (currentRowInStripe_ > previousRowInStripe) {
+    // We have to seek forward on the same stripe. We can just skip.
+    if (!currentUnit_) {
+      // Load the current stripe if no stripe was loaded.
+      loadCurrentStripe();
+    }
+    skip(currentRowInStripe_ - previousRowInStripe);
+  } // otherwise the seek ended on the same stripe, same row
 
-  return previousRow;
+  return previousRow_;
 }
 
 uint64_t DwrfRowReader::skipRows(uint64_t numberOfRowsToSkip) {
@@ -180,71 +436,71 @@ uint64_t DwrfRowReader::skipRows(uint64_t numberOfRowsToSkip) {
   }
 
   // when we skipped or exhausted the whole file we can return 0
-  auto& footer = getReader().getFooter();
-  if (previousRow == footer.numberOfRows()) {
-    VLOG(1) << "previousRow is beyond EOF, nothing to skip";
+  const auto& fileFooter = getReader().footer();
+  if (previousRow_ == fileFooter.numberOfRows()) {
+    VLOG(1) << "previousRow_ is beyond EOF, nothing to skip";
     return 0;
   }
 
-  if (previousRow == std::numeric_limits<uint64_t>::max()) {
+  if (previousRow_ == std::numeric_limits<uint64_t>::max()) {
     VLOG(1) << "Start of the file, skipping: " << numberOfRowsToSkip;
     seekToRow(numberOfRowsToSkip);
-    if (previousRow == footer.numberOfRows()) {
-      VLOG(1) << "Reached end of the file, returning: " << previousRow;
-      return previousRow;
+    if (previousRow_ == fileFooter.numberOfRows()) {
+      VLOG(1) << "Reached end of the file, returning: " << previousRow_;
+      return previousRow_;
     } else {
-      VLOG(1) << "previousRow after skipping: " << previousRow;
-      return previousRow;
+      VLOG(1) << "previousRow_ after skipping: " << previousRow_;
+      return previousRow_;
     }
   }
 
-  VLOG(1) << "Previous row: " << previousRow
+  VLOG(1) << "Previous row: " << previousRow_
           << " Skipping: " << numberOfRowsToSkip;
 
-  uint64_t initialRow = previousRow;
-  seekToRow(previousRow + numberOfRowsToSkip);
+  const uint64_t initialRow = previousRow_;
+  seekToRow(previousRow_ + numberOfRowsToSkip);
 
-  VLOG(1) << "After skipping: " << previousRow << " InitialRow: " << initialRow;
+  VLOG(1) << "After skipping: " << previousRow_
+          << " InitialRow: " << initialRow;
 
-  if (previousRow == footer.numberOfRows()) {
-    VLOG(1) << "When seeking past lastStripe";
-    return previousRow - initialRow - 1;
+  if (previousRow_ == fileFooter.numberOfRows()) {
+    VLOG(1) << "When seeking past stripeCeiling_";
+    return previousRow_ - initialRow - 1;
   }
-  return previousRow - initialRow;
+  return previousRow_ - initialRow;
 }
 
 void DwrfRowReader::checkSkipStrides(uint64_t strideSize) {
-  if (!selectiveColumnReader_ || strideSize == 0 ||
-      currentRowInStripe % strideSize != 0) {
+  if (!getSelectiveColumnReader() || strideSize == 0 ||
+      currentRowInStripe_ % strideSize != 0) {
     return;
   }
 
-  if (currentRowInStripe == 0 || recomputeStridesToSkip_) {
-    StatsContext context(
-        getReader().getWriterName(), getReader().getWriterVersion());
+  if (currentRowInStripe_ == 0 || recomputeStridesToSkip_) {
+    StatsContext context(getReader().writerName(), getReader().writerVersion());
     DwrfData::FilterRowGroupsResult res;
-    selectiveColumnReader_->filterRowGroups(strideSize, context, res);
-    if (auto& metadataFilter = options_.getMetadataFilter()) {
+    getSelectiveColumnReader()->filterRowGroups(strideSize, context, res);
+    if (auto& metadataFilter = options_.metadataFilter()) {
       metadataFilter->eval(res.metadataFilterResults, res.filterResult);
     }
     stridesToSkip_ = res.filterResult.data();
     stridesToSkipSize_ = res.totalCount;
-    stripeStridesToSkip_[currentStripe] = std::move(res.filterResult);
+    stripeStridesToSkip_[currentStripe_] = std::move(res.filterResult);
     recomputeStridesToSkip_ = false;
   }
 
   bool foundStridesToSkip = false;
-  auto currentStride = currentRowInStripe / strideSize;
+  auto currentStride = currentRowInStripe_ / strideSize;
   while (currentStride < stridesToSkipSize_ &&
          bits::isBitSet(stridesToSkip_, currentStride)) {
     foundStridesToSkip = true;
-    currentRowInStripe =
-        std::min(currentRowInStripe + strideSize, rowsInCurrentStripe);
-    currentStride++;
-    skippedStrides_++;
+    currentRowInStripe_ =
+        std::min(currentRowInStripe_ + strideSize, rowsInCurrentStripe_);
+    ++currentStride;
+    ++skippedStrides_;
   }
-  if (foundStridesToSkip && currentRowInStripe < rowsInCurrentStripe) {
-    selectiveColumnReader_->seekToRowGroup(currentStride);
+  if (foundStridesToSkip && currentRowInStripe_ < rowsInCurrentStripe_) {
+    getSelectiveColumnReader()->seekToRowGroup(currentStride);
   }
 }
 
@@ -252,106 +508,83 @@ void DwrfRowReader::readNext(
     uint64_t rowsToRead,
     const dwio::common::Mutation* mutation,
     VectorPtr& result) {
-  if (!selectiveColumnReader_) {
+  if (!getSelectiveColumnReader()) {
+    std::optional<std::chrono::steady_clock::time_point> startTime;
+    if (decodingTimeCallback_) {
+      // We'll use wall time since we have parallel decoding.
+      // If we move to sequential decoding only, we can use CPU time.
+      startTime.emplace(std::chrono::steady_clock::now());
+    }
     // TODO: Move row number appending logic here.  Currently this is done in
     // the wrapper reader.
-    VELOX_CHECK(
-        mutation == nullptr,
-        "Mutation pushdown is only supported in selective reader");
-    columnReader_->next(rowsToRead, result);
+    VELOX_CHECK_NULL(
+        mutation, "Mutation pushdown is only supported in selective reader");
+    getColumnReader()->next(rowsToRead, result);
+    if (startTime.has_value()) {
+      decodingTimeCallback_(
+          std::chrono::steady_clock::now() - startTime.value());
+    }
     return;
   }
-  if (!options_.getAppendRowNumberColumn()) {
-    selectiveColumnReader_->next(rowsToRead, result, mutation);
+
+  if (!options_.rowNumberColumnInfo().has_value()) {
+    getSelectiveColumnReader()->next(rowsToRead, result, mutation);
     return;
   }
-  readWithRowNumber(rowsToRead, mutation, result);
+
+  readWithRowNumber(
+      getSelectiveColumnReader(),
+      options_,
+      previousRow_,
+      rowsToRead,
+      mutation,
+      result);
 }
 
-void DwrfRowReader::readWithRowNumber(
-    uint64_t rowsToRead,
-    const dwio::common::Mutation* mutation,
-    VectorPtr& result) {
-  auto* rowVector = result->asUnchecked<RowVector>();
-  column_index_t numChildren = 0;
-  for (auto& column : options_.getScanSpec()->children()) {
-    if (column->projectOut()) {
-      ++numChildren;
-    }
-  }
-  VectorPtr rowNumVector;
-  if (rowVector->childrenSize() != numChildren) {
-    VELOX_CHECK_EQ(rowVector->childrenSize(), numChildren + 1);
-    rowNumVector = rowVector->childAt(numChildren);
-    auto& rowType = rowVector->type()->asRow();
-    auto names = rowType.names();
-    auto types = rowType.children();
-    auto children = rowVector->children();
-    VELOX_DCHECK(!names.empty() && !types.empty() && !children.empty());
-    names.pop_back();
-    types.pop_back();
-    children.pop_back();
-    result = std::make_shared<RowVector>(
-        rowVector->pool(),
-        ROW(std::move(names), std::move(types)),
-        rowVector->nulls(),
-        rowVector->size(),
-        std::move(children));
-  }
-  selectiveColumnReader_->next(rowsToRead, result, mutation);
-  FlatVector<int64_t>* flatRowNum = nullptr;
-  if (rowNumVector && BaseVector::isVectorWritable(rowNumVector)) {
-    flatRowNum = rowNumVector->asFlatVector<int64_t>();
-  }
-  if (flatRowNum) {
-    flatRowNum->clearAllNulls();
-    flatRowNum->resize(result->size());
+uint64_t DwrfRowReader::skip(uint64_t numValues) {
+  if (getSelectiveColumnReader()) {
+    return getSelectiveColumnReader()->skip(numValues);
   } else {
-    rowNumVector = std::make_shared<FlatVector<int64_t>>(
-        result->pool(),
-        BIGINT(),
-        nullptr,
-        result->size(),
-        AlignedBuffer::allocate<int64_t>(result->size(), result->pool()),
-        std::vector<BufferPtr>());
-    flatRowNum = rowNumVector->asUnchecked<FlatVector<int64_t>>();
+    return getColumnReader()->skip(numValues);
   }
-  auto rowOffsets = selectiveColumnReader_->outputRows();
-  VELOX_DCHECK_EQ(rowOffsets.size(), result->size());
-  auto* rawRowNum = flatRowNum->mutableRawValues();
-  for (int i = 0; i < rowOffsets.size(); ++i) {
-    rawRowNum[i] = previousRow + rowOffsets[i];
-  }
-  rowVector = result->asUnchecked<RowVector>();
-  auto& rowType = rowVector->type()->asRow();
-  auto names = rowType.names();
-  auto types = rowType.children();
-  auto children = rowVector->children();
-  names.emplace_back();
-  types.push_back(BIGINT());
-  children.push_back(rowNumVector);
-  result = std::make_shared<RowVector>(
-      rowVector->pool(),
-      ROW(std::move(names), std::move(types)),
-      rowVector->nulls(),
-      rowVector->size(),
-      std::move(children));
 }
 
 int64_t DwrfRowReader::nextRowNumber() {
-  auto strideSize = getReader().getFooter().rowIndexStride();
-  while (currentStripe < lastStripe) {
-    if (currentRowInStripe == 0) {
-      startNextStripe();
+  if (nextRowNumber_.has_value()) {
+    return *nextRowNumber_;
+  }
+
+  const auto strideSize = getReader().footer().rowIndexStride();
+  while (currentStripe_ < stripeCeiling_) {
+    if (currentRowInStripe_ == 0) {
+      if (getReader().randomSkip()) {
+        const auto numStripeRows =
+            getReader().footer().stripes(currentStripe_).numberOfRows();
+        const auto skipRows = getReader().randomSkip()->nextSkip();
+        if (skipRows >= numStripeRows) {
+          getReader().randomSkip()->consume(numStripeRows);
+          const auto numStrides = bits::divRoundUp(numStripeRows, strideSize);
+          skippedStrides_ += numStrides;
+          goto advanceToNextStripe;
+        }
+      }
+      loadCurrentStripe();
+      VELOX_CHECK_NOT_NULL(currentUnit_);
     }
+
     checkSkipStrides(strideSize);
-    if (currentRowInStripe < rowsInCurrentStripe) {
-      return firstRowOfStripe[currentStripe] + currentRowInStripe;
+    if (currentRowInStripe_ < rowsInCurrentStripe_) {
+      nextRowNumber_ = firstRowOfStripe_[currentStripe_] + currentRowInStripe_;
+      return *nextRowNumber_;
     }
-    ++currentStripe;
-    currentRowInStripe = 0;
-    newStripeReadyForRead = false;
+
+  advanceToNextStripe:
+    ++currentStripe_;
+    currentRowInStripe_ = 0;
+    currentUnit_ = nullptr;
   }
+
+  nextRowNumber_ = kAtEnd;
   return kAtEnd;
 }
 
@@ -360,12 +593,13 @@ int64_t DwrfRowReader::nextReadSize(uint64_t size) {
   if (nextRowNumber() == kAtEnd) {
     return kAtEnd;
   }
-  auto rowsToRead = std::min(size, rowsInCurrentStripe - currentRowInStripe);
-  auto strideSize = getReader().getFooter().rowIndexStride();
+
+  auto rowsToRead = std::min(size, rowsInCurrentStripe_ - currentRowInStripe_);
+  const auto strideSize = getReader().footer().rowIndexStride();
   if (LIKELY(strideSize > 0)) {
     // Don't allow read to cross stride.
     rowsToRead =
-        std::min(rowsToRead, strideSize - currentRowInStripe % strideSize);
+        std::min(rowsToRead, strideSize - currentRowInStripe_ % strideSize);
   }
   VELOX_DCHECK_GT(rowsToRead, 0);
   return rowsToRead;
@@ -375,251 +609,97 @@ uint64_t DwrfRowReader::next(
     uint64_t size,
     velox::VectorPtr& result,
     const dwio::common::Mutation* mutation) {
-  auto nextRow = nextRowNumber();
+  const auto nextRow = nextRowNumber();
   if (nextRow == kAtEnd) {
-    if (lastStripe > 0) {
-      previousRow = firstRowOfStripe[lastStripe - 1] +
-          getReader().getFooter().stripes(lastStripe - 1).numberOfRows();
+    if (!isEmptyFile()) {
+      previousRow_ = firstRowOfStripe_[stripeCeiling_ - 1] +
+          getReader().footer().stripes(stripeCeiling_ - 1).numberOfRows();
     } else {
-      previousRow = 0;
+      previousRow_ = 0;
     }
     return 0;
   }
-  auto rowsToRead = nextReadSize(size);
-  previousRow = nextRow;
+
+  const auto rowsToRead = nextReadSize(size);
+  nextRowNumber_.reset();
+  previousRow_ = nextRow;
   // Record strideIndex for use by the columnReader_ which may delay actual
   // reading of the data.
-  auto strideSize = getReader().getFooter().rowIndexStride();
-  strideIndex_ = strideSize > 0 ? currentRowInStripe / strideSize : 0;
+  const auto strideSize = getReader().footer().rowIndexStride();
+  strideIndex_ = strideSize > 0 ? currentRowInStripe_ / strideSize : 0;
+  const auto loadUnitIdx = currentStripe_ - firstStripe_;
+  unitLoader_->onRead(loadUnitIdx, currentRowInStripe_, rowsToRead);
   readNext(rowsToRead, mutation, result);
-  currentRowInStripe += rowsToRead;
+  currentRowInStripe_ += rowsToRead;
   return rowsToRead;
 }
 
 void DwrfRowReader::resetFilterCaches() {
-  if (selectiveColumnReader_) {
-    selectiveColumnReader_->resetFilterCaches();
+  if (getSelectiveColumnReader()) {
+    getSelectiveColumnReader()->resetFilterCaches();
     recomputeStridesToSkip_ = true;
   }
 
   // For columnReader_, this is no-op.
 }
 
-std::optional<std::vector<velox::dwio::common::RowReader::PrefetchUnit>>
-DwrfRowReader::prefetchUnits() {
-  auto rowsInStripe = getReader().getRowsPerStripe();
-  DWIO_ENSURE(firstStripe <= rowsInStripe.size());
-  DWIO_ENSURE(lastStripe <= rowsInStripe.size());
-  DWIO_ENSURE(firstStripe <= lastStripe);
-
-  std::vector<PrefetchUnit> res;
-  res.reserve(lastStripe - firstStripe);
-
-  for (auto stripe = firstStripe; stripe < lastStripe; ++stripe) {
-    res.push_back(
-        {.rowCount = rowsInStripe[stripe],
-         .prefetch = std::bind(&DwrfRowReader::prefetch, this, stripe)});
-  }
-  return res;
-}
-
-DwrfRowReader::FetchResult DwrfRowReader::fetch(uint32_t stripeIndex) {
-  FetchStatus prevStatus;
-  stripeLoadStatuses_.withWLock([&](auto& loadRequestIssued) {
-    if (stripeIndex < 0 || stripeIndex >= loadRequestIssued.size()) {
-      prevStatus = FetchStatus::ERROR;
-    }
-
-    prevStatus = loadRequestIssued[stripeIndex];
-    if (prevStatus == FetchStatus::NOT_STARTED) {
-      loadRequestIssued[stripeIndex] = FetchStatus::IN_PROGRESS;
-    }
-  });
-
-  DWIO_ENSURE(
-      prevStatus != FetchStatus::ERROR, "Fetch request was out of bounds");
-
-  if (prevStatus != FetchStatus::NOT_STARTED) {
-    bool finishedLoading = prevStatus == FetchStatus::FINISHED;
-
-    VLOG(1) << "Stripe " << stripeIndex << " was not loaded, as it was already "
-            << (finishedLoading ? "finished loading" : "in progress");
-    return finishedLoading ? FetchResult::kAlreadyFetched
-                           : FetchResult::kInProgress;
-  }
-
-  DWIO_ENSURE(
-      !prefetchedStripeStates_.rlock()->contains(stripeIndex),
-      "prefetched stripe state already exists for stripeIndex " +
-          std::to_string(stripeIndex) + ", LIKELY RACE CONDITION");
-
-  auto startTime = std::chrono::high_resolution_clock::now();
-  bool preload = options_.getPreloadStripe();
-
-  // Currently we only call prefetchStripe through here. If stripeLoadStatuses_
-  // says we haven't started a load here yet, then this should always succeed
-  DWIO_ENSURE(fetchStripe(stripeIndex, preload));
-
-  VLOG(1) << "fetchStripe success";
-
-  auto prefetchedStripeBase = getStripeBase(stripeIndex);
-
-  auto state = std::make_shared<StripeReadState>(
-      readerBaseShared(),
-      prefetchedStripeBase->stripeInput.get(),
-      prefetchedStripeBase->footer,
-      getDecryptionHandler());
-
-  auto stripe = getReader().getFooter().stripes(stripeIndex);
-  StripeStreamsImpl stripeStreams(
-      state,
-      getColumnSelector(),
-      options_,
-      stripe.offset(),
-      stripe.numberOfRows(),
-      *this,
-      stripeIndex);
-
-  auto scanSpec = options_.getScanSpec().get();
-  auto requestedType = getColumnSelector().getSchemaWithId();
-  auto dataType = getReader().getSchemaWithId();
-  FlatMapContext flatMapContext;
-  flatMapContext.keySelectionCallback = options_.getKeySelectionCallback();
-  memory::AllocationPool pool(&getReader().getMemoryPool());
-  StreamLabels streamLabels(pool);
-
-  PrefetchedStripeState stripeState;
-  if (scanSpec) {
-    stripeState.selectiveColumnReader = SelectiveDwrfReader::build(
-        requestedType,
-        dataType,
-        stripeStreams,
-        streamLabels,
-        columnReaderStatistics_,
-        scanSpec,
-        flatMapContext,
-        true); // isRoot
-    stripeState.selectiveColumnReader->setIsTopLevel();
-  } else {
-    stripeState.columnReader = ColumnReader::build( // enqueue streams
-        requestedType,
-        dataType,
-        stripeStreams,
-        streamLabels,
-        flatMapContext);
-  }
-  DWIO_ENSURE(
-      (stripeState.columnReader != nullptr) !=
-          (stripeState.selectiveColumnReader != nullptr),
-      "ColumnReader was not created");
-
-  // load data plan according to its updated selector
-  // during column reader construction
-  // if planReads is off which means stripe data loaded as whole
-  if (!preload) {
-    VLOG(1) << "[DWRF] Load read plan for stripe " << currentStripe;
-    stripeStreams.loadReadPlan();
+void DwrfRowReader::loadCurrentStripe() {
+  if (currentUnit_ || currentStripe_ >= stripeCeiling_) {
+    return;
   }
 
-  stripeState.stripeDictionaryCache = stripeStreams.getStripeDictionaryCache();
-  stripeState.preloaded = preload;
-  prefetchedStripeStates_.wlock()->operator[](stripeIndex) =
-      std::move(stripeState);
-
-  auto endTime = std::chrono::high_resolution_clock::now();
-  VLOG(1) << " time to complete prefetch: "
-          << std::chrono::duration_cast<std::chrono::microseconds>(
-                 endTime - startTime)
-                 .count();
-  stripeLoadBatons_[stripeIndex]->post();
-  VLOG(1) << "done in fetch and baton posted for " << stripeIndex << ", thread "
-          << std::this_thread::get_id();
-
-  stripeLoadStatuses_.wlock()->operator[](stripeIndex) = FetchStatus::FINISHED;
-  return FetchResult::kFetched;
+  VELOX_CHECK_GE(currentStripe_, firstStripe_);
+  strideIndex_ = 0;
+  const auto loadUnitIdx = currentStripe_ - firstStripe_;
+  currentUnit_ = castDwrfUnit(&unitLoader_->getLoadedUnit(loadUnitIdx));
+  rowsInCurrentStripe_ = currentUnit_->getNumRows();
 }
 
-DwrfRowReader::FetchResult DwrfRowReader::prefetch(uint32_t stripeToFetch) {
-  DWIO_ENSURE(stripeToFetch < lastStripe && stripeToFetch >= 0);
-  prefetchHasOccurred_ = true;
-
-  VLOG(1) << "Unlocked lock and calling fetch for " << stripeToFetch
-          << ", thread " << std::this_thread::get_id();
-  return fetch(stripeToFetch);
+size_t DwrfRowReader::estimatedReaderMemory() const {
+  VELOX_CHECK_NOT_NULL(columnSelector_);
+  return 2 * DwrfReader::getMemoryUse(getReader(), -1, *columnSelector_);
 }
 
-// Guarantee stripe we are currently on is available and loaded
-void DwrfRowReader::safeFetchNextStripe() {
-  // Check result of fetch to avoid synchronization if we fetched on this
-  // thread.
-  if (fetch(currentStripe) != FetchResult::kFetched) {
-    // Now we know the stripe was or is being loaded on another thread,
-    // Await the baton for this stripe before we return to ensure load is done.
-    VLOG(1) << "Waiting on baton for stripe: " << currentStripe;
-    stripeLoadBatons_[currentStripe]->wait();
-    VLOG(1) << "Acquired baton for stripe " << currentStripe;
+bool DwrfRowReader::shouldReadNode(uint32_t nodeId) const {
+  if (columnSelector_) {
+    return columnSelector_->shouldReadNode(nodeId);
   }
-  DWIO_ENSURE(prefetchedStripeStates_.rlock()->contains(currentStripe));
+  return projectedNodes_->contains(nodeId);
 }
 
-void DwrfRowReader::startNextStripe() {
-  if (newStripeReadyForRead || currentStripe >= lastStripe) {
-    return;
+namespace {
+
+template <typename T>
+std::optional<uint64_t> getStringOrBinaryColumnSize(
+    const dwio::common::ColumnStatistics& stats) {
+  if (auto* typedStats = dynamic_cast<const T*>(&stats)) {
+    if (typedStats->getTotalLength().has_value()) {
+      return typedStats->getTotalLength();
+    }
   }
-  columnReader_.reset();
-  selectiveColumnReader_.reset();
-  safeFetchNextStripe();
-  prefetchedStripeStates_.withWLock([&](auto& prefetchedStripeStates) {
-    DWIO_ENSURE(prefetchedStripeStates.contains(currentStripe));
-
-    auto stripe = getReader().getFooter().stripes(currentStripe);
-    rowsInCurrentStripe = stripe.numberOfRows();
-
-    auto& state = prefetchedStripeStates[currentStripe];
-    columnReader_ = std::move(state.columnReader);
-    selectiveColumnReader_ = std::move(state.selectiveColumnReader);
-    stripeDictionaryCache_ = state.stripeDictionaryCache;
-
-    VLOG(1) << "Erasing " << currentStripe << " from prefetched_";
-    // This callsite knows we have already fetched the stripe, and preload arg
-    // will not be used.
-    bool preloadThrowaway = false;
-    loadStripe(currentStripe, preloadThrowaway);
-
-    prefetchedStripeStates.erase(currentStripe);
-  });
-  auto startTime = std::chrono::high_resolution_clock::now();
-
-  DWIO_ENSURE(freeStripeAt(currentStripe));
-
-  newStripeReadyForRead = true;
-  auto endTime = std::chrono::high_resolution_clock::now();
-  VLOG(1) << " time to complete startNextStripe: "
-          << std::chrono::duration_cast<std::chrono::microseconds>(
-                 endTime - startTime)
-                 .count();
+  // Sometimes the column statistics are not typed and we don't have total
+  // length, use raw size as an estimation.
+  return stats.getRawSize();
 }
 
-size_t DwrfRowReader::estimatedReaderMemory() const {
-  return 2 * DwrfReader::getMemoryUse(getReader(), -1, *columnSelector_);
-}
+} // namespace
 
 std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
-    const FooterWrapper& footer,
+    const FooterWrapper& fileFooter,
     const dwio::common::Statistics& stats,
     uint32_t nodeId) const {
-  DWIO_ENSURE_LT(nodeId, footer.typesSize(), "Types missing in footer");
+  VELOX_CHECK_LT(nodeId, fileFooter.typesSize(), "Types missing in footer");
 
-  const auto& s = stats.getColumnStatistics(nodeId);
-  const auto& t = footer.types(nodeId);
-  if (!s.getNumberOfValues()) {
+  const auto& nodeStats = stats.getColumnStatistics(nodeId);
+  const auto& nodeType = fileFooter.types(nodeId);
+  if (!nodeStats.getNumberOfValues()) {
     return std::nullopt;
   }
-  auto valueCount = s.getNumberOfValues().value();
+  const auto valueCount = nodeStats.getNumberOfValues().value();
   if (valueCount < 1) {
     return 0;
   }
-  switch (t.kind()) {
+  switch (nodeType.kind()) {
     case TypeKind::BOOLEAN: {
       return valueCount * sizeof(uint8_t);
     }
@@ -644,30 +724,12 @@ std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
     case TypeKind::DOUBLE: {
       return valueCount * sizeof(double);
     }
-    case TypeKind::VARCHAR: {
-      auto stringStats =
-          dynamic_cast<const dwio::common::StringColumnStatistics*>(&s);
-      if (!stringStats) {
-        return std::nullopt;
-      }
-      auto length = stringStats->getTotalLength();
-      if (!length) {
-        return std::nullopt;
-      }
-      return length.value();
-    }
-    case TypeKind::VARBINARY: {
-      auto binaryStats =
-          dynamic_cast<const dwio::common::BinaryColumnStatistics*>(&s);
-      if (!binaryStats) {
-        return std::nullopt;
-      }
-      auto length = binaryStats->getTotalLength();
-      if (!length) {
-        return std::nullopt;
-      }
-      return length.value();
-    }
+    case TypeKind::VARCHAR:
+      return getStringOrBinaryColumnSize<dwio::common::StringColumnStatistics>(
+          nodeStats);
+    case TypeKind::VARBINARY:
+      return getStringOrBinaryColumnSize<dwio::common::BinaryColumnStatistics>(
+          nodeStats);
     case TypeKind::TIMESTAMP: {
       return valueCount * sizeof(uint64_t) * 2;
     }
@@ -676,12 +738,12 @@ std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
     case TypeKind::ROW: {
       // start the estimate with the offsets and hasNulls vectors sizes
       size_t totalEstimate = valueCount * (sizeof(uint8_t) + sizeof(uint64_t));
-      for (int32_t i = 0; i < t.subtypesSize(); ++i) {
-        if (!columnSelector_->shouldReadNode(t.subtypes(i))) {
+      for (int32_t i = 0; i < nodeType.subtypesSize(); ++i) {
+        if (!shouldReadNode(nodeType.subtypes(i))) {
           continue;
         }
-        auto subtypeEstimate =
-            estimatedRowSizeHelper(footer, stats, t.subtypes(i));
+        const auto subtypeEstimate =
+            estimatedRowSizeHelper(fileFooter, stats, nodeType.subtypes(i));
         if (subtypeEstimate.has_value()) {
           totalEstimate += subtypeEstimate.value();
         } else {
@@ -696,25 +758,25 @@ std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
 }
 
 std::optional<size_t> DwrfRowReader::estimatedRowSize() const {
-  auto& reader = getReader();
-  auto& footer = reader.getFooter();
+  const auto& reader = getReader();
+  const auto& fileFooter = reader.footer();
 
-  if (!footer.hasNumberOfRows()) {
+  if (!fileFooter.hasNumberOfRows()) {
     return std::nullopt;
   }
 
-  if (footer.numberOfRows() < 1) {
+  if (fileFooter.numberOfRows() < 1) {
     return 0;
   }
 
-  // Estimate with projections
+  // Estimate with projections.
   constexpr uint32_t ROOT_NODE_ID = 0;
-  auto stats = reader.getStatistics();
-  auto projectedSize = estimatedRowSizeHelper(footer, *stats, ROOT_NODE_ID);
+  const auto stats = reader.statistics();
+  const auto projectedSize =
+      estimatedRowSizeHelper(fileFooter, *stats, ROOT_NODE_ID);
   if (projectedSize.has_value()) {
-    return projectedSize.value() / footer.numberOfRows();
+    return projectedSize.value() / fileFooter.numberOfRows();
   }
-
   return std::nullopt;
 }
 
@@ -722,23 +784,25 @@ DwrfReader::DwrfReader(
     const ReaderOptions& options,
     std::unique_ptr<dwio::common::BufferedInput> input)
     : readerBase_(std::make_unique<ReaderBase>(
-          options.getMemoryPool(),
+          options.memoryPool(),
           std::move(input),
-          options.getDecrypterFactory(),
-          options.getDirectorySizeGuess(),
-          options.getFilePreloadThreshold(),
-          options.getFileFormat() == FileFormat::ORC ? FileFormat::ORC
-                                                     : FileFormat::DWRF,
-          options.isFileColumnNamesReadAsLowerCase())),
+          options.decrypterFactory(),
+          options.footerEstimatedSize(),
+          options.filePreloadThreshold(),
+          options.fileFormat() == FileFormat::ORC ? FileFormat::ORC
+                                                  : FileFormat::DWRF,
+          options.fileColumnNamesReadAsLowerCase(),
+          options.randomSkip(),
+          options.scanSpec())),
       options_(options) {
-  // If we are not using column names to map table columns to file columns, then
-  // we use indices. In that case we need to ensure the names completely match,
-  // because we are still mapping columns by names further down the code.
-  // So we rename column names in the file schema to match table schema.
-  // We test the options to have 'fileSchema' (actually table schema) as most of
-  // the unit tests fail to provide it.
-  if ((not options_.isUseColumnNamesForColumnMapping()) and
-      (options_.getFileSchema() != nullptr)) {
+  // If we are not using column names to map table columns to file columns,
+  // then we use indices. In that case we need to ensure the names completely
+  // match, because we are still mapping columns by names further down the
+  // code. So we rename column names in the file schema to match table schema.
+  // We test the options to have 'fileSchema' (actually table schema) as most
+  // of the unit tests fail to provide it.
+  if ((!options_.useColumnNamesForColumnMapping()) &&
+      (options_.fileSchema() != nullptr)) {
     updateColumnNamesFromTableSchema();
   }
 }
@@ -765,24 +829,32 @@ TypePtr updateColumnNames(
 // Non-primitive type tree recursion function.
 template <typename T>
 TypePtr updateColumnNames(const TypePtr& fileType, const TypePtr& tableType) {
-  auto fileRowType = std::dynamic_pointer_cast<const T>(fileType);
-  auto tableRowType = std::dynamic_pointer_cast<const T>(tableType);
+  const auto fileRowType = std::dynamic_pointer_cast<const T>(fileType);
+  const auto tableRowType = std::dynamic_pointer_cast<const T>(tableType);
 
-  std::vector<std::string> newFileFieldNames{fileRowType->names()};
-  std::vector<TypePtr> newFileFieldTypes{fileRowType->children()};
+  std::vector<std::string> newFileFieldNames;
+  newFileFieldNames.reserve(fileRowType->size());
+  std::vector<TypePtr> newFileFieldTypes;
+  newFileFieldTypes.reserve(fileRowType->size());
 
   for (auto childIdx = 0; childIdx < tableRowType->size(); ++childIdx) {
     if (childIdx >= fileRowType->size()) {
       break;
     }
 
-    newFileFieldTypes[childIdx] = updateColumnNames(
+    newFileFieldTypes.push_back(updateColumnNames(
         fileRowType->childAt(childIdx),
         tableRowType->childAt(childIdx),
         fileRowType->nameOf(childIdx),
-        tableRowType->nameOf(childIdx));
+        tableRowType->nameOf(childIdx)));
 
-    newFileFieldNames[childIdx] = tableRowType->nameOf(childIdx);
+    newFileFieldNames.push_back(tableRowType->nameOf(childIdx));
+  }
+
+  for (auto childIdx = tableRowType->size(); childIdx < fileRowType->size();
+       ++childIdx) {
+    newFileFieldTypes.push_back(fileRowType->childAt(childIdx));
+    newFileFieldNames.push_back(fileRowType->nameOf(childIdx));
   }
 
   return std::make_shared<const T>(
@@ -795,7 +867,8 @@ TypePtr updateColumnNames(
     const TypePtr& tableType,
     const std::string& fileFieldName,
     const std::string& tableFieldName) {
-  // Check type kind equality. If not equal, no point to continue down the tree.
+  // Check type kind equality. If not equal, no point to continue down the
+  // tree.
   if (fileType->kind() != tableType->kind()) {
     logTypeInequality(*fileType, *tableType, fileFieldName, tableFieldName);
     return fileType;
@@ -806,9 +879,6 @@ TypePtr updateColumnNames(
     return fileType;
   }
 
-  std::vector<std::string> fileFieldNames{fileType->size()};
-  std::vector<TypePtr> fileFieldTypes{fileType->size()};
-
   if (fileType->isRow()) {
     return updateColumnNames<RowType>(fileType, tableType);
   }
@@ -829,18 +899,17 @@ TypePtr updateColumnNames(
 } // namespace
 
 void DwrfReader::updateColumnNamesFromTableSchema() {
-  const auto& tableSchema = options_.getFileSchema();
-  const auto& fileSchema = readerBase_->getSchema();
-  auto newSchema = std::dynamic_pointer_cast<const RowType>(
-      updateColumnNames(fileSchema, tableSchema, "", ""));
-  readerBase_->setSchema(newSchema);
+  const auto& tableSchema = options_.fileSchema();
+  const auto& fileSchema = readerBase_->schema();
+  readerBase_->setSchema(std::dynamic_pointer_cast<const RowType>(
+      updateColumnNames(fileSchema, tableSchema, "", "")));
 }
 
 std::unique_ptr<StripeInformation> DwrfReader::getStripe(
     uint32_t stripeIndex) const {
-  DWIO_ENSURE_LT(
+  VELOX_CHECK_LT(
       stripeIndex, getNumberOfStripes(), "stripe index out of range");
-  auto stripeInfo = readerBase_->getFooter().stripes(stripeIndex);
+  auto stripeInfo = readerBase_->footer().stripes(stripeIndex);
 
   return std::make_unique<StripeInformationImpl>(
       stripeInfo.offset(),
@@ -852,28 +921,28 @@ std::unique_ptr<StripeInformation> DwrfReader::getStripe(
 
 std::vector<std::string> DwrfReader::getMetadataKeys() const {
   std::vector<std::string> result;
-  auto& footer = readerBase_->getFooter();
-  result.reserve(footer.metadataSize());
-  for (int32_t i = 0; i < footer.metadataSize(); ++i) {
-    result.push_back(footer.metadata(i).name());
+  auto& fileFooter = readerBase_->footer();
+  result.reserve(fileFooter.metadataSize());
+  for (int32_t i = 0; i < fileFooter.metadataSize(); ++i) {
+    result.push_back(fileFooter.metadata(i).name());
   }
   return result;
 }
 
 std::string DwrfReader::getMetadataValue(const std::string& key) const {
-  auto& footer = readerBase_->getFooter();
-  for (int32_t i = 0; i < footer.metadataSize(); ++i) {
-    if (footer.metadata(i).name() == key) {
-      return footer.metadata(i).value();
+  auto& fileFooter = readerBase_->footer();
+  for (int32_t i = 0; i < fileFooter.metadataSize(); ++i) {
+    if (fileFooter.metadata(i).name() == key) {
+      return fileFooter.metadata(i).value();
     }
   }
-  DWIO_RAISE("key not found");
+  VELOX_FAIL("key not found: {}", key);
 }
 
 bool DwrfReader::hasMetadataValue(const std::string& key) const {
-  auto& footer = readerBase_->getFooter();
-  for (int32_t i = 0; i < footer.metadataSize(); ++i) {
-    if (footer.metadata(i).name() == key) {
+  auto& fileFooter = readerBase_->footer();
+  for (int32_t i = 0; i < fileFooter.metadataSize(); ++i) {
+    if (fileFooter.metadata(i).name() == key) {
       return true;
     }
   }
@@ -931,28 +1000,28 @@ uint64_t maxStreamsForType(const TypeWrapper& type) {
 }
 
 uint64_t DwrfReader::getMemoryUse(int32_t stripeIx) {
-  ColumnSelector cs(readerBase_->getSchema());
+  ColumnSelector cs(readerBase_->schema());
   return getMemoryUse(*readerBase_, stripeIx, cs);
 }
 
 uint64_t DwrfReader::getMemoryUseByFieldId(
     const std::vector<uint64_t>& include,
     int32_t stripeIx) {
-  ColumnSelector cs(readerBase_->getSchema(), include);
+  ColumnSelector cs(readerBase_->schema(), include);
   return getMemoryUse(*readerBase_, stripeIx, cs);
 }
 
 uint64_t DwrfReader::getMemoryUseByName(
     const std::vector<std::string>& names,
     int32_t stripeIx) {
-  ColumnSelector cs(readerBase_->getSchema(), names);
+  ColumnSelector cs(readerBase_->schema(), names);
   return getMemoryUse(*readerBase_, stripeIx, cs);
 }
 
 uint64_t DwrfReader::getMemoryUseByTypeId(
     const std::vector<uint64_t>& include,
     int32_t stripeIx) {
-  ColumnSelector cs(readerBase_->getSchema(), include, true);
+  ColumnSelector cs(readerBase_->schema(), include, true);
   return getMemoryUse(*readerBase_, stripeIx, cs);
 }
 
@@ -961,27 +1030,23 @@ uint64_t DwrfReader::getMemoryUse(
     int32_t stripeIx,
     const ColumnSelector& cs) {
   uint64_t maxDataLength = 0;
-  auto& footer = readerBase.getFooter();
-  if (stripeIx >= 0 && stripeIx < footer.stripesSize()) {
-    uint64_t stripe = footer.stripes(stripeIx).dataLength();
-    if (maxDataLength < stripe) {
-      maxDataLength = stripe;
-    }
+  const auto& fileFooter = readerBase.footer();
+  if (stripeIx >= 0 && stripeIx < fileFooter.stripesSize()) {
+    const uint64_t stripeLength = fileFooter.stripes(stripeIx).dataLength();
+    maxDataLength = std::max(maxDataLength, stripeLength);
   } else {
-    for (int32_t i = 0; i < footer.stripesSize(); i++) {
-      uint64_t stripe = footer.stripes(i).dataLength();
-      if (maxDataLength < stripe) {
-        maxDataLength = stripe;
-      }
+    for (int32_t i = 0; i < fileFooter.stripesSize(); ++i) {
+      const uint64_t stripeLength = fileFooter.stripes(i).dataLength();
+      maxDataLength = std::max(maxDataLength, stripeLength);
     }
   }
 
   bool hasStringColumn = false;
-  uint64_t nSelectedStreams = 0;
-  for (int32_t i = 0; !hasStringColumn && i < footer.typesSize(); i++) {
+  uint64_t numSelectedStreams = 0;
+  for (int32_t i = 0; !hasStringColumn && i < fileFooter.typesSize(); ++i) {
     if (cs.shouldReadNode(i)) {
-      const auto type = footer.types(i);
-      nSelectedStreams += maxStreamsForType(type);
+      const auto type = fileFooter.types(i);
+      numSelectedStreams += maxStreamsForType(type);
       switch (type.kind()) {
         case TypeKind::VARCHAR:
         case TypeKind::VARBINARY: {
@@ -995,46 +1060,45 @@ uint64_t DwrfReader::getMemoryUse(
     }
   }
 
-  /* If a string column is read, use stripe datalength as a memory estimate
-   * because we don't know the dictionary size. Multiply by 2 because
-   * a string column requires two buffers:
-   * in the input stream and in the seekable input stream.
-   * If no string column is read, estimate from the number of streams.
-   */
-  uint64_t memory = hasStringColumn ? 2 * maxDataLength
-                                    : std::min(
-                                          uint64_t(maxDataLength),
-                                          nSelectedStreams *
-                                              readerBase.getBufferedInput()
-                                                  .getReadFile()
-                                                  ->getNaturalReadSize());
+  // If a string column is read, use stripe datalength as a memory estimate
+  // because we don't know the dictionary size. Multiply by 2 because a string
+  // column requires two buffers: in the input stream and in the seekable
+  // input stream. If no string column is read, estimate from the number of
+  // streams.
+  uint64_t memoryBytes = hasStringColumn
+      ? 2 * maxDataLength
+      : std::min(
+            uint64_t(maxDataLength),
+            numSelectedStreams *
+                readerBase.bufferedInput().getReadFile()->getNaturalReadSize());
 
   // Do we need even more memory to read the footer or the metadata?
-  auto footerLength = readerBase.getPostScript().footerLength();
-  if (memory < footerLength + readerBase.getDirectorySizeGuess()) {
-    memory = footerLength + readerBase.getDirectorySizeGuess();
+  const auto footerLength = readerBase.postScript().footerLength();
+  if (memoryBytes < footerLength + readerBase.footerEstimatedSize()) {
+    memoryBytes = footerLength + readerBase.footerEstimatedSize();
   }
 
   // Account for firstRowOfStripe.
-  memory += static_cast<uint64_t>(footer.stripesSize()) * sizeof(uint64_t);
+  memoryBytes +=
+      static_cast<uint64_t>(fileFooter.stripesSize()) * sizeof(uint64_t);
 
   // Decompressors need buffers for each stream
-  uint64_t decompressorMemory = 0;
-  auto compression = readerBase.getCompressionKind();
-  if (compression != common::CompressionKind_NONE) {
-    for (int32_t i = 0; i < footer.typesSize(); i++) {
+  uint64_t decompressorMemoryBytes = 0;
+  const auto compressionKind = readerBase.compressionKind();
+  if (compressionKind != common::CompressionKind_NONE) {
+    for (int32_t i = 0; i < fileFooter.typesSize(); ++i) {
       if (cs.shouldReadNode(i)) {
-        const auto type = footer.types(i);
-        decompressorMemory +=
-            maxStreamsForType(type) * readerBase.getCompressionBlockSize();
+        const auto type = fileFooter.types(i);
+        decompressorMemoryBytes +=
+            maxStreamsForType(type) * readerBase.compressionBlockSize();
       }
     }
-    if (compression == common::CompressionKind_SNAPPY) {
-      decompressorMemory *= 2; // Snappy decompressor uses a second buffer
+    if (compressionKind == common::CompressionKind_SNAPPY) {
+      decompressorMemoryBytes *= 2; // Snappy decompressor uses a second buffer
     }
   }
 
-  return memory + decompressorMemory;
+  return memoryBytes + decompressorMemoryBytes;
 }
 
 std::unique_ptr<dwio::common::RowReader> DwrfReader::createRowReader(
@@ -1045,12 +1109,12 @@ std::unique_ptr<dwio::common::RowReader> DwrfReader::createRowReader(
 std::unique_ptr<DwrfRowReader> DwrfReader::createDwrfRowReader(
     const RowReaderOptions& opts) const {
   auto rowReader = std::make_unique<DwrfRowReader>(readerBase_, opts);
-  if (opts.getEagerFirstStripeLoad()) {
+  if (opts.eagerFirstStripeLoad()) {
     // Load the first stripe on construction so that readers created in
     // background have a reader tree and can preload the first
     // stripe. Also the reader tree needs to exist in order to receive
     // adaptation from a previous reader.
-    rowReader->startNextStripe();
+    rowReader->nextRowNumber();
   }
   return rowReader;
 }
diff --git a/velox/dwio/dwrf/reader/DwrfReader.h b/velox/dwio/dwrf/reader/DwrfReader.h
index 995b01a67df8b..43a4dc5fae7b2 100644
--- a/velox/dwio/dwrf/reader/DwrfReader.h
+++ b/velox/dwio/dwrf/reader/DwrfReader.h
@@ -16,13 +16,31 @@
 
 #pragma once
 
+#include "folly/Executor.h"
 #include "folly/synchronization/Baton.h"
 #include "velox/dwio/common/ReaderFactory.h"
+#include "velox/dwio/common/UnitLoader.h"
 #include "velox/dwio/dwrf/reader/SelectiveDwrfReader.h"
 
 namespace facebook::velox::dwrf {
 
 class ColumnReader;
+class DwrfUnit;
+
+class DwrfOptions : public dwio::common::FormatSpecificOptions {
+ public:
+  void setColumnReaderFactory(
+      std::shared_ptr<ColumnReaderFactory> columnReaderFactory) {
+    columnReaderFactory_ = std::move(columnReaderFactory);
+  }
+
+  const std::shared_ptr<ColumnReaderFactory>& columnReaderFactory() const {
+    return columnReaderFactory_;
+  }
+
+ private:
+  std::shared_ptr<ColumnReaderFactory> columnReaderFactory_;
+};
 
 class DwrfRowReader : public StrideIndexProvider,
                       public StripeReaderBase,
@@ -30,7 +48,7 @@ class DwrfRowReader : public StrideIndexProvider,
  public:
   /**
    * Constructor that lets the user specify additional options.
-   * @param contents of the file
+   * @param reader contents of the file
    * @param options options for reading
    */
   DwrfRowReader(
@@ -49,41 +67,41 @@ class DwrfRowReader : public StrideIndexProvider,
     return columnSelector_;
   }
 
-  const dwio::common::RowReaderOptions& getRowReaderOptions() const {
+  const dwio::common::RowReaderOptions& rowReaderOptions() const {
     return options_;
   }
 
-  std::shared_ptr<const dwio::common::TypeWithId> getSelectedType() const {
-    if (!selectedSchema) {
-      selectedSchema = columnSelector_->buildSelected();
+  std::shared_ptr<const dwio::common::TypeWithId> selectedType() const {
+    if (!selectedSchema_) {
+      selectedSchema_ = columnSelector_->buildSelected();
     }
 
-    return selectedSchema;
+    return selectedSchema_;
   }
 
-  uint64_t getRowNumber() const {
-    return previousRow;
+  uint64_t rowNumber() const {
+    return previousRow_;
   }
 
   uint64_t seekToRow(uint64_t rowNumber);
 
   uint64_t skipRows(uint64_t numberOfRowsToSkip);
 
-  uint32_t getCurrentStripe() const {
-    return currentStripe;
+  uint32_t currentStripe() const {
+    return currentStripe_;
   }
 
   uint64_t getStrideIndex() const override {
     return strideIndex_;
   }
 
-  // Estimate the space used by the reader
+  /// Estimates the space used by the reader
   size_t estimatedReaderMemory() const;
 
-  // Estimate the row size for projected columns
+  /// Estimates the row size for projected columns
   std::optional<size_t> estimatedRowSize() const override;
 
-  // Returns number of rows read. Guaranteed to be less then or equal to size.
+  /// Returns number of rows read. Guaranteed to be less then or equal to size.
   uint64_t next(
       uint64_t size,
       VectorPtr& result,
@@ -111,73 +129,74 @@ class DwrfRowReader : public StrideIndexProvider,
     return it->second;
   }
 
-  // Creates column reader tree and may start prefetch of frequently read
-  // columns.
-  void startNextStripe();
+  void loadCurrentStripe();
 
-  void safeFetchNextStripe();
-
-  std::optional<std::vector<PrefetchUnit>> prefetchUnits() override;
+  std::optional<std::vector<PrefetchUnit>> prefetchUnits() override {
+    return std::nullopt;
+  }
 
   int64_t nextRowNumber() override;
 
   int64_t nextReadSize(uint64_t size) override;
 
+  std::shared_ptr<const RowType> type() const {
+    if (columnSelector_) {
+      return columnSelector_->getSchema();
+    }
+    return options_.requestedType();
+  }
+
  private:
-  // Represents the status of a stripe being fetched.
-  enum class FetchStatus { NOT_STARTED, IN_PROGRESS, FINISHED, ERROR };
+  bool shouldReadNode(uint32_t nodeId) const;
+
+  std::optional<size_t> estimatedRowSizeHelper(
+      const FooterWrapper& fileFooter,
+      const dwio::common::Statistics& stats,
+      uint32_t nodeId) const;
+
+  bool isEmptyFile() const {
+    return stripeCeiling_ == firstStripe_;
+  }
+
+  void checkSkipStrides(uint64_t strideSize);
+
+  void readNext(
+      uint64_t rowsToRead,
+      const dwio::common::Mutation*,
+      VectorPtr& result);
+
+  uint64_t skip(uint64_t numValues);
 
-  FetchResult fetch(uint32_t stripeIndex);
-  FetchResult prefetch(uint32_t stripeToFetch);
+  std::unique_ptr<ColumnReader>& getColumnReader();
+
+  std::unique_ptr<dwio::common::SelectiveColumnReader>&
+  getSelectiveColumnReader();
+
+  std::unique_ptr<dwio::common::UnitLoader> getUnitLoader();
+
+  const dwio::common::RowReaderOptions options_;
+  // column selector
+  const std::shared_ptr<dwio::common::ColumnSelector> columnSelector_;
+  const std::function<void(std::chrono::high_resolution_clock::duration)>
+      decodingTimeCallback_;
 
   // footer
-  std::vector<uint64_t> firstRowOfStripe;
-  mutable std::shared_ptr<const dwio::common::TypeWithId> selectedSchema;
+  std::vector<uint64_t> firstRowOfStripe_;
+  mutable std::shared_ptr<const dwio::common::TypeWithId> selectedSchema_;
 
   // reading state
-  uint64_t previousRow;
-  uint32_t firstStripe;
-  uint32_t currentStripe;
-  uint32_t lastStripe; // the stripe AFTER the last one
-  uint64_t currentRowInStripe;
-  bool newStripeReadyForRead;
-  uint64_t rowsInCurrentStripe;
+  uint64_t previousRow_;
+  uint32_t firstStripe_;
+  uint32_t currentStripe_;
+  // The the stripe AFTER the last one that should be read. e.g. if the highest
+  // stripe in the RowReader's bounds is 3, then stripeCeiling_ is 4.
+  uint32_t stripeCeiling_;
+  uint64_t currentRowInStripe_;
+  uint64_t rowsInCurrentStripe_;
   uint64_t strideIndex_;
-  std::shared_ptr<StripeDictionaryCache> stripeDictionaryCache_;
-  dwio::common::RowReaderOptions options_;
-
-  struct PrefetchedStripeState {
-    bool preloaded;
-    std::unique_ptr<ColumnReader> columnReader;
-    std::unique_ptr<dwio::common::SelectiveColumnReader> selectiveColumnReader;
-    std::shared_ptr<StripeDictionaryCache> stripeDictionaryCache;
-  };
-
-  // stripeLoadStatuses_ and prefetchedStripeStates_ will never be acquired
-  // simultaneously on the same thread.
-  // Key is stripe index
-  folly::Synchronized<folly::F14FastMap<uint32_t, PrefetchedStripeState>>
-      prefetchedStripeStates_;
-
-  // Indicates the status of load requests. The ith element in
-  // stripeLoadStatuses_ represents the status of the ith stripe.
-  folly::Synchronized<std::vector<FetchStatus>> stripeLoadStatuses_;
-
-  // Currently, seek logic relies on reloading the stripe every time the row is
-  // seeked to, even if the row was present in the already loaded stripe. This
-  // is a temporary flag to disable seek on a reader which has already
-  // prefetched, until we implement a good way to support both.
-  std::atomic<bool> prefetchHasOccurred_{false};
-
-  // Used to indicate which stripes are finished loading. If stripeLoadBatons[i]
-  // is posted, it means the ith stripe has finished loading
-  std::vector<std::unique_ptr<folly::Baton<>>> stripeLoadBatons_;
 
-  // column selector
-  std::shared_ptr<dwio::common::ColumnSelector> columnSelector_;
+  std::shared_ptr<BitSet> projectedNodes_;
 
-  std::unique_ptr<ColumnReader> columnReader_;
-  std::unique_ptr<dwio::common::SelectiveColumnReader> selectiveColumnReader_;
   const uint64_t* stridesToSkip_;
   int stridesToSkipSize_;
   // Record of strides to skip in each visited stripe. Used for diagnostics.
@@ -185,39 +204,17 @@ class DwrfRowReader : public StrideIndexProvider,
   // Number of skipped strides.
   int64_t skippedStrides_{0};
 
-  // Set to true after clearing filter caches, i.e. adding a dynamic
-  // filter. Causes filters to be re-evaluated against stride stats on
-  // next stride instead of next stripe.
+  // Set to true after clearing filter caches, i.e. adding a dynamic filter.
+  // Causes filters to be re-evaluated against stride stats on next stride
+  // instead of next stripe.
   bool recomputeStridesToSkip_{false};
 
   dwio::common::ColumnReaderStatistics columnReaderStatistics_;
 
-  // internal methods
+  std::optional<int64_t> nextRowNumber_;
 
-  std::optional<size_t> estimatedRowSizeHelper(
-      const FooterWrapper& footer,
-      const dwio::common::Statistics& stats,
-      uint32_t nodeId) const;
-
-  std::shared_ptr<const RowType> getType() const {
-    return columnSelector_->getSchema();
-  }
-
-  bool isEmptyFile() const {
-    return (lastStripe == 0);
-  }
-
-  void checkSkipStrides(uint64_t strideSize);
-
-  void readNext(
-      uint64_t rowsToRead,
-      const dwio::common::Mutation*,
-      VectorPtr& result);
-
-  void readWithRowNumber(
-      uint64_t rowsToRead,
-      const dwio::common::Mutation*,
-      VectorPtr& result);
+  std::unique_ptr<dwio::common::UnitLoader> unitLoader_;
+  DwrfUnit* currentUnit_;
 };
 
 class DwrfReader : public dwio::common::Reader {
@@ -232,15 +229,15 @@ class DwrfReader : public dwio::common::Reader {
   ~DwrfReader() override = default;
 
   common::CompressionKind getCompression() const {
-    return readerBase_->getCompressionKind();
+    return readerBase_->compressionKind();
   }
 
   WriterVersion getWriterVersion() const {
-    return readerBase_->getWriterVersion();
+    return readerBase_->writerVersion();
   }
 
   const std::string& getWriterName() const {
-    return readerBase_->getWriterName();
+    return readerBase_->writerName();
   }
 
   std::vector<std::string> getMetadataKeys() const;
@@ -250,56 +247,56 @@ class DwrfReader : public dwio::common::Reader {
   bool hasMetadataValue(const std::string& key) const;
 
   uint64_t getCompressionBlockSize() const {
-    return readerBase_->getCompressionBlockSize();
+    return readerBase_->compressionBlockSize();
   }
 
   uint32_t getNumberOfStripes() const {
-    return readerBase_->getFooter().stripesSize();
+    return readerBase_->footer().stripesSize();
   }
 
   std::vector<uint64_t> getRowsPerStripe() const {
-    return readerBase_->getRowsPerStripe();
+    return readerBase_->rowsPerStripe();
   }
   uint32_t strideSize() const {
-    return readerBase_->getFooter().rowIndexStride();
+    return readerBase_->footer().rowIndexStride();
   }
 
   std::unique_ptr<StripeInformation> getStripe(uint32_t) const;
 
   uint64_t getFileLength() const {
-    return readerBase_->getFileLength();
+    return readerBase_->fileLength();
   }
 
   std::unique_ptr<dwio::common::Statistics> getStatistics() const {
-    return readerBase_->getStatistics();
+    return readerBase_->statistics();
   }
 
   std::unique_ptr<dwio::common::ColumnStatistics> columnStatistics(
       uint32_t nodeId) const override {
-    return readerBase_->getColumnStatistics(nodeId);
+    return readerBase_->columnStatistics(nodeId);
   }
 
   const std::shared_ptr<const RowType>& rowType() const override {
-    return readerBase_->getSchema();
+    return readerBase_->schema();
   }
 
   const std::shared_ptr<const dwio::common::TypeWithId>& typeWithId()
       const override {
-    return readerBase_->getSchemaWithId();
+    return readerBase_->schemaWithId();
   }
 
   const PostScript& getPostscript() const {
-    return readerBase_->getPostScript();
+    return readerBase_->postScript();
   }
 
   const FooterWrapper& getFooter() const {
-    return readerBase_->getFooter();
+    return readerBase_->footer();
   }
 
   std::optional<uint64_t> numberOfRows() const override {
-    auto& footer = readerBase_->getFooter();
-    if (footer.hasNumberOfRows()) {
-      return footer.numberOfRows();
+    auto& fileFooter = readerBase_->footer();
+    if (fileFooter.hasNumberOfRows()) {
+      return fileFooter.numberOfRows();
     }
     return std::nullopt;
   }
@@ -331,13 +328,17 @@ class DwrfReader : public dwio::common::Reader {
 
   /**
    * Create a reader to the for the dwrf file.
-   * @param stream the stream to read
+   * @param input the stream to read
    * @param options the options for reading the file
    */
   static std::unique_ptr<DwrfReader> create(
       std::unique_ptr<dwio::common::BufferedInput> input,
       const dwio::common::ReaderOptions& options);
 
+  ReaderBase* testingReaderBase() const {
+    return readerBase_.get();
+  }
+
  private:
   // Ensures that files column names match the ones from the table schema using
   // column indices.
@@ -346,8 +347,6 @@ class DwrfReader : public dwio::common::Reader {
  private:
   std::shared_ptr<ReaderBase> readerBase_;
   const dwio::common::ReaderOptions options_;
-
-  friend class E2EEncryptionTest;
 };
 
 class DwrfReaderFactory : public dwio::common::ReaderFactory {
@@ -361,8 +360,4 @@ class DwrfReaderFactory : public dwio::common::ReaderFactory {
   }
 };
 
-void registerDwrfReaderFactory();
-
-void unregisterDwrfReaderFactory();
-
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/EncodingContext.h b/velox/dwio/dwrf/reader/EncodingContext.h
index 823d1ef7b929c..b7e4432b45b39 100644
--- a/velox/dwio/dwrf/reader/EncodingContext.h
+++ b/velox/dwio/dwrf/reader/EncodingContext.h
@@ -21,8 +21,8 @@
 
 namespace facebook::velox::dwrf {
 
-// Struct containing context for flatmap encoding.
-// Default initialization is non-flatmap context.
+/// Struct containing context for flatmap encoding.
+/// Default initialization is non-flatmap context.
 struct FlatMapContext {
  public:
   uint32_t sequence{0};
diff --git a/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp b/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
index 5b4ddfd69c917..d601e3416a2d6 100644
--- a/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
@@ -74,10 +74,10 @@ KeyPredicate<T> prepareKeyPredicate(
 
 // Helper function to perform uniqueness checks before visiting streams
 uint32_t visitUniqueStreamsOfNode(
-    const std::shared_ptr<const TypeWithId>& dataType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     StripeStreams& stripe,
     std::function<void(const StreamInformation&)> visitor) {
-  const auto dataValueType = dataType->childAt(1);
+  const auto dataValueType = fileType->childAt(1);
   folly::F14FastSet<size_t> processed;
 
   auto streams = stripe.visitStreamsOfNode(
@@ -109,24 +109,25 @@ template <typename T>
 std::vector<std::unique_ptr<KeyNode<T>>> getKeyNodesFiltered(
     const std::function<bool(const KeyValue<T>&)>& keyPredicate,
     const std::shared_ptr<const TypeWithId>& requestedType,
-    const std::shared_ptr<const TypeWithId>& dataType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     memory::MemoryPool& memoryPool,
-    FlatMapContext& flatMapContext) {
+    FlatMapContext& flatMapContext,
+    ColumnReaderFactory& factory) {
   std::vector<std::unique_ptr<KeyNode<T>>> keyNodes;
 
   auto keySelectionStats =
       facebook::velox::dwio::common::flatmap::FlatMapKeySelectionStats{};
 
   const auto requestedValueType = requestedType->childAt(1);
-  const auto dataValueType = dataType->childAt(1);
+  const auto dataValueType = fileType->childAt(1);
   folly::F14FastSet<size_t> processed;
 
   // load all sub streams
   // fetch reader, in map bitmap and key object.
   auto streams = visitUniqueStreamsOfNode(
-      dataType, stripe, [&](const StreamInformation& stream) {
+      fileType, stripe, [&](const StreamInformation& stream) {
         auto sequence = stream.getSequence();
         // No need to load shared dictionary stream here.
         if (sequence == 0 || processed.count(sequence)) {
@@ -150,11 +151,13 @@ std::vector<std::unique_ptr<KeyNode<T>>> getKeyNodesFiltered(
         // build seekable
         auto inMapDecoder = createBooleanRleDecoder(std::move(inMap), seqEk);
 
-        auto valueReader = ColumnReader::build(
+        auto valueReader = factory.build(
             requestedValueType,
             dataValueType,
             stripe,
             labels,
+            nullptr,
+            0,
             FlatMapContext{
                 .sequence = sequence,
                 .inMapDecoder = inMapDecoder.get(),
@@ -174,7 +177,7 @@ std::vector<std::unique_ptr<KeyNode<T>>> getKeyNodesFiltered(
   triggerKeySelectionNotification(flatMapContext, keySelectionStats);
 
   VLOG(1) << "[Flat-Map] Initialized a flat-map column reader for node "
-          << dataType->id() << ", keys=" << keyNodes.size()
+          << fileType->id() << ", keys=" << keyNodes.size()
           << ", streams=" << streams;
   return keyNodes;
 }
@@ -200,30 +203,39 @@ std::vector<std::unique_ptr<KeyNode<T>>> rearrangeKeyNodesAsProjectedOrder(
 
   return keyNodes;
 }
+
 } // namespace
 
 template <typename T>
 FlatMapColumnReader<T>::FlatMapColumnReader(
     const std::shared_ptr<const TypeWithId>& requestedType,
-    const std::shared_ptr<const TypeWithId>& dataType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
-    FlatMapContext flatMapContext)
-    : ColumnReader(dataType, stripe, streamLabels, std::move(flatMapContext)),
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    FlatMapContext flatMapContext,
+    ColumnReaderFactory& factory)
+    : ColumnReader(fileType, stripe, streamLabels, std::move(flatMapContext)),
       requestedType_{requestedType},
-      returnFlatVector_{stripe.getRowReaderOptions().getReturnFlatVector()} {
-  DWIO_ENSURE_EQ(nodeType_->id(), dataType->id());
+      returnFlatVector_{stripe.rowReaderOptions().returnFlatVector()},
+      executor_{executor} {
+  DWIO_ENSURE_EQ(fileType_->id(), fileType->id());
 
   const auto keyPredicate = prepareKeyPredicate<T>(requestedType, stripe);
 
   keyNodes_ = getKeyNodesFiltered<T>(
       [&keyPredicate](const auto& keyValue) { return keyPredicate(keyValue); },
       requestedType,
-      dataType,
+      fileType,
       stripe,
       streamLabels,
       memoryPool_,
-      flatMapContext_);
+      flatMapContext_,
+      factory);
+
+  parallelForOnKeyNodes_ = std::make_unique<dwio::common::ParallelFor>(
+      executor_, 0, keyNodes_.size(), decodingParallelismFactor);
 
   // sort nodes by sequence id so order of keys is fixed
   std::sort(keyNodes_.begin(), keyNodes_.end(), [](auto& a, auto& b) {
@@ -325,14 +337,17 @@ void FlatMapColumnReader<T>::next(
   std::vector<KeyNode<T>*> nodes;
   utils::BulkBitIterator<char> bulkInMapIter{};
   std::vector<const BaseVector*> nodeBatches;
+  std::vector<const BaseVector*> batches(keyNodes_.size(), nullptr);
   size_t totalChildren = 0;
   if (nonNullMaps > 0) {
-    for (auto& node : keyNodes_) {
-      // if the node has value filled into key-value batch
-      // future optimization - enable batch to be sortable on row index
-      // and below next can be updated to next(keys, values, numValues)
-      // which writes row index into batch and offsets can be generated
-      auto batch = node->load(nonNullMaps);
+    auto keyNodes_sz = keyNodes_.size();
+    nodeBatches.reserve(keyNodes_sz);
+    nodes.reserve(keyNodes_sz);
+    parallelForOnKeyNodes_->execute(
+        [&](size_t i) { batches[i] = keyNodes_[i]->load(nonNullMaps); });
+    for (size_t i = 0; i < keyNodes_sz; ++i) {
+      auto& batch = batches[i];
+      auto& node = keyNodes_[i];
       if (batch) {
         nodes.emplace_back(node.get());
         node->addToBulkInMapBitIterator(bulkInMapIter);
@@ -567,11 +582,12 @@ void KeyNode<StringView>::fillKeysVector(
 template <typename T>
 std::vector<std::unique_ptr<KeyNode<T>>> getKeyNodesForStructEncoding(
     const std::shared_ptr<const TypeWithId>& requestedType,
-    const std::shared_ptr<const TypeWithId>& dataType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
     memory::MemoryPool& memoryPool,
-    FlatMapContext& flatMapContext) {
+    FlatMapContext& flatMapContext,
+    ColumnReaderFactory& factory) {
   // `KeyNode` is ordered based on the projection. So if [3, 2, 1] is
   // projected, the vector of key node will be created [3, 2, 1].
   // If the key is not found in the stripe, the key node will be nullptr.
@@ -581,14 +597,15 @@ std::vector<std::unique_ptr<KeyNode<T>>> getKeyNodesForStructEncoding(
   auto availableKeyNodes = getKeyNodesFiltered<T>(
       [&keyPredicate](const auto& keyValue) { return keyPredicate(keyValue); },
       requestedType,
-      dataType,
+      fileType,
       stripe,
       streamLabels,
       memoryPool,
-      flatMapContext);
+      flatMapContext,
+      factory);
 
   const auto& mapColumnIdAsStruct =
-      stripe.getRowReaderOptions().getMapColumnIdAsStruct();
+      stripe.rowReaderOptions().mapColumnIdAsStruct();
   auto it = mapColumnIdAsStruct.find(requestedType->id());
   DWIO_ENSURE(it != mapColumnIdAsStruct.end());
 
@@ -598,10 +615,13 @@ std::vector<std::unique_ptr<KeyNode<T>>> getKeyNodesForStructEncoding(
 template <typename T>
 FlatMapStructEncodingColumnReader<T>::FlatMapStructEncodingColumnReader(
     const std::shared_ptr<const TypeWithId>& requestedType,
-    const std::shared_ptr<const TypeWithId>& dataType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
-    FlatMapContext flatMapContext)
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    FlatMapContext flatMapContext,
+    ColumnReaderFactory& factory)
     : ColumnReader(
           requestedType,
           stripe,
@@ -610,17 +630,24 @@ FlatMapStructEncodingColumnReader<T>::FlatMapStructEncodingColumnReader(
       requestedType_{requestedType},
       keyNodes_{getKeyNodesForStructEncoding<T>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
           memoryPool_,
-          flatMapContext_)},
+          flatMapContext_,
+          factory)},
       nullColumnReader_{std::make_unique<NullColumnReader>(
           stripe,
-          requestedType_->type()->asMap().valueType())} {
-  DWIO_ENSURE_EQ(nodeType_->id(), dataType->id());
-  DWIO_ENSURE(!keyNodes_.empty()); // "For struct encoding, keys to project must
-                                   // be configured.";
+          requestedType_->type()->asMap().valueType())},
+      executor_{executor},
+      parallelForOnKeyNodes_{
+          executor_,
+          0,
+          keyNodes_.size(),
+          decodingParallelismFactor} {
+  DWIO_ENSURE_EQ(fileType_->id(), fileType->id());
+  DWIO_ENSURE(!keyNodes_.empty()); // "For struct encoding, keys to project
+                                   // must be configured.";
 }
 
 template <typename T>
@@ -638,6 +665,24 @@ uint64_t FlatMapStructEncodingColumnReader<T>::skip(uint64_t numValues) {
   return numValues;
 }
 
+namespace {
+
+BufferPtr getBufferForCurrentThread(
+    folly::Synchronized<std::unordered_map<std::thread::id, BufferPtr>>&
+        bufferMap) {
+  const auto id = std::this_thread::get_id();
+  {
+    auto bufferMapRead = bufferMap.rlock();
+    auto mergedNullsIt = bufferMapRead->find(id);
+    if (mergedNullsIt != bufferMapRead->end()) {
+      return mergedNullsIt->second;
+    }
+  }
+  return bufferMap.wlock()->emplace(id, nullptr).first->second;
+}
+
+} // namespace
+
 template <typename T>
 void FlatMapStructEncodingColumnReader<T>::next(
     uint64_t numValues,
@@ -648,7 +693,7 @@ void FlatMapStructEncodingColumnReader<T>::next(
   if (rowVector) {
     // Track children vectors in a local variable because readNulls may reset
     // the parent vector.
-    result->resize(numValues, false);
+    rowVector->unsafeResize(numValues, false);
     children = rowVector->children();
     DWIO_ENSURE_EQ(children.size(), keyNodes_.size());
   }
@@ -670,14 +715,36 @@ void FlatMapStructEncodingColumnReader<T>::next(
     childrenPtr = &children;
   }
 
-  for (size_t i = 0; i < keyNodes_.size(); ++i) {
-    auto& node = keyNodes_[i];
-    auto& child = (*childrenPtr)[i];
-
-    if (node) {
-      node->loadAsChild(child, numValues, mergedNulls_, nonNullMaps, nullsPtr);
-    } else {
-      nullColumnReader_->next(numValues, child, nullsPtr);
+  if (executor_) {
+    auto mergedNullsBuffers =
+        folly::Synchronized<std::unordered_map<std::thread::id, BufferPtr>>();
+    parallelForOnKeyNodes_.execute([numValues,
+                                    nonNullMaps,
+                                    nullsPtr,
+                                    &mergedNullsBuffers,
+                                    this,
+                                    childrenPtr](size_t i) {
+      auto mergedNullsBuffer = getBufferForCurrentThread(mergedNullsBuffers);
+      auto& node = keyNodes_[i];
+      auto& child = (*childrenPtr)[i];
+      if (node) {
+        node->loadAsChild(
+            child, numValues, mergedNullsBuffer, nonNullMaps, nullsPtr);
+      } else {
+        nullColumnReader_->next(numValues, child, nullsPtr);
+      }
+    });
+  } else {
+    for (size_t i = 0; i < keyNodes_.size(); ++i) {
+      auto& node = keyNodes_[i];
+      auto& child = (*childrenPtr)[i];
+
+      if (node) {
+        node->loadAsChild(
+            child, numValues, mergedNulls_, nonNullMaps, nullsPtr);
+      } else {
+        nullColumnReader_->next(numValues, child, nullsPtr);
+      }
     }
   }
 
@@ -699,79 +766,106 @@ void FlatMapStructEncodingColumnReader<T>::next(
 inline bool isRequiringStructEncoding(
     const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
     const dwio::common::RowReaderOptions& rowOptions) {
-  return rowOptions.getMapColumnIdAsStruct().count(requestedType->id()) > 0;
+  return rowOptions.mapColumnIdAsStruct().count(requestedType->id()) > 0;
 }
 
 template <typename T>
 std::unique_ptr<ColumnReader> createFlatMapColumnReader(
     const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
-    FlatMapContext flatMapContext) {
-  if (isRequiringStructEncoding(requestedType, stripe.getRowReaderOptions())) {
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    FlatMapContext flatMapContext,
+    ColumnReaderFactory& factory) {
+  if (isRequiringStructEncoding(requestedType, stripe.rowReaderOptions())) {
     return std::make_unique<FlatMapStructEncodingColumnReader<T>>(
         requestedType,
-        dataType,
+        fileType,
         stripe,
         streamLabels,
-        std::move(flatMapContext));
+        executor,
+        decodingParallelismFactor,
+        std::move(flatMapContext),
+        factory);
   } else {
     return std::make_unique<FlatMapColumnReader<T>>(
         requestedType,
-        dataType,
+        fileType,
         stripe,
         streamLabels,
-        std::move(flatMapContext));
+        executor,
+        decodingParallelismFactor,
+        std::move(flatMapContext),
+        factory);
   }
 }
 
 /* static */ std::unique_ptr<ColumnReader> FlatMapColumnReaderFactory::create(
     const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     StripeStreams& stripe,
     const StreamLabels& streamLabels,
-    FlatMapContext flatMapContext) {
+    folly::Executor* executor,
+    size_t decodingParallelismFactor,
+    FlatMapContext flatMapContext,
+    ColumnReaderFactory& factory) {
   // create flat map column reader based on key type
-  const auto kind = dataType->childAt(0)->type()->kind();
+  const auto kind = fileType->childAt(0)->type()->kind();
 
   switch (kind) {
     case TypeKind::TINYINT:
       return createFlatMapColumnReader<int8_t>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
-          std::move(flatMapContext));
+          executor,
+          decodingParallelismFactor,
+          std::move(flatMapContext),
+          factory);
     case TypeKind::SMALLINT:
       return createFlatMapColumnReader<int16_t>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
-          std::move(flatMapContext));
+          executor,
+          decodingParallelismFactor,
+          std::move(flatMapContext),
+          factory);
     case TypeKind::INTEGER:
       return createFlatMapColumnReader<int32_t>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
-          std::move(flatMapContext));
+          executor,
+          decodingParallelismFactor,
+          std::move(flatMapContext),
+          factory);
     case TypeKind::BIGINT:
       return createFlatMapColumnReader<int64_t>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
-          std::move(flatMapContext));
+          executor,
+          decodingParallelismFactor,
+          std::move(flatMapContext),
+          factory);
     case TypeKind::VARBINARY:
     case TypeKind::VARCHAR:
       return createFlatMapColumnReader<StringView>(
           requestedType,
-          dataType,
+          fileType,
           stripe,
           streamLabels,
-          std::move(flatMapContext));
+          executor,
+          decodingParallelismFactor,
+          std::move(flatMapContext),
+          factory);
     default:
       DWIO_RAISE("Not supported key type: ", kind);
   }
diff --git a/velox/dwio/dwrf/reader/FlatMapColumnReader.h b/velox/dwio/dwrf/reader/FlatMapColumnReader.h
index fe15207a505eb..0c636e16f56ca 100644
--- a/velox/dwio/dwrf/reader/FlatMapColumnReader.h
+++ b/velox/dwio/dwrf/reader/FlatMapColumnReader.h
@@ -16,9 +16,11 @@
 
 #pragma once
 
+#include <folly/Executor.h>
 #include "velox/common/base/BitUtil.h"
 #include "velox/dwio/common/DataBuffer.h"
 #include "velox/dwio/common/FlatMapHelper.h"
+#include "velox/dwio/common/ParallelFor.h"
 #include "velox/dwio/common/TypeWithId.h"
 #include "velox/dwio/dwrf/reader/ColumnReader.h"
 #include "velox/dwio/dwrf/reader/ConstantColumnReader.h"
@@ -77,20 +79,20 @@ class KeyNode {
 
   // try to load numValues from current position
   // return the items loaded
-  BaseVector* FOLLY_NULLABLE load(uint64_t numValues);
+  BaseVector* load(uint64_t numValues);
 
   void loadAsChild(
       VectorPtr& vec,
       uint64_t numValues,
       BufferPtr& mergedNulls,
       uint64_t nonNullMaps,
-      const uint64_t* FOLLY_NULLABLE nulls);
+      const uint64_t* nulls);
 
-  const uint64_t* FOLLY_NULLABLE mergeNulls(
+  const uint64_t* mergeNulls(
       uint64_t numValues,
       BufferPtr& mergedNulls,
       uint64_t nonNullMaps,
-      const uint64_t* FOLLY_NULLABLE nulls);
+      const uint64_t* nulls);
 
   const uint64_t* FOLLY_NULLABLE
   getAllNulls(uint64_t numValues, BufferPtr& mergedNulls);
@@ -107,7 +109,7 @@ class KeyNode {
   void fillKeysVector(
       VectorPtr& vector,
       vector_size_t offset,
-      const StringKeyBuffer* FOLLY_NULLABLE /* unused */) {
+      const StringKeyBuffer* /* unused */) {
     // Ideally, this should be dynamic_cast, but we would like to avoid the
     // cost. We cannot make vector type template variable because for string
     // type, we will have two different vector representations
@@ -144,24 +146,31 @@ class FlatMapColumnReader : public ColumnReader {
  public:
   FlatMapColumnReader(
       const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
-      FlatMapContext flatMapContext);
+      folly::Executor* executor,
+      size_t decodingParallelismFactor,
+      FlatMapContext flatMapContext,
+      ColumnReaderFactory& factory);
   ~FlatMapColumnReader() override = default;
 
   uint64_t skip(uint64_t numValues) override;
 
-  void next(
-      uint64_t numValues,
-      VectorPtr& result,
-      const uint64_t* FOLLY_NULLABLE nulls) override;
+  void next(uint64_t numValues, VectorPtr& result, const uint64_t* nulls)
+      override;
+
+  bool isFlatMap() const override {
+    return true;
+  }
 
  private:
   const std::shared_ptr<const dwio::common::TypeWithId> requestedType_;
   std::vector<std::unique_ptr<KeyNode<T>>> keyNodes_;
   std::unique_ptr<StringKeyBuffer> stringKeyBuffer_;
   bool returnFlatVector_;
+  folly::Executor* executor_;
+  std::unique_ptr<dwio::common::ParallelFor> parallelForOnKeyNodes_;
 
   void initStringKeyBuffer() {}
 
@@ -173,23 +182,30 @@ class FlatMapStructEncodingColumnReader : public ColumnReader {
  public:
   FlatMapStructEncodingColumnReader(
       const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
-      FlatMapContext flatMapContext);
+      folly::Executor* executor,
+      size_t decodingParallelismFactor,
+      FlatMapContext flatMapContext,
+      ColumnReaderFactory& factory);
   ~FlatMapStructEncodingColumnReader() override = default;
 
   uint64_t skip(uint64_t numValues) override;
 
-  void next(
-      uint64_t numValues,
-      VectorPtr& result,
-      const uint64_t* FOLLY_NULLABLE nulls) override;
+  void next(uint64_t numValues, VectorPtr& result, const uint64_t* nulls)
+      override;
+
+  bool isFlatMap() const override {
+    return true;
+  }
 
  private:
   const std::shared_ptr<const dwio::common::TypeWithId> requestedType_;
   std::vector<std::unique_ptr<KeyNode<T>>> keyNodes_;
   std::unique_ptr<NullColumnReader> nullColumnReader_;
+  folly::Executor* executor_;
+  dwio::common::ParallelFor parallelForOnKeyNodes_;
   BufferPtr mergedNulls_;
 };
 
@@ -197,10 +213,13 @@ class FlatMapColumnReaderFactory {
  public:
   static std::unique_ptr<ColumnReader> create(
       const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
-      FlatMapContext flatMapContext);
+      folly::Executor* executor,
+      size_t decodingParallelismFactor,
+      FlatMapContext flatMapContext,
+      ColumnReaderFactory& factory);
 };
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/ReaderBase.cpp b/velox/dwio/dwrf/reader/ReaderBase.cpp
index 8248c1b95e82a..ff2b13c9dd7c8 100644
--- a/velox/dwio/dwrf/reader/ReaderBase.cpp
+++ b/velox/dwio/dwrf/reader/ReaderBase.cpp
@@ -18,13 +18,14 @@
 
 #include <fmt/format.h>
 
+#include "velox/common/process/TraceContext.h"
+#include "velox/dwio/common/Mutation.h"
 #include "velox/dwio/common/exception/Exception.h"
 
 namespace facebook::velox::dwrf {
 
 using dwio::common::ColumnStatistics;
 using dwio::common::FileFormat;
-using dwio::common::InputStream;
 using dwio::common::LogType;
 using dwio::common::Statistics;
 using dwio::common::encryption::DecrypterFactory;
@@ -34,8 +35,8 @@ using memory::MemoryPool;
 FooterStatisticsImpl::FooterStatisticsImpl(
     const ReaderBase& reader,
     const StatsContext& statsContext) {
-  auto& footer = reader.getFooter();
-  auto& handler = reader.getDecryptionHandler();
+  auto& footer = reader.footer();
+  auto& handler = reader.decryptionHandler();
   colStats_.resize(footer.statisticsSize());
   // fill in the encrypted stats
   if (handler.isEncrypted()) {
@@ -60,7 +61,8 @@ FooterStatisticsImpl::FooterStatisticsImpl(
         for (uint32_t statsIndex = 0; statsIndex < stats->statistics_size();
              ++statsIndex) {
           colStats_[node + statsIndex] = buildColumnStatisticsFromProto(
-              stats->statistics(statsIndex), statsContext);
+              ColumnStatisticsWrapper(&stats->statistics(statsIndex)),
+              statsContext);
         }
       }
     }
@@ -82,7 +84,7 @@ ReaderBase::ReaderBase(
           pool,
           std::move(input),
           nullptr,
-          dwio::common::ReaderOptions::kDefaultDirectorySizeGuess,
+          dwio::common::ReaderOptions::kDefaultFooterEstimatedSize,
           dwio::common::ReaderOptions::kDefaultFilePreloadThreshold,
           fileFormat) {}
 
@@ -90,40 +92,45 @@ ReaderBase::ReaderBase(
     MemoryPool& pool,
     std::unique_ptr<dwio::common::BufferedInput> input,
     std::shared_ptr<DecrypterFactory> decryptorFactory,
-    uint64_t directorySizeGuess,
+    uint64_t footerEstimatedSize,
     uint64_t filePreloadThreshold,
     FileFormat fileFormat,
-    bool fileColumnNamesReadAsLowerCase)
+    bool fileColumnNamesReadAsLowerCase,
+    std::shared_ptr<random::RandomSkipTracker> randomSkip,
+    std::shared_ptr<velox::common::ScanSpec> scanSpec)
     : pool_{pool},
       arena_(std::make_unique<google::protobuf::Arena>()),
       decryptorFactory_(decryptorFactory),
-      directorySizeGuess_(directorySizeGuess),
+      footerEstimatedSize_(footerEstimatedSize),
       filePreloadThreshold_(filePreloadThreshold),
-      input_(std::move(input)) {
-  // read last bytes into buffer to get PostScript
-  // If file is small, load the entire file.
+      input_(std::move(input)),
+      randomSkip_(std::move(randomSkip)),
+      scanSpec_(std::move(scanSpec)),
+      fileLength_(input_->getReadFile()->size()) {
+  process::TraceContext trace("ReaderBase::ReaderBase");
   // TODO: make a config
-  fileLength_ = input_->getReadFile()->size();
   DWIO_ENSURE(fileLength_ > 0, "ORC file is empty");
+  VELOX_CHECK_GE(fileLength_, 4, "File size too small");
 
-  auto preloadFile = fileLength_ <= filePreloadThreshold_;
-  uint64_t readSize =
-      preloadFile ? fileLength_ : std::min(fileLength_, directorySizeGuess_);
-  DWIO_ENSURE_GE(readSize, 4, "File size too small");
-
-  input_->enqueue({fileLength_ - readSize, readSize, "footer"});
-  input_->load(preloadFile ? LogType::FILE : LogType::FOOTER);
+  const auto preloadFile = fileLength_ <= filePreloadThreshold_;
+  const uint64_t readSize =
+      preloadFile ? fileLength_ : std::min(fileLength_, footerEstimatedSize_);
+  if (input_->supportSyncLoad()) {
+    input_->enqueue({fileLength_ - readSize, readSize, "footer"});
+    input_->load(preloadFile ? LogType::FILE : LogType::FOOTER);
+  }
 
   // TODO: read footer from spectrum
   {
     const void* buf;
     int32_t ignored;
     auto lastByteStream = input_->read(fileLength_ - 1, 1, LogType::FOOTER);
-    DWIO_ENSURE(lastByteStream->Next(&buf, &ignored), "failed to read");
+    const bool ret = lastByteStream->Next(&buf, &ignored);
+    VELOX_CHECK(ret, "Failed to read");
     // Make sure 'lastByteStream' is live while dereferencing 'buf'.
     psLength_ = *static_cast<const char*>(buf) & 0xff;
   }
-  DWIO_ENSURE_LE(
+  VELOX_CHECK_LE(
       psLength_ + 4, // 1 byte for post script len, 3 byte "ORC" header.
       fileLength_,
       "Corrupted file, Post script size is invalid");
@@ -138,28 +145,28 @@ ReaderBase::ReaderBase(
     postScript_ = std::make_unique<PostScript>(std::move(postScript));
   }
 
-  uint64_t footerSize = postScript_->footerLength();
-  uint64_t cacheSize =
+  const uint64_t footerSize = postScript_->footerLength();
+  const uint64_t cacheSize =
       postScript_->hasCacheSize() ? postScript_->cacheSize() : 0;
-  uint64_t tailSize = 1 + psLength_ + footerSize + cacheSize;
+  const uint64_t tailSize = 1 + psLength_ + footerSize + cacheSize;
 
   // There are cases in warehouse, where RC/text files are stored
   // in ORC partition. This causes the Reader to SIGSEGV. The following
   // checks catches most of the corrupted files (but not all).
-  DWIO_ENSURE_LT(
+  VELOX_CHECK_LT(
       footerSize, fileLength_, "Corrupted file, footer size is invalid");
-  DWIO_ENSURE_LT(
+  VELOX_CHECK_LT(
       cacheSize, fileLength_, "Corrupted file, cache size is invalid");
-  DWIO_ENSURE_LE(tailSize, fileLength_, "Corrupted file, tail size is invalid");
+  VELOX_CHECK_LE(tailSize, fileLength_, "Corrupted file, tail size is invalid");
 
-  DWIO_ENSURE(
+  VELOX_CHECK(
       (format() == DwrfFormat::kDwrf)
           ? proto::CompressionKind_IsValid(postScript_->compression())
           : proto::orc::CompressionKind_IsValid(postScript_->compression()),
       "Corrupted File, invalid compression kind ",
       postScript_->compression());
 
-  if (tailSize > readSize) {
+  if (input_->supportSyncLoad() && (tailSize > readSize)) {
     input_->enqueue({fileLength_ - tailSize, tailSize, "footer"});
     input_->load(LogType::FOOTER);
   }
@@ -184,36 +191,37 @@ ReaderBase::ReaderBase(
 
   schema_ = std::dynamic_pointer_cast<const RowType>(
       convertType(*footer_, 0, fileColumnNamesReadAsLowerCase));
-  DWIO_ENSURE_NOT_NULL(schema_, "invalid schema");
+  VELOX_CHECK_NOT_NULL(schema_, "invalid schema");
 
   // load stripe index/footer cache
   if (cacheSize > 0) {
-    DWIO_ENSURE_EQ(format(), DwrfFormat::kDwrf);
+    VELOX_CHECK_EQ(format(), DwrfFormat::kDwrf);
+    const uint64_t cacheOffset = fileLength_ - tailSize;
     if (input_->shouldPrefetchStripes()) {
       cache_ = std::make_unique<StripeMetadataCache>(
           postScript_->cacheMode(),
           *footer_,
-          input_->read(fileLength_ - tailSize, cacheSize, LogType::FOOTER));
+          input_->read(cacheOffset, cacheSize, LogType::FOOTER));
       input_->load(LogType::FOOTER);
     } else {
       auto cacheBuffer =
           std::make_shared<dwio::common::DataBuffer<char>>(pool, cacheSize);
-      input_->read(fileLength_ - tailSize, cacheSize, LogType::FOOTER)
+      input_->read(cacheOffset, cacheSize, LogType::FOOTER)
           ->readFully(cacheBuffer->data(), cacheSize);
       cache_ = std::make_unique<StripeMetadataCache>(
           postScript_->cacheMode(), *footer_, std::move(cacheBuffer));
     }
   }
   if (!cache_ && input_->shouldPrefetchStripes()) {
-    auto numStripes = getFooter().stripesSize();
+    const auto numStripes = footer().stripesSize();
     for (auto i = 0; i < numStripes; i++) {
-      const auto stripe = getFooter().stripes(i);
+      const auto stripe = footer().stripes(i);
       input_->enqueue(
           {stripe.offset() + stripe.indexLength() + stripe.dataLength(),
            stripe.footerLength(),
            "stripe_footer"});
     }
-    if (numStripes) {
+    if (numStripes > 0) {
       input_->load(LogType::FOOTER);
     }
   }
@@ -221,30 +229,30 @@ ReaderBase::ReaderBase(
   handler_ = DecryptionHandler::create(*footer_, decryptorFactory_.get());
 }
 
-std::vector<uint64_t> ReaderBase::getRowsPerStripe() const {
+std::vector<uint64_t> ReaderBase::rowsPerStripe() const {
   std::vector<uint64_t> rowsPerStripe;
-  auto numStripes = getFooter().stripesSize();
+  auto numStripes = footer().stripesSize();
   rowsPerStripe.reserve(numStripes);
   for (auto i = 0; i < numStripes; i++) {
-    rowsPerStripe.push_back(getFooter().stripes(i).numberOfRows());
+    rowsPerStripe.push_back(footer().stripes(i).numberOfRows());
   }
   return rowsPerStripe;
 }
 
-std::unique_ptr<Statistics> ReaderBase::getStatistics() const {
-  StatsContext statsContext(getWriterName(), getWriterVersion());
+std::unique_ptr<Statistics> ReaderBase::statistics() const {
+  StatsContext statsContext(writerName(), writerVersion());
   return std::make_unique<FooterStatisticsImpl>(*this, statsContext);
 }
 
-std::unique_ptr<ColumnStatistics> ReaderBase::getColumnStatistics(
+std::unique_ptr<ColumnStatistics> ReaderBase::columnStatistics(
     uint32_t index) const {
-  DWIO_ENSURE_LT(
+  VELOX_CHECK_LT(
       index,
       static_cast<uint32_t>(footer_->statisticsSize()),
       "column index out of range");
-  StatsContext statsContext(getWriterVersion());
+  StatsContext statsContext(writerVersion());
   if (!handler_->isEncrypted(index)) {
-    auto& stats = footer_->statistics(index);
+    auto stats = footer_->statistics(index);
     return buildColumnStatisticsFromProto(stats, statsContext);
   }
 
@@ -255,7 +263,7 @@ std::unique_ptr<ColumnStatistics> ReaderBase::getColumnStatistics(
 
   // if key is not loaded, return plaintext stats
   if (!decrypter.isKeyLoaded()) {
-    auto& stats = footer_->statistics(index);
+    auto stats = footer_->statistics(index);
     return buildColumnStatisticsFromProto(stats, statsContext);
   }
 
@@ -271,37 +279,51 @@ std::unique_ptr<ColumnStatistics> ReaderBase::getColumnStatistics(
   auto stats = readProtoFromString<proto::FileStatistics>(
       group.statistics(nodeIndex), &decrypter);
   return buildColumnStatisticsFromProto(
-      stats->statistics(index - root), statsContext);
+      ColumnStatisticsWrapper(&stats->statistics(index - root)), statsContext);
 }
 
 std::shared_ptr<const Type> ReaderBase::convertType(
     const FooterWrapper& footer,
     uint32_t index,
     bool fileColumnNamesReadAsLowerCase) {
-  DWIO_ENSURE_LT(
+  VELOX_CHECK_LT(
       index,
       folly::to<uint32_t>(footer.typesSize()),
       "Corrupted file, invalid types");
   const auto type = footer.types(index);
   switch (type.kind()) {
     case TypeKind::BOOLEAN:
+      return BOOLEAN();
     case TypeKind::TINYINT:
+      return TINYINT();
     case TypeKind::SMALLINT:
+      return SMALLINT();
     case TypeKind::INTEGER:
+      return INTEGER();
     case TypeKind::BIGINT:
+      if (type.format() == DwrfFormat::kOrc &&
+          type.getOrcPtr()->kind() == proto::orc::Type_Kind_DECIMAL) {
+        return DECIMAL(
+            type.getOrcPtr()->precision(), type.getOrcPtr()->scale());
+      }
+      return BIGINT();
     case TypeKind::HUGEINT:
       if (type.format() == DwrfFormat::kOrc &&
           type.getOrcPtr()->kind() == proto::orc::Type_Kind_DECIMAL) {
         return DECIMAL(
             type.getOrcPtr()->precision(), type.getOrcPtr()->scale());
       }
-      [[fallthrough]];
+      return HUGEINT();
     case TypeKind::REAL:
+      return REAL();
     case TypeKind::DOUBLE:
+      return DOUBLE();
     case TypeKind::VARCHAR:
+      return VARCHAR();
     case TypeKind::VARBINARY:
+      return VARBINARY();
     case TypeKind::TIMESTAMP:
-      return createScalarType(type.kind());
+      return TIMESTAMP();
     case TypeKind::ARRAY:
       return ARRAY(convertType(
           footer, type.subtypes(0), fileColumnNamesReadAsLowerCase));
@@ -311,25 +333,25 @@ std::shared_ptr<const Type> ReaderBase::convertType(
           convertType(
               footer, type.subtypes(1), fileColumnNamesReadAsLowerCase));
     case TypeKind::ROW: {
-      std::vector<std::shared_ptr<const Type>> tl;
-      tl.reserve(type.subtypesSize());
+      std::vector<std::shared_ptr<const Type>> types;
+      types.reserve(type.subtypesSize());
       std::vector<std::string> names;
       names.reserve(type.subtypesSize());
       for (int32_t i = 0; i < type.subtypesSize(); ++i) {
-        auto child = convertType(
+        auto childType = convertType(
             footer, type.subtypes(i), fileColumnNamesReadAsLowerCase);
         auto childName = type.fieldNames(i);
         if (fileColumnNamesReadAsLowerCase) {
           folly::toLowerAscii(childName);
         }
         names.push_back(std::move(childName));
-        tl.push_back(std::move(child));
+        types.push_back(std::move(childType));
       }
 
       // NOTE: There are empty dwrf files in data warehouse that has empty
       // struct as the root type. So the assumption that struct has at least one
       // child doesn't hold.
-      return ROW(std::move(names), std::move(tl));
+      return ROW(std::move(names), std::move(types));
     }
     default:
       DWIO_RAISE("Unknown type kind");
diff --git a/velox/dwio/dwrf/reader/ReaderBase.h b/velox/dwio/dwrf/reader/ReaderBase.h
index b841262a074f9..34287d3fcd716 100644
--- a/velox/dwio/dwrf/reader/ReaderBase.h
+++ b/velox/dwio/dwrf/reader/ReaderBase.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/base/RandomUtil.h"
 #include "velox/dwio/common/BufferedInput.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/SeekableInputStream.h"
@@ -59,25 +60,27 @@ class FooterStatisticsImpl : public dwio::common::Statistics {
 
 class ReaderBase {
  public:
-  // create reader base from buffered input
+  /// Creates reader base from buffered input.
   ReaderBase(
       memory::MemoryPool& pool,
       std::unique_ptr<dwio::common::BufferedInput> input,
       std::shared_ptr<dwio::common::encryption::DecrypterFactory>
           decryptorFactory = nullptr,
-      uint64_t directorySizeGuess =
-          dwio::common::ReaderOptions::kDefaultDirectorySizeGuess,
+      uint64_t footerEstimatedSize =
+          dwio::common::ReaderOptions::kDefaultFooterEstimatedSize,
       uint64_t filePreloadThreshold =
           dwio::common::ReaderOptions::kDefaultFilePreloadThreshold,
       dwio::common::FileFormat fileFormat = dwio::common::FileFormat::DWRF,
-      bool fileColumnNamesReadAsLowerCase = false);
+      bool fileColumnNamesReadAsLowerCase = false,
+      std::shared_ptr<random::RandomSkipTracker> randomSkip = nullptr,
+      std::shared_ptr<velox::common::ScanSpec> scanSpec = nullptr);
 
   ReaderBase(
       memory::MemoryPool& pool,
       std::unique_ptr<dwio::common::BufferedInput> input,
       dwio::common::FileFormat fileFormat);
 
-  // create reader base from metadata
+  /// Creates reader base from metadata.
   ReaderBase(
       memory::MemoryPool& pool,
       std::unique_ptr<dwio::common::BufferedInput> input,
@@ -91,89 +94,91 @@ class ReaderBase {
         cache_{std::move(cache)},
         handler_{std::move(handler)},
         input_{std::move(input)},
+        fileLength_{0},
         schema_{
             std::dynamic_pointer_cast<const RowType>(convertType(*footer_))},
-        fileLength_{0},
         psLength_{0} {
-    DWIO_ENSURE(footer_->getDwrfPtr()->GetArena());
-    DWIO_ENSURE_NOT_NULL(schema_, "invalid schema");
+    VELOX_CHECK_NOT_NULL(schema_, "invalid schema");
     if (!handler_) {
       handler_ = encryption::DecryptionHandler::create(*footer);
     }
   }
 
   // for testing
-  explicit ReaderBase(memory::MemoryPool& pool) : pool_{pool} {}
+  explicit ReaderBase(memory::MemoryPool& pool) : pool_{pool}, fileLength_{0} {}
 
   virtual ~ReaderBase() = default;
 
-  memory::MemoryPool& getMemoryPool() const {
+  memory::MemoryPool& memoryPool() const {
     return pool_;
   }
 
-  const PostScript& getPostScript() const {
+  const PostScript& postScript() const {
     return *postScript_;
   }
 
-  const FooterWrapper& getFooter() const {
+  const FooterWrapper& footer() const {
     return *footer_;
   }
 
-  const RowTypePtr& getSchema() const {
+  const RowTypePtr& schema() const {
     return schema_;
   }
 
-  void setSchema(const RowTypePtr& newSchema) {
-    schema_ = newSchema;
+  void setSchema(RowTypePtr newSchema) {
+    schema_ = std::move(newSchema);
   }
 
-  const std::shared_ptr<const dwio::common::TypeWithId>& getSchemaWithId()
-      const {
+  const std::shared_ptr<const dwio::common::TypeWithId>& schemaWithId() const {
     if (!schemaWithId_) {
-      schemaWithId_ = dwio::common::TypeWithId::create(schema_);
+      if (scanSpec_) {
+        schemaWithId_ = dwio::common::TypeWithId::create(schema_, *scanSpec_);
+      } else {
+        schemaWithId_ = dwio::common::TypeWithId::create(schema_);
+      }
     }
     return schemaWithId_;
   }
 
-  dwio::common::BufferedInput& getBufferedInput() const {
+  dwio::common::BufferedInput& bufferedInput() const {
     return *input_;
   }
 
-  const std::unique_ptr<StripeMetadataCache>& getMetadataCache() const {
+  const std::unique_ptr<StripeMetadataCache>& metadataCache() const {
     return cache_;
   }
 
-  const encryption::DecryptionHandler& getDecryptionHandler() const {
+  const encryption::DecryptionHandler& decryptionHandler() const {
     return *handler_;
   }
 
-  uint64_t getDirectorySizeGuess() const {
-    return directorySizeGuess_;
+  uint64_t footerEstimatedSize() const {
+    return footerEstimatedSize_;
   }
 
-  uint64_t getFileLength() const {
+  uint64_t fileLength() const {
     return fileLength_;
   }
 
-  std::vector<uint64_t> getRowsPerStripe() const;
+  std::vector<uint64_t> rowsPerStripe() const;
 
-  uint64_t getPostScriptLength() const {
+  uint64_t postScriptLength() const {
     return psLength_;
   }
 
-  uint64_t getCompressionBlockSize() const {
+  uint64_t compressionBlockSize() const {
     return postScript_->hasCompressionBlockSize()
         ? postScript_->compressionBlockSize()
         : common::DEFAULT_COMPRESSION_BLOCK_SIZE;
   }
 
-  common::CompressionKind getCompressionKind() const {
+  common::CompressionKind compressionKind() const {
     return postScript_->hasCompressionBlockSize()
         ? postScript_->compression()
         : common::CompressionKind::CompressionKind_NONE;
   }
 
-  WriterVersion getWriterVersion() const {
+  WriterVersion writerVersion() const {
     if (!postScript_->hasWriterVersion()) {
       return WriterVersion::ORIGINAL;
     }
@@ -183,7 +188,7 @@ class ReaderBase {
         : WriterVersion::FUTURE;
   }
 
-  const std::string& getWriterName() const {
+  const std::string& writerName() const {
     for (int32_t index = 0; index < footer_->metadataSize(); ++index) {
       auto entry = footer_->metadata(index);
       if (entry.name() == WRITER_NAME_KEY) {
@@ -195,9 +200,9 @@ class ReaderBase {
     return kEmpty;
   }
 
-  std::unique_ptr<dwio::common::Statistics> getStatistics() const;
+  std::unique_ptr<dwio::common::Statistics> statistics() const;
 
-  std::unique_ptr<dwio::common::ColumnStatistics> getColumnStatistics(
+  std::unique_ptr<dwio::common::ColumnStatistics> columnStatistics(
       uint32_t index) const;
 
   std::unique_ptr<dwio::common::SeekableInputStream> createDecompressedStream(
@@ -205,9 +210,9 @@ class ReaderBase {
       const std::string& streamDebugInfo,
       const dwio::common::encryption::Decrypter* decrypter = nullptr) const {
     return createDecompressor(
-        getCompressionKind(),
+        compressionKind(),
         std::move(compressed),
-        getCompressionBlockSize(),
+        compressionBlockSize(),
         pool_,
         streamDebugInfo,
         decrypter);
@@ -231,6 +236,10 @@ class ReaderBase {
     return postScript_->format();
   }
 
+  const std::shared_ptr<random::RandomSkipTracker>& randomSkip() const {
+    return randomSkip_;
+  }
+
  private:
   static std::shared_ptr<const Type> convertType(
       const FooterWrapper& footer,
@@ -245,16 +254,19 @@ class ReaderBase {
   // Keeps factory alive for possibly async prefetch.
   std::shared_ptr<dwio::common::encryption::DecrypterFactory> decryptorFactory_;
   std::unique_ptr<encryption::DecryptionHandler> handler_;
-  const uint64_t directorySizeGuess_{
-      dwio::common::ReaderOptions::kDefaultDirectorySizeGuess};
+  const uint64_t footerEstimatedSize_{
+      dwio::common::ReaderOptions::kDefaultFooterEstimatedSize};
   const uint64_t filePreloadThreshold_{
       dwio::common::ReaderOptions::kDefaultFilePreloadThreshold};
 
-  std::unique_ptr<dwio::common::BufferedInput> input_;
+  const std::unique_ptr<dwio::common::BufferedInput> input_;
+  const std::shared_ptr<random::RandomSkipTracker> randomSkip_;
+  const std::shared_ptr<velox::common::ScanSpec> scanSpec_;
+  const uint64_t fileLength_;
+
   RowTypePtr schema_;
   // Lazily populated
   mutable std::shared_ptr<const dwio::common::TypeWithId> schemaWithId_;
-  uint64_t fileLength_;
   uint64_t psLength_;
 };
 
diff --git a/velox/dwio/dwrf/reader/SelectiveByteRleColumnReader.h b/velox/dwio/dwrf/reader/SelectiveByteRleColumnReader.h
index 8f6c62ba302bf..c2eefd0edccbd 100644
--- a/velox/dwio/dwrf/reader/SelectiveByteRleColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveByteRleColumnReader.h
@@ -26,17 +26,18 @@ class SelectiveByteRleColumnReader
   using ValueType = int8_t;
 
   SelectiveByteRleColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      std::shared_ptr<const dwio::common::TypeWithId> dataType,
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec,
       bool isBool)
       : dwio::common::SelectiveByteRleColumnReader(
-            requestedType->type(),
+            requestedType,
+            std::move(fileType),
             params,
-            scanSpec,
-            std::move(dataType)) {
-    EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
+            scanSpec) {
+    const EncodingKey encodingKey{
+        fileType_->id(), params.flatMapContext().sequence};
     auto& stripe = params.stripeStreams();
     if (isBool) {
       boolRle_ = createBooleanRleDecoder(
@@ -77,14 +78,16 @@ class SelectiveByteRleColumnReader
     return numValues;
   }
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override {
-    readCommon<SelectiveByteRleColumnReader>(offset, rows, incomingNulls);
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override {
+    readCommon<SelectiveByteRleColumnReader, true>(offset, rows, incomingNulls);
     readOffset_ += rows.back() + 1;
   }
 
   template <typename ColumnVisitor>
-  void readWithVisitor(RowSet rows, ColumnVisitor visitor);
+  void readWithVisitor(const RowSet& rows, ColumnVisitor visitor);
 
   std::unique_ptr<ByteRleDecoder> byteRle_;
   std::unique_ptr<BooleanRleDecoder> boolRle_;
@@ -92,9 +95,8 @@ class SelectiveByteRleColumnReader
 
 template <typename ColumnVisitor>
 void SelectiveByteRleColumnReader::readWithVisitor(
-    RowSet rows,
+    const RowSet& rows,
     ColumnVisitor visitor) {
-  vector_size_t numRows = rows.back() + 1;
   if (boolRle_) {
     if (nullsInReadRange_) {
       boolRle_->readWithVisitor<true>(
diff --git a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
index 9c417235a86b7..32b73b4e93871 100644
--- a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
@@ -20,10 +20,10 @@ namespace facebook::velox::dwrf {
 
 template <typename DataT>
 SelectiveDecimalColumnReader<DataT>::SelectiveDecimalColumnReader(
-    const std::shared_ptr<const TypeWithId>& nodeType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec)
-    : SelectiveColumnReader(nodeType->type(), params, scanSpec, nodeType) {
+    : SelectiveColumnReader(fileType->type(), fileType, params, scanSpec) {
   EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
   if constexpr (std::is_same_v<DataT, std::int64_t>) {
@@ -43,7 +43,7 @@ SelectiveDecimalColumnReader<DataT>::SelectiveDecimalColumnReader(
   scaleDecoder_ = createRleDecoder</*isSigned*/ true>(
       stripe.getStream(secondary, params.streamLabels().label(), true),
       version_,
-      memoryPool_,
+      *memoryPool_,
       stripe.getUseVInts(secondary),
       LONG_BYTE_SIZE);
 }
@@ -86,7 +86,7 @@ void SelectiveDecimalColumnReader<DataT>::readHelper(RowSet rows) {
   }
 
   // copy scales into scaleBuffer_
-  ensureCapacity<int64_t>(scaleBuffer_, numValues_, &memoryPool_);
+  ensureCapacity<int64_t>(scaleBuffer_, numValues_, memoryPool_);
   scaleBuffer_->setSize(numValues_ * sizeof(int64_t));
   memcpy(
       scaleBuffer_->asMutable<char>(),
@@ -109,9 +109,10 @@ void SelectiveDecimalColumnReader<DataT>::readHelper(RowSet rows) {
 template <typename DataT>
 void SelectiveDecimalColumnReader<DataT>::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   VELOX_CHECK(!scanSpec_->filter());
+  VELOX_CHECK(!scanSpec_->valueHook());
   prepareRead<int64_t>(offset, rows, incomingNulls);
   bool isDense = rows.back() == rows.size() - 1;
   if (isDense) {
@@ -123,7 +124,7 @@ void SelectiveDecimalColumnReader<DataT>::read(
 
 template <typename DataT>
 void SelectiveDecimalColumnReader<DataT>::getValues(
-    RowSet rows,
+    const RowSet& rows,
     VectorPtr* result) {
   auto nullsPtr =
       resultNulls() ? resultNulls()->template as<uint64_t>() : nullptr;
diff --git a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
index b2e96ea42efbb..53790d9ce2e66 100644
--- a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
@@ -29,16 +29,24 @@ template <typename DataT>
 class SelectiveDecimalColumnReader : public SelectiveColumnReader {
  public:
   SelectiveDecimalColumnReader(
-      const std::shared_ptr<const TypeWithId>& nodeType,
+      const std::shared_ptr<const TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
+  bool hasBulkPath() const override {
+    // Only ORC uses RLEv2 encoding. Currently, ORC decimal data does not
+    // support fastpath reads. When reading RLEv2-encoded decimal data
+    // with null, the query will fail.
+    return version_ != velox::dwrf::RleVersion_2;
+  }
+
   void seekToRowGroup(uint32_t index) override;
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* nulls) override;
+  void read(vector_size_t offset, const RowSet& rows, const uint64_t* nulls)
+      override;
 
-  void getValues(RowSet rows, VectorPtr* result) override;
+  void getValues(const RowSet& rows, VectorPtr* result) override;
 
  private:
   template <bool kDense>
diff --git a/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp b/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
index 53db1aad7f9f8..c2f05507545a7 100644
--- a/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
@@ -34,117 +34,121 @@ namespace facebook::velox::dwrf {
 using namespace facebook::velox::dwio::common;
 
 std::unique_ptr<SelectiveColumnReader> buildIntegerReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     uint32_t numBytes,
     common::ScanSpec& scanSpec) {
-  EncodingKey ek{dataType->id(), params.flatMapContext().sequence};
+  const EncodingKey encodingKey{
+      fileType->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
-  switch (static_cast<int64_t>(stripe.getEncoding(ek).kind())) {
+  const auto encodingKind =
+      static_cast<int64_t>(stripe.getEncoding(encodingKey).kind());
+  switch (encodingKind) {
     case proto::ColumnEncoding_Kind_DICTIONARY:
     case proto::ColumnEncoding_Kind_DICTIONARY_V2:
       return std::make_unique<SelectiveIntegerDictionaryColumnReader>(
-          requestedType, dataType, params, scanSpec, numBytes);
+          requestedType, fileType, params, scanSpec, numBytes);
     case proto::ColumnEncoding_Kind_DIRECT:
     case proto::ColumnEncoding_Kind_DIRECT_V2:
       return std::make_unique<SelectiveIntegerDirectColumnReader>(
-          requestedType, dataType, params, numBytes, scanSpec);
+          requestedType, fileType, params, numBytes, scanSpec);
     default:
-      DWIO_RAISE("buildReader unhandled integer encoding");
+      VELOX_FAIL("buildReader unhandled integer encoding: {}", encodingKind);
   }
 }
 
 // static
 std::unique_ptr<SelectiveColumnReader> SelectiveDwrfReader::build(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec,
     bool isRoot) {
-  DWIO_ENSURE(
-      !isRoot || dataType->type()->kind() == TypeKind::ROW,
+  VELOX_CHECK(
+      !isRoot || fileType->type()->kind() == TypeKind::ROW,
       "The root object can only be a row.");
+
   dwio::common::typeutils::checkTypeCompatibility(
-      *dataType->type(), *requestedType->type());
-  EncodingKey ek{dataType->id(), params.flatMapContext().sequence};
+      *fileType->type(), *requestedType);
+  EncodingKey ek{fileType->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
-  switch (dataType->type()->kind()) {
+  switch (fileType->type()->kind()) {
     case TypeKind::INTEGER:
       return buildIntegerReader(
-          requestedType, dataType, params, INT_BYTE_SIZE, scanSpec);
+          requestedType, fileType, params, INT_BYTE_SIZE, scanSpec);
     case TypeKind::BIGINT:
-      if (dataType->type()->isDecimal()) {
+      if (fileType->type()->isDecimal()) {
         return std::make_unique<SelectiveDecimalColumnReader<int64_t>>(
-            requestedType, params, scanSpec);
+            fileType, params, scanSpec);
       } else {
         return buildIntegerReader(
-            requestedType, dataType, params, LONG_BYTE_SIZE, scanSpec);
+            requestedType, fileType, params, LONG_BYTE_SIZE, scanSpec);
       }
     case TypeKind::SMALLINT:
       return buildIntegerReader(
-          requestedType, dataType, params, SHORT_BYTE_SIZE, scanSpec);
+          requestedType, fileType, params, SHORT_BYTE_SIZE, scanSpec);
     case TypeKind::ARRAY:
       return std::make_unique<SelectiveListColumnReader>(
-          requestedType, dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
     case TypeKind::MAP:
       if (stripe.getEncoding(ek).kind() ==
           proto::ColumnEncoding_Kind_MAP_FLAT) {
         return createSelectiveFlatMapColumnReader(
-            requestedType, dataType, params, scanSpec);
+            requestedType, fileType, params, scanSpec);
       }
       return std::make_unique<SelectiveMapColumnReader>(
-          requestedType, dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
     case TypeKind::REAL:
-      if (requestedType->type()->kind() == TypeKind::REAL) {
+      if (requestedType->kind() == TypeKind::REAL) {
         return std::make_unique<
             SelectiveFloatingPointColumnReader<float, float>>(
-            requestedType->type(), dataType, params, scanSpec);
+            requestedType, fileType, params, scanSpec);
       } else {
         return std::make_unique<
             SelectiveFloatingPointColumnReader<float, double>>(
-            requestedType->type(), dataType, params, scanSpec);
+            requestedType, fileType, params, scanSpec);
       }
     case TypeKind::DOUBLE:
       return std::make_unique<
           SelectiveFloatingPointColumnReader<double, double>>(
-          requestedType->type(), dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
     case TypeKind::ROW:
       return std::make_unique<SelectiveStructColumnReader>(
-          requestedType, dataType, params, scanSpec, isRoot);
+          requestedType, fileType, params, scanSpec, isRoot);
     case TypeKind::BOOLEAN:
       return std::make_unique<SelectiveByteRleColumnReader>(
-          requestedType, dataType, params, scanSpec, true);
+          requestedType, fileType, params, scanSpec, true);
     case TypeKind::TINYINT:
       return std::make_unique<SelectiveByteRleColumnReader>(
-          requestedType, dataType, params, scanSpec, false);
+          requestedType, fileType, params, scanSpec, false);
     case TypeKind::VARBINARY:
     case TypeKind::VARCHAR:
       switch (static_cast<int64_t>(stripe.getEncoding(ek).kind())) {
         case proto::ColumnEncoding_Kind_DIRECT:
         case proto::ColumnEncoding_Kind_DIRECT_V2:
           return std::make_unique<SelectiveStringDirectColumnReader>(
-              dataType, params, scanSpec);
+              fileType, params, scanSpec);
         case proto::ColumnEncoding_Kind_DICTIONARY:
         case proto::ColumnEncoding_Kind_DICTIONARY_V2:
           return std::make_unique<SelectiveStringDictionaryColumnReader>(
-              dataType, params, scanSpec);
+              fileType, params, scanSpec);
         default:
           DWIO_RAISE("buildReader string unknown encoding");
       }
     case TypeKind::TIMESTAMP:
       return std::make_unique<SelectiveTimestampColumnReader>(
-          dataType, params, scanSpec);
+          fileType, params, scanSpec);
     case TypeKind::HUGEINT:
-      if (dataType->type()->isDecimal()) {
+      if (fileType->type()->isDecimal()) {
         return std::make_unique<SelectiveDecimalColumnReader<int128_t>>(
-            requestedType, params, scanSpec);
+            fileType, params, scanSpec);
       }
       [[fallthrough]];
     default:
-      DWIO_RAISE(
+      VELOX_FAIL(
           "buildReader unhandled type: " +
-          mapTypeKindToName(dataType->type()->kind()));
+          mapTypeKindToName(fileType->type()->kind()));
   }
 }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveDwrfReader.h b/velox/dwio/dwrf/reader/SelectiveDwrfReader.h
index a4c793ed87003..2f6bc6834c456 100644
--- a/velox/dwio/dwrf/reader/SelectiveDwrfReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveDwrfReader.h
@@ -22,29 +22,29 @@
 
 namespace facebook::velox::dwrf {
 
-// Wrapper for static functions for making DWRF readers
+/// Wrapper for static functions for making DWRF readers
 class SelectiveDwrfReader {
  public:
   static std::unique_ptr<dwio::common::SelectiveColumnReader> build(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec,
       bool isRoot = false);
 
-  // Compatibility wrapper for tests. Takes the components of DwrfParams as
-  // separate.
+  /// Compatibility wrapper for tests. Takes the components of DwrfParams as
+  /// separate.
   static std::unique_ptr<dwio::common::SelectiveColumnReader> build(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       dwio::common::ColumnReaderStatistics& stats,
-      common::ScanSpec* FOLLY_NONNULL scanSpec,
+      common::ScanSpec* scanSpec,
       FlatMapContext flatMapContext = {},
       bool isRoot = false) {
     auto params = DwrfParams(stripe, streamLabels, stats, flatMapContext);
-    return build(requestedType, dataType, params, *scanSpec, isRoot);
+    return build(requestedType, fileType, params, *scanSpec, isRoot);
   }
 };
 
@@ -55,8 +55,8 @@ class SelectiveColumnReaderFactory : public ColumnReaderFactory {
       : scanSpec_(scanSpec) {}
 
   std::unique_ptr<dwio::common::SelectiveColumnReader> buildSelective(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       StripeStreams& stripe,
       const StreamLabels& streamLabels,
       dwio::common::ColumnReaderStatistics& stats,
@@ -64,7 +64,7 @@ class SelectiveColumnReaderFactory : public ColumnReaderFactory {
     auto params =
         DwrfParams(stripe, streamLabels, stats, std::move(flatMapContext));
     auto reader =
-        SelectiveDwrfReader::build(requestedType, dataType, params, *scanSpec_);
+        SelectiveDwrfReader::build(requestedType, fileType, params, *scanSpec_);
     reader->setIsTopLevel();
     return reader;
   }
diff --git a/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
index ec55ec1690f08..35fea227cf1b3 100644
--- a/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
@@ -22,8 +22,6 @@
 
 namespace facebook::velox::dwrf {
 
-bool noFastPath = false;
-
 namespace {
 
 template <typename T>
@@ -47,15 +45,6 @@ std::string toString(const T& x) {
   }
 }
 
-template <typename T>
-dwio::common::flatmap::KeyPredicate<T> prepareKeyPredicate(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    StripeStreams& stripe) {
-  auto& cs = stripe.getColumnSelector();
-  const auto expr = cs.getNode(requestedType->id())->getNode().expression;
-  return dwio::common::flatmap::prepareKeyPredicate<T>(expr);
-}
-
 // Represent a branch of a value node in a flat map.  Represent a keyed value
 // node.
 template <typename T>
@@ -78,8 +67,8 @@ struct KeyNode {
 
 template <typename T>
 std::vector<KeyNode<T>> getKeyNodes(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec,
     bool asStruct) {
@@ -89,32 +78,31 @@ std::vector<KeyNode<T>> getKeyNodes(
   std::unordered_set<size_t> processed;
 
   auto& requestedValueType = requestedType->childAt(1);
-  auto& dataValueType = dataType->childAt(1);
+  auto& dataValueType = fileType->childAt(1);
   auto& stripe = params.stripeStreams();
-  auto keyPredicate = prepareKeyPredicate<T>(requestedType, stripe);
-
-  std::shared_ptr<common::ScanSpec> keysSpec;
-  std::shared_ptr<common::ScanSpec> valuesSpec;
-  if (!asStruct) {
-    if (auto keys = scanSpec.childByName(common::ScanSpec::kMapKeysFieldName)) {
-      keysSpec = scanSpec.removeChild(keys);
-    }
-    if (auto values =
-            scanSpec.childByName(common::ScanSpec::kMapValuesFieldName)) {
-      VELOX_CHECK(!values->hasFilter());
-      valuesSpec = scanSpec.removeChild(values);
-    }
-  }
 
+  common::ScanSpec* keysSpec = nullptr;
+  common::ScanSpec* valuesSpec = nullptr;
   std::unordered_map<KeyValue<T>, common::ScanSpec*, KeyValueHash<T>>
       childSpecs;
-  if (asStruct) {
+  if (!asStruct) {
+    keysSpec = scanSpec.getOrCreateChild(common::ScanSpec::kMapKeysFieldName);
+    valuesSpec =
+        scanSpec.getOrCreateChild(common::ScanSpec::kMapValuesFieldName);
+    VELOX_CHECK(!valuesSpec->hasFilter());
+    keysSpec->setProjectOut(true);
+    keysSpec->setExtractValues(true);
+    valuesSpec->setProjectOut(true);
+    valuesSpec->setExtractValues(true);
+  } else {
     for (auto& c : scanSpec.children()) {
+      T key;
       if constexpr (std::is_same_v<T, StringView>) {
-        childSpecs[KeyValue<T>(StringView(c->fieldName()))] = c.get();
+        key = StringView(c->fieldName());
       } else {
-        childSpecs[KeyValue<T>(c->subscript())] = c.get();
+        key = folly::to<T>(c->fieldName());
       }
+      childSpecs[KeyValue<T>(key)] = c.get();
     }
   }
 
@@ -131,10 +119,6 @@ std::vector<KeyNode<T>> getKeyNodes(
         EncodingKey seqEk(dataValueType->id(), sequence);
         const auto& keyInfo = stripe.getEncoding(seqEk).key();
         auto key = extractKey<T>(keyInfo);
-        // Check if we have key filter passed through read schema.
-        if (!keyPredicate(key)) {
-          return;
-        }
         common::ScanSpec* childSpec;
         if (auto it = childSpecs.find(key);
             it != childSpecs.end() && !it->second->isConstant()) {
@@ -147,14 +131,7 @@ std::vector<KeyNode<T>> getKeyNodes(
               !common::applyFilter(*keysSpec->filter(), key.get())) {
             return; // Subfield pruning
           }
-          childSpec =
-              scanSpec.getOrCreateChild(common::Subfield(toString(key.get())));
-          childSpec->setProjectOut(true);
-          childSpec->setExtractValues(true);
-          if (valuesSpec) {
-            *childSpec = *valuesSpec;
-          }
-          childSpecs[key] = childSpec;
+          childSpecs[key] = childSpec = valuesSpec;
         }
         auto labels = params.streamLabels().append(toString(key.get()));
         auto inMap = stripe.getStream(
@@ -176,9 +153,14 @@ std::vector<KeyNode<T>> getKeyNodes(
       });
 
   VLOG(1) << "[Flat-Map] Initialized a flat-map column reader for node "
-          << dataType->id() << ", keys=" << keyNodes.size()
+          << fileType->id() << ", keys=" << keyNodes.size()
           << ", streams=" << streams;
 
+  if (!asStruct) {
+    std::sort(keyNodes.begin(), keyNodes.end(), [](auto& x, auto& y) {
+      return x.sequence < y.sequence;
+    });
+  }
   return keyNodes;
 }
 
@@ -186,18 +168,17 @@ template <typename T>
 class SelectiveFlatMapAsStructReader : public SelectiveStructColumnReaderBase {
  public:
   SelectiveFlatMapAsStructReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
-      common::ScanSpec& scanSpec,
-      const std::vector<std::string>& /*keys*/)
+      common::ScanSpec& scanSpec)
       : SelectiveStructColumnReaderBase(
             requestedType,
-            dataType,
+            fileType,
             params,
             scanSpec),
         keyNodes_(
-            getKeyNodes<T>(requestedType, dataType, params, scanSpec, true)) {
+            getKeyNodes<T>(requestedType, fileType, params, scanSpec, true)) {
     VELOX_CHECK(
         !keyNodes_.empty(),
         "For struct encoding, keys to project must be configured");
@@ -216,498 +197,47 @@ template <typename T>
 class SelectiveFlatMapReader : public SelectiveStructColumnReaderBase {
  public:
   SelectiveFlatMapReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec)
       : SelectiveStructColumnReaderBase(
             requestedType,
-            dataType,
+            fileType,
             params,
             scanSpec),
-        // Copy the scan spec because we need to remove the children.
-        structScanSpec_(scanSpec) {
-    scanSpec_ = &structScanSpec_;
-    keyNodes_ =
-        getKeyNodes<T>(requestedType, dataType, params, structScanSpec_, false);
-    std::sort(keyNodes_.begin(), keyNodes_.end(), [](auto& x, auto& y) {
-      return x.sequence < y.sequence;
-    });
-    childValues_.resize(keyNodes_.size());
-    copyRanges_.resize(keyNodes_.size());
-    children_.resize(keyNodes_.size());
-    for (int i = 0; i < keyNodes_.size(); ++i) {
-      children_[i] = keyNodes_[i].reader.get();
-    }
-    if (auto type = requestedType_->type()->childAt(1); type->isRow()) {
-      for (auto& vec : childValues_) {
-        vec = BaseVector::create(type, 0, &memoryPool_);
-      }
-    }
-  }
-
-  bool useBulkPath() const override {
-    return false;
+        flatMap_(
+            *this,
+            getKeyNodes<T>(requestedType, fileType, params, scanSpec, false)) {}
+
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override {
+    flatMap_.read(offset, rows, incomingNulls);
   }
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override {
-    numReads_ = scanSpec_->newRead();
-    prepareRead<char>(offset, rows, incomingNulls);
-    VELOX_DCHECK(!hasMutation());
-    auto activeRows = rows;
-    auto* mapNulls =
-        nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
-    if (scanSpec_->filter()) {
-      auto kind = scanSpec_->filter()->kind();
-      VELOX_CHECK(
-          kind == common::FilterKind::kIsNull ||
-          kind == common::FilterKind::kIsNotNull);
-      filterNulls<int32_t>(rows, kind == common::FilterKind::kIsNull, false);
-      if (outputRows_.empty()) {
-        for (auto* reader : children_) {
-          reader->addParentNulls(offset, mapNulls, rows);
-        }
-        return;
-      }
-      activeRows = outputRows_;
-    }
-    for (auto* reader : children_) {
-      advanceFieldReader(reader, offset);
-      reader->read(offset, activeRows, mapNulls);
-      reader->addParentNulls(offset, mapNulls, rows);
-    }
-    lazyVectorReadOffset_ = offset;
-    readOffset_ = offset + rows.back() + 1;
-  }
-
-  void getValues(RowSet rows, VectorPtr* result) override {
-    for (int k = 0; k < children_.size(); ++k) {
-      children_[k]->getValues(rows, &childValues_[k]);
-      copyRanges_[k].clear();
-    }
-    auto offsets =
-        AlignedBuffer::allocate<vector_size_t>(rows.size(), &memoryPool_);
-    auto sizes =
-        AlignedBuffer::allocate<vector_size_t>(rows.size(), &memoryPool_);
-    auto* nulls =
-        nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
-
-    if (!noFastPath && fastPath(offsets, sizes, rows, nulls, result)) {
-      return;
-    }
-    auto* rawOffsets = offsets->template asMutable<vector_size_t>();
-    auto* rawSizes = sizes->template asMutable<vector_size_t>();
-    vector_size_t totalSize = 0;
-    for (vector_size_t i = 0; i < rows.size(); ++i) {
-      if (nulls && bits::isBitNull(nulls, rows[i])) {
-        rawSizes[i] = 0;
-
-        if (!returnReaderNulls_) {
-          bits::setNull(rawResultNulls_, i);
-        }
-
-        anyNulls_ = true;
-
-        continue;
-      }
-      int currentRowSize = 0;
-      for (int k = 0; k < children_.size(); ++k) {
-        auto& data = static_cast<const DwrfData&>(children_[k]->formatData());
-        auto* inMap = data.inMap();
-        if (inMap && bits::isBitNull(inMap, rows[i])) {
-          continue;
-        }
-        copyRanges_[k].push_back({
-            .sourceIndex = i,
-            .targetIndex = totalSize + currentRowSize,
-            .count = 1,
-        });
-        ++currentRowSize;
-      }
-      rawOffsets[i] = totalSize;
-      rawSizes[i] = currentRowSize;
-      totalSize += currentRowSize;
-    }
-    auto& mapType = requestedType_->type()->asMap();
-    VectorPtr keys =
-        BaseVector::create(mapType.keyType(), totalSize, &memoryPool_);
-    VectorPtr values =
-        BaseVector::create(mapType.valueType(), totalSize, &memoryPool_);
-    auto* flatKeys = keys->asFlatVector<T>();
-    T* rawKeys = flatKeys->mutableRawValues();
-    [[maybe_unused]] size_t strKeySize;
-    [[maybe_unused]] char* rawStrKeyBuffer;
-    if constexpr (std::is_same_v<T, StringView>) {
-      strKeySize = 0;
-      for (int k = 0; k < children_.size(); ++k) {
-        if (!keyNodes_[k].key.get().isInline()) {
-          strKeySize += keyNodes_[k].key.get().size();
-        }
-      }
-      if (strKeySize > 0) {
-        auto buf = AlignedBuffer::allocate<char>(strKeySize, &memoryPool_);
-        rawStrKeyBuffer = buf->template asMutable<char>();
-        flatKeys->addStringBuffer(buf);
-        strKeySize = 0;
-        for (int k = 0; k < children_.size(); ++k) {
-          auto& s = keyNodes_[k].key.get();
-          if (!s.isInline()) {
-            memcpy(&rawStrKeyBuffer[strKeySize], s.data(), s.size());
-            strKeySize += s.size();
-          }
-        }
-        strKeySize = 0;
-      }
-    }
-    for (int k = 0; k < children_.size(); ++k) {
-      [[maybe_unused]] StringView strKey;
-      if constexpr (std::is_same_v<T, StringView>) {
-        strKey = keyNodes_[k].key.get();
-        if (!strKey.isInline()) {
-          strKey = {
-              &rawStrKeyBuffer[strKeySize],
-              static_cast<int32_t>(strKey.size())};
-          strKeySize += strKey.size();
-        }
-      }
-      for (auto& r : copyRanges_[k]) {
-        if constexpr (std::is_same_v<T, StringView>) {
-          rawKeys[r.targetIndex] = strKey;
-        } else {
-          rawKeys[r.targetIndex] = keyNodes_[k].key.get();
-        }
-      }
-      values->copyRanges(childValues_[k].get(), copyRanges_[k]);
-    }
-    *result = std::make_shared<MapVector>(
-        &memoryPool_,
-        requestedType_->type(),
-        resultNulls(),
-        rows.size(),
-        std::move(offsets),
-        std::move(sizes),
-        std::move(keys),
-        std::move(values));
+  void getValues(const RowSet& rows, VectorPtr* result) override {
+    flatMap_.getValues(rows, result);
   }
 
  private:
-  // Sets the bits for present and selected positions in 'rowColumnBits_' for
-  // 'columnIdx' for the 64 rows selected by the inMap and selected bitmaps.
-  // 'baseRow' is the number of selectd rows below the range covered by 'inMap'
-  // and 'selected'
-  void setRowBits(
-      uint64_t inMap,
-      uint64_t selected,
-      int32_t baseRow,
-      int32_t columnIdx) {
-    auto pitch = children_.size();
-    auto rowColumns = rowColumnBits_.data();
-    auto selectedPresent = selected & inMap;
-    while (selectedPresent) {
-      int32_t row = __builtin_ctzll(selectedPresent);
-      auto nthRow = __builtin_popcountll(selected & bits::lowMask(row));
-      bits::setBit(rowColumns, (nthRow + baseRow) * pitch + columnIdx, true);
-      selectedPresent &= selectedPresent - 1;
-    }
-  }
-
-  // Returns the count of selected rows that have a value in inMap. Sets the
-  // corresponding bits in 'rowColumnBits_'.
-  int32_t countInMap(
-      const uint64_t* inMap,
-      const uint64_t* selected,
-      int32_t numRows,
-      int32_t columnIdx) {
-    int32_t numSelected = 0;
-    int32_t count = 0;
-    bits::forEachWord(
-        0,
-        numRows,
-        [&](int32_t idx, uint64_t mask) {
-          count += __builtin_popcountll(inMap[idx] & selected[idx] & mask);
-          setRowBits(inMap[idx], selected[idx] & mask, numSelected, columnIdx);
-          numSelected += __builtin_popcountll(selected[idx] & mask);
-        },
-        [&](int32_t idx) {
-          count += __builtin_popcountll(inMap[idx] & selected[idx]);
-          setRowBits(inMap[idx], selected[idx], numSelected, columnIdx);
-          numSelected += __builtin_popcountll(selected[idx]);
-        });
-    return count;
-  }
-
-  template <TypeKind kind>
-  void fillValues(
-      const BufferPtr& offsets,
-      const BufferPtr& sizes,
-      const uint64_t* mapNulls,
-      RowSet rows,
-      int32_t totalChildValues,
-      T* rawKeys) {
-    using V = typename TypeTraits<kind>::NativeType;
-    auto rawOffsets = offsets->asMutable<int32_t>();
-    auto rawSizes = sizes->asMutable<int32_t>();
-    int32_t pitch = children_.size();
-    auto values = AlignedBuffer::allocate<V>(totalChildValues, &memoryPool_);
-    auto rawValues = values->template asMutable<V>();
-    BufferPtr valueNulls;
-    uint64_t* valueRawNulls = nullptr;
-    if (nullsInChildValues_) {
-      valueNulls = AlignedBuffer::allocate<bool>(
-          totalChildValues, &memoryPool_, bits::kNotNull);
-      valueRawNulls = valueNulls->asMutable<uint64_t>();
-    }
-    bool mayHaveDict = !childIndices_.empty();
-    int32_t startBit = 0;
-    int32_t fill = 0;
-    for (int32_t rowIndex = 0; rowIndex < rows.size(); ++rowIndex) {
-      int32_t row = rows[rowIndex];
-      if (mapNulls && bits::isBitNull(mapNulls, row)) {
-        rawSizes[rowIndex] = 0;
-        rawOffsets[rowIndex] = 0;
-        if (!returnReaderNulls_) {
-          if (!rawResultNulls_) {
-            mutableNulls(rows.size());
-          }
-          bits::setNull(rawResultNulls_, rowIndex);
-          anyNulls_ = true;
-        }
-        // A row which is null for the whole map will only have not presents in
-        // inMap.
-        startBit += pitch;
-        continue;
-      }
-      rawOffsets[rowIndex] = fill;
-      bits::forEachSetBit(
-          rowColumnBits_.data(),
-          startBit,
-          startBit + pitch,
-          [&](int32_t index) {
-            auto column = index - startBit;
-            rawKeys[fill] = keyValues_[column];
-            if (childRawNulls_[column] &&
-                bits::isBitNull(childRawNulls_[column], rowIndex)) {
-              bits::setNull(valueRawNulls, fill);
-            } else {
-              auto valueIndex = rowIndex;
-              if (mayHaveDict && childIndices_[column]) {
-                valueIndex = childIndices_[column][rowIndex];
-              }
-              rawValues[fill] = reinterpret_cast<const V*>(
-                  childRawValues_[column])[valueIndex];
-            }
-            ++fill;
-          });
-      rawSizes[rowIndex] = fill - rawOffsets[rowIndex];
-      startBit += pitch;
-    }
-    VELOX_CHECK_EQ(fill, totalChildValues);
-    std::vector<BufferPtr> allStrings;
-    if constexpr (std::is_same_v<V, StringView>) {
-      for (auto i = 0; i < childValues_.size(); ++i) {
-        std::vector<BufferPtr> strings = vectorStrings(*childValues_[i]);
-        allStrings.insert(allStrings.end(), strings.begin(), strings.end());
-      }
-    }
-
-    valueVector_ = std::make_shared<FlatVector<V>>(
-        &memoryPool_,
-        requestedType_->type()->childAt(1),
-        std::move(valueNulls),
-        totalChildValues,
-        std::move(values),
-        std::move(allStrings));
-  }
-
-  static std::vector<BufferPtr> vectorStrings(BaseVector& vector) {
-    if (vector.encoding() == VectorEncoding::Simple::CONSTANT) {
-      auto buffer =
-          vector.asUnchecked<ConstantVector<StringView>>()->getStringBuffer();
-      if (!buffer) {
-        return {};
-      }
-      return {buffer};
-    } else if (vector.encoding() == VectorEncoding::Simple::FLAT) {
-      return vector.asUnchecked<FlatVector<StringView>>()->stringBuffers();
-    } else if (vector.encoding() == VectorEncoding::Simple::DICTIONARY) {
-      return vector.valueVector()
-          ->asUnchecked<FlatVector<StringView>>()
-          ->stringBuffers();
-    } else {
-      VELOX_FAIL("String value is is neither flat, dictionary  nor constant");
-    }
-  }
-
-  bool fastPath(
-      BufferPtr& offsets,
-      BufferPtr& sizes,
-      RowSet rows,
-      const uint64_t* nulls,
-      VectorPtr* result) {
-    auto& valueType = requestedType_->type()->childAt(1);
-    auto valueKind = valueType->kind();
-    if (valueKind == TypeKind::MAP || valueKind == TypeKind::ROW ||
-        valueKind == TypeKind::ARRAY) {
-      return false;
-    }
-    initKeyValues();
-    assert(!children_.empty());
-    childRawNulls_.resize(children_.size());
-    childRawValues_.resize(children_.size());
-    inMap_.resize(children_.size());
-    if (!childIndices_.empty()) {
-      std::fill(childIndices_.begin(), childIndices_.end(), nullptr);
-    }
-    SelectivityVector selectedInMap(rows.back() + 1, false);
-    for (auto row : rows) {
-      selectedInMap.setValid(row, true);
-    }
-    int32_t totalChildValues = 0;
-    rowColumnBits_.resize(bits::nwords(rows.size() * children_.size()));
-    std::fill(rowColumnBits_.begin(), rowColumnBits_.end(), 0);
-    nullsInChildValues_ = false;
-    for (auto i = 0; i < children_.size(); ++i) {
-      auto& data = static_cast<const DwrfData&>(children_[i]->formatData());
-      inMap_[i] = data.inMap();
-      auto& child = childValues_[i];
-      childRawNulls_[i] = child->rawNulls();
-      if (childRawNulls_[i]) {
-        nullsInChildValues_ = true;
-      }
-      if (child->encoding() == VectorEncoding::Simple::DICTIONARY) {
-        childIndices_.resize(children_.size());
-        childIndices_[i] = child->wrapInfo()->template as<int32_t>();
-        childRawValues_[i] = child->valueVector()->valuesAsVoid();
-      } else if (child->encoding() == VectorEncoding::Simple::FLAT) {
-        childRawValues_[i] = childValues_[i]->valuesAsVoid();
-      } else if (child->encoding() == VectorEncoding::Simple::CONSTANT) {
-        if (zeros_.size() < rows.size()) {
-          zeros_.resize(rows.size());
-        }
-        childRawValues_[i] = child->valuesAsVoid();
-        if (childValues_[i]->isNullAt(0)) {
-          // There are at least rows worth of zero words, so this can serve as
-          // an all null bitmap.
-          childRawNulls_[i] = reinterpret_cast<const uint64_t*>(zeros_.data());
-        } else {
-          childRawNulls_[i] = nullptr;
-        }
-        childIndices_.resize(children_.size());
-        // Every null is redirected to row 0, which is valuesAsVoid of constant
-        // vector.
-        childIndices_[i] = zeros_.data();
-      } else {
-        VELOX_FAIL(
-            "Flat map columns must be flat or single level dictionaries");
-      }
-      totalChildValues += countInMap(
-          inMap_[i], selectedInMap.asRange().bits(), selectedInMap.size(), i);
-    }
-    BufferPtr keyBuffer =
-        AlignedBuffer::allocate<T>(totalChildValues, &memoryPool_);
-    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-        fillValues,
-        valueKind,
-        offsets,
-        sizes,
-        nulls,
-        rows,
-        totalChildValues,
-        keyBuffer->template asMutable<T>());
-
-    std::vector<BufferPtr> keyStrings;
-    if constexpr (std::is_same_v<T, StringView>) {
-      keyStrings.push_back(keyStrings_);
-    }
-    auto keyVector = std::make_shared<FlatVector<T>>(
-        &memoryPool_,
-        requestedType_->type()->childAt(0),
-        BufferPtr(nullptr),
-        totalChildValues,
-        std::move(keyBuffer),
-        std::move(keyStrings));
-    *result = std::make_shared<MapVector>(
-        &memoryPool_,
-        requestedType_->type(),
-        resultNulls(),
-        rows.size(),
-        std::move(offsets),
-        std::move(sizes),
-        std::move(keyVector),
-        std::move(valueVector_));
-    return true;
-  }
-
-  void initKeyValues() {
-    if (!keyValues_.empty()) {
-      return;
-    }
-    assert(!children_.empty());
-    keyValues_.resize(children_.size());
-    if constexpr (std::is_same_v<T, StringView>) {
-      int32_t strKeySize = 0;
-      for (int k = 0; k < children_.size(); ++k) {
-        if (!keyNodes_[k].key.get().isInline()) {
-          strKeySize += keyNodes_[k].key.get().size();
-        }
-      }
-      char* rawStrKeyBuffer = nullptr;
-      if (strKeySize > 0) {
-        keyStrings_ = AlignedBuffer::allocate<char>(strKeySize, &memoryPool_);
-        rawStrKeyBuffer = keyStrings_->template asMutable<char>();
-        strKeySize = 0;
-      }
-      for (int k = 0; k < children_.size(); ++k) {
-        auto& s = keyNodes_[k].key.get();
-        if (!s.isInline()) {
-          memcpy(&rawStrKeyBuffer[strKeySize], s.data(), s.size());
-          *reinterpret_cast<StringView*>(&keyValues_[k]) =
-              StringView(&rawStrKeyBuffer[strKeySize], s.size());
-          strKeySize += s.size();
-        } else {
-          keyValues_[k] = s;
-        }
-      }
-    } else {
-      for (auto i = 0; i < children_.size(); ++i) {
-        keyValues_[i] = keyNodes_[i].key.get();
-      }
-    }
-  }
-
-  common::ScanSpec structScanSpec_;
-  std::vector<KeyNode<T>> keyNodes_;
-  std::vector<VectorPtr> childValues_;
-  std::vector<std::vector<BaseVector::CopyRange>> copyRanges_;
-  std::vector<const uint64_t*> inMap_;
-  std::vector<const uint64_t*> childRawNulls_;
-  // if a child is dictionary encoded, these are indices of non-null values.
-  std::vector<const int32_t*> childIndices_;
-  std::vector<const void*> childRawValues_;
-  std::vector<uint64_t> rowColumnBits_;
-  std::vector<T> keyValues_;
-  BufferPtr keyStrings_;
-  bool nullsInChildValues_{false};
-  VectorPtr valueVector_;
-  std::vector<int32_t> zeros_;
+  dwio::common::SelectiveFlatMapColumnReaderHelper<T, KeyNode<T>, DwrfData>
+      flatMap_;
 };
 
 template <typename T>
 std::unique_ptr<dwio::common::SelectiveColumnReader> createReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec) {
-  auto& mapColumnIdAsStruct =
-      params.stripeStreams().getRowReaderOptions().getMapColumnIdAsStruct();
-  auto it = mapColumnIdAsStruct.find(requestedType->id());
-  if (it != mapColumnIdAsStruct.end()) {
+  if (scanSpec.isFlatMapAsStruct()) {
     return std::make_unique<SelectiveFlatMapAsStructReader<T>>(
-        requestedType, dataType, params, scanSpec, it->second);
+        requestedType, fileType, params, scanSpec);
   } else {
     return std::make_unique<SelectiveFlatMapReader<T>>(
-        requestedType, dataType, params, scanSpec);
+        requestedType, fileType, params, scanSpec);
   }
 }
 
@@ -715,24 +245,24 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> createReader(
 
 std::unique_ptr<dwio::common::SelectiveColumnReader>
 createSelectiveFlatMapColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec) {
-  auto kind = dataType->childAt(0)->type()->kind();
+  auto kind = fileType->childAt(0)->type()->kind();
   switch (kind) {
     case TypeKind::TINYINT:
-      return createReader<int8_t>(requestedType, dataType, params, scanSpec);
+      return createReader<int8_t>(requestedType, fileType, params, scanSpec);
     case TypeKind::SMALLINT:
-      return createReader<int16_t>(requestedType, dataType, params, scanSpec);
+      return createReader<int16_t>(requestedType, fileType, params, scanSpec);
     case TypeKind::INTEGER:
-      return createReader<int32_t>(requestedType, dataType, params, scanSpec);
+      return createReader<int32_t>(requestedType, fileType, params, scanSpec);
     case TypeKind::BIGINT:
-      return createReader<int64_t>(requestedType, dataType, params, scanSpec);
+      return createReader<int64_t>(requestedType, fileType, params, scanSpec);
     case TypeKind::VARBINARY:
     case TypeKind::VARCHAR:
       return createReader<StringView>(
-          requestedType, dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
     default:
       VELOX_UNSUPPORTED("Not supported key type: {}", kind);
   }
diff --git a/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.h b/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.h
index d85fc72646889..9a3c3898927da 100644
--- a/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.h
@@ -23,8 +23,8 @@ namespace facebook::velox::dwrf {
 
 std::unique_ptr<dwio::common::SelectiveColumnReader>
 createSelectiveFlatMapColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams&,
     common::ScanSpec&);
 
diff --git a/velox/dwio/dwrf/reader/SelectiveFloatingPointColumnReader.h b/velox/dwio/dwrf/reader/SelectiveFloatingPointColumnReader.h
index 57d78f77f8959..4f4b78f2c7689 100644
--- a/velox/dwio/dwrf/reader/SelectiveFloatingPointColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveFloatingPointColumnReader.h
@@ -21,19 +21,19 @@
 
 namespace facebook::velox::dwrf {
 
-template <typename TData, typename TRequested>
+template <typename TFile, typename TRequested>
 class SelectiveFloatingPointColumnReader
     : public dwio::common::
-          SelectiveFloatingPointColumnReader<TData, TRequested> {
+          SelectiveFloatingPointColumnReader<TFile, TRequested> {
  public:
   using ValueType = TRequested;
 
   using base =
-      dwio::common::SelectiveFloatingPointColumnReader<TData, TRequested>;
+      dwio::common::SelectiveFloatingPointColumnReader<TFile, TRequested>;
 
   SelectiveFloatingPointColumnReader(
       const TypePtr& requestedType,
-      std::shared_ptr<const dwio::common::TypeWithId> dataType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
@@ -46,29 +46,31 @@ class SelectiveFloatingPointColumnReader
 
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override {
-    using T = SelectiveFloatingPointColumnReader<TData, TRequested>;
-    this->template readCommon<T>(offset, rows, incomingNulls);
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override {
+    using T = SelectiveFloatingPointColumnReader<TFile, TRequested>;
+    this->template readCommon<T, true>(offset, rows, incomingNulls);
     this->readOffset_ += rows.back() + 1;
   }
 
   template <typename TVisitor>
-  void readWithVisitor(RowSet rows, TVisitor visitor);
+  void readWithVisitor(const RowSet& rows, TVisitor visitor);
 
-  FloatingPointDecoder<TData, TRequested> decoder_;
+  FloatingPointDecoder<TFile, TRequested> decoder_;
 };
 
-template <typename TData, typename TRequested>
-SelectiveFloatingPointColumnReader<TData, TRequested>::
+template <typename TFile, typename TRequested>
+SelectiveFloatingPointColumnReader<TFile, TRequested>::
     SelectiveFloatingPointColumnReader(
         const TypePtr& requestedType,
-        std::shared_ptr<const dwio::common::TypeWithId> dataType,
+        std::shared_ptr<const dwio::common::TypeWithId> fileType,
         DwrfParams& params,
         common::ScanSpec& scanSpec)
-    : dwio::common::SelectiveFloatingPointColumnReader<TData, TRequested>(
+    : dwio::common::SelectiveFloatingPointColumnReader<TFile, TRequested>(
           requestedType,
-          std::move(dataType),
+          std::move(fileType),
           params,
           scanSpec),
       decoder_(params.stripeStreams().getStream(
@@ -77,18 +79,18 @@ SelectiveFloatingPointColumnReader<TData, TRequested>::
           params.streamLabels().label(),
           true)) {}
 
-template <typename TData, typename TRequested>
-uint64_t SelectiveFloatingPointColumnReader<TData, TRequested>::skip(
+template <typename TFile, typename TRequested>
+uint64_t SelectiveFloatingPointColumnReader<TFile, TRequested>::skip(
     uint64_t numValues) {
   numValues = this->formatData_->skipNulls(numValues);
   decoder_.skip(numValues);
   return numValues;
 }
 
-template <typename TData, typename TRequested>
+template <typename TFile, typename TRequested>
 template <typename TVisitor>
-void SelectiveFloatingPointColumnReader<TData, TRequested>::readWithVisitor(
-    RowSet rows,
+void SelectiveFloatingPointColumnReader<TFile, TRequested>::readWithVisitor(
+    const RowSet& /*rows*/,
     TVisitor visitor) {
   if (this->nullsInReadRange_) {
     decoder_.template readWithVisitor<true, TVisitor>(
diff --git a/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.cpp
index 3f7edaa47456a..c740e76832536 100644
--- a/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.cpp
@@ -22,31 +22,32 @@ namespace facebook::velox::dwrf {
 using namespace dwio::common;
 
 SelectiveIntegerDictionaryColumnReader::SelectiveIntegerDictionaryColumnReader(
-    const std::shared_ptr<const TypeWithId>& requestedType,
-    std::shared_ptr<const TypeWithId> dataType,
+    const TypePtr& requestedType,
+    std::shared_ptr<const TypeWithId> fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec,
     uint32_t numBytes)
     : SelectiveIntegerColumnReader(
-          requestedType->type(),
+          requestedType,
           params,
           scanSpec,
-          std::move(dataType)) {
-  EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
+          std::move(fileType)) {
+  const EncodingKey encodingKey{
+      fileType_->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
-  auto encoding = stripe.getEncoding(encodingKey);
+  const auto encoding = stripe.getEncoding(encodingKey);
   scanState_.dictionary.numValues = encoding.dictionarysize();
   rleVersion_ = convertRleVersion(encoding.kind());
-  auto data = encodingKey.forKind(proto::Stream_Kind_DATA);
-  bool dataVInts = stripe.getUseVInts(data);
-  dataReader_ = createRleDecoder</* isSigned = */ false>(
-      stripe.getStream(data, params.streamLabels().label(), true),
+  const auto si = encodingKey.forKind(proto::Stream_Kind_DATA);
+  const bool dataVInts = stripe.getUseVInts(si);
+  dataReader_ = createRleDecoder</*isSigned=*/false>(
+      stripe.getStream(si, params.streamLabels().label(), true),
       rleVersion_,
-      memoryPool_,
+      *memoryPool_,
       dataVInts,
       numBytes);
 
-  // make a lazy dictionary initializer
+  // Makes a lazy dictionary initializer
   dictInit_ = stripe.getIntDictionaryInitializerForNode(
       encodingKey, numBytes, params.streamLabels(), numBytes);
 
@@ -72,7 +73,7 @@ uint64_t SelectiveIntegerDictionaryColumnReader::skip(uint64_t numValues) {
 
 void SelectiveIntegerDictionaryColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   VELOX_WIDTH_DISPATCH(
       sizeOfIntKind(fileType_->type()->kind()),
@@ -80,19 +81,19 @@ void SelectiveIntegerDictionaryColumnReader::read(
       offset,
       rows,
       incomingNulls);
-  auto end = rows.back() + 1;
+  const auto end = rows.back() + 1;
   const auto* rawNulls =
       nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
 
-  // read the stream of booleans indicating whether a given data entry
-  // is an offset or a literal value.
+  // Read the stream of booleans indicating whether a given data entry is an
+  // offset or a literal value.
   if (inDictionaryReader_) {
-    bool isBulk = useBulkPath();
-    int32_t numFlags = (isBulk && nullsInReadRange_)
+    const bool isBulk = useBulkPath();
+    const int32_t numFlags = (isBulk && nullsInReadRange_)
         ? bits::countNonNulls(nullsInReadRange_->as<uint64_t>(), 0, end)
         : end;
     dwio::common::ensureCapacity<uint64_t>(
-        scanState_.inDictionary, bits::nwords(numFlags), &memoryPool_);
+        scanState_.inDictionary, bits::nwords(numFlags), memoryPool_);
     // The in dict buffer may have changed. If no change in
     // dictionary, the raw state will not be updated elsewhere.
     scanState_.rawState.inDictionary = scanState_.inDictionary->as<uint64_t>();
@@ -105,7 +106,7 @@ void SelectiveIntegerDictionaryColumnReader::read(
 
   // lazy load dictionary only when it's needed
   ensureInitialized();
-  readCommon<SelectiveIntegerDictionaryColumnReader>(rows);
+  readCommon<SelectiveIntegerDictionaryColumnReader, true>(rows);
 
   readOffset_ += rows.back() + 1;
 }
@@ -115,9 +116,9 @@ void SelectiveIntegerDictionaryColumnReader::ensureInitialized() {
     return;
   }
 
-  Timer timer;
+  ClockTimer timer{initTimeClocks_};
   scanState_.dictionary.values = dictInit_();
-  if (scanSpec_->hasFilter()) {
+  if (DictionaryValues::hasFilter(scanSpec_->filter())) {
     // Make sure there is a cache even for an empty dictionary because of asan
     // failure when preparing a gather with all lanes masked out.
     scanState_.filterCache.resize(
@@ -127,9 +128,8 @@ void SelectiveIntegerDictionaryColumnReader::ensureInitialized() {
         FilterResult::kUnknown,
         scanState_.filterCache.size());
   }
-  initialized_ = true;
-  initTimeClocks_ = timer.elapsedClocks();
   scanState_.updateRawState();
+  initialized_ = true;
 }
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.h b/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.h
index 7e194c24fb8be..9683bbe8a86e2 100644
--- a/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveIntegerDictionaryColumnReader.h
@@ -28,8 +28,8 @@ class SelectiveIntegerDictionaryColumnReader
   using ValueType = int64_t;
 
   SelectiveIntegerDictionaryColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      std::shared_ptr<const dwio::common::TypeWithId> dataType,
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec,
       uint32_t numBytes);
@@ -42,24 +42,24 @@ class SelectiveIntegerDictionaryColumnReader
     }
 
     dataReader_->seekToRowGroup(positionsProvider);
-
     VELOX_CHECK(!positionsProvider.hasNext());
   }
 
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override;
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
   template <typename ColumnVisitor>
-  void readWithVisitor(RowSet rows, ColumnVisitor visitor);
+  void readWithVisitor(const RowSet& rows, ColumnVisitor visitor);
 
  private:
   void ensureInitialized();
 
   std::unique_ptr<ByteRleDecoder> inDictionaryReader_;
-  std::unique_ptr<dwio::common::IntDecoder</* isSigned = */ false>> dataReader_;
-  std::unique_ptr<dwio::common::IntDecoder</* isSigned = */ true>> dictReader_;
+  std::unique_ptr<dwio::common::IntDecoder</*isSigned=*/false>> dataReader_;
   std::function<BufferPtr()> dictInit_;
   RleVersion rleVersion_;
   bool initialized_{false};
@@ -67,7 +67,7 @@ class SelectiveIntegerDictionaryColumnReader
 
 template <typename ColumnVisitor>
 void SelectiveIntegerDictionaryColumnReader::readWithVisitor(
-    RowSet rows,
+    const RowSet& /*rows*/,
     ColumnVisitor visitor) {
   auto dictVisitor = visitor.toDictionaryColumnVisitor();
   if (rleVersion_ == RleVersion_1) {
diff --git a/velox/dwio/dwrf/reader/SelectiveIntegerDirectColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveIntegerDirectColumnReader.cpp
index 57dc53090953f..a434dfa5cd19f 100644
--- a/velox/dwio/dwrf/reader/SelectiveIntegerDirectColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveIntegerDirectColumnReader.cpp
@@ -20,13 +20,13 @@ namespace facebook::velox::dwrf {
 
 uint64_t SelectiveIntegerDirectColumnReader::skip(uint64_t numValues) {
   numValues = SelectiveColumnReader::skip(numValues);
-  ints->skip(numValues);
+  intDecoder_->skip(numValues);
   return numValues;
 }
 
 void SelectiveIntegerDirectColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   VELOX_WIDTH_DISPATCH(
       dwio::common::sizeOfIntKind(fileType_->type()->kind()),
@@ -34,7 +34,7 @@ void SelectiveIntegerDirectColumnReader::read(
       offset,
       rows,
       incomingNulls);
-  readCommon<SelectiveIntegerDirectColumnReader>(rows);
+  readCommon<SelectiveIntegerDirectColumnReader, true>(rows);
   readOffset_ += rows.back() + 1;
 }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveIntegerDirectColumnReader.h b/velox/dwio/dwrf/reader/SelectiveIntegerDirectColumnReader.h
index ee092c271dd16..8ccfa4cc6b86b 100644
--- a/velox/dwio/dwrf/reader/SelectiveIntegerDirectColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveIntegerDirectColumnReader.h
@@ -28,72 +28,80 @@ class SelectiveIntegerDirectColumnReader
   using ValueType = int64_t;
 
   SelectiveIntegerDirectColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      std::shared_ptr<const dwio::common::TypeWithId> dataType,
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       DwrfParams& params,
       uint32_t numBytes,
       common::ScanSpec& scanSpec)
       : SelectiveIntegerColumnReader(
-            requestedType->type(),
+            requestedType,
             params,
             scanSpec,
-            std::move(dataType)) {
-    EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
-    auto data = encodingKey.forKind(proto::Stream_Kind_DATA);
-    auto& stripe = params.stripeStreams();
-    bool dataVInts = stripe.getUseVInts(data);
+            std::move(fileType)) {
+    const EncodingKey encodingKey{
+        fileType_->id(), params.flatMapContext().sequence};
+    const auto si = encodingKey.forKind(proto::Stream_Kind_DATA);
+    const auto& stripe = params.stripeStreams();
+    const bool dataVInts = stripe.getUseVInts(si);
 
-    format = stripe.format();
-    if (format == velox::dwrf::DwrfFormat::kDwrf) {
-      ints = createDirectDecoder</*isSigned*/ true>(
-          stripe.getStream(data, params.streamLabels().label(), true),
+    format_ = stripe.format();
+    version_ = convertRleVersion(stripe.getEncoding(encodingKey).kind());
+    if (format_ == velox::dwrf::DwrfFormat::kDwrf) {
+      intDecoder_ = createDirectDecoder</*isSigned=*/true>(
+          stripe.getStream(si, params.streamLabels().label(), true),
           dataVInts,
           numBytes);
-    } else if (format == velox::dwrf::DwrfFormat::kOrc) {
-      version = convertRleVersion(stripe.getEncoding(encodingKey).kind());
-      ints = createRleDecoder</*isSigned*/ true>(
-          stripe.getStream(data, params.streamLabels().label(), true),
-          version,
+    } else if (format_ == velox::dwrf::DwrfFormat::kOrc) {
+      version_ = convertRleVersion(stripe.getEncoding(encodingKey).kind());
+      intDecoder_ = createRleDecoder</*isSigned*/ true>(
+          stripe.getStream(si, params.streamLabels().label(), true),
+          version_,
           params.pool(),
           dataVInts,
           numBytes);
     } else {
-      VELOX_FAIL("invalid stripe format");
+      VELOX_FAIL("invalid stripe format: {}", format_);
     }
   }
 
   bool hasBulkPath() const override {
-    return true;
+    // Only ORC uses RLEv2 encoding. Currently, ORC integer data does not
+    // support fastpath reads. When reading RLEv2-encoded integer data
+    // with null, the query will fail.
+    return version_ != velox::dwrf::RleVersion_2;
   }
 
   void seekToRowGroup(uint32_t index) override {
     dwio::common::SelectiveIntegerColumnReader::seekToRowGroup(index);
     auto positionsProvider = formatData_->seekToRowGroup(index);
-    ints->seekToRowGroup(positionsProvider);
+    intDecoder_->seekToRowGroup(positionsProvider);
 
     VELOX_CHECK(!positionsProvider.hasNext());
   }
 
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override;
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
   template <typename ColumnVisitor>
-  void readWithVisitor(RowSet rows, ColumnVisitor visitor);
+  void readWithVisitor(const RowSet& rows, ColumnVisitor visitor);
 
  private:
-  dwrf::DwrfFormat format;
-  RleVersion version;
-  std::unique_ptr<dwio::common::IntDecoder<true>> ints;
+  dwrf::DwrfFormat format_;
+  RleVersion version_;
+  std::unique_ptr<dwio::common::IntDecoder<true>> intDecoder_;
 };
 
 template <typename ColumnVisitor>
 void SelectiveIntegerDirectColumnReader::readWithVisitor(
-    RowSet rows,
+    const RowSet& rows,
     ColumnVisitor visitor) {
-  if (format == velox::dwrf::DwrfFormat::kDwrf) {
-    decodeWithVisitor<dwio::common::DirectDecoder<true>>(ints.get(), visitor);
+  if (format_ == velox::dwrf::DwrfFormat::kDwrf) {
+    decodeWithVisitor<dwio::common::DirectDecoder<true>>(
+        intDecoder_.get(), visitor);
   } else {
     // orc format does not use int128
     if constexpr (!std::is_same_v<typename ColumnVisitor::DataType, int128_t>) {
@@ -107,13 +115,13 @@ void SelectiveIntegerDirectColumnReader::readWithVisitor(
               &visitor.reader(),
               rows,
               visitor.extractValues());
-      if (version == velox::dwrf::RleVersion_1) {
+      if (version_ == velox::dwrf::RleVersion_1) {
         decodeWithVisitor<velox::dwrf::RleDecoderV1<true>>(
-            ints.get(), drVisitor);
+            intDecoder_.get(), drVisitor);
       } else {
-        VELOX_CHECK(version == velox::dwrf::RleVersion_2);
+        VELOX_CHECK(version_ == velox::dwrf::RleVersion_2);
         decodeWithVisitor<velox::dwrf::RleDecoderV2<true>>(
-            ints.get(), drVisitor);
+            intDecoder_.get(), drVisitor);
       }
     } else {
       VELOX_UNREACHABLE(
diff --git a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
index bb8ffb65d9ce3..88171321583a0 100644
--- a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
@@ -20,15 +20,16 @@
 namespace facebook::velox::dwrf {
 namespace {
 std::unique_ptr<dwio::common::IntDecoder</*isSigned*/ false>> makeLengthDecoder(
-    const dwio::common::TypeWithId& nodeType,
+    const dwio::common::TypeWithId& fileType,
     DwrfParams& params,
     memory::MemoryPool& pool) {
-  EncodingKey encodingKey{nodeType.id(), params.flatMapContext().sequence};
+  EncodingKey encodingKey{fileType.id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
-  auto rleVersion = convertRleVersion(stripe.getEncoding(encodingKey).kind());
-  auto lenId = encodingKey.forKind(proto::Stream_Kind_LENGTH);
-  bool lenVints = stripe.getUseVInts(lenId);
-  return createRleDecoder</*isSigned*/ false>(
+  const auto rleVersion =
+      convertRleVersion(stripe.getEncoding(encodingKey).kind());
+  const auto lenId = encodingKey.forKind(proto::Stream_Kind_LENGTH);
+  const bool lenVints = stripe.getUseVInts(lenId);
+  return createRleDecoder</*isSigned=*/false>(
       stripe.getStream(lenId, params.streamLabels().label(), true),
       rleVersion,
       pool,
@@ -37,7 +38,7 @@ std::unique_ptr<dwio::common::IntDecoder</*isSigned*/ false>> makeLengthDecoder(
 }
 } // namespace
 
-FlatMapContext flatMapContextFromEncodingKey(EncodingKey& encodingKey) {
+FlatMapContext flatMapContextFromEncodingKey(const EncodingKey& encodingKey) {
   return FlatMapContext{
       .sequence = encodingKey.sequence(),
       .inMapDecoder = nullptr,
@@ -45,28 +46,23 @@ FlatMapContext flatMapContextFromEncodingKey(EncodingKey& encodingKey) {
 }
 
 SelectiveListColumnReader::SelectiveListColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec)
     : dwio::common::SelectiveListColumnReader(
           requestedType,
-          dataType,
+          fileType,
           params,
           scanSpec),
-      length_(makeLengthDecoder(*fileType_, params, memoryPool_)) {
-  DWIO_ENSURE_EQ(fileType_->id(), dataType->id(), "working on the same node");
+      length_(makeLengthDecoder(*fileType_, params, *memoryPool_)) {
+  VELOX_CHECK_EQ(fileType_->id(), fileType->id(), "working on the same node");
   EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
   // count the number of selected sub-columns
-  const auto& cs = stripe.getColumnSelector();
   auto& childType = requestedType_->childAt(0);
-  VELOX_CHECK(
-      cs.shouldReadNode(childType->id()),
-      "SelectiveListColumnReader must select the values stream");
   if (scanSpec_->children().empty()) {
-    scanSpec.getOrCreateChild(
-        common::Subfield(common::ScanSpec::kArrayElementsFieldName));
+    scanSpec.getOrCreateChild(common::ScanSpec::kArrayElementsFieldName);
   }
   scanSpec_->children()[0]->setProjectOut(true);
   scanSpec_->children()[0]->setExtractValues(true);
@@ -82,35 +78,30 @@ SelectiveListColumnReader::SelectiveListColumnReader(
 }
 
 SelectiveMapColumnReader::SelectiveMapColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec)
     : dwio::common::SelectiveMapColumnReader(
           requestedType,
-          dataType,
+          fileType,
           params,
           scanSpec),
-      length_(makeLengthDecoder(*fileType_, params, memoryPool_)) {
-  DWIO_ENSURE_EQ(fileType_->id(), dataType->id(), "working on the same node");
-  EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
+      length_(makeLengthDecoder(*fileType_, params, *memoryPool_)) {
+  VELOX_CHECK_EQ(fileType_->id(), fileType->id(), "working on the same node");
+  const EncodingKey encodingKey{
+      fileType_->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
   if (scanSpec_->children().empty()) {
-    scanSpec_->getOrCreateChild(
-        common::Subfield(common::ScanSpec::kMapKeysFieldName));
-    scanSpec_->getOrCreateChild(
-        common::Subfield(common::ScanSpec::kMapValuesFieldName));
+    scanSpec_->getOrCreateChild(common::ScanSpec::kMapKeysFieldName);
+    scanSpec_->getOrCreateChild(common::ScanSpec::kMapValuesFieldName);
   }
   scanSpec_->children()[0]->setProjectOut(true);
   scanSpec_->children()[0]->setExtractValues(true);
   scanSpec_->children()[1]->setProjectOut(true);
   scanSpec_->children()[1]->setExtractValues(true);
 
-  const auto& cs = stripe.getColumnSelector();
   auto& keyType = requestedType_->childAt(0);
-  VELOX_CHECK(
-      cs.shouldReadNode(keyType->id()),
-      "Map key must be selected in SelectiveMapColumnReader");
   auto keyParams = DwrfParams(
       stripe,
       params.streamLabels(),
@@ -123,9 +114,6 @@ SelectiveMapColumnReader::SelectiveMapColumnReader(
       *scanSpec_->children()[0].get());
 
   auto& valueType = requestedType_->childAt(1);
-  VELOX_CHECK(
-      cs.shouldReadNode(valueType->id()),
-      "Map Values must be selected in SelectiveMapColumnReader");
   auto elementParams = DwrfParams(
       stripe,
       params.streamLabels(),
diff --git a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
index 063f579683fcc..d777dd71d0111 100644
--- a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
@@ -28,8 +28,8 @@ class SelectiveListColumnReader
     : public dwio::common::SelectiveListColumnReader {
  public:
   SelectiveListColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
@@ -49,10 +49,8 @@ class SelectiveListColumnReader
     childTargetReadOffset_ = 0;
   }
 
-  void readLengths(
-      int32_t* FOLLY_NONNULL lengths,
-      int32_t numLengths,
-      const uint64_t* FOLLY_NULLABLE nulls) override {
+  void readLengths(int32_t* lengths, int32_t numLengths, const uint64_t* nulls)
+      override {
     length_->next(lengths, numLengths, nulls);
   }
 
@@ -63,8 +61,8 @@ class SelectiveListColumnReader
 class SelectiveMapColumnReader : public dwio::common::SelectiveMapColumnReader {
  public:
   SelectiveMapColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
@@ -88,15 +86,13 @@ class SelectiveMapColumnReader : public dwio::common::SelectiveMapColumnReader {
     childTargetReadOffset_ = 0;
   }
 
-  void readLengths(
-      int32_t* FOLLY_NONNULL lengths,
-      int32_t numLengths,
-      const uint64_t* FOLLY_NULLABLE nulls) override {
+  void readLengths(int32_t* lengths, int32_t numLengths, const uint64_t* nulls)
+      override {
     length_->next(lengths, numLengths, nulls);
   }
 
  private:
-  std::unique_ptr<dwio::common::IntDecoder</*isSigned*/ false>> length_;
+  std::unique_ptr<dwio::common::IntDecoder</*isSigned=*/false>> length_;
 };
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
index bcdab82310259..df25566c5babc 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
@@ -23,10 +23,10 @@ namespace facebook::velox::dwrf {
 using namespace dwio::common;
 
 SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
-    const std::shared_ptr<const TypeWithId>& nodeType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec)
-    : SelectiveColumnReader(nodeType->type(), params, scanSpec, nodeType),
+    : SelectiveColumnReader(fileType->type(), fileType, params, scanSpec),
       lastStrideIndex_(-1),
       provider_(params.stripeStreams().getStrideIndexProvider()),
       statistics_(params.runtimeStatistics()) {
@@ -41,7 +41,7 @@ SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
   dictIndex_ = createRleDecoder</*isSigned*/ false>(
       stripe.getStream(dataId, params.streamLabels().label(), true),
       version_,
-      memoryPool_,
+      *memoryPool_,
       dictVInts,
       dwio::common::INT_BYTE_SIZE);
 
@@ -50,7 +50,7 @@ SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
   lengthDecoder_ = createRleDecoder</*isSigned*/ false>(
       stripe.getStream(lenId, params.streamLabels().label(), false),
       version_,
-      memoryPool_,
+      *memoryPool_,
       lenVInts,
       dwio::common::INT_BYTE_SIZE);
 
@@ -65,8 +65,6 @@ SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
       params.streamLabels().label(),
       false);
   if (inDictStream) {
-    formatData_->as<DwrfData>().ensureRowGroupIndex();
-
     inDictionaryReader_ =
         createBooleanRleDecoder(std::move(inDictStream), encodingKey);
 
@@ -75,7 +73,7 @@ SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
         encodingKey.forKind(proto::Stream_Kind_STRIDE_DICTIONARY),
         params.streamLabels().label(),
         true);
-    DWIO_ENSURE_NOT_NULL(strideDictStream_, "Stride dictionary is missing");
+    VELOX_CHECK_NOT_NULL(strideDictStream_, "Stride dictionary is missing");
 
     const auto strideDictLenId =
         encodingKey.forKind(proto::Stream_Kind_STRIDE_DICTIONARY_LENGTH);
@@ -83,7 +81,7 @@ SelectiveStringDictionaryColumnReader::SelectiveStringDictionaryColumnReader(
     strideDictLengthDecoder_ = createRleDecoder</*isSigned*/ false>(
         stripe.getStream(strideDictLenId, params.streamLabels().label(), true),
         version_,
-        memoryPool_,
+        *memoryPool_,
         strideLenVInt,
         dwio::common::INT_BYTE_SIZE);
   }
@@ -105,16 +103,16 @@ void SelectiveStringDictionaryColumnReader::loadDictionary(
     DictionaryValues& values) {
   // read lengths from length reader
   dwio::common::ensureCapacity<StringView>(
-      values.values, values.numValues, &memoryPool_);
+      values.values, values.numValues, memoryPool_);
   // The lengths are read in the low addresses of the string views array.
-  int64_t* int64Values = values.values->asMutable<int64_t>();
-  lengthDecoder.next(int64Values, values.numValues, nullptr);
+  auto* lengths = values.values->asMutable<int32_t>();
+  lengthDecoder.nextLengths(lengths, values.numValues);
   int64_t stringsBytes = 0;
   for (auto i = 0; i < values.numValues; ++i) {
-    stringsBytes += int64Values[i];
+    stringsBytes += lengths[i];
   }
   // read bytes from underlying string
-  values.strings = AlignedBuffer::allocate<char>(stringsBytes, &memoryPool_);
+  values.strings = AlignedBuffer::allocate<char>(stringsBytes, memoryPool_);
   data.readFully(values.strings->asMutable<char>(), stringsBytes);
   // fill the values with StringViews over the strings. 'strings' will
   // exist even if 'stringsBytes' is 0, which can happen if the only
@@ -125,8 +123,8 @@ void SelectiveStringDictionaryColumnReader::loadDictionary(
   // the lengths at the start of values.
   auto offset = stringsBytes;
   for (int32_t i = values.numValues - 1; i >= 0; --i) {
-    offset -= int64Values[i];
-    views[i] = StringView(strings + offset, int64Values[i]);
+    offset -= lengths[i];
+    views[i] = StringView(strings + offset, lengths[i]);
   }
 }
 
@@ -154,7 +152,7 @@ void SelectiveStringDictionaryColumnReader::loadStrideDictionary() {
   lastStrideIndex_ = nextStride;
   dictionaryValues_ = nullptr;
 
-  if (scanSpec_->hasFilter()) {
+  if (DictionaryValues::hasFilter(scanSpec_->filter())) {
     scanState_.filterCache.resize(
         scanState_.dictionary.numValues + scanState_.dictionary2.numValues);
     simd::memset(
@@ -169,7 +167,7 @@ void SelectiveStringDictionaryColumnReader::makeDictionaryBaseVector() {
   if (scanState_.dictionary2.numValues) {
     BufferPtr values = AlignedBuffer::allocate<StringView>(
         scanState_.dictionary.numValues + scanState_.dictionary2.numValues,
-        &memoryPool_);
+        memoryPool_);
     auto* valuesPtr = values->asMutable<StringView>();
     memcpy(
         valuesPtr,
@@ -181,7 +179,7 @@ void SelectiveStringDictionaryColumnReader::makeDictionaryBaseVector() {
         scanState_.dictionary2.numValues * sizeof(StringView));
 
     dictionaryValues_ = std::make_shared<FlatVector<StringView>>(
-        &memoryPool_,
+        memoryPool_,
         fileType_->type(),
         BufferPtr(nullptr), // TODO nulls
         scanState_.dictionary.numValues +
@@ -191,7 +189,7 @@ void SelectiveStringDictionaryColumnReader::makeDictionaryBaseVector() {
             scanState_.dictionary.strings, scanState_.dictionary2.strings});
   } else {
     dictionaryValues_ = std::make_shared<FlatVector<StringView>>(
-        &memoryPool_,
+        memoryPool_,
         fileType_->type(),
         BufferPtr(nullptr), // TODO nulls
         scanState_.dictionary.numValues /*length*/,
@@ -202,7 +200,7 @@ void SelectiveStringDictionaryColumnReader::makeDictionaryBaseVector() {
 
 void SelectiveStringDictionaryColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   prepareRead<int32_t>(offset, rows, incomingNulls);
   bool isDense = rows.back() == rows.size() - 1;
@@ -218,7 +216,7 @@ void SelectiveStringDictionaryColumnReader::read(
         ? bits::countNonNulls(nullsInReadRange_->as<uint64_t>(), 0, end)
         : end;
     dwio::common::ensureCapacity<uint64_t>(
-        scanState_.inDictionary, bits::nwords(numFlags), &memoryPool_);
+        scanState_.inDictionary, bits::nwords(numFlags), memoryPool_);
     // The in dict buffer may have changed. If no change in
     // dictionary, the raw state will not be updated elsewhere.
     scanState_.rawState.inDictionary = scanState_.inDictionary->as<uint64_t>();
@@ -230,37 +228,10 @@ void SelectiveStringDictionaryColumnReader::read(
     loadStrideDictionary();
   }
 
-  if (scanSpec_->keepValues()) {
-    if (scanSpec_->valueHook()) {
-      if (isDense) {
-        readHelper<common::AlwaysTrue, true>(
-            &alwaysTrue(),
-            rows,
-            ExtractStringDictionaryToGenericHook(
-                scanSpec_->valueHook(), rows, scanState_.rawState));
-      } else {
-        readHelper<common::AlwaysTrue, false>(
-            &alwaysTrue(),
-            rows,
-            ExtractStringDictionaryToGenericHook(
-                scanSpec_->valueHook(), rows, scanState_.rawState));
-      }
-    } else {
-      if (isDense) {
-        processFilter<true>(scanSpec_->filter(), rows, ExtractToReader(this));
-      } else {
-        processFilter<false>(scanSpec_->filter(), rows, ExtractToReader(this));
-      }
-    }
-  } else {
-    if (isDense) {
-      processFilter<true>(
-          scanSpec_->filter(), rows, dwio::common::DropValues());
-    } else {
-      processFilter<false>(
-          scanSpec_->filter(), rows, dwio::common::DropValues());
-    }
-  }
+  dwio::common::StringColumnReadWithVisitorHelper<true, true>(
+      *this, rows)([&](auto visitor) {
+    readWithVisitor(visitor.toStringDictionaryColumnVisitor());
+  });
 
   readOffset_ += rows.back() + 1;
   numRowsScanned_ = readOffset_ - offset;
@@ -268,7 +239,7 @@ void SelectiveStringDictionaryColumnReader::read(
 
 void SelectiveStringDictionaryColumnReader::makeFlat(VectorPtr* result) {
   auto* indices = reinterpret_cast<const vector_size_t*>(rawValues_);
-  auto values = AlignedBuffer::allocate<StringView>(numValues_, &memoryPool_);
+  auto values = AlignedBuffer::allocate<StringView>(numValues_, memoryPool_);
   auto* stringViews = values->asMutable<StringView>();
   std::vector<BufferPtr> stringBuffers;
   auto* stripeDict = scanState_.dictionary.values->as<StringView>();
@@ -293,7 +264,7 @@ void SelectiveStringDictionaryColumnReader::makeFlat(VectorPtr* result) {
     }
   }
   *result = std::make_shared<FlatVector<StringView>>(
-      &memoryPool_,
+      memoryPool_,
       requestedType(),
       std::move(nulls),
       numValues_,
@@ -303,7 +274,7 @@ void SelectiveStringDictionaryColumnReader::makeFlat(VectorPtr* result) {
 }
 
 void SelectiveStringDictionaryColumnReader::getValues(
-    RowSet rows,
+    const RowSet& rows,
     VectorPtr* result) {
   compactScalarValues<int32_t, int32_t>(rows, false);
   VELOX_CHECK_GT(numRowsScanned_, 0);
@@ -323,7 +294,7 @@ void SelectiveStringDictionaryColumnReader::getValues(
     makeDictionaryBaseVector();
   }
   *result = std::make_shared<DictionaryVector<StringView>>(
-      &memoryPool_, resultNulls(), numValues_, dictionaryValues_, values_);
+      memoryPool_, resultNulls(), numValues_, dictionaryValues_, values_);
 }
 
 void SelectiveStringDictionaryColumnReader::ensureInitialized() {
@@ -331,11 +302,11 @@ void SelectiveStringDictionaryColumnReader::ensureInitialized() {
     return;
   }
 
-  Timer timer;
+  ClockTimer timer{initTimeClocks_};
 
   loadDictionary(*blobStream_, *lengthDecoder_, scanState_.dictionary);
 
-  if (scanSpec_->hasFilter()) {
+  if (DictionaryValues::hasFilter(scanSpec_->filter())) {
     scanState_.filterCache.resize(scanState_.dictionary.numValues);
     simd::memset(
         scanState_.filterCache.data(),
@@ -359,7 +330,6 @@ void SelectiveStringDictionaryColumnReader::ensureInitialized() {
   }
   scanState_.updateRawState();
   initialized_ = true;
-  initTimeClocks_ = timer.elapsedClocks();
 }
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.h b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.h
index 2bec5338d46b9..9216764aff111 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.h
@@ -28,10 +28,17 @@ class SelectiveStringDictionaryColumnReader
   using ValueType = int32_t;
 
   SelectiveStringDictionaryColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
+  bool hasBulkPath() const override {
+    // Only ORC uses RLEv2 encoding. Currently, ORC string data does not
+    // support fastpath reads. When reading RLEv2-encoded string data
+    // with null, the query will fail.
+    return version_ != velox::dwrf::RleVersion_2;
+  }
+
   void seekToRowGroup(uint32_t index) override {
     SelectiveColumnReader::seekToRowGroup(index);
     auto positionsProvider = formatData_->as<DwrfData>().seekToRowGroup(index);
@@ -53,26 +60,19 @@ class SelectiveStringDictionaryColumnReader
 
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override;
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
-  void getValues(RowSet rows, VectorPtr* result) override;
+  void getValues(const RowSet& rows, VectorPtr* result) override;
 
  private:
   void loadStrideDictionary();
   void makeDictionaryBaseVector();
 
   template <typename TVisitor>
-  void readWithVisitor(RowSet rows, TVisitor visitor);
-
-  template <typename TFilter, bool isDense, typename ExtractValues>
-  void readHelper(common::Filter* filter, RowSet rows, ExtractValues values);
-
-  template <bool isDense, typename ExtractValues>
-  void processFilter(
-      common::Filter* filter,
-      RowSet rows,
-      ExtractValues extractValues);
+  void readWithVisitor(TVisitor visitor);
 
   // Fills 'values' from 'data' and 'lengthDecoder'. The count of
   // values is in 'values.numValues'.
@@ -108,9 +108,7 @@ class SelectiveStringDictionaryColumnReader
 };
 
 template <typename TVisitor>
-void SelectiveStringDictionaryColumnReader::readWithVisitor(
-    RowSet rows,
-    TVisitor visitor) {
+void SelectiveStringDictionaryColumnReader::readWithVisitor(TVisitor visitor) {
   if (version_ == velox::dwrf::RleVersion_1) {
     decodeWithVisitor<velox::dwrf::RleDecoderV1<false>>(
         dictIndex_.get(), visitor);
@@ -120,58 +118,4 @@ void SelectiveStringDictionaryColumnReader::readWithVisitor(
   }
 }
 
-template <typename TFilter, bool isDense, typename ExtractValues>
-void SelectiveStringDictionaryColumnReader::readHelper(
-    common::Filter* filter,
-    RowSet rows,
-    ExtractValues values) {
-  readWithVisitor(
-      rows,
-      dwio::common::
-          StringDictionaryColumnVisitor<TFilter, ExtractValues, isDense>(
-              *reinterpret_cast<TFilter*>(filter), this, rows, values));
-}
-
-template <bool isDense, typename ExtractValues>
-void SelectiveStringDictionaryColumnReader::processFilter(
-    common::Filter* filter,
-    RowSet rows,
-    ExtractValues extractValues) {
-  switch (filter ? filter->kind() : common::FilterKind::kAlwaysTrue) {
-    case common::FilterKind::kAlwaysTrue:
-      readHelper<common::AlwaysTrue, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kIsNull:
-      filterNulls<int32_t>(
-          rows,
-          true,
-          !std::is_same_v<decltype(extractValues), dwio::common::DropValues>);
-      break;
-    case common::FilterKind::kIsNotNull:
-      if (std::is_same_v<decltype(extractValues), dwio::common::DropValues>) {
-        filterNulls<int32_t>(rows, false, false);
-      } else {
-        readHelper<common::IsNotNull, isDense>(filter, rows, extractValues);
-      }
-      break;
-    case common::FilterKind::kBytesRange:
-      readHelper<common::BytesRange, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kNegatedBytesRange:
-      readHelper<common::NegatedBytesRange, isDense>(
-          filter, rows, extractValues);
-      break;
-    case common::FilterKind::kBytesValues:
-      readHelper<common::BytesValues, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kNegatedBytesValues:
-      readHelper<common::NegatedBytesValues, isDense>(
-          filter, rows, extractValues);
-      break;
-    default:
-      readHelper<common::Filter, isDense>(filter, rows, extractValues);
-      break;
-  }
-}
-
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
index 444eb5f63a23c..b7f96e36e657a 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
@@ -15,17 +15,19 @@
  */
 
 #include "velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h"
+
+#include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/BufferUtil.h"
 #include "velox/dwio/dwrf/common/DecoderUtil.h"
 
 namespace facebook::velox::dwrf {
 
 SelectiveStringDirectColumnReader::SelectiveStringDirectColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec)
-    : SelectiveColumnReader(nodeType->type(), params, scanSpec, nodeType) {
-  EncodingKey encodingKey{nodeType->id(), params.flatMapContext().sequence};
+    : SelectiveColumnReader(fileType->type(), fileType, params, scanSpec) {
+  EncodingKey encodingKey{fileType->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
   RleVersion rleVersion =
       convertRleVersion(stripe.getEncoding(encodingKey).kind());
@@ -34,7 +36,7 @@ SelectiveStringDirectColumnReader::SelectiveStringDirectColumnReader(
   lengthDecoder_ = createRleDecoder</*isSigned*/ false>(
       stripe.getStream(lenId, params.streamLabels().label(), true),
       rleVersion,
-      memoryPool_,
+      *memoryPool_,
       lenVInts,
       dwio::common::INT_BYTE_SIZE);
   blobStream_ = stripe.getStream(
@@ -45,7 +47,7 @@ SelectiveStringDirectColumnReader::SelectiveStringDirectColumnReader(
 
 uint64_t SelectiveStringDirectColumnReader::skip(uint64_t numValues) {
   numValues = SelectiveColumnReader::skip(numValues);
-  dwio::common::ensureCapacity<int64_t>(lengths_, numValues, &memoryPool_);
+  dwio::common::ensureCapacity<int64_t>(lengths_, numValues, memoryPool_);
   lengthDecoder_->nextLengths(lengths_->asMutable<int32_t>(), numValues);
   rawLengths_ = lengths_->as<uint32_t>();
   for (auto i = 0; i < numValues; ++i) {
@@ -134,18 +136,117 @@ void SelectiveStringDirectColumnReader::extractNSparse(
   lengthIndex_ = rows[row + numValues - 1] + 1;
 }
 
+namespace {
+
+#if XSIMD_WITH_AVX2
+xsimd::make_sized_batch_t<uint16_t, 8> toUint16x8(xsimd::batch<uint32_t> x) {
+  auto y = _mm256_castsi128_si256(_mm256_extracti128_si256(x, 1));
+  return _mm256_castsi256_si128(_mm256_packus_epi32(x, y));
+}
+#endif
+
+bool allSmallEnough(const uint32_t* lengths, uint16_t* offsets, bool& gt4) {
+#if XSIMD_WITH_AVX2
+  auto vlength = xsimd::load_unaligned(lengths);
+  static_assert(vlength.size == 8);
+  if (simd::toBitMask(vlength > xsimd::broadcast<uint32_t>(12))) {
+    return false;
+  }
+  gt4 = simd::toBitMask(vlength > xsimd::broadcast<uint32_t>(4));
+  // Convert to 128 bit vector to calculate prefix sums, because
+  // _mm256_slli_si256 is not shifting all 8 lanes together.
+  auto vlength16 = toUint16x8(vlength);
+  vlength16 += _mm_slli_si128(vlength16, 2);
+  vlength16 += _mm_slli_si128(vlength16, 4);
+  vlength16 += _mm_slli_si128(vlength16, 8);
+  offsets[0] = 0;
+  vlength16.store_unaligned(offsets + 1);
+#else
+  for (int i = 0; i < 8; ++i) {
+    if (lengths[i] > 12) {
+      return false;
+    }
+  }
+  gt4 = false;
+  for (int i = 0; i < 8; ++i) {
+    gt4 = gt4 || lengths[i] > 4;
+  }
+  offsets[0] = 0;
+  for (int i = 0; i < 8; ++i) {
+    offsets[i + 1] = offsets[i] + lengths[i];
+  }
+#endif
+  return true;
+}
+
+} // namespace
+
+template <bool kScatter, bool kGreaterThan4>
+bool SelectiveStringDirectColumnReader::try8ConsecutiveSmall(
+    const char* data,
+    const uint16_t* offsets,
+    int startRow) {
+#ifndef NDEBUG
+  bool testCoverage[] = {kScatter, kGreaterThan4};
+  common::testutil::TestValue::adjust(
+      "facebook::velox::dwrf::SelectiveStringDirectColumnReader::try8ConsecutiveSmall",
+      testCoverage);
+#endif
+  auto* result = reinterpret_cast<uint64_t*>(rawValues_);
+  // Make sure the iterations are independent with each other.
+  for (int i = 0; i < 8; ++i) {
+    unsigned j = kScatter ? outerNonNullRows_[startRow + i] : numValues_ + i;
+    uint64_t word;
+    memcpy(&word, data + offsets[i], 4);
+    uint64_t length = offsets[i + 1] - offsets[i];
+    if (kGreaterThan4 && length > 4) {
+      uint64_t word2;
+      memcpy(&word2, data + offsets[i] + 4, 8);
+      uint64_t mask = length == 12 ? -1ull : (1ull << (8 * (length - 4))) - 1;
+      result[2 * j] = length | (word << 32);
+      result[2 * j + 1] = word2 & mask;
+    } else {
+      uint64_t mask = (1ull << (8 * length)) - 1;
+      result[2 * j] = length | ((word & mask) << 32);
+      result[2 * j + 1] = 0;
+    }
+  }
+  bufferStart_ = data + offsets[8];
+  bytesToSkip_ = 0;
+  if constexpr (!kScatter) {
+    numValues_ += 8;
+  } else {
+    numValues_ = outerNonNullRows_[startRow + 7] + 1;
+  }
+  lengthIndex_ += 8;
+  return true;
+}
+
 template <bool scatter, bool sparse>
 inline bool SelectiveStringDirectColumnReader::try8Consecutive(
     int32_t start,
     const int32_t* rows,
     int32_t row) {
-  // If we haven't read in a buffer yet.
-  if (!bufferStart_) {
+  // If we haven't read in a buffer yet, or there is not enough data left.  This
+  // check is important to make sure the subsequent fast path will have enough
+  // data to read.
+  if (!bufferStart_ ||
+      bufferEnd_ - bufferStart_ - bytesToSkip_ < start + 8 * 12) {
     return false;
   }
   const char* data = bufferStart_ + start + bytesToSkip_;
-  if (!data || bufferEnd_ - data < start + 8 * 12) {
-    return false;
+  if constexpr (!sparse) {
+    auto* lengths = rawLengths_ + rows[row];
+    uint16_t offsets[9];
+    bool gt4;
+    if (allSmallEnough(lengths, offsets, gt4)) {
+      if (gt4) {
+        VELOX_DCHECK_LE(data + offsets[7] + 12, bufferEnd_);
+        return try8ConsecutiveSmall<scatter, true>(data, offsets, row);
+      } else {
+        return try8ConsecutiveSmall<scatter, false>(data, offsets, row);
+      }
+    }
   }
   int32_t* result = reinterpret_cast<int32_t*>(rawValues_);
   int32_t resultIndex = numValues_ * 4 - 4;
@@ -171,8 +272,12 @@ inline bool SelectiveStringDirectColumnReader::try8Consecutive(
       return false;
     }
     result[resultIndex] = length;
-    auto first16 = xsimd::make_sized_batch_t<int8_t, 16>::load_unaligned(data);
-    first16.store_unaligned(reinterpret_cast<char*>(result + resultIndex + 1));
+    xsimd::make_sized_batch_t<int8_t, 16> first16;
+    if (length > 0) {
+      first16 = decltype(first16)::load_unaligned(data);
+      first16.store_unaligned(
+          reinterpret_cast<char*>(result + resultIndex + 1));
+    }
     if (length <= 12) {
       data += length;
       *reinterpret_cast<int64_t*>(
@@ -188,7 +293,7 @@ inline bool SelectiveStringDirectColumnReader::try8Consecutive(
     first16.store_unaligned<char>(rawStringBuffer_ + rawUsed);
     if (length > 16) {
       size_t copySize = bits::roundUp(length - 16, 16);
-      VELOX_CHECK_LE(data + copySize, bufferEnd_);
+      VELOX_CHECK_LE(copySize, bufferEnd_ - data - 16);
       simd::memcpy(rawStringBuffer_ + rawUsed + 16, data + 16, copySize);
     }
     rawUsed += length;
@@ -236,12 +341,12 @@ void SelectiveStringDirectColumnReader::extractSparse(
       });
 }
 
-template <bool hasNulls>
+template <bool kHasNulls>
 void SelectiveStringDirectColumnReader::skipInDecode(
     int32_t numValues,
     int32_t current,
     const uint64_t* nulls) {
-  if (hasNulls) {
+  if (kHasNulls) {
     numValues = bits::countNonNulls(nulls, current, current + numValues);
   }
   for (size_t i = lengthIndex_; i < lengthIndex_ + numValues; ++i) {
@@ -266,19 +371,19 @@ folly::StringPiece SelectiveStringDirectColumnReader::readValue(
   return folly::StringPiece(tempString_);
 }
 
-template <bool hasNulls, typename Visitor>
+template <bool kHasNulls, typename Visitor>
 void SelectiveStringDirectColumnReader::decode(
     const uint64_t* nulls,
     Visitor visitor) {
   int32_t current = visitor.start();
   bool atEnd = false;
-  bool allowNulls = hasNulls && visitor.allowNulls();
+  bool allowNulls = kHasNulls && visitor.allowNulls();
   for (;;) {
     int32_t toSkip;
-    if (hasNulls && allowNulls && bits::isBitNull(nulls, current)) {
+    if (kHasNulls && allowNulls && bits::isBitNull(nulls, current)) {
       toSkip = visitor.processNull(atEnd);
     } else {
-      if (hasNulls && !allowNulls) {
+      if (kHasNulls && !allowNulls) {
         toSkip = visitor.checkAndSkipNulls(nulls, current, atEnd);
         if (!Visitor::dense) {
           skipInDecode<false>(toSkip, current, nullptr);
@@ -301,7 +406,7 @@ void SelectiveStringDirectColumnReader::decode(
     }
     ++current;
     if (toSkip) {
-      skipInDecode<hasNulls>(toSkip, current, nulls);
+      skipInDecode<kHasNulls>(toSkip, current, nulls);
       current += toSkip;
     }
     if (atEnd) {
@@ -317,9 +422,7 @@ void SelectiveStringDirectColumnReader::readWithVisitor(
   int32_t current = visitor.start();
   constexpr bool isExtract =
       std::is_same_v<typename TVisitor::FilterType, common::AlwaysTrue> &&
-      std::is_same_v<
-          typename TVisitor::Extract,
-          dwio::common::ExtractToReader<SelectiveStringDirectColumnReader>>;
+      std::is_same_v<typename TVisitor::Extract, dwio::common::ExtractToReader>;
   auto nulls = nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
 
   if (process::hasAvx2() && isExtract) {
@@ -360,109 +463,23 @@ void SelectiveStringDirectColumnReader::readWithVisitor(
   }
 }
 
-template <typename TFilter, bool isDense, typename ExtractValues>
-void SelectiveStringDirectColumnReader::readHelper(
-    common::Filter* filter,
-    RowSet rows,
-    ExtractValues extractValues) {
-  readWithVisitor(
-      rows,
-      dwio::common::
-          ColumnVisitor<folly::StringPiece, TFilter, ExtractValues, isDense>(
-              *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
-}
-
-template <bool isDense, typename ExtractValues>
-void SelectiveStringDirectColumnReader::processFilter(
-    common::Filter* filter,
-    RowSet rows,
-    ExtractValues extractValues) {
-  switch (filter ? filter->kind() : common::FilterKind::kAlwaysTrue) {
-    case common::FilterKind::kAlwaysTrue:
-      readHelper<common::AlwaysTrue, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kIsNull:
-      filterNulls<StringView>(
-          rows,
-          true,
-          !std::is_same_v<decltype(extractValues), dwio::common::DropValues>);
-      break;
-    case common::FilterKind::kIsNotNull:
-      if (std::is_same_v<decltype(extractValues), dwio::common::DropValues>) {
-        filterNulls<StringView>(rows, false, false);
-      } else {
-        readHelper<common::IsNotNull, isDense>(filter, rows, extractValues);
-      }
-      break;
-    case common::FilterKind::kBytesRange:
-      readHelper<common::BytesRange, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kNegatedBytesRange:
-      readHelper<common::NegatedBytesRange, isDense>(
-          filter, rows, extractValues);
-      break;
-    case common::FilterKind::kBytesValues:
-      readHelper<common::BytesValues, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kNegatedBytesValues:
-      readHelper<common::NegatedBytesValues, isDense>(
-          filter, rows, extractValues);
-      break;
-    default:
-      readHelper<common::Filter, isDense>(filter, rows, extractValues);
-      break;
-  }
-}
-
 void SelectiveStringDirectColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   prepareRead<folly::StringPiece>(offset, rows, incomingNulls);
-  bool isDense = rows.back() == rows.size() - 1;
-
   auto numRows = rows.back() + 1;
   auto numNulls = nullsInReadRange_
       ? BaseVector::countNulls(nullsInReadRange_, 0, numRows)
       : 0;
   dwio::common::ensureCapacity<int32_t>(
-      lengths_, numRows - numNulls, &memoryPool_);
+      lengths_, numRows - numNulls, memoryPool_);
   lengthDecoder_->nextLengths(
       lengths_->asMutable<int32_t>(), numRows - numNulls);
   rawLengths_ = lengths_->as<uint32_t>();
   lengthIndex_ = 0;
-  if (scanSpec_->keepValues()) {
-    if (scanSpec_->valueHook()) {
-      if (isDense) {
-        readHelper<common::AlwaysTrue, true>(
-            &dwio::common::alwaysTrue(),
-            rows,
-            dwio::common::ExtractToGenericHook(scanSpec_->valueHook()));
-      } else {
-        readHelper<common::AlwaysTrue, false>(
-            &dwio::common::alwaysTrue(),
-            rows,
-            dwio::common::ExtractToGenericHook(scanSpec_->valueHook()));
-      }
-    } else {
-      if (isDense) {
-        processFilter<true>(
-            scanSpec_->filter(), rows, dwio::common::ExtractToReader(this));
-      } else {
-        processFilter<false>(
-            scanSpec_->filter(), rows, dwio::common::ExtractToReader(this));
-      }
-    }
-  } else {
-    if (isDense) {
-      processFilter<true>(
-          scanSpec_->filter(), rows, dwio::common::DropValues());
-    } else {
-      processFilter<false>(
-          scanSpec_->filter(), rows, dwio::common::DropValues());
-    }
-  }
-
+  dwio::common::StringColumnReadWithVisitorHelper<true, false>(
+      *this, rows)([&](auto visitor) { readWithVisitor(rows, visitor); });
   readOffset_ += numRows;
 }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
index 5b2eb45b412de..e8bd978ba523d 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
@@ -26,7 +26,7 @@ class SelectiveStringDirectColumnReader
  public:
   using ValueType = StringView;
   SelectiveStringDirectColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
@@ -44,10 +44,12 @@ class SelectiveStringDirectColumnReader
 
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override;
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
-  void getValues(RowSet rows, VectorPtr* result) override {
+  void getValues(const RowSet& rows, VectorPtr* result) override {
     rawStringBuffer_ = nullptr;
     rawStringSize_ = 0;
     rawStringUsed_ = 0;
@@ -66,15 +68,6 @@ class SelectiveStringDirectColumnReader
   template <typename TVisitor>
   void readWithVisitor(RowSet rows, TVisitor visitor);
 
-  template <typename TFilter, bool isDense, typename ExtractValues>
-  void readHelper(common::Filter* filter, RowSet rows, ExtractValues values);
-
-  template <bool isDense, typename ExtractValues>
-  void processFilter(
-      common::Filter* filter,
-      RowSet rows,
-      ExtractValues extractValues);
-
   void extractCrossBuffers(
       const int32_t* lengths,
       const int32_t* starts,
@@ -94,6 +87,10 @@ class SelectiveStringDirectColumnReader
   template <bool scatter, bool skip>
   bool try8Consecutive(int32_t start, const int32_t* rows, int32_t row);
 
+  template <bool kScatter, bool kGreaterThan4>
+  bool
+  try8ConsecutiveSmall(const char* data, const uint16_t* offsets, int startRow);
+
   std::unique_ptr<dwio::common::IntDecoder</*isSigned*/ false>> lengthDecoder_;
   std::unique_ptr<dwio::common::SeekableInputStream> blobStream_;
   const char* bufferStart_ = nullptr;
diff --git a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
index a723bbf1d962c..26f5020dd16a5 100644
--- a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
@@ -24,39 +24,42 @@ namespace facebook::velox::dwrf {
 using namespace dwio::common;
 
 SelectiveStructColumnReader::SelectiveStructColumnReader(
-    const std::shared_ptr<const TypeWithId>& requestedType,
-    const std::shared_ptr<const TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec,
     bool isRoot)
     : SelectiveStructColumnReaderBase(
           requestedType,
-          dataType,
+          fileType,
           params,
           scanSpec,
           isRoot) {
   EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
-  auto encoding = static_cast<int64_t>(stripe.getEncoding(encodingKey).kind());
-  DWIO_ENSURE_EQ(
-      encoding,
-      proto::ColumnEncoding_Kind_DIRECT,
+  const auto encodingKind =
+      static_cast<int64_t>(stripe.getEncoding(encodingKey).kind());
+  VELOX_CHECK(
+      encodingKind == proto::ColumnEncoding_Kind_DIRECT,
       "Unknown encoding for StructColumnReader");
 
-  const auto& cs = stripe.getColumnSelector();
   // A reader tree may be constructed while the ScanSpec is being used
   // for another read. This happens when the next stripe is being
   // prepared while the previous one is reading.
   auto& childSpecs = scanSpec.stableChildren();
+  const auto& rowType = requestedType_->asRow();
   for (auto i = 0; i < childSpecs.size(); ++i) {
-    auto childSpec = childSpecs[i];
+    auto* childSpec = childSpecs[i];
+    if (childSpec->isExplicitRowNumber()) {
+      continue;
+    }
     if (isChildConstant(*childSpec)) {
       childSpec->setSubscript(kConstantChildSpecSubscript);
       continue;
     }
-    auto childDataType = fileType_->childByName(childSpec->fieldName());
-    auto childRequestedType =
-        requestedType_->childByName(childSpec->fieldName());
+
+    const auto childFileType = fileType_->childByName(childSpec->fieldName());
+    const auto childRequestedType = rowType.findChild(childSpec->fieldName());
     auto labels = params.streamLabels().append(folly::to<std::string>(i));
     auto childParams = DwrfParams(
         stripe,
@@ -66,9 +69,8 @@ SelectiveStructColumnReader::SelectiveStructColumnReader(
             .sequence = encodingKey.sequence(),
             .inMapDecoder = nullptr,
             .keySelectionCallback = nullptr});
-    VELOX_CHECK(cs.shouldReadNode(childRequestedType->id()));
     addChild(SelectiveDwrfReader::build(
-        childRequestedType, childDataType, childParams, *childSpec));
+        childRequestedType, childFileType, childParams, *childSpec));
     childSpec->setSubscript(children_.size() - 1);
   }
 }
diff --git a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.h b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.h
index d76b2f632c830..4d55fd74bf290 100644
--- a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.h
@@ -25,19 +25,19 @@ class SelectiveStructColumnReaderBase
     : public dwio::common::SelectiveStructColumnReaderBase {
  public:
   SelectiveStructColumnReaderBase(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec,
       bool isRoot = false)
       : dwio::common::SelectiveStructColumnReaderBase(
             requestedType,
-            dataType,
+            fileType,
             params,
             scanSpec,
             isRoot),
         rowsPerRowGroup_(formatData_->rowsPerRowGroup().value()) {
-    VELOX_CHECK_EQ(fileType_->id(), dataType->id(), "working on the same node");
+    VELOX_CHECK_EQ(fileType_->id(), fileType->id(), "working on the same node");
   }
 
   void seekTo(vector_size_t offset, bool readsNullsOnly) override;
@@ -48,11 +48,11 @@ class SelectiveStructColumnReaderBase
       readOffset_ = index * rowsPerRowGroup_;
       return;
     }
+
     // There may be a nulls stream but no other streams for the struct.
     formatData_->seekToRowGroup(index);
-    // Set the read offset recursively. Do this before seeking the
-    // children because list/map children will reset the offsets for
-    // their children.
+    // Set the read offset recursively. Do this before seeking the children
+    // because list/map children will reset the offsets for their children.
     setReadOffsetRecursive(index * rowsPerRowGroup_);
     for (auto& child : children_) {
       child->seekToRowGroup(index);
@@ -66,8 +66,8 @@ class SelectiveStructColumnReaderBase
     if (!reader->isTopLevel()) {
       return;
     }
-    auto rowGroup = reader->readOffset() / rowsPerRowGroup_;
-    auto nextRowGroup = offset / rowsPerRowGroup_;
+    const auto rowGroup = reader->readOffset() / rowsPerRowGroup_;
+    const auto nextRowGroup = offset / rowsPerRowGroup_;
     if (nextRowGroup > rowGroup) {
       reader->seekToRowGroup(nextRowGroup);
       reader->setReadOffset(nextRowGroup * rowsPerRowGroup_);
@@ -78,10 +78,11 @@ class SelectiveStructColumnReaderBase
   const int32_t rowsPerRowGroup_;
 };
 
-struct SelectiveStructColumnReader : SelectiveStructColumnReaderBase {
+class SelectiveStructColumnReader : public SelectiveStructColumnReaderBase {
+ public:
   SelectiveStructColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec,
       bool isRoot = false);
diff --git a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
index 5819eecacab64..689584d706f1f 100644
--- a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
@@ -23,27 +23,29 @@ namespace facebook::velox::dwrf {
 using namespace dwio::common;
 
 SelectiveTimestampColumnReader::SelectiveTimestampColumnReader(
-    const std::shared_ptr<const TypeWithId>& nodeType,
+    const std::shared_ptr<const TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec)
-    : SelectiveColumnReader(nodeType->type(), params, scanSpec, nodeType) {
+    : SelectiveColumnReader(fileType->type(), fileType, params, scanSpec),
+      precision_(
+          params.stripeStreams().rowReaderOptions().timestampPrecision()) {
   EncodingKey encodingKey{fileType_->id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
   version_ = convertRleVersion(stripe.getEncoding(encodingKey).kind());
   auto data = encodingKey.forKind(proto::Stream_Kind_DATA);
   bool vints = stripe.getUseVInts(data);
-  seconds_ = createRleDecoder</*isSigned*/ true>(
+  seconds_ = createRleDecoder</*isSigned=*/true>(
       stripe.getStream(data, params.streamLabels().label(), true),
       version_,
-      memoryPool_,
+      *memoryPool_,
       vints,
       LONG_BYTE_SIZE);
   auto nanoData = encodingKey.forKind(proto::Stream_Kind_NANO_DATA);
   bool nanoVInts = stripe.getUseVInts(nanoData);
-  nano_ = createRleDecoder</*isSigned*/ false>(
+  nano_ = createRleDecoder</*isSigned=*/false>(
       stripe.getStream(nanoData, params.streamLabels().label(), true),
       version_,
-      memoryPool_,
+      *memoryPool_,
       nanoVInts,
       LONG_BYTE_SIZE);
 }
@@ -66,7 +68,7 @@ void SelectiveTimestampColumnReader::seekToRowGroup(uint32_t index) {
 
 void SelectiveTimestampColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   prepareRead<int64_t>(offset, rows, incomingNulls);
   VELOX_CHECK(
@@ -76,7 +78,7 @@ void SelectiveTimestampColumnReader::read(
       resultNulls_->capacity() * 8 < rows.size()) {
     // Make sure a dedicated resultNulls_ is allocated with enough capacity as
     // RleDecoder always assumes it is available.
-    resultNulls_ = AlignedBuffer::allocate<bool>(rows.size(), &memoryPool_);
+    resultNulls_ = AlignedBuffer::allocate<bool>(rows.size(), memoryPool_);
     rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
   }
   bool isDense = rows.back() == rows.size() - 1;
@@ -91,7 +93,7 @@ void SelectiveTimestampColumnReader::read(
 template <bool isDense>
 void SelectiveTimestampColumnReader::readHelper(
     common::Filter* filter,
-    RowSet rows) {
+    const RowSet& rows) {
   ExtractToReader extractValues(this);
   common::AlwaysTrue alwaysTrue;
   DirectRleColumnVisitor<
@@ -110,7 +112,7 @@ void SelectiveTimestampColumnReader::readHelper(
   // Save the seconds into their own buffer before reading nanos into
   // 'values_'
   dwio::common::ensureCapacity<uint64_t>(
-      secondsValues_, numValues_, &memoryPool_);
+      secondsValues_, numValues_, memoryPool_);
   secondsValues_->setSize(numValues_ * sizeof(int64_t));
   memcpy(
       secondsValues_->asMutable<char>(),
@@ -131,7 +133,7 @@ void SelectiveTimestampColumnReader::readHelper(
   const auto rawNulls = nullsInReadRange_
       ? (isDense ? nullsInReadRange_->as<uint64_t>() : rawResultNulls_)
       : nullptr;
-  auto tsValues = AlignedBuffer::allocate<Timestamp>(numValues_, &memoryPool_);
+  auto tsValues = AlignedBuffer::allocate<Timestamp>(numValues_, memoryPool_);
   auto rawTs = tsValues->asMutable<Timestamp>();
 
   for (vector_size_t i = 0; i < numValues_; i++) {
@@ -148,6 +150,16 @@ void SelectiveTimestampColumnReader::readHelper(
       if (seconds < 0 && nanos != 0) {
         seconds -= 1;
       }
+      switch (precision_) {
+        case TimestampPrecision::kMilliseconds:
+          nanos = nanos / 1'000'000 * 1'000'000;
+          break;
+        case TimestampPrecision::kMicroseconds:
+          nanos = nanos / 1'000 * 1'000;
+          break;
+        case TimestampPrecision::kNanoseconds:
+          break;
+      }
       rawTs[i] = Timestamp(seconds, nanos);
     }
   }
@@ -184,7 +196,7 @@ void SelectiveTimestampColumnReader::readHelper(
 
 void SelectiveTimestampColumnReader::processNulls(
     const bool isNull,
-    const RowSet rows,
+    const RowSet& rows,
     const uint64_t* rawNulls) {
   if (!rawNulls) {
     return;
@@ -215,7 +227,7 @@ void SelectiveTimestampColumnReader::processNulls(
 
 void SelectiveTimestampColumnReader::processFilter(
     const common::Filter* filter,
-    const RowSet rows,
+    const RowSet& rows,
     const uint64_t* rawNulls) {
   auto rawTs = values_->asMutable<Timestamp>();
 
@@ -245,7 +257,9 @@ void SelectiveTimestampColumnReader::processFilter(
   }
 }
 
-void SelectiveTimestampColumnReader::getValues(RowSet rows, VectorPtr* result) {
+void SelectiveTimestampColumnReader::getValues(
+    const RowSet& rows,
+    VectorPtr* result) {
   getFlatValues<Timestamp, Timestamp>(rows, result, fileType_->type(), true);
 }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.h b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.h
index 7ee1f13714a22..b3f1b8e9c845d 100644
--- a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.h
@@ -28,29 +28,33 @@ class SelectiveTimestampColumnReader
   using ValueType = int64_t;
 
   SelectiveTimestampColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
   void seekToRowGroup(uint32_t index) override;
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override;
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
-  void getValues(RowSet rows, VectorPtr* result) override;
+  void getValues(const RowSet& rows, VectorPtr* result) override;
 
  private:
   template <bool isDense>
-  void readHelper(common::Filter* filter, RowSet rows);
+  void readHelper(common::Filter* filter, const RowSet& rows);
 
   void
-  processNulls(const bool isNull, const RowSet rows, const uint64_t* rawNulls);
+  processNulls(const bool isNull, const RowSet& rows, const uint64_t* rawNulls);
   void processFilter(
       const common::Filter* filter,
-      const RowSet rows,
+      const RowSet& rows,
       const uint64_t* rawNulls);
 
+  const TimestampPrecision precision_;
+
   std::unique_ptr<dwio::common::IntDecoder</*isSigned*/ true>> seconds_;
   std::unique_ptr<dwio::common::IntDecoder</*isSigned*/ false>> nano_;
 
diff --git a/velox/dwio/dwrf/reader/StreamLabels.cpp b/velox/dwio/dwrf/reader/StreamLabels.cpp
index ac6e97fcffab4..cdfe65317c175 100644
--- a/velox/dwio/dwrf/reader/StreamLabels.cpp
+++ b/velox/dwio/dwrf/reader/StreamLabels.cpp
@@ -24,13 +24,13 @@ std::string_view StreamLabels::label() const {
 
 StreamLabels StreamLabels::append(std::string_view suffix) const {
   const size_t bufSize = label_.size() + suffix.size() + 1;
-  auto buffer = pool_.allocateFixed(bufSize);
+  auto* buffer = pool_.allocateFixed(bufSize);
   if (!label_.empty()) {
-    memcpy(buffer, label_.data(), label_.size());
+    ::memcpy(buffer, label_.data(), label_.size());
   }
   buffer[label_.size()] = '/';
   if (!suffix.empty()) {
-    memcpy(buffer + label_.size() + 1, suffix.data(), suffix.size());
+    ::memcpy(buffer + label_.size() + 1, suffix.data(), suffix.size());
   }
   return StreamLabels(pool_, {buffer, bufSize});
 }
diff --git a/velox/dwio/dwrf/reader/StripeDictionaryCache.cpp b/velox/dwio/dwrf/reader/StripeDictionaryCache.cpp
index 1a8c9418d6b28..16e0f4c9f5eff 100644
--- a/velox/dwio/dwrf/reader/StripeDictionaryCache.cpp
+++ b/velox/dwio/dwrf/reader/StripeDictionaryCache.cpp
@@ -23,10 +23,10 @@ StripeDictionaryCache::DictionaryEntry::DictionaryEntry(
 
 BufferPtr StripeDictionaryCache::DictionaryEntry::getDictionaryBuffer(
     velox::memory::MemoryPool* pool) {
-  if (!dictionaryBuffer_) {
+  folly::call_once(onceFlag_, [&]() {
     dictionaryBuffer_ = dictGen_(pool);
     dictGen_ = nullptr;
-  }
+  });
   return dictionaryBuffer_;
 }
 
@@ -35,14 +35,15 @@ StripeDictionaryCache::StripeDictionaryCache(velox::memory::MemoryPool* pool)
 
 // It might be more elegant to pass in a StripeStream here instead.
 void StripeDictionaryCache::registerIntDictionary(
-    const EncodingKey& ek,
+    const EncodingKey& encodingKey,
     folly::Function<BufferPtr(velox::memory::MemoryPool*)>&& dictGen) {
   intDictionaryFactories_.emplace(
-      ek, std::make_unique<DictionaryEntry>(std::move(dictGen)));
+      encodingKey, std::make_unique<DictionaryEntry>(std::move(dictGen)));
 }
 
-BufferPtr StripeDictionaryCache::getIntDictionary(const EncodingKey& ek) {
-  return intDictionaryFactories_.at(ek)->getDictionaryBuffer(pool_);
+BufferPtr StripeDictionaryCache::getIntDictionary(
+    const EncodingKey& encodingKey) {
+  return intDictionaryFactories_.at(encodingKey)->getDictionaryBuffer(pool_);
 }
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/StripeDictionaryCache.h b/velox/dwio/dwrf/reader/StripeDictionaryCache.h
index 51e76b7af82ce..df5f834c12a2c 100644
--- a/velox/dwio/dwrf/reader/StripeDictionaryCache.h
+++ b/velox/dwio/dwrf/reader/StripeDictionaryCache.h
@@ -18,6 +18,7 @@
 
 #include <folly/Function.h>
 
+#include "folly/synchronization/CallOnce.h"
 #include "velox/common/base/GTestMacros.h"
 #include "velox/dwio/common/IntDecoder.h"
 #include "velox/dwio/dwrf/common/Common.h"
@@ -25,9 +26,18 @@
 
 namespace facebook::velox::dwrf {
 class StripeDictionaryCache {
-  // This could be potentially made an interface to be shared for
-  // string dictionaries. However, we will need a union return type
-  // in that case.
+ public:
+  explicit StripeDictionaryCache(velox::memory::MemoryPool* pool);
+
+  void registerIntDictionary(
+      const EncodingKey& encodingKey,
+      folly::Function<BufferPtr(velox::memory::MemoryPool*)>&& dictGen);
+
+  BufferPtr getIntDictionary(const EncodingKey& encodingKey);
+
+ private:
+  // This could be potentially made an interface to be shared for string
+  // dictionaries. However, we will need a union return type in that case.
   class DictionaryEntry {
    public:
     explicit DictionaryEntry(
@@ -38,27 +48,18 @@ class StripeDictionaryCache {
    private:
     folly::Function<BufferPtr(velox::memory::MemoryPool*)> dictGen_;
     BufferPtr dictionaryBuffer_;
+    folly::once_flag onceFlag_;
   };
 
- public:
-  explicit StripeDictionaryCache(velox::memory::MemoryPool* pool);
-
-  void registerIntDictionary(
-      const EncodingKey& ek,
-      folly::Function<BufferPtr(velox::memory::MemoryPool*)>&& dictGen);
-
-  BufferPtr getIntDictionary(const EncodingKey& ek);
-
- private:
   // This is typically the reader's memory pool.
-  memory::MemoryPool* pool_;
+  memory::MemoryPool* const pool_;
   std::unordered_map<
       EncodingKey,
       std::unique_ptr<DictionaryEntry>,
       EncodingKeyHash>
       intDictionaryFactories_;
 
-  VELOX_FRIEND_TEST(TestStripeDictionaryCache, RegisterDictionary);
+  VELOX_FRIEND_TEST(StripeDictionaryCacheTest, RegisterDictionary);
 };
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/StripeMetadataCache.h b/velox/dwio/dwrf/reader/StripeMetadataCache.h
index 2ec7216e28de7..eaa9d671f9861 100644
--- a/velox/dwio/dwrf/reader/StripeMetadataCache.h
+++ b/velox/dwio/dwrf/reader/StripeMetadataCache.h
@@ -59,33 +59,28 @@ class StripeMetadataCache {
   std::unique_ptr<dwio::common::SeekableInputStream> get(
       StripeCacheMode mode,
       uint64_t stripeIndex) const {
-    auto index = getIndex(mode, stripeIndex);
-    if (index != INVALID_INDEX) {
-      auto offset = offsets_[index];
-      if (buffer_) {
-        return std::make_unique<dwio::common::SeekableArrayInputStream>(
-            buffer_->data() + offset, offsets_[index + 1] - offset);
-      } else {
-        auto clone =
-            reinterpret_cast<dwio::common::CacheInputStream*>(input_.get())
-                ->clone();
-        clone->Skip(offset);
-        clone->setRemainingBytes(offsets_[index + 1] - offset);
-        return clone;
-      }
+    const auto index = getIndex(mode, stripeIndex);
+    if (index == INVALID_INDEX) {
+      return {};
+    }
+
+    const auto offset = offsets_[index];
+    if (buffer_ != nullptr) {
+      return std::make_unique<dwio::common::SeekableArrayInputStream>(
+          buffer_->data() + offset, offsets_[index + 1] - offset);
     }
-    return {};
+
+    auto clone = reinterpret_cast<dwio::common::CacheInputStream*>(input_.get())
+                     ->clone();
+    clone->Skip(offset);
+    clone->setRemainingBytes(offsets_[index + 1] - offset);
+    return clone;
   }
 
  private:
-  StripeCacheMode mode_;
-  std::shared_ptr<dwio::common::DataBuffer<char>> buffer_;
-  std::unique_ptr<dwio::common::SeekableInputStream> input_;
-  std::vector<uint32_t> offsets_;
-
   uint64_t getIndex(StripeCacheMode mode, uint64_t stripeIndex) const {
     if (mode_ & mode) {
-      uint64_t index =
+      const uint64_t index =
           (mode_ == mode ? stripeIndex
                          : stripeIndex * 2 + mode - StripeCacheMode::INDEX);
       // offsets has N + 1 items, so length[N] = offset[N+1]- offset[N]
@@ -103,6 +98,11 @@ class StripeMetadataCache {
     offsets.assign(from.begin(), from.end());
     return offsets;
   }
+
+  const StripeCacheMode mode_;
+  const std::shared_ptr<dwio::common::DataBuffer<char>> buffer_;
+  const std::unique_ptr<dwio::common::SeekableInputStream> input_;
+  const std::vector<uint32_t> offsets_;
 };
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/StripeReaderBase.cpp b/velox/dwio/dwrf/reader/StripeReaderBase.cpp
index 23cdbe15d0e1c..611318d468862 100644
--- a/velox/dwio/dwrf/reader/StripeReaderBase.cpp
+++ b/velox/dwio/dwrf/reader/StripeReaderBase.cpp
@@ -23,31 +23,28 @@ using dwio::common::LogType;
 // preload is not considered or mutated if stripe has already been fetched. e.g.
 // if fetchStripe(0, false) is called, result will be cached and fetchStripe(0,
 // true) will reuse the result without considering the new preload directive
-bool StripeReaderBase::fetchStripe(uint32_t index, bool& preload) {
-  DWIO_ENSURE(canLoad_);
-  if (prefetchedStripes_.rlock()->contains(index)) {
-    VLOG(1) << "Stripe data already fetched at index: " << index;
-    return false;
-  }
-  auto& footer = reader_->getFooter();
-  DWIO_ENSURE_LT(index, footer.stripesSize(), "invalid stripe index");
-  auto stripe = footer.stripes(index);
-  auto& cache = reader_->getMetadataCache();
+std::unique_ptr<const StripeMetadata> StripeReaderBase::fetchStripe(
+    uint32_t index,
+    bool& preload) const {
+  auto& fileFooter = reader_->footer();
+  VELOX_CHECK_LT(index, fileFooter.stripesSize(), "invalid stripe index");
+  auto stripe = fileFooter.stripes(index);
+  auto& cache = reader_->metadataCache();
 
   uint64_t offset = stripe.offset();
   uint64_t length =
       stripe.indexLength() + stripe.dataLength() + stripe.footerLength();
 
-  std::unique_ptr<dwio::common::BufferedInput> prefetchedStripe;
-  if (reader_->getBufferedInput().isBuffered(offset, length)) {
+  std::unique_ptr<dwio::common::BufferedInput> stripeInput;
+  if (reader_->bufferedInput().isBuffered(offset, length)) {
     preload = true;
-    prefetchedStripe = nullptr;
+    stripeInput = nullptr;
   } else {
-    prefetchedStripe = reader_->getBufferedInput().clone();
+    stripeInput = reader_->bufferedInput().clone();
     if (preload) {
       // If metadata cache exists, adjust read position to avoid re-reading
       // metadata sections
-      if (cache) {
+      if (cache != nullptr) {
         if (cache->has(StripeCacheMode::INDEX, index)) {
           offset += stripe.indexLength();
           length -= stripe.indexLength();
@@ -57,88 +54,72 @@ bool StripeReaderBase::fetchStripe(uint32_t index, bool& preload) {
         }
       }
 
-      prefetchedStripe->enqueue({offset, length, "stripe"});
-      prefetchedStripe->load(LogType::STRIPE);
+      stripeInput->enqueue({offset, length, "stripe"});
+      stripeInput->load(LogType::STRIPE);
     }
   }
 
   // load stripe footer
-  std::unique_ptr<dwio::common::SeekableInputStream> stream;
+  std::unique_ptr<dwio::common::SeekableInputStream> footerStream;
   if (cache) {
-    stream = cache->get(StripeCacheMode::FOOTER, index);
+    footerStream = cache->get(StripeCacheMode::FOOTER, index);
   }
 
-  if (!stream) {
-    dwio::common::BufferedInput& bi =
-        prefetchedStripe ? *prefetchedStripe : reader_->getBufferedInput();
-    stream = bi.read(
+  if (!footerStream) {
+    dwio::common::BufferedInput& bufferInput =
+        (stripeInput != nullptr) ? *stripeInput : reader_->bufferedInput();
+    footerStream = bufferInput.read(
         stripe.offset() + stripe.indexLength() + stripe.dataLength(),
         stripe.footerLength(),
         LogType::STRIPE_FOOTER);
   }
 
-  proto::StripeFooter* stripeFooter;
-
-  // todo: reuse footer memory in cases where prefetch does not occur, or we
-  // have finished processing a stripe and can reuse its footer's memory
-  stripeFooter = google::protobuf::Arena::CreateMessage<proto::StripeFooter>(
-      reader_->arena());
-
-  auto streamDebugInfo = fmt::format("Stripe {} Footer ", index);
-  ProtoUtils::readProtoInto<proto::StripeFooter>(
-      reader_->createDecompressedStream(std::move(stream), streamDebugInfo),
-      stripeFooter);
-
-  auto prefetchedStripeBase = std::make_shared<PrefetchedStripeBase>();
+  const auto streamDebugInfo = fmt::format("Stripe {} Footer ", index);
 
-  prefetchedStripeBase->footer = stripeFooter;
-  prefetchedStripeBase->stripeInput = std::move(prefetchedStripe);
+  auto arena = std::make_shared<google::protobuf::Arena>();
+  auto* rawFooter =
+      google::protobuf::Arena::CreateMessage<proto::StripeFooter>(arena.get());
+  ProtoUtils::readProtoInto(
+      reader_->createDecompressedStream(
+          std::move(footerStream), streamDebugInfo),
+      rawFooter);
+  std::shared_ptr<proto::StripeFooter> stripeFooter(
+      rawFooter, [arena = std::move(arena)](auto*) { arena->Reset(); });
 
-  prefetchedStripes_.wlock()->operator[](index) = prefetchedStripeBase;
+  auto decryptionHandler = std::make_unique<encryption::DecryptionHandler>(
+      reader_->decryptionHandler());
 
-  return true;
-}
-
-// Sets stripeInput_ to a new BufferedInput (or null, if data is already
-// buffered in ReaderBase), and loads stripe footer and encryption keys
-StripeInformationWrapper StripeReaderBase::loadStripe(
-    uint32_t index,
-    bool& preload /* load the whole stripe if true*/) {
-  DWIO_ENSURE(canLoad_);
-  auto& footer = reader_->getFooter();
-  DWIO_ENSURE_LT(index, footer.stripesSize(), "invalid stripe index");
-  auto stripe = footer.stripes(index);
-
-  fetchStripe(index, preload);
-  auto prefetchedStripeBase =
-      prefetchedStripes_.withRLock([&](auto& prefetchedStripes) {
-        auto prefetchedStatesIt = prefetchedStripes.find(index);
-        DWIO_ENSURE(prefetchedStatesIt != prefetchedStripes.end());
-        return prefetchedStatesIt->second;
-      });
-
-  footer_ = prefetchedStripeBase->footer;
-  stripeInput_ = std::move(prefetchedStripeBase->stripeInput);
   // refresh stripe encryption key if necessary
-  loadEncryptionKeys(index);
-  lastStripeIndex_ = index;
-  return stripe;
+  loadEncryptionKeys(index, *stripeFooter, stripe, *decryptionHandler);
+  return stripeInput == nullptr ? std::make_unique<const StripeMetadata>(
+                                      &reader_->bufferedInput(),
+                                      std::move(stripeFooter),
+                                      std::move(decryptionHandler),
+                                      std::move(stripe))
+                                : std::make_unique<const StripeMetadata>(
+                                      std::move(stripeInput),
+                                      std::move(stripeFooter),
+                                      std::move(decryptionHandler),
+                                      std::move(stripe));
 }
 
-void StripeReaderBase::loadEncryptionKeys(uint32_t index) {
-  if (!handler_->isEncrypted()) {
+void StripeReaderBase::loadEncryptionKeys(
+    uint32_t index,
+    const proto::StripeFooter& stripeFooter,
+    const StripeInformationWrapper& stripeInfo,
+    encryption::DecryptionHandler& handler) const {
+  if (!handler.isEncrypted()) {
     return;
   }
 
-  DWIO_ENSURE_EQ(
-      footer_->encryptiongroups_size(), handler_->getEncryptionGroupCount());
-  auto& footer = reader_->getFooter();
-  DWIO_ENSURE_LT(index, footer.stripesSize(), "invalid stripe index");
+  VELOX_CHECK_EQ(
+      stripeFooter.encryptiongroups_size(), handler.getEncryptionGroupCount());
+  const auto& fileFooter = reader_->footer();
+  VELOX_CHECK_LT(index, fileFooter.stripesSize(), "invalid stripe index");
 
-  auto stripe = footer.stripes(index);
   // If current stripe has keys, load these keys.
-  if (stripe.keyMetadataSize() > 0) {
-    handler_->setKeys(stripe.keyMetadata());
+  if (stripeInfo.keyMetadataSize() > 0) {
+    handler.setKeys(stripeInfo.keyMetadata());
   } else {
     // If current stripe doesn't have keys, then:
     //  1. If it's sequential read (ie. we've just finished reading one stripe
@@ -147,20 +128,19 @@ void StripeReaderBase::loadEncryptionKeys(uint32_t index) {
     //  2. If it's not sequential read (which means we performed a skip/seek
     //  into a random stripe in the file), we need to sequentially lookup
     //  previous stripes, until we find a stripe with keys.
-    DWIO_ENSURE_GT(index, 0, "first stripe must have key");
-    bool isSequentialRead =
-        (lastStripeIndex_ && lastStripeIndex_.value() == index - 1);
-    if (!isSequentialRead) {
-      uint32_t prevIndex = index - 1;
-      while (true) {
-        auto prev = footer.stripes(prevIndex);
-        if (prev.keyMetadataSize() > 0) {
-          handler_->setKeys(prev.keyMetadata());
-          break;
-        }
-        DWIO_ENSURE_GE(prevIndex, 0, "key not found");
-        --prevIndex;
+    //
+    // But, since we are enabling parallel loads now, let's not rely on
+    // sequential order. Let's apply (2).
+    VELOX_CHECK_GT(index, 0, "first stripe must have key");
+
+    uint32_t prevIndex = index - 1;
+    while (true) {
+      const auto prevStripeInfo = fileFooter.stripes(prevIndex);
+      if (prevStripeInfo.keyMetadataSize() > 0) {
+        handler.setKeys(prevStripeInfo.keyMetadata());
+        break;
       }
+      --prevIndex;
     }
   }
 }
diff --git a/velox/dwio/dwrf/reader/StripeReaderBase.h b/velox/dwio/dwrf/reader/StripeReaderBase.h
index 1f89683241896..6ca5d6fd7319a 100644
--- a/velox/dwio/dwrf/reader/StripeReaderBase.h
+++ b/velox/dwio/dwrf/reader/StripeReaderBase.h
@@ -23,54 +23,44 @@
 
 namespace facebook::velox::dwrf {
 
+struct StripeMetadata {
+  dwio::common::BufferedInput* stripeInput;
+  std::shared_ptr<const proto::StripeFooter> footer;
+  std::unique_ptr<encryption::DecryptionHandler> decryptionHandler;
+  StripeInformationWrapper stripeInfo;
+
+  StripeMetadata(
+      std::shared_ptr<dwio::common::BufferedInput> _stripeInput,
+      std::shared_ptr<const proto::StripeFooter> _footer,
+      std::unique_ptr<encryption::DecryptionHandler> _decryptionHandler,
+      StripeInformationWrapper _stripeInfo)
+      : stripeInput{_stripeInput.get()},
+        footer{std::move(_footer)},
+        decryptionHandler{std::move(_decryptionHandler)},
+        stripeInfo{std::move(_stripeInfo)},
+        stripeInputOwned_{std::move(_stripeInput)} {}
+
+  StripeMetadata(
+      dwio::common::BufferedInput* _stripeInput,
+      std::shared_ptr<const proto::StripeFooter> _footer,
+      std::unique_ptr<encryption::DecryptionHandler> _decryptionHandler,
+      StripeInformationWrapper _stripeInfo)
+      : stripeInput{_stripeInput},
+        footer{std::move(_footer)},
+        decryptionHandler{std::move(_decryptionHandler)},
+        stripeInfo{std::move(_stripeInfo)} {}
+
+ private:
+  const std::shared_ptr<dwio::common::BufferedInput> stripeInputOwned_;
+};
+
 class StripeReaderBase {
  public:
   explicit StripeReaderBase(const std::shared_ptr<ReaderBase>& reader)
-      : reader_{reader},
-        handler_{std::make_unique<encryption::DecryptionHandler>(
-            reader_->getDecryptionHandler())} {}
-
-  // for testing purpose
-  StripeReaderBase(
-      const std::shared_ptr<ReaderBase>& reader,
-      const proto::StripeFooter* footer)
-      : reader_{reader},
-        handler_{std::make_unique<encryption::DecryptionHandler>(
-            reader_->getDecryptionHandler())},
-        footer_{const_cast<proto::StripeFooter*>(footer)},
-        canLoad_{false} {
-    // The footer is expected to be arena allocated and to stay
-    // live for the lifetime of 'this'.
-    DWIO_ENSURE(footer->GetArena());
-  }
+      : reader_{reader} {}
 
   virtual ~StripeReaderBase() = default;
 
-  // Set state to be ready for next stripe, loading stripe information if not
-  // prefetched
-  StripeInformationWrapper loadStripe(uint32_t index, bool& preload);
-
-  // Get footer of stripe currently being read
-  const proto::StripeFooter& getStripeFooter() const {
-    DWIO_ENSURE_NOT_NULL(footer_, "stripe hasn't been initialized for read");
-    return *footer_;
-  }
-
-  // Get footer of stripe at index i, if it's been loaded.
-  const proto::StripeFooter& getStripeFooter(uint32_t index) const {
-    const proto::StripeFooter* result = nullptr;
-    prefetchedStripes_.withRLock([&](auto& prefetchedStripes) {
-      auto stateIt = prefetchedStripes.find(index);
-      DWIO_ENSURE(stateIt != prefetchedStripes.end());
-      result = stateIt->second->footer;
-    });
-    return *result;
-  }
-
-  dwio::common::BufferedInput& getStripeInput() const {
-    return stripeInput_ ? *stripeInput_ : reader_->getBufferedInput();
-  }
-
   ReaderBase& getReader() const {
     return *reader_;
   }
@@ -79,53 +69,19 @@ class StripeReaderBase {
     return reader_;
   }
 
-  const encryption::DecryptionHandler& getDecryptionHandler() const {
-    return *handler_;
-  }
-
-  /**
-  Populates prefetchedStripes_ with a BufferedInput for the given stripe index.
-  If readerbase should be used instead, set value to null.
-  Input value of preload can be mutated in case where readerBase had stripe
-  preloaded, but preload flag was not provided
-  is preload is false and stripe isn't prebuffered in readerbase, this function
-  returns having set prefetchedStripes_[index] to an appropriate value to be
-  LATER fully loaded by RowReader, after StripeStreams are built.
-  @return true if prefetch was successful
-  */
-  bool fetchStripe(uint32_t index, bool& preload);
-
- protected:
-  struct PrefetchedStripeBase {
-    std::unique_ptr<dwio::common::BufferedInput> stripeInput;
-    proto::StripeFooter* footer;
-  };
-
-  std::shared_ptr<PrefetchedStripeBase> getStripeBase(uint32_t index) {
-    return prefetchedStripes_.rlock()->at(index);
-  }
-
-  bool freeStripeAt(uint32_t index) {
-    return prefetchedStripes_.wlock()->erase(index) == 1;
-  }
+  std::unique_ptr<const StripeMetadata> fetchStripe(
+      uint32_t index,
+      bool& preload) const;
 
  private:
+  // stripeFooter default null arg should only be used for testing.
+  void loadEncryptionKeys(
+      uint32_t index,
+      const proto::StripeFooter& stripeFooter,
+      const StripeInformationWrapper& stripeInfo,
+      encryption::DecryptionHandler& handler) const;
+
   const std::shared_ptr<ReaderBase> reader_;
-  const std::unique_ptr<encryption::DecryptionHandler> handler_;
-  std::unique_ptr<dwio::common::BufferedInput> stripeInput_;
-  std::optional<uint32_t> lastStripeIndex_;
-  proto::StripeFooter* footer_ = nullptr;
-  bool canLoad_{true};
-
-  // Map containing stripe blobs which have already been loaded.
-  // A null value represents that the stripe at the key is loaded in
-  // reader_'s BufferedInput. No entry for a given key means that
-  // the stripe has not been loaded yet, or has already been processed.
-  folly::Synchronized<
-      folly::F14FastMap<uint32_t, std::shared_ptr<PrefetchedStripeBase>>>
-      prefetchedStripes_;
-
-  void loadEncryptionKeys(uint32_t index);
 
   friend class StripeLoadKeysTest;
 };
diff --git a/velox/dwio/dwrf/reader/StripeStream.cpp b/velox/dwio/dwrf/reader/StripeStream.cpp
index b785e9233bbb5..0ad5d7fc5125d 100644
--- a/velox/dwio/dwrf/reader/StripeStream.cpp
+++ b/velox/dwio/dwrf/reader/StripeStream.cpp
@@ -17,7 +17,6 @@
 #include <folly/ScopeGuard.h>
 #include <folly/container/F14Set.h>
 
-#include "velox/common/base/BitSet.h"
 #include "velox/dwio/common/exception/Exception.h"
 #include "velox/dwio/dwrf/common/DecoderUtil.h"
 #include "velox/dwio/dwrf/common/wrap/coded-stream-wrapper.h"
@@ -33,9 +32,9 @@ namespace {
 template <typename IsProjected>
 void findProjectedNodes(
     BitSet& projectedNodes,
-    const TypeWithId& expected,
-    const TypeWithId& actual,
-    IsProjected isProjected) {
+    const dwio::common::TypeWithId& expected,
+    const dwio::common::TypeWithId& actual,
+    IsProjected&& isProjected) {
   // we don't need to perform schema compatibility check since reader should
   // have already done that before reaching here.
   // if a leaf node is projected, all the intermediate node from root to the
@@ -53,7 +52,7 @@ void findProjectedNodes(
             projectedNodes,
             *expected.childAt(i),
             *actual.childAt(i),
-            isProjected);
+            std::forward<IsProjected>(isProjected));
       }
       break;
     }
@@ -62,19 +61,19 @@ void findProjectedNodes(
           projectedNodes,
           *expected.childAt(0),
           *actual.childAt(0),
-          isProjected);
+          std::forward<IsProjected>(isProjected));
       break;
     case TypeKind::MAP: {
       findProjectedNodes(
           projectedNodes,
           *expected.childAt(0),
           *actual.childAt(0),
-          isProjected);
+          std::forward<IsProjected>(isProjected));
       findProjectedNodes(
           projectedNodes,
           *expected.childAt(1),
           *actual.childAt(1),
-          isProjected);
+          std::forward<IsProjected>(isProjected));
       break;
     }
     default:
@@ -105,115 +104,128 @@ BufferPtr readDict(
 
 std::function<BufferPtr()>
 StripeStreamsBase::getIntDictionaryInitializerForNode(
-    const EncodingKey& ek,
+    const EncodingKey& encodingKey,
     uint64_t elementWidth,
     const StreamLabels& streamLabels,
     uint64_t dictionaryWidth) {
   // Create local copy for manipulation
-  EncodingKey localEk{ek};
-  auto dictData = localEk.forKind(proto::Stream_Kind_DICTIONARY_DATA);
-  auto dataStream = getStream(dictData, streamLabels.label(), false);
-  auto dictionarySize = getEncoding(localEk).dictionarysize();
+  EncodingKey dictEncodingKey{encodingKey};
+  auto dictDataSi = dictEncodingKey.forKind(proto::Stream_Kind_DICTIONARY_DATA);
+  auto dictDataStream = getStream(dictDataSi, streamLabels.label(), false);
+  const auto dictionarySize = getEncoding(dictEncodingKey).dictionarysize();
   // Try fetching shared dictionary streams instead.
-  if (!dataStream) {
+  if (!dictDataStream) {
     // Get the label of the top level column, since this dictionary is shared by
-    // the entire column
+    // the entire column.
     auto label = streamLabels.label();
     // Shouldn't be empty, but just in case
     if (!label.empty()) {
       // Ex: "/5/1759392083" -> "/5"
       label = label.substr(0, label.find('/', 1));
     }
-    localEk = EncodingKey(ek.node(), 0);
-    dictData = localEk.forKind(proto::Stream_Kind_DICTIONARY_DATA);
-    dataStream = getStream(dictData, label, false);
+    dictEncodingKey = EncodingKey(encodingKey.node(), 0);
+    dictDataSi = dictEncodingKey.forKind(proto::Stream_Kind_DICTIONARY_DATA);
+    dictDataStream = getStream(dictDataSi, label, false);
   }
-  bool dictVInts = getUseVInts(dictData);
-  DWIO_ENSURE(dataStream.get());
+
+  const bool dictVInts = getUseVInts(dictDataSi);
+  VELOX_CHECK_NOT_NULL(dictDataStream);
   stripeDictionaryCache_->registerIntDictionary(
-      localEk,
+      dictEncodingKey,
       [dictReader = createDirectDecoder</* isSigned = */ true>(
-           std::move(dataStream), dictVInts, elementWidth),
+           std::move(dictDataStream), dictVInts, elementWidth),
        dictionaryWidth,
        dictionarySize](velox::memory::MemoryPool* pool) mutable {
         return VELOX_WIDTH_DISPATCH(
             dictionaryWidth, readDict, dictReader.get(), dictionarySize, pool);
       });
-  return [&dictCache = *stripeDictionaryCache_, localEk]() {
+  return [&dictCache = *stripeDictionaryCache_, dictEncodingKey]() {
     // If this is not flat map or if dictionary is not shared, return as is
-    return dictCache.getIntDictionary(localEk);
+    return dictCache.getIntDictionary(dictEncodingKey);
   };
 }
 
 void StripeStreamsImpl::loadStreams() {
-  auto& footer = *readState_->footer;
-
-  // HACK!!!
-  // Column selector filters based on requested schema (ie, table schema), while
-  // we need filter based on file schema. As a result we cannot call
-  // shouldReadNode directly. Instead, build projected nodes set based on node
-  // id from file schema. Column selector should really be fixed to handle file
-  // schema properly
-  BitSet projectedNodes(0);
-  auto expected = selector_.getSchemaWithId();
-  auto actual = readState_->readerBase->getSchemaWithId();
-  findProjectedNodes(projectedNodes, *expected, *actual, [&](uint32_t node) {
-    return selector_.shouldReadNode(node);
-  });
-
-  auto addStream = [&](auto& stream, auto& offset) {
+  const auto& stripeFooter = *readState_->stripeMetadata->footer;
+
+  if (selector_) {
+    // HACK!!!
+    //
+    // Column selector filters based on requested schema (ie, table schema),
+    // while we need filter based on file schema. As a result we cannot call
+    // shouldReadNode directly. Instead, build projected nodes set based on node
+    // id from file schema. Column selector should really be fixed to handle
+    // file schema properly.
+    VELOX_CHECK_NULL(projectedNodes_);
+    projectedNodes_ = std::make_shared<BitSet>(0);
+    auto expected = selector_->getSchemaWithId();
+    auto actual = readState_->readerBase->schemaWithId();
+    findProjectedNodes(
+        *projectedNodes_, *expected, *actual, [&](uint32_t node) {
+          return selector_->shouldReadNode(node);
+        });
+  }
+
+  const auto addStream = [&](auto& stream, auto& offset) {
     if (stream.has_offset()) {
       offset = stream.offset();
     }
-    if (projectedNodes.contains(stream.node())) {
+    if (projectedNodes_->contains(stream.node())) {
       streams_[stream] = {offset, stream};
     }
     offset += stream.length();
   };
 
-  uint64_t streamOffset = 0;
-  for (auto& stream : footer.streams()) {
+  uint64_t streamOffset{0};
+  for (auto& stream : stripeFooter.streams()) {
     addStream(stream, streamOffset);
   }
 
   // update column encoding for each stream
-  for (uint32_t i = 0; i < footer.encoding_size(); ++i) {
-    auto& e = footer.encoding(i);
-    auto node = e.has_node() ? e.node() : i;
-    if (projectedNodes.contains(node)) {
+  for (uint32_t i = 0; i < stripeFooter.encoding_size(); ++i) {
+    const auto& e = stripeFooter.encoding(i);
+    const auto node = e.has_node() ? e.node() : i;
+    if (projectedNodes_->contains(node)) {
       encodings_[{node, e.has_sequence() ? e.sequence() : 0}] = i;
     }
   }
 
   // handle encrypted columns
-  auto& handler = readState_->handler;
-  if (handler.isEncrypted()) {
-    DWIO_ENSURE_EQ(
-        handler.getEncryptionGroupCount(), footer.encryptiongroups_size());
+  const auto& decryptionHandler =
+      *readState_->stripeMetadata->decryptionHandler;
+  if (decryptionHandler.isEncrypted()) {
+    VELOX_CHECK_EQ(
+        decryptionHandler.getEncryptionGroupCount(),
+        stripeFooter.encryptiongroups_size());
     folly::F14FastSet<uint32_t> groupIndices;
     bits::forEachSetBit(
-        projectedNodes.bits(), 0, projectedNodes.max() + 1, [&](uint32_t node) {
-          if (handler.isEncrypted(node)) {
-            groupIndices.insert(handler.getEncryptionGroupIndex(node));
+        projectedNodes_->bits(),
+        0,
+        projectedNodes_->max() + 1,
+        [&](uint32_t node) {
+          if (decryptionHandler.isEncrypted(node)) {
+            groupIndices.insert(
+                decryptionHandler.getEncryptionGroupIndex(node));
           }
         });
 
     // decrypt encryption groups
     for (auto index : groupIndices) {
-      auto& group = footer.encryptiongroups(index);
-      auto groupProto =
+      const auto& group = stripeFooter.encryptiongroups(index);
+      const auto groupProto =
           readState_->readerBase
               ->readProtoFromString<proto::StripeEncryptionGroup>(
                   group,
-                  std::addressof(handler.getEncryptionProviderByIndex(index)));
+                  std::addressof(
+                      decryptionHandler.getEncryptionProviderByIndex(index)));
       streamOffset = 0;
       for (auto& stream : groupProto->streams()) {
         addStream(stream, streamOffset);
       }
       for (auto& encoding : groupProto->encoding()) {
-        DWIO_ENSURE(encoding.has_node(), "node is required");
-        auto node = encoding.node();
-        if (projectedNodes.contains(node)) {
+        VELOX_CHECK(encoding.has_node(), "node is required");
+        const auto node = encoding.node();
+        if (projectedNodes_->contains(node)) {
           decryptedEncodings_[{
               node, encoding.has_sequence() ? encoding.sequence() : 0}] =
               encoding;
@@ -229,23 +241,23 @@ StripeStreamsImpl::getCompressedStream(
     std::string_view label) const {
   const auto& info = getStreamInfo(si);
 
-  std::unique_ptr<dwio::common::SeekableInputStream> streamRead;
+  std::unique_ptr<dwio::common::SeekableInputStream> streamInput;
   if (isIndexStream(si.kind())) {
-    streamRead = getIndexStreamFromCache(info);
+    streamInput = getIndexStreamFromCache(info);
   }
 
-  if (!streamRead) {
-    streamRead = readState_->stripeInput->enqueue(
+  if (!streamInput) {
+    streamInput = readState_->stripeMetadata->stripeInput->enqueue(
         {info.getOffset() + stripeStart_, info.getLength(), label}, &si);
   }
 
-  DWIO_ENSURE(streamRead != nullptr, " Stream can't be read", si.toString());
-  return streamRead;
+  VELOX_CHECK_NOT_NULL(streamInput, " Stream can't be read", si.toString());
+  return streamInput;
 }
 
 folly::F14FastMap<uint32_t, std::vector<uint32_t>>
 StripeStreamsImpl::getEncodingKeys() const {
-  DWIO_ENSURE_EQ(
+  VELOX_CHECK_EQ(
       decryptedEncodings_.size(),
       0,
       "Not supported for reader with encryption");
@@ -264,47 +276,41 @@ StripeStreamsImpl::getStreamIdentifiers() const {
   folly::F14FastMap<uint32_t, std::vector<DwrfStreamIdentifier>>
       nodeToStreamIdMap;
 
-  for (const auto& kv : streams_) {
-    nodeToStreamIdMap[kv.first.encodingKey().node()].push_back(kv.first);
+  for (const auto& item : streams_) {
+    nodeToStreamIdMap[item.first.encodingKey().node()].push_back(item.first);
   }
-
   return nodeToStreamIdMap;
 }
 
 std::unique_ptr<dwio::common::SeekableInputStream> StripeStreamsImpl::getStream(
     const DwrfStreamIdentifier& si,
     std::string_view label,
-    bool /* throwIfNotFound*/) const {
-  // if not found, return an empty {}
-  const auto& info = getStreamInfo(si, false /* throwIfNotFound */);
-  if (!info.valid()) { // Stream not found.
+    bool /*throwIfNotFound*/) const {
+  // If not found, return an empty {}
+  const auto& info = getStreamInfo(si, /*throwIfNotFound=*/false);
+  if (!info.valid()) {
+    // Stream not found.
     return {};
   }
 
-  std::unique_ptr<dwio::common::SeekableInputStream> streamRead;
+  std::unique_ptr<dwio::common::SeekableInputStream> streamInput;
   if (isIndexStream(si.kind())) {
-    streamRead = getIndexStreamFromCache(info);
+    streamInput = getIndexStreamFromCache(info);
   }
 
-  if (!streamRead) {
-    streamRead =
-        // If stripeInput is null, it means the stripe was preloaded during
-        // initial footer io, and we can get from ReaderBase input.
-        (readState_->stripeInput ? readState_->stripeInput
-                                 : &readState_->readerBase->getBufferedInput())
-            ->enqueue(
-                {info.getOffset() + stripeStart_, info.getLength(), label},
-                &si);
+  if (!streamInput) {
+    streamInput = readState_->stripeMetadata->stripeInput->enqueue(
+        {info.getOffset() + stripeStart_, info.getLength(), label}, &si);
   }
 
-  if (!streamRead) {
-    return streamRead;
+  if (!streamInput) {
+    return streamInput;
   }
 
-  auto streamDebugInfo =
+  const auto streamDebugInfo =
       fmt::format("Stripe {} Stream {}", stripeIndex_, si.toString());
   return readState_->readerBase->createDecompressedStream(
-      std::move(streamRead),
+      std::move(streamInput),
       streamDebugInfo,
       getDecrypter(si.encodingKey().node()));
 }
@@ -319,7 +325,6 @@ uint32_t StripeStreamsImpl::visitStreamsOfNode(
       ++count;
     }
   }
-
   return count;
 }
 
@@ -335,37 +340,43 @@ bool StripeStreamsImpl::getUseVInts(const DwrfStreamIdentifier& si) const {
 std::unique_ptr<dwio::common::SeekableInputStream>
 StripeStreamsImpl::getIndexStreamFromCache(
     const StreamInformation& info) const {
-  std::unique_ptr<dwio::common::SeekableInputStream> indexStream;
-  auto& metadataCache = readState_->readerBase->getMetadataCache();
-  if (metadataCache) {
-    auto indexBase = metadataCache->get(StripeCacheMode::INDEX, stripeIndex_);
-    if (indexBase) {
-      auto offset = info.getOffset();
-      auto length = info.getLength();
-      if (auto cacheInput =
-              dynamic_cast<dwio::common::CacheInputStream*>(indexBase.get())) {
-        cacheInput->Skip(offset);
-        cacheInput->setRemainingBytes(length);
-        return indexBase;
-      }
-      const void* start;
-      int32_t ignored;
-      DWIO_ENSURE(indexBase->Next(&start, &ignored), "failed to read index");
-      indexStream = std::make_unique<dwio::common::SeekableArrayInputStream>(
-          static_cast<const char*>(start) + offset, length);
-    }
+  auto& metadataCache = readState_->readerBase->metadataCache();
+  if (!metadataCache) {
+    return nullptr;
+  }
+
+  auto indexBase = metadataCache->get(StripeCacheMode::INDEX, stripeIndex_);
+  if (!indexBase) {
+    return nullptr;
+  }
+
+  const auto offset = info.getOffset();
+  const auto length = info.getLength();
+  if (auto* cacheInput =
+          dynamic_cast<dwio::common::CacheInputStream*>(indexBase.get())) {
+    cacheInput->Skip(offset);
+    cacheInput->setRemainingBytes(length);
+    return indexBase;
+  }
+
+  const void* start;
+  {
+    int32_t ignored;
+    const bool ret = indexBase->Next(&start, &ignored);
+    VELOX_CHECK(ret, "Failed to read index");
   }
-  return indexStream;
+  return std::make_unique<dwio::common::SeekableArrayInputStream>(
+      static_cast<const char*>(start) + offset, length);
 }
 
 void StripeStreamsImpl::loadReadPlan() {
-  DWIO_ENSURE_EQ(readPlanLoaded_, false, "only load read plan once!");
+  VELOX_CHECK(!readPlanLoaded_, "only load read plan once!");
   SCOPE_EXIT {
     readPlanLoaded_ = true;
   };
 
-  auto& input = *readState_->stripeInput;
-  input.load(LogType::STREAM_BUNDLE);
+  auto* input = readState_->stripeMetadata->stripeInput;
+  input->load(LogType::STREAM_BUNDLE);
 }
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/reader/StripeStream.h b/velox/dwio/dwrf/reader/StripeStream.h
index 7886be3676d02..362a0b43d097e 100644
--- a/velox/dwio/dwrf/reader/StripeStream.h
+++ b/velox/dwio/dwrf/reader/StripeStream.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/base/BitSet.h"
 #include "velox/dwio/common/ColumnSelector.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/SeekableInputStream.h"
@@ -36,12 +37,6 @@ class StrideIndexProvider {
  * StreamInformation Implementation
  */
 class StreamInformationImpl : public StreamInformation {
- private:
-  DwrfStreamIdentifier streamId_;
-  uint64_t offset_;
-  uint64_t length_;
-  bool useVInts_;
-
  public:
   static const StreamInformationImpl& getNotFound() {
     static const StreamInformationImpl NOT_FOUND;
@@ -53,9 +48,7 @@ class StreamInformationImpl : public StreamInformation {
       : streamId_(stream),
         offset_(offset),
         length_(stream.length()),
-        useVInts_(stream.usevints()) {
-    // PASS
-  }
+        useVInts_(stream.usevints()) {}
 
   ~StreamInformationImpl() override = default;
 
@@ -86,6 +79,12 @@ class StreamInformationImpl : public StreamInformation {
   bool valid() const override {
     return streamId_.encodingKey().valid();
   }
+
+ private:
+  DwrfStreamIdentifier streamId_;
+  uint64_t offset_;
+  uint64_t length_;
+  bool useVInts_;
 };
 
 class StripeStreams {
@@ -105,7 +104,7 @@ class StripeStreams {
   virtual const dwio::common::ColumnSelector& getColumnSelector() const = 0;
 
   // Get row reader options
-  virtual const dwio::common::RowReaderOptions& getRowReaderOptions() const = 0;
+  virtual const dwio::common::RowReaderOptions& rowReaderOptions() const = 0;
 
   /**
    * Get the encoding for the given column for this stripe.
@@ -124,7 +123,7 @@ class StripeStreams {
       std::string_view label,
       bool throwIfNotFound) const = 0;
 
-  /// Get the integer dictionary data for the given node and sequence.
+  /// Gets the integer dictionary data for the given node and sequence.
   ///
   /// 'elementWidth' is the width of the data type of the column.
   /// 'dictionaryWidth' is *the width at which this is stored  in the reader.
@@ -198,98 +197,46 @@ class StripeStreamsBase : public StripeStreams {
   }
 
  protected:
-  memory::MemoryPool* pool_;
-  std::shared_ptr<StripeDictionaryCache> stripeDictionaryCache_;
+  memory::MemoryPool* const pool_;
+  const std::shared_ptr<StripeDictionaryCache> stripeDictionaryCache_;
 };
 
 struct StripeReadState {
   std::shared_ptr<ReaderBase> readerBase;
-  dwio::common::BufferedInput* stripeInput;
-  const proto::StripeFooter* footer;
-  const encryption::DecryptionHandler& handler;
+  std::unique_ptr<const StripeMetadata> stripeMetadata;
 
   StripeReadState(
-      std::shared_ptr<ReaderBase> readerBase,
-      dwio::common::BufferedInput* stripeInput,
-      const proto::StripeFooter* footer,
-      const encryption::DecryptionHandler& handler)
-      : readerBase{std::move(readerBase)},
-        stripeInput{stripeInput},
-        footer{footer},
-        handler{handler} {}
+      std::shared_ptr<ReaderBase> _readerBase,
+      std::unique_ptr<const StripeMetadata> _stripeMetadata)
+      : readerBase{std::move(_readerBase)},
+        stripeMetadata{std::move(_stripeMetadata)} {}
 };
 
 /**
  * StripeStream Implementation
  */
 class StripeStreamsImpl : public StripeStreamsBase {
- private:
-  std::shared_ptr<StripeReadState> readState_;
-  const dwio::common::ColumnSelector& selector_;
-  const dwio::common::RowReaderOptions& opts_;
-  const uint64_t stripeStart_;
-  const int64_t stripeNumberOfRows_;
-  const StrideIndexProvider& provider_;
-  const uint32_t stripeIndex_;
-  bool readPlanLoaded_;
-
-  void loadStreams();
-
-  // map of stream id -> stream information
-  folly::F14FastMap<
-      DwrfStreamIdentifier,
-      StreamInformationImpl,
-      dwio::common::StreamIdentifierHash>
-      streams_;
-  folly::F14FastMap<EncodingKey, uint32_t, EncodingKeyHash> encodings_;
-  folly::F14FastMap<EncodingKey, proto::ColumnEncoding, EncodingKeyHash>
-      decryptedEncodings_;
-
  public:
   static constexpr int64_t kUnknownStripeRows = -1;
 
   StripeStreamsImpl(
       std::shared_ptr<StripeReadState> readState,
-      const dwio::common::ColumnSelector& selector,
+      const dwio::common::ColumnSelector* selector,
+      std::shared_ptr<BitSet> projectedNodes,
       const dwio::common::RowReaderOptions& opts,
       uint64_t stripeStart,
       int64_t stripeNumberOfRows,
       const StrideIndexProvider& provider,
       uint32_t stripeIndex)
-      : StripeStreamsBase{&readState->readerBase->getMemoryPool()},
+      : StripeStreamsBase{&readState->readerBase->memoryPool()},
         readState_(std::move(readState)),
         selector_{selector},
         opts_{opts},
+        projectedNodes_{std::move(projectedNodes)},
         stripeStart_{stripeStart},
         stripeNumberOfRows_{stripeNumberOfRows},
         provider_(provider),
-        stripeIndex_{stripeIndex},
-        readPlanLoaded_{false} {
-    loadStreams();
-  }
-
-  StripeStreamsImpl(
-      const StripeReaderBase& reader,
-      const dwio::common::ColumnSelector& selector,
-      const dwio::common::RowReaderOptions& opts,
-      uint64_t stripeStart,
-      int64_t stripeNumberOfRows,
-      const StrideIndexProvider& provider,
-      uint32_t stripeIndex)
-      : StripeStreamsBase{&reader.getReader().getMemoryPool()},
-        selector_{selector},
-        opts_{opts},
-        stripeStart_{stripeStart},
-        stripeNumberOfRows_{stripeNumberOfRows},
-        provider_(provider),
-        stripeIndex_{stripeIndex},
-        readPlanLoaded_{false} {
-    std::shared_ptr<StripeReadState> state = std::make_shared<StripeReadState>(
-        reader.readerBaseShared(),
-        &reader.getStripeInput(),
-        &reader.getStripeFooter(),
-        reader.getDecryptionHandler());
-    readState_ = std::move(state);
+        stripeIndex_{stripeIndex} {
     loadStreams();
   }
 
@@ -300,25 +247,25 @@ class StripeStreamsImpl : public StripeStreamsBase {
   }
 
   const dwio::common::ColumnSelector& getColumnSelector() const override {
-    return selector_;
+    return *selector_;
   }
 
-  const dwio::common::RowReaderOptions& getRowReaderOptions() const override {
+  const dwio::common::RowReaderOptions& rowReaderOptions() const override {
     return opts_;
   }
 
   const proto::ColumnEncoding& getEncoding(
-      const EncodingKey& ek) const override {
-    auto index = encodings_.find(ek);
+      const EncodingKey& encodingKey) const override {
+    auto index = encodings_.find(encodingKey);
     if (index != encodings_.end()) {
-      return readState_->footer->encoding(index->second);
+      return readState_->stripeMetadata->footer->encoding(index->second);
     }
-    auto enc = decryptedEncodings_.find(ek);
-    DWIO_ENSURE(
-        enc != decryptedEncodings_.end(),
+    auto encodingKeyIt = decryptedEncodings_.find(encodingKey);
+    VELOX_CHECK(
+        encodingKeyIt != decryptedEncodings_.end(),
         "encoding not found: ",
-        ek.toString());
-    return enc->second;
+        encodingKey.toString());
+    return encodingKeyIt->second;
   }
 
   // load data into buffer according to read plan
@@ -328,6 +275,10 @@ class StripeStreamsImpl : public StripeStreamsBase {
       const DwrfStreamIdentifier& si,
       std::string_view label) const;
 
+  uint64_t getStreamOffset(const DwrfStreamIdentifier& si) const {
+    return getStreamInfo(si).getOffset() + stripeStart_;
+  }
+
   uint64_t getStreamLength(const DwrfStreamIdentifier& si) const {
     return getStreamInfo(si).getLength();
   }
@@ -358,20 +309,20 @@ class StripeStreamsImpl : public StripeStreamsBase {
   }
 
   uint32_t rowsPerRowGroup() const override {
-    return readState_->readerBase->getFooter().rowIndexStride();
+    return readState_->readerBase->footer().rowIndexStride();
   }
 
  private:
   const StreamInformation& getStreamInfo(
       const DwrfStreamIdentifier& si,
       const bool throwIfNotFound = true) const {
-    auto index = streams_.find(si);
-    if (index == streams_.end()) {
-      DWIO_ENSURE(!throwIfNotFound, "stream info not found: ", si.toString());
+    const auto it = streams_.find(si);
+    if (it == streams_.end()) {
+      VELOX_CHECK(!throwIfNotFound, "stream info not found: ", si.toString());
       return StreamInformationImpl::getNotFound();
     }
 
-    return index->second;
+    return it->second;
   }
 
   std::unique_ptr<dwio::common::SeekableInputStream> getIndexStreamFromCache(
@@ -379,11 +330,36 @@ class StripeStreamsImpl : public StripeStreamsBase {
 
   const dwio::common::encryption::Decrypter* getDecrypter(
       uint32_t nodeId) const {
-    auto& handler = readState_->handler;
+    auto& handler = *readState_->stripeMetadata->decryptionHandler;
     return handler.isEncrypted(nodeId)
         ? std::addressof(handler.getEncryptionProvider(nodeId))
         : nullptr;
   }
+
+  void loadStreams();
+
+  const std::shared_ptr<StripeReadState> readState_;
+  const dwio::common::ColumnSelector* const selector_;
+  const dwio::common::RowReaderOptions& opts_;
+  // When selector_ is null, this needs to be passed in constructor; otherwise
+  // leave it as null and it will be populated from selector_.
+  std::shared_ptr<BitSet> projectedNodes_;
+  const uint64_t stripeStart_;
+  const int64_t stripeNumberOfRows_;
+  const StrideIndexProvider& provider_;
+  const uint32_t stripeIndex_;
+
+  bool readPlanLoaded_{false};
+
+  // map of stream id -> stream information
+  folly::F14FastMap<
+      DwrfStreamIdentifier,
+      StreamInformationImpl,
+      dwio::common::StreamIdentifierHash>
+      streams_;
+  folly::F14FastMap<EncodingKey, uint32_t, EncodingKeyHash> encodings_;
+  folly::F14FastMap<EncodingKey, proto::ColumnEncoding, EncodingKeyHash>
+      decryptedEncodings_;
 };
 
 /**
diff --git a/velox/dwio/dwrf/test/CMakeLists.txt b/velox/dwio/dwrf/test/CMakeLists.txt
index 48341173e2165..09ee72cd408e4 100644
--- a/velox/dwio/dwrf/test/CMakeLists.txt
+++ b/velox/dwio/dwrf/test/CMakeLists.txt
@@ -20,9 +20,9 @@ set(TEST_LINK_LIBS
     velox_dwio_dwrf_reader
     velox_dwio_dwrf_writer
     gflags::gflags
-    gtest
-    gtest_main
-    gmock
+    GTest::gtest
+    GTest::gtest_main
+    GTest::gmock
     glog::glog
     ${FILESYSTEM})
 
@@ -31,17 +31,29 @@ add_executable(velox_dwio_dwrf_buffered_output_stream_test
 add_test(velox_dwio_dwrf_buffered_output_stream_test
          velox_dwio_dwrf_buffered_output_stream_test)
 
-target_link_libraries(velox_dwio_dwrf_buffered_output_stream_test
-                      velox_link_libs Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_buffered_output_stream_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
-add_executable(velox_dwio_dwrf_column_statistics_test TestColumnStatistics.cpp)
+add_executable(velox_dwio_dwrf_column_statistics_test
+               TestDwrfColumnStatistics.cpp)
 add_test(velox_dwio_dwrf_column_statistics_test
          velox_dwio_dwrf_column_statistics_test)
 
-target_link_libraries(velox_dwio_dwrf_column_statistics_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_column_statistics_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
+
+add_executable(velox_dwio_orc_column_statistics_test
+               TestOrcColumnStatistics.cpp)
+add_test(velox_dwio_orc_column_statistics_test
+         velox_dwio_orc_column_statistics_test)
 
-add_executable(velox_dwio_dwrf_compression_test TestCompression.cpp)
+target_link_libraries(
+  velox_dwio_orc_column_statistics_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
+
+add_executable(velox_dwio_dwrf_compression_test CompressionTest.cpp)
 add_test(velox_dwio_dwrf_compression_test velox_dwio_dwrf_compression_test)
 
 target_link_libraries(
@@ -120,37 +132,45 @@ add_executable(velox_dwio_dwrf_dictionary_encoder_test
 add_test(velox_dwio_dwrf_dictionary_encoder_test
          velox_dwio_dwrf_dictionary_encoder_test)
 
-target_link_libraries(velox_dwio_dwrf_dictionary_encoder_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_dictionary_encoder_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_encoding_selector_test TestEncodingSelector.cpp)
 add_test(velox_dwio_dwrf_encoding_selector_test
          velox_dwio_dwrf_encoding_selector_test)
 
-target_link_libraries(velox_dwio_dwrf_encoding_selector_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_encoding_selector_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_index_builder_test IndexBuilderTests.cpp)
 add_test(velox_dwio_dwrf_index_builder_test velox_dwio_dwrf_index_builder_test)
 
-target_link_libraries(velox_dwio_dwrf_index_builder_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_index_builder_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_dictionary_encoding_utils_test
                TestDictionaryEncodingUtils.cpp)
 add_test(velox_dwio_dwrf_dictionary_encoding_utils_test
          velox_dwio_dwrf_dictionary_encoding_utils_test)
 
-target_link_libraries(velox_dwio_dwrf_dictionary_encoding_utils_test
-                      velox_link_libs Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_dictionary_encoding_utils_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_checksum_test ChecksumTests.cpp)
 add_test(velox_dwio_dwrf_checksum_test velox_dwio_dwrf_checksum_test)
 
-target_link_libraries(velox_dwio_dwrf_checksum_test velox_link_libs
-                      Folly::folly Boost::headers ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_checksum_test
+  velox_link_libs
+  Folly::folly
+  Boost::headers
+  ${TEST_LINK_LIBS})
 
-add_executable(velox_dwio_dwrf_writer_test WriterTests.cpp)
+add_executable(velox_dwio_dwrf_writer_test WriterTest.cpp)
 add_test(velox_dwio_dwrf_writer_test velox_dwio_dwrf_writer_test)
 
 target_link_libraries(
@@ -163,7 +183,7 @@ target_link_libraries(
   ZLIB::ZLIB
   ${TEST_LINK_LIBS})
 
-add_executable(velox_dwio_dwrf_writer_context_test TestWriterContext.cpp)
+add_executable(velox_dwio_dwrf_writer_context_test WriterContextTest.cpp)
 add_test(velox_dwio_dwrf_writer_context_test
          velox_dwio_dwrf_writer_context_test)
 
@@ -192,19 +212,21 @@ target_link_libraries(
   ZLIB::ZLIB
   ${TEST_LINK_LIBS})
 
-add_executable(velox_dwio_dwrf_writer_sink_test WriterSinkTests.cpp)
+add_executable(velox_dwio_dwrf_writer_sink_test WriterSinkTest.cpp)
 add_test(velox_dwio_dwrf_writer_sink_test velox_dwio_dwrf_writer_sink_test)
 
-target_link_libraries(velox_dwio_dwrf_writer_sink_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_writer_sink_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_data_buffer_holder_test
                DataBufferHolderTests.cpp)
 add_test(velox_dwio_dwrf_data_buffer_holder_test
          velox_dwio_dwrf_data_buffer_holder_test)
 
-target_link_libraries(velox_dwio_dwrf_data_buffer_holder_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_data_buffer_holder_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_layout_planner_test LayoutPlannerTests.cpp)
 add_test(velox_dwio_dwrf_layout_planner_test
@@ -223,14 +245,16 @@ target_link_libraries(
 add_executable(velox_dwio_dwrf_decryption_test DecryptionTests.cpp)
 add_test(velox_dwio_dwrf_decryption_test velox_dwio_dwrf_decryption_test)
 
-target_link_libraries(velox_dwio_dwrf_decryption_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_decryption_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_encryption_test EncryptionTests.cpp)
 add_test(velox_dwio_dwrf_encryption_test velox_dwio_dwrf_encryption_test)
 
-target_link_libraries(velox_dwio_dwrf_encryption_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_encryption_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_stripe_reader_base_test
                StripeReaderBaseTests.cpp)
@@ -264,63 +288,83 @@ target_link_libraries(
 add_executable(velox_dwio_dwrf_config_test ConfigTests.cpp)
 add_test(velox_dwio_dwrf_config_test velox_dwio_dwrf_config_test)
 
-target_link_libraries(velox_dwio_dwrf_config_test velox_link_libs Folly::folly
-                      ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_config_test velox_link_libs Folly::folly ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_ratio_checker_test RatioTrackerTest.cpp)
 add_test(velox_dwio_dwrf_ratio_checker_test velox_dwio_dwrf_ratio_checker_test)
 
-target_link_libraries(velox_dwio_dwrf_ratio_checker_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_ratio_checker_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_flush_policy_test FlushPolicyTest.cpp)
 add_test(velox_dwio_dwrf_flush_policy_test velox_dwio_dwrf_flush_policy_test)
 
-target_link_libraries(velox_dwio_dwrf_flush_policy_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_flush_policy_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_byte_rle_test TestByteRle.cpp)
 add_test(velox_dwio_dwrf_byte_rle_test velox_dwio_dwrf_byte_rle_test)
 
-target_link_libraries(velox_dwio_dwrf_byte_rle_test velox_link_libs fmt::fmt
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_byte_rle_test
+  velox_link_libs
+  fmt::fmt
+  Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_byte_rle_encoder_test TestByteRLEEncoder.cpp)
 add_test(velox_dwio_dwrf_byte_rle_encoder_test
          velox_dwio_dwrf_byte_rle_encoder_test)
 
-target_link_libraries(velox_dwio_dwrf_byte_rle_encoder_test velox_link_libs
-                      fmt::fmt Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_byte_rle_encoder_test
+  velox_link_libs
+  fmt::fmt
+  Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_int_encoder_test TestIntEncoder.cpp)
 add_test(velox_dwio_dwrf_int_encoder_test velox_dwio_dwrf_int_encoder_test)
 
-target_link_libraries(velox_dwio_dwrf_int_encoder_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_int_encoder_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_rle_test TestRle.cpp)
 add_test(velox_dwio_dwrf_rle_test velox_dwio_dwrf_rle_test)
 
-target_link_libraries(velox_dwio_dwrf_rle_test velox_link_libs Folly::folly
-                      ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_rle_test velox_link_libs Folly::folly ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_int_direct_test TestIntDirect.cpp)
 add_test(velox_dwio_dwrf_int_direct_test velox_dwio_dwrf_int_direct_test)
 
-target_link_libraries(velox_dwio_dwrf_int_direct_test velox_link_libs fmt::fmt
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_int_direct_test
+  velox_link_libs
+  fmt::fmt
+  Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_rlev1_encoder_test TestRLEv1Encoder.cpp)
 add_test(velox_dwio_dwrf_rlev1_encoder_test velox_dwio_dwrf_rlev1_encoder_test)
 
-target_link_libraries(velox_dwio_dwrf_rlev1_encoder_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_rlev1_encoder_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_column_reader_test TestColumnReader.cpp)
 add_test(velox_dwio_dwrf_column_reader_test velox_dwio_dwrf_column_reader_test)
 
-target_link_libraries(velox_dwio_dwrf_column_reader_test velox_link_libs
-                      Folly::folly fmt::fmt ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwio_dwrf_column_reader_test
+  velox_link_libs
+  Folly::folly
+  fmt::fmt
+  ${TEST_LINK_LIBS})
 
 add_executable(velox_dwio_dwrf_reader_test ReaderTest.cpp)
 add_test(
@@ -346,8 +390,9 @@ add_test(velox_dwrf_e2e_filter_test velox_dwrf_e2e_filter_test)
 
 target_link_libraries(
   velox_dwrf_e2e_filter_test
-  velox_e2e_filter_test_base
+  velox_dwio_common_test_utils
   velox_link_libs
+  velox_test_util
   Folly::folly
   fmt::fmt
   lz4::lz4
@@ -361,10 +406,11 @@ add_executable(velox_dwrf_statistics_builder_utils_test
 add_test(velox_dwrf_statistics_builder_utils_test
          velox_dwrf_statistics_builder_utils_test)
 
-target_link_libraries(velox_dwrf_statistics_builder_utils_test velox_link_libs
-                      Folly::folly ${TEST_LINK_LIBS})
+target_link_libraries(
+  velox_dwrf_statistics_builder_utils_test velox_link_libs Folly::folly
+  ${TEST_LINK_LIBS})
 
-add_executable(velox_dwrf_column_writer_test ColumnWriterTests.cpp)
+add_executable(velox_dwrf_column_writer_test ColumnWriterTest.cpp)
 add_test(velox_dwrf_column_writer_test velox_dwrf_column_writer_test)
 
 target_link_libraries(
@@ -380,7 +426,7 @@ target_link_libraries(
   ZLIB::ZLIB
   ${TEST_LINK_LIBS})
 
-add_executable(velox_dwrf_column_writer_index_test ColumnWriterIndexTests.cpp)
+add_executable(velox_dwrf_column_writer_index_test ColumnWriterIndexTest.cpp)
 add_test(velox_dwrf_column_writer_index_test
          velox_dwrf_column_writer_index_test)
 
@@ -411,7 +457,7 @@ target_link_libraries(
   ZLIB::ZLIB
   ${TEST_LINK_LIBS})
 
-add_executable(velox_dwrf_e2e_writer_test E2EWriterTests.cpp)
+add_executable(velox_dwrf_e2e_writer_test E2EWriterTest.cpp)
 add_test(velox_dwrf_e2e_writer_test velox_dwrf_e2e_writer_test)
 
 target_link_libraries(
@@ -428,6 +474,23 @@ target_link_libraries(
   ZLIB::ZLIB
   ${TEST_LINK_LIBS})
 
+add_executable(velox_dwrf_e2e_reader_test E2EReaderTest.cpp)
+add_test(velox_dwrf_e2e_reader_test velox_dwrf_e2e_reader_test)
+
+target_link_libraries(
+  velox_dwrf_e2e_reader_test
+  velox_dwrf_test_utils
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  velox_link_libs
+  Folly::folly
+  fmt::fmt
+  lz4::lz4
+  lzo2::lzo2
+  zstd::zstd
+  ZLIB::ZLIB
+  ${TEST_LINK_LIBS})
+
 add_executable(velox_dwrf_writer_extended_test WriterExtendedTests.cpp)
 
 target_link_libraries(
@@ -475,8 +538,12 @@ target_link_libraries(
 
 add_executable(velox_dwrf_int_encoder_benchmark IntEncoderBenchmark.cpp)
 target_link_libraries(
-  velox_dwrf_int_encoder_benchmark velox_dwio_dwrf_common velox_memory
-  velox_dwio_common_exception Folly::folly ${FOLLY_BENCHMARK})
+  velox_dwrf_int_encoder_benchmark
+  velox_dwio_dwrf_common
+  velox_memory
+  velox_dwio_common_exception
+  Folly::folly
+  ${FOLLY_BENCHMARK})
 
 add_executable(velox_dwrf_float_column_writer_benchmark
                FloatColumnWriterBenchmark.cpp)
@@ -489,7 +556,8 @@ target_link_libraries(
   ${FOLLY_BENCHMARK}
   fmt::fmt)
 
-add_executable(velox_dwio_cache_test CacheInputTest.cpp)
+add_executable(velox_dwio_cache_test CacheInputTest.cpp
+                                     DirectBufferedInputTest.cpp)
 
 add_test(velox_dwio_cache_test velox_dwio_cache_test)
 
diff --git a/velox/dwio/dwrf/test/CacheInputTest.cpp b/velox/dwio/dwrf/test/CacheInputTest.cpp
index 0741d55aca1f2..e3a9dff0f7cc6 100644
--- a/velox/dwio/dwrf/test/CacheInputTest.cpp
+++ b/velox/dwio/dwrf/test/CacheInputTest.cpp
@@ -17,6 +17,7 @@
 #include <folly/Random.h>
 #include <folly/container/F14Map.h>
 #include <folly/executors/IOThreadPoolExecutor.h>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/caching/FileIds.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/io/IoStatistics.h"
@@ -24,8 +25,10 @@
 #include "velox/common/memory/MmapAllocator.h"
 #include "velox/dwio/common/CachedBufferedInput.h"
 #include "velox/dwio/dwrf/common/Common.h"
+#include "velox/dwio/dwrf/test/TestReadFile.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 
+#include <fcntl.h>
 #include <gtest/gtest.h>
 
 using namespace facebook::velox;
@@ -37,61 +40,7 @@ using facebook::velox::common::Region;
 using memory::MemoryAllocator;
 using IoStatisticsPtr = std::shared_ptr<IoStatistics>;
 
-// Testing stream producing deterministic data. The byte at offset is
-// the low byte of 'seed_' + offset.
-class TestReadFile : public ReadFile {
- public:
-  TestReadFile(uint64_t seed, uint64_t length, IoStatisticsPtr ioStats)
-      : seed_(seed), length_(length), ioStats_(std::move(ioStats)) {}
-
-  uint64_t size() const override {
-    return length_;
-  }
-
-  std::string_view pread(uint64_t offset, uint64_t length, void* buffer)
-      const override {
-    int fill;
-    uint64_t content = offset + seed_;
-    uint64_t available = std::min(length_ - offset, length);
-    for (fill = 0; fill < (available); ++fill) {
-      reinterpret_cast<char*>(buffer)[fill] = content + fill;
-    }
-    ioStats_->incRawBytesRead(length);
-    return std::string_view(static_cast<const char*>(buffer), fill);
-  }
-
-  // Asserts that 'bytes' is as would be read from 'offset'.
-  void checkData(const void* bytes, uint64_t offset, int32_t size) {
-    for (auto i = 0; i < size; ++i) {
-      char expected = seed_ + offset + i;
-      ASSERT_EQ(expected, reinterpret_cast<const char*>(bytes)[i])
-          << " at " << offset + i;
-    }
-  }
-
-  uint64_t memoryUsage() const override {
-    VELOX_NYI();
-  }
-
-  bool shouldCoalesce() const override {
-    VELOX_NYI();
-  }
-
-  std::string getName() const override {
-    return "<TestReadFile>";
-  }
-
-  uint64_t getNaturalReadSize() const override {
-    VELOX_NYI();
-  }
-
- private:
-  const uint64_t seed_;
-  const uint64_t length_;
-  IoStatisticsPtr ioStats_;
-};
-
-class CacheTest : public testing::Test {
+class CacheTest : public ::testing::Test {
  protected:
   static constexpr int32_t kMaxStreams = 50;
 
@@ -103,34 +52,60 @@ class CacheTest : public testing::Test {
     std::vector<Region> regions;
   };
 
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    executor_ = std::make_unique<folly::IOThreadPoolExecutor>(10, 10);
+    // executor_ = std::make_unique<folly::IOThreadPoolExecutor>(10, 10);
     rng_.seed(1);
     ioStats_ = std::make_shared<IoStatistics>();
     filesystems::registerLocalFileSystem();
   }
 
   void TearDown() override {
-    executor_->join();
-    auto ssdCache = cache_->ssdCache();
-    if (ssdCache) {
-      ssdCache->testingDeleteFiles();
-    }
-    if (cache_) {
+    shutdownCache();
+  }
+
+  void shutdownCache() {
+    if (cache_ != nullptr) {
       cache_->shutdown();
     }
+    if (executor_ != nullptr) {
+      executor_.reset();
+    }
+    if (cache_ != nullptr) {
+      auto* ssdCache = cache_->ssdCache();
+      if (ssdCache != nullptr) {
+        ssdCache->testingDeleteFiles();
+      }
+    }
   }
 
-  void initializeCache(uint64_t maxBytes, uint64_t ssdBytes = 0) {
+  void initializeCache(
+      uint64_t maxBytes,
+      uint64_t ssdBytes = 0,
+      bool checksumEnabled = false) {
+    shutdownCache();
+
+    if (executor_ == nullptr) {
+      executor_ = std::make_unique<folly::IOThreadPoolExecutor>(10, 10);
+    }
+
     std::unique_ptr<SsdCache> ssd;
-    if (ssdBytes) {
+    if (ssdBytes > 0) {
       FLAGS_ssd_odirect = false;
       tempDirectory_ = exec::test::TempDirectoryPath::create();
-      ssd = std::make_unique<SsdCache>(
-          fmt::format("{}/cache", tempDirectory_->path),
+      const SsdCache::Config config(
+          fmt::format("{}/cache", tempDirectory_->getPath()),
           ssdBytes,
           1,
-          executor_.get());
+          executor_.get(),
+          0,
+          false,
+          checksumEnabled,
+          checksumEnabled);
+      ssd = std::make_unique<SsdCache>(config);
       groupStats_ = &ssd->groupStats();
     }
     memory::MmapAllocator::Options options;
@@ -148,15 +123,23 @@ class CacheTest : public testing::Test {
     for (auto i = 1; i <= kMaxStreams; ++i) {
       streamStarts_[i] = streamStarts_[i - 1] + spacing * i;
       if (i < kMaxStreams / 3) {
-        spacing += 1000;
+        spacing += 1'000;
       } else if (i < kMaxStreams / 3 * 2) {
-        spacing += 20000;
+        spacing += 20'000;
       } else if (i > kMaxStreams - 5) {
-        spacing += 2000000;
+        spacing += 2'000'000;
       }
     }
   }
 
+  // Corrupts the file by invalidate its content.
+  static void corruptSsdFile(const std::string& path) {
+    const auto fd = ::open(path.c_str(), O_WRONLY);
+    const auto size = ::lseek(fd, 0, SEEK_END);
+    ASSERT_EQ(ftruncate(fd, 0), 0);
+    ASSERT_EQ(ftruncate(fd, size), 0);
+  }
+
   static void checkEntry(const cache::AsyncDataCacheEntry& entry) {
     uint64_t seed = entry.key().fileNum.id();
     if (entry.tinyData()) {
@@ -200,25 +183,25 @@ class CacheTest : public testing::Test {
   std::shared_ptr<TestReadFile>
   inputByPath(const std::string& path, uint64_t& fileId, uint64_t& groupId) {
     std::lock_guard<std::mutex> l(mutex_);
-    StringIdLease lease(fileIds(), path);
-    fileId = lease.id();
+    StringIdLease fileLease(fileIds(), path);
+    fileId = fileLease.id();
     StringIdLease groupLease(fileIds(), fmt::format("group{}", fileId / 2));
     groupId = groupLease.id();
-    auto it = pathToInput_.find(lease.id());
-    if (it == pathToInput_.end()) {
-      fileIds_.push_back(lease);
-      fileIds_.push_back(groupLease);
-      auto stream = std::make_shared<TestReadFile>(
-          lease.id(), 1UL << 63, std::make_shared<io::IoStatistics>());
-      pathToInput_[lease.id()] = stream;
-      return stream;
+    auto it = pathToInput_.find(fileId);
+    if (it != pathToInput_.end()) {
+      return it->second;
     }
-    return it->second;
+    fileIds_.push_back(fileLease);
+    fileIds_.push_back(groupLease);
+    // Creates an extremely large read file for test.
+    auto stream = std::make_shared<TestReadFile>(
+        fileLease.id(), 1UL << 63, std::make_shared<io::IoStatistics>());
+    pathToInput_[fileLease.id()] = stream;
+    return stream;
   }
 
-  // Makes a CachedBufferedInput with a subset of the testing streams
-  // enqueued. 'numColumns' streams are evenly selected from
-  // kMaxStreams.
+  // Makes a CachedBufferedInput with a subset of the testing streams enqueued.
+  // 'numColumns' streams are evenly selected from kMaxStreams.
   std::unique_ptr<StripeData> makeStripeData(
       std::shared_ptr<TestReadFile> readFile,
       int32_t numColumns,
@@ -226,8 +209,11 @@ class CacheTest : public testing::Test {
       uint64_t fileId,
       uint64_t groupId,
       int64_t offset,
+      bool noCacheRetention,
       const IoStatisticsPtr& ioStats) {
     auto data = std::make_unique<StripeData>();
+    auto readOptions = io::ReaderOptions(pool_.get());
+    readOptions.setNoCacheRetention(noCacheRetention);
     data->input = std::make_unique<CachedBufferedInput>(
         readFile,
         MetricsLog::voidLog(),
@@ -237,21 +223,29 @@ class CacheTest : public testing::Test {
         groupId,
         ioStats,
         executor_.get(),
-        io::ReaderOptions(pool_.get()));
+        readOptions);
     data->file = readFile.get();
     for (auto i = 0; i < numColumns; ++i) {
-      int32_t streamIndex = i * (kMaxStreams / numColumns);
+      const int32_t streamIndex = i * (kMaxStreams / numColumns);
 
-      // Each region covers half the space from its start to the
-      // start of the next or at max a little under 20MB.
-      Region region{
+      // Each region covers half the space from its start to the start of the
+      // next or at max a little under 20MB.
+      const Region region{
           offset + streamStarts_[streamIndex],
           std::min<uint64_t>(
               (1 << 20) - 11,
               (streamStarts_[streamIndex + 1] - streamStarts_[streamIndex]) /
                   2)};
-      data->streams.push_back(
-          data->input->enqueue(region, streamIds_[streamIndex].get()));
+      auto stream = data->input->enqueue(region, streamIds_[streamIndex].get());
+      if (cache_->ssdCache() != nullptr) {
+        const auto name =
+            static_cast<const CacheInputStream&>(*stream).getName();
+        EXPECT_TRUE(
+            name.find("ssdFile=" + cache_->ssdCache()->filePrefix()) !=
+            name.npos)
+            << name;
+      }
+      data->streams.push_back(std::move(stream));
       data->regions.push_back(region);
     }
     return data;
@@ -278,13 +272,13 @@ class CacheTest : public testing::Test {
     int32_t size;
     int64_t numRead = 0;
     auto& stream = *stripe.streams[columnIndex];
-    auto region = stripe.regions[columnIndex];
+    const auto region = stripe.regions[columnIndex];
     do {
       stream.Next(&data, &size);
       stripe.file->checkData(data, region.offset + numRead, size);
       numRead += size;
     } while (size > 0);
-    EXPECT_EQ(numRead, region.length);
+    ASSERT_EQ(numRead, region.length);
     if (testRandomSeek_) {
       // Test random access
       std::vector<uint64_t> offsets = {
@@ -296,47 +290,45 @@ class CacheTest : public testing::Test {
       }
     }
   }
+
   void checkRandomRead(
       const StripeData& stripe,
       SeekableInputStream& stream,
       const std::vector<uint64_t>& offsets,
       int32_t i,
-      Region region) {
+      const Region& region) {
     const void* data;
     int32_t size;
     int64_t numRead = 0;
     auto offset = offsets[i];
-    // Reads from offset to halfway to the next offset or end.
-    auto toRead =
+    // Reads from offset to half-way to the next offset or end.
+    const auto toRead =
         ((i == offsets.size() - 1 ? region.length : offsets[i + 1]) - offset) /
         2;
-
     do {
       stream.Next(&data, &size);
       stripe.file->checkData(data, region.offset + offset, size);
       numRead += size;
       offset += size;
-      if (size == 0 && numRead) {
-        FAIL() << "Stream end prematurely after  random seek";
+      if (size == 0 && numRead == 0) {
+        VELOX_FAIL("Stream end prematurely after random seek");
       }
     } while (numRead < toRead);
   }
 
-  // Makes a series of kReadAhead CachedBufferedInputs for consecutive
-  // stripes and starts background load guided by the load frequency
-  // in the previous stripes for 'stripeWindow' ahead of the stripe
-  // being read. When at end, destroys the CachedBufferedInput for the
-  // pre-read stripes while they are in a background loading state. A
-  // window size of 1 means that only one CachedbufferedInput is
-  // active at a time.
+  // Makes a series of kReadAhead CachedBufferedInputs for consecutive stripes
+  // and starts background load guided by the load frequency in the previous
+  // stripes for 'stripeWindow' ahead of the stripe being read. When at end,
+  // destroys the CachedBufferedInput for the pre-read stripes while they are in
+  // a background loading state. A window size of 1 means that only one
+  // CachedbufferedInput actives at a time.
   //
-  // 'readPct' is the probability any given
-  // stripe will access any given column. 'readPctModulo' biases the
-  // read probability of as a function of the column number. If this
-  // is 1, all columns will be read at 'readPct'. If this is 4,
-  // 'readPct is divided by 1 + columnId % readPctModulo, so that
-  // multiples of 4 get read at readPct and columns with id % 4 == 3
-  // get read at 1/4 of readPct.
+  // 'readPct' is the probability any given stripe will access any given column.
+  // 'readPctModulo' biases the read probability of as a function of the column
+  // number. If this is 1, all columns will be read at 'readPct'. If this is 4,
+  // 'readPct is divided by 1 + columnId % readPctModulo, so that multiples of 4
+  // get read at readPct and columns with id % 4 == 3 get read at 1/4 of
+  // readPct.
   void readLoop(
       const std::string& filename,
       int numColumns,
@@ -344,6 +336,7 @@ class CacheTest : public testing::Test {
       int32_t readPctModulo,
       int32_t numStripes,
       int32_t stripeWindow,
+      bool noCacheRetention,
       const IoStatisticsPtr& ioStats) {
     auto tracker = std::make_shared<ScanTracker>(
         "testTracker",
@@ -358,9 +351,10 @@ class CacheTest : public testing::Test {
       groupStats_->recordFile(fileId, groupId, numStripes);
     }
     for (auto stripeIndex = 0; stripeIndex < numStripes; ++stripeIndex) {
-      auto firstPrefetchStripe = stripeIndex + stripes.size();
-      auto window = std::min(stripeIndex + 1, stripeWindow);
-      auto lastPrefetchStripe = std::min(numStripes, stripeIndex + window);
+      const auto firstPrefetchStripe = stripeIndex + stripes.size();
+      const auto window = std::min(stripeIndex + 1, stripeWindow);
+      const auto lastPrefetchStripe =
+          std::min(numStripes, stripeIndex + window);
       for (auto prefetchStripeIndex = firstPrefetchStripe;
            prefetchStripeIndex < lastPrefetchStripe;
            ++prefetchStripeIndex) {
@@ -371,6 +365,7 @@ class CacheTest : public testing::Test {
             fileId,
             groupId,
             prefetchStripeIndex * streamStarts_[kMaxStreams - 1],
+            noCacheRetention,
             ioStats));
         if (stripes.back()->input->shouldPreload()) {
           stripes.back()->input->load(LogType::TEST);
@@ -387,8 +382,8 @@ class CacheTest : public testing::Test {
     }
   }
 
-  // Reads a files from prefix<from> to prefix<to>. The other
-  // parameters have the same meaning as with readLoop().
+  // Reads a files from prefix<from> to prefix<to>. The other parameters have
+  // the same meaning as with readLoop().
   void readFiles(
       const std::string& prefix,
       int32_t from,
@@ -406,6 +401,7 @@ class CacheTest : public testing::Test {
           readPctModulo,
           numStripes,
           stripeWindow,
+          /*noCacheRetention=*/false,
           ioStats_);
     }
   }
@@ -424,12 +420,13 @@ class CacheTest : public testing::Test {
   std::vector<StringIdLease> fileIds_;
   folly::F14FastMap<uint64_t, std::shared_ptr<TestReadFile>> pathToInput_;
   std::shared_ptr<exec::test::TempDirectoryPath> tempDirectory_;
-  cache::FileGroupStats* FOLLY_NULLABLE groupStats_ = nullptr;
+  cache::FileGroupStats* groupStats_ = nullptr;
   std::shared_ptr<memory::MemoryAllocator> allocator_;
   std::shared_ptr<AsyncDataCache> cache_;
   std::shared_ptr<IoStatistics> ioStats_;
   std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 
   // Id of simulated streams. Corresponds 1:1 to 'streamStarts_'.
   std::vector<std::unique_ptr<dwrf::DwrfStreamIdentifier>> streamIds_;
@@ -441,8 +438,8 @@ class CacheTest : public testing::Test {
   bool deterministic_{false};
   folly::Random::DefaultGenerator rng_;
 
-  // Specifies if random seek follows bulk read in tests. We turn this
-  // off so as not to inflate cache hits.
+  // Specifies if random seek follows bulk read in tests. We turn this off so as
+  // not to inflate cache hits.
   bool testRandomSeek_{true};
 };
 
@@ -472,6 +469,7 @@ TEST_F(CacheTest, window) {
   auto stream = input->read(begin, end - begin, LogType::TEST);
   auto cacheInput = dynamic_cast<CacheInputStream*>(stream.get());
   EXPECT_TRUE(cacheInput != nullptr);
+  ASSERT_EQ(cacheInput->getName(), "CacheInputStream 0 of 13631488");
   auto maxSize =
       allocator_->sizeClasses().back() * memory::AllocationTraits::kPageSize;
   const void* buffer;
@@ -509,17 +507,17 @@ TEST_F(CacheTest, window) {
 TEST_F(CacheTest, bufferedInput) {
   // Size 160 MB. Frequent evictions and not everything fits in prefetch window.
   initializeCache(160 << 20);
-  readLoop("testfile", 30, 70, 10, 20, 4, ioStats_);
-  readLoop("testfile", 30, 70, 10, 20, 4, ioStats_);
-  readLoop("testfile2", 30, 70, 70, 20, 4, ioStats_);
+  readLoop("testfile", 30, 70, 10, 20, 4, /*noCacheRetention=*/false, ioStats_);
+  readLoop("testfile", 30, 70, 10, 20, 4, /*noCacheRetention=*/false, ioStats_);
+  readLoop(
+      "testfile2", 30, 70, 70, 20, 4, /*noCacheRetention=*/false, ioStats_);
 }
 
-// Calibrates the data read for a densely and sparsely read stripe of
-// test data. Fills the SSD cache with test data. Reads 2x cache size
-// worth of data and checks that the cache population settles to a
-// stable state.  Shifts the reading pattern so that half the working
-// set drops out and another half is added. Checks that the
-// working set stabilizes again.
+// Calibrates the data read for a densely and sparsely read stripe of test data.
+// Fills the SSD cache with test data. Reads 2x cache size worth of data and
+// checks that the cache population settles to a stable state.  Shifts the
+// reading pattern so that half the working set drops out and another half is
+// added. Checks that the working set stabilizes again.
 TEST_F(CacheTest, ssd) {
   constexpr int64_t kSsdBytes = 256 << 20;
   // 64 RAM, 256MB SSD
@@ -528,7 +526,7 @@ TEST_F(CacheTest, ssd) {
   deterministic_ = true;
 
   // We read one stripe with all columns.
-  readLoop("testfile", 30, 100, 1, 1, 1, ioStats_);
+  readLoop("testfile", 30, 100, 1, 1, 1, /*noCacheRetention=*/false, ioStats_);
   // This is a cold read, so expect no hits.
   EXPECT_EQ(0, ioStats_->ramHit().sum());
   // Expect some extra reading from coalescing.
@@ -537,7 +535,7 @@ TEST_F(CacheTest, ssd) {
   auto bytes = ioStats_->rawBytesRead();
   cache_->clear();
   // We read 10 stripes with some columns sparsely accessed.
-  readLoop("testfile", 30, 70, 10, 10, 1, ioStats_);
+  readLoop("testfile", 30, 70, 10, 10, 1, /*noCacheRetention=*/false, ioStats_);
   auto sparseStripeBytes = (ioStats_->rawBytesRead() - bytes) / 10;
   EXPECT_LT(sparseStripeBytes, fullStripeBytes / 4);
   // Expect the dense fraction of columns to have read ahead.
@@ -549,8 +547,6 @@ TEST_F(CacheTest, ssd) {
   readFiles(
       "prefix1_", 0, kSsdBytes / bytesPerFile, 30, 100, 1, kStripesPerFile, 4);
 
-  LOG(INFO) << cache_->toString();
-
   waitForWrite();
   cache_->clear();
   // Read double this to get some eviction from SSD.
@@ -571,7 +567,6 @@ TEST_F(CacheTest, ssd) {
   // issued. Also, the head of each file does not get prefetched
   // because each file has its own tracker.
   EXPECT_LE(kSsdBytes / 8, ioStats_->prefetch().sum());
-  LOG(INFO) << cache_->toString();
 
   readFiles(
       "prefix1_",
@@ -582,7 +577,6 @@ TEST_F(CacheTest, ssd) {
       1,
       kStripesPerFile,
       4);
-  LOG(INFO) << cache_->toString();
 }
 
 TEST_F(CacheTest, singleFileThreads) {
@@ -593,7 +587,15 @@ TEST_F(CacheTest, singleFileThreads) {
   threads.reserve(numThreads);
   for (int i = 0; i < numThreads; ++i) {
     threads.push_back(std::thread([this, i]() {
-      readLoop(fmt::format("testfile{}", i), 10, 70, 10, 20, 4, ioStats_);
+      readLoop(
+          fmt::format("testfile{}", i),
+          10,
+          70,
+          10,
+          20,
+          4,
+          /*noCacheRetention=*/false,
+          ioStats_);
     }));
   }
   for (auto i = 0; i < numThreads; ++i) {
@@ -617,7 +619,14 @@ TEST_F(CacheTest, ssdThreads) {
     threads.push_back(std::thread([i, this, threadStats = stats.back()]() {
       for (auto counter = 0; counter < 4; ++counter) {
         readLoop(
-            fmt::format("testfile{}", i / 2), 10, 70, 10, 20, 2, threadStats);
+            fmt::format("testfile{}", i / 2),
+            10,
+            70,
+            10,
+            20,
+            2,
+            /*noCacheRetention=*/false,
+            threadStats);
       }
     }));
   }
@@ -645,13 +654,14 @@ class FileWithReadAhead {
   static constexpr int64_t kLoadQuantum = 6 << 20;
   FileWithReadAhead(
       const std::string& name,
-      cache::AsyncDataCache* FOLLY_NONNULL cache,
+      cache::AsyncDataCache* cache,
       IoStatisticsPtr stats,
       memory::MemoryPool& pool,
       folly::Executor* executor)
       : options_(&pool) {
     fileId_ = std::make_unique<StringIdLease>(fileIds(), name);
     file_ = std::make_shared<TestReadFile>(fileId_->id(), kFileSize, stats);
+    options_.setNoCacheRetention(true);
     bufferedInput_ = std::make_unique<CachedBufferedInput>(
         file_,
         MetricsLog::voidLog(),
@@ -664,10 +674,11 @@ class FileWithReadAhead {
         options_);
     auto sequential = StreamIdentifier::sequentialFile();
     stream_ = bufferedInput_->enqueue(Region{0, file_->size()}, &sequential);
+    VELOX_CHECK(reinterpret_cast<CacheInputStream*>(stream_.get())
+                    ->testingNoCacheRetention());
     // Trigger load of next 4MB after reading the first 2MB of the previous 4MB
     // quantum.
     reinterpret_cast<CacheInputStream*>(stream_.get())->setPrefetchPct(50);
-    reinterpret_cast<CacheInputStream*>(stream_.get())->setNoRetention();
     bufferedInput_->load(LogType::FILE);
   }
 
@@ -761,3 +772,199 @@ TEST_F(CacheTest, readAhead) {
 
   LOG(INFO) << count << " prefetches with total " << bytes << " bytes";
 }
+
+TEST_F(CacheTest, noCacheRetention) {
+  const int64_t cacheSize = 1LL << 30;
+  struct {
+    bool noCacheRetention;
+    bool hasSsdCache;
+    int readPct;
+
+    std::string debugString() const {
+      return fmt::format(
+          "noCacheRetention {}, hasSsdCache {}, readPct {}",
+          noCacheRetention,
+          hasSsdCache,
+          readPct);
+    }
+  } testSettings[] = {
+      {true, true, 100},
+      {true, false, 100},
+      {false, false, 100},
+      {false, true, 100},
+      {true, true, 10},
+      {true, false, 100},
+      {false, false, 100},
+      {false, true, 100}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    // 1GB RAM with 1GB SSD or not so there is always sufficient space to cache
+    // all the read data in both ram and ssd caches.
+    initializeCache(cacheSize, testData.hasSsdCache ? cacheSize : 0);
+    testRandomSeek_ = true;
+    deterministic_ = true;
+
+    // We read one stripe with all columns,
+    readLoop(
+        "noCacheRetention",
+        20,
+        testData.readPct,
+        1,
+        5,
+        1,
+        testData.noCacheRetention,
+        ioStats_);
+    // This is a cold read, so expect no hits.
+    ASSERT_EQ(ioStats_->ramHit().sum(), 0);
+    // Only one reference per column so there is no prefetch.
+    ASSERT_LT(0, ioStats_->prefetch().sum());
+    // Expect some extra reading from coalescing.
+    ASSERT_LT(0, ioStats_->rawOverreadBytes());
+    ASSERT_LT(0, ioStats_->rawBytesRead());
+    auto* ssdCache = cache_->ssdCache();
+    if (ssdCache != nullptr) {
+      ssdCache->waitForWriteToFinish();
+      if (testData.noCacheRetention) {
+        ASSERT_EQ(ssdCache->stats().entriesCached, 0);
+      } else {
+        ASSERT_GT(ssdCache->stats().entriesCached, 0);
+      }
+      ASSERT_EQ(ssdCache->stats().regionsEvicted, 0);
+    }
+    const auto cacheEntries = cache_->testingCacheEntries();
+    for (const auto& cacheEntry : cacheEntries) {
+      if (testData.noCacheRetention) {
+        ASSERT_EQ(cacheEntry->testingAccessStats().numUses, 0);
+        ASSERT_EQ(cacheEntry->testingAccessStats().lastUse, 0);
+      } else {
+        ASSERT_GE(cacheEntry->testingAccessStats().numUses, 0);
+        ASSERT_NE(cacheEntry->testingAccessStats().lastUse, 0);
+      }
+    }
+    const auto stats = cache_->refreshStats();
+    ASSERT_EQ(stats.numEvict, 0);
+    ASSERT_EQ(stats.numEntries, cacheEntries.size());
+  }
+}
+
+TEST_F(CacheTest, loadQuotumTooLarge) {
+  initializeCache(64 << 20, 256 << 20);
+  auto fileId = std::make_unique<StringIdLease>(fileIds(), "foo");
+  auto readFile =
+      std::make_shared<TestReadFile>(fileId->id(), 10 << 20, nullptr);
+  auto readOptions = io::ReaderOptions(pool_.get());
+  readOptions.setLoadQuantum(9 << 20 /*9MB*/);
+  VELOX_ASSERT_THROW(
+      std::make_unique<CachedBufferedInput>(
+          readFile,
+          MetricsLog::voidLog(),
+          fileId->id(),
+          cache_.get(),
+          nullptr,
+          0,
+          nullptr,
+          executor_.get(),
+          readOptions),
+      "Load quantum exceeded SSD cache entry size limit");
+}
+
+TEST_F(CacheTest, ssdReadVerification) {
+  constexpr int64_t kMemoryBytes = 32 << 20;
+  constexpr int64_t kSsdBytes = 256 << 20;
+  // 32 RAM, 256MB SSD, with checksumWrite/checksumReadVerification enabled.
+  initializeCache(kMemoryBytes, kSsdBytes, true);
+
+  uint64_t fileId;
+  uint64_t groupId;
+  auto file = inputByPath("test_file", fileId, groupId);
+  auto tracker = std::make_shared<ScanTracker>(
+      "testTracker", nullptr, io::ReaderOptions::kDefaultLoadQuantum);
+  auto input = std::make_unique<CachedBufferedInput>(
+      file,
+      MetricsLog::voidLog(),
+      fileId,
+      cache_.get(),
+      tracker,
+      groupId,
+      ioStats_,
+      executor_.get(),
+      io::ReaderOptions(pool_.get()));
+
+  const auto readData = [&](uint32_t numBytesRead) {
+    const uint64_t kNumBytesPerRead = 4 << 20;
+    for (uint64_t offset = 0; offset < numBytesRead;
+         offset += kNumBytesPerRead) {
+      auto stream = input->read(offset, kNumBytesPerRead, LogType::TEST);
+      const void* buffer;
+      int32_t size;
+      int32_t bytes = 0;
+      while (bytes < kNumBytesPerRead) {
+        EXPECT_TRUE(stream->Next(&buffer, &size));
+        bytes += size;
+      }
+    }
+  };
+
+  // Read kMemoryBytes of data.
+  readData(kMemoryBytes);
+  waitForWrite();
+  auto stats = cache_->refreshStats();
+  // This is a cold read, so expect no cache hit.
+  ASSERT_EQ(stats.numHit, 0);
+  ASSERT_EQ(stats.ssdStats->entriesRead, 0);
+  ASSERT_EQ(stats.ssdStats->readSsdCorruptions, 0);
+  ASSERT_GT(ioStats_->read().sum(), 0);
+  ASSERT_EQ(ioStats_->ramHit().sum(), 0);
+  ASSERT_EQ(ioStats_->ssdRead().sum(), 0);
+
+  // Read kSsdBytes of data.
+  readData(kSsdBytes);
+  waitForWrite();
+  stats = cache_->refreshStats();
+  // Expect memory cache hits.
+  ASSERT_GT(stats.numHit, 0);
+  ASSERT_EQ(stats.ssdStats->entriesRead, 0);
+  ASSERT_EQ(stats.ssdStats->readSsdCorruptions, 0);
+  ASSERT_GT(ioStats_->read().sum(), 0);
+  ASSERT_GT(ioStats_->ramHit().sum(), 0);
+  ASSERT_EQ(ioStats_->ssdRead().sum(), 0);
+
+  // Read kSsdBytes of data.
+  readData(kSsdBytes);
+  waitForWrite();
+  stats = cache_->refreshStats();
+  // Expect SSD cache hits.
+  ASSERT_GT(stats.numHit, 0);
+  ASSERT_GT(stats.ssdStats->entriesRead, 0);
+  ASSERT_EQ(stats.ssdStats->readSsdCorruptions, 0);
+  ASSERT_GT(ioStats_->read().sum(), 0);
+  ASSERT_GT(ioStats_->ramHit().sum(), 0);
+  ASSERT_GT(ioStats_->ssdRead().sum(), 0);
+
+  // Corrupt SSD cache file.
+  corruptSsdFile(fmt::format("{}/cache0", tempDirectory_->getPath()));
+  // Clear memory cache to force ssd read.
+  cache_->clear();
+
+  // Record the baseline stats.
+  const auto prevStats = cache_->refreshStats();
+  const auto prevRead = ioStats_->read().sum();
+  const auto prevRamHit = ioStats_->ramHit().sum();
+  const auto prevSsdRead = ioStats_->ssdRead().sum();
+
+  // Read from the corrupted cache.
+  readData(kSsdBytes);
+  waitForWrite();
+  stats = cache_->refreshStats();
+  // Expect all new reads to be recorded as corruptions.
+  ASSERT_GT(ioStats_->read().sum(), prevRead);
+  ASSERT_GT(stats.ssdStats->readSsdCorruptions, 0);
+  ASSERT_EQ(
+      stats.ssdStats->readSsdCorruptions,
+      stats.ssdStats->entriesRead - prevStats.ssdStats->entriesRead);
+  // Expect no new succeeded cache hits.
+  ASSERT_EQ(stats.numHit, prevStats.numHit);
+  ASSERT_EQ(ioStats_->ramHit().sum(), prevRamHit);
+  ASSERT_EQ(ioStats_->ssdRead().sum(), prevSsdRead);
+}
diff --git a/velox/dwio/dwrf/test/ColumnStatisticsBase.h b/velox/dwio/dwrf/test/ColumnStatisticsBase.h
new file mode 100644
index 0000000000000..32b09aacfcf0e
--- /dev/null
+++ b/velox/dwio/dwrf/test/ColumnStatisticsBase.h
@@ -0,0 +1,975 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include "velox/dwio/common/Statistics.h"
+#include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
+
+namespace facebook::velox::dwrf {
+class ColumnStatisticsBase {
+ public:
+  ColumnStatisticsBase()
+      : arena_(std::make_unique<google::protobuf::Arena>()) {}
+
+  void testSize() {
+    {
+      StatisticsBuilder missingSize{options()};
+      ASSERT_FALSE(missingSize.getSize().has_value());
+      StatisticsBuilder hasSize{StatisticsBuilderOptions{
+          /*stringLengthLimit=*/32, /*initialSize=*/10}};
+      ASSERT_TRUE(hasSize.getSize().has_value());
+      EXPECT_EQ(10, hasSize.getSize().value());
+
+      hasSize.merge(missingSize, /*ignoreSize=*/true);
+      EXPECT_FALSE(missingSize.getSize().has_value());
+      ASSERT_TRUE(hasSize.getSize().has_value());
+      EXPECT_EQ(10, hasSize.getSize().value());
+
+      // Coercing to missing/invalid size when not ignoring by default.
+      hasSize.merge(missingSize);
+      EXPECT_FALSE(missingSize.getSize().has_value());
+      EXPECT_FALSE(hasSize.getSize().has_value());
+    }
+    {
+      StatisticsBuilder from{options()};
+      ASSERT_FALSE(from.getSize().has_value());
+
+      StatisticsBuilder to{options()};
+      ASSERT_FALSE(to.getSize().has_value());
+      to.incrementSize(64);
+      ASSERT_FALSE(to.getSize().has_value());
+
+      to.ensureSize();
+      ASSERT_EQ(0, to.getSize().value());
+      to.incrementSize(64);
+      EXPECT_EQ(64, to.getSize().value());
+
+      to.merge(from, /*ignoreSize=*/true);
+      EXPECT_FALSE(from.getSize().has_value());
+      EXPECT_EQ(64, to.getSize().value());
+
+      to.merge(from);
+      EXPECT_FALSE(from.getSize().has_value());
+      EXPECT_FALSE(to.getSize().has_value());
+    }
+  }
+
+  void testInteger() {
+    IntegerStatisticsBuilder builder{options()};
+    // empty builder should have all defaults
+    EXPECT_EQ(std::numeric_limits<int64_t>::max(), builder.getMinimum());
+    EXPECT_EQ(std::numeric_limits<int64_t>::min(), builder.getMaximum());
+    EXPECT_EQ(0, builder.getSum());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+
+    builder.addValues(3);
+    builder.addValues(1);
+    builder.addValues(5);
+
+    // stats should be merged
+    IntegerStatisticsBuilder target{options()};
+    target.merge(*builder.build());
+    auto stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(3, stats->getNumberOfValues());
+    EXPECT_EQ(1, stats->getMinimum());
+    EXPECT_EQ(5, stats->getMaximum());
+    EXPECT_EQ(9, stats->getSum());
+
+    // stats should be merged again
+    builder.addValues(0);
+    builder.addValues(6);
+    target.merge(*builder.build());
+    stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(8, stats->getNumberOfValues());
+    EXPECT_EQ(0, stats->getMinimum());
+    EXPECT_EQ(6, stats->getMaximum());
+    EXPECT_EQ(24, stats->getSum());
+
+    target.merge(*builder.build());
+    stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(13, stats->getNumberOfValues());
+    EXPECT_EQ(0, stats->getMinimum());
+    EXPECT_EQ(6, stats->getMaximum());
+    EXPECT_EQ(39, stats->getSum());
+
+    // add value
+    target.addValues(100, 2);
+    stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(15, stats->getNumberOfValues());
+    EXPECT_EQ(0, stats->getMinimum());
+    EXPECT_EQ(100, stats->getMaximum());
+    EXPECT_EQ(239, stats->getSum());
+
+    // reset
+    builder.reset();
+    EXPECT_EQ(std::numeric_limits<int64_t>::max(), builder.getMinimum());
+    EXPECT_EQ(std::numeric_limits<int64_t>::min(), builder.getMaximum());
+    EXPECT_EQ(0, builder.getSum());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+  }
+
+  void testIntegerMissingStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    IntegerStatisticsBuilder target{options()};
+    target.addValues(1, 5);
+    auto stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getSum());
+
+    // merge missing stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto intPtr = reinterpret_cast<proto::IntegerStatistics*>(protoPtr);
+      intPtr->set_minimum(0);
+      intPtr->set_maximum(1);
+      intPtr->set_sum(100);
+    } else {
+      auto intPtr = reinterpret_cast<proto::orc::IntegerStatistics*>(protoPtr);
+      intPtr->set_minimum(0);
+      intPtr->set_maximum(1);
+      intPtr->set_sum(100);
+    }
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // add again
+    target.addValues(2);
+    stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testIntegerEmptyStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    IntegerStatisticsBuilder target{options()};
+    target.addValues(1, 5);
+    auto stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getSum());
+
+    // merge empty stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getSum());
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto columnPtr = reinterpret_cast<proto::ColumnStatistics*>(protoPtr);
+      columnPtr->clear_numberofvalues();
+    } else {
+      auto columnPtr =
+          reinterpret_cast<proto::orc::ColumnStatistics*>(protoPtr);
+      columnPtr->clear_numberofvalues();
+    }
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testIntegerOverflow() {
+    IntegerStatisticsBuilder target{options()};
+    auto testMinMax =
+        [&](int64_t val1, int64_t val2, int64_t min, int64_t max) {
+          target.reset();
+          target.addValues(val1);
+          auto stats =
+              as<dwio::common::IntegerColumnStatistics>(target.build());
+          EXPECT_EQ(val1, stats->getMaximum());
+          EXPECT_EQ(val1, stats->getMinimum());
+          EXPECT_EQ(val1, stats->getSum());
+
+          target.addValues(val2);
+          stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+          EXPECT_EQ(max, stats->getMaximum());
+          EXPECT_EQ(min, stats->getMinimum());
+          EXPECT_FALSE(stats->getSum().has_value());
+        };
+
+    testMinMax(
+        std::numeric_limits<int64_t>::min(),
+        -1,
+        std::numeric_limits<int64_t>::min(),
+        -1);
+    testMinMax(
+        std::numeric_limits<int64_t>::max(),
+        1,
+        1,
+        std::numeric_limits<int64_t>::max());
+
+    // make sure we also capture overflow that happened for adding multiple
+    // items
+    target.reset();
+    target.addValues(std::numeric_limits<int64_t>::max() / 10, 11);
+    auto stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+    EXPECT_EQ(11, stats->getNumberOfValues());
+    EXPECT_EQ(stats->getMaximum().value(), stats->getMinimum().value());
+    EXPECT_FALSE(stats->getSum().has_value());
+
+    // merge overflow
+    auto testMergeOverflow = [&](int64_t val1, int64_t val2) {
+      target.reset();
+      target.addValues(val1);
+      IntegerStatisticsBuilder builder{options()};
+      builder.addValues(val2);
+      target.merge(builder);
+      stats = as<dwio::common::IntegerColumnStatistics>(target.build());
+      EXPECT_FALSE(stats->getSum().has_value());
+    };
+    testMergeOverflow(std::numeric_limits<int64_t>::min(), -1);
+    testMergeOverflow(std::numeric_limits<int64_t>::max(), 1);
+  }
+
+  void testDoubles() {
+    DoubleStatisticsBuilder builder{options()};
+    // empty builder should have all defaults
+    EXPECT_EQ(std::numeric_limits<double>::infinity(), builder.getMinimum());
+    EXPECT_EQ(-std::numeric_limits<double>::infinity(), builder.getMaximum());
+    EXPECT_EQ(0, builder.getSum());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+
+    builder.addValues(3);
+    builder.addValues(1);
+    builder.addValues(5);
+
+    // stats should be merged
+    DoubleStatisticsBuilder target{options()};
+    target.merge(*builder.build());
+    auto stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(3, stats->getNumberOfValues());
+    EXPECT_EQ(1, stats->getMinimum());
+    EXPECT_EQ(5, stats->getMaximum());
+    EXPECT_EQ(9, stats->getSum());
+
+    // stats should be merged again
+    builder.addValues(0);
+    builder.addValues(6);
+    target.merge(*builder.build());
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(8, stats->getNumberOfValues());
+    EXPECT_EQ(0, stats->getMinimum());
+    EXPECT_EQ(6, stats->getMaximum());
+    EXPECT_EQ(24, stats->getSum());
+
+    target.merge(*builder.build());
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(13, stats->getNumberOfValues());
+    EXPECT_EQ(0, stats->getMinimum());
+    EXPECT_EQ(6, stats->getMaximum());
+    EXPECT_EQ(39, stats->getSum());
+
+    // add value
+    target.addValues(100, 2);
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(15, stats->getNumberOfValues());
+    EXPECT_EQ(0, stats->getMinimum());
+    EXPECT_EQ(100, stats->getMaximum());
+    EXPECT_EQ(239, stats->getSum());
+
+    // reset
+    builder.reset();
+    EXPECT_EQ(std::numeric_limits<double>::infinity(), builder.getMinimum());
+    EXPECT_EQ(-std::numeric_limits<double>::infinity(), builder.getMaximum());
+    EXPECT_EQ(0, builder.getSum());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+  }
+
+  void testDoubleMissingStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    DoubleStatisticsBuilder target{options()};
+    target.addValues(1, 5);
+    auto stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getSum());
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto doubleProto = reinterpret_cast<proto::DoubleStatistics*>(protoPtr);
+      doubleProto->set_minimum(0);
+      doubleProto->set_maximum(1);
+      doubleProto->set_sum(100);
+    } else {
+      auto doubleProto =
+          reinterpret_cast<proto::orc::DoubleStatistics*>(protoPtr);
+      doubleProto->set_minimum(0);
+      doubleProto->set_maximum(1);
+      doubleProto->set_sum(100);
+    }
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // add again
+    target.addValues(2);
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testDoubleEmptyStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    DoubleStatisticsBuilder target{options()};
+    target.addValues(1, 5);
+    auto stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getSum());
+
+    // merge empty stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getSum());
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto columnPtr = reinterpret_cast<proto::ColumnStatistics*>(protoPtr);
+      columnPtr->clear_numberofvalues();
+    } else {
+      auto columnPtr =
+          reinterpret_cast<proto::orc::ColumnStatistics*>(protoPtr);
+      columnPtr->clear_numberofvalues();
+    }
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testDoubleNaN() {
+    DoubleStatisticsBuilder target{options()};
+    // test nan. Nan causes fallback to basic stats.
+    target.addValues(std::numeric_limits<float>::quiet_NaN());
+    auto stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    target.reset();
+    target.addValues(std::numeric_limits<double>::infinity());
+    target.addValues(-std::numeric_limits<double>::infinity());
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(stats->getMaximum(), std::numeric_limits<double>::infinity());
+    EXPECT_EQ(stats->getMinimum(), -std::numeric_limits<double>::infinity());
+    EXPECT_FALSE(stats->getSum().has_value());
+
+    target.reset();
+    DoubleStatisticsBuilder builder{options()};
+    target.addValues(std::numeric_limits<double>::infinity());
+    builder.addValues(-std::numeric_limits<double>::infinity());
+    target.merge(*builder.build());
+    stats = as<dwio::common::DoubleColumnStatistics>(target.build());
+    EXPECT_EQ(stats->getMaximum(), std::numeric_limits<double>::infinity());
+    EXPECT_EQ(stats->getMinimum(), -std::numeric_limits<double>::infinity());
+    EXPECT_FALSE(stats->getSum().has_value());
+  }
+
+  void testString() {
+    StringStatisticsBuilder builder{options()};
+    // empty builder should have all defaults
+    EXPECT_FALSE(builder.getMinimum().has_value());
+    EXPECT_FALSE(builder.getMaximum().has_value());
+    EXPECT_EQ(0, builder.getTotalLength());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+
+    builder.addValues("xx");
+    builder.addValues("bb");
+    builder.addValues("yy");
+
+    // stats should be merged
+    StringStatisticsBuilder target{options()};
+    target.merge(*builder.build());
+    auto stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(3, stats->getNumberOfValues());
+    EXPECT_EQ("bb", stats->getMinimum());
+    EXPECT_EQ("yy", stats->getMaximum());
+    EXPECT_EQ(6, stats->getTotalLength());
+
+    // stats should be merged again
+    builder.addValues("aa");
+    builder.addValues("zz");
+    target.merge(*builder.build());
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(8, stats->getNumberOfValues());
+    EXPECT_EQ("aa", stats->getMinimum());
+    EXPECT_EQ("zz", stats->getMaximum());
+    EXPECT_EQ(16, stats->getTotalLength());
+
+    target.merge(*builder.build());
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(13, stats->getNumberOfValues());
+    EXPECT_EQ("aa", stats->getMinimum());
+    EXPECT_EQ("zz", stats->getMaximum());
+    EXPECT_EQ(26, stats->getTotalLength());
+
+    // add value
+    target.addValues("zzz", 2);
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(15, stats->getNumberOfValues());
+    EXPECT_EQ("aa", stats->getMinimum());
+    EXPECT_EQ("zzz", stats->getMaximum());
+    EXPECT_EQ(32, stats->getTotalLength());
+
+    // reset
+    builder.reset();
+    EXPECT_FALSE(builder.getMinimum().has_value());
+    EXPECT_FALSE(builder.getMaximum().has_value());
+    EXPECT_EQ(0, builder.getTotalLength());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+  }
+
+  void testStringMissingStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    StringStatisticsBuilder target{options()};
+    target.addValues("zz", 5);
+    auto stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(10, stats->getTotalLength());
+
+    // merge missing stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto strProto = reinterpret_cast<proto::StringStatistics*>(protoPtr);
+      strProto->set_minimum("aa");
+      strProto->set_maximum("bb");
+      strProto->set_sum(100);
+    } else {
+      auto strProto = reinterpret_cast<proto::orc::StringStatistics*>(protoPtr);
+      strProto->set_minimum("aa");
+      strProto->set_maximum("bb");
+      strProto->set_sum(100);
+    }
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // add again
+    target.addValues("aa");
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testStringEmptyStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    StringStatisticsBuilder target{options()};
+    target.addValues("zz", 5);
+    auto stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(10, stats->getTotalLength());
+
+    // merge empty stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(10, stats->getTotalLength());
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto proto = reinterpret_cast<proto::ColumnStatistics*>(protoPtr);
+      proto->clear_numberofvalues();
+    } else {
+      auto proto = reinterpret_cast<proto::orc::ColumnStatistics*>(protoPtr);
+      proto->clear_numberofvalues();
+    }
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testStringLengthThreshold() {
+    StringStatisticsBuilder target{StatisticsBuilderOptions{2}};
+    target.addValues("yyy");
+    auto stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_FALSE(stats->getMinimum().has_value());
+    EXPECT_FALSE(stats->getMaximum().has_value());
+
+    // merge empty stats
+    target.addValues("aa");
+    target.addValues("zz");
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_EQ(stats->getMinimum(), "aa");
+    EXPECT_EQ(stats->getMaximum(), "zz");
+  }
+
+  void testStringLengthOverflow(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    // add value causing overflow
+    StringStatisticsBuilder target{options()};
+
+    if (format == DwrfFormat::kDwrf) {
+      auto strProto = reinterpret_cast<proto::StringStatistics*>(protoPtr);
+      strProto->set_sum(std::numeric_limits<int64_t>::max());
+      strProto->set_minimum("foo");
+    } else {
+      auto strProto = reinterpret_cast<proto::orc::StringStatistics*>(protoPtr);
+      strProto->set_sum(std::numeric_limits<int64_t>::max());
+      strProto->set_minimum("foo");
+    }
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    EXPECT_TRUE(target.getTotalLength().has_value());
+    auto stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_TRUE(stats->getTotalLength().has_value());
+
+    target.addValues("foo");
+    EXPECT_TRUE(target.getTotalLength().has_value());
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_FALSE(stats->getTotalLength().has_value());
+
+    // merge causing overflow
+    target.reset();
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    EXPECT_TRUE(target.getTotalLength().has_value());
+    stats = as<dwio::common::StringColumnStatistics>(target.build());
+    EXPECT_FALSE(stats->getTotalLength().has_value());
+  }
+
+  void testBoolean() {
+    BooleanStatisticsBuilder builder{options()};
+    // empty builder should have all defaults
+    EXPECT_EQ(0, builder.getTrueCount());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+
+    builder.addValues(true, 2);
+
+    // stats should be merged
+    BooleanStatisticsBuilder target{options()};
+    target.merge(*builder.build());
+    auto stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(2, stats->getNumberOfValues());
+    EXPECT_EQ(2, stats->getTrueCount());
+
+    // stats should be merged again
+    target.merge(*builder.build());
+    stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(4, stats->getNumberOfValues());
+    EXPECT_EQ(4, stats->getTrueCount());
+
+    // add value
+    target.addValues(false, 2);
+    stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(6, stats->getNumberOfValues());
+    EXPECT_EQ(4, stats->getTrueCount());
+
+    // reset
+    builder.reset();
+    EXPECT_EQ(0, builder.getTrueCount());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+  }
+
+  void testBooleanMissingStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    BooleanStatisticsBuilder target{options()};
+    target.addValues(true, 5);
+    auto stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getTrueCount());
+
+    // merge missing stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto boolProto = reinterpret_cast<proto::BucketStatistics*>(protoPtr);
+      boolProto->add_count(1);
+    } else {
+      auto boolProto =
+          reinterpret_cast<proto::orc::BucketStatistics*>(protoPtr);
+      boolProto->add_count(1);
+    }
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // add again
+    target.addValues(true);
+    stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testBooleanEmptyStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    BooleanStatisticsBuilder target{options()};
+    target.addValues(true, 5);
+    auto stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getTrueCount());
+
+    // merge empty stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getTrueCount());
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto proto = reinterpret_cast<proto::ColumnStatistics*>(protoPtr);
+      proto->clear_numberofvalues();
+    } else {
+      auto proto = reinterpret_cast<proto::orc::ColumnStatistics*>(protoPtr);
+      proto->clear_numberofvalues();
+    }
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::BooleanColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testBasic() {
+    StatisticsBuilder builder{options()};
+    EXPECT_EQ(0, builder.getNumberOfValues());
+    EXPECT_EQ(0, builder.getRawSize());
+    EXPECT_FALSE(builder.hasNull().value());
+
+    builder.increaseValueCount(5);
+    builder.increaseRawSize(10);
+    builder.setHasNull();
+
+    // stats should be merged
+    StatisticsBuilder target{options()};
+    target.merge(*builder.build());
+    auto stats = target.build();
+    EXPECT_EQ(5, stats->getNumberOfValues());
+    EXPECT_EQ(10, stats->getRawSize());
+    EXPECT_TRUE(stats->hasNull().value());
+
+    // stats should be merged again
+    target.merge(*builder.build());
+    stats = target.build();
+    EXPECT_EQ(10, stats->getNumberOfValues());
+    EXPECT_EQ(20, stats->getRawSize());
+    EXPECT_TRUE(stats->hasNull().value());
+
+    // add value
+    target.increaseValueCount(1);
+    target.increaseRawSize(2);
+    stats = target.build();
+    EXPECT_EQ(11, stats->getNumberOfValues());
+    EXPECT_EQ(22, stats->getRawSize());
+    EXPECT_TRUE(stats->hasNull().value());
+
+    // reset
+    builder.reset();
+    EXPECT_EQ(0, builder.getNumberOfValues());
+    EXPECT_EQ(0, builder.getRawSize());
+    EXPECT_FALSE(builder.hasNull().value());
+  }
+
+  void testBasicMissingStats(ColumnStatisticsWrapper columnStatisticsWrapper) {
+    StatisticsBuilder target{options()};
+    target.increaseValueCount(5);
+    target.increaseRawSize(10);
+    auto stats = target.build();
+    EXPECT_EQ(5, stats->getNumberOfValues());
+    EXPECT_EQ(10, stats->getRawSize());
+    EXPECT_FALSE(stats->hasNull().value());
+
+    // merge missing stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = target.build();
+    EXPECT_FALSE(stats->getNumberOfValues().has_value());
+    EXPECT_FALSE(stats->getRawSize().has_value());
+    EXPECT_FALSE(stats->hasNull().has_value());
+
+    // add again
+    target.increaseValueCount(5);
+    target.increaseRawSize(10);
+    target.setHasNull();
+    stats = target.build();
+    EXPECT_FALSE(stats->getNumberOfValues().has_value());
+    EXPECT_FALSE(stats->getRawSize().has_value());
+    EXPECT_TRUE(stats->hasNull().value());
+  }
+
+  void testBasicHasNull(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      DwrfFormat format) {
+    enum class State { kTrue = 0, kFalse, kMissing };
+    auto test = [&](State to, State from, State expected) {
+      StatisticsBuilder target{options()};
+      if (to == State::kTrue) {
+        target.setHasNull();
+      } else if (to == State::kMissing) {
+        // merge against unknown
+        target.merge(*buildColumnStatisticsFromProto(
+            columnStatisticsWrapper, context()));
+      }
+
+      if (format == DwrfFormat::kDwrf) {
+        auto columnStatistics =
+            google::protobuf::Arena::CreateMessage<proto::ColumnStatistics>(
+                arena_.get());
+        if (from == State::kFalse) {
+          columnStatistics->set_hasnull(false);
+        } else if (from == State::kTrue) {
+          columnStatistics->set_hasnull(true);
+        }
+        target.merge(*buildColumnStatisticsFromProto(
+            ColumnStatisticsWrapper(columnStatistics), context()));
+      } else {
+        auto columnStatistics = google::protobuf::Arena::CreateMessage<
+            proto::orc::ColumnStatistics>(arena_.get());
+        if (from == State::kFalse) {
+          columnStatistics->set_hasnull(false);
+        } else if (from == State::kTrue) {
+          columnStatistics->set_hasnull(true);
+        }
+        target.merge(*buildColumnStatisticsFromProto(
+            ColumnStatisticsWrapper(columnStatistics), context()));
+      }
+      auto stats = target.build();
+      if (expected == State::kFalse) {
+        EXPECT_FALSE(stats->hasNull().value());
+      } else if (expected == State::kTrue) {
+        EXPECT_TRUE(stats->hasNull().value());
+      } else {
+        EXPECT_FALSE(stats->hasNull().has_value());
+      }
+    };
+
+    // true / any => true
+    test(State::kTrue, State::kTrue, State::kTrue);
+    test(State::kTrue, State::kFalse, State::kTrue);
+    test(State::kTrue, State::kMissing, State::kTrue);
+    // unknown / true => true
+    // unknown / unknown or false => unknown
+    test(State::kMissing, State::kTrue, State::kTrue);
+    test(State::kMissing, State::kFalse, State::kMissing);
+    test(State::kMissing, State::kMissing, State::kMissing);
+    // false / unknown => unknown
+    // false / false => false
+    // false / true => true
+    test(State::kFalse, State::kMissing, State::kMissing);
+    test(State::kFalse, State::kFalse, State::kFalse);
+    test(State::kFalse, State::kTrue, State::kTrue);
+  }
+
+  void testBinary() {
+    BinaryStatisticsBuilder builder{options()};
+    // empty builder should have all defaults
+    EXPECT_EQ(0, builder.getTotalLength());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+
+    builder.addValues(5, 2);
+
+    // stats should be merged
+    BinaryStatisticsBuilder target{options()};
+    target.merge(*builder.build());
+    auto stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(2, stats->getNumberOfValues());
+    EXPECT_EQ(10, stats->getTotalLength());
+
+    // stats should be merged again
+    target.merge(*builder.build());
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(4, stats->getNumberOfValues());
+    EXPECT_EQ(20, stats->getTotalLength());
+
+    // add value
+    target.addValues(10);
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getNumberOfValues());
+    EXPECT_EQ(30, stats->getTotalLength());
+
+    // reset
+    builder.reset();
+    EXPECT_EQ(0, builder.getTotalLength());
+    EXPECT_EQ(0, builder.getNumberOfValues());
+  }
+
+  void testBinaryMissingStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    BinaryStatisticsBuilder target{options()};
+    target.addValues(5);
+    auto stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getTotalLength());
+
+    // merge missing stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto binProto = reinterpret_cast<proto::BinaryStatistics*>(protoPtr);
+      binProto->set_sum(100);
+    } else {
+      auto binProto = reinterpret_cast<proto::orc::BinaryStatistics*>(protoPtr);
+      binProto->set_sum(100);
+    }
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // add again
+    target.addValues(10);
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testBinaryEmptyStats(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    BinaryStatisticsBuilder target{options()};
+    target.addValues(5);
+    auto stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getTotalLength());
+
+    // merge empty stats
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(5, stats->getTotalLength());
+
+    // merge again
+    if (format == DwrfFormat::kDwrf) {
+      auto proto = reinterpret_cast<proto::ColumnStatistics*>(protoPtr);
+      proto->clear_numberofvalues();
+    } else {
+      auto proto = reinterpret_cast<proto::orc::ColumnStatistics*>(protoPtr);
+      proto->clear_numberofvalues();
+    }
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testBinaryLengthOverflow(
+      ColumnStatisticsWrapper columnStatisticsWrapper,
+      void* protoPtr,
+      DwrfFormat format) {
+    // add value causing overflow
+    BinaryStatisticsBuilder target{options()};
+    target.addValues(std::numeric_limits<int64_t>::max());
+    auto stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_NE(stats, nullptr);
+    target.addValues(1);
+    EXPECT_TRUE(target.getTotalLength().has_value());
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+
+    // merge causing overflow
+    target.reset();
+    target.addValues(std::numeric_limits<int64_t>::max());
+
+    if (format == DwrfFormat::kDwrf) {
+      auto binProto = reinterpret_cast<proto::BinaryStatistics*>(protoPtr);
+      binProto->set_sum(1);
+    } else {
+      auto binProto = reinterpret_cast<proto::orc::BinaryStatistics*>(protoPtr);
+      binProto->set_sum(1);
+    }
+
+    target.merge(
+        *buildColumnStatisticsFromProto(columnStatisticsWrapper, context()));
+    EXPECT_TRUE(target.getTotalLength().has_value());
+    stats = as<dwio::common::BinaryColumnStatistics>(target.build());
+    EXPECT_EQ(stats, nullptr);
+  }
+
+  void testInitialSize() {
+    StatisticsBuilder target{options()};
+    target.increaseValueCount(1);
+    EXPECT_FALSE(target.getSize().has_value());
+    auto stats = target.build();
+    EXPECT_FALSE(stats->getSize().has_value());
+
+    StatisticsBuilder target2{StatisticsBuilderOptions{16, 100U}};
+    target2.increaseValueCount(1);
+    EXPECT_EQ(target2.getSize().value(), 100);
+    stats = target2.build();
+    EXPECT_EQ(stats->getSize().value(), 100);
+    target2.reset();
+    EXPECT_EQ(target2.getSize().value(), 100);
+    stats = target2.build();
+    EXPECT_EQ(stats->getSize().value(), 100);
+  }
+
+ protected:
+  StatisticsBuilderOptions options() {
+    StatisticsBuilderOptions options{16};
+    return options;
+  }
+
+  facebook::velox::dwrf::StatsContext context() {
+    facebook::velox::dwrf::StatsContext context{WriterVersion_CURRENT};
+    return context;
+  }
+
+  template <typename T, typename U>
+  std::unique_ptr<T> as(std::unique_ptr<U>&& ptr) {
+    auto p = ptr.release();
+    if (auto cp = dynamic_cast<T*>(p)) {
+      return std::unique_ptr<T>(cp);
+    }
+    delete p;
+    return nullptr;
+  }
+
+ private:
+  std::unique_ptr<google::protobuf::Arena> arena_;
+};
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp b/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp
new file mode 100644
index 0000000000000..b0a9ca5368dc6
--- /dev/null
+++ b/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp
@@ -0,0 +1,1506 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/dwrf/test/OrcTest.h"
+#include "velox/dwio/dwrf/writer/ColumnWriter.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/FlatVector.h"
+
+using namespace ::testing;
+using namespace facebook::velox;
+using namespace facebook::velox::dwrf;
+using namespace facebook::velox::dwio::common;
+
+using facebook::velox::memory::MemoryPool;
+
+namespace facebook::velox::dwrf {
+
+namespace {
+template <typename Integer>
+Integer generateDistinctValues(size_t i, size_t /* unused */) {
+  return i;
+}
+
+template <typename Integer>
+Integer generateSomewhatRandomData(size_t i, size_t size) {
+  int64_t val = size % (i + 1);
+  return i % 2 ? val : -val;
+}
+
+std::string alphabeticRoundRobin(size_t index, size_t size) {
+  char element = 'a' + index % 26;
+  return std::string(size % (index + 1), element);
+}
+
+bool someNulls(size_t i, size_t size) {
+  return (size % (i + 1)) % 2;
+}
+
+bool neverAbandonDict(size_t /* unused */, size_t /* unused */) {
+  return false;
+}
+
+std::function<bool(size_t, size_t)> abandonNthWrite(size_t n) {
+  return [n](size_t stripeCount, size_t pageCount) {
+    return stripeCount == 0 && pageCount == n;
+  };
+}
+
+bool abandonEveryWrite(size_t /* unused */, size_t /* unused */) {
+  return true;
+}
+
+template <typename T>
+VectorPtr prepBatchImpl(
+    size_t size,
+    MemoryPool* pool,
+    std::function<T(size_t, size_t)> genData,
+    std::function<bool(size_t, size_t)> genNulls) {
+  BufferPtr nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), pool);
+  auto* nullsPtr = nulls->asMutable<uint64_t>();
+  size_t nullCount = 0;
+
+  BufferPtr values = AlignedBuffer::allocate<T>(size, pool);
+  auto valuesPtr = values->asMutableRange<T>();
+
+  for (size_t i = 0; i < size; ++i) {
+    bool isPresent = genNulls(i, size);
+    bits::setNull(nullsPtr, i, !isPresent);
+
+    if (!isPresent) {
+      nullCount++;
+      // valuesPtr[i] = 0;
+    } else {
+      valuesPtr[i] = genData(i, size);
+    }
+  }
+
+  auto batch = std::make_shared<FlatVector<T>>(
+      pool,
+      CppToType<T>::create(),
+      nulls,
+      size,
+      values,
+      std::vector<BufferPtr>());
+  batch->setNullCount(nullCount);
+  return batch;
+}
+
+VectorPtr prepStringBatchImpl(
+    size_t size,
+    MemoryPool* pool,
+    std::function<std::string(size_t, size_t)> genData,
+    std::function<bool(size_t, size_t)> genNulls) {
+  BufferPtr nulls = allocateNulls(size, pool);
+  auto* nullsPtr = nulls->asMutable<uint64_t>();
+  size_t nullCount = 0;
+
+  BufferPtr values = AlignedBuffer::allocate<StringView>(size, pool);
+  auto* valuesPtr = values->asMutable<StringView>();
+
+  std::vector<BufferPtr> dataChunks;
+  BufferPtr dataChunk = AlignedBuffer::allocate<char>(1024, pool);
+  dataChunks.push_back(dataChunk);
+  auto* dataChunkPtr = dataChunk->asMutable<char>();
+  size_t offset = 0;
+
+  // Prepare input
+  for (size_t i = 0; i < size; ++i) {
+    bool isPresent = genNulls(i, size);
+    bits::setNull(nullsPtr, i, !isPresent);
+
+    if (isPresent) {
+      auto val = genData(i, size);
+      if (offset + val.size() > dataChunk->capacity()) {
+        dataChunk = AlignedBuffer::allocate<char>(1024, pool);
+        dataChunks.push_back(dataChunk);
+        dataChunkPtr = dataChunk->asMutable<char>();
+        offset = 0;
+      }
+
+      memcpy(dataChunkPtr + offset, val.data(), val.size());
+      valuesPtr[i] = StringView(dataChunkPtr + offset, val.size());
+      offset += val.size();
+    } else {
+      nullCount++;
+    }
+  }
+
+  auto batch = std::make_shared<FlatVector<StringView>>(
+      pool, VARCHAR(), nulls, size, values, std::move(dataChunks));
+  batch->setNullCount(nullCount);
+  return batch;
+}
+
+void validateBasicStats(const VectorPtr& batch, const ColumnStatistics& stats) {
+  ASSERT_EQ(batch->getNullCount().value() > 0, stats.hasNull().value());
+  ASSERT_EQ(
+      batch->size() - batch->getNullCount().value(), stats.getNumberOfValues());
+}
+
+template <typename INTEGER>
+void validateIntStats(const VectorPtr& batch, const ColumnStatistics& stats) {
+  int64_t min = std::numeric_limits<int64_t>::max();
+  int64_t max = std::numeric_limits<int64_t>::min();
+  int64_t sum = 0;
+  auto* converted = batch->as<FlatVector<INTEGER>>();
+  for (size_t i = 0; i < converted->size(); ++i) {
+    if (!converted->isNullAt(i)) {
+      auto val = converted->valueAt(i);
+      if (val < min) {
+        min = val;
+      }
+      if (val > max) {
+        max = val;
+      }
+      sum += val;
+    }
+  }
+  auto& intStats = dynamic_cast<const IntegerColumnStatistics&>(stats);
+  ASSERT_EQ(min, intStats.getMinimum());
+  ASSERT_EQ(max, intStats.getMaximum());
+  ASSERT_EQ(sum, intStats.getSum());
+}
+
+void validateBooleanStats(
+    const VectorPtr& batch,
+    const ColumnStatistics& stats) {
+  uint64_t trueCount = 0;
+  auto* converted = batch->as<FlatVector<bool>>();
+  for (size_t i = 0; i < converted->size(); ++i) {
+    if (!converted->isNullAt(i)) {
+      if (converted->valueAt(i)) {
+        ++trueCount;
+      }
+    }
+  }
+  auto& boolStats = dynamic_cast<const BooleanColumnStatistics&>(stats);
+  ASSERT_EQ(trueCount, boolStats.getTrueCount());
+}
+
+void validateStringStats(
+    const VectorPtr& batch,
+    const ColumnStatistics& stats) {
+  auto* converted = batch->as<FlatVector<StringView>>();
+  std::string min;
+  std::string max;
+  int64_t length = 0;
+  bool first = true;
+  for (size_t i = 0; i < converted->size(); ++i) {
+    if (!converted->isNullAt(i)) {
+      auto val = converted->valueAt(i).str();
+      if (first) {
+        min = val;
+        max = val;
+        first = false;
+      } else {
+        if (val < min) {
+          min = val;
+        }
+        if (val > max) {
+          max = val;
+        }
+      }
+      length += val.size();
+    }
+  }
+  auto& strStats = dynamic_cast<const StringColumnStatistics&>(stats);
+  ASSERT_EQ(min, strStats.getMinimum());
+  ASSERT_EQ(max, strStats.getMaximum());
+  ASSERT_EQ(length, strStats.getTotalLength());
+}
+
+template <typename FLOAT>
+void validateDoubleStats(
+    const VectorPtr& batch,
+    const ColumnStatistics& stats) {
+  double min = std::numeric_limits<double>::infinity();
+  double max = -std::numeric_limits<double>::infinity();
+  double sum = 0;
+  auto* converted = batch->as<FlatVector<FLOAT>>();
+  for (size_t i = 0; i < converted->size(); ++i) {
+    if (!converted->isNullAt(i)) {
+      auto val = converted->valueAt(i);
+      if (val < min) {
+        min = val;
+      }
+      if (val > max) {
+        max = val;
+      }
+      sum += val;
+    }
+  }
+  auto& doubleStats = dynamic_cast<const DoubleColumnStatistics&>(stats);
+  ASSERT_EQ(min, doubleStats.getMinimum());
+  ASSERT_EQ(max, doubleStats.getMaximum());
+  ASSERT_EQ(sum, doubleStats.getSum());
+}
+
+void validateBinaryStats(
+    const VectorPtr& batch,
+    const ColumnStatistics& stats) {
+  auto* converted = batch->as<FlatVector<StringView>>();
+  int64_t length = 0;
+  for (size_t i = 0; i < converted->size(); ++i) {
+    if (!converted->isNullAt(i)) {
+      length += converted->valueAt(i).size();
+    }
+  }
+  auto& binStats = dynamic_cast<const BinaryColumnStatistics&>(stats);
+  ASSERT_EQ(length, binStats.getTotalLength());
+}
+
+} // namespace
+
+class WriterEncodingIndexTest2 {
+ public:
+  WriterEncodingIndexTest2(TypePtr type)
+      : config_{std::make_shared<Config>()},
+        pool_{facebook::velox::memory::memoryManager()->addLeafPool()},
+        type_{std::move(type)} {}
+
+  virtual ~WriterEncodingIndexTest2() = default;
+
+  void runTest(
+      size_t pageCount,
+      size_t recordPositionCount,
+      size_t backfillPositionCount,
+      size_t stripeCount,
+      bool isRoot = false) {
+    runTest(
+        pageCount,
+        std::vector<size_t>{recordPositionCount},
+        std::vector<size_t>{backfillPositionCount},
+        stripeCount,
+        isRoot);
+  }
+
+  void runTest(
+      size_t pageCount,
+      const std::vector<size_t>& recordPositionCount,
+      const std::vector<size_t>& backfillPositionCount,
+      size_t stripeCount,
+      bool isRoot = false,
+      size_t flatMapOffset = 0) {
+    auto isFlatMap = isRoot && flatMapOffset > 0;
+    ASSERT_EQ(recordPositionCount.size(), backfillPositionCount.size());
+    WriterContext context{
+        config_,
+        velox::memory::memoryManager()->addRootPool(
+            "WriterEncodingIndexTest2")};
+    context.initBuffer();
+    std::vector<StrictMock<MockIndexBuilder>*> mocks;
+    for (auto i = 0; i < recordPositionCount.size(); ++i) {
+      mocks.push_back(new StrictMock<MockIndexBuilder>());
+    }
+    // Hack: for flat map, value node is destructed after each stripe and hence
+    // index build is also destructed. So reset pos when all the pointers are
+    // used, and meanwhile, create new index builder after every flush
+    size_t pos = 0;
+    context.indexBuilderFactory_ =
+        [&](auto stream) -> std::unique_ptr<IndexBuilder> {
+      if (pos < recordPositionCount.size()) {
+        auto ptr = std::unique_ptr<StrictMock<MockIndexBuilder>>(mocks[pos++]);
+        if (isFlatMap && pos == mocks.size()) {
+          pos = flatMapOffset + 1;
+        }
+        return ptr;
+      } else {
+        return std::make_unique<IndexBuilder>(std::move(stream));
+      }
+    };
+
+    auto typeWithId = TypeWithId::create(type_, isRoot ? 0 : 1);
+    auto batch = prepBatch(1000, pool_.get(), isRoot);
+
+    // Creating a stream calls recordPosition.
+    for (auto n = 0; n < mocks.size(); ++n) {
+      EXPECT_CALL(*mocks.at(n), add(0, -1)).Times(recordPositionCount[n]);
+    }
+    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
+
+    // Indices are captured the same way for all stripes in the derived tests.
+    for (size_t j = 0; j != stripeCount; ++j) {
+      for (size_t i = 0; i != pageCount; ++i) {
+        columnWriter->write(batch, common::Ranges::of(0, 1000));
+        for (auto n = 0; n < mocks.size(); ++n) {
+          EXPECT_CALL(*mocks.at(n), addEntry(_))
+              .WillOnce(Invoke([&, k = n](const StatisticsBuilder& builder) {
+                auto stats = builder.build();
+                if (k == 0) {
+                  validateStats(batch, *stats);
+                }
+              }));
+          // RecordPosition is invoked on call to createIndexEntry
+          EXPECT_CALL(*mocks.at(n), add(_, -1)).Times(recordPositionCount[n]);
+        }
+        columnWriter->createIndexEntry();
+      }
+
+      for (auto n = 0; n < mocks.size(); ++n) {
+        if (backfillPositionCount[n]) {
+          // Backfill starting positions for starting stride.
+          // All Inherited tests have starting position as 0.
+          EXPECT_CALL(*mocks.at(n), add(0, 0)).Times(backfillPositionCount[n]);
+          for (size_t i = 1; i != pageCount + 1; ++i) {
+            // Backfilling all but PRESENT positions for all subsequent strides.
+            EXPECT_CALL(*mocks.at(n), add(_, i))
+                .Times(backfillPositionCount[n]);
+          }
+        }
+        EXPECT_CALL(*mocks.at(n), flush());
+        if (!(isFlatMap && n > flatMapOffset)) {
+          // Recording positions for the new stripe.
+          EXPECT_CALL(*mocks.at(n), add(0, -1)).Times(recordPositionCount[n]);
+        }
+      }
+      proto::StripeFooter stripeFooter;
+      columnWriter->flush(
+          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
+            return *stripeFooter.add_encoding();
+          });
+
+      // Simulate continue writing to next stripe, so internally buffered data
+      // is cleared
+      context.nextStripe();
+      columnWriter->reset();
+
+      // create new index builders
+      if (isFlatMap && j < stripeCount - 1) {
+        EXPECT_EQ(pos, flatMapOffset + 1);
+        for (auto i = flatMapOffset + 1; i < recordPositionCount.size(); ++i) {
+          mocks[i] = new StrictMock<MockIndexBuilder>();
+          // Recording positions for the new stripe.
+          EXPECT_CALL(*mocks.at(i), add(0, -1)).Times(recordPositionCount[i]);
+        }
+      }
+    }
+  }
+
+ protected:
+  virtual VectorPtr prepBatch(size_t size, MemoryPool* pool) = 0;
+
+  virtual VectorPtr prepBatch(size_t size, MemoryPool* pool, bool isRoot) {
+    return prepBatch(size, pool);
+  }
+
+  virtual void validateStats(
+      const VectorPtr& batch,
+      const ColumnStatistics& stats) {
+    validateBasicStats(batch, stats);
+  }
+
+  std::shared_ptr<Config> config_;
+  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
+  const TypePtr type_;
+};
+
+class TimestampWriterIndexTest : public testing::Test,
+                                 public WriterEncodingIndexTest2 {
+ public:
+  TimestampWriterIndexTest() : WriterEncodingIndexTest2(TIMESTAMP()) {}
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    return prepBatchImpl<Timestamp>(
+        size,
+        pool_.get(),
+        [](size_t i, size_t /*unused*/) -> Timestamp {
+          return Timestamp(i, i);
+        },
+        someNulls);
+  }
+
+  // timestamp column only has basic stats, so validation method in base class
+  // is sufficient
+};
+
+TEST_F(TimestampWriterIndexTest, TestIndex) {
+  // Present Stream has 4. seconds and nanos are Ints with 3 each.
+  // 4+3+3 = 10. There is no backfill.
+  runTest(2, 10, 0, 0);
+  runTest(2, 10, 0, 1);
+  runTest(2, 10, 0, 100);
+}
+
+template <typename Integer>
+class IntegerColumnWriterDictionaryEncodingIndexTest
+    : public testing::Test,
+      public WriterEncodingIndexTest2 {
+ public:
+  explicit IntegerColumnWriterDictionaryEncodingIndexTest()
+      : WriterEncodingIndexTest2(CppToType<Integer>::create()) {
+    this->config_->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 1.0f);
+  }
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    return prepBatchImpl<Integer>(
+        size, pool, generateSomewhatRandomData<Integer>, someNulls);
+  }
+
+  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
+      override {
+    validateBasicStats(batch, stats);
+    validateIntStats<Integer>(batch, stats);
+  }
+};
+
+using DictionaryTypes = ::testing::Types<int16_t, int32_t, int64_t>;
+VELOX_TYPED_TEST_SUITE(
+    IntegerColumnWriterDictionaryEncodingIndexTest,
+    DictionaryTypes);
+
+TYPED_TEST(IntegerColumnWriterDictionaryEncodingIndexTest, WriteAllStreams) {
+  // Present stream uses 4 positions.
+  // compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining
+  constexpr size_t RECORD_POSITION_COUNT = 4;
+
+  // Data Stream 3 Positions
+  // In Dictionary 4 positions (Similar to Present Stream)
+  constexpr size_t BACKFILL_POSITION_COUNT = 7;
+
+  this->runTest(1, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 0);
+
+  this->runTest(1, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 1);
+  this->runTest(1, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 100);
+}
+
+TYPED_TEST(IntegerColumnWriterDictionaryEncodingIndexTest, OmitInDictStream) {
+  // Present stream uses 4 positions.
+  // compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining
+  constexpr size_t RECORD_POSITION_COUNT = 4;
+
+  // Data Stream 3 Positions
+  constexpr size_t BACKFILL_POSITION_COUNT = 3;
+
+  // Writing the batch twice so that all values are in dictionary.
+  this->runTest(2, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 0);
+  this->runTest(2, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 1);
+  this->runTest(2, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 100);
+}
+
+class BoolColumnWriterEncodingIndexTest : public testing::Test,
+                                          public WriterEncodingIndexTest2 {
+ public:
+  explicit BoolColumnWriterEncodingIndexTest()
+      : WriterEncodingIndexTest2(BOOLEAN()) {}
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    return prepBatchImpl<bool>(
+        size,
+        pool,
+        [](size_t i, size_t /*unused*/) -> bool { return true; },
+        [](size_t i, size_t /*unused*/) -> bool { return i % 3 == 0; });
+  }
+
+  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
+      override {
+    validateBasicStats(batch, stats);
+    validateBooleanStats(batch, stats);
+  }
+};
+
+TEST_F(BoolColumnWriterEncodingIndexTest, TestIndex) {
+  // Boolean Stream uses one Stream for Presence and Other Stream for data
+  // Each Stream has compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining , so 4+4 =8. It has no back fill streams.
+  runTest(2, 8, 0, 0);
+  runTest(2, 8, 0, 1);
+  runTest(2, 8, 0, 100);
+}
+
+class ByteColumnWriterEncodingIndexTest : public testing::Test,
+                                          public WriterEncodingIndexTest2 {
+ public:
+  explicit ByteColumnWriterEncodingIndexTest()
+      : WriterEncodingIndexTest2(TINYINT()) {}
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    int8_t value = 0;
+    return prepBatchImpl<int8_t>(
+        size,
+        pool,
+        [&value](size_t i, size_t /*unused*/) -> int8_t { return value++; },
+        [](size_t i, size_t /*unused*/) -> bool { return i % INT8_MAX == 0; });
+  }
+
+  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
+      override {
+    validateBasicStats(batch, stats);
+    validateIntStats<int8_t>(batch, stats);
+  }
+};
+
+TEST_F(ByteColumnWriterEncodingIndexTest, TestIndex) {
+  // Byte Stream has presence Stream and data stream.
+  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining (4)
+  // Data stream has compressed size, uncompressed size, ByteRLE numLiterals (3)
+  // so total Streams(4+3) = 7. It has no back fill streams.
+
+  runTest(2, 7, 0, 0);
+  runTest(2, 7, 0, 1);
+  runTest(2, 7, 0, 100);
+}
+
+class BinaryColumnWriterEncodingIndexTest : public testing::Test,
+                                            public WriterEncodingIndexTest2 {
+ public:
+  BinaryColumnWriterEncodingIndexTest()
+      : WriterEncodingIndexTest2(VARBINARY()) {}
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    BufferPtr nulls = allocateNulls(size, pool);
+    auto* nullsPtr = nulls->asMutable<uint64_t>();
+    size_t nullCount = 0;
+
+    BufferPtr values = AlignedBuffer::allocate<StringView>(size, pool);
+    auto* valuesPtr = values->asMutable<StringView>();
+
+    auto data = AlignedBuffer::allocate<char>(100, pool);
+    auto dataPtr = data->asMutable<char>();
+    std::memset(dataPtr, 'a', 100);
+
+    size_t value = 0;
+    size_t nullEvery = 10;
+    for (size_t i = 0; i < size; ++i) {
+      if (i % nullEvery != 0) {
+        bits::clearNull(nullsPtr, i);
+        valuesPtr[i] = StringView(dataPtr, value++);
+        value %= 50;
+      } else {
+        bits::setNull(nullsPtr, i);
+        nullCount++;
+      }
+    }
+
+    auto batch = std::make_shared<FlatVector<StringView>>(
+        pool, VARCHAR(), nulls, size, values, std::vector<BufferPtr>{data});
+    batch->setNullCount(nullCount);
+    return batch;
+  }
+
+  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
+      override {
+    validateBasicStats(batch, stats);
+    validateBinaryStats(batch, stats);
+  }
+};
+
+TEST_F(BinaryColumnWriterEncodingIndexTest, TestIndex) {
+  // Binary Stream has present, data and length.
+  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining (4)
+  // Data stream has compressed size, uncompressed size (2)
+  // Length stream has compressed size, uncompressed size, RLE numLiterals (3)
+  // so total Streams(4+2+3) = 9. It has no back fill streams.
+
+  runTest(2, 9, 0, 0);
+  runTest(2, 9, 0, 1);
+  runTest(2, 9, 0, 100);
+}
+
+template <typename FLOAT>
+class FloatColumnWriterEncodingIndexTest : public testing::Test,
+                                           public WriterEncodingIndexTest2 {
+ public:
+  FloatColumnWriterEncodingIndexTest()
+      : WriterEncodingIndexTest2(
+            std::is_same_v<FLOAT, float> ? (TypePtr)REAL() : DOUBLE()) {}
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    return prepBatchImpl<FLOAT>(
+        size,
+        pool,
+        [](size_t i, size_t /*unused*/) -> float { return i; },
+        [](size_t i, size_t /*unused*/) -> bool { return i % 30 != 0; });
+  }
+
+  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
+      override {
+    validateBasicStats(batch, stats);
+    validateDoubleStats<FLOAT>(batch, stats);
+  }
+};
+
+using FloatTypes = ::testing::Types<float, double>;
+VELOX_TYPED_TEST_SUITE(FloatColumnWriterEncodingIndexTest, FloatTypes);
+
+TYPED_TEST(FloatColumnWriterEncodingIndexTest, TestIndex) {
+  // Float Stream has present and data.
+  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining (4)
+  // Data stream has uncompressed size, ByteRLE numLiterals (2)
+  // so total Streams(4+2) = 6. It has no back fill streams.
+
+  this->runTest(2, 6, 0, 0);
+  this->runTest(2, 6, 0, 1);
+  this->runTest(2, 6, 0, 100);
+}
+
+class IntegerColumnWriterDirectEncodingIndexTest : public testing::Test {
+ public:
+  explicit IntegerColumnWriterDirectEncodingIndexTest(bool abandonDict = false)
+      : pool_{memory::memoryManager()->addLeafPool()},
+        config_{std::make_shared<Config>()},
+        abandonDict_{abandonDict} {
+    config_->set(
+        Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD,
+        abandonDict ? 1.0f : 0.0f);
+  }
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void testForAllTypes(
+      size_t pageCount,
+      size_t positionCount,
+      size_t stripeCount,
+      std::function<bool(size_t, size_t)> callAbandonDict = neverAbandonDict) {
+    runTest<int16_t>(pageCount, positionCount, stripeCount, callAbandonDict);
+    runTest<int32_t>(pageCount, positionCount, stripeCount, callAbandonDict);
+    runTest<int64_t>(pageCount, positionCount, stripeCount, callAbandonDict);
+  }
+
+  template <typename Integer>
+  VectorPtr prepBatch(
+      size_t size,
+      std::function<Integer(size_t, size_t)> genData,
+      std::function<bool(size_t, size_t)> genNulls) {
+    return prepBatchImpl<Integer>(size, pool_.get(), genData, genNulls);
+  }
+
+  template <typename Integer>
+  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats) {
+    validateBasicStats(batch, stats);
+    validateIntStats<Integer>(batch, stats);
+  }
+
+  template <typename Integer>
+  void runTest(
+      size_t pageCount,
+      size_t positionCount,
+      size_t stripeCount,
+      std::function<bool(size_t, size_t)> callAbandonDict) {
+    WriterContext context{
+        config_,
+        velox::memory::memoryManager()->addRootPool(
+            "IntegerColumnWriterDirectEncodingIndexTest")};
+    context.initBuffer();
+    auto mockIndexBuilder = std::make_unique<StrictMock<MockIndexBuilder>>();
+    auto mockIndexBuilderPtr = mockIndexBuilder.get();
+    context.indexBuilderFactory_ = [&](auto /* unused */) {
+      return std::move(mockIndexBuilder);
+    };
+    auto type = CppToType<Integer>::create();
+    auto typeWithId = TypeWithId::create(type, 1);
+    auto batch =
+        prepBatch<Integer>(1000, generateDistinctValues<Integer>, someNulls);
+
+    // ColumnWriter::recordPosition to capture PRESENT stream positions.
+    // Compression + BufferedOutputStream + byteRLE + booleanRLE
+    EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
+    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
+
+    for (size_t j = 0; j != stripeCount; ++j) {
+      // We need to convert from dictionary in the first stripe. This part calls
+      // index builder in a very similar pattern to that of dictionary encoding.
+      // When we need to abandon dictionary, however, we do need to backfill all
+      // strides so far with direct encoding positions.
+      if (j == 0) {
+        size_t currentPage = 0;
+        while (currentPage < pageCount) {
+          if (abandonDict_) {
+            if (callAbandonDict(j, currentPage)) {
+              // Backfilling starting positions for all but PRESENT stream.
+              EXPECT_CALL(*mockIndexBuilderPtr, add(0, 0))
+                  .Times(positionCount - 4);
+              for (size_t k = 1; k <= currentPage; ++k) {
+                // Backfilling all but PRESENT positions for all subsequent
+                // strides.
+                EXPECT_CALL(*mockIndexBuilderPtr, add(_, k))
+                    .Times(positionCount - 4);
+              }
+              columnWriter->tryAbandonDictionaries(true);
+              break;
+            }
+          }
+          columnWriter->write(batch, common::Ranges::of(0, 1000));
+          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
+              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
+                auto stats = builder.build();
+                validateStats<Integer>(batch, *stats);
+              }));
+          // PRESENT stream positions are always recorded as soon as we create
+          // new entries.
+          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(4);
+          columnWriter->createIndexEntry();
+          ++currentPage;
+        }
+
+        // The rest of the strides are all written directly in direct encoding.
+        for (size_t i = currentPage + 1; i < pageCount; ++i) {
+          columnWriter->write(batch, common::Ranges::of(0, 1000));
+          if (abandonDict_) {
+            if (callAbandonDict(j, i)) {
+              // These calls should essentially be no-ops.
+              columnWriter->tryAbandonDictionaries(true);
+            }
+          }
+          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
+              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
+                auto stats = builder.build();
+                validateStats<Integer>(batch, *stats);
+              }));
+          // We can record all stream positions immediately now that we have
+          // determined the encoding.
+          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(positionCount);
+          columnWriter->createIndexEntry();
+        }
+
+        if (!abandonDict_) {
+          // Backfilling starting positions for all but PRESENT stream.
+          EXPECT_CALL(*mockIndexBuilderPtr, add(0, 0)).Times(positionCount - 4);
+          for (size_t i = 1; i != pageCount + 1; ++i) {
+            // Backfilling all but PRESENT positions for all subsequent strides.
+            EXPECT_CALL(*mockIndexBuilderPtr, add(_, i))
+                .Times(positionCount - 4);
+          }
+        }
+        EXPECT_CALL(*mockIndexBuilderPtr, flush());
+        // Recording starting positions for the new stripe right after flush for
+        // *all* streams
+        EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
+        proto::StripeFooter stripeFooter;
+        columnWriter->flush(
+            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
+              return *stripeFooter.add_encoding();
+            });
+      } else {
+        for (size_t i = 0; i != pageCount; ++i) {
+          columnWriter->write(batch, common::Ranges::of(0, 1000));
+          if (abandonDict_) {
+            if (callAbandonDict(j, i)) {
+              // These calls should essentially be no-ops.
+              columnWriter->tryAbandonDictionaries(true);
+            }
+          }
+          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
+              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
+                auto stats = builder.build();
+                validateStats<Integer>(batch, *stats);
+              }));
+          // We can record all stream positions immediately now that we have
+          // determined the encoding.
+          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(positionCount);
+          columnWriter->createIndexEntry();
+        }
+        EXPECT_CALL(*mockIndexBuilderPtr, flush());
+        EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
+        proto::StripeFooter stripeFooter;
+        columnWriter->flush(
+            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
+              return *stripeFooter.add_encoding();
+            });
+      }
+
+      // Simulate continue writing to next stripe, so internally buffered data
+      // is cleared
+      context.nextStripe();
+      columnWriter->reset();
+    }
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::shared_ptr<Config> config_;
+  bool abandonDict_;
+};
+
+TEST_F(IntegerColumnWriterDirectEncodingIndexTest, ConvertFromDictionary) {
+  testForAllTypes(1, 6, 0);
+  testForAllTypes(10, 6, 0);
+  // 6 positions: {PRESENT, 4}, {DATA, 2}
+  testForAllTypes(1, 6, 1);
+  testForAllTypes(10, 6, 1);
+}
+
+TEST_F(IntegerColumnWriterDirectEncodingIndexTest, DirectWrites) {
+  // Same 6 positions but recorded at different points in time.
+  testForAllTypes(1, 6, 2);
+  testForAllTypes(10, 6, 100);
+}
+
+class IntegerColumnWriterAbandonDictionaryIndexTest
+    : public IntegerColumnWriterDirectEncodingIndexTest {
+ public:
+  explicit IntegerColumnWriterAbandonDictionaryIndexTest()
+      : IntegerColumnWriterDirectEncodingIndexTest{true} {}
+};
+
+TEST_F(IntegerColumnWriterAbandonDictionaryIndexTest, AbandonDictionary) {
+  testForAllTypes(1, 6, 0, abandonEveryWrite);
+  testForAllTypes(10, 6, 0, abandonEveryWrite);
+  // 6 positions: {PRESENT, 4}, {DATA, 2}
+  testForAllTypes(1, 6, 5, abandonNthWrite(0));
+  testForAllTypes(10, 6, 5, abandonNthWrite(7));
+  testForAllTypes(1, 6, 5, abandonEveryWrite);
+  testForAllTypes(10, 6, 5, abandonEveryWrite);
+}
+
+class StringColumnWriterDictionaryEncodingIndexTest : public testing::Test {
+ public:
+  explicit StringColumnWriterDictionaryEncodingIndexTest()
+      : rootPool_{memory::memoryManager()->addRootPool(
+            "StringColumnWriterDictionaryEncodingIndexTest")},
+        leafPool_{rootPool_->addLeafChild(
+            "StringColumnWriterDictionaryEncodingIndexTest")},
+        config_{std::make_shared<Config>()} {
+    config_->set(
+        Config::STRING_STATS_LIMIT, std::numeric_limits<uint32_t>::max());
+    config_->set(Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
+    config_->set(Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 1.0f);
+  }
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(
+      size_t size,
+      MemoryPool* pool,
+      std::function<std::string(size_t, size_t)> genData,
+      std::function<bool(size_t, size_t)> genNulls) {
+    return prepStringBatchImpl(size, pool, genData, genNulls);
+  }
+
+  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats) {
+    validateBasicStats(batch, stats);
+    validateStringStats(batch, stats);
+  }
+
+  void runTest(size_t pageCount, size_t positionCount, size_t stripeCount) {
+    WriterContext context{config_, rootPool_};
+    context.initBuffer();
+    auto mockIndexBuilder = std::make_unique<StrictMock<MockIndexBuilder>>();
+    auto mockIndexBuilderPtr = mockIndexBuilder.get();
+    context.indexBuilderFactory_ = [&](auto /* unused */) {
+      return std::move(mockIndexBuilder);
+    };
+
+    auto typeWithId = TypeWithId::create(VARCHAR(), 1);
+    auto batch =
+        prepBatch(1000, leafPool_.get(), alphabeticRoundRobin, someNulls);
+
+    // ColumnWriter::recordPosition to capture PRESENT stream positions.
+    // Compression + BufferedOutputStream + byteRLE + booleanRLE
+    EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
+    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
+
+    // Indices are captured the same way for all stripes when using dictionary
+    // encoding.
+    for (size_t j = 0; j != stripeCount; ++j) {
+      for (size_t i = 0; i != pageCount; ++i) {
+        columnWriter->write(batch, common::Ranges::of(0, 1000));
+        EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
+            .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
+              auto stats = builder.build();
+              validateStats(batch, *stats);
+            }));
+        // PRESENT stream positions are always recorded as soon as we create new
+        // entries.
+        EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(4);
+        columnWriter->createIndexEntry();
+      }
+      // Backfill starting positions for all but PRESENT stream, and the stride
+      // dictionary size for the first stride.
+      EXPECT_CALL(*mockIndexBuilderPtr, add(_, 0)).Times(positionCount - 4);
+      for (size_t i = 1; i != pageCount + 1; ++i) {
+        // Backfilling all but PRESENT positions for all subsequent strides.
+        EXPECT_CALL(*mockIndexBuilderPtr, add(_, i)).Times(positionCount - 4);
+      }
+      EXPECT_CALL(*mockIndexBuilderPtr, flush());
+      // Recording PRESENT stream starting positions for the new stripe.
+      EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
+      proto::StripeFooter stripeFooter;
+      columnWriter->flush(
+          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
+            return *stripeFooter.add_encoding();
+          });
+
+      // Simulate continue writing to next stripe, so internally buffered data
+      // is cleared
+      context.nextStripe();
+      columnWriter->reset();
+    }
+  }
+
+  std::shared_ptr<memory::MemoryPool> rootPool_;
+  std::shared_ptr<memory::MemoryPool> leafPool_;
+  std::shared_ptr<Config> config_;
+};
+
+TEST_F(StringColumnWriterDictionaryEncodingIndexTest, WriteAllStreams) {
+  runTest(1, 17, 0);
+  // 17 positions: {PRESENT, 4}, {STRIDE_DICT_DATA, 2}, {STRIDE_DICT_LENGTH, 3},
+  // {stride dict size, 1}, {IN_DICTIONARY, 4}, {DATA, 3}
+  runTest(1, 17, 1);
+  runTest(1, 17, 100);
+}
+
+TEST_F(StringColumnWriterDictionaryEncodingIndexTest, OmitInDictStream) {
+  runTest(2, 7, 0);
+  // Writing the batch twice so that all values are in dictionary.
+  // 7 positions: {PRESENT, 4}, {DATA, 3}
+  runTest(2, 7, 1);
+  runTest(2, 7, 100);
+}
+
+class StringColumnWriterDirectEncodingIndexTest : public testing::Test {
+ public:
+  explicit StringColumnWriterDirectEncodingIndexTest(bool abandonDict = false)
+      : rootPool_{memory::memoryManager()->addRootPool(
+            "StringColumnWriterDirectEncodingIndexTest")},
+        leafPool_{rootPool_->addLeafChild(
+            "StringColumnWriterDirectEncodingIndexTest")},
+        config_{std::make_shared<Config>()},
+        abandonDict_{abandonDict} {
+    config_->set(
+        Config::STRING_STATS_LIMIT, std::numeric_limits<uint32_t>::max());
+    config_->set(Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
+    config_->set(Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 0.0f);
+  }
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(
+      size_t size,
+      std::function<std::string(size_t, size_t)> genData,
+      std::function<bool(size_t, size_t)> genNulls) {
+    return prepStringBatchImpl(size, leafPool_.get(), genData, genNulls);
+  }
+
+  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats) {
+    validateBasicStats(batch, stats);
+    validateStringStats(batch, stats);
+  }
+
+  void runTest(
+      size_t pageCount,
+      size_t positionCount,
+      size_t stripeCount,
+      std::function<bool(size_t, size_t)> callAbandonDict = neverAbandonDict) {
+    WriterContext context{config_, rootPool_};
+    context.initBuffer();
+    auto mockIndexBuilder = std::make_unique<StrictMock<MockIndexBuilder>>();
+    auto mockIndexBuilderPtr = mockIndexBuilder.get();
+    context.indexBuilderFactory_ = [&](auto /* unused */) {
+      return std::move(mockIndexBuilder);
+    };
+
+    auto typeWithId = TypeWithId::create(VARCHAR(), 1);
+    auto batch = prepBatch(1000, alphabeticRoundRobin, someNulls);
+
+    // ColumnWriter::recordPosition to capture PRESENT stream positions.
+    // Compression + BufferedOutputStream + byteRLE + booleanRLE
+    EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
+    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
+
+    for (size_t j = 0; j != stripeCount; ++j) {
+      // We need to convert from dictionary in the first stripe. This part calls
+      // index builder in a very similar pattern to that of dictionary encoding.
+      // When we need to abandon dictionary, however, we do need to backfill all
+      // strides so far with direct encoding positions.
+      if (j == 0) {
+        size_t currentPage = 0;
+        while (currentPage < pageCount) {
+          if (abandonDict_) {
+            if (callAbandonDict(j, currentPage)) {
+              // Backfilling starting positions for all but PRESENT stream.
+              EXPECT_CALL(*mockIndexBuilderPtr, add(0, 0))
+                  .Times(positionCount - 4);
+              for (size_t k = 1; k <= currentPage; ++k) {
+                // Backfilling all but PRESENT positions for all subsequent
+                // strides.
+                EXPECT_CALL(*mockIndexBuilderPtr, add(_, k))
+                    .Times(positionCount - 4);
+              }
+              columnWriter->tryAbandonDictionaries(true);
+              break;
+            }
+          }
+          columnWriter->write(batch, common::Ranges::of(0, 1000));
+          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
+              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
+                auto stats = builder.build();
+                validateStats(batch, *stats);
+              }));
+          // PRESENT stream positions are always recorded as soon as we create
+          // new entries.
+          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(4);
+          columnWriter->createIndexEntry();
+          ++currentPage;
+        }
+
+        // The rest of the strides are all written directly in direct encoding.
+        for (size_t i = currentPage + 1; i < pageCount; ++i) {
+          columnWriter->write(batch, common::Ranges::of(0, 1000));
+          if (abandonDict_) {
+            if (callAbandonDict(j, i)) {
+              // These calls should essentially be no-ops.
+              columnWriter->tryAbandonDictionaries(true);
+            }
+          }
+          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
+              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
+                auto stats = builder.build();
+                validateStats(batch, *stats);
+              }));
+          // We can record all stream positions immediately now that we have
+          // determined the encoding.
+          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(positionCount);
+          columnWriter->createIndexEntry();
+        }
+
+        if (!abandonDict_) {
+          // Backfilling starting positions for all but PRESENT stream.
+          EXPECT_CALL(*mockIndexBuilderPtr, add(0, 0)).Times(positionCount - 4);
+          for (size_t i = 1; i != pageCount + 1; ++i) {
+            // Backfilling all but PRESENT positions for all subsequent strides.
+            EXPECT_CALL(*mockIndexBuilderPtr, add(_, i))
+                .Times(positionCount - 4);
+          }
+        }
+        EXPECT_CALL(*mockIndexBuilderPtr, flush());
+        // Recording starting positions for the new stripe right after flush for
+        // *all* streams
+        EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
+        proto::StripeFooter stripeFooter;
+        columnWriter->flush(
+            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
+              return *stripeFooter.add_encoding();
+            });
+      } else {
+        for (size_t i = 0; i != pageCount; ++i) {
+          columnWriter->write(batch, common::Ranges::of(0, 1000));
+          if (abandonDict_) {
+            if (callAbandonDict(j, i)) {
+              // These calls should essentially be no-ops.
+              columnWriter->tryAbandonDictionaries(true);
+            }
+          }
+          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
+              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
+                auto stats = builder.build();
+                validateStats(batch, *stats);
+              }));
+          // We can record all stream positions immediately now that we have
+          // determined the encoding.
+          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(positionCount);
+          columnWriter->createIndexEntry();
+        }
+        EXPECT_CALL(*mockIndexBuilderPtr, flush());
+        EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
+        proto::StripeFooter stripeFooter;
+        columnWriter->flush(
+            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
+              return *stripeFooter.add_encoding();
+            });
+      }
+
+      // Simulate continue writing to next stripe, so internally buffered data
+      // is cleared
+      context.nextStripe();
+      columnWriter->reset();
+    }
+  }
+
+  std::shared_ptr<memory::MemoryPool> rootPool_;
+  std::shared_ptr<memory::MemoryPool> leafPool_;
+  std::shared_ptr<Config> config_;
+  bool abandonDict_;
+};
+
+TEST_F(StringColumnWriterDirectEncodingIndexTest, ConvertFromDictionary) {
+  runTest(1, 9, 0);
+  runTest(10, 9, 0);
+  // 9 positions: {PRESENT, 4}, {DATA, 2}, {DATA_LENGTH, 3}
+  runTest(1, 9, 1);
+  runTest(10, 9, 1);
+}
+
+TEST_F(StringColumnWriterDirectEncodingIndexTest, DirectWrites) {
+  // Same 9 positions but recorded at different points in time.
+  runTest(1, 9, 2);
+  runTest(10, 9, 100);
+}
+
+class StringColumnWriterAbandonDictionaryIndexTest
+    : public StringColumnWriterDirectEncodingIndexTest {
+ public:
+  explicit StringColumnWriterAbandonDictionaryIndexTest()
+      : StringColumnWriterDirectEncodingIndexTest{true} {}
+};
+
+TEST_F(StringColumnWriterAbandonDictionaryIndexTest, AbandonDictionary) {
+  runTest(1, 9, 0, abandonEveryWrite);
+  runTest(10, 9, 0, abandonEveryWrite);
+  // 9 positions: {PRESENT, 4}, {DATA, 2}, {DATA_LENGTH, 3}
+  runTest(1, 9, 5, abandonNthWrite(0));
+  runTest(10, 9, 5, abandonNthWrite(7));
+  runTest(1, 9, 5, abandonEveryWrite);
+  runTest(10, 9, 5, abandonEveryWrite);
+}
+
+class ListColumnWriterEncodingIndexTest : public testing::Test,
+                                          public WriterEncodingIndexTest2 {
+ public:
+  ListColumnWriterEncodingIndexTest()
+      : WriterEncodingIndexTest2(ARRAY(REAL())){};
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    auto nulls = allocateNulls(size, pool);
+    auto* nullsPtr = nulls->asMutable<uint64_t>();
+    size_t nullCount = 0;
+
+    auto offsets = allocateOffsets(size, pool);
+    auto* offsetsPtr = offsets->asMutable<vector_size_t>();
+
+    auto lengths = allocateSizes(size, pool);
+    auto* lengthsPtr = lengths->asMutable<vector_size_t>();
+
+    size_t value = 0;
+    size_t nullEvery = 10;
+    // set up list
+    auto offset = 0;
+    for (size_t i = 0; i < size; i++) {
+      if (i % nullEvery == 0) {
+        bits::setNull(nullsPtr, i);
+        nullCount++;
+      } else {
+        bits::clearNull(nullsPtr, i);
+        offsetsPtr[i] = offset;
+        lengthsPtr[i] = value++;
+        offset += lengthsPtr[i];
+        value %= 50;
+      }
+    }
+    offsetsPtr[size] = offset;
+
+    auto noNulls = [](size_t i, size_t /*unused*/) -> bool { return false; };
+
+    return std::make_shared<ArrayVector>(
+        pool,
+        ARRAY(REAL()),
+        nulls,
+        size,
+        offsets,
+        lengths,
+        prepBatchImpl<float>(
+            offset,
+            pool,
+            [](size_t i, size_t /*unused*/) -> float { return i; },
+            noNulls),
+        nullCount);
+  }
+};
+
+TEST_F(ListColumnWriterEncodingIndexTest, TestIndex) {
+  // List Stream has present and length.
+  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining (4)
+  // Length stream has compressed size, uncompressed size, RLE numLiterals (3)
+  // so total Streams(4+3) = 7. It has no back fill streams.
+
+  runTest(2, 7, 0, 0);
+  runTest(2, 7, 0, 1);
+  runTest(2, 7, 0, 100);
+}
+
+class MapColumnWriterEncodingIndexTest : public testing::Test,
+                                         public WriterEncodingIndexTest2 {
+ public:
+  MapColumnWriterEncodingIndexTest()
+      : WriterEncodingIndexTest2(MAP(REAL(), REAL())) {}
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    auto nulls = allocateNulls(size, pool);
+    auto* nullsPtr = nulls->asMutable<uint64_t>();
+    size_t nullCount = 0;
+
+    auto offsets = allocateOffsets(size, pool);
+    auto* offsetsPtr = offsets->asMutable<vector_size_t>();
+
+    auto lengths = allocateSizes(size, pool);
+    auto* lengthsPtr = lengths->asMutable<vector_size_t>();
+
+    size_t value = 0;
+    size_t nullEvery = 10;
+    // set up list
+    auto offset = 0;
+    for (size_t i = 0; i < size; i++) {
+      if (i % nullEvery == 0) {
+        bits::setNull(nullsPtr, i);
+        nullCount++;
+      } else {
+        bits::clearNull(nullsPtr, i);
+        offsetsPtr[i] = offset;
+        lengthsPtr[i] = value++;
+        offset += lengthsPtr[i];
+        value %= 50;
+      }
+    }
+    offsetsPtr[size] = offset;
+
+    auto noNulls = [](size_t i, size_t /*unused*/) -> bool { return false; };
+
+    return std::make_shared<MapVector>(
+        pool,
+        MAP(REAL(), REAL()),
+        nulls,
+        size,
+        offsets,
+        lengths,
+        prepBatchImpl<float>(
+            offset,
+            pool,
+            [](size_t i, size_t /*unused*/) -> float { return i; },
+            noNulls),
+        prepBatchImpl<float>(
+            offset,
+            pool,
+            [](size_t i, size_t /*unused*/) -> float { return i; },
+            noNulls),
+        nullCount);
+  }
+};
+
+TEST_F(MapColumnWriterEncodingIndexTest, TestIndex) {
+  // Map Stream has present and length.
+  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining (4)
+  // Length stream has compressed size, uncompressed size, RLE numLiterals (3)
+  // so total Streams(4+3) = 7. It has no back fill streams.
+
+  runTest(2, 7, 0, 0);
+  runTest(2, 7, 0, 1);
+  runTest(2, 7, 0, 100);
+}
+
+class FlatMapColumnWriterEncodingIndexTest : public testing::Test,
+                                             public WriterEncodingIndexTest2 {
+ public:
+  FlatMapColumnWriterEncodingIndexTest()
+      : WriterEncodingIndexTest2(
+            ROW({MAP(INTEGER(), MAP(INTEGER(), REAL()))})) {}
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    auto offsets = allocateOffsets(size, pool);
+    auto* offsetsPtr = offsets->asMutable<vector_size_t>();
+    auto offsets2 = AlignedBuffer::allocate<vector_size_t>(size, pool);
+    auto* offsets2Ptr = offsets2->asMutable<vector_size_t>();
+
+    auto lengths = allocateSizes(size, pool);
+    auto* lengthsPtr = lengths->asMutable<vector_size_t>();
+    auto lengths2 = AlignedBuffer::allocate<vector_size_t>(size, pool);
+    auto* lengths2Ptr = lengths2->asMutable<vector_size_t>();
+
+    for (size_t i = 0; i < size; i++) {
+      offsetsPtr[i] = i;
+      offsets2Ptr[i] = i;
+      lengthsPtr[i] = 1;
+      lengths2Ptr[i] = 1;
+    }
+
+    auto noNulls = [](size_t /*unused*/, size_t /*unused*/) -> bool {
+      return true;
+    };
+    auto inner = std::make_shared<MapVector>(
+        pool,
+        MAP(INTEGER(), REAL()),
+        nullptr,
+        size,
+        offsets2,
+        lengths2,
+        prepBatchImpl<int32_t>(
+            size,
+            pool,
+            [](size_t i, size_t /*unused*/) -> int32_t { return i; },
+            noNulls),
+        prepBatchImpl<float>(
+            size,
+            pool,
+            [](size_t i, size_t /*unused*/) -> float { return i; },
+            noNulls),
+        0);
+
+    auto outer = std::make_shared<MapVector>(
+        pool,
+        MAP(INTEGER(), MAP(INTEGER(), REAL())),
+        nullptr,
+        size,
+        offsets,
+        lengths,
+        prepBatchImpl<int32_t>(
+            size,
+            pool,
+            [](size_t i, size_t /*unused*/) -> int32_t { return i % 2; },
+            noNulls),
+        inner,
+        0);
+
+    std::vector<VectorPtr> children{outer};
+    return std::make_shared<RowVector>(
+        pool,
+        ROW({MAP(INTEGER(), MAP(INTEGER(), REAL()))}),
+        nullptr,
+        size,
+        children,
+        0);
+  }
+};
+
+TEST_F(FlatMapColumnWriterEncodingIndexTest, TestIndex) {
+  config_->set(Config::FLATTEN_MAP, true);
+  config_->set(Config::MAP_FLAT_COLS, {0});
+
+  // #0 is root, 0
+  // #1 is a flat map, present 4 = 4
+  // #2 is regular map, in_map 4 + present 4 + length 3 = 11
+  // #3 is int direct: present 4 + data 2 = 6
+  // #4 is float: present 4 + data 2 = 6
+
+  // empty flat map doesn't create value writer
+  runTest(2, {0, 4}, {0, 0}, 0, true, 1);
+  runTest(2, {0, 4, 11, 6, 6, 11, 6, 6}, {0, 0, 0, 0, 0, 0, 0, 0}, 1, true, 1);
+  runTest(
+      2, {0, 4, 11, 6, 6, 11, 6, 6}, {0, 0, 0, 0, 0, 0, 0, 0}, 100, true, 1);
+}
+
+class StructColumnWriterEncodingIndexTest : public testing::Test,
+                                            public WriterEncodingIndexTest2 {
+ public:
+  StructColumnWriterEncodingIndexTest()
+      : WriterEncodingIndexTest2(ROW({REAL(), REAL()})) {}
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
+    return prepBatch(size, pool, false);
+  }
+
+  VectorPtr prepBatch(size_t size, MemoryPool* pool, bool isRoot) override {
+    auto nulls = allocateNulls(size, pool);
+    auto* nullsPtr = nulls->asMutable<uint64_t>();
+    size_t nullCount = 0;
+
+    size_t nullEvery = 10;
+    for (size_t i = 0; i < size; i++) {
+      bool isNull = !isRoot && (i % nullEvery == 0);
+      bits::setNull(nullsPtr, i, isNull);
+      if (isNull) {
+        nullCount++;
+      }
+    }
+
+    auto noNulls = [](size_t i, size_t /*unused*/) -> bool { return false; };
+
+    std::vector<VectorPtr> children(2);
+    for (size_t i = 0; i < 2; i++) {
+      children[i] = prepBatchImpl<float>(
+          size,
+          pool,
+          [](size_t i, size_t /*unused*/) -> float { return i; },
+          noNulls);
+    }
+
+    return std::make_shared<RowVector>(
+        pool, ROW({REAL(), REAL()}), nulls, size, children, nullCount);
+  }
+};
+
+TEST_F(StructColumnWriterEncodingIndexTest, TestIndex) {
+  // Struct Stream has present stream
+  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
+  // Boolean 8-bitsRemaining (4)
+  runTest(2, 4, 0, 0, false);
+  runTest(2, 4, 0, 1, false);
+  runTest(2, 4, 0, 100, false);
+
+  // For root, we don't have present stream, so 0
+  runTest(2, 0, 0, 0, true);
+  runTest(2, 0, 0, 1, true);
+  runTest(2, 0, 0, 100, true);
+}
+
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/ColumnWriterIndexTests.cpp b/velox/dwio/dwrf/test/ColumnWriterIndexTests.cpp
deleted file mode 100644
index 6ca0996242720..0000000000000
--- a/velox/dwio/dwrf/test/ColumnWriterIndexTests.cpp
+++ /dev/null
@@ -1,1455 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/dwio/dwrf/test/OrcTest.h"
-#include "velox/dwio/dwrf/writer/ColumnWriter.h"
-#include "velox/vector/ComplexVector.h"
-#include "velox/vector/FlatVector.h"
-
-using namespace ::testing;
-using namespace facebook::velox;
-using namespace facebook::velox::dwrf;
-using namespace facebook::velox::dwio::common;
-
-using facebook::velox::memory::MemoryPool;
-
-namespace facebook::velox::dwrf {
-
-namespace {
-template <typename Integer>
-Integer generateDistinctValues(size_t i, size_t /* unused */) {
-  return i;
-}
-
-template <typename Integer>
-Integer generateSomewhatRandomData(size_t i, size_t size) {
-  int64_t val = size % (i + 1);
-  return i % 2 ? val : -val;
-}
-
-std::string alphabeticRoundRobin(size_t index, size_t size) {
-  char element = 'a' + index % 26;
-  return std::string(size % (index + 1), element);
-}
-
-bool someNulls(size_t i, size_t size) {
-  return (size % (i + 1)) % 2;
-}
-
-bool neverAbandonDict(size_t /* unused */, size_t /* unused */) {
-  return false;
-}
-
-std::function<bool(size_t, size_t)> abandonNthWrite(size_t n) {
-  return [n](size_t stripeCount, size_t pageCount) {
-    return stripeCount == 0 && pageCount == n;
-  };
-}
-
-bool abandonEveryWrite(size_t /* unused */, size_t /* unused */) {
-  return true;
-}
-
-template <typename T>
-VectorPtr prepBatchImpl(
-    size_t size,
-    MemoryPool* pool,
-    std::function<T(size_t, size_t)> genData,
-    std::function<bool(size_t, size_t)> genNulls) {
-  BufferPtr nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), pool);
-  auto* nullsPtr = nulls->asMutable<uint64_t>();
-  size_t nullCount = 0;
-
-  BufferPtr values = AlignedBuffer::allocate<T>(size, pool);
-  auto valuesPtr = values->asMutableRange<T>();
-
-  for (size_t i = 0; i < size; ++i) {
-    bool isPresent = genNulls(i, size);
-    bits::setNull(nullsPtr, i, !isPresent);
-
-    if (!isPresent) {
-      nullCount++;
-      // valuesPtr[i] = 0;
-    } else {
-      valuesPtr[i] = genData(i, size);
-    }
-  }
-
-  auto batch = std::make_shared<FlatVector<T>>(
-      pool,
-      CppToType<T>::create(),
-      nulls,
-      size,
-      values,
-      std::vector<BufferPtr>());
-  batch->setNullCount(nullCount);
-  return batch;
-}
-
-VectorPtr prepStringBatchImpl(
-    size_t size,
-    MemoryPool* pool,
-    std::function<std::string(size_t, size_t)> genData,
-    std::function<bool(size_t, size_t)> genNulls) {
-  BufferPtr nulls = allocateNulls(size, pool);
-  auto* nullsPtr = nulls->asMutable<uint64_t>();
-  size_t nullCount = 0;
-
-  BufferPtr values = AlignedBuffer::allocate<StringView>(size, pool);
-  auto* valuesPtr = values->asMutable<StringView>();
-
-  std::vector<BufferPtr> dataChunks;
-  BufferPtr dataChunk = AlignedBuffer::allocate<char>(1024, pool);
-  dataChunks.push_back(dataChunk);
-  auto* dataChunkPtr = dataChunk->asMutable<char>();
-  size_t offset = 0;
-
-  // Prepare input
-  for (size_t i = 0; i < size; ++i) {
-    bool isPresent = genNulls(i, size);
-    bits::setNull(nullsPtr, i, !isPresent);
-
-    if (isPresent) {
-      auto val = genData(i, size);
-      if (offset + val.size() > dataChunk->capacity()) {
-        dataChunk = AlignedBuffer::allocate<char>(1024, pool);
-        dataChunks.push_back(dataChunk);
-        dataChunkPtr = dataChunk->asMutable<char>();
-        offset = 0;
-      }
-
-      memcpy(dataChunkPtr + offset, val.data(), val.size());
-      valuesPtr[i] = StringView(dataChunkPtr + offset, val.size());
-      offset += val.size();
-    } else {
-      nullCount++;
-    }
-  }
-
-  auto batch = std::make_shared<FlatVector<StringView>>(
-      pool, VARCHAR(), nulls, size, values, std::move(dataChunks));
-  batch->setNullCount(nullCount);
-  return batch;
-}
-
-void validateBasicStats(const VectorPtr& batch, const ColumnStatistics& stats) {
-  ASSERT_EQ(batch->getNullCount().value() > 0, stats.hasNull().value());
-  ASSERT_EQ(
-      batch->size() - batch->getNullCount().value(), stats.getNumberOfValues());
-}
-
-template <typename INTEGER>
-void validateIntStats(const VectorPtr& batch, const ColumnStatistics& stats) {
-  int64_t min = std::numeric_limits<int64_t>::max();
-  int64_t max = std::numeric_limits<int64_t>::min();
-  int64_t sum = 0;
-  auto* converted = batch->as<FlatVector<INTEGER>>();
-  for (size_t i = 0; i < converted->size(); ++i) {
-    if (!converted->isNullAt(i)) {
-      auto val = converted->valueAt(i);
-      if (val < min) {
-        min = val;
-      }
-      if (val > max) {
-        max = val;
-      }
-      sum += val;
-    }
-  }
-  auto& intStats = dynamic_cast<const IntegerColumnStatistics&>(stats);
-  ASSERT_EQ(min, intStats.getMinimum());
-  ASSERT_EQ(max, intStats.getMaximum());
-  ASSERT_EQ(sum, intStats.getSum());
-}
-
-void validateBooleanStats(
-    const VectorPtr& batch,
-    const ColumnStatistics& stats) {
-  uint64_t trueCount = 0;
-  auto* converted = batch->as<FlatVector<bool>>();
-  for (size_t i = 0; i < converted->size(); ++i) {
-    if (!converted->isNullAt(i)) {
-      if (converted->valueAt(i)) {
-        ++trueCount;
-      }
-    }
-  }
-  auto& boolStats = dynamic_cast<const BooleanColumnStatistics&>(stats);
-  ASSERT_EQ(trueCount, boolStats.getTrueCount());
-}
-
-void validateStringStats(
-    const VectorPtr& batch,
-    const ColumnStatistics& stats) {
-  auto* converted = batch->as<FlatVector<StringView>>();
-  std::string min;
-  std::string max;
-  int64_t length = 0;
-  bool first = true;
-  for (size_t i = 0; i < converted->size(); ++i) {
-    if (!converted->isNullAt(i)) {
-      auto val = converted->valueAt(i).str();
-      if (first) {
-        min = val;
-        max = val;
-        first = false;
-      } else {
-        if (val < min) {
-          min = val;
-        }
-        if (val > max) {
-          max = val;
-        }
-      }
-      length += val.size();
-    }
-  }
-  auto& strStats = dynamic_cast<const StringColumnStatistics&>(stats);
-  ASSERT_EQ(min, strStats.getMinimum());
-  ASSERT_EQ(max, strStats.getMaximum());
-  ASSERT_EQ(length, strStats.getTotalLength());
-}
-
-template <typename FLOAT>
-void validateDoubleStats(
-    const VectorPtr& batch,
-    const ColumnStatistics& stats) {
-  double min = std::numeric_limits<double>::infinity();
-  double max = -std::numeric_limits<double>::infinity();
-  double sum = 0;
-  auto* converted = batch->as<FlatVector<FLOAT>>();
-  for (size_t i = 0; i < converted->size(); ++i) {
-    if (!converted->isNullAt(i)) {
-      auto val = converted->valueAt(i);
-      if (val < min) {
-        min = val;
-      }
-      if (val > max) {
-        max = val;
-      }
-      sum += val;
-    }
-  }
-  auto& doubleStats = dynamic_cast<const DoubleColumnStatistics&>(stats);
-  ASSERT_EQ(min, doubleStats.getMinimum());
-  ASSERT_EQ(max, doubleStats.getMaximum());
-  ASSERT_EQ(sum, doubleStats.getSum());
-}
-
-void validateBinaryStats(
-    const VectorPtr& batch,
-    const ColumnStatistics& stats) {
-  auto* converted = batch->as<FlatVector<StringView>>();
-  int64_t length = 0;
-  for (size_t i = 0; i < converted->size(); ++i) {
-    if (!converted->isNullAt(i)) {
-      length += converted->valueAt(i).size();
-    }
-  }
-  auto& binStats = dynamic_cast<const BinaryColumnStatistics&>(stats);
-  ASSERT_EQ(length, binStats.getTotalLength());
-}
-
-} // namespace
-
-template <typename Type>
-class WriterEncodingIndexTest2 {
- public:
-  WriterEncodingIndexTest2()
-      : config_{std::make_shared<Config>()},
-        pool_{facebook::velox::memory::addDefaultLeafMemoryPool()} {}
-
-  virtual ~WriterEncodingIndexTest2() = default;
-
-  void runTest(
-      size_t pageCount,
-      size_t recordPositionCount,
-      size_t backfillPositionCount,
-      size_t stripeCount,
-      bool isRoot = false) {
-    runTest(
-        pageCount,
-        std::vector<size_t>{recordPositionCount},
-        std::vector<size_t>{backfillPositionCount},
-        stripeCount,
-        isRoot);
-  }
-
-  void runTest(
-      size_t pageCount,
-      const std::vector<size_t>& recordPositionCount,
-      const std::vector<size_t>& backfillPositionCount,
-      size_t stripeCount,
-      bool isRoot = false,
-      size_t flatMapOffset = 0) {
-    auto isFlatMap = isRoot && flatMapOffset > 0;
-    ASSERT_EQ(recordPositionCount.size(), backfillPositionCount.size());
-    WriterContext context{
-        config_,
-        velox::memory::defaultMemoryManager().addRootPool(
-            "WriterEncodingIndexTest2")};
-    std::vector<StrictMock<MockIndexBuilder>*> mocks;
-    for (auto i = 0; i < recordPositionCount.size(); ++i) {
-      mocks.push_back(new StrictMock<MockIndexBuilder>());
-    }
-    // Hack: for flat map, value node is destructed after each stripe and hence
-    // index build is also destructed. So reset pos when all the pointers are
-    // used, and meanwhile, create new index builder after every flush
-    size_t pos = 0;
-    context.indexBuilderFactory_ =
-        [&](auto stream) -> std::unique_ptr<IndexBuilder> {
-      if (pos < recordPositionCount.size()) {
-        auto ptr = std::unique_ptr<StrictMock<MockIndexBuilder>>(mocks[pos++]);
-        if (isFlatMap && pos == mocks.size()) {
-          pos = flatMapOffset + 1;
-        }
-        return ptr;
-      } else {
-        return std::make_unique<IndexBuilder>(std::move(stream));
-      }
-    };
-    auto type = CppToType<Type>::create();
-    auto typeWithId = TypeWithId::create(type, isRoot ? 0 : 1);
-    auto batch = prepBatch(1000, pool_.get(), isRoot);
-
-    // Creating a stream calls recordPosition.
-    for (auto n = 0; n < mocks.size(); ++n) {
-      EXPECT_CALL(*mocks.at(n), add(0, -1)).Times(recordPositionCount[n]);
-    }
-    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
-
-    // Indices are captured the same way for all stripes in the derived tests.
-    for (size_t j = 0; j != stripeCount; ++j) {
-      for (size_t i = 0; i != pageCount; ++i) {
-        columnWriter->write(batch, common::Ranges::of(0, 1000));
-        for (auto n = 0; n < mocks.size(); ++n) {
-          EXPECT_CALL(*mocks.at(n), addEntry(_))
-              .WillOnce(Invoke([&, k = n](const StatisticsBuilder& builder) {
-                auto stats = builder.build();
-                if (k == 0) {
-                  validateStats(batch, *stats);
-                }
-              }));
-          // RecordPosition is invoked on call to createIndexEntry
-          EXPECT_CALL(*mocks.at(n), add(_, -1)).Times(recordPositionCount[n]);
-        }
-        columnWriter->createIndexEntry();
-      }
-
-      for (auto n = 0; n < mocks.size(); ++n) {
-        if (backfillPositionCount[n]) {
-          // Backfill starting positions for starting stride.
-          // All Inherited tests have starting position as 0.
-          EXPECT_CALL(*mocks.at(n), add(0, 0)).Times(backfillPositionCount[n]);
-          for (size_t i = 1; i != pageCount + 1; ++i) {
-            // Backfilling all but PRESENT positions for all subsequent strides.
-            EXPECT_CALL(*mocks.at(n), add(_, i))
-                .Times(backfillPositionCount[n]);
-          }
-        }
-        EXPECT_CALL(*mocks.at(n), flush());
-        if (!(isFlatMap && n > flatMapOffset)) {
-          // Recording positions for the new stripe.
-          EXPECT_CALL(*mocks.at(n), add(0, -1)).Times(recordPositionCount[n]);
-        }
-      }
-      proto::StripeFooter stripeFooter;
-      columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
-          });
-
-      // Simulate continue writing to next stripe, so internally buffered data
-      // is cleared
-      context.nextStripe();
-      columnWriter->reset();
-
-      // create new index builders
-      if (isFlatMap && j < stripeCount - 1) {
-        EXPECT_EQ(pos, flatMapOffset + 1);
-        for (auto i = flatMapOffset + 1; i < recordPositionCount.size(); ++i) {
-          mocks[i] = new StrictMock<MockIndexBuilder>();
-          // Recording positions for the new stripe.
-          EXPECT_CALL(*mocks.at(i), add(0, -1)).Times(recordPositionCount[i]);
-        }
-      }
-    }
-  }
-
- protected:
-  virtual VectorPtr prepBatch(size_t size, MemoryPool* pool) = 0;
-
-  virtual VectorPtr prepBatch(size_t size, MemoryPool* pool, bool isRoot) {
-    return prepBatch(size, pool);
-  }
-
-  virtual void validateStats(
-      const VectorPtr& batch,
-      const ColumnStatistics& stats) {
-    validateBasicStats(batch, stats);
-  }
-
-  std::shared_ptr<Config> config_;
-  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
-};
-
-class TimestampWriterIndexTest : public testing::Test,
-                                 public WriterEncodingIndexTest2<Timestamp> {
- public:
-  TimestampWriterIndexTest() : WriterEncodingIndexTest2<Timestamp>() {}
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    return prepBatchImpl<Timestamp>(
-        size,
-        pool_.get(),
-        [](size_t i, size_t /*unused*/) -> Timestamp {
-          return Timestamp(i, i);
-        },
-        someNulls);
-  }
-
-  // timestamp column only has basic stats, so validation method in base class
-  // is sufficient
-};
-
-TEST_F(TimestampWriterIndexTest, TestIndex) {
-  // Present Stream has 4. seconds and nanos are Ints with 3 each.
-  // 4+3+3 = 10. There is no backfill.
-  this->runTest(2, 10, 0, 0);
-  this->runTest(2, 10, 0, 1);
-  this->runTest(2, 10, 0, 100);
-}
-
-template <typename Integer>
-class IntegerColumnWriterDictionaryEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<Integer> {
- public:
-  explicit IntegerColumnWriterDictionaryEncodingIndexTest()
-      : WriterEncodingIndexTest2<Integer>() {
-    this->config_->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 1.0f);
-  }
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    return prepBatchImpl<Integer>(
-        size, pool, generateSomewhatRandomData<Integer>, someNulls);
-  }
-
-  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
-      override {
-    validateBasicStats(batch, stats);
-    validateIntStats<Integer>(batch, stats);
-  }
-};
-
-using DictionaryTypes = ::testing::Types<int16_t, int32_t, int64_t>;
-VELOX_TYPED_TEST_SUITE(
-    IntegerColumnWriterDictionaryEncodingIndexTest,
-    DictionaryTypes);
-
-TYPED_TEST(IntegerColumnWriterDictionaryEncodingIndexTest, WriteAllStreams) {
-  // Present stream uses 4 positions.
-  // compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining
-  constexpr size_t RECORD_POSITION_COUNT = 4;
-
-  // Data Stream 3 Positions
-  // In Dictionary 4 positions (Similar to Present Stream)
-  constexpr size_t BACKFILL_POSITION_COUNT = 7;
-
-  this->runTest(1, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 0);
-
-  this->runTest(1, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 1);
-  this->runTest(1, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 100);
-}
-
-TYPED_TEST(IntegerColumnWriterDictionaryEncodingIndexTest, OmitInDictStream) {
-  // Present stream uses 4 positions.
-  // compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining
-  constexpr size_t RECORD_POSITION_COUNT = 4;
-
-  // Data Stream 3 Positions
-  constexpr size_t BACKFILL_POSITION_COUNT = 3;
-
-  // Writing the batch twice so that all values are in dictionary.
-  this->runTest(2, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 0);
-  this->runTest(2, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 1);
-  this->runTest(2, RECORD_POSITION_COUNT, BACKFILL_POSITION_COUNT, 100);
-}
-
-class BoolColumnWriterEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<bool> {
- public:
-  explicit BoolColumnWriterEncodingIndexTest()
-      : WriterEncodingIndexTest2<bool>() {}
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    return prepBatchImpl<bool>(
-        size,
-        pool,
-        [](size_t i, size_t /*unused*/) -> bool { return true; },
-        [](size_t i, size_t /*unused*/) -> bool { return i % 3 == 0; });
-  }
-
-  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
-      override {
-    validateBasicStats(batch, stats);
-    validateBooleanStats(batch, stats);
-  }
-};
-
-TEST_F(BoolColumnWriterEncodingIndexTest, TestIndex) {
-  // Boolean Stream uses one Stream for Presence and Other Stream for data
-  // Each Stream has compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining , so 4+4 =8. It has no back fill streams.
-  this->runTest(2, 8, 0, 0);
-  this->runTest(2, 8, 0, 1);
-  this->runTest(2, 8, 0, 100);
-}
-
-class ByteColumnWriterEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<int8_t> {
- public:
-  explicit ByteColumnWriterEncodingIndexTest()
-      : WriterEncodingIndexTest2<int8_t>() {}
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    int8_t value = 0;
-    return prepBatchImpl<int8_t>(
-        size,
-        pool,
-        [&value](size_t i, size_t /*unused*/) -> int8_t { return value++; },
-        [](size_t i, size_t /*unused*/) -> bool { return i % INT8_MAX == 0; });
-  }
-
-  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
-      override {
-    validateBasicStats(batch, stats);
-    validateIntStats<int8_t>(batch, stats);
-  }
-};
-
-TEST_F(ByteColumnWriterEncodingIndexTest, TestIndex) {
-  // Byte Stream has presence Stream and data stream.
-  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining (4)
-  // Data stream has compressed size, uncompressed size, ByteRLE numLiterals (3)
-  // so total Streams(4+3) = 7. It has no back fill streams.
-
-  this->runTest(2, 7, 0, 0);
-  this->runTest(2, 7, 0, 1);
-  this->runTest(2, 7, 0, 100);
-}
-
-class BinaryColumnWriterEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<Varbinary> {
- public:
-  BinaryColumnWriterEncodingIndexTest() = default;
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    BufferPtr nulls = allocateNulls(size, pool);
-    auto* nullsPtr = nulls->asMutable<uint64_t>();
-    size_t nullCount = 0;
-
-    BufferPtr values = AlignedBuffer::allocate<StringView>(size, pool);
-    auto* valuesPtr = values->asMutable<StringView>();
-
-    auto data = AlignedBuffer::allocate<char>(100, pool);
-    auto dataPtr = data->asMutable<char>();
-    std::memset(dataPtr, 'a', 100);
-
-    size_t value = 0;
-    size_t nullEvery = 10;
-    for (size_t i = 0; i < size; ++i) {
-      if (i % nullEvery != 0) {
-        bits::clearNull(nullsPtr, i);
-        valuesPtr[i] = StringView(dataPtr, value++);
-        value %= 50;
-      } else {
-        bits::setNull(nullsPtr, i);
-        nullCount++;
-      }
-    }
-
-    auto batch = std::make_shared<FlatVector<StringView>>(
-        pool, VARCHAR(), nulls, size, values, std::vector<BufferPtr>{data});
-    batch->setNullCount(nullCount);
-    return batch;
-  }
-
-  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
-      override {
-    validateBasicStats(batch, stats);
-    validateBinaryStats(batch, stats);
-  }
-};
-
-TEST_F(BinaryColumnWriterEncodingIndexTest, TestIndex) {
-  // Binary Stream has present, data and length.
-  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining (4)
-  // Data stream has compressed size, uncompressed size (2)
-  // Length stream has compressed size, uncompressed size, RLE numLiterals (3)
-  // so total Streams(4+2+3) = 9. It has no back fill streams.
-
-  this->runTest(2, 9, 0, 0);
-  this->runTest(2, 9, 0, 1);
-  this->runTest(2, 9, 0, 100);
-}
-
-template <typename FLOAT>
-class FloatColumnWriterEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<FLOAT> {
- public:
-  FloatColumnWriterEncodingIndexTest() = default;
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    return prepBatchImpl<FLOAT>(
-        size,
-        pool,
-        [](size_t i, size_t /*unused*/) -> float { return i; },
-        [](size_t i, size_t /*unused*/) -> bool { return i % 30 != 0; });
-  }
-
-  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats)
-      override {
-    validateBasicStats(batch, stats);
-    validateDoubleStats<FLOAT>(batch, stats);
-  }
-};
-
-using FloatTypes = ::testing::Types<float, double>;
-VELOX_TYPED_TEST_SUITE(FloatColumnWriterEncodingIndexTest, FloatTypes);
-
-TYPED_TEST(FloatColumnWriterEncodingIndexTest, TestIndex) {
-  // Float Stream has present and data.
-  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining (4)
-  // Data stream has uncompressed size, ByteRLE numLiterals (2)
-  // so total Streams(4+2) = 6. It has no back fill streams.
-
-  this->runTest(2, 6, 0, 0);
-  this->runTest(2, 6, 0, 1);
-  this->runTest(2, 6, 0, 100);
-}
-
-class IntegerColumnWriterDirectEncodingIndexTest : public testing::Test {
- public:
-  explicit IntegerColumnWriterDirectEncodingIndexTest(bool abandonDict = false)
-      : pool_{memory::addDefaultLeafMemoryPool()},
-        config_{std::make_shared<Config>()},
-        abandonDict_{abandonDict} {
-    config_->set(
-        Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD,
-        abandonDict ? 1.0f : 0.0f);
-  }
-
- protected:
-  void testForAllTypes(
-      size_t pageCount,
-      size_t positionCount,
-      size_t stripeCount,
-      std::function<bool(size_t, size_t)> callAbandonDict = neverAbandonDict) {
-    runTest<int16_t>(pageCount, positionCount, stripeCount, callAbandonDict);
-    runTest<int32_t>(pageCount, positionCount, stripeCount, callAbandonDict);
-    runTest<int64_t>(pageCount, positionCount, stripeCount, callAbandonDict);
-  }
-
-  template <typename Integer>
-  VectorPtr prepBatch(
-      size_t size,
-      std::function<Integer(size_t, size_t)> genData,
-      std::function<bool(size_t, size_t)> genNulls) {
-    return prepBatchImpl<Integer>(size, pool_.get(), genData, genNulls);
-  }
-
-  template <typename Integer>
-  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats) {
-    validateBasicStats(batch, stats);
-    validateIntStats<Integer>(batch, stats);
-  }
-
-  template <typename Integer>
-  void runTest(
-      size_t pageCount,
-      size_t positionCount,
-      size_t stripeCount,
-      std::function<bool(size_t, size_t)> callAbandonDict) {
-    WriterContext context{
-        config_,
-        velox::memory::defaultMemoryManager().addRootPool(
-            "IntegerColumnWriterDirectEncodingIndexTest")};
-    auto mockIndexBuilder = std::make_unique<StrictMock<MockIndexBuilder>>();
-    auto mockIndexBuilderPtr = mockIndexBuilder.get();
-    context.indexBuilderFactory_ = [&](auto /* unused */) {
-      return std::move(mockIndexBuilder);
-    };
-    auto type = CppToType<Integer>::create();
-    auto typeWithId = TypeWithId::create(type, 1);
-    auto batch =
-        prepBatch<Integer>(1000, generateDistinctValues<Integer>, someNulls);
-
-    // ColumnWriter::recordPosition to capture PRESENT stream positions.
-    // Compression + BufferedOutputStream + byteRLE + booleanRLE
-    EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
-    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
-
-    for (size_t j = 0; j != stripeCount; ++j) {
-      // We need to convert from dictionary in the first stripe. This part calls
-      // index builder in a very similar pattern to that of dictionary encoding.
-      // When we need to abandon dictionary, however, we do need to backfill all
-      // strides so far with direct encoding positions.
-      if (j == 0) {
-        size_t currentPage = 0;
-        while (currentPage < pageCount) {
-          if (abandonDict_) {
-            if (callAbandonDict(j, currentPage)) {
-              // Backfilling starting positions for all but PRESENT stream.
-              EXPECT_CALL(*mockIndexBuilderPtr, add(0, 0))
-                  .Times(positionCount - 4);
-              for (size_t k = 1; k <= currentPage; ++k) {
-                // Backfilling all but PRESENT positions for all subsequent
-                // strides.
-                EXPECT_CALL(*mockIndexBuilderPtr, add(_, k))
-                    .Times(positionCount - 4);
-              }
-              columnWriter->tryAbandonDictionaries(true);
-              break;
-            }
-          }
-          columnWriter->write(batch, common::Ranges::of(0, 1000));
-          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
-              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
-                auto stats = builder.build();
-                validateStats<Integer>(batch, *stats);
-              }));
-          // PRESENT stream positions are always recorded as soon as we create
-          // new entries.
-          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(4);
-          columnWriter->createIndexEntry();
-          ++currentPage;
-        }
-
-        // The rest of the strides are all written directly in direct encoding.
-        for (size_t i = currentPage + 1; i < pageCount; ++i) {
-          columnWriter->write(batch, common::Ranges::of(0, 1000));
-          if (abandonDict_) {
-            if (callAbandonDict(j, i)) {
-              // These calls should essentially be no-ops.
-              columnWriter->tryAbandonDictionaries(true);
-            }
-          }
-          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
-              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
-                auto stats = builder.build();
-                validateStats<Integer>(batch, *stats);
-              }));
-          // We can record all stream positions immediately now that we have
-          // determined the encoding.
-          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(positionCount);
-          columnWriter->createIndexEntry();
-        }
-
-        if (!abandonDict_) {
-          // Backfilling starting positions for all but PRESENT stream.
-          EXPECT_CALL(*mockIndexBuilderPtr, add(0, 0)).Times(positionCount - 4);
-          for (size_t i = 1; i != pageCount + 1; ++i) {
-            // Backfilling all but PRESENT positions for all subsequent strides.
-            EXPECT_CALL(*mockIndexBuilderPtr, add(_, i))
-                .Times(positionCount - 4);
-          }
-        }
-        EXPECT_CALL(*mockIndexBuilderPtr, flush());
-        // Recording starting positions for the new stripe right after flush for
-        // *all* streams
-        EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
-        proto::StripeFooter stripeFooter;
-        columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
-            });
-      } else {
-        for (size_t i = 0; i != pageCount; ++i) {
-          columnWriter->write(batch, common::Ranges::of(0, 1000));
-          if (abandonDict_) {
-            if (callAbandonDict(j, i)) {
-              // These calls should essentially be no-ops.
-              columnWriter->tryAbandonDictionaries(true);
-            }
-          }
-          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
-              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
-                auto stats = builder.build();
-                validateStats<Integer>(batch, *stats);
-              }));
-          // We can record all stream positions immediately now that we have
-          // determined the encoding.
-          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(positionCount);
-          columnWriter->createIndexEntry();
-        }
-        EXPECT_CALL(*mockIndexBuilderPtr, flush());
-        EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
-        proto::StripeFooter stripeFooter;
-        columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
-            });
-      }
-
-      // Simulate continue writing to next stripe, so internally buffered data
-      // is cleared
-      context.nextStripe();
-      columnWriter->reset();
-    }
-  }
-
-  std::shared_ptr<memory::MemoryPool> pool_;
-  std::shared_ptr<Config> config_;
-  bool abandonDict_;
-};
-
-TEST_F(IntegerColumnWriterDirectEncodingIndexTest, ConvertFromDictionary) {
-  testForAllTypes(1, 6, 0);
-  testForAllTypes(10, 6, 0);
-  // 6 positions: {PRESENT, 4}, {DATA, 2}
-  testForAllTypes(1, 6, 1);
-  testForAllTypes(10, 6, 1);
-}
-
-TEST_F(IntegerColumnWriterDirectEncodingIndexTest, DirectWrites) {
-  // Same 6 positions but recorded at different points in time.
-  testForAllTypes(1, 6, 2);
-  testForAllTypes(10, 6, 100);
-}
-
-class IntegerColumnWriterAbandonDictionaryIndexTest
-    : public IntegerColumnWriterDirectEncodingIndexTest {
- public:
-  explicit IntegerColumnWriterAbandonDictionaryIndexTest()
-      : IntegerColumnWriterDirectEncodingIndexTest{true} {}
-};
-
-TEST_F(IntegerColumnWriterAbandonDictionaryIndexTest, AbandonDictionary) {
-  testForAllTypes(1, 6, 0, abandonEveryWrite);
-  testForAllTypes(10, 6, 0, abandonEveryWrite);
-  // 6 positions: {PRESENT, 4}, {DATA, 2}
-  testForAllTypes(1, 6, 5, abandonNthWrite(0));
-  testForAllTypes(10, 6, 5, abandonNthWrite(7));
-  testForAllTypes(1, 6, 5, abandonEveryWrite);
-  testForAllTypes(10, 6, 5, abandonEveryWrite);
-}
-
-class StringColumnWriterDictionaryEncodingIndexTest : public testing::Test {
- public:
-  explicit StringColumnWriterDictionaryEncodingIndexTest()
-      : rootPool_{memory::defaultMemoryManager().addRootPool(
-            "StringColumnWriterDictionaryEncodingIndexTest")},
-        leafPool_{rootPool_->addLeafChild(
-            "StringColumnWriterDictionaryEncodingIndexTest")},
-        config_{std::make_shared<Config>()} {
-    config_->set(
-        Config::STRING_STATS_LIMIT, std::numeric_limits<uint32_t>::max());
-    config_->set(Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
-    config_->set(Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 1.0f);
-  }
-
- protected:
-  VectorPtr prepBatch(
-      size_t size,
-      MemoryPool* pool,
-      std::function<std::string(size_t, size_t)> genData,
-      std::function<bool(size_t, size_t)> genNulls) {
-    return prepStringBatchImpl(size, pool, genData, genNulls);
-  }
-
-  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats) {
-    validateBasicStats(batch, stats);
-    validateStringStats(batch, stats);
-  }
-
-  void runTest(size_t pageCount, size_t positionCount, size_t stripeCount) {
-    WriterContext context{config_, rootPool_};
-    auto mockIndexBuilder = std::make_unique<StrictMock<MockIndexBuilder>>();
-    auto mockIndexBuilderPtr = mockIndexBuilder.get();
-    context.indexBuilderFactory_ = [&](auto /* unused */) {
-      return std::move(mockIndexBuilder);
-    };
-    auto type = CppToType<folly::StringPiece>::create();
-    auto typeWithId = TypeWithId::create(type, 1);
-    auto batch =
-        prepBatch(1000, leafPool_.get(), alphabeticRoundRobin, someNulls);
-
-    // ColumnWriter::recordPosition to capture PRESENT stream positions.
-    // Compression + BufferedOutputStream + byteRLE + booleanRLE
-    EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
-    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
-
-    // Indices are captured the same way for all stripes when using dictionary
-    // encoding.
-    for (size_t j = 0; j != stripeCount; ++j) {
-      for (size_t i = 0; i != pageCount; ++i) {
-        columnWriter->write(batch, common::Ranges::of(0, 1000));
-        EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
-            .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
-              auto stats = builder.build();
-              validateStats(batch, *stats);
-            }));
-        // PRESENT stream positions are always recorded as soon as we create new
-        // entries.
-        EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(4);
-        columnWriter->createIndexEntry();
-      }
-      // Backfill starting positions for all but PRESENT stream, and the stride
-      // dictionary size for the first stride.
-      EXPECT_CALL(*mockIndexBuilderPtr, add(_, 0)).Times(positionCount - 4);
-      for (size_t i = 1; i != pageCount + 1; ++i) {
-        // Backfilling all but PRESENT positions for all subsequent strides.
-        EXPECT_CALL(*mockIndexBuilderPtr, add(_, i)).Times(positionCount - 4);
-      }
-      EXPECT_CALL(*mockIndexBuilderPtr, flush());
-      // Recording PRESENT stream starting positions for the new stripe.
-      EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
-      proto::StripeFooter stripeFooter;
-      columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
-          });
-
-      // Simulate continue writing to next stripe, so internally buffered data
-      // is cleared
-      context.nextStripe();
-      columnWriter->reset();
-    }
-  }
-
-  std::shared_ptr<memory::MemoryPool> rootPool_;
-  std::shared_ptr<memory::MemoryPool> leafPool_;
-  std::shared_ptr<Config> config_;
-};
-
-TEST_F(StringColumnWriterDictionaryEncodingIndexTest, WriteAllStreams) {
-  runTest(1, 17, 0);
-  // 17 positions: {PRESENT, 4}, {STRIDE_DICT_DATA, 2}, {STRIDE_DICT_LENGTH, 3},
-  // {stride dict size, 1}, {IN_DICTIONARY, 4}, {DATA, 3}
-  runTest(1, 17, 1);
-  runTest(1, 17, 100);
-}
-
-TEST_F(StringColumnWriterDictionaryEncodingIndexTest, OmitInDictStream) {
-  runTest(2, 7, 0);
-  // Writing the batch twice so that all values are in dictionary.
-  // 7 positions: {PRESENT, 4}, {DATA, 3}
-  runTest(2, 7, 1);
-  runTest(2, 7, 100);
-}
-
-class StringColumnWriterDirectEncodingIndexTest : public testing::Test {
- public:
-  explicit StringColumnWriterDirectEncodingIndexTest(bool abandonDict = false)
-      : rootPool_{memory::defaultMemoryManager().addRootPool(
-            "StringColumnWriterDirectEncodingIndexTest")},
-        leafPool_{rootPool_->addLeafChild(
-            "StringColumnWriterDirectEncodingIndexTest")},
-        config_{std::make_shared<Config>()},
-        abandonDict_{abandonDict} {
-    config_->set(
-        Config::STRING_STATS_LIMIT, std::numeric_limits<uint32_t>::max());
-    config_->set(Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
-    config_->set(Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 0.0f);
-  }
-
- protected:
-  VectorPtr prepBatch(
-      size_t size,
-      std::function<std::string(size_t, size_t)> genData,
-      std::function<bool(size_t, size_t)> genNulls) {
-    return prepStringBatchImpl(size, leafPool_.get(), genData, genNulls);
-  }
-
-  void validateStats(const VectorPtr& batch, const ColumnStatistics& stats) {
-    validateBasicStats(batch, stats);
-    validateStringStats(batch, stats);
-  }
-
-  void runTest(
-      size_t pageCount,
-      size_t positionCount,
-      size_t stripeCount,
-      std::function<bool(size_t, size_t)> callAbandonDict = neverAbandonDict) {
-    WriterContext context{config_, rootPool_};
-    auto mockIndexBuilder = std::make_unique<StrictMock<MockIndexBuilder>>();
-    auto mockIndexBuilderPtr = mockIndexBuilder.get();
-    context.indexBuilderFactory_ = [&](auto /* unused */) {
-      return std::move(mockIndexBuilder);
-    };
-    auto type = CppToType<folly::StringPiece>::create();
-    auto typeWithId = TypeWithId::create(type, 1);
-    auto batch = prepBatch(1000, alphabeticRoundRobin, someNulls);
-
-    // ColumnWriter::recordPosition to capture PRESENT stream positions.
-    // Compression + BufferedOutputStream + byteRLE + booleanRLE
-    EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
-    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
-
-    for (size_t j = 0; j != stripeCount; ++j) {
-      // We need to convert from dictionary in the first stripe. This part calls
-      // index builder in a very similar pattern to that of dictionary encoding.
-      // When we need to abandon dictionary, however, we do need to backfill all
-      // strides so far with direct encoding positions.
-      if (j == 0) {
-        size_t currentPage = 0;
-        while (currentPage < pageCount) {
-          if (abandonDict_) {
-            if (callAbandonDict(j, currentPage)) {
-              // Backfilling starting positions for all but PRESENT stream.
-              EXPECT_CALL(*mockIndexBuilderPtr, add(0, 0))
-                  .Times(positionCount - 4);
-              for (size_t k = 1; k <= currentPage; ++k) {
-                // Backfilling all but PRESENT positions for all subsequent
-                // strides.
-                EXPECT_CALL(*mockIndexBuilderPtr, add(_, k))
-                    .Times(positionCount - 4);
-              }
-              columnWriter->tryAbandonDictionaries(true);
-              break;
-            }
-          }
-          columnWriter->write(batch, common::Ranges::of(0, 1000));
-          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
-              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
-                auto stats = builder.build();
-                validateStats(batch, *stats);
-              }));
-          // PRESENT stream positions are always recorded as soon as we create
-          // new entries.
-          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(4);
-          columnWriter->createIndexEntry();
-          ++currentPage;
-        }
-
-        // The rest of the strides are all written directly in direct encoding.
-        for (size_t i = currentPage + 1; i < pageCount; ++i) {
-          columnWriter->write(batch, common::Ranges::of(0, 1000));
-          if (abandonDict_) {
-            if (callAbandonDict(j, i)) {
-              // These calls should essentially be no-ops.
-              columnWriter->tryAbandonDictionaries(true);
-            }
-          }
-          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
-              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
-                auto stats = builder.build();
-                validateStats(batch, *stats);
-              }));
-          // We can record all stream positions immediately now that we have
-          // determined the encoding.
-          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(positionCount);
-          columnWriter->createIndexEntry();
-        }
-
-        if (!abandonDict_) {
-          // Backfilling starting positions for all but PRESENT stream.
-          EXPECT_CALL(*mockIndexBuilderPtr, add(0, 0)).Times(positionCount - 4);
-          for (size_t i = 1; i != pageCount + 1; ++i) {
-            // Backfilling all but PRESENT positions for all subsequent strides.
-            EXPECT_CALL(*mockIndexBuilderPtr, add(_, i))
-                .Times(positionCount - 4);
-          }
-        }
-        EXPECT_CALL(*mockIndexBuilderPtr, flush());
-        // Recording starting positions for the new stripe right after flush for
-        // *all* streams
-        EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
-        proto::StripeFooter stripeFooter;
-        columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
-            });
-      } else {
-        for (size_t i = 0; i != pageCount; ++i) {
-          columnWriter->write(batch, common::Ranges::of(0, 1000));
-          if (abandonDict_) {
-            if (callAbandonDict(j, i)) {
-              // These calls should essentially be no-ops.
-              columnWriter->tryAbandonDictionaries(true);
-            }
-          }
-          EXPECT_CALL(*mockIndexBuilderPtr, addEntry(_))
-              .WillOnce(Invoke([&](const StatisticsBuilder& builder) {
-                auto stats = builder.build();
-                validateStats(batch, *stats);
-              }));
-          // We can record all stream positions immediately now that we have
-          // determined the encoding.
-          EXPECT_CALL(*mockIndexBuilderPtr, add(_, -1)).Times(positionCount);
-          columnWriter->createIndexEntry();
-        }
-        EXPECT_CALL(*mockIndexBuilderPtr, flush());
-        EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
-        proto::StripeFooter stripeFooter;
-        columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
-            });
-      }
-
-      // Simulate continue writing to next stripe, so internally buffered data
-      // is cleared
-      context.nextStripe();
-      columnWriter->reset();
-    }
-  }
-
-  std::shared_ptr<memory::MemoryPool> rootPool_;
-  std::shared_ptr<memory::MemoryPool> leafPool_;
-  std::shared_ptr<Config> config_;
-  bool abandonDict_;
-};
-
-TEST_F(StringColumnWriterDirectEncodingIndexTest, ConvertFromDictionary) {
-  runTest(1, 9, 0);
-  runTest(10, 9, 0);
-  // 9 positions: {PRESENT, 4}, {DATA, 2}, {DATA_LENGTH, 3}
-  runTest(1, 9, 1);
-  runTest(10, 9, 1);
-}
-
-TEST_F(StringColumnWriterDirectEncodingIndexTest, DirectWrites) {
-  // Same 9 positions but recorded at different points in time.
-  runTest(1, 9, 2);
-  runTest(10, 9, 100);
-}
-
-class StringColumnWriterAbandonDictionaryIndexTest
-    : public StringColumnWriterDirectEncodingIndexTest {
- public:
-  explicit StringColumnWriterAbandonDictionaryIndexTest()
-      : StringColumnWriterDirectEncodingIndexTest{true} {}
-};
-
-TEST_F(StringColumnWriterAbandonDictionaryIndexTest, AbandonDictionary) {
-  runTest(1, 9, 0, abandonEveryWrite);
-  runTest(10, 9, 0, abandonEveryWrite);
-  // 9 positions: {PRESENT, 4}, {DATA, 2}, {DATA_LENGTH, 3}
-  runTest(1, 9, 5, abandonNthWrite(0));
-  runTest(10, 9, 5, abandonNthWrite(7));
-  runTest(1, 9, 5, abandonEveryWrite);
-  runTest(10, 9, 5, abandonEveryWrite);
-}
-
-class ListColumnWriterEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<Array<float>> {
- public:
-  ListColumnWriterEncodingIndexTest() = default;
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    auto nulls = allocateNulls(size, pool);
-    auto* nullsPtr = nulls->asMutable<uint64_t>();
-    size_t nullCount = 0;
-
-    auto offsets = allocateOffsets(size, pool);
-    auto* offsetsPtr = offsets->asMutable<vector_size_t>();
-
-    auto lengths = allocateSizes(size, pool);
-    auto* lengthsPtr = lengths->asMutable<vector_size_t>();
-
-    size_t value = 0;
-    size_t nullEvery = 10;
-    // set up list
-    auto offset = 0;
-    for (size_t i = 0; i < size; i++) {
-      if (i % nullEvery == 0) {
-        bits::setNull(nullsPtr, i);
-        nullCount++;
-      } else {
-        bits::clearNull(nullsPtr, i);
-        offsetsPtr[i] = offset;
-        lengthsPtr[i] = value++;
-        offset += lengthsPtr[i];
-        value %= 50;
-      }
-    }
-    offsetsPtr[size] = offset;
-
-    auto noNulls = [](size_t i, size_t /*unused*/) -> bool { return false; };
-
-    return std::make_shared<ArrayVector>(
-        pool,
-        CppToType<Array<float>>::create(),
-        nulls,
-        size,
-        offsets,
-        lengths,
-        prepBatchImpl<float>(
-            offset,
-            pool,
-            [](size_t i, size_t /*unused*/) -> float { return i; },
-            noNulls),
-        nullCount);
-  }
-};
-
-TEST_F(ListColumnWriterEncodingIndexTest, TestIndex) {
-  // List Stream has present and length.
-  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining (4)
-  // Length stream has compressed size, uncompressed size, RLE numLiterals (3)
-  // so total Streams(4+3) = 7. It has no back fill streams.
-
-  this->runTest(2, 7, 0, 0);
-  this->runTest(2, 7, 0, 1);
-  this->runTest(2, 7, 0, 100);
-}
-
-class MapColumnWriterEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<Map<float, float>> {
- public:
-  MapColumnWriterEncodingIndexTest() = default;
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    auto nulls = allocateNulls(size, pool);
-    auto* nullsPtr = nulls->asMutable<uint64_t>();
-    size_t nullCount = 0;
-
-    auto offsets = allocateOffsets(size, pool);
-    auto* offsetsPtr = offsets->asMutable<vector_size_t>();
-
-    auto lengths = allocateSizes(size, pool);
-    auto* lengthsPtr = lengths->asMutable<vector_size_t>();
-
-    size_t value = 0;
-    size_t nullEvery = 10;
-    // set up list
-    auto offset = 0;
-    for (size_t i = 0; i < size; i++) {
-      if (i % nullEvery == 0) {
-        bits::setNull(nullsPtr, i);
-        nullCount++;
-      } else {
-        bits::clearNull(nullsPtr, i);
-        offsetsPtr[i] = offset;
-        lengthsPtr[i] = value++;
-        offset += lengthsPtr[i];
-        value %= 50;
-      }
-    }
-    offsetsPtr[size] = offset;
-
-    auto noNulls = [](size_t i, size_t /*unused*/) -> bool { return false; };
-
-    return std::make_shared<MapVector>(
-        pool,
-        CppToType<Map<float, float>>::create(),
-        nulls,
-        size,
-        offsets,
-        lengths,
-        prepBatchImpl<float>(
-            offset,
-            pool,
-            [](size_t i, size_t /*unused*/) -> float { return i; },
-            noNulls),
-        prepBatchImpl<float>(
-            offset,
-            pool,
-            [](size_t i, size_t /*unused*/) -> float { return i; },
-            noNulls),
-        nullCount);
-  }
-};
-
-TEST_F(MapColumnWriterEncodingIndexTest, TestIndex) {
-  // Map Stream has present and length.
-  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining (4)
-  // Length stream has compressed size, uncompressed size, RLE numLiterals (3)
-  // so total Streams(4+3) = 7. It has no back fill streams.
-
-  this->runTest(2, 7, 0, 0);
-  this->runTest(2, 7, 0, 1);
-  this->runTest(2, 7, 0, 100);
-}
-
-class FlatMapColumnWriterEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<Row<Map<int32_t, Map<int32_t, float>>>> {
- public:
-  FlatMapColumnWriterEncodingIndexTest() = default;
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    auto offsets = allocateOffsets(size, pool);
-    auto* offsetsPtr = offsets->asMutable<vector_size_t>();
-    auto offsets2 = AlignedBuffer::allocate<vector_size_t>(size, pool);
-    auto* offsets2Ptr = offsets2->asMutable<vector_size_t>();
-
-    auto lengths = allocateSizes(size, pool);
-    auto* lengthsPtr = lengths->asMutable<vector_size_t>();
-    auto lengths2 = AlignedBuffer::allocate<vector_size_t>(size, pool);
-    auto* lengths2Ptr = lengths2->asMutable<vector_size_t>();
-
-    for (size_t i = 0; i < size; i++) {
-      offsetsPtr[i] = i;
-      offsets2Ptr[i] = i;
-      lengthsPtr[i] = 1;
-      lengths2Ptr[i] = 1;
-    }
-
-    auto noNulls = [](size_t /*unused*/, size_t /*unused*/) -> bool {
-      return true;
-    };
-    auto inner = std::make_shared<MapVector>(
-        pool,
-        MAP(INTEGER(), REAL()),
-        nullptr,
-        size,
-        offsets2,
-        lengths2,
-        prepBatchImpl<int32_t>(
-            size,
-            pool,
-            [](size_t i, size_t /*unused*/) -> int32_t { return i; },
-            noNulls),
-        prepBatchImpl<float>(
-            size,
-            pool,
-            [](size_t i, size_t /*unused*/) -> float { return i; },
-            noNulls),
-        0);
-
-    auto outer = std::make_shared<MapVector>(
-        pool,
-        MAP(INTEGER(), MAP(INTEGER(), REAL())),
-        nullptr,
-        size,
-        offsets,
-        lengths,
-        prepBatchImpl<int32_t>(
-            size,
-            pool,
-            [](size_t i, size_t /*unused*/) -> int32_t { return i % 2; },
-            noNulls),
-        inner,
-        0);
-
-    std::vector<VectorPtr> children{outer};
-    return std::make_shared<RowVector>(
-        pool,
-        ROW({MAP(INTEGER(), MAP(INTEGER(), REAL()))}),
-        nullptr,
-        size,
-        children,
-        0);
-  }
-};
-
-TEST_F(FlatMapColumnWriterEncodingIndexTest, TestIndex) {
-  config_->set(Config::FLATTEN_MAP, true);
-  config_->set(Config::MAP_FLAT_COLS, {0});
-
-  // #0 is root, 0
-  // #1 is a flat map, present 4 = 4
-  // #2 is regular map, in_map 4 + present 4 + length 3 = 11
-  // #3 is int direct: present 4 + data 2 = 6
-  // #4 is float: present 4 + data 2 = 6
-
-  // empty flat map doesn't create value writer
-  this->runTest(2, {0, 4}, {0, 0}, 0, true, 1);
-  this->runTest(
-      2, {0, 4, 11, 6, 6, 11, 6, 6}, {0, 0, 0, 0, 0, 0, 0, 0}, 1, true, 1);
-  this->runTest(
-      2, {0, 4, 11, 6, 6, 11, 6, 6}, {0, 0, 0, 0, 0, 0, 0, 0}, 100, true, 1);
-}
-
-class StructColumnWriterEncodingIndexTest
-    : public testing::Test,
-      public WriterEncodingIndexTest2<Row<float, float>> {
- public:
-  StructColumnWriterEncodingIndexTest() = default;
-
- protected:
-  VectorPtr prepBatch(size_t size, MemoryPool* pool) override {
-    return prepBatch(size, pool, false);
-  }
-
-  VectorPtr prepBatch(size_t size, MemoryPool* pool, bool isRoot) override {
-    auto nulls = allocateNulls(size, pool);
-    auto* nullsPtr = nulls->asMutable<uint64_t>();
-    size_t nullCount = 0;
-
-    size_t nullEvery = 10;
-    for (size_t i = 0; i < size; i++) {
-      bool isNull = !isRoot && (i % nullEvery == 0);
-      bits::setNull(nullsPtr, i, isNull);
-      if (isNull) {
-        nullCount++;
-      }
-    }
-
-    auto noNulls = [](size_t i, size_t /*unused*/) -> bool { return false; };
-
-    std::vector<VectorPtr> children(2);
-    for (size_t i = 0; i < 2; i++) {
-      children[i] = prepBatchImpl<float>(
-          size,
-          pool,
-          [](size_t i, size_t /*unused*/) -> float { return i; },
-          noNulls);
-    }
-
-    return std::make_shared<RowVector>(
-        pool,
-        CppToType<Row<float, float>>::create(),
-        nulls,
-        size,
-        children,
-        nullCount);
-  }
-};
-
-TEST_F(StructColumnWriterEncodingIndexTest, TestIndex) {
-  // Struct Stream has present stream
-  // Present Stream has compressed size, uncompressed size, ByteRLE numLiterals,
-  // Boolean 8-bitsRemaining (4)
-  this->runTest(2, 4, 0, 0, false);
-  this->runTest(2, 4, 0, 1, false);
-  this->runTest(2, 4, 0, 100, false);
-
-  // For root, we don't have present stream, so 0
-  this->runTest(2, 0, 0, 0, true);
-  this->runTest(2, 0, 0, 1, true);
-  this->runTest(2, 0, 0, 100, true);
-}
-
-} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/ColumnWriterStatsTests.cpp b/velox/dwio/dwrf/test/ColumnWriterStatsTests.cpp
index 015b9e3623534..f0d66c6f699bf 100644
--- a/velox/dwio/dwrf/test/ColumnWriterStatsTests.cpp
+++ b/velox/dwio/dwrf/test/ColumnWriterStatsTests.cpp
@@ -51,59 +51,62 @@ void verifyStats(
     const size_t repeat,
     const std::vector<size_t>& nodeSizePerStride,
     const bool hasFlatMapCol) {
-  ASSERT_EQ(1, rowReader.getReader().getFooter().stripesSize())
+  ASSERT_EQ(1, rowReader.getReader().footer().stripesSize())
       << "Only one stripe expected";
 
-  ASSERT_EQ(true, rowReader.getReader().getFooter().hasRawDataSize())
+  ASSERT_EQ(true, rowReader.getReader().footer().hasRawDataSize())
       << "File raw data size does not exist";
 
   ASSERT_EQ(
       nodeSizePerStride.at(0) * repeat,
-      rowReader.getReader().getFooter().rawDataSize())
+      rowReader.getReader().footer().rawDataSize())
       << "File raw data size does not match";
 
   // Verify File Column's raw Size.
   for (auto nodeId = 0; nodeId < nodeSizePerStride.size(); nodeId++) {
     ASSERT_EQ(
         nodeSizePerStride.at(nodeId) * repeat,
-        rowReader.getReader().getColumnStatistics(nodeId)->getRawSize())
+        rowReader.getReader().columnStatistics(nodeId)->getRawSize())
         << "RawSize does not match. Node " << nodeId << " "
-        << rowReader.getReader().getColumnStatistics(nodeId)->toString();
+        << rowReader.getReader().columnStatistics(nodeId)->toString();
   }
 
   bool preload = true;
-  auto stripeInfo = rowReader.loadStripe(0, preload);
+  auto stripeMetadata = rowReader.fetchStripe(0, preload);
+  auto& stripeInfo = stripeMetadata->stripeInfo;
 
   // Verify Stripe content length + index length equals size of the column 0.
   auto totalStreamSize = stripeInfo.dataLength() + stripeInfo.indexLength();
-  auto node_0_Size = rowReader.getReader().getColumnStatistics(0)->getSize();
+  auto node_0_Size = rowReader.getReader().columnStatistics(0)->getSize();
 
   ASSERT_EQ(node_0_Size, totalStreamSize) << "Total size does not match";
 
   // Compute Node Size and verify the File Footer Node Size matches.
-  auto& stripeFooter = rowReader.getStripeFooter();
+  auto& stripeFooter = *stripeMetadata->footer;
   std::unordered_map<uint32_t, uint64_t> nodeSizes;
   for (auto&& ss : stripeFooter.streams()) {
     nodeSizes[ss.node()] += ss.length();
   }
 
   computeCumulativeNodeSize(
-      nodeSizes, *TypeWithId::create(rowReader.getReader().getSchema()));
+      nodeSizes, *TypeWithId::create(rowReader.getReader().schema()));
   for (auto nodeId = 0;
-       nodeId < rowReader.getReader().getFooter().statisticsSize();
+       nodeId < rowReader.getReader().footer().statisticsSize();
        nodeId++) {
     ASSERT_EQ(
         nodeSizes[nodeId],
-        rowReader.getReader().getColumnStatistics(nodeId)->getSize().value())
+        rowReader.getReader().columnStatistics(nodeId)->getSize().value())
         << "Size does not match. Node " << nodeId << " "
-        << rowReader.getReader().getColumnStatistics(nodeId)->toString();
+        << rowReader.getReader().columnStatistics(nodeId)->toString();
   }
 
   // Verify Stride Stats.
   StripeStreamsImpl streams{
-      rowReader,
-      rowReader.getColumnSelector(),
-      rowReader.getRowReaderOptions(),
+      std::make_shared<StripeReadState>(
+          rowReader.readerBaseShared(), std::move(stripeMetadata)),
+      &rowReader.getColumnSelector(),
+      nullptr,
+      rowReader.rowReaderOptions(),
       stripeInfo.offset(),
       static_cast<int64_t>(stripeInfo.numberOfRows()),
       rowReader,
@@ -125,7 +128,7 @@ void verifyStats(
 
     for (auto count = 0; count < rowIndex->entry_size(); count++) {
       auto stridStatistics = buildColumnStatisticsFromProto(
-          rowIndex->entry(count).statistics(),
+          ColumnStatisticsWrapper(&rowIndex->entry(count).statistics()),
           dwrf::StatsContext(WriterVersion_CURRENT));
       // TODO, take in a lambda to verify the entire statistics instead of Just
       // the rawSize.
@@ -141,8 +144,12 @@ using PopulateBatch =
 
 class ColumnWriterStatsTest : public ::testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    rootPool_ = defaultMemoryManager().addRootPool("ColumnWriterStatsTest");
+    rootPool_ = memory::memoryManager()->addRootPool("ColumnWriterStatsTest");
     leafPool_ = rootPool_->addLeafChild("ColumnWriterStatsTest");
   }
 
@@ -182,8 +189,9 @@ class ColumnWriterStatsTest : public ::testing::Test {
 
     writer.close();
 
-    std::string_view data(sinkPtr->data(), sinkPtr->size());
-    auto readFile = std::make_shared<facebook::velox::InMemoryReadFile>(data);
+    std::string data(sinkPtr->data(), sinkPtr->size());
+    auto readFile =
+        std::make_shared<facebook::velox::InMemoryReadFile>(std::move(data));
     auto input = std::make_unique<BufferedInput>(readFile, *leafPool_);
 
     dwio::common::ReaderOptions readerOpts{leafPool_.get()};
@@ -532,7 +540,7 @@ TEST_F(ColumnWriterStatsTest, List) {
     auto nodeSizePerStride = populateFloatBatch(pool, &childVector, childSize);
     *vector = std::make_shared<ArrayVector>(
         &pool,
-        CppToType<Array<float>>::create(),
+        ARRAY(REAL()),
         nulls,
         size,
         offsets,
@@ -581,7 +589,7 @@ TEST_F(ColumnWriterStatsTest, Map) {
     auto nodeSizePerStride = populateFloatBatch(pool, &valueVector, childSize);
     *vector = std::make_shared<MapVector>(
         &pool,
-        CppToType<Map<int32_t, float>>::create(),
+        MAP(INTEGER(), REAL()),
         nulls,
         size,
         offsets,
@@ -635,12 +643,7 @@ TEST_F(ColumnWriterStatsTest, Struct) {
           nodeSizePerStride.push_back(floatBatchSize);
         }
         *vector = std::make_shared<RowVector>(
-            &pool,
-            CppToType<Row<float, float>>::create(),
-            nulls,
-            size,
-            children,
-            nullCount);
+            &pool, ROW({REAL(), REAL()}), nulls, size, children, nullCount);
         nodeSizePerStride.at(0) =
             nullCount + nodeSizePerStride.at(2) + nodeSizePerStride.at(3);
         nodeSizePerStride.at(1) =
diff --git a/velox/dwio/dwrf/test/ColumnWriterTest.cpp b/velox/dwio/dwrf/test/ColumnWriterTest.cpp
new file mode 100644
index 0000000000000..93cc5f0533081
--- /dev/null
+++ b/velox/dwio/dwrf/test/ColumnWriterTest.cpp
@@ -0,0 +1,4623 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Random.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <algorithm>
+#include <optional>
+#include <vector>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/dwio/common/IntDecoder.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/dwio/common/exception/Exception.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/dwio/common/tests/utils/MapBuilder.h"
+#include "velox/dwio/dwrf/common/DecoderUtil.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/type/Type.h"
+#include "velox/vector/DictionaryVector.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+using namespace ::testing;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwrf;
+using namespace facebook::velox::test;
+using namespace facebook::velox;
+using namespace facebook::velox::memory;
+using folly::Random;
+
+namespace facebook::velox::dwrf {
+
+class MockStrideIndexProvider : public StrideIndexProvider {
+ public:
+  MOCK_CONST_METHOD0(getStrideIndex, uint64_t());
+};
+
+class MockStreamInformation : public StreamInformation {
+ public:
+  explicit MockStreamInformation(const DwrfStreamIdentifier& streamIdentifier)
+      : streamIdentifier_{streamIdentifier} {}
+
+  StreamKind getKind() const override {
+    return streamIdentifier_.kind();
+  }
+
+  uint32_t getNode() const override {
+    return streamIdentifier_.encodingKey().node();
+  }
+
+  uint32_t getSequence() const override {
+    return streamIdentifier_.encodingKey().sequence();
+  }
+
+  MOCK_CONST_METHOD0(getOffset, uint64_t());
+  MOCK_CONST_METHOD0(getLength, uint64_t());
+  MOCK_CONST_METHOD0(getUseVInts, bool());
+  MOCK_CONST_METHOD0(valid, bool());
+
+ private:
+  const DwrfStreamIdentifier& streamIdentifier_;
+};
+
+class TestStripeStreams : public StripeStreamsBase {
+ public:
+  TestStripeStreams(
+      WriterContext& context,
+      const proto::StripeFooter& footer,
+      const std::shared_ptr<const RowType>& rowType,
+      MemoryPool* pool,
+      bool returnFlatVector = false,
+      std::unordered_map<uint32_t, std::vector<std::string>>
+          structReaderContext = {})
+      : StripeStreamsBase{pool},
+        context_{context},
+        footer_{footer},
+        selector_{rowType} {
+    options_.setReturnFlatVector(returnFlatVector);
+    if (!structReaderContext.empty()) {
+      options_.setFlatmapNodeIdsAsStruct(structReaderContext);
+    }
+  }
+
+  std::unique_ptr<SeekableInputStream> getStream(
+      const DwrfStreamIdentifier& si,
+      std::string_view /* label */,
+      bool throwIfNotFound) const override {
+    const DataBufferHolder* stream = nullptr;
+    if (context_.hasStream(si)) {
+      stream = std::addressof(context_.getStream(si));
+    }
+    if (!stream || stream->isSuppressed()) {
+      if (throwIfNotFound) {
+        DWIO_RAISE(fmt::format("stream {} not found", si.toString()));
+      } else {
+        return nullptr;
+      }
+    }
+
+    auto buf = std::make_unique<DataBuffer<char>>(
+        context_.getMemoryPool(MemoryUsageCategory::GENERAL), 0);
+    stream->spill(*buf);
+    auto compressed =
+        std::make_unique<SeekableArrayInputStream>(buf->data(), buf->size());
+    buffers_.push_back(std::move(buf));
+
+    return createDecompressor(
+        context_.compression(),
+        std::move(compressed),
+        context_.compressionBlockSize(),
+        getMemoryPool(),
+        si.toString());
+  }
+
+  const proto::ColumnEncoding& getEncoding(
+      const EncodingKey& ek) const override {
+    for (auto& enc : footer_.encoding()) {
+      if (ek.node() == enc.node() && ek.sequence() == enc.sequence()) {
+        return enc;
+      }
+    }
+    DWIO_RAISE("encoding not found");
+  }
+
+  uint32_t visitStreamsOfNode(
+      uint32_t node,
+      std::function<void(const StreamInformation&)> visitor) const override {
+    uint32_t count = 0;
+    context_.iterateUnSuppressedStreams([&](auto& pair) {
+      if (pair.first.encodingKey().node() == node) {
+        visitor(MockStreamInformation(pair.first));
+        ++count;
+      }
+    });
+
+    return count;
+  }
+
+  const ColumnSelector& getColumnSelector() const override {
+    return selector_;
+  }
+
+  const RowReaderOptions& rowReaderOptions() const override {
+    return options_;
+  }
+
+  bool getUseVInts(const DwrfStreamIdentifier& streamId) const override {
+    DWIO_ENSURE(
+        context_.hasStream(streamId),
+        fmt::format("Stream not found: {}", streamId.toString()));
+    return context_.getConfig(Config::USE_VINTS);
+  }
+
+  const StrideIndexProvider& getStrideIndexProvider() const override {
+    return mockStrideIndexProvider_;
+  }
+
+  const StrictMock<MockStrideIndexProvider>& getMockStrideIndexProvider() {
+    return mockStrideIndexProvider_;
+  }
+
+  int64_t stripeRows() const override {
+    VELOX_UNSUPPORTED();
+  }
+
+  uint32_t rowsPerRowGroup() const override {
+    VELOX_UNSUPPORTED();
+  }
+
+ private:
+  WriterContext& context_;
+  const proto::StripeFooter& footer_;
+  ColumnSelector selector_;
+  RowReaderOptions options_;
+  mutable std::vector<std::unique_ptr<DataBuffer<char>>> buffers_;
+  StrictMock<MockStrideIndexProvider> mockStrideIndexProvider_;
+};
+
+constexpr uint32_t ITERATIONS = 100'000;
+
+template <typename T>
+VectorPtr populateBatch(
+    std::vector<std::optional<T>> const& data,
+    MemoryPool* pool) {
+  BufferPtr values = AlignedBuffer::allocate<T>(data.size(), pool);
+  auto valuesPtr = values->asMutableRange<T>();
+
+  BufferPtr nulls = allocateNulls(data.size(), pool);
+  auto* nullsPtr = nulls->asMutable<uint64_t>();
+  size_t index = 0;
+  size_t nullCount = 0;
+  for (auto val : data) {
+    if (val) {
+      valuesPtr[index] = val.value();
+      bits::clearNull(nullsPtr, index);
+    } else {
+      bits::setNull(nullsPtr, index);
+      ++nullCount;
+    }
+    ++index;
+  }
+
+  auto batch = std::make_shared<FlatVector<T>>(
+      pool,
+      CppToType<T>::create(),
+      nulls,
+      data.size(),
+      values,
+      std::vector<BufferPtr>{});
+  batch->setNullCount(nullCount);
+  return batch;
+}
+
+template <typename T>
+void verifyValue(
+    const std::shared_ptr<FlatVector<T>>& fv,
+    size_t index,
+    T value,
+    const uint32_t seed,
+    bool* failed) {
+  *failed = value != fv->valueAt(index);
+  ASSERT_EQ(value, fv->valueAt(index))
+      << "value mismatch at " << index << " with seed " << seed;
+}
+
+template <>
+void verifyValue(
+    const std::shared_ptr<FlatVector<Timestamp>>& fv,
+    size_t index,
+    Timestamp timestamp,
+    const uint32_t seed,
+    bool* failed) {
+  *failed = true;
+  auto v = fv->valueAt(index);
+  if (timestamp.getNanos() > 0 && timestamp.getSeconds() == -1) {
+    // This value should be corrupted by Java Writer. Ensure that
+    // same behavior happens in the CPP as well. Look into
+    // the TimestampColumnWriter comment on the reason behind this.
+    ASSERT_EQ(v.getSeconds(), 0) << "Unexpected seconds" << v.getSeconds()
+                                 << " with index, seed " << index << seed;
+  } else {
+    ASSERT_EQ(v.getSeconds(), timestamp.getSeconds())
+        << "Seconds mismatch with index, seed " << index << seed;
+  }
+
+  ASSERT_EQ(v.getNanos(), timestamp.getNanos())
+      << "Nanos mismatch with index, seed " << index << seed;
+  *failed = false;
+}
+
+template <typename T>
+void verifyBatch(
+    std::vector<std::optional<T>> const& data,
+    const VectorPtr& out,
+    const std::optional<vector_size_t>& nullCount,
+    const uint32_t seed) {
+  auto size = data.size();
+  ASSERT_EQ(out->size(), size) << "Batch size mismatch with seed " << seed;
+  ASSERT_EQ(nullCount, out->getNullCount())
+      << "nullCount mismatch with seed " << seed;
+
+  auto outFv = std::dynamic_pointer_cast<FlatVector<T>>(out);
+  size_t index = 0;
+  for (auto val : data) {
+    bool failed = false;
+    if (val) {
+      ASSERT_FALSE(out->isNullAt(index))
+          << "null mismatch with index, seed " << index << seed;
+
+      if constexpr (std::is_floating_point_v<T>) {
+        // for floating point nan != nan
+        if (std::isnan(val.value())) {
+          ASSERT_TRUE(std::isnan(outFv->rawValues()[index]))
+              << "nan mismatch with seed " << seed;
+        } else {
+          verifyValue(outFv, index, val.value(), seed, &failed);
+        }
+      } else {
+        verifyValue(outFv, index, val.value(), seed, &failed);
+      }
+    } else {
+      ASSERT_TRUE(out->isNullAt(index)) << "null mismatch with seed " << seed;
+    }
+    ++index;
+    if (failed) {
+      break;
+    }
+  }
+}
+
+template <typename T>
+void testDataTypeWriter(
+    const TypePtr& type,
+    std::vector<std::optional<T>>& data,
+    const uint32_t sequence = 0) {
+  // Generate a seed and randomly shuffle the data
+  uint32_t seed = Random::rand32();
+  std::shuffle(data.begin(), data.end(), std::default_random_engine(seed));
+
+  auto config = std::make_shared<Config>();
+  auto pool = memory::memoryManager()->addLeafPool();
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  auto rowType = ROW({type});
+  auto dataTypeWithId = TypeWithId::create(type, 1);
+
+  // write
+  auto writer = BaseColumnWriter::create(context, *dataTypeWithId, sequence);
+  auto size = data.size();
+  auto batch = populateBatch(data, pool.get());
+  const size_t stripeCount = 2;
+  const size_t strideCount = 3;
+
+  for (auto stripeI = 0; stripeI < stripeCount; ++stripeI) {
+    proto::StripeFooter sf;
+    for (auto strideI = 0; strideI < strideCount; ++strideI) {
+      writer->write(batch, common::Ranges::of(0, size));
+      writer->createIndexEntry();
+    }
+    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
+      return *sf.add_encoding();
+    });
+
+    TestStripeStreams streams(context, sf, rowType, pool.get());
+    auto typeWithId = TypeWithId::create(rowType);
+    auto reqType = typeWithId->childAt(0);
+
+    memory::AllocationPool allocPool(pool.get());
+    StreamLabels labels(allocPool);
+    auto reader = ColumnReader::build(
+        reqType,
+        reqType,
+        streams,
+        labels,
+        nullptr,
+        0,
+        FlatMapContext{
+            .sequence = sequence,
+            .inMapDecoder = nullptr,
+            .keySelectionCallback = nullptr});
+    VectorPtr out;
+    for (auto strideI = 0; strideI < strideCount; ++strideI) {
+      reader->next(size, out);
+      verifyBatch(data, out, batch->getNullCount(), seed);
+    }
+    // Reader API requires the caller to read the Stripe for number of
+    // values and iterate only until that number.
+    // It does notd support hasNext/next protocol.
+    // Use a bigger number like 50, as some values may be bit packed.
+    VELOX_ASSERT_THROW(reader->next(50, out), "");
+
+    context.nextStripe();
+    writer->reset();
+  }
+}
+
+class ColumnWriterTest : public Test {
+ public:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+ protected:
+  std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+
+TEST_F(ColumnWriterTest, LowMemoryModeConfig) {
+  auto dataTypeWithId = TypeWithId::create(std::make_shared<VarcharType>(), 1);
+  auto config = std::make_shared<Config>();
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  auto writer = BaseColumnWriter::create(context, *dataTypeWithId);
+  EXPECT_TRUE(writer->useDictionaryEncoding());
+}
+
+TEST_F(ColumnWriterTest, IntegerDictionaryEncodingEnabledConfig) {
+  auto dataTypeWithId = TypeWithId::create(INTEGER(), 1);
+  auto config = std::make_shared<Config>();
+  config->set(Config::INTEGER_DICTIONARY_ENCODING_ENABLED, true);
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  auto writer = BaseColumnWriter::create(context, *dataTypeWithId);
+  EXPECT_TRUE(writer->useDictionaryEncoding());
+
+  dataTypeWithId = TypeWithId::create(INTEGER(), 2);
+  config->set(Config::INTEGER_DICTIONARY_ENCODING_ENABLED, false);
+  writer = BaseColumnWriter::create(context, *dataTypeWithId);
+  EXPECT_FALSE(writer->useDictionaryEncoding());
+}
+
+TEST_F(ColumnWriterTest, StringDictionaryEncodingEnabledConfig) {
+  auto dataTypeWithId = TypeWithId::create(VARCHAR(), 1);
+  auto config = std::make_shared<Config>();
+  config->set(Config::STRING_DICTIONARY_ENCODING_ENABLED, true);
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  auto writer = BaseColumnWriter::create(context, *dataTypeWithId);
+  EXPECT_TRUE(writer->useDictionaryEncoding());
+
+  dataTypeWithId = TypeWithId::create(VARCHAR(), 2);
+  config->set(Config::STRING_DICTIONARY_ENCODING_ENABLED, false);
+  writer = BaseColumnWriter::create(context, *dataTypeWithId);
+  EXPECT_FALSE(writer->useDictionaryEncoding());
+}
+
+TEST_F(ColumnWriterTest, TestBooleanWriter) {
+  std::vector<std::optional<bool>> data;
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    bool value = (bool)(Random::rand32() & 1);
+    data.emplace_back(value);
+  }
+  testDataTypeWriter(BOOLEAN(), data);
+
+  // Test writer with non-zero sequence
+  testDataTypeWriter(BOOLEAN(), data, 3);
+}
+
+TEST_F(ColumnWriterTest, TestNullBooleanWriter) {
+  std::vector<std::optional<bool>> data;
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    data.emplace_back();
+  }
+  testDataTypeWriter(BOOLEAN(), data);
+}
+
+TEST_F(ColumnWriterTest, TestTimestampEpochWriter) {
+  std::vector<std::optional<Timestamp>> data;
+  // This value will be corrupted. verified in verifyValue method.
+  data.emplace_back(Timestamp(-1, 1));
+  data.emplace_back(Timestamp(-1, MAX_NANOS));
+
+  // The following values should not be corrupted.
+  data.emplace_back(Timestamp(-1, 0));
+  data.emplace_back(Timestamp(0, 0));
+  data.emplace_back(Timestamp(0, 1));
+  data.emplace_back(Timestamp(0, MAX_NANOS));
+  testDataTypeWriter(TIMESTAMP(), data);
+}
+
+TEST_F(ColumnWriterTest, TestTimestampWriter) {
+  std::vector<std::optional<Timestamp>> data;
+  for (int64_t i = 0; i < ITERATIONS; ++i) {
+    Timestamp ts(i, i);
+    data.emplace_back(ts);
+  }
+  testDataTypeWriter(TIMESTAMP(), data);
+
+  // Test writer with non-zero sequence
+  testDataTypeWriter(TIMESTAMP(), data, 6);
+}
+
+TEST_F(ColumnWriterTest, TestTimestampBoundaryValuesWriter) {
+  std::vector<std::optional<Timestamp>> data;
+  for (int64_t i = 0; i < ITERATIONS; ++i) {
+    if (i & 1) {
+      Timestamp ts(Timestamp::kMaxSeconds, MAX_NANOS);
+      data.emplace_back(ts);
+    } else {
+      Timestamp ts(Timestamp::kMinSeconds, MAX_NANOS);
+      data.emplace_back(ts);
+    }
+    data.emplace_back();
+  }
+  testDataTypeWriter(TIMESTAMP(), data);
+}
+
+TEST_F(ColumnWriterTest, TestTimestampMixedWriter) {
+  std::vector<std::optional<Timestamp>> data;
+  for (int64_t i = 0; i < ITERATIONS; ++i) {
+    int64_t seconds = Random::rand64(Timestamp::kMaxSeconds);
+    int64_t nanos = Random::rand32(MAX_NANOS + 1);
+    Timestamp ts(seconds, nanos);
+    data.emplace_back(ts);
+    // Add null value
+    data.emplace_back();
+  }
+  testDataTypeWriter(TIMESTAMP(), data);
+}
+
+void verifyInvalidTimestamp(int64_t seconds, int64_t nanos) {
+  std::vector<std::optional<Timestamp>> data;
+  for (int64_t i = 1; i < ITERATIONS; ++i) {
+    Timestamp ts(i, i);
+    data.emplace_back(ts);
+  }
+  Timestamp ts(seconds, nanos);
+  data.emplace_back(ts);
+  EXPECT_THROW(
+      testDataTypeWriter(TIMESTAMP(), data), exception::LoggedException);
+}
+
+TEST_F(ColumnWriterTest, TestTimestampNullWriter) {
+  std::vector<std::optional<Timestamp>> data;
+  for (int64_t i = 0; i < ITERATIONS; ++i) {
+    data.emplace_back();
+  }
+  testDataTypeWriter(TIMESTAMP(), data);
+}
+
+TEST_F(ColumnWriterTest, TestBooleanMixedWriter) {
+  std::vector<std::optional<bool>> data;
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    bool value = (bool)(Random::rand32() & 1);
+    data.emplace_back(value);
+    data.emplace_back();
+  }
+  testDataTypeWriter(BOOLEAN(), data);
+}
+
+TEST_F(ColumnWriterTest, TestAllBytesWriter) {
+  std::vector<std::optional<int8_t>> data;
+  for (int16_t i = INT8_MIN; i <= INT8_MAX; ++i) {
+    data.emplace_back(i);
+  }
+  for (int16_t i = INT8_MAX; i >= INT8_MIN; --i) {
+    data.emplace_back(i);
+  }
+  testDataTypeWriter(TINYINT(), data);
+}
+
+TEST_F(ColumnWriterTest, TestRepeatedValuesByteWriter) {
+  std::vector<std::optional<int8_t>> data;
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    data.emplace_back(INT8_MIN);
+  }
+  testDataTypeWriter(TINYINT(), data);
+}
+
+TEST_F(ColumnWriterTest, TestOnlyNullByteWriter) {
+  std::vector<std::optional<int8_t>> data;
+  for (auto i = 0; i <= ITERATIONS; ++i) {
+    data.emplace_back();
+  }
+  testDataTypeWriter(TINYINT(), data);
+}
+
+TEST_F(ColumnWriterTest, TestByteNullAndExtremeValueMixed) {
+  std::vector<std::optional<int8_t>> data;
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    data.emplace_back(INT8_MIN);
+    data.emplace_back();
+    data.emplace_back(INT8_MAX);
+  }
+  testDataTypeWriter(TINYINT(), data);
+}
+
+template <typename T>
+void generateSampleData(std::vector<std::optional<T>>& data) {
+  const size_t size = 100;
+  for (size_t i = 0; i < size; ++i) {
+    if (i != 20 && i != 40) {
+      data.emplace_back(i);
+    } else {
+      data.emplace_back();
+    }
+    ASSERT_EQ(i != 20 && i != 40, data.at(i).has_value());
+  }
+}
+
+TEST_F(ColumnWriterTest, TestByteWriter) {
+  std::vector<std::optional<int8_t>> data;
+  generateSampleData(data);
+  testDataTypeWriter(TINYINT(), data);
+
+  // Test writer with non-zero sequence
+  testDataTypeWriter(TINYINT(), data, 5);
+}
+
+TEST_F(ColumnWriterTest, TestShortWriter) {
+  std::vector<std::optional<int16_t>> data;
+  generateSampleData(data);
+  testDataTypeWriter(SMALLINT(), data);
+
+  // Test writer with non-zero sequence
+  testDataTypeWriter(SMALLINT(), data, 23);
+}
+
+TEST_F(ColumnWriterTest, TestIntWriter) {
+  std::vector<std::optional<int32_t>> data;
+  generateSampleData(data);
+  testDataTypeWriter(INTEGER(), data);
+
+  // Test writer with non-zero sequence
+  testDataTypeWriter(INTEGER(), data, 1);
+}
+
+TEST_F(ColumnWriterTest, TestLongWriter) {
+  std::vector<std::optional<int64_t>> data;
+  generateSampleData(data);
+  testDataTypeWriter(BIGINT(), data);
+
+  // Test writer with non-zero sequence
+  testDataTypeWriter(BIGINT(), data, 42);
+}
+
+TEST_F(ColumnWriterTest, TestBinaryWriter) {
+  std::vector<std::optional<StringView>> data;
+  const size_t size = 100;
+  for (size_t i = 0; i < size; ++i) {
+    if (i != 20 && i != 40) {
+      data.emplace_back(StringView::makeInline(folly::to<std::string>(i)));
+    } else {
+      data.emplace_back();
+    }
+    ASSERT_EQ(i != 20 && i != 40, data.at(i).has_value());
+  }
+  testDataTypeWriter(VARBINARY(), data);
+
+  // Test writer with non-zero sequence
+  testDataTypeWriter(VARBINARY(), data, 42);
+}
+
+TEST_F(ColumnWriterTest, TestBinaryWriterAllNulls) {
+  std::vector<std::optional<StringView>> data{100};
+  testDataTypeWriter(VARBINARY(), data);
+}
+
+template <typename T>
+struct ValueOf {
+  static std::string get(const VectorPtr& batch, const uint32_t offset) {
+    auto scalarBatch = std::dynamic_pointer_cast<FlatVector<T>>(batch);
+    return std::to_string(scalarBatch->valueAt(offset));
+  }
+};
+
+template <>
+struct ValueOf<bool> {
+  static std::string get(const VectorPtr& batch, const uint32_t offset) {
+    auto scalarBatch = std::dynamic_pointer_cast<FlatVector<bool>>(batch);
+    return folly::to<std::string>(scalarBatch->valueAt(offset));
+  }
+};
+
+template <>
+struct ValueOf<StringView> {
+  static std::string get(const VectorPtr& batch, const uint32_t offset) {
+    auto scalarBatch = std::dynamic_pointer_cast<FlatVector<StringView>>(batch);
+    return scalarBatch->valueAt(offset).str();
+  }
+};
+
+template <typename keyT, typename valueT>
+struct ValueOf<Map<keyT, valueT>> {
+  static std::string get(const VectorPtr& batch, const uint32_t offset) {
+    auto mapBatch = std::dynamic_pointer_cast<MapVector>(batch);
+    return folly::to<std::string>(
+        "map at ",
+        offset,
+        " child: ",
+        mapBatch->offsetAt(offset),
+        ":",
+        mapBatch->sizeAt(offset));
+  }
+};
+
+template <typename elemT>
+struct ValueOf<Array<elemT>> {
+  static std::string get(const VectorPtr& batch, const uint32_t offset) {
+    auto arrayBatch = std::dynamic_pointer_cast<ArrayVector>(batch);
+    return folly::to<std::string>(
+        "array at ",
+        offset,
+        " child: ",
+        arrayBatch->offsetAt(offset),
+        ":",
+        arrayBatch->sizeAt(offset));
+  }
+};
+
+template <typename... T>
+struct ValueOf<Row<T...>> {
+  static std::string get(const VectorPtr& /* batch */, const uint32_t offset) {
+    return folly::to<std::string>("row at ", offset);
+  }
+};
+
+template <typename T>
+std::string getNullCountStr(const T& vector) {
+  return vector.getNullCount().has_value()
+      ? std::to_string(vector.getNullCount().value())
+      : "none";
+}
+
+template <typename TKEY, typename TVALUE>
+void printMap(const std::string& title, const VectorPtr& batch) {
+  auto mv = std::dynamic_pointer_cast<MapVector>(batch);
+  if (!mv) {
+    VLOG(3) << "To be implemented for encoded vector";
+    return;
+  }
+
+  VLOG(3) << "*******" << title << "*******";
+  VLOG(3) << "Size: " << mv->size() << ", Null count: " << getNullCountStr(*mv);
+  for (int32_t i = 0; i <= mv->size(); ++i) {
+    VLOG(3) << "Offset[" << i << "]: " << mv->offsetAt(i)
+            << (i < mv->size() && mv->isNullAt(i) ? " (null)" : "");
+  }
+
+  auto keys = mv->mapKeys();
+  auto values = mv->mapValues();
+
+  VLOG(3) << "Keys Size: " << keys->size()
+          << ", Keys Null count: " << getNullCountStr(*keys);
+  VLOG(3) << "Values Size: " << values->size()
+          << ", Values Null count: " << getNullCountStr(*values);
+
+  for (int32_t i = 0; i < keys->size(); ++i) {
+    VLOG(3) << "[" << i << "]: " << ValueOf<TKEY>::get(keys, i) << " -> "
+            << (values->isNullAt(i) ? "null" : ValueOf<TVALUE>::get(values, i));
+  }
+}
+
+void printRow(const std::string& title, const VectorPtr& batch) {
+  auto row = std::dynamic_pointer_cast<RowVector>(batch);
+  if (!row) {
+    VLOG(3) << "To be implemented for encoded vector";
+    return;
+  }
+
+  VLOG(3) << "*******" << title << "*******";
+  VLOG(3) << "Size: " << row->size()
+          << ", Null count: " << getNullCountStr(*row);
+  for (int i = 0; i < row->size(); i++) {
+    VLOG(3) << "[" << i << "]: " << row->toString(i);
+  }
+}
+
+VectorPtr
+wrapInDictionary(const VectorPtr& batch, size_t stride, MemoryPool& pool) {
+  VectorPtr ret = batch;
+  // Wrap key if least significant bit is 1
+  if (stride & 0x01) {
+    auto map = batch->as<MapVector>();
+    auto keys = map->mapKeys();
+    auto size = keys->size();
+
+    auto indices = AlignedBuffer::allocate<vector_size_t>(size, &pool);
+    auto rawIndices = indices->asMutable<vector_size_t>();
+    for (auto i = 0; i < size; ++i) {
+      rawIndices[i] = i;
+    }
+
+    ret = std::make_shared<MapVector>(
+        map->pool(),
+        map->type(),
+        map->nulls(),
+        map->size(),
+        map->offsets(),
+        map->sizes(),
+        BaseVector::wrapInDictionary(nullptr, indices, size, keys),
+        map->mapValues());
+  }
+
+  // Wrap map if 2nd least significant bit is 1
+  if (stride & 0x02) {
+    auto size = ret->size();
+
+    auto indices = AlignedBuffer::allocate<vector_size_t>(size, &pool);
+    auto rawIndices = indices->asMutable<vector_size_t>();
+    for (auto i = 0; i < size; ++i) {
+      rawIndices[i] = i;
+    }
+
+    ret = BaseVector::wrapInDictionary(nullptr, indices, size, ret);
+  }
+
+  return ret;
+}
+
+VectorPtr wrapInDictionaryRow(const VectorPtr& batch, MemoryPool& pool) {
+  auto row = batch->as<RowVector>();
+
+  auto size = row->size();
+  auto indices = AlignedBuffer::allocate<vector_size_t>(size, &pool);
+  auto rawIndices = indices->asMutable<vector_size_t>();
+  for (auto i = 0; i < size; i++) {
+    rawIndices[i] = i;
+  }
+
+  return BaseVector::wrapInDictionary(nullptr, indices, size, batch);
+}
+
+template <typename T>
+void getUniqueKeys(
+    std::vector<T>& uniqueKeys,
+    const std::vector<VectorPtr>& batches) {
+  std::unordered_set<T> seenKeys;
+
+  for (auto batch : batches) {
+    auto map = std::dynamic_pointer_cast<MapVector>(batch);
+    ASSERT_TRUE(map);
+    auto keys = map->mapKeys();
+    auto flatKeys = std::dynamic_pointer_cast<FlatVector<T>>(keys);
+    ASSERT_TRUE(flatKeys);
+    for (vector_size_t i = 0; i < flatKeys->size(); i++) {
+      ASSERT_TRUE(!flatKeys->isNullAt(i));
+      seenKeys.insert(flatKeys->valueAt(i));
+    }
+  }
+
+  uniqueKeys.clear();
+  uniqueKeys.insert(uniqueKeys.end(), seenKeys.cbegin(), seenKeys.cend());
+}
+
+template <typename TKEY, typename TVALUE>
+void mapToStruct(
+    MemoryPool& pool,
+    std::vector<VectorPtr>& batches,
+    const std::vector<TKEY>& uniqueKeys) {
+  std::unordered_map<TKEY, int> keyColIndex;
+  for (auto i = 0; i < uniqueKeys.size(); i++) {
+    keyColIndex[uniqueKeys[i]] = i; // lookup from key -> column#
+  }
+
+  for (size_t i = 0; i < batches.size(); i++) {
+    auto origBatch = batches[i];
+    std::vector<VectorPtr> childrenVectors(uniqueKeys.size());
+    // initialize children of batch size filled with nulls
+    VectorMaker maker{&pool};
+    for (auto column = 0; column < uniqueKeys.size(); column++) {
+      childrenVectors[column] =
+          maker.allNullFlatVector<TVALUE>(origBatch->size());
+      // only flat for scalar types
+      // create function to handle nested complex types
+    }
+    batches[i] = maker.rowVector(childrenVectors);
+    auto batchStruct = std::dynamic_pointer_cast<RowVector>(batches[i]);
+
+    auto mapBatch = std::dynamic_pointer_cast<MapVector>(origBatch);
+    ASSERT_TRUE(mapBatch);
+
+    auto keys = mapBatch->mapKeys();
+    auto flatKeys = std::dynamic_pointer_cast<FlatVector<TKEY>>(keys);
+    ASSERT_TRUE(flatKeys);
+    auto values = mapBatch->mapValues();
+    auto flatValues = std::dynamic_pointer_cast<FlatVector<TVALUE>>(values);
+    ASSERT_TRUE(flatValues);
+
+    auto offsets = mapBatch->offsets()->as<vector_size_t>();
+    auto sizes = mapBatch->sizes()->as<vector_size_t>();
+
+    // for each row in current batch
+    for (vector_size_t row = 0; row < mapBatch->size(); row++) {
+      // for each key in row (single map)
+      for (vector_size_t index = offsets[row],
+                         endOffset = offsets[row] + sizes[row];
+           index < endOffset;
+           index++) {
+        ASSERT_FALSE(flatKeys->isNullAt(index));
+        // set value in correct row
+        auto key = flatKeys->valueAt(index);
+        auto element = std::dynamic_pointer_cast<FlatVector<TVALUE>>(
+            batchStruct->childAt(keyColIndex[key]));
+        ASSERT_TRUE(element);
+        element->set(row, flatValues->valueAt(index));
+      }
+    }
+  }
+}
+
+template <typename TKEY, typename TVALUE, bool useStruct = false>
+void testMapWriter(
+    MemoryPool& pool,
+    const std::vector<VectorPtr>& batches,
+    bool useFlatMap,
+    bool disableDictionaryEncoding,
+    bool testEncoded,
+    bool printMaps = true) {
+  const auto rowType = CppToType<Row<Map<TKEY, TVALUE>>>::create();
+  const auto dataType = rowType->childAt(0);
+  const auto rowTypeWithId = TypeWithId::create(rowType);
+  const auto dataTypeWithId = rowTypeWithId->childAt(0);
+  const auto writerSchema = TypeWithId::create(rowType);
+  const auto writerDataTypeWithId = writerSchema->childAt(0);
+
+  VLOG(2) << "Testing map writer " << dataType->toString() << " using "
+          << (useFlatMap ? "Flat Map" : "Regular Map")
+          << (useFlatMap && useStruct ? " - Struct" : "");
+
+  const auto config = std::make_shared<Config>();
+  auto* pBatches = &batches;
+  std::vector<VectorPtr> structs;
+  std::unordered_map<uint32_t, std::vector<std::string>> structReaderContext;
+  if (useFlatMap) {
+    if constexpr (useStruct) {
+      structs = batches;
+      pBatches = &structs;
+      std::vector<TKEY> uniqueKeys;
+      ASSERT_NO_FATAL_FAILURE(getUniqueKeys<TKEY>(uniqueKeys, batches));
+      ASSERT_NO_FATAL_FAILURE(
+          (mapToStruct<TKEY, TVALUE>(pool, structs, uniqueKeys)));
+
+      std::vector<std::string> uniqueKeysString;
+      uniqueKeysString.reserve(uniqueKeys.size());
+      std::transform(
+          uniqueKeys.cbegin(),
+          uniqueKeys.cend(),
+          std::back_inserter(uniqueKeysString),
+          [](const auto& e) { return folly::to<std::string>(e); });
+      ASSERT_EQ(writerDataTypeWithId->column(), 0);
+      config->set(Config::MAP_FLAT_COLS_STRUCT_KEYS, {uniqueKeysString});
+      structReaderContext[writerDataTypeWithId->id()] = uniqueKeysString;
+    }
+
+    config->set(Config::FLATTEN_MAP, true);
+    config->set(Config::MAP_FLAT_COLS, {writerDataTypeWithId->column()});
+    config->set(
+        Config::MAP_FLAT_DISABLE_DICT_ENCODING, disableDictionaryEncoding);
+
+    // expect that if we pass useStruct true with useFlatMap false, it will fail
+  }
+
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  const auto writer = BaseColumnWriter::create(context, *writerDataTypeWithId);
+  // For writing flat map with encoded input, we'd like to test all 4
+  // combinations.
+  size_t strideCount = testEncoded ? 4 : 2;
+
+  // Each batch represents an input for a separate stripe
+  for (auto batch : *pBatches) {
+    auto isStruct = useFlatMap && useStruct;
+    if (printMaps) {
+      if (isStruct) {
+        printRow("Input", batch);
+      } else {
+        printMap<TKEY, TVALUE>("Input", batch);
+      }
+    }
+
+    proto::StripeFooter sf;
+    std::vector<VectorPtr> writtenBatches;
+
+    // Write map/row
+    for (auto strideI = 0; strideI < strideCount; ++strideI) {
+      auto toWrite = batch;
+      if (testEncoded) {
+        if (isStruct) {
+          toWrite = wrapInDictionaryRow(toWrite, pool);
+        } else {
+          toWrite = wrapInDictionary(toWrite, strideI, pool);
+        }
+      }
+      writer->write(toWrite, common::Ranges::of(0, toWrite->size()));
+      writer->createIndexEntry();
+      writtenBatches.push_back(toWrite);
+    }
+
+    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
+      return *sf.add_encoding();
+    });
+
+    auto validate = [&](bool returnFlatVector = false) {
+      TestStripeStreams streams(
+          context, sf, rowType, &pool, returnFlatVector, structReaderContext);
+      auto pool = memory::memoryManager()->addLeafPool();
+      memory::AllocationPool allocPool(pool.get());
+      StreamLabels labels(allocPool);
+      const auto reader = ColumnReader::build(
+          dataTypeWithId, dataTypeWithId, streams, labels, nullptr, 0);
+      VectorPtr out;
+
+      // Read map/row
+      for (auto& writtenBatch : writtenBatches) {
+        reader->next(writtenBatch->size(), out);
+        ASSERT_EQ(out->size(), writtenBatch->size()) << "Batch size mismatch";
+
+        if (printMaps) {
+          if (isStruct) {
+            printRow("Result", batch);
+          } else {
+            printMap<TKEY, TVALUE>("Result", out);
+          }
+        }
+
+        for (int32_t i = 0; i < writtenBatch->size(); ++i) {
+          ASSERT_TRUE(writtenBatch->equalValueAt(out.get(), i, i))
+              << "Row mismatch at index " << i;
+        }
+      }
+
+      // Reader API requires the caller to read the Stripe for number of
+      // values and iterate only until that number.
+      // It does not support hasNext/next protocol.
+      // Use a bigger number like 50, as some values may be bit packed.
+      VELOX_ASSERT_THROW(reader->next(50, out), "");
+    };
+
+    ASSERT_NO_FATAL_FAILURE(validate());
+    if (useFlatMap) {
+      ASSERT_NO_FATAL_FAILURE(validate(true));
+    }
+
+    context.nextStripe();
+
+    auto valueNodeId = dataTypeWithId->childAt(1)->id();
+    auto streamCount = 0;
+    context.iterateUnSuppressedStreams([&](auto& pair) {
+      if (pair.first.encodingKey().node() == valueNodeId) {
+        ++streamCount;
+      }
+    });
+
+    ASSERT_GT(streamCount, 0) << "Expecting to find at least one value stream";
+
+    writer->reset();
+
+    streamCount = 0;
+    context.iterateUnSuppressedStreams([&](auto& pair) {
+      if (pair.first.encodingKey().node() == valueNodeId) {
+        ++streamCount;
+      }
+    });
+
+    if (useFlatMap) {
+      ASSERT_EQ(streamCount, 0)
+          << "Expecting all flat map value streams to be disposed";
+    } else {
+      ASSERT_GT(streamCount, 0)
+          << "Expecting to find at least one regular map value stream";
+    }
+  }
+}
+
+template <typename TVALUE>
+void testMapWriterRow(
+    MemoryPool& pool,
+    const std::vector<VectorPtr>& batches,
+    bool disableDictionaryEncoding,
+    bool testEncoded,
+    bool printInput = true) {
+  const auto rowType = CppToType<Row<Map<int32_t, TVALUE>>>::create();
+  const auto dataType = rowType->childAt(0);
+  const auto rowTypeWithId = TypeWithId::create(rowType);
+  const auto dataTypeWithId = rowTypeWithId->childAt(0);
+  const auto writerSchema = TypeWithId::create(rowType);
+  const auto writerDataTypeWithId = writerSchema->childAt(0);
+
+  VLOG(2) << "Testing map writer struct input " << dataType->toString();
+
+  const auto config = std::make_shared<Config>();
+  std::unordered_map<uint32_t, std::vector<std::string>> structReaderContext;
+  ASSERT_TRUE(batches.size() > 0);
+  auto row = std::dynamic_pointer_cast<RowVector>(batches[0]);
+  ASSERT_TRUE(row);
+
+  // defaulting to int32_t keys
+  std::vector<std::string> uniqueKeysString;
+  uniqueKeysString.reserve(row->childrenSize());
+  for (auto i = 0; i < row->childrenSize(); i++) {
+    uniqueKeysString.push_back(folly::to<std::string>(i));
+  }
+
+  ASSERT_EQ(writerDataTypeWithId->column(), 0);
+  config->set(Config::MAP_FLAT_COLS_STRUCT_KEYS, {uniqueKeysString});
+  structReaderContext[writerDataTypeWithId->id()] = uniqueKeysString;
+
+  config->set(Config::FLATTEN_MAP, true);
+  config->set(Config::MAP_FLAT_COLS, {writerDataTypeWithId->column()});
+  config->set(
+      Config::MAP_FLAT_DISABLE_DICT_ENCODING, disableDictionaryEncoding);
+
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  const auto writer = BaseColumnWriter::create(context, *writerDataTypeWithId);
+
+  // Each batch represents an input for a separate stripe
+  for (auto batch : batches) {
+    if (printInput) {
+      printRow("Input", batch);
+    }
+
+    proto::StripeFooter sf;
+    std::vector<VectorPtr> writtenBatches;
+
+    // Write map/row
+    auto toWrite = batch;
+    if (testEncoded) {
+      toWrite = wrapInDictionaryRow(toWrite, pool);
+    }
+    writer->write(toWrite, common::Ranges::of(0, toWrite->size()));
+    writer->createIndexEntry();
+    writtenBatches.push_back(toWrite);
+
+    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
+      return *sf.add_encoding();
+    });
+
+    auto validate = [&](bool returnFlatVector = false) {
+      TestStripeStreams streams(
+          context, sf, rowType, &pool, returnFlatVector, structReaderContext);
+      auto pool = memory::memoryManager()->addLeafPool();
+      memory::AllocationPool allocPool(pool.get());
+      StreamLabels labels(allocPool);
+      const auto reader = ColumnReader::build(
+          dataTypeWithId, dataTypeWithId, streams, labels, nullptr, 0);
+      VectorPtr out;
+
+      // Read map/row
+      for (auto& writtenBatch : writtenBatches) {
+        reader->next(writtenBatch->size(), out);
+        ASSERT_EQ(out->size(), writtenBatch->size()) << "Batch size mismatch";
+
+        if (printInput) {
+          printRow("Result", batch);
+        }
+
+        for (int32_t i = 0; i < writtenBatch->size(); ++i) {
+          ASSERT_TRUE(writtenBatch->equalValueAt(out.get(), i, i))
+              << "Row mismatch at index " << i;
+        }
+      }
+
+      // Reader API requires the caller to read the Stripe for number of
+      // values and iterate only until that number.
+      // It does not support hasNext/next protocol.
+      // Use a bigger number like 50, as some values may be bit packed.
+      VELOX_ASSERT_THROW(reader->next(50, out), "");
+    };
+
+    ASSERT_NO_FATAL_FAILURE(validate());
+    ASSERT_NO_FATAL_FAILURE(validate(true));
+
+    context.nextStripe();
+
+    auto valueNodeId = dataTypeWithId->childAt(1)->id();
+    auto streamCount = 0;
+    context.iterateUnSuppressedStreams([&](auto& pair) {
+      if (pair.first.encodingKey().node() == valueNodeId) {
+        ++streamCount;
+      }
+    });
+
+    ASSERT_GT(streamCount, 0) << "Expecting to find at least one value stream";
+
+    writer->reset();
+
+    streamCount = 0;
+    context.iterateUnSuppressedStreams([&](auto& pair) {
+      if (pair.first.encodingKey().node() == valueNodeId) {
+        ++streamCount;
+      }
+    });
+
+    ASSERT_EQ(streamCount, 0)
+        << "Expecting all flat map value streams to be disposed";
+  }
+}
+
+template <typename TVALUE>
+void testMapWriterRowImpl() {
+  auto type = CppToType<Row<TVALUE, TVALUE>>::create();
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = BatchMaker::createVector<TypeKind::ROW>(type, 10, *pool);
+
+  std::vector<VectorPtr> batches{batch, batch};
+
+  testMapWriterRow<TVALUE>(*pool, batches, true, false);
+  testMapWriterRow<TVALUE>(*pool, batches, true, true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterNestedRow) {
+  testMapWriterRowImpl<bool>();
+  testMapWriterRowImpl<Array<int32_t>>();
+  testMapWriterRowImpl<Array<bool>>();
+  testMapWriterRowImpl<Array<StringView>>();
+  testMapWriterRowImpl<Map<int32_t, bool>>();
+  testMapWriterRowImpl<Map<int32_t, int32_t>>();
+  testMapWriterRowImpl<Map<int32_t, StringView>>();
+  testMapWriterRowImpl<Map<int32_t, Array<int32_t>>>();
+  testMapWriterRowImpl<Map<int32_t, Map<int32_t, StringView>>>();
+  testMapWriterRowImpl<Map<int32_t, Row<int32_t, bool, StringView>>>();
+  testMapWriterRowImpl<Row<int32_t, bool, StringView>>();
+}
+
+template <typename TKEY, typename TVALUE, bool useStruct = false>
+void testMapWriter(
+    MemoryPool& pool,
+    const VectorPtr& batch,
+    bool useFlatMap,
+    bool printMaps = true) {
+  std::vector<VectorPtr> batches{batch, batch};
+  testMapWriter<TKEY, TVALUE, useStruct>(
+      pool, batches, useFlatMap, true, false, printMaps);
+  if (useFlatMap) {
+    testMapWriter<TKEY, TVALUE, useStruct>(
+        pool, batches, useFlatMap, false, false, printMaps);
+    testMapWriter<TKEY, TVALUE, useStruct>(
+        pool, batches, useFlatMap, true, true, printMaps);
+  }
+}
+
+template <typename T, bool useStruct = false>
+void testMapWriterNumericKey(bool useFlatMap) {
+  using b = MapBuilder<T, T>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool,
+      {typename b::row{
+           typename b::pair{std::numeric_limits<T>::max(), 3},
+           typename b::pair{2, std::numeric_limits<T>::max()}},
+       typename b::row{
+           typename b::pair{2, 5},
+           typename b::pair{
+               std::numeric_limits<T>::min(), std::numeric_limits<T>::min()}}});
+
+  testMapWriter<T, T, useStruct>(*pool, batch, useFlatMap, true);
+}
+
+// Workaround to avoid issues with two template arguments when wrapped in gtest
+// EXPECT macros.
+template <typename T>
+void testMapWriterNumericKeyUseStruct(bool useFlatMap) {
+  testMapWriterNumericKey<T, true>(useFlatMap);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterFloatKey) {
+  testMapWriterNumericKey<float>(/* useFlatMap */ false);
+
+  EXPECT_THROW(
+      { testMapWriterNumericKey<float>(/* useFlatMap */ true); },
+      exception::LoggedException);
+
+  EXPECT_THROW(
+      {
+        testMapWriterNumericKeyUseStruct<float>(
+            /* useFlatMap */ true);
+      },
+      exception::LoggedException);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterInt64Key) {
+  testMapWriterNumericKey<int64_t>(/* useFlatMap */ false);
+  testMapWriterNumericKey<int64_t>(/* useFlatMap */ true);
+  testMapWriterNumericKeyUseStruct<int64_t>(/* useFlatMap */ true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterDuplicatedInt64Key) {
+  using T = int64_t;
+  using b = MapBuilder<T, T>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool, {typename b::row{typename b::pair{5, 3}, typename b::pair{5, 4}}});
+
+  EXPECT_THAT(
+      ([&]() { testMapWriter<T, T>(*pool, batch, /* useFlatMap */ true); }),
+      Throws<
+          facebook::velox::dwio::common::exception::LoggedException>(Property(
+          &facebook::velox::dwio::common::exception::LoggedException::message,
+          HasSubstr("Duplicated key in map: 5"))));
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterInt32Key) {
+  testMapWriterNumericKey<int32_t>(/* useFlatMap */ false);
+  testMapWriterNumericKey<int32_t>(/* useFlatMap */ true);
+  testMapWriterNumericKeyUseStruct<int32_t>(/* useFlatMap */ true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterInt16Key) {
+  testMapWriterNumericKey<int16_t>(/* useFlatMap */ false);
+  testMapWriterNumericKey<int16_t>(/* useFlatMap */ true);
+  testMapWriterNumericKeyUseStruct<int16_t>(/* useFlatMap */ true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterInt8Key) {
+  testMapWriterNumericKey<int8_t>(/* useFlatMap */ false);
+  testMapWriterNumericKey<int8_t>(/* useFlatMap */ true);
+  testMapWriterNumericKeyUseStruct<int8_t>(/* useFlatMap */ true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterStringKey) {
+  using keyType = StringView;
+  using valueType = StringView;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool_,
+      {b::row{b::pair{"1", "3"}, b::pair{"2", "2"}},
+       b::row{b::pair{"2", "5"}, b::pair{"3", "8"}}});
+
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ true);
+  testMapWriter<keyType, valueType, /* useStruct */ true>(
+      *pool_, batch, /* useFlatMap */ true, true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterDuplicatedStringKey) {
+  using keyType = StringView;
+  using valueType = StringView;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool_,
+      {b::row{b::pair{"2", "5"}, b::pair{"2", "8"}}}); // Duplicated key: 2
+
+  EXPECT_THAT(
+      ([&]() {
+        testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ true);
+      }),
+      Throws<
+          facebook::velox::dwio::common::exception::LoggedException>(Property(
+          &facebook::velox::dwio::common::exception::LoggedException::message,
+          HasSubstr("Duplicated key in map: 2"))));
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterDifferentNumericKeyValue) {
+  using keyType = float;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool_,
+      {b::row{b::pair{1, 3}, b::pair{2, 2}},
+       b::row{b::pair{2, 5}, b::pair{3, 8}}});
+
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterDifferentKeyValue) {
+  using keyType = float;
+  using valueType = StringView;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool_,
+      {b::row{b::pair{1, "3"}, b::pair{2, "2"}},
+       b::row{b::pair{2, "5"}, b::pair{3, "8"}}});
+
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterMixedBatchTypeHandling) {
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  using valueType2 = StringView;
+  using b2 = MapBuilder<keyType, valueType2>;
+
+  auto batch1 = b::create(
+      *pool_,
+      {b::row{b::pair{1, 3}, b::pair{2, 2}},
+       b::row{b::pair{5, 5}, b::pair{3, 4}, b::pair{2, 5}}});
+
+  auto batch2 = b2::create(
+      *pool_,
+      {b2::row{b2::pair{8, "3"}, b2::pair{6, "2"}},
+       b2::row{b2::pair{20, "5"}, b2::pair{2, "4"}, b2::pair{63, "5"}}});
+
+  std::vector<VectorPtr> batches{batch1, batch2};
+  // Test type cast assertion in the direct encoding case.
+  // TODO(T91654228): Check and throw for non-homogeneous batch types
+  // when dictionary encoding is enabled.
+  EXPECT_THROW(
+      (testMapWriter<keyType, valueType>(
+          *pool_,
+          batches,
+          /* useFlatMap */ true,
+          true,
+          false)),
+      exception::LoggedException);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterBinaryKey) {
+  using keyType = StringView;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool_,
+      {b::row{b::pair{"1", 3}, b::pair{"2", 2}},
+       b::row{b::pair{"2", 5}, b::pair{"3", 8}}});
+
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ true);
+  testMapWriter<keyType, valueType, /* useStruct */ true>(
+      *pool_, batch, /* useFlatMap */ true, true);
+}
+
+template <typename keyType, typename valueType>
+void testMapWriterImpl() {
+  auto type = CppToType<Map<keyType, valueType>>::create();
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = BatchMaker::createVector<TypeKind::MAP>(type, 100, *pool);
+
+  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
+  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterNestedMap) {
+  testMapWriterImpl<int32_t, bool>();
+  testMapWriterImpl<int32_t, Array<int32_t>>();
+  testMapWriterImpl<int32_t, Array<bool>>();
+  testMapWriterImpl<int32_t, Array<StringView>>();
+  testMapWriterImpl<int32_t, Map<int32_t, bool>>();
+  testMapWriterImpl<int32_t, Map<int32_t, int32_t>>();
+  testMapWriterImpl<int32_t, Map<int32_t, StringView>>();
+  testMapWriterImpl<int32_t, Map<int32_t, Array<int32_t>>>();
+  testMapWriterImpl<int32_t, Map<int32_t, Map<int32_t, StringView>>>();
+  testMapWriterImpl<int32_t, Map<int32_t, Row<int32_t, bool, StringView>>>();
+  testMapWriterImpl<int32_t, Row<int32_t, bool, StringView>>();
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterDifferentStripeBatches) {
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch1 = b::create(
+      *pool_,
+      {b::row{b::pair{1, 3}, b::pair{2, 2}},
+       b::row{b::pair{5, 5}, b::pair{3, 4}, b::pair{2, 5}}});
+
+  auto batch2 = b::create(
+      *pool_,
+      {b::row{b::pair{8, 3}, b::pair{6, 2}},
+       b::row{b::pair{20, 5}, b::pair{2, 4}, b::pair{63, 5}}});
+
+  std::vector<VectorPtr> batches{batch1, batch2};
+
+  testMapWriter<keyType, valueType>(
+      *pool_,
+      batches,
+      /* useFlatMap */ false,
+      false,
+      false);
+  testMapWriter<keyType, valueType>(
+      *pool_,
+      batches,
+      /* useFlatMap */ true,
+      false,
+      false);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterNullValues) {
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool_,
+      {b::row{b::pair{1, std::nullopt}, b::pair{2, 2}},
+       b::row{b::pair{5, 5}, b::pair{3, std::nullopt}, b::pair{2, 5}}});
+
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterNullRows) {
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool_,
+      {std::nullopt,
+       b::row{b::pair{1, 3}, b::pair{2, 2}},
+       std::nullopt,
+       b::row{b::pair{2, 5}},
+       std::nullopt});
+
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterDuplicateKeys) {
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto batch = b::create(
+      *pool_,
+      {
+          b::row{b::pair{1, 3}, b::pair{1, 2}},
+      });
+
+  // Default map writer doesn't throw on duplicate keys
+  // TODO: Is there a way to easily detect duplicate keys in MapColumnWriter?
+  testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
+  EXPECT_THROW(
+      (testMapWriter<keyType, valueType>(*pool_, batch, true)),
+      exception::LoggedException);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterBigBatch) {
+  using keyType = int32_t;
+  using valueType = float;
+  using b = MapBuilder<keyType, valueType>;
+
+  const auto size = 1000;
+  const auto maxDictionarySize = 50;
+  const auto nullEvery = 10;
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  b::rows rows;
+  for (int32_t i = 0; i < size; ++i) {
+    if ((i % nullEvery) == 0) {
+      rows.push_back(std::nullopt);
+    }
+    const auto rowCount = Random::rand32(maxDictionarySize) + 1;
+    const auto randomStart = Random::rand32(10);
+    b::row row;
+    for (int32_t j = 0; j < rowCount; j++) {
+      row.push_back(b::pair{randomStart + j, Random::randDouble(0, 50)});
+    }
+
+    rows.push_back(row);
+  }
+
+  auto batch = b::create(*pool_, rows);
+  testMapWriter<keyType, valueType>(
+      *pool_,
+      batch,
+      /* useFlatMap */ false);
+  testMapWriter<keyType, valueType>(
+      *pool_,
+      batch,
+      /* useFlatMap */ true);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterUnalignedKeyValueCount) {
+  VectorMaker maker(pool_.get());
+  auto keys = maker.flatVector<int64_t>(11, folly::identity);
+  auto values = maker.flatVector<int64_t>(12, folly::identity);
+  auto offsets = allocateIndices(3, pool_.get());
+  auto sizes = allocateIndices(3, pool_.get());
+
+  for (int i = 0; i < 3; ++i) {
+    offsets->asMutable<vector_size_t>()[i] = 3 * i;
+    sizes->asMutable<vector_size_t>()[i] = 3;
+  }
+  auto batch = std::make_shared<MapVector>(
+      pool_.get(),
+      MAP(BIGINT(), BIGINT()),
+      nullptr,
+      3,
+      offsets,
+      sizes,
+      keys,
+      values);
+  testMapWriter<int64_t, int64_t>(*pool_, batch, false);
+  testMapWriter<int64_t, int64_t>(*pool_, batch, true);
+
+  for (int i = 0; i < 3; ++i) {
+    offsets->asMutable<vector_size_t>()[i] = 4 * i;
+    sizes->asMutable<vector_size_t>()[i] = 4;
+  }
+  batch = std::make_shared<MapVector>(
+      pool_.get(),
+      MAP(BIGINT(), BIGINT()),
+      nullptr,
+      3,
+      offsets,
+      sizes,
+      keys,
+      values);
+  ASSERT_THROW(
+      (testMapWriter<int64_t, int64_t>(*pool_, batch, false)),
+      exception::LoggedException);
+  ASSERT_THROW(
+      (testMapWriter<int64_t, int64_t>(*pool_, batch, true)),
+      exception::LoggedException);
+}
+
+TEST_F(ColumnWriterTest, TestStructKeysConfigSerializationDeserialization) {
+  const std::vector<std::vector<std::string>> columns{
+      {"1.45", "hi, you;", "29102819", "1e-4"},
+      {"291", "world"},
+      {},
+      {"one", ", more", "\"two'three$"}};
+  const auto config = std::make_shared<Config>();
+  config->set<decltype(columns)>(Config::MAP_FLAT_COLS_STRUCT_KEYS, columns);
+  EXPECT_EQ(config->get(Config::MAP_FLAT_COLS_STRUCT_KEYS), columns);
+}
+
+std::unique_ptr<DwrfReader> getDwrfReader(
+    MemoryPool& rootPool,
+    MemoryPool& leafPool,
+    const std::shared_ptr<const RowType> type,
+    const VectorPtr& batch,
+    bool useFlatMap) {
+  auto config = std::make_shared<Config>();
+  if (useFlatMap) {
+    config->set(Config::FLATTEN_MAP, true);
+    config->set(Config::MAP_FLAT_COLS, {0});
+  }
+
+  auto sink = std::make_unique<MemorySink>(
+      2 * 1024 * 1024, dwio::common::FileSink::Options{.pool = &leafPool});
+  auto sinkPtr = sink.get();
+
+  dwrf::WriterOptions options;
+  options.config = config;
+  options.schema = type;
+  options.flushPolicyFactory = [&]() {
+    return std::make_unique<LambdaFlushPolicy>([]() {
+      return true; // Flushes every batch.
+    });
+  };
+  options.memoryPool = &rootPool;
+  dwrf::Writer writer{std::move(sink), options};
+  writer.write(batch);
+  writer.close();
+
+  std::string data(sinkPtr->data(), sinkPtr->size());
+  dwio::common::ReaderOptions readerOpts{&leafPool};
+  return std::make_unique<DwrfReader>(
+      readerOpts,
+      std::make_unique<BufferedInput>(
+          std::make_shared<InMemoryReadFile>(std::move(data)),
+          readerOpts.memoryPool()));
+}
+
+void removeSizeFromStats(std::string& input) {
+  // FlatMap and Map, Serializes the data differently. Size is the sum of
+  // all Serialized Stream and hence they don't match. Remove the Size
+  // and value from the String used for comparison.
+  auto firstPos = input.find(" Size:");
+  ASSERT_NE(firstPos, std::string::npos) << " Size not found in " << input;
+  auto endPos = input.find(",", firstPos);
+  ASSERT_NE(endPos, std::string::npos) << " , not found after Size " << input;
+  input.erase(firstPos, (endPos + 1) - firstPos);
+}
+
+void testMapWriterStats(const std::shared_ptr<const RowType> type) {
+  auto rootPool = memory::memoryManager()->addRootPool();
+  auto leafPool = memory::memoryManager()->addLeafPool();
+  auto batch = BatchMaker::createBatch(type, 10, *leafPool);
+  auto mapReader = getDwrfReader(*rootPool, *leafPool, type, batch, false);
+  auto flatMapReader = getDwrfReader(*rootPool, *leafPool, type, batch, true);
+  ASSERT_EQ(
+      mapReader->getFooter().statisticsSize(),
+      flatMapReader->getFooter().statisticsSize());
+
+  for (int32_t i = 0; i < mapReader->getFooter().statisticsSize(); ++i) {
+    LOG(INFO) << "Stats " << i
+              << "     map: " << mapReader->columnStatistics(i)->toString();
+    LOG(INFO) << "Stats " << i
+              << " flatmap: " << flatMapReader->columnStatistics(i)->toString();
+    auto mapReaderStatString = mapReader->columnStatistics(i)->toString();
+    auto flatMapReaderStatString =
+        flatMapReader->columnStatistics(i)->toString();
+
+    removeSizeFromStats(mapReaderStatString);
+    removeSizeFromStats(flatMapReaderStatString);
+    ASSERT_EQ(mapReaderStatString, flatMapReaderStatString);
+  }
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterCompareStatsBinaryKey) {
+  using keyType = Varbinary;
+  // We create a complex map with complex value structure to test that value
+  // aggregation work well in flat maps
+  const auto type = CppToType<Row<
+      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
+
+  testMapWriterStats(type);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterCompareStatsStringKey) {
+  using keyType = std::string;
+  // We create a complex map with complex value structure to test that value
+  // aggregation work well in flat maps
+  const auto type = CppToType<Row<
+      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
+
+  testMapWriterStats(type);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterCompareStatsInt8Key) {
+  using keyType = int8_t;
+
+  // We create a complex map with complex value structure to test that value
+  // aggregation work well in flat maps
+  const auto type = CppToType<Row<
+      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
+
+  testMapWriterStats(type);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterCompareStatsInt16Key) {
+  using keyType = int16_t;
+
+  // We create a complex map with complex value structure to test that value
+  // aggregation work well in flat maps
+  const auto type = CppToType<Row<
+      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
+
+  testMapWriterStats(type);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterCompareStatsInt32Key) {
+  using keyType = int32_t;
+
+  // We create a complex map with complex value structure to test that value
+  // aggregation work well in flat maps
+  const auto type = CppToType<Row<
+      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
+
+  testMapWriterStats(type);
+}
+
+TEST_F(ColumnWriterTest, TestMapWriterCompareStatsInt64Key) {
+  using keyType = int64_t;
+
+  // We create a complex map with complex value structure to test that value
+  // aggregation work well in flat maps
+  const auto type = CppToType<Row<
+      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
+
+  testMapWriterStats(type);
+}
+
+template <typename type>
+void testFractionalWrite(const TypePtr& t) {
+  std::vector<std::optional<type>> data;
+  generateSampleData(data);
+  testDataTypeWriter(t, data);
+}
+
+TEST_F(ColumnWriterTest, TestFloatWriter) {
+  testFractionalWrite<float>(REAL());
+}
+
+TEST_F(ColumnWriterTest, TestDoubleWriter) {
+  testFractionalWrite<double>(DOUBLE());
+}
+
+template <typename type>
+void testFractionalInfinityWrite(const TypePtr& t) {
+  std::vector<std::optional<type>> data;
+  type infinity = std::numeric_limits<type>::infinity();
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    data.emplace_back(infinity);
+  }
+  testDataTypeWriter(t, data);
+}
+
+TEST_F(ColumnWriterTest, TestFloatInfinityWriter) {
+  testFractionalInfinityWrite<float>(REAL());
+}
+
+TEST_F(ColumnWriterTest, TestDoubleInfinityWriter) {
+  testFractionalInfinityWrite<double>(DOUBLE());
+}
+
+template <typename type>
+void testFractionalNegativeInfinityWrite(const TypePtr& t) {
+  std::vector<std::optional<type>> data;
+  type negativeInfinity = -std::numeric_limits<type>::infinity();
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    data.emplace_back(negativeInfinity);
+  }
+  testDataTypeWriter(t, data);
+}
+
+TEST_F(ColumnWriterTest, TestFloatNegativeInfinityWriter) {
+  testFractionalNegativeInfinityWrite<float>(REAL());
+}
+
+TEST_F(ColumnWriterTest, TestDoubleNegativeInfinityWriter) {
+  testFractionalNegativeInfinityWrite<double>(DOUBLE());
+}
+
+template <typename type>
+void testFractionalNaNWrite(const TypePtr& t) {
+  std::vector<std::optional<type>> data;
+  type nan = -std::numeric_limits<type>::quiet_NaN();
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    data.emplace_back(nan);
+  }
+  testDataTypeWriter(t, data);
+}
+
+TEST_F(ColumnWriterTest, TestFloatNanWriter) {
+  testFractionalNaNWrite<float>(REAL());
+}
+
+TEST_F(ColumnWriterTest, TestDoubleNanWriter) {
+  testFractionalNaNWrite<double>(DOUBLE());
+}
+
+template <typename type>
+void testFractionalNullWrite(const TypePtr& t) {
+  std::vector<std::optional<type>> data;
+  for (auto i = 0; i < ITERATIONS; ++i) {
+    data.emplace_back();
+  }
+  testDataTypeWriter(t, data);
+}
+
+TEST_F(ColumnWriterTest, TestFloatAllNullWriter) {
+  testFractionalNullWrite<float>(REAL());
+}
+
+TEST_F(ColumnWriterTest, TestDoubleAllNullWriter) {
+  testFractionalNullWrite<double>(DOUBLE());
+}
+
+template <typename type>
+void testFractionalMixedWrite(const TypePtr& t) {
+  std::vector<std::optional<type>> data;
+  type nan = -std::numeric_limits<type>::quiet_NaN();
+  type negativeInfinity = -std::numeric_limits<type>::infinity();
+  type infinity = std::numeric_limits<type>::infinity();
+  type max = std::numeric_limits<type>::max();
+  type min = std::numeric_limits<type>::lowest();
+  for (auto i = 0; i < 10'000; ++i) {
+    data.emplace_back(nan);
+    data.emplace_back();
+    data.emplace_back(negativeInfinity);
+    data.emplace_back(infinity);
+    data.emplace_back(i);
+    data.emplace_back(min);
+    data.emplace_back(max);
+  }
+  testDataTypeWriter(t, data);
+}
+
+TEST_F(ColumnWriterTest, TestFloatMixedWriter) {
+  testFractionalMixedWrite<float>(REAL());
+}
+
+TEST_F(ColumnWriterTest, TestDoubleMixedWriter) {
+  testFractionalMixedWrite<double>(DOUBLE());
+}
+
+// This generation method is skewed due to double precision. However, this
+// does not really matter - it would generate enough distinct values across
+// the range for reasonable sizes. Tests for sizes bigger than the positive
+// numeric range don't require a precise behavior for dinstinct value
+// generation anyway since it overflows the dictionary.
+int64_t generateRangeWithCustomLimits(
+    size_t i,
+    size_t size,
+    int64_t lowest,
+    int64_t max) {
+  // Explicitly include the numeric limits.
+  if (i == 0) {
+    return lowest;
+  }
+  if (i == size - 1) {
+    return max;
+  }
+  auto interval = -2 * folly::to<double>(lowest) / size;
+  // Generate the range such that we have similar amounts of values generated
+  // for each exponent.
+  double center = size % 2 ? -0.5 : interval / 2 - 0.5;
+  double value = center + (i - size / 2) * interval;
+  // Return a guard-railed value with the numeric limits.
+  // NOTE: There can be a more compact way to write this if we cast i and size
+  // to signed types, but it's not worth the effort enforcing the assumptions.
+  if (i < size / 2) {
+    auto distance = (size / 2 - i) * interval;
+    return std::max(center - distance, folly::to<double>(lowest));
+  } else {
+    auto distance = (i - size / 2) * interval;
+    return std::min(center + distance + 1, -folly::to<double>(lowest)) - 1;
+  }
+}
+
+template <typename Integer>
+Integer generateRangeWithLimits(size_t i, size_t size) {
+  auto lowest = std::numeric_limits<Integer>::lowest();
+  auto max = std::numeric_limits<Integer>::max();
+  return generateRangeWithCustomLimits(i, size, lowest, max);
+}
+
+int64_t generateSomewhatRandomPositiveData(
+    size_t i,
+    size_t size,
+    int64_t /* unused */,
+    int64_t /* unused */) {
+  return size % (i + 1);
+}
+
+int64_t generateSomewhatRandomData(
+    size_t i,
+    size_t size,
+    int64_t /* unused */,
+    int64_t /* unused */) {
+  int64_t val = size % (i + 1);
+  return i % 2 ? val : -val;
+}
+
+template <typename Integer>
+Integer generateSomewhatRandomDataTyped(size_t i, size_t size) {
+  int64_t val = size % (i + 1);
+  return i % 2 ? val : -val;
+}
+
+// This really is a placeholder method. In most practical cases, the PRESENT
+// stream would just be empty if there are no nulls in the stripe.
+bool noNulls(size_t /* unused */, size_t /* unused */) {
+  return true;
+}
+
+bool noNullsWithStride(
+    size_t /* unused */,
+    size_t /* unused */,
+    size_t /* unused */) {
+  return true;
+}
+
+bool allNulls(size_t /* unused */, size_t /* unused */) {
+  return false;
+}
+
+bool allNullsWithStride(
+    size_t /* unused */,
+    size_t /* unused */,
+    size_t /* unused */) {
+  return false;
+}
+
+bool someNulls(size_t i, size_t size) {
+  return (size % (i + 1)) % 2;
+}
+
+bool someNullsWithStride(size_t /* unused */, size_t i, size_t size) {
+  return (size % (i + 1)) % 2;
+}
+
+std::function<void(ColumnWriter&, size_t, size_t)> checkAbandonDict(
+    const std::function<bool(size_t, size_t)>& callTryAbandonDict,
+    bool force,
+    const std::function<bool(size_t, size_t)>& abandonDictSuccess) {
+  return [callTryAbandonDict, force, abandonDictSuccess](
+             ColumnWriter& columnWriter, size_t stripeCount, size_t repCount) {
+    if (callTryAbandonDict(stripeCount, repCount)) {
+      EXPECT_EQ(
+          abandonDictSuccess(stripeCount, repCount),
+          columnWriter.tryAbandonDictionaries(force));
+    }
+  };
+}
+
+void noPostProcessing(
+    ColumnWriter& /* unused */,
+    size_t /* unused */,
+    size_t /* unused */) {}
+
+bool neverAbandonDict(size_t /* unused */, size_t /* unused */) {
+  return false;
+}
+
+std::function<bool(size_t, size_t)> abandonNthWriteForStripe(
+    size_t stripeIndex,
+    size_t n) {
+  return [stripeIndex, n](size_t stripeCount, size_t repCount) {
+    return stripeCount == stripeIndex && repCount == n;
+  };
+}
+
+bool abandonEveryWrite(size_t /* unused */, size_t /* unused */) {
+  return true;
+}
+
+std::function<bool(size_t, size_t)> successAtNthWriteForStripe(
+    size_t stripeIndex,
+    size_t n) {
+  return [stripeIndex, n](size_t stripeCount, size_t repCount) {
+    return stripeCount == stripeIndex && repCount == n;
+  };
+}
+
+bool noSuccess(size_t /* unused */, size_t /* unused */) {
+  return false;
+}
+
+// A type erasure runner for the different test types.
+struct TestRunner {
+  template <typename T>
+  /* implicit */ TestRunner(const T& test)
+      : test_{std::make_shared<Test<T>>(test)} {}
+
+  void runTest() const {
+    test_->runTest();
+  }
+
+  struct TestInterface {
+    virtual ~TestInterface() = default;
+    virtual void runTest() const = 0;
+  };
+
+  template <typename T>
+  struct Test : public TestInterface {
+    explicit Test(const T& test) : test_{test} {}
+    void runTest() const override {
+      test_.runTest();
+    }
+
+   private:
+    T test_;
+  };
+
+ private:
+  std::shared_ptr<const TestInterface> test_;
+};
+
+template <typename Integer>
+struct IntegerColumnWriterTypedTestCase {
+  const size_t size;
+  const bool writeDirect;
+  const float dictionaryWriteThreshold;
+  const size_t finalDictionarySize;
+  const std::function<Integer(size_t, size_t)> genData;
+  const bool hasNulls;
+  const std::function<bool(size_t, size_t)> genNulls;
+  const std::function<void(ColumnWriter&, size_t, size_t)> postProcess;
+  const size_t repetitionCount;
+  const size_t flushCount;
+
+  IntegerColumnWriterTypedTestCase(
+      size_t size,
+      bool writeDirect,
+      float dictionaryWriteThreshold,
+      size_t finalDictionarySize,
+      const std::function<Integer(size_t, size_t)>& genData,
+      bool hasNulls,
+      const std::function<bool(size_t, size_t)>& genNulls,
+      const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : size{size},
+        writeDirect{writeDirect},
+        dictionaryWriteThreshold{dictionaryWriteThreshold},
+        finalDictionarySize{finalDictionarySize},
+        genData{genData},
+        hasNulls{hasNulls},
+        genNulls{genNulls},
+        postProcess{postProcess},
+        repetitionCount{repetitionCount},
+        flushCount{flushCount} {}
+
+  virtual ~IntegerColumnWriterTypedTestCase() = default;
+
+  void runTest() const {
+    auto type = CppToType<Integer>::create();
+    auto typeWithId = TypeWithId::create(type, 1);
+    auto pool = memory::memoryManager()->addLeafPool();
+
+    // Prepare input
+    BufferPtr nulls = allocateNulls(size, pool.get());
+    auto* nullsPtr = nulls->asMutable<uint64_t>();
+    size_t nullCount = 0;
+
+    BufferPtr values = AlignedBuffer::allocate<Integer>(size, pool.get());
+    auto* valuesPtr = values->asMutable<Integer>();
+
+    for (size_t i = 0; i != size; ++i) {
+      bool isPresent = genNulls(i, size);
+      if (hasNulls && !isPresent) {
+        bits::setNull(nullsPtr, i);
+        valuesPtr[i] = 0;
+        nullCount++;
+      } else {
+        bits::clearNull(nullsPtr, i);
+        valuesPtr[i] = genData(i, size);
+      }
+    }
+
+    // Randomly shuffle the input, based on a seed to verify more
+    // combinations.
+    uint32_t seed = Random::rand32();
+
+    std::mt19937 gen;
+    gen.seed(seed);
+    for (size_t i = 0; i != size; ++i) {
+      size_t j = Random::rand32(i, size, gen);
+      if (i != j) {
+        std::swap(valuesPtr[i], valuesPtr[j]);
+        auto tmp = bits::isBitNull(nullsPtr, i);
+        bits::setNull(nullsPtr, i, bits::isBitNull(nullsPtr, j));
+        bits::setNull(nullsPtr, j, tmp);
+      }
+    }
+
+    auto batch = std::make_shared<FlatVector<Integer>>(
+        pool.get(),
+        CppToType<Integer>::create(),
+        nulls,
+        size,
+        values,
+        std::vector<BufferPtr>());
+    batch->setNullCount(nullCount);
+
+    // Set up writer.
+    auto config = std::make_shared<Config>();
+    config->set(
+        Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD,
+        dictionaryWriteThreshold);
+    WriterContext context{config, memory::memoryManager()->addRootPool()};
+    context.initBuffer();
+    // Register root node.
+    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
+
+    for (size_t i = 0; i != flushCount; ++i) {
+      proto::StripeFooter stripeFooter;
+      for (size_t j = 0; j != repetitionCount; ++j) {
+        columnWriter->write(batch, common::Ranges::of(0, batch->size()));
+        postProcess(*columnWriter, i, j);
+        columnWriter->createIndexEntry();
+      }
+      // We only flush once per stripe.
+      columnWriter->flush(
+          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
+            return *stripeFooter.add_encoding();
+          });
+
+      // Read and verify.
+      const size_t nodeId = 1;
+      auto rowType = ROW({{"integral_column", type}});
+      TestStripeStreams streams(context, stripeFooter, rowType, pool.get());
+      EncodingKey key{nodeId};
+      const auto& encoding = streams.getEncoding(key);
+      if (writeDirect) {
+        ASSERT_EQ(
+            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DIRECT,
+            encoding.kind());
+      } else {
+        ASSERT_EQ(
+            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY,
+            encoding.kind());
+        ASSERT_EQ(finalDictionarySize, encoding.dictionarysize());
+      }
+
+      auto reqType = TypeWithId::create(rowType)->childAt(0);
+      memory::AllocationPool allocPool(pool.get());
+      StreamLabels labels(allocPool);
+      auto columnReader =
+          ColumnReader::build(reqType, reqType, streams, labels, nullptr, 0);
+
+      for (size_t j = 0; j != repetitionCount; ++j) {
+        // TODO Make reuse work
+        VectorPtr resultBatch;
+        columnReader->next(size, resultBatch);
+        auto resultIv =
+            std::dynamic_pointer_cast<FlatVector<Integer>>(resultBatch);
+        std::vector<Integer> resultVec{
+            resultIv->rawValues(), resultIv->rawValues() + resultIv->size()};
+        ASSERT_EQ(batch->size(), resultBatch->size());
+        ASSERT_EQ(batch->getNullCount(), resultBatch->getNullCount());
+        if (!batch->getNullCount().has_value() ||
+            batch->getNullCount().value() > 0) {
+          // Normalizing the null values so that we can leverage gtest
+          // matchers later for better failure dumps.
+          for (size_t k = 0; k != batch->size(); ++k) {
+            if (batch->isNullAt(k)) {
+              resultVec[k] = 0;
+            }
+          }
+          for (size_t k = 0; k < batch->size(); k++) {
+            EXPECT_EQ(batch->isNullAt(k), resultBatch->isNullAt(k));
+          }
+        }
+        EXPECT_THAT(
+            resultVec,
+            ElementsAreArray(batch->rawValues(), resultBatch->size()));
+      }
+      context.nextStripe();
+      columnWriter->reset();
+    }
+  }
+};
+
+template <typename Integer>
+struct TypedDictionaryEncodingTestCase
+    : public IntegerColumnWriterTypedTestCase<Integer> {
+  TypedDictionaryEncodingTestCase(
+      size_t size,
+      float dictionaryWriteThreshold,
+      size_t finalDictionarySize,
+      const std::function<Integer(size_t, size_t)>& genData,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : IntegerColumnWriterTypedTestCase<Integer>{
+            size,
+            false,
+            dictionaryWriteThreshold,
+            finalDictionarySize,
+            genData,
+            false,
+            noNulls,
+            noPostProcessing,
+            repetitionCount,
+            flushCount} {}
+};
+
+// Even as the dictionary size threshold allows, we might not end up writing
+// with dictionary encoding.
+template <typename Integer>
+struct TypedDirectEncodingTestCase
+    : public IntegerColumnWriterTypedTestCase<Integer> {
+  TypedDirectEncodingTestCase(
+      size_t size,
+      float dictionaryWriteThreshold,
+      const std::function<Integer(size_t, size_t)>& genData,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : IntegerColumnWriterTypedTestCase<Integer>{
+            size,
+            true,
+            dictionaryWriteThreshold,
+            0,
+            genData,
+            false,
+            noNulls,
+            noPostProcessing,
+            repetitionCount,
+            flushCount} {}
+};
+
+struct IntegerColumnWriterUniversalTestCase {
+  IntegerColumnWriterTypedTestCase<int16_t> int16tTestCase;
+  IntegerColumnWriterTypedTestCase<int32_t> int32tTestCase;
+  IntegerColumnWriterTypedTestCase<int64_t> int64tTestCase;
+
+  IntegerColumnWriterUniversalTestCase(
+      size_t size,
+      bool writeDirect,
+      float dictionaryWriteThreshold,
+      size_t finalDictionarySize,
+      const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+      bool hasNulls,
+      const std::function<bool(size_t, size_t)>& genNulls,
+      const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : int16tTestCase{size, writeDirect, dictionaryWriteThreshold, finalDictionarySize, coerceGenData<int16_t>(genData), hasNulls, genNulls, postProcess, repetitionCount, flushCount},
+        int32tTestCase{
+            size,
+            writeDirect,
+            dictionaryWriteThreshold,
+            finalDictionarySize,
+            coerceGenData<int32_t>(genData),
+            hasNulls,
+            genNulls,
+            postProcess,
+            repetitionCount,
+            flushCount},
+        int64tTestCase{
+            size,
+            writeDirect,
+            dictionaryWriteThreshold,
+            finalDictionarySize,
+            coerceGenData<int64_t>(genData),
+            hasNulls,
+            genNulls,
+            postProcess,
+            repetitionCount,
+            flushCount} {}
+
+  virtual ~IntegerColumnWriterUniversalTestCase() = default;
+
+  template <typename Integer>
+  std::function<Integer(size_t, size_t)> coerceGenData(
+      const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData) {
+    return [=](size_t i, size_t size) -> Integer {
+      return genData(
+          i,
+          size,
+          std::numeric_limits<Integer>::lowest(),
+          std::numeric_limits<Integer>::max());
+    };
+  }
+
+  void runTest() const {
+    int16tTestCase.runTest();
+    int32tTestCase.runTest();
+    int64tTestCase.runTest();
+  }
+};
+
+// Test cases that would end up writing with dictionary encoding
+struct IntegerColumnWriterDictionaryEncodingUniversalTestCase
+    : public IntegerColumnWriterUniversalTestCase {
+  IntegerColumnWriterDictionaryEncodingUniversalTestCase(
+      size_t size,
+      float dictionaryWriteThreshold,
+      size_t finalDictionarySize,
+      const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+      bool hasNulls,
+      const std::function<bool(size_t, size_t)>& genNulls,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : IntegerColumnWriterUniversalTestCase{
+            size,
+            false,
+            dictionaryWriteThreshold,
+            finalDictionarySize,
+            genData,
+            hasNulls,
+            genNulls,
+            noPostProcessing,
+            repetitionCount,
+            flushCount} {}
+};
+
+// Universal test cases that would end up writing with direct encoding.
+struct IntegerColumnWriterDirectEncodingUniversalTestCase
+    : public IntegerColumnWriterUniversalTestCase {
+  IntegerColumnWriterDirectEncodingUniversalTestCase(
+      size_t size,
+      float dictionaryWriteThreshold,
+      const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+      bool hasNulls,
+      const std::function<bool(size_t, size_t)>& genNulls,
+      const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : IntegerColumnWriterUniversalTestCase{
+            size,
+            true,
+            dictionaryWriteThreshold,
+            0,
+            genData,
+            hasNulls,
+            genNulls,
+            postProcess,
+            repetitionCount,
+            flushCount} {}
+};
+
+TEST_F(ColumnWriterTest, IntegerTypeDictionaryEncodingWrites) {
+  struct TestCase
+      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
+    TestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
+              size,
+              1.0,
+              finalDictionarySize,
+              genData,
+              false,
+              noNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      // No values in dictionary.
+      TestCase{1000, 0, generateRangeWithCustomLimits},
+      // Mixture of values in dictionary vs not.
+      TestCase{1000, 201, generateSomewhatRandomData},
+      // Test repeated writes. All values are in dictionary.
+      TestCase{1000, 617, generateSomewhatRandomData, 20},
+      // Test repeated writes and flushes with mixture of values in
+      // dictionary.
+      // Tests independence of dictionary encoding writes across stripes. (In
+      // other words, whether the dictionary is cleared across stripes.)
+      TestCase{1000, 201, generateSomewhatRandomData, 1, 10},
+      // Test repeated writes and flushes. All values are in dictionary.
+      TestCase{1000, 617, generateSomewhatRandomData, 2, 10},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerTypeDictionaryEncodingWritesWithNulls) {
+  struct DictionaryEncodingTestCase
+      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<bool(size_t, size_t)>& genNulls,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
+              size,
+              1.0,
+              finalDictionarySize,
+              genData,
+              true,
+              genNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  // Even as the dictionary size threshold allows, we might not end up writing
+  // with dictionary encoding.
+  struct DirectEncodingTestCase
+      : public IntegerColumnWriterDirectEncodingUniversalTestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<bool(size_t, size_t)>& genNulls,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDirectEncodingUniversalTestCase{
+              size,
+              1.0,
+              genData,
+              true,
+              genNulls,
+              noPostProcessing,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      // When all values are null, we don't try to write dictionary at all.
+      DirectEncodingTestCase{1000, generateRangeWithCustomLimits, allNulls},
+      // No values in dictionary.
+      DictionaryEncodingTestCase{
+          1000, 0, generateRangeWithCustomLimits, someNulls},
+      // Mixture of values in dictionary vs not.
+      DictionaryEncodingTestCase{
+          1000, 62, generateSomewhatRandomData, someNulls},
+      // Test repeated writes. All values are in dictionary.
+      DictionaryEncodingTestCase{
+          1000, 250, generateSomewhatRandomData, someNulls, 20},
+      // Test repeated writes and flushes with mixture of values in
+      // dictionary.
+      // Tests independence of dictionary encoding writes across stripes. (In
+      // other words, whether the dictionary is cleared across stripes.)
+      DictionaryEncodingTestCase{
+          1000, 62, generateSomewhatRandomData, someNulls, 1, 10},
+      // Test repeated writes and flushes. All values are in dictionary.
+      DictionaryEncodingTestCase{
+          1000, 250, generateSomewhatRandomData, someNulls, 2, 10},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerTypeDictionaryEncodingHugeWrites) {
+  struct TestCase
+      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
+    TestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
+              size,
+              1.0,
+              finalDictionarySize,
+              genData,
+              false,
+              noNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      // We hit each distinct value in int16_t more than once.
+      TypedDictionaryEncodingTestCase<int16_t>{
+          1000000,
+          1.0,
+          -2 * std::numeric_limits<int16_t>::lowest(),
+          generateRangeWithLimits<int16_t>},
+      TypedDictionaryEncodingTestCase<int32_t>{
+          1000000, 1.0, 0, generateRangeWithLimits<int32_t>},
+      TypedDictionaryEncodingTestCase<int64_t>{
+          1000000, 1.0, 0, generateRangeWithLimits<int64_t>},
+      // Mixture of values in dictionary vs not. Out of range for int16_t.
+      TypedDictionaryEncodingTestCase<int32_t>{
+          1000000, 1.0, 201668, generateSomewhatRandomDataTyped<int32_t>},
+      TypedDictionaryEncodingTestCase<int64_t>{
+          1000000, 1.0, 201668, generateSomewhatRandomDataTyped<int64_t>},
+  };
+
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+// Split test to avoid sandcastle timeouts.
+TEST_F(ColumnWriterTest, IntegerTypeDictionaryEncodingHugeRepeatedWrites) {
+  struct TestCase
+      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
+    TestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
+              size,
+              1.0,
+              finalDictionarySize,
+              genData,
+              false,
+              noNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      // Test repeated writes. All values are in dictionary.
+      TestCase{1000, 617, generateSomewhatRandomData, 1000},
+      // Test repeated writes and flushes with mixture of values in
+      // dictionary.
+      // Tests independence of dictionary encoding writes across stripes. (In
+      // other words, whether the dictionary is cleared across stripes.)
+      TestCase{1000, 201, generateSomewhatRandomData, 1, 1000},
+      // Test repeated writes and flushes. All values are in dictionary.
+      TestCase{1000, 617, generateSomewhatRandomData, 2, 500},
+  };
+
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerTypeDirectEncodingWrites) {
+  struct TestCase : public IntegerColumnWriterDirectEncodingUniversalTestCase {
+    TestCase(
+        size_t size,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDirectEncodingUniversalTestCase{
+              size,
+              0.0,
+              genData,
+              false,
+              noNulls,
+              noPostProcessing,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      TestCase{1000, generateRangeWithCustomLimits},
+      TestCase{1000, generateSomewhatRandomData},
+      TestCase{1000, generateSomewhatRandomData, 20},
+      // Note, writes from the second stripe on uses direct encoding from the
+      // get-go.
+      // TODO: reinforce that the subsequent writes go through the right code
+      // path when we have more granular memory tracking.
+      TestCase{1000, generateSomewhatRandomData, 1, 10},
+      TestCase{1000, generateSomewhatRandomData, 2, 10},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerTypeDirectEncodingWritesWithNulls) {
+  struct TestCase : public IntegerColumnWriterDirectEncodingUniversalTestCase {
+    TestCase(
+        size_t size,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<bool(size_t, size_t)>& genNulls,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDirectEncodingUniversalTestCase{
+              size,
+              0.0,
+              genData,
+              true,
+              genNulls,
+              noPostProcessing,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      TestCase{1000, generateRangeWithCustomLimits, allNulls},
+      TestCase{1000, generateRangeWithCustomLimits, someNulls},
+      TestCase{1000, generateSomewhatRandomData, someNulls},
+      TestCase{1000, generateSomewhatRandomData, someNulls, 20},
+      // Note, writes from the second stripe on uses direct encoding from the
+      // get-go.
+      // TODO: reinforce that the subsequent writes go through the right code
+      // path when we have more granular memory tracking.
+      TestCase{1000, generateSomewhatRandomData, someNulls, 1, 10},
+      TestCase{1000, generateSomewhatRandomData, someNulls, 2, 10},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerTypeDirectEncodingHugeWrites) {
+  struct TestCase : public IntegerColumnWriterDirectEncodingUniversalTestCase {
+    TestCase(
+        size_t size,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDirectEncodingUniversalTestCase{
+              size,
+              0.0,
+              genData,
+              false,
+              noNulls,
+              noPostProcessing,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      // Everything is straight forward for direct encoding writes, so no
+      // special casing needed for types.
+      TestCase{1000000, generateRangeWithCustomLimits},
+      TestCase{1000000, generateSomewhatRandomData},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+// Split test to avoid sandcastle timeouts.
+TEST_F(ColumnWriterTest, IntegerTypeDirectEncodingHugeRepeatedWrites) {
+  struct TestCase : public IntegerColumnWriterDirectEncodingUniversalTestCase {
+    TestCase(
+        size_t size,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDirectEncodingUniversalTestCase{
+              size,
+              0.0,
+              genData,
+              false,
+              noNulls,
+              noPostProcessing,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      // Test repeated writes.
+      TestCase{1000, generateSomewhatRandomData, 1000},
+      // Note, writes from the second stripe on uses direct encoding from the
+      // get-go.
+      // TODO: reinforce that the subsequent writes go through the right code
+      // path when we have more granular memory tracking.
+      TestCase{1000, generateSomewhatRandomData, 1, 1000},
+      TestCase{1000, generateSomewhatRandomData, 2, 500},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerTypeDictionaryWriteThreshold) {
+  struct DictionaryEncodingTestCase
+      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        float dictionarySizeThreshold,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
+              size,
+              dictionarySizeThreshold,
+              finalDictionarySize,
+              genData,
+              false,
+              noNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  struct DirectEncodingTestCase
+      : public IntegerColumnWriterDirectEncodingUniversalTestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        float dictionarySizeThreshold,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDirectEncodingUniversalTestCase{
+              size,
+              dictionarySizeThreshold,
+              genData,
+              false,
+              noNulls,
+              noPostProcessing,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  struct DirectEncodingTestCaseAllNulls
+      : public IntegerColumnWriterDirectEncodingUniversalTestCase {
+    DirectEncodingTestCaseAllNulls(
+        size_t size,
+        float dictionarySizeThreshold,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterDirectEncodingUniversalTestCase{
+              size,
+              dictionarySizeThreshold,
+              genData,
+              true,
+              allNulls,
+              noPostProcessing,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      // All nulls should use direct encoding regardless.
+      DirectEncodingTestCaseAllNulls{1000, 1.0, generateRangeWithCustomLimits},
+      // No value in dictionary.
+      DirectEncodingTestCase{1000, 0.75, generateRangeWithCustomLimits},
+      DictionaryEncodingTestCase{1000, 1.0, 0, generateRangeWithCustomLimits},
+      // Dict size is exactly 50.
+      DictionaryEncodingTestCase{
+          100, 0.5, 24, generateSomewhatRandomPositiveData},
+      // Fails with a threshold that is the slightest amount under possible.
+      DirectEncodingTestCase{
+          100,
+          0.5 - std::numeric_limits<float>::epsilon(),
+          generateSomewhatRandomPositiveData},
+      // All values are in dictionary in repeated writes.
+      DirectEncodingTestCase{
+          1000,
+          0.5 - std::numeric_limits<float>::epsilon(),
+          generateRangeWithCustomLimits,
+          2},
+      DictionaryEncodingTestCase{
+          1000,
+          0.5 - std::numeric_limits<float>::epsilon(),
+          1000,
+          generateRangeWithCustomLimits,
+          4},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerColumnWriterAbandonDictionaries) {
+  struct TestCase : public IntegerColumnWriterUniversalTestCase {
+    TestCase(
+        size_t size,
+        bool writeDirect,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount,
+        size_t flushCount)
+        : IntegerColumnWriterUniversalTestCase{
+              size,
+              writeDirect,
+              1.0f,
+              finalDictionarySize,
+              genData,
+              false,
+              noNulls,
+              postProcess,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  struct DirectEncodingTestCase : public TestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ true,
+              /* finalDictionarySize */ 0,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  struct DictionaryEncodingTestCase : public TestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ false,
+              finalDictionarySize,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  std::vector<TestRunner> testCases{
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          10},
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          1,
+          10},
+      // Test abandoning dictionary in multi-write scenarios. For now we could
+      // only abandon dictionary starting from the first stripe, because we
+      // could not switch up encoding of a writer once determined.
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          2,
+          5},
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 1)),
+          2,
+          5},
+      // We shouldn't be able to switch encodings beyond the first stripe.
+      DictionaryEncodingTestCase{
+          1000,
+          /* finalDictionarySize */ 1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(1, 0), /* force */ true, noSuccess),
+          2,
+          5},
+      // Abandoning at every write to make sure subsequent abandon dict calls
+      // are safe.
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          10},
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          1,
+          10},
+  };
+
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerColumnWriterAbandonDictionariesWithNulls) {
+  struct TestCase : public IntegerColumnWriterUniversalTestCase {
+    TestCase(
+        size_t size,
+        bool writeDirect,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount,
+        size_t flushCount)
+        : IntegerColumnWriterUniversalTestCase{
+              size,
+              writeDirect,
+              1.0f,
+              finalDictionarySize,
+              genData,
+              true,
+              someNulls,
+              postProcess,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  struct DirectEncodingTestCase : public TestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ true,
+              /* finalDictionarySize */ 0,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  struct DictionaryEncodingTestCase : public TestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ false,
+              finalDictionarySize,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  std::vector<TestRunner> testCases{
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          10},
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          1,
+          10},
+      // Test abandoning dictionary in multi-write scenarios. For now we could
+      // only abandon dictionary starting from the first stripe, because we
+      // could not switch up encoding of a writer once determined.
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          2,
+          5},
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 1)),
+          2,
+          5},
+      // We shouldn't be able to switch encodings beyond the first stripe.
+      DictionaryEncodingTestCase{
+          1000,
+          /* finalDictionarySize */ 341,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(1, 0), /* force */ true, noSuccess),
+          2,
+          5},
+      // Abandoning at every write to make sure subsequent abandon dict calls
+      // are safe.
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          10},
+      DirectEncodingTestCase{
+          1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          1,
+          10},
+  };
+
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerColumnWriterAbandonLowValueDictionaries) {
+  struct TestCase : public IntegerColumnWriterUniversalTestCase {
+    TestCase(
+        size_t size,
+        bool writeDirect,
+        float dictionaryWriteThreshold,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : IntegerColumnWriterUniversalTestCase{
+              size,
+              writeDirect,
+              dictionaryWriteThreshold,
+              finalDictionarySize,
+              genData,
+              false,
+              noNulls,
+              postProcess,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  struct DirectEncodingTestCase : public TestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        float dictionaryWriteThreshold,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ true,
+              dictionaryWriteThreshold,
+              /* finalDictionarySize */ 0,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  struct DictionaryEncodingTestCase : public TestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        float dictionaryWriteThreshold,
+        size_t finalDictionarySize,
+        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ false,
+              dictionaryWriteThreshold,
+              finalDictionarySize,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  std::vector<TestRunner> testCases{
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 1.0f,
+          /* finalDictionarySize */ 1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 10},
+      // finalDictionarySize == 0 because in each stripe
+      // each value only appeared once.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 1.0f,
+          /* finalDictionarySize */ 0,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 1,
+          /* stripeCount */ 10},
+      DirectEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 0.4f,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ false,
+              successAtNthWriteForStripe(0, 1)),
+          /* repCount */ 10},
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 0.4f,
+          /* finalDictionarySize */ 1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 2),
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 10},
+      // Test abandoning dictionary in multi-write scenarios. For now we could
+      // only abandon dictionary starting from the first stripe, because we
+      // could not switch up encoding of a writer once determined.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 1.0f,
+          /* finalDictionarySize */ 1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 5,
+          /* stripeCount*/ 2},
+      // We shouldn't be able to switch encodings beyond the first stripe.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 1.0f,
+          /* finalDictionarySize */ 1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(1, 0), /* force */ false, noSuccess),
+          /* repCount */ 5,
+          /* stripeCount*/ 2},
+      DirectEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 0.1f,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ false,
+              successAtNthWriteForStripe(0, 1)),
+          /* repCount */ 5,
+          /* stripeCount*/ 2},
+      // Return false because we were already using direct encoding.
+      DirectEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 0.1f,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonNthWriteForStripe(1, 0), /* force */ false, noSuccess),
+          /* repCount */ 5,
+          /* stripeCount*/ 2},
+      // Abandoning at every write to make sure subsequent abandon dict calls
+      // are safe.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 1.0f,
+          /* finalDictionarySize */ 1000,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 10},
+      // finalDictionarySize == 0 because in each stripe
+      // each value only appeared once.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryWriteThreshold */ 1.0f,
+          /* finalDictionarySize */ 0,
+          generateRangeWithCustomLimits,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 1,
+          /* stripeCount*/ 10},
+  };
+
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+template <typename Integer>
+void testIntegerDictionaryEncodableWriterConstructor() {
+  auto type = CppToType<Integer>::create();
+  auto typeWithId = TypeWithId::create(type, 1);
+  auto pool = memory::memoryManager()->addLeafPool();
+
+  // Write input
+  auto config = std::make_shared<Config>();
+  float slightlyOver = 1.0f + std::numeric_limits<float>::epsilon() * 2;
+  {
+    config->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, slightlyOver);
+    WriterContext context{config, memory::memoryManager()->addRootPool()};
+    context.initBuffer();
+    EXPECT_ANY_THROW(BaseColumnWriter::create(context, *typeWithId));
+  }
+  float slightlyUnder = -std::numeric_limits<float>::epsilon();
+  {
+    config->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, slightlyUnder);
+    WriterContext context{config, memory::memoryManager()->addRootPool()};
+    context.initBuffer();
+    EXPECT_ANY_THROW(BaseColumnWriter::create(context, *typeWithId));
+  }
+}
+
+TEST_F(ColumnWriterTest, IntegerDictionaryDictionaryEncodableWriterCtor) {
+  testIntegerDictionaryEncodableWriterConstructor<int16_t>();
+  testIntegerDictionaryEncodableWriterConstructor<int32_t>();
+  testIntegerDictionaryEncodableWriterConstructor<int64_t>();
+}
+
+std::string
+generateSomewhatRandomStringData(size_t /*unused*/, size_t i, size_t size) {
+  return folly::to<std::string>(generateSomewhatRandomData(i, size, 0, 0));
+}
+
+std::string generateStringRange(size_t /*unused*/, size_t i, size_t size) {
+  return folly::to<std::string>(generateRangeWithLimits<int64_t>(i, size));
+}
+
+struct StringColumnWriterTestCase {
+  const size_t size;
+  const bool writeDirect;
+  const float dictionaryKeyEfficiencyThreshold;
+  const float entropyKeyEfficiencyThreshold;
+  const size_t finalDictionarySize;
+  const std::function<std::string(size_t, size_t, size_t)> genData;
+  const bool hasNulls;
+  const std::function<bool(size_t, size_t, size_t)> genNulls;
+  const std::function<void(ColumnWriter&, size_t, size_t)> postProcess;
+  const size_t repetitionCount;
+  const size_t flushCount;
+  const std::shared_ptr<const Type> type;
+
+  StringColumnWriterTestCase(
+      size_t size,
+      bool writeDirect,
+      float dictionaryKeyEfficiencyThreshold,
+      float entropyKeyEfficiencyThreshold,
+      size_t finalDictionarySize,
+      const std::function<std::string(size_t, size_t, size_t)>& genData,
+      bool hasNulls,
+      const std::function<bool(size_t, size_t, size_t)>& genNulls,
+      const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : size{size},
+        writeDirect{writeDirect},
+        dictionaryKeyEfficiencyThreshold{dictionaryKeyEfficiencyThreshold},
+        entropyKeyEfficiencyThreshold{entropyKeyEfficiencyThreshold},
+        finalDictionarySize{finalDictionarySize},
+        genData{genData},
+        hasNulls{hasNulls},
+        genNulls{genNulls},
+        postProcess{postProcess},
+        repetitionCount{repetitionCount},
+        flushCount{flushCount},
+        type{CppToType<folly::StringPiece>::create()} {}
+
+  virtual ~StringColumnWriterTestCase() = default;
+
+  FlatVectorPtr<StringView> generateStringSlice(
+      size_t strideIndex,
+      MemoryPool* pool) const {
+    auto nulls = allocateNulls(size, pool);
+    auto* nullsPtr = nulls->asMutable<uint64_t>();
+
+    auto values = AlignedBuffer::allocate<StringView>(size, pool);
+    auto* valuesPtr = values->asMutable<StringView>();
+
+    std::vector<BufferPtr> dataChunks;
+
+    BufferPtr dataChunk = AlignedBuffer::allocate<char>(1024, pool);
+    dataChunks.push_back(dataChunk);
+    auto* dataChunkPtr = dataChunk->asMutable<char>();
+
+    size_t nullCount = 0;
+    size_t offset = 0;
+    for (size_t i = 0; i != size; ++i) {
+      bool isPresent = genNulls(strideIndex, i, size);
+      bits::setNull(nullsPtr, i, !isPresent);
+
+      if (isPresent) {
+        auto val = genData(strideIndex, i, size);
+        if (offset + val.size() > dataChunk->capacity()) {
+          dataChunk = AlignedBuffer::allocate<char>(1024, pool);
+          dataChunks.push_back(dataChunk);
+          dataChunkPtr = dataChunk->asMutable<char>();
+          offset = 0;
+        }
+
+        memcpy(dataChunkPtr + offset, val.data(), val.size());
+        valuesPtr[i] = StringView(dataChunkPtr + offset, val.size());
+        offset += val.size();
+      } else {
+        nullCount++;
+      }
+    }
+
+    auto stringVector = std::make_shared<FlatVector<StringView>>(
+        pool, VARCHAR(), nulls, size, values, std::move(dataChunks));
+    stringVector->setNullCount(nullCount);
+    return stringVector;
+  }
+
+  void runTest() const {
+    auto pool = memory::memoryManager()->addLeafPool();
+
+    // Set up writer.
+    auto config = std::make_shared<Config>();
+    config->set(
+        Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD,
+        entropyKeyEfficiencyThreshold);
+    config->set(
+        Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD,
+        dictionaryKeyEfficiencyThreshold);
+    WriterContext context{config, memory::memoryManager()->addRootPool()};
+    context.initBuffer();
+    // Register root node.
+    auto typeWithId = TypeWithId::create(type, 1);
+    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
+
+    // Prepare input
+    std::vector<VectorPtr> batches;
+
+    for (size_t j = 0; j != repetitionCount; j++) {
+      batches.emplace_back(generateStringSlice(j, pool.get()));
+    }
+
+    for (size_t i = 0; i != flushCount; ++i) {
+      proto::StripeFooter stripeFooter;
+      // Write Stride
+      for (size_t j = 0; j != repetitionCount; ++j) {
+        // TODO: break the batch into multiple strides.
+        columnWriter->write(batches[j], common::Ranges::of(0, size));
+        postProcess(*columnWriter, i, j);
+        columnWriter->createIndexEntry();
+      }
+
+      // Flush when all strides are written (once per stripe).
+      columnWriter->flush(
+          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
+            return *stripeFooter.add_encoding();
+          });
+
+      // Read and verify.
+      const size_t nodeId = 1;
+      auto rowType = ROW({{"string_column", type}});
+      TestStripeStreams streams(context, stripeFooter, rowType, pool.get());
+      EncodingKey key{nodeId};
+      const auto& encoding = streams.getEncoding(key);
+      if (writeDirect) {
+        ASSERT_EQ(
+            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DIRECT,
+            encoding.kind());
+      } else {
+        ASSERT_EQ(
+            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY,
+            encoding.kind());
+        ASSERT_EQ(finalDictionarySize, encoding.dictionarysize());
+      }
+
+      auto reqType = TypeWithId::create(rowType)->childAt(0);
+      memory::AllocationPool allocPool(pool.get());
+      StreamLabels labels(allocPool);
+      auto columnReader =
+          ColumnReader::build(reqType, reqType, streams, labels, nullptr, 0);
+
+      for (size_t j = 0; j != repetitionCount; ++j) {
+        if (!writeDirect) {
+          EXPECT_CALL(streams.getMockStrideIndexProvider(), getStrideIndex())
+              .Times(::testing::AtMost(1)) // Stride dictionary is optional
+              .WillOnce(Return(j));
+        }
+
+        // TODO Make reuse work
+        VectorPtr resultBatch;
+        columnReader->next(size, resultBatch);
+
+        auto batch = batches[j];
+        ASSERT_EQ(batch->size(), resultBatch->size());
+
+        auto sv = std::dynamic_pointer_cast<FlatVector<StringView>>(batch);
+        ASSERT_TRUE(sv);
+        auto resultSv =
+            std::dynamic_pointer_cast<SimpleVector<StringView>>(resultBatch);
+        ASSERT_TRUE(resultSv);
+        ASSERT_EQ(sv->getNullCount(), resultSv->getNullCount());
+        for (size_t k = 0; k < sv->size(); k++) {
+          EXPECT_EQ(sv->isNullAt(k), resultSv->isNullAt(k));
+        }
+
+        for (size_t k = 0; k != sv->size(); ++k) {
+          if (!sv->isNullAt(k)) {
+            EXPECT_EQ(sv->valueAt(k), resultSv->valueAt(k)) << folly::sformat(
+                "Mismatch on {}-th element. \nExpected: {}\n Actual: {}",
+                k,
+                sv->valueAt(k).str(),
+                resultSv->valueAt(k).str());
+          }
+        }
+      }
+      context.nextStripe();
+      columnWriter->reset();
+    }
+  }
+};
+
+struct StringDictionaryEncodingTestCase : public StringColumnWriterTestCase {
+  explicit StringDictionaryEncodingTestCase(
+      size_t size,
+      size_t finalDictionarySize,
+      const std::function<std::string(size_t, size_t, size_t)>& genData,
+      bool hasNull,
+      const std::function<bool(size_t, size_t, size_t)>& genNulls,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : StringColumnWriterTestCase{
+            size,
+            false,
+            1.0f,
+            0.0f,
+            finalDictionarySize,
+            genData,
+            hasNull,
+            genNulls,
+            noPostProcessing,
+            repetitionCount,
+            flushCount} {}
+};
+
+struct StringDirectEncodingTestCase : public StringColumnWriterTestCase {
+  explicit StringDirectEncodingTestCase(
+      size_t size,
+      const std::function<std::string(size_t, size_t, size_t)>& genData,
+      bool hasNull,
+      const std::function<bool(size_t, size_t, size_t)>& genNulls,
+      size_t repetitionCount = 1,
+      size_t flushCount = 1)
+      : StringColumnWriterTestCase{
+            size,
+            true,
+            0.0f,
+            1.0f,
+            0,
+            genData,
+            hasNull,
+            genNulls,
+            noPostProcessing,
+            repetitionCount,
+            flushCount} {}
+};
+
+TEST_F(ColumnWriterTest, StringDictionaryEncodingWrite) {
+  struct TestCase : public StringDictionaryEncodingTestCase {
+    explicit TestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : StringDictionaryEncodingTestCase{
+              size,
+              finalDictionarySize,
+              genData,
+              false,
+              noNullsWithStride,
+              repetitionCount,
+              flushCount} {}
+  };
+  std::vector<TestRunner> testCases{
+      // No values in dictionary.
+      TestCase{1000, 0, generateStringRange},
+      // Mixture of values in dictionary vs not.
+      TestCase{1000, 201, generateSomewhatRandomStringData},
+      // Test repeated writes. All values are in dictionary.
+      TestCase{1000, 617, generateSomewhatRandomStringData, 20},
+      // Test repeated writes and flushes with mixture of values in
+      // dictionary.
+      // Tests independence of dictionary encoding writes across stripes. (In
+      // other words, whether the dictionary is cleared across stripes.)
+      TestCase{1000, 201, generateSomewhatRandomStringData, 1, 10},
+      // Test repeated writes and flushes. All values are in dictionary.
+      TestCase{1000, 617, generateSomewhatRandomStringData, 2, 10},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+std::string genStrideData_scheme1(
+    size_t strideIndex,
+    size_t strideOffset,
+    size_t /*unused*/) {
+  // 1st stride contains - "0", "a",  "a", "a",...
+  // 2nd stride contains - "1", "b",  "b", "b",...
+  // The 1st string will block the inDictStream optimization and exercise
+  // the related code path.
+  char ch = static_cast<char>(
+      (strideOffset == 0) ? '0' + strideIndex : 'a' + strideIndex);
+  return std::string(1, ch);
+}
+
+std::string genStrideData_scheme2(
+    size_t strideIndex,
+    size_t strideOffset,
+    size_t /*unused*/) {
+  // 1st stride contains - "start",  "a", "a",...
+  // 2nd stride contains - "b",  "b", "b",...
+  if (strideOffset == 0 && strideIndex == 0) {
+    // If all the keys are in dictionary, inDictStream is skipped and the code
+    // path is skipped. So introducing a non repeated string here
+    // intentionally.
+    return std::string("start");
+  }
+  char ch = static_cast<char>('a' + strideIndex);
+  return std::string(1, ch);
+}
+
+bool genNulls_ForStride2(
+    size_t strideIndex,
+    size_t /*unused*/,
+    size_t /*unused*/) {
+  // Except for Stride 2, the rest strides will contain nulls.
+  return strideIndex == 2;
+}
+
+TEST_F(ColumnWriterTest, StrideStringWithSomeDataNotInDictionary) {
+  struct TestCase : public StringDictionaryEncodingTestCase {
+    explicit TestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        bool hasNulls,
+        const std::function<bool(size_t, size_t, size_t)>& genNulls,
+        size_t repetitionCount,
+        size_t flushCount)
+        : StringDictionaryEncodingTestCase{
+              size,
+              finalDictionarySize,
+              genData,
+              hasNulls,
+              genNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      TestCase{1000, 2, genStrideData_scheme1, false, noNullsWithStride, 2, 5},
+
+      TestCase{1000, 2, genStrideData_scheme2, false, noNullsWithStride, 2, 3},
+
+      TestCase{
+          1000, 1, genStrideData_scheme1, true, genNulls_ForStride2, 3, 1}};
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, StringDictionaryEncodingWritesWithNulls) {
+  struct DictionaryEncodingTestCase : public StringDictionaryEncodingTestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<bool(size_t, size_t, size_t)>& genNulls,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : StringDictionaryEncodingTestCase{
+              size,
+              finalDictionarySize,
+              genData,
+              true,
+              genNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  // Even as the dictionary size threshold allows, we might not end up writing
+  // with dictionary encoding.
+  struct DirectEncodingTestCase : public StringDirectEncodingTestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<bool(size_t, size_t, size_t)>& genNulls,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : StringDirectEncodingTestCase{
+              size,
+              genData,
+              true,
+              genNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      // When all values are null, we don't try to write dictionary at all.
+      DirectEncodingTestCase{1000, generateStringRange, allNullsWithStride},
+      // No values in dictionary.
+      DictionaryEncodingTestCase{
+          100, 0, generateStringRange, someNullsWithStride},
+      // Mixture of values in dictionary vs not.
+      DictionaryEncodingTestCase{
+          1000, 62, generateSomewhatRandomStringData, someNullsWithStride},
+      // Test repeated writes. All values are in dictionary.
+      DictionaryEncodingTestCase{
+          1000, 250, generateSomewhatRandomStringData, someNullsWithStride, 20},
+      // Test repeated writes and flushes with mixture of values in
+      // dictionary.
+      // Tests independence of dictionary encoding writes across stripes. (In
+      // other words, whether the dictionary is cleared across stripes.)
+      DictionaryEncodingTestCase{
+          1000,
+          62,
+          generateSomewhatRandomStringData,
+          someNullsWithStride,
+          1,
+          10},
+      // Test repeated writes and flushes. All values are in dictionary.
+      DictionaryEncodingTestCase{
+          1000,
+          250,
+          generateSomewhatRandomStringData,
+          someNullsWithStride,
+          2,
+          10},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, StringDirectEncodingWrites) {
+  struct TestCase : public StringDirectEncodingTestCase {
+    TestCase(
+        size_t size,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : StringDirectEncodingTestCase{
+              size,
+              genData,
+              false,
+              noNullsWithStride,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      TestCase{1000, generateStringRange},
+      TestCase{1000, generateSomewhatRandomStringData},
+      TestCase{1000, generateSomewhatRandomStringData, 20},
+      // Note, writes from the second stripe on uses direct encoding from the
+      // get-go.
+      // TODO: reinforce that the subsequent writes go through the right code
+      // path when we have more granular memory tracking.
+      TestCase{1000, generateSomewhatRandomStringData, 1, 10},
+      TestCase{1000, generateSomewhatRandomStringData, 2, 10},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, StringDirectEncodingWritesWithNulls) {
+  struct TestCase : public StringDirectEncodingTestCase {
+    TestCase(
+        size_t size,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<bool(size_t, size_t, size_t)>& genNulls,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : StringDirectEncodingTestCase{
+              size,
+              genData,
+              true,
+              genNulls,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  std::vector<TestRunner> testCases{
+      TestCase{1000, generateStringRange, allNullsWithStride},
+      TestCase{1000, generateStringRange, someNullsWithStride},
+      TestCase{1000, generateSomewhatRandomStringData, someNullsWithStride},
+      TestCase{1000, generateSomewhatRandomStringData, someNullsWithStride, 20},
+      // Note, writes from the second stripe on uses direct encoding from the
+      // get-go.
+      // TODO: reinforce that the subsequent writes go through the right code
+      // path when we have more granular memory tracking.
+      TestCase{
+          1000, generateSomewhatRandomStringData, someNullsWithStride, 1, 10},
+      TestCase{
+          1000, generateSomewhatRandomStringData, someNullsWithStride, 2, 10},
+  };
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, StringColumnWriterAbandonDictionaries) {
+  struct TestCase : public StringColumnWriterTestCase {
+    TestCase(
+        size_t size,
+        bool writeDirect,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount,
+        size_t flushCount)
+        : StringColumnWriterTestCase{
+              size,
+              writeDirect,
+              1.0f,
+              0.0f,
+              finalDictionarySize,
+              genData,
+              false,
+              noNullsWithStride,
+              postProcess,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  struct DirectEncodingTestCase : public TestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ true,
+              /* finalDictionarySize */ 0,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  struct DictionaryEncodingTestCase : public TestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ false,
+              finalDictionarySize,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  std::vector<TestRunner> testCases{
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          10},
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          1,
+          10},
+      // Test abandoning dictionary in multi-write scenarios. For now we could
+      // only abandon dictionary starting from the first stripe, because we
+      // could not switch up encoding of a writer once determined.
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          2,
+          5},
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 1)),
+          2,
+          5},
+      // We shouldn't be able to switch encodings beyond the first stripe.
+      DictionaryEncodingTestCase{
+          1000,
+          /* finalDictionarySize */ 1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(1, 0), /* force */ true, noSuccess),
+          2,
+          5},
+      // Abandoning at every write to make sure subsequent abandon dict calls
+      // are safe.
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          10},
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          1,
+          10},
+  };
+
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+// TODO: how about all nulls?
+TEST_F(ColumnWriterTest, StringColumnWriterAbandonDictionariesWithNulls) {
+  struct TestCase : public StringColumnWriterTestCase {
+    TestCase(
+        size_t size,
+        bool writeDirect,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : StringColumnWriterTestCase{
+              size,
+              writeDirect,
+              1.0f,
+              0.0f,
+              finalDictionarySize,
+              genData,
+              true,
+              someNullsWithStride,
+              postProcess,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  struct DirectEncodingTestCase : public TestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ true,
+              /* finalDictionarySize */ 0,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  struct DictionaryEncodingTestCase : public TestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ false,
+              finalDictionarySize,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  std::vector<TestRunner> testCases{
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          10},
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          1,
+          10},
+      // Test abandoning dictionary in multi-write scenarios. For now we could
+      // only abandon dictionary starting from the first stripe, because we
+      // could not switch up encoding of a writer once determined.
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          2,
+          5},
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ true,
+              successAtNthWriteForStripe(0, 1)),
+          2,
+          5},
+      // We shouldn't be able to switch encodings beyond the first stripe.
+      DictionaryEncodingTestCase{
+          1000,
+          /* finalDictionarySize */ 341,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(1, 0), /* force */ true, noSuccess),
+          2,
+          5},
+      // Abandoning at every write to make sure subsequent abandon dict calls
+      // are safe.
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          10},
+      DirectEncodingTestCase{
+          1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ true,
+              successAtNthWriteForStripe(0, 0)),
+          1,
+          10},
+  };
+
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, StringColumnWriterAbandonLowValueDictionaries) {
+  struct TestCase : public StringColumnWriterTestCase {
+    TestCase(
+        size_t size,
+        bool writeDirect,
+        float dictionaryKeyEfficiencyThreshold,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount,
+        size_t flushCount)
+        : StringColumnWriterTestCase{
+              size,
+              writeDirect,
+              dictionaryKeyEfficiencyThreshold,
+              /* entropyKeyEfficiencyThreshold */ 0.0f,
+              finalDictionarySize,
+              genData,
+              false,
+              noNullsWithStride,
+              postProcess,
+              repetitionCount,
+              flushCount} {}
+  };
+
+  struct DirectEncodingTestCase : public TestCase {
+    DirectEncodingTestCase(
+        size_t size,
+        float dictionaryKeyEfficiencyThreshold,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ true,
+              dictionaryKeyEfficiencyThreshold,
+              /* finalDictionarySize */ 0,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  struct DictionaryEncodingTestCase : public TestCase {
+    DictionaryEncodingTestCase(
+        size_t size,
+        float dictionaryKeyEfficiencyThreshold,
+        size_t finalDictionarySize,
+        const std::function<std::string(size_t, size_t, size_t)>& genData,
+        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
+        size_t repetitionCount = 1,
+        size_t flushCount = 1)
+        : TestCase(
+              size,
+              /* writeDirect */ false,
+              dictionaryKeyEfficiencyThreshold,
+              finalDictionarySize,
+              genData,
+              postProcess,
+              repetitionCount,
+              flushCount) {}
+  };
+
+  std::vector<TestRunner> testCases{
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
+          /* finalDictionarySize */ 1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 10},
+      // FinalDictionarySize == 0 because in each stripe
+      // each value only appeared once.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
+          /* finalDictionarySize */ 0,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 0),
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 1,
+          /* stripeCount */ 10},
+      DirectEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 0.4f,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ false,
+              successAtNthWriteForStripe(0, 1)),
+          /* repCount */ 10},
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 0.4f,
+          /* finalDictionarySize */ 1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 2),
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 10},
+      // Test abandoning dictionary in multi-write scenarios. For now we could
+      // only abandon dictionary starting from the first stripe, because we
+      // could not switch up encoding of a writer once determined.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
+          /* finalDictionarySize */ 1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 5,
+          /* stripeCount*/ 2},
+      // We shouldn't be able to switch encodings beyond the first stripe.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
+          /* finalDictionarySize */ 1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(1, 0), /* force */ false, noSuccess),
+          /* repCount */ 5,
+          /* stripeCount*/ 2},
+      DirectEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 0.1f,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(0, 1),
+              /* force */ false,
+              successAtNthWriteForStripe(0, 1)),
+          /* repCount */ 5,
+          /* stripeCount*/ 2},
+      // Return false because we were already using direct encoding.
+      DirectEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 0.1f,
+          generateStringRange,
+          checkAbandonDict(
+              abandonNthWriteForStripe(1, 0), /* force */ false, noSuccess),
+          /* repCount */ 5,
+          /* stripeCount*/ 2},
+      // Abandoning at every write to make sure subsequent abandon dict calls
+      // are safe.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
+          /* finalDictionarySize */ 1000,
+          generateStringRange,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 10},
+      // FinalDictionarySize == 0 because in each stripe
+      // each value only appeared once.
+      DictionaryEncodingTestCase{
+          1000,
+          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
+          /* finalDictionarySize */ 0,
+          generateStringRange,
+          checkAbandonDict(
+              abandonEveryWrite,
+              /* force */ false,
+              noSuccess),
+          /* repCount */ 1,
+          /* stripeCount*/ 10},
+  };
+
+  for (const auto& testCase : testCases) {
+    testCase.runTest();
+  }
+}
+
+TEST_F(ColumnWriterTest, IntDictWriterDirectValueOverflow) {
+  auto config = std::make_shared<Config>();
+  WriterContext context{
+      config,
+      memory::memoryManager()->addRootPool("IntDictWriterDirectValueOverflow")};
+  context.initBuffer();
+  auto type = std::make_shared<const IntegerType>();
+  auto typeWithId = TypeWithId::create(type, 1);
+
+  // write
+  constexpr size_t size = 100;
+  std::vector<std::optional<int32_t>> data;
+  for (auto i = 0; i < size; ++i) {
+    data.push_back((i == 0 ? -1 : 1));
+  }
+  auto vector = populateBatch<int32_t>(data, pool_.get());
+
+  auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
+  writer->write(vector, common::Ranges::of(0, size));
+  writer->createIndexEntry();
+  proto::StripeFooter sf;
+  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
+    return *sf.add_encoding();
+  });
+  auto& enc = sf.encoding(0);
+  ASSERT_EQ(enc.kind(), proto::ColumnEncoding_Kind_DICTIONARY);
+
+  // get data stream
+  TestStripeStreams streams(context, sf, ROW({"foo"}, {type}), pool_.get());
+  DwrfStreamIdentifier si{1, 0, 0, proto::Stream_Kind_DATA};
+  auto stream = streams.getStream(si, {}, true);
+
+  // read it as long
+  auto decoder = createRleDecoder<false>(
+      std::move(stream), RleVersion_1, *pool_, streams.getUseVInts(si), 8);
+  std::array<int64_t, size> actual;
+  decoder->next(actual.data(), size, nullptr);
+  for (auto i = 0; i < size; ++i) {
+    ASSERT_EQ(actual[i], i == 0 ? -1 : 0);
+  }
+}
+
+TEST_F(ColumnWriterTest, ShortDictWriterDictValueOverflow) {
+  auto config = std::make_shared<Config>();
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  auto type = std::make_shared<const SmallintType>();
+  auto typeWithId = TypeWithId::create(type, 1);
+
+  // write
+  constexpr size_t repeat = 3;
+  constexpr size_t count = 1 << 16;
+  constexpr size_t size = repeat * count;
+  std::vector<std::optional<int16_t>> data;
+  for (auto i = 0; i < repeat; ++i) {
+    int16_t val = std::numeric_limits<int16_t>::min();
+    for (auto j = 0; j < count; ++j) {
+      data.push_back(val++);
+    }
+  }
+  auto vector = populateBatch<int16_t>(data, pool_.get());
+
+  auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
+  writer->write(vector, common::Ranges::of(0, size));
+  writer->createIndexEntry();
+  proto::StripeFooter sf;
+  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
+    return *sf.add_encoding();
+  });
+  auto& enc = sf.encoding(0);
+  ASSERT_EQ(enc.kind(), proto::ColumnEncoding_Kind_DICTIONARY);
+
+  // get data stream
+  TestStripeStreams streams(context, sf, ROW({"foo"}, {type}), pool_.get());
+  DwrfStreamIdentifier si{1, 0, 0, proto::Stream_Kind_DATA};
+  auto stream = streams.getStream(si, {}, true);
+
+  // read it as long
+  auto decoder = createRleDecoder<false>(
+      std::move(stream), RleVersion_1, *pool_, streams.getUseVInts(si), 8);
+  std::array<int64_t, size> actual;
+  decoder->next(actual.data(), size, nullptr);
+  for (auto i = 0; i < size; ++i) {
+    ASSERT_GE(actual[i], 0);
+  }
+}
+
+TEST_F(ColumnWriterTest, RemovePresentStream) {
+  auto config = std::make_shared<Config>();
+
+  std::vector<std::optional<int32_t>> data;
+  auto size = 100;
+  for (auto i = 0; i < size; ++i) {
+    data.push_back(i);
+  }
+  auto vector = populateBatch<int32_t>(data, pool_.get());
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  auto type = std::make_shared<const IntegerType>();
+  auto typeWithId = TypeWithId::create(type, 1);
+
+  // write
+  auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
+
+  writer->write(vector, common::Ranges::of(0, size));
+  writer->createIndexEntry();
+  proto::StripeFooter sf;
+  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
+    return *sf.add_encoding();
+  });
+
+  // get data stream
+  TestStripeStreams streams(context, sf, ROW({"foo"}, {type}), pool_.get());
+  DwrfStreamIdentifier si{1, 0, 0, proto::Stream_Kind_PRESENT};
+  ASSERT_EQ(streams.getStream(si, {}, false), nullptr);
+}
+
+TEST_F(ColumnWriterTest, ColumnIdInStream) {
+  auto config = std::make_shared<Config>();
+
+  std::vector<std::optional<int32_t>> data;
+  auto size = 100;
+  for (auto i = 0; i < size; ++i) {
+    data.push_back(i);
+  }
+  auto vector = populateBatch<int32_t>(data, pool_.get());
+  WriterContext context{
+      config, memory::memoryManager()->addRootPool("ColumnIdInStream")};
+  context.initBuffer();
+  auto type = std::make_shared<const IntegerType>();
+  const uint32_t kNodeId = 4;
+  const uint32_t kColumnId = 2;
+  auto typeWithId = std::make_shared<const TypeWithId>(
+      type,
+      std::vector<std::unique_ptr<TypeWithId>>{},
+      /* id */ kNodeId,
+      /* maxId */ kNodeId,
+      /* column */ kColumnId);
+
+  // write
+  auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
+
+  writer->write(vector, common::Ranges::of(0, size));
+  writer->createIndexEntry();
+  proto::StripeFooter sf;
+  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
+    return *sf.add_encoding();
+  });
+
+  // get data stream
+  TestStripeStreams streams(context, sf, ROW({"foo"}, {type}), pool_.get());
+  DwrfStreamIdentifier si{
+      kNodeId, /* sequence */ 0, kColumnId, proto::Stream_Kind_DATA};
+  ASSERT_NE(streams.getStream(si, {}, false), nullptr);
+}
+
+template <typename T, bool isComplexTypeT>
+struct DictColumnWriterTestCase {
+  DictColumnWriterTestCase(size_t size, bool writeDirect, const TypePtr& type)
+      : size_(size), writeDirect_(writeDirect), type_(type) {}
+  const size_t size_;
+  const bool writeDirect_;
+  TypePtr type_;
+
+  BufferPtr randomIndices(vector_size_t size) {
+    BufferPtr indices =
+        AlignedBuffer::allocate<vector_size_t>(size, pool_.get());
+    auto rawIndices = indices->asMutable<vector_size_t>();
+    for (int32_t i = 0; i < size; i++) {
+      rawIndices[i] = folly::Random::rand32(size);
+    }
+    return indices;
+  }
+
+  /**
+   * Used to generate dictionary data for the non-complex columns
+   * @param size the number of rows
+   * @param valueAt the lambda generating values
+   * @param isNullAt the lambda generating nulls
+   * @return generated data as flat vector
+   */
+  FlatVectorPtr<T> makeFlatVector(
+      vector_size_t size,
+      std::function<T(vector_size_t /*index*/)> valueAt,
+      std::function<bool(vector_size_t /*index*/)> isNullAt = nullptr) {
+    auto vector = std::dynamic_pointer_cast<FlatVector<T>>(
+        BaseVector::create(type_, size, pool_.get()));
+    for (int32_t i = 0; i < size; ++i) {
+      if (isNullAt && isNullAt(i)) {
+        vector->setNull(i, true);
+      } else {
+        vector->set(i, valueAt(i));
+      }
+    }
+    return vector;
+  }
+
+  /**
+   * Used to only generate dictionary complex vector tests
+   * The data is generated randomly while the nulls are
+   * generated using a lambda.
+   * @param rowType the complex row type
+   * @param count the number of rows in the generated column
+   * @param isNullAt the bool lambda for generating nulls
+   * @return generated data as Row, Array or Map vectors.
+   */
+  VectorPtr makeComplexVectors(
+      const std::shared_ptr<const RowType> rowType,
+      int32_t count,
+      std::function<bool(vector_size_t /*index*/)> isNullAt) {
+    auto vector = std::dynamic_pointer_cast<RowVector>(
+        BatchMaker::createBatch(rowType, count, *pool_, isNullAt));
+    // Batch is returned as a RowVector and so we grab its first column
+    return vector->childAt(0);
+  }
+
+  /**
+   * Used to generate dicitionary data for the non-complex columns
+   * @param size the size the generated data (before dictionary)
+   * @param valueAt the lmbda generating values
+   * @param isNullAt the lambda generating nulls
+   * @param complexRowType only set if the data wil be complex (Row, Array or
+   * Map)
+   * @return
+   */
+  template <bool isComplexRowType = false>
+  VectorPtr createDictionaryBatch(
+      size_t size,
+      std::function<T(vector_size_t /*index*/)> valueAt,
+      std::function<bool(vector_size_t /*index*/)> isNullAt,
+      const std::shared_ptr<const RowType> complexRowType = nullptr) {
+    BufferPtr indices = randomIndices(size);
+    VectorPtr dictionaryVector;
+
+    VectorPtr flatVector;
+    if constexpr (isComplexRowType) {
+      flatVector = makeComplexVectors(complexRowType, size, isNullAt);
+    } else {
+      flatVector = makeFlatVector(size, valueAt, isNullAt);
+    }
+
+    auto wrappedVector = BaseVector::wrapInDictionary(
+        BufferPtr(nullptr), indices, size, flatVector);
+    EXPECT_EQ(wrappedVector->encoding(), VectorEncoding::Simple::DICTIONARY);
+    return wrappedVector;
+  }
+
+  void runTest(
+      std::function<T(vector_size_t /*index*/)> valueAt,
+      std::function<bool(vector_size_t /*index*/)> isNullAt = nullptr) {
+    auto config = std::make_shared<Config>();
+    auto typeWithId = TypeWithId::create(type_, 1);
+    auto rowType = ROW({type_});
+
+    WriterContext context{config, memory::memoryManager()->addRootPool()};
+    context.initBuffer();
+
+    VectorPtr batch;
+    if constexpr (isComplexTypeT) {
+      batch = createDictionaryBatch<true>(size_, valueAt, isNullAt, rowType);
+    } else {
+      batch = createDictionaryBatch<false>(size_, valueAt, isNullAt);
+    }
+
+    const auto writer = BaseColumnWriter::create(context, *typeWithId);
+
+    // Testing write direct paths
+    if (writeDirect_) {
+      writer->tryAbandonDictionaries(true);
+    }
+    writer->write(batch, common::Ranges::of(0, batch->size()));
+    writer->createIndexEntry();
+
+    proto::StripeFooter sf;
+    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
+      return *sf.add_encoding();
+    });
+
+    // Reading the vector out
+    TestStripeStreams streams(context, sf, rowType, pool_.get());
+    EXPECT_CALL(streams.getMockStrideIndexProvider(), getStrideIndex())
+        .WillRepeatedly(Return(0));
+    auto rowTypeWithId = TypeWithId::create(rowType);
+    auto reqType = rowTypeWithId->childAt(0);
+    memory::AllocationPool allocPool(pool_.get());
+    StreamLabels labels(allocPool);
+    auto reader =
+        ColumnReader::build(reqType, reqType, streams, labels, nullptr, 0);
+    VectorPtr out;
+    reader->next(batch->size(), out);
+    compareResults(batch, out);
+
+    context.nextStripe();
+    writer->reset();
+  }
+
+  void compareResults(VectorPtr& writeVector, VectorPtr& readVector) {
+    ASSERT_EQ(readVector->size(), writeVector->size());
+    for (int32_t i = 0; i < writeVector->size(); ++i) {
+      ASSERT_TRUE(readVector->equalValueAt(writeVector.get(), i, i))
+          << "at index " << i;
+    }
+  }
+
+  std::shared_ptr<MemoryPool> pool_ = memory::memoryManager()->addLeafPool();
+};
+
+std::function<bool(vector_size_t /*index*/)> randomNulls(int32_t n) {
+  return
+      [n](vector_size_t /*index*/) { return folly::Random::rand32() % n == 0; };
+}
+
+template <typename T, bool isComplexTypeT = false>
+void testDictionary(
+    const TypePtr& type,
+    std::function<bool(vector_size_t)> isNullAt = nullptr,
+    std::function<T(vector_size_t)> valueAt = nullptr) {
+  constexpr int32_t vectorSize = 200;
+
+  // Tests for null/non null data with direct or dict write
+  DictColumnWriterTestCase<T, isComplexTypeT>(vectorSize, true, type)
+      .runTest(valueAt, isNullAt);
+
+  DictColumnWriterTestCase<T, isComplexTypeT>(vectorSize, false, type)
+      .runTest(valueAt, isNullAt);
+
+  // Tests for non null data with direct or dict write
+  DictColumnWriterTestCase<T, isComplexTypeT>(vectorSize, true, type)
+      .runTest(valueAt, [](int) { return false; });
+
+  DictColumnWriterTestCase<T, isComplexTypeT>(vectorSize, false, type)
+      .runTest(valueAt, [](int) { return false; });
+}
+
+TEST_F(ColumnWriterTest, ColumnWriterDictionarySimple) {
+  testDictionary<Timestamp>(TIMESTAMP(), randomNulls(11), [](vector_size_t i) {
+    return Timestamp(i * 5, i * 2);
+  });
+
+  testDictionary<int64_t>(
+      BIGINT(), randomNulls(5), [](vector_size_t i) { return i % 5; });
+
+  testDictionary<int32_t>(
+      INTEGER(), randomNulls(9), [](vector_size_t i) { return i % 5; });
+
+  testDictionary<int16_t>(
+      SMALLINT(), randomNulls(11), [](vector_size_t i) { return i % 5; });
+
+  testDictionary<int8_t>(
+      TINYINT(), randomNulls(13), [](vector_size_t i) { return i % 5; });
+
+  testDictionary<float>(
+      REAL(), randomNulls(7), [](vector_size_t i) { return (i % 3) * 0.2; });
+
+  testDictionary<double>(
+      DOUBLE(), randomNulls(9), [](vector_size_t i) { return (i % 3) * 0.2; });
+
+  testDictionary<bool>(
+      BOOLEAN(), randomNulls(11), [](vector_size_t i) { return i % 2 == 0; });
+
+  testDictionary<StringView>(VARCHAR(), randomNulls(9), [](vector_size_t i) {
+    return StringView::makeInline("str" + std::to_string(i % 3));
+  });
+
+  testDictionary<StringView>(VARBINARY(), randomNulls(9), [](vector_size_t i) {
+    return StringView::makeInline("binary" + std::to_string(i % 3));
+  });
+};
+
+TEST_F(ColumnWriterTest, rowDictionary) {
+  // For complex data valueAt lambda is not set as the data is generated
+  // randomly
+
+  // Row tests
+  testDictionary<Row<int32_t>, true>(ROW({INTEGER()}), randomNulls(5));
+
+  testDictionary<Row<StringView, int32_t>, true>(
+      ROW({VARCHAR(), INTEGER()}), randomNulls(11));
+
+  testDictionary<Row<Row<StringView, int32_t>>, true>(
+      ROW({ROW({VARCHAR(), INTEGER()})}), randomNulls(11));
+
+  testDictionary<Row<int32_t, double, StringView>, true>(
+      ROW({INTEGER(), DOUBLE(), VARCHAR()}), randomNulls(5));
+
+  testDictionary<Row<int32_t, StringView, double, StringView>, true>(
+      ROW({INTEGER(), VARCHAR(), DOUBLE(), VARCHAR()}), randomNulls(5));
+
+  testDictionary<Row<Array<StringView>, StringView>, true>(
+      ROW({ARRAY(VARCHAR()), VARCHAR()}), randomNulls(11));
+
+  testDictionary<
+      Row<Map<int32_t, double>,
+          Array<Map<int32_t, Row<int32_t, double>>>,
+          Row<int32_t, StringView>>,
+      true>(
+      ROW(
+          {MAP(INTEGER(), DOUBLE()),
+           ARRAY(MAP(INTEGER(), ROW({INTEGER(), DOUBLE()}))),
+           ROW({INTEGER(), VARCHAR()})}),
+      randomNulls(11));
+}
+
+TEST_F(ColumnWriterTest, arrayDictionary) {
+  // Array tests
+  testDictionary<Array<float>, true>(ARRAY(REAL()), randomNulls(7));
+
+  testDictionary<
+      Row<Array<int32_t>, Row<StringView, Array<Map<StringView, StringView>>>>,
+      true>(
+      ROW(
+          {ARRAY(INTEGER()),
+           ROW({VARCHAR(), ARRAY(MAP(VARCHAR(), VARCHAR()))})}),
+      randomNulls(11));
+
+  testDictionary<
+      Array<Map<int32_t, Array<Map<int8_t, Row<StringView, Array<double>>>>>>,
+      true>(
+      ARRAY(MAP(
+          INTEGER(), ARRAY(MAP(TINYINT(), ROW({VARCHAR(), ARRAY(DOUBLE())}))))),
+      randomNulls(7));
+}
+
+TEST_F(ColumnWriterTest, mapDictionary) {
+  // Map tests
+  testDictionary<Map<int32_t, double>, true>(
+      MAP(INTEGER(), DOUBLE()), randomNulls(7));
+
+  testDictionary<Map<StringView, StringView>, true>(
+      MAP(VARCHAR(), VARCHAR()), randomNulls(13));
+
+  testDictionary<
+      Map<StringView,
+          Map<int32_t, Array<Row<int32_t, int32_t, Array<double>>>>>,
+      true>(
+      MAP(VARCHAR(),
+          MAP(INTEGER(), ARRAY(ROW({INTEGER(), INTEGER(), ARRAY(DOUBLE())})))),
+      randomNulls(9));
+
+  testDictionary<Map<int32_t, Map<StringView, Map<StringView, int8_t>>>, true>(
+      MAP(INTEGER(), MAP(VARCHAR(), MAP(VARCHAR(), TINYINT()))),
+      randomNulls(3));
+}
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/ColumnWriterTests.cpp b/velox/dwio/dwrf/test/ColumnWriterTests.cpp
deleted file mode 100644
index ff4579700b34d..0000000000000
--- a/velox/dwio/dwrf/test/ColumnWriterTests.cpp
+++ /dev/null
@@ -1,4537 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Random.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <algorithm>
-#include <optional>
-#include <vector>
-#include "velox/common/memory/Memory.h"
-#include "velox/dwio/common/IntDecoder.h"
-#include "velox/dwio/common/TypeWithId.h"
-#include "velox/dwio/common/exception/Exception.h"
-#include "velox/dwio/common/tests/utils/BatchMaker.h"
-#include "velox/dwio/common/tests/utils/MapBuilder.h"
-#include "velox/dwio/dwrf/common/DecoderUtil.h"
-#include "velox/dwio/dwrf/reader/DwrfReader.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
-#include "velox/type/Type.h"
-#include "velox/vector/DictionaryVector.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
-
-using namespace ::testing;
-using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::dwrf;
-using namespace facebook::velox::test;
-using namespace facebook::velox;
-using namespace facebook::velox::memory;
-using folly::Random;
-
-namespace facebook::velox::dwrf {
-
-class MockStrideIndexProvider : public StrideIndexProvider {
- public:
-  MOCK_CONST_METHOD0(getStrideIndex, uint64_t());
-};
-
-class MockStreamInformation : public StreamInformation {
- public:
-  explicit MockStreamInformation(const DwrfStreamIdentifier& streamIdentifier)
-      : streamIdentifier_{streamIdentifier} {}
-
-  StreamKind getKind() const override {
-    return streamIdentifier_.kind();
-  }
-
-  uint32_t getNode() const override {
-    return streamIdentifier_.encodingKey().node();
-  }
-
-  uint32_t getSequence() const override {
-    return streamIdentifier_.encodingKey().sequence();
-  }
-
-  MOCK_CONST_METHOD0(getOffset, uint64_t());
-  MOCK_CONST_METHOD0(getLength, uint64_t());
-  MOCK_CONST_METHOD0(getUseVInts, bool());
-  MOCK_CONST_METHOD0(valid, bool());
-
- private:
-  const DwrfStreamIdentifier& streamIdentifier_;
-};
-
-class TestStripeStreams : public StripeStreamsBase {
- public:
-  TestStripeStreams(
-      WriterContext& context,
-      const proto::StripeFooter& footer,
-      const std::shared_ptr<const RowType>& rowType,
-      MemoryPool* pool,
-      bool returnFlatVector = false,
-      std::unordered_map<uint32_t, std::vector<std::string>>
-          structReaderContext = {})
-      : StripeStreamsBase{pool},
-        context_{context},
-        footer_{footer},
-        selector_{rowType} {
-    options_.setReturnFlatVector(returnFlatVector);
-    if (!structReaderContext.empty()) {
-      options_.setFlatmapNodeIdsAsStruct(structReaderContext);
-    }
-  }
-
-  std::unique_ptr<SeekableInputStream> getStream(
-      const DwrfStreamIdentifier& si,
-      std::string_view /* label */,
-      bool throwIfNotFound) const override {
-    const DataBufferHolder* stream = nullptr;
-    if (context_.hasStream(si)) {
-      stream = std::addressof(context_.getStream(si));
-    }
-    if (!stream || stream->isSuppressed()) {
-      if (throwIfNotFound) {
-        DWIO_RAISE(fmt::format(
-            "stream (node = {}, seq = {}, column = {}, kind = {}) not found",
-            si.encodingKey().node(),
-            si.encodingKey().sequence(),
-            si.column(),
-            si.kind()));
-      } else {
-        return nullptr;
-      }
-    }
-
-    auto buf = std::make_unique<DataBuffer<char>>(
-        context_.getMemoryPool(MemoryUsageCategory::GENERAL), 0);
-    stream->spill(*buf);
-    auto compressed =
-        std::make_unique<SeekableArrayInputStream>(buf->data(), buf->size());
-    buffers_.push_back(std::move(buf));
-
-    return createDecompressor(
-        context_.compression(),
-        std::move(compressed),
-        context_.compressionBlockSize(),
-        getMemoryPool(),
-        si.toString());
-  }
-
-  const proto::ColumnEncoding& getEncoding(
-      const EncodingKey& ek) const override {
-    for (auto& enc : footer_.encoding()) {
-      if (ek.node() == enc.node() && ek.sequence() == enc.sequence()) {
-        return enc;
-      }
-    }
-    DWIO_RAISE("encoding not found");
-  }
-
-  uint32_t visitStreamsOfNode(
-      uint32_t node,
-      std::function<void(const StreamInformation&)> visitor) const override {
-    uint32_t count = 0;
-    context_.iterateUnSuppressedStreams([&](auto& pair) {
-      if (pair.first.encodingKey().node() == node) {
-        visitor(MockStreamInformation(pair.first));
-        ++count;
-      }
-    });
-
-    return count;
-  }
-
-  const ColumnSelector& getColumnSelector() const override {
-    return selector_;
-  }
-
-  const RowReaderOptions& getRowReaderOptions() const override {
-    return options_;
-  }
-
-  bool getUseVInts(const DwrfStreamIdentifier& streamId) const override {
-    DWIO_ENSURE(
-        context_.hasStream(streamId),
-        fmt::format("Stream not found: {}", streamId.toString()));
-    return context_.getConfig(Config::USE_VINTS);
-  }
-
-  const StrideIndexProvider& getStrideIndexProvider() const override {
-    return mockStrideIndexProvider_;
-  }
-
-  const StrictMock<MockStrideIndexProvider>& getMockStrideIndexProvider() {
-    return mockStrideIndexProvider_;
-  }
-
-  int64_t stripeRows() const override {
-    VELOX_UNSUPPORTED();
-  }
-
-  uint32_t rowsPerRowGroup() const override {
-    VELOX_UNSUPPORTED();
-  }
-
- private:
-  WriterContext& context_;
-  const proto::StripeFooter& footer_;
-  ColumnSelector selector_;
-  RowReaderOptions options_;
-  mutable std::vector<std::unique_ptr<DataBuffer<char>>> buffers_;
-  StrictMock<MockStrideIndexProvider> mockStrideIndexProvider_;
-};
-
-constexpr uint32_t ITERATIONS = 100'000;
-
-template <typename T>
-VectorPtr populateBatch(
-    std::vector<std::optional<T>> const& data,
-    MemoryPool* pool) {
-  BufferPtr values = AlignedBuffer::allocate<T>(data.size(), pool);
-  auto valuesPtr = values->asMutableRange<T>();
-
-  BufferPtr nulls = allocateNulls(data.size(), pool);
-  auto* nullsPtr = nulls->asMutable<uint64_t>();
-  size_t index = 0;
-  size_t nullCount = 0;
-  for (auto val : data) {
-    if (val) {
-      valuesPtr[index] = val.value();
-      bits::clearNull(nullsPtr, index);
-    } else {
-      bits::setNull(nullsPtr, index);
-      ++nullCount;
-    }
-    ++index;
-  }
-
-  auto batch = std::make_shared<FlatVector<T>>(
-      pool,
-      CppToType<T>::create(),
-      nulls,
-      data.size(),
-      values,
-      std::vector<BufferPtr>{});
-  batch->setNullCount(nullCount);
-  return batch;
-}
-
-template <typename T>
-void verifyValue(
-    const std::shared_ptr<FlatVector<T>>& fv,
-    size_t index,
-    T value,
-    const uint32_t seed,
-    bool* failed) {
-  *failed = value != fv->valueAt(index);
-  ASSERT_EQ(value, fv->valueAt(index))
-      << "value mismatch at " << index << " with seed " << seed;
-}
-
-template <>
-void verifyValue(
-    const std::shared_ptr<FlatVector<Timestamp>>& fv,
-    size_t index,
-    Timestamp timestamp,
-    const uint32_t seed,
-    bool* failed) {
-  *failed = true;
-  auto v = fv->valueAt(index);
-  if (timestamp.getNanos() > 0 && timestamp.getSeconds() == -1) {
-    // This value should be corrupted by Java Writer. Ensure that
-    // same behavior happens in the CPP as well. Look into
-    // the TimestampColumnWriter comment on the reason behind this.
-    ASSERT_EQ(v.getSeconds(), 0) << "Unexpected seconds" << v.getSeconds()
-                                 << " with index, seed " << index << seed;
-  } else {
-    ASSERT_EQ(v.getSeconds(), timestamp.getSeconds())
-        << "Seconds mismatch with index, seed " << index << seed;
-  }
-
-  ASSERT_EQ(v.getNanos(), timestamp.getNanos())
-      << "Nanos mismatch with index, seed " << index << seed;
-  *failed = false;
-}
-
-template <typename T>
-void verifyBatch(
-    std::vector<std::optional<T>> const& data,
-    const VectorPtr& out,
-    const std::optional<vector_size_t>& nullCount,
-    const uint32_t seed) {
-  auto size = data.size();
-  ASSERT_EQ(out->size(), size) << "Batch size mismatch with seed " << seed;
-  ASSERT_EQ(nullCount, out->getNullCount())
-      << "nullCount mismatch with seed " << seed;
-
-  auto outFv = std::dynamic_pointer_cast<FlatVector<T>>(out);
-  size_t index = 0;
-  for (auto val : data) {
-    bool failed = false;
-    if (val) {
-      ASSERT_FALSE(out->isNullAt(index))
-          << "null mismatch with index, seed " << index << seed;
-
-      if constexpr (std::is_floating_point_v<T>) {
-        // for floating point nan != nan
-        if (std::isnan(val.value())) {
-          ASSERT_TRUE(std::isnan(outFv->rawValues()[index]))
-              << "nan mismatch with seed " << seed;
-        } else {
-          verifyValue(outFv, index, val.value(), seed, &failed);
-        }
-      } else {
-        verifyValue(outFv, index, val.value(), seed, &failed);
-      }
-    } else {
-      ASSERT_TRUE(out->isNullAt(index)) << "null mismatch with seed " << seed;
-    }
-    ++index;
-    if (failed) {
-      break;
-    }
-  }
-}
-
-template <typename T>
-void testDataTypeWriter(
-    const TypePtr& type,
-    std::vector<std::optional<T>>& data,
-    const uint32_t sequence = 0) {
-  // Generate a seed and randomly shuffle the data
-  uint32_t seed = Random::rand32();
-  std::shuffle(data.begin(), data.end(), std::default_random_engine(seed));
-
-  auto config = std::make_shared<Config>();
-  auto pool = addDefaultLeafMemoryPool();
-  WriterContext context{config, defaultMemoryManager().addRootPool()};
-  auto rowType = ROW({type});
-  auto dataTypeWithId = TypeWithId::create(type, 1);
-
-  // write
-  auto writer = BaseColumnWriter::create(context, *dataTypeWithId, sequence);
-  auto size = data.size();
-  auto batch = populateBatch(data, pool.get());
-  const size_t stripeCount = 2;
-  const size_t strideCount = 3;
-
-  for (auto stripeI = 0; stripeI < stripeCount; ++stripeI) {
-    proto::StripeFooter sf;
-    for (auto strideI = 0; strideI < strideCount; ++strideI) {
-      writer->write(batch, common::Ranges::of(0, size));
-      writer->createIndexEntry();
-    }
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
-    });
-
-    TestStripeStreams streams(context, sf, rowType, pool.get());
-    auto typeWithId = TypeWithId::create(rowType);
-    auto reqType = typeWithId->childAt(0);
-
-    memory::AllocationPool allocPool(pool.get());
-    StreamLabels labels(allocPool);
-    auto reader = ColumnReader::build(
-        reqType,
-        reqType,
-        streams,
-        labels,
-        FlatMapContext{
-            .sequence = sequence,
-            .inMapDecoder = nullptr,
-            .keySelectionCallback = nullptr});
-    VectorPtr out;
-    for (auto strideI = 0; strideI < strideCount; ++strideI) {
-      reader->next(size, out);
-      verifyBatch(data, out, batch->getNullCount(), seed);
-    }
-    // Reader API requires the caller to read the Stripe for number of
-    // values and iterate only until that number.
-    // It does not support hasNext/next protocol.
-    // Use a bigger number like 50, as some values may be bit packed.
-    EXPECT_THROW({ reader->next(50, out); }, exception::LoggedException);
-
-    context.nextStripe();
-    writer->reset();
-  }
-}
-
-TEST(ColumnWriterTests, LowMemoryModeConfig) {
-  auto dataTypeWithId = TypeWithId::create(std::make_shared<VarcharType>(), 1);
-  auto config = std::make_shared<Config>();
-  WriterContext context{
-      config, facebook::velox::memory::defaultMemoryManager().addRootPool()};
-  auto writer = BaseColumnWriter::create(context, *dataTypeWithId);
-  EXPECT_TRUE(writer->useDictionaryEncoding());
-}
-
-TEST(ColumnWriterTests, TestBooleanWriter) {
-  std::vector<std::optional<bool>> data;
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    bool value = (bool)(Random::rand32() & 1);
-    data.emplace_back(value);
-  }
-  testDataTypeWriter(BOOLEAN(), data);
-
-  // Test writer with non-zero sequence
-  testDataTypeWriter(BOOLEAN(), data, 3);
-}
-
-TEST(ColumnWriterTests, TestNullBooleanWriter) {
-  std::vector<std::optional<bool>> data;
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    data.emplace_back();
-  }
-  testDataTypeWriter(BOOLEAN(), data);
-}
-
-TEST(ColumnWriterTests, TestTimestampEpochWriter) {
-  std::vector<std::optional<Timestamp>> data;
-  // This value will be corrupted. verified in verifyValue method.
-  data.emplace_back(Timestamp(-1, 1));
-  data.emplace_back(Timestamp(-1, MAX_NANOS));
-
-  // The following values should not be corrupted.
-  data.emplace_back(Timestamp(-1, 0));
-  data.emplace_back(Timestamp(0, 0));
-  data.emplace_back(Timestamp(0, 1));
-  data.emplace_back(Timestamp(0, MAX_NANOS));
-  testDataTypeWriter(TIMESTAMP(), data);
-}
-
-TEST(ColumnWriterTests, TestTimestampWriter) {
-  std::vector<std::optional<Timestamp>> data;
-  for (int64_t i = 0; i < ITERATIONS; ++i) {
-    Timestamp ts(i, i);
-    data.emplace_back(ts);
-  }
-  testDataTypeWriter(TIMESTAMP(), data);
-
-  // Test writer with non-zero sequence
-  testDataTypeWriter(TIMESTAMP(), data, 6);
-}
-
-TEST(ColumnWriterTests, TestTimestampBoundaryValuesWriter) {
-  std::vector<std::optional<Timestamp>> data;
-  for (int64_t i = 0; i < ITERATIONS; ++i) {
-    if (i & 1) {
-      Timestamp ts(Timestamp::kMaxSeconds, MAX_NANOS);
-      data.emplace_back(ts);
-    } else {
-      Timestamp ts(Timestamp::kMinSeconds, MAX_NANOS);
-      data.emplace_back(ts);
-    }
-    data.emplace_back();
-  }
-  testDataTypeWriter(TIMESTAMP(), data);
-}
-
-TEST(ColumnWriterTests, TestTimestampMixedWriter) {
-  std::vector<std::optional<Timestamp>> data;
-  for (int64_t i = 0; i < ITERATIONS; ++i) {
-    int64_t seconds = Random::rand64(Timestamp::kMaxSeconds);
-    int64_t nanos = Random::rand32(MAX_NANOS + 1);
-    Timestamp ts(seconds, nanos);
-    data.emplace_back(ts);
-    // Add null value
-    data.emplace_back();
-  }
-  testDataTypeWriter(TIMESTAMP(), data);
-}
-
-void verifyInvalidTimestamp(int64_t seconds, int64_t nanos) {
-  std::vector<std::optional<Timestamp>> data;
-  for (int64_t i = 1; i < ITERATIONS; ++i) {
-    Timestamp ts(i, i);
-    data.emplace_back(ts);
-  }
-  Timestamp ts(seconds, nanos);
-  data.emplace_back(ts);
-  EXPECT_THROW(
-      testDataTypeWriter(TIMESTAMP(), data), exception::LoggedException);
-}
-
-TEST(ColumnWriterTests, TestTimestampNullWriter) {
-  std::vector<std::optional<Timestamp>> data;
-  for (int64_t i = 0; i < ITERATIONS; ++i) {
-    data.emplace_back();
-  }
-  testDataTypeWriter(TIMESTAMP(), data);
-}
-
-TEST(ColumnWriterTests, TestBooleanMixedWriter) {
-  std::vector<std::optional<bool>> data;
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    bool value = (bool)(Random::rand32() & 1);
-    data.emplace_back(value);
-    data.emplace_back();
-  }
-  testDataTypeWriter(BOOLEAN(), data);
-}
-
-TEST(ColumnWriterTests, TestAllBytesWriter) {
-  std::vector<std::optional<int8_t>> data;
-  for (int16_t i = INT8_MIN; i <= INT8_MAX; ++i) {
-    data.emplace_back(i);
-  }
-  for (int16_t i = INT8_MAX; i >= INT8_MIN; --i) {
-    data.emplace_back(i);
-  }
-  testDataTypeWriter(TINYINT(), data);
-}
-
-TEST(ColumnWriterTests, TestRepeatedValuesByteWriter) {
-  std::vector<std::optional<int8_t>> data;
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    data.emplace_back(INT8_MIN);
-  }
-  testDataTypeWriter(TINYINT(), data);
-}
-
-TEST(ColumnWriterTests, TestOnlyNullByteWriter) {
-  std::vector<std::optional<int8_t>> data;
-  for (auto i = 0; i <= ITERATIONS; ++i) {
-    data.emplace_back();
-  }
-  testDataTypeWriter(TINYINT(), data);
-}
-
-TEST(ColumnWriterTests, TestByteNullAndExtremeValueMixed) {
-  std::vector<std::optional<int8_t>> data;
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    data.emplace_back(INT8_MIN);
-    data.emplace_back();
-    data.emplace_back(INT8_MAX);
-  }
-  testDataTypeWriter(TINYINT(), data);
-}
-
-template <typename T>
-void generateSampleData(std::vector<std::optional<T>>& data) {
-  const size_t size = 100;
-  for (size_t i = 0; i < size; ++i) {
-    if (i != 20 && i != 40) {
-      data.emplace_back(i);
-    } else {
-      data.emplace_back();
-    }
-    ASSERT_EQ(i != 20 && i != 40, data.at(i).has_value());
-  }
-}
-
-TEST(ColumnWriterTests, TestByteWriter) {
-  std::vector<std::optional<int8_t>> data;
-  generateSampleData(data);
-  testDataTypeWriter(TINYINT(), data);
-
-  // Test writer with non-zero sequence
-  testDataTypeWriter(TINYINT(), data, 5);
-}
-
-TEST(ColumnWriterTests, TestShortWriter) {
-  std::vector<std::optional<int16_t>> data;
-  generateSampleData(data);
-  testDataTypeWriter(SMALLINT(), data);
-
-  // Test writer with non-zero sequence
-  testDataTypeWriter(SMALLINT(), data, 23);
-}
-
-TEST(ColumnWriterTests, TestIntWriter) {
-  std::vector<std::optional<int32_t>> data;
-  generateSampleData(data);
-  testDataTypeWriter(INTEGER(), data);
-
-  // Test writer with non-zero sequence
-  testDataTypeWriter(INTEGER(), data, 1);
-}
-
-TEST(ColumnWriterTests, TestLongWriter) {
-  std::vector<std::optional<int64_t>> data;
-  generateSampleData(data);
-  testDataTypeWriter(BIGINT(), data);
-
-  // Test writer with non-zero sequence
-  testDataTypeWriter(BIGINT(), data, 42);
-}
-
-TEST(ColumnWriterTests, TestBinaryWriter) {
-  std::vector<std::optional<StringView>> data;
-  const size_t size = 100;
-  for (size_t i = 0; i < size; ++i) {
-    if (i != 20 && i != 40) {
-      data.emplace_back(StringView::makeInline(folly::to<std::string>(i)));
-    } else {
-      data.emplace_back();
-    }
-    ASSERT_EQ(i != 20 && i != 40, data.at(i).has_value());
-  }
-  testDataTypeWriter(VARBINARY(), data);
-
-  // Test writer with non-zero sequence
-  testDataTypeWriter(VARBINARY(), data, 42);
-}
-
-TEST(ColumnWriterTests, TestBinaryWriterAllNulls) {
-  std::vector<std::optional<StringView>> data{100};
-  testDataTypeWriter(VARBINARY(), data);
-}
-
-template <typename T>
-struct ValueOf {
-  static std::string get(const VectorPtr& batch, const uint32_t offset) {
-    auto scalarBatch = std::dynamic_pointer_cast<FlatVector<T>>(batch);
-    return std::to_string(scalarBatch->valueAt(offset));
-  }
-};
-
-template <>
-struct ValueOf<bool> {
-  static std::string get(const VectorPtr& batch, const uint32_t offset) {
-    auto scalarBatch = std::dynamic_pointer_cast<FlatVector<bool>>(batch);
-    return folly::to<std::string>(scalarBatch->valueAt(offset));
-  }
-};
-
-template <>
-struct ValueOf<StringView> {
-  static std::string get(const VectorPtr& batch, const uint32_t offset) {
-    auto scalarBatch = std::dynamic_pointer_cast<FlatVector<StringView>>(batch);
-    return scalarBatch->valueAt(offset).str();
-  }
-};
-
-template <typename keyT, typename valueT>
-struct ValueOf<Map<keyT, valueT>> {
-  static std::string get(const VectorPtr& batch, const uint32_t offset) {
-    auto mapBatch = std::dynamic_pointer_cast<MapVector>(batch);
-    return folly::to<std::string>(
-        "map at ",
-        offset,
-        " child: ",
-        mapBatch->offsetAt(offset),
-        ":",
-        mapBatch->sizeAt(offset));
-  }
-};
-
-template <typename elemT>
-struct ValueOf<Array<elemT>> {
-  static std::string get(const VectorPtr& batch, const uint32_t offset) {
-    auto arrayBatch = std::dynamic_pointer_cast<ArrayVector>(batch);
-    return folly::to<std::string>(
-        "array at ",
-        offset,
-        " child: ",
-        arrayBatch->offsetAt(offset),
-        ":",
-        arrayBatch->sizeAt(offset));
-  }
-};
-
-template <typename... T>
-struct ValueOf<Row<T...>> {
-  static std::string get(const VectorPtr& /* batch */, const uint32_t offset) {
-    return folly::to<std::string>("row at ", offset);
-  }
-};
-
-template <typename T>
-std::string getNullCountStr(const T& vector) {
-  return vector.getNullCount().has_value()
-      ? std::to_string(vector.getNullCount().value())
-      : "none";
-}
-
-template <typename TKEY, typename TVALUE>
-void printMap(const std::string& title, const VectorPtr& batch) {
-  auto mv = std::dynamic_pointer_cast<MapVector>(batch);
-  if (!mv) {
-    VLOG(3) << "To be implemented for encoded vector";
-    return;
-  }
-
-  VLOG(3) << "*******" << title << "*******";
-  VLOG(3) << "Size: " << mv->size() << ", Null count: " << getNullCountStr(*mv);
-  for (int32_t i = 0; i <= mv->size(); ++i) {
-    VLOG(3) << "Offset[" << i << "]: " << mv->offsetAt(i)
-            << (i < mv->size() && mv->isNullAt(i) ? " (null)" : "");
-  }
-
-  auto keys = mv->mapKeys();
-  auto values = mv->mapValues();
-
-  VLOG(3) << "Keys Size: " << keys->size()
-          << ", Keys Null count: " << getNullCountStr(*keys);
-  VLOG(3) << "Values Size: " << values->size()
-          << ", Values Null count: " << getNullCountStr(*values);
-
-  for (int32_t i = 0; i < keys->size(); ++i) {
-    VLOG(3) << "[" << i << "]: " << ValueOf<TKEY>::get(keys, i) << " -> "
-            << (values->isNullAt(i) ? "null" : ValueOf<TVALUE>::get(values, i));
-  }
-}
-
-void printRow(const std::string& title, const VectorPtr& batch) {
-  auto row = std::dynamic_pointer_cast<RowVector>(batch);
-  if (!row) {
-    VLOG(3) << "To be implemented for encoded vector";
-    return;
-  }
-
-  VLOG(3) << "*******" << title << "*******";
-  VLOG(3) << "Size: " << row->size()
-          << ", Null count: " << getNullCountStr(*row);
-  for (int i = 0; i < row->size(); i++) {
-    VLOG(3) << "[" << i << "]: " << row->toString(i);
-  }
-}
-
-VectorPtr
-wrapInDictionary(const VectorPtr& batch, size_t stride, MemoryPool& pool) {
-  VectorPtr ret = batch;
-  // Wrap key if least significant bit is 1
-  if (stride & 0x01) {
-    auto map = batch->as<MapVector>();
-    auto keys = map->mapKeys();
-    auto size = keys->size();
-
-    auto indices = AlignedBuffer::allocate<vector_size_t>(size, &pool);
-    auto rawIndices = indices->asMutable<vector_size_t>();
-    for (auto i = 0; i < size; ++i) {
-      rawIndices[i] = i;
-    }
-
-    ret = std::make_shared<MapVector>(
-        map->pool(),
-        map->type(),
-        map->nulls(),
-        map->size(),
-        map->offsets(),
-        map->sizes(),
-        BaseVector::wrapInDictionary(nullptr, indices, size, keys),
-        map->mapValues());
-  }
-
-  // Wrap map if 2nd least significant bit is 1
-  if (stride & 0x02) {
-    auto size = ret->size();
-
-    auto indices = AlignedBuffer::allocate<vector_size_t>(size, &pool);
-    auto rawIndices = indices->asMutable<vector_size_t>();
-    for (auto i = 0; i < size; ++i) {
-      rawIndices[i] = i;
-    }
-
-    ret = BaseVector::wrapInDictionary(nullptr, indices, size, ret);
-  }
-
-  return ret;
-}
-
-VectorPtr wrapInDictionaryRow(const VectorPtr& batch, MemoryPool& pool) {
-  auto row = batch->as<RowVector>();
-
-  auto size = row->size();
-  auto indices = AlignedBuffer::allocate<vector_size_t>(size, &pool);
-  auto rawIndices = indices->asMutable<vector_size_t>();
-  for (auto i = 0; i < size; i++) {
-    rawIndices[i] = i;
-  }
-
-  return BaseVector::wrapInDictionary(nullptr, indices, size, batch);
-}
-
-template <typename T>
-void getUniqueKeys(
-    std::vector<T>& uniqueKeys,
-    const std::vector<VectorPtr>& batches) {
-  std::unordered_set<T> seenKeys;
-
-  for (auto batch : batches) {
-    auto map = std::dynamic_pointer_cast<MapVector>(batch);
-    ASSERT_TRUE(map);
-    auto keys = map->mapKeys();
-    auto flatKeys = std::dynamic_pointer_cast<FlatVector<T>>(keys);
-    ASSERT_TRUE(flatKeys);
-    for (vector_size_t i = 0; i < flatKeys->size(); i++) {
-      ASSERT_TRUE(!flatKeys->isNullAt(i));
-      seenKeys.insert(flatKeys->valueAt(i));
-    }
-  }
-
-  uniqueKeys.clear();
-  uniqueKeys.insert(uniqueKeys.end(), seenKeys.cbegin(), seenKeys.cend());
-}
-
-template <typename TKEY, typename TVALUE>
-void mapToStruct(
-    MemoryPool& pool,
-    std::vector<VectorPtr>& batches,
-    const std::vector<TKEY>& uniqueKeys) {
-  std::unordered_map<TKEY, int> keyColIndex;
-  for (auto i = 0; i < uniqueKeys.size(); i++) {
-    keyColIndex[uniqueKeys[i]] = i; // lookup from key -> column#
-  }
-
-  for (size_t i = 0; i < batches.size(); i++) {
-    auto origBatch = batches[i];
-    std::vector<VectorPtr> childrenVectors(uniqueKeys.size());
-    // initialize children of batch size filled with nulls
-    VectorMaker maker{&pool};
-    for (auto column = 0; column < uniqueKeys.size(); column++) {
-      childrenVectors[column] =
-          maker.allNullFlatVector<TVALUE>(origBatch->size());
-      // only flat for scalar types
-      // create function to handle nested complex types
-    }
-    batches[i] = maker.rowVector(childrenVectors);
-    auto batchStruct = std::dynamic_pointer_cast<RowVector>(batches[i]);
-
-    auto mapBatch = std::dynamic_pointer_cast<MapVector>(origBatch);
-    ASSERT_TRUE(mapBatch);
-
-    auto keys = mapBatch->mapKeys();
-    auto flatKeys = std::dynamic_pointer_cast<FlatVector<TKEY>>(keys);
-    ASSERT_TRUE(flatKeys);
-    auto values = mapBatch->mapValues();
-    auto flatValues = std::dynamic_pointer_cast<FlatVector<TVALUE>>(values);
-    ASSERT_TRUE(flatValues);
-
-    auto offsets = mapBatch->offsets()->as<vector_size_t>();
-    auto sizes = mapBatch->sizes()->as<vector_size_t>();
-
-    // for each row in current batch
-    for (vector_size_t row = 0; row < mapBatch->size(); row++) {
-      // for each key in row (single map)
-      for (vector_size_t index = offsets[row],
-                         endOffset = offsets[row] + sizes[row];
-           index < endOffset;
-           index++) {
-        ASSERT_FALSE(flatKeys->isNullAt(index));
-        // set value in correct row
-        auto key = flatKeys->valueAt(index);
-        auto element = std::dynamic_pointer_cast<FlatVector<TVALUE>>(
-            batchStruct->childAt(keyColIndex[key]));
-        ASSERT_TRUE(element);
-        element->set(row, flatValues->valueAt(index));
-      }
-    }
-  }
-}
-
-template <typename TKEY, typename TVALUE>
-void testMapWriter(
-    MemoryPool& pool,
-    const std::vector<VectorPtr>& batches,
-    bool useFlatMap,
-    bool disableDictionaryEncoding,
-    bool testEncoded,
-    bool printMaps = true,
-    bool useStruct = false) {
-  const auto rowType = CppToType<Row<Map<TKEY, TVALUE>>>::create();
-  const auto dataType = rowType->childAt(0);
-  const auto rowTypeWithId = TypeWithId::create(rowType);
-  const auto dataTypeWithId = rowTypeWithId->childAt(0);
-  const auto writerSchema = TypeWithId::create(rowType);
-  const auto writerDataTypeWithId = writerSchema->childAt(0);
-
-  VLOG(2) << "Testing map writer " << dataType->toString() << " using "
-          << (useFlatMap ? "Flat Map" : "Regular Map")
-          << (useFlatMap && useStruct ? " - Struct" : "");
-
-  const auto config = std::make_shared<Config>();
-  auto* pBatches = &batches;
-  std::vector<VectorPtr> structs;
-  std::unordered_map<uint32_t, std::vector<std::string>> structReaderContext;
-  if (useFlatMap) {
-    if (useStruct) {
-      structs = batches;
-      pBatches = &structs;
-      std::vector<TKEY> uniqueKeys;
-      ASSERT_NO_FATAL_FAILURE(getUniqueKeys<TKEY>(uniqueKeys, batches));
-      ASSERT_NO_FATAL_FAILURE(
-          (mapToStruct<TKEY, TVALUE>(pool, structs, uniqueKeys)));
-
-      std::vector<std::string> uniqueKeysString;
-      uniqueKeysString.reserve(uniqueKeys.size());
-      std::transform(
-          uniqueKeys.cbegin(),
-          uniqueKeys.cend(),
-          std::back_inserter(uniqueKeysString),
-          [](const auto& e) { return folly::to<std::string>(e); });
-      ASSERT_EQ(writerDataTypeWithId->column(), 0);
-      config->set(Config::MAP_FLAT_COLS_STRUCT_KEYS, {uniqueKeysString});
-      structReaderContext[writerDataTypeWithId->id()] = uniqueKeysString;
-    }
-
-    config->set(Config::FLATTEN_MAP, true);
-    config->set(Config::MAP_FLAT_COLS, {writerDataTypeWithId->column()});
-    config->set(
-        Config::MAP_FLAT_DISABLE_DICT_ENCODING, disableDictionaryEncoding);
-
-    // expect that if we pass useStruct true with useFlatMap false, it will fail
-  }
-
-  WriterContext context{config, defaultMemoryManager().addRootPool()};
-  const auto writer = BaseColumnWriter::create(context, *writerDataTypeWithId);
-  // For writing flat map with encoded input, we'd like to test all 4
-  // combinations.
-  size_t strideCount = testEncoded ? 4 : 2;
-
-  // Each batch represents an input for a separate stripe
-  for (auto batch : *pBatches) {
-    auto isStruct = useFlatMap && useStruct;
-    if (printMaps) {
-      if (isStruct) {
-        printRow("Input", batch);
-      } else {
-        printMap<TKEY, TVALUE>("Input", batch);
-      }
-    }
-
-    proto::StripeFooter sf;
-    std::vector<VectorPtr> writtenBatches;
-
-    // Write map/row
-    for (auto strideI = 0; strideI < strideCount; ++strideI) {
-      auto toWrite = batch;
-      if (testEncoded) {
-        if (isStruct) {
-          toWrite = wrapInDictionaryRow(toWrite, pool);
-        } else {
-          toWrite = wrapInDictionary(toWrite, strideI, pool);
-        }
-      }
-      writer->write(toWrite, common::Ranges::of(0, toWrite->size()));
-      writer->createIndexEntry();
-      writtenBatches.push_back(toWrite);
-    }
-
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
-    });
-
-    auto validate = [&](bool returnFlatVector = false) {
-      TestStripeStreams streams(
-          context, sf, rowType, &pool, returnFlatVector, structReaderContext);
-      auto pool = addDefaultLeafMemoryPool();
-      memory::AllocationPool allocPool(pool.get());
-      StreamLabels labels(allocPool);
-      const auto reader =
-          ColumnReader::build(dataTypeWithId, dataTypeWithId, streams, labels);
-      VectorPtr out;
-
-      // Read map/row
-      for (auto& writtenBatch : writtenBatches) {
-        reader->next(writtenBatch->size(), out);
-        ASSERT_EQ(out->size(), writtenBatch->size()) << "Batch size mismatch";
-
-        if (printMaps) {
-          if (isStruct) {
-            printRow("Result", batch);
-          } else {
-            printMap<TKEY, TVALUE>("Result", out);
-          }
-        }
-
-        for (int32_t i = 0; i < writtenBatch->size(); ++i) {
-          ASSERT_TRUE(writtenBatch->equalValueAt(out.get(), i, i))
-              << "Row mismatch at index " << i;
-        }
-      }
-
-      // Reader API requires the caller to read the Stripe for number of
-      // values and iterate only until that number.
-      // It does not support hasNext/next protocol.
-      // Use a bigger number like 50, as some values may be bit packed.
-      EXPECT_THROW({ reader->next(50, out); }, exception::LoggedException);
-    };
-
-    ASSERT_NO_FATAL_FAILURE(validate());
-    if (useFlatMap) {
-      ASSERT_NO_FATAL_FAILURE(validate(true));
-    }
-
-    context.nextStripe();
-
-    auto valueNodeId = dataTypeWithId->childAt(1)->id();
-    auto streamCount = 0;
-    context.iterateUnSuppressedStreams([&](auto& pair) {
-      if (pair.first.encodingKey().node() == valueNodeId) {
-        ++streamCount;
-      }
-    });
-
-    ASSERT_GT(streamCount, 0) << "Expecting to find at least one value stream";
-
-    writer->reset();
-
-    streamCount = 0;
-    context.iterateUnSuppressedStreams([&](auto& pair) {
-      if (pair.first.encodingKey().node() == valueNodeId) {
-        ++streamCount;
-      }
-    });
-
-    if (useFlatMap) {
-      ASSERT_EQ(streamCount, 0)
-          << "Expecting all flat map value streams to be disposed";
-    } else {
-      ASSERT_GT(streamCount, 0)
-          << "Expecting to find at least one regular map value stream";
-    }
-  }
-}
-
-template <typename TVALUE>
-void testMapWriterRow(
-    MemoryPool& pool,
-    const std::vector<VectorPtr>& batches,
-    bool disableDictionaryEncoding,
-    bool testEncoded,
-    bool printInput = true) {
-  const auto rowType = CppToType<Row<Map<int32_t, TVALUE>>>::create();
-  const auto dataType = rowType->childAt(0);
-  const auto rowTypeWithId = TypeWithId::create(rowType);
-  const auto dataTypeWithId = rowTypeWithId->childAt(0);
-  const auto writerSchema = TypeWithId::create(rowType);
-  const auto writerDataTypeWithId = writerSchema->childAt(0);
-
-  VLOG(2) << "Testing map writer struct input " << dataType->toString();
-
-  const auto config = std::make_shared<Config>();
-  std::unordered_map<uint32_t, std::vector<std::string>> structReaderContext;
-  ASSERT_TRUE(batches.size() > 0);
-  auto row = std::dynamic_pointer_cast<RowVector>(batches[0]);
-  ASSERT_TRUE(row);
-
-  // defaulting to int32_t keys
-  std::vector<std::string> uniqueKeysString;
-  uniqueKeysString.reserve(row->childrenSize());
-  for (auto i = 0; i < row->childrenSize(); i++) {
-    uniqueKeysString.push_back(folly::to<std::string>(i));
-  }
-
-  ASSERT_EQ(writerDataTypeWithId->column(), 0);
-  config->set(Config::MAP_FLAT_COLS_STRUCT_KEYS, {uniqueKeysString});
-  structReaderContext[writerDataTypeWithId->id()] = uniqueKeysString;
-
-  config->set(Config::FLATTEN_MAP, true);
-  config->set(Config::MAP_FLAT_COLS, {writerDataTypeWithId->column()});
-  config->set(
-      Config::MAP_FLAT_DISABLE_DICT_ENCODING, disableDictionaryEncoding);
-
-  WriterContext context{config, defaultMemoryManager().addRootPool()};
-  const auto writer = BaseColumnWriter::create(context, *writerDataTypeWithId);
-
-  // Each batch represents an input for a separate stripe
-  for (auto batch : batches) {
-    if (printInput) {
-      printRow("Input", batch);
-    }
-
-    proto::StripeFooter sf;
-    std::vector<VectorPtr> writtenBatches;
-
-    // Write map/row
-    auto toWrite = batch;
-    if (testEncoded) {
-      toWrite = wrapInDictionaryRow(toWrite, pool);
-    }
-    writer->write(toWrite, common::Ranges::of(0, toWrite->size()));
-    writer->createIndexEntry();
-    writtenBatches.push_back(toWrite);
-
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
-    });
-
-    auto validate = [&](bool returnFlatVector = false) {
-      TestStripeStreams streams(
-          context, sf, rowType, &pool, returnFlatVector, structReaderContext);
-      auto pool = addDefaultLeafMemoryPool();
-      memory::AllocationPool allocPool(pool.get());
-      StreamLabels labels(allocPool);
-      const auto reader =
-          ColumnReader::build(dataTypeWithId, dataTypeWithId, streams, labels);
-      VectorPtr out;
-
-      // Read map/row
-      for (auto& writtenBatch : writtenBatches) {
-        reader->next(writtenBatch->size(), out);
-        ASSERT_EQ(out->size(), writtenBatch->size()) << "Batch size mismatch";
-
-        if (printInput) {
-          printRow("Result", batch);
-        }
-
-        for (int32_t i = 0; i < writtenBatch->size(); ++i) {
-          ASSERT_TRUE(writtenBatch->equalValueAt(out.get(), i, i))
-              << "Row mismatch at index " << i;
-        }
-      }
-
-      // Reader API requires the caller to read the Stripe for number of
-      // values and iterate only until that number.
-      // It does not support hasNext/next protocol.
-      // Use a bigger number like 50, as some values may be bit packed.
-      EXPECT_THROW({ reader->next(50, out); }, exception::LoggedException);
-    };
-
-    ASSERT_NO_FATAL_FAILURE(validate());
-    ASSERT_NO_FATAL_FAILURE(validate(true));
-
-    context.nextStripe();
-
-    auto valueNodeId = dataTypeWithId->childAt(1)->id();
-    auto streamCount = 0;
-    context.iterateUnSuppressedStreams([&](auto& pair) {
-      if (pair.first.encodingKey().node() == valueNodeId) {
-        ++streamCount;
-      }
-    });
-
-    ASSERT_GT(streamCount, 0) << "Expecting to find at least one value stream";
-
-    writer->reset();
-
-    streamCount = 0;
-    context.iterateUnSuppressedStreams([&](auto& pair) {
-      if (pair.first.encodingKey().node() == valueNodeId) {
-        ++streamCount;
-      }
-    });
-
-    ASSERT_EQ(streamCount, 0)
-        << "Expecting all flat map value streams to be disposed";
-  }
-}
-
-template <typename TVALUE>
-void testMapWriterRowImpl() {
-  auto type = CppToType<Row<TVALUE, TVALUE>>::create();
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = BatchMaker::createVector<TypeKind::ROW>(type, 10, *pool);
-
-  std::vector<VectorPtr> batches{batch, batch};
-
-  testMapWriterRow<TVALUE>(*pool, batches, true, false);
-  testMapWriterRow<TVALUE>(*pool, batches, true, true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterNestedRow) {
-  testMapWriterRowImpl<bool>();
-  testMapWriterRowImpl<Array<int32_t>>();
-  testMapWriterRowImpl<Array<bool>>();
-  testMapWriterRowImpl<Array<StringView>>();
-  testMapWriterRowImpl<Map<int32_t, bool>>();
-  testMapWriterRowImpl<Map<int32_t, int32_t>>();
-  testMapWriterRowImpl<Map<int32_t, StringView>>();
-  testMapWriterRowImpl<Map<int32_t, Array<int32_t>>>();
-  testMapWriterRowImpl<Map<int32_t, Map<int32_t, StringView>>>();
-  testMapWriterRowImpl<Map<int32_t, Row<int32_t, bool, StringView>>>();
-  testMapWriterRowImpl<Row<int32_t, bool, StringView>>();
-}
-
-template <typename TKEY, typename TVALUE>
-void testMapWriter(
-    MemoryPool& pool,
-    const VectorPtr& batch,
-    bool useFlatMap,
-    bool printMaps = true,
-    bool useStruct = false) {
-  std::vector<VectorPtr> batches{batch, batch};
-  testMapWriter<TKEY, TVALUE>(
-      pool, batches, useFlatMap, true, false, printMaps, useStruct);
-  if (useFlatMap) {
-    testMapWriter<TKEY, TVALUE>(
-        pool, batches, useFlatMap, false, false, printMaps, useStruct);
-    testMapWriter<TKEY, TVALUE>(
-        pool, batches, useFlatMap, true, true, printMaps, useStruct);
-  }
-}
-
-template <typename T>
-void testMapWriterNumericKey(bool useFlatMap, bool useStruct = false) {
-  using b = MapBuilder<T, T>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = b::create(
-      *pool,
-      {typename b::row{
-           typename b::pair{std::numeric_limits<T>::max(), 3},
-           typename b::pair{2, std::numeric_limits<T>::max()}},
-       typename b::row{
-           typename b::pair{2, 5},
-           typename b::pair{
-               std::numeric_limits<T>::min(), std::numeric_limits<T>::min()}}});
-
-  testMapWriter<T, T>(*pool, batch, useFlatMap, true, useStruct);
-}
-
-TEST(ColumnWriterTests, TestMapWriterFloatKey) {
-  testMapWriterNumericKey<float>(/* useFlatMap */ false);
-
-  EXPECT_THROW(
-      { testMapWriterNumericKey<float>(/* useFlatMap */ true); },
-      exception::LoggedException);
-
-  EXPECT_THROW(
-      {
-        testMapWriterNumericKey<float>(
-            /* useFlatMap */ true, /* useStruct */ true);
-      },
-      exception::LoggedException);
-}
-
-TEST(ColumnWriterTests, TestMapWriterInt64Key) {
-  testMapWriterNumericKey<int64_t>(/* useFlatMap */ false);
-  testMapWriterNumericKey<int64_t>(/* useFlatMap */ true);
-  testMapWriterNumericKey<int64_t>(/* useFlatMap */ true, /* useStruct */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterInt32Key) {
-  testMapWriterNumericKey<int32_t>(/* useFlatMap */ false);
-  testMapWriterNumericKey<int32_t>(/* useFlatMap */ true);
-  testMapWriterNumericKey<int32_t>(/* useFlatMap */ true, /* useStruct */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterInt16Key) {
-  testMapWriterNumericKey<int16_t>(/* useFlatMap */ false);
-  testMapWriterNumericKey<int16_t>(/* useFlatMap */ true);
-  testMapWriterNumericKey<int16_t>(/* useFlatMap */ true, /* useStruct */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterInt8Key) {
-  testMapWriterNumericKey<int8_t>(/* useFlatMap */ false);
-  testMapWriterNumericKey<int8_t>(/* useFlatMap */ true);
-  testMapWriterNumericKey<int8_t>(/* useFlatMap */ true, /* useStruct */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterStringKey) {
-  using keyType = StringView;
-  using valueType = StringView;
-  using b = MapBuilder<keyType, valueType>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = b::create(
-      *pool,
-      {b::row{b::pair{"1", "3"}, b::pair{"2", "2"}},
-       b::row{b::pair{"2", "5"}, b::pair{"3", "8"}}});
-
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ true);
-  testMapWriter<keyType, valueType>(
-      *pool, batch, /* useFlatMap */ true, true, /* useStruct */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterDifferentNumericKeyValue) {
-  using keyType = float;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = b::create(
-      *pool,
-      {b::row{b::pair{1, 3}, b::pair{2, 2}},
-       b::row{b::pair{2, 5}, b::pair{3, 8}}});
-
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
-}
-
-TEST(ColumnWriterTests, TestMapWriterDifferentKeyValue) {
-  using keyType = float;
-  using valueType = StringView;
-  using b = MapBuilder<keyType, valueType>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = b::create(
-      *pool,
-      {b::row{b::pair{1, "3"}, b::pair{2, "2"}},
-       b::row{b::pair{2, "5"}, b::pair{3, "8"}}});
-
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
-}
-
-TEST(ColumnWriterTests, TestMapWriterMixedBatchTypeHandling) {
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  using valueType2 = StringView;
-  using b2 = MapBuilder<keyType, valueType2>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch1 = b::create(
-      *pool,
-      {b::row{b::pair{1, 3}, b::pair{2, 2}},
-       b::row{b::pair{5, 5}, b::pair{3, 4}, b::pair{2, 5}}});
-
-  auto batch2 = b2::create(
-      *pool,
-      {b2::row{b2::pair{8, "3"}, b2::pair{6, "2"}},
-       b2::row{b2::pair{20, "5"}, b2::pair{2, "4"}, b2::pair{63, "5"}}});
-
-  std::vector<VectorPtr> batches{batch1, batch2};
-  // Test type cast assertion in the direct encoding case.
-  // TODO(T91654228): Check and throw for non-homogeneous batch types
-  // when dictionary encoding is enabled.
-  EXPECT_THROW(
-      (testMapWriter<keyType, valueType>(
-          *pool,
-          batches,
-          /* useFlatMap */ true,
-          true,
-          false)),
-      exception::LoggedException);
-}
-
-TEST(ColumnWriterTests, TestMapWriterBinaryKey) {
-  using keyType = StringView;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = b::create(
-      *pool,
-      {b::row{b::pair{"1", 3}, b::pair{"2", 2}},
-       b::row{b::pair{"2", 5}, b::pair{"3", 8}}});
-
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ true);
-  testMapWriter<keyType, valueType>(
-      *pool, batch, /* useFlatMap */ true, true, /* useStruct */ true);
-}
-
-template <typename keyType, typename valueType>
-void testMapWriterImpl() {
-  auto type = CppToType<Map<keyType, valueType>>::create();
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = BatchMaker::createVector<TypeKind::MAP>(type, 100, *pool);
-
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterNestedMap) {
-  testMapWriterImpl<int32_t, bool>();
-  testMapWriterImpl<int32_t, Array<int32_t>>();
-  testMapWriterImpl<int32_t, Array<bool>>();
-  testMapWriterImpl<int32_t, Array<StringView>>();
-  testMapWriterImpl<int32_t, Map<int32_t, bool>>();
-  testMapWriterImpl<int32_t, Map<int32_t, int32_t>>();
-  testMapWriterImpl<int32_t, Map<int32_t, StringView>>();
-  testMapWriterImpl<int32_t, Map<int32_t, Array<int32_t>>>();
-  testMapWriterImpl<int32_t, Map<int32_t, Map<int32_t, StringView>>>();
-  testMapWriterImpl<int32_t, Map<int32_t, Row<int32_t, bool, StringView>>>();
-  testMapWriterImpl<int32_t, Row<int32_t, bool, StringView>>();
-}
-
-TEST(ColumnWriterTests, TestMapWriterDifferentStripeBatches) {
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch1 = b::create(
-      *pool,
-      {b::row{b::pair{1, 3}, b::pair{2, 2}},
-       b::row{b::pair{5, 5}, b::pair{3, 4}, b::pair{2, 5}}});
-
-  auto batch2 = b::create(
-      *pool,
-      {b::row{b::pair{8, 3}, b::pair{6, 2}},
-       b::row{b::pair{20, 5}, b::pair{2, 4}, b::pair{63, 5}}});
-
-  std::vector<VectorPtr> batches{batch1, batch2};
-
-  testMapWriter<keyType, valueType>(
-      *pool,
-      batches,
-      /* useFlatMap */ false,
-      false,
-      false);
-  testMapWriter<keyType, valueType>(
-      *pool,
-      batches,
-      /* useFlatMap */ true,
-      false,
-      false);
-}
-
-TEST(ColumnWriterTests, TestMapWriterNullValues) {
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = b::create(
-      *pool,
-      {b::row{b::pair{1, std::nullopt}, b::pair{2, 2}},
-       b::row{b::pair{5, 5}, b::pair{3, std::nullopt}, b::pair{2, 5}}});
-
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterNullRows) {
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = b::create(
-      *pool,
-      {std::nullopt,
-       b::row{b::pair{1, 3}, b::pair{2, 2}},
-       std::nullopt,
-       b::row{b::pair{2, 5}},
-       std::nullopt});
-
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterDuplicateKeys) {
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  auto pool = addDefaultLeafMemoryPool();
-  auto batch = b::create(
-      *pool,
-      {
-          b::row{b::pair{1, 3}, b::pair{1, 2}},
-      });
-
-  // Default map writer doesn't throw on duplicate keys
-  // TODO: Is there a way to easily detect duplicate keys in MapColumnWriter?
-  testMapWriter<keyType, valueType>(*pool, batch, /* useFlatMap */ false);
-  EXPECT_THROW(
-      (testMapWriter<keyType, valueType>(*pool, batch, true)),
-      exception::LoggedException);
-}
-
-TEST(ColumnWriterTests, TestMapWriterBigBatch) {
-  using keyType = int32_t;
-  using valueType = float;
-  using b = MapBuilder<keyType, valueType>;
-
-  const auto size = 1000;
-  const auto maxDictionarySize = 50;
-  const auto nullEvery = 10;
-
-  auto pool = addDefaultLeafMemoryPool();
-  b::rows rows;
-  for (int32_t i = 0; i < size; ++i) {
-    if ((i % nullEvery) == 0) {
-      rows.push_back(std::nullopt);
-    }
-    const auto rowCount = Random::rand32(maxDictionarySize) + 1;
-    const auto randomStart = Random::rand32(10);
-    b::row row;
-    for (int32_t j = 0; j < rowCount; j++) {
-      row.push_back(b::pair{randomStart + j, Random::randDouble(0, 50)});
-    }
-
-    rows.push_back(row);
-  }
-
-  auto batch = b::create(*pool, rows);
-  testMapWriter<keyType, valueType>(
-      *pool,
-      batch,
-      /* useFlatMap */ false);
-  testMapWriter<keyType, valueType>(
-      *pool,
-      batch,
-      /* useFlatMap */ true);
-}
-
-TEST(ColumnWriterTests, TestMapWriterUnalignedKeyValueCount) {
-  auto pool = addDefaultLeafMemoryPool();
-  VectorMaker maker(pool.get());
-  auto keys = maker.flatVector<int64_t>(11, folly::identity);
-  auto values = maker.flatVector<int64_t>(12, folly::identity);
-  auto offsets = allocateIndices(3, pool.get());
-  auto sizes = allocateIndices(3, pool.get());
-
-  for (int i = 0; i < 3; ++i) {
-    offsets->asMutable<vector_size_t>()[i] = 3 * i;
-    sizes->asMutable<vector_size_t>()[i] = 3;
-  }
-  auto batch = std::make_shared<MapVector>(
-      pool.get(),
-      MAP(BIGINT(), BIGINT()),
-      nullptr,
-      3,
-      offsets,
-      sizes,
-      keys,
-      values);
-  testMapWriter<int64_t, int64_t>(*pool, batch, false);
-  testMapWriter<int64_t, int64_t>(*pool, batch, true);
-
-  for (int i = 0; i < 3; ++i) {
-    offsets->asMutable<vector_size_t>()[i] = 4 * i;
-    sizes->asMutable<vector_size_t>()[i] = 4;
-  }
-  batch = std::make_shared<MapVector>(
-      pool.get(),
-      MAP(BIGINT(), BIGINT()),
-      nullptr,
-      3,
-      offsets,
-      sizes,
-      keys,
-      values);
-  ASSERT_THROW(
-      (testMapWriter<int64_t, int64_t>(*pool, batch, false)),
-      exception::LoggedException);
-  ASSERT_THROW(
-      (testMapWriter<int64_t, int64_t>(*pool, batch, true)),
-      exception::LoggedException);
-}
-
-TEST(ColumnWriterTests, TestStructKeysConfigSerializationDeserialization) {
-  const std::vector<std::vector<std::string>> columns{
-      {"1.45", "hi, you;", "29102819", "1e-4"},
-      {"291", "world"},
-      {},
-      {"one", ", more", "\"two'three$"}};
-  const auto config = std::make_shared<Config>();
-  config->set<decltype(columns)>(Config::MAP_FLAT_COLS_STRUCT_KEYS, columns);
-  EXPECT_EQ(config->get(Config::MAP_FLAT_COLS_STRUCT_KEYS), columns);
-}
-
-std::unique_ptr<DwrfReader> getDwrfReader(
-    MemoryPool& rootPool,
-    MemoryPool& leafPool,
-    const std::shared_ptr<const RowType> type,
-    const VectorPtr& batch,
-    bool useFlatMap) {
-  auto config = std::make_shared<Config>();
-  if (useFlatMap) {
-    config->set(Config::FLATTEN_MAP, true);
-    config->set(Config::MAP_FLAT_COLS, {0});
-  }
-
-  auto sink = std::make_unique<MemorySink>(
-      2 * 1024 * 1024, dwio::common::FileSink::Options{.pool = &leafPool});
-  auto sinkPtr = sink.get();
-
-  dwrf::WriterOptions options;
-  options.config = config;
-  options.schema = type;
-  options.flushPolicyFactory = [&]() {
-    return std::make_unique<LambdaFlushPolicy>([]() {
-      return true; // Flushes every batch.
-    });
-  };
-  options.memoryPool = &rootPool;
-  dwrf::Writer writer{std::move(sink), options};
-  writer.write(batch);
-  writer.close();
-
-  std::string_view data(sinkPtr->data(), sinkPtr->size());
-  dwio::common::ReaderOptions readerOpts{&leafPool};
-  return std::make_unique<DwrfReader>(
-      readerOpts,
-      std::make_unique<BufferedInput>(
-          std::make_shared<InMemoryReadFile>(data),
-          readerOpts.getMemoryPool()));
-}
-
-void removeSizeFromStats(std::string& input) {
-  // FlatMap and Map, Serializes the data differently. Size is the sum of
-  // all Serialized Stream and hence they don't match. Remove the Size
-  // and value from the String used for comparison.
-  auto firstPos = input.find(" Size:");
-  ASSERT_NE(firstPos, std::string::npos) << " Size not found in " << input;
-  auto endPos = input.find(",", firstPos);
-  ASSERT_NE(endPos, std::string::npos) << " , not found after Size " << input;
-  input.erase(firstPos, (endPos + 1) - firstPos);
-}
-
-void testMapWriterStats(const std::shared_ptr<const RowType> type) {
-  auto rootPool = defaultMemoryManager().addRootPool();
-  auto leafPool = addDefaultLeafMemoryPool();
-  auto batch = BatchMaker::createBatch(type, 10, *leafPool);
-  auto mapReader = getDwrfReader(*rootPool, *leafPool, type, batch, false);
-  auto flatMapReader = getDwrfReader(*rootPool, *leafPool, type, batch, true);
-  ASSERT_EQ(
-      mapReader->getFooter().statisticsSize(),
-      flatMapReader->getFooter().statisticsSize());
-
-  for (int32_t i = 0; i < mapReader->getFooter().statisticsSize(); ++i) {
-    LOG(INFO) << "Stats " << i
-              << "     map: " << mapReader->columnStatistics(i)->toString();
-    LOG(INFO) << "Stats " << i
-              << " flatmap: " << flatMapReader->columnStatistics(i)->toString();
-    auto mapReaderStatString = mapReader->columnStatistics(i)->toString();
-    auto flatMapReaderStatString =
-        flatMapReader->columnStatistics(i)->toString();
-
-    removeSizeFromStats(mapReaderStatString);
-    removeSizeFromStats(flatMapReaderStatString);
-    ASSERT_EQ(mapReaderStatString, flatMapReaderStatString);
-  }
-}
-
-TEST(ColumnWriterTests, TestMapWriterCompareStatsBinaryKey) {
-  using keyType = Varbinary;
-  // We create a complex map with complex value structure to test that value
-  // aggregation work well in flat maps
-  const auto type = CppToType<Row<
-      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
-
-  testMapWriterStats(type);
-}
-
-TEST(ColumnWriterTests, TestMapWriterCompareStatsStringKey) {
-  using keyType = std::string;
-  // We create a complex map with complex value structure to test that value
-  // aggregation work well in flat maps
-  const auto type = CppToType<Row<
-      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
-
-  testMapWriterStats(type);
-}
-
-TEST(ColumnWriterTests, TestMapWriterCompareStatsInt8Key) {
-  using keyType = int8_t;
-
-  // We create a complex map with complex value structure to test that value
-  // aggregation work well in flat maps
-  const auto type = CppToType<Row<
-      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
-
-  testMapWriterStats(type);
-}
-
-TEST(ColumnWriterTests, TestMapWriterCompareStatsInt16Key) {
-  using keyType = int16_t;
-
-  // We create a complex map with complex value structure to test that value
-  // aggregation work well in flat maps
-  const auto type = CppToType<Row<
-      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
-
-  testMapWriterStats(type);
-}
-
-TEST(ColumnWriterTests, TestMapWriterCompareStatsInt32Key) {
-  using keyType = int32_t;
-
-  // We create a complex map with complex value structure to test that value
-  // aggregation work well in flat maps
-  const auto type = CppToType<Row<
-      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
-
-  testMapWriterStats(type);
-}
-
-TEST(ColumnWriterTests, TestMapWriterCompareStatsInt64Key) {
-  using keyType = int64_t;
-
-  // We create a complex map with complex value structure to test that value
-  // aggregation work well in flat maps
-  const auto type = CppToType<Row<
-      Map<keyType, Row<int32_t, Row<std::string, Array<int16_t>>>>>>::create();
-
-  testMapWriterStats(type);
-}
-
-template <typename type>
-void testFractionalWrite(const TypePtr& t) {
-  std::vector<std::optional<type>> data;
-  generateSampleData(data);
-  testDataTypeWriter(t, data);
-}
-
-TEST(ColumnWriterTests, TestFloatWriter) {
-  testFractionalWrite<float>(REAL());
-}
-
-TEST(ColumnWriterTests, TestDoubleWriter) {
-  testFractionalWrite<double>(DOUBLE());
-}
-
-template <typename type>
-void testFractionalInfinityWrite(const TypePtr& t) {
-  std::vector<std::optional<type>> data;
-  type infinity = std::numeric_limits<type>::infinity();
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    data.emplace_back(infinity);
-  }
-  testDataTypeWriter(t, data);
-}
-
-TEST(ColumnWriterTests, TestFloatInfinityWriter) {
-  testFractionalInfinityWrite<float>(REAL());
-}
-
-TEST(ColumnWriterTests, TestDoubleInfinityWriter) {
-  testFractionalInfinityWrite<double>(DOUBLE());
-}
-
-template <typename type>
-void testFractionalNegativeInfinityWrite(const TypePtr& t) {
-  std::vector<std::optional<type>> data;
-  type negativeInfinity = -std::numeric_limits<type>::infinity();
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    data.emplace_back(negativeInfinity);
-  }
-  testDataTypeWriter(t, data);
-}
-
-TEST(ColumnWriterTests, TestFloatNegativeInfinityWriter) {
-  testFractionalNegativeInfinityWrite<float>(REAL());
-}
-
-TEST(ColumnWriterTests, TestDoubleNegativeInfinityWriter) {
-  testFractionalNegativeInfinityWrite<double>(DOUBLE());
-}
-
-template <typename type>
-void testFractionalNaNWrite(const TypePtr& t) {
-  std::vector<std::optional<type>> data;
-  type nan = -std::numeric_limits<type>::quiet_NaN();
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    data.emplace_back(nan);
-  }
-  testDataTypeWriter(t, data);
-}
-
-TEST(ColumnWriterTests, TestFloatNanWriter) {
-  testFractionalNaNWrite<float>(REAL());
-}
-
-TEST(ColumnWriterTests, TestDoubleNanWriter) {
-  testFractionalNaNWrite<double>(DOUBLE());
-}
-
-template <typename type>
-void testFractionalNullWrite(const TypePtr& t) {
-  std::vector<std::optional<type>> data;
-  for (auto i = 0; i < ITERATIONS; ++i) {
-    data.emplace_back();
-  }
-  testDataTypeWriter(t, data);
-}
-
-TEST(ColumnWriterTests, TestFloatAllNullWriter) {
-  testFractionalNullWrite<float>(REAL());
-}
-
-TEST(ColumnWriterTests, TestDoubleAllNullWriter) {
-  testFractionalNullWrite<double>(DOUBLE());
-}
-
-template <typename type>
-void testFractionalMixedWrite(const TypePtr& t) {
-  std::vector<std::optional<type>> data;
-  type nan = -std::numeric_limits<type>::quiet_NaN();
-  type negativeInfinity = -std::numeric_limits<type>::infinity();
-  type infinity = std::numeric_limits<type>::infinity();
-  type max = std::numeric_limits<type>::max();
-  type min = std::numeric_limits<type>::lowest();
-  for (auto i = 0; i < 10'000; ++i) {
-    data.emplace_back(nan);
-    data.emplace_back();
-    data.emplace_back(negativeInfinity);
-    data.emplace_back(infinity);
-    data.emplace_back(i);
-    data.emplace_back(min);
-    data.emplace_back(max);
-  }
-  testDataTypeWriter(t, data);
-}
-
-TEST(ColumnWriterTests, TestFloatMixedWriter) {
-  testFractionalMixedWrite<float>(REAL());
-}
-
-TEST(ColumnWriterTests, TestDoubleMixedWriter) {
-  testFractionalMixedWrite<double>(DOUBLE());
-}
-
-// This generation method is skewed due to double precision. However, this
-// does not really matter - it would generate enough distinct values across
-// the range for reasonable sizes. Tests for sizes bigger than the positive
-// numeric range don't require a precise behavior for dinstinct value
-// generation anyway since it overflows the dictionary.
-int64_t generateRangeWithCustomLimits(
-    size_t i,
-    size_t size,
-    int64_t lowest,
-    int64_t max) {
-  // Explicitly include the numeric limits.
-  if (i == 0) {
-    return lowest;
-  }
-  if (i == size - 1) {
-    return max;
-  }
-  auto interval = -2 * folly::to<double>(lowest) / size;
-  // Generate the range such that we have similar amounts of values generated
-  // for each exponent.
-  double center = size % 2 ? -0.5 : interval / 2 - 0.5;
-  double value = center + (i - size / 2) * interval;
-  // Return a guard-railed value with the numeric limits.
-  // NOTE: There can be a more compact way to write this if we cast i and size
-  // to signed types, but it's not worth the effort enforcing the assumptions.
-  if (i < size / 2) {
-    auto distance = (size / 2 - i) * interval;
-    return std::max(center - distance, folly::to<double>(lowest));
-  } else {
-    auto distance = (i - size / 2) * interval;
-    return std::min(center + distance + 1, -folly::to<double>(lowest)) - 1;
-  }
-}
-
-template <typename Integer>
-Integer generateRangeWithLimits(size_t i, size_t size) {
-  auto lowest = std::numeric_limits<Integer>::lowest();
-  auto max = std::numeric_limits<Integer>::max();
-  return generateRangeWithCustomLimits(i, size, lowest, max);
-}
-
-int64_t generateSomewhatRandomPositiveData(
-    size_t i,
-    size_t size,
-    int64_t /* unused */,
-    int64_t /* unused */) {
-  return size % (i + 1);
-}
-
-int64_t generateSomewhatRandomData(
-    size_t i,
-    size_t size,
-    int64_t /* unused */,
-    int64_t /* unused */) {
-  int64_t val = size % (i + 1);
-  return i % 2 ? val : -val;
-}
-
-template <typename Integer>
-Integer generateSomewhatRandomDataTyped(size_t i, size_t size) {
-  int64_t val = size % (i + 1);
-  return i % 2 ? val : -val;
-}
-
-// This really is a placeholder method. In most practical cases, the PRESENT
-// stream would just be empty if there are no nulls in the stripe.
-bool noNulls(size_t /* unused */, size_t /* unused */) {
-  return true;
-}
-
-bool noNullsWithStride(
-    size_t /* unused */,
-    size_t /* unused */,
-    size_t /* unused */) {
-  return true;
-}
-
-bool allNulls(size_t /* unused */, size_t /* unused */) {
-  return false;
-}
-
-bool allNullsWithStride(
-    size_t /* unused */,
-    size_t /* unused */,
-    size_t /* unused */) {
-  return false;
-}
-
-bool someNulls(size_t i, size_t size) {
-  return (size % (i + 1)) % 2;
-}
-
-bool someNullsWithStride(size_t /* unused */, size_t i, size_t size) {
-  return (size % (i + 1)) % 2;
-}
-
-std::function<void(ColumnWriter&, size_t, size_t)> checkAbandonDict(
-    const std::function<bool(size_t, size_t)>& callTryAbandonDict,
-    bool force,
-    const std::function<bool(size_t, size_t)>& abandonDictSuccess) {
-  return [callTryAbandonDict, force, abandonDictSuccess](
-             ColumnWriter& columnWriter, size_t stripeCount, size_t repCount) {
-    if (callTryAbandonDict(stripeCount, repCount)) {
-      EXPECT_EQ(
-          abandonDictSuccess(stripeCount, repCount),
-          columnWriter.tryAbandonDictionaries(force));
-    }
-  };
-}
-
-void noPostProcessing(
-    ColumnWriter& /* unused */,
-    size_t /* unused */,
-    size_t /* unused */) {}
-
-bool neverAbandonDict(size_t /* unused */, size_t /* unused */) {
-  return false;
-}
-
-std::function<bool(size_t, size_t)> abandonNthWriteForStripe(
-    size_t stripeIndex,
-    size_t n) {
-  return [stripeIndex, n](size_t stripeCount, size_t repCount) {
-    return stripeCount == stripeIndex && repCount == n;
-  };
-}
-
-bool abandonEveryWrite(size_t /* unused */, size_t /* unused */) {
-  return true;
-}
-
-std::function<bool(size_t, size_t)> successAtNthWriteForStripe(
-    size_t stripeIndex,
-    size_t n) {
-  return [stripeIndex, n](size_t stripeCount, size_t repCount) {
-    return stripeCount == stripeIndex && repCount == n;
-  };
-}
-
-bool noSuccess(size_t /* unused */, size_t /* unused */) {
-  return false;
-}
-
-// A type erasure runner for the different test types.
-struct TestRunner {
-  template <typename T>
-  /* implicit */ TestRunner(const T& test)
-      : test_{std::make_shared<Test<T>>(test)} {}
-
-  void runTest() const {
-    test_->runTest();
-  }
-
-  struct TestInterface {
-    virtual ~TestInterface() = default;
-    virtual void runTest() const = 0;
-  };
-
-  template <typename T>
-  struct Test : public TestInterface {
-    explicit Test(const T& test) : test_{test} {}
-    void runTest() const override {
-      test_.runTest();
-    }
-
-   private:
-    T test_;
-  };
-
- private:
-  std::shared_ptr<const TestInterface> test_;
-};
-
-template <typename Integer>
-struct IntegerColumnWriterTypedTestCase {
-  const size_t size;
-  const bool writeDirect;
-  const float dictionaryWriteThreshold;
-  const size_t finalDictionarySize;
-  const std::function<Integer(size_t, size_t)> genData;
-  const bool hasNulls;
-  const std::function<bool(size_t, size_t)> genNulls;
-  const std::function<void(ColumnWriter&, size_t, size_t)> postProcess;
-  const size_t repetitionCount;
-  const size_t flushCount;
-
-  IntegerColumnWriterTypedTestCase(
-      size_t size,
-      bool writeDirect,
-      float dictionaryWriteThreshold,
-      size_t finalDictionarySize,
-      const std::function<Integer(size_t, size_t)>& genData,
-      bool hasNulls,
-      const std::function<bool(size_t, size_t)>& genNulls,
-      const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : size{size},
-        writeDirect{writeDirect},
-        dictionaryWriteThreshold{dictionaryWriteThreshold},
-        finalDictionarySize{finalDictionarySize},
-        genData{genData},
-        hasNulls{hasNulls},
-        genNulls{genNulls},
-        postProcess{postProcess},
-        repetitionCount{repetitionCount},
-        flushCount{flushCount} {}
-
-  virtual ~IntegerColumnWriterTypedTestCase() = default;
-
-  void runTest() const {
-    auto type = CppToType<Integer>::create();
-    auto typeWithId = TypeWithId::create(type, 1);
-    auto pool = addDefaultLeafMemoryPool();
-
-    // Prepare input
-    BufferPtr nulls = allocateNulls(size, pool.get());
-    auto* nullsPtr = nulls->asMutable<uint64_t>();
-    size_t nullCount = 0;
-
-    BufferPtr values = AlignedBuffer::allocate<Integer>(size, pool.get());
-    auto* valuesPtr = values->asMutable<Integer>();
-
-    for (size_t i = 0; i != size; ++i) {
-      bool isPresent = genNulls(i, size);
-      if (hasNulls && !isPresent) {
-        bits::setNull(nullsPtr, i);
-        valuesPtr[i] = 0;
-        nullCount++;
-      } else {
-        bits::clearNull(nullsPtr, i);
-        valuesPtr[i] = genData(i, size);
-      }
-    }
-
-    // Randomly shuffle the input, based on a seed to verify more
-    // combinations.
-    uint32_t seed = Random::rand32();
-
-    std::mt19937 gen;
-    gen.seed(seed);
-    for (size_t i = 0; i != size; ++i) {
-      size_t j = Random::rand32(i, size, gen);
-      if (i != j) {
-        std::swap(valuesPtr[i], valuesPtr[j]);
-        auto tmp = bits::isBitNull(nullsPtr, i);
-        bits::setNull(nullsPtr, i, bits::isBitNull(nullsPtr, j));
-        bits::setNull(nullsPtr, j, tmp);
-      }
-    }
-
-    auto batch = std::make_shared<FlatVector<Integer>>(
-        pool.get(),
-        CppToType<Integer>::create(),
-        nulls,
-        size,
-        values,
-        std::vector<BufferPtr>());
-    batch->setNullCount(nullCount);
-
-    // Set up writer.
-    auto config = std::make_shared<Config>();
-    config->set(
-        Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD,
-        dictionaryWriteThreshold);
-    WriterContext context{config, defaultMemoryManager().addRootPool()};
-    // Register root node.
-    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
-
-    for (size_t i = 0; i != flushCount; ++i) {
-      proto::StripeFooter stripeFooter;
-      for (size_t j = 0; j != repetitionCount; ++j) {
-        columnWriter->write(batch, common::Ranges::of(0, batch->size()));
-        postProcess(*columnWriter, i, j);
-        columnWriter->createIndexEntry();
-      }
-      // We only flush once per stripe.
-      columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
-          });
-
-      // Read and verify.
-      const size_t nodeId = 1;
-      auto rowType = ROW({{"integral_column", type}});
-      TestStripeStreams streams(context, stripeFooter, rowType, pool.get());
-      EncodingKey key{nodeId};
-      const auto& encoding = streams.getEncoding(key);
-      if (writeDirect) {
-        ASSERT_EQ(
-            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DIRECT,
-            encoding.kind());
-      } else {
-        ASSERT_EQ(
-            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY,
-            encoding.kind());
-        ASSERT_EQ(finalDictionarySize, encoding.dictionarysize());
-      }
-
-      auto reqType = TypeWithId::create(rowType)->childAt(0);
-      memory::AllocationPool allocPool(pool.get());
-      StreamLabels labels(allocPool);
-      auto columnReader =
-          ColumnReader::build(reqType, reqType, streams, labels);
-
-      for (size_t j = 0; j != repetitionCount; ++j) {
-        // TODO Make reuse work
-        VectorPtr resultBatch;
-        columnReader->next(size, resultBatch);
-        auto resultIv =
-            std::dynamic_pointer_cast<FlatVector<Integer>>(resultBatch);
-        std::vector<Integer> resultVec{
-            resultIv->rawValues(), resultIv->rawValues() + resultIv->size()};
-        ASSERT_EQ(batch->size(), resultBatch->size());
-        ASSERT_EQ(batch->getNullCount(), resultBatch->getNullCount());
-        if (!batch->getNullCount().has_value() ||
-            batch->getNullCount().value() > 0) {
-          // Normalizing the null values so that we can leverage gtest
-          // matchers later for better failure dumps.
-          for (size_t k = 0; k != batch->size(); ++k) {
-            if (batch->isNullAt(k)) {
-              resultVec[k] = 0;
-            }
-          }
-          for (size_t k = 0; k < batch->size(); k++) {
-            EXPECT_EQ(batch->isNullAt(k), resultBatch->isNullAt(k));
-          }
-        }
-        EXPECT_THAT(
-            resultVec,
-            ElementsAreArray(batch->rawValues(), resultBatch->size()));
-      }
-      context.nextStripe();
-      columnWriter->reset();
-    }
-  }
-};
-
-template <typename Integer>
-struct TypedDictionaryEncodingTestCase
-    : public IntegerColumnWriterTypedTestCase<Integer> {
-  TypedDictionaryEncodingTestCase(
-      size_t size,
-      float dictionaryWriteThreshold,
-      size_t finalDictionarySize,
-      const std::function<Integer(size_t, size_t)>& genData,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : IntegerColumnWriterTypedTestCase<Integer>{
-            size,
-            false,
-            dictionaryWriteThreshold,
-            finalDictionarySize,
-            genData,
-            false,
-            noNulls,
-            noPostProcessing,
-            repetitionCount,
-            flushCount} {}
-};
-
-// Even as the dictionary size threshold allows, we might not end up writing
-// with dictionary encoding.
-template <typename Integer>
-struct TypedDirectEncodingTestCase
-    : public IntegerColumnWriterTypedTestCase<Integer> {
-  TypedDirectEncodingTestCase(
-      size_t size,
-      float dictionaryWriteThreshold,
-      const std::function<Integer(size_t, size_t)>& genData,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : IntegerColumnWriterTypedTestCase<Integer>{
-            size,
-            true,
-            dictionaryWriteThreshold,
-            0,
-            genData,
-            false,
-            noNulls,
-            noPostProcessing,
-            repetitionCount,
-            flushCount} {}
-};
-
-struct IntegerColumnWriterUniversalTestCase {
-  IntegerColumnWriterTypedTestCase<int16_t> int16tTestCase;
-  IntegerColumnWriterTypedTestCase<int32_t> int32tTestCase;
-  IntegerColumnWriterTypedTestCase<int64_t> int64tTestCase;
-
-  IntegerColumnWriterUniversalTestCase(
-      size_t size,
-      bool writeDirect,
-      float dictionaryWriteThreshold,
-      size_t finalDictionarySize,
-      const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-      bool hasNulls,
-      const std::function<bool(size_t, size_t)>& genNulls,
-      const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : int16tTestCase{size, writeDirect, dictionaryWriteThreshold, finalDictionarySize, coerceGenData<int16_t>(genData), hasNulls, genNulls, postProcess, repetitionCount, flushCount},
-        int32tTestCase{
-            size,
-            writeDirect,
-            dictionaryWriteThreshold,
-            finalDictionarySize,
-            coerceGenData<int32_t>(genData),
-            hasNulls,
-            genNulls,
-            postProcess,
-            repetitionCount,
-            flushCount},
-        int64tTestCase{
-            size,
-            writeDirect,
-            dictionaryWriteThreshold,
-            finalDictionarySize,
-            coerceGenData<int64_t>(genData),
-            hasNulls,
-            genNulls,
-            postProcess,
-            repetitionCount,
-            flushCount} {}
-
-  virtual ~IntegerColumnWriterUniversalTestCase() = default;
-
-  template <typename Integer>
-  std::function<Integer(size_t, size_t)> coerceGenData(
-      const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData) {
-    return [=](size_t i, size_t size) -> Integer {
-      return genData(
-          i,
-          size,
-          std::numeric_limits<Integer>::lowest(),
-          std::numeric_limits<Integer>::max());
-    };
-  }
-
-  void runTest() const {
-    int16tTestCase.runTest();
-    int32tTestCase.runTest();
-    int64tTestCase.runTest();
-  }
-};
-
-// Test cases that would end up writing with dictionary encoding
-struct IntegerColumnWriterDictionaryEncodingUniversalTestCase
-    : public IntegerColumnWriterUniversalTestCase {
-  IntegerColumnWriterDictionaryEncodingUniversalTestCase(
-      size_t size,
-      float dictionaryWriteThreshold,
-      size_t finalDictionarySize,
-      const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-      bool hasNulls,
-      const std::function<bool(size_t, size_t)>& genNulls,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : IntegerColumnWriterUniversalTestCase{
-            size,
-            false,
-            dictionaryWriteThreshold,
-            finalDictionarySize,
-            genData,
-            hasNulls,
-            genNulls,
-            noPostProcessing,
-            repetitionCount,
-            flushCount} {}
-};
-
-// Universal test cases that would end up writing with direct encoding.
-struct IntegerColumnWriterDirectEncodingUniversalTestCase
-    : public IntegerColumnWriterUniversalTestCase {
-  IntegerColumnWriterDirectEncodingUniversalTestCase(
-      size_t size,
-      float dictionaryWriteThreshold,
-      const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-      bool hasNulls,
-      const std::function<bool(size_t, size_t)>& genNulls,
-      const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : IntegerColumnWriterUniversalTestCase{
-            size,
-            true,
-            dictionaryWriteThreshold,
-            0,
-            genData,
-            hasNulls,
-            genNulls,
-            postProcess,
-            repetitionCount,
-            flushCount} {}
-};
-
-TEST(ColumnWriterTests, IntegerTypeDictionaryEncodingWrites) {
-  struct TestCase
-      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
-    TestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
-              size,
-              1.0,
-              finalDictionarySize,
-              genData,
-              false,
-              noNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      // No values in dictionary.
-      TestCase{1000, 0, generateRangeWithCustomLimits},
-      // Mixture of values in dictionary vs not.
-      TestCase{1000, 201, generateSomewhatRandomData},
-      // Test repeated writes. All values are in dictionary.
-      TestCase{1000, 617, generateSomewhatRandomData, 20},
-      // Test repeated writes and flushes with mixture of values in
-      // dictionary.
-      // Tests independence of dictionary encoding writes across stripes. (In
-      // other words, whether the dictionary is cleared across stripes.)
-      TestCase{1000, 201, generateSomewhatRandomData, 1, 10},
-      // Test repeated writes and flushes. All values are in dictionary.
-      TestCase{1000, 617, generateSomewhatRandomData, 2, 10},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerTypeDictionaryEncodingWritesWithNulls) {
-  struct DictionaryEncodingTestCase
-      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<bool(size_t, size_t)>& genNulls,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
-              size,
-              1.0,
-              finalDictionarySize,
-              genData,
-              true,
-              genNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  // Even as the dictionary size threshold allows, we might not end up writing
-  // with dictionary encoding.
-  struct DirectEncodingTestCase
-      : public IntegerColumnWriterDirectEncodingUniversalTestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<bool(size_t, size_t)>& genNulls,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDirectEncodingUniversalTestCase{
-              size,
-              1.0,
-              genData,
-              true,
-              genNulls,
-              noPostProcessing,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      // When all values are null, we don't try to write dictionary at all.
-      DirectEncodingTestCase{1000, generateRangeWithCustomLimits, allNulls},
-      // No values in dictionary.
-      DictionaryEncodingTestCase{
-          1000, 0, generateRangeWithCustomLimits, someNulls},
-      // Mixture of values in dictionary vs not.
-      DictionaryEncodingTestCase{
-          1000, 62, generateSomewhatRandomData, someNulls},
-      // Test repeated writes. All values are in dictionary.
-      DictionaryEncodingTestCase{
-          1000, 250, generateSomewhatRandomData, someNulls, 20},
-      // Test repeated writes and flushes with mixture of values in
-      // dictionary.
-      // Tests independence of dictionary encoding writes across stripes. (In
-      // other words, whether the dictionary is cleared across stripes.)
-      DictionaryEncodingTestCase{
-          1000, 62, generateSomewhatRandomData, someNulls, 1, 10},
-      // Test repeated writes and flushes. All values are in dictionary.
-      DictionaryEncodingTestCase{
-          1000, 250, generateSomewhatRandomData, someNulls, 2, 10},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerTypeDictionaryEncodingHugeWrites) {
-  struct TestCase
-      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
-    TestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
-              size,
-              1.0,
-              finalDictionarySize,
-              genData,
-              false,
-              noNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      // We hit each distinct value in int16_t more than once.
-      TypedDictionaryEncodingTestCase<int16_t>{
-          1000000,
-          1.0,
-          -2 * std::numeric_limits<int16_t>::lowest(),
-          generateRangeWithLimits<int16_t>},
-      TypedDictionaryEncodingTestCase<int32_t>{
-          1000000, 1.0, 0, generateRangeWithLimits<int32_t>},
-      TypedDictionaryEncodingTestCase<int64_t>{
-          1000000, 1.0, 0, generateRangeWithLimits<int64_t>},
-      // Mixture of values in dictionary vs not. Out of range for int16_t.
-      TypedDictionaryEncodingTestCase<int32_t>{
-          1000000, 1.0, 201668, generateSomewhatRandomDataTyped<int32_t>},
-      TypedDictionaryEncodingTestCase<int64_t>{
-          1000000, 1.0, 201668, generateSomewhatRandomDataTyped<int64_t>},
-  };
-
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-// Split test to avoid sandcastle timeouts.
-TEST(ColumnWriterTests, IntegerTypeDictionaryEncodingHugeRepeatedWrites) {
-  struct TestCase
-      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
-    TestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
-              size,
-              1.0,
-              finalDictionarySize,
-              genData,
-              false,
-              noNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      // Test repeated writes. All values are in dictionary.
-      TestCase{1000, 617, generateSomewhatRandomData, 1000},
-      // Test repeated writes and flushes with mixture of values in
-      // dictionary.
-      // Tests independence of dictionary encoding writes across stripes. (In
-      // other words, whether the dictionary is cleared across stripes.)
-      TestCase{1000, 201, generateSomewhatRandomData, 1, 1000},
-      // Test repeated writes and flushes. All values are in dictionary.
-      TestCase{1000, 617, generateSomewhatRandomData, 2, 500},
-  };
-
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerTypeDirectEncodingWrites) {
-  struct TestCase : public IntegerColumnWriterDirectEncodingUniversalTestCase {
-    TestCase(
-        size_t size,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDirectEncodingUniversalTestCase{
-              size,
-              0.0,
-              genData,
-              false,
-              noNulls,
-              noPostProcessing,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      TestCase{1000, generateRangeWithCustomLimits},
-      TestCase{1000, generateSomewhatRandomData},
-      TestCase{1000, generateSomewhatRandomData, 20},
-      // Note, writes from the second stripe on uses direct encoding from the
-      // get-go.
-      // TODO: reinforce that the subsequent writes go through the right code
-      // path when we have more granular memory tracking.
-      TestCase{1000, generateSomewhatRandomData, 1, 10},
-      TestCase{1000, generateSomewhatRandomData, 2, 10},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerTypeDirectEncodingWritesWithNulls) {
-  struct TestCase : public IntegerColumnWriterDirectEncodingUniversalTestCase {
-    TestCase(
-        size_t size,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<bool(size_t, size_t)>& genNulls,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDirectEncodingUniversalTestCase{
-              size,
-              0.0,
-              genData,
-              true,
-              genNulls,
-              noPostProcessing,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      TestCase{1000, generateRangeWithCustomLimits, allNulls},
-      TestCase{1000, generateRangeWithCustomLimits, someNulls},
-      TestCase{1000, generateSomewhatRandomData, someNulls},
-      TestCase{1000, generateSomewhatRandomData, someNulls, 20},
-      // Note, writes from the second stripe on uses direct encoding from the
-      // get-go.
-      // TODO: reinforce that the subsequent writes go through the right code
-      // path when we have more granular memory tracking.
-      TestCase{1000, generateSomewhatRandomData, someNulls, 1, 10},
-      TestCase{1000, generateSomewhatRandomData, someNulls, 2, 10},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerTypeDirectEncodingHugeWrites) {
-  struct TestCase : public IntegerColumnWriterDirectEncodingUniversalTestCase {
-    TestCase(
-        size_t size,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDirectEncodingUniversalTestCase{
-              size,
-              0.0,
-              genData,
-              false,
-              noNulls,
-              noPostProcessing,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      // Everything is straight forward for direct encoding writes, so no
-      // special casing needed for types.
-      TestCase{1000000, generateRangeWithCustomLimits},
-      TestCase{1000000, generateSomewhatRandomData},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-// Split test to avoid sandcastle timeouts.
-TEST(ColumnWriterTests, IntegerTypeDirectEncodingHugeRepeatedWrites) {
-  struct TestCase : public IntegerColumnWriterDirectEncodingUniversalTestCase {
-    TestCase(
-        size_t size,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDirectEncodingUniversalTestCase{
-              size,
-              0.0,
-              genData,
-              false,
-              noNulls,
-              noPostProcessing,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      // Test repeated writes.
-      TestCase{1000, generateSomewhatRandomData, 1000},
-      // Note, writes from the second stripe on uses direct encoding from the
-      // get-go.
-      // TODO: reinforce that the subsequent writes go through the right code
-      // path when we have more granular memory tracking.
-      TestCase{1000, generateSomewhatRandomData, 1, 1000},
-      TestCase{1000, generateSomewhatRandomData, 2, 500},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerTypeDictionaryWriteThreshold) {
-  struct DictionaryEncodingTestCase
-      : public IntegerColumnWriterDictionaryEncodingUniversalTestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        float dictionarySizeThreshold,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDictionaryEncodingUniversalTestCase{
-              size,
-              dictionarySizeThreshold,
-              finalDictionarySize,
-              genData,
-              false,
-              noNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  struct DirectEncodingTestCase
-      : public IntegerColumnWriterDirectEncodingUniversalTestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        float dictionarySizeThreshold,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDirectEncodingUniversalTestCase{
-              size,
-              dictionarySizeThreshold,
-              genData,
-              false,
-              noNulls,
-              noPostProcessing,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  struct DirectEncodingTestCaseAllNulls
-      : public IntegerColumnWriterDirectEncodingUniversalTestCase {
-    DirectEncodingTestCaseAllNulls(
-        size_t size,
-        float dictionarySizeThreshold,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterDirectEncodingUniversalTestCase{
-              size,
-              dictionarySizeThreshold,
-              genData,
-              true,
-              allNulls,
-              noPostProcessing,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      // All nulls should use direct encoding regardless.
-      DirectEncodingTestCaseAllNulls{1000, 1.0, generateRangeWithCustomLimits},
-      // No value in dictionary.
-      DirectEncodingTestCase{1000, 0.75, generateRangeWithCustomLimits},
-      DictionaryEncodingTestCase{1000, 1.0, 0, generateRangeWithCustomLimits},
-      // Dict size is exactly 50.
-      DictionaryEncodingTestCase{
-          100, 0.5, 24, generateSomewhatRandomPositiveData},
-      // Fails with a threshold that is the slightest amount under possible.
-      DirectEncodingTestCase{
-          100,
-          0.5 - std::numeric_limits<float>::epsilon(),
-          generateSomewhatRandomPositiveData},
-      // All values are in dictionary in repeated writes.
-      DirectEncodingTestCase{
-          1000,
-          0.5 - std::numeric_limits<float>::epsilon(),
-          generateRangeWithCustomLimits,
-          2},
-      DictionaryEncodingTestCase{
-          1000,
-          0.5 - std::numeric_limits<float>::epsilon(),
-          1000,
-          generateRangeWithCustomLimits,
-          4},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerColumnWriterAbandonDictionaries) {
-  struct TestCase : public IntegerColumnWriterUniversalTestCase {
-    TestCase(
-        size_t size,
-        bool writeDirect,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount,
-        size_t flushCount)
-        : IntegerColumnWriterUniversalTestCase{
-              size,
-              writeDirect,
-              1.0f,
-              finalDictionarySize,
-              genData,
-              false,
-              noNulls,
-              postProcess,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  struct DirectEncodingTestCase : public TestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ true,
-              /* finalDictionarySize */ 0,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  struct DictionaryEncodingTestCase : public TestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ false,
-              finalDictionarySize,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  std::vector<TestRunner> testCases{
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          10},
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          1,
-          10},
-      // Test abandoning dictionary in multi-write scenarios. For now we could
-      // only abandon dictionary starting from the first stripe, because we
-      // could not switch up encoding of a writer once determined.
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          2,
-          5},
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 1)),
-          2,
-          5},
-      // We shouldn't be able to switch encodings beyond the first stripe.
-      DictionaryEncodingTestCase{
-          1000,
-          /* finalDictionarySize */ 1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(1, 0), /* force */ true, noSuccess),
-          2,
-          5},
-      // Abandoning at every write to make sure subsequent abandon dict calls
-      // are safe.
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          10},
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          1,
-          10},
-  };
-
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerColumnWriterAbandonDictionariesWithNulls) {
-  struct TestCase : public IntegerColumnWriterUniversalTestCase {
-    TestCase(
-        size_t size,
-        bool writeDirect,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount,
-        size_t flushCount)
-        : IntegerColumnWriterUniversalTestCase{
-              size,
-              writeDirect,
-              1.0f,
-              finalDictionarySize,
-              genData,
-              true,
-              someNulls,
-              postProcess,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  struct DirectEncodingTestCase : public TestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ true,
-              /* finalDictionarySize */ 0,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  struct DictionaryEncodingTestCase : public TestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ false,
-              finalDictionarySize,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  std::vector<TestRunner> testCases{
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          10},
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          1,
-          10},
-      // Test abandoning dictionary in multi-write scenarios. For now we could
-      // only abandon dictionary starting from the first stripe, because we
-      // could not switch up encoding of a writer once determined.
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          2,
-          5},
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 1)),
-          2,
-          5},
-      // We shouldn't be able to switch encodings beyond the first stripe.
-      DictionaryEncodingTestCase{
-          1000,
-          /* finalDictionarySize */ 341,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(1, 0), /* force */ true, noSuccess),
-          2,
-          5},
-      // Abandoning at every write to make sure subsequent abandon dict calls
-      // are safe.
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          10},
-      DirectEncodingTestCase{
-          1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          1,
-          10},
-  };
-
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntegerColumnWriterAbandonLowValueDictionaries) {
-  struct TestCase : public IntegerColumnWriterUniversalTestCase {
-    TestCase(
-        size_t size,
-        bool writeDirect,
-        float dictionaryWriteThreshold,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : IntegerColumnWriterUniversalTestCase{
-              size,
-              writeDirect,
-              dictionaryWriteThreshold,
-              finalDictionarySize,
-              genData,
-              false,
-              noNulls,
-              postProcess,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  struct DirectEncodingTestCase : public TestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        float dictionaryWriteThreshold,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ true,
-              dictionaryWriteThreshold,
-              /* finalDictionarySize */ 0,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  struct DictionaryEncodingTestCase : public TestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        float dictionaryWriteThreshold,
-        size_t finalDictionarySize,
-        const std::function<int64_t(size_t, size_t, int64_t, int64_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ false,
-              dictionaryWriteThreshold,
-              finalDictionarySize,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  std::vector<TestRunner> testCases{
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 1.0f,
-          /* finalDictionarySize */ 1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 10},
-      // finalDictionarySize == 0 because in each stripe
-      // each value only appeared once.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 1.0f,
-          /* finalDictionarySize */ 0,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 1,
-          /* stripeCount */ 10},
-      DirectEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 0.4f,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ false,
-              successAtNthWriteForStripe(0, 1)),
-          /* repCount */ 10},
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 0.4f,
-          /* finalDictionarySize */ 1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 2),
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 10},
-      // Test abandoning dictionary in multi-write scenarios. For now we could
-      // only abandon dictionary starting from the first stripe, because we
-      // could not switch up encoding of a writer once determined.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 1.0f,
-          /* finalDictionarySize */ 1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 5,
-          /* stripeCount*/ 2},
-      // We shouldn't be able to switch encodings beyond the first stripe.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 1.0f,
-          /* finalDictionarySize */ 1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(1, 0), /* force */ false, noSuccess),
-          /* repCount */ 5,
-          /* stripeCount*/ 2},
-      DirectEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 0.1f,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ false,
-              successAtNthWriteForStripe(0, 1)),
-          /* repCount */ 5,
-          /* stripeCount*/ 2},
-      // Return false because we were already using direct encoding.
-      DirectEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 0.1f,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonNthWriteForStripe(1, 0), /* force */ false, noSuccess),
-          /* repCount */ 5,
-          /* stripeCount*/ 2},
-      // Abandoning at every write to make sure subsequent abandon dict calls
-      // are safe.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 1.0f,
-          /* finalDictionarySize */ 1000,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 10},
-      // finalDictionarySize == 0 because in each stripe
-      // each value only appeared once.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryWriteThreshold */ 1.0f,
-          /* finalDictionarySize */ 0,
-          generateRangeWithCustomLimits,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 1,
-          /* stripeCount*/ 10},
-  };
-
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-template <typename Integer>
-void testIntegerDictionaryEncodableWriterConstructor() {
-  auto type = CppToType<Integer>::create();
-  auto typeWithId = TypeWithId::create(type, 1);
-  auto pool = addDefaultLeafMemoryPool();
-
-  // Write input
-  auto config = std::make_shared<Config>();
-  float slightlyOver = 1.0f + std::numeric_limits<float>::epsilon() * 2;
-  {
-    config->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, slightlyOver);
-    WriterContext context{config, defaultMemoryManager().addRootPool()};
-    EXPECT_ANY_THROW(BaseColumnWriter::create(context, *typeWithId));
-  }
-  float slightlyUnder = -std::numeric_limits<float>::epsilon();
-  {
-    config->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, slightlyUnder);
-    WriterContext context{config, defaultMemoryManager().addRootPool()};
-    EXPECT_ANY_THROW(BaseColumnWriter::create(context, *typeWithId));
-  }
-}
-
-TEST(ColumnWriterTests, IntegerDictionaryDictionaryEncodableWriterCtor) {
-  testIntegerDictionaryEncodableWriterConstructor<int16_t>();
-  testIntegerDictionaryEncodableWriterConstructor<int32_t>();
-  testIntegerDictionaryEncodableWriterConstructor<int64_t>();
-}
-
-std::string
-generateSomewhatRandomStringData(size_t /*unused*/, size_t i, size_t size) {
-  return folly::to<std::string>(generateSomewhatRandomData(i, size, 0, 0));
-}
-
-std::string generateStringRange(size_t /*unused*/, size_t i, size_t size) {
-  return folly::to<std::string>(generateRangeWithLimits<int64_t>(i, size));
-}
-
-struct StringColumnWriterTestCase {
-  const size_t size;
-  const bool writeDirect;
-  const float dictionaryKeyEfficiencyThreshold;
-  const float entropyKeyEfficiencyThreshold;
-  const size_t finalDictionarySize;
-  const std::function<std::string(size_t, size_t, size_t)> genData;
-  const bool hasNulls;
-  const std::function<bool(size_t, size_t, size_t)> genNulls;
-  const std::function<void(ColumnWriter&, size_t, size_t)> postProcess;
-  const size_t repetitionCount;
-  const size_t flushCount;
-  const std::shared_ptr<const Type> type;
-
-  StringColumnWriterTestCase(
-      size_t size,
-      bool writeDirect,
-      float dictionaryKeyEfficiencyThreshold,
-      float entropyKeyEfficiencyThreshold,
-      size_t finalDictionarySize,
-      const std::function<std::string(size_t, size_t, size_t)>& genData,
-      bool hasNulls,
-      const std::function<bool(size_t, size_t, size_t)>& genNulls,
-      const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : size{size},
-        writeDirect{writeDirect},
-        dictionaryKeyEfficiencyThreshold{dictionaryKeyEfficiencyThreshold},
-        entropyKeyEfficiencyThreshold{entropyKeyEfficiencyThreshold},
-        finalDictionarySize{finalDictionarySize},
-        genData{genData},
-        hasNulls{hasNulls},
-        genNulls{genNulls},
-        postProcess{postProcess},
-        repetitionCount{repetitionCount},
-        flushCount{flushCount},
-        type{CppToType<folly::StringPiece>::create()} {}
-
-  virtual ~StringColumnWriterTestCase() = default;
-
-  FlatVectorPtr<StringView> generateStringSlice(
-      size_t strideIndex,
-      MemoryPool* pool) const {
-    auto nulls = allocateNulls(size, pool);
-    auto* nullsPtr = nulls->asMutable<uint64_t>();
-
-    auto values = AlignedBuffer::allocate<StringView>(size, pool);
-    auto* valuesPtr = values->asMutable<StringView>();
-
-    std::vector<BufferPtr> dataChunks;
-
-    BufferPtr dataChunk = AlignedBuffer::allocate<char>(1024, pool);
-    dataChunks.push_back(dataChunk);
-    auto* dataChunkPtr = dataChunk->asMutable<char>();
-
-    size_t nullCount = 0;
-    size_t offset = 0;
-    for (size_t i = 0; i != size; ++i) {
-      bool isPresent = genNulls(strideIndex, i, size);
-      bits::setNull(nullsPtr, i, !isPresent);
-
-      if (isPresent) {
-        auto val = genData(strideIndex, i, size);
-        if (offset + val.size() > dataChunk->capacity()) {
-          dataChunk = AlignedBuffer::allocate<char>(1024, pool);
-          dataChunks.push_back(dataChunk);
-          dataChunkPtr = dataChunk->asMutable<char>();
-          offset = 0;
-        }
-
-        memcpy(dataChunkPtr + offset, val.data(), val.size());
-        valuesPtr[i] = StringView(dataChunkPtr + offset, val.size());
-        offset += val.size();
-      } else {
-        nullCount++;
-      }
-    }
-
-    auto stringVector = std::make_shared<FlatVector<StringView>>(
-        pool, VARCHAR(), nulls, size, values, std::move(dataChunks));
-    stringVector->setNullCount(nullCount);
-    return stringVector;
-  }
-
-  void runTest() const {
-    auto pool = addDefaultLeafMemoryPool();
-
-    // Set up writer.
-    auto config = std::make_shared<Config>();
-    config->set(
-        Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD,
-        entropyKeyEfficiencyThreshold);
-    config->set(
-        Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD,
-        dictionaryKeyEfficiencyThreshold);
-    WriterContext context{config, defaultMemoryManager().addRootPool()};
-    // Register root node.
-    auto typeWithId = TypeWithId::create(type, 1);
-    auto columnWriter = BaseColumnWriter::create(context, *typeWithId);
-
-    // Prepare input
-    std::vector<VectorPtr> batches;
-
-    for (size_t j = 0; j != repetitionCount; j++) {
-      batches.emplace_back(generateStringSlice(j, pool.get()));
-    }
-
-    for (size_t i = 0; i != flushCount; ++i) {
-      proto::StripeFooter stripeFooter;
-      // Write Stride
-      for (size_t j = 0; j != repetitionCount; ++j) {
-        // TODO: break the batch into multiple strides.
-        columnWriter->write(batches[j], common::Ranges::of(0, size));
-        postProcess(*columnWriter, i, j);
-        columnWriter->createIndexEntry();
-      }
-
-      // Flush when all strides are written (once per stripe).
-      columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
-          });
-
-      // Read and verify.
-      const size_t nodeId = 1;
-      auto rowType = ROW({{"string_column", type}});
-      TestStripeStreams streams(context, stripeFooter, rowType, pool.get());
-      EncodingKey key{nodeId};
-      const auto& encoding = streams.getEncoding(key);
-      if (writeDirect) {
-        ASSERT_EQ(
-            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DIRECT,
-            encoding.kind());
-      } else {
-        ASSERT_EQ(
-            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY,
-            encoding.kind());
-        ASSERT_EQ(finalDictionarySize, encoding.dictionarysize());
-      }
-
-      auto reqType = TypeWithId::create(rowType)->childAt(0);
-      memory::AllocationPool allocPool(pool.get());
-      StreamLabels labels(allocPool);
-      auto columnReader =
-          ColumnReader::build(reqType, reqType, streams, labels);
-
-      for (size_t j = 0; j != repetitionCount; ++j) {
-        if (!writeDirect) {
-          EXPECT_CALL(streams.getMockStrideIndexProvider(), getStrideIndex())
-              .Times(::testing::AtMost(1)) // Stride dictionary is optional
-              .WillOnce(Return(j));
-        }
-
-        // TODO Make reuse work
-        VectorPtr resultBatch;
-        columnReader->next(size, resultBatch);
-
-        auto batch = batches[j];
-        ASSERT_EQ(batch->size(), resultBatch->size());
-
-        auto sv = std::dynamic_pointer_cast<FlatVector<StringView>>(batch);
-        ASSERT_TRUE(sv);
-        auto resultSv =
-            std::dynamic_pointer_cast<SimpleVector<StringView>>(resultBatch);
-        ASSERT_TRUE(resultSv);
-        ASSERT_EQ(sv->getNullCount(), resultSv->getNullCount());
-        for (size_t k = 0; k < sv->size(); k++) {
-          EXPECT_EQ(sv->isNullAt(k), resultSv->isNullAt(k));
-        }
-
-        for (size_t k = 0; k != sv->size(); ++k) {
-          if (!sv->isNullAt(k)) {
-            EXPECT_EQ(sv->valueAt(k), resultSv->valueAt(k)) << folly::sformat(
-                "Mismatch on {}-th element. \nExpected: {}\n Actual: {}",
-                k,
-                sv->valueAt(k).str(),
-                resultSv->valueAt(k).str());
-          }
-        }
-      }
-      context.nextStripe();
-      columnWriter->reset();
-    }
-  }
-};
-
-struct StringDictionaryEncodingTestCase : public StringColumnWriterTestCase {
-  explicit StringDictionaryEncodingTestCase(
-      size_t size,
-      size_t finalDictionarySize,
-      const std::function<std::string(size_t, size_t, size_t)>& genData,
-      bool hasNull,
-      const std::function<bool(size_t, size_t, size_t)>& genNulls,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : StringColumnWriterTestCase{
-            size,
-            false,
-            1.0f,
-            0.0f,
-            finalDictionarySize,
-            genData,
-            hasNull,
-            genNulls,
-            noPostProcessing,
-            repetitionCount,
-            flushCount} {}
-};
-
-struct StringDirectEncodingTestCase : public StringColumnWriterTestCase {
-  explicit StringDirectEncodingTestCase(
-      size_t size,
-      const std::function<std::string(size_t, size_t, size_t)>& genData,
-      bool hasNull,
-      const std::function<bool(size_t, size_t, size_t)>& genNulls,
-      size_t repetitionCount = 1,
-      size_t flushCount = 1)
-      : StringColumnWriterTestCase{
-            size,
-            true,
-            0.0f,
-            1.0f,
-            0,
-            genData,
-            hasNull,
-            genNulls,
-            noPostProcessing,
-            repetitionCount,
-            flushCount} {}
-};
-
-TEST(ColumnWriterTests, StringDictionaryEncodingWrite) {
-  struct TestCase : public StringDictionaryEncodingTestCase {
-    explicit TestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : StringDictionaryEncodingTestCase{
-              size,
-              finalDictionarySize,
-              genData,
-              false,
-              noNullsWithStride,
-              repetitionCount,
-              flushCount} {}
-  };
-  std::vector<TestRunner> testCases{
-      // No values in dictionary.
-      TestCase{1000, 0, generateStringRange},
-      // Mixture of values in dictionary vs not.
-      TestCase{1000, 201, generateSomewhatRandomStringData},
-      // Test repeated writes. All values are in dictionary.
-      TestCase{1000, 617, generateSomewhatRandomStringData, 20},
-      // Test repeated writes and flushes with mixture of values in
-      // dictionary.
-      // Tests independence of dictionary encoding writes across stripes. (In
-      // other words, whether the dictionary is cleared across stripes.)
-      TestCase{1000, 201, generateSomewhatRandomStringData, 1, 10},
-      // Test repeated writes and flushes. All values are in dictionary.
-      TestCase{1000, 617, generateSomewhatRandomStringData, 2, 10},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-std::string genStrideData_scheme1(
-    size_t strideIndex,
-    size_t strideOffset,
-    size_t /*unused*/) {
-  // 1st stride contains - "0", "a",  "a", "a",...
-  // 2nd stride contains - "1", "b",  "b", "b",...
-  // The 1st string will block the inDictStream optimization and exercise
-  // the related code path.
-  char ch = static_cast<char>(
-      (strideOffset == 0) ? '0' + strideIndex : 'a' + strideIndex);
-  return std::string(1, ch);
-}
-
-std::string genStrideData_scheme2(
-    size_t strideIndex,
-    size_t strideOffset,
-    size_t /*unused*/) {
-  // 1st stride contains - "start",  "a", "a",...
-  // 2nd stride contains - "b",  "b", "b",...
-  if (strideOffset == 0 && strideIndex == 0) {
-    // If all the keys are in dictionary, inDictStream is skipped and the code
-    // path is skipped. So introducing a non repeated string here
-    // intentionally.
-    return std::string("start");
-  }
-  char ch = static_cast<char>('a' + strideIndex);
-  return std::string(1, ch);
-}
-
-bool genNulls_ForStride2(
-    size_t strideIndex,
-    size_t /*unused*/,
-    size_t /*unused*/) {
-  // Except for Stride 2, the rest strides will contain nulls.
-  return strideIndex == 2;
-}
-
-TEST(ColumnWriterTests, StrideStringWithSomeDataNotInDictionary) {
-  struct TestCase : public StringDictionaryEncodingTestCase {
-    explicit TestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        bool hasNulls,
-        const std::function<bool(size_t, size_t, size_t)>& genNulls,
-        size_t repetitionCount,
-        size_t flushCount)
-        : StringDictionaryEncodingTestCase{
-              size,
-              finalDictionarySize,
-              genData,
-              hasNulls,
-              genNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      TestCase{1000, 2, genStrideData_scheme1, false, noNullsWithStride, 2, 5},
-
-      TestCase{1000, 2, genStrideData_scheme2, false, noNullsWithStride, 2, 3},
-
-      TestCase{
-          1000, 1, genStrideData_scheme1, true, genNulls_ForStride2, 3, 1}};
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, StringDictionaryEncodingWritesWithNulls) {
-  struct DictionaryEncodingTestCase : public StringDictionaryEncodingTestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<bool(size_t, size_t, size_t)>& genNulls,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : StringDictionaryEncodingTestCase{
-              size,
-              finalDictionarySize,
-              genData,
-              true,
-              genNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  // Even as the dictionary size threshold allows, we might not end up writing
-  // with dictionary encoding.
-  struct DirectEncodingTestCase : public StringDirectEncodingTestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<bool(size_t, size_t, size_t)>& genNulls,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : StringDirectEncodingTestCase{
-              size,
-              genData,
-              true,
-              genNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      // When all values are null, we don't try to write dictionary at all.
-      DirectEncodingTestCase{1000, generateStringRange, allNullsWithStride},
-      // No values in dictionary.
-      DictionaryEncodingTestCase{
-          100, 0, generateStringRange, someNullsWithStride},
-      // Mixture of values in dictionary vs not.
-      DictionaryEncodingTestCase{
-          1000, 62, generateSomewhatRandomStringData, someNullsWithStride},
-      // Test repeated writes. All values are in dictionary.
-      DictionaryEncodingTestCase{
-          1000, 250, generateSomewhatRandomStringData, someNullsWithStride, 20},
-      // Test repeated writes and flushes with mixture of values in
-      // dictionary.
-      // Tests independence of dictionary encoding writes across stripes. (In
-      // other words, whether the dictionary is cleared across stripes.)
-      DictionaryEncodingTestCase{
-          1000,
-          62,
-          generateSomewhatRandomStringData,
-          someNullsWithStride,
-          1,
-          10},
-      // Test repeated writes and flushes. All values are in dictionary.
-      DictionaryEncodingTestCase{
-          1000,
-          250,
-          generateSomewhatRandomStringData,
-          someNullsWithStride,
-          2,
-          10},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, StringDirectEncodingWrites) {
-  struct TestCase : public StringDirectEncodingTestCase {
-    TestCase(
-        size_t size,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : StringDirectEncodingTestCase{
-              size,
-              genData,
-              false,
-              noNullsWithStride,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      TestCase{1000, generateStringRange},
-      TestCase{1000, generateSomewhatRandomStringData},
-      TestCase{1000, generateSomewhatRandomStringData, 20},
-      // Note, writes from the second stripe on uses direct encoding from the
-      // get-go.
-      // TODO: reinforce that the subsequent writes go through the right code
-      // path when we have more granular memory tracking.
-      TestCase{1000, generateSomewhatRandomStringData, 1, 10},
-      TestCase{1000, generateSomewhatRandomStringData, 2, 10},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, StringDirectEncodingWritesWithNulls) {
-  struct TestCase : public StringDirectEncodingTestCase {
-    TestCase(
-        size_t size,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<bool(size_t, size_t, size_t)>& genNulls,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : StringDirectEncodingTestCase{
-              size,
-              genData,
-              true,
-              genNulls,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  std::vector<TestRunner> testCases{
-      TestCase{1000, generateStringRange, allNullsWithStride},
-      TestCase{1000, generateStringRange, someNullsWithStride},
-      TestCase{1000, generateSomewhatRandomStringData, someNullsWithStride},
-      TestCase{1000, generateSomewhatRandomStringData, someNullsWithStride, 20},
-      // Note, writes from the second stripe on uses direct encoding from the
-      // get-go.
-      // TODO: reinforce that the subsequent writes go through the right code
-      // path when we have more granular memory tracking.
-      TestCase{
-          1000, generateSomewhatRandomStringData, someNullsWithStride, 1, 10},
-      TestCase{
-          1000, generateSomewhatRandomStringData, someNullsWithStride, 2, 10},
-  };
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, StringColumnWriterAbandonDictionaries) {
-  struct TestCase : public StringColumnWriterTestCase {
-    TestCase(
-        size_t size,
-        bool writeDirect,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount,
-        size_t flushCount)
-        : StringColumnWriterTestCase{
-              size,
-              writeDirect,
-              1.0f,
-              0.0f,
-              finalDictionarySize,
-              genData,
-              false,
-              noNullsWithStride,
-              postProcess,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  struct DirectEncodingTestCase : public TestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ true,
-              /* finalDictionarySize */ 0,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  struct DictionaryEncodingTestCase : public TestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ false,
-              finalDictionarySize,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  std::vector<TestRunner> testCases{
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          10},
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          1,
-          10},
-      // Test abandoning dictionary in multi-write scenarios. For now we could
-      // only abandon dictionary starting from the first stripe, because we
-      // could not switch up encoding of a writer once determined.
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          2,
-          5},
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 1)),
-          2,
-          5},
-      // We shouldn't be able to switch encodings beyond the first stripe.
-      DictionaryEncodingTestCase{
-          1000,
-          /* finalDictionarySize */ 1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(1, 0), /* force */ true, noSuccess),
-          2,
-          5},
-      // Abandoning at every write to make sure subsequent abandon dict calls
-      // are safe.
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          10},
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          1,
-          10},
-  };
-
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-// TODO: how about all nulls?
-TEST(ColumnWriterTests, StringColumnWriterAbandonDictionariesWithNulls) {
-  struct TestCase : public StringColumnWriterTestCase {
-    TestCase(
-        size_t size,
-        bool writeDirect,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : StringColumnWriterTestCase{
-              size,
-              writeDirect,
-              1.0f,
-              0.0f,
-              finalDictionarySize,
-              genData,
-              true,
-              someNullsWithStride,
-              postProcess,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  struct DirectEncodingTestCase : public TestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ true,
-              /* finalDictionarySize */ 0,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  struct DictionaryEncodingTestCase : public TestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ false,
-              finalDictionarySize,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  std::vector<TestRunner> testCases{
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          10},
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          1,
-          10},
-      // Test abandoning dictionary in multi-write scenarios. For now we could
-      // only abandon dictionary starting from the first stripe, because we
-      // could not switch up encoding of a writer once determined.
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          2,
-          5},
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ true,
-              successAtNthWriteForStripe(0, 1)),
-          2,
-          5},
-      // We shouldn't be able to switch encodings beyond the first stripe.
-      DictionaryEncodingTestCase{
-          1000,
-          /* finalDictionarySize */ 341,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(1, 0), /* force */ true, noSuccess),
-          2,
-          5},
-      // Abandoning at every write to make sure subsequent abandon dict calls
-      // are safe.
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          10},
-      DirectEncodingTestCase{
-          1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ true,
-              successAtNthWriteForStripe(0, 0)),
-          1,
-          10},
-  };
-
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, StringColumnWriterAbandonLowValueDictionaries) {
-  struct TestCase : public StringColumnWriterTestCase {
-    TestCase(
-        size_t size,
-        bool writeDirect,
-        float dictionaryKeyEfficiencyThreshold,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount,
-        size_t flushCount)
-        : StringColumnWriterTestCase{
-              size,
-              writeDirect,
-              dictionaryKeyEfficiencyThreshold,
-              /* entropyKeyEfficiencyThreshold */ 0.0f,
-              finalDictionarySize,
-              genData,
-              false,
-              noNullsWithStride,
-              postProcess,
-              repetitionCount,
-              flushCount} {}
-  };
-
-  struct DirectEncodingTestCase : public TestCase {
-    DirectEncodingTestCase(
-        size_t size,
-        float dictionaryKeyEfficiencyThreshold,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ true,
-              dictionaryKeyEfficiencyThreshold,
-              /* finalDictionarySize */ 0,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  struct DictionaryEncodingTestCase : public TestCase {
-    DictionaryEncodingTestCase(
-        size_t size,
-        float dictionaryKeyEfficiencyThreshold,
-        size_t finalDictionarySize,
-        const std::function<std::string(size_t, size_t, size_t)>& genData,
-        const std::function<void(ColumnWriter&, size_t, size_t)>& postProcess,
-        size_t repetitionCount = 1,
-        size_t flushCount = 1)
-        : TestCase(
-              size,
-              /* writeDirect */ false,
-              dictionaryKeyEfficiencyThreshold,
-              finalDictionarySize,
-              genData,
-              postProcess,
-              repetitionCount,
-              flushCount) {}
-  };
-
-  std::vector<TestRunner> testCases{
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
-          /* finalDictionarySize */ 1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 10},
-      // FinalDictionarySize == 0 because in each stripe
-      // each value only appeared once.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
-          /* finalDictionarySize */ 0,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 0),
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 1,
-          /* stripeCount */ 10},
-      DirectEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 0.4f,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ false,
-              successAtNthWriteForStripe(0, 1)),
-          /* repCount */ 10},
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 0.4f,
-          /* finalDictionarySize */ 1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 2),
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 10},
-      // Test abandoning dictionary in multi-write scenarios. For now we could
-      // only abandon dictionary starting from the first stripe, because we
-      // could not switch up encoding of a writer once determined.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
-          /* finalDictionarySize */ 1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 5,
-          /* stripeCount*/ 2},
-      // We shouldn't be able to switch encodings beyond the first stripe.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
-          /* finalDictionarySize */ 1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(1, 0), /* force */ false, noSuccess),
-          /* repCount */ 5,
-          /* stripeCount*/ 2},
-      DirectEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 0.1f,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(0, 1),
-              /* force */ false,
-              successAtNthWriteForStripe(0, 1)),
-          /* repCount */ 5,
-          /* stripeCount*/ 2},
-      // Return false because we were already using direct encoding.
-      DirectEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 0.1f,
-          generateStringRange,
-          checkAbandonDict(
-              abandonNthWriteForStripe(1, 0), /* force */ false, noSuccess),
-          /* repCount */ 5,
-          /* stripeCount*/ 2},
-      // Abandoning at every write to make sure subsequent abandon dict calls
-      // are safe.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
-          /* finalDictionarySize */ 1000,
-          generateStringRange,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 10},
-      // FinalDictionarySize == 0 because in each stripe
-      // each value only appeared once.
-      DictionaryEncodingTestCase{
-          1000,
-          /* dictionaryKeyEfficiencyThreshold */ 1.0f,
-          /* finalDictionarySize */ 0,
-          generateStringRange,
-          checkAbandonDict(
-              abandonEveryWrite,
-              /* force */ false,
-              noSuccess),
-          /* repCount */ 1,
-          /* stripeCount*/ 10},
-  };
-
-  for (const auto& testCase : testCases) {
-    testCase.runTest();
-  }
-}
-
-TEST(ColumnWriterTests, IntDictWriterDirectValueOverflow) {
-  auto config = std::make_shared<Config>();
-  auto pool = addDefaultLeafMemoryPool();
-  WriterContext context{
-      config,
-      defaultMemoryManager().addRootPool("IntDictWriterDirectValueOverflow")};
-  auto type = std::make_shared<const IntegerType>();
-  auto typeWithId = TypeWithId::create(type, 1);
-
-  // write
-  constexpr size_t size = 100;
-  std::vector<std::optional<int32_t>> data;
-  for (auto i = 0; i < size; ++i) {
-    data.push_back((i == 0 ? -1 : 1));
-  }
-  auto vector = populateBatch<int32_t>(data, pool.get());
-
-  auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
-  writer->write(vector, common::Ranges::of(0, size));
-  writer->createIndexEntry();
-  proto::StripeFooter sf;
-  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
-  });
-  auto& enc = sf.encoding(0);
-  ASSERT_EQ(enc.kind(), proto::ColumnEncoding_Kind_DICTIONARY);
-
-  // get data stream
-  TestStripeStreams streams(context, sf, ROW({"foo"}, {type}), pool.get());
-  DwrfStreamIdentifier si{1, 0, 0, proto::Stream_Kind_DATA};
-  auto stream = streams.getStream(si, {}, true);
-
-  // read it as long
-  auto decoder = createRleDecoder<false>(
-      std::move(stream), RleVersion_1, *pool, streams.getUseVInts(si), 8);
-  std::array<int64_t, size> actual;
-  decoder->next(actual.data(), size, nullptr);
-  for (auto i = 0; i < size; ++i) {
-    ASSERT_EQ(actual[i], i == 0 ? -1 : 0);
-  }
-}
-
-TEST(ColumnWriterTests, ShortDictWriterDictValueOverflow) {
-  auto config = std::make_shared<Config>();
-  auto pool = addDefaultLeafMemoryPool();
-  WriterContext context{config, defaultMemoryManager().addRootPool()};
-  auto type = std::make_shared<const SmallintType>();
-  auto typeWithId = TypeWithId::create(type, 1);
-
-  // write
-  constexpr size_t repeat = 3;
-  constexpr size_t count = 1 << 16;
-  constexpr size_t size = repeat * count;
-  std::vector<std::optional<int16_t>> data;
-  for (auto i = 0; i < repeat; ++i) {
-    int16_t val = std::numeric_limits<int16_t>::min();
-    for (auto j = 0; j < count; ++j) {
-      data.push_back(val++);
-    }
-  }
-  auto vector = populateBatch<int16_t>(data, pool.get());
-
-  auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
-  writer->write(vector, common::Ranges::of(0, size));
-  writer->createIndexEntry();
-  proto::StripeFooter sf;
-  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
-  });
-  auto& enc = sf.encoding(0);
-  ASSERT_EQ(enc.kind(), proto::ColumnEncoding_Kind_DICTIONARY);
-
-  // get data stream
-  TestStripeStreams streams(context, sf, ROW({"foo"}, {type}), pool.get());
-  DwrfStreamIdentifier si{1, 0, 0, proto::Stream_Kind_DATA};
-  auto stream = streams.getStream(si, {}, true);
-
-  // read it as long
-  auto decoder = createRleDecoder<false>(
-      std::move(stream), RleVersion_1, *pool, streams.getUseVInts(si), 8);
-  std::array<int64_t, size> actual;
-  decoder->next(actual.data(), size, nullptr);
-  for (auto i = 0; i < size; ++i) {
-    ASSERT_GE(actual[i], 0);
-  }
-}
-
-TEST(ColumnWriterTests, RemovePresentStream) {
-  auto config = std::make_shared<Config>();
-  auto pool = addDefaultLeafMemoryPool();
-
-  std::vector<std::optional<int32_t>> data;
-  auto size = 100;
-  for (auto i = 0; i < size; ++i) {
-    data.push_back(i);
-  }
-  auto vector = populateBatch<int32_t>(data, pool.get());
-  WriterContext context{config, defaultMemoryManager().addRootPool()};
-  auto type = std::make_shared<const IntegerType>();
-  auto typeWithId = TypeWithId::create(type, 1);
-
-  // write
-  auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
-
-  writer->write(vector, common::Ranges::of(0, size));
-  writer->createIndexEntry();
-  proto::StripeFooter sf;
-  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
-  });
-
-  // get data stream
-  TestStripeStreams streams(context, sf, ROW({"foo"}, {type}), pool.get());
-  DwrfStreamIdentifier si{1, 0, 0, proto::Stream_Kind_PRESENT};
-  ASSERT_EQ(streams.getStream(si, {}, false), nullptr);
-}
-
-TEST(ColumnWriterTests, ColumnIdInStream) {
-  auto config = std::make_shared<Config>();
-  auto pool = addDefaultLeafMemoryPool();
-
-  std::vector<std::optional<int32_t>> data;
-  auto size = 100;
-  for (auto i = 0; i < size; ++i) {
-    data.push_back(i);
-  }
-  auto vector = populateBatch<int32_t>(data, pool.get());
-  WriterContext context{
-      config, defaultMemoryManager().addRootPool("ColumnIdInStream")};
-  auto type = std::make_shared<const IntegerType>();
-  const uint32_t kNodeId = 4;
-  const uint32_t kColumnId = 2;
-  auto typeWithId = std::make_shared<const TypeWithId>(
-      type,
-      std::vector<std::shared_ptr<const TypeWithId>>{},
-      /* id */ kNodeId,
-      /* maxId */ kNodeId,
-      /* column */ kColumnId);
-
-  // write
-  auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
-
-  writer->write(vector, common::Ranges::of(0, size));
-  writer->createIndexEntry();
-  proto::StripeFooter sf;
-  writer->flush([&sf](auto /* unused */) -> proto::ColumnEncoding& {
-    return *sf.add_encoding();
-  });
-
-  // get data stream
-  TestStripeStreams streams(context, sf, ROW({"foo"}, {type}), pool.get());
-  DwrfStreamIdentifier si{
-      kNodeId, /* sequence */ 0, kColumnId, proto::Stream_Kind_DATA};
-  ASSERT_NE(streams.getStream(si, {}, false), nullptr);
-}
-
-template <typename T>
-struct DictColumnWriterTestCase {
-  DictColumnWriterTestCase(size_t size, bool writeDirect, const TypePtr& type)
-      : size_(size), writeDirect_(writeDirect), type_(type) {}
-  const size_t size_;
-  const bool writeDirect_;
-  TypePtr type_;
-
-  BufferPtr randomIndices(vector_size_t size) {
-    BufferPtr indices =
-        AlignedBuffer::allocate<vector_size_t>(size, pool_.get());
-    auto rawIndices = indices->asMutable<vector_size_t>();
-    for (int32_t i = 0; i < size; i++) {
-      rawIndices[i] = folly::Random::rand32(size);
-    }
-    return indices;
-  }
-
-  /**
-   * Used to generate dictionary data for the non-complex columns
-   * @param size the number of rows
-   * @param valueAt the lambda generating values
-   * @param isNullAt the lambda generating nulls
-   * @return generated data as flat vector
-   */
-  FlatVectorPtr<T> makeFlatVector(
-      vector_size_t size,
-      std::function<T(vector_size_t /*index*/)> valueAt,
-      std::function<bool(vector_size_t /*index*/)> isNullAt = nullptr) {
-    auto vector = std::dynamic_pointer_cast<FlatVector<T>>(
-        BaseVector::create(type_, size, pool_.get()));
-    for (int32_t i = 0; i < size; ++i) {
-      if (isNullAt && isNullAt(i)) {
-        vector->setNull(i, true);
-      } else {
-        vector->set(i, valueAt(i));
-      }
-    }
-    return vector;
-  }
-
-  /**
-   * Used to only generate dictionary complex vector tests
-   * The data is generated randomly while the nulls are
-   * generated using a lambda.
-   * @param rowType the complex row type
-   * @param count the number of rows in the generated column
-   * @param isNullAt the bool lambda for generating nulls
-   * @return generated data as Row, Array or Map vectors.
-   */
-  VectorPtr makeComplexVectors(
-      const std::shared_ptr<const RowType> rowType,
-      int32_t count,
-      std::function<bool(vector_size_t /*index*/)> isNullAt) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType, count, *pool_, isNullAt));
-    // Batch is returned as a RowVector and so we grab its first column
-    return vector->childAt(0);
-  }
-
-  /**
-   * Used to generate dicitionary data for the non-complex columns
-   * @param size the size the generated data (before dictionary)
-   * @param valueAt the lmbda generating values
-   * @param isNullAt the lambda generating nulls
-   * @param complexRowType only set if the data wil be complex (Row, Array or
-   * Map)
-   * @return
-   */
-  VectorPtr createDictionaryBatch(
-      size_t size,
-      std::function<T(vector_size_t /*index*/)> valueAt,
-      std::function<bool(vector_size_t /*index*/)> isNullAt,
-      const std::shared_ptr<const RowType> complexRowType = nullptr) {
-    BufferPtr indices = randomIndices(size);
-    VectorPtr dictionaryVector;
-
-    VectorPtr flatVector;
-    if (complexRowType == nullptr) {
-      flatVector = makeFlatVector(size, valueAt, isNullAt);
-    } else {
-      flatVector = makeComplexVectors(complexRowType, size, isNullAt);
-    }
-
-    auto wrappedVector = BaseVector::wrapInDictionary(
-        BufferPtr(nullptr), indices, size, flatVector);
-    EXPECT_EQ(wrappedVector->encoding(), VectorEncoding::Simple::DICTIONARY);
-    return wrappedVector;
-  }
-
-  void runTest(
-      std::function<T(vector_size_t /*index*/)> valueAt,
-      std::function<bool(vector_size_t /*index*/)> isNullAt = nullptr) {
-    auto config = std::make_shared<Config>();
-    auto typeWithId = TypeWithId::create(type_, 1);
-    auto rowType = ROW({type_});
-
-    WriterContext context{config, defaultMemoryManager().addRootPool()};
-
-    // complexVectorType will be nullptr if the vector is not complex.
-    bool isComplexType = std::dynamic_pointer_cast<const RowType>(type_) ||
-        std::dynamic_pointer_cast<const MapType>(type_) ||
-        std::dynamic_pointer_cast<const ArrayType>(type_);
-
-    auto complexVectorType = isComplexType ? rowType : nullptr;
-    auto batch =
-        createDictionaryBatch(size_, valueAt, isNullAt, complexVectorType);
-
-    const auto writer = BaseColumnWriter::create(context, *typeWithId);
-
-    // Testing write direct paths
-    if (writeDirect_) {
-      writer->tryAbandonDictionaries(true);
-    }
-    writer->write(batch, common::Ranges::of(0, batch->size()));
-    writer->createIndexEntry();
-
-    proto::StripeFooter sf;
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
-    });
-
-    auto pool = addDefaultLeafMemoryPool();
-    // Reading the vector out
-    TestStripeStreams streams(context, sf, rowType, pool.get());
-    EXPECT_CALL(streams.getMockStrideIndexProvider(), getStrideIndex())
-        .WillRepeatedly(Return(0));
-    auto rowTypeWithId = TypeWithId::create(rowType);
-    auto reqType = rowTypeWithId->childAt(0);
-    memory::AllocationPool allocPool(pool.get());
-    StreamLabels labels(allocPool);
-    auto reader = ColumnReader::build(reqType, reqType, streams, labels);
-    VectorPtr out;
-    reader->next(batch->size(), out);
-    compareResults(batch, out);
-
-    context.nextStripe();
-    writer->reset();
-  }
-
-  void compareResults(VectorPtr& writeVector, VectorPtr& readVector) {
-    ASSERT_EQ(readVector->size(), writeVector->size());
-    for (int32_t i = 0; i < writeVector->size(); ++i) {
-      ASSERT_TRUE(readVector->equalValueAt(writeVector.get(), i, i))
-          << "at index " << i;
-    }
-  }
-
-  std::shared_ptr<MemoryPool> pool_ = addDefaultLeafMemoryPool();
-};
-
-std::function<bool(vector_size_t /*index*/)> randomNulls(int32_t n) {
-  return
-      [n](vector_size_t /*index*/) { return folly::Random::rand32() % n == 0; };
-}
-
-template <typename T>
-void testDictionary(
-    const TypePtr& type,
-    std::function<bool(vector_size_t)> isNullAt = nullptr,
-    std::function<T(vector_size_t)> valueAt = nullptr) {
-  constexpr int32_t vectorSize = 200;
-
-  // Tests for null/non null data with direct or dict write
-  DictColumnWriterTestCase<T>(vectorSize, true, type)
-      .runTest(valueAt, isNullAt);
-
-  DictColumnWriterTestCase<T>(vectorSize, false, type)
-      .runTest(valueAt, isNullAt);
-
-  // Tests for non null data with direct or dict write
-  DictColumnWriterTestCase<T>(vectorSize, true, type).runTest(valueAt, [](int) {
-    return false;
-  });
-
-  DictColumnWriterTestCase<T>(vectorSize, false, type)
-      .runTest(valueAt, [](int) { return false; });
-}
-
-TEST(ColumnWriterTests, ColumnWriterDictionarySimple) {
-  testDictionary<Timestamp>(TIMESTAMP(), randomNulls(11), [](vector_size_t i) {
-    return Timestamp(i * 5, i * 2);
-  });
-
-  testDictionary<int64_t>(
-      BIGINT(), randomNulls(5), [](vector_size_t i) { return i % 5; });
-
-  testDictionary<int32_t>(
-      INTEGER(), randomNulls(9), [](vector_size_t i) { return i % 5; });
-
-  testDictionary<int16_t>(
-      SMALLINT(), randomNulls(11), [](vector_size_t i) { return i % 5; });
-
-  testDictionary<int8_t>(
-      TINYINT(), randomNulls(13), [](vector_size_t i) { return i % 5; });
-
-  testDictionary<float>(
-      REAL(), randomNulls(7), [](vector_size_t i) { return (i % 3) * 0.2; });
-
-  testDictionary<double>(
-      DOUBLE(), randomNulls(9), [](vector_size_t i) { return (i % 3) * 0.2; });
-
-  testDictionary<bool>(
-      BOOLEAN(), randomNulls(11), [](vector_size_t i) { return i % 2 == 0; });
-
-  testDictionary<StringView>(VARCHAR(), randomNulls(9), [](vector_size_t i) {
-    return StringView::makeInline("str" + std::to_string(i % 3));
-  });
-
-  testDictionary<StringView>(VARBINARY(), randomNulls(9), [](vector_size_t i) {
-    return StringView::makeInline("binary" + std::to_string(i % 3));
-  });
-};
-
-TEST(ColumnWriterTests, rowDictionary) {
-  // For complex data valueAt lambda is not set as the data is generated
-  // randomly
-
-  // Row tests
-  testDictionary<Row<int32_t>>(ROW({INTEGER()}), randomNulls(5));
-
-  testDictionary<Row<StringView, int32_t>>(
-      ROW({VARCHAR(), INTEGER()}), randomNulls(11));
-
-  testDictionary<Row<Row<StringView, int32_t>>>(
-      ROW({ROW({VARCHAR(), INTEGER()})}), randomNulls(11));
-
-  testDictionary<Row<int32_t, double, StringView>>(
-      ROW({INTEGER(), DOUBLE(), VARCHAR()}), randomNulls(5));
-
-  testDictionary<Row<int32_t, StringView, double, StringView>>(
-      ROW({INTEGER(), VARCHAR(), DOUBLE(), VARCHAR()}), randomNulls(5));
-
-  testDictionary<Row<Array<StringView>, StringView>>(
-      ROW({ARRAY(VARCHAR()), VARCHAR()}), randomNulls(11));
-
-  testDictionary<
-      Row<Map<int32_t, double>,
-          Array<Map<int32_t, Row<int32_t, double>>>,
-          Row<int32_t, StringView>>>(
-      ROW(
-          {MAP(INTEGER(), DOUBLE()),
-           ARRAY(MAP(INTEGER(), ROW({INTEGER(), DOUBLE()}))),
-           ROW({INTEGER(), VARCHAR()})}),
-      randomNulls(11));
-}
-
-TEST(ColumnWriterTests, arrayDictionary) {
-  // Array tests
-  testDictionary<Array<float>>(ARRAY(REAL()), randomNulls(7));
-
-  testDictionary<
-      Row<Array<int32_t>, Row<StringView, Array<Map<StringView, StringView>>>>>(
-      ROW(
-          {ARRAY(INTEGER()),
-           ROW({VARCHAR(), ARRAY(MAP(VARCHAR(), VARCHAR()))})}),
-      randomNulls(11));
-
-  testDictionary<
-      Array<Map<int32_t, Array<Map<int8_t, Row<StringView, Array<double>>>>>>>(
-      ARRAY(MAP(
-          INTEGER(), ARRAY(MAP(TINYINT(), ROW({VARCHAR(), ARRAY(DOUBLE())}))))),
-      randomNulls(7));
-}
-
-TEST(ColumnWriterTests, mapDictionary) {
-  // Map tests
-  testDictionary<Map<int32_t, double>>(
-      MAP(INTEGER(), DOUBLE()), randomNulls(7));
-
-  testDictionary<Map<StringView, StringView>>(
-      MAP(VARCHAR(), VARCHAR()), randomNulls(13));
-
-  testDictionary<
-      Map<StringView,
-          Map<int32_t, Array<Row<int32_t, int32_t, Array<double>>>>>>(
-      MAP(VARCHAR(),
-          MAP(INTEGER(), ARRAY(ROW({INTEGER(), INTEGER(), ARRAY(DOUBLE())})))),
-      randomNulls(9));
-
-  testDictionary<Map<int32_t, Map<StringView, Map<StringView, int8_t>>>>(
-      MAP(INTEGER(), MAP(VARCHAR(), MAP(VARCHAR(), TINYINT()))),
-      randomNulls(3));
-}
-
-} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/CompressionTest.cpp b/velox/dwio/dwrf/test/CompressionTest.cpp
new file mode 100644
index 0000000000000..349d2df74db63
--- /dev/null
+++ b/velox/dwio/dwrf/test/CompressionTest.cpp
@@ -0,0 +1,477 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/dwrf/common/Compression.h"
+#include "velox/common/base/VeloxException.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/encryption/TestProvider.h"
+#include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
+#include "velox/dwio/dwrf/test/OrcTest.h"
+
+#include <folly/Random.h>
+#include <gtest/gtest.h>
+#include "velox/common/compression/Compression.h"
+
+#include <algorithm>
+
+using namespace ::testing;
+using namespace facebook::velox::common;
+using namespace facebook::velox::dwio;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwio::common::encryption;
+using namespace facebook::velox::dwio::common::encryption::test;
+using namespace facebook::velox::dwrf;
+using namespace facebook::velox::memory;
+using facebook::velox::VeloxException;
+
+const int32_t DEFAULT_MEM_STREAM_SIZE = 1024 * 1024 * 2; // 2M
+
+class TestBufferPool : public CompressionBufferPool {
+ public:
+  TestBufferPool(MemoryPool& pool, uint64_t blockSize)
+      : buffer_{std::make_unique<DataBuffer<char>>(
+            pool,
+            blockSize + PAGE_HEADER_SIZE)} {}
+
+  std::unique_ptr<DataBuffer<char>> getBuffer(uint64_t /* unused */) override {
+    VELOX_CHECK_NOT_NULL(buffer_);
+    return std::move(buffer_);
+  }
+
+  void returnBuffer(std::unique_ptr<DataBuffer<char>> buffer) override {
+    VELOX_CHECK_NULL(buffer_);
+    VELOX_CHECK_NOT_NULL(buffer);
+    buffer_ = std::move(buffer);
+  }
+
+ private:
+  std::unique_ptr<DataBuffer<char>> buffer_;
+};
+
+void generateRandomData(char* data, size_t size, bool letter) {
+  for (size_t i = 0; i < size; ++i) {
+    if (letter) {
+      bool capitalized = folly::Random::rand32() % 2 == 0;
+      data[i] = capitalized
+          ? static_cast<char>('A' + folly::Random::rand32() % 26)
+          : static_cast<char>('a' + folly::Random::rand32() % 26);
+    } else {
+      data[i] = static_cast<char>(folly::Random::rand32() % 256);
+    }
+  }
+}
+
+void decompressAndVerify(
+    const MemorySink& memSink,
+    CompressionKind kind,
+    uint64_t blockSize,
+    const char* data,
+    size_t size,
+    MemoryPool& pool,
+    const Decrypter* decrypter) {
+  std::unique_ptr<SeekableInputStream> inputStream(
+      new SeekableArrayInputStream(memSink.data(), memSink.size()));
+
+  std::unique_ptr<SeekableInputStream> decompressStream = createDecompressor(
+      kind,
+      std::move(inputStream),
+      blockSize,
+      pool,
+      "Test Comrpession",
+      decrypter);
+
+  const char* decompressedBuffer;
+  int32_t decompressedSize;
+  int32_t pos = 0;
+  while (decompressStream->Next(
+      reinterpret_cast<const void**>(&decompressedBuffer), &decompressedSize)) {
+    for (int32_t i = 0; i < decompressedSize; ++i) {
+      EXPECT_LT(static_cast<size_t>(pos), size);
+      EXPECT_EQ(data[pos], decompressedBuffer[i]);
+      ++pos;
+    }
+  }
+  ASSERT_EQ(pos, size);
+}
+
+void compressAndVerify(
+    CompressionKind kind,
+    FileSink& sink,
+    uint64_t block,
+    MemoryPool& pool,
+    const char* data,
+    size_t dataSize,
+    const Encrypter* encrypter) {
+  TestBufferPool bufferPool(pool, block);
+  DataBufferHolder holder{
+      pool, block, 0, DEFAULT_PAGE_GROW_RATIO, std::addressof(sink)};
+  Config config;
+  config.set<uint32_t>(Config::COMPRESSION_THRESHOLD, 128);
+  std::unique_ptr<BufferedOutputStream> compressStream =
+      createCompressor(kind, bufferPool, holder, config, encrypter);
+
+  size_t pos = 0;
+  char* compressBuffer;
+  int32_t compressBufferSize = 0;
+  while (dataSize > 0 &&
+         compressStream->Next(
+             reinterpret_cast<void**>(&compressBuffer), &compressBufferSize)) {
+    size_t copy_size =
+        std::min(static_cast<size_t>(compressBufferSize), dataSize);
+    memcpy(compressBuffer, data + pos, copy_size);
+
+    if (copy_size == dataSize) {
+      compressStream->BackUp(
+          compressBufferSize - static_cast<int32_t>(dataSize));
+    }
+
+    pos += copy_size;
+    dataSize -= copy_size;
+  }
+
+  EXPECT_EQ(0, dataSize);
+  compressStream->flush();
+}
+
+typedef std::tuple<CompressionKind, const Encrypter*, const Decrypter*>
+    TestParams;
+TestEncrypter testEncrypter;
+TestDecrypter testDecrypter;
+
+class CompressionTest : public TestWithParam<TestParams> {
+ public:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    auto tuple = GetParam();
+    kind_ = std::get<0>(tuple);
+    encrypter_ = std::get<1>(tuple);
+    decrypter_ = std::get<2>(tuple);
+  }
+
+ protected:
+  CompressionKind kind_;
+  const Encrypter* encrypter_;
+  const Decrypter* decrypter_;
+  std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+
+TEST_P(CompressionTest, compressOriginalString) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
+
+  uint64_t block = 128;
+
+  // simple, short string which will result in the original being saved
+  char testData[] = "hello world!";
+  compressAndVerify(
+      kind_, memSink, block, *pool_, testData, sizeof(testData), encrypter_);
+  decompressAndVerify(
+      memSink, kind_, block, testData, sizeof(testData), *pool_, decrypter_);
+}
+
+TEST_P(CompressionTest, compressSimpleRepeatedString) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
+
+  constexpr uint64_t block = 128;
+
+  // simple repeated string (128 'a's) which should be compressed
+  char testData[block];
+  std::memset(testData, 'a', block);
+  compressAndVerify(kind_, memSink, block, *pool_, testData, block, encrypter_);
+  decompressAndVerify(
+      memSink, kind_, block, testData, block, *pool_, decrypter_);
+}
+
+TEST_P(CompressionTest, compressTwoBlocks) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
+
+  uint64_t block = 128;
+  constexpr size_t size = 170;
+
+  // testData will be compressed in two blocks
+  char testData[size];
+  std::memset(testData, 'a', size);
+  compressAndVerify(kind_, memSink, block, *pool_, testData, size, encrypter_);
+  decompressAndVerify(
+      memSink, kind_, block, testData, size, *pool_, decrypter_);
+}
+
+TEST_P(CompressionTest, compressRandomLetters) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
+
+  uint64_t block = 1024;
+  constexpr size_t dataSize = 1024 * 1024; // 1M
+
+  // testData will be compressed in two blocks
+  char testData[dataSize];
+  generateRandomData(testData, dataSize, true);
+  compressAndVerify(
+      kind_, memSink, block, *pool_, testData, dataSize, encrypter_);
+  decompressAndVerify(
+      memSink, kind_, block, testData, dataSize, *pool_, decrypter_);
+}
+
+TEST_P(CompressionTest, compressRandomBytes) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
+
+  uint64_t block = 1024;
+  constexpr size_t dataSize = 1024 * 1024; // 1M
+
+  // testData will be compressed in two blocks
+  char testData[dataSize];
+  generateRandomData(testData, dataSize, false);
+  compressAndVerify(
+      kind_, memSink, block, *pool_, testData, dataSize, encrypter_);
+  decompressAndVerify(
+      memSink, kind_, block, testData, dataSize, *pool_, decrypter_);
+}
+
+void verifyProto(
+    const MemorySink& memSink,
+    CompressionKind kind,
+    uint64_t block,
+    MemoryPool& pool,
+    proto::PostScript& expected,
+    const Decrypter* decrypter) {
+  std::unique_ptr<SeekableInputStream> inputStream(
+      new SeekableArrayInputStream(memSink.data(), memSink.size()));
+
+  std::unique_ptr<SeekableInputStream> decompressStream = createDecompressor(
+      kind, std::move(inputStream), block, pool, "Test Comrpession", decrypter);
+
+  proto::PostScript ps;
+  ps.ParseFromZeroCopyStream(decompressStream.get());
+
+  EXPECT_EQ(expected.footerlength(), ps.footerlength());
+  EXPECT_EQ(expected.compression(), ps.compression());
+  EXPECT_EQ(expected.writerversion(), ps.writerversion());
+}
+
+TEST_P(CompressionTest, compressProtoBuf) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
+
+  uint64_t block = 256;
+
+  proto::PostScript ps;
+  ps.set_footerlength(197934);
+  ps.set_compression(
+      static_cast<proto::CompressionKind>(static_cast<int32_t>(kind_)));
+  ps.set_writerversion(789);
+
+  TestBufferPool bufferPool(*pool_, block);
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  Config config;
+  std::unique_ptr<BufferedOutputStream> compressStream =
+      createCompressor(kind_, bufferPool, holder, config, encrypter_);
+
+  EXPECT_TRUE(ps.SerializeToZeroCopyStream(compressStream.get()));
+  compressStream->flush();
+
+  verifyProto(memSink, kind_, block, *pool_, ps, decrypter_);
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TestCompression,
+    CompressionTest,
+    Values(
+        std::make_tuple(CompressionKind_ZLIB, nullptr, nullptr),
+        std::make_tuple(CompressionKind_ZLIB, &testEncrypter, &testDecrypter),
+        std::make_tuple(CompressionKind_ZSTD, nullptr, nullptr),
+        std::make_tuple(CompressionKind_ZSTD, &testEncrypter, &testDecrypter),
+        std::make_tuple(CompressionKind_NONE, nullptr, nullptr),
+        std::make_tuple(CompressionKind_NONE, &testEncrypter, &testDecrypter)));
+
+typedef std::tuple<CompressionKind, const Encrypter*> TestParams2;
+
+class RecordPositionTest : public TestWithParam<TestParams2> {
+ public:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    auto tuple = GetParam();
+    kind_ = std::get<0>(tuple);
+    encrypter_ = std::get<1>(tuple);
+  }
+
+ protected:
+  CompressionKind kind_;
+  const Encrypter* encrypter_;
+  std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+
+TEST_P(RecordPositionTest, testRecordPosition) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
+  uint64_t block = 256;
+  uint64_t initial = 128;
+
+  TestBufferPool bufferPool(*pool_, block);
+  DataBufferHolder holder{
+      *pool_, block, initial, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  Config config;
+  std::unique_ptr<BufferedOutputStream> stream =
+      createCompressor(kind_, bufferPool, holder, config, encrypter_);
+
+  TestPositionRecorder recorder;
+  EXPECT_EQ(stream->size(), 0);
+  stream->recordPosition(recorder, 3, 2);
+  {
+    auto& pos = recorder.getPositions();
+    EXPECT_EQ(pos.size(), 2);
+    EXPECT_EQ(pos.at(0), 0);
+    EXPECT_EQ(pos.at(1), 0);
+  }
+
+  int32_t size;
+  void* data;
+  stream->Next(&data, &size);
+  EXPECT_EQ(size, initial);
+  recorder.addEntry();
+  EXPECT_EQ(stream->size(), 0);
+  stream->recordPosition(recorder, size, 100);
+  {
+    auto& pos = recorder.getPositions();
+    EXPECT_EQ(pos.size(), 2);
+    EXPECT_EQ(pos.at(0), 0);
+    EXPECT_EQ(pos.at(1), 100);
+  }
+
+  stream->Next(&data, &size);
+  EXPECT_EQ(size, block - initial);
+  recorder.addEntry();
+  EXPECT_EQ(stream->size(), 0);
+  stream->recordPosition(recorder, size, 100);
+  {
+    auto& pos = recorder.getPositions();
+    EXPECT_EQ(pos.size(), 2);
+    EXPECT_EQ(pos.at(0), 0);
+    EXPECT_EQ(pos.at(1), 100 + initial);
+  }
+
+  stream->Next(&data, &size);
+  EXPECT_EQ(size, block);
+  recorder.addEntry();
+  EXPECT_GT(stream->size(), PAGE_HEADER_SIZE);
+  stream->recordPosition(recorder, size, 100);
+  {
+    auto& pos = recorder.getPositions();
+    EXPECT_EQ(pos.size(), 2);
+    EXPECT_EQ(pos.at(0), stream->size());
+    EXPECT_EQ(pos.at(1), 100);
+  }
+
+  recorder.addEntry();
+  stream->recordPosition(recorder, size, 100, 4);
+  auto& pos = recorder.getPositions(4);
+  EXPECT_EQ(pos.size(), 2);
+  EXPECT_EQ(pos.at(0), stream->size());
+  EXPECT_EQ(pos.at(1), 100);
+}
+
+TEST_P(CompressionTest, getCompressionBufferOOM) {
+  MemorySink memSink(10L << 20, {.pool = pool_.get()});
+  const uint64_t compressBlockSize{2L << 20};
+
+  struct {
+    bool oomOnNextCall;
+    bool hasSink;
+
+    std::string debugString() const {
+      return fmt::format("oomOnNextCall:{} hasSink:{}", oomOnNextCall, hasSink);
+    }
+  } testSettings[] = {
+      {true, true}, {true, false}, {false, true}, {false, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(fmt::format(
+        "{} compression {}",
+        testData.debugString(),
+        compressionKindToString(kind_)));
+
+    auto config = std::make_shared<Config>();
+    config->set<CompressionKind>(Config::COMPRESSION, kind_);
+    config->set<uint32_t>(Config::COMPRESSION_THRESHOLD, compressBlockSize / 2);
+    config->set<uint64_t>(Config::COMPRESSION_BLOCK_SIZE, compressBlockSize);
+    WriterContext context{
+        config,
+        memoryManager()->addRootPool(
+            "oomOnCompression",
+            kind_ == facebook::velox::common::CompressionKind_NONE ? 3L << 20
+                                                                   : 6L << 20)};
+    context.initBuffer();
+
+    DataBufferHolder holder{
+        context.getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM),
+        context.compressionBlockSize(),
+        context.getConfigs().get(Config::COMPRESSION_BLOCK_SIZE_MIN),
+        context.getConfigs().get(Config::COMPRESSION_BLOCK_SIZE_EXTEND_RATIO),
+        testData.hasSink ? &memSink : nullptr};
+
+    std::unique_ptr<BufferedOutputStream> compressStream = createCompressor(
+        kind_, context, holder, context.getConfigs(), encrypter_);
+    void* buffer;
+    int32_t nextBufferSize;
+    ASSERT_TRUE(
+        compressStream->Next(&buffer, &nextBufferSize, compressBlockSize));
+    char* data = static_cast<char*>(buffer);
+    for (int i = 0; i < compressBlockSize; ++i) {
+      data[i] = folly::Random::rand32() % 256;
+    }
+    if (testData.oomOnNextCall) {
+      VELOX_ASSERT_THROW(
+          compressStream->Next(&buffer, &nextBufferSize, compressBlockSize),
+          "Exceeded memory pool cap");
+    } else {
+      VELOX_ASSERT_THROW(compressStream->flush(), "Exceeded memory pool cap");
+    }
+    if (kind_ != facebook::velox::common::CompressionKind_NONE) {
+      auto compressionBuffer = context.getBuffer(0);
+      ASSERT_TRUE(compressionBuffer != nullptr);
+      context.returnBuffer(std::move(compressionBuffer));
+    } else {
+      ASSERT_TRUE(context.testingCompressionBuffer() == nullptr);
+    }
+  }
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TestCompression,
+    RecordPositionTest,
+    Values(
+        std::make_tuple(CompressionKind_ZLIB, nullptr),
+        std::make_tuple(CompressionKind_ZLIB, &testEncrypter),
+        std::make_tuple(CompressionKind_ZSTD, nullptr),
+        std::make_tuple(CompressionKind_ZSTD, &testEncrypter),
+        std::make_tuple(CompressionKind_NONE, &testEncrypter)));
+
+TEST(CompressionOptionsTest, testCompressionOptions) {
+  auto options = getDwrfOrcCompressionOptions(
+      facebook::velox::common::CompressionKind_ZLIB, 256, 4, 7);
+
+  EXPECT_EQ(
+      options.format.zlib.windowBits, Compressor::DWRF_ORC_ZLIB_WINDOW_BITS);
+  EXPECT_EQ(options.format.zlib.compressionLevel, 4);
+  EXPECT_EQ(options.compressionThreshold, 256);
+
+  options = getDwrfOrcCompressionOptions(
+      facebook::velox::common::CompressionKind_ZSTD, 256, 4, 7);
+
+  EXPECT_EQ(options.format.zstd.compressionLevel, 7);
+  EXPECT_EQ(options.compressionThreshold, 256);
+}
diff --git a/velox/dwio/dwrf/test/DataBufferHolderTests.cpp b/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
index 05d86d7d65b2b..55b0b6eab82ab 100644
--- a/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
+++ b/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
@@ -22,22 +22,29 @@ using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::memory;
 using facebook::velox::VeloxException;
 
-TEST(DataBufferHolderTests, InputCheck) {
-  auto pool = addDefaultLeafMemoryPool();
-  VELOX_ASSERT_THROW((DataBufferHolder{*pool, 0}), "");
-  VELOX_ASSERT_THROW((DataBufferHolder{*pool, 1024, 2048}), "");
-  VELOX_ASSERT_THROW((DataBufferHolder{*pool, 1024, 1024, 1.1f}), "");
-
-  { DataBufferHolder holder{*pool, 1024}; }
-  { DataBufferHolder holder{*pool, 1024, 512}; }
-  { DataBufferHolder holder{*pool, 1024, 512, 3.0f}; }
+class DataBufferHolderTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<MemoryPool> pool_{memoryManager()->addLeafPool()};
+};
+
+TEST_F(DataBufferHolderTest, InputCheck) {
+  VELOX_ASSERT_THROW((DataBufferHolder{*pool_, 0}), "");
+  VELOX_ASSERT_THROW((DataBufferHolder{*pool_, 1024, 2048}), "");
+  VELOX_ASSERT_THROW((DataBufferHolder{*pool_, 1024, 1024, 1.1f}), "");
+
+  { DataBufferHolder holder{*pool_, 1024}; }
+  { DataBufferHolder holder{*pool_, 1024, 512}; }
+  { DataBufferHolder holder{*pool_, 1024, 512, 3.0f}; }
 }
 
-TEST(DataBufferHolderTests, TakeAndGetBuffer) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink sink{1024, {.pool = pool.get()}};
-  DataBufferHolder holder{*pool, 1024, 0, 2.0f, &sink};
-  DataBuffer<char> buffer{*pool, 512};
+TEST_F(DataBufferHolderTest, TakeAndGetBuffer) {
+  MemorySink sink{1024, {.pool = pool_.get()}};
+  DataBufferHolder holder{*pool_, 1024, 0, 2.0f, &sink};
+  DataBuffer<char> buffer{*pool_, 512};
   std::memset(buffer.data(), 'a', 512);
   holder.take(buffer);
   ASSERT_EQ(holder.size(), 512);
@@ -56,11 +63,10 @@ TEST(DataBufferHolderTests, TakeAndGetBuffer) {
   ASSERT_EQ(holder.getBuffers().size(), 0);
 }
 
-TEST(DataBufferHolderTests, TruncateBufferHolder) {
-  auto pool = addDefaultLeafMemoryPool();
-  DataBufferHolder holder{*pool, 1024};
+TEST_F(DataBufferHolderTest, TruncateBufferHolder) {
+  DataBufferHolder holder{*pool_, 1024};
   constexpr size_t BUF_SIZE = 10;
-  DataBuffer<char> buffer{*pool, BUF_SIZE};
+  DataBuffer<char> buffer{*pool_, BUF_SIZE};
   std::memset(buffer.data(), 'a', BUF_SIZE);
   for (int32_t i = 0; i < 12; i++) {
     holder.take(buffer);
@@ -81,10 +87,9 @@ TEST(DataBufferHolderTests, TruncateBufferHolder) {
   }
 }
 
-TEST(DataBufferHolderTests, TakeAndGetBufferNoOutput) {
-  auto pool = addDefaultLeafMemoryPool();
-  DataBufferHolder holder{*pool, 1024};
-  DataBuffer<char> buffer{*pool, 512};
+TEST_F(DataBufferHolderTest, TakeAndGetBufferNoOutput) {
+  DataBufferHolder holder{*pool_, 1024};
+  DataBuffer<char> buffer{*pool_, 512};
   std::memset(buffer.data(), 'a', 512);
   holder.take(buffer);
   ASSERT_EQ(holder.size(), 512);
@@ -92,7 +97,7 @@ TEST(DataBufferHolderTests, TakeAndGetBufferNoOutput) {
   holder.take(buffer);
   ASSERT_EQ(holder.size(), 1024);
 
-  DataBuffer<char> output{*pool, 128};
+  DataBuffer<char> output{*pool_, 128};
   holder.spill(output);
   ASSERT_EQ(output.size(), 1024);
   for (size_t i = 0; i < 512; ++i) {
@@ -111,10 +116,9 @@ TEST(DataBufferHolderTests, TakeAndGetBufferNoOutput) {
   }
 }
 
-TEST(DataBufferHolderTests, Reset) {
-  auto pool = addDefaultLeafMemoryPool();
-  DataBufferHolder holder{*pool, 1024};
-  DataBuffer<char> buffer{*pool, 512};
+TEST_F(DataBufferHolderTest, Reset) {
+  DataBufferHolder holder{*pool_, 1024};
+  DataBuffer<char> buffer{*pool_, 512};
   std::memset(buffer.data(), 'a', 512);
   holder.take(buffer);
   ASSERT_EQ(holder.size(), 512);
@@ -125,18 +129,16 @@ TEST(DataBufferHolderTests, Reset) {
   ASSERT_FALSE(holder.isSuppressed());
 }
 
-TEST(DataBufferHolderTests, TryResize) {
-  auto pool = addDefaultLeafMemoryPool();
-  DataBufferHolder holder{*pool, 1024, 128};
+TEST_F(DataBufferHolderTest, TryResize) {
+  DataBufferHolder holder{*pool_, 1024, 128};
 
-  auto runTest = [&pool, &holder](
-                     uint64_t size,
+  auto runTest = [&](uint64_t size,
                      uint64_t capacity,
                      uint64_t headerSize,
                      uint64_t increment,
                      bool expected,
                      uint64_t expectedSize) {
-    DataBuffer<char> buffer{*pool, size};
+    DataBuffer<char> buffer{*pool_, size};
     ASSERT_EQ(size, buffer.size());
     if (capacity > size) {
       buffer.reserve(capacity);
@@ -240,10 +242,9 @@ TEST(DataBufferHolderTests, TryResize) {
       1024 + headerSize);
 }
 
-TEST(DataBufferHolderTests, TestGrowRatio) {
-  auto pool = addDefaultLeafMemoryPool();
-  DataBufferHolder holder{*pool, 1024, 16, 4.0f};
-  DataBuffer<char> buffer{*pool, 16};
+TEST_F(DataBufferHolderTest, TestGrowRatio) {
+  DataBufferHolder holder{*pool_, 1024, 16, 4.0f};
+  DataBuffer<char> buffer{*pool_, 16};
   ASSERT_TRUE(holder.tryResize(buffer, 0, 1));
   ASSERT_EQ(buffer.size(), 64);
 }
diff --git a/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp b/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp
new file mode 100644
index 0000000000000..842dd85cf2d6e
--- /dev/null
+++ b/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/common/DirectBufferedInput.h"
+#include <folly/Random.h>
+#include <folly/container/F14Map.h>
+#include <folly/executors/IOThreadPoolExecutor.h>
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/memory/MmapAllocator.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/dwrf/common/Common.h"
+#include "velox/dwio/dwrf/test/TestReadFile.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::dwio;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::cache;
+
+using facebook::velox::common::Region;
+
+using memory::MemoryAllocator;
+using IoStatisticsPtr = std::shared_ptr<IoStatistics>;
+
+struct TestRegion {
+  int32_t offset;
+  int32_t length;
+};
+
+class DirectBufferedInputTest : public testing::Test {
+ protected:
+  static constexpr int32_t kLoadQuantum = 8 << 20;
+
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    executor_ = std::make_unique<folly::IOThreadPoolExecutor>(10, 10);
+    ioStats_ = std::make_shared<IoStatistics>();
+    fileIoStats_ = std::make_shared<IoStatistics>();
+    tracker_ = std::make_shared<cache::ScanTracker>("", nullptr, kLoadQuantum);
+    file_ = std::make_shared<TestReadFile>(11, 100 << 20, fileIoStats_);
+    opts_ = std::make_unique<dwio::common::ReaderOptions>(pool_.get());
+    opts_->setLoadQuantum(kLoadQuantum);
+  }
+
+  void TearDown() override {
+    executor_->join();
+  }
+
+  std::unique_ptr<DirectBufferedInput> makeInput() {
+    return std::make_unique<DirectBufferedInput>(
+        file_,
+        dwio::common::MetricsLog::voidLog(),
+        1,
+        tracker_,
+        2,
+        ioStats_,
+        executor_.get(),
+        *opts_);
+  }
+
+  // Reads and checks the result of reading ''regions' and checks that this
+  // causes 'numIos' accesses to the file.
+  void testLoads(std::vector<TestRegion> regions, int32_t numIos) {
+    auto previous = file_->numIos();
+    auto input = makeInput();
+    std::vector<std::unique_ptr<SeekableInputStream>> streams;
+    for (auto i = 0; i < regions.size(); ++i) {
+      if (regions[i].length > 0) {
+        Region region;
+        region.offset = regions[i].offset;
+        region.length = regions[i].length;
+        StreamIdentifier si(i);
+        streams.push_back(input->enqueue(region, &si));
+      }
+    }
+    input->load(LogType::FILE);
+    for (auto i = 0; i < regions.size(); ++i) {
+      if (regions[i].length > 0) {
+        checkRead(streams[i].get(), regions[i]);
+      }
+    }
+    EXPECT_EQ(numIos, file_->numIos() - previous);
+  }
+
+  // Marks the numStreams first streams as densely read. A large number of
+  // references that all end in a read.
+  void makeDense(int32_t numStreams) {
+    for (auto i = 0; i < numStreams; ++i) {
+      StreamIdentifier si(i);
+      auto trackId = TrackingId(si.getId());
+      for (auto counter = 0; counter < 100; ++counter) {
+        tracker_->recordReference(trackId, 1000000, 1, 1);
+        tracker_->recordRead(trackId, 1000000, 1, 1);
+      }
+    }
+  }
+
+  void checkRead(SeekableInputStream* stream, TestRegion region) {
+    int32_t size;
+    int32_t totalRead = 0;
+    const void* buffer;
+    while (stream->Next(&buffer, &size)) {
+      file_->checkData(buffer, region.offset + totalRead, size);
+      totalRead += size;
+    }
+    EXPECT_EQ(region.length, totalRead);
+  }
+
+  std::unique_ptr<dwio::common::ReaderOptions> opts_;
+  std::shared_ptr<TestReadFile> file_;
+  std::shared_ptr<cache::ScanTracker> tracker_;
+  std::shared_ptr<IoStatistics> ioStats_;
+  std::shared_ptr<IoStatistics> fileIoStats_;
+  std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+};
+
+TEST_F(DirectBufferedInputTest, basic) {
+  // The small leading parts coalesce with the the 7M.  The 2M goes standalone.
+  // the last is read in 2 parts. This is because these are not yet densely
+  // accessed and thus coalescing only works to load quantum of 8MB.
+  testLoads(
+      {{100, 100},
+       {300, 100},
+       {1000, 7000000},
+       {7004000, 2000000},
+       {20000000, 10000000}},
+      4);
+
+  // All but the last coalesce into one , the last is read in 2 parts. The
+  // columns are now dense and coalesce goes up to 128MB if gaps are small
+  // enough.
+  testLoads(
+      {{100, 100},
+       {300, 100},
+       {1000, 7000000},
+       {7004000, 2000000},
+       {20000000, 10000000}},
+      3);
+
+  // Mark the first 4 ranges as densely accessed.
+  makeDense(4);
+
+  // The first and first part of second coalesce.
+  testLoads({{100, 100}, {1000, 10000000}}, 2);
+
+  // The first is read in two parts, the tail of the first does not coalesce
+  // with the second.
+  testLoads({{1000, 10000000}, {10001000, 1000}}, 3);
+
+  // One large standalone read in 2 parts.
+  testLoads({{1000, 10000000}}, 2);
+
+  // Small standalone read in 1 part.
+  testLoads({{100, 100}}, 1);
+
+  // Two small far apart
+  testLoads({{100, 100}, {1000000, 100}}, 2);
+  // The two coalesce because the first fits within load quantum + max coalesce
+  // distance.
+  testLoads({{1000, 8500000}, {8510000, 1000000}}, 1);
+
+  // The two coalesce because the first fits within load quantum + max coalesce
+  // distance. The tail of the second does not coalesce.
+  testLoads({{1000, 8500000}, {8510000, 8400000}}, 2);
+
+  // The first reads in 2 parts and does not coalesce to the second, which reads
+  // in one part.
+  testLoads({{1000, 9000000}, {9010000, 1000000}}, 3);
+}
diff --git a/velox/dwio/dwrf/test/E2EFilterTest.cpp b/velox/dwio/dwrf/test/E2EFilterTest.cpp
index f1fc1f611acb6..43b67e91e5508 100644
--- a/velox/dwio/dwrf/test/E2EFilterTest.cpp
+++ b/velox/dwio/dwrf/test/E2EFilterTest.cpp
@@ -15,7 +15,8 @@
  */
 
 #include "velox/common/base/Portability.h"
-#include "velox/dwio/common/tests/E2EFilterTestBase.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/dwio/common/tests/utils/E2EFilterTestBase.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/writer/FlushPolicy.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
@@ -78,21 +79,22 @@ class E2EFilterTest : public E2EFilterTestBase {
         200 * 1024 * 1024,
         dwio::common::FileSink::Options{.pool = leafPool_.get()});
     ASSERT_TRUE(sink->isBuffered());
-    sinkPtr_ = sink.get();
+    auto* sinkPtr = sink.get();
     options.memoryPool = rootPool_.get();
     writer_ = std::make_unique<dwrf::Writer>(std::move(sink), options);
     for (auto& batch : batches) {
       writer_->write(batch);
     }
     writer_->close();
+    sinkData_ = std::string_view(sinkPtr->data(), sinkPtr->size());
   }
 
   void setUpRowReaderOptions(
       dwio::common::RowReaderOptions& opts,
       const std::shared_ptr<ScanSpec>& spec) override {
     E2EFilterTestBase::setUpRowReaderOptions(opts, spec);
-    if (!flatmapNodeIdsAsStruct_.empty()) {
-      opts.setFlatmapNodeIdsAsStruct(flatmapNodeIdsAsStruct_);
+    for (auto& field : flatMapAsStructFields_) {
+      spec->childByName(field)->setFlatMapAsStruct(true);
     }
   }
 
@@ -125,6 +127,7 @@ class E2EFilterTest : public E2EFilterTestBase {
           mapFlatColsStructKeys.back().push_back(name);
         }
         columnTypes[i] = MAP(VARCHAR(), columnTypes[i]->childAt(0));
+        flatMapAsStructFields_.push_back(rowType.nameOf(i));
       }
       writerSchema = ROW(
           std::vector<std::string>(rowType.names()), std::move(columnTypes));
@@ -135,10 +138,6 @@ class E2EFilterTest : public E2EFilterTestBase {
         }
         auto& child = schemaWithId->childAt(i);
         mapFlatCols.push_back(child->column());
-        if (!rowType.childAt(i)->isRow()) {
-          continue;
-        }
-        flatmapNodeIdsAsStruct_[child->id()] = mapFlatColsStructKeys[i];
       }
       config->set(dwrf::Config::FLATTEN_MAP, true);
       config->set(dwrf::Config::MAP_FLAT_DISABLE_DICT_ENCODING, false);
@@ -156,8 +155,7 @@ class E2EFilterTest : public E2EFilterTestBase {
   }
 
   std::unique_ptr<dwrf::Writer> writer_;
-  std::unordered_map<uint32_t, std::vector<std::string>>
-      flatmapNodeIdsAsStruct_;
+  std::vector<std::string> flatMapAsStructFields_;
 };
 
 TEST_F(E2EFilterTest, integerDirect) {
@@ -244,6 +242,14 @@ TEST_F(E2EFilterTest, floatAndDouble) {
 }
 
 TEST_F(E2EFilterTest, stringDirect) {
+  testutil::TestValue::enable();
+  bool coverage[2][2]{};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::SelectiveStringDirectColumnReader::try8ConsecutiveSmall",
+      std::function<void(bool*)>([&](bool* params) {
+        coverage[0][params[0]] = true;
+        coverage[1][params[1]] = true;
+      }));
   flushEveryNBatches_ = 1;
   testWithTypes(
       "string_val:string,"
@@ -252,11 +258,16 @@ TEST_F(E2EFilterTest, stringDirect) {
         makeStringUnique("string_val");
         makeStringUnique("string_val_2");
       },
-
       true,
       {"string_val", "string_val_2"},
       20,
       true);
+#ifndef NDEBUG
+  ASSERT_TRUE(coverage[0][0]);
+  ASSERT_TRUE(coverage[0][1]);
+  ASSERT_TRUE(coverage[1][0]);
+  ASSERT_TRUE(coverage[1][1]);
+#endif
 }
 
 TEST_F(E2EFilterTest, stringDictionary) {
@@ -373,8 +384,7 @@ TEST_F(E2EFilterTest, flatMapAsStruct) {
       "long_vals:struct<v1:bigint,v2:bigint,v3:bigint>,"
       "struct_vals:struct<nested1:struct<v1:bigint, v2:float>,nested2:struct<v1:bigint, v2:float>>";
   flatMapColumns_ = {"long_vals", "struct_vals"};
-  testWithTypes(
-      kColumns, [] {}, false, {"long_val"}, 10, true);
+  testWithTypes(kColumns, [] {}, false, {"long_val"}, 10, true);
 }
 
 TEST_F(E2EFilterTest, flatMapScalar) {
@@ -439,6 +449,6 @@ TEST_F(E2EFilterTest, mutationCornerCases) {
 // Define main so that gflags get processed.
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/dwio/dwrf/test/E2EReaderTest.cpp b/velox/dwio/dwrf/test/E2EReaderTest.cpp
new file mode 100644
index 0000000000000..3e3ab15f1964d
--- /dev/null
+++ b/velox/dwio/dwrf/test/E2EReaderTest.cpp
@@ -0,0 +1,371 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "folly/Conv.h"
+#include "folly/Random.h"
+#include "folly/String.h"
+#include "velox/common/file/File.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/dwio/common/FileSink.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/dwio/dwrf/common/Config.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h"
+#include "velox/type/fbhive/HiveTypeParser.h"
+
+using namespace ::testing;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwrf;
+using namespace facebook::velox::test;
+using namespace facebook::velox::type::fbhive;
+using namespace facebook::velox;
+
+namespace {
+
+class RemoveGuard {
+ public:
+  explicit RemoveGuard(std::string path) : path_(std::move(path)) {}
+
+  ~RemoveGuard() {
+    std::remove(path_.c_str());
+  }
+
+ private:
+  std::string path_;
+};
+
+enum class Decoding { SERIAL, PARALLEL };
+enum class FlatMapAs { MAP, STRUCT };
+
+class ValueTypes {
+  static constexpr size_t kParallelismFactor = 2;
+
+ public:
+  ValueTypes(
+      Decoding decoding,
+      FlatMapAs flatMapAs,
+      std::initializer_list<std::string> values)
+      : values_(std::move(values)),
+        executor_{
+            decoding == Decoding::PARALLEL
+                ? std::make_shared<folly::CPUThreadPoolExecutor>(
+                      kParallelismFactor)
+                : nullptr},
+        asStruct_{flatMapAs == FlatMapAs::STRUCT} {}
+
+  auto size() const {
+    return values_.size();
+  }
+
+  auto begin() const {
+    return values_.begin();
+  }
+
+  auto end() const {
+    return values_.end();
+  }
+
+  const std::shared_ptr<folly::Executor>& decodingExecutor() const {
+    return executor_;
+  }
+
+  const size_t decodingParallelismFactor() const {
+    return executor_ ? kParallelismFactor : 0;
+  }
+
+  bool isReadAsStruct() const {
+    return asStruct_;
+  }
+
+ private:
+  std::vector<std::string> values_;
+  std::shared_ptr<folly::Executor> executor_;
+  bool asStruct_;
+};
+
+class E2EReaderTest : public testing::TestWithParam<ValueTypes> {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+} // namespace
+
+TEST_P(E2EReaderTest, SharedDictionaryFlatmapReadAsStruct) {
+  const size_t batchCount = 10;
+  size_t size = 1;
+  auto pool = memory::memoryManager()->addLeafPool();
+
+  std::vector<uint32_t> flatMapCols(GetParam().size());
+  std::iota(flatMapCols.begin(), flatMapCols.end(), 0);
+
+  std::string schema = "struct<";
+  for (auto& valueType : GetParam()) {
+    schema += folly::to<std::string>("map_val:map<int,", valueType, ">,");
+  }
+  schema.append(">");
+  HiveTypeParser parser;
+  auto type = parser.parse(schema);
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::ROW_INDEX_STRIDE, static_cast<uint32_t>(1000));
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set<const std::vector<uint32_t>>(
+      dwrf::Config::MAP_FLAT_COLS, flatMapCols);
+  config->set(dwrf::Config::MAP_FLAT_DISABLE_DICT_ENCODING, false);
+  config->set(dwrf::Config::MAP_FLAT_DISABLE_DICT_ENCODING_STRING, false);
+  config->set(dwrf::Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 1.0f);
+  config->set(dwrf::Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 1.0f);
+  config->set(dwrf::Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
+
+  auto suffix = folly::to<std::string>(folly::Random::secureRand32());
+  auto path = "/tmp/e2e_reader_test_shared_dictionary_" + suffix + ".orc";
+  RemoveGuard guard(path);
+  auto localWriteFile = std::make_unique<LocalWriteFile>(path, true, false);
+  auto sink = std::make_unique<WriteFileSink>(std::move(localWriteFile), path);
+  auto writer = E2EWriterTestUtil::createWriter(
+      std::move(sink),
+      type,
+      config,
+      E2EWriterTestUtil::simpleFlushPolicyFactory(true));
+
+  auto seed = folly::Random::secureRand32();
+  LOG(INFO) << "seed: " << seed;
+  std::mt19937 gen(seed);
+  auto cs = std::make_shared<ColumnSelector>(
+      std::dynamic_pointer_cast<const RowType>(type));
+  std::unordered_map<uint32_t, std::unordered_set<std::string>>
+      structEncodingProtoMap;
+  const auto schemaWithId = cs->getSchemaWithId();
+  for (size_t i = 0; i < batchCount; ++i) {
+    auto batch = BatchMaker::createBatch(type, size, *pool, gen);
+    for (size_t col = 0, schemaSize = schemaWithId->size(); col < schemaSize;
+         ++col) {
+      auto& set = structEncodingProtoMap[schemaWithId->childAt(col)->id()];
+      auto keys = batch->as<RowVector>()
+                      ->childAt(col)
+                      ->as<MapVector>()
+                      ->mapKeys()
+                      ->as<SimpleVector<int32_t>>();
+      for (vector_size_t featureIdx = 0, featureCount = keys->size();
+           featureIdx < featureCount;
+           ++featureIdx) {
+        set.insert(keys->toString(featureIdx));
+      }
+    }
+    writer->write(std::move(batch));
+    size = std::min(size * 2, 2048UL);
+  }
+  writer->close();
+  writer.reset();
+
+  dwio::common::ReaderOptions readerOpts{pool.get()};
+  auto bufferedInput = std::make_unique<BufferedInput>(
+      std::make_shared<LocalReadFile>(path), *pool);
+  auto reader = DwrfReader::create(std::move(bufferedInput), readerOpts);
+
+  RowReaderOptions rowReaderOptions;
+  rowReaderOptions.setDecodingExecutor(GetParam().decodingExecutor());
+  rowReaderOptions.setDecodingParallelismFactor(
+      GetParam().decodingParallelismFactor());
+  rowReaderOptions.select(cs);
+
+  const bool asStruct = GetParam().isReadAsStruct();
+  if (asStruct) {
+    std::unordered_map<uint32_t, std::vector<std::string>> structEncodingMap;
+    for (auto& [id, keys] : structEncodingProtoMap) {
+      structEncodingMap[id].reserve(keys.size());
+      for (auto& key : keys) {
+        structEncodingMap[id].push_back(key);
+      }
+    }
+    rowReaderOptions.setFlatmapNodeIdsAsStruct(structEncodingMap);
+  }
+
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr batch;
+  while (rowReader->next(100, batch)) {
+    ASSERT_TRUE(type->isRow());
+    ASSERT_TRUE(batch->type()->isRow());
+    auto& schemaRow = type->as<TypeKind::ROW>();
+    auto& resultTypeRow = batch->type()->as<TypeKind::ROW>();
+    auto* batchRow = batch->as<RowVector>();
+    ASSERT_EQ(schemaRow.size(), resultTypeRow.size());
+    for (size_t col = 0, columns = schemaRow.size(); col < columns; ++col) {
+      auto& schemaChild = schemaRow.childAt(col)->as<TypeKind::MAP>();
+      ASSERT_TRUE(schemaRow.childAt(col)->isMap());
+      if (asStruct) {
+        // Type should be ROW since it's struct encoding
+        ASSERT_TRUE(resultTypeRow.childAt(col)->isRow());
+        ASSERT_EQ(batchRow->childAt(col)->typeKind(), TypeKind::ROW);
+        auto& resultTypeChild = resultTypeRow.childAt(col)->as<TypeKind::ROW>();
+        auto* batchRowChild = batchRow->childAt(col)->as<RowVector>();
+        ASSERT_EQ(resultTypeChild.size(), batchRowChild->children().size());
+        for (uint32_t feature = 0, features = resultTypeChild.size();
+             feature < features;
+             ++feature) {
+          ASSERT_EQ(
+              schemaChild.valueType()->kind(),
+              resultTypeChild.childAt(feature)->kind());
+          ASSERT_EQ(
+              resultTypeChild.childAt(feature)->kind(),
+              batchRowChild->childAt(feature)->typeKind());
+        }
+      } else {
+        ASSERT_TRUE(resultTypeRow.childAt(col)->isMap());
+        ASSERT_EQ(batchRow->childAt(col)->typeKind(), TypeKind::MAP);
+        auto& resultTypeChild = resultTypeRow.childAt(col)->as<TypeKind::MAP>();
+        auto* batchRowChild = batchRow->childAt(col)->as<MapVector>();
+        ASSERT_EQ(
+            resultTypeChild.keyType()->kind(), schemaChild.keyType()->kind());
+        ASSERT_EQ(
+            resultTypeChild.valueType()->kind(),
+            schemaChild.valueType()->kind());
+      }
+    }
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    SingleTypesSerialMap,
+    E2EReaderTest,
+    ValuesIn(std::vector<ValueTypes>{
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"tinyint"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"smallint"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"integer"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"bigint"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"string"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<tinyint>"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<smallint>"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<integer>"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<bigint>"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::MAP, {"array<string>"})}));
+
+INSTANTIATE_TEST_SUITE_P(
+    SingleTypesSerialStruct,
+    E2EReaderTest,
+    ValuesIn(std::vector<ValueTypes>{
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"tinyint"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"smallint"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"integer"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"bigint"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"string"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<tinyint>"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<smallint>"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<integer>"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<bigint>"}),
+        ValueTypes(Decoding::SERIAL, FlatMapAs::STRUCT, {"array<string>"})}));
+
+INSTANTIATE_TEST_SUITE_P(
+    AllTypesSerialMap,
+    E2EReaderTest,
+    ValuesIn(std::vector<ValueTypes>{ValueTypes(
+        Decoding::SERIAL,
+        FlatMapAs::MAP,
+        {"tinyint",
+         "smallint",
+         "integer",
+         "bigint",
+         "string",
+         "array<tinyint>",
+         "array<smallint>",
+         "array<integer>",
+         "array<bigint>",
+         "array<string>"})}));
+
+INSTANTIATE_TEST_SUITE_P(
+    AllTypesSerialStruct,
+    E2EReaderTest,
+    ValuesIn(std::vector<ValueTypes>{ValueTypes(
+        Decoding::SERIAL,
+        FlatMapAs::STRUCT,
+        {"tinyint",
+         "smallint",
+         "integer",
+         "bigint",
+         "string",
+         "array<tinyint>",
+         "array<smallint>",
+         "array<integer>",
+         "array<bigint>",
+         "array<string>"})}));
+
+INSTANTIATE_TEST_SUITE_P(
+    SingleTypesParallelMap,
+    E2EReaderTest,
+    ValuesIn(std::vector<ValueTypes>{
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"tinyint"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"smallint"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"integer"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"bigint"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"string"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<tinyint>"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<smallint>"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<integer>"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<bigint>"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::MAP, {"array<string>"})}));
+
+INSTANTIATE_TEST_SUITE_P(
+    SingleTypesParallelStruct,
+    E2EReaderTest,
+    ValuesIn(std::vector<ValueTypes>{
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"tinyint"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"smallint"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"integer"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"bigint"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"string"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<tinyint>"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<smallint>"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<integer>"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<bigint>"}),
+        ValueTypes(Decoding::PARALLEL, FlatMapAs::STRUCT, {"array<string>"})}));
+
+INSTANTIATE_TEST_SUITE_P(
+    AllTypesParallelMap,
+    E2EReaderTest,
+    ValuesIn(std::vector<ValueTypes>{ValueTypes(
+        Decoding::PARALLEL,
+        FlatMapAs::MAP,
+        {"tinyint",
+         "smallint",
+         "integer",
+         "bigint",
+         "string",
+         "array<tinyint>",
+         "array<smallint>",
+         "array<integer>",
+         "array<bigint>",
+         "array<string>"})}));
+
+INSTANTIATE_TEST_SUITE_P(
+    AllTypesParallelStruct,
+    E2EReaderTest,
+    ValuesIn(std::vector<ValueTypes>{ValueTypes(
+        Decoding::PARALLEL,
+        FlatMapAs::STRUCT,
+        {"tinyint",
+         "smallint",
+         "integer",
+         "bigint",
+         "string",
+         "array<tinyint>",
+         "array<smallint>",
+         "array<integer>",
+         "array<bigint>",
+         "array<string>"})}));
diff --git a/velox/dwio/dwrf/test/E2EWriterTest.cpp b/velox/dwio/dwrf/test/E2EWriterTest.cpp
new file mode 100644
index 0000000000000..f8cccab6575d9
--- /dev/null
+++ b/velox/dwio/dwrf/test/E2EWriterTest.cpp
@@ -0,0 +1,2141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Random.h>
+#include <random>
+#include "velox/common/base/SpillConfig.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/dwio/common/encryption/TestProvider.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/dwio/common/tests/utils/MapBuilder.h"
+#include "velox/dwio/dwrf/common/Config.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/dwio/dwrf/test/OrcTest.h"
+#include "velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/type/fbhive/HiveTypeParser.h"
+#include "velox/vector/FlatVector.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+using namespace ::testing;
+using namespace facebook::velox::common::testutil;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwio::common::encryption;
+using namespace facebook::velox::dwio::common::encryption::test;
+using namespace facebook::velox::test;
+using namespace facebook::velox::dwrf::encryption;
+using namespace facebook::velox::type::fbhive;
+using namespace facebook::velox;
+using facebook::velox::memory::MemoryPool;
+using folly::Random;
+
+constexpr uint64_t kSizeMB = 1024UL * 1024UL;
+
+namespace {
+class E2EWriterTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    TestValue::enable();
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  E2EWriterTest() {
+    rootPool_ = memory::memoryManager()->addRootPool("E2EWriterTest");
+    leafPool_ = rootPool_->addLeafChild("leaf");
+  }
+
+  std::unique_ptr<dwrf::DwrfReader> createReader(
+      const MemorySink& sink,
+      const dwio::common::ReaderOptions& opts) {
+    std::string_view data(sink.data(), sink.size());
+    return std::make_unique<dwrf::DwrfReader>(
+        opts,
+        std::make_unique<BufferedInput>(
+            std::make_shared<InMemoryReadFile>(data), opts.memoryPool()));
+  }
+
+  void testFlatMapConfig(
+      std::shared_ptr<const Type> type,
+      const std::vector<uint32_t>& mapColumnIds,
+      const std::unordered_set<uint32_t>& expectedNodeIds) {
+    size_t batchSize = 100;
+    size_t stripes = 3;
+
+    // write file to memory
+    auto config = std::make_shared<dwrf::Config>();
+    config->set(dwrf::Config::FLATTEN_MAP, true);
+    config->set<const std::vector<uint32_t>>(
+        dwrf::Config::MAP_FLAT_COLS, mapColumnIds);
+    config->set(dwrf::Config::MAP_STATISTICS, true);
+
+    auto sink = std::make_unique<MemorySink>(
+        200 * 1024 * 1024,
+        dwio::common::FileSink::Options{.pool = leafPool_.get()});
+    auto sinkPtr = sink.get();
+
+    dwrf::WriterOptions options;
+    options.config = config;
+    options.schema = type;
+    options.memoryPool = rootPool_.get();
+    dwrf::Writer writer{std::move(sink), options};
+
+    for (size_t i = 0; i < stripes; ++i) {
+      writer.write(
+          BatchMaker::createBatch(type, batchSize, *leafPool_, nullptr, i));
+    }
+
+    writer.close();
+
+    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    RowReaderOptions rowReaderOpts;
+    auto reader = createReader(*sinkPtr, readerOpts);
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    auto dwrfRowReader = dynamic_cast<dwrf::DwrfRowReader*>(rowReader.get());
+    bool preload = true;
+    std::unordered_set<uint32_t> actualNodeIds;
+    for (int32_t i = 0; i < reader->getNumberOfStripes(); ++i) {
+      auto stripeMetadata = dwrfRowReader->fetchStripe(i, preload);
+      auto& footer = *stripeMetadata->footer;
+      for (int32_t j = 0; j < footer.encoding_size(); ++j) {
+        auto encoding = footer.encoding(j);
+        if (encoding.kind() ==
+            dwrf::proto::ColumnEncoding_Kind::ColumnEncoding_Kind_MAP_FLAT) {
+          actualNodeIds.insert(encoding.node());
+        }
+      }
+      ASSERT_EQ(expectedNodeIds, actualNodeIds);
+    }
+  }
+
+  void testFlatMapFileStats(
+      std::shared_ptr<const Type> type,
+      const std::vector<uint32_t>& mapColumnIds,
+      const uint32_t strideSize = 10000,
+      const uint32_t rowCount = 2000) {
+    size_t stripes = 3;
+
+    // write file to memory
+    auto config = std::make_shared<dwrf::Config>();
+    // Ensure we cross stride boundary
+    config->set(dwrf::Config::ROW_INDEX_STRIDE, strideSize);
+    config->set(dwrf::Config::FLATTEN_MAP, true);
+    config->set<const std::vector<uint32_t>>(
+        dwrf::Config::MAP_FLAT_COLS, mapColumnIds);
+    config->set(dwrf::Config::MAP_STATISTICS, true);
+
+    auto sink = std::make_unique<MemorySink>(
+        400 * 1024 * 1024,
+        dwio::common::FileSink::Options{.pool = leafPool_.get()});
+    auto sinkPtr = sink.get();
+
+    dwrf::WriterOptions options;
+    options.config = config;
+    options.schema = type;
+    options.memoryPool = rootPool_.get();
+    dwrf::Writer writer{std::move(sink), options};
+
+    const size_t seed = std::time(nullptr);
+    LOG(INFO) << "seed: " << seed;
+    std::mt19937 gen{};
+    gen.seed(seed);
+    for (size_t i = 0; i < stripes; ++i) {
+      // The logic really does not depend on data shape. Hence, we can
+      // ignore the nulls.
+      writer.write(
+          BatchMaker::createBatch(type, rowCount, *leafPool_, gen, nullptr));
+      writer.flush();
+    }
+
+    writer.close();
+
+    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    RowReaderOptions rowReaderOpts;
+    auto reader = createReader(*sinkPtr, readerOpts);
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+
+    auto dwrfRowReader = dynamic_cast<dwrf::DwrfRowReader*>(rowReader.get());
+    bool preload = true;
+
+    auto typeWithId = TypeWithId::create(type);
+    for (auto mapColumn : mapColumnIds) {
+      folly::F14FastMap<KeyInfo, uint64_t, folly::transparent<KeyInfoHash>>
+          featureStreamSizes;
+      auto mapTypeId = typeWithId->childAt(mapColumn)->id();
+      auto valueTypeId = mapTypeId + 2;
+      for (int32_t i = 0; i < reader->getNumberOfStripes(); ++i) {
+        auto stripeMetadata = dwrfRowReader->fetchStripe(i, preload);
+        auto& currentStripeInfo = stripeMetadata->stripeInfo;
+        dwrf::StripeStreamsImpl stripeStreams(
+            std::make_shared<dwrf::StripeReadState>(
+                dwrfRowReader->readerBaseShared(), std::move(stripeMetadata)),
+            &dwrfRowReader->getColumnSelector(),
+            nullptr,
+            rowReaderOpts,
+            currentStripeInfo.offset(),
+            currentStripeInfo.numberOfRows(),
+            *dwrfRowReader,
+            i);
+
+        folly::F14FastMap<int64_t, dwio::common::KeyInfo> sequenceToKey;
+
+        stripeStreams.visitStreamsOfNode(
+            valueTypeId, [&](const dwrf::StreamInformation& stream) {
+              auto sequence = stream.getSequence();
+              // No need to load shared dictionary stream here.
+              if (sequence == 0) {
+                return;
+              }
+
+              dwrf::EncodingKey seqEk(valueTypeId, sequence);
+              const auto& keyInfo = stripeStreams.getEncoding(seqEk).key();
+              auto key = dwrf::constructKey(keyInfo);
+              sequenceToKey.emplace(sequence, key);
+            });
+
+        auto allStreams = stripeStreams.getStreamIdentifiers();
+        for (const auto& streamIdPerNode : allStreams) {
+          for (const auto& streamId : streamIdPerNode.second) {
+            if (streamId.encodingKey().sequence() != 0 &&
+                streamId.column() == mapColumn) {
+              // Update the aggregate.
+              const auto& keyInfo =
+                  sequenceToKey.at(streamId.encodingKey().sequence());
+              auto streamLength = stripeStreams.getStreamLength(streamId);
+              auto it = featureStreamSizes.find(keyInfo);
+              if (it == featureStreamSizes.end()) {
+                featureStreamSizes.emplace(keyInfo, streamLength);
+              } else {
+                it->second += streamLength;
+              }
+            }
+          }
+        }
+      }
+      auto stats = reader->getFooter().statistics(mapTypeId);
+      ASSERT_TRUE(stats.hasMapStatistics());
+      ASSERT_EQ(featureStreamSizes.size(), stats.mapStatistics().stats_size());
+      for (size_t i = 0; i != stats.mapStatistics().stats_size(); ++i) {
+        const auto& entry = stats.mapStatistics().stats(i);
+        ASSERT_TRUE(entry.stats().has_size());
+        EXPECT_EQ(
+            featureStreamSizes.at(dwrf::constructKey(entry.key())),
+            entry.stats().size());
+      }
+    }
+  }
+
+  static common::SpillConfig getSpillConfig(
+      int32_t minSpillableReservationPct,
+      int32_t spillableReservationGrowthPct,
+      uint64_t writerFlushThresholdSize = 0) {
+    static const std::string emptySpillFolder = "";
+    return common::SpillConfig(
+        [&]() -> const std::string& { return emptySpillFolder; },
+        [&](uint64_t) {},
+        "fakeSpillConfig",
+        0,
+        0,
+        0,
+        nullptr,
+        minSpillableReservationPct,
+        spillableReservationGrowthPct,
+        0,
+        0,
+        0,
+        0,
+        writerFlushThresholdSize,
+        "none");
+  }
+
+  std::shared_ptr<MemoryPool> rootPool_;
+  std::shared_ptr<MemoryPool> leafPool_;
+};
+
+// This test can be run to generate test files. Run it with following command
+// buck test velox/dwio/dwrf/test:velox_dwrf_e2e_writer_tests --
+// DISABLED_TestFileCreation
+// --run-disabled
+TEST_F(E2EWriterTest, DISABLED_TestFileCreation) {
+  const size_t batchCount = 4;
+  const size_t batchSize = 200;
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "byte_val:tinyint,"
+      "short_val:smallint,"
+      "int_val:int,"
+      "long_val:bigint,"
+      "float_val:float,"
+      "double_val:double,"
+      "string_val:string,"
+      "binary_val:binary,"
+      "timestamp_val:timestamp,"
+      "array_val:array<float>,"
+      "map_val:map<int,double>,"
+      "map_val:map<bigint,double>," /* this is column 12 */
+      "map_val:map<bigint,map<string, int>>," /* this is column 13 */
+      "struct_val:struct<a:float,b:double>"
+      ">");
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(
+      dwrf::Config::MAP_FLAT_COLS,
+      {12, 13}); /* this is the second and third map */
+
+  std::vector<VectorPtr> batches;
+  for (size_t i = 0; i < batchCount; ++i) {
+    batches.push_back(
+        BatchMaker::createBatch(type, batchSize, *leafPool_, nullptr, i));
+  }
+
+  auto path = "/tmp/e2e_generated_file.orc";
+  auto localWriteFile = std::make_unique<LocalWriteFile>(path, true, false);
+  auto sink = std::make_unique<WriteFileSink>(std::move(localWriteFile), path);
+  dwrf::E2EWriterTestUtil::writeData(
+      std::move(sink),
+      type,
+      batches,
+      config,
+      dwrf::E2EWriterTestUtil::simpleFlushPolicyFactory(true));
+}
+
+VectorPtr createRowVector(
+    facebook::velox::memory::MemoryPool* pool,
+    std::shared_ptr<const Type> type,
+    size_t batchSize,
+    const VectorPtr& child) {
+  return std::make_shared<RowVector>(
+      pool,
+      type,
+      BufferPtr(nullptr),
+      batchSize,
+      std::vector<VectorPtr>{child},
+      /*nullCount=*/0);
+}
+
+TEST_F(E2EWriterTest, E2E) {
+  const size_t batchCount = 4;
+  // Start with a size larger than stride to cover splitting into
+  // strides. Continue with smaller size for faster test.
+  size_t batchSize = 1100;
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "byte_val:tinyint,"
+      "short_val:smallint,"
+      "int_val:int,"
+      "long_val:bigint,"
+      "float_val:float,"
+      "double_val:double,"
+      "string_val:string,"
+      "binary_val:binary,"
+      "timestamp_val:timestamp,"
+      "array_val:array<float>,"
+      "map_val:map<int,double>,"
+      "map_val:map<bigint,double>," /* this is column 12 */
+      "map_val:map<bigint,map<string, int>>," /* this is column 13 */
+      "struct_val:struct<a:float,b:double>"
+      ">");
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::ROW_INDEX_STRIDE, static_cast<uint32_t>(1000));
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(
+      dwrf::Config::MAP_FLAT_COLS,
+      {12, 13}); /* this is the second and third map */
+
+  std::vector<VectorPtr> batches;
+  for (size_t i = 0; i < batchCount; ++i) {
+    batches.push_back(
+        BatchMaker::createBatch(type, batchSize, *leafPool_, nullptr, i));
+    batchSize = 200;
+  }
+
+  dwrf::E2EWriterTestUtil::testWriter(*leafPool_, type, batches, 1, 1, config);
+}
+
+// Disabled because test is failing in continuous runs T193531984.
+TEST_F(E2EWriterTest, DISABLED_DisableLinearHeuristics) {
+  const size_t batchCount = 100;
+  size_t batchSize = 3000;
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "byte_val:tinyint,"
+      "short_val:smallint,"
+      "int_val:int,"
+      "long_val:bigint,"
+      "float_val:float,"
+      "double_val:double,"
+      "string_val:string,"
+      "binary_val:binary,"
+      "timestamp_val:timestamp,"
+      "array_val:array<float>,"
+      "map_val:map<int,double>,"
+      "map_val:map<bigint,double>," /* this is column 12 */
+      "map_val:map<bigint,map<string, int>>," /* this is column 13 */
+      "struct_val:struct<a:float,b:double>"
+      ">");
+
+  auto batches = dwrf::E2EWriterTestUtil::generateBatches(
+      type, batchCount, batchSize, /*seed=*/1411367325, *leafPool_);
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::ROW_INDEX_STRIDE, static_cast<uint32_t>(1000));
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(
+      dwrf::Config::MAP_FLAT_COLS,
+      {12, 13}); /* this is the second and third map */
+  config->set<uint64_t>(dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN, 64UL);
+  config->set<uint64_t>(dwrf::Config::STRIPE_SIZE, 25UL * 1024 * 1024);
+
+  // default mode writer
+  dwrf::E2EWriterTestUtil::testWriter(*leafPool_, type, batches, 3, 3, config);
+
+  // disable linear heuristics
+  config->set(dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS, false);
+  dwrf::E2EWriterTestUtil::testWriter(*leafPool_, type, batches, 2, 3, config);
+}
+
+// Beside writing larger files, this test also uses regular maps only.
+// Disabled because test is failing in continuous runs T193531984.
+TEST_F(E2EWriterTest, DISABLED_DisableLinearHeuristicsLargeAnalytics) {
+  const size_t batchCount = 500;
+  size_t batchSize = 3000;
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "byte_val:tinyint,"
+      "short_val:smallint,"
+      "int_val:int,"
+      "long_val:bigint,"
+      "float_val:float,"
+      "double_val:double,"
+      "string_val:string,"
+      "binary_val:binary,"
+      "timestamp_val:timestamp,"
+      "array_val:array<float>,"
+      "map_val:map<int,double>,"
+      "map_val:map<bigint,double>," /* this is column 12 */
+      "map_val:map<bigint,map<string, int>>," /* this is column 13 */
+      "struct_val:struct<a:float,b:double>"
+      ">");
+
+  auto batches = dwrf::E2EWriterTestUtil::generateBatches(
+      type, batchCount, batchSize, /*seed=*/1411367325, *leafPool_);
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set<uint64_t>(dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN, 64UL);
+  config->set<uint64_t>(dwrf::Config::STRIPE_SIZE, 25UL * 1024 * 1024);
+
+  // default mode writer
+  dwrf::E2EWriterTestUtil::testWriter(
+      *leafPool_, type, batches, 10, 10, config);
+
+  // disable linear heuristics
+  config->set(dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS, false);
+  // When disabling linear heuristics, avg stripe size goes up to ~33MB from
+  // ~25MB.
+  dwrf::E2EWriterTestUtil::testWriter(*leafPool_, type, batches, 8, 8, config);
+}
+
+TEST_F(E2EWriterTest, FlatMapDictionaryEncoding) {
+  const size_t batchCount = 4;
+  // Start with a size larger than stride to cover splitting into
+  // strides. Continue with smaller size for faster test.
+  size_t batchSize = 1100;
+  auto pool = memory::memoryManager()->addLeafPool();
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "map_val:map<int,double>,"
+      "map_val:map<bigint,double>,"
+      "map_val:map<bigint,map<string, int>>,"
+      "map_val:map<int, string>,"
+      "map_val:map<bigint,map<int, string>>"
+      ">");
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::ROW_INDEX_STRIDE, static_cast<uint32_t>(1000));
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0, 1, 2, 3, 4});
+  config->set(dwrf::Config::MAP_FLAT_DISABLE_DICT_ENCODING, false);
+  config->set(dwrf::Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 1.0f);
+  config->set(dwrf::Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 1.0f);
+  config->set(dwrf::Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
+
+  std::vector<VectorPtr> batches;
+  std::mt19937 gen;
+  gen.seed(983871726);
+  for (size_t i = 0; i < batchCount; ++i) {
+    batches.push_back(BatchMaker::createBatch(type, batchSize, *pool, gen));
+    batchSize = 200;
+  }
+
+  dwrf::E2EWriterTestUtil::testWriter(*pool, type, batches, 1, 1, config);
+}
+
+TEST_F(E2EWriterTest, MaxFlatMapKeys) {
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  const uint32_t keyLimit = 2000;
+  const auto randomStart = Random::rand32(100);
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  b::row row;
+  for (int32_t i = 0; i < keyLimit; ++i) {
+    row.push_back(b::pair{randomStart + i, Random::rand64()});
+  }
+
+  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
+  auto batch =
+      createRowVector(pool.get(), type, 1, b::create(*pool, b::rows{row}));
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
+  config->set(dwrf::Config::MAP_FLAT_MAX_KEYS, keyLimit);
+
+  dwrf::E2EWriterTestUtil::testWriter(
+      *pool,
+      type,
+      dwrf::E2EWriterTestUtil::generateBatches(batch),
+      1,
+      1,
+      config);
+}
+
+TEST_F(E2EWriterTest, PresentStreamIsSuppressedOnFlatMap) {
+  using keyType = int32_t;
+  using valueType = int64_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  const auto randomStart = Random::rand32(100);
+
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+  b::row row;
+  row.push_back(b::pair{randomStart, Random::rand64()});
+
+  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
+  auto batch =
+      createRowVector(pool.get(), type, 1, b::create(*pool, b::rows{row}));
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
+
+  auto sink = std::make_unique<MemorySink>(
+      200 * 1024 * 1024,
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto sinkPtr = sink.get();
+
+  auto writer = dwrf::E2EWriterTestUtil::writeData(
+      std::move(sink),
+      type,
+      dwrf::E2EWriterTestUtil::generateBatches(std::move(batch)),
+      config,
+      dwrf::E2EWriterTestUtil::simpleFlushPolicyFactory(true));
+
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  RowReaderOptions rowReaderOpts;
+  auto reader = createReader(*sinkPtr, readerOpts);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto dwrfRowReader = dynamic_cast<dwrf::DwrfRowReader*>(rowReader.get());
+  bool preload = true;
+  std::unordered_set<uint32_t> actualNodeIds;
+  for (int i = 0; i < reader->getNumberOfStripes(); ++i) {
+    auto stripeMetadata = dwrfRowReader->fetchStripe(i, preload);
+    auto& footer = *stripeMetadata->footer;
+    for (int j = 0; j < footer.streams_size(); ++j) {
+      auto stream = footer.streams(j);
+      ASSERT_NE(stream.kind(), dwrf::proto::Stream_Kind::Stream_Kind_PRESENT);
+    }
+  }
+}
+
+TEST_F(E2EWriterTest, TooManyFlatMapKeys) {
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  const uint32_t keyLimit = 2000;
+  const auto randomStart = Random::rand32(100);
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  b::row row;
+  for (int32_t i = 0; i < (keyLimit + 1); ++i) {
+    row.push_back(b::pair{randomStart + i, Random::rand64()});
+  }
+
+  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
+  auto batch =
+      createRowVector(pool.get(), type, 1, b::create(*pool, b::rows{row}));
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
+  config->set(dwrf::Config::MAP_FLAT_MAX_KEYS, keyLimit);
+
+  EXPECT_THROW(
+      dwrf::E2EWriterTestUtil::testWriter(
+          *pool,
+          type,
+          dwrf::E2EWriterTestUtil::generateBatches(batch),
+          1,
+          1,
+          config),
+      exception::LoggedException);
+}
+
+TEST_F(E2EWriterTest, FlatMapBackfill) {
+  auto pool = memory::memoryManager()->addLeafPool();
+
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  const uint32_t strideSize = 1000;
+
+  std::vector<VectorPtr> batches;
+  b::rows rows;
+
+  for (int32_t i = 0; i < (strideSize * 3); ++i) {
+    rows.push_back(
+        b::row{b::pair{1, Random::rand64()}, b::pair{2, Random::rand64()}});
+  }
+
+  for (int32_t i = 0; i < (strideSize / 2); ++i) {
+    rows.push_back(b::row{b::pair{1, Random::rand64()}});
+  }
+
+  // This row introduces new key, in the middle of a stride and and existing key
+  // that wasn't used in this stride. The new key will trigger backfilling based
+  // on previous stride rows. But since this is part of a bigger batch, spanning
+  // the entire current stride, it will not trigger the partial stride backfill.
+  // This is covered in the next batch below.
+  rows.push_back(
+      b::row{b::pair{3, Random::rand64()}, b::pair{2, Random::rand64()}});
+
+  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
+  auto rowCount = rows.size();
+  auto batch = createRowVector(
+      pool.get(), type, rowCount, b::create(*pool, std::move(rows)));
+  batches.push_back(batch);
+
+  // This extra batch is forcing another write call in the same (partial)
+  // stride. This tests the backfill of partial strides.
+  batch = createRowVector(
+      pool.get(),
+      type,
+      1,
+      b::create(*pool, {b::row{b::pair{4, Random::rand64()}}}));
+  batches.push_back(batch);
+  // TODO: Add another batch inside last stride, to test for backfill in stride.
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
+  config->set(dwrf::Config::ROW_INDEX_STRIDE, strideSize);
+
+  dwrf::E2EWriterTestUtil::testWriter(
+      *pool,
+      type,
+      batches,
+      1,
+      1,
+      config,
+      dwrf::E2EWriterTestUtil::simpleFlushPolicyFactory(false));
+}
+
+void testFlatMapWithNulls(
+    bool firstRowNotNull,
+    bool enableFlatmapDictionaryEncoding = false,
+    bool shareDictionary = false) {
+  auto pool = memory::memoryManager()->addLeafPool();
+
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  const uint32_t strideSize = 1000;
+
+  std::vector<VectorPtr> batches;
+  b::rows rows;
+
+  for (int32_t i = 0; i < (strideSize * 3); ++i) {
+    if (firstRowNotNull && i == 0) {
+      rows.push_back(
+          b::row{b::pair{1, Random::rand64()}, b::pair{2, Random::rand64()}});
+    } else {
+      rows.push_back({});
+    }
+  }
+
+  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
+  auto rowCount = rows.size();
+  auto batch = createRowVector(
+      pool.get(), type, rowCount, b::create(*pool, std::move(rows)));
+  batches.push_back(batch);
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
+  config->set(dwrf::Config::ROW_INDEX_STRIDE, strideSize);
+  config->set(
+      dwrf::Config::MAP_FLAT_DISABLE_DICT_ENCODING,
+      !enableFlatmapDictionaryEncoding);
+  config->set(dwrf::Config::MAP_FLAT_DICT_SHARE, shareDictionary);
+
+  dwrf::E2EWriterTestUtil::testWriter(
+      *pool,
+      type,
+      batches,
+      1,
+      1,
+      config,
+      dwrf::E2EWriterTestUtil::simpleFlushPolicyFactory(false));
+}
+
+TEST_F(E2EWriterTest, FlatMapWithNulls) {
+  testFlatMapWithNulls(
+      /*firstRowNotNull=*/false, /*enableFlatmapDictionaryEncoding=*/false);
+  testFlatMapWithNulls(
+      /*firstRowNotNull=*/true, /*enableFlatmapDictionaryEncoding=*/false);
+  testFlatMapWithNulls(
+      /*firstRowNotNull=*/false, /*enableFlatmapDictionaryEncoding=*/true);
+  testFlatMapWithNulls(
+      /*firstRowNotNull=*/true, /*enableFlatmapDictionaryEncoding=*/true);
+}
+
+TEST_F(E2EWriterTest, FlatMapWithNullsSharedDict) {
+  testFlatMapWithNulls(
+      /*firstRowNotNull=*/false,
+      /*enableFlatmapDictionaryEncoding=*/true,
+      /*shareDictionary=*/true);
+  testFlatMapWithNulls(
+      /*firstRowNotNull=*/true,
+      /*enableFlatmapDictionaryEncoding=*/true,
+      /*shareDictionary=*/true);
+}
+
+TEST_F(E2EWriterTest, FlatMapEmpty) {
+  auto pool = memory::memoryManager()->addLeafPool();
+
+  using keyType = int32_t;
+  using valueType = int32_t;
+  using b = MapBuilder<keyType, valueType>;
+
+  const uint32_t strideSize = 1000;
+
+  std::vector<VectorPtr> batches;
+  b::rows rows;
+
+  for (int32_t i = 0; i < strideSize; ++i) {
+    if (i % 5 != 0) {
+      rows.push_back(b::row{b::pair{i % 3, Random::rand64()}});
+    } else {
+      rows.push_back(b::row{});
+    }
+  }
+
+  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
+  auto rowCount = rows.size();
+  auto batch = createRowVector(
+      pool.get(), type, rowCount, b::create(*pool, std::move(rows)));
+  batches.push_back(batch);
+
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
+  config->set(dwrf::Config::ROW_INDEX_STRIDE, strideSize);
+
+  dwrf::E2EWriterTestUtil::testWriter(
+      *pool,
+      type,
+      batches,
+      1,
+      1,
+      config,
+      dwrf::E2EWriterTestUtil::simpleFlushPolicyFactory(false));
+}
+
+TEST_F(E2EWriterTest, FlatMapConfigSingleColumn) {
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "map_val:map<bigint,double>,"
+      ">");
+
+  testFlatMapConfig(type, {0}, {1});
+  testFlatMapConfig(type, {}, {});
+}
+
+TEST_F(E2EWriterTest, FlatMapConfigMixedTypes) {
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "map_val:map<bigint,double>,"
+      ">");
+
+  testFlatMapConfig(type, {1}, {2});
+  testFlatMapConfig(type, {}, {});
+}
+
+TEST_F(E2EWriterTest, FlatMapConfigNestedMap) {
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "map_val:map<bigint,map<string,float>>,"
+      ">");
+
+  testFlatMapConfig(type, {1}, {2});
+  testFlatMapConfig(type, {}, {});
+}
+
+TEST_F(E2EWriterTest, FlatMapConfigMixedMaps) {
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "map_val:map<bigint,map<string,float>>,"
+      "map_val:map<bigint,float>,"
+      "map_val:map<bigint,map<string,float>>,"
+      "map_val:map<bigint,double>,"
+      ">");
+
+  testFlatMapConfig(type, {2, 3}, {9, 14});
+  testFlatMapConfig(type, {}, {});
+}
+
+TEST_F(E2EWriterTest, FlatMapConfigNotMapColumn) {
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "map_val:map<bigint,double>,"
+      ">");
+
+  EXPECT_THROW(
+      { testFlatMapConfig(type, {0}, {}); }, exception::LoggedException);
+}
+
+TEST_F(E2EWriterTest, mapStatsSingleStride) {
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "map_val:map<bigint,int>,"
+      "map_val:map<bigint,double>,"
+      "map_val:map<bigint,map<bigint,bigint>>,"
+      "map_val:map<bigint,map<bigint,double>>,"
+      "map_val:map<bigint,array<bigint>>,"
+      "map_val:map<bigint,map<string,float>>,"
+      ">");
+
+  // Single column
+  testFlatMapFileStats(type, {0});
+  // All non-nested columns
+  testFlatMapFileStats(type, {0, 1});
+  // All columns
+  testFlatMapFileStats(type, {0, 1, 2, 3, 4, 5});
+}
+
+TEST_F(E2EWriterTest, mapStatsMultiStrides) {
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "map_val:map<bigint,int>,"
+      "map_val:map<bigint,double>,"
+      "map_val:map<bigint,map<bigint,bigint>>,"
+      "map_val:map<bigint,map<bigint,double>>,"
+      "map_val:map<bigint,array<bigint>>,"
+      "map_val:map<bigint,map<string,float>>,"
+      ">");
+
+  // Single column
+  testFlatMapFileStats(type, {0}, /*strideSize=*/1000);
+  // All non-nested columns
+  testFlatMapFileStats(type, {0, 1}, /*strideSize=*/1000);
+  // All columns
+  testFlatMapFileStats(type, {0, 1, 2, 3, 4, 5}, /*strideSize=*/1000);
+}
+
+TEST_F(E2EWriterTest, PartialStride) {
+  auto type = ROW({"bool_val"}, {INTEGER()});
+
+  size_t batchSize = 1'000;
+
+  auto config = std::make_shared<dwrf::Config>();
+  auto sink = std::make_unique<MemorySink>(
+      2 * 1024 * 1024,
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto sinkPtr = sink.get();
+
+  dwrf::WriterOptions options;
+  options.config = config;
+  options.schema = type;
+  options.memoryPool = rootPool_.get();
+  dwrf::Writer writer{std::move(sink), options};
+
+  auto nulls = allocateNulls(batchSize, leafPool_.get());
+  auto* nullsPtr = nulls->asMutable<uint64_t>();
+  size_t nullCount = 0;
+
+  auto values = AlignedBuffer::allocate<int32_t>(batchSize, leafPool_.get());
+  auto* valuesPtr = values->asMutable<int32_t>();
+
+  for (size_t i = 0; i < batchSize; ++i) {
+    if ((i & 1) == 0) {
+      bits::clearNull(nullsPtr, i);
+      valuesPtr[i] = i;
+    } else {
+      bits::setNull(nullsPtr, i);
+      nullCount++;
+    }
+  }
+
+  auto batch = createRowVector(
+      leafPool_.get(),
+      type,
+      batchSize,
+      std::make_shared<FlatVector<int32_t>>(
+          leafPool_.get(),
+          type->childAt(0),
+          nulls,
+          batchSize,
+          values,
+          std::vector<BufferPtr>()));
+
+  writer.write(batch);
+  writer.close();
+
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  RowReaderOptions rowReaderOpts;
+  auto reader = createReader(*sinkPtr, readerOpts);
+  ASSERT_EQ(
+      batchSize - nullCount, reader->columnStatistics(1)->getNumberOfValues())
+      << reader->columnStatistics(1)->toString();
+  ASSERT_EQ(true, reader->columnStatistics(1)->hasNull().value());
+}
+
+TEST_F(E2EWriterTest, OversizeRows) {
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "map_val:map<string, map<string, map<string, map<string, string>>>>,"
+      "list_val:array<array<array<array<string>>>>,"
+      "struct_val:struct<"
+      "map_val_field_1:map<string, map<string, map<string, map<string, string>>>>,"
+      "list_val_field_1:array<array<array<array<string>>>>,"
+      "list_val_field_2:array<array<array<array<string>>>>,"
+      "map_val_field_2:map<string, map<string, map<string, map<string, string>>>>"
+      ">,"
+      ">");
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::DISABLE_LOW_MEMORY_MODE, true);
+  config->set(dwrf::Config::STRIPE_SIZE, 10 * kSizeMB);
+  config->set(
+      dwrf::Config::RAW_DATA_SIZE_PER_BATCH, folly::to<uint64_t>(20 * 1024UL));
+
+  // Retained bytes in vector: 44704
+  auto singleBatch = dwrf::E2EWriterTestUtil::generateBatches(
+      type, 1, 1, /*seed=*/1411367325, *pool);
+
+  dwrf::E2EWriterTestUtil::testWriter(
+      *pool,
+      type,
+      singleBatch,
+      1,
+      1,
+      config,
+      /*flushPolicyFactory=*/nullptr,
+      /*layoutPlannerFactory=*/nullptr,
+      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
+      false);
+}
+
+TEST_F(E2EWriterTest, OversizeBatches) {
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "byte_val:tinyint,"
+      "float_val:float,"
+      "double_val:double,"
+      ">");
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::DISABLE_LOW_MEMORY_MODE, true);
+  config->set(dwrf::Config::STRIPE_SIZE, 10 * kSizeMB);
+
+  // Test splitting a gigantic batch.
+  auto singleBatch = dwrf::E2EWriterTestUtil::generateBatches(
+      type, 1, 10000000, /*seed=*/1411367325, *pool);
+  // A gigantic batch is split into 10 stripes.
+  dwrf::E2EWriterTestUtil::testWriter(
+      *pool,
+      type,
+      singleBatch,
+      10,
+      10,
+      config,
+      /*flushPolicyFactory=*/nullptr,
+      /*layoutPlannerFactory=*/nullptr,
+      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
+      false);
+
+  // Test splitting multiple huge batches.
+  auto batches = dwrf::E2EWriterTestUtil::generateBatches(
+      type, 3, 5000000, /*seed=*/1411367325, *pool);
+  // 3 gigantic batches are split into 15~16 stripes.
+  dwrf::E2EWriterTestUtil::testWriter(
+      *pool,
+      type,
+      batches,
+      15,
+      16,
+      config,
+      /*flushPolicyFactory=*/nullptr,
+      /*layoutPlannerFactory=*/nullptr,
+      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
+      false);
+}
+
+TEST_F(E2EWriterTest, OverflowLengthIncrements) {
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "struct_val:struct<bigint_val:bigint>"
+      ">");
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::DISABLE_LOW_MEMORY_MODE, true);
+  config->set(dwrf::Config::STRIPE_SIZE, 10 * kSizeMB);
+  config->set(
+      dwrf::Config::RAW_DATA_SIZE_PER_BATCH,
+      folly::to<uint64_t>(500 * 1024UL * 1024UL));
+
+  const size_t batchSize = 1024;
+
+  auto nulls =
+      AlignedBuffer::allocate<char>(bits::nbytes(batchSize), pool.get());
+  auto* nullsPtr = nulls->asMutable<uint64_t>();
+  for (size_t i = 0; i < batchSize; ++i) {
+    // Only the first element is non-null
+    bits::setNull(nullsPtr, i, i != 0);
+  }
+
+  // Bigint column
+  VectorMaker maker{pool.get()};
+  auto child = maker.flatVector<int64_t>(std::vector<int64_t>{1UL});
+
+  std::vector<VectorPtr> children{child};
+  auto rowVec = std::make_shared<RowVector>(
+      pool.get(),
+      type->childAt(0),
+      nulls,
+      batchSize,
+      children,
+      /*nullCount=*/batchSize - 1);
+
+  // Retained bytes in vector: 192, which is much less than 1024
+  auto vec = std::make_shared<RowVector>(
+      pool.get(),
+      type,
+      BufferPtr{},
+      batchSize,
+      std::vector<VectorPtr>{rowVec},
+      /*nullCount=*/0);
+
+  dwrf::E2EWriterTestUtil::testWriter(
+      *pool,
+      type,
+      {vec},
+      1,
+      1,
+      config,
+      /*flushPolicyFactory=*/nullptr,
+      /*layoutPlannerFactory=*/nullptr,
+      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
+      false);
+}
+
+class E2EEncryptionTest : public E2EWriterTest {
+ protected:
+  E2EEncryptionTest() : E2EWriterTest() {}
+
+  std::unique_ptr<::facebook::velox::dwrf::DwrfReader> writeAndRead(
+      const std::string& schema,
+      const std::shared_ptr<EncryptionSpecification>& spec,
+      std::shared_ptr<DecrypterFactory> decrypterFactory =
+          std::make_shared<TestDecrypterFactory>()) {
+    HiveTypeParser parser;
+    auto type = parser.parse(schema);
+
+    // write file to memory
+    auto config = std::make_shared<::facebook::velox::dwrf::Config>();
+    // make sure we always write dictionary to test stride index
+    config->set(
+        ::facebook::velox::dwrf::Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD,
+        1.0f);
+    config->set(
+        ::facebook::velox::dwrf::Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD,
+        0.0f);
+    auto sink = std::make_unique<MemorySink>(
+        16 * 1024 * 1024,
+        dwio::common::FileSink::Options{.pool = leafPool_.get()});
+    sink_ = sink.get();
+    ::facebook::velox::dwrf::WriterOptions options;
+    options.config = config;
+    options.schema = type;
+    options.encryptionSpec = spec;
+    options.encrypterFactory = std::make_shared<TestEncrypterFactory>();
+    writer_ =
+        std::make_unique<dwrf::Writer>(std::move(sink), options, rootPool_);
+
+    for (size_t i = 0; i < batchCount_; ++i) {
+      auto batch =
+          BatchMaker::createBatch(type, batchSize_, *leafPool_, nullptr, i);
+      writer_->write(batch);
+      batches_.push_back(std::move(batch));
+      if (i % flushInterval_ == flushInterval_ - 1) {
+        writer_->flush();
+      }
+    }
+    writer_->close();
+
+    // read it back for compare
+    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    readerOpts.setDecrypterFactory(decrypterFactory);
+    return createReader(*sink_, readerOpts);
+  }
+
+  const DecryptionHandler& getDecryptionHandler(
+      const ::facebook::velox::dwrf::DwrfReader& reader) const {
+    return reader.testingReaderBase()->decryptionHandler();
+  }
+
+  void validateFileContent(
+      const ::facebook::velox::dwrf::DwrfReader& reader) const {
+    RowReaderOptions rowReaderOpts;
+    auto rowReader = reader.createRowReader(rowReaderOpts);
+    // make sure size estimate works
+    ASSERT_GT(rowReader->estimatedRowSize(), 0);
+    VectorPtr batch;
+    for (auto& expected : batches_) {
+      ASSERT_TRUE(rowReader->next(batchSize_, batch));
+      compareBatches(batch, expected);
+    }
+    ASSERT_FALSE(rowReader->next(batchSize_, batch));
+
+    // make sure decrypter is actually used
+    auto& handler = getDecryptionHandler(reader);
+    for (size_t i = 0; i < handler.getEncryptionGroupCount(); ++i) {
+      auto& decrypter = dynamic_cast<const TestDecrypter&>(
+          handler.getEncryptionProviderByIndex(i));
+      ASSERT_GT(decrypter.getCount(), 0);
+    }
+  }
+
+  void compareBatches(const VectorPtr& a, const VectorPtr& b) const {
+    ASSERT_EQ(a->size(), b->size());
+    for (int32_t i = 0; i < a->size(); ++i) {
+      ASSERT_TRUE(a->equalValueAt(b.get(), i, i)) << "Mismatch at " << i;
+    }
+  }
+
+  std::unique_ptr<Writer> writer_;
+  MemorySink* sink_;
+  size_t batchSize_{100};
+  size_t batchCount_{10};
+  size_t flushInterval_{3};
+  std::vector<VectorPtr> batches_;
+};
+
+TEST_F(E2EEncryptionTest, EncryptRoot) {
+  auto spec =
+      std::make_shared<EncryptionSpecification>(EncryptionProvider::Unknown);
+  spec->withRootEncryptionProperties(
+      std::make_shared<TestEncryptionProperties>("key"));
+  auto reader =
+      writeAndRead("struct<a:int,b:float,c:string,d:int,e:string>", spec);
+
+  // make sure footer has right set of properties set
+  auto& handler = getDecryptionHandler(*reader);
+  ASSERT_TRUE(handler.isEncrypted());
+  ASSERT_EQ(handler.getEncryptionGroupCount(), 1);
+  ASSERT_EQ(handler.getEncryptionRoot(0), 0);
+
+  // make sure footer doesn't have detailed stats
+  auto& footer = reader->getFooter();
+  auto& unencryptedStats = footer.statistics();
+  auto encryptedStats = reader->getStatistics();
+  ASSERT_EQ(unencryptedStats.size(), encryptedStats->getNumberOfColumns());
+  for (size_t i = 0; i < unencryptedStats.size(); ++i) {
+    auto& stats = unencryptedStats.Get(i);
+    ASSERT_TRUE(stats.has_hasnull());
+    ASSERT_TRUE(stats.has_numberofvalues());
+    ASSERT_FALSE(
+        stats.has_intstatistics() || stats.has_doublestatistics() ||
+        stats.has_stringstatistics());
+    auto& encrypted = encryptedStats->getColumnStatistics(i);
+    ASSERT_EQ(stats.hasnull(), encrypted.hasNull().value());
+    ASSERT_EQ(stats.numberofvalues(), encrypted.getNumberOfValues());
+    // stats got thru api should not be the basic one
+    ASSERT_EQ(typeid(encrypted) == typeid(const ColumnStatistics&), i == 0);
+  }
+
+  RowReaderOptions rowReaderOpts;
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  // make sure stripe footer doesn't have any stream/encoding
+  auto dwrfRowReader =
+      dynamic_cast<::facebook::velox::dwrf::DwrfRowReader*>(rowReader.get());
+  bool preload = true;
+  for (int32_t i = 0; i < reader->getNumberOfStripes(); ++i) {
+    auto stripeMetadata = dwrfRowReader->fetchStripe(i, preload);
+    auto& sf = *stripeMetadata->footer;
+    ASSERT_EQ(sf.encoding_size(), 0);
+    ASSERT_EQ(sf.streams_size(), 0);
+    ASSERT_EQ(sf.encryptiongroups_size(), 1);
+  }
+
+  validateFileContent(*reader);
+}
+
+TEST_F(E2EEncryptionTest, EncryptSelectedFields) {
+  auto spec =
+      std::make_shared<EncryptionSpecification>(EncryptionProvider::Unknown);
+  spec->withEncryptedField(
+          FieldEncryptionSpecification{}.withIndex(1).withEncryptionProperties(
+              std::make_shared<TestEncryptionProperties>("key1")))
+      .withEncryptedField(
+          FieldEncryptionSpecification{}.withIndex(2).withEncryptionProperties(
+              std::make_shared<TestEncryptionProperties>("key2")))
+      .withEncryptedField(
+          FieldEncryptionSpecification{}.withIndex(4).withEncryptionProperties(
+              std::make_shared<TestEncryptionProperties>("key2")));
+  std::string schema =
+      "struct<"
+      // not encrypted
+      "a:int,"
+      // encrypted primitive type. encryption group 0
+      "b:float,"
+      // encrypted complex type. encryption group 1
+      "c:map<int,string>,"
+      // not encrypted
+      "d:struct<a:int,b:string,c:float>,"
+      // encrypted complex type. encryption group 1
+      "e:array<struct<a:int,b:string>>>";
+  auto reader = writeAndRead(schema, spec);
+
+  // make sure footer has right set of properties set
+  auto& handler = getDecryptionHandler(*reader);
+  ASSERT_TRUE(handler.isEncrypted());
+  ASSERT_EQ(handler.getEncryptionGroupCount(), 2);
+
+  std::vector<std::vector<uint32_t>> eg{{2}, {3, 4, 5, 10, 11, 12, 13}};
+  std::unordered_set<uint32_t> encryptedNodes;
+  for (size_t i = 0; i < eg.size(); ++i) {
+    for (auto& n : eg[i]) {
+      ASSERT_EQ(handler.getEncryptionGroupIndex(n), i);
+      encryptedNodes.insert(n);
+    }
+  }
+
+  // make sure footer doesn't have detailed stats
+  auto& footer = reader->getFooter();
+  auto& unencryptedStats = footer.statistics();
+  auto encryptedStats = reader->getStatistics();
+  ASSERT_EQ(unencryptedStats.size(), encryptedStats->getNumberOfColumns());
+  for (size_t i = 0; i < unencryptedStats.size(); ++i) {
+    auto& stats = unencryptedStats.Get(i);
+    ASSERT_TRUE(stats.has_hasnull());
+    ASSERT_TRUE(stats.has_numberofvalues());
+    // only unencrypted leaf node in the schema may have detailed stats
+    ASSERT_EQ(
+        stats.has_intstatistics() || stats.has_doublestatistics() ||
+            stats.has_stringstatistics(),
+        (i == 1 || i == 7 || i == 8 || i == 9));
+    auto& encrypted = encryptedStats->getColumnStatistics(i);
+    ASSERT_EQ(stats.hasnull(), encrypted.hasNull().value());
+    ASSERT_EQ(stats.numberofvalues(), encrypted.getNumberOfValues());
+    // stats got thru api should not be the basic one unless they are
+    // intermediate nodes
+    ASSERT_EQ(
+        typeid(encrypted) == typeid(const ColumnStatistics&),
+        (i == 0 || i == 3 || i == 6 || i == 10 || i == 11));
+  }
+
+  RowReaderOptions rowReaderOpts;
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  // make sure stripe footer doesn't have any stream/encoding
+  auto dwrfRowReader = dynamic_cast<dwrf::DwrfRowReader*>(rowReader.get());
+  bool preload = true;
+  for (int32_t i = 0; i < reader->getNumberOfStripes(); ++i) {
+    auto stripeMetadata = dwrfRowReader->fetchStripe(i, preload);
+    auto& sf = *stripeMetadata->footer;
+    for (auto& enc : sf.encoding()) {
+      ASSERT_TRUE(encryptedNodes.find(enc.node()) == encryptedNodes.end());
+    }
+    for (auto& stream : sf.streams()) {
+      ASSERT_TRUE(encryptedNodes.find(stream.node()) == encryptedNodes.end());
+    }
+  }
+
+  validateFileContent(*reader);
+}
+
+TEST_F(E2EEncryptionTest, EncryptEmptyFile) {
+  auto spec =
+      std::make_shared<EncryptionSpecification>(EncryptionProvider::Unknown);
+  spec->withEncryptedField(
+      FieldEncryptionSpecification{}.withIndex(0).withEncryptionProperties(
+          std::make_shared<TestEncryptionProperties>("key1")));
+  std::string schema = "struct<a:int>";
+  batchCount_ = 0;
+  auto reader = writeAndRead(schema, spec);
+
+  // make sure footer has right set of properties set
+  auto& handler = getDecryptionHandler(*reader);
+  ASSERT_FALSE(handler.isEncrypted());
+}
+
+TEST_F(E2EEncryptionTest, ReadWithoutKey) {
+  auto spec =
+      std::make_shared<EncryptionSpecification>(EncryptionProvider::Unknown);
+  spec->withEncryptedField(
+      FieldEncryptionSpecification{}.withIndex(1).withEncryptionProperties(
+          std::make_shared<TestEncryptionProperties>("key1")));
+  std::string schema =
+      "struct<"
+      // not encrypted
+      "a:int,"
+      // encrypted
+      "b:float>";
+  HiveTypeParser parser;
+  auto type = std::dynamic_pointer_cast<const RowType>(parser.parse(schema));
+  auto reader = writeAndRead(schema, spec, nullptr);
+
+  // reading unencrypted column should not fail
+  {
+    RowReaderOptions rowReaderOpts;
+    rowReaderOpts.select(
+        std::make_shared<ColumnSelector>(type, std::vector<uint64_t>{0}));
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    VectorPtr batch;
+    ASSERT_TRUE(rowReader->next(1, batch));
+  }
+
+  // fail when reading encrypted column
+  {
+    RowReaderOptions rowReaderOpts;
+    rowReaderOpts.select(
+        std::make_shared<ColumnSelector>(type, std::vector<uint64_t>{1}));
+    ASSERT_THROW(
+        reader->createRowReader(rowReaderOpts), exception::LoggedException);
+  }
+}
+
+void testWriter(
+    MemoryPool& pool,
+    const std::shared_ptr<const Type>& type,
+    size_t batchCount,
+    std::function<VectorPtr()> generator,
+    const std::shared_ptr<dwrf::Config> config =
+        std::make_shared<dwrf::Config>()) {
+  std::vector<VectorPtr> batches;
+  for (auto i = 0; i < batchCount; ++i) {
+    batches.push_back(generator());
+  }
+  dwrf::E2EWriterTestUtil::testWriter(pool, type, batches, 1, 1, config);
+};
+
+template <TypeKind K>
+VectorPtr createKeysImpl(
+    MemoryPool& pool,
+    std::mt19937& rng,
+    size_t batchSize,
+    size_t maxVal) {
+  using TCpp = typename TypeTraits<K>::NativeType;
+
+  auto vector = std::make_shared<FlatVector<TCpp>>(
+      &pool,
+      CppToType<TCpp>::create(),
+      nullptr,
+      batchSize,
+      AlignedBuffer::allocate<TCpp>(batchSize, &pool),
+      std::vector<BufferPtr>{});
+
+  size_t value = 0;
+  for (size_t i = 0; i < vector->size(); ++i, value = ((value + 1) % maxVal)) {
+    if constexpr (std::is_same_v<TCpp, StringView>) {
+      auto strVal = folly::to<std::string>(value);
+      StringView sv{strVal};
+      DWIO_ENSURE(sv.isInline());
+      vector->set(i, sv);
+    } else {
+      vector->set(i, value);
+    }
+  }
+
+  if (folly::Random::oneIn(2, rng)) {
+    return vector;
+  }
+
+  // wrap in dictionary
+  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(batchSize, &pool);
+  auto rawIndices = indices->asMutable<vector_size_t>();
+
+  for (size_t i = 0; i < batchSize; ++i) {
+    rawIndices[i] = batchSize - 1 - i;
+  }
+
+  return BaseVector::wrapInDictionary(nullptr, indices, batchSize, vector);
+}
+
+VectorPtr createKeys(
+    const std::shared_ptr<const Type> type,
+    MemoryPool& pool,
+    std::mt19937& rng,
+    size_t batchSize,
+    size_t maxVal) {
+  switch (type->kind()) {
+    case TypeKind::INTEGER:
+      return createKeysImpl<TypeKind::INTEGER>(pool, rng, batchSize, maxVal);
+    case TypeKind::VARCHAR:
+      return createKeysImpl<TypeKind::VARCHAR>(pool, rng, batchSize, maxVal);
+    default:
+      folly::assume_unreachable();
+  }
+}
+
+TEST_F(E2EWriterTest, fuzzSimple) {
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto type = ROW({
+      {"bool_val", BOOLEAN()},
+      {"byte_val", TINYINT()},
+      {"short_val", SMALLINT()},
+      {"int_val", INTEGER()},
+      {"long_val", BIGINT()},
+      {"float_val", REAL()},
+      {"double_val", DOUBLE()},
+      {"string_val", VARCHAR()},
+      {"binary_val", VARBINARY()},
+      {"ts_val", TIMESTAMP()},
+  });
+  auto seed = folly::Random::rand32();
+  LOG(INFO) << "seed: " << seed;
+
+  // Small batches creates more edge cases.
+  size_t batchSize = 10;
+  VectorFuzzer noNulls(
+      {
+          .vectorSize = batchSize,
+          .nullRatio = 0,
+          .stringLength = 20,
+          .stringVariableLength = true,
+      },
+      pool.get(),
+      seed);
+
+  VectorFuzzer hasNulls{
+      {
+          .vectorSize = batchSize,
+          .nullRatio = 0.05,
+          .stringLength = 10,
+          .stringVariableLength = true,
+      },
+      pool.get(),
+      seed};
+
+  auto iterations = 20;
+  auto batches = 20;
+  for (auto i = 0; i < iterations; ++i) {
+    testWriter(
+        *pool, type, batches, [&]() { return noNulls.fuzzInputRow(type); });
+    testWriter(
+        *pool, type, batches, [&]() { return hasNulls.fuzzInputRow(type); });
+  }
+}
+
+TEST_F(E2EWriterTest, fuzzComplex) {
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto type = ROW({
+      {"array", ARRAY(REAL())},
+      {"map", MAP(INTEGER(), DOUBLE())},
+      {"row",
+       ROW({
+           {"a", REAL()},
+           {"b", INTEGER()},
+       })},
+      {"nested",
+       ARRAY(ROW({
+           {"a", INTEGER()},
+           {"b", MAP(REAL(), REAL())},
+       }))},
+  });
+  auto seed = folly::Random::rand32();
+  LOG(INFO) << "seed: " << seed;
+
+  // Small batches creates more edge cases.
+  size_t batchSize = 10;
+  VectorFuzzer noNulls(
+      {
+          .vectorSize = batchSize,
+          .nullRatio = 0,
+          .stringLength = 20,
+          .stringVariableLength = true,
+          .containerLength = 5,
+          .containerVariableLength = true,
+      },
+      pool.get(),
+      seed);
+
+  VectorFuzzer hasNulls{
+      {
+          .vectorSize = batchSize,
+          .nullRatio = 0.05,
+          .stringLength = 10,
+          .stringVariableLength = true,
+          .containerLength = 5,
+          .containerVariableLength = true,
+      },
+      pool.get(),
+      seed};
+
+  auto iterations = 20;
+  auto batches = 20;
+  for (auto i = 0; i < iterations; ++i) {
+    testWriter(
+        *pool, type, batches, [&]() { return noNulls.fuzzInputRow(type); });
+    testWriter(
+        *pool, type, batches, [&]() { return hasNulls.fuzzInputRow(type); });
+  }
+}
+
+TEST_F(E2EWriterTest, fuzzFlatmap) {
+  auto pool = memory::memoryManager()->addLeafPool();
+  auto type = ROW({
+      {"flatmap1", MAP(INTEGER(), REAL())},
+      {"flatmap2", MAP(VARCHAR(), ARRAY(REAL()))},
+      {"flatmap3", MAP(INTEGER(), MAP(INTEGER(), REAL()))},
+  });
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0, 1, 2});
+  auto seed = folly::Random::rand32();
+  LOG(INFO) << "seed: " << seed;
+  std::mt19937 rng{seed};
+
+  // Small batches creates more edge cases.
+  size_t batchSize = 10;
+  VectorFuzzer fuzzer(
+      {
+          .vectorSize = batchSize,
+          .nullRatio = 0,
+          .stringLength = 20,
+          .stringVariableLength = true,
+          .containerLength = 5,
+          .containerVariableLength = true,
+      },
+      pool.get(),
+      seed);
+
+  auto genMap = [&](auto type, auto size) {
+    auto offsets = allocateOffsets(batchSize, pool.get());
+    auto rawOffsets = offsets->template asMutable<vector_size_t>();
+    auto sizes = allocateSizes(batchSize, pool.get());
+    auto rawSizes = sizes->template asMutable<vector_size_t>();
+    vector_size_t childSize = 0;
+    // flatmap doesn't like empty map
+    for (auto i = 0; i < batchSize; ++i) {
+      rawOffsets[i] = childSize;
+      auto length = folly::Random::rand32(1, 5, rng);
+      rawSizes[i] = length;
+      childSize += length;
+    }
+
+    VectorFuzzer valueFuzzer(
+        {
+            .vectorSize = static_cast<size_t>(childSize),
+            .nullRatio = 0,
+            .stringLength = 20,
+            .stringVariableLength = true,
+            .containerLength = 5,
+            .containerVariableLength = true,
+        },
+        pool.get(),
+        seed);
+
+    auto& mapType = type->asMap();
+    VectorPtr vector = std::make_shared<MapVector>(
+        pool.get(),
+        type,
+        nullptr,
+        batchSize,
+        offsets,
+        sizes,
+        createKeys(mapType.keyType(), *pool, rng, childSize, 10),
+        valueFuzzer.fuzz(mapType.valueType()));
+
+    if (folly::Random::oneIn(2, rng)) {
+      vector = fuzzer.fuzzDictionary(vector);
+    }
+    return vector;
+  };
+
+  auto gen = [&]() {
+    std::vector<VectorPtr> children;
+    for (auto i = 0; i < type->size(); ++i) {
+      children.push_back(genMap(type->childAt(i), batchSize));
+    }
+
+    return std::make_shared<RowVector>(
+        pool.get(), type, nullptr, batchSize, std::move(children));
+  };
+
+  auto iterations = 20;
+  auto batches = 20;
+  for (auto i = 0; i < iterations; ++i) {
+    testWriter(*pool, type, batches, gen, config);
+  }
+}
+
+TEST_F(E2EWriterTest, memoryConfigError) {
+  const auto type = ROW(
+      {{"int_val", INTEGER()},
+       {"string_val", VARCHAR()},
+       {"binary_val", VARBINARY()}});
+
+  dwrf::WriterOptions options;
+  options.schema = type;
+  const common::SpillConfig spillConfig = getSpillConfig(10, 20);
+  options.spillConfig = &spillConfig;
+  auto writerPool = memory::memoryManager()->addRootPool(
+      "memoryReclaim", 1L << 30, exec::MemoryReclaimer::create());
+  auto dwrfPool = writerPool->addAggregateChild("writer");
+  auto sinkPool =
+      writerPool->addLeafChild("sink", true, exec::MemoryReclaimer::create());
+  auto sink = std::make_unique<MemorySink>(
+      200 * 1024 * 1024, FileSink::Options{.pool = sinkPool.get()});
+  VELOX_ASSERT_THROW(
+      std::make_unique<dwrf::Writer>(std::move(sink), options, dwrfPool),
+      "nonReclaimableSection_ must be set if writer memory reclaim is enabled");
+}
+
+DEBUG_ONLY_TEST_F(E2EWriterTest, memoryReclaimOnWrite) {
+  const auto type = ROW(
+      {{"int_val", INTEGER()},
+       {"string_val", VARCHAR()},
+       {"binary_val", VARBINARY()}});
+
+  VectorFuzzer fuzzer(
+      {
+          .vectorSize = 1000,
+          .stringLength = 1'000,
+          .stringVariableLength = false,
+      },
+      leafPool_.get());
+
+  std::vector<VectorPtr> vectors;
+  for (int i = 0; i < 10; ++i) {
+    vectors.push_back(fuzzer.fuzzInputRow(type));
+  }
+  const common::SpillConfig spillConfig = getSpillConfig(10, 20);
+  for (bool enableReclaim : {false, true}) {
+    SCOPED_TRACE(fmt::format("enableReclaim {}", enableReclaim));
+
+    auto config = std::make_shared<dwrf::Config>();
+    config->set<uint64_t>(dwrf::Config::STRIPE_SIZE, 1L << 30);
+    config->set<uint64_t>(dwrf::Config::MAX_DICTIONARY_SIZE, 1L << 30);
+
+    tsan_atomic<bool> nonReclaimableSection{false};
+    dwrf::WriterOptions options;
+    options.schema = type;
+    options.config = std::move(config);
+    options.nonReclaimableSection = &nonReclaimableSection;
+    if (enableReclaim) {
+      options.spillConfig = &spillConfig;
+    }
+    auto writerPool = memory::memoryManager()->addRootPool(
+        "memoryReclaim", 1L << 30, exec::MemoryReclaimer::create());
+    auto dwrfPool = writerPool->addAggregateChild("writer");
+    auto sinkPool =
+        writerPool->addLeafChild("sink", true, exec::MemoryReclaimer::create());
+    auto sink = std::make_unique<MemorySink>(
+        200 * 1024 * 1024, FileSink::Options{.pool = sinkPool.get()});
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::dwrf::Writer::write",
+        std::function<void(dwrf::Writer*)>([&](dwrf::Writer* writer) {
+          VELOX_CHECK(writer->testingNonReclaimableSection());
+          ASSERT_EQ(writer->canReclaim(), enableReclaim);
+          if (!writer->canReclaim()) {
+            return;
+          }
+          auto& context = writer->getContext();
+          const auto memoryUsage = context.getTotalMemoryUsage();
+          const auto availableMemoryUsage =
+              context.availableMemoryReservation();
+          ASSERT_GE(
+              availableMemoryUsage,
+              memoryUsage * spillConfig.minSpillableReservationPct / 100);
+        }));
+
+    auto writer =
+        std::make_unique<dwrf::Writer>(std::move(sink), options, dwrfPool);
+
+    std::atomic<bool> reservationCalled{false};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+          ASSERT_TRUE(enableReclaim);
+          reservationCalled = true;
+          // Verify the writer is reclaimable under memory reservation.
+          ASSERT_FALSE(writer->testingNonReclaimableSection());
+        }));
+
+    memory::MemoryReclaimer::Stats stats;
+    const auto oldCapacity = writerPool->capacity();
+    const auto oldReservedBytes = writerPool->reservedBytes();
+    const auto oldUsedBytes = writerPool->usedBytes();
+    {
+      memory::ScopedMemoryArbitrationContext arbitrationCtx(writerPool.get());
+      writerPool->reclaim(1L << 30, 0, stats);
+    }
+    ASSERT_EQ(stats.numNonReclaimableAttempts, 0);
+    // We don't expect the capacity change by memory reclaim but only the used
+    // or reserved memory change.
+    ASSERT_EQ(writerPool->capacity(), oldCapacity);
+    if (enableReclaim) {
+      // The writer is empty so nothing to free.
+      ASSERT_EQ(stats.reclaimedBytes, 0);
+      ASSERT_GE(stats.reclaimExecTimeUs, 0);
+      ASSERT_EQ(
+          oldReservedBytes - writerPool->reservedBytes(), stats.reclaimedBytes);
+      ASSERT_EQ(oldUsedBytes, writerPool->usedBytes());
+    } else {
+      ASSERT_EQ(stats, memory::MemoryReclaimer::Stats{});
+    }
+
+    // Expect a throw if we don't set the non-reclaimable section.
+    VELOX_ASSERT_THROW(writer->write(vectors[0]), "");
+    {
+      memory::NonReclaimableSectionGuard nonReclaimableGuard(
+          &nonReclaimableSection);
+      for (size_t i = 0; i < vectors.size(); ++i) {
+        writer->write(vectors[i]);
+      }
+    }
+    if (!enableReclaim) {
+      ASSERT_FALSE(reservationCalled);
+      ASSERT_EQ(writerPool->reclaim(1L << 30, 0, stats), 0);
+      ASSERT_EQ(stats, memory::MemoryReclaimer::Stats{});
+    } else {
+      ASSERT_TRUE(reservationCalled);
+      writer->testingNonReclaimableSection() = true;
+      ASSERT_EQ(writerPool->reclaim(1L << 30, 0, stats), 0);
+      ASSERT_EQ(stats.numNonReclaimableAttempts, 1);
+      writer->testingNonReclaimableSection() = false;
+      stats.numNonReclaimableAttempts = 0;
+      {
+        memory::ScopedMemoryArbitrationContext arbitrationCtx(writerPool.get());
+        const auto reclaimedBytes = writerPool->reclaim(1L << 30, 0, stats);
+        ASSERT_GT(reclaimedBytes, 0);
+      }
+      ASSERT_EQ(stats.numNonReclaimableAttempts, 0);
+      ASSERT_GT(stats.reclaimedBytes, 0);
+      ASSERT_GT(stats.reclaimExecTimeUs, 0);
+    }
+    writer->close();
+  }
+}
+
+DEBUG_ONLY_TEST_F(E2EWriterTest, memoryReclaimOnFlush) {
+  const auto type = ROW(
+      {{"int_val", INTEGER()},
+       {"string_val", VARCHAR()},
+       {"binary_val", VARBINARY()}});
+
+  VectorFuzzer fuzzer(
+      {
+          .vectorSize = 1000,
+          .stringLength = 1'000,
+          .stringVariableLength = false,
+      },
+      leafPool_.get());
+  std::vector<VectorPtr> vectors;
+  for (int i = 0; i < 10; ++i) {
+    vectors.push_back(fuzzer.fuzzInputRow(type));
+  }
+  const common::SpillConfig spillConfig = getSpillConfig(10, 20);
+  for (bool enableReclaim : {false, true}) {
+    SCOPED_TRACE(fmt::format("enableReclaim {}", enableReclaim));
+
+    auto config = std::make_shared<dwrf::Config>();
+    config->set<uint64_t>(dwrf::Config::STRIPE_SIZE, 1L << 30);
+    config->set<uint64_t>(dwrf::Config::MAX_DICTIONARY_SIZE, 1L << 30);
+
+    dwrf::WriterOptions options;
+    options.schema = type;
+    options.config = std::move(config);
+    tsan_atomic<bool> nonReclaimableSection{false};
+    options.nonReclaimableSection = &nonReclaimableSection;
+    if (enableReclaim) {
+      options.spillConfig = &spillConfig;
+    }
+    auto writerPool = memory::memoryManager()->addRootPool(
+        "memoryReclaim", 1L << 30, exec::MemoryReclaimer::create());
+    auto dwrfPool = writerPool->addAggregateChild("writer");
+    auto sinkPool =
+        writerPool->addLeafChild("sink", true, exec::MemoryReclaimer::create());
+    auto sink = std::make_unique<MemorySink>(
+        200 * 1024 * 1024, FileSink::Options{.pool = sinkPool.get()});
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::dwrf::Writer::flushStripe",
+        std::function<void(dwrf::Writer*)>([&](dwrf::Writer* writer) {
+          VELOX_CHECK(writer->testingNonReclaimableSection());
+          ASSERT_EQ(writer->canReclaim(), enableReclaim);
+          if (!writer->canReclaim()) {
+            return;
+          }
+          auto& context = writer->getContext();
+          auto& outputPool =
+              context.getMemoryPool(dwrf::MemoryUsageCategory::OUTPUT_STREAM);
+          const auto memoryUsage = outputPool.usedBytes();
+          const auto availableMemoryUsage = outputPool.availableReservation();
+          ASSERT_GE(
+              availableMemoryUsage,
+              memoryUsage * spillConfig.minSpillableReservationPct / 100);
+        }));
+
+    auto writer =
+        std::make_unique<dwrf::Writer>(std::move(sink), options, dwrfPool);
+
+    std::atomic<bool> reservationCalled{false};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+          ASSERT_TRUE(enableReclaim);
+          reservationCalled = true;
+          // Verify the writer is reclaimable under memory reservation.
+          ASSERT_FALSE(writer->testingNonReclaimableSection());
+        }));
+
+    {
+      memory::NonReclaimableSectionGuard nonReclaimableGuard(
+          &nonReclaimableSection);
+      for (size_t i = 0; i < vectors.size(); ++i) {
+        writer->write(vectors[i]);
+      }
+      writer->flush();
+    }
+    ASSERT_EQ(reservationCalled, enableReclaim);
+    writer->close();
+  }
+}
+
+TEST_F(E2EWriterTest, memoryReclaimAfterClose) {
+  const auto type = ROW(
+      {{"int_val", INTEGER()},
+       {"string_val", VARCHAR()},
+       {"binary_val", VARBINARY()}});
+
+  VectorFuzzer fuzzer(
+      {
+          .vectorSize = 1000,
+          .stringLength = 1'000,
+          .stringVariableLength = false,
+      },
+      leafPool_.get());
+  std::vector<VectorPtr> vectors;
+  for (int i = 0; i < 10; ++i) {
+    vectors.push_back(fuzzer.fuzzInputRow(type));
+  }
+
+  const common::SpillConfig spillConfig = getSpillConfig(10, 20);
+  struct {
+    bool canReclaim;
+    bool abort;
+    bool expectedNonReclaimableAttempt;
+
+    std::string debugString() const {
+      return fmt::format(
+          "canReclaim: {}, abort: {}, expectedNonReclaimableAttempt: {}",
+          canReclaim,
+          abort,
+          expectedNonReclaimableAttempt);
+    }
+  } testSettings[] = {
+      {true, true, true},
+      {true, false, true},
+      {false, true, false},
+      {false, false, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto config = std::make_shared<dwrf::Config>();
+    config->set<uint64_t>(dwrf::Config::STRIPE_SIZE, 1L << 30);
+    config->set<uint64_t>(dwrf::Config::MAX_DICTIONARY_SIZE, 1L << 30);
+
+    dwrf::WriterOptions options;
+    options.schema = type;
+    options.config = std::move(config);
+    tsan_atomic<bool> nonReclaimableSection{false};
+    options.nonReclaimableSection = &nonReclaimableSection;
+    if (testData.canReclaim) {
+      options.spillConfig = &spillConfig;
+    }
+    auto writerPool = memory::memoryManager()->addRootPool(
+        "memoryReclaim", 1L << 30, exec::MemoryReclaimer::create());
+    auto dwrfPool = writerPool->addAggregateChild("writer");
+    auto sinkPool =
+        writerPool->addLeafChild("sink", true, exec::MemoryReclaimer::create());
+    auto sink = std::make_unique<MemorySink>(
+        200 * 1024 * 1024, FileSink::Options{.pool = sinkPool.get()});
+
+    auto writer =
+        std::make_unique<dwrf::Writer>(std::move(sink), options, dwrfPool);
+    ASSERT_EQ(writer->state(), dwio::common::Writer::State::kRunning);
+    ASSERT_EQ(writer->canReclaim(), testData.canReclaim);
+
+    writer->flush();
+
+    {
+      memory::NonReclaimableSectionGuard nonReclaimableGuard(
+          &nonReclaimableSection);
+      for (size_t i = 0; i < vectors.size(); ++i) {
+        writer->write(vectors[i]);
+      }
+    }
+
+    if (testData.abort) {
+      writer->abort();
+      VELOX_ASSERT_THROW(writer->abort(), "Writer is not running: ABORTED");
+      VELOX_ASSERT_THROW(writer->close(), "Writer is not running: ABORTED");
+    } else {
+      writer->close();
+      VELOX_ASSERT_THROW(writer->abort(), "Writer is not running: CLOSED");
+      VELOX_ASSERT_THROW(writer->close(), "Writer is not running: CLOSED");
+    }
+    // Verify append or write after close or abort will fail.
+    VELOX_ASSERT_THROW(writer->write(vectors[0]), "Writer is not running");
+    VELOX_ASSERT_THROW(writer->flush(), "Writer is not running");
+
+    memory::MemoryReclaimer::Stats stats;
+    const auto oldCapacity = writerPool->capacity();
+    writerPool->reclaim(1L << 30, 0, stats);
+    if (testData.abort || !testData.canReclaim) {
+      ASSERT_EQ(stats.numNonReclaimableAttempts, 0);
+    } else {
+      ASSERT_EQ(stats.numNonReclaimableAttempts, 1);
+    }
+    // Reclaim does not happen as the writer is either aborted or closed.
+    ASSERT_EQ(stats.reclaimExecTimeUs, 0);
+    ASSERT_EQ(stats.reclaimedBytes, 0);
+  }
+}
+
+DEBUG_ONLY_TEST_F(E2EWriterTest, memoryReclaimDuringInit) {
+  const auto type = ROW(
+      {{"int_val", INTEGER()},
+       {"string_val", VARCHAR()},
+       {"binary_val", VARBINARY()}});
+
+  VectorFuzzer fuzzer(
+      {
+          .vectorSize = 1000,
+          .stringLength = 1'000,
+          .stringVariableLength = false,
+      },
+      leafPool_.get());
+
+  const common::SpillConfig spillConfig = getSpillConfig(10, 20);
+  for (const auto& reclaimable : {false, true}) {
+    SCOPED_TRACE(fmt::format("reclaimable {}", reclaimable));
+
+    auto config = std::make_shared<dwrf::Config>();
+    config->set<uint64_t>(dwrf::Config::STRIPE_SIZE, 1L << 30);
+    config->set<uint64_t>(dwrf::Config::MAX_DICTIONARY_SIZE, 1L << 30);
+
+    dwrf::WriterOptions options;
+    options.schema = type;
+    options.config = std::move(config);
+    tsan_atomic<bool> nonReclaimableSection{false};
+    options.nonReclaimableSection = &nonReclaimableSection;
+    if (reclaimable) {
+      options.spillConfig = &spillConfig;
+    }
+    auto writerPool = memory::memoryManager()->addRootPool(
+        "memoryReclaimDuringInit", 1L << 30, exec::MemoryReclaimer::create());
+    auto dwrfPool = writerPool->addAggregateChild("writer");
+    auto sinkPool =
+        writerPool->addLeafChild("sink", true, exec::MemoryReclaimer::create());
+    auto sink = std::make_unique<MemorySink>(
+        200 * 1024 * 1024, FileSink::Options{.pool = sinkPool.get()});
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe",
+        std::function<void(MemoryPool*)>([&](MemoryPool* /*unused*/) {
+          auto reclaimableBytesOpt = writerPool->reclaimableBytes();
+          ASSERT_EQ(reclaimableBytesOpt.has_value(), reclaimable);
+
+          memory::MemoryReclaimer::Stats stats;
+          writerPool->reclaim(1L << 30, 0, stats);
+          if (reclaimable) {
+            ASSERT_GE(reclaimableBytesOpt.value(), 0);
+            // We can't reclaim during writer init.
+            ASSERT_LE(stats.numNonReclaimableAttempts, 1);
+            ASSERT_EQ(stats.reclaimedBytes, 0);
+            ASSERT_EQ(stats.reclaimExecTimeUs, 0);
+          } else {
+            ASSERT_EQ(stats, memory::MemoryReclaimer::Stats{});
+          }
+        }));
+
+    std::unique_ptr<dwrf::Writer> writer;
+    {
+      memory::NonReclaimableSectionGuard nonReclaimableGuard(
+          &nonReclaimableSection);
+      std::thread writerThread([&]() {
+        writer =
+            std::make_unique<dwrf::Writer>(std::move(sink), options, dwrfPool);
+      });
+
+      writerThread.join();
+    }
+    ASSERT_TRUE(writer != nullptr);
+    ASSERT_EQ(writer->canReclaim(), reclaimable);
+    writer->close();
+  }
+}
+
+DEBUG_ONLY_TEST_F(E2EWriterTest, memoryReclaimThreshold) {
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::MemoryReclaimer::reclaimableBytes",
+      std::function<void(dwrf::Writer*)>([&](dwrf::Writer* writer) {
+        // Release before reclaim to make it not able to reclaim from
+        // reserved memory.
+        writer->getContext().releaseMemoryReservation();
+      }));
+  const auto type = ROW(
+      {{"int_val", INTEGER()},
+       {"string_val", VARCHAR()},
+       {"binary_val", VARBINARY()}});
+
+  VectorFuzzer fuzzer(
+      {
+          .vectorSize = 1000,
+          .stringLength = 1'000,
+          .stringVariableLength = false,
+      },
+      leafPool_.get());
+  std::vector<VectorPtr> vectors;
+  for (int i = 0; i < 10; ++i) {
+    vectors.push_back(fuzzer.fuzzInputRow(type));
+  }
+  const std::vector<uint64_t> writerFlushThresholdSizes = {0, 1L << 30};
+  for (uint64_t writerFlushThresholdSize : writerFlushThresholdSizes) {
+    SCOPED_TRACE(fmt::format(
+        "writerFlushThresholdSize {}",
+        succinctBytes(writerFlushThresholdSize)));
+
+    const common::SpillConfig spillConfig =
+        getSpillConfig(10, 20, writerFlushThresholdSize);
+    auto config = std::make_shared<dwrf::Config>();
+    config->set<uint64_t>(dwrf::Config::STRIPE_SIZE, 1L << 30);
+    config->set<uint64_t>(dwrf::Config::MAX_DICTIONARY_SIZE, 1L << 30);
+
+    dwrf::WriterOptions options;
+    options.schema = type;
+    options.config = std::move(config);
+    tsan_atomic<bool> nonReclaimableSection{false};
+    options.nonReclaimableSection = &nonReclaimableSection;
+    options.spillConfig = &spillConfig;
+
+    auto writerPool = memory::memoryManager()->addRootPool(
+        "memoryReclaimThreshold", 1L << 30, exec::MemoryReclaimer::create());
+    auto dwrfPool = writerPool->addAggregateChild("writer");
+    auto sinkPool =
+        writerPool->addLeafChild("sink", true, exec::MemoryReclaimer::create());
+    auto sink = std::make_unique<MemorySink>(
+        200 * 1024 * 1024, FileSink::Options{.pool = sinkPool.get()});
+
+    auto writer =
+        std::make_unique<dwrf::Writer>(std::move(sink), options, dwrfPool);
+
+    {
+      memory::NonReclaimableSectionGuard nonReclaimableGuard(
+          &nonReclaimableSection);
+      for (size_t i = 0; i < vectors.size(); ++i) {
+        writer->write(vectors[i]);
+      }
+    }
+
+    uint64_t reclaimableBytes{0};
+    memory::MemoryReclaimer::Stats stats;
+    if (writerFlushThresholdSize == 0) {
+      ASSERT_TRUE(writerPool->reclaimer()->reclaimableBytes(
+          *writerPool, reclaimableBytes));
+      ASSERT_GT(reclaimableBytes, 0);
+      {
+        memory::ScopedMemoryArbitrationContext arbitrationCtx(writerPool.get());
+        ASSERT_GT(writerPool->reclaim(1L << 30, 0, stats), 0);
+      }
+      ASSERT_GT(stats.reclaimExecTimeUs, 0);
+      ASSERT_GT(stats.reclaimedBytes, 0);
+    } else {
+      ASSERT_FALSE(writerPool->reclaimer()->reclaimableBytes(
+          *writerPool, reclaimableBytes));
+      ASSERT_EQ(reclaimableBytes, 0);
+      {
+        memory::ScopedMemoryArbitrationContext arbitrationCtx(writerPool.get());
+        ASSERT_EQ(writerPool->reclaim(1L << 30, 0, stats), 0);
+      }
+      ASSERT_EQ(stats.numNonReclaimableAttempts, 0);
+      ASSERT_EQ(stats.reclaimExecTimeUs, 0);
+      ASSERT_EQ(stats.reclaimedBytes, 0);
+    }
+    writer->flush();
+    writer->close();
+  }
+}
+} // namespace
diff --git a/velox/dwio/dwrf/test/E2EWriterTests.cpp b/velox/dwio/dwrf/test/E2EWriterTests.cpp
deleted file mode 100644
index 20dcd35eabc37..0000000000000
--- a/velox/dwio/dwrf/test/E2EWriterTests.cpp
+++ /dev/null
@@ -1,1505 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Random.h>
-#include <random>
-#include "velox/dwio/common/Options.h"
-#include "velox/dwio/common/Statistics.h"
-#include "velox/dwio/common/TypeWithId.h"
-#include "velox/dwio/common/encryption/TestProvider.h"
-#include "velox/dwio/common/tests/utils/BatchMaker.h"
-#include "velox/dwio/common/tests/utils/MapBuilder.h"
-#include "velox/dwio/dwrf/reader/DwrfReader.h"
-#include "velox/dwio/dwrf/test/OrcTest.h"
-#include "velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
-#include "velox/type/fbhive/HiveTypeParser.h"
-#include "velox/vector/FlatVector.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
-
-using namespace ::testing;
-using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::dwio::common::encryption;
-using namespace facebook::velox::dwio::common::encryption::test;
-using namespace facebook::velox::test;
-using namespace facebook::velox::dwrf;
-using namespace facebook::velox::dwrf::encryption;
-using namespace facebook::velox::type::fbhive;
-using namespace facebook::velox;
-using facebook::velox::memory::MemoryPool;
-using folly::Random;
-
-constexpr uint64_t kSizeMB = 1024UL * 1024UL;
-
-namespace {
-auto defaultPool = memory::addDefaultLeafMemoryPool();
-}
-
-class E2EWriterTests : public Test {
- protected:
-  E2EWriterTests() {
-    rootPool_ = memory::defaultMemoryManager().addRootPool("E2EWriterTests");
-    leafPool_ = rootPool_->addLeafChild("leaf");
-  }
-
-  std::unique_ptr<DwrfReader> createReader(
-      const MemorySink& sink,
-      const dwio::common::ReaderOptions& opts) {
-    std::string_view data(sink.data(), sink.size());
-    return std::make_unique<DwrfReader>(
-        opts,
-        std::make_unique<BufferedInput>(
-            std::make_shared<InMemoryReadFile>(data), opts.getMemoryPool()));
-  }
-
-  void testFlatMapConfig(
-      std::shared_ptr<const Type> type,
-      const std::vector<uint32_t>& mapColumnIds,
-      const std::unordered_set<uint32_t>& expectedNodeIds) {
-    size_t size = 100;
-    size_t stripes = 3;
-
-    // write file to memory
-    auto config = std::make_shared<dwrf::Config>();
-    config->set(dwrf::Config::FLATTEN_MAP, true);
-    config->set<const std::vector<uint32_t>>(
-        dwrf::Config::MAP_FLAT_COLS, mapColumnIds);
-    config->set(dwrf::Config::MAP_STATISTICS, true);
-
-    auto sink = std::make_unique<MemorySink>(
-        200 * 1024 * 1024,
-        dwio::common::FileSink::Options{.pool = leafPool_.get()});
-    auto sinkPtr = sink.get();
-
-    dwrf::WriterOptions options;
-    options.config = config;
-    options.schema = type;
-    options.memoryPool = rootPool_.get();
-    dwrf::Writer writer{std::move(sink), options};
-
-    for (size_t i = 0; i < stripes; ++i) {
-      writer.write(BatchMaker::createBatch(type, size, *leafPool_, nullptr, i));
-    }
-
-    writer.close();
-
-    dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-    RowReaderOptions rowReaderOpts;
-    auto reader = createReader(*sinkPtr, readerOpts);
-    auto rowReader = reader->createRowReader(rowReaderOpts);
-    auto dwrfRowReader = dynamic_cast<DwrfRowReader*>(rowReader.get());
-    bool preload = true;
-    std::unordered_set<uint32_t> actualNodeIds;
-    for (int32_t i = 0; i < reader->getNumberOfStripes(); ++i) {
-      dwrfRowReader->loadStripe(i, preload);
-      auto& footer = dwrfRowReader->getStripeFooter();
-      for (int32_t j = 0; j < footer.encoding_size(); ++j) {
-        auto encoding = footer.encoding(j);
-        if (encoding.kind() ==
-            proto::ColumnEncoding_Kind::ColumnEncoding_Kind_MAP_FLAT) {
-          actualNodeIds.insert(encoding.node());
-        }
-      }
-      ASSERT_EQ(expectedNodeIds, actualNodeIds);
-    }
-  }
-
-  void testFlatMapFileStats(
-      std::shared_ptr<const Type> type,
-      const std::vector<uint32_t>& mapColumnIds,
-      const uint32_t strideSize = 10000,
-      const uint32_t rowCount = 2000) {
-    size_t stripes = 3;
-
-    // write file to memory
-    auto config = std::make_shared<dwrf::Config>();
-    // Ensure we cross stride boundary
-    config->set(dwrf::Config::ROW_INDEX_STRIDE, strideSize);
-    config->set(dwrf::Config::FLATTEN_MAP, true);
-    config->set<const std::vector<uint32_t>>(
-        dwrf::Config::MAP_FLAT_COLS, mapColumnIds);
-    config->set(dwrf::Config::MAP_STATISTICS, true);
-
-    auto sink = std::make_unique<MemorySink>(
-        400 * 1024 * 1024,
-        dwio::common::FileSink::Options{.pool = leafPool_.get()});
-    auto sinkPtr = sink.get();
-
-    dwrf::WriterOptions options;
-    options.config = config;
-    options.schema = type;
-    options.memoryPool = rootPool_.get();
-    dwrf::Writer writer{std::move(sink), options};
-
-    const size_t seed = std::time(nullptr);
-    LOG(INFO) << "seed: " << seed;
-    std::mt19937 gen{};
-    gen.seed(seed);
-    for (size_t i = 0; i < stripes; ++i) {
-      // The logic really does not depend on data shape. Hence, we can
-      // ignore the nulls.
-      writer.write(
-          BatchMaker::createBatch(type, rowCount, *leafPool_, gen, nullptr));
-      writer.flush();
-    }
-
-    writer.close();
-
-    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
-    RowReaderOptions rowReaderOpts;
-    auto reader = createReader(*sinkPtr, readerOpts);
-    auto rowReader = reader->createRowReader(rowReaderOpts);
-
-    auto dwrfRowReader = dynamic_cast<DwrfRowReader*>(rowReader.get());
-    bool preload = true;
-
-    auto typeWithId = TypeWithId::create(type);
-    for (auto mapColumn : mapColumnIds) {
-      folly::F14FastMap<KeyInfo, uint64_t, folly::transparent<KeyInfoHash>>
-          featureStreamSizes;
-      auto mapTypeId = typeWithId->childAt(mapColumn)->id();
-      auto valueTypeId = mapTypeId + 2;
-      for (int32_t i = 0; i < reader->getNumberOfStripes(); ++i) {
-        auto currentStripeInfo = dwrfRowReader->loadStripe(i, preload);
-        StripeStreamsImpl stripeStreams(
-            *dwrfRowReader,
-            dwrfRowReader->getColumnSelector(),
-            rowReaderOpts,
-            currentStripeInfo.offset(),
-            currentStripeInfo.numberOfRows(),
-            *dwrfRowReader,
-            i);
-
-        folly::F14FastMap<int64_t, dwio::common::KeyInfo> sequenceToKey;
-
-        stripeStreams.visitStreamsOfNode(
-            valueTypeId, [&](const StreamInformation& stream) {
-              auto sequence = stream.getSequence();
-              // No need to load shared dictionary stream here.
-              if (sequence == 0) {
-                return;
-              }
-
-              EncodingKey seqEk(valueTypeId, sequence);
-              const auto& keyInfo = stripeStreams.getEncoding(seqEk).key();
-              auto key = constructKey(keyInfo);
-              sequenceToKey.emplace(sequence, key);
-            });
-
-        auto allStreams = stripeStreams.getStreamIdentifiers();
-        for (const auto& streamIdPerNode : allStreams) {
-          for (const auto& streamId : streamIdPerNode.second) {
-            if (streamId.encodingKey().sequence() != 0 &&
-                streamId.column() == mapColumn) {
-              // Update the aggregate.
-              const auto& keyInfo =
-                  sequenceToKey.at(streamId.encodingKey().sequence());
-              auto streamLength = stripeStreams.getStreamLength(streamId);
-              auto it = featureStreamSizes.find(keyInfo);
-              if (it == featureStreamSizes.end()) {
-                featureStreamSizes.emplace(keyInfo, streamLength);
-              } else {
-                it->second += streamLength;
-              }
-            }
-          }
-        }
-      }
-      auto stats = reader->getFooter().statistics(mapTypeId);
-      ASSERT_TRUE(stats.has_mapstatistics());
-      ASSERT_EQ(featureStreamSizes.size(), stats.mapstatistics().stats_size());
-      for (size_t i = 0; i != stats.mapstatistics().stats_size(); ++i) {
-        const auto& entry = stats.mapstatistics().stats(i);
-        ASSERT_TRUE(entry.stats().has_size());
-        EXPECT_EQ(
-            featureStreamSizes.at(constructKey(entry.key())),
-            entry.stats().size());
-      }
-    }
-  }
-
-  std::shared_ptr<MemoryPool> rootPool_;
-  std::shared_ptr<MemoryPool> leafPool_;
-};
-
-// This test can be run to generate test files. Run it with following command
-// buck test velox/dwio/dwrf/test:velox_dwrf_e2e_writer_tests --
-// DISABLED_TestFileCreation
-// --run-disabled
-TEST_F(E2EWriterTests, DISABLED_TestFileCreation) {
-  const size_t batchCount = 4;
-  const size_t size = 200;
-
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "bool_val:boolean,"
-      "byte_val:tinyint,"
-      "short_val:smallint,"
-      "int_val:int,"
-      "long_val:bigint,"
-      "float_val:float,"
-      "double_val:double,"
-      "string_val:string,"
-      "binary_val:binary,"
-      "timestamp_val:timestamp,"
-      "array_val:array<float>,"
-      "map_val:map<int,double>,"
-      "map_val:map<bigint,double>," /* this is column 12 */
-      "map_val:map<bigint,map<string, int>>," /* this is column 13 */
-      "struct_val:struct<a:float,b:double>"
-      ">");
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(
-      dwrf::Config::MAP_FLAT_COLS,
-      {12, 13}); /* this is the second and third map */
-
-  std::vector<VectorPtr> batches;
-  for (size_t i = 0; i < batchCount; ++i) {
-    batches.push_back(
-        BatchMaker::createBatch(type, size, *leafPool_, nullptr, i));
-  }
-
-  auto path = "/tmp/e2e_generated_file.orc";
-  auto localWriteFile = std::make_unique<LocalWriteFile>(path, true, false);
-  auto sink = std::make_unique<WriteFileSink>(std::move(localWriteFile), path);
-  E2EWriterTestUtil::writeData(
-      std::move(sink),
-      type,
-      batches,
-      config,
-      E2EWriterTestUtil::simpleFlushPolicyFactory(true));
-}
-
-VectorPtr createRowVector(
-    facebook::velox::memory::MemoryPool* pool,
-    std::shared_ptr<const Type> type,
-    size_t size,
-    const VectorPtr& child) {
-  return std::make_shared<RowVector>(
-      pool,
-      type,
-      BufferPtr(nullptr),
-      size,
-      std::vector<VectorPtr>{child},
-      0 /*nullCount*/);
-}
-
-TEST_F(E2EWriterTests, E2E) {
-  const size_t batchCount = 4;
-  // Start with a size larger than stride to cover splitting into
-  // strides. Continue with smaller size for faster test.
-  size_t size = 1100;
-
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "bool_val:boolean,"
-      "byte_val:tinyint,"
-      "short_val:smallint,"
-      "int_val:int,"
-      "long_val:bigint,"
-      "float_val:float,"
-      "double_val:double,"
-      "string_val:string,"
-      "binary_val:binary,"
-      "timestamp_val:timestamp,"
-      "array_val:array<float>,"
-      "map_val:map<int,double>,"
-      "map_val:map<bigint,double>," /* this is column 12 */
-      "map_val:map<bigint,map<string, int>>," /* this is column 13 */
-      "struct_val:struct<a:float,b:double>"
-      ">");
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::ROW_INDEX_STRIDE, static_cast<uint32_t>(1000));
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(
-      dwrf::Config::MAP_FLAT_COLS,
-      {12, 13}); /* this is the second and third map */
-
-  std::vector<VectorPtr> batches;
-  for (size_t i = 0; i < batchCount; ++i) {
-    batches.push_back(
-        BatchMaker::createBatch(type, size, *leafPool_, nullptr, i));
-    size = 200;
-  }
-
-  E2EWriterTestUtil::testWriter(*leafPool_, type, batches, 1, 1, config);
-}
-
-TEST_F(E2EWriterTests, FlatMapDictionaryEncoding) {
-  const size_t batchCount = 4;
-  // Start with a size larger than stride to cover splitting into
-  // strides. Continue with smaller size for faster test.
-  size_t size = 1100;
-  auto pool = memory::addDefaultLeafMemoryPool();
-
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "map_val:map<int,double>,"
-      "map_val:map<bigint,double>,"
-      "map_val:map<bigint,map<string, int>>,"
-      "map_val:map<int, string>,"
-      "map_val:map<bigint,map<int, string>>"
-      ">");
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::ROW_INDEX_STRIDE, static_cast<uint32_t>(1000));
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(dwrf::Config::MAP_FLAT_COLS, {0, 1, 2, 3, 4});
-  config->set(dwrf::Config::MAP_FLAT_DISABLE_DICT_ENCODING, false);
-  config->set(dwrf::Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 1.0f);
-  config->set(dwrf::Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 1.0f);
-  config->set(dwrf::Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
-
-  std::vector<VectorPtr> batches;
-  std::mt19937 gen;
-  gen.seed(983871726);
-  for (size_t i = 0; i < batchCount; ++i) {
-    batches.push_back(BatchMaker::createBatch(type, size, *pool, gen));
-    size = 200;
-  }
-
-  E2EWriterTestUtil::testWriter(*pool, type, batches, 1, 1, config);
-}
-
-TEST_F(E2EWriterTests, MaxFlatMapKeys) {
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  const uint32_t keyLimit = 2000;
-  const auto randomStart = Random::rand32(100);
-
-  auto pool = memory::addDefaultLeafMemoryPool();
-  b::row row;
-  for (int32_t i = 0; i < keyLimit; ++i) {
-    row.push_back(b::pair{randomStart + i, Random::rand64()});
-  }
-
-  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
-  auto batch =
-      createRowVector(pool.get(), type, 1, b::create(*pool, b::rows{row}));
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
-  config->set(dwrf::Config::MAP_FLAT_MAX_KEYS, keyLimit);
-
-  E2EWriterTestUtil::testWriter(
-      *pool, type, E2EWriterTestUtil::generateBatches(batch), 1, 1, config);
-}
-
-TEST_F(E2EWriterTests, PresentStreamIsSuppressedOnFlatMap) {
-  using keyType = int32_t;
-  using valueType = int64_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  const auto randomStart = Random::rand32(100);
-
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-  b::row row;
-  row.push_back(b::pair{randomStart, Random::rand64()});
-
-  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
-  auto batch =
-      createRowVector(pool.get(), type, 1, b::create(*pool, b::rows{row}));
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
-
-  auto sink = std::make_unique<MemorySink>(
-      200 * 1024 * 1024,
-      dwio::common::FileSink::Options{.pool = leafPool_.get()});
-  auto sinkPtr = sink.get();
-
-  auto writer = E2EWriterTestUtil::writeData(
-      std::move(sink),
-      type,
-      E2EWriterTestUtil::generateBatches(std::move(batch)),
-      config,
-      E2EWriterTestUtil::simpleFlushPolicyFactory(true));
-
-  dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-  RowReaderOptions rowReaderOpts;
-  auto reader = createReader(*sinkPtr, readerOpts);
-  auto rowReader = reader->createRowReader(rowReaderOpts);
-  auto dwrfRowReader = dynamic_cast<DwrfRowReader*>(rowReader.get());
-  bool preload = true;
-  std::unordered_set<uint32_t> actualNodeIds;
-  for (int i = 0; i < reader->getNumberOfStripes(); ++i) {
-    dwrfRowReader->loadStripe(i, preload);
-    auto& footer = dwrfRowReader->getStripeFooter();
-    for (int j = 0; j < footer.streams_size(); ++j) {
-      auto stream = footer.streams(j);
-      ASSERT_NE(stream.kind(), proto::Stream_Kind::Stream_Kind_PRESENT);
-    }
-  }
-}
-
-TEST_F(E2EWriterTests, TooManyFlatMapKeys) {
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  const uint32_t keyLimit = 2000;
-  const auto randomStart = Random::rand32(100);
-
-  auto pool = memory::addDefaultLeafMemoryPool();
-  b::row row;
-  for (int32_t i = 0; i < (keyLimit + 1); ++i) {
-    row.push_back(b::pair{randomStart + i, Random::rand64()});
-  }
-
-  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
-  auto batch =
-      createRowVector(pool.get(), type, 1, b::create(*pool, b::rows{row}));
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
-  config->set(dwrf::Config::MAP_FLAT_MAX_KEYS, keyLimit);
-
-  EXPECT_THROW(
-      E2EWriterTestUtil::testWriter(
-          *pool, type, E2EWriterTestUtil::generateBatches(batch), 1, 1, config),
-      exception::LoggedException);
-}
-
-TEST_F(E2EWriterTests, FlatMapBackfill) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  const uint32_t strideSize = 1000;
-
-  std::vector<VectorPtr> batches;
-  b::rows rows;
-
-  for (int32_t i = 0; i < (strideSize * 3); ++i) {
-    rows.push_back(
-        b::row{b::pair{1, Random::rand64()}, b::pair{2, Random::rand64()}});
-  }
-
-  for (int32_t i = 0; i < (strideSize / 2); ++i) {
-    rows.push_back(b::row{b::pair{1, Random::rand64()}});
-  }
-
-  // This row introduces new key, in the middle of a stride and and existing key
-  // that wasn't used in this stride. The new key will trigger backfilling based
-  // on previous stride rows. But since this is part of a bigger batch, spanning
-  // the entire current stride, it will not trigger the partial stride backfill.
-  // This is covered in the next batch below.
-  rows.push_back(
-      b::row{b::pair{3, Random::rand64()}, b::pair{2, Random::rand64()}});
-
-  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
-  auto rowCount = rows.size();
-  auto batch = createRowVector(
-      pool.get(), type, rowCount, b::create(*pool, std::move(rows)));
-  batches.push_back(batch);
-
-  // This extra batch is forcing another write call in the same (partial)
-  // stride. This tests the backfill of partial strides.
-  batch = createRowVector(
-      pool.get(),
-      type,
-      1,
-      b::create(*pool, {b::row{b::pair{4, Random::rand64()}}}));
-  batches.push_back(batch);
-  // TODO: Add another batch inside last stride, to test for backfill in stride.
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
-  config->set(dwrf::Config::ROW_INDEX_STRIDE, strideSize);
-
-  E2EWriterTestUtil::testWriter(
-      *pool,
-      type,
-      batches,
-      1,
-      1,
-      config,
-      E2EWriterTestUtil::simpleFlushPolicyFactory(false));
-}
-
-void testFlatMapWithNulls(
-    bool firstRowNotNull,
-    bool enableFlatmapDictionaryEncoding = false,
-    bool shareDictionary = false) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  const uint32_t strideSize = 1000;
-
-  std::vector<VectorPtr> batches;
-  b::rows rows;
-
-  for (int32_t i = 0; i < (strideSize * 3); ++i) {
-    if (firstRowNotNull && i == 0) {
-      rows.push_back(
-          b::row{b::pair{1, Random::rand64()}, b::pair{2, Random::rand64()}});
-    } else {
-      rows.push_back({});
-    }
-  }
-
-  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
-  auto rowCount = rows.size();
-  auto batch = createRowVector(
-      pool.get(), type, rowCount, b::create(*pool, std::move(rows)));
-  batches.push_back(batch);
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
-  config->set(dwrf::Config::ROW_INDEX_STRIDE, strideSize);
-  config->set(
-      dwrf::Config::MAP_FLAT_DISABLE_DICT_ENCODING,
-      !enableFlatmapDictionaryEncoding);
-  config->set(dwrf::Config::MAP_FLAT_DICT_SHARE, shareDictionary);
-
-  E2EWriterTestUtil::testWriter(
-      *pool,
-      type,
-      batches,
-      1,
-      1,
-      config,
-      E2EWriterTestUtil::simpleFlushPolicyFactory(false));
-}
-
-TEST_F(E2EWriterTests, FlatMapWithNulls) {
-  testFlatMapWithNulls(
-      /* firstRowNotNull */ false, /* enableFlatmapDictionaryEncoding */ false);
-  testFlatMapWithNulls(
-      /* firstRowNotNull */ true, /* enableFlatmapDictionaryEncoding */ false);
-  testFlatMapWithNulls(
-      /* firstRowNotNull */ false, /* enableFlatmapDictionaryEncoding */ true);
-  testFlatMapWithNulls(
-      /* firstRowNotNull */ true, /* enableFlatmapDictionaryEncoding */ true);
-}
-
-TEST_F(E2EWriterTests, FlatMapWithNullsSharedDict) {
-  testFlatMapWithNulls(
-      /* firstRowNotNull */ false,
-      /* enableFlatmapDictionaryEncoding */ true,
-      /* shareDictionary */ true);
-  testFlatMapWithNulls(
-      /* firstRowNotNull */ true,
-      /* enableFlatmapDictionaryEncoding */ true,
-      /* shareDictionary */ true);
-}
-
-TEST_F(E2EWriterTests, FlatMapEmpty) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-
-  using keyType = int32_t;
-  using valueType = int32_t;
-  using b = MapBuilder<keyType, valueType>;
-
-  const uint32_t strideSize = 1000;
-
-  std::vector<VectorPtr> batches;
-  b::rows rows;
-
-  for (int32_t i = 0; i < strideSize; ++i) {
-    if (i % 5 != 0) {
-      rows.push_back(b::row{b::pair{i % 3, Random::rand64()}});
-    } else {
-      rows.push_back(b::row{});
-    }
-  }
-
-  const auto type = CppToType<Row<Map<keyType, valueType>>>::create();
-  auto rowCount = rows.size();
-  auto batch = createRowVector(
-      pool.get(), type, rowCount, b::create(*pool, std::move(rows)));
-  batches.push_back(batch);
-
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
-  config->set(dwrf::Config::ROW_INDEX_STRIDE, strideSize);
-
-  E2EWriterTestUtil::testWriter(
-      *pool,
-      type,
-      batches,
-      1,
-      1,
-      config,
-      E2EWriterTestUtil::simpleFlushPolicyFactory(false));
-}
-
-TEST_F(E2EWriterTests, FlatMapConfigSingleColumn) {
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "map_val:map<bigint,double>,"
-      ">");
-
-  testFlatMapConfig(type, {0}, {1});
-  testFlatMapConfig(type, {}, {});
-}
-
-TEST_F(E2EWriterTests, FlatMapConfigMixedTypes) {
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "bool_val:boolean,"
-      "map_val:map<bigint,double>,"
-      ">");
-
-  testFlatMapConfig(type, {1}, {2});
-  testFlatMapConfig(type, {}, {});
-}
-
-TEST_F(E2EWriterTests, FlatMapConfigNestedMap) {
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "bool_val:boolean,"
-      "map_val:map<bigint,map<string,float>>,"
-      ">");
-
-  testFlatMapConfig(type, {1}, {2});
-  testFlatMapConfig(type, {}, {});
-}
-
-TEST_F(E2EWriterTests, FlatMapConfigMixedMaps) {
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "map_val:map<bigint,map<string,float>>,"
-      "map_val:map<bigint,float>,"
-      "map_val:map<bigint,map<string,float>>,"
-      "map_val:map<bigint,double>,"
-      ">");
-
-  testFlatMapConfig(type, {2, 3}, {9, 14});
-  testFlatMapConfig(type, {}, {});
-}
-
-TEST_F(E2EWriterTests, FlatMapConfigNotMapColumn) {
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "bool_val:boolean,"
-      "map_val:map<bigint,double>,"
-      ">");
-
-  EXPECT_THROW(
-      { testFlatMapConfig(type, {0}, {}); }, exception::LoggedException);
-}
-
-TEST_F(E2EWriterTests, mapStatsSingleStride) {
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "map_val:map<bigint,int>,"
-      "map_val:map<bigint,double>,"
-      "map_val:map<bigint,map<bigint,bigint>>,"
-      "map_val:map<bigint,map<bigint,double>>,"
-      "map_val:map<bigint,array<bigint>>,"
-      "map_val:map<bigint,map<string,float>>,"
-      ">");
-
-  // Single column
-  testFlatMapFileStats(type, {0});
-  // All non-nested columns
-  testFlatMapFileStats(type, {0, 1});
-  // All columns
-  testFlatMapFileStats(type, {0, 1, 2, 3, 4, 5});
-}
-
-TEST_F(E2EWriterTests, mapStatsMultiStrides) {
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "map_val:map<bigint,int>,"
-      "map_val:map<bigint,double>,"
-      "map_val:map<bigint,map<bigint,bigint>>,"
-      "map_val:map<bigint,map<bigint,double>>,"
-      "map_val:map<bigint,array<bigint>>,"
-      "map_val:map<bigint,map<string,float>>,"
-      ">");
-
-  // Single column
-  testFlatMapFileStats(type, {0}, /*strideSize=*/1000);
-  // All non-nested columns
-  testFlatMapFileStats(type, {0, 1}, /*strideSize=*/1000);
-  // All columns
-  testFlatMapFileStats(type, {0, 1, 2, 3, 4, 5}, /*strideSize=*/1000);
-}
-
-TEST_F(E2EWriterTests, PartialStride) {
-  auto type = ROW({"bool_val"}, {INTEGER()});
-
-  size_t size = 1'000;
-
-  auto config = std::make_shared<dwrf::Config>();
-  auto sink = std::make_unique<MemorySink>(
-      2 * 1024 * 1024,
-      dwio::common::FileSink::Options{.pool = leafPool_.get()});
-  auto sinkPtr = sink.get();
-
-  dwrf::WriterOptions options;
-  options.config = config;
-  options.schema = type;
-  options.memoryPool = rootPool_.get();
-  dwrf::Writer writer{std::move(sink), options};
-
-  auto nulls = allocateNulls(size, leafPool_.get());
-  auto* nullsPtr = nulls->asMutable<uint64_t>();
-  size_t nullCount = 0;
-
-  auto values = AlignedBuffer::allocate<int32_t>(size, leafPool_.get());
-  auto* valuesPtr = values->asMutable<int32_t>();
-
-  for (size_t i = 0; i < size; ++i) {
-    if ((i & 1) == 0) {
-      bits::clearNull(nullsPtr, i);
-      valuesPtr[i] = i;
-    } else {
-      bits::setNull(nullsPtr, i);
-      nullCount++;
-    }
-  }
-
-  auto batch = createRowVector(
-      leafPool_.get(),
-      type,
-      size,
-      std::make_shared<FlatVector<int32_t>>(
-          leafPool_.get(),
-          type->childAt(0),
-          nulls,
-          size,
-          values,
-          std::vector<BufferPtr>()));
-
-  writer.write(batch);
-  writer.close();
-
-  dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-  RowReaderOptions rowReaderOpts;
-  auto reader = createReader(*sinkPtr, readerOpts);
-  ASSERT_EQ(size - nullCount, reader->columnStatistics(1)->getNumberOfValues())
-      << reader->columnStatistics(1)->toString();
-  ASSERT_EQ(true, reader->columnStatistics(1)->hasNull().value());
-}
-
-TEST_F(E2EWriterTests, OversizeRows) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "map_val:map<string, map<string, map<string, map<string, string>>>>,"
-      "list_val:array<array<array<array<string>>>>,"
-      "struct_val:struct<"
-      "map_val_field_1:map<string, map<string, map<string, map<string, string>>>>,"
-      "list_val_field_1:array<array<array<array<string>>>>,"
-      "list_val_field_2:array<array<array<array<string>>>>,"
-      "map_val_field_2:map<string, map<string, map<string, map<string, string>>>>"
-      ">,"
-      ">");
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::DISABLE_LOW_MEMORY_MODE, true);
-  config->set(dwrf::Config::STRIPE_SIZE, 10 * kSizeMB);
-  config->set(
-      dwrf::Config::RAW_DATA_SIZE_PER_BATCH, folly::to<uint64_t>(20 * 1024UL));
-
-  // Retained bytes in vector: 44704
-  auto singleBatch = E2EWriterTestUtil::generateBatches(
-      type, 1, 1, /* seed */ 1411367325, *pool);
-
-  E2EWriterTestUtil::testWriter(
-      *pool,
-      type,
-      singleBatch,
-      1,
-      1,
-      config,
-      /* flushPolicyFactory */ nullptr,
-      /* layoutPlannerFactory */ nullptr,
-      /* memoryBudget */ std::numeric_limits<int64_t>::max(),
-      false);
-}
-
-TEST_F(E2EWriterTests, OversizeBatches) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "bool_val:boolean,"
-      "byte_val:tinyint,"
-      "float_val:float,"
-      "double_val:double,"
-      ">");
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::DISABLE_LOW_MEMORY_MODE, true);
-  config->set(dwrf::Config::STRIPE_SIZE, 10 * kSizeMB);
-
-  // Test splitting a gigantic batch.
-  auto singleBatch = E2EWriterTestUtil::generateBatches(
-      type, 1, 10000000, /* seed */ 1411367325, *pool);
-  // A gigantic batch is split into 10 stripes.
-  E2EWriterTestUtil::testWriter(
-      *pool,
-      type,
-      singleBatch,
-      10,
-      10,
-      config,
-      /* flushPolicyFactory */ nullptr,
-      /* layoutPlannerFactory */ nullptr,
-      /* memoryBudget */ std::numeric_limits<int64_t>::max(),
-      false);
-
-  // Test splitting multiple huge batches.
-  auto batches = E2EWriterTestUtil::generateBatches(
-      type, 3, 5000000, /* seed */ 1411367325, *pool);
-  // 3 gigantic batches are split into 15~16 stripes.
-  E2EWriterTestUtil::testWriter(
-      *pool,
-      type,
-      batches,
-      15,
-      16,
-      config,
-      /* flushPolicyFactory */ nullptr,
-      /* layoutPlannerFactory */ nullptr,
-      /* memoryBudget */ std::numeric_limits<int64_t>::max(),
-      false);
-}
-
-TEST_F(E2EWriterTests, OverflowLengthIncrements) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
-
-  HiveTypeParser parser;
-  auto type = parser.parse(
-      "struct<"
-      "struct_val:struct<bigint_val:bigint>"
-      ">");
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::DISABLE_LOW_MEMORY_MODE, true);
-  config->set(dwrf::Config::STRIPE_SIZE, 10 * kSizeMB);
-  config->set(
-      dwrf::Config::RAW_DATA_SIZE_PER_BATCH,
-      folly::to<uint64_t>(500 * 1024UL * 1024UL));
-
-  const size_t size = 1024;
-
-  auto nulls = AlignedBuffer::allocate<char>(bits::nbytes(size), pool.get());
-  auto* nullsPtr = nulls->asMutable<uint64_t>();
-  for (size_t i = 0; i < size; ++i) {
-    // Only the first element is non-null
-    bits::setNull(nullsPtr, i, i != 0);
-  }
-
-  // Bigint column
-  VectorMaker maker{pool.get()};
-  auto child = maker.flatVector<int64_t>(std::vector<int64_t>{1UL});
-
-  std::vector<VectorPtr> children{child};
-  auto rowVec = std::make_shared<RowVector>(
-      pool.get(),
-      type->childAt(0),
-      nulls,
-      size,
-      children,
-      /* nullCount */ size - 1);
-
-  // Retained bytes in vector: 192, which is much less than 1024
-  auto vec = std::make_shared<RowVector>(
-      pool.get(),
-      type,
-      BufferPtr{},
-      size,
-      std::vector<VectorPtr>{rowVec},
-      /* nullCount */ 0);
-
-  E2EWriterTestUtil::testWriter(
-      *pool,
-      type,
-      {vec},
-      1,
-      1,
-      config,
-      /*flushPolicyFactory=*/nullptr,
-      /*layoutPlannerFactory=*/nullptr,
-      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
-      false);
-}
-
-namespace facebook::velox::dwrf {
-
-class E2EEncryptionTest : public E2EWriterTests {
- protected:
-  E2EEncryptionTest() : E2EWriterTests() {}
-
-  std::unique_ptr<DwrfReader> writeAndRead(
-      const std::string& schema,
-      const std::shared_ptr<EncryptionSpecification>& spec,
-      std::shared_ptr<DecrypterFactory> decrypterFactory =
-          std::make_shared<TestDecrypterFactory>()) {
-    HiveTypeParser parser;
-    auto type = parser.parse(schema);
-
-    // write file to memory
-    auto config = std::make_shared<Config>();
-    // make sure we always write dictionary to test stride index
-    config->set(Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 1.0f);
-    config->set(Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
-    auto sink = std::make_unique<MemorySink>(
-        16 * 1024 * 1024,
-        dwio::common::FileSink::Options{.pool = leafPool_.get()});
-    sink_ = sink.get();
-    dwrf::WriterOptions options;
-    options.config = config;
-    options.schema = type;
-    options.encryptionSpec = spec;
-    options.encrypterFactory = std::make_shared<TestEncrypterFactory>();
-    writer_ = std::make_unique<Writer>(std::move(sink), options, rootPool_);
-
-    for (size_t i = 0; i < batchCount_; ++i) {
-      auto batch =
-          BatchMaker::createBatch(type, batchSize_, *leafPool_, nullptr, i);
-      writer_->write(batch);
-      batches_.push_back(std::move(batch));
-      if (i % flushInterval_ == flushInterval_ - 1) {
-        writer_->flush();
-      }
-    }
-    writer_->close();
-
-    // read it back for compare
-    dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-    readerOpts.setDecrypterFactory(decrypterFactory);
-    return createReader(*sink_, readerOpts);
-  }
-
-  const DecryptionHandler& getDecryptionHandler(
-      const DwrfReader& reader) const {
-    return reader.readerBase_->getDecryptionHandler();
-  }
-
-  void validateFileContent(const DwrfReader& reader) const {
-    RowReaderOptions rowReaderOpts;
-    auto rowReader = reader.createRowReader(rowReaderOpts);
-    // make sure size estimate works
-    ASSERT_GT(rowReader->estimatedRowSize(), 0);
-    VectorPtr batch;
-    for (auto& expected : batches_) {
-      ASSERT_TRUE(rowReader->next(batchSize_, batch));
-      compareBatches(batch, expected);
-    }
-    ASSERT_FALSE(rowReader->next(batchSize_, batch));
-
-    // make sure decrypter is actually used
-    auto& handler = getDecryptionHandler(reader);
-    for (size_t i = 0; i < handler.getEncryptionGroupCount(); ++i) {
-      auto& decrypter = dynamic_cast<const TestDecrypter&>(
-          handler.getEncryptionProviderByIndex(i));
-      ASSERT_GT(decrypter.getCount(), 0);
-    }
-  }
-
-  void compareBatches(const VectorPtr& a, const VectorPtr& b) const {
-    ASSERT_EQ(a->size(), b->size());
-    for (int32_t i = 0; i < a->size(); ++i) {
-      ASSERT_TRUE(a->equalValueAt(b.get(), i, i)) << "Mismatch at " << i;
-    }
-  }
-
-  std::unique_ptr<Writer> writer_;
-  MemorySink* sink_;
-  size_t batchSize_{100};
-  size_t batchCount_{10};
-  size_t flushInterval_{3};
-  std::vector<VectorPtr> batches_;
-};
-
-} // namespace facebook::velox::dwrf
-
-TEST_F(E2EEncryptionTest, EncryptRoot) {
-  auto spec =
-      std::make_shared<EncryptionSpecification>(EncryptionProvider::Unknown);
-  spec->withRootEncryptionProperties(
-      std::make_shared<TestEncryptionProperties>("key"));
-  auto reader =
-      writeAndRead("struct<a:int,b:float,c:string,d:int,e:string>", spec);
-
-  // make sure footer has right set of properties set
-  auto& handler = getDecryptionHandler(*reader);
-  ASSERT_TRUE(handler.isEncrypted());
-  ASSERT_EQ(handler.getEncryptionGroupCount(), 1);
-  ASSERT_EQ(handler.getEncryptionRoot(0), 0);
-
-  // make sure footer doesn't have detailed stats
-  auto& footer = reader->getFooter();
-  auto& unencryptedStats = footer.statistics();
-  auto encryptedStats = reader->getStatistics();
-  ASSERT_EQ(unencryptedStats.size(), encryptedStats->getNumberOfColumns());
-  for (size_t i = 0; i < unencryptedStats.size(); ++i) {
-    auto& stats = unencryptedStats.Get(i);
-    ASSERT_TRUE(stats.has_hasnull());
-    ASSERT_TRUE(stats.has_numberofvalues());
-    ASSERT_FALSE(
-        stats.has_intstatistics() || stats.has_doublestatistics() ||
-        stats.has_stringstatistics());
-    auto& encrypted = encryptedStats->getColumnStatistics(i);
-    ASSERT_EQ(stats.hasnull(), encrypted.hasNull().value());
-    ASSERT_EQ(stats.numberofvalues(), encrypted.getNumberOfValues());
-    // stats got thru api should not be the basic one
-    ASSERT_EQ(typeid(encrypted) == typeid(const ColumnStatistics&), i == 0);
-  }
-
-  RowReaderOptions rowReaderOpts;
-  auto rowReader = reader->createRowReader(rowReaderOpts);
-
-  // make sure stripe footer doesn't have any stream/encoding
-  auto dwrfRowReader = dynamic_cast<DwrfRowReader*>(rowReader.get());
-  bool preload = true;
-  for (int32_t i = 0; i < reader->getNumberOfStripes(); ++i) {
-    dwrfRowReader->loadStripe(0, preload);
-    auto& sf = dwrfRowReader->getStripeFooter();
-    ASSERT_EQ(sf.encoding_size(), 0);
-    ASSERT_EQ(sf.streams_size(), 0);
-    ASSERT_EQ(sf.encryptiongroups_size(), 1);
-  }
-
-  validateFileContent(*reader);
-}
-
-TEST_F(E2EEncryptionTest, EncryptSelectedFields) {
-  auto spec =
-      std::make_shared<EncryptionSpecification>(EncryptionProvider::Unknown);
-  spec->withEncryptedField(
-          FieldEncryptionSpecification{}.withIndex(1).withEncryptionProperties(
-              std::make_shared<TestEncryptionProperties>("key1")))
-      .withEncryptedField(
-          FieldEncryptionSpecification{}.withIndex(2).withEncryptionProperties(
-              std::make_shared<TestEncryptionProperties>("key2")))
-      .withEncryptedField(
-          FieldEncryptionSpecification{}.withIndex(4).withEncryptionProperties(
-              std::make_shared<TestEncryptionProperties>("key2")));
-  std::string schema =
-      "struct<"
-      // not encrypted
-      "a:int,"
-      // encrypted primitive type. encryption group 0
-      "b:float,"
-      // encrypted complex type. encryption group 1
-      "c:map<int,string>,"
-      // not encrypted
-      "d:struct<a:int,b:string,c:float>,"
-      // encrypted complex type. encryption group 1
-      "e:array<struct<a:int,b:string>>>";
-  auto reader = writeAndRead(schema, spec);
-
-  // make sure footer has right set of properties set
-  auto& handler = getDecryptionHandler(*reader);
-  ASSERT_TRUE(handler.isEncrypted());
-  ASSERT_EQ(handler.getEncryptionGroupCount(), 2);
-
-  std::vector<std::vector<uint32_t>> eg{{2}, {3, 4, 5, 10, 11, 12, 13}};
-  std::unordered_set<uint32_t> encryptedNodes;
-  for (size_t i = 0; i < eg.size(); ++i) {
-    for (auto& n : eg[i]) {
-      ASSERT_EQ(handler.getEncryptionGroupIndex(n), i);
-      encryptedNodes.insert(n);
-    }
-  }
-
-  // make sure footer doesn't have detailed stats
-  auto& footer = reader->getFooter();
-  auto& unencryptedStats = footer.statistics();
-  auto encryptedStats = reader->getStatistics();
-  ASSERT_EQ(unencryptedStats.size(), encryptedStats->getNumberOfColumns());
-  for (size_t i = 0; i < unencryptedStats.size(); ++i) {
-    auto& stats = unencryptedStats.Get(i);
-    ASSERT_TRUE(stats.has_hasnull());
-    ASSERT_TRUE(stats.has_numberofvalues());
-    // only unencrypted leaf node in the schema may have detailed stats
-    ASSERT_EQ(
-        stats.has_intstatistics() || stats.has_doublestatistics() ||
-            stats.has_stringstatistics(),
-        (i == 1 || i == 7 || i == 8 || i == 9));
-    auto& encrypted = encryptedStats->getColumnStatistics(i);
-    ASSERT_EQ(stats.hasnull(), encrypted.hasNull().value());
-    ASSERT_EQ(stats.numberofvalues(), encrypted.getNumberOfValues());
-    // stats got thru api should not be the basic one unless they are
-    // intermediate nodes
-    ASSERT_EQ(
-        typeid(encrypted) == typeid(const ColumnStatistics&),
-        (i == 0 || i == 3 || i == 6 || i == 10 || i == 11));
-  }
-
-  RowReaderOptions rowReaderOpts;
-  auto rowReader = reader->createRowReader(rowReaderOpts);
-
-  // make sure stripe footer doesn't have any stream/encoding
-  auto dwrfRowReader = dynamic_cast<DwrfRowReader*>(rowReader.get());
-  bool preload = true;
-  for (int32_t i = 0; i < reader->getNumberOfStripes(); ++i) {
-    dwrfRowReader->loadStripe(0, preload);
-    auto& sf = dwrfRowReader->getStripeFooter();
-    for (auto& enc : sf.encoding()) {
-      ASSERT_TRUE(encryptedNodes.find(enc.node()) == encryptedNodes.end());
-    }
-    for (auto& stream : sf.streams()) {
-      ASSERT_TRUE(encryptedNodes.find(stream.node()) == encryptedNodes.end());
-    }
-  }
-
-  validateFileContent(*reader);
-}
-
-TEST_F(E2EEncryptionTest, EncryptEmptyFile) {
-  auto spec =
-      std::make_shared<EncryptionSpecification>(EncryptionProvider::Unknown);
-  spec->withEncryptedField(
-      FieldEncryptionSpecification{}.withIndex(0).withEncryptionProperties(
-          std::make_shared<TestEncryptionProperties>("key1")));
-  std::string schema = "struct<a:int>";
-  batchCount_ = 0;
-  auto reader = writeAndRead(schema, spec);
-
-  // make sure footer has right set of properties set
-  auto& handler = getDecryptionHandler(*reader);
-  ASSERT_FALSE(handler.isEncrypted());
-}
-
-TEST_F(E2EEncryptionTest, ReadWithoutKey) {
-  auto spec =
-      std::make_shared<EncryptionSpecification>(EncryptionProvider::Unknown);
-  spec->withEncryptedField(
-      FieldEncryptionSpecification{}.withIndex(1).withEncryptionProperties(
-          std::make_shared<TestEncryptionProperties>("key1")));
-  std::string schema =
-      "struct<"
-      // not encrypted
-      "a:int,"
-      // encrypted
-      "b:float>";
-  HiveTypeParser parser;
-  auto type = std::dynamic_pointer_cast<const RowType>(parser.parse(schema));
-  auto reader = writeAndRead(schema, spec, nullptr);
-
-  // reading unencrypted column should not fail
-  {
-    RowReaderOptions rowReaderOpts;
-    rowReaderOpts.select(
-        std::make_shared<ColumnSelector>(type, std::vector<uint64_t>{0}));
-    auto rowReader = reader->createRowReader(rowReaderOpts);
-    VectorPtr batch;
-    ASSERT_TRUE(rowReader->next(1, batch));
-  }
-
-  // fail when reading encrypted column
-  {
-    RowReaderOptions rowReaderOpts;
-    rowReaderOpts.select(
-        std::make_shared<ColumnSelector>(type, std::vector<uint64_t>{1}));
-    ASSERT_THROW(
-        reader->createRowReader(rowReaderOpts), exception::LoggedException);
-  }
-}
-
-namespace {
-
-void testWriter(
-    MemoryPool& pool,
-    const std::shared_ptr<const Type>& type,
-    size_t batchCount,
-    std::function<VectorPtr()> generator,
-    const std::shared_ptr<dwrf::Config> config =
-        std::make_shared<dwrf::Config>()) {
-  std::vector<VectorPtr> batches;
-  for (auto i = 0; i < batchCount; ++i) {
-    batches.push_back(generator());
-  }
-  E2EWriterTestUtil::testWriter(pool, type, batches, 1, 1, config);
-};
-
-template <TypeKind K>
-VectorPtr createKeysImpl(
-    MemoryPool& pool,
-    std::mt19937& rng,
-    size_t size,
-    size_t maxVal) {
-  using TCpp = typename TypeTraits<K>::NativeType;
-
-  auto vector = std::make_shared<FlatVector<TCpp>>(
-      &pool,
-      CppToType<TCpp>::create(),
-      nullptr,
-      size,
-      AlignedBuffer::allocate<TCpp>(size, &pool),
-      std::vector<BufferPtr>{});
-
-  size_t value = 0;
-  for (size_t i = 0; i < vector->size(); ++i, value = ((value + 1) % maxVal)) {
-    if constexpr (std::is_same_v<TCpp, StringView>) {
-      auto strVal = folly::to<std::string>(value);
-      StringView sv{strVal};
-      DWIO_ENSURE(sv.isInline());
-      vector->set(i, sv);
-    } else {
-      vector->set(i, value);
-    }
-  }
-
-  if (folly::Random::oneIn(2, rng)) {
-    return vector;
-  }
-
-  // wrap in dictionary
-  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(size, &pool);
-  auto rawIndices = indices->asMutable<vector_size_t>();
-
-  for (size_t i = 0; i < size; ++i) {
-    rawIndices[i] = size - 1 - i;
-  }
-
-  return BaseVector::wrapInDictionary(nullptr, indices, size, vector);
-}
-
-VectorPtr createKeys(
-    const std::shared_ptr<const Type> type,
-    MemoryPool& pool,
-    std::mt19937& rng,
-    size_t size,
-    size_t maxVal) {
-  switch (type->kind()) {
-    case TypeKind::INTEGER:
-      return createKeysImpl<TypeKind::INTEGER>(pool, rng, size, maxVal);
-    case TypeKind::VARCHAR:
-      return createKeysImpl<TypeKind::VARCHAR>(pool, rng, size, maxVal);
-    default:
-      folly::assume_unreachable();
-  }
-}
-
-} // namespace
-
-TEST_F(E2EWriterTests, fuzzSimple) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  auto type = ROW({
-      {"bool_val", BOOLEAN()},
-      {"byte_val", TINYINT()},
-      {"short_val", SMALLINT()},
-      {"int_val", INTEGER()},
-      {"long_val", BIGINT()},
-      {"float_val", REAL()},
-      {"double_val", DOUBLE()},
-      {"string_val", VARCHAR()},
-      {"binary_val", VARBINARY()},
-      {"ts_val", TIMESTAMP()},
-  });
-  auto seed = folly::Random::rand32();
-  LOG(INFO) << "seed: " << seed;
-
-  // Small batches creates more edge cases.
-  size_t batchSize = 10;
-  VectorFuzzer noNulls(
-      {
-          .vectorSize = batchSize,
-          .nullRatio = 0,
-          .stringLength = 20,
-          .stringVariableLength = true,
-      },
-      pool.get(),
-      seed);
-
-  VectorFuzzer hasNulls{
-      {
-          .vectorSize = batchSize,
-          .nullRatio = 0.05,
-          .stringLength = 10,
-          .stringVariableLength = true,
-      },
-      pool.get(),
-      seed};
-
-  auto iterations = 20;
-  auto batches = 20;
-  for (auto i = 0; i < iterations; ++i) {
-    testWriter(
-        *pool, type, batches, [&]() { return noNulls.fuzzInputRow(type); });
-    testWriter(
-        *pool, type, batches, [&]() { return hasNulls.fuzzInputRow(type); });
-  }
-}
-
-TEST_F(E2EWriterTests, fuzzComplex) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  auto type = ROW({
-      {"array", ARRAY(REAL())},
-      {"map", MAP(INTEGER(), DOUBLE())},
-      {"row",
-       ROW({
-           {"a", REAL()},
-           {"b", INTEGER()},
-       })},
-      {"nested",
-       ARRAY(ROW({
-           {"a", INTEGER()},
-           {"b", MAP(REAL(), REAL())},
-       }))},
-  });
-  auto seed = folly::Random::rand32();
-  LOG(INFO) << "seed: " << seed;
-
-  // Small batches creates more edge cases.
-  size_t batchSize = 10;
-  VectorFuzzer noNulls(
-      {
-          .vectorSize = batchSize,
-          .nullRatio = 0,
-          .stringLength = 20,
-          .stringVariableLength = true,
-          .containerLength = 5,
-          .containerVariableLength = true,
-      },
-      pool.get(),
-      seed);
-
-  VectorFuzzer hasNulls{
-      {
-          .vectorSize = batchSize,
-          .nullRatio = 0.05,
-          .stringLength = 10,
-          .stringVariableLength = true,
-          .containerLength = 5,
-          .containerVariableLength = true,
-      },
-      pool.get(),
-      seed};
-
-  auto iterations = 20;
-  auto batches = 20;
-  for (auto i = 0; i < iterations; ++i) {
-    testWriter(
-        *pool, type, batches, [&]() { return noNulls.fuzzInputRow(type); });
-    testWriter(
-        *pool, type, batches, [&]() { return hasNulls.fuzzInputRow(type); });
-  }
-}
-
-TEST_F(E2EWriterTests, fuzzFlatmap) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  auto type = ROW({
-      {"flatmap1", MAP(INTEGER(), REAL())},
-      {"flatmap2", MAP(VARCHAR(), ARRAY(REAL()))},
-      {"flatmap3", MAP(INTEGER(), MAP(INTEGER(), REAL()))},
-  });
-  auto config = std::make_shared<dwrf::Config>();
-  config->set(dwrf::Config::FLATTEN_MAP, true);
-  config->set(dwrf::Config::MAP_FLAT_COLS, {0, 1, 2});
-  auto seed = folly::Random::rand32();
-  LOG(INFO) << "seed: " << seed;
-  std::mt19937 rng{seed};
-
-  // Small batches creates more edge cases.
-  size_t batchSize = 10;
-  VectorFuzzer fuzzer(
-      {
-          .vectorSize = batchSize,
-          .nullRatio = 0,
-          .stringLength = 20,
-          .stringVariableLength = true,
-          .containerLength = 5,
-          .containerVariableLength = true,
-      },
-      pool.get(),
-      seed);
-
-  auto genMap = [&](auto type, auto size) {
-    auto offsets = allocateOffsets(size, pool.get());
-    auto rawOffsets = offsets->template asMutable<vector_size_t>();
-    auto sizes = allocateSizes(size, pool.get());
-    auto rawSizes = sizes->template asMutable<vector_size_t>();
-    vector_size_t childSize = 0;
-    // flatmap doesn't like empty map
-    for (auto i = 0; i < batchSize; ++i) {
-      rawOffsets[i] = childSize;
-      auto length = folly::Random::rand32(1, 5, rng);
-      rawSizes[i] = length;
-      childSize += length;
-    }
-
-    VectorFuzzer valueFuzzer(
-        {
-            .vectorSize = static_cast<size_t>(childSize),
-            .nullRatio = 0,
-            .stringLength = 20,
-            .stringVariableLength = true,
-            .containerLength = 5,
-            .containerVariableLength = true,
-        },
-        pool.get(),
-        seed);
-
-    auto& mapType = type->asMap();
-    VectorPtr vector = std::make_shared<MapVector>(
-        pool.get(),
-        type,
-        nullptr,
-        size,
-        offsets,
-        sizes,
-        createKeys(mapType.keyType(), *pool, rng, childSize, 10),
-        valueFuzzer.fuzz(mapType.valueType()));
-
-    if (folly::Random::oneIn(2, rng)) {
-      vector = fuzzer.fuzzDictionary(vector);
-    }
-    return vector;
-  };
-
-  auto gen = [&]() {
-    std::vector<VectorPtr> children;
-    for (auto i = 0; i < type->size(); ++i) {
-      children.push_back(genMap(type->childAt(i), batchSize));
-    }
-
-    return std::make_shared<RowVector>(
-        pool.get(), type, nullptr, batchSize, std::move(children));
-  };
-
-  auto iterations = 20;
-  auto batches = 20;
-  for (auto i = 0; i < iterations; ++i) {
-    testWriter(*pool, type, batches, gen, config);
-  }
-}
diff --git a/velox/dwio/dwrf/test/FloatColumnWriterBenchmark.cpp b/velox/dwio/dwrf/test/FloatColumnWriterBenchmark.cpp
index 3a73c4986291c..30f70a2bc529a 100644
--- a/velox/dwio/dwrf/test/FloatColumnWriterBenchmark.cpp
+++ b/velox/dwio/dwrf/test/FloatColumnWriterBenchmark.cpp
@@ -42,7 +42,7 @@ void runBenchmark(int nullEvery) {
 
   auto type = CppToType<float>::create();
   auto typeWithId = TypeWithId::create(type, 1);
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   VectorPtr vector;
   // Prepare input
   BufferPtr values = AlignedBuffer::allocate<float>(kVectorSize, pool.get());
@@ -78,8 +78,7 @@ void runBenchmark(int nullEvery) {
     auto config = std::make_shared<dwrf::Config>();
     WriterContext context{
         config,
-        memory::defaultMemoryManager().addRootPool(
-            "FloatColumnWriterBenchmark")};
+        memory::memoryManager()->addRootPool("FloatColumnWriterBenchmark")};
     auto writer = BaseColumnWriter::create(context, *typeWithId, 0);
     writer->write(vector, common::Ranges::of(0, kVectorSize));
   }
@@ -130,7 +129,8 @@ BENCHMARK(FloatColumnWriterBenchmark10000) {
 }
 
 int32_t main(int32_t argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/dwio/dwrf/test/FlushPolicyTest.cpp b/velox/dwio/dwrf/test/FlushPolicyTest.cpp
index 8c7bc9a1fa6b4..e571477cf9473 100644
--- a/velox/dwio/dwrf/test/FlushPolicyTest.cpp
+++ b/velox/dwio/dwrf/test/FlushPolicyTest.cpp
@@ -25,7 +25,14 @@ using namespace facebook::velox::memory;
 
 namespace facebook::velox::dwrf {
 
-TEST(DefaultFlushPolicyTest, StripeProgressTest) {
+class DefaultFlushPolicyTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(DefaultFlushPolicyTest, StripeProgressTest) {
   struct TestCase {
     const uint64_t stripeSizeThreshold;
     const int64_t stripeSize;
@@ -41,7 +48,7 @@ TEST(DefaultFlushPolicyTest, StripeProgressTest) {
           .stripeSizeThreshold = 200, .stripeSize = 400, .shouldFlush = true}};
   for (const auto& testCase : testCases) {
     DefaultFlushPolicy policy{
-        testCase.stripeSizeThreshold, /* dictionarySizeThreshold */ 0};
+        testCase.stripeSizeThreshold, /*dictionarySizeThreshold=*/0};
     EXPECT_EQ(
         testCase.shouldFlush,
         policy.shouldFlush(dwio::common::StripeProgress{
@@ -49,9 +56,9 @@ TEST(DefaultFlushPolicyTest, StripeProgressTest) {
   }
 }
 
-TEST(DefaultFlushPolicyTest, AdditionalCriteriaTest) {
+TEST_F(DefaultFlushPolicyTest, AdditionalCriteriaTest) {
   struct TestCase {
-    const bool stripeProgressDecision;
+    const bool flushStripe;
     const bool overMemoryBudget;
     const uint64_t dictionarySizeThreshold;
     const uint64_t dictionarySize;
@@ -60,66 +67,176 @@ TEST(DefaultFlushPolicyTest, AdditionalCriteriaTest) {
 
   std::vector<TestCase> testCases{
       TestCase{
-          .stripeProgressDecision = false,
+          .flushStripe = false,
           .overMemoryBudget = false,
           .dictionarySizeThreshold = 20,
           .dictionarySize = 15,
           .decision = FlushDecision::SKIP},
       TestCase{
-          .stripeProgressDecision = false,
+          .flushStripe = false,
           .overMemoryBudget = true,
           .dictionarySizeThreshold = 20,
           .dictionarySize = 15,
           .decision = FlushDecision::SKIP},
       TestCase{
-          .stripeProgressDecision = true,
+          .flushStripe = true,
           .overMemoryBudget = false,
           .dictionarySizeThreshold = 20,
           .dictionarySize = 15,
           .decision = FlushDecision::SKIP},
       TestCase{
-          .stripeProgressDecision = true,
+          .flushStripe = true,
           .overMemoryBudget = true,
           .dictionarySizeThreshold = 20,
           .dictionarySize = 15,
           .decision = FlushDecision::SKIP},
       TestCase{
-          .stripeProgressDecision = false,
+          .flushStripe = false,
           .overMemoryBudget = false,
           .dictionarySizeThreshold = 20,
           .dictionarySize = 42,
           .decision = FlushDecision::FLUSH_DICTIONARY},
       TestCase{
-          .stripeProgressDecision = false,
+          .flushStripe = false,
           .overMemoryBudget = true,
           .dictionarySizeThreshold = 20,
           .dictionarySize = 42,
           .decision = FlushDecision::FLUSH_DICTIONARY},
       TestCase{
-          .stripeProgressDecision = true,
+          .flushStripe = true,
           .overMemoryBudget = false,
           .dictionarySizeThreshold = 20,
           .dictionarySize = 42,
-          .decision = FlushDecision::FLUSH_DICTIONARY},
+          .decision = FlushDecision::SKIP},
       TestCase{
-          .stripeProgressDecision = true,
+          .flushStripe = true,
           .overMemoryBudget = true,
           .dictionarySizeThreshold = 20,
           .dictionarySize = 42,
-          .decision = FlushDecision::FLUSH_DICTIONARY}};
+          .decision = FlushDecision::SKIP}};
   for (const auto& testCase : testCases) {
     DefaultFlushPolicy policy{
-        /* stripeSizeThreshold */ 0, testCase.dictionarySizeThreshold};
+        /*stripeSizeThreshold=*/1000, testCase.dictionarySizeThreshold};
     EXPECT_EQ(
         testCase.decision,
         policy.shouldFlushDictionary(
-            testCase.stripeProgressDecision,
+            testCase.flushStripe,
             testCase.overMemoryBudget,
-            testCase.dictionarySize));
+            // StripeProgress is not used in this test.
+            dwio::common::StripeProgress{},
+            testCase.dictionarySize))
+        << fmt::format(
+               "flushStripe = {}, overMemoryBudget = {}, dictionarySize = {}",
+               testCase.flushStripe,
+               testCase.overMemoryBudget,
+               testCase.dictionarySize);
   }
 }
 
-TEST(RowsPerStripeFlushPolicyTest, EmptyFile) {
+TEST_F(DefaultFlushPolicyTest, EarlyDictionaryEvaluation) {
+  // Test the precedence of decisions.
+  struct TestCase {
+    dwio::common::StripeProgress stripeProgress;
+    const uint64_t stripeSizeThreshold;
+    const bool flushStripe;
+    const uint64_t dictionarySizeThreshold;
+    const uint64_t dictionarySize;
+    const FlushDecision decision;
+  };
+
+  std::vector<TestCase> testCases{
+      TestCase{
+          .stripeProgress =
+              dwio::common::StripeProgress{.stripeSizeEstimate = 100},
+          .stripeSizeThreshold = 200,
+          .flushStripe = false,
+          .dictionarySizeThreshold = 20,
+          .dictionarySize = 15,
+          .decision = FlushDecision::EVALUATE_DICTIONARY},
+      TestCase{
+          .stripeProgress =
+              dwio::common::StripeProgress{.stripeSizeEstimate = 100},
+          .stripeSizeThreshold = 200,
+          .flushStripe = false,
+          .dictionarySizeThreshold = 20,
+          .dictionarySize = 42,
+          .decision = FlushDecision::FLUSH_DICTIONARY},
+      TestCase{
+          .stripeProgress =
+              dwio::common::StripeProgress{.stripeSizeEstimate = 100},
+          .stripeSizeThreshold = 200,
+          .flushStripe = true,
+          .dictionarySizeThreshold = 20,
+          .dictionarySize = 42,
+          .decision = FlushDecision::SKIP}};
+  for (const auto& testCase : testCases) {
+    DefaultFlushPolicy policy{
+        testCase.stripeSizeThreshold, testCase.dictionarySizeThreshold};
+    EXPECT_EQ(
+        testCase.decision,
+        policy.shouldFlushDictionary(
+            testCase.flushStripe,
+            /*overMemoryBudget=*/false,
+            testCase.stripeProgress,
+            testCase.dictionarySize))
+        << fmt::format(
+               "flushStripe = {}, stripeSizeThreshold = {}, estimatedStripeSize = {}, dictionarySizeThreshold = {}, dictionarySize = {}",
+               testCase.flushStripe,
+               testCase.stripeSizeThreshold,
+               testCase.stripeProgress.stripeSizeEstimate,
+               testCase.dictionarySizeThreshold,
+               testCase.dictionarySize);
+  }
+
+  // Test dictionary evaluation signals throughout the stripe.
+  DefaultFlushPolicy policy{
+      /*stripeSizeThreshold=*/1000,
+      /*dictionarySizeThreshold=*/std::numeric_limits<uint64_t>::max()};
+  EXPECT_EQ(
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/false,
+          /*overMemoryBudget=*/false,
+          dwio::common::StripeProgress{.stripeSizeEstimate = 100},
+          /*dictionarySize=*/20),
+      FlushDecision::SKIP);
+  EXPECT_EQ(
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/false,
+          /*overMemoryBudget=*/false,
+          dwio::common::StripeProgress{.stripeSizeEstimate = 200},
+          /*dictionarySize=*/20),
+      FlushDecision::SKIP);
+  EXPECT_EQ(
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/false,
+          /*overMemoryBudget=*/false,
+          dwio::common::StripeProgress{.stripeSizeEstimate = 400},
+          /*dictionarySize=*/20),
+      FlushDecision::EVALUATE_DICTIONARY);
+  EXPECT_EQ(
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/false,
+          /*overMemoryBudget=*/false,
+          dwio::common::StripeProgress{.stripeSizeEstimate = 500},
+          /*dictionarySize=*/20),
+      FlushDecision::SKIP);
+  EXPECT_EQ(
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/false,
+          /*overMemoryBudget=*/false,
+          dwio::common::StripeProgress{.stripeSizeEstimate = 700},
+          /*dictionarySize=*/20),
+      FlushDecision::EVALUATE_DICTIONARY);
+  EXPECT_EQ(
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/false,
+          /*overMemoryBudget=*/false,
+          dwio::common::StripeProgress{.stripeSizeEstimate = 900},
+          /*dictionarySize=*/20),
+      FlushDecision::SKIP);
+}
+
+TEST_F(DefaultFlushPolicyTest, EmptyFile) {
   // Empty vector creation succeeds.
   RowsPerStripeFlushPolicy policy({});
 
@@ -128,7 +245,7 @@ TEST(RowsPerStripeFlushPolicyTest, EmptyFile) {
       exception::LoggedException);
 }
 
-TEST(RowsPerStripeFlushPolicyTest, InvalidCases) {
+TEST_F(DefaultFlushPolicyTest, InvalidCases) {
   // Vector with 0 rows, throws
   ASSERT_THROW(
       RowsPerStripeFlushPolicy policy({5, 7, 0, 10}),
@@ -136,23 +253,47 @@ TEST(RowsPerStripeFlushPolicyTest, InvalidCases) {
 }
 
 // RowsPerStripeFlushPolicy has no dictionary flush criteria.
-TEST(RowsPerSTripeFlushPolicyTest, DictionaryCriteriaTest) {
+TEST_F(DefaultFlushPolicyTest, DictionaryCriteriaTest) {
   auto config = std::make_shared<Config>();
   WriterContext context{
-      config, defaultMemoryManager().addRootPool("DictionaryCriteriaTest")};
+      config, memory::memoryManager()->addRootPool("DictionaryCriteriaTest")};
 
   RowsPerStripeFlushPolicy policy({42});
   EXPECT_EQ(
-      FlushDecision::SKIP, policy.shouldFlushDictionary(false, false, context));
+      FlushDecision::SKIP,
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/false,
+          /*overMemoryBudget=*/false,
+          // StripeProgress is not used in this test.
+          dwio::common::StripeProgress{},
+          context));
   EXPECT_EQ(
-      FlushDecision::SKIP, policy.shouldFlushDictionary(false, true, context));
+      FlushDecision::SKIP,
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/false,
+          /*overMemoryBudget=*/true,
+          // StripeProgress is not used in this test.
+          dwio::common::StripeProgress{},
+          context));
   EXPECT_EQ(
-      FlushDecision::SKIP, policy.shouldFlushDictionary(true, false, context));
+      FlushDecision::SKIP,
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/true,
+          /*overMemoryBudget=*/false,
+          // StripeProgress is not used in this test.
+          dwio::common::StripeProgress{},
+          context));
   EXPECT_EQ(
-      FlushDecision::SKIP, policy.shouldFlushDictionary(true, true, context));
+      FlushDecision::SKIP,
+      policy.shouldFlushDictionary(
+          /*flushStripe=*/true,
+          /*overMemoryBudget=*/true,
+          // StripeProgress is not used in this test.
+          dwio::common::StripeProgress{},
+          context));
 }
 
-TEST(RowsPerStripeFlushPolicyTest, FlushTest) {
+TEST_F(DefaultFlushPolicyTest, FlushTest) {
   RowsPerStripeFlushPolicy policy({5, 7, 12});
 
   ASSERT_FALSE(policy.shouldFlush(
diff --git a/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp b/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
index f09939325fad1..5de1d7d5daed4 100644
--- a/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
+++ b/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
@@ -30,7 +30,7 @@ using namespace facebook::velox::memory;
 
 static size_t generateAutoId(int64_t startId, int64_t count) {
   size_t capacity = count * folly::kMaxVarintLength64;
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   DataBufferHolder holder{*pool, capacity};
   auto output = std::make_unique<BufferedOutputStream>(holder);
   auto encoder =
@@ -44,7 +44,7 @@ static size_t generateAutoId(int64_t startId, int64_t count) {
 
 static size_t generateAutoId2(int64_t startId, int64_t count) {
   size_t capacity = count * folly::kMaxVarintLength64;
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   DataBufferHolder holder{*pool, capacity};
   auto output = std::make_unique<BufferedOutputStream>(holder);
   auto encoder =
@@ -204,7 +204,8 @@ BENCHMARK_RELATIVE(GenerateAutoIdNew_64) {
 }
 
 int32_t main(int32_t argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/dwio/dwrf/test/LayoutPlannerTests.cpp b/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
index 9ac3ce5b2a55f..74dc4b4e5516a 100644
--- a/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
+++ b/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
@@ -35,9 +35,16 @@ void testCreateNodeToColumnIdMapping(
   auto typeWithId = dwio::common::TypeWithId::create(type);
   EXPECT_EQ(expected, TestLayoutPlanner{*typeWithId}.getNodeToColumnMap());
 }
+
+class LayoutPlannerTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 } // namespace
 
-TEST(LayoutPlannerTests, CreateNodeToColumnIdMapping) {
+TEST_F(LayoutPlannerTest, CreateNodeToColumnIdMapping) {
   testCreateNodeToColumnIdMapping(ROW({BOOLEAN()}), {{0, 0}, {1, 0}});
   testCreateNodeToColumnIdMapping(
       ROW(
@@ -89,13 +96,13 @@ TEST(LayoutPlannerTests, CreateNodeToColumnIdMapping) {
        {17, 5}});
 }
 
-TEST(LayoutPlannerTests, Basic) {
+TEST_F(LayoutPlannerTest, Basic) {
   auto config = std::make_shared<Config>();
   config->set(
       Config::COMPRESSION, common::CompressionKind::CompressionKind_NONE);
   WriterContext context{
       config,
-      facebook::velox::memory::defaultMemoryManager().addRootPool(
+      facebook::velox::memory::memoryManager()->addRootPool(
           "LayoutPlannerTests")};
   // fake streams
   std::vector<DwrfStreamIdentifier> streams;
diff --git a/velox/dwio/dwrf/test/OrcTest.h b/velox/dwio/dwrf/test/OrcTest.h
index e420f1926a010..942ad269242af 100644
--- a/velox/dwio/dwrf/test/OrcTest.h
+++ b/velox/dwio/dwrf/test/OrcTest.h
@@ -37,9 +37,16 @@ inline std::string getExampleFilePath(const std::string& fileName) {
       "velox/dwio/dwrf/test", "examples/" + fileName);
 }
 
+std::unique_ptr<dwio::common::BufferedInput> createFileBufferedInput(
+    const std::string& path,
+    memory::MemoryPool& pool) {
+  return std::make_unique<dwio::common::BufferedInput>(
+      std::make_shared<LocalReadFile>(path), pool);
+}
+
 class MockStripeStreams : public StripeStreams {
  public:
-  MockStripeStreams() : pool_{memory::addDefaultLeafMemoryPool()} {};
+  MockStripeStreams() : pool_{memory::memoryManager()->addLeafPool()} {};
   ~MockStripeStreams() = default;
 
   std::unique_ptr<dwio::common::SeekableInputStream> getStream(
@@ -101,7 +108,7 @@ class MockStripeStreams : public StripeStreams {
     return *getColumnSelectorProxy();
   }
 
-  const dwio::common::RowReaderOptions& getRowReaderOptions() const override {
+  const dwio::common::RowReaderOptions& rowReaderOptions() const override {
     auto ptr = getRowReaderOptionsProxy();
     return ptr ? *ptr : options_;
   }
diff --git a/velox/dwio/dwrf/test/RatioTrackerTest.cpp b/velox/dwio/dwrf/test/RatioTrackerTest.cpp
index 912da20c5f23f..4f4bddf0662f8 100644
--- a/velox/dwio/dwrf/test/RatioTrackerTest.cpp
+++ b/velox/dwio/dwrf/test/RatioTrackerTest.cpp
@@ -53,7 +53,7 @@ TEST(RatioTrackerTest, BasicTests) {
           {{10, 11}, {20, 1}, {30, 1}, {40, 1}, {50, 1}},
           0.1f},
       TestCase{std::make_shared<CompressionRatioTracker>(), {}, 0.3f},
-      TestCase{std::make_shared<FlushOverheadRatioTracker>(), {}, 1.0f},
+      TestCase{std::make_shared<FlushOverheadRatioTracker>(), {}, 0.1f},
       TestCase{std::make_shared<AverageRowSizeTracker>(), {}, 0.0f},
   };
 
diff --git a/velox/dwio/dwrf/test/ReaderBaseTests.cpp b/velox/dwio/dwrf/test/ReaderBaseTests.cpp
index ac15fda052d45..17bb111780a6c 100644
--- a/velox/dwio/dwrf/test/ReaderBaseTests.cpp
+++ b/velox/dwio/dwrf/test/ReaderBaseTests.cpp
@@ -16,6 +16,7 @@
 
 #include <gtest/gtest.h>
 #include <cstring>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/InputStream.h"
 #include "velox/dwio/common/encryption/TestProvider.h"
 #include "velox/dwio/common/exception/Exception.h"
@@ -48,8 +49,12 @@ void addStats(
 
 class EncryptedStatsTest : public Test {
  protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = defaultMemoryManager().addRootPool("EncryptedStatsTest");
+    pool_ = memoryManager()->addRootPool("EncryptedStatsTest");
     sinkPool_ = pool_->addLeafChild("sink");
     ProtoWriter writer{pool_, *sinkPool_};
     auto& context = const_cast<const ProtoWriter&>(writer).getContext();
@@ -122,8 +127,8 @@ class EncryptedStatsTest : public Test {
   std::shared_ptr<MemoryPool> readerPool_;
 };
 
-TEST_F(EncryptedStatsTest, getStatistics) {
-  auto stats = reader_->getStatistics();
+TEST_F(EncryptedStatsTest, statistics) {
+  auto stats = reader_->statistics();
   for (size_t i = 1; i < 7; ++i) {
     auto& stat = stats->getColumnStatistics(i);
     if (i != 5) {
@@ -136,7 +141,7 @@ TEST_F(EncryptedStatsTest, getStatistics) {
 
 TEST_F(EncryptedStatsTest, getStatisticsKeyNotLoaded) {
   clearKey(0);
-  auto stats = reader_->getStatistics();
+  auto stats = reader_->statistics();
   for (size_t i = 2; i < 7; ++i) {
     auto& stat = stats->getColumnStatistics(i);
     if (i != 5) {
@@ -149,7 +154,7 @@ TEST_F(EncryptedStatsTest, getStatisticsKeyNotLoaded) {
 
 TEST_F(EncryptedStatsTest, getColumnStatistics) {
   for (size_t i = 1; i < 7; ++i) {
-    auto stats = reader_->getColumnStatistics(i);
+    auto stats = reader_->columnStatistics(i);
     if (i != 5) {
       ASSERT_EQ(stats->getNumberOfValues(), i * 100);
     } else {
@@ -161,7 +166,7 @@ TEST_F(EncryptedStatsTest, getColumnStatistics) {
 TEST_F(EncryptedStatsTest, getColumnStatisticsKeyNotLoaded) {
   clearKey(0);
   for (size_t i = 2; i < 7; ++i) {
-    auto stats = reader_->getColumnStatistics(i);
+    auto stats = reader_->columnStatistics(i);
     if (i != 5) {
       ASSERT_EQ(stats->getNumberOfValues(), i * 100);
     } else {
@@ -173,7 +178,7 @@ TEST_F(EncryptedStatsTest, getColumnStatisticsKeyNotLoaded) {
 std::unique_ptr<ReaderBase> createCorruptedFileReader(
     uint64_t footerLen,
     uint32_t cacheLen) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
   MemorySink sink{1024, {.pool = pool.get()}};
   DataBufferHolder holder{*pool, 1024, 0, DEFAULT_PAGE_GROW_RATIO, &sink};
   BufferedOutputStream output{holder};
@@ -206,14 +211,23 @@ std::unique_ptr<ReaderBase> createCorruptedFileReader(
 
   sink.write(std::move(buf));
   auto readFile = std::make_shared<facebook::velox::InMemoryReadFile>(
-      std::string_view(sink.data(), sink.size()));
+      std::string(sink.data(), sink.size()));
   return std::make_unique<ReaderBase>(
       *pool, std::make_unique<BufferedInput>(readFile, *pool));
 }
 
-TEST(ReaderBaseTest, InvalidPostScriptThrows) {
-  EXPECT_THROW(
-      { createCorruptedFileReader(1'000'000, 0); }, exception::LoggedException);
-  EXPECT_THROW(
-      { createCorruptedFileReader(0, 1'000'000); }, exception::LoggedException);
+class ReaderBaseTest : public Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(ReaderBaseTest, InvalidPostScriptThrows) {
+  VELOX_ASSERT_THROW(
+      createCorruptedFileReader(1'000'000, 0),
+      "Corrupted file, footer size is invalid");
+  VELOX_ASSERT_THROW(
+      createCorruptedFileReader(0, 1'000'000),
+      "Corrupted file, cache size is invalid");
 }
diff --git a/velox/dwio/dwrf/test/ReaderTest.cpp b/velox/dwio/dwrf/test/ReaderTest.cpp
index 4b7bf877a2460..daeb070d1c7c6 100644
--- a/velox/dwio/dwrf/test/ReaderTest.cpp
+++ b/velox/dwio/dwrf/test/ReaderTest.cpp
@@ -16,21 +16,21 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-#include <velox/buffer/Buffer.h>
 #include "folly/Random.h"
+#include "folly/executors/CPUThreadPoolExecutor.h"
 #include "folly/lang/Assume.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/ExecutorBarrier.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
 #include "velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h"
-#include "velox/type/Type.h"
 #include "velox/type/fbhive/HiveTypeParser.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/FlatVector.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <fmt/core.h>
 #include <array>
@@ -61,26 +61,64 @@ const std::string& getFMLargeFile() {
   return fmLargeFile_;
 }
 
-const std::shared_ptr<facebook::velox::memory::MemoryPool>& getDefaultPool() {
-  static const auto pool_ = memory::addDefaultLeafMemoryPool();
-  return pool_;
-}
-
 // RowType for fmSmallFile and fmLargeFile
 const std::shared_ptr<const RowType>& getFlatmapSchema() {
   static const std::shared_ptr<const RowType> schema_ =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse("struct<\
-          id:int,\
-      map1:map<int, array<float>>,\
-      map2:map<string, map<smallint,bigint>>,\
-      map3:map<int,int>,\
-      map4:map<int,struct<field1:int,field2:float,field3:string>>,\
-      memo:string>"));
+         id:int,\
+     map1:map<int, array<float>>,\
+     map2:map<string, map<smallint,bigint>>,\
+     map3:map<int,int>,\
+     map4:map<int,struct<field1:int,field2:float,field3:string>>,\
+     memo:string>"));
   return schema_;
 }
+
+class TestReaderP
+    : public testing::TestWithParam</* parallel decoding = */ bool>,
+      public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  folly::Executor* executor() {
+    if (GetParam() && !executor_) {
+      std::make_shared<folly::CPUThreadPoolExecutor>(
+          getDecodingParallelismFactor());
+    }
+    return executor_.get();
+  }
+
+  size_t getDecodingParallelismFactor() {
+    return GetParam() ? 2 : 0;
+  }
+
+ private:
+  std::unique_ptr<folly::Executor> executor_;
+};
+
+class TestReader : public testing::Test, public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::vector<VectorPtr> createBatches(
+      const std::vector<std::vector<int32_t>>& values) {
+    std::vector<VectorPtr> batches;
+    for (const auto& value : values) {
+      auto vector = makeFlatVector<int32_t>(value);
+      auto rowVector = makeRowVector({vector});
+      batches.push_back(rowVector);
+    }
+    return batches;
+  }
+};
+
 } // namespace
 
-TEST(TestReader, testWriterVersions) {
+TEST_F(TestReader, testWriterVersions) {
   EXPECT_EQ("original", writerVersionToString(ORIGINAL));
   EXPECT_EQ("dwrf-4.9", writerVersionToString(DWRF_4_9));
   EXPECT_EQ("dwrf-5.0", writerVersionToString(DWRF_5_0));
@@ -89,13 +127,6 @@ TEST(TestReader, testWriterVersions) {
       "future - 99", writerVersionToString(static_cast<WriterVersion>(99)));
 }
 
-std::unique_ptr<BufferedInput> createFileBufferedInput(
-    const std::string& path,
-    memory::MemoryPool& pool) {
-  return std::make_unique<BufferedInput>(
-      std::make_shared<LocalReadFile>(path), pool);
-}
-
 // This relies on schema and data inside of our fm_small and fm_large orc files,
 // and is not composeable with other schema/datas
 void verifyFlatMapReading(
@@ -191,40 +222,6 @@ void verifyFlatMapReading(
   EXPECT_EQ(batchId, numBatches);
 }
 
-void verifyPrefetch(
-    DwrfRowReader* rowReader,
-    const std::vector<uint32_t>& expectedPrefetchRowSizes = {},
-    const std::vector<bool>& shouldTryPrefetch = {}) {
-  auto prefetchUnitsOpt = rowReader->prefetchUnits();
-  ASSERT_TRUE(prefetchUnitsOpt.has_value());
-  auto prefetchUnits = std::move(prefetchUnitsOpt.value());
-  auto numFetches = prefetchUnits.size();
-  auto expectedResultsSize = shouldTryPrefetch.size();
-  auto expectedRowsSize = expectedPrefetchRowSizes.size();
-  bool shouldCheckResults = expectedResultsSize != 0;
-  bool shouldCheckRowCount = expectedRowsSize != 0;
-
-  // Empty vector will skip the check, but they should never been different than
-  // actual expected prefetchUnits vector
-  DWIO_ENSURE(expectedResultsSize == numFetches || !shouldCheckResults);
-  DWIO_ENSURE(expectedRowsSize == numFetches || !shouldCheckRowCount);
-
-  for (int i = 0; i < numFetches; i++) {
-    if (shouldCheckRowCount) {
-      EXPECT_EQ(prefetchUnits[i].rowCount, expectedPrefetchRowSizes[i]);
-    }
-    if (shouldCheckResults && shouldTryPrefetch[i]) {
-      RowReader::FetchResult result = prefetchUnits[i].prefetch();
-      EXPECT_EQ(
-          result,
-          // A prefetch request for the first stripe should be already fetched,
-          // because createDwrfRowReader calls startNextStripe() synchronously.
-          i == 0 ? RowReader::FetchResult::kAlreadyFetched
-                 : RowReader::FetchResult::kFetched);
-    }
-  }
-}
-
 // schema of flat map sample file
 // struct {
 //   id int,
@@ -235,6 +232,7 @@ void verifyPrefetch(
 //   memo varchar
 // }
 void verifyFlatMapReading(
+    memory::MemoryPool* pool,
     const std::string& file,
     const int32_t seeks[],
     const int32_t expectedBatchSize[],
@@ -242,23 +240,21 @@ void verifyFlatMapReading(
     bool returnFlatVector,
     const std::vector<uint32_t>& expectedPrefetchRowSizes = {},
     const std::vector<bool>& shouldTryPrefetch = {}) {
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool};
 
   /* If an extra sanity check is desired you can uncomment the 2 below lines and
    * re-run */
-  // readerOpts.setDirectorySizeGuess(257);
+  // readerOpts.setFooterEstimatedSize(257);
   // readerOpts.setFilePreloadThreshold(0);
 
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setReturnFlatVector(returnFlatVector);
   rowReaderOpts.select(std::make_shared<ColumnSelector>(getFlatmapSchema()));
   auto reader = DwrfReader::create(
-      createFileBufferedInput(file, readerOpts.getMemoryPool()), readerOpts);
+      createFileBufferedInput(file, readerOpts.memoryPool()), readerOpts);
   auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
   auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
 
-  // Prefetch the requested # of times
-  verifyPrefetch(rowReader, expectedPrefetchRowSizes, shouldTryPrefetch);
   verifyFlatMapReading(rowReader, seeks, expectedBatchSize, numBatches);
 }
 
@@ -266,9 +262,9 @@ void verifyFlatMapReading(
 Verifies contents of dict_encoded_strings.orc
 schema:
 struct {
-  int_column int,
-  string_column string
-  string_column_2 string
+ int_column int,
+ string_column string
+ string_column_2 string
 }
 */
 void verifyCachedIndexStreamReads(
@@ -353,24 +349,28 @@ void verifyCachedIndexStreamReads(
   }
 }
 
-class TestFlatMapReader : public TestWithParam<bool> {};
+class TestFlatMapReader : public TestWithParam<bool>, public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 TEST_P(TestFlatMapReader, testReadFlatMapEmptyMap) {
   const std::string emptyFile(getExampleFilePath("empty_flatmap.orc"));
   auto returnFlatVector = GetParam();
 
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setReturnFlatVector(returnFlatVector);
   std::shared_ptr<const RowType> emptyFileType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse("struct<\
-          id:int,\
-      mapCol:map<int,int>,\
-      ds:string>"));
+         id:int,\
+     mapCol:map<int,int>,\
+     ds:string>"));
   rowReaderOpts.select(std::make_shared<ColumnSelector>(emptyFileType));
   auto reader = DwrfReader::create(
-      createFileBufferedInput(emptyFile, readerOpts.getMemoryPool()),
-      readerOpts);
+      createFileBufferedInput(emptyFile, readerOpts.memoryPool()), readerOpts);
   auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
   auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
   VectorPtr batch;
@@ -390,15 +390,14 @@ TEST_P(TestFlatMapReader, testStringKeyLifeCycle) {
   auto returnFlatVector = GetParam();
 
   VectorPtr batch;
-  dwio::common::ReaderOptions readerOptions{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOptions{pool()};
 
   {
     RowReaderOptions rowReaderOptions;
     rowReaderOptions.setReturnFlatVector(returnFlatVector);
 
     auto reader = DwrfReader::create(
-        createFileBufferedInput(
-            getFMSmallFile(), readerOptions.getMemoryPool()),
+        createFileBufferedInput(getFMSmallFile(), readerOptions.memoryPool()),
         readerOptions);
     auto rowReader = reader->createRowReader(rowReaderOptions);
     rowReader->next(100, batch);
@@ -450,6 +449,7 @@ TEST_P(TestFlatMapReader, testReadFlatMapSampleSmallSkips) {
   const std::array<int32_t, 3> expectedBatchSize{200, 200, 100};
   auto returnFlatVector = GetParam();
   verifyFlatMapReading(
+      pool(),
       getFMSmallFile(),
       seeks.data(),
       expectedBatchSize.data(),
@@ -464,6 +464,7 @@ TEST_P(TestFlatMapReader, testReadFlatMapSampleSmall) {
   const std::array<int32_t, 4> expectedBatchSize{300, 300, 300, 100};
   auto returnFlatVector = GetParam();
   verifyFlatMapReading(
+      pool(),
       getFMSmallFile(),
       seeks.data(),
       expectedBatchSize.data(),
@@ -481,6 +482,7 @@ TEST_P(TestFlatMapReader, testReadFlatMapSampleLarge) {
       1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000};
   auto returnFlatVector = GetParam();
   verifyFlatMapReading(
+      pool(),
       getFMLargeFile(),
       seeks.data(),
       expectedBatchSize.data(),
@@ -493,367 +495,19 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     TestFlatMapReader,
     Values(true, false));
 
-TEST(TestRowReaderPrefetch, testPartialPrefetch) {
-  // batch size is set as 1000 in reading
-  std::array<int32_t, 5> seeks;
-  seeks.fill(0);
-  const std::array<int32_t, 4> expectedBatchSize{300, 300, 300, 100};
-  verifyFlatMapReading(
-      getFMSmallFile(),
-      seeks.data(),
-      expectedBatchSize.data(),
-      expectedBatchSize.size(),
-      false,
-      {300, 300, 300, 100},
-      /* file has 4 stripes, prefetch only some and verify whole read */
-      {true, false, true, false});
-}
-
-TEST(TestRowReaderPrefetch, testPrefetchWholeFile) {
-  // batch size is set as 1000 in reading
-  std::array<int32_t, 5> seeks;
-  seeks.fill(0);
-  const std::array<int32_t, 4> expectedBatchSize{300, 300, 300, 100};
-  verifyFlatMapReading(
-      getFMSmallFile(),
-      seeks.data(),
-      expectedBatchSize.data(),
-      expectedBatchSize.size(),
-      false,
-      {300, 300, 300, 100},
-      /* file has 4 stripes, issue prefetch for each one */
-      {true, true, true, true});
-}
-
-TEST(TestRowReaderPfetch, testSeekBeforePrefetch) {
-  // batch size is set as 1000 in reading
-  std::array<int32_t, 5> seeks;
-  seeks.fill(0);
-
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  RowReaderOptions rowReaderOpts;
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(getFlatmapSchema()));
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
-  auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
-
-  rowReader->seekToRow(100);
-  // First stripe has 300 rows, but expect 200 due to seeking past first 100
-  const std::array<int32_t, 4> expectedBatchSize{200, 300, 300, 100};
-  auto prefetches = rowReader->prefetchUnits().value();
-  for (auto& prefetch : prefetches) {
-    prefetch.prefetch();
-  }
-
-  verifyFlatMapReading(
-      rowReader,
-      seeks.data(),
-      expectedBatchSize.data(),
-      expectedBatchSize.size());
-}
-
-// Synchronous interleaving
-TEST(TestRowReaderPrefetch, testPrefetchAndStartNextStripeInterleaved) {
-  // batch size is set as 1000 in reading
-  std::array<int32_t, 5> seeks;
-  seeks.fill(0);
-  const std::array<int32_t, 4> expectedBatchSize{300, 300, 300, 100};
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  readerOpts.setFilePreloadThreshold(0);
-  RowReaderOptions rowReaderOpts;
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(getFlatmapSchema()));
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
-  auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
-
-  // startNextStripe just loads state for current row- it shouldn't prefetch
-  // ahead of its place
-  rowReader->startNextStripe();
-
-  // std::optional<std::vector<DwrfRowReader::PrefetchUnit>> units =
-  // rowReader->prefetchUnits();
-  auto units = rowReader->prefetchUnits().value();
-  EXPECT_EQ(units.size(), 4);
-
-  // startNextStripe should not interfere with prefetch- it should just be
-  // continuously re-loading the stripe its row index is on (currently 0).
-  EXPECT_EQ(units[0].prefetch(), DwrfRowReader::FetchResult::kAlreadyFetched);
-  EXPECT_EQ(units[1].prefetch(), DwrfRowReader::FetchResult::kFetched);
-  EXPECT_EQ(units[1].prefetch(), DwrfRowReader::FetchResult::kAlreadyFetched);
-  rowReader->startNextStripe();
-  rowReader->startNextStripe();
-  EXPECT_EQ(units[1].prefetch(), DwrfRowReader::FetchResult::kAlreadyFetched);
-
-  // Prefetch rest of stripe and call again (expecting no-op)
-  EXPECT_EQ(units[2].prefetch(), DwrfRowReader::FetchResult::kFetched);
-  EXPECT_EQ(units[3].prefetch(), DwrfRowReader::FetchResult::kFetched);
-
-  // DwrfRowReader still should register having no prefetching to do
-  rowReader->startNextStripe();
-
-  // Verify reads are correct
-  verifyFlatMapReading(
-      rowReader,
-      seeks.data(),
-      expectedBatchSize.data(),
-      expectedBatchSize.size());
-}
-
-TEST(TestRowReaderPrefetch, testReadLargePrefetch) {
-  // batch size is set as 1000 in reading
-  // 3000 per stripe
-  std::array<int32_t, 11> seeks;
-  seeks.fill(0);
-  const std::array<int32_t, 10> expectedBatchSize{
-      1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000};
-  verifyFlatMapReading(
-      getFMLargeFile(),
-      seeks.data(),
-      expectedBatchSize.data(),
-      expectedBatchSize.size(),
-      false,
-      {3000, 3000, 3000, 1000},
-      {true, true, false, false});
-}
-
-TEST(TestRowReaderPrefetch, testParallelPrefetch) {
-  // batch size is set as 1000 in reading
-  std::array<int32_t, 5> seeks;
-  seeks.fill(0);
-  const std::array<int32_t, 4> expectedBatchSize{300, 300, 300, 100};
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  RowReaderOptions rowReaderOpts;
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(getFlatmapSchema()));
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
-  auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
-
-  auto units = rowReader->prefetchUnits().value();
-  std::vector<std::future<DwrfRowReader::FetchResult>> prefetches;
-  prefetches.reserve(4);
-  for (int i = 0; i < 4; i++) {
-    prefetches.push_back(std::async(units[i].prefetch));
-  }
-
-  // Verify reads are correct
-  verifyFlatMapReading(
-      rowReader,
-      seeks.data(),
-      expectedBatchSize.data(),
-      expectedBatchSize.size());
-}
-
-// Use large file and disable preload to test
-TEST(TestRowReaderPrefetch, testParallelPrefetchNoPreload) {
-  // batch size is set as 1000 in reading
-  std::array<int32_t, 11> seeks;
-  seeks.fill(0);
-  const std::array<int32_t, 10> expectedBatchSize{
-      1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000};
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  // Explicitly disable so IO takes some time
-  readerOpts.setFilePreloadThreshold(0);
-  readerOpts.setDirectorySizeGuess(4);
-  RowReaderOptions rowReaderOpts;
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(getFlatmapSchema()));
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMLargeFile(), readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
-  auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
-
-  auto units = rowReader->prefetchUnits().value();
-  std::vector<std::future<DwrfRowReader::FetchResult>> prefetches;
-  prefetches.reserve(4);
-  for (int i = 0; i < 4; i++) {
-    prefetches.push_back(std::async(units[i].prefetch));
-  }
-
-  // Verify reads are correct
-  verifyFlatMapReading(
-      rowReader,
-      seeks.data(),
-      expectedBatchSize.data(),
-      expectedBatchSize.size());
-}
-
-TEST(TestRowReaderPrefetch, prefetchWithCachedIndexStream) {
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  readerOpts.setFilePreloadThreshold(0);
-  readerOpts.setDirectorySizeGuess(4);
-  RowReaderOptions rowReaderOpts;
-
-  std::shared_ptr<const RowType> requestedType = std::dynamic_pointer_cast<
-      const RowType>(HiveTypeParser().parse(
-      "struct<int_column:int,string_column:string,string_column_2:string,ds:string>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(requestedType));
-  rowReaderOpts.setEagerFirstStripeLoad(false);
-
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(
-          getExampleFilePath("dict_encoded_strings.orc"),
-          readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
-  auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
-
-  auto units = rowReader->prefetchUnits().value();
-  std::vector<DwrfRowReader::FetchResult> prefetches;
-
-  prefetches.reserve(1);
-  for (int i = 0; i < 3; i++) {
-    prefetches.emplace_back(units[i].prefetch());
-  }
-
-  for (auto& fetchResult : prefetches) {
-    ASSERT_EQ(DwrfRowReader::FetchResult::kFetched, fetchResult);
+class TestFlatMapReaderFlatLayout
+    : public TestWithParam<std::tuple<bool, size_t>>,
+      public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
   }
-  verifyCachedIndexStreamReads(rowReader, 0, 3);
-}
-
-struct ByStripeInfo {
-  uint64_t offset;
-  uint64_t length;
-  uint32_t firstStripe;
-  uint32_t pastLastStripe;
-
-  ByStripeInfo(
-      uint64_t offset,
-      uint64_t length,
-      uint32_t firstStripe,
-      uint32_t pastLastStripe)
-      : offset(offset),
-        length(length),
-        firstStripe(firstStripe),
-        pastLastStripe(pastLastStripe) {}
 };
 
-class TestRowReaderPrefetchByStripe : public TestWithParam<ByStripeInfo> {};
-
-// This test ensures that we only return the prefetch units for the stripes that
-// we'll actually use, according to the range passed to the row reader. We
-// don't need to be able to prefetch stripes that we won't use. That would
-// confuse us, since we'd have to calculate, outside of the reader, which
-// stripes we need to prefetch.
-TEST_P(TestRowReaderPrefetchByStripe, prefetchWithCachedIndexStream) {
-  auto opt = GetParam();
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  readerOpts.setFilePreloadThreshold(0);
-  readerOpts.setDirectorySizeGuess(4);
-  RowReaderOptions rowReaderOpts;
-  rowReaderOpts.range(opt.offset, opt.length);
-
-  std::shared_ptr<const RowType> requestedType = std::dynamic_pointer_cast<
-      const RowType>(HiveTypeParser().parse(
-      "struct<int_column:int,string_column:string,string_column_2:string,ds:string>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(requestedType));
-  rowReaderOpts.setEagerFirstStripeLoad(false);
-
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(
-          getExampleFilePath("dict_encoded_strings.orc"),
-          readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
-  auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
-
-  auto units = rowReader->prefetchUnits().value();
-  EXPECT_EQ(units.size(), (opt.pastLastStripe - opt.firstStripe));
-  std::vector<DwrfRowReader::FetchResult> prefetches;
-  prefetches.reserve(opt.pastLastStripe - opt.firstStripe);
-
-  for (auto& unit : units) {
-    prefetches.emplace_back(unit.prefetch());
-  }
-
-  ASSERT_EQ(prefetches.size(), opt.pastLastStripe - opt.firstStripe);
-
-  for (auto& fetchResult : prefetches) {
-    ASSERT_EQ(DwrfRowReader::FetchResult::kFetched, fetchResult);
-  }
-  verifyCachedIndexStreamReads(rowReader, opt.firstStripe, opt.pastLastStripe);
-}
-
-// Stripe | offset | length | rows
-//      0 |      3 |    583 |    3
-//      1 |    586 |    508 |  100
-//      2 |   1094 | ? (1+) |  100
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    TestRowReaderPrefetchByStripeSuite,
-    TestRowReaderPrefetchByStripe,
-    ValuesIn({
-        ByStripeInfo(3, 1, 0, 1), // Stripes: 0
-        ByStripeInfo(586, 1, 1, 2), // Stripes: 1
-        ByStripeInfo(1094, 1, 2, 3), // Stripes: 2
-        ByStripeInfo(3, 584, 0, 2), // Stripes: 0, 1
-        ByStripeInfo(586, 509, 1, 3), // Stripes: 1, 2
-        ByStripeInfo(3, 1092, 0, 3) // Stripes: 0, 1, 2
-    }));
-
-// This test just verifies read correctness with the eager first stripe load
-// config off for regression purposes. It does not ensure the first stripe is
-// not loaded before we explicitly prefetch or start reading.
-TEST(TestRowReaderPrefetch, testNoEagerFirstStripeLoad) {
-  // batch size is set as 1000 in reading
-  std::array<int32_t, 5> seeks;
-  seeks.fill(0);
-  const std::array<int32_t, 4> expectedBatchSize{300, 300, 300, 100};
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  RowReaderOptions rowReaderOpts;
-
-  // If we ever change default to false, let us fail this test so we can
-  // change tests in this file accordingly.
-  ASSERT_TRUE(rowReaderOpts.getEagerFirstStripeLoad());
-  rowReaderOpts.setEagerFirstStripeLoad(false);
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(getFlatmapSchema()));
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
-  auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
-
-  // Verify reads are correct
-  verifyFlatMapReading(
-      rowReader,
-      seeks.data(),
-      expectedBatchSize.data(),
-      expectedBatchSize.size());
-}
-
-// Other tests use default of eager loading, and test first stripe is
-// preloaded after DwrfRowReader::create. This tests the case where eager
-// loading is set to false.
-TEST(TestRowReaderPrefetch, testFirstStripeNotLoadedWithEagerLoadingOff) {
-  // batch size is set as 1000 in reading
-  std::array<int32_t, 5> seeks;
-  seeks.fill(0);
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  RowReaderOptions rowReaderOpts;
-  rowReaderOpts.setEagerFirstStripeLoad(false);
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(getFlatmapSchema()));
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
-  auto rowReader = dynamic_cast<DwrfRowReader*>(rowReaderOwner.get());
-
-  auto units = rowReader->prefetchUnits().value();
-  ASSERT_EQ(units[0].prefetch(), DwrfRowReader::FetchResult::kFetched);
-}
-
-class TestFlatMapReaderFlatLayout
-    : public TestWithParam<std::tuple<bool, size_t>> {};
-
 TEST_P(TestFlatMapReaderFlatLayout, testCompare) {
-  dwio::common::ReaderOptions readerOptions{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOptions{pool()};
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOptions.getMemoryPool()),
+      createFileBufferedInput(getFMSmallFile(), readerOptions.memoryPool()),
       readerOptions);
   RowReaderOptions rowReaderOptions;
   auto param = GetParam();
@@ -881,10 +535,10 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     TestFlatMapReaderFlatLayout,
     Combine(Bool(), Values(1, 100)));
 
-TEST(TestReader, testReadFlatMapWithKeyFilters) {
+TEST_F(TestReader, testReadFlatMapWithKeyFilters) {
   // batch size is set as 1000 in reading
   // file has schema: a int, b struct<a:int, b:float, c:string>, c float
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
   // set map key filter for map1 we only need key=1, and map2 only key-1
   auto cs = std::make_shared<ColumnSelector>(
@@ -892,7 +546,7 @@ TEST(TestReader, testReadFlatMapWithKeyFilters) {
       std::vector<std::string>{"map1#[1]", "map2#[\"key-1\"]"});
   rowReaderOpts.select(cs);
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -934,16 +588,16 @@ TEST(TestReader, testReadFlatMapWithKeyFilters) {
   } while (true);
 }
 
-TEST(TestReader, testReadFlatMapWithKeyRejectList) {
+TEST_F(TestReader, testReadFlatMapWithKeyRejectList) {
   // batch size is set as 1000 in reading
   // file has schema: a int, b struct<a:int, b:float, c:string>, c float
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
   auto cs = std::make_shared<ColumnSelector>(
       getFlatmapSchema(), std::vector<std::string>{"map1#[\"!2\",\"!3\"]"});
   rowReaderOpts.select(cs);
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -974,7 +628,7 @@ TEST(TestReader, testReadFlatMapWithKeyRejectList) {
   } while (true);
 }
 
-TEST(TestReader, testStatsCallbackFiredWithFiltering) {
+TEST_F(TestReader, testStatsCallbackFiredWithFiltering) {
   RowReaderOptions rowReaderOpts;
   // Apply feature projection
   auto cs = std::make_shared<ColumnSelector>(
@@ -992,10 +646,10 @@ TEST(TestReader, testStatsCallbackFiredWithFiltering) {
         selectedKeyStreamsAggregate += keySelectionStats.selectedKeys;
       });
 
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
 
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -1012,11 +666,156 @@ TEST(TestReader, testStatsCallbackFiredWithFiltering) {
   EXPECT_EQ(selectedKeyStreamsAggregate, 4);
 }
 
-TEST(TestReader, testEstimatedSize) {
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+TEST_F(TestReader, testBlockedIoCallbackFiredBlocking) {
+  RowReaderOptions rowReaderOpts;
+  std::optional<uint64_t> metricToIncrement;
+
+  rowReaderOpts.setBlockedOnIoCallback(
+      [&metricToIncrement](
+          std::chrono::high_resolution_clock::duration blockedTime) {
+        const auto blockedTimeMs =
+            std::chrono::duration_cast<std::chrono::milliseconds>(blockedTime)
+                .count();
+        if (metricToIncrement) {
+          *metricToIncrement += blockedTimeMs;
+        } else {
+          metricToIncrement = blockedTimeMs;
+        }
+      });
+  rowReaderOpts.setEagerFirstStripeLoad(false);
+
+  dwio::common::ReaderOptions readerOpts{pool()};
+
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(getFMLargeFile(), readerOpts.memoryPool()),
+      readerOpts);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  // We didn't preload first stripe, so we expect metric to not be populated yet
+  EXPECT_EQ(metricToIncrement, std::nullopt);
+  VectorPtr batch;
+
+  auto lastMetric = metricToIncrement;
+  do {
+    bool result = rowReader->next(1000, batch);
+    // Stripes in fm_large are 1000 rows, so we expect reading 1000 rows to load
+    // a new stripe and increment the metric
+    EXPECT_GE(metricToIncrement, lastMetric);
+    lastMetric = metricToIncrement;
+    if (!result) {
+      break;
+    }
+  } while (true);
+
+  // Reading stripes that were prefetched should not affect metric
+  EXPECT_GE(metricToIncrement, 0);
+}
+
+TEST_F(TestReader, DISABLED_testBlockedIoCallbackFiredNonBlocking) {
+  RowReaderOptions rowReaderOpts;
+  std::optional<uint64_t> metricToIncrement;
+
+  rowReaderOpts.setBlockedOnIoCallback(
+      [&metricToIncrement](
+          std::chrono::high_resolution_clock::duration blockedTime) {
+        const auto blockedTimeMs =
+            std::chrono::duration_cast<std::chrono::milliseconds>(blockedTime)
+                .count();
+        if (metricToIncrement) {
+          *metricToIncrement += blockedTimeMs;
+        } else {
+          metricToIncrement = blockedTimeMs;
+        }
+      });
+  rowReaderOpts.setEagerFirstStripeLoad(false);
+
+  dwio::common::ReaderOptions readerOpts{pool()};
+
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(getFMLargeFile(), readerOpts.memoryPool()),
+      readerOpts);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  EXPECT_EQ(metricToIncrement, std::nullopt);
+  VectorPtr batch;
+
+  auto units = rowReader->prefetchUnits().value();
+
+  // Blocking prefetch all stripes
+  for (auto& unit : units) {
+    unit.prefetch();
+    // Since these are not blocking a read, metric should not be incremented.
+    EXPECT_EQ(metricToIncrement, std::nullopt);
+  }
+
+  do {
+    bool result = rowReader->next(1000, batch);
+    if (!result) {
+      break;
+    }
+  } while (true);
+
+  // Reading prefetched stripes should not increment metric, but it should set
+  // the metric from nullopt to 0, indicating we've hit the read path
+  EXPECT_EQ(metricToIncrement, 0);
+}
+
+TEST_F(TestReader, DISABLED_testBlockedIoCallbackFiredWithFirstStripeLoad) {
+  RowReaderOptions rowReaderOpts;
+  std::optional<uint64_t> metricToIncrement;
+
+  rowReaderOpts.setBlockedOnIoCallback(
+      [&metricToIncrement](
+          std::chrono::high_resolution_clock::duration blockedTime) {
+        const auto blockedTimeMs =
+            std::chrono::duration_cast<std::chrono::milliseconds>(blockedTime)
+                .count();
+        if (metricToIncrement) {
+          *metricToIncrement += blockedTimeMs;
+        } else {
+          metricToIncrement = blockedTimeMs;
+        }
+      });
+
+  rowReaderOpts.setEagerFirstStripeLoad(true);
+
+  dwio::common::ReaderOptions readerOpts{pool()};
+
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(getFMLargeFile(), readerOpts.memoryPool()),
+      readerOpts);
+  EXPECT_EQ(metricToIncrement, std::nullopt);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  // Expect metric has now been populated, due to the initial blocking IO of
+  // loadCurrentStripe()
+  EXPECT_GE(metricToIncrement, 0);
+  auto metricAfterFirstStripe = metricToIncrement;
+  VectorPtr batch;
+
+  auto units = rowReader->prefetchUnits().value();
+  EXPECT_EQ(metricToIncrement, metricAfterFirstStripe);
+
+  // Blocking prefetch all stripes
+  for (auto& unit : units) {
+    unit.prefetch();
+    // Since these are not blocking a read, metric should not be incremented
+    EXPECT_EQ(metricToIncrement, metricAfterFirstStripe);
+  }
+
+  do {
+    bool result = rowReader->next(1000, batch);
+    if (!result) {
+      break;
+    }
+  } while (true);
+
+  // Reading prefetched stripes should not affect metric
+  EXPECT_EQ(metricToIncrement, metricAfterFirstStripe);
+}
+
+TEST_F(TestReader, testEstimatedSize) {
+  dwio::common::ReaderOptions readerOpts{pool()};
   {
     auto reader = DwrfReader::create(
-        createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
+        createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
         readerOpts);
     auto cs = std::make_shared<ColumnSelector>(
         getFlatmapSchema(), std::vector<std::string>{"map2"});
@@ -1029,7 +828,7 @@ TEST(TestReader, testEstimatedSize) {
 
   {
     auto reader = DwrfReader::create(
-        createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
+        createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
         readerOpts);
     auto cs = std::make_shared<ColumnSelector>(
         getFlatmapSchema(), std::vector<std::string>{"id"});
@@ -1040,7 +839,7 @@ TEST(TestReader, testEstimatedSize) {
   }
 }
 
-TEST(TestReader, testStatsCallbackFiredWithoutFiltering) {
+TEST_F(TestReader, testStatsCallbackFiredWithoutFiltering) {
   RowReaderOptions rowReaderOpts;
   // Don't apply feature projection here
   auto cs = std::make_shared<ColumnSelector>(
@@ -1058,10 +857,10 @@ TEST(TestReader, testStatsCallbackFiredWithoutFiltering) {
         selectedKeyStreamsAggregate += keySelectionStats.selectedKeys;
       });
 
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
 
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getFMSmallFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getFMSmallFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -1138,14 +937,14 @@ void verifyMapColumnEqual(
 }
 
 void verifyFlatmapStructEncoding(
+    memory::MemoryPool* pool,
     const std::string& filename,
     const std::vector<int32_t>& keysAsFields,
     const std::vector<int32_t>& keysToSelect,
     size_t batchSize = 1000) {
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool};
   auto reader = DwrfReader::create(
-      createFileBufferedInput(filename, readerOpts.getMemoryPool()),
-      readerOpts);
+      createFileBufferedInput(filename, readerOpts.memoryPool()), readerOpts);
 
   const std::string projectedColumn = "map1";
   const vector_size_t projectedColumnIndex = 1;
@@ -1156,12 +955,12 @@ void verifyFlatmapStructEncoding(
 
   auto cs = std::make_shared<ColumnSelector>(
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse("struct<\
-          id:int,\
-      map1:map<int, array<float>>,\
-      map2:map<string, map<smallint,bigint>>,\
-      map3:map<int,int>,\
-      map4:map<int,struct<field1:int,field2:float,field3:string>>,\
-      memo:string>")),
+         id:int,\
+     map1:map<int, array<float>>,\
+     map2:map<string, map<smallint,bigint>>,\
+     map3:map<int,int>,\
+     map4:map<int,struct<field1:int,field2:float,field3:string>>,\
+     memo:string>")),
       columnSelections);
 
   RowReaderOptions rowReaderOpts;
@@ -1205,36 +1004,40 @@ void verifyFlatmapStructEncoding(
 }
 } // namespace
 
-TEST(TestReader, testFlatmapAsStructSmall) {
+TEST_F(TestReader, testFlatmapAsStructSmall) {
   verifyFlatmapStructEncoding(
+      pool(),
       getFMSmallFile(),
       {1, 2, 3, 4, 5, -99999999 /* does not exist */},
       {} /* no key filtering */);
 }
 
-TEST(TestReader, testFlatmapAsStructSmallEmptyInmap) {
+TEST_F(TestReader, testFlatmapAsStructSmallEmptyInmap) {
   verifyFlatmapStructEncoding(
+      pool(),
       getFMSmallFile(),
       {1, 2, 3, 4, 5, -99999999 /* does not exist */},
       {} /* no key filtering */,
       2);
 }
 
-TEST(TestReader, testFlatmapAsStructLarge) {
+TEST_F(TestReader, testFlatmapAsStructLarge) {
   verifyFlatmapStructEncoding(
+      pool(),
       getFMSmallFile(),
       {1, 2, 3, 4, 5, -99999999 /* does not exist */},
       {} /* no key filtering */);
 }
 
-TEST(TestReader, testFlatmapAsStructWithKeyProjection) {
+TEST_F(TestReader, testFlatmapAsStructWithKeyProjection) {
   verifyFlatmapStructEncoding(
+      pool(),
       getFMSmallFile(),
       {1, 2, 3, 4, 5, -99999999 /* does not exist */},
       {3, 5} /* select only these to read */);
 }
 
-TEST(TestReader, testFlatmapAsStructRequiringKeyList) {
+TEST_F(TestReader, testFlatmapAsStructRequiringKeyList) {
   const std::unordered_map<uint32_t, std::vector<std::string>> emptyKeys = {
       {0, {}}};
   RowReaderOptions rowReaderOpts;
@@ -1243,9 +1046,9 @@ TEST(TestReader, testFlatmapAsStructRequiringKeyList) {
 }
 
 // TODO: replace with mock
-TEST(TestReader, testMismatchSchemaMoreFields) {
+TEST_F(TestReader, testMismatchSchemaMoreFields) {
   // file has schema: a int, b struct<a:int, b:float, c:string>, c float
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
@@ -1253,7 +1056,7 @@ TEST(TestReader, testMismatchSchemaMoreFields) {
   rowReaderOpts.select(std::make_shared<ColumnSelector>(
       requestedType, std::vector<uint64_t>{1, 2, 3}));
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -1272,7 +1075,7 @@ TEST(TestReader, testMismatchSchemaMoreFields) {
 
   rowReaderOpts.setProjectSelectedType(true);
   reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   rowReader = reader->createRowReader(rowReaderOpts);
   rowReader->next(1, batch);
@@ -1288,9 +1091,9 @@ TEST(TestReader, testMismatchSchemaMoreFields) {
   }
 }
 
-TEST(TestReader, testMismatchSchemaFewerFields) {
+TEST_F(TestReader, testMismatchSchemaFewerFields) {
   // file has schema: a int, b struct<a:int, b:float, c:string>, c float
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
@@ -1298,7 +1101,7 @@ TEST(TestReader, testMismatchSchemaFewerFields) {
   rowReaderOpts.select(std::make_shared<ColumnSelector>(
       requestedType, std::vector<uint64_t>{1}));
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -1316,7 +1119,7 @@ TEST(TestReader, testMismatchSchemaFewerFields) {
   batch.reset();
   rowReaderOpts.setProjectSelectedType(true);
   reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   rowReader = reader->createRowReader(rowReaderOpts);
   rowReader->next(1, batch);
@@ -1329,9 +1132,9 @@ TEST(TestReader, testMismatchSchemaFewerFields) {
   }
 }
 
-TEST(TestReader, testMismatchSchemaNestedMoreFields) {
+TEST_F(TestReader, testMismatchSchemaNestedMoreFields) {
   // file has schema: a int, b struct<a:int, b:float>, c float
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
@@ -1340,7 +1143,7 @@ TEST(TestReader, testMismatchSchemaNestedMoreFields) {
   rowReaderOpts.select(std::make_shared<ColumnSelector>(
       requestedType, std::vector<std::string>{"b.b", "b.c", "b.d", "c"}));
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -1370,7 +1173,7 @@ TEST(TestReader, testMismatchSchemaNestedMoreFields) {
   batch.reset();
   rowReaderOpts.setProjectSelectedType(true);
   reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   rowReader = reader->createRowReader(rowReaderOpts);
   rowReader->next(1, batch);
@@ -1395,9 +1198,9 @@ TEST(TestReader, testMismatchSchemaNestedMoreFields) {
   }
 }
 
-TEST(TestReader, testMismatchSchemaNestedFewerFields) {
+TEST_F(TestReader, testMismatchSchemaNestedFewerFields) {
   // file has schema: a int, b struct<a:int, b:float>, c float
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
@@ -1405,7 +1208,7 @@ TEST(TestReader, testMismatchSchemaNestedFewerFields) {
   rowReaderOpts.select(std::make_shared<ColumnSelector>(
       requestedType, std::vector<std::string>{"b.b", "c"}));
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -1431,7 +1234,7 @@ TEST(TestReader, testMismatchSchemaNestedFewerFields) {
   batch.reset();
   rowReaderOpts.setProjectSelectedType(true);
   reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   rowReader = reader->createRowReader(rowReaderOpts);
   rowReader->next(1, batch);
@@ -1452,9 +1255,9 @@ TEST(TestReader, testMismatchSchemaNestedFewerFields) {
   }
 }
 
-TEST(TestReader, testMismatchSchemaIncompatibleNotSelected) {
+TEST_F(TestReader, testMismatchSchemaIncompatibleNotSelected) {
   // file has schema: a int, b struct<a:int, b:float>, c float
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
@@ -1462,7 +1265,7 @@ TEST(TestReader, testMismatchSchemaIncompatibleNotSelected) {
   rowReaderOpts.select(std::make_shared<ColumnSelector>(
       requestedType, std::vector<std::string>{"b.b"}));
   auto reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   auto rowReader = reader->createRowReader(rowReaderOpts);
   VectorPtr batch;
@@ -1490,7 +1293,7 @@ TEST(TestReader, testMismatchSchemaIncompatibleNotSelected) {
   batch.reset();
   rowReaderOpts.setProjectSelectedType(true);
   reader = DwrfReader::create(
-      createFileBufferedInput(getStructFile(), readerOpts.getMemoryPool()),
+      createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
   rowReader = reader->createRowReader(rowReaderOpts);
   rowReader->next(1, batch);
@@ -1509,7 +1312,7 @@ TEST(TestReader, testMismatchSchemaIncompatibleNotSelected) {
   }
 }
 
-TEST(TestReader, testMismatchSchemaIncompatible) {
+TEST_F(TestReader, testMismatchSchemaIncompatible) {
   MockStripeStreams streams;
 
   // set getEncoding
@@ -1533,27 +1336,27 @@ TEST(TestReader, testMismatchSchemaIncompatible) {
   }
 }
 
-TEST(TestReader, fileColumnNamesReadAsLowerCase) {
+TEST_F(TestReader, fileColumnNamesReadAsLowerCase) {
   // upper.orc holds one columns (Bool_Val: BOOLEAN, b: BIGINT)
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   readerOpts.setFileColumnNamesReadAsLowerCase(true);
   auto reader = DwrfReader::create(
       createFileBufferedInput(
-          getExampleFilePath("upper.orc"), readerOpts.getMemoryPool()),
+          getExampleFilePath("upper.orc"), readerOpts.memoryPool()),
       readerOpts);
   auto type = reader->typeWithId();
   auto col0 = type->childAt(0);
   EXPECT_EQ(type->childByName("bool_val"), col0);
 }
 
-TEST(TestReader, fileColumnNamesReadAsLowerCaseComplexStruct) {
+TEST_F(TestReader, fileColumnNamesReadAsLowerCaseComplexStruct) {
   // upper_complex.orc holds type
   // Cc:struct<CcLong0:bigint,CcMap1:map<string,struct<CcArray2:array<struct<CcInt3:int>>>>>
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   readerOpts.setFileColumnNamesReadAsLowerCase(true);
   auto reader = DwrfReader::create(
       createFileBufferedInput(
-          getExampleFilePath("upper_complex.orc"), readerOpts.getMemoryPool()),
+          getExampleFilePath("upper_complex.orc"), readerOpts.memoryPool()),
       readerOpts);
   auto type = reader->typeWithId();
 
@@ -1586,7 +1389,93 @@ TEST(TestReader, fileColumnNamesReadAsLowerCaseComplexStruct) {
   EXPECT_EQ(col0_1_1_0_0->childByName("ccint3"), col0_1_1_0_0_0);
 }
 
-TEST(TestReader, testUpcastBoolean) {
+TEST_F(TestReader, TestStripeSizeCallback) {
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setFilePreloadThreshold(0);
+  readerOpts.setFooterEstimatedSize(4);
+  RowReaderOptions rowReaderOpts;
+
+  std::shared_ptr<const RowType> requestedType = std::dynamic_pointer_cast<
+      const RowType>(HiveTypeParser().parse(
+      "struct<int_column:int,string_column:string,string_column_2:string,ds:string>"));
+  rowReaderOpts.select(std::make_shared<ColumnSelector>(requestedType));
+  rowReaderOpts.setEagerFirstStripeLoad(false);
+  uint16_t stripeCount = 0;
+  int numCalls = 0;
+  rowReaderOpts.setStripeCountCallback([&](uint16_t count) {
+    stripeCount += count;
+    ++numCalls;
+  });
+
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(
+          getExampleFilePath("dict_encoded_strings.orc"),
+          readerOpts.memoryPool()),
+      readerOpts);
+  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
+  EXPECT_EQ(stripeCount, 3);
+  EXPECT_EQ(numCalls, 1);
+}
+
+TEST_F(TestReader, TestStripeSizeCallbackLimitsOneStripe) {
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setFilePreloadThreshold(0);
+  readerOpts.setFooterEstimatedSize(4);
+  RowReaderOptions rowReaderOpts;
+
+  std::shared_ptr<const RowType> requestedType = std::dynamic_pointer_cast<
+      const RowType>(HiveTypeParser().parse(
+      "struct<int_column:int,string_column:string,string_column_2:string,ds:string>"));
+  rowReaderOpts.select(std::make_shared<ColumnSelector>(requestedType));
+  rowReaderOpts.setEagerFirstStripeLoad(false);
+  rowReaderOpts.range(600, 600);
+  uint16_t stripeCount = 0;
+  int numCalls = 0;
+  rowReaderOpts.setStripeCountCallback([&](uint16_t count) {
+    stripeCount += count;
+    ++numCalls;
+  });
+
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(
+          getExampleFilePath("dict_encoded_strings.orc"),
+          readerOpts.memoryPool()),
+      readerOpts);
+  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
+  EXPECT_EQ(stripeCount, 1);
+  EXPECT_EQ(numCalls, 1);
+}
+
+TEST_F(TestReader, TestStripeSizeCallbackLimitsTwoStripe) {
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setFilePreloadThreshold(0);
+  readerOpts.setFooterEstimatedSize(4);
+  RowReaderOptions rowReaderOpts;
+
+  std::shared_ptr<const RowType> requestedType = std::dynamic_pointer_cast<
+      const RowType>(HiveTypeParser().parse(
+      "struct<int_column:int,string_column:string,string_column_2:string,ds:string>"));
+  rowReaderOpts.select(std::make_shared<ColumnSelector>(requestedType));
+  rowReaderOpts.setEagerFirstStripeLoad(false);
+  rowReaderOpts.range(0, 600);
+  uint16_t stripeCount = 0;
+  int numCalls = 0;
+  rowReaderOpts.setStripeCountCallback([&](uint16_t count) {
+    stripeCount += count;
+    ++numCalls;
+  });
+
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(
+          getExampleFilePath("dict_encoded_strings.orc"),
+          readerOpts.memoryPool()),
+      readerOpts);
+  auto rowReaderOwner = reader->createRowReader(rowReaderOpts);
+  EXPECT_EQ(stripeCount, 2);
+  EXPECT_EQ(numCalls, 1);
+}
+
+TEST_P(TestReaderP, testUpcastBoolean) {
   MockStripeStreams streams;
 
   // set getEncoding
@@ -1616,13 +1505,15 @@ TEST(TestReader, testUpcastBoolean) {
           HiveTypeParser().parse("struct<col0:int>"));
   ColumnSelector cs(reqType, rowType);
   EXPECT_CALL(streams, getColumnSelectorProxy()).WillRepeatedly(Return(&cs));
-  memory::AllocationPool allocPool(getDefaultPool().get());
+  memory::AllocationPool allocPool(pool());
   StreamLabels labels(allocPool);
   std::unique_ptr<ColumnReader> reader = ColumnReader::build(
       TypeWithId::create(reqType),
       TypeWithId::create(rowType),
       streams,
-      labels);
+      labels,
+      executor(),
+      getDecodingParallelismFactor());
 
   VectorPtr batch;
   reader->next(104, batch);
@@ -1635,7 +1526,7 @@ TEST(TestReader, testUpcastBoolean) {
   }
 }
 
-TEST(TestReader, testUpcastIntDirect) {
+TEST_P(TestReaderP, testUpcastIntDirect) {
   MockStripeStreams streams;
 
   // set getEncoding
@@ -1665,13 +1556,15 @@ TEST(TestReader, testUpcastIntDirect) {
 
   ColumnSelector cs(reqType, rowType);
   EXPECT_CALL(streams, getColumnSelectorProxy()).WillRepeatedly(Return(&cs));
-  memory::AllocationPool allocPool(getDefaultPool().get());
+  memory::AllocationPool allocPool(pool());
   StreamLabels labels(allocPool);
   std::unique_ptr<ColumnReader> reader = ColumnReader::build(
       TypeWithId::create(reqType),
       TypeWithId::create(rowType),
       streams,
-      labels);
+      labels,
+      executor(),
+      getDecodingParallelismFactor());
 
   VectorPtr batch;
   reader->next(100, batch);
@@ -1685,7 +1578,7 @@ TEST(TestReader, testUpcastIntDirect) {
   }
 }
 
-TEST(TestReader, testUpcastIntDict) {
+TEST_P(TestReaderP, testUpcastIntDict) {
   MockStripeStreams streams;
 
   // set getEncoding
@@ -1731,13 +1624,15 @@ TEST(TestReader, testUpcastIntDict) {
           HiveTypeParser().parse("struct<col0:bigint>"));
   ColumnSelector cs(reqType, rowType);
   EXPECT_CALL(streams, getColumnSelectorProxy()).WillRepeatedly(Return(&cs));
-  memory::AllocationPool allocPool(getDefaultPool().get());
+  memory::AllocationPool allocPool(pool());
   StreamLabels labels(allocPool);
   std::unique_ptr<ColumnReader> reader = ColumnReader::build(
       TypeWithId::create(reqType),
       TypeWithId::create(rowType),
       streams,
-      labels);
+      labels,
+      executor(),
+      getDecodingParallelismFactor());
 
   VectorPtr batch;
   reader->next(100, batch);
@@ -1749,7 +1644,7 @@ TEST(TestReader, testUpcastIntDict) {
   }
 }
 
-TEST(TestReader, testUpcastFloat) {
+TEST_P(TestReaderP, testUpcastFloat) {
   MockStripeStreams streams;
 
   // set getEncoding
@@ -1785,13 +1680,15 @@ TEST(TestReader, testUpcastFloat) {
           HiveTypeParser().parse("struct<col0:double>"));
   ColumnSelector cs(reqType, rowType);
   EXPECT_CALL(streams, getColumnSelectorProxy()).WillRepeatedly(Return(&cs));
-  memory::AllocationPool allocPool(getDefaultPool().get());
+  memory::AllocationPool allocPool(pool());
   StreamLabels labels(allocPool);
   std::unique_ptr<ColumnReader> reader = ColumnReader::build(
       TypeWithId::create(reqType),
       TypeWithId::create(rowType),
       streams,
-      labels);
+      labels,
+      executor(),
+      getDecodingParallelismFactor());
 
   VectorPtr batch;
   reader->next(100, batch);
@@ -1803,10 +1700,19 @@ TEST(TestReader, testUpcastFloat) {
   }
 }
 
-TEST(TestReader, testEmptyFile) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink sink{1024, {.pool = pool.get()}};
-  DataBufferHolder holder{*pool, 1024, 0, DEFAULT_PAGE_GROW_RATIO, &sink};
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TestReaderSerialDecoding,
+    TestReaderP,
+    Values(false));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TestReaderParallelDecoding,
+    TestReaderP,
+    Values(true));
+
+TEST_F(TestReader, testEmptyFile) {
+  MemorySink sink{1024, {.pool = pool()}};
+  DataBufferHolder holder{*pool(), 1024, 0, DEFAULT_PAGE_GROW_RATIO, &sink};
   BufferedOutputStream output{holder};
 
   proto::Footer footer;
@@ -1826,14 +1732,14 @@ TEST(TestReader, testEmptyFile) {
   output.flush();
   auto psLen = static_cast<uint8_t>(sink.size() - footerLen);
 
-  DataBuffer<char> buf{*pool, 1};
+  DataBuffer<char> buf{*pool(), 1};
   buf.data()[0] = psLen;
   sink.write(std::move(buf));
-  std::string_view data(sink.data(), sink.size());
+  std::string data(sink.data(), sink.size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), *pool);
+      std::make_shared<InMemoryReadFile>(std::move(data)), *pool());
 
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool()};
   RowReaderOptions rowReaderOpts;
 
   auto rowReader = DwrfReader::create(std::move(input), readerOpts)
@@ -1911,12 +1817,12 @@ iterateVector(const VectorPtr& vector, IteraterCallback cb, size_t index = 0) {
 }
 
 void testBufferLifeCycle(
+    memory::MemoryPool* pool,
     const std::shared_ptr<const RowType>& schema,
     const std::shared_ptr<dwrf::Config>& config,
     std::mt19937& rng,
     size_t batchSize,
     bool hasNull) {
-  auto pool = memory::addDefaultLeafMemoryPool();
   std::vector<VectorPtr> batches;
   std::function<bool(vector_size_t)> isNullAt = nullptr;
   if (hasNull) {
@@ -1927,16 +1833,16 @@ void testBufferLifeCycle(
   batches.push_back(vector);
 
   auto sink = std::make_unique<MemorySink>(
-      1024 * 1024, FileSink::Options{.pool = pool.get()});
+      1024 * 1024, FileSink::Options{.pool = pool});
   auto sinkPtr = sink.get();
   auto writer =
       E2EWriterTestUtil::writeData(std::move(sink), schema, batches, config);
 
-  std::string_view data(sinkPtr->data(), sinkPtr->size());
+  std::string data(sinkPtr->data(), sinkPtr->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), *pool);
+      std::make_shared<InMemoryReadFile>(std::move(data)), *pool);
 
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool};
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setReturnFlatVector(true);
   auto reader = std::make_unique<DwrfReader>(readerOpts, std::move(input));
@@ -1969,12 +1875,12 @@ void testBufferLifeCycle(
 }
 
 void testFlatmapAsMapFieldLifeCycle(
+    memory::MemoryPool* pool,
     const std::shared_ptr<const RowType>& schema,
     const std::shared_ptr<dwrf::Config>& config,
     std::mt19937& rng,
     size_t batchSize,
     bool hasNull) {
-  auto pool = memory::addDefaultLeafMemoryPool();
   std::vector<VectorPtr> batches;
   std::function<bool(vector_size_t)> isNullAt = nullptr;
   if (hasNull) {
@@ -1985,16 +1891,16 @@ void testFlatmapAsMapFieldLifeCycle(
   batches.push_back(vector);
 
   auto sink = std::make_unique<MemorySink>(
-      1024 * 1024, FileSink::Options{.pool = pool.get()});
+      1024 * 1024, FileSink::Options{.pool = pool});
   auto sinkPtr = sink.get();
   auto writer =
       E2EWriterTestUtil::writeData(std::move(sink), schema, batches, config);
 
-  std::string_view data(sinkPtr->data(), sinkPtr->size());
+  std::string data(sinkPtr->data(), sinkPtr->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), *pool);
+      std::make_shared<InMemoryReadFile>(std::move(data)), *pool);
 
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
+  dwio::common::ReaderOptions readerOpts{pool};
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setReturnFlatVector(true);
   auto reader = std::make_unique<DwrfReader>(readerOpts, std::move(input));
@@ -2008,7 +1914,6 @@ void testFlatmapAsMapFieldLifeCycle(
   auto child =
       std::dynamic_pointer_cast<MapVector>(result->as<RowVector>()->childAt(0));
   BaseVector* rowPtr = result.get();
-  MapVector* childPtr = child.get();
   Buffer* rawNulls = child->nulls().get();
   BufferPtr sizes = child->sizes();
   Buffer* rawOffsets = child->offsets().get();
@@ -2029,7 +1934,6 @@ void testFlatmapAsMapFieldLifeCycle(
 
   auto mapKeys = child->mapKeys();
   auto rawSizes = child->sizes().get();
-  childPtr = child.get();
   child.reset();
 
   EXPECT_TRUE(rowReader->next(batchSize, result));
@@ -2041,7 +1945,6 @@ void testFlatmapAsMapFieldLifeCycle(
   EXPECT_NE(mapKeys, child->mapKeys());
   // there is a TODO in FlatMapColumnReader next() (result is not reused)
   // should be EQ; fix: https://fburl.com/code/wtrq8r5q
-  // EXPECT_EQ(childPtr, child.get());
   EXPECT_EQ(rowPtr, result.get());
 
   EXPECT_TRUE(rowReader->next(batchSize, result));
@@ -2053,13 +1956,12 @@ void testFlatmapAsMapFieldLifeCycle(
   EXPECT_NE(rawSizes, childCurr->sizes().get());
   EXPECT_NE(rawOffsets, childCurr->offsets().get());
   EXPECT_NE(keysPtr, childCurr->mapKeys().get());
-  // EXPECT_EQ(childPtr, childCurr.get());
   EXPECT_EQ(rowPtr, result.get());
 }
 
 } // namespace
 
-TEST(TestReader, testBufferLifeCycle) {
+TEST_F(TestReader, testBufferLifeCycle) {
   const size_t batchSize = 10;
   auto schema = ROW({
       MAP(VARCHAR(), INTEGER()),
@@ -2095,12 +1997,12 @@ TEST(TestReader, testBufferLifeCycle) {
   std::mt19937 rng{seed};
 
   for (auto i = 0; i < 10; ++i) {
-    testBufferLifeCycle(schema, config, rng, batchSize, false);
-    testBufferLifeCycle(schema, config, rng, batchSize, true);
+    testBufferLifeCycle(pool(), schema, config, rng, batchSize, false);
+    testBufferLifeCycle(pool(), schema, config, rng, batchSize, true);
   }
 }
 
-TEST(TestReader, testFlatmapAsMapFieldLifeCycle) {
+TEST_F(TestReader, testFlatmapAsMapFieldLifeCycle) {
   const size_t batchSize = 10;
   auto schema = ROW({
       MAP(VARCHAR(), INTEGER()),
@@ -2114,40 +2016,11 @@ TEST(TestReader, testFlatmapAsMapFieldLifeCycle) {
   LOG(INFO) << "seed: " << seed;
   std::mt19937 rng{seed};
 
-  testFlatmapAsMapFieldLifeCycle(schema, config, rng, batchSize, false);
-  testFlatmapAsMapFieldLifeCycle(schema, config, rng, batchSize, true);
+  testFlatmapAsMapFieldLifeCycle(pool(), schema, config, rng, batchSize, false);
+  testFlatmapAsMapFieldLifeCycle(pool(), schema, config, rng, batchSize, true);
 }
 
-TEST(TestReader, testOrcReaderSimple) {
-  const std::string simpleTest(
-      getExampleFilePath("TestStringDictionary.testRowIndex.orc"));
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  // To make DwrfReader reads ORC file, setFileFormat to FileFormat::ORC
-  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(simpleTest, readerOpts.getMemoryPool()),
-      readerOpts);
-
-  RowReaderOptions rowReaderOptions;
-  auto rowReader = reader->createRowReader(rowReaderOptions);
-
-  VectorPtr batch;
-  const std::string stringPrefix{"row "};
-  size_t rowNumber = 0;
-  while (rowReader->next(500, batch)) {
-    auto rowVector = batch->as<RowVector>();
-    auto strings = rowVector->childAt(0)->as<SimpleVector<StringView>>();
-    for (size_t i = 0; i < rowVector->size(); ++i) {
-      std::stringstream stream;
-      stream << std::setfill('0') << std::setw(6) << rowNumber;
-      EXPECT_EQ(stringPrefix + stream.str(), strings->valueAt(i).str());
-      rowNumber++;
-    }
-  }
-  EXPECT_EQ(rowNumber, 32768);
-}
-
-TEST(TestReader, testFooterWrapper) {
+TEST_F(TestReader, testFooterWrapper) {
   proto::Footer impl;
   FooterWrapper wrapper(&impl);
   EXPECT_FALSE(wrapper.hasNumberOfRows());
@@ -2156,7 +2029,7 @@ TEST(TestReader, testFooterWrapper) {
   EXPECT_EQ(wrapper.numberOfRows(), 0);
 }
 
-TEST(TestReader, testOrcAndDwrfRowIndexStride) {
+TEST_F(TestReader, testOrcAndDwrfRowIndexStride) {
   // orc footer
   proto::orc::Footer orcFooter;
   FooterWrapper orcFooterWrapper(&orcFooter);
@@ -2173,103 +2046,8 @@ TEST(TestReader, testOrcAndDwrfRowIndexStride) {
   ASSERT_TRUE(dwrfFooterWrapper.hasRowIndexStride());
   EXPECT_EQ(dwrfFooterWrapper.rowIndexStride(), 100);
 }
-
-TEST(TestReader, testOrcReaderComplexTypes) {
-  const std::string icebergOrc(getExampleFilePath("complextypes_iceberg.orc"));
-  const std::shared_ptr<const RowType> expectedType =
-      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse("struct<\
-      id:bigint,int_array:array<int>,int_array_array:array<array<int>>,\
-      int_map:map<string,int>,int_map_array:array<map<string,int>>,\
-      nested_struct:struct<\
-        a:int,b:array<int>,c:struct<\
-          d:array<array<struct<\
-            e:int,f:string>>>>,\
-          g:map<string,struct<\
-            h:struct<\
-              i:array<double>>>>>>"));
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(icebergOrc, readerOpts.getMemoryPool()),
-      readerOpts);
-  auto rowType = reader->rowType();
-  EXPECT_TRUE(rowType->equivalent(*expectedType));
-}
-
-TEST(TestReader, testOrcReaderVarchar) {
-  const std::string varcharOrc(getExampleFilePath("orc_index_int_string.orc"));
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(varcharOrc, readerOpts.getMemoryPool()),
-      readerOpts);
-
-  RowReaderOptions rowReaderOptions;
-  auto rowReader = reader->createRowReader(rowReaderOptions);
-
-  VectorPtr batch;
-  int counter = 0;
-  while (rowReader->next(500, batch)) {
-    auto rowVector = batch->as<RowVector>();
-    auto ints = rowVector->childAt(0)->as<SimpleVector<int32_t>>();
-    auto strings = rowVector->childAt(1)->as<SimpleVector<StringView>>();
-    for (size_t i = 0; i < rowVector->size(); ++i) {
-      counter++;
-      EXPECT_EQ(counter, ints->valueAt(i));
-      std::stringstream stream;
-      stream << counter;
-      if (counter < 1000) {
-        stream << "a";
-      }
-      EXPECT_EQ(stream.str(), strings->valueAt(i).str());
-    }
-  }
-  EXPECT_EQ(counter, 6000);
-}
-
-TEST(TestReader, testOrcReaderDate) {
-  const std::string dateOrc(getExampleFilePath("TestOrcFile.testDate1900.orc"));
-  dwio::common::ReaderOptions readerOpts{getDefaultPool().get()};
-  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
-  auto reader = DwrfReader::create(
-      createFileBufferedInput(dateOrc, readerOpts.getMemoryPool()), readerOpts);
-
-  RowReaderOptions rowReaderOptions;
-  auto rowReader = reader->createRowReader(rowReaderOptions);
-
-  VectorPtr batch;
-  int year = 1900;
-  while (rowReader->next(1000, batch)) {
-    auto rowVector = batch->as<RowVector>();
-    auto dates = rowVector->childAt(1)->as<SimpleVector<int32_t>>();
-
-    std::stringstream stream;
-    stream << year << "-12-25";
-    EXPECT_EQ(stream.str(), DATE()->toString(dates->valueAt(0)));
-
-    for (size_t i = 1; i < rowVector->size(); ++i) {
-      EXPECT_EQ(dates->valueAt(0), dates->valueAt(i));
-    }
-
-    year++;
-  }
-}
-
 namespace {
 
-std::vector<VectorPtr> createBatches(
-    const std::vector<std::vector<int32_t>>& integerValues,
-    memory::MemoryPool& pool) {
-  std::vector<VectorPtr> batches;
-  VectorMaker maker(&pool);
-  for (auto i = 0; i < integerValues.size(); ++i) {
-    auto vector = maker.flatVector<int32_t>(integerValues[i]);
-    auto rowVector = maker.rowVector({vector});
-    batches.push_back(rowVector);
-  }
-  return batches;
-}
-
 /*
  * Verifies that row numbers are equal to values in first column
  */
@@ -2296,13 +2074,13 @@ void verifyRowNumbers(
 std::pair<std::unique_ptr<dwrf::Writer>, std::unique_ptr<DwrfReader>>
 createWriterReader(
     const std::vector<VectorPtr>& batches,
-    memory::MemoryPool& pool,
+    memory::MemoryPool* pool,
     const std::shared_ptr<dwrf::Config>& config =
         std::make_shared<dwrf::Config>(),
     std::function<std::unique_ptr<DWRFFlushPolicy>()> flushPolicy =
         E2EWriterTestUtil::simpleFlushPolicyFactory(true)) {
   auto sink =
-      std::make_unique<MemorySink>(1 << 20, FileSink::Options{.pool = &pool});
+      std::make_unique<MemorySink>(1 << 20, FileSink::Options{.pool = pool});
   auto* sinkPtr = sink.get();
   auto writer = E2EWriterTestUtil::writeData(
       std::move(sink),
@@ -2310,10 +2088,10 @@ createWriterReader(
       batches,
       config,
       std::move(flushPolicy));
-  std::string_view data(sinkPtr->data(), sinkPtr->size());
+  std::string data(sinkPtr->data(), sinkPtr->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), pool);
-  dwio::common::ReaderOptions readerOpts(&pool);
+      std::make_shared<InMemoryReadFile>(std::move(data)), *pool);
+  dwio::common::ReaderOptions readerOpts(pool);
   readerOpts.setFileFormat(FileFormat::DWRF);
   auto reader = DwrfReader::create(std::move(input), readerOpts);
   return std::make_pair(std::move(writer), std::move(reader));
@@ -2321,7 +2099,7 @@ createWriterReader(
 
 } // namespace
 
-TEST(TestReader, appendRowNumberColumn) {
+TEST_F(TestReader, setRowNumberColumnInfo) {
   std::vector<std::vector<int32_t>> integerValues{
       {0, 1, 2, 3, 4},
       {5, 6, 7},
@@ -2329,20 +2107,23 @@ TEST(TestReader, appendRowNumberColumn) {
       {},
       {9, 10, 11, 12, 13, 14, 15},
   };
-  auto& pool = getDefaultPool();
-  auto batches = createBatches(integerValues, *pool);
+  auto batches = createBatches(integerValues);
   auto schema = asRowType(batches[0]->type());
-  auto [writer, reader] = createWriterReader(batches, *pool);
+  auto [writer, reader] = createWriterReader(batches, pool());
 
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setScanSpec(spec);
-  rowReaderOpts.setAppendRowNumberColumn(true);
+  RowNumberColumnInfo rowNumberColumnInfo;
+  rowNumberColumnInfo.insertPosition = 1;
+  rowNumberColumnInfo.name = "";
+  rowNumberColumnInfo.isExplicit = false;
+  rowReaderOpts.setRowNumberColumnInfo(rowNumberColumnInfo);
   {
     SCOPED_TRACE("Selective no filter");
     auto rowReader = reader->createRowReader(rowReaderOpts);
-    verifyRowNumbers(*rowReader, pool.get(), 16);
+    verifyRowNumbers(*rowReader, pool(), 16);
   }
   spec->childByName("c0")->setFilter(
       common::createBigintValues({1, 4, 5, 7, 11, 14}, false));
@@ -2350,27 +2131,30 @@ TEST(TestReader, appendRowNumberColumn) {
   {
     SCOPED_TRACE("Selective with filter");
     auto rowReader = reader->createRowReader(rowReaderOpts);
-    verifyRowNumbers(*rowReader, pool.get(), 6);
+    verifyRowNumbers(*rowReader, pool(), 6);
   }
 }
 
-TEST(TestReader, reuseRowNumberColumn) {
+TEST_F(TestReader, reuseRowNumberColumn) {
   std::vector<std::vector<int32_t>> integerValues{{0, 1, 2, 3, 4}};
-  auto& pool = getDefaultPool();
-  auto batches = createBatches(integerValues, *pool);
+  auto batches = createBatches(integerValues);
   auto schema = asRowType(batches[0]->type());
-  auto [writer, reader] = createWriterReader(batches, *pool);
+  auto [writer, reader] = createWriterReader(batches, pool());
 
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setScanSpec(spec);
-  rowReaderOpts.setAppendRowNumberColumn(true);
+  RowNumberColumnInfo rowNumberColumnInfo;
+  rowNumberColumnInfo.insertPosition = 1;
+  rowNumberColumnInfo.name = "";
+  rowNumberColumnInfo.isExplicit = false;
+  rowReaderOpts.setRowNumberColumnInfo(rowNumberColumnInfo);
   {
     SCOPED_TRACE("Reuse passed in");
     auto rowReader = reader->createRowReader(rowReaderOpts);
-    auto result = BaseVector::create(
-        ROW({{"c0", INTEGER()}, {"", BIGINT()}}), 0, pool.get());
+    auto result =
+        BaseVector::create(ROW({{"c0", INTEGER()}, {"", BIGINT()}}), 0, pool());
     auto* rowNum = result->asUnchecked<RowVector>()->childAt(1).get();
     ASSERT_EQ(rowReader->next(3, result), 3);
     ASSERT_EQ(rowNum, result->asUnchecked<RowVector>()->childAt(1).get());
@@ -2378,7 +2162,7 @@ TEST(TestReader, reuseRowNumberColumn) {
   {
     SCOPED_TRACE("Reuse generated");
     auto rowReader = reader->createRowReader(rowReaderOpts);
-    auto result = BaseVector::create(ROW({{"c0", INTEGER()}}), 0, pool.get());
+    auto result = BaseVector::create(ROW({{"c0", INTEGER()}}), 0, pool());
     ASSERT_EQ(rowReader->next(3, result), 3);
     auto* rowNum = result->asUnchecked<RowVector>()->childAt(1).get();
     ASSERT_EQ(rowReader->next(3, result), 2);
@@ -2387,8 +2171,8 @@ TEST(TestReader, reuseRowNumberColumn) {
   {
     SCOPED_TRACE("No reuse passed in");
     auto rowReader = reader->createRowReader(rowReaderOpts);
-    auto result = BaseVector::create(
-        ROW({{"c0", INTEGER()}, {"", BIGINT()}}), 0, pool.get());
+    auto result =
+        BaseVector::create(ROW({{"c0", INTEGER()}, {"", BIGINT()}}), 0, pool());
     auto rowNum = result->asUnchecked<RowVector>()->childAt(1);
     ASSERT_EQ(rowReader->next(3, result), 3);
     ASSERT_NE(rowNum.get(), result->asUnchecked<RowVector>()->childAt(1).get());
@@ -2396,7 +2180,7 @@ TEST(TestReader, reuseRowNumberColumn) {
   {
     SCOPED_TRACE("No reuse generated");
     auto rowReader = reader->createRowReader(rowReaderOpts);
-    auto result = BaseVector::create(ROW({{"c0", INTEGER()}}), 0, pool.get());
+    auto result = BaseVector::create(ROW({{"c0", INTEGER()}}), 0, pool());
     ASSERT_EQ(rowReader->next(3, result), 3);
     auto rowNum = result->asUnchecked<RowVector>()->childAt(1);
     ASSERT_EQ(rowReader->next(3, result), 2);
@@ -2406,31 +2190,29 @@ TEST(TestReader, reuseRowNumberColumn) {
     SCOPED_TRACE("No reuse type mismatch");
     auto rowReader = reader->createRowReader(rowReaderOpts);
     auto result = BaseVector::create(
-        ROW({{"c0", INTEGER()}, {"", INTEGER()}}), 0, pool.get());
+        ROW({{"c0", INTEGER()}, {"", INTEGER()}}), 0, pool());
     auto rowNum = result->asUnchecked<RowVector>()->childAt(1);
     ASSERT_EQ(rowReader->next(3, result), 3);
     ASSERT_NE(rowNum.get(), result->asUnchecked<RowVector>()->childAt(1).get());
   }
 }
 
-TEST(TestReader, failToReuseReaderNulls) {
-  auto* pool = getDefaultPool().get();
-  VectorMaker maker(pool);
-  auto c0 = maker.rowVector(
+TEST_F(TestReader, failToReuseReaderNulls) {
+  auto c0 = makeRowVector(
       {"a", "b"},
       {
-          maker.flatVector<int64_t>(11, folly::identity),
-          maker.flatVector<int64_t>(
+          makeFlatVector<int64_t>(11, folly::identity),
+          makeFlatVector<int64_t>(
               11, folly::identity, [](auto i) { return i % 3 == 0; }),
       });
   // Set a null so that the children will not be loaded lazily.
   bits::setNull(c0->mutableRawNulls(), 10);
-  auto data = maker.rowVector({
+  auto data = makeRowVector({
       c0,
-      maker.rowVector({"c"}, {maker.flatVector<int64_t>(11, folly::identity)}),
+      makeRowVector({"c"}, {makeFlatVector<int64_t>(11, folly::identity)}),
   });
   auto schema = asRowType(data->type());
-  auto [writer, reader] = createWriterReader({data}, *pool);
+  auto [writer, reader] = createWriterReader({data}, pool());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   spec->addAllChildFields(*schema);
   spec->childByName("c0")->childByName("a")->setFilter(
@@ -2441,7 +2223,7 @@ TEST(TestReader, failToReuseReaderNulls) {
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setScanSpec(spec);
   auto rowReader = reader->createRowReader(rowReaderOpts);
-  auto result = BaseVector::create(schema, 0, pool);
+  auto result = BaseVector::create(schema, 0, pool());
   ASSERT_EQ(rowReader->next(10, result), 10);
   ASSERT_EQ(result->size(), 5);
   for (int i = 0; i < result->size(); ++i) {
@@ -2449,13 +2231,10 @@ TEST(TestReader, failToReuseReaderNulls) {
   }
 }
 
-TEST(TestReader, readFlatMapsSomeEmpty) {
+TEST_F(TestReader, readFlatMapsSomeEmpty) {
   // Test reading a flat map where the key filter means that some maps are
   // empty.
-  auto* pool = getDefaultPool().get();
-  VectorMaker maker(pool);
-
-  auto keys = maker.flatVector(std::vector<int64_t>{
+  auto keys = makeFlatVector(std::vector<int64_t>{
       1,
       2,
       3,
@@ -2473,17 +2252,17 @@ TEST(TestReader, readFlatMapsSomeEmpty) {
       5,
       6 // map 4 has some selected keys.
   });
-  auto values = maker.flatVector<int64_t>(16, folly::identity);
-  auto maps = maker.mapVector(
-      std::vector<vector_size_t>{0, 6, 9, 12, 16}, keys, values);
-  auto row = maker.rowVector({"a"}, {maps});
+  auto values = makeFlatVector<int64_t>(16, folly::identity);
+  auto maps =
+      makeMapVector(std::vector<vector_size_t>{0, 6, 9, 12, 16}, keys, values);
+  auto row = makeRowVector({"a"}, {maps});
 
   // Set up the config so that the maps are flattened.
   std::shared_ptr<dwrf::Config> config = std::make_shared<dwrf::Config>();
   config->set(dwrf::Config::FLATTEN_MAP, true);
   config->set(dwrf::Config::MAP_FLAT_COLS, {0});
 
-  auto [writer, reader] = createWriterReader({row}, *pool, config);
+  auto [writer, reader] = createWriterReader({row}, pool(), config);
 
   auto schema = asRowType(row->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -2495,7 +2274,7 @@ TEST(TestReader, readFlatMapsSomeEmpty) {
   rowReaderOpts.setScanSpec(spec);
 
   auto rowReader = reader->createRowReader(rowReaderOpts);
-  VectorPtr batch = BaseVector::create(schema, 0, pool);
+  VectorPtr batch = BaseVector::create(schema, 0, pool());
 
   ASSERT_TRUE(rowReader->next(4, batch));
   auto rowVector = batch->as<RowVector>();
@@ -2531,28 +2310,25 @@ TEST(TestReader, readFlatMapsSomeEmpty) {
   validate(3, 2, {1, 2}, {12, 13});
 }
 
-TEST(TestReader, readFlatMapsWithNullMaps) {
+TEST_F(TestReader, readFlatMapsWithNullMaps) {
   // Test reading a flat map where the key filter means that some maps are
   // empty.
-  auto* pool = getDefaultPool().get();
-  VectorMaker maker(pool);
-
   auto keys =
-      maker.flatVector<int64_t>(16, [](vector_size_t row) { return row % 4; });
-  auto values = maker.flatVector<int64_t>(16, folly::identity);
-  auto maps = maker.mapVector(
+      makeFlatVector<int64_t>(16, [](vector_size_t row) { return row % 4; });
+  auto values = makeFlatVector<int64_t>(16, folly::identity);
+  auto maps = makeMapVector(
       std::vector<vector_size_t>{0, 4, 4, 8, 8, 12, 12, 16, 16},
       keys,
       values,
       {1, 3, 5, 7});
-  auto row = maker.rowVector({"a"}, {maps});
+  auto row = makeRowVector({"a"}, {maps});
 
   // Set up the config so that the maps are flattened.
   std::shared_ptr<dwrf::Config> config = std::make_shared<dwrf::Config>();
   config->set(dwrf::Config::FLATTEN_MAP, true);
   config->set(dwrf::Config::MAP_FLAT_COLS, {0});
 
-  auto [writer, reader] = createWriterReader({row}, *pool, config);
+  auto [writer, reader] = createWriterReader({row}, pool(), config);
 
   auto schema = asRowType(row->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -2564,7 +2340,7 @@ TEST(TestReader, readFlatMapsWithNullMaps) {
   rowReaderOpts.setScanSpec(spec);
 
   auto rowReader = reader->createRowReader(rowReaderOpts);
-  VectorPtr batch = BaseVector::create(schema, 0, pool);
+  VectorPtr batch = BaseVector::create(schema, 0, pool());
 
   ASSERT_TRUE(rowReader->next(8, batch));
   auto rowVector = batch->as<RowVector>();
@@ -2601,22 +2377,19 @@ TEST(TestReader, readFlatMapsWithNullMaps) {
   }
 }
 
-TEST(TestReader, readStructWithWholeBatchFiltered) {
+TEST_F(TestReader, readStructWithWholeBatchFiltered) {
   // Test reading a struct with a pushdown filter that filters out all rows
   // for a certain batch.
-  auto* pool = getDefaultPool().get();
-  VectorMaker maker(pool);
-
   auto rowType = ROW({"a"}, {BIGINT()});
   const vector_size_t vectorSize = 20;
   const vector_size_t batchSize = 10;
-  std::vector<VectorPtr> children{maker.flatVector<int64_t>(
+  std::vector<VectorPtr> children{makeFlatVector<int64_t>(
       vectorSize,
       folly::identity,
       // In the first batch, the parent Rows will all be null.
       [&](auto i) { return i < batchSize; })};
 
-  BufferPtr nulls = AlignedBuffer::allocate<bool>(vectorSize, pool);
+  BufferPtr nulls = AlignedBuffer::allocate<bool>(vectorSize, pool());
   uint64_t* rawNulls = nulls->asMutable<uint64_t>();
   memset(rawNulls, bits::kNotNullByte, nulls->capacity());
   // Mark the Row as null in the first batch.
@@ -2625,10 +2398,10 @@ TEST(TestReader, readStructWithWholeBatchFiltered) {
   }
 
   auto c0 =
-      std::make_shared<RowVector>(pool, rowType, nulls, vectorSize, children);
-  auto row = maker.rowVector({"c0"}, {c0});
+      std::make_shared<RowVector>(pool(), rowType, nulls, vectorSize, children);
+  auto row = makeRowVector({"c0"}, {c0});
 
-  auto [writer, reader] = createWriterReader({row}, *pool);
+  auto [writer, reader] = createWriterReader({row}, pool());
 
   auto schema = asRowType(row->type());
   auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -2639,7 +2412,7 @@ TEST(TestReader, readStructWithWholeBatchFiltered) {
   rowReaderOpts.setScanSpec(spec);
 
   auto rowReader = reader->createRowReader(rowReaderOpts);
-  VectorPtr batch = BaseVector::create(schema, 0, pool);
+  VectorPtr batch = BaseVector::create(schema, 0, pool());
 
   ASSERT_TRUE(rowReader->next(batchSize, batch));
   // Confirm that all rows were filtered out.
@@ -2666,25 +2439,23 @@ TEST(TestReader, readStructWithWholeBatchFiltered) {
   }
 }
 
-TEST(TestReader, readStringDictionaryAsFlat) {
+TEST_F(TestReader, readStringDictionaryAsFlat) {
   std::vector<std::string> dictionary;
   for (int i = 0; i < 26; ++i) {
     dictionary.emplace_back(20 + i, 'a' + i);
   }
-  auto* pool = getDefaultPool().get();
-  VectorMaker maker(pool);
-  auto indices = allocateIndices(200, pool);
+  auto indices = allocateIndices(200, pool());
   auto* rawIndices = indices->asMutable<vector_size_t>();
   for (int i = 0; i < 200; ++i) {
     rawIndices[i] = i % dictionary.size();
   }
-  auto batch = maker.rowVector({
+  auto batch = makeRowVector({
       BaseVector::wrapInDictionary(
-          nullptr, indices, 200, maker.flatVector(dictionary)),
+          nullptr, indices, 200, makeFlatVector(dictionary)),
   });
   auto [writer, reader] = createWriterReader(
       {batch},
-      *pool,
+      pool(),
       std::make_shared<dwrf::Config>(),
       // The always true flush policy would disable dictionary encoding at least
       // for first batch.
@@ -2695,7 +2466,7 @@ TEST(TestReader, readStringDictionaryAsFlat) {
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setScanSpec(spec);
   auto rowReader = reader->createRowReader(rowReaderOpts);
-  auto actual = BaseVector::create(rowType, 0, pool);
+  auto actual = BaseVector::create(rowType, 0, pool());
   ASSERT_EQ(rowReader->next(20, actual), 20);
   ASSERT_EQ(actual->size(), 20);
   auto* c0 = actual->as<RowVector>()->childAt(0)->loadedVector();
@@ -2716,3 +2487,102 @@ TEST(TestReader, readStringDictionaryAsFlat) {
   rowReader->updateRuntimeStats(stats);
   ASSERT_EQ(stats.columnReaderStatistics.flattenStringDictionaryValues, 1);
 }
+
+// A primitive subfield is missing in file, and result is not reused.
+TEST_F(TestReader, missingSubfieldsNoResultReusing) {
+  constexpr int kSize = 10;
+  auto batch = makeRowVector({
+      makeRowVector({
+          makeFlatVector<int64_t>(kSize, folly::identity),
+      }),
+  });
+  auto [writer, reader] = createWriterReader({batch}, pool());
+  auto schema = ROW({{"c0", ROW({{"c0", BIGINT()}, {"c1", VARCHAR()}})}});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto actual = BaseVector::create(schema, 0, pool());
+  // Hold a second reference to result so it cannot be reused.
+  auto actual2 = actual;
+  ASSERT_EQ(rowReader->next(1024, actual), 10);
+  auto expected = makeRowVector({
+      makeRowVector({
+          makeFlatVector<int64_t>(kSize, folly::identity),
+          BaseVector::createNullConstant(VARCHAR(), kSize, pool()),
+      }),
+  });
+  assertEqualVectors(expected, actual);
+}
+
+// Ensure there is enough data before switching to fast path.
+TEST_F(TestReader, selectiveStringDirectFastPath) {
+  auto genStr = [](auto i) {
+    return i == 0 ? "x" : i < 8 ? "" : "xxxxxxxxxxx";
+  };
+  auto batch = makeRowVector({
+      makeFlatVector<int64_t>(17, [](auto i) { return i != 8; }),
+      makeFlatVector<StringView>(17, genStr),
+  });
+  auto [writer, reader] = createWriterReader({batch}, pool());
+  auto schema = asRowType(batch->type());
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  spec->childByName("c0")->setFilter(common::createBigintValues({1}, false));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto actual = BaseVector::create(schema, 0, pool());
+  ASSERT_EQ(rowReader->next(1024, actual), batch->size());
+  auto expected = makeRowVector({
+      makeConstant<int64_t>(1, 16),
+      makeFlatVector<StringView>(16, genStr),
+  });
+  assertEqualVectors(expected, actual);
+}
+
+TEST_F(TestReader, selectiveStringDirect) {
+  auto genStr = [](auto i) {
+    static const std::string s(2048, 'x');
+    return i == 0 || i == 8 ? s.c_str() : "";
+  };
+  auto batch = makeRowVector({
+      makeFlatVector<int64_t>(17, [](auto i) { return i != 15; }),
+      makeFlatVector<StringView>(17, genStr),
+  });
+  auto [writer, reader] = createWriterReader({batch}, pool());
+  auto schema = asRowType(batch->type());
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  spec->childByName("c0")->setFilter(common::createBigintValues({1}, false));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto actual = BaseVector::create(schema, 0, pool());
+  ASSERT_EQ(rowReader->next(1024, actual), batch->size());
+  auto expected = makeRowVector({
+      makeConstant<int64_t>(1, 16),
+      makeFlatVector<StringView>(16, genStr),
+  });
+  assertEqualVectors(expected, actual);
+}
+
+TEST_F(TestReader, selectiveFlatMapFastPathAllInlinedStringKeys) {
+  auto maps = makeMapVector<std::string, int64_t>(
+      {{{"a", 0}, {"b", 0}}, {{"a", 1}, {"b", 1}}});
+  auto row = makeRowVector({"c0"}, {maps});
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set(dwrf::Config::MAP_FLAT_COLS, {0});
+  auto [writer, reader] = createWriterReader({row}, pool(), config);
+  auto schema = asRowType(row->type());
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr batch = BaseVector::create(schema, 0, pool());
+  ASSERT_EQ(rowReader->next(10, batch), 2);
+  assertEqualVectors(batch, row);
+}
diff --git a/velox/dwio/dwrf/test/StreamLabelsTests.cpp b/velox/dwio/dwrf/test/StreamLabelsTests.cpp
index 9d4abf570d7a4..c189db26d6165 100644
--- a/velox/dwio/dwrf/test/StreamLabelsTests.cpp
+++ b/velox/dwio/dwrf/test/StreamLabelsTests.cpp
@@ -22,8 +22,15 @@ using namespace ::testing;
 using facebook::velox::memory::AllocationPool;
 using namespace facebook::velox::dwrf;
 
-TEST(StreamLabelsTest, E2E) {
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+class StreamLabelsTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    facebook::velox::memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(StreamLabelsTest, E2E) {
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
   AllocationPool allocationPool(pool.get());
   StreamLabels root(allocationPool);
   auto c0 = root.append("c0");
diff --git a/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp b/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
index d27a81139edda..1ed91ed929fa0 100644
--- a/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
+++ b/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include "velox/dwio/common/encryption/TestProvider.h"
@@ -33,104 +34,104 @@ namespace facebook::velox::dwrf {
 
 class StripeLoadKeysTest : public Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
     HiveTypeParser parser;
     auto type = parser.parse("struct<a:int>");
-    auto footer =
-        google::protobuf::Arena::CreateMessage<proto::Footer>(&arena_);
-    ProtoUtils::writeType(*type, *footer);
-    auto enc = footer->mutable_encryption();
+    footer_ = std::make_unique<proto::Footer>();
+    ProtoUtils::writeType(*type, *footer_);
+    auto enc = footer_->mutable_encryption();
     enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
     auto group = enc->add_encryptiongroups();
     group->add_nodes(1);
     group->add_statistics();
     group->set_keymetadata("footer");
 
-    auto stripe = footer->add_stripes();
+    auto stripe = footer_->add_stripes();
     *stripe->add_keymetadata() = "stripe0";
 
-    stripe = footer->add_stripes();
-    stripe = footer->add_stripes();
+    stripe = footer_->add_stripes();
+    stripe = footer_->add_stripes();
     *stripe->add_keymetadata() = "stripe2";
 
-    stripe = footer->add_stripes();
+    stripe = footer_->add_stripes();
     *stripe->add_keymetadata() = "stripe3.1";
     *stripe->add_keymetadata() = "stripe3.2";
 
-    auto stripeFooter =
-        google::protobuf::Arena::CreateMessage<proto::StripeFooter>(&arena_);
-    stripeFooter->add_encryptiongroups();
-
     TestDecrypterFactory factory;
-    auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
-    pool_ = addDefaultLeafMemoryPool();
+    auto handler =
+        DecryptionHandler::create(FooterWrapper(footer_.get()), &factory);
+    pool_ = memoryManager()->addLeafPool();
 
     reader_ = std::make_unique<ReaderBase>(
         *pool_,
         std::make_unique<BufferedInput>(
             std::make_shared<InMemoryReadFile>(std::string()), *pool_),
         nullptr,
-        footer,
+        footer_.get(),
         nullptr,
         std::move(handler));
-    stripeReader_ =
-        std::make_unique<StripeReaderBase>(reader_, std::move(stripeFooter));
-    enc_ = const_cast<TestEncryption*>(
-        std::addressof(dynamic_cast<const TestEncryption&>(
-            stripeReader_->getDecryptionHandler().getEncryptionProviderByIndex(
-                0))));
+
+    stripeReader_ = std::make_unique<StripeReaderBase>(reader_);
   }
 
-  void runTest(std::optional<uint32_t> prevIndex, uint32_t newIndex) {
-    stripeReader_->lastStripeIndex_ = prevIndex;
-    stripeReader_->loadEncryptionKeys(newIndex);
+  void runTest(uint32_t index) {
+    auto stripeFooter = std::make_unique<proto::StripeFooter>();
+    stripeFooter->add_encryptiongroups();
+    stripeFooter_ = std::move(stripeFooter);
+
+    stripeInfo_ = std::make_unique<const StripeInformationWrapper>(
+        FooterWrapper(footer_.get()).stripes(index));
+
+    auto handler = std::make_unique<encryption::DecryptionHandler>(
+        reader_->decryptionHandler());
+
+    stripeReader_->loadEncryptionKeys(
+        index, *stripeFooter_, *stripeInfo_, *handler);
+
+    handler_ = std::move(handler);
+
+    enc_ = const_cast<TestEncryption*>(
+        std::addressof(dynamic_cast<const TestEncryption&>(
+            handler_->getEncryptionProviderByIndex(0))));
   }
 
-  google::protobuf::Arena arena_;
+  std::unique_ptr<proto::Footer> footer_;
   std::shared_ptr<ReaderBase> reader_;
   std::unique_ptr<StripeReaderBase> stripeReader_;
   TestEncryption* enc_;
   std::shared_ptr<MemoryPool> pool_;
+  std::unique_ptr<const proto::StripeFooter> stripeFooter_;
+  std::unique_ptr<const encryption::DecryptionHandler> handler_;
+  std::unique_ptr<const StripeInformationWrapper> stripeInfo_;
 };
 
 } // namespace facebook::velox::dwrf
 
 TEST_F(StripeLoadKeysTest, FirstStripeHasKey) {
-  ASSERT_EQ(enc_->getKey(), "footer");
-
-  runTest(std::optional<uint32_t>(), 0);
-  ASSERT_EQ(enc_->getKey(), "stripe0");
-}
-
-TEST_F(StripeLoadKeysTest, FirstStripeNoKey) {
-  ASSERT_EQ(enc_->getKey(), "footer");
-
-  runTest(std::optional<uint32_t>(), 1);
+  runTest(0);
   ASSERT_EQ(enc_->getKey(), "stripe0");
 }
 
-TEST_F(StripeLoadKeysTest, SeekToStripeNoKey) {
-  ASSERT_EQ(enc_->getKey(), "footer");
-
-  runTest(2, 1);
+TEST_F(StripeLoadKeysTest, SecondStripeNoKey) {
+  runTest(1);
   ASSERT_EQ(enc_->getKey(), "stripe0");
 }
 
-TEST_F(StripeLoadKeysTest, ContinueSameKey) {
-  ASSERT_EQ(enc_->getKey(), "footer");
-
-  runTest(0, 1);
-  ASSERT_EQ(enc_->getKey(), "footer");
-}
-
-TEST_F(StripeLoadKeysTest, ContinueDifferentKey) {
-  ASSERT_EQ(enc_->getKey(), "footer");
-
-  runTest(1, 2);
+TEST_F(StripeLoadKeysTest, ThirdStripeHasKey) {
+  runTest(2);
   ASSERT_EQ(enc_->getKey(), "stripe2");
 }
 
 TEST_F(StripeLoadKeysTest, KeyMismatch) {
-  ASSERT_THROW(
-      runTest(std::optional<uint32_t>(), 3), exception::LoggedException);
+  EXPECT_THAT(
+      [&]() { runTest(3); },
+      Throws<facebook::velox::dwio::common::exception::LoggedException>(
+          Property(
+              &facebook::velox::dwio::common::exception::LoggedException::
+                  failingExpression,
+              HasSubstr("keys.size() == providers_.size()"))));
 }
diff --git a/velox/dwio/dwrf/test/TestBufferedOutputStream.cpp b/velox/dwio/dwrf/test/TestBufferedOutputStream.cpp
index ededfdbde9ae7..8b3bcd99fa5cb 100644
--- a/velox/dwio/dwrf/test/TestBufferedOutputStream.cpp
+++ b/velox/dwio/dwrf/test/TestBufferedOutputStream.cpp
@@ -24,12 +24,20 @@ using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::memory;
 using namespace facebook::velox::dwrf;
 
-TEST(BufferedOutputStream, blockAligned) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(1024, {.pool = pool.get()});
+class BufferedOutputStreamTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+
+TEST_F(BufferedOutputStreamTest, blockAligned) {
+  MemorySink memSink(1024, {.pool = pool_.get()});
 
   uint64_t block = 10;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
   BufferedOutputStream bufStream(holder);
   for (int32_t i = 0; i < 100; ++i) {
     char* buf;
@@ -48,12 +56,11 @@ TEST(BufferedOutputStream, blockAligned) {
   }
 }
 
-TEST(BufferedOutputStream, blockNotAligned) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(1024, {.pool = pool.get()});
+TEST_F(BufferedOutputStreamTest, blockNotAligned) {
+  MemorySink memSink(1024, {.pool = pool_.get()});
 
   uint64_t block = 10;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
   BufferedOutputStream bufStream(holder);
 
   char* buf;
@@ -93,12 +100,11 @@ TEST(BufferedOutputStream, blockNotAligned) {
   }
 }
 
-TEST(BufferedOutputStream, protoBufSerialization) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(1024, {.pool = pool.get()});
+TEST_F(BufferedOutputStreamTest, protoBufSerialization) {
+  MemorySink memSink(1024, {.pool = pool_.get()});
 
   uint64_t block = 10;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
   BufferedOutputStream bufStream(holder);
 
   proto::PostScript ps;
@@ -118,13 +124,12 @@ TEST(BufferedOutputStream, protoBufSerialization) {
   ASSERT_EQ(ps.writerversion(), ps2.writerversion());
 }
 
-TEST(BufferedOutputStream, increaseSize) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(1024, {.pool = pool.get()});
+TEST_F(BufferedOutputStreamTest, increaseSize) {
+  MemorySink memSink(1024, {.pool = pool_.get()});
 
   uint64_t max = 512;
   uint64_t min = 16;
-  DataBufferHolder holder{*pool, max, min, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, max, min, DEFAULT_PAGE_GROW_RATIO, &memSink};
   BufferedOutputStream bufStream(holder);
 
   char* buf;
@@ -173,13 +178,12 @@ TEST(BufferedOutputStream, increaseSize) {
   }
 }
 
-TEST(BufferedOutputStream, recordPosition) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(1024, {.pool = pool.get()});
+TEST_F(BufferedOutputStreamTest, recordPosition) {
+  MemorySink memSink(1024, {.pool = pool_.get()});
   uint64_t block = 256;
   uint64_t initial = 128;
   DataBufferHolder holder{
-      *pool, block, initial, DEFAULT_PAGE_GROW_RATIO, &memSink};
+      *pool_, block, initial, DEFAULT_PAGE_GROW_RATIO, &memSink};
   BufferedOutputStream bufStream(holder);
 
   TestPositionRecorder recorder;
@@ -233,11 +237,19 @@ TEST(BufferedOutputStream, recordPosition) {
   EXPECT_EQ(pos.at(0), block + 100);
 }
 
-TEST(AppendOnlyBufferedStream, Basic) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(1024, {.pool = pool.get()});
+class AppendOnlyBufferedStreamTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+
+TEST_F(AppendOnlyBufferedStreamTest, Basic) {
+  MemorySink memSink(1024, {.pool = pool_.get()});
   uint64_t block = 10;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
   auto bufStream = std::make_unique<BufferedOutputStream>(holder);
   AppendOnlyBufferedStream appendable(std::move(bufStream));
 
diff --git a/velox/dwio/dwrf/test/TestByteRLEEncoder.cpp b/velox/dwio/dwrf/test/TestByteRLEEncoder.cpp
index b03c304141c5c..fb3c7ddf1b8a3 100644
--- a/velox/dwio/dwrf/test/TestByteRLEEncoder.cpp
+++ b/velox/dwio/dwrf/test/TestByteRLEEncoder.cpp
@@ -110,8 +110,15 @@ void decodeAndVerifyBoolean(
   delete[] decodedData;
 }
 
-TEST(ByteRleEncoder, random_chars) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+class ByteRleEncoderTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(ByteRleEncoderTest, random_chars) {
+  auto pool = memory::memoryManager()->addLeafPool();
   MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
 
   uint64_t block = 1024;
@@ -130,8 +137,8 @@ TEST(ByteRleEncoder, random_chars) {
   delete[] data;
 }
 
-TEST(ByteRleEncoder, random_chars_with_null) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(ByteRleEncoderTest, random_chars_with_null) {
+  auto pool = memory::memoryManager()->addLeafPool();
   MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
 
   uint64_t block = 1024;
@@ -152,8 +159,15 @@ TEST(ByteRleEncoder, random_chars_with_null) {
   delete[] nulls;
 }
 
-TEST(BooleanRleEncoder, random_bits_not_aligned) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+class BooleanRleEncoderTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(BooleanRleEncoderTest, random_bits_not_aligned) {
+  auto pool = memory::memoryManager()->addLeafPool();
   MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
 
   uint64_t block = 1024;
@@ -172,8 +186,8 @@ TEST(BooleanRleEncoder, random_bits_not_aligned) {
   delete[] data;
 }
 
-TEST(BooleanRleEncoder, random_bits_aligned) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(BooleanRleEncoderTest, random_bits_aligned) {
+  auto pool = memory::memoryManager()->addLeafPool();
   MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
 
   uint64_t block = 1024;
@@ -192,8 +206,8 @@ TEST(BooleanRleEncoder, random_bits_aligned) {
   delete[] data;
 }
 
-TEST(BooleanRleEncoder, random_bits_aligned_with_null) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(BooleanRleEncoderTest, random_bits_aligned_with_null) {
+  auto pool = memory::memoryManager()->addLeafPool();
   MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
 
   uint64_t block = 1024;
diff --git a/velox/dwio/dwrf/test/TestByteRle.cpp b/velox/dwio/dwrf/test/TestByteRle.cpp
index 25c3e1dd9cdd0..ad19d341a50a2 100644
--- a/velox/dwio/dwrf/test/TestByteRle.cpp
+++ b/velox/dwio/dwrf/test/TestByteRle.cpp
@@ -17,6 +17,7 @@
 #include <folly/Random.h>
 #include <gtest/gtest.h>
 #include <vector>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/exception/Exception.h"
 #include "velox/dwio/dwrf/common/ByteRLE.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
@@ -911,14 +912,15 @@ TEST(ByteRle, testSeek) {
   PositionProvider pp{position};
   rle->seekToRowGroup(pp);
   // Seek is fine, but read should fail
-  EXPECT_THROW(rle->next(data.data(), 1, nullptr), exception::LoggedException);
+  VELOX_ASSERT_THROW(rle->next(data.data(), 1, nullptr), "");
 
   // Seek to end + 1
   position.clear();
   position.push_back(VELOX_ARRAY_SIZE(buffer));
   position.push_back(1);
   PositionProvider pp2{position};
-  EXPECT_THROW(rle->seekToRowGroup(pp2), exception::LoggedException);
+  rle->seekToRowGroup(pp2);
+  VELOX_ASSERT_THROW(rle->next(data.data(), 1, nullptr), "");
 }
 
 TEST(BooleanRle, simpleTest) {
@@ -1200,15 +1202,12 @@ TEST(BooleanRle, skipTestWithNulls) {
   std::unique_ptr<SeekableInputStream> stream(
       new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
-  std::vector<char> data;
-  // Buffers are expected to be writable in full words. Init a full
-  // word for valgrind, then resize to actually used size.
-  data.resize(bits::roundUp(3, 8));
+  raw_vector<char> data;
   data.resize(3);
   std::vector<uint64_t> someNull(1, ~0x0505050505050505);
   std::vector<uint64_t> allNull(1, bits::kNull64);
   for (size_t i = 0; i < 16384; i += 5) {
-    data.assign(data.size(), -1);
+    std::fill(data.begin(), data.end(), -1);
     rle->next(data.data(), data.size(), someNull.data());
     EXPECT_EQ(0, bits::isBitSet(data.data(), 0)) << "Output wrong at " << i;
     EXPECT_EQ(0, bits::isBitSet(data.data(), 2)) << "Output wrong at " << i;
@@ -1218,7 +1217,7 @@ TEST(BooleanRle, skipTestWithNulls) {
       rle->skip(4);
     }
     rle->skip(0);
-    data.assign(data.size(), -1);
+    std::fill(data.begin(), data.end(), -1);
     ;
     rle->next(data.data(), data.size(), allNull.data());
     for (size_t j = 0; j < data.size(); ++j) {
@@ -1502,17 +1501,25 @@ TEST(BooleanRle, seekTestWithNulls) {
       0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c,
       0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c, 0x71, 0xc7, 0x1c,
       0x71, 0xc7, 0x1c, 0x71};
-  std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
-  std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
+  auto* stream = new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer));
+  auto rle = createBooleanDecoder(std::unique_ptr<SeekableInputStream>(stream));
+  ASSERT_EQ(stream->totalRead(), 0);
+  auto lastTotalReadBytes = stream->totalRead();
+  auto getNumReadBytes = [&] {
+    auto ans = stream->totalRead() - lastTotalReadBytes;
+    lastTotalReadBytes = stream->totalRead();
+    return ans;
+  };
   std::vector<char> data(NUM_VALUES);
   std::vector<uint64_t> allNull(256, bits::kNull64);
   std::vector<uint64_t> noNull(256, bits::kNotNull64);
   rle->next(data.data(), data.size(), allNull.data());
+  ASSERT_EQ(getNumReadBytes(), 0);
   for (size_t i = 0; i < data.size(); ++i) {
     EXPECT_EQ(0, bits::isBitSet(data.data(), i)) << "Output wrong at " << i;
   }
   rle->next(data.data(), data.size(), noNull.data());
+  ASSERT_EQ(getNumReadBytes(), VELOX_ARRAY_SIZE(buffer));
   for (size_t i = 0; i < data.size(); ++i) {
     EXPECT_EQ(i < 8192 ? i & 1 : (i / 3) & 1, bits::isBitSet(data.data(), i))
         << "Output wrong at " << i;
@@ -1537,12 +1544,15 @@ TEST(BooleanRle, seekTestWithNulls) {
     --i;
     PositionProvider location(positions[i]);
     rle->seekToRowGroup(location);
+    ASSERT_EQ(getNumReadBytes(), 0);
     char readByte;
     rle->next(&readByte, 1, noNull.data());
+    ASSERT_GT(getNumReadBytes(), 0);
     EXPECT_EQ(i < 8192 ? i & 1 : (i / 3) & 1, readByte & 1)
         << "Output wrong at " << i;
     bits::setBit(&readByte, 0, 1);
     rle->next(&readByte, 1, allNull.data());
+    ASSERT_EQ(getNumReadBytes(), 0);
     EXPECT_FALSE(bits::isBitSet(&readByte, 0)) << "Output wrong at " << i;
   } while (i != 0);
 }
@@ -1592,7 +1602,7 @@ TEST(BooleanRle, skipToEnd) {
   rle->next(value, 1, nullptr);
   rle->skip(15);
   // additional read will fail
-  ASSERT_THROW(rle->next(value, 1, nullptr), exception::LoggedException);
+  VELOX_ASSERT_THROW(rle->next(value, 1, nullptr), "");
 }
 
 TEST(BooleanRle, longReadTest) {
diff --git a/velox/dwio/dwrf/test/TestColumnReader.cpp b/velox/dwio/dwrf/test/TestColumnReader.cpp
index c1e20499db139..ef055a29f2fbd 100644
--- a/velox/dwio/dwrf/test/TestColumnReader.cpp
+++ b/velox/dwio/dwrf/test/TestColumnReader.cpp
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
+#include "folly/executors/CPUThreadPoolExecutor.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/encode/Coding.h"
-#include "velox/dwio/common/Adaptor.h"
 #include "velox/dwio/common/exception/Exceptions.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 #include "velox/dwio/dwrf/reader/ColumnReader.h"
@@ -116,33 +116,37 @@ class ColumnReaderTestBase {
 
   void buildReader(
       const std::shared_ptr<const Type>& requestedType,
+      const std::shared_ptr<const Type>& fileType = nullptr,
       std::vector<uint64_t> nodes = {},
-      const std::shared_ptr<const Type>& dataType = nullptr,
       common::ScanSpec* scanSpec = nullptr) {
     const std::shared_ptr<const RowType>& rowType =
         std::dynamic_pointer_cast<const RowType>(requestedType);
+    if (parallelDecoding()) {
+      executor_ = std::make_unique<folly::CPUThreadPoolExecutor>(2);
+    }
     ColumnSelector cs(rowType, nodes, true);
     auto options = RowReaderOptions();
     options.setReturnFlatVector(returnFlatVector());
+    options.setTimestampPrecision(TimestampPrecision::kNanoseconds);
 
     EXPECT_CALL(streams_, getColumnSelectorProxy())
         .WillRepeatedly(testing::Return(&cs));
     EXPECT_CALL(streams_, getRowReaderOptionsProxy())
         .WillRepeatedly(testing::Return(&options));
 
-    auto dataTypeWithId =
-        TypeWithId::create(dataType ? dataType : requestedType);
+    std::shared_ptr<const TypeWithId> fileTypeWithId =
+        TypeWithId::create(fileType ? fileType : requestedType);
 
     if (useSelectiveReader()) {
       if (!scanSpec) {
         scanSpec_ = std::make_unique<common::ScanSpec>("root");
-        scanSpec_->addAllChildFields(*dataTypeWithId->type());
+        scanSpec_->addAllChildFields(*fileTypeWithId->type());
         scanSpec = scanSpec_.get();
       }
       makeFieldSpecs("", 0, rowType, scanSpec);
       selectiveColumnReader_ = SelectiveDwrfReader::build(
-          cs.getSchemaWithId(),
-          dataTypeWithId,
+          cs.getSchema(),
+          fileTypeWithId,
           streams_,
           labels_,
           columnReaderStatistics_,
@@ -152,7 +156,12 @@ class ColumnReaderTestBase {
       columnReader_ = nullptr;
     } else {
       columnReader_ = ColumnReader::build(
-          cs.getSchemaWithId(), dataTypeWithId, streams_, labels_);
+          cs.getSchemaWithId(),
+          fileTypeWithId,
+          streams_,
+          labels_,
+          executor_.get(),
+          parallelDecoding() ? 2 : 0);
       selectiveColumnReader_ = nullptr;
     }
   }
@@ -203,16 +212,21 @@ class ColumnReaderTestBase {
     } else {
       selectiveColumnReader_.reset(nullptr);
     }
+    if (executor_) {
+      executor_.reset();
+    }
   }
 
   virtual bool useSelectiveReader() const = 0;
   virtual bool returnFlatVector() const = 0;
+  virtual bool parallelDecoding() const = 0;
 
   MockStripeStreams streams_;
   memory::AllocationPool pool_;
   StreamLabels labels_;
   std::unique_ptr<ColumnReader> columnReader_;
   std::unique_ptr<SelectiveColumnReader> selectiveColumnReader_;
+  std::unique_ptr<folly::Executor> executor_;
 
  private:
   std::unique_ptr<common::ScanSpec> scanSpec_;
@@ -223,12 +237,14 @@ struct StringReaderTestParams {
   const bool useSelectiveReader;
   const bool returnFlatVector;
   const bool expectMemoryReuse;
+  const bool parallelDecoding;
 
   std::string toString() const {
     std::ostringstream out;
     out << (useSelectiveReader ? "selective" : "") << "_"
         << (returnFlatVector ? "as_flat" : "") << "_"
-        << (expectMemoryReuse ? "reuse" : "");
+        << (expectMemoryReuse ? "reuse" : "") << "_"
+        << (parallelDecoding ? "parallel" : "");
     return out.str();
   }
 };
@@ -237,9 +253,15 @@ class StringReaderTests
     : public ::testing::TestWithParam<StringReaderTestParams>,
       public ColumnReaderTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   StringReaderTests()
-      : expectMemoryReuse_{GetParam().expectMemoryReuse},
-        returnFlatVector_{GetParam().returnFlatVector} {}
+      : useSelectiveReader_{GetParam().useSelectiveReader},
+        returnFlatVector_{GetParam().returnFlatVector},
+        expectMemoryReuse_{GetParam().expectMemoryReuse},
+        parallelDecoding_{GetParam().parallelDecoding} {}
 
   VectorPtr newBatch(const TypePtr& rowType) const {
     return useSelectiveReader()
@@ -255,26 +277,34 @@ class StringReaderTests
     }
   }
 
-  const bool expectMemoryReuse_;
+  const bool useSelectiveReader_;
   const bool returnFlatVector_;
+  const bool expectMemoryReuse_;
+  const bool parallelDecoding_;
 
   bool useSelectiveReader() const override {
-    return GetParam().useSelectiveReader;
+    return useSelectiveReader_;
   }
 
   bool returnFlatVector() const override {
     return returnFlatVector_;
   }
+
+  bool parallelDecoding() const override {
+    return parallelDecoding_;
+  }
 };
 
 struct ReaderTestParams {
   const bool useSelectiveReader;
   const bool expectMemoryReuse;
+  const bool parallelDecoding;
 
   std::string toString() const {
     std::ostringstream out;
     out << (useSelectiveReader ? "selective" : "") << "_"
-        << (expectMemoryReuse ? "reuse" : "");
+        << (expectMemoryReuse ? "reuse" : "") << "_"
+        << (parallelDecoding ? "parallel" : "");
     return out.str();
   }
 };
@@ -282,7 +312,14 @@ struct ReaderTestParams {
 class TestColumnReader : public testing::TestWithParam<ReaderTestParams>,
                          public ColumnReaderTestBase {
  protected:
-  TestColumnReader() : expectMemoryReuse_{GetParam().expectMemoryReuse} {}
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  TestColumnReader()
+      : useSelectiveReader_{GetParam().useSelectiveReader},
+        expectMemoryReuse_{GetParam().expectMemoryReuse},
+        parallelDecoding_{GetParam().parallelDecoding} {}
 
   VectorPtr newBatch(const TypePtr& rowType) const {
     return useSelectiveReader()
@@ -302,22 +339,47 @@ class TestColumnReader : public testing::TestWithParam<ReaderTestParams>,
     }
   }
 
+  const bool useSelectiveReader_;
+  const bool expectMemoryReuse_;
+  const bool parallelDecoding_;
+
   bool useSelectiveReader() const override {
-    return GetParam().useSelectiveReader;
+    return useSelectiveReader_;
   }
 
   bool returnFlatVector() const override {
     return false;
   }
 
-  const bool expectMemoryReuse_;
+  bool parallelDecoding() const override {
+    return parallelDecoding_;
+  }
+};
+
+struct NonSelectiveReaderTestParams {
+  const bool expectMemoryReuse;
+  const bool parallelDecoding;
+
+  std::string toString() const {
+    std::ostringstream out;
+    out << (expectMemoryReuse ? "reuse" : "") << "_"
+        << (parallelDecoding ? "parallel" : "");
+    return out.str();
+  }
 };
 
 // For test cases where SelectiveColumnReader does not have support.
-class TestNonSelectiveColumnReader : public testing::TestWithParam<bool>,
-                                     public ColumnReaderTestBase {
+class TestNonSelectiveColumnReader
+    : public testing::TestWithParam<NonSelectiveReaderTestParams>,
+      public ColumnReaderTestBase {
  protected:
-  TestNonSelectiveColumnReader() : expectMemoryReuse_{GetParam()} {}
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  TestNonSelectiveColumnReader()
+      : expectMemoryReuse_{GetParam().expectMemoryReuse},
+        parallelDecoding_{GetParam().parallelDecoding} {}
 
   VectorPtr newBatch(const TypePtr& rowType) const {
     return nullptr;
@@ -339,36 +401,68 @@ class TestNonSelectiveColumnReader : public testing::TestWithParam<bool>,
     return false;
   }
 
+  bool parallelDecoding() const override {
+    return parallelDecoding_;
+  }
+
   const bool expectMemoryReuse_;
+  const bool parallelDecoding_;
+};
+
+struct SchemaMismatchTestParam {
+  const bool useSelectiveReader;
+  const bool parallelDecoding;
+
+  std::string toString() const {
+    std::ostringstream out;
+    out << (useSelectiveReader ? "selective" : "") << "_"
+        << (parallelDecoding ? "parallel" : "");
+    return out.str();
+  }
 };
 
-class SchemaMismatchTest : public TestWithParam<bool>,
+class SchemaMismatchTest : public TestWithParam<SchemaMismatchTestParam>,
                            public ColumnReaderTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  SchemaMismatchTest()
+      : useSelectiveReader_{GetParam().useSelectiveReader},
+        parallelDecoding_{GetParam().parallelDecoding} {}
+
   VectorPtr newBatch(const TypePtr& rowType) {
     return useSelectiveReader()
         ? BaseVector::create(rowType, 0, &streams_.getMemoryPool())
         : nullptr;
   }
 
+  const bool useSelectiveReader_;
+  const bool parallelDecoding_;
+
   bool useSelectiveReader() const override {
-    return GetParam();
+    return useSelectiveReader_;
   }
 
   bool returnFlatVector() const override {
     return false;
   }
 
+  bool parallelDecoding() const override {
+    return parallelDecoding_;
+  }
+
   template <typename From, typename To>
   void runTest(uint64_t size) {
-    auto dataType = ROW({"c0"}, {CppToType<From>::create()});
+    auto fileType = ROW({"c0"}, {CppToType<From>::create()});
     auto requestedType = ROW({"c0"}, {CppToType<To>::create()});
 
     // build asIsColumnReader_ and asIsSelectiveColumnReader_.
-    buildReader(dataType);
+    buildReader(fileType);
     asIsColumnReader_ = std::move(columnReader_);
     asIsSelectiveColumnReader_ = std::move(selectiveColumnReader_);
-    VectorPtr asIsBatch = newBatch(dataType);
+    VectorPtr asIsBatch = newBatch(fileType);
     if (asIsColumnReader_) {
       asIsColumnReader_->next(size, asIsBatch, nullptr);
     } else {
@@ -378,7 +472,7 @@ class SchemaMismatchTest : public TestWithParam<bool>,
     // build columnReader_ and selectiveColumnReader_. They are used as
     // mismatch ColumnReaders
     auto scanSpec2 = std::make_unique<common::ScanSpec>("root2");
-    buildReader(requestedType, {}, dataType, scanSpec2.get());
+    buildReader(requestedType, fileType, {}, scanSpec2.get());
     VectorPtr mismatchBatch = newBatch(requestedType);
     if (columnReader_) {
       columnReader_->next(size, mismatchBatch, nullptr);
@@ -808,16 +902,16 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
   // create the row type
   auto rowType =
       HiveTypeParser().parse("struct<col_0:int,col_1:int,col_2:int>");
-  auto dataType = TypeWithId::create(rowType)->type();
+  auto fileType = TypeWithId::create(rowType)->type();
   VectorPtr batch = newBatch(rowType);
   if (useSelectiveReader()) {
     auto scanSpec = std::make_unique<common::ScanSpec>("root");
-    scanSpec->addAllChildFields(*dataType);
+    scanSpec->addAllChildFields(*fileType);
     scanSpec->childByName("col_0")->setFilter(
         std::make_unique<common::BigintRange>(2100, 2140, false));
     scanSpec->childByName("col_1")->setFilter(
         std::make_unique<common::BigintRange>(11, 20, false));
-    buildReader(rowType, {}, nullptr, scanSpec.get());
+    buildReader(rowType, nullptr, {}, scanSpec.get());
     selectiveColumnReader_->next(size, batch, nullptr);
 
     auto rowVector = std::dynamic_pointer_cast<RowVector>(batch);
@@ -1885,10 +1979,10 @@ TEST_P(TestColumnReader, testShortBlobError) {
     next(100, batch);
     batch->as<RowVector>()->childAt(0)->loadedVector();
     FAIL() << "Expected an error";
-  } catch (const exception::LoggedException& e) {
-    ASSERT_EQ("bad read in readFully", e.message());
   } catch (const VeloxRuntimeError& e) {
-    ASSERT_EQ("Reading past end", e.message());
+    ASSERT_TRUE(
+        "bad read in readFully" == e.message() ||
+        "Reading past end" == e.message());
   }
 }
 
@@ -2661,7 +2755,7 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNullsNoData) {
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:array<bigint>>");
   // selected filter tree nodes list
-  buildReader(rowType, {0, 1});
+  buildReader(rowType, nullptr, {0, 1});
 
   VectorPtr batch = newBatch(rowType);
 
@@ -3171,7 +3265,7 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNullsNoData) {
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:map<bigint,bigint>>");
-  buildReader(rowType, {0, 1});
+  buildReader(rowType, nullptr, {0, 1});
 
   VectorPtr batch = newBatch(rowType);
 
@@ -3229,7 +3323,7 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithAllNulls) {
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:map<bigint,bigint>>");
-  buildReader(rowType, {0, 1});
+  buildReader(rowType, nullptr, {0, 1});
 
   VectorPtr batch = newBatch(rowType);
   skipAndRead(batch, /* read */ 8);
@@ -4079,7 +4173,7 @@ TEST_P(StringReaderTests, testStringDirectUseBatchAfterClose) {
           Return(new SeekableArrayInputStream(lengths.data(), lengths.size())));
 
   auto rowType = HiveTypeParser().parse("struct<myString:string>");
-  buildReader(rowType, {});
+  buildReader(rowType, nullptr, {});
 
   std::vector<VectorPtr> batches;
   for (size_t i = 0; i < ROW_COUNT; ++i) {
@@ -5027,64 +5121,113 @@ TEST_P(SchemaMismatchTest, testFloat) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TestColumnReaderNoReuse,
     TestColumnReader,
-    ::testing::Values(ReaderTestParams{false, false}));
+    ::testing::Values(ReaderTestParams{false, false, false}));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TestColumnReaderNoReuseParallel,
+    TestColumnReader,
+    ::testing::Values(ReaderTestParams{false, false, true}));
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TestColumnReaderReuse,
     TestColumnReader,
-    ::testing::Values(ReaderTestParams{false, true}));
+    ::testing::Values(ReaderTestParams{false, true, false}));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TestColumnReaderReuseParallel,
+    TestColumnReader,
+    ::testing::Values(ReaderTestParams{false, true, true}));
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TestSelectiveColumnReader,
     TestColumnReader,
-    ::testing::Values(ReaderTestParams{true, false}));
+    ::testing::Values(ReaderTestParams{true, false, false}));
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TestNonSelectiveColumnReaderNoReuse,
     TestNonSelectiveColumnReader,
-    ::testing::Values(false));
+    ::testing::Values(NonSelectiveReaderTestParams{false, false}));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TestNonSelectiveColumnReaderNoReuseParallel,
+    TestNonSelectiveColumnReader,
+    ::testing::Values(NonSelectiveReaderTestParams{false, true}));
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TestNonSelectiveColumnReaderReuse,
     TestNonSelectiveColumnReader,
-    ::testing::Values(true));
+    ::testing::Values(NonSelectiveReaderTestParams{true, false}));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TestNonSelectiveColumnReaderReuseParallel,
+    TestNonSelectiveColumnReader,
+    ::testing::Values(NonSelectiveReaderTestParams{true, true}));
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     StringViewReaderNoReuse,
     StringReaderTests,
-    ::testing::Values(StringReaderTestParams{false, false, false}),
+    ::testing::Values(StringReaderTestParams{false, false, false, false}),
+    [](auto p) { return p.param.toString(); });
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    StringViewReaderNoReuseParallel,
+    StringReaderTests,
+    ::testing::Values(StringReaderTestParams{false, false, false, true}),
     [](auto p) { return p.param.toString(); });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     StringViewReaderReuse,
     StringReaderTests,
-    ::testing::Values(StringReaderTestParams{false, false, true}),
+    ::testing::Values(StringReaderTestParams{false, false, true, false}),
+    [](auto p) { return p.param.toString(); });
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    StringViewReaderReuseParallel,
+    StringReaderTests,
+    ::testing::Values(StringReaderTestParams{false, false, true, true}),
     [](auto p) { return p.param.toString(); });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     FlatStringViewReaderNoReuse,
     StringReaderTests,
-    ::testing::Values(StringReaderTestParams{false, true, false}),
+    ::testing::Values(StringReaderTestParams{false, true, false, false}),
+    [](auto p) { return p.param.toString(); });
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    FlatStringViewReaderNoReuseParallel,
+    StringReaderTests,
+    ::testing::Values(StringReaderTestParams{false, true, false, true}),
     [](auto p) { return p.param.toString(); });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     FlatStringViewReaderReuse,
     StringReaderTests,
-    ::testing::Values(StringReaderTestParams{false, true, true}),
+    ::testing::Values(StringReaderTestParams{false, true, true, false}),
+    [](auto p) { return p.param.toString(); });
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    FlatStringViewReaderReuseParallel,
+    StringReaderTests,
+    ::testing::Values(StringReaderTestParams{false, true, true, true}),
     [](auto p) { return p.param.toString(); });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SelectiveStringViewReader,
     StringReaderTests,
-    ::testing::Values(StringReaderTestParams{true, false, false}),
+    ::testing::Values(StringReaderTestParams{true, false, false, false}),
     [](auto p) { return p.param.toString(); });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SchemaMismatch,
     SchemaMismatchTest,
-    Values(false));
+    Values(SchemaMismatchTestParam{false, false}));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    SchemaMismatchParallel,
+    SchemaMismatchTest,
+    Values(SchemaMismatchTestParam{false, true}));
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SelectiveSchemaMismatch,
     SchemaMismatchTest,
-    Values(true));
+    Values(SchemaMismatchTestParam{true, false}));
diff --git a/velox/dwio/dwrf/test/TestColumnStatistics.cpp b/velox/dwio/dwrf/test/TestColumnStatistics.cpp
deleted file mode 100644
index 99bef6ce8c269..0000000000000
--- a/velox/dwio/dwrf/test/TestColumnStatistics.cpp
+++ /dev/null
@@ -1,1138 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <cmath>
-#include "velox/dwio/common/Statistics.h"
-#include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
-#include "velox/type/fbhive/HiveTypeParser.h"
-
-using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::dwrf;
-using facebook::velox::type::fbhive::HiveTypeParser;
-
-StatisticsBuilderOptions options{16};
-
-facebook::velox::dwrf::StatsContext context{WriterVersion_CURRENT};
-template <typename T, typename U>
-std::unique_ptr<T> as(std::unique_ptr<U>&& ptr) {
-  auto p = ptr.release();
-  if (auto cp = dynamic_cast<T*>(p)) {
-    return std::unique_ptr<T>(cp);
-  }
-  delete p;
-  return nullptr;
-}
-
-TEST(StatisticsBuilder, size) {
-  {
-    StatisticsBuilder missingSize{options};
-    ASSERT_FALSE(missingSize.getSize().has_value());
-    StatisticsBuilder hasSize{
-        StatisticsBuilderOptions{/*stringLengthLimit=*/32, /*initialSize=*/10}};
-    ASSERT_TRUE(hasSize.getSize().has_value());
-    EXPECT_EQ(10, hasSize.getSize().value());
-
-    hasSize.merge(missingSize, /*ignoreSize=*/true);
-    EXPECT_FALSE(missingSize.getSize().has_value());
-    ASSERT_TRUE(hasSize.getSize().has_value());
-    EXPECT_EQ(10, hasSize.getSize().value());
-
-    // Coercing to missing/invalid size when not ignoring by default.
-    hasSize.merge(missingSize);
-    EXPECT_FALSE(missingSize.getSize().has_value());
-    EXPECT_FALSE(hasSize.getSize().has_value());
-  }
-  {
-    StatisticsBuilder from{options};
-    ASSERT_FALSE(from.getSize().has_value());
-
-    StatisticsBuilder to{options};
-    ASSERT_FALSE(to.getSize().has_value());
-    to.incrementSize(64);
-    ASSERT_FALSE(to.getSize().has_value());
-
-    to.ensureSize();
-    ASSERT_EQ(0, to.getSize().value());
-    to.incrementSize(64);
-    EXPECT_EQ(64, to.getSize().value());
-
-    to.merge(from, /*ignoreSize=*/true);
-    EXPECT_FALSE(from.getSize().has_value());
-    EXPECT_EQ(64, to.getSize().value());
-
-    to.merge(from);
-    EXPECT_FALSE(from.getSize().has_value());
-    EXPECT_FALSE(to.getSize().has_value());
-  }
-}
-
-TEST(StatisticsBuilder, integer) {
-  IntegerStatisticsBuilder builder{options};
-  // empty builder should have all defaults
-  EXPECT_EQ(std::numeric_limits<int64_t>::max(), builder.getMinimum());
-  EXPECT_EQ(std::numeric_limits<int64_t>::min(), builder.getMaximum());
-  EXPECT_EQ(0, builder.getSum());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-
-  builder.addValues(3);
-  builder.addValues(1);
-  builder.addValues(5);
-
-  // stats should be merged
-  IntegerStatisticsBuilder target{options};
-  target.merge(*builder.build());
-  auto stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(3, stats->getNumberOfValues());
-  EXPECT_EQ(1, stats->getMinimum());
-  EXPECT_EQ(5, stats->getMaximum());
-  EXPECT_EQ(9, stats->getSum());
-
-  // stats should be merged again
-  builder.addValues(0);
-  builder.addValues(6);
-  target.merge(*builder.build());
-  stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(8, stats->getNumberOfValues());
-  EXPECT_EQ(0, stats->getMinimum());
-  EXPECT_EQ(6, stats->getMaximum());
-  EXPECT_EQ(24, stats->getSum());
-
-  target.merge(*builder.build());
-  stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(13, stats->getNumberOfValues());
-  EXPECT_EQ(0, stats->getMinimum());
-  EXPECT_EQ(6, stats->getMaximum());
-  EXPECT_EQ(39, stats->getSum());
-
-  // add value
-  target.addValues(100, 2);
-  stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(15, stats->getNumberOfValues());
-  EXPECT_EQ(0, stats->getMinimum());
-  EXPECT_EQ(100, stats->getMaximum());
-  EXPECT_EQ(239, stats->getSum());
-
-  // reset
-  builder.reset();
-  EXPECT_EQ(std::numeric_limits<int64_t>::max(), builder.getMinimum());
-  EXPECT_EQ(std::numeric_limits<int64_t>::min(), builder.getMaximum());
-  EXPECT_EQ(0, builder.getSum());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-}
-
-TEST(StatisticsBuilder, integerMissingStats) {
-  IntegerStatisticsBuilder target{options};
-  target.addValues(1, 5);
-  auto stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getSum());
-
-  // merge missing stats
-  proto::ColumnStatistics proto;
-  auto intProto = proto.mutable_intstatistics();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // merge again
-  intProto->set_minimum(0);
-  intProto->set_maximum(1);
-  intProto->set_sum(100);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // add again
-  target.addValues(2);
-  stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, integerEmptyStats) {
-  IntegerStatisticsBuilder target{options};
-  target.addValues(1, 5);
-  auto stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getSum());
-
-  // merge empty stats
-  proto::ColumnStatistics proto;
-  proto.set_numberofvalues(0);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getSum());
-
-  // merge again
-  proto.clear_numberofvalues();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, integerOverflow) {
-  IntegerStatisticsBuilder target{options};
-  auto testMinMax = [&](int64_t val1, int64_t val2, int64_t min, int64_t max) {
-    target.reset();
-    target.addValues(val1);
-    auto stats = as<IntegerColumnStatistics>(target.build());
-    EXPECT_EQ(val1, stats->getMaximum());
-    EXPECT_EQ(val1, stats->getMinimum());
-    EXPECT_EQ(val1, stats->getSum());
-
-    target.addValues(val2);
-    stats = as<IntegerColumnStatistics>(target.build());
-    EXPECT_EQ(max, stats->getMaximum());
-    EXPECT_EQ(min, stats->getMinimum());
-    EXPECT_FALSE(stats->getSum().has_value());
-  };
-
-  testMinMax(
-      std::numeric_limits<int64_t>::min(),
-      -1,
-      std::numeric_limits<int64_t>::min(),
-      -1);
-  testMinMax(
-      std::numeric_limits<int64_t>::max(),
-      1,
-      1,
-      std::numeric_limits<int64_t>::max());
-
-  // make sure we also capture overflow that happened for adding multiple items
-  target.reset();
-  target.addValues(std::numeric_limits<int64_t>::max() / 10, 11);
-  auto stats = as<IntegerColumnStatistics>(target.build());
-  EXPECT_EQ(11, stats->getNumberOfValues());
-  EXPECT_EQ(stats->getMaximum().value(), stats->getMinimum().value());
-  EXPECT_FALSE(stats->getSum().has_value());
-
-  // merge overflow
-  auto testMergeOverflow = [&](int64_t val1, int64_t val2) {
-    target.reset();
-    target.addValues(val1);
-    IntegerStatisticsBuilder builder{options};
-    builder.addValues(val2);
-    target.merge(builder);
-    stats = as<IntegerColumnStatistics>(target.build());
-    EXPECT_FALSE(stats->getSum().has_value());
-  };
-  testMergeOverflow(std::numeric_limits<int64_t>::min(), -1);
-  testMergeOverflow(std::numeric_limits<int64_t>::max(), 1);
-}
-
-TEST(StatisticsBuilder, doubles) {
-  DoubleStatisticsBuilder builder{options};
-  // empty builder should have all defaults
-  EXPECT_EQ(std::numeric_limits<double>::infinity(), builder.getMinimum());
-  EXPECT_EQ(-std::numeric_limits<double>::infinity(), builder.getMaximum());
-  EXPECT_EQ(0, builder.getSum());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-
-  builder.addValues(3);
-  builder.addValues(1);
-  builder.addValues(5);
-
-  // stats should be merged
-  DoubleStatisticsBuilder target{options};
-  target.merge(*builder.build());
-  auto stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(3, stats->getNumberOfValues());
-  EXPECT_EQ(1, stats->getMinimum());
-  EXPECT_EQ(5, stats->getMaximum());
-  EXPECT_EQ(9, stats->getSum());
-
-  // stats should be merged again
-  builder.addValues(0);
-  builder.addValues(6);
-  target.merge(*builder.build());
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(8, stats->getNumberOfValues());
-  EXPECT_EQ(0, stats->getMinimum());
-  EXPECT_EQ(6, stats->getMaximum());
-  EXPECT_EQ(24, stats->getSum());
-
-  target.merge(*builder.build());
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(13, stats->getNumberOfValues());
-  EXPECT_EQ(0, stats->getMinimum());
-  EXPECT_EQ(6, stats->getMaximum());
-  EXPECT_EQ(39, stats->getSum());
-
-  // add value
-  target.addValues(100, 2);
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(15, stats->getNumberOfValues());
-  EXPECT_EQ(0, stats->getMinimum());
-  EXPECT_EQ(100, stats->getMaximum());
-  EXPECT_EQ(239, stats->getSum());
-
-  // reset
-  builder.reset();
-  EXPECT_EQ(std::numeric_limits<double>::infinity(), builder.getMinimum());
-  EXPECT_EQ(-std::numeric_limits<double>::infinity(), builder.getMaximum());
-  EXPECT_EQ(0, builder.getSum());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-}
-
-TEST(StatisticsBuilder, doubleMissingStats) {
-  DoubleStatisticsBuilder target{options};
-  target.addValues(1, 5);
-  auto stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getSum());
-
-  // merge missing stats
-  proto::ColumnStatistics proto;
-  auto doubleProto = proto.mutable_doublestatistics();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // merge again
-  doubleProto->set_minimum(0);
-  doubleProto->set_maximum(1);
-  doubleProto->set_sum(100);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // add again
-  target.addValues(2);
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, doubleEmptyStats) {
-  DoubleStatisticsBuilder target{options};
-  target.addValues(1, 5);
-  auto stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getSum());
-
-  // merge empty stats
-  proto::ColumnStatistics proto;
-  proto.set_numberofvalues(0);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getSum());
-
-  // merge again
-  proto.clear_numberofvalues();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, doubleNaN) {
-  DoubleStatisticsBuilder target{options};
-  // test nan. Nan causes fallback to basic stats.
-  target.addValues(std::numeric_limits<float>::quiet_NaN());
-  auto stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  target.reset();
-  target.addValues(std::numeric_limits<double>::infinity());
-  target.addValues(-std::numeric_limits<double>::infinity());
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(stats->getMaximum(), std::numeric_limits<double>::infinity());
-  EXPECT_EQ(stats->getMinimum(), -std::numeric_limits<double>::infinity());
-  EXPECT_FALSE(stats->getSum().has_value());
-
-  target.reset();
-  DoubleStatisticsBuilder builder{options};
-  target.addValues(std::numeric_limits<double>::infinity());
-  builder.addValues(-std::numeric_limits<double>::infinity());
-  target.merge(*builder.build());
-  stats = as<DoubleColumnStatistics>(target.build());
-  EXPECT_EQ(stats->getMaximum(), std::numeric_limits<double>::infinity());
-  EXPECT_EQ(stats->getMinimum(), -std::numeric_limits<double>::infinity());
-  EXPECT_FALSE(stats->getSum().has_value());
-}
-
-TEST(StatisticsBuilder, string) {
-  StringStatisticsBuilder builder{options};
-  // empty builder should have all defaults
-  EXPECT_FALSE(builder.getMinimum().has_value());
-  EXPECT_FALSE(builder.getMaximum().has_value());
-  EXPECT_EQ(0, builder.getTotalLength());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-
-  builder.addValues("xx");
-  builder.addValues("bb");
-  builder.addValues("yy");
-
-  // stats should be merged
-  StringStatisticsBuilder target{options};
-  target.merge(*builder.build());
-  auto stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(3, stats->getNumberOfValues());
-  EXPECT_EQ("bb", stats->getMinimum());
-  EXPECT_EQ("yy", stats->getMaximum());
-  EXPECT_EQ(6, stats->getTotalLength());
-
-  // stats should be merged again
-  builder.addValues("aa");
-  builder.addValues("zz");
-  target.merge(*builder.build());
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(8, stats->getNumberOfValues());
-  EXPECT_EQ("aa", stats->getMinimum());
-  EXPECT_EQ("zz", stats->getMaximum());
-  EXPECT_EQ(16, stats->getTotalLength());
-
-  target.merge(*builder.build());
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(13, stats->getNumberOfValues());
-  EXPECT_EQ("aa", stats->getMinimum());
-  EXPECT_EQ("zz", stats->getMaximum());
-  EXPECT_EQ(26, stats->getTotalLength());
-
-  // add value
-  target.addValues("zzz", 2);
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(15, stats->getNumberOfValues());
-  EXPECT_EQ("aa", stats->getMinimum());
-  EXPECT_EQ("zzz", stats->getMaximum());
-  EXPECT_EQ(32, stats->getTotalLength());
-
-  // reset
-  builder.reset();
-  EXPECT_FALSE(builder.getMinimum().has_value());
-  EXPECT_FALSE(builder.getMaximum().has_value());
-  EXPECT_EQ(0, builder.getTotalLength());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-}
-
-TEST(StatisticsBuilder, stringMissingStats) {
-  StringStatisticsBuilder target{options};
-  target.addValues("zz", 5);
-  auto stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(10, stats->getTotalLength());
-
-  // merge missing stats
-  proto::ColumnStatistics proto;
-  auto strProto = proto.mutable_stringstatistics();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // merge again
-  strProto->set_minimum("aa");
-  strProto->set_maximum("bb");
-  strProto->set_sum(100);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // add again
-  target.addValues("aa");
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, stringEmptyStats) {
-  StringStatisticsBuilder target{options};
-  target.addValues("zz", 5);
-  auto stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(10, stats->getTotalLength());
-
-  // merge empty stats
-  proto::ColumnStatistics proto;
-  proto.set_numberofvalues(0);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(10, stats->getTotalLength());
-
-  // merge again
-  proto.clear_numberofvalues();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, stringLengthThreshold) {
-  StringStatisticsBuilder target{StatisticsBuilderOptions{2}};
-  target.addValues("yyy");
-  auto stats = as<StringColumnStatistics>(target.build());
-  EXPECT_FALSE(stats->getMinimum().has_value());
-  EXPECT_FALSE(stats->getMaximum().has_value());
-
-  // merge empty stats
-  target.addValues("aa");
-  target.addValues("zz");
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_EQ(stats->getMinimum(), "aa");
-  EXPECT_EQ(stats->getMaximum(), "zz");
-}
-
-TEST(StatisticsBuilder, stringLengthOverflow) {
-  // add value causing overflow
-  StringStatisticsBuilder target{options};
-  proto::ColumnStatistics proto;
-  proto.set_numberofvalues(1);
-  auto strProto = proto.mutable_stringstatistics();
-  strProto->set_sum(std::numeric_limits<int64_t>::max());
-  strProto->set_minimum("foo");
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  EXPECT_TRUE(target.getTotalLength().has_value());
-  auto stats = as<StringColumnStatistics>(target.build());
-  EXPECT_TRUE(stats->getTotalLength().has_value());
-
-  target.addValues("foo");
-  EXPECT_TRUE(target.getTotalLength().has_value());
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_FALSE(stats->getTotalLength().has_value());
-
-  // merge causing overflow
-  target.reset();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  EXPECT_TRUE(target.getTotalLength().has_value());
-  stats = as<StringColumnStatistics>(target.build());
-  EXPECT_FALSE(stats->getTotalLength().has_value());
-}
-
-TEST(StatisticsBuilder, boolean) {
-  BooleanStatisticsBuilder builder{options};
-  // empty builder should have all defaults
-  EXPECT_EQ(0, builder.getTrueCount());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-
-  builder.addValues(true, 2);
-
-  // stats should be merged
-  BooleanStatisticsBuilder target{options};
-  target.merge(*builder.build());
-  auto stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(2, stats->getNumberOfValues());
-  EXPECT_EQ(2, stats->getTrueCount());
-
-  // stats should be merged again
-  target.merge(*builder.build());
-  stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(4, stats->getNumberOfValues());
-  EXPECT_EQ(4, stats->getTrueCount());
-
-  // add value
-  target.addValues(false, 2);
-  stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(6, stats->getNumberOfValues());
-  EXPECT_EQ(4, stats->getTrueCount());
-
-  // reset
-  builder.reset();
-  EXPECT_EQ(0, builder.getTrueCount());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-}
-
-TEST(StatisticsBuilder, booleanMissingStats) {
-  BooleanStatisticsBuilder target{options};
-  target.addValues(true, 5);
-  auto stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getTrueCount());
-
-  // merge missing stats
-  proto::ColumnStatistics proto;
-  auto boolProto = proto.mutable_bucketstatistics();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // merge again
-  boolProto->add_count(1);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // add again
-  target.addValues(true);
-  stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, booleanEmptyStats) {
-  BooleanStatisticsBuilder target{options};
-  target.addValues(true, 5);
-  auto stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getTrueCount());
-
-  // merge empty stats
-  proto::ColumnStatistics proto;
-  proto.set_numberofvalues(0);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getTrueCount());
-
-  // merge again
-  proto.clear_numberofvalues();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<BooleanColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, basic) {
-  StatisticsBuilder builder{options};
-  EXPECT_EQ(0, builder.getNumberOfValues());
-  EXPECT_EQ(0, builder.getRawSize());
-  EXPECT_FALSE(builder.hasNull().value());
-
-  builder.increaseValueCount(5);
-  builder.increaseRawSize(10);
-  builder.setHasNull();
-
-  // stats should be merged
-  StatisticsBuilder target{options};
-  target.merge(*builder.build());
-  auto stats = target.build();
-  EXPECT_EQ(5, stats->getNumberOfValues());
-  EXPECT_EQ(10, stats->getRawSize());
-  EXPECT_TRUE(stats->hasNull().value());
-
-  // stats should be merged again
-  target.merge(*builder.build());
-  stats = target.build();
-  EXPECT_EQ(10, stats->getNumberOfValues());
-  EXPECT_EQ(20, stats->getRawSize());
-  EXPECT_TRUE(stats->hasNull().value());
-
-  // add value
-  target.increaseValueCount(1);
-  target.increaseRawSize(2);
-  stats = target.build();
-  EXPECT_EQ(11, stats->getNumberOfValues());
-  EXPECT_EQ(22, stats->getRawSize());
-  EXPECT_TRUE(stats->hasNull().value());
-
-  // reset
-  builder.reset();
-  EXPECT_EQ(0, builder.getNumberOfValues());
-  EXPECT_EQ(0, builder.getRawSize());
-  EXPECT_FALSE(builder.hasNull().value());
-}
-
-TEST(StatisticsBuilder, basicMissingStats) {
-  StatisticsBuilder target{options};
-  target.increaseValueCount(5);
-  target.increaseRawSize(10);
-  auto stats = target.build();
-  EXPECT_EQ(5, stats->getNumberOfValues());
-  EXPECT_EQ(10, stats->getRawSize());
-  EXPECT_FALSE(stats->hasNull().value());
-
-  // merge missing stats
-  proto::ColumnStatistics proto;
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = target.build();
-  EXPECT_FALSE(stats->getNumberOfValues().has_value());
-  EXPECT_FALSE(stats->getRawSize().has_value());
-  EXPECT_FALSE(stats->hasNull().has_value());
-
-  // add again
-  target.increaseValueCount(5);
-  target.increaseRawSize(10);
-  target.setHasNull();
-  stats = target.build();
-  EXPECT_FALSE(stats->getNumberOfValues().has_value());
-  EXPECT_FALSE(stats->getRawSize().has_value());
-  EXPECT_TRUE(stats->hasNull().value());
-}
-
-TEST(StatisticsBuilder, basicHasNull) {
-  enum class State { kTrue = 0, kFalse, kMissing };
-  auto test = [](State to, State from, State expected) {
-    StatisticsBuilder target{options};
-    if (to == State::kTrue) {
-      target.setHasNull();
-    } else if (to == State::kMissing) {
-      // merge against unknown
-      proto::ColumnStatistics proto;
-      target.merge(*buildColumnStatisticsFromProto(proto, context));
-    }
-
-    proto::ColumnStatistics proto;
-    if (from == State::kFalse) {
-      proto.set_hasnull(false);
-    } else if (from == State::kTrue) {
-      proto.set_hasnull(true);
-    }
-
-    target.merge(*buildColumnStatisticsFromProto(proto, context));
-    auto stats = target.build();
-    if (expected == State::kFalse) {
-      EXPECT_FALSE(stats->hasNull().value());
-    } else if (expected == State::kTrue) {
-      EXPECT_TRUE(stats->hasNull().value());
-    } else {
-      EXPECT_FALSE(stats->hasNull().has_value());
-    }
-  };
-
-  // true / any => true
-  test(State::kTrue, State::kTrue, State::kTrue);
-  test(State::kTrue, State::kFalse, State::kTrue);
-  test(State::kTrue, State::kMissing, State::kTrue);
-  // unknown / true => true
-  // unknown / unknown or false => unknown
-  test(State::kMissing, State::kTrue, State::kTrue);
-  test(State::kMissing, State::kFalse, State::kMissing);
-  test(State::kMissing, State::kMissing, State::kMissing);
-  // false / unknown => unknown
-  // false / false => false
-  // false / true => true
-  test(State::kFalse, State::kMissing, State::kMissing);
-  test(State::kFalse, State::kFalse, State::kFalse);
-  test(State::kFalse, State::kTrue, State::kTrue);
-}
-
-TEST(StatisticsBuilder, binary) {
-  BinaryStatisticsBuilder builder{options};
-  // empty builder should have all defaults
-  EXPECT_EQ(0, builder.getTotalLength());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-
-  builder.addValues(5, 2);
-
-  // stats should be merged
-  BinaryStatisticsBuilder target{options};
-  target.merge(*builder.build());
-  auto stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(2, stats->getNumberOfValues());
-  EXPECT_EQ(10, stats->getTotalLength());
-
-  // stats should be merged again
-  target.merge(*builder.build());
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(4, stats->getNumberOfValues());
-  EXPECT_EQ(20, stats->getTotalLength());
-
-  // add value
-  target.addValues(10);
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getNumberOfValues());
-  EXPECT_EQ(30, stats->getTotalLength());
-
-  // reset
-  builder.reset();
-  EXPECT_EQ(0, builder.getTotalLength());
-  EXPECT_EQ(0, builder.getNumberOfValues());
-}
-
-TEST(StatisticsBuilder, binaryMissingStats) {
-  BinaryStatisticsBuilder target{options};
-  target.addValues(5);
-  auto stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getTotalLength());
-
-  // merge missing stats
-  proto::ColumnStatistics proto;
-  auto binProto = proto.mutable_binarystatistics();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // merge again
-  binProto->set_sum(100);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // add again
-  target.addValues(10);
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, binaryEmptyStats) {
-  BinaryStatisticsBuilder target{options};
-  target.addValues(5);
-  auto stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getTotalLength());
-
-  // merge empty stats
-  proto::ColumnStatistics proto;
-  proto.set_numberofvalues(0);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(5, stats->getTotalLength());
-
-  // merge again
-  proto.clear_numberofvalues();
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, binaryLengthOverflow) {
-  // add value causing overflow
-  BinaryStatisticsBuilder target{options};
-  target.addValues(std::numeric_limits<int64_t>::max());
-  auto stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_NE(stats, nullptr);
-  target.addValues(1);
-  EXPECT_TRUE(target.getTotalLength().has_value());
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-
-  // merge causing overflow
-  target.reset();
-  target.addValues(std::numeric_limits<int64_t>::max());
-  proto::ColumnStatistics proto;
-  auto binProto = proto.mutable_binarystatistics();
-  binProto->set_sum(1);
-  target.merge(*buildColumnStatisticsFromProto(proto, context));
-  EXPECT_TRUE(target.getTotalLength().has_value());
-  stats = as<BinaryColumnStatistics>(target.build());
-  EXPECT_EQ(stats, nullptr);
-}
-
-TEST(StatisticsBuilder, initialSize) {
-  StatisticsBuilder target{options};
-  target.increaseValueCount(1);
-  EXPECT_FALSE(target.getSize().has_value());
-  auto stats = target.build();
-  EXPECT_FALSE(stats->getSize().has_value());
-
-  StatisticsBuilder target2{StatisticsBuilderOptions{16, 100U}};
-  target2.increaseValueCount(1);
-  EXPECT_EQ(target2.getSize().value(), 100);
-  stats = target2.build();
-  EXPECT_EQ(stats->getSize().value(), 100);
-  target2.reset();
-  EXPECT_EQ(target2.getSize().value(), 100);
-  stats = target2.build();
-  EXPECT_EQ(stats->getSize().value(), 100);
-}
-
-proto::KeyInfo createKeyInfo(int64_t key) {
-  proto::KeyInfo keyInfo;
-  keyInfo.set_intkey(key);
-  return keyInfo;
-}
-
-inline bool operator==(
-    const ColumnStatistics& lhs,
-    const ColumnStatistics& rhs) {
-  return (lhs.hasNull() == rhs.hasNull()) &&
-      (lhs.getNumberOfValues() == rhs.getNumberOfValues()) &&
-      (lhs.getRawSize() == rhs.getRawSize());
-}
-
-void checkEntries(
-    const std::vector<ColumnStatistics>& entries,
-    const std::vector<ColumnStatistics>& expectedEntries) {
-  EXPECT_EQ(expectedEntries.size(), entries.size());
-  for (const auto& entry : entries) {
-    EXPECT_NE(
-        std::find_if(
-            expectedEntries.begin(),
-            expectedEntries.end(),
-            [&](const ColumnStatistics& expectedStats) {
-              return expectedStats == entry;
-            }),
-        expectedEntries.end());
-  }
-}
-
-struct TestKeyStats {
-  TestKeyStats(int64_t key, bool hasNull, uint64_t valueCount, uint64_t rawSize)
-      : key{key}, hasNull{hasNull}, valueCount{valueCount}, rawSize{rawSize} {}
-
-  int64_t key;
-  bool hasNull;
-  uint64_t valueCount;
-  uint64_t rawSize;
-};
-
-struct MapStatsAddValueTestCase {
-  explicit MapStatsAddValueTestCase(
-      const std::vector<TestKeyStats>& input,
-      const std::vector<TestKeyStats>& expected)
-      : input{input}, expected{expected} {}
-
-  std::vector<TestKeyStats> input;
-  std::vector<TestKeyStats> expected;
-};
-
-class MapStatisticsBuilderAddValueTest
-    : public ::testing::Test,
-      public ::testing::WithParamInterface<MapStatsAddValueTestCase> {};
-
-TEST_P(MapStatisticsBuilderAddValueTest, addValues) {
-  auto type = HiveTypeParser{}.parse("map<int, float>");
-  MapStatisticsBuilder mapStatsBuilder{*type, options};
-
-  for (const auto& entry : GetParam().input) {
-    StatisticsBuilder statsBuilder{options};
-    if (entry.hasNull) {
-      statsBuilder.setHasNull();
-    }
-    statsBuilder.increaseValueCount(entry.valueCount);
-    statsBuilder.increaseRawSize(entry.rawSize);
-    mapStatsBuilder.addValues(createKeyInfo(entry.key), statsBuilder);
-  }
-
-  const auto& expectedTestEntries = GetParam().expected;
-  std::vector<ColumnStatistics> expectedEntryStats{};
-  expectedEntryStats.reserve(expectedTestEntries.size());
-  for (const auto& entry : expectedTestEntries) {
-    StatisticsBuilder statsBuilder{options};
-    if (entry.hasNull) {
-      statsBuilder.setHasNull();
-    }
-    statsBuilder.increaseValueCount(entry.valueCount);
-    statsBuilder.increaseRawSize(entry.rawSize);
-    expectedEntryStats.push_back(statsBuilder);
-  }
-
-  std::vector<ColumnStatistics> entryStats;
-  const auto& outputEntries = mapStatsBuilder.getEntryStatistics();
-  entryStats.reserve(outputEntries.size());
-  for (const auto& entry : outputEntries) {
-    entryStats.push_back(*entry.second);
-  }
-
-  checkEntries(entryStats, expectedEntryStats);
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    MapStatisticsBuilderAddValueTestSuite,
-    MapStatisticsBuilderAddValueTest,
-    testing::Values(
-        MapStatsAddValueTestCase{{}, {}},
-        MapStatsAddValueTestCase{
-            {TestKeyStats{1, false, 1, 21}},
-            {TestKeyStats{1, false, 1, 21}}},
-        MapStatsAddValueTestCase{
-            {TestKeyStats{1, false, 1, 21}, TestKeyStats{1, true, 3, 42}},
-            {TestKeyStats{1, true, 4, 63}}},
-        MapStatsAddValueTestCase{
-            {TestKeyStats{1, false, 1, 21}, TestKeyStats{2, true, 3, 42}},
-            {TestKeyStats{1, false, 1, 21}, TestKeyStats{2, true, 3, 42}}},
-        MapStatsAddValueTestCase{
-            {TestKeyStats{1, false, 1, 21},
-             TestKeyStats{2, false, 3, 42},
-             TestKeyStats{2, false, 3, 42},
-             TestKeyStats{1, true, 1, 42}},
-            {TestKeyStats{1, true, 2, 63}, TestKeyStats{2, false, 6, 84}}}));
-
-struct MapStatsMergeTestCase {
-  std::vector<std::vector<TestKeyStats>> inputs;
-  std::vector<TestKeyStats> expected;
-};
-
-class MapStatisticsBuilderMergeTest
-    : public ::testing::Test,
-      public ::testing::WithParamInterface<MapStatsMergeTestCase> {};
-
-TEST_P(MapStatisticsBuilderMergeTest, addValues) {
-  auto type = HiveTypeParser{}.parse("map<int, float>");
-
-  const auto& inputTestEntries = GetParam().inputs;
-  std::vector<std::unique_ptr<MapStatisticsBuilder>> mapStatsBuilders;
-  mapStatsBuilders.reserve(inputTestEntries.size());
-  for (const auto& input : inputTestEntries) {
-    std::unique_ptr<MapStatisticsBuilder> mapStatsBuilder =
-        std::make_unique<MapStatisticsBuilder>(*type, options);
-    for (const auto& entry : input) {
-      StatisticsBuilder statsBuilder{options};
-      if (entry.hasNull) {
-        statsBuilder.setHasNull();
-      }
-      statsBuilder.increaseValueCount(entry.valueCount);
-      statsBuilder.increaseRawSize(entry.rawSize);
-      mapStatsBuilder->addValues(createKeyInfo(entry.key), statsBuilder);
-    }
-    mapStatsBuilders.push_back(std::move(mapStatsBuilder));
-  }
-
-  MapStatisticsBuilder aggregateMapStatsBuilder{*type, options};
-  for (const auto& mapStatsBuilder : mapStatsBuilders) {
-    aggregateMapStatsBuilder.merge(*mapStatsBuilder);
-  }
-
-  const auto& expectedTestEntries = GetParam().expected;
-  std::vector<ColumnStatistics> expectedEntryStats{};
-  expectedEntryStats.reserve(expectedTestEntries.size());
-  for (const auto& entry : expectedTestEntries) {
-    StatisticsBuilder statsBuilder{options};
-    if (entry.hasNull) {
-      statsBuilder.setHasNull();
-    }
-    statsBuilder.increaseValueCount(entry.valueCount);
-    statsBuilder.increaseRawSize(entry.rawSize);
-    expectedEntryStats.push_back(statsBuilder);
-  }
-
-  std::vector<ColumnStatistics> entryStats;
-  const auto& aggregatedEntries = aggregateMapStatsBuilder.getEntryStatistics();
-  entryStats.reserve(aggregatedEntries.size());
-  for (const auto& entry : aggregatedEntries) {
-    entryStats.push_back(*entry.second);
-  }
-
-  checkEntries(entryStats, expectedEntryStats);
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    MapStatisticsBuilderMergeTestSuite,
-    MapStatisticsBuilderMergeTest,
-    testing::Values(
-        MapStatsMergeTestCase{{}, {}},
-        MapStatsMergeTestCase{
-            {{TestKeyStats{1, false, 1, 21}}},
-            {TestKeyStats{1, false, 1, 21}}},
-        MapStatsMergeTestCase{
-            {{}, {TestKeyStats{1, false, 1, 21}}},
-            {TestKeyStats{1, false, 1, 21}}},
-        MapStatsMergeTestCase{
-            {{TestKeyStats{1, false, 1, 21}}, {TestKeyStats{1, true, 3, 42}}},
-            {TestKeyStats{1, true, 4, 63}}},
-        MapStatsMergeTestCase{
-            {{TestKeyStats{1, false, 1, 21}}, {TestKeyStats{2, true, 3, 42}}},
-            {TestKeyStats{1, false, 1, 21}, TestKeyStats{2, true, 3, 42}}},
-        MapStatsMergeTestCase{
-            {{TestKeyStats{1, false, 1, 21}, TestKeyStats{2, false, 3, 42}},
-             {TestKeyStats{2, false, 3, 42}},
-             {TestKeyStats{1, true, 1, 42}}},
-            {TestKeyStats{1, true, 2, 63}, TestKeyStats{2, false, 6, 84}}}));
-
-TEST(MapStatisticsBuilderTest, innerStatsType) {
-  {
-    auto type = HiveTypeParser{}.parse("map<int, float>");
-    MapStatisticsBuilder mapStatsBuilder{*type, options};
-
-    DoubleStatisticsBuilder statsBuilder{options};
-    statsBuilder.addValues(0.1);
-    statsBuilder.addValues(1.0);
-    mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder);
-
-    auto& doubleStats = dynamic_cast<DoubleColumnStatistics&>(
-        *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
-
-    EXPECT_EQ(0.1, doubleStats.getMinimum());
-    EXPECT_EQ(1.0, doubleStats.getMaximum());
-  }
-  {
-    auto type = HiveTypeParser{}.parse("map<bigint, bigint>");
-    MapStatisticsBuilder mapStatsBuilder{*type, options};
-
-    IntegerStatisticsBuilder statsBuilder{options};
-    statsBuilder.addValues(1);
-    statsBuilder.addValues(2);
-    mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder);
-
-    auto& intStats = dynamic_cast<IntegerColumnStatistics&>(
-        *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
-
-    EXPECT_EQ(1, intStats.getMinimum());
-    EXPECT_EQ(2, intStats.getMaximum());
-    EXPECT_EQ(3, intStats.getSum());
-  }
-}
-
-TEST(MapStatisticsBuilderTest, incrementSize) {
-  auto type = HiveTypeParser{}.parse("map<int, float>");
-  MapStatisticsBuilder mapStatsBuilder{*type, options};
-
-  DoubleStatisticsBuilder statsBuilder1{options};
-  statsBuilder1.addValues(0.1);
-  statsBuilder1.addValues(1.0);
-  ASSERT_FALSE(statsBuilder1.getSize().has_value());
-  mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder1);
-  EXPECT_FALSE(mapStatsBuilder.getEntryStatistics()
-                   .at(KeyInfo{1})
-                   ->getSize()
-                   .has_value());
-
-  DoubleStatisticsBuilder statsBuilder2{options};
-  statsBuilder2.addValues(0.3);
-  statsBuilder2.addValues(3.0);
-  ASSERT_FALSE(statsBuilder2.getSize().has_value());
-  mapStatsBuilder.addValues(createKeyInfo(2), statsBuilder2);
-  EXPECT_FALSE(mapStatsBuilder.getEntryStatistics()
-                   .at(KeyInfo{2})
-                   ->getSize()
-                   .has_value());
-
-  mapStatsBuilder.incrementSize(createKeyInfo(1), 4);
-  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
-                  .at(KeyInfo{1})
-                  ->getSize()
-                  .has_value());
-  EXPECT_EQ(
-      4,
-      mapStatsBuilder.getEntryStatistics().at(KeyInfo{1})->getSize().value());
-  ASSERT_FALSE(mapStatsBuilder.getEntryStatistics()
-                   .at(KeyInfo{2})
-                   ->getSize()
-                   .has_value());
-  mapStatsBuilder.incrementSize(createKeyInfo(2), 8);
-  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
-                  .at(KeyInfo{1})
-                  ->getSize()
-                  .has_value());
-  EXPECT_EQ(
-      4,
-      mapStatsBuilder.getEntryStatistics().at(KeyInfo{1})->getSize().value());
-  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
-                  .at(KeyInfo{2})
-                  ->getSize()
-                  .has_value());
-  EXPECT_EQ(
-      8,
-      mapStatsBuilder.getEntryStatistics().at(KeyInfo{2})->getSize().value());
-
-  mapStatsBuilder.incrementSize(createKeyInfo(1), 8);
-  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
-                  .at(KeyInfo{1})
-                  ->getSize()
-                  .has_value());
-  EXPECT_EQ(
-      12,
-      mapStatsBuilder.getEntryStatistics().at(KeyInfo{1})->getSize().value());
-  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
-                  .at(KeyInfo{2})
-                  ->getSize()
-                  .has_value());
-  EXPECT_EQ(
-      8,
-      mapStatsBuilder.getEntryStatistics().at(KeyInfo{2})->getSize().value());
-}
-
-TEST(MapStatisticsBuilderTest, mergeKeyStats) {
-  auto type = HiveTypeParser{}.parse("map<bigint, bigint>");
-  MapStatisticsBuilder mapStatsBuilder{*type, options};
-
-  mapStatsBuilder.incrementSize(createKeyInfo(1), 42);
-  auto& keyStats = dynamic_cast<StatisticsBuilder&>(
-      *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
-  ASSERT_EQ(0, keyStats.getNumberOfValues());
-  ASSERT_TRUE(keyStats.getRawSize().has_value());
-  ASSERT_EQ(0, keyStats.getRawSize().value());
-  ASSERT_TRUE(keyStats.getSize().has_value());
-  ASSERT_EQ(42, keyStats.getSize().value());
-
-  IntegerStatisticsBuilder statsBuilder{options};
-  statsBuilder.addValues(1);
-  statsBuilder.addValues(2);
-  statsBuilder.increaseRawSize(8);
-  mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder);
-
-  keyStats = dynamic_cast<StatisticsBuilder&>(
-      *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
-  ASSERT_EQ(2, keyStats.getNumberOfValues());
-  ASSERT_TRUE(keyStats.getRawSize().has_value());
-  ASSERT_EQ(8, keyStats.getRawSize().value());
-  EXPECT_TRUE(keyStats.getSize().has_value());
-  EXPECT_EQ(42, keyStats.getSize().value());
-}
diff --git a/velox/dwio/dwrf/test/TestCompression.cpp b/velox/dwio/dwrf/test/TestCompression.cpp
deleted file mode 100644
index 8163491306de6..0000000000000
--- a/velox/dwio/dwrf/test/TestCompression.cpp
+++ /dev/null
@@ -1,469 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/common/base/VeloxException.h"
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/dwio/common/encryption/TestProvider.h"
-#include "velox/dwio/dwrf/common/Compression.h"
-#include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
-#include "velox/dwio/dwrf/test/OrcTest.h"
-
-#include <folly/Random.h>
-#include <gtest/gtest.h>
-
-#include <algorithm>
-
-using namespace ::testing;
-using namespace facebook::velox::common;
-using namespace facebook::velox::dwio;
-using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::dwio::common::encryption;
-using namespace facebook::velox::dwio::common::encryption::test;
-using namespace facebook::velox::dwrf;
-using namespace facebook::velox::memory;
-using facebook::velox::VeloxException;
-
-const int32_t DEFAULT_MEM_STREAM_SIZE = 1024 * 1024 * 2; // 2M
-
-class TestBufferPool : public CompressionBufferPool {
- public:
-  TestBufferPool(MemoryPool& pool, uint64_t blockSize)
-      : buffer_{std::make_unique<DataBuffer<char>>(
-            pool,
-            blockSize + PAGE_HEADER_SIZE)} {}
-
-  std::unique_ptr<DataBuffer<char>> getBuffer(uint64_t /* unused */) override {
-    VELOX_CHECK_NOT_NULL(buffer_);
-    return std::move(buffer_);
-  }
-
-  void returnBuffer(std::unique_ptr<DataBuffer<char>> buffer) override {
-    VELOX_CHECK_NULL(buffer_);
-    VELOX_CHECK_NOT_NULL(buffer);
-    buffer_ = std::move(buffer);
-  }
-
- private:
-  std::unique_ptr<DataBuffer<char>> buffer_;
-};
-
-void generateRandomData(char* data, size_t size, bool letter) {
-  for (size_t i = 0; i < size; ++i) {
-    if (letter) {
-      bool capitalized = folly::Random::rand32() % 2 == 0;
-      data[i] = capitalized
-          ? static_cast<char>('A' + folly::Random::rand32() % 26)
-          : static_cast<char>('a' + folly::Random::rand32() % 26);
-    } else {
-      data[i] = static_cast<char>(folly::Random::rand32() % 256);
-    }
-  }
-}
-
-void decompressAndVerify(
-    const MemorySink& memSink,
-    CompressionKind kind,
-    uint64_t blockSize,
-    const char* data,
-    size_t size,
-    MemoryPool& pool,
-    const Decrypter* decrypter) {
-  std::unique_ptr<SeekableInputStream> inputStream(
-      new SeekableArrayInputStream(memSink.data(), memSink.size()));
-
-  std::unique_ptr<SeekableInputStream> decompressStream = createDecompressor(
-      kind,
-      std::move(inputStream),
-      blockSize,
-      pool,
-      "Test Comrpession",
-      decrypter);
-
-  const char* decompressedBuffer;
-  int32_t decompressedSize;
-  int32_t pos = 0;
-  while (decompressStream->Next(
-      reinterpret_cast<const void**>(&decompressedBuffer), &decompressedSize)) {
-    for (int32_t i = 0; i < decompressedSize; ++i) {
-      EXPECT_LT(static_cast<size_t>(pos), size);
-      EXPECT_EQ(data[pos], decompressedBuffer[i]);
-      ++pos;
-    }
-  }
-  ASSERT_EQ(pos, size);
-}
-
-void compressAndVerify(
-    CompressionKind kind,
-    FileSink& sink,
-    uint64_t block,
-    MemoryPool& pool,
-    const char* data,
-    size_t dataSize,
-    const Encrypter* encrypter) {
-  TestBufferPool bufferPool(pool, block);
-  DataBufferHolder holder{
-      pool, block, 0, DEFAULT_PAGE_GROW_RATIO, std::addressof(sink)};
-  Config config;
-  config.set<uint32_t>(Config::COMPRESSION_THRESHOLD, 128);
-  std::unique_ptr<BufferedOutputStream> compressStream =
-      createCompressor(kind, bufferPool, holder, config, encrypter);
-
-  size_t pos = 0;
-  char* compressBuffer;
-  int32_t compressBufferSize = 0;
-  while (dataSize > 0 &&
-         compressStream->Next(
-             reinterpret_cast<void**>(&compressBuffer), &compressBufferSize)) {
-    size_t copy_size =
-        std::min(static_cast<size_t>(compressBufferSize), dataSize);
-    memcpy(compressBuffer, data + pos, copy_size);
-
-    if (copy_size == dataSize) {
-      compressStream->BackUp(
-          compressBufferSize - static_cast<int32_t>(dataSize));
-    }
-
-    pos += copy_size;
-    dataSize -= copy_size;
-  }
-
-  EXPECT_EQ(0, dataSize);
-  compressStream->flush();
-}
-
-typedef std::tuple<CompressionKind, const Encrypter*, const Decrypter*>
-    TestParams;
-TestEncrypter testEncrypter;
-TestDecrypter testDecrypter;
-
-class CompressionTest : public TestWithParam<TestParams> {
- public:
-  void SetUp() override {
-    auto tuple = GetParam();
-    kind_ = std::get<0>(tuple);
-    encrypter_ = std::get<1>(tuple);
-    decrypter_ = std::get<2>(tuple);
-  }
-
- protected:
-  CompressionKind kind_;
-  const Encrypter* encrypter_;
-  const Decrypter* decrypter_;
-};
-
-TEST_P(CompressionTest, compressOriginalString) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
-
-  uint64_t block = 128;
-
-  // simple, short string which will result in the original being saved
-  char testData[] = "hello world!";
-  compressAndVerify(
-      kind_, memSink, block, *pool, testData, sizeof(testData), encrypter_);
-  decompressAndVerify(
-      memSink, kind_, block, testData, sizeof(testData), *pool, decrypter_);
-}
-
-TEST_P(CompressionTest, compressSimpleRepeatedString) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
-
-  constexpr uint64_t block = 128;
-
-  // simple repeated string (128 'a's) which should be compressed
-  char testData[block];
-  std::memset(testData, 'a', block);
-  compressAndVerify(kind_, memSink, block, *pool, testData, block, encrypter_);
-  decompressAndVerify(
-      memSink, kind_, block, testData, block, *pool, decrypter_);
-}
-
-TEST_P(CompressionTest, compressTwoBlocks) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
-
-  uint64_t block = 128;
-  constexpr size_t size = 170;
-
-  // testData will be compressed in two blocks
-  char testData[size];
-  std::memset(testData, 'a', size);
-  compressAndVerify(kind_, memSink, block, *pool, testData, size, encrypter_);
-  decompressAndVerify(memSink, kind_, block, testData, size, *pool, decrypter_);
-}
-
-TEST_P(CompressionTest, compressRandomLetters) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
-
-  uint64_t block = 1024;
-  constexpr size_t dataSize = 1024 * 1024; // 1M
-
-  // testData will be compressed in two blocks
-  char testData[dataSize];
-  generateRandomData(testData, dataSize, true);
-  compressAndVerify(
-      kind_, memSink, block, *pool, testData, dataSize, encrypter_);
-  decompressAndVerify(
-      memSink, kind_, block, testData, dataSize, *pool, decrypter_);
-}
-
-TEST_P(CompressionTest, compressRandomBytes) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
-
-  uint64_t block = 1024;
-  constexpr size_t dataSize = 1024 * 1024; // 1M
-
-  // testData will be compressed in two blocks
-  char testData[dataSize];
-  generateRandomData(testData, dataSize, false);
-  compressAndVerify(
-      kind_, memSink, block, *pool, testData, dataSize, encrypter_);
-  decompressAndVerify(
-      memSink, kind_, block, testData, dataSize, *pool, decrypter_);
-}
-
-void verifyProto(
-    const MemorySink& memSink,
-    CompressionKind kind,
-    uint64_t block,
-    MemoryPool& pool,
-    proto::PostScript& expected,
-    const Decrypter* decrypter) {
-  std::unique_ptr<SeekableInputStream> inputStream(
-      new SeekableArrayInputStream(memSink.data(), memSink.size()));
-
-  std::unique_ptr<SeekableInputStream> decompressStream = createDecompressor(
-      kind, std::move(inputStream), block, pool, "Test Comrpession", decrypter);
-
-  proto::PostScript ps;
-  ps.ParseFromZeroCopyStream(decompressStream.get());
-
-  EXPECT_EQ(expected.footerlength(), ps.footerlength());
-  EXPECT_EQ(expected.compression(), ps.compression());
-  EXPECT_EQ(expected.writerversion(), ps.writerversion());
-}
-
-TEST_P(CompressionTest, compressProtoBuf) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
-
-  uint64_t block = 256;
-
-  proto::PostScript ps;
-  ps.set_footerlength(197934);
-  ps.set_compression(
-      static_cast<proto::CompressionKind>(static_cast<int32_t>(kind_)));
-  ps.set_writerversion(789);
-
-  TestBufferPool bufferPool(*pool, block);
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
-  Config config;
-  std::unique_ptr<BufferedOutputStream> compressStream =
-      createCompressor(kind_, bufferPool, holder, config, encrypter_);
-
-  EXPECT_TRUE(ps.SerializeToZeroCopyStream(compressStream.get()));
-  compressStream->flush();
-
-  verifyProto(memSink, kind_, block, *pool, ps, decrypter_);
-}
-
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    TestCompression,
-    CompressionTest,
-    Values(
-        std::make_tuple(CompressionKind_ZLIB, nullptr, nullptr),
-        std::make_tuple(CompressionKind_ZLIB, &testEncrypter, &testDecrypter),
-        std::make_tuple(CompressionKind_ZSTD, nullptr, nullptr),
-        std::make_tuple(CompressionKind_ZSTD, &testEncrypter, &testDecrypter),
-        std::make_tuple(CompressionKind_NONE, nullptr, nullptr),
-        std::make_tuple(CompressionKind_NONE, &testEncrypter, &testDecrypter)));
-
-typedef std::tuple<CompressionKind, const Encrypter*> TestParams2;
-
-class RecordPositionTest : public TestWithParam<TestParams2> {
- public:
-  void SetUp() override {
-    auto tuple = GetParam();
-    kind_ = std::get<0>(tuple);
-    encrypter_ = std::get<1>(tuple);
-  }
-
- protected:
-  CompressionKind kind_;
-  const Encrypter* encrypter_;
-};
-
-TEST_P(RecordPositionTest, testRecordPosition) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
-  uint64_t block = 256;
-  uint64_t initial = 128;
-
-  TestBufferPool bufferPool(*pool, block);
-  DataBufferHolder holder{
-      *pool, block, initial, DEFAULT_PAGE_GROW_RATIO, &memSink};
-  Config config;
-  std::unique_ptr<BufferedOutputStream> stream =
-      createCompressor(kind_, bufferPool, holder, config, encrypter_);
-
-  TestPositionRecorder recorder;
-  EXPECT_EQ(stream->size(), 0);
-  stream->recordPosition(recorder, 3, 2);
-  {
-    auto& pos = recorder.getPositions();
-    EXPECT_EQ(pos.size(), 2);
-    EXPECT_EQ(pos.at(0), 0);
-    EXPECT_EQ(pos.at(1), 0);
-  }
-
-  int32_t size;
-  void* data;
-  stream->Next(&data, &size);
-  EXPECT_EQ(size, initial);
-  recorder.addEntry();
-  EXPECT_EQ(stream->size(), 0);
-  stream->recordPosition(recorder, size, 100);
-  {
-    auto& pos = recorder.getPositions();
-    EXPECT_EQ(pos.size(), 2);
-    EXPECT_EQ(pos.at(0), 0);
-    EXPECT_EQ(pos.at(1), 100);
-  }
-
-  stream->Next(&data, &size);
-  EXPECT_EQ(size, block - initial);
-  recorder.addEntry();
-  EXPECT_EQ(stream->size(), 0);
-  stream->recordPosition(recorder, size, 100);
-  {
-    auto& pos = recorder.getPositions();
-    EXPECT_EQ(pos.size(), 2);
-    EXPECT_EQ(pos.at(0), 0);
-    EXPECT_EQ(pos.at(1), 100 + initial);
-  }
-
-  stream->Next(&data, &size);
-  EXPECT_EQ(size, block);
-  recorder.addEntry();
-  EXPECT_GT(stream->size(), PAGE_HEADER_SIZE);
-  stream->recordPosition(recorder, size, 100);
-  {
-    auto& pos = recorder.getPositions();
-    EXPECT_EQ(pos.size(), 2);
-    EXPECT_EQ(pos.at(0), stream->size());
-    EXPECT_EQ(pos.at(1), 100);
-  }
-
-  recorder.addEntry();
-  stream->recordPosition(recorder, size, 100, 4);
-  auto& pos = recorder.getPositions(4);
-  EXPECT_EQ(pos.size(), 2);
-  EXPECT_EQ(pos.at(0), stream->size());
-  EXPECT_EQ(pos.at(1), 100);
-}
-
-TEST_P(CompressionTest, getCompressionBufferOOM) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink memSink(10L << 20, {.pool = pool.get()});
-  const uint64_t compressBlockSize{2L << 20};
-
-  struct {
-    bool oomOnNextCall;
-    bool hasSink;
-
-    std::string debugString() const {
-      return fmt::format("oomOnNextCall:{} hasSink:{}", oomOnNextCall, hasSink);
-    }
-  } testSettings[] = {
-      {true, true}, {true, false}, {false, true}, {false, false}};
-
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(
-        fmt::format("{} compression {}", testData.debugString(), kind_));
-
-    auto config = std::make_shared<Config>();
-    config->set<CompressionKind>(Config::COMPRESSION, kind_);
-    config->set<uint32_t>(Config::COMPRESSION_THRESHOLD, compressBlockSize / 2);
-    config->set<uint64_t>(Config::COMPRESSION_BLOCK_SIZE, compressBlockSize);
-    WriterContext context{
-        config,
-        defaultMemoryManager().addRootPool(
-            "oomOnCompression",
-            kind_ == facebook::velox::common::CompressionKind_NONE ? 3L << 20
-                                                                   : 6L << 20)};
-    DataBufferHolder holder{
-        context.getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM),
-        context.compressionBlockSize(),
-        context.getConfigs().get(Config::COMPRESSION_BLOCK_SIZE_MIN),
-        context.getConfigs().get(Config::COMPRESSION_BLOCK_SIZE_EXTEND_RATIO),
-        testData.hasSink ? &memSink : nullptr};
-
-    std::unique_ptr<BufferedOutputStream> compressStream = createCompressor(
-        kind_, context, holder, context.getConfigs(), encrypter_);
-    void* buffer;
-    int32_t nextBufferSize;
-    ASSERT_TRUE(
-        compressStream->Next(&buffer, &nextBufferSize, compressBlockSize));
-    char* data = static_cast<char*>(buffer);
-    for (int i = 0; i < compressBlockSize; ++i) {
-      data[i] = folly::Random::rand32() % 256;
-    }
-    if (testData.oomOnNextCall) {
-      VELOX_ASSERT_THROW(
-          compressStream->Next(&buffer, &nextBufferSize, compressBlockSize),
-          "Exceeded memory pool cap");
-    } else {
-      VELOX_ASSERT_THROW(compressStream->flush(), "Exceeded memory pool cap");
-    }
-    if (kind_ != facebook::velox::common::CompressionKind_NONE) {
-      auto compressionBuffer = context.getBuffer(0);
-      ASSERT_TRUE(compressionBuffer != nullptr);
-      context.returnBuffer(std::move(compressionBuffer));
-    } else {
-      ASSERT_TRUE(context.testingCompressionBuffer() == nullptr);
-    }
-  }
-}
-
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    TestCompression,
-    RecordPositionTest,
-    Values(
-        std::make_tuple(CompressionKind_ZLIB, nullptr),
-        std::make_tuple(CompressionKind_ZLIB, &testEncrypter),
-        std::make_tuple(CompressionKind_ZSTD, nullptr),
-        std::make_tuple(CompressionKind_ZSTD, &testEncrypter),
-        std::make_tuple(CompressionKind_NONE, &testEncrypter)));
-
-TEST(CompressionOptionsTest, testCompressionOptions) {
-  auto options = getDwrfOrcCompressionOptions(
-      facebook::velox::common::CompressionKind_ZLIB, 256, 4, 7);
-
-  EXPECT_EQ(
-      options.format.zlib.windowBits, Compressor::DWRF_ORC_ZLIB_WINDOW_BITS);
-  EXPECT_EQ(options.format.zlib.compressionLevel, 4);
-  EXPECT_EQ(options.compressionThreshold, 256);
-
-  options = getDwrfOrcCompressionOptions(
-      facebook::velox::common::CompressionKind_ZSTD, 256, 4, 7);
-
-  EXPECT_EQ(options.format.zstd.compressionLevel, 7);
-  EXPECT_EQ(options.compressionThreshold, 256);
-}
diff --git a/velox/dwio/dwrf/test/TestDecompression.cpp b/velox/dwio/dwrf/test/TestDecompression.cpp
index 74446372fe063..8d7c9f5b80ab9 100644
--- a/velox/dwio/dwrf/test/TestDecompression.cpp
+++ b/velox/dwio/dwrf/test/TestDecompression.cpp
@@ -20,6 +20,7 @@
 #include <folly/compression/Zlib.h>
 #include <gtest/gtest.h>
 #include "velox/common/base/BitUtil.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/InputStream.h"
 #include "velox/dwio/common/compression/Compression.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
@@ -36,15 +37,37 @@ using namespace folly::io;
 
 const std::string simpleFile(getExampleFilePath("simple-file.binary"));
 
-std::shared_ptr<MemoryPool> pool = addDefaultLeafMemoryPool();
+class DecompressionTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::unique_ptr<SeekableInputStream> createTestDecompressor(
+      CompressionKind kind,
+      std::unique_ptr<SeekableInputStream> input,
+      uint64_t bufferSize) {
+    return createDecompressor(
+        kind, std::move(input), bufferSize, *pool_, "Test Decompression");
+  }
 
-TEST(TestDecompression, testPrintBufferEmpty) {
+  SeekableFileInputStream createSeekableFileInputStream() {
+    auto readFile = std::make_shared<LocalReadFile>(simpleFile);
+    auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
+    return SeekableFileInputStream(
+        std::move(file), 0, 200, *pool_, LogType::TEST, 20);
+  }
+
+  std::shared_ptr<MemoryPool> pool_ = memory::memoryManager()->addLeafPool();
+};
+
+TEST_F(DecompressionTest, testPrintBufferEmpty) {
   std::ostringstream str;
   printBuffer(str, nullptr, 0);
   EXPECT_EQ("", str.str());
 }
 
-TEST(TestDecompression, testPrintBufferSmall) {
+TEST_F(DecompressionTest, testPrintBufferSmall) {
   std::vector<char> buffer(10);
   std::ostringstream str;
   for (size_t i = 0; i < 10; ++i) {
@@ -54,7 +77,7 @@ TEST(TestDecompression, testPrintBufferSmall) {
   EXPECT_EQ("0000000 00 01 02 03 04 05 06 07 08 09\n", str.str());
 }
 
-TEST(TestDecompression, testPrintBufferLong) {
+TEST_F(DecompressionTest, testPrintBufferLong) {
   std::vector<char> buffer(300);
   std::ostringstream str;
   for (size_t i = 0; i < 300; ++i) {
@@ -90,7 +113,7 @@ TEST(TestDecompression, testPrintBufferLong) {
   EXPECT_EQ(expected.str(), str.str());
 }
 
-TEST(TestDecompression, testArrayBackup) {
+TEST_F(DecompressionTest, testArrayBackup) {
   std::vector<char> bytes(200);
   for (size_t i = 0; i < bytes.size(); ++i) {
     bytes[i] = static_cast<char>(i);
@@ -98,7 +121,7 @@ TEST(TestDecompression, testArrayBackup) {
   SeekableArrayInputStream stream(bytes.data(), bytes.size(), 20);
   const void* ptr;
   int32_t len;
-  ASSERT_THROW(stream.BackUp(10), exception::LoggedException);
+  VELOX_ASSERT_THROW(stream.BackUp(10), "(10 vs. 0) Can't backup that much!");
   EXPECT_EQ(true, stream.Next(&ptr, &len));
   EXPECT_EQ(bytes.data(), static_cast<const char*>(ptr));
   EXPECT_EQ(20, len);
@@ -119,11 +142,11 @@ TEST(TestDecompression, testArrayBackup) {
   EXPECT_EQ(10, len);
   EXPECT_EQ(true, !stream.Next(&ptr, &len));
   EXPECT_EQ(0, len);
-  ASSERT_THROW(stream.BackUp(30), exception::LoggedException);
+  VELOX_ASSERT_THROW(stream.BackUp(30), "(30 vs. 20) Can't backup that much!");
   EXPECT_EQ(200, stream.ByteCount());
 }
 
-TEST(TestDecompression, testArraySkip) {
+TEST_F(DecompressionTest, testArraySkip) {
   std::vector<char> bytes(200);
   for (size_t i = 0; i < bytes.size(); ++i) {
     bytes[i] = static_cast<char>(i);
@@ -145,7 +168,7 @@ TEST(TestDecompression, testArraySkip) {
   EXPECT_EQ("SeekableArrayInputStream 200 of 200", stream.getName());
 }
 
-TEST(TestDecompression, testArrayCombo) {
+TEST_F(DecompressionTest, testArrayCombo) {
   std::vector<char> bytes(200);
   for (size_t i = 0; i < bytes.size(); ++i) {
     bytes[i] = static_cast<char>(i);
@@ -175,18 +198,11 @@ void checkBytes(const char* data, int32_t length, uint32_t startValue) {
   }
 }
 
-SeekableFileInputStream createSeekableFileInputStream() {
-  auto readFile = std::make_shared<LocalReadFile>(simpleFile);
-  auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-  return SeekableFileInputStream(
-      std::move(file), 0, 200, *pool, LogType::TEST, 20);
-}
-
-TEST(TestDecompression, testFileBackup) {
+TEST_F(DecompressionTest, testFileBackup) {
   auto stream = createSeekableFileInputStream();
   const void* ptr;
   int32_t len;
-  ASSERT_THROW(stream.BackUp(10), exception::LoggedException);
+  VELOX_ASSERT_THROW(stream.BackUp(10), "(10 vs. 0) can't backup that far");
   EXPECT_EQ(true, stream.Next(&ptr, &len));
   EXPECT_EQ(20, len);
   checkBytes(static_cast<const char*>(ptr), len, 0);
@@ -207,11 +223,11 @@ TEST(TestDecompression, testFileBackup) {
   }
   EXPECT_EQ(true, !stream.Next(&ptr, &len));
   EXPECT_EQ(0, len);
-  ASSERT_THROW(stream.BackUp(30), exception::LoggedException);
+  VELOX_ASSERT_THROW(stream.BackUp(30), "(30 vs. 20) can't backup that far");
   EXPECT_EQ(200, stream.ByteCount());
 }
 
-TEST(TestDecompression, testFileSkip) {
+TEST_F(DecompressionTest, testFileSkip) {
   auto stream = createSeekableFileInputStream();
   const void* ptr;
   int32_t len;
@@ -229,7 +245,7 @@ TEST(TestDecompression, testFileSkip) {
   EXPECT_EQ(std::string(simpleFile) + " from 0 for 200", stream.getName());
 }
 
-TEST(TestDecompression, testFileCombo) {
+TEST_F(DecompressionTest, testFileCombo) {
   auto stream = createSeekableFileInputStream();
   const void* ptr;
   int32_t len;
@@ -247,7 +263,7 @@ TEST(TestDecompression, testFileCombo) {
   EXPECT_EQ(true, !stream.Next(&ptr, &len));
 }
 
-TEST(TestDecompression, testFileSeek) {
+TEST_F(DecompressionTest, testFileSeek) {
   auto stream = createSeekableFileInputStream();
   const void* ptr;
   int32_t len;
@@ -274,22 +290,12 @@ TEST(TestDecompression, testFileSeek) {
   {
     std::vector<uint64_t> offsets(1, 201);
     PositionProvider posn(offsets);
-    EXPECT_THROW(stream.seekToPosition(posn), exception::LoggedException);
+    VELOX_ASSERT_THROW(
+        stream.seekToPosition(posn), "(201 vs. 200) seek too far");
   }
 }
 
-namespace {
-std::unique_ptr<SeekableInputStream> createTestDecompressor(
-    CompressionKind kind,
-    std::unique_ptr<SeekableInputStream> input,
-    uint64_t bufferSize) {
-  return createDecompressor(
-      kind, std::move(input), bufferSize, *pool, "Test Decompression");
-}
-
-} // namespace
-
-TEST(TestDecompression, testCreateNone) {
+TEST_F(DecompressionTest, testCreateNone) {
   std::vector<char> bytes(10);
   for (uint32_t i = 0; i < bytes.size(); ++i) {
     bytes[i] = static_cast<char>(i);
@@ -307,7 +313,7 @@ TEST(TestDecompression, testCreateNone) {
   }
 }
 
-TEST(TestDecompression, testLzoEmpty) {
+TEST_F(DecompressionTest, testLzoEmpty) {
   const unsigned char buffer[] = {0};
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZO,
@@ -322,7 +328,7 @@ TEST(TestDecompression, testLzoEmpty) {
   ASSERT_TRUE(!result->Next(&ptr, &length));
 }
 
-TEST(TestDecompression, testLzoSmall) {
+TEST_F(DecompressionTest, testLzoSmall) {
   const unsigned char buffer[] = {
       70,  0,   0,   48,  88,  88,  88, 88, 97, 98, 99, 100, 97,
       98,  99,  100, 65,  66,  67,  68, 65, 66, 67, 68, 119, 120,
@@ -344,7 +350,7 @@ TEST(TestDecompression, testLzoSmall) {
   ASSERT_TRUE(!result->Next(&ptr, &length));
 }
 
-TEST(TestDecompression, testLzoLong) {
+TEST_F(DecompressionTest, testLzoLong) {
   // set up a framed lzo buffer with 100,000 'a'
   unsigned char buffer[482];
   bzero(buffer, VELOX_ARRAY_SIZE(buffer));
@@ -384,7 +390,7 @@ TEST(TestDecompression, testLzoLong) {
   ASSERT_TRUE(!result->Next(&ptr, &length));
 }
 
-TEST(TestDecompression, testLz4Empty) {
+TEST_F(DecompressionTest, testLz4Empty) {
   const unsigned char buffer[] = {0};
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZ4,
@@ -399,7 +405,7 @@ TEST(TestDecompression, testLz4Empty) {
   ASSERT_TRUE(!result->Next(&ptr, &length));
 }
 
-TEST(TestDecompression, testLz4Small) {
+TEST_F(DecompressionTest, testLz4Small) {
   const unsigned char buffer[] = {60,  0,   0,   128, 88,  88,  88,  88,  97,
                                   98,  99,  100, 4,   0,   64,  65,  66,  67,
                                   68,  4,   0,   176, 119, 120, 121, 122, 119,
@@ -421,7 +427,7 @@ TEST(TestDecompression, testLz4Small) {
   ASSERT_TRUE(!result->Next(&ptr, &length));
 }
 
-TEST(TestDecompression, testLz4Long) {
+TEST_F(DecompressionTest, testLz4Long) {
   // set up a framed lzo buffer with 100,000 'a'
   unsigned char buffer[406];
   memset(buffer, 255, VELOX_ARRAY_SIZE(buffer));
@@ -454,7 +460,7 @@ TEST(TestDecompression, testLz4Long) {
   ASSERT_TRUE(!result->Next(&ptr, &length));
 }
 
-TEST(TestDecompression, testCreateZlib) {
+TEST_F(DecompressionTest, testCreateZlib) {
   const unsigned char buffer[] = {0x0b, 0x0, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4};
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
@@ -484,7 +490,7 @@ TEST(TestDecompression, testCreateZlib) {
   }
 }
 
-TEST(TestDecompression, testLiteralBlocks) {
+TEST_F(DecompressionTest, testLiteralBlocks) {
   const unsigned char buffer[] = {0x19, 0x0, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4,
                                   0x5,  0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xb,
                                   0x0,  0x0, 0xc, 0xd, 0xe, 0xf, 0x10};
@@ -527,7 +533,7 @@ TEST(TestDecompression, testLiteralBlocks) {
   EXPECT_EQ(16, static_cast<const char*>(ptr)[2]);
 }
 
-TEST(TestDecompression, testInflate) {
+TEST_F(DecompressionTest, testInflate) {
   const unsigned char buffer[] = {
       0xe, 0x0, 0x0, 0x63, 0x60, 0x64, 0x62, 0xc0, 0x8d, 0x0};
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
@@ -546,7 +552,7 @@ TEST(TestDecompression, testInflate) {
   }
 }
 
-TEST(TestDecompression, testInflateSequence) {
+TEST_F(DecompressionTest, testInflateSequence) {
   const unsigned char buffer[] = {0xe,  0x0,  0x0,  0x63, 0x60, 0x64, 0x62,
                                   0xc0, 0x8d, 0x0,  0xe,  0x0,  0x0,  0x63,
                                   0x60, 0x64, 0x62, 0xc0, 0x8d, 0x0};
@@ -581,7 +587,7 @@ TEST(TestDecompression, testInflateSequence) {
   }
 }
 
-TEST(TestDecompression, testSkipZlib) {
+TEST_F(DecompressionTest, testSkipZlib) {
   const unsigned char buffer[] = {0x19, 0x0, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4,
                                   0x5,  0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xb,
                                   0x0,  0x0, 0xc, 0xd, 0xe, 0xf, 0x10};
@@ -659,7 +665,7 @@ class CompressBuffer {
   }
 };
 
-TEST(TestDecompression, testBasic) {
+TEST_F(DecompressionTest, testBasic) {
   const int32_t N = 1024;
   std::vector<char> buf(N * sizeof(int));
   for (int32_t i = 0; i < N; ++i) {
@@ -692,7 +698,7 @@ TEST(TestDecompression, testBasic) {
   }
 }
 
-TEST(TestDecompression, testMultiBuffer) {
+TEST_F(DecompressionTest, testMultiBuffer) {
   const int32_t N = 1024;
   std::vector<char> buf(N * sizeof(int));
   for (int32_t i = 0; i < N; ++i) {
@@ -740,7 +746,7 @@ TEST(TestDecompression, testMultiBuffer) {
   }
 }
 
-TEST(TestDecompression, testSkipSnappy) {
+TEST_F(DecompressionTest, testSkipSnappy) {
   const int32_t N = 1024;
   std::vector<char> buf(N * sizeof(int));
   for (int32_t i = 0; i < N; ++i) {
@@ -776,7 +782,7 @@ TEST(TestDecompression, testSkipSnappy) {
   }
 }
 
-TEST(TestDecompression, testDelayedSkip) {
+TEST_F(DecompressionTest, testDelayedSkip) {
   constexpr int32_t N = 1024;
   std::vector<int> buf(N);
   for (int32_t i = 0; i < N; ++i) {
@@ -852,8 +858,21 @@ compress(char* buf, size_t size, char* output, size_t offset, Codec& codec) {
 
 class TestSeek : public ::testing::Test {
  public:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   ~TestSeek() override {}
-  static void runTest(Codec& codec, CompressionKind kind) {
+
+  std::unique_ptr<SeekableInputStream> createTestDecompressor(
+      CompressionKind kind,
+      std::unique_ptr<SeekableInputStream> input,
+      uint64_t bufferSize) {
+    return createDecompressor(
+        kind, std::move(input), bufferSize, *pool_, "Test Decompression");
+  }
+
+  void runTest(Codec& codec, CompressionKind kind) {
     constexpr size_t inputSize = 1024;
     constexpr size_t outputSize = 4096;
     char output[outputSize];
@@ -862,14 +881,13 @@ class TestSeek : public ::testing::Test {
     size_t offset1;
     size_t offset2;
     prepareTestData(codec, input1, input2, inputSize, output, offset1, offset2);
-    auto pool = addDefaultLeafMemoryPool();
 
     std::unique_ptr<SeekableInputStream> stream = createDecompressor(
         kind,
         std::unique_ptr<SeekableInputStream>(
             new SeekableArrayInputStream(output, offset2, outputSize / 10)),
         outputSize,
-        *pool,
+        *pool_,
         "TestSeek Decompressor",
         nullptr);
 
@@ -907,6 +925,8 @@ class TestSeek : public ::testing::Test {
     offset1 = compress(input1, inputSize, output, 0, codec);
     offset2 = compress(input2, inputSize, output, offset1, codec);
   }
+
+  std::shared_ptr<MemoryPool> pool_ = memory::memoryManager()->addLeafPool();
 };
 
 TEST_F(TestSeek, Zlib) {
@@ -1014,11 +1034,13 @@ class TestingSeekableInputStream : public SeekableInputStream {
     VELOX_CHECK_LE(count, lastSize_);
     position_ -= count;
   }
-  bool Skip(int32_t count) override {
+
+  bool SkipInt64(int64_t count) override {
     VELOX_CHECK_LE(count + position_, length_);
     position_ += count;
     return true;
   }
+
   google::protobuf::int64 ByteCount() const override {
     return position_;
   }
@@ -1135,8 +1157,6 @@ TEST_F(TestSeek, uncompressedLarge) {
     return 0;
   };
   // Start and size of last Next as offsets to content (no headers).
-  int32_t lastReadStart = 0;
-  int32_t lastReadSize = 0;
 
   for (auto& pair : ranges) {
     uint64_t target = pair.first;
@@ -1150,8 +1170,6 @@ TEST_F(TestSeek, uncompressedLarge) {
       EXPECT_EQ(result, addressForOffset(target + readSize));
       EXPECT_EQ(
           size, readSizeForAddress(reinterpret_cast<const char*>(result)));
-      lastReadStart = target + readSize;
-      lastReadSize = size;
       readSize += size;
     } while (readSize < targetSize);
   }
diff --git a/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp b/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
index a7bca793619cc..fc5bed6dea5ed 100644
--- a/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
+++ b/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
@@ -23,7 +23,14 @@ using namespace testing;
 using namespace facebook::velox::memory;
 
 namespace facebook::velox::dwrf {
-TEST(TestDictionaryEncodingUtils, StringGetSortedIndexLookupTable) {
+class DictionaryEncodingUtilsTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(DictionaryEncodingUtilsTest, StringGetSortedIndexLookupTable) {
   struct TestCase {
     explicit TestCase(
         bool sort,
@@ -91,7 +98,7 @@ TEST(TestDictionaryEncodingUtils, StringGetSortedIndexLookupTable) {
           {0, 1, 2, 3}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       stringDictEncoder.addKey(key, 0);
@@ -137,7 +144,7 @@ TEST(TestDictionaryEncodingUtils, StringGetSortedIndexLookupTable) {
   }
 }
 
-TEST(TestDictionaryEncodingUtils, StringStrideDictOptimization) {
+TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
   constexpr size_t kStrideSize{10};
   struct TestCase {
     explicit TestCase(
@@ -296,7 +303,7 @@ TEST(TestDictionaryEncodingUtils, StringStrideDictOptimization) {
   };
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     size_t rowCount = 0;
     for (const auto& key : testCase.addKeySequence) {
diff --git a/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp b/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp
new file mode 100644
index 0000000000000..cf13c6df826b6
--- /dev/null
+++ b/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp
@@ -0,0 +1,500 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/dwrf/test/ColumnStatisticsBase.h"
+#include "velox/type/fbhive/HiveTypeParser.h"
+
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwrf;
+using facebook::velox::type::fbhive::HiveTypeParser;
+
+class ColumnStatisticsTest : public ::testing::Test,
+                             public ColumnStatisticsBase {};
+
+TEST_F(ColumnStatisticsTest, size) {
+  testSize();
+}
+
+TEST_F(ColumnStatisticsTest, integer) {
+  testInteger();
+}
+
+TEST_F(ColumnStatisticsTest, integerMissingStats) {
+  proto::ColumnStatistics proto;
+  auto intProto = proto.mutable_intstatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testIntegerMissingStats(columnStatisticsWrapper, intProto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, integerEmptyStats) {
+  proto::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testIntegerEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, integerOverflow) {
+  testIntegerOverflow();
+}
+
+TEST_F(ColumnStatisticsTest, doubles) {
+  testDoubles();
+}
+
+TEST_F(ColumnStatisticsTest, doubleMissingStats) {
+  proto::ColumnStatistics proto;
+  auto doubleProto = proto.mutable_doublestatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testDoubleMissingStats(
+      columnStatisticsWrapper, doubleProto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, doubleEmptyStats) {
+  proto::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testDoubleEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, doubleNaN) {
+  testDoubleNaN();
+}
+
+TEST_F(ColumnStatisticsTest, string) {
+  testString();
+}
+
+TEST_F(ColumnStatisticsTest, stringMissingStats) {
+  proto::ColumnStatistics proto;
+  auto strProto = proto.mutable_stringstatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testStringMissingStats(columnStatisticsWrapper, strProto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, stringEmptyStats) {
+  proto::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testStringEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, stringLengthThreshold) {
+  testStringLengthThreshold();
+}
+
+TEST_F(ColumnStatisticsTest, stringLengthOverflow) {
+  proto::ColumnStatistics proto;
+  proto.set_numberofvalues(1);
+  auto strProto = proto.mutable_stringstatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testStringLengthOverflow(
+      columnStatisticsWrapper, strProto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, boolean) {
+  testBoolean();
+}
+
+TEST_F(ColumnStatisticsTest, booleanMissingStats) {
+  proto::ColumnStatistics proto;
+  auto boolProto = proto.mutable_bucketstatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBooleanMissingStats(
+      columnStatisticsWrapper, boolProto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, booleanEmptyStats) {
+  proto::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBooleanEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, basic) {
+  testBasic();
+}
+
+TEST_F(ColumnStatisticsTest, basicMissingStats) {
+  proto::ColumnStatistics proto;
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBasicMissingStats(columnStatisticsWrapper);
+}
+
+TEST_F(ColumnStatisticsTest, basicHasNull) {
+  proto::ColumnStatistics proto;
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBasicHasNull(columnStatisticsWrapper, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, binary) {
+  testBinary();
+}
+
+TEST_F(ColumnStatisticsTest, binaryMissingStats) {
+  proto::ColumnStatistics proto;
+  auto binProto = proto.mutable_binarystatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBinaryMissingStats(columnStatisticsWrapper, binProto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, binaryEmptyStats) {
+  proto::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBinaryEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, binaryLengthOverflow) {
+  proto::ColumnStatistics proto;
+  auto binProto = proto.mutable_binarystatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBinaryLengthOverflow(
+      columnStatisticsWrapper, binProto, DwrfFormat::kDwrf);
+}
+
+TEST_F(ColumnStatisticsTest, initialSize) {
+  testInitialSize();
+}
+
+proto::KeyInfo createKeyInfo(int64_t key) {
+  proto::KeyInfo keyInfo;
+  keyInfo.set_intkey(key);
+  return keyInfo;
+}
+
+inline bool operator==(
+    const ColumnStatistics& lhs,
+    const ColumnStatistics& rhs) {
+  return (lhs.hasNull() == rhs.hasNull()) &&
+      (lhs.getNumberOfValues() == rhs.getNumberOfValues()) &&
+      (lhs.getRawSize() == rhs.getRawSize());
+}
+
+void checkEntries(
+    const std::vector<ColumnStatistics>& entries,
+    const std::vector<ColumnStatistics>& expectedEntries) {
+  EXPECT_EQ(expectedEntries.size(), entries.size());
+  for (const auto& entry : entries) {
+    EXPECT_NE(
+        std::find_if(
+            expectedEntries.begin(),
+            expectedEntries.end(),
+            [&](const ColumnStatistics& expectedStats) {
+              return expectedStats == entry;
+            }),
+        expectedEntries.end());
+  }
+}
+
+struct TestKeyStats {
+  TestKeyStats(int64_t key, bool hasNull, uint64_t valueCount, uint64_t rawSize)
+      : key{key}, hasNull{hasNull}, valueCount{valueCount}, rawSize{rawSize} {}
+
+  int64_t key;
+  bool hasNull;
+  uint64_t valueCount;
+  uint64_t rawSize;
+};
+
+struct MapStatsAddValueTestCase {
+  explicit MapStatsAddValueTestCase(
+      const std::vector<TestKeyStats>& input,
+      const std::vector<TestKeyStats>& expected)
+      : input{input}, expected{expected} {}
+
+  std::vector<TestKeyStats> input;
+  std::vector<TestKeyStats> expected;
+};
+
+class MapStatisticsBuilderAddValueTest
+    : public ::testing::Test,
+      public ::testing::WithParamInterface<MapStatsAddValueTestCase> {};
+
+StatisticsBuilderOptions options{16};
+TEST_P(MapStatisticsBuilderAddValueTest, addValues) {
+  auto type = HiveTypeParser{}.parse("map<int, float>");
+  MapStatisticsBuilder mapStatsBuilder{*type, options};
+
+  for (const auto& entry : GetParam().input) {
+    StatisticsBuilder statsBuilder{options};
+    if (entry.hasNull) {
+      statsBuilder.setHasNull();
+    }
+    statsBuilder.increaseValueCount(entry.valueCount);
+    statsBuilder.increaseRawSize(entry.rawSize);
+    mapStatsBuilder.addValues(createKeyInfo(entry.key), statsBuilder);
+  }
+
+  const auto& expectedTestEntries = GetParam().expected;
+  std::vector<ColumnStatistics> expectedEntryStats{};
+  expectedEntryStats.reserve(expectedTestEntries.size());
+  for (const auto& entry : expectedTestEntries) {
+    StatisticsBuilder statsBuilder{options};
+    if (entry.hasNull) {
+      statsBuilder.setHasNull();
+    }
+    statsBuilder.increaseValueCount(entry.valueCount);
+    statsBuilder.increaseRawSize(entry.rawSize);
+    expectedEntryStats.push_back(statsBuilder);
+  }
+
+  std::vector<ColumnStatistics> entryStats;
+  const auto& outputEntries = mapStatsBuilder.getEntryStatistics();
+  entryStats.reserve(outputEntries.size());
+  for (const auto& entry : outputEntries) {
+    entryStats.push_back(*entry.second);
+  }
+
+  checkEntries(entryStats, expectedEntryStats);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    MapStatisticsBuilderAddValueTestSuite,
+    MapStatisticsBuilderAddValueTest,
+    testing::Values(
+        MapStatsAddValueTestCase{{}, {}},
+        MapStatsAddValueTestCase{
+            {TestKeyStats{1, false, 1, 21}},
+            {TestKeyStats{1, false, 1, 21}}},
+        MapStatsAddValueTestCase{
+            {TestKeyStats{1, false, 1, 21}, TestKeyStats{1, true, 3, 42}},
+            {TestKeyStats{1, true, 4, 63}}},
+        MapStatsAddValueTestCase{
+            {TestKeyStats{1, false, 1, 21}, TestKeyStats{2, true, 3, 42}},
+            {TestKeyStats{1, false, 1, 21}, TestKeyStats{2, true, 3, 42}}},
+        MapStatsAddValueTestCase{
+            {TestKeyStats{1, false, 1, 21},
+             TestKeyStats{2, false, 3, 42},
+             TestKeyStats{2, false, 3, 42},
+             TestKeyStats{1, true, 1, 42}},
+            {TestKeyStats{1, true, 2, 63}, TestKeyStats{2, false, 6, 84}}}));
+
+struct MapStatsMergeTestCase {
+  std::vector<std::vector<TestKeyStats>> inputs;
+  std::vector<TestKeyStats> expected;
+};
+
+class MapStatisticsBuilderMergeTest
+    : public ::testing::Test,
+      public ::testing::WithParamInterface<MapStatsMergeTestCase> {};
+
+TEST_P(MapStatisticsBuilderMergeTest, addValues) {
+  auto type = HiveTypeParser{}.parse("map<int, float>");
+
+  const auto& inputTestEntries = GetParam().inputs;
+  std::vector<std::unique_ptr<MapStatisticsBuilder>> mapStatsBuilders;
+  mapStatsBuilders.reserve(inputTestEntries.size());
+  for (const auto& input : inputTestEntries) {
+    std::unique_ptr<MapStatisticsBuilder> mapStatsBuilder =
+        std::make_unique<MapStatisticsBuilder>(*type, options);
+    for (const auto& entry : input) {
+      StatisticsBuilder statsBuilder{options};
+      if (entry.hasNull) {
+        statsBuilder.setHasNull();
+      }
+      statsBuilder.increaseValueCount(entry.valueCount);
+      statsBuilder.increaseRawSize(entry.rawSize);
+      mapStatsBuilder->addValues(createKeyInfo(entry.key), statsBuilder);
+    }
+    mapStatsBuilders.push_back(std::move(mapStatsBuilder));
+  }
+
+  MapStatisticsBuilder aggregateMapStatsBuilder{*type, options};
+  for (const auto& mapStatsBuilder : mapStatsBuilders) {
+    aggregateMapStatsBuilder.merge(*mapStatsBuilder);
+  }
+
+  const auto& expectedTestEntries = GetParam().expected;
+  std::vector<ColumnStatistics> expectedEntryStats{};
+  expectedEntryStats.reserve(expectedTestEntries.size());
+  for (const auto& entry : expectedTestEntries) {
+    StatisticsBuilder statsBuilder{options};
+    if (entry.hasNull) {
+      statsBuilder.setHasNull();
+    }
+    statsBuilder.increaseValueCount(entry.valueCount);
+    statsBuilder.increaseRawSize(entry.rawSize);
+    expectedEntryStats.push_back(statsBuilder);
+  }
+
+  std::vector<ColumnStatistics> entryStats;
+  const auto& aggregatedEntries = aggregateMapStatsBuilder.getEntryStatistics();
+  entryStats.reserve(aggregatedEntries.size());
+  for (const auto& entry : aggregatedEntries) {
+    entryStats.push_back(*entry.second);
+  }
+
+  checkEntries(entryStats, expectedEntryStats);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    MapStatisticsBuilderMergeTestSuite,
+    MapStatisticsBuilderMergeTest,
+    testing::Values(
+        MapStatsMergeTestCase{{}, {}},
+        MapStatsMergeTestCase{
+            {{TestKeyStats{1, false, 1, 21}}},
+            {TestKeyStats{1, false, 1, 21}}},
+        MapStatsMergeTestCase{
+            {{}, {TestKeyStats{1, false, 1, 21}}},
+            {TestKeyStats{1, false, 1, 21}}},
+        MapStatsMergeTestCase{
+            {{TestKeyStats{1, false, 1, 21}}, {TestKeyStats{1, true, 3, 42}}},
+            {TestKeyStats{1, true, 4, 63}}},
+        MapStatsMergeTestCase{
+            {{TestKeyStats{1, false, 1, 21}}, {TestKeyStats{2, true, 3, 42}}},
+            {TestKeyStats{1, false, 1, 21}, TestKeyStats{2, true, 3, 42}}},
+        MapStatsMergeTestCase{
+            {{TestKeyStats{1, false, 1, 21}, TestKeyStats{2, false, 3, 42}},
+             {TestKeyStats{2, false, 3, 42}},
+             {TestKeyStats{1, true, 1, 42}}},
+            {TestKeyStats{1, true, 2, 63}, TestKeyStats{2, false, 6, 84}}}));
+
+TEST(MapStatisticsBuilderTest, innerStatsType) {
+  {
+    auto type = HiveTypeParser{}.parse("map<int, float>");
+    MapStatisticsBuilder mapStatsBuilder{*type, options};
+
+    DoubleStatisticsBuilder statsBuilder{options};
+    statsBuilder.addValues(0.1);
+    statsBuilder.addValues(1.0);
+    mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder);
+
+    auto& doubleStats = dynamic_cast<DoubleColumnStatistics&>(
+        *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
+
+    EXPECT_EQ(0.1, doubleStats.getMinimum());
+    EXPECT_EQ(1.0, doubleStats.getMaximum());
+  }
+  {
+    auto type = HiveTypeParser{}.parse("map<bigint, bigint>");
+    MapStatisticsBuilder mapStatsBuilder{*type, options};
+
+    IntegerStatisticsBuilder statsBuilder{options};
+    statsBuilder.addValues(1);
+    statsBuilder.addValues(2);
+    mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder);
+
+    auto& intStats = dynamic_cast<IntegerColumnStatistics&>(
+        *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
+
+    EXPECT_EQ(1, intStats.getMinimum());
+    EXPECT_EQ(2, intStats.getMaximum());
+    EXPECT_EQ(3, intStats.getSum());
+  }
+}
+
+TEST(MapStatisticsBuilderTest, incrementSize) {
+  auto type = HiveTypeParser{}.parse("map<int, float>");
+  MapStatisticsBuilder mapStatsBuilder{*type, options};
+
+  DoubleStatisticsBuilder statsBuilder1{options};
+  statsBuilder1.addValues(0.1);
+  statsBuilder1.addValues(1.0);
+  ASSERT_FALSE(statsBuilder1.getSize().has_value());
+  mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder1);
+  EXPECT_FALSE(mapStatsBuilder.getEntryStatistics()
+                   .at(KeyInfo{1})
+                   ->getSize()
+                   .has_value());
+
+  DoubleStatisticsBuilder statsBuilder2{options};
+  statsBuilder2.addValues(0.3);
+  statsBuilder2.addValues(3.0);
+  ASSERT_FALSE(statsBuilder2.getSize().has_value());
+  mapStatsBuilder.addValues(createKeyInfo(2), statsBuilder2);
+  EXPECT_FALSE(mapStatsBuilder.getEntryStatistics()
+                   .at(KeyInfo{2})
+                   ->getSize()
+                   .has_value());
+
+  mapStatsBuilder.incrementSize(createKeyInfo(1), 4);
+  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
+                  .at(KeyInfo{1})
+                  ->getSize()
+                  .has_value());
+  EXPECT_EQ(
+      4,
+      mapStatsBuilder.getEntryStatistics().at(KeyInfo{1})->getSize().value());
+  ASSERT_FALSE(mapStatsBuilder.getEntryStatistics()
+                   .at(KeyInfo{2})
+                   ->getSize()
+                   .has_value());
+  mapStatsBuilder.incrementSize(createKeyInfo(2), 8);
+  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
+                  .at(KeyInfo{1})
+                  ->getSize()
+                  .has_value());
+  EXPECT_EQ(
+      4,
+      mapStatsBuilder.getEntryStatistics().at(KeyInfo{1})->getSize().value());
+  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
+                  .at(KeyInfo{2})
+                  ->getSize()
+                  .has_value());
+  EXPECT_EQ(
+      8,
+      mapStatsBuilder.getEntryStatistics().at(KeyInfo{2})->getSize().value());
+
+  mapStatsBuilder.incrementSize(createKeyInfo(1), 8);
+  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
+                  .at(KeyInfo{1})
+                  ->getSize()
+                  .has_value());
+  EXPECT_EQ(
+      12,
+      mapStatsBuilder.getEntryStatistics().at(KeyInfo{1})->getSize().value());
+  ASSERT_TRUE(mapStatsBuilder.getEntryStatistics()
+                  .at(KeyInfo{2})
+                  ->getSize()
+                  .has_value());
+  EXPECT_EQ(
+      8,
+      mapStatsBuilder.getEntryStatistics().at(KeyInfo{2})->getSize().value());
+}
+
+TEST(MapStatisticsBuilderTest, mergeKeyStats) {
+  auto type = HiveTypeParser{}.parse("map<bigint, bigint>");
+  MapStatisticsBuilder mapStatsBuilder{*type, options};
+
+  mapStatsBuilder.incrementSize(createKeyInfo(1), 42);
+  auto& keyStats = dynamic_cast<StatisticsBuilder&>(
+      *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
+  ASSERT_EQ(0, keyStats.getNumberOfValues());
+  ASSERT_TRUE(keyStats.getRawSize().has_value());
+  ASSERT_EQ(0, keyStats.getRawSize().value());
+  ASSERT_TRUE(keyStats.getSize().has_value());
+  ASSERT_EQ(42, keyStats.getSize().value());
+
+  IntegerStatisticsBuilder statsBuilder{options};
+  statsBuilder.addValues(1);
+  statsBuilder.addValues(2);
+  statsBuilder.increaseRawSize(8);
+  mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder);
+
+  keyStats = dynamic_cast<StatisticsBuilder&>(
+      *mapStatsBuilder.getEntryStatistics().at(KeyInfo{1}));
+  ASSERT_EQ(2, keyStats.getNumberOfValues());
+  ASSERT_TRUE(keyStats.getRawSize().has_value());
+  ASSERT_EQ(8, keyStats.getRawSize().value());
+  EXPECT_TRUE(keyStats.getSize().has_value());
+  EXPECT_EQ(42, keyStats.getSize().value());
+}
diff --git a/velox/dwio/dwrf/test/TestEncodingSelector.cpp b/velox/dwio/dwrf/test/TestEncodingSelector.cpp
index 6df2b7c63d895..a74e47fd9d0bc 100644
--- a/velox/dwio/dwrf/test/TestEncodingSelector.cpp
+++ b/velox/dwio/dwrf/test/TestEncodingSelector.cpp
@@ -21,9 +21,15 @@
 using namespace facebook::velox::memory;
 
 namespace facebook::velox::dwrf {
+class EntropyEncodingSelectorTests : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
-TEST(TestEntropyEncodingSelector, Ctor) {
-  auto pool = addDefaultLeafMemoryPool();
+TEST_F(EntropyEncodingSelectorTests, Ctor) {
+  auto pool = memoryManager()->addLeafPool();
   float slightlyOver = 1.0f + std::numeric_limits<float>::epsilon() * 2;
   float slightlyUnder = -std::numeric_limits<float>::epsilon();
   EXPECT_ANY_THROW(
@@ -70,7 +76,7 @@ class EntropyEncodingSelectorTest {
         decision_{decision} {}
 
   void runTest() const {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     dwio::common::DataBuffer<uint32_t> rows{*pool};
     rows.reserve(size_);
@@ -88,7 +94,7 @@ class EntropyEncodingSelectorTest {
   }
 };
 
-TEST(TestEntropyEncodingSelector, NoHeuristic) {
+TEST_F(EntropyEncodingSelectorTests, NoHeuristic) {
   class TestCase : public EntropyEncodingSelectorTest {
    public:
     explicit TestCase(
@@ -131,7 +137,7 @@ TEST(TestEntropyEncodingSelector, NoHeuristic) {
   }
 }
 
-TEST(TestEntropyEncodingSelector, NoSampling) {
+TEST_F(EntropyEncodingSelectorTests, NoSampling) {
   class TestCase : public EntropyEncodingSelectorTest {
    public:
     explicit TestCase(
@@ -181,7 +187,7 @@ std::string alphabeticRoundRobin(size_t index, size_t size) {
   return std::string(size % (index + 1), element);
 }
 
-TEST(TestEntropyEncodingSelector, Sampling) {
+TEST_F(EntropyEncodingSelectorTests, Sampling) {
   class TestCase : public EntropyEncodingSelectorTest {
    public:
     explicit TestCase(
diff --git a/velox/dwio/dwrf/test/TestIntDirect.cpp b/velox/dwio/dwrf/test/TestIntDirect.cpp
index e0860029bf34f..9b7e9e425086a 100644
--- a/velox/dwio/dwrf/test/TestIntDirect.cpp
+++ b/velox/dwio/dwrf/test/TestIntDirect.cpp
@@ -16,6 +16,7 @@
 
 #include <folly/Random.h>
 #include "velox/common/base/Nulls.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/IntDecoder.h"
 #include "velox/dwio/dwrf/common/DecoderUtil.h"
 #include "velox/dwio/dwrf/common/EncoderUtil.h"
@@ -30,7 +31,7 @@ using namespace facebook::velox::dwrf;
 
 template <typename T, bool isSigned, bool vInt>
 void testInts(std::function<T()> generator) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   constexpr size_t count = 10240;
   DataBuffer<T> buffer{*pool, count};
   std::array<uint64_t, count / 64> nulls;
@@ -96,7 +97,7 @@ void testInts(std::function<T()> generator) {
     if (numRead + stride >= count / 2) {
       break;
     }
-    decoder->skipLongsFast(stride);
+    decoder->skip(stride);
     numRead += stride;
     stride = (stride * 2 + 1) % 31;
     int64_t num;
@@ -134,37 +135,44 @@ void testInts(std::function<T()> generator) {
   }
 }
 
-TEST(TestDirect, fixedWidthShort) {
+class DirectTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(DirectTest, fixedWidthShort) {
   testInts<int16_t, true, false>([]() -> int16_t {
     return static_cast<int16_t>(folly::Random::rand32());
   });
 }
 
-TEST(TestDirect, fixedWidthInt) {
+TEST_F(DirectTest, fixedWidthInt) {
   testInts<int32_t, true, false>(
       []() -> int32_t { return folly::Random::rand32(); });
 }
 
-TEST(TestDirect, fixedWidthLong) {
+TEST_F(DirectTest, fixedWidthLong) {
   testInts<int64_t, true, false>(
       []() -> int64_t { return folly::Random::rand64(); });
 }
 
-TEST(TestDirect, vIntSignedShort) {
+TEST_F(DirectTest, vIntSignedShort) {
   folly::Random::DefaultGenerator rng;
   rng.seed(2);
   testInts<int16_t, true, true>(
       [&]() -> int16_t { return folly::Random::rand32(rng); });
 }
 
-TEST(TestDirect, vIntSignedInt) {
+TEST_F(DirectTest, vIntSignedInt) {
   folly::Random::DefaultGenerator rng;
   rng.seed(2);
   testInts<int64_t, true, true>(
       [&]() -> int32_t { return folly::Random::rand32(rng); });
 }
 
-TEST(TestDirect, vIntSignedLong) {
+TEST_F(DirectTest, vIntSignedLong) {
   folly::Random::DefaultGenerator rng;
   rng.seed(2);
   int32_t count = 0;
@@ -178,7 +186,7 @@ TEST(TestDirect, vIntSignedLong) {
   });
 }
 
-TEST(TestDirect, vIntUnsignedLong) {
+TEST_F(DirectTest, vIntUnsignedLong) {
   folly::Random::DefaultGenerator rng;
   rng.seed(1);
   int32_t count = 0;
@@ -214,11 +222,10 @@ void testCorruptedVarInts() {
   std::array<int64_t, 2> vals;
   // First value is always read on the slow path.
   decoder->next(vals.data(), 1, nullptr);
-  EXPECT_THROW(decoder->next(vals.data(), 1, nullptr);
-               , exception::LoggedException);
+  VELOX_ASSERT_THROW(decoder->next(vals.data(), 1, nullptr), "");
 }
 
-TEST(TestDirect, corruptedInts) {
+TEST_F(DirectTest, corruptedInts) {
   testCorruptedVarInts<false>();
   testCorruptedVarInts<true>();
 }
diff --git a/velox/dwio/dwrf/test/TestIntegerDictionaryEncoder.cpp b/velox/dwio/dwrf/test/TestIntegerDictionaryEncoder.cpp
index 873449568d59c..8f1e1675c5840 100644
--- a/velox/dwio/dwrf/test/TestIntegerDictionaryEncoder.cpp
+++ b/velox/dwio/dwrf/test/TestIntegerDictionaryEncoder.cpp
@@ -29,6 +29,7 @@ class TestIntegerDictionaryEncoder : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     FLAGS_velox_enable_memory_usage_track_in_default_memory_pool = true;
+    memory::MemoryManager::testingSetInstance({});
   }
 };
 
@@ -50,7 +51,7 @@ TEST_F(TestIntegerDictionaryEncoder, AddKey) {
       TestCase{{-2, 2, 2, -2, 2}, {0, 1, 1, 0, 1}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     IntegerDictionaryEncoder<int64_t> intDictEncoder{*pool, *pool};
     std::vector<size_t> actualEncodedSequence{};
     for (const auto& key : testCase.addKeySequence) {
@@ -83,7 +84,7 @@ TEST_F(TestIntegerDictionaryEncoder, GetCount) {
           {3, 2, 3, 3, 2}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     IntegerDictionaryEncoder<int64_t> intDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       intDictEncoder.addKey(key);
@@ -115,7 +116,7 @@ TEST_F(TestIntegerDictionaryEncoder, GetTotalCount) {
       TestCase{{-2, 1, 2, 0, -1, 1, 0, 2, 0, -2, -1, -2, 1}, 13}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     IntegerDictionaryEncoder<int64_t> intDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       intDictEncoder.addKey(key);
@@ -126,7 +127,7 @@ TEST_F(TestIntegerDictionaryEncoder, GetTotalCount) {
 }
 
 TEST_F(TestIntegerDictionaryEncoder, Clear) {
-  auto pool = addDefaultLeafMemoryPool();
+  auto pool = memoryManager()->addLeafPool();
   {
     IntegerDictionaryEncoder<int64_t> intDictEncoder{*pool, *pool};
     EXPECT_EQ(1, intDictEncoder.refCount_);
@@ -207,7 +208,7 @@ TEST_F(TestIntegerDictionaryEncoder, Clear) {
 }
 
 TEST_F(TestIntegerDictionaryEncoder, RepeatedFlush) {
-  auto pool = addDefaultLeafMemoryPool();
+  auto pool = memoryManager()->addLeafPool();
   IntegerDictionaryEncoder<int64_t> intDictEncoder{*pool, *pool};
   std::vector<int> keys{0, 1, 4, 9, 16, 25, 9, 1};
   for (const auto& key : keys) {
@@ -233,7 +234,7 @@ TEST_F(TestIntegerDictionaryEncoder, RepeatedFlush) {
 }
 
 TEST_F(TestIntegerDictionaryEncoder, Limit) {
-  auto pool = addDefaultLeafMemoryPool();
+  auto pool = memoryManager()->addLeafPool();
   IntegerDictionaryEncoder<int16_t> intDictEncoder{*pool, *pool};
   for (size_t iter = 0; iter < 2; ++iter) {
     int16_t val = std::numeric_limits<int16_t>::min();
@@ -270,7 +271,7 @@ void testGetSortedIndexLookupTable() {
       TestCase{{-1, 0, -2, 2, 1}, false, {0, 1, 2, 3, 4}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     IntegerDictionaryEncoder<T> intDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       intDictEncoder.addKey(key);
@@ -337,7 +338,7 @@ TEST_F(TestIntegerDictionaryEncoder, ShortIntegerDictionary) {
     values.emplace_back(static_cast<int16_t>(i));
   }
 
-  auto pool = addDefaultLeafMemoryPool();
+  auto pool = memoryManager()->addLeafPool();
   IntegerDictionaryEncoder<int16_t> intDictEncoder{*pool, *pool};
   dwio::common::DataBuffer<bool> inDict{*pool};
   dwio::common::DataBuffer<int16_t> lookupTable{*pool};
@@ -450,7 +451,7 @@ void testInfrequentKeyOptimization() {
           24}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     IntegerDictionaryEncoder<T> intDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       intDictEncoder.addKey(key);
diff --git a/velox/dwio/dwrf/test/TestOrcColumnStatistics.cpp b/velox/dwio/dwrf/test/TestOrcColumnStatistics.cpp
new file mode 100644
index 0000000000000..db11bf2439aa6
--- /dev/null
+++ b/velox/dwio/dwrf/test/TestOrcColumnStatistics.cpp
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/dwrf/test/ColumnStatisticsBase.h"
+
+using namespace facebook::velox::dwrf;
+
+class ColumnStatisticsTest : public ::testing::Test,
+                             public ColumnStatisticsBase {};
+
+TEST_F(ColumnStatisticsTest, size) {
+  testSize();
+}
+
+TEST_F(ColumnStatisticsTest, integer) {
+  testInteger();
+}
+
+TEST_F(ColumnStatisticsTest, integerMissingStats) {
+  proto::orc::ColumnStatistics proto;
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  auto intProto = proto.mutable_intstatistics();
+  testIntegerMissingStats(columnStatisticsWrapper, intProto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, integerEmptyStats) {
+  proto::orc::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testIntegerEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, integerOverflow) {
+  testIntegerOverflow();
+}
+
+TEST_F(ColumnStatisticsTest, doubles) {
+  testDoubles();
+}
+
+TEST_F(ColumnStatisticsTest, doubleMissingStats) {
+  proto::orc::ColumnStatistics proto;
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  auto doubleProto = proto.mutable_doublestatistics();
+  testDoubleMissingStats(
+      columnStatisticsWrapper, doubleProto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, doubleEmptyStats) {
+  proto::orc::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testDoubleEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, doubleNaN) {
+  testDoubleNaN();
+}
+
+TEST_F(ColumnStatisticsTest, string) {
+  testString();
+}
+
+TEST_F(ColumnStatisticsTest, stringMissingStats) {
+  proto::orc::ColumnStatistics proto;
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  auto strProto = proto.mutable_stringstatistics();
+  testStringMissingStats(columnStatisticsWrapper, strProto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, stringEmptyStats) {
+  proto::orc::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testStringEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, stringLengthThreshold) {
+  testStringLengthThreshold();
+}
+
+TEST_F(ColumnStatisticsTest, stringLengthOverflow) {
+  proto::orc::ColumnStatistics proto;
+  proto.set_numberofvalues(1);
+  auto strProto = proto.mutable_stringstatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testStringLengthOverflow(columnStatisticsWrapper, strProto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, boolean) {
+  testBoolean();
+}
+
+TEST_F(ColumnStatisticsTest, booleanMissingStats) {
+  proto::orc::ColumnStatistics proto;
+  auto boolProto = proto.mutable_bucketstatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBooleanMissingStats(columnStatisticsWrapper, boolProto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, booleanEmptyStats) {
+  proto::orc::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBooleanEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, basic) {
+  testBasic();
+}
+
+TEST_F(ColumnStatisticsTest, basicMissingStats) {
+  proto::orc::ColumnStatistics proto;
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBasicMissingStats(columnStatisticsWrapper);
+}
+
+TEST_F(ColumnStatisticsTest, basicHasNull) {
+  proto::orc::ColumnStatistics proto;
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBasicHasNull(columnStatisticsWrapper, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, binary) {
+  testBinary();
+}
+
+TEST_F(ColumnStatisticsTest, binaryMissingStats) {
+  proto::orc::ColumnStatistics proto;
+  auto binProto = proto.mutable_binarystatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBinaryMissingStats(columnStatisticsWrapper, binProto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, binaryEmptyStats) {
+  proto::orc::ColumnStatistics proto;
+  proto.set_numberofvalues(0);
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBinaryEmptyStats(
+      columnStatisticsWrapper, (void*)&proto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, binaryLengthOverflow) {
+  proto::orc::ColumnStatistics proto;
+  auto binProto = proto.mutable_binarystatistics();
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  testBinaryLengthOverflow(columnStatisticsWrapper, binProto, DwrfFormat::kOrc);
+}
+
+TEST_F(ColumnStatisticsTest, initialSize) {
+  testInitialSize();
+}
+
+TEST(MapStatistics, orcUnsupportedMapStatistics) {
+  proto::orc::ColumnStatistics proto;
+  auto columnStatisticsWrapper = ColumnStatisticsWrapper(&proto);
+  ASSERT_FALSE(columnStatisticsWrapper.hasMapStatistics());
+  ASSERT_THROW(
+      columnStatisticsWrapper.mapStatistics(),
+      ::facebook::velox::VeloxRuntimeError);
+}
diff --git a/velox/dwio/dwrf/test/TestRLEv1Encoder.cpp b/velox/dwio/dwrf/test/TestRLEv1Encoder.cpp
index ece7c19cdb767..3c0c4e87460d9 100644
--- a/velox/dwio/dwrf/test/TestRLEv1Encoder.cpp
+++ b/velox/dwio/dwrf/test/TestRLEv1Encoder.cpp
@@ -86,57 +86,62 @@ void decodeAndVerify(
   delete[] decodedData;
 }
 
-class RleEncoderV1Test : public testing::Test {};
+class RleEncoderV1Test : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+};
 
-TEST(RleEncoderV1Test, encodeMinAndMax) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, encodeMinAndMax) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<false> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
 
   auto data = folly::make_array(INT64_MIN, INT64_MAX, INT64_MIN);
   encoder.add(data.data(), common::Ranges::of(0, 2), nullptr);
-  EXPECT_TRUE(encoder.isOverflow);
+  EXPECT_TRUE(encoder.overflow_);
 
   encoder.add(data.data(), common::Ranges::of(2, 3), nullptr);
-  EXPECT_TRUE(encoder.isOverflow);
+  EXPECT_TRUE(encoder.overflow_);
   encoder.flush();
 
   decodeAndVerify<false>(memSink, data.data(), 2, nullptr);
 }
 
-TEST(RleEncoderV1Test, encodeMinAndMaxint32) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, encodeMinAndMaxint32) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<true> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
 
   auto data = folly::make_array(INT32_MIN, INT32_MAX, INT32_MIN);
   encoder.add(data.data(), common::Ranges::of(0, 2), nullptr);
-  EXPECT_FALSE(encoder.isOverflow);
+  EXPECT_FALSE(encoder.overflow_);
 
   encoder.add(data.data(), common::Ranges::of(2, 3), nullptr);
-  EXPECT_FALSE(encoder.isOverflow);
+  EXPECT_FALSE(encoder.overflow_);
 
   encoder.flush();
 
   decodeAndVerify<true>(memSink, data.data(), 2, nullptr);
 }
 
-TEST(RleEncoderV1Test, deltaIncreasingSequanceUnsigned) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, deltaIncreasingSequanceUnsigned) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<false> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
@@ -150,12 +155,11 @@ TEST(RleEncoderV1Test, deltaIncreasingSequanceUnsigned) {
   delete[] data;
 }
 
-TEST(RleEncoderV1Test, deltaIncreasingSequanceUnsignedNull) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, deltaIncreasingSequanceUnsignedNull) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<false> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
@@ -171,12 +175,11 @@ TEST(RleEncoderV1Test, deltaIncreasingSequanceUnsignedNull) {
   delete[] nulls;
 }
 
-TEST(RleEncoderV1Test, deltaDecreasingSequanceUnsigned) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, deltaDecreasingSequanceUnsigned) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<false> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
@@ -190,12 +193,11 @@ TEST(RleEncoderV1Test, deltaDecreasingSequanceUnsigned) {
   delete[] data;
 }
 
-TEST(RleEncoderV1Test, deltaDecreasingSequanceSigned) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, deltaDecreasingSequanceSigned) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<true> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
@@ -209,12 +211,11 @@ TEST(RleEncoderV1Test, deltaDecreasingSequanceSigned) {
   delete[] data;
 }
 
-TEST(RleEncoderV1Test, deltaDecreasingSequanceSignedNull) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, deltaDecreasingSequanceSignedNull) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<true> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
@@ -230,12 +231,11 @@ TEST(RleEncoderV1Test, deltaDecreasingSequanceSignedNull) {
   delete[] nulls;
 }
 
-TEST(RleEncoderV1Test, randomSequanceSigned) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, randomSequanceSigned) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<true> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
@@ -249,12 +249,11 @@ TEST(RleEncoderV1Test, randomSequanceSigned) {
   delete[] data;
 }
 
-TEST(RleEncoderV1Test, allNull) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, allNull) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<true> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
@@ -270,12 +269,11 @@ TEST(RleEncoderV1Test, allNull) {
   delete[] nulls;
 }
 
-TEST(RleEncoderV1Test, recordPosition) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, recordPosition) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<true> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
@@ -292,12 +290,11 @@ TEST(RleEncoderV1Test, recordPosition) {
   EXPECT_EQ(pos.at(1), size - 130);
 }
 
-TEST(RleEncoderV1Test, backfillPosition) {
-  auto pool = memory::addDefaultLeafMemoryPool();
-  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool.get()});
+TEST_F(RleEncoderV1Test, backfillPosition) {
+  MemorySink memSink(DEFAULT_MEM_STREAM_SIZE, {.pool = pool_.get()});
 
   uint64_t block = 1024;
-  DataBufferHolder holder{*pool, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
+  DataBufferHolder holder{*pool_, block, 0, DEFAULT_PAGE_GROW_RATIO, &memSink};
 
   RleEncoderV1<true> encoder(
       std::make_unique<BufferedOutputStream>(holder), true, 8);
diff --git a/velox/dwio/dwrf/test/TestReadFile.h b/velox/dwio/dwrf/test/TestReadFile.h
new file mode 100644
index 0000000000000..30b35de2b277f
--- /dev/null
+++ b/velox/dwio/dwrf/test/TestReadFile.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/io/IoStatistics.h"
+
+#include "velox/common/file/File.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::dwio::common {
+
+// Testing stream producing deterministic data. The byte at offset is
+// the low byte of 'seed_' + offset.
+class TestReadFile : public velox::ReadFile {
+ public:
+  TestReadFile(
+      uint64_t seed,
+      uint64_t length,
+      std::shared_ptr<io::IoStatistics> ioStats)
+      : seed_(seed), length_(length), ioStats_(std::move(ioStats)) {}
+
+  uint64_t size() const override {
+    return length_;
+  }
+
+  std::string_view pread(uint64_t offset, uint64_t length, void* buffer)
+      const override {
+    const uint64_t content = offset + seed_;
+    const uint64_t available = std::min(length_ - offset, length);
+    int fill;
+    for (fill = 0; fill < available; ++fill) {
+      reinterpret_cast<char*>(buffer)[fill] = content + fill;
+    }
+    return std::string_view(static_cast<const char*>(buffer), fill);
+  }
+
+  uint64_t preadv(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers) const override {
+    auto res = ReadFile::preadv(offset, buffers);
+    ++numIos_;
+    return res;
+  }
+
+  // Asserts that 'bytes' is as would be read from 'offset'.
+  void checkData(const void* bytes, uint64_t offset, int32_t size) {
+    for (auto i = 0; i < size; ++i) {
+      char expected = seed_ + offset + i;
+      ASSERT_EQ(expected, reinterpret_cast<const char*>(bytes)[i])
+          << " at " << offset + i;
+    }
+  }
+
+  uint64_t memoryUsage() const override {
+    VELOX_NYI();
+  }
+
+  bool shouldCoalesce() const override {
+    VELOX_NYI();
+  }
+
+  int64_t numIos() const {
+    return numIos_;
+  }
+
+  std::string getName() const override {
+    return "<TestReadFile>";
+  }
+
+  uint64_t getNaturalReadSize() const override {
+    VELOX_NYI();
+  }
+
+ private:
+  const uint64_t seed_;
+  const uint64_t length_;
+  std::shared_ptr<io::IoStatistics> ioStats_;
+  mutable std::atomic<int64_t> numIos_{0};
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/dwrf/test/TestRle.cpp b/velox/dwio/dwrf/test/TestRle.cpp
index 26222848de57a..9b18b81b66987 100644
--- a/velox/dwio/dwrf/test/TestRle.cpp
+++ b/velox/dwio/dwrf/test/TestRle.cpp
@@ -31,7 +31,7 @@ std::vector<int64_t> decodeRLEv2(
     size_t n,
     size_t count,
     const uint64_t* nulls = nullptr) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::make_unique<dwio::common::SeekableArrayInputStream>(bytes, l),
       RleVersion_2,
@@ -73,7 +73,14 @@ void checkResults(
   }
 }
 
-TEST(RLEv2, basicDelta0) {
+class RLEv2Test : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(RLEv2Test, basicDelta0) {
   const size_t count = 20;
   std::vector<int64_t> values;
   for (size_t i = 0; i < count; ++i) {
@@ -89,7 +96,7 @@ TEST(RLEv2, basicDelta0) {
   checkResults(values, decodeRLEv2(bytes, l, count, count), count);
 };
 
-TEST(RLEv2, basicDelta1) {
+TEST_F(RLEv2Test, basicDelta1) {
   std::vector<int64_t> values(5);
   values[0] = -500;
   values[1] = -400;
@@ -110,7 +117,7 @@ TEST(RLEv2, basicDelta1) {
       values.size());
 };
 
-TEST(RLEv2, basicDelta2) {
+TEST_F(RLEv2Test, basicDelta2) {
   std::vector<int64_t> values(5);
   values[0] = -500;
   values[1] = -600;
@@ -131,7 +138,7 @@ TEST(RLEv2, basicDelta2) {
       values.size());
 };
 
-TEST(RLEv2, basicDelta3) {
+TEST_F(RLEv2Test, basicDelta3) {
   std::vector<int64_t> values(5);
   values[0] = 500;
   values[1] = 400;
@@ -152,7 +159,7 @@ TEST(RLEv2, basicDelta3) {
       values.size());
 };
 
-TEST(RLEv2, basicDelta4) {
+TEST_F(RLEv2Test, basicDelta4) {
   std::vector<int64_t> values(5);
   values[0] = 500;
   values[1] = 600;
@@ -173,8 +180,8 @@ TEST(RLEv2, basicDelta4) {
       values.size());
 };
 
-TEST(RLEv2, delta0Width) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv2Test, delta0Width) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {
       0x4e, 0x2, 0x0, 0x1, 0x2, 0xc0, 0x2, 0x42, 0x0};
   std::unique_ptr<dwio::common::IntDecoder<false>> decoder =
@@ -196,7 +203,7 @@ TEST(RLEv2, delta0Width) {
   EXPECT_EQ(0x42, values[5]);
 }
 
-TEST(RLEv2, basicDelta0WithNulls) {
+TEST_F(RLEv2Test, basicDelta0WithNulls) {
   std::vector<int64_t> values;
   uint64_t nulls[1];
   size_t idx = 0;
@@ -222,7 +229,7 @@ TEST(RLEv2, basicDelta0WithNulls) {
       values, decodeRLEv2(bytes, l, count, count, nulls), count, nulls);
 };
 
-TEST(RLEv2, shortRepeats) {
+TEST_F(RLEv2Test, shortRepeats) {
   const size_t runLength = 7;
   const size_t nVals = 10;
   const size_t count = nVals * runLength;
@@ -244,7 +251,7 @@ TEST(RLEv2, shortRepeats) {
   checkResults(values, decodeRLEv2(bytes, l, count, count), count);
 };
 
-TEST(RLEv2, multiByteShortRepeats) {
+TEST_F(RLEv2Test, multiByteShortRepeats) {
   const size_t runLength = 7;
   const size_t nVals = 3;
   const size_t count = nVals * runLength;
@@ -267,8 +274,8 @@ TEST(RLEv2, multiByteShortRepeats) {
   checkResults(values, decodeRLEv2(bytes, l, count, count), count);
 };
 
-TEST(RLEv2, 0to2Repeat1Direct) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv2Test, 0to2Repeat1Direct) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0x46, 0x02, 0x02, 0x40};
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
@@ -286,7 +293,7 @@ TEST(RLEv2, 0to2Repeat1Direct) {
   }
 };
 
-TEST(RLEv2, bitSize2Direct) {
+TEST_F(RLEv2Test, bitSize2Direct) {
   // 0,1 repeated 10 times (signed ints)
   const size_t count = 20;
   std::vector<int64_t> values;
@@ -303,7 +310,7 @@ TEST(RLEv2, bitSize2Direct) {
   checkResults(values, decodeRLEv2(bytes, l, count, count), count);
 };
 
-TEST(RLEv2, bitSize4Direct) {
+TEST_F(RLEv2Test, bitSize4Direct) {
   // 0,2 repeated 10 times (signed ints)
   const size_t count = 20;
   std::vector<int64_t> values;
@@ -322,7 +329,7 @@ TEST(RLEv2, bitSize4Direct) {
   checkResults(values, decodeRLEv2(bytes, l, count, count), count);
 };
 
-TEST(RLEv2, multipleRunsDirect) {
+TEST_F(RLEv2Test, multipleRunsDirect) {
   std::vector<int64_t> values;
   // 0,1 repeated 10 times (signed ints)
   for (size_t i = 0; i < 20; ++i) {
@@ -365,8 +372,8 @@ TEST(RLEv2, multipleRunsDirect) {
       values.size());
 };
 
-TEST(RLEv2, largeNegativesDirect) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv2Test, largeNegativesDirect) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {
       0x7e, 0x04, 0xcf, 0xca, 0xcc, 0x91, 0xba, 0x38, 0x93, 0xab, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -390,7 +397,7 @@ TEST(RLEv2, largeNegativesDirect) {
   EXPECT_EQ(-5535739865598783616, data[4]) << "Output wrong at " << 4;
 };
 
-TEST(RLEv2, overflowDirect) {
+TEST_F(RLEv2Test, overflowDirect) {
   std::vector<int64_t> values(4);
   values[0] = 4513343538618202719l;
   values[1] = 4513343538618202711l;
@@ -412,7 +419,7 @@ TEST(RLEv2, overflowDirect) {
       values.size());
 };
 
-TEST(RLEv2, basicPatched0) {
+TEST_F(RLEv2Test, basicPatched0) {
   long v[] = {2030, 2000, 2020, 1000000, 2040, 2050, 2060, 2070, 2080, 2090};
   std::vector<int64_t> values;
   for (size_t i = 0; i < sizeof(v) / sizeof(long); ++i) {
@@ -449,7 +456,7 @@ TEST(RLEv2, basicPatched0) {
       values.size());
 };
 
-TEST(RLEv2, basicPatched1) {
+TEST_F(RLEv2Test, basicPatched1) {
   long v[] = {20, 2,   3,    2,   1,  3, 17,  71,  35, 2,   1,    139,   2,
               2,  3,   1783, 475, 2,  1, 1,   3,   1,  3,   2,    32,    1,
               2,  3,   1,    8,   30, 1, 3,   414, 1,  1,   135,  3,     3,
@@ -488,7 +495,7 @@ TEST(RLEv2, basicPatched1) {
       values.size());
 };
 
-TEST(RLEv2, mixedPatchedAndShortRepeats) {
+TEST_F(RLEv2Test, mixedPatchedAndShortRepeats) {
   long v[] = {20,  2,   3,    2,   1,  3,  17,  71,   35,  2,   1,    139,   2,
               2,   3,   1783, 475, 2,  1,  1,   3,    1,   3,   2,    32,    1,
               2,   3,   1,    8,   30, 1,  3,   414,  1,   1,   135,  3,     3,
@@ -548,8 +555,8 @@ TEST(RLEv2, mixedPatchedAndShortRepeats) {
       values.size());
 };
 
-TEST(RLEv2, basicDirectSeek) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv2Test, basicDirectSeek) {
+  auto pool = memory::memoryManager()->addLeafPool();
   // 0,1 repeated 10 times (signed ints) followed by
   // 0,2 repeated 10 times (signed ints)
   const unsigned char bytes[] = {
@@ -600,8 +607,8 @@ TEST(RLEv2, basicDirectSeek) {
   EXPECT_EQ(2, data[0]);
 };
 
-TEST(RLEv2, bitsLeftByPreviousStream) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv2Test, bitsLeftByPreviousStream) {
+  auto pool = memory::memoryManager()->addLeafPool();
   // test for #109
   // 118 DIRECT values, followed by PATHCED values
   const unsigned char bytes[] = {
@@ -666,8 +673,15 @@ TEST(RLEv2, bitsLeftByPreviousStream) {
   }
 };
 
-TEST(RLEv1, simpleTest) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+class RLEv1Test : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(RLEv1Test, simpleTest) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {
       0x61, 0xff, 0x64, 0xfb, 0x02, 0x03, 0x5, 0x7, 0xb};
   std::unique_ptr<dwio::common::IntDecoder<false>> rle =
@@ -692,8 +706,8 @@ TEST(RLEv1, simpleTest) {
   EXPECT_EQ(11, data[104]);
 };
 
-TEST(RLEv1, signedNullLiteralTest) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, signedNullLiteralTest) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0xf8, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7};
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
@@ -712,8 +726,8 @@ TEST(RLEv1, signedNullLiteralTest) {
   }
 }
 
-TEST(RLEv1, splitHeader) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, splitHeader) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0x0, 0x00, 0xdc, 0xba, 0x98, 0x76};
   std::unique_ptr<dwio::common::IntDecoder<false>> rle =
       createRleDecoder<false>(
@@ -732,8 +746,8 @@ TEST(RLEv1, splitHeader) {
   }
 }
 
-TEST(RLEv1, splitRuns) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, splitRuns) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {
       0x7d, 0x01, 0xff, 0x01, 0xfb, 0x01, 0x02, 0x03, 0x04, 0x05};
   dwio::common::SeekableInputStream* const stream =
@@ -766,8 +780,8 @@ TEST(RLEv1, splitRuns) {
   EXPECT_EQ(5, data[0]);
 }
 
-TEST(RLEv1, testSigned) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, testSigned) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0x7f, 0xff, 0x20};
   dwio::common::SeekableInputStream* const stream =
       new dwio::common::SeekableArrayInputStream(
@@ -790,8 +804,8 @@ TEST(RLEv1, testSigned) {
   }
 }
 
-TEST(RLEv1, testNull) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, testNull) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0x75, 0x02, 0x00};
   dwio::common::SeekableInputStream* const stream =
       new dwio::common::SeekableArrayInputStream(
@@ -822,8 +836,8 @@ TEST(RLEv1, testNull) {
   }
 }
 
-TEST(RLEv1, testAllNulls) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, testAllNulls) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0xf0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
                                   0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
                                   0x0d, 0x0e, 0x0f, 0x3d, 0x00, 0x12};
@@ -862,8 +876,8 @@ TEST(RLEv1, testAllNulls) {
   rle->next(data.data(), data.size(), allNull.data());
 }
 
-TEST(RLEv1, skipTest) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, skipTest) {
+  auto pool = memory::memoryManager()->addLeafPool();
   // Create the RLE stream from Java's TestRunLengthIntegerEncoding.testSkips
   // for (size_t i = 0; i < 1024; ++i)
   //   out.write(i);
@@ -1104,8 +1118,8 @@ TEST(RLEv1, skipTest) {
   }
 }
 
-TEST(RLEv1, seekTest) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, seekTest) {
+  auto pool = memory::memoryManager()->addLeafPool();
   // Create the RLE stream from Java's
   // TestRunLengthIntegerEncoding.testUncompressedSeek
   // for (size_t i = 0; i < 1024; ++i)
@@ -1858,9 +1872,8 @@ TEST(RLEv1, seekTest) {
       151, 12,  193, 190, 224, 143, 9,   129, 245, 133, 204, 8,   182, 209, 250,
       178, 8,   148, 139, 144, 193, 11,  230, 182, 245, 164, 7,   149, 204, 161,
       226, 14,  175, 229, 148, 166, 13,  148, 140, 189, 216, 3};
-  dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+  auto* stream = new dwio::common::SeekableArrayInputStream(
+      buffer, VELOX_ARRAY_SIZE(buffer));
   const long junk[] = {
       -1192035722, 1672896916,  1491444859,  -1244121273, -791680696,
       1681943525,  -571055948,  -1744759283, -998345856,  240559198,
@@ -2969,8 +2982,16 @@ TEST(RLEv1, seekTest) {
       *pool,
       true,
       dwio::common::INT_BYTE_SIZE);
+  ASSERT_EQ(stream->totalRead(), 0);
+  auto lastTotalReadBytes = stream->totalRead();
+  auto getNumReadBytes = [&] {
+    auto ans = stream->totalRead() - lastTotalReadBytes;
+    lastTotalReadBytes = stream->totalRead();
+    return ans;
+  };
   std::vector<int64_t> data(2048);
   rle->next(data.data(), data.size(), nullptr);
+  ASSERT_EQ(getNumReadBytes(), VELOX_ARRAY_SIZE(buffer));
   for (size_t i = 0; i < data.size(); ++i) {
     if (i < 1024) {
       EXPECT_EQ(i / 4, data[i]) << "Wrong output at " << i;
@@ -2979,6 +3000,7 @@ TEST(RLEv1, seekTest) {
     }
   }
   rle->next(data.data(), data.size(), nullptr);
+  ASSERT_EQ(getNumReadBytes(), 0);
   for (size_t i = 0; i < data.size(); ++i) {
     EXPECT_EQ(junk[i], data[i]) << "Wrong output at " << i;
   }
@@ -2987,7 +3009,9 @@ TEST(RLEv1, seekTest) {
     --i;
     dwio::common::PositionProvider location(positions[i]);
     rle->seekToRowGroup(location);
+    ASSERT_EQ(getNumReadBytes(), 0);
     rle->next(data.data(), 1, nullptr);
+    ASSERT_GT(getNumReadBytes(), 0);
     if (i < 1024) {
       EXPECT_EQ(i / 4, data[0]) << "Wrong output at " << i;
     } else if (i < 2048) {
@@ -3003,6 +3027,7 @@ TEST(RLEv1, seekTest) {
   position.push_back(0);
   dwio::common::PositionProvider pp{position};
   rle->seekToRowGroup(pp);
+  ASSERT_EQ(getNumReadBytes(), 0);
   // Seek is fine, but read should fail
   EXPECT_THROW(rle->next(data.data(), 1, nullptr), VeloxException);
 
@@ -3011,11 +3036,14 @@ TEST(RLEv1, seekTest) {
   position.push_back(VELOX_ARRAY_SIZE(buffer));
   position.push_back(1);
   dwio::common::PositionProvider pp2{position};
-  EXPECT_THROW(rle->seekToRowGroup(pp2), VeloxException);
+  // Seek is fine (because it's lazy), but read should fail
+  rle->seekToRowGroup(pp2);
+  ASSERT_EQ(getNumReadBytes(), 0);
+  EXPECT_THROW(rle->next(data.data(), 1, nullptr), VeloxException);
 }
 
-TEST(RLEv1, testLeadingNulls) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(RLEv1Test, testLeadingNulls) {
+  auto pool = memory::memoryManager()->addLeafPool();
   const unsigned char buffer[] = {0xfb, 0x01, 0x02, 0x03, 0x04, 0x05};
   std::unique_ptr<dwio::common::IntDecoder<false>> rle =
       createRleDecoder<false>(
diff --git a/velox/dwio/dwrf/test/TestStatisticsBuilderUtils.cpp b/velox/dwio/dwrf/test/TestStatisticsBuilderUtils.cpp
index ffce2b0cf3683..6f4afacbd297e 100644
--- a/velox/dwio/dwrf/test/TestStatisticsBuilderUtils.cpp
+++ b/velox/dwio/dwrf/test/TestStatisticsBuilderUtils.cpp
@@ -52,20 +52,29 @@ std::shared_ptr<FlatVector<T>> makeFlatVectorNoNulls(
   return makeFlatVector<T>(pool, BufferPtr(nullptr), 0, length, values);
 }
 
-TEST(TestStatisticsBuilderUtils, addIntegerValues) {
+class TestStatisticsBuilderUtils : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  const std::shared_ptr<memory::MemoryPool> pool_ =
+      memory::memoryManager()->addLeafPool();
+};
+
+TEST_F(TestStatisticsBuilderUtils, addIntegerValues) {
   IntegerStatisticsBuilder builder{options};
 
   // add values non null
-  auto pool = memory::addDefaultLeafMemoryPool();
   size_t size = 10;
 
-  auto values = AlignedBuffer::allocate<int32_t>(size, pool.get());
+  auto values = AlignedBuffer::allocate<int32_t>(size, pool_.get());
   auto* valuesPtr = values->asMutable<int32_t>();
   for (size_t i = 0; i < size; ++i) {
     valuesPtr[i] = i + 1;
   }
 
-  auto vec = makeFlatVectorNoNulls<int32_t>(pool.get(), size, values);
+  auto vec = makeFlatVectorNoNulls<int32_t>(pool_.get(), size, values);
   {
     StatisticsBuilderUtils::addValues<int32_t>(
         builder, vec, common::Ranges::of(0, size));
@@ -79,10 +88,10 @@ TEST(TestStatisticsBuilderUtils, addIntegerValues) {
   }
 
   // add values with null
-  auto nulls = allocateNulls(size, pool.get());
+  auto nulls = allocateNulls(size, pool_.get());
   bits::setNull(nulls->asMutable<uint64_t>(), 3);
 
-  vec = makeFlatVector<int32_t>(pool.get(), nulls, 1, size, values);
+  vec = makeFlatVector<int32_t>(pool_.get(), nulls, 1, size, values);
 
   {
     StatisticsBuilderUtils::addValues<int32_t>(
@@ -97,21 +106,20 @@ TEST(TestStatisticsBuilderUtils, addIntegerValues) {
   }
 }
 
-TEST(TestStatisticsBuilderUtils, addDoubleValues) {
+TEST_F(TestStatisticsBuilderUtils, addDoubleValues) {
   DoubleStatisticsBuilder builder{options};
 
   // add values non null
-  auto pool = memory::addDefaultLeafMemoryPool();
   size_t size = 10;
 
-  auto values = AlignedBuffer::allocate<float>(size, pool.get());
+  auto values = AlignedBuffer::allocate<float>(size, pool_.get());
   auto* valuesPtr = values->asMutable<float>();
   for (size_t i = 0; i < size; ++i) {
     valuesPtr[i] = i + 1;
   }
 
   {
-    auto vec = makeFlatVectorNoNulls<float>(pool.get(), size, values);
+    auto vec = makeFlatVectorNoNulls<float>(pool_.get(), size, values);
     StatisticsBuilderUtils::addValues<float>(
         builder, vec, common::Ranges::of(0, size));
     auto stats = builder.build();
@@ -124,11 +132,11 @@ TEST(TestStatisticsBuilderUtils, addDoubleValues) {
   }
 
   // add values with null
-  auto nulls = allocateNulls(size, pool.get());
+  auto nulls = allocateNulls(size, pool_.get());
   bits::setNull(nulls->asMutable<uint64_t>(), 3);
 
   {
-    auto vec = makeFlatVector<float>(pool.get(), nulls, 1, size, values);
+    auto vec = makeFlatVector<float>(pool_.get(), nulls, 1, size, values);
 
     StatisticsBuilderUtils::addValues<float>(
         builder, vec, common::Ranges::of(0, size));
@@ -142,14 +150,13 @@ TEST(TestStatisticsBuilderUtils, addDoubleValues) {
   }
 }
 
-TEST(TestStatisticsBuilderUtils, addStringValues) {
+TEST_F(TestStatisticsBuilderUtils, addStringValues) {
   StringStatisticsBuilder builder{options};
 
   // add values non null
-  auto pool = memory::addDefaultLeafMemoryPool();
   size_t size = 10;
 
-  auto values = AlignedBuffer::allocate<StringView>(10, pool.get());
+  auto values = AlignedBuffer::allocate<StringView>(10, pool_.get());
   auto* valuesPtr = values->asMutable<StringView>();
   char c = 'a';
   for (size_t i = 0; i < size; ++i, ++c) {
@@ -157,7 +164,7 @@ TEST(TestStatisticsBuilderUtils, addStringValues) {
   }
 
   {
-    auto vec = makeFlatVectorNoNulls<StringView>(pool.get(), size, values);
+    auto vec = makeFlatVectorNoNulls<StringView>(pool_.get(), size, values);
     StatisticsBuilderUtils::addValues(
         builder, vec, common::Ranges::of(0, size));
     auto stats = builder.build();
@@ -170,11 +177,11 @@ TEST(TestStatisticsBuilderUtils, addStringValues) {
   }
 
   // add values with null
-  auto nulls = allocateNulls(size, pool.get());
+  auto nulls = allocateNulls(size, pool_.get());
   bits::setNull(nulls->asMutable<uint64_t>(), 3);
 
   {
-    auto vec = makeFlatVector<StringView>(pool.get(), nulls, 1, size, values);
+    auto vec = makeFlatVector<StringView>(pool_.get(), nulls, 1, size, values);
     StatisticsBuilderUtils::addValues(
         builder, vec, common::Ranges::of(0, size));
     auto stats = builder.build();
@@ -187,14 +194,13 @@ TEST(TestStatisticsBuilderUtils, addStringValues) {
   }
 }
 
-TEST(TestStatisticsBuilderUtils, addBooleanValues) {
+TEST_F(TestStatisticsBuilderUtils, addBooleanValues) {
   BooleanStatisticsBuilder builder{options};
 
   // add values non null
-  auto pool = memory::addDefaultLeafMemoryPool();
   size_t size = 10;
 
-  auto values = AlignedBuffer::allocate<bool>(size, pool.get());
+  auto values = AlignedBuffer::allocate<bool>(size, pool_.get());
   auto valuesPtr = values->asMutableRange<bool>();
   for (int32_t i = 0; i < size; ++i) {
     valuesPtr[i] = true;
@@ -202,7 +208,7 @@ TEST(TestStatisticsBuilderUtils, addBooleanValues) {
   valuesPtr[6] = false;
 
   {
-    auto vec = makeFlatVectorNoNulls<bool>(pool.get(), size, values);
+    auto vec = makeFlatVectorNoNulls<bool>(pool_.get(), size, values);
 
     StatisticsBuilderUtils::addValues(
         builder, vec, common::Ranges::of(0, size));
@@ -214,11 +220,11 @@ TEST(TestStatisticsBuilderUtils, addBooleanValues) {
   }
 
   // add values with null
-  auto nulls = allocateNulls(size, pool.get());
+  auto nulls = allocateNulls(size, pool_.get());
   bits::setNull(nulls->asMutable<uint64_t>(), 3);
 
   {
-    auto vec = makeFlatVector<bool>(pool.get(), nulls, 1, size, values);
+    auto vec = makeFlatVector<bool>(pool_.get(), nulls, 1, size, values);
 
     StatisticsBuilderUtils::addValues(
         builder, vec, common::Ranges::of(0, size));
@@ -230,17 +236,16 @@ TEST(TestStatisticsBuilderUtils, addBooleanValues) {
   }
 }
 
-TEST(TestStatisticsBuilderUtils, addValues) {
+TEST_F(TestStatisticsBuilderUtils, addValues) {
   StatisticsBuilder builder{options};
 
   // add values non null
-  auto pool = memory::addDefaultLeafMemoryPool();
   size_t size = 10;
 
-  auto values = AlignedBuffer::allocate<bool>(size, pool.get());
+  auto values = AlignedBuffer::allocate<bool>(size, pool_.get());
 
   {
-    auto vec = makeFlatVectorNoNulls<bool>(pool.get(), size, values);
+    auto vec = makeFlatVectorNoNulls<bool>(pool_.get(), size, values);
 
     StatisticsBuilderUtils::addValues(
         builder, vec, common::Ranges::of(0, size));
@@ -250,11 +255,11 @@ TEST(TestStatisticsBuilderUtils, addValues) {
   }
 
   // add values with null
-  auto nulls = allocateNulls(size, pool.get());
+  auto nulls = allocateNulls(size, pool_.get());
   bits::setNull(nulls->asMutable<uint64_t>(), 3);
 
   {
-    auto vec = makeFlatVector<bool>(pool.get(), nulls, 1, size, values);
+    auto vec = makeFlatVector<bool>(pool_.get(), nulls, 1, size, values);
 
     StatisticsBuilderUtils::addValues(
         builder, vec, common::Ranges::of(0, size));
@@ -264,26 +269,23 @@ TEST(TestStatisticsBuilderUtils, addValues) {
   }
 }
 
-TEST(TestStatisticsBuilderUtils, addBinaryValues) {
+TEST_F(TestStatisticsBuilderUtils, addBinaryValues) {
   BinaryStatisticsBuilder builder{options};
 
   // add values non null
-  auto pool = memory::addDefaultLeafMemoryPool();
   size_t size = 10;
 
-  auto values = AlignedBuffer::allocate<StringView>(size, pool.get());
+  auto values = AlignedBuffer::allocate<StringView>(size, pool_.get());
   auto* valuesPtr = values->asMutable<StringView>();
 
   std::array<char, 10> data;
   std::memset(data.data(), 'a', 10);
-  size_t total = 0;
   for (size_t i = 0; i < size; ++i) {
     valuesPtr[i] = StringView(data.data(), i + 1);
-    total += (i + 1);
   }
 
   {
-    auto vec = makeFlatVectorNoNulls<StringView>(pool.get(), size, values);
+    auto vec = makeFlatVectorNoNulls<StringView>(pool_.get(), size, values);
 
     StatisticsBuilderUtils::addValues(
         builder, vec, common::Ranges::of(0, size));
@@ -295,11 +297,11 @@ TEST(TestStatisticsBuilderUtils, addBinaryValues) {
   }
 
   // add values with null
-  auto nulls = allocateNulls(size, pool.get());
+  auto nulls = allocateNulls(size, pool_.get());
   bits::setNull(nulls->asMutable<uint64_t>(), 3);
 
   {
-    auto vec = makeFlatVector<StringView>(pool.get(), nulls, 1, size, values);
+    auto vec = makeFlatVector<StringView>(pool_.get(), nulls, 1, size, values);
 
     StatisticsBuilderUtils::addValues(
         builder, vec, common::Ranges::of(0, size));
diff --git a/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp b/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
index 45ebe21d4572a..f6dd8d848f039 100644
--- a/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
+++ b/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
@@ -28,6 +28,7 @@ class TestStringDictionaryEncoder : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     FLAGS_velox_enable_memory_usage_track_in_default_memory_pool = true;
+    memory::MemoryManager::testingSetInstance({});
   }
 };
 
@@ -49,7 +50,7 @@ TEST_F(TestStringDictionaryEncoder, AddKey) {
       TestCase{{"doe", "sow", "sow", "doe", "sow"}, {0, 1, 1, 0, 1}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     std::vector<size_t> actualEncodedSequence{};
     for (const auto& key : testCase.addKeySequence) {
@@ -93,7 +94,7 @@ TEST_F(TestStringDictionaryEncoder, GetIndex) {
           {0, 3, 4, 2, 1, 3, 2, 4, 2, 0, 1, 0, 3}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       stringDictEncoder.addKey(key, 0);
@@ -142,7 +143,7 @@ TEST_F(TestStringDictionaryEncoder, GetCount) {
           {3, 2, 3, 3, 2}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       stringDictEncoder.addKey(key, 0);
@@ -196,7 +197,7 @@ TEST_F(TestStringDictionaryEncoder, GetStride) {
           {1, 1, 6, 3, 4}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = addDefaultLeafMemoryPool();
+    auto pool = memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& kv : testCase.addKeySequence) {
       stringDictEncoder.addKey(kv.first, kv.second);
@@ -219,13 +220,13 @@ std::string genPaddedIntegerString(size_t integer, size_t length) {
 }
 
 TEST_F(TestStringDictionaryEncoder, Clear) {
-  auto pool = addDefaultLeafMemoryPool();
+  auto pool = memoryManager()->addLeafPool();
   StringDictionaryEncoder stringDictEncoder{*pool, *pool};
   std::string baseString{"jjkkll"};
   for (size_t i = 0; i != 2500; ++i) {
     stringDictEncoder.addKey(baseString + genPaddedIntegerString(i, 4), 0);
   }
-  auto peakMemory = pool->currentBytes();
+  auto peakMemory = pool->usedBytes();
   stringDictEncoder.clear();
   EXPECT_EQ(0, stringDictEncoder.size());
   EXPECT_EQ(0, stringDictEncoder.keyIndex_.size());
@@ -237,22 +238,22 @@ TEST_F(TestStringDictionaryEncoder, Clear) {
   EXPECT_EQ(0, stringDictEncoder.counts_.capacity());
   EXPECT_EQ(0, stringDictEncoder.firstSeenStrideIndex_.size());
   EXPECT_EQ(0, stringDictEncoder.firstSeenStrideIndex_.capacity());
-  EXPECT_LT(pool->currentBytes(), peakMemory);
+  EXPECT_LT(pool->usedBytes(), peakMemory);
 }
 
 TEST_F(TestStringDictionaryEncoder, MemBenchmark) {
-  auto pool = addDefaultLeafMemoryPool();
+  auto pool = memoryManager()->addLeafPool();
   StringDictionaryEncoder stringDictEncoder{*pool, *pool};
   std::string baseString{"jjkkll"};
   for (size_t i = 0; i != 10000; ++i) {
     stringDictEncoder.addKey(baseString + genPaddedIntegerString(i, 4), 0);
   }
 
-  LOG(INFO) << "Total memory bytes: " << pool->currentBytes();
+  LOG(INFO) << "Total memory bytes: " << pool->usedBytes();
 }
 
 TEST_F(TestStringDictionaryEncoder, Limit) {
-  auto pool = addDefaultLeafMemoryPool();
+  auto pool = memoryManager()->addLeafPool();
   StringDictionaryEncoder encoder{*pool, *pool};
   encoder.addKey(folly::StringPiece{"abc"}, 0);
   dwio::common::DataBuffer<char> buf{*pool};
diff --git a/velox/dwio/dwrf/test/TestStripeDictionaryCache.cpp b/velox/dwio/dwrf/test/TestStripeDictionaryCache.cpp
index 6151740205405..44d3abbc44c48 100644
--- a/velox/dwio/dwrf/test/TestStripeDictionaryCache.cpp
+++ b/velox/dwio/dwrf/test/TestStripeDictionaryCache.cpp
@@ -26,8 +26,6 @@ using namespace ::testing;
 namespace facebook::velox::dwrf {
 
 namespace {
-auto defaultPool = velox::memory::addDefaultLeafMemoryPool();
-
 folly::Function<BufferPtr(memory::MemoryPool*)> genConsecutiveRangeBuffer(
     int64_t begin,
     int64_t end) {
@@ -56,11 +54,21 @@ void verifyRange(BufferPtr bufferPtr, int64_t begin, int64_t end) {
   }
   EXPECT_THAT(actualRange, ElementsAreArray(expectedRange));
 }
+
+class StripeDictionaryCacheTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<velox::memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+};
 } // namespace
 
-TEST(TestStripeDictionaryCache, RegisterDictionary) {
+TEST_F(StripeDictionaryCacheTest, RegisterDictionary) {
   {
-    StripeDictionaryCache cache{defaultPool.get()};
+    StripeDictionaryCache cache{pool_.get()};
     cache.registerIntDictionary({9, 0}, genConsecutiveRangeBuffer(0, 100));
     EXPECT_EQ(1, cache.intDictionaryFactories_.size());
     EXPECT_EQ(1, cache.intDictionaryFactories_.count({9, 0}));
@@ -70,7 +78,7 @@ TEST(TestStripeDictionaryCache, RegisterDictionary) {
   // StripeStream, so it won't matter. For here, we have to test that
   // the content is not changed in getDictionaryBuffer tests.
   {
-    StripeDictionaryCache cache{defaultPool.get()};
+    StripeDictionaryCache cache{pool_.get()};
 
     cache.registerIntDictionary({9, 0}, genConsecutiveRangeBuffer(0, 100));
     cache.registerIntDictionary({9, 0}, genConsecutiveRangeBuffer(100, 200));
@@ -79,7 +87,7 @@ TEST(TestStripeDictionaryCache, RegisterDictionary) {
     EXPECT_EQ(1, cache.intDictionaryFactories_.count({9, 0}));
   }
   {
-    StripeDictionaryCache cache{defaultPool.get()};
+    StripeDictionaryCache cache{pool_.get()};
 
     cache.registerIntDictionary({1, 0}, genConsecutiveRangeBuffer(0, 100));
     cache.registerIntDictionary({1, 1}, genConsecutiveRangeBuffer(0, 100));
@@ -92,9 +100,9 @@ TEST(TestStripeDictionaryCache, RegisterDictionary) {
   }
 }
 
-TEST(TestStripeDictionaryCache, GetDictionaryBuffer) {
+TEST_F(StripeDictionaryCacheTest, GetDictionaryBuffer) {
   {
-    StripeDictionaryCache cache{defaultPool.get()};
+    StripeDictionaryCache cache{pool_.get()};
 
     cache.registerIntDictionary({9, 0}, genConsecutiveRangeBuffer(0, 100));
     verifyRange(cache.getIntDictionary({9, 0}), 0, 100);
@@ -105,7 +113,7 @@ TEST(TestStripeDictionaryCache, GetDictionaryBuffer) {
   // StripeStream, so it won't matter. For here, we have to test that
   // the content is not changed.
   {
-    StripeDictionaryCache cache{defaultPool.get()};
+    StripeDictionaryCache cache{pool_.get()};
 
     cache.registerIntDictionary({9, 0}, genConsecutiveRangeBuffer(0, 100));
     cache.registerIntDictionary({9, 0}, genConsecutiveRangeBuffer(100, 200));
@@ -113,7 +121,7 @@ TEST(TestStripeDictionaryCache, GetDictionaryBuffer) {
     verifyRange(cache.getIntDictionary({9, 0}), 0, 100);
   }
   {
-    StripeDictionaryCache cache{defaultPool.get()};
+    StripeDictionaryCache cache{pool_.get()};
 
     cache.registerIntDictionary({1, 0}, genConsecutiveRangeBuffer(0, 100));
     cache.registerIntDictionary({1, 1}, genConsecutiveRangeBuffer(0, 100));
diff --git a/velox/dwio/dwrf/test/TestStripeStream.cpp b/velox/dwio/dwrf/test/TestStripeStream.cpp
index f26fa34e0a346..58dd3bab49ea9 100644
--- a/velox/dwio/dwrf/test/TestStripeStream.cpp
+++ b/velox/dwio/dwrf/test/TestStripeStream.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/encryption/TestProvider.h"
 #include "velox/dwio/dwrf/reader/StripeStream.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
@@ -28,9 +29,9 @@ using namespace facebook::velox::dwio::common::encryption::test;
 using namespace facebook::velox::dwrf;
 using namespace facebook::velox::dwrf::encryption;
 using namespace facebook::velox::memory;
-using facebook::velox::common::Region;
-
 using facebook::velox::RowType;
+using facebook::velox::common::Region;
+using facebook::velox::dwio::common::BufferedInput;
 using facebook::velox::type::fbhive::HiveTypeParser;
 
 class RecordingInputStream : public facebook::velox::InMemoryReadFile {
@@ -60,16 +61,15 @@ class TestProvider : public StrideIndexProvider {
 
 namespace {
 void enqueueReads(
-    const StripeReaderBase& reader,
+    BufferedInput& input,
+    facebook::velox::dwrf::ReaderBase& readerBase,
+    const proto::StripeFooter& footer,
     const ColumnSelector& selector,
     uint64_t stripeStart,
     uint32_t stripeIndex) {
-  auto& input = reader.getStripeInput();
-  auto& metadataCache = reader.getReader().getMetadataCache();
+  auto& metadataCache = readerBase.metadataCache();
   uint64_t offset = stripeStart;
   uint64_t length = 0;
-  uint32_t regions = 0;
-  auto& footer = reader.getStripeFooter();
   for (const auto& stream : footer.streams()) {
     length = stream.length();
     // If index cache is available, there is no need to read it
@@ -81,32 +81,46 @@ void enqueueReads(
         selector.shouldReadStream(stream.node(), stream.sequence()) &&
         !inMetaCache) {
       input.enqueue({offset, length});
-      regions++;
     }
     offset += length;
   }
 }
 
 StripeStreamsImpl createAndLoadStripeStreams(
-    const StripeReaderBase& stripeReader,
+    std::shared_ptr<StripeReadState> readState,
     const ColumnSelector& selector) {
   TestProvider indexProvider;
   StripeStreamsImpl streams{
-      stripeReader,
-      selector,
+      readState,
+      &selector,
+      nullptr,
       RowReaderOptions{},
       0,
       StripeStreamsImpl::kUnknownStripeRows,
       indexProvider,
       0};
-  enqueueReads(stripeReader, selector, 0, 0);
+  enqueueReads(
+      *readState->stripeMetadata->stripeInput,
+      *readState->readerBase,
+      *readState->stripeMetadata->footer,
+      selector,
+      0,
+      0);
   streams.loadReadPlan();
   return streams;
 }
+
+class StripeStreamTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<MemoryPool> pool_{memoryManager()->addLeafPool()};
+};
 } // namespace
 
-TEST(StripeStream, planReads) {
-  auto pool = addDefaultLeafMemoryPool();
+TEST_F(StripeStreamTest, planReads) {
   google::protobuf::Arena arena;
   auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
   footer->set_rowindexstride(100);
@@ -115,10 +129,10 @@ TEST(StripeStream, planReads) {
   auto is = std::make_unique<RecordingInputStream>();
   auto isPtr = is.get();
   auto readerBase = std::make_shared<ReaderBase>(
-      *pool,
+      *pool_,
       std::make_unique<BufferedInput>(
           std::move(is),
-          *pool,
+          *pool_,
           MetricsLog::voidLog(),
           nullptr,
           BufferedInput::kMaxMergeDistance,
@@ -126,9 +140,8 @@ TEST(StripeStream, planReads) {
       std::make_unique<PostScript>(proto::PostScript{}),
       footer,
       nullptr);
-  ColumnSelector cs{readerBase->getSchema(), std::vector<uint64_t>{2}, true};
-  auto stripeFooter =
-      google::protobuf::Arena::CreateMessage<proto::StripeFooter>(&arena);
+  ColumnSelector cs{readerBase->schema(), std::vector<uint64_t>{2}, true};
+  auto stripeFooter = std::make_unique<proto::StripeFooter>();
   std::vector<std::tuple<uint64_t, StreamKind, uint64_t>> ss{
       std::make_tuple(1, StreamKind::StreamKind_ROW_INDEX, 100),
       std::make_tuple(2, StreamKind::StreamKind_ROW_INDEX, 100),
@@ -142,8 +155,18 @@ TEST(StripeStream, planReads) {
     stream->set_kind(static_cast<proto::Stream_Kind>(std::get<1>(s)));
     stream->set_length(std::get<2>(s));
   }
-  StripeReaderBase stripeReader{readerBase, stripeFooter};
-  auto streams = createAndLoadStripeStreams(stripeReader, cs);
+  TestDecrypterFactory factory;
+  auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
+  auto stripeMetadata = std::make_unique<const StripeMetadata>(
+      readerBase->bufferedInput().clone(),
+      std::move(stripeFooter),
+      std::move(handler),
+      StripeInformationWrapper(
+          static_cast<const proto::StripeInformation*>(nullptr)));
+  auto stripeReadState =
+      std::make_shared<StripeReadState>(readerBase, std::move(stripeMetadata));
+  StripeReaderBase stripeReader{readerBase};
+  auto streams = createAndLoadStripeStreams(stripeReadState, cs);
   auto const& actual = isPtr->getReads();
   ASSERT_FALSE(actual.empty());
   EXPECT_EQ(std::min(actual.cbegin(), actual.cend())->offset, 100);
@@ -156,8 +179,7 @@ TEST(StripeStream, planReads) {
       1000300);
 }
 
-TEST(StripeStream, filterSequences) {
-  auto pool = addDefaultLeafMemoryPool();
+TEST_F(StripeStreamTest, filterSequences) {
   google::protobuf::Arena arena;
   auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
   footer->set_rowindexstride(100);
@@ -166,14 +188,14 @@ TEST(StripeStream, filterSequences) {
   auto is = std::make_unique<RecordingInputStream>();
   auto isPtr = is.get();
   auto readerBase = std::make_shared<ReaderBase>(
-      *pool,
-      std::make_unique<BufferedInput>(std::move(is), *pool),
+      *pool_,
+      std::make_unique<BufferedInput>(std::move(is), *pool_),
       std::make_unique<PostScript>(proto::PostScript{}),
       footer,
       nullptr);
 
   // mock a filter that we only need one node and one sequence
-  ColumnSelector cs{readerBase->getSchema(), std::vector<std::string>{"a#[1]"}};
+  ColumnSelector cs{readerBase->schema(), std::vector<std::string>{"a#[1]"}};
   const auto& node = cs.getNode(1);
   auto seqFilter = std::make_shared<std::unordered_set<size_t>>();
   seqFilter->insert(1);
@@ -181,8 +203,7 @@ TEST(StripeStream, filterSequences) {
 
   // mock the input stream data to verify our plan
   // only covered the filtered streams
-  auto stripeFooter =
-      google::protobuf::Arena::CreateMessage<proto::StripeFooter>(&arena);
+  auto stripeFooter = std::make_unique<proto::StripeFooter>();
   std::vector<std::tuple<uint64_t, StreamKind, uint64_t, uint64_t>> ss{
       std::make_tuple(1, StreamKind::StreamKind_ROW_INDEX, 100, 0),
       std::make_tuple(2, StreamKind::StreamKind_ROW_INDEX, 100, 0),
@@ -200,10 +221,20 @@ TEST(StripeStream, filterSequences) {
     stream->set_sequence(std::get<3>(s));
   }
 
+  TestDecrypterFactory factory;
+  auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
   // filter by sequence 1
   std::vector<Region> expected{{600, 5000000}, {8000600, 1000000}};
-  StripeReaderBase stripeReader{readerBase, stripeFooter};
-  auto streams = createAndLoadStripeStreams(stripeReader, cs);
+  auto stripeMetadata = std::make_unique<const StripeMetadata>(
+      readerBase->bufferedInput().clone(),
+      std::move(stripeFooter),
+      std::move(handler),
+      StripeInformationWrapper(
+          static_cast<const proto::StripeInformation*>(nullptr)));
+  auto stripeReadState =
+      std::make_shared<StripeReadState>(readerBase, std::move(stripeMetadata));
+  StripeReaderBase stripeReader{readerBase};
+  auto streams = createAndLoadStripeStreams(stripeReadState, cs);
   auto const& actual = isPtr->getReads();
   EXPECT_EQ(actual.size(), expected.size());
   for (uint64_t i = 0; i < actual.size(); ++i) {
@@ -212,8 +243,7 @@ TEST(StripeStream, filterSequences) {
   }
 }
 
-TEST(StripeStream, zeroLength) {
-  auto pool = addDefaultLeafMemoryPool();
+TEST_F(StripeStreamTest, zeroLength) {
   google::protobuf::Arena arena;
   auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
   footer->set_rowindexstride(100);
@@ -225,14 +255,13 @@ TEST(StripeStream, zeroLength) {
   auto is = std::make_unique<RecordingInputStream>();
   auto isPtr = is.get();
   auto readerBase = std::make_shared<ReaderBase>(
-      *pool,
-      std::make_unique<BufferedInput>(std::move(is), *pool),
+      *pool_,
+      std::make_unique<BufferedInput>(std::move(is), *pool_),
       std::make_unique<PostScript>(std::move(ps)),
       footer,
       nullptr);
 
-  auto stripeFooter =
-      google::protobuf::Arena::CreateMessage<proto::StripeFooter>(&arena);
+  auto stripeFooter = std::make_unique<proto::StripeFooter>();
   std::vector<std::tuple<uint64_t, StreamKind, uint64_t>> ss{
       std::make_tuple(0, StreamKind::StreamKind_ROW_INDEX, 0),
       std::make_tuple(1, StreamKind::StreamKind_ROW_INDEX, 0),
@@ -243,12 +272,25 @@ TEST(StripeStream, zeroLength) {
     stream->set_kind(static_cast<proto::Stream_Kind>(std::get<1>(s)));
     stream->set_length(std::get<2>(s));
   }
-  StripeReaderBase stripeReader{readerBase, stripeFooter};
+
+  TestDecrypterFactory factory;
+  auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
+  auto stripeMetadata = std::make_unique<const StripeMetadata>(
+      readerBase->bufferedInput().clone(),
+      std::move(stripeFooter),
+      std::move(handler),
+      StripeInformationWrapper(
+          static_cast<const proto::StripeInformation*>(nullptr)));
+  auto stripeReadState =
+      std::make_shared<StripeReadState>(readerBase, std::move(stripeMetadata));
+  StripeReaderBase stripeReader{readerBase};
+
   TestProvider indexProvider;
   ColumnSelector cs{std::dynamic_pointer_cast<const RowType>(type)};
   StripeStreamsImpl streams{
-      stripeReader,
-      cs,
+      stripeReadState,
+      &cs,
+      nullptr,
       RowReaderOptions{},
       0,
       StripeStreamsImpl::kUnknownStripeRows,
@@ -271,8 +313,7 @@ TEST(StripeStream, zeroLength) {
   }
 }
 
-TEST(StripeStream, planReadsIndex) {
-  auto pool = addDefaultLeafMemoryPool();
+TEST_F(StripeStreamTest, planReadsIndex) {
   google::protobuf::Arena arena;
 
   // build ps
@@ -298,7 +339,7 @@ TEST(StripeStream, planReadsIndex) {
 
   // build cache
   std::string str(buffer.str());
-  auto cacheBuffer = std::make_shared<DataBuffer<char>>(*pool, str.size());
+  auto cacheBuffer = std::make_shared<DataBuffer<char>>(*pool_, str.size());
   memcpy(cacheBuffer->data(), str.data(), str.size());
   auto cache = std::make_unique<StripeMetadataCache>(
       StripeCacheMode::INDEX, FooterWrapper(footer), std::move(cacheBuffer));
@@ -306,14 +347,13 @@ TEST(StripeStream, planReadsIndex) {
   auto is = std::make_unique<RecordingInputStream>();
   auto isPtr = is.get();
   auto readerBase = std::make_shared<ReaderBase>(
-      *pool,
-      std::make_unique<BufferedInput>(std::move(is), *pool),
+      *pool_,
+      std::make_unique<BufferedInput>(std::move(is), *pool_),
       std::make_unique<PostScript>(std::move(ps)),
       footer,
       std::move(cache));
 
-  auto stripeFooter =
-      google::protobuf::Arena::CreateMessage<proto::StripeFooter>(&arena);
+  auto stripeFooter = std::make_unique<proto::StripeFooter>();
   std::vector<std::tuple<uint64_t, StreamKind, uint64_t>> ss{
       std::make_tuple(0, StreamKind::StreamKind_ROW_INDEX, length),
       std::make_tuple(1, StreamKind::StreamKind_ROW_INDEX, length),
@@ -325,9 +365,20 @@ TEST(StripeStream, planReadsIndex) {
     stream->set_kind(static_cast<proto::Stream_Kind>(std::get<1>(s)));
     stream->set_length(std::get<2>(s));
   }
-  StripeReaderBase stripeReader{readerBase, stripeFooter};
+
+  TestDecrypterFactory factory;
+  auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
+  auto stripeMetadata = std::make_unique<const StripeMetadata>(
+      readerBase->bufferedInput().clone(),
+      std::move(stripeFooter),
+      std::move(handler),
+      StripeInformationWrapper(
+          static_cast<const proto::StripeInformation*>(nullptr)));
+  auto stripeReadState =
+      std::make_shared<StripeReadState>(readerBase, std::move(stripeMetadata));
+  StripeReaderBase stripeReader{readerBase};
   ColumnSelector cs{std::dynamic_pointer_cast<const RowType>(type)};
-  auto streams = createAndLoadStripeStreams(stripeReader, cs);
+  auto streams = createAndLoadStripeStreams(stripeReadState, cs);
   auto const& actual = isPtr->getReads();
   ASSERT_FALSE(actual.empty());
   EXPECT_EQ(std::min(actual.cbegin(), actual.cend())->offset, length * 2);
@@ -381,8 +432,8 @@ void addNode(T& t, uint32_t node, uint32_t offset = 0) {
   }
 }
 
-TEST(StripeStream, readEncryptedStreams) {
-  auto pool = defaultMemoryManager().addRootPool("readEncryptedStreams");
+TEST_F(StripeStreamTest, readEncryptedStreams) {
+  auto pool = memoryManager()->addRootPool("readEncryptedStreams");
   google::protobuf::Arena arena;
   proto::PostScript ps;
   ps.set_compression(proto::CompressionKind::ZSTD);
@@ -411,8 +462,7 @@ TEST(StripeStream, readEncryptedStreams) {
 
   auto sinkPool = pool->addLeafChild("sink");
   ProtoWriter pw{pool, *sinkPool};
-  auto stripeFooter =
-      google::protobuf::Arena::CreateMessage<proto::StripeFooter>(&arena);
+  auto stripeFooter = std::make_unique<proto::StripeFooter>();
   addNode(*stripeFooter, 1);
   proto::StripeEncryptionGroup group1;
   addNode(group1, 2, 100);
@@ -436,13 +486,21 @@ TEST(StripeStream, readEncryptedStreams) {
       footer,
       nullptr,
       std::move(handler));
-  auto stripeReader =
-      std::make_unique<StripeReaderBase>(readerBase, stripeFooter);
-  ColumnSelector selector{readerBase->getSchema(), {1, 2, 4}, true};
+  auto stripeMetadata = std::make_unique<const StripeMetadata>(
+      &readerBase->bufferedInput(),
+      std::move(stripeFooter),
+      DecryptionHandler::create(FooterWrapper(footer), &factory),
+      StripeInformationWrapper(
+          static_cast<const proto::StripeInformation*>(nullptr)));
+  auto stripeReadState =
+      std::make_shared<StripeReadState>(readerBase, std::move(stripeMetadata));
+  StripeReaderBase stripeReader{readerBase};
+  ColumnSelector selector{readerBase->schema(), {1, 2, 4}, true};
   TestProvider provider;
   StripeStreamsImpl streams{
-      *stripeReader,
-      selector,
+      stripeReadState,
+      &selector,
+      nullptr,
       RowReaderOptions{},
       0,
       StripeStreamsImpl::kUnknownStripeRows,
@@ -461,14 +519,14 @@ TEST(StripeStream, readEncryptedStreams) {
       ASSERT_EQ(streams.getEncoding(ek).dictionarysize(), node + 1);
       ASSERT_NE(stream, nullptr);
     } else {
-      ASSERT_THROW(streams.getEncoding(ek), exception::LoggedException);
+      VELOX_ASSERT_THROW(streams.getEncoding(ek), "encoding not found");
       ASSERT_EQ(stream, nullptr);
     }
   }
 }
 
-TEST(StripeStream, schemaMismatch) {
-  auto pool = defaultMemoryManager().addRootPool("schemaMismatch");
+TEST_F(StripeStreamTest, schemaMismatch) {
+  auto pool = memoryManager()->addRootPool("schemaMismatch");
   google::protobuf::Arena arena;
   proto::PostScript ps;
   ps.set_compression(proto::CompressionKind::ZSTD);
@@ -492,8 +550,7 @@ TEST(StripeStream, schemaMismatch) {
 
   auto sinkPool = pool->addLeafChild("sink");
   ProtoWriter pw{pool, *sinkPool};
-  auto stripeFooter =
-      google::protobuf::Arena::CreateMessage<proto::StripeFooter>(&arena);
+  auto stripeFooter = std::make_unique<proto::StripeFooter>();
   addNode(*stripeFooter, 1);
   addNode(*stripeFooter, 2);
   addNode(*stripeFooter, 4);
@@ -507,13 +564,20 @@ TEST(StripeStream, schemaMismatch) {
       *readerPool,
       std::make_unique<BufferedInput>(
           std::make_shared<facebook::velox::InMemoryReadFile>(std::string()),
-          *pool),
+          *pool_),
       std::make_unique<PostScript>(std::move(ps)),
       footer,
       nullptr,
       std::move(handler));
-  auto stripeReader =
-      std::make_unique<StripeReaderBase>(readerBase, stripeFooter);
+  auto stripeMetadata = std::make_unique<const StripeMetadata>(
+      &readerBase->bufferedInput(),
+      std::move(stripeFooter),
+      DecryptionHandler::create(FooterWrapper(footer), &factory),
+      StripeInformationWrapper(
+          static_cast<const proto::StripeInformation*>(nullptr)));
+  auto stripeReadState =
+      std::make_shared<StripeReadState>(readerBase, std::move(stripeMetadata));
+  StripeReaderBase stripeReader{readerBase};
   // now, we read the file as if schema has changed
   auto schema =
       HiveTypeParser().parse("struct<a:struct<a1:int,a2:int>,b:int,c:int>");
@@ -522,8 +586,9 @@ TEST(StripeStream, schemaMismatch) {
       std::dynamic_pointer_cast<const RowType>(schema), {4, 5}, true};
   TestProvider provider;
   StripeStreamsImpl streams{
-      *stripeReader,
-      selector,
+      stripeReadState,
+      &selector,
+      nullptr,
       RowReaderOptions{},
       0,
       StripeStreamsImpl::kUnknownStripeRows,
@@ -570,7 +635,7 @@ class TestStripeStreams : public StripeStreamsBase {
     VELOX_UNSUPPORTED();
   }
 
-  const facebook::velox::dwio::common::RowReaderOptions& getRowReaderOptions()
+  const facebook::velox::dwio::common::RowReaderOptions& rowReaderOptions()
       const override {
     VELOX_UNSUPPORTED();
   }
@@ -618,10 +683,8 @@ proto::ColumnEncoding genColumnEncoding(
 }
 } // namespace
 
-TEST(StripeStream, shareDictionary) {
-  std::shared_ptr<MemoryPool> pool =
-      addDefaultLeafMemoryPool("shareDictionary");
-  TestStripeStreams ss(pool.get());
+TEST_F(StripeStreamTest, shareDictionary) {
+  TestStripeStreams ss(pool_.get());
 
   auto nonSharedDictionaryEncoding =
       genColumnEncoding(1, 0, proto::ColumnEncoding_Kind_DICTIONARY, 100);
@@ -669,7 +732,7 @@ TEST(StripeStream, shareDictionary) {
       ss, getStreamProxy(2, Not(0), proto::Stream_Kind_DICTIONARY_DATA, _))
       .WillRepeatedly(Return(nullptr));
 
-  facebook::velox::memory::AllocationPool allocPool(pool.get());
+  facebook::velox::memory::AllocationPool allocPool(pool_.get());
   StreamLabels labels(allocPool);
   std::vector<std::function<facebook::velox::BufferPtr()>> dictInits{};
   dictInits.push_back(
diff --git a/velox/dwio/dwrf/test/TestWriterContext.cpp b/velox/dwio/dwrf/test/TestWriterContext.cpp
deleted file mode 100644
index f0fd56f36bdff..0000000000000
--- a/velox/dwio/dwrf/test/TestWriterContext.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-
-#include "velox/dwio/common/TypeWithId.h"
-#include "velox/dwio/dwrf/writer/WriterContext.h"
-
-using namespace ::testing;
-
-namespace facebook::velox::dwrf {
-TEST(TestWriterContext, GetIntDictionaryEncoder) {
-  auto config = std::make_shared<Config>();
-  WriterContext context{
-      config,
-      memory::defaultMemoryManager().addRootPool("GetIntDictionaryEncoder")};
-
-  EXPECT_EQ(0, context.dictEncoders_.size());
-  auto& intEncoder_1_0 = context.getIntDictionaryEncoder<int32_t>(
-      {1, 0}, *context.dictionaryPool_, *context.generalPool_);
-  EXPECT_EQ(1, context.dictEncoders_.size());
-  ASSERT_EQ(1, intEncoder_1_0.refCount_);
-
-  auto& duplicateCallResult_1_0 = context.getIntDictionaryEncoder<int32_t>(
-      {1, 0}, *context.dictionaryPool_, *context.generalPool_);
-  EXPECT_EQ(1, context.dictEncoders_.size());
-  EXPECT_EQ(&intEncoder_1_0, &duplicateCallResult_1_0);
-  EXPECT_EQ(2, intEncoder_1_0.refCount_);
-
-  for (size_t i = 0; i < 40; ++i) {
-    context.getIntDictionaryEncoder<int32_t>(
-        {1, 0}, *context.dictionaryPool_, *context.generalPool_);
-  }
-  EXPECT_EQ(42, intEncoder_1_0.refCount_);
-
-  // Ignore the mismatched type request.
-  context.getIntDictionaryEncoder<int64_t>(
-      {1, 0}, *context.dictionaryPool_, *context.generalPool_);
-  EXPECT_EQ(1, context.dictEncoders_.size());
-
-  context.getIntDictionaryEncoder<int32_t>(
-      {2, 0}, *context.dictionaryPool_, *context.generalPool_);
-  EXPECT_EQ(2, context.dictEncoders_.size());
-}
-
-TEST(TestWriterContext, RemoveIntDictionaryEncoderForNode) {
-  auto config = std::make_shared<Config>();
-  config->set(Config::MAP_FLAT_DICT_SHARE, false);
-  WriterContext context{
-      config,
-      memory::defaultMemoryManager().addRootPool(
-          "RemoveIntDictionaryEncoderForNode")};
-
-  context.getIntDictionaryEncoder<int32_t>(
-      {1, 1}, *context.dictionaryPool_, *context.generalPool_);
-  context.getIntDictionaryEncoder<int32_t>(
-      {1, 2}, *context.dictionaryPool_, *context.generalPool_);
-  context.getIntDictionaryEncoder<int32_t>(
-      {1, 4}, *context.dictionaryPool_, *context.generalPool_);
-  context.getIntDictionaryEncoder<int32_t>(
-      {1, 5}, *context.dictionaryPool_, *context.generalPool_);
-  EXPECT_EQ(4, context.dictEncoders_.size());
-
-  context.getIntDictionaryEncoder<int32_t>(
-      {2, 0}, *context.dictionaryPool_, *context.generalPool_);
-  context.getIntDictionaryEncoder<int32_t>(
-      {3, 1}, *context.dictionaryPool_, *context.generalPool_);
-  context.getIntDictionaryEncoder<int32_t>(
-      {3, 3}, *context.dictionaryPool_, *context.generalPool_);
-  EXPECT_EQ(7, context.dictEncoders_.size());
-
-  context.removeAllIntDictionaryEncodersOnNode(
-      [](uint32_t nodeId) { return nodeId == 1; });
-  EXPECT_EQ(3, context.dictEncoders_.size());
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 1}));
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 2}));
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 4}));
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 5}));
-  EXPECT_EQ(1, context.dictEncoders_.count(EncodingKey{2, 0}));
-  EXPECT_EQ(1, context.dictEncoders_.count(EncodingKey{3, 1}));
-  EXPECT_EQ(1, context.dictEncoders_.count(EncodingKey{3, 3}));
-
-  context.removeAllIntDictionaryEncodersOnNode(
-      [](uint32_t nodeId) { return nodeId == 3; });
-  EXPECT_EQ(1, context.dictEncoders_.size());
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 1}));
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 2}));
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 4}));
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 5}));
-  EXPECT_EQ(1, context.dictEncoders_.count(EncodingKey{2, 0}));
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{3, 1}));
-  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{3, 3}));
-
-  context.removeAllIntDictionaryEncodersOnNode(
-      [](uint32_t nodeId) { return nodeId == 2; });
-  EXPECT_EQ(0, context.dictEncoders_.size());
-}
-
-TEST(TestWriterContext, BuildPhysicalSizeAggregators) {
-  auto config = std::make_shared<Config>();
-  WriterContext context{
-      config,
-      memory::defaultMemoryManager().addRootPool(
-          "BuildPhysicalSizeAggregators")};
-  auto type = ROW({
-      {"array", ARRAY(REAL())},
-      {"map", MAP(INTEGER(), DOUBLE())},
-      {"row",
-       ROW({
-           {"a", REAL()},
-           {"b", INTEGER()},
-       })},
-      {"nested",
-       ARRAY(ROW({
-           {"a", INTEGER()},
-           {"b", MAP(REAL(), REAL())},
-       }))},
-  });
-  auto typeWithId = velox::dwio::common::TypeWithId::create(type);
-  context.buildPhysicalSizeAggregators(*typeWithId);
-  std::vector<uint32_t> mapNodes{3, 12};
-  for (size_t i = 0; i < 14; ++i) {
-    EXPECT_NO_THROW(context.getPhysicalSizeAggregator(i));
-  }
-  for (const auto nodeId : mapNodes) {
-    EXPECT_NO_THROW(dynamic_cast<MapPhysicalSizeAggregator&>(
-        context.getPhysicalSizeAggregator(nodeId)));
-  }
-}
-} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/WriterContextTest.cpp b/velox/dwio/dwrf/test/WriterContextTest.cpp
new file mode 100644
index 0000000000000..0cc6b8ce6395b
--- /dev/null
+++ b/velox/dwio/dwrf/test/WriterContextTest.cpp
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/dwio/dwrf/writer/WriterContext.h"
+#include "velox/exec/MemoryReclaimer.h"
+
+using namespace ::testing;
+
+namespace facebook::velox::dwrf {
+class WriterContextTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(WriterContextTest, GetIntDictionaryEncoder) {
+  auto config = std::make_shared<Config>();
+  WriterContext context{
+      config, memory::memoryManager()->addRootPool("GetIntDictionaryEncoder")};
+
+  EXPECT_EQ(0, context.dictEncoders_.size());
+  auto& intEncoder_1_0 = context.getIntDictionaryEncoder<int32_t>(
+      {1, 0}, *context.dictionaryPool_, *context.generalPool_);
+  EXPECT_EQ(1, context.dictEncoders_.size());
+  ASSERT_EQ(1, intEncoder_1_0.refCount_);
+
+  auto& duplicateCallResult_1_0 = context.getIntDictionaryEncoder<int32_t>(
+      {1, 0}, *context.dictionaryPool_, *context.generalPool_);
+  EXPECT_EQ(1, context.dictEncoders_.size());
+  EXPECT_EQ(&intEncoder_1_0, &duplicateCallResult_1_0);
+  EXPECT_EQ(2, intEncoder_1_0.refCount_);
+
+  for (size_t i = 0; i < 40; ++i) {
+    context.getIntDictionaryEncoder<int32_t>(
+        {1, 0}, *context.dictionaryPool_, *context.generalPool_);
+  }
+  EXPECT_EQ(42, intEncoder_1_0.refCount_);
+
+  // Ignore the mismatched type request.
+  context.getIntDictionaryEncoder<int64_t>(
+      {1, 0}, *context.dictionaryPool_, *context.generalPool_);
+  EXPECT_EQ(1, context.dictEncoders_.size());
+
+  context.getIntDictionaryEncoder<int32_t>(
+      {2, 0}, *context.dictionaryPool_, *context.generalPool_);
+  EXPECT_EQ(2, context.dictEncoders_.size());
+}
+
+TEST_F(WriterContextTest, RemoveIntDictionaryEncoderForNode) {
+  auto config = std::make_shared<Config>();
+  config->set(Config::MAP_FLAT_DICT_SHARE, false);
+  WriterContext context{
+      config,
+      memory::memoryManager()->addRootPool(
+          "RemoveIntDictionaryEncoderForNode")};
+
+  context.getIntDictionaryEncoder<int32_t>(
+      {1, 1}, *context.dictionaryPool_, *context.generalPool_);
+  context.getIntDictionaryEncoder<int32_t>(
+      {1, 2}, *context.dictionaryPool_, *context.generalPool_);
+  context.getIntDictionaryEncoder<int32_t>(
+      {1, 4}, *context.dictionaryPool_, *context.generalPool_);
+  context.getIntDictionaryEncoder<int32_t>(
+      {1, 5}, *context.dictionaryPool_, *context.generalPool_);
+  EXPECT_EQ(4, context.dictEncoders_.size());
+
+  context.getIntDictionaryEncoder<int32_t>(
+      {2, 0}, *context.dictionaryPool_, *context.generalPool_);
+  context.getIntDictionaryEncoder<int32_t>(
+      {3, 1}, *context.dictionaryPool_, *context.generalPool_);
+  context.getIntDictionaryEncoder<int32_t>(
+      {3, 3}, *context.dictionaryPool_, *context.generalPool_);
+  EXPECT_EQ(7, context.dictEncoders_.size());
+
+  context.removeAllIntDictionaryEncodersOnNode(
+      [](uint32_t nodeId) { return nodeId == 1; });
+  EXPECT_EQ(3, context.dictEncoders_.size());
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 1}));
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 2}));
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 4}));
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 5}));
+  EXPECT_EQ(1, context.dictEncoders_.count(EncodingKey{2, 0}));
+  EXPECT_EQ(1, context.dictEncoders_.count(EncodingKey{3, 1}));
+  EXPECT_EQ(1, context.dictEncoders_.count(EncodingKey{3, 3}));
+
+  context.removeAllIntDictionaryEncodersOnNode(
+      [](uint32_t nodeId) { return nodeId == 3; });
+  EXPECT_EQ(1, context.dictEncoders_.size());
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 1}));
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 2}));
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 4}));
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{1, 5}));
+  EXPECT_EQ(1, context.dictEncoders_.count(EncodingKey{2, 0}));
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{3, 1}));
+  EXPECT_EQ(0, context.dictEncoders_.count(EncodingKey{3, 3}));
+
+  context.removeAllIntDictionaryEncodersOnNode(
+      [](uint32_t nodeId) { return nodeId == 2; });
+  EXPECT_EQ(0, context.dictEncoders_.size());
+}
+
+TEST_F(WriterContextTest, BuildPhysicalSizeAggregators) {
+  auto config = std::make_shared<Config>();
+  WriterContext context{
+      config,
+      memory::memoryManager()->addRootPool("BuildPhysicalSizeAggregators")};
+  auto type = ROW({
+      {"array", ARRAY(REAL())},
+      {"map", MAP(INTEGER(), DOUBLE())},
+      {"row",
+       ROW({
+           {"a", REAL()},
+           {"b", INTEGER()},
+       })},
+      {"nested",
+       ARRAY(ROW({
+           {"a", INTEGER()},
+           {"b", MAP(REAL(), REAL())},
+       }))},
+  });
+  auto typeWithId = velox::dwio::common::TypeWithId::create(type);
+  context.buildPhysicalSizeAggregators(*typeWithId);
+  std::vector<uint32_t> mapNodes{3, 12};
+  for (size_t i = 0; i < 14; ++i) {
+    EXPECT_NO_THROW(context.getPhysicalSizeAggregator(i));
+  }
+  for (const auto nodeId : mapNodes) {
+    EXPECT_NO_THROW(dynamic_cast<MapPhysicalSizeAggregator&>(
+        context.getPhysicalSizeAggregator(nodeId)));
+  }
+}
+
+TEST_F(WriterContextTest, memory) {
+  auto writerRoot = memory::memoryManager()->addRootPool(
+      "memory", 1L << 30, exec::MemoryReclaimer::create());
+  WriterContext context{std::make_shared<Config>(), writerRoot};
+  ASSERT_EQ(context.getTotalMemoryUsage(), 0);
+  context.initBuffer();
+  VELOX_ASSERT_THROW(context.initBuffer(), "");
+  // The writer context has some initial memory allocation on construction.
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208);
+  ASSERT_EQ(context.availableMemoryReservation(), 786368);
+
+  auto& generalPool = context.getMemoryPool(MemoryUsageCategory::GENERAL);
+  auto& dictPool = context.getMemoryPool(MemoryUsageCategory::DICTIONARY);
+  auto& outputPool = context.getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM);
+  ASSERT_TRUE(generalPool.reclaimer() == nullptr);
+  ASSERT_TRUE(dictPool.reclaimer() == nullptr);
+  ASSERT_TRUE(outputPool.reclaimer() == nullptr);
+  const int bufferSize{1024};
+  void* generalBuf = generalPool.allocate(bufferSize);
+  void* dictBuf = dictPool.allocate(bufferSize);
+  void* outputBuf = outputPool.allocate(bufferSize);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208 + bufferSize * 3);
+  ASSERT_EQ(context.availableMemoryReservation(), 2880448);
+
+  ASSERT_EQ(generalPool.usedBytes(), 262208 + bufferSize);
+  ASSERT_EQ(generalPool.reservedBytes(), 1048576);
+  ASSERT_EQ(dictPool.usedBytes(), bufferSize);
+  ASSERT_EQ(dictPool.reservedBytes(), 1048576);
+  ASSERT_EQ(outputPool.usedBytes(), bufferSize);
+  ASSERT_EQ(outputPool.reservedBytes(), 1048576);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208 + bufferSize * 3);
+  ASSERT_EQ(context.availableMemoryReservation(), 2880448);
+
+  ASSERT_TRUE(generalPool.maybeReserve(4L << 20));
+  ASSERT_TRUE(dictPool.maybeReserve(4L << 20));
+  ASSERT_TRUE(outputPool.maybeReserve(4L << 20));
+  ASSERT_EQ(generalPool.usedBytes(), 262208 + bufferSize);
+  ASSERT_EQ(generalPool.reservedBytes(), 9437184);
+  ASSERT_EQ(dictPool.usedBytes(), bufferSize);
+  ASSERT_EQ(dictPool.reservedBytes(), 9437184);
+  ASSERT_EQ(outputPool.usedBytes(), bufferSize);
+  ASSERT_EQ(outputPool.reservedBytes(), 9437184);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208 + bufferSize * 3);
+  ASSERT_EQ(context.availableMemoryReservation(), 28046272);
+
+  context.releaseMemoryReservation();
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208 + bufferSize * 3);
+  ASSERT_EQ(generalPool.usedBytes(), 262208 + bufferSize);
+  ASSERT_EQ(generalPool.reservedBytes(), 1048576);
+  ASSERT_EQ(dictPool.usedBytes(), bufferSize);
+  ASSERT_EQ(dictPool.reservedBytes(), 1048576);
+  ASSERT_EQ(outputPool.usedBytes(), bufferSize);
+  ASSERT_EQ(outputPool.reservedBytes(), 1048576);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208 + bufferSize * 3);
+  ASSERT_EQ(context.availableMemoryReservation(), 2880448);
+
+  generalPool.free(generalBuf, bufferSize);
+  dictPool.free(dictBuf, bufferSize);
+  outputPool.free(outputBuf, bufferSize);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208);
+  ASSERT_EQ(generalPool.usedBytes(), 262208);
+  ASSERT_EQ(generalPool.reservedBytes(), 1048576);
+  ASSERT_EQ(dictPool.usedBytes(), 0);
+  ASSERT_EQ(dictPool.reservedBytes(), 0);
+  ASSERT_EQ(outputPool.usedBytes(), 0);
+  ASSERT_EQ(outputPool.reservedBytes(), 0);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208);
+  ASSERT_EQ(context.availableMemoryReservation(), 786368);
+}
+
+TEST_F(WriterContextTest, abort) {
+  auto writerRoot = memory::memoryManager()->addRootPool(
+      "abort", 1L << 30, exec::MemoryReclaimer::create());
+  WriterContext context{std::make_shared<Config>(), writerRoot};
+  ASSERT_EQ(context.getTotalMemoryUsage(), 0);
+  context.initBuffer();
+  // The writer context has some initial memory allocation on construction.
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208);
+  ASSERT_EQ(context.availableMemoryReservation(), 786368);
+
+  auto& generalPool = context.getMemoryPool(MemoryUsageCategory::GENERAL);
+  auto& dictPool = context.getMemoryPool(MemoryUsageCategory::DICTIONARY);
+  auto& outputPool = context.getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM);
+
+  const int bufferSize{1024};
+  void* generalBuf = generalPool.allocate(bufferSize);
+  void* dictBuf = dictPool.allocate(bufferSize);
+  void* outputBuf = outputPool.allocate(bufferSize);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208 + bufferSize * 3);
+  ASSERT_EQ(context.availableMemoryReservation(), 2880448);
+
+  ASSERT_EQ(generalPool.usedBytes(), 262208 + bufferSize);
+  ASSERT_EQ(generalPool.reservedBytes(), 1048576);
+  ASSERT_EQ(dictPool.usedBytes(), bufferSize);
+  ASSERT_EQ(dictPool.reservedBytes(), 1048576);
+  ASSERT_EQ(outputPool.usedBytes(), bufferSize);
+  ASSERT_EQ(outputPool.reservedBytes(), 1048576);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208 + bufferSize * 3);
+  ASSERT_EQ(context.availableMemoryReservation(), 2880448);
+
+  ASSERT_TRUE(generalPool.maybeReserve(4L << 20));
+  ASSERT_TRUE(dictPool.maybeReserve(4L << 20));
+  ASSERT_TRUE(outputPool.maybeReserve(4L << 20));
+  ASSERT_EQ(generalPool.usedBytes(), 262208 + bufferSize);
+  ASSERT_EQ(generalPool.reservedBytes(), 9437184);
+  ASSERT_EQ(dictPool.usedBytes(), bufferSize);
+  ASSERT_EQ(dictPool.reservedBytes(), 9437184);
+  ASSERT_EQ(outputPool.usedBytes(), bufferSize);
+  ASSERT_EQ(outputPool.reservedBytes(), 9437184);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 262208 + bufferSize * 3);
+  ASSERT_EQ(context.availableMemoryReservation(), 28046272);
+
+  context.abort();
+
+  ASSERT_EQ(context.getTotalMemoryUsage(), bufferSize * 3);
+  ASSERT_EQ(generalPool.usedBytes(), bufferSize);
+  ASSERT_EQ(generalPool.reservedBytes(), 1048576);
+  ASSERT_EQ(dictPool.usedBytes(), bufferSize);
+  ASSERT_EQ(dictPool.reservedBytes(), 1048576);
+  ASSERT_EQ(outputPool.usedBytes(), bufferSize);
+  ASSERT_EQ(outputPool.reservedBytes(), 1048576);
+  ASSERT_EQ(context.availableMemoryReservation(), 3142656);
+
+  generalPool.free(generalBuf, bufferSize);
+  dictPool.free(dictBuf, bufferSize);
+  outputPool.free(outputBuf, bufferSize);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 0);
+  ASSERT_EQ(generalPool.usedBytes(), 0);
+  ASSERT_EQ(generalPool.reservedBytes(), 0);
+  ASSERT_EQ(dictPool.usedBytes(), 0);
+  ASSERT_EQ(dictPool.reservedBytes(), 0);
+  ASSERT_EQ(outputPool.usedBytes(), 0);
+  ASSERT_EQ(outputPool.reservedBytes(), 0);
+  ASSERT_EQ(context.getTotalMemoryUsage(), 0);
+  ASSERT_EQ(context.availableMemoryReservation(), 0);
+}
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/WriterExtendedTests.cpp b/velox/dwio/dwrf/test/WriterExtendedTests.cpp
index 40e35bca68409..ddf383b449eb3 100644
--- a/velox/dwio/dwrf/test/WriterExtendedTests.cpp
+++ b/velox/dwio/dwrf/test/WriterExtendedTests.cpp
@@ -15,6 +15,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <cstdint>
 #include "folly/CPortability.h"
 
 #include "folly/Random.h"
@@ -41,25 +42,12 @@ constexpr size_t kSizeMB = 1024 * 1024;
 
 struct FlushPolicyTestCase {
  public:
-  FlushPolicyTestCase(
-      uint64_t inputStripeSize,
-      uint64_t inputDictSize,
-      uint32_t inputNumStripesLower,
-      uint32_t inputNumStripesUpper,
-      uint32_t inputSeed,
-      int64_t memoryBudget = std::numeric_limits<int64_t>::max())
-      : stripeSize{inputStripeSize},
-        dictSize{inputDictSize},
-        numStripesLower{inputNumStripesLower},
-        numStripesUpper{inputNumStripesUpper},
-        seed{inputSeed},
-        memoryBudget{memoryBudget} {}
   const uint64_t stripeSize;
   const uint64_t dictSize;
   const uint32_t numStripesLower;
   const uint32_t numStripesUpper;
   const uint32_t seed;
-  const int64_t memoryBudget;
+  const int64_t memoryBudget = std::numeric_limits<int64_t>::max();
 
   std::string debugString() const {
     return fmt::format(
@@ -75,19 +63,6 @@ struct FlushPolicyTestCase {
 
 struct FlatMapFlushPolicyTestCase : public FlushPolicyTestCase {
  public:
-  FlatMapFlushPolicyTestCase(
-      uint64_t inputStripeSize,
-      uint64_t inputDictSize,
-      uint32_t inputNumStripesLower,
-      uint32_t inputNumStripesUpper,
-      bool enableDictionary,
-      bool enableDictionarySharing,
-      uint32_t inputSeed,
-      int64_t memoryBudget = std::numeric_limits<int64_t>::max())
-      : FlushPolicyTestCase{inputStripeSize, inputDictSize, inputNumStripesLower, inputNumStripesUpper, inputSeed, memoryBudget},
-        enableDictionary{enableDictionary},
-        enableDictionarySharing{enableDictionarySharing} {}
-
   const bool enableDictionary;
   const bool enableDictionarySharing;
 };
@@ -108,16 +83,23 @@ void testWriterDefaultFlushPolicy(
       numStripesLower,
       numStripesUpper,
       config,
-      /* flushPolicyFactory */ nullptr,
-      /* layoutPlannerFactory */ nullptr,
+      /*flushPolicyFactory=*/nullptr,
+      /*layoutPlannerFactory=*/nullptr,
       memoryBudget,
       false);
 }
 
-TEST(E2EWriterTests, FlushPolicySimpleEncoding) {
+class E2EWriterTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(E2EWriterTest, FlushPolicySimpleEncoding) {
   const size_t batchCount = 200;
-  const size_t size = 1000;
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+  const size_t batchSize = 1000;
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
 
   HiveTypeParser parser;
   auto type = parser.parse(
@@ -129,32 +111,34 @@ TEST(E2EWriterTests, FlushPolicySimpleEncoding) {
       "timestamp_val:timestamp,"
       ">");
 
+  // Final file size ~3.5MB
+  const uint32_t seed = 1411367325;
   auto testCases = folly::make_array<FlushPolicyTestCase>(
       FlushPolicyTestCase{
-          /*stripeSize*/ 256 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 13,
-          /*numStripesUpper*/ 13,
-          /*seed*/ 1411367325},
+          .stripeSize = 256 * kSizeKB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 13,
+          .numStripesUpper = 13,
+          .seed = seed},
       FlushPolicyTestCase{
-          /*stripeSize*/ 512 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 7,
-          /*numStripesUpper*/ 7,
-          /*seed*/ 1411367325},
+          .stripeSize = 512 * kSizeKB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 7,
+          .numStripesUpper = 7,
+          .seed = seed},
       FlushPolicyTestCase{
-          /*stripeSize*/ 1 * kSizeMB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 4,
-          /*numStripesUpper*/ 4,
-          /*seed*/ 1411367325});
+          .stripeSize = 1 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 4,
+          .numStripesUpper = 4,
+          .seed = seed});
 
   for (const auto& testCase : testCases) {
     auto config = std::make_shared<Config>();
     config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
     config->set(Config::STRIPE_SIZE, testCase.stripeSize);
     auto batches = E2EWriterTestUtil::generateBatches(
-        type, batchCount, size, testCase.seed, *pool);
+        type, batchCount, batchSize, testCase.seed, *pool);
     testWriterDefaultFlushPolicy(
         *pool,
         type,
@@ -168,10 +152,10 @@ TEST(E2EWriterTests, FlushPolicySimpleEncoding) {
 
 // Many streams are not yet allocated prior to the first flush, hence first
 // flush is delayed if we rely on stream usage to estimate stripe size.
-TEST(E2EWriterTests, FlushPolicyDictionaryEncoding) {
+TEST_F(E2EWriterTest, FlushPolicyDictionaryEncoding) {
   const size_t batchCount = 500;
-  const size_t size = 1000;
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+  const size_t batchSize = 1000;
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
 
   HiveTypeParser parser;
   auto type = parser.parse(
@@ -183,40 +167,28 @@ TEST(E2EWriterTests, FlushPolicyDictionaryEncoding) {
       "binary_val:binary,"
       ">");
 
+  // Final file size ~10.7MB
+  const uint32_t seed = 1630160118;
   auto testCases = folly::make_array<FlushPolicyTestCase>(
       FlushPolicyTestCase{
-          /*stripeSize*/ 1 * kSizeMB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 11,
-          /*numStripesUpper*/ 11,
-          /*seed*/ 1630160118},
+          .stripeSize = 1 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 11,
+          .numStripesUpper = 11,
+          .seed = seed},
       FlushPolicyTestCase{
-          /*stripeSize*/ 1 * kSizeMB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 11,
-          /*numStripesUpper*/ 11,
-          /*seed*/ 1630160118,
-          11 * kSizeMB},
-      FlushPolicyTestCase{
-          /*stripeSize*/ 2 * kSizeMB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 6,
-          /*numStripesUpper*/ 6,
-          /*seed*/ 1630160118},
-      FlushPolicyTestCase{
-          /*stripeSize*/ 2 * kSizeMB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 6,
-          /*numStripesUpper*/ 6,
-          /*seed*/ 1630160118,
-          13 * kSizeMB});
+          .stripeSize = 2 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 5,
+          .numStripesUpper = 5,
+          .seed = seed});
 
   for (const auto& testCase : testCases) {
     auto config = std::make_shared<Config>();
     config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
     config->set(Config::STRIPE_SIZE, testCase.stripeSize);
     auto batches = E2EWriterTestUtil::generateBatches(
-        type, batchCount, size, testCase.seed, *pool);
+        type, batchCount, batchSize, testCase.seed, *pool);
     testWriterDefaultFlushPolicy(
         *pool,
         type,
@@ -227,33 +199,26 @@ TEST(E2EWriterTests, FlushPolicyDictionaryEncoding) {
         testCase.memoryBudget);
   }
 
+  // Final file size ~11MB
   auto dictionaryEncodingTestCases = folly::make_array<FlushPolicyTestCase>(
       FlushPolicyTestCase{
-          /*stripeSize*/ 256 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 42,
-          /*numStripesUpper*/ 42,
-          /*seed*/ 1630160118},
-      FlushPolicyTestCase{
-          /*stripeSize*/ 256 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 42,
-          /*numStripesUpper*/ 42,
-          /*seed*/ 1630160118,
-          6 * kSizeMB},
+          .stripeSize = 256 * kSizeKB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 42,
+          .numStripesUpper = 43,
+          .seed = seed},
       FlushPolicyTestCase{
-          /*stripeSize*/ 512 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 22,
-          /*numStripesUpper*/ 22,
-          /*seed*/ 1630160118},
+          .stripeSize = 512 * kSizeKB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 22,
+          .numStripesUpper = 22,
+          .seed = seed},
       FlushPolicyTestCase{
-          /*stripeSize*/ 512 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 22,
-          /*numStripesUpper*/ 22,
-          /*seed*/ 1630160118,
-          10 * kSizeMB});
+          .stripeSize = 4 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 3,
+          .numStripesUpper = 3,
+          .seed = seed});
 
   for (const auto& testCase : dictionaryEncodingTestCases) {
     auto config = std::make_shared<Config>();
@@ -263,7 +228,7 @@ TEST(E2EWriterTests, FlushPolicyDictionaryEncoding) {
     config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
     config->set(Config::STRIPE_SIZE, testCase.stripeSize);
     auto batches = E2EWriterTestUtil::generateBatches(
-        type, batchCount, size, testCase.seed, *pool);
+        type, batchCount, batchSize, testCase.seed, *pool);
     testWriterDefaultFlushPolicy(
         *pool,
         type,
@@ -274,19 +239,21 @@ TEST(E2EWriterTests, FlushPolicyDictionaryEncoding) {
         testCase.memoryBudget);
   }
 
+  // Final file size ~11MB
+  const uint32_t dictionaryFlushSeed = 1719796763;
   auto dictionarySizeTestCases = folly::make_array<FlushPolicyTestCase>(
       FlushPolicyTestCase{
-          /*stripeSize*/ std::numeric_limits<int64_t>::max(),
-          /*dictSize*/ 20 * kSizeKB,
-          /*numStripesLower*/ 500,
-          /*numStripesUpper*/ 500,
-          /*seed*/ 1719796763},
+          .stripeSize = std::numeric_limits<int64_t>::max(),
+          .dictSize = 20 * kSizeKB,
+          .numStripesLower = 500,
+          .numStripesUpper = 500,
+          .seed = dictionaryFlushSeed},
       FlushPolicyTestCase{
-          /*stripeSize*/ std::numeric_limits<int64_t>::max(),
-          /*dictSize*/ 40 * kSizeKB,
-          /*numStripesLower*/ 250,
-          /*numStripesUpper*/ 250,
-          /*seed*/ 1719796763});
+          .stripeSize = std::numeric_limits<int64_t>::max(),
+          .dictSize = 40 * kSizeKB,
+          .numStripesLower = 250,
+          .numStripesUpper = 250,
+          .seed = dictionaryFlushSeed});
 
   for (const auto& testCase : dictionarySizeTestCases) {
     // Force writing with dictionary encoding.
@@ -297,7 +264,7 @@ TEST(E2EWriterTests, FlushPolicyDictionaryEncoding) {
 
     config->set(Config::MAX_DICTIONARY_SIZE, testCase.dictSize);
     auto batches = E2EWriterTestUtil::generateBatches(
-        type, batchCount, size, testCase.seed, *pool);
+        type, batchCount, batchSize, testCase.seed, *pool);
     testWriterDefaultFlushPolicy(
         *pool,
         type,
@@ -310,10 +277,10 @@ TEST(E2EWriterTests, FlushPolicyDictionaryEncoding) {
 }
 
 // stream usage seems to have a delta that is close to compression block size?
-TEST(E2EWriterTests, FlushPolicyNestedTypes) {
+TEST_F(E2EWriterTest, FlushPolicyNestedTypes) {
   const size_t batchCount = 10;
-  const size_t size = 1000;
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+  const size_t batchSize = 1000;
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
 
   HiveTypeParser parser;
   auto type = parser.parse(
@@ -325,40 +292,377 @@ TEST(E2EWriterTests, FlushPolicyNestedTypes) {
       "struct_val:struct<a:float,b:double>"
       ">");
 
+  // Final file size ~1.4MB
+  const uint32_t seed = 3850165650;
   auto testCases = folly::make_array<FlushPolicyTestCase>(
       FlushPolicyTestCase{
-          /*stripeSize*/ 256 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 5,
-          /*numStripesUpper*/ 5,
-          /*seed*/ 3850165650},
+          .stripeSize = 256 * kSizeKB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 5,
+          .numStripesUpper = 5,
+          .seed = seed},
+      FlushPolicyTestCase{
+          .stripeSize = 512 * kSizeKB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 3,
+          .numStripesUpper = 3,
+          .seed = seed});
+
+  for (const auto& testCase : testCases) {
+    auto config = std::make_shared<Config>();
+    config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
+    config->set(Config::STRIPE_SIZE, testCase.stripeSize);
+    auto batches = E2EWriterTestUtil::generateBatches(
+        type, batchCount, batchSize, testCase.seed, *pool);
+    testWriterDefaultFlushPolicy(
+        *pool,
+        type,
+        batches,
+        testCase.numStripesLower,
+        testCase.numStripesUpper,
+        config,
+        testCase.memoryBudget);
+  }
+}
+
+// Flat map has 1.5 orders of magnitude inflated stream memory usage.
+TEST_F(E2EWriterTest, FlushPolicyFlatMap) {
+  const size_t batchCount = 10;
+  const size_t batchSize = 500;
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+
+  HiveTypeParser parser;
+  // A mixture of columns where dictionary sharing is not necessarily
+  // turned on.
+  auto type = parser.parse(
+      "struct<"
+      "map_val:map<int,int>,"
+      "dense_features:map<int,float>,"
+      "sparse_features:map<bigint,array<bigint>>,"
+      "id_score_list_features:map<bigint,map<bigint, float>>,"
+      ">");
+
+  const uint32_t seed = 1321904009;
+  auto testCases = folly::make_array<FlatMapFlushPolicyTestCase>(
+      FlatMapFlushPolicyTestCase{
+          {.stripeSize = 256 * kSizeKB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 6,
+           .numStripesUpper = 6,
+           .seed = seed},
+          /*enableDictionary=*/true,
+          /*enableDictionarySharing=*/false},
+      FlatMapFlushPolicyTestCase{
+          {.stripeSize = 512 * kSizeKB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 4,
+           .numStripesUpper = 4,
+           .seed = seed},
+          /*enableDictionary=*/true,
+          /*enableDictionarySharing=*/false},
+      FlatMapFlushPolicyTestCase{
+          {.stripeSize = 2 * kSizeMB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 2,
+           .numStripesUpper = 2,
+           .seed = seed},
+          /*enableDictionary=*/true,
+          /*enableDictionarySharing=*/false},
+      FlatMapFlushPolicyTestCase{
+          {.stripeSize = 256 * kSizeKB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 6,
+           .numStripesUpper = 6,
+           .seed = seed},
+          /*enableDictionary=*/false,
+          /*enableDictionarySharing=*/false},
+      FlatMapFlushPolicyTestCase{
+          {.stripeSize = 512 * kSizeKB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 4,
+           .numStripesUpper = 4,
+           .seed = seed},
+          /*enableDictionary=*/false,
+          /*enableDictionarySharing=*/false},
+      FlatMapFlushPolicyTestCase{
+          {.stripeSize = 2 * kSizeMB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 2,
+           .numStripesUpper = 2,
+           .seed = seed},
+          /*enableDictionary=*/false,
+          /*enableDictionarySharing=*/false});
+
+  for (const auto& testCase : testCases) {
+    auto config = std::make_shared<Config>();
+    config->set(Config::STRIPE_SIZE, testCase.stripeSize);
+    config->set(Config::MAX_DICTIONARY_SIZE, testCase.dictSize);
+    config->set(Config::FLATTEN_MAP, true);
+    config->set(Config::MAP_FLAT_COLS, {0, 1, 2, 3});
+    config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
+    config->set(
+        Config::MAP_FLAT_DISABLE_DICT_ENCODING, !testCase.enableDictionary);
+    if (testCase.enableDictionary) {
+      // Force dictionary encoding for integer columns.
+      config->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 1.0f);
+    } else {
+      config->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 0.0f);
+    }
+    config->set(Config::MAP_FLAT_DICT_SHARE, testCase.enableDictionarySharing);
+    auto batches = E2EWriterTestUtil::generateBatches(
+        type, batchCount, batchSize, testCase.seed, *pool);
+
+    testWriterDefaultFlushPolicy(
+        *pool,
+        type,
+        batches,
+        testCase.numStripesLower,
+        testCase.numStripesUpper,
+        config,
+        testCase.memoryBudget);
+  }
+}
+
+TEST_F(E2EWriterTest, MemoryPoolBasedFlushPolicySimpleEncoding) {
+  const size_t batchCount = 2000;
+  const size_t batchSize = 5000;
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "bool_val:boolean,"
+      "byte_val:tinyint,"
+      "float_val:float,"
+      "double_val:double,"
+      "timestamp_val:timestamp,"
+      ">");
+
+  // Final file size ~175MB
+  const uint32_t seed = 1411367325;
+  auto testCases = folly::make_array<FlushPolicyTestCase>(
       FlushPolicyTestCase{
-          /*stripeSize*/ 256 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 5,
-          /*numStripesUpper*/ 5,
-          /*seed*/ 3850165650,
-          8 * kSizeMB},
+          .stripeSize = 2 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 55,
+          .numStripesUpper = 55,
+          .seed = seed},
       FlushPolicyTestCase{
-          /*stripeSize*/ 512 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 3,
-          /*numStripesUpper*/ 3,
-          /*seed*/ 3850165650},
+          .stripeSize = 4 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 23,
+          .numStripesUpper = 23,
+          .seed = seed},
       FlushPolicyTestCase{
-          /*stripeSize*/ 512 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 3,
-          /*numStripesUpper*/ 3,
-          /*seed*/ 2969662436,
-          8 * kSizeMB});
+          .stripeSize = 32 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 3,
+          .numStripesUpper = 3,
+          .seed = seed});
 
   for (const auto& testCase : testCases) {
     auto config = std::make_shared<Config>();
     config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
     config->set(Config::STRIPE_SIZE, testCase.stripeSize);
+    config->set<uint64_t>(dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN, 64UL);
+    config->set(dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS, false);
     auto batches = E2EWriterTestUtil::generateBatches(
-        type, batchCount, size, testCase.seed, *pool);
+        type, batchCount, batchSize, testCase.seed, *pool);
+    testWriterDefaultFlushPolicy(
+        *pool,
+        type,
+        batches,
+        testCase.numStripesLower,
+        testCase.numStripesUpper,
+        config,
+        testCase.memoryBudget);
+  }
+}
+
+// Many streams are not yet allocated prior to the first flush, hence first
+// flush is delayed if we rely on stream usage to estimate stripe size.
+TEST_F(E2EWriterTest, MemoryPoolBasedFlushPolicyDictionaryEncoding) {
+  const size_t batchCount = 1000;
+  const size_t batchSize = 2000;
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "short_val:smallint,"
+      "int_val:int,"
+      "long_val:bigint,"
+      "string_val:string,"
+      "binary_val:binary,"
+      ">");
+
+  // Final file size 43MB-46MB
+  const uint32_t seed = 1630160118;
+  auto testCases = folly::make_array<FlushPolicyTestCase>(
+      FlushPolicyTestCase{
+          .stripeSize = 1 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 38,
+          .numStripesUpper = 38,
+          .seed = seed},
+      FlushPolicyTestCase{
+          .stripeSize = 2 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 15,
+          .numStripesUpper = 15,
+          .seed = seed},
+      FlushPolicyTestCase{
+          .stripeSize = 16 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 2,
+          .numStripesUpper = 2,
+          .seed = seed});
+
+  for (const auto& testCase : testCases) {
+    auto config = std::make_shared<Config>();
+    config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
+    config->set(Config::STRIPE_SIZE, testCase.stripeSize);
+    config->set<uint64_t>(dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN, 64UL);
+    config->set(dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS, false);
+    auto batches = E2EWriterTestUtil::generateBatches(
+        type, batchCount, batchSize, testCase.seed, *pool);
+    testWriterDefaultFlushPolicy(
+        *pool,
+        type,
+        batches,
+        testCase.numStripesLower,
+        testCase.numStripesUpper,
+        config,
+        testCase.memoryBudget);
+  }
+
+  // Final file size 43MB-46MB
+  auto dictionaryEncodingTestCases = folly::make_array<FlushPolicyTestCase>(
+      FlushPolicyTestCase{
+          .stripeSize = 1 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 63,
+          .numStripesUpper = 63,
+          .seed = seed},
+      FlushPolicyTestCase{
+          .stripeSize = 2 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 29,
+          .numStripesUpper = 29,
+          .seed = seed},
+      FlushPolicyTestCase{
+          .stripeSize = 16 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 3,
+          .numStripesUpper = 3,
+          .seed = seed});
+
+  for (const auto& testCase : dictionaryEncodingTestCases) {
+    auto config = std::make_shared<Config>();
+    config->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 1.0f);
+    config->set(Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 1.0f);
+    config->set(Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
+    config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
+    config->set(Config::STRIPE_SIZE, testCase.stripeSize);
+    config->set<uint64_t>(dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN, 64UL);
+    config->set(dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS, false);
+    auto batches = E2EWriterTestUtil::generateBatches(
+        type, batchCount, batchSize, testCase.seed, *pool);
+    testWriterDefaultFlushPolicy(
+        *pool,
+        type,
+        batches,
+        testCase.numStripesLower,
+        testCase.numStripesUpper,
+        config,
+        testCase.memoryBudget);
+  }
+
+  // Final file size 43MB-46MB
+  const uint32_t dictionaryFlushSeed = 1719796763;
+  auto dictionarySizeTestCases = folly::make_array<FlushPolicyTestCase>(
+      FlushPolicyTestCase{
+          .stripeSize = std::numeric_limits<int64_t>::max(),
+          .dictSize = 200 * kSizeKB,
+          .numStripesLower = 319,
+          .numStripesUpper = 319,
+          .seed = dictionaryFlushSeed},
+      FlushPolicyTestCase{
+          .stripeSize = std::numeric_limits<int64_t>::max(),
+          .dictSize = 1 * kSizeMB,
+          .numStripesLower = 63,
+          .numStripesUpper = 63,
+          .seed = dictionaryFlushSeed});
+
+  for (const auto& testCase : dictionarySizeTestCases) {
+    // Force writing with dictionary encoding.
+    auto config = std::make_shared<Config>();
+    config->set(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD, 1.0f);
+    config->set(Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD, 1.0f);
+    config->set(Config::ENTROPY_KEY_STRING_SIZE_THRESHOLD, 0.0f);
+    config->set<uint64_t>(dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN, 64UL);
+    config->set(dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS, false);
+
+    config->set(Config::MAX_DICTIONARY_SIZE, testCase.dictSize);
+    auto batches = E2EWriterTestUtil::generateBatches(
+        type, batchCount, batchSize, testCase.seed, *pool);
+    testWriterDefaultFlushPolicy(
+        *pool,
+        type,
+        batches,
+        testCase.numStripesLower,
+        testCase.numStripesUpper,
+        config,
+        testCase.memoryBudget);
+  }
+}
+
+// stream usage seems to have a delta that is close to compression block size?
+TEST_F(E2EWriterTest, MemoryPoolBasedFlushPolicyNestedTypes) {
+  const size_t batchCount = 100;
+  const size_t batchSize = 1000;
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+
+  HiveTypeParser parser;
+  auto type = parser.parse(
+      "struct<"
+      "array_val:array<float>,"
+      "map_val:map<int,double>,"
+      "map_val1:map<bigint,double>,"
+      "map_val2:map<bigint,map<string, int>>,"
+      "struct_val:struct<a:float,b:double>"
+      ">");
+
+  // Final file size 14MB
+  const uint32_t seed = 3850165650;
+  auto testCases = folly::make_array<FlushPolicyTestCase>(
+      FlushPolicyTestCase{
+          .stripeSize = 2 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 5,
+          .numStripesUpper = 5,
+          .seed = seed},
+      FlushPolicyTestCase{
+          .stripeSize = 4 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 3,
+          .numStripesUpper = 3,
+          .seed = seed},
+      FlushPolicyTestCase{
+          .stripeSize = 16 * kSizeMB,
+          .dictSize = std::numeric_limits<int64_t>::max(),
+          .numStripesLower = 1,
+          .numStripesUpper = 1,
+          .seed = seed});
+
+  for (const auto& testCase : testCases) {
+    auto config = std::make_shared<Config>();
+    config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
+    config->set(Config::STRIPE_SIZE, testCase.stripeSize);
+    config->set<uint64_t>(dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN, 64UL);
+    config->set(dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS, false);
+    auto batches = E2EWriterTestUtil::generateBatches(
+        type, batchCount, batchSize, testCase.seed, *pool);
     testWriterDefaultFlushPolicy(
         *pool,
         type,
@@ -371,10 +675,11 @@ TEST(E2EWriterTests, FlushPolicyNestedTypes) {
 }
 
 // Flat map has 1.5 orders of magnitude inflated stream memory usage.
-TEST(E2EWriterTests, FlushPolicyFlatMap) {
-  const size_t batchCount = 10;
-  const size_t size = 500;
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+// Disabled because test is failing in continuous runs T193531984.
+TEST_F(E2EWriterTest, DISABLED_MemoryPoolBasedFlushPolicyFlatMap) {
+  const size_t batchCount = 500;
+  const size_t batchSize = 500;
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
 
   HiveTypeParser parser;
   // A mixture of columns where dictionary sharing is not necessarily
@@ -387,55 +692,56 @@ TEST(E2EWriterTests, FlushPolicyFlatMap) {
       "id_score_list_features:map<bigint,map<bigint, float>>,"
       ">");
 
+  const uint32_t seed = 1321904009;
   auto testCases = folly::make_array<FlatMapFlushPolicyTestCase>(
       FlatMapFlushPolicyTestCase{
-          /*stripeSize*/ 256 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 6,
-          /*numStripesUpper*/ 6,
-          /*enableDictionary*/ true,
-          /*enableDictionarySharing*/ false,
-          /*seed*/ 1321904009},
+          {.stripeSize = 4 * kSizeMB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 310,
+           .numStripesUpper = 310,
+           .seed = seed},
+          /*enableDictionary=*/true,
+          /*enableDictionarySharing=*/true},
       FlatMapFlushPolicyTestCase{
-          /*stripeSize*/ 512 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 4,
-          /*numStripesUpper*/ 4,
-          /*enableDictionary*/ true,
-          /*enableDictionarySharing*/ false,
-          /*seed*/ 1321904009},
+          {.stripeSize = 16 * kSizeMB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 3,
+           .numStripesUpper = 4,
+           .seed = seed},
+          /*enableDictionary=*/true,
+          /*enableDictionarySharing=*/true},
       FlatMapFlushPolicyTestCase{
-          /*stripeSize*/ 2 * kSizeMB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 2,
-          /*numStripesUpper*/ 2,
-          /*enableDictionary*/ true,
-          /*enableDictionarySharing*/ true,
-          /*seed*/ 1321904009},
+          {.stripeSize = 128 * kSizeMB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 1,
+           .numStripesUpper = 1,
+           .seed = seed},
+          /*enableDictionary=*/true,
+          /*enableDictionarySharing=*/true},
       FlatMapFlushPolicyTestCase{
-          /*stripeSize*/ 256 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 6,
-          /*numStripesUpper*/ 6,
-          /*enableDictionary*/ false,
-          /*enableDictionarySharing*/ false,
-          /*seed*/ 1321904009},
+          {.stripeSize = 4 * kSizeMB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 308,
+           .numStripesUpper = 308,
+           .seed = seed},
+          /*enableDictionary=*/false,
+          /*enableDictionarySharing=*/true},
       FlatMapFlushPolicyTestCase{
-          /*stripeSize*/ 512 * kSizeKB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 4,
-          /*numStripesUpper*/ 4,
-          /*enableDictionary*/ false,
-          /*enableDictionarySharing*/ false,
-          /*seed*/ 1321904009},
+          {.stripeSize = 16 * kSizeMB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 3,
+           .numStripesUpper = 4,
+           .seed = seed},
+          /*enableDictionary=*/false,
+          /*enableDictionarySharing=*/true},
       FlatMapFlushPolicyTestCase{
-          /*stripeSize*/ 2 * kSizeMB,
-          /*dictSize*/ std::numeric_limits<int64_t>::max(),
-          /*numStripesLower*/ 2,
-          /*numStripesUpper*/ 2,
-          /*enableDictionary*/ false,
-          /*enableDictionarySharing*/ true,
-          /*seed*/ 1321904009});
+          {.stripeSize = 128 * kSizeMB,
+           .dictSize = std::numeric_limits<int64_t>::max(),
+           .numStripesLower = 1,
+           .numStripesUpper = 1,
+           .seed = seed},
+          /*enableDictionary=*/false,
+          /*enableDictionarySharing=*/true});
 
   for (const auto& testCase : testCases) {
     auto config = std::make_shared<Config>();
@@ -444,6 +750,8 @@ TEST(E2EWriterTests, FlushPolicyFlatMap) {
     config->set(Config::FLATTEN_MAP, true);
     config->set(Config::MAP_FLAT_COLS, {0, 1, 2, 3});
     config->set(Config::DISABLE_LOW_MEMORY_MODE, true);
+    config->set<uint64_t>(dwrf::Config::COMPRESSION_BLOCK_SIZE_MIN, 64UL);
+    config->set(dwrf::Config::LINEAR_STRIPE_SIZE_HEURISTICS, false);
     config->set(
         Config::MAP_FLAT_DISABLE_DICT_ENCODING, !testCase.enableDictionary);
     if (testCase.enableDictionary) {
@@ -454,7 +762,7 @@ TEST(E2EWriterTests, FlushPolicyFlatMap) {
     }
     config->set(Config::MAP_FLAT_DICT_SHARE, testCase.enableDictionarySharing);
     auto batches = E2EWriterTestUtil::generateBatches(
-        type, batchCount, size, testCase.seed, *pool);
+        type, batchCount, batchSize, testCase.seed, *pool);
 
     testWriterDefaultFlushPolicy(
         *pool,
diff --git a/velox/dwio/dwrf/test/WriterFlushTest.cpp b/velox/dwio/dwrf/test/WriterFlushTest.cpp
index 2fdcba761ac2c..76ef171717b99 100644
--- a/velox/dwio/dwrf/test/WriterFlushTest.cpp
+++ b/velox/dwio/dwrf/test/WriterFlushTest.cpp
@@ -57,18 +57,20 @@ class MockMemoryPool : public velox::memory::MemoryPool {
     VELOX_NYI("{} unsupported", __FUNCTION__);
   }
 
-  int64_t reservedBytes() const override {
+  int64_t releasableReservation() const override {
     VELOX_NYI("{} unsupported", __FUNCTION__);
   }
 
-  bool maybeReserve(uint64_t size) override {
-    VELOX_NYI("{} unsupported", __FUNCTION__);
+  int64_t reservedBytes() const override {
+    return localMemoryUsage_;
   }
 
-  void release() override {
+  bool maybeReserve(uint64_t size) override {
     VELOX_NYI("{} unsupported", __FUNCTION__);
   }
 
+  void release() override {}
+
   Stats stats() const override {
     VELOX_NYI("{} unsupported", __FUNCTION__);
   }
@@ -154,7 +156,7 @@ class MockMemoryPool : public velox::memory::MemoryPool {
     VELOX_UNSUPPORTED("growContiguous unsupported");
   }
 
-  int64_t currentBytes() const override {
+  int64_t usedBytes() const override {
     return localMemoryUsage_;
   }
 
@@ -169,7 +171,6 @@ class MockMemoryPool : public velox::memory::MemoryPool {
   }
 
   MOCK_CONST_METHOD0(peakBytes, int64_t());
-  // MOCK_CONST_METHOD0(getMaxBytes, int64_t());
 
   MOCK_METHOD1(updateSubtreeMemoryUsage, int64_t(int64_t));
 
@@ -180,12 +181,10 @@ class MockMemoryPool : public velox::memory::MemoryPool {
   }
 
   void setReclaimer(
-      std::unique_ptr<memory::MemoryReclaimer> reclaimer) override {
-    VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
-  }
+      std::unique_ptr<memory::MemoryReclaimer> reclaimer) override {}
 
   memory::MemoryReclaimer* reclaimer() const override {
-    VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
+    return nullptr;
   }
 
   void enterArbitration() override {
@@ -196,11 +195,12 @@ class MockMemoryPool : public velox::memory::MemoryPool {
     VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
   }
 
-  bool reclaimableBytes(uint64_t& reclaimableBytes) const override {
+  std::optional<uint64_t> reclaimableBytes() const override {
     VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
   }
 
   uint64_t reclaim(
+      uint64_t /*unused*/,
       uint64_t /*unused*/,
       velox::memory::MemoryReclaimer::Stats& /*unused*/) override {
     VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
@@ -210,7 +210,7 @@ class MockMemoryPool : public velox::memory::MemoryPool {
     VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
   }
 
-  uint64_t grow(uint64_t /*unused*/) noexcept override {
+  bool grow(uint64_t /*unused*/, uint64_t /*unused*/) noexcept override {
     VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
   }
 
@@ -228,13 +228,13 @@ class MockMemoryPool : public velox::memory::MemoryPool {
     VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
   }
 
-  std::string treeMemoryUsage() const override {
+  std::string treeMemoryUsage(bool /*unused*/) const override {
     VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);
   }
 
  private:
   velox::memory::MemoryAllocator* const allocator_{
-      velox::memory::MemoryAllocator::getInstance()};
+      velox::memory::memoryManager()->allocator()};
   const int64_t capacity_;
   int64_t localMemoryUsage_{0};
 };
@@ -324,7 +324,7 @@ struct SimulatedFlush {
     auto& generalPool = dynamic_cast<MockMemoryPool&>(
         context.getMemoryPool(MemoryUsageCategory::GENERAL));
     dictPool.setLocalMemoryUsage(dictMemoryUsage);
-    ASSERT_EQ(outputStreamMemoryUsage, outputPool.currentBytes());
+    ASSERT_EQ(outputStreamMemoryUsage, outputPool.usedBytes());
     outputPool.updateLocalMemoryUsage(flushOverhead);
     generalPool.setLocalMemoryUsage(generalMemoryUsage);
 
@@ -421,13 +421,12 @@ class WriterFlushTestHelper {
       if (writer->shouldFlush(context, write.numRows)) {
         ASSERT_EQ(
             0,
-            context.getMemoryPool(MemoryUsageCategory::DICTIONARY)
-                .currentBytes());
+            context.getMemoryPool(MemoryUsageCategory::DICTIONARY).usedBytes());
         auto outputStreamMemoryUsage =
             context.getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM)
-                .currentBytes();
+                .usedBytes();
         auto generalMemoryUsage =
-            context.getMemoryPool(MemoryUsageCategory::GENERAL).currentBytes();
+            context.getMemoryPool(MemoryUsageCategory::GENERAL).usedBytes();
 
         uint64_t flushOverhead =
             folly::Random::rand32(0, context.stripeRawSize(), gen);
@@ -478,8 +477,15 @@ class WriterFlushTestHelper {
   }
 };
 
+class TestWriterFlush : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
 // This test checks against constructed test cases.
-TEST(TestWriterFlush, CheckAgainstMemoryBudget) {
+TEST_F(TestWriterFlush, CheckAgainstMemoryBudget) {
   auto pool = MockMemoryPool::create();
   {
     auto writer = WriterFlushTestHelper::prepWriter(pool, 1024);
@@ -629,7 +635,7 @@ TEST(TestWriterFlush, CheckAgainstMemoryBudget) {
 }
 
 // Tests the number of stripes produced based on random results.
-TEST(TestWriterFlush, MemoryBasedFlushRandom) {
+TEST_F(TestWriterFlush, MemoryBasedFlushRandom) {
   struct TestCase {
     TestCase(
         uint32_t seed,
diff --git a/velox/dwio/dwrf/test/WriterSinkTest.cpp b/velox/dwio/dwrf/test/WriterSinkTest.cpp
new file mode 100644
index 0000000000000..15ecea7128dfd
--- /dev/null
+++ b/velox/dwio/dwrf/test/WriterSinkTest.cpp
@@ -0,0 +1,513 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/dwrf/writer/WriterSink.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "folly/Random.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+using namespace ::testing;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwrf;
+using namespace facebook::velox::memory;
+
+class WriterSinkTest : public Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    for (size_t i = 0; i < data.size(); ++i) {
+      data.data()[i] = static_cast<char>(i % 0xff);
+    }
+  }
+
+  void TearDown() override {}
+
+  void checkOutput(const MemorySink& out, size_t offset) {
+    ASSERT_EQ(out.size() - offset, data.size());
+    auto actual = out.data() + offset;
+    for (size_t i = 0; i < data.size(); ++i) {
+      ASSERT_EQ(data.data()[i], actual[i]);
+    }
+  }
+
+  std::array<char, 1024> data;
+};
+
+TEST_F(WriterSinkTest, Checksum) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024 + 3, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::CRC32);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::NA);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+  VELOX_ASSERT_THROW(sink.init(*pool), "");
+  auto offset = out.size();
+
+  auto checksum = sink.getChecksum();
+  ASSERT_EQ(checksum->getType(), proto::ChecksumAlgorithm::CRC32);
+
+  sink.setMode(WriterSink::Mode::Index);
+  sink.addBuffer(*pool, data.data(), data.size());
+  checkOutput(out, offset);
+  ASSERT_EQ(checksum->getDigest(), 1709612422);
+
+  out.reset();
+  offset = out.size();
+  sink.setMode(WriterSink::Mode::Data);
+  sink.addBuffer(*pool, data.data(), data.size());
+  checkOutput(out, offset);
+  ASSERT_EQ(checksum->getDigest(), 1709612422);
+
+  out.reset();
+  offset = out.size();
+  sink.setMode(WriterSink::Mode::Footer);
+  sink.addBuffer(*pool, data.data(), data.size());
+  checkOutput(out, offset);
+  ASSERT_EQ(checksum->getDigest(), 1709612422);
+
+  out.reset();
+  offset = out.size();
+  sink.setMode(WriterSink::Mode::None);
+  sink.addBuffer(*pool, data.data(), data.size());
+  checkOutput(out, offset);
+  ASSERT_EQ(checksum->getDigest(), 0);
+
+  ASSERT_EQ(sink.size(), out.size() - offset);
+}
+
+TEST_F(WriterSinkTest, NoChecksum) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024 + 3, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::NA);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+  auto offset = out.size();
+
+  ASSERT_EQ(sink.getChecksum(), nullptr);
+  sink.setMode(WriterSink::Mode::Index);
+
+  sink.addBuffer(*pool, data.data(), data.size());
+  checkOutput(out, offset);
+}
+
+TEST_F(WriterSinkTest, NoCache) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::NA);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+  auto offset = out.size();
+
+  ASSERT_EQ(sink.getCacheMode(), config.get(Config::STRIPE_CACHE_MODE));
+  ASSERT_EQ(sink.getCacheOffsets().size(), 0);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+
+  sink.setMode(WriterSink::Mode::Index);
+  sink.addBuffer(*pool, data.data(), 512);
+  sink.setMode(WriterSink::Mode::None);
+
+  ASSERT_EQ(sink.getCacheOffsets().size(), 0);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+
+  sink.writeCache();
+  ASSERT_EQ(out.size() - offset, 512);
+}
+
+TEST_F(WriterSinkTest, CacheIndex) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::INDEX);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+  auto offset = out.size();
+
+  ASSERT_EQ(sink.getCacheMode(), config.get(Config::STRIPE_CACHE_MODE));
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+  ASSERT_EQ(sink.getCacheOffsets().at(0), 0);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+
+  sink.setMode(WriterSink::Mode::Index);
+  sink.addBuffer(*pool, data.data(), 128);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+
+  sink.setMode(WriterSink::Mode::Data);
+  ASSERT_EQ(sink.getCacheSize(), 128);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+  ASSERT_EQ(sink.getCacheOffsets().at(1), sink.getCacheSize());
+  sink.addBuffer(*pool, data.data() + 1, 128);
+
+  sink.setMode(WriterSink::Mode::Footer);
+  ASSERT_EQ(sink.getCacheSize(), 128);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+  sink.addBuffer(*pool, data.data() + 2, 128);
+
+  sink.setMode(WriterSink::Mode::None);
+  ASSERT_EQ(sink.getCacheSize(), 128);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+
+  ASSERT_EQ(out.size() - offset, 384);
+  sink.writeCache();
+  ASSERT_EQ(out.size() - offset, 512);
+  ASSERT_EQ(
+      std::string(out.data() + offset + 384, 128),
+      std::string(out.data() + offset, 128));
+}
+
+TEST_F(WriterSinkTest, CacheFooter) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::FOOTER);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+  auto offset = out.size();
+
+  ASSERT_EQ(sink.getCacheMode(), config.get(Config::STRIPE_CACHE_MODE));
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+  ASSERT_EQ(sink.getCacheOffsets().at(0), 0);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+
+  sink.setMode(WriterSink::Mode::Index);
+  sink.addBuffer(*pool, data.data(), 128);
+
+  sink.setMode(WriterSink::Mode::Data);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+  sink.addBuffer(*pool, data.data() + 1, 128);
+
+  sink.setMode(WriterSink::Mode::Footer);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+  sink.addBuffer(*pool, data.data() + 2, 128);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+
+  sink.setMode(WriterSink::Mode::None);
+  ASSERT_EQ(sink.getCacheSize(), 128);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+  ASSERT_EQ(sink.getCacheOffsets().at(1), sink.getCacheSize());
+
+  ASSERT_EQ(out.size() - offset, 384);
+  sink.writeCache();
+  ASSERT_EQ(out.size() - offset, 512);
+  ASSERT_EQ(
+      std::string(out.data() + offset + 256, 128),
+      std::string(out.data() + offset + 384, 128));
+}
+
+TEST_F(WriterSinkTest, CacheBothEmptyIndex) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+
+  sink.setMode(WriterSink::Mode::Index);
+  // don't add any buffer
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+  ASSERT_EQ(sink.getCacheOffsets().at(0), 0);
+
+  sink.setMode(WriterSink::Mode::Data);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+  ASSERT_EQ(sink.getCacheOffsets().at(1), 0);
+  sink.addBuffer(*pool, data.data() + 1, 128);
+
+  sink.setMode(WriterSink::Mode::Footer);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+  sink.addBuffer(*pool, data.data() + 1, 128);
+  sink.setMode(WriterSink::Mode::None);
+
+  ASSERT_EQ(sink.getCacheOffsets().size(), 3);
+  ASSERT_EQ(sink.getCacheOffsets().at(2), 128);
+  ASSERT_EQ(sink.getCacheSize(), 128);
+}
+
+TEST_F(WriterSinkTest, CacheBoth) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+  auto offset = out.size();
+
+  ASSERT_EQ(sink.getCacheMode(), config.get(Config::STRIPE_CACHE_MODE));
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+  ASSERT_EQ(sink.getCacheOffsets().at(0), 0);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+
+  sink.setMode(WriterSink::Mode::Index);
+  sink.addBuffer(*pool, data.data(), 128);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+
+  sink.setMode(WriterSink::Mode::Data);
+  ASSERT_EQ(sink.getCacheSize(), 128);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+  ASSERT_EQ(sink.getCacheOffsets().at(1), sink.getCacheSize());
+  sink.addBuffer(*pool, data.data() + 1, 128);
+
+  sink.setMode(WriterSink::Mode::Footer);
+  ASSERT_EQ(sink.getCacheSize(), 128);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+  sink.addBuffer(*pool, data.data() + 2, 128);
+  ASSERT_EQ(sink.getCacheSize(), 128);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+
+  sink.setMode(WriterSink::Mode::None);
+  ASSERT_EQ(sink.getCacheSize(), 256);
+  ASSERT_EQ(sink.getCacheOffsets().size(), 3);
+  ASSERT_EQ(sink.getCacheOffsets().at(2), sink.getCacheSize());
+
+  ASSERT_EQ(out.size() - offset, 384);
+  sink.writeCache();
+  ASSERT_EQ(out.size() - offset, 640);
+  ASSERT_EQ(
+      std::string(out.data() + offset, 128),
+      std::string(out.data() + offset + 384, 128));
+  ASSERT_EQ(
+      std::string(out.data() + offset + 256, 128),
+      std::string(out.data() + offset + 512, 128));
+}
+
+TEST_F(WriterSinkTest, CacheExceedsLimit) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
+  config.set(Config::STRIPE_CACHE_SIZE, static_cast<uint32_t>(100));
+
+  {
+    WriterSink sink{out, *pool, config};
+    sink.init(*pool);
+    auto offset = out.size();
+
+    sink.setMode(WriterSink::Mode::Index);
+    sink.addBuffer(*pool, data.data(), 10);
+
+    sink.setMode(WriterSink::Mode::Footer);
+    ASSERT_EQ(sink.getCacheSize(), 10);
+    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+    sink.addBuffer(*pool, data.data(), 90);
+
+    sink.setMode(WriterSink::Mode::None);
+    ASSERT_EQ(sink.getCacheSize(), 100);
+    ASSERT_EQ(sink.getCacheOffsets().size(), 3);
+
+    sink.writeCache();
+    ASSERT_EQ(out.size() - offset, 200);
+  }
+
+  out.reset();
+
+  {
+    WriterSink sink{out, *pool, config};
+    sink.init(*pool);
+    auto offset = out.size();
+
+    sink.setMode(WriterSink::Mode::Index);
+    sink.addBuffer(*pool, data.data(), 10);
+
+    sink.setMode(WriterSink::Mode::Footer);
+    ASSERT_EQ(sink.getCacheSize(), 10);
+    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+    sink.addBuffer(*pool, data.data(), 91);
+
+    sink.setMode(WriterSink::Mode::None);
+    ASSERT_EQ(sink.getCacheSize(), 10);
+    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+
+    sink.setMode(WriterSink::Mode::Index);
+    sink.addBuffer(*pool, data.data(), 10);
+
+    sink.setMode(WriterSink::Mode::None);
+    ASSERT_EQ(sink.getCacheSize(), 10);
+    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+
+    sink.writeCache();
+    ASSERT_EQ(out.size() - offset, 121);
+  }
+
+  out.reset();
+  {
+    config.set(Config::STRIPE_CACHE_SIZE, static_cast<uint32_t>(89));
+    WriterSink sink{out, *pool, config};
+    sink.init(*pool);
+    auto offset = out.size();
+
+    sink.setMode(WriterSink::Mode::Index);
+    for (int32_t i = 0; i < 9; i++) {
+      sink.addBuffer(*pool, data.data(), 10);
+      sink.setMode(WriterSink::Mode::Index);
+      ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+    }
+
+    // Cache max size is 89, Total index size is 90 (9 *10).
+    // Since it can't fit in the cache size, it should be discarded.
+    sink.setMode(WriterSink::Mode::None);
+    ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+
+    sink.writeCache();
+    ASSERT_EQ(sink.getCacheMode(), StripeCacheMode::BOTH);
+    // Only data gets written.
+    ASSERT_EQ(out.size() - offset, 90);
+  }
+
+  out.reset();
+  {
+    config.set(Config::STRIPE_CACHE_SIZE, static_cast<uint32_t>(89));
+    WriterSink sink{out, *pool, config};
+    sink.init(*pool);
+    auto offset = out.size();
+
+    sink.setMode(WriterSink::Mode::Index);
+    for (int32_t i = 0; i < 6; i++) {
+      sink.addBuffer(*pool, data.data(), 10);
+      sink.setMode(WriterSink::Mode::Index);
+      ASSERT_EQ(sink.getCacheOffsets().size(), 1);
+    }
+
+    sink.setMode(WriterSink::Mode::Footer);
+    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
+    ASSERT_EQ(sink.getCacheSize(), 60);
+
+    sink.addBuffer(*pool, data.data(), 10);
+    sink.setMode(WriterSink::Mode::None);
+    ASSERT_EQ(sink.getCacheOffsets().size(), 3);
+    ASSERT_EQ(sink.getCacheSize(), 70);
+
+    sink.setMode(WriterSink::Mode::Index);
+    for (int32_t i = 0; i < 6; i++) {
+      sink.addBuffer(*pool, data.data(), 10);
+      sink.setMode(WriterSink::Mode::Index);
+    }
+
+    sink.setMode(WriterSink::Mode::Footer);
+    sink.addBuffer(*pool, data.data(), 10);
+    sink.setMode(WriterSink::Mode::None);
+
+    // Last index and footer size, does not fit in cache size, so all of them
+    // should be discarded.
+    ASSERT_EQ(sink.getCacheOffsets().size(), 3);
+    ASSERT_EQ(sink.getCacheSize(), 70);
+
+    sink.writeCache();
+    ASSERT_EQ(sink.getCacheMode(), StripeCacheMode::BOTH);
+    ASSERT_EQ(out.size() - offset, 210);
+  }
+}
+
+TEST_F(WriterSinkTest, CacheLarge) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{10 * 1024 * 1024 + 3, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+  auto offset = out.size();
+
+  DataBuffer<char> buffer{*pool, 2048};
+  std::memset(buffer.data(), 'a', 2048);
+
+  sink.setMode(WriterSink::Mode::Index);
+  auto total = 0;
+  for (size_t i = 0; i < 1024; ++i) {
+    auto size = folly::Random::rand32(buffer.size() - 1) + 1;
+    total += size;
+    sink.addBuffer(*pool, buffer.data(), size);
+  }
+  sink.setMode(WriterSink::Mode::None);
+  ASSERT_THAT(sink.getCacheOffsets(), ElementsAre(0, total));
+  ASSERT_EQ(out.size() - offset, total);
+  sink.writeCache();
+  ASSERT_EQ(out.size() - offset, total * 2);
+}
+
+TEST_F(WriterSinkTest, SetModeOutOfOrder) {
+  auto pool = memoryManager()->addLeafPool();
+  MemorySink out{1024, {.pool = pool.get()}};
+  Config config;
+  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::CRC32);
+  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
+  WriterSink sink{out, *pool, config};
+  sink.init(*pool);
+
+  ASSERT_EQ(sink.getCacheSize(), 0);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 0);
+
+  sink.setMode(WriterSink::Mode::None);
+  sink.addBuffer(*pool, data.data(), 10);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 0);
+
+  sink.setMode(WriterSink::Mode::None);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+
+  sink.setMode(WriterSink::Mode::Index);
+  ASSERT_EQ(sink.getCacheSize(), 0);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 0);
+
+  sink.addBuffer(*pool, data.data(), 10);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 1164760902);
+
+  sink.setMode(WriterSink::Mode::Footer);
+  ASSERT_EQ(sink.getCacheSize(), 10);
+
+  sink.addBuffer(*pool, data.data(), 10);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 936993659);
+
+  sink.setMode(WriterSink::Mode::Data);
+  ASSERT_EQ(sink.getCacheSize(), 20);
+
+  sink.addBuffer(*pool, data.data(), 10);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 1522393763);
+
+  sink.setMode(WriterSink::Mode::Footer);
+  ASSERT_EQ(sink.getCacheSize(), 20);
+
+  sink.addBuffer(*pool, data.data(), 10);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 3650468470);
+
+  sink.setMode(WriterSink::Mode::Index);
+  ASSERT_EQ(sink.getCacheSize(), 30);
+
+  sink.addBuffer(*pool, data.data(), 10);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 977966233);
+
+  sink.setMode(WriterSink::Mode::None);
+  ASSERT_EQ(sink.getCacheSize(), 40);
+
+  sink.addBuffer(*pool, data.data(), 10);
+  ASSERT_EQ(sink.getChecksum()->getDigest(false), 977966233);
+}
diff --git a/velox/dwio/dwrf/test/WriterSinkTests.cpp b/velox/dwio/dwrf/test/WriterSinkTests.cpp
deleted file mode 100644
index f089d0e2823b7..0000000000000
--- a/velox/dwio/dwrf/test/WriterSinkTests.cpp
+++ /dev/null
@@ -1,494 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include "folly/Random.h"
-#include "velox/dwio/dwrf/writer/WriterSink.h"
-
-using namespace ::testing;
-using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::dwrf;
-using namespace facebook::velox::memory;
-
-class WriterSinkTests : public Test {
- protected:
-  void SetUp() override {
-    for (size_t i = 0; i < data.size(); ++i) {
-      data.data()[i] = static_cast<char>(i % 0xff);
-    }
-  }
-
-  void TearDown() override {}
-
-  void checkOutput(const MemorySink& out, size_t offset) {
-    ASSERT_EQ(out.size() - offset, data.size());
-    auto actual = out.data() + offset;
-    for (size_t i = 0; i < data.size(); ++i) {
-      ASSERT_EQ(data.data()[i], actual[i]);
-    }
-  }
-
-  std::array<char, 1024> data;
-};
-
-TEST_F(WriterSinkTests, Checksum) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024 + 3, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::CRC32);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::NA);
-  WriterSink sink{out, *pool, config};
-  auto offset = out.size();
-
-  auto checksum = sink.getChecksum();
-  ASSERT_EQ(checksum->getType(), proto::ChecksumAlgorithm::CRC32);
-
-  sink.setMode(WriterSink::Mode::Index);
-  sink.addBuffer(*pool, data.data(), data.size());
-  checkOutput(out, offset);
-  ASSERT_EQ(checksum->getDigest(), 1709612422);
-
-  out.reset();
-  offset = out.size();
-  sink.setMode(WriterSink::Mode::Data);
-  sink.addBuffer(*pool, data.data(), data.size());
-  checkOutput(out, offset);
-  ASSERT_EQ(checksum->getDigest(), 1709612422);
-
-  out.reset();
-  offset = out.size();
-  sink.setMode(WriterSink::Mode::Footer);
-  sink.addBuffer(*pool, data.data(), data.size());
-  checkOutput(out, offset);
-  ASSERT_EQ(checksum->getDigest(), 1709612422);
-
-  out.reset();
-  offset = out.size();
-  sink.setMode(WriterSink::Mode::None);
-  sink.addBuffer(*pool, data.data(), data.size());
-  checkOutput(out, offset);
-  ASSERT_EQ(checksum->getDigest(), 0);
-
-  ASSERT_EQ(sink.size(), out.size() - offset);
-}
-
-TEST_F(WriterSinkTests, NoChecksum) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024 + 3, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::NA);
-  WriterSink sink{out, *pool, config};
-  auto offset = out.size();
-
-  ASSERT_EQ(sink.getChecksum(), nullptr);
-  sink.setMode(WriterSink::Mode::Index);
-
-  sink.addBuffer(*pool, data.data(), data.size());
-  checkOutput(out, offset);
-}
-
-TEST_F(WriterSinkTests, NoCache) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::NA);
-  WriterSink sink{out, *pool, config};
-  auto offset = out.size();
-
-  ASSERT_EQ(sink.getCacheMode(), config.get(Config::STRIPE_CACHE_MODE));
-  ASSERT_EQ(sink.getCacheOffsets().size(), 0);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-
-  sink.setMode(WriterSink::Mode::Index);
-  sink.addBuffer(*pool, data.data(), 512);
-  sink.setMode(WriterSink::Mode::None);
-
-  ASSERT_EQ(sink.getCacheOffsets().size(), 0);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-
-  sink.writeCache();
-  ASSERT_EQ(out.size() - offset, 512);
-}
-
-TEST_F(WriterSinkTests, CacheIndex) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::INDEX);
-  WriterSink sink{out, *pool, config};
-  auto offset = out.size();
-
-  ASSERT_EQ(sink.getCacheMode(), config.get(Config::STRIPE_CACHE_MODE));
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-  ASSERT_EQ(sink.getCacheOffsets().at(0), 0);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-
-  sink.setMode(WriterSink::Mode::Index);
-  sink.addBuffer(*pool, data.data(), 128);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-
-  sink.setMode(WriterSink::Mode::Data);
-  ASSERT_EQ(sink.getCacheSize(), 128);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-  ASSERT_EQ(sink.getCacheOffsets().at(1), sink.getCacheSize());
-  sink.addBuffer(*pool, data.data() + 1, 128);
-
-  sink.setMode(WriterSink::Mode::Footer);
-  ASSERT_EQ(sink.getCacheSize(), 128);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-  sink.addBuffer(*pool, data.data() + 2, 128);
-
-  sink.setMode(WriterSink::Mode::None);
-  ASSERT_EQ(sink.getCacheSize(), 128);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-
-  ASSERT_EQ(out.size() - offset, 384);
-  sink.writeCache();
-  ASSERT_EQ(out.size() - offset, 512);
-  ASSERT_EQ(
-      std::string(out.data() + offset + 384, 128),
-      std::string(out.data() + offset, 128));
-}
-
-TEST_F(WriterSinkTests, CacheFooter) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::FOOTER);
-  WriterSink sink{out, *pool, config};
-  auto offset = out.size();
-
-  ASSERT_EQ(sink.getCacheMode(), config.get(Config::STRIPE_CACHE_MODE));
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-  ASSERT_EQ(sink.getCacheOffsets().at(0), 0);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-
-  sink.setMode(WriterSink::Mode::Index);
-  sink.addBuffer(*pool, data.data(), 128);
-
-  sink.setMode(WriterSink::Mode::Data);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-  sink.addBuffer(*pool, data.data() + 1, 128);
-
-  sink.setMode(WriterSink::Mode::Footer);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-  sink.addBuffer(*pool, data.data() + 2, 128);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-
-  sink.setMode(WriterSink::Mode::None);
-  ASSERT_EQ(sink.getCacheSize(), 128);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-  ASSERT_EQ(sink.getCacheOffsets().at(1), sink.getCacheSize());
-
-  ASSERT_EQ(out.size() - offset, 384);
-  sink.writeCache();
-  ASSERT_EQ(out.size() - offset, 512);
-  ASSERT_EQ(
-      std::string(out.data() + offset + 256, 128),
-      std::string(out.data() + offset + 384, 128));
-}
-
-TEST_F(WriterSinkTests, CacheBothEmptyIndex) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
-  WriterSink sink{out, *pool, config};
-
-  sink.setMode(WriterSink::Mode::Index);
-  // don't add any buffer
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-  ASSERT_EQ(sink.getCacheOffsets().at(0), 0);
-
-  sink.setMode(WriterSink::Mode::Data);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-  ASSERT_EQ(sink.getCacheOffsets().at(1), 0);
-  sink.addBuffer(*pool, data.data() + 1, 128);
-
-  sink.setMode(WriterSink::Mode::Footer);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-  sink.addBuffer(*pool, data.data() + 1, 128);
-  sink.setMode(WriterSink::Mode::None);
-
-  ASSERT_EQ(sink.getCacheOffsets().size(), 3);
-  ASSERT_EQ(sink.getCacheOffsets().at(2), 128);
-  ASSERT_EQ(sink.getCacheSize(), 128);
-}
-
-TEST_F(WriterSinkTests, CacheBoth) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
-  WriterSink sink{out, *pool, config};
-  auto offset = out.size();
-
-  ASSERT_EQ(sink.getCacheMode(), config.get(Config::STRIPE_CACHE_MODE));
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-  ASSERT_EQ(sink.getCacheOffsets().at(0), 0);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-
-  sink.setMode(WriterSink::Mode::Index);
-  sink.addBuffer(*pool, data.data(), 128);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-
-  sink.setMode(WriterSink::Mode::Data);
-  ASSERT_EQ(sink.getCacheSize(), 128);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-  ASSERT_EQ(sink.getCacheOffsets().at(1), sink.getCacheSize());
-  sink.addBuffer(*pool, data.data() + 1, 128);
-
-  sink.setMode(WriterSink::Mode::Footer);
-  ASSERT_EQ(sink.getCacheSize(), 128);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-  sink.addBuffer(*pool, data.data() + 2, 128);
-  ASSERT_EQ(sink.getCacheSize(), 128);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-
-  sink.setMode(WriterSink::Mode::None);
-  ASSERT_EQ(sink.getCacheSize(), 256);
-  ASSERT_EQ(sink.getCacheOffsets().size(), 3);
-  ASSERT_EQ(sink.getCacheOffsets().at(2), sink.getCacheSize());
-
-  ASSERT_EQ(out.size() - offset, 384);
-  sink.writeCache();
-  ASSERT_EQ(out.size() - offset, 640);
-  ASSERT_EQ(
-      std::string(out.data() + offset, 128),
-      std::string(out.data() + offset + 384, 128));
-  ASSERT_EQ(
-      std::string(out.data() + offset + 256, 128),
-      std::string(out.data() + offset + 512, 128));
-}
-
-TEST_F(WriterSinkTests, CacheExceedsLimit) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
-  config.set(Config::STRIPE_CACHE_SIZE, static_cast<uint32_t>(100));
-
-  {
-    WriterSink sink{out, *pool, config};
-    auto offset = out.size();
-
-    sink.setMode(WriterSink::Mode::Index);
-    sink.addBuffer(*pool, data.data(), 10);
-
-    sink.setMode(WriterSink::Mode::Footer);
-    ASSERT_EQ(sink.getCacheSize(), 10);
-    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-    sink.addBuffer(*pool, data.data(), 90);
-
-    sink.setMode(WriterSink::Mode::None);
-    ASSERT_EQ(sink.getCacheSize(), 100);
-    ASSERT_EQ(sink.getCacheOffsets().size(), 3);
-
-    sink.writeCache();
-    ASSERT_EQ(out.size() - offset, 200);
-  }
-
-  out.reset();
-
-  {
-    WriterSink sink{out, *pool, config};
-    auto offset = out.size();
-
-    sink.setMode(WriterSink::Mode::Index);
-    sink.addBuffer(*pool, data.data(), 10);
-
-    sink.setMode(WriterSink::Mode::Footer);
-    ASSERT_EQ(sink.getCacheSize(), 10);
-    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-    sink.addBuffer(*pool, data.data(), 91);
-
-    sink.setMode(WriterSink::Mode::None);
-    ASSERT_EQ(sink.getCacheSize(), 10);
-    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-
-    sink.setMode(WriterSink::Mode::Index);
-    sink.addBuffer(*pool, data.data(), 10);
-
-    sink.setMode(WriterSink::Mode::None);
-    ASSERT_EQ(sink.getCacheSize(), 10);
-    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-
-    sink.writeCache();
-    ASSERT_EQ(out.size() - offset, 121);
-  }
-
-  out.reset();
-  {
-    config.set(Config::STRIPE_CACHE_SIZE, static_cast<uint32_t>(89));
-    WriterSink sink{out, *pool, config};
-    auto offset = out.size();
-
-    sink.setMode(WriterSink::Mode::Index);
-    for (int32_t i = 0; i < 9; i++) {
-      sink.addBuffer(*pool, data.data(), 10);
-      sink.setMode(WriterSink::Mode::Index);
-      ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-    }
-
-    // Cache max size is 89, Total index size is 90 (9 *10).
-    // Since it can't fit in the cache size, it should be discarded.
-    sink.setMode(WriterSink::Mode::None);
-    ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-
-    sink.writeCache();
-    ASSERT_EQ(sink.getCacheMode(), StripeCacheMode::BOTH);
-    // Only data gets written.
-    ASSERT_EQ(out.size() - offset, 90);
-  }
-
-  out.reset();
-  {
-    config.set(Config::STRIPE_CACHE_SIZE, static_cast<uint32_t>(89));
-    WriterSink sink{out, *pool, config};
-    auto offset = out.size();
-
-    sink.setMode(WriterSink::Mode::Index);
-    for (int32_t i = 0; i < 6; i++) {
-      sink.addBuffer(*pool, data.data(), 10);
-      sink.setMode(WriterSink::Mode::Index);
-      ASSERT_EQ(sink.getCacheOffsets().size(), 1);
-    }
-
-    sink.setMode(WriterSink::Mode::Footer);
-    ASSERT_EQ(sink.getCacheOffsets().size(), 2);
-    ASSERT_EQ(sink.getCacheSize(), 60);
-
-    sink.addBuffer(*pool, data.data(), 10);
-    sink.setMode(WriterSink::Mode::None);
-    ASSERT_EQ(sink.getCacheOffsets().size(), 3);
-    ASSERT_EQ(sink.getCacheSize(), 70);
-
-    sink.setMode(WriterSink::Mode::Index);
-    for (int32_t i = 0; i < 6; i++) {
-      sink.addBuffer(*pool, data.data(), 10);
-      sink.setMode(WriterSink::Mode::Index);
-    }
-
-    sink.setMode(WriterSink::Mode::Footer);
-    sink.addBuffer(*pool, data.data(), 10);
-    sink.setMode(WriterSink::Mode::None);
-
-    // Last index and footer size, does not fit in cache size, so all of them
-    // should be discarded.
-    ASSERT_EQ(sink.getCacheOffsets().size(), 3);
-    ASSERT_EQ(sink.getCacheSize(), 70);
-
-    sink.writeCache();
-    ASSERT_EQ(sink.getCacheMode(), StripeCacheMode::BOTH);
-    ASSERT_EQ(out.size() - offset, 210);
-  }
-}
-
-TEST_F(WriterSinkTests, CacheLarge) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{10 * 1024 * 1024 + 3, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
-  WriterSink sink{out, *pool, config};
-  auto offset = out.size();
-
-  DataBuffer<char> buffer{*pool, 2048};
-  std::memset(buffer.data(), 'a', 2048);
-
-  sink.setMode(WriterSink::Mode::Index);
-  auto total = 0;
-  for (size_t i = 0; i < 1024; ++i) {
-    auto size = folly::Random::rand32(buffer.size() - 1) + 1;
-    total += size;
-    sink.addBuffer(*pool, buffer.data(), size);
-  }
-  sink.setMode(WriterSink::Mode::None);
-  ASSERT_THAT(sink.getCacheOffsets(), ElementsAre(0, total));
-  ASSERT_EQ(out.size() - offset, total);
-  sink.writeCache();
-  ASSERT_EQ(out.size() - offset, total * 2);
-}
-
-TEST_F(WriterSinkTests, SetModeOutOfOrder) {
-  auto pool = addDefaultLeafMemoryPool();
-  MemorySink out{1024, {.pool = pool.get()}};
-  Config config;
-  config.set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::CRC32);
-  config.set(Config::STRIPE_CACHE_MODE, StripeCacheMode::BOTH);
-  WriterSink sink{out, *pool, config};
-
-  ASSERT_EQ(sink.getCacheSize(), 0);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 0);
-
-  sink.setMode(WriterSink::Mode::None);
-  sink.addBuffer(*pool, data.data(), 10);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 0);
-
-  sink.setMode(WriterSink::Mode::None);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-
-  sink.setMode(WriterSink::Mode::Index);
-  ASSERT_EQ(sink.getCacheSize(), 0);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 0);
-
-  sink.addBuffer(*pool, data.data(), 10);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 1164760902);
-
-  sink.setMode(WriterSink::Mode::Footer);
-  ASSERT_EQ(sink.getCacheSize(), 10);
-
-  sink.addBuffer(*pool, data.data(), 10);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 936993659);
-
-  sink.setMode(WriterSink::Mode::Data);
-  ASSERT_EQ(sink.getCacheSize(), 20);
-
-  sink.addBuffer(*pool, data.data(), 10);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 1522393763);
-
-  sink.setMode(WriterSink::Mode::Footer);
-  ASSERT_EQ(sink.getCacheSize(), 20);
-
-  sink.addBuffer(*pool, data.data(), 10);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 3650468470);
-
-  sink.setMode(WriterSink::Mode::Index);
-  ASSERT_EQ(sink.getCacheSize(), 30);
-
-  sink.addBuffer(*pool, data.data(), 10);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 977966233);
-
-  sink.setMode(WriterSink::Mode::None);
-  ASSERT_EQ(sink.getCacheSize(), 40);
-
-  sink.addBuffer(*pool, data.data(), 10);
-  ASSERT_EQ(sink.getChecksum()->getDigest(false), 977966233);
-}
diff --git a/velox/dwio/dwrf/test/WriterTest.cpp b/velox/dwio/dwrf/test/WriterTest.cpp
new file mode 100644
index 0000000000000..3a8fee8e6d6b2
--- /dev/null
+++ b/velox/dwio/dwrf/test/WriterTest.cpp
@@ -0,0 +1,476 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <stdexcept>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/dwrf/reader/ReaderBase.h"
+#include "velox/dwio/dwrf/writer/WriterBase.h"
+#include "velox/type/fbhive/HiveTypeParser.h"
+
+using namespace ::testing;
+using namespace facebook::velox::common;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::type::fbhive;
+using namespace facebook::velox::memory;
+
+namespace facebook::velox::dwrf {
+
+class WriterTest : public Test {
+ public:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance({});
+  }
+
+  WriterTest() : pool_(memoryManager()->addLeafPool("WriterTest")) {}
+
+  WriterBase& createWriter(
+      const std::shared_ptr<Config>& config,
+      std::unique_ptr<FileSink> sink = nullptr) {
+    if (!sink) {
+      auto memSink = std::make_unique<MemorySink>(
+          1024, FileSink::Options{.pool = pool_.get()});
+      sinkPtr_ = memSink.get();
+      sink = std::move(memSink);
+    }
+    writer_ = std::make_unique<WriterBase>(std::move(sink));
+    writer_->initContext(
+        config, memory::memoryManager()->addRootPool("WriterTest"));
+    auto& context = writer_->getContext();
+    context.initBuffer();
+    writer_->getSink().init(
+        context.getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM));
+    return *writer_;
+  }
+
+  std::unique_ptr<ReaderBase> createReader() {
+    std::string data(sinkPtr_->data(), sinkPtr_->size());
+    auto readFile = std::make_shared<InMemoryReadFile>(std::move(data));
+    auto input = std::make_unique<BufferedInput>(std::move(readFile), *pool_);
+    return std::make_unique<ReaderBase>(*pool_, std::move(input));
+  }
+
+  auto& getContext() {
+    return writer_->getContext();
+  }
+
+  auto& getFooter() {
+    return writer_->getFooter();
+  }
+
+  auto& addStripeInfo() {
+    return writer_->addStripeInfo();
+  }
+
+  void writeFooter(const Type& type) {
+    writer_->writeFooter(type);
+  }
+
+  void validateStreamSize(uint64_t streamSize) {
+    DwrfStreamIdentifier si{1, 0, 0, proto::Stream_Kind_DATA};
+    writer_->validateStreamSize(si, streamSize);
+  }
+
+  std::shared_ptr<MemoryPool> pool_;
+  MemorySink* sinkPtr_;
+  std::unique_ptr<WriterBase> writer_;
+};
+
+class SupportedCompressionTest
+    : public WriterTest,
+      public testing::WithParamInterface<CompressionKind> {
+ public:
+  SupportedCompressionTest() : supportedCompressionKind_(GetParam()) {}
+
+  static std::vector<CompressionKind> getTestParams() {
+    static std::vector<CompressionKind> params = {
+        CompressionKind::CompressionKind_NONE,
+        CompressionKind::CompressionKind_ZLIB,
+        CompressionKind::CompressionKind_ZSTD};
+    return params;
+  }
+
+ protected:
+  CompressionKind supportedCompressionKind_;
+};
+
+class AllWriterCompressionTest
+    : public WriterTest,
+      public testing::WithParamInterface<CompressionKind> {
+ public:
+  AllWriterCompressionTest() : compressionKind_(GetParam()) {}
+
+  static std::vector<CompressionKind> getTestParams() {
+    static std::vector<CompressionKind> params = {
+        CompressionKind::CompressionKind_NONE,
+        CompressionKind::CompressionKind_ZLIB,
+        CompressionKind::CompressionKind_SNAPPY,
+        CompressionKind::CompressionKind_LZO,
+        CompressionKind::CompressionKind_ZSTD,
+        CompressionKind::CompressionKind_LZ4,
+        CompressionKind::CompressionKind_GZIP,
+        CompressionKind::CompressionKind_MAX};
+    return params;
+  }
+
+ protected:
+  CompressionKind compressionKind_;
+};
+
+TEST_P(AllWriterCompressionTest, compression) {
+  std::map<std::string, std::string> overrideConfigs;
+  overrideConfigs.emplace(
+      Config::COMPRESSION.key, std::to_string(compressionKind_));
+  auto config = Config::fromMap(overrideConfigs);
+  auto& writer = createWriter(config);
+  auto& context = getContext();
+  std::array<char, 10> data;
+  std::memset(data.data(), 'a', 10);
+  auto& writerSink = writer.getSink();
+
+  for (size_t i = 0; i < 3; ++i) {
+    writerSink.setMode(WriterSink::Mode::Index);
+    writerSink.addBuffer(*pool_, data.data(), data.size());
+    writerSink.setMode(WriterSink::Mode::Data);
+    writerSink.addBuffer(*pool_, data.data(), data.size());
+    writerSink.setMode(WriterSink::Mode::Footer);
+    writerSink.addBuffer(*pool_, data.data(), data.size());
+    writerSink.setMode(WriterSink::Mode::None);
+    context.setStripeRowCount(123);
+    context.setStripeRawSize(345);
+    addStripeInfo();
+    context.nextStripe();
+  }
+
+  std::string typeStr{"struct<a:int,b:float,c:string>"};
+  HiveTypeParser parser;
+  auto schema = parser.parse(typeStr);
+
+  for (size_t i = 0; i < 2; ++i) {
+    writer.addUserMetadata(
+        folly::to<std::string>(i), folly::to<std::string>(i + 1));
+  }
+  for (size_t i = 0; i < 4; ++i) {
+    getFooter().add_statistics();
+  }
+
+  if (compressionKind_ == CompressionKind::CompressionKind_SNAPPY ||
+      compressionKind_ == CompressionKind::CompressionKind_LZO ||
+      compressionKind_ == CompressionKind::CompressionKind_LZ4 ||
+      compressionKind_ == CompressionKind::CompressionKind_GZIP ||
+      compressionKind_ == CompressionKind::CompressionKind_MAX) {
+    VELOX_ASSERT_THROW(
+        writeFooter(*schema),
+        fmt::format(
+            "Unsupported compression type: {}",
+            compressionKindToString(compressionKind_)));
+    return;
+  }
+
+  writeFooter(*schema);
+  writer.close();
+
+  // deserialize and verify
+  auto reader = createReader();
+  ASSERT_EQ(
+      reader->compressionKind(),
+      // Verify the compression type is the same as passed-in.
+      // If compression is not passed in (CompressionKind::CompressionKind_MAX),
+      // verify compressionKind the compression type is the same as config.
+      compressionKind_ == CompressionKind::CompressionKind_MAX
+          ? config->get(Config::COMPRESSION)
+          : compressionKind_);
+}
+
+TEST_P(SupportedCompressionTest, WriteFooter) {
+  auto config = std::make_shared<Config>();
+  config->set(Config::COMPRESSION, supportedCompressionKind_);
+  auto& writer = createWriter(config);
+  auto& context = getContext();
+  std::array<char, 10> data;
+  std::memset(data.data(), 'a', 10);
+  auto& writerSink = writer.getSink();
+
+  for (size_t i = 0; i < 3; ++i) {
+    writerSink.setMode(WriterSink::Mode::Index);
+    writerSink.addBuffer(*pool_, data.data(), data.size());
+    writerSink.setMode(WriterSink::Mode::Data);
+    writerSink.addBuffer(*pool_, data.data(), data.size());
+    writerSink.setMode(WriterSink::Mode::Footer);
+    writerSink.addBuffer(*pool_, data.data(), data.size());
+    writerSink.setMode(WriterSink::Mode::None);
+    context.setStripeRowCount(123);
+    context.setStripeRawSize(345);
+    addStripeInfo();
+    context.nextStripe();
+  }
+
+  std::string typeStr{"struct<a:int,b:float,c:string>"};
+  HiveTypeParser parser;
+  auto schema = parser.parse(typeStr);
+
+  for (size_t i = 0; i < 2; ++i) {
+    writer.addUserMetadata(
+        folly::to<std::string>(i), folly::to<std::string>(i + 1));
+  }
+  for (size_t i = 0; i < 4; ++i) {
+    getFooter().add_statistics();
+  }
+  writeFooter(*schema);
+  writer.close();
+
+  // deserialize and verify
+  auto reader = createReader();
+
+  auto& ps = reader->postScript();
+  ASSERT_EQ(reader->writerVersion(), config->get(Config::WRITER_VERSION));
+  ASSERT_EQ(reader->compressionKind(), config->get(Config::COMPRESSION));
+  ASSERT_EQ(
+      reader->compressionBlockSize(),
+      config->get(Config::COMPRESSION_BLOCK_SIZE));
+  ASSERT_EQ(ps.cacheSize(), (10 + 10) * 3);
+  ASSERT_EQ(ps.cacheMode(), config->get(Config::STRIPE_CACHE_MODE));
+
+  auto& footer = reader->footer();
+  ASSERT_TRUE(footer.hasHeaderLength());
+  ASSERT_EQ(footer.headerLength(), ORC_MAGIC_LEN);
+  ASSERT_TRUE(footer.hasContentLength());
+  ASSERT_EQ(footer.contentLength(), (10 + 10 + 10) * 3);
+  ASSERT_EQ(footer.stripesSize(), 3);
+  for (size_t i = 0; i < 3; ++i) {
+    auto stripe = footer.stripes(i);
+    ASSERT_EQ(stripe.rawDataSize(), 345);
+    ASSERT_EQ(stripe.numberOfRows(), 123);
+  }
+  ASSERT_EQ(footer.typesSize(), 4);
+  ASSERT_EQ(footer.metadataSize(), 5);
+  for (size_t i = 0; i < 4; ++i) {
+    auto item = footer.metadata(i);
+    if (item.name() == WRITER_NAME_KEY) {
+      ASSERT_EQ(item.value(), kDwioWriter);
+    } else if (item.name() == WRITER_VERSION_KEY) {
+      ASSERT_EQ(item.value(), folly::to<std::string>(reader->writerVersion()));
+    } else if (item.name() == WRITER_HOSTNAME_KEY) {
+      ASSERT_EQ(item.value(), process::getHostName());
+    } else {
+      ASSERT_EQ(
+          folly::to<size_t>(item.name()) + 1, folly::to<size_t>(item.value()));
+    }
+  }
+  ASSERT_TRUE(footer.hasNumberOfRows());
+  ASSERT_EQ(footer.numberOfRows(), 123 * 3);
+  ASSERT_TRUE(footer.hasRowIndexStride());
+  ASSERT_EQ(footer.rowIndexStride(), config->get(Config::ROW_INDEX_STRIDE));
+  ASSERT_TRUE(footer.hasRawDataSize());
+  ASSERT_EQ(footer.rawDataSize(), 345 * 3);
+  ASSERT_TRUE(footer.hasChecksumAlgorithm());
+  ASSERT_EQ(
+      footer.checksumAlgorithm(), config->get(Config::CHECKSUM_ALGORITHM));
+  ASSERT_THAT(
+      footer.stripeCacheOffsets(), ElementsAre(0, 10, 20, 30, 40, 50, 60));
+  auto& cache = reader->metadataCache();
+  for (size_t i = 0; i < 3; ++i) {
+    ASSERT_TRUE(cache->has(StripeCacheMode::INDEX, i));
+    ASSERT_TRUE(cache->has(StripeCacheMode::FOOTER, i));
+  }
+}
+
+TEST_P(SupportedCompressionTest, AddStripeInfo) {
+  auto config = std::make_shared<Config>();
+  config->set(Config::COMPRESSION, supportedCompressionKind_);
+  auto& writer = createWriter(config);
+  auto& context = getContext();
+
+  context.setStripeRowCount(101);
+  context.setStripeRawSize(202);
+  std::array<char, 512> data;
+  std::memset(data.data(), 'a', data.size());
+  auto& writerSink = writer.getSink();
+  writerSink.setMode(WriterSink::Mode::Data);
+  writerSink.addBuffer(*pool_, data.data(), data.size());
+  writerSink.setMode(WriterSink::Mode::None);
+
+  auto& ret = addStripeInfo();
+  ASSERT_EQ(ret.numberofrows(), 101);
+  ASSERT_EQ(ret.rawdatasize(), 202);
+  ASSERT_EQ(ret.checksum(), 8963334039576633799);
+  writer.close();
+}
+
+TEST_P(SupportedCompressionTest, NoChecksum) {
+  auto config = std::make_shared<Config>();
+  config->set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
+  config->set(Config::COMPRESSION, supportedCompressionKind_);
+  auto& writer = createWriter(config);
+
+  std::array<char, 512> data;
+  std::memset(data.data(), 'a', data.size());
+  auto& writerSink = writer.getSink();
+  writerSink.setMode(WriterSink::Mode::Data);
+  writerSink.addBuffer(*pool_, data.data(), data.size());
+  writerSink.setMode(WriterSink::Mode::None);
+
+  auto& ret = addStripeInfo();
+  ASSERT_FALSE(ret.has_checksum());
+
+  std::string typeStr{"struct<a:int,b:float,c:string>"};
+  HiveTypeParser parser;
+  auto schema = parser.parse(typeStr);
+  for (size_t i = 0; i < 4; ++i) {
+    getFooter().add_statistics();
+  }
+  writeFooter(*schema);
+  writer.close();
+
+  // deserialize and verify
+  auto reader = createReader();
+  auto& footer = reader->footer();
+  ASSERT_TRUE(footer.hasChecksumAlgorithm());
+  ASSERT_EQ(footer.checksumAlgorithm(), proto::ChecksumAlgorithm::NULL_);
+}
+
+TEST_P(SupportedCompressionTest, NoCache) {
+  auto config = std::make_shared<Config>();
+  config->set(Config::STRIPE_CACHE_MODE, StripeCacheMode::NA);
+  config->set(Config::COMPRESSION, supportedCompressionKind_);
+  auto& writer = createWriter(config);
+
+  std::array<char, 512> data;
+  std::memset(data.data(), 'a', data.size());
+  auto& writerSink = writer.getSink();
+  writerSink.setMode(WriterSink::Mode::Index);
+  writerSink.addBuffer(*pool_, data.data(), 10);
+  writerSink.setMode(WriterSink::Mode::Data);
+  writerSink.addBuffer(*pool_, data.data(), 10);
+  writerSink.setMode(WriterSink::Mode::Footer);
+  writerSink.addBuffer(*pool_, data.data(), 10);
+  writerSink.setMode(WriterSink::Mode::None);
+
+  addStripeInfo();
+
+  std::string typeStr{"struct<a:int,b:float,c:string>"};
+  HiveTypeParser parser;
+  auto schema = parser.parse(typeStr);
+  for (size_t i = 0; i < 4; ++i) {
+    getFooter().add_statistics();
+  }
+  writeFooter(*schema);
+  writer.close();
+
+  // deserialize and verify
+  auto reader = createReader();
+  auto& footer = reader->footer();
+  ASSERT_EQ(footer.stripeCacheOffsetsSize(), 0);
+  auto& ps = reader->postScript();
+  ASSERT_EQ(ps.cacheMode(), StripeCacheMode::NA);
+  ASSERT_EQ(ps.cacheSize(), 0);
+  ASSERT_EQ(reader->metadataCache(), nullptr);
+}
+
+TEST_P(SupportedCompressionTest, ValidateStreamSizeConfigDisabled) {
+  auto config = std::make_shared<Config>();
+  config->set(Config::STREAM_SIZE_ABOVE_THRESHOLD_CHECK_ENABLED, false);
+  config->set(Config::COMPRESSION, supportedCompressionKind_);
+  auto& writer = createWriter(config);
+  validateStreamSize(std::numeric_limits<uint64_t>::max());
+  validateStreamSize(std::numeric_limits<uint32_t>::max());
+  writer.close();
+}
+
+TEST_P(SupportedCompressionTest, ValidateStreamSizeConfigEnabled) {
+  auto config = std::make_shared<Config>();
+  ASSERT_TRUE(config->get(Config::STREAM_SIZE_ABOVE_THRESHOLD_CHECK_ENABLED));
+  config->set(Config::COMPRESSION, supportedCompressionKind_);
+  auto& writer = createWriter(config);
+  validateStreamSize(std::numeric_limits<int32_t>::max());
+
+  uint32_t int32Max = std::numeric_limits<int32_t>::max();
+  EXPECT_THROW(validateStreamSize(int32Max + 1), exception::LoggedException);
+
+  EXPECT_THROW(
+      validateStreamSize(std::numeric_limits<uint64_t>::max()),
+      exception::LoggedException);
+
+  EXPECT_THROW(
+      validateStreamSize(std::numeric_limits<uint32_t>::max()),
+      exception::LoggedException);
+  writer.close();
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    AllWriterCompressionTestSuite,
+    AllWriterCompressionTest,
+    testing::ValuesIn(AllWriterCompressionTest::getTestParams()));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    SupportedCompressionTestSuite,
+    SupportedCompressionTest,
+    testing::ValuesIn(SupportedCompressionTest::getTestParams()));
+
+class FailingSink : public FileSink {
+ public:
+  FailingSink()
+      : FileSink{
+            "FailingSink",
+            FileSink::Options{.metricLogger = MetricsLog::voidLog()}} {}
+
+  virtual ~FailingSink() override {}
+
+  void write(std::vector<DataBuffer<char>>&) override {
+    DWIO_RAISE("Unexpected call");
+  }
+};
+
+void abandonWriterWithoutClosing() {
+  WriterBase writer{std::make_unique<FailingSink>()};
+
+  auto guard = folly::makeGuard([&] { writer.abort(); });
+  throw std::runtime_error("Some error");
+  // If not for error, guard should be dismissed like this
+  // guard.dismiss();
+}
+
+TEST_F(WriterTest, DoNotCrashDbgModeOnAbort) {
+  EXPECT_THROW(abandonWriterWithoutClosing(), std::runtime_error);
+}
+
+class MockFileSink : public dwio::common::FileSink {
+ public:
+  explicit MockFileSink()
+      : FileSink("mock_data_sink", {.metricLogger = nullptr}) {}
+  virtual ~MockFileSink() = default;
+
+  MOCK_METHOD(uint64_t, size, (), (const override));
+  MOCK_METHOD(bool, isBuffered, (), (const override));
+  MOCK_METHOD(void, write, (std::vector<DataBuffer<char>>&));
+};
+
+TEST_F(WriterTest, FlushWriterSinkUponClose) {
+  auto config = std::make_shared<Config>();
+  auto pool = memory::memoryManager()->addRootPool("FlushWriterSinkUponClose");
+  auto sink = std::make_unique<MockFileSink>();
+  MockFileSink* sinkPtr = sink.get();
+  EXPECT_CALL(*sinkPtr, write(_)).Times(1);
+  EXPECT_CALL(*sinkPtr, isBuffered()).WillOnce(Return(false));
+  {
+    auto writer = std::make_unique<WriterBase>(std::move(sink));
+    writer->initContext(config, pool->addAggregateChild("test_writer_pool"));
+    writer->close();
+  }
+}
+
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/WriterTests.cpp b/velox/dwio/dwrf/test/WriterTests.cpp
deleted file mode 100644
index 16d3360d7e74b..0000000000000
--- a/velox/dwio/dwrf/test/WriterTests.cpp
+++ /dev/null
@@ -1,471 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <stdexcept>
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/dwio/dwrf/reader/ReaderBase.h"
-#include "velox/dwio/dwrf/writer/WriterBase.h"
-#include "velox/type/fbhive/HiveTypeParser.h"
-
-using namespace ::testing;
-using namespace facebook::velox::common;
-using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::type::fbhive;
-using namespace facebook::velox::memory;
-
-namespace facebook::velox::dwrf {
-
-class WriterTest : public Test {
- public:
-  WriterTest() : pool_(addDefaultLeafMemoryPool("WriterTest")) {}
-
-  WriterBase& createWriter(
-      const std::shared_ptr<Config>& config,
-      std::unique_ptr<FileSink> sink = nullptr) {
-    if (!sink) {
-      auto memSink = std::make_unique<MemorySink>(
-          1024, FileSink::Options{.pool = pool_.get()});
-      sinkPtr_ = memSink.get();
-      sink = std::move(memSink);
-    }
-    writer_ = std::make_unique<WriterBase>(std::move(sink));
-    writer_->initContext(
-        config, defaultMemoryManager().addRootPool("WriterTest"));
-    return *writer_;
-  }
-
-  std::unique_ptr<ReaderBase> createReader() {
-    std::string_view data(sinkPtr_->data(), sinkPtr_->size());
-    auto readFile = std::make_shared<InMemoryReadFile>(data);
-    auto input = std::make_unique<BufferedInput>(std::move(readFile), *pool_);
-    return std::make_unique<ReaderBase>(*pool_, std::move(input));
-  }
-
-  auto& getContext() {
-    return writer_->getContext();
-  }
-
-  auto& getFooter() {
-    return writer_->getFooter();
-  }
-
-  auto& addStripeInfo() {
-    return writer_->addStripeInfo();
-  }
-
-  void writeFooter(const Type& type) {
-    writer_->writeFooter(type);
-  }
-
-  void validateStreamSize(uint64_t streamSize) {
-    DwrfStreamIdentifier si{1, 0, 0, proto::Stream_Kind_DATA};
-    writer_->validateStreamSize(si, streamSize);
-  }
-
-  std::shared_ptr<MemoryPool> pool_;
-  MemorySink* sinkPtr_;
-  std::unique_ptr<WriterBase> writer_;
-};
-
-class SupportedCompressionTest
-    : public WriterTest,
-      public testing::WithParamInterface<CompressionKind> {
- public:
-  SupportedCompressionTest() : supportedCompressionKind_(GetParam()) {}
-
-  static std::vector<CompressionKind> getTestParams() {
-    static std::vector<CompressionKind> params = {
-        CompressionKind::CompressionKind_NONE,
-        CompressionKind::CompressionKind_ZLIB,
-        CompressionKind::CompressionKind_ZSTD};
-    return params;
-  }
-
- protected:
-  CompressionKind supportedCompressionKind_;
-};
-
-class AllWriterCompressionTest
-    : public WriterTest,
-      public testing::WithParamInterface<CompressionKind> {
- public:
-  AllWriterCompressionTest() : compressionKind_(GetParam()) {}
-
-  static std::vector<CompressionKind> getTestParams() {
-    static std::vector<CompressionKind> params = {
-        CompressionKind::CompressionKind_NONE,
-        CompressionKind::CompressionKind_ZLIB,
-        CompressionKind::CompressionKind_SNAPPY,
-        CompressionKind::CompressionKind_LZO,
-        CompressionKind::CompressionKind_ZSTD,
-        CompressionKind::CompressionKind_LZ4,
-        CompressionKind::CompressionKind_GZIP,
-        CompressionKind::CompressionKind_MAX};
-    return params;
-  }
-
- protected:
-  CompressionKind compressionKind_;
-};
-
-TEST_P(AllWriterCompressionTest, compression) {
-  std::map<std::string, std::string> overrideConfigs;
-  overrideConfigs.emplace(
-      Config::COMPRESSION.configKey(), std::to_string(compressionKind_));
-  auto config = Config::fromMap(overrideConfigs);
-  auto& writer = createWriter(config);
-  auto& context = getContext();
-  std::array<char, 10> data;
-  std::memset(data.data(), 'a', 10);
-  auto& writerSink = writer.getSink();
-
-  for (size_t i = 0; i < 3; ++i) {
-    writerSink.setMode(WriterSink::Mode::Index);
-    writerSink.addBuffer(*pool_, data.data(), data.size());
-    writerSink.setMode(WriterSink::Mode::Data);
-    writerSink.addBuffer(*pool_, data.data(), data.size());
-    writerSink.setMode(WriterSink::Mode::Footer);
-    writerSink.addBuffer(*pool_, data.data(), data.size());
-    writerSink.setMode(WriterSink::Mode::None);
-    context.setStripeRowCount(123);
-    context.setStripeRawSize(345);
-    addStripeInfo();
-    context.nextStripe();
-  }
-
-  std::string typeStr{"struct<a:int,b:float,c:string>"};
-  HiveTypeParser parser;
-  auto schema = parser.parse(typeStr);
-
-  for (size_t i = 0; i < 2; ++i) {
-    writer.addUserMetadata(
-        folly::to<std::string>(i), folly::to<std::string>(i + 1));
-  }
-  for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
-  }
-
-  if (compressionKind_ == CompressionKind::CompressionKind_SNAPPY ||
-      compressionKind_ == CompressionKind::CompressionKind_LZO ||
-      compressionKind_ == CompressionKind::CompressionKind_LZ4 ||
-      compressionKind_ == CompressionKind::CompressionKind_GZIP ||
-      compressionKind_ == CompressionKind::CompressionKind_MAX) {
-    VELOX_ASSERT_THROW(
-        writeFooter(*schema),
-        fmt::format(
-            "Unsupported compression type: {}",
-            compressionKindToString(compressionKind_)));
-    return;
-  }
-
-  writeFooter(*schema);
-  writer.close();
-
-  // deserialize and verify
-  auto reader = createReader();
-
-  auto& ps = reader->getPostScript();
-  ASSERT_EQ(
-      reader->getCompressionKind(),
-      // Verify the compression type is the same as passed-in.
-      // If compression is not passed in (CompressionKind::CompressionKind_MAX),
-      // verify compressionKind the compression type is the same as config.
-      compressionKind_ == CompressionKind::CompressionKind_MAX
-          ? config->get(Config::COMPRESSION)
-          : compressionKind_);
-}
-
-TEST_P(SupportedCompressionTest, WriteFooter) {
-  auto config = std::make_shared<Config>();
-  config->set(Config::COMPRESSION, supportedCompressionKind_);
-  auto& writer = createWriter(config);
-  auto& context = getContext();
-  std::array<char, 10> data;
-  std::memset(data.data(), 'a', 10);
-  auto& writerSink = writer.getSink();
-
-  for (size_t i = 0; i < 3; ++i) {
-    writerSink.setMode(WriterSink::Mode::Index);
-    writerSink.addBuffer(*pool_, data.data(), data.size());
-    writerSink.setMode(WriterSink::Mode::Data);
-    writerSink.addBuffer(*pool_, data.data(), data.size());
-    writerSink.setMode(WriterSink::Mode::Footer);
-    writerSink.addBuffer(*pool_, data.data(), data.size());
-    writerSink.setMode(WriterSink::Mode::None);
-    context.setStripeRowCount(123);
-    context.setStripeRawSize(345);
-    addStripeInfo();
-    context.nextStripe();
-  }
-
-  std::string typeStr{"struct<a:int,b:float,c:string>"};
-  HiveTypeParser parser;
-  auto schema = parser.parse(typeStr);
-
-  for (size_t i = 0; i < 2; ++i) {
-    writer.addUserMetadata(
-        folly::to<std::string>(i), folly::to<std::string>(i + 1));
-  }
-  for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
-  }
-  writeFooter(*schema);
-  writer.close();
-
-  // deserialize and verify
-  auto reader = createReader();
-
-  auto& ps = reader->getPostScript();
-  ASSERT_EQ(reader->getWriterVersion(), config->get(Config::WRITER_VERSION));
-  ASSERT_EQ(reader->getCompressionKind(), config->get(Config::COMPRESSION));
-  ASSERT_EQ(
-      reader->getCompressionBlockSize(),
-      config->get(Config::COMPRESSION_BLOCK_SIZE));
-  ASSERT_EQ(ps.cacheSize(), (10 + 10) * 3);
-  ASSERT_EQ(ps.cacheMode(), config->get(Config::STRIPE_CACHE_MODE));
-
-  auto& footer = reader->getFooter();
-  ASSERT_TRUE(footer.hasHeaderLength());
-  ASSERT_EQ(footer.headerLength(), ORC_MAGIC_LEN);
-  ASSERT_TRUE(footer.hasContentLength());
-  ASSERT_EQ(footer.contentLength(), (10 + 10 + 10) * 3);
-  ASSERT_EQ(footer.stripesSize(), 3);
-  for (size_t i = 0; i < 3; ++i) {
-    auto stripe = footer.stripes(i);
-    ASSERT_EQ(stripe.rawDataSize(), 345);
-    ASSERT_EQ(stripe.numberOfRows(), 123);
-  }
-  ASSERT_EQ(footer.typesSize(), 4);
-  ASSERT_EQ(footer.metadataSize(), 5);
-  for (size_t i = 0; i < 4; ++i) {
-    auto item = footer.metadata(i);
-    if (item.name() == WRITER_NAME_KEY) {
-      ASSERT_EQ(item.value(), kDwioWriter);
-    } else if (item.name() == WRITER_VERSION_KEY) {
-      ASSERT_EQ(
-          item.value(), folly::to<std::string>(reader->getWriterVersion()));
-    } else if (item.name() == WRITER_HOSTNAME_KEY) {
-      ASSERT_EQ(item.value(), process::getHostName());
-    } else {
-      ASSERT_EQ(
-          folly::to<size_t>(item.name()) + 1, folly::to<size_t>(item.value()));
-    }
-  }
-  ASSERT_TRUE(footer.hasNumberOfRows());
-  ASSERT_EQ(footer.numberOfRows(), 123 * 3);
-  ASSERT_TRUE(footer.hasRowIndexStride());
-  ASSERT_EQ(footer.rowIndexStride(), config->get(Config::ROW_INDEX_STRIDE));
-  ASSERT_TRUE(footer.hasRawDataSize());
-  ASSERT_EQ(footer.rawDataSize(), 345 * 3);
-  ASSERT_TRUE(footer.hasChecksumAlgorithm());
-  ASSERT_EQ(
-      footer.checksumAlgorithm(), config->get(Config::CHECKSUM_ALGORITHM));
-  ASSERT_THAT(
-      footer.stripeCacheOffsets(), ElementsAre(0, 10, 20, 30, 40, 50, 60));
-  auto& cache = reader->getMetadataCache();
-  for (size_t i = 0; i < 3; ++i) {
-    ASSERT_TRUE(cache->has(StripeCacheMode::INDEX, i));
-    ASSERT_TRUE(cache->has(StripeCacheMode::FOOTER, i));
-  }
-}
-
-TEST_P(SupportedCompressionTest, AddStripeInfo) {
-  auto config = std::make_shared<Config>();
-  config->set(Config::COMPRESSION, supportedCompressionKind_);
-  auto& writer = createWriter(config);
-  auto& context = getContext();
-
-  context.setStripeRowCount(101);
-  context.setStripeRawSize(202);
-  std::array<char, 512> data;
-  std::memset(data.data(), 'a', data.size());
-  auto& writerSink = writer.getSink();
-  writerSink.setMode(WriterSink::Mode::Data);
-  writerSink.addBuffer(*pool_, data.data(), data.size());
-  writerSink.setMode(WriterSink::Mode::None);
-
-  auto& ret = addStripeInfo();
-  ASSERT_EQ(ret.numberofrows(), 101);
-  ASSERT_EQ(ret.rawdatasize(), 202);
-  ASSERT_EQ(ret.checksum(), 8963334039576633799);
-  writer.close();
-}
-
-TEST_P(SupportedCompressionTest, NoChecksum) {
-  auto config = std::make_shared<Config>();
-  config->set(Config::CHECKSUM_ALGORITHM, proto::ChecksumAlgorithm::NULL_);
-  config->set(Config::COMPRESSION, supportedCompressionKind_);
-  auto& writer = createWriter(config);
-
-  std::array<char, 512> data;
-  std::memset(data.data(), 'a', data.size());
-  auto& writerSink = writer.getSink();
-  writerSink.setMode(WriterSink::Mode::Data);
-  writerSink.addBuffer(*pool_, data.data(), data.size());
-  writerSink.setMode(WriterSink::Mode::None);
-
-  auto& ret = addStripeInfo();
-  ASSERT_FALSE(ret.has_checksum());
-
-  std::string typeStr{"struct<a:int,b:float,c:string>"};
-  HiveTypeParser parser;
-  auto schema = parser.parse(typeStr);
-  for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
-  }
-  writeFooter(*schema);
-  writer.close();
-
-  // deserialize and verify
-  auto reader = createReader();
-  auto& footer = reader->getFooter();
-  ASSERT_TRUE(footer.hasChecksumAlgorithm());
-  ASSERT_EQ(footer.checksumAlgorithm(), proto::ChecksumAlgorithm::NULL_);
-}
-
-TEST_P(SupportedCompressionTest, NoCache) {
-  auto config = std::make_shared<Config>();
-  config->set(Config::STRIPE_CACHE_MODE, StripeCacheMode::NA);
-  config->set(Config::COMPRESSION, supportedCompressionKind_);
-  auto& writer = createWriter(config);
-
-  std::array<char, 512> data;
-  std::memset(data.data(), 'a', data.size());
-  auto& writerSink = writer.getSink();
-  writerSink.setMode(WriterSink::Mode::Index);
-  writerSink.addBuffer(*pool_, data.data(), 10);
-  writerSink.setMode(WriterSink::Mode::Data);
-  writerSink.addBuffer(*pool_, data.data(), 10);
-  writerSink.setMode(WriterSink::Mode::Footer);
-  writerSink.addBuffer(*pool_, data.data(), 10);
-  writerSink.setMode(WriterSink::Mode::None);
-
-  addStripeInfo();
-
-  std::string typeStr{"struct<a:int,b:float,c:string>"};
-  HiveTypeParser parser;
-  auto schema = parser.parse(typeStr);
-  for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
-  }
-  writeFooter(*schema);
-  writer.close();
-
-  // deserialize and verify
-  auto reader = createReader();
-  auto& footer = reader->getFooter();
-  ASSERT_EQ(footer.stripeCacheOffsetsSize(), 0);
-  auto& ps = reader->getPostScript();
-  ASSERT_EQ(ps.cacheMode(), StripeCacheMode::NA);
-  ASSERT_EQ(ps.cacheSize(), 0);
-  ASSERT_EQ(reader->getMetadataCache(), nullptr);
-}
-
-TEST_P(SupportedCompressionTest, ValidateStreamSizeConfigDisabled) {
-  auto config = std::make_shared<Config>();
-  config->set(Config::STREAM_SIZE_ABOVE_THRESHOLD_CHECK_ENABLED, false);
-  config->set(Config::COMPRESSION, supportedCompressionKind_);
-  auto& writer = createWriter(config);
-  validateStreamSize(std::numeric_limits<uint64_t>::max());
-  validateStreamSize(std::numeric_limits<uint32_t>::max());
-  writer.close();
-}
-
-TEST_P(SupportedCompressionTest, ValidateStreamSizeConfigEnabled) {
-  auto config = std::make_shared<Config>();
-  ASSERT_TRUE(config->get(Config::STREAM_SIZE_ABOVE_THRESHOLD_CHECK_ENABLED));
-  config->set(Config::COMPRESSION, supportedCompressionKind_);
-  auto& writer = createWriter(config);
-  validateStreamSize(std::numeric_limits<int32_t>::max());
-
-  uint32_t int32Max = std::numeric_limits<int32_t>::max();
-  EXPECT_THROW(validateStreamSize(int32Max + 1), exception::LoggedException);
-
-  EXPECT_THROW(
-      validateStreamSize(std::numeric_limits<uint64_t>::max()),
-      exception::LoggedException);
-
-  EXPECT_THROW(
-      validateStreamSize(std::numeric_limits<uint32_t>::max()),
-      exception::LoggedException);
-  writer.close();
-}
-
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    AllWriterCompressionTestSuite,
-    AllWriterCompressionTest,
-    testing::ValuesIn(AllWriterCompressionTest::getTestParams()));
-
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    SupportedCompressionTestSuite,
-    SupportedCompressionTest,
-    testing::ValuesIn(SupportedCompressionTest::getTestParams()));
-
-class FailingSink : public FileSink {
- public:
-  FailingSink()
-      : FileSink{
-            "FailingSink",
-            FileSink::Options{.metricLogger = MetricsLog::voidLog()}} {}
-
-  virtual ~FailingSink() override {}
-
-  void write(std::vector<DataBuffer<char>>&) override {
-    DWIO_RAISE("Unexpected call");
-  }
-};
-
-void abandonWriterWithoutClosing() {
-  WriterBase writer{std::make_unique<FailingSink>()};
-
-  auto guard = folly::makeGuard([&] { writer.abort(); });
-  throw std::runtime_error("Some error");
-  // If not for error, guard should be dismissed like this
-  // guard.dismiss();
-}
-
-TEST_F(WriterTest, DoNotCrashDbgModeOnAbort) {
-  EXPECT_THROW(abandonWriterWithoutClosing(), std::runtime_error);
-}
-
-class MockFileSink : public dwio::common::FileSink {
- public:
-  explicit MockFileSink()
-      : FileSink("mock_data_sink", {.metricLogger = nullptr}) {}
-  virtual ~MockFileSink() = default;
-
-  MOCK_METHOD(uint64_t, size, (), (const override));
-  MOCK_METHOD(bool, isBuffered, (), (const override));
-  MOCK_METHOD(void, write, (std::vector<DataBuffer<char>>&));
-};
-
-TEST(WriterBaseTest, FlushWriterSinkUponClose) {
-  auto config = std::make_shared<Config>();
-  auto pool = defaultMemoryManager().addRootPool("FlushWriterSinkUponClose");
-  auto sink = std::make_unique<MockFileSink>();
-  MockFileSink* sinkPtr = sink.get();
-  EXPECT_CALL(*sinkPtr, write(_)).Times(1);
-  EXPECT_CALL(*sinkPtr, isBuffered()).WillOnce(Return(false));
-  {
-    auto writer = std::make_unique<WriterBase>(std::move(sink));
-    writer->initContext(config, pool->addAggregateChild("test_writer_pool"));
-    writer->close();
-  }
-}
-
-} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/utils/CMakeLists.txt b/velox/dwio/dwrf/test/utils/CMakeLists.txt
index 70c82b67cb46a..8badcedc8db39 100644
--- a/velox/dwio/dwrf/test/utils/CMakeLists.txt
+++ b/velox/dwio/dwrf/test/utils/CMakeLists.txt
@@ -25,8 +25,8 @@ target_link_libraries(
   velox_memory
   velox_type
   velox_vector
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
 
 # older versions of GCC need it to allow std::filesystem
 if(CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9)
diff --git a/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.cpp b/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.cpp
index 53484691ddcec..1504cd1f6185d 100644
--- a/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.cpp
+++ b/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.cpp
@@ -29,10 +29,9 @@ using namespace facebook::velox::memory;
 
 namespace facebook::velox::dwrf {
 
-/* static */ std::unique_ptr<Writer> E2EWriterTestUtil::writeData(
+/* static */ std::unique_ptr<Writer> E2EWriterTestUtil::createWriter(
     std::unique_ptr<FileSink> sink,
     const std::shared_ptr<const Type>& type,
-    const std::vector<VectorPtr>& batches,
     const std::shared_ptr<Config>& config,
     std::function<std::unique_ptr<DWRFFlushPolicy>()> flushPolicyFactory,
     std::function<std::unique_ptr<LayoutPlanner>(const TypeWithId&)>
@@ -46,19 +45,42 @@ namespace facebook::velox::dwrf {
   options.flushPolicyFactory = flushPolicyFactory;
   options.layoutPlannerFactory = layoutPlannerFactory;
 
-  auto writer = std::make_unique<dwrf::Writer>(
-      std::move(sink),
-      options,
-      velox::memory::defaultMemoryManager().addRootPool());
+  return std::make_unique<dwrf::Writer>(
+      std::move(sink), options, velox::memory::memoryManager()->addRootPool());
+}
 
+/* static */ std::unique_ptr<Writer> E2EWriterTestUtil::writeData(
+    std::unique_ptr<Writer> writer,
+    const std::vector<VectorPtr>& batches) {
   for (size_t i = 0; i < batches.size(); ++i) {
     writer->write(batches[i]);
   }
 
   writer->close();
+  LOG(INFO) << "writer root pool usage: "
+            << writer->getContext().testingGetWriterMemoryStats();
   return writer;
 }
 
+/* static */ std::unique_ptr<Writer> E2EWriterTestUtil::writeData(
+    std::unique_ptr<FileSink> sink,
+    const std::shared_ptr<const Type>& type,
+    const std::vector<VectorPtr>& batches,
+    const std::shared_ptr<Config>& config,
+    std::function<std::unique_ptr<DWRFFlushPolicy>()> flushPolicyFactory,
+    std::function<std::unique_ptr<LayoutPlanner>(const TypeWithId&)>
+        layoutPlannerFactory,
+    const int64_t writerMemoryCap) {
+  auto writer = createWriter(
+      std::move(sink),
+      type,
+      config,
+      std::move(flushPolicyFactory),
+      std::move(layoutPlannerFactory),
+      writerMemoryCap);
+  return writeData(std::move(writer), batches);
+}
+
 /* static */ void E2EWriterTestUtil::testWriter(
     MemoryPool& pool,
     const std::shared_ptr<const Type>& type,
@@ -89,7 +111,7 @@ namespace facebook::velox::dwrf {
       writerMemoryCap);
   // read it back and compare
   auto readFile = std::make_shared<InMemoryReadFile>(
-      std::string_view(sinkPtr->data(), sinkPtr->size()));
+      std::string(sinkPtr->data(), sinkPtr->size()));
   auto input = std::make_unique<BufferedInput>(readFile, pool);
 
   dwio::common::ReaderOptions readerOpts{&pool};
@@ -97,13 +119,32 @@ namespace facebook::velox::dwrf {
   auto reader = std::make_unique<DwrfReader>(readerOpts, std::move(input));
   EXPECT_GE(numStripesUpper, reader->getNumberOfStripes());
   EXPECT_LE(numStripesLower, reader->getNumberOfStripes());
-  if (!verifyContent) {
-    return;
-  }
 
   auto rowReader = reader->createRowReader(rowReaderOpts);
   auto dwrfRowReader = dynamic_cast<DwrfRowReader*>(rowReader.get());
 
+  size_t dictEncodingCount = 0;
+  size_t totalEncodingCount = 0;
+  for (size_t i = 0; i < reader->getNumberOfStripes(); ++i) {
+    bool preload{false};
+    auto stripeMetadata = dwrfRowReader->fetchStripe(i, preload);
+    const auto& stripeFooter = *stripeMetadata->footer;
+    totalEncodingCount += stripeFooter.encoding_size();
+    for (const auto& encoding : stripeFooter.encoding()) {
+      if (encoding.kind() == proto::ColumnEncoding_Kind_DICTIONARY) {
+        ++dictEncodingCount;
+      }
+    }
+  }
+  LOG(INFO) << fmt::format(
+      "dict encoding distribution: {}/{}",
+      dictEncodingCount,
+      totalEncodingCount);
+
+  if (!verifyContent) {
+    return;
+  }
+
   auto batchIndex = 0;
   auto rowIndex = 0;
   VectorPtr batch;
diff --git a/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h b/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h
index 26083e7389546..5eb2a9faa0b60 100644
--- a/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h
+++ b/velox/dwio/dwrf/test/utils/E2EWriterTestUtil.h
@@ -24,11 +24,45 @@ namespace facebook::velox::dwrf {
 class E2EWriterTestUtil {
  public:
   /**
-   * Writes data and returns the writer so that the caller can control
+   * Creates and returns the writer so that the caller can control
    * its life cycle. The writer is constructed with the supplied parameters.
    *    sink                    the container for writer output, could be
    *                            in-memory or on-disk.
    *    type                    schema of the output data
+   *    config                  ORC configs
+   *    flushPolicyFactory      supplies the policy writer use to determine
+   *                            when to flush the current stripe and start a
+   *                            new one
+   *    layoutPlannerFactory    supplies the layout planner and determine how
+   *                            order of the data streams prior to flush
+   *    writerMemoryCap         total memory budget for the writer
+   */
+  static std::unique_ptr<Writer> createWriter(
+      std::unique_ptr<dwio::common::FileSink> sink,
+      const std::shared_ptr<const Type>& type,
+      const std::shared_ptr<Config>& config,
+      std::function<std::unique_ptr<DWRFFlushPolicy>()> flushPolicyFactory =
+          nullptr,
+      std::function<std::unique_ptr<LayoutPlanner>(
+          const dwio::common::TypeWithId&)> layoutPlannerFactory = nullptr,
+      const int64_t writerMemoryCap = std::numeric_limits<int64_t>::max());
+
+  /**
+   * Writes data and returns the same writer so that the caller can control
+   * its life cycle. Parameters:
+   *    writer                  the writer to write data into
+   *    batches                 generated data
+   */
+  static std::unique_ptr<Writer> writeData(
+      std::unique_ptr<Writer> writer,
+      const std::vector<VectorPtr>& batches);
+
+  /*
+   * Combines createWriter and writeData.
+   * The writer is constructed with the supplied parameters.
+   *    sink                    the container for writer output, could be
+   *                            in-memory or on-disk.
+   *    type                    schema of the output data
    *    batches                 generated data
    *    config                  ORC configs
    *    flushPolicyFactory      supplies the policy writer use to determine
diff --git a/velox/dwio/dwrf/utils/BufferedWriter.h b/velox/dwio/dwrf/utils/BufferedWriter.h
index e336e460b9757..4dd035ae161c2 100644
--- a/velox/dwio/dwrf/utils/BufferedWriter.h
+++ b/velox/dwio/dwrf/utils/BufferedWriter.h
@@ -83,6 +83,14 @@ class BufferedWriter {
     flush();
   }
 
+  /// Invoked to abort this buffered write on error. It closes the buffered
+  /// writer without flushing pending buffers.
+  void abort() {
+    VELOX_CHECK(!closed_);
+    pos_ = 0;
+    closed_ = true;
+  }
+
   std::string toString() const {
     return fmt::format(
         "BufferedWriter[pos[{}] capacity[{}] closed[{}]]",
diff --git a/velox/dwio/dwrf/utils/CMakeLists.txt b/velox/dwio/dwrf/utils/CMakeLists.txt
index 0f9f472cd7e63..c05206e7d1b7a 100644
--- a/velox/dwio/dwrf/utils/CMakeLists.txt
+++ b/velox/dwio/dwrf/utils/CMakeLists.txt
@@ -16,9 +16,11 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(test)
 endif()
 
-add_library(velox_dwio_dwrf_utils ProtoUtils.cpp BitIterator.h)
+velox_add_library(velox_dwio_dwrf_utils ProtoUtils.cpp BitIterator.h)
 
-add_dependencies(velox_dwio_dwrf_utils velox_dwio_dwrf_proto)
+if(NOT VELOX_MONO_LIBRARY)
+  add_dependencies(velox_dwio_dwrf_utils velox_dwio_dwrf_proto)
+endif()
 
-target_link_libraries(velox_dwio_dwrf_utils velox_dwio_dwrf_proto velox_type
-                      velox_memory)
+velox_link_libraries(velox_dwio_dwrf_utils velox_dwio_dwrf_proto velox_type
+                     velox_memory)
diff --git a/velox/dwio/dwrf/utils/test/BufferedWriterTest.cpp b/velox/dwio/dwrf/utils/test/BufferedWriterTest.cpp
index 685a2e910383c..c9d469af86652 100644
--- a/velox/dwio/dwrf/utils/test/BufferedWriterTest.cpp
+++ b/velox/dwio/dwrf/utils/test/BufferedWriterTest.cpp
@@ -30,10 +30,13 @@ class BufferedWriterTest : public testing::TestWithParam<bool> {
  protected:
   BufferedWriterTest()
       : usePool_(GetParam()),
-        pool_(memory::addDefaultLeafMemoryPool("BufferedWriterTest")) {}
+        pool_(memory::memoryManager()->addLeafPool("BufferedWriterTest")) {}
 
   void SetUp() override {}
-  static void SetUpTestCase() {}
+
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
 
   // Indicates test with buffered writer interface which takes memory pool or
   // not.
@@ -218,16 +221,47 @@ TEST_P(BufferedWriterTest, closeTest) {
     writer = std::make_unique<BufferedWriter<char, WriteFn>>(
         *pool_, bufferSize, writeFn);
   } else {
-    writer = std::make_unique<BufferedWriter<char, WriteFn>>(
-        *pool_, bufferSize, writeFn);
+    writer = std::make_unique<BufferedWriter<char, WriteFn>>(*buffer, writeFn);
   }
   writer->add('a');
   ASSERT_EQ(
       writer->toString(),
       "BufferedWriter[pos[1] capacity[1024] closed[false]]");
   writer->close();
+  ASSERT_EQ(flushCount, 1);
   // Verify all the calls on a closed object throw.
   VELOX_ASSERT_THROW(writer->close(), "");
+  VELOX_ASSERT_THROW(writer->abort(), "");
+  VELOX_ASSERT_THROW(writer->add('a'), "");
+  VELOX_ASSERT_THROW(writer->flush(), "");
+}
+
+TEST_P(BufferedWriterTest, abortTest) {
+  const int bufferSize = 1024;
+  std::unique_ptr<dwio::common::DataBuffer<char>> buffer;
+  if (!usePool_) {
+    buffer =
+        std::make_unique<dwio::common::DataBuffer<char>>(*pool_, bufferSize);
+  }
+  size_t flushCount{0};
+  auto writeFn = [&](char* buf, size_t size) { flushCount += size; };
+  std::unique_ptr<BufferedWriter<char, WriteFn>> writer;
+  if (usePool_) {
+    writer = std::make_unique<BufferedWriter<char, WriteFn>>(
+        *pool_, bufferSize, writeFn);
+  } else {
+    writer = std::make_unique<BufferedWriter<char, WriteFn>>(*buffer, writeFn);
+  }
+  writer->add('a');
+  ASSERT_EQ(
+      writer->toString(),
+      "BufferedWriter[pos[1] capacity[1024] closed[false]]");
+  writer->abort();
+  // Verify nothing has been flushed on abort.
+  ASSERT_EQ(flushCount, 0);
+  // Verify all the calls on an abort object throw.
+  VELOX_ASSERT_THROW(writer->close(), "");
+  VELOX_ASSERT_THROW(writer->abort(), "");
   VELOX_ASSERT_THROW(writer->add('a'), "");
   VELOX_ASSERT_THROW(writer->flush(), "");
 }
diff --git a/velox/dwio/dwrf/utils/test/CMakeLists.txt b/velox/dwio/dwrf/utils/test/CMakeLists.txt
index 99b99b05d3edb..ee25ebbf9bb10 100644
--- a/velox/dwio/dwrf/utils/test/CMakeLists.txt
+++ b/velox/dwio/dwrf/utils/test/CMakeLists.txt
@@ -24,6 +24,6 @@ target_link_libraries(
   velox_dwio_common_exception
   velox_type_fbhive
   gflags::gflags
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   glog::glog)
diff --git a/velox/dwio/dwrf/writer/CMakeLists.txt b/velox/dwio/dwrf/writer/CMakeLists.txt
index 52c1546f0f687..72726d3e79cde 100644
--- a/velox/dwio/dwrf/writer/CMakeLists.txt
+++ b/velox/dwio/dwrf/writer/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(
   velox_dwio_dwrf_writer
   ColumnWriter.cpp
   FlatMapColumnWriter.cpp
@@ -26,11 +26,12 @@ add_library(
   WriterContext.cpp
   WriterSink.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_dwio_dwrf_writer
   velox_dwio_common
   velox_dwio_dwrf_common
   velox_dwio_dwrf_utils
+  velox_exec
   velox_process
   velox_time
   velox_vector
diff --git a/velox/dwio/dwrf/writer/ColumnWriter.cpp b/velox/dwio/dwrf/writer/ColumnWriter.cpp
index ef15605ec893b..425f9b5df289c 100644
--- a/velox/dwio/dwrf/writer/ColumnWriter.cpp
+++ b/velox/dwio/dwrf/writer/ColumnWriter.cpp
@@ -205,7 +205,9 @@ class IntegerColumnWriter : public BaseColumnWriter {
                 context.shareFlatMapDictionaries() ? 0 : sequence},
             getMemoryPool(MemoryUsageCategory::DICTIONARY),
             getMemoryPool(MemoryUsageCategory::GENERAL))},
-        rows_{getMemoryPool(MemoryUsageCategory::GENERAL)},
+        rows_{
+            getMemoryPool(MemoryUsageCategory::GENERAL),
+            /*initialCapacity=*/16},
         dictionaryKeySizeThreshold_{
             getConfig(Config::DICTIONARY_NUMERIC_KEY_SIZE_THRESHOLD)},
         sort_{getConfig(Config::DICTIONARY_SORT_KEYS)},
@@ -445,6 +447,11 @@ class IntegerColumnWriter : public BaseColumnWriter {
     }
   }
 
+  bool useDictionaryEncoding() const override {
+    return getConfig(Config::INTEGER_DICTIONARY_ENCODING_ENABLED) &&
+        BaseColumnWriter::useDictionaryEncoding();
+  }
+
   void populateDictionaryEncodingStreams();
   void convertToDirectEncoding();
 
@@ -795,7 +802,9 @@ class StringColumnWriter : public BaseColumnWriter {
         dictEncoder_{
             getMemoryPool(MemoryUsageCategory::DICTIONARY),
             getMemoryPool(MemoryUsageCategory::GENERAL)},
-        rows_{getMemoryPool(MemoryUsageCategory::GENERAL)},
+        rows_{
+            getMemoryPool(MemoryUsageCategory::GENERAL),
+            /*initialCapacity=*/16},
         encodingSelector_{
             getMemoryPool(MemoryUsageCategory::GENERAL),
             getConfig(Config::DICTIONARY_STRING_KEY_SIZE_THRESHOLD),
@@ -951,14 +960,6 @@ class StringColumnWriter : public BaseColumnWriter {
     return true;
   }
 
- protected:
-  bool useDictionaryEncoding() const override {
-    return (sequence_ == 0 ||
-            !context_.getConfig(
-                Config::MAP_FLAT_DISABLE_DICT_ENCODING_STRING)) &&
-        !context_.isLowMemoryMode();
-  }
-
  private:
   uint64_t writeDict(
       DecodedVector& decodedVector,
@@ -1054,6 +1055,13 @@ class StringColumnWriter : public BaseColumnWriter {
     }
   }
 
+  bool useDictionaryEncoding() const override {
+    return getConfig(Config::STRING_DICTIONARY_ENCODING_ENABLED) &&
+        (sequence_ == 0 ||
+         !getConfig(Config::MAP_FLAT_DISABLE_DICT_ENCODING_STRING)) &&
+        !context_.isLowMemoryMode();
+  }
+
   void populateDictionaryEncodingStreams();
   void convertToDirectEncoding();
 
@@ -1245,20 +1253,22 @@ void StringColumnWriter::populateDictionaryEncodingStreams() {
                 [&](auto buf, auto size) {
                   inDictionary_->add(buf, common::Ranges::of(0, size), nullptr);
                 });
-
+            auto errorGuard =
+                folly::makeGuard([&inDictWriter]() { inDictWriter.abort(); });
             uint32_t strideDictSize = 0;
             for (size_t i = start; i != end; ++i) {
               auto origIndex = rows_[i];
               bool valInDict = inDict[origIndex];
               inDictWriter.add(valInDict ? 1 : 0);
-              // TODO: optimize this branching either through restoring visitor
-              // pattern, or through separating the index backfill.
+              // TODO: optimize this branching either through restoring
+              // visitor pattern, or through separating the index backfill.
               if (!valInDict) {
                 auto strideDictIndex = lookupTable[origIndex];
                 sortedStrideDictKeyIndexBuffer[strideDictIndex] = origIndex;
                 ++strideDictSize;
               }
             }
+            errorGuard.dismiss();
             inDictWriter.close();
             VELOX_CHECK_EQ(strideDictSize, strideDictKeyCount);
           }
@@ -1273,12 +1283,16 @@ void StringColumnWriter::populateDictionaryEncodingStreams() {
                   strideDictionaryDataLength_->add(
                       buf, common::Ranges::of(0, size), nullptr);
                 });
+            auto errorGuard = folly::makeGuard(
+                [&strideLengthWriter]() { strideLengthWriter.abort(); });
 
             for (size_t i = 0; i < strideDictKeyCount; ++i) {
               auto val = dictEncoder_.getKey(sortedStrideDictKeyIndexBuffer[i]);
               strideDictionaryData_->write(val.data(), val.size());
               strideLengthWriter.add(val.size());
             }
+
+            errorGuard.dismiss();
             strideLengthWriter.close();
           }
         }
@@ -1318,12 +1332,16 @@ void StringColumnWriter::convertToDirectEncoding() {
             [&](auto buf, auto size) {
               dataDirectLength_->add(buf, common::Ranges::of(0, size), nullptr);
             });
+        auto errorGuard =
+            folly::makeGuard([&lengthWriter]() { lengthWriter.abort(); });
 
         for (size_t i = start; i != end; ++i) {
           auto key = dictEncoder_.getKey(rows_[i]);
           dataDirect_->write(key.data(), key.size());
           lengthWriter.add(key.size());
         }
+
+        errorGuard.dismiss();
         lengthWriter.close();
       };
 
@@ -1389,13 +1407,13 @@ uint64_t FloatColumnWriter<T>::write(
           [&](auto buf, auto size) {
             data_.write(reinterpret_cast<const char*>(buf), size * sizeof(T));
           });
+      auto errorGuard = folly::makeGuard([&writer]() { writer.abort(); });
 
       auto processRow = [&](size_t pos) {
         auto val = data[pos];
         writer.add(val);
         statsBuilder.addValues(val);
       };
-
       for (auto& pos : ranges) {
         if (bits::isBitNull(nulls, pos)) {
           ++nullCount;
@@ -1403,6 +1421,8 @@ uint64_t FloatColumnWriter<T>::write(
           processRow(pos);
         }
       }
+
+      errorGuard.dismiss();
       writer.close();
     } else {
       for (auto& pos : ranges) {
@@ -1426,12 +1446,13 @@ uint64_t FloatColumnWriter<T>::write(
         [&](auto buf, auto size) {
           data_.write(reinterpret_cast<const char*>(buf), size * sizeof(T));
         });
+    auto errorGuard = folly::makeGuard([&writer]() { writer.abort(); });
+
     auto processRow = [&](size_t pos) {
       auto val = decodedVector.template valueAt<T>(pos);
       writer.add(val);
       statsBuilder.addValues(val);
     };
-
     if (decodedVector.mayHaveNulls()) {
       for (auto& pos : ranges) {
         if (decodedVector.isNullAt(pos)) {
@@ -1445,6 +1466,8 @@ uint64_t FloatColumnWriter<T>::write(
         processRow(pos);
       }
     }
+
+    errorGuard.dismiss();
     writer.close();
   }
 
diff --git a/velox/dwio/dwrf/writer/ColumnWriter.h b/velox/dwio/dwrf/writer/ColumnWriter.h
index 60ca160a8e784..b404893d65151 100644
--- a/velox/dwio/dwrf/writer/ColumnWriter.h
+++ b/velox/dwio/dwrf/writer/ColumnWriter.h
@@ -268,7 +268,9 @@ class BaseColumnWriter : public ColumnWriter {
   // in_map stream
   const std::function<void(IndexBuilder&)> onRecordPosition_;
 
-  VELOX_FRIEND_TEST(ColumnWriterTests, LowMemoryModeConfig);
+  VELOX_FRIEND_TEST(ColumnWriterTest, LowMemoryModeConfig);
+  VELOX_FRIEND_TEST(ColumnWriterTest, IntegerDictionaryEncodingEnabledConfig);
+  VELOX_FRIEND_TEST(ColumnWriterTest, StringDictionaryEncodingEnabledConfig);
   friend class ValueStatisticsBuilder;
   friend class ValueWriter;
 };
diff --git a/velox/dwio/dwrf/writer/DictionaryEncodingUtils.h b/velox/dwio/dwrf/writer/DictionaryEncodingUtils.h
index 70ecd3a9aa7ca..5068597b84159 100644
--- a/velox/dwio/dwrf/writer/DictionaryEncodingUtils.h
+++ b/velox/dwio/dwrf/writer/DictionaryEncodingUtils.h
@@ -80,6 +80,8 @@ class DictionaryEncodingUtils {
     uint32_t newIndex = 0;
     auto dictLengthWriter =
         createBufferedWriter<uint32_t>(pool, 64 * 1024, lengthFn);
+    auto errorGuard =
+        folly::makeGuard([&dictLengthWriter]() { dictLengthWriter.abort(); });
     for (uint32_t i = 0; i != numKeys; ++i) {
       auto origIndex = (sort ? sortedIndex[i] : i);
       if (!dropInfrequentKeys || shouldWriteKey(dictEncoder, origIndex)) {
@@ -94,6 +96,7 @@ class DictionaryEncodingUtils {
         inDict[origIndex] = false;
       }
     }
+    errorGuard.dismiss();
     dictLengthWriter.close();
 
     return newIndex;
diff --git a/velox/dwio/dwrf/writer/FlatMapColumnWriter.h b/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
index 6d265fb032c55..6e50a0e435ac8 100644
--- a/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
+++ b/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
@@ -120,7 +120,13 @@ class ValueWriter {
 
   void addOffset(uint64_t offset, uint64_t inMapIndex) {
     if (UNLIKELY(inMapBuffer_[inMapIndex])) {
-      DWIO_RAISE("Duplicate key in map");
+      std::string duplicatedKey = "<unknown>";
+      if (keyInfo_.has_byteskey()) {
+        duplicatedKey = keyInfo_.byteskey();
+      } else if (keyInfo_.has_intkey()) {
+        duplicatedKey = std::to_string(keyInfo_.intkey());
+      }
+      DWIO_RAISE("Duplicated key in map: ", duplicatedKey);
     }
 
     ranges_.add(offset, offset + 1);
diff --git a/velox/dwio/dwrf/writer/FlushPolicy.cpp b/velox/dwio/dwrf/writer/FlushPolicy.cpp
index 576055ec9bde5..0236929654b6a 100644
--- a/velox/dwio/dwrf/writer/FlushPolicy.cpp
+++ b/velox/dwio/dwrf/writer/FlushPolicy.cpp
@@ -16,31 +16,55 @@
 
 #include "velox/dwio/dwrf/writer/FlushPolicy.h"
 
+namespace {
+static constexpr size_t kNumDictioanryTestsPerStripe = 3UL;
+} // namespace
+
 namespace facebook::velox::dwrf {
 
 DefaultFlushPolicy::DefaultFlushPolicy(
     uint64_t stripeSizeThreshold,
     uint64_t dictionarySizeThreshold)
     : stripeSizeThreshold_{stripeSizeThreshold},
-      dictionarySizeThreshold_{dictionarySizeThreshold} {}
+      dictionarySizeThreshold_{dictionarySizeThreshold},
+      dictionaryAssessmentThreshold_{getDictionaryAssessmentIncrement()} {}
+
+uint64_t DefaultFlushPolicy::getDictionaryAssessmentIncrement() const {
+  return stripeSizeThreshold_ / kNumDictioanryTestsPerStripe;
+}
 
 FlushDecision DefaultFlushPolicy::shouldFlushDictionary(
-    bool stripeProgressDecision,
+    bool flushStripe,
     bool overMemoryBudget,
+    const dwio::common::StripeProgress& stripeProgress,
     int64_t dictionaryMemoryUsage) {
+  if (flushStripe) {
+    return FlushDecision::SKIP;
+  }
+
   if (dictionaryMemoryUsage > dictionarySizeThreshold_) {
     return FlushDecision::FLUSH_DICTIONARY;
   }
+  if (stripeProgress.stripeSizeEstimate >= dictionaryAssessmentThreshold_) {
+    // In the current implementation, since we don't ever change encoding
+    // decision after the first stripe, we don't need to ever reset this
+    // threshold.
+    dictionaryAssessmentThreshold_ +=
+        stripeSizeThreshold_ / kNumDictioanryTestsPerStripe;
+    return FlushDecision::EVALUATE_DICTIONARY;
+  }
   return FlushDecision::SKIP;
 }
 
 FlushDecision DefaultFlushPolicy::shouldFlushDictionary(
-    bool stripeProgressDecision,
+    bool flushStripe,
     bool overMemoryBudget,
+    const dwio::common::StripeProgress& stripeProgress,
     const WriterContext& context) {
   return shouldFlushDictionary(
-      stripeProgressDecision,
+      flushStripe,
       overMemoryBudget,
+      stripeProgress,
       context.getMemoryUsage(MemoryUsageCategory::DICTIONARY));
 }
 
@@ -81,5 +105,4 @@ bool RowsPerStripeFlushPolicy::shouldFlush(
 
   return stripeRowCount == rowsPerStripe_.at(stripeIndex);
 }
-
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/writer/FlushPolicy.h b/velox/dwio/dwrf/writer/FlushPolicy.h
index 0a6fb117a7e04..1e60f5a0dc530 100644
--- a/velox/dwio/dwrf/writer/FlushPolicy.h
+++ b/velox/dwio/dwrf/writer/FlushPolicy.h
@@ -23,6 +23,7 @@
 namespace facebook::velox::dwrf {
 enum class FlushDecision {
   SKIP,
+  EVALUATE_DICTIONARY,
   FLUSH_DICTIONARY,
   ABANDON_DICTIONARY,
 };
@@ -36,10 +37,11 @@ class DWRFFlushPolicy : virtual public dwio::common::FlushPolicy {
 
   /// Checks additional flush criteria based on dictionary encoding.
   /// Different actions can also be taken based on the additional checks.
-  /// e.g. abandon dictionary encodings.
+  /// e.g. abandon or evaluate dictionary encodings.
   virtual FlushDecision shouldFlushDictionary(
-      bool stripeProgressDecision,
+      bool flushStripe,
       bool overMemoryBudget,
+      const dwio::common::StripeProgress& stripeProgress,
       const WriterContext& context) = 0;
 
   /// This method needs to be safe to call *after* WriterBase::close().
@@ -60,20 +62,25 @@ class DefaultFlushPolicy : public DWRFFlushPolicy {
   }
 
   FlushDecision shouldFlushDictionary(
-      bool stripeProgressDecision,
+      bool flushStripe,
       bool overMemoryBudget,
+      const dwio::common::StripeProgress& stripeProgress,
       int64_t dictionaryMemoryUsage);
 
   FlushDecision shouldFlushDictionary(
-      bool stripeProgressDecision,
+      bool flushStripe,
       bool overMemoryBudget,
+      const dwio::common::StripeProgress& stripeProgress,
       const WriterContext& context) override;
 
   void onClose() override {}
 
  private:
+  uint64_t getDictionaryAssessmentIncrement() const;
+
   const uint64_t stripeSizeThreshold_;
   const uint64_t dictionarySizeThreshold_;
+  uint64_t dictionaryAssessmentThreshold_;
 };
 
 class RowsPerStripeFlushPolicy : public DWRFFlushPolicy {
@@ -85,8 +92,9 @@ class RowsPerStripeFlushPolicy : public DWRFFlushPolicy {
   bool shouldFlush(const dwio::common::StripeProgress& stripeProgress) override;
 
   FlushDecision shouldFlushDictionary(
-      bool /* stripeProgressDecision */,
+      bool /* flushStripe */,
       bool /* overMemoryBudget */,
+      const dwio::common::StripeProgress& /* stripeProgress */,
       const WriterContext& /* context */) override {
     return FlushDecision::SKIP;
   }
@@ -110,8 +118,9 @@ class RowThresholdFlushPolicy : public DWRFFlushPolicy {
   }
 
   FlushDecision shouldFlushDictionary(
-      bool /* stripeProgressDecision */,
+      bool /* flushStripe */,
       bool /* overMemoryBudget */,
+      const dwio::common::StripeProgress& /* stripeProgress */,
       const WriterContext& /* context */) override {
     return FlushDecision::SKIP;
   }
@@ -133,8 +142,9 @@ class LambdaFlushPolicy : public DWRFFlushPolicy {
   }
 
   FlushDecision shouldFlushDictionary(
-      bool /* unused */,
-      bool /* unused */,
+      bool /* flushStripe */,
+      bool /* overMemoryBudget */,
+      const dwio::common::StripeProgress& /* stripeProgress */,
       const WriterContext& /* unused */) override {
     return FlushDecision::SKIP;
   }
diff --git a/velox/dwio/dwrf/writer/IntegerDictionaryEncoder.h b/velox/dwio/dwrf/writer/IntegerDictionaryEncoder.h
index 82592ea38eda7..3ce91eb82070f 100644
--- a/velox/dwio/dwrf/writer/IntegerDictionaryEncoder.h
+++ b/velox/dwio/dwrf/writer/IntegerDictionaryEncoder.h
@@ -207,6 +207,7 @@ class IntegerDictionaryEncoder : public AbstractIntegerDictionaryEncoder {
     uint32_t newIndex = 0;
 
     auto dictWriter = createBufferedWriter<Integer>(writeBuffer, fn);
+    auto errorGuard = folly::makeGuard([&dictWriter]() { dictWriter.abort(); });
     for (uint32_t i = 0; i != numKeys; ++i) {
       auto origIndex = (sort ? sortedIndex[i] : i);
       if (!dropInfrequentKeys || shouldWriteKey(dictEncoder, origIndex)) {
@@ -218,6 +219,7 @@ class IntegerDictionaryEncoder : public AbstractIntegerDictionaryEncoder {
         inDict[origIndex] = false;
       }
     }
+    errorGuard.dismiss();
     dictWriter.close();
     return newIndex;
   }
@@ -277,7 +279,7 @@ class IntegerDictionaryEncoder : public AbstractIntegerDictionaryEncoder {
  private:
   VELOX_FRIEND_TEST(TestIntegerDictionaryEncoder, Clear);
   VELOX_FRIEND_TEST(TestIntegerDictionaryEncoder, GetCount);
-  VELOX_FRIEND_TEST(TestWriterContext, GetIntDictionaryEncoder);
+  VELOX_FRIEND_TEST(WriterContextTest, GetIntDictionaryEncoder);
 
   // TODO: partially specialize for integers only.
   template <typename T>
diff --git a/velox/dwio/dwrf/writer/RatioTracker.h b/velox/dwio/dwrf/writer/RatioTracker.h
index 2152396843a70..38c50ccadafae 100644
--- a/velox/dwio/dwrf/writer/RatioTracker.h
+++ b/velox/dwio/dwrf/writer/RatioTracker.h
@@ -19,7 +19,7 @@
 #include <glob.h>
 
 constexpr float kCompressionRatioInitialGuess = 0.3f;
-constexpr float kFlushOverheadRatioInitialGuess = 1.0f;
+constexpr float kFlushOverheadRatioInitialGuess = 0.1f;
 // TODO(T79660637): make write cost estimate more granular.
 constexpr float kAverageRowSizeInitialGuess = 0.0f;
 
diff --git a/velox/dwio/dwrf/writer/StatisticsBuilder.cpp b/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
index bf9e690f59def..3940e29f17b11 100644
--- a/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
+++ b/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
@@ -115,7 +115,8 @@ std::unique_ptr<dwio::common::ColumnStatistics> StatisticsBuilder::build()
   proto::ColumnStatistics stats;
   toProto(stats);
   StatsContext context{WriterVersion_CURRENT};
-  return buildColumnStatisticsFromProto(stats, context);
+  return buildColumnStatisticsFromProto(
+      ColumnStatisticsWrapper(&stats), context);
 }
 
 std::unique_ptr<StatisticsBuilder> StatisticsBuilder::create(
diff --git a/velox/dwio/dwrf/writer/Writer.cpp b/velox/dwio/dwrf/writer/Writer.cpp
index 39722d7fa61bb..ab92dc52d11a6 100644
--- a/velox/dwio/dwrf/writer/Writer.cpp
+++ b/velox/dwio/dwrf/writer/Writer.cpp
@@ -18,41 +18,44 @@
 
 #include <folly/ScopeGuard.h>
 
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/Pointers.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/common/time/CpuWallTimer.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/utils/ProtoUtils.h"
 #include "velox/dwio/dwrf/writer/FlushPolicy.h"
 #include "velox/dwio/dwrf/writer/LayoutPlanner.h"
+#include "velox/exec/MemoryReclaimer.h"
+
+using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::dwrf {
 
 namespace {
-// We currently use previous stripe raw size as the proxy for the expected
-// stripe raw size. For the first stripe, we are more conservative about
-// flush overhead memory unless we know otherwise, e.g. perhaps from
-// encoding DB work.
-// This can be fitted linearly just like flush overhead or perhaps
-// figured out from the schema.
-// This can be simplified with Slice::estimateMemory().
-size_t estimateNextWriteSize(const WriterContext& context, size_t numRows) {
-  // This is 0 for first slice. We are assuming reasonable input for now.
-  return folly::to<size_t>(ceil(context.getAverageRowSize() * numRows));
-}
 
 dwio::common::StripeProgress getStripeProgress(const WriterContext& context) {
   return dwio::common::StripeProgress{
       .stripeIndex = context.stripeIndex(),
       .stripeRowCount = context.stripeRowCount(),
       .totalMemoryUsage = context.getTotalMemoryUsage(),
-      .stripeSizeEstimate = std::max(
-          context.getEstimatedStripeSize(context.stripeRawSize()),
-          // The stripe size estimate is only more accurate from the second
-          // stripe onward because it uses past stripe states in heuristics.
-          // We need to additionally bound it with output stream size based
-          // estimate for the first stripe.
-          context.stripeIndex() == 0 ? context.getEstimatedOutputStreamSize()
-                                     : 0)};
+      .stripeSizeEstimate = context.linearStripeSizeHeuristics()
+          ? std::max(
+                context.getEstimatedStripeSize(context.stripeRawSize()),
+                // The stripe size estimate is only more accurate from the
+                // second stripe onward because it uses past stripe states in
+                // heuristics. We need to additionally bound it with output
+                // stream size based estimate for the first stripe.
+                context.stripeIndex() == 0
+                    ? context.getEstimatedOutputStreamSize()
+                    : 0)
+          : context.getEstimatedOutputStreamSize()};
 }
+
+#define NON_RECLAIMABLE_SECTION_CHECK() \
+  VELOX_CHECK(nonReclaimableSection_ == nullptr || *nonReclaimableSection_);
 } // namespace
 
 Writer::Writer(
@@ -60,33 +63,35 @@ Writer::Writer(
     const WriterOptions& options,
     std::shared_ptr<memory::MemoryPool> pool)
     : writerBase_(std::make_unique<WriterBase>(std::move(sink))),
-      schema_{dwio::common::TypeWithId::create(options.schema)} {
+      schema_{dwio::common::TypeWithId::create(options.schema)},
+      spillConfig_{options.spillConfig},
+      nonReclaimableSection_(options.nonReclaimableSection) {
   VELOX_CHECK(
-      !pool->isLeaf(),
-      "Memory pool {} for DWRF writer can't be leaf",
-      pool->name());
-  if (options.setMemoryReclaimer != nullptr) {
-    options.setMemoryReclaimer(pool.get());
-  }
+      spillConfig_ == nullptr || nonReclaimableSection_ != nullptr,
+      "nonReclaimableSection_ must be set if writer memory reclaim is enabled");
   auto handler =
       (options.encryptionSpec ? encryption::EncryptionHandler::create(
                                     schema_,
                                     *options.encryptionSpec,
                                     options.encrypterFactory.get())
                               : nullptr);
-  writerBase_->initContext(
-      options.config,
-      std::move(pool),
-      options.setMemoryReclaimer,
-      std::move(handler));
+  writerBase_->initContext(options.config, pool, std::move(handler));
+
   auto& context = writerBase_->getContext();
+  VELOX_CHECK_EQ(
+      context.getTotalMemoryUsage(),
+      0,
+      "Unexpected memory usage on dwrf writer construction");
+  setMemoryReclaimers(pool);
+  writerBase_->initBuffers();
+
   context.buildPhysicalSizeAggregators(*schema_);
   if (options.flushPolicyFactory == nullptr) {
     flushPolicy_ = std::make_unique<DefaultFlushPolicy>(
         context.stripeSizeFlushThreshold(),
         context.dictionarySizeFlushThreshold());
   } else {
-    flushPolicy_ = options.flushPolicyFactory();
+    castUniquePointer(options.flushPolicyFactory(), flushPolicy_);
   }
 
   if (options.layoutPlannerFactory != nullptr) {
@@ -100,6 +105,7 @@ Writer::Writer(
   } else {
     writer_ = options.columnWriterFactory(writerBase_->getContext(), *schema_);
   }
+  setState(State::kRunning);
 }
 
 Writer::Writer(
@@ -109,10 +115,36 @@ Writer::Writer(
           std::move(sink),
           options,
           options.memoryPool->addAggregateChild(fmt::format(
-              "writer_node_{}",
+              "{}.dwrf.{}",
+              options.memoryPool->name(),
               folly::to<std::string>(folly::Random::rand64())))} {}
 
+void Writer::setMemoryReclaimers(
+    const std::shared_ptr<memory::MemoryPool>& pool) {
+  VELOX_CHECK(
+      !pool->isLeaf(),
+      "The root memory pool for dwrf writer can't be leaf: {}",
+      pool->name());
+  VELOX_CHECK_NULL(pool->reclaimer());
+
+  if ((pool->parent() == nullptr) || (pool->parent()->reclaimer() == nullptr)) {
+    return;
+  }
+
+  pool->setReclaimer(MemoryReclaimer::create(this));
+  auto& context = getContext();
+  context.getMemoryPool(MemoryUsageCategory::GENERAL)
+      .setReclaimer(exec::MemoryReclaimer::create());
+  context.getMemoryPool(MemoryUsageCategory::DICTIONARY)
+      .setReclaimer(exec::MemoryReclaimer::create());
+  context.getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM)
+      .setReclaimer(exec::MemoryReclaimer::create());
+}
+
 void Writer::write(const VectorPtr& input) {
+  checkRunning();
+  NON_RECLAIMABLE_SECTION_CHECK();
+
   auto& context = writerBase_->getContext();
   // Calculate length increment based on linear projection of micro batch size.
   // Total length is capped later.
@@ -135,6 +167,7 @@ void Writer::write(const VectorPtr& input) {
         estimatedInputMemoryBytes,
         context.rawDataSizePerBatch());
   }
+
   size_t rowOffset = 0;
   while (rowOffset < inputRowCount) {
     size_t numRowsToWrite = writeBatchSize;
@@ -146,11 +179,21 @@ void Writer::write(const VectorPtr& input) {
 
     numRowsToWrite = std::min(numRowsToWrite, inputRowCount - rowOffset);
     VELOX_CHECK_GT(numRowsToWrite, 0);
+
+    ensureWriteFits(
+        estimatedInputMemoryBytes * numRowsToWrite / inputRowCount,
+        numRowsToWrite);
+
+    TestValue::adjust("facebook::velox::dwrf::Writer::write", this);
+
     bool doFlush = shouldFlush(context, numRowsToWrite);
     if (doFlush) {
-      // Try abandoning inefficiency dictionary encodings early and see if we
-      // can delay the flush.
-      if (writer_->tryAbandonDictionaries(false)) {
+      // TODO: this is likely not needed after the early dictionary tests.
+      // Should make the decision based on arbitration stats. Then we can
+      // potential simplify a lot of logic around trimming. Try abandoning
+      // inefficiency dictionary encodings early and see if we can delay the
+      // flush.
+      if (writer_->tryAbandonDictionaries(/*force=*/false)) {
         doFlush = shouldFlush(context, numRowsToWrite);
       }
       if (doFlush) {
@@ -170,6 +213,107 @@ void Writer::write(const VectorPtr& input) {
   }
 }
 
+bool Writer::canReclaim() const {
+  return spillConfig_ != nullptr;
+}
+
+void Writer::ensureWriteFits(size_t appendBytes, size_t appendRows) {
+  if (!canReclaim()) {
+    return;
+  }
+
+  auto& context = getContext();
+  const uint64_t totalMemoryUsage = context.getTotalMemoryUsage();
+  if (totalMemoryUsage == 0) {
+    return;
+  }
+
+  // Allows the memory arbitrator to reclaim memory from this file writer if the
+  // memory reservation below has triggered memory arbitration.
+  memory::ReclaimableSectionGuard reclaimGuard(nonReclaimableSection_);
+
+  const size_t estimatedAppendMemoryBytes =
+      std::max(appendBytes, context.estimateNextWriteSize(appendRows));
+  const double estimatedMemoryGrowthRatio =
+      (double)estimatedAppendMemoryBytes / totalMemoryUsage;
+  if (!maybeReserveMemory(
+          MemoryUsageCategory::GENERAL, estimatedMemoryGrowthRatio)) {
+    return;
+  }
+  if (!maybeReserveMemory(
+          MemoryUsageCategory::DICTIONARY, estimatedMemoryGrowthRatio)) {
+    return;
+  }
+  if (!maybeReserveMemory(
+          MemoryUsageCategory::OUTPUT_STREAM, estimatedMemoryGrowthRatio)) {
+    return;
+  }
+}
+
+void Writer::ensureStripeFlushFits() {
+  if (!canReclaim()) {
+    return;
+  }
+  if (memory::underMemoryArbitration()) {
+    // NOTE: we skip memory reservation if the stripe flush is triggered by
+    // memory arbitration.
+    return;
+  }
+
+  // Allows the memory arbitrator to reclaim memory from this file writer if the
+  // memory reservation below has triggered memory arbitration.
+  memory::ReclaimableSectionGuard reclaimGuard(nonReclaimableSection_);
+
+  auto& context = getContext();
+  const size_t estimateFlushMemoryBytes =
+      context.getEstimatedFlushOverhead(context.stripeRawSize());
+  const uint64_t outputMemoryUsage =
+      context.getMemoryUsage(MemoryUsageCategory::OUTPUT_STREAM);
+  if (outputMemoryUsage == 0) {
+    const uint64_t outputMemoryToReserve = estimateFlushMemoryBytes +
+        estimateFlushMemoryBytes * spillConfig_->spillableReservationGrowthPct /
+            100;
+    context.getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM)
+        .maybeReserve(outputMemoryToReserve);
+  } else {
+    const double estimatedMemoryGrowthRatio =
+        (double)estimateFlushMemoryBytes / outputMemoryUsage;
+    maybeReserveMemory(
+        MemoryUsageCategory::OUTPUT_STREAM, estimatedMemoryGrowthRatio);
+  }
+}
+
+bool Writer::maybeReserveMemory(
+    MemoryUsageCategory memoryUsageCategory,
+    double estimatedMemoryGrowthRatio) {
+  VELOX_CHECK(!*nonReclaimableSection_);
+  VELOX_CHECK(canReclaim());
+  auto& context = getContext();
+  auto& pool = context.getMemoryPool(memoryUsageCategory);
+  const uint64_t availableReservation = pool.availableReservation();
+  const uint64_t usedBytes = pool.usedBytes();
+  const uint64_t minReservationBytes =
+      usedBytes * spillConfig_->minSpillableReservationPct / 100;
+  const uint64_t estimatedIncrementBytes =
+      usedBytes * estimatedMemoryGrowthRatio;
+  if ((availableReservation > minReservationBytes) &&
+      (availableReservation > 2 * estimatedIncrementBytes)) {
+    return true;
+  }
+
+  const uint64_t bytesToReserve = std::max(
+      estimatedIncrementBytes * 2,
+      usedBytes * spillConfig_->spillableReservationGrowthPct / 100);
+  return pool.maybeReserve(bytesToReserve);
+}
+
+int64_t Writer::releaseMemory() {
+  if (!canReclaim()) {
+    return 0;
+  }
+  return getContext().releaseMemoryReservation();
+}
+
 uint64_t Writer::flushTimeMemoryUsageEstimate(
     const WriterContext& context,
     size_t nextWriteSize) const {
@@ -183,7 +327,7 @@ bool Writer::overMemoryBudget(const WriterContext& context, size_t numRows)
     const {
   // Flush if we cannot take one additional slice/stride based on current stripe
   // raw size.
-  const size_t nextWriteSize = estimateNextWriteSize(context, numRows);
+  const size_t nextWriteSize = context.estimateNextWriteSize(numRows);
   return flushTimeMemoryUsageEstimate(context, nextWriteSize) >
       context.getMemoryBudget();
 }
@@ -197,10 +341,10 @@ bool Writer::shouldFlush(const WriterContext& context, size_t nextWriteRows) {
   // If we are hitting memory budget before satisfying flush criteria, try
   // entering low memory mode to work with less memory-intensive encodings.
   bool overBudget = overMemoryBudget(context, nextWriteRows);
-  bool stripeProgressDecision =
-      flushPolicy_->shouldFlush(getStripeProgress(context));
-  auto dictionaryFlushDecision = flushPolicy_->shouldFlushDictionary(
-      stripeProgressDecision, overBudget, context);
+  const auto stripeProgress = getStripeProgress(context);
+  bool stripeProgressDecision = flushPolicy_->shouldFlush(stripeProgress);
+  const auto dictionaryFlushDecision = flushPolicy_->shouldFlushDictionary(
+      stripeProgressDecision, overBudget, stripeProgress, context);
 
   if (FOLLY_UNLIKELY(
           dictionaryFlushDecision == FlushDecision::ABANDON_DICTIONARY)) {
@@ -212,6 +356,8 @@ bool Writer::shouldFlush(const WriterContext& context, size_t nextWriteRows) {
     overBudget = overMemoryBudget(context, nextWriteRows);
     stripeProgressDecision =
         flushPolicy_->shouldFlush(getStripeProgress(context));
+  } else if (dictionaryFlushDecision == FlushDecision::EVALUATE_DICTIONARY) {
+    writer_->tryAbandonDictionaries(/*force=*/false);
   }
 
   const bool shouldFlush = overBudget || stripeProgressDecision ||
@@ -239,7 +385,7 @@ void Writer::enterLowMemoryMode() {
   if (FOLLY_UNLIKELY(
           context.checkLowMemoryMode() && context.stripeIndex() == 0)) {
     // Idempotent call to switch to less memory intensive encodings.
-    writer_->tryAbandonDictionaries(true);
+    writer_->tryAbandonDictionaries(/*force=*/true);
   }
 }
 
@@ -262,7 +408,16 @@ void Writer::flushStripe(bool close) {
     createRowIndexEntry();
   }
 
-  const auto preFlushMem = context.getTotalMemoryUsage();
+  const auto preFlushTotalMemBytes = context.getTotalMemoryUsage();
+  ensureStripeFlushFits();
+  // NOTE: ensureStripeFlushFits() might trigger memory arbitration that have
+  // flushed the current stripe.
+  if (context.stripeRowCount() == 0) {
+    VELOX_CHECK(canReclaim());
+    return;
+  }
+
+  TestValue::adjust("facebook::velox::dwrf::Writer::flushStripe", this);
 
   const auto& handler = context.getEncryptionHandler();
   EncodingManager encodingManager{handler};
@@ -272,13 +427,16 @@ void Writer::flushStripe(bool close) {
   });
 
   // Collects the memory increment from flushing data to output streams.
+  const auto postFlushStreamMemoryUsage =
+      context.getMemoryUsage(MemoryUsageCategory::OUTPUT_STREAM);
   const auto flushOverhead =
-      context.getMemoryUsage(MemoryUsageCategory::OUTPUT_STREAM) -
-      preFlushStreamMemoryUsage;
-  context.recordFlushOverhead(flushOverhead);
-  metrics.flushOverhead = flushOverhead;
+      postFlushStreamMemoryUsage > preFlushStreamMemoryUsage
+      ? postFlushStreamMemoryUsage - preFlushStreamMemoryUsage
+      : 0;
+  metrics.flushOverhead = static_cast<uint64_t>(flushOverhead);
+  context.recordFlushOverhead(metrics.flushOverhead);
 
-  const auto postFlushMem = context.getTotalMemoryUsage();
+  const auto postFlushTotalMemBytes = context.getTotalMemoryUsage();
 
   auto& sink = writerBase_->getSink();
   auto stripeOffset = sink.size();
@@ -385,7 +543,7 @@ void Writer::flushStripe(bool close) {
   metrics.availableMemory = context.getMemoryBudget() - totalMemoryUsage;
 
   auto& dictionaryPool = context.getMemoryPool(MemoryUsageCategory::DICTIONARY);
-  metrics.dictionaryMemory = dictionaryPool.currentBytes();
+  metrics.dictionaryMemory = dictionaryPool.usedBytes();
   // TODO: what does this try to capture?
   metrics.maxDictSize = dictionaryPool.stats().peakBytes;
 
@@ -398,14 +556,17 @@ void Writer::flushStripe(bool close) {
   metrics.groupSize = 0;
   metrics.close = close;
 
-  LOG(INFO) << fmt::format(
+  VLOG(1) << fmt::format(
       "Stripe {}: Flush overhead = {}, data length = {}, pre flush mem = {}, post flush mem = {}. Closing = {}",
       metrics.stripeIndex,
       metrics.flushOverhead,
       metrics.stripeSize,
-      preFlushMem,
-      postFlushMem,
+      preFlushTotalMemBytes,
+      postFlushTotalMemBytes,
       metrics.close);
+  addThreadLocalRuntimeStat(
+      "stripeSize",
+      RuntimeCounter(metrics.stripeSize, RuntimeCounter::Unit::kBytes));
   // Add flush overhead and other ratio logging.
   context.metricLogger()->logStripeFlush(metrics);
 
@@ -415,6 +576,9 @@ void Writer::flushStripe(bool close) {
 }
 
 void Writer::flushInternal(bool close) {
+  TestValue::adjust("facebook::velox::dwrf::Writer::flushInternal", this);
+  auto exitGuard = folly::makeGuard([this]() { releaseMemory(); });
+
   auto& context = writerBase_->getContext();
   auto& footer = writerBase_->getFooter();
   auto& sink = writerBase_->getSink();
@@ -523,42 +687,127 @@ void Writer::flushInternal(bool close) {
 }
 
 void Writer::flush() {
+  checkRunning();
   flushInternal(false);
 }
 
 void Writer::close() {
-  auto exitGuard = folly::makeGuard([this]() { flushPolicy_->onClose(); });
+  checkRunning();
+  auto exitGuard = folly::makeGuard([this]() {
+    flushPolicy_->onClose();
+    setState(State::kClosed);
+  });
   flushInternal(true);
   writerBase_->close();
 }
 
 void Writer::abort() {
+  checkRunning();
+  auto exitGuard = folly::makeGuard([this]() { setState(State::kAborted); });
   // NOTE: we need to reset column writer as all its dependent objects (e.g.
   // writer context) will be reset by writer base abort.
   writer_.reset();
   writerBase_->abort();
 }
 
-dwrf::WriterOptions getDwrfOptions(const dwio::common::WriterOptions& options) {
-  std::map<std::string, std::string> configs;
-  if (options.compressionKind.has_value()) {
-    configs.emplace(
-        Config::COMPRESSION.configKey(),
-        std::to_string(options.compressionKind.value()));
-  }
-  dwrf::WriterOptions dwrfOptions;
-  dwrfOptions.config = Config::fromMap(configs);
-  dwrfOptions.schema = options.schema;
-  dwrfOptions.memoryPool = options.memoryPool;
-  dwrfOptions.setMemoryReclaimer = options.setMemoryReclaimer;
-  return dwrfOptions;
+std::unique_ptr<memory::MemoryReclaimer> Writer::MemoryReclaimer::create(
+    Writer* writer) {
+  return std::unique_ptr<memory::MemoryReclaimer>(
+      new Writer::MemoryReclaimer(writer));
+}
+
+bool Writer::MemoryReclaimer::reclaimableBytes(
+    const memory::MemoryPool& /*unused*/,
+    uint64_t& reclaimableBytes) const {
+  reclaimableBytes = 0;
+  if (!writer_->canReclaim()) {
+    return false;
+  }
+  TestValue::adjust(
+      "facebook::velox::dwrf::Writer::MemoryReclaimer::reclaimableBytes",
+      writer_);
+  const auto& context = writer_->getContext();
+  const auto usedBytes = context.getTotalMemoryUsage();
+  const auto releasableBytes = context.releasableMemoryReservation();
+  const bool flushable =
+      usedBytes >= writer_->spillConfig_->writerFlushThresholdSize;
+  if (releasableBytes == 0 && !flushable) {
+    return false;
+  }
+  reclaimableBytes = (flushable ? usedBytes : 0) + releasableBytes;
+  return true;
+}
+
+uint64_t Writer::MemoryReclaimer::reclaim(
+    memory::MemoryPool* pool,
+    uint64_t targetBytes,
+    uint64_t /*unused*/,
+    memory::MemoryReclaimer::Stats& stats) {
+  if (!writer_->canReclaim()) {
+    return 0;
+  }
+
+  if (*writer_->nonReclaimableSection_) {
+    RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
+    LOG(WARNING)
+        << "Can't reclaim from dwrf writer which is under non-reclaimable "
+           "section: "
+        << pool->name();
+    ++stats.numNonReclaimableAttempts;
+    return 0;
+  }
+  if (!writer_->isRunning()) {
+    LOG(WARNING) << "Can't reclaim from a not running dwrf writer: "
+                 << pool->name() << ", state: " << writer_->state();
+    ++stats.numNonReclaimableAttempts;
+    return 0;
+  }
+
+  return memory::MemoryReclaimer::run(
+      [&]() {
+        int64_t reclaimedBytes{0};
+        {
+          memory::ScopedReclaimedBytesRecorder recorder(pool, &reclaimedBytes);
+          const auto& context = writer_->getContext();
+          const auto usedBytes = context.getTotalMemoryUsage();
+          const auto releasedBytes = writer_->releaseMemory();
+          if (releasedBytes == 0 &&
+              usedBytes < writer_->spillConfig_->writerFlushThresholdSize) {
+            RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
+            LOG(WARNING)
+                << "Can't reclaim memory from dwrf writer pool " << pool->name()
+                << " which doesn't have sufficient memory to release or flush, "
+                   "writer memory usage: "
+                << succinctBytes(usedBytes)
+                << ", writer memory available reservation: "
+                << succinctBytes(context.availableMemoryReservation())
+                << ", writer flush memory threshold: "
+                << succinctBytes(
+                       writer_->spillConfig_->writerFlushThresholdSize);
+            ++stats.numNonReclaimableAttempts;
+          } else {
+            if (usedBytes >= writer_->spillConfig_->writerFlushThresholdSize) {
+              writer_->flushInternal(false);
+            }
+          }
+        }
+        return reclaimedBytes;
+      },
+      stats);
 }
 
 std::unique_ptr<dwio::common::Writer> DwrfWriterFactory::createWriter(
     std::unique_ptr<dwio::common::FileSink> sink,
-    const dwio::common::WriterOptions& options) {
-  auto dwrfOptions = getDwrfOptions(options);
-  return std::make_unique<Writer>(std::move(sink), dwrfOptions);
+    const std::shared_ptr<dwio::common::WriterOptions>& options) {
+  auto dwrfOptions = std::dynamic_pointer_cast<dwrf::WriterOptions>(options);
+  VELOX_CHECK_NOT_NULL(
+      dwrfOptions, "DWRF writer factory expected a DWRF WriterOptions object.");
+  return std::make_unique<Writer>(std::move(sink), *dwrfOptions);
+}
+
+std::unique_ptr<dwio::common::WriterOptions>
+DwrfWriterFactory::createWriterOptions() {
+  return std::make_unique<dwrf::WriterOptions>();
 }
 
 void registerDwrfWriterFactory() {
diff --git a/velox/dwio/dwrf/writer/Writer.h b/velox/dwio/dwrf/writer/Writer.h
index c715981636bea..66c38c99a5164 100644
--- a/velox/dwio/dwrf/writer/Writer.h
+++ b/velox/dwio/dwrf/writer/Writer.h
@@ -26,17 +26,12 @@
 #include "velox/dwio/dwrf/writer/FlushPolicy.h"
 #include "velox/dwio/dwrf/writer/LayoutPlanner.h"
 #include "velox/dwio/dwrf/writer/WriterBase.h"
+#include "velox/exec/MemoryReclaimer.h"
 
 namespace facebook::velox::dwrf {
 
-struct WriterOptions {
+struct WriterOptions : public dwio::common::WriterOptions {
   std::shared_ptr<const Config> config = std::make_shared<Config>();
-  std::shared_ptr<const Type> schema;
-  velox::memory::MemoryPool* memoryPool;
-  velox::memory::SetMemoryReclaimer setMemoryReclaimer{nullptr};
-  /// The default factory allows the writer to construct the default flush
-  /// policy with the configs in its ctor.
-  std::function<std::unique_ptr<DWRFFlushPolicy>()> flushPolicyFactory;
   /// Changes the interface to stream list and encoding iter.
   std::function<std::unique_ptr<LayoutPlanner>(const dwio::common::TypeWithId&)>
       layoutPlannerFactory;
@@ -59,7 +54,8 @@ class Writer : public dwio::common::Writer {
             std::move(sink),
             options,
             parentPool.addAggregateChild(fmt::format(
-                "writer_node_{}",
+                "{}.dwrf_{}",
+                parentPool.name(),
                 folly::to<std::string>(folly::Random::rand64())))} {}
 
   Writer(
@@ -127,14 +123,70 @@ class Writer : public dwio::common::Writer {
     return writerBase_->getContext();
   }
 
+  const proto::Footer& getFooter() const {
+    return writerBase_->getFooter();
+  }
+
   WriterSink& getSink() {
     return writerBase_->getSink();
   }
 
+  /// True if we can reclaim memory from this writer by memory arbitration.
+  bool canReclaim() const;
+
+  tsan_atomic<bool>& testingNonReclaimableSection() {
+    return *nonReclaimableSection_;
+  }
+
  protected:
   std::shared_ptr<WriterBase> writerBase_;
 
  private:
+  class MemoryReclaimer : public exec::MemoryReclaimer {
+   public:
+    static std::unique_ptr<memory::MemoryReclaimer> create(Writer* writer);
+
+    bool reclaimableBytes(
+        const memory::MemoryPool& pool,
+        uint64_t& reclaimableBytes) const override;
+
+    uint64_t reclaim(
+        memory::MemoryPool* pool,
+        uint64_t targetBytes,
+        uint64_t maxWaitMs,
+        memory::MemoryReclaimer::Stats& stats) override;
+
+   private:
+    explicit MemoryReclaimer(Writer* writer) : writer_(writer) {
+      VELOX_CHECK_NOT_NULL(writer_);
+    }
+
+    Writer* const writer_;
+  };
+
+  // Sets the memory reclaimers for all the memory pools used by this writer.
+  void setMemoryReclaimers(const std::shared_ptr<memory::MemoryPool>& pool);
+
+  // Invoked to ensure sufficient memory to process the given size of input by
+  // reserving memory from each of the leaf memory pool. This only applies if we
+  // support memory reclaim on this writer. The memory reservation might trigger
+  // stripe flush by memory arbitration if the query root memory pool doesn't
+  // enough memory capacity.
+  void ensureWriteFits(size_t appendBytes, size_t appendRows);
+
+  // Similar to 'ensureWriteFits' above to ensure sufficient memory to flush
+  // the buffered stripe data to disk.
+  void ensureStripeFlushFits();
+
+  // Grows a memory pool size by the specified ratio.
+  bool maybeReserveMemory(
+      MemoryUsageCategory memoryUsageCategory,
+      double estimatedMemoryGrowthRatio);
+
+  // Releases the unused memory reservations after we flush a stripe. Returns
+  // the total number of released bytes.
+  int64_t releaseMemory();
+
   // Create a new stripe. No-op if there is no data written.
   void flushInternal(bool close = false);
 
@@ -146,6 +198,11 @@ class Writer : public dwio::common::Writer {
   }
 
   const std::shared_ptr<const dwio::common::TypeWithId> schema_;
+  const common::SpillConfig* const spillConfig_;
+  // If not null, used by memory arbitration to track if this file writer is
+  // under memory reclaimable section or not.
+  tsan_atomic<bool>* const nonReclaimableSection_{nullptr};
+
   std::unique_ptr<DWRFFlushPolicy> flushPolicy_;
   std::unique_ptr<LayoutPlanner> layoutPlanner_;
   std::unique_ptr<ColumnWriter> writer_;
@@ -157,11 +214,9 @@ class DwrfWriterFactory : public dwio::common::WriterFactory {
 
   std::unique_ptr<dwio::common::Writer> createWriter(
       std::unique_ptr<dwio::common::FileSink> sink,
-      const dwio::common::WriterOptions& options) override;
-};
+      const std::shared_ptr<dwio::common::WriterOptions>& options) override;
 
-void registerDwrfWriterFactory();
-
-void unregisterDwrfWriterFactory();
+  std::unique_ptr<dwio::common::WriterOptions> createWriterOptions() override;
+};
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/writer/WriterBase.cpp b/velox/dwio/dwrf/writer/WriterBase.cpp
index b7a1e279226ed..6fd51477d0484 100644
--- a/velox/dwio/dwrf/writer/WriterBase.cpp
+++ b/velox/dwio/dwrf/writer/WriterBase.cpp
@@ -90,4 +90,10 @@ void WriterBase::writeUserMetadata(uint32_t writerVersion) {
     item->set_value(pair.second);
   });
 }
+
+void WriterBase::initBuffers() {
+  context_->initBuffer();
+  writerSink_->init(
+      context_->getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM));
+}
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/writer/WriterBase.h b/velox/dwio/dwrf/writer/WriterBase.h
index 5cdbd6bd005fb..29ba724a45d27 100644
--- a/velox/dwio/dwrf/writer/WriterBase.h
+++ b/velox/dwio/dwrf/writer/WriterBase.h
@@ -40,7 +40,9 @@ class WriterBase {
 
   virtual void abort() {
     writerSink_ = nullptr;
-    context_ = nullptr;
+    if (context_ != nullptr) {
+      context_->abort();
+    }
     if (sink_) {
       sink_->close();
       sink_ = nullptr;
@@ -72,20 +74,17 @@ class WriterBase {
   void initContext(
       const std::shared_ptr<const Config>& config,
       std::shared_ptr<velox::memory::MemoryPool> pool,
-      const velox::memory::SetMemoryReclaimer& setReclaimer = nullptr,
       std::unique_ptr<encryption::EncryptionHandler> handler = nullptr) {
     context_ = std::make_unique<WriterContext>(
-        config,
-        std::move(pool),
-        setReclaimer,
-        sink_->metricsLog(),
-        std::move(handler));
+        config, std::move(pool), sink_->metricsLog(), std::move(handler));
     writerSink_ = std::make_unique<WriterSink>(
         *sink_,
         context_->getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM),
         context_->getConfigs());
   }
 
+  void initBuffers();
+
   WriterContext& getContext() {
     DWIO_ENSURE_NOT_NULL(context_);
     return *context_;
diff --git a/velox/dwio/dwrf/writer/WriterContext.cpp b/velox/dwio/dwrf/writer/WriterContext.cpp
index 0f2a3963ce60a..68cb916d55e2d 100644
--- a/velox/dwio/dwrf/writer/WriterContext.cpp
+++ b/velox/dwio/dwrf/writer/WriterContext.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "velox/dwio/dwrf/writer/WriterContext.h"
+#include "velox/common/compression/Compression.h"
+#include "velox/exec/MemoryReclaimer.h"
 
 namespace facebook::velox::dwrf {
 namespace {
@@ -24,14 +26,16 @@ constexpr uint32_t MIN_INDEX_STRIDE = 1000;
 WriterContext::WriterContext(
     const std::shared_ptr<const Config>& config,
     std::shared_ptr<memory::MemoryPool> pool,
-    const memory::SetMemoryReclaimer& setReclaimer,
     const dwio::common::MetricsLogPtr& metricLogger,
     std::unique_ptr<encryption::EncryptionHandler> handler)
     : config_{config},
       pool_{std::move(pool)},
-      dictionaryPool_{pool_->addLeafChild(".dictionary")},
-      outputStreamPool_{pool_->addLeafChild(".compression")},
-      generalPool_{pool_->addLeafChild(".general")},
+      dictionaryPool_{
+          pool_->addLeafChild(fmt::format("{}.dictionary", pool_->name()))},
+      outputStreamPool_{
+          pool_->addLeafChild(fmt::format("{}.compression", pool_->name()))},
+      generalPool_{
+          pool_->addLeafChild(fmt::format("{}.general", pool_->name()))},
       indexEnabled_{getConfig(Config::CREATE_INDEX)},
       indexStride_{getConfig(Config::ROW_INDEX_STRIDE)},
       compression_{getConfig(Config::COMPRESSION)},
@@ -39,6 +43,8 @@ WriterContext::WriterContext(
       shareFlatMapDictionaries_{getConfig(Config::MAP_FLAT_DICT_SHARE)},
       stripeSizeFlushThreshold_{getConfig(Config::STRIPE_SIZE)},
       dictionarySizeFlushThreshold_{getConfig(Config::MAX_DICTIONARY_SIZE)},
+      linearStripeSizeHeuristics_{
+          getConfig(Config::LINEAR_STRIPE_SIZE_HEURISTICS)},
       streamSizeAboveThresholdCheckEnabled_{
           getConfig(Config::STREAM_SIZE_ABOVE_THRESHOLD_CHECK_ENABLED)},
       rawDataSizePerBatch_{getConfig(Config::RAW_DATA_SIZE_PER_BATCH)},
@@ -47,11 +53,6 @@ WriterContext::WriterContext(
       // pass down the metric log.
       metricLogger_{metricLogger},
       handler_{std::move(handler)} {
-  if (setReclaimer != nullptr) {
-    setReclaimer(dictionaryPool_.get());
-    setReclaimer(outputStreamPool_.get());
-    setReclaimer(generalPool_.get());
-  }
   const bool forceLowMemoryMode{getConfig(Config::FORCE_LOW_MEMORY_MODE)};
   const bool disableLowMemoryMode{getConfig(Config::DISABLE_LOW_MEMORY_MODE)};
   VELOX_CHECK(!(forceLowMemoryMode && disableLowMemoryMode));
@@ -63,11 +64,12 @@ WriterContext::WriterContext(
     handler_ = std::make_unique<encryption::EncryptionHandler>();
   }
   validateConfigs();
-  VLOG(2) << fmt::format("Compression config: {}", compression_);
-  if (compression_ != common::CompressionKind_NONE) {
-    compressionBuffer_ = std::make_unique<dwio::common::DataBuffer<char>>(
-        *generalPool_, compressionBlockSize_ + PAGE_HEADER_SIZE);
-  }
+  VLOG(2) << fmt::format(
+      "Compression config: {}", common::compressionKindToString(compression_));
+}
+
+WriterContext::~WriterContext() {
+  releaseMemoryReservation();
 }
 
 void WriterContext::validateConfigs() const {
@@ -88,6 +90,14 @@ void WriterContext::validateConfigs() const {
       dwio::common::MIN_PAGE_GROW_RATIO);
 }
 
+void WriterContext::initBuffer() {
+  VELOX_CHECK_NULL(compressionBuffer_);
+  if (compression_ != common::CompressionKind_NONE) {
+    compressionBuffer_ = std::make_unique<dwio::common::DataBuffer<char>>(
+        *generalPool_, compressionBlockSize_ + PAGE_HEADER_SIZE);
+  }
+}
+
 memory::MemoryPool& WriterContext::getMemoryPool(
     const MemoryUsageCategory& category) {
   switch (category) {
@@ -106,19 +116,51 @@ int64_t WriterContext::getMemoryUsage(
     const MemoryUsageCategory& category) const {
   switch (category) {
     case MemoryUsageCategory::DICTIONARY:
-      return dictionaryPool_->currentBytes();
+      return dictionaryPool_->usedBytes();
     case MemoryUsageCategory::OUTPUT_STREAM:
-      return outputStreamPool_->currentBytes();
+      return outputStreamPool_->usedBytes();
     case MemoryUsageCategory::GENERAL:
-      return generalPool_->currentBytes();
+      return generalPool_->usedBytes();
     default:
       VELOX_FAIL("Unreachable: {}", static_cast<int>(category));
   }
 }
 
 int64_t WriterContext::getTotalMemoryUsage() const {
-  return getMemoryUsage(MemoryUsageCategory::OUTPUT_STREAM) +
-      getMemoryUsage(MemoryUsageCategory::DICTIONARY) +
-      getMemoryUsage(MemoryUsageCategory::GENERAL);
+  return generalPool_->usedBytes() + dictionaryPool_->usedBytes() +
+      outputStreamPool_->usedBytes();
+}
+
+int64_t WriterContext::availableMemoryReservation() const {
+  return dictionaryPool_->availableReservation() +
+      outputStreamPool_->availableReservation() +
+      generalPool_->availableReservation();
+}
+
+int64_t WriterContext::releasableMemoryReservation() const {
+  return generalPool_->parent()->releasableReservation();
+}
+
+int64_t WriterContext::releaseMemoryReservation() {
+  const auto* aggregatePool = dictionaryPool_->parent();
+  const auto beforeTotalReservation = aggregatePool->reservedBytes();
+  dictionaryPool_->release();
+  outputStreamPool_->release();
+  generalPool_->release();
+  const auto releasedMemory =
+      beforeTotalReservation - aggregatePool->reservedBytes();
+  VELOX_CHECK_GE(releasedMemory, 0);
+  return releasedMemory;
+}
+
+void WriterContext::abort() {
+  compressionBuffer_.reset();
+  physicalSizeAggregators_.clear();
+  streams_.clear();
+  dictEncoders_.clear();
+  decodedVectorPool_.clear();
+  decodedVectorPool_.shrink_to_fit();
+  selectivityVector_.reset();
+  releaseMemoryReservation();
 }
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/writer/WriterContext.h b/velox/dwio/dwrf/writer/WriterContext.h
index d1c385736790b..4c93409d8d034 100644
--- a/velox/dwio/dwrf/writer/WriterContext.h
+++ b/velox/dwio/dwrf/writer/WriterContext.h
@@ -41,11 +41,12 @@ class WriterContext : public CompressionBufferPool {
   WriterContext(
       const std::shared_ptr<const Config>& config,
       std::shared_ptr<memory::MemoryPool> pool,
-      const memory::SetMemoryReclaimer& setReclaimer = nullptr,
       const dwio::common::MetricsLogPtr& metricLogger =
           dwio::common::MetricsLog::voidLog(),
       std::unique_ptr<encryption::EncryptionHandler> handler = nullptr);
 
+  ~WriterContext() override;
+
   bool hasStream(const DwrfStreamIdentifier& stream) const {
     return streams_.find(stream) != streams_.end();
   }
@@ -181,12 +182,26 @@ class WriterContext : public CompressionBufferPool {
 
   int64_t getMemoryUsage(const MemoryUsageCategory& category) const;
 
+  std::string testingGetWriterMemoryStats() {
+    return pool_->treeMemoryUsage();
+  }
+
   int64_t getTotalMemoryUsage() const;
 
   int64_t getMemoryBudget() const {
     return pool_->maxCapacity();
   }
 
+  /// Returns the available memory reservations from all the memory pools.
+  int64_t availableMemoryReservation() const;
+
+  /// Returns the amount of unused memory reservation that could be released.
+  int64_t releasableMemoryReservation() const;
+
+  /// Releases unused memory reservation from all the memory pools. Returns
+  /// total released bytes.
+  int64_t releaseMemoryReservation();
+
   const encryption::EncryptionHandler& getEncryptionHandler() const {
     return *handler_;
   }
@@ -237,6 +252,8 @@ class WriterContext : public CompressionBufferPool {
     }
   }
 
+  void initBuffer();
+
   std::unique_ptr<dwio::common::DataBuffer<char>> getBuffer(
       uint64_t size) override {
     VELOX_CHECK_NOT_NULL(compressionBuffer_);
@@ -252,12 +269,12 @@ class WriterContext : public CompressionBufferPool {
   }
 
   void incrementNodeSize(uint32_t node, uint64_t size) {
-    nodeSize[node] += size;
+    nodeSize_[node] += size;
   }
 
   uint64_t getNodeSize(uint32_t node) {
-    if (nodeSize.count(node) > 0) {
-      return nodeSize[node];
+    if (nodeSize_.count(node) > 0) {
+      return nodeSize_[node];
     }
     return 0;
   }
@@ -301,19 +318,41 @@ class WriterContext : public CompressionBufferPool {
   }
 
   int64_t getEstimatedOutputStreamSize() const {
+    constexpr float kDataBufferGrowthFactor = 1.5;
+    // NOTE: This is a rough heuristic, based on buffer growth factors. Due to
+    // the chained/paged buffer semantics of output streams, the larger the
+    // streams are, the more we are undercounting content size. However, this
+    // ensures that we don't produce small stripes for flat map scenarios. A
+    // better heuristics would have to account for the number of streams in some
+    // way.
     return (int64_t)std::ceil(
-        (getMemoryUsage(MemoryUsageCategory::OUTPUT_STREAM) +
-         getMemoryUsage(MemoryUsageCategory::DICTIONARY)) /
-        getConfig(Config::COMPRESSION_BLOCK_SIZE_EXTEND_RATIO));
+        (getMemoryUsage(MemoryUsageCategory::OUTPUT_STREAM) /
+             getConfig(Config::COMPRESSION_BLOCK_SIZE_EXTEND_RATIO) +
+         getMemoryUsage(MemoryUsageCategory::DICTIONARY) /
+             kDataBufferGrowthFactor));
   }
 
-  // The additional memory usage of writers during flush typically comes from
-  // flushing remaining data to output buffer, or all of it in the case of
-  // dictionary encoding. In either case, the maximal memory consumption is
-  // O(k * raw data size). The actual coefficient k can differ
-  // from encoding to encoding, and thus should be schema aware.
+  /// The additional memory usage of writers during flush typically comes from
+  /// flushing remaining data to output buffer, or all of it in the case of
+  /// dictionary encoding. In either case, the maximal memory consumption is
+  /// O(k * raw data size). The actual coefficient k can differ
+  /// from encoding to encoding, and thus should be schema aware.
   size_t getEstimatedFlushOverhead(size_t dataRawSize) const {
-    return ceil(flushOverheadRatioTracker_.getEstimatedRatio() * dataRawSize);
+    return ceil(
+        flushOverheadRatioTracker_.getEstimatedRatio() *
+        (dataRawSize + getMemoryUsage(MemoryUsageCategory::DICTIONARY)));
+  }
+
+  /// We currently use previous stripe raw size as the proxy for the expected
+  /// stripe raw size. For the first stripe, we are more conservative about
+  /// flush overhead memory unless we know otherwise, e.g. perhaps from
+  /// encoding DB work.
+  /// This can be fitted linearly just like flush overhead or perhaps
+  /// figured out from the schema.
+  /// This can be simplified with Slice::estimateMemory().
+  size_t estimateNextWriteSize(size_t numRows) const {
+    // This is 0 for first slice. We are assuming reasonable input for now.
+    return folly::to<size_t>(ceil(getAverageRowSize() * numRows));
   }
 
   bool checkLowMemoryMode() const {
@@ -365,6 +404,10 @@ class WriterContext : public CompressionBufferPool {
     return dictionarySizeFlushThreshold_;
   }
 
+  bool linearStripeSizeHeuristics() const {
+    return linearStripeSizeHeuristics_;
+  }
+
   bool streamSizeAboveThresholdCheckEnabled() const {
     return streamSizeAboveThresholdCheckEnabled_;
   }
@@ -468,37 +511,37 @@ class WriterContext : public CompressionBufferPool {
         break;
       }
       case TypeKind::BOOLEAN:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::TINYINT:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::SMALLINT:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::INTEGER:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::BIGINT:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::HUGEINT:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::REAL:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::DOUBLE:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::VARCHAR:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::VARBINARY:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::TIMESTAMP:
         physicalSizeAggregators_.emplace(
             type.id(), std::make_unique<PhysicalSizeAggregator>(parent));
         break;
       case TypeKind::UNKNOWN:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::FUNCTION:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::OPAQUE:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       case TypeKind::INVALID:
-        FOLLY_FALLTHROUGH;
+        [[fallthrough]];
       default:
         VELOX_FAIL(
             "Unexpected type kind {} encountered when building "
@@ -546,6 +589,8 @@ class WriterContext : public CompressionBufferPool {
     return *selectivityVector_;
   }
 
+  void abort();
+
   dwio::common::DataBuffer<char>* testingCompressionBuffer() const {
     return compressionBuffer_.get();
   }
@@ -579,6 +624,7 @@ class WriterContext : public CompressionBufferPool {
   const bool shareFlatMapDictionaries_;
   const uint64_t stripeSizeFlushThreshold_;
   const uint64_t dictionarySizeFlushThreshold_;
+  const bool linearStripeSizeHeuristics_;
   const bool streamSizeAboveThresholdCheckEnabled_;
   const uint64_t rawDataSizePerBatch_;
   const dwio::common::MetricsLogPtr metricLogger_;
@@ -607,7 +653,7 @@ class WriterContext : public CompressionBufferPool {
   std::unique_ptr<velox::SelectivityVector> selectivityVector_;
 
   std::unique_ptr<encryption::EncryptionHandler> handler_;
-  folly::F14FastMap<uint32_t, uint64_t> nodeSize;
+  folly::F14FastMap<uint32_t, uint64_t> nodeSize_;
   CompressionRatioTracker compressionRatioTracker_;
   FlushOverheadRatioTracker flushOverheadRatioTracker_;
   // This might not be the best idea if client actually sends batches
@@ -632,11 +678,10 @@ class WriterContext : public CompressionBufferPool {
   friend class StringColumnWriterDictionaryEncodingIndexTest;
   friend class StringColumnWriterDirectEncodingIndexTest;
   // TODO: remove once writer code is consolidated
-  template <typename TestType>
   friend class WriterEncodingIndexTest2;
 
-  VELOX_FRIEND_TEST(TestWriterContext, GetIntDictionaryEncoder);
-  VELOX_FRIEND_TEST(TestWriterContext, RemoveIntDictionaryEncoderForNode);
+  VELOX_FRIEND_TEST(WriterContextTest, GetIntDictionaryEncoder);
+  VELOX_FRIEND_TEST(WriterContextTest, RemoveIntDictionaryEncoderForNode);
 };
 
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/writer/WriterSink.cpp b/velox/dwio/dwrf/writer/WriterSink.cpp
index e56b6df244f26..9f717672175c5 100644
--- a/velox/dwio/dwrf/writer/WriterSink.cpp
+++ b/velox/dwio/dwrf/writer/WriterSink.cpp
@@ -58,4 +58,18 @@ void WriterSink::addBuffer(dwio::common::DataBuffer<char> buffer) {
     sink_->write(std::move(buffer));
   }
 }
+
+void WriterSink::init(memory::MemoryPool& pool) {
+  VELOX_CHECK(!initialized_);
+  VELOX_CHECK(offsets_.empty());
+  initialized_ = true;
+
+  if (cacheMode_ != StripeCacheMode::NA) {
+    offsets_.push_back(0);
+    cacheBuffer_.reserve(SLICE_SIZE);
+  }
+
+  // initialize the buffer with the orc header
+  addBuffer(pool, ORC_MAGIC.data(), ORC_MAGIC_LEN);
+}
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/writer/WriterSink.h b/velox/dwio/dwrf/writer/WriterSink.h
index 889fd334d4d0b..3022b0c45c92d 100644
--- a/velox/dwio/dwrf/writer/WriterSink.h
+++ b/velox/dwio/dwrf/writer/WriterSink.h
@@ -50,19 +50,12 @@ class WriterSink {
         size_{0},
         cacheHolder_{pool, SLICE_SIZE, SLICE_SIZE},
         cacheBuffer_{pool},
-        exceedsLimit_{false} {
-    if (cacheMode_ != StripeCacheMode::NA) {
-      offsets_.push_back(0);
-      cacheBuffer_.reserve(SLICE_SIZE);
-    }
-
-    // initialize the buffer with the orc header
-    addBuffer(pool, ORC_MAGIC.data(), ORC_MAGIC_LEN);
-  }
+        exceedsLimit_{false} {}
 
   ~WriterSink() {
     if (!buffers_.empty() || size_ != 0) {
-      LOG(WARNING) << "Unflushed data in writer sink!";
+      LOG(WARNING) << "Unflushed data in writer sink: " << succinctBytes(size_)
+                   << ", " << buffers_.size() << " buffers";
     }
   }
 
@@ -70,6 +63,8 @@ class WriterSink {
     return sink_->size() + size_;
   }
 
+  void init(memory::MemoryPool& pool);
+
   void addBuffer(memory::MemoryPool& pool, const char* data, size_t size) {
     dwio::common::DataBuffer<char> buf{pool, size};
     std::memcpy(buf.data(), data, size);
@@ -176,6 +171,7 @@ class WriterSink {
   const bool shouldBuffer_;
   const uint32_t maxCacheSize_;
 
+  bool initialized_{false};
   Mode mode_;
   uint64_t size_;
 
diff --git a/velox/dwio/orc/CMakeLists.txt b/velox/dwio/orc/CMakeLists.txt
new file mode 100644
index 0000000000000..44f623de1231b
--- /dev/null
+++ b/velox/dwio/orc/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_subdirectory(reader)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(test)
+endif()
diff --git a/velox/dwio/orc/reader/CMakeLists.txt b/velox/dwio/orc/reader/CMakeLists.txt
new file mode 100644
index 0000000000000..18a977afee3ff
--- /dev/null
+++ b/velox/dwio/orc/reader/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(velox_dwio_orc_reader OrcReader.cpp)
+
+velox_link_libraries(velox_dwio_orc_reader velox_dwio_dwrf_reader)
diff --git a/velox/dwio/orc/reader/OrcReader.cpp b/velox/dwio/orc/reader/OrcReader.cpp
new file mode 100644
index 0000000000000..7839552aeae46
--- /dev/null
+++ b/velox/dwio/orc/reader/OrcReader.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/orc/reader/OrcReader.h"
+
+namespace facebook::velox::orc {
+void registerOrcReaderFactory() {
+  dwio::common::registerReaderFactory(std::make_shared<OrcReaderFactory>());
+}
+
+void unregisterOrcReaderFactory() {
+  dwio::common::unregisterReaderFactory(dwio::common::FileFormat::ORC);
+}
+} // namespace facebook::velox::orc
diff --git a/velox/dwio/orc/reader/OrcReader.h b/velox/dwio/orc/reader/OrcReader.h
new file mode 100644
index 0000000000000..621d84787214e
--- /dev/null
+++ b/velox/dwio/orc/reader/OrcReader.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/dwio/common/ReaderFactory.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+
+namespace facebook::velox::orc {
+
+class OrcReaderFactory : public dwio::common::ReaderFactory {
+ public:
+  OrcReaderFactory() : ReaderFactory(dwio::common::FileFormat::ORC) {}
+
+  std::unique_ptr<dwio::common::Reader> createReader(
+      std::unique_ptr<dwio::common::BufferedInput> input,
+      const dwio::common::ReaderOptions& options) override {
+    return velox::dwrf::DwrfReader::create(std::move(input), options);
+  }
+};
+
+void registerOrcReaderFactory();
+
+void unregisterOrcReaderFactory();
+
+} // namespace facebook::velox::orc
diff --git a/velox/dwio/orc/test/CMakeLists.txt b/velox/dwio/orc/test/CMakeLists.txt
new file mode 100644
index 0000000000000..efb2ad3f5a6f2
--- /dev/null
+++ b/velox/dwio/orc/test/CMakeLists.txt
@@ -0,0 +1,30 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_dwio_orc_reader_test ReaderTest.cpp)
+add_test(
+  NAME velox_dwio_orc_reader_test
+  COMMAND velox_dwio_orc_reader_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(
+  velox_dwio_orc_reader_test
+  velox_dwrf_test_utils
+  velox_dwio_common_test_utils
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock)
+
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples
+     DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/velox/dwio/orc/test/ReaderTest.cpp b/velox/dwio/orc/test/ReaderTest.cpp
new file mode 100644
index 0000000000000..37ce83a568c4b
--- /dev/null
+++ b/velox/dwio/orc/test/ReaderTest.cpp
@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/dwio/dwrf/common/Common.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/dwio/dwrf/test/OrcTest.h"
+#include "velox/type/fbhive/HiveTypeParser.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::type::fbhive;
+using namespace facebook::velox;
+using namespace facebook::velox::dwrf;
+using namespace facebook::velox::test;
+
+namespace {
+class OrcReaderTest : public testing::Test, public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+inline std::string getExamplesFilePath(const std::string& fileName) {
+  return test::getDataFilePath("velox/dwio/orc/test", "examples/" + fileName);
+}
+
+} // namespace
+
+TEST_F(OrcReaderTest, testOrcReaderSimple) {
+  const std::string simpleTest(
+      getExamplesFilePath("TestStringDictionary.testRowIndex.orc"));
+  dwio::common::ReaderOptions readerOpts{pool()};
+  // To make DwrfReader reads ORC file, setFileFormat to FileFormat::ORC
+  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(simpleTest, readerOpts.memoryPool()), readerOpts);
+
+  RowReaderOptions rowReaderOptions;
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr batch;
+  const std::string stringPrefix{"row "};
+  size_t rowNumber = 0;
+  while (rowReader->next(500, batch)) {
+    auto rowVector = batch->as<RowVector>();
+    auto strings = rowVector->childAt(0)->as<SimpleVector<StringView>>();
+    for (size_t i = 0; i < rowVector->size(); ++i) {
+      std::stringstream stream;
+      stream << std::setfill('0') << std::setw(6) << rowNumber;
+      EXPECT_EQ(stringPrefix + stream.str(), strings->valueAt(i).str());
+      rowNumber++;
+    }
+  }
+  EXPECT_EQ(rowNumber, 32768);
+}
+TEST_F(OrcReaderTest, testOrcReaderComplexTypes) {
+  const std::string icebergOrc(getExamplesFilePath("complextypes_iceberg.orc"));
+  const std::shared_ptr<const RowType> expectedType =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse("struct<\
+     id:bigint,int_array:array<int>,int_array_array:array<array<int>>,\
+     int_map:map<string,int>,int_map_array:array<map<string,int>>,\
+     nested_struct:struct<\
+       a:int,b:array<int>,c:struct<\
+         d:array<array<struct<\
+           e:int,f:string>>>>,\
+         g:map<string,struct<\
+           h:struct<\
+             i:array<double>>>>>>"));
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(icebergOrc, readerOpts.memoryPool()), readerOpts);
+  auto rowType = reader->rowType();
+  EXPECT_TRUE(rowType->equivalent(*expectedType));
+}
+
+TEST_F(OrcReaderTest, testOrcReaderVarchar) {
+  const std::string varcharOrc(getExamplesFilePath("orc_index_int_string.orc"));
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(varcharOrc, readerOpts.memoryPool()), readerOpts);
+
+  RowReaderOptions rowReaderOptions;
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr batch;
+  int counter = 0;
+  while (rowReader->next(500, batch)) {
+    auto rowVector = batch->as<RowVector>();
+    auto ints = rowVector->childAt(0)->as<SimpleVector<int32_t>>();
+    auto strings = rowVector->childAt(1)->as<SimpleVector<StringView>>();
+    for (size_t i = 0; i < rowVector->size(); ++i) {
+      counter++;
+      EXPECT_EQ(counter, ints->valueAt(i));
+      std::stringstream stream;
+      stream << counter;
+      if (counter < 1000) {
+        stream << "a";
+      }
+      EXPECT_EQ(stream.str(), strings->valueAt(i).str());
+    }
+  }
+  EXPECT_EQ(counter, 6000);
+}
+
+TEST_F(OrcReaderTest, testOrcReaderDate) {
+  const std::string dateOrc(
+      getExamplesFilePath("TestOrcFile.testDate1900.orc"));
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(dateOrc, readerOpts.memoryPool()), readerOpts);
+
+  RowReaderOptions rowReaderOptions;
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr batch;
+  int year = 1900;
+  while (rowReader->next(1000, batch)) {
+    auto rowVector = batch->as<RowVector>();
+    auto dates = rowVector->childAt(1)->as<SimpleVector<int32_t>>();
+
+    std::stringstream stream;
+    stream << year << "-12-25";
+    EXPECT_EQ(stream.str(), DATE()->toString(dates->valueAt(0)));
+
+    for (size_t i = 1; i < rowVector->size(); ++i) {
+      EXPECT_EQ(dates->valueAt(0), dates->valueAt(i));
+    }
+
+    year++;
+  }
+}
+
+// create table orc_types_test (
+//    "a" integer,
+//    "b" bigint,
+//    "c" tinyint,
+//    "d" smallint,
+//    "e" real,
+//    "f" double,
+//    "g" varchar,
+//    "h" boolean,
+//    "i" decimal(38,6),
+//    "j" decimal(9,2),
+//    "k" date,
+//    "l" timestamp,
+//    "m" array(varchar(100)),
+//    "n" map(varchar(20), bigint),
+//    "o" ROW(x BIGINT, y DOUBLE)
+// ) with (format = 'ORC');
+TEST_F(OrcReaderTest, testOrcReadAllType) {
+  const std::string dateOrc(getExamplesFilePath("orc_all_type.orc"));
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(dateOrc, readerOpts.memoryPool()), readerOpts);
+
+  RowReaderOptions rowReaderOptions;
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr batch;
+  while (rowReader->next(500, batch)) {
+    auto rowVector = batch->as<RowVector>();
+    auto integerCol = rowVector->childAt(0)->as<SimpleVector<int32_t>>();
+    auto bigintCol = rowVector->childAt(1)->as<SimpleVector<int64_t>>();
+    auto tinyintCol = rowVector->childAt(2)->as<SimpleVector<int8_t>>();
+    auto smallintCol = rowVector->childAt(3)->as<SimpleVector<int16_t>>();
+    auto realCol = rowVector->childAt(4)->as<SimpleVector<float>>();
+    auto doubleCol = rowVector->childAt(5)->as<SimpleVector<double>>();
+    auto varcharCol = rowVector->childAt(6)->as<SimpleVector<StringView>>();
+    auto booleanCol = rowVector->childAt(7)->as<SimpleVector<bool>>();
+    auto longDecimalCol = rowVector->childAt(8)->as<SimpleVector<int128_t>>();
+    auto shortDecimalCol = rowVector->childAt(9)->as<SimpleVector<int64_t>>();
+    auto dateCol = rowVector->childAt(10)->as<SimpleVector<int32_t>>();
+    auto timestampCol = rowVector->childAt(11)->as<SimpleVector<Timestamp>>();
+    auto arrayCol = rowVector->childAt(12)->as<ArrayVector>();
+    auto mapCol = rowVector->childAt(13)->as<MapVector>();
+    auto structCol = rowVector->childAt(14)->as<RowVector>();
+
+    EXPECT_EQ(1, rowVector->size());
+    EXPECT_EQ(integerCol->valueAt(0), 111);
+    EXPECT_EQ(bigintCol->valueAt(0), 1111);
+    EXPECT_EQ(tinyintCol->valueAt(0), 127);
+    EXPECT_EQ(smallintCol->valueAt(0), 11);
+    EXPECT_EQ(realCol->valueAt(0), static_cast<float>(1.1));
+    EXPECT_EQ(doubleCol->valueAt(0), static_cast<double>(1.12));
+    EXPECT_EQ(varcharCol->valueAt(0), "velox");
+    EXPECT_EQ(booleanCol->valueAt(0), false);
+
+    auto longDecimalType = rowVector->type()->childAt(8);
+    auto shortDecimalType = rowVector->type()->childAt(9);
+    EXPECT_EQ(
+        DecimalUtil::toString(longDecimalCol->valueAt(0), longDecimalType),
+        "1242141234.123456");
+    EXPECT_EQ(
+        DecimalUtil::toString(shortDecimalCol->valueAt(0), shortDecimalType),
+        "321423.21");
+
+    EXPECT_EQ(dateCol->valueAt(0), DATE()->toDays("2023-08-18"));
+    EXPECT_EQ(
+        timestampCol->valueAt(0),
+        util::fromTimestampString(
+            "2023-08-18 08:12:23.000", util::TimestampParseMode::kPrestoCast)
+            .value());
+
+    auto arrayElements = arrayCol->elements()->as<SimpleVector<StringView>>();
+    EXPECT_EQ(arrayElements->size(), 3);
+    EXPECT_EQ(arrayElements->toString(0, 3, ",", false), "aaaa,BBBB,velox");
+
+    auto mapKeys = mapCol->mapKeys()->as<SimpleVector<StringView>>();
+    auto mapValues = mapCol->mapValues()->as<SimpleVector<int64_t>>();
+    EXPECT_EQ(mapKeys->size(), 2);
+    EXPECT_EQ(mapKeys->size(), mapValues->size());
+    EXPECT_EQ(
+        mapCol->toString(0, 2, ",", false),
+        "2 elements starting at 0 {foo => 1, bar => 2}");
+
+    EXPECT_EQ(structCol->size(), 1);
+    EXPECT_EQ(structCol->type()->toString(), "ROW<\"\":BIGINT,\"\":DOUBLE>");
+    EXPECT_EQ(structCol->toString(0, 2, ",", false), "{1, 2}");
+  }
+}
+
+TEST_F(OrcReaderTest, testOrcRlev2) {
+  google::InstallFailureSignalHandler();
+  const std::string dateOrc(getExamplesFilePath("rlev2.orc"));
+  auto schema =
+      ROW({"id", "price", "name"}, {BIGINT(), DECIMAL(7, 2), VARCHAR()});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*schema);
+
+  dwio::common::ReaderOptions readerOpts{pool()};
+  readerOpts.setScanSpec(spec);
+  readerOpts.setFileFormat(dwio::common::FileFormat::ORC);
+
+  auto reader = DwrfReader::create(
+      createFileBufferedInput(dateOrc, readerOpts.memoryPool()), readerOpts);
+
+  RowReaderOptions rowReaderOptions;
+  rowReaderOptions.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  auto batch = BaseVector::create(schema, 0, &readerOpts.memoryPool());
+  while (rowReader->next(500, batch)) {
+    auto rowVector = batch->as<RowVector>();
+    auto idCol =
+        rowVector->childAt(0)->loadedVector()->as<SimpleVector<int64_t>>();
+    auto priceCol =
+        rowVector->childAt(1)->loadedVector()->as<SimpleVector<int64_t>>();
+    auto nameCol =
+        rowVector->childAt(2)->loadedVector()->as<SimpleVector<StringView>>();
+
+    EXPECT_EQ(5, rowVector->size());
+    EXPECT_EQ(idCol->valueAt(0), 1);
+
+    auto priceColType = rowVector->type()->childAt(1);
+    EXPECT_EQ(
+        DecimalUtil::toString(priceCol->valueAt(0), priceColType), "111.11");
+    EXPECT_EQ(nameCol->valueAt(0), "AAAA");
+  }
+}
diff --git a/velox/dwio/dwrf/test/examples/TestOrcFile.testDate1900.orc b/velox/dwio/orc/test/examples/TestOrcFile.testDate1900.orc
similarity index 100%
rename from velox/dwio/dwrf/test/examples/TestOrcFile.testDate1900.orc
rename to velox/dwio/orc/test/examples/TestOrcFile.testDate1900.orc
diff --git a/velox/dwio/dwrf/test/examples/TestStringDictionary.testRowIndex.orc b/velox/dwio/orc/test/examples/TestStringDictionary.testRowIndex.orc
similarity index 100%
rename from velox/dwio/dwrf/test/examples/TestStringDictionary.testRowIndex.orc
rename to velox/dwio/orc/test/examples/TestStringDictionary.testRowIndex.orc
diff --git a/velox/dwio/dwrf/test/examples/complextypes_iceberg.orc b/velox/dwio/orc/test/examples/complextypes_iceberg.orc
similarity index 100%
rename from velox/dwio/dwrf/test/examples/complextypes_iceberg.orc
rename to velox/dwio/orc/test/examples/complextypes_iceberg.orc
diff --git a/velox/dwio/orc/test/examples/orc_all_type.orc b/velox/dwio/orc/test/examples/orc_all_type.orc
new file mode 100644
index 0000000000000..d7691975fb033
Binary files /dev/null and b/velox/dwio/orc/test/examples/orc_all_type.orc differ
diff --git a/velox/dwio/dwrf/test/examples/orc_index_int_string.orc b/velox/dwio/orc/test/examples/orc_index_int_string.orc
similarity index 100%
rename from velox/dwio/dwrf/test/examples/orc_index_int_string.orc
rename to velox/dwio/orc/test/examples/orc_index_int_string.orc
diff --git a/velox/dwio/orc/test/examples/rlev2.orc b/velox/dwio/orc/test/examples/rlev2.orc
new file mode 100644
index 0000000000000..bbb1c7fdafcb2
Binary files /dev/null and b/velox/dwio/orc/test/examples/rlev2.orc differ
diff --git a/velox/dwio/parquet/CMakeLists.txt b/velox/dwio/parquet/CMakeLists.txt
index c14149c7eb6b8..8a6d3034f3c13 100644
--- a/velox/dwio/parquet/CMakeLists.txt
+++ b/velox/dwio/parquet/CMakeLists.txt
@@ -14,6 +14,7 @@
 
 if(VELOX_ENABLE_PARQUET)
   add_subdirectory(thrift)
+  add_subdirectory(common)
   add_subdirectory(reader)
   add_subdirectory(writer)
 
@@ -22,12 +23,12 @@ if(VELOX_ENABLE_PARQUET)
   endif()
 endif()
 
-add_library(velox_dwio_parquet_reader RegisterParquetReader.cpp)
-add_library(velox_dwio_parquet_writer RegisterParquetWriter.cpp)
+velox_add_library(velox_dwio_parquet_reader RegisterParquetReader.cpp)
+velox_add_library(velox_dwio_parquet_writer RegisterParquetWriter.cpp)
 
 if(VELOX_ENABLE_PARQUET)
-  target_link_libraries(velox_dwio_parquet_reader
-                        velox_dwio_native_parquet_reader xsimd)
-  target_link_libraries(velox_dwio_parquet_writer
-                        velox_dwio_arrow_parquet_writer)
+  velox_link_libraries(velox_dwio_parquet_reader
+                       velox_dwio_native_parquet_reader xsimd)
+  velox_link_libraries(velox_dwio_parquet_writer
+                       velox_dwio_arrow_parquet_writer)
 endif()
diff --git a/velox/dwio/parquet/RegisterParquetReader.cpp b/velox/dwio/parquet/RegisterParquetReader.cpp
index da8afaa5dd8ef..2f4cc94b81fec 100644
--- a/velox/dwio/parquet/RegisterParquetReader.cpp
+++ b/velox/dwio/parquet/RegisterParquetReader.cpp
@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 
-#include "velox/dwio/parquet/RegisterParquetReader.h"
-
 #ifdef VELOX_ENABLE_PARQUET
-#include "velox/dwio/parquet/reader/ParquetReader.h"
+#include "velox/dwio/parquet/reader/ParquetReader.h" // @manual
 #endif
 
 namespace facebook::velox::parquet {
diff --git a/velox/dwio/parquet/RegisterParquetWriter.cpp b/velox/dwio/parquet/RegisterParquetWriter.cpp
index d0d3e4825386c..1d6c0e0333572 100644
--- a/velox/dwio/parquet/RegisterParquetWriter.cpp
+++ b/velox/dwio/parquet/RegisterParquetWriter.cpp
@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 
-#include "velox/dwio/parquet/RegisterParquetWriter.h"
-
 #ifdef VELOX_ENABLE_PARQUET
-#include "velox/dwio/parquet/writer/Writer.h"
+#include "velox/dwio/parquet/writer/Writer.h" // @manual
 #endif
 
 namespace facebook::velox::parquet {
diff --git a/velox/dwio/parquet/common/BloomFilter.cpp b/velox/dwio/parquet/common/BloomFilter.cpp
new file mode 100644
index 0000000000000..17a01674f08f4
--- /dev/null
+++ b/velox/dwio/parquet/common/BloomFilter.cpp
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#include "velox/dwio/parquet/common/BloomFilter.h"
+#include "velox/dwio/parquet/common/XxHasher.h"
+#include "velox/dwio/parquet/thrift/ThriftTransport.h"
+
+#include <thrift/protocol/TCompactProtocol.h>
+#include <thrift/transport/TBufferTransports.h>
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+
+namespace facebook::velox::parquet {
+
+constexpr uint32_t BlockSplitBloomFilter::SALT[kBitsSetPerBlock];
+
+BlockSplitBloomFilter::BlockSplitBloomFilter(memory::MemoryPool* pool)
+    : pool_(pool),
+      hashStrategy_(HashStrategy::XXHASH),
+      algorithm_(Algorithm::BLOCK),
+      compressionStrategy_(CompressionStrategy::UNCOMPRESSED) {}
+
+void BlockSplitBloomFilter::init(uint32_t numBytes) {
+  if (numBytes < kMinimumBloomFilterBytes) {
+    numBytes = kMinimumBloomFilterBytes;
+  }
+
+  // Get next power of 2 if it is not power of 2.
+  if ((numBytes & (numBytes - 1)) != 0) {
+    numBytes = static_cast<uint32_t>(bits::nextPowerOfTwo(numBytes));
+  }
+
+  if (numBytes > kMaximumBloomFilterBytes) {
+    numBytes = kMaximumBloomFilterBytes;
+  }
+
+  numBytes_ = numBytes;
+  data_ = AlignedBuffer::allocate<char>(numBytes_, pool_);
+  memset(data_->asMutable<char>(), 0, numBytes_);
+
+  this->hasher_ = std::make_unique<XxHasher>();
+}
+
+void BlockSplitBloomFilter::init(const uint8_t* bitset, uint32_t numBytes) {
+  VELOX_CHECK(bitset != nullptr);
+
+  if (numBytes < kMinimumBloomFilterBytes ||
+      numBytes > kMaximumBloomFilterBytes || (numBytes & (numBytes - 1)) != 0) {
+    VELOX_FAIL("Given length of bitset is illegal");
+  }
+
+  numBytes_ = numBytes;
+  data_ = AlignedBuffer::allocate<char>(numBytes_, pool_);
+  memcpy(data_->asMutable<char>(), bitset, numBytes_);
+
+  this->hasher_ = std::make_unique<XxHasher>();
+}
+
+static void validateBloomFilterHeader(const thrift::BloomFilterHeader& header) {
+  std::stringstream error;
+  if (!header.algorithm.__isset.BLOCK) {
+    error << "Unsupported Bloom filter algorithm: ";
+    error << header.algorithm;
+    VELOX_FAIL(error.str());
+  }
+
+  if (!header.hash.__isset.XXHASH) {
+    error << "Unsupported Bloom filter hash: ", error << header.hash;
+    VELOX_FAIL(error.str());
+  }
+
+  if (!header.compression.__isset.UNCOMPRESSED) {
+    error << "Unsupported Bloom filter compression: ",
+        error << header.compression;
+    VELOX_FAIL(error.str());
+  }
+
+  if (header.numBytes <= 0 ||
+      static_cast<uint32_t>(header.numBytes) >
+          BloomFilter::kMaximumBloomFilterBytes) {
+    error << "Bloom filter size is incorrect: " << header.numBytes
+          << ". Must be in range (" << 0 << ", "
+          << BloomFilter::kMaximumBloomFilterBytes << "].";
+    VELOX_FAIL(error.str());
+  }
+}
+
+BlockSplitBloomFilter BlockSplitBloomFilter::deserialize(
+    dwio::common::SeekableInputStream* input,
+    memory::MemoryPool& pool) {
+  const void* headerBuffer;
+  int32_t size;
+  input->Next(&headerBuffer, &size);
+  const char* bufferStart = reinterpret_cast<const char*>(headerBuffer);
+  const char* bufferEnd = bufferStart + size;
+
+  std::shared_ptr<thrift::ThriftTransport> transport =
+      std::make_shared<thrift::ThriftStreamingTransport>(
+          input, bufferStart, bufferEnd);
+  apache::thrift::protocol::TCompactProtocolT<thrift::ThriftTransport> protocol(
+      transport);
+  thrift::BloomFilterHeader header;
+  uint32_t headerSize = header.read(&protocol);
+  validateBloomFilterHeader(header);
+
+  const int32_t bloomFilterSize = header.numBytes;
+  if (bloomFilterSize + headerSize <= size) {
+    // The bloom filter data is entirely contained in the buffer we just read
+    // => just return it.
+    BlockSplitBloomFilter bloomFilter(&pool);
+    bloomFilter.init(
+        reinterpret_cast<const uint8_t*>(headerBuffer) + headerSize,
+        bloomFilterSize);
+    return bloomFilter;
+  }
+  // We have read a part of the bloom filter already, copy it to the target
+  // buffer and read the remaining part from the InputStream.
+  auto buffer = AlignedBuffer::allocate<char>(bloomFilterSize, &pool);
+
+  const auto bloomFilterSizeInHeaderBuffer = size - headerSize;
+  if (bloomFilterSizeInHeaderBuffer > 0) {
+    std::memcpy(
+        buffer->asMutable<char>(),
+        reinterpret_cast<const uint8_t*>(headerBuffer) + headerSize,
+        bloomFilterSizeInHeaderBuffer);
+  }
+  const auto requiredReadSize = bloomFilterSize - bloomFilterSizeInHeaderBuffer;
+
+  input->readFully(
+      buffer->asMutable<char>() + bloomFilterSizeInHeaderBuffer,
+      requiredReadSize);
+  VELOX_CHECK_EQ(
+      buffer->size(),
+      bloomFilterSize,
+      "Bloom Filter read failed: not enough data, read size: {}, actual size: {}",
+      buffer->size(),
+      bloomFilterSize);
+  BlockSplitBloomFilter bloomFilter(&pool);
+  bloomFilter.init(
+      reinterpret_cast<const uint8_t*>(buffer->as<char>()), bloomFilterSize);
+  return bloomFilter;
+}
+
+void BlockSplitBloomFilter::writeTo(
+    velox::dwio::common::AppendOnlyBufferedStream* sink) const {
+  VELOX_CHECK(sink != nullptr);
+
+  thrift::BloomFilterHeader header;
+  if (algorithm_ != BloomFilter::Algorithm::BLOCK) {
+    VELOX_FAIL("BloomFilter does not support Algorithm other than BLOCK");
+  }
+  header.algorithm.__set_BLOCK(thrift::SplitBlockAlgorithm());
+  if (hashStrategy_ != HashStrategy::XXHASH) {
+    VELOX_FAIL("BloomFilter does not support Hash other than XXHASH");
+  }
+  header.hash.__set_XXHASH(thrift::XxHash());
+  if (compressionStrategy_ != CompressionStrategy::UNCOMPRESSED) {
+    VELOX_FAIL(
+        "BloomFilter does not support Compression other than UNCOMPRESSED");
+  }
+  header.compression.__set_UNCOMPRESSED(thrift::Uncompressed());
+  header.__set_numBytes(numBytes_);
+
+  std::shared_ptr<apache::thrift::transport::TMemoryBuffer> memBuffer =
+      std::make_shared<apache::thrift::transport::TMemoryBuffer>();
+  apache::thrift::protocol::TCompactProtocolFactoryT<
+      apache::thrift::transport::TMemoryBuffer>
+      factory;
+  std::shared_ptr<apache::thrift::protocol::TProtocol> protocol =
+      factory.getProtocol(memBuffer);
+  try {
+    memBuffer->resetBuffer();
+    header.write(protocol.get());
+  } catch (std::exception& e) {
+    std::stringstream ss;
+    ss << "Couldn't serialize thrift: " << e.what() << "\n";
+    VELOX_FAIL(ss.str());
+  }
+  uint8_t* outBuffer;
+  uint32_t outLength;
+  memBuffer->getBuffer(&outBuffer, &outLength);
+  // write header
+  sink->write(reinterpret_cast<const char*>(outBuffer), outLength);
+  // write bitset
+  sink->write(data_->as<char>(), numBytes_);
+}
+
+bool BlockSplitBloomFilter::findHash(uint64_t hash) const {
+  const uint32_t bucketIndex = static_cast<uint32_t>(
+      ((hash >> 32) * (numBytes_ / kBytesPerFilterBlock)) >> 32);
+  const uint32_t key = static_cast<uint32_t>(hash);
+  const uint32_t* bitset32 =
+      reinterpret_cast<const uint32_t*>(data_->as<char>());
+
+  for (int i = 0; i < kBitsSetPerBlock; ++i) {
+    // Calculate mask for key in the given bitset.
+    const uint32_t mask = UINT32_C(0x1) << ((key * SALT[i]) >> 27);
+    if (0 == (bitset32[kBitsSetPerBlock * bucketIndex + i] & mask)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void BlockSplitBloomFilter::insertHashImpl(uint64_t hash) {
+  const uint32_t bucketIndex = static_cast<uint32_t>(
+      ((hash >> 32) * (numBytes_ / kBytesPerFilterBlock)) >> 32);
+  const uint32_t key = static_cast<uint32_t>(hash);
+  uint32_t* bitset32 = reinterpret_cast<uint32_t*>(data_->asMutable<char>());
+
+  for (int i = 0; i < kBitsSetPerBlock; i++) {
+    // Calculate mask for key in the given bitset.
+    const uint32_t mask = UINT32_C(0x1) << ((key * SALT[i]) >> 27);
+    bitset32[bucketIndex * kBitsSetPerBlock + i] |= mask;
+  }
+}
+
+void BlockSplitBloomFilter::insertHash(uint64_t hash) {
+  insertHashImpl(hash);
+}
+
+void BlockSplitBloomFilter::insertHashes(
+    const uint64_t* hashes,
+    int numValues) {
+  for (int i = 0; i < numValues; ++i) {
+    insertHashImpl(hashes[i]);
+  }
+}
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/common/BloomFilter.h b/velox/dwio/parquet/common/BloomFilter.h
new file mode 100644
index 0000000000000..c2a5e97aec9f1
--- /dev/null
+++ b/velox/dwio/parquet/common/BloomFilter.h
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#pragma once
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/dwio/common/BufferedInput.h"
+#include "velox/dwio/common/OutputStream.h"
+#include "velox/dwio/parquet/common/Hasher.h"
+#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
+
+#include <cmath>
+#include <cstdint>
+#include <memory>
+
+namespace facebook::velox::parquet {
+
+// A Bloom filter is a compact structure to indicate whether an item is not in a
+// set or probably in a set. The Bloom filter usually consists of a bit set that
+// represents a set of elements, a hash strategy and a Bloom filter algorithm.
+class BloomFilter {
+ public:
+  // Maximum Bloom filter size, it sets to HDFS default block size 128MB
+  // This value will be reconsidered when implementing Bloom filter producer.
+  static constexpr uint32_t kMaximumBloomFilterBytes = 128 * 1024 * 1024;
+
+  /// Determine whether an element exist in set or not.
+  ///
+  /// @param hash the element to contain.
+  /// @return false if value is definitely not in set, and true means PROBABLY
+  /// in set.
+  virtual bool findHash(uint64_t hash) const = 0;
+
+  /// Insert element to set represented by Bloom filter bitset.
+  /// @param hash the hash of value to insert into Bloom filter.
+  virtual void insertHash(uint64_t hash) = 0;
+
+  /// Insert elements to set represented by Bloom filter bitset.
+  /// @param hashes the hash values to insert into Bloom filter.
+  /// @param num_values the number of hash values to insert.
+  virtual void insertHashes(const uint64_t* hashes, int numValues) = 0;
+
+  /// Write this Bloom filter to an output stream. A Bloom filter structure
+  /// should include bitset length, hash strategy, algorithm, and bitset.
+  ///
+  /// @param sink the output stream to write
+  virtual void writeTo(
+      velox::dwio::common::AppendOnlyBufferedStream* sink) const = 0;
+
+  /// Get the number of bytes of bitset
+  virtual uint32_t getBitsetSize() const = 0;
+
+  /// Compute hash for 32 bits value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(int32_t value) const = 0;
+
+  /// Compute hash for 64 bits value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(int64_t value) const = 0;
+
+  /// Compute hash for float value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(float value) const = 0;
+
+  /// Compute hash for double value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(double value) const = 0;
+
+  /// Compute hash for bytearray by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(const ByteArray* value) const = 0;
+
+  /// Batch compute hashes for 32 bits values by using its plain encoding
+  /// result.
+  ///
+  /// @param values values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const int32_t* values, int numValues, uint64_t* hashes)
+      const = 0;
+
+  /// Batch compute hashes for 64 bits values by using its plain encoding
+  /// result.
+  ///
+  /// @param values values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const int64_t* values, int numValues, uint64_t* hashes)
+      const = 0;
+
+  /// Batch compute hashes for float values by using its plain encoding result.
+  ///
+  /// @param values values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const float* values, int numValues, uint64_t* hashes)
+      const = 0;
+
+  /// Batch compute hashes for double values by using its plain encoding result.
+  ///
+  /// @param values values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const double* values, int numValues, uint64_t* hashes)
+      const = 0;
+
+  /// Batch compute hashes for bytearray values by using its plain encoding
+  /// result.
+  ///
+  /// @param values values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const ByteArray* values, int numValues, uint64_t* hashes)
+      const = 0;
+
+  virtual ~BloomFilter() = default;
+
+ protected:
+  // Hash strategy available for Bloom filter.
+  enum class HashStrategy : uint32_t { XXHASH = 0 };
+
+  // Bloom filter algorithm.
+  enum class Algorithm : uint32_t { BLOCK = 0 };
+
+  enum class CompressionStrategy : uint32_t { UNCOMPRESSED = 0 };
+};
+
+/// The BlockSplitBloomFilter is implemented using block-based Bloom filters
+/// from Putze et al.'s "Cache-,Hash- and Space-Efficient Bloom filters". The
+/// basic idea is to hash the item to a tiny Bloom filter which size fit a
+/// single cache line or smaller.
+///
+/// This implementation sets 8 bits in each tiny Bloom filter. Each tiny Bloom
+/// filter is 32 bytes to take advantage of 32-byte SIMD instructions.
+class BlockSplitBloomFilter : public BloomFilter {
+ public:
+  /// The constructor of BlockSplitBloomFilter. It uses XXH64 as hash function.
+  ///
+  /// @param pool memory pool to use.
+  explicit BlockSplitBloomFilter(memory::MemoryPool* pool);
+
+  /// Initialize the BlockSplitBloomFilter. The range of num_bytes should be
+  /// within [kMinimumBloomFilterBytes, kMaximumBloomFilterBytes], it will be
+  /// rounded up/down to lower/upper bound if num_bytes is out of range and also
+  /// will be rounded up to a power of 2.
+  ///
+  /// @param num_bytes The number of bytes to store Bloom filter bitset.
+  void init(uint32_t numBytes);
+
+  /// Initialize the BlockSplitBloomFilter. It copies the bitset as underlying
+  /// bitset because the given bitset may not satisfy the 32-byte alignment
+  /// requirement which may lead to segfault when performing SIMD instructions.
+  /// It is the caller's responsibility to free the bitset passed in. This is
+  /// used when reconstructing a Bloom filter from a parquet file.
+  ///
+  /// @param bitset The given bitset to initialize the Bloom filter.
+  /// @param num_bytes  The number of bytes of given bitset.
+  void init(const uint8_t* bitset, uint32_t numBytes);
+
+  /// Minimum Bloom filter size, it sets to 32 bytes to fit a tiny Bloom filter.
+  static constexpr uint32_t kMinimumBloomFilterBytes = 32;
+
+  /// Calculate optimal size according to the number of distinct values and
+  /// false positive probability.
+  ///
+  /// @param ndv The number of distinct values.
+  /// @param fpp The false positive probability.
+  /// @return it always return a value between kMinimumBloomFilterBytes and
+  /// kMaximumBloomFilterBytes, and the return value is always a power of 2
+  static uint32_t optimalNumOfBytes(uint32_t ndv, double fpp) {
+    uint32_t optimalNumBits = optimalNumOfBits(ndv, fpp);
+    VELOX_CHECK(optimalNumBits % 8 == 0);
+    return optimalNumBits >> 3;
+  }
+
+  /// Calculate optimal size according to the number of distinct values and
+  /// false positive probability.
+  ///
+  /// @param ndv The number of distinct values.
+  /// @param fpp The false positive probability.
+  /// @return it always return a value between kMinimumBloomFilterBytes * 8 and
+  /// kMaximumBloomFilterBytes * 8, and the return value is always a power of 16
+  static uint32_t optimalNumOfBits(uint32_t ndv, double fpp) {
+    VELOX_CHECK(fpp > 0.0 && fpp < 1.0);
+    const double m = -8.0 * ndv / log(1 - pow(fpp, 1.0 / 8));
+    uint32_t numBits;
+
+    // Handle overflow.
+    if (m < 0 || m > kMaximumBloomFilterBytes << 3) {
+      numBits = static_cast<uint32_t>(kMaximumBloomFilterBytes << 3);
+    } else {
+      numBits = static_cast<uint32_t>(m);
+    }
+
+    // Round up to lower bound
+    if (numBits < kMinimumBloomFilterBytes << 3) {
+      numBits = kMinimumBloomFilterBytes << 3;
+    }
+
+    // Get next power of 2 if bits is not power of 2.
+    if ((numBits & (numBits - 1)) != 0) {
+      numBits = static_cast<uint32_t>(bits::nextPowerOfTwo(numBits));
+    }
+
+    // Round down to upper bound
+    if (numBits > kMaximumBloomFilterBytes << 3) {
+      numBits = kMaximumBloomFilterBytes << 3;
+    }
+
+    return numBits;
+  }
+
+  bool findHash(uint64_t hash) const override;
+  void insertHash(uint64_t hash) override;
+  void insertHashes(const uint64_t* hashes, int numValues) override;
+  void writeTo(
+      velox::dwio::common::AppendOnlyBufferedStream* sink) const override;
+  uint32_t getBitsetSize() const override {
+    return numBytes_;
+  }
+
+  uint64_t hash(int32_t value) const override {
+    return hasher_->hash(value);
+  }
+  uint64_t hash(int64_t value) const override {
+    return hasher_->hash(value);
+  }
+  uint64_t hash(float value) const override {
+    return hasher_->hash(value);
+  }
+  uint64_t hash(double value) const override {
+    return hasher_->hash(value);
+  }
+  uint64_t hash(const ByteArray* value) const override {
+    return hasher_->hash(value);
+  }
+
+  void hashes(const int32_t* values, int numValues, uint64_t* hashes)
+      const override {
+    hasher_->hashes(values, numValues, hashes);
+  }
+  void hashes(const int64_t* values, int numValues, uint64_t* hashes)
+      const override {
+    hasher_->hashes(values, numValues, hashes);
+  }
+  void hashes(const float* values, int numValues, uint64_t* hashes)
+      const override {
+    hasher_->hashes(values, numValues, hashes);
+  }
+  void hashes(const double* values, int numValues, uint64_t* hashes)
+      const override {
+    hasher_->hashes(values, numValues, hashes);
+  }
+  void hashes(const ByteArray* values, int numValues, uint64_t* hashes)
+      const override {
+    hasher_->hashes(values, numValues, hashes);
+  }
+
+  uint64_t hash(const int32_t* value) const {
+    return hasher_->hash(*value);
+  }
+  uint64_t hash(const int64_t* value) const {
+    return hasher_->hash(*value);
+  }
+  uint64_t hash(const float* value) const {
+    return hasher_->hash(*value);
+  }
+  uint64_t hash(const double* value) const {
+    return hasher_->hash(*value);
+  }
+
+  /// Deserialize the Bloom filter from an input stream. It is used when
+  /// reconstructing a Bloom filter from a parquet filter.
+  ///
+  /// @param input_stream The input stream from which to construct the Bloom
+  /// filter.
+  /// @return The BlockSplitBloomFilter.
+  static BlockSplitBloomFilter deserialize(
+      dwio::common::SeekableInputStream* input_stream,
+      memory::MemoryPool& pool);
+
+ private:
+  inline void insertHashImpl(uint64_t hash);
+
+  // Bytes in a tiny Bloom filter block.
+  static constexpr int kBytesPerFilterBlock = 32;
+
+  // The number of bits to be set in each tiny Bloom filter
+  static constexpr int kBitsSetPerBlock = 8;
+
+  // A mask structure used to set bits in each tiny Bloom filter.
+  struct BlockMask {
+    uint32_t item[kBitsSetPerBlock];
+  };
+
+  // The block-based algorithm needs eight odd SALT values to calculate eight
+  // indexes of bit to set, one bit in each 32-bit word.
+  static constexpr uint32_t SALT[kBitsSetPerBlock] = {
+      0x47b6137bU,
+      0x44974d91U,
+      0x8824ad5bU,
+      0xa2b7289dU,
+      0x705495c7U,
+      0x2df1424bU,
+      0x9efc4947U,
+      0x5c6bfb31U};
+
+  // Memory pool to allocate aligned buffer for bitset
+  memory::MemoryPool* pool_;
+
+  // The underlying buffer of bitset.
+  BufferPtr data_;
+
+  // The number of bytes of Bloom filter bitset.
+  uint32_t numBytes_;
+
+  // Hash strategy used in this Bloom filter.
+  HashStrategy hashStrategy_;
+
+  // Algorithm used in this Bloom filter.
+  Algorithm algorithm_;
+
+  // Compression used in this Bloom filter.
+  CompressionStrategy compressionStrategy_;
+
+  // The hash pointer points to actual hash class used.
+  std::unique_ptr<Hasher> hasher_;
+};
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/common/CMakeLists.txt b/velox/dwio/parquet/common/CMakeLists.txt
new file mode 100644
index 0000000000000..cbffcbd7eee62
--- /dev/null
+++ b/velox/dwio/parquet/common/CMakeLists.txt
@@ -0,0 +1,27 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_dwio_native_parquet_common BloomFilter.cpp XxHasher.cpp)
+
+target_link_libraries(
+  velox_dwio_native_parquet_common
+  velox_dwio_parquet_thrift
+  velox_type
+  velox_dwio_common
+  velox_dwio_common_compression
+  fmt::fmt
+  arrow
+  Snappy::snappy
+  thrift
+  zstd::zstd)
diff --git a/velox/dwio/parquet/common/Hasher.h b/velox/dwio/parquet/common/Hasher.h
new file mode 100644
index 0000000000000..3f3a907d06b41
--- /dev/null
+++ b/velox/dwio/parquet/common/Hasher.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace facebook::velox::parquet {
+
+struct ByteArray {
+  ByteArray() : len(0), ptr(nullptr) {}
+  ByteArray(uint32_t len, const uint8_t* ptr) : len(len), ptr(ptr) {}
+
+  ByteArray(::std::string_view view) // NOLINT implicit conversion
+      : ByteArray(
+            static_cast<uint32_t>(view.size()),
+            reinterpret_cast<const uint8_t*>(view.data())) {}
+
+  explicit operator std::string_view() const {
+    return std::string_view{reinterpret_cast<const char*>(ptr), len};
+  }
+
+  uint32_t len;
+  const uint8_t* ptr;
+};
+
+// Abstract class for hash
+class Hasher {
+ public:
+  /// Compute hash for 32 bits value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(int32_t value) const = 0;
+
+  /// Compute hash for 64 bits value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(int64_t value) const = 0;
+
+  /// Compute hash for float value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(float value) const = 0;
+
+  /// Compute hash for double value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(double value) const = 0;
+
+  /// Compute hash for ByteArray value by using its plain encoding result.
+  ///
+  /// @param value the value to hash.
+  /// @return hash result.
+  virtual uint64_t hash(const ByteArray* value) const = 0;
+
+  /// Batch compute hashes for 32 bits values by using its plain encoding
+  /// result.
+  ///
+  /// @param values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const int32_t* values, int num_values, uint64_t* hashes)
+      const = 0;
+
+  /// Batch compute hashes for 64 bits values by using its plain encoding
+  /// result.
+  ///
+  /// @param values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const int64_t* values, int num_values, uint64_t* hashes)
+      const = 0;
+
+  /// Batch compute hashes for float values by using its plain encoding result.
+  ///
+  /// @param values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const float* values, int num_values, uint64_t* hashes)
+      const = 0;
+
+  /// Batch compute hashes for double values by using its plain encoding result.
+  ///
+  /// @param values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const double* values, int num_values, uint64_t* hashes)
+      const = 0;
+
+  /// Batch compute hashes for ByteArray values by using its plain encoding
+  /// result.
+  ///
+  /// @param values a pointer to the values to hash.
+  /// @param num_values the number of values to hash.
+  /// @param hashes a pointer to the output hash values, its length should be
+  /// equal to num_values.
+  virtual void hashes(const ByteArray* values, int num_values, uint64_t* hashes)
+      const = 0;
+
+  virtual ~Hasher() = default;
+};
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/common/XxHasher.cpp b/velox/dwio/parquet/common/XxHasher.cpp
new file mode 100644
index 0000000000000..255f62c6253cc
--- /dev/null
+++ b/velox/dwio/parquet/common/XxHasher.cpp
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#include "XxHasher.h"
+
+#define XXH_INLINE_ALL
+#include <external/xxhash/xxhash.h>
+
+namespace facebook::velox::parquet {
+
+namespace {
+template <typename T>
+uint64_t XxHashHelper(T value, uint32_t seed) {
+  return XXH64(reinterpret_cast<const void*>(&value), sizeof(T), seed);
+}
+
+template <typename T>
+void XxHashesHelper(
+    const T* values,
+    uint32_t seed,
+    int numValues,
+    uint64_t* results) {
+  for (int i = 0; i < numValues; ++i) {
+    results[i] = XxHashHelper(values[i], seed);
+  }
+}
+
+} // namespace
+
+uint64_t XxHasher::hash(int32_t value) const {
+  return XxHashHelper(value, kParquetBloomXxHashSeed);
+}
+
+uint64_t XxHasher::hash(int64_t value) const {
+  return XxHashHelper(value, kParquetBloomXxHashSeed);
+}
+
+uint64_t XxHasher::hash(float value) const {
+  return XxHashHelper(value, kParquetBloomXxHashSeed);
+}
+
+uint64_t XxHasher::hash(double value) const {
+  return XxHashHelper(value, kParquetBloomXxHashSeed);
+}
+
+uint64_t XxHasher::hash(const ByteArray* value) const {
+  return XXH64(
+      reinterpret_cast<const void*>(value->ptr),
+      value->len,
+      kParquetBloomXxHashSeed);
+}
+
+void XxHasher::hashes(const int32_t* values, int numValues, uint64_t* hashes)
+    const {
+  XxHashesHelper(values, kParquetBloomXxHashSeed, numValues, hashes);
+}
+
+void XxHasher::hashes(const int64_t* values, int numValues, uint64_t* hashes)
+    const {
+  XxHashesHelper(values, kParquetBloomXxHashSeed, numValues, hashes);
+}
+
+void XxHasher::hashes(const float* values, int numValues, uint64_t* hashes)
+    const {
+  XxHashesHelper(values, kParquetBloomXxHashSeed, numValues, hashes);
+}
+
+void XxHasher::hashes(const double* values, int numValues, uint64_t* hashes)
+    const {
+  XxHashesHelper(values, kParquetBloomXxHashSeed, numValues, hashes);
+}
+
+void XxHasher::hashes(const ByteArray* values, int numValues, uint64_t* hashes)
+    const {
+  for (int i = 0; i < numValues; ++i) {
+    hashes[i] = XXH64(
+        reinterpret_cast<const void*>(values[i].ptr),
+        values[i].len,
+        kParquetBloomXxHashSeed);
+  }
+}
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/common/XxHasher.h b/velox/dwio/parquet/common/XxHasher.h
new file mode 100644
index 0000000000000..07c37f762f36e
--- /dev/null
+++ b/velox/dwio/parquet/common/XxHasher.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#pragma once
+
+#include <cstdint>
+
+#include "Hasher.h"
+
+namespace facebook::velox::parquet {
+
+class XxHasher : public Hasher {
+ public:
+  uint64_t hash(int32_t value) const override;
+  uint64_t hash(int64_t value) const override;
+  uint64_t hash(float value) const override;
+  uint64_t hash(double value) const override;
+  uint64_t hash(const ByteArray* value) const override;
+
+  void hashes(const int32_t* values, int numValues, uint64_t* hashes)
+      const override;
+  void hashes(const int64_t* values, int numValues, uint64_t* hashes)
+      const override;
+  void hashes(const float* values, int numValues, uint64_t* hashes)
+      const override;
+  void hashes(const double* values, int numValues, uint64_t* hashes)
+      const override;
+  virtual void hashes(const ByteArray* values, int numValues, uint64_t* hashes)
+      const override;
+
+  static constexpr int kParquetBloomXxHashSeed = 0;
+};
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/BooleanColumnReader.h b/velox/dwio/parquet/reader/BooleanColumnReader.h
index 7ba526e13c552..1c2cd43a4706d 100644
--- a/velox/dwio/parquet/reader/BooleanColumnReader.h
+++ b/velox/dwio/parquet/reader/BooleanColumnReader.h
@@ -25,15 +25,15 @@ class BooleanColumnReader : public dwio::common::SelectiveByteRleColumnReader {
  public:
   using ValueType = bool;
   BooleanColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      std::shared_ptr<const dwio::common::TypeWithId> dataType,
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       ParquetParams& params,
       common::ScanSpec& scanSpec)
       : SelectiveByteRleColumnReader(
-            requestedType->type(),
+            requestedType,
+            std::move(fileType),
             params,
-            scanSpec,
-            std::move(dataType)) {}
+            scanSpec) {}
 
   void seekToRowGroup(uint32_t index) override {
     SelectiveByteRleColumnReader::seekToRowGroup(index);
@@ -47,14 +47,16 @@ class BooleanColumnReader : public dwio::common::SelectiveByteRleColumnReader {
     return numValues;
   }
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override {
-    readCommon<BooleanColumnReader>(offset, rows, incomingNulls);
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override {
+    readCommon<BooleanColumnReader, true>(offset, rows, incomingNulls);
     readOffset_ += rows.back() + 1;
   }
 
   template <typename ColumnVisitor>
-  void readWithVisitor(RowSet rows, ColumnVisitor visitor) {
+  void readWithVisitor(const RowSet& /*rows*/, ColumnVisitor visitor) {
     formatData_->as<ParquetData>().readWithVisitor(visitor);
   }
 };
diff --git a/velox/dwio/parquet/reader/BooleanDecoder.h b/velox/dwio/parquet/reader/BooleanDecoder.h
index aeb493f00c053..b22cfe7f60e4b 100644
--- a/velox/dwio/parquet/reader/BooleanDecoder.h
+++ b/velox/dwio/parquet/reader/BooleanDecoder.h
@@ -20,7 +20,7 @@ namespace facebook::velox::parquet {
 
 class BooleanDecoder {
  public:
-  BooleanDecoder(const char* FOLLY_NONNULL start, const char* FOLLY_NONNULL end)
+  BooleanDecoder(const char* start, const char* end)
       : bufferStart_(start), bufferEnd_(end) {}
 
   void skip(uint64_t numValues) {
@@ -28,10 +28,7 @@ class BooleanDecoder {
   }
 
   template <bool hasNulls>
-  inline void skip(
-      int32_t numValues,
-      int32_t current,
-      const uint64_t* FOLLY_NULLABLE nulls) {
+  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
     if (hasNulls) {
       numValues = bits::countNonNulls(nulls, current, current + numValues);
     }
@@ -102,8 +99,8 @@ class BooleanDecoder {
 
   size_t remainingBits_{0};
   uint8_t reversedLastByte_{0};
-  const char* FOLLY_NONNULL bufferStart_{nullptr};
-  const char* FOLLY_NONNULL bufferEnd_{nullptr};
+  const char* bufferStart_{nullptr};
+  const char* bufferEnd_{nullptr};
 };
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/CMakeLists.txt b/velox/dwio/parquet/reader/CMakeLists.txt
index dbf1e3f71d820..6c7b243ec1761 100644
--- a/velox/dwio/parquet/reader/CMakeLists.txt
+++ b/velox/dwio/parquet/reader/CMakeLists.txt
@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(
   velox_dwio_native_parquet_reader
+  Metadata.cpp
   NestedStructureDecoder.cpp
   ParquetReader.cpp
   ParquetTypeWithId.cpp
@@ -22,20 +23,17 @@ add_library(
   ParquetData.cpp
   RepeatedColumnReader.cpp
   RleBpDecoder.cpp
-  Statistics.cpp
   StructColumnReader.cpp
   StringColumnReader.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_dwio_native_parquet_reader
   velox_dwio_parquet_thrift
   velox_type
   velox_dwio_common
   velox_dwio_common_compression
   fmt::fmt
-  parquet
   arrow
   Snappy::snappy
   thrift
-  zstd::zstd
-  ${Protobuf_LIBRARIES})
+  zstd::zstd)
diff --git a/velox/dwio/parquet/reader/DeltaBpDecoder.h b/velox/dwio/parquet/reader/DeltaBpDecoder.h
new file mode 100644
index 0000000000000..f2833bbf80a6e
--- /dev/null
+++ b/velox/dwio/parquet/reader/DeltaBpDecoder.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::parquet {
+
+// DeltaBpDecoder is adapted from Apache Arrow:
+// https://github.com/apache/arrow/blob/apache-arrow-12.0.0/cpp/src/parquet/encoding.cc#LL2357C18-L2586C3
+class DeltaBpDecoder {
+ public:
+  explicit DeltaBpDecoder(const char* start) : bufferStart_(start) {
+    initHeader();
+  }
+
+  void skip(uint64_t numValues) {
+    skip<false>(numValues, 0, nullptr);
+  }
+
+  template <bool hasNulls>
+  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
+    if (hasNulls) {
+      numValues = bits::countNonNulls(nulls, current, current + numValues);
+    }
+    for (int32_t i = 0; i < numValues; ++i) {
+      readLong();
+    }
+  }
+
+  template <bool hasNulls, typename Visitor>
+  void readWithVisitor(const uint64_t* nulls, Visitor visitor) {
+    int32_t current = visitor.start();
+    skip<hasNulls>(current, 0, nulls);
+    int32_t toSkip;
+    bool atEnd = false;
+    const bool allowNulls = hasNulls && visitor.allowNulls();
+    for (;;) {
+      if (hasNulls && allowNulls && bits::isBitNull(nulls, current)) {
+        toSkip = visitor.processNull(atEnd);
+      } else {
+        if (hasNulls && !allowNulls) {
+          toSkip = visitor.checkAndSkipNulls(nulls, current, atEnd);
+          if (!Visitor::dense) {
+            skip<false>(toSkip, current, nullptr);
+          }
+          if (atEnd) {
+            return;
+          }
+        }
+
+        // We are at a non-null value on a row to visit.
+        toSkip = visitor.process(readLong(), atEnd);
+      }
+      ++current;
+      if (toSkip) {
+        skip<hasNulls>(toSkip, current, nulls);
+        current += toSkip;
+      }
+      if (atEnd) {
+        return;
+      }
+    }
+  }
+
+  const char* bufferStart() {
+    return bufferStart_;
+  }
+
+  int64_t validValuesCount() {
+    return static_cast<int64_t>(totalValuesRemaining_);
+  }
+
+ private:
+  bool getVlqInt(uint64_t& v) {
+    uint64_t tmp = 0;
+    for (int i = 0; i < folly::kMaxVarintLength64; i++) {
+      uint8_t byte = *(bufferStart_++);
+      tmp |= static_cast<uint64_t>(byte & 0x7F) << (7 * i);
+      if ((byte & 0x80) == 0) {
+        v = tmp;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool getZigZagVlqInt(int64_t& v) {
+    uint64_t u;
+    if (!getVlqInt(u)) {
+      return false;
+    }
+    v = (u >> 1) ^ (~(u & 1) + 1);
+    return true;
+  }
+
+  void initHeader() {
+    if (!getVlqInt(valuesPerBlock_) || !getVlqInt(miniBlocksPerBlock_) ||
+        !getVlqInt(totalValueCount_) || !getZigZagVlqInt(lastValue_)) {
+      VELOX_FAIL("initHeader EOF");
+    }
+
+    VELOX_CHECK_GT(valuesPerBlock_, 0, "cannot have zero value per block");
+    VELOX_CHECK_EQ(
+        valuesPerBlock_ % 128,
+        0,
+        "the number of values in a block must be multiple of 128, but it's " +
+            std::to_string(valuesPerBlock_));
+    VELOX_CHECK_GT(
+        miniBlocksPerBlock_, 0, "cannot have zero miniblock per block");
+    valuesPerMiniBlock_ = valuesPerBlock_ / miniBlocksPerBlock_;
+    VELOX_CHECK_GT(
+        valuesPerMiniBlock_, 0, "cannot have zero value per miniblock");
+    VELOX_CHECK_EQ(
+        valuesPerMiniBlock_ % 32,
+        0,
+        "the number of values in a miniblock must be multiple of 32, but it's " +
+            std::to_string(valuesPerMiniBlock_));
+
+    totalValuesRemaining_ = totalValueCount_;
+    deltaBitWidths_.resize(miniBlocksPerBlock_);
+    firstBlockInitialized_ = false;
+    valuesRemainingCurrentMiniBlock_ = 0;
+  }
+
+  void initBlock() {
+    VELOX_DCHECK_GT(totalValuesRemaining_, 0, "initBlock called at EOF");
+
+    if (!getZigZagVlqInt(minDelta_)) {
+      VELOX_FAIL("initBlock EOF");
+    }
+
+    // read the bitwidth of each miniblock
+    for (uint32_t i = 0; i < miniBlocksPerBlock_; ++i) {
+      deltaBitWidths_[i] = *(bufferStart_++);
+      // Note that non-conformant bitwidth entries are allowed by the Parquet
+      // spec for extraneous miniblocks in the last block (GH-14923), so we
+      // check the bitwidths when actually using them (see initMiniBlock()).
+    }
+
+    miniBlockIdx_ = 0;
+    firstBlockInitialized_ = true;
+    initMiniBlock(deltaBitWidths_[0]);
+  }
+
+  void initMiniBlock(int32_t bitWidth) {
+    VELOX_DCHECK_LE(
+        bitWidth,
+        kMaxDeltaBitWidth,
+        "delta bit width larger than integer bit width");
+    deltaBitWidth_ = bitWidth;
+    valuesRemainingCurrentMiniBlock_ = valuesPerMiniBlock_;
+  }
+
+  int64_t readLong() {
+    int64_t value = 0;
+    if (valuesRemainingCurrentMiniBlock_ == 0) {
+      if (!firstBlockInitialized_) {
+        value = lastValue_;
+        // When block is uninitialized we have two different possibilities:
+        // 1. totalValueCount_ == 1, which means that the page may have only
+        // one value (encoded in the header), and we should not initialize
+        // any block.
+        // 2. totalValueCount_ != 1, which means we should initialize the
+        // incoming block for subsequent reads.
+        if (totalValueCount_ != 1) {
+          initBlock();
+        }
+        totalValuesRemaining_--;
+        return value;
+      } else {
+        ++miniBlockIdx_;
+        if (miniBlockIdx_ < miniBlocksPerBlock_) {
+          initMiniBlock(deltaBitWidths_[miniBlockIdx_]);
+        } else {
+          initBlock();
+        }
+      }
+    }
+
+    uint64_t consumedBits =
+        (valuesPerMiniBlock_ - valuesRemainingCurrentMiniBlock_) *
+        deltaBitWidth_;
+    bits::copyBits(
+        reinterpret_cast<const uint64_t*>(bufferStart_),
+        consumedBits,
+        reinterpret_cast<uint64_t*>(&value),
+        0,
+        deltaBitWidth_);
+    // Addition between minDelta_, packed int and lastValue_ should be treated
+    // as unsigned addition. Overflow is as expected.
+    value = static_cast<uint64_t>(minDelta_) + static_cast<uint64_t>(value) +
+        static_cast<uint64_t>(lastValue_);
+    lastValue_ = value;
+    valuesRemainingCurrentMiniBlock_--;
+    totalValuesRemaining_--;
+
+    if (valuesRemainingCurrentMiniBlock_ == 0 || totalValuesRemaining_ == 0) {
+      bufferStart_ += bits::nbytes(deltaBitWidth_ * valuesPerMiniBlock_);
+    }
+    return value;
+  }
+
+  static constexpr int kMaxDeltaBitWidth =
+      static_cast<int>(sizeof(int64_t) * 8);
+
+  const char* bufferStart_;
+
+  uint64_t valuesPerBlock_;
+  uint64_t miniBlocksPerBlock_;
+  uint64_t valuesPerMiniBlock_;
+  uint64_t totalValueCount_;
+
+  uint64_t totalValuesRemaining_;
+  // Remaining values in current mini block. If the current block is the last
+  // mini block, valuesRemainingCurrentMiniBlock_ may greater than
+  // totalValuesRemaining_.
+  uint64_t valuesRemainingCurrentMiniBlock_;
+
+  // If the page doesn't contain any block, `firstBlockInitialized_` will
+  // always be false. Otherwise, it will be true when first block initialized.
+  bool firstBlockInitialized_;
+  int64_t minDelta_;
+  uint64_t miniBlockIdx_;
+  std::vector<uint8_t> deltaBitWidths_;
+  uint64_t deltaBitWidth_;
+
+  int64_t lastValue_;
+};
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/FloatingPointColumnReader.h b/velox/dwio/parquet/reader/FloatingPointColumnReader.h
index 8a50f0af24f4a..66487e1da9387 100644
--- a/velox/dwio/parquet/reader/FloatingPointColumnReader.h
+++ b/velox/dwio/parquet/reader/FloatingPointColumnReader.h
@@ -32,7 +32,7 @@ class FloatingPointColumnReader
 
   FloatingPointColumnReader(
       const TypePtr& requestedType,
-      std::shared_ptr<const dwio::common::TypeWithId> dataType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       ParquetParams& params,
       common::ScanSpec& scanSpec);
 
@@ -45,26 +45,28 @@ class FloatingPointColumnReader
 
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override {
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override {
     using T = FloatingPointColumnReader<TData, TRequested>;
-    this->template readCommon<T>(offset, rows, incomingNulls);
+    this->template readCommon<T, true>(offset, rows, incomingNulls);
     this->readOffset_ += rows.back() + 1;
   }
 
   template <typename TVisitor>
-  void readWithVisitor(RowSet rows, TVisitor visitor);
+  void readWithVisitor(const RowSet& rows, TVisitor visitor);
 };
 
 template <typename TData, typename TRequested>
 FloatingPointColumnReader<TData, TRequested>::FloatingPointColumnReader(
     const TypePtr& requestedType,
-    std::shared_ptr<const dwio::common::TypeWithId> dataType,
+    std::shared_ptr<const dwio::common::TypeWithId> fileType,
     ParquetParams& params,
     common::ScanSpec& scanSpec)
     : dwio::common::SelectiveFloatingPointColumnReader<TData, TRequested>(
           requestedType,
-          std::move(dataType),
+          std::move(fileType),
           params,
           scanSpec) {}
 
@@ -77,7 +79,7 @@ uint64_t FloatingPointColumnReader<TData, TRequested>::skip(
 template <typename TData, typename TRequested>
 template <typename TVisitor>
 void FloatingPointColumnReader<TData, TRequested>::readWithVisitor(
-    RowSet rows,
+    const RowSet& rows,
     TVisitor visitor) {
   this->formatData_->template as<ParquetData>().readWithVisitor(visitor);
 }
diff --git a/velox/dwio/parquet/reader/IntegerColumnReader.h b/velox/dwio/parquet/reader/IntegerColumnReader.h
index e36d9d6327b1d..4568e9ba2d445 100644
--- a/velox/dwio/parquet/reader/IntegerColumnReader.h
+++ b/velox/dwio/parquet/reader/IntegerColumnReader.h
@@ -17,25 +17,25 @@
 #pragma once
 
 #include "velox/dwio/common/SelectiveIntegerColumnReader.h"
-#include "velox/dwio/parquet/reader/ParquetColumnReader.h"
 
 namespace facebook::velox::parquet {
 
 class IntegerColumnReader : public dwio::common::SelectiveIntegerColumnReader {
  public:
   IntegerColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      std::shared_ptr<const dwio::common::TypeWithId> dataType,
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
       ParquetParams& params,
       common::ScanSpec& scanSpec)
       : SelectiveIntegerColumnReader(
-            requestedType->type(),
+            requestedType,
             params,
             scanSpec,
-            std::move(dataType)) {}
+            std::move(fileType)) {}
 
   bool hasBulkPath() const override {
-    return !this->fileType().type()->isLongDecimal() &&
+    return !formatData_->as<ParquetData>().isDeltaBinaryPacked() &&
+        !this->fileType().type()->isLongDecimal() &&
         ((this->fileType().type()->isShortDecimal())
              ? formatData_->as<ParquetData>().hasDictionary()
              : true);
@@ -53,9 +53,20 @@ class IntegerColumnReader : public dwio::common::SelectiveIntegerColumnReader {
     return numValues;
   }
 
+  void getValues(const RowSet& rows, VectorPtr* result) override {
+    auto& fileType = static_cast<const ParquetTypeWithId&>(*fileType_);
+    auto logicalType = fileType.logicalType_;
+    if (logicalType.has_value() && logicalType.value().__isset.INTEGER &&
+        !logicalType.value().INTEGER.isSigned) {
+      getUnsignedIntValues(rows, requestedType_, result);
+    } else {
+      getIntValues(rows, requestedType_, result);
+    }
+  }
+
   void read(
       vector_size_t offset,
-      RowSet rows,
+      const RowSet& rows,
       const uint64_t* /*incomingNulls*/) override {
     auto& data = formatData_->as<ParquetData>();
     VELOX_WIDTH_DISPATCH(
@@ -64,12 +75,12 @@ class IntegerColumnReader : public dwio::common::SelectiveIntegerColumnReader {
         offset,
         rows,
         nullptr);
-    readCommon<IntegerColumnReader>(rows);
+    readCommon<IntegerColumnReader, true>(rows);
     readOffset_ += rows.back() + 1;
   }
 
   template <typename ColumnVisitor>
-  void readWithVisitor(RowSet rows, ColumnVisitor visitor) {
+  void readWithVisitor(const RowSet& rows, ColumnVisitor visitor) {
     formatData_->as<ParquetData>().readWithVisitor(visitor);
   }
 };
diff --git a/velox/dwio/parquet/reader/Metadata.cpp b/velox/dwio/parquet/reader/Metadata.cpp
new file mode 100644
index 0000000000000..771e68e8a5959
--- /dev/null
+++ b/velox/dwio/parquet/reader/Metadata.cpp
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/parquet/reader/Metadata.h"
+#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
+
+namespace facebook::velox::parquet {
+
+template <typename T>
+inline const T load(const char* ptr) {
+  T ret;
+  std::memcpy(&ret, ptr, sizeof(ret));
+  return ret;
+}
+
+template <typename T>
+inline std::optional<T> getMin(const thrift::Statistics& columnChunkStats) {
+  return columnChunkStats.__isset.min_value
+      ? load<T>(columnChunkStats.min_value.data())
+      : (columnChunkStats.__isset.min
+             ? std::optional<T>(load<T>(columnChunkStats.min.data()))
+             : std::nullopt);
+}
+
+template <typename T>
+inline std::optional<T> getMax(const thrift::Statistics& columnChunkStats) {
+  return columnChunkStats.__isset.max_value
+      ? std::optional<T>(load<T>(columnChunkStats.max_value.data()))
+      : (columnChunkStats.__isset.max
+             ? std::optional<T>(load<T>(columnChunkStats.max.data()))
+             : std::nullopt);
+}
+
+template <>
+inline std::optional<std::string> getMin(
+    const thrift::Statistics& columnChunkStats) {
+  return columnChunkStats.__isset.min_value
+      ? std::optional(columnChunkStats.min_value)
+      : (columnChunkStats.__isset.min ? std::optional(columnChunkStats.min)
+                                      : std::nullopt);
+}
+
+template <>
+inline std::optional<std::string> getMax(
+    const thrift::Statistics& columnChunkStats) {
+  return columnChunkStats.__isset.max_value
+      ? std::optional(columnChunkStats.max_value)
+      : (columnChunkStats.__isset.max ? std::optional(columnChunkStats.max)
+                                      : std::nullopt);
+}
+
+std::unique_ptr<dwio::common::ColumnStatistics> buildColumnStatisticsFromThrift(
+    const thrift::Statistics& columnChunkStats,
+    const velox::Type& type,
+    uint64_t numRowsInRowGroup) {
+  std::optional<uint64_t> nullCount = columnChunkStats.__isset.null_count
+      ? std::optional<uint64_t>(columnChunkStats.null_count)
+      : std::nullopt;
+  std::optional<uint64_t> valueCount = nullCount.has_value()
+      ? std::optional<uint64_t>(numRowsInRowGroup - nullCount.value())
+      : std::nullopt;
+  std::optional<bool> hasNull = columnChunkStats.__isset.null_count
+      ? std::optional<bool>(columnChunkStats.null_count > 0)
+      : std::nullopt;
+
+  switch (type.kind()) {
+    case TypeKind::BOOLEAN:
+      return std::make_unique<dwio::common::BooleanColumnStatistics>(
+          valueCount, hasNull, std::nullopt, std::nullopt, std::nullopt);
+    case TypeKind::TINYINT:
+      return std::make_unique<dwio::common::IntegerColumnStatistics>(
+          valueCount,
+          hasNull,
+          std::nullopt,
+          std::nullopt,
+          getMin<int8_t>(columnChunkStats),
+          getMax<int8_t>(columnChunkStats),
+          std::nullopt);
+    case TypeKind::SMALLINT:
+      return std::make_unique<dwio::common::IntegerColumnStatistics>(
+          valueCount,
+          hasNull,
+          std::nullopt,
+          std::nullopt,
+          getMin<int16_t>(columnChunkStats),
+          getMax<int16_t>(columnChunkStats),
+          std::nullopt);
+    case TypeKind::INTEGER:
+      return std::make_unique<dwio::common::IntegerColumnStatistics>(
+          valueCount,
+          hasNull,
+          std::nullopt,
+          std::nullopt,
+          getMin<int32_t>(columnChunkStats),
+          getMax<int32_t>(columnChunkStats),
+          std::nullopt);
+    case TypeKind::BIGINT:
+      return std::make_unique<dwio::common::IntegerColumnStatistics>(
+          valueCount,
+          hasNull,
+          std::nullopt,
+          std::nullopt,
+          getMin<int64_t>(columnChunkStats),
+          getMax<int64_t>(columnChunkStats),
+          std::nullopt);
+    case TypeKind::REAL:
+      return std::make_unique<dwio::common::DoubleColumnStatistics>(
+          valueCount,
+          hasNull,
+          std::nullopt,
+          std::nullopt,
+          getMin<float>(columnChunkStats),
+          getMax<float>(columnChunkStats),
+          std::nullopt);
+    case TypeKind::DOUBLE:
+      return std::make_unique<dwio::common::DoubleColumnStatistics>(
+          valueCount,
+          hasNull,
+          std::nullopt,
+          std::nullopt,
+          getMin<double>(columnChunkStats),
+          getMax<double>(columnChunkStats),
+          std::nullopt);
+    case TypeKind::VARCHAR:
+    case TypeKind::VARBINARY:
+      return std::make_unique<dwio::common::StringColumnStatistics>(
+          valueCount,
+          hasNull,
+          std::nullopt,
+          std::nullopt,
+          getMin<std::string>(columnChunkStats),
+          getMax<std::string>(columnChunkStats),
+          std::nullopt);
+
+    default:
+      return std::make_unique<dwio::common::ColumnStatistics>(
+          valueCount, hasNull, std::nullopt, std::nullopt);
+  }
+}
+
+common::CompressionKind thriftCodecToCompressionKind(
+    thrift::CompressionCodec::type codec) {
+  switch (codec) {
+    case thrift::CompressionCodec::UNCOMPRESSED:
+      return common::CompressionKind::CompressionKind_NONE;
+      break;
+    case thrift::CompressionCodec::SNAPPY:
+      return common::CompressionKind::CompressionKind_SNAPPY;
+      break;
+    case thrift::CompressionCodec::GZIP:
+      return common::CompressionKind::CompressionKind_GZIP;
+      break;
+    case thrift::CompressionCodec::LZO:
+      return common::CompressionKind::CompressionKind_LZO;
+      break;
+    case thrift::CompressionCodec::LZ4:
+      return common::CompressionKind::CompressionKind_LZ4;
+      break;
+    case thrift::CompressionCodec::ZSTD:
+      return common::CompressionKind::CompressionKind_ZSTD;
+      break;
+    case thrift::CompressionCodec::LZ4_RAW:
+      return common::CompressionKind::CompressionKind_LZ4;
+    default:
+      VELOX_UNSUPPORTED(
+          "Unsupported compression type: " +
+          facebook::velox::parquet::thrift::to_string(codec));
+      break;
+  }
+}
+
+ColumnChunkMetaDataPtr::ColumnChunkMetaDataPtr(const void* metadata)
+    : ptr_(metadata) {}
+
+ColumnChunkMetaDataPtr::~ColumnChunkMetaDataPtr() = default;
+
+FOLLY_ALWAYS_INLINE const thrift::ColumnChunk* thriftColumnChunkPtr(
+    const void* metadata) {
+  return reinterpret_cast<const thrift::ColumnChunk*>(metadata);
+}
+
+int64_t ColumnChunkMetaDataPtr::numValues() const {
+  return thriftColumnChunkPtr(ptr_)->meta_data.num_values;
+}
+
+bool ColumnChunkMetaDataPtr::hasMetadata() const {
+  return thriftColumnChunkPtr(ptr_)->__isset.meta_data;
+}
+
+bool ColumnChunkMetaDataPtr::hasStatistics() const {
+  return hasMetadata() &&
+      thriftColumnChunkPtr(ptr_)->meta_data.__isset.statistics;
+}
+
+bool ColumnChunkMetaDataPtr::hasDictionaryPageOffset() const {
+  return hasMetadata() &&
+      thriftColumnChunkPtr(ptr_)->meta_data.__isset.dictionary_page_offset;
+}
+
+std::unique_ptr<dwio::common::ColumnStatistics>
+ColumnChunkMetaDataPtr::getColumnStatistics(
+    const TypePtr type,
+    int64_t numRows) {
+  VELOX_CHECK(hasStatistics());
+  return buildColumnStatisticsFromThrift(
+      thriftColumnChunkPtr(ptr_)->meta_data.statistics, *type, numRows);
+};
+
+int64_t ColumnChunkMetaDataPtr::dataPageOffset() const {
+  return thriftColumnChunkPtr(ptr_)->meta_data.data_page_offset;
+}
+
+int64_t ColumnChunkMetaDataPtr::dictionaryPageOffset() const {
+  VELOX_CHECK(hasDictionaryPageOffset());
+  return thriftColumnChunkPtr(ptr_)->meta_data.dictionary_page_offset;
+}
+
+common::CompressionKind ColumnChunkMetaDataPtr::compression() const {
+  return thriftCodecToCompressionKind(
+      thriftColumnChunkPtr(ptr_)->meta_data.codec);
+}
+
+int64_t ColumnChunkMetaDataPtr::totalCompressedSize() const {
+  return thriftColumnChunkPtr(ptr_)->meta_data.total_compressed_size;
+}
+
+int64_t ColumnChunkMetaDataPtr::totalUncompressedSize() const {
+  return thriftColumnChunkPtr(ptr_)->meta_data.total_uncompressed_size;
+}
+
+FOLLY_ALWAYS_INLINE const thrift::RowGroup* thriftRowGroupPtr(
+    const void* metadata) {
+  return reinterpret_cast<const thrift::RowGroup*>(metadata);
+}
+
+RowGroupMetaDataPtr::RowGroupMetaDataPtr(const void* metadata)
+    : ptr_(metadata) {}
+
+RowGroupMetaDataPtr::~RowGroupMetaDataPtr() = default;
+
+int RowGroupMetaDataPtr::numColumns() const {
+  return thriftRowGroupPtr(ptr_)->columns.size();
+}
+
+int64_t RowGroupMetaDataPtr::numRows() const {
+  return thriftRowGroupPtr(ptr_)->num_rows;
+}
+
+int64_t RowGroupMetaDataPtr::totalByteSize() const {
+  return thriftRowGroupPtr(ptr_)->total_byte_size;
+}
+
+bool RowGroupMetaDataPtr::hasFileOffset() const {
+  return thriftRowGroupPtr(ptr_)->__isset.file_offset;
+}
+
+int64_t RowGroupMetaDataPtr::fileOffset() const {
+  return thriftRowGroupPtr(ptr_)->file_offset;
+}
+
+bool RowGroupMetaDataPtr::hasTotalCompressedSize() const {
+  return thriftRowGroupPtr(ptr_)->__isset.total_compressed_size;
+}
+
+int64_t RowGroupMetaDataPtr::totalCompressedSize() const {
+  return thriftRowGroupPtr(ptr_)->total_compressed_size;
+}
+
+ColumnChunkMetaDataPtr RowGroupMetaDataPtr::columnChunk(int i) const {
+  return ColumnChunkMetaDataPtr(
+      reinterpret_cast<const void*>(&thriftRowGroupPtr(ptr_)->columns[i]));
+}
+
+FOLLY_ALWAYS_INLINE const thrift::FileMetaData* thriftFileMetaDataPtr(
+    const void* metadata) {
+  return reinterpret_cast<const thrift::FileMetaData*>(metadata);
+}
+
+FileMetaDataPtr::FileMetaDataPtr(const void* metadata) : ptr_(metadata) {}
+
+FileMetaDataPtr::~FileMetaDataPtr() = default;
+
+RowGroupMetaDataPtr FileMetaDataPtr::rowGroup(int i) const {
+  return RowGroupMetaDataPtr(reinterpret_cast<const void*>(
+      &thriftFileMetaDataPtr(ptr_)->row_groups[i]));
+}
+
+int64_t FileMetaDataPtr::numRows() const {
+  return thriftFileMetaDataPtr(ptr_)->num_rows;
+}
+
+int FileMetaDataPtr::numRowGroups() const {
+  return thriftFileMetaDataPtr(ptr_)->row_groups.size();
+}
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/Metadata.h b/velox/dwio/parquet/reader/Metadata.h
new file mode 100644
index 0000000000000..f99d46656d8ca
--- /dev/null
+++ b/velox/dwio/parquet/reader/Metadata.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/dwio/common/Statistics.h"
+#include "velox/dwio/common/compression/Compression.h"
+
+namespace facebook::velox::parquet {
+
+/// ColumnChunkMetaDataPtr is a proxy around pointer to thrift::ColumnChunk.
+class ColumnChunkMetaDataPtr {
+ public:
+  explicit ColumnChunkMetaDataPtr(const void* metadata);
+
+  ~ColumnChunkMetaDataPtr();
+
+  /// Check the presence of ColumnChunk metadata.
+  bool hasMetadata() const;
+
+  /// Check the presence of statistics in the ColumnChunk metadata.
+  bool hasStatistics() const;
+
+  /// Check the presence of the dictionary page offset in ColumnChunk metadata.
+  bool hasDictionaryPageOffset() const;
+
+  /// Return the ColumnChunk statistics.
+  std::unique_ptr<dwio::common::ColumnStatistics> getColumnStatistics(
+      const TypePtr type,
+      int64_t numRows);
+
+  /// Number of values.
+  int64_t numValues() const;
+
+  /// The data page offset.
+  int64_t dataPageOffset() const;
+
+  /// The dictionary page offset.
+  /// Must check for its presence using hasDictionaryPageOffset().
+  int64_t dictionaryPageOffset() const;
+
+  /// The compression.
+  common::CompressionKind compression() const;
+
+  /// Total byte size of all the compressed (and potentially encrypted)
+  /// column data in this row group.
+  /// This information is optional and may be 0 if omitted.
+  int64_t totalCompressedSize() const;
+
+  /// Total byte size of all the uncompressed (and potentially encrypted)
+  /// column data in this row group.
+  /// This information is optional and may be 0 if omitted.
+  int64_t totalUncompressedSize() const;
+
+ private:
+  const void* ptr_;
+};
+
+/// RowGroupMetaDataPtr is a proxy around pointer to thrift::RowGroup.
+class RowGroupMetaDataPtr {
+ public:
+  explicit RowGroupMetaDataPtr(const void* metadata);
+
+  ~RowGroupMetaDataPtr();
+
+  /// The number of columns in this row group. The order must match the
+  /// parent's column ordering.
+  int numColumns() const;
+
+  /// Return the ColumnChunkMetaData pointer of the corresponding column index.
+  ColumnChunkMetaDataPtr columnChunk(int index) const;
+
+  /// Number of rows in this row group.
+  int64_t numRows() const;
+
+  /// Total byte size of all the uncompressed column data in this row
+  /// group.
+  int64_t totalByteSize() const;
+
+  /// Check the presence of file offset.
+  bool hasFileOffset() const;
+
+  /// Byte offset from beginning of file to first page (data or dictionary)
+  /// in this row group
+  int64_t fileOffset() const;
+
+  /// Check the presence of total compressed size.
+  bool hasTotalCompressedSize() const;
+
+  /// Total byte size of all the compressed (and potentially encrypted)
+  /// column data in this row group.
+  /// This information is optional and may be 0 if omitted.
+  int64_t totalCompressedSize() const;
+
+ private:
+  const void* ptr_;
+};
+
+/// FileMetaData is a proxy around pointer to thrift::FileMetaData.
+class FileMetaDataPtr {
+ public:
+  explicit FileMetaDataPtr(const void* metadata);
+
+  ~FileMetaDataPtr();
+
+  /// The total number of rows.
+  int64_t numRows() const;
+
+  /// The number of row groups in the file.
+  int numRowGroups() const;
+
+  /// Return the RowGroupMetaData pointer of the corresponding row group index.
+  RowGroupMetaDataPtr rowGroup(int index) const;
+
+ private:
+  const void* ptr_;
+};
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/NestedStructureDecoder.cpp b/velox/dwio/parquet/reader/NestedStructureDecoder.cpp
index e04f179a17681..97574c3cf43bb 100644
--- a/velox/dwio/parquet/reader/NestedStructureDecoder.cpp
+++ b/velox/dwio/parquet/reader/NestedStructureDecoder.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/dwio/parquet/reader/NestedStructureDecoder.h"
 
-#include "velox/common/base/Exceptions.h"
 #include "velox/dwio/common/BufferUtil.h"
 
 namespace facebook::velox::parquet {
diff --git a/velox/dwio/parquet/reader/PageReader.cpp b/velox/dwio/parquet/reader/PageReader.cpp
index ae3f516bd843f..c185358470e68 100644
--- a/velox/dwio/parquet/reader/PageReader.cpp
+++ b/velox/dwio/parquet/reader/PageReader.cpp
@@ -15,24 +15,27 @@
  */
 
 #include "velox/dwio/parquet/reader/PageReader.h"
-#include "velox/common/compression/LzoDecompressor.h"
+
+#include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/BufferUtil.h"
 #include "velox/dwio/common/ColumnVisitors.h"
-#include "velox/dwio/parquet/reader/NestedStructureDecoder.h"
 #include "velox/dwio/parquet/thrift/ThriftTransport.h"
 #include "velox/vector/FlatVector.h"
 
-#include <lz4.h>
-#include <snappy.h>
-#include <thrift/protocol/TCompactProtocol.h> //@manual
-#include <zlib.h>
-#include <zstd.h>
+#include <thrift/protocol/TCompactProtocol.h> // @manual
+
+using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::parquet {
 
 using thrift::Encoding;
 using thrift::PageHeader;
 
+struct __attribute__((__packed__)) Int96Timestamp {
+  int32_t days;
+  uint64_t nanos;
+};
+
 void PageReader::seekToPage(int64_t row) {
   defineDecoder_.reset();
   repeatDecoder_.reset();
@@ -78,6 +81,8 @@ void PageReader::seekToPage(int64_t row) {
 }
 
 PageHeader PageReader::readPageHeader() {
+  TestValue::adjust(
+      "facebook::velox::parquet::PageReader::readPageHeader", this);
   if (bufferEnd_ == bufferStart_) {
     const void* buffer;
     int32_t size;
@@ -123,119 +128,10 @@ const char* PageReader::readBytes(int32_t size, BufferPtr& copy) {
   return copy->as<char>();
 }
 
-const char* FOLLY_NONNULL decompressLz4AndLzo(
-    const char* compressedData,
-    BufferPtr& decompressedData,
-    uint32_t compressedSize,
-    uint32_t uncompressedSize,
-    memory::MemoryPool& pool,
-    const thrift::CompressionCodec::type codec_) {
-  dwio::common::ensureCapacity<char>(decompressedData, uncompressedSize, &pool);
-
-  uint32_t decompressedTotalLength = 0;
-  auto* inputPtr = compressedData;
-  auto* outPtr = decompressedData->asMutable<char>();
-  uint32_t inputLength = compressedSize;
-
-  while (inputLength > 0) {
-    if (inputLength < sizeof(uint32_t)) {
-      VELOX_FAIL(
-          "{} decompression failed, input len is to small: {}",
-          codec_,
-          inputLength)
-    }
-    uint32_t decompressedBlockLength =
-        folly::Endian::big(folly::loadUnaligned<uint32_t>(inputPtr));
-    inputPtr += dwio::common::INT_BYTE_SIZE;
-    inputLength -= dwio::common::INT_BYTE_SIZE;
-    uint32_t remainingOutputSize = uncompressedSize - decompressedTotalLength;
-    if (remainingOutputSize < decompressedBlockLength) {
-      VELOX_FAIL(
-          "{} decompression failed, remainingOutputSize is less then "
-          "decompressedBlockLength, remainingOutputSize: {}, "
-          "decompressedBlockLength: {}",
-          remainingOutputSize,
-          decompressedBlockLength)
-    }
-    if (inputLength <= 0) {
-      break;
-    }
-
-    do {
-      // Check that input length should not be negative.
-      if (inputLength < sizeof(uint32_t)) {
-        VELOX_FAIL(
-            "{} decompression failed, input len is to small: {}",
-            codec_,
-            inputLength)
-      }
-      // Read the length of the next lz4/lzo compressed block.
-      uint32_t compressedLength =
-          folly::Endian::big(folly::loadUnaligned<uint32_t>(inputPtr));
-      inputPtr += dwio::common::INT_BYTE_SIZE;
-      inputLength -= dwio::common::INT_BYTE_SIZE;
-
-      if (compressedLength == 0) {
-        continue;
-      }
-
-      if (compressedLength > inputLength) {
-        VELOX_FAIL(
-            "{} decompression failed, compressedLength is less then inputLength, "
-            "compressedLength: {}, inputLength: {}",
-            compressedLength,
-            inputLength)
-      }
-
-      // Decompress this block.
-      remainingOutputSize = uncompressedSize - decompressedTotalLength;
-      uint64_t decompressedSize = -1;
-      if (codec_ == thrift::CompressionCodec::LZ4) {
-        decompressedSize = LZ4_decompress_safe(
-            inputPtr,
-            outPtr,
-            static_cast<int32_t>(compressedLength),
-            static_cast<int32_t>(remainingOutputSize));
-      } else if (codec_ == thrift::CompressionCodec::LZO) {
-        decompressedSize = common::compression::lzoDecompress(
-            inputPtr,
-            inputPtr + compressedLength,
-            outPtr,
-            outPtr + remainingOutputSize);
-      } else {
-        VELOX_FAIL("Unsupported Parquet compression type '{}'", codec_);
-      }
-
-      VELOX_CHECK_EQ(decompressedSize, remainingOutputSize);
-
-      outPtr += decompressedSize;
-      inputPtr += compressedLength;
-      inputLength -= compressedLength;
-      decompressedBlockLength -= decompressedSize;
-      decompressedTotalLength += decompressedSize;
-    } while (decompressedBlockLength > 0);
-  }
-
-  VELOX_CHECK_EQ(decompressedTotalLength, uncompressedSize);
-
-  return decompressedData->as<char>();
-}
-
-const char* FOLLY_NONNULL PageReader::decompressData(
+const char* PageReader::decompressData(
     const char* pageData,
     uint32_t compressedSize,
     uint32_t uncompressedSize) {
-  if (codec_ == thrift::CompressionCodec::LZ4 ||
-      codec_ == thrift::CompressionCodec::LZO) {
-    return decompressLz4AndLzo(
-        pageData,
-        decompressedData_,
-        compressedSize,
-        uncompressedSize,
-        pool_,
-        codec_);
-  }
-
   std::unique_ptr<dwio::common::SeekableInputStream> inputStream =
       std::make_unique<dwio::common::SeekableArrayInputStream>(
           pageData, compressedSize, 0);
@@ -243,11 +139,11 @@ const char* FOLLY_NONNULL PageReader::decompressData(
       fmt::format("Page Reader: Stream {}", inputStream_->getName());
   std::unique_ptr<dwio::common::SeekableInputStream> decompressedStream =
       dwio::common::compression::createDecompressor(
-          ThriftCodecToCompressionKind(codec_),
+          codec_,
           std::move(inputStream),
           uncompressedSize,
           pool_,
-          getParquetDecompressionOptions(),
+          getParquetDecompressionOptions(codec_),
           streamDebugInfo,
           nullptr,
           true,
@@ -327,10 +223,10 @@ void PageReader::prepareDataPageV1(const PageHeader& pageHeader, int64_t row) {
   auto pageEnd = pageData_ + pageHeader.uncompressed_page_size;
   if (maxRepeat_ > 0) {
     uint32_t repeatLength = readField<int32_t>(pageData_);
-    repeatDecoder_ = std::make_unique<arrow::util::RleDecoder>(
+    repeatDecoder_ = std::make_unique<::arrow::util::RleDecoder>(
         reinterpret_cast<const uint8_t*>(pageData_),
         repeatLength,
-        arrow::bit_util::NumRequiredBits(maxRepeat_));
+        ::arrow::bit_util::NumRequiredBits(maxRepeat_));
 
     pageData_ += repeatLength;
   }
@@ -341,12 +237,12 @@ void PageReader::prepareDataPageV1(const PageHeader& pageHeader, int64_t row) {
       defineDecoder_ = std::make_unique<RleBpDecoder>(
           pageData_,
           pageData_ + defineLength,
-          arrow::bit_util::NumRequiredBits(maxDefine_));
+          ::arrow::bit_util::NumRequiredBits(maxDefine_));
     }
-    wideDefineDecoder_ = std::make_unique<arrow::util::RleDecoder>(
+    wideDefineDecoder_ = std::make_unique<::arrow::util::RleDecoder>(
         reinterpret_cast<const uint8_t*>(pageData_),
         defineLength,
-        arrow::bit_util::NumRequiredBits(maxDefine_));
+        ::arrow::bit_util::NumRequiredBits(maxDefine_));
     pageData_ += defineLength;
   }
   encodedDataSize_ = pageEnd - pageData_;
@@ -375,32 +271,32 @@ void PageReader::prepareDataPageV2(const PageHeader& pageHeader, int64_t row) {
     return;
   }
 
-  uint32_t defineLength = maxDefine_ > 0
-      ? pageHeader.data_page_header_v2.definition_levels_byte_length
-      : 0;
-  uint32_t repeatLength = maxRepeat_ > 0
-      ? pageHeader.data_page_header_v2.repetition_levels_byte_length
-      : 0;
+  uint32_t defineLength =
+      pageHeader.data_page_header_v2.definition_levels_byte_length;
+  uint32_t repeatLength =
+      pageHeader.data_page_header_v2.repetition_levels_byte_length;
+
   auto bytes = pageHeader.compressed_page_size;
   pageData_ = readBytes(bytes, pageBuffer_);
 
   if (repeatLength) {
-    repeatDecoder_ = std::make_unique<arrow::util::RleDecoder>(
+    repeatDecoder_ = std::make_unique<::arrow::util::RleDecoder>(
         reinterpret_cast<const uint8_t*>(pageData_),
         repeatLength,
-        arrow::bit_util::NumRequiredBits(maxRepeat_));
+        ::arrow::bit_util::NumRequiredBits(maxRepeat_));
   }
 
   if (maxDefine_ > 0) {
     defineDecoder_ = std::make_unique<RleBpDecoder>(
         pageData_ + repeatLength,
         pageData_ + repeatLength + defineLength,
-        arrow::bit_util::NumRequiredBits(maxDefine_));
+        ::arrow::bit_util::NumRequiredBits(maxDefine_));
   }
   auto levelsSize = repeatLength + defineLength;
   pageData_ += levelsSize;
-  if (pageHeader.data_page_header_v2.__isset.is_compressed ||
-      pageHeader.data_page_header_v2.is_compressed) {
+  if (pageHeader.data_page_header_v2.__isset.is_compressed &&
+      pageHeader.data_page_header_v2.is_compressed &&
+      (pageHeader.compressed_page_size - levelsSize > 0)) {
     pageData_ = decompressData(
         pageData_,
         pageHeader.compressed_page_size - levelsSize,
@@ -430,7 +326,7 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       dictionaryEncoding_ == Encoding::PLAIN_DICTIONARY ||
       dictionaryEncoding_ == Encoding::PLAIN);
 
-  if (codec_ != thrift::CompressionCodec::UNCOMPRESSED) {
+  if (codec_ != common::CompressionKind::CompressionKind_NONE) {
     pageData_ = readBytes(pageHeader.compressed_page_size, pageBuffer_);
     pageData_ = decompressData(
         pageData_,
@@ -480,6 +376,42 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       }
       break;
     }
+    case thrift::Type::INT96: {
+      auto numVeloxBytes = dictionary_.numValues * sizeof(Timestamp);
+      dictionary_.values = AlignedBuffer::allocate<char>(numVeloxBytes, &pool_);
+      auto numBytes = dictionary_.numValues * sizeof(Int96Timestamp);
+      if (pageData_) {
+        memcpy(dictionary_.values->asMutable<char>(), pageData_, numBytes);
+      } else {
+        dwio::common::readBytes(
+            numBytes,
+            inputStream_.get(),
+            dictionary_.values->asMutable<char>(),
+            bufferStart_,
+            bufferEnd_);
+      }
+      // Expand the Parquet type length values to Velox type length.
+      // We start from the end to allow in-place expansion.
+      auto values = dictionary_.values->asMutable<Timestamp>();
+      auto parquetValues = dictionary_.values->asMutable<char>();
+
+      for (auto i = dictionary_.numValues - 1; i >= 0; --i) {
+        // Convert the timestamp into seconds and nanos since the Unix epoch,
+        // 00:00:00.000000 on 1 January 1970.
+        int64_t nanos;
+        memcpy(
+            &nanos,
+            parquetValues + i * sizeof(Int96Timestamp),
+            sizeof(int64_t));
+        int32_t days;
+        memcpy(
+            &days,
+            parquetValues + i * sizeof(Int96Timestamp) + sizeof(int64_t),
+            sizeof(int32_t));
+        values[i] = Timestamp::fromDaysAndNanos(days, nanos);
+      }
+      break;
+    }
     case thrift::Type::BYTE_ARRAY: {
       dictionary_.values =
           AlignedBuffer::allocate<StringView>(dictionary_.numValues, &pool_);
@@ -570,7 +502,6 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       VELOX_UNSUPPORTED(
           "Parquet type {} not supported for dictionary", parquetType);
     }
-    case thrift::Type::INT96:
     default:
       VELOX_UNSUPPORTED(
           "Parquet type {} not supported for dictionary", parquetType);
@@ -597,6 +528,8 @@ int32_t parquetTypeBytes(thrift::Type::type type) {
     case thrift::Type::INT64:
     case thrift::Type::DOUBLE:
       return 8;
+    case thrift::Type::INT96:
+      return 12;
     default:
       VELOX_FAIL("Type does not have a byte width {}", type);
   }
@@ -668,14 +601,14 @@ void PageReader::decodeRepDefs(int32_t numTopLevelRows) {
 
 int32_t PageReader::getLengthsAndNulls(
     LevelMode mode,
-    const ::parquet::internal::LevelInfo& info,
+    const arrow::LevelInfo& info,
     int32_t begin,
     int32_t end,
     int32_t maxItems,
     int32_t* lengths,
     uint64_t* nulls,
     int32_t nullsStartIndex) const {
-  ::parquet::internal::ValidityBitmapInputOutput bits;
+  arrow::ValidityBitmapInputOutput bits;
   bits.values_read_upper_bound = maxItems;
   bits.values_read = 0;
   bits.null_count = 0;
@@ -688,7 +621,7 @@ int32_t PageReader::getLengthsAndNulls(
           definitionLevels_.data() + begin, end - begin, info, &bits);
       break;
     case LevelMode::kList: {
-      ::parquet::internal::DefRepLevelsToList(
+      arrow::DefRepLevelsToList(
           definitionLevels_.data() + begin,
           repetitionLevels_.data() + begin,
           end - begin,
@@ -733,12 +666,18 @@ void PageReader::makeDecoder() {
               pageData_, pageData_ + encodedDataSize_);
           break;
         case thrift::Type::FIXED_LEN_BYTE_ARRAY:
-          directDecoder_ = std::make_unique<dwio::common::DirectDecoder<true>>(
-              std::make_unique<dwio::common::SeekableArrayInputStream>(
-                  pageData_, encodedDataSize_),
-              false,
-              type_->typeLength_,
-              true);
+          if (type_->type()->isVarbinary() || type_->type()->isVarchar()) {
+            stringDecoder_ = std::make_unique<StringDecoder>(
+                pageData_, pageData_ + encodedDataSize_, type_->typeLength_);
+          } else {
+            directDecoder_ =
+                std::make_unique<dwio::common::DirectDecoder<true>>(
+                    std::make_unique<dwio::common::SeekableArrayInputStream>(
+                        pageData_, encodedDataSize_),
+                    false,
+                    type_->typeLength_,
+                    true);
+          }
           break;
         default: {
           directDecoder_ = std::make_unique<dwio::common::DirectDecoder<true>>(
@@ -750,6 +689,16 @@ void PageReader::makeDecoder() {
       }
       break;
     case Encoding::DELTA_BINARY_PACKED:
+      switch (parquetType) {
+        case thrift::Type::INT32:
+        case thrift::Type::INT64:
+          deltaBpDecoder_ = std::make_unique<DeltaBpDecoder>(pageData_);
+          break;
+        default:
+          VELOX_UNSUPPORTED(
+              "DELTA_BINARY_PACKED decoder only supports INT32 and INT64");
+      }
+      break;
     default:
       VELOX_UNSUPPORTED("Encoding not supported yet: {}", encoding_);
   }
@@ -770,8 +719,14 @@ void PageReader::skip(int64_t numRows) {
   }
   firstUnvisited_ += numRows;
 
+  if (toSkip == 0) {
+    return;
+  }
   // Skip nulls
   toSkip = skipNulls(toSkip);
+  if (toSkip == 0) {
+    return;
+  }
 
   // Skip the decoder
   if (isDictionary()) {
@@ -782,6 +737,8 @@ void PageReader::skip(int64_t numRows) {
     stringDecoder_->skip(toSkip);
   } else if (booleanDecoder_) {
     booleanDecoder_->skip(toSkip);
+  } else if (deltaBpDecoder_) {
+    deltaBpDecoder_->skip(toSkip);
   } else {
     VELOX_FAIL("No decoder to skip");
   }
diff --git a/velox/dwio/parquet/reader/PageReader.h b/velox/dwio/parquet/reader/PageReader.h
index 2e8c220efe5c8..4813f84d01d48 100644
--- a/velox/dwio/parquet/reader/PageReader.h
+++ b/velox/dwio/parquet/reader/PageReader.h
@@ -16,17 +16,18 @@
 
 #pragma once
 
-#include <arrow/util/rle_encoding.h>
 #include "velox/common/compression/Compression.h"
 #include "velox/dwio/common/BitConcatenation.h"
 #include "velox/dwio/common/DirectDecoder.h"
 #include "velox/dwio/common/SelectiveColumnReader.h"
 #include "velox/dwio/common/compression/Compression.h"
 #include "velox/dwio/parquet/reader/BooleanDecoder.h"
+#include "velox/dwio/parquet/reader/DeltaBpDecoder.h"
 #include "velox/dwio/parquet/reader/ParquetTypeWithId.h"
 #include "velox/dwio/parquet/reader/RleBpDataDecoder.h"
 #include "velox/dwio/parquet/reader/StringDecoder.h"
-#include "velox/vector/BaseVector.h"
+
+#include <arrow/util/rle_encoding.h>
 
 namespace facebook::velox::parquet {
 
@@ -38,18 +39,20 @@ class PageReader {
   PageReader(
       std::unique_ptr<dwio::common::SeekableInputStream> stream,
       memory::MemoryPool& pool,
-      ParquetTypeWithIdPtr nodeType,
-      thrift::CompressionCodec::type codec,
-      int64_t chunkSize)
+      ParquetTypeWithIdPtr fileType,
+      common::CompressionKind codec,
+      int64_t chunkSize,
+      const tz::TimeZone* sessionTimezone)
       : pool_(pool),
         inputStream_(std::move(stream)),
-        type_(std::move(nodeType)),
+        type_(std::move(fileType)),
         maxRepeat_(type_->maxRepeat_),
         maxDefine_(type_->maxDefine_),
         isTopLevel_(maxRepeat_ == 0 && maxDefine_ <= 1),
         codec_(codec),
         chunkSize_(chunkSize),
-        nullConcatenation_(pool_) {
+        nullConcatenation_(pool_),
+        sessionTimezone_(sessionTimezone) {
     type_->makeLevelInfo(leafInfo_);
   }
 
@@ -57,8 +60,9 @@ class PageReader {
   PageReader(
       std::unique_ptr<dwio::common::SeekableInputStream> stream,
       memory::MemoryPool& pool,
-      thrift::CompressionCodec::type codec,
-      int64_t chunkSize)
+      common::CompressionKind codec,
+      int64_t chunkSize,
+      const tz::TimeZone* sessionTimezone = nullptr)
       : pool_(pool),
         inputStream_(std::move(stream)),
         maxRepeat_(0),
@@ -66,46 +70,8 @@ class PageReader {
         isTopLevel_(maxRepeat_ == 0 && maxDefine_ <= 1),
         codec_(codec),
         chunkSize_(chunkSize),
-        nullConcatenation_(pool_) {}
-
-  common::CompressionKind ThriftCodecToCompressionKind(
-      thrift::CompressionCodec::type codec) const {
-    switch (codec) {
-      case thrift::CompressionCodec::UNCOMPRESSED:
-        return common::CompressionKind::CompressionKind_NONE;
-        break;
-      case thrift::CompressionCodec::SNAPPY:
-        return common::CompressionKind::CompressionKind_SNAPPY;
-        break;
-      case thrift::CompressionCodec::GZIP:
-        return common::CompressionKind::CompressionKind_GZIP;
-        break;
-      case thrift::CompressionCodec::LZO:
-        return common::CompressionKind::CompressionKind_LZO;
-        break;
-      case thrift::CompressionCodec::LZ4:
-        return common::CompressionKind::CompressionKind_LZ4;
-        break;
-      case thrift::CompressionCodec::ZSTD:
-        return common::CompressionKind::CompressionKind_ZSTD;
-        break;
-      case thrift::CompressionCodec::LZ4_RAW:
-        return common::CompressionKind::CompressionKind_LZ4;
-      default:
-        VELOX_UNSUPPORTED(
-            "Unsupported compression type: " +
-            facebook::velox::parquet::thrift::to_string(codec));
-        break;
-    }
-  }
-
-  static const dwio::common::compression::CompressionOptions
-  getParquetDecompressionOptions() {
-    dwio::common::compression::CompressionOptions options;
-    options.format.zlib.windowBits =
-        dwio::common::compression::Compressor::PARQUET_ZLIB_WINDOW_BITS;
-    return options;
-  }
+        nullConcatenation_(pool_),
+        sessionTimezone_(sessionTimezone) {}
 
   /// Advances 'numRows' top level rows.
   void skip(int64_t numRows);
@@ -122,12 +88,12 @@ class PageReader {
   /// filled.
   int32_t getLengthsAndNulls(
       LevelMode mode,
-      const ::parquet::internal::LevelInfo& info,
+      const arrow::LevelInfo& info,
       int32_t begin,
       int32_t end,
       int32_t maxItems,
-      int32_t* FOLLY_NULLABLE lengths,
-      uint64_t* FOLLY_NULLABLE nulls,
+      int32_t* lengths,
+      uint64_t* nulls,
       int32_t nullsStartIndex) const;
 
   /// Applies 'visitor' to values in the ColumnChunk of 'this'. The
@@ -161,6 +127,10 @@ class PageReader {
     dictionaryValues_.reset();
   }
 
+  bool isDeltaBinaryPacked() const {
+    return encoding_ == thrift::Encoding::DELTA_BINARY_PACKED;
+  }
+
   /// Returns the range of repdefs for the top level rows covered by the last
   /// decoderepDefs().
   std::pair<int32_t, int32_t> repDefRange() const {
@@ -171,6 +141,10 @@ class PageReader {
   // bufferEnd_ to the corresponding positions.
   thrift::PageHeader readPageHeader();
 
+  const tz::TimeZone* sessionTimezone() const {
+    return sessionTimezone_;
+  }
+
  private:
   // Indicates that we only want the repdefs for the next page. Used when
   // prereading repdefs with seekToPage.
@@ -182,7 +156,7 @@ class PageReader {
 
   // If the current page has nulls, returns a nulls bitmap owned by 'this'. This
   // is filled for 'numRows' bits.
-  const uint64_t* FOLLY_NULLABLE readNulls(int32_t numRows, BufferPtr& buffer);
+  const uint64_t* readNulls(int32_t numRows, BufferPtr& buffer);
 
   // Skips the define decoder, if any, for 'numValues' top level
   // rows. Returns the number of non-nulls skipped. The range is the
@@ -235,13 +209,13 @@ class PageReader {
   // Returns a pointer to contiguous space for the next 'size' bytes
   // from current position. Copies data into 'copy' if the range
   // straddles buffers. Allocates or resizes 'copy' as needed.
-  const char* FOLLY_NONNULL readBytes(int32_t size, BufferPtr& copy);
+  const char* readBytes(int32_t size, BufferPtr& copy);
 
   // Decompresses data starting at 'pageData_', consuming 'compressedsize' and
   // producing up to 'uncompressedSize' bytes. The start of the decoding
   // result is returned. an intermediate copy may be made in 'decompresseddata_'
-  const char* FOLLY_NONNULL decompressData(
-      const char* FOLLY_NONNULL pageData,
+  const char* decompressData(
+      const char* pageData,
       uint32_t compressedSize,
       uint32_t uncompressedSize);
 
@@ -289,10 +263,8 @@ class PageReader {
           !std::is_same_v<typename Visitor::DataType, folly::StringPiece> &&
               !std::is_same_v<typename Visitor::DataType, int8_t>,
           int>::type = 0>
-  void callDecoder(
-      const uint64_t* FOLLY_NULLABLE nulls,
-      bool& nullsFromFastPath,
-      Visitor visitor) {
+  void
+  callDecoder(const uint64_t* nulls, bool& nullsFromFastPath, Visitor visitor) {
     if (nulls) {
       nullsFromFastPath = dwio::common::useFastPath<Visitor, true>(visitor) &&
           (!this->type_->type()->isLongDecimal()) &&
@@ -301,6 +273,9 @@ class PageReader {
       if (isDictionary()) {
         auto dictVisitor = visitor.toDictionaryColumnVisitor();
         dictionaryIdDecoder_->readWithVisitor<true>(nulls, dictVisitor);
+      } else if (encoding_ == thrift::Encoding::DELTA_BINARY_PACKED) {
+        nullsFromFastPath = false;
+        deltaBpDecoder_->readWithVisitor<true>(nulls, visitor);
       } else {
         directDecoder_->readWithVisitor<true>(
             nulls, visitor, nullsFromFastPath);
@@ -309,6 +284,8 @@ class PageReader {
       if (isDictionary()) {
         auto dictVisitor = visitor.toDictionaryColumnVisitor();
         dictionaryIdDecoder_->readWithVisitor<false>(nullptr, dictVisitor);
+      } else if (encoding_ == thrift::Encoding::DELTA_BINARY_PACKED) {
+        deltaBpDecoder_->readWithVisitor<false>(nulls, visitor);
       } else {
         directDecoder_->readWithVisitor<false>(
             nulls, visitor, !this->type_->type()->isShortDecimal());
@@ -321,10 +298,8 @@ class PageReader {
       typename std::enable_if<
           std::is_same_v<typename Visitor::DataType, folly::StringPiece>,
           int>::type = 0>
-  void callDecoder(
-      const uint64_t* FOLLY_NULLABLE nulls,
-      bool& nullsFromFastPath,
-      Visitor visitor) {
+  void
+  callDecoder(const uint64_t* nulls, bool& nullsFromFastPath, Visitor visitor) {
     if (nulls) {
       if (isDictionary()) {
         nullsFromFastPath = dwio::common::useFastPath<Visitor, true>(visitor);
@@ -349,11 +324,9 @@ class PageReader {
       typename std::enable_if<
           std::is_same_v<typename Visitor::DataType, int8_t>,
           int>::type = 0>
-  void callDecoder(
-      const uint64_t* FOLLY_NULLABLE nulls,
-      bool& nullsFromFastPath,
-      Visitor visitor) {
-    VELOX_CHECK(!isDictionary(), "BOOLEAN types are never dictionary-encoded")
+  void
+  callDecoder(const uint64_t* nulls, bool& nullsFromFastPath, Visitor visitor) {
+    VELOX_CHECK(!isDictionary(), "BOOLEAN types are never dictionary-encoded");
     if (nulls) {
       nullsFromFastPath = false;
       booleanDecoder_->readWithVisitor<true>(nulls, visitor);
@@ -383,18 +356,18 @@ class PageReader {
   const int32_t maxDefine_;
   const bool isTopLevel_;
 
-  const thrift::CompressionCodec::type codec_;
+  const common::CompressionKind codec_;
   const int64_t chunkSize_;
-  const char* FOLLY_NULLABLE bufferStart_{nullptr};
-  const char* FOLLY_NULLABLE bufferEnd_{nullptr};
+  const char* bufferStart_{nullptr};
+  const char* bufferEnd_{nullptr};
   BufferPtr tempNulls_;
   BufferPtr nullsInReadRange_;
   BufferPtr multiPageNulls_;
   // Decoder for single bit definition levels. the arrow decoders are used for
   // multibit levels pending fixing RleBpDecoder for the case.
   std::unique_ptr<RleBpDecoder> defineDecoder_;
-  std::unique_ptr<arrow::util::RleDecoder> repeatDecoder_;
-  std::unique_ptr<arrow::util::RleDecoder> wideDefineDecoder_;
+  std::unique_ptr<::arrow::util::RleDecoder> repeatDecoder_;
+  std::unique_ptr<::arrow::util::RleDecoder> wideDefineDecoder_;
 
   // True for a leaf column for which repdefs are loaded for the whole column
   // chunk. This is typically the leaftmost leaf of a list. Other leaves under
@@ -451,7 +424,7 @@ class PageReader {
 
   // First byte of decompressed encoded data. Contains the encoded data as a
   // contiguous run of bytes.
-  const char* FOLLY_NULLABLE pageData_{nullptr};
+  const char* pageData_{nullptr};
 
   // Dictionary contents.
   dwio::common::DictionaryValues dictionary_;
@@ -469,7 +442,7 @@ class PageReader {
   // Below members Keep state between calls to readWithVisitor().
 
   // Original rows in Visitor.
-  const vector_size_t* FOLLY_NULLABLE visitorRows_{nullptr};
+  const vector_size_t* visitorRows_{nullptr};
   int32_t numVisitorRows_{0};
 
   // 'rowOfPage_' at the start of readWithVisitor().
@@ -489,7 +462,7 @@ class PageReader {
 
   //  Temporary for rewriting rows to access in readWithVisitor when moving
   //  between pages. Initialized from the visitor.
-  raw_vector<vector_size_t>* FOLLY_NULLABLE rowsCopy_{nullptr};
+  raw_vector<vector_size_t>* rowsCopy_{nullptr};
 
   // If 'rowsCopy_' is used, this is the difference between the rows in
   // 'rowsCopy_' and the row numbers in 'rows' given to readWithVisitor().
@@ -503,19 +476,38 @@ class PageReader {
   dwio::common::BitConcatenation nullConcatenation_;
 
   // LevelInfo for reading nulls for the leaf column 'this' represents.
-  ::parquet::internal::LevelInfo leafInfo_;
+  arrow::LevelInfo leafInfo_;
 
   // Base values of dictionary when reading a string dictionary.
   VectorPtr dictionaryValues_;
 
+  const tz::TimeZone* sessionTimezone_{nullptr};
+
   // Decoders. Only one will be set at a time.
   std::unique_ptr<dwio::common::DirectDecoder<true>> directDecoder_;
   std::unique_ptr<RleBpDataDecoder> dictionaryIdDecoder_;
   std::unique_ptr<StringDecoder> stringDecoder_;
   std::unique_ptr<BooleanDecoder> booleanDecoder_;
+  std::unique_ptr<DeltaBpDecoder> deltaBpDecoder_;
   // Add decoders for other encodings here.
 };
 
+FOLLY_ALWAYS_INLINE dwio::common::compression::CompressionOptions
+getParquetDecompressionOptions(common::CompressionKind kind) {
+  dwio::common::compression::CompressionOptions options;
+
+  if (kind == common::CompressionKind_ZLIB ||
+      kind == common::CompressionKind_GZIP) {
+    options.format.zlib.windowBits =
+        dwio::common::compression::Compressor::PARQUET_ZLIB_WINDOW_BITS;
+  } else if (
+      kind == common::CompressionKind_LZ4 ||
+      kind == common::CompressionKind_LZO) {
+    options.format.lz4_lzo.isHadoopFrameFormat = true;
+  }
+  return options;
+}
+
 template <typename Visitor>
 void PageReader::readWithVisitor(Visitor& visitor) {
   constexpr bool hasFilter =
@@ -537,6 +529,13 @@ void PageReader::readWithVisitor(Visitor& visitor) {
     visitor.setNumValuesBias(numValuesBeforePage);
     visitor.setRows(pageRows);
     callDecoder(nulls, nullsFromFastPath, visitor);
+    if (encoding_ == thrift::Encoding::DELTA_BINARY_PACKED &&
+        deltaBpDecoder_->validValuesCount() == 0) {
+      VELOX_DCHECK(
+          deltaBpDecoder_->bufferStart() == pageData_ + encodedDataSize_,
+          "Once all data in the delta binary packed decoder has been read, "
+          "its buffer ptr should be moved to the end of the page.");
+    }
     if (currentVisitorRow_ < numVisitorRows_ || isMultiPage) {
       if (mayProduceNulls) {
         if (!isMultiPage) {
diff --git a/velox/dwio/parquet/reader/ParquetColumnReader.cpp b/velox/dwio/parquet/reader/ParquetColumnReader.cpp
index 8f28400da1ad5..a87a295a787cd 100644
--- a/velox/dwio/parquet/reader/ParquetColumnReader.cpp
+++ b/velox/dwio/parquet/reader/ParquetColumnReader.cpp
@@ -19,6 +19,7 @@
 //
 
 #include "velox/dwio/parquet/reader/ParquetColumnReader.h"
+
 #include "velox/dwio/common/SelectiveColumnReaderInternal.h"
 #include "velox/dwio/parquet/reader/BooleanColumnReader.h"
 #include "velox/dwio/parquet/reader/FloatingPointColumnReader.h"
@@ -26,60 +27,62 @@
 #include "velox/dwio/parquet/reader/RepeatedColumnReader.h"
 #include "velox/dwio/parquet/reader/StringColumnReader.h"
 #include "velox/dwio/parquet/reader/StructColumnReader.h"
-
-#include "velox/dwio/parquet/reader/Statistics.h"
-#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
+#include "velox/dwio/parquet/reader/TimestampColumnReader.h"
 
 namespace facebook::velox::parquet {
 
 // static
 std::unique_ptr<dwio::common::SelectiveColumnReader> ParquetColumnReader::build(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     ParquetParams& params,
     common::ScanSpec& scanSpec) {
   auto colName = scanSpec.fieldName();
 
-  switch (dataType->type()->kind()) {
+  switch (fileType->type()->kind()) {
     case TypeKind::INTEGER:
     case TypeKind::BIGINT:
     case TypeKind::SMALLINT:
     case TypeKind::TINYINT:
     case TypeKind::HUGEINT:
       return std::make_unique<IntegerColumnReader>(
-          requestedType, dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
 
     case TypeKind::REAL:
       return std::make_unique<FloatingPointColumnReader<float, float>>(
-          requestedType->type(), dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
     case TypeKind::DOUBLE:
       return std::make_unique<FloatingPointColumnReader<double, double>>(
-          requestedType->type(), dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
 
     case TypeKind::ROW:
       return std::make_unique<StructColumnReader>(
-          requestedType, dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
 
     case TypeKind::VARBINARY:
     case TypeKind::VARCHAR:
-      return std::make_unique<StringColumnReader>(dataType, params, scanSpec);
+      return std::make_unique<StringColumnReader>(fileType, params, scanSpec);
 
     case TypeKind::ARRAY:
       return std::make_unique<ListColumnReader>(
-          requestedType, dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
 
     case TypeKind::MAP:
       return std::make_unique<MapColumnReader>(
-          requestedType, dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
 
     case TypeKind::BOOLEAN:
       return std::make_unique<BooleanColumnReader>(
-          requestedType, dataType, params, scanSpec);
+          requestedType, fileType, params, scanSpec);
+
+    case TypeKind::TIMESTAMP:
+      return std::make_unique<TimestampColumnReader>(
+          requestedType, fileType, params, scanSpec);
 
     default:
       VELOX_FAIL(
           "buildReader unhandled type: " +
-          mapTypeKindToName(dataType->type()->kind()));
+          mapTypeKindToName(fileType->type()->kind()));
   }
 }
 
diff --git a/velox/dwio/parquet/reader/ParquetColumnReader.h b/velox/dwio/parquet/reader/ParquetColumnReader.h
index bd029a0150797..8ff0860294724 100644
--- a/velox/dwio/parquet/reader/ParquetColumnReader.h
+++ b/velox/dwio/parquet/reader/ParquetColumnReader.h
@@ -39,11 +39,11 @@ inline int32_t parquetSizeOfIntKind(TypeKind kind) {
 /// Wrapper for static functions for Parquet columns.
 class ParquetColumnReader {
  public:
-  /// Builds a reader tree producing 'dataType'. The metadata is in 'params'.
+  /// Builds a reader tree producing 'fileType'. The metadata is in 'params'.
   /// The filters and pruning are in 'scanSpec'.
   static std::unique_ptr<dwio::common::SelectiveColumnReader> build(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       ParquetParams& params,
       common::ScanSpec& scanSpec);
 };
diff --git a/velox/dwio/parquet/reader/ParquetData.cpp b/velox/dwio/parquet/reader/ParquetData.cpp
index f94ed2936895b..03ed01aa65d12 100644
--- a/velox/dwio/parquet/reader/ParquetData.cpp
+++ b/velox/dwio/parquet/reader/ParquetData.cpp
@@ -15,16 +15,16 @@
  */
 
 #include "velox/dwio/parquet/reader/ParquetData.h"
-#include "velox/dwio/parquet/reader/Statistics.h"
 
-namespace facebook::velox::parquet {
+#include "velox/dwio/common/BufferedInput.h"
 
-using thrift::RowGroup;
+namespace facebook::velox::parquet {
 
 std::unique_ptr<dwio::common::FormatData> ParquetParams::toFormatData(
     const std::shared_ptr<const dwio::common::TypeWithId>& type,
     const common::ScanSpec& /*scanSpec*/) {
-  return std::make_unique<ParquetData>(type, metaData_.row_groups, pool());
+  return std::make_unique<ParquetData>(
+      type, metaData_, pool(), sessionTimezone_);
 }
 
 void ParquetData::filterRowGroups(
@@ -32,7 +32,8 @@ void ParquetData::filterRowGroups(
     uint64_t /*rowsPerRowGroup*/,
     const dwio::common::StatsContext& /*writerContext*/,
     FilterRowGroupsResult& result) {
-  result.totalCount = std::max<int>(result.totalCount, rowGroups_.size());
+  result.totalCount =
+      std::max<int>(result.totalCount, fileMetaDataPtr_.numRowGroups());
   auto nwords = bits::nwords(result.totalCount);
   if (result.filterResult.size() < nwords) {
     result.filterResult.resize(nwords);
@@ -42,42 +43,40 @@ void ParquetData::filterRowGroups(
     result.metadataFilterResults.emplace_back(
         scanSpec.metadataFilterNodeAt(i), std::vector<uint64_t>(nwords));
   }
-  for (auto i = 0; i < rowGroups_.size(); ++i) {
-    if (scanSpec.filter() && !rowGroupMatches(i, scanSpec.filter())) {
-      bits::setBit(result.filterResult.data(), i);
-      continue;
-    }
-    for (int j = 0; j < scanSpec.numMetadataFilters(); ++j) {
-      auto* metadataFilter = scanSpec.metadataFilterAt(j);
-      if (!rowGroupMatches(i, metadataFilter)) {
-        bits::setBit(
-            result.metadataFilterResults[metadataFiltersStartIndex + j]
-                .second.data(),
-            i);
+  if (scanSpec.filter() || scanSpec.numMetadataFilters() > 0) {
+    for (auto i = 0; i < fileMetaDataPtr_.numRowGroups(); ++i) {
+      if (scanSpec.filter() && !rowGroupMatches(i, scanSpec.filter())) {
+        bits::setBit(result.filterResult.data(), i);
+        continue;
+      }
+      for (int j = 0; j < scanSpec.numMetadataFilters(); ++j) {
+        auto* metadataFilter = scanSpec.metadataFilterAt(j);
+        if (!rowGroupMatches(i, metadataFilter)) {
+          bits::setBit(
+              result.metadataFilterResults[metadataFiltersStartIndex + j]
+                  .second.data(),
+              i);
+        }
       }
     }
   }
 }
 
-bool ParquetData::rowGroupMatches(
-    uint32_t rowGroupId,
-    common::Filter* FOLLY_NULLABLE filter) {
+bool ParquetData::rowGroupMatches(uint32_t rowGroupId, common::Filter* filter) {
   auto column = type_->column();
   auto type = type_->type();
-  auto rowGroup = rowGroups_[rowGroupId];
-  assert(!rowGroup.columns.empty());
+  auto rowGroup = fileMetaDataPtr_.rowGroup(rowGroupId);
+  assert(rowGroup.numColumns() != 0);
 
   if (!filter) {
     return true;
   }
 
-  if (rowGroup.columns[column].__isset.meta_data &&
-      rowGroup.columns[column].meta_data.__isset.statistics) {
-    auto columnStats = buildColumnStatisticsFromThrift(
-        rowGroup.columns[column].meta_data.statistics,
-        *type,
-        rowGroup.num_rows);
-    return testFilter(filter, columnStats.get(), rowGroup.num_rows, type);
+  auto columnChunk = rowGroup.columnChunk(column);
+  if (columnChunk.hasStatistics()) {
+    auto columnStats =
+        columnChunk.getColumnStatistics(type, rowGroup.numRows());
+    return testFilter(filter, columnStats.get(), rowGroup.numRows(), type);
   }
   return true;
 }
@@ -85,25 +84,24 @@ bool ParquetData::rowGroupMatches(
 void ParquetData::enqueueRowGroup(
     uint32_t index,
     dwio::common::BufferedInput& input) {
-  auto& chunk = rowGroups_[index].columns[type_->column()];
-  streams_.resize(rowGroups_.size());
+  auto chunk = fileMetaDataPtr_.rowGroup(index).columnChunk(type_->column());
+  streams_.resize(fileMetaDataPtr_.numRowGroups());
   VELOX_CHECK(
-      chunk.__isset.meta_data,
+      chunk.hasMetadata(),
       "ColumnMetaData does not exist for schema Id ",
       type_->column());
-  auto& metaData = chunk.meta_data;
+  ;
 
-  uint64_t chunkReadOffset = metaData.data_page_offset;
-  if (metaData.__isset.dictionary_page_offset &&
-      metaData.dictionary_page_offset >= 4) {
+  uint64_t chunkReadOffset = chunk.dataPageOffset();
+  if (chunk.hasDictionaryPageOffset() && chunk.dictionaryPageOffset() >= 4) {
     // this assumes the data pages follow the dict pages directly.
-    chunkReadOffset = metaData.dictionary_page_offset;
+    chunkReadOffset = chunk.dictionaryPageOffset();
   }
-  VELOX_CHECK_GE(chunkReadOffset, 0);
 
-  uint64_t readSize = (metaData.codec == thrift::CompressionCodec::UNCOMPRESSED)
-      ? metaData.total_uncompressed_size
-      : metaData.total_compressed_size;
+  uint64_t readSize =
+      (chunk.compression() == common::CompressionKind::CompressionKind_NONE)
+      ? chunk.totalUncompressedSize()
+      : chunk.totalCompressedSize();
 
   auto id = dwio::common::StreamIdentifier(type_->column());
   streams_[index] = input.enqueue({chunkReadOffset, readSize}, &id);
@@ -113,30 +111,31 @@ dwio::common::PositionProvider ParquetData::seekToRowGroup(uint32_t index) {
   static std::vector<uint64_t> empty;
   VELOX_CHECK_LT(index, streams_.size());
   VELOX_CHECK(streams_[index], "Stream not enqueued for column");
-  auto& metadata = rowGroups_[index].columns[type_->column()].meta_data;
+  auto metadata = fileMetaDataPtr_.rowGroup(index).columnChunk(type_->column());
   reader_ = std::make_unique<PageReader>(
       std::move(streams_[index]),
       pool_,
       type_,
-      metadata.codec,
-      metadata.total_compressed_size);
+      metadata.compression(),
+      metadata.totalCompressedSize(),
+      sessionTimezone_);
   return dwio::common::PositionProvider(empty);
 }
 
 std::pair<int64_t, int64_t> ParquetData::getRowGroupRegion(
     uint32_t index) const {
-  auto& rowGroup = rowGroups_[index];
+  auto rowGroup = fileMetaDataPtr_.rowGroup(index);
 
-  VELOX_CHECK_GT(rowGroup.columns.size(), 0);
-  auto fileOffset = rowGroup.__isset.file_offset ? rowGroup.file_offset
-      : rowGroup.columns[0].meta_data.__isset.dictionary_page_offset
-      ? rowGroup.columns[0].meta_data.dictionary_page_offset
-      : rowGroup.columns[0].meta_data.data_page_offset;
+  VELOX_CHECK_GT(rowGroup.numColumns(), 0);
+  auto fileOffset = rowGroup.hasFileOffset() ? rowGroup.fileOffset()
+      : rowGroup.columnChunk(0).hasDictionaryPageOffset()
+      ? rowGroup.columnChunk(0).dictionaryPageOffset()
+      : rowGroup.columnChunk(0).dataPageOffset();
   VELOX_CHECK_GT(fileOffset, 0);
 
-  auto length = rowGroup.__isset.total_compressed_size
-      ? rowGroup.total_compressed_size
-      : rowGroup.total_byte_size;
+  auto length = rowGroup.hasTotalCompressedSize()
+      ? rowGroup.totalCompressedSize()
+      : rowGroup.totalByteSize();
 
   return {fileOffset, length};
 }
diff --git a/velox/dwio/parquet/reader/ParquetData.h b/velox/dwio/parquet/reader/ParquetData.h
index 709f38fba6461..897f153fd2bfb 100644
--- a/velox/dwio/parquet/reader/ParquetData.h
+++ b/velox/dwio/parquet/reader/ParquetData.h
@@ -16,29 +16,44 @@
 
 #pragma once
 
-#include <thrift/protocol/TCompactProtocol.h> //@manual
-#include "velox/common/base/RawVector.h"
 #include "velox/dwio/common/BufferUtil.h"
-#include "velox/dwio/common/BufferedInput.h"
-#include "velox/dwio/common/ScanSpec.h"
+#include "velox/dwio/parquet/reader/Metadata.h"
 #include "velox/dwio/parquet/reader/PageReader.h"
-#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
-#include "velox/dwio/parquet/thrift/ThriftTransport.h"
+
+namespace facebook::velox::common {
+class ScanSpec;
+} // namespace facebook::velox::common
+
+namespace facebook::velox::dwio::common {
+class BufferedInput;
+} // namespace facebook::velox::dwio::common
 
 namespace facebook::velox::parquet {
+
 class ParquetParams : public dwio::common::FormatParams {
  public:
   ParquetParams(
       memory::MemoryPool& pool,
       dwio::common::ColumnReaderStatistics& stats,
-      const thrift::FileMetaData& metaData)
-      : FormatParams(pool, stats), metaData_(metaData) {}
+      const FileMetaDataPtr metaData,
+      const tz::TimeZone* sessionTimezone,
+      TimestampPrecision timestampPrecision)
+      : FormatParams(pool, stats),
+        metaData_(metaData),
+        sessionTimezone_(sessionTimezone),
+        timestampPrecision_(timestampPrecision) {}
   std::unique_ptr<dwio::common::FormatData> toFormatData(
       const std::shared_ptr<const dwio::common::TypeWithId>& type,
       const common::ScanSpec& scanSpec) override;
 
+  TimestampPrecision timestampPrecision() const {
+    return timestampPrecision_;
+  }
+
  private:
-  const thrift::FileMetaData& metaData_;
+  const FileMetaDataPtr metaData_;
+  const tz::TimeZone* sessionTimezone_;
+  const TimestampPrecision timestampPrecision_;
 };
 
 /// Format-specific data created for each leaf column of a Parquet rowgroup.
@@ -46,14 +61,16 @@ class ParquetData : public dwio::common::FormatData {
  public:
   ParquetData(
       const std::shared_ptr<const dwio::common::TypeWithId>& type,
-      const std::vector<thrift::RowGroup>& rowGroups,
-      memory::MemoryPool& pool)
+      const FileMetaDataPtr fileMetadataPtr,
+      memory::MemoryPool& pool,
+      const tz::TimeZone* sessionTimezone)
       : pool_(pool),
         type_(std::static_pointer_cast<const ParquetTypeWithId>(type)),
-        rowGroups_(rowGroups),
+        fileMetaDataPtr_(fileMetadataPtr),
         maxDefine_(type_->maxDefine_),
         maxRepeat_(type_->maxRepeat_),
-        rowsInRowGroup_(-1) {}
+        rowsInRowGroup_(-1),
+        sessionTimezone_(sessionTimezone) {}
 
   /// Prepares to read data for 'index'th row group.
   void enqueueRowGroup(uint32_t index, dwio::common::BufferedInput& input);
@@ -69,7 +86,7 @@ class ParquetData : public dwio::common::FormatData {
       const dwio::common::StatsContext& writerContext,
       FilterRowGroupsResult&) override;
 
-  PageReader* FOLLY_NONNULL reader() const {
+  PageReader* reader() const {
     return reader_.get();
   }
 
@@ -100,7 +117,7 @@ class ParquetData : public dwio::common::FormatData {
 
   void readNulls(
       vector_size_t numValues,
-      const uint64_t* FOLLY_NULLABLE incomingNulls,
+      const uint64_t* incomingNulls,
       BufferPtr& nulls,
       bool nullsOnly = false) override {
     // If the query accesses only nulls, read the nulls from the pages in range.
@@ -171,6 +188,10 @@ class ParquetData : public dwio::common::FormatData {
     return reader_->isDictionary();
   }
 
+  bool isDeltaBinaryPacked() const {
+    return reader_->isDeltaBinaryPacked();
+  }
+
   bool parentNullsInLeaves() const override {
     return true;
   }
@@ -186,7 +207,7 @@ class ParquetData : public dwio::common::FormatData {
  protected:
   memory::MemoryPool& pool_;
   std::shared_ptr<const ParquetTypeWithId> type_;
-  const std::vector<thrift::RowGroup>& rowGroups_;
+  const FileMetaDataPtr fileMetaDataPtr_;
   // Streams for this column in each of 'rowGroups_'. Will be created on or
   // ahead of first use, not at construction.
   std::vector<std::unique_ptr<dwio::common::SeekableInputStream>> streams_;
@@ -194,6 +215,7 @@ class ParquetData : public dwio::common::FormatData {
   const uint32_t maxDefine_;
   const uint32_t maxRepeat_;
   int64_t rowsInRowGroup_;
+  const tz::TimeZone* sessionTimezone_;
   std::unique_ptr<PageReader> reader_;
 
   // Nulls derived from leaf repdefs for non-leaf readers.
diff --git a/velox/dwio/parquet/reader/ParquetReader.cpp b/velox/dwio/parquet/reader/ParquetReader.cpp
index d68bd0355d054..e40617f7991e0 100644
--- a/velox/dwio/parquet/reader/ParquetReader.cpp
+++ b/velox/dwio/parquet/reader/ParquetReader.cpp
@@ -15,16 +15,16 @@
  */
 
 #include "velox/dwio/parquet/reader/ParquetReader.h"
+
+#include <boost/algorithm/string.hpp>
 #include <thrift/protocol/TCompactProtocol.h> //@manual
-#include "velox/dwio/common/MetricsLog.h"
-#include "velox/dwio/common/TypeUtils.h"
+
+#include "velox/dwio/parquet/reader/ParquetColumnReader.h"
 #include "velox/dwio/parquet/reader/StructColumnReader.h"
 #include "velox/dwio/parquet/thrift/ThriftTransport.h"
 
 namespace facebook::velox::parquet {
 
-using dwio::common::ColumnSelector;
-
 /// Metadata and options for reading Parquet.
 class ReaderBase {
  public:
@@ -46,12 +46,12 @@ class ReaderBase {
     return fileLength_;
   }
 
-  uint64_t fileNumRows() const {
-    return fileMetaData_->num_rows;
+  const thrift::FileMetaData& thriftFileMetaData() const {
+    return *fileMetaData_;
   }
 
-  const thrift::FileMetaData& fileMetaData() const {
-    return *fileMetaData_;
+  FileMetaDataPtr fileMetaData() const {
+    return FileMetaDataPtr(reinterpret_cast<const void*>(fileMetaData_.get()));
   }
 
   const std::shared_ptr<const RowType>& schema() const {
@@ -63,7 +63,11 @@ class ReaderBase {
   }
 
   bool isFileColumnNamesReadAsLowerCase() const {
-    return options_.isFileColumnNamesReadAsLowerCase();
+    return options_.fileColumnNamesReadAsLowerCase();
+  }
+
+  const tz::TimeZone* sessionTimezone() const {
+    return options_.getSessionTimezone();
   }
 
   /// Ensures that streams are enqueued and loading for the row group at
@@ -89,22 +93,26 @@ class ReaderBase {
 
   void initializeSchema();
 
-  std::shared_ptr<const ParquetTypeWithId> getParquetColumnInfo(
+  std::unique_ptr<ParquetTypeWithId> getParquetColumnInfo(
       uint32_t maxSchemaElementIdx,
       uint32_t maxRepeat,
       uint32_t maxDefine,
+      uint32_t parentSchemaIdx,
       uint32_t& schemaIdx,
-      uint32_t& columnIdx) const;
+      uint32_t& columnIdx,
+      const TypePtr& requestedType) const;
 
-  TypePtr convertType(const thrift::SchemaElement& schemaElement) const;
+  TypePtr convertType(
+      const thrift::SchemaElement& schemaElement,
+      const TypePtr& requestedType) const;
 
+  template <typename T>
   static std::shared_ptr<const RowType> createRowType(
-      std::vector<std::shared_ptr<const ParquetTypeWithId::TypeWithId>>
-          children,
+      const std::vector<T>& children,
       bool fileColumnNamesReadAsLowerCase);
 
   memory::MemoryPool& pool_;
-  const uint64_t directorySizeGuess_;
+  const uint64_t footerEstimatedSize_;
   const uint64_t filePreloadThreshold_;
   // Copy of options. Must be owned by 'this'.
   const dwio::common::ReaderOptions options_;
@@ -114,8 +122,6 @@ class ReaderBase {
   RowTypePtr schema_;
   std::shared_ptr<const dwio::common::TypeWithId> schemaWithId_;
 
-  const bool binaryAsString = false;
-
   // Map from row group index to pre-created loading BufferedInput.
   std::unordered_map<uint32_t, std::shared_ptr<dwio::common::BufferedInput>>
       inputs_;
@@ -124,12 +130,12 @@ class ReaderBase {
 ReaderBase::ReaderBase(
     std::unique_ptr<dwio::common::BufferedInput> input,
     const dwio::common::ReaderOptions& options)
-    : pool_(options.getMemoryPool()),
-      directorySizeGuess_(options.getDirectorySizeGuess()),
-      filePreloadThreshold_(options.getFilePreloadThreshold()),
-      options_(options),
-      input_(std::move(input)) {
-  fileLength_ = input_->getReadFile()->size();
+    : pool_{options.memoryPool()},
+      footerEstimatedSize_{options.footerEstimatedSize()},
+      filePreloadThreshold_{options.filePreloadThreshold()},
+      options_{options},
+      input_{std::move(input)},
+      fileLength_{input_->getReadFile()->size()} {
   VELOX_CHECK_GT(fileLength_, 0, "Parquet file is empty");
   VELOX_CHECK_GE(fileLength_, 12, "Parquet file is too small");
 
@@ -139,8 +145,8 @@ ReaderBase::ReaderBase(
 
 void ReaderBase::loadFileMetaData() {
   bool preloadFile =
-      fileLength_ <= std::max(filePreloadThreshold_, directorySizeGuess_);
-  uint64_t readSize = preloadFile ? fileLength_ : directorySizeGuess_;
+      fileLength_ <= std::max(filePreloadThreshold_, footerEstimatedSize_);
+  uint64_t readSize = preloadFile ? fileLength_ : footerEstimatedSize_;
 
   std::unique_ptr<dwio::common::SeekableInputStream> stream;
   if (preloadFile) {
@@ -159,8 +165,8 @@ void ReaderBase::loadFileMetaData() {
       strncmp(copy.data() + readSize - 4, "PAR1", 4) == 0,
       "No magic bytes found at end of the Parquet file");
 
-  uint32_t footerLength =
-      *(reinterpret_cast<const uint32_t*>(copy.data() + readSize - 8));
+  uint32_t footerLength;
+  std::memcpy(&footerLength, copy.data() + readSize - 8, sizeof(uint32_t));
   VELOX_CHECK_LE(footerLength + 12, fileLength_);
   int32_t footerOffsetInBuffer = readSize - 8 - footerLength;
   if (footerLength > readSize - 8) {
@@ -211,24 +217,37 @@ void ReaderBase::initializeSchema() {
   uint32_t schemaIdx = 0;
   uint32_t columnIdx = 0;
   uint32_t maxSchemaElementIdx = fileMetaData_->schema.size() - 1;
+  // Setting the parent schema index of the root("hive_schema") to be 0, which
+  // is the root itself. This is ok because it's never required to check the
+  // parent of the root in getParquetColumnInfo().
   schemaWithId_ = getParquetColumnInfo(
-      maxSchemaElementIdx, maxRepeat, maxDefine, schemaIdx, columnIdx);
+      maxSchemaElementIdx,
+      maxRepeat,
+      maxDefine,
+      0,
+      schemaIdx,
+      columnIdx,
+      options_.fileSchema());
   schema_ = createRowType(
       schemaWithId_->getChildren(), isFileColumnNamesReadAsLowerCase());
 }
 
-std::shared_ptr<const ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
+std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
     uint32_t maxSchemaElementIdx,
     uint32_t maxRepeat,
     uint32_t maxDefine,
+    uint32_t parentSchemaIdx,
     uint32_t& schemaIdx,
-    uint32_t& columnIdx) const {
+    uint32_t& columnIdx,
+    const TypePtr& requestedType) const {
   VELOX_CHECK(fileMetaData_ != nullptr);
   VELOX_CHECK_LT(schemaIdx, fileMetaData_->schema.size());
 
   auto& schema = fileMetaData_->schema;
   uint32_t curSchemaIdx = schemaIdx;
   auto& schemaElement = schema[curSchemaIdx];
+  bool isRepeated = false;
+  bool isOptional = false;
 
   if (schemaElement.__isset.repetition_type) {
     if (schemaElement.repetition_type !=
@@ -238,6 +257,11 @@ std::shared_ptr<const ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
     if (schemaElement.repetition_type ==
         thrift::FieldRepetitionType::REPEATED) {
       maxRepeat++;
+      isRepeated = true;
+    }
+    if (schemaElement.repetition_type ==
+        thrift::FieldRepetitionType::OPTIONAL) {
+      isOptional = true;
     }
   }
 
@@ -249,25 +273,110 @@ std::shared_ptr<const ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
     VELOX_CHECK(
         schemaElement.__isset.num_children && schemaElement.num_children > 0,
         "Node has no children but should");
+    VELOX_CHECK(!requestedType || requestedType->isRow());
 
-    std::vector<std::shared_ptr<const ParquetTypeWithId::TypeWithId>> children;
+    std::vector<std::unique_ptr<ParquetTypeWithId::TypeWithId>> children;
 
+    auto curSchemaIdx = schemaIdx;
     for (int32_t i = 0; i < schemaElement.num_children; i++) {
+      ++schemaIdx;
+      auto childName = schema[schemaIdx].name;
+      if (isFileColumnNamesReadAsLowerCase()) {
+        folly::toLowerAscii(childName);
+      }
+      auto childRequestedType =
+          requestedType ? requestedType->asRow().findChild(childName) : nullptr;
       auto child = getParquetColumnInfo(
-          maxSchemaElementIdx, maxRepeat, maxDefine, ++schemaIdx, columnIdx);
-      children.push_back(child);
+          maxSchemaElementIdx,
+          maxRepeat,
+          maxDefine,
+          curSchemaIdx,
+          schemaIdx,
+          columnIdx,
+          childRequestedType);
+      children.push_back(std::move(child));
     }
     VELOX_CHECK(!children.empty());
 
     if (schemaElement.__isset.converted_type) {
       switch (schemaElement.converted_type) {
-        case thrift::ConvertedType::LIST:
+        case thrift::ConvertedType::LIST: {
+          VELOX_CHECK_EQ(children.size(), 1);
+          const auto& child = children[0];
+          isRepeated = true;
+          // In case the child is a MAP or current element is repeated then
+          // wrap child around additional ARRAY
+          if (child->type()->kind() == TypeKind::MAP ||
+              schemaElement.repetition_type ==
+                  thrift::FieldRepetitionType::REPEATED) {
+            return std::make_unique<ParquetTypeWithId>(
+                TypeFactory<TypeKind::ARRAY>::create(child->type()),
+                std::move(children),
+                curSchemaIdx,
+                maxSchemaElementIdx,
+                ParquetTypeWithId::kNonLeaf,
+                std::move(name),
+                std::nullopt,
+                std::nullopt,
+                maxRepeat + 1,
+                maxDefine,
+                isOptional,
+                isRepeated);
+          }
+          // Only special case list of map and list of list is handled here,
+          // other generic case is handled with case MAP
+          [[fallthrough]];
+        }
+        case thrift::ConvertedType::MAP_KEY_VALUE:
+          // If the MAP_KEY_VALUE annotated group's parent is a MAP, it should
+          // be the repeated key_value group that directly contains the key and
+          // value children.
+          if (schema[parentSchemaIdx].converted_type ==
+              thrift::ConvertedType::MAP) {
+            // TODO: the group names need to be checked. According to the spec,
+            // https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#maps
+            // the name of the schema element being 'key_value' is
+            // also an indication of this is a map type
+            VELOX_CHECK_EQ(
+                schemaElement.repetition_type,
+                thrift::FieldRepetitionType::REPEATED);
+            VELOX_CHECK_EQ(children.size(), 2);
+
+            auto type = TypeFactory<TypeKind::MAP>::create(
+                children[0]->type(), children[1]->type());
+            return std::make_unique<ParquetTypeWithId>(
+                std::move(type),
+                std::move(children),
+                curSchemaIdx, // TODO: there are holes in the ids
+                maxSchemaElementIdx,
+                ParquetTypeWithId::kNonLeaf, // columnIdx,
+                std::move(name),
+                std::nullopt,
+                std::nullopt,
+                maxRepeat,
+                maxDefine,
+                isOptional,
+                isRepeated);
+          }
+
+          // For backward-compatibility, a group annotated with MAP_KEY_VALUE
+          // that is not contained by a MAP-annotated group should be handled as
+          // a MAP-annotated group.
+          [[fallthrough]];
+
         case thrift::ConvertedType::MAP: {
-          auto element = children.at(0)->getChildren();
           VELOX_CHECK_EQ(children.size(), 1);
-          return std::make_shared<const ParquetTypeWithId>(
-              children[0]->type(),
-              std::move(element),
+          const auto& child = children[0];
+          auto type = child->type();
+          isRepeated = true;
+          // This level will not have the "isRepeated" info in the parquet
+          // schema since parquet schema will have a child layer which will have
+          // the "repeated info" which we are ignoring here, hence we set the
+          // isRepeated to true eg
+          // https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#lists
+          return std::make_unique<ParquetTypeWithId>(
+              std::move(type),
+              std::move(*(ParquetTypeWithId*)child.get()).moveChildren(),
               curSchemaIdx, // TODO: there are holes in the ids
               maxSchemaElementIdx,
               ParquetTypeWithId::kNonLeaf, // columnIdx,
@@ -275,74 +384,156 @@ std::shared_ptr<const ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
               std::nullopt,
               std::nullopt,
               maxRepeat + 1,
-              maxDefine);
-        }
-        case thrift::ConvertedType::MAP_KEY_VALUE: {
-          // child of MAP
-          VELOX_CHECK_EQ(
-              schemaElement.repetition_type,
-              thrift::FieldRepetitionType::REPEATED);
-          assert(children.size() == 2);
-          auto childrenCopy = children;
-          return std::make_shared<const ParquetTypeWithId>(
-              TypeFactory<TypeKind::MAP>::create(
-                  children[0]->type(), children[1]->type()),
-              std::move(childrenCopy),
-              curSchemaIdx, // TODO: there are holes in the ids
-              maxSchemaElementIdx,
-              ParquetTypeWithId::kNonLeaf, // columnIdx,
-              std::move(name),
-              std::nullopt,
-              std::nullopt,
-              maxRepeat,
-              maxDefine);
+              maxDefine,
+              isOptional,
+              isRepeated);
         }
+
         default:
-          VELOX_UNSUPPORTED(
-              "Unsupported SchemaElement type: {}",
-              schemaElement.converted_type);
+          VELOX_UNREACHABLE(
+              "Invalid SchemaElement converted_type: {}, name: {}",
+              schemaElement.converted_type,
+              schemaElement.name);
       }
     } else {
       if (schemaElement.repetition_type ==
           thrift::FieldRepetitionType::REPEATED) {
-        VELOX_CHECK_LE(
-            children.size(), 2, "children size should not be larger than 2");
-        if (children.size() == 1) {
+        if (schema[parentSchemaIdx].converted_type ==
+            thrift::ConvertedType::LIST) {
+          // TODO: the group names need to be checked. According to spec,
+          // https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#lists
+          // the name of the schema element being 'array' is
+          // also an indication of this is a list type
           // child of LIST
-          auto childrenCopy = children;
-          return std::make_shared<ParquetTypeWithId>(
-              TypeFactory<TypeKind::ARRAY>::create(children[0]->type()),
-              std::move(childrenCopy),
-              curSchemaIdx,
+          VELOX_CHECK_GE(children.size(), 1);
+          if (children.size() == 1 && name != "array" &&
+              name != schema[parentSchemaIdx].name + "_tuple") {
+            auto type =
+                TypeFactory<TypeKind::ARRAY>::create(children[0]->type());
+            return std::make_unique<ParquetTypeWithId>(
+                std::move(type),
+                std::move(children),
+                curSchemaIdx,
+                maxSchemaElementIdx,
+                ParquetTypeWithId::kNonLeaf, // columnIdx,
+                std::move(name),
+                std::nullopt,
+                std::nullopt,
+                maxRepeat,
+                maxDefine,
+                isOptional,
+                isRepeated);
+          } else {
+            // According to the spec of list backward compatibility
+            // https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#lists
+            // "If the repeated field is a group with multiple fields, then its
+            // type is the element type and elements are required." when there
+            // are multiple fields, creating a new row type instance which has
+            // all the fields as its children.
+            // TODO: since this is newly created node, its schemaIdx actually
+            // doesn't exist from the footer schema. Reusing the curSchemaIdx
+            // but potentially could have issue.
+            auto childrenRowType =
+                createRowType(children, isFileColumnNamesReadAsLowerCase());
+            std::vector<std::unique_ptr<ParquetTypeWithId::TypeWithId>>
+                rowChildren;
+            // In this legacy case, there is no middle layer between "array"
+            // node and the children nodes. Below creates this dummy middle
+            // layer to mimic the non-legacy case and fill the gap.
+            rowChildren.emplace_back(std::make_unique<ParquetTypeWithId>(
+                childrenRowType,
+                std::move(children),
+                curSchemaIdx,
+                maxSchemaElementIdx,
+                ParquetTypeWithId::kNonLeaf,
+                "dummy",
+                std::nullopt,
+                std::nullopt,
+                maxRepeat,
+                maxDefine,
+                isOptional,
+                isRepeated));
+            auto res = std::make_unique<ParquetTypeWithId>(
+                TypeFactory<TypeKind::ARRAY>::create(childrenRowType),
+                std::move(rowChildren),
+                curSchemaIdx,
+                maxSchemaElementIdx,
+                ParquetTypeWithId::kNonLeaf, // columnIdx,
+                std::move(name),
+                std::nullopt,
+                std::nullopt,
+                maxRepeat,
+                maxDefine,
+                isOptional,
+                isRepeated);
+            return res;
+          }
+        } else if (
+            schema[parentSchemaIdx].converted_type ==
+                thrift::ConvertedType::MAP ||
+            schema[parentSchemaIdx].converted_type ==
+                thrift::ConvertedType::MAP_KEY_VALUE) {
+          // children  of MAP
+          VELOX_CHECK_EQ(children.size(), 2);
+          auto type = TypeFactory<TypeKind::MAP>::create(
+              children[0]->type(), children[1]->type());
+          return std::make_unique<ParquetTypeWithId>(
+              std::move(type),
+              std::move(children),
+              curSchemaIdx, // TODO: there are holes in the ids
               maxSchemaElementIdx,
               ParquetTypeWithId::kNonLeaf, // columnIdx,
               std::move(name),
               std::nullopt,
               std::nullopt,
               maxRepeat,
-              maxDefine);
-        } else if (children.size() == 2) {
-          // children  of MAP
-          auto childrenCopy = children;
-          return std::make_shared<const ParquetTypeWithId>(
-              TypeFactory<TypeKind::MAP>::create(
-                  children[0]->type(), children[1]->type()),
-              std::move(childrenCopy),
-              curSchemaIdx, // TODO: there are holes in the ids
+              maxDefine,
+              isOptional,
+              isRepeated);
+        } else {
+          // Row type
+          // To support list backward compatibility, need create a new row type
+          // instance and set all the fields as its children.
+          auto childrenRowType =
+              createRowType(children, isFileColumnNamesReadAsLowerCase());
+          std::vector<std::unique_ptr<ParquetTypeWithId::TypeWithId>>
+              rowChildren;
+          // In this legacy case, there is no middle layer between "array"
+          // node and the children nodes. Below creates this dummy middle
+          // layer to mimic the non-legacy case and fill the gap.
+          rowChildren.emplace_back(std::make_unique<ParquetTypeWithId>(
+              childrenRowType,
+              std::move(children),
+              curSchemaIdx,
+              maxSchemaElementIdx,
+              ParquetTypeWithId::kNonLeaf,
+              "dummy",
+              std::nullopt,
+              std::nullopt,
+              maxRepeat,
+              maxDefine,
+              isOptional,
+              isRepeated));
+          return std::make_unique<ParquetTypeWithId>(
+              TypeFactory<TypeKind::ARRAY>::create(childrenRowType),
+              std::move(rowChildren),
+              curSchemaIdx,
               maxSchemaElementIdx,
               ParquetTypeWithId::kNonLeaf, // columnIdx,
               std::move(name),
               std::nullopt,
               std::nullopt,
               maxRepeat,
-              maxDefine);
+              maxDefine,
+              isOptional,
+              isRepeated);
         }
       } else {
         // Row type
-        auto childrenCopy = children;
-        return std::make_shared<const ParquetTypeWithId>(
-            createRowType(children, isFileColumnNamesReadAsLowerCase()),
-            std::move(childrenCopy),
+        auto type = createRowType(children, isFileColumnNamesReadAsLowerCase());
+        return std::make_unique<ParquetTypeWithId>(
+            std::move(type),
+            std::move(children),
             curSchemaIdx,
             maxSchemaElementIdx,
             ParquetTypeWithId::kNonLeaf, // columnIdx,
@@ -350,64 +541,70 @@ std::shared_ptr<const ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
             std::nullopt,
             std::nullopt,
             maxRepeat,
-            maxDefine);
+            maxDefine,
+            isOptional,
+            isRepeated);
       }
     }
   } else { // leaf node
-    const auto veloxType = convertType(schemaElement);
+    const auto veloxType = convertType(schemaElement, requestedType);
     int32_t precision =
         schemaElement.__isset.precision ? schemaElement.precision : 0;
     int32_t scale = schemaElement.__isset.scale ? schemaElement.scale : 0;
     int32_t type_length =
         schemaElement.__isset.type_length ? schemaElement.type_length : 0;
-    std::vector<std::shared_ptr<const dwio::common::TypeWithId>> children;
+    std::vector<std::unique_ptr<dwio::common::TypeWithId>> children;
     const std::optional<thrift::LogicalType> logicalType_ =
         schemaElement.__isset.logicalType
         ? std::optional<thrift::LogicalType>(schemaElement.logicalType)
         : std::nullopt;
-    std::shared_ptr<const ParquetTypeWithId> leafTypePtr =
-        std::make_shared<const ParquetTypeWithId>(
-            veloxType,
-            std::move(children),
-            curSchemaIdx,
-            maxSchemaElementIdx,
-            columnIdx++,
-            name,
-            schemaElement.type,
-            logicalType_,
-            maxRepeat,
-            maxDefine,
-            precision,
-            scale,
-            type_length);
+    auto leafTypePtr = std::make_unique<ParquetTypeWithId>(
+        veloxType,
+        std::move(children),
+        curSchemaIdx,
+        maxSchemaElementIdx,
+        columnIdx++,
+        name,
+        schemaElement.type,
+        logicalType_,
+        maxRepeat,
+        maxDefine,
+        isOptional,
+        isRepeated,
+        precision,
+        scale,
+        type_length);
 
     if (schemaElement.repetition_type ==
         thrift::FieldRepetitionType::REPEATED) {
       // Array
       children.clear();
       children.reserve(1);
-      children.push_back(leafTypePtr);
-      return std::make_shared<const ParquetTypeWithId>(
+      children.push_back(std::move(leafTypePtr));
+      return std::make_unique<ParquetTypeWithId>(
           TypeFactory<TypeKind::ARRAY>::create(veloxType),
           std::move(children),
           curSchemaIdx,
           maxSchemaElementIdx,
-          columnIdx++,
+          columnIdx - 1, // was already incremented for leafTypePtr
           std::move(name),
           std::nullopt,
           std::nullopt,
           maxRepeat,
-          maxDefine - 1);
+          maxDefine - 1,
+          isOptional,
+          isRepeated);
     }
     return leafTypePtr;
   }
 
-  VELOX_FAIL("Unable to extract Parquet column info.")
+  VELOX_FAIL("Unable to extract Parquet column info.");
   return nullptr;
 }
 
 TypePtr ReaderBase::convertType(
-    const thrift::SchemaElement& schemaElement) const {
+    const thrift::SchemaElement& schemaElement,
+    const TypePtr& requestedType) const {
   VELOX_CHECK(schemaElement.__isset.type && schemaElement.num_children == 0);
   VELOX_CHECK(
       schemaElement.type != thrift::Type::FIXED_LEN_BYTE_ARRAY ||
@@ -503,10 +700,16 @@ TypePtr ReaderBase::convertType(
             VELOX_FAIL(
                 "UTF8 converted type can only be set for thrift::Type::(FIXED_LEN_)BYTE_ARRAY");
         }
+      case thrift::ConvertedType::ENUM: {
+        VELOX_CHECK_EQ(
+            schemaElement.type,
+            thrift::Type::BYTE_ARRAY,
+            "ENUM converted type can only be set for value of thrift::Type::BYTE_ARRAY");
+        return VARCHAR();
+      }
       case thrift::ConvertedType::MAP:
       case thrift::ConvertedType::MAP_KEY_VALUE:
       case thrift::ConvertedType::LIST:
-      case thrift::ConvertedType::ENUM:
       case thrift::ConvertedType::TIME_MILLIS:
       case thrift::ConvertedType::TIME_MICROS:
       case thrift::ConvertedType::JSON:
@@ -514,7 +717,7 @@ TypePtr ReaderBase::convertType(
       case thrift::ConvertedType::INTERVAL:
       default:
         VELOX_FAIL(
-            "Unsupported Parquet SchemaElement converted type: ",
+            "Unsupported Parquet SchemaElement converted type: {}",
             schemaElement.converted_type);
     }
   } else {
@@ -526,33 +729,34 @@ TypePtr ReaderBase::convertType(
       case thrift::Type::type::INT64:
         return BIGINT();
       case thrift::Type::type::INT96:
-        return DOUBLE(); // TODO: Lose precision
+        return TIMESTAMP(); // INT96 only maps to a timestamp
       case thrift::Type::type::FLOAT:
         return REAL();
       case thrift::Type::type::DOUBLE:
         return DOUBLE();
       case thrift::Type::type::BYTE_ARRAY:
       case thrift::Type::type::FIXED_LEN_BYTE_ARRAY:
-        if (binaryAsString) {
+        if (requestedType && requestedType->isVarchar()) {
           return VARCHAR();
         } else {
           return VARBINARY();
         }
 
       default:
-        VELOX_FAIL("Unknown Parquet SchemaElement type: ", schemaElement.type);
+        VELOX_FAIL(
+            "Unknown Parquet SchemaElement type: {}", schemaElement.type);
     }
   }
 }
 
+template <typename T>
 std::shared_ptr<const RowType> ReaderBase::createRowType(
-    std::vector<std::shared_ptr<const ParquetTypeWithId::TypeWithId>> children,
+    const std::vector<T>& children,
     bool fileColumnNamesReadAsLowerCase) {
   std::vector<std::string> childNames;
   std::vector<TypePtr> childTypes;
   for (auto& child : children) {
-    auto childName =
-        std::static_pointer_cast<const ParquetTypeWithId>(child)->name_;
+    auto childName = static_cast<const ParquetTypeWithId&>(*child).name_;
     if (fileColumnNamesReadAsLowerCase) {
       folly::toLowerAscii(childName);
     }
@@ -567,24 +771,16 @@ void ReaderBase::scheduleRowGroups(
     const std::vector<uint32_t>& rowGroupIds,
     int32_t currentGroup,
     StructColumnReader& reader) {
-  auto thisGroup = rowGroupIds[currentGroup];
-  auto nextGroup =
-      currentGroup + 1 < rowGroupIds.size() ? rowGroupIds[currentGroup + 1] : 0;
-  auto input = inputs_[thisGroup].get();
-  if (!input) {
-    inputs_[thisGroup] = reader.loadRowGroup(thisGroup, input_);
-  }
-  for (auto counter = 0; counter < options_.prefetchRowGroups(); ++counter) {
-    if (nextGroup) {
-      if (inputs_.count(nextGroup) == 0) {
-        inputs_[nextGroup] = reader.loadRowGroup(nextGroup, input_);
-      }
-    } else {
-      break;
+  auto numRowGroupsToLoad = std::min(
+      options_.prefetchRowGroups() + 1,
+      static_cast<int64_t>(rowGroupIds.size() - currentGroup));
+  for (auto i = 0; i < numRowGroupsToLoad; i++) {
+    auto thisGroup = rowGroupIds[currentGroup + i];
+    if (!inputs_[thisGroup]) {
+      inputs_[thisGroup] = reader.loadRowGroup(thisGroup, input_);
     }
-    nextGroup =
-        nextGroup + 1 < rowGroupIds.size() ? rowGroupIds[nextGroup + 1] : 0;
   }
+
   if (currentGroup >= 1) {
     inputs_.erase(rowGroupIds[currentGroup - 1]);
   }
@@ -594,6 +790,9 @@ int64_t ReaderBase::rowGroupUncompressedSize(
     int32_t rowGroupIndex,
     const dwio::common::TypeWithId& type) const {
   if (type.column() != ParquetTypeWithId::kNonLeaf) {
+    VELOX_CHECK_LT(rowGroupIndex, fileMetaData_->row_groups.size());
+    VELOX_CHECK_LT(
+        type.column(), fileMetaData_->row_groups[rowGroupIndex].columns.size());
     return fileMetaData_->row_groups[rowGroupIndex]
         .columns[type.column()]
         .meta_data.total_uncompressed_size;
@@ -609,158 +808,242 @@ bool ReaderBase::isRowGroupBuffered(int32_t rowGroupIndex) const {
   return inputs_.count(rowGroupIndex) != 0;
 }
 
-ParquetRowReader::ParquetRowReader(
-    const std::shared_ptr<ReaderBase>& readerBase,
-    const dwio::common::RowReaderOptions& options)
-    : pool_(readerBase->getMemoryPool()),
-      readerBase_(readerBase),
-      options_(options),
-      rowGroups_(readerBase_->fileMetaData().row_groups),
-      nextRowGroupIdsIdx_(0),
-      currentRowGroupPtr_(nullptr),
-      rowsInCurrentRowGroup_(0),
-      currentRowInGroup_(0) {
-  // Validate the requested type is compatible with what's in the file
-  std::function<std::string()> createExceptionContext = [&]() {
-    std::string exceptionMessageContext = fmt::format(
-        "The schema loaded in the reader does not match the schema in the file footer."
-        "Input Name: {},\n"
-        "File Footer Schema (without partition columns): {},\n"
-        "Input Table Schema (with partition columns): {}\n",
-        readerBase_->bufferedInput().getReadFile()->getName(),
-        readerBase_->schema()->toString(),
-        requestedType_->toString());
-    return exceptionMessageContext;
-  };
-
-  if (rowGroups_.empty()) {
-    return; // TODO
-  }
-  ParquetParams params(pool_, columnReaderStats_, readerBase_->fileMetaData());
-  auto columnSelector = std::make_shared<ColumnSelector>(
-      ColumnSelector::apply(options_.getSelector(), readerBase_->schema()));
-  columnReader_ = ParquetColumnReader::build(
-      columnSelector->getSchemaWithId(),
-      readerBase_->schemaWithId(), // Id is schema id
-      params,
-      *options_.getScanSpec());
-
-  filterRowGroups();
-  if (!rowGroupIds_.empty()) {
-    // schedule prefetch of first row group right after reading the metadata.
-    // This is usually on a split preload thread before the split goes to table
-    // scan.
-    advanceToNextRowGroup();
-  }
-}
-
 namespace {
 struct ParquetStatsContext : dwio::common::StatsContext {};
 } // namespace
 
-void ParquetRowReader::filterRowGroups() {
-  rowGroupIds_.reserve(rowGroups_.size());
-  firstRowOfRowGroup_.reserve(rowGroups_.size());
-
-  ParquetData::FilterRowGroupsResult res;
-  columnReader_->filterRowGroups(0, ParquetStatsContext(), res);
-  if (auto& metadataFilter = options_.getMetadataFilter()) {
-    metadataFilter->eval(res.metadataFilterResults, res.filterResult);
+class ParquetRowReader::Impl {
+ public:
+  Impl(
+      const std::shared_ptr<ReaderBase>& readerBase,
+      const dwio::common::RowReaderOptions& options)
+      : pool_{readerBase->getMemoryPool()},
+        readerBase_{readerBase},
+        options_{options},
+        rowGroups_{readerBase_->thriftFileMetaData().row_groups},
+        nextRowGroupIdsIdx_{0},
+        currentRowGroupPtr_{nullptr},
+        rowsInCurrentRowGroup_{0},
+        currentRowInGroup_{0} {
+    // Validate the requested type is compatible with what's in the file
+    std::function<std::string()> createExceptionContext = [&]() {
+      std::string exceptionMessageContext = fmt::format(
+          "The schema loaded in the reader does not match the schema in the file footer."
+          "Input Name: {},\n"
+          "File Footer Schema (without partition columns): {},\n"
+          "Input Table Schema (with partition columns): {}\n",
+          readerBase_->bufferedInput().getReadFile()->getName(),
+          readerBase_->schema()->toString(),
+          requestedType_->toString());
+      return exceptionMessageContext;
+    };
+
+    if (rowGroups_.empty()) {
+      return; // TODO
+    }
+    ParquetParams params(
+        pool_,
+        columnReaderStats_,
+        readerBase_->fileMetaData(),
+        readerBase->sessionTimezone(),
+        options_.timestampPrecision());
+    requestedType_ = options_.requestedType() ? options_.requestedType()
+                                              : readerBase_->schema();
+    columnReader_ = ParquetColumnReader::build(
+        requestedType_,
+        readerBase_->schemaWithId(), // Id is schema id
+        params,
+        *options_.scanSpec());
+    columnReader_->setFillMutatedOutputRows(
+        options_.rowNumberColumnInfo().has_value());
+    columnReader_->setIsTopLevel();
+
+    filterRowGroups();
+    if (!rowGroupIds_.empty()) {
+      // schedule prefetch of first row group right after reading the metadata.
+      // This is usually on a split preload thread before the split goes to
+      // table scan.
+      advanceToNextRowGroup();
+    }
   }
 
-  uint64_t rowNumber = 0;
-  for (auto i = 0; i < rowGroups_.size(); i++) {
-    VELOX_CHECK_GT(rowGroups_[i].columns.size(), 0);
-    auto fileOffset = rowGroups_[i].__isset.file_offset
-        ? rowGroups_[i].file_offset
-        : rowGroups_[i].columns[0].meta_data.__isset.dictionary_page_offset
-        ? rowGroups_[i].columns[0].meta_data.dictionary_page_offset
-        : rowGroups_[i].columns[0].meta_data.data_page_offset;
-    VELOX_CHECK_GT(fileOffset, 0);
-    auto rowGroupInRange =
-        (fileOffset >= options_.getOffset() &&
-         fileOffset < options_.getLimit());
-    // A skipped row group is one that is in range and is in the excluded list.
-    if (rowGroupInRange) {
-      if (i < res.totalCount && bits::isBitSet(res.filterResult.data(), i)) {
-        ++skippedRowGroups_;
-      } else {
+  void filterRowGroups() {
+    rowGroupIds_.reserve(rowGroups_.size());
+    firstRowOfRowGroup_.reserve(rowGroups_.size());
+
+    ParquetData::FilterRowGroupsResult res;
+    columnReader_->filterRowGroups(0, ParquetStatsContext(), res);
+    if (auto& metadataFilter = options_.metadataFilter()) {
+      metadataFilter->eval(res.metadataFilterResults, res.filterResult);
+    }
+
+    uint64_t rowNumber = 0;
+    for (auto i = 0; i < rowGroups_.size(); i++) {
+      VELOX_CHECK_GT(rowGroups_[i].columns.size(), 0);
+      auto fileOffset = rowGroups_[i].__isset.file_offset
+          ? rowGroups_[i].file_offset
+          : rowGroups_[i].columns[0].meta_data.__isset.dictionary_page_offset
+          ? rowGroups_[i].columns[0].meta_data.dictionary_page_offset
+          : rowGroups_[i].columns[0].meta_data.data_page_offset;
+      VELOX_CHECK_GT(fileOffset, 0);
+      auto rowGroupInRange =
+          (fileOffset >= options_.offset() && fileOffset < options_.limit());
+
+      auto isExcluded =
+          (i < res.totalCount && bits::isBitSet(res.filterResult.data(), i));
+      auto isEmpty = rowGroups_[i].num_rows == 0;
+
+      // Add a row group to read if it is within range and not empty and not in
+      // the excluded list.
+      if (rowGroupInRange && !isExcluded && !isEmpty) {
         rowGroupIds_.push_back(i);
         firstRowOfRowGroup_.push_back(rowNumber);
       }
+      rowNumber += rowGroups_[i].num_rows;
+    }
+  }
+
+  int64_t nextRowNumber() {
+    if (currentRowInGroup_ >= rowsInCurrentRowGroup_ &&
+        !advanceToNextRowGroup()) {
+      return kAtEnd;
+    }
+    return firstRowOfRowGroup_[nextRowGroupIdsIdx_ - 1] + currentRowInGroup_;
+  }
+
+  int64_t nextReadSize(uint64_t size) {
+    VELOX_CHECK_GT(size, 0);
+    if (nextRowNumber() == kAtEnd) {
+      return kAtEnd;
+    }
+    return std::min(size, rowsInCurrentRowGroup_ - currentRowInGroup_);
+  }
+
+  uint64_t next(
+      uint64_t size,
+      velox::VectorPtr& result,
+      const dwio::common::Mutation* mutation) {
+    auto rowsToRead = nextReadSize(size);
+    if (rowsToRead == kAtEnd) {
+      return 0;
+    }
+    VELOX_DCHECK_GT(rowsToRead, 0);
+    if (!options_.rowNumberColumnInfo().has_value()) {
+      columnReader_->next(rowsToRead, result, mutation);
+    } else {
+      readWithRowNumber(
+          columnReader_,
+          options_,
+          nextRowNumber(),
+          rowsToRead,
+          mutation,
+          result);
+    }
+
+    currentRowInGroup_ += rowsToRead;
+    return rowsToRead;
+  }
+
+  std::optional<size_t> estimatedRowSize() const {
+    auto index =
+        nextRowGroupIdsIdx_ < 1 ? 0 : rowGroupIds_[nextRowGroupIdsIdx_ - 1];
+    return readerBase_->rowGroupUncompressedSize(
+               index, *readerBase_->schemaWithId()) /
+        rowGroups_[index].num_rows;
+  }
+
+  void updateRuntimeStats(dwio::common::RuntimeStatistics& stats) const {
+    stats.skippedStrides += rowGroups_.size() - rowGroupIds_.size();
+  }
+
+  void resetFilterCaches() {
+    columnReader_->resetFilterCaches();
+  }
+
+  bool isRowGroupBuffered(int32_t rowGroupIndex) const {
+    return readerBase_->isRowGroupBuffered(rowGroupIndex);
+  }
+
+ private:
+  bool advanceToNextRowGroup() {
+    if (nextRowGroupIdsIdx_ == rowGroupIds_.size()) {
+      return false;
     }
-    rowNumber += rowGroups_[i].num_rows;
+
+    auto nextRowGroupIndex = rowGroupIds_[nextRowGroupIdsIdx_];
+    readerBase_->scheduleRowGroups(
+        rowGroupIds_,
+        nextRowGroupIdsIdx_,
+        static_cast<StructColumnReader&>(*columnReader_));
+    currentRowGroupPtr_ = &rowGroups_[rowGroupIds_[nextRowGroupIdsIdx_]];
+    rowsInCurrentRowGroup_ = currentRowGroupPtr_->num_rows;
+    currentRowInGroup_ = 0;
+    nextRowGroupIdsIdx_++;
+    columnReader_->seekToRowGroup(nextRowGroupIndex);
+    return true;
   }
+
+  memory::MemoryPool& pool_;
+  const std::shared_ptr<ReaderBase> readerBase_;
+  const dwio::common::RowReaderOptions options_;
+
+  // All row groups from file metadata.
+  const std::vector<thrift::RowGroup>& rowGroups_;
+  // Indices of row groups where stats match filters.
+  std::vector<uint32_t> rowGroupIds_;
+  std::vector<uint64_t> firstRowOfRowGroup_;
+  uint32_t nextRowGroupIdsIdx_;
+  const thrift::RowGroup* currentRowGroupPtr_{nullptr};
+  uint64_t rowsInCurrentRowGroup_;
+  uint64_t currentRowInGroup_;
+
+  std::unique_ptr<dwio::common::SelectiveColumnReader> columnReader_;
+
+  TypePtr requestedType_;
+
+  dwio::common::ColumnReaderStatistics columnReaderStats_;
+};
+
+ParquetRowReader::ParquetRowReader(
+    const std::shared_ptr<ReaderBase>& readerBase,
+    const dwio::common::RowReaderOptions& options) {
+  impl_ = std::make_unique<ParquetRowReader::Impl>(readerBase, options);
+}
+
+void ParquetRowReader::filterRowGroups() {
+  impl_->filterRowGroups();
 }
 
 int64_t ParquetRowReader::nextRowNumber() {
-  if (currentRowInGroup_ >= rowsInCurrentRowGroup_ &&
-      !advanceToNextRowGroup()) {
-    return kAtEnd;
-  }
-  return firstRowOfRowGroup_[nextRowGroupIdsIdx_ - 1] + currentRowInGroup_;
+  return impl_->nextRowNumber();
 }
 
 int64_t ParquetRowReader::nextReadSize(uint64_t size) {
-  VELOX_CHECK_GT(size, 0);
-  if (nextRowNumber() == kAtEnd) {
-    return kAtEnd;
-  }
-  return std::min(size, rowsInCurrentRowGroup_ - currentRowInGroup_);
+  return impl_->nextReadSize(size);
 }
 
 uint64_t ParquetRowReader::next(
     uint64_t size,
     velox::VectorPtr& result,
     const dwio::common::Mutation* mutation) {
-  VELOX_DCHECK(!options_.getAppendRowNumberColumn());
-  auto rowsToRead = nextReadSize(size);
-  if (rowsToRead == kAtEnd) {
-    return 0;
-  }
-  VELOX_DCHECK_GT(rowsToRead, 0);
-  columnReader_->next(rowsToRead, result, mutation);
-  currentRowInGroup_ += rowsToRead;
-  return rowsToRead;
-}
-
-bool ParquetRowReader::advanceToNextRowGroup() {
-  if (nextRowGroupIdsIdx_ == rowGroupIds_.size()) {
-    return false;
-  }
-
-  auto nextRowGroupIndex = rowGroupIds_[nextRowGroupIdsIdx_];
-  readerBase_->scheduleRowGroups(
-      rowGroupIds_,
-      nextRowGroupIdsIdx_,
-      static_cast<StructColumnReader&>(*columnReader_));
-  currentRowGroupPtr_ = &rowGroups_[rowGroupIds_[nextRowGroupIdsIdx_]];
-  rowsInCurrentRowGroup_ = currentRowGroupPtr_->num_rows;
-  currentRowInGroup_ = 0;
-  nextRowGroupIdsIdx_++;
-  columnReader_->seekToRowGroup(nextRowGroupIndex);
-  return true;
+  return impl_->next(size, result, mutation);
 }
 
 void ParquetRowReader::updateRuntimeStats(
     dwio::common::RuntimeStatistics& stats) const {
-  stats.skippedStrides += skippedRowGroups_;
+  impl_->updateRuntimeStats(stats);
 }
 
 void ParquetRowReader::resetFilterCaches() {
-  columnReader_->resetFilterCaches();
+  impl_->resetFilterCaches();
 }
 
 bool ParquetRowReader::isRowGroupBuffered(int32_t rowGroupIndex) const {
-  return readerBase_->isRowGroupBuffered(rowGroupIndex);
+  return impl_->isRowGroupBuffered(rowGroupIndex);
 }
 
 std::optional<size_t> ParquetRowReader::estimatedRowSize() const {
-  auto index =
-      nextRowGroupIdsIdx_ < 1 ? 0 : rowGroupIds_[nextRowGroupIdsIdx_ - 1];
-  return readerBase_->rowGroupUncompressedSize(
-             index, *readerBase_->schemaWithId()) /
-      rowGroups_[index].num_rows;
+  return impl_->estimatedRowSize();
 }
 
 ParquetReader::ParquetReader(
@@ -769,7 +1052,7 @@ ParquetReader::ParquetReader(
     : readerBase_(std::make_shared<ReaderBase>(std::move(input), options)) {}
 
 std::optional<uint64_t> ParquetReader::numberOfRows() const {
-  return readerBase_->fileNumRows();
+  return readerBase_->thriftFileMetaData().num_rows;
 }
 
 const velox::RowTypePtr& ParquetReader::rowType() const {
@@ -781,12 +1064,13 @@ ParquetReader::typeWithId() const {
   return readerBase_->schemaWithId();
 }
 
-size_t ParquetReader::numberOfRowGroups() const {
-  return readerBase_->fileMetaData().row_groups.size();
-}
-
 std::unique_ptr<dwio::common::RowReader> ParquetReader::createRowReader(
     const dwio::common::RowReaderOptions& options) const {
   return std::make_unique<ParquetRowReader>(readerBase_, options);
 }
+
+FileMetaDataPtr ParquetReader::fileMetaData() const {
+  return readerBase_->fileMetaData();
+}
+
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/ParquetReader.h b/velox/dwio/parquet/reader/ParquetReader.h
index 01e057e3e3a65..a40c456601796 100644
--- a/velox/dwio/parquet/reader/ParquetReader.h
+++ b/velox/dwio/parquet/reader/ParquetReader.h
@@ -16,12 +16,16 @@
 
 #pragma once
 
-#include "velox/dwio/common/BufferedInput.h"
 #include "velox/dwio/common/Reader.h"
 #include "velox/dwio/common/ReaderFactory.h"
-#include "velox/dwio/common/SelectiveColumnReader.h"
-#include "velox/dwio/parquet/reader/ParquetTypeWithId.h"
-#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
+#include "velox/dwio/parquet/reader/Metadata.h"
+
+namespace facebook::velox::dwio::common {
+
+class SelectiveColumnReader;
+class BufferedInput;
+
+} // namespace facebook::velox::dwio::common
 
 namespace facebook::velox::parquet {
 
@@ -55,10 +59,6 @@ class ParquetRowReader : public dwio::common::RowReader {
 
   std::optional<size_t> estimatedRowSize() const override;
 
-  const dwio::common::RowReaderOptions& getOptions() {
-    return options_;
-  }
-
   bool allPrefetchIssued() const override {
     //  Allow opening the next split while this is reading.
     return true;
@@ -74,33 +74,9 @@ class ParquetRowReader : public dwio::common::RowReader {
   // ReaderBase and determines the set of row groups to scan.
   void filterRowGroups();
 
-  // Positions the reader tre at the start of the next row group, as determined
-  // by filterRowGroups().
-  bool advanceToNextRowGroup();
-
-  memory::MemoryPool& pool_;
-  const std::shared_ptr<ReaderBase> readerBase_;
-  const dwio::common::RowReaderOptions options_;
-
-  // All row groups from file metadata.
-  const std::vector<thrift::RowGroup>& rowGroups_;
-
-  // Indices of row groups where stats match filters.
-  std::vector<uint32_t> rowGroupIds_;
-  std::vector<uint64_t> firstRowOfRowGroup_;
-  uint32_t nextRowGroupIdsIdx_;
-  const thrift::RowGroup* FOLLY_NULLABLE currentRowGroupPtr_{nullptr};
-  uint64_t rowsInCurrentRowGroup_;
-  uint64_t currentRowInGroup_;
-
-  // Number of row groups skipped based on stats.
-  int32_t skippedRowGroups_{0};
-
-  std::unique_ptr<dwio::common::SelectiveColumnReader> columnReader_;
-
-  RowTypePtr requestedType_;
-
-  dwio::common::ColumnReaderStatistics columnReaderStats_;
+ protected:
+  class Impl;
+  std::unique_ptr<Impl> impl_;
 };
 
 /// Implements the reader interface for Parquet.
@@ -124,11 +100,11 @@ class ParquetReader : public dwio::common::Reader {
   const std::shared_ptr<const dwio::common::TypeWithId>& typeWithId()
       const override;
 
-  size_t numberOfRowGroups() const;
-
   std::unique_ptr<dwio::common::RowReader> createRowReader(
       const dwio::common::RowReaderOptions& options = {}) const override;
 
+  FileMetaDataPtr fileMetaData() const;
+
  private:
   std::shared_ptr<ReaderBase> readerBase_;
 };
diff --git a/velox/dwio/parquet/reader/ParquetTypeWithId.cpp b/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
index 9cf325c7fa6ff..85c92d96f844f 100644
--- a/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
+++ b/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
@@ -32,7 +32,46 @@ bool containsList(const ParquetTypeWithId& type) {
   return false;
 }
 } // namespace
-using ::parquet::internal::LevelInfo;
+using arrow::LevelInfo;
+
+std::vector<std::unique_ptr<ParquetTypeWithId::TypeWithId>>
+ParquetTypeWithId::moveChildren() && {
+  std::vector<std::unique_ptr<TypeWithId>> children;
+  for (auto& child : getChildren()) {
+    auto type = child->type();
+    auto id = child->id();
+    auto maxId = child->maxId();
+    auto column = child->column();
+    auto* parquetChild = (ParquetTypeWithId*)child.get();
+    auto name = parquetChild->name_;
+    auto parquetType = parquetChild->parquetType_;
+    auto logicalType = parquetChild->logicalType_;
+    auto maxRepeat = parquetChild->maxRepeat_;
+    auto maxDefine = parquetChild->maxDefine_;
+    auto isOptional = parquetChild->isOptional_;
+    auto isRepeated = parquetChild->isRepeated_;
+    auto precision = parquetChild->precision_;
+    auto scale = parquetChild->scale_;
+    auto typeLength = parquetChild->typeLength_;
+    children.push_back(std::make_unique<ParquetTypeWithId>(
+        std::move(type),
+        std::move(*parquetChild).moveChildren(),
+        id,
+        maxId,
+        column,
+        std::move(name),
+        parquetType,
+        std::move(logicalType),
+        maxRepeat,
+        maxDefine,
+        isOptional,
+        isRepeated,
+        precision,
+        scale,
+        typeLength));
+  }
+  return children;
+}
 
 bool ParquetTypeWithId::hasNonRepeatedLeaf() const {
   if (type()->kind() == TypeKind::ARRAY) {
@@ -51,26 +90,21 @@ bool ParquetTypeWithId::hasNonRepeatedLeaf() const {
 }
 
 LevelMode ParquetTypeWithId::makeLevelInfo(LevelInfo& info) const {
-  int16_t repeatedAncestor = 0;
-  for (auto parent = parquetParent(); parent;
-       parent = parent->parquetParent()) {
-    if (parent->type()->kind() == TypeKind::ARRAY ||
-        parent->type()->kind() == TypeKind::MAP) {
-      repeatedAncestor = parent->maxDefine_;
-      break;
+  int repeatedAncestor = maxDefine_;
+  auto node = this;
+  do {
+    if (node->isOptional_) {
+      repeatedAncestor--;
     }
-  }
+    node = node->parquetParent();
+  } while (node && !node->isRepeated_);
   bool isList = type()->kind() == TypeKind::ARRAY;
   bool isStruct = type()->kind() == TypeKind::ROW;
   bool isMap = type()->kind() == TypeKind::MAP;
   bool hasList = false;
   if (isStruct) {
-    bool isAllLists = true;
     for (auto i = 0; i < getChildren().size(); ++i) {
-      auto child = parquetChildAt(i);
-      if (child.type()->kind() != TypeKind ::ARRAY) {
-        isAllLists = false;
-      }
+      auto& child = parquetChildAt(i);
       hasList |= hasList || containsList(child);
     }
   }
diff --git a/velox/dwio/parquet/reader/ParquetTypeWithId.h b/velox/dwio/parquet/reader/ParquetTypeWithId.h
index 08b1449a8f19e..e593c23be6acb 100644
--- a/velox/dwio/parquet/reader/ParquetTypeWithId.h
+++ b/velox/dwio/parquet/reader/ParquetTypeWithId.h
@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <parquet/level_conversion.h>
 #include "velox/dwio/common/TypeWithId.h"
 #include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
+#include "velox/dwio/parquet/writer/arrow/LevelConversion.h"
 
 namespace facebook::velox::parquet {
 
@@ -36,7 +36,7 @@ class ParquetTypeWithId : public dwio::common::TypeWithId {
 
   ParquetTypeWithId(
       TypePtr type,
-      std::vector<std::shared_ptr<const TypeWithId>>&& children,
+      std::vector<std::unique_ptr<TypeWithId>>&& children,
       uint32_t id,
       uint32_t maxId,
       uint32_t column,
@@ -45,6 +45,8 @@ class ParquetTypeWithId : public dwio::common::TypeWithId {
       std::optional<thrift::LogicalType> logicalType,
       uint32_t maxRepeat,
       uint32_t maxDefine,
+      bool isOptional,
+      bool isRepeated,
       int32_t precision = 0,
       int32_t scale = 0,
       int32_t typeLength = 0)
@@ -54,6 +56,8 @@ class ParquetTypeWithId : public dwio::common::TypeWithId {
         logicalType_(std::move(logicalType)),
         maxRepeat_(maxRepeat),
         maxDefine_(maxDefine),
+        isOptional_(isOptional),
+        isRepeated_(isRepeated),
         precision_(precision),
         scale_(scale),
         typeLength_(typeLength) {}
@@ -67,18 +71,22 @@ class ParquetTypeWithId : public dwio::common::TypeWithId {
     return *reinterpret_cast<const ParquetTypeWithId*>(childAt(index).get());
   }
 
-  const ParquetTypeWithId* FOLLY_NULLABLE parquetParent() const {
+  const ParquetTypeWithId* parquetParent() const {
     return reinterpret_cast<const ParquetTypeWithId*>(parent());
   }
 
   /// Fills 'info' and returns the mode for interpreting levels.
-  LevelMode makeLevelInfo(::parquet::internal::LevelInfo& info) const;
+  LevelMode makeLevelInfo(arrow::LevelInfo& info) const;
+
+  std::vector<std::unique_ptr<ParquetTypeWithId::TypeWithId>> moveChildren() &&;
 
   const std::string name_;
   const std::optional<thrift::Type::type> parquetType_;
   const std::optional<thrift::LogicalType> logicalType_;
   const uint32_t maxRepeat_;
   const uint32_t maxDefine_;
+  const bool isOptional_;
+  const bool isRepeated_;
   const int32_t precision_;
   const int32_t scale_;
   const int32_t typeLength_;
diff --git a/velox/dwio/parquet/reader/RepeatedColumnReader.cpp b/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
index d0da3f77577a9..f076aec8a5c5b 100644
--- a/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
+++ b/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
@@ -20,9 +20,11 @@
 
 namespace facebook::velox::parquet {
 
+class ParquetTypeWithId;
+
 namespace {
-PageReader* FOLLY_NULLABLE readLeafRepDefs(
-    dwio::common::SelectiveColumnReader* FOLLY_NONNULL reader,
+PageReader* readLeafRepDefs(
+    dwio::common::SelectiveColumnReader* reader,
     int32_t numTop,
     bool mustRead) {
   auto children = reader->children();
@@ -98,33 +100,33 @@ void enqueueChildren(
 void ensureRepDefs(
     dwio::common::SelectiveColumnReader& reader,
     int32_t numTop) {
-  auto& nodeType =
+  auto& fileType =
       *reinterpret_cast<const ParquetTypeWithId*>(&reader.fileType());
   // Check that this is a direct child of the root struct.
-  if (nodeType.parent() && !nodeType.parent()->parent()) {
+  if (fileType.parent() && !fileType.parent()->parent()) {
     skipUnreadLengthsAndNulls(reader);
     readLeafRepDefs(&reader, numTop, true);
   }
 }
 
 MapColumnReader::MapColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     ParquetParams& params,
     common::ScanSpec& scanSpec)
     : dwio::common::SelectiveMapColumnReader(
           requestedType,
-          dataType,
+          fileType,
           params,
           scanSpec) {
-  DWIO_ENSURE_EQ(fileType_->id(), dataType->id(), "working on the same node");
+  DWIO_ENSURE_EQ(fileType_->id(), fileType->id(), "working on the same node");
   auto& keyChildType = requestedType->childAt(0);
   auto& elementChildType = requestedType->childAt(1);
   keyReader_ = ParquetColumnReader::build(
       keyChildType, fileType_->childAt(0), params, *scanSpec.children()[0]);
   elementReader_ = ParquetColumnReader::build(
       elementChildType, fileType_->childAt(1), params, *scanSpec.children()[1]);
-  reinterpret_cast<const ParquetTypeWithId*>(dataType.get())
+  reinterpret_cast<const ParquetTypeWithId*>(fileType.get())
       ->makeLevelInfo(levelInfo_);
   children_ = {keyReader_.get(), elementReader_.get()};
 }
@@ -162,10 +164,10 @@ void MapColumnReader::setLengthsFromRepDefs(PageReader& pageReader) {
   auto repDefRange = pageReader.repDefRange();
   int32_t numRepDefs = repDefRange.second - repDefRange.first;
   BufferPtr lengths = std::move(lengths_.lengths());
-  dwio::common::ensureCapacity<int32_t>(lengths, numRepDefs, &memoryPool_);
+  dwio::common::ensureCapacity<int32_t>(lengths, numRepDefs, memoryPool_);
   memset(lengths->asMutable<uint64_t>(), 0, lengths->size());
   dwio::common::ensureCapacity<uint64_t>(
-      nullsInReadRange_, bits::nwords(numRepDefs), &memoryPool_);
+      nullsInReadRange_, bits::nwords(numRepDefs), memoryPool_);
   auto numLists = pageReader.getLengthsAndNulls(
       LevelMode::kList,
       levelInfo_,
@@ -182,7 +184,7 @@ void MapColumnReader::setLengthsFromRepDefs(PageReader& pageReader) {
 
 void MapColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   // The topmost list reader reads the repdefs for the left subtree.
   ensureRepDefs(*this, offset + rows.back() + 1 - readOffset_);
@@ -213,24 +215,23 @@ void MapColumnReader::filterRowGroups(
     uint64_t rowGroupSize,
     const dwio::common::StatsContext& context,
     dwio::common::FormatData::FilterRowGroupsResult& result) const {
-  keyReader_->filterRowGroups(rowGroupSize, context, result);
-  elementReader_->filterRowGroups(rowGroupSize, context, result);
+  // empty placeholder to avoid incorrect calling on parent's impl
 }
 
 ListColumnReader::ListColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     ParquetParams& params,
     common::ScanSpec& scanSpec)
     : dwio::common::SelectiveListColumnReader(
           requestedType,
-          dataType,
+          fileType,
           params,
           scanSpec) {
   auto& childType = requestedType->childAt(0);
   child_ = ParquetColumnReader::build(
       childType, fileType_->childAt(0), params, *scanSpec.children()[0]);
-  reinterpret_cast<const ParquetTypeWithId*>(dataType.get())
+  reinterpret_cast<const ParquetTypeWithId*>(fileType.get())
       ->makeLevelInfo(levelInfo_);
   children_ = {child_.get()};
 }
@@ -267,10 +268,10 @@ void ListColumnReader::setLengthsFromRepDefs(PageReader& pageReader) {
   auto repDefRange = pageReader.repDefRange();
   int32_t numRepDefs = repDefRange.second - repDefRange.first;
   BufferPtr lengths = std::move(lengths_.lengths());
-  dwio::common::ensureCapacity<int32_t>(lengths, numRepDefs, &memoryPool_);
+  dwio::common::ensureCapacity<int32_t>(lengths, numRepDefs, memoryPool_);
   memset(lengths->asMutable<uint64_t>(), 0, lengths->size());
   dwio::common::ensureCapacity<uint64_t>(
-      nullsInReadRange_, bits::nwords(numRepDefs), &memoryPool_);
+      nullsInReadRange_, bits::nwords(numRepDefs), memoryPool_);
   auto numLists = pageReader.getLengthsAndNulls(
       LevelMode::kList,
       levelInfo_,
@@ -286,7 +287,8 @@ void ListColumnReader::setLengthsFromRepDefs(PageReader& pageReader) {
 }
 void ListColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   // The topmost list reader reads the repdefs for the left subtree.
   ensureRepDefs(*this, offset + rows.back() + 1 - readOffset_);
@@ -316,7 +318,7 @@ void ListColumnReader::filterRowGroups(
     uint64_t rowGroupSize,
     const dwio::common::StatsContext& context,
     dwio::common::FormatData::FilterRowGroupsResult& result) const {
-  child_->filterRowGroups(rowGroupSize, context, result);
+  // empty placeholder to avoid incorrect calling on parent's impl
 }
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/RepeatedColumnReader.h b/velox/dwio/parquet/reader/RepeatedColumnReader.h
index aaa05eff2a286..6aef4ff05239b 100644
--- a/velox/dwio/parquet/reader/RepeatedColumnReader.h
+++ b/velox/dwio/parquet/reader/RepeatedColumnReader.h
@@ -38,7 +38,7 @@ class RepeatedLengths {
     return nextLengthIndex_;
   }
 
-  void readLengths(int32_t* FOLLY_NONNULL lengths, int32_t numLengths) {
+  void readLengths(int32_t* lengths, int32_t numLengths) {
     VELOX_CHECK_LE(
         nextLengthIndex_ + numLengths, lengths_->size() / sizeof(int32_t));
     memcpy(
@@ -56,15 +56,15 @@ class RepeatedLengths {
 class MapColumnReader : public dwio::common::SelectiveMapColumnReader {
  public:
   MapColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       ParquetParams& params,
       common::ScanSpec& scanSpec);
 
   void prepareRead(
       vector_size_t offset,
       RowSet rows,
-      const uint64_t* FOLLY_NULLABLE incomingNulls) {
+      const uint64_t* incomingNulls) {
     // The prepare is done by the topmost list/map/struct.
   }
 
@@ -74,16 +74,16 @@ class MapColumnReader : public dwio::common::SelectiveMapColumnReader {
 
   void read(
       vector_size_t offset,
-      RowSet rows,
-      const uint64_t* FOLLY_NULLABLE /*incomingNulls*/) override;
+      const RowSet& rows,
+      const uint64_t* /*incomingNulls*/) override;
 
   void setLengths(BufferPtr lengths) {
     lengths_.setLengths(lengths);
   }
   void readLengths(
-      int32_t* FOLLY_NONNULL lengths,
+      int32_t* lengths,
       int32_t numLengths,
-      const uint64_t* FOLLY_NULLABLE /*nulls*/) override {
+      const uint64_t* /*nulls*/) override {
     lengths_.readLengths(lengths, numLengths);
   }
 
@@ -106,21 +106,21 @@ class MapColumnReader : public dwio::common::SelectiveMapColumnReader {
   RepeatedLengths lengths_;
   RepeatedLengths keyLengths_;
   RepeatedLengths elementLengths_;
-  ::parquet::internal::LevelInfo levelInfo_;
+  arrow::LevelInfo levelInfo_;
 };
 
 class ListColumnReader : public dwio::common::SelectiveListColumnReader {
  public:
   ListColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       ParquetParams& params,
       common::ScanSpec& scanSpec);
 
   void prepareRead(
       vector_size_t offset,
       RowSet rows,
-      const uint64_t* FOLLY_NULLABLE incomingNulls) {
+      const uint64_t* incomingNulls) {
     // The prepare is done by the topmost list/struct.
   }
 
@@ -130,16 +130,16 @@ class ListColumnReader : public dwio::common::SelectiveListColumnReader {
 
   void read(
       vector_size_t offset,
-      RowSet rows,
-      const uint64_t* FOLLY_NULLABLE /*incomingNulls*/) override;
+      const RowSet& rows,
+      const uint64_t* /*incomingNulls*/) override;
 
   void setLengths(BufferPtr lengths) {
     lengths_.setLengths(lengths);
   }
   void readLengths(
-      int32_t* FOLLY_NONNULL lengths,
+      int32_t* lengths,
       int32_t numLengths,
-      const uint64_t* FOLLY_NULLABLE /*nulls*/) override {
+      const uint64_t* /*nulls*/) override {
     lengths_.readLengths(lengths, numLengths);
   }
 
@@ -160,7 +160,7 @@ class ListColumnReader : public dwio::common::SelectiveListColumnReader {
 
  private:
   RepeatedLengths lengths_;
-  ::parquet::internal::LevelInfo levelInfo_;
+  arrow::LevelInfo levelInfo_;
 };
 
 /// Sets nulls and lengths for 'reader' and its children for the
diff --git a/velox/dwio/parquet/reader/RleBpDataDecoder.h b/velox/dwio/parquet/reader/RleBpDataDecoder.h
index 4b2ce3ae14272..2931e33085fd0 100644
--- a/velox/dwio/parquet/reader/RleBpDataDecoder.h
+++ b/velox/dwio/parquet/reader/RleBpDataDecoder.h
@@ -31,17 +31,11 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
  public:
   using super = facebook::velox::parquet::RleBpDecoder;
 
-  RleBpDataDecoder(
-      const char* FOLLY_NONNULL start,
-      const char* FOLLY_NONNULL end,
-      uint8_t bitWidth)
+  RleBpDataDecoder(const char* start, const char* end, uint8_t bitWidth)
       : super::RleBpDecoder{start, end, bitWidth} {}
 
   template <bool hasNulls>
-  inline void skip(
-      int32_t numValues,
-      int32_t current,
-      const uint64_t* FOLLY_NULLABLE nulls) {
+  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
     if (hasNulls) {
       numValues = bits::countNonNulls(nulls, current, current + numValues);
     }
@@ -54,7 +48,7 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
   }
 
   template <bool hasNulls, typename Visitor>
-  void readWithVisitor(const uint64_t* FOLLY_NULLABLE nulls, Visitor visitor) {
+  void readWithVisitor(const uint64_t* nulls, Visitor visitor) {
     if (dwio::common::useFastPath<Visitor, hasNulls>(visitor)) {
       fastPath<hasNulls>(nulls, visitor);
       return;
@@ -103,7 +97,7 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
 
  private:
   template <bool hasNulls, typename Visitor>
-  void fastPath(const uint64_t* FOLLY_NULLABLE nulls, Visitor& visitor) {
+  void fastPath(const uint64_t* nulls, Visitor& visitor) {
     constexpr bool hasFilter =
         !std::is_same_v<typename Visitor::FilterType, common::AlwaysTrue>;
     constexpr bool hasHook =
@@ -120,6 +114,11 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
           visitor.setAllNull(hasFilter ? 0 : numRows);
           return;
         }
+        if (hasHook && visitor.numValuesBias() > 0) {
+          for (auto& row : *outerVector) {
+            row += visitor.numValuesBias();
+          }
+        }
         bulkScan<hasFilter, hasHook, true>(
             folly::Range<const int32_t*>(rows, outerVector->size()),
             outerVector->data(),
@@ -144,6 +143,11 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
           visitor.setAllNull(hasFilter ? 0 : numRows);
           return;
         }
+        if (hasHook && visitor.numValuesBias() > 0) {
+          for (auto& row : *outerVector) {
+            row += visitor.numValuesBias();
+          }
+        }
         bulkScan<hasFilter, hasHook, true>(
             *innerVector, outerVector->data(), visitor);
         skip<false>(tailSkip, 0, nullptr);
@@ -155,13 +159,13 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
 
   template <bool hasFilter, bool hasHook, bool scatter, typename Visitor>
   void processRun(
-      const int32_t* FOLLY_NONNULL rows,
+      const int32_t* rows,
       int32_t rowIndex,
       int32_t currentRow,
       int32_t numRows,
-      const int32_t* FOLLY_NULLABLE scatterRows,
-      int32_t* FOLLY_NULLABLE filterHits,
-      typename Visitor::DataType* FOLLY_NONNULL values,
+      const int32_t* scatterRows,
+      int32_t* filterHits,
+      typename Visitor::DataType* values,
       int32_t& numValues,
       Visitor& visitor) {
     auto numBits = bitOffset_ +
@@ -194,7 +198,7 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
   // last in rows that falls in the current run.
   template <bool dense>
   std::pair<int32_t, std::int32_t> findNumInRun(
-      const int32_t* FOLLY_NONNULL rows,
+      const int32_t* rows,
       int32_t rowIndex,
       int32_t numRows,
       int32_t currentRow) {
@@ -220,7 +224,7 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
   template <bool hasFilter, bool hasHook, bool scatter, typename Visitor>
   void bulkScan(
       folly::Range<const int32_t*> nonNullRows,
-      const int32_t* FOLLY_NULLABLE scatterRows,
+      const int32_t* scatterRows,
       Visitor& visitor) {
     auto numAllRows = visitor.numRows();
     visitor.setRows(nonNullRows);
@@ -279,16 +283,16 @@ class RleBpDataDecoder : public facebook::velox::parquet::RleBpDecoder {
   // Loads a bit field from 'ptr' + bitOffset for up to 'bitWidth' bits. makes
   // sure not to access bytes past lastSafeWord + 7.
   static inline uint64_t safeLoadBits(
-      const char* FOLLY_NONNULL ptr,
+      const char* ptr,
       int32_t bitOffset,
       uint8_t bitWidth,
-      const char* FOLLY_NONNULL lastSafeWord) {
+      const char* lastSafeWord) {
     VELOX_DCHECK_GE(7, bitOffset);
     VELOX_DCHECK_GE(56, bitWidth);
     if (ptr < lastSafeWord) {
       return *reinterpret_cast<const uint64_t*>(ptr) >> bitOffset;
     }
-    int32_t byteWidth = bits::roundUp(bitOffset + bitWidth, 8) / 8;
+    const int32_t byteWidth = bits::divRoundUp(bitOffset + bitWidth, 8);
     return bits::loadPartialWord(
                reinterpret_cast<const uint8_t*>(ptr), byteWidth) >>
         bitOffset;
diff --git a/velox/dwio/parquet/reader/RleBpDecoder.cpp b/velox/dwio/parquet/reader/RleBpDecoder.cpp
index 54a660e10c6b2..4b044da9ac27f 100644
--- a/velox/dwio/parquet/reader/RleBpDecoder.cpp
+++ b/velox/dwio/parquet/reader/RleBpDecoder.cpp
@@ -16,7 +16,7 @@
 
 #include "velox/dwio/parquet/reader/RleBpDecoder.h"
 
-#include "velox/dwio/common/BitPackDecoder.h"
+#include <folly/Varint.h>
 
 namespace facebook::velox::parquet {
 
@@ -38,8 +38,8 @@ void RleBpDecoder::skip(uint64_t numValues) {
 
 void RleBpDecoder::readBits(
     int32_t numValues,
-    uint64_t* FOLLY_NONNULL outputBuffer,
-    bool* FOLLY_NULLABLE allOnes) {
+    uint64_t* outputBuffer,
+    bool* allOnes) {
   VELOX_CHECK_EQ(1, bitWidth_);
   auto toRead = numValues;
   int32_t numWritten = 0;
diff --git a/velox/dwio/parquet/reader/RleBpDecoder.h b/velox/dwio/parquet/reader/RleBpDecoder.h
index 5669cf93fa8f6..ac07ed76ad0c0 100644
--- a/velox/dwio/parquet/reader/RleBpDecoder.h
+++ b/velox/dwio/parquet/reader/RleBpDecoder.h
@@ -19,23 +19,16 @@
 #include "velox/common/base/BitUtil.h"
 #include "velox/dwio/common/BitPackDecoder.h"
 #include "velox/dwio/common/DecoderUtil.h"
-#include "velox/type/Filter.h"
-#include "velox/vector/LazyVector.h"
-
-#include <folly/Varint.h>
 
 namespace facebook::velox::parquet {
 
 class RleBpDecoder {
  public:
-  RleBpDecoder(
-      const char* FOLLY_NONNULL start,
-      const char* FOLLY_NONNULL end,
-      uint8_t bitWidth)
+  RleBpDecoder(const char* start, const char* end, uint8_t bitWidth)
       : bufferStart_(start),
         bufferEnd_(end),
         bitWidth_(bitWidth),
-        byteWidth_(bits::roundUp(bitWidth, 8) / 8),
+        byteWidth_(bits::divRoundUp(bitWidth, 8)),
         bitMask_(bits::lowMask(bitWidth)),
         lastSafeWord_(end - sizeof(uint64_t)) {}
 
@@ -102,10 +95,8 @@ class RleBpDecoder {
   /// not copy them into 'buffer' but instead may set '*allOnes' to
   /// true. If allOnes is non-nullptr and not all bits are ones, then
   /// '*allOnes' is set to false and the bits are copied to 'buffer'.
-  void readBits(
-      int32_t numValues,
-      uint64_t* FOLLY_NONNULL outputBuffer,
-      bool* FOLLY_NULLABLE allOnes = nullptr);
+  void
+  readBits(int32_t numValues, uint64_t* outputBuffer, bool* allOnes = nullptr);
 
  protected:
   void readHeader();
@@ -127,12 +118,12 @@ class RleBpDecoder {
     remainingUnpackedValuesOffset_ += numValues;
   }
 
-  const char* FOLLY_NULLABLE bufferStart_;
-  const char* FOLLY_NULLABLE bufferEnd_;
+  const char* bufferStart_;
+  const char* bufferEnd_;
   const int8_t bitWidth_;
   const int8_t byteWidth_;
   const uint64_t bitMask_;
-  const char* FOLLY_NONNULL const lastSafeWord_;
+  const char* const lastSafeWord_;
   uint64_t remainingValues_{0};
   int64_t value_;
   int8_t bitOffset_{0};
diff --git a/velox/dwio/parquet/reader/Statistics.cpp b/velox/dwio/parquet/reader/Statistics.cpp
deleted file mode 100644
index 3712c5978a5c8..0000000000000
--- a/velox/dwio/parquet/reader/Statistics.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/dwio/parquet/reader/Statistics.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::parquet {
-
-std::unique_ptr<dwio::common::ColumnStatistics> buildColumnStatisticsFromThrift(
-    const thrift::Statistics& columnChunkStats,
-    const velox::Type& type,
-    uint64_t numRowsInRowGroup) {
-  std::optional<uint64_t> nullCount = columnChunkStats.__isset.null_count
-      ? std::optional<uint64_t>(columnChunkStats.null_count)
-      : std::nullopt;
-  std::optional<uint64_t> valueCount = nullCount.has_value()
-      ? std::optional<uint64_t>(numRowsInRowGroup - nullCount.value())
-      : std::nullopt;
-  std::optional<bool> hasNull = columnChunkStats.__isset.null_count
-      ? std::optional<bool>(columnChunkStats.null_count > 0)
-      : std::nullopt;
-
-  switch (type.kind()) {
-    case TypeKind::BOOLEAN:
-      return std::make_unique<dwio::common::BooleanColumnStatistics>(
-          valueCount, hasNull, std::nullopt, std::nullopt, std::nullopt);
-    case TypeKind::TINYINT:
-      return std::make_unique<dwio::common::IntegerColumnStatistics>(
-          valueCount,
-          hasNull,
-          std::nullopt,
-          std::nullopt,
-          getMin<int8_t>(columnChunkStats),
-          getMax<int8_t>(columnChunkStats),
-          std::nullopt);
-    case TypeKind::SMALLINT:
-      return std::make_unique<dwio::common::IntegerColumnStatistics>(
-          valueCount,
-          hasNull,
-          std::nullopt,
-          std::nullopt,
-          getMin<int16_t>(columnChunkStats),
-          getMax<int16_t>(columnChunkStats),
-          std::nullopt);
-    case TypeKind::INTEGER:
-      return std::make_unique<dwio::common::IntegerColumnStatistics>(
-          valueCount,
-          hasNull,
-          std::nullopt,
-          std::nullopt,
-          getMin<int32_t>(columnChunkStats),
-          getMax<int32_t>(columnChunkStats),
-          std::nullopt);
-    case TypeKind::BIGINT:
-      return std::make_unique<dwio::common::IntegerColumnStatistics>(
-          valueCount,
-          hasNull,
-          std::nullopt,
-          std::nullopt,
-          getMin<int64_t>(columnChunkStats),
-          getMax<int64_t>(columnChunkStats),
-          std::nullopt);
-    case TypeKind::REAL:
-      return std::make_unique<dwio::common::DoubleColumnStatistics>(
-          valueCount,
-          hasNull,
-          std::nullopt,
-          std::nullopt,
-          getMin<float>(columnChunkStats),
-          getMax<float>(columnChunkStats),
-          std::nullopt);
-    case TypeKind::DOUBLE:
-      return std::make_unique<dwio::common::DoubleColumnStatistics>(
-          valueCount,
-          hasNull,
-          std::nullopt,
-          std::nullopt,
-          getMin<double>(columnChunkStats),
-          getMax<double>(columnChunkStats),
-          std::nullopt);
-    case TypeKind::VARCHAR:
-    case TypeKind::VARBINARY:
-      return std::make_unique<dwio::common::StringColumnStatistics>(
-          valueCount,
-          hasNull,
-          std::nullopt,
-          std::nullopt,
-          getMin<std::string>(columnChunkStats),
-          getMax<std::string>(columnChunkStats),
-          std::nullopt);
-
-    default:
-      return std::make_unique<dwio::common::ColumnStatistics>(
-          valueCount, hasNull, std::nullopt, std::nullopt);
-  }
-}
-
-} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/Statistics.h b/velox/dwio/parquet/reader/Statistics.h
deleted file mode 100644
index bdd3c2854ef0c..0000000000000
--- a/velox/dwio/parquet/reader/Statistics.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/dwio/common/Statistics.h"
-#include "velox/dwio/parquet/thrift/ParquetThriftTypes.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::parquet {
-
-// TODO: provide function to merge multiple Statistics into one
-
-template <typename T>
-inline const T load(const char* ptr) {
-  T ret;
-  memcpy(&ret, ptr, sizeof(ret));
-  return ret;
-}
-
-template <typename T>
-inline std::optional<T> getMin(const thrift::Statistics& columnChunkStats) {
-  return columnChunkStats.__isset.min_value
-      ? load<T>(columnChunkStats.min_value.data())
-      : (columnChunkStats.__isset.min
-             ? std::optional<T>(load<T>(columnChunkStats.min.data()))
-             : std::nullopt);
-}
-
-template <typename T>
-inline std::optional<T> getMax(const thrift::Statistics& columnChunkStats) {
-  return columnChunkStats.__isset.max_value
-      ? std::optional<T>(load<T>(columnChunkStats.max_value.data()))
-      : (columnChunkStats.__isset.max
-             ? std::optional<T>(load<T>(columnChunkStats.max.data()))
-             : std::nullopt);
-}
-
-template <>
-inline std::optional<std::string> getMin(
-    const thrift::Statistics& columnChunkStats) {
-  return columnChunkStats.__isset.min_value
-      ? std::optional(columnChunkStats.min_value)
-      : (columnChunkStats.__isset.min ? std::optional(columnChunkStats.min)
-                                      : std::nullopt);
-}
-
-template <>
-inline std::optional<std::string> getMax(
-    const thrift::Statistics& columnChunkStats) {
-  return columnChunkStats.__isset.max_value
-      ? std::optional(columnChunkStats.max_value)
-      : (columnChunkStats.__isset.max ? std::optional(columnChunkStats.max)
-                                      : std::nullopt);
-}
-
-std::unique_ptr<dwio::common::ColumnStatistics> buildColumnStatisticsFromThrift(
-    const thrift::Statistics& columnChunkStats,
-    const velox::Type& type,
-    uint64_t numRowsInRowGroup);
-
-} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/StringColumnReader.cpp b/velox/dwio/parquet/reader/StringColumnReader.cpp
index 8834a38becaa6..68ca8c4ba3529 100644
--- a/velox/dwio/parquet/reader/StringColumnReader.cpp
+++ b/velox/dwio/parquet/reader/StringColumnReader.cpp
@@ -15,124 +15,42 @@
  */
 
 #include "velox/dwio/parquet/reader/StringColumnReader.h"
-#include "velox/dwio/common/BufferUtil.h"
+
+#include "velox/dwio/common/SelectiveColumnReaderInternal.h"
 
 namespace facebook::velox::parquet {
 
 StringColumnReader::StringColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     ParquetParams& params,
     common::ScanSpec& scanSpec)
-    : SelectiveColumnReader(nodeType->type(), params, scanSpec, nodeType) {}
+    : SelectiveColumnReader(fileType->type(), fileType, params, scanSpec) {}
 
 uint64_t StringColumnReader::skip(uint64_t numValues) {
   formatData_->skip(numValues);
   return numValues;
 }
 
-template <typename TFilter, bool isDense, typename ExtractValues>
-void StringColumnReader::readHelper(
-    common::Filter* filter,
-    RowSet rows,
-    ExtractValues extractValues) {
-  formatData_->as<ParquetData>().readWithVisitor(
-      dwio::common::
-          ColumnVisitor<folly::StringPiece, TFilter, ExtractValues, isDense>(
-              *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
-}
-
-template <bool isDense, typename ExtractValues>
-void StringColumnReader::processFilter(
-    common::Filter* filter,
-    RowSet rows,
-    ExtractValues extractValues) {
-  switch (filter ? filter->kind() : common::FilterKind::kAlwaysTrue) {
-    case common::FilterKind::kAlwaysTrue:
-      readHelper<common::AlwaysTrue, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kIsNull:
-      filterNulls<StringView>(
-          rows,
-          true,
-          !std::is_same<decltype(extractValues), dwio::common::DropValues>::
-              value);
-      break;
-    case common::FilterKind::kIsNotNull:
-      if (std::is_same<decltype(extractValues), dwio::common::DropValues>::
-              value) {
-        filterNulls<StringView>(rows, false, false);
-      } else {
-        readHelper<common::IsNotNull, isDense>(filter, rows, extractValues);
-      }
-      break;
-    case common::FilterKind::kBytesRange:
-      readHelper<common::BytesRange, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kNegatedBytesRange:
-      readHelper<common::NegatedBytesRange, isDense>(
-          filter, rows, extractValues);
-      break;
-    case common::FilterKind::kBytesValues:
-      readHelper<common::BytesValues, isDense>(filter, rows, extractValues);
-      break;
-    case common::FilterKind::kNegatedBytesValues:
-      readHelper<common::NegatedBytesValues, isDense>(
-          filter, rows, extractValues);
-      break;
-    default:
-      readHelper<common::Filter, isDense>(filter, rows, extractValues);
-      break;
-  }
-}
-
 void StringColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* incomingNulls) {
   prepareRead<folly::StringPiece>(offset, rows, incomingNulls);
-  bool isDense = rows.back() == rows.size() - 1;
-  if (scanSpec_->keepValues()) {
-    if (scanSpec_->valueHook()) {
-      if (isDense) {
-        readHelper<common::AlwaysTrue, true>(
-            &dwio::common::alwaysTrue(),
-            rows,
-            dwio::common::ExtractToGenericHook(scanSpec_->valueHook()));
-      } else {
-        readHelper<common::AlwaysTrue, false>(
-            &dwio::common::alwaysTrue(),
-            rows,
-            dwio::common::ExtractToGenericHook(scanSpec_->valueHook()));
-      }
-      return;
-    }
-    if (isDense) {
-      processFilter<true>(
-          scanSpec_->filter(), rows, dwio::common::ExtractToReader(this));
-    } else {
-      processFilter<false>(
-          scanSpec_->filter(), rows, dwio::common::ExtractToReader(this));
-    }
-  } else {
-    if (isDense) {
-      processFilter<true>(
-          scanSpec_->filter(), rows, dwio::common::DropValues());
-    } else {
-      processFilter<false>(
-          scanSpec_->filter(), rows, dwio::common::DropValues());
-    }
-  }
+  dwio::common::StringColumnReadWithVisitorHelper<true, false>(
+      *this, rows)([&](auto visitor) {
+    formatData_->as<ParquetData>().readWithVisitor(visitor);
+  });
   readOffset_ += rows.back() + 1;
 }
 
-void StringColumnReader::getValues(RowSet rows, VectorPtr* result) {
+void StringColumnReader::getValues(const RowSet& rows, VectorPtr* result) {
   if (scanState_.dictionary.values) {
     auto dictionaryValues =
         formatData_->as<ParquetData>().dictionaryValues(fileType_->type());
     compactScalarValues<int32_t, int32_t>(rows, false);
 
     *result = std::make_shared<DictionaryVector<StringView>>(
-        &memoryPool_, resultNulls(), numValues_, dictionaryValues, values_);
+        memoryPool_, resultNulls(), numValues_, dictionaryValues, values_);
     return;
   }
   rawStringBuffer_ = nullptr;
diff --git a/velox/dwio/parquet/reader/StringColumnReader.h b/velox/dwio/parquet/reader/StringColumnReader.h
index 767759d07822a..8c3a9a2a6b0f0 100644
--- a/velox/dwio/parquet/reader/StringColumnReader.h
+++ b/velox/dwio/parquet/reader/StringColumnReader.h
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include "velox/dwio/common/SelectiveColumnReaderInternal.h"
+#include "velox/dwio/common/SelectiveColumnReader.h"
 #include "velox/dwio/parquet/reader/ParquetData.h"
 
 namespace facebook::velox::parquet {
@@ -25,7 +25,7 @@ class StringColumnReader : public dwio::common::SelectiveColumnReader {
  public:
   using ValueType = StringView;
   StringColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& nodeType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       ParquetParams& params,
       common::ScanSpec& scanSpec);
 
@@ -43,33 +43,14 @@ class StringColumnReader : public dwio::common::SelectiveColumnReader {
 
   uint64_t skip(uint64_t numValues) override;
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override;
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
-  void getValues(RowSet rows, VectorPtr* result) override;
+  void getValues(const RowSet& rows, VectorPtr* result) override;
 
   void dedictionarize() override;
-
- private:
-  template <bool hasNulls>
-  void skipInDecode(int32_t numValues, int32_t current, const uint64_t* nulls);
-
-  folly::StringPiece readValue(int32_t length);
-
-  template <bool hasNulls, typename Visitor>
-  void decode(const uint64_t* nulls, Visitor visitor);
-
-  template <typename TVisitor>
-  void readWithVisitor(RowSet rows, TVisitor visitor);
-
-  template <typename TFilter, bool isDense, typename ExtractValues>
-  void readHelper(common::Filter* filter, RowSet rows, ExtractValues values);
-
-  template <bool isDense, typename ExtractValues>
-  void processFilter(
-      common::Filter* filter,
-      RowSet rows,
-      ExtractValues extractValues);
 };
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/StringDecoder.h b/velox/dwio/parquet/reader/StringDecoder.h
index bbb6c50dcddbb..740a91cd9a537 100644
--- a/velox/dwio/parquet/reader/StringDecoder.h
+++ b/velox/dwio/parquet/reader/StringDecoder.h
@@ -16,31 +16,22 @@
 
 #pragma once
 
-#include "velox/common/base/GTestMacros.h"
-#include "velox/common/base/Nulls.h"
-#include "velox/dwio/common/DecoderUtil.h"
-#include "velox/dwio/common/IntDecoder.h"
-#include "velox/dwio/common/TypeUtil.h"
-
 namespace facebook::velox::parquet {
 
 class StringDecoder {
  public:
-  StringDecoder(const char* FOLLY_NONNULL start, const char* FOLLY_NONNULL end)
+  StringDecoder(const char* start, const char* end, int fixedLength = -1)
       : bufferStart_(start),
         bufferEnd_(end),
-
-        lastSafeWord_(end - simd::kPadding) {}
+        lastSafeWord_(end - simd::kPadding),
+        fixedLength_(fixedLength) {}
 
   void skip(uint64_t numValues) {
     skip<false>(numValues, 0, nullptr);
   }
 
   template <bool hasNulls>
-  inline void skip(
-      int32_t numValues,
-      int32_t current,
-      const uint64_t* FOLLY_NULLABLE nulls) {
+  inline void skip(int32_t numValues, int32_t current, const uint64_t* nulls) {
     if (hasNulls) {
       numValues = bits::countNonNulls(nulls, current, current + numValues);
     }
@@ -50,8 +41,9 @@ class StringDecoder {
   }
 
   template <bool hasNulls, typename Visitor>
-  void readWithVisitor(const uint64_t* FOLLY_NULLABLE nulls, Visitor visitor) {
+  void readWithVisitor(const uint64_t* nulls, Visitor visitor) {
     int32_t current = visitor.start();
+    int32_t numValues = 0;
     skip<hasNulls>(current, 0, nulls);
     int32_t toSkip;
     bool atEnd = false;
@@ -66,26 +58,36 @@ class StringDecoder {
             skip<false>(toSkip, current, nullptr);
           }
           if (atEnd) {
+            if constexpr (Visitor::kHasHook) {
+              visitor.setNumValues(
+                  Visitor::kHasFilter ? numValues : visitor.numRows());
+            }
             return;
           }
         }
 
         // We are at a non-null value on a row to visit.
-        toSkip = visitor.process(readString(), atEnd);
+        toSkip = visitor.process(
+            fixedLength_ > 0 ? readFixedString() : readString(), atEnd);
       }
       ++current;
+      ++numValues;
       if (toSkip) {
         skip<hasNulls>(toSkip, current, nulls);
         current += toSkip;
       }
       if (atEnd) {
+        if constexpr (Visitor::kHasHook) {
+          visitor.setNumValues(
+              Visitor::kHasFilter ? numValues : visitor.numRows());
+        }
         return;
       }
     }
   }
 
  private:
-  int32_t lengthAt(const char* FOLLY_NONNULL buffer) {
+  int32_t lengthAt(const char* buffer) {
     return *reinterpret_cast<const int32_t*>(buffer);
   }
 
@@ -94,9 +96,16 @@ class StringDecoder {
     bufferStart_ += length + sizeof(int32_t);
     return folly::StringPiece(bufferStart_ - length, length);
   }
-  const char* FOLLY_NONNULL bufferStart_;
-  const char* FOLLY_NONNULL bufferEnd_;
-  const char* FOLLY_NONNULL const lastSafeWord_;
+
+  folly::StringPiece readFixedString() {
+    bufferStart_ += fixedLength_;
+    return folly::StringPiece(bufferStart_ - fixedLength_, fixedLength_);
+  }
+
+  const char* bufferStart_;
+  const char* bufferEnd_;
+  const char* const lastSafeWord_;
+  const int fixedLength_;
 };
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/StructColumnReader.cpp b/velox/dwio/parquet/reader/StructColumnReader.cpp
index a0af6324477f6..90c407c961358 100644
--- a/velox/dwio/parquet/reader/StructColumnReader.cpp
+++ b/velox/dwio/parquet/reader/StructColumnReader.cpp
@@ -15,27 +15,38 @@
  */
 
 #include "velox/dwio/parquet/reader/StructColumnReader.h"
+
+#include "velox/dwio/common/BufferedInput.h"
+#include "velox/dwio/parquet/reader/ParquetColumnReader.h"
 #include "velox/dwio/parquet/reader/RepeatedColumnReader.h"
 
+namespace facebook::velox::common {
+class ScanSpec;
+}
+
 namespace facebook::velox::parquet {
 
 StructColumnReader::StructColumnReader(
-    const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     ParquetParams& params,
     common::ScanSpec& scanSpec)
-    : SelectiveStructColumnReader(requestedType, dataType, params, scanSpec) {
+    : SelectiveStructColumnReader(requestedType, fileType, params, scanSpec) {
   auto& childSpecs = scanSpec_->stableChildren();
   for (auto i = 0; i < childSpecs.size(); ++i) {
     auto childSpec = childSpecs[i];
     if (childSpecs[i]->isConstant()) {
       continue;
     }
-    auto childDataType = fileType_->childByName(childSpec->fieldName());
+    if (childSpecs[i]->isExplicitRowNumber()) {
+      continue;
+    }
+    auto childFileType = fileType_->childByName(childSpec->fieldName());
     auto childRequestedType =
-        requestedType_->childByName(childSpec->fieldName());
+        requestedType_->asRow().findChild(childSpec->fieldName());
     addChild(ParquetColumnReader::build(
-        childRequestedType, childDataType, params, *childSpec));
+        childRequestedType, childFileType, params, *childSpec));
+
     childSpecs[i]->setSubscript(children_.size() - 1);
   }
   auto type = reinterpret_cast<const ParquetTypeWithId*>(fileType_.get());
@@ -90,7 +101,7 @@ StructColumnReader::findBestLeaf() {
 
 void StructColumnReader::read(
     vector_size_t offset,
-    RowSet rows,
+    const RowSet& rows,
     const uint64_t* /*incomingNulls*/) {
   ensureRepDefs(*this, offset + rows.back() + 1 - readOffset_);
   SelectiveStructColumnReader::read(offset, rows, nullptr);
@@ -168,7 +179,7 @@ void StructColumnReader::setNullsFromRepDefs(PageReader& pageReader) {
   auto repDefRange = pageReader.repDefRange();
   int32_t numRepDefs = repDefRange.second - repDefRange.first;
   dwio::common::ensureCapacity<uint64_t>(
-      nullsInReadRange_, bits::nwords(numRepDefs), &memoryPool_);
+      nullsInReadRange_, bits::nwords(numRepDefs), memoryPool_);
   auto numStructs = pageReader.getLengthsAndNulls(
       levelMode_,
       levelInfo_,
diff --git a/velox/dwio/parquet/reader/StructColumnReader.h b/velox/dwio/parquet/reader/StructColumnReader.h
index 30e8ebf6d62c6..d9c41e3849d80 100644
--- a/velox/dwio/parquet/reader/StructColumnReader.h
+++ b/velox/dwio/parquet/reader/StructColumnReader.h
@@ -17,20 +17,30 @@
 #pragma once
 
 #include "velox/dwio/common/SelectiveStructColumnReader.h"
-#include "velox/dwio/parquet/reader/ParquetColumnReader.h"
+#include "velox/dwio/parquet/writer/arrow/LevelConversion.h"
+
+namespace facebook::velox::dwio::common {
+class BufferedInput;
+}
 
 namespace facebook::velox::parquet {
 
+enum class LevelMode;
+class PageReader;
+class ParquetParams;
+
 class StructColumnReader : public dwio::common::SelectiveStructColumnReader {
  public:
   StructColumnReader(
-      const std::shared_ptr<const dwio::common::TypeWithId>& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& dataType,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       ParquetParams& params,
       common::ScanSpec& scanSpec);
 
-  void read(vector_size_t offset, RowSet rows, const uint64_t* incomingNulls)
-      override;
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* incomingNulls) override;
 
   void seekToRowGroup(uint32_t index) override;
 
@@ -44,12 +54,12 @@ class StructColumnReader : public dwio::common::SelectiveStructColumnReader {
   // No-op in Parquet. All readers switch row groups at the same time, there is
   // no on-demand skipping to a new row group.
   void advanceFieldReader(
-      dwio::common::SelectiveColumnReader* FOLLY_NONNULL /*reader*/,
+      dwio::common::SelectiveColumnReader* /*reader*/,
       vector_size_t /*offset*/) override {}
 
   void setNullsFromRepDefs(PageReader& pageReader);
 
-  dwio::common::SelectiveColumnReader* FOLLY_NULLABLE childForRepDefs() const {
+  dwio::common::SelectiveColumnReader* childForRepDefs() const {
     return childForRepDefs_;
   }
 
@@ -76,7 +86,7 @@ class StructColumnReader : public dwio::common::SelectiveStructColumnReader {
 
   // Leaf column reader used for getting nullability information for
   // 'this'. This is nullptr for the root of a table.
-  dwio::common::SelectiveColumnReader* FOLLY_NULLABLE childForRepDefs_{nullptr};
+  dwio::common::SelectiveColumnReader* childForRepDefs_{nullptr};
 
   // Mode for getting nulls from repdefs. kStructOverLists if 'this'
   // only has list children.
@@ -84,7 +94,7 @@ class StructColumnReader : public dwio::common::SelectiveStructColumnReader {
 
   // The level information for extracting nulls for 'this' from the
   // repdefs in a leaf PageReader.
-  ::parquet::internal::LevelInfo levelInfo_;
+  arrow::LevelInfo levelInfo_;
 };
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/TimestampColumnReader.h b/velox/dwio/parquet/reader/TimestampColumnReader.h
new file mode 100644
index 0000000000000..d7de779f83a16
--- /dev/null
+++ b/velox/dwio/parquet/reader/TimestampColumnReader.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/dwio/parquet/reader/IntegerColumnReader.h"
+#include "velox/dwio/parquet/reader/ParquetColumnReader.h"
+
+namespace facebook::velox::parquet {
+
+class TimestampColumnReader : public IntegerColumnReader {
+ public:
+  TimestampColumnReader(
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
+      ParquetParams& params,
+      common::ScanSpec& scanSpec)
+      : IntegerColumnReader(requestedType, fileType, params, scanSpec),
+        timestampPrecision_(params.timestampPrecision()) {}
+
+  bool hasBulkPath() const override {
+    return false;
+  }
+
+  void getValues(const RowSet& rows, VectorPtr* result) override {
+    getFlatValues<Timestamp, Timestamp>(rows, result, requestedType_);
+    if (allNull_) {
+      return;
+    }
+
+    // Adjust timestamp nanos to the requested precision.
+    VectorPtr resultVector = *result;
+    auto rawValues =
+        resultVector->asUnchecked<FlatVector<Timestamp>>()->mutableRawValues();
+    for (auto i = 0; i < numValues_; ++i) {
+      if (resultVector->isNullAt(i)) {
+        continue;
+      }
+      const auto timestamp = rawValues[i];
+      uint64_t nanos = timestamp.getNanos();
+      switch (timestampPrecision_) {
+        case TimestampPrecision::kMilliseconds:
+          nanos = nanos / 1'000'000 * 1'000'000;
+          break;
+        case TimestampPrecision::kMicroseconds:
+          nanos = nanos / 1'000 * 1'000;
+          break;
+        case TimestampPrecision::kNanoseconds:
+          break;
+      }
+      rawValues[i] = Timestamp(timestamp.getSeconds(), nanos);
+    }
+  }
+
+  void read(
+      vector_size_t offset,
+      const RowSet& rows,
+      const uint64_t* /*incomingNulls*/) override {
+    auto& data = formatData_->as<ParquetData>();
+    // Use int128_t as a workaroud. Timestamp in Velox is of 16-byte length.
+    prepareRead<int128_t>(offset, rows, nullptr);
+    readCommon<IntegerColumnReader, true>(rows);
+    readOffset_ += rows.back() + 1;
+  }
+
+ private:
+  // The requested precision can be specified from HiveConfig to read timestamp
+  // from Parquet.
+  TimestampPrecision timestampPrecision_;
+};
+
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/tests/CMakeLists.txt b/velox/dwio/parquet/tests/CMakeLists.txt
index bc595b3c5baa1..6cac19e7e196c 100644
--- a/velox/dwio/parquet/tests/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/CMakeLists.txt
@@ -15,9 +15,11 @@
 set(TEST_LINK_LIBS
     velox_dwio_common_test_utils
     velox_vector_test_lib
-    gtest
-    gtest_main
-    gmock
+    velox_exec_test_lib
+    velox_temp_path
+    GTest::gtest
+    GTest::gtest_main
+    GTest::gmock
     gflags::gflags
     ${GLOG}
     ${FILESYSTEM})
@@ -41,3 +43,6 @@ target_link_libraries(
   velox_aggregates
   velox_tpch_gen
   ${TEST_LINK_LIBS})
+
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples
+     DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/velox/dwio/parquet/tests/ParquetReaderTestBase.h b/velox/dwio/parquet/tests/ParquetReaderTestBase.h
deleted file mode 100644
index c2166c0cacb97..0000000000000
--- a/velox/dwio/parquet/tests/ParquetReaderTestBase.h
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/dwio/common/tests/utils/DataFiles.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
-
-#include <gtest/gtest.h>
-
-namespace facebook::velox::dwio::parquet {
-
-class ParquetReaderTestBase : public testing::Test {
- protected:
-  dwio::common::RowReaderOptions getReaderOpts(
-      const RowTypePtr& rowType,
-      bool fileColumnNamesReadAsLowerCase = false) {
-    dwio::common::RowReaderOptions rowReaderOpts;
-    rowReaderOpts.select(
-        std::make_shared<facebook::velox::dwio::common::ColumnSelector>(
-            rowType,
-            rowType->names(),
-            nullptr,
-            fileColumnNamesReadAsLowerCase));
-
-    return rowReaderOpts;
-  }
-
-  static RowTypePtr sampleSchema() {
-    return ROW({"a", "b"}, {BIGINT(), DOUBLE()});
-  }
-
-  static RowTypePtr dateSchema() {
-    return ROW({"date"}, {DATE()});
-  }
-
-  static RowTypePtr intSchema() {
-    return ROW({"int", "bigint"}, {INTEGER(), BIGINT()});
-  }
-
-  static RowTypePtr upperSchemaToLowerCase() {
-    return ROW({"a", "b"}, {BIGINT(), BIGINT()});
-  }
-
-  template <typename T>
-  VectorPtr rangeVector(size_t size, T start) {
-    std::vector<T> vals(size);
-    for (size_t i = 0; i < size; ++i) {
-      vals[i] = start + static_cast<T>(i);
-    }
-    return vectorMaker_->flatVector(vals);
-  }
-
-  // Check that actual vector is equal to a part of expected vector
-  // at a specified offset.
-  void assertEqualVectorPart(
-      const VectorPtr& expected,
-      const VectorPtr& actual,
-      vector_size_t offset) {
-    ASSERT_GE(expected->size(), actual->size() + offset);
-    ASSERT_EQ(expected->typeKind(), actual->typeKind());
-    for (vector_size_t i = 0; i < actual->size(); i++) {
-      ASSERT_TRUE(expected->equalValueAt(actual.get(), i + offset, i))
-          << "at " << (i + offset) << ": expected "
-          << expected->toString(i + offset) << ", but got "
-          << actual->toString(i);
-    }
-  }
-
-  void assertReadExpected(
-      std::shared_ptr<const RowType> outputType,
-      dwio::common::RowReader& reader,
-      RowVectorPtr expected,
-      memory::MemoryPool& memoryPool) {
-    uint64_t total = 0;
-    VectorPtr result = BaseVector::create(outputType, 0, &memoryPool);
-
-    while (total < expected->size()) {
-      auto part = reader.next(1000, result);
-      if (part > 0) {
-        assertEqualVectorPart(expected, result, total);
-        total += result->size();
-      } else {
-        break;
-      }
-    }
-    EXPECT_EQ(total, expected->size());
-    EXPECT_EQ(reader.next(1000, result), 0);
-  }
-
-  std::shared_ptr<velox::common::ScanSpec> makeScanSpec(
-      const RowTypePtr& rowType) {
-    auto scanSpec = std::make_shared<velox::common::ScanSpec>("");
-    scanSpec->addAllChildFields(*rowType);
-    return scanSpec;
-  }
-
-  using FilterMap =
-      std::unordered_map<std::string, std::unique_ptr<velox::common::Filter>>;
-
-  void assertReadWithReaderAndFilters(
-      const std::unique_ptr<dwio::common::Reader> reader,
-      const std::string& /* fileName */,
-      const RowTypePtr& fileSchema,
-      FilterMap filters,
-      const RowVectorPtr& expected) {
-    auto scanSpec = makeScanSpec(fileSchema);
-    for (auto&& [column, filter] : filters) {
-      scanSpec->getOrCreateChild(velox::common::Subfield(column))
-          ->setFilter(std::move(filter));
-    }
-
-    auto rowReaderOpts = getReaderOpts(fileSchema);
-    rowReaderOpts.setScanSpec(scanSpec);
-    auto rowReader = reader->createRowReader(rowReaderOpts);
-    assertReadExpected(fileSchema, *rowReader, expected, *pool_);
-  }
-
-  std::string getExampleFilePath(const std::string& fileName) {
-    return test::getDataFilePath(
-        "velox/dwio/parquet/tests/reader", "../examples/" + fileName);
-  }
-
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  std::unique_ptr<test::VectorMaker> vectorMaker_{
-      std::make_unique<test::VectorMaker>(pool_.get())};
-};
-} // namespace facebook::velox::dwio::parquet
diff --git a/velox/dwio/parquet/tests/ParquetTestBase.h b/velox/dwio/parquet/tests/ParquetTestBase.h
new file mode 100644
index 0000000000000..0195447dfbda2
--- /dev/null
+++ b/velox/dwio/parquet/tests/ParquetTestBase.h
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <gtest/gtest.h>
+#include <string>
+#include "velox/common/base/Fs.h"
+#include "velox/dwio/common/FileSink.h"
+#include "velox/dwio/common/Reader.h"
+#include "velox/dwio/common/tests/utils/DataFiles.h"
+#include "velox/dwio/parquet/reader/PageReader.h"
+#include "velox/dwio/parquet/reader/ParquetReader.h"
+#include "velox/dwio/parquet/writer/Writer.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::parquet {
+
+class ParquetTestBase : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    dwio::common::LocalFileSink::registerFactory();
+    rootPool_ = memory::memoryManager()->addRootPool("ParquetTests");
+    leafPool_ = rootPool_->addLeafChild("ParquetTests");
+    tempPath_ = exec::test::TempDirectoryPath::create();
+  }
+
+  static RowTypePtr sampleSchema() {
+    return ROW({"a", "b"}, {BIGINT(), DOUBLE()});
+  }
+
+  static RowTypePtr dateSchema() {
+    return ROW({"date"}, {DATE()});
+  }
+
+  static RowTypePtr intSchema() {
+    return ROW({"int", "bigint"}, {INTEGER(), BIGINT()});
+  }
+
+  static RowTypePtr upperSchemaToLowerCase() {
+    return ROW({"a", "b"}, {BIGINT(), BIGINT()});
+  }
+
+  std::unique_ptr<facebook::velox::parquet::ParquetReader> createReader(
+      const std::string& path,
+      const dwio::common::ReaderOptions& opts) {
+    auto input = std::make_unique<dwio::common::BufferedInput>(
+        std::make_shared<LocalReadFile>(path), opts.memoryPool());
+    return std::make_unique<facebook::velox::parquet::ParquetReader>(
+        std::move(input), opts);
+  }
+
+  dwio::common::RowReaderOptions getReaderOpts(
+      const RowTypePtr& rowType,
+      bool fileColumnNamesReadAsLowerCase = false) {
+    dwio::common::RowReaderOptions rowReaderOpts;
+    rowReaderOpts.select(
+        std::make_shared<facebook::velox::dwio::common::ColumnSelector>(
+            rowType,
+            rowType->names(),
+            nullptr,
+            fileColumnNamesReadAsLowerCase));
+
+    return rowReaderOpts;
+  }
+
+  std::shared_ptr<velox::common::ScanSpec> makeScanSpec(
+      const RowTypePtr& rowType) {
+    auto scanSpec = std::make_shared<velox::common::ScanSpec>("");
+    scanSpec->addAllChildFields(*rowType);
+    return scanSpec;
+  }
+
+  using FilterMap =
+      std::unordered_map<std::string, std::unique_ptr<velox::common::Filter>>;
+
+  void assertEqualVectorPart(
+      const VectorPtr& expected,
+      const VectorPtr& actual,
+      vector_size_t offset) {
+    ASSERT_GE(expected->size(), actual->size() + offset);
+    ASSERT_EQ(expected->typeKind(), actual->typeKind());
+    for (vector_size_t i = 0; i < actual->size(); i++) {
+      ASSERT_TRUE(expected->equalValueAt(actual.get(), i + offset, i))
+          << "at " << (i + offset) << ": expected "
+          << expected->toString(i + offset) << ", but got "
+          << actual->toString(i);
+    }
+  }
+
+  void assertReadWithReaderAndExpected(
+      std::shared_ptr<const RowType> outputType,
+      dwio::common::RowReader& reader,
+      RowVectorPtr expected,
+      memory::MemoryPool& memoryPool) {
+    uint64_t total = 0;
+    VectorPtr result = BaseVector::create(outputType, 0, &memoryPool);
+    while (total < expected->size()) {
+      auto part = reader.next(1000, result);
+      if (part > 0) {
+        assertEqualVectorPart(expected, result, total);
+        total += result->size();
+      } else {
+        break;
+      }
+    }
+    EXPECT_EQ(total, expected->size());
+    EXPECT_EQ(reader.next(1000, result), 0);
+  }
+
+  void assertReadWithReaderAndFilters(
+      const std::unique_ptr<dwio::common::Reader> reader,
+      const std::string& /* fileName */,
+      const RowTypePtr& fileSchema,
+      FilterMap filters,
+      const RowVectorPtr& expected) {
+    auto scanSpec = makeScanSpec(fileSchema);
+    for (auto&& [column, filter] : filters) {
+      scanSpec->getOrCreateChild(velox::common::Subfield(column))
+          ->setFilter(std::move(filter));
+    }
+
+    auto rowReaderOpts = getReaderOpts(fileSchema);
+    rowReaderOpts.setScanSpec(scanSpec);
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    assertReadWithReaderAndExpected(
+        fileSchema, *rowReader, expected, *leafPool_);
+  }
+
+  std::unique_ptr<dwio::common::FileSink> createSink(
+      const std::string& filePath) {
+    auto sink = dwio::common::FileSink::create(
+        fmt::format("file:{}", filePath), {.pool = rootPool_.get()});
+    EXPECT_TRUE(sink->isBuffered());
+    EXPECT_TRUE(fs::exists(filePath));
+    EXPECT_FALSE(sink->isClosed());
+    return sink;
+  }
+
+  std::unique_ptr<facebook::velox::parquet::Writer> createWriter(
+      std::unique_ptr<dwio::common::FileSink> sink,
+      std::function<
+          std::unique_ptr<facebook::velox::parquet::DefaultFlushPolicy>()>
+          flushPolicy,
+      const RowTypePtr& rowType,
+      facebook::velox::common::CompressionKind compressionKind =
+          facebook::velox::common::CompressionKind_NONE) {
+    facebook::velox::parquet::WriterOptions options;
+    options.memoryPool = rootPool_.get();
+    options.flushPolicyFactory = flushPolicy;
+    options.compressionKind = compressionKind;
+    return std::make_unique<facebook::velox::parquet::Writer>(
+        std::move(sink), options, rowType);
+  }
+
+  std::vector<RowVectorPtr> createBatches(
+      const RowTypePtr& rowType,
+      uint64_t numBatches,
+      uint64_t vectorSize) {
+    std::vector<RowVectorPtr> batches;
+    batches.reserve(numBatches);
+    VectorFuzzer fuzzer({.vectorSize = vectorSize}, leafPool_.get());
+    for (auto i = 0; i < numBatches; ++i) {
+      batches.emplace_back(fuzzer.fuzzInputFlatRow(rowType));
+    }
+    return batches;
+  }
+
+  std::string getExampleFilePath(const std::string& fileName) {
+    return test::getDataFilePath(
+        "velox/dwio/parquet/tests/reader", "../examples/" + fileName);
+  }
+
+  static constexpr uint64_t kRowsInRowGroup = 10'000;
+  static constexpr uint64_t kBytesInRowGroup = 128 * 1'024 * 1'024;
+  std::shared_ptr<memory::MemoryPool> rootPool_;
+  std::shared_ptr<memory::MemoryPool> leafPool_;
+  std::shared_ptr<exec::test::TempDirectoryPath> tempPath_;
+};
+} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/tests/ParquetTpchTest.cpp b/velox/dwio/parquet/tests/ParquetTpchTest.cpp
index eb08597189ce8..cac577ecd654b 100644
--- a/velox/dwio/parquet/tests/ParquetTpchTest.cpp
+++ b/velox/dwio/parquet/tests/ParquetTpchTest.cpp
@@ -17,7 +17,6 @@
 #include <folly/init/Init.h>
 #include <vector>
 
-#include "velox/common/base/Fs.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/dwio/parquet/RegisterParquetReader.h"
@@ -37,9 +36,13 @@ using namespace facebook::velox::exec::test;
 
 class ParquetTpchTest : public testing::Test {
  protected:
-  void SetUp() override {
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance({});
+
     duckDb_ = std::make_shared<DuckDbQueryRunner>();
     tempDirectory_ = TempDirectoryPath::create();
+    tpchBuilder_ =
+        std::make_shared<TpchQueryBuilder>(dwio::common::FileFormat::PARQUET);
 
     functions::prestosql::registerAllScalarFunctions();
     aggregate::prestosql::registerAllAggregateFunctions();
@@ -53,39 +56,45 @@ class ParquetTpchTest : public testing::Test {
     auto hiveConnector =
         connector::getConnectorFactory(
             connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(kHiveConnectorId, nullptr);
+            ->newConnector(
+                kHiveConnectorId,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
     connector::registerConnector(hiveConnector);
 
     auto tpchConnector =
         connector::getConnectorFactory(
             connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(kTpchConnectorId, nullptr);
+            ->newConnector(
+                kTpchConnectorId,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
     connector::registerConnector(tpchConnector);
 
     saveTpchTablesAsParquet();
-    tpchBuilder_.initialize(tempDirectory_->path);
+    tpchBuilder_->initialize(tempDirectory_->getPath());
   }
 
-  void TearDown() override {
+  static void TearDownTestSuite() {
     connector::unregisterConnector(kHiveConnectorId);
     connector::unregisterConnector(kTpchConnectorId);
     parquet::unregisterParquetReaderFactory();
     parquet::unregisterParquetWriterFactory();
   }
 
-  void saveTpchTablesAsParquet() {
+  static void saveTpchTablesAsParquet() {
     std::shared_ptr<memory::MemoryPool> rootPool{
-        memory::defaultMemoryManager().addRootPool()};
+        memory::memoryManager()->addRootPool()};
     std::shared_ptr<memory::MemoryPool> pool{rootPool->addLeafChild("leaf")};
 
     for (const auto& table : tpch::tables) {
       auto tableName = toTableName(table);
       auto tableDirectory =
-          fmt::format("{}/{}", tempDirectory_->path, tableName);
+          fmt::format("{}/{}", tempDirectory_->getPath(), tableName);
       auto tableSchema = tpch::getTableSchema(table);
       auto columnNames = tableSchema->names();
       auto plan = PlanBuilder()
-                      .tableScan(table, std::move(columnNames), 0.01)
+                      .tpchTableScan(table, std::move(columnNames), 0.01)
                       .planNode();
       auto split =
           exec::Split(std::make_shared<connector::tpch::TpchConnectorSplit>(
@@ -107,7 +116,7 @@ class ParquetTpchTest : public testing::Test {
   void assertQuery(
       int queryId,
       const std::optional<std::vector<uint32_t>>& sortingKeys = {}) {
-    auto tpchPlan = tpchBuilder_.getQueryPlan(queryId);
+    auto tpchPlan = tpchBuilder_->getQueryPlan(queryId);
     auto duckDbSql = tpch::getQuery(queryId);
     assertQuery(tpchPlan, duckDbSql, sortingKeys);
   }
@@ -141,22 +150,36 @@ class ParquetTpchTest : public testing::Test {
         params, addSplits, duckQuery, *duckDb_, sortingKeys);
   }
 
-  std::shared_ptr<DuckDbQueryRunner> duckDb_;
-  std::shared_ptr<TempDirectoryPath> tempDirectory_;
-  TpchQueryBuilder tpchBuilder_{dwio::common::FileFormat::PARQUET};
+  static std::shared_ptr<DuckDbQueryRunner> duckDb_;
+  static std::shared_ptr<TempDirectoryPath> tempDirectory_;
+  static std::shared_ptr<TpchQueryBuilder> tpchBuilder_;
 
   static constexpr char const* kTpchConnectorId{"test-tpch"};
 };
 
+std::shared_ptr<DuckDbQueryRunner> ParquetTpchTest::duckDb_ = nullptr;
+std::shared_ptr<TempDirectoryPath> ParquetTpchTest::tempDirectory_ = nullptr;
+std::shared_ptr<TpchQueryBuilder> ParquetTpchTest::tpchBuilder_ = nullptr;
+
 TEST_F(ParquetTpchTest, Q1) {
   assertQuery(1);
 }
 
+TEST_F(ParquetTpchTest, Q2) {
+  std::vector<uint32_t> sortingKeys{0, 1, 2, 3};
+  assertQuery(2, std::move(sortingKeys));
+}
+
 TEST_F(ParquetTpchTest, Q3) {
   std::vector<uint32_t> sortingKeys{1, 2};
   assertQuery(3, std::move(sortingKeys));
 }
 
+TEST_F(ParquetTpchTest, Q4) {
+  std::vector<uint32_t> sortingKeys{0};
+  assertQuery(4, std::move(sortingKeys));
+}
+
 TEST_F(ParquetTpchTest, Q5) {
   std::vector<uint32_t> sortingKeys{1};
   assertQuery(5, std::move(sortingKeys));
@@ -186,6 +209,11 @@ TEST_F(ParquetTpchTest, Q10) {
   assertQuery(10, std::move(sortingKeys));
 }
 
+TEST_F(ParquetTpchTest, Q11) {
+  std::vector<uint32_t> sortingKeys{1};
+  assertQuery(11, std::move(sortingKeys));
+}
+
 TEST_F(ParquetTpchTest, Q12) {
   std::vector<uint32_t> sortingKeys{0};
   assertQuery(12, std::move(sortingKeys));
@@ -239,6 +267,6 @@ TEST_F(ParquetTpchTest, Q22) {
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/dwio/parquet/tests/examples/array_of_array1.parquet b/velox/dwio/parquet/tests/examples/array_of_array1.parquet
new file mode 100644
index 0000000000000..4c6e9d274167f
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/array_of_array1.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_array_value.parquet b/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_array_value.parquet
new file mode 100644
index 0000000000000..f76b2a89da618
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_array_value.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_struct_value.parquet b/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_struct_value.parquet
new file mode 100644
index 0000000000000..3eb637958290f
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_struct_value.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/different_encodings_with_filter.parquet b/velox/dwio/parquet/tests/examples/different_encodings_with_filter.parquet
new file mode 100644
index 0000000000000..15097cc3061c6
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/different_encodings_with_filter.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/empty_row_groups.parquet b/velox/dwio/parquet/tests/examples/empty_row_groups.parquet
new file mode 100644
index 0000000000000..7efd8a81a88c7
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/empty_row_groups.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/empty_v2datapage.parquet b/velox/dwio/parquet/tests/examples/empty_v2datapage.parquet
new file mode 100644
index 0000000000000..a3d27bfa1c6f9
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/empty_v2datapage.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/enum_type.parquet b/velox/dwio/parquet/tests/examples/enum_type.parquet
new file mode 100644
index 0000000000000..90b53745ce921
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/enum_type.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/icebergNullIcebergPartition.parquet b/velox/dwio/parquet/tests/examples/icebergNullIcebergPartition.parquet
new file mode 100644
index 0000000000000..0f6e562f56a3d
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/icebergNullIcebergPartition.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/listmultiplechildren.parquet b/velox/dwio/parquet/tests/examples/listmultiplechildren.parquet
new file mode 100644
index 0000000000000..a467966a2b616
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/listmultiplechildren.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/lzo.parquet b/velox/dwio/parquet/tests/examples/lzo.parquet
new file mode 100644
index 0000000000000..ffc4bdd52d32a
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/lzo.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/map_key_value.parquet b/velox/dwio/parquet/tests/examples/map_key_value.parquet
new file mode 100644
index 0000000000000..ae0755cf0b25f
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/map_key_value.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/null_map.parquet b/velox/dwio/parquet/tests/examples/null_map.parquet
new file mode 100644
index 0000000000000..64dbe3e87a43c
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/null_map.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/proto-struct-with-array.parquet b/velox/dwio/parquet/tests/examples/proto-struct-with-array.parquet
new file mode 100644
index 0000000000000..325a8370ad20e
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/proto-struct-with-array.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/sample_with_rowindex.parquet b/velox/dwio/parquet/tests/examples/sample_with_rowindex.parquet
new file mode 100644
index 0000000000000..2f7636639f1dd
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/sample_with_rowindex.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/str_sort.parquet b/velox/dwio/parquet/tests/examples/str_sort.parquet
new file mode 100644
index 0000000000000..eb988a820d8a2
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/str_sort.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/struct_of_array.parquet b/velox/dwio/parquet/tests/examples/struct_of_array.parquet
new file mode 100644
index 0000000000000..21dd6dcf88377
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/struct_of_array.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/struct_of_array_of_array.parquet b/velox/dwio/parquet/tests/examples/struct_of_array_of_array.parquet
new file mode 100644
index 0000000000000..2b161e77d773e
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/struct_of_array_of_array.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/timestamp_int96.parquet b/velox/dwio/parquet/tests/examples/timestamp_int96.parquet
new file mode 100644
index 0000000000000..ea3a125aab606
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/timestamp_int96.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/uint.parquet b/velox/dwio/parquet/tests/examples/uint.parquet
new file mode 100644
index 0000000000000..1e1682d05aff5
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/uint.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/unannotated_list.parquet b/velox/dwio/parquet/tests/examples/unannotated_list.parquet
new file mode 100644
index 0000000000000..a7426b77ce7d7
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/unannotated_list.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/unnotated_map.parquet b/velox/dwio/parquet/tests/examples/unnotated_map.parquet
new file mode 100644
index 0000000000000..1d7b72bdcd7dd
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/unnotated_map.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/uuid.parquet b/velox/dwio/parquet/tests/examples/uuid.parquet
new file mode 100644
index 0000000000000..91ca9d2061fd9
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/uuid.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/v2_page.parquet b/velox/dwio/parquet/tests/examples/v2_page.parquet
new file mode 100644
index 0000000000000..4275539bc1cdd
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/v2_page.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/varbinary_flba.parquet b/velox/dwio/parquet/tests/examples/varbinary_flba.parquet
new file mode 100644
index 0000000000000..befd342fc2a0c
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/varbinary_flba.parquet differ
diff --git a/velox/dwio/parquet/tests/reader/BloomFilterTest.cpp b/velox/dwio/parquet/tests/reader/BloomFilterTest.cpp
new file mode 100644
index 0000000000000..91ba224d0c81f
--- /dev/null
+++ b/velox/dwio/parquet/tests/reader/BloomFilterTest.cpp
@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <random>
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "velox/dwio/common/OutputStream.h"
+#include "velox/dwio/parquet/common/BloomFilter.h"
+#include "velox/dwio/parquet/common/XxHasher.h"
+#include "velox/dwio/parquet/reader/ParquetData.h"
+#include "velox/dwio/parquet/reader/ParquetReader.h"
+#include "velox/dwio/parquet/tests/ParquetTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::parquet;
+
+class BloomFilterTest : public ParquetTestBase {};
+
+TEST_F(BloomFilterTest, ConstructorTest) {
+  BlockSplitBloomFilter bloomFilter(leafPool_.get());
+  EXPECT_NO_THROW(bloomFilter.init(1000));
+
+  // It throws because the length cannot be zero
+  std::unique_ptr<uint8_t[]> bitset1(new uint8_t[1024]());
+  EXPECT_THROW(bloomFilter.init(bitset1.get(), 0), VeloxRuntimeError);
+
+  // It throws because the number of bytes of Bloom filter bitset must be a
+  // power of 2.
+  std::unique_ptr<uint8_t[]> bitset2(new uint8_t[1024]());
+  EXPECT_THROW(bloomFilter.init(bitset2.get(), 1023), VeloxRuntimeError);
+}
+
+// The BasicTest is used to test basic operations including InsertHash, FindHash
+// and serializing and de-serializing.
+TEST_F(BloomFilterTest, BasicTest) {
+  const std::vector<uint32_t> kBloomFilterSizes = {
+      32,
+      64,
+      128,
+      256,
+      512,
+      1024,
+      2048,
+  };
+  const std::vector<int32_t> kIntInserts = {
+      1, 2, 3, 5, 6, 7, 8, 9, 10, 42, -1, 1 << 29, 1 << 30};
+  const std::vector<double> kFloatInserts = {
+      1.5, -1.5, 3.0, 6.0, 0.0, 123.456, 1e6, 1e7, 1e8};
+  const std::vector<int32_t> kNegativeIntLookups = {
+      0, 11, 12, 13, -2, -3, 43, 1 << 27, 1 << 28};
+
+  for (const auto bloomFilterBytes : kBloomFilterSizes) {
+    BlockSplitBloomFilter bloomFilter(leafPool_.get());
+    bloomFilter.init(bloomFilterBytes);
+
+    // Empty bloom filter deterministically returns false
+    for (const auto v : kIntInserts) {
+      EXPECT_FALSE(bloomFilter.findHash(bloomFilter.hash(v)));
+    }
+    for (const auto v : kFloatInserts) {
+      EXPECT_FALSE(bloomFilter.findHash(bloomFilter.hash(v)));
+    }
+
+    // Insert all values
+    for (const auto v : kIntInserts) {
+      bloomFilter.insertHash(bloomFilter.hash(v));
+    }
+    for (const auto v : kFloatInserts) {
+      bloomFilter.insertHash(bloomFilter.hash(v));
+    }
+
+    // They should always lookup successfully
+    for (const auto v : kIntInserts) {
+      EXPECT_TRUE(bloomFilter.findHash(bloomFilter.hash(v)));
+    }
+    for (const auto v : kFloatInserts) {
+      EXPECT_TRUE(bloomFilter.findHash(bloomFilter.hash(v)));
+    }
+
+    // Values not inserted in the filter should only rarely lookup successfully
+    int falsePositives = 0;
+    for (const auto v : kNegativeIntLookups) {
+      falsePositives += bloomFilter.findHash(bloomFilter.hash(v));
+    }
+    // (this is a crude check, see FPPTest below for a more rigorous formula)
+    EXPECT_LE(falsePositives, 2);
+
+    // Serialize Bloom filter to memory output stream
+    uint64_t blockSize = 1024;
+    dwio::common::DataBufferHolder bufferHolder{*leafPool_.get(), blockSize};
+    //    dwio::common::BufferedOutputStream bufferedOutputStream(bufferHolder);
+    dwio::common::AppendOnlyBufferedStream sink(
+        std::make_unique<dwio::common::BufferedOutputStream>(bufferHolder));
+    bloomFilter.writeTo(&sink);
+    sink.flush();
+    std::string buffer;
+
+    for (auto& tmpBuffer : bufferHolder.getBuffers()) {
+      buffer.append(tmpBuffer.data(), tmpBuffer.size());
+    }
+
+    // Deserialize Bloom filter from memory
+    dwio::common::SeekableArrayInputStream* source =
+        new dwio::common::SeekableArrayInputStream(
+            buffer.c_str(), buffer.size(), blockSize);
+
+    BlockSplitBloomFilter deBloom =
+        BlockSplitBloomFilter::deserialize(source, *leafPool_.get());
+
+    // Lookup previously inserted values
+    for (const auto v : kIntInserts) {
+      EXPECT_TRUE(deBloom.findHash(deBloom.hash(v)));
+    }
+    for (const auto v : kFloatInserts) {
+      EXPECT_TRUE(deBloom.findHash(deBloom.hash(v)));
+    }
+    falsePositives = 0;
+    for (const auto v : kNegativeIntLookups) {
+      falsePositives += deBloom.findHash(deBloom.hash(v));
+    }
+    EXPECT_LE(falsePositives, 2);
+  }
+}
+
+// Helper function to generate random string.
+std::string GetRandomString(uint32_t length) {
+  // Character set used to generate random string
+  const std::string charset =
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+  std::default_random_engine gen(42);
+  std::uniform_int_distribution<uint32_t> dist(
+      0, static_cast<int>(charset.size() - 1));
+  std::string ret(length, 'x');
+
+  for (uint32_t i = 0; i < length; i++) {
+    ret[i] = charset[dist(gen)];
+  }
+  return ret;
+}
+
+TEST_F(BloomFilterTest, FPPTest) {
+  // It counts the number of times FindHash returns true.
+  int exist = 0;
+
+  // Total count of elements that will be used
+#ifdef PARQUET_VALGRIND
+  const int totalCount = 5000;
+#else
+  const int totalCount = 100000;
+#endif
+
+  // Bloom filter fpp parameter
+  const double fpp = 0.01;
+
+  std::vector<std::string> members;
+  BlockSplitBloomFilter bloomFilter(leafPool_.get());
+  bloomFilter.init(BlockSplitBloomFilter::optimalNumOfBytes(totalCount, fpp));
+
+  // Insert elements into the Bloom filter
+  for (int i = 0; i < totalCount; i++) {
+    // Insert random string which length is 8
+    std::string tmp = GetRandomString(8);
+    const ByteArray byte_array(
+        8, reinterpret_cast<const uint8_t*>(tmp.c_str()));
+    members.push_back(tmp);
+    bloomFilter.insertHash(bloomFilter.hash(&byte_array));
+  }
+
+  for (int i = 0; i < totalCount; i++) {
+    const ByteArray byte_array1(
+        8, reinterpret_cast<const uint8_t*>(members[i].c_str()));
+    ASSERT_TRUE(bloomFilter.findHash(bloomFilter.hash(&byte_array1)));
+    std::string tmp = GetRandomString(7);
+    const ByteArray byte_array2(
+        7, reinterpret_cast<const uint8_t*>(tmp.c_str()));
+
+    if (bloomFilter.findHash(bloomFilter.hash(&byte_array2))) {
+      exist++;
+    }
+  }
+
+  // The exist should be probably less than 1000 according default FPP 0.01.
+  EXPECT_LT(exist, totalCount * fpp);
+}
+
+// The CompatibilityTest is used to test cross compatibility with parquet-mr, it
+// reads the Bloom filter binary generated by the Bloom filter class in the
+// parquet-mr project and tests whether the values inserted before could be
+// filtered or not.
+
+// TODO: disabled as it requires Arrow parquet data dir.
+// The Bloom filter binary is generated by three steps in from Parquet-mr.
+// Step 1: Construct a Bloom filter with 1024 bytes bitset.
+// Step 2: Insert "hello", "parquet", "bloom", "filter" to Bloom filter.
+// Step 3: Call writeTo API to write to File.
+/*
+TEST(CompatibilityTest, TestBloomFilter) {
+  const std::string test_string[4] = {"hello", "parquet", "bloom", "filter"};
+  const std::string bloom_filter_test_binary =
+      std::string(test::get_data_dir()) + "/bloom_filter.xxhash.bin";
+
+  PARQUET_ASSIGN_OR_THROW(auto handle,
+                          ::arrow::io::ReadableFile::Open(bloom_filter_test_binary));
+  PARQUET_ASSIGN_OR_THROW(int64_t size, handle->GetSize());
+
+  // 16 bytes (thrift header) + 1024 bytes (bitset)
+  EXPECT_EQ(size, 1040);
+
+  std::unique_ptr<uint8_t[]> bitset(new uint8_t[size]());
+  PARQUET_ASSIGN_OR_THROW(auto buffer, handle->Read(size));
+
+  ::arrow::io::BufferReader source(buffer);
+  ReaderProperties reader_properties;
+  BlockSplitBloomFilter bloom_filter1 =
+      BlockSplitBloomFilter::Deserialize(reader_properties, &source);
+
+  for (int i = 0; i < 4; i++) {
+    const ByteArray tmp(static_cast<uint32_t>(test_string[i].length()),
+                        reinterpret_cast<const
+uint8_t*>(test_string[i].c_str()));
+    EXPECT_TRUE(bloom_filter1.findHash(bloom_filter1.hash(&tmp)));
+  }
+
+  // The following is used to check whether the new created Bloom filter in
+parquet-cpp is
+  // byte-for-byte identical to file at bloom_data_path which is created from
+parquet-mr
+  // with same inserted hashes.
+  BlockSplitBloomFilter bloom_filter2;
+  bloom_filter2.Init(bloom_filter1.GetBitsetSize());
+  for (int i = 0; i < 4; i++) {
+    const ByteArray byte_array(static_cast<uint32_t>(test_string[i].length()),
+                               reinterpret_cast<const
+uint8_t*>(test_string[i].c_str()));
+    bloom_filter2.InsertHash(bloom_filter2.hash(&byte_array));
+  }
+
+  // Serialize Bloom filter to memory output stream
+  auto sink = CreateOutputStream();
+  bloom_filter2.WriteTo(sink.get());
+  PARQUET_ASSIGN_OR_THROW(auto buffer1, sink->Finish());
+
+  PARQUET_THROW_NOT_OK(handle->Seek(0));
+  PARQUET_ASSIGN_OR_THROW(size, handle->GetSize());
+  PARQUET_ASSIGN_OR_THROW(auto buffer2, handle->Read(size));
+
+  EXPECT_TRUE((*buffer1).Equals(*buffer2));
+}
+*/
+
+// OptimalValueTest is used to test whether OptimalNumOfBits returns expected
+// numbers according to formula:
+//     num_of_bits = -8.0 * ndv / log(1 - pow(fpp, 1.0 / 8.0))
+// where ndv is the number of distinct values and fpp is the false positive
+// probability. Also it is used to test whether OptimalNumOfBits returns value
+// between [MINIMUM_BLOOM_FILTER_SIZE, MAXIMUM_BLOOM_FILTER_SIZE].
+TEST_F(BloomFilterTest, OptimalValueTest) {
+  auto testOptimalNumEstimation = [](uint32_t ndv,
+                                     double fpp,
+                                     uint32_t num_bits) {
+    EXPECT_EQ(BlockSplitBloomFilter::optimalNumOfBits(ndv, fpp), num_bits);
+    EXPECT_EQ(BlockSplitBloomFilter::optimalNumOfBytes(ndv, fpp), num_bits / 8);
+  };
+
+  testOptimalNumEstimation(256, 0.01, UINT32_C(4096));
+  testOptimalNumEstimation(512, 0.01, UINT32_C(8192));
+  testOptimalNumEstimation(1024, 0.01, UINT32_C(16384));
+  testOptimalNumEstimation(2048, 0.01, UINT32_C(32768));
+
+  testOptimalNumEstimation(200, 0.01, UINT32_C(2048));
+  testOptimalNumEstimation(300, 0.01, UINT32_C(4096));
+  testOptimalNumEstimation(700, 0.01, UINT32_C(8192));
+  testOptimalNumEstimation(1500, 0.01, UINT32_C(16384));
+
+  testOptimalNumEstimation(200, 0.025, UINT32_C(2048));
+  testOptimalNumEstimation(300, 0.025, UINT32_C(4096));
+  testOptimalNumEstimation(700, 0.025, UINT32_C(8192));
+  testOptimalNumEstimation(1500, 0.025, UINT32_C(16384));
+
+  testOptimalNumEstimation(200, 0.05, UINT32_C(2048));
+  testOptimalNumEstimation(300, 0.05, UINT32_C(4096));
+  testOptimalNumEstimation(700, 0.05, UINT32_C(8192));
+  testOptimalNumEstimation(1500, 0.05, UINT32_C(16384));
+
+  // Boundary check
+  testOptimalNumEstimation(
+      4, 0.01, BlockSplitBloomFilter::kMinimumBloomFilterBytes * 8);
+  testOptimalNumEstimation(
+      4, 0.25, BlockSplitBloomFilter::kMinimumBloomFilterBytes * 8);
+
+  testOptimalNumEstimation(
+      std::numeric_limits<uint32_t>::max(),
+      0.01,
+      BlockSplitBloomFilter::kMaximumBloomFilterBytes * 8);
+  testOptimalNumEstimation(
+      std::numeric_limits<uint32_t>::max(),
+      0.25,
+      BlockSplitBloomFilter::kMaximumBloomFilterBytes * 8);
+}
+
+// The test below is plainly copied from parquet-mr and serves as a basic sanity
+// check of our XXH64 wrapper.
+const int64_t HASHES_OF_LOOPING_BYTES_WITH_SEED_0[32] = {
+    -1205034819632174695L, -1642502924627794072L, 5216751715308240086L,
+    -1889335612763511331L, -13835840860730338L,   -2521325055659080948L,
+    4867868962443297827L,  1498682999415010002L,  -8626056615231480947L,
+    7482827008138251355L,  -617731006306969209L,  7289733825183505098L,
+    4776896707697368229L,  1428059224718910376L,  6690813482653982021L,
+    -6248474067697161171L, 4951407828574235127L,  6198050452789369270L,
+    5776283192552877204L,  -626480755095427154L,  -6637184445929957204L,
+    8370873622748562952L,  -1705978583731280501L, -7898818752540221055L,
+    -2516210193198301541L, 8356900479849653862L,  -4413748141896466000L,
+    -6040072975510680789L, 1451490609699316991L,  -7948005844616396060L,
+    8567048088357095527L,  -4375578310507393311L};
+
+/**
+ * Test data is output of the following program with xxHash implementation
+ * from https://github.com/Cyan4973/xxHash with commit
+ * c8c4cc0f812719ce1f5b2c291159658980e7c255
+ *
+ * #define XXH_INLINE_ALL
+ * #include "xxhash.h"
+ * #include <stdlib.h>
+ * #include <stdio.h>
+ * int main()
+ * {
+ *     char* src = (char*) malloc(32);
+ *     const int N = 32;
+ *     for (int i = 0; i < N; i++) {
+ *         src[i] = (char) i;
+ *     }
+ *
+ *     printf("without seed\n");
+ *     for (int i = 0; i <= N; i++) {
+ *        printf("%lldL,\n", (long long) XXH64(src, i, 0));
+ *     }
+ * }
+ */
+TEST_F(BloomFilterTest, XxHashTest) {
+  constexpr int kNumValues = 32;
+  uint8_t bytes[kNumValues] = {};
+
+  for (int i = 0; i < kNumValues; i++) {
+    ByteArray byteArray(i, bytes);
+    bytes[i] = i;
+
+    auto hasherSeed0 = std::make_unique<XxHasher>();
+    EXPECT_EQ(
+        HASHES_OF_LOOPING_BYTES_WITH_SEED_0[i], hasherSeed0->hash(&byteArray))
+        << "Hash with seed 0 Error: " << i;
+  }
+}
+
+// Same as TestBloomFilter but using Batch interface
+TEST_F(BloomFilterTest, TestBloomFilterHashes) {
+  constexpr int kNumValues = 32;
+  uint8_t bytes[kNumValues] = {};
+
+  std::vector<ByteArray> byteArrayVector;
+  for (int i = 0; i < kNumValues; i++) {
+    bytes[i] = i;
+    byteArrayVector.emplace_back(i, bytes);
+  }
+  auto hasherSeed0 = std::make_unique<XxHasher>();
+  std::vector<uint64_t> hashes;
+  hashes.resize(kNumValues);
+  hasherSeed0->hashes(
+      byteArrayVector.data(),
+      static_cast<int>(byteArrayVector.size()),
+      hashes.data());
+  for (int i = 0; i < kNumValues; i++) {
+    EXPECT_EQ(HASHES_OF_LOOPING_BYTES_WITH_SEED_0[i], hashes[i])
+        << "Hash with seed 0 Error: " << i;
+  }
+}
diff --git a/velox/dwio/parquet/tests/reader/CMakeLists.txt b/velox/dwio/parquet/tests/reader/CMakeLists.txt
index ff8aa8a9c27e4..b58429d73e933 100644
--- a/velox/dwio/parquet/tests/reader/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/reader/CMakeLists.txt
@@ -12,15 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_dwio_parquet_reader_test ParquetReaderTest.cpp)
-add_test(
-  NAME velox_dwio_parquet_reader_test
-  COMMAND velox_dwio_parquet_reader_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(
-  velox_dwio_parquet_reader_test velox_dwio_native_parquet_reader
-  velox_link_libs ${TEST_LINK_LIBS})
-
 add_executable(velox_dwio_parquet_page_reader_test ParquetPageReaderTest.cpp)
 add_test(
   NAME velox_dwio_parquet_page_reader_test
@@ -34,7 +25,7 @@ add_executable(velox_parquet_e2e_filter_test E2EFilterTest.cpp)
 add_test(velox_parquet_e2e_filter_test velox_parquet_e2e_filter_test)
 target_link_libraries(
   velox_parquet_e2e_filter_test
-  velox_e2e_filter_test_base
+  velox_dwio_common_test_utils
   velox_dwio_parquet_writer
   velox_dwio_native_parquet_reader
   lz4::lz4
@@ -43,16 +34,33 @@ target_link_libraries(
   ZLIB::ZLIB
   ${TEST_LINK_LIBS})
 
-add_executable(velox_dwio_parquet_reader_benchmark ParquetReaderBenchmark.cpp)
+add_library(velox_dwio_parquet_reader_benchmark_lib ParquetReaderBenchmark.cpp)
 target_link_libraries(
-  velox_dwio_parquet_reader_benchmark
+  velox_dwio_parquet_reader_benchmark_lib
   velox_dwio_parquet_reader
   velox_dwio_parquet_writer
   velox_exec_test_lib
   velox_exec
   velox_hive_connector
-  Folly::folly
-  ${FOLLY_BENCHMARK})
+  ${TEST_LINK_LIBS}
+  ${FOLLY_BENCHMARK}
+  Folly::folly)
+
+add_executable(velox_dwio_parquet_reader_benchmark
+               ParquetReaderBenchmarkMain.cpp)
+target_link_libraries(
+  velox_dwio_parquet_reader_benchmark velox_dwio_parquet_reader_benchmark_lib)
+
+add_executable(
+  velox_dwio_parquet_reader_test
+  ParquetReaderTest.cpp ParquetReaderBenchmarkTest.cpp BloomFilterTest.cpp)
+add_test(
+  NAME velox_dwio_parquet_reader_test
+  COMMAND velox_dwio_parquet_reader_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(
+  velox_dwio_parquet_reader_test velox_dwio_native_parquet_common
+  velox_dwio_parquet_reader_benchmark_lib velox_link_libs)
 
 add_executable(velox_dwio_parquet_structure_decoder_test
                NestedStructureDecoderTest.cpp)
@@ -82,6 +90,7 @@ target_link_libraries(
   velox_exec
   velox_hive_connector
   velox_link_libs
+  velox_type_tz
   ${TEST_LINK_LIBS})
 
 if(${VELOX_ENABLE_ARROW})
@@ -92,7 +101,10 @@ if(${VELOX_ENABLE_ARROW})
     COMMAND velox_dwio_parquet_rlebp_decoder_test
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
   target_link_libraries(
-    velox_dwio_parquet_rlebp_decoder_test velox_dwio_native_parquet_reader
-    arrow velox_link_libs ${TEST_LINK_LIBS})
+    velox_dwio_parquet_rlebp_decoder_test
+    velox_dwio_native_parquet_reader
+    arrow
+    velox_link_libs
+    ${TEST_LINK_LIBS})
 
 endif()
diff --git a/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp b/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
index c633dff6fb6c4..0b27395f9a00d 100644
--- a/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
+++ b/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
@@ -14,9 +14,11 @@
  * limitations under the License.
  */
 
-#include "velox/dwio/common/tests/E2EFilterTestBase.h"
+#include "velox/dwio/common/tests/utils/E2EFilterTestBase.h"
 #include "velox/dwio/parquet/reader/ParquetReader.h"
+#include "velox/dwio/parquet/reader/ParquetTypeWithId.h"
 #include "velox/dwio/parquet/writer/Writer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <folly/init/Init.h>
 
@@ -27,7 +29,7 @@ using namespace facebook::velox::parquet;
 
 using dwio::common::MemorySink;
 
-class E2EFilterTest : public E2EFilterTestBase {
+class E2EFilterTest : public E2EFilterTestBase, public test::VectorTestBase {
  protected:
   void SetUp() override {
     E2EFilterTestBase::SetUp();
@@ -53,13 +55,13 @@ class E2EFilterTest : public E2EFilterTestBase {
   }
 
   void writeToMemory(
-      const TypePtr&,
+      const TypePtr& type,
       const std::vector<RowVectorPtr>& batches,
       bool forRowGroupSkip = false) override {
     auto sink = std::make_unique<MemorySink>(
         200 * 1024 * 1024, FileSink::Options{.pool = leafPool_.get()});
-    sinkPtr_ = sink.get();
-    options_.memoryPool = rootPool_.get();
+    auto* sinkPtr = sink.get();
+    options_.memoryPool = E2EFilterTestBase::rootPool_.get();
     int32_t flushCounter = 0;
     options_.flushPolicyFactory = [&]() {
       return std::make_unique<LambdaFlushPolicy>(
@@ -71,12 +73,13 @@ class E2EFilterTest : public E2EFilterTestBase {
     };
 
     writer_ = std::make_unique<facebook::velox::parquet::Writer>(
-        std::move(sink), options_);
+        std::move(sink), options_, asRowType(type));
     for (auto& batch : batches) {
       writer_->write(batch);
     }
     writer_->flush();
     writer_->close();
+    sinkData_ = std::string_view(sinkPtr->data(), sinkPtr->size());
   }
 
   std::unique_ptr<dwio::common::Reader> makeReader(
@@ -92,13 +95,13 @@ class E2EFilterTest : public E2EFilterTestBase {
 };
 
 TEST_F(E2EFilterTest, writerMagic) {
-  rowType_ = ROW({INTEGER()});
+  rowType_ = ROW({"c0"}, {INTEGER()});
   std::vector<RowVectorPtr> batches;
   batches.push_back(std::static_pointer_cast<RowVector>(
       test::BatchMaker::createBatch(rowType_, 20000, *leafPool_, nullptr, 0)));
   writeToMemory(rowType_, batches, false);
-  auto data = sinkPtr_->data();
-  auto size = sinkPtr_->size();
+  auto data = sinkData_.data();
+  auto size = sinkData_.size();
   EXPECT_EQ("PAR1", std::string(data, 4));
   EXPECT_EQ("PAR1", std::string(data + size - 4, 4));
 }
@@ -128,6 +131,22 @@ TEST_F(E2EFilterTest, integerDirect) {
       20);
 }
 
+TEST_F(E2EFilterTest, integerDeltaBinaryPack) {
+  options_.enableDictionary = false;
+  options_.encoding =
+      facebook::velox::parquet::arrow::Encoding::DELTA_BINARY_PACKED;
+
+  testWithTypes(
+      "short_val:smallint,"
+      "int_val:int,"
+      "long_val:bigint,"
+      "long_null:bigint",
+      [&]() { makeAllNulls("long_null"); },
+      true,
+      {"short_val", "int_val", "long_val"},
+      20);
+}
+
 TEST_F(E2EFilterTest, compression) {
   for (const auto compression :
        {common::CompressionKind_SNAPPY,
@@ -140,7 +159,7 @@ TEST_F(E2EFilterTest, compression) {
     }
 
     options_.dataPageSize = 4 * 1024;
-    options_.compression = compression;
+    options_.compressionKind = compression;
 
     testWithTypes(
         "tinyint_val:tinyint,"
@@ -237,6 +256,19 @@ TEST_F(E2EFilterTest, integerDictionary) {
       20);
 }
 
+TEST_F(E2EFilterTest, timestampDictionary) {
+  options_.dataPageSize = 4 * 1024;
+  options_.writeInt96AsTimestamp = true;
+
+  testWithTypes(
+      "timestamp_val_0:timestamp,"
+      "timestamp_val_1:timestamp",
+      [&]() {},
+      true,
+      {"timestamp_val_0", "timestamp_val_1"},
+      20);
+}
+
 TEST_F(E2EFilterTest, floatAndDoubleDirect) {
   options_.enableDictionary = false;
   options_.dataPageSize = 4 * 1024;
@@ -561,18 +593,17 @@ TEST_F(E2EFilterTest, varbinaryDictionary) {
 TEST_F(E2EFilterTest, largeMetadata) {
   rowsInRowGroup_ = 1;
 
-  rowType_ = ROW({INTEGER()});
+  rowType_ = ROW({"c0"}, {INTEGER()});
   std::vector<RowVectorPtr> batches;
   batches.push_back(std::static_pointer_cast<RowVector>(
       test::BatchMaker::createBatch(rowType_, 1000, *leafPool_, nullptr, 0)));
   writeToMemory(rowType_, batches, false);
   dwio::common::ReaderOptions readerOpts{leafPool_.get()};
-  readerOpts.setDirectorySizeGuess(1024);
+  readerOpts.setFooterEstimatedSize(1024);
   readerOpts.setFilePreloadThreshold(1024 * 8);
   dwio::common::RowReaderOptions rowReaderOpts;
-  std::string_view data(sinkPtr_->data(), sinkPtr_->size());
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), readerOpts.getMemoryPool());
+      std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
   EXPECT_EQ(1000, reader->numberOfRows());
 }
@@ -598,26 +629,93 @@ TEST_F(E2EFilterTest, date) {
 
 TEST_F(E2EFilterTest, combineRowGroup) {
   rowsInRowGroup_ = 5;
-  rowType_ = ROW({INTEGER()});
+  rowType_ = ROW({"c0"}, {INTEGER()});
   std::vector<RowVectorPtr> batches;
   for (int i = 0; i < 5; i++) {
     batches.push_back(std::static_pointer_cast<RowVector>(
         test::BatchMaker::createBatch(rowType_, 1, *leafPool_, nullptr, 0)));
   }
   writeToMemory(rowType_, batches, false);
-  std::string_view data(sinkPtr_->data(), sinkPtr_->size());
   dwio::common::ReaderOptions readerOpts{leafPool_.get()};
   auto input = std::make_unique<BufferedInput>(
-      std::make_shared<InMemoryReadFile>(data), readerOpts.getMemoryPool());
+      std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
   auto reader = makeReader(readerOpts, std::move(input));
   auto parquetReader = dynamic_cast<ParquetReader&>(*reader.get());
-  EXPECT_EQ(parquetReader.numberOfRowGroups(), 1);
+  EXPECT_EQ(parquetReader.fileMetaData().numRowGroups(), 1);
   EXPECT_EQ(parquetReader.numberOfRows(), 5);
 }
 
+TEST_F(E2EFilterTest, writeDecimalAsInteger) {
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int64_t>({1, 2}, DECIMAL(8, 2)),
+       makeFlatVector<int64_t>({1, 2}, DECIMAL(10, 2)),
+       makeFlatVector<int64_t>({1, 2}, DECIMAL(19, 2))});
+  writeToMemory(rowVector->type(), {rowVector}, false);
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  auto input = std::make_unique<BufferedInput>(
+      std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
+  auto reader = makeReader(readerOpts, std::move(input));
+  auto parquetReader = dynamic_cast<ParquetReader&>(*reader.get());
+
+  auto types = parquetReader.typeWithId()->getChildren();
+  auto c0 = std::dynamic_pointer_cast<const ParquetTypeWithId>(types[0]);
+  EXPECT_EQ(c0->parquetType_.value(), thrift::Type::type::INT32);
+  auto c1 = std::dynamic_pointer_cast<const ParquetTypeWithId>(types[1]);
+  EXPECT_EQ(c1->parquetType_.value(), thrift::Type::type::INT64);
+  auto c2 = std::dynamic_pointer_cast<const ParquetTypeWithId>(types[2]);
+  EXPECT_EQ(c2->parquetType_.value(), thrift::Type::type::FIXED_LEN_BYTE_ARRAY);
+}
+
+TEST_F(E2EFilterTest, configurableWriteSchema) {
+  auto test = [&](auto& type, auto& newType) {
+    std::vector<RowVectorPtr> batches;
+    for (auto i = 0; i < 5; i++) {
+      auto vector = BaseVector::create(type, 100, pool());
+      auto rowVector = std::dynamic_pointer_cast<RowVector>(vector);
+      batches.push_back(rowVector);
+    }
+
+    writeToMemory(newType, batches, false);
+    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+    auto input = std::make_unique<BufferedInput>(
+        std::make_shared<InMemoryReadFile>(sinkData_), readerOpts.memoryPool());
+    auto reader = makeReader(readerOpts, std::move(input));
+    auto parquetReader = dynamic_cast<ParquetReader&>(*reader.get());
+
+    EXPECT_EQ(parquetReader.rowType()->toString(), newType->toString());
+  };
+
+  // ROW(ROW(ROW))
+  auto type =
+      ROW({"a", "b"}, {INTEGER(), ROW({"c"}, {ROW({"d"}, {INTEGER()})})});
+  auto newType =
+      ROW({"aa", "bb"}, {INTEGER(), ROW({"cc"}, {ROW({"dd"}, {INTEGER()})})});
+  test(type, newType);
+
+  // ARRAY(ROW)
+  type =
+      ROW({"a", "b"}, {ARRAY(ROW({"c", "d"}, {BIGINT(), BIGINT()})), BIGINT()});
+  newType = ROW(
+      {"aa", "bb"}, {ARRAY(ROW({"cc", "dd"}, {BIGINT(), BIGINT()})), BIGINT()});
+  test(type, newType);
+
+  // // MAP(ROW)
+  type =
+      ROW({"a", "b"},
+          {MAP(ROW({"c", "d"}, {BIGINT(), BIGINT()}),
+               ROW({"e", "f"}, {BIGINT(), BIGINT()})),
+           BIGINT()});
+  newType =
+      ROW({"aa", "bb"},
+          {MAP(ROW({"cc", "dd"}, {BIGINT(), BIGINT()}),
+               ROW({"ee", "ff"}, {BIGINT(), BIGINT()})),
+           BIGINT()});
+  test(type, newType);
+}
+
 // Define main so that gflags get processed.
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/dwio/parquet/tests/reader/NestedStructureDecoderBenchmark.cpp b/velox/dwio/parquet/tests/reader/NestedStructureDecoderBenchmark.cpp
index b1b8f1fd3a9f9..2b79db6231a13 100644
--- a/velox/dwio/parquet/tests/reader/NestedStructureDecoderBenchmark.cpp
+++ b/velox/dwio/parquet/tests/reader/NestedStructureDecoderBenchmark.cpp
@@ -30,7 +30,7 @@ class NestedStructureDecoderBenchmark {
       : numValues_(numValues),
         definitionLevels_(new unsigned char[numValues]()),
         repetitionLevels_(new unsigned char[numValues]()),
-        pool_(memory::addDefaultLeafMemoryPool()) {}
+        pool_(memory::memoryManager()->addLeafPool()) {}
 
   void setUp(uint16_t maxDefinition, uint16_t maxRepetition) {
     dwio::common::ensureCapacity<uint64_t>(
@@ -91,6 +91,7 @@ BENCHMARK(randomDefs) {
 }
 
 int main(int /*argc*/, char** /*argv*/) {
+  memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/dwio/parquet/tests/reader/NestedStructureDecoderTest.cpp b/velox/dwio/parquet/tests/reader/NestedStructureDecoderTest.cpp
index 23fda0f770acc..074557db848ca 100644
--- a/velox/dwio/parquet/tests/reader/NestedStructureDecoderTest.cpp
+++ b/velox/dwio/parquet/tests/reader/NestedStructureDecoderTest.cpp
@@ -28,9 +28,12 @@ class NestedStructureDecoderTest : public testing::Test {
  protected:
   static constexpr int32_t kMaxNumValues = 10'000;
 
- protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = memory::addDefaultLeafMemoryPool();
+    pool_ = memory::memoryManager()->addLeafPool();
 
     dwio::common::ensureCapacity<bool>(
         nullsBuffer_, kMaxNumValues, pool_.get());
diff --git a/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp b/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
index f96a349df029f..5145dcfdc8ca9 100644
--- a/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
@@ -15,20 +15,14 @@
  */
 
 #include "velox/dwio/parquet/reader/PageReader.h"
-#include "velox/dwio/parquet/reader/ParquetReader.h"
-#include "velox/dwio/parquet/tests/ParquetReaderTestBase.h"
+#include "velox/dwio/parquet/tests/ParquetTestBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::common;
 using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::dwio::parquet;
 using namespace facebook::velox::parquet;
 
-class ParquetPageReaderTest : public ParquetReaderTestBase {};
-
-namespace {
-auto defaultPool = memory::addDefaultLeafMemoryPool();
-}
+class ParquetPageReaderTest : public ParquetTestBase {};
 
 TEST_F(ParquetPageReaderTest, smallPage) {
   auto readFile =
@@ -36,11 +30,11 @@ TEST_F(ParquetPageReaderTest, smallPage) {
   auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
   auto headerSize = file->getLength();
   auto inputStream = std::make_unique<SeekableFileInputStream>(
-      std::move(file), 0, headerSize, *defaultPool, LogType::TEST);
+      std::move(file), 0, headerSize, *leafPool_, LogType::TEST);
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
-      *defaultPool,
-      thrift::CompressionCodec::type::GZIP,
+      *leafPool_,
+      common::CompressionKind::CompressionKind_GZIP,
       headerSize);
   auto header = pageReader->readPageHeader();
   EXPECT_EQ(header.type, thrift::PageType::type::DATA_PAGE);
@@ -64,11 +58,11 @@ TEST_F(ParquetPageReaderTest, largePage) {
   auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
   auto headerSize = file->getLength();
   auto inputStream = std::make_unique<SeekableFileInputStream>(
-      std::move(file), 0, headerSize, *defaultPool, LogType::TEST);
+      std::move(file), 0, headerSize, *leafPool_, LogType::TEST);
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
-      *defaultPool,
-      thrift::CompressionCodec::type::GZIP,
+      *leafPool_,
+      common::CompressionKind::CompressionKind_GZIP,
       headerSize);
   auto header = pageReader->readPageHeader();
 
@@ -93,22 +87,23 @@ TEST_F(ParquetPageReaderTest, corruptedPageHeader) {
   auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
   auto headerSize = file->getLength();
   auto inputStream = std::make_unique<SeekableFileInputStream>(
-      std::move(file), 0, headerSize, *defaultPool, LogType::TEST);
+      std::move(file), 0, headerSize, *leafPool_, LogType::TEST);
 
   // In the corrupted_page_header, the min_value length is set incorrectly on
   // purpose. This is to simulate the situation where the Parquet Page Header is
   // corrupted. And an error is expected to be thrown.
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
-      *defaultPool,
-      thrift::CompressionCodec::type::GZIP,
+      *leafPool_,
+      common::CompressionKind::CompressionKind_GZIP,
       headerSize);
 
   EXPECT_THROW(pageReader->readPageHeader(), VeloxException);
 }
 
 TEST(CompressionOptionsTest, testCompressionOptions) {
-  auto options = PageReader::getParquetDecompressionOptions();
+  auto options = getParquetDecompressionOptions(
+      facebook::velox::common::CompressionKind_ZLIB);
   EXPECT_EQ(
       options.format.zlib.windowBits,
       dwio::common::compression::Compressor::PARQUET_ZLIB_WINDOW_BITS);
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.cpp
index af67747e4cb31..976d021d87edc 100644
--- a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.cpp
@@ -14,17 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/dwio/common/FileSink.h"
-#include "velox/dwio/common/Options.h"
-#include "velox/dwio/common/Statistics.h"
-#include "velox/dwio/common/tests/utils/DataSetBuilder.h"
-#include "velox/dwio/parquet/RegisterParquetReader.h"
-#include "velox/dwio/parquet/reader/ParquetReader.h"
-#include "velox/dwio/parquet/writer/Writer.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-
-#include <folly/Benchmark.h>
-#include <folly/init/Init.h>
+#include "velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::dwio;
@@ -32,214 +22,196 @@ using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::parquet;
 using namespace facebook::velox::test;
 
-const uint32_t kNumRowsPerBatch = 60000;
-const uint32_t kNumBatches = 50;
-const uint32_t kNumRowsPerRowGroup = 10000;
-const double kFilterErrorMargin = 0.2;
-
-class ParquetReaderBenchmark {
- public:
-  explicit ParquetReaderBenchmark(bool disableDictionary)
-      : disableDictionary_(disableDictionary) {
-    rootPool_ =
-        memory::defaultMemoryManager().addRootPool("ParquetReaderBenchmark");
-    leafPool_ = rootPool_->addLeafChild("ParquetReaderBenchmark");
-    dataSetBuilder_ = std::make_unique<DataSetBuilder>(*leafPool_, 0);
-    auto path = fileFolder_->path + "/" + fileName_;
-    auto localWriteFile = std::make_unique<LocalWriteFile>(path, true, false);
-    auto sink =
-        std::make_unique<WriteFileSink>(std::move(localWriteFile), path);
-    facebook::velox::parquet::WriterOptions options;
-    if (disableDictionary_) {
-      // The parquet file is in plain encoding format.
-      options.enableDictionary = false;
-    }
-    options.memoryPool = rootPool_.get();
-    writer_ = std::make_unique<facebook::velox::parquet::Writer>(
-        std::move(sink), options);
-  }
-
-  ~ParquetReaderBenchmark() {}
-
-  void writeToFile(
-      const std::vector<RowVectorPtr>& batches,
-      bool /*forRowGroupSkip*/) {
-    for (auto& batch : batches) {
-      writer_->write(batch);
-    }
-    writer_->flush();
-    writer_->close();
+namespace facebook::velox::parquet::test {
+void ParquetReaderBenchmark::writeToFile(
+    const std::vector<RowVectorPtr>& batches,
+    bool /*forRowGroupSkip*/) {
+  for (auto& batch : batches) {
+    writer_->write(batch);
   }
+  writer_->flush();
+  writer_->close();
+}
 
-  FilterSpec createFilterSpec(
-      const std::string& columnName,
-      float startPct,
-      float selectPct,
-      const TypePtr& type,
-      bool isForRowGroupSkip,
-      bool allowNulls) {
-    switch (type->childAt(0)->kind()) {
-      case TypeKind::BIGINT:
-      case TypeKind::INTEGER:
-        return FilterSpec(
-            columnName,
-            startPct,
-            selectPct,
-            FilterKind::kBigintRange,
-            isForRowGroupSkip,
-            allowNulls);
-      case TypeKind::DOUBLE:
-        return FilterSpec(
-            columnName,
-            startPct,
-            selectPct,
-            FilterKind::kDoubleRange,
-            isForRowGroupSkip,
-            allowNulls);
-      default:
-        VELOX_FAIL("Unsupported Data Type {}", type->childAt(0)->toString());
-    }
-    return FilterSpec(columnName, startPct, selectPct, FilterKind(), false);
-  }
-
-  std::shared_ptr<ScanSpec> createScanSpec(
-      const std::vector<RowVectorPtr>& batches,
-      RowTypePtr& rowType,
-      const std::vector<FilterSpec>& filterSpecs,
-      std::vector<uint64_t>& hitRows) {
-    std::unique_ptr<FilterGenerator> filterGenerator =
-        std::make_unique<FilterGenerator>(rowType, 0);
-    auto filters = filterGenerator->makeSubfieldFilters(
-        filterSpecs, batches, nullptr, hitRows);
-    auto scanSpec = filterGenerator->makeScanSpec(std::move(filters));
-    return scanSpec;
-  }
-
-  std::unique_ptr<RowReader> createReader(
-      std::shared_ptr<ScanSpec> scanSpec,
-      const RowTypePtr& rowType) {
-    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
-    auto input = std::make_unique<BufferedInput>(
-        std::make_shared<LocalReadFile>(fileFolder_->path + "/" + fileName_),
-        readerOpts.getMemoryPool());
-
-    std::unique_ptr<Reader> reader =
-        std::make_unique<ParquetReader>(std::move(input), readerOpts);
-
-    dwio::common::RowReaderOptions rowReaderOpts;
-    rowReaderOpts.select(
-        std::make_shared<facebook::velox::dwio::common::ColumnSelector>(
-            rowType, rowType->names()));
-    rowReaderOpts.setScanSpec(scanSpec);
-    auto rowReader = reader->createRowReader(rowReaderOpts);
-
-    return rowReader;
+FilterSpec ParquetReaderBenchmark::createFilterSpec(
+    const std::string& columnName,
+    float startPct,
+    float selectPct,
+    const TypePtr& type,
+    bool isForRowGroupSkip,
+    bool allowNulls) {
+  switch (type->childAt(0)->kind()) {
+    case TypeKind::BIGINT:
+    case TypeKind::INTEGER:
+      return FilterSpec(
+          columnName,
+          startPct,
+          selectPct,
+          FilterKind::kBigintRange,
+          isForRowGroupSkip,
+          allowNulls);
+    case TypeKind::DOUBLE:
+      return FilterSpec(
+          columnName,
+          startPct,
+          selectPct,
+          FilterKind::kDoubleRange,
+          isForRowGroupSkip,
+          allowNulls);
+    case TypeKind::HUGEINT:
+      return FilterSpec(
+          columnName,
+          startPct,
+          selectPct,
+          FilterKind::kHugeintRange,
+          isForRowGroupSkip,
+          allowNulls);
+    case TypeKind::VARCHAR:
+      return FilterSpec(
+          columnName,
+          startPct,
+          selectPct,
+          FilterKind::kBytesRange,
+          isForRowGroupSkip,
+          allowNulls);
+    default:
+      VELOX_FAIL("Unsupported Data Type {}", type->childAt(0)->toString());
   }
+  return FilterSpec(columnName, startPct, selectPct, FilterKind(), false);
+}
 
-  int read(
-      const RowTypePtr& rowType,
-      std::shared_ptr<ScanSpec> scanSpec,
-      uint32_t nextSize) {
-    auto rowReader = createReader(scanSpec, rowType);
-    runtimeStats_ = dwio::common::RuntimeStatistics();
-
-    rowReader->resetFilterCaches();
-    auto result = BaseVector::create(rowType, 1, leafPool_.get());
-    int resultSize = 0;
-    while (true) {
-      bool hasData = rowReader->next(nextSize, result);
-
-      if (!hasData) {
-        break;
-      }
-      if (result->size() == 0) {
-        continue;
-      }
-
-      auto rowVector = result->asUnchecked<RowVector>();
-      for (auto i = 0; i < rowVector->childrenSize(); ++i) {
-        rowVector->childAt(i)->loadedVector();
-      }
+std::shared_ptr<ScanSpec> ParquetReaderBenchmark::createScanSpec(
+    const std::vector<RowVectorPtr>& batches,
+    RowTypePtr& rowType,
+    const std::vector<FilterSpec>& filterSpecs,
+    std::vector<uint64_t>& hitRows) {
+  std::unique_ptr<FilterGenerator> filterGenerator =
+      std::make_unique<FilterGenerator>(rowType, 0);
+  auto filters = filterGenerator->makeSubfieldFilters(
+      filterSpecs, batches, nullptr, hitRows);
+  auto scanSpec = filterGenerator->makeScanSpec(std::move(filters));
+  return scanSpec;
+}
 
-      VELOX_CHECK_EQ(
-          rowVector->childrenSize(),
-          1,
-          "The benchmark is performed on single columns. So the result should only contain one column.")
+std::unique_ptr<RowReader> ParquetReaderBenchmark::createReader(
+    std::shared_ptr<ScanSpec> scanSpec,
+    const RowTypePtr& rowType) {
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  auto input = std::make_unique<BufferedInput>(
+      std::make_shared<LocalReadFile>(fileFolder_->getPath() + "/" + fileName_),
+      readerOpts.memoryPool());
+
+  std::unique_ptr<Reader> reader =
+      std::make_unique<ParquetReader>(std::move(input), readerOpts);
+
+  dwio::common::RowReaderOptions rowReaderOpts;
+  rowReaderOpts.select(
+      std::make_shared<facebook::velox::dwio::common::ColumnSelector>(
+          rowType, rowType->names()));
+  rowReaderOpts.setScanSpec(scanSpec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  return rowReader;
+}
 
-      for (int i = 0; i < rowVector->size(); i++) {
-        resultSize += !rowVector->childAt(0)->isNullAt(i);
-      }
+// This method is the place where we do the read opeartions.
+// scanSpec contains the setting of filters. e.g.
+// filterRateX100 = 30 means it would filter out 70% of rows and 30% remain.
+// nullsRateX100 = 70 means it would filter out 70% of rows and 30% remain.
+// Return the number of rows after the filter and null-filter.
+int ParquetReaderBenchmark::read(
+    const RowTypePtr& rowType,
+    std::shared_ptr<ScanSpec> scanSpec,
+    uint32_t nextSize) {
+  auto rowReader = createReader(scanSpec, rowType);
+  runtimeStats_ = dwio::common::RuntimeStatistics();
+
+  rowReader->resetFilterCaches();
+  auto result = BaseVector::create(rowType, 1, leafPool_.get());
+  int resultSize = 0;
+  while (true) {
+    bool hasData = rowReader->next(nextSize, result);
+
+    if (!hasData) {
+      break;
     }
-
-    rowReader->updateRuntimeStats(runtimeStats_);
-    return resultSize;
-  }
-
-  void readSingleColumn(
-      const std::string& columnName,
-      const TypePtr& type,
-      float startPct,
-      float selectPct,
-      uint8_t nullsRateX100,
-      uint32_t nextSize) {
-    folly::BenchmarkSuspender suspender;
-
-    auto rowType = ROW({columnName}, {type});
-    auto batches =
-        dataSetBuilder_->makeDataset(rowType, kNumBatches, kNumRowsPerBatch)
-            .withRowGroupSpecificData(kNumRowsPerRowGroup)
-            .withNullsForField(Subfield(columnName), nullsRateX100)
-            .build();
-    writeToFile(*batches, true);
-    std::vector<FilterSpec> filterSpecs;
-
-    //    Filters on List and Map are not supported currently.
-    if (type->kind() != TypeKind::ARRAY && type->kind() != TypeKind::MAP) {
-      filterSpecs.emplace_back(createFilterSpec(
-          columnName, startPct, selectPct, rowType, false, false));
+    if (result->size() == 0) {
+      continue;
     }
 
-    std::vector<uint64_t> hitRows;
-    auto scanSpec = createScanSpec(*batches, rowType, filterSpecs, hitRows);
-
-    suspender.dismiss();
+    auto rowVector = result->asUnchecked<RowVector>();
+    for (auto i = 0; i < rowVector->childrenSize(); ++i) {
+      rowVector->childAt(i)->loadedVector();
+    }
 
-    // Filter range is generated from a small sample data of 4096 rows. So the
-    // upperBound and lowerBound are introduced to estimate the result size.
-    auto resultSize = read(rowType, scanSpec, nextSize);
+    VELOX_CHECK_EQ(
+        rowVector->childrenSize(),
+        1,
+        "The benchmark is performed on single columns. So the result should only contain one column.");
 
-    // Add one to expected to avoid 0 in calculating upperBound and lowerBound.
-    int expected = kNumBatches * kNumRowsPerBatch *
-            (1 - (double)nullsRateX100 / 100) * ((double)selectPct / 100) +
-        1;
+    for (int i = 0; i < rowVector->size(); i++) {
+      resultSize += !rowVector->childAt(0)->isNullAt(i);
+    }
+  }
 
-    // Make the upperBound and lowerBound large enough to avoid very small
-    // resultSize and expected size, where the diff ratio is relatively very
-    // large.
-    int upperBound = expected * (1 + kFilterErrorMargin) + 1;
-    int lowerBound = expected * (1 - kFilterErrorMargin) - 1;
-    upperBound = std::max(16, upperBound);
-    lowerBound = std::max(0, lowerBound);
+  rowReader->updateRuntimeStats(runtimeStats_);
+  return resultSize;
+}
 
-    VELOX_CHECK(
-        resultSize <= upperBound && resultSize >= lowerBound,
-        "Result Size {} and Expected Size {} Mismatch",
-        resultSize,
-        expected);
+void ParquetReaderBenchmark::readSingleColumn(
+    const std::string& columnName,
+    const TypePtr& type,
+    float startPct,
+    float selectPct,
+    uint8_t nullsRateX100,
+    uint32_t nextSize) {
+  folly::BenchmarkSuspender suspender;
+
+  auto rowType = ROW({columnName}, {type});
+  // Generating the data (consider the null rate).
+  auto batches =
+      dataSetBuilder_->makeDataset(rowType, kNumBatches, kNumRowsPerBatch)
+          .withRowGroupSpecificData(kNumRowsPerRowGroup)
+          .withNullsForField(Subfield(columnName), nullsRateX100)
+          .build();
+  writeToFile(*batches, true);
+  std::vector<FilterSpec> filterSpecs;
+
+  // Filters on List and Map are not supported currently.
+  if (type->kind() != TypeKind::ARRAY && type->kind() != TypeKind::MAP) {
+    filterSpecs.emplace_back(createFilterSpec(
+        columnName, startPct, selectPct, rowType, false, false));
   }
 
- private:
-  const std::string fileName_ = "test.parquet";
-  const std::shared_ptr<facebook::velox::exec::test::TempDirectoryPath>
-      fileFolder_ = facebook::velox::exec::test::TempDirectoryPath::create();
-  const bool disableDictionary_;
-
-  std::unique_ptr<test::DataSetBuilder> dataSetBuilder_;
-  std::shared_ptr<memory::MemoryPool> rootPool_;
-  std::shared_ptr<memory::MemoryPool> leafPool_;
-  std::unique_ptr<facebook::velox::parquet::Writer> writer_;
-  RuntimeStatistics runtimeStats_;
-};
+  std::vector<uint64_t> hitRows;
+  auto scanSpec = createScanSpec(*batches, rowType, filterSpecs, hitRows);
+
+  suspender.dismiss();
+
+  // Filter range is generated from a small sample data of 4096 rows. So the
+  // upperBound and lowerBound are introduced to estimate the result size.
+  auto resultSize = read(rowType, scanSpec, nextSize);
+
+  // Calculate the expected number of rows after the filters.
+  // Add one to expected to avoid 0 in calculating upperBound and lowerBound.
+  int expected = kNumBatches * kNumRowsPerBatch *
+          (1 - (double)nullsRateX100 / 100) * ((double)selectPct / 100) +
+      1;
+
+  // Make the upperBound and lowerBound large enough to avoid very small
+  // resultSize and expected size, where the diff ratio is relatively very
+  // large.
+  int upperBound = expected * (1 + kFilterErrorMargin) + 1;
+  int lowerBound = expected * (1 - kFilterErrorMargin) - 1;
+  upperBound = std::max(16, upperBound);
+  lowerBound = std::max(0, lowerBound);
+
+  VELOX_CHECK(
+      resultSize <= upperBound && resultSize >= lowerBound,
+      "Result Size {} and Expected Size {} Mismatch",
+      resultSize,
+      expected);
+}
 
 void run(
     uint32_t,
@@ -249,807 +221,12 @@ void run(
     uint8_t nullsRateX100,
     uint32_t nextSize,
     bool disableDictionary) {
-  ParquetReaderBenchmark benchmark(disableDictionary);
+  RowTypePtr rowType = ROW({columnName}, {type});
+  facebook::velox::parquet::test::ParquetReaderBenchmark benchmark(
+      disableDictionary, rowType);
   BIGINT()->toString();
   benchmark.readSingleColumn(
       columnName, type, 0, filterRateX100, nullsRateX100, nextSize);
 }
 
-#define PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, _null_) \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_5k_dict,         \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      5000,                                                               \
-      false);                                                             \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_5k_plain,        \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      5000,                                                               \
-      true);                                                              \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_10k_dict,        \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      10000,                                                              \
-      false);                                                             \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_10k_Plain,       \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      10000,                                                              \
-      true);                                                              \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_20k_dict,        \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      20000,                                                              \
-      false);                                                             \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_20k_plain,       \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      20000,                                                              \
-      true);                                                              \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_50k_dict,        \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      50000,                                                              \
-      false);                                                             \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_50k_plain,       \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      50000,                                                              \
-      true);                                                              \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_100k_dict,       \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      100000,                                                             \
-      false);                                                             \
-  BENCHMARK_NAMED_PARAM(                                                  \
-      run,                                                                \
-      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_100k_plain,      \
-      #_name_,                                                            \
-      _type_,                                                             \
-      _filter_,                                                           \
-      _null_,                                                             \
-      100000,                                                             \
-      true);                                                              \
-  BENCHMARK_DRAW_LINE();
-
-#define PARQUET_BENCHMARKS_FILTERS(_type_, _name_, _filter_)    \
-  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 0)  \
-  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 20) \
-  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 50) \
-  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 70) \
-  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 100)
-
-#define PARQUET_BENCHMARKS(_type_, _name_)        \
-  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 0)   \
-  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 20)  \
-  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 50)  \
-  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 70)  \
-  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 100) \
-  BENCHMARK_DRAW_LINE();
-
-#define PARQUET_BENCHMARKS_NO_FILTER(_type_, _name_) \
-  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 100)    \
-  BENCHMARK_DRAW_LINE();
-
-PARQUET_BENCHMARKS(BIGINT(), BigInt);
-PARQUET_BENCHMARKS(DOUBLE(), Double);
-PARQUET_BENCHMARKS_NO_FILTER(MAP(BIGINT(), BIGINT()), Map);
-PARQUET_BENCHMARKS_NO_FILTER(ARRAY(BIGINT()), List);
-
-// TODO: Add all data types
-
-int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
-  folly::runBenchmarks();
-  return 0;
-}
-
-/*
-CPU model name: Intel(R) Xeon(R) Platinum 8163 CPU @ 2.50GHz
-Core(s) used: 24
-Memory(GB): 96
-
-============================================================================
-relative                                                  time/iter  iters/s
-============================================================================
-run(BigInt_Filter_0_Nulls_0_next_5k_dict)                    7.75ms   129.03
-run(BigInt_Filter_0_Nulls_0_next_5k_plain)                  41.18ms    24.28
-run(BigInt_Filter_0_Nulls_0_next_10k_dict)                  29.86ms    33.49
-run(BigInt_Filter_0_Nulls_0_next_10k_Plain)                 40.74ms    24.54
-run(BigInt_Filter_0_Nulls_0_next_20k_dict)                  62.92ms    15.89
-run(BigInt_Filter_0_Nulls_0_next_20k_plain)                 24.68ms    40.52
-run(BigInt_Filter_0_Nulls_0_next_50k_dict)                  60.66ms    16.49
-run(BigInt_Filter_0_Nulls_0_next_50k_plain)                 13.58ms    73.63
-run(BigInt_Filter_0_Nulls_0_next_100k_dict)                 42.61ms    23.47
-run(BigInt_Filter_0_Nulls_0_next_100k_plain)                31.32ms    31.93
-----------------------------------------------------------------------------
-run(BigInt_Filter_0_Nulls_20_next_5k_dict)                  24.36ms    41.04
-run(BigInt_Filter_0_Nulls_20_next_5k_plain)                 27.84ms    35.92
-run(BigInt_Filter_0_Nulls_20_next_10k_dict)                 12.15ms    82.33
-run(BigInt_Filter_0_Nulls_20_next_10k_Plain)                30.98ms    32.28
-run(BigInt_Filter_0_Nulls_20_next_20k_dict)                 36.97ms    27.05
-run(BigInt_Filter_0_Nulls_20_next_20k_plain)                30.09ms    33.23
-run(BigInt_Filter_0_Nulls_20_next_50k_dict)                 44.06ms    22.70
-run(BigInt_Filter_0_Nulls_20_next_50k_plain)                11.44ms    87.43
-run(BigInt_Filter_0_Nulls_20_next_100k_dict)                54.49ms    18.35
-run(BigInt_Filter_0_Nulls_20_next_100k_plain)                8.10ms   123.39
-----------------------------------------------------------------------------
-run(BigInt_Filter_0_Nulls_50_next_5k_dict)                  24.37ms    41.03
-run(BigInt_Filter_0_Nulls_50_next_5k_plain)                 30.68ms    32.60
-run(BigInt_Filter_0_Nulls_50_next_10k_dict)                  7.20ms   138.94
-run(BigInt_Filter_0_Nulls_50_next_10k_Plain)                15.61ms    64.04
-run(BigInt_Filter_0_Nulls_50_next_20k_dict)                 17.66ms    56.63
-run(BigInt_Filter_0_Nulls_50_next_20k_plain)                17.82ms    56.12
-run(BigInt_Filter_0_Nulls_50_next_50k_dict)                 19.38ms    51.59
-run(BigInt_Filter_0_Nulls_50_next_50k_plain)                11.77ms    84.97
-run(BigInt_Filter_0_Nulls_50_next_100k_dict)                14.20ms    70.44
-run(BigInt_Filter_0_Nulls_50_next_100k_plain)               14.86ms    67.31
-----------------------------------------------------------------------------
-run(BigInt_Filter_0_Nulls_70_next_5k_dict)                  19.18ms    52.15
-run(BigInt_Filter_0_Nulls_70_next_5k_plain)                 10.37ms    96.47
-run(BigInt_Filter_0_Nulls_70_next_10k_dict)                 11.02ms    90.76
-run(BigInt_Filter_0_Nulls_70_next_10k_Plain)                11.13ms    89.89
-run(BigInt_Filter_0_Nulls_70_next_20k_dict)                 10.43ms    95.85
-run(BigInt_Filter_0_Nulls_70_next_20k_plain)                10.60ms    94.31
-run(BigInt_Filter_0_Nulls_70_next_50k_dict)                 12.00ms    83.36
-run(BigInt_Filter_0_Nulls_70_next_50k_plain)                12.04ms    83.03
-run(BigInt_Filter_0_Nulls_70_next_100k_dict)                11.81ms    84.65
-run(BigInt_Filter_0_Nulls_70_next_100k_plain)               10.59ms    94.39
-----------------------------------------------------------------------------
-run(BigInt_Filter_0_Nulls_100_next_5k_dict)                  1.07ms   938.83
-run(BigInt_Filter_0_Nulls_100_next_5k_plain)                 1.01ms   991.27
-run(BigInt_Filter_0_Nulls_100_next_10k_dict)                 1.06ms   941.26
-run(BigInt_Filter_0_Nulls_100_next_10k_Plain)                1.02ms   979.09
-run(BigInt_Filter_0_Nulls_100_next_20k_dict)                 1.06ms   945.97
-run(BigInt_Filter_0_Nulls_100_next_20k_plain)                1.02ms   978.10
-run(BigInt_Filter_0_Nulls_100_next_50k_dict)                 1.09ms   916.37
-run(BigInt_Filter_0_Nulls_100_next_50k_plain)                1.02ms   976.12
-run(BigInt_Filter_0_Nulls_100_next_100k_dict)                1.07ms   936.30
-run(BigInt_Filter_0_Nulls_100_next_100k_plain)               1.01ms   986.33
-----------------------------------------------------------------------------
-run(BigInt_Filter_20_Nulls_0_next_5k_dict)                  50.42ms    19.83
-run(BigInt_Filter_20_Nulls_0_next_5k_plain)                 55.73ms    17.94
-run(BigInt_Filter_20_Nulls_0_next_10k_dict)                 80.05ms    12.49
-run(BigInt_Filter_20_Nulls_0_next_10k_Plain)                58.70ms    17.04
-run(BigInt_Filter_20_Nulls_0_next_20k_dict)                 70.42ms    14.20
-run(BigInt_Filter_20_Nulls_0_next_20k_plain)                59.00ms    16.95
-run(BigInt_Filter_20_Nulls_0_next_50k_dict)                 83.51ms    11.97
-run(BigInt_Filter_20_Nulls_0_next_50k_plain)                25.46ms    39.27
-run(BigInt_Filter_20_Nulls_0_next_100k_dict)                75.88ms    13.18
-run(BigInt_Filter_20_Nulls_0_next_100k_plain)               60.11ms    16.64
-----------------------------------------------------------------------------
-run(BigInt_Filter_20_Nulls_20_next_5k_dict)                 65.20ms    15.34
-run(BigInt_Filter_20_Nulls_20_next_5k_plain)                42.99ms    23.26
-run(BigInt_Filter_20_Nulls_20_next_10k_dict)                67.89ms    14.73
-run(BigInt_Filter_20_Nulls_20_next_10k_Plain)               40.18ms    24.89
-run(BigInt_Filter_20_Nulls_20_next_20k_dict)                65.53ms    15.26
-run(BigInt_Filter_20_Nulls_20_next_20k_plain)               40.92ms    24.44
-run(BigInt_Filter_20_Nulls_20_next_50k_dict)                70.80ms    14.12
-run(BigInt_Filter_20_Nulls_20_next_50k_plain)               38.04ms    26.29
-run(BigInt_Filter_20_Nulls_20_next_100k_dict)               62.03ms    16.12
-run(BigInt_Filter_20_Nulls_20_next_100k_plain)              43.54ms    22.97
-----------------------------------------------------------------------------
-run(BigInt_Filter_20_Nulls_50_next_5k_dict)                 49.09ms    20.37
-run(BigInt_Filter_20_Nulls_50_next_5k_plain)                25.91ms    38.60
-run(BigInt_Filter_20_Nulls_50_next_10k_dict)                37.13ms    26.93
-run(BigInt_Filter_20_Nulls_50_next_10k_Plain)               27.16ms    36.82
-run(BigInt_Filter_20_Nulls_50_next_20k_dict)                37.01ms    27.02
-run(BigInt_Filter_20_Nulls_50_next_20k_plain)               26.73ms    37.41
-run(BigInt_Filter_20_Nulls_50_next_50k_dict)                36.27ms    27.57
-run(BigInt_Filter_20_Nulls_50_next_50k_plain)               25.01ms    39.98
-run(BigInt_Filter_20_Nulls_50_next_100k_dict)               36.16ms    27.65
-run(BigInt_Filter_20_Nulls_50_next_100k_plain)              27.30ms    36.63
-----------------------------------------------------------------------------
-run(BigInt_Filter_20_Nulls_70_next_5k_dict)                 34.33ms    29.13
-run(BigInt_Filter_20_Nulls_70_next_5k_plain)                18.45ms    54.19
-run(BigInt_Filter_20_Nulls_70_next_10k_dict)                25.55ms    39.14
-run(BigInt_Filter_20_Nulls_70_next_10k_Plain)               20.94ms    47.75
-run(BigInt_Filter_20_Nulls_70_next_20k_dict)                29.33ms    34.10
-run(BigInt_Filter_20_Nulls_70_next_20k_plain)               19.46ms    51.38
-run(BigInt_Filter_20_Nulls_70_next_50k_dict)                28.41ms    35.20
-run(BigInt_Filter_20_Nulls_70_next_50k_plain)               18.20ms    54.93
-run(BigInt_Filter_20_Nulls_70_next_100k_dict)               25.68ms    38.94
-run(BigInt_Filter_20_Nulls_70_next_100k_plain)              18.88ms    52.97
-----------------------------------------------------------------------------
-run(BigInt_Filter_20_Nulls_100_next_5k_dict)                 1.16ms   860.57
-run(BigInt_Filter_20_Nulls_100_next_5k_plain)                1.01ms   992.49
-run(BigInt_Filter_20_Nulls_100_next_10k_dict)                1.10ms   907.85
-run(BigInt_Filter_20_Nulls_100_next_10k_Plain)             999.27us    1.00K
-run(BigInt_Filter_20_Nulls_100_next_20k_dict)                1.12ms   890.24
-run(BigInt_Filter_20_Nulls_100_next_20k_plain)               1.06ms   942.98
-run(BigInt_Filter_20_Nulls_100_next_50k_dict)                1.15ms   872.19
-run(BigInt_Filter_20_Nulls_100_next_50k_plain)               1.06ms   945.59
-run(BigInt_Filter_20_Nulls_100_next_100k_dict)               1.11ms   896.97
-run(BigInt_Filter_20_Nulls_100_next_100k_plain)              1.08ms   926.88
-----------------------------------------------------------------------------
-run(BigInt_Filter_50_Nulls_0_next_5k_dict)                  94.90ms    10.54
-run(BigInt_Filter_50_Nulls_0_next_5k_plain)                 26.45ms    37.81
-run(BigInt_Filter_50_Nulls_0_next_10k_dict)                188.07ms     5.32
-run(BigInt_Filter_50_Nulls_0_next_10k_Plain)                83.78ms    11.94
-run(BigInt_Filter_50_Nulls_0_next_20k_dict)                 85.43ms    11.71
-run(BigInt_Filter_50_Nulls_0_next_20k_plain)                56.34ms    17.75
-run(BigInt_Filter_50_Nulls_0_next_50k_dict)                 99.34ms    10.07
-run(BigInt_Filter_50_Nulls_0_next_50k_plain)                42.77ms    23.38
-run(BigInt_Filter_50_Nulls_0_next_100k_dict)                97.26ms    10.28
-run(BigInt_Filter_50_Nulls_0_next_100k_plain)               54.87ms    18.22
-----------------------------------------------------------------------------
-run(BigInt_Filter_50_Nulls_20_next_5k_dict)                 87.86ms    11.38
-run(BigInt_Filter_50_Nulls_20_next_5k_plain)                45.31ms    22.07
-run(BigInt_Filter_50_Nulls_20_next_10k_dict)                73.18ms    13.66
-run(BigInt_Filter_50_Nulls_20_next_10k_Plain)               49.73ms    20.11
-run(BigInt_Filter_50_Nulls_20_next_20k_dict)                73.67ms    13.57
-run(BigInt_Filter_50_Nulls_20_next_20k_plain)               42.47ms    23.54
-run(BigInt_Filter_50_Nulls_20_next_50k_dict)                73.13ms    13.67
-run(BigInt_Filter_50_Nulls_20_next_50k_plain)               48.73ms    20.52
-run(BigInt_Filter_50_Nulls_20_next_100k_dict)               74.09ms    13.50
-run(BigInt_Filter_50_Nulls_20_next_100k_plain)              44.34ms    22.55
-----------------------------------------------------------------------------
-run(BigInt_Filter_50_Nulls_50_next_5k_dict)                 54.68ms    18.29
-run(BigInt_Filter_50_Nulls_50_next_5k_plain)                29.64ms    33.74
-run(BigInt_Filter_50_Nulls_50_next_10k_dict)                46.24ms    21.63
-run(BigInt_Filter_50_Nulls_50_next_10k_Plain)               25.79ms    38.78
-run(BigInt_Filter_50_Nulls_50_next_20k_dict)                44.20ms    22.62
-run(BigInt_Filter_50_Nulls_50_next_20k_plain)               24.72ms    40.45
-run(BigInt_Filter_50_Nulls_50_next_50k_dict)                45.32ms    22.06
-run(BigInt_Filter_50_Nulls_50_next_50k_plain)               46.27ms    21.61
-run(BigInt_Filter_50_Nulls_50_next_100k_dict)              101.24ms     9.88
-run(BigInt_Filter_50_Nulls_50_next_100k_plain)              27.50ms    36.36
-----------------------------------------------------------------------------
-run(BigInt_Filter_50_Nulls_70_next_5k_dict)                 39.17ms    25.53
-run(BigInt_Filter_50_Nulls_70_next_5k_plain)                19.61ms    51.00
-run(BigInt_Filter_50_Nulls_70_next_10k_dict)                32.26ms    31.00
-run(BigInt_Filter_50_Nulls_70_next_10k_Plain)               17.96ms    55.67
-run(BigInt_Filter_50_Nulls_70_next_20k_dict)                31.52ms    31.72
-run(BigInt_Filter_50_Nulls_70_next_20k_plain)               19.25ms    51.94
-run(BigInt_Filter_50_Nulls_70_next_50k_dict)                32.78ms    30.50
-run(BigInt_Filter_50_Nulls_70_next_50k_plain)               21.08ms    47.43
-run(BigInt_Filter_50_Nulls_70_next_100k_dict)               31.40ms    31.85
-run(BigInt_Filter_50_Nulls_70_next_100k_plain)              19.42ms    51.48
-----------------------------------------------------------------------------
-run(BigInt_Filter_50_Nulls_100_next_5k_dict)                 1.13ms   883.51
-run(BigInt_Filter_50_Nulls_100_next_5k_plain)                1.01ms   989.30
-run(BigInt_Filter_50_Nulls_100_next_10k_dict)                1.11ms   903.18
-run(BigInt_Filter_50_Nulls_100_next_10k_Plain)               1.06ms   945.54
-run(BigInt_Filter_50_Nulls_100_next_20k_dict)                1.17ms   853.65
-run(BigInt_Filter_50_Nulls_100_next_20k_plain)               1.04ms   961.50
-run(BigInt_Filter_50_Nulls_100_next_50k_dict)                1.10ms   905.35
-run(BigInt_Filter_50_Nulls_100_next_50k_plain)               1.07ms   935.95
-run(BigInt_Filter_50_Nulls_100_next_100k_dict)               1.14ms   876.28
-run(BigInt_Filter_50_Nulls_100_next_100k_plain)              1.08ms   922.87
-----------------------------------------------------------------------------
-run(BigInt_Filter_70_Nulls_0_next_5k_dict)                  67.26ms    14.87
-run(BigInt_Filter_70_Nulls_0_next_5k_plain)                 50.38ms    19.85
-run(BigInt_Filter_70_Nulls_0_next_10k_dict)                 86.54ms    11.55
-run(BigInt_Filter_70_Nulls_0_next_10k_Plain)                57.47ms    17.40
-run(BigInt_Filter_70_Nulls_0_next_20k_dict)                 86.72ms    11.53
-run(BigInt_Filter_70_Nulls_0_next_20k_plain)                30.38ms    32.92
-run(BigInt_Filter_70_Nulls_0_next_50k_dict)                 86.81ms    11.52
-run(BigInt_Filter_70_Nulls_0_next_50k_plain)                58.23ms    17.17
-run(BigInt_Filter_70_Nulls_0_next_100k_dict)                91.78ms    10.90
-run(BigInt_Filter_70_Nulls_0_next_100k_plain)               61.13ms    16.36
-----------------------------------------------------------------------------
-run(BigInt_Filter_70_Nulls_20_next_5k_dict)                 75.08ms    13.32
-run(BigInt_Filter_70_Nulls_20_next_5k_plain)                50.99ms    19.61
-run(BigInt_Filter_70_Nulls_20_next_10k_dict)                74.97ms    13.34
-run(BigInt_Filter_70_Nulls_20_next_10k_Plain)               52.91ms    18.90
-run(BigInt_Filter_70_Nulls_20_next_20k_dict)                72.78ms    13.74
-run(BigInt_Filter_70_Nulls_20_next_20k_plain)               47.73ms    20.95
-run(BigInt_Filter_70_Nulls_20_next_50k_dict)                75.43ms    13.26
-run(BigInt_Filter_70_Nulls_20_next_50k_plain)               51.01ms    19.60
-run(BigInt_Filter_70_Nulls_20_next_100k_dict)               70.30ms    14.22
-run(BigInt_Filter_70_Nulls_20_next_100k_plain)              54.85ms    18.23
-----------------------------------------------------------------------------
-run(BigInt_Filter_70_Nulls_50_next_5k_dict)                 51.76ms    19.32
-run(BigInt_Filter_70_Nulls_50_next_5k_plain)                31.75ms    31.50
-run(BigInt_Filter_70_Nulls_50_next_10k_dict)                45.24ms    22.11
-run(BigInt_Filter_70_Nulls_50_next_10k_Plain)               28.94ms    34.56
-run(BigInt_Filter_70_Nulls_50_next_20k_dict)                41.10ms    24.33
-run(BigInt_Filter_70_Nulls_50_next_20k_plain)               30.63ms    32.65
-run(BigInt_Filter_70_Nulls_50_next_50k_dict)                46.30ms    21.60
-run(BigInt_Filter_70_Nulls_50_next_50k_plain)               28.34ms    35.29
-run(BigInt_Filter_70_Nulls_50_next_100k_dict)               47.60ms    21.01
-run(BigInt_Filter_70_Nulls_50_next_100k_plain)              36.24ms    27.59
-----------------------------------------------------------------------------
-run(BigInt_Filter_70_Nulls_70_next_5k_dict)                 46.48ms    21.51
-run(BigInt_Filter_70_Nulls_70_next_5k_plain)                17.26ms    57.92
-run(BigInt_Filter_70_Nulls_70_next_10k_dict)                24.55ms    40.74
-run(BigInt_Filter_70_Nulls_70_next_10k_Plain)               18.40ms    54.36
-run(BigInt_Filter_70_Nulls_70_next_20k_dict)                32.09ms    31.16
-run(BigInt_Filter_70_Nulls_70_next_20k_plain)               20.01ms    49.98
-run(BigInt_Filter_70_Nulls_70_next_50k_dict)                32.16ms    31.09
-run(BigInt_Filter_70_Nulls_70_next_50k_plain)               19.33ms    51.72
-run(BigInt_Filter_70_Nulls_70_next_100k_dict)               28.15ms    35.53
-run(BigInt_Filter_70_Nulls_70_next_100k_plain)              20.87ms    47.91
-----------------------------------------------------------------------------
-run(BigInt_Filter_70_Nulls_100_next_5k_dict)                 1.12ms   889.19
-run(BigInt_Filter_70_Nulls_100_next_5k_plain)                1.08ms   925.58
-run(BigInt_Filter_70_Nulls_100_next_10k_dict)                1.14ms   874.84
-run(BigInt_Filter_70_Nulls_100_next_10k_Plain)               1.04ms   961.56
-run(BigInt_Filter_70_Nulls_100_next_20k_dict)                1.10ms   905.32
-run(BigInt_Filter_70_Nulls_100_next_20k_plain)               1.06ms   942.57
-run(BigInt_Filter_70_Nulls_100_next_50k_dict)                1.13ms   887.46
-run(BigInt_Filter_70_Nulls_100_next_50k_plain)               1.06ms   947.04
-run(BigInt_Filter_70_Nulls_100_next_100k_dict)               1.11ms   900.77
-run(BigInt_Filter_70_Nulls_100_next_100k_plain)              1.06ms   941.01
-----------------------------------------------------------------------------
-run(BigInt_Filter_100_Nulls_0_next_5k_dict)                 46.36ms    21.57
-run(BigInt_Filter_100_Nulls_0_next_5k_plain)                59.90ms    16.69
-run(BigInt_Filter_100_Nulls_0_next_10k_dict)                78.87ms    12.68
-run(BigInt_Filter_100_Nulls_0_next_10k_Plain)               61.97ms    16.14
-run(BigInt_Filter_100_Nulls_0_next_20k_dict)                75.71ms    13.21
-run(BigInt_Filter_100_Nulls_0_next_20k_plain)               65.25ms    15.33
-run(BigInt_Filter_100_Nulls_0_next_50k_dict)               129.60ms     7.72
-run(BigInt_Filter_100_Nulls_0_next_50k_plain)              110.12ms     9.08
-run(BigInt_Filter_100_Nulls_0_next_100k_dict)               91.04ms    10.98
-run(BigInt_Filter_100_Nulls_0_next_100k_plain)              42.92ms    23.30
-----------------------------------------------------------------------------
-run(BigInt_Filter_100_Nulls_20_next_5k_dict)                77.86ms    12.84
-run(BigInt_Filter_100_Nulls_20_next_5k_plain)               44.95ms    22.25
-run(BigInt_Filter_100_Nulls_20_next_10k_dict)               72.22ms    13.85
-run(BigInt_Filter_100_Nulls_20_next_10k_Plain)              52.12ms    19.19
-run(BigInt_Filter_100_Nulls_20_next_20k_dict)               58.55ms    17.08
-run(BigInt_Filter_100_Nulls_20_next_20k_plain)              49.64ms    20.15
-run(BigInt_Filter_100_Nulls_20_next_50k_dict)               61.28ms    16.32
-run(BigInt_Filter_100_Nulls_20_next_50k_plain)              47.43ms    21.09
-run(BigInt_Filter_100_Nulls_20_next_100k_dict)              66.19ms    15.11
-run(BigInt_Filter_100_Nulls_20_next_100k_plain)             45.53ms    21.97
-----------------------------------------------------------------------------
-run(BigInt_Filter_100_Nulls_50_next_5k_dict)                44.46ms    22.49
-run(BigInt_Filter_100_Nulls_50_next_5k_plain)               26.50ms    37.73
-run(BigInt_Filter_100_Nulls_50_next_10k_dict)               39.00ms    25.64
-run(BigInt_Filter_100_Nulls_50_next_10k_Plain)              31.51ms    31.74
-run(BigInt_Filter_100_Nulls_50_next_20k_dict)               35.79ms    27.94
-run(BigInt_Filter_100_Nulls_50_next_20k_plain)              28.04ms    35.66
-run(BigInt_Filter_100_Nulls_50_next_50k_dict)               36.43ms    27.45
-run(BigInt_Filter_100_Nulls_50_next_50k_plain)              26.79ms    37.32
-run(BigInt_Filter_100_Nulls_50_next_100k_dict)              37.73ms    26.50
-run(BigInt_Filter_100_Nulls_50_next_100k_plain)             30.57ms    32.71
-----------------------------------------------------------------------------
-run(BigInt_Filter_100_Nulls_70_next_5k_dict)                31.60ms    31.64
-run(BigInt_Filter_100_Nulls_70_next_5k_plain)               18.93ms    52.84
-run(BigInt_Filter_100_Nulls_70_next_10k_dict)               25.33ms    39.48
-run(BigInt_Filter_100_Nulls_70_next_10k_Plain)              20.15ms    49.63
-run(BigInt_Filter_100_Nulls_70_next_20k_dict)               25.75ms    38.83
-run(BigInt_Filter_100_Nulls_70_next_20k_plain)              18.67ms    53.57
-run(BigInt_Filter_100_Nulls_70_next_50k_dict)               30.65ms    32.63
-run(BigInt_Filter_100_Nulls_70_next_50k_plain)              54.27ms    18.43
-run(BigInt_Filter_100_Nulls_70_next_100k_dict)              25.32ms    39.50
-run(BigInt_Filter_100_Nulls_70_next_100k_plain)             18.07ms    55.35
-----------------------------------------------------------------------------
-run(BigInt_Filter_100_Nulls_100_next_5k_dict)                1.15ms   869.44
-run(BigInt_Filter_100_Nulls_100_next_5k_plain)               1.05ms   951.19
-run(BigInt_Filter_100_Nulls_100_next_10k_dict)               1.17ms   856.61
-run(BigInt_Filter_100_Nulls_100_next_10k_Plain)              1.05ms   951.32
-run(BigInt_Filter_100_Nulls_100_next_20k_dict)               1.12ms   891.29
-run(BigInt_Filter_100_Nulls_100_next_20k_plain)              1.07ms   932.20
-run(BigInt_Filter_100_Nulls_100_next_50k_dict)               1.11ms   899.75
-run(BigInt_Filter_100_Nulls_100_next_50k_plain)              1.06ms   939.04
-run(BigInt_Filter_100_Nulls_100_next_100k_dict)              1.11ms   897.09
-run(BigInt_Filter_100_Nulls_100_next_100k_plain              1.08ms   926.95
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
-run(Double_Filter_0_Nulls_0_next_5k_dict)                   46.04ms    21.72
-run(Double_Filter_0_Nulls_0_next_5k_plain)                  10.34ms    96.76
-run(Double_Filter_0_Nulls_0_next_10k_dict)                 116.04ms     8.62
-run(Double_Filter_0_Nulls_0_next_10k_Plain)                 84.38ms    11.85
-run(Double_Filter_0_Nulls_0_next_20k_dict)                  58.66ms    17.05
-run(Double_Filter_0_Nulls_0_next_20k_plain)                 22.44ms    44.57
-run(Double_Filter_0_Nulls_0_next_50k_dict)                  36.30ms    27.55
-run(Double_Filter_0_Nulls_0_next_50k_plain)                 38.86ms    25.73
-run(Double_Filter_0_Nulls_0_next_100k_dict)                 34.28ms    29.17
-run(Double_Filter_0_Nulls_0_next_100k_plain)                40.39ms    24.76
-----------------------------------------------------------------------------
-run(Double_Filter_0_Nulls_20_next_5k_dict)                  36.77ms    27.20
-run(Double_Filter_0_Nulls_20_next_5k_plain)                 29.27ms    34.16
-run(Double_Filter_0_Nulls_20_next_10k_dict)                 28.53ms    35.05
-run(Double_Filter_0_Nulls_20_next_10k_Plain)                48.94ms    20.43
-run(Double_Filter_0_Nulls_20_next_20k_dict)                100.08ms     9.99
-run(Double_Filter_0_Nulls_20_next_20k_plain)                61.53ms    16.25
-run(Double_Filter_0_Nulls_20_next_50k_dict)                 47.61ms    21.01
-run(Double_Filter_0_Nulls_20_next_50k_plain)                11.76ms    85.05
-run(Double_Filter_0_Nulls_20_next_100k_dict)                29.92ms    33.42
-run(Double_Filter_0_Nulls_20_next_100k_plain)               27.75ms    36.03
-----------------------------------------------------------------------------
-run(Double_Filter_0_Nulls_50_next_5k_dict)                  31.65ms    31.60
-run(Double_Filter_0_Nulls_50_next_5k_plain)                 20.92ms    47.81
-run(Double_Filter_0_Nulls_50_next_10k_dict)                 15.91ms    62.84
-run(Double_Filter_0_Nulls_50_next_10k_Plain)                20.29ms    49.28
-run(Double_Filter_0_Nulls_50_next_20k_dict)                 15.48ms    64.60
-run(Double_Filter_0_Nulls_50_next_20k_plain)                19.93ms    50.17
-run(Double_Filter_0_Nulls_50_next_50k_dict)                 23.60ms    42.37
-run(Double_Filter_0_Nulls_50_next_50k_plain)                11.11ms    90.04
-run(Double_Filter_0_Nulls_50_next_100k_dict)                18.63ms    53.69
-run(Double_Filter_0_Nulls_50_next_100k_plain)               18.58ms    53.81
-----------------------------------------------------------------------------
-run(Double_Filter_0_Nulls_70_next_5k_dict)                  20.09ms    49.77
-run(Double_Filter_0_Nulls_70_next_5k_plain)                 11.68ms    85.62
-run(Double_Filter_0_Nulls_70_next_10k_dict)                 12.67ms    78.94
-run(Double_Filter_0_Nulls_70_next_10k_Plain)                11.80ms    84.74
-run(Double_Filter_0_Nulls_70_next_20k_dict)                 14.77ms    67.68
-run(Double_Filter_0_Nulls_70_next_20k_plain)                11.40ms    87.69
-run(Double_Filter_0_Nulls_70_next_50k_dict)                 12.71ms    78.65
-run(Double_Filter_0_Nulls_70_next_50k_plain)                11.36ms    88.01
-run(Double_Filter_0_Nulls_70_next_100k_dict)                12.45ms    80.35
-run(Double_Filter_0_Nulls_70_next_100k_plain)               12.26ms    81.60
-----------------------------------------------------------------------------
-run(Double_Filter_0_Nulls_100_next_5k_dict)                  1.15ms   871.27
-run(Double_Filter_0_Nulls_100_next_5k_plain)                 1.11ms   903.46
-run(Double_Filter_0_Nulls_100_next_10k_dict)                 1.16ms   859.44
-run(Double_Filter_0_Nulls_100_next_10k_Plain)                1.08ms   924.40
-run(Double_Filter_0_Nulls_100_next_20k_dict)                 1.13ms   886.21
-run(Double_Filter_0_Nulls_100_next_20k_plain)                1.05ms   947.89
-run(Double_Filter_0_Nulls_100_next_50k_dict)                 1.17ms   853.94
-run(Double_Filter_0_Nulls_100_next_50k_plain)                1.11ms   904.17
-run(Double_Filter_0_Nulls_100_next_100k_dict)                1.13ms   881.83
-run(Double_Filter_0_Nulls_100_next_100k_plain)               1.10ms   906.42
-----------------------------------------------------------------------------
-run(Double_Filter_20_Nulls_0_next_5k_dict)                  70.59ms    14.17
-run(Double_Filter_20_Nulls_0_next_5k_plain)                 54.44ms    18.37
-run(Double_Filter_20_Nulls_0_next_10k_dict)                 65.36ms    15.30
-run(Double_Filter_20_Nulls_0_next_10k_Plain)                56.26ms    17.77
-run(Double_Filter_20_Nulls_0_next_20k_dict)                107.09ms     9.34
-run(Double_Filter_20_Nulls_0_next_20k_plain)                32.33ms    30.93
-run(Double_Filter_20_Nulls_0_next_50k_dict)                 82.43ms    12.13
-run(Double_Filter_20_Nulls_0_next_50k_plain)                55.24ms    18.10
-run(Double_Filter_20_Nulls_0_next_100k_dict)                90.81ms    11.01
-run(Double_Filter_20_Nulls_0_next_100k_plain)               45.57ms    21.95
-----------------------------------------------------------------------------
-run(Double_Filter_20_Nulls_20_next_5k_dict)                 68.66ms    14.56
-run(Double_Filter_20_Nulls_20_next_5k_plain)                45.86ms    21.80
-run(Double_Filter_20_Nulls_20_next_10k_dict)                85.67ms    11.67
-run(Double_Filter_20_Nulls_20_next_10k_Plain)               43.48ms    23.00
-run(Double_Filter_20_Nulls_20_next_20k_dict)                50.89ms    19.65
-run(Double_Filter_20_Nulls_20_next_20k_plain)               45.35ms    22.05
-run(Double_Filter_20_Nulls_20_next_50k_dict)                65.92ms    15.17
-run(Double_Filter_20_Nulls_20_next_50k_plain)               52.20ms    19.16
-run(Double_Filter_20_Nulls_20_next_100k_dict)               54.88ms    18.22
-run(Double_Filter_20_Nulls_20_next_100k_plain)              44.52ms    22.46
-----------------------------------------------------------------------------
-run(Double_Filter_20_Nulls_50_next_5k_dict)                 50.85ms    19.67
-run(Double_Filter_20_Nulls_50_next_5k_plain)                27.56ms    36.29
-run(Double_Filter_20_Nulls_50_next_10k_dict)                40.32ms    24.80
-run(Double_Filter_20_Nulls_50_next_10k_Plain)               25.39ms    39.38
-run(Double_Filter_20_Nulls_50_next_20k_dict)                40.65ms    24.60
-run(Double_Filter_20_Nulls_50_next_20k_plain)               31.98ms    31.27
-run(Double_Filter_20_Nulls_50_next_50k_dict)                36.55ms    27.36
-run(Double_Filter_20_Nulls_50_next_50k_plain)               39.60ms    25.25
-run(Double_Filter_20_Nulls_50_next_100k_dict)               34.30ms    29.15
-run(Double_Filter_20_Nulls_50_next_100k_plain)              24.74ms    40.43
-----------------------------------------------------------------------------
-run(Double_Filter_20_Nulls_70_next_5k_dict)                 35.97ms    27.80
-run(Double_Filter_20_Nulls_70_next_5k_plain)                18.81ms    53.17
-run(Double_Filter_20_Nulls_70_next_10k_dict)                29.70ms    33.67
-run(Double_Filter_20_Nulls_70_next_10k_Plain)               21.07ms    47.47
-run(Double_Filter_20_Nulls_70_next_20k_dict)                26.30ms    38.02
-run(Double_Filter_20_Nulls_70_next_20k_plain)               17.80ms    56.17
-run(Double_Filter_20_Nulls_70_next_50k_dict)                29.23ms    34.21
-run(Double_Filter_20_Nulls_70_next_50k_plain)               19.76ms    50.61
-run(Double_Filter_20_Nulls_70_next_100k_dict)               27.26ms    36.68
-run(Double_Filter_20_Nulls_70_next_100k_plain)              19.21ms    52.06
-----------------------------------------------------------------------------
-run(Double_Filter_20_Nulls_100_next_5k_dict)                 1.19ms   838.33
-run(Double_Filter_20_Nulls_100_next_5k_plain)                1.08ms   923.65
-run(Double_Filter_20_Nulls_100_next_10k_dict)                1.15ms   867.52
-run(Double_Filter_20_Nulls_100_next_10k_Plain)               1.09ms   917.52
-run(Double_Filter_20_Nulls_100_next_20k_dict)                1.13ms   881.77
-run(Double_Filter_20_Nulls_100_next_20k_plain)               1.08ms   922.16
-run(Double_Filter_20_Nulls_100_next_50k_dict)                1.14ms   875.53
-run(Double_Filter_20_Nulls_100_next_50k_plain)               1.09ms   914.11
-run(Double_Filter_20_Nulls_100_next_100k_dict)               1.15ms   866.91
-run(Double_Filter_20_Nulls_100_next_100k_plain)              1.12ms   888.90
-----------------------------------------------------------------------------
-run(Double_Filter_50_Nulls_0_next_5k_dict)                  66.61ms    15.01
-run(Double_Filter_50_Nulls_0_next_5k_plain)                 87.16ms    11.47
-run(Double_Filter_50_Nulls_0_next_10k_dict)                 69.75ms    14.34
-run(Double_Filter_50_Nulls_0_next_10k_Plain)                61.24ms    16.33
-run(Double_Filter_50_Nulls_0_next_20k_dict)                 91.42ms    10.94
-run(Double_Filter_50_Nulls_0_next_20k_plain)                58.48ms    17.10
-run(Double_Filter_50_Nulls_0_next_50k_dict)                115.35ms     8.67
-run(Double_Filter_50_Nulls_0_next_50k_plain)                35.94ms    27.83
-run(Double_Filter_50_Nulls_0_next_100k_dict)               106.14ms     9.42
-run(Double_Filter_50_Nulls_0_next_100k_plain)               46.01ms    21.73
-----------------------------------------------------------------------------
-run(Double_Filter_50_Nulls_20_next_5k_dict)                 92.77ms    10.78
-run(Double_Filter_50_Nulls_20_next_5k_plain)                44.99ms    22.23
-run(Double_Filter_50_Nulls_20_next_10k_dict)               100.23ms     9.98
-run(Double_Filter_50_Nulls_20_next_10k_Plain)               23.82ms    41.99
-run(Double_Filter_50_Nulls_20_next_20k_dict)                79.26ms    12.62
-run(Double_Filter_50_Nulls_20_next_20k_plain)               42.55ms    23.50
-run(Double_Filter_50_Nulls_20_next_50k_dict)                86.56ms    11.55
-run(Double_Filter_50_Nulls_20_next_50k_plain)               33.30ms    30.03
-run(Double_Filter_50_Nulls_20_next_100k_dict)               82.79ms    12.08
-run(Double_Filter_50_Nulls_20_next_100k_plain)              40.66ms    24.60
-----------------------------------------------------------------------------
-run(Double_Filter_50_Nulls_50_next_5k_dict)                 58.81ms    17.00
-run(Double_Filter_50_Nulls_50_next_5k_plain)                23.38ms    42.76
-run(Double_Filter_50_Nulls_50_next_10k_dict)                44.38ms    22.53
-run(Double_Filter_50_Nulls_50_next_10k_Plain)               25.49ms    39.22
-run(Double_Filter_50_Nulls_50_next_20k_dict)                47.56ms    21.03
-run(Double_Filter_50_Nulls_50_next_20k_plain)               29.23ms    34.22
-run(Double_Filter_50_Nulls_50_next_50k_dict)                47.74ms    20.95
-run(Double_Filter_50_Nulls_50_next_50k_plain)               28.10ms    35.59
-run(Double_Filter_50_Nulls_50_next_100k_dict)               45.19ms    22.13
-run(Double_Filter_50_Nulls_50_next_100k_plain)              30.13ms    33.19
-----------------------------------------------------------------------------
-run(Double_Filter_50_Nulls_70_next_5k_dict)                 42.39ms    23.59
-run(Double_Filter_50_Nulls_70_next_5k_plain)                19.13ms    52.27
-run(Double_Filter_50_Nulls_70_next_10k_dict)                39.34ms    25.42
-run(Double_Filter_50_Nulls_70_next_10k_Plain)               19.04ms    52.52
-run(Double_Filter_50_Nulls_70_next_20k_dict)                31.11ms    32.15
-run(Double_Filter_50_Nulls_70_next_20k_plain)               19.06ms    52.47
-run(Double_Filter_50_Nulls_70_next_50k_dict)                32.22ms    31.03
-run(Double_Filter_50_Nulls_70_next_50k_plain)               17.79ms    56.20
-run(Double_Filter_50_Nulls_70_next_100k_dict)               29.08ms    34.39
-run(Double_Filter_50_Nulls_70_next_100k_plain)              18.06ms    55.36
-----------------------------------------------------------------------------
-run(Double_Filter_50_Nulls_100_next_5k_dict)                 1.19ms   838.37
-run(Double_Filter_50_Nulls_100_next_5k_plain)                1.11ms   900.88
-run(Double_Filter_50_Nulls_100_next_10k_dict)                1.15ms   871.34
-run(Double_Filter_50_Nulls_100_next_10k_Plain)               1.09ms   913.35
-run(Double_Filter_50_Nulls_100_next_20k_dict)                1.20ms   832.54
-run(Double_Filter_50_Nulls_100_next_20k_plain)               1.11ms   901.54
-run(Double_Filter_50_Nulls_100_next_50k_dict)                1.19ms   840.64
-run(Double_Filter_50_Nulls_100_next_50k_plain)               1.11ms   901.77
-run(Double_Filter_50_Nulls_100_next_100k_dict)               1.18ms   844.59
-run(Double_Filter_50_Nulls_100_next_100k_plain)              1.12ms   894.72
-----------------------------------------------------------------------------
-run(Double_Filter_70_Nulls_0_next_5k_dict)                  68.68ms    14.56
-run(Double_Filter_70_Nulls_0_next_5k_plain)                 52.46ms    19.06
-run(Double_Filter_70_Nulls_0_next_10k_dict)                104.38ms     9.58
-run(Double_Filter_70_Nulls_0_next_10k_Plain)                45.86ms    21.81
-run(Double_Filter_70_Nulls_0_next_20k_dict)                 92.56ms    10.80
-run(Double_Filter_70_Nulls_0_next_20k_plain)                60.98ms    16.40
-run(Double_Filter_70_Nulls_0_next_50k_dict)                126.62ms     7.90
-run(Double_Filter_70_Nulls_0_next_50k_plain)                36.57ms    27.35
-run(Double_Filter_70_Nulls_0_next_100k_dict)               106.28ms     9.41
-run(Double_Filter_70_Nulls_0_next_100k_plain)               43.34ms    23.07
-----------------------------------------------------------------------------
-run(Double_Filter_70_Nulls_20_next_5k_dict)                 78.40ms    12.75
-run(Double_Filter_70_Nulls_20_next_5k_plain)                26.06ms    38.37
-run(Double_Filter_70_Nulls_20_next_10k_dict)                73.75ms    13.56
-run(Double_Filter_70_Nulls_20_next_10k_Plain)               49.60ms    20.16
-run(Double_Filter_70_Nulls_20_next_20k_dict)                76.06ms    13.15
-run(Double_Filter_70_Nulls_20_next_20k_plain)               50.12ms    19.95
-run(Double_Filter_70_Nulls_20_next_50k_dict)                75.28ms    13.28
-run(Double_Filter_70_Nulls_20_next_50k_plain)               72.46ms    13.80
-run(Double_Filter_70_Nulls_20_next_100k_dict)              111.26ms     8.99
-run(Double_Filter_70_Nulls_20_next_100k_plain)             112.18ms     8.91
-----------------------------------------------------------------------------
-run(Double_Filter_70_Nulls_50_next_5k_dict)                 54.95ms    18.20
-run(Double_Filter_70_Nulls_50_next_5k_plain)                32.73ms    30.56
-run(Double_Filter_70_Nulls_50_next_10k_dict)                46.12ms    21.68
-run(Double_Filter_70_Nulls_50_next_10k_Plain)               32.05ms    31.20
-run(Double_Filter_70_Nulls_50_next_20k_dict)                41.23ms    24.26
-run(Double_Filter_70_Nulls_50_next_20k_plain)               18.43ms    54.26
-run(Double_Filter_70_Nulls_50_next_50k_dict)                43.51ms    22.99
-run(Double_Filter_70_Nulls_50_next_50k_plain)               28.03ms    35.68
-run(Double_Filter_70_Nulls_50_next_100k_dict)               48.58ms    20.59
-run(Double_Filter_70_Nulls_50_next_100k_plain)              27.13ms    36.86
-----------------------------------------------------------------------------
-run(Double_Filter_70_Nulls_70_next_5k_dict)                 36.94ms    27.07
-run(Double_Filter_70_Nulls_70_next_5k_plain)                21.51ms    46.48
-run(Double_Filter_70_Nulls_70_next_10k_dict)                30.33ms    32.97
-run(Double_Filter_70_Nulls_70_next_10k_Plain)               19.03ms    52.55
-run(Double_Filter_70_Nulls_70_next_20k_dict)                29.70ms    33.68
-run(Double_Filter_70_Nulls_70_next_20k_plain)               44.39ms    22.53
-run(Double_Filter_70_Nulls_70_next_50k_dict)                29.47ms    33.93
-run(Double_Filter_70_Nulls_70_next_50k_plain)               19.93ms    50.18
-run(Double_Filter_70_Nulls_70_next_100k_dict)               30.55ms    32.73
-run(Double_Filter_70_Nulls_70_next_100k_plain)              78.45ms    12.75
-----------------------------------------------------------------------------
-run(Double_Filter_70_Nulls_100_next_5k_dict)                 1.22ms   821.69
-run(Double_Filter_70_Nulls_100_next_5k_plain)                1.08ms   922.01
-run(Double_Filter_70_Nulls_100_next_10k_dict)                1.13ms   886.77
-run(Double_Filter_70_Nulls_100_next_10k_Plain)               1.10ms   906.80
-run(Double_Filter_70_Nulls_100_next_20k_dict)                1.25ms   801.04
-run(Double_Filter_70_Nulls_100_next_20k_plain)               1.08ms   922.37
-run(Double_Filter_70_Nulls_100_next_50k_dict)                1.13ms   881.13
-run(Double_Filter_70_Nulls_100_next_50k_plain)               1.08ms   926.57
-run(Double_Filter_70_Nulls_100_next_100k_dict)               1.16ms   859.24
-run(Double_Filter_70_Nulls_100_next_100k_plain)              1.10ms   908.55
-----------------------------------------------------------------------------
-run(Double_Filter_100_Nulls_0_next_5k_dict)                 60.38ms    16.56
-run(Double_Filter_100_Nulls_0_next_5k_plain)                77.51ms    12.90
-run(Double_Filter_100_Nulls_0_next_10k_dict)                64.41ms    15.53
-run(Double_Filter_100_Nulls_0_next_10k_Plain)               48.80ms    20.49
-run(Double_Filter_100_Nulls_0_next_20k_dict)                77.02ms    12.98
-run(Double_Filter_100_Nulls_0_next_20k_plain)               62.04ms    16.12
-run(Double_Filter_100_Nulls_0_next_50k_dict)                70.91ms    14.10
-run(Double_Filter_100_Nulls_0_next_50k_plain)               60.01ms    16.66
-run(Double_Filter_100_Nulls_0_next_100k_dict)               79.32ms    12.61
-run(Double_Filter_100_Nulls_0_next_100k_plain)              57.80ms    17.30
-----------------------------------------------------------------------------
-run(Double_Filter_100_Nulls_20_next_5k_dict)                69.99ms    14.29
-run(Double_Filter_100_Nulls_20_next_5k_plain)               44.72ms    22.36
-run(Double_Filter_100_Nulls_20_next_10k_dict)               63.70ms    15.70
-run(Double_Filter_100_Nulls_20_next_10k_Plain)              45.46ms    22.00
-run(Double_Filter_100_Nulls_20_next_20k_dict)               63.55ms    15.73
-run(Double_Filter_100_Nulls_20_next_20k_plain)              44.95ms    22.25
-run(Double_Filter_100_Nulls_20_next_50k_dict)               74.41ms    13.44
-run(Double_Filter_100_Nulls_20_next_50k_plain)              33.79ms    29.60
-run(Double_Filter_100_Nulls_20_next_100k_dict)              73.03ms    13.69
-run(Double_Filter_100_Nulls_20_next_100k_plain)             36.55ms    27.36
-----------------------------------------------------------------------------
-run(Double_Filter_100_Nulls_50_next_5k_dict)                47.57ms    21.02
-run(Double_Filter_100_Nulls_50_next_5k_plain)               30.64ms    32.63
-run(Double_Filter_100_Nulls_50_next_10k_dict)               46.46ms    21.53
-run(Double_Filter_100_Nulls_50_next_10k_Plain)              28.97ms    34.52
-run(Double_Filter_100_Nulls_50_next_20k_dict)               36.57ms    27.35
-run(Double_Filter_100_Nulls_50_next_20k_plain)              30.93ms    32.33
-run(Double_Filter_100_Nulls_50_next_50k_dict)               39.82ms    25.11
-run(Double_Filter_100_Nulls_50_next_50k_plain)              26.45ms    37.81
-run(Double_Filter_100_Nulls_50_next_100k_dict)              38.63ms    25.89
-run(Double_Filter_100_Nulls_50_next_100k_plain)             26.30ms    38.03
-----------------------------------------------------------------------------
-run(Double_Filter_100_Nulls_70_next_5k_dict)                35.46ms    28.20
-run(Double_Filter_100_Nulls_70_next_5k_plain)               16.41ms    60.94
-run(Double_Filter_100_Nulls_70_next_10k_dict)               26.78ms    37.34
-run(Double_Filter_100_Nulls_70_next_10k_Plain)              23.31ms    42.90
-run(Double_Filter_100_Nulls_70_next_20k_dict)               68.08ms    14.69
-run(Double_Filter_100_Nulls_70_next_20k_plain)              19.56ms    51.12
-run(Double_Filter_100_Nulls_70_next_50k_dict)               26.04ms    38.41
-run(Double_Filter_100_Nulls_70_next_50k_plain)              19.09ms    52.37
-run(Double_Filter_100_Nulls_70_next_100k_dict)              26.38ms    37.91
-run(Double_Filter_100_Nulls_70_next_100k_plain)             19.99ms    50.03
-----------------------------------------------------------------------------
-run(Double_Filter_100_Nulls_100_next_5k_dict)                1.23ms   812.53
-run(Double_Filter_100_Nulls_100_next_5k_plain)               1.16ms   865.38
-run(Double_Filter_100_Nulls_100_next_10k_dict)               1.22ms   818.96
-run(Double_Filter_100_Nulls_100_next_10k_Plain)              1.12ms   890.70
-run(Double_Filter_100_Nulls_100_next_20k_dict)               1.18ms   850.97
-run(Double_Filter_100_Nulls_100_next_20k_plain)              1.11ms   903.99
-run(Double_Filter_100_Nulls_100_next_50k_dict)               1.17ms   852.25
-run(Double_Filter_100_Nulls_100_next_50k_plain)              1.08ms   926.62
-run(Double_Filter_100_Nulls_100_next_100k_dict)              1.21ms   823.54
-run(Double_Filter_100_Nulls_100_next_100k_plain              1.07ms   931.79
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
-run(Map_Filter_100_Nulls_0_next_5k_dict)                   512.01ms     1.95
-run(Map_Filter_100_Nulls_0_next_5k_plain)                  519.26ms     1.93
-run(Map_Filter_100_Nulls_0_next_10k_dict)                  491.47ms     2.03
-run(Map_Filter_100_Nulls_0_next_10k_Plain)                 477.31ms     2.10
-run(Map_Filter_100_Nulls_0_next_20k_dict)                  483.19ms     2.07
-run(Map_Filter_100_Nulls_0_next_20k_plain)                 492.69ms     2.03
-run(Map_Filter_100_Nulls_0_next_50k_dict)                  503.63ms     1.99
-run(Map_Filter_100_Nulls_0_next_50k_plain)                 458.13ms     2.18
-run(Map_Filter_100_Nulls_0_next_100k_dict)                 526.96ms     1.90
-run(Map_Filter_100_Nulls_0_next_100k_plain)                484.31ms     2.06
-----------------------------------------------------------------------------
-run(Map_Filter_100_Nulls_20_next_5k_dict)                  485.14ms     2.06
-run(Map_Filter_100_Nulls_20_next_5k_plain)                 523.81ms     1.91
-run(Map_Filter_100_Nulls_20_next_10k_dict)                 487.79ms     2.05
-run(Map_Filter_100_Nulls_20_next_10k_Plain)                501.78ms     1.99
-run(Map_Filter_100_Nulls_20_next_20k_dict)                 480.07ms     2.08
-run(Map_Filter_100_Nulls_20_next_20k_plain)                500.53ms     2.00
-run(Map_Filter_100_Nulls_20_next_50k_dict)                 496.29ms     2.01
-run(Map_Filter_100_Nulls_20_next_50k_plain)                449.78ms     2.22
-run(Map_Filter_100_Nulls_20_next_100k_dict)                479.64ms     2.08
-run(Map_Filter_100_Nulls_20_next_100k_plain)               451.55ms     2.21
-----------------------------------------------------------------------------
-run(Map_Filter_100_Nulls_50_next_5k_dict)                  377.07ms     2.65
-run(Map_Filter_100_Nulls_50_next_5k_plain)                 344.94ms     2.90
-run(Map_Filter_100_Nulls_50_next_10k_dict)                 380.58ms     2.63
-run(Map_Filter_100_Nulls_50_next_10k_Plain)                334.15ms     2.99
-run(Map_Filter_100_Nulls_50_next_20k_dict)                 397.08ms     2.52
-run(Map_Filter_100_Nulls_50_next_20k_plain)                318.45ms     3.14
-run(Map_Filter_100_Nulls_50_next_50k_dict)                 420.00ms     2.38
-run(Map_Filter_100_Nulls_50_next_50k_plain)                328.35ms     3.05
-run(Map_Filter_100_Nulls_50_next_100k_dict)                380.53ms     2.63
-run(Map_Filter_100_Nulls_50_next_100k_plain)               335.41ms     2.98
-----------------------------------------------------------------------------
-run(Map_Filter_100_Nulls_70_next_5k_dict)                  269.50ms     3.71
-run(Map_Filter_100_Nulls_70_next_5k_plain)                 251.71ms     3.97
-run(Map_Filter_100_Nulls_70_next_10k_dict)                 245.63ms     4.07
-run(Map_Filter_100_Nulls_70_next_10k_Plain)                237.48ms     4.21
-run(Map_Filter_100_Nulls_70_next_20k_dict)                 242.31ms     4.13
-run(Map_Filter_100_Nulls_70_next_20k_plain)                244.02ms     4.10
-run(Map_Filter_100_Nulls_70_next_50k_dict)                 262.59ms     3.81
-run(Map_Filter_100_Nulls_70_next_50k_plain)                230.39ms     4.34
-run(Map_Filter_100_Nulls_70_next_100k_dict)                257.85ms     3.88
-run(Map_Filter_100_Nulls_70_next_100k_plain)               231.06ms     4.33
-----------------------------------------------------------------------------
-run(Map_Filter_100_Nulls_100_next_5k_dict)                  52.11ms    19.19
-run(Map_Filter_100_Nulls_100_next_5k_plain)                 50.11ms    19.95
-run(Map_Filter_100_Nulls_100_next_10k_dict)                 49.96ms    20.02
-run(Map_Filter_100_Nulls_100_next_10k_Plain)                50.56ms    19.78
-run(Map_Filter_100_Nulls_100_next_20k_dict)                 50.12ms    19.95
-run(Map_Filter_100_Nulls_100_next_20k_plain)                50.14ms    19.95
-run(Map_Filter_100_Nulls_100_next_50k_dict)                 50.40ms    19.84
-run(Map_Filter_100_Nulls_100_next_50k_plain)                50.28ms    19.89
-run(Map_Filter_100_Nulls_100_next_100k_dict)                50.64ms    19.75
-run(Map_Filter_100_Nulls_100_next_100k_plain)               50.84ms    19.67
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
-run(List_Filter_100_Nulls_0_next_5k_dict)                  510.33ms     1.96
-run(List_Filter_100_Nulls_0_next_5k_plain)                 470.09ms     2.13
-run(List_Filter_100_Nulls_0_next_10k_dict)                 635.49ms     1.57
-run(List_Filter_100_Nulls_0_next_10k_Plain)                479.80ms     2.08
-run(List_Filter_100_Nulls_0_next_20k_dict)                 583.73ms     1.71
-run(List_Filter_100_Nulls_0_next_20k_plain)                494.83ms     2.02
-run(List_Filter_100_Nulls_0_next_50k_dict)                 578.41ms     1.73
-run(List_Filter_100_Nulls_0_next_50k_plain)                480.41ms     2.08
-run(List_Filter_100_Nulls_0_next_100k_dict)                515.73ms     1.94
-run(List_Filter_100_Nulls_0_next_100k_plain)               492.10ms     2.03
-----------------------------------------------------------------------------
-run(List_Filter_100_Nulls_20_next_5k_dict)                 527.48ms     1.90
-run(List_Filter_100_Nulls_20_next_5k_plain)                448.50ms     2.23
-run(List_Filter_100_Nulls_20_next_10k_dict)                527.30ms     1.90
-run(List_Filter_100_Nulls_20_next_10k_Plain)               450.71ms     2.22
-run(List_Filter_100_Nulls_20_next_20k_dict)                513.22ms     1.95
-run(List_Filter_100_Nulls_20_next_20k_plain)               475.91ms     2.10
-run(List_Filter_100_Nulls_20_next_50k_dict)                509.59ms     1.96
-run(List_Filter_100_Nulls_20_next_50k_plain)               487.91ms     2.05
-run(List_Filter_100_Nulls_20_next_100k_dict)               551.87ms     1.81
-run(List_Filter_100_Nulls_20_next_100k_plain)              444.48ms     2.25
-----------------------------------------------------------------------------
-run(List_Filter_100_Nulls_50_next_5k_dict)                 398.44ms     2.51
-run(List_Filter_100_Nulls_50_next_5k_plain)                351.05ms     2.85
-run(List_Filter_100_Nulls_50_next_10k_dict)                358.92ms     2.79
-run(List_Filter_100_Nulls_50_next_10k_Plain)               361.92ms     2.76
-run(List_Filter_100_Nulls_50_next_20k_dict)                365.71ms     2.73
-run(List_Filter_100_Nulls_50_next_20k_plain)               379.67ms     2.63
-run(List_Filter_100_Nulls_50_next_50k_dict)                386.53ms     2.59
-run(List_Filter_100_Nulls_50_next_50k_plain)               333.08ms     3.00
-run(List_Filter_100_Nulls_50_next_100k_dict)               391.00ms     2.56
-run(List_Filter_100_Nulls_50_next_100k_plain)              314.15ms     3.18
-----------------------------------------------------------------------------
-run(List_Filter_100_Nulls_70_next_5k_dict)                 269.02ms     3.72
-run(List_Filter_100_Nulls_70_next_5k_plain)                237.83ms     4.20
-run(List_Filter_100_Nulls_70_next_10k_dict)                240.33ms     4.16
-run(List_Filter_100_Nulls_70_next_10k_Plain)               242.11ms     4.13
-run(List_Filter_100_Nulls_70_next_20k_dict)                243.19ms     4.11
-run(List_Filter_100_Nulls_70_next_20k_plain)               262.23ms     3.81
-run(List_Filter_100_Nulls_70_next_50k_dict)                241.58ms     4.14
-run(List_Filter_100_Nulls_70_next_50k_plain)               237.81ms     4.21
-run(List_Filter_100_Nulls_70_next_100k_dict)               262.14ms     3.81
-run(List_Filter_100_Nulls_70_next_100k_plain)              238.90ms     4.19
-----------------------------------------------------------------------------
-run(List_Filter_100_Nulls_100_next_5k_dict)                 49.10ms    20.37
-run(List_Filter_100_Nulls_100_next_5k_plain)                49.41ms    20.24
-run(List_Filter_100_Nulls_100_next_10k_dict)                49.93ms    20.03
-run(List_Filter_100_Nulls_100_next_10k_Plain)               49.90ms    20.04
-run(List_Filter_100_Nulls_100_next_20k_dict)                49.38ms    20.25
-run(List_Filter_100_Nulls_100_next_20k_plain)               48.86ms    20.47
-run(List_Filter_100_Nulls_100_next_50k_dict)                48.91ms    20.45
-run(List_Filter_100_Nulls_100_next_50k_plain)               49.07ms    20.38
-run(List_Filter_100_Nulls_100_next_100k_dict)               49.25ms    20.31
-run(List_Filter_100_Nulls_100_next_100k_plain)              48.90ms    20.45
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
-*/
+} // namespace facebook::velox::parquet::test
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h
new file mode 100644
index 0000000000000..07f2913a89f59
--- /dev/null
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/dwio/common/FileSink.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/dwio/common/tests/utils/DataSetBuilder.h"
+#include "velox/dwio/parquet/RegisterParquetReader.h"
+#include "velox/dwio/parquet/reader/ParquetReader.h"
+#include "velox/dwio/parquet/writer/Writer.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+namespace facebook::velox::parquet::test {
+
+constexpr uint32_t kNumRowsPerBatch = 60000;
+constexpr uint32_t kNumBatches = 50;
+constexpr uint32_t kNumRowsPerRowGroup = 10000;
+constexpr double kFilterErrorMargin = 0.2;
+
+class ParquetReaderBenchmark {
+ public:
+  explicit ParquetReaderBenchmark(
+      bool disableDictionary,
+      const facebook::velox::RowTypePtr& rowType)
+      : disableDictionary_(disableDictionary) {
+    rootPool_ = facebook::velox::memory::memoryManager()->addRootPool(
+        "ParquetReaderBenchmark");
+    leafPool_ = rootPool_->addLeafChild("ParquetReaderBenchmark");
+    dataSetBuilder_ =
+        std::make_unique<facebook::velox::test::DataSetBuilder>(*leafPool_, 0);
+    auto path = fileFolder_->getPath() + "/" + fileName_;
+    auto localWriteFile =
+        std::make_unique<facebook::velox::LocalWriteFile>(path, true, false);
+    auto sink = std::make_unique<facebook::velox::dwio::common::WriteFileSink>(
+        std::move(localWriteFile), path);
+    facebook::velox::parquet::WriterOptions options;
+    if (disableDictionary_) {
+      // The parquet file is in plain encoding format.
+      options.enableDictionary = false;
+    }
+    options.memoryPool = rootPool_.get();
+    writer_ = std::make_unique<facebook::velox::parquet::Writer>(
+        std::move(sink), options, rowType);
+  }
+
+  ~ParquetReaderBenchmark() {}
+
+  void writeToFile(
+      const std::vector<facebook::velox::RowVectorPtr>& batches,
+      bool /*forRowGroupSkip*/);
+
+  facebook::velox::dwio::common::FilterSpec createFilterSpec(
+      const std::string& columnName,
+      float startPct,
+      float selectPct,
+      const facebook::velox::TypePtr& type,
+      bool isForRowGroupSkip,
+      bool allowNulls);
+
+  std::shared_ptr<facebook::velox::dwio::common::ScanSpec> createScanSpec(
+      const std::vector<facebook::velox::RowVectorPtr>& batches,
+      facebook::velox::RowTypePtr& rowType,
+      const std::vector<facebook::velox::dwio::common::FilterSpec>& filterSpecs,
+      std::vector<uint64_t>& hitRows);
+
+  std::unique_ptr<facebook::velox::dwio::common::RowReader> createReader(
+      std::shared_ptr<facebook::velox::dwio::common::ScanSpec> scanSpec,
+      const facebook::velox::RowTypePtr& rowType);
+
+  // This method is the place where we do the read opeartions.
+  // scanSpec contains the setting of filters. e.g.
+  // filterRateX100 = 30 means it would filter out 70% of rows and 30% remain.
+  // nullsRateX100 = 70 means it would filter out 70% of rows and 30% remain.
+  // Return the number of rows after the filter and null-filter.
+  int read(
+      const facebook::velox::RowTypePtr& rowType,
+      std::shared_ptr<facebook::velox::dwio::common::ScanSpec> scanSpec,
+      uint32_t nextSize);
+
+  void readSingleColumn(
+      const std::string& columnName,
+      const facebook::velox::TypePtr& type,
+      float startPct,
+      float selectPct,
+      uint8_t nullsRateX100,
+      uint32_t nextSize);
+
+ private:
+  const std::string fileName_ = "test.parquet";
+  const std::shared_ptr<facebook::velox::exec::test::TempDirectoryPath>
+      fileFolder_ = facebook::velox::exec::test::TempDirectoryPath::create();
+  const bool disableDictionary_;
+
+  std::unique_ptr<facebook::velox::test::DataSetBuilder> dataSetBuilder_;
+  std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool_;
+  std::shared_ptr<facebook::velox::memory::MemoryPool> leafPool_;
+  std::unique_ptr<facebook::velox::parquet::Writer> writer_;
+  facebook::velox::dwio::common::RuntimeStatistics runtimeStats_;
+};
+
+void run(
+    uint32_t,
+    const std::string& columnName,
+    const facebook::velox::TypePtr& type,
+    float filterRateX100,
+    uint8_t nullsRateX100,
+    uint32_t nextSize,
+    bool disableDictionary);
+
+} // namespace facebook::velox::parquet::test
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmarkMain.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmarkMain.cpp
new file mode 100644
index 0000000000000..dd1a3bbb162b2
--- /dev/null
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmarkMain.cpp
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::dwio;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::parquet;
+using namespace facebook::velox::parquet::test;
+using namespace facebook::velox::test;
+
+#define PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, _null_) \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_5k_dict,         \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      5000,                                                               \
+      false);                                                             \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_5k_plain,        \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      5000,                                                               \
+      true);                                                              \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_10k_dict,        \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      10000,                                                              \
+      false);                                                             \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_10k_Plain,       \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      10000,                                                              \
+      true);                                                              \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_20k_dict,        \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      20000,                                                              \
+      false);                                                             \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_20k_plain,       \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      20000,                                                              \
+      true);                                                              \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_50k_dict,        \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      50000,                                                              \
+      false);                                                             \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_50k_plain,       \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      50000,                                                              \
+      true);                                                              \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_100k_dict,       \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      100000,                                                             \
+      false);                                                             \
+  BENCHMARK_NAMED_PARAM(                                                  \
+      run,                                                                \
+      _name_##_Filter_##_filter_##_Nulls_##_null_##_next_100k_plain,      \
+      #_name_,                                                            \
+      _type_,                                                             \
+      _filter_,                                                           \
+      _null_,                                                             \
+      100000,                                                             \
+      true);                                                              \
+  BENCHMARK_DRAW_LINE();
+
+#define PARQUET_BENCHMARKS_FILTERS(_type_, _name_, _filter_)    \
+  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 0)  \
+  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 20) \
+  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 50) \
+  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 70) \
+  PARQUET_BENCHMARKS_FILTER_NULLS(_type_, _name_, _filter_, 100)
+
+#define PARQUET_BENCHMARKS(_type_, _name_)        \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 0)   \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 20)  \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 50)  \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 70)  \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 100) \
+  BENCHMARK_DRAW_LINE();
+
+#define PARQUET_BENCHMARKS_NO_FILTER(_type_, _name_) \
+  PARQUET_BENCHMARKS_FILTERS(_type_, _name_, 100)    \
+  BENCHMARK_DRAW_LINE();
+
+PARQUET_BENCHMARKS(DECIMAL(18, 3), ShortDecimalType);
+PARQUET_BENCHMARKS(DECIMAL(38, 3), LongDecimalType);
+PARQUET_BENCHMARKS(VARCHAR(), Varchar);
+
+PARQUET_BENCHMARKS(BIGINT(), BigInt);
+PARQUET_BENCHMARKS(DOUBLE(), Double);
+PARQUET_BENCHMARKS_NO_FILTER(MAP(BIGINT(), BIGINT()), Map);
+PARQUET_BENCHMARKS_NO_FILTER(ARRAY(BIGINT()), List);
+
+// TODO: Add all data types
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderBenchmarkTest.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmarkTest.cpp
new file mode 100644
index 0000000000000..890ce37b96433
--- /dev/null
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderBenchmarkTest.cpp
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/dwio/parquet/tests/reader/ParquetReaderBenchmark.h"
+#include <gtest/gtest.h>
+
+namespace facebook::velox::parquet::test {
+namespace {
+TEST(ParquetReaderBenchmarkTest, basic) {
+  memory::MemoryManager::testingSetInstance({});
+  run(1, "BigInt", BIGINT(), 20, 0, 500, false);
+  run(2, "ShortDecimal", DECIMAL(18, 3), 0, 20, 500, false);
+  run(3, "LongDecimal", DECIMAL(38, 3), 10, 5, 500, false);
+  run(4, "Double", DOUBLE(), 5, 10, 500, false);
+  run(5, "Varchar", VARCHAR(), 0, 0, 500, false);
+  run(6, "Map", MAP(BIGINT(), BIGINT()), 100, 20, 500, false);
+  run(7, "Array", ARRAY(BIGINT()), 100, 0, 500, false);
+}
+} // namespace
+} // namespace facebook::velox::parquet::test
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
index eba62445f2460..a774f83a0609b 100644
--- a/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
@@ -14,29 +14,40 @@
  * limitations under the License.
  */
 
-#include "velox/dwio/parquet/reader/ParquetReader.h"
-#include "velox/dwio/parquet/tests/ParquetReaderTestBase.h"
+#include "velox/dwio/parquet/tests/ParquetTestBase.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::common;
 using namespace facebook::velox::dwio::common;
-using namespace facebook::velox::dwio::parquet;
 using namespace facebook::velox::parquet;
 
-namespace {
-auto defaultPool = memory::addDefaultLeafMemoryPool();
-}
-
-class ParquetReaderTest : public ParquetReaderTestBase {
+class ParquetReaderTest : public ParquetTestBase {
  public:
-  ParquetReader createReader(
-      const std::string& path,
-      const facebook::velox::dwio::common::ReaderOptions& opts) {
-    return ParquetReader(
-        std::make_unique<BufferedInput>(
-            std::make_shared<LocalReadFile>(path), opts.getMemoryPool()),
-        opts);
+  std::unique_ptr<dwio::common::RowReader> createRowReader(
+      const std::string& fileName,
+      const RowTypePtr& rowType) {
+    const std::string sample(getExampleFilePath(fileName));
+
+    dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+    auto reader = createReader(sample, readerOptions);
+
+    RowReaderOptions rowReaderOpts;
+    rowReaderOpts.select(
+        std::make_shared<facebook::velox::dwio::common::ColumnSelector>(
+            rowType, rowType->names()));
+    rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    return rowReader;
+  }
+
+  void assertReadWithExpected(
+      const std::string& fileName,
+      const RowTypePtr& rowType,
+      const RowVectorPtr& expected) {
+    auto rowReader = createRowReader(fileName, rowType);
+    assertReadWithReaderAndExpected(rowType, *rowReader, expected, *pool_);
   }
 
   void assertReadWithFilters(
@@ -45,14 +56,10 @@ class ParquetReaderTest : public ParquetReaderTestBase {
       FilterMap filters,
       const RowVectorPtr& expected) {
     const auto filePath(getExampleFilePath(fileName));
-    facebook::velox::dwio::common::ReaderOptions readerOpts{defaultPool.get()};
+    dwio::common::ReaderOptions readerOpts{leafPool_.get()};
     auto reader = createReader(filePath, readerOpts);
     assertReadWithReaderAndFilters(
-        std::make_unique<ParquetReader>(reader),
-        fileName,
-        fileSchema,
-        std::move(filters),
-        expected);
+        std::move(reader), fileName, fileSchema, std::move(filters), expected);
   }
 };
 
@@ -64,11 +71,11 @@ TEST_F(ParquetReaderTest, parseSample) {
   //   b: [1.0..20.0]
   const std::string sample(getExampleFilePath("sample.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
-  ParquetReader reader = createReader(sample, readerOptions);
-  EXPECT_EQ(reader.numberOfRows(), 20ULL);
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 20ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 2ULL);
   auto col0 = type->childAt(0);
   EXPECT_EQ(col0->type()->kind(), TypeKind::BIGINT);
@@ -80,55 +87,212 @@ TEST_F(ParquetReaderTest, parseSample) {
   auto rowReaderOpts = getReaderOpts(sampleSchema());
   auto scanSpec = makeScanSpec(sampleSchema());
   rowReaderOpts.setScanSpec(scanSpec);
-  auto rowReader = reader.createRowReader(rowReaderOpts);
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(20, 1), rangeVector<double>(20, 1)});
-  assertReadExpected(sampleSchema(), *rowReader, expected, *pool_);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(20, [](auto row) { return row + 1; }),
+      makeFlatVector<double>(20, [](auto row) { return row + 1; }),
+  });
+
+  assertReadWithReaderAndExpected(
+      sampleSchema(), *rowReader, expected, *leafPool_);
+}
+
+TEST_F(ParquetReaderTest, parseUnannotatedList) {
+  // unannotated_list.parquet has the following the schema
+  // the list is defined without the middle layer
+  // message ParquetSchema {
+  //   optional group self (LIST) {
+  //     repeated group self_tuple {
+  //       optional int64 a;
+  //       optional boolean b;
+  //       required binary c (STRING);
+  //     }
+  //   }
+  // }
+  const std::string sample(getExampleFilePath("unannotated_list.parquet"));
+
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  auto reader = createReader(sample, readerOpts);
+
+  EXPECT_EQ(reader->numberOfRows(), 22ULL);
+
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 1ULL);
+  auto col0 = type->childAt(0);
+  EXPECT_EQ(col0->type()->kind(), TypeKind::ARRAY);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(col0)->name_, "self");
+
+  EXPECT_EQ(col0->size(), 1ULL);
+  EXPECT_EQ(col0->childAt(0)->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(col0->childAt(0))
+          ->name_,
+      "dummy");
+
+  EXPECT_EQ(col0->childAt(0)->childAt(0)->type()->kind(), TypeKind::BIGINT);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(
+          col0->childAt(0)->childAt(0))
+          ->name_,
+      "a");
+
+  EXPECT_EQ(col0->childAt(0)->childAt(1)->type()->kind(), TypeKind::BOOLEAN);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(
+          col0->childAt(0)->childAt(1))
+          ->name_,
+      "b");
+
+  EXPECT_EQ(col0->childAt(0)->childAt(2)->type()->kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(
+          col0->childAt(0)->childAt(2))
+          ->name_,
+      "c");
+}
+
+TEST_F(ParquetReaderTest, parseUnannotatedMap) {
+  // unannotated_map.parquet has the following the schema
+  // the map is defined with a MAP_KEY_VALUE node
+  // message hive_schema {
+  // optional group test (MAP) {
+  //   repeated group key_value (MAP_KEY_VALUE) {
+  //       required binary key (STRING);
+  //       optional int64 value;
+  //   }
+  //  }
+  //}
+  const std::string filename("unnotated_map.parquet");
+  const std::string sample(getExampleFilePath(filename));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 1ULL);
+  auto col0 = type->childAt(0);
+  EXPECT_EQ(col0->type()->kind(), TypeKind::MAP);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(col0)->name_, "test");
+
+  EXPECT_EQ(col0->size(), 2ULL);
+  EXPECT_EQ(col0->childAt(0)->type()->kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(col0->childAt(0))
+          ->name_,
+      "key");
+
+  EXPECT_EQ(col0->childAt(1)->type()->kind(), TypeKind::BIGINT);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(col0->childAt(1))
+          ->name_,
+      "value");
+}
+
+TEST_F(ParquetReaderTest, parseLegacyListWithMultipleChildren) {
+  // listmultiplechildren.parquet has the following the schema
+  // message hive_schema {
+  //  optional group test (LIST) {
+  //    repeated group array {
+  //      optional int64 a;
+  //      optional boolean b;
+  //      optional binary c (STRING);
+  //    }
+  //  }
+  // }
+  // Namely, node 'array' has >1 child
+  const std::string filename("listmultiplechildren.parquet");
+  const std::string sample(getExampleFilePath(filename));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 1ULL);
+  auto col0 = type->childAt(0);
+  EXPECT_EQ(col0->type()->kind(), TypeKind::ARRAY);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(col0)->name_, "test");
+
+  EXPECT_EQ(col0->size(), 1ULL);
+  EXPECT_EQ(col0->childAt(0)->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(col0->childAt(0))
+          ->name_,
+      "dummy");
+
+  EXPECT_EQ(col0->childAt(0)->childAt(0)->type()->kind(), TypeKind::BIGINT);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(
+          col0->childAt(0)->childAt(0))
+          ->name_,
+      "a");
+
+  EXPECT_EQ(col0->childAt(0)->childAt(1)->type()->kind(), TypeKind::BOOLEAN);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(
+          col0->childAt(0)->childAt(1))
+          ->name_,
+      "b");
+
+  EXPECT_EQ(col0->childAt(0)->childAt(2)->type()->kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(
+      std::static_pointer_cast<const ParquetTypeWithId>(
+          col0->childAt(0)->childAt(2))
+          ->name_,
+      "c");
 }
 
 TEST_F(ParquetReaderTest, parseSampleRange1) {
   const std::string sample(getExampleFilePath("sample.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-  ParquetReader reader = createReader(sample, readerOpts);
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  auto reader = createReader(sample, readerOpts);
 
   auto rowReaderOpts = getReaderOpts(sampleSchema());
   auto scanSpec = makeScanSpec(sampleSchema());
   rowReaderOpts.setScanSpec(scanSpec);
   rowReaderOpts.range(0, 200);
-  auto rowReader = reader.createRowReader(rowReaderOpts);
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(10, 1), rangeVector<double>(10, 1)});
-  assertReadExpected(sampleSchema(), *rowReader, expected, *pool_);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(10, [](auto row) { return row + 1; }),
+      makeFlatVector<double>(10, [](auto row) { return row + 1; }),
+  });
+  assertReadWithReaderAndExpected(
+      sampleSchema(), *rowReader, expected, *leafPool_);
 }
 
 TEST_F(ParquetReaderTest, parseSampleRange2) {
   const std::string sample(getExampleFilePath("sample.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-  ParquetReader reader = createReader(sample, readerOpts);
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  auto reader = createReader(sample, readerOpts);
 
   auto rowReaderOpts = getReaderOpts(sampleSchema());
   auto scanSpec = makeScanSpec(sampleSchema());
   rowReaderOpts.setScanSpec(scanSpec);
   rowReaderOpts.range(200, 500);
-  auto rowReader = reader.createRowReader(rowReaderOpts);
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(10, 11), rangeVector<double>(10, 11)});
-  assertReadExpected(sampleSchema(), *rowReader, expected, *pool_);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(10, [](auto row) { return row + 11; }),
+      makeFlatVector<double>(10, [](auto row) { return row + 11; }),
+  });
+  assertReadWithReaderAndExpected(
+      sampleSchema(), *rowReader, expected, *leafPool_);
 }
 
 TEST_F(ParquetReaderTest, parseSampleEmptyRange) {
   const std::string sample(getExampleFilePath("sample.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-  ParquetReader reader = createReader(sample, readerOpts);
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  auto reader = createReader(sample, readerOpts);
 
   auto rowReaderOpts = getReaderOpts(sampleSchema());
   auto scanSpec = makeScanSpec(sampleSchema());
   rowReaderOpts.setScanSpec(scanSpec);
   rowReaderOpts.range(300, 10);
-  auto rowReader = reader.createRowReader(rowReaderOpts);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
 
   VectorPtr result;
   EXPECT_EQ(rowReader->next(1000, result), 0);
@@ -139,12 +303,14 @@ TEST_F(ParquetReaderTest, parseReadAsLowerCase) {
   // 2 rows.
   const std::string upper(getExampleFilePath("upper.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto outputRowType = ROW({"a", "b"}, {BIGINT(), BIGINT()});
+  readerOptions.setFileSchema(outputRowType);
   readerOptions.setFileColumnNamesReadAsLowerCase(true);
-  ParquetReader reader = createReader(upper, readerOptions);
-  EXPECT_EQ(reader.numberOfRows(), 2ULL);
+  auto reader = createReader(upper, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 2ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 2ULL);
   auto col0 = type->childAt(0);
   EXPECT_EQ(col0->type()->kind(), TypeKind::BIGINT);
@@ -173,13 +339,13 @@ TEST_F(ParquetReaderTest, parseRowMapArrayReadAsLowerCase) {
   // +-----------------------+
   const std::string upper(getExampleFilePath("upper_complex.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
   readerOptions.setFileColumnNamesReadAsLowerCase(true);
-  ParquetReader reader = createReader(upper, readerOptions);
+  auto reader = createReader(upper, readerOptions);
 
-  EXPECT_EQ(reader.numberOfRows(), 1ULL);
+  EXPECT_EQ(reader->numberOfRows(), 1ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 1ULL);
 
   auto col0 = type->childAt(0);
@@ -216,11 +382,11 @@ TEST_F(ParquetReaderTest, parseEmpty) {
   // 0 rows.
   const std::string empty(getExampleFilePath("empty.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
-  ParquetReader reader = createReader(empty, readerOptions);
-  EXPECT_EQ(reader.numberOfRows(), 0ULL);
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(empty, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 0ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 2ULL);
   auto col0 = type->childAt(0);
   EXPECT_EQ(col0->type()->kind(), TypeKind::BIGINT);
@@ -238,12 +404,12 @@ TEST_F(ParquetReaderTest, parseInt) {
   //   bigint: [1000 .. 1009]
   const std::string sample(getExampleFilePath("int.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-  ParquetReader reader = createReader(sample, readerOpts);
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  auto reader = createReader(sample, readerOpts);
 
-  EXPECT_EQ(reader.numberOfRows(), 10ULL);
+  EXPECT_EQ(reader->numberOfRows(), 10ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 2ULL);
   auto col0 = type->childAt(0);
   EXPECT_EQ(col0->type()->kind(), TypeKind::INTEGER);
@@ -253,11 +419,120 @@ TEST_F(ParquetReaderTest, parseInt) {
   auto rowReaderOpts = getReaderOpts(intSchema());
   auto scanSpec = makeScanSpec(intSchema());
   rowReaderOpts.setScanSpec(scanSpec);
-  auto rowReader = reader.createRowReader(rowReaderOpts);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>(10, [](auto row) { return row + 100; }),
+      makeFlatVector<int64_t>(10, [](auto row) { return row + 1000; }),
+  });
+  assertReadWithReaderAndExpected(
+      intSchema(), *rowReader, expected, *leafPool_);
+}
+
+TEST_F(ParquetReaderTest, parseUnsignedInt1) {
+  // uint.parquet holds unsigned integer columns (uint8: TINYINT, uint16:
+  // SMALLINT, uint32: INTEGER, uint64: BIGINT) and 3 rows. Data is in plain
+  // uncompressed format:
+  //   uint8: [255, 3, 3]
+  //   uint16: [65535, 2000, 3000]
+  //   uint32: [4294967295, 2000000000, 3000000000]
+  //   uint64: [18446744073709551615, 2000000000000000000, 3000000000000000000]
+  const std::string sample(getExampleFilePath("uint.parquet"));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+
+  EXPECT_EQ(reader->numberOfRows(), 3ULL);
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 4ULL);
+  auto col0 = type->childAt(0);
+  EXPECT_EQ(col0->type()->kind(), TypeKind::TINYINT);
+  auto col1 = type->childAt(1);
+  EXPECT_EQ(col1->type()->kind(), TypeKind::SMALLINT);
+  auto col2 = type->childAt(2);
+  EXPECT_EQ(col2->type()->kind(), TypeKind::INTEGER);
+  auto col3 = type->childAt(3);
+  EXPECT_EQ(col3->type()->kind(), TypeKind::BIGINT);
+
+  auto rowType =
+      ROW({"uint8", "uint16", "uint32", "uint64"},
+          {TINYINT(), SMALLINT(), INTEGER(), BIGINT()});
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.select(std::make_shared<dwio::common::ColumnSelector>(
+      rowType, rowType->names()));
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
 
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int32_t>(10, 100), rangeVector<int64_t>(10, 1000)});
-  assertReadExpected(intSchema(), *rowReader, expected, *pool_);
+  auto expected = makeRowVector(
+      {makeFlatVector<uint8_t>({255, 2, 3}),
+       makeFlatVector<uint16_t>({65535, 2000, 3000}),
+       makeFlatVector<uint32_t>({4294967295, 2000000000, 3000000000}),
+       makeFlatVector<uint64_t>(
+           {18446744073709551615ULL,
+            2000000000000000000ULL,
+            3000000000000000000ULL})});
+  assertReadWithReaderAndExpected(rowType, *rowReader, expected, *pool_);
+}
+
+TEST_F(ParquetReaderTest, parseUnsignedInt2) {
+  auto rowType =
+      ROW({"uint8", "uint16", "uint32", "uint64"},
+          {SMALLINT(), SMALLINT(), INTEGER(), BIGINT()});
+  auto expected = makeRowVector(
+      {makeFlatVector<uint16_t>({255, 2, 3}),
+       makeFlatVector<uint16_t>({65535, 2000, 3000}),
+       makeFlatVector<uint32_t>({4294967295, 2000000000, 3000000000}),
+       makeFlatVector<uint64_t>(
+           {18446744073709551615ULL,
+            2000000000000000000ULL,
+            3000000000000000000ULL})});
+  assertReadWithExpected("uint.parquet", rowType, expected);
+}
+
+TEST_F(ParquetReaderTest, parseUnsignedInt3) {
+  auto rowType =
+      ROW({"uint8", "uint16", "uint32", "uint64"},
+          {SMALLINT(), INTEGER(), INTEGER(), BIGINT()});
+  auto expected = makeRowVector(
+      {makeFlatVector<uint16_t>({255, 2, 3}),
+       makeFlatVector<uint32_t>({65535, 2000, 3000}),
+       makeFlatVector<uint32_t>({4294967295, 2000000000, 3000000000}),
+       makeFlatVector<uint64_t>(
+           {18446744073709551615ULL,
+            2000000000000000000ULL,
+            3000000000000000000ULL})});
+  assertReadWithExpected("uint.parquet", rowType, expected);
+}
+
+TEST_F(ParquetReaderTest, parseUnsignedInt4) {
+  auto rowType =
+      ROW({"uint8", "uint16", "uint32", "uint64"},
+          {SMALLINT(), INTEGER(), INTEGER(), DECIMAL(20, 0)});
+  auto expected = makeRowVector(
+      {makeFlatVector<uint16_t>({255, 2, 3}),
+       makeFlatVector<uint32_t>({65535, 2000, 3000}),
+       makeFlatVector<uint32_t>({4294967295, 2000000000, 3000000000}),
+       makeFlatVector<uint128_t>(
+           {18446744073709551615ULL,
+            2000000000000000000ULL,
+            3000000000000000000ULL})});
+  assertReadWithExpected("uint.parquet", rowType, expected);
+}
+
+TEST_F(ParquetReaderTest, parseUnsignedInt5) {
+  auto rowType =
+      ROW({"uint8", "uint16", "uint32", "uint64"},
+          {SMALLINT(), INTEGER(), BIGINT(), DECIMAL(20, 0)});
+  auto expected = makeRowVector(
+      {makeFlatVector<uint16_t>({255, 2, 3}),
+       makeFlatVector<uint32_t>({65535, 2000, 3000}),
+       makeFlatVector<uint64_t>({4294967295, 2000000000, 3000000000}),
+       makeFlatVector<uint128_t>(
+           {18446744073709551615ULL,
+            2000000000000000000ULL,
+            3000000000000000000ULL})});
+  assertReadWithExpected("uint.parquet", rowType, expected);
 }
 
 TEST_F(ParquetReaderTest, parseDate) {
@@ -267,12 +542,12 @@ TEST_F(ParquetReaderTest, parseDate) {
   //   date: [1969-12-27 .. 1970-01-20]
   const std::string sample(getExampleFilePath("date.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
-  ParquetReader reader = createReader(sample, readerOptions);
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
 
-  EXPECT_EQ(reader.numberOfRows(), 25ULL);
+  EXPECT_EQ(reader->numberOfRows(), 25ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 1ULL);
   auto col0 = type->childAt(0);
   EXPECT_EQ(col0->type(), DATE());
@@ -281,10 +556,12 @@ TEST_F(ParquetReaderTest, parseDate) {
   auto rowReaderOpts = getReaderOpts(dateSchema());
   auto scanSpec = makeScanSpec(dateSchema());
   rowReaderOpts.setScanSpec(scanSpec);
-  auto rowReader = reader.createRowReader(rowReaderOpts);
-
-  auto expected = vectorMaker_->rowVector({rangeVector<int32_t>(25, -5)});
-  assertReadExpected(dateSchema(), *rowReader, expected, *pool_);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>(25, [](auto row) { return row - 5; }),
+  });
+  assertReadWithReaderAndExpected(
+      dateSchema(), *rowReader, expected, *leafPool_);
 }
 
 TEST_F(ParquetReaderTest, parseRowMapArray) {
@@ -292,12 +569,12 @@ TEST_F(ParquetReaderTest, parseRowMapArray) {
   // ARRAY(INTEGER)) c1) c)
   const std::string sample(getExampleFilePath("row_map_array.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
-  ParquetReader reader = createReader(sample, readerOptions);
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
 
-  EXPECT_EQ(reader.numberOfRows(), 1ULL);
+  EXPECT_EQ(reader->numberOfRows(), 1ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 1ULL);
 
   auto col0 = type->childAt(0);
@@ -325,13 +602,12 @@ TEST_F(ParquetReaderTest, parseRowMapArray) {
 TEST_F(ParquetReaderTest, projectNoColumns) {
   // This is the case for count(*).
   auto rowType = ROW({}, {});
-  facebook::velox::dwio::common::ReaderOptions readerOpts{defaultPool.get()};
-  ParquetReader reader =
-      createReader(getExampleFilePath("sample.parquet"), readerOpts);
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
+  auto reader = createReader(getExampleFilePath("sample.parquet"), readerOpts);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setScanSpec(makeScanSpec(rowType));
-  auto rowReader = reader.createRowReader(rowReaderOpts);
-  auto result = BaseVector::create(rowType, 1, pool_.get());
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto result = BaseVector::create(rowType, 1, leafPool_.get());
   constexpr int kBatchSize = 100;
   ASSERT_TRUE(rowReader->next(kBatchSize, result));
   EXPECT_EQ(result->size(), 10);
@@ -350,17 +626,17 @@ TEST_F(ParquetReaderTest, parseIntDecimal) {
   //   a: [11.11, 11.11, 22.22, 22.22, 33.33, 33.33]
   //   b: [11.11, 11.11, 22.22, 22.22, 33.33, 33.33]
   auto rowType = ROW({"a", "b"}, {DECIMAL(7, 2), DECIMAL(14, 2)});
-  facebook::velox::dwio::common::ReaderOptions readerOpts{defaultPool.get()};
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
   const std::string decimal_dict(getExampleFilePath("decimal_dict.parquet"));
 
-  ParquetReader reader = createReader(decimal_dict, readerOpts);
+  auto reader = createReader(decimal_dict, readerOpts);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setScanSpec(makeScanSpec(rowType));
-  auto rowReader = reader.createRowReader(rowReaderOpts);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
 
-  EXPECT_EQ(reader.numberOfRows(), 6ULL);
+  EXPECT_EQ(reader->numberOfRows(), 6ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 2ULL);
   auto col0 = type->childAt(0);
   auto col1 = type->childAt(1);
@@ -368,12 +644,18 @@ TEST_F(ParquetReaderTest, parseIntDecimal) {
   EXPECT_EQ(col1->type()->kind(), TypeKind::BIGINT);
 
   int64_t expectValues[3] = {1111, 2222, 3333};
-  auto result = BaseVector::create(rowType, 1, pool_.get());
+  auto result = BaseVector::create(rowType, 1, leafPool_.get());
   rowReader->next(6, result);
   EXPECT_EQ(result->size(), 6ULL);
   auto decimals = result->as<RowVector>();
-  auto a = decimals->childAt(0)->asFlatVector<int64_t>()->rawValues();
-  auto b = decimals->childAt(1)->asFlatVector<int64_t>()->rawValues();
+  auto a = decimals->childAt(0)
+               ->loadedVector()
+               ->asFlatVector<int64_t>()
+               ->rawValues();
+  auto b = decimals->childAt(1)
+               ->loadedVector()
+               ->asFlatVector<int64_t>()
+               ->rawValues();
   for (int i = 0; i < 3; i++) {
     int index = 2 * i;
     EXPECT_EQ(a[index], expectValues[i]);
@@ -383,13 +665,117 @@ TEST_F(ParquetReaderTest, parseIntDecimal) {
   }
 }
 
+TEST_F(ParquetReaderTest, parseMapKeyValueAsMap) {
+  // map_key_value.parquet holds a single map column (key: VARCHAR, b: BIGINT)
+  // and 1 row that contains 8 map entries. It is with older version of Parquet
+  // and uses MAP_KEY_VALUE instead of MAP as the map SchemaElement
+  // converted_type. It has 5 SchemaElements in the schema, in the format of
+  // schemaIdx: <repetition> <type> name (<converted type>):
+  //
+  // 0: REQUIRED BOOLEAN hive_schema (UTF8)
+  // 1:   OPTIONAL BOOLEAN test (MAP_KEY_VALUE)
+  // 2:     REPEATED BOOLEAN map (UTF8)
+  // 3:       REQUIRED BYTE_ARRAY key (UTF8)
+  // 4:       OPTIONAL INT64 value (UTF8)
+
+  const std::string sample(getExampleFilePath("map_key_value.parquet"));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 1ULL);
+
+  auto rowType = reader->typeWithId();
+  EXPECT_EQ(rowType->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(rowType->size(), 1ULL);
+
+  auto mapColumnType = rowType->childAt(0);
+  EXPECT_EQ(mapColumnType->type()->kind(), TypeKind::MAP);
+
+  auto mapKeyType = mapColumnType->childAt(0);
+  EXPECT_EQ(mapKeyType->type()->kind(), TypeKind::VARCHAR);
+
+  auto mapValueType = mapColumnType->childAt(1);
+  EXPECT_EQ(mapValueType->type()->kind(), TypeKind::BIGINT);
+
+  auto fileSchema =
+      ROW({"test"}, {createType<TypeKind::MAP>({VARCHAR(), BIGINT()})});
+  auto rowReaderOpts = getReaderOpts(fileSchema);
+  auto scanSpec = makeScanSpec(fileSchema);
+  rowReaderOpts.setScanSpec(scanSpec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = makeRowVector({vectorMaker_.mapVector<std::string, int64_t>(
+      {{{"0", 0},
+        {"1", 1},
+        {"2", 2},
+        {"3", 3},
+        {"4", 4},
+        {"5", 5},
+        {"6", 6},
+        {"7", 7}}})});
+
+  assertReadWithReaderAndExpected(fileSchema, *rowReader, expected, *leafPool_);
+}
+
+TEST_F(ParquetReaderTest, parseRowArrayTest) {
+  // schema:
+  //   optionalPrimitive:int
+  //   requiredPrimitive:int
+  //   repeatedPrimitive:array<int>
+  //   optionalMessage:struct<someId:int>
+  //   requiredMessage:struct<someId:int>
+  //   repeatedMessage:array<struct<someId:int>>
+  const std::string sample(
+      getExampleFilePath("proto-struct-with-array.parquet"));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 1ULL);
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 6ULL);
+  auto col6_type = type->childAt(5);
+  EXPECT_EQ(col6_type->type()->kind(), TypeKind::ARRAY);
+  auto col6_1_type = col6_type->childAt(0);
+  EXPECT_EQ(col6_1_type->type()->kind(), TypeKind::ROW);
+
+  auto outputRowType =
+      ROW({"optionalPrimitive",
+           "requiredPrimitive",
+           "repeatedPrimitive",
+           "optionalMessage",
+           "requiredMessage",
+           "repeatedMessage"},
+          {INTEGER(),
+           INTEGER(),
+           ARRAY(INTEGER()),
+           ROW({"someId"}, {INTEGER()}),
+           ROW({"someId"}, {INTEGER()}),
+           ARRAY(ROW({"someId"}, {INTEGER()}))});
+  auto rowReaderOpts = getReaderOpts(outputRowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(outputRowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr result = BaseVector::create(outputRowType, 0, &*leafPool_);
+
+  ASSERT_TRUE(rowReader->next(1, result));
+  // data: 10, 9, <empty>, null, {9}, 2 elements starting at 0 {{9}, {10}}}
+  auto structArray =
+      result->as<RowVector>()->childAt(5)->loadedVector()->as<ArrayVector>();
+  auto structEle = structArray->elements()
+                       ->as<RowVector>()
+                       ->childAt(0)
+                       ->asFlatVector<int32_t>()
+                       ->valueAt(0);
+  EXPECT_EQ(structEle, 9);
+}
+
 TEST_F(ParquetReaderTest, readSampleBigintRangeFilter) {
   // Read sample.parquet with the int filter "a BETWEEN 16 AND 20".
   FilterMap filters;
   filters.insert({"a", exec::between(16, 20)});
-
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(5, 16), rangeVector<double>(5, 16)});
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(5, [](auto row) { return row + 16; }),
+      makeFlatVector<double>(5, [](auto row) { return row + 16; }),
+  });
   assertReadWithFilters(
       "sample.parquet", sampleSchema(), std::move(filters), expected);
 }
@@ -397,14 +783,14 @@ TEST_F(ParquetReaderTest, readSampleBigintRangeFilter) {
 TEST_F(ParquetReaderTest, readSampleBigintValuesUsingBitmaskFilter) {
   // Read sample.parquet with the int filter "a in 16, 17, 18, 19, 20".
   std::vector<int64_t> values{16, 17, 18, 19, 20};
-  auto bigintBitmaskFilter =
-      std::make_unique<facebook::velox::common::BigintValuesUsingBitmask>(
-          16, 20, std::move(values), false);
+  auto bigintBitmaskFilter = std::make_unique<common::BigintValuesUsingBitmask>(
+      16, 20, std::move(values), false);
   FilterMap filters;
   filters.insert({"a", std::move(bigintBitmaskFilter)});
-
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(5, 16), rangeVector<double>(5, 16)});
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(5, [](auto row) { return row + 16; }),
+      makeFlatVector<double>(5, [](auto row) { return row + 16; }),
+  });
   assertReadWithFilters(
       "sample.parquet", sampleSchema(), std::move(filters), expected);
 }
@@ -414,8 +800,11 @@ TEST_F(ParquetReaderTest, readSampleEqualFilter) {
   FilterMap filters;
   filters.insert({"a", exec::equal(16)});
 
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(1, 16), rangeVector<double>(1, 16)});
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(1, [](auto row) { return row + 16; }),
+      makeFlatVector<double>(1, [](auto row) { return row + 16; }),
+  });
+
   assertReadWithFilters(
       "sample.parquet", sampleSchema(), std::move(filters), expected);
 }
@@ -425,7 +814,10 @@ TEST_F(ParquetReaderTest, dateFilters) {
   FilterMap filters;
   filters.insert({"date", exec::between(5, 14)});
 
-  auto expected = vectorMaker_->rowVector({rangeVector<int32_t>(10, 5)});
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>(10, [](auto row) { return row + 5; }),
+  });
+
   assertReadWithFilters(
       "date.parquet", dateSchema(), std::move(filters), expected);
 }
@@ -436,8 +828,10 @@ TEST_F(ParquetReaderTest, intMultipleFilters) {
   filters.insert({"int", exec::between(102, 120)});
   filters.insert({"bigint", exec::between(900, 1006)});
 
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int32_t>(5, 102), rangeVector<int64_t>(5, 1002)});
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>(5, [](auto row) { return row + 102; }),
+      makeFlatVector<int64_t>(5, [](auto row) { return row + 1002; }),
+  });
 
   assertReadWithFilters(
       "int.parquet", intSchema(), std::move(filters), expected);
@@ -448,38 +842,54 @@ TEST_F(ParquetReaderTest, doubleFilters) {
   FilterMap filters;
   filters.insert({"b", exec::lessThanDouble(10.0)});
 
-  auto expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(9, 1), rangeVector<double>(9, 1)});
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(9, [](auto row) { return row + 1; }),
+      makeFlatVector<double>(9, [](auto row) { return row + 1; }),
+  });
+
   assertReadWithFilters(
       "sample.parquet", sampleSchema(), std::move(filters), expected);
+  filters.clear();
 
   // Test "b <= 10.0".
   filters.insert({"b", exec::lessThanOrEqualDouble(10.0)});
-  expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(10, 1), rangeVector<double>(10, 1)});
+  expected = makeRowVector({
+      makeFlatVector<int64_t>(10, [](auto row) { return row + 1; }),
+      makeFlatVector<double>(10, [](auto row) { return row + 1; }),
+  });
   assertReadWithFilters(
       "sample.parquet", sampleSchema(), std::move(filters), expected);
+  filters.clear();
 
   // Test "b between 10.0 and 14.0".
   filters.insert({"b", exec::betweenDouble(10.0, 14.0)});
-  expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(5, 10), rangeVector<double>(5, 10)});
+  expected = makeRowVector({
+      makeFlatVector<int64_t>(5, [](auto row) { return row + 10; }),
+      makeFlatVector<double>(5, [](auto row) { return row + 10; }),
+  });
   assertReadWithFilters(
       "sample.parquet", sampleSchema(), std::move(filters), expected);
+  filters.clear();
 
   // Test "b > 14.0".
   filters.insert({"b", exec::greaterThanDouble(14.0)});
-  expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(6, 15), rangeVector<double>(6, 15)});
+  expected = makeRowVector({
+      makeFlatVector<int64_t>(6, [](auto row) { return row + 15; }),
+      makeFlatVector<double>(6, [](auto row) { return row + 15; }),
+  });
   assertReadWithFilters(
       "sample.parquet", sampleSchema(), std::move(filters), expected);
+  filters.clear();
 
   // Test "b >= 14.0".
   filters.insert({"b", exec::greaterThanOrEqualDouble(14.0)});
-  expected = vectorMaker_->rowVector(
-      {rangeVector<int64_t>(7, 14), rangeVector<double>(7, 14)});
+  expected = makeRowVector({
+      makeFlatVector<int64_t>(7, [](auto row) { return row + 14; }),
+      makeFlatVector<double>(7, [](auto row) { return row + 14; }),
+  });
   assertReadWithFilters(
       "sample.parquet", sampleSchema(), std::move(filters), expected);
+  filters.clear();
 }
 
 TEST_F(ParquetReaderTest, varcharFilters) {
@@ -487,10 +897,10 @@ TEST_F(ParquetReaderTest, varcharFilters) {
   FilterMap filters;
   filters.insert({"name", exec::lessThan("CANADA")});
 
-  auto expected = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>({0, 1, 2}),
-      vectorMaker_->flatVector({"ALGERIA", "ARGENTINA", "BRAZIL"}),
-      vectorMaker_->flatVector<int64_t>({0, 1, 1}),
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 2}),
+      makeFlatVector<std::string>({"ALGERIA", "ARGENTINA", "BRAZIL"}),
+      makeFlatVector<int64_t>({0, 1, 1}),
   });
 
   auto rowType =
@@ -498,68 +908,103 @@ TEST_F(ParquetReaderTest, varcharFilters) {
 
   assertReadWithFilters(
       "nation.parquet", rowType, std::move(filters), expected);
+  filters.clear();
 
   // Test "name <= 'CANADA'".
   filters.insert({"name", exec::lessThanOrEqual("CANADA")});
-  expected = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>({0, 1, 2, 3}),
-      vectorMaker_->flatVector({"ALGERIA", "ARGENTINA", "BRAZIL", "CANADA"}),
-      vectorMaker_->flatVector<int64_t>({0, 1, 1, 1}),
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 2, 3}),
+      makeFlatVector<std::string>({"ALGERIA", "ARGENTINA", "BRAZIL", "CANADA"}),
+      makeFlatVector<int64_t>({0, 1, 1, 1}),
   });
   assertReadWithFilters(
       "nation.parquet", rowType, std::move(filters), expected);
+  filters.clear();
 
   // Test "name > UNITED KINGDOM".
   filters.insert({"name", exec::greaterThan("UNITED KINGDOM")});
-  expected = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>({21, 24}),
-      vectorMaker_->flatVector({"VIETNAM", "UNITED STATES"}),
-      vectorMaker_->flatVector<int64_t>({2, 1}),
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({21, 24}),
+      makeFlatVector<std::string>({"VIETNAM", "UNITED STATES"}),
+      makeFlatVector<int64_t>({2, 1}),
   });
   assertReadWithFilters(
       "nation.parquet", rowType, std::move(filters), expected);
+  filters.clear();
 
   // Test "name >= 'UNITED KINGDOM'".
   filters.insert({"name", exec::greaterThanOrEqual("UNITED KINGDOM")});
-  expected = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>({21, 23, 24}),
-      vectorMaker_->flatVector({"VIETNAM", "UNITED KINGDOM", "UNITED STATES"}),
-      vectorMaker_->flatVector<int64_t>({2, 3, 1}),
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({21, 23, 24}),
+      makeFlatVector<std::string>(
+          {"VIETNAM", "UNITED KINGDOM", "UNITED STATES"}),
+      makeFlatVector<int64_t>({2, 3, 1}),
   });
   assertReadWithFilters(
       "nation.parquet", rowType, std::move(filters), expected);
+  filters.clear();
 
   // Test "name = 'CANADA'".
   filters.insert({"name", exec::equal("CANADA")});
-  expected = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>({3}),
-      vectorMaker_->flatVector({"CANADA"}),
-      vectorMaker_->flatVector<int64_t>({1}),
+  expected = makeRowVector({
+      makeFlatVector<int64_t>(1, [](auto row) { return row + 3; }),
+      makeFlatVector<std::string>({"CANADA"}),
+      makeFlatVector<int64_t>(1, [](auto row) { return row + 1; }),
   });
   assertReadWithFilters(
       "nation.parquet", rowType, std::move(filters), expected);
+  filters.clear();
 
   // Test "name IN ('CANADA', 'UNITED KINGDOM')".
   filters.insert({"name", exec::in({std::string("CANADA"), "UNITED KINGDOM"})});
-  expected = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>({3, 23}),
-      vectorMaker_->flatVector({"CANADA", "UNITED KINGDOM"}),
-      vectorMaker_->flatVector<int64_t>({1, 3}),
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({3, 23}),
+      makeFlatVector<std::string>({"CANADA", "UNITED KINGDOM"}),
+      makeFlatVector<int64_t>({1, 3}),
   });
   assertReadWithFilters(
       "nation.parquet", rowType, std::move(filters), expected);
+  filters.clear();
 
   // Test "name IN ('UNITED STATES', 'CANADA', 'INDIA', 'RUSSIA')".
   filters.insert(
       {"name",
        exec::in({std::string("UNITED STATES"), "INDIA", "CANADA", "RUSSIA"})});
-  expected = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>({3, 8, 22, 24}),
-      vectorMaker_->flatVector({"CANADA", "INDIA", "RUSSIA", "UNITED STATES"}),
-      vectorMaker_->flatVector<int64_t>({1, 2, 3, 1}),
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({3, 8, 22, 24}),
+      makeFlatVector<std::string>(
+          {"CANADA", "INDIA", "RUSSIA", "UNITED STATES"}),
+      makeFlatVector<int64_t>({1, 2, 3, 1}),
   });
   assertReadWithFilters(
       "nation.parquet", rowType, std::move(filters), expected);
+  filters.clear();
+}
+
+TEST_F(ParquetReaderTest, readDifferentEncodingsWithFilter) {
+  FilterMap filters;
+  filters.insert({"n_1", exec::equal(1)});
+  auto rowType = ROW({"n_0", "n_1", "n_2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4, 1, 2, 3, 4, 6, 9}),
+      makeFlatVector<int32_t>(10, [](auto /*row*/) { return 1; }),
+      makeNullableFlatVector<std::string>(
+          {"A",
+           "B",
+           std::nullopt,
+           std::nullopt,
+           "A",
+           "B",
+           std::nullopt,
+           std::nullopt,
+           "F",
+           std::nullopt}),
+  });
+  assertReadWithFilters(
+      "different_encodings_with_filter.parquet",
+      rowType,
+      std::move(filters),
+      expected);
 }
 
 // This test is to verify filterRowGroups() doesn't throw the fileOffset Velox
@@ -568,28 +1013,28 @@ TEST_F(ParquetReaderTest, filterRowGroups) {
   // decimal_no_ColumnMetadata.parquet has one columns a: DECIMAL(9,1). It
   // doesn't have ColumnMetaData, and rowGroups_[0].columns[0].file_offset is 0.
   auto rowType = ROW({"_c0"}, {DECIMAL(9, 1)});
-  facebook::velox::dwio::common::ReaderOptions readerOpts{defaultPool.get()};
+  dwio::common::ReaderOptions readerOpts{leafPool_.get()};
   const std::string decimal_dict(
       getExampleFilePath("decimal_no_ColumnMetadata.parquet"));
 
-  ParquetReader reader = createReader(decimal_dict, readerOpts);
+  auto reader = createReader(decimal_dict, readerOpts);
   RowReaderOptions rowReaderOpts;
   rowReaderOpts.setScanSpec(makeScanSpec(rowType));
-  auto rowReader = reader.createRowReader(rowReaderOpts);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
 
-  EXPECT_EQ(reader.numberOfRows(), 10ULL);
+  EXPECT_EQ(reader->numberOfRows(), 10ULL);
 }
 
 TEST_F(ParquetReaderTest, parseLongTagged) {
   // This is a case for long with annonation read
   const std::string sample(getExampleFilePath("tagged_long.parquet"));
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
-  ParquetReader reader = createReader(sample, readerOptions);
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
 
-  EXPECT_EQ(reader.numberOfRows(), 4ULL);
+  EXPECT_EQ(reader->numberOfRows(), 4ULL);
 
-  auto type = reader.typeWithId();
+  auto type = reader->typeWithId();
   EXPECT_EQ(type->size(), 1ULL);
   auto col0 = type->childAt(0);
   EXPECT_EQ(col0->type()->kind(), TypeKind::BIGINT);
@@ -600,9 +1045,9 @@ TEST_F(ParquetReaderTest, preloadSmallFile) {
   const std::string sample(getExampleFilePath("sample.parquet"));
 
   auto file = std::make_shared<LocalReadFile>(sample);
-  auto input = std::make_unique<BufferedInput>(file, *defaultPool);
+  auto input = std::make_unique<BufferedInput>(file, *leafPool_);
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
   auto reader =
       std::make_unique<ParquetReader>(std::move(input), readerOptions);
 
@@ -614,10 +1059,8 @@ TEST_F(ParquetReaderTest, preloadSmallFile) {
   // Ensure the input is small parquet file.
   const auto fileSize = file->size();
   ASSERT_TRUE(
-      fileSize <= facebook::velox::dwio::common::ReaderOptions::
-                      kDefaultFilePreloadThreshold ||
-      fileSize <= facebook::velox::dwio::common::ReaderOptions::
-                      kDefaultDirectorySizeGuess);
+      fileSize <= dwio::common::ReaderOptions::kDefaultFilePreloadThreshold ||
+      fileSize <= dwio::common::ReaderOptions::kDefaultFooterEstimatedSize);
 
   // Check the whole file already loaded.
   ASSERT_EQ(file->bytesRead(), fileSize);
@@ -626,7 +1069,7 @@ TEST_F(ParquetReaderTest, preloadSmallFile) {
   file->resetBytesRead();
 
   constexpr int kBatchSize = 10;
-  auto result = BaseVector::create(sampleSchema(), 1, pool_.get());
+  auto result = BaseVector::create(sampleSchema(), 1, leafPool_.get());
   while (rowReader->next(kBatchSize, result)) {
     // Check no duplicate reads.
     ASSERT_EQ(file->bytesRead(), 0);
@@ -638,7 +1081,7 @@ TEST_F(ParquetReaderTest, prefetchRowGroups) {
   const std::string sample(getExampleFilePath("multiple_row_groups.parquet"));
   const int numRowGroups = 4;
 
-  facebook::velox::dwio::common::ReaderOptions readerOptions{defaultPool.get()};
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
   // Disable preload of file.
   readerOptions.setFilePreloadThreshold(0);
 
@@ -647,19 +1090,16 @@ TEST_F(ParquetReaderTest, prefetchRowGroups) {
   // 4: Exactly as total number of row groups.
   // 10: More than total number of row groups.
   const std::vector<int> numPrefetchRowGroups{
-      facebook::velox::dwio::common::ReaderOptions::kDefaultPrefetchRowGroups,
-      2,
-      4,
-      10};
+      dwio::common::ReaderOptions::kDefaultPrefetchRowGroups, 2, 4, 10};
   for (auto numPrefetch : numPrefetchRowGroups) {
     readerOptions.setPrefetchRowGroups(numPrefetch);
 
-    ParquetReader reader = createReader(sample, readerOptions);
-    EXPECT_EQ(reader.numberOfRowGroups(), numRowGroups);
+    auto reader = createReader(sample, readerOptions);
+    EXPECT_EQ(reader->fileMetaData().numRowGroups(), numRowGroups);
 
     RowReaderOptions rowReaderOpts;
     rowReaderOpts.setScanSpec(makeScanSpec(rowType));
-    auto rowReader = reader.createRowReader(rowReaderOpts);
+    auto rowReader = reader->createRowReader(rowReaderOpts);
     auto parquetRowReader = dynamic_cast<ParquetRowReader*>(rowReader.get());
 
     constexpr int kBatchSize = 1000;
@@ -689,3 +1129,376 @@ TEST_F(ParquetReaderTest, prefetchRowGroups) {
     }
   }
 }
+
+TEST_F(ParquetReaderTest, testEmptyRowGroups) {
+  // empty_row_groups.parquet contains empty row groups
+  const std::string sample(getExampleFilePath("empty_row_groups.parquet"));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 5ULL);
+
+  auto rowType = reader->typeWithId();
+  EXPECT_EQ(rowType->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(rowType->size(), 1ULL);
+
+  auto integerType = rowType->childAt(0);
+  EXPECT_EQ(integerType->type()->kind(), TypeKind::INTEGER);
+
+  auto fileSchema = ROW({"a"}, {INTEGER()});
+  auto rowReaderOpts = getReaderOpts(fileSchema);
+  auto scanSpec = makeScanSpec(fileSchema);
+  rowReaderOpts.setScanSpec(scanSpec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = makeRowVector({makeFlatVector<int32_t>({0, 3, 3, 3, 3})});
+
+  assertReadWithReaderAndExpected(fileSchema, *rowReader, expected, *leafPool_);
+}
+
+TEST_F(ParquetReaderTest, testEnumType) {
+  // enum_type.parquet contains 1 column (ENUM) with 3 rows.
+  const std::string sample(getExampleFilePath("enum_type.parquet"));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 3ULL);
+
+  auto rowType = reader->typeWithId();
+  EXPECT_EQ(rowType->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(rowType->size(), 1ULL);
+
+  EXPECT_EQ(rowType->childAt(0)->type()->kind(), TypeKind::VARCHAR);
+
+  auto fileSchema = ROW({"test"}, {VARCHAR()});
+  auto rowReaderOpts = getReaderOpts(fileSchema);
+  rowReaderOpts.setScanSpec(makeScanSpec(fileSchema));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected =
+      makeRowVector({makeFlatVector<StringView>({"FOO", "BAR", "FOO"})});
+
+  assertReadWithReaderAndExpected(fileSchema, *rowReader, expected, *leafPool_);
+}
+
+TEST_F(ParquetReaderTest, readVarbinaryFromFLBA) {
+  const std::string filename("varbinary_flba.parquet");
+  const std::string sample(getExampleFilePath(filename));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 8ULL);
+  auto flbaCol =
+      std::static_pointer_cast<const ParquetTypeWithId>(type->childAt(6));
+  EXPECT_EQ(flbaCol->name_, "flba_field");
+  EXPECT_EQ(flbaCol->parquetType_, thrift::Type::FIXED_LEN_BYTE_ARRAY);
+
+  auto selectedType = ROW({"flba_field"}, {VARBINARY()});
+  auto rowReaderOpts = getReaderOpts(selectedType);
+  rowReaderOpts.setScanSpec(makeScanSpec(selectedType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = std::string(1024, '*');
+  VectorPtr result = BaseVector::create(selectedType, 0, &(*leafPool_));
+  rowReader->next(1, result);
+  EXPECT_EQ(
+      expected,
+      result->as<RowVector>()
+          ->childAt(0)
+          ->loadedVector()
+          ->asFlatVector<StringView>()
+          ->valueAt(0));
+}
+
+TEST_F(ParquetReaderTest, readBinaryAsStringFromNation) {
+  const std::string filename("nation.parquet");
+  const std::string sample(getExampleFilePath(filename));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto outputRowType =
+      ROW({"nationkey", "name", "regionkey", "comment"},
+          {BIGINT(), VARCHAR(), BIGINT(), VARCHAR()});
+
+  readerOptions.setFileSchema(outputRowType);
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 25ULL);
+  auto rowType = reader->typeWithId();
+  EXPECT_EQ(rowType->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(rowType->size(), 4ULL);
+  EXPECT_EQ(rowType->childAt(1)->type()->kind(), TypeKind::VARCHAR);
+
+  auto rowReaderOpts = getReaderOpts(outputRowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(outputRowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = std::string("ALGERIA");
+  VectorPtr result = BaseVector::create(outputRowType, 0, &(*leafPool_));
+  rowReader->next(1, result);
+  auto nameVector = result->as<RowVector>()->childAt(1);
+  ASSERT_TRUE(isLazyNotLoaded(*nameVector));
+  EXPECT_EQ(
+      expected,
+      nameVector->loadedVector()->asFlatVector<StringView>()->valueAt(0));
+}
+
+TEST_F(ParquetReaderTest, readFixedLenBinaryAsStringFromUuid) {
+  const std::string filename("uuid.parquet");
+  const std::string sample(getExampleFilePath(filename));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto outputRowType = ROW({"uuid_field"}, {VARCHAR()});
+
+  readerOptions.setFileSchema(outputRowType);
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 3ULL);
+  auto rowType = reader->typeWithId();
+  EXPECT_EQ(rowType->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(rowType->size(), 1ULL);
+  EXPECT_EQ(rowType->childAt(0)->type()->kind(), TypeKind::VARCHAR);
+
+  auto rowReaderOpts = getReaderOpts(outputRowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(outputRowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = std::string("5468454a-363f-ccc8-7d0b-76072a75dfaa");
+  VectorPtr result = BaseVector::create(outputRowType, 0, &(*leafPool_));
+  rowReader->next(1, result);
+  auto uuidVector = result->as<RowVector>()->childAt(0);
+  ASSERT_TRUE(isLazyNotLoaded(*uuidVector));
+  EXPECT_EQ(
+      expected,
+      uuidVector->loadedVector()->asFlatVector<StringView>()->valueAt(0));
+}
+
+TEST_F(ParquetReaderTest, testV2PageWithZeroMaxDefRep) {
+  // enum_type.parquet contains 1 column (ENUM) with 3 rows.
+  const std::string sample(getExampleFilePath("v2_page.parquet"));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 5ULL);
+
+  auto rowType = reader->typeWithId();
+  EXPECT_EQ(rowType->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(rowType->size(), 1ULL);
+
+  EXPECT_EQ(rowType->childAt(0)->type()->kind(), TypeKind::BIGINT);
+
+  auto outputRowType = ROW({"regionkey"}, {BIGINT()});
+  auto rowReaderOpts = getReaderOpts(outputRowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(outputRowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = makeRowVector({makeFlatVector<int64_t>({0, 1, 2, 3, 4})});
+
+  assertReadWithReaderAndExpected(
+      outputRowType, *rowReader, expected, *leafPool_);
+}
+
+TEST_F(ParquetReaderTest, arrayOfMapOfIntKeyArrayValue) {
+  //  The Schema is of type
+  //  message hive_schema {
+  //    optional group test (LIST) {
+  //      repeated group array (MAP) {
+  //        repeated group key_value (MAP_KEY_VALUE) {
+  //          required binary key (UTF8);
+  //          optional group value (LIST) {
+  //            repeated int32 array;
+  //          }
+  //        }
+  //      }
+  //    }
+  //  }
+  const std::string expectedVeloxType =
+      "ROW<test:ARRAY<MAP<VARCHAR,ARRAY<INTEGER>>>>";
+  const std::string sample(
+      getExampleFilePath("array_of_map_of_int_key_array_value.parquet"));
+  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
+  auto numRows = reader->numberOfRows();
+  auto type = reader->typeWithId();
+  RowReaderOptions rowReaderOpts;
+  auto rowType = ROW({"test"}, {ARRAY(MAP(VARCHAR(), ARRAY(INTEGER())))});
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto result = BaseVector::create(rowType, 10, leafPool_.get());
+  constexpr int kBatchSize = 1000;
+  while (rowReader->next(kBatchSize, result)) {
+  }
+}
+
+TEST_F(ParquetReaderTest, arrayOfMapOfIntKeyStructValue) {
+  //  The Schema is of type
+  //   message hive_schema {
+  //    optional group test (LIST) {
+  //      repeated group array (MAP) {
+  //        repeated group key_value (MAP_KEY_VALUE) {
+  //          required int32 key;
+  //          optional group value {
+  //            optional binary stringfield (UTF8);
+  //            optional int64 longfield;
+  //          }
+  //        }
+  //      }
+  //    }
+  //  }
+  const std::string expectedVeloxType =
+      "ROW<test:ARRAY<MAP<INTEGER,ROW<stringfield:VARCHAR,longfield:BIGINT>>>>";
+  const std::string sample(
+      getExampleFilePath("array_of_map_of_int_key_struct_value.parquet"));
+  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
+  auto numRows = reader->numberOfRows();
+  auto type = reader->typeWithId();
+  RowReaderOptions rowReaderOpts;
+  auto rowType = reader->rowType();
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto result = BaseVector::create(rowType, 10, leafPool_.get());
+  constexpr int kBatchSize = 1000;
+  while (rowReader->next(kBatchSize, result)) {
+  }
+}
+
+TEST_F(ParquetReaderTest, struct_of_array_of_array) {
+  //  The Schema is of type
+  //  message hive_schema {
+  //    optional group test {
+  //      optional group stringarrayfield (LIST) {
+  //        repeated group array (LIST) {
+  //          repeated binary array (UTF8);
+  //        }
+  //      }
+  //      optional group intarrayfield (LIST) {
+  //        repeated group array (LIST) {
+  //          repeated int32 array;
+  //        }
+  //      }
+  //    }
+  //  }
+  const std::string expectedVeloxType =
+      "ROW<test:ROW<stringarrayfield:ARRAY<ARRAY<VARCHAR>>,intarrayfield:ARRAY<ARRAY<INTEGER>>>>";
+  const std::string sample(
+      getExampleFilePath("struct_of_array_of_array.parquet"));
+  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  auto numRows = reader->numberOfRows();
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 1ULL);
+  EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
+
+  auto test_column = type->childAt(0);
+  EXPECT_EQ(test_column->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(type->childByName("test"), test_column);
+
+  // test_column has 2 children
+  EXPECT_EQ(test_column->size(), 2ULL);
+  // explore 1st child of test_column
+  auto stringarrayfield_column = test_column->childAt(0);
+  EXPECT_EQ(stringarrayfield_column->type()->kind(), TypeKind::ARRAY);
+
+  // stringarrayfield_column column has 1 child
+  EXPECT_EQ(stringarrayfield_column->size(), 1ULL);
+  // explore 1st child of stringarrayfield_column
+  auto array_column = stringarrayfield_column->childAt(0);
+  EXPECT_EQ(array_column->type()->kind(), TypeKind::ARRAY);
+
+  // array_column column has 1 child
+  EXPECT_EQ(array_column->size(), 1ULL);
+  // explore 1st child of array_column
+  auto array_leaf_column = array_column->childAt(0);
+  EXPECT_EQ(array_leaf_column->type()->kind(), TypeKind::VARCHAR);
+
+  // explore 2nd child of test_column
+  auto intarrayfield_column = test_column->childAt(1);
+  EXPECT_EQ(intarrayfield_column->type()->kind(), TypeKind::ARRAY);
+  EXPECT_EQ(test_column->childByName("intarrayfield"), intarrayfield_column);
+
+  // intarrayfield_column column has 1 child
+  EXPECT_EQ(intarrayfield_column->size(), 1ULL);
+  // explore 1st child of intarrayfield_column
+  auto array_column_for_intarrayfield = intarrayfield_column->childAt(0);
+  EXPECT_EQ(array_column_for_intarrayfield->type()->kind(), TypeKind::ARRAY);
+
+  // array_column_for_intarrayfield column has 1 child
+  EXPECT_EQ(array_column_for_intarrayfield->size(), 1ULL);
+  // explore 1st child
+  auto array_leaf_column_for_intarrayfield =
+      array_column_for_intarrayfield->childAt(0);
+  EXPECT_EQ(
+      array_leaf_column_for_intarrayfield->type()->kind(), TypeKind::INTEGER);
+
+  RowReaderOptions rowReaderOpts;
+  auto rowType =
+      ROW({"test"},
+          {ROW(
+              {"stringarrayfield", "intarrayfield"},
+              {ARRAY(ARRAY(VARCHAR())), ARRAY(ARRAY(INTEGER()))})});
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto result = BaseVector::create(rowType, 10, leafPool_.get());
+  constexpr int kBatchSize = 1000;
+  while (rowReader->next(kBatchSize, result)) {
+  }
+}
+
+TEST_F(ParquetReaderTest, testLzoDataPage) {
+  const std::string sample(getExampleFilePath("lzo.parquet"));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 23'547ULL);
+
+  auto outputRowType = ROW(
+      {"test"},
+      {ROW({"intfield", "stringarrayfield"}, {INTEGER(), ARRAY(VARCHAR())})});
+  auto rowReaderOpts = getReaderOpts(outputRowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(outputRowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  uint64_t total = 0;
+  VectorPtr result = BaseVector::create(outputRowType, 0, &*leafPool_);
+  rowReader->next(23'547ULL, result);
+  EXPECT_EQ(23'547ULL, result->size());
+  auto* rowVector = result->asUnchecked<RowVector>();
+  auto* values =
+      rowVector->childAt(0)->loadedVector()->asUnchecked<RowVector>();
+  auto* intField = values->childAt(0)->loadedVector()->asFlatVector<int32_t>();
+  auto* stringArray = values->childAt(1)->loadedVector()->as<ArrayVector>();
+  EXPECT_EQ(intField->valueAt(0), 1);
+  EXPECT_EQ(intField->valueAt(23'546), 13);
+  EXPECT_EQ(
+      stringArray->elements()->asFlatVector<StringView>()->valueAt(0).str(),
+      "0");
+  EXPECT_EQ(
+      stringArray->elements()
+          ->asFlatVector<StringView>()
+          ->valueAt(31'232)
+          .str(),
+      "31232");
+}
+
+TEST_F(ParquetReaderTest, testEmptyV2DataPage) {
+  const std::string sample(getExampleFilePath("empty_v2datapage.parquet"));
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->numberOfRows(), 30001ULL);
+
+  auto outputRowType = ROW({"test"}, {REAL()});
+  EXPECT_EQ(*(reader->typeWithId()->type()), *outputRowType);
+
+  auto rowReaderOpts = getReaderOpts(outputRowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(outputRowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = makeRowVector({makeFlatVector<float>(
+      30001, [](auto /*row*/) { return 1; }, nullEvery(1))});
+
+  assertReadWithReaderAndExpected(
+      outputRowType, *rowReader, expected, *leafPool_);
+}
diff --git a/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp b/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
index 7a40045b135f3..faa9833a9af74 100644
--- a/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
@@ -17,17 +17,23 @@
 #include <folly/init/Init.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/dwio/common/tests/utils/DataFiles.h"
-#include "velox/dwio/parquet/RegisterParquetReader.h"
-#include "velox/dwio/parquet/reader/ParquetReader.h"
-#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/dwio/common/tests/utils/DataFiles.h" // @manual
+#include "velox/dwio/parquet/RegisterParquetReader.h" // @manual
+#include "velox/dwio/parquet/reader/PageReader.h" // @manual
+#include "velox/dwio/parquet/reader/ParquetReader.h" // @manual=//velox/connectors/hive:velox_hive_connector_parquet
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h" // @manual
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/external/date/tz.h"
 #include "velox/type/tests/SubfieldFiltersBuilder.h"
+#include "velox/type/tz/TimeZoneMap.h"
 
-#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HiveConfig.h" // @manual=//velox/connectors/hive:velox_hive_connector_parquet
+#include "velox/dwio/parquet/writer/Writer.h" // @manual
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
+using namespace facebook::velox::connector::hive;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::parquet;
 
@@ -36,12 +42,16 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
   using OperatorTestBase::assertQuery;
 
   void SetUp() {
+    OperatorTestBase::SetUp();
     registerParquetReaderFactory();
 
     auto hiveConnector =
         connector::getConnectorFactory(
             connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(kHiveConnectorId, nullptr);
+            ->newConnector(
+                kHiveConnectorId,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
     connector::registerConnector(hiveConnector);
   }
 
@@ -55,19 +65,36 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
     assertQuery(plan, splits_, sql);
   }
 
+  void assertSelectWithAssignments(
+      std::vector<std::string>&& outputColumnNames,
+      std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>&
+          assignments,
+      const std::string& sql) {
+    auto rowType = getRowType(std::move(outputColumnNames));
+    auto plan = PlanBuilder()
+                    .tableScan(rowType, {}, "", nullptr, assignments)
+                    .planNode();
+    assertQuery(plan, splits_, sql);
+  }
+
   void assertSelectWithFilter(
       std::vector<std::string>&& outputColumnNames,
       const std::vector<std::string>& subfieldFilters,
       const std::string& remainingFilter,
-      const std::string& sql) {
+      const std::string& sql,
+      const std::unordered_map<
+          std::string,
+          std::shared_ptr<connector::ColumnHandle>>& assignments = {}) {
     auto rowType = getRowType(std::move(outputColumnNames));
     parse::ParseOptions options;
     options.parseDecimalAsDouble = false;
 
-    auto plan = PlanBuilder(pool_.get())
-                    .setParseOptions(options)
-                    .tableScan(rowType, subfieldFilters, remainingFilter)
-                    .planNode();
+    auto plan =
+        PlanBuilder(pool_.get())
+            .setParseOptions(options)
+            .tableScan(
+                rowType, subfieldFilters, remainingFilter, nullptr, assignments)
+            .planNode();
 
     assertQuery(plan, splits_, sql);
   }
@@ -103,22 +130,95 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
     assertQuery(plan, splits_, sql);
   }
 
-  void
-  loadData(const std::string& filePath, RowTypePtr rowType, RowVectorPtr data) {
-    splits_ = {makeSplit(filePath)};
+  void assertSelectWithTimezone(
+      std::vector<std::string>&& outputColumnNames,
+      const std::string& sql,
+      const std::string& sessionTimezone) {
+    auto rowType = getRowType(std::move(outputColumnNames));
+    auto plan = PlanBuilder().tableScan(rowType).planNode();
+    std::vector<exec::Split> splits;
+    splits.reserve(splits_.size());
+    for (const auto& connectorSplit : splits_) {
+      splits.emplace_back(folly::copy(connectorSplit), -1);
+    }
+
+    AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .config(core::QueryConfig::kSessionTimezone, sessionTimezone)
+        .splits(splits)
+        .assertResults(sql);
+  }
+
+  void loadData(
+      const std::string& filePath,
+      RowTypePtr rowType,
+      RowVectorPtr data,
+      const std::optional<
+          std::unordered_map<std::string, std::optional<std::string>>>&
+          partitionKeys = std::nullopt,
+      const std::optional<std::unordered_map<std::string, std::string>>&
+          infoColumns = std::nullopt) {
+    splits_ = {makeSplit(filePath, partitionKeys, infoColumns)};
     rowType_ = rowType;
     createDuckDbTable({data});
   }
 
+  void loadDataWithRowType(const std::string& filePath, RowVectorPtr data) {
+    splits_ = {makeSplit(filePath)};
+    auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
+    dwio::common::ReaderOptions readerOpts{pool.get()};
+    auto reader = std::make_unique<ParquetReader>(
+        std::make_unique<facebook::velox::dwio::common::BufferedInput>(
+            std::make_shared<LocalReadFile>(filePath), readerOpts.memoryPool()),
+        readerOpts);
+    rowType_ = reader->rowType();
+    createDuckDbTable({data});
+  }
+
   std::string getExampleFilePath(const std::string& fileName) {
     return facebook::velox::test::getDataFilePath(
         "velox/dwio/parquet/tests/reader", "../examples/" + fileName);
   }
 
   std::shared_ptr<connector::hive::HiveConnectorSplit> makeSplit(
-      const std::string& filePath) {
+      const std::string& filePath,
+      const std::optional<
+          std::unordered_map<std::string, std::optional<std::string>>>&
+          partitionKeys = std::nullopt,
+      const std::optional<std::unordered_map<std::string, std::string>>&
+          infoColumns = std::nullopt) {
     return makeHiveConnectorSplits(
-        filePath, 1, dwio::common::FileFormat::PARQUET)[0];
+        filePath,
+        1,
+        dwio::common::FileFormat::PARQUET,
+        partitionKeys,
+        infoColumns)[0];
+  }
+
+  // Write data to a parquet file on specified path.
+  // @param writeInt96AsTimestamp Write timestamp as Int96 if enabled.
+  void writeToParquetFile(
+      const std::string& path,
+      const std::vector<RowVectorPtr>& data,
+      bool writeInt96AsTimestamp) {
+    VELOX_CHECK_GT(data.size(), 0);
+
+    WriterOptions options;
+    options.writeInt96AsTimestamp = writeInt96AsTimestamp;
+
+    auto writeFile = std::make_unique<LocalWriteFile>(path, true, false);
+    auto sink = std::make_unique<dwio::common::WriteFileSink>(
+        std::move(writeFile), path);
+    auto childPool =
+        rootPool_->addAggregateChild("ParquetTableScanTest.Writer");
+    options.memoryPool = childPool.get();
+
+    auto writer = std::make_unique<Writer>(
+        std::move(sink), options, asRowType(data[0]->type()));
+
+    for (const auto& vector : data) {
+      writer->write(vector);
+    }
+    writer->close();
   }
 
  private:
@@ -212,6 +312,26 @@ TEST_F(ParquetTableScanTest, basic) {
       "SELECT max(b), a FROM tmp WHERE a < 3 GROUP BY a");
 }
 
+TEST_F(ParquetTableScanTest, lazy) {
+  auto filePath = getExampleFilePath("sample.parquet");
+  auto schema = ROW({"a", "b"}, {BIGINT(), DOUBLE()});
+  CursorParameters params;
+  params.copyResult = false;
+  params.planNode = PlanBuilder().tableScan(schema).planNode();
+  auto cursor = TaskCursor::create(params);
+  cursor->task()->addSplit("0", exec::Split(makeSplit(filePath)));
+  cursor->task()->noMoreSplits("0");
+  int rows = 0;
+  while (cursor->moveNext()) {
+    auto* result = cursor->current()->asUnchecked<RowVector>();
+    ASSERT_TRUE(result->childAt(0)->isLazy());
+    ASSERT_TRUE(result->childAt(1)->isLazy());
+    rows += result->size();
+  }
+  ASSERT_EQ(rows, 20);
+  ASSERT_TRUE(waitForTaskCompletion(cursor->task().get()));
+}
+
 TEST_F(ParquetTableScanTest, countStar) {
   // sample.parquet holds two columns (a: BIGINT, b: DOUBLE) and
   // 20 rows.
@@ -270,7 +390,6 @@ TEST_F(ParquetTableScanTest, decimalSubfieldFilter) {
       "Scalar function signature is not supported: eq(DECIMAL(5, 2), DECIMAL(5, 1))");
 }
 
-// Core dump is fixed.
 TEST_F(ParquetTableScanTest, map) {
   auto vector = makeMapVector<StringView, StringView>({{{"name", "gluten"}}});
 
@@ -286,7 +405,19 @@ TEST_F(ParquetTableScanTest, map) {
   assertSelectWithFilter({"map"}, {}, "", "SELECT map FROM tmp");
 }
 
-// Core dump is fixed.
+TEST_F(ParquetTableScanTest, nullMap) {
+  auto path = getExampleFilePath("null_map.parquet");
+  loadData(
+      path,
+      ROW({"i", "c"}, {VARCHAR(), MAP(VARCHAR(), VARCHAR())}),
+      makeRowVector(
+          {"i", "c"},
+          {makeConstant<std::string>("1", 1),
+           makeNullableMapVector<std::string, std::string>({std::nullopt})}));
+
+  assertSelectWithFilter({"i", "c"}, {}, "", "SELECT i, c FROM tmp");
+}
+
 TEST_F(ParquetTableScanTest, singleRowStruct) {
   auto vector = makeArrayVector<int32_t>({{}});
   loadData(
@@ -301,10 +432,8 @@ TEST_F(ParquetTableScanTest, singleRowStruct) {
   assertSelectWithFilter({"s"}, {}, "", "SELECT (0, 1)");
 }
 
-// Core dump and incorrect result are fixed.
-TEST_F(ParquetTableScanTest, DISABLED_array) {
-  auto vector = makeArrayVector<int32_t>({{1, 2, 3}});
-
+TEST_F(ParquetTableScanTest, array) {
+  auto vector = makeArrayVector<int32_t>({});
   loadData(
       getExampleFilePath("old_repeated_int.parquet"),
       ROW({"repeatedInt"}, {ARRAY(INTEGER())}),
@@ -315,12 +444,11 @@ TEST_F(ParquetTableScanTest, DISABLED_array) {
           }));
 
   assertSelectWithFilter(
-      {"repeatedInt"}, {}, "", "SELECT repeatedInt FROM tmp");
+      {"repeatedInt"}, {}, "", "SELECT UNNEST(array[array[1,2,3]])");
 }
 
 // Optional array with required elements.
-// Incorrect result.
-TEST_F(ParquetTableScanTest, DISABLED_optArrayReqEle) {
+TEST_F(ParquetTableScanTest, optArrayReqEle) {
   auto vector = makeArrayVector<StringView>({});
 
   loadData(
@@ -340,8 +468,7 @@ TEST_F(ParquetTableScanTest, DISABLED_optArrayReqEle) {
 }
 
 // Required array with required elements.
-// Core dump is fixed, but the result is incorrect.
-TEST_F(ParquetTableScanTest, DISABLED_reqArrayReqEle) {
+TEST_F(ParquetTableScanTest, reqArrayReqEle) {
   auto vector = makeArrayVector<StringView>({});
 
   loadData(
@@ -361,8 +488,7 @@ TEST_F(ParquetTableScanTest, DISABLED_reqArrayReqEle) {
 }
 
 // Required array with optional elements.
-// Incorrect result.
-TEST_F(ParquetTableScanTest, DISABLED_reqArrayOptEle) {
+TEST_F(ParquetTableScanTest, reqArrayOptEle) {
   auto vector = makeArrayVector<StringView>({});
 
   loadData(
@@ -381,27 +507,59 @@ TEST_F(ParquetTableScanTest, DISABLED_reqArrayOptEle) {
       "SELECT UNNEST(array[array['a', null], array[], array[null, 'b']])");
 }
 
+TEST_F(ParquetTableScanTest, arrayOfArrayTest) {
+  auto vector = makeArrayVector<StringView>({});
+
+  loadDataWithRowType(
+      getExampleFilePath("array_of_array1.parquet"),
+      makeRowVector(
+          {"_1"},
+          {
+              vector,
+          }));
+
+  assertSelectWithFilter(
+      {"_1"},
+      {},
+      "",
+      "SELECT UNNEST(array[null, array[array['g', 'h'], null]])");
+}
+
 // Required array with legacy format.
-// Incorrect result.
-TEST_F(ParquetTableScanTest, DISABLED_reqArrayLegacy) {
+TEST_F(ParquetTableScanTest, reqArrayLegacy) {
   auto vector = makeArrayVector<StringView>({});
 
   loadData(
       getExampleFilePath("array_3.parquet"),
-      ROW({"_1"}, {ARRAY(VARCHAR())}),
+      ROW({"element"}, {ARRAY(VARCHAR())}),
       makeRowVector(
-          {"_1"},
+          {"element"},
           {
               vector,
           }));
 
   assertSelectWithFilter(
-      {"_1"},
+      {"element"},
       {},
       "",
       "SELECT UNNEST(array[array['a', 'b'], array[], array['c', 'd']])");
 }
 
+TEST_F(ParquetTableScanTest, filterOnNestedArray) {
+  loadData(
+      getExampleFilePath("struct_of_array.parquet"),
+      ROW({"struct"},
+          {ROW({"a0", "a1"}, {ARRAY(VARCHAR()), ARRAY(INTEGER())})}),
+      makeRowVector(
+          {"unused"},
+          {
+              makeFlatVector<int32_t>({}),
+          }));
+
+  assertSelectWithFilter(
+      {"struct"}, {}, "struct.a0 is null", "SELECT ROW(NULL, NULL)");
+}
+
 TEST_F(ParquetTableScanTest, readAsLowerCase) {
   auto plan = PlanBuilder(pool_.get())
                   .tableScan(ROW({"a"}, {BIGINT()}), {}, "")
@@ -411,13 +569,13 @@ TEST_F(ParquetTableScanTest, readAsLowerCase) {
       std::make_shared<folly::CPUThreadPoolExecutor>(
           std::thread::hardware_concurrency());
   std::shared_ptr<core::QueryCtx> queryCtx =
-      std::make_shared<core::QueryCtx>(executor.get());
-  std::unordered_map<std::string, std::string> configs = {
+      core::QueryCtx::create(executor.get());
+  std::unordered_map<std::string, std::string> session = {
       {std::string(
-           connector::hive::HiveConfig::kFileColumnNamesReadAsLowerCase),
+           connector::hive::HiveConfig::kFileColumnNamesReadAsLowerCaseSession),
        "true"}};
-  queryCtx->setConnectorConfigOverridesUnsafe(
-      kHiveConnectorId, std::move(configs));
+  queryCtx->setConnectorSessionOverridesUnsafe(
+      kHiveConnectorId, std::move(session));
   params.queryCtx = queryCtx;
   params.planNode = plan;
   const int numSplitsPerFile = 1;
@@ -442,8 +600,276 @@ TEST_F(ParquetTableScanTest, readAsLowerCase) {
       result.second, {makeRowVector({"a"}, {makeFlatVector<int64_t>({0, 1})})});
 }
 
+TEST_F(ParquetTableScanTest, rowIndex) {
+  static const char* kPath = "file_path";
+  // case 1: file not have `_tmp_metadata_row_index`, scan generate it for user.
+  auto filePath = getExampleFilePath("sample.parquet");
+  loadData(
+      filePath,
+      ROW({"a", "b", "_tmp_metadata_row_index", kPath},
+          {BIGINT(), DOUBLE(), BIGINT(), VARCHAR()}),
+      makeRowVector(
+          {"a", "b", "_tmp_metadata_row_index", kPath},
+          {
+              makeFlatVector<int64_t>(20, [](auto row) { return row + 1; }),
+              makeFlatVector<double>(20, [](auto row) { return row + 1; }),
+              makeFlatVector<int64_t>(20, [](auto row) { return row; }),
+              makeFlatVector<std::string>(
+                  20, [filePath](auto row) { return filePath; }),
+          }),
+      std::nullopt,
+      std::unordered_map<std::string, std::string>{{kPath, filePath}});
+  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+      assignments;
+  assignments["a"] = std::make_shared<connector::hive::HiveColumnHandle>(
+      "a",
+      connector::hive::HiveColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      BIGINT());
+  assignments["b"] = std::make_shared<connector::hive::HiveColumnHandle>(
+      "b",
+      connector::hive::HiveColumnHandle::ColumnType::kRegular,
+      DOUBLE(),
+      DOUBLE());
+  assignments[kPath] = synthesizedColumn(kPath, VARCHAR());
+  assignments["_tmp_metadata_row_index"] =
+      std::make_shared<connector::hive::HiveColumnHandle>(
+          "_tmp_metadata_row_index",
+          connector::hive::HiveColumnHandle::ColumnType::kRowIndex,
+          BIGINT(),
+          BIGINT());
+
+  assertSelect({"a"}, "SELECT a FROM tmp");
+  assertSelectWithAssignments(
+      {"a", "_tmp_metadata_row_index"},
+      assignments,
+      "SELECT a, _tmp_metadata_row_index FROM tmp");
+  assertSelectWithAssignments(
+      {"_tmp_metadata_row_index", "a"},
+      assignments,
+      "SELECT _tmp_metadata_row_index, a FROM tmp");
+  assertSelectWithAssignments(
+      {"_tmp_metadata_row_index"},
+      assignments,
+      "SELECT _tmp_metadata_row_index FROM tmp");
+  assertSelectWithAssignments(
+      {kPath, "_tmp_metadata_row_index"},
+      assignments,
+      fmt::format("SELECT {}, _tmp_metadata_row_index FROM tmp", kPath));
+
+  // case 2: file has `_tmp_metadata_row_index` column, then use user data
+  // insteads of generating it.
+  loadData(
+      getExampleFilePath("sample_with_rowindex.parquet"),
+      ROW({"a", "b", "_tmp_metadata_row_index"},
+          {BIGINT(), DOUBLE(), BIGINT()}),
+      makeRowVector(
+          {"a", "b", "_tmp_metadata_row_index"},
+          {
+              makeFlatVector<int64_t>(20, [](auto row) { return row + 1; }),
+              makeFlatVector<double>(20, [](auto row) { return row + 1; }),
+              makeFlatVector<int64_t>(20, [](auto row) { return row + 1; }),
+          }));
+
+  assertSelect({"a"}, "SELECT a FROM tmp");
+  assertSelect(
+      {"a", "_tmp_metadata_row_index"},
+      "SELECT a, _tmp_metadata_row_index FROM tmp");
+}
+
+// The file icebergNullIcebergPartition.parquet was copied from a null
+// partition in an Iceberg table created with the below DDL using Spark:
+//
+// CREATE TABLE iceberg_tmp_parquet_partitioned
+//    ( c0 bigint, c1 bigint )
+// USING iceberg
+// PARTITIONED BY (c1)
+// TBLPROPERTIES ('write.format.default' = 'parquet', 'format-version' = 2,
+// 'write.delete.mode' = 'merge-on-read') LOCATION
+// 's3a://presto-workload/tmp/iceberg_tmp_parquet_partitioned';
+//
+// INSERT INTO iceberg_tmp_parquet_partitioned
+// VALUES (1, 1), (2, null),(3, null);
+TEST_F(ParquetTableScanTest, filterNullIcebergPartition) {
+  loadData(
+      getExampleFilePath("icebergNullIcebergPartition.parquet"),
+      ROW({"c0", "c1"}, {BIGINT(), BIGINT()}),
+      makeRowVector(
+          {"c0", "c1"},
+          {
+              makeFlatVector<int64_t>(std::vector<int64_t>{2, 3}),
+              makeNullableFlatVector<int64_t>({std::nullopt, std::nullopt}),
+          }),
+      std::unordered_map<std::string, std::optional<std::string>>{
+          {"c1", std::nullopt}});
+
+  std::shared_ptr<connector::ColumnHandle> c0 = makeColumnHandle(
+      "c0", BIGINT(), BIGINT(), {}, HiveColumnHandle::ColumnType::kRegular);
+  std::shared_ptr<connector::ColumnHandle> c1 = makeColumnHandle(
+      "c1",
+      BIGINT(),
+      BIGINT(),
+      {},
+      HiveColumnHandle::ColumnType::kPartitionKey);
+
+  assertSelectWithFilter(
+      {"c0", "c1"},
+      {"c1 IS NOT NULL"},
+      "",
+      "SELECT c0, c1 FROM tmp WHERE c1 IS NOT NULL",
+      std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>{
+          {"c0", c0}, {"c1", c1}});
+
+  assertSelectWithFilter(
+      {"c0", "c1"},
+      {"c1 IS NULL"},
+      "",
+      "SELECT c0, c1 FROM tmp WHERE c1 IS NULL",
+      std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>{
+          {"c0", c0}, {"c1", c1}});
+}
+
+TEST_F(ParquetTableScanTest, sessionTimezone) {
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::parquet::PageReader::readPageHeader",
+      std::function<void(PageReader*)>(([&](PageReader* reader) {
+        VELOX_CHECK_EQ(reader->sessionTimezone()->name(), "Asia/Shanghai");
+      })));
+
+  // Read sample.parquet to verify if the sessionTimezone in the PageReader
+  // meets expectations.
+  loadData(
+      getExampleFilePath("sample.parquet"),
+      ROW({"a", "b"}, {BIGINT(), DOUBLE()}),
+      makeRowVector(
+          {"a", "b"},
+          {
+              makeFlatVector<int64_t>(20, [](auto row) { return row + 1; }),
+              makeFlatVector<double>(20, [](auto row) { return row + 1; }),
+          }));
+
+  assertSelectWithTimezone({"a"}, "SELECT a FROM tmp", "Asia/Shanghai");
+}
+
+TEST_F(ParquetTableScanTest, timestampFilter) {
+  // Timestamp-int96.parquet holds one column (t: TIMESTAMP) and
+  // 10 rows in one row group. Data is in SNAPPY compressed format.
+  // The values are:
+  // |t                  |
+  // +-------------------+
+  // |2015-06-01 19:34:56|
+  // |2015-06-02 19:34:56|
+  // |2001-02-03 03:34:06|
+  // |1998-03-01 08:01:06|
+  // |2022-12-23 03:56:01|
+  // |1980-01-24 00:23:07|
+  // |1999-12-08 13:39:26|
+  // |2023-04-21 09:09:34|
+  // |2000-09-12 22:36:29|
+  // |2007-12-12 04:27:56|
+  // +-------------------+
+  auto vector = makeFlatVector<Timestamp>(
+      {Timestamp(1433187296, 0),
+       Timestamp(1433273696, 0),
+       Timestamp(981171246, 0),
+       Timestamp(888739266, 0),
+       Timestamp(1671767761, 0),
+       Timestamp(317521387, 0),
+       Timestamp(944660366, 0),
+       Timestamp(1682068174, 0),
+       Timestamp(968798189, 0),
+       Timestamp(1197433676, 0)});
+
+  loadData(
+      getExampleFilePath("timestamp_int96.parquet"),
+      ROW({"t"}, {TIMESTAMP()}),
+      makeRowVector(
+          {"t"},
+          {
+              vector,
+          }));
+
+  assertSelectWithFilter({"t"}, {}, "", "SELECT t from tmp");
+  assertSelectWithFilter(
+      {"t"},
+      {},
+      "t < TIMESTAMP '2000-09-12 22:36:29'",
+      "SELECT t from tmp where t < TIMESTAMP '2000-09-12 22:36:29'");
+  assertSelectWithFilter(
+      {"t"},
+      {},
+      "t <= TIMESTAMP '2000-09-12 22:36:29'",
+      "SELECT t from tmp where t <= TIMESTAMP '2000-09-12 22:36:29'");
+  assertSelectWithFilter(
+      {"t"},
+      {},
+      "t > TIMESTAMP '1980-01-24 00:23:07'",
+      "SELECT t from tmp where t > TIMESTAMP '1980-01-24 00:23:07'");
+  assertSelectWithFilter(
+      {"t"},
+      {},
+      "t >= TIMESTAMP '1980-01-24 00:23:07'",
+      "SELECT t from tmp where t >= TIMESTAMP '1980-01-24 00:23:07'");
+  assertSelectWithFilter(
+      {"t"},
+      {},
+      "t == TIMESTAMP '2022-12-23 03:56:01'",
+      "SELECT t from tmp where t == TIMESTAMP '2022-12-23 03:56:01'");
+}
+
+TEST_F(ParquetTableScanTest, timestampPrecisionMicrosecond) {
+  // Write timestamp data into parquet.
+  constexpr int kSize = 10;
+  auto vector = makeRowVector({
+      makeFlatVector<Timestamp>(
+          kSize, [](auto i) { return Timestamp(i, i * 1'001'001); }),
+  });
+  auto schema = asRowType(vector->type());
+  auto file = TempFilePath::create();
+  writeToParquetFile(file->getPath(), {vector}, true);
+  auto plan = PlanBuilder().tableScan(schema).planNode();
+
+  // Read timestamp data from parquet with microsecond precision.
+  CursorParameters params;
+  std::shared_ptr<folly::Executor> executor =
+      std::make_shared<folly::CPUThreadPoolExecutor>(
+          std::thread::hardware_concurrency());
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      core::QueryCtx::create(executor.get());
+  std::unordered_map<std::string, std::string> session = {
+      {std::string(connector::hive::HiveConfig::kReadTimestampUnitSession),
+       "6"}};
+  queryCtx->setConnectorSessionOverridesUnsafe(
+      kHiveConnectorId, std::move(session));
+  params.queryCtx = queryCtx;
+  params.planNode = plan;
+  const int numSplitsPerFile = 1;
+
+  bool noMoreSplits = false;
+  auto addSplits = [&](exec::Task* task) {
+    if (!noMoreSplits) {
+      auto const splits = HiveConnectorTestBase::makeHiveConnectorSplits(
+          {file->getPath()},
+          numSplitsPerFile,
+          dwio::common::FileFormat::PARQUET);
+      for (const auto& split : splits) {
+        task->addSplit("0", exec::Split(split));
+      }
+      task->noMoreSplits("0");
+    }
+    noMoreSplits = true;
+  };
+  auto result = readCursor(params, addSplits);
+  ASSERT_TRUE(waitForTaskCompletion(result.first->task().get()));
+  auto expected = makeRowVector({
+      makeFlatVector<Timestamp>(
+          kSize, [](auto i) { return Timestamp(i, i * 1'001'000); }),
+  });
+  assertEqualResults({expected}, result.second);
+}
+
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/dwio/parquet/tests/thrift/CMakeLists.txt b/velox/dwio/parquet/tests/thrift/CMakeLists.txt
index c81df362a8d39..3c3af4113645d 100644
--- a/velox/dwio/parquet/tests/thrift/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/thrift/CMakeLists.txt
@@ -15,5 +15,10 @@
 add_executable(velox_dwio_parquet_thrift_test ThriftTransportTest.cpp)
 
 add_test(velox_dwio_parquet_thrift_test velox_dwio_parquet_thrift_test)
-target_link_libraries(velox_dwio_parquet_thrift_test arrow thrift
-                      velox_link_libs gtest gtest_main)
+target_link_libraries(
+  velox_dwio_parquet_thrift_test
+  arrow
+  thrift
+  velox_link_libs
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/dwio/parquet/tests/thrift/ThriftTransportTest.cpp b/velox/dwio/parquet/tests/thrift/ThriftTransportTest.cpp
index 2fed88512f6d5..489b721aff674 100644
--- a/velox/dwio/parquet/tests/thrift/ThriftTransportTest.cpp
+++ b/velox/dwio/parquet/tests/thrift/ThriftTransportTest.cpp
@@ -55,8 +55,8 @@ class ThriftTransportTest : public testing::Test {
   static constexpr uint32_t batchSize_ = 20;
   std::vector<uint8_t> input_;
   std::vector<uint8_t> output_;
-  const char* FOLLY_NULLABLE bufferStart_{nullptr};
-  const char* FOLLY_NULLABLE bufferEnd_{nullptr};
+  const char* bufferStart_{nullptr};
+  const char* bufferEnd_{nullptr};
   std::shared_ptr<SeekableInputStream> inputStream_;
   std::shared_ptr<ThriftTransport> transport_;
 };
@@ -106,6 +106,6 @@ TEST_F(ThriftTransportTest, bufferedOutOfBoundry) {
 // Define main so that gflags get processed.
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/dwio/parquet/tests/writer/CMakeLists.txt b/velox/dwio/parquet/tests/writer/CMakeLists.txt
index 527612f5c0edf..01e718dc22c46 100644
--- a/velox/dwio/parquet/tests/writer/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/writer/CMakeLists.txt
@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_parquet_writer_sink_test SinkTests.cpp
-                                              ParquetWriterTestBase.cpp)
+add_executable(velox_parquet_writer_sink_test SinkTests.cpp)
 
 add_test(
   NAME velox_parquet_writer_sink_test
@@ -25,11 +24,27 @@ target_link_libraries(
   velox_dwio_parquet_writer
   velox_dwio_common_test_utils
   velox_vector_fuzzer
-  velox_exec_test_lib
-  velox_temp_path
   Boost::regex
   velox_link_libs
   Folly::folly
   ${TEST_LINK_LIBS}
-  gtest
+  GTest::gtest
+  fmt::fmt)
+
+add_executable(velox_parquet_writer_test ParquetWriterTest.cpp)
+
+add_test(
+  NAME velox_parquet_writer_test
+  COMMAND velox_parquet_writer_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(
+  velox_parquet_writer_test
+  velox_dwio_parquet_writer
+  velox_dwio_common_test_utils
+  velox_link_libs
+  Boost::regex
+  Folly::folly
+  ${TEST_LINK_LIBS}
+  GTest::gtest
   fmt::fmt)
diff --git a/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp b/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp
new file mode 100644
index 0000000000000..87a7c6f0421d1
--- /dev/null
+++ b/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <arrow/type.h>
+#include <folly/init/Init.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/hive/HiveConnector.h" // @manual
+#include "velox/core/QueryCtx.h"
+#include "velox/dwio/parquet/RegisterParquetWriter.h" // @manual
+#include "velox/dwio/parquet/tests/ParquetTestBase.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/Cursor.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+
+namespace {
+
+using namespace facebook::velox;
+using namespace facebook::velox::common;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::parquet;
+
+class ParquetWriterTest : public ParquetTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+    testutil::TestValue::enable();
+    auto hiveConnector =
+        connector::getConnectorFactory(
+            connector::hive::HiveConnectorFactory::kHiveConnectorName)
+            ->newConnector(
+                kHiveConnectorId,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
+    connector::registerConnector(hiveConnector);
+    parquet::registerParquetWriterFactory();
+  }
+
+  std::unique_ptr<RowReader> createRowReaderWithSchema(
+      const std::unique_ptr<Reader> reader,
+      const RowTypePtr& rowType) {
+    auto rowReaderOpts = getReaderOpts(rowType);
+    auto scanSpec = makeScanSpec(rowType);
+    rowReaderOpts.setScanSpec(scanSpec);
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    return rowReader;
+  };
+
+  std::unique_ptr<facebook::velox::parquet::ParquetReader> createReaderInMemory(
+      const dwio::common::MemorySink& sink,
+      const dwio::common::ReaderOptions& opts) {
+    std::string data(sink.data(), sink.size());
+    return std::make_unique<facebook::velox::parquet::ParquetReader>(
+        std::make_unique<dwio::common::BufferedInput>(
+            std::make_shared<InMemoryReadFile>(std::move(data)),
+            opts.memoryPool()),
+        opts);
+  };
+
+  inline static const std::string kHiveConnectorId = "test-hive";
+};
+
+std::vector<CompressionKind> params = {
+    CompressionKind::CompressionKind_NONE,
+    CompressionKind::CompressionKind_SNAPPY,
+    CompressionKind::CompressionKind_ZSTD,
+    CompressionKind::CompressionKind_LZ4,
+    CompressionKind::CompressionKind_GZIP,
+};
+
+TEST_F(ParquetWriterTest, compression) {
+  auto schema =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6"},
+          {INTEGER(),
+           DOUBLE(),
+           BIGINT(),
+           INTEGER(),
+           BIGINT(),
+           INTEGER(),
+           DOUBLE()});
+  const int64_t kRows = 10'000;
+  const auto data = makeRowVector({
+      makeFlatVector<int32_t>(kRows, [](auto row) { return row + 5; }),
+      makeFlatVector<double>(kRows, [](auto row) { return row - 10; }),
+      makeFlatVector<int64_t>(kRows, [](auto row) { return row - 15; }),
+      makeFlatVector<uint32_t>(kRows, [](auto row) { return row + 20; }),
+      makeFlatVector<uint64_t>(kRows, [](auto row) { return row + 25; }),
+      makeFlatVector<int32_t>(kRows, [](auto row) { return row + 30; }),
+      makeFlatVector<double>(kRows, [](auto row) { return row - 25; }),
+  });
+
+  // Create an in-memory writer
+  auto sink = std::make_unique<MemorySink>(
+      200 * 1024 * 1024,
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto sinkPtr = sink.get();
+  facebook::velox::parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.compressionKind = CompressionKind::CompressionKind_SNAPPY;
+
+  const auto& fieldNames = schema->names();
+
+  for (int i = 0; i < params.size(); i++) {
+    writerOptions.columnCompressionsMap[fieldNames[i]] = params[i];
+  }
+
+  auto writer = std::make_unique<facebook::velox::parquet::Writer>(
+      std::move(sink), writerOptions, rootPool_, schema);
+  writer->write(data);
+  writer->close();
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReaderInMemory(*sinkPtr, readerOptions);
+
+  ASSERT_EQ(reader->numberOfRows(), kRows);
+  ASSERT_EQ(*reader->rowType(), *schema);
+
+  for (int i = 0; i < params.size(); i++) {
+    EXPECT_EQ(
+        reader->fileMetaData().rowGroup(0).columnChunk(i).compression(),
+        (i < params.size()) ? params[i]
+                            : CompressionKind::CompressionKind_SNAPPY);
+  }
+
+  auto rowReader = createRowReaderWithSchema(std::move(reader), schema);
+  assertReadWithReaderAndExpected(schema, *rowReader, data, *leafPool_);
+};
+
+DEBUG_ONLY_TEST_F(ParquetWriterTest, unitFromWriterOptions) {
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::parquet::Writer::write",
+      std::function<void(const ::arrow::Schema*)>(
+          ([&](const ::arrow::Schema* arrowSchema) {
+            const auto tsType =
+                std::dynamic_pointer_cast<::arrow::TimestampType>(
+                    arrowSchema->field(0)->type());
+            ASSERT_EQ(tsType->unit(), ::arrow::TimeUnit::MICRO);
+            ASSERT_EQ(tsType->timezone(), "America/Los_Angeles");
+          })));
+
+  const auto data = makeRowVector({makeFlatVector<Timestamp>(
+      10'000, [](auto row) { return Timestamp(row, row); })});
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.parquetWriteTimestampUnit = TimestampUnit::kMicro;
+  writerOptions.parquetWriteTimestampTimeZone = "America/Los_Angeles";
+
+  // Create an in-memory writer.
+  auto sink = std::make_unique<MemorySink>(
+      200 * 1024 * 1024,
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto writer = std::make_unique<parquet::Writer>(
+      std::move(sink), writerOptions, rootPool_, ROW({"c0"}, {TIMESTAMP()}));
+  writer->write(data);
+  writer->close();
+};
+
+TEST_F(ParquetWriterTest, parquetWriteTimestampTimeZoneWithDefault) {
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::parquet::Writer::write",
+      std::function<void(const ::arrow::Schema*)>(
+          ([&](const ::arrow::Schema* arrowSchema) {
+            const auto tsType =
+                std::dynamic_pointer_cast<::arrow::TimestampType>(
+                    arrowSchema->field(0)->type());
+            ASSERT_EQ(tsType->unit(), ::arrow::TimeUnit::MICRO);
+            ASSERT_EQ(tsType->timezone(), "");
+          })));
+
+  const auto data = makeRowVector({makeFlatVector<Timestamp>(
+      10'000, [](auto row) { return Timestamp(row, row); })});
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.parquetWriteTimestampUnit = TimestampUnit::kMicro;
+
+  // Create an in-memory writer.
+  auto sink = std::make_unique<MemorySink>(
+      200 * 1024 * 1024,
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto writer = std::make_unique<parquet::Writer>(
+      std::move(sink), writerOptions, rootPool_, ROW({"c0"}, {TIMESTAMP()}));
+  writer->write(data);
+  writer->close();
+};
+
+#ifdef VELOX_ENABLE_PARQUET
+DEBUG_ONLY_TEST_F(ParquetWriterTest, unitFromHiveConfig) {
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::parquet::Writer::write",
+      std::function<void(const ::arrow::Schema*)>(
+          ([&](const ::arrow::Schema* arrowSchema) {
+            const auto tsType =
+                std::dynamic_pointer_cast<::arrow::TimestampType>(
+                    arrowSchema->field(0)->type());
+            ASSERT_EQ(tsType->unit(), ::arrow::TimeUnit::MICRO);
+          })));
+
+  const auto data = makeRowVector({makeFlatVector<Timestamp>(
+      10'000, [](auto row) { return Timestamp(row, row); })});
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  auto writerOptions = std::make_shared<parquet::WriterOptions>();
+  writerOptions->parquetWriteTimestampUnit = TimestampUnit::kMicro;
+
+  const auto plan = PlanBuilder()
+                        .values({data})
+                        .tableWrite(
+                            outputDirectory->getPath(),
+                            dwio::common::FileFormat::PARQUET,
+                            {},
+                            writerOptions)
+                        .planNode();
+  AssertQueryBuilder(plan).copyResults(pool_.get());
+}
+#endif
+
+} // namespace
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::Init init{&argc, &argv, false};
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/dwio/parquet/tests/writer/ParquetWriterTestBase.cpp b/velox/dwio/parquet/tests/writer/ParquetWriterTestBase.cpp
deleted file mode 100644
index 45322dd41794a..0000000000000
--- a/velox/dwio/parquet/tests/writer/ParquetWriterTestBase.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/dwio/parquet/tests/writer/ParquetWriterTestBase.h"
-#include "velox/dwio/common/tests/utils/DataFiles.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-
-namespace facebook::velox::parquet {
-
-std::vector<RowVectorPtr> ParquetWriterTestBase::createBatches(
-    const RowTypePtr& rowType,
-    uint64_t numBatches,
-    uint64_t vectorSize) {
-  std::vector<RowVectorPtr> batches;
-  batches.reserve(numBatches);
-  VectorFuzzer fuzzer({.vectorSize = vectorSize}, leafPool_.get());
-  for (auto i = 0; i < numBatches; ++i) {
-    batches.emplace_back(fuzzer.fuzzInputFlatRow(rowType));
-  }
-  return batches;
-}
-
-std::unique_ptr<dwio::common::FileSink> ParquetWriterTestBase::createSink(
-    const std::string& filePath) {
-  auto sink = dwio::common::FileSink::create(
-      fmt::format("file:{}", filePath), {.pool = rootPool_.get()});
-  EXPECT_TRUE(sink->isBuffered());
-  EXPECT_TRUE(fs::exists(filePath));
-  EXPECT_FALSE(sink->isClosed());
-  return sink;
-}
-
-std::unique_ptr<Writer> ParquetWriterTestBase::createWriter(
-    std::unique_ptr<dwio::common::FileSink> sink,
-    std::function<std::unique_ptr<DefaultFlushPolicy>()> flushPolicy) {
-  facebook::velox::parquet::WriterOptions options;
-  options.memoryPool = rootPool_.get();
-  options.flushPolicyFactory = flushPolicy;
-  return std::make_unique<Writer>(std::move(sink), options);
-}
-} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/tests/writer/ParquetWriterTestBase.h b/velox/dwio/parquet/tests/writer/ParquetWriterTestBase.h
deleted file mode 100644
index 92be5524251c7..0000000000000
--- a/velox/dwio/parquet/tests/writer/ParquetWriterTestBase.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <gtest/gtest.h>
-#include <string>
-#include "velox/common/base/Fs.h"
-#include "velox/dwio/parquet/writer/Writer.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-
-namespace facebook::velox::parquet {
-
-class ParquetWriterTestBase : public testing::Test {
- protected:
-  void SetUp() override {
-    dwio::common::LocalFileSink::registerFactory();
-    rootPool_ = memory::defaultMemoryManager().addRootPool("ParquetWriterTest");
-    leafPool_ = rootPool_->addLeafChild("SinkTest");
-    tempPath_ = exec::test::TempDirectoryPath::create();
-  }
-
-  std::vector<RowVectorPtr> createBatches(
-      const RowTypePtr& rowType,
-      uint64_t numBatches,
-      uint64_t vectorSize);
-
-  std::unique_ptr<dwio::common::FileSink> createSink(
-      const std::string& filePath);
-
-  std::unique_ptr<Writer> createWriter(
-      std::unique_ptr<dwio::common::FileSink> sink,
-      std::function<std::unique_ptr<DefaultFlushPolicy>()> flushPolicy);
-
-  std::shared_ptr<memory::MemoryPool> rootPool_;
-  std::shared_ptr<memory::MemoryPool> leafPool_;
-  std::shared_ptr<exec::test::TempDirectoryPath> tempPath_;
-};
-} // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/tests/writer/SinkTests.cpp b/velox/dwio/parquet/tests/writer/SinkTests.cpp
index d44566c4e9f96..8599688f8ce41 100644
--- a/velox/dwio/parquet/tests/writer/SinkTests.cpp
+++ b/velox/dwio/parquet/tests/writer/SinkTests.cpp
@@ -14,36 +14,28 @@
  * limitations under the License.
  */
 
-#include <utility>
-
-#include "velox/dwio/parquet/tests/writer/ParquetWriterTestBase.h"
+#include "velox/dwio/parquet/tests/ParquetTestBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::dwio::common;
 using namespace facebook::velox::parquet;
 
-class SinkTest : public ParquetWriterTestBase {
- protected:
-  std::pair<std::unique_ptr<parquet::Writer>, FileSink*>
-  createWriterWithSinkPtr(
-      const std::string& filePath,
-      std::function<std::unique_ptr<DefaultFlushPolicy>()> flushPolicy) {
-    auto sink = createSink(filePath);
-    auto sinkPtr = sink.get();
-    return {createWriter(std::move(sink), std::move(flushPolicy)), sinkPtr};
-  }
-
-  static constexpr uint64_t kRowsInRowGroup = 10'000;
-  static constexpr uint64_t kBytesInRowGroup = 128 * 1'024 * 1'024;
-};
+class SinkTest : public ParquetTestBase {};
 
 TEST_F(SinkTest, close) {
-  auto batches = createBatches(ROW({INTEGER(), VARCHAR()}), 2, 3);
-  auto filePath = fs::path(fmt::format("{}/test_close.txt", tempPath_->path));
-  auto [writer, sinkPtr] = createWriterWithSinkPtr(filePath.string(), [&]() {
-    return std::make_unique<LambdaFlushPolicy>(
-        kRowsInRowGroup, kBytesInRowGroup, [&]() { return false; });
-  });
+  auto rowType = ROW({"c0", "c1"}, {INTEGER(), VARCHAR()});
+  auto batches = createBatches(rowType, 2, 3);
+  auto filePath =
+      fs::path(fmt::format("{}/test_close.txt", tempPath_->getPath()));
+  auto sink = createSink(filePath.string());
+  auto sinkPtr = sink.get();
+  auto writer = createWriter(
+      std::move(sink),
+      [&]() {
+        return std::make_unique<LambdaFlushPolicy>(
+            kRowsInRowGroup, kBytesInRowGroup, [&]() { return false; });
+      },
+      rowType);
 
   for (auto& batch : batches) {
     writer->write(batch);
@@ -62,12 +54,19 @@ TEST_F(SinkTest, close) {
 }
 
 TEST_F(SinkTest, abort) {
-  auto batches = createBatches(ROW({INTEGER(), VARCHAR()}), 2, 3);
-  auto filePath = fs::path(fmt::format("{}/test_abort.txt", tempPath_->path));
-  auto [writer, sinkPtr] = createWriterWithSinkPtr(filePath.string(), [&]() {
-    return std::make_unique<LambdaFlushPolicy>(
-        kRowsInRowGroup, kBytesInRowGroup, [&]() { return false; });
-  });
+  auto rowType = ROW({"c0", "c1"}, {INTEGER(), VARCHAR()});
+  auto batches = createBatches(rowType, 2, 3);
+  auto filePath =
+      fs::path(fmt::format("{}/test_abort.txt", tempPath_->getPath()));
+  auto sink = createSink(filePath.string());
+  auto sinkPtr = sink.get();
+  auto writer = createWriter(
+      std::move(sink),
+      [&]() {
+        return std::make_unique<LambdaFlushPolicy>(
+            kRowsInRowGroup, kBytesInRowGroup, [&]() { return false; });
+      },
+      rowType);
 
   for (auto& batch : batches) {
     writer->write(batch);
diff --git a/velox/dwio/parquet/thrift/CMakeLists.txt b/velox/dwio/parquet/thrift/CMakeLists.txt
index 08df5614f92fc..cb0b6ea918815 100644
--- a/velox/dwio/parquet/thrift/CMakeLists.txt
+++ b/velox/dwio/parquet/thrift/CMakeLists.txt
@@ -12,5 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_dwio_parquet_thrift ParquetThriftTypes.cpp)
-target_link_libraries(velox_dwio_parquet_thrift arrow thrift Boost::headers)
+velox_add_library(velox_dwio_parquet_thrift ParquetThriftTypes.cpp)
+velox_link_libraries(
+  velox_dwio_parquet_thrift
+  arrow
+  thrift
+  Boost::headers
+  fmt::fmt)
diff --git a/velox/dwio/parquet/thrift/ParquetThriftTypes.h b/velox/dwio/parquet/thrift/ParquetThriftTypes.h
index 517c425b7f012..0fd63e83cc0ed 100644
--- a/velox/dwio/parquet/thrift/ParquetThriftTypes.h
+++ b/velox/dwio/parquet/thrift/ParquetThriftTypes.h
@@ -28,6 +28,7 @@
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/transport/TTransport.h>
 
+#include <fmt/format.h>
 #include <functional>
 #include <iosfwd>
 #include <memory>
@@ -3742,3 +3743,81 @@ void swap(FileCryptoMetaData& a, FileCryptoMetaData& b);
 std::ostream& operator<<(std::ostream& out, const FileCryptoMetaData& obj);
 
 } // namespace facebook::velox::parquet::thrift
+
+template <>
+struct fmt::formatter<facebook::velox::parquet::thrift::Type::type>
+    : fmt::formatter<std::string_view> {
+  auto format(
+      const facebook::velox::parquet::thrift::Type::type& s,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::parquet::thrift::to_string(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::parquet::thrift::CompressionCodec::type>
+    : fmt::formatter<std::string_view> {
+  auto format(
+      const facebook::velox::parquet::thrift::CompressionCodec::type& s,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::parquet::thrift::to_string(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::parquet::thrift::ConvertedType::type>
+    : fmt::formatter<std::string_view> {
+  auto format(
+      const facebook::velox::parquet::thrift::ConvertedType::type& s,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::parquet::thrift::to_string(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<
+    facebook::velox::parquet::thrift::FieldRepetitionType::type>
+    : fmt::formatter<std::string_view> {
+  auto format(
+      const facebook::velox::parquet::thrift::FieldRepetitionType::type& s,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::parquet::thrift::to_string(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::parquet::thrift::Encoding::type>
+    : fmt::formatter<std::string_view> {
+  auto format(
+      const facebook::velox::parquet::thrift::Encoding::type& s,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::parquet::thrift::to_string(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::parquet::thrift::PageType::type>
+    : fmt::formatter<std::string_view> {
+  auto format(
+      const facebook::velox::parquet::thrift::PageType::type& s,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::parquet::thrift::to_string(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::parquet::thrift::BoundaryOrder::type>
+    : fmt::formatter<std::string_view> {
+  auto format(
+      const facebook::velox::parquet::thrift::BoundaryOrder::type& s,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::parquet::thrift::to_string(s), ctx);
+  }
+};
diff --git a/velox/dwio/parquet/thrift/parquet.thrift b/velox/dwio/parquet/thrift/parquet.thrift
index 2e2f5abde0f1b..c7c962a0c5015 100644
--- a/velox/dwio/parquet/thrift/parquet.thrift
+++ b/velox/dwio/parquet/thrift/parquet.thrift
@@ -37,7 +37,6 @@
  * File format description for the parquet file format
  */
 
-cpp_include "parquet/windows_compatibility.h"
 namespace cpp parquet.format
 namespace java org.apache.parquet.format
 
diff --git a/velox/dwio/parquet/writer/CMakeLists.txt b/velox/dwio/parquet/writer/CMakeLists.txt
index fd9ffd5371998..6d2e42434c4b0 100644
--- a/velox/dwio/parquet/writer/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/CMakeLists.txt
@@ -14,14 +14,13 @@
 
 add_subdirectory(arrow)
 
-add_library(velox_dwio_arrow_parquet_writer Writer.cpp)
+velox_add_library(velox_dwio_arrow_parquet_writer Writer.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_dwio_arrow_parquet_writer
   velox_dwio_arrow_parquet_writer_lib
   velox_dwio_arrow_parquet_writer_util_lib
   velox_dwio_common
   velox_arrow_bridge
-  parquet
   arrow
   fmt::fmt)
diff --git a/velox/dwio/parquet/writer/Writer.cpp b/velox/dwio/parquet/writer/Writer.cpp
index 2ecf5c23217a5..bce6919a7cc63 100644
--- a/velox/dwio/parquet/writer/Writer.cpp
+++ b/velox/dwio/parquet/writer/Writer.cpp
@@ -14,15 +14,17 @@
  * limitations under the License.
  */
 
-#include "velox/vector/arrow/Bridge.h"
-
+#include "velox/dwio/parquet/writer/Writer.h"
 #include <arrow/c/bridge.h>
 #include <arrow/io/interfaces.h>
 #include <arrow/table.h>
-
-#include "velox/dwio/parquet/writer/Writer.h"
+#include "velox/common/base/Pointers.h"
+#include "velox/common/config/Config.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/dwio/parquet/writer/arrow/Properties.h"
 #include "velox/dwio/parquet/writer/arrow/Writer.h"
+#include "velox/exec/MemoryReclaimer.h"
 
 namespace facebook::velox::parquet {
 
@@ -122,6 +124,8 @@ Compression::type getArrowParquetCompression(
   }
 }
 
+namespace {
+
 std::shared_ptr<WriterProperties> getArrowParquetWriterOptions(
     const parquet::WriterOptions& options,
     const std::unique_ptr<DefaultFlushPolicy>& flushPolicy) {
@@ -130,48 +134,139 @@ std::shared_ptr<WriterProperties> getArrowParquetWriterOptions(
   if (!options.enableDictionary) {
     properties = properties->disable_dictionary();
   }
-  properties =
-      properties->compression(getArrowParquetCompression(options.compression));
+  properties = properties->compression(getArrowParquetCompression(
+      options.compressionKind.value_or(common::CompressionKind_NONE)));
+  for (const auto& columnCompressionValues : options.columnCompressionsMap) {
+    properties->compression(
+        columnCompressionValues.first,
+        getArrowParquetCompression(columnCompressionValues.second));
+  }
+  properties = properties->encoding(options.encoding);
   properties = properties->data_pagesize(options.dataPageSize);
   properties = properties->max_row_group_length(
       static_cast<int64_t>(flushPolicy->rowsInRowGroup()));
+  properties = properties->codec_options(options.codecOptions);
+  properties = properties->enable_store_decimal_as_integer();
   return properties->build();
 }
 
+void validateSchemaRecursive(const RowTypePtr& schema) {
+  // Check the schema's field names is not empty and unique.
+  VELOX_USER_CHECK_NOT_NULL(schema, "Field schema must not be empty.");
+  const auto& fieldNames = schema->names();
+
+  folly::F14FastSet<std::string> uniqueNames;
+  for (const auto& name : fieldNames) {
+    VELOX_USER_CHECK(!name.empty(), "Field name must not be empty.");
+    auto result = uniqueNames.insert(name);
+    VELOX_USER_CHECK(
+        result.second,
+        "File schema should not have duplicate columns: {}",
+        name);
+  }
+
+  for (auto i = 0; i < schema->size(); ++i) {
+    if (auto childSchema =
+            std::dynamic_pointer_cast<const RowType>(schema->childAt(i))) {
+      validateSchemaRecursive(childSchema);
+    }
+  }
+}
+
+std::shared_ptr<::arrow::Field> updateFieldNameRecursive(
+    const std::shared_ptr<::arrow::Field>& field,
+    const Type& type,
+    const std::string& name = "") {
+  if (type.isRow()) {
+    auto& rowType = type.asRow();
+    auto newField = field->WithName(name);
+    auto structType =
+        std::dynamic_pointer_cast<::arrow::StructType>(newField->type());
+    auto childrenSize = rowType.size();
+    std::vector<std::shared_ptr<::arrow::Field>> newFields;
+    newFields.reserve(childrenSize);
+    for (auto i = 0; i < childrenSize; i++) {
+      newFields.push_back(updateFieldNameRecursive(
+          structType->fields()[i], *rowType.childAt(i), rowType.nameOf(i)));
+    }
+    return newField->WithType(::arrow::struct_(newFields));
+  } else if (type.isArray()) {
+    auto newField = field->WithName(name);
+    auto listType =
+        std::dynamic_pointer_cast<::arrow::BaseListType>(newField->type());
+    auto elementType = type.asArray().elementType();
+    auto elementField = listType->value_field();
+    return newField->WithType(
+        ::arrow::list(updateFieldNameRecursive(elementField, *elementType)));
+  } else if (type.isMap()) {
+    auto mapType = type.asMap();
+    auto newField = field->WithName(name);
+    auto arrowMapType =
+        std::dynamic_pointer_cast<::arrow::MapType>(newField->type());
+    auto newKeyField =
+        updateFieldNameRecursive(arrowMapType->key_field(), *mapType.keyType());
+    auto newValueField = updateFieldNameRecursive(
+        arrowMapType->item_field(), *mapType.valueType());
+    return newField->WithType(
+        ::arrow::map(newKeyField->type(), newValueField->type()));
+  } else if (name != "") {
+    return field->WithName(name);
+  } else {
+    return field;
+  }
+}
+
+} // namespace
+
 Writer::Writer(
     std::unique_ptr<dwio::common::FileSink> sink,
     const WriterOptions& options,
-    std::shared_ptr<memory::MemoryPool> pool)
+    std::shared_ptr<memory::MemoryPool> pool,
+    RowTypePtr schema)
     : pool_(std::move(pool)),
       generalPool_{pool_->addLeafChild(".general")},
       stream_(std::make_shared<ArrowDataBufferSink>(
           std::move(sink),
           *generalPool_,
           options.bufferGrowRatio)),
-      arrowContext_(std::make_shared<ArrowContext>()) {
+      arrowContext_(std::make_shared<ArrowContext>()),
+      schema_(std::move(schema)) {
+  validateSchemaRecursive(schema_);
+
   if (options.flushPolicyFactory) {
-    flushPolicy_ = options.flushPolicyFactory();
+    castUniquePointer(options.flushPolicyFactory(), flushPolicy_);
   } else {
     flushPolicy_ = std::make_unique<DefaultFlushPolicy>();
   }
+  options_.timestampUnit =
+      options.parquetWriteTimestampUnit.value_or(TimestampUnit::kNano);
+  options_.timestampTimeZone = options.parquetWriteTimestampTimeZone;
   arrowContext_->properties =
       getArrowParquetWriterOptions(options, flushPolicy_);
+  setMemoryReclaimers();
+  writeInt96AsTimestamp_ = options.writeInt96AsTimestamp;
 }
 
 Writer::Writer(
     std::unique_ptr<dwio::common::FileSink> sink,
-    const WriterOptions& options)
+    const WriterOptions& options,
+    RowTypePtr schema)
     : Writer{
           std::move(sink),
           options,
           options.memoryPool->addAggregateChild(fmt::format(
               "writer_node_{}",
-              folly::to<std::string>(folly::Random::rand64())))} {}
+              folly::to<std::string>(folly::Random::rand64()))),
+          std::move(schema)} {}
 
 void Writer::flush() {
   if (arrowContext_->stagingRows > 0) {
     if (!arrowContext_->writer) {
-      auto arrowProperties = ArrowWriterProperties::Builder().build();
+      ArrowWriterProperties::Builder builder;
+      if (writeInt96AsTimestamp_) {
+        builder.enable_deprecated_int96_timestamps();
+      }
+      auto arrowProperties = builder.build();
       PARQUET_ASSIGN_OR_THROW(
           arrowContext_->writer,
           FileWriter::Open(
@@ -223,12 +318,30 @@ dwio::common::StripeProgress getStripeProgress(
  * This method assumes each input `ColumnarBatch` have same schema.
  */
 void Writer::write(const VectorPtr& data) {
+  VELOX_USER_CHECK(
+      data->type()->equivalent(*schema_),
+      "The file schema type should be equal with the input rowvector type.");
+
   ArrowArray array;
   ArrowSchema schema;
-  exportToArrow(data, array, generalPool_.get());
-  exportToArrow(data, schema);
+  exportToArrow(data, array, generalPool_.get(), options_);
+  exportToArrow(data, schema, options_);
+
+  // Convert the arrow schema to Schema and then update the column names based
+  // on schema_.
+  auto arrowSchema = ::arrow::ImportSchema(&schema).ValueOrDie();
+  common::testutil::TestValue::adjust(
+      "facebook::velox::parquet::Writer::write", arrowSchema.get());
+  std::vector<std::shared_ptr<::arrow::Field>> newFields;
+  auto childSize = schema_->size();
+  for (auto i = 0; i < childSize; i++) {
+    newFields.push_back(updateFieldNameRecursive(
+        arrowSchema->fields()[i], *schema_->childAt(i), schema_->nameOf(i)));
+  }
+
   PARQUET_ASSIGN_OR_THROW(
-      auto recordBatch, ::arrow::ImportRecordBatch(&array, &schema));
+      auto recordBatch,
+      ::arrow::ImportRecordBatch(&array, ::arrow::schema(newFields)));
   if (!arrowContext_->schema) {
     arrowContext_->schema = recordBatch->schema();
     for (int colIdx = 0; colIdx < arrowContext_->schema->num_fields();
@@ -279,21 +392,38 @@ void Writer::abort() {
   arrowContext_.reset();
 }
 
-parquet::WriterOptions getParquetOptions(
-    const dwio::common::WriterOptions& options) {
-  parquet::WriterOptions parquetOptions;
-  parquetOptions.memoryPool = options.memoryPool;
-  if (options.compressionKind.has_value()) {
-    parquetOptions.compression = options.compressionKind.value();
+void Writer::setMemoryReclaimers() {
+  VELOX_CHECK(
+      !pool_->isLeaf(),
+      "The root memory pool for parquet writer can't be leaf: {}",
+      pool_->name());
+  VELOX_CHECK_NULL(pool_->reclaimer());
+
+  if ((pool_->parent() == nullptr) ||
+      (pool_->parent()->reclaimer() == nullptr)) {
+    return;
   }
-  return parquetOptions;
+
+  // TODO https://github.com/facebookincubator/velox/issues/8190
+  pool_->setReclaimer(exec::MemoryReclaimer::create());
+  generalPool_->setReclaimer(exec::MemoryReclaimer::create());
 }
 
 std::unique_ptr<dwio::common::Writer> ParquetWriterFactory::createWriter(
     std::unique_ptr<dwio::common::FileSink> sink,
-    const dwio::common::WriterOptions& options) {
-  auto parquetOptions = getParquetOptions(options);
-  return std::make_unique<Writer>(std::move(sink), parquetOptions);
+    const std::shared_ptr<dwio::common::WriterOptions>& options) {
+  auto parquetOptions =
+      std::dynamic_pointer_cast<parquet::WriterOptions>(options);
+  VELOX_CHECK_NOT_NULL(
+      parquetOptions,
+      "Parquet writer factory expected a Parquet WriterOptions object.");
+  return std::make_unique<Writer>(
+      std::move(sink), *parquetOptions, asRowType(options->schema));
+}
+
+std::unique_ptr<dwio::common::WriterOptions>
+ParquetWriterFactory::createWriterOptions() {
+  return std::make_unique<parquet::WriterOptions>();
 }
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/writer/Writer.h b/velox/dwio/parquet/writer/Writer.h
index 9a2c105bc0827..7e0fa28b6e789 100644
--- a/velox/dwio/parquet/writer/Writer.h
+++ b/velox/dwio/parquet/writer/Writer.h
@@ -17,16 +17,22 @@
 #pragma once
 
 #include "velox/common/compression/Compression.h"
+#include "velox/common/config/Config.h"
 #include "velox/dwio/common/DataBuffer.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/FlushPolicy.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/common/Writer.h"
 #include "velox/dwio/common/WriterFactory.h"
+#include "velox/dwio/parquet/writer/arrow/Types.h"
+#include "velox/dwio/parquet/writer/arrow/util/Compression.h"
 #include "velox/vector/ComplexVector.h"
+#include "velox/vector/arrow/Bridge.h"
 
 namespace facebook::velox::parquet {
 
+using facebook::velox::parquet::arrow::util::CodecOptions;
+
 class ArrowDataBufferSink;
 
 struct ArrowContext;
@@ -81,19 +87,37 @@ class LambdaFlushPolicy : public DefaultFlushPolicy {
   std::function<bool()> lambda_;
 };
 
-struct WriterOptions {
+struct WriterOptions : public dwio::common::WriterOptions {
   bool enableDictionary = true;
   int64_t dataPageSize = 1'024 * 1'024;
   int64_t dictionaryPageSizeLimit = 1'024 * 1'024;
+
   // Growth ratio passed to ArrowDataBufferSink. The default value is a
   // heuristic borrowed from
   // folly/FBVector(https://github.com/facebook/folly/blob/main/folly/docs/FBVector.md#memory-handling).
   double bufferGrowRatio = 1.5;
-  common::CompressionKind compression = common::CompressionKind_NONE;
-  velox::memory::MemoryPool* memoryPool;
-  // The default factory allows the writer to construct the default flush
-  // policy with the configs in its ctor.
-  std::function<std::unique_ptr<DefaultFlushPolicy>()> flushPolicyFactory;
+
+  arrow::Encoding::type encoding = arrow::Encoding::PLAIN;
+
+  std::shared_ptr<CodecOptions> codecOptions;
+  std::unordered_map<std::string, common::CompressionKind>
+      columnCompressionsMap;
+
+  /// Timestamp unit for Parquet write through Arrow bridge.
+  /// Default if not specified: TimestampUnit::kNano (9).
+  std::optional<TimestampUnit> parquetWriteTimestampUnit;
+  /// Timestamp time zone for Parquet write through Arrow bridge.
+  std::optional<std::string> parquetWriteTimestampTimeZone;
+  bool writeInt96AsTimestamp = false;
+
+  // Parsing session and hive configs.
+
+  // This isn't a typo; session and hive connector config names are different
+  // ('_' vs '-').
+  static constexpr const char* kParquetSessionWriteTimestampUnit =
+      "hive.parquet.writer.timestamp_unit";
+  static constexpr const char* kParquetHiveConnectorWriteTimestampUnit =
+      "hive.parquet.writer.timestamp-unit";
 };
 
 // Writes Velox vectors into  a DataSink using Arrow Parquet writer.
@@ -102,15 +126,18 @@ class Writer : public dwio::common::Writer {
   // Constructs a writer with output to 'sink'. A new row group is
   // started every 'rowsInRowGroup' top level rows. 'pool' is used for
   // temporary memory. 'properties' specifies Parquet-specific
-  // options.
+  // options. 'schema' specifies the file's overall schema, and it is always
+  // non-null.
   Writer(
       std::unique_ptr<dwio::common::FileSink> sink,
       const WriterOptions& options,
-      std::shared_ptr<memory::MemoryPool> pool);
+      std::shared_ptr<memory::MemoryPool> pool,
+      RowTypePtr schema);
 
   Writer(
       std::unique_ptr<dwio::common::FileSink> sink,
-      const WriterOptions& options);
+      const WriterOptions& options,
+      RowTypePtr schema);
 
   ~Writer() override = default;
 
@@ -132,6 +159,9 @@ class Writer : public dwio::common::Writer {
   void abort() override;
 
  private:
+  // Sets the memory reclaimers for all the memory pools used by this writer.
+  void setMemoryReclaimers();
+
   // Pool for 'stream_'.
   std::shared_ptr<memory::MemoryPool> pool_;
   std::shared_ptr<memory::MemoryPool> generalPool_;
@@ -142,6 +172,13 @@ class Writer : public dwio::common::Writer {
   std::shared_ptr<ArrowContext> arrowContext_;
 
   std::unique_ptr<DefaultFlushPolicy> flushPolicy_;
+
+  const RowTypePtr schema_;
+
+  ArrowOptions options_{.flattenDictionary = true, .flattenConstant = true};
+
+  // Whether to write Int96 timestamps in Arrow Parquet write.
+  bool writeInt96AsTimestamp_;
 };
 
 class ParquetWriterFactory : public dwio::common::WriterFactory {
@@ -150,7 +187,9 @@ class ParquetWriterFactory : public dwio::common::WriterFactory {
 
   std::unique_ptr<dwio::common::Writer> createWriter(
       std::unique_ptr<dwio::common::FileSink> sink,
-      const dwio::common::WriterOptions& options) override;
+      const std::shared_ptr<dwio::common::WriterOptions>& options) override;
+
+  std::unique_ptr<dwio::common::WriterOptions> createWriterOptions() override;
 };
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp b/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
index 8d0af70572dc7..2b76a04c840ac 100644
--- a/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
+++ b/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
@@ -34,8 +34,8 @@
 #include "arrow/util/string.h"
 #include "arrow/util/value_parsing.h"
 
-#include "parquet/exception.h"
 #include "velox/dwio/parquet/writer/arrow/ArrowSchemaInternal.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Metadata.h"
 #include "velox/dwio/parquet/writer/arrow/Properties.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
diff --git a/velox/dwio/parquet/writer/arrow/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/CMakeLists.txt
index a0ec7e61e483d..e3bdcb90e874f 100644
--- a/velox/dwio/parquet/writer/arrow/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/CMakeLists.txt
@@ -19,7 +19,7 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-add_library(
+velox_add_library(
   velox_dwio_arrow_parquet_writer_lib
   ArrowSchema.cpp
   ArrowSchemaInternal.cpp
@@ -27,6 +27,7 @@ add_library(
   Encoding.cpp
   Encryption.cpp
   EncryptionInternal.cpp
+  Exception.cpp
   FileEncryptorInternal.cpp
   FileDecryptorInternal.cpp
   FileWriter.cpp
@@ -43,12 +44,11 @@ add_library(
   Types.cpp
   Writer.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_dwio_arrow_parquet_writer_lib
   velox_dwio_arrow_parquet_writer_util_lib
   velox_dwio_arrow_parquet_writer_thrift_lib
   velox_dwio_common
   velox_arrow_bridge
-  parquet
   arrow
   fmt::fmt)
diff --git a/velox/dwio/parquet/writer/arrow/ColumnPage.h b/velox/dwio/parquet/writer/arrow/ColumnPage.h
index 32a8177fc3395..ead7d96bd477c 100644
--- a/velox/dwio/parquet/writer/arrow/ColumnPage.h
+++ b/velox/dwio/parquet/writer/arrow/ColumnPage.h
@@ -136,9 +136,7 @@ class DataPageV1 : public DataPage {
             statistics,
             std::move(first_row_index)),
         definition_level_encoding_(definition_level_encoding),
-        repetition_level_encoding_(repetition_level_encoding) {
-    LOG(ERROR) << "CREATING PAGE: " << encoding;
-  }
+        repetition_level_encoding_(repetition_level_encoding) {}
 
   Encoding::type repetition_level_encoding() const {
     return repetition_level_encoding_;
diff --git a/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp b/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
index 405e798961312..cae2374a546f3 100644
--- a/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
+++ b/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
@@ -71,7 +71,6 @@ using arrow::bit_util::BitWriter;
 using arrow::internal::checked_cast;
 using arrow::internal::checked_pointer_cast;
 using arrow::util::RleEncoder;
-using ::parquet::ParquetException;
 
 namespace bit_util = arrow::bit_util;
 
@@ -152,11 +151,15 @@ struct ValueBufferSlicer {
   NOT_IMPLEMENTED_VISIT(Union);
   NOT_IMPLEMENTED_VISIT(List);
   NOT_IMPLEMENTED_VISIT(LargeList);
+  NOT_IMPLEMENTED_VISIT(ListView);
+  NOT_IMPLEMENTED_VISIT(LargeListView);
   NOT_IMPLEMENTED_VISIT(Struct);
   NOT_IMPLEMENTED_VISIT(FixedSizeList);
   NOT_IMPLEMENTED_VISIT(Dictionary);
   NOT_IMPLEMENTED_VISIT(RunEndEncoded);
   NOT_IMPLEMENTED_VISIT(Extension);
+  NOT_IMPLEMENTED_VISIT(BinaryView);
+  NOT_IMPLEMENTED_VISIT(StringView);
 
 #undef NOT_IMPLEMENTED_VISIT
 
diff --git a/velox/dwio/parquet/writer/arrow/ColumnWriter.h b/velox/dwio/parquet/writer/arrow/ColumnWriter.h
index dd4de25e7142d..7ee98533423c1 100644
--- a/velox/dwio/parquet/writer/arrow/ColumnWriter.h
+++ b/velox/dwio/parquet/writer/arrow/ColumnWriter.h
@@ -22,7 +22,7 @@
 #include <cstring>
 #include <memory>
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
 #include "velox/dwio/parquet/writer/arrow/util/Compression.h"
@@ -83,7 +83,7 @@ class PARQUET_EXPORT LevelEncoder {
 
   int32_t len() {
     if (encoding_ != Encoding::RLE) {
-      throw ::parquet::ParquetException("Only implemented for RLE encoding");
+      throw ParquetException("Only implemented for RLE encoding");
     }
     return rle_length_;
   }
diff --git a/velox/dwio/parquet/writer/arrow/Encoding.cpp b/velox/dwio/parquet/writer/arrow/Encoding.cpp
index efde9ab3b5899..672856cffead3 100644
--- a/velox/dwio/parquet/writer/arrow/Encoding.cpp
+++ b/velox/dwio/parquet/writer/arrow/Encoding.cpp
@@ -39,16 +39,16 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/bitmap_writer.h"
-#include "arrow/util/byte_stream_split.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/rle_encoding.h"
 #include "arrow/util/ubsan.h"
 #include "arrow/visit_data_inline.h"
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
+#include "velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h"
 #include "velox/dwio/parquet/writer/arrow/util/Hashing.h"
 #include "velox/dwio/parquet/writer/arrow/util/OverflowUtilInternal.h"
 
@@ -65,8 +65,6 @@ using arrow::internal::MultiplyWithOverflow;
 using arrow::internal::SubtractWithOverflow;
 using std::string_view;
 
-using ::parquet::ParquetException;
-
 template <typename T>
 using ArrowPoolVector = std::vector<T, ::arrow::stl::allocator<T>>;
 
@@ -507,9 +505,7 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
         dict_encoded_size_(0),
         memo_table_(pool, kInitialHashTableSize) {}
 
-  ~DictEncoderImpl() override {
-    DCHECK(buffered_indices_.empty());
-  }
+  ~DictEncoderImpl() = default;
 
   int dict_encoded_size() const override {
     return dict_encoded_size_;
@@ -966,7 +962,7 @@ std::shared_ptr<::arrow::Buffer> ByteStreamSplitEncoder<DType>::FlushValues() {
       AllocateBuffer(this->memory_pool(), EstimatedDataEncodedSize());
   uint8_t* output_buffer_raw = output_buffer->mutable_data();
   const uint8_t* raw_values = sink_.data();
-  ::arrow::util::internal::ByteStreamSplitEncode<T>(
+  ByteStreamSplitEncode<T>(
       raw_values, num_values_in_buffer_, output_buffer_raw);
   sink_.Reset();
   num_values_in_buffer_ = 0;
@@ -4049,7 +4045,7 @@ int ByteStreamSplitDecoder<DType>::Decode(T* buffer, int max_values) {
   const int num_decoded_previously = num_values_in_buffer_ - num_values_;
   const uint8_t* data = data_ + num_decoded_previously;
 
-  ::arrow::util::internal::ByteStreamSplitDecode<T>(
+  ByteStreamSplitDecode<T>(
       data, values_to_decode, num_values_in_buffer_, buffer);
   num_values_ -= values_to_decode;
   len_ -= sizeof(T) * values_to_decode;
diff --git a/velox/dwio/parquet/writer/arrow/Encoding.h b/velox/dwio/parquet/writer/arrow/Encoding.h
index 44816762466dd..b57ee2b68e366 100644
--- a/velox/dwio/parquet/writer/arrow/Encoding.h
+++ b/velox/dwio/parquet/writer/arrow/Encoding.h
@@ -25,7 +25,7 @@
 
 #include "arrow/util/spaced.h"
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
 
@@ -303,7 +303,7 @@ class TypedDecoder : virtual public Decoder {
       int values_to_read = num_values - null_count;
       int values_read = Decode(buffer, values_to_read);
       if (values_read != values_to_read) {
-        throw ::parquet::ParquetException(
+        throw ParquetException(
             "Number of values / definition_levels read did not match");
       }
 
diff --git a/velox/dwio/parquet/writer/arrow/Encryption.h b/velox/dwio/parquet/writer/arrow/Encryption.h
index ae80b94f5936b..df310589a433c 100644
--- a/velox/dwio/parquet/writer/arrow/Encryption.h
+++ b/velox/dwio/parquet/writer/arrow/Encryption.h
@@ -23,12 +23,10 @@
 #include <string>
 #include <utility>
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
 
-using ::parquet::ParquetException;
-
 namespace facebook::velox::parquet::arrow {
 
 static constexpr ParquetCipher::type kDefaultEncryptionAlgorithm =
diff --git a/velox/dwio/parquet/writer/arrow/EncryptionInternal.cpp b/velox/dwio/parquet/writer/arrow/EncryptionInternal.cpp
index 76b1083fb426d..7b2c1a1e6b94c 100644
--- a/velox/dwio/parquet/writer/arrow/EncryptionInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/EncryptionInternal.cpp
@@ -28,9 +28,7 @@
 #include <string>
 #include <vector>
 
-#include "parquet/exception.h"
-
-using parquet::ParquetException;
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 
 namespace facebook::velox::parquet::arrow::encryption {
 
diff --git a/velox/dwio/parquet/writer/arrow/Exception.cpp b/velox/dwio/parquet/writer/arrow/Exception.cpp
new file mode 100644
index 0000000000000..26a9fb32e76f9
--- /dev/null
+++ b/velox/dwio/parquet/writer/arrow/Exception.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
+
+namespace facebook::velox::parquet::arrow {
+
+std::ostream& operator<<(std::ostream& os, const ParquetException& exception) {
+  os << exception.what();
+  return os;
+}
+
+} // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/Exception.h b/velox/dwio/parquet/writer/arrow/Exception.h
new file mode 100644
index 0000000000000..927df34074644
--- /dev/null
+++ b/velox/dwio/parquet/writer/arrow/Exception.h
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#pragma once
+
+#include <exception>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "arrow/type_fwd.h"
+#include "arrow/util/string_builder.h"
+#include "velox/dwio/parquet/writer/arrow/Platform.h"
+
+// PARQUET-1085
+#if !defined(ARROW_UNUSED)
+#define ARROW_UNUSED(x) UNUSED(x)
+#endif
+
+// Parquet exception to Arrow Status
+
+#define BEGIN_PARQUET_CATCH_EXCEPTIONS try {
+#define END_PARQUET_CATCH_EXCEPTIONS                                           \
+  }                                                                            \
+  catch (const ::facebook::velox::parquet::arrow::ParquetStatusException& e) { \
+    return e.status();                                                         \
+  }                                                                            \
+  catch (const ::facebook::velox::parquet::arrow::ParquetException& e) {       \
+    return ::arrow::Status::IOError(e.what());                                 \
+  }
+
+// clang-format off
+
+#define PARQUET_CATCH_NOT_OK(s)    \
+  BEGIN_PARQUET_CATCH_EXCEPTIONS   \
+  (s);                             \
+  END_PARQUET_CATCH_EXCEPTIONS
+
+// clang-format on
+
+#define PARQUET_CATCH_AND_RETURN(s) \
+  BEGIN_PARQUET_CATCH_EXCEPTIONS    \
+  return (s);                       \
+  END_PARQUET_CATCH_EXCEPTIONS
+
+// Arrow Status to Parquet exception
+
+#define PARQUET_IGNORE_NOT_OK(s)                                \
+  do {                                                          \
+    ::arrow::Status _s = ::arrow::internal::GenericToStatus(s); \
+    ARROW_UNUSED(_s);                                           \
+  } while (0)
+
+#define PARQUET_THROW_NOT_OK(s)                                        \
+  do {                                                                 \
+    ::arrow::Status _s = ::arrow::internal::GenericToStatus(s);        \
+    if (!_s.ok()) {                                                    \
+      throw ::facebook::velox::parquet::arrow::ParquetStatusException( \
+          std::move(_s));                                              \
+    }                                                                  \
+  } while (0)
+
+#define PARQUET_ASSIGN_OR_THROW_IMPL(status_name, lhs, rexpr) \
+  auto status_name = (rexpr);                                 \
+  PARQUET_THROW_NOT_OK(status_name.status());                 \
+  lhs = std::move(status_name).ValueOrDie();
+
+#define PARQUET_ASSIGN_OR_THROW(lhs, rexpr) \
+  PARQUET_ASSIGN_OR_THROW_IMPL(             \
+      ARROW_ASSIGN_OR_RAISE_NAME(_error_or_value, __COUNTER__), lhs, rexpr);
+
+namespace facebook::velox::parquet::arrow {
+
+class ParquetException : public std::exception {
+ public:
+  PARQUET_NORETURN static void EofException(const std::string& msg = "") {
+    static std::string prefix = "Unexpected end of stream";
+    if (msg.empty()) {
+      throw ParquetException(prefix);
+    }
+    throw ParquetException(prefix, ": ", msg);
+  }
+
+  PARQUET_NORETURN static void NYI(const std::string& msg = "") {
+    throw ParquetException("Not yet implemented: ", msg, ".");
+  }
+
+  template <typename... Args>
+  explicit ParquetException(Args&&... args)
+      : msg_(::arrow::util::StringBuilder(std::forward<Args>(args)...)) {}
+
+  explicit ParquetException(std::string msg) : msg_(std::move(msg)) {}
+
+  explicit ParquetException(const char* msg, const std::exception&)
+      : msg_(msg) {}
+
+  ParquetException(const ParquetException&) = default;
+  ParquetException& operator=(const ParquetException&) = default;
+  ParquetException(ParquetException&&) = default;
+  ParquetException& operator=(ParquetException&&) = default;
+
+  const char* what() const noexcept override {
+    return msg_.c_str();
+  }
+
+ private:
+  std::string msg_;
+};
+
+// Support printing a ParquetException.
+// This is needed for clang-on-MSVC as there operator<< is not defined for
+// std::exception.
+PARQUET_EXPORT
+std::ostream& operator<<(std::ostream& os, const ParquetException& exception);
+
+class ParquetStatusException : public ParquetException {
+ public:
+  explicit ParquetStatusException(::arrow::Status status)
+      : ParquetException(status.ToString()), status_(std::move(status)) {}
+
+  const ::arrow::Status& status() const {
+    return status_;
+  }
+
+ private:
+  ::arrow::Status status_;
+};
+
+// This class exists for the purpose of detecting an invalid or corrupted file.
+class ParquetInvalidOrCorruptedFileException : public ParquetStatusException {
+ public:
+  ParquetInvalidOrCorruptedFileException(
+      const ParquetInvalidOrCorruptedFileException&) = default;
+
+  template <
+      typename Arg,
+      typename std::enable_if<
+          !std::is_base_of<ParquetInvalidOrCorruptedFileException, Arg>::value,
+          int>::type = 0,
+      typename... Args>
+  explicit ParquetInvalidOrCorruptedFileException(Arg arg, Args&&... args)
+      : ParquetStatusException(::arrow::Status::Invalid(
+            std::forward<Arg>(arg),
+            std::forward<Args>(args)...)) {}
+};
+
+template <typename StatusReturnBlock>
+void ThrowNotOk(StatusReturnBlock&& b) {
+  PARQUET_THROW_NOT_OK(b());
+}
+
+} // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/FileWriter.cpp b/velox/dwio/parquet/writer/arrow/FileWriter.cpp
index c51d8b17a9206..08c3852290ea1 100644
--- a/velox/dwio/parquet/writer/arrow/FileWriter.cpp
+++ b/velox/dwio/parquet/writer/arrow/FileWriter.cpp
@@ -26,9 +26,9 @@
 
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
-#include "parquet/exception.h"
 #include "velox/dwio/parquet/writer/arrow/ColumnWriter.h"
 #include "velox/dwio/parquet/writer/arrow/EncryptionInternal.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/FileEncryptorInternal.h"
 #include "velox/dwio/parquet/writer/arrow/PageIndex.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
diff --git a/velox/dwio/parquet/writer/arrow/LevelComparison.cpp b/velox/dwio/parquet/writer/arrow/LevelComparison.cpp
index 1f4fef6e187a2..18ac0ca81a458 100644
--- a/velox/dwio/parquet/writer/arrow/LevelComparison.cpp
+++ b/velox/dwio/parquet/writer/arrow/LevelComparison.cpp
@@ -46,11 +46,10 @@ struct GreaterThanDynamicFunction {
 
   static std::vector<std::pair<DispatchLevel, FunctionType>> implementations() {
     return {
-      { DispatchLevel::NONE, standard::GreaterThanBitmapImpl }
+        {DispatchLevel::NONE, standard::GreaterThanBitmapImpl}
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
-      , {
-        DispatchLevel::AVX2, GreaterThanBitmapAvx2
-      }
+        ,
+        {DispatchLevel::AVX2, GreaterThanBitmapAvx2}
 #endif
     };
   }
@@ -61,11 +60,10 @@ struct MinMaxDynamicFunction {
 
   static std::vector<std::pair<DispatchLevel, FunctionType>> implementations() {
     return {
-      { DispatchLevel::NONE, standard::FindMinMaxImpl }
+        {DispatchLevel::NONE, standard::FindMinMaxImpl}
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
-      , {
-        DispatchLevel::AVX2, FindMinMaxAvx2
-      }
+        ,
+        {DispatchLevel::AVX2, FindMinMaxAvx2}
 #endif
     };
   }
diff --git a/velox/dwio/parquet/writer/arrow/LevelConversion.cpp b/velox/dwio/parquet/writer/arrow/LevelConversion.cpp
index cbc4e13c3138d..22143af9e0d48 100644
--- a/velox/dwio/parquet/writer/arrow/LevelConversion.cpp
+++ b/velox/dwio/parquet/writer/arrow/LevelConversion.cpp
@@ -26,7 +26,7 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/cpu_info.h"
 #include "arrow/util/logging.h"
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 
 #include "velox/dwio/parquet/writer/arrow/LevelComparison.h"
 #define PARQUET_IMPL_NAMESPACE standard
@@ -37,7 +37,6 @@ namespace facebook::velox::parquet::arrow {
 namespace {
 
 using ::arrow::internal::CpuInfo;
-using ::parquet::ParquetException;
 using ::std::optional;
 
 template <typename OffsetType>
diff --git a/velox/dwio/parquet/writer/arrow/LevelConversionInc.h b/velox/dwio/parquet/writer/arrow/LevelConversionInc.h
index badfd1b8459b0..8c335ea17dd27 100644
--- a/velox/dwio/parquet/writer/arrow/LevelConversionInc.h
+++ b/velox/dwio/parquet/writer/arrow/LevelConversionInc.h
@@ -29,7 +29,7 @@
 #include "arrow/util/bitmap_writer.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/simd.h"
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/LevelComparison.h"
 
 #ifndef PARQUET_IMPL_NAMESPACE
@@ -38,8 +38,6 @@
 
 namespace facebook::velox::parquet::arrow::internal::PARQUET_IMPL_NAMESPACE {
 
-using ::parquet::ParquetException;
-
 // clang-format off
 /* Python code to generate lookup table:
 
diff --git a/velox/dwio/parquet/writer/arrow/Metadata.cpp b/velox/dwio/parquet/writer/arrow/Metadata.cpp
index dc811c1ad1294..b7bb942c4d5db 100644
--- a/velox/dwio/parquet/writer/arrow/Metadata.cpp
+++ b/velox/dwio/parquet/writer/arrow/Metadata.cpp
@@ -29,8 +29,8 @@
 #include "arrow/io/memory.h"
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
-#include "parquet/exception.h"
 #include "velox/dwio/parquet/writer/arrow/EncryptionInternal.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/FileDecryptorInternal.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 #include "velox/dwio/parquet/writer/arrow/SchemaInternal.h"
diff --git a/velox/dwio/parquet/writer/arrow/PageIndex.cpp b/velox/dwio/parquet/writer/arrow/PageIndex.cpp
index 04711628c8ed1..52b25fc7ae757 100644
--- a/velox/dwio/parquet/writer/arrow/PageIndex.cpp
+++ b/velox/dwio/parquet/writer/arrow/PageIndex.cpp
@@ -18,8 +18,8 @@
 
 #include "velox/dwio/parquet/writer/arrow/PageIndex.h"
 
-#include "parquet/exception.h"
 #include "velox/dwio/parquet/writer/arrow/Encoding.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Metadata.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 #include "velox/dwio/parquet/writer/arrow/Statistics.h"
diff --git a/velox/dwio/parquet/writer/arrow/PathInternal.cpp b/velox/dwio/parquet/writer/arrow/PathInternal.cpp
index 2f48fb3f90a72..d9e2a9f7503b7 100644
--- a/velox/dwio/parquet/writer/arrow/PathInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/PathInternal.cpp
@@ -898,6 +898,8 @@ class PathBuilder {
   // Types not yet supported in Parquet.
   NOT_IMPLEMENTED_VISIT(Union)
   NOT_IMPLEMENTED_VISIT(RunEndEncoded);
+  NOT_IMPLEMENTED_VISIT(ListView);
+  NOT_IMPLEMENTED_VISIT(LargeListView);
 
 #undef NOT_IMPLEMENTED_VISIT
   std::vector<PathInfo>& paths() {
diff --git a/velox/dwio/parquet/writer/arrow/Platform.cpp b/velox/dwio/parquet/writer/arrow/Platform.cpp
index 74ef72a474aae..66f27575d5d84 100644
--- a/velox/dwio/parquet/writer/arrow/Platform.cpp
+++ b/velox/dwio/parquet/writer/arrow/Platform.cpp
@@ -23,8 +23,7 @@
 #include <utility>
 
 #include "arrow/io/memory.h"
-
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 
 namespace facebook::velox::parquet::arrow {
 
diff --git a/velox/dwio/parquet/writer/arrow/Properties.h b/velox/dwio/parquet/writer/arrow/Properties.h
index c0eae9009c92d..563b9ae538364 100644
--- a/velox/dwio/parquet/writer/arrow/Properties.h
+++ b/velox/dwio/parquet/writer/arrow/Properties.h
@@ -27,8 +27,8 @@
 #include "arrow/io/caching.h"
 #include "arrow/type.h"
 #include "arrow/util/type_fwd.h"
-#include "parquet/exception.h"
 #include "velox/dwio/parquet/writer/arrow/Encryption.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
@@ -39,7 +39,6 @@
 
 namespace facebook::velox::parquet::arrow {
 
-using namespace ::parquet;
 using facebook::velox::parquet::arrow::util::CodecOptions;
 
 /// \brief Feature selection when writing Parquet files
diff --git a/velox/dwio/parquet/writer/arrow/Schema.cpp b/velox/dwio/parquet/writer/arrow/Schema.cpp
index eb8e77dff2613..a333044e701a9 100644
--- a/velox/dwio/parquet/writer/arrow/Schema.cpp
+++ b/velox/dwio/parquet/writer/arrow/Schema.cpp
@@ -28,7 +28,7 @@
 #include <utility>
 
 #include "arrow/util/logging.h"
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 
 using facebook::velox::parquet::arrow::format::SchemaElement;
 
@@ -785,8 +785,8 @@ struct SchemaPrinter : public Node::ConstVisitor {
 
   void Visit(const GroupNode* node) {
     PrintRepLevel(node->repetition(), stream_);
-    stream_ << " group "
-            << "field_id=" << node->field_id() << " " << node->name();
+    stream_ << " group " << "field_id=" << node->field_id() << " "
+            << node->name();
     auto lt = node->converted_type();
     auto la = node->logical_type();
     if (la && la->is_valid() && !la->is_none()) {
diff --git a/velox/dwio/parquet/writer/arrow/Statistics.cpp b/velox/dwio/parquet/writer/arrow/Statistics.cpp
index e35098bdb2af9..47229980385e5 100644
--- a/velox/dwio/parquet/writer/arrow/Statistics.cpp
+++ b/velox/dwio/parquet/writer/arrow/Statistics.cpp
@@ -34,8 +34,8 @@
 #include "arrow/util/logging.h"
 #include "arrow/util/ubsan.h"
 #include "arrow/visit_data_inline.h"
-#include "parquet/exception.h"
 #include "velox/dwio/parquet/writer/arrow/Encoding.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 
@@ -43,7 +43,6 @@ using arrow::default_memory_pool;
 using arrow::MemoryPool;
 using arrow::ResizableBuffer;
 using arrow::internal::checked_cast;
-using ::parquet::ParquetException;
 
 namespace facebook::velox::parquet::arrow {
 namespace {
diff --git a/velox/dwio/parquet/writer/arrow/ThriftInternal.h b/velox/dwio/parquet/writer/arrow/ThriftInternal.h
index 903ce5bea8f70..25acd8f26723f 100644
--- a/velox/dwio/parquet/writer/arrow/ThriftInternal.h
+++ b/velox/dwio/parquet/writer/arrow/ThriftInternal.h
@@ -36,7 +36,7 @@
 
 #include "arrow/util/logging.h"
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/FileDecryptorInternal.h"
 #include "velox/dwio/parquet/writer/arrow/FileEncryptorInternal.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
diff --git a/velox/dwio/parquet/writer/arrow/Types.cpp b/velox/dwio/parquet/writer/arrow/Types.cpp
index d0998d248f5d2..2e4c857f899a5 100644
--- a/velox/dwio/parquet/writer/arrow/Types.cpp
+++ b/velox/dwio/parquet/writer/arrow/Types.cpp
@@ -24,12 +24,11 @@
 
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/logging.h"
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
 #include "velox/dwio/parquet/writer/arrow/generated/parquet_types.h"
 
 using arrow::internal::checked_cast;
-using parquet::ParquetException;
 
 namespace facebook::velox::parquet::arrow {
 
diff --git a/velox/dwio/parquet/writer/arrow/Writer.cpp b/velox/dwio/parquet/writer/arrow/Writer.cpp
index 1d3a81d42b5d9..6bcbfabb8ecac 100644
--- a/velox/dwio/parquet/writer/arrow/Writer.cpp
+++ b/velox/dwio/parquet/writer/arrow/Writer.cpp
@@ -38,9 +38,9 @@
 #include "arrow/util/logging.h"
 #include "arrow/util/parallel.h"
 
-#include "parquet/exception.h"
 #include "velox/dwio/parquet/writer/arrow/ArrowSchema.h"
 #include "velox/dwio/parquet/writer/arrow/ColumnWriter.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/FileWriter.h"
 #include "velox/dwio/parquet/writer/arrow/PathInternal.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
diff --git a/velox/dwio/parquet/writer/arrow/generated/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/generated/CMakeLists.txt
index a37f134ede800..fefbb35e37727 100644
--- a/velox/dwio/parquet/writer/arrow/generated/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/generated/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_dwio_arrow_parquet_writer_thrift_lib parquet_types.cpp)
+velox_add_library(velox_dwio_arrow_parquet_writer_thrift_lib parquet_types.cpp)
 
-target_link_libraries(velox_dwio_arrow_parquet_writer_thrift_lib arrow
-                      Boost::headers)
+velox_link_libraries(velox_dwio_arrow_parquet_writer_thrift_lib arrow
+                     Boost::headers)
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp b/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
index a21af4628bc6e..c15381b3c8f6c 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
@@ -24,7 +24,7 @@
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/ThriftInternal.h"
 #include "velox/dwio/parquet/writer/arrow/generated/parquet_types.h"
 #include "velox/dwio/parquet/writer/arrow/tests/BloomFilter.h"
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.cpp b/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.cpp
index e7141f1ee460f..152ebf32d7720 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.cpp
@@ -17,7 +17,7 @@
 // Adapted from Apache Arrow.
 
 #include "velox/dwio/parquet/writer/arrow/tests/BloomFilterReader.h"
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Metadata.h"
 #include "velox/dwio/parquet/writer/arrow/tests/BloomFilter.h"
 
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp b/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
index 016b1e51fda7e..644fda5a678fb 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
@@ -32,7 +32,7 @@
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/random.h"
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
 #include "velox/dwio/parquet/writer/arrow/tests/BloomFilter.h"
diff --git a/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
index ce1bc6782014c..0cda25430f2c1 100644
--- a/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
@@ -33,12 +33,10 @@ add_test(velox_dwio_arrow_parquet_writer_test
 
 target_link_libraries(
   velox_dwio_arrow_parquet_writer_test
-  velox_dwio_arrow_parquet_writer_lib
   velox_dwio_arrow_parquet_writer_test_lib
-  gmock
-  gtest
-  gtest_main
-  parquet
+  GTest::gmock
+  GTest::gtest
+  GTest::gtest_main
   arrow
   arrow_testing)
 
@@ -52,5 +50,6 @@ add_library(
   TestUtil.cpp
   XxHasher.cpp)
 
-target_link_libraries(velox_dwio_arrow_parquet_writer_test_lib
-                      velox_dwio_arrow_parquet_writer_lib parquet arrow gtest)
+target_link_libraries(
+  velox_dwio_arrow_parquet_writer_test_lib arrow
+  velox_dwio_arrow_parquet_writer_lib GTest::gtest)
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnReader.h b/velox/dwio/parquet/writer/arrow/tests/ColumnReader.h
index 1daccd7f21bea..57b7911d5d20e 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnReader.h
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnReader.h
@@ -23,7 +23,7 @@
 #include <utility>
 #include <vector>
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/LevelConversion.h"
 #include "velox/dwio/parquet/writer/arrow/Metadata.h"
 #include "velox/dwio/parquet/writer/arrow/Properties.h"
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.h b/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.h
index e4e8bd8a7cb14..5729a4c05cebc 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.h
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnScanner.h
@@ -27,7 +27,7 @@
 #include <utility>
 #include <vector>
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp b/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
index cefe2f2255b9f..c6cb01b82b1c3 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
@@ -613,7 +613,6 @@ TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithStatsAndGzipCompression) {
       Encoding::PLAIN, Compression::GZIP, false, true, LARGE_SIZE);
 }
 
-#ifdef ARROW_WITH_LZ4
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithLz4Compression) {
   this->TestRequiredWithSettings(
       Encoding::PLAIN, Compression::LZ4, false, false, LARGE_SIZE);
@@ -623,7 +622,6 @@ TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithStatsAndLz4Compression) {
   this->TestRequiredWithSettings(
       Encoding::PLAIN, Compression::LZ4, false, true, LARGE_SIZE);
 }
-#endif
 
 TYPED_TEST(TestPrimitiveWriter, RequiredPlainWithZstdCompression) {
   this->TestRequiredWithSettings(
diff --git a/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp b/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
index ee2e3877e0964..161e6a22cf57a 100644
--- a/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
@@ -38,7 +38,6 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/bitmap_writer.h"
-#include "arrow/util/byte_stream_split.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/hashing.h"
 #include "arrow/util/int_util_overflow.h"
@@ -47,10 +46,11 @@
 #include "arrow/util/ubsan.h"
 #include "arrow/visit_data_inline.h"
 
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 #include "velox/dwio/parquet/writer/arrow/Types.h"
+#include "velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h"
 
 namespace bit_util = arrow::bit_util;
 
@@ -60,7 +60,6 @@ using arrow::internal::AddWithOverflow;
 using arrow::internal::checked_cast;
 using arrow::util::SafeLoad;
 using arrow::util::SafeLoadAs;
-using ::parquet::ParquetException;
 using std::string_view;
 
 template <typename T>
@@ -1005,7 +1004,7 @@ std::shared_ptr<Buffer> ByteStreamSplitEncoder<DType>::FlushValues() {
       AllocateBuffer(this->memory_pool(), EstimatedDataEncodedSize());
   uint8_t* output_buffer_raw = output_buffer->mutable_data();
   const uint8_t* raw_values = sink_.data();
-  ::arrow::util::internal::ByteStreamSplitEncode<T>(
+  ByteStreamSplitEncode<T>(
       raw_values, num_values_in_buffer_, output_buffer_raw);
   sink_.Reset();
   num_values_in_buffer_ = 0;
@@ -3400,7 +3399,7 @@ class RleBooleanDecoder : public DecoderImpl, virtual public BooleanDecoder {
     }
     // Load the first 4 bytes in little-endian, which indicates the length
     num_bytes = ::arrow::bit_util::FromLittleEndian(SafeLoadAs<uint32_t>(data));
-    if (num_bytes < 0 || num_bytes > static_cast<uint32_t>(len - 4)) {
+    if (num_bytes > static_cast<uint32_t>(len - 4)) {
       throw ParquetException(
           "Received invalid number of bytes : " + std::to_string(num_bytes) +
           " (corrupt data page?)");
@@ -3735,7 +3734,7 @@ int ByteStreamSplitDecoder<DType>::Decode(T* buffer, int max_values) {
   const int num_decoded_previously = num_values_in_buffer_ - num_values_;
   const uint8_t* data = data_ + num_decoded_previously;
 
-  ::arrow::util::internal::ByteStreamSplitDecode<T>(
+  ByteStreamSplitDecode<T>(
       data, values_to_decode, num_values_in_buffer_, buffer);
   num_values_ -= values_to_decode;
   len_ -= sizeof(T) * values_to_decode;
diff --git a/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp b/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
index efa97b634fbbc..c764551d2df01 100644
--- a/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
@@ -24,8 +24,8 @@
 #include <memory>
 #include <optional>
 
-#include "parquet/exception.h"
 #include "velox/dwio/parquet/writer/arrow/ColumnPage.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/FileWriter.h"
 #include "velox/dwio/parquet/writer/arrow/Metadata.h"
 #include "velox/dwio/parquet/writer/arrow/Platform.h"
@@ -36,7 +36,6 @@
 #include "velox/dwio/parquet/writer/arrow/tests/TestUtil.h"
 
 #include "arrow/io/memory.h"
-#include "arrow/status.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/compression.h"
 #include "arrow/util/crc32.h"
@@ -95,10 +94,8 @@ static std::vector<Compression::type> GetSupportedCodecTypes() {
 
   codec_types.push_back(Compression::GZIP);
 
-#ifdef ARROW_WITH_LZ4
   codec_types.push_back(Compression::LZ4);
   codec_types.push_back(Compression::LZ4_HADOOP);
-#endif
 
   codec_types.push_back(Compression::ZSTD);
   return codec_types;
diff --git a/velox/dwio/parquet/writer/arrow/tests/FileReader.cpp b/velox/dwio/parquet/writer/arrow/tests/FileReader.cpp
index a30c9923a5975..79c79ef76c19e 100644
--- a/velox/dwio/parquet/writer/arrow/tests/FileReader.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/FileReader.cpp
@@ -36,9 +36,9 @@
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/ubsan.h"
-#include "parquet/exception.h"
 
 #include "velox/dwio/parquet/writer/arrow/EncryptionInternal.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/FileDecryptorInternal.h"
 #include "velox/dwio/parquet/writer/arrow/FileWriter.h"
 #include "velox/dwio/parquet/writer/arrow/Metadata.h"
diff --git a/velox/dwio/parquet/writer/arrow/tests/FileSerializeTest.cpp b/velox/dwio/parquet/writer/arrow/tests/FileSerializeTest.cpp
index 1bd753c3dac69..1a939b49a9a27 100644
--- a/velox/dwio/parquet/writer/arrow/tests/FileSerializeTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/FileSerializeTest.cpp
@@ -381,7 +381,6 @@ TYPED_TEST(TestSerialize, SmallFileGzip) {
   ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::GZIP));
 }
 
-#ifdef ARROW_WITH_LZ4
 TYPED_TEST(TestSerialize, SmallFileLz4) {
   ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::LZ4));
 }
@@ -389,7 +388,6 @@ TYPED_TEST(TestSerialize, SmallFileLz4) {
 TYPED_TEST(TestSerialize, SmallFileLz4Hadoop) {
   ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::LZ4_HADOOP));
 }
-#endif
 
 TYPED_TEST(TestSerialize, SmallFileZstd) {
   ASSERT_NO_FATAL_FAILURE(this->FileSerializeTest(Compression::ZSTD));
diff --git a/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp b/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
index bc50ce8d09a71..19a591e3ae4e4 100644
--- a/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
@@ -27,7 +27,7 @@
 #include <vector>
 
 #include "arrow/util/checked_cast.h"
-#include "parquet/exception.h"
+#include "velox/dwio/parquet/writer/arrow/Exception.h"
 #include "velox/dwio/parquet/writer/arrow/Schema.h"
 #include "velox/dwio/parquet/writer/arrow/SchemaInternal.h"
 #include "velox/dwio/parquet/writer/arrow/ThriftInternal.h"
diff --git a/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h b/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h
new file mode 100644
index 0000000000000..45e5b025ff1e8
--- /dev/null
+++ b/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h
@@ -0,0 +1,846 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#pragma once
+
+#include "arrow/util/endian.h"
+#include "arrow/util/simd.h"
+#include "arrow/util/ubsan.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+
+#ifdef ARROW_HAVE_SSE4_2
+// Enable the SIMD for ByteStreamSplit Encoder/Decoder
+#define ARROW_HAVE_SIMD_SPLIT
+#endif // ARROW_HAVE_SSE4_2
+
+namespace facebook::velox::parquet::arrow {
+
+//
+// SIMD implementations
+//
+
+#if defined(ARROW_HAVE_SSE4_2)
+template <typename T>
+void ByteStreamSplitDecodeSse2(
+    const uint8_t* data,
+    int64_t num_values,
+    int64_t stride,
+    T* out) {
+  constexpr size_t kNumStreams = sizeof(T);
+  static_assert(
+      kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
+  constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
+  constexpr int64_t kBlockSize = sizeof(__m128i) * kNumStreams;
+
+  const int64_t size = num_values * sizeof(T);
+  const int64_t num_blocks = size / kBlockSize;
+  uint8_t* output_data = reinterpret_cast<uint8_t*>(out);
+
+  // First handle suffix.
+  // This helps catch if the simd-based processing overflows into the suffix
+  // since almost surely a test would fail.
+  const int64_t num_processed_elements =
+      (num_blocks * kBlockSize) / kNumStreams;
+  for (int64_t i = num_processed_elements; i < num_values; ++i) {
+    uint8_t gathered_byte_data[kNumStreams];
+    for (size_t b = 0; b < kNumStreams; ++b) {
+      const size_t byte_index = b * stride + i;
+      gathered_byte_data[b] = data[byte_index];
+    }
+    out[i] = arrow::util::SafeLoadAs<T>(&gathered_byte_data[0]);
+  }
+
+  // The blocks get processed hierarchically using the unpack intrinsics.
+  // Example with four streams:
+  // Stage 1: AAAA BBBB CCCC DDDD
+  // Stage 2: ACAC ACAC BDBD BDBD
+  // Stage 3: ABCD ABCD ABCD ABCD
+  __m128i stage[kNumStreamsLog2 + 1U][kNumStreams];
+  constexpr size_t kNumStreamsHalf = kNumStreams / 2U;
+
+  for (int64_t i = 0; i < num_blocks; ++i) {
+    for (size_t j = 0; j < kNumStreams; ++j) {
+      stage[0][j] = _mm_loadu_si128(reinterpret_cast<const __m128i*>(
+          &data[i * sizeof(__m128i) + j * stride]));
+    }
+    for (size_t step = 0; step < kNumStreamsLog2; ++step) {
+      for (size_t j = 0; j < kNumStreamsHalf; ++j) {
+        stage[step + 1U][j * 2] =
+            _mm_unpacklo_epi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
+        stage[step + 1U][j * 2 + 1U] =
+            _mm_unpackhi_epi8(stage[step][j], stage[step][kNumStreamsHalf + j]);
+      }
+    }
+    for (size_t j = 0; j < kNumStreams; ++j) {
+      _mm_storeu_si128(
+          reinterpret_cast<__m128i*>(
+              &output_data[(i * kNumStreams + j) * sizeof(__m128i)]),
+          stage[kNumStreamsLog2][j]);
+    }
+  }
+}
+
+template <typename T>
+void ByteStreamSplitEncodeSse2(
+    const uint8_t* raw_values,
+    const size_t num_values,
+    uint8_t* output_buffer_raw) {
+  constexpr size_t kNumStreams = sizeof(T);
+  static_assert(
+      kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
+  constexpr size_t kBlockSize = sizeof(__m128i) * kNumStreams;
+
+  __m128i stage[3][kNumStreams];
+  __m128i final_result[kNumStreams];
+
+  const size_t size = num_values * sizeof(T);
+  const size_t num_blocks = size / kBlockSize;
+  const __m128i* raw_values_sse = reinterpret_cast<const __m128i*>(raw_values);
+  __m128i* output_buffer_streams[kNumStreams];
+  for (size_t i = 0; i < kNumStreams; ++i) {
+    output_buffer_streams[i] =
+        reinterpret_cast<__m128i*>(&output_buffer_raw[num_values * i]);
+  }
+
+  // First handle suffix.
+  const size_t num_processed_elements = (num_blocks * kBlockSize) / sizeof(T);
+  for (size_t i = num_processed_elements; i < num_values; ++i) {
+    for (size_t j = 0U; j < kNumStreams; ++j) {
+      const uint8_t byte_in_value = raw_values[i * kNumStreams + j];
+      output_buffer_raw[j * num_values + i] = byte_in_value;
+    }
+  }
+  // The current shuffling algorithm diverges for float and double types but the
+  // compiler should be able to remove the branch since only one path is taken
+  // for each template instantiation. Example run for floats: Step 0, copy:
+  //   0: ABCD ABCD ABCD ABCD 1: ABCD ABCD ABCD ABCD ...
+  // Step 1: _mm_unpacklo_epi8 and mm_unpackhi_epi8:
+  //   0: AABB CCDD AABB CCDD 1: AABB CCDD AABB CCDD ...
+  //   0: AAAA BBBB CCCC DDDD 1: AAAA BBBB CCCC DDDD ...
+  // Step 3: __mm_unpacklo_epi8 and _mm_unpackhi_epi8:
+  //   0: AAAA AAAA BBBB BBBB 1: CCCC CCCC DDDD DDDD ...
+  // Step 4: __mm_unpacklo_epi64 and _mm_unpackhi_epi64:
+  //   0: AAAA AAAA AAAA AAAA 1: BBBB BBBB BBBB BBBB ...
+  for (size_t block_index = 0; block_index < num_blocks; ++block_index) {
+    // First copy the data to stage 0.
+    for (size_t i = 0; i < kNumStreams; ++i) {
+      stage[0][i] =
+          _mm_loadu_si128(&raw_values_sse[block_index * kNumStreams + i]);
+    }
+
+    // The shuffling of bytes is performed through the unpack intrinsics.
+    // In my measurements this gives better performance then an implementation
+    // which uses the shuffle intrinsics.
+    for (size_t stage_lvl = 0; stage_lvl < 2U; ++stage_lvl) {
+      for (size_t i = 0; i < kNumStreams / 2U; ++i) {
+        stage[stage_lvl + 1][i * 2] = _mm_unpacklo_epi8(
+            stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
+        stage[stage_lvl + 1][i * 2 + 1] = _mm_unpackhi_epi8(
+            stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
+      }
+    }
+    if constexpr (kNumStreams == 8U) {
+      // This is the path for double.
+      __m128i tmp[8];
+      for (size_t i = 0; i < 4; ++i) {
+        tmp[i * 2] = _mm_unpacklo_epi32(stage[2][i], stage[2][i + 4]);
+        tmp[i * 2 + 1] = _mm_unpackhi_epi32(stage[2][i], stage[2][i + 4]);
+      }
+
+      for (size_t i = 0; i < 4; ++i) {
+        final_result[i * 2] = _mm_unpacklo_epi32(tmp[i], tmp[i + 4]);
+        final_result[i * 2 + 1] = _mm_unpackhi_epi32(tmp[i], tmp[i + 4]);
+      }
+    } else {
+      // this is the path for float.
+      __m128i tmp[4];
+      for (size_t i = 0; i < 2; ++i) {
+        tmp[i * 2] = _mm_unpacklo_epi8(stage[2][i * 2], stage[2][i * 2 + 1]);
+        tmp[i * 2 + 1] =
+            _mm_unpackhi_epi8(stage[2][i * 2], stage[2][i * 2 + 1]);
+      }
+      for (size_t i = 0; i < 2; ++i) {
+        final_result[i * 2] = _mm_unpacklo_epi64(tmp[i], tmp[i + 2]);
+        final_result[i * 2 + 1] = _mm_unpackhi_epi64(tmp[i], tmp[i + 2]);
+      }
+    }
+    for (size_t i = 0; i < kNumStreams; ++i) {
+      _mm_storeu_si128(&output_buffer_streams[i][block_index], final_result[i]);
+    }
+  }
+}
+#endif // ARROW_HAVE_SSE4_2
+
+#if defined(ARROW_HAVE_AVX2)
+template <typename T>
+void ByteStreamSplitDecodeAvx2(
+    const uint8_t* data,
+    int64_t num_values,
+    int64_t stride,
+    T* out) {
+  constexpr size_t kNumStreams = sizeof(T);
+  static_assert(
+      kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
+  constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
+  constexpr int64_t kBlockSize = sizeof(__m256i) * kNumStreams;
+
+  const int64_t size = num_values * sizeof(T);
+  if (size < kBlockSize) // Back to SSE for small size
+    return ByteStreamSplitDecodeSse2(data, num_values, stride, out);
+  const int64_t num_blocks = size / kBlockSize;
+  uint8_t* output_data = reinterpret_cast<uint8_t*>(out);
+
+  // First handle suffix.
+  const int64_t num_processed_elements =
+      (num_blocks * kBlockSize) / kNumStreams;
+  for (int64_t i = num_processed_elements; i < num_values; ++i) {
+    uint8_t gathered_byte_data[kNumStreams];
+    for (size_t b = 0; b < kNumStreams; ++b) {
+      const size_t byte_index = b * stride + i;
+      gathered_byte_data[b] = data[byte_index];
+    }
+    out[i] = arrow::util::SafeLoadAs<T>(&gathered_byte_data[0]);
+  }
+
+  // Processed hierarchically using unpack intrinsics, then permute intrinsics.
+  __m256i stage[kNumStreamsLog2 + 1U][kNumStreams];
+  __m256i final_result[kNumStreams];
+  constexpr size_t kNumStreamsHalf = kNumStreams / 2U;
+
+  for (int64_t i = 0; i < num_blocks; ++i) {
+    for (size_t j = 0; j < kNumStreams; ++j) {
+      stage[0][j] = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(
+          &data[i * sizeof(__m256i) + j * stride]));
+    }
+
+    for (size_t step = 0; step < kNumStreamsLog2; ++step) {
+      for (size_t j = 0; j < kNumStreamsHalf; ++j) {
+        stage[step + 1U][j * 2] = _mm256_unpacklo_epi8(
+            stage[step][j], stage[step][kNumStreamsHalf + j]);
+        stage[step + 1U][j * 2 + 1U] = _mm256_unpackhi_epi8(
+            stage[step][j], stage[step][kNumStreamsHalf + j]);
+      }
+    }
+
+    if constexpr (kNumStreams == 8U) {
+      // path for double, 128i index:
+      //   {0x00, 0x08}, {0x01, 0x09}, {0x02, 0x0A}, {0x03, 0x0B},
+      //   {0x04, 0x0C}, {0x05, 0x0D}, {0x06, 0x0E}, {0x07, 0x0F},
+      final_result[0] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b00100000);
+      final_result[1] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b00100000);
+      final_result[2] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][4], stage[kNumStreamsLog2][5], 0b00100000);
+      final_result[3] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][6], stage[kNumStreamsLog2][7], 0b00100000);
+      final_result[4] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b00110001);
+      final_result[5] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b00110001);
+      final_result[6] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][4], stage[kNumStreamsLog2][5], 0b00110001);
+      final_result[7] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][6], stage[kNumStreamsLog2][7], 0b00110001);
+    } else {
+      // path for float, 128i index:
+      //   {0x00, 0x04}, {0x01, 0x05}, {0x02, 0x06}, {0x03, 0x07}
+      final_result[0] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b00100000);
+      final_result[1] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b00100000);
+      final_result[2] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b00110001);
+      final_result[3] = _mm256_permute2x128_si256(
+          stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b00110001);
+    }
+
+    for (size_t j = 0; j < kNumStreams; ++j) {
+      _mm256_storeu_si256(
+          reinterpret_cast<__m256i*>(
+              &output_data[(i * kNumStreams + j) * sizeof(__m256i)]),
+          final_result[j]);
+    }
+  }
+}
+
+template <typename T>
+void ByteStreamSplitEncodeAvx2(
+    const uint8_t* raw_values,
+    const size_t num_values,
+    uint8_t* output_buffer_raw) {
+  constexpr size_t kNumStreams = sizeof(T);
+  static_assert(
+      kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
+  constexpr size_t kBlockSize = sizeof(__m256i) * kNumStreams;
+
+  if constexpr (kNumStreams == 8U) // Back to SSE, currently no path for double.
+    return ByteStreamSplitEncodeSse2<T>(
+        raw_values, num_values, output_buffer_raw);
+
+  const size_t size = num_values * sizeof(T);
+  if (size < kBlockSize) // Back to SSE for small size
+    return ByteStreamSplitEncodeSse2<T>(
+        raw_values, num_values, output_buffer_raw);
+  const size_t num_blocks = size / kBlockSize;
+  const __m256i* raw_values_simd = reinterpret_cast<const __m256i*>(raw_values);
+  __m256i* output_buffer_streams[kNumStreams];
+
+  for (size_t i = 0; i < kNumStreams; ++i) {
+    output_buffer_streams[i] =
+        reinterpret_cast<__m256i*>(&output_buffer_raw[num_values * i]);
+  }
+
+  // First handle suffix.
+  const size_t num_processed_elements = (num_blocks * kBlockSize) / sizeof(T);
+  for (size_t i = num_processed_elements; i < num_values; ++i) {
+    for (size_t j = 0U; j < kNumStreams; ++j) {
+      const uint8_t byte_in_value = raw_values[i * kNumStreams + j];
+      output_buffer_raw[j * num_values + i] = byte_in_value;
+    }
+  }
+
+  // Path for float.
+  // 1. Processed hierarchically to 32i block using the unpack intrinsics.
+  // 2. Pack 128i block using _mm256_permutevar8x32_epi32.
+  // 3. Pack final 256i block with _mm256_permute2x128_si256.
+  constexpr size_t kNumUnpack = 3U;
+  __m256i stage[kNumUnpack + 1][kNumStreams];
+  static const __m256i kPermuteMask =
+      _mm256_set_epi32(0x07, 0x03, 0x06, 0x02, 0x05, 0x01, 0x04, 0x00);
+  __m256i permute[kNumStreams];
+  __m256i final_result[kNumStreams];
+
+  for (size_t block_index = 0; block_index < num_blocks; ++block_index) {
+    for (size_t i = 0; i < kNumStreams; ++i) {
+      stage[0][i] =
+          _mm256_loadu_si256(&raw_values_simd[block_index * kNumStreams + i]);
+    }
+
+    for (size_t stage_lvl = 0; stage_lvl < kNumUnpack; ++stage_lvl) {
+      for (size_t i = 0; i < kNumStreams / 2U; ++i) {
+        stage[stage_lvl + 1][i * 2] = _mm256_unpacklo_epi8(
+            stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
+        stage[stage_lvl + 1][i * 2 + 1] = _mm256_unpackhi_epi8(
+            stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
+      }
+    }
+
+    for (size_t i = 0; i < kNumStreams; ++i) {
+      permute[i] =
+          _mm256_permutevar8x32_epi32(stage[kNumUnpack][i], kPermuteMask);
+    }
+
+    final_result[0] =
+        _mm256_permute2x128_si256(permute[0], permute[2], 0b00100000);
+    final_result[1] =
+        _mm256_permute2x128_si256(permute[0], permute[2], 0b00110001);
+    final_result[2] =
+        _mm256_permute2x128_si256(permute[1], permute[3], 0b00100000);
+    final_result[3] =
+        _mm256_permute2x128_si256(permute[1], permute[3], 0b00110001);
+
+    for (size_t i = 0; i < kNumStreams; ++i) {
+      _mm256_storeu_si256(
+          &output_buffer_streams[i][block_index], final_result[i]);
+    }
+  }
+}
+#endif // ARROW_HAVE_AVX2
+
+#if defined(ARROW_HAVE_AVX512)
+template <typename T>
+void ByteStreamSplitDecodeAvx512(
+    const uint8_t* data,
+    int64_t num_values,
+    int64_t stride,
+    T* out) {
+  constexpr size_t kNumStreams = sizeof(T);
+  static_assert(
+      kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
+  constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
+  constexpr int64_t kBlockSize = sizeof(__m512i) * kNumStreams;
+
+  const int64_t size = num_values * sizeof(T);
+  if (size < kBlockSize) // Back to AVX2 for small size
+    return ByteStreamSplitDecodeAvx2(data, num_values, stride, out);
+  const int64_t num_blocks = size / kBlockSize;
+  uint8_t* output_data = reinterpret_cast<uint8_t*>(out);
+
+  // First handle suffix.
+  const int64_t num_processed_elements =
+      (num_blocks * kBlockSize) / kNumStreams;
+  for (int64_t i = num_processed_elements; i < num_values; ++i) {
+    uint8_t gathered_byte_data[kNumStreams];
+    for (size_t b = 0; b < kNumStreams; ++b) {
+      const size_t byte_index = b * stride + i;
+      gathered_byte_data[b] = data[byte_index];
+    }
+    out[i] = arrow::util::SafeLoadAs<T>(&gathered_byte_data[0]);
+  }
+
+  // Processed hierarchically using the unpack, then two shuffles.
+  __m512i stage[kNumStreamsLog2 + 1U][kNumStreams];
+  __m512i shuffle[kNumStreams];
+  __m512i final_result[kNumStreams];
+  constexpr size_t kNumStreamsHalf = kNumStreams / 2U;
+
+  for (int64_t i = 0; i < num_blocks; ++i) {
+    for (size_t j = 0; j < kNumStreams; ++j) {
+      stage[0][j] = _mm512_loadu_si512(reinterpret_cast<const __m512i*>(
+          &data[i * sizeof(__m512i) + j * stride]));
+    }
+
+    for (size_t step = 0; step < kNumStreamsLog2; ++step) {
+      for (size_t j = 0; j < kNumStreamsHalf; ++j) {
+        stage[step + 1U][j * 2] = _mm512_unpacklo_epi8(
+            stage[step][j], stage[step][kNumStreamsHalf + j]);
+        stage[step + 1U][j * 2 + 1U] = _mm512_unpackhi_epi8(
+            stage[step][j], stage[step][kNumStreamsHalf + j]);
+      }
+    }
+
+    if constexpr (kNumStreams == 8U) {
+      // path for double, 128i index:
+      // {0x00, 0x04, 0x08, 0x0C}, {0x10, 0x14, 0x18, 0x1C},
+      // {0x01, 0x05, 0x09, 0x0D}, {0x11, 0x15, 0x19, 0x1D},
+      // {0x02, 0x06, 0x0A, 0x0E}, {0x12, 0x16, 0x1A, 0x1E},
+      // {0x03, 0x07, 0x0B, 0x0F}, {0x13, 0x17, 0x1B, 0x1F},
+      shuffle[0] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b01000100);
+      shuffle[1] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b01000100);
+      shuffle[2] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][4], stage[kNumStreamsLog2][5], 0b01000100);
+      shuffle[3] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][6], stage[kNumStreamsLog2][7], 0b01000100);
+      shuffle[4] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b11101110);
+      shuffle[5] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b11101110);
+      shuffle[6] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][4], stage[kNumStreamsLog2][5], 0b11101110);
+      shuffle[7] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][6], stage[kNumStreamsLog2][7], 0b11101110);
+
+      final_result[0] =
+          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b10001000);
+      final_result[1] =
+          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b10001000);
+      final_result[2] =
+          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b11011101);
+      final_result[3] =
+          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b11011101);
+      final_result[4] =
+          _mm512_shuffle_i32x4(shuffle[4], shuffle[5], 0b10001000);
+      final_result[5] =
+          _mm512_shuffle_i32x4(shuffle[6], shuffle[7], 0b10001000);
+      final_result[6] =
+          _mm512_shuffle_i32x4(shuffle[4], shuffle[5], 0b11011101);
+      final_result[7] =
+          _mm512_shuffle_i32x4(shuffle[6], shuffle[7], 0b11011101);
+    } else {
+      // path for float, 128i index:
+      // {0x00, 0x04, 0x08, 0x0C}, {0x01, 0x05, 0x09, 0x0D}
+      // {0x02, 0x06, 0x0A, 0x0E}, {0x03, 0x07, 0x0B, 0x0F},
+      shuffle[0] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b01000100);
+      shuffle[1] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b01000100);
+      shuffle[2] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][0], stage[kNumStreamsLog2][1], 0b11101110);
+      shuffle[3] = _mm512_shuffle_i32x4(
+          stage[kNumStreamsLog2][2], stage[kNumStreamsLog2][3], 0b11101110);
+
+      final_result[0] =
+          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b10001000);
+      final_result[1] =
+          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b11011101);
+      final_result[2] =
+          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b10001000);
+      final_result[3] =
+          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b11011101);
+    }
+
+    for (size_t j = 0; j < kNumStreams; ++j) {
+      _mm512_storeu_si512(
+          reinterpret_cast<__m512i*>(
+              &output_data[(i * kNumStreams + j) * sizeof(__m512i)]),
+          final_result[j]);
+    }
+  }
+}
+
+template <typename T>
+void ByteStreamSplitEncodeAvx512(
+    const uint8_t* raw_values,
+    const size_t num_values,
+    uint8_t* output_buffer_raw) {
+  constexpr size_t kNumStreams = sizeof(T);
+  static_assert(
+      kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
+  constexpr size_t kBlockSize = sizeof(__m512i) * kNumStreams;
+
+  const size_t size = num_values * sizeof(T);
+
+  if (size < kBlockSize) // Back to AVX2 for small size
+    return ByteStreamSplitEncodeAvx2<T>(
+        raw_values, num_values, output_buffer_raw);
+
+  const size_t num_blocks = size / kBlockSize;
+  const __m512i* raw_values_simd = reinterpret_cast<const __m512i*>(raw_values);
+  __m512i* output_buffer_streams[kNumStreams];
+  for (size_t i = 0; i < kNumStreams; ++i) {
+    output_buffer_streams[i] =
+        reinterpret_cast<__m512i*>(&output_buffer_raw[num_values * i]);
+  }
+
+  // First handle suffix.
+  const size_t num_processed_elements = (num_blocks * kBlockSize) / sizeof(T);
+  for (size_t i = num_processed_elements; i < num_values; ++i) {
+    for (size_t j = 0U; j < kNumStreams; ++j) {
+      const uint8_t byte_in_value = raw_values[i * kNumStreams + j];
+      output_buffer_raw[j * num_values + i] = byte_in_value;
+    }
+  }
+
+  constexpr size_t KNumUnpack = (kNumStreams == 8U) ? 2U : 3U;
+  __m512i final_result[kNumStreams];
+  __m512i unpack[KNumUnpack + 1][kNumStreams];
+  __m512i permutex[kNumStreams];
+  __m512i permutex_mask;
+  if constexpr (kNumStreams == 8U) {
+    // use _mm512_set_epi32, no _mm512_set_epi16 for some old gcc version.
+    permutex_mask = _mm512_set_epi32(
+        0x001F0017,
+        0x000F0007,
+        0x001E0016,
+        0x000E0006,
+        0x001D0015,
+        0x000D0005,
+        0x001C0014,
+        0x000C0004,
+        0x001B0013,
+        0x000B0003,
+        0x001A0012,
+        0x000A0002,
+        0x00190011,
+        0x00090001,
+        0x00180010,
+        0x00080000);
+  } else {
+    permutex_mask = _mm512_set_epi32(
+        0x0F,
+        0x0B,
+        0x07,
+        0x03,
+        0x0E,
+        0x0A,
+        0x06,
+        0x02,
+        0x0D,
+        0x09,
+        0x05,
+        0x01,
+        0x0C,
+        0x08,
+        0x04,
+        0x00);
+  }
+
+  for (size_t block_index = 0; block_index < num_blocks; ++block_index) {
+    for (size_t i = 0; i < kNumStreams; ++i) {
+      unpack[0][i] =
+          _mm512_loadu_si512(&raw_values_simd[block_index * kNumStreams + i]);
+    }
+
+    for (size_t unpack_lvl = 0; unpack_lvl < KNumUnpack; ++unpack_lvl) {
+      for (size_t i = 0; i < kNumStreams / 2U; ++i) {
+        unpack[unpack_lvl + 1][i * 2] = _mm512_unpacklo_epi8(
+            unpack[unpack_lvl][i * 2], unpack[unpack_lvl][i * 2 + 1]);
+        unpack[unpack_lvl + 1][i * 2 + 1] = _mm512_unpackhi_epi8(
+            unpack[unpack_lvl][i * 2], unpack[unpack_lvl][i * 2 + 1]);
+      }
+    }
+
+    if constexpr (kNumStreams == 8U) {
+      // path for double
+      // 1. unpack to epi16 block
+      // 2. permutexvar_epi16 to 128i block
+      // 3. shuffle 128i to final 512i target, index:
+      //   {0x00, 0x04, 0x08, 0x0C}, {0x10, 0x14, 0x18, 0x1C},
+      //   {0x01, 0x05, 0x09, 0x0D}, {0x11, 0x15, 0x19, 0x1D},
+      //   {0x02, 0x06, 0x0A, 0x0E}, {0x12, 0x16, 0x1A, 0x1E},
+      //   {0x03, 0x07, 0x0B, 0x0F}, {0x13, 0x17, 0x1B, 0x1F},
+      for (size_t i = 0; i < kNumStreams; ++i)
+        permutex[i] =
+            _mm512_permutexvar_epi16(permutex_mask, unpack[KNumUnpack][i]);
+
+      __m512i shuffle[kNumStreams];
+      shuffle[0] = _mm512_shuffle_i32x4(permutex[0], permutex[2], 0b01000100);
+      shuffle[1] = _mm512_shuffle_i32x4(permutex[4], permutex[6], 0b01000100);
+      shuffle[2] = _mm512_shuffle_i32x4(permutex[0], permutex[2], 0b11101110);
+      shuffle[3] = _mm512_shuffle_i32x4(permutex[4], permutex[6], 0b11101110);
+      shuffle[4] = _mm512_shuffle_i32x4(permutex[1], permutex[3], 0b01000100);
+      shuffle[5] = _mm512_shuffle_i32x4(permutex[5], permutex[7], 0b01000100);
+      shuffle[6] = _mm512_shuffle_i32x4(permutex[1], permutex[3], 0b11101110);
+      shuffle[7] = _mm512_shuffle_i32x4(permutex[5], permutex[7], 0b11101110);
+
+      final_result[0] =
+          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b10001000);
+      final_result[1] =
+          _mm512_shuffle_i32x4(shuffle[0], shuffle[1], 0b11011101);
+      final_result[2] =
+          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b10001000);
+      final_result[3] =
+          _mm512_shuffle_i32x4(shuffle[2], shuffle[3], 0b11011101);
+      final_result[4] =
+          _mm512_shuffle_i32x4(shuffle[4], shuffle[5], 0b10001000);
+      final_result[5] =
+          _mm512_shuffle_i32x4(shuffle[4], shuffle[5], 0b11011101);
+      final_result[6] =
+          _mm512_shuffle_i32x4(shuffle[6], shuffle[7], 0b10001000);
+      final_result[7] =
+          _mm512_shuffle_i32x4(shuffle[6], shuffle[7], 0b11011101);
+    } else {
+      // Path for float.
+      // 1. Processed hierarchically to 32i block using the unpack intrinsics.
+      // 2. Pack 128i block using _mm256_permutevar8x32_epi32.
+      // 3. Pack final 256i block with _mm256_permute2x128_si256.
+      for (size_t i = 0; i < kNumStreams; ++i)
+        permutex[i] =
+            _mm512_permutexvar_epi32(permutex_mask, unpack[KNumUnpack][i]);
+
+      final_result[0] =
+          _mm512_shuffle_i32x4(permutex[0], permutex[2], 0b01000100);
+      final_result[1] =
+          _mm512_shuffle_i32x4(permutex[0], permutex[2], 0b11101110);
+      final_result[2] =
+          _mm512_shuffle_i32x4(permutex[1], permutex[3], 0b01000100);
+      final_result[3] =
+          _mm512_shuffle_i32x4(permutex[1], permutex[3], 0b11101110);
+    }
+
+    for (size_t i = 0; i < kNumStreams; ++i) {
+      _mm512_storeu_si512(
+          &output_buffer_streams[i][block_index], final_result[i]);
+    }
+  }
+}
+#endif // ARROW_HAVE_AVX512
+
+#if defined(ARROW_HAVE_SIMD_SPLIT)
+template <typename T>
+void inline ByteStreamSplitDecodeSimd(
+    const uint8_t* data,
+    int64_t num_values,
+    int64_t stride,
+    T* out) {
+#if defined(ARROW_HAVE_AVX512)
+  return ByteStreamSplitDecodeAvx512(data, num_values, stride, out);
+#elif defined(ARROW_HAVE_AVX2)
+  return ByteStreamSplitDecodeAvx2(data, num_values, stride, out);
+#elif defined(ARROW_HAVE_SSE4_2)
+  return ByteStreamSplitDecodeSse2(data, num_values, stride, out);
+#else
+#error "ByteStreamSplitDecodeSimd not implemented"
+#endif
+}
+
+template <typename T>
+void inline ByteStreamSplitEncodeSimd(
+    const uint8_t* raw_values,
+    const int64_t num_values,
+    uint8_t* output_buffer_raw) {
+#if defined(ARROW_HAVE_AVX512)
+  return ByteStreamSplitEncodeAvx512<T>(
+      raw_values, static_cast<size_t>(num_values), output_buffer_raw);
+#elif defined(ARROW_HAVE_AVX2)
+  return ByteStreamSplitEncodeAvx2<T>(
+      raw_values, static_cast<size_t>(num_values), output_buffer_raw);
+#elif defined(ARROW_HAVE_SSE4_2)
+  return ByteStreamSplitEncodeSse2<T>(
+      raw_values, static_cast<size_t>(num_values), output_buffer_raw);
+#else
+#error "ByteStreamSplitEncodeSimd not implemented"
+#endif
+}
+#endif
+
+//
+// Scalar implementations
+//
+
+inline void DoSplitStreams(
+    const uint8_t* src,
+    int width,
+    int64_t nvalues,
+    uint8_t** dest_streams) {
+  // Value empirically chosen to provide the best performance on the author's
+  // machine
+  constexpr int kBlockSize = 32;
+
+  while (nvalues >= kBlockSize) {
+    for (int stream = 0; stream < width; ++stream) {
+      uint8_t* dest = dest_streams[stream];
+      for (int i = 0; i < kBlockSize; i += 8) {
+        uint64_t a = src[stream + i * width];
+        uint64_t b = src[stream + (i + 1) * width];
+        uint64_t c = src[stream + (i + 2) * width];
+        uint64_t d = src[stream + (i + 3) * width];
+        uint64_t e = src[stream + (i + 4) * width];
+        uint64_t f = src[stream + (i + 5) * width];
+        uint64_t g = src[stream + (i + 6) * width];
+        uint64_t h = src[stream + (i + 7) * width];
+#if ARROW_LITTLE_ENDIAN
+        uint64_t r = a | (b << 8) | (c << 16) | (d << 24) | (e << 32) |
+            (f << 40) | (g << 48) | (h << 56);
+#else
+        uint64_t r = (a << 56) | (b << 48) | (c << 40) | (d << 32) | (e << 24) |
+            (f << 16) | (g << 8) | h;
+#endif
+        ::arrow::util::SafeStore(&dest[i], r);
+      }
+      dest_streams[stream] += kBlockSize;
+    }
+    src += width * kBlockSize;
+    nvalues -= kBlockSize;
+  }
+
+  // Epilog
+  for (int stream = 0; stream < width; ++stream) {
+    uint8_t* dest = dest_streams[stream];
+    for (int64_t i = 0; i < nvalues; ++i) {
+      dest[i] = src[stream + i * width];
+    }
+  }
+}
+
+inline void DoMergeStreams(
+    const uint8_t** src_streams,
+    int width,
+    int64_t nvalues,
+    uint8_t* dest) {
+  // Value empirically chosen to provide the best performance on the author's
+  // machine
+  constexpr int kBlockSize = 128;
+
+  while (nvalues >= kBlockSize) {
+    for (int stream = 0; stream < width; ++stream) {
+      // Take kBlockSize bytes from the given stream and spread them
+      // to their logical places in destination.
+      const uint8_t* src = src_streams[stream];
+      for (int i = 0; i < kBlockSize; i += 8) {
+        uint64_t v = ::arrow::util::SafeLoadAs<uint64_t>(&src[i]);
+#if ARROW_LITTLE_ENDIAN
+        dest[stream + i * width] = static_cast<uint8_t>(v);
+        dest[stream + (i + 1) * width] = static_cast<uint8_t>(v >> 8);
+        dest[stream + (i + 2) * width] = static_cast<uint8_t>(v >> 16);
+        dest[stream + (i + 3) * width] = static_cast<uint8_t>(v >> 24);
+        dest[stream + (i + 4) * width] = static_cast<uint8_t>(v >> 32);
+        dest[stream + (i + 5) * width] = static_cast<uint8_t>(v >> 40);
+        dest[stream + (i + 6) * width] = static_cast<uint8_t>(v >> 48);
+        dest[stream + (i + 7) * width] = static_cast<uint8_t>(v >> 56);
+#else
+        dest[stream + i * width] = static_cast<uint8_t>(v >> 56);
+        dest[stream + (i + 1) * width] = static_cast<uint8_t>(v >> 48);
+        dest[stream + (i + 2) * width] = static_cast<uint8_t>(v >> 40);
+        dest[stream + (i + 3) * width] = static_cast<uint8_t>(v >> 32);
+        dest[stream + (i + 4) * width] = static_cast<uint8_t>(v >> 24);
+        dest[stream + (i + 5) * width] = static_cast<uint8_t>(v >> 16);
+        dest[stream + (i + 6) * width] = static_cast<uint8_t>(v >> 8);
+        dest[stream + (i + 7) * width] = static_cast<uint8_t>(v);
+#endif
+      }
+      src_streams[stream] += kBlockSize;
+    }
+    dest += width * kBlockSize;
+    nvalues -= kBlockSize;
+  }
+
+  // Epilog
+  for (int stream = 0; stream < width; ++stream) {
+    const uint8_t* src = src_streams[stream];
+    for (int64_t i = 0; i < nvalues; ++i) {
+      dest[stream + i * width] = src[i];
+    }
+  }
+}
+
+template <typename T>
+void ByteStreamSplitEncodeScalar(
+    const uint8_t* raw_values,
+    const int64_t num_values,
+    uint8_t* output_buffer_raw) {
+  constexpr int kNumStreams = static_cast<int>(sizeof(T));
+  std::array<uint8_t*, kNumStreams> dest_streams;
+  for (int stream = 0; stream < kNumStreams; ++stream) {
+    dest_streams[stream] = &output_buffer_raw[stream * num_values];
+  }
+  DoSplitStreams(raw_values, kNumStreams, num_values, dest_streams.data());
+}
+
+template <typename T>
+void ByteStreamSplitDecodeScalar(
+    const uint8_t* data,
+    int64_t num_values,
+    int64_t stride,
+    T* out) {
+  constexpr int kNumStreams = static_cast<int>(sizeof(T));
+  std::array<const uint8_t*, kNumStreams> src_streams;
+  for (int stream = 0; stream < kNumStreams; ++stream) {
+    src_streams[stream] = &data[stream * stride];
+  }
+  DoMergeStreams(
+      src_streams.data(),
+      kNumStreams,
+      num_values,
+      reinterpret_cast<uint8_t*>(out));
+}
+
+template <typename T>
+void inline ByteStreamSplitEncode(
+    const uint8_t* raw_values,
+    const int64_t num_values,
+    uint8_t* output_buffer_raw) {
+#if defined(ARROW_HAVE_SIMD_SPLIT)
+  return ByteStreamSplitEncodeSimd<T>(
+      raw_values, num_values, output_buffer_raw);
+#else
+  return ByteStreamSplitEncodeScalar<T>(
+      raw_values, num_values, output_buffer_raw);
+#endif
+}
+
+template <typename T>
+void inline ByteStreamSplitDecode(
+    const uint8_t* data,
+    int64_t num_values,
+    int64_t stride,
+    T* out) {
+#if defined(ARROW_HAVE_SIMD_SPLIT)
+  return ByteStreamSplitDecodeSimd(data, num_values, stride, out);
+#else
+  return ByteStreamSplitDecodeScalar(data, num_values, stride, out);
+#endif
+}
+
+} // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
index 87ec25e877035..e5757f81646b3 100644
--- a/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
@@ -12,10 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(
   velox_dwio_arrow_parquet_writer_util_lib
-  Compression.cpp CompressionSnappy.cpp CompressionZstd.cpp CompressionZlib.cpp
-  Hashing.cpp Crc32.cpp)
+  Compression.cpp
+  CompressionSnappy.cpp
+  CompressionZstd.cpp
+  CompressionZlib.cpp
+  CompressionLZ4.cpp
+  Hashing.cpp
+  Crc32.cpp)
 
-target_link_libraries(velox_dwio_arrow_parquet_writer_util_lib parquet arrow
-                      Snappy::snappy zstd::zstd ZLIB::ZLIB)
+velox_link_libraries(
+  velox_dwio_arrow_parquet_writer_util_lib
+  arrow
+  Snappy::snappy
+  zstd::zstd
+  ZLIB::ZLIB
+  lz4::lz4)
diff --git a/velox/dwio/parquet/writer/arrow/util/Compression.cpp b/velox/dwio/parquet/writer/arrow/util/Compression.cpp
index 210c88c813a8f..f5f77313d1018 100644
--- a/velox/dwio/parquet/writer/arrow/util/Compression.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/Compression.cpp
@@ -190,19 +190,13 @@ Result<std::unique_ptr<Codec>> Codec::Create(
       break;
     }
     case Compression::LZ4:
-#ifdef ARROW_WITH_LZ4
       codec = internal::MakeLz4RawCodec(compression_level);
-#endif
       break;
     case Compression::LZ4_FRAME:
-#ifdef ARROW_WITH_LZ4
       codec = internal::MakeLz4FrameCodec(compression_level);
-#endif
       break;
     case Compression::LZ4_HADOOP:
-#ifdef ARROW_WITH_LZ4
       codec = internal::MakeLz4HadoopRawCodec();
-#endif
       break;
     case Compression::ZSTD:
       codec = internal::MakeZSTDCodec(compression_level);
@@ -248,11 +242,7 @@ bool Codec::IsAvailable(Compression::type codec_type) {
     case Compression::LZ4:
     case Compression::LZ4_FRAME:
     case Compression::LZ4_HADOOP:
-#ifdef ARROW_WITH_LZ4
       return true;
-#else
-      return false;
-#endif
     case Compression::ZSTD:
       return true;
     case Compression::BZ2:
diff --git a/velox/dwio/parquet/writer/arrow/util/CompressionLZ4.cpp b/velox/dwio/parquet/writer/arrow/util/CompressionLZ4.cpp
new file mode 100644
index 0000000000000..1b433c5797b09
--- /dev/null
+++ b/velox/dwio/parquet/writer/arrow/util/CompressionLZ4.cpp
@@ -0,0 +1,622 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from Apache Arrow.
+
+#include "velox/dwio/parquet/writer/arrow/util/CompressionInternal.h"
+
+#include <memory>
+
+#include <lz4.h>
+#include <lz4frame.h>
+#include <lz4hc.h>
+
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/macros.h"
+#include "arrow/util/ubsan.h"
+
+using std::size_t;
+
+namespace facebook::velox::parquet::arrow::util::internal {
+namespace {
+
+constexpr int kLz4MinCompressionLevel = 1;
+
+static Status LZ4Error(LZ4F_errorCode_t ret, const char* prefix_msg) {
+  return Status::IOError(prefix_msg, LZ4F_getErrorName(ret));
+}
+
+static LZ4F_preferences_t DefaultPreferences() {
+  LZ4F_preferences_t prefs;
+  memset(&prefs, 0, sizeof(prefs));
+  return prefs;
+}
+
+static LZ4F_preferences_t PreferencesWithCompressionLevel(
+    int compression_level) {
+  LZ4F_preferences_t prefs = DefaultPreferences();
+  prefs.compressionLevel = compression_level;
+  return prefs;
+}
+
+// ----------------------------------------------------------------------
+// Lz4 frame decompressor implementation
+
+class LZ4Decompressor : public Decompressor {
+ public:
+  LZ4Decompressor() {}
+
+  ~LZ4Decompressor() override {
+    if (ctx_ != nullptr) {
+      ARROW_UNUSED(LZ4F_freeDecompressionContext(ctx_));
+    }
+  }
+
+  Status Init() {
+    LZ4F_errorCode_t ret;
+    finished_ = false;
+
+    ret = LZ4F_createDecompressionContext(&ctx_, LZ4F_VERSION);
+    if (LZ4F_isError(ret)) {
+      return LZ4Error(ret, "LZ4 init failed: ");
+    } else {
+      return Status::OK();
+    }
+  }
+
+  Status Reset() override {
+#if defined(LZ4_VERSION_NUMBER) && LZ4_VERSION_NUMBER >= 10800
+    // LZ4F_resetDecompressionContext appeared in 1.8.0
+    DCHECK_NE(ctx_, nullptr);
+    LZ4F_resetDecompressionContext(ctx_);
+    finished_ = false;
+    return Status::OK();
+#else
+    if (ctx_ != nullptr) {
+      ARROW_UNUSED(LZ4F_freeDecompressionContext(ctx_));
+    }
+    return Init();
+#endif
+  }
+
+  Result<DecompressResult> Decompress(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_len,
+      uint8_t* output) override {
+    auto src = input;
+    auto dst = output;
+    auto src_size = static_cast<size_t>(input_len);
+    auto dst_capacity = static_cast<size_t>(output_len);
+    size_t ret;
+
+    ret = LZ4F_decompress(
+        ctx_, dst, &dst_capacity, src, &src_size, nullptr /* options */);
+    if (LZ4F_isError(ret)) {
+      return LZ4Error(ret, "LZ4 decompress failed: ");
+    }
+    finished_ = (ret == 0);
+    return DecompressResult{
+        static_cast<int64_t>(src_size),
+        static_cast<int64_t>(dst_capacity),
+        (src_size == 0 && dst_capacity == 0)};
+  }
+
+  bool IsFinished() override {
+    return finished_;
+  }
+
+ protected:
+  LZ4F_decompressionContext_t ctx_ = nullptr;
+  bool finished_;
+};
+
+// ----------------------------------------------------------------------
+// Lz4 frame compressor implementation
+
+class LZ4Compressor : public Compressor {
+ public:
+  explicit LZ4Compressor(int compression_level)
+      : compression_level_(compression_level) {}
+
+  ~LZ4Compressor() override {
+    if (ctx_ != nullptr) {
+      ARROW_UNUSED(LZ4F_freeCompressionContext(ctx_));
+    }
+  }
+
+  Status Init() {
+    LZ4F_errorCode_t ret;
+    prefs_ = PreferencesWithCompressionLevel(compression_level_);
+    first_time_ = true;
+
+    ret = LZ4F_createCompressionContext(&ctx_, LZ4F_VERSION);
+    if (LZ4F_isError(ret)) {
+      return LZ4Error(ret, "LZ4 init failed: ");
+    } else {
+      return Status::OK();
+    }
+  }
+
+#define BEGIN_COMPRESS(dst, dst_capacity, output_too_small)     \
+  if (first_time_) {                                            \
+    if (dst_capacity < LZ4F_HEADER_SIZE_MAX) {                  \
+      /* Output too small to write LZ4F header */               \
+      return (output_too_small);                                \
+    }                                                           \
+    ret = LZ4F_compressBegin(ctx_, dst, dst_capacity, &prefs_); \
+    if (LZ4F_isError(ret)) {                                    \
+      return LZ4Error(ret, "LZ4 compress begin failed: ");      \
+    }                                                           \
+    first_time_ = false;                                        \
+    dst += ret;                                                 \
+    dst_capacity -= ret;                                        \
+    bytes_written += static_cast<int64_t>(ret);                 \
+  }
+
+  Result<CompressResult> Compress(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_len,
+      uint8_t* output) override {
+    auto src = input;
+    auto dst = output;
+    auto src_size = static_cast<size_t>(input_len);
+    auto dst_capacity = static_cast<size_t>(output_len);
+    size_t ret;
+    int64_t bytes_written = 0;
+
+    BEGIN_COMPRESS(dst, dst_capacity, (CompressResult{0, 0}));
+
+    if (dst_capacity < LZ4F_compressBound(src_size, &prefs_)) {
+      // Output too small to compress into
+      return CompressResult{0, bytes_written};
+    }
+    ret = LZ4F_compressUpdate(
+        ctx_, dst, dst_capacity, src, src_size, nullptr /* options */);
+    if (LZ4F_isError(ret)) {
+      return LZ4Error(ret, "LZ4 compress update failed: ");
+    }
+    bytes_written += static_cast<int64_t>(ret);
+    DCHECK_LE(bytes_written, output_len);
+    return CompressResult{input_len, bytes_written};
+  }
+
+  Result<FlushResult> Flush(int64_t output_len, uint8_t* output) override {
+    auto dst = output;
+    auto dst_capacity = static_cast<size_t>(output_len);
+    size_t ret;
+    int64_t bytes_written = 0;
+
+    BEGIN_COMPRESS(dst, dst_capacity, (FlushResult{0, true}));
+
+    if (dst_capacity < LZ4F_compressBound(0, &prefs_)) {
+      // Output too small to flush into
+      return FlushResult{bytes_written, true};
+    }
+
+    ret = LZ4F_flush(ctx_, dst, dst_capacity, nullptr /* options */);
+    if (LZ4F_isError(ret)) {
+      return LZ4Error(ret, "LZ4 flush failed: ");
+    }
+    bytes_written += static_cast<int64_t>(ret);
+    DCHECK_LE(bytes_written, output_len);
+    return FlushResult{bytes_written, false};
+  }
+
+  Result<EndResult> End(int64_t output_len, uint8_t* output) override {
+    auto dst = output;
+    auto dst_capacity = static_cast<size_t>(output_len);
+    size_t ret;
+    int64_t bytes_written = 0;
+
+    BEGIN_COMPRESS(dst, dst_capacity, (EndResult{0, true}));
+
+    if (dst_capacity < LZ4F_compressBound(0, &prefs_)) {
+      // Output too small to end frame into
+      return EndResult{bytes_written, true};
+    }
+
+    ret = LZ4F_compressEnd(ctx_, dst, dst_capacity, nullptr /* options */);
+    if (LZ4F_isError(ret)) {
+      return LZ4Error(ret, "LZ4 end failed: ");
+    }
+    bytes_written += static_cast<int64_t>(ret);
+    DCHECK_LE(bytes_written, output_len);
+    return EndResult{bytes_written, false};
+  }
+
+#undef BEGIN_COMPRESS
+
+ protected:
+  int compression_level_;
+  LZ4F_compressionContext_t ctx_ = nullptr;
+  LZ4F_preferences_t prefs_;
+  bool first_time_;
+};
+
+// ----------------------------------------------------------------------
+// Lz4 frame codec implementation
+
+class Lz4FrameCodec : public Codec {
+ public:
+  explicit Lz4FrameCodec(int compression_level)
+      : compression_level_(
+            compression_level == kUseDefaultCompressionLevel
+                ? kLz4DefaultCompressionLevel
+                : compression_level),
+        prefs_(PreferencesWithCompressionLevel(compression_level_)) {}
+
+  int64_t MaxCompressedLen(
+      int64_t input_len,
+      const uint8_t* ARROW_ARG_UNUSED(input)) override {
+    return static_cast<int64_t>(
+        LZ4F_compressFrameBound(static_cast<size_t>(input_len), &prefs_));
+  }
+
+  Result<int64_t> Compress(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_buffer_len,
+      uint8_t* output_buffer) override {
+    auto output_len = LZ4F_compressFrame(
+        output_buffer,
+        static_cast<size_t>(output_buffer_len),
+        input,
+        static_cast<size_t>(input_len),
+        &prefs_);
+    if (LZ4F_isError(output_len)) {
+      return LZ4Error(output_len, "Lz4 compression failure: ");
+    }
+    return static_cast<int64_t>(output_len);
+  }
+
+  Result<int64_t> Decompress(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_buffer_len,
+      uint8_t* output_buffer) override {
+    ARROW_ASSIGN_OR_RAISE(auto decomp, MakeDecompressor());
+
+    int64_t total_bytes_written = 0;
+    while (!decomp->IsFinished() && input_len != 0) {
+      ARROW_ASSIGN_OR_RAISE(
+          auto res,
+          decomp->Decompress(
+              input_len, input, output_buffer_len, output_buffer));
+      input += res.bytes_read;
+      input_len -= res.bytes_read;
+      output_buffer += res.bytes_written;
+      output_buffer_len -= res.bytes_written;
+      total_bytes_written += res.bytes_written;
+      if (res.need_more_output) {
+        return Status::IOError("Lz4 decompression buffer too small");
+      }
+    }
+    if (!decomp->IsFinished()) {
+      return Status::IOError(
+          "Lz4 compressed input contains less than one frame");
+    }
+    if (input_len != 0) {
+      return Status::IOError(
+          "Lz4 compressed input contains more than one frame");
+    }
+    return total_bytes_written;
+  }
+
+  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
+    auto ptr = std::make_shared<LZ4Compressor>(compression_level_);
+    RETURN_NOT_OK(ptr->Init());
+    return ptr;
+  }
+
+  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
+    auto ptr = std::make_shared<LZ4Decompressor>();
+    RETURN_NOT_OK(ptr->Init());
+    return ptr;
+  }
+
+  Compression::type compression_type() const override {
+    return Compression::LZ4_FRAME;
+  }
+  int minimum_compression_level() const override {
+    return kLz4MinCompressionLevel;
+  }
+#if (defined(LZ4_VERSION_NUMBER) && LZ4_VERSION_NUMBER < 10800)
+  int maximum_compression_level() const override {
+    return 12;
+  }
+#else
+  int maximum_compression_level() const override {
+    return LZ4F_compressionLevel_max();
+  }
+#endif
+  int default_compression_level() const override {
+    return kLz4DefaultCompressionLevel;
+  }
+
+  int compression_level() const override {
+    return compression_level_;
+  }
+
+ protected:
+  const int compression_level_;
+  const LZ4F_preferences_t prefs_;
+};
+
+// ----------------------------------------------------------------------
+// Lz4 "raw" codec implementation
+
+class Lz4Codec : public Codec {
+ public:
+  explicit Lz4Codec(int compression_level)
+      : compression_level_(
+            compression_level == kUseDefaultCompressionLevel
+                ? kLz4DefaultCompressionLevel
+                : compression_level) {}
+
+  Result<int64_t> Decompress(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_buffer_len,
+      uint8_t* output_buffer) override {
+    int64_t decompressed_size = LZ4_decompress_safe(
+        reinterpret_cast<const char*>(input),
+        reinterpret_cast<char*>(output_buffer),
+        static_cast<int>(input_len),
+        static_cast<int>(output_buffer_len));
+    if (decompressed_size < 0) {
+      return Status::IOError("Corrupt Lz4 compressed data.");
+    }
+    return decompressed_size;
+  }
+
+  int64_t MaxCompressedLen(
+      int64_t input_len,
+      const uint8_t* ARROW_ARG_UNUSED(input)) override {
+    return LZ4_compressBound(static_cast<int>(input_len));
+  }
+
+  Result<int64_t> Compress(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_buffer_len,
+      uint8_t* output_buffer) override {
+    int64_t output_len;
+#ifdef LZ4HC_CLEVEL_MIN
+    constexpr int min_hc_clevel = LZ4HC_CLEVEL_MIN;
+#else // For older versions of the lz4 library
+    constexpr int min_hc_clevel = 3;
+#endif
+    if (compression_level_ < min_hc_clevel) {
+      output_len = LZ4_compress_default(
+          reinterpret_cast<const char*>(input),
+          reinterpret_cast<char*>(output_buffer),
+          static_cast<int>(input_len),
+          static_cast<int>(output_buffer_len));
+    } else {
+      output_len = LZ4_compress_HC(
+          reinterpret_cast<const char*>(input),
+          reinterpret_cast<char*>(output_buffer),
+          static_cast<int>(input_len),
+          static_cast<int>(output_buffer_len),
+          compression_level_);
+    }
+    if (output_len == 0) {
+      return Status::IOError("Lz4 compression failure.");
+    }
+    return output_len;
+  }
+
+  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
+    return Status::NotImplemented(
+        "Streaming compression unsupported with LZ4 raw format. "
+        "Try using LZ4 frame format instead.");
+  }
+
+  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
+    return Status::NotImplemented(
+        "Streaming decompression unsupported with LZ4 raw format. "
+        "Try using LZ4 frame format instead.");
+  }
+
+  Compression::type compression_type() const override {
+    return Compression::LZ4;
+  }
+  int minimum_compression_level() const override {
+    return kLz4MinCompressionLevel;
+  }
+#if (defined(LZ4_VERSION_NUMBER) && LZ4_VERSION_NUMBER < 10800)
+  int maximum_compression_level() const override {
+    return 12;
+  }
+#else
+  int maximum_compression_level() const override {
+    return LZ4F_compressionLevel_max();
+  }
+#endif
+  int default_compression_level() const override {
+    return kLz4DefaultCompressionLevel;
+  }
+
+ protected:
+  int compression_level_;
+};
+
+// ----------------------------------------------------------------------
+// Lz4 Hadoop "raw" codec implementation
+
+class Lz4HadoopCodec : public Lz4Codec {
+ public:
+  Lz4HadoopCodec() : Lz4Codec(kUseDefaultCompressionLevel) {}
+
+  Result<int64_t> Decompress(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_buffer_len,
+      uint8_t* output_buffer) override {
+    const int64_t decompressed_size =
+        TryDecompressHadoop(input_len, input, output_buffer_len, output_buffer);
+    if (decompressed_size != kNotHadoop) {
+      return decompressed_size;
+    }
+    // Fall back on raw LZ4 codec (for files produces by earlier versions of
+    // Parquet C++)
+    return Lz4Codec::Decompress(
+        input_len, input, output_buffer_len, output_buffer);
+  }
+
+  int64_t MaxCompressedLen(
+      int64_t input_len,
+      const uint8_t* ARROW_ARG_UNUSED(input)) override {
+    return kPrefixLength + Lz4Codec::MaxCompressedLen(input_len, nullptr);
+  }
+
+  Result<int64_t> Compress(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_buffer_len,
+      uint8_t* output_buffer) override {
+    if (output_buffer_len < kPrefixLength) {
+      return Status::Invalid(
+          "Output buffer too small for Lz4HadoopCodec compression");
+    }
+
+    ARROW_ASSIGN_OR_RAISE(
+        int64_t output_len,
+        Lz4Codec::Compress(
+            input_len,
+            input,
+            output_buffer_len - kPrefixLength,
+            output_buffer + kPrefixLength));
+
+    // Prepend decompressed size in bytes and compressed size in bytes
+    // to be compatible with Hadoop Lz4Codec
+    const uint32_t decompressed_size =
+        bit_util::ToBigEndian(static_cast<uint32_t>(input_len));
+    const uint32_t compressed_size =
+        bit_util::ToBigEndian(static_cast<uint32_t>(output_len));
+    ::arrow::util::SafeStore(output_buffer, decompressed_size);
+    ::arrow::util::SafeStore(output_buffer + sizeof(uint32_t), compressed_size);
+
+    return kPrefixLength + output_len;
+  }
+
+  Result<std::shared_ptr<Compressor>> MakeCompressor() override {
+    return Status::NotImplemented(
+        "Streaming compression unsupported with LZ4 Hadoop raw format. "
+        "Try using LZ4 frame format instead.");
+  }
+
+  Result<std::shared_ptr<Decompressor>> MakeDecompressor() override {
+    return Status::NotImplemented(
+        "Streaming decompression unsupported with LZ4 Hadoop raw format. "
+        "Try using LZ4 frame format instead.");
+  }
+
+  Compression::type compression_type() const override {
+    return Compression::LZ4_HADOOP;
+  }
+
+ protected:
+  // Offset starting at which page data can be read/written
+  static const int64_t kPrefixLength = sizeof(uint32_t) * 2;
+
+  static const int64_t kNotHadoop = -1;
+
+  int64_t TryDecompressHadoop(
+      int64_t input_len,
+      const uint8_t* input,
+      int64_t output_buffer_len,
+      uint8_t* output_buffer) {
+    // Parquet files written with the Hadoop Lz4Codec use their own framing.
+    // The input buffer can contain an arbitrary number of "frames", each
+    // with the following structure:
+    // - bytes 0..3: big-endian uint32_t representing the frame decompressed
+    // size
+    // - bytes 4..7: big-endian uint32_t representing the frame compressed size
+    // - bytes 8...: frame compressed data
+    //
+    // The Hadoop Lz4Codec source code can be found here:
+    // https://github.com/apache/hadoop/blob/trunk/hadoop-mapreduce-project/hadoop-mapreduce-client/hadoop-mapreduce-client-nativetask/src/main/native/src/codec/Lz4Codec.cc
+    int64_t total_decompressed_size = 0;
+
+    while (input_len >= kPrefixLength) {
+      const uint32_t expected_decompressed_size =
+          bit_util::FromBigEndian(::arrow::util::SafeLoadAs<uint32_t>(input));
+      const uint32_t expected_compressed_size = bit_util::FromBigEndian(
+          ::arrow::util::SafeLoadAs<uint32_t>(input + sizeof(uint32_t)));
+      input += kPrefixLength;
+      input_len -= kPrefixLength;
+
+      if (input_len < expected_compressed_size) {
+        // Not enough bytes for Hadoop "frame"
+        return kNotHadoop;
+      }
+      if (output_buffer_len < expected_decompressed_size) {
+        // Not enough bytes to hold advertised output => probably not Hadoop
+        return kNotHadoop;
+      }
+      // Try decompressing and compare with expected decompressed length
+      auto maybe_decompressed_size = Lz4Codec::Decompress(
+          expected_compressed_size, input, output_buffer_len, output_buffer);
+      if (!maybe_decompressed_size.ok() ||
+          *maybe_decompressed_size != expected_decompressed_size) {
+        return kNotHadoop;
+      }
+      input += expected_compressed_size;
+      input_len -= expected_compressed_size;
+      output_buffer += expected_decompressed_size;
+      output_buffer_len -= expected_decompressed_size;
+      total_decompressed_size += expected_decompressed_size;
+    }
+
+    if (input_len == 0) {
+      return total_decompressed_size;
+    } else {
+      return kNotHadoop;
+    }
+  }
+
+  int minimum_compression_level() const override {
+    return kUseDefaultCompressionLevel;
+  }
+  int maximum_compression_level() const override {
+    return kUseDefaultCompressionLevel;
+  }
+  int default_compression_level() const override {
+    return kUseDefaultCompressionLevel;
+  }
+};
+
+} // namespace
+
+std::unique_ptr<Codec> MakeLz4FrameCodec(int compression_level) {
+  return std::make_unique<Lz4FrameCodec>(compression_level);
+}
+
+std::unique_ptr<Codec> MakeLz4HadoopRawCodec() {
+  return std::make_unique<Lz4HadoopCodec>();
+}
+
+std::unique_ptr<Codec> MakeLz4RawCodec(int compression_level) {
+  return std::make_unique<Lz4Codec>(compression_level);
+}
+
+} // namespace facebook::velox::parquet::arrow::util::internal
diff --git a/velox/dwio/parquet/writer/arrow/util/CompressionZstd.cpp b/velox/dwio/parquet/writer/arrow/util/CompressionZstd.cpp
index ed8b38e2402c1..16cf5a2a696aa 100644
--- a/velox/dwio/parquet/writer/arrow/util/CompressionZstd.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/CompressionZstd.cpp
@@ -281,4 +281,4 @@ class ZSTDCodec : public Codec {
 std::unique_ptr<Codec> MakeZSTDCodec(int compression_level) {
   return std::make_unique<ZSTDCodec>(compression_level);
 }
-}; // namespace facebook::velox::parquet::arrow::util::internal.
+} // namespace facebook::velox::parquet::arrow::util::internal.
diff --git a/velox/dwio/parquet/writer/arrow/util/safe-math.h b/velox/dwio/parquet/writer/arrow/util/safe-math.h
index d851546512fc0..661b62887bc7a 100644
--- a/velox/dwio/parquet/writer/arrow/util/safe-math.h
+++ b/velox/dwio/parquet/writer/arrow/util/safe-math.h
@@ -48,8 +48,8 @@
 #define PSNIP_SAFE_LIKELY(expr) __builtin_expect(!!(expr), 1)
 #define PSNIP_SAFE_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
 #else
-#define PSNIP_SAFE_LIKELY(expr) !!(expr)
-#define PSNIP_SAFE_UNLIKELY(expr) !!(expr)
+#define PSNIP_SAFE_LIKELY(expr) (!!(expr))
+#define PSNIP_SAFE_UNLIKELY(expr) (!!(expr))
 #endif /* defined(__GNUC__) */
 
 #if !defined(PSNIP_SAFE_STATIC_INLINE)
@@ -1312,18 +1312,19 @@ PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
 
 #endif /* !defined(PSNIP_SAFE_NO_FIXED) */
 
-#define PSNIP_SAFE_C11_GENERIC_SELECTION(res, op)      \
-  _Generic((*res), char                                \
-           : psnip_safe_char_##op, unsigned char       \
-           : psnip_safe_uchar_##op, short              \
-           : psnip_safe_short_##op, unsigned short     \
-           : psnip_safe_ushort_##op, int               \
-           : psnip_safe_int_##op, unsigned int         \
-           : psnip_safe_uint_##op, long                \
-           : psnip_safe_long_##op, unsigned long       \
-           : psnip_safe_ulong_##op, long long          \
-           : psnip_safe_llong_##op, unsigned long long \
-           : psnip_safe_ullong_##op)
+#define PSNIP_SAFE_C11_GENERIC_SELECTION(res, op) \
+  _Generic(                                       \
+      (*res),                                     \
+      char: psnip_safe_char_##op,                 \
+      unsigned char: psnip_safe_uchar_##op,       \
+      short: psnip_safe_short_##op,               \
+      unsigned short: psnip_safe_ushort_##op,     \
+      int: psnip_safe_int_##op,                   \
+      unsigned int: psnip_safe_uint_##op,         \
+      long: psnip_safe_long_##op,                 \
+      unsigned long: psnip_safe_ulong_##op,       \
+      long long: psnip_safe_llong_##op,           \
+      unsigned long long: psnip_safe_ullong_##op)
 
 #define PSNIP_SAFE_C11_GENERIC_BINARY_OP(op, res, a, b) \
   PSNIP_SAFE_C11_GENERIC_SELECTION(res, op)(res, a, b)
@@ -1331,11 +1332,11 @@ PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint64_t, uint64, 0xffffffffffffffffULL)
   PSNIP_SAFE_C11_GENERIC_SELECTION(res, op)(res, v)
 
 #if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)
-#define psnip_safe_add(res, a, b) !__builtin_add_overflow(a, b, res)
-#define psnip_safe_sub(res, a, b) !__builtin_sub_overflow(a, b, res)
-#define psnip_safe_mul(res, a, b) !__builtin_mul_overflow(a, b, res)
-#define psnip_safe_div(res, a, b) !__builtin_div_overflow(a, b, res)
-#define psnip_safe_mod(res, a, b) !__builtin_mod_overflow(a, b, res)
+#define psnip_safe_add(res, a, b) (!__builtin_add_overflow(a, b, res))
+#define psnip_safe_sub(res, a, b) (!__builtin_sub_overflow(a, b, res))
+#define psnip_safe_mul(res, a, b) (!__builtin_mul_overflow(a, b, res))
+#define psnip_safe_div(res, a, b) (!__builtin_div_overflow(a, b, res))
+#define psnip_safe_mod(res, a, b) (!__builtin_mod_overflow(a, b, res))
 #define psnip_safe_neg(res, v) PSNIP_SAFE_C11_GENERIC_UNARY_OP(neg, res, v)
 
 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
diff --git a/velox/examples/CMakeLists.txt b/velox/examples/CMakeLists.txt
index 8625d34ce82ee..958c7c296ec09 100644
--- a/velox/examples/CMakeLists.txt
+++ b/velox/examples/CMakeLists.txt
@@ -14,25 +14,38 @@
 
 add_executable(velox_example_simple_functions SimpleFunctions.cpp)
 
-target_link_libraries(velox_example_simple_functions velox_functions_lib
-                      velox_core velox_expression re2::re2)
+target_link_libraries(
+  velox_example_simple_functions
+  velox_functions_lib
+  velox_core
+  velox_expression
+  re2::re2)
 
 add_executable(velox_example_expression_eval ExpressionEval.cpp)
 
-target_link_libraries(velox_example_expression_eval velox_type velox_vector
-                      velox_caching velox_memory velox_expression)
+target_link_libraries(
+  velox_example_expression_eval
+  velox_type
+  velox_vector
+  velox_caching
+  velox_memory
+  velox_expression)
 
 add_executable(velox_example_opaque_type OpaqueType.cpp)
-
-target_link_libraries(velox_example_opaque_type velox_type velox_vector
-                      velox_caching velox_expression velox_memory)
+target_link_libraries(
+  velox_example_opaque_type
+  velox_type
+  velox_vector
+  velox_caching
+  velox_expression
+  velox_memory)
 
 # This is disabled temporarily until we figure out why g++ is crashing linking
 # it on linux builds.
 
 # add_executable(velox_example_scan_and_sort ScanAndSort.cpp)
 
-# target_link_libraries( velox_example_scan_and_sort velox_type velox_vector
+# velox_link_libraries( velox_example_scan_and_sort velox_type velox_vector
 # velox_exec velox_exec_test_lib velox_hive_connector velox_memory
 # velox_vector_test_lib)
 
@@ -49,11 +62,10 @@ target_link_libraries(
 
 add_executable(velox_example_vector_reader_writer VectorReaderWriter.cpp)
 
-target_link_libraries(velox_example_vector_reader_writer velox_expression
-                      velox_type velox_vector)
+target_link_libraries(
+  velox_example_vector_reader_writer velox_expression velox_type velox_vector)
 
 add_executable(velox_example_operator_extensibility OperatorExtensibility.cpp)
-
 target_link_libraries(
   velox_example_operator_extensibility
   velox_type
diff --git a/velox/examples/ExpressionEval.cpp b/velox/examples/ExpressionEval.cpp
index 48f20e11461e1..c16b08bdebaf1 100644
--- a/velox/examples/ExpressionEval.cpp
+++ b/velox/examples/ExpressionEval.cpp
@@ -50,13 +50,15 @@ int main(int argc, char** argv) {
   // registered.
   registerFunction<TimesTwoFunction, int64_t, int64_t>({"times_two"});
 
+  memory::MemoryManager::initialize({});
+
   // First of all, executing an expression in Velox will require us to create a
   // query context, a memory pool, and an execution context.
   //
   // QueryCtx holds the metadata and configuration associated with a
   // particular query. This is shared between all threads of execution
   // for the same query (one object per query).
-  auto queryCtx = std::make_shared<core::QueryCtx>();
+  auto queryCtx = core::QueryCtx::create();
 
   // ExecCtx holds structures associated with a single thread of execution
   // (one per thread). Each thread of execution requires a scoped memory pool,
@@ -64,8 +66,8 @@ int main(int argc, char** argv) {
   // pointer to this pool can be obtained using execCtx.pool().
   //
   // Optionally, one can control the per-thread memory cap by passing it as an
-  // argument to addDefaultLeafMemoryPool() - no limit by default.
-  auto pool = memory::addDefaultLeafMemoryPool();
+  // argument to add() - no limit by default.
+  auto pool = memory::memoryManager()->addLeafPool();
   core::ExecCtx execCtx{pool.get(), queryCtx.get()};
 
   // Next, let's create an expression tree to be executed in this example. On a
diff --git a/velox/examples/OpaqueType.cpp b/velox/examples/OpaqueType.cpp
index fe421d9b2b42f..0c4fa637f6feb 100644
--- a/velox/examples/OpaqueType.cpp
+++ b/velox/examples/OpaqueType.cpp
@@ -187,9 +187,10 @@ int main(int argc, char** argv) {
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_map_resolver_vector, "map_resolver_vector");
 
+  memory::MemoryManager::initialize({});
   // Create memory pool and other query-related structures.
-  auto queryCtx = std::make_shared<core::QueryCtx>();
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto queryCtx = core::QueryCtx::create();
+  auto pool = memory::memoryManager()->addLeafPool();
   core::ExecCtx execCtx{pool.get(), queryCtx.get()};
 
   // Next, we need to generate an input batch of data (rowVector). We create a
@@ -313,7 +314,7 @@ VectorPtr evaluate(
   std::vector<VectorPtr> result{nullptr};
   SelectivityVector rows{rowVector->size()};
 
-  auto rowType = rowVector->type()->as<TypeKind::ROW>();
+  auto& rowType = rowVector->type()->as<TypeKind::ROW>();
 
   auto fieldAccessExprNode1 = std::make_shared<core::FieldAccessTypedExpr>(
       rowType.findChild(argName1), argName1);
diff --git a/velox/examples/OperatorExtensibility.cpp b/velox/examples/OperatorExtensibility.cpp
index b534f4f1145f6..b002fe0196751 100644
--- a/velox/examples/OperatorExtensibility.cpp
+++ b/velox/examples/OperatorExtensibility.cpp
@@ -160,7 +160,7 @@ class DuplicateRowTranslator : public exec::Operator::PlanNodeTranslator {
 };
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   // Fourth, we register the custom plan translator. We're now ready to use our
   // operator in a query plan.
@@ -170,7 +170,8 @@ int main(int argc, char** argv) {
   // assert that the output results contain the dataset properly duplicated.
 
   // Create a new memory pool to in this example.
-  auto pool = memory::addDefaultLeafMemoryPool();
+  memory::MemoryManager::initialize({});
+  auto pool = memory::memoryManager()->addLeafPool();
 
   // VectorMaker is a test utility that helps you build vectors. Shouldn't be
   // used in production.
diff --git a/velox/examples/ScanAndSort.cpp b/velox/examples/ScanAndSort.cpp
index bb9171d518600..4f86083d1cf39 100644
--- a/velox/examples/ScanAndSort.cpp
+++ b/velox/examples/ScanAndSort.cpp
@@ -19,7 +19,7 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
-#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/exec/Task.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -42,10 +42,11 @@ using exec::test::HiveConnectorTestBase;
 int main(int argc, char** argv) {
   // Velox Tasks/Operators are based on folly's async framework, so we need to
   // make sure we initialize it first.
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   // Default memory allocator used throughout this example.
-  auto pool = memory::addDefaultLeafMemoryPool();
+  memory::MemoryManager::initialize({});
+  auto pool = memory::memoryManager()->addLeafPool();
 
   // For this example, the input dataset will be comprised of a single BIGINT
   // column ("my_col"), containing 10 rows.
@@ -88,7 +89,10 @@ int main(int argc, char** argv) {
   auto hiveConnector =
       connector::getConnectorFactory(
           connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(kHiveConnectorId, nullptr);
+          ->newConnector(
+              kHiveConnectorId,
+              std::make_shared<config::ConfigBase>(
+                  std::unordered_map<std::string, std::string>()));
   connector::registerConnector(hiveConnector);
 
   // To be able to read local files, we need to register the local file
@@ -129,7 +133,8 @@ int main(int argc, char** argv) {
       "my_write_task",
       writerPlanFragment,
       /*destination=*/0,
-      std::make_shared<core::QueryCtx>(executor.get()));
+      core::QueryCtx::create(executor.get()),
+      exec::Task::ExecutionMode::kParallel);
 
   // next() starts execution using the client thread. The loop pumps output
   // vectors out of the task (there are none in this query fragment).
@@ -158,7 +163,8 @@ int main(int argc, char** argv) {
       "my_read_task",
       readPlanFragment,
       /*destination=*/0,
-      std::make_shared<core::QueryCtx>(executor.get()));
+      core::QueryCtx::create(executor.get()),
+      exec::Task::ExecutionMode::kParallel);
 
   // Now that we have the query fragment and Task structure set up, we will
   // add data to it via `splits`.
@@ -167,7 +173,7 @@ int main(int argc, char** argv) {
   // HiveConnectorSplit for each file, using the same HiveConnector id defined
   // above, the local file path (the "file:" prefix specifies which FileSystem
   // to use; local, in this case), and the file format (DWRF/ORC).
-  for (auto& filePath : fs::directory_iterator(tempDir->path)) {
+  for (auto& filePath : fs::directory_iterator(tempDir->getPath())) {
     auto connectorSplit = std::make_shared<connector::hive::HiveConnectorSplit>(
         kHiveConnectorId,
         "file:" + filePath.path().string(),
diff --git a/velox/examples/ScanOrc.cpp b/velox/examples/ScanOrc.cpp
index 238138efd9b2f..bac1f6be4d83f 100644
--- a/velox/examples/ScanOrc.cpp
+++ b/velox/examples/ScanOrc.cpp
@@ -19,7 +19,9 @@
 
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/Memory.h"
-#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/dwio/common/Reader.h"
+#include "velox/dwio/common/ReaderFactory.h"
+#include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/BaseVector.h"
 
@@ -31,7 +33,7 @@ using namespace facebook::velox::dwrf;
 // Used to compare the ORC data read by DWRFReader against apache-orc repo.
 // Usage: velox_example_scan_orc {orc_file_path}
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   if (argc < 2) {
     return 1;
@@ -41,17 +43,19 @@ int main(int argc, char** argv) {
   // filesystem. We also need to register the dwrf reader factory:
   filesystems::registerLocalFileSystem();
   dwrf::registerDwrfReaderFactory();
-  auto pool = facebook::velox::memory::addDefaultLeafMemoryPool();
+  facebook::velox::memory::MemoryManager::initialize({});
+  auto pool = facebook::velox::memory::memoryManager()->addLeafPool();
 
   std::string filePath{argv[1]};
   dwio::common::ReaderOptions readerOpts{pool.get()};
   // To make DwrfReader reads ORC file, setFileFormat to FileFormat::ORC
   readerOpts.setFileFormat(FileFormat::ORC);
-  auto reader = DwrfReader::create(
-      std::make_unique<BufferedInput>(
-          std::make_shared<LocalReadFile>(filePath),
-          readerOpts.getMemoryPool()),
-      readerOpts);
+  auto reader = dwio::common::getReaderFactory(FileFormat::ORC)
+                    ->createReader(
+                        std::make_unique<BufferedInput>(
+                            std::make_shared<LocalReadFile>(filePath),
+                            readerOpts.memoryPool()),
+                        readerOpts);
 
   VectorPtr batch;
   RowReaderOptions rowReaderOptions;
diff --git a/velox/examples/SimpleFunctions.cpp b/velox/examples/SimpleFunctions.cpp
index 0cd782d0fb92a..6d7c5500c2812 100644
--- a/velox/examples/SimpleFunctions.cpp
+++ b/velox/examples/SimpleFunctions.cpp
@@ -331,6 +331,7 @@ struct MyRegexpMatchFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig&,
       const arg_type<Varchar>*,
       const arg_type<Varchar>* pattern) {
diff --git a/velox/examples/VectorReaderWriter.cpp b/velox/examples/VectorReaderWriter.cpp
index 70d737e1fc3b2..a17d1908e2791 100644
--- a/velox/examples/VectorReaderWriter.cpp
+++ b/velox/examples/VectorReaderWriter.cpp
@@ -38,6 +38,7 @@ auto serial() {
 
 int main() {
   const int num_rows = 8;
+  memory::MemoryManager::initialize({});
 
   /****************** Vector Writer **********************/
 
@@ -46,7 +47,7 @@ int main() {
   // Array<Map<int,int>>
   auto type = TypeFactory<TypeKind::ARRAY>::create(
       TypeFactory<TypeKind::MAP>::create(BIGINT(), BIGINT()));
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
 
   // result vector
   VectorPtr result;
diff --git a/velox/exec/AddressableNonNullValueList.cpp b/velox/exec/AddressableNonNullValueList.cpp
index dcb12aaddc4c7..5e4cc84d36919 100644
--- a/velox/exec/AddressableNonNullValueList.cpp
+++ b/velox/exec/AddressableNonNullValueList.cpp
@@ -18,11 +18,9 @@
 
 namespace facebook::velox::aggregate::prestosql {
 
-HashStringAllocator::Position AddressableNonNullValueList::append(
-    const DecodedVector& decoded,
-    vector_size_t index,
+ByteOutputStream AddressableNonNullValueList::initStream(
     HashStringAllocator* allocator) {
-  ByteStream stream(allocator);
+  ByteOutputStream stream(allocator);
   if (!firstHeader_) {
     // An array_agg or related begins with an allocation of 5 words and
     // 4 bytes for header. This is compact for small arrays (up to 5
@@ -30,78 +28,106 @@ HashStringAllocator::Position AddressableNonNullValueList::append(
     // and a next pointer. This could be adaptive, with smaller initial
     // sizes for lots of small arrays.
     static constexpr int kInitialSize = 44;
-
     currentPosition_ = allocator->newWrite(stream, kInitialSize);
     firstHeader_ = currentPosition_.header;
   } else {
     allocator->extendWrite(currentPosition_, stream);
   }
 
-  // Write hash.
-  stream.appendOne(decoded.base()->hashValueAt(decoded.index(index)));
+  return stream;
+}
+
+AddressableNonNullValueList::Entry AddressableNonNullValueList::append(
+    const DecodedVector& decoded,
+    vector_size_t index,
+    HashStringAllocator* allocator) {
+  return append(*decoded.base(), decoded.index(index), allocator);
+}
+
+AddressableNonNullValueList::Entry AddressableNonNullValueList::append(
+    const BaseVector& vector,
+    vector_size_t index,
+    HashStringAllocator* allocator) {
+  auto stream = initStream(allocator);
+
+  const auto hash = vector.hashValueAt(index);
+
+  const auto originalSize = stream.size();
+
   // Write value.
-  exec::ContainerRowSerde::serialize(
-      *decoded.base(), decoded.index(index), stream);
+  exec::ContainerRowSerdeOptions options{};
+  exec::ContainerRowSerde::serialize(vector, index, stream, options);
+  ++size_;
 
+  auto startAndFinish = allocator->finishWrite(stream, 1024);
+  currentPosition_ = startAndFinish.second;
+
+  const auto writtenSize = stream.size() - originalSize;
+
+  return {startAndFinish.first, writtenSize, hash};
+}
+
+HashStringAllocator::Position AddressableNonNullValueList::appendSerialized(
+    const StringView& value,
+    HashStringAllocator* allocator) {
+  auto stream = initStream(allocator);
+
+  const auto originalSize = stream.size();
+  stream.appendStringView(value);
   ++size_;
 
   auto startAndFinish = allocator->finishWrite(stream, 1024);
   currentPosition_ = startAndFinish.second;
-  return startAndFinish.first;
+  VELOX_CHECK_EQ(stream.size() - originalSize, value.size());
+  return {startAndFinish.first};
 }
 
 namespace {
 
-void prepareRead(
-    HashStringAllocator::Position position,
-    ByteStream& stream,
-    bool skipHash) {
-  auto header = position.header;
-  auto seek = static_cast<int32_t>(position.position - header->begin());
-
-  HashStringAllocator::prepareRead(header, stream);
-  stream.seekp(seek);
-  if (skipHash) {
-    stream.skip(sizeof(uint64_t));
-  }
+std::unique_ptr<ByteInputStream> prepareRead(
+    const AddressableNonNullValueList::Entry& entry) {
+  auto header = entry.offset.header;
+  auto seek = entry.offset.position - header->begin();
+
+  auto stream = HashStringAllocator::prepareRead(header, entry.size + seek);
+  stream->seekp(seek);
+  return stream;
 }
 } // namespace
 
 // static
 bool AddressableNonNullValueList::equalTo(
-    HashStringAllocator::Position left,
-    HashStringAllocator::Position right,
+    const Entry& left,
+    const Entry& right,
     const TypePtr& type) {
-  ByteStream leftStream;
-  prepareRead(left, leftStream, true /*skipHash*/);
+  if (left.hash != right.hash) {
+    return false;
+  }
 
-  ByteStream rightStream;
-  prepareRead(right, rightStream, true /*skipHash*/);
+  auto leftStream = prepareRead(left);
+  auto rightStream = prepareRead(right);
 
-  CompareFlags compareFlags;
-  compareFlags.equalsOnly = true;
+  CompareFlags compareFlags =
+      CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
   return exec::ContainerRowSerde::compare(
-             leftStream, rightStream, type.get(), compareFlags) == 0;
-}
-
-// static
-uint64_t AddressableNonNullValueList::readHash(
-    HashStringAllocator::Position position) {
-  ByteStream stream;
-  prepareRead(position, stream, false /*skipHash*/);
-
-  return stream.read<uint64_t>();
+             *leftStream, *rightStream, type.get(), compareFlags) == 0;
 }
 
 // static
 void AddressableNonNullValueList::read(
-    HashStringAllocator::Position position,
+    const Entry& position,
     BaseVector& result,
     vector_size_t index) {
-  ByteStream stream;
-  prepareRead(position, stream, true /*skipHash*/);
+  auto stream = prepareRead(position);
+  exec::ContainerRowSerde::deserialize(*stream, index, &result);
+}
 
-  exec::ContainerRowSerde::deserialize(stream, index, &result);
+// static
+void AddressableNonNullValueList::readSerialized(
+    const Entry& position,
+    char* dest) {
+  auto stream = prepareRead(position);
+  stream->readBytes(dest, position.size);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/exec/AddressableNonNullValueList.h b/velox/exec/AddressableNonNullValueList.h
index c5906b1918965..b8713ccca0e3c 100644
--- a/velox/exec/AddressableNonNullValueList.h
+++ b/velox/exec/AddressableNonNullValueList.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/common/base/IOUtils.h"
 #include "velox/common/memory/HashStringAllocator.h"
 #include "velox/vector/DecodedVector.h"
 
@@ -30,33 +31,49 @@ namespace facebook::velox::aggregate::prestosql {
 /// set_union.
 class AddressableNonNullValueList {
  public:
+  struct Entry {
+    HashStringAllocator::Position offset;
+    size_t size;
+    uint64_t hash;
+  };
+
   struct Hash {
-    size_t operator()(HashStringAllocator::Position position) const {
-      return AddressableNonNullValueList::readHash(position);
+    size_t operator()(const Entry& key) const {
+      return key.hash;
     }
   };
 
   struct EqualTo {
     const TypePtr& type;
 
-    bool operator()(
-        HashStringAllocator::Position left,
-        HashStringAllocator::Position right) const {
+    bool operator()(const Entry& left, const Entry& right) const {
       return AddressableNonNullValueList::equalTo(left, right, type);
     }
   };
 
   /// Append a non-null value to the end of the list. Returns 'index' that can
   /// be used to access the value later.
-  HashStringAllocator::Position append(
+  Entry append(
       const DecodedVector& decoded,
       vector_size_t index,
       HashStringAllocator* allocator);
 
+  /// Same as above, but takes BaseVector.
+  Entry append(
+      const BaseVector& vector,
+      vector_size_t index,
+      HashStringAllocator* allocator);
+
+  /// Append a non-null serialized value to the end of the list.
+  /// Returns position that can be used to access the value later.
+  HashStringAllocator::Position appendSerialized(
+      const StringView& value,
+      HashStringAllocator* allocator);
+
   /// Removes last element. 'position' must be a value returned from the latest
   /// call to 'append'.
-  void removeLast(HashStringAllocator::Position position) {
-    currentPosition_ = position;
+  void removeLast(const Entry& entry) {
+    currentPosition_ = entry.offset;
     --size_;
   }
 
@@ -66,19 +83,15 @@ class AddressableNonNullValueList {
   }
 
   /// Returns true if elements at 'left' and 'right' are equal.
-  static bool equalTo(
-      HashStringAllocator::Position left,
-      HashStringAllocator::Position right,
-      const TypePtr& type);
-
-  /// Returns the hash of the specified element.
-  static uint64_t readHash(HashStringAllocator::Position position);
+  static bool
+  equalTo(const Entry& left, const Entry& right, const TypePtr& type);
 
   /// Copies the specified element to 'result[index]'.
-  static void read(
-      HashStringAllocator::Position position,
-      BaseVector& result,
-      vector_size_t index);
+  static void
+  read(const Entry& position, BaseVector& result, vector_size_t index);
+
+  /// Copies to 'dest' entry.size bytes at position.
+  static void readSerialized(const Entry& position, char* dest);
 
   void free(HashStringAllocator& allocator) {
     if (size_ > 0) {
@@ -87,6 +100,8 @@ class AddressableNonNullValueList {
   }
 
  private:
+  ByteOutputStream initStream(HashStringAllocator* allocator);
+
   // Memory allocation (potentially multi-part).
   HashStringAllocator::Header* firstHeader_{nullptr};
   HashStringAllocator::Position currentPosition_{nullptr, nullptr};
diff --git a/velox/exec/Aggregate.cpp b/velox/exec/Aggregate.cpp
index 11c26e8983f98..1bab06a1a8336 100644
--- a/velox/exec/Aggregate.cpp
+++ b/velox/exec/Aggregate.cpp
@@ -55,8 +55,9 @@ getAggregateFunctionEntry(const std::string& name) {
 
 AggregateRegistrationResult registerAggregateFunction(
     const std::string& name,
-    std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures,
-    AggregateFunctionFactory factory,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>& signatures,
+    const AggregateFunctionFactory& factory,
+    const AggregateFunctionMetadata& metadata,
     bool registerCompanionFunctions,
     bool overwrite) {
   auto sanitizedName = sanitizeName(name);
@@ -64,15 +65,16 @@ AggregateRegistrationResult registerAggregateFunction(
 
   if (overwrite) {
     aggregateFunctions().withWLock([&](auto& aggregationFunctionMap) {
-      aggregationFunctionMap[sanitizedName] = {signatures, std::move(factory)};
+      aggregationFunctionMap[sanitizedName] = {
+          signatures, std::move(factory), metadata};
     });
     registered.mainFunction = true;
   } else {
     auto inserted =
         aggregateFunctions().withWLock([&](auto& aggregationFunctionMap) {
-          auto [_, inserted] = aggregationFunctionMap.insert(
-              {sanitizedName, {signatures, factory}});
-          return inserted;
+          auto [_, inserted_2] = aggregationFunctionMap.insert(
+              {sanitizedName, {signatures, factory, metadata}});
+          return inserted_2;
         });
     registered.mainFunction = inserted;
   }
@@ -98,6 +100,47 @@ AggregateRegistrationResult registerAggregateFunction(
   return registered;
 }
 
+AggregateRegistrationResult registerAggregateFunction(
+    const std::string& name,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>& signatures,
+    const AggregateFunctionFactory& factory,
+    bool registerCompanionFunctions,
+    bool overwrite) {
+  return registerAggregateFunction(
+      name, signatures, factory, {}, registerCompanionFunctions, overwrite);
+}
+
+std::vector<AggregateRegistrationResult> registerAggregateFunction(
+    const std::vector<std::string>& names,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>& signatures,
+    const AggregateFunctionFactory& factory,
+    bool registerCompanionFunctions,
+    bool overwrite) {
+  return registerAggregateFunction(
+      names, signatures, factory, {}, registerCompanionFunctions, overwrite);
+}
+
+std::vector<AggregateRegistrationResult> registerAggregateFunction(
+    const std::vector<std::string>& names,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>& signatures,
+    const AggregateFunctionFactory& factory,
+    const AggregateFunctionMetadata& metadata,
+    bool registerCompanionFunctions,
+    bool overwrite) {
+  auto size = names.size();
+  std::vector<AggregateRegistrationResult> registrationResults{size};
+  for (int i = 0; i < size; ++i) {
+    registrationResults[i] = registerAggregateFunction(
+        names[i],
+        signatures,
+        factory,
+        metadata,
+        registerCompanionFunctions,
+        overwrite);
+  }
+  return registrationResults;
+}
+
 std::unordered_map<
     std::string,
     std::vector<std::shared_ptr<AggregateFunctionSignature>>>
@@ -282,9 +325,13 @@ void Aggregate::setOffsetsInternal(
     int32_t offset,
     int32_t nullByte,
     uint8_t nullMask,
+    int32_t initializedByte,
+    uint8_t initializedMask,
     int32_t rowSizeOffset) {
   nullByte_ = nullByte;
   nullMask_ = nullMask;
+  initializedByte_ = initializedByte;
+  initializedMask_ = initializedMask;
   offset_ = offset;
   rowSizeOffset_ = rowSizeOffset;
 }
@@ -293,4 +340,24 @@ void Aggregate::clearInternal() {
   numNulls_ = 0;
 }
 
+void Aggregate::singleInputAsIntermediate(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    VectorPtr& result) const {
+  VELOX_CHECK_EQ(args.size(), 1);
+  const auto& input = args[0];
+  if (rows.isAllSelected()) {
+    result = input;
+    return;
+  }
+  VELOX_CHECK_NOT_NULL(result);
+  // Set result to NULL for rows that are masked out.
+  {
+    auto nulls = allocateNulls(rows.size(), allocator_->pool(), bits::kNull);
+    rows.clearNulls(nulls);
+    result->setNulls(nulls);
+  }
+  result->copy(input.get(), rows, nullptr);
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Aggregate.h b/velox/exec/Aggregate.h
index ff460f0b55d9a..d6bc12aefcdee 100644
--- a/velox/exec/Aggregate.h
+++ b/velox/exec/Aggregate.h
@@ -42,12 +42,12 @@ bool isPartialOutput(core::AggregationNode::Step step);
 
 class Aggregate {
  protected:
-  explicit Aggregate(TypePtr resultType) : resultType_(resultType) {}
+  explicit Aggregate(TypePtr resultType) : resultType_(std::move(resultType)) {}
 
  public:
   virtual ~Aggregate() {}
 
-  TypePtr resultType() const {
+  const TypePtr& resultType() const {
     return resultType_;
   }
 
@@ -105,6 +105,10 @@ class Aggregate {
   // @param offset Offset in bytes from the start of the row of the accumulator
   // @param nullByte Offset in bytes from the start of the row of the null flag
   // @param nullMask The specific bit in the nullByte that stores the null flag
+  // @param initializedByte Offset in bytes from the start of the row of the
+  // initialized flag
+  // @param initializedMask The specific bit in the initializedByte that stores
+  // the initialized flag
   // @param rowSizeOffset The offset of a uint32_t row size from the start of
   // the row. Only applies to accumulators that store variable size data out of
   // line. Fixed length accumulators do not use this. 0 if the row does not have
@@ -113,8 +117,16 @@ class Aggregate {
       int32_t offset,
       int32_t nullByte,
       uint8_t nullMask,
+      int32_t initializedByte,
+      int8_t initializedMask,
       int32_t rowSizeOffset) {
-    setOffsetsInternal(offset, nullByte, nullMask, rowSizeOffset);
+    setOffsetsInternal(
+        offset,
+        nullByte,
+        nullMask,
+        initializedByte,
+        initializedMask,
+        rowSizeOffset);
   }
 
   // Initializes null flags and accumulators for newly encountered groups.  This
@@ -124,7 +136,13 @@ class Aggregate {
   // @param indices Indices into 'groups' of the new entries.
   virtual void initializeNewGroups(
       char** groups,
-      folly::Range<const vector_size_t*> indices) = 0;
+      folly::Range<const vector_size_t*> indices) {
+    initializeNewGroupsInternal(groups, indices);
+
+    for (auto index : indices) {
+      groups[index][initializedByte_] |= initializedMask_;
+    }
+  }
 
   // Single Aggregate instance is able to take both raw data and
   // intermediate result as input based on the assumption that Partial
@@ -208,6 +226,10 @@ class Aggregate {
   // 'result' and its parts are expected to be singly referenced. If
   // other threads or operators hold references that they would use
   // after 'result' has been updated by this, effects will be unpredictable.
+  // This method should not have side effects, i.e., calling this method
+  // doesn't change the content of the accumulators. This is needed for an
+  // optimization in Window operator where aggregations for expanding frames are
+  // computed incrementally.
   virtual void
   extractValues(char** groups, int32_t numGroups, VectorPtr* result) = 0;
 
@@ -216,7 +238,7 @@ class Aggregate {
   // @param numGroups Number of groups to extract results from.
   // @param result The result vector to store the results in.
   //
-  // See comment on 'result' in extractValues().
+  // See comment on 'result' and side effects in extractValues().
   virtual void
   extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result) = 0;
 
@@ -238,8 +260,14 @@ class Aggregate {
   }
 
   // Frees any out of line storage for the accumulator in
-  // 'groups'. No-op for fixed length accumulators.
-  virtual void destroy(folly::Range<char**> /*groups*/) {}
+  // 'groups' and marks the aggregate as uninitialized.
+  virtual void destroy(folly::Range<char**> groups) {
+    destroyInternal(groups);
+
+    for (auto* group : groups) {
+      group[initializedByte_] &= ~initializedMask_;
+    }
+  }
 
   // Clears state between reuses, e.g. this is called before reusing
   // the aggregation operator's state after flushing a partial
@@ -252,6 +280,24 @@ class Aggregate {
     validateIntermediateInputs_ = true;
   }
 
+  /// Creates an instance of aggregate function to accumulate a mix of raw input
+  /// and intermediate results and produce either intermediate or final result.
+  ///
+  /// The caller will call setAllocator and setOffsets before starting to add
+  /// data via initializeNewGroups, addRawInput, addIntermediateResults, etc.
+  ///
+  /// @param name Function name, e.g. min, max, sum, avg.
+  /// @param step Either kPartial or kSingle. Determines the type of result:
+  /// intermediate if kPartial, final if kSingle. Partial and intermediate
+  /// aggregations create functions using kPartial. Single and final
+  /// aggregations create functions using kSingle.
+  /// @param argTypes Raw input types. Combined with the function name, uniquely
+  /// identifies the function.
+  /// @param resultType Intermediate result type if step is kPartial. Final
+  /// result type is step is kFinal. This parameter is redundant since it can be
+  /// derived from rawInput types and step. Present for legacy reasons.
+  /// @param config Query config.
+  /// @return An instance of the aggregate function.
   static std::unique_ptr<Aggregate> create(
       const std::string& name,
       core::AggregationNode::Step step,
@@ -272,10 +318,32 @@ class Aggregate {
       int32_t offset,
       int32_t nullByte,
       uint8_t nullMask,
+      int32_t initializedByte,
+      uint8_t initializedMask,
       int32_t rowSizeOffset);
 
   virtual void clearInternal();
 
+  // Initializes null flags and accumulators for newly encountered groups.  This
+  // function should be called only once for each group.
+  //
+  // @param groups Pointers to the start of the new group rows.
+  // @param indices Indices into 'groups' of the new entries.
+  virtual void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) = 0;
+
+  // Frees any out of line storage for the accumulator in
+  // 'groups'. No-op for fixed length accumulators.
+  virtual void destroyInternal(folly::Range<char**> groups) {}
+
+  // Helper function to pass single input argument directly as intermediate
+  // result.
+  void singleInputAsIntermediate(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      VectorPtr& result) const;
+
   // Shorthand for maintaining accumulator variable length size in
   // accumulator update methods. Use like: { auto tracker =
   // trackRowSize(group); update(group); }
@@ -288,6 +356,10 @@ class Aggregate {
     return numNulls_ && (group[nullByte_] & nullMask_);
   }
 
+  bool isInitialized(char* group) const {
+    return group[initializedByte_] & initializedMask_;
+  }
+
   // Sets null flag for all specified groups to true.
   // For any given group, this method can be called at most once.
   void setAllNulls(char** groups, folly::Range<const vector_size_t*> indices) {
@@ -329,9 +401,11 @@ class Aggregate {
 
   template <typename T>
   void destroyAccumulator(char* group) const {
-    auto accumulator = value<T>(group);
-    std::destroy_at(accumulator);
-    memset(accumulator, 0, sizeof(T));
+    if (isInitialized(group)) {
+      auto accumulator = value<T>(group);
+      std::destroy_at(accumulator);
+      ::memset(accumulator, 0, sizeof(T));
+    }
   }
 
   template <typename T>
@@ -362,6 +436,9 @@ class Aggregate {
   // Byte position of null flag in group row.
   int32_t nullByte_;
   uint8_t nullMask_;
+  // Byte position of the initialized flag in group row.
+  int32_t initializedByte_;
+  uint8_t initializedMask_;
   // Offset of fixed length accumulator state in group row.
   int32_t offset_;
 
@@ -395,6 +472,11 @@ using AggregateFunctionFactory = std::function<std::unique_ptr<Aggregate>(
     const TypePtr& resultType,
     const core::QueryConfig& config)>;
 
+struct AggregateFunctionMetadata {
+  /// True if results of the aggregation depend on the order of inputs. For
+  /// example, array_agg is order sensitive while count is not.
+  bool orderSensitive{true};
+};
 /// Register an aggregate function with the specified name and signatures. If
 /// registerCompanionFunctions is true, also register companion aggregate and
 /// scalar functions with it. When functions with `name` already exist, if
@@ -402,10 +484,35 @@ using AggregateFunctionFactory = std::function<std::unique_ptr<Aggregate>(
 /// false without overwriting the registry.
 AggregateRegistrationResult registerAggregateFunction(
     const std::string& name,
-    std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures,
-    AggregateFunctionFactory factory,
-    bool registerCompanionFunctions = false,
-    bool overwrite = false);
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>& signatures,
+    const AggregateFunctionFactory& factory,
+    bool registerCompanionFunctions,
+    bool overwrite);
+
+AggregateRegistrationResult registerAggregateFunction(
+    const std::string& name,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>& signatures,
+    const AggregateFunctionFactory& factory,
+    const AggregateFunctionMetadata& metadata,
+    bool registerCompanionFunctions,
+    bool overwrite);
+
+// Register an aggregation function with multiple names. Returns a vector of
+// AggregateRegistrationResult, one for each name at the corresponding index.
+std::vector<AggregateRegistrationResult> registerAggregateFunction(
+    const std::vector<std::string>& names,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>& signatures,
+    const AggregateFunctionFactory& factory,
+    bool registerCompanionFunctions,
+    bool overwrite);
+
+std::vector<AggregateRegistrationResult> registerAggregateFunction(
+    const std::vector<std::string>& names,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>& signatures,
+    const AggregateFunctionFactory& factory,
+    const AggregateFunctionMetadata& metadata,
+    bool registerCompanionFunctions,
+    bool overwrite);
 
 /// Returns signatures of the aggregate function with the specified name.
 /// Returns empty std::optional if function with that name is not found.
@@ -422,6 +529,7 @@ AggregateFunctionSignatureMap getAggregateFunctionSignatures();
 struct AggregateFunctionEntry {
   std::vector<AggregateFunctionSignaturePtr> signatures;
   AggregateFunctionFactory factory;
+  AggregateFunctionMetadata metadata;
 };
 
 using AggregateFunctionMap = folly::Synchronized<
diff --git a/velox/exec/AggregateCompanionAdapter.cpp b/velox/exec/AggregateCompanionAdapter.cpp
index 06998e79e2c02..d0c36e660224d 100644
--- a/velox/exec/AggregateCompanionAdapter.cpp
+++ b/velox/exec/AggregateCompanionAdapter.cpp
@@ -27,8 +27,16 @@ void AggregateCompanionFunctionBase::setOffsetsInternal(
     int32_t offset,
     int32_t nullByte,
     uint8_t nullMask,
+    int32_t initializedByte,
+    uint8_t initializedMask,
     int32_t rowSizeOffset) {
-  fn_->setOffsets(offset, nullByte, nullMask, rowSizeOffset);
+  fn_->setOffsets(
+      offset,
+      nullByte,
+      nullMask,
+      initializedByte,
+      initializedMask,
+      rowSizeOffset);
 }
 
 int32_t AggregateCompanionFunctionBase::accumulatorFixedWidthSize() const {
@@ -56,6 +64,11 @@ void AggregateCompanionFunctionBase::destroy(folly::Range<char**> groups) {
   fn_->destroy(groups);
 }
 
+void AggregateCompanionFunctionBase::destroyInternal(
+    folly::Range<char**> groups) {
+  fn_->destroy(groups);
+}
+
 void AggregateCompanionFunctionBase::clearInternal() {
   fn_->clear();
 }
@@ -66,6 +79,12 @@ void AggregateCompanionFunctionBase::initializeNewGroups(
   fn_->initializeNewGroups(groups, indices);
 }
 
+void AggregateCompanionFunctionBase::initializeNewGroupsInternal(
+    char** groups,
+    folly::Range<const vector_size_t*> indices) {
+  fn_->initializeNewGroups(groups, indices);
+}
+
 void AggregateCompanionFunctionBase::addRawInput(
     char** groups,
     const SelectivityVector& rows,
@@ -154,6 +173,8 @@ int32_t AggregateCompanionAdapter::ExtractFunction::setOffset() const {
       offset,
       RowContainer::nullByte(0),
       RowContainer::nullMask(0),
+      RowContainer::initializedByte(0),
+      RowContainer::initializedMask(0),
       rowSizeOffset);
   return offset;
 }
@@ -304,81 +325,12 @@ bool CompanionFunctionsRegistrar::registerMergeFunction(
       .mainFunction;
 }
 
-bool CompanionFunctionsRegistrar::registerMergeExtractFunctionWithSuffix(
+bool registerAggregateFunction(
     const std::string& name,
-    const std::vector<AggregateFunctionSignaturePtr>& signatures,
+    const std::string& mergeExtractFunctionName,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>&
+        mergeExtractSignatures,
     bool overwrite) {
-  auto groupedSignatures =
-      CompanionSignatures::groupSignaturesByReturnType(signatures);
-  bool registered = false;
-  for (const auto& [type, signatureGroup] : groupedSignatures) {
-    auto mergeExtractSignatures =
-        CompanionSignatures::mergeExtractFunctionSignatures(signatureGroup);
-    if (mergeExtractSignatures.empty()) {
-      continue;
-    }
-
-    auto mergeExtractFunctionName =
-        CompanionSignatures::mergeExtractFunctionNameWithSuffix(name, type);
-
-    registered |=
-        exec::registerAggregateFunction(
-            mergeExtractFunctionName,
-            std::move(mergeExtractSignatures),
-            [name, mergeExtractFunctionName](
-                core::AggregationNode::Step /*step*/,
-                const std::vector<TypePtr>& argTypes,
-                const TypePtr& resultType,
-                const core::QueryConfig& config) -> std::unique_ptr<Aggregate> {
-              const auto& [originalResultType, _] =
-                  resolveAggregateFunction(mergeExtractFunctionName, argTypes);
-              if (!originalResultType) {
-                // TODO: limitation -- result type must be resolveable given
-                // intermediate type of the original UDAF.
-                VELOX_UNREACHABLE(
-                    "Signatures whose result types are not resolvable given intermediate types should have been excluded.");
-              }
-
-              if (auto func = getAggregateFunctionEntry(name)) {
-                auto fn = func->factory(
-                    core::AggregationNode::Step::kFinal,
-                    argTypes,
-                    originalResultType,
-                    config);
-                VELOX_CHECK_NOT_NULL(fn);
-                return std::make_unique<
-                    AggregateCompanionAdapter::MergeExtractFunction>(
-                    std::move(fn), resultType);
-              }
-              VELOX_FAIL(
-                  "Original aggregation function {} not found: {}",
-                  name,
-                  mergeExtractFunctionName);
-            },
-            /*registerCompanionFunctions*/ false,
-            overwrite)
-            .mainFunction;
-  }
-  return registered;
-}
-
-bool CompanionFunctionsRegistrar::registerMergeExtractFunction(
-    const std::string& name,
-    const std::vector<AggregateFunctionSignaturePtr>& signatures,
-    bool overwrite) {
-  if (CompanionSignatures::hasSameIntermediateTypesAcrossSignatures(
-          signatures)) {
-    return registerMergeExtractFunctionWithSuffix(name, signatures, overwrite);
-  }
-
-  auto mergeExtractSignatures =
-      CompanionSignatures::mergeExtractFunctionSignatures(signatures);
-  if (mergeExtractSignatures.empty()) {
-    return false;
-  }
-
-  auto mergeExtractFunctionName =
-      CompanionSignatures::mergeExtractFunctionName(name);
   return exec::registerAggregateFunction(
              mergeExtractFunctionName,
              std::move(mergeExtractSignatures),
@@ -418,82 +370,63 @@ bool CompanionFunctionsRegistrar::registerMergeExtractFunction(
       .mainFunction;
 }
 
-bool CompanionFunctionsRegistrar::registerExtractFunctionWithSuffix(
-    const std::string& originalName,
+bool CompanionFunctionsRegistrar::registerMergeExtractFunctionWithSuffix(
+    const std::string& name,
     const std::vector<AggregateFunctionSignaturePtr>& signatures,
     bool overwrite) {
   auto groupedSignatures =
       CompanionSignatures::groupSignaturesByReturnType(signatures);
   bool registered = false;
   for (const auto& [type, signatureGroup] : groupedSignatures) {
-    auto extractSignatures =
-        CompanionSignatures::extractFunctionSignatures(signatureGroup);
-    if (extractSignatures.empty()) {
+    auto mergeExtractSignatures =
+        CompanionSignatures::mergeExtractFunctionSignatures(signatureGroup);
+    if (mergeExtractSignatures.empty()) {
       continue;
     }
 
-    auto factory = [originalName](
-                       const std::string& name,
-                       const std::vector<VectorFunctionArg>& inputArgs,
-                       const core::QueryConfig& config)
-        -> std::shared_ptr<VectorFunction> {
-      std::vector<TypePtr> argTypes{inputArgs.size()};
-      std::transform(
-          inputArgs.begin(),
-          inputArgs.end(),
-          argTypes.begin(),
-          [](auto inputArg) { return inputArg.type; });
-
-      auto resultType = resolveVectorFunction(name, argTypes);
-      if (!resultType) {
-        // TODO: limitation -- result type must be resolveable given
-        // intermediate type of the original UDAF.
-        VELOX_UNREACHABLE(
-            "Signatures whose result types are not resolvable given intermediate types should have been excluded.");
-      }
-
-      if (auto func = getAggregateFunctionEntry(originalName)) {
-        auto fn = func->factory(
-            core::AggregationNode::Step::kFinal, argTypes, resultType, config);
-        VELOX_CHECK_NOT_NULL(fn);
-        return std::make_shared<AggregateCompanionAdapter::ExtractFunction>(
-            std::move(fn));
-      }
-      VELOX_FAIL(
-          "Original aggregation function {} not found: {}", originalName, name);
-    };
+    auto mergeExtractFunctionName =
+        CompanionSignatures::mergeExtractFunctionNameWithSuffix(name, type);
 
-    registered |= exec::registerStatefulVectorFunction(
-        CompanionSignatures::extractFunctionNameWithSuffix(originalName, type),
-        extractSignatures,
-        factory,
-        {},
+    registered |= registerAggregateFunction(
+        name,
+        mergeExtractFunctionName,
+        std::move(mergeExtractSignatures),
         overwrite);
   }
   return registered;
 }
 
-bool CompanionFunctionsRegistrar::registerExtractFunction(
-    const std::string& originalName,
+bool CompanionFunctionsRegistrar::registerMergeExtractFunction(
+    const std::string& name,
     const std::vector<AggregateFunctionSignaturePtr>& signatures,
     bool overwrite) {
   if (CompanionSignatures::hasSameIntermediateTypesAcrossSignatures(
           signatures)) {
-    return registerExtractFunctionWithSuffix(
-        originalName, signatures, overwrite);
+    return registerMergeExtractFunctionWithSuffix(name, signatures, overwrite);
   }
 
-  auto extractSignatures =
-      CompanionSignatures::extractFunctionSignatures(signatures);
-  if (extractSignatures.empty()) {
+  auto mergeExtractSignatures =
+      CompanionSignatures::mergeExtractFunctionSignatures(signatures);
+  if (mergeExtractSignatures.empty()) {
     return false;
   }
 
-  auto factory =
-      [originalName](
-          const std::string& name,
-          const std::vector<VectorFunctionArg>& inputArgs,
-          const core::QueryConfig& config) -> std::shared_ptr<VectorFunction> {
+  auto mergeExtractFunctionName =
+      CompanionSignatures::mergeExtractFunctionName(name);
+  return registerAggregateFunction(
+      name,
+      mergeExtractFunctionName,
+      std::move(mergeExtractSignatures),
+      overwrite);
+}
+
+VectorFunctionFactory getVectorFunctionFactory(
+    const std::string& originalName) {
+  return [originalName](
+             const std::string& name,
+             const std::vector<VectorFunctionArg>& inputArgs,
+             const core::QueryConfig& config)
+             -> std::shared_ptr<VectorFunction> {
     std::vector<TypePtr> argTypes{inputArgs.size()};
     std::transform(
         inputArgs.begin(),
@@ -519,11 +452,57 @@ bool CompanionFunctionsRegistrar::registerExtractFunction(
     VELOX_FAIL(
         "Original aggregation function {} not found: {}", originalName, name);
   };
+}
+
+bool CompanionFunctionsRegistrar::registerExtractFunctionWithSuffix(
+    const std::string& originalName,
+    const std::vector<AggregateFunctionSignaturePtr>& signatures,
+    bool overwrite) {
+  auto groupedSignatures =
+      CompanionSignatures::groupSignaturesByReturnType(signatures);
+  bool registered = false;
+  for (const auto& [type, signatureGroup] : groupedSignatures) {
+    auto extractSignatures =
+        CompanionSignatures::extractFunctionSignatures(signatureGroup);
+    if (extractSignatures.empty()) {
+      continue;
+    }
+
+    auto factory = getVectorFunctionFactory(originalName);
+    registered |= exec::registerStatefulVectorFunction(
+        CompanionSignatures::extractFunctionNameWithSuffix(originalName, type),
+        std::move(extractSignatures),
+        std::move(factory),
+        exec::VectorFunctionMetadataBuilder()
+            .defaultNullBehavior(false)
+            .build(),
+        overwrite);
+  }
+  return registered;
+}
+
+bool CompanionFunctionsRegistrar::registerExtractFunction(
+    const std::string& originalName,
+    const std::vector<AggregateFunctionSignaturePtr>& signatures,
+    bool overwrite) {
+  if (CompanionSignatures::hasSameIntermediateTypesAcrossSignatures(
+          signatures)) {
+    return registerExtractFunctionWithSuffix(
+        originalName, signatures, overwrite);
+  }
+
+  auto extractSignatures =
+      CompanionSignatures::extractFunctionSignatures(signatures);
+  if (extractSignatures.empty()) {
+    return false;
+  }
+
+  auto factory = getVectorFunctionFactory(originalName);
   return exec::registerStatefulVectorFunction(
       CompanionSignatures::extractFunctionName(originalName),
-      extractSignatures,
-      factory,
-      {},
+      std::move(extractSignatures),
+      std::move(factory),
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
       overwrite);
 }
 
diff --git a/velox/exec/AggregateCompanionAdapter.h b/velox/exec/AggregateCompanionAdapter.h
index 4b2f0e7f2632f..91b7c3a7bed85 100644
--- a/velox/exec/AggregateCompanionAdapter.h
+++ b/velox/exec/AggregateCompanionAdapter.h
@@ -74,12 +74,20 @@ class AggregateCompanionFunctionBase : public Aggregate {
       int32_t offset,
       int32_t nullByte,
       uint8_t nullMask,
+      int32_t initializedByte,
+      uint8_t initializedMask,
       int32_t rowSizeOffset) override final;
 
   void setAllocatorInternal(HashStringAllocator* allocator) override final;
 
   void clearInternal() override final;
 
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override final;
+
+  void destroyInternal(folly::Range<char**> groups) override final;
+
   std::unique_ptr<Aggregate> fn_;
 };
 
@@ -134,10 +142,6 @@ struct AggregateCompanionAdapter {
     explicit ExtractFunction(std::unique_ptr<Aggregate> fn)
         : fn_{std::move(fn)} {}
 
-    bool isDefaultNullBehavior() const override {
-      return false;
-    }
-
     void apply(
         const SelectivityVector& rows,
         std::vector<VectorPtr>& args,
diff --git a/velox/exec/AggregateInfo.cpp b/velox/exec/AggregateInfo.cpp
new file mode 100644
index 0000000000000..9b19ab687965b
--- /dev/null
+++ b/velox/exec/AggregateInfo.cpp
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/AggregateInfo.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/Operator.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::exec {
+
+namespace {
+std::vector<core::LambdaTypedExprPtr> extractLambdaInputs(
+    const core::AggregationNode::Aggregate& aggregate) {
+  std::vector<core::LambdaTypedExprPtr> lambdas;
+  for (const auto& arg : aggregate.call->inputs()) {
+    if (auto lambda =
+            std::dynamic_pointer_cast<const core::LambdaTypedExpr>(arg)) {
+      lambdas.push_back(lambda);
+    }
+  }
+
+  return lambdas;
+}
+} // namespace
+
+std::vector<AggregateInfo> toAggregateInfo(
+    const core::AggregationNode& aggregationNode,
+    const OperatorCtx& operatorCtx,
+    uint32_t numKeys,
+    std::shared_ptr<core::ExpressionEvaluator>& expressionEvaluator,
+    bool isStreaming) {
+  const auto numAggregates = aggregationNode.aggregates().size();
+  std::vector<AggregateInfo> aggregates;
+  aggregates.reserve(numAggregates);
+
+  const auto& inputType = aggregationNode.sources()[0]->outputType();
+  const auto& outputType = aggregationNode.outputType();
+  const auto step = aggregationNode.step();
+
+  for (auto i = 0; i < numAggregates; i++) {
+    const auto& aggregate = aggregationNode.aggregates()[i];
+    AggregateInfo info;
+    // Populate input.
+    auto& channels = info.inputs;
+    auto& constants = info.constantInputs;
+    for (const auto& arg : aggregate.call->inputs()) {
+      if (auto field =
+              dynamic_cast<const core::FieldAccessTypedExpr*>(arg.get())) {
+        channels.push_back(inputType->getChildIdx(field->name()));
+        constants.push_back(nullptr);
+      } else if (
+          auto constant =
+              dynamic_cast<const core::ConstantTypedExpr*>(arg.get())) {
+        channels.push_back(kConstantChannel);
+        constants.push_back(constant->toConstantVector(operatorCtx.pool()));
+      } else if (
+          auto lambda = dynamic_cast<const core::LambdaTypedExpr*>(arg.get())) {
+        for (const auto& name : lambda->signature()->names()) {
+          if (auto captureIndex = inputType->getChildIdxIfExists(name)) {
+            channels.push_back(captureIndex.value());
+            constants.push_back(nullptr);
+          }
+        }
+      } else {
+        VELOX_FAIL(
+            "Expression must be field access, constant, or lambda: {}",
+            arg->toString());
+      }
+    }
+
+    info.distinct = aggregate.distinct;
+    info.intermediateType = Aggregate::intermediateType(
+        aggregate.call->name(), aggregate.rawInputTypes);
+
+    // Setup aggregation mask: convert the Variable Reference name to the
+    // channel (projection) index, if there is a mask.
+    if (const auto& mask = aggregate.mask) {
+      info.mask = inputType->asRow().getChildIdx(mask->name());
+    } else {
+      info.mask = std::nullopt;
+    }
+
+    auto index = numKeys + i;
+    const auto& aggResultType = outputType->childAt(index);
+    info.function = Aggregate::create(
+        aggregate.call->name(),
+        isPartialOutput(step) ? core::AggregationNode::Step::kPartial
+                              : core::AggregationNode::Step::kSingle,
+        aggregate.rawInputTypes,
+        aggResultType,
+        operatorCtx.driverCtx()->queryConfig());
+
+    auto lambdas = extractLambdaInputs(aggregate);
+    if (!lambdas.empty()) {
+      if (expressionEvaluator == nullptr) {
+        expressionEvaluator = std::make_shared<SimpleExpressionEvaluator>(
+            operatorCtx.execCtx()->queryCtx(), operatorCtx.execCtx()->pool());
+      }
+      info.function->setLambdaExpressions(lambdas, expressionEvaluator);
+    }
+
+    // Ignore sorting properties if aggregate function is not sensitive to the
+    // order of inputs.
+    auto* entry = getAggregateFunctionEntry(aggregate.call->name());
+    const auto& metadata = entry->metadata;
+    if (metadata.orderSensitive) {
+      // Sorting keys and orders.
+      const auto numSortingKeys = aggregate.sortingKeys.size();
+      VELOX_CHECK_EQ(numSortingKeys, aggregate.sortingOrders.size());
+      info.sortingOrders = aggregate.sortingOrders;
+      info.sortingKeys.reserve(numSortingKeys);
+      for (const auto& key : aggregate.sortingKeys) {
+        info.sortingKeys.push_back(exprToChannel(key.get(), inputType));
+      }
+    }
+
+    info.output = index;
+    aggregates.emplace_back(std::move(info));
+  }
+  return aggregates;
+}
+
+std::vector<std::optional<column_index_t>> extractMaskChannels(
+    const std::vector<AggregateInfo>& aggregates) {
+  std::vector<std::optional<column_index_t>> masks;
+  masks.reserve(aggregates.size());
+  for (const auto& aggregate : aggregates) {
+    masks.push_back(aggregate.mask);
+  }
+  return masks;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/AggregateInfo.h b/velox/exec/AggregateInfo.h
index 22e7007e526e6..3bc8ca1e82e2e 100644
--- a/velox/exec/AggregateInfo.h
+++ b/velox/exec/AggregateInfo.h
@@ -54,4 +54,36 @@ struct AggregateInfo {
   /// Type of intermediate results. Used for spilling.
   TypePtr intermediateType;
 };
+
+class OperatorCtx;
+
+/// Translate an AggregationNode to a list of AggregationInfo, which could be
+/// a hash aggregation plan node or a streaming aggregation plan node. Ignore
+/// sorting properties if aggregate function is not sensitive to the order of
+/// inputs.
+///
+/// @param aggregationNode Plan node of this aggregation.
+/// @param operatorCtx Operator context.
+/// @param numKeys Number of grouping keys.
+/// @param expressionEvaluator An Expression evaluator. It is used by an
+/// aggregate operator to compile and eval lambda expression. It should be
+/// initiated/assigned for at most one time.
+/// @param isStreaming Indicate whether this aggregation is streaming or not.
+/// Pass true if the aggregate operator is a StreamingAggregation and false if
+/// the aggregate operator is a HashAggregation. This parameter will be
+/// removed after sorted, distinct aggregation, and lambda functions support
+/// are added to StreamingAggregation.
+/// @return List of AggregationInfo.
+std::vector<AggregateInfo> toAggregateInfo(
+    const core::AggregationNode& aggregationNode,
+    const OperatorCtx& operatorCtx,
+    uint32_t numKeys,
+    std::shared_ptr<core::ExpressionEvaluator>& expressionEvaluator,
+    bool isStreaming = false);
+
+/// Extract index of the 'mask' column for each aggregation from aggregations.
+/// Aggregations without masks use std::nullopt.
+std::vector<std::optional<column_index_t>> extractMaskChannels(
+    const std::vector<AggregateInfo>& aggregates);
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/AggregateUtil.h b/velox/exec/AggregateUtil.h
index e7ffb038fa62d..53df121064b99 100644
--- a/velox/exec/AggregateUtil.h
+++ b/velox/exec/AggregateUtil.h
@@ -24,6 +24,14 @@ struct AggregateRegistrationResult {
   bool mergeFunction{false};
   bool extractFunction{false};
   bool mergeExtractFunction{false};
+
+  bool operator==(const AggregateRegistrationResult& other) const {
+    return mainFunction == other.mainFunction &&
+        partialFunction == other.partialFunction &&
+        mergeFunction == other.mergeFunction &&
+        extractFunction == other.extractFunction &&
+        mergeExtractFunction == other.mergeExtractFunction;
+  }
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/AggregateWindow.cpp b/velox/exec/AggregateWindow.cpp
index 54a3d91bd1c0d..2bdad5342c6e6 100644
--- a/velox/exec/AggregateWindow.cpp
+++ b/velox/exec/AggregateWindow.cpp
@@ -75,8 +75,8 @@ class AggregateWindowFunction : public exec::WindowFunction {
     //
     // Here we always make space for a row size since we only have one
     // row and no RowContainer. We also have a single aggregate here, so there
-    // is only one null bit.
-    static const int32_t kNullOffset = 0;
+    // is only one null bit and one initialized bit.
+    static const int32_t kAccumulatorFlagsOffset = 0;
     static const int32_t kRowSizeOffset = bits::nbytes(1);
     singleGroupRowSize_ = kRowSizeOffset + sizeof(int32_t);
     // Accumulator offset must be aligned by their alignment size.
@@ -84,8 +84,10 @@ class AggregateWindowFunction : public exec::WindowFunction {
         singleGroupRowSize_, aggregate_->accumulatorAlignmentSize());
     aggregate_->setOffsets(
         singleGroupRowSize_,
-        exec::RowContainer::nullByte(kNullOffset),
-        exec::RowContainer::nullMask(kNullOffset),
+        exec::RowContainer::nullByte(kAccumulatorFlagsOffset),
+        exec::RowContainer::nullMask(kAccumulatorFlagsOffset),
+        exec::RowContainer::initializedByte(kAccumulatorFlagsOffset),
+        exec::RowContainer::initializedMask(kAccumulatorFlagsOffset),
         /* needed for out of line allocations */ kRowSizeOffset);
     singleGroupRowSize_ += aggregate_->accumulatorFixedWidthSize();
 
@@ -97,6 +99,8 @@ class AggregateWindowFunction : public exec::WindowFunction {
     // Constructing a vector of a single result value used for copying from
     // the aggregate to the final result.
     aggregateResultVector_ = BaseVector::create(resultType, 1, pool_);
+
+    computeDefaultAggregateValue(resultType);
   }
 
   ~AggregateWindowFunction() {
@@ -196,10 +200,7 @@ class AggregateWindowFunction : public exec::WindowFunction {
       vector_size_t resultOffset,
       const VectorPtr& result) {
     if (!validRows.hasSelections()) {
-      uint64_t* rawNulls = result->mutableRawNulls();
-      for (auto row = 0; row < validRows.size(); row++) {
-        bits::setNull(rawNulls, row + resultOffset, true);
-      }
+      setEmptyFramesResult(validRows, resultOffset, emptyResult_, result);
       return true;
     }
     return false;
@@ -308,7 +309,7 @@ class AggregateWindowFunction : public exec::WindowFunction {
     });
 
     // Set null values for empty (non valid) frames in the output block.
-    setNullEmptyFramesResults(validRows, resultOffset, result);
+    setEmptyFramesResult(validRows, resultOffset, emptyResult_, result);
   }
 
   void simpleAggregation(
@@ -341,7 +342,20 @@ class AggregateWindowFunction : public exec::WindowFunction {
     });
 
     // Set null values for empty (non valid) frames in the output block.
-    setNullEmptyFramesResults(validRows, resultOffset, result);
+    setEmptyFramesResult(validRows, resultOffset, emptyResult_, result);
+  }
+
+  // Precompute and save the aggregate output for empty input in emptyResult_.
+  // This value is returned for rows with empty frames.
+  void computeDefaultAggregateValue(const TypePtr& resultType) {
+    aggregate_->clear();
+    aggregate_->initializeNewGroups(
+        &rawSingleGroupRow_, std::vector<vector_size_t>{0});
+    aggregateInitialized_ = true;
+
+    emptyResult_ = BaseVector::create(resultType, 1, pool_);
+    aggregate_->extractValues(&rawSingleGroupRow_, 1, &emptyResult_);
+    aggregate_->clear();
   }
 
   // Aggregate function object required for this window function evaluation.
@@ -374,6 +388,11 @@ class AggregateWindowFunction : public exec::WindowFunction {
   // Stores metadata about the previous output block of the partition
   // to optimize aggregate computation and reading argument vectors.
   std::optional<FrameMetadata> previousFrameMetadata_;
+
+  // Stores default result value for empty frame aggregation. Window functions
+  // return the default value of an aggregate (aggregation with no rows) for
+  // empty frames. e.g. count for empty frames should return 0 and not null.
+  VectorPtr emptyResult_;
 };
 
 } // namespace
@@ -391,6 +410,7 @@ void registerAggregateWindowFunction(const std::string& name) {
     exec::registerWindowFunction(
         name,
         std::move(signatures),
+        {exec::WindowFunction::ProcessMode::kRows, true},
         [name](
             const std::vector<exec::WindowFunctionArg>& args,
             const TypePtr& resultType,
diff --git a/velox/exec/AggregationHook.h b/velox/exec/AggregationHook.h
index 1b05e3164e1b4..21444aca08a08 100644
--- a/velox/exec/AggregationHook.h
+++ b/velox/exec/AggregationHook.h
@@ -15,27 +15,17 @@
  */
 #pragma once
 
+#include "folly/CPortability.h"
+
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Range.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/vector/LazyVector.h"
 
 namespace facebook::velox::aggregate {
 
 class AggregationHook : public ValueHook {
  public:
-  // Constants for identifying hooks for specialized template instantiations.
-
-  static constexpr Kind kSumFloatToDouble = 1;
-  static constexpr Kind kSumDoubleToDouble = 2;
-  static constexpr Kind kSumIntegerToBigint = 3;
-  static constexpr Kind kSumBigintToBigint = 4;
-  static constexpr Kind kBigintMax = 5;
-  static constexpr Kind kBigintMin = 6;
-  static constexpr Kind kFloatMax = 7;
-  static constexpr Kind kFloatMin = 8;
-  static constexpr Kind kDoubleMax = 9;
-  static constexpr Kind kDoubleMin = 10;
-
   // Make null behavior known at compile time. This is useful when
   // templating a column decoding loop with a hook.
   static constexpr bool kSkipNulls = true;
@@ -53,23 +43,6 @@ class AggregationHook : public ValueHook {
         groups_(groups),
         numNulls_(numNulls) {}
 
-  bool acceptsNulls() const override final {
-    return false;
-  }
-
-  // Fallback implementation of fast path. Prefer defining special
-  // cases for all subclasses.
-  void addValues(
-      const vector_size_t* rows,
-      const void* values,
-      vector_size_t size,
-      uint8_t valueWidth) override {
-    auto valuesAsChar = reinterpret_cast<const char*>(values);
-    for (auto i = 0; i < size; ++i) {
-      addValue(rows[i], valuesAsChar + valueWidth * i);
-    }
-  }
-
  protected:
   inline char* findGroup(vector_size_t row) {
     return groups_[row];
@@ -96,19 +69,7 @@ class AggregationHook : public ValueHook {
   uint64_t* numNulls_;
 };
 
-namespace {
-template <typename TValue>
-inline void updateSingleValue(TValue& result, TValue value) {
-  if constexpr (
-      std::is_same_v<TValue, double> || std::is_same_v<TValue, float>) {
-    result += value;
-  } else {
-    result = checkedPlus<TValue>(result, value);
-  }
-}
-} // namespace
-
-template <typename TValue, typename TAggregate>
+template <typename TAggregate, bool Overflow = false>
 class SumHook final : public AggregationHook {
  public:
   SumHook(
@@ -119,35 +80,70 @@ class SumHook final : public AggregationHook {
       uint64_t* numNulls)
       : AggregationHook(offset, nullByte, nullMask, groups, numNulls) {}
 
-  Kind kind() const override {
+  Kind kind() const final {
     if (std::is_same_v<TAggregate, double>) {
-      if (std::is_same_v<TValue, double>) {
-        return kSumDoubleToDouble;
-      }
-      if (std::is_same_v<TValue, float>) {
-        return kSumFloatToDouble;
-      }
+      return kDoubleSum;
     } else if (std::is_same_v<TAggregate, int64_t>) {
-      if (std::is_same_v<TValue, int32_t>) {
-        return kSumIntegerToBigint;
-      }
-      if (std::is_same_v<TValue, int64_t>) {
-        return kSumBigintToBigint;
-      }
+      return Overflow ? kBigintSumOverflow : kBigintSum;
     }
     return kGeneric;
   }
 
-  void addValue(vector_size_t row, const void* value) override {
+  void addValue(vector_size_t row, int64_t value) final {
+    if constexpr (std::is_integral_v<TAggregate>) {
+      addValueImpl(row, value);
+    } else {
+      VELOX_UNREACHABLE();
+    }
+  }
+
+  void addValue(vector_size_t row, float value) final {
+    if constexpr (std::is_floating_point_v<TAggregate>) {
+      addValueImpl(row, value);
+    } else {
+      VELOX_UNREACHABLE();
+    }
+  }
+
+  void addValue(vector_size_t row, double value) final {
+    if constexpr (std::is_floating_point_v<TAggregate>) {
+      addValueImpl(row, value);
+    } else {
+      VELOX_UNREACHABLE();
+    }
+  }
+
+  // Spark's sum function sets Overflow to true and intentionally let the result
+  // value be automatically wrapped around when integer overflow happens. Hence,
+  // disable undefined behavior sanitizer to not fail on signed integer
+  // overflow.  The disablement of the sanitizer only affects SumHook that is
+  // used for pushdown of sum aggregation functions. It doesn't affect the
+  // Presto's sum function that sets Overflow to false because overflow is
+  // handled explicitly in checkedPlus.
+#if defined(FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER)
+  FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER("signed-integer-overflow")
+#endif
+  static void add(TAggregate& result, TAggregate value) {
+    if constexpr (
+        (std::is_same_v<TAggregate, int64_t> && Overflow) ||
+        std::is_same_v<TAggregate, double> ||
+        std::is_same_v<TAggregate, float>) {
+      result += value;
+    } else {
+      result = checkedPlus<TAggregate>(result, value);
+    }
+  }
+
+ private:
+  template <typename T>
+  void addValueImpl(vector_size_t row, T value) {
     auto group = findGroup(row);
     clearNull(group);
-    updateSingleValue(
-        *reinterpret_cast<TAggregate*>(group + offset_),
-        TAggregate(*reinterpret_cast<const TValue*>(value)));
+    add(*reinterpret_cast<TAggregate*>(group + offset_), value);
   }
 };
 
-template <typename TValue, typename TAggregate, typename UpdateSingleValue>
+template <typename TAggregate, typename UpdateSingleValue>
 class SimpleCallableHook final : public AggregationHook {
  public:
   SimpleCallableHook(
@@ -160,23 +156,34 @@ class SimpleCallableHook final : public AggregationHook {
       : AggregationHook(offset, nullByte, nullMask, groups, numNulls),
         updateSingleValue_(updateSingleValue) {}
 
-  Kind kind() const override {
+  Kind kind() const final {
     return kGeneric;
   }
 
-  void addValue(vector_size_t row, const void* value) override {
+  void addValue(vector_size_t row, int64_t value) final {
+    addValueImpl(row, value);
+  }
+
+  void addValue(vector_size_t row, float value) final {
+    addValueImpl(row, value);
+  }
+
+  void addValue(vector_size_t row, double value) final {
+    addValueImpl(row, value);
+  }
+
+ private:
+  template <typename T>
+  void addValueImpl(vector_size_t row, T value) {
     auto group = findGroup(row);
     clearNull(group);
-    updateSingleValue_(
-        *reinterpret_cast<TAggregate*>(group + offset_),
-        TAggregate(*reinterpret_cast<const TValue*>(value)));
+    updateSingleValue_(*reinterpret_cast<TAggregate*>(group + offset_), value);
   }
 
- private:
   UpdateSingleValue updateSingleValue_;
 };
 
-template <typename T, bool isMin>
+template <typename TAggregate, bool isMin>
 class MinMaxHook final : public AggregationHook {
  public:
   MinMaxHook(
@@ -187,38 +194,56 @@ class MinMaxHook final : public AggregationHook {
       uint64_t* numNulls)
       : AggregationHook(offset, nullByte, nullMask, groups, numNulls) {}
 
-  Kind kind() const override {
-    if (isMin) {
-      if (std::is_same_v<T, int64_t>) {
-        return kBigintMin;
-      }
-      if (std::is_same_v<T, float>) {
-        return kFloatMin;
-      }
-      if (std::is_same_v<T, double>) {
-        return kDoubleMin;
-      }
-    } else {
-      if (std::is_same_v<T, int64_t>) {
-        return kBigintMax;
-      }
-      if (std::is_same_v<T, float>) {
-        return kFloatMax;
-      }
-      if (std::is_same_v<T, double>) {
-        return kDoubleMax;
-      }
+  Kind kind() const final {
+    if (std::is_same_v<TAggregate, int64_t>) {
+      return isMin ? kBigintMin : kBigintMax;
+    }
+    if (std::is_same_v<TAggregate, float> ||
+        std::is_same_v<TAggregate, double>) {
+      return isMin ? kFloatingPointMin : kFloatingPointMax;
     }
     return kGeneric;
   }
 
-  void addValue(vector_size_t row, const void* value) override {
+  void addValue(vector_size_t row, int64_t value) final {
+    if constexpr (std::is_integral_v<TAggregate>) {
+      addValueImpl(row, value);
+    } else {
+      VELOX_UNREACHABLE();
+    }
+  }
+
+  void addValue(vector_size_t row, float value) final {
+    if constexpr (std::is_floating_point_v<TAggregate>) {
+      addValueImpl(row, value);
+    } else {
+      VELOX_UNREACHABLE();
+    }
+  }
+
+  void addValue(vector_size_t row, double value) final {
+    if constexpr (std::is_floating_point_v<TAggregate>) {
+      addValueImpl(row, value);
+    } else {
+      VELOX_UNREACHABLE();
+    }
+  }
+
+ private:
+  template <typename T>
+  void addValueImpl(vector_size_t row, T value) {
     auto group = findGroup(row);
-    if (clearNull(group) ||
-        (*reinterpret_cast<T*>(group + offset_) >
-         *reinterpret_cast<const T*>(value)) == isMin) {
-      *reinterpret_cast<T*>(group + offset_) =
-          *reinterpret_cast<const T*>(value);
+    auto* currPtr = reinterpret_cast<TAggregate*>(group + offset_);
+    if constexpr (std::is_floating_point_v<TAggregate>) {
+      static const auto isGreater =
+          util::floating_point::NaNAwareGreaterThan<TAggregate>{};
+      if (clearNull(group) || isGreater(*currPtr, value) == isMin) {
+        *currPtr = value;
+      }
+    } else {
+      if (clearNull(group) || (*currPtr > value) == isMin) {
+        *currPtr = value;
+      }
     }
   }
 };
diff --git a/velox/exec/ArrowStream.cpp b/velox/exec/ArrowStream.cpp
index 863e43f8ba22f..e368844e41f6e 100644
--- a/velox/exec/ArrowStream.cpp
+++ b/velox/exec/ArrowStream.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/ArrowStream.h"
+#include "velox/vector/arrow/Bridge.h"
 
 namespace facebook::velox::exec {
 
diff --git a/velox/exec/AssignUniqueId.cpp b/velox/exec/AssignUniqueId.cpp
index 7ca29a12f57c9..711796985489a 100644
--- a/velox/exec/AssignUniqueId.cpp
+++ b/velox/exec/AssignUniqueId.cpp
@@ -33,7 +33,10 @@ AssignUniqueId::AssignUniqueId(
           planNode->id(),
           "AssignUniqueId"),
       rowIdPool_(std::move(rowIdPool)) {
-  VELOX_CHECK_LT(uniqueTaskId, kTaskUniqueIdLimit)
+  VELOX_USER_CHECK_LT(
+      uniqueTaskId,
+      kTaskUniqueIdLimit,
+      "Unique 24-bit ID specified for AssignUniqueId exceeds the limit");
   uniqueValueMask_ = ((int64_t)uniqueTaskId) << 40;
 
   const auto numColumns = planNode->outputType()->size();
@@ -52,7 +55,7 @@ AssignUniqueId::AssignUniqueId(
 void AssignUniqueId::addInput(RowVectorPtr input) {
   auto numInput = input->size();
   VELOX_CHECK_NE(
-      numInput, 0, "AssignUniqueId::addInput received empty set of rows")
+      numInput, 0, "AssignUniqueId::addInput received empty set of rows");
   input_ = std::move(input);
 }
 
@@ -88,13 +91,19 @@ void AssignUniqueId::generateIdColumn(vector_size_t size) {
       requestRowIds();
     }
 
-    auto batchSize =
-        std::min(maxRowIdCounterValue_ - rowIdCounter_ + 1, kRowIdsPerRequest);
-    auto end = (int32_t)std::min((int64_t)size, start + batchSize);
-    VELOX_CHECK_EQ((rowIdCounter_ + end - 1) & uniqueValueMask_, 0);
+    const auto numAvailableIds =
+        std::min(maxRowIdCounterValue_ - rowIdCounter_, kRowIdsPerRequest);
+    const auto end = (int32_t)std::min((int64_t)size, start + numAvailableIds);
+    VELOX_CHECK_EQ(
+        (rowIdCounter_ + (end - start)) & uniqueValueMask_,
+        0,
+        "Ran out of unique IDs at {}. Need {} more.",
+        rowIdCounter_,
+        (end - start));
     std::iota(
         rawResults + start, rawResults + end, uniqueValueMask_ | rowIdCounter_);
-    rowIdCounter_ += end;
+
+    rowIdCounter_ += (end - start);
     start = end;
   }
 }
diff --git a/velox/exec/CMakeLists.txt b/velox/exec/CMakeLists.txt
index 11d3437cf3f3c..48b63d0872df8 100644
--- a/velox/exec/CMakeLists.txt
+++ b/velox/exec/CMakeLists.txt
@@ -11,16 +11,18 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(
+velox_add_library(
   velox_exec
   AddressableNonNullValueList.cpp
   Aggregate.cpp
   AggregateCompanionAdapter.cpp
   AggregateCompanionSignatures.cpp
   AggregateFunctionRegistry.cpp
+  AggregateInfo.cpp
   AggregationMasks.cpp
   AggregateWindow.cpp
   ArrowStream.cpp
+  AssignUniqueId.cpp
   ContainerRowSerde.cpp
   DistinctAggregations.cpp
   Driver.cpp
@@ -29,6 +31,7 @@ add_library(
   ExchangeClient.cpp
   ExchangeQueue.cpp
   ExchangeSource.cpp
+  Expand.cpp
   FilterProject.cpp
   GroupId.cpp
   GroupingSet.cpp
@@ -52,21 +55,24 @@ add_library(
   Operator.cpp
   OperatorUtils.cpp
   OrderBy.cpp
+  OutputBuffer.cpp
+  OutputBufferManager.cpp
   PartitionedOutput.cpp
-  PartitionedOutputBuffer.cpp
-  PartitionedOutputBufferManager.cpp
+  PartitionFunction.cpp
+  PartitionStreamingWindowBuild.cpp
   PlanNodeStats.cpp
+  PrefixSort.cpp
   ProbeOperatorState.cpp
+  RowsStreamingWindowBuild.cpp
   RowContainer.cpp
   RowNumber.cpp
   SortBuffer.cpp
   SortedAggregations.cpp
   SortWindowBuild.cpp
   Spill.cpp
-  SpillOperatorGroup.cpp
+  SpillFile.cpp
   Spiller.cpp
   StreamingAggregation.cpp
-  StreamingWindowBuild.cpp
   Strings.cpp
   TableScan.cpp
   TableWriteMerge.cpp
@@ -80,24 +86,24 @@ add_library(
   Window.cpp
   WindowBuild.cpp
   WindowFunction.cpp
-  WindowPartition.cpp
-  AssignUniqueId.cpp
-  PartitionFunction.cpp)
+  WindowPartition.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_exec
   velox_file
   velox_core
   velox_vector
   velox_connector
+  velox_expression
   velox_time
-  velox_codegen
   velox_common_base
   velox_test_util
   velox_arrow_bridge
-  velox_common_compression)
+  velox_common_compression
+  velox_query_trace_exec)
 
 if(${VELOX_BUILD_TESTING})
+  add_subdirectory(fuzzer)
   add_subdirectory(tests)
 elseif(${VELOX_BUILD_TEST_UTILS})
   add_subdirectory(tests/utils)
@@ -106,3 +112,6 @@ endif()
 if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(benchmarks)
 endif()
+
+add_subdirectory(prefixsort)
+add_subdirectory(trace)
diff --git a/velox/exec/CallbackSink.h b/velox/exec/CallbackSink.h
index 8c7cd6bc82d99..fe981d8850339 100644
--- a/velox/exec/CallbackSink.h
+++ b/velox/exec/CallbackSink.h
@@ -27,11 +27,11 @@ class CallbackSink : public Operator {
       DriverCtx* driverCtx,
       std::function<BlockingReason(RowVectorPtr, ContinueFuture*)> callback)
       : Operator(driverCtx, nullptr, operatorId, "N/A", "CallbackSink"),
-        callback_{callback} {}
+        callback_{std::move(callback)} {}
 
   void addInput(RowVectorPtr input) override {
     loadColumns(input, *operatorCtx_->execCtx());
-    blockingReason_ = callback_(input, &future_);
+    blockingReason_ = callback_(std::move(input), &future_);
   }
 
   RowVectorPtr getOutput() override {
diff --git a/velox/exec/ContainerRowSerde.cpp b/velox/exec/ContainerRowSerde.cpp
index 2f9cc768fc4c1..bced017d13296 100644
--- a/velox/exec/ContainerRowSerde.cpp
+++ b/velox/exec/ContainerRowSerde.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "velox/exec/ContainerRowSerde.h"
-#include "velox/common/base/Exceptions.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/FlatVector.h"
 
@@ -27,13 +27,15 @@ namespace {
 void serializeSwitch(
     const BaseVector& source,
     vector_size_t index,
-    ByteStream& out);
+    ByteOutputStream& out,
+    const ContainerRowSerdeOptions& options);
 
 template <TypeKind Kind>
 void serializeOne(
     const BaseVector& vector,
     vector_size_t index,
-    ByteStream& stream) {
+    ByteOutputStream& stream,
+    const ContainerRowSerdeOptions& options) {
   using T = typename TypeTraits<Kind>::NativeType;
   stream.appendOne<T>(vector.asUnchecked<SimpleVector<T>>()->valueAt(index));
 }
@@ -42,27 +44,30 @@ template <>
 void serializeOne<TypeKind::VARCHAR>(
     const BaseVector& vector,
     vector_size_t index,
-    ByteStream& stream) {
+    ByteOutputStream& stream,
+    const ContainerRowSerdeOptions& /*options*/) {
   auto string = vector.asUnchecked<SimpleVector<StringView>>()->valueAt(index);
   stream.appendOne<int32_t>(string.size());
-  stream.appendStringPiece(folly::StringPiece(string.data(), string.size()));
+  stream.appendStringView(string);
 }
 
 template <>
 void serializeOne<TypeKind::VARBINARY>(
     const BaseVector& vector,
     vector_size_t index,
-    ByteStream& stream) {
+    ByteOutputStream& stream,
+    const ContainerRowSerdeOptions& /*options*/) {
   auto string = vector.asUnchecked<SimpleVector<StringView>>()->valueAt(index);
   stream.appendOne<int32_t>(string.size());
-  stream.appendStringPiece(folly::StringPiece(string.data(), string.size()));
+  stream.appendStringView(string);
 }
 
 template <>
 void serializeOne<TypeKind::ROW>(
     const BaseVector& vector,
     vector_size_t index,
-    ByteStream& out) {
+    ByteOutputStream& out,
+    const ContainerRowSerdeOptions& options) {
   auto row = vector.wrappedVector()->asUnchecked<RowVector>();
   auto wrappedIndex = vector.wrappedIndex(index);
   const auto& type = row->type()->as<TypeKind::ROW>();
@@ -81,7 +86,7 @@ void serializeOne<TypeKind::ROW>(
   out.append<uint64_t>(nulls);
   for (auto i = 0; i < children.size(); ++i) {
     if (!bits ::isBitSet(nulls.data(), i)) {
-      serializeSwitch(*children[i], wrappedIndex, out);
+      serializeSwitch(*children[i], wrappedIndex, out, options);
     }
   }
 }
@@ -90,7 +95,7 @@ void writeNulls(
     const BaseVector& values,
     vector_size_t offset,
     vector_size_t size,
-    ByteStream& out) {
+    ByteOutputStream& out) {
   for (auto i = 0; i < size; i += 64) {
     uint64_t flags = 0;
     auto end = i + 64 < size ? 64 : size - i;
@@ -106,7 +111,7 @@ void writeNulls(
 void writeNulls(
     const BaseVector& values,
     folly::Range<const vector_size_t*> indices,
-    ByteStream& out) {
+    ByteOutputStream& out) {
   auto size = indices.size();
   for (auto i = 0; i < size; i += 64) {
     uint64_t flags = 0;
@@ -124,12 +129,13 @@ void serializeArray(
     const BaseVector& elements,
     vector_size_t offset,
     vector_size_t size,
-    ByteStream& out) {
+    ByteOutputStream& out,
+    const ContainerRowSerdeOptions& options) {
   out.appendOne<int32_t>(size);
   writeNulls(elements, offset, size, out);
   for (auto i = 0; i < size; ++i) {
     if (!elements.isNullAt(i + offset)) {
-      serializeSwitch(elements, i + offset, out);
+      serializeSwitch(elements, i + offset, out, options);
     }
   }
 }
@@ -137,12 +143,13 @@ void serializeArray(
 void serializeArray(
     const BaseVector& elements,
     folly::Range<const vector_size_t*> indices,
-    ByteStream& out) {
+    ByteOutputStream& out,
+    const ContainerRowSerdeOptions& options) {
   out.appendOne<int32_t>(indices.size());
   writeNulls(elements, indices, out);
   for (auto i : indices) {
     if (!elements.isNullAt(i)) {
-      serializeSwitch(elements, i, out);
+      serializeSwitch(elements, i, out, options);
     }
   }
 }
@@ -151,43 +158,58 @@ template <>
 void serializeOne<TypeKind::ARRAY>(
     const BaseVector& source,
     vector_size_t index,
-    ByteStream& out) {
+    ByteOutputStream& out,
+    const ContainerRowSerdeOptions& options) {
   auto array = source.wrappedVector()->asUnchecked<ArrayVector>();
   auto wrappedIndex = source.wrappedIndex(index);
   serializeArray(
       *array->elements(),
       array->offsetAt(wrappedIndex),
       array->sizeAt(wrappedIndex),
-      out);
+      out,
+      options);
 }
 
 template <>
 void serializeOne<TypeKind::MAP>(
     const BaseVector& vector,
     vector_size_t index,
-    ByteStream& out) {
+    ByteOutputStream& out,
+    const ContainerRowSerdeOptions& options) {
   auto map = vector.wrappedVector()->asUnchecked<MapVector>();
   auto wrappedIndex = vector.wrappedIndex(index);
-  auto size = map->sizeAt(wrappedIndex);
-  auto offset = map->offsetAt(wrappedIndex);
-  auto indices = map->sortedKeyIndices(wrappedIndex);
-  serializeArray(*map->mapKeys(), indices, out);
-  serializeArray(*map->mapValues(), indices, out);
+  if (options.isKey) {
+    auto indices = map->sortedKeyIndices(wrappedIndex);
+    serializeArray(*map->mapKeys(), indices, out, options);
+    serializeArray(*map->mapValues(), indices, out, options);
+  } else {
+    auto size = map->sizeAt(wrappedIndex);
+    auto offset = map->offsetAt(wrappedIndex);
+    serializeArray(*map->mapKeys(), offset, size, out, options);
+    serializeArray(*map->mapValues(), offset, size, out, options);
+  }
 }
 
 void serializeSwitch(
     const BaseVector& source,
     vector_size_t index,
-    ByteStream& stream) {
+    ByteOutputStream& stream,
+    const ContainerRowSerdeOptions& options) {
   VELOX_DYNAMIC_TYPE_DISPATCH(
-      serializeOne, source.typeKind(), source, index, stream);
+      serializeOne, source.typeKind(), source, index, stream, options);
 }
 
 // Copy from serialization to vector.
-void deserializeSwitch(ByteStream& in, vector_size_t index, BaseVector& result);
+void deserializeSwitch(
+    ByteInputStream& in,
+    vector_size_t index,
+    BaseVector& result);
 
 template <TypeKind Kind>
-void deserializeOne(ByteStream& in, vector_size_t index, BaseVector& result) {
+void deserializeOne(
+    ByteInputStream& in,
+    vector_size_t index,
+    BaseVector& result) {
   using T = typename TypeTraits<Kind>::NativeType;
   // Check that the vector is writable. This is faster than dynamic_cast.
   VELOX_CHECK_EQ(result.encoding(), VectorEncoding::Simple::FLAT);
@@ -196,7 +218,7 @@ void deserializeOne(ByteStream& in, vector_size_t index, BaseVector& result) {
 }
 
 void deserializeString(
-    ByteStream& in,
+    ByteInputStream& in,
     vector_size_t index,
     BaseVector& result) {
   VELOX_CHECK_EQ(result.encoding(), VectorEncoding::Simple::FLAT);
@@ -214,7 +236,7 @@ void deserializeString(
 
 template <>
 void deserializeOne<TypeKind::VARCHAR>(
-    ByteStream& in,
+    ByteInputStream& in,
     vector_size_t index,
     BaseVector& result) {
   deserializeString(in, index, result);
@@ -222,13 +244,13 @@ void deserializeOne<TypeKind::VARCHAR>(
 
 template <>
 void deserializeOne<TypeKind::VARBINARY>(
-    ByteStream& in,
+    ByteInputStream& in,
     vector_size_t index,
     BaseVector& result) {
   deserializeString(in, index, result);
 }
 
-std::vector<uint64_t> readNulls(ByteStream& in, int32_t size) {
+std::vector<uint64_t> readNulls(ByteInputStream& in, int32_t size) {
   auto n = bits::nwords(size);
   std::vector<uint64_t> nulls(n);
   for (auto i = 0; i < n; ++i) {
@@ -239,7 +261,7 @@ std::vector<uint64_t> readNulls(ByteStream& in, int32_t size) {
 
 template <>
 void deserializeOne<TypeKind::ROW>(
-    ByteStream& in,
+    ByteInputStream& in,
     vector_size_t index,
     BaseVector& result) {
   const auto& type = result.type()->as<TypeKind::ROW>();
@@ -265,8 +287,10 @@ void deserializeOne<TypeKind::ROW>(
 // Reads the size, null flags and deserializes from 'in', appending to
 // the end of 'elements'. Returns the number of added elements and
 // sets 'offset' to the index of the first added element.
-vector_size_t
-deserializeArray(ByteStream& in, BaseVector& elements, vector_size_t& offset) {
+vector_size_t deserializeArray(
+    ByteInputStream& in,
+    BaseVector& elements,
+    vector_size_t& offset) {
   auto size = in.read<int32_t>();
   auto nulls = readNulls(in, size);
   offset = elements.size();
@@ -283,7 +307,7 @@ deserializeArray(ByteStream& in, BaseVector& elements, vector_size_t& offset) {
 
 template <>
 void deserializeOne<TypeKind::ARRAY>(
-    ByteStream& in,
+    ByteInputStream& in,
     vector_size_t index,
     BaseVector& result) {
   VELOX_CHECK_EQ(result.encoding(), VectorEncoding::Simple::ARRAY);
@@ -299,7 +323,7 @@ void deserializeOne<TypeKind::ARRAY>(
 
 template <>
 void deserializeOne<TypeKind::MAP>(
-    ByteStream& in,
+    ByteInputStream& in,
     vector_size_t index,
     BaseVector& result) {
   VELOX_CHECK_EQ(result.encoding(), VectorEncoding::Simple::MAP);
@@ -318,7 +342,7 @@ void deserializeOne<TypeKind::MAP>(
 }
 
 void deserializeSwitch(
-    ByteStream& in,
+    ByteInputStream& in,
     vector_size_t index,
     BaseVector& result) {
   VELOX_DYNAMIC_TYPE_DISPATCH(
@@ -327,26 +351,26 @@ void deserializeSwitch(
 
 // Comparison of serialization and vector.
 std::optional<int32_t> compareSwitch(
-    ByteStream& stream,
+    ByteInputStream& stream,
     const BaseVector& vector,
     vector_size_t index,
     CompareFlags flags);
 
 template <TypeKind Kind>
 std::optional<int32_t> compare(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& right,
     vector_size_t index,
     CompareFlags flags) {
   using T = typename TypeTraits<Kind>::NativeType;
   auto rightValue = right.asUnchecked<SimpleVector<T>>()->valueAt(index);
   auto leftValue = left.read<T>();
-  auto result = leftValue < rightValue ? -1 : leftValue == rightValue ? 0 : 1;
+  auto result = SimpleVector<T>::comparePrimitiveAsc(leftValue, rightValue);
   return flags.ascending ? result : result * -1;
 }
 
 int compareStringAsc(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& right,
     vector_size_t index,
     bool equalsOnly) {
@@ -373,7 +397,7 @@ int compareStringAsc(
 
 template <>
 std::optional<int32_t> compare<TypeKind::VARCHAR>(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& right,
     vector_size_t index,
     CompareFlags flags) {
@@ -383,7 +407,7 @@ std::optional<int32_t> compare<TypeKind::VARCHAR>(
 
 template <>
 std::optional<int32_t> compare<TypeKind::VARBINARY>(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& right,
     vector_size_t index,
     CompareFlags flags) {
@@ -393,7 +417,7 @@ std::optional<int32_t> compare<TypeKind::VARBINARY>(
 
 template <>
 std::optional<int32_t> compare<TypeKind::ROW>(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& right,
     vector_size_t index,
     CompareFlags flags) {
@@ -427,7 +451,7 @@ std::optional<int32_t> compare<TypeKind::ROW>(
 }
 
 std::optional<int32_t> compareArrays(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& elements,
     vector_size_t offset,
     vector_size_t rightSize,
@@ -462,7 +486,7 @@ std::optional<int32_t> compareArrays(
 }
 
 std::optional<int32_t> compareArrayIndices(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& elements,
     folly::Range<const vector_size_t*> rightIndices,
     CompareFlags flags) {
@@ -498,7 +522,7 @@ std::optional<int32_t> compareArrayIndices(
 
 template <>
 std::optional<int32_t> compare<TypeKind::ARRAY>(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& right,
     vector_size_t index,
     CompareFlags flags) {
@@ -515,7 +539,7 @@ std::optional<int32_t> compare<TypeKind::ARRAY>(
 
 template <>
 std::optional<int32_t> compare<TypeKind::MAP>(
-    ByteStream& left,
+    ByteInputStream& left,
     const BaseVector& right,
     vector_size_t index,
     CompareFlags flags) {
@@ -533,7 +557,7 @@ std::optional<int32_t> compare<TypeKind::MAP>(
 }
 
 std::optional<int32_t> compareSwitch(
-    ByteStream& stream,
+    ByteInputStream& stream,
     const BaseVector& vector,
     vector_size_t index,
     CompareFlags flags) {
@@ -544,7 +568,7 @@ std::optional<int32_t> compareSwitch(
 // Returns a view over a serialized string with the string as a
 // contiguous array of bytes. This may use 'storage' for a temporary
 // copy.
-StringView readStringView(ByteStream& stream, std::string& storage) {
+StringView readStringView(ByteInputStream& stream, std::string& storage) {
   int32_t size = stream.read<int32_t>();
   auto view = stream.nextView(size);
   if (view.size() == size) {
@@ -558,29 +582,29 @@ StringView readStringView(ByteStream& stream, std::string& storage) {
 }
 
 // Comparison of two serializations.
-int32_t compareSwitch(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compareSwitch(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* type,
     CompareFlags flags);
 
 template <TypeKind Kind>
-int32_t compare(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compare(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* /*type*/,
     CompareFlags flags) {
   using T = typename TypeTraits<Kind>::NativeType;
   T leftValue = left.read<T>();
   T rightValue = right.read<T>();
-  auto result = leftValue == rightValue ? 0 : leftValue < rightValue ? -1 : 1;
+  auto result = SimpleVector<T>::comparePrimitiveAsc(leftValue, rightValue);
   return flags.ascending ? result : result * -1;
 }
 
 template <>
-int32_t compare<TypeKind::VARCHAR>(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compare<TypeKind::VARCHAR>(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* /*type*/,
     CompareFlags flags) {
   std::string leftStorage;
@@ -592,9 +616,9 @@ int32_t compare<TypeKind::VARCHAR>(
 }
 
 template <>
-int32_t compare<TypeKind::VARBINARY>(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compare<TypeKind::VARBINARY>(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* /*type*/,
     CompareFlags flags) {
   std::string leftStorage;
@@ -605,9 +629,9 @@ int32_t compare<TypeKind::VARBINARY>(
                          : rightValue.compare(leftValue);
 }
 
-int32_t compareArrays(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compareArrays(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* elementType,
     CompareFlags flags) {
   auto leftSize = left.read<int32_t>();
@@ -621,27 +645,27 @@ int32_t compareArrays(
   for (auto i = 0; i < compareSize; ++i) {
     bool leftNull = bits::isBitSet(leftNulls.data(), i);
     bool rightNull = bits::isBitSet(rightNulls.data(), i);
-    if (leftNull && rightNull) {
-      continue;
-    }
-    if (leftNull) {
-      return flags.nullsFirst ? -1 : 1;
-    }
-    if (rightNull) {
-      return flags.nullsFirst ? 1 : -1;
+    if (leftNull || rightNull) {
+      auto result = BaseVector::compareNulls(leftNull, rightNull, flags);
+      if (result.has_value() && result.value() == 0) {
+        continue;
+      }
+      return result;
     }
+
     auto result = compareSwitch(left, right, elementType, flags);
-    if (result) {
-      return result;
+    if (result.has_value() && result.value() == 0) {
+      continue;
     }
+    return result;
   }
   return flags.ascending ? (leftSize - rightSize) : (rightSize - leftSize);
 }
 
 template <>
-int32_t compare<TypeKind::ROW>(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compare<TypeKind::ROW>(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* type,
     CompareFlags flags) {
   const auto& rowType = type->as<TypeKind::ROW>();
@@ -651,48 +675,48 @@ int32_t compare<TypeKind::ROW>(
   for (auto i = 0; i < size; ++i) {
     bool leftNull = bits::isBitSet(leftNulls.data(), i);
     bool rightNull = bits::isBitSet(rightNulls.data(), i);
-    if (leftNull && rightNull) {
-      continue;
-    }
-    if (leftNull) {
-      return flags.nullsFirst ? -1 : 1;
-    }
-    if (rightNull) {
-      return flags.nullsFirst ? 1 : -1;
+    if (leftNull || rightNull) {
+      auto result = BaseVector::compareNulls(leftNull, rightNull, flags);
+      if (result.has_value() && result.value() == 0) {
+        continue;
+      }
+      return result;
     }
+
     auto result = compareSwitch(left, right, rowType.childAt(i).get(), flags);
-    if (result) {
-      return result;
+    if (result.has_value() && result.value() == 0) {
+      continue;
     }
+    return result;
   }
   return 0;
 }
 
 template <>
-int32_t compare<TypeKind::ARRAY>(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compare<TypeKind::ARRAY>(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* type,
     CompareFlags flags) {
   return compareArrays(left, right, type->childAt(0).get(), flags);
 }
 
 template <>
-int32_t compare<TypeKind::MAP>(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compare<TypeKind::MAP>(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* type,
     CompareFlags flags) {
   auto result = compareArrays(left, right, type->childAt(0).get(), flags);
-  if (result) {
-    return result;
+  if (result.has_value() && result.value() == 0) {
+    return compareArrays(left, right, type->childAt(1).get(), flags);
   }
-  return compareArrays(left, right, type->childAt(1).get(), flags);
+  return result;
 }
 
-int32_t compareSwitch(
-    ByteStream& left,
-    ByteStream& right,
+std::optional<int32_t> compareSwitch(
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* type,
     CompareFlags flags) {
   return VELOX_DYNAMIC_TYPE_DISPATCH(
@@ -700,29 +724,36 @@ int32_t compareSwitch(
 }
 
 // Hash functions.
-uint64_t hashSwitch(ByteStream& stream, const Type* type);
+uint64_t hashSwitch(ByteInputStream& stream, const Type* type);
 
 template <TypeKind Kind>
-uint64_t hashOne(ByteStream& stream, const Type* /*type*/) {
+uint64_t hashOne(ByteInputStream& stream, const Type* /*type*/) {
   using T = typename TypeTraits<Kind>::NativeType;
-  return folly::hasher<T>()(stream.read<T>());
+  if constexpr (std::is_floating_point_v<T>) {
+    return util::floating_point::NaNAwareHash<T>()(stream.read<T>());
+  } else {
+    return folly::hasher<T>()(stream.read<T>());
+  }
 }
 
 template <>
-uint64_t hashOne<TypeKind::VARCHAR>(ByteStream& stream, const Type* /*type*/) {
+uint64_t hashOne<TypeKind::VARCHAR>(
+    ByteInputStream& stream,
+    const Type* /*type*/) {
   std::string storage;
   return folly::hasher<StringView>()(readStringView(stream, storage));
 }
 
 template <>
 uint64_t hashOne<TypeKind::VARBINARY>(
-    ByteStream& stream,
+    ByteInputStream& stream,
     const Type* /*type*/) {
   std::string storage;
   return folly::hasher<StringView>()(readStringView(stream, storage));
 }
 
-uint64_t hashArray(ByteStream& in, uint64_t hash, const Type* elementType) {
+uint64_t
+hashArray(ByteInputStream& in, uint64_t hash, const Type* elementType) {
   auto size = in.read<int32_t>();
   auto nulls = readNulls(in, size);
   for (auto i = 0; i < size; ++i) {
@@ -738,7 +769,7 @@ uint64_t hashArray(ByteStream& in, uint64_t hash, const Type* elementType) {
 }
 
 template <>
-uint64_t hashOne<TypeKind::ROW>(ByteStream& in, const Type* type) {
+uint64_t hashOne<TypeKind::ROW>(ByteInputStream& in, const Type* type) {
   auto size = type->size();
   auto nulls = readNulls(in, size);
   uint64_t hash = BaseVector::kNullHash;
@@ -755,19 +786,19 @@ uint64_t hashOne<TypeKind::ROW>(ByteStream& in, const Type* type) {
 }
 
 template <>
-uint64_t hashOne<TypeKind::ARRAY>(ByteStream& in, const Type* type) {
+uint64_t hashOne<TypeKind::ARRAY>(ByteInputStream& in, const Type* type) {
   return hashArray(in, BaseVector::kNullHash, type->childAt(0).get());
 }
 
 template <>
-uint64_t hashOne<TypeKind::MAP>(ByteStream& in, const Type* type) {
+uint64_t hashOne<TypeKind::MAP>(ByteInputStream& in, const Type* type) {
   return hashArray(
       in,
       hashArray(in, BaseVector::kNullHash, type->childAt(0).get()),
       type->childAt(1).get());
 }
 
-uint64_t hashSwitch(ByteStream& in, const Type* type) {
+uint64_t hashSwitch(ByteInputStream& in, const Type* type) {
   return VELOX_DYNAMIC_TYPE_DISPATCH(hashOne, type->kind(), in, type);
 }
 
@@ -777,15 +808,16 @@ uint64_t hashSwitch(ByteStream& in, const Type* type) {
 void ContainerRowSerde::serialize(
     const BaseVector& source,
     vector_size_t index,
-    ByteStream& out) {
+    ByteOutputStream& out,
+    const ContainerRowSerdeOptions& options) {
   VELOX_DCHECK(
       !source.isNullAt(index), "Null top-level values are not supported");
-  serializeSwitch(source, index, out);
+  serializeSwitch(source, index, out, options);
 }
 
 // static
 void ContainerRowSerde::deserialize(
-    ByteStream& in,
+    ByteInputStream& in,
     vector_size_t index,
     BaseVector* result) {
   deserializeSwitch(in, index, *result);
@@ -793,29 +825,29 @@ void ContainerRowSerde::deserialize(
 
 // static
 int32_t ContainerRowSerde::compare(
-    ByteStream& left,
+    ByteInputStream& left,
     const DecodedVector& right,
     vector_size_t index,
     CompareFlags flags) {
   VELOX_DCHECK(
       !right.isNullAt(index), "Null top-level values are not supported");
-  VELOX_DCHECK(!flags.mayStopAtNull(), "not supported null handling mode");
+  VELOX_DCHECK(flags.nullAsValue(), "not supported null handling mode");
   return compareSwitch(left, *right.base(), right.index(index), flags).value();
 }
 
 // static
 int32_t ContainerRowSerde::compare(
-    ByteStream& left,
-    ByteStream& right,
+    ByteInputStream& left,
+    ByteInputStream& right,
     const Type* type,
     CompareFlags flags) {
-  VELOX_DCHECK(!flags.mayStopAtNull(), "not supported null handling mode");
+  VELOX_DCHECK(flags.nullAsValue(), "not supported null handling mode");
 
-  return compareSwitch(left, right, type, flags);
+  return compareSwitch(left, right, type, flags).value();
 }
 
 std::optional<int32_t> ContainerRowSerde::compareWithNulls(
-    ByteStream& left,
+    ByteInputStream& left,
     const DecodedVector& right,
     vector_size_t index,
     CompareFlags flags) {
@@ -824,8 +856,16 @@ std::optional<int32_t> ContainerRowSerde::compareWithNulls(
   return compareSwitch(left, *right.base(), right.index(index), flags);
 }
 
+std::optional<int32_t> ContainerRowSerde::compareWithNulls(
+    ByteInputStream& left,
+    ByteInputStream& right,
+    const Type* type,
+    CompareFlags flags) {
+  return compareSwitch(left, right, type, flags);
+}
+
 // static
-uint64_t ContainerRowSerde::hash(ByteStream& in, const Type* type) {
+uint64_t ContainerRowSerde::hash(ByteInputStream& in, const Type* type) {
   return hashSwitch(in, type);
 }
 
diff --git a/velox/exec/ContainerRowSerde.h b/velox/exec/ContainerRowSerde.h
index 3e6796a32995c..c3b139b426d43 100644
--- a/velox/exec/ContainerRowSerde.h
+++ b/velox/exec/ContainerRowSerde.h
@@ -21,49 +21,72 @@
 
 namespace facebook::velox::exec {
 
+struct ContainerRowSerdeOptions {
+  /// Used for ex., sorting maps by map keys, when occurring as key.
+  bool isKey = true;
+};
+
 /// Row-wise serialization for use in hash tables and order by.
 class ContainerRowSerde {
  public:
   /// Serializes value from source[index] into 'out'. The value must not be
   /// null.
-  static void
-  serialize(const BaseVector& source, vector_size_t index, ByteStream& out);
+  static void serialize(
+      const BaseVector& source,
+      vector_size_t index,
+      ByteOutputStream& out,
+      const ContainerRowSerdeOptions& options);
 
   static void
-  deserialize(ByteStream& in, vector_size_t index, BaseVector* result);
+  deserialize(ByteInputStream& in, vector_size_t index, BaseVector* result);
 
   /// Returns < 0 if 'left' is less than 'right' at 'index', 0 if
-  /// equal and > 0 otherwise. flags.nullHandlingMode can be only NoStop and
-  /// support null-safe equal.
-  /// Top level rows in right are not allowed to be null.
+  /// equal and > 0 otherwise. flags.nullHandlingMode can be only NullAsValue
+  /// and support null-safe equal. Top level rows in right are not allowed to be
+  /// null. Note that the assumption for Map is the serialized map entries are
+  /// sorted in the order of key to be comparable.
   static int32_t compare(
-      ByteStream& left,
+      ByteInputStream& left,
       const DecodedVector& right,
       vector_size_t index,
       CompareFlags flags);
 
   /// Returns < 0 if 'left' is less than 'right' at 'index', 0 if
-  /// equal and > 0 otherwise. flags.nullHandlingMode can be only NoStop and
-  /// support null-safe equal.
+  /// equal and > 0 otherwise. flags.nullHandlingMode can be only NullAsValue
+  /// and support null-safe equal. Note that the assumption for Map is the
+  /// serialized map entries are sorted in the order of key to be comparable.
   static int32_t compare(
-      ByteStream& left,
-      ByteStream& right,
+      ByteInputStream& left,
+      ByteInputStream& right,
       const Type* type,
       CompareFlags flags);
 
   /// Returns < 0 if 'left' is less than 'right' at 'index', 0 if
   /// equal and > 0 otherwise. If flags.nullHandlingMode is StopAtNull,
   /// returns std::nullopt if either 'left' or 'right' value is null or contains
-  /// a null. If flags.nullHandlingMode is NoStop then NULL is considered equal
-  /// to NULL.
-  /// Top level rows in right are not allowed to be null.
+  /// a null. If flags.nullHandlingMode is NullAsValue then NULL is considered
+  /// equal to NULL. Top level rows in right are not allowed to be null. Note
+  /// that the assumption for Map is the serialized map entries are
+  /// sorted in the order of key to be comparable.
   static std::optional<int32_t> compareWithNulls(
-      ByteStream& left,
+      ByteInputStream& left,
       const DecodedVector& right,
       vector_size_t index,
       CompareFlags flags);
 
-  static uint64_t hash(ByteStream& data, const Type* type);
+  /// Returns < 0 if 'left' is less than 'right' at 'index', 0 if
+  /// equal and > 0 otherwise. If flags.nullHandlingMode is StopAtNull,
+  /// returns std::nullopt if either 'left' or 'right' value is null or contains
+  /// a null. If flags.nullHandlingMode is NullAsValue then NULL is considered
+  /// equal to NULL. Note that the assumption for Map is the serialized map
+  /// entries are sorted in the order of key to be comparable.
+  static std::optional<int32_t> compareWithNulls(
+      ByteInputStream& left,
+      ByteInputStream& right,
+      const Type* type,
+      CompareFlags flags);
+
+  static uint64_t hash(ByteInputStream& data, const Type* type);
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/DistinctAggregations.cpp b/velox/exec/DistinctAggregations.cpp
index ab52e3de3746f..5f5c4405b3e17 100644
--- a/velox/exec/DistinctAggregations.cpp
+++ b/velox/exec/DistinctAggregations.cpp
@@ -43,6 +43,10 @@ class TypedDistinctAggregations : public DistinctAggregations {
         sizeof(AccumulatorType),
         false, // usesExternalMemory
         1, // alignment
+        nullptr,
+        [](folly::Range<char**> /*groups*/, VectorPtr& /*result*/) {
+          VELOX_UNREACHABLE();
+        },
         [this](folly::Range<char**> groups) {
           for (auto* group : groups) {
             auto* accumulator =
@@ -52,20 +56,6 @@ class TypedDistinctAggregations : public DistinctAggregations {
         }};
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    for (auto i : indices) {
-      groups[i][nullByte_] |= nullMask_;
-      new (groups[i] + offset_) AccumulatorType(inputType_, allocator_);
-    }
-
-    for (auto i = 0; i < aggregates_.size(); ++i) {
-      const auto& aggregate = *aggregates_[i];
-      aggregate.function->initializeNewGroups(groups, indices);
-    }
-  }
-
   void addInput(
       char** groups,
       const RowVectorPtr& input,
@@ -118,11 +108,13 @@ class TypedDistinctAggregations : public DistinctAggregations {
           accumulator->extractValues(*(data->template as<FlatVector<T>>()), 0);
         }
 
-        rows.resize(data->size());
-        std::vector<VectorPtr> inputForAggregation_ =
-            makeInputForAggregation(data);
-        aggregate.function->addSingleGroupRawInput(
-            group, rows, inputForAggregation_, false);
+        if (data->size() > 0) {
+          rows.resize(data->size());
+          std::vector<VectorPtr> inputForAggregation =
+              makeInputForAggregation(data);
+          aggregate.function->addSingleGroupRawInput(
+              group, rows, inputForAggregation, false);
+        }
       }
 
       aggregate.function->extractValues(
@@ -131,6 +123,29 @@ class TypedDistinctAggregations : public DistinctAggregations {
       // Release memory back to HashStringAllocator to allow next
       // aggregate to re-use it.
       aggregate.function->destroy(groups);
+
+      // Overwrite empty groups over the destructed groups to keep the container
+      // in a well formed state.
+      raw_vector<int32_t> temp;
+      aggregate.function->initializeNewGroups(
+          groups.data(),
+          folly::Range<const int32_t*>(
+              iota(groups.size(), temp), groups.size()));
+    }
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto i : indices) {
+      groups[i][nullByte_] |= nullMask_;
+      new (groups[i] + offset_) AccumulatorType(inputType_, allocator_);
+    }
+
+    for (auto i = 0; i < aggregates_.size(); ++i) {
+      const auto& aggregate = *aggregates_[i];
+      aggregate.function->initializeNewGroups(groups, indices);
     }
   }
 
@@ -224,6 +239,9 @@ std::unique_ptr<DistinctAggregations> DistinctAggregations::create(
     case TypeKind::BIGINT:
       return std::make_unique<TypedDistinctAggregations<int64_t>>(
           aggregates, inputType, pool);
+    case TypeKind::HUGEINT:
+      return std::make_unique<TypedDistinctAggregations<int128_t>>(
+          aggregates, inputType, pool);
     case TypeKind::REAL:
       return std::make_unique<TypedDistinctAggregations<float>>(
           aggregates, inputType, pool);
@@ -233,6 +251,8 @@ std::unique_ptr<DistinctAggregations> DistinctAggregations::create(
     case TypeKind::TIMESTAMP:
       return std::make_unique<TypedDistinctAggregations<Timestamp>>(
           aggregates, inputType, pool);
+    case TypeKind::VARBINARY:
+      [[fallthrough]];
     case TypeKind::VARCHAR:
       return std::make_unique<TypedDistinctAggregations<StringView>>(
           aggregates, inputType, pool);
diff --git a/velox/exec/DistinctAggregations.h b/velox/exec/DistinctAggregations.h
index f36b961c67d42..ffb6d1b1a4c32 100644
--- a/velox/exec/DistinctAggregations.h
+++ b/velox/exec/DistinctAggregations.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <cstdint>
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/AggregateInfo.h"
 #include "velox/exec/RowContainer.h"
@@ -29,7 +30,6 @@ class DistinctAggregations {
   /// @param aggregates Non-empty list of
   /// aggregates that require inputs to be de-duplicated. All
   /// aggregates should have the same inputs.
-  /// Aggregates with multiple inputs are not supported.
   /// @param inputType Input row type for the aggregation operator.
   /// @param pool Memory pool.
   static std::unique_ptr<DistinctAggregations> create(
@@ -50,16 +50,31 @@ class DistinctAggregations {
       int32_t offset,
       int32_t nullByte,
       uint8_t nullMask,
+      int32_t initializedByte,
+      uint8_t initializedMask,
       int32_t rowSizeOffset) {
     offset_ = offset;
     nullByte_ = nullByte;
     nullMask_ = nullMask;
+    initializedByte_ = initializedByte;
+    initializedMask_ = initializedMask;
     rowSizeOffset_ = rowSizeOffset;
   }
 
-  virtual void initializeNewGroups(
+  // Initializes null flags and accumulators for newly encountered groups.  This
+  // function should be called only once for each group.
+  //
+  // @param groups Pointers to the start of the new group rows.
+  // @param indices Indices into 'groups' of the new entries.
+  void initializeNewGroups(
       char** groups,
-      folly::Range<const vector_size_t*> indices) = 0;
+      folly::Range<const vector_size_t*> indices) {
+    initializeNewGroupsInternal(groups, indices);
+
+    for (auto index : indices) {
+      groups[index][initializedByte_] |= initializedMask_;
+    }
+  }
 
   virtual void addInput(
       char** groups,
@@ -77,10 +92,21 @@ class DistinctAggregations {
       const RowVectorPtr& result) = 0;
 
  protected:
+  // Initializes null flags and accumulators for newly encountered groups.  This
+  // function should be called only once for each group.
+  //
+  // @param groups Pointers to the start of the new group rows.
+  // @param indices Indices into 'groups' of the new entries.
+  virtual void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) = 0;
+
   HashStringAllocator* allocator_;
   int32_t offset_;
   int32_t nullByte_;
   uint8_t nullMask_;
+  int32_t initializedByte_;
+  uint8_t initializedMask_;
   int32_t rowSizeOffset_;
 };
 
diff --git a/velox/exec/Driver.cpp b/velox/exec/Driver.cpp
index fca8535ec67e1..307ba0d323708 100644
--- a/velox/exec/Driver.cpp
+++ b/velox/exec/Driver.cpp
@@ -14,16 +14,9 @@
  * limitations under the License.
  */
 
-#include "Driver.h"
-#include <folly/ScopeGuard.h>
-#include <folly/executors/QueuedImmediateExecutor.h>
-#include <folly/executors/thread_factory/InitThreadFactory.h>
-#include <gflags/gflags.h>
+#include "velox/exec/Driver.h"
+
 #include "velox/common/process/TraceContext.h"
-#include "velox/common/testutil/TestValue.h"
-#include "velox/common/time/Timer.h"
-#include "velox/exec/Operator.h"
-#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 
 using facebook::velox::common::testutil::TestValue;
@@ -31,37 +24,6 @@ using facebook::velox::common::testutil::TestValue;
 namespace facebook::velox::exec {
 namespace {
 
-// Ensures that the thread is removed from its Task's thread count on exit.
-class CancelGuard {
- public:
-  CancelGuard(
-      Task* task,
-      ThreadState* state,
-      std::function<void(StopReason)> onTerminate)
-      : task_(task), state_(state), onTerminate_(std::move(onTerminate)) {}
-
-  void notThrown() {
-    isThrow_ = false;
-  }
-
-  ~CancelGuard() {
-    bool onTerminateCalled = false;
-    if (isThrow_) {
-      // Runtime error. Driver is on thread, hence safe.
-      state_->isTerminated = true;
-      onTerminate_(StopReason::kNone);
-      onTerminateCalled = true;
-    }
-    task_->leave(*state_, onTerminateCalled ? nullptr : onTerminate_);
-  }
-
- private:
-  Task* task_;
-  ThreadState* state_;
-  std::function<void(StopReason reason)> onTerminate_;
-  bool isThrow_ = true;
-};
-
 // Checks if output channel is produced using identity projection and returns
 // input channel if so.
 std::optional<column_index_t> getIdentityProjection(
@@ -75,18 +37,6 @@ std::optional<column_index_t> getIdentityProjection(
   return std::nullopt;
 }
 
-void validateOperatorResult(RowVectorPtr& result, Operator& op) {
-  try {
-    result->validate({});
-  } catch (const std::exception& e) {
-    VELOX_FAIL(
-        "Output validation failed for [operator: {}, plan node ID: {}]: {}",
-        op.operatorType(),
-        op.planNodeId(),
-        e.what());
-  }
-}
-
 thread_local DriverThreadContext* driverThreadCtx{nullptr};
 
 void recordSilentThrows(Operator& op) {
@@ -97,6 +47,35 @@ void recordSilentThrows(Operator& op) {
   }
 }
 
+// Used to generate context for exceptions that are thrown while executing an
+// operator. Eg output: 'Operator: FilterProject(1) PlanNodeId: 1 TaskId:
+// test_cursor 1 PipelineId: 0 DriverId: 0 OperatorAddress: 0x61a000003c80'
+std::string addContextOnException(
+    VeloxException::Type exceptionType,
+    void* arg) {
+  if (exceptionType != VeloxException::Type::kSystem) {
+    return "";
+  }
+  auto* op = static_cast<Operator*>(arg);
+  return fmt::format("Operator: {}", op->toString());
+}
+
+std::exception_ptr makeException(
+    const std::string& message,
+    const char* file,
+    int line,
+    const char* function) {
+  return std::make_exception_ptr(VeloxRuntimeError(
+      file,
+      line,
+      function,
+      "",
+      message,
+      error_source::kErrorSourceRuntime,
+      error_code::kInvalidState,
+      false));
+}
+
 } // namespace
 
 DriverCtx::DriverCtx(
@@ -109,7 +88,7 @@ DriverCtx::DriverCtx(
       pipelineId(_pipelineId),
       splitGroupId(_splitGroupId),
       partitionId(_partitionId),
-      task(_task),
+      task(std::move(_task)),
       threadDebugInfo({task->queryCtx()->queryId(), task->taskId(), nullptr}) {}
 
 const core::QueryConfig& DriverCtx::queryConfig() const {
@@ -119,7 +98,8 @@ const core::QueryConfig& DriverCtx::queryConfig() const {
 velox::memory::MemoryPool* DriverCtx::addOperatorPool(
     const core::PlanNodeId& planNodeId,
     const std::string& operatorType) {
-  return task->addOperatorPool(planNodeId, pipelineId, driverId, operatorType);
+  return task->addOperatorPool(
+      planNodeId, splitGroupId, pipelineId, driverId, operatorType);
 }
 
 std::optional<common::SpillConfig> DriverCtx::makeSpillConfig(
@@ -131,22 +111,33 @@ std::optional<common::SpillConfig> DriverCtx::makeSpillConfig(
   if (task->spillDirectory().empty()) {
     return std::nullopt;
   }
+  common::GetSpillDirectoryPathCB getSpillDirPathCb =
+      [this]() -> std::string_view {
+    return task->getOrCreateSpillDirectory();
+  };
+  const auto& spillFilePrefix =
+      fmt::format("{}_{}_{}", pipelineId, driverId, operatorId);
+  common::UpdateAndCheckSpillLimitCB updateAndCheckSpillLimitCb =
+      [this](uint64_t bytes) {
+        task->queryCtx()->updateSpilledBytesAndCheckLimit(bytes);
+      };
   return common::SpillConfig(
-      makeOperatorSpillPath(
-          task->spillDirectory(), pipelineId, driverId, operatorId),
+      std::move(getSpillDirPathCb),
+      std::move(updateAndCheckSpillLimitCb),
+      spillFilePrefix,
       queryConfig.maxSpillFileSize(),
       queryConfig.spillWriteBufferSize(),
-      queryConfig.minSpillRunSize(),
+      queryConfig.spillReadBufferSize(),
       task->queryCtx()->spillExecutor(),
       queryConfig.minSpillableReservationPct(),
       queryConfig.spillableReservationGrowthPct(),
       queryConfig.spillStartPartitionBit(),
-      queryConfig.joinSpillPartitionBits(),
-      queryConfig.aggregationSpillPartitionBits(),
-      queryConfig.aggregationSpillAll(),
+      queryConfig.spillNumPartitionBits(),
       queryConfig.maxSpillLevel(),
-      queryConfig.testingSpillPct(),
-      queryConfig.spillCompressionKind());
+      queryConfig.maxSpillRunRows(),
+      queryConfig.writerFlushThresholdBytes(),
+      queryConfig.spillCompressionKind(),
+      queryConfig.spillFileCreateConfig());
 }
 
 std::atomic_uint64_t BlockingState::numBlockedDrivers_{0};
@@ -179,12 +170,12 @@ void BlockingState::setResume(std::shared_ptr<BlockingState> state) {
         auto& driver = state->driver_;
         auto& task = driver->task();
 
-        std::lock_guard<std::mutex> l(task->mutex());
+        std::lock_guard<std::timed_mutex> l(task->mutex());
         if (!driver->state().isTerminated) {
           state->operator_->recordBlockingTime(
               state->sinceMicros_, state->reason_);
         }
-        VELOX_CHECK(!driver->state().isSuspended);
+        VELOX_CHECK(!driver->state().suspended());
         VELOX_CHECK(driver->state().hasBlockingFuture);
         driver->state().hasBlockingFuture = false;
         if (task->pauseRequested()) {
@@ -199,8 +190,8 @@ void BlockingState::setResume(std::shared_ptr<BlockingState> state) {
               VELOX_FAIL(
                   "A ContinueFuture for task {} was realized with error: {}",
                   state->driver_->task()->taskId(),
-                  e.what())
-            } catch (const VeloxException& eNew) {
+                  e.what());
+            } catch (const VeloxException&) {
               state->driver_->task()->setError(std::current_exception());
             }
           });
@@ -235,6 +226,8 @@ std::ostream& operator<<(std::ostream& out, const StopReason& reason) {
 
 // static
 void Driver::enqueue(std::shared_ptr<Driver> driver) {
+  process::ScopedThreadDebugInfo scopedInfo(
+      driver->driverCtx()->threadDebugInfo);
   // This is expected to be called inside the Driver's Tasks's mutex.
   driver->enqueueInternal();
   if (driver->closed_) {
@@ -249,9 +242,10 @@ void Driver::init(
     std::vector<std::unique_ptr<Operator>> operators) {
   VELOX_CHECK_NULL(ctx_);
   ctx_ = std::move(ctx);
+  cpuSliceMs_ = task()->driverCpuTimeSliceLimitMs();
   VELOX_CHECK(operators_.empty());
   operators_ = std::move(operators);
-  curOpIndex_ = operators_.size() - 1;
+  curOperatorId_ = operators_.size() - 1;
   trackOperatorCpuUsage_ = ctx_->queryConfig().operatorTrackCpuUsage();
 }
 
@@ -266,11 +260,12 @@ void Driver::initializeOperators() {
 }
 
 void Driver::pushdownFilters(int operatorIndex) {
-  auto op = operators_[operatorIndex].get();
+  auto* op = operators_[operatorIndex].get();
   const auto& filters = op->getDynamicFilters();
   if (filters.empty()) {
     return;
   }
+  const auto& planNodeId = op->planNodeId();
 
   op->addRuntimeStat("dynamicFiltersProduced", RuntimeCounter(filters.size()));
 
@@ -286,20 +281,21 @@ void Driver::pushdownFilters(int operatorIndex) {
             prevOp->canAddDynamicFilter(),
             "Cannot push down dynamic filters produced by {}",
             op->toString());
-        prevOp->addDynamicFilter(channel, entry.second);
+        prevOp->addDynamicFilter(planNodeId, channel, entry.second);
         prevOp->addRuntimeStat("dynamicFiltersAccepted", RuntimeCounter(1));
         break;
       }
 
       const auto& identityProjections = prevOp->identityProjections();
-      auto inputChannel = getIdentityProjection(identityProjections, channel);
+      const auto inputChannel =
+          getIdentityProjection(identityProjections, channel);
       if (!inputChannel.has_value()) {
         // Filter channel is not an identity projection.
         VELOX_CHECK(
             prevOp->canAddDynamicFilter(),
             "Cannot push down dynamic filters produced by {}",
             op->toString());
-        prevOp->addDynamicFilter(channel, entry.second);
+        prevOp->addDynamicFilter(planNodeId, channel, entry.second);
         prevOp->addRuntimeStat("dynamicFiltersAccepted", RuntimeCounter(1));
         break;
       }
@@ -312,21 +308,35 @@ void Driver::pushdownFilters(int operatorIndex) {
   op->clearDynamicFilters();
 }
 
-RowVectorPtr Driver::next(std::shared_ptr<BlockingState>& blockingState) {
+RowVectorPtr Driver::next(ContinueFuture* future) {
   enqueueInternal();
   auto self = shared_from_this();
   facebook::velox::process::ScopedThreadDebugInfo scopedInfo(
       self->driverCtx()->threadDebugInfo);
   ScopedDriverThreadContext scopedDriverThreadContext(*self->driverCtx());
+  std::shared_ptr<BlockingState> blockingState;
   RowVectorPtr result;
-  auto stop = runInternal(self, blockingState, result);
+  const auto stop = runInternal(self, blockingState, result);
+
+  if (blockingState != nullptr) {
+    VELOX_CHECK_NULL(result);
+    *future = blockingState->future();
+    return nullptr;
+  }
+
+  if (stop == StopReason::kPause) {
+    VELOX_CHECK_NULL(result);
+    const auto paused = task()->pauseRequested(future);
+    VELOX_CHECK_EQ(paused, future->valid());
+    return nullptr;
+  }
 
   // We get kBlock if 'result' was produced; kAtEnd if pipeline has finished
   // processing and no more results will be produced; kAlreadyTerminated on
   // error.
   VELOX_CHECK(
       stop == StopReason::kBlock || stop == StopReason::kAtEnd ||
-      stop == StopReason::kAlreadyTerminated);
+      stop == StopReason::kAlreadyTerminated || stop == StopReason::kTerminate);
 
   return result;
 }
@@ -335,27 +345,56 @@ void Driver::enqueueInternal() {
   VELOX_CHECK(!state_.isEnqueued);
   state_.isEnqueued = true;
   // When enqueuing, starting timing the queue time.
-  queueTimeStartMicros_ = getCurrentTimeMicro();
+  queueTimeStartUs_ = getCurrentTimeMicro();
 }
 
 // Call an Oprator method. record silenced throws, but not a query
 // terminating throw. Annotate exceptions with Operator info.
-#define CALL_OPERATOR(call, operator, methodName)                       \
-  try {                                                                 \
-    threadNumVeloxThrow() = 0;                                          \
-    call;                                                               \
-    recordSilentThrows(*operator);                                      \
-  } catch (const VeloxException& e) {                                   \
-    throw;                                                              \
-  } catch (const std::exception& e) {                                   \
-    VELOX_FAIL(                                                         \
-        "Operator::{} failed for [operator: {}, plan node ID: {}]: {}", \
-        methodName,                                                     \
-        operator->operatorType(),                                       \
-        operator->planNodeId(),                                         \
-        e.what());                                                      \
+#define CALL_OPERATOR(call, operatorPtr, operatorId, operatorMethod)       \
+  try {                                                                    \
+    Operator::NonReclaimableSectionGuard nonReclaimableGuard(operatorPtr); \
+    RuntimeStatWriterScopeGuard statsWriterGuard(operatorPtr);             \
+    threadNumVeloxThrow() = 0;                                             \
+    opCallStatus_.start(operatorId, operatorMethod);                       \
+    ExceptionContextSetter exceptionContext(                               \
+        {addContextOnException, operatorPtr, true});                       \
+    auto stopGuard = folly::makeGuard([&]() { opCallStatus_.stop(); });    \
+    call;                                                                  \
+    recordSilentThrows(*operatorPtr);                                      \
+  } catch (const VeloxException&) {                                        \
+    throw;                                                                 \
+  } catch (const std::exception& e) {                                      \
+    VELOX_FAIL(                                                            \
+        "Operator::{} failed for [operator: {}, plan node ID: {}]: {}",    \
+        operatorMethod,                                                    \
+        operatorPtr->operatorType(),                                       \
+        operatorPtr->planNodeId(),                                         \
+        e.what());                                                         \
   }
 
+void OpCallStatus::start(int32_t operatorId, const char* operatorMethod) {
+  timeStartMs = getCurrentTimeMs();
+  opId = operatorId;
+  method = operatorMethod;
+}
+
+void OpCallStatus::stop() {
+  timeStartMs = 0;
+}
+
+size_t OpCallStatusRaw::callDuration() const {
+  return empty() ? 0 : (getCurrentTimeMs() - timeStartMs);
+}
+
+/*static*/ std::string OpCallStatusRaw::formatCall(
+    Operator* op,
+    const char* operatorMethod) {
+  return op
+      ? fmt::format(
+            "{}.{}::{}", op->operatorType(), op->planNodeId(), operatorMethod)
+      : fmt::format("null::{}", operatorMethod);
+}
+
 CpuWallTiming Driver::processLazyTiming(
     Operator& op,
     const CpuWallTiming& timing) {
@@ -363,102 +402,104 @@ CpuWallTiming Driver::processLazyTiming(
     return timing;
   }
   auto lockStats = op.stats().wlock();
-  uint64_t cpuDelta = 0;
-  uint64_t wallDelta = 0;
   auto it = lockStats->runtimeStats.find(LazyVector::kCpuNanos);
-  if (it != lockStats->runtimeStats.end()) {
-    auto cpu = it->second.sum;
-    cpuDelta = cpu >= lockStats->lastLazyCpuNanos
-        ? cpu - lockStats->lastLazyCpuNanos
-        : 0;
-    if (cpuDelta == 0) {
-      // return early if no change. Checking one counter is enough. If
-      // this did not change and the other did, the change would be
-      // insignificant and tracking would catch up when this counter next
-      // changed.
-      return timing;
-    }
-    lockStats->lastLazyCpuNanos = cpu;
-  } else {
-    // Return early if no lazy activity. Lazy CPU and wall times are recorded
+  if (it == lockStats->runtimeStats.end()) {
+    // Return early if no lazy activity.  Lazy CPU and wall times are recorded
     // together, checking one is enough.
     return timing;
   }
+  int64_t cpu = it->second.sum;
+  auto cpuDelta = std::max<int64_t>(0, cpu - lockStats->lastLazyCpuNanos);
+  if (cpuDelta == 0) {
+    // Return early if no change.  Checking one counter is enough.  If this did
+    // not change and the other did, the change would be insignificant and
+    // tracking would catch up when this counter next changed.
+    return timing;
+  }
+  lockStats->lastLazyCpuNanos = cpu;
+  int64_t wallDelta = 0;
   it = lockStats->runtimeStats.find(LazyVector::kWallNanos);
   if (it != lockStats->runtimeStats.end()) {
-    auto wall = it->second.sum;
-    wallDelta = wall >= lockStats->lastLazyWallNanos
-        ? wall - lockStats->lastLazyWallNanos
-        : 0;
+    int64_t wall = it->second.sum;
+    wallDelta = std::max<int64_t>(0, wall - lockStats->lastLazyWallNanos);
     if (wallDelta > 0) {
       lockStats->lastLazyWallNanos = wall;
     }
   }
-  operators_[0]->stats().wlock()->getOutputTiming.add(
-      CpuWallTiming{1, wallDelta, cpuDelta});
+  lockStats.unlock();
+  cpuDelta = std::min<int64_t>(cpuDelta, timing.cpuNanos);
+  wallDelta = std::min<int64_t>(wallDelta, timing.wallNanos);
+  lockStats = operators_[0]->stats().wlock();
+  lockStats->getOutputTiming.add(CpuWallTiming{
+      1,
+      static_cast<uint64_t>(wallDelta),
+      static_cast<uint64_t>(cpuDelta),
+  });
   return CpuWallTiming{
       1,
-      timing.wallNanos >= wallDelta ? timing.wallNanos - wallDelta : 0,
-      timing.cpuNanos >= cpuDelta ? timing.cpuNanos - cpuDelta : 0};
+      timing.wallNanos - wallDelta,
+      timing.cpuNanos - cpuDelta,
+  };
+}
+
+bool Driver::shouldYield() const {
+  if (cpuSliceMs_ == 0) {
+    return false;
+  }
+  return execTimeMs() >= cpuSliceMs_;
+}
+
+bool Driver::checkUnderArbitration(ContinueFuture* future) {
+  return task()->queryCtx()->checkUnderArbitration(future);
 }
 
 StopReason Driver::runInternal(
     std::shared_ptr<Driver>& self,
     std::shared_ptr<BlockingState>& blockingState,
     RowVectorPtr& result) {
-  TestValue::adjust("facebook::velox::exec::Driver::runInternal", self.get());
   const auto now = getCurrentTimeMicro();
-  const auto queuedTime = (now - queueTimeStartMicros_) * 1'000;
+  const auto queuedTimeUs = now - queueTimeStartUs_;
   // Update the next operator's queueTime.
-  auto stop = closed_ ? StopReason::kTerminate : task()->enter(state_, now);
+  StopReason stop =
+      closed_ ? StopReason::kTerminate : task()->enter(state_, now);
   if (stop != StopReason::kNone) {
     if (stop == StopReason::kTerminate) {
       // ctx_ still has a reference to the Task. 'this' is not on
       // thread from the Task's viewpoint, hence no need to call
       // close().
-      ctx_->task->setError(std::make_exception_ptr(VeloxRuntimeError(
-          __FILE__,
-          __LINE__,
-          __FUNCTION__,
-          "",
-          "Cancelled",
-          error_source::kErrorSourceRuntime,
-          error_code::kInvalidState,
-          false)));
+      ctx_->task->setError(
+          makeException("Cancelled", __FILE__, __LINE__, __FUNCTION__));
     }
     return stop;
   }
 
   // Update the queued time after entering the Task to ensure the stats have not
   // been deleted.
-  if (curOpIndex_ < operators_.size()) {
-    operators_[curOpIndex_]->addRuntimeStat(
+  if (curOperatorId_ < operators_.size()) {
+    operators_[curOperatorId_]->addRuntimeStat(
         "queuedWallNanos",
-        RuntimeCounter(queuedTime, RuntimeCounter::Unit::kNanos));
+        RuntimeCounter(queuedTimeUs * 1'000, RuntimeCounter::Unit::kNanos));
+    RECORD_HISTOGRAM_METRIC_VALUE(
+        kMetricDriverQueueTimeMs, queuedTimeUs / 1'000);
   }
 
-  CancelGuard guard(task().get(), &state_, [&](StopReason reason) {
+  CancelGuard guard(self, task().get(), &state_, [&](StopReason reason) {
     // This is run on error or cancel exit.
     if (reason == StopReason::kTerminate) {
-      task()->setError(std::make_exception_ptr(VeloxRuntimeError(
-          __FILE__,
-          __LINE__,
-          __FUNCTION__,
-          "",
-          "Cancelled",
-          error_source::kErrorSourceRuntime,
-          error_code::kInvalidState,
-          false)));
+      ctx_->task->setError(
+          makeException("Cancelled", __FILE__, __LINE__, __FUNCTION__));
     }
     close();
   });
 
   try {
     // Invoked to initialize the operators once before driver starts execution.
-    self->initializeOperators();
+    initializeOperators();
+
+    TestValue::adjust("facebook::velox::exec::Driver::runInternal", this);
 
     const int32_t numOperators = operators_.size();
-    ContinueFuture future;
+    ContinueFuture future = ContinueFuture::makeEmpty();
 
     for (;;) {
       for (int32_t i = numOperators - 1; i >= 0; --i) {
@@ -468,94 +509,105 @@ StopReason Driver::runInternal(
           return stop;
         }
 
-        auto op = operators_[i].get();
-        VELOX_CHECK(op->isInitialized());
+        if (FOLLY_UNLIKELY(shouldYield())) {
+          recordYieldCount();
+          guard.notThrown();
+          return StopReason::kYield;
+        }
+
+        auto* op = operators_[i].get();
 
         // In case we are blocked, this index will point to the operator, whose
         // queuedTime we should update.
-        curOpIndex_ = i;
-        RuntimeStatWriterScopeGuard statsWriterGuard(op);
+        curOperatorId_ = i;
+
+        if (FOLLY_UNLIKELY(checkUnderArbitration(&future))) {
+          // Blocks the driver if the associated query is under memory
+          // arbitration as it is very likely the driver run will trigger memory
+          // arbitration when it needs to allocate memory, and the memory
+          // arbitration will be blocked by the current running arbitration
+          // until it finishes. Instead of blocking the driver thread to wait
+          // for the current running arbitration, it is more efficient
+          // system-wide to let driver go off thread for the other queries which
+          // have free memory capacity to run during the time.
+          blockingReason_ = BlockingReason::kWaitForArbitration;
+          return blockDriver(self, i, std::move(future), blockingState, guard);
+        }
 
         CALL_OPERATOR(
-            blockingReason_ = op->isBlocked(&future), op, "isBlocked");
+            blockingReason_ = op->isBlocked(&future),
+            op,
+            curOperatorId_,
+            kOpMethodIsBlocked);
         if (blockingReason_ != BlockingReason::kNotBlocked) {
-          blockingState = std::make_shared<BlockingState>(
-              self, std::move(future), op, blockingReason_);
-          guard.notThrown();
-          return StopReason::kBlock;
+          return blockDriver(self, i, std::move(future), blockingState, guard);
         }
-        Operator* nextOp = nullptr;
-        if (i < operators_.size() - 1) {
-          nextOp = operators_[i + 1].get();
-          RuntimeStatWriterScopeGuard statsWriterGuard(nextOp);
+
+        if (i < numOperators - 1) {
+          Operator* nextOp = operators_[i + 1].get();
+
           CALL_OPERATOR(
               blockingReason_ = nextOp->isBlocked(&future),
               nextOp,
-              "isBlocked");
+              curOperatorId_ + 1,
+              kOpMethodIsBlocked);
           if (blockingReason_ != BlockingReason::kNotBlocked) {
-            blockingState = std::make_shared<BlockingState>(
-                self, std::move(future), nextOp, blockingReason_);
-            guard.notThrown();
-            return StopReason::kBlock;
+            return blockDriver(
+                self, i + 1, std::move(future), blockingState, guard);
           }
 
           bool needsInput;
           CALL_OPERATOR(
-              needsInput = nextOp->needsInput(), nextOp, "needsInput");
+              needsInput = nextOp->needsInput(),
+              nextOp,
+              curOperatorId_ + 1,
+              kOpMethodNeedsInput);
           if (needsInput) {
             uint64_t resultBytes = 0;
             RowVectorPtr intermediateResult;
             {
-              auto timer = createDeltaCpuWallTimer(
-                  [op, this](const CpuWallTiming& deltaTiming) {
-                    processLazyTiming(*op, deltaTiming);
-                    op->stats().wlock()->getOutputTiming.add(deltaTiming);
-                  });
-              RuntimeStatWriterScopeGuard statsWriterGuard(op);
-              TestValue::adjust(
-                  "facebook::velox::exec::Driver::runInternal::getOutput", op);
-              CALL_OPERATOR(
-                  intermediateResult = op->getOutput(), op, "getOutput");
-              if (intermediateResult) {
-                VELOX_CHECK(
-                    intermediateResult->size() > 0,
-                    "Operator::getOutput() must return nullptr or "
-                    "a non-empty vector: {}",
-                    op->operatorType());
-                if (ctx_->queryConfig().validateOutputFromOperators()) {
-                  validateOperatorResult(intermediateResult, *op);
-                }
-                resultBytes = intermediateResult->estimateFlatSize();
-                {
-                  auto lockedStats = op->stats().wlock();
-                  lockedStats->addOutputVector(
-                      resultBytes, intermediateResult->size());
+              withDeltaCpuWallTimer(op, &OperatorStats::getOutputTiming, [&]() {
+                TestValue::adjust(
+                    "facebook::velox::exec::Driver::runInternal::getOutput",
+                    op);
+                CALL_OPERATOR(
+                    intermediateResult = op->getOutput(),
+                    op,
+                    curOperatorId_,
+                    kOpMethodGetOutput);
+                if (intermediateResult) {
+                  validateOperatorOutputResult(intermediateResult, *op);
+                  resultBytes = intermediateResult->estimateFlatSize();
+                  {
+                    auto lockedStats = op->stats().wlock();
+                    lockedStats->addOutputVector(
+                        resultBytes, intermediateResult->size());
+                  }
                 }
-              }
+              });
             }
             pushdownFilters(i);
             if (intermediateResult) {
-              auto timer = createDeltaCpuWallTimer(
-                  [nextOp, this](const CpuWallTiming& timing) {
-                    auto selfDelta = processLazyTiming(*nextOp, timing);
-                    nextOp->stats().wlock()->addInputTiming.add(selfDelta);
-                  });
-              {
-                auto lockedStats = nextOp->stats().wlock();
-                lockedStats->addInputVector(
-                    resultBytes, intermediateResult->size());
-              }
-              RuntimeStatWriterScopeGuard statsWriterGuard(nextOp);
-              TestValue::adjust(
-                  "facebook::velox::exec::Driver::runInternal::addInput",
-                  nextOp);
+              withDeltaCpuWallTimer(op, &OperatorStats::addInputTiming, [&]() {
+                {
+                  auto lockedStats = nextOp->stats().wlock();
+                  lockedStats->addInputVector(
+                      resultBytes, intermediateResult->size());
+                }
+                TestValue::adjust(
+                    "facebook::velox::exec::Driver::runInternal::addInput",
+                    nextOp);
 
-              CALL_OPERATOR(
-                  nextOp->addInput(intermediateResult), nextOp, "addInput");
+                CALL_OPERATOR(
+                    nextOp->addInput(intermediateResult),
+                    nextOp,
+                    curOperatorId_ + 1,
+                    kOpMethodAddInput);
 
-              // The next iteration will see if operators_[i + 1] has
-              // output now that it got input.
-              i += 2;
+                // The next iteration will see if operators_[i + 1] has
+                // output now that it got input.
+                i += 2;
+              });
               continue;
             } else {
               stop = task()->shouldStop();
@@ -570,25 +622,32 @@ StopReason Driver::runInternal(
               // not the source, just try to get output from the one
               // before.
               CALL_OPERATOR(
-                  blockingReason_ = op->isBlocked(&future), op, "isBlocked");
+                  blockingReason_ = op->isBlocked(&future),
+                  op,
+                  curOperatorId_,
+                  kOpMethodIsBlocked);
               if (blockingReason_ != BlockingReason::kNotBlocked) {
-                blockingState = std::make_shared<BlockingState>(
-                    self, std::move(future), op, blockingReason_);
-                guard.notThrown();
-                return StopReason::kBlock;
+                return blockDriver(
+                    self, i, std::move(future), blockingState, guard);
               }
-              RuntimeStatWriterScopeGuard statsWriterGuard(op);
-              if (op->isFinished()) {
-                auto timer = createDeltaCpuWallTimer(
-                    [op, this](const CpuWallTiming& timing) {
-                      processLazyTiming(*op, timing);
-                      op->stats().wlock()->finishTiming.add(timing);
+              bool finished{false};
+              CALL_OPERATOR(
+                  finished = op->isFinished(),
+                  op,
+                  curOperatorId_,
+                  kOpMethodIsFinished);
+              if (finished) {
+                withDeltaCpuWallTimer(
+                    op, &OperatorStats::finishTiming, [this, &nextOp]() {
+                      TestValue::adjust(
+                          "facebook::velox::exec::Driver::runInternal::noMoreInput",
+                          nextOp);
+                      CALL_OPERATOR(
+                          nextOp->noMoreInput(),
+                          nextOp,
+                          curOperatorId_ + 1,
+                          kOpMethodNoMoreInput);
                     });
-                RuntimeStatWriterScopeGuard statsWriterGuard(nextOp);
-                TestValue::adjust(
-                    "facebook::velox::exec::Driver::runInternal::noMoreInput",
-                    nextOp);
-                CALL_OPERATOR(nextOp->noMoreInput(), nextOp, "noMoreInput");
                 break;
               }
             }
@@ -598,35 +657,37 @@ StopReason Driver::runInternal(
           // control here, so it can advance. If it is again blocked,
           // this will be detected when trying to add input, and we
           // will come back here after this is again on thread.
-          {
-            auto timer = createDeltaCpuWallTimer(
-                [op, this](const CpuWallTiming& timing) {
-                  auto selfDelta = processLazyTiming(*op, timing);
-                  op->stats().wlock()->getOutputTiming.add(selfDelta);
-                });
-            CALL_OPERATOR(result = op->getOutput(), op, "getOutput");
+          withDeltaCpuWallTimer(op, &OperatorStats::getOutputTiming, [&]() {
+            CALL_OPERATOR(
+                result = op->getOutput(),
+                op,
+                curOperatorId_,
+                kOpMethodGetOutput);
             if (result) {
-              VELOX_CHECK(
-                  result->size() > 0,
-                  "Operator::getOutput() must return nullptr or "
-                  "a non-empty vector: {}",
-                  op->operatorType());
-              if (ctx_->queryConfig().validateOutputFromOperators()) {
-                validateOperatorResult(result, *op);
-              }
+              validateOperatorOutputResult(result, *op);
+
               {
                 auto lockedStats = op->stats().wlock();
                 lockedStats->addOutputVector(
                     result->estimateFlatSize(), result->size());
               }
-
-              // This code path is used only in single-threaded execution.
-              blockingReason_ = BlockingReason::kWaitForConsumer;
-              guard.notThrown();
-              return StopReason::kBlock;
             }
+          });
+
+          if (result) {
+            // This code path is used only in serial execution mode.
+            blockingReason_ = BlockingReason::kWaitForConsumer;
+            guard.notThrown();
+            return StopReason::kBlock;
           }
-          if (op->isFinished()) {
+
+          bool finished{false};
+          CALL_OPERATOR(
+              finished = op->isFinished(),
+              op,
+              curOperatorId_,
+              kOpMethodIsFinished);
+          if (finished) {
             guard.notThrown();
             close();
             return StopReason::kAtEnd;
@@ -636,11 +697,11 @@ StopReason Driver::runInternal(
         }
       }
     }
-  } catch (velox::VeloxException& e) {
+  } catch (velox::VeloxException&) {
     task()->setError(std::current_exception());
     // The CancelPoolGuard will close 'self' and remove from Task.
     return StopReason::kAlreadyTerminated;
-  } catch (std::exception& e) {
+  } catch (std::exception&) {
     task()->setError(std::current_exception());
     // The CancelGuard will close 'self' and remove from Task.
     return StopReason::kAlreadyTerminated;
@@ -649,6 +710,18 @@ StopReason Driver::runInternal(
 
 #undef CALL_OPERATOR
 
+// static
+std::atomic_uint64_t& Driver::yieldCount() {
+  static std::atomic_uint64_t count{0};
+  return count;
+}
+
+// static
+void Driver::recordYieldCount() {
+  ++yieldCount();
+  RECORD_METRIC_VALUE(kMetricDriverYieldCount);
+}
+
 // static
 void Driver::run(std::shared_ptr<Driver> self) {
   process::TraceContext trace("Driver::run");
@@ -664,7 +737,7 @@ void Driver::run(std::shared_ptr<Driver> self) {
   VELOX_CHECK_NULL(
       nullResult,
       "The last operator (sink) must not produce any results. "
-      "Results need to be consumed by either a callback or another operator. ")
+      "Results need to be consumed by either a callback or another operator. ");
 
   // There can be a race between Task terminating and the Driver being on the
   // thread and exiting the runInternal() in a blocked state. If this happens
@@ -694,7 +767,7 @@ void Driver::run(std::shared_ptr<Driver> self) {
     case StopReason::kAtEnd:
       return;
     default:
-      VELOX_CHECK(false, "Unhandled stop reason");
+      VELOX_FAIL("Unhandled stop reason");
   }
 }
 
@@ -721,12 +794,24 @@ void Driver::closeOperators() {
   // Add operator stats to the task.
   for (auto& op : operators_) {
     auto stats = op->stats(true);
-    stats.memoryStats.update(op->pool());
     stats.numDrivers = 1;
     task()->addOperatorStats(stats);
   }
 }
 
+void Driver::updateStats() {
+  DriverStats stats;
+  if (state_.totalPauseTimeMs > 0) {
+    stats.runtimeStats[DriverStats::kTotalPauseTime] = RuntimeMetric(
+        1'000'000 * state_.totalPauseTimeMs, RuntimeCounter::Unit::kNanos);
+  }
+  if (state_.totalOffThreadTimeMs > 0) {
+    stats.runtimeStats[DriverStats::kTotalOffThreadTime] = RuntimeMetric(
+        1'000'000 * state_.totalOffThreadTimeMs, RuntimeCounter::Unit::kNanos);
+  }
+  task()->addDriverStats(ctx_->pipelineId, std::move(stats));
+}
+
 void Driver::close() {
   if (closed_) {
     // Already closed.
@@ -736,6 +821,7 @@ void Driver::close() {
     LOG(FATAL) << "Driver::close is only allowed from the Driver's thread";
   }
   closeOperators();
+  updateStats();
   closed_ = true;
   Task::removeDriver(ctx_->task, this);
 }
@@ -744,6 +830,7 @@ void Driver::closeByTask() {
   VELOX_CHECK(isOnThread());
   VELOX_CHECK(isTerminated());
   closeOperators();
+  updateStats();
   closed_ = true;
 }
 
@@ -783,7 +870,7 @@ std::unordered_set<column_index_t> Driver::canPushdownFilters(
   for (auto i = 0; i < channels.size(); ++i) {
     auto channel = channels[i];
     for (auto j = filterSourceIndex - 1; j >= 0; --j) {
-      auto prevOp = operators_[j].get();
+      auto* prevOp = operators_[j].get();
 
       if (j == 0) {
         // Source operator.
@@ -794,7 +881,8 @@ std::unordered_set<column_index_t> Driver::canPushdownFilters(
       }
 
       const auto& identityProjections = prevOp->identityProjections();
-      auto inputChannel = getIdentityProjection(identityProjections, channel);
+      const auto inputChannel =
+          getIdentityProjection(identityProjections, channel);
       if (!inputChannel.has_value()) {
         // Filter channel is not an identity projection.
         if (prevOp->canAddDynamicFilter()) {
@@ -825,6 +913,11 @@ Operator* Driver::findOperator(int32_t operatorId) const {
   return operators_[operatorId].get();
 }
 
+Operator* Driver::findOperatorNoThrow(int32_t operatorId) const {
+  return (operatorId < operators_.size()) ? operators_[operatorId].get()
+                                          : nullptr;
+}
+
 std::vector<Operator*> Driver::operators() const {
   std::vector<Operator*> operators;
   operators.reserve(operators_.size());
@@ -836,35 +929,138 @@ std::vector<Operator*> Driver::operators() const {
 
 std::string Driver::toString() const {
   std::stringstream out;
-  out << "{Driver: ";
-  if (state_.isOnThread()) {
+  out << "{Driver." << driverCtx()->pipelineId << "." << driverCtx()->driverId
+      << ": ";
+  if (state_.isTerminated) {
+    out << "terminated, ";
+  }
+  if (state_.hasBlockingFuture) {
+    std::string blockedOp = (blockedOperatorId_ < operators_.size())
+        ? operators_[blockedOperatorId_]->toString()
+        : "<unknown op>";
+    out << "blocked (" << blockingReasonToString(blockingReason_) << " "
+        << blockedOp << "), ";
+  } else if (state_.isEnqueued) {
+    out << "enqueued ";
+  } else if (state_.isOnThread()) {
     out << "running ";
   } else {
-    out << "blocked " << static_cast<int>(blockingReason_) << " ";
+    out << "unknown state";
   }
+
+  out << "{Operators: ";
   for (auto& op : operators_) {
-    out << op->toString() << " ";
+    out << op->toString() << ", ";
+  }
+  out << "}";
+  const auto ocs = opCallStatus();
+  if (!ocs.empty()) {
+    out << "{OpCallStatus: executing "
+        << ocs.formatCall(findOperatorNoThrow(ocs.opId), ocs.method) << " for "
+        << ocs.callDuration() << "ms}";
   }
   out << "}";
   return out.str();
 }
 
-std::string Driver::toJsonString() const {
+Driver::CancelGuard::~CancelGuard() {
+  bool onTerminateCalled{false};
+  if (isThrow_) {
+    // Runtime error. Driver is on thread, hence safe.
+    state_->isTerminated = true;
+    onTerminate_(StopReason::kNone);
+    onTerminateCalled = true;
+  }
+  task_->leave(*state_, onTerminateCalled ? nullptr : onTerminate_);
+}
+
+folly::dynamic Driver::toJson() const {
   folly::dynamic obj = folly::dynamic::object;
   obj["blockingReason"] = blockingReasonToString(blockingReason_);
-  obj["state"] = state_.toJsonString();
+  obj["state"] = state_.toJson();
   obj["closed"] = closed_.load();
-  obj["queueTimeStartMicros"] = queueTimeStartMicros_;
-  obj["curOpIndex"] = curOpIndex_;
+  obj["queueTimeStartMicros"] = queueTimeStartUs_;
+  const auto ocs = opCallStatus();
+  if (!ocs.empty()) {
+    obj["curOpCall"] =
+        ocs.formatCall(findOperatorNoThrow(ocs.opId), ocs.method);
+    obj["curOpCallDuration"] = ocs.callDuration();
+  }
 
   folly::dynamic operatorsObj = folly::dynamic::object;
   int index = 0;
   for (auto& op : operators_) {
-    operatorsObj[std::to_string(index++)] = op->toString();
+    operatorsObj[std::to_string(index++)] = op->toJson();
+  }
+  obj["operators"] = operatorsObj;
+
+  return obj;
+}
+
+template <typename Func>
+void Driver::withDeltaCpuWallTimer(
+    Operator* op,
+    TimingMemberPtr opTimingMember,
+    Func&& opFunction) {
+  // If 'trackOperatorCpuUsage_' is true, create and initialize the timer object
+  // to track cpu and wall time of the opFunction.
+  if (!trackOperatorCpuUsage_) {
+    return opFunction();
+  }
+
+  // The delta CpuWallTiming object would be recorded to the corresponding
+  // opTimingMember upon destruction of the timer when withDeltaCpuWallTimer
+  // ends. The timer is created on the stack to avoid heap allocation
+  auto f = [op, opTimingMember, this](const CpuWallTiming& elapsedTime) {
+    auto elapsedSelfTime = processLazyTiming(*op, elapsedTime);
+    op->stats().withWLock([&](auto& lockedStats) {
+      (lockedStats.*opTimingMember).add(elapsedSelfTime);
+    });
+  };
+  DeltaCpuWallTimer<decltype(f)> timer(std::move(f));
+
+  opFunction();
+}
+
+void Driver::validateOperatorOutputResult(
+    const RowVectorPtr& result,
+    const Operator& op) {
+  VELOX_CHECK_GT(
+      result->size(),
+      0,
+      "Operator::getOutput() must return nullptr or a non-empty vector: {}",
+      op.operatorType());
+
+  if (ctx_->queryConfig().validateOutputFromOperators()) {
+    try {
+      result->validate({});
+    } catch (const std::exception& e) {
+      VELOX_FAIL(
+          "Output validation failed for [operator: {}, plan node ID: {}]: {}",
+          op.operatorType(),
+          op.planNodeId(),
+          e.what());
+    }
   }
-  obj["operatorsObj"] = operatorsObj;
+}
 
-  return folly::toPrettyJson(obj);
+StopReason Driver::blockDriver(
+    const std::shared_ptr<Driver>& self,
+    size_t blockedOperatorId,
+    ContinueFuture&& future,
+    std::shared_ptr<BlockingState>& blockingState,
+    CancelGuard& guard) {
+  auto* op = operators_[blockedOperatorId].get();
+  VELOX_CHECK(
+      future.valid(),
+      "The operator {} is blocked but blocking future is not valid",
+      op->operatorType());
+
+  blockedOperatorId_ = blockedOperatorId;
+  blockingState = std::make_shared<BlockingState>(
+      self, std::move(future), op, blockingReason_);
+  guard.notThrown();
+  return StopReason::kBlock;
 }
 
 SuspendedSection::SuspendedSection(Driver* driver) : driver_(driver) {
@@ -875,7 +1071,10 @@ SuspendedSection::SuspendedSection(Driver* driver) : driver_(driver) {
 
 SuspendedSection::~SuspendedSection() {
   if (driver_->task()->leaveSuspended(driver_->state()) != StopReason::kNone) {
-    VELOX_FAIL("Terminate detected when leaving suspended section");
+    LOG(WARNING)
+        << "Terminate detected when leaving suspended section for driver "
+        << driver_->driverCtx()->driverId << " from task "
+        << driver_->task()->taskId();
   }
 }
 
@@ -905,6 +1104,10 @@ std::string blockingReasonToString(BlockingReason reason) {
       return "kWaitForConnector";
     case BlockingReason::kWaitForSpill:
       return "kWaitForSpill";
+    case BlockingReason::kYield:
+      return "kYield";
+    case BlockingReason::kWaitForArbitration:
+      return "kWaitForArbitration";
   }
   VELOX_UNREACHABLE();
   return "";
diff --git a/velox/exec/Driver.h b/velox/exec/Driver.h
index 5d23fbd675b6e..7551b2b304d71 100644
--- a/velox/exec/Driver.h
+++ b/velox/exec/Driver.h
@@ -14,19 +14,18 @@
  * limitations under the License.
  */
 #pragma once
+
+#include <memory>
+
 #include <folly/executors/CPUThreadPoolExecutor.h>
 #include <folly/futures/Future.h>
 #include <folly/portability/SysSyscall.h>
-#include <memory>
 
-#include "velox/common/future/VeloxPromise.h"
-#include "velox/common/process/ThreadDebugInfo.h"
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/time/CpuWallTimer.h"
-#include "velox/connectors/Connector.h"
 #include "velox/core/PlanFragment.h"
-#include "velox/core/PlanNode.h"
 #include "velox/core/QueryCtx.h"
-#include "velox/exec/Spiller.h"
 
 namespace facebook::velox::exec {
 
@@ -37,21 +36,21 @@ struct OperatorStats;
 class Task;
 
 enum class StopReason {
-  // Keep running.
+  /// Keep running.
   kNone,
-  // Go off thread and do not schedule more activity.
+  /// Go off thread and do not schedule more activity.
   kPause,
-  // Stop and free all. This is returned once and the thread that gets
-  // this value is responsible for freeing the state associated with
-  // the thread. Other threads will get kAlreadyTerminated after the
-  // first thread has received kTerminate.
+  /// Stop and free all. This is returned once and the thread that gets this
+  /// value is responsible for freeing the state associated with the thread.
+  /// Other threads will get kAlreadyTerminated after the first thread has
+  /// received kTerminate.
   kTerminate,
   kAlreadyTerminated,
-  // Go off thread and then enqueue to the back of the runnable queue.
+  /// Go off thread and then enqueue to the back of the runnable queue.
   kYield,
-  // Must wait for external events.
+  /// Must wait for external events.
   kBlock,
-  // No more data to produce.
+  /// No more data to produce.
   kAtEnd,
   kAlreadyOnThread
 };
@@ -60,53 +59,72 @@ std::string stopReasonString(StopReason reason);
 
 std::ostream& operator<<(std::ostream& out, const StopReason& reason);
 
-// Represents a Driver's state. This is used for cancellation, forcing
-// release of and for waiting for memory. The fields are serialized on
-// the mutex of the Driver's Task.
-//
-// The Driver goes through the following states:
-// Not on thread. It is created and has not started. All flags are false.
-//
-// Enqueued - The Driver is added to an executor but does not yet have a thread.
-// isEnqueued is true. Next states are terminated or on thread.
-//
-// On thread - 'thread' is set to the thread that is running the Driver. Next
-// states are blocked, terminated, suspended, enqueued.
-//
-//  Blocked - The Driver is not on thread and is waiting for an external event.
-//  Next states are terminated, enqueued.
-//
-// Suspended - The Driver is on thread, 'thread' and 'isSuspended' are set. The
-// thread does not manipulate the Driver's state and is suspended as in waiting
-// for memory or out of process IO. This is different from Blocked in that here
-// we keep the stack so that when the wait is over the control stack is not
-// lost. Next states are on thread or terminated.
-//
-//  Terminated - 'isTerminated' is set. The Driver cannot run after this and
-// the state is final.
-//
-// CancelPool  allows terminating or pausing a set of Drivers. The Task API
-// allows starting or resuming Drivers. When terminate is requested the request
-// is successful when all Drivers are off thread, blocked or suspended. When
-// pause is requested, we have success when all Drivers are either enqueued,
-// suspended, off thread or blocked.
+struct DriverStats {
+  static constexpr const char* kTotalPauseTime = "totalDriverPauseWallNanos";
+  static constexpr const char* kTotalOffThreadTime =
+      "totalDriverOffThreadWallNanos";
+
+  std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+};
+
+/// Represents a Driver's state. This is used for cancellation, forcing
+/// release of and for waiting for memory. The fields are serialized on
+/// the mutex of the Driver's Task.
+///
+/// The Driver goes through the following states:
+/// Not on thread. It is created and has not started. All flags are false.
+///
+/// Enqueued - The Driver is added to an executor but does not yet have a
+/// thread. isEnqueued is true. Next states are terminated or on thread.
+///
+/// On thread - 'thread' is set to the thread that is running the Driver. Next
+/// states are blocked, terminated, suspended, enqueued.
+///
+///  Blocked - The Driver is not on thread and is waiting for an external event.
+///  Next states are terminated, enqueued.
+///
+/// Suspended - The Driver is on thread, 'thread' and 'isSuspended' are set. The
+/// thread does not manipulate the Driver's state and is suspended as in waiting
+/// for memory or out of process IO. This is different from Blocked in that here
+/// we keep the stack so that when the wait is over the control stack is not
+/// lost. Next states are on thread or terminated.
+///
+///  Terminated - 'isTerminated' is set. The Driver cannot run after this and
+/// the state is final.
+///
+/// CancelPool  allows terminating or pausing a set of Drivers. The Task API
+/// allows starting or resuming Drivers. When terminate is requested the request
+/// is successful when all Drivers are off thread, blocked or suspended. When
+/// pause is requested, we have success when all Drivers are either enqueued,
+/// suspended, off thread or blocked.
 struct ThreadState {
-  // The thread currently running this.
+  /// The thread currently running this.
   std::atomic<std::thread::id> thread{std::thread::id()};
-  // The tid of 'thread'. Allows finding the thread in a debugger.
+  /// The tid of 'thread'. Allows finding the thread in a debugger.
   std::atomic<int32_t> tid{0};
-  // True if queued on an executor but not on thread.
+  /// True if queued on an executor but not on thread.
   std::atomic<bool> isEnqueued{false};
-  // True if being terminated or already terminated.
+  /// True if being terminated or already terminated.
   std::atomic<bool> isTerminated{false};
-  // True if there is a future outstanding that will schedule this on an
-  // executor thread when some promise is realized.
+  /// True if there is a future outstanding that will schedule this on an
+  /// executor thread when some promise is realized.
   bool hasBlockingFuture{false};
-  // True if on thread but in a section waiting for RPC or memory
-  // strategy decision. The thread is not supposed to access its
-  // memory, which a third party can revoke while the thread is in
-  // this state.
-  bool isSuspended{false};
+  /// The number of suspension requests on a on-thread driver. If > 0, this
+  /// driver thread is in a (recursive) section waiting for RPC or memory
+  /// strategy decision. The thread is not supposed to access its memory, which
+  /// a third party can revoke while the thread is in this state.
+  std::atomic<uint32_t> numSuspensions{0};
+  /// The start execution time on thread in milliseconds. It is reset when the
+  /// driver goes off thread. This is used to track the time that a driver has
+  /// continuously run on a thread for per-driver cpu time slice enforcement.
+  size_t startExecTimeMs{0};
+  /// The end execution time on thread in milliseconds. It is set when the
+  /// driver goes off thread and reset when the driver gets on a thread.
+  size_t endExecTimeMs{0};
+  /// Total time the driver in pause.
+  uint64_t totalPauseTimeMs{0};
+  /// Total off thread time (including blocked time and pause time).
+  uint64_t totalOffThreadTimeMs{0};
 
   bool isOnThread() const {
     return thread != std::thread::id();
@@ -114,6 +132,11 @@ struct ThreadState {
 
   void setThread() {
     thread = std::this_thread::get_id();
+    startExecTimeMs = getCurrentTimeMs();
+    if (endExecTimeMs != 0) {
+      totalOffThreadTimeMs += startExecTimeMs - endExecTimeMs;
+      endExecTimeMs = 0;
+    }
 #if !defined(__APPLE__)
     // This is a debugging feature disabled on the Mac since syscall
     // is deprecated on that platform.
@@ -123,18 +146,37 @@ struct ThreadState {
 
   void clearThread() {
     thread = std::thread::id(); // no thread.
+    endExecTimeMs = getCurrentTimeMs();
+    RECORD_HISTOGRAM_METRIC_VALUE(
+        kMetricDriverExecTimeMs, (endExecTimeMs - startExecTimeMs));
+    startExecTimeMs = 0;
     tid = 0;
   }
 
-  std::string toJsonString() const {
+  /// Returns the driver execution time on thread. Returns zero if the driver
+  /// is currently not running on thread.
+  size_t execTimeMs() const {
+    if (startExecTimeMs == 0) {
+      VELOX_CHECK(!isOnThread());
+      return 0;
+    }
+    return getCurrentTimeMs() - startExecTimeMs;
+  }
+
+  bool suspended() const {
+    return numSuspensions > 0;
+  }
+
+  folly::dynamic toJson() const {
     folly::dynamic obj = folly::dynamic::object;
     obj["onThread"] = std::to_string(isOnThread());
     obj["tid"] = tid.load();
     obj["isTerminated"] = isTerminated.load();
     obj["isEnqueued"] = isEnqueued.load();
     obj["hasBlockingFuture"] = hasBlockingFuture;
-    obj["isSuspended"] = isSuspended;
-    return folly::toPrettyJson(obj);
+    obj["isSuspended"] = suspended();
+    obj["startExecTime"] = startExecTimeMs;
+    return obj;
   }
 };
 
@@ -162,6 +204,13 @@ enum class BlockingReason {
   /// Build operator is blocked waiting for all its peers to stop to run group
   /// spill on all of them.
   kWaitForSpill,
+  /// Some operators (like Table Scan) may run long loops and can 'voluntarily'
+  /// exit them because Task requested to yield or stop or after a certain time.
+  /// This is the blocking reason used in such cases.
+  kYield,
+  /// Operator is blocked waiting for its associated query memory arbitration to
+  /// finish.
+  kWaitForArbitration,
 };
 
 std::string blockingReasonToString(BlockingReason reason);
@@ -189,7 +238,7 @@ class BlockingState {
   }
 
   /// Moves out the blocking future stored inside. Can be called only once.
-  /// Used in single-threaded execution.
+  /// Used in serial execution mode.
   ContinueFuture future() {
     return std::move(future_);
   }
@@ -224,10 +273,10 @@ struct DriverCtx {
   const uint32_t partitionId;
 
   std::shared_ptr<Task> task;
-  Driver* driver;
+  Driver* driver{nullptr};
   facebook::velox::process::ThreadDebugInfo threadDebugInfo;
 
-  explicit DriverCtx(
+  DriverCtx(
       std::shared_ptr<Task> _task,
       int _driverId,
       int _pipelineId,
@@ -242,6 +291,63 @@ struct DriverCtx {
 
   /// Builds the spill config for the operator with specified 'operatorId'.
   std::optional<common::SpillConfig> makeSpillConfig(int32_t operatorId) const;
+
+  common::PrefixSortConfig prefixSortConfig() const {
+    return common::PrefixSortConfig{
+        queryConfig().prefixSortNormalizedKeyMaxBytes(),
+        queryConfig().prefixSortMinRows()};
+  }
+};
+
+constexpr const char* kOpMethodNone = "";
+constexpr const char* kOpMethodIsBlocked = "isBlocked";
+constexpr const char* kOpMethodNeedsInput = "needsInput";
+constexpr const char* kOpMethodGetOutput = "getOutput";
+constexpr const char* kOpMethodAddInput = "addInput";
+constexpr const char* kOpMethodNoMoreInput = "noMoreInput";
+constexpr const char* kOpMethodIsFinished = "isFinished";
+
+/// Same as the structure below, but does not have atomic members.
+/// Used to return the status from the struct with atomics.
+struct OpCallStatusRaw {
+  /// Time (ms) when the operator call started.
+  size_t timeStartMs{0};
+  /// Id of the operator, method of which is currently running. It is index into
+  /// the vector of Driver's operators.
+  int32_t opId{0};
+  /// Method of the operator, which is currently running.
+  const char* method{kOpMethodNone};
+
+  bool empty() const {
+    return timeStartMs == 0;
+  }
+
+  static std::string formatCall(Operator* op, const char* operatorMethod);
+  size_t callDuration() const;
+};
+
+/// Structure holds the information about the current operator call the driver
+/// is in. Can be used to detect deadlocks and otherwise blocked calls.
+/// If timeStartMs is zero, then we aren't in an operator call.
+struct OpCallStatus {
+  OpCallStatus() {}
+
+  /// The status accessor.
+  OpCallStatusRaw operator()() const {
+    return OpCallStatusRaw{timeStartMs, opId, method};
+  }
+
+  void start(int32_t operatorId, const char* operatorMethod);
+  void stop();
+
+ private:
+  /// Time (ms) when the operator call started.
+  std::atomic_size_t timeStartMs{0};
+  /// Id of the operator, method of which is currently running. It is index into
+  /// the vector of Driver's operators.
+  std::atomic_int32_t opId{0};
+  /// Method of the operator, which is currently running.
+  std::atomic<const char*> method{kOpMethodNone};
 };
 
 class Driver : public std::enable_shared_from_this<Driver> {
@@ -250,7 +356,7 @@ class Driver : public std::enable_shared_from_this<Driver> {
 
   /// Run the pipeline until it produces a batch of data or gets blocked.
   /// Return the data produced or nullptr if pipeline finished processing and
-  /// will not produce more data. Return nullptr and set 'blockingState' if
+  /// will not produce more data. Return nullptr and set 'future' if
   /// pipeline got blocked.
   ///
   /// This API supports execution of a Task synchronously in the caller's
@@ -258,7 +364,7 @@ class Driver : public std::enable_shared_from_this<Driver> {
   /// When using 'enqueue', the last operator in the pipeline (sink) must not
   /// return any data from Operator::getOutput(). When using 'next', the last
   /// operator must produce data that will be returned to caller.
-  RowVectorPtr next(std::shared_ptr<BlockingState>& blockingState);
+  RowVectorPtr next(ContinueFuture* future);
 
   /// Invoked to initialize the operators from this driver once on its first
   /// execution.
@@ -268,6 +374,12 @@ class Driver : public std::enable_shared_from_this<Driver> {
     return state_.isOnThread();
   }
 
+  /// Returns the time in ms since this driver started execution on thread. The
+  /// function returns zero if this driver is off-thread.
+  uint64_t execTimeMs() const {
+    return state_.execTimeMs();
+  }
+
   bool isTerminated() const {
     return state_.isTerminated;
   }
@@ -278,6 +390,15 @@ class Driver : public std::enable_shared_from_this<Driver> {
     return state_;
   }
 
+  /// Returns true if this driver is running on thread and has exceeded the cpu
+  /// time slice limit if set.
+  bool shouldYield() const;
+
+  /// Checks if the associated query is under memory arbitration or not. The
+  /// function returns true if it is and set future which is fulfilled when the
+  /// the memory arbiration finishes.
+  bool checkUnderArbitration(ContinueFuture* future);
+
   void initializeOperatorStats(std::vector<OperatorStats>& stats);
 
   /// Close operators and add operator stats to the task.
@@ -297,15 +418,24 @@ class Driver : public std::enable_shared_from_this<Driver> {
   /// example, hash join probe accesses the corresponding build by id.
   Operator* findOperator(std::string_view planNodeId) const;
 
-  /// Returns the Operator with 'operatorId' or nullptr if not found.
+  /// Returns the Operator with 'operatorId' (basically by index) or throws if
+  /// not found.
   Operator* findOperator(int32_t operatorId) const;
 
+  /// Returns the Operator with 'operatorId' (basically by index) or nullptr if
+  /// not found.
+  Operator* findOperatorNoThrow(int32_t operatorId) const;
+
   /// Returns a list of all operators.
   std::vector<Operator*> operators() const;
 
   std::string toString() const;
 
-  std::string toJsonString() const;
+  folly::dynamic toJson() const;
+
+  OpCallStatusRaw opCallStatus() const {
+    return opCallStatus_();
+  }
 
   DriverCtx* driverCtx() const {
     return ctx_.get();
@@ -323,6 +453,9 @@ class Driver : public std::enable_shared_from_this<Driver> {
     return blockingReason_;
   }
 
+  /// Returns the process-wide number of driver cpu yields.
+  static std::atomic_uint64_t& yieldCount();
+
   static std::shared_ptr<Driver> testingCreate(
       std::unique_ptr<DriverCtx> ctx = nullptr) {
     auto driver = new Driver();
@@ -334,8 +467,39 @@ class Driver : public std::enable_shared_from_this<Driver> {
   }
 
  private:
+  // Ensures that the thread is removed from its Task's thread count on exit.
+  class CancelGuard {
+   public:
+    CancelGuard(
+        const std::shared_ptr<Driver>& driver,
+        Task* task,
+        ThreadState* state,
+        std::function<void(StopReason)> onTerminate)
+        : driver_(driver),
+          task_(task),
+          state_(state),
+          onTerminate_(std::move(onTerminate)) {}
+
+    void notThrown() {
+      isThrow_ = false;
+    }
+
+    ~CancelGuard();
+
+   private:
+    std::shared_ptr<Driver> const driver_;
+    Task* const task_;
+    ThreadState* const state_;
+    const std::function<void(StopReason reason)> onTerminate_;
+
+    bool isThrow_{true};
+  };
+
   Driver() = default;
 
+  // Invoked to record the driver cpu yield count.
+  static void recordYieldCount();
+
   void init(
       std::unique_ptr<DriverCtx> driverCtx,
       std::vector<std::unique_ptr<Operator>> operators);
@@ -349,22 +513,20 @@ class Driver : public std::enable_shared_from_this<Driver> {
       std::shared_ptr<BlockingState>& blockingState,
       RowVectorPtr& result);
 
+  void updateStats();
+
   void close();
 
   // Push down dynamic filters produced by the operator at the specified
   // position in the pipeline.
   void pushdownFilters(int operatorIndex);
 
-  // If 'trackOperatorCpuUsage_' is true, returns initialized timer object to
-  // track cpu and wall time of an operation. Returns null otherwise.
-  // The delta CpuWallTiming object would be passes to 'func' upon
-  // destruction of the timer.
-  template <typename F>
-  std::unique_ptr<DeltaCpuWallTimer<F>> createDeltaCpuWallTimer(F&& func) {
-    return trackOperatorCpuUsage_
-        ? std::make_unique<DeltaCpuWallTimer<F>>(std::move(func))
-        : nullptr;
-  }
+  using TimingMemberPtr = CpuWallTiming OperatorStats::*;
+  template <typename Func>
+  void withDeltaCpuWallTimer(
+      Operator* op,
+      TimingMemberPtr opTimingMember,
+      Func&& opFunction);
 
   // Adjusts 'timing' by removing the lazy load wall and CPU times
   // accrued since last time timing information was recorded for
@@ -374,25 +536,42 @@ class Driver : public std::enable_shared_from_this<Driver> {
   // but these do not bias the op's timing.
   CpuWallTiming processLazyTiming(Operator& op, const CpuWallTiming& timing);
 
+  inline void validateOperatorOutputResult(
+      const RowVectorPtr& result,
+      const Operator& op);
+
+  inline StopReason blockDriver(
+      const std::shared_ptr<Driver>& self,
+      size_t blockedOperatorId,
+      ContinueFuture&& future,
+      std::shared_ptr<BlockingState>& blockingState,
+      CancelGuard& guard);
+
   std::unique_ptr<DriverCtx> ctx_;
 
+  // If not zero, specifies the driver cpu time slice.
+  size_t cpuSliceMs_{0};
+
   bool operatorsInitialized_{false};
 
   std::atomic_bool closed_{false};
 
+  OpCallStatus opCallStatus_;
+
   // Set via Task and serialized by Task's mutex.
   ThreadState state_;
 
   // Timer used to track down the time we are sitting in the driver queue.
-  size_t queueTimeStartMicros_{0};
-  // Index of the current operator to run (or the 1st one if we haven't
-  // started yet). Used to determine which operator's queueTime we should
-  // update.
-  size_t curOpIndex_{0};
+  size_t queueTimeStartUs_{0};
+  // Id (index in the vector) of the current operator to run (or the 1st one if
+  // we haven't started yet). Used to determine which operator's queueTime we
+  // should update.
+  size_t curOperatorId_{0};
 
   std::vector<std::unique_ptr<Operator>> operators_;
 
   BlockingReason blockingReason_{BlockingReason::kNotBlocked};
+  size_t blockedOperatorId_{0};
 
   bool trackOperatorCpuUsage_;
 
@@ -469,7 +648,7 @@ struct DriverFactory {
 
   static void registerAdapter(DriverAdapter adapter);
 
-  bool supportsSingleThreadedExecution() const {
+  bool supportsSerialExecution() const {
     return !needsPartitionedOutput() && !needsExchangeClient() &&
         !needsLocalExchange();
   }
@@ -570,3 +749,12 @@ class ScopedDriverThreadContext {
 DriverThreadContext* driverThreadContext();
 
 } // namespace facebook::velox::exec
+
+template <>
+struct fmt::formatter<facebook::velox::exec::StopReason>
+    : formatter<std::string> {
+  auto format(facebook::velox::exec::StopReason s, format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::exec::stopReasonString(s), ctx);
+  }
+};
diff --git a/velox/exec/EnforceSingleRow.cpp b/velox/exec/EnforceSingleRow.cpp
index ee6fc53ebf79f..85d629431fc3f 100644
--- a/velox/exec/EnforceSingleRow.cpp
+++ b/velox/exec/EnforceSingleRow.cpp
@@ -33,7 +33,7 @@ EnforceSingleRow::EnforceSingleRow(
 void EnforceSingleRow::addInput(RowVectorPtr input) {
   auto numInput = input->size();
   VELOX_CHECK_NE(
-      numInput, 0, "EnforceSingleRow::addInput received empty set of rows")
+      numInput, 0, "EnforceSingleRow::addInput received empty set of rows");
   if (input_ == nullptr) {
     VELOX_USER_CHECK_EQ(
         numInput,
diff --git a/velox/exec/Exchange.cpp b/velox/exec/Exchange.cpp
index 7599f115b1b16..7551764f06dde 100644
--- a/velox/exec/Exchange.cpp
+++ b/velox/exec/Exchange.cpp
@@ -18,6 +18,14 @@
 
 namespace facebook::velox::exec {
 
+void Exchange::addTaskIds(std::vector<std::string>& taskIds) {
+  std::shuffle(std::begin(taskIds), std::end(taskIds), rng_);
+  for (const std::string& taskId : taskIds) {
+    exchangeClient_->addRemoteTaskId(taskId);
+  }
+  stats_.wlock()->numSplits += taskIds.size();
+}
+
 bool Exchange::getSplits(ContinueFuture* future) {
   if (!processSplits_) {
     return false;
@@ -25,6 +33,7 @@ bool Exchange::getSplits(ContinueFuture* future) {
   if (noMoreSplits_) {
     return false;
   }
+  std::vector<std::string> taskIds;
   for (;;) {
     exec::Split split;
     auto reason = operatorCtx_->task()->getSplitOrFuture(
@@ -34,26 +43,27 @@ bool Exchange::getSplits(ContinueFuture* future) {
         auto remoteSplit = std::dynamic_pointer_cast<RemoteConnectorSplit>(
             split.connectorSplit);
         VELOX_CHECK(remoteSplit, "Wrong type of split");
-        exchangeClient_->addRemoteTaskId(remoteSplit->taskId);
-        ++stats_.wlock()->numSplits;
+        taskIds.push_back(remoteSplit->taskId);
       } else {
+        addTaskIds(taskIds);
         exchangeClient_->noMoreRemoteTasks();
         noMoreSplits_ = true;
         if (atEnd_) {
           operatorCtx_->task()->multipleSplitsFinished(
-              stats_.rlock()->numSplits);
+              false, stats_.rlock()->numSplits, 0);
           recordExchangeClientStats();
         }
         return false;
       }
     } else {
+      addTaskIds(taskIds);
       return true;
     }
   }
 }
 
 BlockingReason Exchange::isBlocked(ContinueFuture* future) {
-  if (currentPage_ || atEnd_) {
+  if (!currentPages_.empty() || atEnd_) {
     return BlockingReason::kNotBlocked;
   }
 
@@ -64,12 +74,16 @@ BlockingReason Exchange::isBlocked(ContinueFuture* future) {
     getSplits(&splitFuture_);
   }
 
+  const auto maxBytes = getSerde()->supportsAppendInDeserialize()
+      ? preferredOutputBatchBytes_
+      : 1;
+
   ContinueFuture dataFuture;
-  currentPage_ = exchangeClient_->next(&atEnd_, &dataFuture);
-  if (currentPage_ || atEnd_) {
+  currentPages_ = exchangeClient_->next(maxBytes, &atEnd_, &dataFuture);
+  if (!currentPages_.empty() || atEnd_) {
     if (atEnd_ && noMoreSplits_) {
       const auto numSplits = stats_.rlock()->numSplits;
-      operatorCtx_->task()->multipleSplitsFinished(numSplits);
+      operatorCtx_->task()->multipleSplitsFinished(false, numSplits, 0);
     }
     recordExchangeClientStats();
     return BlockingReason::kNotBlocked;
@@ -92,41 +106,48 @@ BlockingReason Exchange::isBlocked(ContinueFuture* future) {
 }
 
 bool Exchange::isFinished() {
-  return atEnd_;
+  return atEnd_ && currentPages_.empty();
 }
 
 RowVectorPtr Exchange::getOutput() {
-  if (!currentPage_) {
+  if (currentPages_.empty()) {
     return nullptr;
   }
 
   uint64_t rawInputBytes{0};
-  if (!inputStream_) {
-    inputStream_ = std::make_unique<ByteStream>();
-    rawInputBytes += currentPage_->size();
-    currentPage_->prepareStreamForDeserialize(inputStream_.get());
+  vector_size_t resultOffset = 0;
+  for (const auto& page : currentPages_) {
+    rawInputBytes += page->size();
+
+    auto inputStream = page->prepareStreamForDeserialize();
+
+    while (!inputStream->atEnd()) {
+      getSerde()->deserialize(
+          inputStream.get(),
+          pool(),
+          outputType_,
+          &result_,
+          resultOffset,
+          &options_);
+      resultOffset = result_->size();
+    }
   }
 
-  getSerde()->deserialize(
-      inputStream_.get(), operatorCtx_->pool(), outputType_, &result_);
+  currentPages_.clear();
 
   {
     auto lockedStats = stats_.wlock();
     lockedStats->rawInputBytes += rawInputBytes;
+    lockedStats->rawInputPositions += result_->size();
     lockedStats->addInputVector(result_->estimateFlatSize(), result_->size());
   }
 
-  if (inputStream_->atEnd()) {
-    currentPage_ = nullptr;
-    inputStream_ = nullptr;
-  }
-
   return result_;
 }
 
 void Exchange::close() {
   SourceOperator::close();
-  currentPage_ = nullptr;
+  currentPages_.clear();
   result_ = nullptr;
   if (exchangeClient_) {
     recordExchangeClientStats();
@@ -142,7 +163,7 @@ void Exchange::recordExchangeClientStats() {
 
   auto lockedStats = stats_.wlock();
   const auto exchangeClientStats = exchangeClient_->stats();
-  for (const auto& [name, value] : exchangeClient_->stats()) {
+  for (const auto& [name, value] : exchangeClientStats) {
     lockedStats->runtimeStats.erase(name);
     lockedStats->runtimeStats.insert({name, value});
   }
diff --git a/velox/exec/Exchange.h b/velox/exec/Exchange.h
index e3014a319c79d..dea346773355a 100644
--- a/velox/exec/Exchange.h
+++ b/velox/exec/Exchange.h
@@ -15,8 +15,12 @@
  */
 #pragma once
 
+#include <algorithm>
+#include <random>
 #include "velox/exec/ExchangeClient.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/OutputBufferManager.h"
+#include "velox/serializers/PrestoSerializer.h"
 
 namespace facebook::velox::exec {
 
@@ -35,18 +39,23 @@ class Exchange : public SourceOperator {
  public:
   Exchange(
       int32_t operatorId,
-      DriverCtx* ctx,
+      DriverCtx* driverCtx,
       const std::shared_ptr<const core::ExchangeNode>& exchangeNode,
       std::shared_ptr<ExchangeClient> exchangeClient,
       const std::string& operatorType = "Exchange")
       : SourceOperator(
-            ctx,
+            driverCtx,
             exchangeNode->outputType(),
             operatorId,
             exchangeNode->id(),
             operatorType),
+        preferredOutputBatchBytes_{
+            driverCtx->queryConfig().preferredOutputBatchBytes()},
         processSplits_{operatorCtx_->driverCtx()->driverId == 0},
-        exchangeClient_{std::move(exchangeClient)} {}
+        exchangeClient_{std::move(exchangeClient)} {
+    options_.compressionKind =
+        OutputBufferManager::getInstance().lock()->compressionKind();
+  }
 
   ~Exchange() override {
     close();
@@ -64,6 +73,12 @@ class Exchange : public SourceOperator {
   virtual VectorSerde* getSerde();
 
  private:
+  // Invoked to create exchange client for remote tasks.
+  // The function shuffles the source task ids first to randomize the source
+  // tasks we fetch data from. This helps to avoid different tasks fetching from
+  // the same source task in a distributed system.
+  void addTaskIds(std::vector<std::string>& taskIds);
+
   /// Fetches splits from the task until there are no more splits or task
   /// returns a future that will be complete when more splits arrive. Adds
   /// splits to exchangeClient_. Returns true if received a future from the task
@@ -77,6 +92,8 @@ class Exchange : public SourceOperator {
   /// operator's stats.
   void recordExchangeClientStats();
 
+  const uint64_t preferredOutputBatchBytes_;
+
   /// True if this operator is responsible for fetching splits from the Task and
   /// passing these to ExchangeClient.
   const bool processSplits_;
@@ -86,11 +103,14 @@ class Exchange : public SourceOperator {
   /// there are more splits available or no-more-splits signal has arrived.
   ContinueFuture splitFuture_{ContinueFuture::makeEmpty()};
 
+  // Reusable result vector.
   RowVectorPtr result_;
+
   std::shared_ptr<ExchangeClient> exchangeClient_;
-  std::unique_ptr<SerializedPage> currentPage_;
-  std::unique_ptr<ByteStream> inputStream_;
+  std::vector<std::unique_ptr<SerializedPage>> currentPages_;
   bool atEnd_{false};
+  std::default_random_engine rng_{std::random_device{}()};
+  serializer::presto::PrestoVectorSerde::PrestoOptions options_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/ExchangeClient.cpp b/velox/exec/ExchangeClient.cpp
index 37dadf4299446..98d4369582b2c 100644
--- a/velox/exec/ExchangeClient.cpp
+++ b/velox/exec/ExchangeClient.cpp
@@ -15,15 +15,18 @@
  */
 #include "velox/exec/ExchangeClient.h"
 
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+
 namespace facebook::velox::exec {
 
 void ExchangeClient::addRemoteTaskId(const std::string& taskId) {
-  RequestSpec requestSpec;
+  std::vector<RequestSpec> requestSpecs;
   std::shared_ptr<ExchangeSource> toClose;
   {
     std::lock_guard<std::mutex> l(queue_->mutex());
 
-    bool duplicate = !taskIds_.insert(taskId).second;
+    bool duplicate = !remoteTaskIds_.insert(taskId).second;
     if (duplicate) {
       // Do not add sources twice. Presto protocol may add duplicate sources
       // and the task updates have no guarantees of arriving in order.
@@ -33,7 +36,7 @@ void ExchangeClient::addRemoteTaskId(const std::string& taskId) {
     std::shared_ptr<ExchangeSource> source;
     try {
       source = ExchangeSource::create(taskId, destination_, queue_, pool_);
-    } catch (const VeloxException& e) {
+    } catch (const VeloxException&) {
       throw;
     } catch (const std::exception& e) {
       // Task ID can be very long. Truncate to 128 characters.
@@ -48,11 +51,8 @@ void ExchangeClient::addRemoteTaskId(const std::string& taskId) {
     } else {
       sources_.push_back(source);
       queue_->addSourceLocked();
-      // Put new source into 'producingSources_' queue to prioritise fetching
-      // from these to find out whether these are productive or not.
-      producingSources_.push(source);
-
-      requestSpec = pickSourcesToRequestLocked();
+      emptySources_.push(source);
+      requestSpecs = pickSourcesToRequestLocked();
     }
   }
 
@@ -60,7 +60,7 @@ void ExchangeClient::addRemoteTaskId(const std::string& taskId) {
   if (toClose) {
     toClose->close();
   } else {
-    request(requestSpec);
+    request(std::move(requestSpecs));
   }
 }
 
@@ -91,8 +91,17 @@ folly::F14FastMap<std::string, RuntimeMetric> ExchangeClient::stats() const {
 
   folly::F14FastMap<std::string, RuntimeMetric> stats;
   for (const auto& source : sources_) {
-    for (const auto& [name, value] : source->stats()) {
-      stats[name].addValue(value);
+    if (source->supportsMetrics()) {
+      for (const auto& [name, value] : source->metrics()) {
+        if (UNLIKELY(stats.count(name) == 0)) {
+          stats.insert(std::pair(name, RuntimeMetric(value.unit)));
+        }
+        stats[name].merge(value);
+      }
+    } else {
+      for (const auto& [name, value] : source->stats()) {
+        stats[name].addValue(value);
+      }
     }
   }
 
@@ -105,147 +114,153 @@ folly::F14FastMap<std::string, RuntimeMetric> ExchangeClient::stats() const {
   return stats;
 }
 
-std::unique_ptr<SerializedPage> ExchangeClient::next(
-    bool* atEnd,
-    ContinueFuture* future) {
-  RequestSpec requestSpec;
-  std::unique_ptr<SerializedPage> page;
+std::vector<std::unique_ptr<SerializedPage>>
+ExchangeClient::next(uint32_t maxBytes, bool* atEnd, ContinueFuture* future) {
+  std::vector<RequestSpec> requestSpecs;
+  std::vector<std::unique_ptr<SerializedPage>> pages;
   {
     std::lock_guard<std::mutex> l(queue_->mutex());
+    if (closed_) {
+      *atEnd = true;
+      return pages;
+    }
+
     *atEnd = false;
-    page = queue_->dequeueLocked(atEnd, future);
+    pages = queue_->dequeueLocked(maxBytes, atEnd, future);
     if (*atEnd) {
-      return page;
+      return pages;
     }
 
-    if (page && queue_->totalBytes() > maxQueuedBytes_) {
-      return page;
+    if (!pages.empty() && queue_->totalBytes() > maxQueuedBytes_) {
+      return pages;
     }
 
-    requestSpec = pickSourcesToRequestLocked();
+    requestSpecs = pickSourcesToRequestLocked();
   }
 
   // Outside of lock
-  request(requestSpec);
-  return page;
+  request(std::move(requestSpecs));
+  return pages;
 }
 
-void ExchangeClient::request(const RequestSpec& requestSpec) {
-  auto& exec = folly::QueuedImmediateExecutor::instance();
-  for (auto& source : requestSpec.sources) {
-    if (source->supportsFlowControlV2()) {
-      auto future =
-          source->request(requestSpec.maxBytes, kDefaultMaxWaitSeconds);
-      VELOX_CHECK(future.valid());
-      std::move(future)
-          .via(&exec)
-          .thenValue([this, requestSource = source](auto&& response) {
-            RequestSpec requestSpec;
-            {
-              std::lock_guard<std::mutex> l(queue_->mutex());
-              if (!response.atEnd) {
-                if (response.bytes > 0) {
-                  producingSources_.push(requestSource);
-                } else {
-                  emptySources_.push(requestSource);
+void ExchangeClient::request(std::vector<RequestSpec>&& requestSpecs) {
+  auto self = shared_from_this();
+  for (auto& spec : requestSpecs) {
+    auto future = folly::SemiFuture<ExchangeSource::Response>::makeEmpty();
+    if (spec.maxBytes == 0) {
+      future = spec.source->requestDataSizes(kRequestDataSizesMaxWait);
+    } else {
+      future = spec.source->request(spec.maxBytes, kRequestDataMaxWait);
+    }
+    VELOX_CHECK(future.valid());
+    std::move(future)
+        .via(executor_)
+        .thenValue([self,
+                    spec = std::move(spec),
+                    sendTimeMs = getCurrentTimeMs()](auto&& response) {
+          const auto requestTimeMs = getCurrentTimeMs() - sendTimeMs;
+          if (spec.maxBytes == 0) {
+            RECORD_HISTOGRAM_METRIC_VALUE(
+                kMetricExchangeDataSizeTimeMs, requestTimeMs);
+            RECORD_METRIC_VALUE(kMetricExchangeDataSizeCount);
+          } else {
+            RECORD_HISTOGRAM_METRIC_VALUE(
+                kMetricExchangeDataTimeMs, requestTimeMs);
+            RECORD_METRIC_VALUE(kMetricExchangeDataBytes, response.bytes);
+            RECORD_HISTOGRAM_METRIC_VALUE(
+                kMetricExchangeDataSize, response.bytes);
+            RECORD_METRIC_VALUE(kMetricExchangeDataCount);
+          }
+
+          bool pauseCurrentSource = false;
+          std::vector<RequestSpec> requestSpecs;
+          std::shared_ptr<ExchangeSource> currentSource = spec.source;
+          {
+            std::lock_guard<std::mutex> l(self->queue_->mutex());
+            if (self->closed_) {
+              return;
+            }
+            if (!response.atEnd) {
+              if (!response.remainingBytes.empty()) {
+                for (auto bytes : response.remainingBytes) {
+                  VELOX_CHECK_GT(bytes, 0);
                 }
+                self->producingSources_.push(
+                    {std::move(spec.source),
+                     std::move(response.remainingBytes)});
+              } else {
+                self->emptySources_.push(std::move(spec.source));
               }
-              requestSpec = pickSourcesToRequestLocked();
             }
-            request(requestSpec);
-          })
-          .thenError(
-              folly::tag_t<std::exception>{},
-              [&](const std::exception& e) { queue_->setError(e.what()); });
-    } else {
-      auto future = source->request(requestSpec.maxBytes);
-      VELOX_CHECK(future.valid());
-      std::move(future)
-          .via(&exec)
-          .thenValue([this, requestSource = source](auto&& /*unused*/) {
-            RequestSpec requestSpec;
-            {
-              std::lock_guard<std::mutex> l(queue_->mutex());
-              emptySources_.push(requestSource);
-              requestSpec = pickSourcesToRequestLocked();
-            }
-            request(requestSpec);
-          })
-          .thenError(
-              folly::tag_t<std::exception>{},
-              [&](const std::exception& e) { queue_->setError(e.what()); });
-    }
+            self->totalPendingBytes_ -= spec.maxBytes;
+            requestSpecs = self->pickSourcesToRequestLocked();
+            pauseCurrentSource =
+                std::find_if(
+                    requestSpecs.begin(),
+                    requestSpecs.end(),
+                    [&currentSource](const RequestSpec& spec) -> bool {
+                      return spec.source.get() == currentSource.get();
+                    }) == requestSpecs.end();
+          }
+          if (pauseCurrentSource) {
+            currentSource->pause();
+          }
+          self->request(std::move(requestSpecs));
+        })
+        .thenError(
+            folly::tag_t<std::exception>{}, [self](const std::exception& e) {
+              self->queue_->setError(e.what());
+            });
   }
 }
 
-int32_t ExchangeClient::countPendingSourcesLocked() {
-  int32_t numPending = 0;
-  for (auto& source : sources_) {
-    if (source->isRequestPendingLocked()) {
-      ++numPending;
-    }
-  }
-  return numPending;
-}
-
-int64_t ExchangeClient::getAveragePageSize() {
-  auto averagePageSize =
-      std::min<int64_t>(maxQueuedBytes_, queue_->averageReceivedPageBytes());
-  if (averagePageSize == 0) {
-    averagePageSize = 1 << 20; // 1 MB.
+std::vector<ExchangeClient::RequestSpec>
+ExchangeClient::pickSourcesToRequestLocked() {
+  if (closed_) {
+    return {};
   }
-
-  return averagePageSize;
-}
-
-int32_t ExchangeClient::getNumSourcesToRequestLocked(int64_t averagePageSize) {
-  // Figure out how many more 'averagePageSize' fit into 'maxQueuedBytes_'.
-  // Make sure to leave room for 'numPending' pages.
-  const auto numPending = countPendingSourcesLocked();
-
-  auto numToRequest = std::max<int32_t>(
-      1, (maxQueuedBytes_ - queue_->totalBytes()) / averagePageSize);
-  if (numToRequest <= numPending) {
-    return 0;
+  std::vector<RequestSpec> requestSpecs;
+  while (!emptySources_.empty()) {
+    auto& source = emptySources_.front();
+    VELOX_CHECK(source->shouldRequestLocked());
+    requestSpecs.push_back({std::move(source), 0});
+    emptySources_.pop();
   }
-
-  return numToRequest - numPending;
-}
-
-void ExchangeClient::pickSourcesToRequestLocked(
-    RequestSpec& requestSpec,
-    int32_t numToRequest,
-    std::queue<std::shared_ptr<ExchangeSource>>& sources) {
-  while (requestSpec.sources.size() < numToRequest && !sources.empty()) {
-    auto& source = sources.front();
-    if (source->shouldRequestLocked()) {
-      requestSpec.sources.push_back(source);
+  int64_t availableSpace =
+      maxQueuedBytes_ - queue_->totalBytes() - totalPendingBytes_;
+  while (availableSpace > 0 && !producingSources_.empty()) {
+    auto& source = producingSources_.front().source;
+    int64_t requestBytes = 0;
+    for (auto bytes : producingSources_.front().remainingBytes) {
+      availableSpace -= bytes;
+      if (availableSpace < 0) {
+        break;
+      }
+      requestBytes += bytes;
     }
-    sources.pop();
-  }
-}
-
-ExchangeClient::RequestSpec ExchangeClient::pickSourcesToRequestLocked() {
-  if (closed_ || queue_->totalBytes() >= maxQueuedBytes_) {
-    return {};
+    if (requestBytes == 0) {
+      VELOX_CHECK_LT(availableSpace, 0);
+      break;
+    }
+    VELOX_CHECK(source->shouldRequestLocked());
+    requestSpecs.push_back({std::move(source), requestBytes});
+    producingSources_.pop();
+    totalPendingBytes_ += requestBytes;
   }
-
-  const auto averagePageSize = getAveragePageSize();
-  const auto numToRequest = getNumSourcesToRequestLocked(averagePageSize);
-
-  if (numToRequest == 0) {
-    return {};
+  if (queue_->totalBytes() == 0 && totalPendingBytes_ == 0 &&
+      !producingSources_.empty()) {
+    // We have full capacity but still cannot initiate one single data transfer.
+    // Let the transfer happen in this case to avoid getting stuck.
+    auto& source = producingSources_.front().source;
+    auto requestBytes = producingSources_.front().remainingBytes.at(0);
+    LOG(INFO) << "Requesting large single page " << requestBytes
+              << " bytes, exceeding capacity " << maxQueuedBytes_;
+    VELOX_CHECK(source->shouldRequestLocked());
+    requestSpecs.push_back({std::move(source), requestBytes});
+    producingSources_.pop();
+    totalPendingBytes_ += requestBytes;
   }
-
-  RequestSpec requestSpec;
-  requestSpec.maxBytes = averagePageSize;
-
-  // Pick up to 'numToRequest' next sources to request data from. Prioritize
-  // sources that return data.
-  pickSourcesToRequestLocked(requestSpec, numToRequest, producingSources_);
-  pickSourcesToRequestLocked(requestSpec, numToRequest, emptySources_);
-
-  return requestSpec;
+  return requestSpecs;
 }
 
 ExchangeClient::~ExchangeClient() {
@@ -260,16 +275,17 @@ std::string ExchangeClient::toString() const {
   return out.str();
 }
 
-std::string ExchangeClient::toJsonString() const {
+folly::dynamic ExchangeClient::toJson() const {
   folly::dynamic obj = folly::dynamic::object;
   obj["taskId"] = taskId_;
   obj["closed"] = closed_;
   folly::dynamic clientsObj = folly::dynamic::object;
   int index = 0;
   for (auto& source : sources_) {
-    clientsObj[std::to_string(index++)] = source->toJsonString();
+    clientsObj[std::to_string(index++)] = source->toJson();
   }
-  return folly::toPrettyJson(obj);
+  obj["clients"] = clientsObj;
+  return obj;
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/ExchangeClient.h b/velox/exec/ExchangeClient.h
index 2f714e0285709..29bc3b884fdd9 100644
--- a/velox/exec/ExchangeClient.h
+++ b/velox/exec/ExchangeClient.h
@@ -15,7 +15,6 @@
  */
 #pragma once
 
-#include "velox/common/base/RuntimeMetrics.h"
 #include "velox/exec/ExchangeQueue.h"
 #include "velox/exec/ExchangeSource.h"
 
@@ -23,23 +22,36 @@ namespace facebook::velox::exec {
 
 // Handle for a set of producers. This may be shared by multiple Exchanges, one
 // per consumer thread.
-class ExchangeClient {
+class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
  public:
   static constexpr int32_t kDefaultMaxQueuedBytes = 32 << 20; // 32 MB.
-  static constexpr int32_t kDefaultMaxWaitSeconds = 2;
+  static constexpr std::chrono::seconds kRequestDataSizesMaxWait{10};
+  static constexpr std::chrono::milliseconds kRequestDataMaxWait{100};
   static inline const std::string kBackgroundCpuTimeMs = "backgroundCpuTimeMs";
 
   ExchangeClient(
       std::string taskId,
       int destination,
+      int64_t maxQueuedBytes,
       memory::MemoryPool* pool,
-      int64_t maxQueuedBytes)
+      folly::Executor* executor)
       : taskId_{std::move(taskId)},
         destination_(destination),
         maxQueuedBytes_{maxQueuedBytes},
         pool_(pool),
+        executor_(executor),
         queue_(std::make_shared<ExchangeQueue>()) {
     VELOX_CHECK_NOT_NULL(pool_);
+    VELOX_CHECK_NOT_NULL(executor_);
+    // NOTE: the executor is used to run async response callback from the
+    // exchange source. The provided executor must not be
+    // folly::InlineLikeExecutor, otherwise it might cause potential deadlock as
+    // the response callback in exchange client might call back into the
+    // exchange source under uncertain execution context. For instance, the
+    // exchange client might inline close the exchange source from a background
+    // thread of the exchange source, and the close needs to wait for this
+    // background thread to complete first.
+    VELOX_CHECK_NULL(dynamic_cast<const folly::InlineLikeExecutor*>(executor_));
     VELOX_CHECK_GE(
         destination, 0, "Exchange client destination must not be negative");
   }
@@ -66,52 +78,61 @@ class ExchangeClient {
   // runtime metric named ExchangeClient::kBackgroundCpuTimeMs.
   folly::F14FastMap<std::string, RuntimeMetric> stats() const;
 
-  std::shared_ptr<ExchangeQueue> queue() const {
+  const std::shared_ptr<ExchangeQueue>& queue() const {
     return queue_;
   }
 
-  std::unique_ptr<SerializedPage> next(bool* atEnd, ContinueFuture* future);
+  /// Returns up to 'maxBytes' pages of data, but no less than one.
+  ///
+  /// If no data is available returns empty list and sets 'atEnd' to true if no
+  /// more data is expected. If data is still expected, sets 'atEnd' to false
+  /// and sets 'future' to a Future that will complete when data arrives.
+  ///
+  /// The data may be compressed, in which case 'maxBytes' applies to compressed
+  /// size.
+  std::vector<std::unique_ptr<SerializedPage>>
+  next(uint32_t maxBytes, bool* atEnd, ContinueFuture* future);
 
   std::string toString() const;
 
-  std::string toJsonString() const;
+  folly::dynamic toJson() const;
 
  private:
-  // A list of sources to request data from and how much to request from each
-  // (in bytes).
   struct RequestSpec {
-    std::vector<std::shared_ptr<ExchangeSource>> sources;
+    std::shared_ptr<ExchangeSource> source;
+
+    // How much bytes to request from this source.  0 bytes means request data
+    // sizes only.
     int64_t maxBytes;
   };
 
-  int64_t getAveragePageSize();
-
-  int32_t getNumSourcesToRequestLocked(int64_t averagePageSize);
-
-  RequestSpec pickSourcesToRequestLocked();
-
-  void pickSourcesToRequestLocked(
-      RequestSpec& requestSpec,
-      int32_t numToRequest,
-      std::queue<std::shared_ptr<ExchangeSource>>& sources);
+  struct ProducingSource {
+    std::shared_ptr<ExchangeSource> source;
+    std::vector<int64_t> remainingBytes;
+  };
 
-  int32_t countPendingSourcesLocked();
+  std::vector<RequestSpec> pickSourcesToRequestLocked();
 
-  void request(const RequestSpec& requestSpec);
+  void request(std::vector<RequestSpec>&& requestSpecs);
 
   // Handy for ad-hoc logging.
   const std::string taskId_;
   const int destination_;
   const int64_t maxQueuedBytes_;
   memory::MemoryPool* const pool_;
-  std::shared_ptr<ExchangeQueue> queue_;
-  std::unordered_set<std::string> taskIds_;
+  folly::Executor* const executor_;
+  const std::shared_ptr<ExchangeQueue> queue_;
+
+  std::unordered_set<std::string> remoteTaskIds_;
   std::vector<std::shared_ptr<ExchangeSource>> sources_;
   bool closed_{false};
 
+  // Total number of bytes in flight.
+  int64_t totalPendingBytes_{0};
+
   // A queue of sources that have returned non-empty response from the latest
   // request.
-  std::queue<std::shared_ptr<ExchangeSource>> producingSources_;
+  std::queue<ProducingSource> producingSources_;
   // A queue of sources that returned empty response from the latest request.
   std::queue<std::shared_ptr<ExchangeSource>> emptySources_;
 };
diff --git a/velox/exec/ExchangeQueue.cpp b/velox/exec/ExchangeQueue.cpp
index 1b09a68b252c9..f19745191d477 100644
--- a/velox/exec/ExchangeQueue.cpp
+++ b/velox/exec/ExchangeQueue.cpp
@@ -19,9 +19,11 @@ namespace facebook::velox::exec {
 
 SerializedPage::SerializedPage(
     std::unique_ptr<folly::IOBuf> iobuf,
-    std::function<void(folly::IOBuf&)> onDestructionCb)
+    std::function<void(folly::IOBuf&)> onDestructionCb,
+    std::optional<int64_t> numRows)
     : iobuf_(std::move(iobuf)),
       iobufBytes_(chainBytes(*iobuf_.get())),
+      numRows_(numRows),
       onDestructionCb_(onDestructionCb) {
   VELOX_CHECK_NOT_NULL(iobuf_);
   for (auto& buf : *iobuf_) {
@@ -39,8 +41,8 @@ SerializedPage::~SerializedPage() {
   }
 }
 
-void SerializedPage::prepareStreamForDeserialize(ByteStream* input) {
-  input->resetInput(std::move(ranges_));
+std::unique_ptr<ByteInputStream> SerializedPage::prepareStreamForDeserialize() {
+  return std::make_unique<BufferInputStream>(std::move(ranges_));
 }
 
 void ExchangeQueue::noMoreSources() {
@@ -91,29 +93,42 @@ void ExchangeQueue::enqueueLocked(
   }
 }
 
-std::unique_ptr<SerializedPage> ExchangeQueue::dequeueLocked(
+std::vector<std::unique_ptr<SerializedPage>> ExchangeQueue::dequeueLocked(
+    uint32_t maxBytes,
     bool* atEnd,
     ContinueFuture* future) {
-  VELOX_CHECK(future);
+  VELOX_CHECK_NOT_NULL(future);
   if (!error_.empty()) {
     *atEnd = true;
     VELOX_FAIL(error_);
   }
-  if (queue_.empty()) {
-    if (atEnd_) {
-      *atEnd = true;
-    } else {
-      promises_.emplace_back("ExchangeQueue::dequeue");
-      *future = promises_.back().getSemiFuture();
-      *atEnd = false;
+
+  *atEnd = false;
+
+  std::vector<std::unique_ptr<SerializedPage>> pages;
+  uint32_t pageBytes = 0;
+  for (;;) {
+    if (queue_.empty()) {
+      if (atEnd_) {
+        *atEnd = true;
+      } else if (pages.empty()) {
+        promises_.emplace_back("ExchangeQueue::dequeue");
+        *future = promises_.back().getSemiFuture();
+      }
+      return pages;
+    }
+
+    if (pageBytes > 0 && pageBytes + queue_.front()->size() > maxBytes) {
+      return pages;
     }
-    return nullptr;
+
+    pages.emplace_back(std::move(queue_.front()));
+    queue_.pop_front();
+    pageBytes += pages.back()->size();
+    totalBytes_ -= pages.back()->size();
   }
-  auto page = std::move(queue_.front());
-  queue_.pop_front();
-  *atEnd = false;
-  totalBytes_ -= page->size();
-  return page;
+
+  VELOX_UNREACHABLE();
 }
 
 void ExchangeQueue::setError(const std::string& error) {
diff --git a/velox/exec/ExchangeQueue.h b/velox/exec/ExchangeQueue.h
index cc1b52e823e4c..91e3a663aa06c 100644
--- a/velox/exec/ExchangeQueue.h
+++ b/velox/exec/ExchangeQueue.h
@@ -19,25 +19,30 @@
 
 namespace facebook::velox::exec {
 
-// Corresponds to Presto SerializedPage, i.e. a container for
-// serialize vectors in Presto wire format.
+/// Corresponds to Presto SerializedPage, i.e. a container for serialize vectors
+/// in Presto wire format.
 class SerializedPage {
  public:
-  // Construct from IOBuf chain.
+  /// Construct from IOBuf chain.
   explicit SerializedPage(
       std::unique_ptr<folly::IOBuf> iobuf,
-      std::function<void(folly::IOBuf&)> onDestructionCb = nullptr);
+      std::function<void(folly::IOBuf&)> onDestructionCb = nullptr,
+      std::optional<int64_t> numRows = std::nullopt);
 
   ~SerializedPage();
 
-  // Returns the size of the serialized data in bytes.
+  /// Returns the size of the serialized data in bytes.
   uint64_t size() const {
     return iobufBytes_;
   }
 
-  // Makes 'input' ready for deserializing 'this' with
-  // VectorStreamGroup::read().
-  void prepareStreamForDeserialize(ByteStream* input);
+  std::optional<int64_t> numRows() const {
+    return numRows_;
+  }
+
+  /// Makes 'input' ready for deserializing 'this' with
+  /// VectorStreamGroup::read().
+  std::unique_ptr<ByteInputStream> prepareStreamForDeserialize();
 
   std::unique_ptr<folly::IOBuf> getIOBuf() const {
     return iobuf_->clone();
@@ -61,6 +66,9 @@ class SerializedPage {
   // Number of payload bytes in 'iobuf_'.
   const int64_t iobufBytes_;
 
+  // Number of payload rows, if provided.
+  const std::optional<int64_t> numRows_;
+
   // Callback that will be called on destruction of the SerializedPage,
   // primarily used to free externally allocated memory backing folly::IOBuf
   // from caller. Caller is responsible to pass in proper cleanup logic to
@@ -68,17 +76,11 @@ class SerializedPage {
   std::function<void(folly::IOBuf&)> onDestructionCb_;
 };
 
-// Queue of results retrieved from source. Owned by shared_ptr by
-// Exchange and client threads and registered callbacks waiting
-// for input.
+/// Queue of results retrieved from source. Owned by shared_ptr by
+/// Exchange and client threads and registered callbacks waiting
+/// for input.
 class ExchangeQueue {
  public:
-#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-  explicit ExchangeQueue(int64_t /*minBytes*/) {}
-
-  ExchangeQueue() = default;
-#endif
-
   ~ExchangeQueue() {
     clearAllPromises();
   }
@@ -91,21 +93,37 @@ class ExchangeQueue {
     return queue_.empty();
   }
 
+  /// Enqueues 'page' to the queue. One random promise(top of promise queue)
+  /// associated with the future that is waiting for the data from the queue is
+  /// returned in 'promises' if 'page' is not nullptr. When 'page' is nullptr
+  /// and the queue is completed serving data, all left over promises will be
+  /// returned in 'promises'. When 'page' is nullptr and the queue is not
+  /// completed serving data, no 'promises' will be added and returned.
   void enqueueLocked(
       std::unique_ptr<SerializedPage>&& page,
       std::vector<ContinuePromise>& promises);
 
-  // If data is permanently not available, e.g. the source cannot be
-  // contacted, this registers an error message and causes the reading
-  // Exchanges to throw with the message.
+  /// If data is permanently not available, e.g. the source cannot be
+  /// contacted, this registers an error message and causes the reading
+  /// Exchanges to throw with the message.
   void setError(const std::string& error);
 
-  std::unique_ptr<SerializedPage> dequeueLocked(
-      bool* atEnd,
-      ContinueFuture* future);
+  /// Returns pages of data.
+  ///
+  /// Returns empty list if no data is available. If data is still expected,
+  /// sets 'atEnd' to false and 'future' to a Future that will complete when
+  /// data arrives. If no more data is expected, sets 'atEnd' to true. Returns
+  /// at least one page if data is available. If multiple pages are available,
+  /// returns as many pages as fit within 'maxBytes', but no fewer than one.
+  /// Calling this method with 'maxBytes' of 1 returns at most one page.
+  ///
+  /// The data may be compressed, in which case 'maxBytes' applies to compressed
+  /// size.
+  std::vector<std::unique_ptr<SerializedPage>>
+  dequeueLocked(uint32_t maxBytes, bool* atEnd, ContinueFuture* future);
 
   /// Returns the total bytes held by SerializedPages in 'this'.
-  uint64_t totalBytes() const {
+  int64_t totalBytes() const {
     return totalBytes_;
   }
 
@@ -179,7 +197,7 @@ class ExchangeQueue {
   // throw an exception with this message.
   std::string error_;
   // Total size of SerializedPages in queue.
-  uint64_t totalBytes_{0};
+  int64_t totalBytes_{0};
   // Number of SerializedPages received.
   int64_t receivedPages_{0};
   // Total size of SerializedPages received. Used to calculate an average
diff --git a/velox/exec/ExchangeSource.h b/velox/exec/ExchangeSource.h
index 4fd34d02d6fa4..5137423f7b2a3 100644
--- a/velox/exec/ExchangeSource.h
+++ b/velox/exec/ExchangeSource.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/common/base/RuntimeMetrics.h"
 #include "velox/exec/ExchangeQueue.h"
 
 namespace facebook::velox::exec {
@@ -39,9 +40,9 @@ class ExchangeSource : public std::enable_shared_from_this<ExchangeSource> {
       std::shared_ptr<ExchangeQueue> queue,
       memory::MemoryPool* pool);
 
-  /// Temporary API to indicate whether 'request(maxBytes, maxWaitSeconds)' API
+  /// Temporary API to indicate whether 'metrics()' API
   /// is supported.
-  virtual bool supportsFlowControlV2() const {
+  virtual bool supportsMetrics() const {
     return false;
   }
 
@@ -54,18 +55,6 @@ class ExchangeSource : public std::enable_shared_from_this<ExchangeSource> {
   /// threads from issuing the same request.
   virtual bool shouldRequestLocked() = 0;
 
-  virtual bool isRequestPendingLocked() const {
-    return requestPending_;
-  }
-
-  /// Requests the producer to generate up to 'maxBytes' more data.
-  /// Returns a future that completes when producer responds either with 'data'
-  /// or with a message indicating that all data has been already produced or
-  /// data will take more time to produce.
-  virtual ContinueFuture request(uint32_t /*maxBytes*/) {
-    VELOX_NYI();
-  }
-
   struct Response {
     /// Size of the response in bytes. Zero means response didn't contain any
     /// data.
@@ -73,17 +62,33 @@ class ExchangeSource : public std::enable_shared_from_this<ExchangeSource> {
 
     /// Boolean indicating that there will be no more data.
     const bool atEnd;
+
+    /// Number of bytes still buffered at the source.  Each element represent
+    /// one page, and the consumer can choose to fetch a prefix of them
+    /// according to the memory restriction.
+    const std::vector<int64_t> remainingBytes;
   };
 
   /// Requests the producer to generate up to 'maxBytes' more data and reply
-  /// within 'maxWaitSeconds'. Returns a future that completes when producer
-  /// responds either with 'data' or with a message indicating that all data has
-  /// been already produced or data will take more time to produce.
+  /// within 'maxWait'. Returns a future that completes when producer responds
+  /// either with 'data' or with a message indicating that all data has been
+  /// already produced or data will take more time to produce.
   virtual folly::SemiFuture<Response> request(
-      uint32_t /*maxBytes*/,
-      uint32_t /*maxWaitSeconds*/) {
-    VELOX_NYI();
-  }
+      uint32_t maxBytes,
+      std::chrono::microseconds maxWait) = 0;
+
+  /// Ask for available data sizes that can be fetched.  Normally should not
+  /// fetching any actual data (i.e. Response::bytes should be 0).  However for
+  /// backward compatibility (e.g. communicating with coordinator), we allow
+  /// small data (1MB) to be returned.
+  virtual folly::SemiFuture<Response> requestDataSizes(
+      std::chrono::microseconds maxWait) = 0;
+
+  /// Notifies that the engine needs some time to process already received data
+  /// and may not request more for a while. The implementation may choose to
+  /// release temporary buffers or pause fetching any new data until any of
+  /// the 'request' or 'requestDataSizes' methods are called.
+  virtual void pause() {};
 
   /// Close the exchange source. May be called before all data
   /// has been received and processed. This can happen in case
@@ -94,7 +99,17 @@ class ExchangeSource : public std::enable_shared_from_this<ExchangeSource> {
   // Returns runtime statistics. ExchangeSource is expected to report
   // background CPU time by including a runtime metric named
   // ExchangeClient::kBackgroundCpuTimeMs.
-  virtual folly::F14FastMap<std::string, int64_t> stats() const = 0;
+  virtual folly::F14FastMap<std::string, int64_t> stats() const {
+    VELOX_UNREACHABLE();
+  }
+
+  /// Returns runtime statistics. ExchangeSource is expected to report
+  /// Specify units of individual counters in ExchangeSource.
+  /// for an example: 'totalBytes ：count: 9, sum: 11.17GB, max: 1.39GB,
+  /// min:  1.16GB'
+  virtual folly::F14FastMap<std::string, RuntimeMetric> metrics() const {
+    VELOX_NYI();
+  }
 
   virtual std::string toString() {
     std::stringstream out;
@@ -103,14 +118,14 @@ class ExchangeSource : public std::enable_shared_from_this<ExchangeSource> {
     return out.str();
   }
 
-  virtual std::string toJsonString() {
+  virtual folly::dynamic toJson() {
     folly::dynamic obj = folly::dynamic::object;
     obj["taskId"] = taskId_;
     obj["destination"] = destination_;
     obj["sequence"] = sequence_;
     obj["requestPending"] = requestPending_.load();
     obj["atEnd"] = atEnd_;
-    return folly::toPrettyJson(obj);
+    return obj;
   }
 
   using Factory = std::function<std::shared_ptr<ExchangeSource>(
@@ -126,16 +141,16 @@ class ExchangeSource : public std::enable_shared_from_this<ExchangeSource> {
 
   static std::vector<Factory>& factories();
 
+  ExchangeQueue* testingQueue() const {
+    return queue_.get();
+  }
+
  protected:
   // ID of the task producing data
   const std::string taskId_;
   // Destination number of 'this' on producer
   const int destination_;
-  int64_t sequence_ = 0;
-  std::shared_ptr<ExchangeQueue> queue_;
-  std::atomic<bool> requestPending_{false};
-  bool atEnd_ = false;
-
+  const std::shared_ptr<ExchangeQueue> queue_{nullptr};
   // Holds a shared reference on the memory pool as it might be still possible
   // to be accessed by external components after the query task is destroyed.
   // For instance, in Prestissimo, there might be a pending http request issued
@@ -144,6 +159,10 @@ class ExchangeSource : public std::enable_shared_from_this<ExchangeSource> {
   // so we need to hold an additional shared reference on the memory pool to
   // keeps it alive.
   const std::shared_ptr<memory::MemoryPool> pool_;
+
+  int64_t sequence_{0};
+  std::atomic<bool> requestPending_{false};
+  bool atEnd_{false};
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Expand.cpp b/velox/exec/Expand.cpp
new file mode 100644
index 0000000000000..5d866b888c186
--- /dev/null
+++ b/velox/exec/Expand.cpp
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/Expand.h"
+
+namespace facebook::velox::exec {
+
+Expand::Expand(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    const std::shared_ptr<const core::ExpandNode>& expandNode)
+    : Operator(
+          driverCtx,
+          expandNode->outputType(),
+          operatorId,
+          expandNode->id(),
+          "Expand") {
+  const auto& inputType = expandNode->inputType();
+  const auto numRows = expandNode->projections().size();
+  fieldProjections_.reserve(numRows);
+  constantProjections_.reserve(numRows);
+  const auto numColumns = expandNode->names().size();
+  for (const auto& rowProjections : expandNode->projections()) {
+    std::vector<column_index_t> rowProjection;
+    rowProjection.reserve(numColumns);
+    std::vector<std::shared_ptr<const core::ConstantTypedExpr>>
+        constantProjection;
+    constantProjection.reserve(numColumns);
+    for (const auto& columnProjection : rowProjections) {
+      if (auto field = core::TypedExprs::asFieldAccess(columnProjection)) {
+        rowProjection.push_back(inputType->getChildIdx(field->name()));
+        constantProjection.push_back(nullptr);
+      } else if (
+          auto constant = core::TypedExprs::asConstant(columnProjection)) {
+        rowProjection.push_back(kConstantChannel);
+        constantProjection.push_back(constant);
+      } else {
+        VELOX_USER_FAIL(
+            "Expand operator doesn't support this expression. Only column references and constants are supported. {}",
+            columnProjection->toString());
+      }
+    }
+
+    fieldProjections_.emplace_back(std::move(rowProjection));
+    constantProjections_.emplace_back(std::move(constantProjection));
+  }
+}
+
+bool Expand::needsInput() const {
+  return !noMoreInput_ && input_ == nullptr;
+}
+
+void Expand::addInput(RowVectorPtr input) {
+  // Load Lazy vectors.
+  for (auto& child : input->children()) {
+    child->loadedVector();
+  }
+
+  input_ = std::move(input);
+}
+
+RowVectorPtr Expand::getOutput() {
+  if (!input_) {
+    return nullptr;
+  }
+
+  const auto numInput = input_->size();
+
+  std::vector<VectorPtr> outputColumns(outputType_->size());
+
+  const auto& rowProjection = fieldProjections_[rowIndex_];
+  const auto& constantProjection = constantProjections_[rowIndex_];
+  const auto numColumns = rowProjection.size();
+
+  for (auto i = 0; i < numColumns; ++i) {
+    if (rowProjection[i] == kConstantChannel) {
+      const auto& constantExpr = constantProjection[i];
+      if (constantExpr->value().isNull()) {
+        // Add null column.
+        outputColumns[i] = BaseVector::createNullConstant(
+            outputType_->childAt(i), numInput, pool());
+      } else {
+        // Add constant column.
+        outputColumns[i] = BaseVector::createConstant(
+            constantExpr->type(), constantExpr->value(), numInput, pool());
+      }
+    } else {
+      outputColumns[i] = input_->childAt(rowProjection[i]);
+    }
+  }
+
+  ++rowIndex_;
+  if (rowIndex_ == fieldProjections_.size()) {
+    rowIndex_ = 0;
+    input_ = nullptr;
+  }
+
+  return std::make_shared<RowVector>(
+      pool(), outputType_, nullptr, numInput, std::move(outputColumns));
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/Expand.h b/velox/exec/Expand.h
new file mode 100644
index 0000000000000..97c737c1d1f35
--- /dev/null
+++ b/velox/exec/Expand.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/core/Expressions.h"
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::exec {
+
+class Expand : public Operator {
+ public:
+  Expand(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const std::shared_ptr<const core::ExpandNode>& expandNode);
+
+  bool needsInput() const override;
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override {
+    return noMoreInput_ && input_ == nullptr;
+  }
+
+ private:
+  std::vector<std::vector<column_index_t>> fieldProjections_;
+
+  std::vector<std::vector<std::shared_ptr<const core::ConstantTypedExpr>>>
+      constantProjections_;
+
+  // Used to indicate the index of fieldProjections_.
+  int32_t rowIndex_{0};
+};
+} // namespace facebook::velox::exec
diff --git a/velox/exec/FilterProject.cpp b/velox/exec/FilterProject.cpp
index 43d15d343f211..9c2c991ffe7e4 100644
--- a/velox/exec/FilterProject.cpp
+++ b/velox/exec/FilterProject.cpp
@@ -25,8 +25,7 @@ bool checkAddIdentityProjection(
     const RowTypePtr& inputType,
     column_index_t outputChannel,
     std::vector<IdentityProjection>& identityProjections) {
-  if (auto field = std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-          projection)) {
+  if (auto field = core::TypedExprs::asFieldAccess(projection)) {
     const auto& inputs = field->inputs();
     if (inputs.empty() ||
         (inputs.size() == 1 &&
@@ -105,16 +104,6 @@ void FilterProject::initialize() {
 void FilterProject::addInput(RowVectorPtr input) {
   input_ = std::move(input);
   numProcessedInputRows_ = 0;
-  if (!resultProjections_.empty()) {
-    results_.resize(resultProjections_.back().inputChannel + 1);
-    for (auto& result : results_) {
-      if (result && result.unique() && result->isFlatEncoding()) {
-        BaseVector::prepareForReuse(result, 0);
-      } else {
-        result.reset();
-      }
-    }
-  }
 }
 
 bool FilterProject::allInputProcessed() {
@@ -140,7 +129,7 @@ RowVectorPtr FilterProject::getOutput() {
   vector_size_t size = input_->size();
   LocalSelectivityVector localRows(*operatorCtx_->execCtx(), size);
   auto* rows = localRows.get();
-  VELOX_DCHECK_NOT_NULL(rows)
+  VELOX_DCHECK_NOT_NULL(rows);
   rows->setAll();
   EvalCtx evalCtx(operatorCtx_->execCtx(), exprs_.get(), input_.get());
 
@@ -153,20 +142,9 @@ RowVectorPtr FilterProject::getOutput() {
   if (!hasFilter_) {
     numProcessedInputRows_ = size;
     VELOX_CHECK(!isIdentityProjection_);
-    project(*rows, evalCtx);
-
-    if (results_.size() > 0) {
-      auto outCol = results_[0];
-      if (outCol && outCol->isCodegenOutput()) {
-        // codegen can output different size when it merged filter + projection
-        size = outCol->size();
-        if (size == 0) { // all filtered out
-          return nullptr;
-        }
-      }
-    }
+    auto results = project(*rows, evalCtx);
 
-    return fillOutput(size, nullptr);
+    return fillOutput(size, nullptr, results);
   }
 
   // evaluate filter
@@ -180,26 +158,34 @@ RowVectorPtr FilterProject::getOutput() {
   bool allRowsSelected = (numOut == size);
 
   // evaluate projections (if present)
+  std::vector<VectorPtr> results;
   if (!isIdentityProjection_) {
     if (!allRowsSelected) {
       rows->setFromBits(filterEvalCtx_.selectedBits->as<uint64_t>(), size);
     }
-    project(*rows, evalCtx);
+    results = project(*rows, evalCtx);
   }
 
   return fillOutput(
-      numOut, allRowsSelected ? nullptr : filterEvalCtx_.selectedIndices);
+      numOut,
+      allRowsSelected ? nullptr : filterEvalCtx_.selectedIndices,
+      results);
 }
 
-void FilterProject::project(const SelectivityVector& rows, EvalCtx& evalCtx) {
+std::vector<VectorPtr> FilterProject::project(
+    const SelectivityVector& rows,
+    EvalCtx& evalCtx) {
+  std::vector<VectorPtr> results;
   exprs_->eval(
-      hasFilter_ ? 1 : 0, numExprs_, !hasFilter_, rows, evalCtx, results_);
+      hasFilter_ ? 1 : 0, numExprs_, !hasFilter_, rows, evalCtx, results);
+  return results;
 }
 
 vector_size_t FilterProject::filter(
     EvalCtx& evalCtx,
     const SelectivityVector& allRows) {
-  exprs_->eval(0, 1, true, allRows, evalCtx, results_);
-  return processFilterResults(results_[0], allRows, filterEvalCtx_, pool());
+  std::vector<VectorPtr> results;
+  exprs_->eval(0, 1, true, allRows, evalCtx, results);
+  return processFilterResults(results[0], allRows, filterEvalCtx_, pool());
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/FilterProject.h b/velox/exec/FilterProject.h
index e4eaf396af5f7..07d32cf1402b6 100644
--- a/velox/exec/FilterProject.h
+++ b/velox/exec/FilterProject.h
@@ -86,9 +86,11 @@ class FilterProject : public Operator {
   // updated.
   vector_size_t filter(EvalCtx& evalCtx, const SelectivityVector& allRows);
 
-  // Evaluate projections on the specified rows and populate results_.
+  // Evaluate projections on the specified rows and return the results.
   // pre-condition: !isIdentityProjection_
-  void project(const SelectivityVector& rows, EvalCtx& evalCtx);
+  std::vector<VectorPtr> project(
+      const SelectivityVector& rows,
+      EvalCtx& evalCtx);
 
   // If true exprs_[0] is a filter and the other expressions are projections
   const bool hasFilter_{false};
diff --git a/velox/exec/GroupingSet.cpp b/velox/exec/GroupingSet.cpp
index f5c4eca38506a..42c0df1a898af 100644
--- a/velox/exec/GroupingSet.cpp
+++ b/velox/exec/GroupingSet.cpp
@@ -38,15 +38,6 @@ bool areAllLazyNotLoaded(const std::vector<VectorPtr>& vectors) {
   });
 }
 
-std::vector<std::optional<column_index_t>> maskChannels(
-    const std::vector<AggregateInfo>& aggregates) {
-  std::vector<std::optional<column_index_t>> masks;
-  masks.reserve(aggregates.size());
-  for (const auto& aggregate : aggregates) {
-    masks.push_back(aggregate.mask);
-  }
-  return masks;
-}
 } // namespace
 
 GroupingSet::GroupingSet(
@@ -57,29 +48,30 @@ GroupingSet::GroupingSet(
     bool ignoreNullKeys,
     bool isPartial,
     bool isRawInput,
+    const std::vector<vector_size_t>& globalGroupingSets,
+    const std::optional<column_index_t>& groupIdChannel,
     const common::SpillConfig* spillConfig,
-    uint32_t* numSpillRuns,
     tsan_atomic<bool>* nonReclaimableSection,
-    OperatorCtx* operatorCtx)
+    OperatorCtx* operatorCtx,
+    folly::Synchronized<common::SpillStats>* spillStats)
     : preGroupedKeyChannels_(std::move(preGroupedKeys)),
       hashers_(std::move(hashers)),
       isGlobal_(hashers_.empty()),
       isPartial_(isPartial),
       isRawInput_(isRawInput),
-      queryConfig_(&operatorCtx->task()->queryCtx()->queryConfig()),
+      queryConfig_(operatorCtx->task()->queryCtx()->queryConfig()),
       aggregates_(std::move(aggregates)),
-      masks_(maskChannels(aggregates_)),
+      masks_(extractMaskChannels(aggregates_)),
       ignoreNullKeys_(ignoreNullKeys),
-      spillMemoryThreshold_(operatorCtx->driverCtx()
-                                ->queryConfig()
-                                .aggregationSpillMemoryThreshold()),
+      globalGroupingSets_(globalGroupingSets),
+      groupIdChannel_(groupIdChannel),
       spillConfig_(spillConfig),
-      numSpillRuns_(numSpillRuns),
       nonReclaimableSection_(nonReclaimableSection),
       stringAllocator_(operatorCtx->pool()),
       rows_(operatorCtx->pool()),
-      isAdaptive_(queryConfig_->hashAdaptivityEnabled()),
-      pool_(*operatorCtx->pool()) {
+      isAdaptive_(queryConfig_.hashAdaptivityEnabled()),
+      pool_(*operatorCtx->pool()),
+      spillStats_(spillStats) {
   VELOX_CHECK_NOT_NULL(nonReclaimableSection_);
   VELOX_CHECK(pool_.trackUsage());
   for (auto& hasher : hashers_) {
@@ -97,26 +89,12 @@ GroupingSet::GroupingSet(
         allAreSinglyReferenced(aggregate.inputs, channelUseCount));
   }
 
-  // Setup SortedAggregations.
-  std::vector<AggregateInfo*> sortedAggs;
-  for (auto& aggregate : aggregates_) {
-    if (!aggregate.sortingKeys.empty()) {
-      VELOX_USER_CHECK(
-          !isPartial_,
-          "Partial aggregations over sorted inputs are not supported");
-
-      VELOX_USER_CHECK(
-          !aggregate.distinct,
-          "Aggregations over sorted unique values are not supported yet");
-
-      sortedAggs.push_back(&aggregate);
-      continue;
-    }
-  }
-
-  if (!sortedAggs.empty()) {
-    sortedAggregations_ =
-        std::make_unique<SortedAggregations>(sortedAggs, inputType, &pool_);
+  sortedAggregations_ =
+      SortedAggregations::create(aggregates_, inputType, &pool_);
+  if (isPartial_) {
+    VELOX_USER_CHECK_NULL(
+        sortedAggregations_,
+        "Partial aggregations over sorted inputs are not supported");
   }
 
   for (auto& aggregate : aggregates_) {
@@ -151,10 +129,12 @@ std::unique_ptr<GroupingSet> GroupingSet::createForMarkDistinct(
       /*ignoreNullKeys*/ false,
       /*isPartial*/ false,
       /*isRawInput*/ false,
+      /*globalGroupingSets*/ std::vector<vector_size_t>{},
+      /*groupIdColumn*/ std::nullopt,
       /*spillConfig*/ nullptr,
-      /*numSpillRuns*/ nullptr,
       nonReclaimableSection,
-      operatorCtx);
+      operatorCtx,
+      /*spillStats_*/ nullptr);
 };
 
 namespace {
@@ -181,6 +161,7 @@ void GroupingSet::addInput(const RowVectorPtr& input, bool mayPushdown) {
   }
 
   auto numRows = input->size();
+  numInputRows_ += numRows;
   if (!preGroupedKeyChannels_.empty()) {
     if (remainingInput_) {
       addRemainingInput();
@@ -216,14 +197,8 @@ void GroupingSet::noMoreInput() {
   // Spill the remaining in-memory state to disk if spilling has been triggered
   // on this grouping set. This is to simplify query OOM prevention when
   // producing output as we don't support to spill during that stage as for now.
-  // We will remove this limitation after we support spilling during the middle
-  // of output processing later.
-  if (hasSpilled() && spillConfig_->aggregationSpillAll) {
-    spill(0, 0);
-  }
-
-  if (sortedAggregations_) {
-    sortedAggregations_->noMoreInput();
+  if (hasSpilled()) {
+    spill();
   }
 
   ensureOutputFits();
@@ -246,19 +221,21 @@ void GroupingSet::addInputForActiveRows(
   }
   ensureInputFits(input);
 
-  // Prevents the memory arbitrator to reclaim memory from this grouping set
-  // during the execution below.
-  //
-  // NOTE: 'nonReclaimableSection_' points to the corresponding flag in the
-  // associated aggregation operator.
-  auto guard = folly::makeGuard([this]() { *nonReclaimableSection_ = false; });
-  *nonReclaimableSection_ = true;
-
   TestValue::adjust(
       "facebook::velox::exec::GroupingSet::addInputForActiveRows", this);
 
-  table_->prepareForProbe(*lookup_, input, activeRows_, ignoreNullKeys_);
-  table_->groupProbe(*lookup_);
+  table_->prepareForGroupProbe(
+      *lookup_,
+      input,
+      activeRows_,
+      BaseHashTable::kNoSpillInputStartPartitionBit);
+  if (lookup_->rows.empty()) {
+    // No rows to probe. Can happen when ignoreNullKeys_ is true and all rows
+    // have null keys.
+    return;
+  }
+
+  table_->groupProbe(*lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
   masks_.addInput(input, activeRows_);
 
   auto* groups = lookup_->hits.data();
@@ -334,16 +311,18 @@ void initializeAggregates(
   int i = 0;
   for (auto& aggregate : aggregates) {
     auto& function = aggregate.function;
+    function->setAllocator(&rows.stringAllocator());
     if (excludeToIntermediate && function->supportsToIntermediate()) {
       continue;
     }
-    function->setAllocator(&rows.stringAllocator());
 
     const auto rowColumn = rows.columnAt(numKeys + i);
     function->setOffsets(
         rowColumn.offset(),
         rowColumn.nullByte(),
         rowColumn.nullMask(),
+        rowColumn.initializedByte(),
+        rowColumn.initializedMask(),
         rows.rowSizeOffset());
     ++i;
   }
@@ -356,7 +335,8 @@ std::vector<Accumulator> GroupingSet::accumulators(bool excludeToIntermediate) {
   for (auto& aggregate : aggregates_) {
     if (!excludeToIntermediate ||
         !aggregate.function->supportsToIntermediate()) {
-      accumulators.push_back(Accumulator{aggregate.function.get()});
+      accumulators.push_back(
+          Accumulator{aggregate.function.get(), aggregate.intermediateType});
     }
   }
 
@@ -394,6 +374,8 @@ void GroupingSet::createHashTable() {
         rowColumn.offset(),
         rowColumn.nullByte(),
         rowColumn.nullMask(),
+        rowColumn.initializedByte(),
+        rowColumn.initializedMask(),
         rows.rowSizeOffset());
 
     ++numColumns;
@@ -408,6 +390,8 @@ void GroupingSet::createHashTable() {
           rowColumn.offset(),
           rowColumn.nullByte(),
           rowColumn.nullMask(),
+          rowColumn.initializedByte(),
+          rowColumn.initializedMask(),
           rows.rowSizeOffset());
       ++numColumns;
     }
@@ -415,7 +399,7 @@ void GroupingSet::createHashTable() {
 
   lookup_ = std::make_unique<HashLookup>(table_->hashers());
   if (!isAdaptive_ && table_->hashMode() != BaseHashTable::HashMode::kHash) {
-    table_->forceGenericHashMode();
+    table_->forceGenericHashMode(BaseHashTable::kNoSpillInputStartPartitionBit);
   }
 }
 
@@ -428,22 +412,36 @@ void GroupingSet::initializeGlobalAggregation() {
   lookup_->reset(1);
 
   // Row layout is:
-  //  - null flags - one bit per aggregate,
+  //  - alternating null flag, intialized flag - one bit per flag, one pair per
+  //                                             aggregation,
   //  - uint32_t row size,
   //  - fixed-width accumulators - one per aggregate
   //
   // Here we always make space for a row size since we only have one row and no
   // RowContainer.  The whole row is allocated to guarantee that alignment
   // requirements of all aggregate functions are satisfied.
-  int32_t rowSizeOffset = bits::nbytes(aggregates_.size());
+
+  // Allocate space for the null and initialized flags.
+  size_t numAggregates = aggregates_.size();
+  if (sortedAggregations_) {
+    numAggregates++;
+  }
+  for (const auto& aggregation : distinctAggregations_) {
+    if (aggregation != nullptr) {
+      numAggregates++;
+    }
+  }
+  int32_t rowSizeOffset =
+      bits::nbytes(numAggregates * RowContainer::kNumAccumulatorFlags);
   int32_t offset = rowSizeOffset + sizeof(int32_t);
-  int32_t nullOffset = 0;
+  int32_t accumulatorFlagsOffset = 0;
   int32_t alignment = 1;
 
   for (auto& aggregate : aggregates_) {
     auto& function = aggregate.function;
 
-    Accumulator accumulator{aggregate.function.get()};
+    Accumulator accumulator{
+        aggregate.function.get(), aggregate.intermediateType};
 
     // Accumulator offset must be aligned by their alignment size.
     offset = bits::roundUp(offset, accumulator.alignment());
@@ -451,12 +449,14 @@ void GroupingSet::initializeGlobalAggregation() {
     function->setAllocator(&stringAllocator_);
     function->setOffsets(
         offset,
-        RowContainer::nullByte(nullOffset),
-        RowContainer::nullMask(nullOffset),
+        RowContainer::nullByte(accumulatorFlagsOffset),
+        RowContainer::nullMask(accumulatorFlagsOffset),
+        RowContainer::initializedByte(accumulatorFlagsOffset),
+        RowContainer::initializedMask(accumulatorFlagsOffset),
         rowSizeOffset);
 
     offset += accumulator.fixedWidthSize();
-    ++nullOffset;
+    accumulatorFlagsOffset += RowContainer::kNumAccumulatorFlags;
     alignment =
         RowContainer::combineAlignments(accumulator.alignment(), alignment);
   }
@@ -467,14 +467,18 @@ void GroupingSet::initializeGlobalAggregation() {
     offset = bits::roundUp(offset, accumulator.alignment());
 
     sortedAggregations_->setAllocator(&stringAllocator_);
+    VELOX_DCHECK_LT(
+        RowContainer::nullByte(accumulatorFlagsOffset), rowSizeOffset);
     sortedAggregations_->setOffsets(
         offset,
-        RowContainer::nullByte(nullOffset),
-        RowContainer::nullMask(nullOffset),
+        RowContainer::nullByte(accumulatorFlagsOffset),
+        RowContainer::nullMask(accumulatorFlagsOffset),
+        RowContainer::initializedByte(accumulatorFlagsOffset),
+        RowContainer::initializedMask(accumulatorFlagsOffset),
         rowSizeOffset);
 
     offset += accumulator.fixedWidthSize();
-    ++nullOffset;
+    accumulatorFlagsOffset += RowContainer::kNumAccumulatorFlags;
     alignment =
         RowContainer::combineAlignments(accumulator.alignment(), alignment);
   }
@@ -488,12 +492,14 @@ void GroupingSet::initializeGlobalAggregation() {
       aggregation->setAllocator(&stringAllocator_);
       aggregation->setOffsets(
           offset,
-          RowContainer::nullByte(nullOffset),
-          RowContainer::nullMask(nullOffset),
+          RowContainer::nullByte(accumulatorFlagsOffset),
+          RowContainer::nullMask(accumulatorFlagsOffset),
+          RowContainer::initializedByte(accumulatorFlagsOffset),
+          RowContainer::initializedMask(accumulatorFlagsOffset),
           rowSizeOffset);
 
       offset += accumulator.fixedWidthSize();
-      ++nullOffset;
+      accumulatorFlagsOffset += RowContainer::kNumAccumulatorFlags;
       alignment =
           RowContainer::combineAlignments(accumulator.alignment(), alignment);
     }
@@ -502,6 +508,9 @@ void GroupingSet::initializeGlobalAggregation() {
   lookup_->hits[0] = rows_.allocateFixed(offset, alignment);
   const auto singleGroup = std::vector<vector_size_t>{0};
   for (auto& aggregate : aggregates_) {
+    if (!aggregate.sortingKeys.empty()) {
+      continue;
+    }
     aggregate.function->initializeNewGroups(lookup_->hits.data(), singleGroup);
   }
 
@@ -567,11 +576,8 @@ void GroupingSet::addGlobalAggregationInput(
 }
 
 bool GroupingSet::getGlobalAggregationOutput(
-    int32_t batchSize,
-    bool isPartial,
     RowContainerIterator& iterator,
     RowVectorPtr& result) {
-  VELOX_CHECK_EQ(batchSize, 1);
   if (iterator.allocationIndex != 0) {
     return false;
   }
@@ -585,10 +591,11 @@ bool GroupingSet::getGlobalAggregationOutput(
     }
 
     auto& function = aggregates_[i].function;
-    if (isPartial) {
-      function->extractAccumulators(groups, 1, &result->childAt(i));
+    auto& resultVector = result->childAt(aggregates_[i].output);
+    if (isPartial_) {
+      function->extractAccumulators(groups, 1, &resultVector);
     } else {
-      function->extractValues(groups, 1, &result->childAt(i));
+      function->extractValues(groups, 1, &resultVector);
     }
   }
 
@@ -606,15 +613,73 @@ bool GroupingSet::getGlobalAggregationOutput(
   return true;
 }
 
+bool GroupingSet::getDefaultGlobalGroupingSetOutput(
+    RowContainerIterator& iterator,
+    RowVectorPtr& result) {
+  VELOX_CHECK(hasDefaultGlobalGroupingSetOutput());
+
+  if (iterator.allocationIndex != 0) {
+    return false;
+  }
+
+  auto globalAggregatesRow =
+      BaseVector::create<RowVector>(result->type(), 1, &pool_);
+
+  VELOX_CHECK(getGlobalAggregationOutput(iterator, globalAggregatesRow));
+
+  // There is one output row for each global GroupingSet.
+  const auto numGroupingSets = globalGroupingSets_.size();
+  result->resize(numGroupingSets);
+  VELOX_CHECK(groupIdChannel_.has_value());
+
+  // First columns in 'result' are for grouping keys (which could include the
+  // GroupId column). For a global grouping set row :
+  // i) Non-groupId grouping keys are null.
+  // ii) GroupId column is populated with the global grouping set number.
+
+  column_index_t firstAggregateCol = result->type()->size();
+  for (const auto& aggregate : aggregates_) {
+    firstAggregateCol = std::min(firstAggregateCol, aggregate.output);
+  }
+
+  for (auto i = 0; i < firstAggregateCol; i++) {
+    auto column = result->childAt(i);
+    if (i == groupIdChannel_.value()) {
+      column->resize(numGroupingSets);
+      auto* groupIdVector = column->asFlatVector<int64_t>();
+      for (auto j = 0; j < numGroupingSets; j++) {
+        groupIdVector->set(j, globalGroupingSets_.at(j));
+      }
+    } else {
+      column->resize(numGroupingSets, false);
+      for (auto j = 0; j < numGroupingSets; j++) {
+        column->setNull(j, true);
+      }
+    }
+  }
+
+  // The remaining aggregate columns are filled from the computed global
+  // aggregates.
+  for (const auto& aggregate : aggregates_) {
+    auto resultAggregateColumn = result->childAt(aggregate.output);
+    resultAggregateColumn->resize(numGroupingSets);
+    auto sourceAggregateColumn = globalAggregatesRow->childAt(aggregate.output);
+    for (auto i = 0; i < numGroupingSets; i++) {
+      resultAggregateColumn->copy(sourceAggregateColumn.get(), i, 0, 1);
+    }
+  }
+
+  return true;
+}
+
 void GroupingSet::destroyGlobalAggregations() {
   if (!globalAggregationInitialized_) {
     return;
   }
   for (int32_t i = 0; i < aggregates_.size(); ++i) {
     auto& function = aggregates_[i].function;
-    auto groups = lookup_->hits.data();
     if (function->accumulatorUsesExternalMemory()) {
-      auto groups = lookup_->hits.data();
+      auto* groups = lookup_->hits.data();
       function->destroy(folly::Range(groups, 1));
     }
   }
@@ -654,18 +719,20 @@ bool GroupingSet::getOutput(
     int32_t maxOutputBytes,
     RowContainerIterator& iterator,
     RowVectorPtr& result) {
-  auto guard = folly::makeGuard([this]() { *nonReclaimableSection_ = false; });
-  *nonReclaimableSection_ = true;
-
   TestValue::adjust("facebook::velox::exec::GroupingSet::getOutput", this);
 
   if (isGlobal_) {
-    return getGlobalAggregationOutput(
-        maxOutputRows, isPartial_, iterator, result);
+    return getGlobalAggregationOutput(iterator, result);
   }
+
+  if (hasDefaultGlobalGroupingSetOutput()) {
+    return getDefaultGlobalGroupingSetOutput(iterator, result);
+  }
+
   if (hasSpilled()) {
     return getOutputWithSpill(maxOutputRows, maxOutputBytes, result);
   }
+  VELOX_CHECK(!isDistinct());
 
   // @lint-ignore CLANGTIDY
   char* groups[maxOutputRows];
@@ -690,7 +757,7 @@ void GroupingSet::extractGroups(
   if (groups.empty()) {
     return;
   }
-  RowContainer& rows = table_ ? *table_->rows() : *nonSpilledRowContainer_;
+  RowContainer& rows = *table_->rows();
   auto totalKeys = rows.keyTypes().size();
   for (int32_t i = 0; i < totalKeys; ++i) {
     auto keyVector = result->childAt(i);
@@ -722,7 +789,7 @@ void GroupingSet::extractGroups(
   }
 }
 
-void GroupingSet::resetPartial() {
+void GroupingSet::resetTable() {
   if (table_ != nullptr) {
     table_->clear();
   }
@@ -744,7 +811,8 @@ bool GroupingSet::isPartialFull(int64_t maxBytes) {
   // per 32 buckets.
   if (stats.capacity * sizeof(void*) > maxBytes / 16 &&
       stats.numDistinct < stats.capacity / 32) {
-    table_->decideHashMode(0, true);
+    table_->decideHashMode(
+        0, BaseHashTable::kNoSpillInputStartPartitionBit, true);
   }
   return allocatedBytes() > maxBytes;
 }
@@ -767,6 +835,7 @@ void GroupingSet::ensureInputFits(const RowVectorPtr& input) {
   if (isPartial_ || spillConfig_ == nullptr) {
     return;
   }
+
   const auto numDistinct = table_->numDistinct();
   if (numDistinct == 0) {
     // Table is empty. Nothing to spill.
@@ -781,29 +850,13 @@ void GroupingSet::ensureInputFits(const RowVectorPtr& input) {
   const int64_t flatBytes = input->estimateFlatSize();
 
   // Test-only spill path.
-  if (spillConfig_->testSpillPct > 0 &&
-      (folly::hasher<uint64_t>()(++spillTestCounter_)) % 100 <=
-          spillConfig_->testSpillPct) {
-    const auto rowsToSpill = std::max<int64_t>(1, numDistinct / 10);
-    spill(
-        numDistinct - rowsToSpill,
-        outOfLineBytes - (rowsToSpill * outOfLineBytesPerRow));
-    return;
-  }
-
-  const auto currentUsage = pool_.currentBytes();
-  if (spillMemoryThreshold_ != 0 && currentUsage > spillMemoryThreshold_) {
-    const int64_t bytesToSpill =
-        currentUsage * spillConfig_->spillableReservationGrowthPct / 100;
-    auto rowsToSpill = std::max<int64_t>(
-        1, bytesToSpill / (rows->fixedRowSize() + outOfLineBytesPerRow));
-    spill(
-        std::max<int64_t>(0, numDistinct - rowsToSpill),
-        std::max<int64_t>(
-            0, outOfLineBytes - (rowsToSpill * outOfLineBytesPerRow)));
+  if (testingTriggerSpill(pool_.name())) {
+    memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
+    memory::testingRunArbitration(&pool_);
     return;
   }
 
+  const auto currentUsage = pool_.usedBytes();
   const auto minReservationBytes =
       currentUsage * spillConfig_->minSpillableReservationPct / 100;
   const auto availableReservationBytes = pool_.availableReservation();
@@ -841,18 +894,16 @@ void GroupingSet::ensureInputFits(const RowVectorPtr& input) {
   const auto targetIncrementBytes = std::max<int64_t>(
       incrementBytes * 2,
       currentUsage * spillConfig_->spillableReservationGrowthPct / 100);
-  if (pool_.maybeReserve(targetIncrementBytes)) {
-    return;
+  {
+    memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
+    if (pool_.maybeReserve(targetIncrementBytes)) {
+      return;
+    }
   }
-
-  // NOTE: disk spilling use the system disk spilling memory pool instead of
-  // the operator memory pool.
-  const auto rowsToSpill = std::max<int64_t>(
-      1, targetIncrementBytes / (rows->fixedRowSize() + outOfLineBytesPerRow));
-  spill(
-      std::max<int64_t>(0, numDistinct - rowsToSpill),
-      std::max<int64_t>(
-          0, outOfLineBytes - (rowsToSpill * outOfLineBytesPerRow)));
+  LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
+               << " for memory pool " << pool_.name()
+               << ", usage: " << succinctBytes(pool_.usedBytes())
+               << ", reservation: " << succinctBytes(pool_.reservedBytes());
 }
 
 void GroupingSet::ensureOutputFits() {
@@ -860,68 +911,100 @@ void GroupingSet::ensureOutputFits() {
   // to reserve memory for the output as we can't reclaim much memory from this
   // operator itself. The output processing can reclaim memory from the other
   // operator or query through memory arbitration.
-  if (isPartial_ || spillConfig_ == nullptr || hasSpilled()) {
+  if (isPartial_ || spillConfig_ == nullptr || hasSpilled() ||
+      table_ == nullptr || table_->numDistinct() == 0) {
     return;
   }
 
   // Test-only spill path.
-  if (spillConfig_->testSpillPct > 0 &&
-      (folly::hasher<uint64_t>()(++spillTestCounter_)) % 100 <=
-          spillConfig_->testSpillPct) {
-    spill(RowContainerIterator{});
+  if (testingTriggerSpill(pool_.name())) {
+    memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
+    memory::testingRunArbitration(&pool_);
     return;
   }
 
   const uint64_t outputBufferSizeToReserve =
-      queryConfig_->preferredOutputBatchBytes() * 1.2;
-  if (pool_.maybeReserve(outputBufferSizeToReserve)) {
-    return;
+      queryConfig_.preferredOutputBatchBytes() * 1.2;
+  {
+    memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
+    if (pool_.maybeReserve(outputBufferSizeToReserve)) {
+      return;
+    }
+  }
+  LOG(WARNING) << "Failed to reserve "
+               << succinctBytes(outputBufferSizeToReserve)
+               << " for memory pool " << pool_.name()
+               << ", usage: " << succinctBytes(pool_.usedBytes())
+               << ", reservation: " << succinctBytes(pool_.reservedBytes());
+}
+
+RowTypePtr GroupingSet::makeSpillType() const {
+  auto rows = table_->rows();
+  auto types = rows->keyTypes();
+
+  for (const auto& accumulator : rows->accumulators()) {
+    types.push_back(accumulator.spillType());
+  }
+
+  std::vector<std::string> names;
+  for (auto i = 0; i < types.size(); ++i) {
+    names.push_back(fmt::format("s{}", i));
   }
-  spill(RowContainerIterator{});
+
+  return ROW(std::move(names), std::move(types));
 }
 
-void GroupingSet::spill(int64_t targetRows, int64_t targetBytes) {
+void GroupingSet::spill() {
   // NOTE: if the disk spilling is triggered by the memory arbitrator, then it
   // is possible that the grouping set hasn't processed any input data yet.
   // Correspondingly, 'table_' will not be initialized at that point.
-  if (table_ == nullptr) {
+  if (table_ == nullptr || table_->numDistinct() == 0) {
     return;
   }
+
+  auto* rows = table_->rows();
   if (!hasSpilled()) {
-    auto rows = table_->rows();
-    auto types = rows->keyTypes();
-    for (const auto& aggregate : aggregates_) {
-      types.push_back(aggregate.intermediateType);
-    }
-    std::vector<std::string> names;
-    for (auto i = 0; i < types.size(); ++i) {
-      names.push_back(fmt::format("s{}", i));
-    }
     VELOX_DCHECK(pool_.trackUsage());
+    VELOX_CHECK(numDistinctSpillFilesPerPartition_.empty());
     spiller_ = std::make_unique<Spiller>(
         Spiller::Type::kAggregateInput,
         rows,
-        [&](folly::Range<char**> rows) { table_->erase(rows); },
-        ROW(std::move(names), std::move(types)),
+        makeSpillType(),
         HashBitRange(
             spillConfig_->startPartitionBit,
-            spillConfig_->startPartitionBit +
-                spillConfig_->aggregationPartitionBits),
+            static_cast<uint8_t>(
+                spillConfig_->startPartitionBit +
+                spillConfig_->numPartitionBits)),
         rows->keyTypes().size(),
         std::vector<CompareFlags>(),
-        spillConfig_->filePath,
-        std::numeric_limits<uint64_t>::max(),
-        spillConfig_->writeBufferSize,
-        spillConfig_->minSpillRunSize,
-        spillConfig_->compressionKind,
-        memory::spillMemoryPool(),
-        spillConfig_->executor);
-  }
-  ++(*numSpillRuns_);
-  spiller_->spill(targetRows, targetBytes);
-  if (table_->rows()->numRows() == 0) {
-    table_->clear();
+        spillConfig_,
+        spillStats_);
+    VELOX_CHECK_EQ(
+        spiller_->state().maxPartitions(), 1 << spillConfig_->numPartitionBits);
+  }
+  // Spilling may execute on multiple partitions in parallel, and
+  // HashStringAllocator is not thread safe. If any aggregations
+  // allocate/deallocate memory during spilling it can lead to concurrency bugs.
+  // Freeze the HashStringAllocator to make it effectively immutable and
+  // guarantee we don't accidentally enter an unsafe situation.
+  rows->stringAllocator().freezeAndExecute([&]() { spiller_->spill(); });
+  if (isDistinct() && numDistinctSpillFilesPerPartition_.empty()) {
+    size_t totalNumDistinctSpilledFiles{0};
+    numDistinctSpillFilesPerPartition_.resize(
+        spiller_->state().maxPartitions(), 0);
+    for (int partition = 0; partition < spiller_->state().maxPartitions();
+         ++partition) {
+      numDistinctSpillFilesPerPartition_[partition] =
+          spiller_->state().numFinishedFiles(partition);
+      totalNumDistinctSpilledFiles +=
+          numDistinctSpillFilesPerPartition_[partition];
+    }
+    VELOX_CHECK_GT(totalNumDistinctSpilledFiles, 0);
   }
+  if (sortedAggregations_) {
+    sortedAggregations_->clear();
+  }
+  table_->clear();
 }
 
 void GroupingSet::spill(const RowContainerIterator& rowIterator) {
@@ -932,28 +1015,21 @@ void GroupingSet::spill(const RowContainerIterator& rowIterator) {
   }
 
   auto* rows = table_->rows();
-  auto types = rows->keyTypes();
-  for (const auto& aggregate : aggregates_) {
-    types.push_back(aggregate.intermediateType);
-  }
-  std::vector<std::string> names;
-  for (auto i = 0; i < types.size(); ++i) {
-    names.push_back(fmt::format("s{}", i));
-  }
   VELOX_CHECK(pool_.trackUsage());
   spiller_ = std::make_unique<Spiller>(
       Spiller::Type::kAggregateOutput,
       rows,
-      [&](folly::Range<char**> rows) { table_->erase(rows); },
-      ROW(std::move(names), std::move(types)),
-      spillConfig_->filePath,
-      spillConfig_->writeBufferSize,
-      spillConfig_->compressionKind,
-      memory::spillMemoryPool(),
-      spillConfig_->executor);
-
-  ++(*numSpillRuns_);
-  spiller_->spill(rowIterator);
+      makeSpillType(),
+      spillConfig_,
+      spillStats_);
+
+  // Spilling may execute on multiple partitions in parallel, and
+  // HashStringAllocator is not thread safe. If any aggregations
+  // allocate/deallocate memory during spilling it can lead to concurrency bugs.
+  // Freeze the HashStringAllocator to make it effectively immutable and
+  // guarantee we don't accidentally enter an unsafe situation.
+  rows->stringAllocator().freezeAndExecute(
+      [&]() { spiller_->spill(rowIterator); });
   table_->clear();
 }
 
@@ -961,122 +1037,187 @@ bool GroupingSet::getOutputWithSpill(
     int32_t maxOutputRows,
     int32_t maxOutputBytes,
     const RowVectorPtr& result) {
-  if (outputPartition_ == -1) {
-    mergeArgs_.resize(1);
-    std::vector<TypePtr> keyTypes;
-    for (auto& hasher : table_->hashers()) {
-      keyTypes.push_back(hasher->type());
+  if (outputSpillPartition_ == -1) {
+    VELOX_CHECK_NULL(mergeRows_);
+    VELOX_CHECK(mergeArgs_.empty());
+
+    if (!isDistinct()) {
+      mergeArgs_.resize(1);
+      std::vector<TypePtr> keyTypes;
+      for (auto& hasher : table_->hashers()) {
+        keyTypes.push_back(hasher->type());
+      }
+
+      mergeRows_ = std::make_unique<RowContainer>(
+          keyTypes,
+          !ignoreNullKeys_,
+          accumulators(false),
+          std::vector<TypePtr>(),
+          false,
+          false,
+          false,
+          false,
+          &pool_);
+
+      initializeAggregates(aggregates_, *mergeRows_, false);
     }
+    VELOX_CHECK_EQ(table_->rows()->numRows(), 0);
+    table_->clear(/*freeTable=*/true);
 
-    mergeRows_ = std::make_unique<RowContainer>(
-        keyTypes,
-        !ignoreNullKeys_,
-        accumulators(false),
-        std::vector<TypePtr>(),
-        false,
-        false,
-        false,
-        false,
-        &pool_,
-        table_->rows()->stringAllocatorShared());
-
-    initializeAggregates(aggregates_, *mergeRows_, false);
-
-    // Take ownership of the rows and free the hash table. The table will not be
-    // needed for producing spill output.
-    nonSpilledRowContainer_ = table_->moveRows();
-    table_.reset();
-    outputPartition_ = 0;
-    nonSpilledRows_ = spiller_->finishSpill();
-  }
-
-  // NOTE: we don't expect non-spilled rows if spilling is triggered during the
-  // aggregation output processing.
-  if (spiller_->type() == Spiller::Type::kAggregateOutput) {
-    VELOX_CHECK_EQ(nonSpilledRows_.value().size(), 0);
-  }
-
-  if (nonSpilledRowIndex_ < nonSpilledRows_.value().size()) {
-    const int32_t numGroups =
-        numNonSpilledGroupsToExtract(maxOutputRows, maxOutputBytes);
-    extractGroups(
-        folly::Range<char**>(
-            nonSpilledRows_.value().data() + nonSpilledRowIndex_, numGroups),
-        result);
-    nonSpilledRowIndex_ += numGroups;
-    return true;
-  }
+    VELOX_CHECK_NULL(merge_);
+    spiller_->finishSpill(spillPartitionSet_);
+    removeEmptyPartitions(spillPartitionSet_);
 
-  while (outputPartition_ < spiller_->state().maxPartitions()) {
-    if (merge_ == nullptr) {
-      merge_ = spiller_->startMerge(outputPartition_);
-    }
-    // NOTE: 'merge_' might be nullptr if 'outputPartition_' is empty.
-    if (merge_ == nullptr ||
-        !mergeNext(maxOutputRows, maxOutputBytes, result)) {
-      ++outputPartition_;
-      merge_ = nullptr;
-      continue;
+    if (!prepareNextSpillPartitionOutput()) {
+      VELOX_CHECK_NULL(merge_);
+      return false;
     }
-    return true;
   }
-  return false;
+  VELOX_CHECK_NOT_NULL(merge_);
+  return mergeNext(maxOutputRows, maxOutputBytes, result);
 }
 
-size_t GroupingSet::numNonSpilledGroupsToExtract(
-    int32_t maxOutputRows,
-    int32_t maxOutputBytes) const {
-  const size_t maxNumGroups = std::min<vector_size_t>(
-      maxOutputRows, nonSpilledRows_.value().size() - nonSpilledRowIndex_);
-  size_t totalBytes{0};
-  size_t nextRow = nonSpilledRowIndex_;
-  size_t numGroups{0};
-  for (; numGroups < maxNumGroups; ++numGroups, ++nextRow) {
-    const auto rowSize =
-        nonSpilledRowContainer_->rowSize(nonSpilledRows_.value()[nextRow]);
-    if (numGroups > 0 && (totalBytes + rowSize) >= maxOutputBytes) {
-      break;
-    }
-    totalBytes += rowSize;
+bool GroupingSet::prepareNextSpillPartitionOutput() {
+  VELOX_CHECK_EQ(merge_ == nullptr, outputSpillPartition_ == -1);
+  merge_ = nullptr;
+  if (spillPartitionSet_.empty()) {
+    return false;
   }
-  return numGroups;
+  auto it = spillPartitionSet_.begin();
+  VELOX_CHECK_NE(outputSpillPartition_, it->first.partitionNumber());
+  outputSpillPartition_ = it->first.partitionNumber();
+  merge_ = it->second->createOrderedReader(
+      spillConfig_->readBufferSize, &pool_, spillStats_);
+  spillPartitionSet_.erase(it);
+  return true;
 }
 
 bool GroupingSet::mergeNext(
     int32_t maxOutputRows,
     int32_t maxOutputBytes,
     const RowVectorPtr& result) {
+  if (isDistinct()) {
+    return mergeNextWithoutAggregates(maxOutputRows, result);
+  } else {
+    return mergeNextWithAggregates(maxOutputRows, maxOutputBytes, result);
+  }
+}
+
+bool GroupingSet::mergeNextWithAggregates(
+    int32_t maxOutputRows,
+    int32_t maxOutputBytes,
+    const RowVectorPtr& result) {
+  VELOX_CHECK(!isDistinct());
+  VELOX_CHECK_NOT_NULL(merge_);
+
+  // True if 'merge_' indicates that the next key is the same as the current
+  // one.
+  bool nextKeyIsEqual{false};
   for (;;) {
-    auto next = merge_->nextWithEquals();
-    if (!next.first) {
+    const auto next = merge_->nextWithEquals();
+    if (next.first == nullptr) {
       extractSpillResult(result);
-      return result->size() > 0;
+      if (result->size() > 0) {
+        return true;
+      }
+      VELOX_CHECK(!nextKeyIsEqual);
+      if (!prepareNextSpillPartitionOutput()) {
+        VELOX_CHECK_NULL(merge_);
+        return false;
+      }
+      VELOX_CHECK_NOT_NULL(merge_);
+      continue;
     }
-    if (!nextKeyIsEqual_) {
+    if (!nextKeyIsEqual) {
       mergeState_ = mergeRows_->newRow();
       initializeRow(*next.first, mergeState_);
     }
     updateRow(*next.first, mergeState_);
-    nextKeyIsEqual_ = next.second;
+    nextKeyIsEqual = next.second;
     next.first->pop();
-    if (!nextKeyIsEqual_ &&
+    if (!nextKeyIsEqual &&
         ((mergeRows_->numRows() >= maxOutputRows) ||
          (mergeRows_->allocatedBytes() >= maxOutputBytes))) {
       extractSpillResult(result);
       return true;
     }
   }
+  VELOX_UNREACHABLE();
+}
+
+bool GroupingSet::mergeNextWithoutAggregates(
+    int32_t maxOutputRows,
+    const RowVectorPtr& result) {
+  VELOX_CHECK_NOT_NULL(merge_);
+  VELOX_CHECK(isDistinct());
+  VELOX_CHECK_EQ(
+      numDistinctSpillFilesPerPartition_.size(),
+      spiller_->state().maxPartitions());
+
+  // We are looping over sorted rows produced by tree-of-losers. We logically
+  // split the stream into runs of duplicate rows. As we process each run we
+  // track whether one of the values coming from distinct streams, in which case
+  // we should not produce a result from that run. Otherwise, we produce a
+  // result at the end of the run (when we know for sure whether the run
+  // contains a row from the distinct streams).
+  //
+  // NOTE: the distinct stream refers to the stream that contains the spilled
+  // distinct hash table. A distinct stream contains rows which has already
+  // been output as distinct before we trigger spilling. A distinct stream id is
+  // less than 'numDistinctSpillFilesPerPartition_'.
+  bool newDistinct{true};
+  int32_t numOutputRows{0};
+  while (numOutputRows < maxOutputRows) {
+    const auto next = merge_->nextWithEquals();
+    auto* stream = next.first;
+    if (stream == nullptr) {
+      if (numOutputRows > 0) {
+        break;
+      }
+      if (!prepareNextSpillPartitionOutput()) {
+        VELOX_CHECK_NULL(merge_);
+        break;
+      }
+      VELOX_CHECK_NOT_NULL(merge_);
+      continue;
+    }
+    if (stream->id() <
+        numDistinctSpillFilesPerPartition_[outputSpillPartition_]) {
+      newDistinct = false;
+    }
+    if (next.second) {
+      stream->pop();
+      continue;
+    }
+    if (newDistinct) {
+      // Yield result for new distinct.
+      result->copy(
+          &stream->current(), numOutputRows++, stream->currentIndex(), 1);
+    }
+    stream->pop();
+    newDistinct = true;
+  }
+  result->resize(numOutputRows);
+  return numOutputRows > 0;
 }
 
-void GroupingSet::initializeRow(SpillMergeStream& keys, char* row) {
+void GroupingSet::initializeRow(SpillMergeStream& stream, char* row) {
   for (auto i = 0; i < keyChannels_.size(); ++i) {
-    mergeRows_->store(keys.decoded(i), keys.currentIndex(), mergeState_, i);
+    mergeRows_->store(stream.decoded(i), stream.currentIndex(), mergeState_, i);
   }
   vector_size_t zero = 0;
   for (auto& aggregate : aggregates_) {
+    if (!aggregate.sortingKeys.empty()) {
+      continue;
+    }
     aggregate.function->initializeNewGroups(
         &row, folly::Range<const vector_size_t*>(&zero, 1));
   }
+
+  if (sortedAggregations_ != nullptr) {
+    sortedAggregations_->initializeNewGroups(
+        &row, folly::Range<const vector_size_t*>(&zero, 1));
+  }
 }
 
 void GroupingSet::extractSpillResult(const RowVectorPtr& result) {
@@ -1098,11 +1239,21 @@ void GroupingSet::updateRow(SpillMergeStream& input, char* row) {
   mergeSelection_.setValid(input.currentIndex(), true);
   mergeSelection_.updateBounds();
   for (auto i = 0; i < aggregates_.size(); ++i) {
+    if (!aggregates_[i].sortingKeys.empty()) {
+      continue;
+    }
     mergeArgs_[0] = input.current().childAt(i + keyChannels_.size());
     aggregates_[i].function->addSingleGroupIntermediateResults(
         row, mergeSelection_, mergeArgs_, false);
   }
   mergeSelection_.setValid(input.currentIndex(), false);
+
+  if (sortedAggregations_ != nullptr) {
+    const auto& vector =
+        input.current().childAt(aggregates_.size() + keyChannels_.size());
+    sortedAggregations_->addSingleGroupSpillInput(
+        row, vector, input.currentIndex());
+  }
 }
 
 void GroupingSet::abandonPartialAggregation() {
@@ -1124,12 +1275,27 @@ void GroupingSet::abandonPartialAggregation() {
       false,
       false,
       false,
-      &pool_,
-      table_->rows()->stringAllocatorShared());
+      &pool_);
   initializeAggregates(aggregates_, *intermediateRows_, true);
   table_.reset();
 }
 
+namespace {
+// Recursive resize all children.
+
+void recursiveResizeChildren(VectorPtr& vector, vector_size_t newSize) {
+  VELOX_CHECK(vector.unique());
+  if (vector->typeKind() == TypeKind::ROW) {
+    auto rowVector = vector->asUnchecked<RowVector>();
+    for (auto& child : rowVector->children()) {
+      recursiveResizeChildren(child, newSize);
+    }
+  }
+  vector->resize(newSize);
+}
+
+} // namespace
+
 void GroupingSet::toIntermediate(
     const RowVectorPtr& input,
     RowVectorPtr& result) {
@@ -1162,8 +1328,7 @@ void GroupingSet::toIntermediate(
   for (auto i = 0; i < aggregates_.size(); ++i) {
     auto& function = aggregates_[i].function;
     auto& aggregateVector = result->childAt(i + keyChannels_.size());
-    VELOX_CHECK(aggregateVector.unique());
-    aggregateVector->resize(input->size());
+    recursiveResizeChildren(aggregateVector, input->size());
     const auto& rows = getSelectivityVector(i);
 
     if (function->supportsToIntermediate()) {
@@ -1206,9 +1371,6 @@ void GroupingSet::toIntermediate(
   if (intermediateRows_) {
     intermediateRows_->eraseRows(folly::Range<char**>(
         intermediateGroups_.data(), intermediateGroups_.size()));
-    if (intermediateRows_->checkFree()) {
-      intermediateRows_->stringAllocator().checkEmpty();
-    }
   }
 
   // It's unnecessary to call function->clear() to reset the internal states of
@@ -1218,12 +1380,10 @@ void GroupingSet::toIntermediate(
   tempVectors_.clear();
 }
 
-std::optional<int64_t> GroupingSet::estimateRowSize() const {
-  const RowContainer* rows =
-      table_ ? table_->rows() : nonSpilledRowContainer_.get();
-  return rows && rows->estimateRowSize() >= 0
-      ? std::optional<int64_t>(rows->estimateRowSize())
-      : std::nullopt;
-};
-
+std::optional<int64_t> GroupingSet::estimateOutputRowSize() const {
+  if (table_ == nullptr) {
+    return std::nullopt;
+  }
+  return table_->rows()->estimateRowSize();
+}
 } // namespace facebook::velox::exec
diff --git a/velox/exec/GroupingSet.h b/velox/exec/GroupingSet.h
index 562e96816d2eb..bd88b7d1077f8 100644
--- a/velox/exec/GroupingSet.h
+++ b/velox/exec/GroupingSet.h
@@ -36,10 +36,12 @@ class GroupingSet {
       bool ignoreNullKeys,
       bool isPartial,
       bool isRawInput,
+      const std::vector<vector_size_t>& globalGroupingSets,
+      const std::optional<column_index_t>& groupIdChannel,
       const common::SpillConfig* spillConfig,
-      uint32_t* numSpillRuns,
       tsan_atomic<bool>* nonReclaimableSection,
-      OperatorCtx* operatorCtx);
+      OperatorCtx* operatorCtx,
+      folly::Synchronized<common::SpillStats>* spillStats);
 
   ~GroupingSet();
 
@@ -74,7 +76,10 @@ class GroupingSet {
 
   uint64_t allocatedBytes() const;
 
-  void resetPartial();
+  /// Resets the hash table inside the grouping set when partial aggregation
+  /// is full or reclaims memory from distinct aggregation after it has received
+  /// all the inputs.
+  void resetTable();
 
   /// Returns true if 'this' should start producing partial
   /// aggregation results. Checks the memory consumption against
@@ -89,23 +94,25 @@ class GroupingSet {
     return table_ ? table_->numDistinct() : 0;
   }
 
+  /// Returns number of global grouping sets rows if there is default output.
+  std::optional<vector_size_t> numDefaultGlobalGroupingSetRows() const {
+    if (hasDefaultGlobalGroupingSetOutput()) {
+      return globalGroupingSets_.size();
+    }
+    return std::nullopt;
+  }
+
   const HashLookup& hashLookup() const;
 
-  /// Spills content until under 'targetRows' and under 'targetBytes'
-  /// of out of line data are left. If targetRows is 0, spills
-  /// everything and physically frees the data in the
-  /// 'table_->rows()'. This leaves 'table_' initialized and 'this'
-  /// ready to accumulate more input. This is called by ensureInputFits
-  /// or by external memory management. In the latter case, the Driver
-  /// of this will be in a paused state and off thread.
-  void spill(int64_t targetRows, int64_t targetBytes);
+  /// Spills all the rows in container.
+  void spill();
 
   /// Spills all the rows in container starting from the offset specified by
   /// 'rowIterator'.
   void spill(const RowContainerIterator& rowIterator);
 
   /// Returns the spiller stats including total bytes and rows spilled so far.
-  std::optional<SpillStats> spilledStats() const {
+  std::optional<common::SpillStats> spilledStats() const {
     if (spiller_ == nullptr) {
       return std::nullopt;
     }
@@ -133,14 +140,25 @@ class GroupingSet {
   /// single input row. Passes grouping keys through.
   void toIntermediate(const RowVectorPtr& input, RowVectorPtr& result);
 
-  /// Returns an estimate of the average row size.
-  std::optional<int64_t> estimateRowSize() const;
+  /// Returns default global grouping sets output if there are no input rows.
+  /// The default global grouping set output is a single row per global grouping
+  /// set with the groupId key and the default aggregate value.
+  /// This function can also be used with distinct aggregations.
+  bool getDefaultGlobalGroupingSetOutput(
+      RowContainerIterator& iterator,
+      RowVectorPtr& result);
 
   memory::MemoryPool& testingPool() const {
     return pool_;
   }
 
+  std::optional<int64_t> estimateOutputRowSize() const;
+
  private:
+  bool isDistinct() const {
+    return aggregates_.empty();
+  }
+
   void addInputForActiveRows(const RowVectorPtr& input, bool mayPushdown);
 
   void addRemainingInput();
@@ -152,11 +170,16 @@ class GroupingSet {
   void addGlobalAggregationInput(const RowVectorPtr& input, bool mayPushdown);
 
   bool getGlobalAggregationOutput(
-      int32_t batchSize,
-      bool isPartial,
       RowContainerIterator& iterator,
       RowVectorPtr& result);
 
+  // If there are global grouping sets, then returns if they have default
+  // output in case no input rows were received.
+  bool hasDefaultGlobalGroupingSetOutput() const {
+    return noMoreInput_ && numInputRows_ == 0 && !globalGroupingSets_.empty() &&
+        isRawInput_;
+  }
+
   void createHashTable();
 
   void populateTempVectors(int32_t aggregateIndex, const RowVectorPtr& input);
@@ -190,17 +213,34 @@ class GroupingSet {
       int32_t maxOutputBytes,
       const RowVectorPtr& result);
 
-  // Reads rows from the current spilled partition until producing a batch of
-  // final results in 'result'. Returns false and leaves 'result' empty when
-  // the partition is fully read. 'maxOutputRows' and 'maxOutputBytes' specify
-  // the max number of output rows and bytes in 'result'.
+  // Prepares for the next spill partition for output. It sets
+  // 'outputSpillPartition_' to the number of the next spill partition, and
+  // creates 'merge_' to read from it. The function returns false if all the
+  // spilled partitions have been processed.
+  bool prepareNextSpillPartitionOutput();
+
+  // Reads from spilled rows until producing a batch of final results in
+  // 'result'. Returns false and leaves 'result' empty when the spilled data is
+  // fully read. 'maxOutputRows' and 'maxOutputBytes' specify the max number of
+  // output rows and bytes in 'result'.
   bool mergeNext(
       int32_t maxOutputRows,
       int32_t maxOutputBytes,
       const RowVectorPtr& result);
 
+  // Reads from spilled rows for group by with aggregates.
+  bool mergeNextWithAggregates(
+      int32_t maxOutputRows,
+      int32_t maxOutputBytes,
+      const RowVectorPtr& result);
+
+  // Reads from spilled rows for group by without aggregates.
+  bool mergeNextWithoutAggregates(
+      int32_t maxOutputRows,
+      const RowVectorPtr& result);
+
   // Initializes a new row in 'mergeRows' with the keys from the
-  // current element from 'keys'. Accumulators are left in the initial
+  // current element from 'stream'. Accumulators are left in the initial
   // state with no data accumulated. This is called each time a new
   // key is received from a merge of spilled data. After this
   // updateRow() is called on the same element and on every subsequent
@@ -209,31 +249,26 @@ class GroupingSet {
   // accumulated and we have a new key, we produce the output and
   // clear 'mergeRows_' with extractSpillResult() and only then do
   // initializeRow().
-  void initializeRow(SpillMergeStream& keys, char* row);
+  void initializeRow(SpillMergeStream& stream, char* row);
 
   // Updates the accumulators in 'row' with the intermediate type data from
   // 'keys'. This is called for each row received from a merge of spilled data.
   void updateRow(SpillMergeStream& keys, char* row);
 
+  // Returns a RowType of the spilled data.
+  RowTypePtr makeSpillType() const;
+
   // Copies the finalized state from 'mergeRows' to 'result' and clears
   // 'mergeRows'. Used for producing a batch of results when aggregating spilled
   // groups.
   void extractSpillResult(const RowVectorPtr& result);
 
-  // Return a list of accumulators for 'aggregates_', plus one more accumulator
+  // Returns a list of accumulators for 'aggregates_', plus one more accumulator
   // for 'sortedAggregations_', and one for each 'distinctAggregations_'.  When
   // 'excludeToIntermediate' is true, skip the functions that support
   // 'toIntermediate'.
   std::vector<Accumulator> accumulators(bool excludeToIntermediate);
 
-  // Calculates the number of groups to extract from 'rowsWhileReadingSpill_'
-  // container with rows starting at 'nonSpilledIndex_' in 'nonSpilledRows_'.
-  // 'maxOutputRows' and 'maxOutputBytes' specifies the max number of groups and
-  // bytes to extract.
-  size_t numNonSpilledGroupsToExtract(
-      int32_t maxOutputRows,
-      int32_t maxOutputBytes) const;
-
   std::vector<column_index_t> keyChannels_;
 
   /// A subset of grouping keys on which the input is clustered.
@@ -243,7 +278,7 @@ class GroupingSet {
   const bool isGlobal_;
   const bool isPartial_;
   const bool isRawInput_;
-  const core::QueryConfig* const queryConfig_;
+  const core::QueryConfig& queryConfig_;
 
   std::vector<AggregateInfo> aggregates_;
   AggregationMasks masks_;
@@ -252,13 +287,14 @@ class GroupingSet {
 
   const bool ignoreNullKeys_;
 
-  // The maximum memory usage that a final aggregation can hold before spilling.
-  // If it is zero, then there is no such limit.
-  const uint64_t spillMemoryThreshold_;
+  uint64_t numInputRows_ = 0;
 
-  const common::SpillConfig* const spillConfig_;
+  // List of global grouping set numbers, if being used with a GROUPING SET.
+  const std::vector<vector_size_t> globalGroupingSets_;
+  // Column for groupId for a GROUPING SET.
+  std::optional<column_index_t> groupIdChannel_;
 
-  uint32_t* const numSpillRuns_;
+  const common::SpillConfig* const spillConfig_;
 
   // Indicates if this grouping set and the associated hash aggregation operator
   // is under non-reclaimable execution section or not.
@@ -284,12 +320,12 @@ class GroupingSet {
 
   bool noMoreInput_{false};
 
-  /// In case of partial streaming aggregation, the input vector passed to
-  /// addInput(). A set of rows that belong to the last group of pre-grouped
-  /// keys need to be processed after flushing the hash table and accumulators.
+  // In case of partial streaming aggregation, the input vector passed to
+  // addInput(). A set of rows that belong to the last group of pre-grouped
+  // keys need to be processed after flushing the hash table and accumulators.
   RowVectorPtr remainingInput_;
 
-  /// First row in remainingInput_ that needs to be processed.
+  // First row in remainingInput_ that needs to be processed.
   vector_size_t firstRemainingRow_;
 
   // The value of mayPushdown flag specified in addInput() for the
@@ -297,6 +333,17 @@ class GroupingSet {
   bool remainingMayPushdown_;
 
   std::unique_ptr<Spiller> spiller_;
+
+  // The current spill partition in producing spill output. If it is -1, then we
+  // haven't started yet.
+  int32_t outputSpillPartition_{-1};
+
+  SpillPartitionSet spillPartitionSet_;
+
+  // Sets to the number of files storing the spilled distinct hash table per
+  // each spill partition. These are the files generated by the first spill
+  // call. This only applies for distinct hash aggregation.
+  std::vector<size_t> numDistinctSpillFilesPerPartition_;
   std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge_;
 
   // Container for materializing batches of output from spilling.
@@ -305,9 +352,6 @@ class GroupingSet {
   // The row with the current merge state, allocated from 'mergeRow_'.
   char* mergeState_ = nullptr;
 
-  // The currently running spill partition in producing spilld output.
-  int32_t outputPartition_{-1};
-
   // Intermediate vector for passing arguments to aggregate in merging spill.
   std::vector<VectorPtr> mergeArgs_;
 
@@ -315,28 +359,9 @@ class GroupingSet {
   // to merge.
   SelectivityVector mergeSelection_;
 
-  // True if 'merge_' indicates that the next key is the same as the current
-  // one.
-  bool nextKeyIsEqual_{false};
-
-  // The set of rows that are outside of the spillable hash number ranges. Used
-  // when producing output.
-  std::optional<Spiller::SpillRows> nonSpilledRows_;
-
-  // Index of first in 'nonSpilledRows_' that has not been added to output.
-  size_t nonSpilledRowIndex_{0};
-
   // Pool of the OperatorCtx. Used for spilling.
   memory::MemoryPool& pool_;
 
-  // The RowContainer of 'table_' is moved here before freeing 'table_' when
-  // starting to read spill output.
-  std::unique_ptr<RowContainer> nonSpilledRowContainer_;
-
-  // Counts input batches and triggers spilling if folly hash of this % 100 <=
-  // 'testSpillPct_';.
-  uint64_t spillTestCounter_{0};
-
   // True if partial aggregation has been given up as non-productive.
   bool abandonedPartialAggregation_{false};
 
@@ -352,6 +377,8 @@ class GroupingSet {
   // Temporary for case where an aggregate in toIntermediate() outputs post-init
   // state of aggregate for all rows.
   std::vector<char*> firstGroup_;
+
+  folly::Synchronized<common::SpillStats>* const spillStats_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/HashAggregation.cpp b/velox/exec/HashAggregation.cpp
index d6898d0f40f9c..05c2f73c5fd29 100644
--- a/velox/exec/HashAggregation.cpp
+++ b/velox/exec/HashAggregation.cpp
@@ -15,88 +15,11 @@
  */
 #include "velox/exec/HashAggregation.h"
 #include <optional>
-#include "velox/exec/Aggregate.h"
-#include "velox/exec/OperatorUtils.h"
-#include "velox/exec/SortedAggregations.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/Expr.h"
 
 namespace facebook::velox::exec {
 
-namespace {
-std::vector<core::LambdaTypedExprPtr> extractLambdaInputs(
-    const core::AggregationNode::Aggregate& aggregate) {
-  std::vector<core::LambdaTypedExprPtr> lambdas;
-  for (const auto& arg : aggregate.call->inputs()) {
-    if (auto lambda =
-            std::dynamic_pointer_cast<const core::LambdaTypedExpr>(arg)) {
-      lambdas.push_back(lambda);
-    }
-  }
-
-  return lambdas;
-}
-
-std::vector<TypePtr> populateAggregateInputs(
-    const core::AggregationNode::Aggregate& aggregate,
-    const RowType& inputType,
-    AggregateInfo& info,
-    memory::MemoryPool* pool) {
-  auto& channels = info.inputs;
-  auto& constants = info.constantInputs;
-  std::vector<TypePtr> argTypes;
-  for (const auto& arg : aggregate.call->inputs()) {
-    argTypes.push_back(arg->type());
-    if (auto field =
-            dynamic_cast<const core::FieldAccessTypedExpr*>(arg.get())) {
-      channels.push_back(inputType.getChildIdx(field->name()));
-      constants.push_back(nullptr);
-    } else if (
-        auto constant =
-            dynamic_cast<const core::ConstantTypedExpr*>(arg.get())) {
-      channels.push_back(kConstantChannel);
-      constants.push_back(constant->toConstantVector(pool));
-    } else if (
-        auto lambda = dynamic_cast<const core::LambdaTypedExpr*>(arg.get())) {
-      for (const auto& name : lambda->signature()->names()) {
-        if (auto captureIndex = inputType.getChildIdxIfExists(name)) {
-          channels.push_back(captureIndex.value());
-          constants.push_back(nullptr);
-        }
-      }
-    } else {
-      VELOX_FAIL(
-          "Expression must be field access, constant, or lambda: {}",
-          arg->toString());
-    }
-  }
-
-  return argTypes;
-}
-
-void verifyIntermediateInputs(
-    const std::string& name,
-    const std::vector<TypePtr>& types) {
-  VELOX_USER_CHECK_GE(
-      types.size(),
-      1,
-      "Intermediate aggregates must have at least one argument: {}",
-      name);
-  VELOX_USER_CHECK_NE(
-      types[0]->kind(),
-      TypeKind::FUNCTION,
-      "First argument of an intermediate aggregate cannot be a lambda: {}",
-      name);
-  for (auto i = 1; i < types.size(); ++i) {
-    VELOX_USER_CHECK_EQ(
-        types[i]->kind(),
-        TypeKind::FUNCTION,
-        "Non-first argument of an intermediate aggregate must be a lambda: {}",
-        name);
-  }
-}
-} // namespace
-
 HashAggregation::HashAggregation(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -112,112 +35,39 @@ HashAggregation::HashAggregation(
           aggregationNode->canSpill(driverCtx->queryConfig())
               ? driverCtx->makeSpillConfig(operatorId)
               : std::nullopt),
+      aggregationNode_(aggregationNode),
       isPartialOutput_(isPartialOutput(aggregationNode->step())),
       isGlobal_(aggregationNode->groupingKeys().empty()),
       isDistinct_(!isGlobal_ && aggregationNode->aggregates().empty()),
       maxExtendedPartialAggregationMemoryUsage_(
           driverCtx->queryConfig().maxExtendedPartialAggregationMemoryUsage()),
-      maxPartialAggregationMemoryUsage_(
-          driverCtx->queryConfig().maxPartialAggregationMemoryUsage()),
       abandonPartialAggregationMinRows_(
           driverCtx->queryConfig().abandonPartialAggregationMinRows()),
       abandonPartialAggregationMinPct_(
-          driverCtx->queryConfig().abandonPartialAggregationMinPct()) {
-  VELOX_CHECK(pool()->trackUsage());
+          driverCtx->queryConfig().abandonPartialAggregationMinPct()),
+      maxPartialAggregationMemoryUsage_(
+          driverCtx->queryConfig().maxPartialAggregationMemoryUsage()) {}
+
+void HashAggregation::initialize() {
+  Operator::initialize();
 
-  auto inputType = aggregationNode->sources()[0]->outputType();
+  VELOX_CHECK(pool()->trackUsage());
 
+  const auto& inputType = aggregationNode_->sources()[0]->outputType();
   auto hashers =
-      createVectorHashers(inputType, aggregationNode->groupingKeys());
+      createVectorHashers(inputType, aggregationNode_->groupingKeys());
   auto numHashers = hashers.size();
 
   std::vector<column_index_t> preGroupedChannels;
-  preGroupedChannels.reserve(aggregationNode->preGroupedKeys().size());
-  for (const auto& key : aggregationNode->preGroupedKeys()) {
+  preGroupedChannels.reserve(aggregationNode_->preGroupedKeys().size());
+  for (const auto& key : aggregationNode_->preGroupedKeys()) {
     auto channel = exprToChannel(key.get(), inputType);
     preGroupedChannels.push_back(channel);
   }
 
-  auto numAggregates = aggregationNode->aggregates().size();
-  std::vector<AggregateInfo> aggregateInfos;
-  aggregateInfos.reserve(numAggregates);
-
   std::shared_ptr<core::ExpressionEvaluator> expressionEvaluator;
-
-  for (auto i = 0; i < numAggregates; i++) {
-    const auto& aggregate = aggregationNode->aggregates()[i];
-
-    AggregateInfo info;
-    info.distinct = aggregate.distinct;
-    auto argTypes =
-        populateAggregateInputs(aggregate, inputType->asRow(), info, pool());
-
-    if (aggregate.rawInputTypes.empty()) {
-      // Backwards-compatible code path.
-      if (isRawInput(aggregationNode->step())) {
-        info.intermediateType =
-            Aggregate::intermediateType(aggregate.call->name(), argTypes);
-      } else {
-        verifyIntermediateInputs(aggregate.call->name(), argTypes);
-        info.intermediateType = argTypes[0];
-      }
-    } else {
-      info.intermediateType = Aggregate::intermediateType(
-          aggregate.call->name(), aggregate.rawInputTypes);
-    }
-
-    // Setup aggregation mask: convert the Variable Reference name to the
-    // channel (projection) index, if there is a mask.
-    if (const auto& mask = aggregate.mask) {
-      if (mask != nullptr) {
-        info.mask = inputType->asRow().getChildIdx(mask->name());
-      }
-    }
-
-    const auto& resultType = outputType_->childAt(numHashers + i);
-    if (aggregate.rawInputTypes.empty()) {
-      // Backwards-compatible code path.
-      info.function = Aggregate::create(
-          aggregate.call->name(),
-          aggregationNode->step(),
-          argTypes,
-          resultType,
-          driverCtx->queryConfig());
-    } else {
-      info.function = Aggregate::create(
-          aggregate.call->name(),
-          isPartialOutput(aggregationNode->step())
-              ? core::AggregationNode::Step::kPartial
-              : core::AggregationNode::Step::kSingle,
-          aggregate.rawInputTypes,
-          resultType,
-          driverCtx->queryConfig());
-    }
-
-    auto lambdas = extractLambdaInputs(aggregate);
-    if (!lambdas.empty()) {
-      if (expressionEvaluator == nullptr) {
-        expressionEvaluator = std::make_shared<SimpleExpressionEvaluator>(
-            operatorCtx_->execCtx()->queryCtx(),
-            operatorCtx_->execCtx()->pool());
-      }
-      info.function->setLambdaExpressions(lambdas, expressionEvaluator);
-    }
-
-    info.output = numHashers + i;
-
-    // Sorting keys and orders.
-    const auto numSortingKeys = aggregate.sortingKeys.size();
-    VELOX_CHECK_EQ(numSortingKeys, aggregate.sortingOrders.size());
-    info.sortingOrders = aggregate.sortingOrders;
-
-    info.sortingKeys.reserve(numSortingKeys);
-    for (const auto& key : aggregate.sortingKeys) {
-      info.sortingKeys.push_back(exprToChannel(key.get(), inputType));
-    }
-
-    aggregateInfos.emplace_back(std::move(info));
-  }
+  std::vector<AggregateInfo> aggregateInfos = toAggregateInfo(
+      *aggregationNode_, *operatorCtx_, numHashers, expressionEvaluator);
 
   // Check that aggregate result type match the output type.
   for (auto i = 0; i < aggregateInfos.size(); i++) {
@@ -228,13 +78,18 @@ HashAggregation::HashAggregation(
         "Unexpected result type for an aggregation: {}, expected {}, step {}",
         aggResultType->toString(),
         expectedType->toString(),
-        core::AggregationNode::stepName(aggregationNode->step()));
+        core::AggregationNode::stepName(aggregationNode_->step()));
   }
 
-  if (isDistinct_) {
-    for (auto i = 0; i < hashers.size(); ++i) {
-      identityProjections_.emplace_back(hashers[i]->channel(), i);
-    }
+  for (auto i = 0; i < hashers.size(); ++i) {
+    identityProjections_.emplace_back(hashers[i]->channel(), i);
+  }
+
+  std::optional<column_index_t> groupIdChannel;
+  if (aggregationNode_->groupId().has_value()) {
+    groupIdChannel = outputType_->getChildIdxIfExists(
+        aggregationNode_->groupId().value()->name());
+    VELOX_CHECK(groupIdChannel.has_value());
   }
 
   groupingSet_ = std::make_unique<GroupingSet>(
@@ -242,13 +97,17 @@ HashAggregation::HashAggregation(
       std::move(hashers),
       std::move(preGroupedChannels),
       std::move(aggregateInfos),
-      aggregationNode->ignoreNullKeys(),
+      aggregationNode_->ignoreNullKeys(),
       isPartialOutput_,
-      isRawInput(aggregationNode->step()),
+      isRawInput(aggregationNode_->step()),
+      aggregationNode_->globalGroupingSets(),
+      groupIdChannel,
       spillConfig_.has_value() ? &spillConfig_.value() : nullptr,
-      &numSpillRuns_,
       &nonReclaimableSection_,
-      operatorCtx_.get());
+      operatorCtx_.get(),
+      &spillStats_);
+
+  aggregationNode_.reset();
 }
 
 bool HashAggregation::abandonPartialAggregationEarly(int64_t numOutput) const {
@@ -284,15 +143,16 @@ void HashAggregation::addInput(RowVectorPtr input) {
   }
 
   if (isDistinct_) {
-    newDistincts_ = !groupingSet_->hashLookup().newGroups.empty();
+    newDistincts_ = !groupingSet_->hasSpilled() &&
+        !groupingSet_->hashLookup().newGroups.empty();
 
     if (newDistincts_) {
       // Save input to use for output in getOutput().
       input_ = input;
-    } else if (abandonPartialEarly) {
-      // If no new distinct groups (meaning we don't have anything to output)
-      // and we are abandoning the partial aggregation, then we need to ensure
-      // we 'need input'. For that we need to reset the 'partial full' flag.
+    } else {
+      // If no new distinct groups (meaning we don't have anything to output),
+      // then we need to ensure we 'need input'. For that we need to reset
+      // the 'partial full' flag.
       partialFull_ = false;
     }
   }
@@ -318,25 +178,16 @@ void HashAggregation::updateRuntimeStats() {
     }
   }
 
-  runtimeStats["hashtable.capacity"] = RuntimeMetric(hashTableStats.capacity);
-  runtimeStats["hashtable.numRehashes"] =
+  runtimeStats[BaseHashTable::kCapacity] =
+      RuntimeMetric(hashTableStats.capacity);
+  runtimeStats[BaseHashTable::kNumRehashes] =
       RuntimeMetric(hashTableStats.numRehashes);
-  runtimeStats["hashtable.numDistinct"] =
+  runtimeStats[BaseHashTable::kNumDistinct] =
       RuntimeMetric(hashTableStats.numDistinct);
-  runtimeStats["hashtable.numTombstones"] =
+  runtimeStats[BaseHashTable::kNumTombstones] =
       RuntimeMetric(hashTableStats.numTombstones);
 }
 
-void HashAggregation::recordSpillStats() {
-  auto spillStatsOr = groupingSet_->spilledStats();
-  if (!spillStatsOr.has_value()) {
-    return;
-  }
-  VELOX_CHECK_EQ(spillStatsOr.value().spillRuns, 0);
-  spillStatsOr.value().spillRuns = numSpillRuns_;
-  Operator::recordSpillStats(spillStatsOr.value());
-}
-
 void HashAggregation::prepareOutput(vector_size_t size) {
   if (output_) {
     VectorPtr output = std::move(output_);
@@ -363,7 +214,7 @@ void HashAggregation::resetPartialOutputIfNeed() {
     lockedStats->addRuntimeStat(
         "partialAggregationPct", RuntimeCounter(aggregationPct));
   }
-  groupingSet_->resetPartial();
+  groupingSet_->resetTable();
   partialFull_ = false;
   if (!finished_) {
     maybeIncreasePartialAggregationMemoryUsage(aggregationPct);
@@ -441,15 +292,41 @@ RowVectorPtr HashAggregation::getOutput() {
   }
 
   if (isDistinct_) {
-    if (!newDistincts_) {
-      if (noMoreInput_) {
-        finished_ = true;
-      }
-      return nullptr;
+    return getDistinctOutput();
+  }
+
+  const auto& queryConfig = operatorCtx_->driverCtx()->queryConfig();
+  const auto maxOutputRows =
+      isGlobal_ ? 1 : outputBatchRows(estimatedOutputRowSize_);
+  // Reuse output vectors if possible.
+  prepareOutput(maxOutputRows);
+
+  const bool hasData = groupingSet_->getOutput(
+      maxOutputRows,
+      queryConfig.preferredOutputBatchBytes(),
+      resultIterator_,
+      output_);
+  if (!hasData) {
+    resultIterator_.reset();
+    if (noMoreInput_) {
+      finished_ = true;
     }
+    resetPartialOutputIfNeed();
+    return nullptr;
+  }
+  numOutputRows_ += output_->size();
+  return output_;
+}
+
+RowVectorPtr HashAggregation::getDistinctOutput() {
+  VELOX_CHECK(isDistinct_);
+  VELOX_CHECK(!finished_);
 
-    auto lookup = groupingSet_->hashLookup();
-    auto size = lookup.newGroups.size();
+  if (newDistincts_) {
+    VELOX_CHECK_NOT_NULL(input_);
+
+    auto& lookup = groupingSet_->hashLookup();
+    const auto size = lookup.newGroups.size();
     BufferPtr indices = allocateIndices(size, operatorCtx_->pool());
     auto indicesPtr = indices->asMutable<vector_size_t>();
     std::copy(lookup.newGroups.begin(), lookup.newGroups.end(), indicesPtr);
@@ -464,24 +341,36 @@ RowVectorPtr HashAggregation::getOutput() {
     resetPartialOutputIfNeed();
     return output;
   }
+  VELOX_CHECK(!newDistincts_);
 
-  const auto& queryConfig = operatorCtx_->driverCtx()->queryConfig();
-  const auto maxOutputRows =
-      isGlobal_ ? 1 : queryConfig.preferredOutputBatchRows();
-  // Reuse output vectors if possible.
-  prepareOutput(maxOutputRows);
-
-  bool hasData = groupingSet_->getOutput(
-      maxOutputRows,
-      queryConfig.preferredOutputBatchBytes(),
-      resultIterator_,
-      output_);
-  if (!hasData) {
-    resultIterator_.reset();
+  if (!groupingSet_->hasSpilled()) {
     if (noMoreInput_) {
       finished_ = true;
+      if (auto numRows = groupingSet_->numDefaultGlobalGroupingSetRows()) {
+        prepareOutput(numRows.value());
+        if (groupingSet_->getDefaultGlobalGroupingSetOutput(
+                resultIterator_, output_)) {
+          numOutputRows_ += output_->size();
+          return output_;
+        }
+      }
     }
-    resetPartialOutputIfNeed();
+    return nullptr;
+  }
+
+  if (!noMoreInput_) {
+    return nullptr;
+  }
+
+  const auto& queryConfig = operatorCtx_->driverCtx()->queryConfig();
+  const auto maxOutputRows = outputBatchRows(estimatedOutputRowSize_);
+  prepareOutput(maxOutputRows);
+  if (!groupingSet_->getOutput(
+          maxOutputRows,
+          queryConfig.preferredOutputBatchBytes(),
+          resultIterator_,
+          output_)) {
+    finished_ = true;
     return nullptr;
   }
   numOutputRows_ += output_->size();
@@ -489,9 +378,9 @@ RowVectorPtr HashAggregation::getOutput() {
 }
 
 void HashAggregation::noMoreInput() {
+  updateEstimatedOutputRowSize();
   groupingSet_->noMoreInput();
   Operator::noMoreInput();
-  recordSpillStats();
   // Release the extra reserved memory right after processing all the inputs.
   pool()->release();
 }
@@ -504,35 +393,38 @@ void HashAggregation::reclaim(
     uint64_t targetBytes,
     memory::MemoryReclaimer::Stats& stats) {
   VELOX_CHECK(canReclaim());
+  VELOX_CHECK(!nonReclaimableSection_);
 
-  // NOTE: an aggregation operator is reclaimable if it hasn't started output
-  // processing and is not under non-reclaimable execution section.
-  if (nonReclaimableSection_) {
-    // TODO: reduce the log frequency if it is too verbose.
-    ++stats.numNonReclaimableAttempts;
-    LOG(WARNING)
-        << "Can't reclaim from aggregation operator which is under non-reclaimable section: "
-        << pool()->toString();
+  if (groupingSet_ == nullptr) {
     return;
   }
 
+  updateEstimatedOutputRowSize();
+
   if (noMoreInput_) {
     if (groupingSet_->hasSpilled()) {
       LOG(WARNING)
-          << "Can't reclaim from aggregation operator which has spilled and is under output processing: "
-          << pool()->toString();
+          << "Can't reclaim from aggregation operator which has spilled and is under output processing, pool "
+          << pool()->name()
+          << ", memory usage: " << succinctBytes(pool()->usedBytes())
+          << ", reservation: " << succinctBytes(pool()->reservedBytes());
+      return;
+    }
+    if (isDistinct_) {
+      // Since we have seen all the input, we can safely reset the hash table.
+      groupingSet_->resetTable();
+      // Release the minimum reserved memory.
+      pool()->release();
       return;
     }
+
     // Spill all the rows starting from the next output row pointed by
     // 'resultIterator_'.
     groupingSet_->spill(resultIterator_);
-    // NOTE: we will only spill once during the output processing stage so
-    // record stats here.
-    recordSpillStats();
   } else {
     // TODO: support fine-grain disk spilling based on 'targetBytes' after
     // having row container memory compaction support later.
-    groupingSet_->spill(0, targetBytes);
+    groupingSet_->spill();
   }
   VELOX_CHECK_EQ(groupingSet_->numRows(), 0);
   VELOX_CHECK_EQ(groupingSet_->numDistinct(), 0);
@@ -547,7 +439,18 @@ void HashAggregation::close() {
   groupingSet_.reset();
 }
 
-void HashAggregation::abort() {
-  close();
+void HashAggregation::updateEstimatedOutputRowSize() {
+  const auto optionalRowSize = groupingSet_->estimateOutputRowSize();
+  if (!optionalRowSize.has_value()) {
+    return;
+  }
+
+  const auto rowSize = optionalRowSize.value();
+
+  if (!estimatedOutputRowSize_.has_value()) {
+    estimatedOutputRowSize_ = rowSize;
+  } else if (rowSize > estimatedOutputRowSize_.value()) {
+    estimatedOutputRowSize_ = rowSize;
+  }
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/HashAggregation.h b/velox/exec/HashAggregation.h
index 51e01897fb02f..1bf28c43428ad 100644
--- a/velox/exec/HashAggregation.h
+++ b/velox/exec/HashAggregation.h
@@ -27,6 +27,8 @@ class HashAggregation : public Operator {
       DriverCtx* driverCtx,
       const std::shared_ptr<const core::AggregationNode>& aggregationNode);
 
+  void initialize() override;
+
   void addInput(RowVectorPtr input) override;
 
   RowVectorPtr getOutput() override;
@@ -48,8 +50,6 @@ class HashAggregation : public Operator {
 
   void close() override;
 
-  void abort() override;
-
  private:
   void updateRuntimeStats();
 
@@ -70,32 +70,37 @@ class HashAggregation : public Operator {
   // 'abandonPartialAggregationMinPct_' % of rows are unique.
   bool abandonPartialAggregationEarly(int64_t numOutput) const;
 
-  // Invoked to record the spilling stats in operator stats after processing all
-  // the inputs.
-  void recordSpillStats();
+  RowVectorPtr getDistinctOutput();
+
+  void updateEstimatedOutputRowSize();
+
+  std::shared_ptr<const core::AggregationNode> aggregationNode_;
 
   const bool isPartialOutput_;
   const bool isGlobal_;
   const bool isDistinct_;
   const int64_t maxExtendedPartialAggregationMemoryUsage_;
+  // Minimum number of rows to see before deciding to give up on partial
+  // aggregation.
+  const int32_t abandonPartialAggregationMinRows_;
+  // Min unique rows pct for partial aggregation. If more than this many rows
+  // are unique, the partial aggregation is not worthwhile.
+  const int32_t abandonPartialAggregationMinPct_;
 
   int64_t maxPartialAggregationMemoryUsage_;
   std::unique_ptr<GroupingSet> groupingSet_;
 
+  // Size of a single output row estimated using
+  // 'groupingSet_->estimateRowSize()'. If spilling, this value is set to max
+  // 'groupingSet_->estimateRowSize()' across all accumulated data set.
+  std::optional<int64_t> estimatedOutputRowSize_;
+
   bool partialFull_ = false;
   bool newDistincts_ = false;
   bool finished_ = false;
   // True if partial aggregation has been found to be non-reducing.
   bool abandonedPartialAggregation_{false};
 
-  // Minimum number of rows to see before deciding to give up on partial
-  // aggregation.
-  const int32_t abandonPartialAggregationMinRows_;
-
-  // Min unique rows pct for partial aggregation. If more than this many rows
-  // are unique, the partial aggregation is not worthwhile.
-  const int32_t abandonPartialAggregationMinPct_;
-
   RowContainerIterator resultIterator_;
   bool pushdownChecked_ = false;
   bool mayPushdown_ = false;
diff --git a/velox/exec/HashBuild.cpp b/velox/exec/HashBuild.cpp
index 64ee498bce130..b7fa3eafd69fc 100644
--- a/velox/exec/HashBuild.cpp
+++ b/velox/exec/HashBuild.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "velox/exec/HashBuild.h"
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
@@ -31,6 +33,8 @@ BlockingReason fromStateToBlockingReason(HashBuild::State state) {
       [[fallthrough]];
     case HashBuild::State::kFinish:
       return BlockingReason::kNotBlocked;
+    case HashBuild::State::kYield:
+      return BlockingReason::kYield;
     case HashBuild::State::kWaitForSpill:
       return BlockingReason::kWaitForSpill;
     case HashBuild::State::kWaitForBuild:
@@ -59,35 +63,29 @@ HashBuild::HashBuild(
       joinNode_(std::move(joinNode)),
       joinType_{joinNode_->joinType()},
       nullAware_{joinNode_->isNullAware()},
+      needProbedFlagSpill_{needRightSideJoin(joinType_)},
       joinBridge_(operatorCtx_->task()->getHashJoinBridgeLocked(
           operatorCtx_->driverCtx()->splitGroupId,
           planNodeId())),
-      spillMemoryThreshold_(
-          operatorCtx_->driverCtx()->queryConfig().joinSpillMemoryThreshold()) {
+      keyChannelMap_(joinNode_->rightKeys().size()) {
   VELOX_CHECK(pool()->trackUsage());
   VELOX_CHECK_NOT_NULL(joinBridge_);
 
-  spillGroup_ = spillEnabled()
-      ? operatorCtx_->task()->getSpillOperatorGroupLocked(
-            operatorCtx_->driverCtx()->splitGroupId, planNodeId())
-      : nullptr;
-
   joinBridge_->addBuilder();
 
   auto inputType = joinNode_->sources()[1]->outputType();
 
-  auto numKeys = joinNode_->rightKeys().size();
+  const auto numKeys = joinNode_->rightKeys().size();
   keyChannels_.reserve(numKeys);
-  folly::F14FastMap<column_index_t, column_index_t> keyChannelMap(numKeys);
   std::vector<std::string> names;
   names.reserve(inputType->size());
   std::vector<TypePtr> types;
   types.reserve(inputType->size());
 
-  for (int i = 0; i < joinNode_->rightKeys().size(); ++i) {
+  for (int i = 0; i < numKeys; ++i) {
     auto& key = joinNode_->rightKeys()[i];
     auto channel = exprToChannel(key.get(), inputType);
-    keyChannelMap[channel] = i;
+    keyChannelMap_[channel] = i;
     keyChannels_.emplace_back(channel);
     names.emplace_back(inputType->nameOf(channel));
     types.emplace_back(inputType->childAt(channel));
@@ -105,7 +103,7 @@ HashBuild::HashBuild(
     decoders_.reserve(numDependents);
   }
   for (auto i = 0; i < inputType->size(); ++i) {
-    if (keyChannelMap.find(i) == keyChannelMap.end()) {
+    if (keyChannelMap_.find(i) == keyChannelMap_.end()) {
       dependentChannels_.emplace_back(i);
       decoders_.emplace_back(std::make_unique<DecodedVector>());
       names.emplace_back(inputType->nameOf(i));
@@ -116,9 +114,14 @@ HashBuild::HashBuild(
   tableType_ = ROW(std::move(names), std::move(types));
   setupTable();
   setupSpiller();
+  stateCleared_ = false;
+}
+
+void HashBuild::initialize() {
+  Operator::initialize();
 
   if (isAntiJoin(joinType_) && joinNode_->filter()) {
-    setupFilterForAntiJoins(keyChannelMap);
+    setupFilterForAntiJoins(keyChannelMap_);
   }
 }
 
@@ -194,49 +197,54 @@ void HashBuild::setupSpiller(SpillPartition* spillPartition) {
   if (!spillEnabled()) {
     return;
   }
-  const auto& spillConfig = spillConfig_.value();
-  HashBitRange hashBits(
-      spillConfig.startPartitionBit,
-      spillConfig.startPartitionBit + spillConfig.joinPartitionBits);
-  if (spillPartition == nullptr) {
-    spillGroup_->addOperator(
-        *this,
-        operatorCtx_->driver()->shared_from_this(),
-        [&](const std::vector<Operator*>& operators) { runSpill(operators); });
-  } else {
-    spillInputReader_ = spillPartition->createReader();
+  if (spillType_ == nullptr) {
+    spillType_ = hashJoinTableSpillType(tableType_, joinType_);
+    if (needProbedFlagSpill_) {
+      spillProbedFlagChannel_ = spillType_->size() - 1;
+      VELOX_CHECK_NULL(spillProbedFlagVector_);
+      // Creates a constant probed flag vector with all values false for build
+      // side table spilling.
+      spillProbedFlagVector_ = std::make_shared<ConstantVector<bool>>(
+          pool(), 0, /*isNull=*/false, BOOLEAN(), false);
+    }
+  }
 
-    const auto startBit = spillPartition->id().partitionBitOffset() +
-        spillConfig.joinPartitionBits;
+  const auto* config = spillConfig();
+  uint8_t startPartitionBit = config->startPartitionBit;
+  if (spillPartition != nullptr) {
+    spillInputReader_ = spillPartition->createUnorderedReader(
+        config->readBufferSize, pool(), &spillStats_);
+    startPartitionBit =
+        spillPartition->id().partitionBitOffset() + config->numPartitionBits;
     // Disable spilling if exceeding the max spill level and the query might run
     // out of memory if the restored partition still can't fit in memory.
-    if (spillConfig.exceedJoinSpillLevelLimit(startBit)) {
+    if (config->exceedSpillLevelLimit(startPartitionBit)) {
+      RECORD_METRIC_VALUE(kMetricMaxSpillLevelExceededCount);
+      FB_LOG_EVERY_MS(WARNING, 1'000)
+          << "Exceeded spill level limit: " << config->maxSpillLevel
+          << ", and disable spilling for memory pool: " << pool()->name();
+      ++spillStats_.wlock()->spillMaxLevelExceededCount;
+      exceededMaxSpillLevelLimit_ = true;
       return;
     }
-    hashBits = HashBitRange(startBit, startBit + spillConfig.joinPartitionBits);
+    exceededMaxSpillLevelLimit_ = false;
   }
 
   spiller_ = std::make_unique<Spiller>(
       Spiller::Type::kHashJoinBuild,
+      joinType_,
       table_->rows(),
-      [&](folly::Range<char**> rows) { table_->rows()->eraseRows(rows); },
-      tableType_,
-      std::move(hashBits),
-      keyChannels_.size(),
-      std::vector<CompareFlags>(),
-      spillConfig.filePath,
-      spillConfig.maxFileSize,
-      spillConfig.writeBufferSize,
-      spillConfig.minSpillRunSize,
-      spillConfig.compressionKind,
-      Spiller::pool(),
-      spillConfig.executor);
+      spillType_,
+      HashBitRange(
+          startPartitionBit, startPartitionBit + config->numPartitionBits),
+      config,
+      &spillStats_);
 
   const int32_t numPartitions = spiller_->hashBits().numPartitions();
   spillInputIndicesBuffers_.resize(numPartitions);
   rawSpillInputIndicesBuffers_.resize(numPartitions);
   numSpillInputs_.resize(numPartitions, 0);
-  spillChildVectors_.resize(tableType_->size());
+  spillChildVectors_.resize(spillType_->size());
 }
 
 bool HashBuild::isInputFromSpill() const {
@@ -288,7 +296,8 @@ void HashBuild::removeInputRowsForAntiJoinFilter() {
       changed = true;
       // NOTE: the true value of a raw null bit indicates non-null so we AND
       // 'rawActiveRows' with the raw bit.
-      bits::andBits(rawActiveRows, decoded.nulls(), 0, activeRows_.end());
+      bits::andBits(
+          rawActiveRows, decoded.nulls(&activeRows_), 0, activeRows_.end());
     }
   };
   for (auto channel : keyFilterChannels_) {
@@ -304,16 +313,9 @@ void HashBuild::removeInputRowsForAntiJoinFilter() {
 
 void HashBuild::addInput(RowVectorPtr input) {
   checkRunning();
+  ensureInputFits(input);
 
-  if (!ensureInputFits(input)) {
-    VELOX_CHECK_NOT_NULL(input_);
-    VELOX_CHECK(future_.valid());
-    return;
-  }
-
-  // Prevents the memory arbitrator to reclaim memory from this operator during
-  // the execution belowg.
-  NonReclaimableSection guard(this);
+  TestValue::adjust("facebook::velox::exec::HashBuild::addInput", this);
 
   activeRows_.resize(input->size());
   activeRows_.setAll();
@@ -325,6 +327,18 @@ void HashBuild::addInput(RowVectorPtr input) {
     hashers[i]->decode(*key, activeRows_);
   }
 
+  // Update statistics for null keys in join operator.
+  // We use activeRows_ to store which rows have some null keys,
+  // and reset it after using it.
+  // Only process when input is not spilled, to avoid overcounting.
+  if (!isInputFromSpill()) {
+    auto lockedStats = stats_.wlock();
+    deselectRowsWithNulls(hashers, activeRows_);
+    lockedStats->numNullKeys +=
+        activeRows_.size() - activeRows_.countSelected();
+    activeRows_.setAll();
+  }
+
   if (!isRightJoin(joinType_) && !isFullJoin(joinType_) &&
       !isRightSemiProjectJoin(joinType_) &&
       !isLeftNullAwareJoinWithFilter(joinNode_)) {
@@ -337,7 +351,7 @@ void HashBuild::addInput(RowVectorPtr input) {
     for (auto& hasher : hashers) {
       auto& decoded = hasher->decodedVector();
       if (decoded.mayHaveNulls()) {
-        auto* nulls = decoded.nulls();
+        auto* nulls = decoded.nulls(&activeRows_);
         if (nulls && bits::countNulls(nulls, 0, activeRows_.end()) > 0) {
           joinHasNullKeys_ = true;
           break;
@@ -385,12 +399,14 @@ void HashBuild::addInput(RowVectorPtr input) {
     }
   }
   auto rows = table_->rows();
-  auto nextOffset = rows->nextOffset();
+  FlatVector<bool>* spillProbedFlagVector{nullptr};
+  if (isInputFromSpill() && needProbedFlagSpill_) {
+    spillProbedFlagVector =
+        input->childAt(spillProbedFlagChannel_)->asFlatVector<bool>();
+  }
+
   activeRows_.applyToSelected([&](auto rowIndex) {
     char* newRow = rows->newRow();
-    if (nextOffset) {
-      *reinterpret_cast<char**>(newRow + nextOffset) = nullptr;
-    }
     // Store the columns for each row in sequence. At probe time
     // strings of the row will probably be in consecutive places, so
     // reading one will prime the cache for the next.
@@ -400,105 +416,94 @@ void HashBuild::addInput(RowVectorPtr input) {
     for (auto i = 0; i < dependentChannels_.size(); ++i) {
       rows->store(*decoders_[i], rowIndex, newRow, i + hashers.size());
     }
+    if (spillProbedFlagVector != nullptr) {
+      VELOX_CHECK(!spillProbedFlagVector->isNullAt(rowIndex));
+      if (spillProbedFlagVector->valueAt(rowIndex)) {
+        rows->setProbedFlag(&newRow, 1);
+      }
+    }
   });
 }
 
-bool HashBuild::ensureInputFits(RowVectorPtr& input) {
+void HashBuild::ensureInputFits(RowVectorPtr& input) {
   // NOTE: we don't need memory reservation if all the partitions are spilling
   // as we spill all the input rows to disk directly.
   if (!spillEnabled() || spiller_ == nullptr || spiller_->isAllSpilled()) {
-    return true;
+    return;
   }
 
   // NOTE: we simply reserve memory all inputs even though some of them are
   // spilling directly. It is okay as we will accumulate the extra reservation
   // in the operator's memory pool, and won't make any new reservation if there
   // is already sufficient reservations.
-  if (!reserveMemory(input)) {
-    if (!requestSpill(input)) {
-      return false;
-    }
-  } else {
-    // Check if any other peer operator has requested group spill.
-    if (waitSpill(input)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool HashBuild::reserveMemory(const RowVectorPtr& input) {
   VELOX_CHECK(spillEnabled());
 
-  numSpillRows_ = 0;
-  numSpillBytes_ = 0;
-
-  auto rows = table_->rows();
-  auto numRows = rows->numRows();
-  if (numRows == 0) {
-    // Skip the memory reservation for the first input as we are lack of memory
-    // usage stats for estimation. It is safe to skip as the query should have
-    // sufficient memory initially.
-    return true;
-  }
+  auto* rows = table_->rows();
+  const auto numRows = rows->numRows();
 
   auto [freeRows, outOfLineFreeBytes] = rows->freeSpace();
-  auto outOfLineBytes =
+  const auto outOfLineBytes =
       rows->stringAllocator().retainedSize() - outOfLineFreeBytes;
-  auto outOfLineBytesPerRow = std::max<uint64_t>(1, outOfLineBytes / numRows);
-  int64_t flatBytes = input->estimateFlatSize();
-
-  // Test-only spill path.
-  if (testingTriggerSpill()) {
-    numSpillRows_ = std::max<int64_t>(1, numRows / 10);
-    numSpillBytes_ = numSpillRows_ * outOfLineBytesPerRow;
-    return false;
-  }
-
-  // We check usage from the parent pool to take peers' allocations into
-  // account.
-  const auto currentUsage = pool()->parent()->currentBytes();
-  if (spillMemoryThreshold_ != 0 && currentUsage > spillMemoryThreshold_) {
-    const int64_t bytesToSpill =
-        currentUsage * spillConfig()->spillableReservationGrowthPct / 100;
-    numSpillRows_ = std::max<int64_t>(
-        1, bytesToSpill / (rows->fixedRowSize() + outOfLineBytesPerRow));
-    numSpillBytes_ = numSpillRows_ * outOfLineBytesPerRow;
-    return false;
-  }
-
-  if (freeRows > input->size() &&
-      (outOfLineBytes == 0 || outOfLineFreeBytes >= flatBytes)) {
-    // Enough free rows for input rows and enough variable length free
-    // space for the flat size of the whole vector. If outOfLineBytes
-    // is 0 there is no need for variable length space.
-    return true;
+  const auto outOfLineBytesPerRow =
+      std::max<uint64_t>(1, numRows == 0 ? 0 : outOfLineBytes / numRows);
+  const auto currentUsage = pool()->usedBytes();
+
+  if (numRows != 0) {
+    // Test-only spill path.
+    if (testingTriggerSpill(pool()->name())) {
+      Operator::ReclaimableSectionGuard guard(this);
+      memory::testingRunArbitration(pool());
+      return;
+    }
   }
 
-  // If there is variable length data we take the flat size of the
-  // input as a cap on the new variable length data needed.
-  const auto increment =
-      rows->sizeIncrement(input->size(), outOfLineBytes ? flatBytes : 0);
+  const auto minReservationBytes =
+      currentUsage * spillConfig_->minSpillableReservationPct / 100;
+  const auto availableReservationBytes = pool()->availableReservation();
+  const auto tableIncrementBytes = table_->hashTableSizeIncrease(input->size());
+  const int64_t flatBytes = input->estimateFlatSize();
+  const auto rowContainerIncrementBytes = numRows == 0
+      ? flatBytes * 2
+      : rows->sizeIncrement(
+            input->size(), outOfLineBytes > 0 ? flatBytes * 2 : 0);
+  const auto incrementBytes = rowContainerIncrementBytes + tableIncrementBytes;
+
+  // First to check if we have sufficient minimal memory reservation.
+  if (availableReservationBytes >= minReservationBytes) {
+    if (freeRows > input->size() &&
+        (outOfLineBytes == 0 || outOfLineFreeBytes >= flatBytes)) {
+      // Enough free rows for input rows and enough variable length free
+      // space for the flat size of the whole vector. If outOfLineBytes
+      // is 0 there is no need for variable length space.
+      return;
+    }
 
-  // There must be at least 2x the increments in reservation.
-  if (pool()->availableReservation() > 2 * increment) {
-    return true;
+    // If there is variable length data we take the flat size of the
+    // input as a cap on the new variable length data needed. There must be at
+    // least 2x the increments in reservation.
+    if (pool()->availableReservation() > 2 * incrementBytes) {
+      return;
+    }
   }
 
   // Check if we can increase reservation. The increment is the larger of
   // twice the maximum increment from this input and
   // 'spillableReservationGrowthPct_' of the current reservation.
-  auto targetIncrement = std::max<int64_t>(
-      increment * 2,
-      pool()->currentBytes() * spillConfig()->spillableReservationGrowthPct /
-          100);
-  if (pool()->maybeReserve(targetIncrement)) {
-    return true;
+  const auto targetIncrementBytes = std::max<int64_t>(
+      incrementBytes * 2,
+      currentUsage * spillConfig_->spillableReservationGrowthPct / 100);
+
+  {
+    Operator::ReclaimableSectionGuard guard(this);
+    if (!pool()->maybeReserve(targetIncrementBytes)) {
+      LOG(WARNING) << "Failed to reserve "
+                   << succinctBytes(targetIncrementBytes) << " for memory pool "
+                   << pool()->name()
+                   << ", usage: " << succinctBytes(pool()->usedBytes())
+                   << ", reservation: "
+                   << succinctBytes(pool()->reservedBytes());
+    }
   }
-  numSpillRows_ = std::max<int64_t>(
-      1, targetIncrement / (rows->fixedRowSize() + outOfLineBytesPerRow));
-  numSpillBytes_ = numSpillRows_ * outOfLineBytesPerRow;
-  return false;
 }
 
 void HashBuild::spillInput(const RowVectorPtr& input) {
@@ -556,6 +561,11 @@ void HashBuild::maybeSetupSpillChildVectors(const RowVectorPtr& input) {
   for (const auto& channel : dependentChannels_) {
     spillChildVectors_[spillChannel++] = input->childAt(channel);
   }
+  if (needProbedFlagSpill_) {
+    VELOX_CHECK_NOT_NULL(spillProbedFlagVector_);
+    spillProbedFlagVector_->resize(input->size());
+    spillChildVectors_[spillChannel] = spillProbedFlagVector_;
+  }
 }
 
 void HashBuild::prepareInputIndicesBuffers(
@@ -589,9 +599,9 @@ void HashBuild::computeSpillPartitions(const RowVectorPtr& input) {
   }
 
   spillPartitions_.resize(input->size());
-  for (auto i = 0; i < spillPartitions_.size(); ++i) {
-    spillPartitions_[i] = spiller_->hashBits().partition(hashes_[i]);
-  }
+  activeRows_.applyToSelected([&](int32_t row) {
+    spillPartitions_[row] = spiller_->hashBits().partition(hashes_[row]);
+  });
 }
 
 void HashBuild::spillPartition(
@@ -606,101 +616,10 @@ void HashBuild::spillPartition(
   } else {
     spiller_->spill(
         partition,
-        wrap(size, indices, tableType_, spillChildVectors_, input->pool()));
-  }
-}
-
-bool HashBuild::requestSpill(RowVectorPtr& input) {
-  VELOX_CHECK_GT(numSpillRows_, 0);
-  VELOX_CHECK_GT(numSpillBytes_, 0);
-
-  input_ = std::move(input);
-  if (spillGroup_->requestSpill(*this, future_)) {
-    VELOX_CHECK(future_.valid());
-    setState(State::kWaitForSpill);
-    return false;
-  }
-  input = std::move(input_);
-  return true;
-}
-
-bool HashBuild::waitSpill(RowVectorPtr& input) {
-  if (!spillGroup_->needSpill()) {
-    return false;
-  }
-
-  if (spillGroup_->waitSpill(*this, future_)) {
-    VELOX_CHECK(future_.valid());
-    input_ = std::move(input);
-    setState(State::kWaitForSpill);
-    return true;
-  }
-  return false;
-}
-
-void HashBuild::runSpill(const std::vector<Operator*>& spillOperators) {
-  VELOX_CHECK(spillEnabled());
-  VELOX_CHECK(!spiller_->state().isAllPartitionSpilled());
-
-  uint64_t targetRows = 0;
-  uint64_t targetBytes = 0;
-  std::vector<Spiller*> spillers;
-  spillers.reserve(spillOperators.size());
-  for (auto& spillOp : spillOperators) {
-    HashBuild* build = dynamic_cast<HashBuild*>(spillOp);
-    VELOX_CHECK_NOT_NULL(build);
-    ++build->numSpillRuns_;
-    spillers.push_back(build->spiller_.get());
-    build->addAndClearSpillTarget(targetRows, targetBytes);
-  }
-  VELOX_CHECK_GT(targetRows, 0);
-  VELOX_CHECK_GT(targetBytes, 0);
-
-  std::vector<Spiller::SpillableStats> spillableStats(
-      spiller_->hashBits().numPartitions());
-  for (auto* spiller : spillers) {
-    spiller->fillSpillRuns(spillableStats);
-  }
-
-  // Sort the partitions based on the amount of spillable data.
-  SpillPartitionNumSet partitionsToSpill;
-  std::vector<int32_t> partitionIndices(spillableStats.size());
-  std::iota(partitionIndices.begin(), partitionIndices.end(), 0);
-  std::sort(
-      partitionIndices.begin(),
-      partitionIndices.end(),
-      [&](int32_t lhs, int32_t rhs) {
-        return spillableStats[lhs].numBytes > spillableStats[rhs].numBytes;
-      });
-  int64_t numRows = 0;
-  int64_t numBytes = 0;
-  for (auto partitionNum : partitionIndices) {
-    if (spillableStats[partitionNum].numBytes == 0) {
-      break;
-    }
-    partitionsToSpill.insert(partitionNum);
-    numRows += spillableStats[partitionNum].numRows;
-    numBytes += spillableStats[partitionNum].numBytes;
-    if (numRows >= targetRows && numBytes >= targetBytes) {
-      break;
-    }
-  }
-  VELOX_CHECK(!partitionsToSpill.empty());
-
-  // TODO: consider to offload the partition spill processing to an executor to
-  // run in parallel.
-  for (auto* spiller : spillers) {
-    spiller->spill(partitionsToSpill);
+        wrap(size, indices, spillType_, spillChildVectors_, input->pool()));
   }
 }
 
-void HashBuild::addAndClearSpillTarget(uint64_t& numRows, uint64_t& numBytes) {
-  numRows += numSpillRows_;
-  numSpillRows_ = 0;
-  numBytes += numSpillBytes_;
-  numSpillBytes_ = 0;
-}
-
 void HashBuild::noMoreInput() {
   checkRunning();
 
@@ -713,10 +632,6 @@ void HashBuild::noMoreInput() {
 }
 
 void HashBuild::noMoreInputInternal() {
-  if (spillEnabled()) {
-    spillGroup_->operatorStopped(*this);
-  }
-
   if (!finishHashBuild()) {
     return;
   }
@@ -726,6 +641,7 @@ void HashBuild::noMoreInputInternal() {
 
 bool HashBuild::finishHashBuild() {
   checkRunning();
+
   // Release the unused memory reservation before building the merged join
   // table.
   pool()->release();
@@ -745,14 +661,14 @@ bool HashBuild::finishHashBuild() {
 
   TestValue::adjust("facebook::velox::exec::HashBuild::finishHashBuild", this);
 
-  auto promisesGuard = folly::makeGuard([&]() {
+  SCOPE_EXIT {
     // Realize the promises so that the other Drivers (which were not
     // the last to finish) can continue from the barrier and finish.
     peers.clear();
     for (auto& promise : promises) {
       promise.setValue();
     }
-  });
+  };
 
   if (joinHasNullKeys_ && isAntiJoin(joinType_) && nullAware_ &&
       !joinNode_->filter()) {
@@ -762,7 +678,11 @@ bool HashBuild::finishHashBuild() {
 
   std::vector<HashBuild*> otherBuilds;
   otherBuilds.reserve(peers.size());
-  uint64_t numRows = table_->rows()->numRows();
+  uint64_t numRows{0};
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    numRows += table_->rows()->numRows();
+  }
   for (auto& peer : peers) {
     auto op = peer->findOperator(planNodeId());
     HashBuild* build = dynamic_cast<HashBuild*>(op);
@@ -774,72 +694,104 @@ bool HashBuild::finishHashBuild() {
         return true;
       }
     }
-    numRows += build->table_->rows()->numRows();
+    {
+      std::lock_guard<std::mutex> l(build->mutex_);
+      VELOX_CHECK(
+          !build->stateCleared_,
+          "Internal state for a peer is empty. It might have already"
+          " been closed.");
+      numRows += build->table_->rows()->numRows();
+    }
     otherBuilds.push_back(build);
   }
 
   ensureTableFits(numRows);
 
-  NonReclaimableSection guard(this);
   std::vector<std::unique_ptr<BaseHashTable>> otherTables;
   otherTables.reserve(peers.size());
   SpillPartitionSet spillPartitions;
   for (auto* build : otherBuilds) {
-    VELOX_CHECK_NOT_NULL(build->table_);
-    otherTables.push_back(std::move(build->table_));
-    if (build->spiller_ != nullptr) {
-      build->spiller_->finishSpill(spillPartitions);
-      build->recordSpillStats();
+    std::unique_ptr<Spiller> spiller;
+    {
+      std::lock_guard<std::mutex> l(build->mutex_);
+      VELOX_CHECK(
+          !build->stateCleared_,
+          "Internal state for a peer is empty. It might have already"
+          " been closed.");
+      build->stateCleared_ = true;
+      VELOX_CHECK_NOT_NULL(build->table_);
+      otherTables.push_back(std::move(build->table_));
+      spiller = std::move(build->spiller_);
+    }
+    if (spiller != nullptr) {
+      spiller->finishSpill(spillPartitions);
     }
   }
 
   if (spiller_ != nullptr) {
     spiller_->finishSpill(spillPartitions);
-    recordSpillStats();
-
-    // Remove the spilled partitions which are empty so as we don't need to
-    // trigger unnecessary spilling at hash probe side.
-    auto iter = spillPartitions.begin();
-    while (iter != spillPartitions.end()) {
-      if (iter->second->numFiles() > 0) {
-        ++iter;
-      } else {
-        iter = spillPartitions.erase(iter);
-      }
-    }
+    removeEmptyPartitions(spillPartitions);
   }
 
-  // TODO: re-enable parallel join build with spilling triggered after
-  // https://github.com/facebookincubator/velox/issues/3567 is fixed.
+  // TODO: Get accurate signal if parallel join build is going to be applied
+  //  from hash table. Currently there is still a chance inside hash table that
+  //  it might decide it is not going to trigger parallel join build.
   const bool allowParallelJoinBuild =
       !otherTables.empty() && spillPartitions.empty();
-  table_->prepareJoinTable(
-      std::move(otherTables),
-      allowParallelJoinBuild ? operatorCtx_->task()->queryCtx()->executor()
-                             : nullptr);
-  addRuntimeStats();
-  if (joinBridge_->setHashTable(
-          std::move(table_), std::move(spillPartitions), joinHasNullKeys_)) {
-    spillGroup_->restart();
+
+  SCOPE_EXIT {
+    // Make a guard to release the unused memory reservation since we have
+    // finished the merged table build.
+    pool()->release();
+  };
+
+  // TODO: Re-enable parallel join build with spilling triggered after
+  //  https://github.com/facebookincubator/velox/issues/3567 is fixed.
+  CpuWallTiming timing;
+  {
+    // If there is a chance the join build is parallel, we suspend the driver
+    // while the hash table is being built. This is because off-driver thread
+    // memory allocations inside parallel join build might trigger memory
+    // arbitration.
+    std::unique_ptr<SuspendedSection> suspendedSection;
+    if (allowParallelJoinBuild) {
+      suspendedSection = std::make_unique<SuspendedSection>(
+          driverThreadContext()->driverCtx.driver);
+    }
+
+    CpuWallTimer cpuWallTimer{timing};
+    table_->prepareJoinTable(
+        std::move(otherTables),
+        isInputFromSpill() ? spillConfig()->startPartitionBit
+                           : BaseHashTable::kNoSpillInputStartPartitionBit,
+        allowParallelJoinBuild ? operatorCtx_->task()->queryCtx()->executor()
+                               : nullptr);
   }
+  stats_.wlock()->addRuntimeStat(
+      BaseHashTable::kBuildWallNanos,
+      RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos));
 
-  // Release the unused memory reservation since we have finished the merged
-  // table build.
-  pool()->release();
+  addRuntimeStats();
+  joinBridge_->setHashTable(
+      std::move(table_), std::move(spillPartitions), joinHasNullKeys_);
+  if (spillEnabled()) {
+    stateCleared_ = true;
+  }
   return true;
 }
 
-void HashBuild::recordSpillStats() {
-  VELOX_CHECK_NOT_NULL(spiller_);
-  const auto spillStats = spiller_->stats();
-  VELOX_CHECK_EQ(spillStats.spillSortTimeUs, 0);
-  Operator::recordSpillStats(spillStats);
-}
-
 void HashBuild::ensureTableFits(uint64_t numRows) {
   // NOTE: we don't need memory reservation if all the partitions have been
   // spilled as nothing need to be built.
-  if (!spillEnabled() || spiller_ == nullptr || spiller_->isAllSpilled()) {
+  if (!spillEnabled() || spiller_ == nullptr || spiller_->isAllSpilled() ||
+      numRows == 0) {
+    return;
+  }
+
+  // Test-only spill path.
+  if (testingTriggerSpill(pool()->name())) {
+    Operator::ReclaimableSectionGuard guard(this);
+    memory::testingRunArbitration(pool());
     return;
   }
 
@@ -847,24 +799,22 @@ void HashBuild::ensureTableFits(uint64_t numRows) {
 
   // NOTE: reserve a bit more memory to consider the extra memory used for
   // parallel table build operation.
-  const uint64_t bytesToReserve = table_->estimateHashTableSize(numRows) * 1.1;
-  if (pool()->maybeReserve(bytesToReserve)) {
-    return;
+  //
+  // TODO: make this query configurable.
+  const uint64_t memoryBytesToReserve =
+      table_->estimateHashTableSize(numRows) * 1.1;
+  {
+    Operator::ReclaimableSectionGuard guard(this);
+    if (pool()->maybeReserve(memoryBytesToReserve)) {
+      return;
+    }
   }
 
-  // TODO: add spilling support here in case of threshold triggered spilling.
-#if 0
-  // NOTE: the memory arbitrator must have spilled everything from this hash
-  // build operator and all its peers.
-  VELOX_CHECK(spiller_->isAllSpilled());
-#endif
-
-  // Throw a memory cap exceeded error to fail this query.
-  VELOX_MEM_POOL_CAP_EXCEEDED(fmt::format(
-      "Failed to reserve {} to build table with {} rows from {}",
-      succinctBytes(bytesToReserve),
-      numRows,
-      pool()->name()));
+  LOG(WARNING) << "Failed to reserve " << succinctBytes(memoryBytesToReserve)
+               << " for join table build from last hash build operator "
+               << pool()->name()
+               << ", usage: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes());
 }
 
 void HashBuild::postHashBuildProcess() {
@@ -906,6 +856,7 @@ void HashBuild::setupSpillInput(HashJoinBridge::SpillInput spillInput) {
 
   setupTable();
   setupSpiller(spillInput.spillPartition.get());
+  stateCleared_ = false;
 
   // Start to process spill input.
   processSpillInput();
@@ -914,11 +865,16 @@ void HashBuild::setupSpillInput(HashJoinBridge::SpillInput spillInput) {
 void HashBuild::processSpillInput() {
   checkRunning();
 
-  while (spillInputReader_->nextBatch(input_)) {
-    addInput(std::move(input_));
+  while (spillInputReader_->nextBatch(spillInput_)) {
+    addInput(std::move(spillInput_));
     if (!isRunning()) {
       return;
     }
+    if (operatorCtx_->driver()->shouldYield()) {
+      state_ = State::kYield;
+      future_ = ContinueFuture{folly::Unit{}};
+      return;
+    }
   }
   noMoreInputInternal();
 }
@@ -931,6 +887,7 @@ void HashBuild::addRuntimeStats() {
   uint64_t asDistinct;
   auto lockedStats = stats_.wlock();
 
+  lockedStats->addInputTiming.add(table_->offThreadBuildTiming());
   for (auto i = 0; i < hashers.size(); i++) {
     hashers[i]->cardinality(0, asRange, asDistinct);
     if (asRange != VectorHasher::kRangeTooLarge) {
@@ -943,14 +900,14 @@ void HashBuild::addRuntimeStats() {
     }
   }
 
-  lockedStats->runtimeStats["hashtable.capacity"] =
+  lockedStats->runtimeStats[BaseHashTable::kCapacity] =
       RuntimeMetric(hashTableStats.capacity);
-  lockedStats->runtimeStats["hashtable.numRehashes"] =
+  lockedStats->runtimeStats[BaseHashTable::kNumRehashes] =
       RuntimeMetric(hashTableStats.numRehashes);
-  lockedStats->runtimeStats["hashtable.numDistinct"] =
+  lockedStats->runtimeStats[BaseHashTable::kNumDistinct] =
       RuntimeMetric(hashTableStats.numDistinct);
   if (hashTableStats.numTombstones != 0) {
-    lockedStats->runtimeStats["hashtable.numTombstones"] =
+    lockedStats->runtimeStats[BaseHashTable::kNumTombstones] =
         RuntimeMetric(hashTableStats.numTombstones);
   }
 
@@ -959,7 +916,7 @@ void HashBuild::addRuntimeStats() {
     lockedStats->addRuntimeStat(
         "maxSpillLevel",
         RuntimeCounter(
-            spillConfig()->joinSpillLevel(spiller_->hashBits().begin())));
+            spillConfig()->spillLevel(spiller_->hashBits().begin())));
   }
 }
 
@@ -970,6 +927,11 @@ BlockingReason HashBuild::isBlocked(ContinueFuture* future) {
         processSpillInput();
       }
       break;
+    case State::kYield:
+      setRunning();
+      VELOX_CHECK(isInputFromSpill());
+      processSpillInput();
+      break;
     case State::kFinish:
       break;
     case State::kWaitForSpill:
@@ -1048,6 +1010,8 @@ std::string HashBuild::stateName(State state) {
   switch (state) {
     case State::kRunning:
       return "RUNNING";
+    case State::kYield:
+      return "YIELD";
     case State::kWaitForSpill:
       return "WAIT_FOR_SPILL";
     case State::kWaitForBuild:
@@ -1061,13 +1025,8 @@ std::string HashBuild::stateName(State state) {
   }
 }
 
-bool HashBuild::testingTriggerSpill() {
-  // Test-only spill path.
-  if (spillConfig()->testSpillPct == 0) {
-    return false;
-  }
-  return folly::hasher<uint64_t>()(++spillTestCounter_) % 100 <=
-      spillConfig()->testSpillPct;
+bool HashBuild::canReclaim() const {
+  return canSpill() && !operatorCtx_->task()->hasMixedExecutionGroup();
 }
 
 void HashBuild::reclaim(
@@ -1075,18 +1034,30 @@ void HashBuild::reclaim(
     memory::MemoryReclaimer::Stats& stats) {
   VELOX_CHECK(canReclaim());
   auto* driver = operatorCtx_->driver();
+  VELOX_CHECK_NOT_NULL(driver);
+  VELOX_CHECK(!nonReclaimableSection_);
 
   TestValue::adjust("facebook::velox::exec::HashBuild::reclaim", this);
 
+  if (exceededMaxSpillLevelLimit_) {
+    return;
+  }
+
   // NOTE: a hash build operator is reclaimable if it is in the middle of table
   // build processing and is not under non-reclaimable execution section.
-  if ((state_ != State::kRunning && state_ != State::kWaitForBuild) ||
-      nonReclaimableSection_) {
+  if (nonReclaimableState()) {
     // TODO: reduce the log frequency if it is too verbose.
+    RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
     ++stats.numNonReclaimableAttempts;
-    LOG(WARNING) << "Can't reclaim from hash build operator, state_["
-                 << stateName(state_) << "], nonReclaimableSection_["
-                 << nonReclaimableSection_ << "], " << pool()->name();
+    FB_LOG_EVERY_MS(WARNING, 1'000)
+        << "Can't reclaim from hash build operator, state_["
+        << stateName(state_) << "], nonReclaimableSection_["
+        << nonReclaimableSection_ << "], spiller_["
+        << (stateCleared_
+                ? "cleared"
+                : (spiller_->finalized() ? "finalized" : "non-finalized"))
+        << "] " << pool()->name()
+        << ", usage: " << succinctBytes(pool()->usedBytes());
     return;
   }
 
@@ -1098,42 +1069,94 @@ void HashBuild::reclaim(
     HashBuild* buildOp = dynamic_cast<HashBuild*>(op);
     VELOX_CHECK_NOT_NULL(buildOp);
     VELOX_CHECK(buildOp->canReclaim());
-    if ((buildOp->state_ != State::kRunning &&
-         buildOp->state_ != State::kWaitForBuild) ||
-        buildOp->nonReclaimableSection_) {
+    if (buildOp->nonReclaimableState()) {
       // TODO: reduce the log frequency if it is too verbose.
+      RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
       ++stats.numNonReclaimableAttempts;
-      LOG(WARNING) << "Can't reclaim from hash build operator, state_["
-                   << stateName(buildOp->state_) << "], nonReclaimableSection_["
-                   << buildOp->nonReclaimableSection_ << "], "
-                   << buildOp->pool()->name();
+      FB_LOG_EVERY_MS(WARNING, 1'000)
+          << "Can't reclaim from hash build operator, state_["
+          << stateName(buildOp->state_) << "], nonReclaimableSection_["
+          << buildOp->nonReclaimableSection_ << "], " << buildOp->pool()->name()
+          << ", usage: " << succinctBytes(buildOp->pool()->usedBytes());
       return;
     }
   }
 
-  std::vector<Spiller::SpillableStats> spillableStats;
-  spillableStats.reserve(spiller_->hashBits().numPartitions());
-  // TODO: consider to parallelize this disk spilling processing.
+  struct SpillResult {
+    const std::exception_ptr error{nullptr};
+
+    explicit SpillResult(std::exception_ptr _error) : error(_error) {}
+  };
+
+  std::vector<std::shared_ptr<AsyncSource<SpillResult>>> spillTasks;
+  auto* spillExecutor = spillConfig()->executor;
   for (auto* op : operators) {
     HashBuild* buildOp = static_cast<HashBuild*>(op);
-    ++buildOp->numSpillRuns_;
-    buildOp->spiller_->fillSpillRuns(spillableStats);
-    // TODO: support fine-grain disk spilling based on 'targetBytes' after
-    // having row container memory compaction support later.
-    buildOp->spiller_->spill();
-    VELOX_CHECK_EQ(buildOp->table_->numDistinct(), 0);
-    buildOp->table_->clear();
-    // Release the minimum reserved memory.
-    op->pool()->release();
+    spillTasks.push_back(
+        memory::createAsyncMemoryReclaimTask<SpillResult>([buildOp]() {
+          try {
+            buildOp->spiller_->spill();
+            buildOp->table_->clear();
+            // Release the minimum reserved memory.
+            buildOp->pool()->release();
+            return std::make_unique<SpillResult>(nullptr);
+          } catch (const std::exception& e) {
+            LOG(ERROR) << "Spill from hash build pool "
+                       << buildOp->pool()->name() << " failed: " << e.what();
+            // The exception is captured and thrown by the caller.
+            return std::make_unique<SpillResult>(std::current_exception());
+          }
+        }));
+    if ((operators.size() > 1) && (spillExecutor != nullptr)) {
+      spillExecutor->add([source = spillTasks.back()]() { source->prepare(); });
+    }
   }
+
+  auto syncGuard = folly::makeGuard([&]() {
+    for (auto& spillTask : spillTasks) {
+      // We consume the result for the pending tasks. This is a cleanup in the
+      // guard and must not throw. The first error is already captured before
+      // this runs.
+      try {
+        spillTask->move();
+      } catch (const std::exception&) {
+      }
+    }
+  });
+
+  for (auto& spillTask : spillTasks) {
+    const auto result = spillTask->move();
+    if (result->error) {
+      std::rethrow_exception(result->error);
+    }
+  }
+}
+
+bool HashBuild::nonReclaimableState() const {
+  // Apart from being in the nonReclaimable section, it's also not reclaimable
+  // if:
+  // 1) the hash table has been built by the last build thread (indicated by
+  //    state_)
+  // 2) the last build operator has transferred ownership of 'this operator's
+  //    internal state (table_ and spiller_) to itself.
+  // 3) it has completed spilling before reaching either of the previous
+  //    two states.
+  return ((state_ != State::kRunning) && (state_ != State::kWaitForBuild) &&
+          (state_ != State::kYield)) ||
+      nonReclaimableSection_ || !spiller_ || spiller_->finalized();
 }
 
-void HashBuild::abort() {
-  Operator::abort();
+void HashBuild::close() {
+  Operator::close();
 
-  // Free up major memory usage.
-  joinBridge_.reset();
-  spiller_.reset();
-  table_.reset();
+  {
+    // Free up major memory usage. Gate access to them as they can be accessed
+    // by the last build thread that finishes building the hash table.
+    std::lock_guard<std::mutex> l(mutex_);
+    stateCleared_ = true;
+    joinBridge_.reset();
+    spiller_.reset();
+    table_.reset();
+  }
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/HashBuild.h b/velox/exec/HashBuild.h
index f94025d01f643..f30f79ee7d8fd 100644
--- a/velox/exec/HashBuild.h
+++ b/velox/exec/HashBuild.h
@@ -19,7 +19,6 @@
 #include "velox/exec/HashTable.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/Spill.h"
-#include "velox/exec/SpillOperatorGroup.h"
 #include "velox/exec/Spiller.h"
 #include "velox/exec/UnorderedStreamReader.h"
 #include "velox/exec/VectorHasher.h"
@@ -42,25 +41,30 @@ class HashBuild final : public Operator {
   enum class State {
     /// The running state.
     kRunning = 1,
+    /// The yield state that voluntarily yield cpu after running too long when
+    /// processing input from spilled file.
+    kYield = 2,
     /// The state that waits for the pending group spill to finish. This state
     /// only applies if disk spilling is enabled.
-    kWaitForSpill = 2,
+    kWaitForSpill = 3,
     /// The state that waits for the hash tables to be merged together.
-    kWaitForBuild = 3,
+    kWaitForBuild = 4,
     /// The state that waits for the hash probe to finish before start to build
     /// the hash table for one of previously spilled partition. This state only
     /// applies if disk spilling is enabled.
-    kWaitForProbe = 4,
+    kWaitForProbe = 5,
     /// The finishing state.
-    kFinish = 5,
+    kFinish = 6,
   };
   static std::string stateName(State state);
 
   HashBuild(
       int32_t operatorId,
-      DriverCtx* FOLLY_NONNULL driverCtx,
+      DriverCtx* driverCtx,
       std::shared_ptr<const core::HashJoinNode> joinNode);
 
+  void initialize() override;
+
   void addInput(RowVectorPtr input) override;
 
   RowVectorPtr getOutput() override {
@@ -73,14 +77,16 @@ class HashBuild final : public Operator {
 
   void noMoreInput() override;
 
-  BlockingReason isBlocked(ContinueFuture* FOLLY_NONNULL future) override;
+  BlockingReason isBlocked(ContinueFuture* future) override;
 
   bool isFinished() override;
 
+  bool canReclaim() const override;
+
   void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
       override;
 
-  void abort() override;
+  void close() override;
 
  private:
   void setState(State state);
@@ -96,9 +102,7 @@ class HashBuild final : public Operator {
   // Invoked when operator has finished processing the build input and wait for
   // all the other drivers to finish the processing. The last driver that
   // reaches to the hash build barrier, is responsible to build the hash table
-  // merged from all the other drivers. If the disk spilling is enabled, the
-  // last driver will also restart 'spillGroup_' and add a new hash build
-  // barrier for the next round of hash table build operation if it needs.
+  // merged from all the other drivers.
   bool finishHashBuild();
 
   // Invoked after the hash table has been built. It waits for any spill data to
@@ -110,15 +114,9 @@ class HashBuild final : public Operator {
   void postHashBuildProcess();
 
   bool spillEnabled() const {
-    return spillConfig_.has_value();
-  }
-
-  const common::SpillConfig* spillConfig() const {
-    return spillConfig_.has_value() ? &spillConfig_.value() : nullptr;
+    return canReclaim();
   }
 
-  void recordSpillStats();
-
   // Indicates if the input is read from spill data or not.
   bool isInputFromSpill() const;
 
@@ -140,26 +138,12 @@ class HashBuild final : public Operator {
 
   // Invoked to ensure there is a sufficient memory to process 'input' by
   // reserving a sufficient amount of memory in advance if disk spilling is
-  // enabled. The function returns true if the disk spilling is not enabled, or
-  // the memory reservation succeeds. If the memory reservation fails, the
-  // function will trigger a group spill which needs coordination among the
-  // other build drivers in the same group. The function returns true if the
-  // group spill has been inline executed which could happen if there is only
-  // one driver in the group, or it happens that all the other drivers have
-  // also requested group spill and this driver is the last one to reach the
-  // group spill barrier. Otherwise, the function returns false to wait for the
-  // group spill to run. The operator will transition to 'kWaitForSpill' state
-  // accordingly.
-  bool ensureInputFits(RowVectorPtr& input);
-
-  // Invoked to ensure there is sufficient memory to build the join table with
-  // the specified 'numRows' if spilling is enabled. The function throws to fail
-  // the query if the memory reservation fails.
-  void ensureTableFits(uint64_t numRows);
+  // enabled.
+  void ensureInputFits(RowVectorPtr& input);
 
-  // Invoked to reserve memory for 'input' if disk spilling is enabled. The
-  // function returns true on success, otherwise false.
-  bool reserveMemory(const RowVectorPtr& input);
+  // Invoked to ensure there is sufficient memory to build the join table. The
+  // function throws to fail the query if the memory reservation fails.
+  void ensureTableFits(uint64_t numRows);
 
   // Invoked to compute spill partitions numbers for each row 'input' and spill
   // rows to spiller directly if the associated partition(s) is spilling. The
@@ -188,28 +172,6 @@ class HashBuild final : public Operator {
       vector_size_t numInput,
       const SpillPartitionNumSet& spillPartitions);
 
-  // Invoked to send group spill request to 'spillGroup_'. The function returns
-  // true if group spill has been inline executed, otherwise returns false. In
-  // the latter case, the operator will transition to 'kWaitForSpill' state and
-  // 'input' will be saved in 'input_' to be processed after the group spill has
-  // been executed.
-  bool requestSpill(RowVectorPtr& input);
-
-  // Invoked to check if it needs to wait for any pending group spill to run.
-  // The function returns true if it needs to wait, otherwise false. The latter
-  // case is either because there is no pending group spill or this operator is
-  // the last one to reach to the group spill barrier and execute the group
-  // spill inline.
-  bool waitSpill(RowVectorPtr& input);
-
-  // The callback registered to 'spillGroup_' to run group spill on
-  // 'spillOperators'.
-  void runSpill(const std::vector<Operator*>& spillOperators);
-
-  // Invoked by 'runSpill' to sum up the spill targets from all the operators in
-  // 'numRows' and 'numBytes'.
-  void addAndClearSpillTarget(uint64_t& numRows, uint64_t& numBytes);
-
   // Invoked to reset the operator state to restore previously spilled data. It
   // setup (recursive) spiller and spill input reader from 'spillInput' received
   // from 'joinBride_'. 'spillInput' contains a shard of previously spilled
@@ -234,8 +196,9 @@ class HashBuild final : public Operator {
 
   void addRuntimeStats();
 
-  // Invoked to check if it needs to trigger spilling for test purpose only.
-  bool testingTriggerSpill();
+  // Indicates if this hash build operator is under non-reclaimable state or
+  // not.
+  bool nonReclaimableState() const;
 
   const std::shared_ptr<const core::HashJoinNode> joinNode_;
 
@@ -243,19 +206,35 @@ class HashBuild final : public Operator {
 
   const bool nullAware_;
 
-  std::shared_ptr<HashJoinBridge> joinBridge_;
+  // Sets to true for join type which needs right side join processing. The hash
+  // table spiller then needs to record the probed flag, and the spilled input
+  // reader also needs to restore the recorded probed flag. This is used to
+  // support probe side spilling to record if a spilled row has been probed or
+  // not.
+  const bool needProbedFlagSpill_;
 
-  // The maximum memory usage that a hash build can hold before spilling.
-  // If it is zero, then there is no such limit.
-  const uint64_t spillMemoryThreshold_;
+  std::shared_ptr<HashJoinBridge> joinBridge_;
 
-  std::shared_ptr<SpillOperatorGroup> spillGroup_;
+  bool exceededMaxSpillLevelLimit_{false};
 
   State state_{State::kRunning};
 
   // The row type used for hash table build and disk spilling.
   RowTypePtr tableType_;
 
+  // Used to serialize access to internal state including 'table_' and
+  // 'spiller_'. This is only required when variables are accessed
+  // concurrently, that is, when a thread tries to close the operator while
+  // another thread is building the hash table. Refer to 'close()' and
+  // finishHashBuild()' for more details.
+  std::mutex mutex_;
+
+  // Indicates if the intermediate state ('table_' and 'spiller_') has
+  // been cleared. This can happen either when the operator is closed or when
+  // the last hash build operator transfers ownership of them to itself while
+  // building the final hash table.
+  bool stateCleared_{false};
+
   // Container for the rows being accumulated.
   std::unique_ptr<BaseHashTable> table_;
 
@@ -286,18 +265,24 @@ class HashBuild final : public Operator {
   // at least one entry with null join keys.
   bool joinHasNullKeys_{false};
 
-  // Counts input batches and triggers spilling if folly hash of this % 100 <=
-  // 'testSpillPct_';.
-  uint64_t spillTestCounter_{0};
-
-  // The spill targets set by 'requestSpill()' to request group spill.
-  uint64_t numSpillRows_{0};
-  uint64_t numSpillBytes_{0};
-
+  // The type used to spill hash table which might attach a boolean column to
+  // record the probed flag if 'needProbedFlagSpill_' is true.
+  RowTypePtr spillType_;
+  // Specifies the column index in 'spillType_' which records the probed flag
+  // for each spilled row.
+  column_index_t spillProbedFlagChannel_;
+  // Used to set the probed flag vector at the build side which is always false.
+  std::shared_ptr<ConstantVector<bool>> spillProbedFlagVector_;
+
+  // This can be nullptr if either spilling is not allowed or it has been
+  // transferred to the last hash build operator while in kWaitForBuild state or
+  // it has been cleared to set up a new one for recursive spilling.
   std::unique_ptr<Spiller> spiller_;
 
   // Used to read input from previously spilled data for restoring.
   std::unique_ptr<UnorderedStreamReader<BatchStream>> spillInputReader_;
+  // Vector used to read from spilled input with type of 'spillType_'.
+  RowVectorPtr spillInput_;
 
   // Reusable memory for spill partition calculation for input data.
   std::vector<uint32_t> spillPartitions_;
@@ -315,6 +300,9 @@ class HashBuild final : public Operator {
   std::vector<column_index_t> keyFilterChannels_;
   // Indices of dependent columns used by the filter in 'decoders_'.
   std::vector<column_index_t> dependentFilterChannels_;
+
+  // Maps key channel in 'input_' to channel in key.
+  folly::F14FastMap<column_index_t, column_index_t> keyChannelMap_;
 };
 
 inline std::ostream& operator<<(std::ostream& os, HashBuild::State state) {
@@ -322,3 +310,13 @@ inline std::ostream& operator<<(std::ostream& os, HashBuild::State state) {
   return os;
 }
 } // namespace facebook::velox::exec
+
+template <>
+struct fmt::formatter<facebook::velox::exec::HashBuild::State>
+    : formatter<std::string> {
+  auto format(facebook::velox::exec::HashBuild::State s, format_context& ctx)
+      const {
+    return formatter<std::string>::format(
+        facebook::velox::exec::HashBuild::stateName(s), ctx);
+  }
+};
diff --git a/velox/exec/HashJoinBridge.cpp b/velox/exec/HashJoinBridge.cpp
index 8e8d585178aaf..733d096940af7 100644
--- a/velox/exec/HashJoinBridge.cpp
+++ b/velox/exec/HashJoinBridge.cpp
@@ -14,17 +14,12 @@
  * limitations under the License.
  */
 
-#include <re2/re2.h>
-
 #include "velox/exec/HashJoinBridge.h"
 
 namespace facebook::velox::exec {
 namespace {
-bool isHashBuildMemoryPool(const memory::MemoryPool& pool) {
-  static const std::string re(".*HashBuild");
-  return RE2::FullMatch(pool.name(), re);
+static const char* kSpillProbedFlagColumnName = "__probedFlag";
 }
-} // namespace
 
 void HashJoinBridge::start() {
   std::lock_guard<std::mutex> l(mutex_);
@@ -38,7 +33,7 @@ void HashJoinBridge::addBuilder() {
   ++numBuilders_;
 }
 
-bool HashJoinBridge::setHashTable(
+void HashJoinBridge::setHashTable(
     std::unique_ptr<BaseHashTable> table,
     SpillPartitionSet spillPartitionSet,
     bool hasNullKeys) {
@@ -46,7 +41,6 @@ bool HashJoinBridge::setHashTable(
 
   auto spillPartitionIdSet = toSpillPartitionIdSet(spillPartitionSet);
 
-  bool hasSpillData;
   std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::mutex> l(mutex_);
@@ -73,12 +67,25 @@ bool HashJoinBridge::setHashTable(
         std::move(spillPartitionIdSet),
         hasNullKeys);
     restoringSpillPartitionId_.reset();
-
-    hasSpillData = !spillPartitionSets_.empty();
     promises = std::move(promises_);
   }
   notify(std::move(promises));
-  return hasSpillData;
+}
+
+void HashJoinBridge::setSpilledHashTable(SpillPartitionSet spillPartitionSet) {
+  VELOX_CHECK(
+      !spillPartitionSet.empty(), "Spilled table partitions can't be empty");
+  std::lock_guard<std::mutex> l(mutex_);
+  VELOX_CHECK(started_);
+  VELOX_CHECK(buildResult_.has_value());
+  VELOX_CHECK(restoringSpillShards_.empty());
+  VELOX_CHECK(!restoringSpillPartitionId_.has_value());
+
+  for (auto& partitionEntry : spillPartitionSet) {
+    const auto id = partitionEntry.first;
+    VELOX_CHECK_EQ(spillPartitionSets_.count(id), 0);
+    spillPartitionSets_.emplace(id, std::move(partitionEntry.second));
+  }
 }
 
 void HashJoinBridge::setAntiJoinHasNullKeys() {
@@ -140,10 +147,8 @@ bool HashJoinBridge::probeFinished() {
           spillPartitionSets_.begin()->second->split(numBuilders_);
       VELOX_CHECK_EQ(restoringSpillShards_.size(), numBuilders_);
       spillPartitionSets_.erase(spillPartitionSets_.begin());
-      promises = std::move(promises_);
-    } else {
-      VELOX_CHECK(promises_.empty());
     }
+    promises = std::move(promises_);
   }
   notify(std::move(promises));
   return hasSpillInput;
@@ -157,15 +162,23 @@ std::optional<HashJoinBridge::SpillInput> HashJoinBridge::spillInputOrFuture(
   VELOX_DCHECK(
       !restoringSpillPartitionId_.has_value() || !buildResult_.has_value());
 
+  // If 'buildResult_' is set, then the probe side is under processing. The
+  // build shall just wait.
+  if (buildResult_.has_value()) {
+    VELOX_CHECK(!restoringSpillPartitionId_.has_value());
+    promises_.emplace_back("HashJoinBridge::spillInputOrFuture");
+    *future = promises_.back().getSemiFuture();
+    return std::nullopt;
+  }
+
+  // If 'restoringSpillPartitionId_' is not set after probe side is done, then
+  // the join processing is all done.
   if (!restoringSpillPartitionId_.has_value()) {
-    if (spillPartitionSets_.empty()) {
-      return HashJoinBridge::SpillInput{};
-    } else {
-      promises_.emplace_back("HashJoinBridge::spillInputOrFuture");
-      *future = promises_.back().getSemiFuture();
-      return std::nullopt;
-    }
+    VELOX_CHECK(spillPartitionSets_.empty());
+    VELOX_CHECK(restoringSpillShards_.empty());
+    return HashJoinBridge::SpillInput{};
   }
+
   VELOX_CHECK(!restoringSpillShards_.empty());
   auto spillShard = std::move(restoringSpillShards_.back());
   restoringSpillShards_.pop_back();
@@ -182,20 +195,72 @@ bool isLeftNullAwareJoinWithFilter(
 uint64_t HashJoinMemoryReclaimer::reclaim(
     memory::MemoryPool* pool,
     uint64_t targetBytes,
+    uint64_t maxWaitMs,
     memory::MemoryReclaimer::Stats& stats) {
+  // The flags to track if we have reclaimed from both build and probe operators
+  // under a hash join node.
+  bool hasReclaimedFromBuild{false};
+  bool hasReclaimedFromProbe{false};
   uint64_t reclaimedBytes{0};
-  pool->visitChildren(
-      [&targetBytes, &reclaimedBytes, &stats](memory::MemoryPool* child) {
-        VELOX_CHECK_EQ(child->kind(), memory::MemoryPool::Kind::kLeaf);
-        // The hash probe operator do not support memory reclaim.
-        if (!isHashBuildMemoryPool(*child)) {
-          return true;
-        }
-        // We only need to reclaim from any one of the hash build operators
-        // which will reclaim from all the peer hash build operators.
-        reclaimedBytes = child->reclaim(targetBytes, stats);
-        return false;
-      });
+  pool->visitChildren([&](memory::MemoryPool* child) {
+    VELOX_CHECK_EQ(child->kind(), memory::MemoryPool::Kind::kLeaf);
+    const bool isBuild = isHashBuildMemoryPool(*child);
+    if (isBuild) {
+      if (!hasReclaimedFromBuild) {
+        // We just need to reclaim from any one of the hash build operator.
+        hasReclaimedFromBuild = true;
+        reclaimedBytes = child->reclaim(targetBytes, maxWaitMs, stats);
+      }
+      return !hasReclaimedFromProbe;
+    }
+
+    if (!hasReclaimedFromProbe) {
+      // The same as build operator, we only need to reclaim from any one of the
+      // hash probe operator.
+      hasReclaimedFromProbe = true;
+      reclaimedBytes = child->reclaim(targetBytes, maxWaitMs, stats);
+    }
+    return !hasReclaimedFromBuild;
+  });
   return reclaimedBytes;
 }
+
+bool isHashBuildMemoryPool(const memory::MemoryPool& pool) {
+  return folly::StringPiece(pool.name()).endsWith("HashBuild");
+}
+
+bool isHashProbeMemoryPool(const memory::MemoryPool& pool) {
+  return folly::StringPiece(pool.name()).endsWith("HashProbe");
+}
+
+bool needRightSideJoin(core::JoinType joinType) {
+  return isRightJoin(joinType) || isFullJoin(joinType) ||
+      isRightSemiFilterJoin(joinType) || isRightSemiProjectJoin(joinType);
+}
+
+RowTypePtr hashJoinTableSpillType(
+    const RowTypePtr& tableType,
+    core::JoinType joinType) {
+  if (!needRightSideJoin(joinType)) {
+    return tableType;
+  }
+  auto names = tableType->names();
+  names.push_back(kSpillProbedFlagColumnName);
+  auto types = tableType->children();
+  types.push_back(BOOLEAN());
+  return ROW(std::move(names), std::move(types));
+}
+
+bool isHashJoinTableSpillType(
+    const RowTypePtr& spillType,
+    core::JoinType joinType) {
+  if (!needRightSideJoin(joinType)) {
+    return true;
+  }
+  const column_index_t probedColumnChannel = spillType->size() - 1;
+  if (!spillType->childAt(probedColumnChannel)->isBoolean()) {
+    return false;
+  }
+  return spillType->nameOf(probedColumnChannel) == kSpillProbedFlagColumnName;
+}
 } // namespace facebook::velox::exec
diff --git a/velox/exec/HashJoinBridge.h b/velox/exec/HashJoinBridge.h
index 39d01d02fe30c..6661b5927f0e3 100644
--- a/velox/exec/HashJoinBridge.h
+++ b/velox/exec/HashJoinBridge.h
@@ -22,6 +22,10 @@
 
 namespace facebook::velox::exec {
 
+namespace test {
+class HashJoinBridgeTestHelper;
+}
+
 /// Hands over a hash table from a multi-threaded build pipeline to a
 /// multi-threaded probe pipeline. This is owned by shared_ptr by all the build
 /// and probe Operator instances concerned. Corresponds to the Presto concept of
@@ -35,15 +39,20 @@ class HashJoinBridge : public JoinBridge {
   /// HashBuild operators to parallelize the restoring operation.
   void addBuilder();
 
+  /// Invoked by the build operator to set the built hash table.
   /// 'spillPartitionSet' contains the spilled partitions while building
-  /// 'table'. The function returns true if there is spill data to restore
-  /// after HashProbe operators process 'table', otherwise false. This only
-  /// applies if the disk spilling is enabled.
-  bool setHashTable(
+  /// 'table' which only applies if the disk spilling is enabled.
+  void setHashTable(
       std::unique_ptr<BaseHashTable> table,
       SpillPartitionSet spillPartitionSet,
       bool hasNullKeys);
 
+  /// Invoked by the probe operator to set the spilled hash table while the
+  /// probing. The function puts the spilled table partitions into
+  /// 'spillPartitionSets_' stack. This only applies if the disk spilling is
+  /// enabled.
+  void setSpilledHashTable(SpillPartitionSet spillPartitionSet);
+
   void setAntiJoinHasNullKeys();
 
   /// Represents the result of HashBuild operators: a hash table, an optional
@@ -75,8 +84,7 @@ class HashJoinBridge : public JoinBridge {
   /// HashBuild operators. If HashProbe operator calls this early, 'future' will
   /// be set to wait asynchronously, otherwise the built table along with
   /// optional spilling related information will be returned in HashBuildResult.
-  std::optional<HashBuildResult> tableOrFuture(
-      ContinueFuture* FOLLY_NONNULL future);
+  std::optional<HashBuildResult> tableOrFuture(ContinueFuture* future);
 
   /// Invoked by HashProbe operator after finishes probing the built table to
   /// set one of the previously spilled partition to restore. The HashBuild
@@ -102,8 +110,7 @@ class HashJoinBridge : public JoinBridge {
   /// If HashBuild operator calls this early, 'future' will be set to wait
   /// asynchronously. If there is no more spill data to restore, then
   /// 'spillPartition' will be set to null in the returned SpillInput.
-  std::optional<SpillInput> spillInputOrFuture(
-      ContinueFuture* FOLLY_NONNULL future);
+  std::optional<SpillInput> spillInputOrFuture(ContinueFuture* future);
 
  private:
   uint32_t numBuilders_{0};
@@ -129,6 +136,8 @@ class HashJoinBridge : public JoinBridge {
   // This set can grow if HashBuild operator cannot load full partition in
   // memory and engages in recursive spilling.
   SpillPartitionSet spillPartitionSets_;
+
+  friend test::HashJoinBridgeTestHelper;
 };
 
 // Indicates if 'joinNode' is null-aware anti or left semi project join type and
@@ -146,9 +155,34 @@ class HashJoinMemoryReclaimer final : public MemoryReclaimer {
   uint64_t reclaim(
       memory::MemoryPool* pool,
       uint64_t targetBytes,
+      uint64_t maxWaitMs,
       memory::MemoryReclaimer::Stats& stats) final;
 
  private:
   HashJoinMemoryReclaimer() : MemoryReclaimer() {}
 };
+
+/// Returns true if 'pool' is a hash build operator's memory pool. The check is
+/// currently based on the pool name.
+bool isHashBuildMemoryPool(const memory::MemoryPool& pool);
+
+/// Returns true if 'pool' is a hash probe operator's memory pool. The check is
+/// currently based on the pool name.
+bool isHashProbeMemoryPool(const memory::MemoryPool& pool);
+
+bool needRightSideJoin(core::JoinType joinType);
+
+/// Returns the type used to spill a given hash table type. The function
+/// might attach a boolean column at the end of 'tableType' if 'joinType' needs
+/// right side join processing. It is used by the hash join table spilling
+/// triggered at the probe side to record if each row has been probed or not.
+RowTypePtr hashJoinTableSpillType(
+    const RowTypePtr& tableType,
+    core::JoinType joinType);
+
+/// Checks if a given type is a hash table spill type or not based on
+/// 'joinType'.
+bool isHashJoinTableSpillType(
+    const RowTypePtr& spillType,
+    core::JoinType joinType);
 } // namespace facebook::velox::exec
diff --git a/velox/exec/HashProbe.cpp b/velox/exec/HashProbe.cpp
index fcf4ec6ce3315..e62aeda2deae8 100644
--- a/velox/exec/HashProbe.cpp
+++ b/velox/exec/HashProbe.cpp
@@ -15,10 +15,15 @@
  */
 
 #include "velox/exec/HashProbe.h"
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/FieldReference.h"
 
+using facebook::velox::common::testutil::TestValue;
+
 namespace facebook::velox::exec {
 
 namespace {
@@ -56,15 +61,15 @@ RowTypePtr makeTableType(
 // 'result'. Reuses 'result' children where possible.
 void extractColumns(
     BaseHashTable* table,
-    folly::Range<char**> rows,
+    folly::Range<char* const*> rows,
     folly::Range<const IdentityProjection*> projections,
     memory::MemoryPool* pool,
     const std::vector<TypePtr>& resultTypes,
     std::vector<VectorPtr>& resultVectors) {
-  VELOX_CHECK_EQ(resultTypes.size(), resultVectors.size())
+  VELOX_CHECK_EQ(resultTypes.size(), resultVectors.size());
   for (auto projection : projections) {
     const auto resultChannel = projection.outputChannel;
-    VELOX_CHECK_LT(resultChannel, resultVectors.size())
+    VELOX_CHECK_LT(resultChannel, resultVectors.size());
 
     auto& child = resultVectors[resultChannel];
     // TODO: Consider reuse of complex types.
@@ -73,8 +78,7 @@ void extractColumns(
       child = BaseVector::create(resultTypes[resultChannel], rows.size(), pool);
     }
     child->resize(rows.size());
-    table->rows()->extractColumn(
-        rows.data(), rows.size(), projection.inputChannel, child);
+    table->extractColumn(rows, projection.inputChannel, child);
   }
 }
 
@@ -103,6 +107,16 @@ SpillPartitionNumSet toPartitionNumSet(
   }
   return partitionNumSet;
 }
+
+template <typename T>
+T* initBuffer(BufferPtr& buffer, vector_size_t size, memory::MemoryPool* pool) {
+  VELOX_CHECK(!buffer || buffer->isMutable());
+  if (!buffer || buffer->size() < size * sizeof(T)) {
+    buffer = AlignedBuffer::allocate<T>(size, pool);
+  }
+  return buffer->asMutable<T>();
+}
+
 } // namespace
 
 HashProbe::HashProbe(
@@ -127,7 +141,7 @@ HashProbe::HashProbe(
           operatorCtx_->driverCtx()->splitGroupId,
           planNodeId())),
       filterResult_(1),
-      outputTableRows_(outputBatchSize_) {
+      outputTableRowsCapacity_(outputBatchSize_) {
   VELOX_CHECK_NOT_NULL(joinBridge_);
 }
 
@@ -156,6 +170,7 @@ void HashProbe::initialize() {
     auto name = probeType_->nameOf(i);
     auto outIndex = outputType_->getChildIdxIfExists(name);
     if (outIndex.has_value()) {
+      projectedInputColumns_.insert(i);
       identityProjections_.emplace_back(i, outIndex.value());
       if (outIndex.value() == i) {
         ++numIdentityProjections;
@@ -220,24 +235,11 @@ void HashProbe::initializeFilter(
   filterInputType_ = ROW(std::move(names), std::move(types));
 }
 
-void HashProbe::maybeSetupSpillInput(
-    const std::optional<SpillPartitionId>& restoredPartitionId,
+void HashProbe::maybeSetupInputSpiller(
     const SpillPartitionIdSet& spillPartitionIds) {
-  VELOX_CHECK_NULL(spillInputReader_);
-
-  // If 'restoredPartitionId' is not null, then 'table_' is built from the
-  // spilled build data. Create an unsorted reader to read the probe inputs from
-  // the corresponding spilled probe partition on disk.
-  if (restoredPartitionId.has_value()) {
-    auto iter = spillPartitionSet_.find(restoredPartitionId.value());
-    VELOX_CHECK(iter != spillPartitionSet_.end());
-    auto partition = std::move(iter->second);
-    VELOX_CHECK_EQ(partition->id(), restoredPartitionId.value());
-    spillInputReader_ = partition->createReader();
-    spillPartitionSet_.erase(iter);
-  }
+  VELOX_CHECK_NULL(inputSpiller_);
+  VELOX_CHECK(spillInputPartitionIds_.empty());
 
-  VELOX_CHECK_NULL(spiller_);
   spillInputPartitionIds_ = spillPartitionIds;
   if (spillInputPartitionIds_.empty()) {
     return;
@@ -245,31 +247,73 @@ void HashProbe::maybeSetupSpillInput(
 
   // If 'spillInputPartitionIds_' is not empty, then we set up a spiller to
   // spill the incoming probe inputs.
-  const auto& spillConfig = spillConfig_.value();
-  ++numSpillRuns_;
-  spiller_ = std::make_unique<Spiller>(
+  inputSpiller_ = std::make_unique<Spiller>(
       Spiller::Type::kHashJoinProbe,
       probeType_,
       HashBitRange(
           spillInputPartitionIds_.begin()->partitionBitOffset(),
           spillInputPartitionIds_.begin()->partitionBitOffset() +
-              spillConfig.joinPartitionBits),
-      spillConfig.filePath,
-      spillConfig.maxFileSize,
-      spillConfig.writeBufferSize,
-      spillConfig.minSpillRunSize,
-      spillConfig.compressionKind,
-      Spiller::pool(),
-      spillConfig.executor);
+              spillConfig()->numPartitionBits),
+      spillConfig(),
+      &spillStats_);
   // Set the spill partitions to the corresponding ones at the build side. The
   // hash probe operator itself won't trigger any spilling.
-  spiller_->setPartitionsSpilled(toPartitionNumSet(spillInputPartitionIds_));
+  inputSpiller_->setPartitionsSpilled(
+      toPartitionNumSet(spillInputPartitionIds_));
 
   spillHashFunction_ = std::make_unique<HashPartitionFunction>(
-      spiller_->hashBits(), probeType_, keyChannels_);
+      inputSpiller_->hashBits(), probeType_, keyChannels_);
   spillInputIndicesBuffers_.resize(spillHashFunction_->numPartitions());
   rawSpillInputIndicesBuffers_.resize(spillHashFunction_->numPartitions());
   numSpillInputs_.resize(spillHashFunction_->numPartitions(), 0);
+  // If we have received no more input signal from either source or restored
+  // spill input, then we shall just finish the spiller and records the spilled
+  // partition set accordingly.
+  if (noMoreSpillInput_) {
+    inputSpiller_->finishSpill(spillPartitionSet_);
+  }
+}
+
+void HashProbe::maybeSetupSpillInputReader(
+    const std::optional<SpillPartitionId>& restoredPartitionId) {
+  VELOX_CHECK_NULL(spillInputReader_);
+  if (!restoredPartitionId.has_value()) {
+    return;
+  }
+  // If 'restoredPartitionId' is not null, then 'table_' is built from the
+  // spilled build data. Create an unsorted reader to read the probe inputs from
+  // the corresponding spilled probe partition on disk.
+  auto iter = spillPartitionSet_.find(restoredPartitionId.value());
+  VELOX_CHECK(iter != spillPartitionSet_.end());
+  auto partition = std::move(iter->second);
+  VELOX_CHECK_EQ(partition->id(), restoredPartitionId.value());
+  spillInputReader_ = partition->createUnorderedReader(
+      spillConfig_->readBufferSize, pool(), &spillStats_);
+  spillPartitionSet_.erase(iter);
+}
+
+void HashProbe::initializeResultIter() {
+  VELOX_CHECK_NOT_NULL(table_);
+  if (resultIter_ != nullptr) {
+    return;
+  }
+  std::vector<vector_size_t> listColumns;
+  listColumns.reserve(tableOutputProjections_.size());
+  for (const auto& projection : tableOutputProjections_) {
+    listColumns.push_back(projection.inputChannel);
+  }
+  std::vector<vector_size_t> varSizeListColumns;
+  uint64_t fixedSizeListColumnsSizeSum{0};
+  varSizeListColumns.reserve(tableOutputProjections_.size());
+  for (const auto column : listColumns) {
+    if (table_->rows()->columnTypes()[column]->isFixedWidth()) {
+      fixedSizeListColumnsSizeSum += table_->rows()->fixedSizeAt(column);
+    } else {
+      varSizeListColumns.push_back(column);
+    }
+  }
+  resultIter_ = std::make_unique<BaseHashTable::JoinResultIterator>(
+      std::move(varSizeListColumns), fixedSizeListColumnsSizeSum);
 }
 
 void HashProbe::asyncWaitForHashTable() {
@@ -279,6 +323,7 @@ void HashProbe::asyncWaitForHashTable() {
   auto hashBuildResult = joinBridge_->tableOrFuture(&future_);
   if (!hashBuildResult.has_value()) {
     VELOX_CHECK(future_.valid());
+    pool()->release();
     setState(ProbeOperatorState::kWaitForBuild);
     return;
   }
@@ -297,10 +342,13 @@ void HashProbe::asyncWaitForHashTable() {
   }
 
   table_ = std::move(hashBuildResult->table);
+  initializeResultIter();
+
   VELOX_CHECK_NOT_NULL(table_);
 
-  maybeSetupSpillInput(
-      hashBuildResult->restoredPartitionId, hashBuildResult->spillPartitionIds);
+  maybeSetupSpillInputReader(hashBuildResult->restoredPartitionId);
+  maybeSetupInputSpiller(hashBuildResult->spillPartitionIds);
+  prepareTableSpill(hashBuildResult->restoredPartitionId);
 
   if (table_->numDistinct() == 0) {
     if (skipProbeOnEmptyBuild()) {
@@ -320,24 +368,30 @@ void HashProbe::asyncWaitForHashTable() {
        isRightSemiFilterJoin(joinType_) || isRightSemiProjectJoin(joinType_)) &&
       table_->hashMode() != BaseHashTable::HashMode::kHash && !isSpillInput() &&
       !hasMoreSpillData()) {
-    // Find out whether there are any upstream operators that can accept
-    // dynamic filters on all or a subset of the join keys. Create dynamic
-    // filters to push down.
+    // Find out whether there are any upstream operators that can accept dynamic
+    // filters on all or a subset of the join keys. Create dynamic filters to
+    // push down.
     //
     // NOTE: this optimization is not applied in the following cases: (1) if the
     // probe input is read from spilled data and there is no upstream operators
     // involved; (2) if there is spill data to restore, then we can't filter
     // probe inputs solely based on the current table's join keys.
     const auto& buildHashers = table_->hashers();
-    auto channels = operatorCtx_->driverCtx()->driver->canPushdownFilters(
+    const auto channels = operatorCtx_->driverCtx()->driver->canPushdownFilters(
         this, keyChannels_);
-    for (auto i = 0; i < keyChannels_.size(); i++) {
+
+    // Null aware Right Semi Project join needs to know whether there are any
+    // nulls on the probe side. Hence, cannot filter these out.
+    const auto nullAllowed = isRightSemiProjectJoin(joinType_) && nullAware_;
+
+    for (auto i = 0; i < keyChannels_.size(); ++i) {
       if (channels.find(keyChannels_[i]) != channels.end()) {
-        if (auto filter = buildHashers[i]->getFilter(false)) {
+        if (auto filter = buildHashers[i]->getFilter(nullAllowed)) {
           dynamicFilters_.emplace(keyChannels_[i], std::move(filter));
         }
       }
     }
+    hasGeneratedDynamicFilters_ = !dynamicFilters_.empty();
   }
 }
 
@@ -352,27 +406,49 @@ void HashProbe::prepareForSpillRestore() {
 
   // Reset the internal states which are relevant to the previous probe run.
   noMoreSpillInput_ = false;
+  if (lastProber_) {
+    table_->clear(true);
+  }
   table_.reset();
-  spiller_.reset();
+  inputSpiller_.reset();
   spillInputReader_.reset();
   spillInputPartitionIds_.clear();
+  spillOutputReader_.reset();
   lastProbeIterator_.reset();
 
   VELOX_CHECK(promises_.empty() || lastProber_);
   if (!lastProber_) {
     return;
   }
-  lastProber_ = false;
   // Notify the hash build operators to build the next hash table.
   joinBridge_->probeFinished();
 
-  // Wake up the peer hash probe operators to wait for table build.
+  wakeupPeerOperators();
+
+  lastProber_ = false;
+}
+
+void HashProbe::wakeupPeerOperators() {
+  VELOX_CHECK(lastProber_);
   auto promises = std::move(promises_);
   for (auto& promise : promises) {
     promise.setValue();
   }
 }
 
+std::vector<HashProbe*> HashProbe::findPeerOperators() {
+  auto task = operatorCtx_->task();
+  const std::vector<Operator*> operators =
+      task->findPeerOperators(operatorCtx_->driverCtx()->pipelineId, this);
+  std::vector<HashProbe*> probeOps;
+  probeOps.reserve(operators.size());
+  for (auto* op : operators) {
+    auto* probeOp = dynamic_cast<HashProbe*>(op);
+    probeOps.push_back(probeOp);
+  }
+  return probeOps;
+}
+
 void HashProbe::addSpillInput() {
   checkRunning();
 
@@ -392,7 +468,7 @@ void HashProbe::spillInput(RowVectorPtr& input) {
 
   const auto numInput = input->size();
   prepareInputIndicesBuffers(
-      input->size(), spiller_->state().spilledPartitionSet());
+      input->size(), inputSpiller_->state().spilledPartitionSet());
   const auto singlePartition =
       spillHashFunction_->partition(*input, spillPartitions_);
 
@@ -400,7 +476,7 @@ void HashProbe::spillInput(RowVectorPtr& input) {
   for (auto row = 0; row < numInput; ++row) {
     const auto partition = singlePartition.has_value() ? singlePartition.value()
                                                        : spillPartitions_[row];
-    if (!spiller_->isSpilled(partition)) {
+    if (!inputSpiller_->isSpilled(partition)) {
       rawNonSpillInputIndicesBuffer_[numNonSpillingInput++] = row;
       continue;
     }
@@ -411,8 +487,8 @@ void HashProbe::spillInput(RowVectorPtr& input) {
   }
 
   // Ensure vector are lazy loaded before spilling.
-  for (int32_t i = 0; i < input_->childrenSize(); ++i) {
-    input_->childAt(i)->loadedVector();
+  for (int32_t i = 0; i < input->childrenSize(); ++i) {
+    input->childAt(i)->loadedVector();
   }
 
   for (int32_t partition = 0; partition < numSpillInputs_.size(); ++partition) {
@@ -420,8 +496,8 @@ void HashProbe::spillInput(RowVectorPtr& input) {
     if (numSpillInputs == 0) {
       continue;
     }
-    VELOX_CHECK(spiller_->isSpilled(partition));
-    spiller_->spill(
+    VELOX_CHECK(inputSpiller_->isSpilled(partition));
+    inputSpiller_->spill(
         partition,
         wrap(numSpillInputs, spillInputIndicesBuffers_[partition], input));
   }
@@ -439,6 +515,7 @@ void HashProbe::prepareInputIndicesBuffers(
   VELOX_DCHECK(spillEnabled());
   const auto maxIndicesBufferBytes = numInput * sizeof(vector_size_t);
   if (nonSpillInputIndicesBuffer_ == nullptr ||
+      !nonSpillInputIndicesBuffer_->isMutable() ||
       nonSpillInputIndicesBuffer_->size() < maxIndicesBufferBytes) {
     nonSpillInputIndicesBuffer_ = allocateIndices(numInput, pool());
     rawNonSpillInputIndicesBuffer_ =
@@ -471,7 +548,7 @@ BlockingReason HashProbe::isBlocked(ContinueFuture* future) {
       }
       break;
     case ProbeOperatorState::kWaitForPeers:
-      VELOX_CHECK(hasMoreSpillData());
+      VELOX_CHECK(spillEnabled());
       if (!future_.valid()) {
         setRunning();
       }
@@ -491,11 +568,8 @@ BlockingReason HashProbe::isBlocked(ContinueFuture* future) {
 }
 
 void HashProbe::clearDynamicFilters() {
-  VELOX_CHECK(!hasMoreSpillData());
-  VELOX_CHECK(!needSpillInput());
-
-  // The join can be completely replaced with a pushed down
-  // filter when the following conditions are met:
+  // The join can be completely replaced with a pushed down filter when the
+  // following conditions are met:
   //  * hash table has a single key with unique values,
   //  * build side has no dependent columns.
   if (keyChannels_.size() == 1 && !table_->hasDuplicateKeys() &&
@@ -529,7 +603,12 @@ void HashProbe::addInput(RowVectorPtr input) {
   }
   input_ = std::move(input);
 
-  if (input_->size() > 0) {
+  // Reset passingInputRowsInitialized_ as input_ as changed.
+  passingInputRowsInitialized_ = false;
+
+  const auto numInput = input_->size();
+
+  if (numInput > 0) {
     noInput_ = false;
   }
 
@@ -561,9 +640,7 @@ void HashProbe::addInput(RowVectorPtr input) {
     }
     // Build side is empty. This state is valid only for anti, left and full
     // joins.
-    VELOX_CHECK(
-        isAntiJoin(joinType_) || isLeftJoin(joinType_) ||
-        isFullJoin(joinType_) || isLeftSemiProjectJoin(joinType_));
+    VELOX_CHECK(joinIncludesMissesFromLeft(joinType_));
     if (isLeftSemiProjectJoin(joinType_) ||
         (isAntiJoin(joinType_) && filter_)) {
       // For anti join with filter and semi project join we need to decode the
@@ -578,37 +655,26 @@ void HashProbe::addInput(RowVectorPtr input) {
   if (!hasDecoded) {
     decodeAndDetectNonNullKeys();
   }
-
   activeRows_ = nonNullInputRows_;
-  lookup_->hashes.resize(input_->size());
-  auto mode = table_->hashMode();
-  auto& buildHashers = table_->hashers();
-  for (auto i = 0; i < keyChannels_.size(); ++i) {
-    if (mode != BaseHashTable::HashMode::kHash) {
-      auto key = input_->childAt(keyChannels_[i]);
-      buildHashers[i]->lookupValueIds(
-          *key, activeRows_, scratchMemory_, lookup_->hashes);
-    } else {
-      hashers_[i]->hash(activeRows_, i > 0, lookup_->hashes);
-    }
-  }
-  lookup_->rows.clear();
-  if (activeRows_.isAllSelected()) {
-    lookup_->rows.resize(activeRows_.size());
-    std::iota(lookup_->rows.begin(), lookup_->rows.end(), 0);
-  } else {
-    activeRows_.applyToSelected(
-        [&](auto row) { lookup_->rows.push_back(row); });
+
+  // Update statistics for null keys in join operator.
+  // Updating here means we will report 0 null keys when build side is empty.
+  // If we want more accurate stats, we will have to decode input vector
+  // even when not needed. So we tradeoff less accurate stats for more
+  // performance.
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->numNullKeys +=
+        activeRows_.size() - activeRows_.countSelected();
   }
 
-  passingInputRowsInitialized_ = false;
-  if (isLeftJoin(joinType_) || isFullJoin(joinType_) || isAntiJoin(joinType_) ||
-      isLeftSemiProjectJoin(joinType_)) {
+  table_->prepareForJoinProbe(*lookup_.get(), input_, activeRows_, false);
+
+  if (joinIncludesMissesFromLeft(joinType_)) {
     // Make sure to allocate an entry in 'hits' for every input row to allow for
     // including rows without a match in the output. Also, make sure to
     // initialize all 'hits' to nullptr as HashTable::joinProbe will only
     // process activeRows_.
-    auto numInput = input_->size();
     auto& hits = lookup_->hits;
     hits.resize(numInput);
     std::fill(hits.data(), hits.data() + numInput, nullptr);
@@ -629,7 +695,8 @@ void HashProbe::addInput(RowVectorPtr input) {
     lookup_->hits.resize(lookup_->rows.back() + 1);
     table_->joinProbe(*lookup_);
   }
-  results_.reset(*lookup_);
+
+  resultIter_->reset(*lookup_);
 }
 
 void HashProbe::prepareOutput(vector_size_t size) {
@@ -665,6 +732,7 @@ void HashProbe::fillLeftSemiProjectMatchColumn(vector_size_t size) {
     auto flatMatch = matchColumn()->as<FlatVector<bool>>();
     flatMatch->resize(size);
     auto rawValues = flatMatch->mutableRawValues<uint64_t>();
+    auto* outputTableRows = outputTableRows_->as<char*>();
     for (auto i = 0; i < size; ++i) {
       if (nullAware_) {
         // Null-aware join may produce TRUE, FALSE or NULL.
@@ -672,7 +740,7 @@ void HashProbe::fillLeftSemiProjectMatchColumn(vector_size_t size) {
           if (leftSemiProjectIsNull_.isValid(i)) {
             flatMatch->setNull(i, true);
           } else {
-            bool hasMatch = outputTableRows_[i] != nullptr;
+            const bool hasMatch = outputTableRows[i] != nullptr;
             bits::setBit(rawValues, i, hasMatch);
           }
         } else {
@@ -681,7 +749,7 @@ void HashProbe::fillLeftSemiProjectMatchColumn(vector_size_t size) {
             flatMatch->setNull(i, true);
           } else {
             // Probe key is not null.
-            bool hasMatch = outputTableRows_[i] != nullptr;
+            const bool hasMatch = outputTableRows[i] != nullptr;
             if (!hasMatch && buildSideHasNullKeys_) {
               flatMatch->setNull(i, true);
             } else {
@@ -690,7 +758,7 @@ void HashProbe::fillLeftSemiProjectMatchColumn(vector_size_t size) {
           }
         }
       } else {
-        bool hasMatch = outputTableRows_[i] != nullptr;
+        const bool hasMatch = outputTableRows[i] != nullptr;
         bits::setBit(rawValues, i, hasMatch);
       }
     }
@@ -715,7 +783,7 @@ void HashProbe::fillOutput(vector_size_t size) {
   } else {
     extractColumns(
         table_.get(),
-        folly::Range<char**>(outputTableRows_.data(), size),
+        folly::Range<char* const*>(outputTableRows_->as<char*>(), size),
         tableOutputProjections_,
         pool(),
         outputType_->children(),
@@ -724,29 +792,30 @@ void HashProbe::fillOutput(vector_size_t size) {
 }
 
 RowVectorPtr HashProbe::getBuildSideOutput() {
-  outputTableRows_.resize(outputBatchSize_);
+  auto* outputTableRows =
+      initBuffer<char*>(outputTableRows_, outputTableRowsCapacity_, pool());
   int32_t numOut;
   if (isRightSemiFilterJoin(joinType_)) {
     numOut = table_->listProbedRows(
         &lastProbeIterator_,
-        outputBatchSize_,
+        outputTableRowsCapacity_,
         RowContainer::kUnlimited,
-        outputTableRows_.data());
+        outputTableRows);
   } else if (isRightSemiProjectJoin(joinType_)) {
     numOut = table_->listAllRows(
         &lastProbeIterator_,
-        outputBatchSize_,
+        outputTableRowsCapacity_,
         RowContainer::kUnlimited,
-        outputTableRows_.data());
+        outputTableRows);
   } else {
     // Must be a right join or full join.
     numOut = table_->listNotProbedRows(
         &lastProbeIterator_,
-        outputBatchSize_,
+        outputTableRowsCapacity_,
         RowContainer::kUnlimited,
-        outputTableRows_.data());
+        outputTableRows);
   }
-  if (!numOut) {
+  if (numOut == 0) {
     return nullptr;
   }
 
@@ -760,7 +829,7 @@ RowVectorPtr HashProbe::getBuildSideOutput() {
 
   extractColumns(
       table_.get(),
-      folly::Range<char**>(outputTableRows_.data(), numOut),
+      folly::Range<char**>(outputTableRows, numOut),
       tableOutputProjections_,
       pool(),
       outputType_->children(),
@@ -774,7 +843,7 @@ RowVectorPtr HashProbe::getBuildSideOutput() {
       matchColumn() = createConstantFalse(numOut, pool());
     } else {
       table_->rows()->extractProbedFlags(
-          outputTableRows_.data(),
+          outputTableRows,
           numOut,
           nullAware_,
           nullAware_ && probeSideHasNullKeys_,
@@ -795,9 +864,7 @@ void HashProbe::clearIdentityProjectedOutput() {
 }
 
 bool HashProbe::needLastProbe() const {
-  return !skipInput_ &&
-      (isRightJoin(joinType_) || isFullJoin(joinType_) ||
-       isRightSemiFilterJoin(joinType_) || isRightSemiProjectJoin(joinType_));
+  return !skipInput_ && needRightSideJoin(joinType_);
 }
 
 bool HashProbe::skipProbeOnEmptyBuild() const {
@@ -807,7 +874,7 @@ bool HashProbe::skipProbeOnEmptyBuild() const {
 }
 
 bool HashProbe::spillEnabled() const {
-  return spillConfig_.has_value();
+  return canSpill() && !operatorCtx_->task()->hasMixedExecutionGroup();
 }
 
 bool HashProbe::hasMoreSpillData() const {
@@ -817,7 +884,7 @@ bool HashProbe::hasMoreSpillData() const {
 
 bool HashProbe::needSpillInput() const {
   VELOX_CHECK(spillInputPartitionIds_.empty() || spillEnabled());
-  VELOX_CHECK_EQ(spillInputPartitionIds_.empty(), spiller_ == nullptr);
+  VELOX_CHECK_EQ(spillInputPartitionIds_.empty(), inputSpiller_ == nullptr);
 
   return !spillInputPartitionIds_.empty();
 }
@@ -831,16 +898,16 @@ void HashProbe::checkStateTransition(ProbeOperatorState state) {
   VELOX_CHECK_NE(state_, state);
   switch (state) {
     case ProbeOperatorState::kRunning:
-      if (!hasMoreSpillData()) {
+      if (!spillEnabled()) {
         VELOX_CHECK_EQ(state_, ProbeOperatorState::kWaitForBuild);
       } else {
         VELOX_CHECK(
             state_ == ProbeOperatorState::kWaitForBuild ||
-            state_ == ProbeOperatorState::kWaitForPeers)
+            state_ == ProbeOperatorState::kWaitForPeers);
       }
       break;
     case ProbeOperatorState::kWaitForPeers:
-      VELOX_CHECK(hasMoreSpillData());
+      VELOX_CHECK(spillEnabled());
       [[fallthrough]];
     case ProbeOperatorState::kWaitForBuild:
       [[fallthrough]];
@@ -854,12 +921,27 @@ void HashProbe::checkStateTransition(ProbeOperatorState state) {
 }
 
 RowVectorPtr HashProbe::getOutput() {
+  return getOutputInternal(/*toSpillOutput=*/false);
+}
+
+RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
   if (isFinished()) {
     return nullptr;
   }
   checkRunning();
 
+  if (!toSpillOutput) {
+    // Avoid memory reservation if it is triggered by memory arbitration to
+    // spill pending output.
+    ensureOutputFits();
+  }
+
+  if (maybeReadSpillOutput()) {
+    return output_;
+  }
+
   clearIdentityProjectedOutput();
+
   if (!input_) {
     if (!hasMoreInput()) {
       if (needLastProbe() && lastProber_) {
@@ -868,10 +950,25 @@ RowVectorPtr HashProbe::getOutput() {
           return output;
         }
       }
+
+      // NOTE: if getOutputInternal() is called from memory arbitration to spill
+      // the produced output from pending 'input_', then we should not proceed
+      // with the rest of procedure, and let the next driver getOutput() call to
+      // handle the probe finishing process properly.
+      if (toSpillOutput) {
+        VELOX_CHECK(memory::underMemoryArbitration());
+        VELOX_CHECK(canReclaim());
+        return nullptr;
+      }
+
       if (hasMoreSpillData()) {
         prepareForSpillRestore();
         asyncWaitForHashTable();
       } else {
+        if (lastProber_ && spillEnabled()) {
+          joinBridge_->probeFinished();
+          wakeupPeerOperators();
+        }
         setState(ProbeOperatorState::kFinish);
       }
       return nullptr;
@@ -894,15 +991,25 @@ RowVectorPtr HashProbe::getOutput() {
 
   const bool emptyBuildSide = (table_->numDistinct() == 0);
 
-  // Left semi and anti joins are always cardinality reducing, e.g. for a given
-  // row of input they produce zero or 1 row of output. Therefore, if there is
-  // no extra filter we can process each batch of input in one go.
+  // Left semi and anti joins are always cardinality reducing, e.g. for a
+  // given row of input they produce zero or 1 row of output. Therefore, if
+  // there is no extra filter we can process each batch of input in one go.
   auto outputBatchSize = (isLeftSemiOrAntiJoinNoFilter || emptyBuildSide)
       ? inputSize
       : outputBatchSize_;
-  auto mapping =
-      initializeRowNumberMapping(outputRowMapping_, outputBatchSize, pool());
-  outputTableRows_.resize(outputBatchSize);
+  outputTableRowsCapacity_ = outputBatchSize;
+  if (filter_ &&
+      (isLeftJoin(joinType_) || isFullJoin(joinType_) ||
+       isAntiJoin(joinType_))) {
+    // If we need non-matching probe side row, there is a possibility that such
+    // row exists at end of an input batch and being carried over in the next
+    // output batch, so we need to make extra room of one row in output.
+    ++outputTableRowsCapacity_;
+  }
+  auto mapping = initializeRowNumberMapping(
+      outputRowMapping_, outputTableRowsCapacity_, pool());
+  auto* outputTableRows =
+      initBuffer<char*>(outputTableRows_, outputTableRowsCapacity_, pool());
 
   for (;;) {
     int numOut = 0;
@@ -910,8 +1017,8 @@ RowVectorPtr HashProbe::getOutput() {
     if (emptyBuildSide) {
       // When build side is empty, anti and left joins return all probe side
       // rows, including ones with null join keys.
-      std::iota(mapping.begin(), mapping.end(), 0);
-      std::fill(outputTableRows_.begin(), outputTableRows_.end(), nullptr);
+      std::iota(mapping.begin(), mapping.begin() + inputSize, 0);
+      std::fill(outputTableRows, outputTableRows + inputSize, nullptr);
       numOut = inputSize;
     } else if (isAntiJoin(joinType_) && !filter_) {
       if (nullAware_) {
@@ -936,11 +1043,11 @@ RowVectorPtr HashProbe::getOutput() {
       }
     } else {
       numOut = table_->listJoinResults(
-          results_,
-          isLeftJoin(joinType_) || isFullJoin(joinType_) ||
-              isAntiJoin(joinType_) || isLeftSemiProjectJoin(joinType_),
-          mapping,
-          folly::Range(outputTableRows_.data(), outputTableRows_.size()));
+          *resultIter_,
+          joinIncludesMissesFromLeft(joinType_),
+          folly::Range(mapping.data(), outputBatchSize),
+          folly::Range(outputTableRows, outputBatchSize),
+          operatorCtx_->driverCtx()->queryConfig().preferredOutputBatchBytes());
     }
 
     // We are done processing the input batch if there are no more joined rows
@@ -950,23 +1057,23 @@ RowVectorPtr HashProbe::getOutput() {
       input_ = nullptr;
       return nullptr;
     }
-    VELOX_CHECK_LE(numOut, outputTableRows_.size());
+    VELOX_CHECK_LE(numOut, outputBatchSize);
 
     numOut = evalFilter(numOut);
 
-    if (!numOut) {
+    if (numOut == 0) {
       continue;
     }
 
     if (needLastProbe()) {
       // Mark build-side rows that have a match on the join condition.
-      table_->rows()->setProbedFlag(outputTableRows_.data(), numOut);
+      table_->rows()->setProbedFlag(outputTableRows, numOut);
     }
 
     // Right semi join only returns the build side output when the probe side
     // is fully complete. Do not return anything here.
     if (isRightSemiFilterJoin(joinType_) || isRightSemiProjectJoin(joinType_)) {
-      if (results_.atEnd()) {
+      if (resultIter_->atEnd()) {
         input_ = nullptr;
       }
       return nullptr;
@@ -981,27 +1088,56 @@ RowVectorPtr HashProbe::getOutput() {
   }
 }
 
-void HashProbe::fillFilterInput(vector_size_t size) {
+bool HashProbe::maybeReadSpillOutput() {
+  maybeSetupSpillOutputReader();
+
+  if (spillOutputReader_ == nullptr) {
+    return false;
+  }
+
+  VELOX_DCHECK_EQ(table_->numDistinct(), 0);
+
+  if (!spillOutputReader_->nextBatch(output_)) {
+    spillOutputReader_.reset();
+    return false;
+  }
+  return true;
+}
+
+RowVectorPtr HashProbe::createFilterInput(vector_size_t size) {
   std::vector<VectorPtr> filterColumns(filterInputType_->size());
   for (auto projection : filterInputProjections_) {
-    ensureLoadedIfNotAtEnd(projection.inputChannel);
+    if (projectedInputColumns_.find(projection.inputChannel) !=
+        projectedInputColumns_.end()) {
+      // If the column is projected to the output, ensure it's loaded if it's
+      // lazy in case the filter only loads an incomplete subset of the rows
+      // that will be output.
+      ensureLoaded(projection.inputChannel);
+    } else {
+      // If the column isn't projected to the output, the Vector will only be
+      // reused if we've broken the input batch into multiple output batches,
+      // i.e. if results_ is not at the end of the iterator.
+      ensureLoadedIfNotAtEnd(projection.inputChannel);
+    }
+
     filterColumns[projection.outputChannel] = wrapChild(
         size, outputRowMapping_, input_->childAt(projection.inputChannel));
   }
 
   extractColumns(
       table_.get(),
-      folly::Range<char**>(outputTableRows_.data(), size),
+      folly::Range<char* const*>(outputTableRows_->as<char*>(), size),
       filterTableProjections_,
       pool(),
       filterInputType_->children(),
       filterColumns);
 
-  filterInput_ = std::make_shared<RowVector>(
+  return std::make_shared<RowVector>(
       pool(), filterInputType_, nullptr, size, std::move(filterColumns));
 }
 
 void HashProbe::prepareFilterRowsForNullAwareJoin(
+    RowVectorPtr& filterInput,
     vector_size_t numRows,
     bool filterPropagateNulls) {
   VELOX_CHECK_LE(numRows, kBatchSize);
@@ -1015,17 +1151,28 @@ void HashProbe::prepareFilterRowsForNullAwareJoin(
     auto* rawNullRows = nullFilterInputRows_.asMutableRange().bits();
     for (auto& projection : filterInputProjections_) {
       filterInputColumnDecodedVector_.decode(
-          *filterInput_->childAt(projection.outputChannel), filterInputRows_);
+          *filterInput->childAt(projection.outputChannel), filterInputRows_);
       if (filterInputColumnDecodedVector_.mayHaveNulls()) {
-        // NOTE: the false value of a raw null bit indicates null so we OR with
-        // negative of the raw bit.
+        SelectivityVector nullsInActiveRows(numRows);
+        memcpy(
+            nullsInActiveRows.asMutableRange().bits(),
+            filterInputColumnDecodedVector_.nulls(&filterInputRows_),
+            bits::nbytes(numRows));
+        // All rows that are not active count as non-null here.
+        bits::orWithNegatedBits(
+            nullsInActiveRows.asMutableRange().bits(),
+            filterInputRows_.asRange().bits(),
+            0,
+            numRows);
+        // NOTE: the false value of a raw null bit indicates null so we OR
+        // with negative of the raw bit.
         bits::orWithNegatedBits(
-            rawNullRows, filterInputColumnDecodedVector_.nulls(), 0, numRows);
+            rawNullRows, nullsInActiveRows.asRange().bits(), 0, numRows);
       }
     }
     nullFilterInputRows_.updateBounds();
-    // TODO: consider to skip filtering on 'nullFilterInputRows_' as we know it
-    // will never pass the filtering.
+    // TODO: consider to skip filtering on 'nullFilterInputRows_' as we know
+    // it will never pass the filtering.
   }
 
   // NOTE: for null-aware anti join, we will skip filtering on the probe rows
@@ -1073,16 +1220,14 @@ void HashProbe::applyFilterOnTableRowsForNullAwareJoin(
   if (!rows.hasSelections()) {
     return;
   }
-  auto* tableRows = table_->rows();
-  VELOX_CHECK(tableRows, "Should not move rows in hash joins");
+  VELOX_CHECK(table_->rows(), "Should not move rows in hash joins");
   char* data[kBatchSize];
   while (auto numRows = iterator(data, kBatchSize)) {
     filterTableInput_->resize(numRows);
     filterTableInputRows_.resizeFill(numRows, true);
     for (auto& projection : filterTableProjections_) {
-      tableRows->extractColumn(
-          data,
-          numRows,
+      table_->extractColumn(
+          folly::Range<char* const*>(data, numRows),
           projection.inputChannel,
           filterTableInput_->childAt(projection.outputChannel));
     }
@@ -1131,13 +1276,13 @@ SelectivityVector HashProbe::evalFilterForNullAwareJoin(
   // Subset of probe-side rows with a match that passed the filter.
   SelectivityVector filterPassedRows(input_->size(), false);
 
-  // Subset of probe-side rows with non-null probe key and either no match or no
-  // match that passed the filter. We need to combine these with all build-side
-  // rows with null keys to see if a filter passes on any of these.
+  // Subset of probe-side rows with non-null probe key and either no match or
+  // no match that passed the filter. We need to combine these with all
+  // build-side rows with null keys to see if a filter passes on any of these.
   SelectivityVector nullKeyProbeRows(input_->size(), false);
 
-  // Subset of probe-sie rows with null probe key. We need to combine these with
-  // all build-side rows to see if a filter passes on any of these.
+  // Subset of probe-sie rows with null probe key. We need to combine these
+  // with all build-side rows to see if a filter passes on any of these.
   SelectivityVector crossJoinProbeRows(input_->size(), false);
 
   for (auto i = 0; i < numRows; ++i) {
@@ -1186,30 +1331,32 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
   const bool filterPropagateNulls = filter_->expr(0)->propagatesNulls();
   auto* rawOutputProbeRowMapping =
       outputRowMapping_->asMutable<vector_size_t>();
+  auto* outputTableRows = outputTableRows_->asMutable<char*>();
 
   filterInputRows_.resizeFill(numRows);
 
   // Do not evaluate filter on rows with no match to (1) avoid
   // false-positives when filter evaluates to true for rows with NULLs on the
-  // build side; (2) avoid errors in filter evaluation that would fail the query
-  // unnecessarily.
+  // build side; (2) avoid errors in filter evaluation that would fail the
+  // query unnecessarily.
   // TODO Apply the same to left joins.
   if (isAntiJoin(joinType_) || isLeftSemiProjectJoin(joinType_)) {
     for (auto i = 0; i < numRows; ++i) {
-      if (outputTableRows_[i] == nullptr) {
+      if (outputTableRows[i] == nullptr) {
         filterInputRows_.setValid(i, false);
       }
     }
     filterInputRows_.updateBounds();
   }
 
-  fillFilterInput(numRows);
+  RowVectorPtr filterInput = createFilterInput(numRows);
 
   if (nullAware_) {
-    prepareFilterRowsForNullAwareJoin(numRows, filterPropagateNulls);
+    prepareFilterRowsForNullAwareJoin(
+        filterInput, numRows, filterPropagateNulls);
   }
 
-  EvalCtx evalCtx(operatorCtx_->execCtx(), filter_.get(), filterInput_.get());
+  EvalCtx evalCtx(operatorCtx_->execCtx(), filter_.get(), filterInput.get());
   filter_->eval(0, 1, true, filterInputRows_, evalCtx, filterResult_);
 
   decodedFilterResult_.decode(*filterResult_[0], filterInputRows_);
@@ -1218,24 +1365,54 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
   if (isLeftJoin(joinType_) || isFullJoin(joinType_)) {
     // Identify probe rows which got filtered out and add them back with nulls
     // for build side.
-    auto addMiss = [&](auto row) {
-      outputTableRows_[numPassed] = nullptr;
-      rawOutputProbeRowMapping[numPassed++] = row;
-    };
-    for (auto i = 0; i < numRows; ++i) {
-      const bool passed = filterPassed(i);
-      noMatchDetector_.advance(rawOutputProbeRowMapping[i], passed, addMiss);
-      if (passed) {
-        outputTableRows_[numPassed] = outputTableRows_[i];
-        rawOutputProbeRowMapping[numPassed++] = rawOutputProbeRowMapping[i];
+    if (noMatchDetector_.hasLastMissedRow()) {
+      auto* tempOutputTableRows = initBuffer<char*>(
+          tempOutputTableRows_, outputTableRowsCapacity_, pool());
+      auto* tempOutputRowMapping = initBuffer<vector_size_t>(
+          tempOutputRowMapping_, outputTableRowsCapacity_, pool());
+      auto addMiss = [&](auto row) {
+        tempOutputTableRows[numPassed] = nullptr;
+        tempOutputRowMapping[numPassed++] = row;
+      };
+      for (auto i = 0; i < numRows; ++i) {
+        const bool passed = filterPassed(i);
+        noMatchDetector_.advance(rawOutputProbeRowMapping[i], passed, addMiss);
+        if (passed) {
+          tempOutputTableRows[numPassed] = outputTableRows[i];
+          tempOutputRowMapping[numPassed++] = rawOutputProbeRowMapping[i];
+        }
+      }
+      if (resultIter_->atEnd()) {
+        noMatchDetector_.finish(addMiss);
+      }
+      std::copy(
+          tempOutputTableRows,
+          tempOutputTableRows + numPassed,
+          outputTableRows);
+      std::copy(
+          tempOutputRowMapping,
+          tempOutputRowMapping + numPassed,
+          rawOutputProbeRowMapping);
+    } else {
+      auto addMiss = [&](auto row) {
+        outputTableRows[numPassed] = nullptr;
+        rawOutputProbeRowMapping[numPassed++] = row;
+      };
+      for (auto i = 0; i < numRows; ++i) {
+        const bool passed = filterPassed(i);
+        noMatchDetector_.advance(rawOutputProbeRowMapping[i], passed, addMiss);
+        if (passed) {
+          outputTableRows[numPassed] = outputTableRows[i];
+          rawOutputProbeRowMapping[numPassed++] = rawOutputProbeRowMapping[i];
+        }
+      }
+      if (resultIter_->atEnd()) {
+        noMatchDetector_.finish(addMiss);
       }
     }
-
-    noMatchDetector_.finishIteration(
-        addMiss, results_.atEnd(), outputTableRows_.size() - numPassed);
   } else if (isLeftSemiFilterJoin(joinType_)) {
     auto addLastMatch = [&](auto row) {
-      outputTableRows_[numPassed] = nullptr;
+      outputTableRows[numPassed] = nullptr;
       rawOutputProbeRowMapping[numPassed++] = row;
     };
     for (auto i = 0; i < numRows; ++i) {
@@ -1244,7 +1421,7 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
             rawOutputProbeRowMapping[i], addLastMatch);
       }
     }
-    if (results_.atEnd()) {
+    if (resultIter_->atEnd()) {
       leftSemiFilterJoinTracker_.finish(addLastMatch);
     }
   } else if (isLeftSemiProjectJoin(joinType_)) {
@@ -1259,7 +1436,7 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
 
       auto addLast = [&](auto row, std::optional<bool> passed) {
         if (passed.has_value()) {
-          outputTableRows_[numPassed] =
+          outputTableRows[numPassed] =
               passed.value() ? const_cast<char*>(kPassed) : nullptr;
         } else {
           leftSemiProjectIsNull_.setValid(numPassed, true);
@@ -1281,12 +1458,12 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
         leftSemiProjectJoinTracker_.advance(probeRow, passed, addLast);
       }
       leftSemiProjectIsNull_.updateBounds();
-      if (results_.atEnd()) {
+      if (resultIter_->atEnd()) {
         leftSemiProjectJoinTracker_.finish(addLast);
       }
     } else {
       auto addLast = [&](auto row, std::optional<bool> passed) {
-        outputTableRows_[numPassed] =
+        outputTableRows[numPassed] =
             passed.value() ? const_cast<char*>(kPassed) : nullptr;
         rawOutputProbeRowMapping[numPassed++] = row;
       };
@@ -1294,13 +1471,13 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
         leftSemiProjectJoinTracker_.advance(
             rawOutputProbeRowMapping[i], filterPassed(i), addLast);
       }
-      if (results_.atEnd()) {
+      if (resultIter_->atEnd()) {
         leftSemiProjectJoinTracker_.finish(addLast);
       }
     }
   } else if (isAntiJoin(joinType_)) {
     auto addMiss = [&](auto row) {
-      outputTableRows_[numPassed] = nullptr;
+      outputTableRows[numPassed] = nullptr;
       rawOutputProbeRowMapping[numPassed++] = row;
     };
     if (nullAware_) {
@@ -1317,33 +1494,40 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
         noMatchDetector_.advance(probeRow, filterPassed(i), addMiss);
       }
     }
-
-    noMatchDetector_.finishIteration(
-        addMiss, results_.atEnd(), outputTableRows_.size() - numPassed);
+    if (resultIter_->atEnd()) {
+      noMatchDetector_.finish(addMiss);
+    }
   } else {
     for (auto i = 0; i < numRows; ++i) {
       if (filterPassed(i)) {
-        outputTableRows_[numPassed] = outputTableRows_[i];
+        outputTableRows[numPassed] = outputTableRows[i];
         rawOutputProbeRowMapping[numPassed++] = rawOutputProbeRowMapping[i];
       }
     }
   }
+  VELOX_CHECK_LE(numPassed, outputTableRowsCapacity_);
   return numPassed;
 }
 
 void HashProbe::ensureLoadedIfNotAtEnd(column_index_t channel) {
-  if ((!filter_ &&
-       (isLeftSemiFilterJoin(joinType_) || isLeftSemiProjectJoin(joinType_) ||
-        isAntiJoin(joinType_))) ||
-      results_.atEnd()) {
+  if (resultIter_->atEnd()) {
+    return;
+  }
+
+  ensureLoaded(channel);
+}
+
+void HashProbe::ensureLoaded(column_index_t channel) {
+  if (!filter_ &&
+      (isLeftSemiFilterJoin(joinType_) || isLeftSemiProjectJoin(joinType_) ||
+       isAntiJoin(joinType_))) {
     return;
   }
 
   if (!passingInputRowsInitialized_) {
     passingInputRowsInitialized_ = true;
     passingInputRows_.resize(input_->size());
-    if (isLeftJoin(joinType_) || isFullJoin(joinType_) ||
-        isLeftSemiProjectJoin(joinType_)) {
+    if (joinIncludesMissesFromLeft(joinType_)) {
       passingInputRows_.setAll();
     } else {
       passingInputRows_.clearAll();
@@ -1354,8 +1538,9 @@ void HashProbe::ensureLoadedIfNotAtEnd(column_index_t channel) {
           passingInputRows_.setValid(i, true);
         }
       }
+
+      passingInputRows_.updateBounds();
     }
-    passingInputRows_.updateBounds();
   }
 
   LazyVector::ensureLoadedRows(input_->childAt(channel), passingInputRows_);
@@ -1375,52 +1560,45 @@ void HashProbe::noMoreInputInternal() {
 
   noMoreSpillInput_ = true;
   if (!spillInputPartitionIds_.empty()) {
+    VELOX_CHECK_NOT_NULL(inputSpiller_);
     VELOX_CHECK_EQ(
-        spillInputPartitionIds_.size(), spiller_->spilledPartitionSet().size());
-    spiller_->finishSpill(spillPartitionSet_);
-    recordSpillStats();
-  }
-
-  // Setup spill partition data.
-  const bool hasSpillData = hasMoreSpillData();
-  if (!needLastProbe() && !hasSpillData) {
-    return;
+        spillInputPartitionIds_.size(),
+        inputSpiller_->spilledPartitionSet().size());
+    inputSpiller_->finishSpill(spillPartitionSet_);
+    VELOX_CHECK_EQ(spillStats_.rlock()->spillSortTimeNanos, 0);
   }
 
+  const bool hasSpillEnabled = spillEnabled();
   std::vector<ContinuePromise> promises;
   std::vector<std::shared_ptr<Driver>> peers;
-  // The last operator to finish processing inputs is responsible for producing
-  // build-side rows based on the join.
+  // The last operator to finish processing inputs is responsible for
+  // producing build-side rows based on the join.
   if (!operatorCtx_->task()->allPeersFinished(
           planNodeId(),
           operatorCtx_->driver(),
-          hasSpillData ? &future_ : nullptr,
-          hasSpillData ? promises_ : promises,
+          hasSpillEnabled ? &future_ : nullptr,
+          hasSpillEnabled ? promises_ : promises,
           peers)) {
-    if (hasSpillData) {
+    if (hasSpillEnabled) {
       VELOX_CHECK(future_.valid());
       setState(ProbeOperatorState::kWaitForPeers);
+      VELOX_DCHECK(promises_.empty());
+    } else {
+      VELOX_DCHECK(promises.empty());
     }
-    DCHECK(promises.empty());
     return;
   }
-  // NOTE: if 'hasSpillData' is false, then this is the last built table to
-  // probe. Correspondingly, the hash probe operator except the last one can
-  // simply finish its processing without waiting the other peers to reach the
-  // barrier.
+
   VELOX_CHECK(promises.empty());
-  VELOX_CHECK(hasSpillData || peers.empty());
+  // NOTE: if 'hasSpillEnabled' is false, then a hash probe operator doesn't
+  // need to wait for all the other peers to finish probe processing.
+  // Otherwise, it needs to wait and might expect spill gets triggered by the
+  // other probe operators, or there is previously spilled table partition(s)
+  // that needs to restore.
+  VELOX_CHECK(hasSpillEnabled || peers.empty());
   lastProber_ = true;
 }
 
-void HashProbe::recordSpillStats() {
-  VELOX_CHECK_NOT_NULL(spiller_);
-  const auto spillStats = spiller_->stats();
-  VELOX_CHECK_EQ(spillStats.spillSortTimeUs, 0);
-  VELOX_CHECK_EQ(spillStats.spillFillTimeUs, 0);
-  Operator::recordSpillStats(spillStats);
-}
-
 bool HashProbe::isFinished() {
   return state_ == ProbeOperatorState::kFinish;
 }
@@ -1437,14 +1615,399 @@ void HashProbe::setRunning() {
   setState(ProbeOperatorState::kRunning);
 }
 
-void HashProbe::abort() {
-  Operator::abort();
+bool HashProbe::nonReclaimableState() const {
+  return (state_ != ProbeOperatorState::kRunning) || nonReclaimableSection_ ||
+      (inputSpiller_ != nullptr) || (table_ == nullptr) ||
+      (table_->numDistinct() == 0);
+}
+
+void HashProbe::ensureOutputFits() {
+  if (!canReclaim()) {
+    // Don't reserve memory if we can't reclaim from this hash probe operator.
+    return;
+  }
+
+  if (testingTriggerSpill(pool()->name())) {
+    Operator::ReclaimableSectionGuard guard(this);
+    memory::testingRunArbitration(pool());
+  }
+
+  const uint64_t bytesToReserve =
+      operatorCtx_->driverCtx()->queryConfig().preferredOutputBatchBytes() *
+      1.2;
+  if (pool()->availableReservation() >= bytesToReserve) {
+    return;
+  }
+  {
+    Operator::ReclaimableSectionGuard guard(this);
+    if (pool()->maybeReserve(bytesToReserve)) {
+      return;
+    }
+  }
+  LOG(WARNING) << "Failed to reserve " << succinctBytes(bytesToReserve)
+               << " for memory pool " << pool()->name()
+               << ", usage: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+}
+
+bool HashProbe::canReclaim() const {
+  return spillEnabled();
+}
+
+void HashProbe::reclaim(
+    uint64_t /*unused*/,
+    memory::MemoryReclaimer::Stats& stats) {
+  VELOX_CHECK(canReclaim());
+  auto* driver = operatorCtx_->driver();
+  VELOX_CHECK_NOT_NULL(driver);
+  VELOX_CHECK(!nonReclaimableSection_);
+
+  if (exceededMaxSpillLevelLimit_) {
+    // NOTE: we might have reached to the max spill limit.
+    return;
+  }
+
+  if (nonReclaimableState()) {
+    // TODO: reduce the log frequency if it is too verbose.
+    RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
+    ++stats.numNonReclaimableAttempts;
+    FB_LOG_EVERY_MS(WARNING, 1'000)
+        << "Can't reclaim from hash probe operator, state_["
+        << ProbeOperatorState(state_) << "], nonReclaimableSection_["
+        << nonReclaimableSection_ << "], inputSpiller_["
+        << (inputSpiller_ == nullptr ? "nullptr" : "initialized")
+        << "], table_[" << (table_ == nullptr ? "nullptr" : "initialized")
+        << "], table_ numDistinct["
+        << (table_ == nullptr ? "nullptr"
+                              : std::to_string(table_->numDistinct()))
+        << "], " << pool()->name()
+        << ", usage: " << succinctBytes(pool()->usedBytes())
+        << ", node pool reservation: "
+        << succinctBytes(pool()->parent()->reservedBytes());
+    return;
+  }
+
+  const auto& task = driver->task();
+  VELOX_CHECK(task->pauseRequested());
+  const std::vector<HashProbe*> probeOps = findPeerOperators();
+  bool hasMoreProbeInput{false};
+  for (auto* probeOp : probeOps) {
+    VELOX_CHECK_NOT_NULL(probeOp);
+    VELOX_CHECK(probeOp->canReclaim());
+    if (probeOp->nonReclaimableState()) {
+      RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
+      ++stats.numNonReclaimableAttempts;
+      const auto* peerPool = probeOp->pool();
+      FB_LOG_EVERY_MS(WARNING, 1'000)
+          << "Can't reclaim from hash probe operator, state_["
+          << ProbeOperatorState(probeOp->state_) << "], nonReclaimableSection_["
+          << probeOp->nonReclaimableSection_ << "], inputSpiller_["
+          << (probeOp->inputSpiller_ == nullptr ? "nullptr" : "initialized")
+          << "], table_["
+          << (probeOp->table_ == nullptr ? "nullptr" : "initialized")
+          << "], table_ numDistinct["
+          << (probeOp->table_ == nullptr
+                  ? "nullptr"
+                  : std::to_string(probeOp->table_->numDistinct()))
+          << "], " << peerPool->name()
+          << ", usage: " << succinctBytes(peerPool->usedBytes())
+          << ", node pool reservation: "
+          << succinctBytes(peerPool->parent()->reservedBytes());
+      return;
+    }
+    hasMoreProbeInput |= !probeOp->noMoreSpillInput_;
+  }
+
+  spillOutput(probeOps);
+
+  SpillPartitionSet spillPartitionSet;
+  if (hasMoreProbeInput) {
+    // Only spill hash table if any hash probe operators still has input probe
+    // data, otherwise we skip this step.
+    spillPartitionSet = spillTable();
+    VELOX_CHECK(!spillPartitionSet.empty());
+  }
+  const auto spillPartitionIdSet = toSpillPartitionIdSet(spillPartitionSet);
+
+  for (auto* probeOp : probeOps) {
+    VELOX_CHECK_NOT_NULL(probeOp);
+    probeOp->clearBuffers();
+    // Setup all the probe operators to spill the rest of probe inputs if the
+    // table has been spilled.
+    if (!spillPartitionSet.empty()) {
+      VELOX_CHECK(hasMoreProbeInput);
+      probeOp->maybeSetupInputSpiller(spillPartitionIdSet);
+    }
+    probeOp->pool()->release();
+  }
+
+  // Clears memory resources held by the built hash table.
+  table_->clear(true);
+  // Sets the spilled hash table in the join bridge.
+  if (!spillPartitionIdSet.empty()) {
+    joinBridge_->setSpilledHashTable(std::move(spillPartitionSet));
+  }
+}
+
+void HashProbe::spillOutput(const std::vector<HashProbe*>& operators) {
+  struct SpillResult {
+    const std::exception_ptr error{nullptr};
+
+    explicit SpillResult(std::exception_ptr _error)
+        : error(std::move(_error)) {}
+  };
+
+  std::vector<std::shared_ptr<AsyncSource<SpillResult>>> spillTasks;
+  auto* spillExecutor = spillConfig()->executor;
+  for (auto* op : operators) {
+    HashProbe* probeOp = static_cast<HashProbe*>(op);
+    spillTasks.push_back(
+        memory::createAsyncMemoryReclaimTask<SpillResult>([probeOp]() {
+          try {
+            probeOp->spillOutput();
+            return std::make_unique<SpillResult>(nullptr);
+          } catch (const std::exception& e) {
+            LOG(ERROR) << "Spill output from hash probe pool "
+                       << probeOp->pool()->name() << " failed: " << e.what();
+            // The exception is captured and thrown by the caller.
+            return std::make_unique<SpillResult>(std::current_exception());
+          }
+        }));
+    if ((spillTasks.size() > 1) && (spillExecutor != nullptr)) {
+      spillExecutor->add([source = spillTasks.back()]() { source->prepare(); });
+    }
+  }
+
+  SCOPE_EXIT {
+    for (auto& spillTask : spillTasks) {
+      // We consume the result for the pending tasks. This is a cleanup in the
+      // guard and must not throw. The first error is already captured before
+      // this runs.
+      try {
+        spillTask->move();
+      } catch (const std::exception&) {
+      }
+    }
+  };
+
+  for (auto& spillTask : spillTasks) {
+    const auto result = spillTask->move();
+    if (result->error) {
+      std::rethrow_exception(result->error);
+    }
+  }
+}
+
+void HashProbe::spillOutput() {
+  // Checks if there is any output to spill or not.
+  if (input_ == nullptr && !needLastProbe()) {
+    return;
+  }
+  // We spill all the outputs produced from 'input_' into a single partition.
+  auto outputSpiller = std::make_unique<Spiller>(
+      Spiller::Type::kHashJoinProbe,
+      outputType_,
+      HashBitRange{},
+      spillConfig(),
+      &spillStats_);
+  outputSpiller->setPartitionsSpilled({0});
+
+  RowVectorPtr output{nullptr};
+  for (;;) {
+    output = getOutputInternal(/*toSpillOutput=*/true);
+    if (output != nullptr) {
+      // Ensure vector are lazy loaded before spilling.
+      for (int32_t i = 0; i < output->childrenSize(); ++i) {
+        output->childAt(i)->loadedVector();
+      }
+      outputSpiller->spill(0, output);
+      continue;
+    }
+    // NOTE: for right semi join types, we need to check if 'input_' has been
+    // cleared or not instead of checking on output. The right semi joins only
+    // producing the output after processing all the probe inputs.
+    if (input_ == nullptr) {
+      break;
+    }
+    VELOX_CHECK(
+        isRightSemiFilterJoin(joinType_) || isRightSemiProjectJoin(joinType_));
+    VELOX_CHECK((output == nullptr) && (input_ != nullptr));
+  }
+  VELOX_CHECK_LE(outputSpiller->spilledPartitionSet().size(), 1);
+
+  VELOX_CHECK(spillOutputPartitionSet_.empty());
+  outputSpiller->finishSpill(spillOutputPartitionSet_);
+  VELOX_CHECK_EQ(spillOutputPartitionSet_.size(), 1);
+
+  removeEmptyPartitions(spillOutputPartitionSet_);
+}
+
+void HashProbe::maybeSetupSpillOutputReader() {
+  if (spillOutputPartitionSet_.empty()) {
+    return;
+  }
+  VELOX_CHECK_EQ(spillOutputPartitionSet_.size(), 1);
+  VELOX_CHECK_NULL(spillOutputReader_);
+
+  spillOutputReader_ =
+      spillOutputPartitionSet_.begin()->second->createUnorderedReader(
+          spillConfig_->readBufferSize, pool(), &spillStats_);
+  spillOutputPartitionSet_.clear();
+}
+
+SpillPartitionSet HashProbe::spillTable() {
+  struct SpillResult {
+    std::unique_ptr<Spiller> spiller{nullptr};
+    const std::exception_ptr error{nullptr};
+
+    explicit SpillResult(std::exception_ptr _error) : error(_error) {}
+    explicit SpillResult(std::unique_ptr<Spiller> _spiller)
+        : spiller(std::move(_spiller)) {}
+  };
+
+  const std::vector<RowContainer*> rowContainers = table_->allRows();
+  std::vector<std::shared_ptr<AsyncSource<SpillResult>>> spillTasks;
+  auto* spillExecutor = spillConfig()->executor;
+  for (auto* rowContainer : rowContainers) {
+    if (rowContainer->numRows() == 0) {
+      continue;
+    }
+    spillTasks.push_back(memory::createAsyncMemoryReclaimTask<SpillResult>(
+        [this, rowContainer]() {
+          try {
+            return std::make_unique<SpillResult>(spillTable(rowContainer));
+          } catch (const std::exception& e) {
+            LOG(ERROR) << "Spill sub-table from hash probe pool "
+                       << pool()->name() << " failed: " << e.what();
+            // The exception is captured and thrown by the caller.
+            return std::make_unique<SpillResult>(std::current_exception());
+          }
+        }));
+    if ((spillTasks.size() > 1) && (spillExecutor != nullptr)) {
+      spillExecutor->add([source = spillTasks.back()]() { source->prepare(); });
+    }
+  }
+
+  auto syncGuard = folly::makeGuard([&]() {
+    for (auto& spillTask : spillTasks) {
+      // We consume the result for the pending tasks. This is a cleanup in the
+      // guard and must not throw. The first error is already captured before
+      // this runs.
+      try {
+        spillTask->move();
+      } catch (const std::exception&) {
+      }
+    }
+  });
+
+  SpillPartitionSet spillPartitions;
+  for (auto& spillTask : spillTasks) {
+    const auto result = spillTask->move();
+    if (result->error) {
+      std::rethrow_exception(result->error);
+    }
+    result->spiller->finishSpill(spillPartitions);
+  }
+
+  // Remove the spilled partitions which are empty so as we don't need to
+  // trigger unnecessary spilling at hash probe side.
+  removeEmptyPartitions(spillPartitions);
+  return spillPartitions;
+}
+
+std::unique_ptr<Spiller> HashProbe::spillTable(RowContainer* subTableRows) {
+  VELOX_CHECK_NOT_NULL(tableSpillType_);
+
+  auto tableSpiller = std::make_unique<Spiller>(
+      Spiller::Type::kHashJoinBuild,
+      joinType_,
+      subTableRows,
+      tableSpillType_,
+      std::move(tableSpillHashBits_),
+      spillConfig(),
+      &spillStats_);
+  tableSpiller->spill();
+  return tableSpiller;
+}
+
+void HashProbe::prepareTableSpill(
+    const std::optional<SpillPartitionId>& restoredPartitionId) {
+  if (!spillEnabled()) {
+    return;
+  }
+
+  const auto* config = spillConfig();
+  uint8_t startPartitionBit = config->startPartitionBit;
+  if (restoredPartitionId.has_value()) {
+    startPartitionBit =
+        restoredPartitionId->partitionBitOffset() + config->numPartitionBits;
+    // Disable spilling if exceeding the max spill level and the query might
+    // run out of memory if the restored partition still can't fit in memory.
+    if (config->exceedSpillLevelLimit(startPartitionBit)) {
+      RECORD_METRIC_VALUE(kMetricMaxSpillLevelExceededCount);
+      FB_LOG_EVERY_MS(WARNING, 1'000)
+          << "Exceeded spill level limit: " << config->maxSpillLevel
+          << ", and disable spilling for memory pool: " << pool()->name();
+      exceededMaxSpillLevelLimit_ = true;
+      ++spillStats_.wlock()->spillMaxLevelExceededCount;
+      return;
+    }
+  }
+  exceededMaxSpillLevelLimit_ = false;
+
+  tableSpillHashBits_ = HashBitRange(
+      startPartitionBit, startPartitionBit + config->numPartitionBits);
+
+  // NOTE: we only need to init 'tableSpillType_' once.
+  if (tableSpillType_ != nullptr) {
+    return;
+  }
+
+  const auto& tableInputType = joinNode_->sources()[1]->outputType();
+  std::vector<std::string> names;
+  names.reserve(tableInputType->size());
+  std::vector<TypePtr> types;
+  types.reserve(tableInputType->size());
+  const auto numKeys = joinNode_->rightKeys().size();
+
+  // Identify the non-key build side columns.
+  folly::F14FastMap<column_index_t, column_index_t> keyChannelMap;
+  for (int i = 0; i < numKeys; ++i) {
+    const auto& key = joinNode_->rightKeys()[i];
+    const auto channel = exprToChannel(key.get(), tableInputType);
+    keyChannelMap[channel] = i;
+    names.emplace_back(tableInputType->nameOf(channel));
+    types.emplace_back(tableInputType->childAt(channel));
+  }
+  const auto numDependents = tableInputType->size() - numKeys;
+  for (auto i = 0; i < tableInputType->size(); ++i) {
+    if (keyChannelMap.find(i) == keyChannelMap.end()) {
+      names.emplace_back(tableInputType->nameOf(i));
+      types.emplace_back(tableInputType->childAt(i));
+    }
+  }
+  tableSpillType_ = hashJoinTableSpillType(
+      ROW(std::move(names), std::move(types)), joinType_);
+}
+
+void HashProbe::close() {
+  Operator::close();
 
   // Free up major memory usage.
   joinBridge_.reset();
-  spiller_.reset();
+  inputSpiller_.reset();
   table_.reset();
+  spillInputReader_.reset();
+  spillOutputPartitionSet_.clear();
+  spillOutputReader_.reset();
+  clearBuffers();
+}
+
+void HashProbe::clearBuffers() {
   outputRowMapping_.reset();
+  tempOutputRowMapping_.reset();
+  outputTableRows_.reset();
+  tempOutputTableRows_.reset();
   output_.reset();
   nonSpillInputIndicesBuffer_.reset();
   spillInputIndicesBuffers_.clear();
diff --git a/velox/exec/HashProbe.h b/velox/exec/HashProbe.h
index 7beadfb8a1e59..5c8dab9b8b3a9 100644
--- a/velox/exec/HashProbe.h
+++ b/velox/exec/HashProbe.h
@@ -44,9 +44,9 @@ class HashProbe : public Operator {
     }
     // NOTE: if we can't apply dynamic filtering, then we can start early to
     // read input even before the hash table has been built.
-    auto channels = operatorCtx_->driverCtx()->driver->canPushdownFilters(
-        this, keyChannels_);
-    return channels.empty();
+    return operatorCtx_->driverCtx()
+        ->driver->canPushdownFilters(this, keyChannels_)
+        .empty();
   }
 
   void addInput(RowVectorPtr input) override;
@@ -59,18 +59,27 @@ class HashProbe : public Operator {
 
   bool isFinished() override;
 
-  /// NOTE: we can't reclaim memory from a hash probe operator. The disk
-  /// spilling in hash probe is used to coordinate with the disk spilling
-  /// triggered by the hash build operator.
-  bool canReclaim() const override {
-    return false;
-  }
+  void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
+      override;
 
-  void abort() override;
+  void close() override;
 
   void clearDynamicFilters() override;
 
+  bool canReclaim() const override;
+
+  bool testingHasInputSpiller() const {
+    return inputSpiller_ != nullptr;
+  }
+
  private:
+  // Indicates if the join type includes misses from the left side in the
+  // output.
+  static bool joinIncludesMissesFromLeft(core::JoinType joinType) {
+    return isLeftJoin(joinType) || isFullJoin(joinType) ||
+        isAntiJoin(joinType) || isLeftSemiProjectJoin(joinType);
+  }
+
   void setState(ProbeOperatorState state);
   void checkStateTransition(ProbeOperatorState state);
 
@@ -79,25 +88,24 @@ class HashProbe : public Operator {
   bool isRunning() const;
 
   // Invoked to wait for the hash table to be built by the hash build operators
-  // asynchronously.
+  // asynchronously. The function also sets up the internal state for
+  // potentially spilling input or reading spilled input or recursively spill
+  // the hash table.
   void asyncWaitForHashTable();
 
-  // Invoked to set up spilling related input processing. The function sets up a
-  // reader to read probe inputs from spilled data on disk if
-  // 'restoredSpillPartitionId' is not null. If 'spillPartitionIds' is not
-  // empty, then spilling has been triggered at the build side and the function
-  // will set up a spiller and the associated data structures to spill probe
-  // inputs.
-  void maybeSetupSpillInput(
-      const std::optional<SpillPartitionId>& restoredSpillPartitionId,
-      const SpillPartitionIdSet& spillPartitionIds);
-
-  // Sets up 'filter_' and related members.p
+  // Sets up 'filter_' and related members.
   void initializeFilter(
       const core::TypedExprPtr& filter,
       const RowTypePtr& probeType,
       const RowTypePtr& tableType);
 
+  // Setup 'resultIter_'.
+  void initializeResultIter();
+
+  // If 'toSpillOutput', the produced output is spilled to disk for memory
+  // arbitration.
+  RowVectorPtr getOutputInternal(bool toSpillOutput);
+
   // Check if output_ can be re-used and if not make a new one.
   void prepareOutput(vector_size_t size);
 
@@ -130,14 +138,17 @@ class HashProbe : public Operator {
         decodedFilterResult_.valueAt<bool>(row);
   }
 
-  // Populate filter input columns.
-  void fillFilterInput(vector_size_t size);
+  // Create a temporary input vector to be passed to the filter. This ensures it
+  // gets destroyed in case its wrapping an unloaded vector which eventually
+  // needs to be wrapped in fillOutput().
+  RowVectorPtr createFilterInput(vector_size_t size);
 
   // Prepare filter row selectivity for null-aware join. 'numRows'
   // specifies the number of rows in 'filterInputRows_' to process. If
   // 'filterPropagateNulls' is true, the probe input row which has null in any
   // probe filter column can't pass the filter.
   void prepareFilterRowsForNullAwareJoin(
+      RowVectorPtr& filterInput,
       vector_size_t numRows,
       bool filterPropagateNulls);
 
@@ -157,6 +168,8 @@ class HashProbe : public Operator {
 
   void ensureLoadedIfNotAtEnd(column_index_t channel);
 
+  void ensureLoaded(column_index_t channel);
+
   // Indicates if the operator has more probe inputs from either the upstream
   // operator or the spill input reader.
   bool hasMoreInput() const;
@@ -174,6 +187,21 @@ class HashProbe : public Operator {
   // partitions have been spilled at the build side.
   bool skipProbeOnEmptyBuild() const;
 
+  // If 'spillPartitionIds' is not empty, then spilling has been triggered at
+  // the build side and the function will set up 'inputSpiller_' to spill probe
+  // inputs.
+  void maybeSetupInputSpiller(const SpillPartitionIdSet& spillPartitionIds);
+
+  // If 'restoredSpillPartitionId' is set, then setup 'spillInputReader_' to
+  // read probe inputs from spilled data on disk.
+  void maybeSetupSpillInputReader(
+      const std::optional<SpillPartitionId>& restoredSpillPartitionId);
+
+  // Prepares the table spill by checking the spill level limit, setting spill
+  // partition bits and table spill type.
+  void prepareTableSpill(
+      const std::optional<SpillPartitionId>& restoredPartitionId);
+
   bool spillEnabled() const;
 
   // Indicates if the probe input is read from spilled data or not.
@@ -188,6 +216,22 @@ class HashProbe : public Operator {
   // to spill the corresponding probe-side rows as well.
   bool needSpillInput() const;
 
+  // This ensures there is sufficient buffer reserved to produce the next output
+  // batch. This might trigger memory arbitration underneath and the probe
+  // operator is set to reclaimable at this stage.
+  void ensureOutputFits();
+
+  // Setups spilled output reader if 'spillOutputPartitionSet_' is not empty.
+  void maybeSetupSpillOutputReader();
+
+  // Reads from the spilled output if the spilling has been triggered during the
+  // middle of an input processing. The latter produces all the outputs and
+  // spill them on to disk in case the output is too large to fit in memory in
+  // some edge case, like one input row has many matches with the build side.
+  // The function returns true if it has read the spilled output and saves in
+  // 'output_'.
+  bool maybeReadSpillOutput();
+
   // Invoked after finishes processing the probe inputs and there is spill data
   // remaining to restore. The function will reset the internal states which
   // are relevant to the last finished probe run. The last finished probe
@@ -198,6 +242,20 @@ class HashProbe : public Operator {
   // Invoked to read next batch of spilled probe inputs from disk to process.
   void addSpillInput();
 
+  // Produces and spills outputs from operator which has pending input to
+  // process in probe 'operators'.
+  void spillOutput(const std::vector<HashProbe*>& operators);
+  // Produces and spills output from this probe operator.
+  void spillOutput();
+
+  // Spills the composed 'table_' from the built side.
+  SpillPartitionSet spillTable();
+  // Spills the row container from one of the sub-table from 'table_' to
+  // parallelize the table spilling. The function spills all the rows from the
+  // row container and returns the spiller for the caller to collect the spilled
+  // partitions and stats.
+  std::unique_ptr<Spiller> spillTable(RowContainer* subTableRows);
+
   // Invoked to spill rows in 'input' to disk directly if the corresponding
   // partitions have been spilled at the build side.
   //
@@ -220,7 +278,9 @@ class HashProbe : public Operator {
   // next hash table from the spilled data.
   void noMoreInputInternal();
 
-  void recordSpillStats();
+  // Indicates if this hash probe operator is under non-reclaimable state or
+  // not.
+  bool nonReclaimableState() const;
 
   // Returns the index of the 'match' column in the output for semi project
   // joins.
@@ -240,8 +300,18 @@ class HashProbe : public Operator {
         spillInputPartitionIds_.empty();
   }
 
+  // Find the peer hash probe operators in the same pipeline.
+  std::vector<HashProbe*> findPeerOperators();
+
+  // Wake up the peer hash probe operators when last probe operator finishes.
+  void wakeupPeerOperators();
+
+  // Invoked to release internal buffers to free up memory resources after
+  // memory reclamation or operator close.
+  void clearBuffers();
+
   // TODO: Define batch size as bytes based on RowContainer row sizes.
-  const uint32_t outputBatchSize_;
+  const vector_size_t outputBatchSize_;
 
   const std::shared_ptr<const core::HashJoinNode> joinNode_;
 
@@ -285,6 +355,12 @@ class HashProbe : public Operator {
   // Channel of probe keys in 'input_'.
   std::vector<column_index_t> keyChannels_;
 
+  // True if we have generated dynamic filters from the hash build join keys.
+  //
+  // NOTE: 'dynamicFilters_' might have been cleared once they have been pushed
+  // down to the upstream operators.
+  tsan_atomic<bool> hasGeneratedDynamicFilters_{false};
+
   // True if the join can become a no-op starting with the next batch of input.
   bool canReplaceWithDynamicFilter_{false};
 
@@ -293,8 +369,8 @@ class HashProbe : public Operator {
 
   std::vector<std::unique_ptr<VectorHasher>> hashers_;
 
-  // Table shared between other HashProbes in other Drivers of the
-  // same pipeline.
+  // Table shared between other HashProbes in other Drivers of the same
+  // pipeline.
   std::shared_ptr<BaseHashTable> table_;
 
   // Indicates whether there was no input. Used for right semi join project.
@@ -316,9 +392,7 @@ class HashProbe : public Operator {
   // side. Used by right semi project join.
   bool probeSideHasNullKeys_{false};
 
-  VectorHasher::ScratchMemory scratchMemory_;
-
-  // Rows in 'filterInput_' to apply 'filter_' to.
+  // Rows in the filter columns to apply 'filter_' to.
   SelectivityVector filterInputRows_;
 
   // Join filter.
@@ -330,17 +404,15 @@ class HashProbe : public Operator {
   // Type of the RowVector for filter inputs.
   RowTypePtr filterInputType_;
 
+  // The input channels that are projected to the output.
+  std::unordered_set<column_index_t> projectedInputColumns_;
+
   // Maps input channels to channels in 'filterInputType_'.
   std::vector<IdentityProjection> filterInputProjections_;
 
   // Maps from column index in hash table to channel in 'filterInputType_'.
   std::vector<IdentityProjection> filterTableProjections_;
 
-  // Temporary projection from probe and build for evaluating
-  // 'filter_'. This can always be reused since this does not escape
-  // this operator.
-  RowVectorPtr filterInput_;
-
   // The following six fields are used in null-aware anti join filter
   // processing.
 
@@ -363,11 +435,20 @@ class HashProbe : public Operator {
   // Row number in 'input_' for each output row.
   BufferPtr outputRowMapping_;
 
+  // For left join with filter, we could overwrite the row which we have not
+  // checked if there is a carryover.  Use a temporary buffer in this case.
+  BufferPtr tempOutputRowMapping_;
+
   // maps from column index in 'table_' to channel in 'output_'.
   std::vector<IdentityProjection> tableOutputProjections_;
 
   // Rows of table found by join probe, later filtered by 'filter_'.
-  std::vector<char*> outputTableRows_;
+  BufferPtr outputTableRows_;
+  vector_size_t outputTableRowsCapacity_;
+
+  // For left join with filter, we could overwrite the row which we have not
+  // checked if there is a carryover.  Use a temporary buffer in this case.
+  BufferPtr tempOutputTableRows_;
 
   // Indicates probe-side rows which should produce a NULL in left semi project
   // with filter.
@@ -380,90 +461,40 @@ class HashProbe : public Operator {
     // Called for each row that the filter was evaluated on. Expects that probe
     // side rows with multiple matches on the build side are next to each other.
     template <typename TOnMiss>
-    void advance(vector_size_t row, bool passed, TOnMiss onMiss) {
-      if (currentRow != row) {
-        // Check if 'currentRow' is the same input row as the last missed row
-        // from a previous output batch.  If so finishIteration will call
-        // onMiss.
-        if (currentRow != -1 && !currentRowPassed &&
-            (!lastMissedRow || currentRow != lastMissedRow)) {
-          onMiss(currentRow);
+    void advance(vector_size_t row, bool passed, TOnMiss&& onMiss) {
+      if (currentRow_ != row) {
+        if (hasLastMissedRow()) {
+          onMiss(currentRow_);
         }
-        currentRow = row;
-        currentRowPassed = false;
+        currentRow_ = row;
+        currentRowPassed_ = false;
       }
-
       if (passed) {
-        // lastMissedRow can only be a row that has never passed the filter.  If
-        // it passes there's no need to continue carrying it forward.
-        if (lastMissedRow && currentRow == lastMissedRow) {
-          lastMissedRow.reset();
-        }
-
-        currentRowPassed = true;
+        currentRowPassed_ = true;
       }
     }
 
-    // Invoked at the end of one output batch processing. 'end' is set to true
-    // at the end of processing an input batch. 'freeOutputRows' is the number
-    // of rows that can still be written to the output batch.
+    // Invoked at the end of all output batches.
     template <typename TOnMiss>
-    void
-    finishIteration(TOnMiss onMiss, bool endOfData, size_t freeOutputRows) {
-      if (endOfData) {
-        if (!currentRowPassed && currentRow != -1) {
-          // If we're at the end of the input batch and the current row hasn't
-          // passed the filter, it never will, process it as a miss.
-          // We're guaranteed to have space, at least the last row was never
-          // written out since it was a miss.
-          VELOX_CHECK_GE(freeOutputRows, 0);
-          onMiss(currentRow);
-          freeOutputRows--;
-        }
-
-        // We no longer need to carry the current row since we already called
-        // onMiss on it.
-        if (lastMissedRow && currentRow == lastMissedRow) {
-          lastMissedRow.reset();
-        }
-
-        currentRow = -1;
-        currentRowPassed = false;
-      }
-
-      // If there's space left in the output batch, write out the last missed
-      // row.
-      if (lastMissedRow && currentRow != lastMissedRow && freeOutputRows > 0) {
-        onMiss(*lastMissedRow);
-        lastMissedRow.reset();
-      }
-
-      // If the current row hasn't passed the filter, we need to carry it
-      // forward in case it never passes the filter.
-      if (!currentRowPassed && currentRow != -1) {
-        lastMissedRow = currentRow;
+    void finish(TOnMiss&& onMiss) {
+      if (hasLastMissedRow()) {
+        onMiss(currentRow_);
       }
+      currentRow_ = -1;
     }
 
     // Returns if we're carrying forward a missed input row. Notably, if this is
     // true, we're not yet done processing the input batch.
-    bool hasLastMissedRow() {
-      return lastMissedRow.has_value();
+    bool hasLastMissedRow() const {
+      return currentRow_ != -1 && !currentRowPassed_;
     }
 
    private:
     // Row number being processed.
-    vector_size_t currentRow{-1};
+    vector_size_t currentRow_{-1};
 
-    // True if currentRow has a match.
-    bool currentRowPassed{false};
-
-    // If set, it points to the last missed (input) row carried over from
-    // previous output batch processing. The last missed row is either written
-    // as a passed row if the same input row has a hit in the next output batch
-    // processed or written to the first output batch which has space at
-    // the end if it never has a hit.
-    std::optional<vector_size_t> lastMissedRow;
+    // True if currentRow_ has a match.
+    bool currentRowPassed_{false};
   };
 
   // For left semi join filter with extra filter, de-duplicates probe side rows
@@ -548,21 +579,21 @@ class HashProbe : public Operator {
 
   BaseHashTable::RowsIterator lastProbeIterator_;
 
-  /// For left and anti join with filter, tracks the probe side rows which had
-  /// matches on the build side but didn't pass the filter.
+  // For left and anti join with filter, tracks the probe side rows which had
+  // matches on the build side but didn't pass the filter.
   NoMatchDetector noMatchDetector_;
 
-  /// For left semi join filter with extra filter, de-duplicates probe side rows
-  /// with multiple matches.
+  // For left semi join filter with extra filter, de-duplicates probe side rows
+  // with multiple matches.
   LeftSemiFilterJoinTracker leftSemiFilterJoinTracker_;
 
-  /// For left semi join project with filter, de-duplicates probe side rows with
-  /// multiple matches.
+  // For left semi join project with filter, de-duplicates probe side rows with
+  // multiple matches.
   LeftSemiProjectJoinTracker leftSemiProjectJoinTracker_;
 
   // Keeps track of returned results between successive batches of
   // output for a batch of input.
-  BaseHashTable::JoinResultIterator results_;
+  std::unique_ptr<BaseHashTable::JoinResultIterator> resultIter_;
 
   RowVectorPtr output_;
 
@@ -574,7 +605,7 @@ class HashProbe : public Operator {
   SelectivityVector activeRows_;
 
   // True if passingInputRows is up to date.
-  bool passingInputRowsInitialized_;
+  bool passingInputRowsInitialized_ = false;
 
   // Set of input rows for which there is at least one join hit. All
   // set if right side optional. Used when loading lazy vectors for
@@ -582,10 +613,28 @@ class HashProbe : public Operator {
   // input.
   SelectivityVector passingInputRows_;
 
-  // 'spiller_' is only created if some part of build-side rows have been
+  // Indicates if this hash probe has exceeded max spill limit which is not
+  // allowed to spill. This is reset when hash probe operator starts to probe
+  // the next previously spilled hash table partition.
+  bool exceededMaxSpillLevelLimit_{false};
+
+  // The partition bits used to spill the hash table.
+  HashBitRange tableSpillHashBits_;
+  // The row type used to spill hash table on disk.
+  RowTypePtr tableSpillType_;
+
+  // The spilled output partition set which is cleared after setup
+  // 'spillOutputReader_'.
+  SpillPartitionSet spillOutputPartitionSet_;
+
+  // The reader used to read the spilled output produced by pending input during
+  // the spill processing.
+  std::unique_ptr<UnorderedStreamReader<BatchStream>> spillOutputReader_;
+
+  // 'inputSpiller_' is created if some part of build-side rows have been
   // spilled. It is used to spill probe-side rows if the corresponding
   // build-side rows have been spilled.
-  std::unique_ptr<Spiller> spiller_;
+  std::unique_ptr<Spiller> inputSpiller_;
 
   // If not empty, the probe inputs with partition id set in
   // 'spillInputPartitionIds_' needs to spill. It is set along with 'spiller_'
diff --git a/velox/exec/HashTable.cpp b/velox/exec/HashTable.cpp
index 07e91e263bcc7..6abede7ccafcf 100644
--- a/velox/exec/HashTable.cpp
+++ b/velox/exec/HashTable.cpp
@@ -16,9 +16,11 @@
 
 #include "velox/exec/HashTable.h"
 #include "velox/common/base/AsyncSource.h"
+#include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Portability.h"
 #include "velox/common/base/SimdUtil.h"
 #include "velox/common/process/ProcessBase.h"
+#include "velox/common/process/TraceContext.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/vector/VectorTypeUtils.h"
@@ -100,7 +102,7 @@ class ProbeState {
   inline void preProbe(const Table& table, uint64_t hash, int32_t row) {
     row_ = row;
     bucketOffset_ = table.bucketOffset(hash);
-    auto tag = BaseHashTable::hashTag(hash);
+    const auto tag = BaseHashTable::hashTag(hash);
     wantedTags_ = BaseHashTable::TagVector::broadcast(tag);
     group_ = nullptr;
     indexInTags_ = kNotSet;
@@ -123,14 +125,16 @@ class ProbeState {
   }
 
   template <Operation op, typename Compare, typename Insert, typename Table>
-  inline char* FOLLY_NULLABLE fullProbe(
+  inline char* fullProbe(
       Table& table,
       int32_t firstKey,
       Compare compare,
       Insert insert,
       int64_t& numTombstones,
       bool extraCheck,
-      int64_t partitionEnd = -1) {
+      TableInsertPartitionInfo* partitionInfo = nullptr) {
+    VELOX_DCHECK(partitionInfo == nullptr || op == Operation::kInsert);
+
     if (group_ && compare(group_, row_)) {
       if (op == Operation::kErase) {
         eraseHit(table, numTombstones);
@@ -139,25 +143,37 @@ class ProbeState {
       return group_;
     }
 
-    auto alreadyChecked = group_;
+    auto* alreadyChecked = group_;
     if (extraCheck) {
       tagsInTable_ = table.loadTags(bucketOffset_);
       hits_ = simd::toBitMask(tagsInTable_ == wantedTags_);
     }
 
+    const int64_t startBucketOffset = bucketOffset_;
     int64_t insertBucketOffset = -1;
     const auto kEmptyGroup = BaseHashTable::TagVector::broadcast(0);
     const auto kTombstoneGroup =
         BaseHashTable::TagVector::broadcast(kTombstoneTag);
-    for (;;) {
+    for (int64_t numProbedBuckets = 0; numProbedBuckets < table.numBuckets();
+         ++numProbedBuckets) {
       if constexpr (op == Operation::kInsert) {
-        if (partitionEnd >= 0 && bucketOffset_ >= partitionEnd) {
-          // We have already gone over the partition boundary.  Call insert to
-          // put row in overflows.
-          return insert(row_, bucketOffset_);
+        if (partitionInfo != nullptr) {
+          if (FOLLY_UNLIKELY(!partitionInfo->inRange(bucketOffset_))) {
+            // If we have passed the partition boundary, then call insert to put
+            // row in overflows.
+            return insert(row_, bucketOffset_);
+          }
+          if (FOLLY_UNLIKELY(
+                  (bucketOffset_ <= startBucketOffset) &&
+                  (numProbedBuckets > 0))) {
+            // If this is the last bucket and wrap around, then call insert to
+            // put row in overflows.
+            return insert(row_, partitionInfo->end);
+          }
         }
       }
-      while (hits_) {
+
+      while (hits_ > 0) {
         loadNextHit<op>(table, firstKey);
         if (!(extraCheck && group_ == alreadyChecked) &&
             compare(group_, row_)) {
@@ -178,12 +194,11 @@ class ProbeState {
           VELOX_FAIL("Erasing non-existing entry");
         }
         if (indexInTags_ != kNotSet) {
-          // We came to the end of the probe without a hit. We replace the
-          // first tombstone on the way.
+          // We came to the end of the probe without a hit. We replace the first
+          // tombstone on the way.
           --numTombstones;
           return insert(row_, insertBucketOffset + indexInTags_);
         }
-        //--numTombstoneGroups;
         auto pos = bits::getAndClearLastSetBit(empty);
         return insert(row_, bucketOffset_ + pos);
       }
@@ -200,17 +215,22 @@ class ProbeState {
       tagsInTable_ = table.loadTags(bucketOffset_);
       hits_ = simd::toBitMask(tagsInTable_ == wantedTags_);
     }
+    // Throws here if we have looped through all the buckets in the table.
+    VELOX_FAIL(
+        "Have looped through all the buckets in table: {}", table.toString());
   }
 
   template <typename Table>
-  FOLLY_ALWAYS_INLINE char* FOLLY_NULLABLE
-  joinNormalizedKeyFullProbe(const Table& table, const uint64_t* keys) {
+  FOLLY_ALWAYS_INLINE char* joinNormalizedKeyFullProbe(
+      const Table& table,
+      const uint64_t* keys) {
     if (group_ && RowContainer::normalizedKey(group_) == keys[row_]) {
       table.incrementHits();
       return group_;
     }
     const auto kEmptyGroup = BaseHashTable::TagVector::broadcast(kEmptyTag);
-    for (;;) {
+    int64_t numProbedBuckets = 0;
+    while (numProbedBuckets < table.numBuckets()) {
       if (!hits_) {
         const uint16_t empty = simd::toBitMask(tagsInTable_ == kEmptyGroup);
         if (empty) {
@@ -226,10 +246,13 @@ class ProbeState {
         continue;
       }
       bucketOffset_ = table.nextBucketOffset(bucketOffset_);
+      ++numProbedBuckets;
       tagsInTable_ = BaseHashTable::loadTags(
           reinterpret_cast<uint8_t*>(table.table_), bucketOffset_);
       hits_ = simd::toBitMask(tagsInTable_ == wantedTags_) & kFullMask;
     }
+    // Throws here if we have looped through all the buckets in the table.
+    VELOX_FAIL("Have looped through all the buckets in table");
   }
 
  private:
@@ -237,7 +260,7 @@ class ProbeState {
 
   template <Operation op, typename Table>
   inline void loadNextHit(Table& table, int32_t firstKey) {
-    int32_t hit = bits::getAndClearLastSetBit(hits_);
+    const int32_t hit = bits::getAndClearLastSetBit(hits_);
 
     if (op == Operation::kErase) {
       indexInTags_ = hit;
@@ -288,7 +311,7 @@ void HashTable<ignoreNullKeys>::storeKeys(
 
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::storeRowPointer(
-    int32_t index,
+    uint64_t index,
     uint64_t hash,
     char* row) {
   if (hashMode_ == HashMode::kArray) {
@@ -305,7 +328,7 @@ void HashTable<ignoreNullKeys>::storeRowPointer(
 template <bool ignoreNullKeys>
 char* HashTable<ignoreNullKeys>::insertEntry(
     HashLookup& lookup,
-    int32_t index,
+    uint64_t index,
     vector_size_t row) {
   char* group = rows_->newRow();
   lookup.hits[row] = group; // NOLINT
@@ -372,8 +395,8 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::fullProbe(
           return RowContainer::normalizedKey(group) ==
               lookup.normalizedKeys[row];
         },
-        [&](int32_t index, int32_t row) {
-          return isJoin ? nullptr : insertEntry(lookup, row, index);
+        [&](int32_t row, uint64_t index) {
+          return isJoin ? nullptr : insertEntry(lookup, index, row);
         },
         numTombstones_,
         !isJoin && extraCheck);
@@ -384,14 +407,17 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::fullProbe(
       *this,
       0,
       [&](char* group, int32_t row) { return compareKeys(group, lookup, row); },
-      [&](int32_t index, int32_t row) {
-        return isJoin ? nullptr : insertEntry(lookup, row, index);
+      [&](int32_t row, uint64_t index) {
+        return isJoin ? nullptr : insertEntry(lookup, index, row);
       },
       numTombstones_,
       !isJoin && extraCheck);
 }
 
 namespace {
+// Group prefetch size for join build & probe.
+constexpr int32_t kPrefetchSize = 64;
+
 // Normalized keys have non0-random bits. Bits need to be propagated
 // up to make a tag byte and down so that non-lowest bits of
 // normalized key affect the hash table index.
@@ -423,7 +449,9 @@ void populateNormalizedKeys(HashLookup& lookup, int8_t sizeBits) {
 } // namespace
 
 template <bool ignoreNullKeys>
-void HashTable<ignoreNullKeys>::groupProbe(HashLookup& lookup) {
+void HashTable<ignoreNullKeys>::groupProbe(
+    HashLookup& lookup,
+    int8_t spillInputStartPartitionBit) {
   incrementProbes(lookup.rows.size());
 
   if (hashMode_ == HashMode::kArray) {
@@ -432,7 +460,7 @@ void HashTable<ignoreNullKeys>::groupProbe(HashLookup& lookup) {
   }
   // Do size-based rehash before mixing hashes from normalized keys
   // because the size of the table affects the mixing.
-  checkSize(lookup.rows.size(), false);
+  checkSize(lookup.rows.size(), false, spillInputStartPartitionBit);
   if (hashMode_ == HashMode::kNormalizedKey) {
     populateNormalizedKeys(lookup, sizeBits_);
     groupNormalizedKeyProbe(lookup);
@@ -556,8 +584,7 @@ void HashTable<ignoreNullKeys>::arrayGroupProbe(HashLookup& lookup) {
     if (UNLIKELY(!group)) {
       group = insertEntry(lookup, index, row);
     }
-    groups[row] = group;
-    lookup.hits[row] = group; // NOLINT
+    groups[row] = group; // NOLINT
   }
 }
 
@@ -653,22 +680,21 @@ void HashTable<ignoreNullKeys>::joinNormalizedKeyProbe(HashLookup& lookup) {
   int32_t probeIndex = 0;
   int32_t numProbes = lookup.rows.size();
   const vector_size_t* rows = lookup.rows.data();
-  constexpr int32_t groupSize = 64;
-  ProbeState states[groupSize];
+  ProbeState states[kPrefetchSize];
   const uint64_t* keys = lookup.normalizedKeys.data();
   const uint64_t* hashes = lookup.hashes.data();
   char** hits = lookup.hits.data();
   constexpr int32_t kKeyOffset =
       -static_cast<int32_t>(sizeof(normalized_key_t));
-  for (; probeIndex + groupSize <= numProbes; probeIndex += groupSize) {
-    for (int32_t i = 0; i < groupSize; ++i) {
+  for (; probeIndex + kPrefetchSize <= numProbes; probeIndex += kPrefetchSize) {
+    for (int32_t i = 0; i < kPrefetchSize; ++i) {
       int32_t row = rows[probeIndex + i];
       states[i].preProbe(*this, hashes[row], row);
     }
-    for (int32_t i = 0; i < groupSize; ++i) {
+    for (int32_t i = 0; i < kPrefetchSize; ++i) {
       states[i].firstProbe(*this, kKeyOffset);
     }
-    for (int32_t i = 0; i < groupSize; ++i) {
+    for (int32_t i = 0; i < kPrefetchSize; ++i) {
       hits[states[i].row()] = states[i].joinNormalizedKeyFullProbe(*this, keys);
     }
   }
@@ -681,13 +707,19 @@ void HashTable<ignoreNullKeys>::joinNormalizedKeyProbe(HashLookup& lookup) {
 }
 
 template <bool ignoreNullKeys>
-void HashTable<ignoreNullKeys>::allocateTables(uint64_t size) {
+void HashTable<ignoreNullKeys>::allocateTables(
+    uint64_t size,
+    int8_t spillInputStartPartitionBit) {
   VELOX_CHECK(bits::isPowerOfTwo(size), "Size is not a power of two: {}", size);
   VELOX_CHECK_GT(size, 0);
   capacity_ = size;
+  const uint64_t byteSize = capacity_ * tableSlotSize();
+  VELOX_CHECK_EQ(byteSize % kBucketSize, 0);
   numTombstones_ = 0;
-  sizeMask_ = (capacity_ * sizeof(void*)) - 1;
+  sizeMask_ = byteSize - 1;
+  numBuckets_ = byteSize / kBucketSize;
   sizeBits_ = __builtin_popcountll(sizeMask_);
+  checkHashBitsOverlap(spillInputStartPartitionBit);
   bucketOffsetMask_ = sizeMask_ & ~(kBucketSize - 1);
   // The total size is 8 bytes per slot, in groups of 16 slots with 16 bytes of
   // tags and 16 * 6 bytes of pointers and a padding of 16 bytes to round up the
@@ -700,11 +732,18 @@ void HashTable<ignoreNullKeys>::allocateTables(uint64_t size) {
 }
 
 template <bool ignoreNullKeys>
-void HashTable<ignoreNullKeys>::clear() {
-  rows_->clear();
+void HashTable<ignoreNullKeys>::clear(bool freeTable) {
+  for (auto* rowContainer : allRows()) {
+    rowContainer->clear();
+  }
   if (table_) {
-    // All modes have 8 bytes per slot.
-    memset(table_, 0, capacity_ * sizeof(char*));
+    if (!freeTable) {
+      // All modes have 8 bytes per slot.
+      ::memset(table_, 0, capacity_ * sizeof(char*));
+    } else {
+      rows_->pool()->freeContiguous(tableAllocation_);
+      table_ = nullptr;
+    }
   }
   numDistinct_ = 0;
   numTombstones_ = 0;
@@ -713,7 +752,8 @@ void HashTable<ignoreNullKeys>::clear() {
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::checkSize(
     int32_t numNew,
-    bool initNormalizedKeys) {
+    bool initNormalizedKeys,
+    int8_t spillInputStartPartitionBit) {
   // NOTE: the way we decide the table size and trigger rehash, guarantees the
   // table should always have free slots after the insertion.
   VELOX_CHECK(
@@ -727,9 +767,9 @@ void HashTable<ignoreNullKeys>::checkSize(
   const int64_t newNumDistincts = numNew + numDistinct_;
   if (table_ == nullptr || capacity_ == 0) {
     const auto newSize = newHashTableEntries(numDistinct_, numNew);
-    allocateTables(newSize);
+    allocateTables(newSize, spillInputStartPartitionBit);
     if (numDistinct_ > 0) {
-      rehash(initNormalizedKeys);
+      rehash(initNormalizedKeys, spillInputStartPartitionBit);
     }
     // We are not always able to reuse a tombstone slot as a free one for hash
     // collision handling purpose. For example, if all the table slots are
@@ -741,8 +781,8 @@ void HashTable<ignoreNullKeys>::checkSize(
     // NOTE: we need to plus one here as number itself could be power of two.
     const auto newCapacity = bits::nextPowerOfTwo(
         std::max(newNumDistincts, capacity_ - numTombstones_) + 1);
-    allocateTables(newCapacity);
-    rehash(initNormalizedKeys);
+    allocateTables(newCapacity, spillInputStartPartitionBit);
+    rehash(initNormalizedKeys, spillInputStartPartitionBit);
   }
 }
 
@@ -795,6 +835,7 @@ template <typename Source>
 void syncWorkItems(
     std::vector<std::shared_ptr<Source>>& items,
     std::exception_ptr& error,
+    CpuWallTiming time,
     bool log = false) {
   // All items must be synced also in case of error because the items
   // hold references to the table and rows which could be destructed
@@ -802,6 +843,7 @@ void syncWorkItems(
   for (auto& item : items) {
     try {
       item->move();
+      time.add(item->prepareTiming());
     } catch (const std::exception& e) {
       if (log) {
         LOG(ERROR) << "Error in async hash build: " << e.what();
@@ -829,10 +871,11 @@ bool HashTable<ignoreNullKeys>::canApplyParallelJoinBuild() const {
 
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::parallelJoinBuild() {
+  process::TraceContext trace("HashTable::parallelJoinBuild");
   TestValue::adjust(
       "facebook::velox::exec::HashTable::parallelJoinBuild", rows_->pool());
   VELOX_CHECK_LE(1 + otherTables_.size(), std::numeric_limits<uint8_t>::max());
-  uint8_t numPartitions = 1 + otherTables_.size();
+  const uint8_t numPartitions = 1 + otherTables_.size();
   VELOX_CHECK_GT(
       capacity_ / numPartitions,
       minTableSizeForParallelJoinBuild_,
@@ -867,8 +910,8 @@ void HashTable<ignoreNullKeys>::parallelJoinBuild() {
     // This is executed on returning path, possibly in unwinding, so must not
     // throw.
     std::exception_ptr error;
-    syncWorkItems(partitionSteps, error, true);
-    syncWorkItems(buildSteps, error, true);
+    syncWorkItems(partitionSteps, error, offThreadBuildTiming_, true);
+    syncWorkItems(buildSteps, error, offThreadBuildTiming_, true);
   });
 
   const auto getTable = [this](size_t i) INLINE_LAMBDA {
@@ -892,16 +935,23 @@ void HashTable<ignoreNullKeys>::parallelJoinBuild() {
           partitionRows(*table, *rawRowPartitions);
           return std::make_unique<bool>(true);
         }));
-    assert(!partitionSteps.empty()); // lint
+    VELOX_CHECK(!partitionSteps.empty());
     buildExecutor_->add([step = partitionSteps.back()]() { step->prepare(); });
   }
+
   std::exception_ptr error;
-  syncWorkItems(partitionSteps, error);
-  if (error) {
+  syncWorkItems(partitionSteps, error, offThreadBuildTiming_);
+  if (error != nullptr) {
     std::rethrow_exception(error);
   }
 
   // The parallel table building step.
+  VELOX_CHECK(joinInsertAllocators_.empty());
+  joinInsertAllocators_.reserve(otherTables_.size());
+  for (int i = 0; i < otherTables_.size(); ++i) {
+    joinInsertAllocators_.push_back(
+        std::make_unique<HashStringAllocator>(rows_->pool()));
+  }
   std::vector<std::vector<char*>> overflowPerPartition(numPartitions);
   for (auto i = 0; i < numPartitions; ++i) {
     buildSteps.push_back(std::make_shared<AsyncSource<bool>>(
@@ -912,8 +962,9 @@ void HashTable<ignoreNullKeys>::parallelJoinBuild() {
     VELOX_CHECK(!buildSteps.empty());
     buildExecutor_->add([step = buildSteps.back()]() { step->prepare(); });
   }
-  syncWorkItems(buildSteps, error);
-  if (error) {
+  syncWorkItems(buildSteps, error, offThreadBuildTiming_);
+
+  if (error != nullptr) {
     std::rethrow_exception(error);
   }
 
@@ -925,14 +976,15 @@ void HashTable<ignoreNullKeys>::parallelJoinBuild() {
         folly::Range<char**>(overflows.data(), overflows.size()),
         false,
         hashes);
+    auto table = i == 0 ? this : otherTables_[i - 1].get();
     insertForJoin(
+        table->rows(),
         overflows.data(),
         hashes.data(),
         overflows.size(),
-        0,
-        sizeMask_ + 1,
-        nullptr);
-    auto table = i == 0 ? this : otherTables_[i - 1].get();
+        nullptr,
+        &rows_->stringAllocator());
+
     VELOX_CHECK_EQ(table->rows()->numRows(), table->numParallelBuildRows_);
   }
 }
@@ -994,20 +1046,29 @@ void HashTable<ignoreNullKeys>::buildJoinPartition(
   constexpr int32_t kBatch = 1024;
   raw_vector<char*> rows(kBatch);
   raw_vector<uint64_t> hashes(kBatch);
-  int32_t numPartitions = 1 + otherTables_.size();
+  const int32_t numPartitions = 1 + otherTables_.size();
+  TableInsertPartitionInfo partitionInfo{
+      buildPartitionBounds_[partition],
+      buildPartitionBounds_[partition + 1],
+      overflow};
+  const int partitionNum = partition;
+  auto* allocator = (partitionNum == 0)
+      ? &rows_->stringAllocator()
+      : joinInsertAllocators_[partitionNum - 1].get();
+  VELOX_CHECK_NOT_NULL(allocator);
   for (auto i = 0; i < numPartitions; ++i) {
-    auto table = i == 0 ? this : otherTables_[i - 1].get();
+    auto* table = i == 0 ? this : otherTables_[i - 1].get();
     RowContainerIterator iter;
-    while (auto numRows = table->rows_->listPartitionRows(
+    while (const auto numRows = table->rows_->listPartitionRows(
                iter, partition, kBatch, *rowPartitions[i], rows.data())) {
       hashRows(folly::Range(rows.data(), numRows), false, hashes);
       insertForJoin(
+          table->rows_.get(),
           rows.data(),
           hashes.data(),
           numRows,
-          buildPartitionBounds_[partition],
-          buildPartitionBounds_[partition + 1],
-          &overflow);
+          &partitionInfo,
+          allocator);
       table->numParallelBuildRows_ += numRows;
     }
   }
@@ -1023,7 +1084,13 @@ bool HashTable<ignoreNullKeys>::insertBatch(
     return false;
   }
   if (isJoinBuild_) {
-    insertForJoin(groups, hashes.data(), numGroups);
+    insertForJoin(
+        rows(),
+        groups,
+        hashes.data(),
+        numGroups,
+        nullptr,
+        &rows_->stringAllocator());
   } else {
     insertForGroupBy(groups, hashes.data(), numGroups);
   }
@@ -1056,7 +1123,9 @@ void HashTable<ignoreNullKeys>::insertForGroupBy(
             reinterpret_cast<char*>(table_) +
             bucketOffset(hashes[i + kPrefetchDistance]));
       }
-      for (;;) {
+      bool inserted{false};
+      for (int64_t numProbedBuckets = 0; numProbedBuckets < numBuckets();
+           ++numProbedBuckets) {
         MaskType free =
             ~simd::toBitMask(
                 BaseHashTable::TagVector::batch_bool_type(tagsInTable)) &
@@ -1064,68 +1133,80 @@ void HashTable<ignoreNullKeys>::insertForGroupBy(
         if (free) {
           auto freeOffset = bits::getAndClearLastSetBit(free);
           storeRowPointer(offset + freeOffset, hash, groups[i]);
+          inserted = true;
           break;
         }
         offset = nextBucketOffset(offset);
         tagsInTable =
             BaseHashTable::loadTags(reinterpret_cast<uint8_t*>(table_), offset);
       }
+      // Throws here if we have looped through all the buckets in the table.
+      VELOX_CHECK(
+          inserted,
+          "Have looped through all the buckets in table: {}",
+          toString());
     }
   }
 }
 
 template <bool ignoreNullKeys>
-bool HashTable<ignoreNullKeys>::arrayPushRow(char* row, int32_t index) {
-  auto existing = table_[index];
-  if (nextOffset_) {
-    nextRow(row) = existing;
-    if (existing) {
+bool HashTable<ignoreNullKeys>::arrayPushRow(
+    RowContainer* rows,
+    char* row,
+    int32_t index,
+    HashStringAllocator* allocator) {
+  auto* existingRow = table_[index];
+  if (existingRow != nullptr) {
+    if (nextOffset_ > 0) {
       hasDuplicates_ = true;
+      rows->appendNextRow(existingRow, row, allocator);
     }
-  } else if (existing) {
-    // Semijoin or a known unique build side ignores a repeat of a key.
     return false;
   }
   table_[index] = row;
-  return !existing;
+  return existingRow == nullptr;
 }
 
 template <bool ignoreNullKeys>
-void HashTable<ignoreNullKeys>::pushNext(char* row, char* next) {
-  if (nextOffset_) {
-    hasDuplicates_ = true;
-    auto previousNext = nextRow(row);
-    nextRow(row) = next;
-    nextRow(next) = previousNext;
-  }
+void HashTable<ignoreNullKeys>::pushNext(
+    RowContainer* rows,
+    char* row,
+    char* next,
+    HashStringAllocator* allocator) {
+  VELOX_CHECK_GT(nextOffset_, 0);
+  hasDuplicates_ = true;
+  rows->appendNextRow(row, next, allocator);
 }
 
 template <bool ignoreNullKeys>
+template <bool isNormailizedKeyMode>
 FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::buildFullProbe(
+    RowContainer* rows,
     ProbeState& state,
     uint64_t hash,
     char* inserted,
     bool extraCheck,
-    PartitionBoundIndexType partitionBegin,
-    PartitionBoundIndexType partitionEnd,
-    std::vector<char*>* overflows) {
+    TableInsertPartitionInfo* partitionInfo,
+    HashStringAllocator* allocator) {
+  constexpr int32_t kKeyOffset =
+      -static_cast<int32_t>(sizeof(normalized_key_t));
   auto insertFn = [&](int32_t /*row*/, PartitionBoundIndexType index) {
-    if (index < partitionBegin || index >= partitionEnd) {
-      overflows->push_back(inserted);
+    if (partitionInfo != nullptr && !partitionInfo->inRange(index)) {
+      partitionInfo->addOverflow(inserted);
       return nullptr;
     }
     storeRowPointer(index, hash, inserted);
     return nullptr;
   };
-  if (hashMode_ == HashMode::kNormalizedKey) {
+  if constexpr (isNormailizedKeyMode) {
     state.fullProbe<ProbeState::Operation::kInsert>(
         *this,
-        -static_cast<int32_t>(sizeof(normalized_key_t)),
+        kKeyOffset,
         [&](char* group, int32_t /*row*/) {
           if (RowContainer::normalizedKey(group) ==
               RowContainer::normalizedKey(inserted)) {
-            if (nextOffset_) {
-              pushNext(group, inserted);
+            if (nextOffset_ > 0) {
+              pushNext(rows, group, inserted, allocator);
             }
             return true;
           }
@@ -1134,15 +1215,15 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::buildFullProbe(
         insertFn,
         numTombstones_,
         extraCheck,
-        partitionEnd);
+        partitionInfo);
   } else {
     state.fullProbe<ProbeState::Operation::kInsert>(
         *this,
         0,
         [&](char* group, int32_t /*row*/) {
           if (compareKeys(group, inserted)) {
-            if (nextOffset_) {
-              pushNext(group, inserted);
+            if (nextOffset_ > 0) {
+              pushNext(rows, group, inserted, allocator);
             }
             return true;
           }
@@ -1151,47 +1232,86 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::buildFullProbe(
         insertFn,
         numTombstones_,
         extraCheck,
-        partitionEnd);
+        partitionInfo);
+  }
+}
+
+template <bool ignoreNullKeys>
+template <bool isNormailizedKeyMode>
+FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::insertForJoinWithPrefetch(
+    RowContainer* rows,
+    char** groups,
+    uint64_t* hashes,
+    int32_t numGroups,
+    TableInsertPartitionInfo* partitionInfo,
+    HashStringAllocator* allocator) {
+  auto i = 0;
+  ProbeState states[kPrefetchSize];
+  constexpr int32_t kKeyOffset =
+      -static_cast<int32_t>(sizeof(normalized_key_t));
+  int32_t keyOffset = 0;
+  if constexpr (isNormailizedKeyMode) {
+    keyOffset = kKeyOffset;
+  }
+  for (; i + kPrefetchSize <= numGroups; i += kPrefetchSize) {
+    for (int32_t j = 0; j < kPrefetchSize; ++j) {
+      auto index = i + j;
+      states[j].preProbe(*this, hashes[index], index);
+    }
+    for (int32_t j = 0; j < kPrefetchSize; ++j) {
+      states[j].firstProbe(*this, keyOffset);
+    }
+    for (int32_t j = 0; j < kPrefetchSize; ++j) {
+      auto index = i + j;
+      buildFullProbe<isNormailizedKeyMode>(
+          rows,
+          states[j],
+          hashes[index],
+          groups[index],
+          j != 0,
+          partitionInfo,
+          allocator);
+    }
+  }
+  for (; i < numGroups; ++i) {
+    states[0].preProbe(*this, hashes[i], i);
+    states[0].firstProbe(*this, keyOffset);
+    buildFullProbe<isNormailizedKeyMode>(
+        rows, states[0], hashes[i], groups[i], false, partitionInfo, allocator);
   }
 }
 
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::insertForJoin(
+    RowContainer* rows,
     char** groups,
     uint64_t* hashes,
     int32_t numGroups,
-    PartitionBoundIndexType partitionBegin,
-    PartitionBoundIndexType partitionEnd,
-    std::vector<char*>* overflow) {
-  // The insertable rows are in the table, all get put in the hash
-  // table or array.
+    TableInsertPartitionInfo* partitionInfo,
+    HashStringAllocator* allocator) {
+  // The insertable rows are in the table, all get put in the hash table or
+  // array.
   if (hashMode_ == HashMode::kArray) {
     for (auto i = 0; i < numGroups; ++i) {
       auto index = hashes[i];
       VELOX_CHECK_LT(index, capacity_);
-      arrayPushRow(groups[i], index);
+      arrayPushRow(rows, groups[i], index, allocator);
     }
     return;
   }
-
-  ProbeState state1;
-  for (auto i = 0; i < numGroups; ++i) {
-    state1.preProbe(*this, hashes[i], i);
-    state1.firstProbe(*this, 0);
-
-    buildFullProbe(
-        state1,
-        hashes[i],
-        groups[i],
-        i,
-        partitionBegin,
-        partitionEnd,
-        overflow);
+  if (hashMode_ == HashMode::kNormalizedKey) {
+    insertForJoinWithPrefetch<true>(
+        rows, groups, hashes, numGroups, partitionInfo, allocator);
+  } else {
+    insertForJoinWithPrefetch<false>(
+        rows, groups, hashes, numGroups, partitionInfo, allocator);
   }
 }
 
 template <bool ignoreNullKeys>
-void HashTable<ignoreNullKeys>::rehash(bool initNormalizedKeys) {
+void HashTable<ignoreNullKeys>::rehash(
+    bool initNormalizedKeys,
+    int8_t spillInputStartPartitionBit) {
   ++numRehashes_;
   constexpr int32_t kHashBatchSize = 1024;
   if (canApplyParallelJoinBuild()) {
@@ -1214,7 +1334,7 @@ void HashTable<ignoreNullKeys>::rehash(bool initNormalizedKeys) {
       if (!insertBatch(
               groups, numGroups, hashes, initNormalizedKeys || i != 0)) {
         VELOX_CHECK_NE(hashMode_, HashMode::kHash);
-        setHashMode(HashMode::kHash, 0);
+        setHashMode(HashMode::kHash, 0, spillInputStartPartitionBit);
         return;
       }
     } while (numGroups > 0);
@@ -1222,8 +1342,12 @@ void HashTable<ignoreNullKeys>::rehash(bool initNormalizedKeys) {
 }
 
 template <bool ignoreNullKeys>
-void HashTable<ignoreNullKeys>::setHashMode(HashMode mode, int32_t numNew) {
+void HashTable<ignoreNullKeys>::setHashMode(
+    HashMode mode,
+    int32_t numNew,
+    int8_t spillInputStartPartitionBit) {
   VELOX_CHECK_NE(hashMode_, HashMode::kHash);
+  TestValue::adjust("facebook::velox::exec::HashTable::setHashMode", &mode);
   if (mode == HashMode::kArray) {
     const auto bytes = capacity_ * tableSlotSize();
     const auto numPages = memory::AllocationTraits::numPages(bytes);
@@ -1231,7 +1355,7 @@ void HashTable<ignoreNullKeys>::setHashMode(HashMode mode, int32_t numNew) {
     table_ = tableAllocation_.data<char*>();
     memset(table_, 0, bytes);
     hashMode_ = HashMode::kArray;
-    rehash(true);
+    rehash(true, spillInputStartPartitionBit);
   } else if (mode == HashMode::kHash) {
     hashMode_ = HashMode::kHash;
     for (auto& hasher : hashers_) {
@@ -1240,12 +1364,12 @@ void HashTable<ignoreNullKeys>::setHashMode(HashMode mode, int32_t numNew) {
     rows_->disableNormalizedKeys();
     capacity_ = 0;
     // Makes tables of the right size and rehashes.
-    checkSize(numNew, true);
+    checkSize(numNew, true, spillInputStartPartitionBit);
   } else if (mode == HashMode::kNormalizedKey) {
     hashMode_ = HashMode::kNormalizedKey;
     capacity_ = 0;
     // Makes tables of the right size and rehashes.
-    checkSize(numNew, true);
+    checkSize(numNew, true, spillInputStartPartitionBit);
   }
 }
 
@@ -1373,6 +1497,7 @@ void HashTable<ignoreNullKeys>::clearUseRange(std::vector<bool>& useRange) {
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::decideHashMode(
     int32_t numNew,
+    int8_t spillInputStartPartitionBit,
     bool disableRangeArrayHash) {
   std::vector<uint64_t> rangeSizes(hashers_.size());
   std::vector<uint64_t> distinctSizes(hashers_.size());
@@ -1389,7 +1514,7 @@ void HashTable<ignoreNullKeys>::decideHashMode(
   disableRangeArrayHash_ |= disableRangeArrayHash;
   if (numDistinct_ && !isJoinBuild_) {
     if (!analyze()) {
-      setHashMode(HashMode::kHash, numNew);
+      setHashMode(HashMode::kHash, numNew, spillInputStartPartitionBit);
       return;
     }
   }
@@ -1414,38 +1539,38 @@ void HashTable<ignoreNullKeys>::decideHashMode(
   if (rangesWithReserve < kArrayHashMaxSize && !disableRangeArrayHash_) {
     std::fill(useRange.begin(), useRange.end(), true);
     capacity_ = setHasherMode(hashers_, useRange, rangeSizes, distinctSizes);
-    setHashMode(HashMode::kArray, numNew);
+    setHashMode(HashMode::kArray, numNew, spillInputStartPartitionBit);
     return;
   }
 
   if (bestWithReserve < kArrayHashMaxSize ||
       (disableRangeArrayHash_ && bestWithReserve < numDistinct_ * 2)) {
     capacity_ = setHasherMode(hashers_, useRange, rangeSizes, distinctSizes);
-    setHashMode(HashMode::kArray, numNew);
+    setHashMode(HashMode::kArray, numNew, spillInputStartPartitionBit);
     return;
   }
   if (rangesWithReserve != VectorHasher::kRangeTooLarge) {
     std::fill(useRange.begin(), useRange.end(), true);
     setHasherMode(hashers_, useRange, rangeSizes, distinctSizes);
-    setHashMode(HashMode::kNormalizedKey, numNew);
+    setHashMode(HashMode::kNormalizedKey, numNew, spillInputStartPartitionBit);
     return;
   }
   if (hashers_.size() == 1 && distinctsWithReserve > 10000) {
     // A single part group by that does not go by range or become an array
     // does not make sense as a normalized key unless it is very small.
-    setHashMode(HashMode::kHash, numNew);
+    setHashMode(HashMode::kHash, numNew, spillInputStartPartitionBit);
     return;
   }
 
   if (distinctsWithReserve < kArrayHashMaxSize) {
     clearUseRange(useRange);
     capacity_ = setHasherMode(hashers_, useRange, rangeSizes, distinctSizes);
-    setHashMode(HashMode::kArray, numNew);
+    setHashMode(HashMode::kArray, numNew, spillInputStartPartitionBit);
     return;
   }
   if (distinctsWithReserve == VectorHasher::kRangeTooLarge &&
       rangesWithReserve == VectorHasher::kRangeTooLarge) {
-    setHashMode(HashMode::kHash, numNew);
+    setHashMode(HashMode::kHash, numNew, spillInputStartPartitionBit);
     return;
   }
   // The key concatenation fits in 64 bits.
@@ -1455,33 +1580,57 @@ void HashTable<ignoreNullKeys>::decideHashMode(
     clearUseRange(useRange);
   }
   setHasherMode(hashers_, useRange, rangeSizes, distinctSizes);
-  setHashMode(HashMode::kNormalizedKey, numNew);
+  setHashMode(HashMode::kNormalizedKey, numNew, spillInputStartPartitionBit);
+}
+
+template <bool ignoreNullKeys>
+std::vector<RowContainer*> HashTable<ignoreNullKeys>::allRows() const {
+  std::vector<RowContainer*> rowContainers;
+  rowContainers.reserve(otherTables_.size() + 1);
+  rowContainers.push_back(rows_.get());
+  for (auto& other : otherTables_) {
+    rowContainers.push_back(other->rows_.get());
+  }
+  return rowContainers;
+}
+
+template <bool ignoreNullKeys>
+void HashTable<ignoreNullKeys>::checkHashBitsOverlap(
+    int8_t spillInputStartPartitionBit) {
+  if (spillInputStartPartitionBit != kNoSpillInputStartPartitionBit &&
+      hashMode() != HashMode::kArray) {
+    VELOX_CHECK_LT(sizeBits_ - 1, spillInputStartPartitionBit);
+  }
 }
 
 template <bool ignoreNullKeys>
 std::string HashTable<ignoreNullKeys>::toString() {
   std::stringstream out;
-  int64_t occupied = 0;
-
-  out << "[HashTable  size: " << capacity_
+  out << "[HashTable keys: " << hashers_.size()
+      << " hash mode: " << modeString(hashMode_) << " capacity: " << capacity_
       << " distinct count: " << numDistinct_
-      << " tombstone count: " << numTombstones_ << "]";
+      << " tombstones count: " << numTombstones_ << "]";
   if (table_ == nullptr) {
-    out << "(no table) ";
+    out << " (no table)";
   }
+
   for (auto& hasher : hashers_) {
-    out << hasher->toString();
+    out << std::endl << hasher->toString();
   }
+  out << std::endl;
+
   if (kTrackLoads) {
-    out << std::endl;
     out << fmt::format(
-        "{} probes {} tag loads {} row loads {} hits",
-        numProbes_,
-        numTagLoads_,
-        numRowLoads_,
-        numHits_);
+               "{} probes {} tag loads {} row loads {} hits",
+               numProbes_,
+               numTagLoads_,
+               numRowLoads_,
+               numHits_)
+        << std::endl;
   }
+
   if (hashMode_ == HashMode::kArray) {
+    int64_t occupied = 0;
     if (table_ && tableAllocation_.data() && tableAllocation_.size()) {
       // 'size_' and 'table_' may not be set if initializing.
       uint64_t size = std::min<uint64_t>(
@@ -1490,22 +1639,77 @@ std::string HashTable<ignoreNullKeys>::toString() {
         occupied += table_[i] != nullptr;
       }
     }
+    out << "Total slots used: " << occupied << std::endl;
   } else {
-    // Count of groups indexed by number of non-empty slots.
-    int64_t numGroups[sizeof(TagVector) + 1] = {};
+    int64_t occupied = 0;
+
+    // Count of buckets indexed by the number of non-empty slots.
+    // Each bucket has 16 slots. Hence, the number of non-empty slots is between
+    // 0 and 16 (17 possible values).
+    int64_t numBuckets[sizeof(TagVector) + 1] = {};
     for (int64_t bucketOffset = 0; bucketOffset < sizeMask_;
          bucketOffset += kBucketSize) {
       auto tags = loadTags(bucketOffset);
       auto filled = simd::toBitMask(tags != TagVector::broadcast(0));
-      ++numGroups[__builtin_popcount(filled)];
-      occupied += filled;
+      auto numOccupied = __builtin_popcount(filled);
+
+      ++numBuckets[numOccupied];
+      occupied += numOccupied;
     }
-    out << " occupied=" << occupied;
-    out << std::endl;
-    for (auto i = 0; i < sizeof(numGroups) / sizeof(numGroups[0]); ++i) {
-      out << numGroups[i] << " groups with " << i << " entries" << std::endl;
+
+    out << "Total buckets: " << (sizeMask_ / kBucketSize + 1) << std::endl;
+    out << "Total slots used: " << occupied << std::endl;
+    for (auto i = 1; i < sizeof(TagVector) + 1; ++i) {
+      if (numBuckets[i] > 0) {
+        out << numBuckets[i] << " buckets with " << i << " slots used"
+            << std::endl;
+      }
+    }
+  }
+
+  return out.str();
+}
+
+template <bool ignoreNullKeys>
+std::string HashTable<ignoreNullKeys>::toString(
+    int64_t startBucket,
+    int64_t numBuckets) const {
+  if (table_ == nullptr) {
+    return "(no table)";
+  }
+
+  VELOX_CHECK_GE(startBucket, 0);
+  VELOX_CHECK_GT(numBuckets, 0);
+
+  const int64_t totalBuckets = sizeMask_ / kBucketSize + 1;
+  if (startBucket >= totalBuckets) {
+    return "";
+  }
+
+  const int64_t endBucket =
+      std::min<int64_t>(startBucket + numBuckets, totalBuckets);
+
+  std::ostringstream out;
+  for (int64_t i = startBucket; i < endBucket; ++i) {
+    out << std::setw(1 + endBucket / 10) << i << ": ";
+
+    auto bucket = bucketAt(i * kBucketSize);
+    for (auto j = 0; j < sizeof(TagVector); ++j) {
+      if (j > 0) {
+        out << ", ";
+      }
+      const auto tag = bucket->tagAt(j);
+      if (tag == ProbeState::kTombstoneTag) {
+        out << std::setw(3) << "T";
+      } else if (tag == ProbeState::kEmptyTag) {
+        out << std::setw(3) << "E";
+      } else {
+        out << (int)tag;
+      }
     }
+    out << std::endl;
   }
+
   return out.str();
 }
 
@@ -1526,6 +1730,7 @@ bool mayUseValueIds(const BaseHashTable& table) {
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::prepareJoinTable(
     std::vector<std::unique_ptr<BaseHashTable>> tables,
+    int8_t spillInputStartPartitionBit,
     folly::Executor* executor) {
   buildExecutor_ = executor;
   otherTables_.reserve(tables.size());
@@ -1533,6 +1738,20 @@ void HashTable<ignoreNullKeys>::prepareJoinTable(
     otherTables_.emplace_back(std::unique_ptr<HashTable<ignoreNullKeys>>(
         dynamic_cast<HashTable<ignoreNullKeys>*>(table.release())));
   }
+
+  // If there are multiple tables, we need to merge the 'columnHasNulls' flags
+  // from the containers of each table and store them in the main table. This
+  // is necessary because, when extracting results, 'rows' may contain row
+  // pointers from multiple containers. We need to ensure the correctness of
+  // the 'columnHasNulls' flags.
+  for (int i = 0; i < rows_->columnTypes().size(); ++i) {
+    columnHasNulls_.emplace_back(rows_->columnHasNulls(i));
+    for (auto& other : otherTables_) {
+      columnHasNulls_[i] =
+          columnHasNulls_[i] || other->rows()->columnHasNulls(i);
+    }
+  }
+
   bool useValueIds = mayUseValueIds(*this);
   if (useValueIds) {
     for (auto& other : otherTables_) {
@@ -1562,13 +1781,26 @@ void HashTable<ignoreNullKeys>::prepareJoinTable(
   }
   if (!useValueIds) {
     if (hashMode_ != HashMode::kHash) {
-      setHashMode(HashMode::kHash, 0);
+      setHashMode(HashMode::kHash, 0, spillInputStartPartitionBit);
     } else {
-      checkSize(0, true);
+      checkSize(0, true, spillInputStartPartitionBit);
     }
   } else {
-    decideHashMode(0);
+    decideHashMode(0, spillInputStartPartitionBit);
+  }
+}
+
+template <bool ignoreNullKeys>
+inline uint64_t HashTable<ignoreNullKeys>::joinProjectedVarColumnsSize(
+    const std::vector<vector_size_t>& columns,
+    const char* row) const {
+  uint64_t totalBytes{0};
+  for (const auto& column : columns) {
+    if (!rows_->columnTypes()[column]->isFixedWidth()) {
+      totalBytes += rows_->variableSizeAt(row, column);
+    }
   }
+  return totalBytes;
 }
 
 template <bool ignoreNullKeys>
@@ -1576,64 +1808,89 @@ int32_t HashTable<ignoreNullKeys>::listJoinResults(
     JoinResultIterator& iter,
     bool includeMisses,
     folly::Range<vector_size_t*> inputRows,
-    folly::Range<char**> hits) {
+    folly::Range<char**> hits,
+    uint64_t maxBytes) {
   VELOX_CHECK_LE(inputRows.size(), hits.size());
-  if (!hasDuplicates_) {
-    return listJoinResultsNoDuplicates(iter, includeMisses, inputRows, hits);
+
+  if (iter.varSizeListColumns.empty() && !hasDuplicates_) {
+    // When there is no duplicates, and no variable length columns are selected
+    // to be projected, we are able to calculate fixed length columns total size
+    // directly and go through fast path.
+    return listJoinResultsFastPath(
+        iter, includeMisses, inputRows, hits, maxBytes);
   }
-  int numOut = 0;
+
+  size_t numOut = 0;
   auto maxOut = inputRows.size();
+  uint64_t totalBytes{0};
   while (iter.lastRowIndex < iter.rows->size()) {
-    if (!iter.nextHit) {
-      auto row = (*iter.rows)[iter.lastRowIndex];
-      iter.nextHit = (*iter.hits)[row]; // NOLINT
-      if (!iter.nextHit) {
-        ++iter.lastRowIndex;
-
-        if (includeMisses) {
-          inputRows[numOut] = row; // NOLINT
-          hits[numOut] = nullptr;
-          ++numOut;
-          if (numOut >= maxOut) {
-            return numOut;
-          }
+    auto row = (*iter.rows)[iter.lastRowIndex];
+    auto hit = (*iter.hits)[row]; // NOLINT
+    if (!hit) {
+      ++iter.lastRowIndex;
+      if (includeMisses) {
+        inputRows[numOut] = row; // NOLINT
+        hits[numOut] = nullptr;
+        ++numOut;
+        if (numOut >= maxOut) {
+          return numOut;
         }
-        continue;
       }
+      continue;
     }
-    while (iter.nextHit) {
-      char* next = nullptr;
-      if (nextOffset_) {
-        next = nextRow(iter.nextHit);
-        if (next) {
-          __builtin_prefetch(reinterpret_cast<char*>(next) + nextOffset_);
-        }
-      }
-      inputRows[numOut] = (*iter.rows)[iter.lastRowIndex]; // NOLINT
-      hits[numOut] = iter.nextHit;
-      ++numOut;
-      iter.nextHit = next;
-      if (!iter.nextHit) {
-        ++iter.lastRowIndex;
+
+    auto rows = rows_->getNextRowVector(hit);
+    if (!rows) {
+      inputRows[numOut] = row; // NOLINT
+      hits[numOut] = hit;
+      numOut++;
+      iter.lastRowIndex++;
+      totalBytes +=
+          (joinProjectedVarColumnsSize(iter.varSizeListColumns, hit) +
+           iter.fixedSizeListColumnsSizeSum);
+    } else {
+      const auto numRows = rows->size();
+      auto num =
+          std::min(numRows - iter.lastDuplicateRowIndex, maxOut - numOut);
+      std::fill_n(inputRows.begin() + numOut, num, row);
+      std::memcpy(
+          hits.data() + numOut,
+          rows->data() + iter.lastDuplicateRowIndex,
+          num * sizeof(char*));
+      iter.lastDuplicateRowIndex += num;
+      numOut += num;
+      for (const auto* dupRow : *rows) {
+        totalBytes +=
+            joinProjectedVarColumnsSize(iter.varSizeListColumns, dupRow);
       }
-      if (numOut >= maxOut) {
-        return numOut;
+      totalBytes += (iter.fixedSizeListColumnsSizeSum * numRows);
+      if (iter.lastDuplicateRowIndex >= numRows) {
+        iter.lastDuplicateRowIndex = 0;
+        iter.lastRowIndex++;
       }
     }
+    if (numOut >= maxOut || totalBytes >= maxBytes) {
+      return numOut;
+    }
   }
   return numOut;
 }
 
 template <bool ignoreNullKeys>
-int32_t HashTable<ignoreNullKeys>::listJoinResultsNoDuplicates(
+int32_t HashTable<ignoreNullKeys>::listJoinResultsFastPath(
     JoinResultIterator& iter,
     bool includeMisses,
     folly::Range<vector_size_t*> inputRows,
-    folly::Range<char**> hits) {
+    folly::Range<char**> hits,
+    uint64_t maxBytes) {
   int32_t numOut = 0;
-  auto maxOut = inputRows.size();
+  const auto maxOut = std::min(
+      static_cast<uint64_t>(inputRows.size()),
+      (iter.fixedSizeListColumnsSizeSum != 0
+           ? maxBytes / iter.fixedSizeListColumnsSizeSum
+           : std::numeric_limits<uint64_t>::max()));
   int32_t i = iter.lastRowIndex;
-  auto numRows = iter.rows->size();
+  const auto numRows = iter.rows->size();
 
   constexpr int32_t kWidth = xsimd::batch<int64_t>::size;
   auto sourceHits = reinterpret_cast<int64_t*>(iter.hits->data());
@@ -1641,7 +1898,7 @@ int32_t HashTable<ignoreNullKeys>::listJoinResultsNoDuplicates(
   // We pass the pointers as int64_t's in 'hitWords'.
   auto resultHits = reinterpret_cast<int64_t*>(hits.data());
   auto resultRows = inputRows.data();
-  int32_t outLimit = maxOut - kWidth;
+  const auto outLimit = maxOut - kWidth;
   for (; i + kWidth <= numRows && numOut < outLimit; i += kWidth) {
     auto indices = simd::loadGatherIndices<int64_t, int32_t>(sourceRows + i);
     auto hitWords = simd::gather(sourceHits, indices);
@@ -1687,21 +1944,21 @@ int32_t HashTable<ignoreNullKeys>::listRows(
     uint64_t maxBytes,
     char** rows) {
   if (iter->hashTableIndex_ == -1) {
-    auto numRows = rows_->listRows<probeType>(
+    const auto numRows = rows_->listRows<probeType>(
         &iter->rowContainerIterator_, maxRows, maxBytes, rows);
-    if (numRows) {
+    if (numRows > 0) {
       return numRows;
     }
     iter->hashTableIndex_ = 0;
     iter->rowContainerIterator_.reset();
   }
   while (iter->hashTableIndex_ < otherTables_.size()) {
-    auto numRows =
+    const auto numRows =
         otherTables_[iter->hashTableIndex_]
             ->rows()
             ->template listRows<probeType>(
                 &iter->rowContainerIterator_, maxRows, maxBytes, rows);
-    if (numRows) {
+    if (numRows > 0) {
       return numRows;
     }
     ++iter->hashTableIndex_;
@@ -1760,13 +2017,28 @@ int32_t HashTable<false>::listNullKeyRows(
     iter->nextHit = lookup.hits[0];
     iter->initialized = true;
   }
-  int32_t numRows = 0;
-  char* hit = iter->nextHit;
-  while (numRows < maxRows && hit) {
-    rows[numRows++] = hit;
-    hit = nextRow(hit);
+  size_t numRows = 0;
+  if (numRows < maxRows && iter->nextHit) {
+    auto nextRows = rows_->getNextRowVector(iter->nextHit);
+    if (nextRows) {
+      auto num = std::min(
+          nextRows->size() - iter->lastDuplicateRowIndex, maxRows - numRows);
+      std::memcpy(
+          rows + numRows,
+          nextRows->data() + iter->lastDuplicateRowIndex,
+          num * sizeof(char*));
+      iter->lastDuplicateRowIndex += num;
+      numRows += num;
+      if (iter->lastDuplicateRowIndex >= nextRows->size()) {
+        iter->nextHit = nullptr;
+        iter->lastDuplicateRowIndex = 0;
+      }
+    } else {
+      rows[numRows++] = iter->nextHit;
+      iter->nextHit = nullptr;
+    }
   }
-  iter->nextHit = hit;
+
   return numRows;
 }
 
@@ -1884,11 +2156,33 @@ void HashTable<ignoreNullKeys>::checkConsistency() const {
 template class HashTable<true>;
 template class HashTable<false>;
 
-void BaseHashTable::prepareForProbe(
+namespace {
+void populateLookupRows(
+    const SelectivityVector& rows,
+    raw_vector<vector_size_t>& lookupRows) {
+  if (rows.isAllSelected()) {
+    std::iota(lookupRows.begin(), lookupRows.end(), 0);
+  } else {
+    lookupRows.clear();
+    rows.applyToSelected([&](auto row) { lookupRows.push_back(row); });
+  }
+}
+} // namespace
+
+std::string BaseHashTable::RowsIterator::toString() const {
+  return fmt::format(
+      "[hashTableIndex:{} rowContainerIter:{}",
+      hashTableIndex_,
+      rowContainerIterator_.toString());
+}
+
+template <bool ignoreNullKeys>
+void HashTable<ignoreNullKeys>::prepareForGroupProbe(
     HashLookup& lookup,
     const RowVectorPtr& input,
     SelectivityVector& rows,
-    bool ignoreNullKeys) {
+    int8_t spillInputStartPartitionBit) {
+  checkHashBitsOverlap(spillInputStartPartitionBit);
   auto& hashers = lookup.hashers;
 
   for (auto& hasher : hashers) {
@@ -1896,7 +2190,7 @@ void BaseHashTable::prepareForProbe(
     hasher->decode(*key, rows);
   }
 
-  if (ignoreNullKeys) {
+  if constexpr (ignoreNullKeys) {
     // A null in any of the keys disables the row.
     deselectRowsWithNulls(hashers, rows);
   }
@@ -1918,20 +2212,50 @@ void BaseHashTable::prepareForProbe(
 
   if (rehash || capacity() == 0) {
     if (mode != BaseHashTable::HashMode::kHash) {
-      decideHashMode(input->size());
+      decideHashMode(input->size(), spillInputStartPartitionBit);
       // Do not forward 'ignoreNullKeys' to avoid redundant evaluation of
       // deselectRowsWithNulls.
-      prepareForProbe(lookup, input, rows, false);
+      prepareForGroupProbe(lookup, input, rows, spillInputStartPartitionBit);
       return;
     }
   }
 
-  if (rows.isAllSelected()) {
-    std::iota(lookup.rows.begin(), lookup.rows.end(), 0);
-  } else {
-    lookup.rows.clear();
-    rows.applyToSelected([&](auto row) { lookup.rows.push_back(row); });
+  populateLookupRows(rows, lookup.rows);
+}
+
+template <bool ignoreNullKeys>
+void HashTable<ignoreNullKeys>::prepareForJoinProbe(
+    HashLookup& lookup,
+    const RowVectorPtr& input,
+    SelectivityVector& rows,
+    bool decodeAndRemoveNulls) {
+  auto& hashers = lookup.hashers;
+
+  if (decodeAndRemoveNulls) {
+    for (auto& hasher : hashers) {
+      auto key = input->childAt(hasher->channel())->loadedVector();
+      hasher->decode(*key, rows);
+    }
+
+    // A null in any of the keys disables the row.
+    deselectRowsWithNulls(hashers, rows);
+  }
+
+  lookup.reset(rows.end());
+
+  const auto mode = hashMode();
+  for (auto i = 0; i < hashers.size(); ++i) {
+    auto& hasher = hashers[i];
+    if (mode != BaseHashTable::HashMode::kHash) {
+      auto& key = input->childAt(hasher->channel());
+      hashers_[i]->lookupValueIds(
+          *key, rows, lookup.scratchMemory, lookup.hashes);
+    } else {
+      hasher->hash(rows, i > 0, lookup.hashes);
+    }
   }
+
+  populateLookupRows(rows, lookup.rows);
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/HashTable.h b/velox/exec/HashTable.h
index 2e06b359afa77..69ffa567e7791 100644
--- a/velox/exec/HashTable.h
+++ b/velox/exec/HashTable.h
@@ -24,7 +24,36 @@
 namespace facebook::velox::exec {
 
 using PartitionBoundIndexType = int64_t;
+/// Provides the partition info for parallel join table build use.
+struct TableInsertPartitionInfo {
+  /// ['start', 'end') specifies the insert range of this table partition.
+  PartitionBoundIndexType start;
+  PartitionBoundIndexType end;
+  /// Used to contains the overflowed rows which can't be inserted into the
+  /// given table partition range.
+  std::vector<char*>& overflows;
+
+  TableInsertPartitionInfo(
+      PartitionBoundIndexType _start,
+      PartitionBoundIndexType _end,
+      std::vector<char*>& _overflows)
+      : start(_start), end(_end), overflows(_overflows) {
+    VELOX_CHECK_GE(start, 0);
+    VELOX_CHECK_LT(start, end);
+  }
+
+  /// Indicates if 'index' is within this partition range.
+  bool inRange(PartitionBoundIndexType index) const {
+    return index >= start && index < end;
+  }
+
+  /// Adds 'row' falls outside of this partititon range into 'overflows'.
+  void addOverflow(char* row) {
+    overflows.push_back(row);
+  }
+};
 
+/// Contains input and output parameters for groupProbe and joinProbe APIs.
 struct HashLookup {
   explicit HashLookup(const std::vector<std::unique_ptr<VectorHasher>>& h)
       : hashers(h) {}
@@ -36,17 +65,36 @@ struct HashLookup {
     newGroups.clear();
   }
 
-  // One entry per aggregation or join key
+  /// One entry per group-by or join key.
   const std::vector<std::unique_ptr<VectorHasher>>& hashers;
+
+  /// Scratch memory used to call VectorHasher::lookupValueIds.
+  VectorHasher::ScratchMemory scratchMemory;
+
+  /// Input to groupProbe and joinProbe APIs.
+
+  /// Set of row numbers of row to probe.
   raw_vector<vector_size_t> rows;
-  // Hash number for all input rows.
+
+  /// Hashes or value IDs for rows in 'rows'. Not aligned with 'rows'. Index is
+  /// the row number.
   raw_vector<uint64_t> hashes;
-  // If using valueIds, list of concatenated valueIds. 1:1 with 'hashes'.
-  raw_vector<uint64_t> normalizedKeys;
-  // Hit for each row of input corresponding group row or join row.
+
+  /// Results of groupProbe and joinProbe APIs.
+
+  /// Contains one entry for each row in 'rows'. Index is the row number.
+  /// For groupProbe, a pointer to an existing or new row with matching grouping
+  /// keys. For joinProbe, a pointer to the first row with matching keys or null
+  /// if no match.
   raw_vector<char*> hits;
-  // Indices of newly inserted rows (not found during probe).
+
+  /// For groupProbe, row numbers for which a new entry was inserted (didn't
+  /// exist before the groupProbe). Empty for joinProbe.
   std::vector<vector_size_t> newGroups;
+
+  /// If using valueIds, list of concatenated valueIds. 1:1 with 'hashes'.
+  /// Populated by groupProbe and joinProbe.
+  raw_vector<uint64_t> normalizedKeys;
 };
 
 struct HashTableStats {
@@ -73,29 +121,53 @@ class BaseHashTable {
   /// Specifies the hash mode of a table.
   enum class HashMode { kHash, kArray, kNormalizedKey };
 
+  static constexpr int8_t kNoSpillInputStartPartitionBit = -1;
+
+  /// The name of the runtime stats collected and reported by operators that use
+  /// the HashTable (HashBuild, HashAggregation).
+  static inline const std::string kCapacity{"hashtable.capacity"};
+  static inline const std::string kNumRehashes{"hashtable.numRehashes"};
+  static inline const std::string kNumDistinct{"hashtable.numDistinct"};
+  static inline const std::string kNumTombstones{"hashtable.numTombstones"};
+
+  /// The same as above but only reported by the HashBuild operator.
+  static inline const std::string kBuildWallNanos{"hashtable.buildWallNanos"};
+
   /// Returns the string of the given 'mode'.
   static std::string modeString(HashMode mode);
 
-  // Keeps track of results returned from a join table. One batch of
-  // keys can produce multiple batches of results. This is initialized
-  // from HashLookup, which is expected to stay constant while 'this'
-  // is being used.
+  /// Keeps track of results returned from a join table. One batch of keys can
+  /// produce multiple batches of results. This is initialized from HashLookup,
+  /// which is expected to stay constant while 'this' is being used.
   struct JoinResultIterator {
+    JoinResultIterator(
+        std::vector<vector_size_t>&& _varSizeListColumns,
+        uint64_t _fixedSizeListColumnsSizeSum)
+        : varSizeListColumns(std::move(_varSizeListColumns)),
+          fixedSizeListColumnsSizeSum(_fixedSizeListColumnsSizeSum) {}
+
     void reset(const HashLookup& lookup) {
       rows = &lookup.rows;
       hits = &lookup.hits;
-      nextHit = nullptr;
       lastRowIndex = 0;
+      lastDuplicateRowIndex = 0;
     }
 
     bool atEnd() const {
       return !rows || lastRowIndex == rows->size();
     }
 
+    /// The indexes of the build side projected columns that are variable sized.
+    const std::vector<vector_size_t> varSizeListColumns;
+    /// The per row total bytes of the build side projected columns that are
+    /// fixed sized.
+    const uint64_t fixedSizeListColumnsSizeSum{0};
+
     const raw_vector<vector_size_t>* rows{nullptr};
     const raw_vector<char*>* hits{nullptr};
-    char* nextHit{nullptr};
+
     vector_size_t lastRowIndex{0};
+    vector_size_t lastDuplicateRowIndex{0};
   };
 
   struct RowsIterator {
@@ -105,11 +177,14 @@ class BaseHashTable {
     void reset() {
       *this = {};
     }
+
+    std::string toString() const;
   };
 
   struct NullKeyRowsIterator {
     bool initialized = false;
     char* nextHit;
+    vector_size_t lastDuplicateRowIndex{0};
   };
 
   /// Takes ownership of 'hashers'. These are used to keep key-level
@@ -124,34 +199,58 @@ class BaseHashTable {
 
   virtual HashStringAllocator* stringAllocator() = 0;
 
-  void prepareForProbe(
+  /// Populates 'hashes' and 'rows' fields in 'lookup' in preparation for
+  /// 'groupProbe' call. Rehashes the table if necessary. Uses lookup.hashes to
+  /// decode grouping keys from 'input'. If 'ignoreNullKeys' is true, updates
+  /// 'rows' to remove entries with null grouping keys. After this call, 'rows'
+  /// may have no entries selected.
+  virtual void prepareForGroupProbe(
       HashLookup& lookup,
       const RowVectorPtr& input,
       SelectivityVector& rows,
-      bool ignoreNullKeys);
+      int8_t spillInputStartPartitionBit) = 0;
 
   /// Finds or creates a group for each key in 'lookup'. The keys are
   /// returned in 'lookup.hits'.
-  virtual void groupProbe(HashLookup& lookup) = 0;
+  virtual void groupProbe(
+      HashLookup& lookup,
+      int8_t spillInputStartPartitionBit) = 0;
 
   /// Returns the first hit for each key in 'lookup'. The keys are in
   /// 'lookup.hits' with a nullptr representing a miss. This is for use in hash
   /// join probe. Use listJoinResults to iterate over the results.
   virtual void joinProbe(HashLookup& lookup) = 0;
 
+  /// Populates 'hashes' and 'rows' fields in 'lookup' in preparation for
+  /// 'joinProbe' call. If hash mode is not kHash, populates 'hashes' with
+  /// values IDs. Rows which do not have value IDs are removed from 'rows'
+  /// (these rows cannot possibly match). if 'decodeAndRemoveNulls' is true,
+  /// uses lookup.hashes to decode grouping keys from 'input' and updates 'rows'
+  /// to remove entries with null grouping keys. Otherwise, assumes the caller
+  /// has done that already. After this call, 'rows' may have no entries
+  /// selected.
+  virtual void prepareForJoinProbe(
+      HashLookup& lookup,
+      const RowVectorPtr& input,
+      SelectivityVector& rows,
+      bool decodeAndRemoveNulls) = 0;
+
   /// Fills 'hits' with consecutive hash join results. The corresponding element
   /// of 'inputRows' is set to the corresponding row number in probe keys.
-  /// Returns the number of hits produced. If this s less than hits.size() then
+  /// Returns the number of hits produced. If this is less than hits.size() then
   /// all the hits have been produced.
   /// Adds input rows without a match to 'inputRows' with corresponding hit
   /// set to nullptr if 'includeMisses' is true. Otherwise, skips input rows
   /// without a match. 'includeMisses' is set to true when listing results for
   /// the LEFT join.
+  /// The filling stops when the total size of currently listed rows exceeds
+  /// 'maxBytes'.
   virtual int32_t listJoinResults(
       JoinResultIterator& iter,
       bool includeMisses,
       folly::Range<vector_size_t*> inputRows,
-      folly::Range<char**> hits) = 0;
+      folly::Range<char**> hits,
+      uint64_t maxBytes) = 0;
 
   /// Returns rows with 'probed' flag unset. Used by the right/full join.
   virtual int32_t listNotProbedRows(
@@ -181,15 +280,16 @@ class BaseHashTable {
 
   virtual void prepareJoinTable(
       std::vector<std::unique_ptr<BaseHashTable>> tables,
+      int8_t spillInputStartPartitionBit,
       folly::Executor* executor = nullptr) = 0;
 
   /// Returns the memory footprint in bytes for any data structures
   /// owned by 'this'.
   virtual int64_t allocatedBytes() const = 0;
 
-  /// Deletes any content of 'this' but does not free the memory. Can
-  /// be used for flushing a partial group by, for example.
-  virtual void clear() = 0;
+  /// Deletes any content of 'this'. If 'freeTable' is false, then hash table is
+  /// not freed which can be used for flushing a partial group by, for example.
+  virtual void clear(bool freeTable = false) = 0;
 
   /// Returns the capacity of the internal hash table which is number of rows
   /// it can stores in a group by or hash join build.
@@ -220,8 +320,8 @@ class BaseHashTable {
   virtual HashMode hashMode() const = 0;
 
   /// Disables use of array or normalized key hash modes.
-  void forceGenericHashMode() {
-    setHashMode(HashMode::kHash, 0);
+  void forceGenericHashMode(int8_t spillInputStartPartitionBit) {
+    setHashMode(HashMode::kHash, 0, spillInputStartPartitionBit);
   }
 
   /// Decides the hash table representation based on the statistics in
@@ -239,9 +339,10 @@ class BaseHashTable {
   /// lifetime of 'this'.
   virtual void decideHashMode(
       int32_t numNew,
+      int8_t spillInputStartPartitionBit,
       bool disableRangeArrayHash = false) = 0;
 
-  // Removes 'rows'  from the hash table and its RowContainer. 'rows' must exist
+  // Removes 'rows' from the hash table and its RowContainer. 'rows' must exist
   // and be unique.
   virtual void erase(folly::Range<char**> rows) = 0;
 
@@ -256,16 +357,21 @@ class BaseHashTable {
     return rows_.get();
   }
 
-  std::unique_ptr<RowContainer> moveRows() {
-    return std::move(rows_);
-  }
+  /// Returns all the row containers of a composed hash table such as for hash
+  /// join use.
+  virtual std::vector<RowContainer*> allRows() const = 0;
 
-  // Static functions for processing internals. Public because used in
-  // structs that define probe and insert algorithms.
+  /// Static functions for processing internals. Public because used in
+  /// structs that define probe and insert algorithms.
 
   /// Extracts a 7 bit tag from a hash number. The high bit is always set.
   static uint8_t hashTag(uint64_t hash) {
-    return static_cast<uint8_t>(hash >> 32) | 0x80;
+    // This is likely all 0 for small key types (<= 32 bits).  Not an issue
+    // because small types have a range that makes them normalized key cases.
+    // If there are multiple small type keys, they are mixed which makes them a
+    // 64 bit hash.  Normalized keys are mixed before being used as hash
+    // numbers.
+    return static_cast<uint8_t>(hash >> 38) | 0x80;
   }
 
   /// Loads a vector of tags for bulk comparison. Disables tsan errors
@@ -290,16 +396,34 @@ class BaseHashTable {
 #endif
   }
 
+  const CpuWallTiming& offThreadBuildTiming() const {
+    return offThreadBuildTiming_;
+  }
+
+  /// Copies the values at 'columnIndex' into 'result' for the 'rows.size' rows
+  /// pointed to by 'rows'. If an entry in 'rows' is null, sets corresponding
+  /// row in 'result' to null.
+  virtual void extractColumn(
+      folly::Range<char* const*> rows,
+      int32_t columnIndex,
+      const VectorPtr& result) = 0;
+
  protected:
   static FOLLY_ALWAYS_INLINE size_t tableSlotSize() {
     // Each slot is 8 bytes.
     return sizeof(void*);
   }
 
-  virtual void setHashMode(HashMode mode, int32_t numNew) = 0;
+  virtual void setHashMode(
+      HashMode mode,
+      int32_t numNew,
+      int8_t spillInputStartPartitionBit) = 0;
 
   std::vector<std::unique_ptr<VectorHasher>> hashers_;
   std::unique_ptr<RowContainer> rows_;
+
+  // Time spent in build outside of the calling thread.
+  CpuWallTiming offThreadBuildTiming_;
 };
 
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
@@ -310,6 +434,10 @@ FOLLY_ALWAYS_INLINE std::ostream& operator<<(
 }
 
 class ProbeState;
+namespace test {
+template <bool ignoreNullKeys>
+class HashTableTestHelper;
+}
 
 template <bool ignoreNullKeys>
 class HashTable : public BaseHashTable {
@@ -331,6 +459,8 @@ class HashTable : public BaseHashTable {
       uint32_t minTableSizeForParallelJoinBuild,
       memory::MemoryPool* pool);
 
+  ~HashTable() override = default;
+
   static std::unique_ptr<HashTable> createForAggregation(
       std::vector<std::unique_ptr<VectorHasher>>&& hashers,
       const std::vector<Accumulator>& accumulators,
@@ -364,7 +494,8 @@ class HashTable : public BaseHashTable {
         pool);
   }
 
-  void groupProbe(HashLookup& lookup) override;
+  void groupProbe(HashLookup& lookup, int8_t spillInputStartPartitionBit)
+      override;
 
   void joinProbe(HashLookup& lookup) override;
 
@@ -372,7 +503,8 @@ class HashTable : public BaseHashTable {
       JoinResultIterator& iter,
       bool includeMisses,
       folly::Range<vector_size_t*> inputRows,
-      folly::Range<char**> hits) override;
+      folly::Range<char**> hits,
+      uint64_t maxBytes) override;
 
   int32_t listNotProbedRows(
       RowsIterator* iter,
@@ -397,7 +529,7 @@ class HashTable : public BaseHashTable {
       int32_t maxRows,
       char** rows) override;
 
-  void clear() override;
+  void clear(bool freeTable = false) override;
 
   int64_t allocatedBytes() const override {
     // For each row: sizeof(char*) per table entry + memory
@@ -430,25 +562,40 @@ class HashTable : public BaseHashTable {
     return hashMode_;
   }
 
-  void decideHashMode(int32_t numNew, bool disableRangeArrayHash = false)
-      override;
+  void decideHashMode(
+      int32_t numNew,
+      int8_t spillInputStartPartitionBit,
+      bool disableRangeArrayHash = false) override;
 
   void erase(folly::Range<char**> rows) override;
 
-  // Moves the contents of 'tables' into 'this' and prepares 'this'
-  // for use in hash join probe. A hash join build side is prepared as
-  // follows: 1. Each build side thread gets a random selection of the
-  // build stream. Each accumulates rows into its own
-  // HashTable'sRowContainer and updates the VectorHashers of the
-  // table to reflect the data as long as the data shows promise for
-  // kArray or kNormalizedKey representation. After all the build
-  // tables are filled, they are combined into one top level table
-  // with prepareJoinTable. This then takes ownership of all the data
-  // and VectorHashers and decides the hash mode and representation.
+  /// Moves the contents of 'tables' into 'this' and prepares 'this'
+  /// for use in hash join probe. A hash join build side is prepared as
+  /// follows: 1. Each build side thread gets a random selection of the
+  /// build stream. Each accumulates rows into its own
+  /// HashTable'sRowContainer and updates the VectorHashers of the
+  /// table to reflect the data as long as the data shows promise for
+  /// kArray or kNormalizedKey representation. After all the build
+  /// tables are filled, they are combined into one top level table
+  /// with prepareJoinTable. This then takes ownership of all the data
+  /// and VectorHashers and decides the hash mode and representation.
   void prepareJoinTable(
       std::vector<std::unique_ptr<BaseHashTable>> tables,
+      int8_t spillInputStartPartitionBit,
       folly::Executor* executor = nullptr) override;
 
+  void prepareForJoinProbe(
+      HashLookup& lookup,
+      const RowVectorPtr& input,
+      SelectivityVector& rows,
+      bool decodeAndRemoveNulls) override;
+
+  void prepareForGroupProbe(
+      HashLookup& lookup,
+      const RowVectorPtr& input,
+      SelectivityVector& rows,
+      int8_t spillInputStartPartitionBit) override;
+
   uint64_t hashTableSizeIncrease(int32_t numNewDistinct) const override {
     if (numDistinct_ + numNewDistinct > rehashSize()) {
       // If rehashed, the table adds size_ entries (i.e. doubles),
@@ -470,12 +617,15 @@ class HashTable : public BaseHashTable {
         memory::AllocationTraits::kPageSize);
   }
 
-  uint64_t rehashSize() const {
-    return rehashSize(capacity_ - numTombstones_);
-  }
+  std::vector<RowContainer*> allRows() const override;
 
   std::string toString() override;
 
+  /// Returns the details of the range of buckets. The range starts from
+  /// zero-based 'startBucket' and contains 'numBuckets' or however many there
+  /// are left till the end of the table.
+  std::string toString(int64_t startBucket, int64_t numBuckets = 1) const;
+
   /// Invoked to check the consistency of the internal state. The function scans
   /// all the table slots to check if the relevant slot counting are correct
   /// such as the number of used slots ('numDistinct_') and the number of
@@ -485,14 +635,26 @@ class HashTable : public BaseHashTable {
   /// purpose.
   void checkConsistency() const;
 
-  void testingSetHashMode(HashMode mode, int32_t numNew) {
-    setHashMode(mode, numNew);
-  }
-
   auto& testingOtherTables() const {
     return otherTables_;
   }
 
+  uint64_t testingRehashSize() const {
+    return rehashSize();
+  }
+
+  void extractColumn(
+      folly::Range<char* const*> rows,
+      int32_t columnIndex,
+      const VectorPtr& result) override {
+    RowContainer::extractColumn(
+        rows.data(),
+        rows.size(),
+        rows_->columnAt(columnIndex),
+        columnHasNulls_[columnIndex],
+        result);
+  }
+
  private:
   // Enables debug stats for collisions for debug build.
 #ifdef NDEBUG
@@ -508,10 +670,6 @@ class HashTable : public BaseHashTable {
   // occupy exactly two (64 bytes) cache lines.
   class Bucket {
    public:
-    Bucket() {
-      static_assert(sizeof(Bucket) == 128);
-    }
-
     uint8_t tagAt(int32_t slotIndex) {
       return reinterpret_cast<uint8_t*>(&tags_)[slotIndex];
     }
@@ -543,6 +701,7 @@ class HashTable : public BaseHashTable {
     char padding_[16];
   };
 
+  static_assert(sizeof(Bucket) == 128);
   static constexpr uint64_t kBucketSize = sizeof(Bucket);
 
   // Returns the bucket at byte offset 'offset' from 'table_'.
@@ -575,20 +734,21 @@ class HashTable : public BaseHashTable {
   int32_t
   listRows(RowsIterator* iter, int32_t maxRows, uint64_t maxBytes, char** rows);
 
-  char*& nextRow(char* row) {
-    return *reinterpret_cast<char**>(row + nextOffset_);
-  }
-
   void arrayGroupProbe(HashLookup& lookup);
 
-  void setHashMode(HashMode mode, int32_t numNew) override;
+  void setHashMode(
+      HashMode mode,
+      int32_t numNew,
+      int8_t spillInputStartPartitionBit) override;
 
-  // Fast path for join results when there are no duplicates in the table.
-  int32_t listJoinResultsNoDuplicates(
+  // Fast path for join results when there are no duplicates in the table and
+  // only fixed size rows are to be extract.
+  int32_t listJoinResultsFastPath(
       JoinResultIterator& iter,
       bool includeMisses,
       folly::Range<vector_size_t*> inputRows,
-      folly::Range<char**> hits);
+      folly::Range<char**> hits,
+      uint64_t maxBytes);
 
   // Tries to use as many range hashers as can in a normalized key situation.
   void enableRangeWhereCan(
@@ -608,20 +768,28 @@ class HashTable : public BaseHashTable {
   // VectorHashers.
   void clearUseRange(std::vector<bool>& useRange);
 
-  void rehash(bool initNormalizedKeys);
+  void rehash(bool initNormalizedKeys, int8_t spillInputStartPartitionBit);
+
+  uint64_t rehashSize() const {
+    return rehashSize(capacity_ - numTombstones_);
+  }
+
   void storeKeys(HashLookup& lookup, vector_size_t row);
 
-  void storeRowPointer(int32_t index, uint64_t hash, char* row);
+  void storeRowPointer(uint64_t index, uint64_t hash, char* row);
 
   // Allocates new tables for tags and payload pointers. The size must
   // a power of 2.
-  void allocateTables(uint64_t size);
+  void allocateTables(uint64_t size, int8_t spillInputStartPartitionBit);
 
   // 'initNormalizedKeys' is passed to 'rehash' --> 'rehash' --> 'insertBatch'.
   // If it's false and the table is in normalized keys mode,
   // the keys are retrieved from the row and the hash is made
   // from this, without recomputing the normalized key.
-  void checkSize(int32_t numNew, bool initNormalizedKeys);
+  void checkSize(
+      int32_t numNew,
+      bool initNormalizedKeys,
+      int8_t spillInputStartPartitionBit);
 
   // Computes hash numbers of the appropriate hash mode for 'groups',
   // stores these in 'hashes' and inserts the groups using
@@ -632,22 +800,22 @@ class HashTable : public BaseHashTable {
       raw_vector<uint64_t>& hashes,
       bool initNormalizedKeys);
 
-  // Inserts 'numGroups' entries into 'this'. 'groups' point to
-  // contents in a RowContainer owned by 'this'. 'hashes' are the hash
-  // numbers or array indices (if kArray mode) for each
-  // group. Duplicate key rows are chained via their next link. if
-  // parallel build, partitionEnd is the index of the first entry
-  // after the partition being inserted. If a row would be inserted to
-  // the right of the end, it is not inserted but rather added to the
-  // end of 'overflows'.
+  // Inserts 'numGroups' entries into 'this'. 'groups' point to contents in a
+  // RowContainer owned by 'this'. 'hashes' are the hash numbers or array
+  // indices (if kArray mode) for each group. Duplicate key rows are chained
+  // via their next link. If not null, 'partitionInfo' provides the table
+  // partition info for parallel join table build. It specifies the first and
+  // (exclusive) last indexes of the insert entries in the table. If a row
+  // can't be inserted within this range, it is not inserted but rather added
+  // to the end of 'overflows' in 'partitionInfo'. 'allocator' is provided for
+  // duplicate row vector allocations.
   void insertForJoin(
+      RowContainer* rows,
       char** groups,
       uint64_t* hashes,
       int32_t numGroups,
-      PartitionBoundIndexType partitionBegin = 0,
-      PartitionBoundIndexType partitionEnd =
-          std::numeric_limits<PartitionBoundIndexType>::max(),
-      std::vector<char*>* overflows = nullptr);
+      TableInsertPartitionInfo* partitionInfo,
+      HashStringAllocator* allocator);
 
   // Inserts 'numGroups' entries into 'this'. 'groups' point to
   // contents in a RowContainer owned by 'this'. 'hashes' are the hash
@@ -700,7 +868,7 @@ class HashTable : public BaseHashTable {
       bool initNormalizedKeys,
       raw_vector<uint64_t>& hashes);
 
-  char* insertEntry(HashLookup& lookup, int32_t index, vector_size_t row);
+  char* insertEntry(HashLookup& lookup, uint64_t index, vector_size_t row);
 
   bool compareKeys(const char* group, HashLookup& lookup, vector_size_t row);
 
@@ -718,31 +886,61 @@ class HashTable : public BaseHashTable {
   // Shortcut for probe with normalized keys.
   void joinNormalizedKeyProbe(HashLookup& lookup);
 
-  // Adds a row to a hash join table in kArray hash mode. Returns true
-  // if a new entry was made and false if the row was added to an
-  // existing set of rows with the same key.
-  bool arrayPushRow(char* row, int32_t index);
-
-  // Adds a row to a hash join build side entry with multiple rows
-  // with the same key.
-  void pushNext(char* row, char* next);
+  // Returns the total size of the variable size 'columns' in 'row'.
+  // NOTE: No checks are done in the method for performance considerations.
+  // Caller needs to make sure only variable size columns are inside of
+  // 'columns'.
+  inline uint64_t joinProjectedVarColumnsSize(
+      const std::vector<vector_size_t>& columns,
+      const char* row) const;
+
+  // Adds a row to a hash join table in kArray hash mode. Returns true if a new
+  // entry was made and false if the row was added to an existing set of rows
+  // with the same key. 'allocator' is provided for duplicate row vector
+  // allocations.
+  bool arrayPushRow(
+      RowContainer* rows,
+      char* row,
+      int32_t index,
+      HashStringAllocator* allocator);
+
+  // Adds a row to a hash join build side entry with multiple rows with the same
+  // key.  'rows' should be the same as the one in hash table except for
+  // 'parallelJoinBuild'. 'allocator' is provided for duplicate row vector
+  // allocations.
+  void pushNext(
+      RowContainer* rows,
+      char* row,
+      char* next,
+      HashStringAllocator* allocator);
 
-  // Finishes inserting an entry into a join hash table. If the insert
-  // would fall outside of 'partitionBegin' ... 'partitionEnd', the
-  // insert is not made but the row is instead added to 'overflow'.
+  // Finishes inserting an entry into a join hash table. If 'partitionInfo' is
+  // not null and the insert falls out-side of the partition range, then insert
+  // is not made but row is instead added to 'overflow' in 'partitionInfo'
+  template <bool isNormailizedKeyMode>
   void buildFullProbe(
+      RowContainer* rows,
       ProbeState& state,
       uint64_t hash,
       char* row,
       bool extraCheck,
-      PartitionBoundIndexType partitionBegin,
-      PartitionBoundIndexType partitionEnd,
-      std::vector<char*>* overflows);
+      TableInsertPartitionInfo* partitionInfo,
+      HashStringAllocator* allocator);
+
+  template <bool isNormailizedKeyMode>
+  void insertForJoinWithPrefetch(
+      RowContainer* rows,
+      char** groups,
+      uint64_t* hashes,
+      int32_t numGroups,
+      TableInsertPartitionInfo* partitionInfo,
+      HashStringAllocator* allocator);
 
   // Updates 'hashers_' to correspond to the keys in the
   // content. Returns true if all hashers offer a mapping to value ids
   // for array or normalized key.
   bool analyze();
+
   // Erases the entries of rows from the hash table and its RowContainer.
   // 'hashes' must be computed according to 'hashMode_'.
   void eraseWithHashes(folly::Range<char**> rows, uint64_t* hashes);
@@ -761,9 +959,14 @@ class HashTable : public BaseHashTable {
 
   // Returns the byte offset of the next bucket from 'offset'. Wraps around at
   // the end of the table.
-  int64_t nextBucketOffset(int32_t offset) const {
-    VELOX_DCHECK_EQ(0, offset & (kBucketSize - 1));
-    return sizeMask_ & (offset + kBucketSize);
+  int64_t nextBucketOffset(int64_t bucketOffset) const {
+    VELOX_DCHECK_EQ(0, bucketOffset & (kBucketSize - 1));
+    VELOX_DCHECK_LT(bucketOffset, sizeMask_);
+    return sizeMask_ & (bucketOffset + kBucketSize);
+  }
+
+  int64_t numBuckets() const {
+    return numBuckets_;
   }
 
   // Return the row pointer at 'slotIndex' of bucket at 'bucketOffset'.
@@ -802,6 +1005,13 @@ class HashTable : public BaseHashTable {
     }
   }
 
+  // We don't want any overlap in the bit ranges used by bucket index and those
+  // used by spill partitioning; otherwise because we receive data from only one
+  // partition, the overlapped bits would be the same and only a fraction of the
+  // buckets would be used.  This would cause the insertion taking very long
+  // time and block driver threads.
+  void checkHashBitsOverlap(int8_t spillInputStartPartitionBit);
+
   // The min table size in row to trigger parallel join table build.
   const uint32_t minTableSizeForParallelJoinBuild_;
 
@@ -813,9 +1023,8 @@ class HashTable : public BaseHashTable {
   // many threads can set this.
   std::atomic<bool> hasDuplicates_{false};
 
-  // Offset of next row link for join build side, 0 if none. Copied
-  // from 'rows_'.
-  int32_t nextOffset_;
+  // Offset of next row link for join build side set from 'rows_'.
+  int32_t nextOffset_{0};
   char** table_ = nullptr;
   memory::ContiguousAllocation tableAllocation_;
 
@@ -829,6 +1038,7 @@ class HashTable : public BaseHashTable {
   // Mask used to get the byte offset of a bucket from 'table_' given a hash
   // number.
   int64_t bucketOffsetMask_{0};
+  int64_t numBuckets_{0};
   int64_t numDistinct_{0};
   // Counts the number of tombstone table slots.
   int64_t numTombstones_{0};
@@ -838,8 +1048,16 @@ class HashTable : public BaseHashTable {
   // Owns the memory of multiple build side hash join tables that are
   // combined into a single probe hash table.
   std::vector<std::unique_ptr<HashTable<ignoreNullKeys>>> otherTables_;
+  // The allocators used for duplicate row vector allocations under parallel
+  // join insert with one per each parallel join partition. These allocators
+  // all allocate memory from the memory pool of the top level memory pool.
+  std::vector<std::unique_ptr<HashStringAllocator>> joinInsertAllocators_;
   // Statistics maintained if kTrackLoads is set.
 
+  // Flags indicate whether the same column in all build-side join hash tables
+  // contains null values.
+  std::vector<bool> columnHasNulls_;
+
   // Number of times a row is looked up or inserted.
   mutable tsan_atomic<int64_t> numProbes_{0};
 
@@ -852,8 +1070,6 @@ class HashTable : public BaseHashTable {
   // Number of times a match is found.
   mutable tsan_atomic<int64_t> numHits_{0};
 
-  friend class ProbeState;
-
   // Bounds of independently buildable index ranges in the table. The
   // range of partition i starts at [i] and ends at [i +1]. Bounds are multiple
   // of cache line  size.
@@ -861,7 +1077,7 @@ class HashTable : public BaseHashTable {
 
   // Executor for parallelizing hash join build. This may be the
   // executor for Drivers. If this executor is indefinitely taken by
-  // other work, the thread of prepareJoinTables() will sequentially
+  // other work, the thread of prepareJoinTable() will sequentially
   // execute the parallel build steps.
   folly::Executor* buildExecutor_{nullptr};
 
@@ -870,6 +1086,20 @@ class HashTable : public BaseHashTable {
 
   // If true, avoids using VectorHasher value ranges with kArray hash mode.
   bool disableRangeArrayHash_{false};
+
+  friend class ProbeState;
+  friend test::HashTableTestHelper<ignoreNullKeys>;
 };
 
 } // namespace facebook::velox::exec
+
+template <>
+struct fmt::formatter<facebook::velox::exec::BaseHashTable::HashMode>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::exec::BaseHashTable::HashMode s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::exec::BaseHashTable::modeString(s), ctx);
+  }
+};
diff --git a/velox/exec/Limit.cpp b/velox/exec/Limit.cpp
index 79b74a65f6b3b..adab0530b30d7 100644
--- a/velox/exec/Limit.cpp
+++ b/velox/exec/Limit.cpp
@@ -42,7 +42,7 @@ bool Limit::needsInput() const {
 }
 
 void Limit::addInput(RowVectorPtr input) {
-  VELOX_CHECK(input_ == nullptr);
+  VELOX_CHECK_NULL(input_);
   input_ = input;
 }
 
@@ -61,10 +61,11 @@ RowVectorPtr Limit::getOutput() {
 
   if (remainingOffset_ > 0) {
     // Return a subset of input_ rows.
-    auto outputSize = std::min(inputSize - remainingOffset_, remainingLimit_);
+    const auto outputSize =
+        std::min(inputSize - remainingOffset_, remainingLimit_);
 
     BufferPtr indices = allocateIndices(outputSize, pool());
-    auto rawIndices = indices->asMutable<vector_size_t>();
+    auto* rawIndices = indices->asMutable<vector_size_t>();
     std::iota(rawIndices, rawIndices + outputSize, remainingOffset_);
 
     auto output = fillOutput(outputSize, indices);
diff --git a/velox/exec/Limit.h b/velox/exec/Limit.h
index a46ab850d36f6..7e38eda64090e 100644
--- a/velox/exec/Limit.h
+++ b/velox/exec/Limit.h
@@ -39,8 +39,8 @@ class Limit : public Operator {
   }
 
  private:
-  int32_t remainingOffset_;
-  int32_t remainingLimit_;
+  int64_t remainingOffset_;
+  int64_t remainingLimit_;
   bool finished_{false};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/LocalPartition.cpp b/velox/exec/LocalPartition.cpp
index 7a2acab98bde0..356e17b91c2be 100644
--- a/velox/exec/LocalPartition.cpp
+++ b/velox/exec/LocalPartition.cpp
@@ -77,16 +77,15 @@ void LocalExchangeQueue::noMoreProducers() {
 
 BlockingReason LocalExchangeQueue::enqueue(
     RowVectorPtr input,
+    int64_t inputBytes,
     ContinueFuture* future) {
-  auto inputBytes = input->estimateFlatSize();
-
   std::vector<ContinuePromise> consumerPromises;
   bool blockedOnConsumer = false;
   bool isClosed = queue_.withWLock([&](auto& queue) {
     if (closed_) {
       return true;
     }
-    queue.push(std::move(input));
+    queue.emplace(std::move(input), inputBytes);
     consumerPromises = std::move(consumerPromises_);
 
     if (memoryManager_->increaseMemoryUsage(future, inputBytes)) {
@@ -139,11 +138,11 @@ BlockingReason LocalExchangeQueue::next(
       return BlockingReason::kWaitForProducer;
     }
 
-    *data = queue.front();
+    int64_t size;
+    std::tie(*data, size) = queue.front();
     queue.pop();
 
-    memoryPromises =
-        memoryManager_->decreaseMemoryUsage((*data)->estimateFlatSize());
+    memoryPromises = memoryManager_->decreaseMemoryUsage(size);
 
     return BlockingReason::kNotBlocked;
   });
@@ -151,8 +150,7 @@ BlockingReason LocalExchangeQueue::next(
   return blockingReason;
 }
 
-bool LocalExchangeQueue::isFinishedLocked(
-    const std::queue<RowVectorPtr>& queue) const {
+bool LocalExchangeQueue::isFinishedLocked(const Queue& queue) const {
   if (closed_) {
     return true;
   }
@@ -174,7 +172,7 @@ void LocalExchangeQueue::close() {
   queue_.withWLock([&](auto& queue) {
     uint64_t freedBytes = 0;
     while (!queue.empty()) {
-      freedBytes += queue.front()->estimateFlatSize();
+      freedBytes += queue.front().second;
       queue.pop();
     }
 
@@ -261,13 +259,12 @@ LocalPartition::LocalPartition(
 
 namespace {
 std::vector<BufferPtr> allocateIndexBuffers(
-    int numBuffers,
-    vector_size_t size,
+    const std::vector<vector_size_t>& sizes,
     memory::MemoryPool* pool) {
   std::vector<BufferPtr> indexBuffers;
-  indexBuffers.reserve(numBuffers);
-  for (auto i = 0; i < numBuffers; i++) {
-    indexBuffers.emplace_back(allocateIndices(size, pool));
+  indexBuffers.reserve(sizes.size());
+  for (auto size : sizes) {
+    indexBuffers.push_back(allocateIndices(size, pool));
   }
   return indexBuffers;
 }
@@ -307,11 +304,10 @@ void LocalPartition::addInput(RowVectorPtr input) {
     child->loadedVector();
   }
 
-  input_ = std::move(input);
-
   if (numPartitions_ == 1) {
     ContinueFuture future;
-    auto blockingReason = queues_[0]->enqueue(input_, &future);
+    auto blockingReason =
+        queues_[0]->enqueue(input, input->retainedSize(), &future);
     if (blockingReason != BlockingReason::kNotBlocked) {
       blockingReasons_.push_back(blockingReason);
       futures_.push_back(std::move(future));
@@ -320,11 +316,11 @@ void LocalPartition::addInput(RowVectorPtr input) {
   }
 
   const auto singlePartition =
-      partitionFunction_->partition(*input_, partitions_);
+      partitionFunction_->partition(*input, partitions_);
   if (singlePartition.has_value()) {
     ContinueFuture future;
-    auto blockingReason =
-        queues_[singlePartition.value()]->enqueue(input_, &future);
+    auto blockingReason = queues_[singlePartition.value()]->enqueue(
+        input, input->retainedSize(), &future);
     if (blockingReason != BlockingReason::kNotBlocked) {
       blockingReasons_.push_back(blockingReason);
       futures_.push_back(std::move(future));
@@ -332,29 +328,33 @@ void LocalPartition::addInput(RowVectorPtr input) {
     return;
   }
 
-  auto numInput = input_->size();
-  auto indexBuffers = allocateIndexBuffers(numPartitions_, numInput, pool());
+  const auto numInput = input->size();
+  std::vector<vector_size_t> maxIndex(numPartitions_, 0);
+  for (auto i = 0; i < numInput; ++i) {
+    ++maxIndex[partitions_[i]];
+  }
+  auto indexBuffers = allocateIndexBuffers(maxIndex, pool());
   auto rawIndices = getRawIndices(indexBuffers);
 
-  std::vector<vector_size_t> maxIndex(numPartitions_, 0);
+  std::fill(maxIndex.begin(), maxIndex.end(), 0);
   for (auto i = 0; i < numInput; ++i) {
     auto partition = partitions_[i];
     rawIndices[partition][maxIndex[partition]] = i;
     ++maxIndex[partition];
   }
 
+  const int64_t totalSize = input->retainedSize();
   for (auto i = 0; i < numPartitions_; i++) {
     auto partitionSize = maxIndex[i];
     if (partitionSize == 0) {
       // Do not enqueue empty partitions.
       continue;
     }
-    indexBuffers[i]->setSize(partitionSize * sizeof(vector_size_t));
     auto partitionData =
-        wrapChildren(input_, partitionSize, std::move(indexBuffers[i]));
-
+        wrapChildren(input, partitionSize, std::move(indexBuffers[i]));
     ContinueFuture future;
-    auto reason = queues_[i]->enqueue(partitionData, &future);
+    auto reason = queues_[i]->enqueue(
+        partitionData, totalSize * partitionSize / numInput, &future);
     if (reason != BlockingReason::kNotBlocked) {
       blockingReasons_.push_back(reason);
       futures_.push_back(std::move(future));
diff --git a/velox/exec/LocalPartition.h b/velox/exec/LocalPartition.h
index 2e47ec85cb713..75d4098a1915c 100644
--- a/velox/exec/LocalPartition.h
+++ b/velox/exec/LocalPartition.h
@@ -67,7 +67,8 @@ class LocalExchangeQueue {
   /// Used by a producer to add data. Returning kNotBlocked if can accept more
   /// data. Otherwise returns kWaitForConsumer and sets future that will be
   /// completed when ready to accept more data.
-  BlockingReason enqueue(RowVectorPtr input, ContinueFuture* future);
+  BlockingReason
+  enqueue(RowVectorPtr input, int64_t inputBytes, ContinueFuture* future);
 
   /// Called by a producer to indicate that no more data will be added.
   void noMoreData();
@@ -89,11 +90,13 @@ class LocalExchangeQueue {
   void close();
 
  private:
-  bool isFinishedLocked(const std::queue<RowVectorPtr>& queue) const;
+  using Queue = std::queue<std::pair<RowVectorPtr, int64_t>>;
+
+  bool isFinishedLocked(const Queue& queue) const;
 
   std::shared_ptr<LocalExchangeMemoryManager> memoryManager_;
   const int partition_;
-  folly::Synchronized<std::queue<RowVectorPtr>> queue_;
+  folly::Synchronized<Queue> queue_;
   // Satisfied when data becomes available or all producers report that they
   // finished producing, e.g. queue_ is not empty or noMoreProducers_ is true
   // and pendingProducers_ is zero.
diff --git a/velox/exec/LocalPlanner.cpp b/velox/exec/LocalPlanner.cpp
index 2c64730d5ebe8..bf99d78e4cf00 100644
--- a/velox/exec/LocalPlanner.cpp
+++ b/velox/exec/LocalPlanner.cpp
@@ -20,6 +20,7 @@
 #include "velox/exec/CallbackSink.h"
 #include "velox/exec/EnforceSingleRow.h"
 #include "velox/exec/Exchange.h"
+#include "velox/exec/Expand.h"
 #include "velox/exec/FilterProject.h"
 #include "velox/exec/GroupId.h"
 #include "velox/exec/HashAggregation.h"
@@ -51,7 +52,7 @@ namespace detail {
 
 /// Returns true if source nodes must run in a separate pipeline.
 bool mustStartNewPipeline(
-    std::shared_ptr<const core::PlanNode> planNode,
+    const std::shared_ptr<const core::PlanNode>& planNode,
     int sourceId) {
   if (auto localMerge =
           std::dynamic_pointer_cast<const core::LocalMergeNode>(planNode)) {
@@ -69,7 +70,8 @@ bool mustStartNewPipeline(
 
 OperatorSupplier makeConsumerSupplier(ConsumerSupplier consumerSupplier) {
   if (consumerSupplier) {
-    return [consumerSupplier](int32_t operatorId, DriverCtx* ctx) {
+    return [consumerSupplier = std::move(consumerSupplier)](
+               int32_t operatorId, DriverCtx* ctx) {
       return std::make_unique<CallbackSink>(
           operatorId, ctx, consumerSupplier());
     };
@@ -87,7 +89,7 @@ OperatorSupplier makeConsumerSupplier(
 
       auto consumer = [mergeSource](
                           RowVectorPtr input, ContinueFuture* future) {
-        return mergeSource->enqueue(input, future);
+        return mergeSource->enqueue(std::move(input), future);
       };
       return std::make_unique<CallbackSink>(operatorId, ctx, consumer);
     };
@@ -122,7 +124,7 @@ OperatorSupplier makeConsumerSupplier(
       auto source =
           ctx->task->getMergeJoinSource(ctx->splitGroupId, planNodeId);
       auto consumer = [source](RowVectorPtr input, ContinueFuture* future) {
-        return source->enqueue(input, future);
+        return source->enqueue(std::move(input), future);
       };
       return std::make_unique<CallbackSink>(operatorId, ctx, consumer);
     };
@@ -140,11 +142,11 @@ void plan(
   if (!currentPlanNodes) {
     driverFactories->push_back(std::make_unique<DriverFactory>());
     currentPlanNodes = &driverFactories->back()->planNodes;
-    driverFactories->back()->consumerSupplier = consumerSupplier;
+    driverFactories->back()->consumerSupplier = std::move(consumerSupplier);
     driverFactories->back()->consumerNode = consumerNode;
   }
 
-  auto sources = planNode->sources();
+  const auto& sources = planNode->sources();
   if (sources.empty()) {
     driverFactories->back()->inputDriver = true;
   } else {
@@ -222,6 +224,12 @@ uint32_t maxDrivers(
     } else if (std::dynamic_pointer_cast<const core::MergeJoinNode>(node)) {
       // Merge join must run single-threaded.
       return 1;
+    } else if (
+        auto join = std::dynamic_pointer_cast<const core::HashJoinNode>(node)) {
+      // Right semi project doesn't support multi-threaded execution.
+      if (join->isRightSemiProjectJoin()) {
+        return 1;
+      }
     } else if (
         auto tableWrite =
             std::dynamic_pointer_cast<const core::TableWriteNode>(node)) {
@@ -243,7 +251,7 @@ uint32_t maxDrivers(
             *result,
             0,
             "maxDrivers must be greater than 0. Plan node: {}",
-            node->toString())
+            node->toString());
         if (*result == 1) {
           return 1;
         }
@@ -381,6 +389,23 @@ void LocalPlanner::markMixedJoinBridges(
   }
 }
 
+namespace {
+
+// If the upstream is partial limit, downstream is final limit and we want to
+// flush as soon as we can to reach the limit and do as little work as possible.
+bool eagerFlush(const core::PlanNode& node) {
+  if (auto* limit = dynamic_cast<const core::LimitNode*>(&node)) {
+    return limit->isPartial() && limit->offset() + limit->count() < 10'000;
+  }
+  if (node.sources().empty()) {
+    return false;
+  }
+  // Follow the first source, which is driving the output.
+  return eagerFlush(*node.sources()[0]);
+}
+
+} // namespace
+
 std::shared_ptr<Driver> DriverFactory::createDriver(
     std::unique_ptr<DriverCtx> ctx,
     std::shared_ptr<ExchangeClient> exchangeClient,
@@ -457,7 +482,7 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
             std::dynamic_pointer_cast<const core::PartitionedOutputNode>(
                 planNode)) {
       operators.push_back(std::make_unique<PartitionedOutput>(
-          id, ctx.get(), partitionedOutputNode));
+          id, ctx.get(), partitionedOutputNode, eagerFlush(*planNode)));
     } else if (
         auto joinNode =
             std::dynamic_pointer_cast<const core::HashJoinNode>(planNode)) {
@@ -471,15 +496,17 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
     } else if (
         auto aggregationNode =
             std::dynamic_pointer_cast<const core::AggregationNode>(planNode)) {
-      if (!aggregationNode->preGroupedKeys().empty() &&
-          aggregationNode->preGroupedKeys().size() ==
-              aggregationNode->groupingKeys().size()) {
+      if (aggregationNode->isPreGrouped()) {
         operators.push_back(std::make_unique<StreamingAggregation>(
             id, ctx.get(), aggregationNode));
       } else {
         operators.push_back(
             std::make_unique<HashAggregation>(id, ctx.get(), aggregationNode));
       }
+    } else if (
+        auto expandNode =
+            std::dynamic_pointer_cast<const core::ExpandNode>(planNode)) {
+      operators.push_back(std::make_unique<Expand>(id, ctx.get(), expandNode));
     } else if (
         auto groupIdNode =
             std::dynamic_pointer_cast<const core::GroupIdNode>(planNode)) {
diff --git a/velox/exec/MemoryReclaimer.cpp b/velox/exec/MemoryReclaimer.cpp
index ba1bf478a366d..8b64b94989077 100644
--- a/velox/exec/MemoryReclaimer.cpp
+++ b/velox/exec/MemoryReclaimer.cpp
@@ -51,11 +51,126 @@ void MemoryReclaimer::leaveArbitration() noexcept {
   driver->task()->leaveSuspended(driver->state());
 }
 
+void MemoryReclaimer::abort(
+    memory::MemoryPool* pool,
+    const std::exception_ptr& error) {
+  if (pool->kind() == memory::MemoryPool::Kind::kLeaf) {
+    return;
+  }
+  pool->visitChildren([&](memory::MemoryPool* child) {
+    auto* reclaimer = child->reclaimer();
+    if (reclaimer != nullptr) {
+      reclaimer->abort(child, error);
+    }
+    return true;
+  });
+}
+
+/*static*/ std::unique_ptr<memory::MemoryReclaimer>
+ParallelMemoryReclaimer::create(folly::Executor* executor) {
+  return std::unique_ptr<memory::MemoryReclaimer>(
+      new ParallelMemoryReclaimer(executor));
+}
+
+ParallelMemoryReclaimer::ParallelMemoryReclaimer(folly::Executor* executor)
+    : executor_(executor) {}
+
+uint64_t ParallelMemoryReclaimer::reclaim(
+    memory::MemoryPool* pool,
+    uint64_t targetBytes,
+    uint64_t maxWaitMs,
+    Stats& stats) {
+  if (executor_ == nullptr) {
+    return memory::MemoryReclaimer::reclaim(
+        pool, targetBytes, maxWaitMs, stats);
+  }
+
+  // Sort the child pools based on their reserved memory and reclaim from the
+  // child pool with most reservation first.
+  struct Candidate {
+    std::shared_ptr<memory::MemoryPool> pool;
+    int64_t reclaimableBytes;
+  };
+  std::vector<Candidate> candidates;
+  {
+    std::shared_lock guard{pool->poolMutex_};
+    candidates.reserve(pool->children_.size());
+    for (auto& entry : pool->children_) {
+      auto child = entry.second.lock();
+      if (child != nullptr) {
+        const int64_t reclaimableBytes = child->reclaimableBytes().value_or(0);
+        candidates.push_back(Candidate{std::move(child), reclaimableBytes});
+      }
+    }
+  }
+  struct ReclaimResult {
+    const uint64_t reclaimedBytes{0};
+    const Stats stats;
+    const std::exception_ptr error{nullptr};
+
+    explicit ReclaimResult(std::exception_ptr _error)
+        : reclaimedBytes(0), error(std::move(_error)) {}
+
+    ReclaimResult(uint64_t _reclaimedBytes, Stats&& _stats)
+        : reclaimedBytes(_reclaimedBytes),
+          stats(std::move(_stats)),
+          error(nullptr) {}
+  };
+
+  std::vector<std::shared_ptr<AsyncSource<ReclaimResult>>> reclaimTasks;
+  for (const auto& candidate : candidates) {
+    if (candidate.reclaimableBytes == 0) {
+      continue;
+    }
+    reclaimTasks.push_back(memory::createAsyncMemoryReclaimTask<ReclaimResult>(
+        [&, reclaimPool = candidate.pool]() {
+          try {
+            Stats reclaimStats;
+            const auto bytes =
+                reclaimPool->reclaim(targetBytes, maxWaitMs, reclaimStats);
+            return std::make_unique<ReclaimResult>(
+                bytes, std::move(reclaimStats));
+          } catch (const std::exception& e) {
+            VELOX_MEM_LOG(ERROR) << "Reclaim from memory pool " << pool->name()
+                                 << " failed: " << e.what();
+            // The exception is captured and thrown by the caller.
+            return std::make_unique<ReclaimResult>(std::current_exception());
+          }
+        }));
+    if (reclaimTasks.size() > 1) {
+      executor_->add([source = reclaimTasks.back()]() { source->prepare(); });
+    }
+  }
+
+  auto syncGuard = folly::makeGuard([&]() {
+    for (auto& reclaimTask : reclaimTasks) {
+      // We consume the result for the pending tasks. This is a cleanup in the
+      // guard and must not throw. The first error is already captured before
+      // this runs.
+      try {
+        reclaimTask->move();
+      } catch (const std::exception&) {
+      }
+    }
+  });
+
+  uint64_t reclaimedBytes{0};
+  for (auto& reclaimTask : reclaimTasks) {
+    const auto result = reclaimTask->move();
+    if (result->error) {
+      std::rethrow_exception(result->error);
+    }
+    stats += result->stats;
+    reclaimedBytes += result->reclaimedBytes;
+  }
+  return reclaimedBytes;
+}
+
 void memoryArbitrationStateCheck(memory::MemoryPool& pool) {
   const auto* driverThreadCtx = driverThreadContext();
   if (driverThreadCtx != nullptr) {
     Driver* driver = driverThreadCtx->driverCtx.driver;
-    if (!driver->state().isSuspended) {
+    if (!driver->state().suspended()) {
       VELOX_FAIL(
           "Driver thread is not suspended under memory arbitration processing: {}, request memory pool: {}",
           driver->toString(),
diff --git a/velox/exec/MemoryReclaimer.h b/velox/exec/MemoryReclaimer.h
index a4e3d479e25a8..7acc41cbed70d 100644
--- a/velox/exec/MemoryReclaimer.h
+++ b/velox/exec/MemoryReclaimer.h
@@ -16,11 +16,10 @@
 
 #pragma once
 
-#include "velox/common/base/Exceptions.h"
 #include "velox/common/memory/MemoryArbitrator.h"
 
 namespace facebook::velox::exec {
-/// Provides the default memory reclaimer implementation for velox task
+/// Provides the default leaf memory reclaimer implementation for velox task
 /// execution.
 class MemoryReclaimer : public memory::MemoryReclaimer {
  public:
@@ -32,10 +31,35 @@ class MemoryReclaimer : public memory::MemoryReclaimer {
 
   void leaveArbitration() noexcept override;
 
+  void abort(memory::MemoryPool* pool, const std::exception_ptr& error)
+      override;
+
  protected:
   MemoryReclaimer() = default;
 };
 
+/// Provides the parallel memory reclaimer implementation for velox task
+/// execution. It parallelize the memory reclamation from all its child memory
+/// pools.
+class ParallelMemoryReclaimer : public memory::MemoryReclaimer {
+ public:
+  virtual ~ParallelMemoryReclaimer() = default;
+
+  static std::unique_ptr<memory::MemoryReclaimer> create(
+      folly::Executor* executor);
+
+  uint64_t reclaim(
+      memory::MemoryPool* pool,
+      uint64_t targetBytes,
+      uint64_t maxWaitMs,
+      Stats& stats) override;
+
+ protected:
+  explicit ParallelMemoryReclaimer(folly::Executor* executor);
+
+  folly::Executor* const executor_{nullptr};
+};
+
 /// Callback used by memory arbitration to check if a driver thread under memory
 /// arbitration has been put in suspension state. This is to prevent arbitration
 /// deadlock as the arbitrator might reclaim memory from the task of the driver
diff --git a/velox/exec/Merge.cpp b/velox/exec/Merge.cpp
index 85eeb2dd6607d..dcca6d28e2c4f 100644
--- a/velox/exec/Merge.cpp
+++ b/velox/exec/Merge.cpp
@@ -192,8 +192,7 @@ bool SourceStream::operator<(const MergeStream& other) const {
   for (auto i = 0; i < sortingKeys_.size(); ++i) {
     const auto& [_, compareFlags] = sortingKeys_[i];
     VELOX_DCHECK(
-        compareFlags.nullHandlingMode == CompareFlags::NullHandlingMode::NoStop,
-        "not supported null handling mode");
+        compareFlags.nullAsValue(), "not supported null handling mode");
     if (auto result = keyColumns_[i]
                           ->compare(
                               otherCursor.keyColumns_[i],
@@ -325,20 +324,38 @@ BlockingReason MergeExchange::addMergeSources(ContinueFuture* future) {
         auto remoteSplit = std::dynamic_pointer_cast<RemoteConnectorSplit>(
             split.connectorSplit);
         VELOX_CHECK(remoteSplit, "Wrong type of split");
-        auto* pool = operatorCtx_->task()->addMergeSourcePool(
-            operatorCtx_->planNodeId(),
-            operatorCtx_->driverCtx()->pipelineId,
-            numSplits_);
-        sources_.emplace_back(MergeSource::createMergeExchangeSource(
-            this,
-            remoteSplit->taskId,
-            operatorCtx_->task()->destination(),
-            pool));
-        ++numSplits_;
+        remoteSourceTaskIds_.push_back(remoteSplit->taskId);
       } else {
         noMoreSplits_ = true;
+        if (!remoteSourceTaskIds_.empty()) {
+          const auto maxMergeExchangeBufferSize =
+              operatorCtx_->driverCtx()
+                  ->queryConfig()
+                  .maxMergeExchangeBufferSize();
+          const auto maxQueuedBytesPerSource = std::min<int64_t>(
+              std::max<int64_t>(
+                  maxMergeExchangeBufferSize / remoteSourceTaskIds_.size(),
+                  MergeSource::kMaxQueuedBytesLowerLimit),
+              MergeSource::kMaxQueuedBytesUpperLimit);
+          for (uint32_t remoteSourceIndex = 0;
+               remoteSourceIndex < remoteSourceTaskIds_.size();
+               ++remoteSourceIndex) {
+            auto* pool = operatorCtx_->task()->addMergeSourcePool(
+                operatorCtx_->planNodeId(),
+                operatorCtx_->driverCtx()->pipelineId,
+                remoteSourceIndex);
+            sources_.emplace_back(MergeSource::createMergeExchangeSource(
+                this,
+                remoteSourceTaskIds_[remoteSourceIndex],
+                operatorCtx_->task()->destination(),
+                maxQueuedBytesPerSource,
+                pool,
+                operatorCtx_->task()->queryCtx()->executor()));
+          }
+        }
         // TODO Delay this call until all input data has been processed.
-        operatorCtx_->task()->multipleSplitsFinished(numSplits_);
+        operatorCtx_->task()->multipleSplitsFinished(
+            false, remoteSourceTaskIds_.size(), 0);
         return BlockingReason::kNotBlocked;
       }
     } else {
diff --git a/velox/exec/Merge.h b/velox/exec/Merge.h
index 455b5ad82f847..b33780613fb74 100644
--- a/velox/exec/Merge.h
+++ b/velox/exec/Merge.h
@@ -59,7 +59,7 @@ class Merge : public SourceOperator {
   void initializeTreeOfLosers();
 
   /// Maximum number of rows in the output batch.
-  const uint32_t outputBatchSize_;
+  const vector_size_t outputBatchSize_;
 
   std::vector<std::pair<column_index_t, CompareFlags>> sortingKeys_;
 
@@ -196,7 +196,8 @@ class MergeExchange : public Merge {
 
  private:
   bool noMoreSplits_ = false;
-  size_t numSplits_{0}; // Number of splits we took to process so far.
+  // Task Ids from all the splits we took to process so far.
+  std::vector<std::string> remoteSourceTaskIds_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/MergeJoin.cpp b/velox/exec/MergeJoin.cpp
index e48b6b6e03b22..438d7cb87689c 100644
--- a/velox/exec/MergeJoin.cpp
+++ b/velox/exec/MergeJoin.cpp
@@ -35,8 +35,9 @@ MergeJoin::MergeJoin(
       numKeys_{joinNode->leftKeys().size()},
       joinNode_(joinNode) {
   VELOX_USER_CHECK(
-      joinNode_->isInnerJoin() || joinNode_->isLeftJoin(),
-      "Merge join supports only inner and left joins. Other join types are not supported yet.");
+      core::MergeJoinNode::isSupported(joinNode_->joinType()),
+      "The join type is not supported by merge join: ",
+      joinTypeName(joinNode_->joinType()));
 }
 
 void MergeJoin::initialize() {
@@ -64,6 +65,12 @@ void MergeJoin::initialize() {
     }
   }
 
+  if (joinNode_->isRightSemiFilterJoin()) {
+    VELOX_USER_CHECK(
+        leftProjections_.empty(),
+        "The left side projections should be empty for right semi join");
+  }
+
   for (auto i = 0; i < rightType->size(); ++i) {
     auto name = rightType->nameOf(i);
     auto outIndex = outputType_->getChildIdxIfExists(name);
@@ -72,13 +79,25 @@ void MergeJoin::initialize() {
     }
   }
 
+  if (joinNode_->isLeftSemiFilterJoin()) {
+    VELOX_USER_CHECK(
+        rightProjections_.empty(),
+        "The right side projections should be empty for left semi join");
+  }
+
   if (joinNode_->filter()) {
     initializeFilter(joinNode_->filter(), leftType, rightType);
 
-    if (joinNode_->isLeftJoin()) {
-      leftJoinTracker_ = LeftJoinTracker(outputBatchSize_, pool());
+    if (joinNode_->isLeftJoin() || joinNode_->isAntiJoin() ||
+        joinNode_->isRightJoin() || joinNode_->isFullJoin()) {
+      joinTracker_ = JoinTracker(outputBatchSize_, pool());
     }
+  } else if (joinNode_->isAntiJoin()) {
+    // Anti join needs to track the left side rows that have no match on the
+    // right.
+    joinTracker_ = JoinTracker(outputBatchSize_, pool());
   }
+
   joinNode_.reset();
 }
 
@@ -103,15 +122,19 @@ void MergeJoin::initializeFilter(
   // columns of that side of the join to the output of the join; 'filters'
   // specifies the mapping from input columns to the 'filterInput_' for columns
   // that are not projected to the output.
+  //
   // This function checks whether the column is projected to the output and if
   // so adds an entry to 'filterInputToOutputChannel_'. Otherwise, adds an entry
   // to 'filters'.
-  // At the end of the loop each column used in a filter appears either in
-  // filterInputToOutputChannel_ (in case the column is projected to the join
-  // output), filterLeftInputs_ (in case the column is not projected to the join
-  // output and it comes from the left side of the join), filterRightInputs_ (in
-  // case the column is not projected to the join output and it comes from the
-  // right side of the join).
+  //
+  // At the end of the loop, each column used in a filter appears either in:
+  //
+  //  - filterInputToOutputChannel_: in case the column is projected to the join
+  //  output;
+  //  - filterLeftInputs_: in case the column is not projected to the join
+  //  output and it comes from the left side of the join;
+  //  - filterRightInputs_: in case the column is not projected to the join
+  //  output and it comes from the right side of the join.
   auto addChannel = [&](column_index_t channel,
                         const std::vector<IdentityProjection>& outputs,
                         std::vector<IdentityProjection>& filters,
@@ -160,6 +183,9 @@ BlockingReason MergeJoin::isBlocked(ContinueFuture* future) {
 }
 
 bool MergeJoin::needsInput() const {
+  if (isRightJoin(joinType_)) {
+    return (input_ == nullptr || rightInput_ == nullptr);
+  }
   return input_ == nullptr;
 }
 
@@ -167,8 +193,8 @@ void MergeJoin::addInput(RowVectorPtr input) {
   input_ = std::move(input);
   index_ = 0;
 
-  if (leftJoinTracker_) {
-    leftJoinTracker_->resetLastVector();
+  if (joinTracker_) {
+    joinTracker_->resetLastVector();
   }
 }
 
@@ -181,10 +207,23 @@ int32_t MergeJoin::compare(
     const RowVectorPtr& otherBatch,
     vector_size_t otherIndex) {
   for (auto i = 0; i < keys.size(); ++i) {
+    CompareFlags compareFlags = {
+        .equalsOnly = true,
+        .nullHandlingMode =
+            CompareFlags::NullHandlingMode::kNullAsIndeterminate};
     auto compare = batch->childAt(keys[i])->compare(
-        otherBatch->childAt(otherKeys[i]).get(), index, otherIndex);
-    if (compare != 0) {
-      return compare;
+        otherBatch->childAt(otherKeys[i]).get(),
+        index,
+        otherIndex,
+        compareFlags);
+
+    // Comparing null with anything will return std::nullopt.
+    if (!compare.has_value()) {
+      // The SQL semantics of Presto and Spark will always return false if
+      // comparing a NULL value with any other value.
+      return -1;
+    } else if (compare.value() != 0) {
+      return compare.value();
     }
   }
 
@@ -246,78 +285,198 @@ void copyRow(
 void MergeJoin::addOutputRowForLeftJoin(
     const RowVectorPtr& left,
     vector_size_t leftIndex) {
-  copyRow(left, leftIndex, output_, outputSize_, leftProjections_);
+  VELOX_USER_CHECK(
+      isLeftJoin(joinType_) || isAntiJoin(joinType_) || isFullJoin(joinType_));
+  rawLeftIndices_[outputSize_] = leftIndex;
 
   for (const auto& projection : rightProjections_) {
     const auto& target = output_->childAt(projection.outputChannel);
     target->setNull(outputSize_, true);
   }
 
-  if (leftJoinTracker_) {
+  if (joinTracker_) {
     // Record left-side row with no match on the right side.
-    leftJoinTracker_->addMiss(outputSize_);
+    joinTracker_->addMiss(outputSize_);
+  }
+
+  ++outputSize_;
+}
+
+void MergeJoin::addOutputRowForRightJoin(
+    const RowVectorPtr& right,
+    vector_size_t rightIndex) {
+  VELOX_USER_CHECK(isRightJoin(joinType_) || isFullJoin(joinType_));
+  rawRightIndices_[outputSize_] = rightIndex;
+
+  for (const auto& projection : leftProjections_) {
+    const auto& target = output_->childAt(projection.outputChannel);
+    target->setNull(outputSize_, true);
+  }
+
+  if (joinTracker_) {
+    // Record right-side row with no match on the left side.
+    joinTracker_->addMiss(outputSize_);
   }
 
   ++outputSize_;
 }
 
+void MergeJoin::flattenRightProjections() {
+  auto& children = output_->children();
+
+  for (const auto& projection : rightProjections_) {
+    auto& currentVector = children[projection.outputChannel];
+    auto newFlat = BaseVector::create(
+        currentVector->type(), outputBatchSize_, operatorCtx_->pool());
+    newFlat->copy(currentVector.get(), 0, 0, outputSize_);
+    children[projection.outputChannel] = std::move(newFlat);
+  }
+  isRightFlattened_ = true;
+}
+
 void MergeJoin::addOutputRow(
     const RowVectorPtr& left,
     vector_size_t leftIndex,
     const RowVectorPtr& right,
     vector_size_t rightIndex) {
-  copyRow(left, leftIndex, output_, outputSize_, leftProjections_);
-  copyRow(right, rightIndex, output_, outputSize_, rightProjections_);
+  // All left side projections share the same dictionary indices (leftIndices_).
+  rawLeftIndices_[outputSize_] = leftIndex;
+
+  // The right side projections can be a dictionary, of flat in case they
+  // crossed a buffer boundary. In the latter case, row values need to be
+  // copied.
+  if (!isRightFlattened_) {
+    // All right side projections share the same dictionary indices
+    // (rightIndices_).
+    rawRightIndices_[outputSize_] = rightIndex;
+  } else {
+    copyRow(right, rightIndex, output_, outputSize_, rightProjections_);
+  }
 
   if (filter_) {
     copyRow(left, leftIndex, filterInput_, outputSize_, filterLeftInputs_);
     copyRow(right, rightIndex, filterInput_, outputSize_, filterRightInputs_);
 
-    if (leftJoinTracker_) {
-      // Record left-side row with a match on the right-side.
-      leftJoinTracker_->addMatch(left, leftIndex, outputSize_);
+    if (joinTracker_) {
+      if (isRightJoin(joinType_)) {
+        // Record right-side row with a match on the left-side.
+        joinTracker_->addMatch(right, rightIndex, outputSize_);
+      } else {
+        // Record left-side row with a match on the right-side.
+        joinTracker_->addMatch(left, leftIndex, outputSize_);
+      }
     }
   }
 
+  // Anti join needs to track the left side rows that have no match on the
+  // right.
+  if (isAntiJoin(joinType_)) {
+    VELOX_CHECK(joinTracker_);
+    // Record left-side row with a match on the right-side.
+    joinTracker_->addMatch(left, leftIndex, outputSize_);
+  }
+
   ++outputSize_;
 }
 
-void MergeJoin::prepareOutput() {
-  if (output_ == nullptr) {
-    std::vector<VectorPtr> localColumns(outputType_->size());
-    for (auto i = 0; i < outputType_->size(); ++i) {
-      localColumns[i] = BaseVector::create(
-          outputType_->childAt(i), outputBatchSize_, operatorCtx_->pool());
+bool MergeJoin::prepareOutput(
+    const RowVectorPtr& newLeft,
+    const RowVectorPtr& right) {
+  // If there is already an allocated output_, check if we can use it.
+  if (output_ != nullptr) {
+    // If there is a new left, we can't continue using it as the old one is the
+    // base for the current left dictionary.
+    if (newLeft != currentLeft_) {
+      return true;
     }
 
-    output_ = std::make_shared<RowVector>(
-        operatorCtx_->pool(),
-        outputType_,
-        nullptr,
-        outputBatchSize_,
-        std::move(localColumns));
-    outputSize_ = 0;
-
-    if (filterInput_ != nullptr) {
-      for (auto i = 0; i < filterInputType_->size(); ++i) {
-        auto& child = filterInput_->childAt(i);
-        // If 'child' is also projected to output, make 'child' to use the same
-        // shared pointer to the output column.
-        if (filterInputToOutputChannel_.find(i) !=
-            filterInputToOutputChannel_.end()) {
-          child = output_->childAt(filterInputToOutputChannel_[i]);
-          continue;
-        }
+    if (isRightJoin(joinType_) && right != currentRight_) {
+      return true;
+    }
 
-        // When filterInput_ contains array or map columns that are not
-        // projected to output, their child vectors(elements, keys and values)
-        // keep growing after each call to 'copyRow'. Call prepareForReuse() to
-        // reset non-reusable buffers and updates child vectors for reusing.
-        if (child->typeKind() == TypeKind::ARRAY) {
-          child->as<ArrayVector>()->prepareForReuse();
-        } else if (child->typeKind() == TypeKind::MAP) {
-          child->as<MapVector>()->prepareForReuse();
-        }
+    // If there is a new right, we need to flatten the dictionary.
+    if (!isRightFlattened_ && right && currentRight_ != right) {
+      flattenRightProjections();
+    }
+    return false;
+  }
+
+  // If output is nullptr, first allocate dictionary indices for the left and
+  // right side projections.
+  leftIndices_ = allocateIndices(outputBatchSize_, pool());
+  rawLeftIndices_ = leftIndices_->asMutable<vector_size_t>();
+
+  rightIndices_ = allocateIndices(outputBatchSize_, pool());
+  rawRightIndices_ = rightIndices_->asMutable<vector_size_t>();
+
+  // Create left side projection outputs.
+  std::vector<VectorPtr> localColumns(outputType_->size());
+  if (newLeft == nullptr) {
+    for (const auto& projection : leftProjections_) {
+      localColumns[projection.outputChannel] = BaseVector::create(
+          outputType_->childAt(projection.outputChannel),
+          outputBatchSize_,
+          operatorCtx_->pool());
+    }
+  } else {
+    for (const auto& projection : leftProjections_) {
+      localColumns[projection.outputChannel] = BaseVector::wrapInDictionary(
+          {},
+          leftIndices_,
+          outputBatchSize_,
+          newLeft->childAt(projection.inputChannel));
+    }
+  }
+  currentLeft_ = newLeft;
+
+  // Create right side projection outputs.
+  if (right == nullptr) {
+    for (const auto& projection : rightProjections_) {
+      localColumns[projection.outputChannel] = BaseVector::create(
+          outputType_->childAt(projection.outputChannel),
+          outputBatchSize_,
+          operatorCtx_->pool());
+    }
+    isRightFlattened_ = true;
+  } else {
+    for (const auto& projection : rightProjections_) {
+      localColumns[projection.outputChannel] = BaseVector::wrapInDictionary(
+          {},
+          rightIndices_,
+          outputBatchSize_,
+          right->childAt(projection.inputChannel));
+    }
+    isRightFlattened_ = false;
+  }
+  currentRight_ = right;
+
+  output_ = std::make_shared<RowVector>(
+      operatorCtx_->pool(),
+      outputType_,
+      nullptr,
+      outputBatchSize_,
+      std::move(localColumns));
+  outputSize_ = 0;
+
+  if (filterInput_ != nullptr) {
+    for (auto i = 0; i < filterInputType_->size(); ++i) {
+      auto& child = filterInput_->childAt(i);
+      // If 'child' is also projected to output, make 'child' to use the same
+      // shared pointer to the output column.
+      if (filterInputToOutputChannel_.find(i) !=
+          filterInputToOutputChannel_.end()) {
+        child = output_->childAt(filterInputToOutputChannel_[i]);
+        continue;
+      }
+
+      // When filterInput_ contains array or map columns that are not
+      // projected to output, their child vectors(elements, keys and values)
+      // keep growing after each call to 'copyRow'. Call prepareForReuse() to
+      // reset non-reusable buffers and updates child vectors for reusing.
+      if (child->typeKind() == TypeKind::ARRAY) {
+        child->as<ArrayVector>()->prepareForReuse();
+      } else if (child->typeKind() == TypeKind::MAP) {
+        child->as<MapVector>()->prepareForReuse();
       }
     }
   }
@@ -344,11 +503,10 @@ void MergeJoin::prepareOutput() {
         outputBatchSize_,
         std::move(inputs));
   }
+  return false;
 }
 
 bool MergeJoin::addToOutput() {
-  prepareOutput();
-
   size_t firstLeftBatch;
   vector_size_t leftStartIndex;
   if (leftMatch_->cursor) {
@@ -383,8 +541,31 @@ bool MergeJoin::addToOutput() {
         auto rightEnd =
             r == numRights - 1 ? rightMatch_->endIndex : right->size();
 
+        if (prepareOutput(left, right)) {
+          output_->resize(outputSize_);
+          leftMatch_->setCursor(l, i);
+          rightMatch_->setCursor(r, rightStart);
+          return true;
+        }
+
+        // TODO: Since semi joins only require determining if there is at least
+        // one match on the other side, we could explore specialized algorithms
+        // or data structures that short-circuit the join process once a match
+        // is found.
+        if (isLeftSemiFilterJoin(joinType_) ||
+            isRightSemiFilterJoin(joinType_)) {
+          // LeftSemiFilter produce each row from the left at most once.
+          // RightSemiFilter produce each row from the right at most once.
+          rightEnd = rightStart + 1;
+        }
+
         for (auto j = rightStart; j < rightEnd; ++j) {
           if (outputSize_ == outputBatchSize_) {
+            // If we run out of space in the current output_, we will need to
+            // produce a buffer and continue processing left later. In this
+            // case, we cannot leave left as a lazy vector, since we cannot have
+            // two dictionaries wrapping the same lazy vector.
+            loadColumns(currentLeft_, *operatorCtx_->execCtx());
             leftMatch_->setCursor(l, i);
             rightMatch_->setCursor(r, j);
             return true;
@@ -398,6 +579,11 @@ bool MergeJoin::addToOutput() {
   leftMatch_.reset();
   rightMatch_.reset();
 
+  // If the current key match finished, but there are still records to be
+  // processed in the left, we need to load lazy vectors (see comment above).
+  if (input_ && index_ != input_->size()) {
+    loadColumns(currentLeft_, *operatorCtx_->execCtx());
+  }
   return outputSize_ == outputBatchSize_;
 }
 
@@ -423,6 +609,32 @@ vector_size_t firstNonNull(
 }
 } // namespace
 
+RowVectorPtr MergeJoin::filterOutputForAntiJoin(const RowVectorPtr& output) {
+  const auto numRows = output->size();
+  const auto& filterRows = joinTracker_->matchingRows(numRows);
+  const auto numPassed = numRows - filterRows.countSelected();
+  if (numPassed == 0) {
+    return nullptr;
+  }
+  if (numPassed == numRows) {
+    // All rows passed.
+    return output;
+  }
+
+  BufferPtr indices = allocateIndices(numPassed, pool());
+  auto* rawIndices = indices->asMutable<vector_size_t>();
+  size_t index{0};
+  for (auto i = 0; i < numRows; ++i) {
+    if (!filterRows.isValid(i)) {
+      rawIndices[index++] = i;
+    }
+  }
+  VELOX_CHECK_EQ(index, numPassed);
+
+  // Some, but not all rows passed.
+  return wrap(numPassed, indices, output);
+}
+
 RowVectorPtr MergeJoin::getOutput() {
   // Make sure to have is-blocked or needs-input as true if returning null
   // output. Otherwise, Driver assumes the operator is finished.
@@ -446,6 +658,14 @@ RowVectorPtr MergeJoin::getOutput() {
 
         // No rows survived the filter. Get more rows.
         continue;
+      } else if (isAntiJoin(joinType_)) {
+        output = filterOutputForAntiJoin(output);
+        if (output) {
+          return output;
+        }
+
+        // No rows survived the filter for anti join. Get more rows.
+        continue;
       } else {
         return output;
       }
@@ -466,10 +686,14 @@ RowVectorPtr MergeJoin::getOutput() {
         }
 
         if (rightInput_) {
-          rightIndex_ = firstNonNull(rightInput_, rightKeys_);
-          if (rightIndex_ == rightInput_->size()) {
-            // Ran out of rows on the right side.
-            rightInput_ = nullptr;
+          if (isFullJoin(joinType_)) {
+            rightIndex_ = 0;
+          } else {
+            rightIndex_ = firstNonNull(rightInput_, rightKeys_);
+            if (rightIndex_ == rightInput_->size()) {
+              // Ran out of rows on the right side.
+              rightInput_ = nullptr;
+            }
           }
         } else {
           noMoreRightInput_ = true;
@@ -525,10 +749,14 @@ RowVectorPtr MergeJoin::doGetOutput() {
         return nullptr;
       }
       if (rightMatch_->inputs.back() == rightInput_) {
-        rightIndex_ =
-            firstNonNull(rightInput_, rightKeys_, rightMatch_->endIndex);
-        if (rightIndex_ == rightInput_->size()) {
-          rightInput_ = nullptr;
+        if (isFullJoin(joinType_)) {
+          rightIndex_ = rightMatch_->endIndex;
+        } else {
+          rightIndex_ =
+              firstNonNull(rightInput_, rightKeys_, rightMatch_->endIndex);
+          if (rightIndex_ == rightInput_->size()) {
+            rightInput_ = nullptr;
+          }
         }
       }
     } else if (noMoreRightInput_) {
@@ -551,14 +779,74 @@ RowVectorPtr MergeJoin::doGetOutput() {
   }
 
   if (!input_ || !rightInput_) {
-    if (isLeftJoin(joinType_)) {
+    if (isLeftJoin(joinType_) || isAntiJoin(joinType_)) {
       if (input_ && noMoreRightInput_) {
-        prepareOutput();
+        // If output_ is currently wrapping a different buffer, return it
+        // first.
+        if (prepareOutput(input_, nullptr)) {
+          output_->resize(outputSize_);
+          return std::move(output_);
+        }
         while (true) {
           if (outputSize_ == outputBatchSize_) {
             return std::move(output_);
           }
+          addOutputRowForLeftJoin(input_, index_);
 
+          ++index_;
+          if (index_ == input_->size()) {
+            // Ran out of rows on the left side.
+            input_ = nullptr;
+            return nullptr;
+          }
+        }
+      }
+
+      if (noMoreInput_ && output_) {
+        output_->resize(outputSize_);
+        return std::move(output_);
+      }
+    } else if (isRightJoin(joinType_)) {
+      if (rightInput_ && noMoreInput_) {
+        // If output_ is currently wrapping a different buffer, return it
+        // first.
+        if (prepareOutput(nullptr, rightInput_)) {
+          output_->resize(outputSize_);
+          return std::move(output_);
+        }
+
+        while (true) {
+          if (outputSize_ == outputBatchSize_) {
+            return std::move(output_);
+          }
+
+          addOutputRowForRightJoin(rightInput_, rightIndex_);
+
+          ++rightIndex_;
+          if (rightIndex_ == rightInput_->size()) {
+            // Ran out of rows on the right side.
+            rightInput_ = nullptr;
+            return nullptr;
+          }
+        }
+      }
+
+      if (noMoreRightInput_ && output_) {
+        output_->resize(outputSize_);
+        return std::move(output_);
+      }
+    } else if (isFullJoin(joinType_)) {
+      if (input_ && noMoreRightInput_) {
+        // If output_ is currently wrapping a different buffer, return it
+        // first.
+        if (prepareOutput(input_, nullptr)) {
+          output_->resize(outputSize_);
+          return std::move(output_);
+        }
+        while (true) {
+          if (outputSize_ == outputBatchSize_) {
+            return std::move(output_);
+          }
           addOutputRowForLeftJoin(input_, index_);
 
           ++index_;
@@ -574,6 +862,35 @@ RowVectorPtr MergeJoin::doGetOutput() {
         output_->resize(outputSize_);
         return std::move(output_);
       }
+
+      if (rightInput_ && noMoreInput_) {
+        // If output_ is currently wrapping a different buffer, return it
+        // first.
+        if (prepareOutput(nullptr, rightInput_)) {
+          output_->resize(outputSize_);
+          return std::move(output_);
+        }
+
+        while (true) {
+          if (outputSize_ == outputBatchSize_) {
+            return std::move(output_);
+          }
+
+          addOutputRowForRightJoin(rightInput_, rightIndex_);
+
+          ++rightIndex_;
+          if (rightIndex_ == rightInput_->size()) {
+            // Ran out of rows on the right side.
+            rightInput_ = nullptr;
+            return nullptr;
+          }
+        }
+      }
+
+      if (noMoreRightInput_ && output_) {
+        output_->resize(outputSize_);
+        return std::move(output_);
+      }
     } else {
       if (noMoreInput_ || noMoreRightInput_) {
         if (output_) {
@@ -594,17 +911,24 @@ RowVectorPtr MergeJoin::doGetOutput() {
   for (;;) {
     // Catch up input_ with rightInput_.
     while (compareResult < 0) {
-      if (isLeftJoin(joinType_)) {
-        prepareOutput();
+      if (isLeftJoin(joinType_) || isAntiJoin(joinType_) ||
+          isFullJoin(joinType_)) {
+        // If output_ is currently wrapping a different buffer, return it
+        // first.
+        if (prepareOutput(input_, nullptr)) {
+          output_->resize(outputSize_);
+          return std::move(output_);
+        }
 
         if (outputSize_ == outputBatchSize_) {
           return std::move(output_);
         }
-
         addOutputRowForLeftJoin(input_, index_);
+        ++index_;
+      } else {
+        index_ = firstNonNull(input_, leftKeys_, index_ + 1);
       }
 
-      ++index_;
       if (index_ == input_->size()) {
         // Ran out of rows on the left side.
         input_ = nullptr;
@@ -615,7 +939,24 @@ RowVectorPtr MergeJoin::doGetOutput() {
 
     // Catch up rightInput_ with input_.
     while (compareResult > 0) {
-      rightIndex_ = firstNonNull(rightInput_, rightKeys_, rightIndex_ + 1);
+      if (isRightJoin(joinType_) || isFullJoin(joinType_)) {
+        // If output_ is currently wrapping a different buffer, return it
+        // first.
+        if (prepareOutput(nullptr, rightInput_)) {
+          output_->resize(outputSize_);
+          return std::move(output_);
+        }
+
+        if (outputSize_ == outputBatchSize_) {
+          return std::move(output_);
+        }
+
+        addOutputRowForRightJoin(rightInput_, rightIndex_);
+        ++rightIndex_;
+      } else {
+        rightIndex_ = firstNonNull(rightInput_, rightKeys_, rightIndex_ + 1);
+      }
+
       if (rightIndex_ == rightInput_->size()) {
         // Ran out of rows on the right side.
         rightInput_ = nullptr;
@@ -666,7 +1007,12 @@ RowVectorPtr MergeJoin::doGetOutput() {
       }
 
       index_ = endIndex;
-      rightIndex_ = firstNonNull(rightInput_, rightKeys_, endRightIndex);
+      if (isFullJoin(joinType_)) {
+        rightIndex_ = endRightIndex;
+      } else {
+        rightIndex_ = firstNonNull(rightInput_, rightKeys_, endRightIndex);
+      }
+
       if (rightIndex_ == rightInput_->size()) {
         // Ran out of rows on the right side.
         rightInput_ = nullptr;
@@ -690,12 +1036,14 @@ RowVectorPtr MergeJoin::doGetOutput() {
 RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
   const auto numRows = output->size();
 
+  RowVectorPtr fullOuterOutput = nullptr;
+
   BufferPtr indices = allocateIndices(numRows, pool());
   auto rawIndices = indices->asMutable<vector_size_t>();
   vector_size_t numPassed = 0;
 
-  if (leftJoinTracker_) {
-    const auto& filterRows = leftJoinTracker_->matchingRows(numRows);
+  if (joinTracker_) {
+    const auto& filterRows = joinTracker_->matchingRows(numRows);
 
     if (!filterRows.hasSelections()) {
       // No matches in the output, no need to evaluate the filter.
@@ -707,11 +1055,74 @@ RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
     // If all matches for a given left-side row fail the filter, add a row to
     // the output with nulls for the right-side columns.
     auto onMiss = [&](auto row) {
-      rawIndices[numPassed++] = row;
+      if (!isAntiJoin(joinType_)) {
+        rawIndices[numPassed++] = row;
+
+        if (isFullJoin(joinType_)) {
+          // For filtered rows, it is necessary to insert additional data
+          // to ensure the result set is complete. Specifically, we
+          // need to generate two records: one record containing the
+          // columns from the left table along with nulls for the
+          // right table, and another record containing the columns
+          // from the right table along with nulls for the left table.
+          // For instance, the current output is filtered based on the condition
+          // t > 1.
+
+          // 1, 1
+          // 2, 2
+          // 3, 3
+
+          // In this scenario, we need to additionally insert a record 1, 1.
+          // Subsequently, we will set the values of the columns on the left to
+          // null and the values of the columns on the right to null as well. By
+          // doing so, we will obtain the final result set.
+
+          // 1,   null
+          // null,  1
+          // 2, 2
+          // 3, 3
+          fullOuterOutput = BaseVector::create<RowVector>(
+              output->type(), output->size() + 1, pool());
+
+          for (auto i = 0; i < row + 1; i++) {
+            for (auto j = 0; j < output->type()->size(); j++) {
+              fullOuterOutput->childAt(j)->copy(
+                  output->childAt(j).get(), i, i, 1);
+            }
+          }
 
-      for (auto& projection : rightProjections_) {
-        auto target = output->childAt(projection.outputChannel);
-        target->setNull(row, true);
+          for (auto j = 0; j < output->type()->size(); j++) {
+            fullOuterOutput->childAt(j)->copy(
+                output->childAt(j).get(), row + 1, row, 1);
+          }
+
+          for (auto i = row + 1; i < output->size(); i++) {
+            for (auto j = 0; j < output->type()->size(); j++) {
+              fullOuterOutput->childAt(j)->copy(
+                  output->childAt(j).get(), i + 1, i, 1);
+            }
+          }
+
+          for (auto& projection : leftProjections_) {
+            auto target = fullOuterOutput->childAt(projection.outputChannel);
+            target->setNull(row, true);
+          }
+
+          for (auto& projection : rightProjections_) {
+            auto target = fullOuterOutput->childAt(projection.outputChannel);
+            target->setNull(row + 1, true);
+          }
+        } else if (!isRightJoin(joinType_)) {
+          for (auto& projection : rightProjections_) {
+            auto target = output->childAt(projection.outputChannel);
+            target->setNull(row, true);
+          }
+        } else {
+          for (auto& projection : leftProjections_) {
+            auto target = output->childAt(projection.outputChannel);
+            target->setNull(row, true);
+          }
+        }
       }
     };
 
@@ -720,10 +1131,16 @@ RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
         const bool passed = !decodedFilterResult_.isNullAt(i) &&
             decodedFilterResult_.valueAt<bool>(i);
 
-        leftJoinTracker_->processFilterResult(i, passed, onMiss);
+        joinTracker_->processFilterResult(i, passed, onMiss);
 
-        if (passed) {
-          rawIndices[numPassed++] = i;
+        if (isAntiJoin(joinType_)) {
+          if (!passed) {
+            rawIndices[numPassed++] = i;
+          }
+        } else {
+          if (passed) {
+            rawIndices[numPassed++] = i;
+          }
         }
       } else {
         // This row doesn't have a match on the right side. Keep it
@@ -732,8 +1149,27 @@ RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
       }
     }
 
-    if (!leftMatch_) {
-      leftJoinTracker_->noMoreFilterResults(onMiss);
+    // Every time we start a new left key match, `processFilterResult()` will
+    // check if at least one row from the previous match passed the filter. If
+    // none did, it calls onMiss to add a record with null right projections to
+    // the output.
+    //
+    // Before we leave the current buffer, since we may not have seen the next
+    // left key match yet, the last key match may still be pending to produce a
+    // row (because `processFilterResult()` was not called yet).
+    //
+    // To handle this, we need to call `noMoreFilterResults()` unless the
+    // same current left key match may continue in the next buffer. So there are
+    // two cases to check:
+    //
+    // 1. If leftMatch_ is nullopt, there for sure the next buffer will contain
+    // a different key match.
+    //
+    // 2. leftMatch_ may not be nullopt, but may be related to a different
+    // (subsequent) left key. So we check if the last row in the batch has the
+    // same left row number as the last key match.
+    if (!leftMatch_ || !joinTracker_->isCurrentLeftMatch(numRows - 1)) {
+      joinTracker_->noMoreFilterResults(onMiss);
     }
   } else {
     filterRows_.resize(numRows);
@@ -756,10 +1192,17 @@ RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
 
   if (numPassed == numRows) {
     // All rows passed.
+    if (fullOuterOutput) {
+      return fullOuterOutput;
+    }
     return output;
   }
 
   // Some, but not all rows passed.
+  if (fullOuterOutput) {
+    return wrap(numPassed, indices, fullOuterOutput);
+  }
+
   return wrap(numPassed, indices, output);
 }
 
@@ -771,6 +1214,18 @@ void MergeJoin::evaluateFilter(const SelectivityVector& rows) {
 }
 
 bool MergeJoin::isFinished() {
+  if (isRightJoin(joinType_)) {
+    // If all rows on both the left and right sides match, we must also verify
+    // the 'noMoreInput_' on the left side to ensure that all results are
+    // complete.
+    return noMoreInput_ && noMoreRightInput_ && rightInput_ == nullptr;
+  }
+
+  if (isFullJoin(joinType_)) {
+    return noMoreInput_ && input_ == nullptr && noMoreRightInput_ &&
+        rightInput_ == nullptr;
+  }
+
   return noMoreInput_ && input_ == nullptr;
 }
 
diff --git a/velox/exec/MergeJoin.h b/velox/exec/MergeJoin.h
index 1117c67ad7751..42222f83ae2e5 100644
--- a/velox/exec/MergeJoin.h
+++ b/velox/exec/MergeJoin.h
@@ -20,6 +20,28 @@
 #include "velox/exec/Operator.h"
 
 namespace facebook::velox::exec {
+
+/// The merge join operator assumes both streams, left (from addInput()) and
+/// right (from rightSource), are sorted in ascending order on the join key.
+///
+/// It works by identifying and maintaining a window of rows with key matches
+/// (leftMatch_ and rightMatch_), and outputting a cartesian product of each key
+/// match. Since keys can span multiple vectors, multiple batches from either
+/// side may need to be materialized and kept in memory. Therefore, the memory
+/// requirement is proportional to the size of the longest key match. Once all
+/// output for a particular key match is produced, the respective batches are
+/// discarded.
+///
+/// Output is produced outputBatchSize_ rows at a time.
+///
+/// The merge join operator generally returns dictionaries which are wrapped
+/// around input vectors. The output is aligned to left vectors, and since
+/// dictionaries cannot wrap around more than one vector, at times merge join
+/// may return fewer than outputBatchSize_ rows.
+///
+/// Dictionaries for right projections are optimistically created; we start by
+/// wrapping the current right vector, but if the output happens to span more
+/// than one right vector, it gets copied and flattened.
 class MergeJoin : public Operator {
  public:
   MergeJoin(
@@ -151,9 +173,11 @@ class MergeJoin : public Operator {
       const RowVectorPtr& input,
       const std::vector<column_index_t>& keys);
 
-  /// Initialize 'output_' vector using 'ouputType_' and 'outputBatchSize_' if
-  /// it is null.
-  void prepareOutput();
+  /// Ensures `output_` is ready to receive records via `addOutput()` or
+  /// `addOutputRowForLeftJoin()`. Initialize vectors using `outputBatchSize_`.
+  /// Returns true is the output_ needs to be returned/produced first, and false
+  /// in case it is ready to take records.
+  bool prepareOutput(const RowVectorPtr& left, const RowVectorPtr& right);
 
   // Appends a cartesian product of the current set of matching rows, leftMatch_
   // x rightMatch_, to output_. Returns true if output_ is full. Sets
@@ -164,19 +188,26 @@ class MergeJoin : public Operator {
   // rightMatchCursor_ if output_ filled up before all rows were added.
   bool addToOutput();
 
-  // Adds one row of output by copying values from left and right batches at the
-  // specified rows. Advances outputSize_. Assumes that output_ has room.
+  // Adds one row of output by writing to the indices of the output
+  // dictionaries. By default, this operator returns dictionaries wrapped around
+  // the input columns from the left and right. If `isRightFlattened_`, the
+  // right side projections are copied to the output.
   //
-  // TODO: Copying is inefficient especially for complex type values. Consider
-  // an optimization of using dictionary wrapping when full batch of output can
-  // be produced using single batch of input from the left side and single batch
-  // of input from the right side.
+  // Advances outputSize_. Assumes that dictionary indices in output_ have room.
   void addOutputRow(
       const RowVectorPtr& left,
       vector_size_t leftIndex,
       const RowVectorPtr& right,
       vector_size_t rightIndex);
 
+  // If the right side projected columns in the current output vector happen to
+  // span more than one vector from the right side, they cannot be simply
+  // wrapped in a dictionary and must be flattened.
+  //
+  // TODO: in theory they can be copied and turned into a dictionary, but this
+  // logic is more involved.
+  void flattenRightProjections();
+
   /// Adds one row of output for a left-side row with no right-side match.
   /// Copies values from the 'leftIndex' row of 'left' and fills in nulls
   /// for columns that correspond to the right side.
@@ -184,6 +215,13 @@ class MergeJoin : public Operator {
       const RowVectorPtr& left,
       vector_size_t leftIndex);
 
+  /// Adds one row of output for a right-side row with no left-side match.
+  /// Copies values from the 'rightIndex' row of 'right' and fills in nulls
+  /// for columns that correspond to the right side.
+  void addOutputRowForRightJoin(
+      const RowVectorPtr& right,
+      vector_size_t rightIndex);
+
   /// Evaluates join filter on 'filterInput_' and returns 'output' that contains
   /// a subset of rows on which the filter passed. Returns nullptr if no rows
   /// passed the filter.
@@ -193,22 +231,40 @@ class MergeJoin : public Operator {
   /// the result using 'decodedFilterResult_'.
   void evaluateFilter(const SelectivityVector& rows);
 
-  /// As we populate the results of the left join, we track whether a given
+  /// An anti join is equivalent to a left join that retains only the rows from
+  /// the left side which do not have a corresponding match on the right side.
+  /// When an anti join includes a filter, it is processed using the applyFilter
+  /// method. For an anti join without a filter, we must specifically exclude
+  /// rows from the left side that have a match on the right.
+  RowVectorPtr filterOutputForAntiJoin(const RowVectorPtr& output);
+
+  /// As we populate the results of the join, we track whether a given
   /// output row is a result of a match between left and right sides or a miss.
-  /// We use LeftJoinTracker::addMatch and addMiss methods for that.
+  /// We use JoinTracker::addMatch and addMiss methods for that.
+  ///
+  /// The semantic of the filter is to include at least one left side row in the
+  /// output after filters are applied. Therefore:
   ///
-  /// Once we have a batch of output, we evaluate the filter on a subset of rows
-  /// which correspond to matches between left and right sides. There is no
-  /// point evaluating filters on misses as these need to be included in the
-  /// output regardless of whether filter passes or fails.
+  /// 1. if left was a miss on the right side: just leave the current row as-is
+  /// without even evaluating the filter (it would have to be added even if
+  /// filters failed).
+  ///
+  /// 2. if left was a hit on the side: if at least one row from the key match
+  /// passes the filter, leave them as-is. If none passed, add a new row with
+  /// the right projections null (see `noMoreFilterResults()`).
+  ///
+  /// Specifically, once we have a batch of output, we evaluate the filter on a
+  /// subset of rows which correspond to matches between left and right sides.
+  /// There is no point evaluating filters on misses as these need to be
+  /// included in the output regardless of whether filter passes or fails.
   ///
   /// We also track blocks of consecutive output rows that correspond to the
   /// same left-side row. If the filter passes on at least one row in such a
   /// block, we keep the subset of passing rows. However, if the filter failed
   /// on all rows in such a block, we add one of these rows back and update
   /// build-side columns to null.
-  struct LeftJoinTracker {
-    LeftJoinTracker(vector_size_t numRows, memory::MemoryPool* pool)
+  struct JoinTracker {
+    JoinTracker(vector_size_t numRows, memory::MemoryPool* pool)
         : matchingRows_{numRows, false} {
       leftRowNumbers_ = AlignedBuffer::allocate<vector_size_t>(numRows, pool);
       rawLeftRowNumbers_ = leftRowNumbers_->asMutable<vector_size_t>();
@@ -261,7 +317,7 @@ class MergeJoin : public Operator {
       lastIndex_ = -1;
     }
 
-    /// Called for each row that the filter was evaluated on in order starting
+    /// Called for each row that the filter was evaluated on, in order, starting
     /// with the first row. Calls 'onMiss' if the filter failed on all output
     /// rows that correspond to a single left-side row. Use
     /// 'noMoreFilterResults' to make sure 'onMiss' is called for the last
@@ -288,6 +344,12 @@ class MergeJoin : public Operator {
       }
     }
 
+    /// Returns whether `row` corresponds to the same left key as the last
+    /// left match evaluated.
+    bool isCurrentLeftMatch(vector_size_t row) {
+      return currentLeftRowNumber_ == rawLeftRowNumbers_[row];
+    }
+
     /// Called when all rows from the current output batch are processed and the
     /// next batch of output will start with a new left-side row or there will
     /// be no more batches. Calls 'onMiss' for the last left-side row if the
@@ -336,10 +398,29 @@ class MergeJoin : public Operator {
     bool currentRowPassed_{false};
   };
 
-  std::optional<LeftJoinTracker> leftJoinTracker_{std::nullopt};
+  /// Used to record both left and right join.
+  std::optional<JoinTracker> joinTracker_{std::nullopt};
+
+  // Indices buffer used by the output dictionaries. All projection from the
+  // left share `leftIndices_`, and projections in the right share
+  // `rightIndices_`.
+  BufferPtr leftIndices_;
+  BufferPtr rightIndices_;
+
+  vector_size_t* rawLeftIndices_;
+  vector_size_t* rawRightIndices_;
+
+  // Stores the current left and right vectors being used by the output
+  // dictionaries.
+  RowVectorPtr currentLeft_;
+  RowVectorPtr currentRight_;
+
+  // If the right side projections have been flattened or they are still
+  // dictionaries wrapped around the right side input.
+  bool isRightFlattened_{false};
 
   // Maximum number of rows in the output batch.
-  const uint32_t outputBatchSize_;
+  const vector_size_t outputBatchSize_;
 
   // Type of join.
   const core::JoinType joinType_;
diff --git a/velox/exec/MergeSource.cpp b/velox/exec/MergeSource.cpp
index b71e5337fe319..3c888d8e1bf36 100644
--- a/velox/exec/MergeSource.cpp
+++ b/velox/exec/MergeSource.cpp
@@ -120,13 +120,16 @@ class MergeExchangeSource : public MergeSource {
       MergeExchange* mergeExchange,
       const std::string& taskId,
       int destination,
-      memory::MemoryPool* FOLLY_NONNULL pool)
+      int64_t maxQueuedBytes,
+      memory::MemoryPool* pool,
+      folly::Executor* executor)
       : mergeExchange_(mergeExchange),
-        client_(std::make_unique<ExchangeClient>(
-            taskId,
+        client_(std::make_shared<ExchangeClient>(
+            mergeExchange->taskId(),
             destination,
+            maxQueuedBytes,
             pool,
-            ExchangeClient::kDefaultMaxQueuedBytes)) {
+            executor)) {
     client_->addRemoteTaskId(taskId);
     client_->noMoreRemoteTasks();
   }
@@ -134,24 +137,25 @@ class MergeExchangeSource : public MergeSource {
   BlockingReason next(RowVectorPtr& data, ContinueFuture* future) override {
     data.reset();
 
-    if (atEnd_) {
+    if (atEnd_ && !currentPage_) {
       return BlockingReason::kNotBlocked;
     }
 
     if (!currentPage_) {
-      currentPage_ = client_->next(&atEnd_, future);
-      if (atEnd_) {
-        return BlockingReason::kNotBlocked;
-      }
+      auto pages = client_->next(1, &atEnd_, future);
+      VELOX_CHECK_LE(pages.size(), 1);
+      currentPage_ = pages.empty() ? nullptr : std::move(pages.front());
 
       if (!currentPage_) {
+        if (atEnd_) {
+          return BlockingReason::kNotBlocked;
+        }
         return BlockingReason::kWaitForProducer;
       }
     }
-    if (!inputStream_) {
-      inputStream_ = std::make_unique<ByteStream>();
+    if (inputStream_ == nullptr) {
       mergeExchange_->stats().wlock()->rawInputBytes += currentPage_->size();
-      currentPage_->prepareStreamForDeserialize(inputStream_.get());
+      inputStream_ = currentPage_->prepareStreamForDeserialize();
     }
 
     if (!inputStream_->atEnd()) {
@@ -163,6 +167,7 @@ class MergeExchangeSource : public MergeSource {
 
       auto lockedStats = mergeExchange_->stats().wlock();
       lockedStats->addInputVector(data->estimateFlatSize(), data->size());
+      lockedStats->rawInputPositions += data->size();
     }
 
     // Since VectorStreamGroup::read() may cause inputStream to be at end,
@@ -170,7 +175,7 @@ class MergeExchangeSource : public MergeSource {
     if (inputStream_->atEnd()) {
       // Reached end of the stream.
       currentPage_ = nullptr;
-      inputStream_ = nullptr;
+      inputStream_.reset();
     }
 
     return BlockingReason::kNotBlocked;
@@ -185,8 +190,8 @@ class MergeExchangeSource : public MergeSource {
 
  private:
   MergeExchange* const mergeExchange_;
-  std::unique_ptr<ExchangeClient> client_;
-  std::unique_ptr<ByteStream> inputStream_;
+  std::shared_ptr<ExchangeClient> client_;
+  std::unique_ptr<ByteInputStream> inputStream_;
   std::unique_ptr<SerializedPage> currentPage_;
   bool atEnd_ = false;
 
@@ -207,9 +212,11 @@ std::shared_ptr<MergeSource> MergeSource::createMergeExchangeSource(
     MergeExchange* mergeExchange,
     const std::string& taskId,
     int destination,
-    memory::MemoryPool* pool) {
+    int64_t maxQueuedBytes,
+    memory::MemoryPool* pool,
+    folly::Executor* executor) {
   return std::make_shared<MergeExchangeSource>(
-      mergeExchange, taskId, destination, pool);
+      mergeExchange, taskId, destination, maxQueuedBytes, pool, executor);
 }
 
 namespace {
@@ -224,6 +231,8 @@ void notify(std::optional<ContinuePromise>& promise) {
 BlockingReason MergeJoinSource::next(
     ContinueFuture* future,
     RowVectorPtr* data) {
+  common::testutil::TestValue::adjust(
+      "facebook::velox::exec::MergeSource::next", this);
   return state_.withWLock([&](auto& state) {
     if (state.data != nullptr) {
       *data = std::move(state.data);
@@ -245,11 +254,18 @@ BlockingReason MergeJoinSource::next(
 BlockingReason MergeJoinSource::enqueue(
     RowVectorPtr data,
     ContinueFuture* future) {
+  common::testutil::TestValue::adjust(
+      "facebook::velox::exec::MergeSource::enqueue", this);
   return state_.withWLock([&](auto& state) {
     if (state.atEnd) {
       // This can happen if consumer called close() because it doesn't need any
-      // more data.
-      // TODO Finish the pipeline early and avoid unnecessary computing.
+      // more data, or because the Task failed or was aborted and the Driver is
+      // cleaning up.
+      // TODO: Finish the pipeline early and avoid unnecessary computing.
+
+      // Notify consumerPromise_ so the consumer doesn't hang indefinitely if
+      // this is because the Driver is closing operators.
+      notify(consumerPromise_);
       return BlockingReason::kNotBlocked;
     }
 
@@ -259,13 +275,14 @@ BlockingReason MergeJoinSource::enqueue(
       return BlockingReason::kNotBlocked;
     }
 
-    VELOX_CHECK_NULL(state.data);
+    if (state.data != nullptr) {
+      return waitForConsumer(future);
+    }
+
     state.data = std::move(data);
     notify(consumerPromise_);
 
-    producerPromise_ = ContinuePromise("MergeJoinSource::enqueue");
-    *future = producerPromise_->getSemiFuture();
-    return BlockingReason::kWaitForConsumer;
+    return waitForConsumer(future);
   });
 }
 
@@ -274,6 +291,7 @@ void MergeJoinSource::close() {
     state.data = nullptr;
     state.atEnd = true;
     notify(producerPromise_);
+    notify(consumerPromise_);
   });
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/MergeSource.h b/velox/exec/MergeSource.h
index a46d6d5dc05c9..c15fb71828922 100644
--- a/velox/exec/MergeSource.h
+++ b/velox/exec/MergeSource.h
@@ -23,6 +23,9 @@ class MergeExchange;
 
 class MergeSource {
  public:
+  static constexpr int32_t kMaxQueuedBytesUpperLimit = 32 << 20; // 32 MB.
+  static constexpr int32_t kMaxQueuedBytesLowerLimit = 1 << 20; // 1 MB.
+
   virtual ~MergeSource() {}
 
   virtual BlockingReason next(RowVectorPtr& data, ContinueFuture* future) = 0;
@@ -40,7 +43,9 @@ class MergeSource {
       MergeExchange* mergeExchange,
       const std::string& taskId,
       int destination,
-      memory::MemoryPool* FOLLY_NONNULL pool);
+      int64_t maxQueuedBytes,
+      memory::MemoryPool* pool,
+      folly::Executor* executor);
 };
 
 /// Coordinates data transfer between single producer and single consumer. Used
@@ -59,8 +64,15 @@ class MergeJoinSource {
   void close();
 
  private:
+  // Wait consumer to fetch next batch of data.
+  BlockingReason waitForConsumer(ContinueFuture* future) {
+    producerPromise_ = ContinuePromise("MergeJoinSource::waitForConsumer");
+    *future = producerPromise_->getSemiFuture();
+    return BlockingReason::kWaitForConsumer;
+  }
+
   struct State {
-    bool atEnd;
+    bool atEnd = false;
     RowVectorPtr data;
   };
 
diff --git a/velox/exec/NestedLoopJoinProbe.cpp b/velox/exec/NestedLoopJoinProbe.cpp
index 30f01a3f83188..b01bd61f43408 100644
--- a/velox/exec/NestedLoopJoinProbe.cpp
+++ b/velox/exec/NestedLoopJoinProbe.cpp
@@ -19,8 +19,8 @@
 #include "velox/expression/FieldReference.h"
 
 namespace facebook::velox::exec {
-
 namespace {
+
 bool needsProbeMismatch(core::JoinType joinType) {
   return isLeftJoin(joinType) || isFullJoin(joinType);
 }
@@ -42,6 +42,7 @@ std::vector<IdentityProjection> extractProjections(
   }
   return projections;
 }
+
 } // namespace
 
 NestedLoopJoinProbe::NestedLoopJoinProbe(
@@ -55,18 +56,70 @@ NestedLoopJoinProbe::NestedLoopJoinProbe(
           joinNode->id(),
           "NestedLoopJoinProbe"),
       outputBatchSize_{outputBatchRows()},
-      joinType_(joinNode->joinType()) {
-  auto probeType = joinNode->sources()[0]->outputType();
-  auto buildType = joinNode->sources()[1]->outputType();
+      joinNode_(joinNode),
+      joinType_(joinNode_->joinType()) {
+  auto probeType = joinNode_->sources()[0]->outputType();
+  auto buildType = joinNode_->sources()[1]->outputType();
   identityProjections_ = extractProjections(probeType, outputType_);
   buildProjections_ = extractProjections(buildType, outputType_);
+}
+
+void NestedLoopJoinProbe::initialize() {
+  Operator::initialize();
 
-  if (joinNode->joinCondition() != nullptr) {
+  VELOX_CHECK(joinNode_ != nullptr);
+  if (joinNode_->joinCondition() != nullptr) {
     initializeFilter(
-        joinNode->joinCondition(),
-        joinNode->sources()[0]->outputType(),
-        joinNode->sources()[1]->outputType());
+        joinNode_->joinCondition(),
+        joinNode_->sources()[0]->outputType(),
+        joinNode_->sources()[1]->outputType());
+  }
+
+  joinNode_.reset();
+}
+
+void NestedLoopJoinProbe::initializeFilter(
+    const core::TypedExprPtr& filter,
+    const RowTypePtr& probeType,
+    const RowTypePtr& buildType) {
+  VELOX_CHECK_NULL(joinCondition_);
+
+  std::vector<core::TypedExprPtr> filters = {filter};
+  joinCondition_ =
+      std::make_unique<ExprSet>(std::move(filters), operatorCtx_->execCtx());
+
+  column_index_t filterChannel = 0;
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  const auto numFields = joinCondition_->expr(0)->distinctFields().size();
+  names.reserve(numFields);
+  types.reserve(numFields);
+
+  for (const auto& field : joinCondition_->expr(0)->distinctFields()) {
+    const auto& name = field->field();
+    auto channel = probeType->getChildIdxIfExists(name);
+    if (channel.has_value()) {
+      auto channelValue = channel.value();
+      filterProbeProjections_.emplace_back(channelValue, filterChannel++);
+      names.emplace_back(probeType->nameOf(channelValue));
+      types.emplace_back(probeType->childAt(channelValue));
+      continue;
+    }
+    channel = buildType->getChildIdxIfExists(name);
+    if (channel.has_value()) {
+      auto channelValue = channel.value();
+      filterBuildProjections_.emplace_back(channelValue, filterChannel++);
+      names.emplace_back(buildType->nameOf(channelValue));
+      types.emplace_back(buildType->childAt(channelValue));
+      continue;
+    }
+    VELOX_FAIL(
+        "Join filter field {} not in probe or build input, filter: {}",
+        field->toString(),
+        filter->toString());
   }
+
+  filterInputType_ = ROW(std::move(names), std::move(types));
 }
 
 BlockingReason NestedLoopJoinProbe::isBlocked(ContinueFuture* future) {
@@ -89,6 +142,9 @@ BlockingReason NestedLoopJoinProbe::isBlocked(ContinueFuture* future) {
       }
       VELOX_CHECK(buildVectors_.has_value());
 
+      // If we just got build data, check if this is a right or full join where
+      // we need to hit track of hits on build records. If it is, initialize the
+      // selectivity vectors that do so.
       if (needsBuildMismatch(joinType_)) {
         buildMatched_.resize(buildVectors_->size());
         for (auto i = 0; i < buildVectors_->size(); ++i) {
@@ -120,10 +176,38 @@ void NestedLoopJoinProbe::addInput(RowVectorPtr input) {
     child->loadedVector();
   }
   input_ = std::move(input);
+  if (input_->size() > 0) {
+    probeSideEmpty_ = false;
+  }
   VELOX_CHECK_EQ(buildIndex_, 0);
-  if (needsProbeMismatch(joinType_)) {
-    probeMatched_.resizeFill(input_->size(), false);
+}
+
+void NestedLoopJoinProbe::noMoreInput() {
+  Operator::noMoreInput();
+  if (state_ != ProbeOperatorState::kRunning || input_ != nullptr) {
+    return;
+  }
+  if (!needsBuildMismatch(joinType_)) {
+    setState(ProbeOperatorState::kFinish);
+    return;
+  }
+  beginBuildMismatch();
+}
+
+bool NestedLoopJoinProbe::getBuildData(ContinueFuture* future) {
+  VELOX_CHECK(!buildVectors_.has_value());
+
+  auto buildData =
+      operatorCtx_->task()
+          ->getNestedLoopJoinBridge(
+              operatorCtx_->driverCtx()->splitGroupId, planNodeId())
+          ->dataOrFuture(future);
+  if (!buildData.has_value()) {
+    return false;
   }
+
+  buildVectors_ = std::move(buildData);
+  return true;
 }
 
 RowVectorPtr NestedLoopJoinProbe::getOutput() {
@@ -133,11 +217,15 @@ RowVectorPtr NestedLoopJoinProbe::getOutput() {
   }
   RowVectorPtr output{nullptr};
   while (output == nullptr) {
+    // If we are done processing all build and probe data, and this is the
+    // operator producing build mismatches (only for right a full outer join).
     if (lastProbe_) {
       VELOX_CHECK(processingBuildMismatch());
 
+      // Scans build input producing build mismatches by wrapping dictionaries
+      // to build input, and null constant to probe projections.
       while (output == nullptr && !hasProbedAllBuildData()) {
-        output = getMismatchedOutput(
+        output = getBuildMismatchedOutput(
             buildVectors_.value()[buildIndex_],
             buildMatched_[buildIndex_],
             buildOutMapping_,
@@ -151,331 +239,450 @@ RowVectorPtr NestedLoopJoinProbe::getOutput() {
       break;
     }
 
+    // Need more input.
     if (input_ == nullptr) {
       break;
     }
 
-    // When input_ is not null but buildIndex_ is at the end, it means the
-    // matching of input_ and buildData_ has finished. For left/full joins,
-    // the next step is to emit output for mismatched probe side rows.
-    if (hasProbedAllBuildData()) {
-      output = needsProbeMismatch(joinType_) ? getMismatchedOutput(
-                                                   input_,
-                                                   probeMatched_,
-                                                   probeOutMapping_,
-                                                   identityProjections_,
-                                                   buildProjections_)
-                                             : nullptr;
-      finishProbeInput();
-      break;
-    }
+    // Generate actual join output by processing probe and build matches, and
+    // probe mismaches (for left joins).
+    output = generateOutput();
+  }
+  return output;
+}
 
-    const vector_size_t probeCnt = getNumProbeRows();
-    output = doMatch(probeCnt);
-    if (advanceProbeRows(probeCnt)) {
-      if (!needsProbeMismatch(joinType_)) {
-        finishProbeInput();
-      }
+RowVectorPtr NestedLoopJoinProbe::generateOutput() {
+  // If addToOutput() returns false, output_ is filled. Need to produce it.
+  if (!addToOutput()) {
+    VELOX_CHECK_GT(output_->size(), 0);
+    return std::move(output_);
+  }
+
+  // Try to advance the probe cursor; call finish if no more probe input.
+  if (advanceProbe()) {
+    finishProbeInput();
+  }
+
+  if (output_ != nullptr && output_->size() == 0) {
+    output_ = nullptr;
+  }
+  return std::move(output_);
+}
+
+bool NestedLoopJoinProbe::advanceProbe() {
+  if (hasProbedAllBuildData()) {
+    probeRow_ += probeRowCount_;
+    probeRowHasMatch_ = false;
+    buildIndex_ = 0;
+
+    // If we finished processing the probe side.
+    if (probeRow_ >= input_->size()) {
+      return true;
     }
   }
-  return output;
+  return false;
 }
 
-void NestedLoopJoinProbe::initializeFilter(
-    const core::TypedExprPtr& filter,
-    const RowTypePtr& probeType,
-    const RowTypePtr& buildType) {
-  VELOX_CHECK_NULL(joinCondition_);
+// Main join loop.
+bool NestedLoopJoinProbe::addToOutput() {
+  VELOX_CHECK_NOT_NULL(input_);
 
-  std::vector<core::TypedExprPtr> filters = {filter};
-  joinCondition_ =
-      std::make_unique<ExprSet>(std::move(filters), operatorCtx_->execCtx());
+  // First, create a new output vector. By default, allocate space for
+  // outputBatchSize_ rows. The output always generates dictionaries wrapped
+  // around the probe vector being processed.
+  //
+  // Since cross join batches can be returned without filter evaluation, no need
+  // to prepare output here.
+  if (!isCrossJoin()) {
+    prepareOutput();
+  }
 
-  column_index_t filterChannel = 0;
-  std::vector<std::string> names;
-  std::vector<TypePtr> types;
-  auto numFields = joinCondition_->expr(0)->distinctFields().size();
-  names.reserve(numFields);
-  types.reserve(numFields);
-  for (auto& field : joinCondition_->expr(0)->distinctFields()) {
-    const auto& name = field->field();
-    auto channel = probeType->getChildIdxIfExists(name);
-    if (channel.has_value()) {
-      auto channelValue = channel.value();
-      filterProbeProjections_.emplace_back(channelValue, filterChannel++);
-      names.emplace_back(probeType->nameOf(channelValue));
-      types.emplace_back(probeType->childAt(channelValue));
+  while (!hasProbedAllBuildData()) {
+    const auto& currentBuild = buildVectors_.value()[buildIndex_];
+
+    // Empty build vector; move to the next.
+    if (currentBuild->size() == 0) {
+      ++buildIndex_;
+      buildRow_ = 0;
       continue;
     }
-    channel = buildType->getChildIdxIfExists(name);
-    if (channel.has_value()) {
-      auto channelValue = channel.value();
-      filterBuildProjections_.emplace_back(channelValue, filterChannel++);
-      names.emplace_back(buildType->nameOf(channelValue));
-      types.emplace_back(buildType->childAt(channelValue));
-      continue;
+
+    // If this is a cross join, there is no filter to evaluate. We can just
+    // return the output vector directly. Also don't need to bother about adding
+    // mismatched rows.
+    if (isCrossJoin()) {
+      output_ = getNextCrossProductBatch(
+          currentBuild, outputType_, identityProjections_, buildProjections_);
+      numOutputRows_ = output_->size();
+      probeRowHasMatch_ = true;
+      ++buildIndex_;
+      buildRow_ = 0;
+      return false;
     }
-    VELOX_FAIL(
-        "Join filter field {} not in probe or build input, filter: {}",
-        field->toString(),
-        filter->toString());
-  }
 
-  filterInputType_ = ROW(std::move(names), std::move(types));
-}
+    // Only re-calculate the filter if we have a new build vector.
+    if (buildRow_ == 0) {
+      evaluateJoinFilter(currentBuild);
+    }
 
-RowVectorPtr NestedLoopJoinProbe::getMismatchedOutput(
-    const RowVectorPtr& data,
-    const SelectivityVector& matched,
-    BufferPtr& unmatchedMapping,
-    const std::vector<IdentityProjection>& projections,
-    const std::vector<IdentityProjection>& nullProjections) {
-  if (matched.isAllSelected() || joinCondition_ == nullptr) {
-    return nullptr;
-  }
+    // Iterate over the filter results. For each match, add an output record.
+    for (size_t i = buildRow_; i < decodedFilterResult_.size(); ++i) {
+      if (isJoinConditionMatch(i)) {
+        addOutputRow(i);
+        ++numOutputRows_;
+        probeRowHasMatch_ = true;
+
+        // If this is a right or full join, we need to keep track of the build
+        // records that got a hit (key match), so that at end we know which
+        // build records to add and which to skip.
+        if (needsBuildMismatch(joinType_)) {
+          buildMatched_[buildIndex_].setValid(i, true);
+        }
 
-  auto rawMapping =
-      initializeRowNumberMapping(unmatchedMapping, data->size(), pool());
-  int32_t numUnmatched{0};
-  for (auto i = 0; i < data->size(); ++i) {
-    if (!matched.isValid(i)) {
-      rawMapping[numUnmatched++] = i;
+        // If the buffer is full, save state and produce it as output.
+        if (numOutputRows_ == outputBatchSize_) {
+          buildRow_ = i + 1;
+          copyBuildValues(currentBuild);
+          return false;
+        }
+      }
     }
-  }
-  VELOX_CHECK_GT(numUnmatched, 0);
 
-  auto output =
-      BaseVector::create<RowVector>(outputType_, numUnmatched, pool());
-  projectChildren(output, data, projections, numUnmatched, unmatchedMapping);
-  for (auto projection : nullProjections) {
-    output->childAt(projection.outputChannel) = BaseVector::createNullConstant(
-        outputType_->childAt(projection.outputChannel), output->size(), pool());
+    // Before moving to the next build vector, copy the needed ranges.
+    copyBuildValues(currentBuild);
+    ++buildIndex_;
+    buildRow_ = 0;
   }
-  return output;
-}
 
-void NestedLoopJoinProbe::finishProbeInput() {
-  VELOX_CHECK_NOT_NULL(input_);
-  input_.reset();
-  buildIndex_ = 0;
-  if (!noMoreInput_) {
-    return;
+  // Check if the current probed row needs to be added as a mismatch (for left
+  // and full outer joins).
+  checkProbeMismatchRow();
+  if (output_ != nullptr) {
+    output_->resize(numOutputRows_);
   }
-  if (!needsBuildMismatch(joinType_) || buildSideEmpty_) {
-    setState(ProbeOperatorState::kFinish);
-    return;
-  }
-  beginBuildMismatch();
+
+  // Signals that all input has been generated for the probeRow and build
+  // vectors; safe to move to the next probe record.
+  return true;
 }
 
-void NestedLoopJoinProbe::noMoreInput() {
-  Operator::noMoreInput();
-  if (state_ != ProbeOperatorState::kRunning || input_ != nullptr) {
-    return;
-  }
-  if (!needsBuildMismatch(joinType_)) {
-    setState(ProbeOperatorState::kFinish);
+void NestedLoopJoinProbe::prepareOutput() {
+  if (output_ != nullptr) {
     return;
   }
-  beginBuildMismatch();
-}
+  std::vector<VectorPtr> localColumns(outputType_->size());
 
-void NestedLoopJoinProbe::beginBuildMismatch() {
-  VELOX_CHECK(needsBuildMismatch(joinType_));
+  probeOutputIndices_ = allocateIndices(outputBatchSize_, pool());
+  rawProbeOutputIndices_ = probeOutputIndices_->asMutable<vector_size_t>();
 
-  std::vector<ContinuePromise> promises;
-  std::vector<std::shared_ptr<Driver>> peers;
-  if (!operatorCtx_->task()->allPeersFinished(
-          planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
-    VELOX_CHECK(future_.valid());
-    setState(ProbeOperatorState::kWaitForPeers);
-    return;
+  for (const auto& projection : identityProjections_) {
+    localColumns[projection.outputChannel] = BaseVector::wrapInDictionary(
+        {},
+        probeOutputIndices_,
+        outputBatchSize_,
+        input_->childAt(projection.inputChannel));
   }
 
-  lastProbe_ = true;
-  // From now on, buildIndex_ is used to indexing into buildMismatched_
-  VELOX_CHECK_EQ(buildIndex_, 0);
-  for (auto& peer : peers) {
-    auto* op = peer->findOperator(planNodeId());
-    auto* probe = dynamic_cast<NestedLoopJoinProbe*>(op);
-    VELOX_CHECK_NOT_NULL(probe);
-    for (auto i = 0; i < buildMatched_.size(); ++i) {
-      buildMatched_[i].select(probe->buildMatched_[i]);
-    }
-  }
-  peers.clear();
-  for (auto& matched : buildMatched_) {
-    matched.updateBounds();
-  }
-  for (auto& promise : promises) {
-    promise.setValue();
+  for (const auto& projection : buildProjections_) {
+    localColumns[projection.outputChannel] = BaseVector::create(
+        outputType_->childAt(projection.outputChannel),
+        outputBatchSize_,
+        operatorCtx_->pool());
   }
+
+  numOutputRows_ = 0;
+  output_ = std::make_shared<RowVector>(
+      pool(), outputType_, nullptr, outputBatchSize_, std::move(localColumns));
 }
 
-bool NestedLoopJoinProbe::getBuildData(ContinueFuture* future) {
-  VELOX_CHECK(!buildVectors_.has_value());
+void NestedLoopJoinProbe::evaluateJoinFilter(const RowVectorPtr& buildVector) {
+  // First step to process is to get a batch so we can evaluate the join
+  // filter.
+  auto filterInput = getNextCrossProductBatch(
+      buildVector,
+      filterInputType_,
+      filterProbeProjections_,
+      filterBuildProjections_);
 
-  auto buildData =
-      operatorCtx_->task()
-          ->getNestedLoopJoinBridge(
-              operatorCtx_->driverCtx()->splitGroupId, planNodeId())
-          ->dataOrFuture(future);
-  if (!buildData.has_value()) {
-    return false;
+  if (filterInputRows_.size() != filterInput->size()) {
+    filterInputRows_.resizeFill(filterInput->size(), true);
   }
+  VELOX_CHECK(filterInputRows_.isAllSelected());
 
-  buildVectors_ = std::move(buildData);
-  if (buildVectors_->empty()) {
-    buildSideEmpty_ = true;
-  }
-  return true;
+  std::vector<VectorPtr> filterResult;
+  EvalCtx evalCtx(
+      operatorCtx_->execCtx(), joinCondition_.get(), filterInput.get());
+  joinCondition_->eval(0, 1, true, filterInputRows_, evalCtx, filterResult);
+  filterOutput_ = filterResult[0];
+  decodedFilterResult_.decode(*filterOutput_, filterInputRows_);
 }
 
-vector_size_t NestedLoopJoinProbe::getNumProbeRows() const {
-  VELOX_CHECK_NOT_NULL(input_);
-  VELOX_CHECK(!hasProbedAllBuildData());
-
-  const auto inputSize = input_->size();
-  auto numBuildRows = buildVectors_.value()[buildIndex_]->size();
-  vector_size_t numProbeRows;
-  if (numBuildRows > outputBatchSize_) {
-    numProbeRows = 1;
+RowVectorPtr NestedLoopJoinProbe::getNextCrossProductBatch(
+    const RowVectorPtr& buildVector,
+    const RowTypePtr& outputType,
+    const std::vector<IdentityProjection>& probeProjections,
+    const std::vector<IdentityProjection>& buildProjections) {
+  VELOX_CHECK_GT(buildVector->size(), 0);
+
+  // TODO: For now we only enable the build optimizations in cross-joins, but we
+  // should allow it for other join types as well.
+  if (isCrossJoin() && isSingleBuildRow()) {
+    return genCrossProductSingleBuildRow(
+        buildVector, outputType, probeProjections, buildProjections);
+  } else if (isCrossJoin() && isSingleBuildVector()) {
+    return genCrossProductSingleBuildVector(
+        buildVector, outputType, probeProjections, buildProjections);
   } else {
-    numProbeRows = std::min(
-        (vector_size_t)outputBatchSize_ / numBuildRows, inputSize - probeRow_);
+    return genCrossProductMultipleBuildVectors(
+        buildVector, outputType, probeProjections, buildProjections);
   }
-  return numProbeRows;
 }
 
-RowVectorPtr NestedLoopJoinProbe::getCrossProduct(
-    vector_size_t probeCnt,
+RowVectorPtr NestedLoopJoinProbe::genCrossProductSingleBuildRow(
+    const RowVectorPtr& buildVector,
     const RowTypePtr& outputType,
     const std::vector<IdentityProjection>& probeProjections,
     const std::vector<IdentityProjection>& buildProjections) {
-  VELOX_CHECK_GT(probeCnt, 0);
-  VELOX_CHECK(!hasProbedAllBuildData());
+  VELOX_CHECK(isSingleBuildRow());
+
+  std::vector<VectorPtr> projectedChildren(outputType->size());
+  size_t numOutputRows = input_->size();
+  probeRowCount_ = input_->size();
+
+  // Project columns from the probe side.
+  projectChildren(
+      projectedChildren, input_, probeProjections, numOutputRows, nullptr);
+
+  // Wrap projections from the build side as constants.
+  for (const auto [inputChannel, outputChannel] : buildProjections) {
+    projectedChildren[outputChannel] = BaseVector::wrapInConstant(
+        numOutputRows, 0, buildVector->childAt(inputChannel));
+  }
+  return std::make_shared<RowVector>(
+      pool(), outputType, nullptr, numOutputRows, std::move(projectedChildren));
+}
 
-  const auto buildSize = buildVectors_.value()[buildIndex_]->size();
-  const auto numOutputRows = probeCnt * buildSize;
-  const bool probeCntChanged = (probeCnt != numPrevProbedRows_);
-  numPrevProbedRows_ = probeCnt;
-  auto output =
-      BaseVector::create<RowVector>(outputType, numOutputRows, pool());
+RowVectorPtr NestedLoopJoinProbe::genCrossProductSingleBuildVector(
+    const RowVectorPtr& buildVector,
+    const RowTypePtr& outputType,
+    const std::vector<IdentityProjection>& probeProjections,
+    const std::vector<IdentityProjection>& buildProjections) {
+  VELOX_CHECK(isSingleBuildVector());
+  std::vector<VectorPtr> projectedChildren(outputType->size());
+  vector_size_t buildRowCount = buildVector->size();
+
+  // Calculate how many probe rows we can cover without exceeding
+  // outputBatchSize_.
+  if (buildRowCount > outputBatchSize_) {
+    probeRowCount_ = 1;
+  } else {
+    probeRowCount_ = std::min(
+        (vector_size_t)outputBatchSize_ / buildRowCount,
+        input_->size() - probeRow_);
+  }
+  size_t numOutputRows = probeRowCount_ * buildRowCount;
 
+  // Generate probe dictionary indices.
   auto rawProbeIndices =
       initializeRowNumberMapping(probeIndices_, numOutputRows, pool());
-  for (auto i = 0; i < probeCnt; ++i) {
+  for (auto i = 0; i < probeRowCount_; ++i) {
     std::fill(
-        rawProbeIndices.begin() + i * buildSize,
-        rawProbeIndices.begin() + (i + 1) * buildSize,
+        rawProbeIndices.begin() + i * buildRowCount,
+        rawProbeIndices.begin() + (i + 1) * buildRowCount,
         probeRow_ + i);
   }
 
-  if (probeCntChanged) {
-    auto rawBuildIndices_ =
-        initializeRowNumberMapping(buildIndices_, numOutputRows, pool());
-    for (auto i = 0; i < probeCnt; ++i) {
-      std::iota(
-          rawBuildIndices_.begin() + i * buildSize,
-          rawBuildIndices_.begin() + (i + 1) * buildSize,
-          0);
-    }
+  // Generate build dictionary indices.
+  auto rawBuildIndices_ =
+      initializeRowNumberMapping(buildIndices_, numOutputRows, pool());
+  for (auto i = 0; i < probeRowCount_; ++i) {
+    std::iota(
+        rawBuildIndices_.begin() + i * buildRowCount,
+        rawBuildIndices_.begin() + (i + 1) * buildRowCount,
+        0);
   }
 
   projectChildren(
-      output, input_, probeProjections, numOutputRows, probeIndices_);
+      projectedChildren,
+      input_,
+      probeProjections,
+      numOutputRows,
+      probeIndices_);
   projectChildren(
-      output,
-      buildVectors_.value()[buildIndex_],
+      projectedChildren,
+      buildVector,
       buildProjections,
       numOutputRows,
       buildIndices_);
-  return output;
+
+  return std::make_shared<RowVector>(
+      pool(), outputType, nullptr, numOutputRows, std::move(projectedChildren));
 }
 
-bool NestedLoopJoinProbe::advanceProbeRows(vector_size_t probeCnt) {
-  probeRow_ += probeCnt;
-  if (probeRow_ < input_->size()) {
-    return false;
+RowVectorPtr NestedLoopJoinProbe::genCrossProductMultipleBuildVectors(
+    const RowVectorPtr& buildVector,
+    const RowTypePtr& outputType,
+    const std::vector<IdentityProjection>& probeProjections,
+    const std::vector<IdentityProjection>& buildProjections) {
+  std::vector<VectorPtr> projectedChildren(outputType->size());
+  size_t numOutputRows = buildVector->size();
+  probeRowCount_ = 1;
+
+  // Project columns from the build side.
+  projectChildren(
+      projectedChildren, buildVector, buildProjections, numOutputRows, nullptr);
+
+  // Wrap projections from the probe side as constants.
+  for (const auto [inputChannel, outputChannel] : probeProjections) {
+    projectedChildren[outputChannel] = BaseVector::wrapInConstant(
+        numOutputRows, probeRow_, input_->childAt(inputChannel));
+  }
+
+  return std::make_shared<RowVector>(
+      pool(), outputType, nullptr, numOutputRows, std::move(projectedChildren));
+}
+
+void NestedLoopJoinProbe::addOutputRow(vector_size_t buildRow) {
+  // Probe side is always a dictionary; just populate the index.
+  rawProbeOutputIndices_[numOutputRows_] = probeRow_;
+
+  // For the build side, we accumulate the ranges to copy, then copy all of them
+  // at once. If records are consecutive and can have a single copy range run.
+  if (!buildCopyRanges_.empty() &&
+      (buildCopyRanges_.back().sourceIndex + buildCopyRanges_.back().count) ==
+          buildRow) {
+    ++buildCopyRanges_.back().count;
+  } else {
+    buildCopyRanges_.push_back({buildRow, numOutputRows_, 1});
   }
-  probeRow_ = 0;
-  numPrevProbedRows_ = 0;
-  do {
-    ++buildIndex_;
-  } while (!hasProbedAllBuildData() &&
-           !buildVectors_.value()[buildIndex_]->size());
-  return hasProbedAllBuildData();
 }
 
-RowVectorPtr NestedLoopJoinProbe::doMatch(vector_size_t probeCnt) {
+void NestedLoopJoinProbe::copyBuildValues(const RowVectorPtr& buildVector) {
+  if (!buildCopyRanges_.empty()) {
+    for (const auto& projection : buildProjections_) {
+      const auto& buildChild = buildVector->childAt(projection.inputChannel);
+      const auto& outputChild = output_->childAt(projection.outputChannel);
+      outputChild->copyRanges(buildChild.get(), buildCopyRanges_);
+    }
+    buildCopyRanges_.clear();
+  }
+}
+
+void NestedLoopJoinProbe::addProbeMismatchRow() {
+  // Probe side is always a dictionary; just populate the index.
+  rawProbeOutputIndices_[numOutputRows_] = probeRow_;
+
+  // Null out build projections.
+  for (const auto& projection : buildProjections_) {
+    const auto& outputChild = output_->childAt(projection.outputChannel);
+    outputChild->setNull(numOutputRows_, true);
+  }
+}
+
+void NestedLoopJoinProbe::checkProbeMismatchRow() {
+  // If we are processing the last batch of the build side, check if we need
+  // to add a probe mismatch record.
+  if (needsProbeMismatch(joinType_) && hasProbedAllBuildData() &&
+      !probeRowHasMatch_) {
+    prepareOutput();
+    addProbeMismatchRow();
+    ++numOutputRows_;
+  }
+}
+
+void NestedLoopJoinProbe::finishProbeInput() {
   VELOX_CHECK_NOT_NULL(input_);
-  VELOX_CHECK(!hasProbedAllBuildData());
+  input_.reset();
+  buildIndex_ = 0;
+  probeRow_ = 0;
+
+  if (!noMoreInput_) {
+    return;
+  }
 
-  if (joinCondition_ == nullptr) {
-    return getCrossProduct(
-        probeCnt, outputType_, identityProjections_, buildProjections_);
+  // From now one we finished processing the probe side. Check now if this is a
+  // right or full outer join, and hence we may need to start emitting buid
+  // mismatch records.
+  if (!needsBuildMismatch(joinType_) || isBuildSideEmpty()) {
+    setState(ProbeOperatorState::kFinish);
+    return;
   }
+  beginBuildMismatch();
+}
 
-  auto filterInput = getCrossProduct(
-      probeCnt,
-      filterInputType_,
-      filterProbeProjections_,
-      filterBuildProjections_);
+void NestedLoopJoinProbe::beginBuildMismatch() {
+  VELOX_CHECK(needsBuildMismatch(joinType_));
 
-  if (filterInputRows_.size() != filterInput->size()) {
-    filterInputRows_.resizeFill(filterInput->size(), true);
+  // Check the state of peer operators. Only the last driver (operator) running
+  // this code will survive and move on to process build mismatches.
+  std::vector<ContinuePromise> promises;
+  std::vector<std::shared_ptr<Driver>> peers;
+  if (!operatorCtx_->task()->allPeersFinished(
+          planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
+    VELOX_CHECK(future_.valid());
+    setState(ProbeOperatorState::kWaitForPeers);
+    return;
   }
-  VELOX_CHECK(filterInputRows_.isAllSelected());
 
-  std::vector<VectorPtr> filterResult;
-  EvalCtx evalCtx(
-      operatorCtx_->execCtx(), joinCondition_.get(), filterInput.get());
-  joinCondition_->eval(0, 1, true, filterInputRows_, evalCtx, filterResult);
-  DecodedVector decodedFilterResult;
-  decodedFilterResult.decode(*filterResult[0], filterInputRows_);
-
-  const vector_size_t maxOutputRows = decodedFilterResult.size();
-  auto rawProbeOutMapping =
-      initializeRowNumberMapping(probeOutMapping_, maxOutputRows, pool());
-  auto rawBuildOutMapping =
-      initializeRowNumberMapping(buildOutMapping_, maxOutputRows, pool());
-  auto* probeIndices = probeIndices_->asMutable<vector_size_t>();
-  auto* buildIndices = buildIndices_->asMutable<vector_size_t>();
-  int32_t numOutputRows{0};
-  for (auto i = 0; i < maxOutputRows; ++i) {
-    if (!decodedFilterResult.isNullAt(i) &&
-        decodedFilterResult.valueAt<bool>(i)) {
-      rawProbeOutMapping[numOutputRows] = probeIndices[i];
-      rawBuildOutMapping[numOutputRows] = buildIndices[i];
-      ++numOutputRows;
+  lastProbe_ = true;
+
+  // From now on, buildIndex_ is used to indexing into buildMismatched_
+  VELOX_CHECK_EQ(buildIndex_, 0);
+
+  // Colect and merge the build mismatch selectivity vectors from all peers.
+  for (auto& peer : peers) {
+    auto* op = peer->findOperator(planNodeId());
+    auto* probe = dynamic_cast<NestedLoopJoinProbe*>(op);
+    VELOX_CHECK_NOT_NULL(probe);
+    for (auto i = 0; i < buildMatched_.size(); ++i) {
+      buildMatched_[i].select(probe->buildMatched_[i]);
+      probeSideEmpty_ &= probe->probeSideEmpty_;
     }
   }
-  if (needsProbeMismatch(joinType_)) {
-    for (auto i = 0; i < numOutputRows; ++i) {
-      probeMatched_.setValid(rawProbeOutMapping[i], true);
-    }
-    probeMatched_.updateBounds();
+  peers.clear();
+  for (auto& matched : buildMatched_) {
+    matched.updateBounds();
   }
-  if (needsBuildMismatch(joinType_)) {
-    for (auto i = 0; i < numOutputRows; ++i) {
-      buildMatched_[buildIndex_].setValid(rawBuildOutMapping[i], true);
-    }
+  for (auto& promise : promises) {
+    promise.setValue();
   }
+}
 
-  if (numOutputRows == 0) {
+RowVectorPtr NestedLoopJoinProbe::getBuildMismatchedOutput(
+    const RowVectorPtr& data,
+    const SelectivityVector& matched,
+    BufferPtr& unmatchedMapping,
+    const std::vector<IdentityProjection>& projections,
+    const std::vector<IdentityProjection>& nullProjections) {
+  // If data is all matched or the join is a cross product, there is no
+  // mismatched rows. But there is an exception that if the join is a cross
+  // product but the build or probe side is empty, there could still be
+  // mismatched rows from the other side.
+  if (matched.isAllSelected() ||
+      (isCrossJoin() && !probeSideEmpty_ && !isBuildSideEmpty())) {
     return nullptr;
   }
-  auto output =
-      BaseVector::create<RowVector>(outputType_, numOutputRows, pool());
-  projectChildren(
-      output, input_, identityProjections_, numOutputRows, probeOutMapping_);
+
+  auto rawMapping =
+      initializeRowNumberMapping(unmatchedMapping, data->size(), pool());
+  int32_t numUnmatched{0};
+  for (auto i = 0; i < data->size(); ++i) {
+    if (!matched.isValid(i)) {
+      rawMapping[numUnmatched++] = i;
+    }
+  }
+  VELOX_CHECK_GT(numUnmatched, 0);
+
+  std::vector<VectorPtr> projectedChildren(outputType_->size());
   projectChildren(
-      output,
-      buildVectors_.value()[buildIndex_],
-      buildProjections_,
-      numOutputRows,
-      buildOutMapping_);
-  return output;
+      projectedChildren, data, projections, numUnmatched, unmatchedMapping);
+  for (auto [_, outputChannel] : nullProjections) {
+    VELOX_CHECK_GT(projectedChildren.size(), outputChannel);
+    projectedChildren[outputChannel] = BaseVector::createNullConstant(
+        outputType_->childAt(outputChannel), numUnmatched, pool());
+  }
+  return std::make_shared<RowVector>(
+      pool(), outputType_, nullptr, numUnmatched, std::move(projectedChildren));
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/NestedLoopJoinProbe.h b/velox/exec/NestedLoopJoinProbe.h
index e6085ce84ee8d..b59457b118aa3 100644
--- a/velox/exec/NestedLoopJoinProbe.h
+++ b/velox/exec/NestedLoopJoinProbe.h
@@ -20,6 +20,51 @@
 #include "velox/exec/ProbeOperatorState.h"
 
 namespace facebook::velox::exec {
+
+/// Implements a Nested Loop Join (NLJ) between records from the probe (input_)
+/// and build (NestedLoopJoinBridge) sides. It supports inner, left, right and
+/// full outer joins.
+///
+/// This class is generally useful to evaluate non-equi-joins (e.g. "k1 >= k2"),
+/// when join conditions may need to be evaluated against a full cross product
+/// of the input. It can also implement cross-join semantics if joinCondition is
+/// nullptr.
+///
+/// The output follows the order of the probe side rows (for inner and left
+/// joins). All build vectors are materialized upfront (check buildVectors_),
+/// but probe batches are processed one-by-one as a stream.
+///
+/// To produce output, the operator processes each probe record from probe
+/// input, using the following steps:
+///
+/// 1. Materialize a cross-product batch across probe and build.
+/// 2. Evaluate the join condition.
+/// 3. Add key matches to the output.
+/// 4. Once all build vectors are processed for a particular probe row, check if
+///    a probe mismatch is needed (only for left and full outer joins).
+/// 5. Once all probe and build inputs are processed, check if build mismatches
+///    are needed (only for right and full outer joins).
+/// 6. If so, signal other peer operators; only a single operator instance will
+///    collect all build matches at the end, and emit any records that haven't
+///    been matched by any of the peers.
+///
+/// There are three different cases for the generation of cross-product across
+/// probe and build (#1 above):
+///
+/// a) If build side has a single row, simply wrap that row as a constant and
+/// produce it along with probe batches.
+///
+/// b) If build side has a single batch, produce a dictionary wrapped across
+/// probe and build rows, covering as many probe rows as allowed by
+/// `outputBatchSize_` (maximum record to produce per batch).
+///
+/// c) If build side has multiple vectors, take one probe row are at a time,
+/// wrapping it as a constant, and produce it along with build batches.
+///
+/// If needed, buid-side copies are done lazily; it first accumulates the ranges
+/// to be copied, then performs the copies in batch, column-by-column. It
+/// produces at most `outputBatchSize_` records, but it may produce fewer since
+/// the output needs to follow the probe vector boundaries.
 class NestedLoopJoinProbe : public Operator {
  public:
   NestedLoopJoinProbe(
@@ -27,6 +72,8 @@ class NestedLoopJoinProbe : public Operator {
       DriverCtx* driverCtx,
       const std::shared_ptr<const core::NestedLoopJoinNode>& joinNode);
 
+  void initialize() override;
+
   void addInput(RowVectorPtr input) override;
 
   RowVectorPtr getOutput() override;
@@ -54,38 +101,155 @@ class NestedLoopJoinProbe : public Operator {
       const RowTypePtr& leftType,
       const RowTypePtr& rightType);
 
+  // Materializes build data from nested loop join bridge into `buildVectors_`.
+  // Returns whether the data has been materialized and is ready for use. Nested
+  // loop join requires all build data to be materialized and available in
+  // `buildVectors_` before it can produce output.
   bool getBuildData(ContinueFuture* future);
 
-  // Calculates the number of probe rows to match with the build side vectors
-  // given the output batch size limit.
-  vector_size_t getNumProbeRows() const;
+  // Generates output from join matches between probe and build sides, as well
+  // as probe mismatches (for left and full outer joins). As much as possible,
+  // generates outputs `outputBatchSize_` records at a time, but batches may be
+  // smaller in some cases - outputs follow the probe side buffer boundaries.
+  RowVectorPtr generateOutput();
 
-  // Generates cross product of next 'probeCnt' rows of input_, and all rows of
-  // build side vector at 'buildIndex_' in 'buildData_'.
-  // 'outputType' specifies the type of output.
-  // Projections from input_ and buildData_ to the output are specified by
-  // 'probeProjections' and 'buildProjections' respectively. Caller is
-  // responsible for ensuring all columns in outputType is contained in either
-  // projections.
-  // TODO: consider consolidate the routine of producing cartesian product that
-  // can be reused at MergeJoin::addToOutput
-  RowVectorPtr getCrossProduct(
-      vector_size_t probeCnt,
+  // Fill in joined output to `output_` by matching the current probeRow_ and
+  // successive build vectors (using getNextCrossProductBatch()). Stops when
+  // either all build vectors were matched for the current probeRow (returns
+  // true), or if the output is full (returns false). If it returns false, a
+  // valid vector with more than zero records will be available at `output_`; if
+  // it returns true, either nullptr or zero records may be placed at `output_`.
+  //
+  // Also updates `buildMatched_` if the build records that received a match, so
+  // that they can be used to implement right and full outer join semantic once
+  // all probe data has been processed.
+  bool addToOutput();
+
+  // Advances 'probeRow_' and resets required state information. Returns true
+  // if there is not more probe data to be processed in the current `input_`
+  // (and hence a new probe input is required). False otherwise.
+  bool advanceProbe();
+
+  // Ensures a new batch of records is available at `output_` and ready to
+  // receive rows. Batches have space for `outputBatchSize_`.
+  void prepareOutput();
+
+  // Evaluates the joinCondition for a given build vector. This method sets
+  // `filterOutput_` and `decodedFilterResult_`, which will be ready to be used
+  // by `isJoinConditionMatch(buildRow)` below.
+  void evaluateJoinFilter(const RowVectorPtr& buildVector);
+
+  // Checks if the join condition matched for a particular row.
+  bool isJoinConditionMatch(vector_size_t i) const {
+    return (
+        !decodedFilterResult_.isNullAt(i) &&
+        decodedFilterResult_.valueAt<bool>(i));
+  }
+
+  // Generates the next batch of a cross product between probe and build. It
+  // should be used as the entry point, and will internally delegate to one of
+  // the three functions below.
+  //
+  // Output projections can be specified so that this function can be used to
+  // generate both filter input and actual output (in case there is no join
+  // filter - cross join).
+  RowVectorPtr getNextCrossProductBatch(
+      const RowVectorPtr& buildVector,
       const RowTypePtr& outputType,
       const std::vector<IdentityProjection>& probeProjections,
       const std::vector<IdentityProjection>& buildProjections);
 
-  // Evaluates joinCondition against the output of getCrossProduct(probeCnt),
-  // returns the result that passed joinCondition, updates probeMatched_,
-  // buildMatched_ accordingly.
-  RowVectorPtr doMatch(vector_size_t probeCnt);
+  // Generates a cross product batch when there is a single build row (probe
+  // batch plus build row as a constant).
+  RowVectorPtr genCrossProductSingleBuildRow(
+      const RowVectorPtr& buildVector,
+      const RowTypePtr& outputType,
+      const std::vector<IdentityProjection>& probeProjections,
+      const std::vector<IdentityProjection>& buildProjections);
+
+  // Generates a cross product batch when there is a single build vector (probe
+  // and build batch wrapped in a dictionary).
+  RowVectorPtr genCrossProductSingleBuildVector(
+      const RowVectorPtr& buildVector,
+      const RowTypePtr& outputType,
+      const std::vector<IdentityProjection>& probeProjections,
+      const std::vector<IdentityProjection>& buildProjections);
+
+  // As a fallback, process the current probe row to as much build data as
+  // possible (probe row as constant, and flat copied data for build records).
+  RowVectorPtr genCrossProductMultipleBuildVectors(
+      const RowVectorPtr& buildVector,
+      const RowTypePtr& outputType,
+      const std::vector<IdentityProjection>& probeProjections,
+      const std::vector<IdentityProjection>& buildProjections);
+
+  // Add a single record to `output_` based on buildRow from buildVector, and
+  // the current probeRow and probe vector (input_). Probe side projections are
+  // zero-copy (dictionary indices), and build side projections are marked to be
+  // copied using `buildCopyRanges_`; they will be copied later on by
+  // `copyBuildValues()`.
+  void addOutputRow(vector_size_t buildRow);
+
+  // Checks if it is required to add a probe mismatch row, and does it if
+  // needed. The caller needs to ensure there is available space in `output_`
+  // for the new record, which has nulled out build projections.
+  void checkProbeMismatchRow();
+
+  // Add a probe mismatch (only for left/full outer joins). The record is based
+  // on the current probeRow and vector (input_) and build projections are null.
+  void addProbeMismatchRow();
 
-  // Updates 'probeRow_' and 'buildIndex_' by advancing 'probeRow_' by probeCnt.
-  // Returns true if 'buildIndex_' points to the end of 'buildData_'.
-  bool advanceProbeRows(vector_size_t probeCnt);
+  // Copies the ranges from buildVector specified by `buildCopyRanges_` to
+  // `output_`, one projected column at a time. Clears buildCopyRanges_.
+  void copyBuildValues(const RowVectorPtr& buildVector);
 
+  // Called when we are done processing the current probe batch, to signal we
+  // are ready for the next one.
+  //
+  // If this is the last probe batch (and this is a right or full outer join),
+  // change the operator state to signal peers.
+  void finishProbeInput();
+
+  // When doing right/full joins, all but the last probe operator that finished
+  // matching probe-side input will turn into kFinish state.
+  // The last finishing operator will gather buildMatched from all the other
+  // probe operators to emit output for mismatched build side rows.
+  void beginBuildMismatch();
+
+  // If this is the operator producing build mismatches (only after producing
+  // all matches and probe mismatches).
+  bool processingBuildMismatch() const {
+    return state_ == ProbeOperatorState::kRunning && input_ == nullptr &&
+        noMoreInput_;
+  }
+
+  // Whether we have processed all build data for the current probe row (based
+  // on buildIndex_'s value).
   bool hasProbedAllBuildData() const {
-    return (buildIndex_ == buildVectors_.value().size());
+    return (buildIndex_ >= buildVectors_.value().size());
+  }
+
+  /// Cross joins are translated into NLJ's without a join conditition.
+  bool isCrossJoin() const {
+    return joinCondition_ == nullptr;
+  }
+
+  // If build has a single vector, we can wrap probe and build batches into
+  // dictionaries and produce as many combinations of probe and build rows,
+  // until `numOutputRows_` is filled.
+  bool isSingleBuildVector() const {
+    return buildVectors_->size() == 1;
+  }
+
+  // If there are no incoming records in the build side.
+  bool isBuildSideEmpty() const {
+    return buildVectors_->empty();
+  }
+
+  // If build has a single row, we can simply add it as a constant to probe
+  // batches.
+  bool isSingleBuildRow() const {
+    return isSingleBuildVector() && buildVectors_->front()->size() == 1;
   }
 
   // Wraps rows of 'data' that are not selected in 'matched' and projects
@@ -93,69 +257,113 @@ class NestedLoopJoinProbe : public Operator {
   // create null column vectors in output for outer join. 'unmatchedMapping' is
   // the reusable buffer to record the mismatched row numbers for output
   // projections.
-  RowVectorPtr getMismatchedOutput(
+  RowVectorPtr getBuildMismatchedOutput(
       const RowVectorPtr& data,
       const SelectivityVector& matched,
       BufferPtr& unmatchedMapping,
       const std::vector<IdentityProjection>& projections,
       const std::vector<IdentityProjection>& nullProjections);
 
-  void finishProbeInput();
-
-  // When doing right/full joins, all but the last probe operators that finished
-  // matching and probe-side mismatch output, will turn into kFinish state.
-  // The last finishing operator will gather buildMatched from all the other
-  // probe operators to emit output for mismatched build side rows.
-  void beginBuildMismatch();
-
-  bool processingBuildMismatch() const {
-    return state_ == ProbeOperatorState::kRunning && input_ == nullptr &&
-        noMoreInput_;
-  }
-
   // TODO: Add state transition check.
   void setState(ProbeOperatorState state) {
     state_ = state;
   }
 
  private:
+  // Output buffer members.
+
   // Maximum number of rows in the output batch.
-  const uint32_t outputBatchSize_;
-  const core::JoinType joinType_;
+  const vector_size_t outputBatchSize_;
 
-  ProbeOperatorState state_{ProbeOperatorState::kWaitForBuild};
-  ContinueFuture future_{ContinueFuture::makeEmpty()};
+  // The current output batch being populated.
+  RowVectorPtr output_;
+
+  // Number of output rows in the current output batch.
+  vector_size_t numOutputRows_{0};
+
+  // Dictionary indices for probe columns used to generate cross-product.
+  BufferPtr probeIndices_;
+
+  // Dictionary indices for probe columns for output vector.
+  BufferPtr probeOutputIndices_;
+  vector_size_t* rawProbeOutputIndices_;
 
-  // Join condition-related state
+  // Dictionary indices for build columns.
+  BufferPtr buildIndices_;
+
+  // Join condition expression.
+
+  // May be nullptr for a cross join.
   std::unique_ptr<ExprSet> joinCondition_;
+
+  // Input type for the join condition expression.
   RowTypePtr filterInputType_;
+
+  // Join condition evaluation state that need to persisted across the
+  // generation of successive output buffers.
   SelectivityVector filterInputRows_;
+  VectorPtr filterOutput_;
+  DecodedVector decodedFilterResult_;
+
+  // Join metadata and state.
+  std::shared_ptr<const core::NestedLoopJoinNode> joinNode_;
+  const core::JoinType joinType_;
+
+  ProbeOperatorState state_{ProbeOperatorState::kWaitForBuild};
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+
+  // Probe side state.
 
-  // Probe side state
-  // Input row to process on next call to getOutput().
+  // Probe row being currently processed (related to `input_`).
   vector_size_t probeRow_{0};
-  // Records the number of probed rows in last getCrossProduct() call. It is
-  // reset upon each 'buildIndex_' update.
-  vector_size_t numPrevProbedRows_{0};
+
+  // How many probe rows are being processed by the current batch.
+  vector_size_t probeRowCount_{1};
+
+  // Whether the current probeRow_ has produces a match. Used for left and full
+  // outer joins.
+  bool probeRowHasMatch_{false};
+
+  // Controls if this is the operator gathering and producing right/full outer
+  // join mismatches. This is only set after all probe and build data has been
+  // processed, only for right/full outer joins, and only executed in one single
+  // operator (need to wait until all peers are finished).
   bool lastProbe_{false};
-  // Represents whether probe side rows have been matched.
-  SelectivityVector probeMatched_;
-  std::vector<IdentityProjection> filterProbeProjections_;
-  BufferPtr probeOutMapping_;
-  BufferPtr probeIndices_;
 
-  // Build side state
+  // Indicate if the probe side has empty input or not. For the last probe,
+  // this indicates if all the probe sides are empty or not. This flag is used
+  // for mismatched output producing.
+  bool probeSideEmpty_{true};
+
+  // Build side state.
+
+  // Stores the data for build vectors (right side of the join).
   std::optional<std::vector<RowVectorPtr>> buildVectors_;
-  bool buildSideEmpty_{false};
-  // Index into buildData_ for the build side vector to process on next call to
-  // getOutput().
+
+  // Index into `buildVectors_` for the build vector being currently processed.
   size_t buildIndex_{0};
-  std::vector<IdentityProjection> buildProjections_;
-  BufferPtr buildIndices_;
 
-  // Represents whether probe build rows have been matched.
+  // Row being currently processed from `buildVectors_[buildIndex_]`.
+  vector_size_t buildRow_{0};
+
+  // Keep track of the build rows that had matches (only used for right or full
+  // outer joins).
   std::vector<SelectivityVector> buildMatched_;
+
+  // Stores the ranges of build values to be copied to the output vector (we
+  // batch them and copy once, instead of copying them row-by-row).
+  std::vector<BaseVector::CopyRange> buildCopyRanges_;
+
+  // List of output projections from the build side. Note that the list of
+  // projections from the probe side is available at `identityProjections_`.
+  std::vector<IdentityProjection> buildProjections_;
+
+  // Projections needed as input to the filter to evaluation join filter
+  // conditions. Note that if this is a cross-join, filter projections are the
+  // same as output projections.
+  std::vector<IdentityProjection> filterProbeProjections_;
   std::vector<IdentityProjection> filterBuildProjections_;
+
   BufferPtr buildOutMapping_;
 };
 
diff --git a/velox/exec/Operator.cpp b/velox/exec/Operator.cpp
index a9491eb0e8716..bb78e9bef57ca 100644
--- a/velox/exec/Operator.cpp
+++ b/velox/exec/Operator.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 #include "velox/exec/Operator.h"
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/exec/Driver.h"
@@ -50,21 +52,26 @@ OperatorCtx::createConnectorQueryCtx(
     const std::string& connectorId,
     const std::string& planNodeId,
     memory::MemoryPool* connectorPool,
-    memory::SetMemoryReclaimer setMemoryReclaimer,
     const common::SpillConfig* spillConfig) const {
-  return std::make_shared<connector::ConnectorQueryCtx>(
+  const auto& task = driverCtx_->task;
+  auto connectorQueryCtx = std::make_shared<connector::ConnectorQueryCtx>(
       pool_,
       connectorPool,
-      std::move(setMemoryReclaimer),
-      driverCtx_->task->queryCtx()->getConnectorConfig(connectorId),
+      task->queryCtx()->connectorSessionProperties(connectorId),
       spillConfig,
+      driverCtx_->prefixSortConfig(),
       std::make_unique<SimpleExpressionEvaluator>(
           execCtx()->queryCtx(), execCtx()->pool()),
-      driverCtx_->task->queryCtx()->cache(),
-      driverCtx_->task->queryCtx()->queryId(),
+      task->queryCtx()->cache(),
+      task->queryCtx()->queryId(),
       taskId(),
       planNodeId,
-      driverCtx_->driverId);
+      driverCtx_->driverId,
+      driverCtx_->queryConfig().sessionTimezone(),
+      task->getCancellationToken());
+  connectorQueryCtx->setSelectiveNimbleReaderEnabled(
+      driverCtx_->queryConfig().selectiveNimbleReaderEnabled());
+  return connectorQueryCtx;
 }
 
 Operator::Operator(
@@ -85,9 +92,7 @@ Operator::Operator(
           operatorId,
           driverCtx->pipelineId,
           std::move(planNodeId),
-          std::move(operatorType)}) {
-  maybeSetReclaimer();
-}
+          std::move(operatorType)}) {}
 
 void Operator::maybeSetReclaimer() {
   VELOX_CHECK_NULL(pool()->reclaimer());
@@ -141,7 +146,13 @@ std::unique_ptr<JoinBridge> Operator::joinBridgeFromPlanNode(
 
 void Operator::initialize() {
   VELOX_CHECK(!initialized_);
+  VELOX_CHECK_EQ(
+      pool()->usedBytes(),
+      0,
+      "Unexpected memory usage from pool {} before operator init",
+      pool()->name());
   initialized_ = true;
+  maybeSetReclaimer();
 }
 
 // static
@@ -196,7 +207,8 @@ static bool isSequence(
 
 RowVectorPtr Operator::fillOutput(
     vector_size_t size,
-    const BufferPtr& mapping) {
+    const BufferPtr& mapping,
+    const std::vector<VectorPtr>& results) {
   bool wrapResults = true;
   if (size == input_->size() &&
       (!mapping || isSequence(mapping->as<vector_size_t>(), 0, size))) {
@@ -206,61 +218,65 @@ RowVectorPtr Operator::fillOutput(
     wrapResults = false;
   }
 
-  auto output{std::make_shared<RowVector>(
-      operatorCtx_->pool(),
-      outputType_,
-      nullptr,
-      size,
-      std::vector<VectorPtr>(outputType_->size(), nullptr))};
-  output->resize(size);
+  std::vector<VectorPtr> projectedChildren(outputType_->size());
   projectChildren(
-      output,
+      projectedChildren,
       input_,
       identityProjections_,
       size,
       wrapResults ? mapping : nullptr);
   projectChildren(
-      output,
-      results_,
+      projectedChildren,
+      results,
       resultProjections_,
       size,
       wrapResults ? mapping : nullptr);
-  return output;
+
+  return std::make_shared<RowVector>(
+      operatorCtx_->pool(),
+      outputType_,
+      nullptr,
+      size,
+      std::move(projectedChildren));
+}
+
+RowVectorPtr Operator::fillOutput(
+    vector_size_t size,
+    const BufferPtr& mapping) {
+  return fillOutput(size, mapping, results_);
 }
 
 OperatorStats Operator::stats(bool clear) {
+  OperatorStats stats;
   if (!clear) {
-    return *stats_.rlock();
+    stats = *stats_.rlock();
+  } else {
+    auto lockedStats = stats_.wlock();
+    stats = *lockedStats;
+    lockedStats->clear();
   }
 
-  auto lockedStats = stats_.wlock();
-  OperatorStats ret{*lockedStats};
-  lockedStats->clear();
-  return ret;
+  stats.memoryStats = MemoryStats::memStatsFromPool(pool());
+  return stats;
 }
 
-uint32_t Operator::outputBatchRows(
+vector_size_t Operator::outputBatchRows(
     std::optional<uint64_t> averageRowSize) const {
   const auto& queryConfig = operatorCtx_->task()->queryCtx()->queryConfig();
-
   if (!averageRowSize.has_value()) {
     return queryConfig.preferredOutputBatchRows();
   }
 
-  const uint64_t rowSize = averageRowSize.value();
-  VELOX_CHECK_GE(
-      rowSize,
-      0,
-      "The given average row size of {}.{} is negative.",
-      operatorType(),
-      operatorId());
+  if (averageRowSize.value() == 0) {
+    return queryConfig.maxOutputBatchRows();
+  }
 
-  if (rowSize * queryConfig.maxOutputBatchRows() <
-      queryConfig.preferredOutputBatchBytes()) {
+  const uint64_t batchSize =
+      queryConfig.preferredOutputBatchBytes() / averageRowSize.value();
+  if (batchSize > queryConfig.maxOutputBatchRows()) {
     return queryConfig.maxOutputBatchRows();
   }
-  return std::max<uint32_t>(
-      queryConfig.preferredOutputBatchBytes() / rowSize, 1);
+  return std::max<vector_size_t>(batchSize, 1);
 }
 
 void Operator::recordBlockingTime(uint64_t start, BlockingReason reason) {
@@ -280,81 +296,106 @@ void Operator::recordBlockingTime(uint64_t start, BlockingReason reason) {
       fmt::format("blocked{}Times", blockReason), RuntimeCounter(1));
 }
 
-void Operator::recordSpillStats(const SpillStats& spillStats) {
-  VELOX_CHECK(noMoreInput_);
+void Operator::recordSpillStats() {
+  const auto lockedSpillStats = spillStats_.wlock();
   auto lockedStats = stats_.wlock();
-  lockedStats->spilledInputBytes += spillStats.spilledInputBytes;
-  lockedStats->spilledBytes += spillStats.spilledBytes;
-  lockedStats->spilledRows += spillStats.spilledRows;
-  lockedStats->spilledPartitions += spillStats.spilledPartitions;
-  lockedStats->spilledFiles += spillStats.spilledFiles;
-  if (spillStats.spillFillTimeUs != 0) {
+  lockedStats->spilledInputBytes += lockedSpillStats->spilledInputBytes;
+  lockedStats->spilledBytes += lockedSpillStats->spilledBytes;
+  lockedStats->spilledRows += lockedSpillStats->spilledRows;
+  lockedStats->spilledPartitions += lockedSpillStats->spilledPartitions;
+  lockedStats->spilledFiles += lockedSpillStats->spilledFiles;
+  if (lockedSpillStats->spillFillTimeNanos != 0) {
     lockedStats->addRuntimeStat(
-        "spillFillTime",
+        kSpillFillTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                spillStats.spillFillTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
+            static_cast<int64_t>(lockedSpillStats->spillFillTimeNanos),
             RuntimeCounter::Unit::kNanos});
   }
-  if (spillStats.spillSortTimeUs != 0) {
+  if (lockedSpillStats->spillSortTimeNanos != 0) {
     lockedStats->addRuntimeStat(
-        "spillSortTime",
+        kSpillSortTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                spillStats.spillSortTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
+            static_cast<int64_t>(lockedSpillStats->spillSortTimeNanos),
             RuntimeCounter::Unit::kNanos});
   }
-  if (spillStats.spillSerializationTimeUs != 0) {
+  if (lockedSpillStats->spillSerializationTimeNanos != 0) {
     lockedStats->addRuntimeStat(
-        "spillSerializationTime",
+        kSpillSerializationTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                spillStats.spillSerializationTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
+            static_cast<int64_t>(lockedSpillStats->spillSerializationTimeNanos),
             RuntimeCounter::Unit::kNanos});
   }
-  if (spillStats.spillFlushTimeUs != 0) {
+  if (lockedSpillStats->spillFlushTimeNanos != 0) {
     lockedStats->addRuntimeStat(
-        "spillFlushTime",
+        kSpillFlushTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                spillStats.spillFlushTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
+            static_cast<int64_t>(lockedSpillStats->spillFlushTimeNanos),
             RuntimeCounter::Unit::kNanos});
   }
-  if (spillStats.spillDiskWrites != 0) {
+  if (lockedSpillStats->spillWrites != 0) {
     lockedStats->addRuntimeStat(
-        "spillDiskWrites",
-        RuntimeCounter{static_cast<int64_t>(spillStats.spillDiskWrites)});
+        kSpillWrites,
+        RuntimeCounter{static_cast<int64_t>(lockedSpillStats->spillWrites)});
   }
-  if (spillStats.spillWriteTimeUs != 0) {
+  if (lockedSpillStats->spillWriteTimeNanos != 0) {
     lockedStats->addRuntimeStat(
-        "spillWriteTime",
+        kSpillWriteTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                spillStats.spillWriteTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
+            static_cast<int64_t>(lockedSpillStats->spillWriteTimeNanos),
             RuntimeCounter::Unit::kNanos});
   }
-  if (numSpillRuns_ != 0) {
+  if (lockedSpillStats->spillRuns != 0) {
     lockedStats->addRuntimeStat(
-        "spillRuns", RuntimeCounter{static_cast<int64_t>(numSpillRuns_)});
-    updateGlobalSpillRunStats(numSpillRuns_);
+        kSpillRuns,
+        RuntimeCounter{static_cast<int64_t>(lockedSpillStats->spillRuns)});
+    common::updateGlobalSpillRunStats(lockedSpillStats->spillRuns);
   }
+
+  if (lockedSpillStats->spillMaxLevelExceededCount != 0) {
+    lockedStats->addRuntimeStat(
+        kExceededMaxSpillLevel,
+        RuntimeCounter{static_cast<int64_t>(
+            lockedSpillStats->spillMaxLevelExceededCount)});
+    common::updateGlobalMaxSpillLevelExceededCount(
+        lockedSpillStats->spillMaxLevelExceededCount);
+  }
+
+  if (lockedSpillStats->spillReadBytes != 0) {
+    lockedStats->addRuntimeStat(
+        kSpillReadBytes,
+        RuntimeCounter{
+            static_cast<int64_t>(lockedSpillStats->spillReadBytes),
+            RuntimeCounter::Unit::kBytes});
+  }
+
+  if (lockedSpillStats->spillReads != 0) {
+    lockedStats->addRuntimeStat(
+        kSpillReads,
+        RuntimeCounter{static_cast<int64_t>(lockedSpillStats->spillReads)});
+  }
+
+  if (lockedSpillStats->spillReadTimeNanos != 0) {
+    lockedStats->addRuntimeStat(
+        kSpillReadTime,
+        RuntimeCounter{
+            static_cast<int64_t>(lockedSpillStats->spillReadTimeNanos),
+            RuntimeCounter::Unit::kNanos});
+  }
+
+  if (lockedSpillStats->spillDeserializationTimeNanos != 0) {
+    lockedStats->addRuntimeStat(
+        kSpillDeserializationTime,
+        RuntimeCounter{
+            static_cast<int64_t>(
+                lockedSpillStats->spillDeserializationTimeNanos),
+            RuntimeCounter::Unit::kNanos});
+  }
+  lockedSpillStats->reset();
 }
 
 std::string Operator::toString() const {
   std::stringstream out;
-  if (auto task = operatorCtx_->task()) {
-    auto driverCtx = operatorCtx_->driverCtx();
-    out << operatorType() << "(" << operatorId() << ")<" << task->taskId()
-        << ":" << driverCtx->pipelineId << "." << driverCtx->driverId << " "
-        << this;
-  } else {
-    out << "<Terminated, no task>";
-  }
+  out << operatorType() << "[" << planNodeId() << "] " << operatorId();
   return out.str();
 }
 
@@ -456,6 +497,10 @@ void OperatorStats::add(const OperatorStats& other) {
   spilledRows += other.spilledRows;
   spilledPartitions += other.spilledPartitions;
   spilledFiles += other.spilledFiles;
+
+  numNullKeys += other.numNullKeys;
+
+  dynamicFilterStats.add(other.dynamicFilterStats);
 }
 
 void OperatorStats::clear() {
@@ -489,6 +534,8 @@ void OperatorStats::clear() {
   spilledRows = 0;
   spilledPartitions = 0;
   spilledFiles = 0;
+
+  dynamicFilterStats.clear();
 }
 
 std::unique_ptr<memory::MemoryReclaimer> Operator::MemoryReclaimer::create(
@@ -509,15 +556,19 @@ void Operator::MemoryReclaimer::enterArbitration() {
   }
 
   Driver* const runningDriver = driverThreadCtx->driverCtx.driver;
-  if (auto opDriver = ensureDriver()) {
-    // NOTE: the current running driver might not be the driver of the operator
-    // that requests memory arbitration. The reason is that an operator might
-    // extend the buffer allocated from the other operator either from the same
-    // or different drivers. But they must be from the same task.
-    VELOX_CHECK_EQ(
-        runningDriver->task()->taskId(),
-        opDriver->task()->taskId(),
-        "The current running driver and the request driver must be from the same task");
+  if (!FLAGS_velox_memory_pool_capacity_transfer_across_tasks) {
+    if (auto opDriver = ensureDriver()) {
+      // NOTE: the current running driver might not be the driver of the
+      // operator that requests memory arbitration. The reason is that an
+      // operator might extend the buffer allocated from the other operator
+      // either from the same or different drivers. But they must be from the
+      // same task as the following check. User could set
+      // FLAGS_transferred_arbitration_allowed=true to bypass this check.
+      VELOX_CHECK_EQ(
+          runningDriver->task()->taskId(),
+          opDriver->task()->taskId(),
+          "The current running driver and the request driver must be from the same task");
+    }
   }
   if (runningDriver->task()->enterSuspended(runningDriver->state()) !=
       StopReason::kNone) {
@@ -535,11 +586,13 @@ void Operator::MemoryReclaimer::leaveArbitration() noexcept {
     return;
   }
   Driver* const runningDriver = driverThreadCtx->driverCtx.driver;
-  if (auto opDriver = ensureDriver()) {
-    VELOX_CHECK_EQ(
-        runningDriver->task()->taskId(),
-        opDriver->task()->taskId(),
-        "The current running driver and the request driver must be from the same task");
+  if (!FLAGS_velox_memory_pool_capacity_transfer_across_tasks) {
+    if (auto opDriver = ensureDriver()) {
+      VELOX_CHECK_EQ(
+          runningDriver->task()->taskId(),
+          opDriver->task()->taskId(),
+          "The current running driver and the request driver must be from the same task");
+    }
   }
   runningDriver->task()->leaveSuspended(runningDriver->state());
 }
@@ -559,6 +612,7 @@ bool Operator::MemoryReclaimer::reclaimableBytes(
 uint64_t Operator::MemoryReclaimer::reclaim(
     memory::MemoryPool* pool,
     uint64_t targetBytes,
+    uint64_t /*unused*/,
     memory::MemoryReclaimer::Stats& stats) {
   std::shared_ptr<Driver> driver = ensureDriver();
   if (FOLLY_UNLIKELY(driver == nullptr)) {
@@ -569,31 +623,69 @@ uint64_t Operator::MemoryReclaimer::reclaim(
   }
   VELOX_CHECK_EQ(pool->name(), op_->pool()->name());
   VELOX_CHECK(
-      !driver->state().isOnThread() || driver->state().isSuspended ||
-      driver->state().isTerminated);
+      !driver->state().isOnThread() || driver->state().suspended() ||
+          driver->state().isTerminated,
+      "driverOnThread {}, driverSuspended {} driverTerminated {} {}",
+      driver->state().isOnThread(),
+      driver->state().suspended(),
+      driver->state().isTerminated,
+      pool->name());
   VELOX_CHECK(driver->task()->pauseRequested());
 
   TestValue::adjust(
       "facebook::velox::exec::Operator::MemoryReclaimer::reclaim", pool);
 
-  op_->reclaim(targetBytes, stats);
-  return pool->shrink(targetBytes);
+  // NOTE: we can't reclaim memory from an operator which is under
+  // non-reclaimable section.
+  if (op_->nonReclaimableSection_) {
+    // TODO: reduce the log frequency if it is too verbose.
+    ++stats.numNonReclaimableAttempts;
+    RECORD_METRIC_VALUE(kMetricMemoryNonReclaimableCount);
+    LOG(WARNING) << "Can't reclaim from memory pool " << pool->name()
+                 << " which is under non-reclaimable section, memory usage: "
+                 << succinctBytes(pool->usedBytes())
+                 << ", reservation: " << succinctBytes(pool->reservedBytes());
+    return 0;
+  }
+
+  RuntimeStatWriterScopeGuard opStatsGuard(op_);
+
+  return memory::MemoryReclaimer::run(
+      [&]() {
+        int64_t reclaimedBytes{0};
+        {
+          memory::ScopedReclaimedBytesRecorder recoder(pool, &reclaimedBytes);
+          op_->reclaim(targetBytes, stats);
+        }
+        VELOX_CHECK_GE(
+            reclaimedBytes,
+            0,
+            "Unexpected memory growth after reclaim from operator memory pool {}",
+            pool->name());
+        return reclaimedBytes;
+      },
+      stats);
 }
 
 void Operator::MemoryReclaimer::abort(
     memory::MemoryPool* pool,
     const std::exception_ptr& /* error */) {
   std::shared_ptr<Driver> driver = ensureDriver();
-  if (FOLLY_UNLIKELY(driver == nullptr)) {
+  if (driver == nullptr) {
     return;
   }
   VELOX_CHECK_EQ(pool->name(), op_->pool()->name());
   VELOX_CHECK(
-      !driver->state().isOnThread() || driver->state().isSuspended ||
+      !driver->state().isOnThread() || driver->state().suspended() ||
       driver->state().isTerminated);
   VELOX_CHECK(driver->task()->isCancelled());
-
-  // Calls operator abort to free up major memory usage.
-  op_->abort();
+  if (driver->state().isOnThread()) {
+    // We can't abort an operator if it is running on a driver thread for memory
+    // arbitration. Otherwise, it might cause random crash when the driver
+    // thread throws after detects the aborted query.
+    return;
+  }
+  // Calls operator close to free up major memory usage.
+  op_->close();
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Operator.h b/velox/exec/Operator.h
index 71850bedc4afd..46010bfe878f4 100644
--- a/velox/exec/Operator.h
+++ b/velox/exec/Operator.h
@@ -46,16 +46,6 @@ struct MemoryStats {
   uint64_t peakTotalMemoryReservation{0};
   uint64_t numMemoryAllocations{0};
 
-  void update(memory::MemoryPool* pool) {
-    const memory::MemoryPool::Stats stats = pool->stats();
-    userMemoryReservation = stats.currentBytes;
-    systemMemoryReservation = 0;
-    peakUserMemoryReservation = stats.peakBytes;
-    peakSystemMemoryReservation = 0;
-    peakTotalMemoryReservation = stats.peakBytes;
-    numMemoryAllocations = stats.numAllocs;
-  }
-
   void add(const MemoryStats& other) {
     userMemoryReservation += other.userMemoryReservation;
     revocableMemoryReservation += other.revocableMemoryReservation;
@@ -78,6 +68,38 @@ struct MemoryStats {
     peakTotalMemoryReservation = 0;
     numMemoryAllocations = 0;
   }
+
+  static MemoryStats memStatsFromPool(const memory::MemoryPool* pool) {
+    const auto poolStats = pool->stats();
+    MemoryStats memStats;
+    memStats.userMemoryReservation = poolStats.usedBytes;
+    memStats.systemMemoryReservation = 0;
+    memStats.peakUserMemoryReservation = poolStats.peakBytes;
+    memStats.peakSystemMemoryReservation = 0;
+    memStats.peakTotalMemoryReservation = poolStats.peakBytes;
+    memStats.numMemoryAllocations = poolStats.numAllocs;
+    return memStats;
+  }
+};
+
+/// Records the dynamic filter stats of an operator.
+struct DynamicFilterStats {
+  /// The set of plan node ids that produce the dynamic filter added to an
+  /// operator. If it is empty, then there is no dynamic filter added.
+  std::unordered_set<core::PlanNodeId> producerNodeIds;
+
+  void clear() {
+    producerNodeIds.clear();
+  }
+
+  void add(const DynamicFilterStats& other) {
+    producerNodeIds.insert(
+        other.producerNodeIds.begin(), other.producerNodeIds.end());
+  }
+
+  bool empty() const {
+    return producerNodeIds.empty();
+  }
 };
 
 struct OperatorStats {
@@ -104,6 +126,9 @@ struct OperatorStats {
   uint64_t inputBytes = 0;
   uint64_t inputPositions = 0;
 
+  /// Contains the dynamic filters stats if applied.
+  DynamicFilterStats dynamicFilterStats;
+
   /// Number of input batches / vectors. Allows to compute an average batch
   /// size.
   uint64_t inputVectors = 0;
@@ -150,10 +175,17 @@ struct OperatorStats {
   int64_t lastLazyCpuNanos{0};
   int64_t lastLazyWallNanos{0};
 
+  // Total null keys processed by the operator.
+  // Currently populated only by HashJoin/HashBuild.
+  // HashProbe doesn't populate numNullKeys when build side is empty.
+  int64_t numNullKeys{0};
+
   std::unordered_map<std::string, RuntimeMetric> runtimeStats;
 
   int numDrivers = 0;
 
+  OperatorStats() = default;
+
   OperatorStats(
       int32_t _operatorId,
       int32_t _pipelineId,
@@ -235,7 +267,6 @@ class OperatorCtx {
       const std::string& connectorId,
       const std::string& planNodeId,
       memory::MemoryPool* connectorPool,
-      memory::SetMemoryReclaimer setMemoryReclaimer = nullptr,
       const common::SpillConfig* spillConfig = nullptr) const;
 
  private:
@@ -249,24 +280,24 @@ class OperatorCtx {
   mutable std::unique_ptr<core::ExecCtx> execCtx_;
 };
 
-// Query operator
+/// Query operator
 class Operator : public BaseRuntimeStatWriter {
  public:
-  // Factory class for mapping a user-registered PlanNode into the corresponding
-  // Operator.
+  /// Factory class for mapping a user-registered PlanNode into the
+  /// corresponding Operator.
   class PlanNodeTranslator {
    public:
     virtual ~PlanNodeTranslator() = default;
 
-    // Translates plan node to operator. Returns nullptr if the plan node cannot
-    // be handled by this factory.
+    /// Translates plan node to operator. Returns nullptr if the plan node
+    /// cannot be handled by this factory.
     virtual std::unique_ptr<Operator>
     toOperator(DriverCtx* ctx, int32_t id, const core::PlanNodePtr& node) {
       return nullptr;
     }
 
-    // An overloaded method that should be called when the operator needs an
-    // ExchangeClient.
+    /// An overloaded method that should be called when the operator needs an
+    /// ExchangeClient.
     virtual std::unique_ptr<Operator> toOperator(
         DriverCtx* ctx,
         int32_t id,
@@ -275,28 +306,48 @@ class Operator : public BaseRuntimeStatWriter {
       return nullptr;
     }
 
-    // Translates plan node to join bridge. Returns nullptr if the plan node
-    // cannot be handled by this factory.
+    /// Translates plan node to join bridge. Returns nullptr if the plan node
+    /// cannot be handled by this factory.
     virtual std::unique_ptr<JoinBridge> toJoinBridge(
         const core::PlanNodePtr& /* node */) {
       return nullptr;
     }
 
-    // Translates plan node to operator supplier. Returns nullptr if the plan
-    // node cannot be handled by this factory.
+    /// Translates plan node to operator supplier. Returns nullptr if the plan
+    /// node cannot be handled by this factory.
     virtual OperatorSupplier toOperatorSupplier(
         const core::PlanNodePtr& /* node */) {
       return nullptr;
     }
 
-    // Returns max driver count for the plan node. Returns std::nullopt if the
-    // plan node cannot be handled by this factory.
+    /// Returns max driver count for the plan node. Returns std::nullopt if the
+    /// plan node cannot be handled by this factory.
     virtual std::optional<uint32_t> maxDrivers(
         const core::PlanNodePtr& /* node */) {
       return std::nullopt;
     }
   };
 
+  /// The name of the runtime spill stats collected and reported by operators
+  /// that support spilling.
+  /// The spill write stats.
+  static inline const std::string kSpillFillTime{"spillFillWallNanos"};
+  static inline const std::string kSpillSortTime{"spillSortWallNanos"};
+  static inline const std::string kSpillSerializationTime{
+      "spillSerializationWallNanos"};
+  static inline const std::string kSpillFlushTime{"spillFlushWallNanos"};
+  static inline const std::string kSpillWrites{"spillWrites"};
+  static inline const std::string kSpillWriteTime{"spillWriteWallNanos"};
+  static inline const std::string kSpillRuns{"spillRuns"};
+  static inline const std::string kExceededMaxSpillLevel{
+      "exceededMaxSpillLevel"};
+  /// The spill read stats.
+  static inline const std::string kSpillReadBytes{"spillReadBytes"};
+  static inline const std::string kSpillReads{"spillReads"};
+  static inline const std::string kSpillReadTime{"spillReadWallNanos"};
+  static inline const std::string kSpillDeserializationTime{
+      "spillDeserializationWallNanos"};
+
   /// 'operatorId' is the initial index of the 'this' in the Driver's list of
   /// Operators. This is used as in index into OperatorStats arrays in the Task.
   /// 'planNodeId' is a query-level unique identifier of the PlanNode to which
@@ -321,7 +372,8 @@ class Operator : public BaseRuntimeStatWriter {
   /// allocation from memory pool that can't be done under operator constructor.
   ///
   /// NOTE: the default implementation set 'initialized_' to true to ensure we
-  /// never call this more than once.
+  /// never call this more than once. The overload initialize() implementation
+  /// must call this base implementation first.
   virtual void initialize();
 
   /// Indicates if this operator has been initialized or not.
@@ -393,6 +445,7 @@ class Operator : public BaseRuntimeStatWriter {
   /// Adds a filter dynamically generated by a downstream operator. Called only
   /// if canAddFilter() returns true.
   virtual void addDynamicFilter(
+      const core::PlanNodeId& /*producer*/,
       column_index_t /*outputChannel*/,
       const std::shared_ptr<common::Filter>& /*filter*/) {
     VELOX_UNSUPPORTED(
@@ -400,8 +453,11 @@ class Operator : public BaseRuntimeStatWriter {
         toString());
   }
 
-  /// Returns a list of identify projections, e.g. columns that are projected
-  /// as-is possibly after applying a filter.
+  /// Returns a list of identity projections, e.g. columns that are projected
+  /// as-is possibly after applying a filter. Used to allow pushdown of dynamic
+  /// filters generated by HashProbe into the TableScan. Examples of identity
+  /// projections: all columns in FilterProject(only filters), group-by keys in
+  /// HashAggregation.
   const std::vector<IdentityProjection>& identityProjections() const {
     return identityProjections_;
   }
@@ -411,19 +467,11 @@ class Operator : public BaseRuntimeStatWriter {
   virtual void close() {
     input_ = nullptr;
     results_.clear();
+    recordSpillStats();
     // Release the unused memory reservation on close.
     operatorCtx_->pool()->release();
   }
 
-  /// Invoked by memory arbitrator to free up operator's resource immediately on
-  /// memory abort, and the query will stop running after this call.
-  ///
-  /// NOTE: we don't expect any access to this operator except close method
-  /// call.
-  virtual void abort() {
-    close();
-  }
-
   // Returns true if 'this' never has more output rows than input rows.
   virtual bool isFilter() const {
     return false;
@@ -435,7 +483,7 @@ class Operator : public BaseRuntimeStatWriter {
 
   /// Returns copy of operator stats. If 'clear' is true, the function also
   /// clears the operator stats after retrieval.
-  OperatorStats stats(bool clear);
+  virtual OperatorStats stats(bool clear);
 
   /// Add a single runtime stat to the operator stats under the write lock.
   /// This member overrides BaseRuntimeStatWriter's member.
@@ -444,7 +492,7 @@ class Operator : public BaseRuntimeStatWriter {
     stats_.wlock()->addRuntimeStat(name, value);
   }
 
-  /// Returns reference to the operator stats synchronized object to gain bulck
+  /// Returns reference to the operator stats synchronized object to gain bulk
   /// read/write access to the stats.
   folly::Synchronized<OperatorStats>& stats() {
     return stats_;
@@ -454,6 +502,13 @@ class Operator : public BaseRuntimeStatWriter {
 
   virtual std::string toString() const;
 
+  /// Used in debug endpoints.
+  virtual folly::dynamic toJson() const {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["operator"] = toString();
+    return obj;
+  }
+
   velox::memory::MemoryPool* pool() const {
     return operatorCtx_->pool();
   }
@@ -492,6 +547,10 @@ class Operator : public BaseRuntimeStatWriter {
     return operatorCtx_->operatorId();
   }
 
+  const uint32_t splitGroupId() const {
+    return operatorCtx_->driverCtx()->splitGroupId;
+  }
+
   /// Sets operator id. Use is limited to renumbering Operators from
   /// DriverAdapter. Do not use outside of this.
   void setOperatorIdFromAdapter(int32_t id) {
@@ -503,6 +562,10 @@ class Operator : public BaseRuntimeStatWriter {
     return operatorCtx_->operatorType();
   }
 
+  const std::string& taskId() const {
+    return operatorCtx_->taskId();
+  }
+
   /// Registers 'translator' for mapping user defined PlanNode subclass
   /// instances to user-defined Operators.
   static void registerOperator(std::unique_ptr<PlanNodeTranslator> translator);
@@ -537,6 +600,47 @@ class Operator : public BaseRuntimeStatWriter {
   /// the first one that is not std::nullopt or std::nullopt otherwise.
   static std::optional<uint32_t> maxDrivers(const core::PlanNodePtr& planNode);
 
+  /// The scoped objects to mark an operator is under non-reclaimable execution
+  /// section or not. This prevents the memory arbitrator from reclaiming memory
+  /// from the operator if it happens to be suspended for memory arbitration
+  /// processing. The driver execution framework marks an operator under
+  /// non-reclaimable section when executes any of its method. The spillable
+  /// operator might clear this temporarily during its execution to reserve
+  /// memory from arbitrator to allow memory reclaim from itself.
+  class ReclaimableSectionGuard {
+   public:
+    /// If 'enter' is true, marks 'op' is under non-reclaimable execution,
+    /// otherwise not.
+    ReclaimableSectionGuard(Operator* op)
+        : op_(op), nonReclaimableSection_(op_->nonReclaimableSection_) {
+      op_->nonReclaimableSection_ = false;
+    }
+
+    ~ReclaimableSectionGuard() {
+      op_->nonReclaimableSection_ = nonReclaimableSection_;
+    }
+
+   private:
+    Operator* const op_;
+    const bool nonReclaimableSection_;
+  };
+
+  class NonReclaimableSectionGuard {
+   public:
+    NonReclaimableSectionGuard(Operator* op)
+        : op_(op), nonReclaimableSection_(op_->nonReclaimableSection_) {
+      op_->nonReclaimableSection_ = true;
+    }
+
+    ~NonReclaimableSectionGuard() {
+      op_->nonReclaimableSection_ = nonReclaimableSection_;
+    }
+
+   private:
+    Operator* const op_;
+    const bool nonReclaimableSection_;
+  };
+
   /// Returns the operator context of this operator. This method is only used
   /// for test.
   const OperatorCtx* testingOperatorCtx() const {
@@ -549,6 +653,16 @@ class Operator : public BaseRuntimeStatWriter {
     return noMoreInput_;
   }
 
+  /// Returns true if this operator is under non-reclaimable section, otherwise
+  /// not. This method is only used for test.
+  bool testingNonReclaimable() const {
+    return nonReclaimableSection_;
+  }
+
+  bool testingHasInput() const {
+    return input_ != nullptr;
+  }
+
  protected:
   static std::vector<std::unique_ptr<PlanNodeTranslator>>& translators();
   friend class NonReclaimableSection;
@@ -570,6 +684,7 @@ class Operator : public BaseRuntimeStatWriter {
     uint64_t reclaim(
         memory::MemoryPool* pool,
         uint64_t targetBytes,
+        uint64_t maxWaitMs,
         memory::MemoryReclaimer::Stats& stats) override;
 
     void abort(memory::MemoryPool* pool, const std::exception_ptr& /* error */)
@@ -581,7 +696,6 @@ class Operator : public BaseRuntimeStatWriter {
       VELOX_CHECK_NOT_NULL(op_);
     }
 
-   private:
     // Gets the shared pointer to the associated driver to ensure the liveness
     // of the operator during the memory reclaim operation.
     //
@@ -594,26 +708,6 @@ class Operator : public BaseRuntimeStatWriter {
     Operator* const op_;
   };
 
-  /// The scoped object to mark a reclaimable operator is under non-reclaimable
-  /// execution section. This prevents the memory arbitrator from reclaiming
-  /// memory from the operator if it happens to be suspended for memory
-  /// arbitration processing.
-  class NonReclaimableSection {
-   public:
-    explicit NonReclaimableSection(Operator* op) : op_(op) {
-      VELOX_CHECK(!op_->nonReclaimableSection_);
-      op_->nonReclaimableSection_ = true;
-    }
-
-    ~NonReclaimableSection() {
-      VELOX_CHECK(op_->nonReclaimableSection_);
-      op_->nonReclaimableSection_ = false;
-    }
-
-   private:
-    Operator* const op_;
-  };
-
   /// Invoked to setup memory reclaimer for this operator's memory pool if its
   /// parent node memory pool has set the reclaimer.
   void maybeSetReclaimer();
@@ -623,12 +717,23 @@ class Operator : public BaseRuntimeStatWriter {
     return spillConfig_.has_value();
   }
 
-  /// Creates output vector from 'input_' and 'results_' according to
+  const common::SpillConfig* spillConfig() const {
+    return spillConfig_.has_value() ? &spillConfig_.value() : nullptr;
+  }
+
+  /// Creates output vector from 'input_' and 'results' according to
   /// 'identityProjections_' and 'resultProjections_'. If 'mapping' is set to
   /// nullptr, the children of the output vector will be identical to their
-  /// respective sources from 'input_' or 'results_'. However, if 'mapping' is
+  /// respective sources from 'input_' or 'results'. However, if 'mapping' is
   /// provided, the children of the output vector will be generated as
   /// dictionary of the sources using the specified 'mapping'.
+  RowVectorPtr fillOutput(
+      vector_size_t size,
+      const BufferPtr& mapping,
+      const std::vector<VectorPtr>& results);
+
+  /// Creates output vector from 'input_' and 'results_' according to
+  /// 'identityProjections_' and 'resultProjections_'.
   RowVectorPtr fillOutput(vector_size_t size, const BufferPtr& mapping);
 
   /// Returns the number of rows for the output batch. This uses averageRowSize
@@ -637,11 +742,11 @@ class Operator : public BaseRuntimeStatWriter {
   /// must not be negative. If the averageRowSize is 0 which is not advised,
   /// returns maxOutputBatchRows. If the averageRowSize is not given, returns
   /// preferredOutputBatchRows.
-  uint32_t outputBatchRows(
+  vector_size_t outputBatchRows(
       std::optional<uint64_t> averageRowSize = std::nullopt) const;
 
   /// Invoked to record spill stats in operator stats.
-  void recordSpillStats(const SpillStats& spillStats);
+  virtual void recordSpillStats();
 
   const std::unique_ptr<OperatorCtx> operatorCtx_;
   const RowTypePtr outputType_;
@@ -652,6 +757,7 @@ class Operator : public BaseRuntimeStatWriter {
   bool initialized_{false};
 
   folly::Synchronized<OperatorStats> stats_;
+  folly::Synchronized<common::SpillStats> spillStats_;
 
   /// Indicates if an operator is under a non-reclaimable execution section.
   /// This prevents the memory arbitrator from reclaiming memory from this
@@ -676,9 +782,6 @@ class Operator : public BaseRuntimeStatWriter {
 
   std::unordered_map<column_index_t, std::shared_ptr<common::Filter>>
       dynamicFilters_;
-
-  /// The number of times that spilling run on this operator.
-  uint32_t numSpillRuns_{0};
 };
 
 /// Given a row type returns indices for the specified subset of columns.
@@ -725,5 +828,13 @@ class SourceOperator : public Operator {
     VELOX_FAIL("SourceOperator does not support noMoreInput()");
   }
 };
-
 } // namespace facebook::velox::exec
+
+template <>
+struct fmt::formatter<std::thread::id> : formatter<std::string> {
+  auto format(std::thread::id s, format_context& ctx) const {
+    std::ostringstream oss;
+    oss << s;
+    return formatter<std::string>::format(oss.str(), ctx);
+  }
+};
diff --git a/velox/exec/OperatorUtils.cpp b/velox/exec/OperatorUtils.cpp
index bc59e4aa3ec19..140eded2bf2d8 100644
--- a/velox/exec/OperatorUtils.cpp
+++ b/velox/exec/OperatorUtils.cpp
@@ -120,7 +120,8 @@ void gatherCopy(
 // per event. This function returns true for such metrics.
 bool shouldAggregateRuntimeMetric(const std::string& name) {
   static const folly::F14FastSet<std::string> metricNames{
-      "dataSourceWallNanos",
+      "dataSourceAddSplitWallNanos",
+      "dataSourceReadWallNanos",
       "dataSourceLazyWallNanos",
       "queuedWallNanos",
       "flushTimes"};
@@ -146,7 +147,7 @@ void deselectRowsWithNulls(
     auto& decoded = hashers[i]->decodedVector();
     if (decoded.mayHaveNulls()) {
       anyChange = true;
-      const auto* nulls = hashers[i]->decodedVector().nulls();
+      const auto* nulls = hashers[i]->decodedVector().nulls(&rows);
       bits::andBits(rows.asMutableRange().bits(), nulls, 0, rows.end());
     }
   }
@@ -177,11 +178,11 @@ namespace {
 vector_size_t processConstantFilterResults(
     const VectorPtr& filterResult,
     const SelectivityVector& rows) {
-  auto constant = filterResult->as<ConstantVector<bool>>();
+  const auto constant = filterResult->as<ConstantVector<bool>>();
   if (constant->isNullAt(0) || constant->valueAt(0) == false) {
     return 0;
   }
-  return rows.size();
+  return rows.countSelected();
 }
 
 vector_size_t processFlatFilterResults(
@@ -189,15 +190,18 @@ vector_size_t processFlatFilterResults(
     const SelectivityVector& rows,
     FilterEvalCtx& filterEvalCtx,
     memory::MemoryPool* pool) {
-  auto size = rows.size();
+  const auto size = rows.size();
 
-  auto selectedBits = filterEvalCtx.getRawSelectedBits(size, pool);
-  auto nonNullBits =
+  auto* selectedBits = filterEvalCtx.getRawSelectedBits(size, pool);
+  auto* nonNullBits =
       filterResult->as<FlatVector<bool>>()->rawValues<uint64_t>();
   if (filterResult->mayHaveNulls()) {
     bits::andBits(selectedBits, nonNullBits, filterResult->rawNulls(), 0, size);
   } else {
-    memcpy(selectedBits, nonNullBits, bits::nbytes(size));
+    ::memcpy(selectedBits, nonNullBits, bits::nbytes(size));
+  }
+  if (!rows.isAllSelected()) {
+    bits::andBits(selectedBits, rows.allBits(), 0, size);
   }
 
   vector_size_t passed = 0;
@@ -219,7 +223,7 @@ vector_size_t processEncodedFilterResults(
   DecodedVector& decoded = filterEvalCtx.decodedResult;
   decoded.decode(*filterResult.get(), rows);
   auto values = decoded.data<uint64_t>();
-  auto nulls = decoded.nulls();
+  auto nulls = decoded.nulls(&rows);
   auto indices = decoded.indices();
 
   vector_size_t passed = 0;
@@ -229,7 +233,7 @@ vector_size_t processEncodedFilterResults(
   for (int32_t i = 0; i < size; ++i) {
     auto index = indices[i];
     if ((!nulls || !bits::isBitNull(nulls, i)) &&
-        bits::isBitSet(values, index)) {
+        bits::isBitSet(values, index) && rows.isValid(i)) {
       rawSelected[passed++] = i;
       bits::setBit(rawSelectedBits, i);
     }
@@ -397,23 +401,27 @@ folly::Range<vector_size_t*> initializeRowNumberMapping(
 }
 
 void projectChildren(
-    const RowVectorPtr& dest,
+    std::vector<VectorPtr>& projectedChildren,
     const RowVectorPtr& src,
     const std::vector<IdentityProjection>& projections,
     int32_t size,
     const BufferPtr& mapping) {
-  projectChildren(dest, src->children(), projections, size, mapping);
+  projectChildren(
+      projectedChildren, src->children(), projections, size, mapping);
 }
 
 void projectChildren(
-    const RowVectorPtr& dest,
+    std::vector<VectorPtr>& projectedChildren,
     const std::vector<VectorPtr>& src,
     const std::vector<IdentityProjection>& projections,
     int32_t size,
     const BufferPtr& mapping) {
-  for (const auto& projection : projections) {
-    dest->childAt(projection.outputChannel) =
-        wrapChild(size, mapping, src[projection.inputChannel]);
+  for (auto [inputChannel, outputChannel] : projections) {
+    if (outputChannel >= projectedChildren.size()) {
+      projectedChildren.resize(outputChannel + 1);
+    }
+    projectedChildren[outputChannel] =
+        wrapChild(size, mapping, src[inputChannel]);
   }
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/OperatorUtils.h b/velox/exec/OperatorUtils.h
index c9ec14e12b41c..14806ae1450ab 100644
--- a/velox/exec/OperatorUtils.h
+++ b/velox/exec/OperatorUtils.h
@@ -36,15 +36,13 @@ struct FilterEvalCtx {
 
   // Make sure selectedBits has enough capacity to hold 'size' bits and return
   // raw pointer to the underlying buffer.
-  uint64_t* FOLLY_NONNULL getRawSelectedBits(
-      vector_size_t size,
-      memory::MemoryPool* FOLLY_NONNULL pool);
+  uint64_t* getRawSelectedBits(vector_size_t size, memory::MemoryPool* pool);
 
   // Make sure selectedIndices buffer has enough capacity to hold 'size'
   // indices and return raw pointer to the underlying buffer.
-  vector_size_t* FOLLY_NONNULL getRawSelectedIndices(
+  vector_size_t* getRawSelectedIndices(
       vector_size_t size,
-      memory::MemoryPool* FOLLY_NONNULL pool);
+      memory::MemoryPool* pool);
 };
 
 // Convert the results of filter evaluation as a vector of booleans into indices
@@ -61,7 +59,7 @@ vector_size_t processFilterResults(
     const VectorPtr& filterResult,
     const SelectivityVector& rows,
     FilterEvalCtx& filterEvalCtx,
-    memory::MemoryPool* FOLLY_NONNULL pool);
+    memory::MemoryPool* pool);
 
 // Wraps the specified vector into a dictionary using the specified mapping.
 // Returns vector as-is if mapping is null. An optional nulls buffer can be
@@ -86,7 +84,7 @@ RowVectorPtr wrap(
     BufferPtr mapping,
     const RowTypePtr& rowType,
     const std::vector<VectorPtr>& childVectors,
-    memory::MemoryPool* FOLLY_NONNULL pool);
+    memory::MemoryPool* pool);
 
 // Ensures that all LazyVectors reachable from 'input' are loaded for all rows.
 void loadColumns(const RowVectorPtr& input, core::ExecCtx& execCtx);
@@ -99,7 +97,7 @@ void loadColumns(const RowVectorPtr& input, core::ExecCtx& execCtx);
 ///
 /// NOTE: all the source row vectors must have the same data type.
 void gatherCopy(
-    RowVector* FOLLY_NONNULL target,
+    RowVector* target,
     vector_size_t targetIndex,
     vector_size_t count,
     const std::vector<const RowVector*>& sources,
@@ -136,11 +134,14 @@ folly::Range<vector_size_t*> initializeRowNumberMapping(
     vector_size_t size,
     memory::MemoryPool* pool);
 
-/// Projects children of 'src' row vector to 'dest' row vector according to
-/// 'projections' and 'mapping'. 'size' specifies number of projected rows in
-/// 'dest'.
+/// Projects children of 'src' row vector according to 'projections'. Optionally
+/// takes a 'mapping' and 'size' that represent the indices and size,
+/// respectively, of a dictionary wrapping that should be applied to the
+/// projections. The output param 'projectedChildren' will contain all the final
+/// projections at the expected channel index. Indices not specified in
+/// 'projections' will be left untouched in 'projectedChildren'.
 void projectChildren(
-    const RowVectorPtr& dest,
+    std::vector<VectorPtr>& projectedChildren,
     const RowVectorPtr& src,
     const std::vector<IdentityProjection>& projections,
     int32_t size,
@@ -149,7 +150,7 @@ void projectChildren(
 /// Overload of the above function that takes reference to const vector of
 /// VectorPtr as 'src' argument, instead of row vector.
 void projectChildren(
-    const RowVectorPtr& dest,
+    std::vector<VectorPtr>& projectedChildren,
     const std::vector<VectorPtr>& src,
     const std::vector<IdentityProjection>& projections,
     int32_t size,
diff --git a/velox/exec/OrderBy.cpp b/velox/exec/OrderBy.cpp
index c4ec9770de1bd..b5939deef12e9 100644
--- a/velox/exec/OrderBy.cpp
+++ b/velox/exec/OrderBy.cpp
@@ -26,7 +26,7 @@ CompareFlags fromSortOrderToCompareFlags(const core::SortOrder& sortOrder) {
       sortOrder.isNullsFirst(),
       sortOrder.isAscending(),
       false,
-      CompareFlags::NullHandlingMode::NoStop};
+      CompareFlags::NullHandlingMode::kNullAsValue};
 }
 } // namespace
 
@@ -43,6 +43,7 @@ OrderBy::OrderBy(
           orderByNode->canSpill(driverCtx->queryConfig())
               ? driverCtx->makeSpillConfig(operatorId)
               : std::nullopt) {
+  maxOutputRows_ = outputBatchRows(std::nullopt);
   VELOX_CHECK(pool()->trackUsage());
   std::vector<column_index_t> sortColumnIndices;
   std::vector<CompareFlags> sortCompareFlags;
@@ -62,14 +63,11 @@ OrderBy::OrderBy(
       outputType_,
       sortColumnIndices,
       sortCompareFlags,
-      outputBatchRows(), // TODO(gaoge): Move to where we can estimate the
-                         // average row size and set the output batch rows based
-                         // on it.
       pool(),
       &nonReclaimableSection_,
-      &numSpillRuns_,
+      driverCtx->prefixSortConfig(),
       spillConfig_.has_value() ? &(spillConfig_.value()) : nullptr,
-      operatorCtx_->driverCtx()->queryConfig().orderBySpillMemoryThreshold());
+      &spillStats_);
 }
 
 void OrderBy::addInput(RowVectorPtr input) {
@@ -80,22 +78,12 @@ void OrderBy::reclaim(
     uint64_t targetBytes,
     memory::MemoryReclaimer::Stats& stats) {
   VELOX_CHECK(canReclaim());
-  auto* driver = operatorCtx_->driver();
+  VELOX_CHECK(!nonReclaimableSection_);
 
-  // NOTE: an order by operator is reclaimable if it hasn't started output
-  // processing and is not under non-reclaimable execution section.
-  if (noMoreInput_ || nonReclaimableSection_) {
-    // TODO: reduce the log frequency if it is too verbose.
-    ++stats.numNonReclaimableAttempts;
-    LOG(WARNING) << "Can't reclaim from order by operator, noMoreInput_["
-                 << noMoreInput_ << "], nonReclaimableSection_["
-                 << nonReclaimableSection_ << "], " << pool()->name();
-    return;
-  }
+  // TODO: support fine-grain disk spilling based on 'targetBytes' after
+  // having row container memory compaction support later.
+  sortBuffer_->spill();
 
-  // TODO: support fine-grain disk spilling based on 'targetBytes' after having
-  // row container memory compaction support later.
-  sortBuffer_->spill(0, targetBytes);
   // Release the minimum reserved memory.
   pool()->release();
 }
@@ -103,8 +91,7 @@ void OrderBy::reclaim(
 void OrderBy::noMoreInput() {
   Operator::noMoreInput();
   sortBuffer_->noMoreInput();
-
-  recordSpillStats();
+  maxOutputRows_ = outputBatchRows(sortBuffer_->estimateOutputRowSize());
 }
 
 RowVectorPtr OrderBy::getOutput() {
@@ -112,21 +99,13 @@ RowVectorPtr OrderBy::getOutput() {
     return nullptr;
   }
 
-  RowVectorPtr output = sortBuffer_->getOutput();
+  RowVectorPtr output = sortBuffer_->getOutput(maxOutputRows_);
   finished_ = (output == nullptr);
   return output;
 }
 
-void OrderBy::abort() {
-  Operator::abort();
+void OrderBy::close() {
+  Operator::close();
   sortBuffer_.reset();
 }
-
-void OrderBy::recordSpillStats() {
-  VELOX_CHECK_NOT_NULL(sortBuffer_);
-  const auto spillStats = sortBuffer_->spilledStats();
-  if (spillStats.has_value()) {
-    Operator::recordSpillStats(spillStats.value());
-  }
-}
 } // namespace facebook::velox::exec
diff --git a/velox/exec/OrderBy.h b/velox/exec/OrderBy.h
index 7d83a7cbff077..fe8e2e61e9b22 100644
--- a/velox/exec/OrderBy.h
+++ b/velox/exec/OrderBy.h
@@ -36,7 +36,7 @@ class OrderBy : public Operator {
  public:
   OrderBy(
       int32_t operatorId,
-      DriverCtx* FOLLY_NONNULL driverCtx,
+      DriverCtx* driverCtx,
       const std::shared_ptr<const core::OrderByNode>& orderByNode);
 
   bool needsInput() const override {
@@ -49,7 +49,7 @@ class OrderBy : public Operator {
 
   RowVectorPtr getOutput() override;
 
-  BlockingReason isBlocked(ContinueFuture* FOLLY_NULLABLE /*future*/) override {
+  BlockingReason isBlocked(ContinueFuture* /*future*/) override {
     return BlockingReason::kNotBlocked;
   }
 
@@ -60,14 +60,11 @@ class OrderBy : public Operator {
   void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
       override;
 
-  void abort() override;
+  void close() override;
 
  private:
-  // Invoked to record the spilling stats in operator stats after processing all
-  // the inputs.
-  void recordSpillStats();
-
   std::unique_ptr<SortBuffer> sortBuffer_;
   bool finished_ = false;
+  vector_size_t maxOutputRows_;
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/OutputBuffer.cpp b/velox/exec/OutputBuffer.cpp
new file mode 100644
index 0000000000000..d35325b3c3907
--- /dev/null
+++ b/velox/exec/OutputBuffer.cpp
@@ -0,0 +1,859 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/OutputBuffer.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/exec/Task.h"
+
+namespace facebook::velox::exec {
+
+using core::PartitionedOutputNode;
+
+void ArbitraryBuffer::noMoreData() {
+  // Drop duplicate end markers.
+  if (!pages_.empty() && pages_.back() == nullptr) {
+    return;
+  }
+  pages_.push_back(nullptr);
+}
+
+void ArbitraryBuffer::enqueue(std::unique_ptr<SerializedPage> page) {
+  VELOX_CHECK_NOT_NULL(page, "Unexpected null page");
+  VELOX_CHECK(!hasNoMoreData(), "Arbitrary buffer has set no more data marker");
+  pages_.push_back(std::shared_ptr<SerializedPage>(page.release()));
+}
+
+void ArbitraryBuffer::getAvailablePageSizes(std::vector<int64_t>& out) const {
+  out.reserve(out.size() + pages_.size());
+  for (const auto& page : pages_) {
+    if (page != nullptr) {
+      out.push_back(page->size());
+    }
+  }
+}
+
+std::vector<std::shared_ptr<SerializedPage>> ArbitraryBuffer::getPages(
+    uint64_t maxBytes) {
+  if (maxBytes == 0 && !pages_.empty() && pages_.front() == nullptr) {
+    // Always give out an end marker when this buffer is finished and fully
+    // consumed.  When multiple `DestinationBuffer' polling the same
+    // `ArbitraryBuffer', we can simplify the code in
+    // `DestinationBuffer::getData' since we will always get a null marker and
+    // not going through the callback path, eliminate the chance of getting
+    // stuck.
+    VELOX_CHECK_EQ(pages_.size(), 1);
+    return {nullptr};
+  }
+  std::vector<std::shared_ptr<SerializedPage>> pages;
+  uint64_t bytesRemoved{0};
+  while (bytesRemoved < maxBytes && !pages_.empty()) {
+    if (pages_.front() == nullptr) {
+      // NOTE: keep the end marker in arbitrary buffer to signal all the
+      // destination buffers after the buffers have all been consumed.
+      VELOX_CHECK_EQ(pages_.size(), 1);
+      pages.push_back(nullptr);
+      break;
+    }
+    bytesRemoved += pages_.front()->size();
+    pages.push_back(std::move(pages_.front()));
+    pages_.pop_front();
+  }
+  return pages;
+}
+
+std::string ArbitraryBuffer::toString() const {
+  return fmt::format(
+      "[ARBITRARY_BUFFER PAGES[{}] NO MORE DATA[{}]]",
+      pages_.size() - !!hasNoMoreData(),
+      hasNoMoreData());
+}
+
+void DestinationBuffer::Stats::recordEnqueue(const SerializedPage& data) {
+  const auto numRows = data.numRows();
+  VELOX_CHECK(numRows.has_value(), "SerializedPage's numRows must be valid");
+  bytesBuffered += data.size();
+  rowsBuffered += numRows.value();
+  ++pagesBuffered;
+}
+
+void DestinationBuffer::Stats::recordAcknowledge(const SerializedPage& data) {
+  const auto numRows = data.numRows();
+  VELOX_CHECK(numRows.has_value(), "SerializedPage's numRows must be valid");
+  const int64_t size = data.size();
+  bytesBuffered -= size;
+  VELOX_DCHECK_GE(bytesBuffered, 0, "bytesBuffered must be non-negative");
+  rowsBuffered -= numRows.value();
+  VELOX_DCHECK_GE(rowsBuffered, 0, "rowsBuffered must be non-negative");
+  --pagesBuffered;
+  VELOX_DCHECK_GE(pagesBuffered, 0, "pagesBuffered must be non-negative");
+  bytesSent += size;
+  rowsSent += numRows.value();
+  ++pagesSent;
+}
+
+void DestinationBuffer::Stats::recordDelete(const SerializedPage& data) {
+  recordAcknowledge(data);
+}
+
+DestinationBuffer::Data DestinationBuffer::getData(
+    uint64_t maxBytes,
+    int64_t sequence,
+    DataAvailableCallback notify,
+    DataConsumerActiveCheckCallback activeCheck,
+    ArbitraryBuffer* arbitraryBuffer) {
+  VELOX_CHECK_GE(
+      sequence, sequence_, "Get received for an already acknowledged item");
+  if (arbitraryBuffer != nullptr) {
+    loadData(arbitraryBuffer, maxBytes);
+  }
+
+  if (sequence - sequence_ >= data_.size()) {
+    if (sequence - sequence_ > data_.size()) {
+      VLOG(1) << this << " Out of order get: " << sequence << " over "
+              << sequence_ << " Setting second notify " << notifySequence_
+              << " / " << sequence;
+    }
+    if (maxBytes == 0) {
+      std::vector<int64_t> remainingBytes;
+      if (arbitraryBuffer) {
+        arbitraryBuffer->getAvailablePageSizes(remainingBytes);
+      }
+      if (!remainingBytes.empty()) {
+        return {{}, std::move(remainingBytes), true};
+      }
+    }
+    notify_ = std::move(notify);
+    aliveCheck_ = std::move(activeCheck);
+    if (sequence - sequence_ > data_.size()) {
+      notifySequence_ = std::min(notifySequence_, sequence);
+    } else {
+      notifySequence_ = sequence;
+    }
+    notifyMaxBytes_ = maxBytes;
+    return {};
+  }
+
+  std::vector<std::unique_ptr<folly::IOBuf>> data;
+  uint64_t resultBytes = 0;
+  auto i = sequence - sequence_;
+  if (maxBytes > 0) {
+    for (; i < data_.size(); ++i) {
+      // nullptr is used as end marker
+      if (data_[i] == nullptr) {
+        VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
+        data.push_back(nullptr);
+        break;
+      }
+      data.push_back(data_[i]->getIOBuf());
+      resultBytes += data_[i]->size();
+      if (resultBytes >= maxBytes) {
+        ++i;
+        break;
+      }
+    }
+  }
+  bool atEnd = false;
+  std::vector<int64_t> remainingBytes;
+  remainingBytes.reserve(data_.size() - i);
+  for (; i < data_.size(); ++i) {
+    if (data_[i] == nullptr) {
+      VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
+      atEnd = true;
+      break;
+    }
+    remainingBytes.push_back(data_[i]->size());
+  }
+  if (!atEnd && arbitraryBuffer) {
+    arbitraryBuffer->getAvailablePageSizes(remainingBytes);
+  }
+  if (data.empty() && remainingBytes.empty() && atEnd) {
+    data.push_back(nullptr);
+  }
+  return {std::move(data), std::move(remainingBytes), true};
+}
+
+void DestinationBuffer::enqueue(std::shared_ptr<SerializedPage> data) {
+  // Drop duplicate end markers.
+  if (data == nullptr && !data_.empty() && data_.back() == nullptr) {
+    return;
+  }
+
+  if (data != nullptr) {
+    stats_.recordEnqueue(*data);
+  }
+  data_.push_back(std::move(data));
+}
+
+DataAvailable DestinationBuffer::getAndClearNotify() {
+  if (notify_ == nullptr) {
+    VELOX_CHECK_NULL(aliveCheck_);
+    return DataAvailable();
+  }
+  DataAvailable result;
+  result.callback = notify_;
+  result.sequence = notifySequence_;
+  auto data = getData(notifyMaxBytes_, notifySequence_, nullptr, nullptr);
+  result.data = std::move(data.data);
+  result.remainingBytes = std::move(data.remainingBytes);
+  clearNotify();
+  return result;
+}
+
+void DestinationBuffer::clearNotify() {
+  notify_ = nullptr;
+  aliveCheck_ = nullptr;
+  notifySequence_ = 0;
+  notifyMaxBytes_ = 0;
+}
+
+void DestinationBuffer::finish() {
+  VELOX_CHECK_NULL(notify_, "notify must be cleared before finish");
+  VELOX_CHECK(data_.empty(), "data must be fetched before finish");
+  stats_.finished = true;
+}
+
+void DestinationBuffer::maybeLoadData(ArbitraryBuffer* buffer) {
+  VELOX_CHECK(!buffer->empty() || buffer->hasNoMoreData());
+  if (notify_ == nullptr) {
+    return;
+  }
+  if (aliveCheck_ != nullptr && !aliveCheck_()) {
+    // Skip load data to an inactive destination buffer.
+    clearNotify();
+    return;
+  }
+  loadData(buffer, notifyMaxBytes_);
+}
+
+void DestinationBuffer::loadData(ArbitraryBuffer* buffer, uint64_t maxBytes) {
+  auto pages = buffer->getPages(maxBytes);
+  for (auto& page : pages) {
+    enqueue(std::move(page));
+  }
+}
+
+std::vector<std::shared_ptr<SerializedPage>> DestinationBuffer::acknowledge(
+    int64_t sequence,
+    bool fromGetData) {
+  const int64_t numDeleted = sequence - sequence_;
+  if (numDeleted == 0 && fromGetData) {
+    // If called from getData, it is expected that there will be
+    // nothing to delete because a previous acknowledgement has been
+    // received before the getData. This is not guaranteed though
+    // because the messages may arrive out of order. Note that getData
+    // implicitly acknowledges all messages with a lower sequence
+    // number than the one in getData.
+    return {};
+  }
+  if (numDeleted <= 0) {
+    // Acknowledges come out of order, e.g. ack of 10 and 9 have
+    // swapped places in flight.
+    VLOG(1) << this << " Out of order ack: " << sequence << " over "
+            << sequence_;
+    return {};
+  }
+
+  VELOX_CHECK_LE(
+      numDeleted, data_.size(), "Ack received for a not yet produced item");
+  std::vector<std::shared_ptr<SerializedPage>> freed;
+  for (auto i = 0; i < numDeleted; ++i) {
+    if (data_[i] == nullptr) {
+      VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
+      break;
+    }
+    stats_.recordAcknowledge(*data_[i]);
+    freed.push_back(std::move(data_[i]));
+  }
+  data_.erase(data_.begin(), data_.begin() + numDeleted);
+  sequence_ += numDeleted;
+  return freed;
+}
+
+std::vector<std::shared_ptr<SerializedPage>>
+DestinationBuffer::deleteResults() {
+  std::vector<std::shared_ptr<SerializedPage>> freed;
+  for (auto i = 0; i < data_.size(); ++i) {
+    if (data_[i] == nullptr) {
+      VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
+      break;
+    }
+    stats_.recordDelete(*data_[i]);
+    freed.push_back(std::move(data_[i]));
+  }
+  data_.clear();
+  return freed;
+}
+
+DestinationBuffer::Stats DestinationBuffer::stats() const {
+  return stats_;
+}
+
+std::string DestinationBuffer::toString() {
+  std::stringstream out;
+  out << "[available: " << data_.size() << ", " << "sequence: " << sequence_
+      << ", " << (notify_ ? "notify registered, " : "") << this << "]";
+  return out.str();
+}
+
+namespace {
+// Frees 'freed' and realizes 'promises'. Used after
+// updateAfterAcknowledgeLocked. This runs outside of the mutex, so
+// that we do the expensive free outside and only then continue the
+// producers which will allocate more memory.
+void releaseAfterAcknowledge(
+    std::vector<std::shared_ptr<SerializedPage>>& freed,
+    std::vector<ContinuePromise>& promises) {
+  freed.clear();
+  for (auto& promise : promises) {
+    promise.setValue();
+  }
+}
+
+} // namespace
+
+OutputBuffer::OutputBuffer(
+    std::shared_ptr<Task> task,
+    PartitionedOutputNode::Kind kind,
+    int numDestinations,
+    uint32_t numDrivers)
+    : task_(std::move(task)),
+      kind_(kind),
+      maxSize_(task_->queryCtx()->queryConfig().maxOutputBufferSize()),
+      continueSize_((maxSize_ * kContinuePct) / 100),
+      arbitraryBuffer_(
+          isArbitrary() ? std::make_unique<ArbitraryBuffer>() : nullptr),
+      numDrivers_(numDrivers) {
+  buffers_.reserve(numDestinations);
+  for (int i = 0; i < numDestinations; i++) {
+    buffers_.push_back(std::make_unique<DestinationBuffer>());
+  }
+  finishedBufferStats_.resize(numDestinations);
+}
+
+void OutputBuffer::updateOutputBuffers(int numBuffers, bool noMoreBuffers) {
+  if (isPartitioned()) {
+    VELOX_CHECK_EQ(buffers_.size(), numBuffers);
+    VELOX_CHECK(noMoreBuffers);
+    noMoreBuffers_ = true;
+    return;
+  }
+
+  std::vector<ContinuePromise> promises;
+  bool isFinished;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+
+    if (numBuffers > buffers_.size()) {
+      addOutputBuffersLocked(numBuffers);
+    }
+
+    if (!noMoreBuffers) {
+      return;
+    }
+
+    noMoreBuffers_ = true;
+    isFinished = isFinishedLocked();
+    updateAfterAcknowledgeLocked(dataToBroadcast_, promises);
+  }
+
+  releaseAfterAcknowledge(dataToBroadcast_, promises);
+  if (isFinished) {
+    task_->setAllOutputConsumed();
+  }
+}
+
+void OutputBuffer::updateNumDrivers(uint32_t newNumDrivers) {
+  bool isNoMoreDrivers{false};
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    numDrivers_ = newNumDrivers;
+    // If we finished all drivers, ensure we register that we are 'done'.
+    if (numDrivers_ == numFinished_) {
+      isNoMoreDrivers = true;
+    }
+  }
+  if (isNoMoreDrivers) {
+    noMoreDrivers();
+  }
+}
+
+void OutputBuffer::addOutputBuffersLocked(int numBuffers) {
+  VELOX_CHECK(!noMoreBuffers_);
+  VELOX_CHECK(!isPartitioned());
+  buffers_.reserve(numBuffers);
+  for (int32_t i = buffers_.size(); i < numBuffers; ++i) {
+    auto buffer = std::make_unique<DestinationBuffer>();
+    if (isBroadcast()) {
+      for (const auto& data : dataToBroadcast_) {
+        buffer->enqueue(data);
+      }
+      if (atEnd_) {
+        buffer->enqueue(nullptr);
+      }
+    }
+    buffers_.emplace_back(std::move(buffer));
+  }
+  finishedBufferStats_.resize(numBuffers);
+}
+
+void OutputBuffer::updateStatsWithEnqueuedPageLocked(
+    int64_t pageBytes,
+    int64_t pageRows) {
+  updateTotalBufferedBytesMsLocked();
+
+  bufferedBytes_ += pageBytes;
+  ++bufferedPages_;
+
+  ++numOutputPages_;
+  numOutputRows_ += pageRows;
+  numOutputBytes_ += pageBytes;
+}
+
+void OutputBuffer::updateStatsWithFreedPagesLocked(
+    int numPages,
+    int64_t pageBytes) {
+  updateTotalBufferedBytesMsLocked();
+
+  bufferedBytes_ -= pageBytes;
+  VELOX_CHECK_GE(bufferedBytes_, 0);
+  bufferedPages_ -= numPages;
+  VELOX_CHECK_GE(bufferedPages_, 0);
+}
+
+void OutputBuffer::updateTotalBufferedBytesMsLocked() {
+  const auto nowMs = getCurrentTimeMs();
+  if (bufferedBytes_ > 0) {
+    const auto deltaMs = nowMs - bufferStartMs_;
+    totalBufferedBytesMs_ += bufferedBytes_ * deltaMs;
+  }
+
+  bufferStartMs_ = nowMs;
+}
+
+bool OutputBuffer::enqueue(
+    int destination,
+    std::unique_ptr<SerializedPage> data,
+    ContinueFuture* future) {
+  VELOX_CHECK_NOT_NULL(data);
+  VELOX_CHECK(
+      task_->isRunning(), "Task is terminated, cannot add data to output.");
+  std::vector<DataAvailable> dataAvailableCallbacks;
+  bool blocked = false;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK_LT(destination, buffers_.size());
+
+    updateStatsWithEnqueuedPageLocked(data->size(), data->numRows().value());
+
+    switch (kind_) {
+      case PartitionedOutputNode::Kind::kBroadcast:
+        VELOX_CHECK_EQ(destination, 0, "Bad destination {}", destination);
+        enqueueBroadcastOutputLocked(std::move(data), dataAvailableCallbacks);
+        break;
+      case PartitionedOutputNode::Kind::kArbitrary:
+        VELOX_CHECK_EQ(destination, 0, "Bad destination {}", destination);
+        enqueueArbitraryOutputLocked(std::move(data), dataAvailableCallbacks);
+        break;
+      case PartitionedOutputNode::Kind::kPartitioned:
+        enqueuePartitionedOutputLocked(
+            destination, std::move(data), dataAvailableCallbacks);
+        break;
+      default:
+        VELOX_UNREACHABLE(PartitionedOutputNode::kindString(kind_));
+    }
+
+    if (bufferedBytes_ >= maxSize_ && future) {
+      promises_.emplace_back("OutputBuffer::enqueue");
+      *future = promises_.back().getSemiFuture();
+      blocked = true;
+    }
+  }
+
+  // Outside mutex_.
+  for (auto& callback : dataAvailableCallbacks) {
+    callback.notify();
+  }
+
+  return blocked;
+}
+
+void OutputBuffer::enqueueBroadcastOutputLocked(
+    std::unique_ptr<SerializedPage> data,
+    std::vector<DataAvailable>& dataAvailableCbs) {
+  VELOX_DCHECK(isBroadcast());
+  VELOX_CHECK_NULL(arbitraryBuffer_);
+  VELOX_DCHECK(dataAvailableCbs.empty());
+
+  std::shared_ptr<SerializedPage> sharedData(data.release());
+  for (auto& buffer : buffers_) {
+    if (buffer != nullptr) {
+      buffer->enqueue(sharedData);
+      dataAvailableCbs.emplace_back(buffer->getAndClearNotify());
+    }
+  }
+
+  // NOTE: we don't need to add new buffer to 'dataToBroadcast_' if there is no
+  // more output buffers.
+  if (!noMoreBuffers_) {
+    dataToBroadcast_.emplace_back(sharedData);
+  }
+}
+
+void OutputBuffer::enqueueArbitraryOutputLocked(
+    std::unique_ptr<SerializedPage> data,
+    std::vector<DataAvailable>& dataAvailableCbs) {
+  VELOX_DCHECK(isArbitrary());
+  VELOX_DCHECK_NOT_NULL(arbitraryBuffer_);
+  VELOX_DCHECK(dataAvailableCbs.empty());
+  VELOX_CHECK(!arbitraryBuffer_->hasNoMoreData());
+
+  arbitraryBuffer_->enqueue(std::move(data));
+  VELOX_CHECK_LT(nextArbitraryLoadBufferIndex_, buffers_.size());
+  int32_t bufferId = nextArbitraryLoadBufferIndex_;
+  for (int32_t i = 0; i < buffers_.size();
+       ++i, bufferId = (bufferId + 1) % buffers_.size()) {
+    if (arbitraryBuffer_->empty()) {
+      nextArbitraryLoadBufferIndex_ = bufferId;
+      break;
+    }
+    auto* buffer = buffers_[bufferId].get();
+    if (buffer == nullptr) {
+      continue;
+    }
+    buffer->maybeLoadData(arbitraryBuffer_.get());
+    dataAvailableCbs.emplace_back(buffer->getAndClearNotify());
+  }
+}
+
+void OutputBuffer::enqueuePartitionedOutputLocked(
+    int destination,
+    std::unique_ptr<SerializedPage> data,
+    std::vector<DataAvailable>& dataAvailableCbs) {
+  VELOX_DCHECK(isPartitioned());
+  VELOX_CHECK_NULL(arbitraryBuffer_);
+  VELOX_DCHECK(dataAvailableCbs.empty());
+
+  VELOX_CHECK_LT(destination, buffers_.size());
+  auto* buffer = buffers_[destination].get();
+  if (buffer != nullptr) {
+    buffer->enqueue(std::move(data));
+    dataAvailableCbs.emplace_back(buffer->getAndClearNotify());
+  } else {
+    // Some downstream tasks may finish early and delete the corresponding
+    // buffers. Further data for these buffers is dropped.
+    updateStatsWithFreedPagesLocked(1, data->size());
+  }
+}
+
+void OutputBuffer::noMoreData() {
+  // Increment number of finished drivers.
+  checkIfDone(true);
+}
+
+void OutputBuffer::noMoreDrivers() {
+  // Do not increment number of finished drivers.
+  checkIfDone(false);
+}
+
+void OutputBuffer::checkIfDone(bool oneDriverFinished) {
+  std::vector<DataAvailable> finished;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    if (oneDriverFinished) {
+      ++numFinished_;
+    }
+    VELOX_CHECK_LE(
+        numFinished_,
+        numDrivers_,
+        "Each driver should call noMoreData exactly once");
+    atEnd_ = numFinished_ == numDrivers_;
+    if (!atEnd_) {
+      return;
+    }
+    if (isArbitrary()) {
+      arbitraryBuffer_->noMoreData();
+      for (auto& buffer : buffers_) {
+        if (buffer != nullptr) {
+          buffer->maybeLoadData(arbitraryBuffer_.get());
+          finished.push_back(buffer->getAndClearNotify());
+        }
+      }
+    } else {
+      for (auto& buffer : buffers_) {
+        if (buffer != nullptr) {
+          buffer->enqueue(nullptr);
+          finished.push_back(buffer->getAndClearNotify());
+        }
+      }
+    }
+  }
+
+  // Notify outside of mutex.
+  for (auto& notification : finished) {
+    notification.notify();
+  }
+}
+
+bool OutputBuffer::isFinished() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return isFinishedLocked();
+}
+
+bool OutputBuffer::isFinishedLocked() {
+  // NOTE: for broadcast output buffer, we can only mark it as finished after
+  // receiving the no more (destination) buffers signal.
+  if (isBroadcast() && !noMoreBuffers_) {
+    return false;
+  }
+  for (auto& buffer : buffers_) {
+    if (buffer != nullptr) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void OutputBuffer::acknowledge(int destination, int64_t sequence) {
+  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK_LT(destination, buffers_.size());
+    auto* buffer = buffers_[destination].get();
+    if (!buffer) {
+      VLOG(1) << "Ack received after final ack for destination " << destination
+              << " and sequence " << sequence;
+      return;
+    }
+    freed = buffer->acknowledge(sequence, false);
+    updateAfterAcknowledgeLocked(freed, promises);
+  }
+  releaseAfterAcknowledge(freed, promises);
+}
+
+void OutputBuffer::updateAfterAcknowledgeLocked(
+    const std::vector<std::shared_ptr<SerializedPage>>& freed,
+    std::vector<ContinuePromise>& promises) {
+  uint64_t freedBytes{0};
+  int freedPages{0};
+  for (const auto& free : freed) {
+    if (free.unique()) {
+      ++freedPages;
+      freedBytes += free->size();
+    }
+  }
+  if (freedPages == 0) {
+    VELOX_CHECK_EQ(freedBytes, 0);
+    return;
+  }
+  VELOX_CHECK_GT(freedBytes, 0);
+
+  updateStatsWithFreedPagesLocked(freedPages, freedBytes);
+
+  if (bufferedBytes_ < continueSize_) {
+    promises = std::move(promises_);
+  }
+}
+
+bool OutputBuffer::deleteResults(int destination) {
+  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<ContinuePromise> promises;
+  bool isFinished;
+  DataAvailable dataAvailable;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK_LT(destination, buffers_.size());
+    auto* buffer = buffers_[destination].get();
+    if (buffer == nullptr) {
+      VLOG(1) << "Extra delete received for destination " << destination;
+      return false;
+    }
+    freed = buffer->deleteResults();
+    dataAvailable = buffer->getAndClearNotify();
+    buffer->finish();
+    VELOX_CHECK_LT(destination, finishedBufferStats_.size());
+    finishedBufferStats_[destination] = buffers_[destination]->stats();
+    buffers_[destination] = nullptr;
+    ++numFinalAcknowledges_;
+    isFinished = isFinishedLocked();
+    updateAfterAcknowledgeLocked(freed, promises);
+  }
+
+  // Outside of mutex.
+  dataAvailable.notify();
+
+  if (!promises.empty()) {
+    VLOG(1) << "Delete of results unblocks producers. Can happen in early end "
+            << "due to error or limit";
+  }
+  releaseAfterAcknowledge(freed, promises);
+  if (isFinished) {
+    task_->setAllOutputConsumed();
+  }
+  return isFinished;
+}
+
+void OutputBuffer::getData(
+    int destination,
+    uint64_t maxBytes,
+    int64_t sequence,
+    DataAvailableCallback notify,
+    DataConsumerActiveCheckCallback activeCheck) {
+  DestinationBuffer::Data data;
+  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+
+    if (!isPartitioned() && destination >= buffers_.size()) {
+      addOutputBuffersLocked(destination + 1);
+    }
+
+    VELOX_CHECK_LT(destination, buffers_.size());
+    auto* buffer = buffers_[destination].get();
+    if (buffer) {
+      freed = buffer->acknowledge(sequence, true);
+      updateAfterAcknowledgeLocked(freed, promises);
+      data = buffer->getData(
+          maxBytes, sequence, notify, activeCheck, arbitraryBuffer_.get());
+    } else {
+      data.data.emplace_back(nullptr);
+      data.immediate = true;
+      VLOG(1) << "getData received after deleteResults for destination "
+              << destination << " and sequence " << sequence;
+    }
+  }
+  releaseAfterAcknowledge(freed, promises);
+  if (data.immediate) {
+    notify(std::move(data.data), sequence, std::move(data.remainingBytes));
+  }
+}
+
+void OutputBuffer::terminate() {
+  VELOX_CHECK(!task_->isRunning());
+
+  std::vector<ContinuePromise> outstandingPromises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    outstandingPromises.swap(promises_);
+  }
+  for (auto& promise : outstandingPromises) {
+    promise.setValue();
+  }
+}
+
+std::string OutputBuffer::toString() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return toStringLocked();
+}
+
+std::string OutputBuffer::toStringLocked() const {
+  std::stringstream out;
+  out << "[OutputBuffer[" << kind_ << "] bufferedBytes_=" << bufferedBytes_
+      << "b, num producers blocked=" << promises_.size()
+      << ", completed=" << numFinished_ << "/" << numDrivers_ << ", "
+      << (atEnd_ ? "at end, " : "") << "destinations: " << std::endl;
+  for (auto i = 0; i < buffers_.size(); ++i) {
+    auto buffer = buffers_[i].get();
+    out << i << ": " << (buffer ? buffer->toString() : "none") << std::endl;
+  }
+  if (isArbitrary()) {
+    out << arbitraryBuffer_->toString();
+  }
+  out << "]" << std::endl;
+  return out.str();
+}
+
+double OutputBuffer::getUtilization() const {
+  return bufferedBytes_ / (double)maxSize_;
+}
+
+bool OutputBuffer::isOverutilized() const {
+  return (bufferedBytes_ > (0.5 * maxSize_)) || atEnd_;
+}
+
+int64_t OutputBuffer::getAverageBufferTimeMsLocked() const {
+  if (numOutputBytes_ > 0) {
+    return totalBufferedBytesMs_ / numOutputBytes_;
+  }
+
+  return 0;
+}
+
+namespace {
+
+// Find out how many buffers hold 80% of the data. Useful to identify skew.
+int32_t countTopBuffers(
+    const std::vector<DestinationBuffer::Stats>& bufferStats,
+    int64_t totalBytes) {
+  std::vector<int64_t> bufferSizes;
+  bufferSizes.reserve(bufferStats.size());
+  for (auto i = 0; i < bufferStats.size(); ++i) {
+    const auto& stats = bufferStats[i];
+    bufferSizes.push_back(stats.bytesBuffered + stats.bytesSent);
+  }
+
+  // Sort descending.
+  std::sort(bufferSizes.begin(), bufferSizes.end(), std::greater<int64_t>());
+
+  const auto limit = totalBytes * 0.8;
+  int32_t numBuffers = 0;
+  int32_t runningTotal = 0;
+  for (auto size : bufferSizes) {
+    runningTotal += size;
+    numBuffers++;
+
+    if (runningTotal >= limit) {
+      break;
+    }
+  }
+
+  return numBuffers;
+}
+
+} // namespace
+
+OutputBuffer::Stats OutputBuffer::stats() {
+  std::lock_guard<std::mutex> l(mutex_);
+  std::vector<DestinationBuffer::Stats> bufferStats;
+  VELOX_CHECK_EQ(buffers_.size(), finishedBufferStats_.size());
+  bufferStats.resize(buffers_.size());
+  for (auto i = 0; i < buffers_.size(); ++i) {
+    auto buffer = buffers_[i].get();
+    if (buffer != nullptr) {
+      bufferStats[i] = buffer->stats();
+    } else {
+      bufferStats[i] = finishedBufferStats_[i];
+    }
+  }
+
+  updateTotalBufferedBytesMsLocked();
+
+  return OutputBuffer::Stats(
+      kind_,
+      noMoreBuffers_,
+      atEnd_,
+      isFinishedLocked(),
+      bufferedBytes_,
+      bufferedPages_,
+      numOutputBytes_,
+      numOutputRows_,
+      numOutputPages_,
+      getAverageBufferTimeMsLocked(),
+      countTopBuffers(bufferStats, numOutputBytes_),
+      bufferStats);
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/OutputBuffer.h b/velox/exec/OutputBuffer.h
new file mode 100644
index 0000000000000..ff20834f7dd17
--- /dev/null
+++ b/velox/exec/OutputBuffer.h
@@ -0,0 +1,438 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/ExchangeQueue.h"
+
+namespace facebook::velox::exec {
+
+/// nullptr in pages indicates that there is no more data.
+/// sequence is the same as specified in BufferManager::getData call. The
+/// caller is expected to advance sequence by the number of entries in groups
+/// and call BufferManager::acknowledge.
+using DataAvailableCallback = std::function<void(
+    std::vector<std::unique_ptr<folly::IOBuf>> pages,
+    int64_t sequence,
+    std::vector<int64_t> remainingBytes)>;
+
+/// Callback provided to indicate if the consumer of a destination buffer is
+/// currently active or not. It is used by arbitrary output buffer to optimize
+/// the http based streaming shuffle in Prestissimo. For instance, the arbitrary
+/// output buffer shall skip sending data to inactive destination buffer and
+/// only send to the currently active ones to reduce the time that a buffer
+/// stays in a destination buffer. Note that once a data is sent to a
+/// destination buffer, it can't be sent to the other destination buffers no
+/// matter the current destination buffer is active or not.
+using DataConsumerActiveCheckCallback = std::function<bool()>;
+
+struct DataAvailable {
+  DataAvailableCallback callback;
+  int64_t sequence;
+  std::vector<std::unique_ptr<folly::IOBuf>> data;
+  std::vector<int64_t> remainingBytes;
+
+  void notify() {
+    if (callback) {
+      callback(std::move(data), sequence, remainingBytes);
+    }
+  }
+};
+
+/// The class is used to buffer the output pages which haven't been fetched by
+/// any destination for arbitrary output.
+///
+/// NOTE: there is only one arbitrary buffer setup for arbitrary output to share
+/// among destinations. Also, this class is not thread-safe.
+class ArbitraryBuffer {
+ public:
+  /// Returns true if this arbitrary buffer has no buffered pages.
+  bool empty() const {
+    return pages_.empty() || (pages_.size() == 1 && pages_.back() == nullptr);
+  }
+
+  /// Returns true if this arbitrary buffer will not receive any new pages from
+  /// enqueue() but it can still has buffered pages waiting to dispatch to
+  /// destination on data fetch.
+  bool hasNoMoreData() const {
+    return !pages_.empty() && (pages_.back() == nullptr);
+  }
+
+  /// Marks this arbitrary buffer will not receive any new incoming pages. It
+  /// appends a null page at the end of 'pages_' as end marker.
+  void noMoreData();
+
+  void enqueue(std::unique_ptr<SerializedPage> page);
+
+  /// Returns a number of pages with total bytes no less than 'maxBytes' if
+  /// there are sufficient buffered pages.
+  std::vector<std::shared_ptr<SerializedPage>> getPages(uint64_t maxBytes);
+
+  /// Append the available page sizes to `out'.
+  void getAvailablePageSizes(std::vector<int64_t>& out) const;
+
+  std::string toString() const;
+
+ private:
+  std::deque<std::shared_ptr<SerializedPage>> pages_;
+};
+
+class DestinationBuffer {
+ public:
+  /// The data transferred by the destination buffer has two phases:
+  /// 1. Buffered: the data resides in the buffer after enqueued and before
+  ///              acked / deleted.
+  /// 2. Sent: the data is removed from the buffer after it is acked or
+  ///          deleted.
+  struct Stats {
+    void recordEnqueue(const SerializedPage& data);
+
+    void recordAcknowledge(const SerializedPage& data);
+
+    void recordDelete(const SerializedPage& data);
+
+    bool finished{false};
+
+    /// Number of buffered bytes / rows / pages.
+    int64_t bytesBuffered{0};
+    int64_t rowsBuffered{0};
+    int64_t pagesBuffered{0};
+
+    /// Number of sent bytes / rows / pages.
+    int64_t bytesSent{0};
+    int64_t rowsSent{0};
+    int64_t pagesSent{0};
+  };
+
+  void enqueue(std::shared_ptr<SerializedPage> data);
+
+  /// Invoked to load data with up to 'notifyMaxBytes_' bytes from arbitrary
+  /// 'buffer' if there is pending fetch from this destination in which case
+  /// 'notify_' is not null. Otherwise, it does nothing. This only used by
+  /// arbitrary output type when enqueue new data.
+  void maybeLoadData(ArbitraryBuffer* buffer);
+
+  /// Invoked to load data with up to 'maxBytes' from arbitrary 'buffer' when
+  /// fetch data from this destination. This only used by arbitrary output type
+  /// which doesn't expect to buffer any data and is always load data from the
+  /// arbitrary buffer on demand.
+  void loadData(ArbitraryBuffer* buffer, uint64_t maxBytes);
+
+  struct Data {
+    /// The actual data available at this buffer.
+    std::vector<std::unique_ptr<folly::IOBuf>> data;
+
+    /// The byte sizes of pages that can be fetched.
+    std::vector<int64_t> remainingBytes;
+
+    /// Whether the result is returned immediately without invoking the `notify'
+    /// callback.
+    bool immediate;
+  };
+
+  /// Returns a shallow copy (folly::IOBuf::clone) of the data starting at
+  /// 'sequence', stopping after exceeding 'maxBytes'. If there is no data,
+  /// 'notify' is installed so that this gets called when data is added. If not
+  /// null, 'activeCheck' is used to check if the consumer of a destination
+  /// buffer with 'notify' installed is currently active or not. This only
+  /// applies for arbitrary output buffer for now.
+  ///
+  /// When arbitraryBuffer is provided, and this buffer is not at end (no null
+  /// marker received), we append the remaining bytes from arbitraryBuffer in
+  /// the result, even the arbitraryBuffer could be shared among multiple
+  /// DestinationBuffers.
+  Data getData(
+      uint64_t maxBytes,
+      int64_t sequence,
+      DataAvailableCallback notify,
+      DataConsumerActiveCheckCallback activeCheck,
+      ArbitraryBuffer* arbitraryBuffer = nullptr);
+
+  /// Removes data from the queue and returns removed data. If 'fromGetData' we
+  /// do not give a warning for the case where no data is removed, otherwise we
+  /// expect that data does get freed. We cannot assert that data gets deleted
+  /// because acknowledge messages can arrive out of order.
+  std::vector<std::shared_ptr<SerializedPage>> acknowledge(
+      int64_t sequence,
+      bool fromGetData);
+
+  /// Removes all remaining data from the queue and returns the removed data.
+  std::vector<std::shared_ptr<SerializedPage>> deleteResults();
+
+  /// Returns and clears the notify callback, if any, along with arguments for
+  /// the callback.
+  DataAvailable getAndClearNotify();
+
+  /// Finishes this destination buffer, set finished stats.
+  void finish();
+
+  /// Returns the stats of this buffer.
+  Stats stats() const;
+
+  std::string toString();
+
+ private:
+  void clearNotify();
+
+  std::vector<std::shared_ptr<SerializedPage>> data_;
+  // The sequence number of the first in 'data_'.
+  int64_t sequence_ = 0;
+  DataAvailableCallback notify_{nullptr};
+  DataConsumerActiveCheckCallback aliveCheck_{nullptr};
+  // The sequence number of the first item to pass to 'notify'.
+  int64_t notifySequence_{0};
+  uint64_t notifyMaxBytes_{0};
+  Stats stats_;
+};
+
+class Task;
+
+class OutputBuffer {
+ public:
+  struct Stats {
+    Stats(
+        core::PartitionedOutputNode::Kind _kind,
+        bool _noMoreBuffers,
+        bool _noMoreData,
+        bool _finished,
+        int64_t _bufferedBytes,
+        int64_t _bufferedPages,
+        int64_t _totalBytesSent,
+        int64_t _totalRowsSent,
+        int64_t _totalPagesSent,
+        int64_t _averageBufferTimeMs,
+        int32_t _numTopBuffers,
+        const std::vector<DestinationBuffer::Stats>& _buffersStats)
+        : kind(_kind),
+          noMoreBuffers(_noMoreBuffers),
+          noMoreData(_noMoreData),
+          finished(_finished),
+          bufferedBytes(_bufferedBytes),
+          bufferedPages(_bufferedPages),
+          totalBytesSent(_totalBytesSent),
+          totalRowsSent(_totalRowsSent),
+          totalPagesSent(_totalPagesSent),
+          averageBufferTimeMs(_averageBufferTimeMs),
+          numTopBuffers(_numTopBuffers),
+          buffersStats(_buffersStats) {}
+
+    core::PartitionedOutputNode::Kind kind;
+
+    /// States of this output buffer.
+    bool noMoreBuffers{false};
+    bool noMoreData{false};
+    bool finished{false};
+
+    /// The sum of buffered bytes/pages in this output buffer.
+    int64_t bufferedBytes{0};
+    int64_t bufferedPages{0};
+
+    /// The total number of bytes/rows/pages sent via this output buffer.
+    int64_t totalBytesSent{0};
+    int64_t totalRowsSent{0};
+    int64_t totalPagesSent{0};
+
+    /// Average time each piece of data has been buffered for in milliseconds.
+    int64_t averageBufferTimeMs{0};
+
+    /// The number of largest buffers that handle 80% of the total data.
+    int32_t numTopBuffers{0};
+
+    /// Stats of the OutputBuffer's destinations.
+    std::vector<DestinationBuffer::Stats> buffersStats;
+
+    std::string toString() const;
+  };
+
+  OutputBuffer(
+      std::shared_ptr<Task> task,
+      core::PartitionedOutputNode::Kind kind,
+      int numDestinations,
+      uint32_t numDrivers);
+
+  core::PartitionedOutputNode::Kind kind() const {
+    return kind_;
+  }
+
+  /// The total number of output buffers may not be known at the task start
+  /// time for broadcast and arbitrary output buffer type. This method can be
+  /// called to update the total number of broadcast or arbitrary destinations
+  /// while the task is running. The function throws if this is partitioned
+  /// output buffer type.
+  void updateOutputBuffers(int numBuffers, bool noMoreBuffers);
+
+  /// When we understand the final number of split groups (for grouped
+  /// execution only), we need to update the number of producing drivers here.
+  void updateNumDrivers(uint32_t newNumDrivers);
+
+  bool enqueue(
+      int destination,
+      std::unique_ptr<SerializedPage> data,
+      ContinueFuture* future);
+
+  void noMoreData();
+
+  void noMoreDrivers();
+
+  bool isFinished();
+
+  bool isFinishedLocked();
+
+  void acknowledge(int destination, int64_t sequence);
+
+  /// Deletes all buffered data and makes all subsequent getData requests
+  /// for 'destination' return empty results. Returns true if all destinations
+  /// are deleted, meaning that the buffer is fully consumed and the producer
+  /// can be marked finished and the buffers freed.
+  bool deleteResults(int destination);
+
+  void getData(
+      int destination,
+      uint64_t maxSize,
+      int64_t sequence,
+      DataAvailableCallback notify,
+      DataConsumerActiveCheckCallback activeCheck);
+
+  // Continues any possibly waiting producers. Called when the
+  // producer task has an error or cancellation.
+  void terminate();
+
+  std::string toString();
+
+  /// Gets the memory utilization ratio in this output buffer.
+  double getUtilization() const;
+
+  /// Indicates if this output buffer is over-utilized, i.e. at least half full,
+  /// and will start blocking producers soon. This is used to dynamically scale
+  /// the number of consumers, for example, increase number of TableWriter
+  /// tasks.
+  bool isOverutilized() const;
+
+  /// Gets the Stats of this output buffer.
+  Stats stats();
+
+ private:
+  // Percentage of maxSize below which a blocked producer should
+  // be unblocked.
+  static constexpr int32_t kContinuePct = 90;
+
+  void updateStatsWithEnqueuedPageLocked(int64_t pageBytes, int64_t pageRows);
+
+  void updateStatsWithFreedPagesLocked(int numPages, int64_t pageBytes);
+
+  void updateTotalBufferedBytesMsLocked();
+
+  int64_t getAverageBufferTimeMsLocked() const;
+
+  // If this is called due to a driver processed all its data (no more data),
+  // we increment the number of finished drivers. If it is called due to us
+  // updating the total number of drivers, we don't.
+  void checkIfDone(bool oneDriverFinished);
+
+  // Updates buffered size and returns possibly continuable producer promises
+  // in 'promises'.
+  void updateAfterAcknowledgeLocked(
+      const std::vector<std::shared_ptr<SerializedPage>>& freed,
+      std::vector<ContinuePromise>& promises);
+
+  /// Given an updated total number of broadcast buffers, add any missing ones
+  /// and enqueue data that has been produced so far (e.g. dataToBroadcast_).
+  void addOutputBuffersLocked(int numBuffers);
+
+  void enqueueBroadcastOutputLocked(
+      std::unique_ptr<SerializedPage> data,
+      std::vector<DataAvailable>& dataAvailableCbs);
+
+  void enqueueArbitraryOutputLocked(
+      std::unique_ptr<SerializedPage> data,
+      std::vector<DataAvailable>& dataAvailableCbs);
+
+  void enqueuePartitionedOutputLocked(
+      int destination,
+      std::unique_ptr<SerializedPage> data,
+      std::vector<DataAvailable>& dataAvailableCbs);
+
+  std::string toStringLocked() const;
+
+  FOLLY_ALWAYS_INLINE bool isBroadcast() const {
+    return kind_ == core::PartitionedOutputNode::Kind::kBroadcast;
+  }
+
+  FOLLY_ALWAYS_INLINE bool isPartitioned() const {
+    return kind_ == core::PartitionedOutputNode::Kind::kPartitioned;
+  }
+
+  FOLLY_ALWAYS_INLINE bool isArbitrary() const {
+    return kind_ == core::PartitionedOutputNode::Kind::kArbitrary;
+  }
+
+  const std::shared_ptr<Task> task_;
+  const core::PartitionedOutputNode::Kind kind_;
+  /// If 'totalSize_' > 'maxSize_', each producer is blocked after adding
+  /// data.
+  const uint64_t maxSize_;
+  // When 'totalSize_' goes below 'continueSize_', blocked producers are
+  // resumed.
+  const uint64_t continueSize_;
+  const std::unique_ptr<ArbitraryBuffer> arbitraryBuffer_;
+
+  // Total number of drivers expected to produce results. This number will
+  // decrease in the end of grouped execution, when we understand the real
+  // number of producer drivers (depending on the number of split groups).
+  uint32_t numDrivers_{0};
+
+  // If true, then we don't allow to add new destination buffers. This only
+  // applies for non-partitioned output buffer type.
+  bool noMoreBuffers_{false};
+
+  // While noMoreBuffers_ is false, stores the enqueued data to
+  // broadcast to destinations that have not yet been initialized. Cleared
+  // after receiving no-more-broadcast-buffers signal.
+  std::vector<std::shared_ptr<SerializedPage>> dataToBroadcast_;
+
+  std::mutex mutex_;
+  // Actual data size in 'buffers_'.
+  int64_t bufferedBytes_{0};
+  // The number of buffered pages which corresponds to 'bufferedBytes_'.
+  int64_t bufferedPages_{0};
+  // The total number of output bytes, rows and pages.
+  uint64_t numOutputBytes_{0};
+  uint64_t numOutputRows_{0};
+  uint64_t numOutputPages_{0};
+  std::vector<ContinuePromise> promises_;
+  // The next buffer index in 'buffers_' to load data from arbitrary buffer
+  // which is only used by arbitrary output type.
+  int32_t nextArbitraryLoadBufferIndex_{0};
+  // One buffer per destination.
+  std::vector<std::unique_ptr<DestinationBuffer>> buffers_;
+  // The sizes of buffers_ and finishedBufferStats_ are the same, but
+  // finishedBufferStats_[i] is set if and only if buffers_[i] is null as
+  // the buffer is finished and deleted.
+  std::vector<DestinationBuffer::Stats> finishedBufferStats_;
+  uint32_t numFinished_{0};
+  // When this reaches buffers_.size(), 'this' can be freed.
+  int numFinalAcknowledges_ = 0;
+  bool atEnd_ = false;
+
+  // Time since last change in bufferedBytes_. Used to compute total time data
+  // is buffered. Ignored if bufferedBytes_ is zero.
+  uint64_t bufferStartMs_;
+
+  // Total time data is buffered as bytes * time.
+  double totalBufferedBytesMs_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/OutputBufferManager.cpp b/velox/exec/OutputBufferManager.cpp
new file mode 100644
index 0000000000000..0425218d175a5
--- /dev/null
+++ b/velox/exec/OutputBufferManager.cpp
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/OutputBufferManager.h"
+#include "velox/exec/Task.h"
+
+namespace facebook::velox::exec {
+// static
+void OutputBufferManager::initialize(const Options& options) {
+  std::lock_guard<std::mutex> l(initMutex_);
+  VELOX_CHECK(
+      instance_ == nullptr, "May initialize OutputBufferManager only once");
+  instance_ = std::make_shared<OutputBufferManager>(options);
+}
+
+// static
+std::weak_ptr<OutputBufferManager> OutputBufferManager::getInstance() {
+  std::lock_guard<std::mutex> l(initMutex_);
+  if (!instance_) {
+    instance_ = std::make_shared<OutputBufferManager>(Options());
+  }
+  return instance_;
+}
+
+std::shared_ptr<OutputBuffer> OutputBufferManager::getBuffer(
+    const std::string& taskId) {
+  return buffers_.withLock([&](auto& buffers) {
+    auto it = buffers.find(taskId);
+    VELOX_CHECK(
+        it != buffers.end(), "Output buffers for task not found: {}", taskId);
+    return it->second;
+  });
+}
+
+std::shared_ptr<OutputBuffer> OutputBufferManager::getBufferIfExists(
+    const std::string& taskId) {
+  return buffers_.withLock([&](auto& buffers) {
+    auto it = buffers.find(taskId);
+    return it == buffers.end() ? nullptr : it->second;
+  });
+}
+
+uint64_t OutputBufferManager::numBuffers() const {
+  return buffers_.lock()->size();
+}
+
+bool OutputBufferManager::enqueue(
+    const std::string& taskId,
+    int destination,
+    std::unique_ptr<SerializedPage> data,
+    ContinueFuture* future) {
+  return getBuffer(taskId)->enqueue(destination, std::move(data), future);
+}
+
+void OutputBufferManager::noMoreData(const std::string& taskId) {
+  getBuffer(taskId)->noMoreData();
+}
+
+bool OutputBufferManager::isFinished(const std::string& taskId) {
+  return getBuffer(taskId)->isFinished();
+}
+
+void OutputBufferManager::acknowledge(
+    const std::string& taskId,
+    int destination,
+    int64_t sequence) {
+  auto buffer =
+      buffers_.withLock([&](auto& buffers) -> std::shared_ptr<OutputBuffer> {
+        auto it = buffers.find(taskId);
+        if (it == buffers.end()) {
+          VLOG(1) << "Receiving ack for non-existent task " << taskId
+                  << " destination " << destination << " sequence " << sequence;
+          return nullptr;
+        }
+        return it->second;
+      });
+  if (buffer) {
+    buffer->acknowledge(destination, sequence);
+  }
+}
+
+void OutputBufferManager::deleteResults(
+    const std::string& taskId,
+    int destination) {
+  if (auto buffer = getBufferIfExists(taskId)) {
+    buffer->deleteResults(destination);
+  }
+}
+
+bool OutputBufferManager::getData(
+    const std::string& taskId,
+    int destination,
+    uint64_t maxBytes,
+    int64_t sequence,
+    DataAvailableCallback notify,
+    DataConsumerActiveCheckCallback activeCheck) {
+  if (auto buffer = getBufferIfExists(taskId)) {
+    buffer->getData(destination, maxBytes, sequence, notify, activeCheck);
+    return true;
+  }
+  return false;
+}
+
+void OutputBufferManager::initializeTask(
+    std::shared_ptr<Task> task,
+    core::PartitionedOutputNode::Kind kind,
+    int numDestinations,
+    int numDrivers) {
+  const auto& taskId = task->taskId();
+
+  buffers_.withLock([&](auto& buffers) {
+    auto it = buffers.find(taskId);
+    if (it == buffers.end()) {
+      buffers[taskId] = std::make_shared<OutputBuffer>(
+          std::move(task), kind, numDestinations, numDrivers);
+    } else {
+      VELOX_FAIL(
+          "Registering an output buffer for pre-existing taskId {}", taskId);
+    }
+  });
+}
+
+bool OutputBufferManager::updateOutputBuffers(
+    const std::string& taskId,
+    int numBuffers,
+    bool noMoreBuffers) {
+  if (auto buffer = getBufferIfExists(taskId)) {
+    buffer->updateOutputBuffers(numBuffers, noMoreBuffers);
+    return true;
+  }
+  return false;
+}
+
+bool OutputBufferManager::updateNumDrivers(
+    const std::string& taskId,
+    uint32_t newNumDrivers) {
+  if (auto buffer = getBufferIfExists(taskId)) {
+    buffer->updateNumDrivers(newNumDrivers);
+    return true;
+  }
+  return false;
+}
+
+void OutputBufferManager::removeTask(const std::string& taskId) {
+  auto buffer =
+      buffers_.withLock([&](auto& buffers) -> std::shared_ptr<OutputBuffer> {
+        auto it = buffers.find(taskId);
+        if (it == buffers.end()) {
+          // Already removed.
+          return nullptr;
+        }
+        auto taskBuffer = it->second;
+        buffers.erase(taskId);
+        return taskBuffer;
+      });
+  if (buffer != nullptr) {
+    buffer->terminate();
+  }
+}
+
+std::string OutputBufferManager::toString() {
+  return buffers_.withLock([](const auto& buffers) {
+    std::stringstream out;
+    out << "[BufferManager:" << std::endl;
+    for (const auto& pair : buffers) {
+      out << pair.first << ": " << pair.second->toString() << std::endl;
+    }
+    out << "]";
+    return out.str();
+  });
+}
+
+double OutputBufferManager::getUtilization(const std::string& taskId) {
+  auto buffer = getBufferIfExists(taskId);
+  if (buffer != nullptr) {
+    return buffer->getUtilization();
+  }
+  return 0;
+}
+
+bool OutputBufferManager::isOverutilized(const std::string& taskId) {
+  auto buffer = getBufferIfExists(taskId);
+  if (buffer != nullptr) {
+    return buffer->isOverutilized();
+  }
+  return false;
+}
+
+std::optional<OutputBuffer::Stats> OutputBufferManager::stats(
+    const std::string& taskId) {
+  auto buffer = getBufferIfExists(taskId);
+  if (buffer != nullptr) {
+    return buffer->stats();
+  }
+  return std::nullopt;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/OutputBufferManager.h b/velox/exec/OutputBufferManager.h
new file mode 100644
index 0000000000000..30da04c6e40c1
--- /dev/null
+++ b/velox/exec/OutputBufferManager.h
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/OutputBuffer.h"
+
+namespace facebook::velox::exec {
+
+class OutputBufferManager {
+ public:
+  /// Options for shuffle. This is initialized once and affects both
+  /// PartitionedOutput and Exchange. This can be used for controlling
+  /// compression, protocol version and other matters where shuffle sides should
+  /// agree.
+  struct Options {
+    common::CompressionKind compressionKind{
+        common::CompressionKind::CompressionKind_NONE};
+  };
+
+  OutputBufferManager(Options options)
+      : compressionKind_(options.compressionKind) {}
+
+  void initializeTask(
+      std::shared_ptr<Task> task,
+      core::PartitionedOutputNode::Kind kind,
+      int numDestinations,
+      int numDrivers);
+
+  /// Updates the number of buffers. Returns true if the buffer exists for a
+  /// given taskId, else returns false.
+  bool updateOutputBuffers(
+      const std::string& taskId,
+      int numBuffers,
+      bool noMoreBuffers);
+
+  /// When we understand the final number of split groups (for grouped
+  /// execution only), we need to update the number of producing drivers here.
+  /// Returns true if the buffer exists for a given taskId, else returns false.
+  bool updateNumDrivers(const std::string& taskId, uint32_t newNumDrivers);
+
+  // Adds data to the outgoing queue for 'destination'. 'data' must not be
+  // nullptr. 'data' is always added but if the buffers are full the future is
+  // set to a ContinueFuture that will be realized when there is space.
+  bool enqueue(
+      const std::string& taskId,
+      int destination,
+      std::unique_ptr<SerializedPage> data,
+      ContinueFuture* future);
+
+  void noMoreData(const std::string& taskId);
+
+  // Returns true if noMoreData has been called and all the accumulated data
+  // have been fetched and acknowledged.
+  bool isFinished(const std::string& taskId);
+
+  // Removes data with sequence number < 'sequence' from the queue for
+  // 'destination_'.
+  void
+  acknowledge(const std::string& taskId, int destination, int64_t sequence);
+
+  void deleteResults(const std::string& taskId, int destination);
+
+  /// Adds up to 'maxBytes' bytes worth of data for 'destination' from 'taskId'.
+  /// The sequence number of the data must be >= 'sequence'. If there is no
+  /// buffer associated with the given taskId, returns false. If there is no
+  /// data, 'notify' will be registered and called when there is data or the
+  /// source is at end, the function returns true. If deleteResults was
+  /// previously called for the destination, 'notify' will be called immediately
+  /// with a list of pages containing a single "end of data" marker. Existing
+  /// data with a sequence number < sequence is deleted. The caller is expected
+  /// to increment the sequence number between calls by the number of items
+  /// received. In this way the next call implicitly acknowledges receipt of the
+  /// results from the previous. The acknowledge method is offered for an early
+  /// ack, so that the producer can continue before the consumer is done
+  /// processing the received data. If not null, 'activeCheck' is used to check
+  /// if data consumer is currently active or not. This only applies for
+  /// arbitrary output buffer for now.
+  bool getData(
+      const std::string& taskId,
+      int destination,
+      uint64_t maxBytes,
+      int64_t sequence,
+      DataAvailableCallback notify,
+      DataConsumerActiveCheckCallback activeCheck = nullptr);
+
+  void removeTask(const std::string& taskId);
+
+  /// Initializes singleton with 'options'. May be called once before
+  /// getInstance().
+  static void initialize(const Options& options);
+
+  static std::weak_ptr<OutputBufferManager> getInstance();
+
+  uint64_t numBuffers() const;
+
+  // Returns a new stream listener if a listener factory has been set.
+  std::unique_ptr<OutputStreamListener> newListener() const {
+    return listenerFactory_ ? listenerFactory_() : nullptr;
+  }
+
+  // Sets the stream listener factory. This allows custom processing of data
+  // for repartitioning, e.g. computing checksums.
+  void setListenerFactory(
+      std::function<std::unique_ptr<OutputStreamListener>()> factory) {
+    listenerFactory_ = factory;
+  }
+
+  std::string toString();
+
+  // Gets the memory utilization ratio for the output buffer from a task of
+  // taskId, if the task of this taskId is not found, return 0.
+  double getUtilization(const std::string& taskId);
+
+  // If the output buffer from a task of taskId is over-utilized and blocks its
+  // producers. When the task of this taskId is not found, return false.
+  bool isOverutilized(const std::string& taskId);
+
+  // Returns nullopt when the specified output buffer doesn't exist.
+  std::optional<OutputBuffer::Stats> stats(const std::string& taskId);
+
+  // Retrieves the set of buffers for a query if exists.
+  // Returns NULL if task not found.
+  std::shared_ptr<OutputBuffer> getBufferIfExists(const std::string& taskId);
+
+  void testingSetCompression(common::CompressionKind kind) {
+    *const_cast<common::CompressionKind*>(&compressionKind_) = kind;
+  }
+
+  common::CompressionKind compressionKind() const {
+    return compressionKind_;
+  }
+
+ private:
+  // Retrieves the set of buffers for a query.
+  // Throws an exception if buffer doesn't exist.
+  std::shared_ptr<OutputBuffer> getBuffer(const std::string& taskId);
+
+  const common::CompressionKind compressionKind_;
+
+  folly::Synchronized<
+      std::unordered_map<std::string, std::shared_ptr<OutputBuffer>>,
+      std::mutex>
+      buffers_;
+
+  std::function<std::unique_ptr<OutputStreamListener>()> listenerFactory_{
+      nullptr};
+
+  inline static std::shared_ptr<OutputBufferManager> instance_;
+  inline static std::mutex initMutex_;
+};
+} // namespace facebook::velox::exec
diff --git a/velox/exec/PartitionStreamingWindowBuild.cpp b/velox/exec/PartitionStreamingWindowBuild.cpp
new file mode 100644
index 0000000000000..22bfc27ba5cce
--- /dev/null
+++ b/velox/exec/PartitionStreamingWindowBuild.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/PartitionStreamingWindowBuild.h"
+
+namespace facebook::velox::exec {
+
+PartitionStreamingWindowBuild::PartitionStreamingWindowBuild(
+    const std::shared_ptr<const core::WindowNode>& windowNode,
+    velox::memory::MemoryPool* pool,
+    const common::SpillConfig* spillConfig,
+    tsan_atomic<bool>* nonReclaimableSection)
+    : WindowBuild(windowNode, pool, spillConfig, nonReclaimableSection) {}
+
+void PartitionStreamingWindowBuild::buildNextPartition() {
+  partitionStartRows_.push_back(sortedRows_.size());
+  sortedRows_.insert(sortedRows_.end(), inputRows_.begin(), inputRows_.end());
+  inputRows_.clear();
+}
+
+void PartitionStreamingWindowBuild::addInput(RowVectorPtr input) {
+  for (auto i = 0; i < inputChannels_.size(); ++i) {
+    decodedInputVectors_[i].decode(*input->childAt(inputChannels_[i]));
+  }
+
+  for (auto row = 0; row < input->size(); ++row) {
+    char* newRow = data_->newRow();
+
+    for (auto col = 0; col < input->childrenSize(); ++col) {
+      data_->store(decodedInputVectors_[col], row, newRow, col);
+    }
+
+    if (previousRow_ != nullptr &&
+        compareRowsWithKeys(previousRow_, newRow, partitionKeyInfo_)) {
+      buildNextPartition();
+    }
+
+    inputRows_.push_back(newRow);
+    previousRow_ = newRow;
+  }
+}
+
+void PartitionStreamingWindowBuild::noMoreInput() {
+  buildNextPartition();
+
+  // Help for last partition related calculations.
+  partitionStartRows_.push_back(sortedRows_.size());
+}
+
+std::shared_ptr<WindowPartition>
+PartitionStreamingWindowBuild::nextPartition() {
+  VELOX_CHECK_GT(
+      partitionStartRows_.size(), 0, "No window partitions available");
+
+  ++currentPartition_;
+  VELOX_CHECK_LE(
+      currentPartition_,
+      partitionStartRows_.size() - 2,
+      "All window partitions consumed");
+
+  // Erase previous partition.
+  if (currentPartition_ > 0) {
+    const auto numPreviousPartitionRows =
+        partitionStartRows_[currentPartition_];
+    data_->eraseRows(
+        folly::Range<char**>(sortedRows_.data(), numPreviousPartitionRows));
+    sortedRows_.erase(
+        sortedRows_.begin(), sortedRows_.begin() + numPreviousPartitionRows);
+    sortedRows_.shrink_to_fit();
+    for (int i = currentPartition_; i < partitionStartRows_.size(); ++i) {
+      partitionStartRows_[i] =
+          partitionStartRows_[i] - numPreviousPartitionRows;
+    }
+  }
+
+  const auto partitionSize = partitionStartRows_[currentPartition_ + 1] -
+      partitionStartRows_[currentPartition_];
+  const auto partition = folly::Range(
+      sortedRows_.data() + partitionStartRows_[currentPartition_],
+      partitionSize);
+
+  return std::make_shared<WindowPartition>(
+      data_.get(), partition, inversedInputChannels_, sortKeyInfo_);
+}
+
+bool PartitionStreamingWindowBuild::hasNextPartition() {
+  return partitionStartRows_.size() > 0 &&
+      currentPartition_ < int(partitionStartRows_.size() - 2);
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/PartitionStreamingWindowBuild.h b/velox/exec/PartitionStreamingWindowBuild.h
new file mode 100644
index 0000000000000..bb5cb352d24fc
--- /dev/null
+++ b/velox/exec/PartitionStreamingWindowBuild.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/WindowBuild.h"
+
+namespace facebook::velox::exec {
+
+/// The PartitionStreamingWindowBuild is used when the input data is already
+/// sorted by {partition keys + order by keys}. The logic identifies partition
+/// changes when receiving input rows and splits out WindowPartitions for the
+/// Window operator to process.
+class PartitionStreamingWindowBuild : public WindowBuild {
+ public:
+  PartitionStreamingWindowBuild(
+      const std::shared_ptr<const core::WindowNode>& windowNode,
+      velox::memory::MemoryPool* pool,
+      const common::SpillConfig* spillConfig,
+      tsan_atomic<bool>* nonReclaimableSection);
+
+  void addInput(RowVectorPtr input) override;
+
+  void spill() override {
+    VELOX_UNREACHABLE();
+  }
+
+  std::optional<common::SpillStats> spilledStats() const override {
+    return std::nullopt;
+  }
+
+  void noMoreInput() override;
+
+  bool hasNextPartition() override;
+
+  std::shared_ptr<WindowPartition> nextPartition() override;
+
+  bool needsInput() override {
+    // No partitions are available or the currentPartition is the last available
+    // one, so can consume input rows.
+    return partitionStartRows_.empty() ||
+        currentPartition_ == partitionStartRows_.size() - 2;
+  }
+
+ private:
+  void buildNextPartition();
+
+  // Vector of pointers to each input row in the data_ RowContainer.
+  // Rows are erased from data_ when they are output from the
+  // Window operator.
+  std::vector<char*> sortedRows_;
+
+  // Holds input rows within the current partition.
+  std::vector<char*> inputRows_;
+
+  // Indices of  the start row (in sortedRows_) of each partition in
+  // the RowContainer data_. This auxiliary structure helps demarcate
+  // partitions.
+  std::vector<vector_size_t> partitionStartRows_;
+
+  // Used to compare rows based on partitionKeys.
+  char* previousRow_ = nullptr;
+
+  // Current partition being output. Used to construct WindowPartitions
+  // during resetPartition.
+  vector_size_t currentPartition_ = -1;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/PartitionedOutput.cpp b/velox/exec/PartitionedOutput.cpp
index 9f45bde8b51b4..d86563a29d11c 100644
--- a/velox/exec/PartitionedOutput.cpp
+++ b/velox/exec/PartitionedOutput.cpp
@@ -15,73 +15,68 @@
  */
 
 #include "velox/exec/PartitionedOutput.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
-
 namespace detail {
 BlockingReason Destination::advance(
     uint64_t maxBytes,
     const std::vector<vector_size_t>& sizes,
     const RowVectorPtr& output,
-    PartitionedOutputBufferManager& bufferManager,
+    OutputBufferManager& bufferManager,
     const std::function<void()>& bufferReleaseFn,
     bool* atEnd,
-    ContinueFuture* future) {
-  if (rangeIdx_ >= ranges_.size()) {
+    ContinueFuture* future,
+    Scratch& scratch) {
+  if (rowIdx_ >= rows_.size()) {
     *atEnd = true;
     return BlockingReason::kNotBlocked;
   }
 
+  const auto firstRow = rowIdx_;
   const uint32_t adjustedMaxBytes = (maxBytes * targetSizePct_) / 100;
   if (bytesInCurrent_ >= adjustedMaxBytes) {
     return flush(bufferManager, bufferReleaseFn, future);
   }
 
-  auto firstRangeIdx = rangeIdx_;
-  for (; rangeIdx_ < ranges_.size(); ++rangeIdx_) {
-    // TODO: add support for serializing partial ranges if the full range is too
-    // big.
-    for (vector_size_t i = 0; i < ranges_[rangeIdx_].size; i++) {
-      bytesInCurrent_ += sizes[ranges_[rangeIdx_].begin + i];
-    }
-    if (bytesInCurrent_ >= adjustedMaxBytes ||
-        rangeIdx_ - firstRangeIdx >= targetNumRows_) {
-      serialize(output, firstRangeIdx, rangeIdx_ + 1);
-      if (rangeIdx_ == ranges_.size() - 1) {
-        *atEnd = true;
-      }
-      ++rangeIdx_;
-      return flush(bufferManager, bufferReleaseFn, future);
-    }
+  // Collect rows to serialize.
+  bool shouldFlush = false;
+  while (rowIdx_ < rows_.size() && !shouldFlush) {
+    bytesInCurrent_ += sizes[rows_[rowIdx_]];
+    ++rowIdx_;
+    ++rowsInCurrent_;
+    shouldFlush =
+        bytesInCurrent_ >= adjustedMaxBytes || rowsInCurrent_ >= targetNumRows_;
   }
-  serialize(output, firstRangeIdx, rangeIdx_);
-  *atEnd = true;
-  return BlockingReason::kNotBlocked;
-}
 
-void Destination::serialize(
-    const RowVectorPtr& output,
-    vector_size_t begin,
-    vector_size_t end) {
+  // Serialize
   if (!current_) {
     current_ = std::make_unique<VectorStreamGroup>(pool_);
     auto rowType = asRowType(output->type());
-    vector_size_t numRows = 0;
-    for (vector_size_t i = begin; i < end; i++) {
-      numRows += ranges_[i].size;
-    }
-    current_->createStreamTree(rowType, numRows);
+    serializer::presto::PrestoVectorSerde::PrestoOptions options;
+    options.compressionKind =
+        OutputBufferManager::getInstance().lock()->compressionKind();
+    options.minCompressionRatio = PartitionedOutput::minCompressionRatio();
+    current_->createStreamTree(rowType, rowsInCurrent_, &options);
+  }
+  current_->append(
+      output, folly::Range(&rows_[firstRow], rowIdx_ - firstRow), scratch);
+  // Update output state variable.
+  if (rowIdx_ == rows_.size()) {
+    *atEnd = true;
   }
-  current_->append(output, folly::Range(&ranges_[begin], end - begin));
+  if (shouldFlush || (eagerFlush_ && rowsInCurrent_ > 0)) {
+    return flush(bufferManager, bufferReleaseFn, future);
+  }
+  return BlockingReason::kNotBlocked;
 }
 
 BlockingReason Destination::flush(
-    PartitionedOutputBufferManager& bufferManager,
+    OutputBufferManager& bufferManager,
     const std::function<void()>& bufferReleaseFn,
     ContinueFuture* future) {
-  if (!current_) {
+  if (!current_ || rowsInCurrent_ == 0) {
     return BlockingReason::kNotBlocked;
   }
 
@@ -92,25 +87,48 @@ BlockingReason Destination::flush(
       *current_->pool(),
       listener.get(),
       std::max<int64_t>(kMinMessageSize, current_->size()));
+  const int64_t flushedRows = rowsInCurrent_;
+
   current_->flush(&stream);
-  current_.reset();
+  current_->clear();
+
+  const int64_t flushedBytes = stream.tellp();
+
   bytesInCurrent_ = 0;
+  rowsInCurrent_ = 0;
   setTargetSizePct();
 
   bool blocked = bufferManager.enqueue(
       taskId_,
       destination_,
-      std::make_unique<SerializedPage>(stream.getIOBuf(bufferReleaseFn)),
+      std::make_unique<SerializedPage>(
+          stream.getIOBuf(bufferReleaseFn), nullptr, flushedRows),
       future);
+
+  recordEnqueued_(flushedBytes, flushedRows);
+
   return blocked ? BlockingReason::kWaitForConsumer
                  : BlockingReason::kNotBlocked;
 }
+
+void Destination::updateStats(Operator* op) {
+  VELOX_CHECK(finished_);
+  if (current_) {
+    const auto serializerStats = current_->runtimeStats();
+    auto lockedStats = op->stats().wlock();
+    for (auto& pair : serializerStats) {
+      lockedStats->addRuntimeStat(pair.first, pair.second);
+    }
+  }
+}
+
 } // namespace detail
 
 PartitionedOutput::PartitionedOutput(
     int32_t operatorId,
     DriverCtx* ctx,
-    const std::shared_ptr<const core::PartitionedOutputNode>& planNode)
+    const std::shared_ptr<const core::PartitionedOutputNode>& planNode,
+    bool eagerFlush)
     : Operator(
           ctx,
           planNode->outputType(),
@@ -128,7 +146,7 @@ PartitionedOutput::PartitionedOutput(
           planNode->inputType(),
           planNode->outputType(),
           planNode->outputType())),
-      bufferManager_(PartitionedOutputBufferManager::getInstance()),
+      bufferManager_(OutputBufferManager::getInstance()),
       // NOTE: 'bufferReleaseFn_' holds a reference on the associated task to
       // prevent it from deleting while there are output buffers being accessed
       // out of the partitioned output buffer manager such as in Prestissimo,
@@ -136,7 +154,8 @@ PartitionedOutput::PartitionedOutput(
       bufferReleaseFn_([task = operatorCtx_->task()]() {}),
       maxBufferedBytes_(ctx->task->queryCtx()
                             ->queryConfig()
-                            .maxPartitionedOutputBufferSize()) {
+                            .maxPartitionedOutputBufferSize()),
+      eagerFlush_(eagerFlush) {
   if (!planNode->isPartitioned()) {
     VELOX_USER_CHECK_EQ(numDestinations_, 1);
   }
@@ -177,20 +196,18 @@ void PartitionedOutput::initializeDestinations() {
   if (destinations_.empty()) {
     auto taskId = operatorCtx_->taskId();
     for (int i = 0; i < numDestinations_; ++i) {
-      destinations_.push_back(
-          std::make_unique<detail::Destination>(taskId, i, pool()));
+      destinations_.push_back(std::make_unique<detail::Destination>(
+          taskId, i, pool(), eagerFlush_, [&](uint64_t bytes, uint64_t rows) {
+            auto lockedStats = stats_.wlock();
+            lockedStats->addOutputVector(bytes, rows);
+          }));
     }
   }
 }
 
 void PartitionedOutput::initializeSizeBuffers() {
   auto numInput = input_->size();
-  if (numInput > topLevelRanges_.size()) {
-    vector_size_t numOld = topLevelRanges_.size();
-    topLevelRanges_.resize(numInput);
-    for (auto i = numOld; i < numInput; ++i) {
-      topLevelRanges_[i] = IndexRange{i, 1};
-    }
+  if (numInput > rowSize_.size()) {
     rowSize_.resize(numInput);
     sizePointers_.resize(numInput);
     // Set all the size pointers since 'rowSize_' may have been reallocated.
@@ -203,21 +220,18 @@ void PartitionedOutput::initializeSizeBuffers() {
 void PartitionedOutput::estimateRowSizes() {
   auto numInput = input_->size();
   std::fill(rowSize_.begin(), rowSize_.end(), 0);
+  raw_vector<vector_size_t> storage;
+  auto numbers = iota(numInput, storage);
   for (int i = 0; i < output_->childrenSize(); ++i) {
     VectorStreamGroup::estimateSerializedSize(
-        output_->childAt(i),
-        folly::Range(topLevelRanges_.data(), numInput),
-        sizePointers_.data());
+        output_->childAt(i).get(),
+        folly::Range(numbers, numInput),
+        sizePointers_.data(),
+        scratch_);
   }
 }
 
 void PartitionedOutput::addInput(RowVectorPtr input) {
-  // TODO Report outputBytes as bytes after serialization
-  {
-    auto lockedStats = stats_.wlock();
-    lockedStats->addOutputVector(input->estimateFlatSize(), input->size());
-  }
-
   initializeInput(std::move(input));
 
   initializeDestinations();
@@ -283,11 +297,18 @@ void PartitionedOutput::collectNullRows() {
 
   decodedVectors_.resize(keyChannels_.size());
 
-  for (auto i : keyChannels_) {
-    auto& keyVector = input_->childAt(i);
+  for (size_t keyChannelIndex = 0; keyChannelIndex < keyChannels_.size();
+       ++keyChannelIndex) {
+    column_index_t keyChannel = keyChannels_[keyChannelIndex];
+    // Skip constant channel.
+    if (keyChannel == kConstantChannel) {
+      continue;
+    }
+    auto& keyVector = input_->childAt(keyChannel);
     if (keyVector->mayHaveNulls()) {
-      decodedVectors_[i].decode(*keyVector, rows_);
-      if (auto* rawNulls = decodedVectors_[i].nulls()) {
+      DecodedVector& decodedVector = decodedVectors_[keyChannelIndex];
+      decodedVector.decode(*keyVector, rows_);
+      if (auto* rawNulls = decodedVector.nulls(&rows_)) {
         bits::orWithNegatedBits(
             nullRows_.asMutableRange().bits(), rawNulls, 0, size);
       }
@@ -305,7 +326,7 @@ RowVectorPtr PartitionedOutput::getOutput() {
   detail::Destination* blockedDestination = nullptr;
   auto bufferManager = bufferManager_.lock();
   VELOX_CHECK_NOT_NULL(
-      bufferManager, "PartitionedOutputBufferManager was already destructed");
+      bufferManager, "OutputBufferManager was already destructed");
 
   // Limit serialized pages to 1MB.
   static const uint64_t kMaxPageSize = 1 << 20;
@@ -325,7 +346,8 @@ RowVectorPtr PartitionedOutput::getOutput() {
           *bufferManager,
           bufferReleaseFn_,
           &atEnd,
-          &future_);
+          &future_,
+          scratch_);
       if (blockingReason_ != BlockingReason::kNotBlocked) {
         blockedDestination = destination.get();
         workLeft = false;
@@ -363,6 +385,7 @@ RowVectorPtr PartitionedOutput::getOutput() {
       }
       destination->flush(*bufferManager, bufferReleaseFn_, nullptr);
       destination->setFinished();
+      destination->updateStats(this);
     }
 
     bufferManager->noMoreData(operatorCtx_->task()->taskId());
diff --git a/velox/exec/PartitionedOutput.h b/velox/exec/PartitionedOutput.h
index fc76d9598595b..28ef0877458de 100644
--- a/velox/exec/PartitionedOutput.h
+++ b/velox/exec/PartitionedOutput.h
@@ -17,7 +17,7 @@
 
 #include <folly/Random.h>
 #include "velox/exec/Operator.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/OutputBufferManager.h"
 #include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::exec {
@@ -25,39 +25,51 @@ namespace facebook::velox::exec {
 namespace detail {
 class Destination {
  public:
+  /// @param recordEnqueued Should be called to record each call to
+  /// OutputBufferManager::enqueue. Takes number of bytes and rows.
   Destination(
       const std::string& taskId,
       int destination,
-      memory::MemoryPool* pool)
-      : taskId_(taskId), destination_(destination), pool_(pool) {
+      memory::MemoryPool* pool,
+      bool eagerFlush,
+      std::function<void(uint64_t bytes, uint64_t rows)> recordEnqueued)
+      : taskId_(taskId),
+        destination_(destination),
+        pool_(pool),
+        eagerFlush_(eagerFlush),
+        recordEnqueued_(std::move(recordEnqueued)) {
     setTargetSizePct();
   }
 
   // Resets the destination before starting a new batch.
   void beginBatch() {
-    ranges_.clear();
-    rangeIdx_ = 0;
+    rows_.clear();
+    rowIdx_ = 0;
   }
 
   void addRow(vector_size_t row) {
-    ranges_.push_back(IndexRange{row, 1});
+    rows_.push_back(row);
   }
 
   void addRows(const IndexRange& rows) {
-    ranges_.push_back(rows);
+    for (auto i = 0; i < rows.size; ++i) {
+      rows_.push_back(rows.begin + i);
+    }
   }
 
+  // Serializes row from 'output' till either 'maxBytes' have been serialized or
   BlockingReason advance(
       uint64_t maxBytes,
       const std::vector<vector_size_t>& sizes,
       const RowVectorPtr& output,
-      PartitionedOutputBufferManager& bufferManager,
+      OutputBufferManager& bufferManager,
       const std::function<void()>& bufferReleaseFn,
       bool* atEnd,
-      ContinueFuture* future);
+      ContinueFuture* future,
+      Scratch& scratch);
 
   BlockingReason flush(
-      PartitionedOutputBufferManager& bufferManager,
+      OutputBufferManager& bufferManager,
       const std::function<void()>& bufferReleaseFn,
       ContinueFuture* future);
 
@@ -73,10 +85,10 @@ class Destination {
     return bytesInCurrent_;
   }
 
- private:
-  void
-  serialize(const RowVectorPtr& input, vector_size_t begin, vector_size_t end);
+  /// Adds stats from 'this' to runtime stats of 'op'.
+  void updateStats(Operator* op);
 
+ private:
   // Sets the next target size for flushing. This is called at the
   // start of each batch of output for the destination. The effect is
   // to make different destinations ready at slightly different times
@@ -93,11 +105,20 @@ class Destination {
   const std::string taskId_;
   const int destination_;
   memory::MemoryPool* const pool_;
+  const bool eagerFlush_;
+  const std::function<void(uint64_t bytes, uint64_t rows)> recordEnqueued_;
+
+  // Bytes serialized in 'current_'
   uint64_t bytesInCurrent_{0};
-  std::vector<IndexRange> ranges_;
+  // Number of rows serialized in 'current_'
+  vector_size_t rowsInCurrent_{0};
+  raw_vector<vector_size_t> rows_;
+
+  // First index of 'rows_' that is not appended to 'current_'.
+  vector_size_t rowIdx_{0};
 
-  // First range index of 'ranges_' that is not appended to 'current_'.
-  vector_size_t rangeIdx_{0};
+  // The current stream where the input is serialized to. This is cleared on
+  // every flush() call.
   std::unique_ptr<VectorStreamGroup> current_;
   bool finished_{false};
 
@@ -133,7 +154,8 @@ class PartitionedOutput : public Operator {
   PartitionedOutput(
       int32_t operatorId,
       DriverCtx* ctx,
-      const std::shared_ptr<const core::PartitionedOutputNode>& planNode);
+      const std::shared_ptr<const core::PartitionedOutputNode>& planNode,
+      bool eagerFlush);
 
   void addInput(RowVectorPtr input) override;
 
@@ -163,6 +185,14 @@ class PartitionedOutput : public Operator {
     destinations_.clear();
   }
 
+  static void testingSetMinCompressionRatio(float ratio) {
+    minCompressionRatio_ = ratio;
+  }
+
+  static float minCompressionRatio() {
+    return minCompressionRatio_;
+  }
+
  private:
   void initializeInput(RowVectorPtr input);
 
@@ -175,23 +205,24 @@ class PartitionedOutput : public Operator {
   /// Collect all rows with null keys into nullRows_.
   void collectNullRows();
 
+  // If compression in serde is enabled, this is the minimum compression that
+  // must be achieved before starting to skip compression. Used for testing.
+  inline static float minCompressionRatio_ = 0.8;
+
   const std::vector<column_index_t> keyChannels_;
   const int numDestinations_;
   const bool replicateNullsAndAny_;
   std::unique_ptr<core::PartitionFunction> partitionFunction_;
   // Empty if column order in the output is exactly the same as in input.
   const std::vector<column_index_t> outputChannels_;
-  const std::weak_ptr<exec::PartitionedOutputBufferManager> bufferManager_;
+  const std::weak_ptr<exec::OutputBufferManager> bufferManager_;
   const std::function<void()> bufferReleaseFn_;
   const int64_t maxBufferedBytes_;
+  const bool eagerFlush_;
 
   BlockingReason blockingReason_{BlockingReason::kNotBlocked};
   ContinueFuture future_;
   bool finished_{false};
-  // top-level row numbers used as input to
-  // VectorStreamGroup::estimateSerializedSize member variable is used to avoid
-  // re-allocating memory
-  std::vector<IndexRange> topLevelRanges_;
   std::vector<vector_size_t*> sizePointers_;
   std::vector<vector_size_t> rowSize_;
   std::vector<std::unique_ptr<detail::Destination>> destinations_;
@@ -203,6 +234,7 @@ class PartitionedOutput : public Operator {
   SelectivityVector nullRows_;
   std::vector<uint32_t> partitions_;
   std::vector<DecodedVector> decodedVectors_;
+  Scratch scratch_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/PartitionedOutputBuffer.cpp b/velox/exec/PartitionedOutputBuffer.cpp
deleted file mode 100644
index 33e8b1c50bdea..0000000000000
--- a/velox/exec/PartitionedOutputBuffer.cpp
+++ /dev/null
@@ -1,645 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/exec/PartitionedOutputBuffer.h"
-#include "velox/exec/Task.h"
-
-namespace facebook::velox::exec {
-
-using core::PartitionedOutputNode;
-
-void ArbitraryBuffer::noMoreData() {
-  // Drop duplicate end markers.
-  if (!pages_.empty() && pages_.back() == nullptr) {
-    return;
-  }
-  pages_.push_back(nullptr);
-}
-
-void ArbitraryBuffer::enqueue(std::unique_ptr<SerializedPage> page) {
-  VELOX_CHECK_NOT_NULL(page, "Unexpected null page");
-  VELOX_CHECK(!hasNoMoreData(), "Arbitrary buffer has set no more data marker");
-  pages_.push_back(std::shared_ptr<SerializedPage>(page.release()));
-}
-
-std::vector<std::shared_ptr<SerializedPage>> ArbitraryBuffer::getPages(
-    uint64_t maxBytes) {
-  VELOX_CHECK_GT(maxBytes, 0, "maxBytes can't be zero");
-
-  std::vector<std::shared_ptr<SerializedPage>> pages;
-  uint64_t bytesRemoved{0};
-  while (bytesRemoved < maxBytes && !pages_.empty()) {
-    if (pages_.front() == nullptr) {
-      // NOTE: keep the end marker in arbitrary buffer to signal all the
-      // destination buffers after the buffers have all been consumed.
-      VELOX_CHECK_EQ(pages_.size(), 1);
-      pages.push_back(nullptr);
-      break;
-    }
-    bytesRemoved += pages_.front()->size();
-    pages.push_back(std::move(pages_.front()));
-    pages_.pop_front();
-  }
-  return pages;
-}
-
-std::string ArbitraryBuffer::toString() const {
-  return fmt::format(
-      "[ARBITRARY_BUFFER PAGES[{}] NO MORE DATA[{}]]",
-      pages_.size() - !!hasNoMoreData(),
-      hasNoMoreData());
-}
-
-std::vector<std::unique_ptr<folly::IOBuf>> DestinationBuffer::getData(
-    uint64_t maxBytes,
-    int64_t sequence,
-    DataAvailableCallback notify,
-    ArbitraryBuffer* arbitraryBuffer) {
-  VELOX_CHECK_GE(
-      sequence, sequence_, "Get received for an already acknowledged item");
-  if (arbitraryBuffer != nullptr) {
-    loadData(arbitraryBuffer, maxBytes);
-  }
-
-  if (sequence - sequence_ > data_.size()) {
-    VLOG(1) << this << " Out of order get: " << sequence << " over "
-            << sequence_ << " Setting second notify " << notifySequence_
-            << " / " << sequence;
-    notify_ = std::move(notify);
-    notifySequence_ = std::min(notifySequence_, sequence);
-    notifyMaxBytes_ = maxBytes;
-    return {};
-  }
-  if (sequence - sequence_ == data_.size()) {
-    notify_ = std::move(notify);
-    notifySequence_ = sequence;
-    notifyMaxBytes_ = maxBytes;
-    return {};
-  }
-
-  std::vector<std::unique_ptr<folly::IOBuf>> result;
-  uint64_t resultBytes = 0;
-  for (auto i = sequence - sequence_; i < data_.size(); ++i) {
-    // nullptr is used as end marker
-    if (data_[i] == nullptr) {
-      VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
-      result.push_back(nullptr);
-      break;
-    }
-    result.push_back(data_[i]->getIOBuf());
-    resultBytes += data_[i]->size();
-    if (resultBytes >= maxBytes) {
-      break;
-    }
-  }
-  return result;
-}
-
-void DestinationBuffer::enqueue(std::shared_ptr<SerializedPage> data) {
-  // Drop duplicate end markers.
-  if (data == nullptr && !data_.empty() && data_.back() == nullptr) {
-    return;
-  }
-
-  data_.push_back(std::move(data));
-}
-
-DataAvailable DestinationBuffer::getAndClearNotify() {
-  if (notify_ == nullptr) {
-    return DataAvailable();
-  }
-  DataAvailable result;
-  result.callback = notify_;
-  result.sequence = notifySequence_;
-  result.data = getData(notifyMaxBytes_, notifySequence_, nullptr);
-  notify_ = nullptr;
-  notifySequence_ = 0;
-  notifyMaxBytes_ = 0;
-  return result;
-}
-
-void DestinationBuffer::maybeLoadData(ArbitraryBuffer* buffer) {
-  VELOX_CHECK(!buffer->empty() || buffer->hasNoMoreData());
-  if (notify_ == nullptr) {
-    return;
-  }
-  VELOX_CHECK_GT(notifyMaxBytes_, 0);
-  loadData(buffer, notifyMaxBytes_);
-}
-
-void DestinationBuffer::loadData(ArbitraryBuffer* buffer, uint64_t maxBytes) {
-  auto pages = buffer->getPages(maxBytes);
-  for (auto& page : pages) {
-    enqueue(std::move(page));
-  }
-}
-
-std::vector<std::shared_ptr<SerializedPage>> DestinationBuffer::acknowledge(
-    int64_t sequence,
-    bool fromGetData) {
-  const int64_t numDeleted = sequence - sequence_;
-  if (numDeleted == 0 && fromGetData) {
-    // If called from getData, it is expected that there will be
-    // nothing to delete because a previous acknowledgement has been
-    // received before the getData. This is not guaranteed though
-    // because the messages may arrive out of order. Note that getData
-    // implicitly acknowledges all messages with a lower sequence
-    // number than the one in getData.
-    return {};
-  }
-  if (numDeleted <= 0) {
-    // Acknowledges come out of order, e.g. ack of 10 and 9 have
-    // swapped places in flight.
-    VLOG(1) << this << " Out of order ack: " << sequence << " over "
-            << sequence_;
-    return {};
-  }
-
-  VELOX_CHECK_LE(
-      numDeleted, data_.size(), "Ack received for a not yet produced item");
-  std::vector<std::shared_ptr<SerializedPage>> freed;
-  for (auto i = 0; i < numDeleted; ++i) {
-    if (data_[i] == nullptr) {
-      VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
-      break;
-    }
-    freed.push_back(std::move(data_[i]));
-  }
-  data_.erase(data_.begin(), data_.begin() + numDeleted);
-  sequence_ += numDeleted;
-  return freed;
-}
-
-std::vector<std::shared_ptr<SerializedPage>>
-DestinationBuffer::deleteResults() {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
-  for (auto i = 0; i < data_.size(); ++i) {
-    if (data_[i] == nullptr) {
-      VELOX_CHECK_EQ(i, data_.size() - 1, "null marker found in the middle");
-      break;
-    }
-    freed.push_back(std::move(data_[i]));
-  }
-  data_.clear();
-  return freed;
-}
-
-std::string DestinationBuffer::toString() {
-  std::stringstream out;
-  out << "[available: " << data_.size() << ", "
-      << "sequence: " << sequence_ << ", "
-      << (notify_ ? "notify registered, " : "") << this << "]";
-  return out.str();
-}
-
-namespace {
-// Frees 'freed' and realizes 'promises'. Used after
-// updateAfterAcknowledgeLocked. This runs outside of the mutex, so
-// that we do the expensive free outside and only then continue the
-// producers which will allocate more memory.
-void releaseAfterAcknowledge(
-    std::vector<std::shared_ptr<SerializedPage>>& freed,
-    std::vector<ContinuePromise>& promises) {
-  freed.clear();
-  for (auto& promise : promises) {
-    promise.setValue();
-  }
-}
-} // namespace
-
-PartitionedOutputBuffer::PartitionedOutputBuffer(
-    std::shared_ptr<Task> task,
-    PartitionedOutputNode::Kind kind,
-    int numDestinations,
-    uint32_t numDrivers)
-    : task_(std::move(task)),
-      kind_(kind),
-      maxSize_(
-          task_->queryCtx()->queryConfig().maxPartitionedOutputBufferSize()),
-      continueSize_((maxSize_ * kContinuePct) / 100),
-      arbitraryBuffer_(
-          isArbitrary() ? std::make_unique<ArbitraryBuffer>() : nullptr),
-      numDrivers_(numDrivers) {
-  buffers_.reserve(numDestinations);
-  for (int i = 0; i < numDestinations; i++) {
-    buffers_.push_back(std::make_unique<DestinationBuffer>());
-  }
-}
-
-void PartitionedOutputBuffer::updateOutputBuffers(
-    int numBuffers,
-    bool noMoreBuffers) {
-  if (isPartitioned()) {
-    VELOX_CHECK_EQ(buffers_.size(), numBuffers);
-    VELOX_CHECK(noMoreBuffers);
-    noMoreBuffers_ = true;
-    return;
-  }
-
-  std::vector<ContinuePromise> promises;
-  bool isFinished;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-
-    if (numBuffers > buffers_.size()) {
-      addOutputBuffersLocked(numBuffers);
-    }
-
-    if (!noMoreBuffers) {
-      return;
-    }
-
-    noMoreBuffers_ = true;
-    isFinished = isFinishedLocked();
-    updateAfterAcknowledgeLocked(dataToBroadcast_, promises);
-  }
-
-  releaseAfterAcknowledge(dataToBroadcast_, promises);
-  if (isFinished) {
-    task_->setAllOutputConsumed();
-  }
-}
-
-void PartitionedOutputBuffer::updateNumDrivers(uint32_t newNumDrivers) {
-  bool isNoMoreDrivers{false};
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    numDrivers_ = newNumDrivers;
-    // If we finished all drivers, ensure we register that we are 'done'.
-    if (numDrivers_ == numFinished_) {
-      isNoMoreDrivers = true;
-    }
-  }
-  if (isNoMoreDrivers) {
-    noMoreDrivers();
-  }
-}
-
-void PartitionedOutputBuffer::addOutputBuffersLocked(int numBuffers) {
-  VELOX_CHECK(!noMoreBuffers_);
-  VELOX_CHECK(!isPartitioned());
-  buffers_.reserve(numBuffers);
-  for (int32_t i = buffers_.size(); i < numBuffers; ++i) {
-    auto buffer = std::make_unique<DestinationBuffer>();
-    if (isBroadcast()) {
-      for (const auto& data : dataToBroadcast_) {
-        buffer->enqueue(data);
-      }
-    }
-    if (atEnd_ && isBroadcast()) {
-      buffer->enqueue(nullptr);
-    }
-    buffers_.emplace_back(std::move(buffer));
-  }
-}
-
-bool PartitionedOutputBuffer::enqueue(
-    int destination,
-    std::unique_ptr<SerializedPage> data,
-    ContinueFuture* future) {
-  VELOX_CHECK_NOT_NULL(data);
-  VELOX_CHECK(
-      task_->isRunning(), "Task is terminated, cannot add data to output.");
-  std::vector<DataAvailable> dataAvailableCallbacks;
-  bool blocked = false;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    VELOX_CHECK_LT(destination, buffers_.size());
-
-    totalSize_ += data->size();
-    switch (kind_) {
-      case PartitionedOutputNode::Kind::kBroadcast:
-        VELOX_CHECK_EQ(destination, 0, "Bad destination {}", destination);
-        enqueueBroadcastOutputLocked(std::move(data), dataAvailableCallbacks);
-        break;
-      case PartitionedOutputNode::Kind::kArbitrary:
-        VELOX_CHECK_EQ(destination, 0, "Bad destination {}", destination);
-        enqueueArbitraryOutputLocked(std::move(data), dataAvailableCallbacks);
-        break;
-      case PartitionedOutputNode::Kind::kPartitioned:
-        enqueuePartitionedOutputLocked(
-            destination, std::move(data), dataAvailableCallbacks);
-        break;
-      default:
-        VELOX_UNREACHABLE(PartitionedOutputNode::kindString(kind_));
-    }
-
-    if (totalSize_ > maxSize_ && future) {
-      promises_.emplace_back("PartitionedOutputBuffer::enqueue");
-      *future = promises_.back().getSemiFuture();
-      blocked = true;
-    }
-  }
-
-  // Outside mutex_.
-  for (auto& callback : dataAvailableCallbacks) {
-    callback.notify();
-  }
-
-  return blocked;
-}
-
-void PartitionedOutputBuffer::enqueueBroadcastOutputLocked(
-    std::unique_ptr<SerializedPage> data,
-    std::vector<DataAvailable>& dataAvailableCbs) {
-  VELOX_DCHECK(isBroadcast());
-  VELOX_CHECK_NULL(arbitraryBuffer_);
-  VELOX_DCHECK(dataAvailableCbs.empty());
-
-  std::shared_ptr<SerializedPage> sharedData(data.release());
-  for (auto& buffer : buffers_) {
-    if (buffer != nullptr) {
-      buffer->enqueue(sharedData);
-      dataAvailableCbs.emplace_back(buffer->getAndClearNotify());
-    }
-  }
-
-  // NOTE: we don't need to add new buffer to 'dataToBroadcast_' if there is no
-  // more output buffers.
-  if (!noMoreBuffers_) {
-    dataToBroadcast_.emplace_back(sharedData);
-  }
-}
-
-void PartitionedOutputBuffer::enqueueArbitraryOutputLocked(
-    std::unique_ptr<SerializedPage> data,
-    std::vector<DataAvailable>& dataAvailableCbs) {
-  VELOX_DCHECK(isArbitrary());
-  VELOX_DCHECK_NOT_NULL(arbitraryBuffer_);
-  VELOX_DCHECK(dataAvailableCbs.empty());
-  VELOX_CHECK(!arbitraryBuffer_->hasNoMoreData());
-
-  arbitraryBuffer_->enqueue(std::move(data));
-  VELOX_CHECK_LT(nextArbitraryLoadBufferIndex_, buffers_.size());
-  int32_t bufferId = nextArbitraryLoadBufferIndex_;
-  for (int32_t i = 0; i < buffers_.size();
-       ++i, bufferId = (bufferId + 1) % buffers_.size()) {
-    if (arbitraryBuffer_->empty()) {
-      nextArbitraryLoadBufferIndex_ = bufferId;
-      break;
-    }
-    auto* buffer = buffers_[bufferId].get();
-    if (buffer == nullptr) {
-      continue;
-    }
-    buffer->maybeLoadData(arbitraryBuffer_.get());
-    dataAvailableCbs.emplace_back(buffer->getAndClearNotify());
-  }
-}
-
-void PartitionedOutputBuffer::enqueuePartitionedOutputLocked(
-    int destination,
-    std::unique_ptr<SerializedPage> data,
-    std::vector<DataAvailable>& dataAvailableCbs) {
-  VELOX_DCHECK(isPartitioned());
-  VELOX_CHECK_NULL(arbitraryBuffer_);
-  VELOX_DCHECK(dataAvailableCbs.empty());
-
-  VELOX_CHECK_LT(destination, buffers_.size());
-  auto* buffer = buffers_[destination].get();
-  if (buffer != nullptr) {
-    buffer->enqueue(std::move(data));
-    dataAvailableCbs.emplace_back(buffer->getAndClearNotify());
-  } else {
-    // Some downstream tasks may finish early and delete the corresponding
-    // buffers. Further data for these buffers is dropped.
-    totalSize_ -= data->size();
-    VELOX_CHECK_GE(totalSize_, 0);
-  }
-}
-
-void PartitionedOutputBuffer::noMoreData() {
-  // Increment number of finished drivers.
-  checkIfDone(true);
-}
-
-void PartitionedOutputBuffer::noMoreDrivers() {
-  // Do not increment number of finished drivers.
-  checkIfDone(false);
-}
-
-void PartitionedOutputBuffer::checkIfDone(bool oneDriverFinished) {
-  std::vector<DataAvailable> finished;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    if (oneDriverFinished) {
-      ++numFinished_;
-    }
-    VELOX_CHECK_LE(
-        numFinished_,
-        numDrivers_,
-        "Each driver should call noMoreData exactly once");
-    atEnd_ = numFinished_ == numDrivers_;
-    if (!atEnd_) {
-      return;
-    }
-    if (isArbitrary()) {
-      arbitraryBuffer_->noMoreData();
-      for (auto& buffer : buffers_) {
-        if (buffer != nullptr) {
-          buffer->maybeLoadData(arbitraryBuffer_.get());
-          finished.push_back(buffer->getAndClearNotify());
-        }
-      }
-    } else {
-      for (auto& buffer : buffers_) {
-        if (buffer != nullptr) {
-          buffer->enqueue(nullptr);
-          finished.push_back(buffer->getAndClearNotify());
-        }
-      }
-    }
-  }
-
-  // Notify outside of mutex.
-  for (auto& notification : finished) {
-    notification.notify();
-  }
-}
-
-bool PartitionedOutputBuffer::isFinished() {
-  std::lock_guard<std::mutex> l(mutex_);
-  return isFinishedLocked();
-}
-
-bool PartitionedOutputBuffer::isFinishedLocked() {
-  // NOTE: for broadcast output buffer, we can only mark it as finished after
-  // receiving the no more (destination) buffers signal.
-  if (isBroadcast() && !noMoreBuffers_) {
-    return false;
-  }
-  for (auto& buffer : buffers_) {
-    if (buffer != nullptr) {
-      return false;
-    }
-  }
-  return true;
-}
-
-void PartitionedOutputBuffer::acknowledge(int destination, int64_t sequence) {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
-  std::vector<ContinuePromise> promises;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    VELOX_CHECK_LT(destination, buffers_.size());
-    auto* buffer = buffers_[destination].get();
-    if (!buffer) {
-      VLOG(1) << "Ack received after final ack for destination " << destination
-              << " and sequence " << sequence;
-      return;
-    }
-    freed = buffer->acknowledge(sequence, false);
-    updateAfterAcknowledgeLocked(freed, promises);
-  }
-  releaseAfterAcknowledge(freed, promises);
-}
-
-void PartitionedOutputBuffer::updateAfterAcknowledgeLocked(
-    const std::vector<std::shared_ptr<SerializedPage>>& freed,
-    std::vector<ContinuePromise>& promises) {
-  uint64_t totalFreed = 0;
-  for (const auto& free : freed) {
-    if (free.unique()) {
-      totalFreed += free->size();
-    }
-  }
-  if (totalFreed == 0) {
-    return;
-  }
-
-  VELOX_CHECK_LE(
-      totalFreed,
-      totalSize_,
-      "Output buffer size goes negative: released {} over {}",
-      totalFreed,
-      totalSize_);
-  totalSize_ -= totalFreed;
-  VELOX_CHECK_GE(totalSize_, 0);
-  if (totalSize_ < continueSize_) {
-    promises = std::move(promises_);
-  }
-}
-
-bool PartitionedOutputBuffer::deleteResults(int destination) {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
-  std::vector<ContinuePromise> promises;
-  bool isFinished;
-  DataAvailable dataAvailable;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    VELOX_CHECK_LT(destination, buffers_.size());
-    auto* buffer = buffers_[destination].get();
-    if (buffer == nullptr) {
-      VLOG(1) << "Extra delete received for destination " << destination;
-      return false;
-    }
-    freed = buffer->deleteResults();
-    dataAvailable = buffer->getAndClearNotify();
-    buffers_[destination] = nullptr;
-    ++numFinalAcknowledges_;
-    isFinished = isFinishedLocked();
-    updateAfterAcknowledgeLocked(freed, promises);
-  }
-
-  // Outside of mutex.
-  dataAvailable.notify();
-
-  if (!promises.empty()) {
-    VLOG(1) << "Delete of results unblocks producers. Can happen in early end "
-            << "due to error or limit";
-  }
-  releaseAfterAcknowledge(freed, promises);
-  if (isFinished) {
-    task_->setAllOutputConsumed();
-  }
-  return isFinished;
-}
-
-void PartitionedOutputBuffer::getData(
-    int destination,
-    uint64_t maxBytes,
-    int64_t sequence,
-    DataAvailableCallback notify) {
-  std::vector<std::unique_ptr<folly::IOBuf>> data;
-  std::vector<std::shared_ptr<SerializedPage>> freed;
-  std::vector<ContinuePromise> promises;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-
-    if (!isPartitioned() && destination >= buffers_.size()) {
-      addOutputBuffersLocked(destination + 1);
-    }
-
-    VELOX_CHECK_LT(destination, buffers_.size());
-    auto* buffer = buffers_[destination].get();
-    VELOX_CHECK_NOT_NULL(
-        buffer,
-        "getData received after its buffer is deleted. Destination: {}, sequence: {}",
-        destination,
-        sequence);
-    freed = buffer->acknowledge(sequence, true);
-    updateAfterAcknowledgeLocked(freed, promises);
-    data = buffer->getData(maxBytes, sequence, notify, arbitraryBuffer_.get());
-  }
-  releaseAfterAcknowledge(freed, promises);
-  if (!data.empty()) {
-    notify(std::move(data), sequence);
-  }
-}
-
-void PartitionedOutputBuffer::terminate() {
-  VELOX_CHECK(!task_->isRunning());
-
-  std::vector<ContinuePromise> outstandingPromises;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    outstandingPromises.swap(promises_);
-  }
-  for (auto& promise : outstandingPromises) {
-    promise.setValue();
-  }
-}
-
-std::string PartitionedOutputBuffer::toString() {
-  std::lock_guard<std::mutex> l(mutex_);
-  return toStringLocked();
-}
-
-std::string PartitionedOutputBuffer::toStringLocked() const {
-  std::stringstream out;
-  out << "[PartitionedOutputBuffer[" << kind_ << "] totalSize_=" << totalSize_
-      << "b, num producers blocked=" << promises_.size()
-      << ", completed=" << numFinished_ << "/" << numDrivers_ << ", "
-      << (atEnd_ ? "at end, " : "") << "destinations: " << std::endl;
-  for (auto i = 0; i < buffers_.size(); ++i) {
-    auto buffer = buffers_[i].get();
-    out << i << ": " << (buffer ? buffer->toString() : "none") << std::endl;
-  }
-  if (isArbitrary()) {
-    out << arbitraryBuffer_->toString();
-  }
-  out << "]" << std::endl;
-  return out.str();
-}
-
-double PartitionedOutputBuffer::getUtilization() const {
-  return totalSize_ / (double)maxSize_;
-}
-
-bool PartitionedOutputBuffer::isOverutilized() const {
-  return (totalSize_ > maxSize_) && !atEnd_;
-}
-
-} // namespace facebook::velox::exec
diff --git a/velox/exec/PartitionedOutputBuffer.h b/velox/exec/PartitionedOutputBuffer.h
deleted file mode 100644
index f6e62c46f851a..0000000000000
--- a/velox/exec/PartitionedOutputBuffer.h
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/core/PlanNode.h"
-#include "velox/exec/ExchangeQueue.h"
-
-namespace facebook::velox::exec {
-
-/// nullptr in pages indicates that there is no more data.
-/// sequence is the same as specified in BufferManager::getData call. The
-/// caller is expected to advance sequence by the number of entries in groups
-/// and call BufferManager::acknowledge.
-using DataAvailableCallback = std::function<
-    void(std::vector<std::unique_ptr<folly::IOBuf>> pages, int64_t sequence)>;
-
-struct DataAvailable {
-  DataAvailableCallback callback;
-  int64_t sequence;
-  std::vector<std::unique_ptr<folly::IOBuf>> data;
-
-  void notify() {
-    if (callback) {
-      callback(std::move(data), sequence);
-    }
-  }
-};
-
-/// The class is used to buffer the output pages which haven't been fetched by
-/// any destination for arbitrary output.
-///
-/// NOTE: there is only one arbitrary buffer setup for arbitrary output to share
-/// among destinations. Also, this class is not thread-safe.
-class ArbitraryBuffer {
- public:
-  /// Returns true if this arbitrary buffer has no buffered pages.
-  bool empty() const {
-    return pages_.empty() || (pages_.size() == 1 && pages_.back() == nullptr);
-  }
-
-  /// Returns true if this arbitrary buffer will not receive any new pages from
-  /// enqueue() but it can still has buffered pages waiting to dispatch to
-  /// destination on data fetch.
-  bool hasNoMoreData() const {
-    return !pages_.empty() && (pages_.back() == nullptr);
-  }
-
-  /// Marks this arbitrary buffer will not receive any new incoming pages. It
-  /// appends a null page at the end of 'pages_' as end marker.
-  void noMoreData();
-
-  void enqueue(std::unique_ptr<SerializedPage> page);
-
-  /// Returns a number of pages with total bytes no less than 'maxBytes' if
-  /// there are sufficient buffered pages.
-  std::vector<std::shared_ptr<SerializedPage>> getPages(uint64_t maxBytes);
-
-  std::string toString() const;
-
- private:
-  std::deque<std::shared_ptr<SerializedPage>> pages_;
-};
-
-class DestinationBuffer {
- public:
-  void enqueue(std::shared_ptr<SerializedPage> data);
-
-  /// Invoked to load data with up to 'notifyMaxBytes_' bytes from arbitrary
-  /// 'buffer' if there is pending fetch from this destination in which case
-  /// 'notify_' is not null. Otherwise, it does nothing. This only used by
-  /// arbitrary output type when enqueue new data.
-  void maybeLoadData(ArbitraryBuffer* buffer);
-
-  /// Invoked to load data with up to 'maxBytes' from arbitrary 'buffer' when
-  /// fetch data from this destination. This only used by arbitrary output type
-  /// which doesn't expect to buffer any data and is always load data from the
-  /// arbitrary buffer on demand.
-  void loadData(ArbitraryBuffer* buffer, uint64_t maxBytes);
-
-  // Returns a shallow copy (folly::IOBuf::clone) of the data starting at
-  // 'sequence', stopping after exceeding 'maxBytes'. If there is no data,
-  // 'notify' is installed so that this gets called when data is added.
-  std::vector<std::unique_ptr<folly::IOBuf>> getData(
-      uint64_t maxBytes,
-      int64_t sequence,
-      DataAvailableCallback notify,
-      ArbitraryBuffer* arbitraryBuffer = nullptr);
-
-  // Removes data from the queue and returns removed data. If 'fromGetData' we
-  // do not give a warning for the case where no data is removed, otherwise we
-  // expect that data does get freed. We cannot assert that data gets
-  // deleted because acknowledge messages can arrive out of order.
-  std::vector<std::shared_ptr<SerializedPage>> acknowledge(
-      int64_t sequence,
-      bool fromGetData);
-
-  // Removes all remaining data from the queue and returns the removed data.
-  std::vector<std::shared_ptr<SerializedPage>> deleteResults();
-
-  // Returns and clears the notify callback, if any, along with arguments for
-  // the callback.
-  DataAvailable getAndClearNotify();
-
-  std::string toString();
-
- private:
-  std::vector<std::shared_ptr<SerializedPage>> data_;
-  // The sequence number of the first in 'data_'.
-  int64_t sequence_ = 0;
-  DataAvailableCallback notify_ = nullptr;
-  // The sequence number of the first item to pass to 'notify'.
-  int64_t notifySequence_{0};
-  uint64_t notifyMaxBytes_{0};
-};
-
-class Task;
-
-class PartitionedOutputBuffer {
- public:
-  PartitionedOutputBuffer(
-      std::shared_ptr<Task> task,
-      core::PartitionedOutputNode::Kind kind,
-      int numDestinations,
-      uint32_t numDrivers);
-
-  core::PartitionedOutputNode::Kind kind() const {
-    return kind_;
-  }
-
-  /// The total number of output buffers may not be known at the task start
-  /// time for broadcast and arbitrary output buffer type. This method can be
-  /// called to update the total number of broadcast or arbitrary destinations
-  /// while the task is running. The function throws if this is partitioned
-  /// output buffer type.
-  void updateOutputBuffers(int numBuffers, bool noMoreBuffers);
-
-  /// When we understand the final number of split groups (for grouped
-  /// execution only), we need to update the number of producing drivers here.
-  void updateNumDrivers(uint32_t newNumDrivers);
-
-  bool enqueue(
-      int destination,
-      std::unique_ptr<SerializedPage> data,
-      ContinueFuture* future);
-
-  void noMoreData();
-
-  void noMoreDrivers();
-
-  bool isFinished();
-
-  bool isFinishedLocked();
-
-  void acknowledge(int destination, int64_t sequence);
-
-  // Deletes all data for 'destination'. Returns true if all
-  // destinations are deleted, meaning that the buffer is fully
-  // consumed and the producer can be marked finished and the buffers
-  // freed.
-  bool deleteResults(int destination);
-
-  void getData(
-      int destination,
-      uint64_t maxSize,
-      int64_t sequence,
-      DataAvailableCallback notify);
-
-  // Continues any possibly waiting producers. Called when the
-  // producer task has an error or cancellation.
-  void terminate();
-
-  std::string toString();
-
-  // Gets the memory utilization ratio in this output buffer.
-  double getUtilization() const;
-
-  // Indicates if this output buffer is over-utilized and thus blocks its
-  // producers.
-  bool isOverutilized() const;
-
- private:
-  // Percentage of maxSize below which a blocked producer should
-  // be unblocked.
-  static constexpr int32_t kContinuePct = 90;
-
-  /// If this is called due to a driver processed all its data (no more data),
-  /// we increment the number of finished drivers. If it is called due to us
-  /// updating the total number of drivers, we don't.
-  void checkIfDone(bool oneDriverFinished);
-
-  // Updates buffered size and returns possibly continuable producer promises
-  // in 'promises'.
-  void updateAfterAcknowledgeLocked(
-      const std::vector<std::shared_ptr<SerializedPage>>& freed,
-      std::vector<ContinuePromise>& promises);
-
-  /// Given an updated total number of broadcast buffers, add any missing ones
-  /// and enqueue data that has been produced so far (e.g. dataToBroadcast_).
-  void addOutputBuffersLocked(int numBuffers);
-
-  void enqueueBroadcastOutputLocked(
-      std::unique_ptr<SerializedPage> data,
-      std::vector<DataAvailable>& dataAvailableCbs);
-
-  void enqueueArbitraryOutputLocked(
-      std::unique_ptr<SerializedPage> data,
-      std::vector<DataAvailable>& dataAvailableCbs);
-
-  void enqueuePartitionedOutputLocked(
-      int destination,
-      std::unique_ptr<SerializedPage> data,
-      std::vector<DataAvailable>& dataAvailableCbs);
-
-  std::string toStringLocked() const;
-
-  FOLLY_ALWAYS_INLINE bool isBroadcast() const {
-    return kind_ == core::PartitionedOutputNode::Kind::kBroadcast;
-  }
-
-  FOLLY_ALWAYS_INLINE bool isPartitioned() const {
-    return kind_ == core::PartitionedOutputNode::Kind::kPartitioned;
-  }
-
-  FOLLY_ALWAYS_INLINE bool isArbitrary() const {
-    return kind_ == core::PartitionedOutputNode::Kind::kArbitrary;
-  }
-
-  const std::shared_ptr<Task> task_;
-  const core::PartitionedOutputNode::Kind kind_;
-  /// If 'totalSize_' > 'maxSize_', each producer is blocked after adding
-  /// data.
-  const uint64_t maxSize_;
-  // When 'totalSize_' goes below 'continueSize_', blocked producers are
-  // resumed.
-  const uint64_t continueSize_;
-  const std::unique_ptr<ArbitraryBuffer> arbitraryBuffer_;
-
-  // Total number of drivers expected to produce results. This number will
-  // decrease in the end of grouped execution, when we understand the real
-  // number of producer drivers (depending on the number of split groups).
-  uint32_t numDrivers_{0};
-
-  // If true, then we don't allow to add new destination buffers. This only
-  // applies for non-partitioned output buffer type.
-  bool noMoreBuffers_{false};
-
-  // While noMoreBuffers_ is false, stores the enqueued data to
-  // broadcast to destinations that have not yet been initialized. Cleared
-  // after receiving no-more-broadcast-buffers signal.
-  std::vector<std::shared_ptr<SerializedPage>> dataToBroadcast_;
-
-  std::mutex mutex_;
-  // Actual data size in 'buffers_'.
-  uint64_t totalSize_ = 0;
-  std::vector<ContinuePromise> promises_;
-  // The next buffer index in 'buffers_' to load data from arbitrary buffer
-  // which is only used by arbitrary output type.
-  int32_t nextArbitraryLoadBufferIndex_{0};
-  // One buffer per destination.
-  std::vector<std::unique_ptr<DestinationBuffer>> buffers_;
-  uint32_t numFinished_{0};
-  // When this reaches buffers_.size(), 'this' can be freed.
-  int numFinalAcknowledges_ = 0;
-  bool atEnd_ = false;
-};
-
-} // namespace facebook::velox::exec
diff --git a/velox/exec/PartitionedOutputBufferManager.cpp b/velox/exec/PartitionedOutputBufferManager.cpp
deleted file mode 100644
index 50b151459c972..0000000000000
--- a/velox/exec/PartitionedOutputBufferManager.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/exec/PartitionedOutputBufferManager.h"
-#include "velox/exec/Task.h"
-
-namespace facebook::velox::exec {
-
-// static
-std::weak_ptr<PartitionedOutputBufferManager>
-PartitionedOutputBufferManager::getInstance() {
-  static auto kInstance = std::make_shared<PartitionedOutputBufferManager>();
-  return kInstance;
-}
-
-std::shared_ptr<PartitionedOutputBuffer>
-PartitionedOutputBufferManager::getBuffer(const std::string& taskId) {
-  return buffers_.withLock([&](auto& buffers) {
-    auto it = buffers.find(taskId);
-    VELOX_CHECK(
-        it != buffers.end(), "Output buffers for task not found: {}", taskId);
-    return it->second;
-  });
-}
-
-std::shared_ptr<PartitionedOutputBuffer>
-PartitionedOutputBufferManager::getBufferIfExists(const std::string& taskId) {
-  return buffers_.withLock([&](auto& buffers) {
-    auto it = buffers.find(taskId);
-    return it == buffers.end() ? nullptr : it->second;
-  });
-}
-
-uint64_t PartitionedOutputBufferManager::numBuffers() const {
-  return buffers_.lock()->size();
-}
-
-bool PartitionedOutputBufferManager::enqueue(
-    const std::string& taskId,
-    int destination,
-    std::unique_ptr<SerializedPage> data,
-    ContinueFuture* future) {
-  return getBuffer(taskId)->enqueue(destination, std::move(data), future);
-}
-
-void PartitionedOutputBufferManager::noMoreData(const std::string& taskId) {
-  getBuffer(taskId)->noMoreData();
-}
-
-bool PartitionedOutputBufferManager::isFinished(const std::string& taskId) {
-  return getBuffer(taskId)->isFinished();
-}
-
-void PartitionedOutputBufferManager::acknowledge(
-    const std::string& taskId,
-    int destination,
-    int64_t sequence) {
-  auto buffer = buffers_.withLock(
-      [&](auto& buffers) -> std::shared_ptr<PartitionedOutputBuffer> {
-        auto it = buffers.find(taskId);
-        if (it == buffers.end()) {
-          VLOG(1) << "Receiving ack for non-existent task " << taskId
-                  << " destination " << destination << " sequence " << sequence;
-          return nullptr;
-        }
-        return it->second;
-      });
-  if (buffer) {
-    buffer->acknowledge(destination, sequence);
-  }
-}
-
-void PartitionedOutputBufferManager::deleteResults(
-    const std::string& taskId,
-    int destination) {
-  if (auto buffer = getBufferIfExists(taskId)) {
-    buffer->deleteResults(destination);
-  }
-}
-
-bool PartitionedOutputBufferManager::getData(
-    const std::string& taskId,
-    int destination,
-    uint64_t maxBytes,
-    int64_t sequence,
-    DataAvailableCallback notify) {
-  if (auto buffer = getBufferIfExists(taskId)) {
-    buffer->getData(destination, maxBytes, sequence, notify);
-    return true;
-  }
-  return false;
-}
-
-void PartitionedOutputBufferManager::initializeTask(
-    std::shared_ptr<Task> task,
-    core::PartitionedOutputNode::Kind kind,
-    int numDestinations,
-    int numDrivers) {
-  const auto& taskId = task->taskId();
-
-  buffers_.withLock([&](auto& buffers) {
-    auto it = buffers.find(taskId);
-    if (it == buffers.end()) {
-      buffers[taskId] = std::make_shared<PartitionedOutputBuffer>(
-          std::move(task), kind, numDestinations, numDrivers);
-    } else {
-      VELOX_FAIL(
-          "Registering an output buffer for pre-existing taskId {}", taskId);
-    }
-  });
-}
-
-bool PartitionedOutputBufferManager::updateOutputBuffers(
-    const std::string& taskId,
-    int numBuffers,
-    bool noMoreBuffers) {
-  if (auto buffer = getBufferIfExists(taskId)) {
-    buffer->updateOutputBuffers(numBuffers, noMoreBuffers);
-    return true;
-  }
-  return false;
-}
-
-void PartitionedOutputBufferManager::updateNumDrivers(
-    const std::string& taskId,
-    uint32_t newNumDrivers) {
-  getBuffer(taskId)->updateNumDrivers(newNumDrivers);
-}
-
-void PartitionedOutputBufferManager::removeTask(const std::string& taskId) {
-  auto buffer = buffers_.withLock(
-      [&](auto& buffers) -> std::shared_ptr<PartitionedOutputBuffer> {
-        auto it = buffers.find(taskId);
-        if (it == buffers.end()) {
-          // Already removed.
-          return nullptr;
-        }
-        auto taskBuffer = it->second;
-        buffers.erase(taskId);
-        return taskBuffer;
-      });
-  if (buffer != nullptr) {
-    buffer->terminate();
-  }
-}
-
-std::string PartitionedOutputBufferManager::toString() {
-  return buffers_.withLock([](const auto& buffers) {
-    std::stringstream out;
-    out << "[BufferManager:" << std::endl;
-    for (const auto& pair : buffers) {
-      out << pair.first << ": " << pair.second->toString() << std::endl;
-    }
-    out << "]";
-    return out.str();
-  });
-}
-
-double PartitionedOutputBufferManager::getUtilization(
-    const std::string& taskId) {
-  auto buffer = getBufferIfExists(taskId);
-  if (buffer != nullptr) {
-    return buffer->getUtilization();
-  }
-  return 0;
-}
-
-bool PartitionedOutputBufferManager::isOverutilized(const std::string& taskId) {
-  auto buffer = getBufferIfExists(taskId);
-  if (buffer != nullptr) {
-    return buffer->isOverutilized();
-  }
-  return false;
-}
-
-} // namespace facebook::velox::exec
diff --git a/velox/exec/PartitionedOutputBufferManager.h b/velox/exec/PartitionedOutputBufferManager.h
deleted file mode 100644
index bab30210870d4..0000000000000
--- a/velox/exec/PartitionedOutputBufferManager.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/exec/PartitionedOutputBuffer.h"
-
-namespace facebook::velox::exec {
-
-class PartitionedOutputBufferManager {
- public:
-  void initializeTask(
-      std::shared_ptr<Task> task,
-      core::PartitionedOutputNode::Kind kind,
-      int numDestinations,
-      int numDrivers);
-
-  /// Updates the number of buffers. Return true if the buffer exists for a
-  /// given taskId, else returns false.
-  bool updateOutputBuffers(
-      const std::string& taskId,
-      int numBuffers,
-      bool noMoreBuffers);
-
-  /// When we understand the final number of split groups (for grouped
-  /// execution only), we need to update the number of producing drivers here.
-  void updateNumDrivers(const std::string& taskId, uint32_t newNumDrivers);
-
-  // Adds data to the outgoing queue for 'destination'. 'data' must not be
-  // nullptr. 'data' is always added but if the buffers are full the future is
-  // set to a ContinueFuture that will be realized when there is space.
-  bool enqueue(
-      const std::string& taskId,
-      int destination,
-      std::unique_ptr<SerializedPage> data,
-      ContinueFuture* future);
-
-  void noMoreData(const std::string& taskId);
-
-  // Returns true if noMoreData has been called and all the accumulated data
-  // have been fetched and acknowledged.
-  bool isFinished(const std::string& taskId);
-
-  // Removes data with sequence number < 'sequence' from the queue for
-  // 'destination_'.
-  void
-  acknowledge(const std::string& taskId, int destination, int64_t sequence);
-
-  void deleteResults(const std::string& taskId, int destination);
-
-  // Adds up to 'maxBytes' bytes worth of data for 'destination' from
-  // 'taskId'. The sequence number of the data must be >= 'sequence'.
-  // If there is no buffer associated with the given taskId, returns false.
-  // If there is no data, 'notify' will be registered and
-  // called when there is data or the source is at end, the function returns
-  // true.
-  // Existing data with a sequence number < sequence is deleted. The caller is
-  // expected to increment the sequence number between calls by the
-  // number of items received. In this way the next call implicitly
-  // acknowledges receipt of the results from the previous. The
-  // acknowledge method is offered for an early ack, so that the
-  // producer can continue before the consumer is done processing the
-  // received data.
-  bool getData(
-      const std::string& taskId,
-      int destination,
-      uint64_t maxBytes,
-      int64_t sequence,
-      DataAvailableCallback notify);
-
-  void removeTask(const std::string& taskId);
-
-  static std::weak_ptr<PartitionedOutputBufferManager> getInstance();
-
-  uint64_t numBuffers() const;
-
-  // Returns a new stream listener if a listener factory has been set.
-  std::unique_ptr<OutputStreamListener> newListener() const {
-    return listenerFactory_ ? listenerFactory_() : nullptr;
-  }
-
-  // Sets the stream listener factory. This allows custom processing of data
-  // for repartitioning, e.g. computing checksums.
-  void setListenerFactory(
-      std::function<std::unique_ptr<OutputStreamListener>()> factory) {
-    listenerFactory_ = factory;
-  }
-
-  std::string toString();
-
-  // Gets the memory utilization ratio for the output buffer from a task of
-  // taskId, if the task of this taskId is not found, return 0.
-  double getUtilization(const std::string& taskId);
-
-  // If the output buffer from a task of taskId is over-utilized and blocks its
-  // producers. When the task of this taskId is not found, return false.
-  bool isOverutilized(const std::string& taskId);
-
-  // Retrieves the set of buffers for a query if exists.
-  // Returns NULL if task not found.
-  std::shared_ptr<PartitionedOutputBuffer> getBufferIfExists(
-      const std::string& taskId);
-
- private:
-  // Retrieves the set of buffers for a query.
-  // Throws an exception if buffer doesn't exist.
-  std::shared_ptr<PartitionedOutputBuffer> getBuffer(const std::string& taskId);
-
-  folly::Synchronized<
-      std::unordered_map<std::string, std::shared_ptr<PartitionedOutputBuffer>>,
-      std::mutex>
-      buffers_;
-
-  std::function<std::unique_ptr<OutputStreamListener>()> listenerFactory_{
-      nullptr};
-};
-} // namespace facebook::velox::exec
diff --git a/velox/exec/PlanNodeStats.cpp b/velox/exec/PlanNodeStats.cpp
index 5aba5e2256393..940d5c6d49618 100644
--- a/velox/exec/PlanNodeStats.cpp
+++ b/velox/exec/PlanNodeStats.cpp
@@ -39,6 +39,8 @@ void PlanNodeStats::addTotals(const OperatorStats& stats) {
   rawInputRows += stats.rawInputPositions;
   rawInputBytes += stats.rawInputBytes;
 
+  dynamicFilterStats.add(stats.dynamicFilterStats);
+
   outputRows += stats.outputPositions;
   outputBytes += stats.outputBytes;
   outputVectors += stats.outputVectors;
@@ -47,11 +49,15 @@ void PlanNodeStats::addTotals(const OperatorStats& stats) {
   cpuWallTiming.add(stats.getOutputTiming);
   cpuWallTiming.add(stats.finishTiming);
 
+  backgroundTiming.add(stats.backgroundTiming);
+
   blockedWallNanos += stats.blockedWallNanos;
 
   peakMemoryBytes += stats.memoryStats.peakTotalMemoryReservation;
   numMemoryAllocations += stats.memoryStats.numMemoryAllocations;
 
+  physicalWrittenBytes += stats.physicalWrittenBytes;
+
   for (const auto& [name, runtimeStats] : stats.runtimeStats) {
     if (UNLIKELY(customStats.count(name) == 0)) {
       customStats.insert(std::make_pair(name, runtimeStats));
@@ -89,8 +95,11 @@ std::string PlanNodeStats::toString(bool includeInputStats) const {
     }
   }
   out << "Output: " << outputRows << " rows (" << succinctBytes(outputBytes)
-      << ", " << outputVectors << " batches)"
-      << ", Cpu time: " << succinctNanos(cpuWallTiming.cpuNanos)
+      << ", " << outputVectors << " batches)";
+  if (physicalWrittenBytes > 0) {
+    out << ", Physical written output: " << succinctBytes(physicalWrittenBytes);
+  }
+  out << ", Cpu time: " << succinctNanos(cpuWallTiming.cpuNanos)
       << ", Blocked wall time: " << succinctNanos(blockedWallNanos)
       << ", Peak memory: " << succinctBytes(peakMemoryBytes)
       << ", Memory allocations: " << numMemoryAllocations;
@@ -102,6 +111,17 @@ std::string PlanNodeStats::toString(bool includeInputStats) const {
   if (numSplits > 0) {
     out << ", Splits: " << numSplits;
   }
+
+  if (spilledRows > 0) {
+    out << ", Spilled: " << spilledRows << " rows ("
+        << succinctBytes(spilledBytes) << ", " << spilledFiles << " files)";
+  }
+
+  if (!dynamicFilterStats.empty()) {
+    out << ", DynamicFilter producer plan nodes: "
+        << folly::join(',', dynamicFilterStats.producerNodeIds);
+  }
+
   return out.str();
 }
 
@@ -146,6 +166,7 @@ folly::dynamic toPlanStatsJson(const facebook::velox::exec::TaskStats& stats) {
       stat["blockedWallNanos"] = operatorStat.second->blockedWallNanos;
       stat["peakMemoryBytes"] = operatorStat.second->peakMemoryBytes;
       stat["numMemoryAllocations"] = operatorStat.second->numMemoryAllocations;
+      stat["physicalWrittenBytes"] = operatorStat.second->physicalWrittenBytes;
       stat["numDrivers"] = operatorStat.second->numDrivers;
       stat["numSplits"] = operatorStat.second->numSplits;
       stat["spilledInputBytes"] = operatorStat.second->spilledInputBytes;
diff --git a/velox/exec/PlanNodeStats.h b/velox/exec/PlanNodeStats.h
index 0f34717da5594..71e653aebafd9 100644
--- a/velox/exec/PlanNodeStats.h
+++ b/velox/exec/PlanNodeStats.h
@@ -62,6 +62,9 @@ struct PlanNodeStats {
   /// Sum of raw input bytes for all corresponding operators.
   uint64_t rawInputBytes{0};
 
+  /// Contains the dynamic filters stats if applied.
+  DynamicFilterStats dynamicFilterStats;
+
   /// Sum of output rows for all corresponding operators. When
   /// plan node corresponds to multiple operator types, operators of only one of
   /// these types report non-zero output rows.
@@ -78,6 +81,11 @@ struct PlanNodeStats {
   /// up.
   CpuWallTiming cpuWallTiming;
 
+  /// Sum of CPU, scheduled and wall times spent on background activities
+  /// (activities that are not running on driver threads) for all corresponding
+  /// operators.
+  CpuWallTiming backgroundTiming;
+
   /// Sum of blocked wall time for all corresponding operators.
   uint64_t blockedWallNanos{0};
 
@@ -87,6 +95,8 @@ struct PlanNodeStats {
 
   uint64_t numMemoryAllocations{0};
 
+  uint64_t physicalWrittenBytes{0};
+
   /// Operator-specific counters.
   std::unordered_map<std::string, RuntimeMetric> customStats;
 
@@ -99,7 +109,7 @@ struct PlanNodeStats {
   /// Number of total splits.
   int numSplits{0};
 
-  // Total bytes in memory for spilling
+  /// Total bytes in memory for spilling
   uint64_t spilledInputBytes{0};
 
   /// Total bytes written for spilling.
diff --git a/velox/exec/PrefixSort.cpp b/velox/exec/PrefixSort.cpp
new file mode 100644
index 0000000000000..5d58ee9b032e3
--- /dev/null
+++ b/velox/exec/PrefixSort.cpp
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/PrefixSort.h"
+
+using namespace facebook::velox::exec::prefixsort;
+
+namespace facebook::velox::exec {
+
+namespace {
+
+// For alignment, 8 is faster than 4.
+// If the alignment is changed from 8 to 4, you need to change bitswap64
+// to bitswap32.
+const int32_t kAlignment = 8;
+
+template <typename T>
+FOLLY_ALWAYS_INLINE void encodeRowColumn(
+    const PrefixSortLayout& prefixSortLayout,
+    const uint32_t index,
+    const RowColumn& rowColumn,
+    char* const row,
+    char* const prefix) {
+  std::optional<T> value;
+  if (RowContainer::isNullAt(row, rowColumn.nullByte(), rowColumn.nullMask())) {
+    value = std::nullopt;
+  } else {
+    value = *(reinterpret_cast<T*>(row + rowColumn.offset()));
+  }
+  prefixSortLayout.encoders[index].encode(
+      value, prefix + prefixSortLayout.prefixOffsets[index]);
+}
+
+FOLLY_ALWAYS_INLINE void extractRowColumnToPrefix(
+    TypeKind typeKind,
+    const PrefixSortLayout& prefixSortLayout,
+    const uint32_t index,
+    const RowColumn& rowColumn,
+    char* const row,
+    char* const prefix) {
+  switch (typeKind) {
+    case TypeKind::SMALLINT: {
+      encodeRowColumn<int16_t>(prefixSortLayout, index, rowColumn, row, prefix);
+      return;
+    }
+    case TypeKind::INTEGER: {
+      encodeRowColumn<int32_t>(prefixSortLayout, index, rowColumn, row, prefix);
+      return;
+    }
+    case TypeKind::BIGINT: {
+      encodeRowColumn<int64_t>(prefixSortLayout, index, rowColumn, row, prefix);
+      return;
+    }
+    case TypeKind::REAL: {
+      encodeRowColumn<float>(prefixSortLayout, index, rowColumn, row, prefix);
+      return;
+    }
+    case TypeKind::DOUBLE: {
+      encodeRowColumn<double>(prefixSortLayout, index, rowColumn, row, prefix);
+      return;
+    }
+    case TypeKind::TIMESTAMP: {
+      encodeRowColumn<Timestamp>(
+          prefixSortLayout, index, rowColumn, row, prefix);
+      return;
+    }
+    default:
+      VELOX_UNSUPPORTED(
+          "prefix-sort does not support type kind: {}",
+          mapTypeKindToName(typeKind));
+  }
+}
+
+FOLLY_ALWAYS_INLINE int32_t alignmentPadding(int32_t size, int32_t alignment) {
+  auto extra = size % alignment;
+  return extra == 0 ? 0 : alignment - extra;
+}
+
+FOLLY_ALWAYS_INLINE void bitsSwapByWord(uint64_t* address, int32_t bytes) {
+  while (bytes != 0) {
+    *address = __builtin_bswap64(*address);
+    ++address;
+    bytes -= kAlignment;
+  }
+}
+
+FOLLY_ALWAYS_INLINE int
+compareByWord(uint64_t* left, uint64_t* right, int32_t bytes) {
+  while (bytes != 0) {
+    if (*left == *right) {
+      ++left;
+      ++right;
+      bytes -= kAlignment;
+      continue;
+    }
+    if (*left > *right) {
+      return 1;
+    } else {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+} // namespace
+
+PrefixSortLayout PrefixSortLayout::makeSortLayout(
+    const std::vector<TypePtr>& types,
+    const std::vector<CompareFlags>& compareFlags,
+    uint32_t maxNormalizedKeySize) {
+  uint32_t normalizedKeySize = 0;
+  uint32_t numNormalizedKeys = 0;
+  const uint32_t numKeys = types.size();
+  std::vector<uint32_t> prefixOffsets;
+  std::vector<PrefixSortEncoder> encoders;
+
+  // Calculate encoders and prefix-offsets, and stop the loop if a key that
+  // cannot be normalized is encountered.
+  for (auto i = 0; i < numKeys; ++i) {
+    if (normalizedKeySize > maxNormalizedKeySize) {
+      break;
+    }
+    std::optional<uint32_t> encodedSize =
+        PrefixSortEncoder::encodedSize(types[i]->kind());
+    if (encodedSize.has_value()) {
+      prefixOffsets.push_back(normalizedKeySize);
+      encoders.push_back(
+          {compareFlags[i].ascending, compareFlags[i].nullsFirst});
+      normalizedKeySize += encodedSize.value();
+      numNormalizedKeys++;
+    } else {
+      break;
+    }
+  }
+  auto padding = alignmentPadding(normalizedKeySize, kAlignment);
+  normalizedKeySize += padding;
+  return PrefixSortLayout{
+      normalizedKeySize + sizeof(char*),
+      normalizedKeySize,
+      numNormalizedKeys,
+      numKeys,
+      compareFlags,
+      numNormalizedKeys == 0,
+      numNormalizedKeys < numKeys,
+      std::move(prefixOffsets),
+      std::move(encoders),
+      padding};
+}
+
+FOLLY_ALWAYS_INLINE int PrefixSort::compareAllNormalizedKeys(
+    char* left,
+    char* right) {
+  return compareByWord(
+      (uint64_t*)left, (uint64_t*)right, sortLayout_.normalizedBufferSize);
+}
+
+int PrefixSort::comparePartNormalizedKeys(char* left, char* right) {
+  int result = compareAllNormalizedKeys(left, right);
+  if (result != 0) {
+    return result;
+  }
+  // If prefixes are equal, compare the left sort keys with rowContainer.
+  char* leftAddress = getAddressFromPrefix(left);
+  char* rightAddress = getAddressFromPrefix(right);
+  for (auto i = sortLayout_.numNormalizedKeys; i < sortLayout_.numKeys; ++i) {
+    result = rowContainer_->compare(
+        leftAddress, rightAddress, i, sortLayout_.compareFlags[i]);
+    if (result != 0) {
+      return result;
+    }
+  }
+  return result;
+}
+
+PrefixSort::PrefixSort(
+    memory::MemoryPool* pool,
+    RowContainer* rowContainer,
+    const PrefixSortLayout& sortLayout)
+    : pool_(pool), sortLayout_(sortLayout), rowContainer_(rowContainer) {}
+
+void PrefixSort::extractRowToPrefix(char* row, char* prefix) {
+  for (auto i = 0; i < sortLayout_.numNormalizedKeys; i++) {
+    extractRowColumnToPrefix(
+        rowContainer_->keyTypes()[i]->kind(),
+        sortLayout_,
+        i,
+        rowContainer_->columnAt(i),
+        row,
+        prefix);
+  }
+  simd::memset(
+      prefix + sortLayout_.normalizedBufferSize - sortLayout_.padding,
+      0,
+      sortLayout_.padding);
+  // When comparing in std::memcmp, each byte is compared. If it is changed to
+  // compare every 8 bytes, the number of comparisons will be reduced and the
+  // performance will be improved.
+  // Use uint64_t compare to implement the above-mentioned comparison of every 8
+  // bytes, assuming the system is little-endian, need to reverse bytes for
+  // every 8 bytes.
+  bitsSwapByWord((uint64_t*)prefix, sortLayout_.normalizedBufferSize);
+  // Set row address.
+  getAddressFromPrefix(prefix) = row;
+}
+
+void PrefixSort::sortInternal(std::vector<char*>& rows) {
+  const auto numRows = rows.size();
+  const auto entrySize = sortLayout_.entrySize;
+  memory::ContiguousAllocation prefixAllocation;
+  // 1. Allocate prefixes data.
+  {
+    const auto numPages =
+        memory::AllocationTraits::numPages(numRows * entrySize);
+    pool_->allocateContiguous(numPages, prefixAllocation);
+  }
+  char* const prefixes = prefixAllocation.data<char>();
+
+  // 2. Extract rows to prefixes with row address.
+  for (auto i = 0; i < rows.size(); ++i) {
+    extractRowToPrefix(rows[i], prefixes + entrySize * i);
+  }
+
+  // 3. Sort prefixes with row address.
+  {
+    const auto swapBuffer = AlignedBuffer::allocate<char>(entrySize, pool_);
+    PrefixSortRunner sortRunner(entrySize, swapBuffer->asMutable<char>());
+    const auto start = prefixes;
+    const auto end = prefixes + numRows * entrySize;
+    if (sortLayout_.hasNonNormalizedKey) {
+      sortRunner.quickSort(start, end, [&](char* a, char* b) {
+        return comparePartNormalizedKeys(a, b);
+      });
+    } else {
+      sortRunner.quickSort(start, end, [&](char* a, char* b) {
+        return compareAllNormalizedKeys(a, b);
+      });
+    }
+  }
+  // 4. Output sorted row addresses.
+  for (int i = 0; i < rows.size(); i++) {
+    rows[i] = getAddressFromPrefix(prefixes + i * entrySize);
+  }
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/PrefixSort.h b/velox/exec/PrefixSort.h
new file mode 100644
index 0000000000000..0f860c777ded6
--- /dev/null
+++ b/velox/exec/PrefixSort.h
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/base/PrefixSortConfig.h"
+#include "velox/common/memory/MemoryAllocator.h"
+#include "velox/exec/RowContainer.h"
+#include "velox/exec/prefixsort/PrefixSortAlgorithm.h"
+#include "velox/exec/prefixsort/PrefixSortEncoder.h"
+
+namespace facebook::velox::exec {
+
+namespace detail {
+
+FOLLY_ALWAYS_INLINE void stdSort(
+    std::vector<char*>& rows,
+    RowContainer* rowContainer,
+    const std::vector<CompareFlags>& compareFlags) {
+  std::sort(
+      rows.begin(), rows.end(), [&](const char* leftRow, const char* rightRow) {
+        for (auto i = 0; i < compareFlags.size(); ++i) {
+          if (auto result = rowContainer->compare(
+                  leftRow, rightRow, i, compareFlags[i])) {
+            return result < 0;
+          }
+        }
+        return false;
+      });
+}
+}; // namespace detail
+
+/// The layout of prefix-sort buffer, a prefix entry includes:
+/// 1. normalized keys
+/// 2. non-normalized data ptr for semi-normalized types such as
+/// string_view`s ptr, it will be filled when support Varchar.
+/// 3. the row address ptr point to RowContainer`s rows is added at the end of
+/// prefix.
+struct PrefixSortLayout {
+  /// Number of bytes to store a prefix, it equals to:
+  /// normalizedKeySize_ + 8 (non-normalized-ptr) + 8(row address).
+  const uint64_t entrySize;
+
+  /// If a sort key supports normalization and can be added to the prefix
+  /// sort buffer, it is called a normalized key.
+  const uint32_t normalizedBufferSize;
+
+  const uint32_t numNormalizedKeys;
+
+  /// The num of sort keys include normalized and non-normalized.
+  const uint32_t numKeys;
+
+  /// CompareFlags of all sort keys.
+  const std::vector<CompareFlags> compareFlags;
+
+  /// Whether the sort keys contains normalized key.
+  /// It equals to 'numNormalizedKeys == 0', a little faster.
+  const bool noNormalizedKeys;
+
+  /// Whether the sort keys contains non-normalized key.
+  const bool hasNonNormalizedKey;
+
+  /// Offsets of normalized keys, used to find write locations when
+  /// extracting columns
+  const std::vector<uint32_t> prefixOffsets;
+
+  /// The encoders for normalized keys.
+  const std::vector<prefixsort::PrefixSortEncoder> encoders;
+
+  /// Align the buffer size to 8 so that long compare can replace byte compare
+  /// during ‘memcmp’
+  const int32_t padding;
+
+  static PrefixSortLayout makeSortLayout(
+      const std::vector<TypePtr>& types,
+      const std::vector<CompareFlags>& compareFlags,
+      uint32_t maxNormalizedKeySize);
+};
+
+class PrefixSort {
+ public:
+  PrefixSort(
+      memory::MemoryPool* pool,
+      RowContainer* rowContainer,
+      const PrefixSortLayout& sortLayout);
+
+  /// Follow the steps below to sort the data in RowContainer:
+  /// 1. Allocate a contiguous block of memory to store normalized keys.
+  /// 2. Extract the sort keys from the RowContainer. If the key can be
+  /// normalized, normalize it. For this kind of keys can be normalized，we
+  /// combine them with the original row address ptr and store them
+  /// together into a buffer, called 'Prefix'.
+  /// 3. Sort the prefixes data we got in step 2.
+  /// For keys can normalized(All fixed width types), we use 'memcmp' to compare
+  /// the normalized binary string.
+  /// For keys can not normalized, we use RowContainer`s compare method to
+  /// compare value.
+  /// For keys can part-normalized(Varchar, Row etc.), we will store the
+  /// normalized part and points to raw data in prefix, and custom the points
+  /// compare. The compare strategy will be defined in PrefixSortLayout as
+  /// follow-up, we treat this part as non-normalized until we implement all
+  /// fixed width types.
+  /// For complex types, e.g. ROW that can be converted to scalar types will be
+  /// supported.
+  /// 4. Extract the original row address ptr from prefixes (previously stored
+  /// them in the prefix buffer) into the input rows vector.
+  ///
+  /// @param rows The result of RowContainer::listRows(), assuming that the
+  /// caller (SortBuffer etc.) has already got the result.
+  FOLLY_ALWAYS_INLINE static void sort(
+      std::vector<char*>& rows,
+      memory::MemoryPool* pool,
+      RowContainer* rowContainer,
+      const std::vector<CompareFlags>& compareFlags,
+      const velox::common::PrefixSortConfig& config) {
+    if (rowContainer->numRows() < config.threshold) {
+      detail::stdSort(rows, rowContainer, compareFlags);
+      return;
+    }
+    VELOX_DCHECK_EQ(rowContainer->keyTypes().size(), compareFlags.size());
+    const auto sortLayout = PrefixSortLayout::makeSortLayout(
+        rowContainer->keyTypes(), compareFlags, config.maxNormalizedKeySize);
+    // All keys can not normalize, skip the binary string compare opt.
+    // Putting this outside sort-internal helps with inline std-sort.
+    if (sortLayout.noNormalizedKeys) {
+      detail::stdSort(rows, rowContainer, compareFlags);
+      return;
+    }
+
+    PrefixSort prefixSort(pool, rowContainer, sortLayout);
+    prefixSort.sortInternal(rows);
+  }
+
+ private:
+  void sortInternal(std::vector<char*>& rows);
+
+  int compareAllNormalizedKeys(char* left, char* right);
+
+  int comparePartNormalizedKeys(char* left, char* right);
+
+  void extractRowToPrefix(char* row, char* prefix);
+
+  // Return the reference of row address ptr for read/write.
+  FOLLY_ALWAYS_INLINE char*& getAddressFromPrefix(char* prefix) {
+    return *reinterpret_cast<char**>(prefix + sortLayout_.normalizedBufferSize);
+  }
+
+  memory::MemoryPool* const pool_;
+  const PrefixSortLayout sortLayout_;
+  RowContainer* const rowContainer_;
+};
+} // namespace facebook::velox::exec
diff --git a/velox/exec/ProbeOperatorState.h b/velox/exec/ProbeOperatorState.h
index 1ba9ef443fb4d..f5434515318b5 100644
--- a/velox/exec/ProbeOperatorState.h
+++ b/velox/exec/ProbeOperatorState.h
@@ -36,7 +36,7 @@ enum class ProbeOperatorState {
   kWaitForBuild = 0,
   /// The running state that join the probe input with the build table.
   kRunning = 1,
-  /// This state has different handlings for hash and nested loop join probe.
+  /// This state has different handling for hash and nested loop join probe.
   /// For hash probe, wait for all the peer probe operators to finish processing
   /// inputs.
   /// This state only applies when disk spilling is enabled. The last finished
@@ -55,3 +55,12 @@ enum class ProbeOperatorState {
 std::string probeOperatorStateName(ProbeOperatorState state);
 
 } // namespace facebook::velox::exec
+
+template <>
+struct fmt::formatter<facebook::velox::exec::ProbeOperatorState>
+    : formatter<int> {
+  auto format(facebook::velox::exec::ProbeOperatorState s, format_context& ctx)
+      const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/exec/RowContainer.cpp b/velox/exec/RowContainer.cpp
index fad8a0fe8fc7b..a158c31cdbeed 100644
--- a/velox/exec/RowContainer.cpp
+++ b/velox/exec/RowContainer.cpp
@@ -20,9 +20,12 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/ContainerRowSerde.h"
 #include "velox/exec/Operator.h"
+#include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::exec {
 namespace {
+static constexpr int32_t kNextRowVectorSize = sizeof(NextRowVector);
+
 template <TypeKind Kind>
 static int32_t kindSize() {
   return sizeof(typename KindToFlatVector<Kind>::HashRowType);
@@ -48,16 +51,21 @@ setBit(char* bits, uint32_t idx) {
 }
 } // namespace
 
-Accumulator::Accumulator(Aggregate* aggregate)
+Accumulator::Accumulator(Aggregate* aggregate, TypePtr spillType)
     : isFixedSize_{aggregate->isFixedSize()},
       fixedSize_{aggregate->accumulatorFixedWidthSize()},
       usesExternalMemory_{aggregate->accumulatorUsesExternalMemory()},
       alignment_{aggregate->accumulatorAlignmentSize()},
+      spillType_{std::move(spillType)},
+      spillExtractFunction_{
+          [aggregate](folly::Range<char**> groups, VectorPtr& result) {
+            aggregate->extractAccumulators(
+                groups.data(), groups.size(), &result);
+          }},
       destroyFunction_{[aggregate](folly::Range<char**> groups) {
         aggregate->destroy(groups);
-      }},
-      aggregate_{aggregate} {
-  VELOX_CHECK_NOT_NULL(aggregate_);
+      }} {
+  VELOX_CHECK_NOT_NULL(aggregate);
 }
 
 Accumulator::Accumulator(
@@ -65,12 +73,17 @@ Accumulator::Accumulator(
     int32_t fixedSize,
     bool usesExternalMemory,
     int32_t alignment,
+    TypePtr spillType,
+    std::function<void(folly::Range<char**> groups, VectorPtr& result)>
+        spillExtractFunction,
     std::function<void(folly::Range<char**> groups)> destroyFunction)
     : isFixedSize_{isFixedSize},
       fixedSize_{fixedSize},
       usesExternalMemory_{usesExternalMemory},
       alignment_{alignment},
-      destroyFunction_{destroyFunction} {}
+      spillType_{std::move(spillType)},
+      spillExtractFunction_{std::move(spillExtractFunction)},
+      destroyFunction_{std::move(destroyFunction)} {}
 
 bool Accumulator::isFixedSize() const {
   return isFixedSize_;
@@ -92,6 +105,16 @@ void Accumulator::destroy(folly::Range<char**> groups) {
   destroyFunction_(groups);
 }
 
+const TypePtr& Accumulator::spillType() const {
+  return spillType_;
+}
+
+void Accumulator::extractForSpill(
+    folly::Range<char**> groups,
+    VectorPtr& result) const {
+  spillExtractFunction_(groups, result);
+}
+
 // static
 int32_t RowContainer::combineAlignments(int32_t a, int32_t b) {
   VELOX_CHECK_EQ(__builtin_popcount(a), 1, "Alignment can only be power of 2");
@@ -99,6 +122,14 @@ int32_t RowContainer::combineAlignments(int32_t a, int32_t b) {
   return std::max(a, b);
 }
 
+std::string RowContainerIterator::toString() const {
+  return fmt::format(
+      "[allocationIndex:{} rowOffset:{} rowNumber:{}]",
+      allocationIndex,
+      rowOffset,
+      rowNumber);
+}
+
 RowContainer::RowContainer(
     const std::vector<TypePtr>& keyTypes,
     bool nullableKeys,
@@ -108,34 +139,34 @@ RowContainer::RowContainer(
     bool isJoinBuild,
     bool hasProbedFlag,
     bool hasNormalizedKeys,
-    memory::MemoryPool* pool,
-    std::shared_ptr<HashStringAllocator> stringAllocator)
+    memory::MemoryPool* pool)
     : keyTypes_(keyTypes),
       nullableKeys_(nullableKeys),
       isJoinBuild_(isJoinBuild),
-      accumulators_(accumulators),
       hasNormalizedKeys_(hasNormalizedKeys),
-      rows_(pool),
-      stringAllocator_(
-          stringAllocator ? stringAllocator
-                          : std::make_shared<HashStringAllocator>(pool)) {
-  // Compute the layout of the payload row.  The row has keys, null
-  // flags, accumulators, dependent fields. All fields are fixed
-  // width. If variable width data is referenced, this is done with
-  // StringView that inlines or points to the data.  The number of
-  // bytes used by each key is determined by keyTypes[i].  Null flags
-  // are one bit per field. If nullableKeys is true there is a null
-  // flag for each key. A null bit for each accumulator and dependent
-  // field follows.  If hasProbedFlag is true, there is an extra bit
-  // to track if the row has been selected by a hash join probe. This
-  // is followed by a free bit which is set if the row is in a free
-  // list. The accumulators come next, with size given by
-  // Aggregate::accumulatorFixedWidthSize(). Dependent fields follow.
-  // These are non-key columns for hash join or order by. If there are variable
-  // length columns or accumulators, i.e. ones that allocate extra space, this
-  // space is tracked by a uint32_t after the dependent columns. If this is a
-  // hash join build side, the pointer to the next row with the same key is
-  // after the optional row size.
+      stringAllocator_(std::make_unique<HashStringAllocator>(pool)),
+      accumulators_(accumulators),
+      rows_(pool) {
+  // Compute the layout of the payload row.  The row has keys, null flags,
+  // accumulators, dependent fields. All fields are fixed width. If variable
+  // width data is referenced, this is done with StringView(for VARCHAR) and
+  // std::string_view(for ARRAY, MAP and ROW) pointing to the data (StringView
+  // might inline the data if it's sufficiently small). The number of bytes used
+  // by each key is determined by keyTypes[i]. Null flags are one bit per field.
+  // If nullableKeys is true there is a null flag for each key. If there are
+  // accumulators, the remaining bits in the current byte are ignored and the
+  // flags for the accumulators begin aligned on the next byte. A null bit and
+  // an initialized bit, alternating, for each accumulator follow. A null bit
+  // for each dependent field follows that.  If hasProbedFlag is true, there is
+  // an extra bit to track if the row has been selected by a hash join probe.
+  // This is followed by a free bit which is set if the row is in a free list.
+  // The accumulators come next, with size given by
+  // Aggregate::accumulatorFixedWidthSize(). Dependent fields follow. These are
+  // non-key columns for hash join or order by. If there are variable length
+  // columns or accumulators, i.e. ones that allocate extra space, this space is
+  // tracked by a uint32_t after the dependent columns. If this is a hash join
+  // build side, the pointer to the next row with the same key is after the
+  // optional row size.
   //
   // In most cases, rows are prefixed with a normalized_key_t at index
   // -1, 8 bytes below the pointer. This space is reserved for a 64
@@ -154,16 +185,26 @@ RowContainer::RowContainer(
     offset += typeKindSize(type->kind());
     nullOffsets_.push_back(nullOffset);
     isVariableWidth |= !type->isFixedWidth();
-    if (nullableKeys) {
+    if (nullableKeys_) {
       ++nullOffset;
     }
+    columnHasNulls_.push_back(false);
   }
   // Make offset at least sizeof pointer so that there is space for a
   // free list next pointer below the bit at 'freeFlagOffset_'.
   offset = std::max<int32_t>(offset, sizeof(void*));
-  int32_t firstAggregate = offsets_.size();
-  int32_t firstAggregateOffset = offset;
+  const int32_t firstAggregateOffset = offset;
+  if (!accumulators.empty()) {
+    // This moves nullOffset to the start of the next byte.
+    // This is to guarantee the null and initialized bits for an aggregate
+    // always appear in the same byte.
+    nullOffset = (nullOffset + 7) & -8;
+  }
   for (const auto& accumulator : accumulators) {
+    // Initialized bit.  Set when the accumulator is initialized.
+    nullOffsets_.push_back(nullOffset);
+    ++nullOffset;
+    // Null bit.
     nullOffsets_.push_back(nullOffset);
     ++nullOffset;
     isVariableWidth |= !accumulator.isFixedSize();
@@ -176,6 +217,7 @@ RowContainer::RowContainer(
     nullOffsets_.push_back(nullOffset);
     ++nullOffset;
     isVariableWidth |= !type->isFixedWidth();
+    columnHasNulls_.push_back(false);
   }
   if (hasProbedFlag) {
     nullOffsets_.push_back(nullOffset);
@@ -186,12 +228,13 @@ RowContainer::RowContainer(
   nullOffsets_.push_back(nullOffset);
   freeFlagOffset_ = nullOffset + firstAggregateOffset * 8;
   ++nullOffset;
-  // Fixup nullOffsets_ to be the bit number from the start of the row.
+  // Add 1 to the last null offset to get the number of bits.
+  flagBytes_ = bits::nbytes(nullOffsets_.back() + 1);
+  // Fixup 'nullOffsets_' to be the bit number from the start of the row.
   for (int32_t i = 0; i < nullOffsets_.size(); ++i) {
     nullOffsets_[i] += firstAggregateOffset * 8;
   }
-  int32_t nullBytes = bits::nbytes(nullOffsets_.size());
-  offset += nullBytes;
+  offset += flagBytes_;
   for (const auto& accumulator : accumulators) {
     // Accumulator offset must be aligned by their alignment size.
     offset = bits::roundUp(offset, accumulator.alignment());
@@ -211,30 +254,34 @@ RowContainer::RowContainer(
     offset += sizeof(void*);
   }
   fixedRowSize_ = bits::roundUp(offset, alignment_);
-  for (int i = 0; i < accumulators_.size(); ++i) {
-    nullOffset = nullOffsets_[i + firstAggregate];
-  }
   // A distinct hash table has no aggregates and if the hash table has
   // no nulls, it may be that there are no null flags.
   if (!nullOffsets_.empty()) {
     // All flags like free and probed flags and null flags for keys and non-keys
-    // start as 0.
-    initialNulls_.resize(nullBytes, 0x0);
-    // Aggregates are null on a new row.
-    auto aggregateNullOffset = nullableKeys ? keyTypes.size() : 0;
-    for (int32_t i = 0; i < accumulators_.size(); ++i) {
-      bits::setBit(initialNulls_.data(), i + aggregateNullOffset);
-    }
+    // start as 0. This is also used to mark aggregates as uninitialized on row
+    // creation.
+    initialNulls_.resize(flagBytes_, 0x0);
   }
   originalNormalizedKeySize_ = hasNormalizedKeys_
       ? bits::roundUp(sizeof(normalized_key_t), alignment_)
       : 0;
   normalizedKeySize_ = originalNormalizedKeySize_;
+  size_t nullOffsetsPos = 0;
   for (auto i = 0; i < offsets_.size(); ++i) {
     rowColumns_.emplace_back(
         offsets_[i],
-        (nullableKeys_ || i >= keyTypes_.size()) ? nullOffsets_[i]
+        (nullableKeys_ || i >= keyTypes_.size()) ? nullOffsets_[nullOffsetsPos]
                                                  : RowColumn::kNotNullOffset);
+
+    // offsets_ contains the offsets for keys, then accumulators, then dependent
+    // columns.  This captures the case where i is the index of an accumulator.
+    if (!accumulators.empty() && i >= keyTypes_.size() &&
+        i < keyTypes_.size() + accumulators.size()) {
+      // Aggregates have null flags and initialized flags.
+      nullOffsetsPos += kNumAccumulatorFlags;
+    } else {
+      ++nullOffsetsPos;
+    }
   }
 }
 
@@ -266,13 +313,14 @@ char* RowContainer::initializeRow(char* row, bool reuse) {
     auto rows = folly::Range<char**>(&row, 1);
     freeVariableWidthFields(rows);
     freeAggregates(rows);
-  } else if (rowSizeOffset_ != 0 && checkFree_) {
+    VELOX_CHECK_EQ(nextOffset_, 0);
+  } else if (rowSizeOffset_ != 0) {
     // zero out string views so that clear() will not hit uninited data. The
     // fastest way is to set the whole row to 0.
     ::memset(row, 0, fixedRowSize_);
   }
   if (!nullOffsets_.empty()) {
-    memcpy(
+    ::memcpy(
         row + nullByte(nullOffsets_[0]),
         initialNulls_.data(),
         initialNulls_.size());
@@ -280,14 +328,15 @@ char* RowContainer::initializeRow(char* row, bool reuse) {
   if (rowSizeOffset_) {
     variableRowSize(row) = 0;
   }
+  if (nextOffset_) {
+    getNextRowVector(row) = nullptr;
+  }
   bits::clearBit(row, freeFlagOffset_);
   return row;
 }
 
 void RowContainer::eraseRows(folly::Range<char**> rows) {
-  freeVariableWidthFields(rows);
-  freeAggregates(rows);
-  numRows_ -= rows.size();
+  freeRowsExtraMemory(rows, false);
   for (auto* row : rows) {
     VELOX_CHECK(!bits::isBitSet(row, freeFlagOffset_), "Double free of row");
     bits::setBit(row, freeFlagOffset_);
@@ -340,28 +389,36 @@ int32_t RowContainer::findRows(folly::Range<char**> rows, char** result) {
   return numRows;
 }
 
+void RowContainer::appendNextRow(
+    char* current,
+    char* nextRow,
+    HashStringAllocator* allocator) {
+  VELOX_CHECK(getNextRowVector(nextRow) == nullptr);
+  NextRowVector*& nextRowArrayPtr = getNextRowVector(current);
+  if (nextRowArrayPtr == nullptr) {
+    nextRowArrayPtr = new (allocator->allocate(kNextRowVectorSize)->begin())
+        NextRowVector(StlAllocator<char*>(allocator));
+    hasDuplicateRows_ = true;
+    nextRowArrayPtr->emplace_back(current);
+  }
+  nextRowArrayPtr->emplace_back(nextRow);
+  getNextRowVector(nextRow) = nextRowArrayPtr;
+}
+
 void RowContainer::freeVariableWidthFields(folly::Range<char**> rows) {
   for (auto i = 0; i < types_.size(); ++i) {
     switch (typeKinds_[i]) {
       case TypeKind::VARCHAR:
-      case TypeKind::VARBINARY:
+      case TypeKind::VARBINARY: {
+        freeVariableWidthFieldsAtColumn<StringView>(i, rows);
+        break;
+      }
       case TypeKind::ROW:
       case TypeKind::ARRAY:
       case TypeKind::MAP: {
-        auto column = columnAt(i);
-        for (auto row : rows) {
-          if (!isNullAt(row, column.nullByte(), column.nullMask())) {
-            StringView view = valueAt<StringView>(row, column.offset());
-            if (!view.isInline()) {
-              stringAllocator_->free(
-                  HashStringAllocator::headerOf(view.data()));
-              if (checkFree_) {
-                valueAt<StringView>(row, column.offset()) = StringView();
-              }
-            }
-          }
-        }
-      } break;
+        freeVariableWidthFieldsAtColumn<std::string_view>(i, rows);
+        break;
+      }
       default:;
     }
   }
@@ -400,51 +457,317 @@ void RowContainer::freeAggregates(folly::Range<char**> rows) {
   }
 }
 
+void RowContainer::freeNextRowVectors(folly::Range<char**> rows, bool clear) {
+  if (!nextOffset_ || !hasDuplicateRows_) {
+    return;
+  }
+
+  if (clear) {
+    for (auto row : rows) {
+      auto vector = getNextRowVector(row);
+      if (vector) {
+        // Clear all rows, we can clear the nextOffset_ slots and delete the
+        // next-row-vector.
+        for (auto& next : *vector) {
+          getNextRowVector(next) = nullptr;
+        }
+        // Because of 'parallelJoinBuild', the memory for the next row vector
+        // may not be allocated from the RowContainer to which the row belongs,
+        // hence we need to release memory through the vector's allocator.
+        auto allocator = vector->get_allocator().allocator();
+        std::destroy_at(vector);
+        allocator->free(HashStringAllocator::headerOf(vector));
+      }
+    }
+    return;
+  }
+
+  for (auto row : rows) {
+    auto vector = getNextRowVector(row);
+    if (vector) {
+      // If 'clear' is false, the caller must ensure that all rows with same
+      // keys appear in the 'rows'.
+      for (auto& next : *vector) {
+        VELOX_CHECK(
+            std::find(rows.begin(), rows.end(), next) != rows.end(),
+            "All rows with the same keys must be present in 'rows'");
+        getNextRowVector(next) = nullptr;
+      }
+      auto allocator = vector->get_allocator().allocator();
+      std::destroy_at(vector);
+      allocator->free(HashStringAllocator::headerOf(vector));
+    }
+  }
+}
+
+void RowContainer::freeRowsExtraMemory(folly::Range<char**> rows, bool clear) {
+  freeVariableWidthFields(rows);
+  freeAggregates(rows);
+  freeNextRowVectors(rows, clear);
+  numRows_ -= rows.size();
+}
+
 void RowContainer::store(
     const DecodedVector& decoded,
     vector_size_t index,
     char* row,
     int32_t column) {
   auto numKeys = keyTypes_.size();
-  if (column < numKeys && !nullableKeys_) {
+  bool isKey = column < numKeys;
+  if (isKey && !nullableKeys_) {
     VELOX_DYNAMIC_TYPE_DISPATCH(
         storeNoNulls,
         typeKinds_[column],
         decoded,
         index,
+        isKey,
         row,
         offsets_[column]);
   } else {
-    VELOX_DCHECK(column < keyTypes_.size() || accumulators_.empty());
+    VELOX_DCHECK(isKey || accumulators_.empty());
     auto rowColumn = rowColumns_[column];
     VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
         storeWithNulls,
         typeKinds_[column],
         decoded,
         index,
+        isKey,
         row,
         rowColumn.offset(),
         rowColumn.nullByte(),
-        rowColumn.nullMask());
+        rowColumn.nullMask(),
+        column);
   }
 }
 
-void RowContainer::prepareRead(
-    const char* row,
-    int32_t offset,
-    ByteStream& stream) {
-  auto view = reinterpret_cast<const StringView*>(row + offset);
-  if (view->isInline()) {
-    stream.setRange(ByteRange{
-        const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(view->data())),
-        static_cast<int32_t>(view->size()),
-        0});
-    return;
+void RowContainer::store(
+    const DecodedVector& decoded,
+    folly::Range<char**> rows,
+    int32_t column) {
+  VELOX_CHECK_GE(decoded.size(), rows.size());
+  const bool isKey = column < keyTypes_.size();
+  if ((isKey && !nullableKeys_) || !decoded.mayHaveNulls()) {
+    VELOX_DYNAMIC_TYPE_DISPATCH(
+        storeNoNullsBatch,
+        typeKinds_[column],
+        decoded,
+        rows,
+        isKey,
+        offsets_[column]);
+  } else {
+    const auto rowColumn = rowColumns_[column];
+    VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+        storeWithNullsBatch,
+        typeKinds_[column],
+        decoded,
+        rows,
+        isKey,
+        rowColumn.offset(),
+        rowColumn.nullByte(),
+        rowColumn.nullMask(),
+        column);
   }
+}
+
+std::unique_ptr<ByteInputStream> RowContainer::prepareRead(
+    const char* row,
+    int32_t offset) {
+  const auto& view = reinterpret_cast<const std::string_view*>(row + offset);
   // We set 'stream' to range over the ranges that start at the Header
-  // immediately below the first character in the StringView.
-  HashStringAllocator::prepareRead(
-      HashStringAllocator::headerOf(view->data()), stream);
+  // immediately below the first character in the std::string_view.
+  return HashStringAllocator::prepareRead(
+      HashStringAllocator::headerOf(view->data()));
+}
+
+int32_t RowContainer::variableSizeAt(const char* row, column_index_t column) {
+  const auto rowColumn = rowColumns_[column];
+
+  if (isNullAt(row, rowColumn)) {
+    return 0;
+  }
+
+  const auto typeKind = typeKinds_[column];
+  if (typeKind == TypeKind::VARCHAR || typeKind == TypeKind::VARBINARY) {
+    return reinterpret_cast<const StringView*>(row + rowColumn.offset())
+        ->size();
+  } else {
+    return reinterpret_cast<const std::string_view*>(row + rowColumn.offset())
+        ->size();
+  }
+}
+
+int32_t RowContainer::fixedSizeAt(column_index_t column) {
+  return typeKindSize(typeKinds_[column]);
+}
+
+int32_t RowContainer::extractVariableSizeAt(
+    const char* row,
+    column_index_t column,
+    char* output) {
+  const auto rowColumn = rowColumns_[column];
+
+  // 4 bytes for size + N bytes for data.
+  if (isNullAt(row, rowColumn)) {
+    ::memset(output, 0, 4);
+    return 4;
+  }
+
+  const auto typeKind = typeKinds_[column];
+  if (typeKind == TypeKind::VARCHAR || typeKind == TypeKind::VARBINARY) {
+    const auto value = valueAt<StringView>(row, rowColumn.offset());
+    const auto size = value.size();
+    ::memcpy(output, &size, 4);
+
+    if (value.isInline() ||
+        reinterpret_cast<const HashStringAllocator::Header*>(value.data())[-1]
+                .size() >= value.size()) {
+      ::memcpy(output + 4, value.data(), size);
+    } else {
+      auto stream = HashStringAllocator::prepareRead(
+          HashStringAllocator::headerOf(value.data()));
+      stream->readBytes(output + 4, size);
+    }
+    return 4 + size;
+  }
+
+  const auto value = valueAt<std::string_view>(row, rowColumn.offset());
+  const auto size = value.size();
+
+  auto stream = prepareRead(row, rowColumn.offset());
+
+  ::memcpy(output, &size, 4);
+  stream->readBytes(output + 4, size);
+
+  return 4 + size;
+}
+
+int32_t RowContainer::storeVariableSizeAt(
+    const char* data,
+    char* row,
+    column_index_t column) {
+  const auto typeKind = typeKinds_[column];
+  const auto rowColumn = rowColumns_[column];
+
+  // First 4 bytes is the size of the data.
+  const auto size = *reinterpret_cast<const int32_t*>(data);
+
+  if (typeKind == TypeKind::VARCHAR || typeKind == TypeKind::VARBINARY) {
+    if (size > 0) {
+      stringAllocator_->copyMultipart(
+          StringView(data + 4, size), row, rowColumn.offset());
+    } else {
+      valueAt<StringView>(row, rowColumn.offset()) = StringView();
+    }
+  } else {
+    if (size > 0) {
+      ByteOutputStream stream(stringAllocator_.get(), false, false);
+      const auto position = stringAllocator_->newWrite(stream);
+      stream.appendStringView(std::string_view(data + 4, size));
+      stringAllocator_->finishWrite(stream, 0);
+      valueAt<std::string_view>(row, rowColumn.offset()) =
+          std::string_view(reinterpret_cast<char*>(position.position), size);
+    } else {
+      valueAt<std::string_view>(row, rowColumn.offset()) = std::string_view();
+    }
+  }
+
+  return 4 + size;
+}
+
+void RowContainer::extractSerializedRows(
+    folly::Range<char**> rows,
+    const VectorPtr& result) {
+  // The format of the extracted row is: null bytes followed by keys and
+  // dependent columns. Fixed-width columns are serialized into fixed number of
+  // bytes (see typeKindSize). Variable-width columns are serialized as 4 bytes
+  // of size followed by that many bytes.
+
+  // First, calculate total number of bytes needed to serialize all rows.
+
+  size_t fixedWidthRowSize = 0;
+  bool hasVariableWidth = false;
+  for (auto i = 0; i < types_.size(); ++i) {
+    const auto& type = types_[i];
+    if (type->isFixedWidth()) {
+      fixedWidthRowSize += typeKindSize(type->kind());
+    } else {
+      hasVariableWidth = true;
+    }
+  }
+
+  size_t totalBytes =
+      flagBytes_ * rows.size() + fixedWidthRowSize * rows.size();
+  if (hasVariableWidth) {
+    for (const char* row : rows) {
+      for (auto i = 0; i < types_.size(); ++i) {
+        const auto& type = types_[i];
+        if (!type->isFixedWidth()) {
+          // 4 bytes for size + N bytes for data.
+          totalBytes += 4 + variableSizeAt(row, i);
+        }
+      }
+    }
+  }
+
+  // Allocate sufficient buffer.
+  auto* flatResult = result->as<FlatVector<StringView>>();
+  flatResult->resize(rows.size());
+  auto* rawBuffer = flatResult->getRawStringBufferWithSpace(totalBytes, true);
+
+  // Write serialized data.
+  size_t totalWritten = 0;
+  for (auto i = 0; i < rows.size(); ++i) {
+    auto* row = rows[i];
+    size_t offset = 0;
+
+    // Copy nulls and other flags.
+    ::memcpy(rawBuffer + offset, row + rowColumns_[0].nullByte(), flagBytes_);
+    offset += flagBytes_;
+
+    // Copy values.
+    for (auto j = 0; j < types_.size(); ++j) {
+      const auto& type = types_[j];
+      if (type->isFixedWidth()) {
+        const auto size = typeKindSize(type->kind());
+        ::memcpy(rawBuffer + offset, row + rowColumns_[j].offset(), size);
+        offset += size;
+      } else {
+        auto size = extractVariableSizeAt(row, j, rawBuffer + offset);
+        offset += size;
+      }
+    }
+
+    flatResult->setNoCopy(i, StringView(rawBuffer, offset));
+    rawBuffer += offset;
+    totalWritten += offset;
+  }
+
+  VELOX_CHECK_EQ(totalWritten, totalBytes);
+}
+
+void RowContainer::storeSerializedRow(
+    const FlatVector<StringView>& vector,
+    vector_size_t index,
+    char* row) {
+  VELOX_CHECK(!vector.isNullAt(index));
+  auto serialized = vector.valueAt(index);
+  size_t offset = 0;
+
+  ::memcpy(row + rowColumns_[0].nullByte(), serialized.data(), flagBytes_);
+  offset += flagBytes_;
+
+  RowSizeTracker tracker(row[rowSizeOffset_], *stringAllocator_);
+  for (auto i = 0; i < types_.size(); ++i) {
+    const auto& type = types_[i];
+    if (type->isFixedWidth()) {
+      const auto size = typeKindSize(type->kind());
+      ::memcpy(row + rowColumns_[i].offset(), serialized.data() + offset, size);
+      offset += size;
+    } else {
+      const auto size = storeVariableSizeAt(serialized.data() + offset, row, i);
+      offset += size;
+    }
+  }
 }
 
 void RowContainer::extractString(
@@ -459,32 +782,37 @@ void RowContainer::extractString(
     return;
   }
   auto rawBuffer = values->getRawStringBufferWithSpace(value.size());
-  ByteStream stream;
-  HashStringAllocator::prepareRead(
-      HashStringAllocator::headerOf(value.data()), stream);
-  stream.readBytes(rawBuffer, value.size());
+  auto stream = HashStringAllocator::prepareRead(
+      HashStringAllocator::headerOf(value.data()));
+  stream->readBytes(rawBuffer, value.size());
   values->setNoCopy(index, StringView(rawBuffer, value.size()));
 }
 
 void RowContainer::storeComplexType(
     const DecodedVector& decoded,
     vector_size_t index,
+    bool isKey,
     char* row,
     int32_t offset,
     int32_t nullByte,
-    uint8_t nullMask) {
+    uint8_t nullMask,
+    int32_t column) {
   if (decoded.isNullAt(index)) {
     VELOX_DCHECK(nullMask);
     row[nullByte] |= nullMask;
+    updateColumnHasNulls(column, true);
     return;
   }
   RowSizeTracker tracker(row[rowSizeOffset_], *stringAllocator_);
-  ByteStream stream(stringAllocator_.get(), false, false);
+  ByteOutputStream stream(stringAllocator_.get(), false, false);
   auto position = stringAllocator_->newWrite(stream);
-  ContainerRowSerde::serialize(*decoded.base(), decoded.index(index), stream);
+  ContainerRowSerdeOptions options{.isKey = isKey};
+  ContainerRowSerde::serialize(
+      *decoded.base(), decoded.index(index), stream, options);
   stringAllocator_->finishWrite(stream, 0);
-  valueAt<StringView>(row, offset) =
-      StringView(reinterpret_cast<char*>(position.position), stream.size());
+
+  valueAt<std::string_view>(row, offset) = std::string_view(
+      reinterpret_cast<char*>(position.position), stream.size());
 }
 
 //   static
@@ -504,11 +832,10 @@ int RowContainer::compareComplexType(
     const DecodedVector& decoded,
     vector_size_t index,
     CompareFlags flags) {
-  VELOX_DCHECK(!flags.mayStopAtNull(), "not supported null handling mode");
+  VELOX_DCHECK(flags.nullAsValue(), "not supported null handling mode");
 
-  ByteStream stream;
-  prepareRead(row, offset, stream);
-  return ContainerRowSerde::compare(stream, decoded, index, flags);
+  auto stream = prepareRead(row, offset);
+  return ContainerRowSerde::compare(*stream, decoded, index, flags);
 }
 
 int32_t RowContainer::compareStringAsc(StringView left, StringView right) {
@@ -525,13 +852,11 @@ int32_t RowContainer::compareComplexType(
     int32_t leftOffset,
     int32_t rightOffset,
     CompareFlags flags) {
-  VELOX_DCHECK(!flags.mayStopAtNull(), "not supported null handling mode");
+  VELOX_DCHECK(flags.nullAsValue(), "not supported null handling mode");
 
-  ByteStream leftStream;
-  ByteStream rightStream;
-  prepareRead(left, leftOffset, leftStream);
-  prepareRead(right, rightOffset, rightStream);
-  return ContainerRowSerde::compare(leftStream, rightStream, type, flags);
+  auto leftStream = prepareRead(left, leftOffset);
+  auto rightStream = prepareRead(right, rightOffset);
+  return ContainerRowSerde::compare(*leftStream, *rightStream, type, flags);
 }
 
 int32_t RowContainer::compareComplexType(
@@ -552,28 +877,28 @@ void RowContainer::hashTyped(
     bool mix,
     uint64_t* result) {
   using T = typename KindToFlatVector<Kind>::HashRowType;
-  auto nullByte = column.nullByte();
-  auto nullMask = column.nullMask();
+
   auto offset = column.offset();
   std::string storage;
   auto numRows = rows.size();
   for (int32_t i = 0; i < numRows; ++i) {
     char* row = rows[i];
-    if (nullable && isNullAt(row, nullByte, nullMask)) {
+    if (nullable && isNullAt(row, column)) {
       result[i] = mix ? bits::hashMix(result[i], BaseVector::kNullHash)
                       : BaseVector::kNullHash;
     } else {
       uint64_t hash;
-      if (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+      if constexpr (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
         hash =
             folly::hasher<StringView>()(HashStringAllocator::contiguousString(
                 valueAt<StringView>(row, offset), storage));
-      } else if (
+      } else if constexpr (
           Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
           Kind == TypeKind::MAP) {
-        ByteStream in;
-        prepareRead(row, offset, in);
-        hash = ContainerRowSerde::hash(in, type);
+        auto in = prepareRead(row, offset);
+        hash = ContainerRowSerde::hash(*in, type);
+      } else if constexpr (std::is_floating_point_v<T>) {
+        hash = util::floating_point::NaNAwareHash<T>()(valueAt<T>(row, offset));
       } else {
         hash = folly::hasher<T>()(valueAt<T>(row, offset));
       }
@@ -608,22 +933,18 @@ void RowContainer::hash(
 }
 
 void RowContainer::clear() {
-  const bool sharedStringAllocator = !stringAllocator_.unique();
-  if (checkFree_ || sharedStringAllocator || usesExternalMemory_) {
+  if (usesExternalMemory_) {
     constexpr int32_t kBatch = 1000;
     std::vector<char*> rows(kBatch);
     RowContainerIterator iter;
     while (auto numRows = listRows(&iter, kBatch, rows.data())) {
-      eraseRows(folly::Range<char**>(rows.data(), numRows));
+      freeRowsExtraMemory(folly::Range<char**>(rows.data(), numRows), true);
     }
   }
+  hasDuplicateRows_ = false;
+
   rows_.clear();
-  if (!sharedStringAllocator) {
-    if (checkFree_) {
-      stringAllocator_->checkEmpty();
-    }
-    stringAllocator_->clear();
-  }
+  stringAllocator_->clear();
   numRows_ = 0;
   numRowsWithNormalizedKey_ = 0;
   normalizedKeySize_ = originalNormalizedKeySize_;
@@ -641,7 +962,7 @@ void RowContainer::setProbedFlag(char** rows, int32_t numRows) {
 }
 
 void RowContainer::extractProbedFlags(
-    const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+    const char* const* rows,
     int32_t numRows,
     bool setNullForNullKeysRow,
     bool setNullForNonProbedRow,
@@ -655,9 +976,7 @@ void RowContainer::extractProbedFlags(
     bool nullResult = false;
     if (setNullForNullKeysRow && nullableKeys_) {
       for (auto c = 0; c < keyTypes_.size(); ++c) {
-        bool isNull =
-            isNullAt(rows[i], columnAt(c).nullByte(), columnAt(c).nullMask());
-        if (isNull) {
+        if (isNullAt(rows[i], columnAt(c))) {
           nullResult = true;
           break;
         }
@@ -667,7 +986,7 @@ void RowContainer::extractProbedFlags(
     if (nullResult) {
       flatResult->setNull(i, true);
     } else {
-      bool probed = bits::isBitSet(rows[i], probedFlagOffset_);
+      const bool probed = bits::isBitSet(rows[i], probedFlagOffset_);
       if (setNullForNonProbedRow && !probed) {
         flatResult->setNull(i, true);
       } else {
@@ -800,8 +1119,8 @@ int32_t RowContainer::listPartitionRows(
         atEnd = true;
       }
       while (bits) {
-        int32_t hit = __builtin_ctz(bits);
-        auto distance = hit + startRow - iter.rowNumber;
+        const int32_t hit = __builtin_ctz(bits);
+        const auto distance = hit + startRow - iter.rowNumber;
         skip(iter, distance);
         result[numResults++] = iter.currentRow();
         if (numResults == maxRows) {
@@ -812,8 +1131,8 @@ int32_t RowContainer::listPartitionRows(
         bits &= bits - 1;
       }
       startRow += kBatch;
-      // The last batch of 32 bytes may have been partly filled. If so, we could
-      // have skipped past end.
+      // The last batch of 32 bytes may have been partly filled. If so, we
+      // could have skipped past end.
       if (atEnd) {
         iter.rowNumber = numRows_;
         return numResults;
@@ -827,6 +1146,46 @@ int32_t RowContainer::listPartitionRows(
   return numResults;
 }
 
+std::string RowContainer::toString() const {
+  std::stringstream out;
+  out << "Keys: ";
+  for (auto i = 0; i < keyTypes_.size(); ++i) {
+    if (i > 0) {
+      out << ", ";
+    }
+    out << keyTypes_[i]->toString();
+  }
+
+  if (types_.size() > keyTypes_.size()) {
+    out << " Dependents: ";
+    for (auto i = keyTypes_.size(); i < types_.size(); ++i) {
+      if (i > keyTypes_.size()) {
+        out << ", ";
+      }
+      out << types_[i]->toString();
+    }
+  }
+
+  if (!accumulators_.empty()) {
+    out << " Num accumulators: " << accumulators_.size();
+  }
+
+  out << " Num rows: " << numRows_;
+  return out.str();
+}
+
+std::string RowContainer::toString(const char* row) const {
+  auto types = types_;
+  auto rowType = ROW(std::move(types));
+  auto vector = BaseVector::create<RowVector>(rowType, 1, pool());
+
+  for (auto i = 0; i < rowType->size(); ++i) {
+    extractColumn(&row, 1, columnAt(i), 0, vector->childAt(i));
+  }
+
+  return vector->toString(0);
+}
+
 RowPartitions::RowPartitions(int32_t numRows, memory::MemoryPool& pool)
     : capacity_(numRows) {
   const auto numPages = memory::AllocationTraits::numPages(capacity_);
@@ -845,7 +1204,7 @@ void RowPartitions::appendPartitions(folly::Range<const uint8_t*> partitions) {
     allocation_.findRun(size_, &run, &offset);
     auto runSize = allocation_.runAt(run).numBytes();
     auto copySize = std::min<int32_t>(toAdd, runSize - offset);
-    memcpy(
+    ::memcpy(
         allocation_.runAt(run).data<uint8_t>() + offset,
         &partitions[index],
         copySize);
diff --git a/velox/exec/RowContainer.h b/velox/exec/RowContainer.h
index 4ab6fcd9a6cc9..9e28fb527e455 100644
--- a/velox/exec/RowContainer.h
+++ b/velox/exec/RowContainer.h
@@ -25,6 +25,8 @@
 
 namespace facebook::velox::exec {
 
+using NextRowVector = std::vector<char*, StlAllocator<char*>>;
+
 class Aggregate;
 
 class Accumulator {
@@ -34,9 +36,12 @@ class Accumulator {
       int32_t fixedSize,
       bool usesExternalMemory,
       int32_t alignment,
+      TypePtr spillType,
+      std::function<void(folly::Range<char**> groups, VectorPtr& result)>
+          spillExtractFunction,
       std::function<void(folly::Range<char**> groups)> destroyFunction);
 
-  explicit Accumulator(Aggregate* aggregate);
+  explicit Accumulator(Aggregate* aggregate, TypePtr spillType);
 
   bool isFixedSize() const;
 
@@ -46,21 +51,20 @@ class Accumulator {
 
   int32_t alignment() const;
 
-  void destroy(folly::Range<char**> groups);
+  const TypePtr& spillType() const;
 
-  /// Used only for spilling. Do not introduce other usages.
-  Aggregate* aggregateForSpill() const {
-    VELOX_CHECK_NOT_NULL(aggregate_);
-    return aggregate_;
-  }
+  void extractForSpill(folly::Range<char**> groups, VectorPtr& result) const;
+
+  void destroy(folly::Range<char**> groups);
 
  private:
   const bool isFixedSize_;
   const int32_t fixedSize_;
   const bool usesExternalMemory_;
   const int32_t alignment_;
+  const TypePtr spillType_;
+  std::function<void(folly::Range<char**>, VectorPtr&)> spillExtractFunction_;
   std::function<void(folly::Range<char**> groups)> destroyFunction_;
-  Aggregate* aggregate_{nullptr};
 };
 
 using normalized_key_t = uint64_t;
@@ -68,19 +72,19 @@ using normalized_key_t = uint64_t;
 struct RowContainerIterator {
   int32_t allocationIndex = 0;
   int32_t rowOffset = 0;
-  // Number of unvisited entries that are prefixed by an uint64_t for
-  // normalized key. Set in listRows() on first call.
+  /// Number of unvisited entries that are prefixed by an uint64_t for
+  /// normalized key. Set in listRows() on first call.
   int64_t normalizedKeysLeft = 0;
   int normalizedKeySize = 0;
 
-  // Ordinal position of 'currentRow' in RowContainer.
+  /// Ordinal position of 'currentRow' in RowContainer.
   int32_t rowNumber{0};
-  char* FOLLY_NULLABLE rowBegin{nullptr};
-  // First byte after the end of the range containing 'currentRow'.
-  char* FOLLY_NULLABLE endOfRun{nullptr};
+  char* rowBegin{nullptr};
+  /// First byte after the end of the range containing 'currentRow'.
+  char* endOfRun{nullptr};
 
-  // Returns the current row, skipping a possible normalized key below the first
-  // byte of row.
+  /// Returns the current row, skipping a possible normalized key below the
+  /// first byte of row.
   inline char* currentRow() const {
     return (rowBegin && normalizedKeysLeft) ? rowBegin + normalizedKeySize
                                             : rowBegin;
@@ -89,6 +93,8 @@ struct RowContainerIterator {
   void reset() {
     *this = {};
   }
+
+  std::string toString() const;
 };
 
 /// Container with a 8-bit partition number field for each row in a
@@ -121,11 +127,11 @@ class RowPartitions {
   memory::Allocation allocation_;
 };
 
-// Packed representation of offset, null byte offset and null mask for
-// a column inside a RowContainer.
+/// Packed representation of offset, null byte offset and null mask for
+/// a column inside a RowContainer.
 class RowColumn {
  public:
-  // Used as null offset for a non-null column.
+  /// Used as null offset for a non-null column.
   static constexpr int32_t kNotNullOffset = -1;
 
   RowColumn(int32_t offset, int32_t nullOffset)
@@ -143,6 +149,20 @@ class RowColumn {
     return packedOffsets_ & 0xff;
   }
 
+  /// The null bits and the initialized bits for accumulators start at the
+  /// beginning of the first byte following the null bits for the keys.  This
+  /// guarantees that they always appear on the same byte for any given
+  /// accumulator (since 2 evenly divides 8).
+  int32_t initializedByte() const {
+    return nullByte();
+  }
+
+  /// The initialized bit for an accumulator is guaranteed to appear on the same
+  /// byte immediately following the null bit for that accumulator.
+  int32_t initializedMask() const {
+    return nullMask() << 1;
+  }
+
  private:
   static uint64_t PackOffsets(int32_t offset, int32_t nullOffset) {
     if (nullOffset == kNotNullOffset) {
@@ -158,23 +178,24 @@ class RowColumn {
   const uint64_t packedOffsets_;
 };
 
-// Collection of rows for aggregation, hash join, order by
+/// Collection of rows for aggregation, hash join, order by.
 class RowContainer {
  public:
   static constexpr uint64_t kUnlimited = std::numeric_limits<uint64_t>::max();
+  /// The number of flags (bits) per accumulator, one for null and one for
+  /// initialized.
+  static constexpr size_t kNumAccumulatorFlags = 2;
   using Eraser = std::function<void(folly::Range<char**> rows)>;
 
-  // 'keyTypes' gives the type of row and use 'allocator' for bulk
-  // allocation.
-  RowContainer(
-      const std::vector<TypePtr>& keyTypes,
-      memory::MemoryPool* FOLLY_NONNULL pool)
+  /// 'keyTypes' gives the type of row and use 'allocator' for bulk
+  /// allocation.
+  RowContainer(const std::vector<TypePtr>& keyTypes, memory::MemoryPool* pool)
       : RowContainer(keyTypes, std::vector<TypePtr>{}, pool) {}
 
   RowContainer(
       const std::vector<TypePtr>& keyTypes,
       const std::vector<TypePtr>& dependentTypes,
-      memory::MemoryPool* FOLLY_NONNULL pool)
+      memory::MemoryPool* pool)
       : RowContainer(
             keyTypes,
             true, // nullableKeys
@@ -190,26 +211,22 @@ class RowContainer {
 
   static int32_t combineAlignments(int32_t a, int32_t b);
 
-  // 'keyTypes' gives the type of the key of each row. For a group by,
-  // order by or right outer join build side these may be
-  // nullable. 'nullableKeys' specifies if these have a null flag.
-  // 'aggregates' is a vector of Aggregate for a group by payload,
-  // empty otherwise. 'DependentTypes' gives the types of non-key
-  // columns for a hash join build side or an order by. 'hasNext' is
-  // true for a hash join build side where keys can be
-  // non-unique. 'isJoinBuild' is true for hash join build sides. This
-  // implies that hashing of keys ignores null keys even if these were
-  // allowed. 'hasProbedFlag' indicates that an extra bit is reserved
-  // for a probed state of a full or right outer
-  // join. 'hasNormalizedKey' specifies that an extra word is left
-  // below each row for a normalized key that collapses all parts
-  // into one word for faster comparison. The bulk allocation is done
-  // from 'allocator'. ContainerRowSerde is used for serializing complex
-  // type values into the container.
-  /// ''stringAllocator' allows sharing the variable length data arena with
-  /// another RowContainer. this is
-  // needed for spilling where the same aggregates are used for
-  // reading one container and merging into another.
+  /// 'keyTypes' gives the type of the key of each row. For a group by,
+  /// order by or right outer join build side these may be
+  /// nullable. 'nullableKeys' specifies if these have a null flag.
+  /// 'aggregates' is a vector of Aggregate for a group by payload,
+  /// empty otherwise. 'DependentTypes' gives the types of non-key
+  /// columns for a hash join build side or an order by. 'hasNext' is
+  /// true for a hash join build side where keys can be
+  /// non-unique. 'isJoinBuild' is true for hash join build sides. This
+  /// implies that hashing of keys ignores null keys even if these were
+  /// allowed. 'hasProbedFlag' indicates that an extra bit is reserved
+  /// for a probed state of a full or right outer
+  /// join. 'hasNormalizedKey' specifies that an extra word is left
+  /// below each row for a normalized key that collapses all parts
+  /// into one word for faster comparison. The bulk allocation is done
+  /// from 'allocator'. ContainerRowSerde is used for serializing complex
+  /// type values into the container.
   RowContainer(
       const std::vector<TypePtr>& keyTypes,
       bool nullableKeys,
@@ -219,139 +236,192 @@ class RowContainer {
       bool isJoinBuild,
       bool hasProbedFlag,
       bool hasNormalizedKey,
-      memory::MemoryPool* FOLLY_NONNULL pool,
-      std::shared_ptr<HashStringAllocator> stringAllocator = nullptr);
+      memory::MemoryPool* pool);
 
-  // Allocates a new row and initializes possible aggregates to null.
-  char* FOLLY_NONNULL newRow();
+  /// Allocates a new row and initializes possible aggregates to null.
+  char* newRow();
 
-  uint32_t rowSize(const char* FOLLY_NONNULL row) const {
+  uint32_t rowSize(const char* row) const {
     return fixedRowSize_ +
         (rowSizeOffset_
              ? *reinterpret_cast<const uint32_t*>(row + rowSizeOffset_)
              : 0);
   }
 
-  /// Sets all fields, aggregates, keys and dependents to null. Used
-  /// when making a row with uninitialized keys for aggregates with
-  /// no-op partial aggregation.
-  void setAllNull(char* FOLLY_NONNULL row) {
+  /// Sets all fields, aggregates, keys and dependents to null. Used when making
+  /// a row with uninitialized keys for aggregates with no-op partial
+  /// aggregation.
+  void setAllNull(char* row) {
     if (!nullOffsets_.empty()) {
       memset(row + nullByte(nullOffsets_[0]), 0xff, initialNulls_.size());
       bits::clearBit(row, freeFlagOffset_);
     }
   }
 
-  // The row size excluding any out-of-line stored variable length values.
+  /// The row size excluding any out-of-line stored variable length values.
   int32_t fixedRowSize() const {
     return fixedRowSize_;
   }
 
-  // Adds 'rows' to the free rows list and frees any associated
-  // variable length data.
+  /// Adds 'rows' to the free rows list and frees any associated variable length
+  /// data.
   void eraseRows(folly::Range<char**> rows);
 
-  // Copies elements of 'rows' where the char* points to a row inside 'this' to
-  // 'result' and returns the number copied. 'result' should have space for
-  // 'rows.size()'.
+  /// Copies elements of 'rows' where the char* points to a row inside 'this' to
+  /// 'result' and returns the number copied. 'result' should have space for
+  /// 'rows.size()'.
   int32_t findRows(folly::Range<char**> rows, char** result);
 
-  void incrementRowSize(char* FOLLY_NONNULL row, uint64_t bytes) {
+  void incrementRowSize(char* row, uint64_t bytes) {
     uint32_t* ptr = reinterpret_cast<uint32_t*>(row + rowSizeOffset_);
     uint64_t size = *ptr + bytes;
     *ptr = std::min<uint64_t>(size, std::numeric_limits<uint32_t>::max());
   }
 
-  // Initialize row. 'reuse' specifies whether the 'row' is reused or
-  // not. If it is reused, it will free memory associated with the row
-  // elsewhere (such as in HashStringAllocator).
-  char* FOLLY_NONNULL initializeRow(char* FOLLY_NONNULL row, bool reuse);
+  /// Initialize row. 'reuse' specifies whether the 'row' is reused or not. If
+  /// it is reused, it will free memory associated with the row elsewhere (such
+  /// as in HashStringAllocator).
+  /// Note: Fields of the row are not zero-initialized. If the row contains
+  /// variable-width fields, the caller must populate these fields by calling
+  /// 'store' or initialize them to zero by calling 'initializeFields'.
+  char* initializeRow(char* row, bool reuse);
 
-  // Stores the 'index'th value in 'decoded' into 'row' at
-  // 'columnIndex'.
+  /// Zero out all the fields of the 'row'.
+  void initializeFields(char* row) {
+    ::memset(row, 0, fixedRowSize_);
+  }
+
+  /// Stores the 'index'th value in 'decoded' into 'row' at 'columnIndex'.
   void store(
       const DecodedVector& decoded,
       vector_size_t index,
-      char* FOLLY_NONNULL row,
+      char* row,
+      int32_t columnIndex);
+
+  /// Stores the first 'rows.size' values from the 'decoded' vector into the
+  /// 'columnIndex' column of 'rows'.
+  void store(
+      const DecodedVector& decoded,
+      folly::Range<char**> rows,
       int32_t columnIndex);
 
   HashStringAllocator& stringAllocator() {
     return *stringAllocator_;
   }
 
-  const std::shared_ptr<HashStringAllocator>& stringAllocatorShared() {
-    return stringAllocator_;
-  }
-
-  // Returns the number of used rows in 'this'. This is the number of
-  // rows a RowContainerIterator would access.
+  /// Returns the number of used rows in 'this'. This is the number of rows a
+  /// RowContainerIterator would access.
   int64_t numRows() const {
     return numRows_;
   }
 
+  /// Copy key and dependent columns into a flat VARBINARY vector. All columns
+  /// of a row are copied into a single buffer. The format of that buffer is an
+  /// implementation detail. The data can be loaded back into the RowContainer
+  /// using 'storeSerializedRow'.
+  ///
+  /// Used for spilling as it is more efficient than converting from row to
+  /// columnar format.
+  void extractSerializedRows(
+      folly::Range<char**> rows,
+      const VectorPtr& result);
+
+  /// Copies serialized row produced by 'extractSerializedRow' into the
+  /// container.
+  void storeSerializedRow(
+      const FlatVector<StringView>& vector,
+      vector_size_t index,
+      char* row);
+
   /// Copies the values at 'col' into 'result' (starting at 'resultOffset')
   /// for the 'numRows' rows pointed to by 'rows'. If a 'row' is null, sets
   /// corresponding row in 'result' to null.
+  /// @param columnHasNulls indicates whether the 'col' column contains null
+  /// values. If 'columnHasNulls' is false, a null-free optimization will be
+  /// applied. It is the caller's responsibility to ensure this flag is set
+  /// correctly.
   static void extractColumn(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       int32_t numRows,
       RowColumn col,
+      bool columnHasNulls,
       vector_size_t resultOffset,
       const VectorPtr& result);
 
-  // Copies the values at 'col' into 'result' for the
-  // 'numRows' rows pointed to by 'rows'. If an entry in 'rows' is null, sets
-  // corresponding row in 'result' to null.
+  /// Copies the values at 'col' into 'result' for the 'numRows' rows pointed to
+  /// by 'rows'. If an entry in 'rows' is null, sets corresponding row in
+  /// 'result' to null.
+  /// @param columnHasNulls indicates whether the 'col' column contains null
+  /// values. If 'columnHasNulls' is false, a null-free optimization will be
+  /// applied. It is the caller's responsibility to ensure this flag is set
+  /// correctly.
   static void extractColumn(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       int32_t numRows,
       RowColumn col,
+      bool columnHasNulls,
       const VectorPtr& result) {
-    extractColumn(rows, numRows, col, 0, result);
+    extractColumn(rows, numRows, col, columnHasNulls, 0, result);
   }
 
   /// Copies the values from the array pointed to by 'rows' at 'col' into
   /// 'result' (starting at 'resultOffset') for the rows at positions in
-  /// the 'rowNumbers' array. If a 'row' is null, sets
-  /// corresponding row in 'result' to null. The positions in 'rowNumbers'
-  /// array can repeat and also appear out of order. If rowNumbers has a
-  /// negative value, then the corresponding row in 'result' is set to null.
+  /// the 'rowNumbers' array. If a 'row' is null, sets corresponding row in
+  /// 'result' to null. The positions in 'rowNumbers' array can repeat and also
+  /// appear out of order. If rowNumbers has a negative value, then the
+  /// corresponding row in 'result' is set to null.
+  /// @param columnHasNulls indicates whether the 'col' column contains null
+  /// values. If 'columnHasNulls' is false, a null-free optimization will be
+  /// applied. It is the caller's responsibility to ensure this flag is set
+  /// correctly.
   static void extractColumn(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       folly::Range<const vector_size_t*> rowNumbers,
       RowColumn col,
+      bool columnHasNulls,
       vector_size_t resultOffset,
       const VectorPtr& result);
 
-  /// Sets in result all locations with null values in col for rows
-  /// (for numRows number of rows).
+  /// Sets in result all locations with null values in col for rows (for numRows
+  /// number of rows).
   static void extractNulls(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       int32_t numRows,
       RowColumn col,
       const BufferPtr& result);
 
-  // Copies the values at 'columnIndex' into 'result' for the
-  // 'numRows' rows pointed to by 'rows'. If an entry in 'rows' is null, sets
-  //  corresponding row in 'result' to null.
+  /// Copies the values at 'columnIndex' into 'result' for the 'numRows' rows
+  /// pointed to by 'rows'. If an entry in 'rows' is null, sets corresponding
+  /// row in 'result' to null.
   void extractColumn(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       int32_t numRows,
       int32_t columnIndex,
       const VectorPtr& result) {
-    extractColumn(rows, numRows, columnAt(columnIndex), result);
+    extractColumn(
+        rows,
+        numRows,
+        columnAt(columnIndex),
+        columnHasNulls(columnIndex),
+        result);
   }
 
   /// Copies the values at 'columnIndex' into 'result' (starting at
   /// 'resultOffset') for the 'numRows' rows pointed to by 'rows'. If an
   /// entry in 'rows' is null, sets corresponding row in 'result' to null.
   void extractColumn(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       int32_t numRows,
       int32_t columnIndex,
       int32_t resultOffset,
       const VectorPtr& result) {
-    extractColumn(rows, numRows, columnAt(columnIndex), resultOffset, result);
+    extractColumn(
+        rows,
+        numRows,
+        columnAt(columnIndex),
+        columnHasNulls(columnIndex),
+        resultOffset,
+        result);
   }
 
   /// Copies the values at 'columnIndex' at positions in the 'rowNumbers' array
@@ -362,18 +432,23 @@ class RowContainer {
   /// has a negative value, then the corresponding row in 'result' is set to
   /// null.
   void extractColumn(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       folly::Range<const vector_size_t*> rowNumbers,
       int32_t columnIndex,
       const vector_size_t resultOffset,
       const VectorPtr& result) {
     extractColumn(
-        rows, rowNumbers, columnAt(columnIndex), resultOffset, result);
+        rows,
+        rowNumbers,
+        columnAt(columnIndex),
+        columnHasNulls(columnIndex),
+        resultOffset,
+        result);
   }
 
   /// Sets in result all locations with null values in columnIndex for rows.
   void extractNulls(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       int32_t numRows,
       int32_t columnIndex,
       const BufferPtr& result) {
@@ -387,7 +462,7 @@ class RowContainer {
   /// in 'result' if 'setNullForNonProbedRow' is true and false otherwise. This
   /// is used for null aware and regular right semi project join types.
   void extractProbedFlags(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       int32_t numRows,
       bool setNullForNullKeysRow,
       bool setNullForNonProbedRow,
@@ -401,8 +476,24 @@ class RowContainer {
     return 1 << (nullOffset & 7);
   }
 
-  // No tsan because probed flags may have been set by a different
-  // thread. There is a barrier but tsan does not know this.
+  /// Only accumulators have initialized flags. accumulatorFlagsOffset is the
+  /// offset at which the flags for an accumulator begin. Currently this is the
+  /// null flag, followed by the initialized flag. So it's equivalent to the
+  /// nullOffset.
+  ///
+  /// It's guaranteed that the flags for an accumulator appear in the same byte.
+  static inline int32_t initializedByte(int32_t accumulatorFlagsOffset) {
+    return nullByte(accumulatorFlagsOffset);
+  }
+
+  /// accumulatorFlagsOffset is the offset at which the flags for an accumulator
+  /// begin.
+  static inline int32_t initializedMask(int32_t accumulatorFlagsOffset) {
+    return nullMask(accumulatorFlagsOffset) << 1;
+  }
+
+  /// No tsan because probed flags may have been set by a different thread.
+  /// There is a barrier but tsan does not know this.
   enum class ProbeType { kAll, kProbed, kNotProbed };
 
   template <ProbeType probeType>
@@ -413,10 +504,10 @@ class RowContainer {
 #endif
   int32_t
   listRows(
-      RowContainerIterator* FOLLY_NONNULL iter,
+      RowContainerIterator* iter,
       int32_t maxRows,
       uint64_t maxBytes,
-      char* FOLLY_NONNULL* FOLLY_NONNULL rows) {
+      char** rows) {
     int32_t count = 0;
     uint64_t totalBytes = 0;
     auto numAllocations = rows_.numRanges();
@@ -476,23 +567,19 @@ class RowContainer {
     return count;
   }
 
-  // Extracts up to 'maxRows' rows starting at the position of
-  // 'iter'. A default constructed or reset iter starts at the
-  // beginning. Returns the number of rows written to 'rows'. Returns
-  // 0 when at end. Stops after the total size of returned rows exceeds
-  // maxBytes.
+  /// Extracts up to 'maxRows' rows starting at the position of 'iter'. A
+  /// default constructed or reset iter starts at the beginning. Returns the
+  /// number of rows written to 'rows'. Returns 0 when at end. Stops after the
+  /// total size of returned rows exceeds maxBytes.
   int32_t listRows(
-      RowContainerIterator* FOLLY_NONNULL iter,
+      RowContainerIterator* iter,
       int32_t maxRows,
       uint64_t maxBytes,
-      char* FOLLY_NONNULL* FOLLY_NONNULL rows) {
+      char** rows) {
     return listRows<ProbeType::kAll>(iter, maxRows, maxBytes, rows);
   }
 
-  int32_t listRows(
-      RowContainerIterator* FOLLY_NONNULL iter,
-      int32_t maxRows,
-      char* FOLLY_NONNULL* FOLLY_NONNULL rows) {
+  int32_t listRows(RowContainerIterator* iter, int32_t maxRows, char** rows) {
     return listRows<ProbeType::kAll>(iter, maxRows, kUnlimited, rows);
   }
 
@@ -510,50 +597,48 @@ class RowContainer {
 #endif
 #endif
   void
-  setProbedFlag(char* FOLLY_NONNULL* FOLLY_NONNULL rows, int32_t numRows);
+  setProbedFlag(char** rows, int32_t numRows);
 
-  // Returns true if 'row' at 'column' equals the value at 'index' in
-  // 'decoded'. 'mayHaveNulls' specifies if nulls need to be checked. This is
-  // a fast path for compare().
+  /// Returns true if 'row' at 'column' equals the value at 'index' in
+  /// 'decoded'. 'mayHaveNulls' specifies if nulls need to be checked. This is a
+  /// fast path for compare().
   template <bool mayHaveNulls>
   bool equals(
-      const char* FOLLY_NONNULL row,
+      const char* row,
       RowColumn column,
       const DecodedVector& decoded,
       vector_size_t index);
 
-  // Compares the value at 'column' in 'row' with the value at 'index'
-  // in 'decoded'. Returns 0 for equal, < 0 for 'row' < 'decoded', > 0
-  // otherwise.
+  /// Compares the value at 'column' in 'row' with the value at 'index' in
+  /// 'decoded'. Returns 0 for equal, < 0 for 'row' < 'decoded', > 0 otherwise.
   int32_t compare(
-      const char* FOLLY_NONNULL row,
+      const char* row,
       RowColumn column,
       const DecodedVector& decoded,
       vector_size_t index,
       CompareFlags flags = CompareFlags());
 
-  // Compares the value at 'columnIndex' between 'left' and 'right'. Returns
-  // 0 for equal, < 0 for left < right, > 0 otherwise.
+  /// Compares the value at 'columnIndex' between 'left' and 'right'. Returns
+  /// 0 for equal, < 0 for left < right, > 0 otherwise.
   int32_t compare(
-      const char* FOLLY_NONNULL left,
-      const char* FOLLY_NONNULL right,
+      const char* left,
+      const char* right,
       int32_t columnIndex,
       CompareFlags flags = CompareFlags());
 
-  // Compares the value between 'left' at 'leftIndex' and 'right' and
-  // 'rightIndex'. Returns 0 for equal, < 0 for left < right, > 0 otherwise.
-  // Both columns should have the same type.
+  /// Compares the value between 'left' at 'leftIndex' and 'right' and
+  /// 'rightIndex'. Returns 0 for equal, < 0 for left < right, > 0 otherwise.
+  /// Both columns should have the same type.
   int32_t compare(
-      const char* FOLLY_NONNULL left,
-      const char* FOLLY_NONNULL right,
+      const char* left,
+      const char* right,
       int leftColumnIndex,
       int rightColumnIndex,
       CompareFlags flags = CompareFlags());
 
-  // Allows get/set of the normalized key. If normalized keys are
-  // used, they are stored in the word immediately below the hash
-  // table row.
-  static inline normalized_key_t& normalizedKey(char* FOLLY_NONNULL group) {
+  /// Allows get/set of the normalized key. If normalized keys are used, they
+  /// are stored in the word immediately below the hash table row.
+  static inline normalized_key_t& normalizedKey(char* group) {
     return reinterpret_cast<normalized_key_t*>(group)[-1];
   }
 
@@ -565,60 +650,78 @@ class RowContainer {
     return rowColumns_[index];
   }
 
-  // Bit offset of the probed flag for a full or right outer join  payload.
-  // 0 if not applicable.
+  /// Returns the size of a string or complex types value stored in the
+  /// specified row and column.
+  int32_t variableSizeAt(const char* row, column_index_t column);
+
+  /// Returns the per row size of a fixed size column.
+  int32_t fixedSizeAt(column_index_t column);
+
+  /// Bit offset of the probed flag for a full or right outer join  payload.
+  /// 0 if not applicable.
   int32_t probedFlagOffset() const {
     return probedFlagOffset_;
   }
 
-  // Returns the offset of a uint32_t row size or 0 if the row has no
-  // variable width fields or accumulators.
+  /// Returns the offset of a uint32_t row size or 0 if the row has no variable
+  /// width fields or accumulators.
   int32_t rowSizeOffset() const {
     return rowSizeOffset_;
   }
 
-  // For a hash join table with possible non-unique entries, the offset of
-  // the pointer to the next row with the same key. 0 if keys are
-  // guaranteed unique, e.g. for a group by or semijoin build.
+  /// For a hash join table with possible non-unique entries, the offset of the
+  /// pointer to the next row with the same key. 0 if keys are guaranteed
+  /// unique, e.g. for a group by or semijoin build.
   int32_t nextOffset() const {
     return nextOffset_;
   }
 
-  // Hashes the values of 'columnIndex' for 'rows'.  If 'mix' is true,
-  // mixes the hash with the existing value in 'result'.
+  /// Creates a next-row-vector if it doesn't exist. Appends the row address to
+  /// the next-row-vector, and store the address of the next-row-vector in the
+  /// 'nextOffset_' slot for all duplicate rows. 'allocator' is provided for the
+  /// duplicate row vector allocations.
+  void
+  appendNextRow(char* current, char* nextRow, HashStringAllocator* allocator);
+
+  NextRowVector*& getNextRowVector(char* row) const {
+    return *reinterpret_cast<NextRowVector**>(row + nextOffset_);
+  }
+
+  /// Hashes the values of 'columnIndex' for 'rows'.  If 'mix' is true, mixes
+  /// the hash with the existing value in 'result'.
   void hash(
       int32_t columnIndex,
       folly::Range<char**> rows,
       bool mix,
-      uint64_t* FOLLY_NONNULL result);
+      uint64_t* result);
 
   uint64_t allocatedBytes() const {
     return rows_.allocatedBytes() + stringAllocator_->retainedSize();
   }
 
-  // Returns the number of fixed size rows that can be allocated
-  // without growing the container and the number of unused bytes of
-  // reserved storage for variable length data.
+  /// Returns the number of fixed size rows that can be allocated without
+  /// growing the container and the number of unused bytes of reserved storage
+  /// for variable length data.
   std::pair<uint64_t, uint64_t> freeSpace() const {
     return std::make_pair<uint64_t, uint64_t>(
         rows_.freeBytes() / fixedRowSize_ + numFreeRows_,
         stringAllocator_->freeSpace());
   }
 
-  // Returns the average size of rows in bytes stored in this container.
+  /// Returns the average size of rows in bytes stored in this container.
   std::optional<int64_t> estimateRowSize() const;
 
-  // Returns a cap on  extra memory that may be needed when adding 'numRows'
-  // and variableLengthBytes of out-of-line variable length data.
+  /// Returns a cap on extra memory that may be needed when adding 'numRows'
+  /// and variableLengthBytes of out-of-line variable length data.
   int64_t sizeIncrement(vector_size_t numRows, int64_t variableLengthBytes)
       const;
 
-  // Resets the state to be as after construction. Frees memory for payload.
+  /// Resets the state to be as after construction. Frees memory for payload.
   void clear();
 
   int32_t compareRows(
-      const char* FOLLY_NONNULL left,
-      const char* FOLLY_NONNULL right,
+      const char* left,
+      const char* right,
       const std::vector<CompareFlags>& flags = {}) {
     VELOX_DCHECK(flags.empty() || flags.size() == keyTypes_.size());
     for (auto i = 0; i < keyTypes_.size(); ++i) {
@@ -631,11 +734,11 @@ class RowContainer {
     return 0;
   }
 
-  memory::MemoryPool* FOLLY_NONNULL pool() const {
+  memory::MemoryPool* pool() const {
     return stringAllocator_->pool();
   }
 
-  // Returns the types of all non-aggregate columns of 'this', keys first.
+  /// Returns the types of all non-aggregate columns of 'this', keys first.
   const auto& columnTypes() const {
     return types_;
   }
@@ -644,6 +747,11 @@ class RowContainer {
     return keyTypes_;
   }
 
+  /// Returns true if specified column may have nulls, false otherwise.
+  inline bool columnHasNulls(int32_t columnIndex) const {
+    return columnHasNulls_[columnIndex];
+  }
+
   const std::vector<Accumulator>& accumulators() const {
     return accumulators_;
   }
@@ -652,15 +760,19 @@ class RowContainer {
     return *stringAllocator_;
   }
 
-  // Checks that row and free row counts match and that free list
-  // membership is consistent with free flag.
+  /// Checks that row and free row counts match and that free list membership is
+  /// consistent with free flag.
   void checkConsistency();
 
   static inline bool
-  isNullAt(const char* FOLLY_NONNULL row, int32_t nullByte, uint8_t nullMask) {
+  isNullAt(const char* row, int32_t nullByte, uint8_t nullMask) {
     return (row[nullByte] & nullMask) != 0;
   }
 
+  static inline bool isNullAt(const char* row, RowColumn rowColumn) {
+    return (row[rowColumn.nullByte()] & rowColumn.nullMask()) != 0;
+  }
+
   /// Creates a container to store a partition number for each row in this row
   /// container. This is used by parallel join build which is responsible for
   /// filling this. This function also marks this row container as immutable
@@ -677,7 +789,7 @@ class RowContainer {
       uint8_t partition,
       int32_t maxRows,
       const RowPartitions& rowPartitions,
-      char* FOLLY_NONNULL* FOLLY_NONNULL result);
+      char** result);
 
   /// Advances 'iterator' by 'numRows'. The current row after skip is
   /// in iter.currentRow(). This is null if past end. Public for testing.
@@ -687,53 +799,89 @@ class RowContainer {
     return mutable_;
   }
 
-  bool checkFree() const {
-    return checkFree_;
-  }
+  /// Returns a summary of the container: key types, dependent types, number of
+  /// accumulators and number of rows.
+  std::string toString() const;
+
+  /// Returns a string representation of the specified row in the same format as
+  /// BaseVector::toString(index).
+  std::string toString(const char* row) const;
 
  private:
   // Offset of the pointer to the next free row on a free row.
   static constexpr int32_t kNextFreeOffset = 0;
 
   template <typename T>
-  static inline T valueAt(const char* FOLLY_NONNULL group, int32_t offset) {
+  static inline T valueAt(const char* group, int32_t offset) {
     return *reinterpret_cast<const T*>(group + offset);
   }
 
   template <typename T>
-  static inline T& valueAt(char* FOLLY_NONNULL group, int32_t offset) {
+  static inline T& valueAt(char* group, int32_t offset) {
     return *reinterpret_cast<T*>(group + offset);
   }
 
+  // Copies a string or complex type value from the specified row and column
+  // into provided buffer. Stored the size of the data in the first 4 bytes of
+  // the buffer. If the value is null, writes zero into the first 4 bytes of
+  // destination and returns.
+  // @return The number of bytes written to 'destination' including the 4 bytes
+  // of the size.
+  int32_t
+  extractVariableSizeAt(const char* row, column_index_t column, char* output);
+
+  // Copies a string or complex type value from 'data' into the specified row
+  // and column. Expects first 4 bytes in 'data' to contain the size of the
+  // string or complex value.
+  // @return The number of bytes read from 'data': 4 bytes for size + that many
+  // bytes.
+  int32_t
+  storeVariableSizeAt(const char* data, char* row, column_index_t column);
+
   template <TypeKind Kind>
   static void extractColumnTyped(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       folly::Range<const vector_size_t*> rowNumbers,
       int32_t numRows,
       RowColumn column,
+      bool columnHasNulls,
       int32_t resultOffset,
       const VectorPtr& result) {
     if (rowNumbers.size() > 0) {
       extractColumnTypedInternal<true, Kind>(
-          rows, rowNumbers, rowNumbers.size(), column, resultOffset, result);
+          rows,
+          rowNumbers,
+          rowNumbers.size(),
+          column,
+          columnHasNulls,
+          resultOffset,
+          result);
     } else {
       extractColumnTypedInternal<false, Kind>(
-          rows, rowNumbers, numRows, column, resultOffset, result);
+          rows,
+          rowNumbers,
+          numRows,
+          column,
+          columnHasNulls,
+          resultOffset,
+          result);
     }
   }
 
   template <bool useRowNumbers, TypeKind Kind>
   static void extractColumnTypedInternal(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       folly::Range<const vector_size_t*> rowNumbers,
       int32_t numRows,
       RowColumn column,
+      bool columnHasNulls,
       int32_t resultOffset,
       const VectorPtr& result) {
     // Resize the result vector before all copies.
     result->resize(numRows + resultOffset);
 
-    if (Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
+    if constexpr (
+        Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
         Kind == TypeKind::MAP) {
       extractComplexType<useRowNumbers>(
           rows, rowNumbers, numRows, column, resultOffset, result);
@@ -743,7 +891,7 @@ class RowContainer {
     auto* flatResult = result->as<FlatVector<T>>();
     auto nullMask = column.nullMask();
     auto offset = column.offset();
-    if (!nullMask) {
+    if (!nullMask || !columnHasNulls) {
       extractValuesNoNulls<useRowNumbers, T>(
           rows, rowNumbers, numRows, offset, resultOffset, flatResult);
     } else {
@@ -759,12 +907,12 @@ class RowContainer {
     }
   }
 
-  char* FOLLY_NULLABLE& nextFree(char* FOLLY_NONNULL row) {
+  char*& nextFree(char* row) {
     return *reinterpret_cast<char**>(row + kNextFreeOffset);
   }
 
-  uint32_t& variableRowSize(char* FOLLY_NONNULL row) {
-    DCHECK(rowSizeOffset_);
+  uint32_t& variableRowSize(char* row) {
+    VELOX_DCHECK(rowSizeOffset_);
     return *reinterpret_cast<uint32_t*>(row + rowSizeOffset_);
   }
 
@@ -772,22 +920,26 @@ class RowContainer {
   inline void storeWithNulls(
       const DecodedVector& decoded,
       vector_size_t index,
-      char* FOLLY_NONNULL row,
+      bool isKey,
+      char* row,
       int32_t offset,
       int32_t nullByte,
-      uint8_t nullMask) {
+      uint8_t nullMask,
+      int32_t column) {
     using T = typename TypeTraits<Kind>::NativeType;
     if (decoded.isNullAt(index)) {
       row[nullByte] |= nullMask;
       // Do not leave an uninitialized value in the case of a
       // null. This is an error with valgrind/asan.
       *reinterpret_cast<T*>(row + offset) = T();
+      updateColumnHasNulls(column, true);
       return;
     }
-    *reinterpret_cast<T*>(row + offset) = decoded.valueAt<T>(index);
     if constexpr (std::is_same_v<T, StringView>) {
       RowSizeTracker tracker(row[rowSizeOffset_], *stringAllocator_);
-      stringAllocator_->copyMultipart(row, offset);
+      stringAllocator_->copyMultipart(decoded.valueAt<T>(index), row, offset);
+    } else {
+      *reinterpret_cast<T*>(row + offset) = decoded.valueAt<T>(index);
     }
   }
 
@@ -795,33 +947,61 @@ class RowContainer {
   inline void storeNoNulls(
       const DecodedVector& decoded,
       vector_size_t index,
-      char* FOLLY_NONNULL group,
+      bool isKey,
+      char* group,
       int32_t offset) {
     using T = typename TypeTraits<Kind>::NativeType;
-    *reinterpret_cast<T*>(group + offset) = decoded.valueAt<T>(index);
     if constexpr (std::is_same_v<T, StringView>) {
       RowSizeTracker tracker(group[rowSizeOffset_], *stringAllocator_);
-      stringAllocator_->copyMultipart(group, offset);
+      stringAllocator_->copyMultipart(decoded.valueAt<T>(index), group, offset);
+    } else {
+      *reinterpret_cast<T*>(group + offset) = decoded.valueAt<T>(index);
+    }
+  }
+
+  template <TypeKind Kind>
+  inline void storeWithNullsBatch(
+      const DecodedVector& decoded,
+      folly::Range<char**> rows,
+      bool isKey,
+      int32_t offset,
+      int32_t nullByte,
+      uint8_t nullMask,
+      int32_t column) {
+    for (int32_t i = 0; i < rows.size(); ++i) {
+      storeWithNulls<Kind>(
+          decoded, i, isKey, rows[i], offset, nullByte, nullMask, column);
+    }
+  }
+
+  template <TypeKind Kind>
+  inline void storeNoNullsBatch(
+      const DecodedVector& decoded,
+      folly::Range<char**> rows,
+      bool isKey,
+      int32_t offset) {
+    for (int32_t i = 0; i < rows.size(); ++i) {
+      storeNoNulls<Kind>(decoded, i, isKey, rows[i], offset);
     }
   }
 
   template <bool useRowNumbers, typename T>
   static void extractValuesWithNulls(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       folly::Range<const vector_size_t*> rowNumbers,
       int32_t numRows,
       int32_t offset,
       int32_t nullByte,
       uint8_t nullMask,
       int32_t resultOffset,
-      FlatVector<T>* FOLLY_NONNULL result) {
+      FlatVector<T>* result) {
     auto maxRows = numRows + resultOffset;
     VELOX_DCHECK_LE(maxRows, result->size());
 
     BufferPtr& nullBuffer = result->mutableNulls(maxRows);
     auto nulls = nullBuffer->asMutable<uint64_t>();
     BufferPtr valuesBuffer = result->mutableValues(maxRows);
-    auto values = valuesBuffer->asMutableRange<T>();
+    [[maybe_unused]] auto values = valuesBuffer->asMutableRange<T>();
     for (int32_t i = 0; i < numRows; ++i) {
       const char* row;
       if constexpr (useRowNumbers) {
@@ -846,16 +1026,16 @@ class RowContainer {
 
   template <bool useRowNumbers, typename T>
   static void extractValuesNoNulls(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       folly::Range<const vector_size_t*> rowNumbers,
       int32_t numRows,
       int32_t offset,
       int32_t resultOffset,
-      FlatVector<T>* FOLLY_NONNULL result) {
+      FlatVector<T>* result) {
     auto maxRows = numRows + resultOffset;
     VELOX_DCHECK_LE(maxRows, result->size());
     BufferPtr valuesBuffer = result->mutableValues(maxRows);
-    auto values = valuesBuffer->asMutableRange<T>();
+    [[maybe_unused]] auto values = valuesBuffer->asMutableRange<T>();
     for (int32_t i = 0; i < numRows; ++i) {
       const char* row;
       if constexpr (useRowNumbers) {
@@ -878,68 +1058,60 @@ class RowContainer {
     }
   }
 
-  static void prepareRead(
-      const char* FOLLY_NONNULL row,
-      int32_t offset,
-      ByteStream& stream);
+  static std::unique_ptr<ByteInputStream> prepareRead(
+      const char* row,
+      int32_t offset);
 
   template <TypeKind Kind>
   void hashTyped(
-      const Type* FOLLY_NONNULL type,
+      const Type* type,
       RowColumn column,
       bool nullable,
       folly::Range<char**> rows,
       bool mix,
-      uint64_t* FOLLY_NONNULL result);
+      uint64_t* result);
 
   template <TypeKind Kind>
   inline bool equalsWithNulls(
-      const char* FOLLY_NONNULL row,
+      const char* row,
       int32_t offset,
       int32_t nullByte,
       uint8_t nullMask,
       const DecodedVector& decoded,
       vector_size_t index) {
-    using T = typename KindToFlatVector<Kind>::HashRowType;
     bool rowIsNull = isNullAt(row, nullByte, nullMask);
     bool indexIsNull = decoded.isNullAt(index);
     if (rowIsNull || indexIsNull) {
       return rowIsNull == indexIsNull;
     }
-    if (Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
-        Kind == TypeKind::MAP) {
-      return compareComplexType(row, offset, decoded, index) == 0;
-    }
-    if (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
-      return compareStringAsc(
-                 valueAt<StringView>(row, offset), decoded, index) == 0;
-    }
-    return decoded.valueAt<T>(index) == valueAt<T>(row, offset);
+
+    return equalsNoNulls<Kind>(row, offset, decoded, index);
   }
 
   template <TypeKind Kind>
   inline bool equalsNoNulls(
-      const char* FOLLY_NONNULL row,
+      const char* row,
       int32_t offset,
       const DecodedVector& decoded,
       vector_size_t index) {
-    using T = typename KindToFlatVector<Kind>::HashRowType;
-
-    if (Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
+    if constexpr (
+        Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
         Kind == TypeKind::MAP) {
       return compareComplexType(row, offset, decoded, index) == 0;
     }
-    if (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    if constexpr (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
       return compareStringAsc(
                  valueAt<StringView>(row, offset), decoded, index) == 0;
     }
 
-    return decoded.valueAt<T>(index) == valueAt<T>(row, offset);
+    using T = typename KindToFlatVector<Kind>::HashRowType;
+    return SimpleVector<T>::comparePrimitiveAsc(
+               decoded.valueAt<T>(index), valueAt<T>(row, offset)) == 0;
   }
 
   template <TypeKind Kind>
   inline int compare(
-      const char* FOLLY_NONNULL row,
+      const char* row,
       RowColumn column,
       const DecodedVector& decoded,
       vector_size_t index,
@@ -953,26 +1125,27 @@ class RowContainer {
     if (indexIsNull) {
       return flags.nullsFirst ? 1 : -1;
     }
-    if (Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
+    if constexpr (
+        Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
         Kind == TypeKind::MAP) {
-      return compareComplexType(row, column.offset(), decoded, index);
+      return compareComplexType(row, column.offset(), decoded, index, flags);
     }
-    if (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    if constexpr (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
       auto result = compareStringAsc(
           valueAt<StringView>(row, column.offset()), decoded, index);
       return flags.ascending ? result : result * -1;
     }
     auto left = valueAt<T>(row, column.offset());
     auto right = decoded.valueAt<T>(index);
-    auto result = comparePrimitiveAsc(left, right);
+    auto result = SimpleVector<T>::comparePrimitiveAsc(left, right);
     return flags.ascending ? result : result * -1;
   }
 
   template <TypeKind Kind>
   inline int compare(
-      const char* FOLLY_NONNULL left,
-      const char* FOLLY_NONNULL right,
-      const Type* FOLLY_NONNULL type,
+      const char* left,
+      const char* right,
+      const Type* type,
       RowColumn leftColumn,
       RowColumn rightColumn,
       CompareFlags flags) {
@@ -990,12 +1163,13 @@ class RowContainer {
 
     auto leftOffset = leftColumn.offset();
     auto rightOffset = rightColumn.offset();
-    if (Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
+    if constexpr (
+        Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
         Kind == TypeKind::MAP) {
       return compareComplexType(
           left, right, type, leftOffset, rightOffset, flags);
     }
-    if (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    if constexpr (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
       auto leftValue = valueAt<StringView>(left, leftOffset);
       auto rightValue = valueAt<StringView>(right, rightOffset);
       auto result = compareStringAsc(leftValue, rightValue);
@@ -1004,52 +1178,38 @@ class RowContainer {
 
     auto leftValue = valueAt<T>(left, leftOffset);
     auto rightValue = valueAt<T>(right, rightOffset);
-    auto result = comparePrimitiveAsc(leftValue, rightValue);
+    auto result = SimpleVector<T>::comparePrimitiveAsc(leftValue, rightValue);
     return flags.ascending ? result : result * -1;
   }
 
   template <TypeKind Kind>
   inline int compare(
-      const char* FOLLY_NONNULL left,
-      const char* FOLLY_NONNULL right,
-      const Type* FOLLY_NONNULL type,
+      const char* left,
+      const char* right,
+      const Type* type,
       RowColumn column,
       CompareFlags flags) {
     return compare<Kind>(left, right, type, column, column, flags);
   }
 
-  template <typename T>
-  static inline int comparePrimitiveAsc(const T& left, const T& right) {
-    if constexpr (std::is_floating_point<T>::value) {
-      bool isLeftNan = std::isnan(left);
-      bool isRightNan = std::isnan(right);
-      if (isLeftNan) {
-        return isRightNan ? 0 : 1;
-      }
-      if (isRightNan) {
-        return -1;
-      }
-    }
-    return left < right ? -1 : left == right ? 0 : 1;
-  }
-
   void storeComplexType(
       const DecodedVector& decoded,
       vector_size_t index,
-      char* FOLLY_NONNULL row,
+      bool isKey,
+      char* row,
       int32_t offset,
       int32_t nullByte = 0,
-      uint8_t nullMask = 0);
+      uint8_t nullMask = 0,
+      int32_t column = 0);
 
   template <bool useRowNumbers>
   static void extractComplexType(
-      const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+      const char* const* rows,
       folly::Range<const vector_size_t*> rowNumbers,
       int32_t numRows,
       RowColumn column,
       int32_t resultOffset,
       const VectorPtr& result) {
-    ByteStream stream;
     auto nullByte = column.nullByte();
     auto nullMask = column.nullMask();
     auto offset = column.offset();
@@ -1067,15 +1227,15 @@ class RowContainer {
       if (!row || isNullAt(row, nullByte, nullMask)) {
         result->setNull(resultIndex, true);
       } else {
-        prepareRead(row, offset, stream);
-        ContainerRowSerde::deserialize(stream, resultIndex, result.get());
+        auto stream = prepareRead(row, offset);
+        ContainerRowSerde::deserialize(*stream, resultIndex, result.get());
       }
     }
   }
 
   static void extractString(
       StringView value,
-      FlatVector<StringView>* FOLLY_NONNULL values,
+      FlatVector<StringView>* values,
       vector_size_t index);
 
   static int32_t compareStringAsc(
@@ -1086,38 +1246,85 @@ class RowContainer {
   static int32_t compareStringAsc(StringView left, StringView right);
 
   int32_t compareComplexType(
-      const char* FOLLY_NONNULL row,
+      const char* row,
       int32_t offset,
       const DecodedVector& decoded,
       vector_size_t index,
       CompareFlags flags = CompareFlags());
 
   int32_t compareComplexType(
-      const char* FOLLY_NONNULL left,
-      const char* FOLLY_NONNULL right,
-      const Type* FOLLY_NONNULL type,
+      const char* left,
+      const char* right,
+      const Type* type,
       int32_t offset,
       CompareFlags flags);
 
   int32_t compareComplexType(
-      const char* FOLLY_NONNULL left,
-      const char* FOLLY_NONNULL right,
-      const Type* FOLLY_NONNULL type,
+      const char* left,
+      const char* right,
+      const Type* type,
       int32_t leftOffset,
       int32_t rightOffset,
       CompareFlags flags = CompareFlags());
 
-  // Free any variable-width fields associated with the 'rows'.
+  // Free variable-width fields at column `column_index` associated with the
+  // 'rows'. `FieldType` is the type of data representation of the fields in
+  // row, and can be one of StringView(represents VARCHAR) and
+  // std::string_view(represents ARRAY, MAP or ROW).
+  template <typename FieldType>
+  void freeVariableWidthFieldsAtColumn(
+      size_t column_index,
+      folly::Range<char**> rows) {
+    static_assert(
+        std::is_same_v<FieldType, StringView> ||
+        std::is_same_v<FieldType, std::string_view>);
+
+    const auto column = columnAt(column_index);
+    for (auto row : rows) {
+      if (isNullAt(row, column.nullByte(), column.nullMask())) {
+        continue;
+      }
+
+      auto& view = valueAt<FieldType>(row, column.offset());
+      if constexpr (std::is_same_v<FieldType, StringView>) {
+        if (view.isInline()) {
+          continue;
+        }
+      } else {
+        if (view.empty()) {
+          continue;
+        }
+      }
+      stringAllocator_->free(HashStringAllocator::headerOf(view.data()));
+    }
+  }
+
+  // Free any variable-width fields associated with the 'rows' and zero out
+  // complex-typed field in 'rows'.
   void freeVariableWidthFields(folly::Range<char**> rows);
 
   // Free any aggregates associated with the 'rows'.
   void freeAggregates(folly::Range<char**> rows);
 
-  const bool checkFree_ = false;
+  // Free next row vectors associated with the 'rows'.
+  void freeNextRowVectors(folly::Range<char**> rows, bool clear);
+
+  void freeRowsExtraMemory(folly::Range<char**> rows, bool clear);
+
+  // Updates the specific column's columnHasNulls_ flag, if 'hasNulls' is true.
+  // columnHasNulls_ flag is false by default.
+  inline void updateColumnHasNulls(int32_t columnIndex, bool hasNulls) {
+    columnHasNulls_[columnIndex] = columnHasNulls_[columnIndex] || hasNulls;
+  }
 
   const std::vector<TypePtr> keyTypes_;
   const bool nullableKeys_;
   const bool isJoinBuild_;
+  // True if normalized keys are enabled in initial state.
+  const bool hasNormalizedKeys_;
+  const std::unique_ptr<HashStringAllocator> stringAllocator_;
+
+  std::vector<bool> columnHasNulls_;
 
   // Indicates if we can add new row to this row container. It is set to false
   // after user calls 'getRowPartitions()' to create 'rowPartitions' object for
@@ -1132,6 +1339,9 @@ class RowContainer {
   std::vector<TypePtr> types_;
   std::vector<TypeKind> typeKinds_;
   int32_t nextOffset_ = 0;
+  // Indicates if this row container has rows with duplicate keys. This only
+  // applies if 'nextOffset_' is set.
+  tsan_atomic<bool> hasDuplicateRows_{false};
   // Bit position of null bit  in the row. 0 if no null flag. Order is keys,
   // accumulators, dependent.
   std::vector<int32_t> nullOffsets_;
@@ -1149,8 +1359,8 @@ class RowContainer {
   int32_t rowSizeOffset_ = 0;
 
   int32_t fixedRowSize_;
-  // True if normalized keys are enabled in initial state.
-  const bool hasNormalizedKeys_;
+  // How many bytes do the flags (null, probed, free) occupy.
+  int32_t flagBytes_;
   // The count of entries that have an extra normalized_key_t before the
   // start.
   int64_t numRowsWithNormalizedKey_ = 0;
@@ -1165,18 +1375,17 @@ class RowContainer {
   std::vector<uint8_t> initialNulls_;
   uint64_t numRows_ = 0;
   // Head of linked list of free rows.
-  char* FOLLY_NULLABLE firstFreeRow_ = nullptr;
+  char* firstFreeRow_ = nullptr;
   uint64_t numFreeRows_ = 0;
 
   memory::AllocationPool rows_;
-  std::shared_ptr<HashStringAllocator> stringAllocator_;
 
   int alignment_ = 1;
 };
 
 template <>
 inline int128_t RowContainer::valueAt<int128_t>(
-    const char* FOLLY_NONNULL group,
+    const char* group,
     int32_t offset) {
   return HugeInt::deserialize(group + offset);
 }
@@ -1185,100 +1394,120 @@ template <>
 inline void RowContainer::storeWithNulls<TypeKind::ROW>(
     const DecodedVector& decoded,
     vector_size_t index,
-    char* FOLLY_NONNULL row,
+    bool isKey,
+    char* row,
     int32_t offset,
     int32_t nullByte,
-    uint8_t nullMask) {
-  storeComplexType(decoded, index, row, offset, nullByte, nullMask);
+    uint8_t nullMask,
+    int32_t column) {
+  storeComplexType(
+      decoded, index, isKey, row, offset, nullByte, nullMask, column);
 }
 
 template <>
 inline void RowContainer::storeNoNulls<TypeKind::ROW>(
     const DecodedVector& decoded,
     vector_size_t index,
-    char* FOLLY_NONNULL row,
+    bool isKey,
+    char* row,
     int32_t offset) {
-  storeComplexType(decoded, index, row, offset);
+  storeComplexType(decoded, index, isKey, row, offset);
 }
 
 template <>
 inline void RowContainer::storeWithNulls<TypeKind::ARRAY>(
     const DecodedVector& decoded,
     vector_size_t index,
-    char* FOLLY_NONNULL row,
+    bool isKey,
+    char* row,
     int32_t offset,
     int32_t nullByte,
-    uint8_t nullMask) {
-  storeComplexType(decoded, index, row, offset, nullByte, nullMask);
+    uint8_t nullMask,
+    int32_t column) {
+  storeComplexType(
+      decoded, index, isKey, row, offset, nullByte, nullMask, column);
 }
 
 template <>
 inline void RowContainer::storeNoNulls<TypeKind::ARRAY>(
     const DecodedVector& decoded,
     vector_size_t index,
-    char* FOLLY_NONNULL row,
+    bool isKey,
+    char* row,
     int32_t offset) {
-  storeComplexType(decoded, index, row, offset);
+  storeComplexType(decoded, index, isKey, row, offset);
 }
 
 template <>
 inline void RowContainer::storeWithNulls<TypeKind::MAP>(
     const DecodedVector& decoded,
     vector_size_t index,
-    char* FOLLY_NONNULL row,
+    bool isKey,
+    char* row,
     int32_t offset,
     int32_t nullByte,
-    uint8_t nullMask) {
-  storeComplexType(decoded, index, row, offset, nullByte, nullMask);
+    uint8_t nullMask,
+    int32_t column) {
+  storeComplexType(
+      decoded, index, isKey, row, offset, nullByte, nullMask, column);
 }
 
 template <>
 inline void RowContainer::storeNoNulls<TypeKind::MAP>(
     const DecodedVector& decoded,
     vector_size_t index,
-    char* FOLLY_NONNULL row,
+    bool isKey,
+    char* row,
     int32_t offset) {
-  storeComplexType(decoded, index, row, offset);
+  storeComplexType(decoded, index, isKey, row, offset);
 }
 
 template <>
 inline void RowContainer::storeWithNulls<TypeKind::HUGEINT>(
     const DecodedVector& decoded,
     vector_size_t index,
-    char* FOLLY_NONNULL row,
+    bool /*isKey*/,
+    char* row,
     int32_t offset,
     int32_t nullByte,
-    uint8_t nullMask) {
-  HugeInt::serialize(decoded.valueAt<int128_t>(index), row + offset);
+    uint8_t nullMask,
+    int32_t column) {
   if (decoded.isNullAt(index)) {
     row[nullByte] |= nullMask;
+    memset(row + offset, 0, sizeof(int128_t));
+    updateColumnHasNulls(column, true);
+    return;
   }
+  HugeInt::serialize(decoded.valueAt<int128_t>(index), row + offset);
 }
 
 template <>
 inline void RowContainer::storeNoNulls<TypeKind::HUGEINT>(
     const DecodedVector& decoded,
     vector_size_t index,
-    char* FOLLY_NONNULL row,
+    bool /*isKey*/,
+    char* row,
     int32_t offset) {
   HugeInt::serialize(decoded.valueAt<int128_t>(index), row + offset);
 }
 
 template <>
 inline void RowContainer::extractColumnTyped<TypeKind::OPAQUE>(
-    const char* FOLLY_NONNULL const* FOLLY_NONNULL /*rows*/,
+    const char* const* /*rows*/,
     folly::Range<const vector_size_t*> /*rowNumbers*/,
     int32_t /*numRows*/,
     RowColumn /*column*/,
+    bool /*columnHasNulls*/,
     int32_t /*resultOffset*/,
     const VectorPtr& /*result*/) {
   VELOX_UNSUPPORTED("RowContainer doesn't support values of type OPAQUE");
 }
 
 inline void RowContainer::extractColumn(
-    const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+    const char* const* rows,
     int32_t numRows,
     RowColumn column,
+    bool columnHasNulls,
     int32_t resultOffset,
     const VectorPtr& result) {
   VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
@@ -1288,14 +1517,16 @@ inline void RowContainer::extractColumn(
       {},
       numRows,
       column,
+      columnHasNulls,
       resultOffset,
       result);
 }
 
 inline void RowContainer::extractColumn(
-    const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+    const char* const* rows,
     folly::Range<const vector_size_t*> rowNumbers,
     RowColumn column,
+    bool columnHasNulls,
     int32_t resultOffset,
     const VectorPtr& result) {
   VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
@@ -1305,12 +1536,13 @@ inline void RowContainer::extractColumn(
       rowNumbers,
       rowNumbers.size(),
       column,
+      columnHasNulls,
       resultOffset,
       result);
 }
 
 inline void RowContainer::extractNulls(
-    const char* FOLLY_NONNULL const* FOLLY_NONNULL rows,
+    const char* const* rows,
     int32_t numRows,
     RowColumn column,
     const BufferPtr& result) {
@@ -1334,7 +1566,7 @@ inline void RowContainer::extractNulls(
 
 template <bool mayHaveNulls>
 inline bool RowContainer::equals(
-    const char* FOLLY_NONNULL row,
+    const char* row,
     RowColumn column,
     const DecodedVector& decoded,
     vector_size_t index) {
@@ -1361,7 +1593,7 @@ inline bool RowContainer::equals(
 
 template <>
 inline int RowContainer::compare<TypeKind::OPAQUE>(
-    const char* FOLLY_NONNULL /*row*/,
+    const char* /*row*/,
     RowColumn /*column*/,
     const DecodedVector& /*decoded*/,
     vector_size_t /*index*/,
@@ -1371,9 +1603,9 @@ inline int RowContainer::compare<TypeKind::OPAQUE>(
 
 template <>
 inline int RowContainer::compare<TypeKind::OPAQUE>(
-    const char* FOLLY_NONNULL /*left*/,
-    const char* FOLLY_NONNULL /*right*/,
-    const Type* FOLLY_NONNULL /*type*/,
+    const char* /*left*/,
+    const char* /*right*/,
+    const Type* /*type*/,
     RowColumn /*leftColumn*/,
     RowColumn /*rightColumn*/,
     CompareFlags /*flags*/) {
@@ -1381,7 +1613,7 @@ inline int RowContainer::compare<TypeKind::OPAQUE>(
 }
 
 inline int RowContainer::compare(
-    const char* FOLLY_NONNULL row,
+    const char* row,
     RowColumn column,
     const DecodedVector& decoded,
     vector_size_t index,
@@ -1391,8 +1623,8 @@ inline int RowContainer::compare(
 }
 
 inline int RowContainer::compare(
-    const char* FOLLY_NONNULL left,
-    const char* FOLLY_NONNULL right,
+    const char* left,
+    const char* right,
     int columnIndex,
     CompareFlags flags) {
   auto type = types_[columnIndex].get();
@@ -1401,8 +1633,8 @@ inline int RowContainer::compare(
 }
 
 inline int RowContainer::compare(
-    const char* FOLLY_NONNULL left,
-    const char* FOLLY_NONNULL right,
+    const char* left,
+    const char* right,
     int leftColumnIndex,
     int rightColumnIndex,
     CompareFlags flags) {
diff --git a/velox/exec/RowNumber.cpp b/velox/exec/RowNumber.cpp
index f6da535982d9d..2a46346508961 100644
--- a/velox/exec/RowNumber.cpp
+++ b/velox/exec/RowNumber.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 #include "velox/exec/RowNumber.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/exec/OperatorUtils.h"
 
 namespace facebook::velox::exec {
 
@@ -26,7 +28,10 @@ RowNumber::RowNumber(
           rowNumberNode->outputType(),
           operatorId,
           rowNumberNode->id(),
-          "RowNumber"),
+          "RowNumber",
+          rowNumberNode->canSpill(driverCtx->queryConfig())
+              ? driverCtx->makeSpillConfig(operatorId)
+              : std::nullopt),
       limit_{rowNumberNode->limit()},
       generateRowNumber_{rowNumberNode->generateRowNumber()} {
   const auto& inputType = rowNumberNode->sources()[0]->outputType();
@@ -47,6 +52,8 @@ RowNumber::RowNumber(
 
     const auto numRowsColumn = table_->rows()->columnAt(numKeys);
     numRowsOffset_ = numRowsColumn.offset();
+
+    inputType_ = rowNumberNode->sources()[0]->outputType();
   }
 
   identityProjections_.reserve(inputType->size());
@@ -58,15 +65,27 @@ RowNumber::RowNumber(
     resultProjections_.emplace_back(0, inputType->size());
     results_.resize(1);
   }
+
+  if (spillEnabled()) {
+    setSpillPartitionBits();
+  }
 }
 
 void RowNumber::addInput(RowVectorPtr input) {
   const auto numInput = input->size();
 
   if (table_) {
+    ensureInputFits(input);
+
+    if (inputSpiller_ != nullptr) {
+      spillInput(input, pool());
+      return;
+    }
+
     SelectivityVector rows(numInput);
-    table_->prepareForProbe(*lookup_, input, rows, false);
-    table_->groupProbe(*lookup_);
+    table_->prepareForGroupProbe(
+        *lookup_, input, rows, BaseHashTable::kNoSpillInputStartPartitionBit);
+    table_->groupProbe(*lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
 
     // Initialize new partitions with zeros.
     for (auto i : lookup_->newGroups) {
@@ -77,6 +96,162 @@ void RowNumber::addInput(RowVectorPtr input) {
   input_ = std::move(input);
 }
 
+void RowNumber::addSpillInput() {
+  VELOX_CHECK_NOT_NULL(input_);
+  ensureInputFits(input_);
+  if (input_ == nullptr) {
+    // Memory arbitration might be triggered by ensureInputFits() which will
+    // spill 'input_'.
+    return;
+  }
+
+  const auto numInput = input_->size();
+  SelectivityVector rows(numInput);
+
+  VELOX_CHECK(spillConfig_.has_value());
+  table_->prepareForGroupProbe(
+      *lookup_, input_, rows, spillConfig_->startPartitionBit);
+  table_->groupProbe(*lookup_, spillConfig_->startPartitionBit);
+
+  // Initialize new partitions with zeros.
+  for (auto i : lookup_->newGroups) {
+    setNumRows(lookup_->hits[i], 0);
+  }
+}
+
+void RowNumber::noMoreInput() {
+  Operator::noMoreInput();
+
+  if (inputSpiller_ != nullptr) {
+    inputSpiller_->finishSpill(spillInputPartitionSet_);
+    removeEmptyPartitions(spillInputPartitionSet_);
+    restoreNextSpillPartition();
+  }
+}
+
+void RowNumber::restoreNextSpillPartition() {
+  if (spillInputPartitionSet_.empty()) {
+    return;
+  }
+
+  auto it = spillInputPartitionSet_.begin();
+  spillInputReader_ = it->second->createUnorderedReader(
+      spillConfig_->readBufferSize, pool(), &spillStats_);
+
+  // Find matching partition for the hash table.
+  auto hashTableIt = spillHashTablePartitionSet_.find(it->first);
+  if (hashTableIt != spillHashTablePartitionSet_.end()) {
+    spillHashTableReader_ = hashTableIt->second->createUnorderedReader(
+        spillConfig_->readBufferSize, pool(), &spillStats_);
+
+    setSpillPartitionBits(&(it->first));
+
+    RowVectorPtr data;
+    while (spillHashTableReader_->nextBatch(data)) {
+      // 'data' contains partition-by keys and count. Transform 'data' to match
+      // 'inputType_' so it can be added to the 'table_'. Move partition-by
+      // columns and leave other columns unset.
+      std::vector<VectorPtr> columns(inputType_->size());
+
+      const auto& hashers = table_->hashers();
+      for (auto i = 0; i < hashers.size(); ++i) {
+        columns[hashers[i]->channel()] = data->childAt(i);
+      }
+
+      auto input = std::make_shared<RowVector>(
+          pool(), inputType_, nullptr, data->size(), std::move(columns));
+
+      const auto numInput = input->size();
+      SelectivityVector rows(numInput);
+      table_->prepareForGroupProbe(
+          *lookup_, input, rows, spillConfig_->startPartitionBit);
+      table_->groupProbe(*lookup_, spillConfig_->startPartitionBit);
+
+      auto* counts = data->children().back()->as<FlatVector<int64_t>>();
+
+      for (auto i = 0; i < numInput; ++i) {
+        auto* partition = lookup_->hits[i];
+        setNumRows(partition, counts->valueAt(i));
+      }
+    }
+  }
+
+  spillInputPartitionSet_.erase(it);
+
+  spillInputReader_->nextBatch(input_);
+  VELOX_CHECK_NOT_NULL(input_);
+  // NOTE: spillInputReader_ will at least produce one batch output.
+  addSpillInput();
+}
+
+void RowNumber::ensureInputFits(const RowVectorPtr& input) {
+  if (!spillEnabled()) {
+    // Spilling is disabled.
+    return;
+  }
+
+  if (table_ == nullptr) {
+    // No hash table. Nothing to spill.
+    return;
+  }
+
+  const auto numDistinct = table_->numDistinct();
+  if (numDistinct == 0) {
+    // Table is empty. Nothing to spill.
+    return;
+  }
+
+  auto* rows = table_->rows();
+  auto [freeRows, outOfLineFreeBytes] = rows->freeSpace();
+  const auto outOfLineBytes =
+      rows->stringAllocator().retainedSize() - outOfLineFreeBytes;
+  const auto outOfLineBytesPerRow = outOfLineBytes / numDistinct;
+
+  // Test-only spill path.
+  if (testingTriggerSpill(pool()->name())) {
+    Operator::ReclaimableSectionGuard guard(this);
+    memory::testingRunArbitration(pool());
+    return;
+  }
+
+  const auto currentUsage = pool()->usedBytes();
+  const auto minReservationBytes =
+      currentUsage * spillConfig_->minSpillableReservationPct / 100;
+  const auto availableReservationBytes = pool()->availableReservation();
+  const auto tableIncrementBytes = table_->hashTableSizeIncrease(input->size());
+  const auto incrementBytes =
+      rows->sizeIncrement(input->size(), outOfLineBytesPerRow * input->size()) +
+      tableIncrementBytes;
+
+  // First to check if we have sufficient minimal memory reservation.
+  if (availableReservationBytes >= minReservationBytes) {
+    if ((tableIncrementBytes == 0) && (freeRows > input->size()) &&
+        (outOfLineBytes == 0 ||
+         outOfLineFreeBytes >= outOfLineBytesPerRow * input->size())) {
+      // Enough free rows for input rows and enough variable length free space.
+      return;
+    }
+  }
+
+  // Check if we can increase reservation. The increment is the largest of twice
+  // the maximum increment from this input and 'spillableReservationGrowthPct_'
+  // of the current memory usage.
+  const auto targetIncrementBytes = std::max<int64_t>(
+      incrementBytes * 2,
+      currentUsage * spillConfig_->spillableReservationGrowthPct / 100);
+  {
+    Operator::ReclaimableSectionGuard guard(this);
+    if (pool()->maybeReserve(targetIncrementBytes)) {
+      return;
+    }
+  }
+
+  LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
+               << " for memory pool " << pool()->name()
+               << ", usage: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+}
+
 FlatVector<int64_t>& RowNumber::getOrCreateRowNumberVector(vector_size_t size) {
   VectorPtr& result = results_[0];
   if (result && result.unique()) {
@@ -89,7 +264,19 @@ FlatVector<int64_t>& RowNumber::getOrCreateRowNumberVector(vector_size_t size) {
 
 RowVectorPtr RowNumber::getOutput() {
   if (input_ == nullptr) {
-    return nullptr;
+    if (spillInputReader_ == nullptr) {
+      return nullptr;
+    }
+
+    recursiveSpillInput();
+    if (yield_) {
+      yield_ = false;
+      return nullptr;
+    }
+
+    if (input_ == nullptr) {
+      return nullptr;
+    }
   }
 
   if (!table_) {
@@ -143,7 +330,19 @@ RowVectorPtr RowNumber::getOutput() {
     output = fillOutput(numInput, nullptr);
   }
 
-  input_ = nullptr;
+  if (spillInputReader_ != nullptr) {
+    if (spillInputReader_->nextBatch(input_)) {
+      addSpillInput();
+    } else {
+      input_ = nullptr;
+      spillInputReader_ = nullptr;
+      table_->clear();
+      restoreNextSpillPartition();
+    }
+  } else {
+    input_ = nullptr;
+  }
+
   return output;
 }
 
@@ -182,4 +381,170 @@ int64_t RowNumber::numRows(char* partition) {
 void RowNumber::setNumRows(char* partition, int64_t numRows) {
   *reinterpret_cast<int64_t*>(partition + numRowsOffset_) = numRows;
 }
+
+void RowNumber::reclaim(
+    uint64_t /*targetBytes*/,
+    memory::MemoryReclaimer::Stats& stats) {
+  VELOX_CHECK(canReclaim());
+  VELOX_CHECK(!nonReclaimableSection_);
+
+  if (table_ == nullptr || table_->numDistinct() == 0) {
+    // Nothing to spill.
+    return;
+  }
+
+  if (exceededMaxSpillLevelLimit_) {
+    LOG(WARNING) << "Exceeded row spill level limit: "
+                 << spillConfig_->maxSpillLevel
+                 << ", and abandon spilling for memory pool: "
+                 << pool()->name();
+    ++spillStats_.wlock()->spillMaxLevelExceededCount;
+    return;
+  }
+
+  spill();
+}
+
+SpillPartitionNumSet RowNumber::spillHashTable() {
+  // TODO Replace joinPartitionBits and Spiller::Type::kHashJoinBuild.
+  VELOX_CHECK_NOT_NULL(table_);
+
+  auto columnTypes = table_->rows()->columnTypes();
+  auto tableType = ROW(std::move(columnTypes));
+  const auto& spillConfig = spillConfig_.value();
+
+  auto hashTableSpiller = std::make_unique<Spiller>(
+      Spiller::Type::kRowNumber,
+      table_->rows(),
+      tableType,
+      spillPartitionBits_,
+      &spillConfig,
+      &spillStats_);
+
+  hashTableSpiller->spill();
+  hashTableSpiller->finishSpill(spillHashTablePartitionSet_);
+
+  table_->clear();
+  pool()->release();
+  return hashTableSpiller->state().spilledPartitionSet();
+}
+
+void RowNumber::setupInputSpiller(
+    const SpillPartitionNumSet& spillPartitionSet) {
+  VELOX_CHECK(!spillPartitionSet.empty());
+
+  const auto& spillConfig = spillConfig_.value();
+
+  // TODO Replace Spiller::Type::kHashJoinProbe.
+  inputSpiller_ = std::make_unique<Spiller>(
+      Spiller::Type::kHashJoinProbe,
+      inputType_,
+      spillPartitionBits_,
+      &spillConfig,
+      &spillStats_);
+  inputSpiller_->setPartitionsSpilled(spillPartitionSet);
+
+  const auto& hashers = table_->hashers();
+
+  std::vector<column_index_t> keyChannels;
+  keyChannels.reserve(hashers.size());
+  for (const auto& hasher : hashers) {
+    keyChannels.push_back(hasher->channel());
+  }
+
+  spillHashFunction_ = std::make_unique<HashPartitionFunction>(
+      inputSpiller_->hashBits(), inputType_, keyChannels);
+}
+
+void RowNumber::spill() {
+  VELOX_CHECK(spillEnabled());
+
+  const auto spillPartitionSet = spillHashTable();
+  VELOX_CHECK_EQ(table_->numDistinct(), 0);
+
+  setupInputSpiller(spillPartitionSet);
+  if (input_ != nullptr) {
+    spillInput(input_, memory::spillMemoryPool());
+    input_ = nullptr;
+  }
+}
+
+void RowNumber::spillInput(
+    const RowVectorPtr& input,
+    memory::MemoryPool* pool) {
+  const auto numInput = input->size();
+
+  std::vector<uint32_t> spillPartitions(numInput);
+  const auto singlePartition =
+      spillHashFunction_->partition(*input, spillPartitions);
+
+  const auto numPartitions = spillHashFunction_->numPartitions();
+
+  std::vector<BufferPtr> partitionIndices(numPartitions);
+  std::vector<vector_size_t*> rawPartitionIndices(numPartitions);
+
+  for (auto i = 0; i < numPartitions; ++i) {
+    partitionIndices[i] = allocateIndices(numInput, pool);
+    rawPartitionIndices[i] = partitionIndices[i]->asMutable<vector_size_t>();
+  }
+
+  std::vector<vector_size_t> numSpillInputs(numPartitions, 0);
+
+  for (auto row = 0; row < numInput; ++row) {
+    const auto partition = singlePartition.has_value() ? singlePartition.value()
+                                                       : spillPartitions[row];
+    rawPartitionIndices[partition][numSpillInputs[partition]++] = row;
+  }
+
+  // Ensure vector are lazy loaded before spilling.
+  for (auto i = 0; i < input->childrenSize(); ++i) {
+    input->childAt(i)->loadedVector();
+  }
+
+  for (int32_t partition = 0; partition < numSpillInputs.size(); ++partition) {
+    const auto numInputs = numSpillInputs[partition];
+    if (numInputs == 0) {
+      continue;
+    }
+
+    inputSpiller_->spill(
+        partition, wrap(numInputs, partitionIndices[partition], input));
+  }
+}
+
+void RowNumber::recursiveSpillInput() {
+  RowVectorPtr input;
+  while (spillInputReader_->nextBatch(input)) {
+    spillInput(input, pool());
+
+    if (operatorCtx_->driver()->shouldYield()) {
+      yield_ = true;
+      return;
+    }
+  }
+
+  inputSpiller_->finishSpill(spillInputPartitionSet_);
+  spillInputReader_ = nullptr;
+
+  removeEmptyPartitions(spillInputPartitionSet_);
+  restoreNextSpillPartition();
+}
+
+void RowNumber::setSpillPartitionBits(
+    const SpillPartitionId* restoredPartitionId) {
+  const auto startPartitionBitOffset = restoredPartitionId == nullptr
+      ? spillConfig_->startPartitionBit
+      : restoredPartitionId->partitionBitOffset() +
+          spillConfig_->numPartitionBits;
+  if (spillConfig_->exceedSpillLevelLimit(startPartitionBitOffset)) {
+    exceededMaxSpillLevelLimit_ = true;
+    return;
+  }
+
+  exceededMaxSpillLevelLimit_ = false;
+  spillPartitionBits_ = HashBitRange(
+      startPartitionBitOffset,
+      startPartitionBitOffset + spillConfig_->numPartitionBits);
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/RowNumber.h b/velox/exec/RowNumber.h
index 7ecf963b69cfd..4db7d3ca82fdd 100644
--- a/velox/exec/RowNumber.h
+++ b/velox/exec/RowNumber.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/exec/HashPartitionFunction.h"
 #include "velox/exec/HashTable.h"
 #include "velox/exec/Operator.h"
 
@@ -29,6 +30,8 @@ class RowNumber : public Operator {
 
   void addInput(RowVectorPtr input) override;
 
+  void noMoreInput() override;
+
   RowVectorPtr getOutput() override;
 
   bool needsInput() const override {
@@ -40,10 +43,33 @@ class RowNumber : public Operator {
   }
 
   bool isFinished() override {
-    return (noMoreInput_ && input_ == nullptr) || finishedEarly_;
+    return (noMoreInput_ && input_ == nullptr &&
+            spillInputReader_ == nullptr) ||
+        finishedEarly_;
   }
 
+  void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
+      override;
+
  private:
+  bool spillEnabled() const {
+    return spillConfig_.has_value();
+  }
+
+  void setupInputSpiller(const SpillPartitionNumSet& spillPartitionSet);
+
+  void ensureInputFits(const RowVectorPtr& input);
+
+  void spillInput(const RowVectorPtr& input, memory::MemoryPool* pool);
+
+  void spill();
+
+  void addSpillInput();
+
+  void restoreNextSpillPartition();
+
+  SpillPartitionNumSet spillHashTable();
+
   int64_t numRows(char* partition);
 
   void setNumRows(char* partition, int64_t numRows);
@@ -52,22 +78,67 @@ class RowNumber : public Operator {
 
   FlatVector<int64_t>& getOrCreateRowNumberVector(vector_size_t size);
 
+  // Used by recursive spill processing to read the spilled input data from the
+  // previous spill run through 'spillInputReader_' and then spill them back
+  // into a number of sub-partitions. After that, the function restores one of
+  // the newly spilled partitions and resets 'spillInputReader_' accordingly.
+  void recursiveSpillInput();
+
+  // Set 'spillPartitionBits_' for (recursive) spill. If 'restoredPartitionId'
+  // is not null, use it to set 'spillPartitionBits_', otherwise use
+  // 'spillConfig_'. If the new 'spillPartitionBits_' exceeds the
+  // 'maxSpillLevel', set 'exceededMaxSpillLevelLimit_' to true.
+  //
+  // NOTE: we don't increment 'spillMaxLevelExceededCount' here, as the actual
+  // increment happens in the 'reclaim()' method if
+  // 'exceededMaxSpillLevelLimit_' is true.
+  void setSpillPartitionBits(
+      const SpillPartitionId* restoredPartitionId = nullptr);
+
   const std::optional<int32_t> limit_;
   const bool generateRowNumber_;
 
-  /// Hash table to store number of rows seen so far per partition. Not used if
-  /// there are no partitioning keys.
+  // Hash table to store number of rows seen so far per partition. Not used if
+  // there are no partitioning keys.
   std::unique_ptr<BaseHashTable> table_;
   std::unique_ptr<HashLookup> lookup_;
   int32_t numRowsOffset_;
 
-  /// Total number of input rows. Used when there are no partitioning keys and
-  /// therefore no hash table.
+  // Total number of input rows. Used when there are no partitioning keys and
+  // therefore no hash table.
   int64_t numTotalInput_{0};
 
-  /// Boolean indicating that the operator finished processing before seeing all
-  /// the input. This happens when there are no partitioning keys and the
-  /// operator already received 'limit_' rows.
+  // Boolean indicating that the operator finished processing before seeing all
+  // the input. This happens when there are no partitioning keys and the
+  // operator already received 'limit_' rows.
   bool finishedEarly_{false};
+
+  RowTypePtr inputType_;
+
+  // The spill partition bits used by both hash table content spill and input
+  // data spill.
+  HashBitRange spillPartitionBits_;
+
+  // Used to restore previously spilled hash table.
+  std::unique_ptr<UnorderedStreamReader<BatchStream>> spillHashTableReader_;
+
+  SpillPartitionSet spillHashTablePartitionSet_;
+
+  // Spiller for input received after spilling has been triggered.
+  std::unique_ptr<Spiller> inputSpiller_;
+
+  // Used to restore previously spilled input.
+  std::unique_ptr<UnorderedStreamReader<BatchStream>> spillInputReader_;
+
+  SpillPartitionSet spillInputPartitionSet_;
+
+  // Used to calculate the spill partition numbers of the inputs.
+  std::unique_ptr<HashPartitionFunction> spillHashFunction_;
+
+  // The cpu may be voluntarily yield after running too long when processing
+  // input from spilled file.
+  bool yield_{false};
+
+  bool exceededMaxSpillLevelLimit_{false};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/RowsStreamingWindowBuild.cpp b/velox/exec/RowsStreamingWindowBuild.cpp
new file mode 100644
index 0000000000000..8c72e0babf932
--- /dev/null
+++ b/velox/exec/RowsStreamingWindowBuild.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/RowsStreamingWindowBuild.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/exec/WindowFunction.h"
+
+namespace facebook::velox::exec {
+
+namespace {
+bool hasRangeFrame(const std::shared_ptr<const core::WindowNode>& windowNode) {
+  for (const auto& function : windowNode->windowFunctions()) {
+    if (function.frame.type == core::WindowNode::WindowType::kRange) {
+      return true;
+    }
+  }
+  return false;
+}
+} // namespace
+
+RowsStreamingWindowBuild::RowsStreamingWindowBuild(
+    const std::shared_ptr<const core::WindowNode>& windowNode,
+    velox::memory::MemoryPool* pool,
+    const common::SpillConfig* spillConfig,
+    tsan_atomic<bool>* nonReclaimableSection)
+    : WindowBuild(windowNode, pool, spillConfig, nonReclaimableSection),
+      hasRangeFrame_(hasRangeFrame(windowNode)) {
+  velox::common::testutil::TestValue::adjust(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      this);
+}
+
+void RowsStreamingWindowBuild::addPartitionInputs(bool finished) {
+  if (inputRows_.empty()) {
+    return;
+  }
+
+  if (windowPartitions_.size() <= inputPartition_) {
+    windowPartitions_.push_back(std::make_shared<WindowPartition>(
+        data_.get(), inversedInputChannels_, sortKeyInfo_));
+  }
+
+  windowPartitions_[inputPartition_]->addRows(inputRows_);
+
+  if (finished) {
+    windowPartitions_[inputPartition_]->setComplete();
+    ++inputPartition_;
+  }
+
+  inputRows_.clear();
+}
+
+void RowsStreamingWindowBuild::addInput(RowVectorPtr input) {
+  for (auto i = 0; i < inputChannels_.size(); ++i) {
+    decodedInputVectors_[i].decode(*input->childAt(inputChannels_[i]));
+  }
+
+  for (auto row = 0; row < input->size(); ++row) {
+    char* newRow = data_->newRow();
+
+    for (auto col = 0; col < input->childrenSize(); ++col) {
+      data_->store(decodedInputVectors_[col], row, newRow, col);
+    }
+
+    if (previousRow_ != nullptr &&
+        compareRowsWithKeys(previousRow_, newRow, partitionKeyInfo_)) {
+      addPartitionInputs(true);
+    }
+
+    if (previousRow_ != nullptr && inputRows_.size() >= numRowsPerOutput_) {
+      // Needs to wait the peer group ready for range frame.
+      if (hasRangeFrame_) {
+        if (compareRowsWithKeys(previousRow_, newRow, sortKeyInfo_)) {
+          addPartitionInputs(false);
+        }
+      } else {
+        addPartitionInputs(false);
+      }
+    }
+
+    inputRows_.push_back(newRow);
+    previousRow_ = newRow;
+  }
+}
+
+void RowsStreamingWindowBuild::noMoreInput() {
+  addPartitionInputs(true);
+}
+
+std::shared_ptr<WindowPartition> RowsStreamingWindowBuild::nextPartition() {
+  VELOX_CHECK(hasNextPartition());
+  return windowPartitions_[++outputPartition_];
+}
+
+bool RowsStreamingWindowBuild::hasNextPartition() {
+  return !windowPartitions_.empty() &&
+      outputPartition_ + 2 <= windowPartitions_.size();
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/RowsStreamingWindowBuild.h b/velox/exec/RowsStreamingWindowBuild.h
new file mode 100644
index 0000000000000..ceb8ada9b6acc
--- /dev/null
+++ b/velox/exec/RowsStreamingWindowBuild.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/WindowBuild.h"
+
+namespace facebook::velox::exec {
+
+/// Unlike PartitionStreamingWindowBuild, RowsStreamingWindowBuild is capable of
+/// processing window functions as rows arrive within a single partition,
+/// without the need to wait for the entirewindow partition to be ready. This
+/// approach can significantly reduce memory usage, especially when a single
+/// partition contains a large amount of data. It is particularly suited for
+/// optimizing rank, dense_rank and row_number functions, as well as aggregate
+/// window functions with a default frame.
+class RowsStreamingWindowBuild : public WindowBuild {
+ public:
+  RowsStreamingWindowBuild(
+      const std::shared_ptr<const core::WindowNode>& windowNode,
+      velox::memory::MemoryPool* pool,
+      const common::SpillConfig* spillConfig,
+      tsan_atomic<bool>* nonReclaimableSection);
+
+  void addInput(RowVectorPtr input) override;
+
+  void spill() override {
+    VELOX_UNREACHABLE();
+  }
+
+  std::optional<common::SpillStats> spilledStats() const override {
+    return std::nullopt;
+  }
+
+  void noMoreInput() override;
+
+  bool hasNextPartition() override;
+
+  std::shared_ptr<WindowPartition> nextPartition() override;
+
+  bool needsInput() override {
+    // No partitions are available or the currentPartition is the last available
+    // one, so can consume input rows.
+    return windowPartitions_.empty() ||
+        outputPartition_ == windowPartitions_.size() - 1;
+  }
+
+ private:
+  // Adds input rows to the current partition, or creates a new partition if it
+  // does not exist.
+  void addPartitionInputs(bool finished);
+
+  // Sets to true if this window node has range frames.
+  const bool hasRangeFrame_;
+
+  // Points to the input rows in the current partition.
+  std::vector<char*> inputRows_;
+
+  // Used to compare rows based on partitionKeys.
+  char* previousRow_ = nullptr;
+
+  // Point to the current output partition if not -1.
+  vector_size_t outputPartition_ = -1;
+
+  // Current input partition that receives inputs.
+  vector_size_t inputPartition_ = 0;
+
+  // Holds all the built window partitions.
+  std::vector<std::shared_ptr<WindowPartition>> windowPartitions_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SetAccumulator.h b/velox/exec/SetAccumulator.h
index 48d81bc2ef664..f17b1fe286f07 100644
--- a/velox/exec/SetAccumulator.h
+++ b/velox/exec/SetAccumulator.h
@@ -34,24 +34,41 @@ template <
     typename Hash = std::hash<T>,
     typename EqualTo = std::equal_to<T>>
 struct SetAccumulator {
-  bool hasNull{false};
-  folly::F14FastSet<T, Hash, EqualTo, AlignedStlAllocator<T, 16>> uniqueValues;
+  std::optional<vector_size_t> nullIndex;
+
+  folly::F14FastMap<
+      T,
+      int32_t,
+      Hash,
+      EqualTo,
+      AlignedStlAllocator<std::pair<const T, vector_size_t>, 16>>
+      uniqueValues;
 
   SetAccumulator(const TypePtr& /*type*/, HashStringAllocator* allocator)
-      : uniqueValues{AlignedStlAllocator<T, 16>(allocator)} {}
+      : uniqueValues{AlignedStlAllocator<std::pair<const T, vector_size_t>, 16>(
+            allocator)} {}
 
   SetAccumulator(Hash hash, EqualTo equalTo, HashStringAllocator* allocator)
-      : uniqueValues{0, hash, equalTo, AlignedStlAllocator<T, 16>(allocator)} {}
+      : uniqueValues{
+            0,
+            hash,
+            equalTo,
+            AlignedStlAllocator<std::pair<const T, vector_size_t>, 16>(
+                allocator)} {}
 
   /// Adds value if new. No-op if the value was added before.
   void addValue(
       const DecodedVector& decoded,
       vector_size_t index,
       HashStringAllocator* /*allocator*/) {
+    const auto cnt = uniqueValues.size();
     if (decoded.isNullAt(index)) {
-      hasNull = true;
+      if (!nullIndex.has_value()) {
+        nullIndex = cnt;
+      }
     } else {
-      uniqueValues.insert(decoded.valueAt<T>(index));
+      uniqueValues.insert(
+          {decoded.valueAt<T>(index), nullIndex.has_value() ? cnt + 1 : cnt});
     }
   }
 
@@ -61,6 +78,7 @@ struct SetAccumulator {
       vector_size_t index,
       const DecodedVector& values,
       HashStringAllocator* allocator) {
+    VELOX_DCHECK(!arrayVector.isNullAt(index));
     const auto size = arrayVector.sizeAt(index);
     const auto offset = arrayVector.offsetAt(index);
 
@@ -69,24 +87,51 @@ struct SetAccumulator {
     }
   }
 
+  /// Adds non-null value if new. No-op if the value is NULL or was added
+  /// before.
+  void addNonNullValue(
+      const DecodedVector& decoded,
+      vector_size_t index,
+      HashStringAllocator* /*allocator*/) {
+    const auto cnt = uniqueValues.size();
+    if (!decoded.isNullAt(index)) {
+      uniqueValues.insert({decoded.valueAt<T>(index), cnt});
+    }
+  }
+
+  /// Adds new non-null values from an array.
+  void addNonNullValues(
+      const ArrayVector& arrayVector,
+      vector_size_t index,
+      const DecodedVector& values,
+      HashStringAllocator* allocator) {
+    VELOX_DCHECK(!arrayVector.isNullAt(index));
+    const auto size = arrayVector.sizeAt(index);
+    const auto offset = arrayVector.offsetAt(index);
+
+    for (auto i = 0; i < size; ++i) {
+      addNonNullValue(values, offset + i, allocator);
+    }
+  }
+
   /// Returns number of unique values including null.
   size_t size() const {
-    return uniqueValues.size() + (hasNull ? 1 : 0);
+    return uniqueValues.size() + (nullIndex.has_value() ? 1 : 0);
   }
 
   /// Copies the unique values and null into the specified vector starting at
   /// the specified offset.
   vector_size_t extractValues(FlatVector<T>& values, vector_size_t offset) {
-    vector_size_t index = offset;
     for (auto value : uniqueValues) {
-      values.set(index++, value);
+      values.set(offset + value.second, value.first);
     }
 
-    if (hasNull) {
-      values.setNull(index++, true);
+    if (nullIndex.has_value()) {
+      values.setNull(offset + nullIndex.value(), true);
     }
 
-    return index - offset;
+    return nullIndex.has_value() ? uniqueValues.size() + 1
+                                 : uniqueValues.size();
   }
 
   void free(HashStringAllocator& allocator) {
@@ -110,8 +155,11 @@ struct StringViewSetAccumulator {
       const DecodedVector& decoded,
       vector_size_t index,
       HashStringAllocator* allocator) {
+    const auto cnt = base.uniqueValues.size();
     if (decoded.isNullAt(index)) {
-      base.hasNull = true;
+      if (!base.nullIndex.has_value()) {
+        base.nullIndex = cnt;
+      }
     } else {
       auto value = decoded.valueAt<StringView>(index);
       if (!value.isInline()) {
@@ -120,7 +168,8 @@ struct StringViewSetAccumulator {
         }
         value = strings.append(value, *allocator);
       }
-      base.uniqueValues.insert(value);
+      base.uniqueValues.insert(
+          {value, base.nullIndex.has_value() ? cnt + 1 : cnt});
     }
   }
 
@@ -129,6 +178,7 @@ struct StringViewSetAccumulator {
       vector_size_t index,
       const DecodedVector& values,
       HashStringAllocator* allocator) {
+    VELOX_DCHECK(!arrayVector.isNullAt(index));
     const auto size = arrayVector.sizeAt(index);
     const auto offset = arrayVector.offsetAt(index);
 
@@ -137,6 +187,37 @@ struct StringViewSetAccumulator {
     }
   }
 
+  void addNonNullValue(
+      const DecodedVector& decoded,
+      vector_size_t index,
+      HashStringAllocator* allocator) {
+    const auto cnt = base.uniqueValues.size();
+    if (!decoded.isNullAt(index)) {
+      auto value = decoded.valueAt<StringView>(index);
+      if (!value.isInline()) {
+        if (base.uniqueValues.contains(value)) {
+          return;
+        }
+        value = strings.append(value, *allocator);
+      }
+      base.uniqueValues.insert({value, cnt});
+    }
+  }
+
+  void addNonNullValues(
+      const ArrayVector& arrayVector,
+      vector_size_t index,
+      const DecodedVector& values,
+      HashStringAllocator* allocator) {
+    VELOX_DCHECK(!arrayVector.isNullAt(index));
+    const auto size = arrayVector.sizeAt(index);
+    const auto offset = arrayVector.offsetAt(index);
+
+    for (auto i = 0; i < size; ++i) {
+      addNonNullValue(values, offset + i, allocator);
+    }
+  }
+
   size_t size() const {
     return base.size();
   }
@@ -158,7 +239,7 @@ struct StringViewSetAccumulator {
 struct ComplexTypeSetAccumulator {
   /// A set of pointers to values stored in AddressableNonNullValueList.
   SetAccumulator<
-      HashStringAllocator::Position,
+      AddressableNonNullValueList::Entry,
       AddressableNonNullValueList::Hash,
       AddressableNonNullValueList::EqualTo>
       base;
@@ -176,13 +257,18 @@ struct ComplexTypeSetAccumulator {
       const DecodedVector& decoded,
       vector_size_t index,
       HashStringAllocator* allocator) {
+    const auto cnt = base.uniqueValues.size();
     if (decoded.isNullAt(index)) {
-      base.hasNull = true;
+      if (!base.nullIndex.has_value()) {
+        base.nullIndex = cnt;
+      }
     } else {
-      auto position = values.append(decoded, index, allocator);
+      auto entry = values.append(decoded, index, allocator);
 
-      if (!base.uniqueValues.insert(position).second) {
-        values.removeLast(position);
+      if (!base.uniqueValues
+               .insert({entry, base.nullIndex.has_value() ? cnt + 1 : cnt})
+               .second) {
+        values.removeLast(entry);
       }
     }
   }
@@ -192,6 +278,7 @@ struct ComplexTypeSetAccumulator {
       vector_size_t index,
       const DecodedVector& values,
       HashStringAllocator* allocator) {
+    VELOX_DCHECK(!arrayVector.isNullAt(index));
     const auto size = arrayVector.sizeAt(index);
     const auto offset = arrayVector.offsetAt(index);
 
@@ -200,21 +287,49 @@ struct ComplexTypeSetAccumulator {
     }
   }
 
+  void addNonNullValue(
+      const DecodedVector& decoded,
+      vector_size_t index,
+      HashStringAllocator* allocator) {
+    const auto cnt = base.uniqueValues.size();
+    if (!decoded.isNullAt(index)) {
+      auto entry = values.append(decoded, index, allocator);
+
+      if (!base.uniqueValues.insert({entry, cnt}).second) {
+        values.removeLast(entry);
+      }
+    }
+  }
+
+  void addNonNullValues(
+      const ArrayVector& arrayVector,
+      vector_size_t index,
+      const DecodedVector& values,
+      HashStringAllocator* allocator) {
+    VELOX_DCHECK(!arrayVector.isNullAt(index));
+    const auto size = arrayVector.sizeAt(index);
+    const auto offset = arrayVector.offsetAt(index);
+
+    for (auto i = 0; i < size; ++i) {
+      addNonNullValue(values, offset + i, allocator);
+    }
+  }
+
   size_t size() const {
     return base.size();
   }
 
   vector_size_t extractValues(BaseVector& values, vector_size_t offset) {
-    vector_size_t index = offset;
     for (const auto& position : base.uniqueValues) {
-      AddressableNonNullValueList::read(position, values, index++);
+      AddressableNonNullValueList::read(
+          position.first, values, offset + position.second);
     }
 
-    if (base.hasNull) {
-      values.setNull(index++, true);
+    if (base.nullIndex.has_value()) {
+      values.setNull(offset + base.nullIndex.value(), true);
     }
 
-    return index - offset;
+    return base.uniqueValues.size() + (base.nullIndex.has_value() ? 1 : 0);
   }
 
   void free(HashStringAllocator& allocator) {
@@ -229,6 +344,22 @@ struct SetAccumulatorTypeTraits {
   using AccumulatorType = SetAccumulator<T>;
 };
 
+template <>
+struct SetAccumulatorTypeTraits<float> {
+  using AccumulatorType = SetAccumulator<
+      float,
+      util::floating_point::NaNAwareHash<float>,
+      util::floating_point::NaNAwareEquals<float>>;
+};
+
+template <>
+struct SetAccumulatorTypeTraits<double> {
+  using AccumulatorType = SetAccumulator<
+      double,
+      util::floating_point::NaNAwareHash<double>,
+      util::floating_point::NaNAwareEquals<double>>;
+};
+
 template <>
 struct SetAccumulatorTypeTraits<StringView> {
   using AccumulatorType = StringViewSetAccumulator;
diff --git a/velox/exec/SimpleAggregateAdapter.h b/velox/exec/SimpleAggregateAdapter.h
index bee0c372e44a2..d92584c6d6473 100644
--- a/velox/exec/SimpleAggregateAdapter.h
+++ b/velox/exec/SimpleAggregateAdapter.h
@@ -41,7 +41,8 @@ using optional_arg_type = OptionalAccessor<T>;
 template <typename FUNC>
 class SimpleAggregateAdapter : public Aggregate {
  public:
-  explicit SimpleAggregateAdapter(TypePtr resultType) : Aggregate(resultType) {}
+  explicit SimpleAggregateAdapter(TypePtr resultType)
+      : Aggregate(std::move(resultType)) {}
 
   // Assume most aggregate functions have fixed-size accumulators. Functions
   // that
@@ -67,17 +68,16 @@ class SimpleAggregateAdapter : public Aggregate {
   // there are a couple of differences in their implementations.
   // 1. When default_null_behavior_ is true, authors define
   //     void AccumulatorType::addInput(HashStringAllocator* allocator,
-  //     exec::arg_type<T1> arg1, ...) void
-  //     AccumulatorType::combine(HashStringAllocator* allocator,
-  //     exec::arg_type<IntermediateType> arg)
+  //                                    exec::arg_type<T1> arg1, ...)
+  //     void AccumulatorType::combine(HashStringAllocator* allocator,
+  //                                   exec::arg_type<IntermediateType> arg)
   // These functions only receive non-null input values. Input rows that contain
   // at least one NULL argument are ignored. The accumulator of a group is set
   // to non-null if at least one input is added to this group through addInput()
   // or combine(). Similarly, authors define
-  //     bool
-  //     AccumulatorType::writeIntermediateResult(exec::out_type<IntermediateType>&
-  //     out) bool AccumulatorType::writeFinalResult(exec::out_type<OutputType>&
-  //     out)
+  //     bool AccumulatorType::writeIntermediateResult(
+  //         exec::out_type<IntermediateType>&out)
+  //     bool AccumulatorType::writeFinalResult(exec::out_type<OutputType>&out)
   // These functions are only called on groups of non-null accumulators. Groups
   // that have NULL accumulators automatically become NULL in the result vector.
   // These functions also return a bool indicating whether the current group
@@ -85,18 +85,21 @@ class SimpleAggregateAdapter : public Aggregate {
   //
   // 2. When default_null_behavior_ is false, authors define
   //     bool AccumulatorType::addInput(HashStringAllocator* allocator,
-  //     exec::optional_arg_type<T1> arg1, ...) bool
-  //     AccumulatorType::combine(HashStringAllocator* allocator,
-  //     exec::optional_arg_type<IntermediateType> arg)
+  //                                    exec::optional_arg_type<T1> arg1, ...)
+  //     bool AccumulatorType::combine(
+  //         HashStringAllocator* allocator,
+  //         exec::optional_arg_type<IntermediateType> arg)
   // These functions receive both non-null and null inputs. They return a bool
   // indicating whether to set the current group's accumulator to non-null. If
   // the accumulator of a group is already non-NULL, returning false from
   // addInput() or combine() doesn't change this group's nullness. Authors also
   // define
-  //     bool AccumulatorType::writeIntermediateResult(bool nonNullGroup,
-  //     exec::out_type<IntermediateType>& out) bool
-  //     AccumulatorType::writeFinalResult(bool nonNullGroup,
-  //     exec::out_type<OutputType>& out)
+  //     bool AccumulatorType::writeIntermediateResult(
+  //         bool nonNullGroup,
+  //         exec::out_type<IntermediateType>& out)
+  //     bool AccumulatorType::writeFinalResult(
+  //         bool nonNullGroup,
+  //         exec::out_type<OutputType>& out)
   // These functions are called on groups of both non-null and null
   // accumulators. These functions also return a bool indicating whether the
   // current group should be a NULL in the result vector.
@@ -142,6 +145,18 @@ class SimpleAggregateAdapter : public Aggregate {
   struct support_to_intermediate<T, std::void_t<decltype(&T::toIntermediate)>>
       : std::true_type {};
 
+  // Whether the accumulator requires aligned access. If it is defined,
+  // SimpleAggregateAdapter::accumulatorAlignmentSize() returns
+  // alignof(typename FUNC::AccumulatorType).
+  // Otherwise, SimpleAggregateAdapter::accumulatorAlignmentSize() returns
+  // Aggregate::accumulatorAlignmentSize(), with a default value of 1.
+  template <typename T, typename = void>
+  struct accumulator_is_aligned : std::false_type {};
+
+  template <typename T>
+  struct accumulator_is_aligned<T, std::void_t<decltype(T::is_aligned_)>>
+      : std::integral_constant<bool, T::is_aligned_> {};
+
   static constexpr bool aggregate_default_null_behavior_ =
       aggregate_default_null_behavior<FUNC>::value;
 
@@ -157,6 +172,9 @@ class SimpleAggregateAdapter : public Aggregate {
   static constexpr bool support_to_intermediate_ =
       support_to_intermediate<FUNC>::value;
 
+  static constexpr bool accumulator_is_aligned_ =
+      accumulator_is_aligned<typename FUNC::AccumulatorType>::value;
+
   bool isFixedSize() const override {
     return accumulator_is_fixed_size_;
   }
@@ -169,13 +187,11 @@ class SimpleAggregateAdapter : public Aggregate {
     return sizeof(typename FUNC::AccumulatorType);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) typename FUNC::AccumulatorType(allocator_);
+  int32_t accumulatorAlignmentSize() const override {
+    if constexpr (accumulator_is_aligned_) {
+      return alignof(typename FUNC::AccumulatorType);
     }
+    return Aggregate::accumulatorAlignmentSize();
   }
 
   // Add raw input to accumulators. If the simple aggregation function has
@@ -328,16 +344,27 @@ class SimpleAggregateAdapter : public Aggregate {
     writer.finish();
   }
 
-  void destroy(folly::Range<char**> groups) override {
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) typename FUNC::AccumulatorType(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
     if constexpr (accumulator_custom_destroy_) {
       for (auto group : groups) {
         auto accumulator = value<typename FUNC::AccumulatorType>(group);
-        if (!isNull(group)) {
+        if (isInitialized(group) && !isNull(group)) {
           accumulator->destroy(allocator_);
         }
       }
+    } else {
+      destroyAccumulators<typename FUNC::AccumulatorType>(groups);
     }
-    destroyAccumulators<typename FUNC::AccumulatorType>(groups);
   }
 
  private:
diff --git a/velox/exec/SortBuffer.cpp b/velox/exec/SortBuffer.cpp
index f3208a105f1f4..2def45fb9cfb1 100644
--- a/velox/exec/SortBuffer.cpp
+++ b/velox/exec/SortBuffer.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "SortBuffer.h"
-#include "velox/vector/BaseVector.h"
+#include "velox/exec/MemoryReclaimer.h"
 
 namespace facebook::velox::exec {
 
@@ -23,26 +23,22 @@ SortBuffer::SortBuffer(
     const RowTypePtr& input,
     const std::vector<column_index_t>& sortColumnIndices,
     const std::vector<CompareFlags>& sortCompareFlags,
-    uint32_t outputBatchSize,
     velox::memory::MemoryPool* pool,
     tsan_atomic<bool>* nonReclaimableSection,
-    uint32_t* numSpillRuns,
+    common::PrefixSortConfig prefixSortConfig,
     const common::SpillConfig* spillConfig,
-    uint64_t spillMemoryThreshold)
+    folly::Synchronized<velox::common::SpillStats>* spillStats)
     : input_(input),
       sortCompareFlags_(sortCompareFlags),
-      outputBatchSize_(outputBatchSize),
       pool_(pool),
       nonReclaimableSection_(nonReclaimableSection),
-      numSpillRuns_(numSpillRuns),
+      prefixSortConfig_(prefixSortConfig),
       spillConfig_(spillConfig),
-      spillMemoryThreshold_(spillMemoryThreshold) {
+      spillStats_(spillStats) {
   VELOX_CHECK_GE(input_->size(), sortCompareFlags_.size());
   VELOX_CHECK_GT(sortCompareFlags_.size(), 0);
   VELOX_CHECK_EQ(sortColumnIndices.size(), sortCompareFlags_.size());
-  VELOX_CHECK_GT(outputBatchSize_, 0);
   VELOX_CHECK_NOT_NULL(nonReclaimableSection_);
-  VELOX_CHECK_NOT_NULL(numSpillRuns_);
 
   std::vector<TypePtr> sortedColumnTypes;
   std::vector<TypePtr> nonSortedColumnTypes;
@@ -81,18 +77,14 @@ SortBuffer::SortBuffer(
       ROW(std::move(sortedSpillColumnNames), std::move(sortedSpillColumnTypes));
 }
 
+SortBuffer::~SortBuffer() {
+  pool_->release();
+}
+
 void SortBuffer::addInput(const VectorPtr& input) {
   VELOX_CHECK(!noMoreInput_);
   ensureInputFits(input);
 
-  // Prevents the memory arbitrator to reclaim memory from this sort buffer
-  // during the execution below.
-  //
-  // NOTE: 'nonReclaimableSection_' points to the corresponding flag in the
-  // associated OrderBy/TableWriter operator.
-  auto guard = folly::makeGuard([this]() { *nonReclaimableSection_ = false; });
-  *nonReclaimableSection_ = true;
-
   SelectivityVector allRows(input->size());
   std::vector<char*> rows(input->size());
   for (int row = 0; row < input->size(); ++row) {
@@ -102,14 +94,17 @@ void SortBuffer::addInput(const VectorPtr& input) {
   for (const auto& columnProjection : columnMap_) {
     DecodedVector decoded(
         *inputRow->childAt(columnProjection.outputChannel), allRows);
-    for (int i = 0; i < input->size(); ++i) {
-      data_->store(decoded, i, rows[i], columnProjection.inputChannel);
-    }
+    data_->store(
+        decoded,
+        folly::Range(rows.data(), input->size()),
+        columnProjection.inputChannel);
   }
   numInputRows_ += allRows.size();
 }
 
 void SortBuffer::noMoreInput() {
+  velox::common::testutil::TestValue::adjust(
+      "facebook::velox::exec::SortBuffer::noMoreInput", this);
   VELOX_CHECK(!noMoreInput_);
   noMoreInput_ = true;
 
@@ -120,45 +115,41 @@ void SortBuffer::noMoreInput() {
 
   if (spiller_ == nullptr) {
     VELOX_CHECK_EQ(numInputRows_, data_->numRows());
+    updateEstimatedOutputRowSize();
     // Sort the pointers to the rows in RowContainer (data_) instead of sorting
     // the rows.
     sortedRows_.resize(numInputRows_);
     RowContainerIterator iter;
     data_->listRows(&iter, numInputRows_, sortedRows_.data());
-    std::sort(
-        sortedRows_.begin(),
-        sortedRows_.end(),
-        [this](const char* leftRow, const char* rightRow) {
-          for (vector_size_t index = 0; index < sortCompareFlags_.size();
-               ++index) {
-            if (auto result = data_->compare(
-                    leftRow, rightRow, index, sortCompareFlags_[index])) {
-              return result < 0;
-            }
-          }
-          return false;
-        });
+    PrefixSort::sort(
+        sortedRows_, pool_, data_.get(), sortCompareFlags_, prefixSortConfig_);
   } else {
-    // Finish spill, and we shouldn't get any rows from non-spilled partition as
-    // there is only one hash partition for SortBuffer.
-    Spiller::SpillRows nonSpilledRows = spiller_->finishSpill();
-    VELOX_CHECK_LE(spiller_->stats().spilledPartitions, 1);
-    VELOX_CHECK(nonSpilledRows.empty());
-
-    VELOX_CHECK_NULL(spillMerger_);
-    spillMerger_ = spiller_->startMerge(0);
-    spillSources_.resize(outputBatchSize_);
-    spillSourceRows_.resize(outputBatchSize_);
+    // Spill the remaining in-memory state to disk if spilling has been
+    // triggered on this sort buffer. This is to simplify query OOM prevention
+    // when producing output as we don't support to spill during that stage as
+    // for now.
+    spill();
+
+    finishSpill();
   }
+
+  // Releases the unused memory reservation after procesing input.
+  pool_->release();
 }
 
-RowVectorPtr SortBuffer::getOutput() {
+RowVectorPtr SortBuffer::getOutput(vector_size_t maxOutputRows) {
+  SCOPE_EXIT {
+    pool_->release();
+  };
+
   VELOX_CHECK(noMoreInput_);
+
   if (numOutputRows_ == numInputRows_) {
     return nullptr;
   }
 
-  prepareOutput();
+  ensureOutputFits();
+  prepareOutput(maxOutputRows);
   if (spiller_ != nullptr) {
     getOutputWithSpill();
   } else {
@@ -167,47 +158,25 @@ RowVectorPtr SortBuffer::getOutput() {
   return output_;
 }
 
-void SortBuffer::spill(int64_t targetRows, int64_t targetBytes) {
+void SortBuffer::spill() {
   VELOX_CHECK_NOT_NULL(
       spillConfig_, "spill config is null when SortBuffer spill is called");
-  VELOX_CHECK_GE(targetRows, 0);
-  VELOX_CHECK_GE(targetBytes, 0);
 
   // Check if sort buffer is empty or not, and skip spill if it is empty.
   if (data_->numRows() == 0) {
     return;
   }
+  updateEstimatedOutputRowSize();
 
-  ++(*numSpillRuns_);
-  if (spiller_ == nullptr) {
-    spiller_ = std::make_unique<Spiller>(
-        Spiller::Type::kOrderBy,
-        data_.get(),
-        [&](folly::Range<char**> rows) { data_->eraseRows(rows); },
-        spillerStoreType_,
-        data_->keyTypes().size(),
-        sortCompareFlags_,
-        spillConfig_->filePath,
-        std::numeric_limits<uint64_t>::max(),
-        spillConfig_->writeBufferSize,
-        spillConfig_->minSpillRunSize,
-        spillConfig_->compressionKind,
-        Spiller::pool(),
-        spillConfig_->executor);
-    VELOX_CHECK_EQ(spiller_->state().maxPartitions(), 1);
+  if (sortedRows_.empty()) {
+    spillInput();
+  } else {
+    spillOutput();
   }
+}
 
-  spiller_->spill(targetRows, targetBytes);
-
-  if (targetRows == 0 || targetBytes == 0) {
-    VELOX_CHECK_EQ(data_->numRows(), 0);
-  }
-  // TODO: support fine-grain memory recycling after row container memory
-  // compaction support. As of now, we only support releasing all the memory
-  // when we spill everything.
-  if (data_->numRows() == 0) {
-    data_->clear();
-  }
+std::optional<uint64_t> SortBuffer::estimateOutputRowSize() const {
+  return estimatedOutputRowSize_;
 }
 
 void SortBuffer::ensureInputFits(const VectorPtr& input) {
@@ -225,50 +194,33 @@ void SortBuffer::ensureInputFits(const VectorPtr& input) {
   auto [freeRows, outOfLineFreeBytes] = data_->freeSpace();
   const auto outOfLineBytes =
       data_->stringAllocator().retainedSize() - outOfLineFreeBytes;
-  const int64_t outOfLineBytesPerRow = outOfLineBytes / numRows;
   const int64_t flatInputBytes = input->estimateFlatSize();
 
   // Test-only spill path.
-  if (numRows > 0 && spillConfig_->testSpillPct &&
-      (folly::hasher<uint64_t>()(++spillTestCounter_)) % 100 <=
-          spillConfig_->testSpillPct) {
-    const int64_t rowsToSpill = std::max<int64_t>(1, numRows / 10);
-    spill(
-        numRows - rowsToSpill,
-        outOfLineBytes - (rowsToSpill * outOfLineBytesPerRow));
+  if (numRows > 0 && testingTriggerSpill(pool_->name())) {
+    spill();
     return;
   }
 
-  // If current memory usage exceeds spilling threshold, trigger spilling.
-  const auto currentMemoryUsage = pool_->currentBytes();
-  if (spillMemoryThreshold_ != 0 &&
-      currentMemoryUsage > spillMemoryThreshold_) {
-    const int64_t bytesToSpill =
-        currentMemoryUsage * spillConfig_->spillableReservationGrowthPct / 100;
-    auto rowsToSpill = std::max<int64_t>(
-        1, bytesToSpill / (data_->fixedRowSize() + outOfLineBytesPerRow));
-    spill(
-        std::max<int64_t>(0, numRows - rowsToSpill),
-        std::max<int64_t>(
-            0, outOfLineBytes - (rowsToSpill * outOfLineBytesPerRow)));
-    return;
-  }
-
-  // If we have enough free rows for input rows and enough variable length
-  // free space for the vector's flat size, no need for spilling.
-  if (freeRows > input->size() &&
-      (outOfLineBytes == 0 || outOfLineFreeBytes >= flatInputBytes)) {
-    return;
-  }
-
-  // For variable length data, we take the flat size of the input as the cap.
+  const auto currentMemoryUsage = pool_->usedBytes();
+  const auto minReservationBytes =
+      currentMemoryUsage * spillConfig_->minSpillableReservationPct / 100;
+  const auto availableReservationBytes = pool_->availableReservation();
   const int64_t estimatedIncrementalBytes =
       data_->sizeIncrement(input->size(), outOfLineBytes ? flatInputBytes : 0);
+  if (availableReservationBytes > minReservationBytes) {
+    // If we have enough free rows for input rows and enough variable length
+    // free space for the vector's flat size, no need for spilling.
+    if (freeRows > input->size() &&
+        (outOfLineBytes == 0 || outOfLineFreeBytes >= flatInputBytes)) {
+      return;
+    }
 
-  // If the current available reservation in memory pool is 2X the
-  // estimatedIncrementalBytes, no need to spill.
-  if (pool_->availableReservation() > 2 * estimatedIncrementalBytes) {
-    return;
+    // If the current available reservation in memory pool is 2X the
+    // estimatedIncrementalBytes, no need to spill.
+    if (availableReservationBytes > 2 * estimatedIncrementalBytes) {
+      return;
+    }
   }
 
   // Try reserving targetIncrementBytes more in memory pool, if succeed, no
@@ -276,25 +228,110 @@ void SortBuffer::ensureInputFits(const VectorPtr& input) {
   const auto targetIncrementBytes = std::max<int64_t>(
       estimatedIncrementalBytes * 2,
       currentMemoryUsage * spillConfig_->spillableReservationGrowthPct / 100);
-  if (pool_->maybeReserve(targetIncrementBytes)) {
+  {
+    memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
+    if (pool_->maybeReserve(targetIncrementBytes)) {
+      return;
+    }
+  }
+  LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
+               << " for memory pool " << pool()->name()
+               << ", usage: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+}
+
+void SortBuffer::ensureOutputFits() {
+  // Check if spilling is enabled or not.
+  if (spillConfig_ == nullptr) {
     return;
   }
 
-  // NOTE: disk spilling use the system disk spilling memory pool instead of
-  // the operator memory pool.
-  const int64_t rowsToSpill = std::max<int64_t>(
-      1, targetIncrementBytes / (data_->fixedRowSize() + outOfLineBytesPerRow));
-  spill(
-      std::max<int64_t>(0, numRows - rowsToSpill),
-      std::max<int64_t>(
-          0, outOfLineBytes - (rowsToSpill * outOfLineBytesPerRow)));
+  // Test-only spill path.
+  if (testingTriggerSpill(pool_->name())) {
+    spill();
+    return;
+  }
+
+  if (!estimatedOutputRowSize_.has_value()) {
+    return;
+  }
+
+  const uint64_t outputBufferSizeToReserve =
+      estimatedOutputRowSize_.value() * 1.2;
+  {
+    memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
+    if (pool_->maybeReserve(outputBufferSizeToReserve)) {
+      return;
+    }
+  }
+  LOG(WARNING) << "Failed to reserve "
+               << succinctBytes(outputBufferSizeToReserve)
+               << " for memory pool " << pool_->name()
+               << ", usage: " << succinctBytes(pool_->usedBytes())
+               << ", reservation: " << succinctBytes(pool_->reservedBytes());
 }
 
-void SortBuffer::prepareOutput() {
-  VELOX_CHECK_GT(numInputRows_, numOutputRows_);
+void SortBuffer::updateEstimatedOutputRowSize() {
+  const auto optionalRowSize = data_->estimateRowSize();
+  if (!optionalRowSize.has_value() || optionalRowSize.value() == 0) {
+    return;
+  }
+
+  const auto rowSize = optionalRowSize.value();
+  if (!estimatedOutputRowSize_.has_value()) {
+    estimatedOutputRowSize_ = rowSize;
+  } else if (rowSize > estimatedOutputRowSize_.value()) {
+    estimatedOutputRowSize_ = rowSize;
+  }
+}
 
+void SortBuffer::spillInput() {
+  if (spiller_ == nullptr) {
+    VELOX_CHECK(!noMoreInput_);
+    spiller_ = std::make_unique<Spiller>(
+        Spiller::Type::kOrderByInput,
+        data_.get(),
+        spillerStoreType_,
+        data_->keyTypes().size(),
+        sortCompareFlags_,
+        spillConfig_,
+        spillStats_);
+  }
+  spiller_->spill();
+  data_->clear();
+}
+
+void SortBuffer::spillOutput() {
+  if (spiller_ != nullptr) {
+    // Already spilled.
+    return;
+  }
+  if (numOutputRows_ == sortedRows_.size()) {
+    // All the output has been produced.
+    return;
+  }
+
+  spiller_ = std::make_unique<Spiller>(
+      Spiller::Type::kOrderByOutput,
+      data_.get(),
+      spillerStoreType_,
+      spillConfig_,
+      spillStats_);
+  auto spillRows = std::vector<char*>(
+      sortedRows_.begin() + numOutputRows_, sortedRows_.end());
+  spiller_->spill(spillRows);
+  data_->clear();
+  sortedRows_.clear();
+  // Finish right after spilling as the output spiller only spills at most
+  // once.
+  finishSpill();
+}
+
+void SortBuffer::prepareOutput(vector_size_t maxOutputRows) {
+  VELOX_CHECK_GT(maxOutputRows, 0);
+  VELOX_CHECK_GT(numInputRows_, numOutputRows_);
   const vector_size_t batchSize =
-      std::min<vector_size_t>(numInputRows_ - numOutputRows_, outputBatchSize_);
+      std::min<uint64_t>(numInputRows_ - numOutputRows_, maxOutputRows);
   if (output_ != nullptr) {
     VectorPtr output = std::move(output_);
     BaseVector::prepareForReuse(output, batchSize);
@@ -307,14 +344,19 @@ void SortBuffer::prepareOutput() {
   for (auto& child : output_->children()) {
     child->resize(batchSize);
   }
-}
 
-void SortBuffer::getOutputWithoutSpill() {
+  if (spiller_ != nullptr) {
+    spillSources_.resize(maxOutputRows);
+    spillSourceRows_.resize(maxOutputRows);
+  }
+
   VELOX_CHECK_GT(output_->size(), 0);
-  VELOX_DCHECK_LE(output_->size(), outputBatchSize_);
+  VELOX_DCHECK_LE(output_->size(), maxOutputRows);
   VELOX_CHECK_LE(output_->size() + numOutputRows_, numInputRows_);
-  VELOX_DCHECK_EQ(numInputRows_, sortedRows_.size());
+}
 
+void SortBuffer::getOutputWithoutSpill() {
+  VELOX_DCHECK_EQ(numInputRows_, sortedRows_.size());
   for (const auto& columnProjection : columnMap_) {
     data_->extractColumn(
         sortedRows_.data() + numOutputRows_,
@@ -328,8 +370,6 @@ void SortBuffer::getOutputWithoutSpill() {
 void SortBuffer::getOutputWithSpill() {
   VELOX_CHECK_NOT_NULL(spillMerger_);
   VELOX_DCHECK_EQ(sortedRows_.size(), 0);
-  VELOX_DCHECK_EQ(spillSources_.size(), outputBatchSize_);
-  VELOX_DCHECK_EQ(spillSourceRows_.size(), outputBatchSize_);
 
   int32_t outputRow = 0;
   int32_t outputSize = 0;
@@ -372,4 +412,13 @@ void SortBuffer::getOutputWithSpill() {
   numOutputRows_ += output_->size();
 }
 
+void SortBuffer::finishSpill() {
+  VELOX_CHECK_NULL(spillMerger_);
+  SpillPartitionSet spillPartitionSet;
+  spiller_->finishSpill(spillPartitionSet);
+  VELOX_CHECK_EQ(spillPartitionSet.size(), 1);
+  spillMerger_ = spillPartitionSet.begin()->second->createOrderedReader(
+      spillConfig_->readBufferSize, pool(), spillStats_);
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SortBuffer.h b/velox/exec/SortBuffer.h
index 2270cd8d375f3..a08052b7b9682 100644
--- a/velox/exec/SortBuffer.h
+++ b/velox/exec/SortBuffer.h
@@ -19,6 +19,7 @@
 #include "velox/exec/ContainerRowSerde.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/OperatorUtils.h"
+#include "velox/exec/PrefixSort.h"
 #include "velox/exec/RowContainer.h"
 #include "velox/exec/Spill.h"
 #include "velox/vector/BaseVector.h"
@@ -34,12 +35,13 @@ class SortBuffer {
       const RowTypePtr& input,
       const std::vector<column_index_t>& sortColumnIndices,
       const std::vector<CompareFlags>& sortCompareFlags,
-      uint32_t outputBatchSize,
       velox::memory::MemoryPool* pool,
       tsan_atomic<bool>* nonReclaimableSection,
-      uint32_t* numSpillRuns,
+      common::PrefixSortConfig prefixSortConfig,
       const common::SpillConfig* spillConfig = nullptr,
-      uint64_t spillMemoryThreshold = 0);
+      folly::Synchronized<velox::common::SpillStats>* spillStats = nullptr);
+
+  ~SortBuffer();
 
   void addInput(const VectorPtr& input);
 
@@ -50,47 +52,52 @@ class SortBuffer {
   void noMoreInput();
 
   /// Returns the sorted output rows in batch.
-  RowVectorPtr getOutput();
-
-  /// Invoked to spill from 'data_' to disk with specified targets.
-  ///
-  /// NOTE: if either 'targetRows' or 'targetBytes' is zero, then we spill all
-  /// the rows from 'data_'.
-  void spill(int64_t targetRows, int64_t targetBytes);
-
-  /// Returns the spiller stats including total bytes and rows spilled so far.
-  std::optional<SpillStats> spilledStats() const {
-    if (spiller_ == nullptr) {
-      return std::nullopt;
-    }
-    return spiller_->stats();
+  RowVectorPtr getOutput(vector_size_t maxOutputRows);
+
+  /// Indicates if this sort buffer can spill or not.
+  bool canSpill() const {
+    return spillConfig_ != nullptr;
+  }
+
+  /// Invoked to spill all the rows from 'data_'.
+  void spill();
+
+  memory::MemoryPool* pool() const {
+    return pool_;
   }
 
+  std::optional<uint64_t> estimateOutputRowSize() const;
+
  private:
   // Ensures there is sufficient memory reserved to process 'input'.
   void ensureInputFits(const VectorPtr& input);
+  // Reserves memory for output processing. If reservation cannot be increased,
+  // spills enough to make output fit.
+  void ensureOutputFits();
+  void updateEstimatedOutputRowSize();
   // Invoked to initialize or reset the reusable output buffer to get output.
-  void prepareOutput();
+  void prepareOutput(vector_size_t maxOutputRows);
   void getOutputWithoutSpill();
   void getOutputWithSpill();
+  // Spill during input stage.
+  void spillInput();
+  // Spill during output stage.
+  void spillOutput();
+  // Finish spill, and we shouldn't get any rows from non-spilled partition as
+  // there is only one hash partition for SortBuffer.
+  void finishSpill();
 
   const RowTypePtr input_;
   const std::vector<CompareFlags> sortCompareFlags_;
-  // Maximum number of rows to return in one output batch.
-  const uint32_t outputBatchSize_;
   velox::memory::MemoryPool* const pool_;
   // The flag is passed from the associated operator such as OrderBy or
   // TableWriter to indicate if this sort buffer object is under non-reclaimable
   // execution section or not.
   tsan_atomic<bool>* const nonReclaimableSection_;
-  // A recorder for number of spill runs passed in from order by operator.
-  uint32_t* const numSpillRuns_;
+  // Configuration settings for prefix-sort.
+  const common::PrefixSortConfig prefixSortConfig_;
   const common::SpillConfig* const spillConfig_;
-  // The maximum size that an SortBuffer can hold in memory before spilling.
-  // Zero indicates no limit.
-  //
-  // NOTE: 'spillMemoryThreshold_' only applies if disk spilling is enabled.
-  const uint64_t spillMemoryThreshold_;
+  folly::Synchronized<common::SpillStats>* const spillStats_;
 
   // The column projection map between 'input_' and 'spillerStoreType_' as sort
   // buffer stores the sort columns first in 'data_'.
@@ -100,7 +107,7 @@ class SortBuffer {
   // sort buffer object.
   bool noMoreInput_ = false;
   // The number of received input rows.
-  size_t numInputRows_ = 0;
+  uint64_t numInputRows_ = 0;
   // Used to store the input data in row format.
   std::unique_ptr<RowContainer> data_;
   std::vector<char*> sortedRows_;
@@ -114,13 +121,14 @@ class SortBuffer {
   // Records the source rows to copy to 'output_' in order.
   std::vector<const RowVector*> spillSources_;
   std::vector<vector_size_t> spillSourceRows_;
-  // Counts input batches to trigger spilling for test.
-  uint64_t spillTestCounter_{0};
 
   // Reusable output vector.
   RowVectorPtr output_;
+  // Estimated size of a single output row by using the max
+  // 'data_->estimateRowSize()' across all accumulated data set.
+  std::optional<uint64_t> estimatedOutputRowSize_{};
   // The number of rows that has been returned.
-  size_t numOutputRows_{0};
+  uint64_t numOutputRows_{0};
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SortWindowBuild.cpp b/velox/exec/SortWindowBuild.cpp
index 32ec4aa97b469..bf1fb0405bd21 100644
--- a/velox/exec/SortWindowBuild.cpp
+++ b/velox/exec/SortWindowBuild.cpp
@@ -15,13 +15,43 @@
  */
 
 #include "velox/exec/SortWindowBuild.h"
+#include "velox/exec/MemoryReclaimer.h"
 
 namespace facebook::velox::exec {
 
+namespace {
+std::vector<CompareFlags> makeSpillCompareFlags(
+    int32_t numPartitionKeys,
+    const std::vector<core::SortOrder>& sortingOrders) {
+  std::vector<CompareFlags> compareFlags;
+  compareFlags.reserve(numPartitionKeys + sortingOrders.size());
+
+  for (auto i = 0; i < numPartitionKeys; ++i) {
+    compareFlags.push_back({});
+  }
+
+  for (const auto& order : sortingOrders) {
+    compareFlags.push_back(
+        {order.isNullsFirst(), order.isAscending(), false /*equalsOnly*/});
+  }
+
+  return compareFlags;
+}
+} // namespace
+
 SortWindowBuild::SortWindowBuild(
-    const std::shared_ptr<const core::WindowNode>& windowNode,
-    velox::memory::MemoryPool* pool)
-    : WindowBuild(windowNode, pool) {
+    const std::shared_ptr<const core::WindowNode>& node,
+    velox::memory::MemoryPool* pool,
+    const common::SpillConfig* spillConfig,
+    tsan_atomic<bool>* nonReclaimableSection,
+    folly::Synchronized<common::SpillStats>* spillStats)
+    : WindowBuild(node, pool, spillConfig, nonReclaimableSection),
+      numPartitionKeys_{node->partitionKeys().size()},
+      spillCompareFlags_{
+          makeSpillCompareFlags(numPartitionKeys_, node->sortingOrders())},
+      pool_(pool),
+      spillStats_(spillStats) {
+  VELOX_CHECK_NOT_NULL(pool_);
   allKeyInfo_.reserve(partitionKeyInfo_.size() + sortKeyInfo_.size());
   allKeyInfo_.insert(
       allKeyInfo_.cend(), partitionKeyInfo_.begin(), partitionKeyInfo_.end());
@@ -31,10 +61,12 @@ SortWindowBuild::SortWindowBuild(
 }
 
 void SortWindowBuild::addInput(RowVectorPtr input) {
-  for (auto col = 0; col < input->childrenSize(); ++col) {
-    decodedInputVectors_[col].decode(*input->childAt(col));
+  for (auto i = 0; i < inputChannels_.size(); ++i) {
+    decodedInputVectors_[i].decode(*input->childAt(inputChannels_[i]));
   }
 
+  ensureInputFits(input);
+
   // Add all the rows into the RowContainer.
   for (auto row = 0; row < input->size(); ++row) {
     char* newRow = data_->newRow();
@@ -46,12 +78,119 @@ void SortWindowBuild::addInput(RowVectorPtr input) {
   numRows_ += input->size();
 }
 
-void SortWindowBuild::computePartitionStartRows() {
-  partitionStartRows_.reserve(numRows_);
+void SortWindowBuild::ensureInputFits(const RowVectorPtr& input) {
+  if (spillConfig_ == nullptr) {
+    // Spilling is disabled.
+    return;
+  }
+
+  if (data_->numRows() == 0) {
+    // Nothing to spill.
+    return;
+  }
+
+  // Test-only spill path.
+  if (testingTriggerSpill(pool_->name())) {
+    spill();
+    return;
+  }
+
+  auto [freeRows, outOfLineFreeBytes] = data_->freeSpace();
+  const auto outOfLineBytes =
+      data_->stringAllocator().retainedSize() - outOfLineFreeBytes;
+  const auto outOfLineBytesPerRow = outOfLineBytes / data_->numRows();
+
+  const auto currentUsage = data_->pool()->usedBytes();
+  const auto minReservationBytes =
+      currentUsage * spillConfig_->minSpillableReservationPct / 100;
+  const auto availableReservationBytes = data_->pool()->availableReservation();
+  const auto incrementBytes =
+      data_->sizeIncrement(input->size(), outOfLineBytesPerRow * input->size());
+
+  // First to check if we have sufficient minimal memory reservation.
+  if (availableReservationBytes >= minReservationBytes) {
+    if ((freeRows > input->size()) &&
+        (outOfLineBytes == 0 ||
+         outOfLineFreeBytes >= outOfLineBytesPerRow * input->size())) {
+      // Enough free rows for input rows and enough variable length free space.
+      return;
+    }
+  }
+
+  // Check if we can increase reservation. The increment is the largest of twice
+  // the maximum increment from this input and 'spillableReservationGrowthPct_'
+  // of the current memory usage.
+  const auto targetIncrementBytes = std::max<int64_t>(
+      incrementBytes * 2,
+      currentUsage * spillConfig_->spillableReservationGrowthPct / 100);
+  {
+    memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
+    if (data_->pool()->maybeReserve(targetIncrementBytes)) {
+      return;
+    }
+  }
+
+  LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
+               << " for memory pool " << data_->pool()->name()
+               << ", usage: " << succinctBytes(data_->pool()->usedBytes())
+               << ", reservation: "
+               << succinctBytes(data_->pool()->reservedBytes());
+}
+
+void SortWindowBuild::setupSpiller() {
+  VELOX_CHECK_NULL(spiller_);
+
+  spiller_ = std::make_unique<Spiller>(
+      // TODO Replace Spiller::Type::kOrderBy.
+      Spiller::Type::kOrderByInput,
+      data_.get(),
+      inputType_,
+      spillCompareFlags_.size(),
+      spillCompareFlags_,
+      spillConfig_,
+      spillStats_);
+}
+
+void SortWindowBuild::spill() {
+  if (spiller_ == nullptr) {
+    setupSpiller();
+  }
+
+  spiller_->spill();
+  data_->clear();
+  data_->pool()->release();
+}
+
+// Use double front and back search algorithm to find next partition start row.
+// It is more efficient than linear or binary search.
+// This algorithm is described at
+// https://medium.com/@insomniocode/search-algorithm-double-front-and-back-20f5f28512e7
+vector_size_t SortWindowBuild::findNextPartitionStartRow(vector_size_t start) {
   auto partitionCompare = [&](const char* lhs, const char* rhs) -> bool {
     return compareRowsWithKeys(lhs, rhs, partitionKeyInfo_);
   };
 
+  auto left = start;
+  auto right = left + 1;
+  auto lastPosition = sortedRows_.size();
+  while (right < lastPosition) {
+    auto distance = 1;
+    for (; distance < lastPosition - left; distance *= 2) {
+      right = left + distance;
+      if (partitionCompare(sortedRows_[left], sortedRows_[right]) != 0) {
+        lastPosition = right;
+        break;
+      }
+    }
+    left += distance / 2;
+    right = left + 1;
+  }
+  return right;
+}
+
+void SortWindowBuild::computePartitionStartRows() {
+  partitionStartRows_.reserve(numRows_);
+
   // Using a sequential traversal to find changing partitions.
   // This algorithm is inefficient and can be changed
   // i) Use a binary search kind of strategy.
@@ -60,15 +199,13 @@ void SortWindowBuild::computePartitionStartRows() {
   partitionStartRows_.push_back(0);
 
   VELOX_CHECK_GT(sortedRows_.size(), 0);
-  for (auto i = 1; i < sortedRows_.size(); i++) {
-    if (partitionCompare(sortedRows_[i - 1], sortedRows_[i])) {
-      partitionStartRows_.push_back(i);
-    }
-  }
 
-  // Setting the startRow of the (last + 1) partition to be returningRows.size()
-  // to help for last partition related calculations.
-  partitionStartRows_.push_back(sortedRows_.size());
+  vector_size_t start = 0;
+  while (start < sortedRows_.size()) {
+    auto next = findNextPartitionStartRow(start);
+    partitionStartRows_.push_back(next);
+    start = next;
+  }
 }
 
 void SortWindowBuild::sortPartitions() {
@@ -94,36 +231,101 @@ void SortWindowBuild::noMoreInput() {
   if (numRows_ == 0) {
     return;
   }
-  // At this point we have seen all the input rows. The operator is
-  // being prepared to output rows now.
-  // To prepare the rows for output in SortWindowBuild they need to
-  // be separated into partitions and sort by ORDER BY keys within
-  // the partition. This will order the rows for getOutput().
-  sortPartitions();
+
+  if (spiller_ != nullptr) {
+    // Spill remaining data to avoid running out of memory while sort-merging
+    // spilled data.
+    spill();
+
+    VELOX_CHECK_NULL(merge_);
+    SpillPartitionSet spillPartitionSet;
+    spiller_->finishSpill(spillPartitionSet);
+    VELOX_CHECK_EQ(spillPartitionSet.size(), 1);
+    merge_ = spillPartitionSet.begin()->second->createOrderedReader(
+        spillConfig_->readBufferSize, pool_, spillStats_);
+  } else {
+    // At this point we have seen all the input rows. The operator is
+    // being prepared to output rows now.
+    // To prepare the rows for output in SortWindowBuild they need to
+    // be separated into partitions and sort by ORDER BY keys within
+    // the partition. This will order the rows for getOutput().
+    sortPartitions();
+  }
 }
 
-std::unique_ptr<WindowPartition> SortWindowBuild::nextPartition() {
-  VELOX_CHECK(partitionStartRows_.size() > 0, "No window partitions available")
+void SortWindowBuild::loadNextPartitionFromSpill() {
+  sortedRows_.clear();
+  data_->clear();
+
+  for (;;) {
+    auto next = merge_->next();
+    if (next == nullptr) {
+      break;
+    }
+
+    bool newPartition = false;
+    if (!sortedRows_.empty()) {
+      CompareFlags compareFlags =
+          CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
+
+      for (auto i = 0; i < numPartitionKeys_; ++i) {
+        if (data_->compare(
+                sortedRows_.back(),
+                data_->columnAt(i),
+                next->decoded(i),
+                next->currentIndex(),
+                compareFlags)) {
+          newPartition = true;
+          break;
+        }
+      }
+    }
+
+    if (newPartition) {
+      break;
+    }
+
+    auto* newRow = data_->newRow();
+    for (auto i = 0; i < inputChannels_.size(); ++i) {
+      data_->store(next->decoded(i), next->currentIndex(), newRow, i);
+    }
+    sortedRows_.push_back(newRow);
+    next->pop();
+  }
+}
+
+std::shared_ptr<WindowPartition> SortWindowBuild::nextPartition() {
+  if (merge_ != nullptr) {
+    VELOX_CHECK(!sortedRows_.empty(), "No window partitions available");
+    auto partition = folly::Range(sortedRows_.data(), sortedRows_.size());
+    return std::make_shared<WindowPartition>(
+        data_.get(), partition, inversedInputChannels_, sortKeyInfo_);
+  }
+
+  VELOX_CHECK(!partitionStartRows_.empty(), "No window partitions available");
 
   currentPartition_++;
-  VELOX_CHECK(
-      currentPartition_ <= partitionStartRows_.size() - 2,
+  VELOX_CHECK_LE(
+      currentPartition_,
+      partitionStartRows_.size() - 2,
       "All window partitions consumed");
 
-  auto windowPartition = std::make_unique<WindowPartition>(
-      data_.get(), inputColumns_, sortKeyInfo_);
   // There is partition data available now.
   auto partitionSize = partitionStartRows_[currentPartition_ + 1] -
       partitionStartRows_[currentPartition_];
   auto partition = folly::Range(
       sortedRows_.data() + partitionStartRows_[currentPartition_],
       partitionSize);
-  windowPartition->resetPartition(partition);
-
-  return windowPartition;
+  return std::make_shared<WindowPartition>(
+      data_.get(), partition, inversedInputChannels_, sortKeyInfo_);
 }
 
 bool SortWindowBuild::hasNextPartition() {
+  if (merge_ != nullptr) {
+    loadNextPartitionFromSpill();
+    return !sortedRows_.empty();
+  }
+
   return partitionStartRows_.size() > 0 &&
       currentPartition_ < int(partitionStartRows_.size() - 2);
 }
diff --git a/velox/exec/SortWindowBuild.h b/velox/exec/SortWindowBuild.h
index 5a3f78942260c..0caecfe6a5c37 100644
--- a/velox/exec/SortWindowBuild.h
+++ b/velox/exec/SortWindowBuild.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/exec/Spiller.h"
 #include "velox/exec/WindowBuild.h"
 
 namespace facebook::velox::exec {
@@ -26,8 +27,11 @@ namespace facebook::velox::exec {
 class SortWindowBuild : public WindowBuild {
  public:
   SortWindowBuild(
-      const std::shared_ptr<const core::WindowNode>& windowNode,
-      velox::memory::MemoryPool* pool);
+      const std::shared_ptr<const core::WindowNode>& node,
+      velox::memory::MemoryPool* pool,
+      const common::SpillConfig* spillConfig,
+      tsan_atomic<bool>* nonReclaimableSection,
+      folly::Synchronized<common::SpillStats>* spillStats);
 
   bool needsInput() override {
     // No partitions are available yet, so can consume input rows.
@@ -36,13 +40,26 @@ class SortWindowBuild : public WindowBuild {
 
   void addInput(RowVectorPtr input) override;
 
+  void spill() override;
+
+  std::optional<common::SpillStats> spilledStats() const override {
+    if (spiller_ == nullptr) {
+      return std::nullopt;
+    }
+    return spiller_->stats();
+  }
+
   void noMoreInput() override;
 
   bool hasNextPartition() override;
 
-  std::unique_ptr<WindowPartition> nextPartition() override;
+  std::shared_ptr<WindowPartition> nextPartition() override;
 
  private:
+  void ensureInputFits(const RowVectorPtr& input);
+
+  void setupSpiller();
+
   // Main sorting function loop done after all input rows are received
   // by WindowBuild.
   void sortPartitions();
@@ -53,6 +70,24 @@ class SortWindowBuild : public WindowBuild {
   // structure that helps simplify the window function computations.
   void computePartitionStartRows();
 
+  // Find the next partition start row from start.
+  vector_size_t findNextPartitionStartRow(vector_size_t start);
+
+  // Reads next partition from spilled data into 'data_' and 'sortedRows_'.
+  void loadNextPartitionFromSpill();
+
+  const size_t numPartitionKeys_;
+
+  // Compare flags for partition and sorting keys. Compare flags for partition
+  // keys are set to default values. Compare flags for sorting keys match
+  // sorting order specified in the plan node.
+  //
+  // Used to sort 'data_' while spilling.
+  const std::vector<CompareFlags> spillCompareFlags_;
+
+  memory::MemoryPool* const pool_;
+  folly::Synchronized<common::SpillStats>* const spillStats_;
+
   // allKeyInfo_ is a combination of (partitionKeyInfo_ and sortKeyInfo_).
   // It is used to perform a full sorting of the input rows to be able to
   // separate partitions and sort the rows in it. The rows are output in
@@ -73,6 +108,12 @@ class SortWindowBuild : public WindowBuild {
   // Current partition being output. Used to construct WindowPartitions
   // during resetPartition.
   vector_size_t currentPartition_ = -1;
+
+  // Spiller for contents of the 'data_'.
+  std::unique_ptr<Spiller> spiller_;
+
+  // Used to sort-merge spilled data.
+  std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SortedAggregations.cpp b/velox/exec/SortedAggregations.cpp
index 3bc43b4602328..13d0a2edaced3 100644
--- a/velox/exec/SortedAggregations.cpp
+++ b/velox/exec/SortedAggregations.cpp
@@ -27,7 +27,7 @@ struct RowPointers {
   size_t size{0};
 
   void append(char* row, HashStringAllocator& allocator) {
-    ByteStream stream(&allocator);
+    ByteOutputStream stream(&allocator);
     if (firstBlock == nullptr) {
       // Allocate first block.
       currentBlock = allocator.newWrite(stream);
@@ -50,27 +50,23 @@ struct RowPointers {
     }
   }
 
-  std::vector<char*> read(HashStringAllocator& allocator) {
-    ByteStream stream(&allocator);
-    HashStringAllocator::prepareRead(firstBlock, stream);
+  void read(folly::Range<char**> rows) {
+    auto stream = HashStringAllocator::prepareRead(firstBlock);
 
-    std::vector<char*> rows(size);
     for (auto i = 0; i < size; ++i) {
-      rows[i] = reinterpret_cast<char*>(stream.read<uintptr_t>());
+      rows[i] = reinterpret_cast<char*>(stream->read<uintptr_t>());
     }
-    return rows;
   }
 };
 } // namespace
 
 SortedAggregations::SortedAggregations(
-    std::vector<AggregateInfo*> aggregates,
+    const std::vector<const AggregateInfo*>& aggregates,
     const RowTypePtr& inputType,
-    memory::MemoryPool* pool)
-    : aggregates_{std::move(aggregates)} {
+    memory::MemoryPool* pool) {
   // Collect inputs and sorting keys from all aggregates.
   std::unordered_set<column_index_t> allInputs;
-  for (const auto* aggregate : aggregates_) {
+  for (const auto* aggregate : aggregates) {
     for (auto i = 0; i < aggregate->inputs.size(); ++i) {
       auto input = aggregate->inputs[i];
       if (input != kConstantChannel) {
@@ -102,6 +98,46 @@ SortedAggregations::SortedAggregations(
 
   inputData_ = std::make_unique<RowContainer>(types, pool);
   decodedInputs_.resize(inputs_.size());
+
+  for (const auto& aggregate : aggregates) {
+    auto it =
+        aggregates_
+            .emplace(
+                toSortingSpec(*aggregate), std::vector<const AggregateInfo*>{})
+            .first;
+    it->second.push_back(aggregate);
+  }
+}
+
+std::unique_ptr<SortedAggregations> SortedAggregations::create(
+    const std::vector<AggregateInfo>& aggregates,
+    const RowTypePtr& inputType,
+    memory::MemoryPool* pool) {
+  std::vector<const AggregateInfo*> sortedAggs;
+  for (auto& aggregate : aggregates) {
+    if (!aggregate.sortingKeys.empty()) {
+      VELOX_USER_CHECK(
+          !aggregate.distinct,
+          "Aggregations over sorted unique values are not supported yet");
+      sortedAggs.push_back(&aggregate);
+    }
+  }
+
+  if (sortedAggs.empty()) {
+    return nullptr;
+  }
+
+  return std::make_unique<SortedAggregations>(sortedAggs, inputType, pool);
+}
+
+SortedAggregations::SortingSpec SortedAggregations::toSortingSpec(
+    const AggregateInfo& aggregate) const {
+  SortingSpec sortingSpec;
+  for (auto i = 0; i < aggregate.sortingKeys.size(); ++i) {
+    sortingSpec.push_back(
+        {inputMapping_[aggregate.sortingKeys[i]], aggregate.sortingOrders[i]});
+  }
+  return sortingSpec;
 }
 
 Accumulator SortedAggregations::accumulator() const {
@@ -110,6 +146,10 @@ Accumulator SortedAggregations::accumulator() const {
       sizeof(RowPointers),
       false,
       1,
+      ARRAY(VARBINARY()),
+      [this](folly::Range<char**> groups, VectorPtr& result) {
+        extractForSpill(groups, result);
+      },
       [this](folly::Range<char**> groups) {
         for (auto* group : groups) {
           auto* accumulator = reinterpret_cast<RowPointers*>(group + offset_);
@@ -118,17 +158,58 @@ Accumulator SortedAggregations::accumulator() const {
       }};
 }
 
+void SortedAggregations::extractForSpill(
+    folly::Range<char**> groups,
+    VectorPtr& result) const {
+  auto* arrayVector = result->as<ArrayVector>();
+  arrayVector->resize(groups.size());
+
+  auto* rawOffsets =
+      arrayVector->mutableOffsets(groups.size())->asMutable<vector_size_t>();
+  auto* rawSizes =
+      arrayVector->mutableSizes(groups.size())->asMutable<vector_size_t>();
+
+  vector_size_t offset = 0;
+  for (auto i = 0; i < groups.size(); ++i) {
+    auto* accumulator = reinterpret_cast<RowPointers*>(groups[i] + offset_);
+    rawSizes[i] = accumulator->size;
+    rawOffsets[i] = offset;
+    offset += accumulator->size;
+  }
+
+  std::vector<char*> groupRows(offset);
+
+  offset = 0;
+  for (auto i = 0; i < groups.size(); ++i) {
+    auto* accumulator = reinterpret_cast<RowPointers*>(groups[i] + offset_);
+    accumulator->read(
+        folly::Range(groupRows.data() + offset, accumulator->size));
+    offset += accumulator->size;
+  }
+
+  auto& elementsVector = arrayVector->elements();
+  elementsVector->resize(offset);
+  inputData_->extractSerializedRows(
+      folly::Range(groupRows.data(), groupRows.size()), elementsVector);
+}
+
+void SortedAggregations::clear() {
+  inputData_->clear();
+}
+
 void SortedAggregations::initializeNewGroups(
     char** groups,
     folly::Range<const vector_size_t*> indices) {
   for (auto i : indices) {
     groups[i][nullByte_] |= nullMask_;
     new (groups[i] + offset_) RowPointers();
+    groups[i][initializedByte_] |= initializedMask_;
   }
 
-  for (auto i = 0; i < aggregates_.size(); ++i) {
-    const auto& aggregate = *aggregates_[i];
-    aggregate.function->initializeNewGroups(groups, indices);
+  for (const auto& [sortingSpec, aggregates] : aggregates_) {
+    for (const auto& aggregate : aggregates) {
+      aggregate->function->initializeNewGroups(groups, indices);
+    }
   }
 }
 
@@ -174,14 +255,30 @@ void SortedAggregations::addSingleGroupInput(
   }
 }
 
+void SortedAggregations::addSingleGroupSpillInput(
+    char* group,
+    const VectorPtr& input,
+    vector_size_t index) {
+  auto* arrayVector = input->as<ArrayVector>();
+  auto* elementsVector = arrayVector->elements()->asFlatVector<StringView>();
+
+  const auto size = arrayVector->sizeAt(index);
+  const auto offset = arrayVector->offsetAt(index);
+  for (auto i = 0; i < size; ++i) {
+    char* newRow = inputData_->newRow();
+    inputData_->storeSerializedRow(*elementsVector, offset + i, newRow);
+    addNewRow(group, newRow);
+  }
+}
+
 bool SortedAggregations::compareRowsWithKeys(
     const char* lhs,
     const char* rhs,
-    const std::vector<std::pair<column_index_t, core::SortOrder>>& keys) {
+    const SortingSpec& sortingSpec) {
   if (lhs == rhs) {
     return false;
   }
-  for (auto& key : keys) {
+  for (auto& key : sortingSpec) {
     if (auto result = inputData_->compare(
             lhs,
             rhs,
@@ -193,62 +290,62 @@ bool SortedAggregations::compareRowsWithKeys(
   return false;
 }
 
-void SortedAggregations::noMoreInput() {}
-
 void SortedAggregations::sortSingleGroup(
     std::vector<char*>& groupRows,
-    const AggregateInfo& aggregate) {
-  std::vector<std::pair<column_index_t, core::SortOrder>> keys;
-  for (auto i = 0; i < aggregate.sortingKeys.size(); ++i) {
-    keys.push_back(
-        {inputMapping_[aggregate.sortingKeys[i]], aggregate.sortingOrders[i]});
-  }
-
+    const SortingSpec& sortingSpec) {
   std::sort(
       groupRows.begin(),
       groupRows.end(),
       [&](const char* leftRow, const char* rightRow) {
-        return compareRowsWithKeys(leftRow, rightRow, keys);
+        return compareRowsWithKeys(leftRow, rightRow, sortingSpec);
       });
 }
 
-std::vector<VectorPtr> SortedAggregations::extractSingleGroup(
+vector_size_t SortedAggregations::extractSingleGroup(
     std::vector<char*>& groupRows,
-    const AggregateInfo& aggregate) {
-  const auto numGroups = groupRows.size();
+    const AggregateInfo& aggregate,
+    std::vector<VectorPtr>& inputVectors) {
+  const auto numGroupRows = groupRows.size();
 
   std::vector<vector_size_t> rowNumbers;
   if (aggregate.mask) {
     FlatVectorPtr<bool> mask = BaseVector::create<FlatVector<bool>>(
-        BOOLEAN(), numGroups, inputData_->pool());
+        BOOLEAN(), numGroupRows, inputData_->pool());
     inputData_->extractColumn(
         groupRows.data(),
-        numGroups,
+        numGroupRows,
         inputMapping_[aggregate.mask.value()],
         mask);
 
-    rowNumbers.reserve(numGroups);
-    for (auto i = 0; i < numGroups; ++i) {
+    rowNumbers.reserve(numGroupRows);
+    for (auto i = 0; i < numGroupRows; ++i) {
       if (!mask->isNullAt(i) && mask->valueAt(i)) {
         rowNumbers.push_back(i);
       }
     }
 
     if (rowNumbers.empty()) {
-      return {};
+      return 0;
     }
   }
 
   const auto numInputs = aggregate.inputs.size();
-  std::vector<VectorPtr> inputVectors(numInputs);
+  VELOX_CHECK_EQ(numInputs, inputVectors.size());
+
+  const auto numRows = aggregate.mask ? rowNumbers.size() : numGroupRows;
+
   for (auto i = 0; i < numInputs; ++i) {
     if (aggregate.inputs[i] == kConstantChannel) {
       inputVectors[i] = aggregate.constantInputs[i];
     } else {
       const auto columnIndex = inputMapping_[aggregate.inputs[i]];
-      const auto numRows = aggregate.mask ? rowNumbers.size() : numGroups;
-      inputVectors[i] = BaseVector::create(
-          inputData_->keyTypes()[columnIndex], numRows, inputData_->pool());
+      if (inputVectors[i] == nullptr) {
+        inputVectors[i] = BaseVector::create(
+            inputData_->keyTypes()[columnIndex], numRows, inputData_->pool());
+      } else {
+        BaseVector::prepareForReuse(inputVectors[i], numRows);
+      }
+
       if (aggregate.mask) {
         inputData_->extractColumn(
             groupRows.data(),
@@ -258,56 +355,84 @@ std::vector<VectorPtr> SortedAggregations::extractSingleGroup(
             inputVectors[i]);
       } else {
         inputData_->extractColumn(
-            groupRows.data(), numGroups, columnIndex, inputVectors[i]);
+            groupRows.data(), numRows, columnIndex, inputVectors[i]);
       }
     }
   }
 
-  return inputVectors;
+  return numRows;
 }
 
 void SortedAggregations::extractValues(
     folly::Range<char**> groups,
     const RowVectorPtr& result) {
-  // TODO Identify aggregates with same order by and sort once.
-
   raw_vector<int32_t> temp;
   SelectivityVector rows;
-  for (auto i = 0; i < aggregates_.size(); ++i) {
-    const auto& aggregate = *aggregates_[i];
+  std::vector<char*> groupRows;
+  for (const auto& [sortingSpec, aggregates] : aggregates_) {
+    std::vector<VectorPtr> inputVectors;
+    size_t numInputColumns = 0;
+    for (const auto& aggregate : aggregates) {
+      numInputColumns += aggregate->inputs.size();
+    }
+    inputVectors.resize(numInputColumns);
 
     // For each group, sort inputs, add them to aggregate.
     for (auto* group : groups) {
-      auto groupRows =
-          reinterpret_cast<RowPointers*>(group + offset_)->read(*allocator_);
-
-      sortSingleGroup(groupRows, aggregate);
-
-      // TODO Process group rows in batches to avoid creating very large input
-      // vectors.
-      auto inputVectors = extractSingleGroup(groupRows, aggregate);
-      if (inputVectors.empty()) {
-        // Mask must be false for all 'groupRows'.
+      auto* accumulator = reinterpret_cast<RowPointers*>(group + offset_);
+      if (accumulator->size == 0) {
         continue;
       }
 
-      rows.resize(inputVectors[0]->size());
-      aggregate.function->addSingleGroupRawInput(
-          group, rows, inputVectors, false);
+      groupRows.resize(accumulator->size);
+      accumulator->read(folly::Range(groupRows.data(), groupRows.size()));
+
+      sortSingleGroup(groupRows, sortingSpec);
+
+      size_t firstInputColumn = 0;
+      for (const auto& aggregate : aggregates) {
+        std::vector<VectorPtr> aggregateInputs;
+        aggregateInputs.reserve(aggregate->inputs.size());
+        for (auto i = 0; i < aggregate->inputs.size(); ++i) {
+          aggregateInputs.push_back(
+              std::move(inputVectors[firstInputColumn + i]));
+        }
+
+        // TODO Process group rows in batches to avoid creating very large input
+        // vectors.
+        const auto numRows =
+            extractSingleGroup(groupRows, *aggregate, aggregateInputs);
+        if (numRows == 0) {
+          // Mask must be false for all 'groupRows'.
+          continue;
+        }
+
+        rows.resize(numRows);
+        aggregate->function->addSingleGroupRawInput(
+            group, rows, aggregateInputs, false);
+
+        for (auto i = 0; i < aggregate->inputs.size(); ++i) {
+          inputVectors[firstInputColumn + i] = std::move(aggregateInputs[i]);
+        }
+
+        firstInputColumn += aggregateInputs.size();
+      }
     }
 
-    aggregate.function->extractValues(
-        groups.data(), groups.size(), &result->childAt(aggregate.output));
-
-    // Release memory back to HashStringAllocator to allow next aggregate to
-    // re-use it.
-    aggregate.function->destroy(groups);
-    // Overwrite empty groups over the destructed groups to keep the container
-    // in a well formed state.
-    aggregate.function->initializeNewGroups(
-        groups.data(),
-        folly::Range<const int32_t*>(iota(groups.size(), temp), groups.size()));
+    for (const auto& aggregate : aggregates) {
+      aggregate->function->extractValues(
+          groups.data(), groups.size(), &result->childAt(aggregate->output));
+
+      // Release memory back to HashStringAllocator to allow next aggregate to
+      // re-use it.
+      aggregate->function->destroy(groups);
+      // Overwrite empty groups over the destructed groups to keep the container
+      // in a well formed state.
+      aggregate->function->initializeNewGroups(
+          groups.data(),
+          folly::Range<const int32_t*>(
+              iota(groups.size(), temp), groups.size()));
+    }
   }
 }
-
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SortedAggregations.h b/velox/exec/SortedAggregations.h
index b8805faf3bbea..63e6706cca5b4 100644
--- a/velox/exec/SortedAggregations.h
+++ b/velox/exec/SortedAggregations.h
@@ -31,7 +31,14 @@ class SortedAggregations {
   /// @param inputType Input row type for the aggregation operator.
   /// @param pool Memory pool.
   SortedAggregations(
-      std::vector<AggregateInfo*> aggregates,
+      const std::vector<const AggregateInfo*>& aggregates,
+      const RowTypePtr& inputType,
+      memory::MemoryPool* pool);
+
+  /// Create a SortedAggregations instance using aggregation infos. Return null
+  /// if there is no sorted aggregation.
+  static std::unique_ptr<SortedAggregations> create(
+      const std::vector<AggregateInfo>& aggregates,
       const RowTypePtr& inputType,
       memory::MemoryPool* pool);
 
@@ -47,10 +54,14 @@ class SortedAggregations {
       int32_t offset,
       int32_t nullByte,
       uint8_t nullMask,
+      int32_t initializedByte,
+      uint8_t initializedMask,
       int32_t rowSizeOffset) {
     offset_ = offset;
     nullByte_ = nullByte;
     nullMask_ = nullMask;
+    initializedByte_ = initializedByte;
+    initializedMask_ = initializedMask;
     rowSizeOffset_ = rowSizeOffset;
   }
 
@@ -62,35 +73,83 @@ class SortedAggregations {
 
   void addSingleGroupInput(char* group, const RowVectorPtr& input);
 
-  void noMoreInput();
+  void addSingleGroupSpillInput(
+      char* group,
+      const VectorPtr& input,
+      vector_size_t index);
 
   /// Sorts input row for the specified groups, computes aggregations and stores
   /// results in the specified 'result' vector.
   void extractValues(folly::Range<char**> groups, const RowVectorPtr& result);
 
+  /// Clears all data accumulated so far. Used to release memory after spilling.
+  void clear();
+
  private:
   void addNewRow(char* group, char* newRow);
 
+  // A list of sorting keys along with sorting orders.
+  using SortingSpec = std::vector<std::pair<column_index_t, core::SortOrder>>;
+
+  SortingSpec toSortingSpec(const AggregateInfo& aggregate) const;
+
   bool compareRowsWithKeys(
       const char* lhs,
       const char* rhs,
-      const std::vector<std::pair<column_index_t, core::SortOrder>>& keys);
+      const SortingSpec& sortingSpec);
 
   void sortSingleGroup(
       std::vector<char*>& groupRows,
-      const AggregateInfo& aggregate);
+      const SortingSpec& sortingSpec);
 
-  std::vector<VectorPtr> extractSingleGroup(
+  vector_size_t extractSingleGroup(
       std::vector<char*>& groupRows,
-      const AggregateInfo& aggregate);
-
-  const std::vector<AggregateInfo*> aggregates_;
-
-  /// Indices of all inputs for all aggregates.
+      const AggregateInfo& aggregate,
+      std::vector<VectorPtr>& inputVectors);
+
+  void extractForSpill(folly::Range<char**> groups, VectorPtr& result) const;
+
+  struct Hash {
+    static uint64_t hashSortOrder(const core::SortOrder& sortOrder) {
+      return bits::hashMix(
+          folly::hasher<bool>{}(sortOrder.isAscending()),
+          folly::hasher<bool>{}(sortOrder.isNullsFirst()));
+    }
+
+    size_t operator()(const SortingSpec& elements) const {
+      uint64_t hash = 0;
+
+      for (auto i = 0; i < elements.size(); ++i) {
+        auto column = elements[i].first;
+        auto sortOrder = elements[i].second;
+
+        auto elementHash = bits::hashMix(
+            folly::hasher<vector_size_t>{}(column), hashSortOrder(sortOrder));
+
+        hash = (i == 0) ? elementHash : bits::hashMix(hash, elementHash);
+      }
+      return hash;
+    }
+  };
+
+  struct EqualTo {
+    bool operator()(const SortingSpec& left, const SortingSpec& right) const {
+      return left == right;
+    }
+  };
+
+  // Aggregates grouped by sorting keys and orders.
+  folly::
+      F14FastMap<SortingSpec, std::vector<const AggregateInfo*>, Hash, EqualTo>
+          aggregates_;
+
+  // Indices of all inputs for all aggregates.
   std::vector<column_index_t> inputs_;
-  /// Stores all input rows for all groups.
+
+  // Stores all input rows for all groups.
   std::unique_ptr<RowContainer> inputData_;
-  /// Mapping from the input column index to an index into 'inputs_'.
+
+  // Mapping from the input column index to an index into 'inputs_'.
   std::vector<column_index_t> inputMapping_;
 
   std::vector<DecodedVector> decodedInputs_;
@@ -99,6 +158,8 @@ class SortedAggregations {
   int32_t offset_;
   int32_t nullByte_;
   uint8_t nullMask_;
+  int32_t initializedByte_;
+  uint8_t initializedMask_;
   int32_t rowSizeOffset_;
 };
 
diff --git a/velox/exec/Spill.cpp b/velox/exec/Spill.cpp
index fdacb601d8590..f7776566864c0 100644
--- a/velox/exec/Spill.cpp
+++ b/velox/exec/Spill.cpp
@@ -15,42 +15,14 @@
  */
 
 #include "velox/exec/Spill.h"
+#include "velox/common/base/RuntimeMetrics.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/exec/OperatorUtils.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/serializers/PrestoSerializer.h"
 
-namespace facebook::velox::exec {
-namespace {
-// Spilling currently uses the default PrestoSerializer which by default
-// serializes timestamp with millisecond precision to maintain compatibility
-// with presto. Since velox's native timestamp implementation supports
-// nanosecond precision, we use this serde option to ensure the serializer
-// preserves precision.
-static const bool kDefaultUseLosslessTimestamp = true;
-
-std::vector<folly::Synchronized<SpillStats>>& allSpillStats() {
-  static std::vector<folly::Synchronized<SpillStats>> spillStatsList(
-      std::thread::hardware_concurrency());
-  return spillStatsList;
-}
-
-folly::Synchronized<SpillStats>& localSpillStats() {
-  const auto idx = std::hash<std::thread::id>{}(std::this_thread::get_id());
-  auto& spillStatsVector = allSpillStats();
-  return spillStatsVector[idx % spillStatsVector.size()];
-}
-} // namespace
-
-std::atomic<int32_t> SpillFile::ordinalCounter_;
-
-void SpillInput::next(bool /*throwIfPastEnd*/) {
-  int32_t readBytes = std::min(input_->size() - offset_, buffer_->capacity());
-  VELOX_CHECK_LT(0, readBytes, "Reading past end of spill file");
-  setRange({buffer_->asMutable<uint8_t>(), readBytes, 0});
-  input_->pread(offset_, readBytes, buffer_->asMutable<char>());
-  offset_ += readBytes;
-}
+using facebook::velox::common::testutil::TestValue;
 
+namespace facebook::velox::exec {
 void SpillMergeStream::pop() {
   if (++index_ >= size_) {
     setNextBatch();
@@ -74,7 +46,7 @@ int32_t SpillMergeStream::compare(const MergeStream& other) const {
       if (result != 0) {
         return result;
       }
-    } while (++key < numSortingKeys());
+    } while (++key < numSortKeys());
   } else {
     do {
       auto result = children[key]
@@ -87,297 +59,119 @@ int32_t SpillMergeStream::compare(const MergeStream& other) const {
       if (result != 0) {
         return result;
       }
-    } while (++key < numSortingKeys());
+    } while (++key < numSortKeys());
   }
   return 0;
 }
 
-SpillFile::SpillFile(
-    RowTypePtr type,
-    int32_t numSortingKeys,
-    const std::vector<CompareFlags>& sortCompareFlags,
-    const std::string& path,
-    common::CompressionKind compressionKind,
-    memory::MemoryPool* pool)
-    : type_(std::move(type)),
-      numSortingKeys_(numSortingKeys),
-      sortCompareFlags_(sortCompareFlags),
-      ordinal_(ordinalCounter_++),
-      path_(fmt::format("{}-{}", path, ordinal_)),
-      compressionKind_(compressionKind),
-      pool_(pool) {
-  // NOTE: if the spilling operator has specified the sort comparison flags,
-  // then it must match the number of sorting keys.
-  VELOX_CHECK(
-      sortCompareFlags_.empty() || sortCompareFlags_.size() == numSortingKeys_);
-}
-
-WriteFile& SpillFile::output() {
-  if (!output_) {
-    auto fs = filesystems::getFileSystem(path_, nullptr);
-    output_ = fs->openFileForWrite(path_);
-  }
-  return *output_;
-}
-
-void SpillFile::startRead() {
-  constexpr uint64_t kMaxReadBufferSize =
-      (1 << 20) - AlignedBuffer::kPaddedSize; // 1MB - padding.
-  VELOX_CHECK(!output_);
-  VELOX_CHECK(!input_);
-  auto fs = filesystems::getFileSystem(path_, nullptr);
-  auto file = fs->openFileForRead(path_);
-  auto buffer = AlignedBuffer::allocate<char>(
-      std::min<uint64_t>(fileSize_, kMaxReadBufferSize), pool_);
-  input_ = std::make_unique<SpillInput>(std::move(file), std::move(buffer));
-}
-
-bool SpillFile::nextBatch(RowVectorPtr& rowVector) {
-  if (input_->atEnd()) {
-    return false;
-  }
-  serializer::presto::PrestoVectorSerde::PrestoOptions options = {
-      kDefaultUseLosslessTimestamp, compressionKind_};
-  VectorStreamGroup::read(input_.get(), pool_, type_, &rowVector, &options);
-  return true;
-}
-
-SpillFileList::SpillFileList(
-    const RowTypePtr& type,
-    int32_t numSortingKeys,
-    const std::vector<CompareFlags>& sortCompareFlags,
-    const std::string& path,
-    uint64_t targetFileSize,
-    uint64_t writeBufferSize,
-    common::CompressionKind compressionKind,
-    memory::MemoryPool* pool,
-    folly::Synchronized<SpillStats>* stats)
-    : type_(type),
-      numSortingKeys_(numSortingKeys),
-      sortCompareFlags_(sortCompareFlags),
-      path_(path),
-      targetFileSize_(targetFileSize),
-      writeBufferSize_(writeBufferSize),
-      compressionKind_(compressionKind),
-      pool_(pool),
-      stats_(stats) {
-  // NOTE: if the associated spilling operator has specified the sort
-  // comparison flags, then it must match the number of sorting keys.
-  VELOX_CHECK(
-      sortCompareFlags_.empty() || sortCompareFlags_.size() == numSortingKeys_);
-}
-
-WriteFile& SpillFileList::currentOutput() {
-  if (files_.empty() || !files_.back()->isWritable() ||
-      files_.back()->size() > targetFileSize_) {
-    if (!files_.empty() && files_.back()->isWritable()) {
-      files_.back()->finishWrite();
-      updateSpilledFiles(files_.back()->size());
-    }
-    files_.push_back(std::make_unique<SpillFile>(
-        type_,
-        numSortingKeys_,
-        sortCompareFlags_,
-        fmt::format("{}-{}", path_, files_.size()),
-        compressionKind_,
-        pool_));
-  }
-  return files_.back()->output();
-}
-
-uint64_t SpillFileList::flush() {
-  uint64_t writtenBytes = 0;
-  if (batch_) {
-    IOBufOutputStream out(
-        *pool_, nullptr, std::max<int64_t>(64 * 1024, batch_->size()));
-    uint64_t flushTimeUs{0};
-    {
-      MicrosecondTimer timer(&flushTimeUs);
-      batch_->flush(&out);
-    }
-
-    batch_.reset();
-    auto iobuf = out.getIOBuf();
-    auto& file = currentOutput();
-    uint64_t writeTimeUs{0};
-    uint32_t numDiskWrites{0};
-    {
-      MicrosecondTimer timer(&writeTimeUs);
-      for (auto& range : *iobuf) {
-        ++numDiskWrites;
-        file.append(std::string_view(
-            reinterpret_cast<const char*>(range.data()), range.size()));
-        writtenBytes += range.size();
-      }
-    }
-    updateWriteStats(numDiskWrites, writtenBytes, flushTimeUs, writeTimeUs);
-  }
-  return writtenBytes;
-}
-
-uint64_t SpillFileList::write(
-    const RowVectorPtr& rows,
-    const folly::Range<IndexRange*>& indices) {
-  uint64_t timeUs{0};
-  {
-    MicrosecondTimer timer(&timeUs);
-    if (batch_ == nullptr) {
-      serializer::presto::PrestoVectorSerde::PrestoOptions options = {
-          kDefaultUseLosslessTimestamp, compressionKind_};
-      batch_ = std::make_unique<VectorStreamGroup>(pool_);
-      batch_->createStreamTree(
-          std::static_pointer_cast<const RowType>(rows->type()),
-          1000,
-          &options);
-    }
-    batch_->append(rows, indices);
-  }
-  updateAppendStats(rows->size(), timeUs);
-  if (batch_->size() < writeBufferSize_) {
-    return 0;
-  }
-  return flush();
-}
-
-void SpillFileList::updateAppendStats(
-    uint64_t numRows,
-    uint64_t serializationTimeUs) {
-  auto statsLocked = stats_->wlock();
-  statsLocked->spilledRows += numRows;
-  statsLocked->spillSerializationTimeUs += serializationTimeUs;
-  updateGlobalSpillAppendStats(numRows, serializationTimeUs);
-}
-
-void SpillFileList::updateWriteStats(
-    uint32_t numDiskWrites,
-    uint64_t spilledBytes,
-    uint64_t flushTimeUs,
-    uint64_t fileWriteTimeUs) {
-  auto statsLocked = stats_->wlock();
-  statsLocked->spilledBytes += spilledBytes;
-  statsLocked->spillFlushTimeUs += flushTimeUs;
-  statsLocked->spillWriteTimeUs += fileWriteTimeUs;
-  statsLocked->spillDiskWrites += numDiskWrites;
-  updateGlobalSpillWriteStats(
-      numDiskWrites, spilledBytes, flushTimeUs, fileWriteTimeUs);
-}
-
-void SpillFileList::updateSpilledFiles(uint64_t fileSize) {
-  ++stats_->wlock()->spilledFiles;
-  addThreadLocalRuntimeStat(
-      "spillFileSize", RuntimeCounter(fileSize, RuntimeCounter::Unit::kBytes));
-  incrementGlobalSpilledFiles();
-}
-
-void SpillFileList::finishFile() {
-  flush();
-  if (files_.empty()) {
-    return;
-  }
-  if (files_.back()->isWritable()) {
-    files_.back()->finishWrite();
-    updateSpilledFiles(files_.back()->size());
-  }
-}
-
-std::vector<std::string> SpillFileList::testingSpilledFilePaths() const {
-  std::vector<std::string> spilledFiles;
-  for (auto& file : files_) {
-    spilledFiles.push_back(file->testingFilePath());
-  }
-  return spilledFiles;
-}
-
 SpillState::SpillState(
-    const std::string& path,
+    const common::GetSpillDirectoryPathCB& getSpillDirPathCb,
+    const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+    const std::string& fileNamePrefix,
     int32_t maxPartitions,
-    int32_t numSortingKeys,
+    int32_t numSortKeys,
     const std::vector<CompareFlags>& sortCompareFlags,
     uint64_t targetFileSize,
     uint64_t writeBufferSize,
     common::CompressionKind compressionKind,
     memory::MemoryPool* pool,
-    folly::Synchronized<SpillStats>* stats)
-    : path_(path),
+    folly::Synchronized<common::SpillStats>* stats,
+    const std::string& fileCreateConfig)
+    : getSpillDirPathCb_(getSpillDirPathCb),
+      updateAndCheckSpillLimitCb_(updateAndCheckSpillLimitCb),
+      fileNamePrefix_(fileNamePrefix),
       maxPartitions_(maxPartitions),
-      numSortingKeys_(numSortingKeys),
+      numSortKeys_(numSortKeys),
       sortCompareFlags_(sortCompareFlags),
       targetFileSize_(targetFileSize),
       writeBufferSize_(writeBufferSize),
       compressionKind_(compressionKind),
+      fileCreateConfig_(fileCreateConfig),
       pool_(pool),
       stats_(stats),
-      files_(maxPartitions_) {}
+      partitionWriters_(maxPartitions_) {}
 
-void SpillState::setPartitionSpilled(int32_t partition) {
+void SpillState::setPartitionSpilled(uint32_t partition) {
   VELOX_DCHECK_LT(partition, maxPartitions_);
   VELOX_DCHECK_LT(spilledPartitionSet_.size(), maxPartitions_);
   VELOX_DCHECK(!spilledPartitionSet_.contains(partition));
   spilledPartitionSet_.insert(partition);
   ++stats_->wlock()->spilledPartitions;
-  incrementGlobalSpilledPartitionStats();
+  common::incrementGlobalSpilledPartitionStats();
 }
 
 void SpillState::updateSpilledInputBytes(uint64_t bytes) {
   auto statsLocked = stats_->wlock();
   statsLocked->spilledInputBytes += bytes;
-  updateGlobalSpillMemoryBytes(bytes);
+  common::updateGlobalSpillMemoryBytes(bytes);
 }
 
 uint64_t SpillState::appendToPartition(
-    int32_t partition,
+    uint32_t partition,
     const RowVectorPtr& rows) {
   VELOX_CHECK(
       isPartitionSpilled(partition), "Partition {} is not spilled", partition);
+
+  TestValue::adjust(
+      "facebook::velox::exec::SpillState::appendToPartition", this);
+
+  VELOX_CHECK_NOT_NULL(
+      getSpillDirPathCb_, "Spill directory callback not specified.");
+  auto spillDir = getSpillDirPathCb_();
+  VELOX_CHECK(!spillDir.empty(), "Spill directory does not exist");
   // Ensure that partition exist before writing.
-  if (!files_.at(partition)) {
-    files_[partition] = std::make_unique<SpillFileList>(
+  if (partitionWriters_.at(partition) == nullptr) {
+    partitionWriters_[partition] = std::make_unique<SpillWriter>(
         std::static_pointer_cast<const RowType>(rows->type()),
-        numSortingKeys_,
+        numSortKeys_,
         sortCompareFlags_,
-        fmt::format("{}-spill-{}", path_, partition),
+        compressionKind_,
+        fmt::format("{}/{}-spill-{}", spillDir, fileNamePrefix_, partition),
         targetFileSize_,
         writeBufferSize_,
-        compressionKind_,
+        fileCreateConfig_,
+        updateAndCheckSpillLimitCb_,
         pool_,
         stats_);
   }
+
   updateSpilledInputBytes(rows->estimateFlatSize());
 
   IndexRange range{0, rows->size()};
-  return files_[partition]->write(rows, folly::Range<IndexRange*>(&range, 1));
+  return partitionWriters_[partition]->write(
+      rows, folly::Range<IndexRange*>(&range, 1));
 }
 
-std::unique_ptr<TreeOfLosers<SpillMergeStream>> SpillState::startMerge(
-    int32_t partition,
-    std::unique_ptr<SpillMergeStream>&& extra) {
-  VELOX_CHECK_LT(partition, files_.size());
-  std::vector<std::unique_ptr<SpillMergeStream>> result;
-  auto list = std::move(files_[partition]);
-  if (list != nullptr) {
-    for (auto& file : list->files()) {
-      result.push_back(FileSpillMergeStream::create(std::move(file)));
-    }
+SpillWriter* SpillState::partitionWriter(uint32_t partition) const {
+  VELOX_DCHECK(isPartitionSpilled(partition));
+  return partitionWriters_[partition].get();
+}
+
+void SpillState::finishFile(uint32_t partition) {
+  auto* writer = partitionWriter(partition);
+  if (writer == nullptr) {
+    return;
   }
-  VELOX_CHECK_EQ(!result.empty(), isPartitionSpilled(partition));
-  if (extra != nullptr) {
-    result.push_back(std::move(extra));
+  writer->finishFile();
+}
+
+size_t SpillState::numFinishedFiles(uint32_t partition) const {
+  if (!isPartitionSpilled(partition)) {
+    return 0;
   }
-  // Check if the partition is empty or not.
-  if (FOLLY_UNLIKELY(result.empty())) {
-    return nullptr;
+  const auto* writer = partitionWriter(partition);
+  if (writer == nullptr) {
+    return 0;
   }
-  return std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(result));
+  return writer->numFinishedFiles();
 }
 
-SpillFiles SpillState::files(int32_t partition) {
-  VELOX_CHECK_LT(partition, files_.size());
-
-  auto list = std::move(files_[partition]);
-  if (list == nullptr) {
+SpillFiles SpillState::finish(uint32_t partition) {
+  auto* writer = partitionWriter(partition);
+  if (writer == nullptr) {
     return {};
   }
-  return list->files();
+  return writer->finish();
 }
 
 const SpillPartitionNumSet& SpillState::spilledPartitionSet() const {
@@ -386,22 +180,27 @@ const SpillPartitionNumSet& SpillState::spilledPartitionSet() const {
 
 std::vector<std::string> SpillState::testingSpilledFilePaths() const {
   std::vector<std::string> spilledFiles;
-  for (const auto& list : files_) {
-    if (list != nullptr) {
-      const auto spilledFilesFromList = list->testingSpilledFilePaths();
+  for (const auto& writer : partitionWriters_) {
+    if (writer != nullptr) {
+      const auto partitionSpilledFiles = writer->testingSpilledFilePaths();
       spilledFiles.insert(
           spilledFiles.end(),
-          spilledFilesFromList.begin(),
-          spilledFilesFromList.end());
+          partitionSpilledFiles.begin(),
+          partitionSpilledFiles.end());
     }
   }
   return spilledFiles;
 }
 
+std::vector<uint32_t> SpillState::testingSpilledFileIds(
+    int32_t partitionNum) const {
+  return partitionWriters_[partitionNum]->testingSpilledFileIds();
+}
+
 SpillPartitionNumSet SpillState::testingNonEmptySpilledPartitionSet() const {
   SpillPartitionNumSet partitionSet;
   for (uint32_t partition = 0; partition < maxPartitions_; ++partition) {
-    if (files_[partition] != nullptr) {
+    if (partitionWriters_[partition] != nullptr) {
       partitionSet.insert(partition);
     }
   }
@@ -410,205 +209,82 @@ SpillPartitionNumSet SpillState::testingNonEmptySpilledPartitionSet() const {
 
 std::vector<std::unique_ptr<SpillPartition>> SpillPartition::split(
     int numShards) {
-  const int32_t numFilesPerShard = bits::roundUp(files_.size(), numShards);
   std::vector<std::unique_ptr<SpillPartition>> shards(numShards);
-
-  for (int shard = 0, fileIdx = 0; shard < numShards; ++shard) {
-    SpillFiles shardFiles;
-    shardFiles.reserve(numFilesPerShard);
-    while (shardFiles.size() < numFilesPerShard && fileIdx < files_.size()) {
-      shardFiles.push_back(std::move(files_[fileIdx++]));
+  const auto numFilesPerShard = files_.size() / numShards;
+  int32_t numRemainingFiles = files_.size() % numShards;
+  int fileIdx{0};
+  for (int shard = 0; shard < numShards; ++shard) {
+    SpillFiles files;
+    auto numFiles = numFilesPerShard;
+    if (numRemainingFiles-- > 0) {
+      ++numFiles;
     }
-    shards[shard] =
-        std::make_unique<SpillPartition>(id_, std::move(shardFiles));
+    files.reserve(numFiles);
+    while (files.size() < numFiles) {
+      files.push_back(std::move(files_[fileIdx++]));
+    }
+    shards[shard] = std::make_unique<SpillPartition>(id_, std::move(files));
   }
+  VELOX_CHECK_EQ(fileIdx, files_.size());
   files_.clear();
   return shards;
 }
 
+std::string SpillPartition::toString() const {
+  return fmt::format(
+      "SPILLED PARTITION[ID:{} FILES:{} SIZE:{}]",
+      id_.toString(),
+      files_.size(),
+      succinctBytes(size_));
+}
+
 std::unique_ptr<UnorderedStreamReader<BatchStream>>
-SpillPartition::createReader() {
+SpillPartition::createUnorderedReader(
+    uint64_t bufferSize,
+    memory::MemoryPool* pool,
+    folly::Synchronized<common::SpillStats>* spillStats) {
+  VELOX_CHECK_NOT_NULL(pool);
   std::vector<std::unique_ptr<BatchStream>> streams;
   streams.reserve(files_.size());
-  for (auto& file : files_) {
-    streams.push_back(FileSpillBatchStream::create(std::move(file)));
+  for (auto& fileInfo : files_) {
+    streams.push_back(FileSpillBatchStream::create(
+        SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
   }
   files_.clear();
   return std::make_unique<UnorderedStreamReader<BatchStream>>(
       std::move(streams));
 }
 
-SpillStats::SpillStats(
-    uint64_t _spillRuns,
-    uint64_t _spilledInputBytes,
-    uint64_t _spilledBytes,
-    uint64_t _spilledRows,
-    uint32_t _spilledPartitions,
-    uint64_t _spilledFiles,
-    uint64_t _spillFillTimeUs,
-    uint64_t _spillSortTimeUs,
-    uint64_t _spillSerializationTimeUs,
-    uint64_t _spillDiskWrites,
-    uint64_t _spillFlushTimeUs,
-    uint64_t _spillWriteTimeUs)
-    : spillRuns(_spillRuns),
-      spilledInputBytes(_spilledInputBytes),
-      spilledBytes(_spilledBytes),
-      spilledRows(_spilledRows),
-      spilledPartitions(_spilledPartitions),
-      spilledFiles(_spilledFiles),
-      spillFillTimeUs(_spillFillTimeUs),
-      spillSortTimeUs(_spillSortTimeUs),
-      spillSerializationTimeUs(_spillSerializationTimeUs),
-      spillDiskWrites(_spillDiskWrites),
-      spillFlushTimeUs(_spillFlushTimeUs),
-      spillWriteTimeUs(_spillWriteTimeUs) {}
-
-bool SpillStats::empty() const {
-  return spilledBytes == 0;
-}
-
-SpillStats& SpillStats::operator+=(const SpillStats& other) {
-  spillRuns += other.spillRuns;
-  spilledInputBytes += other.spilledInputBytes;
-  spilledBytes += other.spilledBytes;
-  spilledRows += other.spilledRows;
-  spilledPartitions += other.spilledPartitions;
-  spilledFiles += other.spilledFiles;
-  spillFillTimeUs += other.spillFillTimeUs;
-  spillSortTimeUs += other.spillSortTimeUs;
-  spillSerializationTimeUs += other.spillSerializationTimeUs;
-  spillDiskWrites += other.spillDiskWrites;
-  spillFlushTimeUs += other.spillFlushTimeUs;
-  spillWriteTimeUs += other.spillWriteTimeUs;
-  return *this;
-}
-
-SpillStats SpillStats::operator-(const SpillStats& other) const {
-  SpillStats result;
-  result.spillRuns = spillRuns - other.spillRuns;
-  result.spilledInputBytes = spilledInputBytes - other.spilledInputBytes;
-  result.spilledBytes = spilledBytes - other.spilledBytes;
-  result.spilledRows = spilledRows - other.spilledRows;
-  result.spilledPartitions = spilledPartitions - other.spilledPartitions;
-  result.spilledFiles = spilledFiles - other.spilledFiles;
-  result.spillFillTimeUs = spillFillTimeUs - other.spillFillTimeUs;
-  result.spillSortTimeUs = spillSortTimeUs - other.spillSortTimeUs;
-  result.spillSerializationTimeUs =
-      spillSerializationTimeUs - other.spillSerializationTimeUs;
-  result.spillDiskWrites = spillDiskWrites - other.spillDiskWrites;
-  result.spillFlushTimeUs = spillFlushTimeUs - other.spillFlushTimeUs;
-  result.spillWriteTimeUs = spillWriteTimeUs - other.spillWriteTimeUs;
-  return result;
-}
-
-bool SpillStats::operator<(const SpillStats& other) const {
-  uint32_t eqCount{0};
-  uint32_t gtCount{0};
-  uint32_t ltCount{0};
-#define UPDATE_COUNTER(counter)           \
-  do {                                    \
-    if (counter < other.counter) {        \
-      ++ltCount;                          \
-    } else if (counter > other.counter) { \
-      ++gtCount;                          \
-    } else {                              \
-      ++eqCount;                          \
-    }                                     \
-  } while (0);
-
-  UPDATE_COUNTER(spillRuns);
-  UPDATE_COUNTER(spilledInputBytes);
-  UPDATE_COUNTER(spilledBytes);
-  UPDATE_COUNTER(spilledRows);
-  UPDATE_COUNTER(spilledPartitions);
-  UPDATE_COUNTER(spilledFiles);
-  UPDATE_COUNTER(spillFillTimeUs);
-  UPDATE_COUNTER(spillSortTimeUs);
-  UPDATE_COUNTER(spillSerializationTimeUs);
-  UPDATE_COUNTER(spillDiskWrites);
-  UPDATE_COUNTER(spillFlushTimeUs);
-  UPDATE_COUNTER(spillWriteTimeUs);
-#undef UPDATE_COUNTER
-  VELOX_CHECK(
-      !((gtCount > 0) && (ltCount > 0)),
-      "gtCount {} ltCount {}",
-      gtCount,
-      ltCount);
-  return ltCount > 0;
-}
-
-bool SpillStats::operator>(const SpillStats& other) const {
-  return !(*this < other) && (*this != other);
-}
-
-bool SpillStats::operator>=(const SpillStats& other) const {
-  return !(*this < other);
-}
-
-bool SpillStats::operator<=(const SpillStats& other) const {
-  return !(*this > other);
-}
-
-bool SpillStats::operator==(const SpillStats& other) const {
-  return std::tie(
-             spillRuns,
-             spilledInputBytes,
-             spilledBytes,
-             spilledRows,
-             spilledPartitions,
-             spilledFiles,
-             spillFillTimeUs,
-             spillSortTimeUs,
-             spillSerializationTimeUs,
-             spillDiskWrites,
-             spillFlushTimeUs,
-             spillWriteTimeUs) ==
-      std::tie(
-             other.spillRuns,
-             other.spilledInputBytes,
-             other.spilledBytes,
-             other.spilledRows,
-             other.spilledPartitions,
-             other.spilledFiles,
-             other.spillFillTimeUs,
-             other.spillSortTimeUs,
-             other.spillSerializationTimeUs,
-             other.spillDiskWrites,
-             other.spillFlushTimeUs,
-             other.spillWriteTimeUs);
+std::unique_ptr<TreeOfLosers<SpillMergeStream>>
+SpillPartition::createOrderedReader(
+    uint64_t bufferSize,
+    memory::MemoryPool* pool,
+    folly::Synchronized<common::SpillStats>* spillStats) {
+  std::vector<std::unique_ptr<SpillMergeStream>> streams;
+  streams.reserve(files_.size());
+  for (auto& fileInfo : files_) {
+    streams.push_back(FileSpillMergeStream::create(
+        SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
+  }
+  files_.clear();
+  // Check if the partition is empty or not.
+  if (FOLLY_UNLIKELY(streams.empty())) {
+    return nullptr;
+  }
+  return std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
 }
 
-void SpillStats::reset() {
-  spillRuns = 0;
-  spilledInputBytes = 0;
-  spilledBytes = 0;
-  spilledRows = 0;
-  spilledPartitions = 0;
-  spilledFiles = 0;
-  spillFillTimeUs = 0;
-  spillSortTimeUs = 0;
-  spillSerializationTimeUs = 0;
-  spillDiskWrites = 0;
-  spillFlushTimeUs = 0;
-  spillWriteTimeUs = 0;
+uint32_t FileSpillMergeStream::id() const {
+  return spillFile_->id();
 }
 
-std::string SpillStats::toString() const {
-  return fmt::format(
-      "spillRuns[{}] spilledInputBytes[{}] spilledBytes[{}] spilledRows[{}] spilledPartitions[{}] spilledFiles[{}] spillFillTimeUs[{}] spillSortTime[{}] spillSerializationTime[{}] spillDiskWrites[{}] spillFlushTime[{}] spillWriteTime[{}]",
-      spillRuns,
-      succinctBytes(spilledInputBytes),
-      succinctBytes(spilledBytes),
-      spilledRows,
-      spilledPartitions,
-      spilledFiles,
-      succinctMicros(spillFillTimeUs),
-      succinctMicros(spillSortTimeUs),
-      succinctMicros(spillSerializationTimeUs),
-      spillDiskWrites,
-      succinctMicros(spillFlushTimeUs),
-      succinctMicros(spillWriteTimeUs));
+void FileSpillMergeStream::nextBatch() {
+  index_ = 0;
+  if (!spillFile_->nextBatch(rowVector_)) {
+    size_ = 0;
+    return;
+  }
+  size_ = rowVector_->size();
 }
 
 SpillPartitionIdSet toSpillPartitionIdSet(
@@ -621,57 +297,76 @@ SpillPartitionIdSet toSpillPartitionIdSet(
   return partitionIdSet;
 }
 
-void updateGlobalSpillRunStats(uint64_t numRuns) {
-  auto statsLocked = localSpillStats().wlock();
-  statsLocked->spillRuns += numRuns;
+namespace {
+tsan_atomic<uint32_t>& maxSpillInjections() {
+  static tsan_atomic<uint32_t> maxInjections{0};
+  return maxInjections;
 }
 
-void updateGlobalSpillAppendStats(
-    uint64_t numRows,
-    uint64_t serializationTimeUs) {
-  auto statsLocked = localSpillStats().wlock();
-  statsLocked->spilledRows += numRows;
-  statsLocked->spillSerializationTimeUs += serializationTimeUs;
+tsan_atomic<uint32_t>& testingSpillPct() {
+  static tsan_atomic<uint32_t> spillPct{0};
+  return spillPct;
 }
 
-void incrementGlobalSpilledPartitionStats() {
-  ++localSpillStats().wlock()->spilledPartitions;
+std::string& testingSpillPoolRegExp() {
+  static std::string spillPoolRegExp{".*"};
+  return spillPoolRegExp;
 }
+} // namespace
 
-void updateGlobalSpillFillTime(uint64_t timeUs) {
-  localSpillStats().wlock()->spillFillTimeUs += timeUs;
+TestScopedSpillInjection::TestScopedSpillInjection(
+    int32_t spillPct,
+    const std::string& poolRegExp,
+    uint32_t maxInjections) {
+  VELOX_CHECK_EQ(injectedSpillCount(), 0);
+  testingSpillPct() = spillPct;
+  testingSpillPoolRegExp() = poolRegExp;
+  maxSpillInjections() = maxInjections;
+  injectedSpillCount() = 0;
 }
 
-void updateGlobalSpillSortTime(uint64_t timeUs) {
-  localSpillStats().wlock()->spillSortTimeUs += timeUs;
+TestScopedSpillInjection::~TestScopedSpillInjection() {
+  testingSpillPct() = 0;
+  injectedSpillCount() = 0;
+  testingSpillPoolRegExp() = ".*";
+  maxSpillInjections() = 0;
 }
 
-void updateGlobalSpillWriteStats(
-    uint32_t numDiskWrites,
-    uint64_t spilledBytes,
-    uint64_t flushTimeUs,
-    uint64_t writeTimeUs) {
-  auto statsLocked = localSpillStats().wlock();
-  statsLocked->spillDiskWrites += numDiskWrites;
-  statsLocked->spilledBytes += spilledBytes;
-  statsLocked->spillFlushTimeUs += flushTimeUs;
-  statsLocked->spillWriteTimeUs += writeTimeUs;
+tsan_atomic<uint32_t>& injectedSpillCount() {
+  static tsan_atomic<uint32_t> injectedCount{0};
+  return injectedCount;
 }
 
-void updateGlobalSpillMemoryBytes(uint64_t spilledInputBytes) {
-  auto statsLocked = localSpillStats().wlock();
-  statsLocked->spilledInputBytes += spilledInputBytes;
-}
+bool testingTriggerSpill(const std::string& pool) {
+  // Put cheap check first to reduce CPU consumption in release code.
+  if (testingSpillPct() <= 0) {
+    return false;
+  }
+
+  if (injectedSpillCount() >= maxSpillInjections()) {
+    return false;
+  }
 
-void incrementGlobalSpilledFiles() {
-  ++localSpillStats().wlock()->spilledFiles;
+  if (folly::Random::rand32() % 100 > testingSpillPct()) {
+    return false;
+  }
+
+  if (!pool.empty() && !RE2::FullMatch(pool, testingSpillPoolRegExp())) {
+    return false;
+  }
+
+  ++injectedSpillCount();
+  return true;
 }
 
-SpillStats globalSpillStats() {
-  SpillStats gSpillStats;
-  for (auto& spillStats : allSpillStats()) {
-    gSpillStats += spillStats.copy();
+void removeEmptyPartitions(SpillPartitionSet& partitionSet) {
+  auto it = partitionSet.begin();
+  while (it != partitionSet.end()) {
+    if (it->second->numFiles() > 0) {
+      ++it;
+    } else {
+      it = partitionSet.erase(it);
+    }
   }
-  return gSpillStats;
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Spill.h b/velox/exec/Spill.h
index 30a34c1731c36..e51c052410b9d 100644
--- a/velox/exec/Spill.h
+++ b/velox/exec/Spill.h
@@ -18,8 +18,13 @@
 
 #include <folly/container/F14Set.h>
 
+#include <re2/re2.h>
+#include "velox/common/base/SpillConfig.h"
+#include "velox/common/base/SpillStats.h"
 #include "velox/common/compression/Compression.h"
 #include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/SpillFile.h"
 #include "velox/exec/TreeOfLosers.h"
 #include "velox/exec/UnorderedStreamReader.h"
 #include "velox/vector/ComplexVector.h"
@@ -27,276 +32,15 @@
 #include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::exec {
-
-// Input stream backed by spill file.
-class SpillInput : public ByteStream {
- public:
-  // Reads from 'input' using 'buffer' for buffering reads.
-  SpillInput(std::unique_ptr<ReadFile>&& input, BufferPtr buffer)
-      : input_(std::move(input)),
-        buffer_(std::move(buffer)),
-        size_(input_->size()) {
-    next(true);
-  }
-
-  void next(bool throwIfPastEnd) override;
-
-  // True if all of the file has been read into vectors.
-  bool atEnd() const {
-    return offset_ >= size_ && ranges()[0].position >= ranges()[0].size;
-  }
-
- private:
-  std::unique_ptr<ReadFile> input_;
-  BufferPtr buffer_;
-  const uint64_t size_;
-  // Offset of first byte not in 'buffer_'
-  uint64_t offset_ = 0;
-};
-
-/// Represents a spill file that is first in write mode and then
-/// turns into a source of spilled RowVectors. Owns a file system file that
-/// contains the spilled data and is live for the duration of 'this'.
-
-/// NOTE: The class will not delete spill file upon destruction, so the user
-/// needs to remove the unused spill files at some point later. For example, a
-/// query Task deletes all the generated spill files in one operation using
-/// rmdir() call.
-class SpillFile {
- public:
-  SpillFile(
-      RowTypePtr type,
-      int32_t numSortingKeys,
-      const std::vector<CompareFlags>& sortCompareFlags,
-      const std::string& path,
-      common::CompressionKind compressionKind,
-      memory::MemoryPool* pool);
-
-  int32_t numSortingKeys() const {
-    return numSortingKeys_;
-  }
-
-  const std::vector<CompareFlags>& sortCompareFlags() const {
-    return sortCompareFlags_;
-  }
-
-  /// Returns a file for writing spilled data. The caller constructs
-  /// this, then calls output() and writes serialized data to the file
-  /// and calls finishWrite when the file has reached its final
-  /// size. For sorted spilling, the data in one file is expected to be
-  // sorted.
-  WriteFile& output();
-
-  bool isWritable() const {
-    return output_ != nullptr;
-  }
-
-  /// Finishes writing and flushes any unwritten data.
-  void finishWrite() {
-    VELOX_CHECK(output_);
-    fileSize_ = output_->size();
-    output_ = nullptr;
-  }
-
-  /// Prepares 'this' for reading. Positions the read at the first row of
-  /// content. The caller must call output() and finishWrite() before this.
-  void startRead();
-
-  bool nextBatch(RowVectorPtr& rowVector);
-
-  /// Returns the file size in bytes. During the writing phase this is
-  /// the current size of the file, during reading this is the final
-  // size.
-  uint64_t size() const {
-    if (output_) {
-      return output_->size();
-    }
-    return fileSize_;
-  }
-
-  std::string label() const {
-    return fmt::format("{}", ordinal_);
-  }
-
-  const std::string& testingFilePath() const {
-    return path_;
-  }
-
- private:
-  static std::atomic<int32_t> ordinalCounter_;
-
-  // Type of 'rowVector_'. Needed for setting up writing.
-  const RowTypePtr type_;
-  const int32_t numSortingKeys_;
-  const std::vector<CompareFlags> sortCompareFlags_;
-  // Ordinal number used for making a label for debugging.
-  const int32_t ordinal_;
-  const std::string path_;
-  const common::CompressionKind compressionKind_;
-  memory::MemoryPool* const pool_;
-
-  // Byte size of the backing file. Set when finishing writing.
-  uint64_t fileSize_ = 0;
-  std::unique_ptr<WriteFile> output_;
-  std::unique_ptr<SpillInput> input_;
-};
-
-/// Provides the fine-grained spill execution stats.
-struct SpillStats {
-  /// The number of times that spilling runs on an operator.
-  uint64_t spillRuns{0};
-  /// The number of bytes in memory to spill
-  uint64_t spilledInputBytes{0};
-  /// The number of bytes spilled to disks.
-  ///
-  /// NOTE: if compression is enabled, this counts the compressed bytes.
-  uint64_t spilledBytes{0};
-  /// The number of spilled rows.
-  uint64_t spilledRows{0};
-  /// NOTE: when we sum up the stats from a group of spill operators, it is
-  /// the total number of spilled partitions X number of operators.
-  uint32_t spilledPartitions{0};
-  /// The number of spilled files.
-  uint64_t spilledFiles{0};
-  /// The time spent on filling rows for spilling.
-  uint64_t spillFillTimeUs{0};
-  /// The time spent on sorting rows for spilling.
-  uint64_t spillSortTimeUs{0};
-  /// The time spent on serializing rows for spilling.
-  uint64_t spillSerializationTimeUs{0};
-  /// The number of disk writes to spill rows.
-  uint64_t spillDiskWrites{0};
-  /// The time spent on copy out serialized rows for disk write. If compression
-  /// is enabled, this includes the compression time.
-  uint64_t spillFlushTimeUs{0};
-  /// The time spent on writing spilled rows to disk.
-  uint64_t spillWriteTimeUs{0};
-
-  SpillStats(
-      uint64_t _spillRuns,
-      uint64_t _spilledInputBytes,
-      uint64_t _spilledBytes,
-      uint64_t _spilledRows,
-      uint32_t _spilledPartitions,
-      uint64_t _spilledFiles,
-      uint64_t _spillFillTimeUs,
-      uint64_t _spillSortTimeUs,
-      uint64_t _spillSerializationTimeUs,
-      uint64_t _spillDiskWrites,
-      uint64_t _spillFlushTimeUs,
-      uint64_t _spillWriteTimeUs);
-
-  SpillStats() = default;
-
-  bool empty() const;
-
-  SpillStats& operator+=(const SpillStats& other);
-  SpillStats operator-(const SpillStats& other) const;
-  bool operator==(const SpillStats& other) const;
-  bool operator!=(const SpillStats& other) const {
-    return !(*this == other);
-  }
-  bool operator>(const SpillStats& other) const;
-  bool operator<(const SpillStats& other) const;
-  bool operator>=(const SpillStats& other) const;
-  bool operator<=(const SpillStats& other) const;
-
-  void reset();
-
-  std::string toString() const;
-};
-
-FOLLY_ALWAYS_INLINE std::ostream& operator<<(
-    std::ostream& o,
-    const SpillStats& stats) {
-  return o << stats.toString();
-}
-
-using SpillFiles = std::vector<std::unique_ptr<SpillFile>>;
-
-/// Sequence of files for one partition of the spilled data. If data is
-/// sorted, each file is sorted. The globally sorted order is produced
-/// by merging the constituent files.
-class SpillFileList {
- public:
-  /// Constructs a set of spill files. 'type' is a RowType describing the
-  /// content. 'numSortingKeys' is the number of leading columns on which the
-  /// data is sorted. 'path' is a file path prefix. ' 'targetFileSize' is the
-  /// target byte size of a single file in the file set. 'pool' is used for
-  /// buffering and constructing the result data read from 'this'.
-  ///
-  /// When writing sorted spill runs, the caller is responsible for buffering
-  /// and sorting the data. write is called multiple times, followed by flush().
-  SpillFileList(
-      const RowTypePtr& type,
-      int32_t numSortingKeys,
-      const std::vector<CompareFlags>& sortCompareFlags,
-      const std::string& path,
-      uint64_t targetFileSize,
-      uint64_t writeBufferSize,
-      common::CompressionKind compressionKind,
-      memory::MemoryPool* pool,
-      folly::Synchronized<SpillStats>* stats);
-
-  /// Adds 'rows' for the positions in 'indices' into 'this'. The indices
-  /// must produce a view where the rows are sorted if sorting is desired.
-  /// Consecutive calls must have sorted data so that the first row of the
-  /// next call is not less than the last row of the previous call.
-  /// Returns the size to write.
-  uint64_t write(
-      const RowVectorPtr& rows,
-      const folly::Range<IndexRange*>& indices);
-
-  /// Closes the current output file if any. Subsequent calls to write will
-  /// start a new one.
-  void finishFile();
-
-  SpillFiles files() {
-    VELOX_CHECK(!files_.empty() || (batch_ != nullptr));
-    finishFile();
-    return std::move(files_);
-  }
-
-  std::vector<std::string> testingSpilledFilePaths() const;
-
- private:
-  // Returns the current file to write to and creates one if needed.
-  WriteFile& currentOutput();
-
-  // Writes data from 'batch_' to the current output file. Returns the actual
-  // written size.
-  uint64_t flush();
-
-  // Invoked to update the number of spilled rows.
-  void updateAppendStats(uint64_t numRows, uint64_t serializationTimeUs);
-  // Invoked to increment the number of spilled files and the file size.
-  void updateSpilledFiles(uint64_t fileSize);
-  // Invoked to update the disk write stats.
-  void updateWriteStats(
-      uint32_t numDiskWrites,
-      uint64_t spilledBytes,
-      uint64_t flushTimeUs,
-      uint64_t writeTimeUs);
-
-  const RowTypePtr type_;
-  const int32_t numSortingKeys_;
-  const std::vector<CompareFlags> sortCompareFlags_;
-  const std::string path_;
-  const uint64_t targetFileSize_;
-  const uint64_t writeBufferSize_;
-  const common::CompressionKind compressionKind_;
-  memory::MemoryPool* const pool_;
-  folly::Synchronized<SpillStats>* const stats_;
-  std::unique_ptr<VectorStreamGroup> batch_;
-  SpillFiles files_;
-};
-
 // A source of sorted spilled RowVectors coming either from a file or memory.
 class SpillMergeStream : public MergeStream {
  public:
   SpillMergeStream() = default;
   virtual ~SpillMergeStream() = default;
 
+  /// Returns the id of a spill merge stream which is unique in the merge set.
+  virtual uint32_t id() const = 0;
+
   bool hasData() const final {
     return index_ < size_;
   }
@@ -324,14 +68,14 @@ class SpillMergeStream : public MergeStream {
     return index_;
   }
 
-  // Returns a DecodedVector set decoding the 'index'th child of 'rowVector_'
+  /// Returns a DecodedVector set decoding the 'index'th child of 'rowVector_'
   DecodedVector& decoded(int32_t index) {
     ensureDecodedValid(index);
     return decoded_[index];
   }
 
  protected:
-  virtual int32_t numSortingKeys() const = 0;
+  virtual int32_t numSortKeys() const = 0;
 
   virtual const std::vector<CompareFlags>& sortCompareFlags() const = 0;
 
@@ -387,37 +131,32 @@ class SpillMergeStream : public MergeStream {
 class FileSpillMergeStream : public SpillMergeStream {
  public:
   static std::unique_ptr<SpillMergeStream> create(
-      std::unique_ptr<SpillFile> spillFile) {
-    spillFile->startRead();
-    auto* spillStream = new FileSpillMergeStream(std::move(spillFile));
-    spillStream->nextBatch();
-    return std::unique_ptr<SpillMergeStream>(spillStream);
+      std::unique_ptr<SpillReadFile> spillFile) {
+    auto spillStream = std::unique_ptr<SpillMergeStream>(
+        new FileSpillMergeStream(std::move(spillFile)));
+    static_cast<FileSpillMergeStream*>(spillStream.get())->nextBatch();
+    return spillStream;
   }
 
+  uint32_t id() const override;
+
  private:
-  explicit FileSpillMergeStream(std::unique_ptr<SpillFile> spillFile)
+  explicit FileSpillMergeStream(std::unique_ptr<SpillReadFile> spillFile)
       : spillFile_(std::move(spillFile)) {
     VELOX_CHECK_NOT_NULL(spillFile_);
   }
 
-  int32_t numSortingKeys() const override {
-    return spillFile_->numSortingKeys();
+  int32_t numSortKeys() const override {
+    return spillFile_->numSortKeys();
   }
 
   const std::vector<CompareFlags>& sortCompareFlags() const override {
     return spillFile_->sortCompareFlags();
   }
 
-  void nextBatch() override {
-    index_ = 0;
-    if (!spillFile_->nextBatch(rowVector_)) {
-      size_ = 0;
-      return;
-    }
-    size_ = rowVector_->size();
-  }
+  void nextBatch() override;
 
-  std::unique_ptr<SpillFile> spillFile_;
+  std::unique_ptr<SpillReadFile> spillFile_;
 };
 
 /// A source of spilled RowVectors coming from a file. The spill data might not
@@ -427,31 +166,22 @@ class FileSpillMergeStream : public SpillMergeStream {
 class FileSpillBatchStream : public BatchStream {
  public:
   static std::unique_ptr<BatchStream> create(
-      std::unique_ptr<SpillFile> spillFile) {
+      std::unique_ptr<SpillReadFile> spillFile) {
     auto* spillStream = new FileSpillBatchStream(std::move(spillFile));
     return std::unique_ptr<BatchStream>(spillStream);
   }
 
   bool nextBatch(RowVectorPtr& batch) override {
-    if (FOLLY_UNLIKELY(!isFileOpened_)) {
-      spillFile_->startRead();
-      isFileOpened_ = true;
-    }
     return spillFile_->nextBatch(batch);
   }
 
  private:
-  explicit FileSpillBatchStream(std::unique_ptr<SpillFile> spillFile)
-      : isFileOpened_(false), spillFile_(std::move(spillFile)) {
+  explicit FileSpillBatchStream(std::unique_ptr<SpillReadFile> spillFile)
+      : spillFile_(std::move(spillFile)) {
     VELOX_CHECK_NOT_NULL(spillFile_);
   }
 
-  // Indicates if 'spillFile_' has been opened for stream read or not.
-  //
-  // NOTE: we open the file until the first read on this stream object so that
-  // we don't open too many files at the same time.
-  bool isFileOpened_;
-  std::unique_ptr<SpillFile> spillFile_;
+  std::unique_ptr<SpillReadFile> spillFile_;
 };
 
 /// Identifies a spill partition generated from a given spilling operator. It
@@ -527,12 +257,14 @@ class SpillPartition {
   explicit SpillPartition(const SpillPartitionId& id)
       : SpillPartition(id, {}) {}
 
-  SpillPartition(const SpillPartitionId& id, SpillFiles files)
-      : id_(id), files_(std::move(files)) {}
+  SpillPartition(const SpillPartitionId& id, SpillFiles files) : id_(id) {
+    addFiles(std::move(files));
+  }
 
   void addFiles(SpillFiles files) {
     files_.reserve(files_.size() + files.size());
     for (auto& file : files) {
+      size_ += file.size;
       files_.push_back(std::move(file));
     }
   }
@@ -545,6 +277,11 @@ class SpillPartition {
     return files_.size();
   }
 
+  /// Returns the total file byte size of this spilled partition.
+  uint64_t size() const {
+    return size_;
+  }
+
   /// Invoked to split this spill partition into 'numShards' to process in
   /// parallel.
   ///
@@ -553,11 +290,33 @@ class SpillPartition {
 
   /// Invoked to create an unordered stream reader from this spill partition.
   /// The created reader will take the ownership of the spill files.
-  std::unique_ptr<UnorderedStreamReader<BatchStream>> createReader();
+  /// 'bufferSize' specifies the read size from the storage. If the file system
+  /// supports async read mode, then reader allocates two buffers with one
+  /// buffer prefetch ahead. 'spillStats' is provided to collect the spill stats
+  /// when reading data from spilled files.
+  std::unique_ptr<UnorderedStreamReader<BatchStream>> createUnorderedReader(
+      uint64_t bufferSize,
+      memory::MemoryPool* pool,
+      folly::Synchronized<common::SpillStats>* spillStats);
+
+  /// Invoked to create an ordered stream reader from this spill partition.
+  /// The created reader will take the ownership of the spill files.
+  /// 'bufferSize' specifies the read size from the storage. If the file system
+  /// supports async read mode, then reader allocates two buffers with one
+  /// buffer prefetch ahead. 'spillStats' is provided to collect the spill stats
+  /// when reading data from spilled files.
+  std::unique_ptr<TreeOfLosers<SpillMergeStream>> createOrderedReader(
+      uint64_t bufferSize,
+      memory::MemoryPool* pool,
+      folly::Synchronized<common::SpillStats>* spillStats);
+
+  std::string toString() const;
 
  private:
   SpillPartitionId id_;
   SpillFiles files_;
+  // Counts the total file size in bytes from this spilled partition.
+  uint64_t size_{0};
 };
 
 using SpillPartitionSet =
@@ -570,29 +329,32 @@ class SpillState {
   /// Constructs a SpillState. 'type' is the content RowType. 'path' is the file
   /// system path prefix. 'bits' is the hash bit field for partitioning data
   /// between files. This also gives the maximum number of partitions.
-  /// 'numSortingKeys' is the number of leading columns on which the data is
+  /// 'numSortKeys' is the number of leading columns on which the data is
   /// sorted, 0 if only hash partitioning is used. 'targetFileSize' is the
   /// target size of a single file.  'pool' owns the memory for state and
   /// results.
   SpillState(
-      const std::string& path,
+      const common::GetSpillDirectoryPathCB& getSpillDirectoryPath,
+      const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+      const std::string& fileNamePrefix,
       int32_t maxPartitions,
-      int32_t numSortingKeys,
+      int32_t numSortKeys,
       const std::vector<CompareFlags>& sortCompareFlags,
       uint64_t targetFileSize,
       uint64_t writeBufferSize,
       common::CompressionKind compressionKind,
       memory::MemoryPool* pool,
-      folly::Synchronized<SpillStats>* stats);
+      folly::Synchronized<common::SpillStats>* stats,
+      const std::string& fileCreateConfig = {});
 
   /// Indicates if a given 'partition' has been spilled or not.
-  bool isPartitionSpilled(int32_t partition) const {
+  bool isPartitionSpilled(uint32_t partition) const {
     VELOX_DCHECK_LT(partition, maxPartitions_);
     return spilledPartitionSet_.contains(partition);
   }
 
   // Sets a partition as spilled.
-  void setPartitionSpilled(int32_t partition);
+  void setPartitionSpilled(uint32_t partition);
 
   // Returns how many ways spilled data can be partitioned.
   int32_t maxPartitions() const {
@@ -623,97 +385,104 @@ class SpillState {
   /// Appends data to 'partition'. The rows given by 'indices' must be sorted
   /// for a sorted spill and must hash to 'partition'. It is safe to call this
   /// on multiple threads if all threads specify a different partition. Returns
-  /// the size to sppend to partition.
-  uint64_t appendToPartition(int32_t partition, const RowVectorPtr& rows);
+  /// the size to append to partition.
+  uint64_t appendToPartition(uint32_t partition, const RowVectorPtr& rows);
 
   /// Finishes a sorted run for 'partition'. If write is called for 'partition'
   /// again, the data does not have to be sorted relative to the data written so
   /// far.
-  void finishWrite(int32_t partition) {
-    VELOX_DCHECK(isPartitionSpilled(partition));
-    files_[partition]->finishFile();
-  }
+  void finishFile(uint32_t partition);
+
+  /// Returns the current number of finished files from a given partition.
+  ///
+  /// NOTE: the fucntion returns zero if the state has finished or the partition
+  /// is not spilled yet.
+  size_t numFinishedFiles(uint32_t partition) const;
 
   /// Returns the spill file objects from a given 'partition'. The function
   /// returns an empty list if either the partition has not been spilled or has
   /// no spilled data.
-  SpillFiles files(int32_t partition);
-
-  /// Starts reading values for 'partition'. If 'extra' is non-null, it can be
-  /// a stream of rows from a RowContainer so as to merge unspilled data with
-  /// spilled data.
-  std::unique_ptr<TreeOfLosers<SpillMergeStream>> startMerge(
-      int32_t partition,
-      std::unique_ptr<SpillMergeStream>&& extra);
+  SpillFiles finish(uint32_t partition);
 
-  bool hasFiles(int32_t partition) const {
-    return partition < files_.size() && files_[partition];
-  }
-
-  /// Return the spilled partition number set.
+  /// Returns the spilled partition number set.
   const SpillPartitionNumSet& spilledPartitionSet() const;
 
+  /// Returns the spilled file paths from all the partitions.
   std::vector<std::string> testingSpilledFilePaths() const;
 
+  /// Returns the file ids from a given partition.
+  std::vector<uint32_t> testingSpilledFileIds(int32_t partitionNum) const;
+
   /// Returns the set of partitions that have spilled data.
   SpillPartitionNumSet testingNonEmptySpilledPartitionSet() const;
 
  private:
   void updateSpilledInputBytes(uint64_t bytes);
 
+  SpillWriter* partitionWriter(uint32_t partition) const;
+
   const RowTypePtr type_;
-  const std::string path_;
+
+  // A callback function that returns the spill directory path. Implementations
+  // can use it to ensure the path exists before returning.
+  common::GetSpillDirectoryPathCB getSpillDirPathCb_;
+
+  // Updates the aggregated spill bytes of this query, and throws if exceeds
+  // the max spill bytes limit.
+  common::UpdateAndCheckSpillLimitCB updateAndCheckSpillLimitCb_;
+
+  /// Prefix for spill files.
+  const std::string fileNamePrefix_;
   const int32_t maxPartitions_;
-  const int32_t numSortingKeys_;
+  const int32_t numSortKeys_;
   const std::vector<CompareFlags> sortCompareFlags_;
   const uint64_t targetFileSize_;
   const uint64_t writeBufferSize_;
   const common::CompressionKind compressionKind_;
+  const std::string fileCreateConfig_;
   memory::MemoryPool* const pool_;
-  folly::Synchronized<SpillStats>* const stats_;
+  folly::Synchronized<common::SpillStats>* const stats_;
 
   // A set of spilled partition numbers.
   SpillPartitionNumSet spilledPartitionSet_;
 
   // A file list for each spilled partition. Only partitions that have
   // started spilling have an entry here.
-  std::vector<std::unique_ptr<SpillFileList>> files_;
+  std::vector<std::unique_ptr<SpillWriter>> partitionWriters_;
 };
 
 /// Generate partition id set from given spill partition set.
 SpillPartitionIdSet toSpillPartitionIdSet(
     const SpillPartitionSet& partitionSet);
 
-/// The utilities to update the process wide spilling stats.
-/// Updates the number of spill runs.
-void updateGlobalSpillRunStats(uint64_t numRuns);
-/// Updates the stats of new append spilled rows including the number of spilled
-/// rows and the serializaion time.
-void updateGlobalSpillAppendStats(
-    uint64_t numRows,
-    uint64_t serializaionTimeUs);
-/// Increments the number of spilled partitions.
-void incrementGlobalSpilledPartitionStats();
-/// Updates the time spent on filling rows to spill.
-void updateGlobalSpillFillTime(uint64_t timeUs);
-/// Updates the time spent on sorting rows to spill.
-void updateGlobalSpillSortTime(uint64_t timeUs);
-/// Updates the stats for disk write including the number of disk writes,
-/// the written bytes, the time spent on copying out (compression) for disk
-/// writes, the time spent on disk writes.
-void updateGlobalSpillWriteStats(
-    uint32_t numDiskWrites,
-    uint64_t spilledBytes,
-    uint64_t flushTimeUs,
-    uint64_t writeTimeUs);
-// Increment the spill memory bytes.
-void updateGlobalSpillMemoryBytes(uint64_t spilledInputBytes);
-
-/// Increments the spilled files by one.
-void incrementGlobalSpilledFiles();
-
-/// Gets the cumulative global spill stats.
-SpillStats globalSpillStats();
+/// Scoped spill percentage utility that allows user to set the behavior of
+/// triggered spill.
+/// 'spillPct' indicates the chance of triggering spilling. 100% means spill
+/// will always be triggered.
+/// 'pools' is a regular expression string used to define the specific memory
+/// pools targeted for injecting spilling.
+/// 'maxInjections' indicates the max number of actual triggering. e.g. when
+/// 'spillPct' is 20 and 'maxInjections' is 10, continuous calls to
+/// testingTriggerSpill(poolName) will keep rolling the dice that has a
+/// chance of 20% triggering until 10 triggers have been invoked.
+class TestScopedSpillInjection {
+ public:
+  explicit TestScopedSpillInjection(
+      int32_t spillPct,
+      const std::string& poolRegExp = ".*",
+      uint32_t maxInjections = std::numeric_limits<uint32_t>::max());
+
+  ~TestScopedSpillInjection();
+};
+
+/// Test utility that returns true if triggered spill is evaluated to happen,
+/// false otherwise.
+bool testingTriggerSpill(const std::string& poolName = "");
+
+tsan_atomic<uint32_t>& injectedSpillCount();
+
+/// Removes empty partitions from given spill partition set.
+void removeEmptyPartitions(SpillPartitionSet& partitionSet);
 } // namespace facebook::velox::exec
 
 // Adding the custom hash for SpillPartitionId to std::hash to make it usable
@@ -727,3 +496,12 @@ struct hash<::facebook::velox::exec::SpillPartitionId> {
   }
 };
 } // namespace std
+
+template <>
+struct fmt::formatter<facebook::velox::exec::SpillPartitionId>
+    : formatter<std::string> {
+  auto format(facebook::velox::exec::SpillPartitionId s, format_context& ctx)
+      const {
+    return formatter<std::string>::format(s.toString(), ctx);
+  }
+};
diff --git a/velox/exec/SpillFile.cpp b/velox/exec/SpillFile.cpp
new file mode 100644
index 0000000000000..0d16005b20f43
--- /dev/null
+++ b/velox/exec/SpillFile.cpp
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/SpillFile.h"
+#include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/file/FileSystems.h"
+
+namespace facebook::velox::exec {
+namespace {
+// Spilling currently uses the default PrestoSerializer which by default
+// serializes timestamp with millisecond precision to maintain compatibility
+// with presto. Since velox's native timestamp implementation supports
+// nanosecond precision, we use this serde option to ensure the serializer
+// preserves precision.
+static const bool kDefaultUseLosslessTimestamp = true;
+} // namespace
+
+std::unique_ptr<SpillWriteFile> SpillWriteFile::create(
+    uint32_t id,
+    const std::string& pathPrefix,
+    const std::string& fileCreateConfig) {
+  return std::unique_ptr<SpillWriteFile>(
+      new SpillWriteFile(id, pathPrefix, fileCreateConfig));
+}
+
+SpillWriteFile::SpillWriteFile(
+    uint32_t id,
+    const std::string& pathPrefix,
+    const std::string& fileCreateConfig)
+    : id_(id), path_(fmt::format("{}-{}", pathPrefix, ordinalCounter_++)) {
+  auto fs = filesystems::getFileSystem(path_, nullptr);
+  file_ = fs->openFileForWrite(
+      path_,
+      filesystems::FileOptions{
+          {{filesystems::FileOptions::kFileCreateConfig.toString(),
+            fileCreateConfig}},
+          nullptr,
+          std::nullopt});
+}
+
+void SpillWriteFile::finish() {
+  VELOX_CHECK_NOT_NULL(file_);
+  size_ = file_->size();
+  file_->close();
+  file_ = nullptr;
+}
+
+uint64_t SpillWriteFile::size() const {
+  if (file_ != nullptr) {
+    return file_->size();
+  }
+  return size_;
+}
+
+uint64_t SpillWriteFile::write(std::unique_ptr<folly::IOBuf> iobuf) {
+  auto writtenBytes = iobuf->computeChainDataLength();
+  file_->append(std::move(iobuf));
+  return writtenBytes;
+}
+
+SpillWriter::SpillWriter(
+    const RowTypePtr& type,
+    const uint32_t numSortKeys,
+    const std::vector<CompareFlags>& sortCompareFlags,
+    common::CompressionKind compressionKind,
+    const std::string& pathPrefix,
+    uint64_t targetFileSize,
+    uint64_t writeBufferSize,
+    const std::string& fileCreateConfig,
+    common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+    memory::MemoryPool* pool,
+    folly::Synchronized<common::SpillStats>* stats)
+    : type_(type),
+      numSortKeys_(numSortKeys),
+      sortCompareFlags_(sortCompareFlags),
+      compressionKind_(compressionKind),
+      pathPrefix_(pathPrefix),
+      targetFileSize_(targetFileSize),
+      writeBufferSize_(writeBufferSize),
+      fileCreateConfig_(fileCreateConfig),
+      updateAndCheckSpillLimitCb_(updateAndCheckSpillLimitCb),
+      pool_(pool),
+      stats_(stats) {
+  // NOTE: if the associated spilling operator has specified the sort
+  // comparison flags, then it must match the number of sorting keys.
+  VELOX_CHECK(
+      sortCompareFlags_.empty() || sortCompareFlags_.size() == numSortKeys_);
+}
+
+SpillWriteFile* SpillWriter::ensureFile() {
+  if ((currentFile_ != nullptr) && (currentFile_->size() > targetFileSize_)) {
+    closeFile();
+  }
+  if (currentFile_ == nullptr) {
+    currentFile_ = SpillWriteFile::create(
+        nextFileId_++,
+        fmt::format("{}-{}", pathPrefix_, finishedFiles_.size()),
+        fileCreateConfig_);
+  }
+  return currentFile_.get();
+}
+
+void SpillWriter::closeFile() {
+  if (currentFile_ == nullptr) {
+    return;
+  }
+  currentFile_->finish();
+  updateSpilledFileStats(currentFile_->size());
+  finishedFiles_.push_back(SpillFileInfo{
+      .id = currentFile_->id(),
+      .type = type_,
+      .path = currentFile_->path(),
+      .size = currentFile_->size(),
+      .numSortKeys = numSortKeys_,
+      .sortFlags = sortCompareFlags_,
+      .compressionKind = compressionKind_});
+  currentFile_.reset();
+}
+
+size_t SpillWriter::numFinishedFiles() const {
+  return finishedFiles_.size();
+}
+
+uint64_t SpillWriter::flush() {
+  if (batch_ == nullptr) {
+    return 0;
+  }
+
+  auto* file = ensureFile();
+  VELOX_CHECK_NOT_NULL(file);
+
+  IOBufOutputStream out(
+      *pool_, nullptr, std::max<int64_t>(64 * 1024, batch_->size()));
+  uint64_t flushTimeNs{0};
+  {
+    NanosecondTimer timer(&flushTimeNs);
+    batch_->flush(&out);
+  }
+  batch_.reset();
+
+  uint64_t writeTimeNs{0};
+  uint64_t writtenBytes{0};
+  auto iobuf = out.getIOBuf();
+  {
+    NanosecondTimer timer(&writeTimeNs);
+    writtenBytes = file->write(std::move(iobuf));
+  }
+  updateWriteStats(writtenBytes, flushTimeNs, writeTimeNs);
+  updateAndCheckSpillLimitCb_(writtenBytes);
+  return writtenBytes;
+}
+
+uint64_t SpillWriter::write(
+    const RowVectorPtr& rows,
+    const folly::Range<IndexRange*>& indices) {
+  checkNotFinished();
+
+  uint64_t timeNs{0};
+  {
+    NanosecondTimer timer(&timeNs);
+    if (batch_ == nullptr) {
+      serializer::presto::PrestoVectorSerde::PrestoOptions options = {
+          kDefaultUseLosslessTimestamp, compressionKind_, true /*nullsFirst*/};
+      batch_ = std::make_unique<VectorStreamGroup>(pool_);
+      batch_->createStreamTree(
+          std::static_pointer_cast<const RowType>(rows->type()),
+          1'000,
+          &options);
+    }
+    batch_->append(rows, indices);
+  }
+  updateAppendStats(rows->size(), timeNs);
+  if (batch_->size() < writeBufferSize_) {
+    return 0;
+  }
+  return flush();
+}
+
+void SpillWriter::updateAppendStats(
+    uint64_t numRows,
+    uint64_t serializationTimeNs) {
+  auto statsLocked = stats_->wlock();
+  statsLocked->spilledRows += numRows;
+  statsLocked->spillSerializationTimeNanos += serializationTimeNs;
+  common::updateGlobalSpillAppendStats(numRows, serializationTimeNs);
+}
+
+void SpillWriter::updateWriteStats(
+    uint64_t spilledBytes,
+    uint64_t flushTimeNs,
+    uint64_t fileWriteTimeNs) {
+  auto statsLocked = stats_->wlock();
+  statsLocked->spilledBytes += spilledBytes;
+  statsLocked->spillFlushTimeNanos += flushTimeNs;
+  statsLocked->spillWriteTimeNanos += fileWriteTimeNs;
+  ++statsLocked->spillWrites;
+  common::updateGlobalSpillWriteStats(
+      spilledBytes, flushTimeNs, fileWriteTimeNs);
+}
+
+void SpillWriter::updateSpilledFileStats(uint64_t fileSize) {
+  ++stats_->wlock()->spilledFiles;
+  addThreadLocalRuntimeStat(
+      "spillFileSize", RuntimeCounter(fileSize, RuntimeCounter::Unit::kBytes));
+  common::incrementGlobalSpilledFiles();
+}
+
+void SpillWriter::finishFile() {
+  checkNotFinished();
+  flush();
+  closeFile();
+  VELOX_CHECK_NULL(currentFile_);
+}
+
+SpillFiles SpillWriter::finish() {
+  checkNotFinished();
+  auto finishGuard = folly::makeGuard([this]() { finished_ = true; });
+
+  finishFile();
+  return std::move(finishedFiles_);
+}
+
+std::vector<std::string> SpillWriter::testingSpilledFilePaths() const {
+  checkNotFinished();
+
+  std::vector<std::string> spilledFilePaths;
+  for (auto& file : finishedFiles_) {
+    spilledFilePaths.push_back(file.path);
+  }
+  if (currentFile_ != nullptr) {
+    spilledFilePaths.push_back(currentFile_->path());
+  }
+  return spilledFilePaths;
+}
+
+std::vector<uint32_t> SpillWriter::testingSpilledFileIds() const {
+  checkNotFinished();
+
+  std::vector<uint32_t> fileIds;
+  for (auto& file : finishedFiles_) {
+    fileIds.push_back(file.id);
+  }
+  if (currentFile_ != nullptr) {
+    fileIds.push_back(currentFile_->id());
+  }
+  return fileIds;
+}
+
+std::unique_ptr<SpillReadFile> SpillReadFile::create(
+    const SpillFileInfo& fileInfo,
+    uint64_t bufferSize,
+    memory::MemoryPool* pool,
+    folly::Synchronized<common::SpillStats>* stats) {
+  return std::unique_ptr<SpillReadFile>(new SpillReadFile(
+      fileInfo.id,
+      fileInfo.path,
+      fileInfo.size,
+      bufferSize,
+      fileInfo.type,
+      fileInfo.numSortKeys,
+      fileInfo.sortFlags,
+      fileInfo.compressionKind,
+      pool,
+      stats));
+}
+
+SpillReadFile::SpillReadFile(
+    uint32_t id,
+    const std::string& path,
+    uint64_t size,
+    uint64_t bufferSize,
+    const RowTypePtr& type,
+    uint32_t numSortKeys,
+    const std::vector<CompareFlags>& sortCompareFlags,
+    common::CompressionKind compressionKind,
+    memory::MemoryPool* pool,
+    folly::Synchronized<common::SpillStats>* stats)
+    : id_(id),
+      path_(path),
+      size_(size),
+      type_(type),
+      numSortKeys_(numSortKeys),
+      sortCompareFlags_(sortCompareFlags),
+      compressionKind_(compressionKind),
+      readOptions_{
+          kDefaultUseLosslessTimestamp,
+          compressionKind_,
+          /*nullsFirst=*/true},
+      pool_(pool),
+      stats_(stats) {
+  auto fs = filesystems::getFileSystem(path_, nullptr);
+  auto file = fs->openFileForRead(path_);
+  input_ = std::make_unique<common::FileInputStream>(
+      std::move(file), bufferSize, pool_);
+}
+
+bool SpillReadFile::nextBatch(RowVectorPtr& rowVector) {
+  if (input_->atEnd()) {
+    recordSpillStats();
+    return false;
+  }
+
+  uint64_t timeNs{0};
+  {
+    NanosecondTimer timer{&timeNs};
+    VectorStreamGroup::read(
+        input_.get(), pool_, type_, &rowVector, &readOptions_);
+  }
+  stats_->wlock()->spillDeserializationTimeNanos += timeNs;
+  common::updateGlobalSpillDeserializationTimeNs(timeNs);
+  return true;
+}
+
+void SpillReadFile::recordSpillStats() {
+  VELOX_CHECK(input_->atEnd());
+  const auto readStats = input_->stats();
+  common::updateGlobalSpillReadStats(
+      readStats.numReads, readStats.readBytes, readStats.readTimeNs);
+  auto lockedSpillStats = stats_->wlock();
+  lockedSpillStats->spillReads += readStats.numReads;
+  lockedSpillStats->spillReadTimeNanos += readStats.readTimeNs;
+  lockedSpillStats->spillReadBytes += readStats.readBytes;
+}
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpillFile.h b/velox/exec/SpillFile.h
new file mode 100644
index 0000000000000..247240262e5ab
--- /dev/null
+++ b/velox/exec/SpillFile.h
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/container/F14Set.h>
+
+#include "velox/common/base/SpillConfig.h"
+#include "velox/common/base/SpillStats.h"
+#include "velox/common/compression/Compression.h"
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileInputStream.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/TreeOfLosers.h"
+#include "velox/exec/UnorderedStreamReader.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec {
+
+/// Represents a spill file for writing the serialized spilled data into a disk
+/// file.
+class SpillWriteFile {
+ public:
+  static std::unique_ptr<SpillWriteFile> create(
+      uint32_t id,
+      const std::string& pathPrefix,
+      const std::string& fileCreateConfig);
+
+  uint32_t id() const {
+    return id_;
+  }
+
+  /// Returns the file size in bytes.
+  uint64_t size() const;
+
+  const std::string& path() const {
+    return path_;
+  }
+
+  uint64_t write(std::unique_ptr<folly::IOBuf> iobuf);
+
+  WriteFile* file() {
+    return file_.get();
+  }
+
+  /// Finishes writing and flushes any unwritten data.
+  void finish();
+
+ private:
+  static inline std::atomic<int32_t> ordinalCounter_{0};
+
+  SpillWriteFile(
+      uint32_t id,
+      const std::string& pathPrefix,
+      const std::string& fileCreateConfig);
+
+  // The spill file id which is monotonically increasing and unique for each
+  // associated spill partition.
+  const uint32_t id_;
+  const std::string path_;
+
+  std::unique_ptr<WriteFile> file_;
+  // Byte size of the backing file. Set when finishing writing.
+  uint64_t size_{0};
+};
+
+/// Records info of a finished spill file which is used for read.
+struct SpillFileInfo {
+  uint32_t id;
+  RowTypePtr type;
+  std::string path;
+  /// The file size in bytes.
+  uint64_t size;
+  uint32_t numSortKeys;
+  std::vector<CompareFlags> sortFlags;
+  common::CompressionKind compressionKind;
+};
+
+using SpillFiles = std::vector<SpillFileInfo>;
+
+/// Used to write the spilled data to a sequence of files for one partition. If
+/// data is sorted, each file is sorted. The globally sorted order is produced
+/// by merging the constituent files.
+class SpillWriter {
+ public:
+  /// 'type' is a RowType describing the content. 'numSortKeys' is the number
+  /// of leading columns on which the data is sorted. 'path' is a file path
+  /// prefix. ' 'targetFileSize' is the target byte size of a single file.
+  /// 'writeBufferSize' specifies the size limit of the buffered data before
+  /// write to file. 'fileOptions' specifies the file layout on remote storage
+  /// which is storage system specific. 'pool' is used for buffering and
+  /// constructing the result data read from 'this'. 'stats' is used to collect
+  /// the spill write stats.
+  ///
+  /// When writing sorted spill runs, the caller is responsible for buffering
+  /// and sorting the data. write is called multiple times, followed by flush().
+  SpillWriter(
+      const RowTypePtr& type,
+      const uint32_t numSortKeys,
+      const std::vector<CompareFlags>& sortCompareFlags,
+      common::CompressionKind compressionKind,
+      const std::string& pathPrefix,
+      uint64_t targetFileSize,
+      uint64_t writeBufferSize,
+      const std::string& fileCreateConfig,
+      common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+      memory::MemoryPool* pool,
+      folly::Synchronized<common::SpillStats>* stats);
+
+  /// Adds 'rows' for the positions in 'indices' into 'this'. The indices
+  /// must produce a view where the rows are sorted if sorting is desired.
+  /// Consecutive calls must have sorted data so that the first row of the
+  /// next call is not less than the last row of the previous call.
+  /// Returns the size to write.
+  uint64_t write(
+      const RowVectorPtr& rows,
+      const folly::Range<IndexRange*>& indices);
+
+  /// Closes the current output file if any. Subsequent calls to write will
+  /// start a new one.
+  void finishFile();
+
+  /// Returns the number of current finished files.
+  size_t numFinishedFiles() const;
+
+  /// Finishes this file writer and returns the written spill files info.
+  ///
+  /// NOTE: we don't allow write to a spill writer after t
+  SpillFiles finish();
+
+  std::vector<std::string> testingSpilledFilePaths() const;
+
+  std::vector<uint32_t> testingSpilledFileIds() const;
+
+ private:
+  FOLLY_ALWAYS_INLINE void checkNotFinished() const {
+    VELOX_CHECK(!finished_, "SpillWriter has finished");
+  }
+
+  // Returns an open spill file for write. If there is no open spill file, then
+  // the function creates a new one. If the current open spill file exceeds the
+  // target file size limit, then it first closes the current one and then
+  // creates a new one. 'currentFile_' points to the current open spill file.
+  SpillWriteFile* ensureFile();
+
+  // Closes the current open spill file pointed by 'currentFile_'.
+  void closeFile();
+
+  // Writes data from 'batch_' to the current output file. Returns the actual
+  // written size.
+  uint64_t flush();
+
+  // Invoked to increment the number of spilled files and the file size.
+  void updateSpilledFileStats(uint64_t fileSize);
+
+  // Invoked to update the number of spilled rows.
+  void updateAppendStats(uint64_t numRows, uint64_t serializationTimeUs);
+
+  // Invoked to update the disk write stats.
+  void updateWriteStats(
+      uint64_t spilledBytes,
+      uint64_t flushTimeUs,
+      uint64_t writeTimeUs);
+
+  const RowTypePtr type_;
+  const uint32_t numSortKeys_;
+  const std::vector<CompareFlags> sortCompareFlags_;
+  const common::CompressionKind compressionKind_;
+  const std::string pathPrefix_;
+  const uint64_t targetFileSize_;
+  const uint64_t writeBufferSize_;
+  const std::string fileCreateConfig_;
+
+  // Updates the aggregated spill bytes of this query, and throws if exceeds
+  // the max spill bytes limit.
+  common::UpdateAndCheckSpillLimitCB updateAndCheckSpillLimitCb_;
+  memory::MemoryPool* const pool_;
+  folly::Synchronized<common::SpillStats>* const stats_;
+
+  bool finished_{false};
+  uint32_t nextFileId_{0};
+  std::unique_ptr<VectorStreamGroup> batch_;
+  std::unique_ptr<SpillWriteFile> currentFile_;
+  SpillFiles finishedFiles_;
+};
+
+/// Represents a spill file for read which turns the serialized spilled data on
+/// disk back into a sequence of spilled row vectors.
+///
+/// NOTE: The class will not delete spill file upon destruction, so the user
+/// needs to remove the unused spill files at some point later. For example, a
+/// query Task deletes all the generated spill files in one operation using
+/// rmdir() call.
+class SpillReadFile {
+ public:
+  static std::unique_ptr<SpillReadFile> create(
+      const SpillFileInfo& fileInfo,
+      uint64_t bufferSize,
+      memory::MemoryPool* pool,
+      folly::Synchronized<common::SpillStats>* stats);
+
+  uint32_t id() const {
+    return id_;
+  }
+
+  int32_t numSortKeys() const {
+    return numSortKeys_;
+  }
+
+  const std::vector<CompareFlags>& sortCompareFlags() const {
+    return sortCompareFlags_;
+  }
+
+  bool nextBatch(RowVectorPtr& rowVector);
+
+  /// Returns the file size in bytes.
+  uint64_t size() const {
+    return size_;
+  }
+
+  const std::string& testingFilePath() const {
+    return path_;
+  }
+
+ private:
+  SpillReadFile(
+      uint32_t id,
+      const std::string& path,
+      uint64_t size,
+      uint64_t bufferSize,
+      const RowTypePtr& type,
+      uint32_t numSortKeys,
+      const std::vector<CompareFlags>& sortCompareFlags,
+      common::CompressionKind compressionKind,
+      memory::MemoryPool* pool,
+      folly::Synchronized<common::SpillStats>* stats);
+
+#ifndef VELOX_ENABLE_BACKWARD_COMPATIBILITY
+  // Invoked to record spill read stats at the end of read input.
+  void recordSpillStats();
+#endif
+
+  // The spill file id which is monotonically increasing and unique for each
+  // associated spill partition.
+  const uint32_t id_;
+  const std::string path_;
+  // The file size in bytes.
+  const uint64_t size_;
+  // The data type of spilled data.
+  const RowTypePtr type_;
+  const uint32_t numSortKeys_;
+  const std::vector<CompareFlags> sortCompareFlags_;
+  const common::CompressionKind compressionKind_;
+  const serializer::presto::PrestoVectorSerde::PrestoOptions readOptions_;
+  memory::MemoryPool* const pool_;
+  folly::Synchronized<common::SpillStats>* const stats_;
+
+  std::unique_ptr<common::FileInputStream> input_;
+};
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpillOperatorGroup.cpp b/velox/exec/SpillOperatorGroup.cpp
deleted file mode 100644
index 872be371d1511..0000000000000
--- a/velox/exec/SpillOperatorGroup.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/exec/SpillOperatorGroup.h"
-#include "velox/common/testutil/TestValue.h"
-#include "velox/exec/Operator.h"
-
-using facebook::velox::common::testutil::TestValue;
-
-namespace facebook::velox::exec {
-
-SpillOperatorGroup::State SpillOperatorGroup::state() {
-  std::lock_guard<std::mutex> l(mutex_);
-  return state_;
-}
-
-std::string SpillOperatorGroup::stateName(State state) {
-  switch (state) {
-    case State::kInit:
-      return "INIT";
-    case State::kRunning:
-      return "RUNNING";
-    case State::kStopped:
-      return "STOPPED";
-    default:
-      return fmt::format("UNKNOWN STATE: {}", static_cast<int>(state));
-  }
-}
-
-void SpillOperatorGroup::addOperator(
-    Operator& op,
-    const std::shared_ptr<Driver>& driver,
-    SpillOperatorGroup::SpillRunner runner) {
-  VELOX_CHECK_NOT_NULL(runner);
-  std::lock_guard<std::mutex> l(mutex_);
-  VELOX_CHECK_EQ(
-      state_,
-      State::kInit,
-      "Can only add an operator before group starts: {}",
-      toStringLocked());
-  operators_.push_back(&op);
-  drivers_.push_back(driver);
-  VELOX_CHECK_EQ(operators_.size(), drivers_.size());
-  // Set 'spillRunner_' to the callback provided by the first added operator.
-  if (spillRunner_ == nullptr) {
-    spillRunner_ = std::move(runner);
-  }
-}
-
-void SpillOperatorGroup::operatorStopped(const Operator& op) {
-  std::vector<ContinuePromise> promises;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    VELOX_CHECK_EQ(
-        state_,
-        State::kRunning,
-        "Can only stop an operator when group is running: {}",
-        toStringLocked());
-    VELOX_CHECK(!stoppedOperators_.contains(&op));
-    stoppedOperators_.insert(&op);
-    VELOX_CHECK_LE(stoppedOperators_.size(), operators_.size());
-    if (stoppedOperators_.size() == operators_.size()) {
-      state_ = State::kStopped;
-      checkStoppedStateLocked();
-      return;
-    }
-    if (!needSpill_) {
-      return;
-    }
-    // NOTE: the stopping operator doesn't need to wait for spill to run.
-    if (numWaitingOperators_ < numActiveOperatorsLocked()) {
-      return;
-    }
-    promises = std::move(promises_);
-  }
-  runSpill(promises);
-}
-
-void SpillOperatorGroup::start() {
-  std::lock_guard<std::mutex> l(mutex_);
-  VELOX_CHECK_EQ(
-      state_,
-      State::kInit,
-      "Can only start a group once: {}",
-      toStringLocked());
-  state_ = State::kRunning;
-}
-
-void SpillOperatorGroup::restart() {
-  std::lock_guard<std::mutex> l(mutex_);
-  VELOX_CHECK_EQ(
-      state_,
-      State::kStopped,
-      "Can only restart a stopped group: {}",
-      toStringLocked());
-  checkStoppedStateLocked();
-  stoppedOperators_.clear();
-  state_ = State::kRunning;
-}
-
-bool SpillOperatorGroup::requestSpill(Operator& op, ContinueFuture& future) {
-  std::vector<ContinuePromise> promises;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    VELOX_CHECK_EQ(
-        state_,
-        State::kRunning,
-        "Can only request spill when group is running: {}",
-        toStringLocked());
-    VELOX_CHECK_LT(numWaitingOperators_, numActiveOperatorsLocked());
-    VELOX_CHECK_LT(stoppedOperators_.size(), operators_.size());
-    needSpill_ = true;
-    if (waitSpillLocked(op, promises, future)) {
-      VELOX_CHECK(future.valid());
-      return true;
-    }
-  }
-  runSpill(promises);
-  return false;
-}
-
-bool SpillOperatorGroup::waitSpill(Operator& op, ContinueFuture& future) {
-  std::vector<ContinuePromise> promises;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    VELOX_CHECK_EQ(
-        state_,
-        State::kRunning,
-        "Can only wait spill when group is running: {}",
-        toStringLocked());
-    VELOX_CHECK_LT(stoppedOperators_.size(), operators_.size());
-    if (!needSpill_) {
-      VELOX_CHECK_EQ(numWaitingOperators_, 0);
-      return false;
-    }
-    if (waitSpillLocked(op, promises, future)) {
-      return true;
-    }
-  }
-  runSpill(promises);
-  return false;
-}
-
-bool SpillOperatorGroup::waitSpillLocked(
-    Operator& op,
-    std::vector<ContinuePromise>& promises,
-    ContinueFuture& future) {
-  VELOX_CHECK_LT(numWaitingOperators_, numActiveOperatorsLocked());
-  if (++numWaitingOperators_ == numActiveOperatorsLocked()) {
-    promises = std::move(promises_);
-    return false;
-  }
-  promises_.emplace_back(ContinuePromise(fmt::format(
-      "SpillOperatorGroup::waitSpillLocked {}/{}/{}/{}",
-      taskId_,
-      planNodeId_,
-      splitGroupId_,
-      op.operatorId())));
-  future = promises_.back().getSemiFuture();
-  return true;
-}
-
-void SpillOperatorGroup::runSpill(std::vector<ContinuePromise>& promises) {
-  TestValue::adjust(
-      "facebook::velox::exec::SpillOperatorGroup::runSpill", this);
-
-  VELOX_CHECK(needSpill_);
-  auto guard = folly::makeGuard([&]() {
-    {
-      std::lock_guard<std::mutex> l(mutex_);
-      VELOX_CHECK_EQ(
-          state_,
-          State::kRunning,
-          "Can only run spill when group is running: {}",
-          toStringLocked());
-      needSpill_ = false;
-      numWaitingOperators_ = 0;
-    }
-    for (auto& promise : promises) {
-      promise.setValue();
-    }
-  });
-
-  std::vector<std::shared_ptr<Driver>> holders = ensureDrivers();
-  spillRunner_(operators_);
-}
-
-std::vector<std::shared_ptr<Driver>> SpillOperatorGroup::ensureDrivers() {
-  std::vector<std::shared_ptr<Driver>> holders;
-  holders.reserve(drivers_.size());
-  for (auto& driver : drivers_) {
-    auto holder = driver.lock();
-    // NOTE: if some driver has gone, the associated query task should have been
-    // terminated so no need to run spilling.
-    VELOX_CHECK_NOT_NULL(holder, "Task has already terminated");
-    holders.push_back(std::move(holder));
-  }
-  return holders;
-}
-
-void SpillOperatorGroup::checkStoppedStateLocked() const {
-  CHECK_EQ(state_, State::kStopped);
-  VELOX_CHECK_EQ(stoppedOperators_.size(), operators_.size());
-  // Reset this coordinator state if all the participated operators have
-  // finished memory intensive operations and won't trigger any more spill.
-  VELOX_CHECK(!needSpill_);
-  VELOX_CHECK_EQ(numWaitingOperators_, 0);
-  VELOX_CHECK(promises_.empty());
-}
-
-std::string SpillOperatorGroup::toStringLocked() const {
-  return fmt::format(
-      "[STATE:{}, NUM_OPS:{}, NUM_WAITING_OPS:{}, NUM_STOPPED_OPS:{}]",
-      stateName(state_),
-      operators_.size(),
-      numWaitingOperators_,
-      stoppedOperators_.size());
-}
-
-} // namespace facebook::velox::exec
diff --git a/velox/exec/SpillOperatorGroup.h b/velox/exec/SpillOperatorGroup.h
deleted file mode 100644
index 1a5d08b19a635..0000000000000
--- a/velox/exec/SpillOperatorGroup.h
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <folly/container/F14Set.h>
-#include <stdint.h>
-#include <functional>
-#include "velox/core/PlanNode.h"
-
-namespace facebook::velox::exec {
-
-class Operator;
-class Driver;
-
-/// Used to coordinate the disk spill operation among multiple operator
-/// instances of the same plan node within a task (split group). Take hash
-/// build for example, when any one of the build operator needs to spill, then
-/// all its peer operators' drivers will stop execution for spill, and one of
-/// them will be selected (the last one reaches to group spill barrier) as the
-/// coordinator to run spill on all the operators, and then resume all the
-/// driver executions after that.
-///
-/// NOTE: as for now, only hash build operators needs to group spill
-/// coordination.
-class SpillOperatorGroup {
- public:
-  /// Define the internal execution state of a spill group. The valid state
-  /// transition is depicted as below:
-  ///
-  ///       kInit --->  kRunning  --->  kStopped
-  ///                      ^               |
-  ///                      |               v
-  ///                      +---------------+
-  ///
-  enum class State {
-    kInit = 0,
-    kRunning = 1,
-    kStopped = 2,
-  };
-  static std::string stateName(State state);
-
-  SpillOperatorGroup(
-      const std::string taskId,
-      const uint32_t splitGroupId,
-      const core::PlanNodeId& planNodeId)
-      : taskId_(taskId),
-        splitGroupId_(splitGroupId),
-        planNodeId_(planNodeId),
-        state_(State::kInit) {}
-
-  State state();
-
-  using SpillRunner = std::function<void(const std::vector<Operator*>& ops)>;
-
-  /// Invoked by an operator on construction to add to this spill group.
-  /// 'spillRunner' is the operator specific callback to run spill on the
-  /// group of operators together.
-  ///
-  /// NOTE: the group of operators are instantiated from the same plan node in a
-  /// task pipeline, such as all the build operators for a hash join node.
-  void addOperator(
-      Operator& op,
-      const std::shared_ptr<Driver>& driver,
-      SpillRunner spillRunner);
-
-  /// Invoked to indicate a driver won't trigger any more spill request and
-  /// it will also not involve in the future group spill operation. The function
-  /// will put this 'op' into 'stoppedOperators_'. This function will also help
-  /// to check if the group spill is ready to run if there is a pending one.
-  void operatorStopped(const Operator& op);
-
-  /// Invoked by the task framework to start this spilling group, and the
-  /// operator needs to add to a group before it is started.
-  void start();
-
-  /// Invoked to restart this spill group to support recursive spilling. For
-  /// example, the hassh build operator might need to trigger recursive spilling
-  /// while building the hash table from a previously spilled partition.
-  ///
-  /// NOTE: a spill group will be stopped after all the operators call
-  /// 'operatorStopped()' to indicates that there will be no more spill request
-  /// from that operator. For example, a hash build operator will call
-  /// 'operatorStopped()' after finishing build the hash table as there will be
-  /// no more memory consumption after that.
-  void restart();
-
-  /// Indicates if this group needs spill or not.
-  bool needSpill() const {
-    return needSpill_;
-  }
-
-  /// Invoked to request a new spill operation on the group. The function
-  /// returns true if it needs to wait for spill to run, otherwise the spill has
-  /// been inline executed and returns false.
-  bool requestSpill(Operator& op, ContinueFuture& future);
-
-  /// Invoked to check if 'op' needs to wait for any pending group spill to run.
-  /// The function returns true if it needs to wait, otherwise it returns false.
-  /// The latter case is either because there is no pending spill or 'op' is the
-  /// last one that reaches to the spill barrier and has inline executed the
-  /// spill for the group.
-  bool waitSpill(Operator& op, ContinueFuture& future);
-
- private:
-  void checkStoppedStateLocked() const;
-
-  // Return the number of non-stopped operators which includes both running and
-  // waiting ones.
-  uint32_t numActiveOperatorsLocked() const {
-    return operators_.size() - stoppedOperators_.size();
-  }
-
-  // Invoked to run spill runner callback on all the spill operators, and after
-  // that the function will also resume the waiting operators' executions by
-  // fulfilling 'promises'.
-  void runSpill(std::vector<ContinuePromise>& promises);
-
-  // Invoked to grab a shared reference to each operator driver to ensure all
-  // the participating operators alive while running spilling. The function
-  // throws if it fails to get the shared reference to any one of the operator
-  // driver. The latter could only happen if the associated query task has
-  // failed, and there is no need to run spilling in that case.
-  std::vector<std::shared_ptr<Driver>> ensureDrivers();
-
-  bool waitSpillLocked(
-      Operator& op,
-      std::vector<ContinuePromise>& promises,
-      ContinueFuture& future);
-
-  std::string toStringLocked() const;
-
-  const std::string taskId_;
-  const uint32_t splitGroupId_;
-  const core::PlanNodeId planNodeId_;
-
-  std::mutex mutex_;
-  State state_;
-
-  // The participating spill operators which won't change after starts the
-  // group.
-  std::vector<Operator*> operators_;
-  // Used to hold the shared reference on the associated drivers to keep the
-  // operators alive while running spilling.
-  std::vector<std::weak_ptr<Driver>> drivers_;
-  // Invoked to run spill on all 'operators_' no matter it has stopped or not.
-  SpillRunner spillRunner_;
-
-  // Indicates if the group needs to spill or not.
-  std::atomic<bool> needSpill_{false};
-
-  // Counts the number of operators to wait for the pending spill to run. Once
-  // the counter matches the number of non-stopped operators, then the last
-  // wait operator will act as the coordinator to run the spill for all the
-  // operators.
-  int32_t numWaitingOperators_{0};
-
-  // The promises created for each waiting spill operator except the last one.
-  std::vector<ContinuePromise> promises_;
-
-  // The set of stopped operators which will not trigger any more spill
-  // operation such as hash build operators which have finished the table build.
-  //
-  // NOTE: once all the operators in the group have been stopped, then the group
-  // will transit to STOPPED state until it has been restarted. The set will be
-  // also been cleared by the group restart. A spill group will be restarted to
-  // support recursive spill operation as required by hash join build.
-  folly::F14FastSet<const Operator*> stoppedOperators_;
-};
-
-inline std::ostream& operator<<(
-    std::ostream& os,
-    SpillOperatorGroup::State state) {
-  os << SpillOperatorGroup::stateName(state);
-  return os;
-}
-
-} // namespace facebook::velox::exec
diff --git a/velox/exec/Spiller.cpp b/velox/exec/Spiller.cpp
index 95d3296a895dd..eee401a4e70b9 100644
--- a/velox/exec/Spiller.cpp
+++ b/velox/exec/Spiller.cpp
@@ -17,15 +17,16 @@
 #include "velox/exec/Spiller.h"
 #include <folly/ScopeGuard.h>
 #include "velox/common/base/AsyncSource.h"
+#include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/exec/Aggregate.h"
+#include "velox/exec/HashJoinBridge.h"
+#include "velox/external/timsort/TimSort.hpp"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
 namespace {
-constexpr int32_t kLogEveryN = 32;
-
 #define CHECK_NOT_FINALIZED() \
   VELOX_CHECK(!finalized_, "Spiller has been finalized")
 
@@ -36,61 +37,99 @@ constexpr int32_t kLogEveryN = 32;
 Spiller::Spiller(
     Type type,
     RowContainer* container,
-    RowContainer::Eraser eraser,
     RowTypePtr rowType,
     int32_t numSortingKeys,
     const std::vector<CompareFlags>& sortCompareFlags,
-    const std::string& path,
-    uint64_t targetFileSize,
-    uint64_t writeBufferSize,
-    uint64_t minSpillRunSize,
-    common::CompressionKind compressionKind,
-    memory::MemoryPool* pool,
-    folly::Executor* executor)
+    const common::SpillConfig* spillConfig,
+    folly::Synchronized<common::SpillStats>* spillStats)
     : Spiller(
           type,
           container,
-          eraser,
           std::move(rowType),
           HashBitRange{},
           numSortingKeys,
           sortCompareFlags,
-          path,
-          targetFileSize,
-          writeBufferSize,
-          minSpillRunSize,
-          compressionKind,
-          pool,
-          executor) {
-  VELOX_CHECK_EQ(type_, Type::kOrderBy);
+          false,
+          spillConfig->getSpillDirPathCb,
+          spillConfig->updateAndCheckSpillLimitCb,
+          spillConfig->fileNamePrefix,
+          std::numeric_limits<uint64_t>::max(),
+          spillConfig->writeBufferSize,
+          spillConfig->compressionKind,
+          spillConfig->executor,
+          spillConfig->maxSpillRunRows,
+          spillConfig->fileCreateConfig,
+          spillStats) {
+  VELOX_CHECK_EQ(
+      type_,
+      Type::kOrderByInput,
+      "Unexpected spiller type: {}",
+      typeName(type_));
+  VELOX_CHECK_EQ(state_.maxPartitions(), 1);
 }
 
 Spiller::Spiller(
     Type type,
     RowContainer* container,
-    RowContainer::Eraser eraser,
     RowTypePtr rowType,
-    const std::string& path,
-    uint64_t writeBufferSize,
-    common::CompressionKind compressionKind,
-    memory::MemoryPool* pool,
-    folly::Executor* executor)
+    const HashBitRange& hashBitRange,
+    int32_t numSortingKeys,
+    const std::vector<CompareFlags>& sortCompareFlags,
+    const common::SpillConfig* spillConfig,
+    folly::Synchronized<common::SpillStats>* spillStats)
+    : Spiller(
+          type,
+          container,
+          std::move(rowType),
+          hashBitRange,
+          numSortingKeys,
+          sortCompareFlags,
+          false,
+          spillConfig->getSpillDirPathCb,
+          spillConfig->updateAndCheckSpillLimitCb,
+          spillConfig->fileNamePrefix,
+          std::numeric_limits<uint64_t>::max(),
+          spillConfig->writeBufferSize,
+          spillConfig->compressionKind,
+          spillConfig->executor,
+          spillConfig->maxSpillRunRows,
+          spillConfig->fileCreateConfig,
+          spillStats) {
+  VELOX_CHECK(
+      type_ == Type::kOrderByInput || type_ == Type::kAggregateInput,
+      "Unexpected spiller type: {}",
+      typeName(type_));
+  VELOX_CHECK_EQ(state_.targetFileSize(), std::numeric_limits<uint64_t>::max());
+}
+
+Spiller::Spiller(
+    Type type,
+    RowContainer* container,
+    RowTypePtr rowType,
+    const common::SpillConfig* spillConfig,
+    folly::Synchronized<common::SpillStats>* spillStats)
     : Spiller(
           type,
           container,
-          std::move(eraser),
           std::move(rowType),
           HashBitRange{},
           0,
           {},
-          path,
+          false,
+          spillConfig->getSpillDirPathCb,
+          spillConfig->updateAndCheckSpillLimitCb,
+          spillConfig->fileNamePrefix,
           std::numeric_limits<uint64_t>::max(),
-          writeBufferSize,
-          0,
-          compressionKind,
-          pool,
-          executor) {
-  VELOX_CHECK_EQ(type, Type::kAggregateOutput);
+          spillConfig->writeBufferSize,
+          spillConfig->compressionKind,
+          spillConfig->executor,
+          spillConfig->maxSpillRunRows,
+          spillConfig->fileCreateConfig,
+          spillStats) {
+  VELOX_CHECK(
+      type_ == Type::kAggregateOutput || type_ == Type::kOrderByOutput,
+      "Unexpected spiller type: {}",
+      typeName(type_));
   VELOX_CHECK_EQ(state_.maxPartitions(), 1);
   VELOX_CHECK_EQ(state_.targetFileSize(), std::numeric_limits<uint64_t>::max());
 }
@@ -99,97 +138,164 @@ Spiller::Spiller(
     Type type,
     RowTypePtr rowType,
     HashBitRange bits,
-    const std::string& path,
-    uint64_t targetFileSize,
-    uint64_t writeBufferSize,
-    uint64_t minSpillRunSize,
-    common::CompressionKind compressionKind,
-    memory::MemoryPool* pool,
-    folly::Executor* executor)
+    const common::SpillConfig* spillConfig,
+    folly::Synchronized<common::SpillStats>* spillStats)
     : Spiller(
           type,
           nullptr,
-          nullptr,
           std::move(rowType),
           bits,
           0,
           {},
-          path,
-          targetFileSize,
-          writeBufferSize,
-          minSpillRunSize,
-          compressionKind,
-          pool,
-          executor) {
-  VELOX_CHECK_EQ(type_, Type::kHashJoinProbe);
+          false,
+          spillConfig->getSpillDirPathCb,
+          spillConfig->updateAndCheckSpillLimitCb,
+          spillConfig->fileNamePrefix,
+          spillConfig->maxFileSize,
+          spillConfig->writeBufferSize,
+          spillConfig->compressionKind,
+          spillConfig->executor,
+          0,
+          spillConfig->fileCreateConfig,
+          spillStats) {
+  VELOX_CHECK_EQ(
+      type_,
+      Type::kHashJoinProbe,
+      "Unexpected spiller type: {}",
+      typeName(type_));
+}
+
+Spiller::Spiller(
+    Type type,
+    core::JoinType joinType,
+    RowContainer* container,
+    RowTypePtr rowType,
+    HashBitRange bits,
+    const common::SpillConfig* spillConfig,
+    folly::Synchronized<common::SpillStats>* spillStats)
+    : Spiller(
+          type,
+          container,
+          std::move(rowType),
+          bits,
+          0,
+          {},
+          needRightSideJoin(joinType),
+          spillConfig->getSpillDirPathCb,
+          spillConfig->updateAndCheckSpillLimitCb,
+          spillConfig->fileNamePrefix,
+          spillConfig->maxFileSize,
+          spillConfig->writeBufferSize,
+          spillConfig->compressionKind,
+          spillConfig->executor,
+          spillConfig->maxSpillRunRows,
+          spillConfig->fileCreateConfig,
+          spillStats) {
+  VELOX_CHECK_EQ(type_, Type::kHashJoinBuild);
+  VELOX_CHECK(isHashJoinTableSpillType(rowType_, joinType));
+}
+
+Spiller::Spiller(
+    Type type,
+    RowContainer* container,
+    RowTypePtr rowType,
+    HashBitRange bits,
+    const common::SpillConfig* spillConfig,
+    folly::Synchronized<common::SpillStats>* spillStats)
+    : Spiller(
+          type,
+          container,
+          std::move(rowType),
+          bits,
+          0,
+          {},
+          false,
+          spillConfig->getSpillDirPathCb,
+          spillConfig->updateAndCheckSpillLimitCb,
+          spillConfig->fileNamePrefix,
+          spillConfig->maxFileSize,
+          spillConfig->writeBufferSize,
+          spillConfig->compressionKind,
+          spillConfig->executor,
+          spillConfig->maxSpillRunRows,
+          spillConfig->fileCreateConfig,
+          spillStats) {
+  VELOX_CHECK_EQ(type_, Type::kRowNumber);
 }
 
 Spiller::Spiller(
     Type type,
     RowContainer* container,
-    RowContainer::Eraser eraser,
     RowTypePtr rowType,
     HashBitRange bits,
     int32_t numSortingKeys,
     const std::vector<CompareFlags>& sortCompareFlags,
-    const std::string& path,
+    bool recordProbedFlag,
+    const common::GetSpillDirectoryPathCB& getSpillDirPathCb,
+    const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+    const std::string& fileNamePrefix,
     uint64_t targetFileSize,
     uint64_t writeBufferSize,
-    uint64_t minSpillRunSize,
     common::CompressionKind compressionKind,
-    memory::MemoryPool* pool,
-    folly::Executor* executor)
+    folly::Executor* executor,
+    uint64_t maxSpillRunRows,
+    const std::string& fileCreateConfig,
+    folly::Synchronized<common::SpillStats>* spillStats)
     : type_(type),
       container_(container),
       executor_(executor),
-      pool_(pool),
-      eraser_(eraser),
       bits_(bits),
       rowType_(std::move(rowType)),
-      minSpillRunSize_(minSpillRunSize),
+      spillProbedFlag_(recordProbedFlag),
+      maxSpillRunRows_(maxSpillRunRows),
+      spillStats_(spillStats),
       state_(
-          path,
+          getSpillDirPathCb,
+          updateAndCheckSpillLimitCb,
+          fileNamePrefix,
           bits.numPartitions(),
           numSortingKeys,
           sortCompareFlags,
           targetFileSize,
           writeBufferSize,
           compressionKind,
-          pool_,
-          &stats_) {
-  TestValue::adjust(
-      "facebook::velox::exec::Spiller", const_cast<HashBitRange*>(&bits_));
+          memory::spillMemoryPool(),
+          spillStats,
+          fileCreateConfig) {
+  TestValue::adjust("facebook::velox::exec::Spiller", this);
 
+  VELOX_CHECK(!spillProbedFlag_ || type_ == Type::kHashJoinBuild);
   VELOX_CHECK_EQ(container_ == nullptr, type_ == Type::kHashJoinProbe);
-  // kOrderBy spiller type must only have one partition.
-  VELOX_CHECK(
-      (type_ != Type::kOrderBy && type_ != Type::kAggregateOutput) ||
-      (state_.maxPartitions() == 1));
   spillRuns_.reserve(state_.maxPartitions());
   for (int i = 0; i < state_.maxPartitions(); ++i) {
-    spillRuns_.emplace_back(*pool_);
+    spillRuns_.emplace_back(*memory::spillMemoryPool());
   }
 }
 
 void Spiller::extractSpill(folly::Range<char**> rows, RowVectorPtr& resultPtr) {
-  if (!resultPtr) {
-    resultPtr = BaseVector::create<RowVector>(rowType_, rows.size(), pool());
+  if (resultPtr == nullptr) {
+    resultPtr = BaseVector::create<RowVector>(
+        rowType_, rows.size(), memory::spillMemoryPool());
   } else {
     resultPtr->prepareForReuse();
     resultPtr->resize(rows.size());
   }
-  auto result = resultPtr.get();
-  auto& types = container_->columnTypes();
+
+  auto* result = resultPtr.get();
+  const auto& types = container_->columnTypes();
   for (auto i = 0; i < types.size(); ++i) {
     container_->extractColumn(rows.data(), rows.size(), i, result->childAt(i));
   }
-
-  auto& accumulators = container_->accumulators();
-
-  auto numKeys = types.size();
+  const auto& accumulators = container_->accumulators();
+  column_index_t accumulatorColumnOffset = types.size();
+  if (spillProbedFlag_) {
+    container_->extractProbedFlags(
+        rows.data(), rows.size(), false, false, result->childAt(types.size()));
+    ++accumulatorColumnOffset;
+  }
   for (auto i = 0; i < accumulators.size(); ++i) {
-    accumulators[i].aggregateForSpill()->extractAccumulators(
-        rows.data(), rows.size(), &result->childAt(i + numKeys));
+    accumulators[i].extractForSpill(
+        rows, result->childAt(i + accumulatorColumnOffset));
   }
 }
 
@@ -202,7 +308,7 @@ int64_t Spiller::extractSpillVector(
   VELOX_CHECK_NE(type_, Type::kHashJoinProbe);
 
   auto limit = std::min<size_t>(rows.size() - nextBatchIndex, maxRows);
-  assert(!rows.empty());
+  VELOX_CHECK(!rows.empty());
   int32_t numRows = 0;
   int64_t bytes = 0;
   for (; numRows < limit; ++numRows) {
@@ -228,11 +334,11 @@ namespace {
 class RowContainerSpillMergeStream : public SpillMergeStream {
  public:
   RowContainerSpillMergeStream(
-      int32_t numSortingKeys,
+      int32_t numSortKeys,
       const std::vector<CompareFlags>& sortCompareFlags,
       Spiller::SpillRows&& rows,
       Spiller& spiller)
-      : numSortingKeys_(numSortingKeys),
+      : numSortKeys_(numSortKeys),
         sortCompareFlags_(sortCompareFlags),
         rows_(std::move(rows)),
         spiller_(spiller) {
@@ -241,9 +347,15 @@ class RowContainerSpillMergeStream : public SpillMergeStream {
     }
   }
 
+  uint32_t id() const override {
+    // Returns the max uint32_t as the special id for in-memory spill merge
+    // stream.
+    return std::numeric_limits<uint32_t>::max();
+  }
+
  private:
-  int32_t numSortingKeys() const override {
-    return numSortingKeys_;
+  int32_t numSortKeys() const override {
+    return numSortKeys_;
   }
 
   const std::vector<CompareFlags>& sortCompareFlags() const override {
@@ -267,7 +379,7 @@ class RowContainerSpillMergeStream : public SpillMergeStream {
     index_ = 0;
   }
 
-  const int32_t numSortingKeys_;
+  const int32_t numSortKeys_;
   const std::vector<CompareFlags> sortCompareFlags_;
 
   Spiller::SpillRows rows_;
@@ -298,10 +410,14 @@ std::unique_ptr<SpillMergeStream> Spiller::spillMergeStreamOverRows(
 
 void Spiller::ensureSorted(SpillRun& run) {
   // The spill data of a hash join doesn't need to be sorted.
-  uint64_t sortTimeUs{0};
-  if (!run.sorted && needSort()) {
-    MicrosecondTimer timer(&sortTimeUs);
-    std::sort(
+  if (run.sorted || !needSort()) {
+    return;
+  }
+
+  uint64_t sortTimeNs{0};
+  {
+    NanosecondTimer timer(&sortTimeNs);
+    gfx::timsort(
         run.rows.begin(),
         run.rows.end(),
         [&](const char* left, const char* right) {
@@ -310,14 +426,14 @@ void Spiller::ensureSorted(SpillRun& run) {
         });
     run.sorted = true;
   }
-  if (sortTimeUs != 0) {
-    updateSpillSortTime(sortTimeUs);
-  }
+
+  // NOTE: Always set a non-zero sort time to avoid flakiness in tests which
+  // check sort time.
+  updateSpillSortTime(std::max<uint64_t>(1, sortTimeNs));
 }
 
 std::unique_ptr<Spiller::SpillStatus> Spiller::writeSpill(int32_t partition) {
   VELOX_CHECK_NE(type_, Type::kHashJoinProbe);
-  VELOX_CHECK_EQ(pendingSpillPartitions_.count(partition), 1);
   // Target size of a single vector of spilled content. One of
   // these will be materialized at a time for each stream of the
   // merge.
@@ -335,11 +451,12 @@ std::unique_ptr<Spiller::SpillStatus> Spiller::writeSpill(int32_t partition) {
           run.rows, kTargetBatchRows, kTargetBatchBytes, spillVector, written);
       totalBytes += state_.appendToPartition(partition, spillVector);
       if (totalBytes > state_.targetFileSize()) {
-        break;
+        VELOX_CHECK(!needSort());
+        state_.finishFile(partition);
       }
     }
     return std::make_unique<SpillStatus>(partition, written, nullptr);
-  } catch (const std::exception& e) {
+  } catch (const std::exception&) {
     // The exception is passed to the caller thread which checks this in
     // advanceSpill().
     return std::make_unique<SpillStatus>(
@@ -347,15 +464,22 @@ std::unique_ptr<Spiller::SpillStatus> Spiller::writeSpill(int32_t partition) {
   }
 }
 
-void Spiller::advanceSpill() {
+void Spiller::runSpill(bool lastRun) {
+  ++spillStats_->wlock()->spillRuns;
+  VELOX_CHECK(type_ != Spiller::Type::kOrderByOutput || lastRun);
+
   std::vector<std::shared_ptr<AsyncSource<SpillStatus>>> writes;
   for (auto partition = 0; partition < spillRuns_.size(); ++partition) {
-    if (pendingSpillPartitions_.count(partition) == 0) {
+    VELOX_CHECK(
+        state_.isPartitionSpilled(partition),
+        "Partition {} is not marked as spilled",
+        partition);
+    if (spillRuns_[partition].rows.empty()) {
       continue;
     }
-    writes.push_back(std::make_shared<AsyncSource<SpillStatus>>(
+    writes.push_back(memory::createAsyncMemoryReclaimTask<SpillStatus>(
         [partition, this]() { return writeSpill(partition); }));
-    if (executor_) {
+    if ((writes.size() > 1) && executor_ != nullptr) {
       executor_->add([source = writes.back()]() { source->prepare(); });
     }
   }
@@ -366,7 +490,7 @@ void Spiller::advanceSpill() {
       // already captured before this runs.
       try {
         write->move();
-      } catch (const std::exception& e) {
+      } catch (const std::exception&) {
       }
     }
   });
@@ -377,165 +501,110 @@ void Spiller::advanceSpill() {
     results.push_back(write->move());
   }
   for (auto& result : results) {
-    if (result->error) {
+    if (result->error != nullptr) {
       std::rethrow_exception(result->error);
     }
     const auto numWritten = result->rowsWritten;
     auto partition = result->partition;
     auto& run = spillRuns_[partition];
-    auto spilled = folly::Range<char**>(run.rows.data(), numWritten);
-    eraser_(spilled);
-    if (!container_->numRows()) {
-      // If the container became empty, free its memory.
-      container_->clear();
+    VELOX_CHECK_EQ(numWritten, run.rows.size());
+    run.clear();
+    // When a sorted run ends, we start with a new file next time.
+    if (needSort()) {
+      state_.finishFile(partition);
     }
-    run.rows.erase(run.rows.begin(), run.rows.begin() + numWritten);
-    if (run.rows.empty()) {
-      run.clear();
-      // When a sorted run ends, we start with a new file next time. For
-      // aggregation output spiller, we expect only one spill call to spill all
-      // the rows starting from the specified row offset.
-      if (needSort() || (type_ == Spiller::Type::kAggregateOutput)) {
-        state_.finishWrite(partition);
-      }
-      pendingSpillPartitions_.erase(partition);
+  }
+
+  // For aggregation output / orderby output spiller, we expect only one spill
+  // call to spill all the rows starting from the specified row offset.
+  if (lastRun &&
+      (type_ == Spiller::Type::kAggregateOutput ||
+       type_ == Spiller::Type::kOrderByOutput)) {
+    for (auto partition = 0; partition < spillRuns_.size(); ++partition) {
+      state_.finishFile(partition);
     }
   }
 }
 
-void Spiller::updateSpillFillTime(uint64_t timeUs) {
-  stats_.wlock()->spillFillTimeUs += timeUs;
-  updateGlobalSpillFillTime(timeUs);
+void Spiller::updateSpillFillTime(uint64_t timeNs) {
+  spillStats_->wlock()->spillFillTimeNanos += timeNs;
+  common::updateGlobalSpillFillTime(timeNs);
 }
 
-void Spiller::updateSpillSortTime(uint64_t timeUs) {
-  stats_.wlock()->spillSortTimeUs += timeUs;
-  updateGlobalSpillSortTime(timeUs);
+void Spiller::updateSpillSortTime(uint64_t timeNs) {
+  spillStats_->wlock()->spillSortTimeNanos += timeNs;
+  common::updateGlobalSpillSortTime(timeNs);
 }
 
 bool Spiller::needSort() const {
   return type_ != Type::kHashJoinProbe && type_ != Type::kHashJoinBuild &&
-      type_ != Type::kAggregateOutput;
+      type_ != Type::kRowNumber && type_ != Type::kAggregateOutput &&
+      type_ != Type::kOrderByOutput;
 }
 
-void Spiller::spill(uint64_t targetRows, uint64_t targetBytes) {
-  return spill(targetRows, targetBytes, nullptr);
+void Spiller::spill() {
+  return spill(nullptr);
 }
 
 void Spiller::spill(const RowContainerIterator& startRowIter) {
-  return spill(0, 0, &startRowIter);
+  VELOX_CHECK_EQ(type_, Type::kAggregateOutput);
+  return spill(&startRowIter);
 }
 
-void Spiller::spill(
-    uint64_t targetRows,
-    uint64_t targetBytes,
-    const RowContainerIterator* startRowIter) {
+void Spiller::spill(const RowContainerIterator* startRowIter) {
   CHECK_NOT_FINALIZED();
+  VELOX_CHECK_NE(type_, Type::kHashJoinProbe);
+  VELOX_CHECK_NE(type_, Type::kOrderByOutput);
 
-  if (type_ == Type::kHashJoinBuild || type_ == Type::kHashJoinProbe) {
-    VELOX_FAIL("Don't support incremental spill on type: {}", typeName(type_));
-  }
+  markAllPartitionsSpilled();
 
-  bool hasFilledRuns = false;
-  for (;;) {
-    auto rowsLeft = container_->numRows();
-    auto spaceLeft = container_->stringAllocator().retainedSize() -
-        container_->stringAllocator().freeSpace();
-    if (rowsLeft == 0 || (rowsLeft <= targetRows && spaceLeft <= targetBytes)) {
-      break;
-    }
-    if (!pendingSpillPartitions_.empty()) {
-      advanceSpill();
-      // Check if we have released sufficient memory after spilling.
-      continue;
-    }
-
-    // Fill the spill runs once per each spill run.
-    //
-    // NOTE: there might be some leftover from previous spill run so that we
-    // finish spilling them first.
-    if (!hasFilledRuns) {
-      fillSpillRuns(startRowIter);
-      hasFilledRuns = true;
-    }
-
-    while (rowsLeft > 0 && (rowsLeft > targetRows || spaceLeft > targetBytes)) {
-      const int32_t partition = pickNextPartitionToSpill();
-      if (partition == -1) {
-        // If 'startRowIter' is set, we only spill rows starting from the offset
-        // as specified in 'startRowIter'.
-        if (startRowIter == nullptr) {
-          VELOX_FAIL(
-              "No partition has spillable data but still doesn't reach the spill target, target rows {}, target bytes {}, rows left {}, bytes left {}",
-              targetRows,
-              targetBytes,
-              rowsLeft,
-              spaceLeft);
-        }
-        break;
-      }
-      if (!state_.isPartitionSpilled(partition)) {
-        state_.setPartitionSpilled(partition);
-      }
-      VELOX_DCHECK_EQ(pendingSpillPartitions_.count(partition), 0);
-      pendingSpillPartitions_.insert(partition);
-      rowsLeft =
-          std::max<int64_t>(0, rowsLeft - spillRuns_[partition].rows.size());
-      spaceLeft =
-          std::max<int64_t>(0, spaceLeft - spillRuns_[partition].numBytes);
-    }
-    // Quit this spill run if we have spilled all the partitions.
-    if (pendingSpillPartitions_.empty()) {
-      LOG_EVERY_N(WARNING, kLogEveryN)
-          << spaceLeft << " bytes and " << rowsLeft
-          << " rows left after spilled all partitions, spiller: " << toString();
-      break;
-    }
+  RowContainerIterator rowIter;
+  if (startRowIter != nullptr) {
+    rowIter = *startRowIter;
   }
 
-  // Clear the non-spilling runs on exit.
-  clearNonSpillingRuns();
+  bool lastRun{false};
+  do {
+    lastRun = fillSpillRuns(&rowIter);
+    runSpill(lastRun);
+  } while (!lastRun);
+
+  checkEmptySpillRuns();
 }
 
-void Spiller::spill(const SpillPartitionNumSet& partitions) {
+void Spiller::spill(std::vector<char*>& rows) {
   CHECK_NOT_FINALIZED();
+  VELOX_CHECK_EQ(type_, Type::kOrderByOutput);
+  VELOX_CHECK(!rows.empty());
 
-  if (type_ == Type::kHashJoinProbe) {
-    VELOX_FAIL("There is no row container for {}", typeName(type_));
-  }
-  if (!pendingSpillPartitions_.empty()) {
-    VELOX_FAIL(
-        "There are pending spilling operations on partitions: {}",
-        folly::join(",", pendingSpillPartitions_));
-  }
+  markAllPartitionsSpilled();
+
+  fillSpillRun(rows);
+  runSpill(true);
+  checkEmptySpillRuns();
+}
 
-  std::vector<uint32_t> partitionsToSpill(partitions.begin(), partitions.end());
-  if (partitionsToSpill.empty()) {
-    partitionsToSpill.resize(state_.maxPartitions());
-    std::iota(partitionsToSpill.begin(), partitionsToSpill.end(), 0);
+void Spiller::checkEmptySpillRuns() const {
+  for (const auto& spillRun : spillRuns_) {
+    VELOX_CHECK(spillRun.rows.empty());
   }
+}
 
-  for (auto partition : partitionsToSpill) {
+void Spiller::markAllPartitionsSpilled() {
+  for (auto partition = 0; partition < state_.maxPartitions(); ++partition) {
     if (!state_.isPartitionSpilled(partition)) {
       state_.setPartitionSpilled(partition);
-      if (!spillRuns_[partition].rows.empty()) {
-        pendingSpillPartitions_.insert(partition);
-      }
     }
   }
-
-  while (!pendingSpillPartitions_.empty()) {
-    advanceSpill();
-  }
 }
 
 void Spiller::spill(uint32_t partition, const RowVectorPtr& spillVector) {
   CHECK_NOT_FINALIZED();
-
-  if (FOLLY_UNLIKELY(needSort())) {
-    VELOX_FAIL(
-        "Do not support to spill vector for sorted spiller: {}", toString());
-  }
+  VELOX_CHECK(
+      type_ == Type::kHashJoinProbe || type_ == Type::kHashJoinBuild ||
+          type_ == Type::kRowNumber,
+      "Unexpected spiller type: {}",
+      typeName(type_));
   if (FOLLY_UNLIKELY(!state_.isPartitionSpilled(partition))) {
     VELOX_FAIL(
         "Can't spill vector to a non-spilling partition: {}, {}",
@@ -551,65 +620,18 @@ void Spiller::spill(uint32_t partition, const RowVectorPtr& spillVector) {
   state_.appendToPartition(partition, spillVector);
 }
 
-int32_t Spiller::pickNextPartitionToSpill() {
-  VELOX_DCHECK_EQ(spillRuns_.size(), state_.maxPartitions());
-
-  // Sort the partitions based on spiller type to pick.
-  std::vector<int32_t> partitionIndices(spillRuns_.size());
-  std::iota(partitionIndices.begin(), partitionIndices.end(), 0);
-  std::sort(
-      partitionIndices.begin(),
-      partitionIndices.end(),
-      [&](int32_t lhs, int32_t rhs) {
-        // If one of the partition has been spilled, then select the spilled one
-        // if its number of bytes exceeds 'minSpillRunSize_' limit.
-        if (state_.isPartitionSpilled(lhs) != state_.isPartitionSpilled(rhs)) {
-          if (state_.isPartitionSpilled(lhs) &&
-              spillRuns_[lhs].numBytes > minSpillRunSize_) {
-            return true;
-          }
-          if (state_.isPartitionSpilled(rhs) &&
-              spillRuns_[rhs].numBytes > minSpillRunSize_) {
-            return false;
-          }
-        }
-        return spillRuns_[lhs].numBytes > spillRuns_[rhs].numBytes;
-      });
-  for (auto partition : partitionIndices) {
-    if (pendingSpillPartitions_.count(partition) != 0) {
-      continue;
-    }
-    if (spillRuns_[partition].numBytes == 0) {
-      continue;
-    }
-    return partition;
-  }
-  return -1;
-}
-
-Spiller::SpillRows Spiller::finishSpill() {
-  finalizeSpill();
-
-  SpillRows rowsFromNonSpillingPartitions(
-      0, memory::StlAllocator<char*>(*pool_));
-  if (type_ != Spiller::Type::kHashJoinProbe) {
-    fillSpillRuns(nullptr, &rowsFromNonSpillingPartitions);
-  }
-  return rowsFromNonSpillingPartitions;
-}
-
 void Spiller::finishSpill(SpillPartitionSet& partitionSet) {
   finalizeSpill();
 
   for (auto& partition : state_.spilledPartitionSet()) {
     const SpillPartitionId partitionId(bits_.begin(), partition);
-    if (FOLLY_UNLIKELY(partitionSet.count(partitionId) == 0)) {
+    if (partitionSet.count(partitionId) == 0) {
       partitionSet.emplace(
           partitionId,
           std::make_unique<SpillPartition>(
-              partitionId, state_.files(partition)));
+              partitionId, state_.finish(partition)));
     } else {
-      partitionSet[partitionId]->addFiles(state_.files(partition));
+      partitionSet[partitionId]->addFiles(state_.finish(partition));
     }
   }
 }
@@ -617,67 +639,31 @@ void Spiller::finishSpill(SpillPartitionSet& partitionSet) {
 void Spiller::finalizeSpill() {
   CHECK_NOT_FINALIZED();
   finalized_ = true;
-
-  for (const auto partition : state_.spilledPartitionSet()) {
-    if (state_.hasFiles(partition)) {
-      state_.finishWrite(partition);
-    }
-  }
 }
 
-std::unique_ptr<TreeOfLosers<SpillMergeStream>> Spiller::startMerge(
-    int32_t partition) {
-  CHECK_FINALIZED();
+bool Spiller::fillSpillRuns(RowContainerIterator* iterator) {
+  checkEmptySpillRuns();
 
-  // We expect the spilled data are sorted for sort merge read except
-  // 'kAggregateOutput' type which is used during the aggregation output
-  // processing. The latter only only has one merge stream with one row per each
-  // distinct aggregation group. Hence, we don't need to sort in that case.
-  if (type_ != Type::kAggregateOutput) {
-    VELOX_CHECK(
-        needSort(), "Can't sort merge the unsorted spill data: {}", toString());
-  }
-
-  auto merger =
-      state_.startMerge(partition, spillMergeStreamOverRows(partition));
-  if (merger != nullptr && type_ == Type::kAggregateOutput) {
-    VELOX_CHECK_EQ(
-        merger->numStreams(),
-        1,
-        "{} spiller can only have one merge stream",
-        typeName(type_));
-  }
-  return merger;
-}
-
-void Spiller::clearSpillRuns() {
-  for (auto& run : spillRuns_) {
-    run.clear();
-  }
-}
-
-void Spiller::fillSpillRuns(
-    const RowContainerIterator* startRowIter,
-    SpillRows* rowsFromNonSpillingPartitions) {
-  clearSpillRuns();
-
-  uint64_t execTimeUs{0};
+  bool lastRun{false};
+  uint64_t execTimeNs{0};
   {
-    MicrosecondTimer timer(&execTimeUs);
-    RowContainerIterator iterator;
-    if (startRowIter != nullptr) {
-      iterator = *startRowIter;
-    }
+    NanosecondTimer timer(&execTimeNs);
+
     // Number of rows to hash and divide into spill partitions at a time.
     constexpr int32_t kHashBatchSize = 4096;
     std::vector<uint64_t> hashes(kHashBatchSize);
     std::vector<char*> rows(kHashBatchSize);
-    VELOX_CHECK((type_ != Type::kOrderBy) || bits_.numPartitions() == 1);
-    const bool isSinglePartition =
-        (type_ == Type::kOrderBy || bits_.numPartitions() == 1);
+    const bool isSinglePartition = bits_.numPartitions() == 1;
+
+    uint64_t totalRows{0};
     for (;;) {
-      auto numRows = container_->listRows(
-          &iterator, rows.size(), RowContainer::kUnlimited, rows.data());
+      const auto numRows = container_->listRows(
+          iterator, rows.size(), RowContainer::kUnlimited, rows.data());
+      if (numRows == 0) {
+        lastRun = true;
+        break;
+      }
+
       // Calculate hashes for this batch of spill candidates.
       auto rowSet = folly::Range<char**>(rows.data(), numRows);
 
@@ -695,31 +681,34 @@ void Spiller::fillSpillRuns(
             ? 0
             : bits_.partition(hashes[i], state_.maxPartitions());
         VELOX_DCHECK_GE(partition, 0);
-        // If 'rowsFromNonSpillingPartitions' is not null, it is used to collect
-        // the rows from non-spilling partitions when finishes spilling.
-        if (FOLLY_UNLIKELY(
-                rowsFromNonSpillingPartitions != nullptr &&
-                !state_.isPartitionSpilled(partition))) {
-          rowsFromNonSpillingPartitions->push_back(rows[i]);
-          continue;
-        }
         spillRuns_[partition].rows.push_back(rows[i]);
         spillRuns_[partition].numBytes += container_->rowSize(rows[i]);
       }
-      if (numRows == 0) {
+
+      totalRows += numRows;
+      if (maxSpillRunRows_ > 0 && totalRows >= maxSpillRunRows_) {
         break;
       }
     }
   }
-  updateSpillFillTime(execTimeUs);
+  updateSpillFillTime(execTimeNs);
+
+  return lastRun;
 }
 
-void Spiller::clearNonSpillingRuns() {
-  for (auto partition = 0; partition < spillRuns_.size(); ++partition) {
-    if (pendingSpillPartitions_.count(partition) == 0) {
-      spillRuns_[partition].clear();
+void Spiller::fillSpillRun(std::vector<char*>& rows) {
+  VELOX_CHECK_EQ(bits_.numPartitions(), 1);
+  checkEmptySpillRuns();
+  uint64_t execTimeNs{0};
+  {
+    NanosecondTimer timer(&execTimeNs);
+    spillRuns_[0].rows =
+        SpillRows(rows.begin(), rows.end(), spillRuns_[0].rows.get_allocator());
+    for (const auto* row : rows) {
+      spillRuns_[0].numBytes += container_->rowSize(row);
     }
   }
+  updateSpillFillTime(execTimeNs);
 }
 
 std::string Spiller::toString() const {
@@ -734,8 +723,10 @@ std::string Spiller::toString() const {
 // static
 std::string Spiller::typeName(Type type) {
   switch (type) {
-    case Type::kOrderBy:
-      return "ORDER_BY";
+    case Type::kOrderByInput:
+      return "ORDER_BY_INPUT";
+    case Type::kOrderByOutput:
+      return "ORDER_BY_OUTPUT";
     case Type::kHashJoinBuild:
       return "HASH_JOIN_BUILD";
     case Type::kHashJoinProbe:
@@ -744,34 +735,14 @@ std::string Spiller::typeName(Type type) {
       return "AGGREGATE_INPUT";
     case Type::kAggregateOutput:
       return "AGGREGATE_OUTPUT";
+    case Type::kRowNumber:
+      return "ROW_NUMBER";
     default:
       VELOX_UNREACHABLE("Unknown type: {}", static_cast<int>(type));
   }
 }
 
-void Spiller::fillSpillRuns(std::vector<SpillableStats>& statsList) {
-  if (FOLLY_UNLIKELY(type_ == Type::kHashJoinProbe)) {
-    VELOX_FAIL("There is no row container for {}", typeName(type_));
-  }
-  statsList.resize(state_.maxPartitions());
-  if (isAllSpilled()) {
-    return;
-  }
-  fillSpillRuns();
-  for (int partitionNum = 0; partitionNum < state_.maxPartitions();
-       ++partitionNum) {
-    const auto& spillRun = spillRuns_[partitionNum];
-    statsList[partitionNum].numBytes += spillRun.numBytes;
-    statsList[partitionNum].numRows += spillRun.rows.size();
-  }
-}
-
-SpillStats Spiller::stats() const {
-  return stats_.copy();
-}
-
-// static
-memory::MemoryPool* Spiller::pool() {
-  return memory::spillMemoryPool();
+common::SpillStats Spiller::stats() const {
+  return spillStats_->copy();
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Spiller.h b/velox/exec/Spiller.h
index 3536197109949..ab711840c42ea 100644
--- a/velox/exec/Spiller.h
+++ b/velox/exec/Spiller.h
@@ -15,8 +15,8 @@
  */
 #pragma once
 
+#include "velox/common/base/SpillConfig.h"
 #include "velox/common/compression/Compression.h"
-#include "velox/common/config/SpillConfig.h"
 #include "velox/exec/HashBitRange.h"
 #include "velox/exec/RowContainer.h"
 
@@ -26,7 +26,7 @@ namespace facebook::velox::exec {
 class Spiller {
  public:
   // Define the spiller types.
-  enum class Type {
+  enum class Type : int8_t {
     // Used for aggregation input processing stage.
     kAggregateInput = 0,
     // Used for aggregation output processing stage.
@@ -35,100 +35,99 @@ class Spiller {
     kHashJoinBuild = 2,
     // Used for hash join probe.
     kHashJoinProbe = 3,
-    // Used for order by.
-    kOrderBy = 4,
+    // Used for order by input processing stage.
+    kOrderByInput = 4,
+    // Used for order by output processing stage.
+    kOrderByOutput = 5,
+    // Used for row number.
+    kRowNumber = 6,
+    // Number of spiller types.
+    kNumTypes = 7,
   };
-  static constexpr int kNumTypes = 4;
+
   static std::string typeName(Type);
 
   using SpillRows = std::vector<char*, memory::StlAllocator<char*>>;
 
-  // The constructor without specifying hash bits which will only use one
-  // partition by default. It is only used by SortBuffer spiller type for now.
+  /// The constructor without specifying hash bits which will only use one
+  /// partition by default.
+
+  /// type == Type::kAggregateInput
   Spiller(
       Type type,
       RowContainer* container,
-      RowContainer::Eraser eraser,
       RowTypePtr rowType,
+      const HashBitRange& hashBitRange,
       int32_t numSortingKeys,
       const std::vector<CompareFlags>& sortCompareFlags,
-      const std::string& path,
-      uint64_t targetFileSize,
-      uint64_t writeBufferSize,
-      uint64_t minSpillRunSize,
-      common::CompressionKind compressionKind,
-      memory::MemoryPool* pool,
-      folly::Executor* executor);
+      const common::SpillConfig* spillConfig,
+      folly::Synchronized<common::SpillStats>* spillStats);
 
+  /// type == Type::kOrderByInput
   Spiller(
       Type type,
       RowContainer* container,
-      RowContainer::Eraser eraser,
       RowTypePtr rowType,
-      const std::string& path,
-      uint64_t writeBufferSize,
-      common::CompressionKind compressionKind,
-      memory::MemoryPool* pool,
-      folly::Executor* executor);
+      int32_t numSortingKeys,
+      const std::vector<CompareFlags>& sortCompareFlags,
+      const common::SpillConfig* spillConfig,
+      folly::Synchronized<common::SpillStats>* spillStats);
+
+  /// type == Type::kAggregateOutput || type == Type::kOrderByOutput
+  Spiller(
+      Type type,
+      RowContainer* container,
+      RowTypePtr rowType,
+      const common::SpillConfig* spillConfig,
+      folly::Synchronized<common::SpillStats>* spillStats);
 
+  /// type == Type::kHashJoinProbe
   Spiller(
       Type type,
       RowTypePtr rowType,
       HashBitRange bits,
-      const std::string& path,
-      uint64_t targetFileSize,
-      uint64_t writeBufferSize,
-      uint64_t minSpillRunSize,
-      common::CompressionKind compressionKind,
-      memory::MemoryPool* pool,
-      folly::Executor* executor);
+      const common::SpillConfig* spillConfig,
+      folly::Synchronized<common::SpillStats>* spillStats);
 
+  /// type == Type::kHashJoinBuild
   Spiller(
       Type type,
+      core::JoinType joinType,
       RowContainer* container,
-      RowContainer::Eraser eraser,
       RowTypePtr rowType,
       HashBitRange bits,
-      int32_t numSortingKeys,
-      const std::vector<CompareFlags>& sortCompareFlags,
-      const std::string& path,
-      uint64_t targetFileSize,
-      uint64_t writeBufferSize,
-      uint64_t minSpillRunSize,
-      common::CompressionKind compressionKind,
-      memory::MemoryPool* pool,
-      folly::Executor* executor);
+      const common::SpillConfig* spillConfig,
+      folly::Synchronized<common::SpillStats>* spillStats);
+
+  /// type == Type::kRowNumber
+  Spiller(
+      Type type,
+      RowContainer* container,
+      RowTypePtr rowType,
+      HashBitRange bits,
+      const common::SpillConfig* spillConfig,
+      folly::Synchronized<common::SpillStats>* spillStats);
 
   Type type() const {
     return type_;
   }
 
-  /// Spills rows from 'this' until there are under 'targetRows' rows
-  /// and 'targetBytes' of allocated variable length space in use. spill()
-  /// starts with the partition with the most spillable data first. If there is
-  /// no more data to spill in one hash partition, it starts spilling another
-  /// hash partition until all hash partitions are spilling. A spillable hash
-  /// partition has a SpillRun struct in 'spillRuns_' A targetRows of 0 causes
-  /// all data to be spilled and 'container_' to become empty.
-  void spill(uint64_t targetRows, uint64_t targetBytes);
+  /// Spills all the rows from 'this' to disk. The spilled rows stays in the
+  /// row container. The caller needs to erase the spilled rows from the row
+  /// container.
+  void spill();
 
   /// Spill all rows starting from 'startRowIter'. This is only used by
   /// 'kAggregateOutput' spiller type to spill during the aggregation output
-  /// processing.
+  /// processing. Similarly, the spilled rows still stays in the row container.
+  /// The caller needs to erase them from the row container.
   void spill(const RowContainerIterator& startRowIter);
 
-  /// Spills all the spillable rows collected in 'spillRuns_' from specified
-  /// 'partitions'. It is now only used by spilling operator which needs
-  /// spilling coordination across multiple drivers such as hash build. One of
-  /// the driver is selected as the spill coordinator which first picks up a set
-  /// of partitions which have the most spillable from all the participated
-  /// drivers, and then spill the chosen partitions on all the drivers. Once
-  /// after that, for those spilled partitions, the spilling operator will
-  /// append new incoming vector to the spill file directly without buffering in
-  /// row container anymore.
-  ///
-  /// NOTE: if 'partitions' is empty, then spill from all the partitions.
-  void spill(const SpillPartitionNumSet& partitions = {});
+  /// Invoked to spill all the rows pointed by rows. This is used by
+  /// 'kOrderByOutput' spiller type to spill during the order by
+  /// output processing. Similarly, the spilled rows still stays in the row
+  /// container. The caller needs to erase them from the row container.
+  void spill(std::vector<char*>& rows);
 
   /// Append 'spillVector' into the spill file of given 'partition'. It is now
   /// only used by the spilling operator which doesn't need data sort, such as
@@ -138,29 +137,6 @@ class Spiller {
   /// spill any data buffered in row container before call this.
   void spill(uint32_t partition, const RowVectorPtr& spillVector);
 
-  /// Contains the amount of spillable data of a partition which includes the
-  /// number of spillable rows and bytes.
-  struct SpillableStats {
-    int64_t numRows = 0;
-    int64_t numBytes = 0;
-
-    inline SpillableStats& operator+=(const SpillableStats& other) {
-      this->numRows += other.numRows;
-      this->numBytes += other.numBytes;
-      return *this;
-    }
-  };
-
-  /// Invoked to fill spill runs on all partitions and accumulate the spillable
-  /// stats in 'statsList' by partition number.
-  void fillSpillRuns(std::vector<SpillableStats>& statsList);
-
-  /// Finishes spilling and returns the rows that are in partitions that have
-  /// not started spilling.
-  SpillRows finishSpill();
-
-  std::unique_ptr<TreeOfLosers<SpillMergeStream>> startMerge(int32_t partition);
-
   /// Extracts up to 'maxRows' or 'maxBytes' from 'rows' into 'spillVector'. The
   /// extract starts at nextBatchIndex and updates nextBatchIndex to be the
   /// index of the first non-extracted element of 'rows'. Returns the byte size
@@ -172,8 +148,8 @@ class Spiller {
       RowVectorPtr& spillVector,
       size_t& nextBatchIndex);
 
-  /// Finishes spilling and accumulate the spilled partition data in
-  /// 'partitionSet' by spill partition id.
+  /// Finishes spilling and accumulate the spilled partition metadata in
+  /// 'partitionSet' indexed by spill partition id.
   void finishSpill(SpillPartitionSet& partitionSet);
 
   const SpillState& state() const {
@@ -205,27 +181,48 @@ class Spiller {
 
   /// Invokes to set a set of 'partitions' as spilling.
   void setPartitionsSpilled(const SpillPartitionNumSet& partitions) {
+    VELOX_CHECK_EQ(
+        type_,
+        Spiller::Type::kHashJoinProbe,
+        "Unexpected spiller type: ",
+        typeName(type_));
     for (const auto& partition : partitions) {
       state_.setPartitionSpilled(partition);
     }
   }
 
-  SpillStats stats() const;
+  /// Indicates if this spiller has finalized or not.
+  bool finalized() const {
+    return finalized_;
+  }
 
-  /// Global memory pool for spill intermediates. ~1MB per spill executor thread
-  /// is the expected peak utilization.
-  static memory::MemoryPool* pool();
+  common::SpillStats stats() const;
 
   std::string toString() const;
 
  private:
-  // Invoked to spill with specified target. If 'rowIter' is not null, then
-  // we only spill rows from row container starting at the offset pointed by
-  // 'startRowIter'.
-  void spill(
-      uint64_t targetRows,
-      uint64_t targetBytes,
-      const RowContainerIterator* startRowIter);
+  Spiller(
+      Type type,
+      RowContainer* container,
+      RowTypePtr rowType,
+      HashBitRange bits,
+      int32_t numSortingKeys,
+      const std::vector<CompareFlags>& sortCompareFlags,
+      bool spillProbedFlag,
+      const common::GetSpillDirectoryPathCB& getSpillDirPathCb,
+      const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+      const std::string& fileNamePrefix,
+      uint64_t targetFileSize,
+      uint64_t writeBufferSize,
+      common::CompressionKind compressionKind,
+      folly::Executor* executor,
+      uint64_t maxSpillRunRows,
+      const std::string& fileCreateConfig,
+      folly::Synchronized<common::SpillStats>* spillStats);
+
+  // Invoked to spill. If 'startRowIter' is not null, then we only spill rows
+  // from row container starting at the offset pointed by 'startRowIter'.
+  void spill(const RowContainerIterator* startRowIter);
 
   // Extracts the keys, dependents or accumulators for 'rows' into '*result'.
   // Creates '*results' in spillPool() if nullptr. Used from Spiller and
@@ -237,6 +234,9 @@ class Spiller {
   // first and 'partition' must specify a partition that has started spilling.
   std::unique_ptr<SpillMergeStream> spillMergeStreamOverRows(int32_t partition);
 
+  // Invoked to finalize the spiller and flush any buffered spill to disk.
+  void finalizeSpill();
+
   // Represents a run of rows from a spillable partition of
   // a RowContainer. Rows that hash to the same partition are accumulated here
   // and sorted in the case of sorted spilling. The run is then
@@ -283,46 +283,34 @@ class Spiller {
         : partition(_partition), rowsWritten(_numWritten), error(_error) {}
   };
 
+  void checkEmptySpillRuns() const;
+
+  // Marks all the partitions have been spilled as we don't support
+  // fine-grained spilling as for now.
+  void markAllPartitionsSpilled();
+
   // Prepares spill runs for the spillable data from all the hash partitions.
   // If 'startRowIter' is not null, we prepare runs starting from the offset
-  // pointed by 'startRowIter'. If 'rowsFromNonSpillingPartitions' is not null,
-  // the function is invoked to finish spill, and it will collect rows from the
-  // non-spilling partitions in 'rowsFromNonSpillingPartitions' instead of
-  // 'spillRuns_'.
-  void fillSpillRuns(
-      const RowContainerIterator* startRowIter = nullptr,
-      SpillRows* rowsFromNonSpillingPartitions = nullptr);
-
-  // Picks the next partition to spill. In case of non kHashJoin type, the
-  // function picks the partition with spillable data no matter it has spilled
-  // or not. For kHashJoin, the function first tries to pick the one from the
-  // spilling partition first. If all the spilling partition has no spillable
-  // data, it tries to look for one from non-spilling partitions. The function
-  // returns -1 if all the partitions have no spillable data which should only
-  // happen when finish spill to collect non-spilling rows.
-  int32_t pickNextPartitionToSpill();
-
-  // Clears pending spill state.
-  void clearSpillRuns();
-
-  // Clears runs that have not started spilling.
-  void clearNonSpillingRuns();
+  // pointed by 'startRowIter'.
+  // The function returns true if it is the last spill run.
+  bool fillSpillRuns(RowContainerIterator* startRowIter = nullptr);
+
+  // Prepares spill run of a single partition for the spillable data from the
+  // rows.
+  void fillSpillRun(std::vector<char*>& rows);
+
+  // Writes out all the rows collected in spillRuns_.
+  void runSpill(bool lastRun);
 
   // Sorts 'run' if not already sorted.
   void ensureSorted(SpillRun& run);
 
   // Function for writing a spill partition on an executor. Writes to
   // 'partition' until all rows in spillRuns_[partition] are written
-  // or spill file size limit is exceededg. Returns the number of rows
+  // or spill file size limit is exceeded. Returns the number of rows
   // written.
   std::unique_ptr<SpillStatus> writeSpill(int32_t partition);
 
-  // Writes out and erases rows marked for spilling.
-  void advanceSpill();
-
-  // Invoked to finalize the spiller and flush any buffered spill to disk.
-  void finalizeSpill();
-
   // Indicates if the spill data needs to be sorted before write to file. It is
   // based on the spiller type. As for now, we need to sort spill data for any
   // non hash join types of spilling.
@@ -335,13 +323,14 @@ class Spiller {
   const Type type_;
   // NOTE: for hash join probe type, there is no associated row container for
   // the spiller.
-  RowContainer* const container_;
+  RowContainer* const container_{nullptr};
   folly::Executor* const executor_;
-  memory::MemoryPool* const pool_;
-  const RowContainer::Eraser eraser_;
   const HashBitRange bits_;
   const RowTypePtr rowType_;
-  const uint64_t minSpillRunSize_;
+  const bool spillProbedFlag_;
+  const uint64_t maxSpillRunRows_;
+
+  folly::Synchronized<common::SpillStats>* const spillStats_;
 
   // True if all rows of spilling partitions are in 'spillRuns_', so
   // that one can start reading these back. This means that the rows
@@ -349,13 +338,17 @@ class Spiller {
   // spillMergeStreamOverRows().
   bool finalized_{false};
 
-  folly::Synchronized<SpillStats> stats_;
   SpillState state_;
 
-  // Indices into 'spillRuns_' that are currently getting spilled.
-  SpillPartitionNumSet pendingSpillPartitions_;
-
-  // One spill run for each partition of spillable data.
+  // Collects the rows to spill for each partition.
   std::vector<SpillRun> spillRuns_;
 };
 } // namespace facebook::velox::exec
+
+template <>
+struct fmt::formatter<facebook::velox::exec::Spiller::Type> : formatter<int> {
+  auto format(facebook::velox::exec::Spiller::Type s, format_context& ctx)
+      const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/exec/Split.h b/velox/exec/Split.h
index 42c2be40f6ffb..a00d31de688e0 100644
--- a/velox/exec/Split.h
+++ b/velox/exec/Split.h
@@ -30,22 +30,10 @@ struct Split {
       int32_t groupId = -1)
       : connectorSplit(std::move(connectorSplit)), groupId(groupId) {}
 
-  Split(Split&& other)
-      : connectorSplit(std::move(other.connectorSplit)),
-        groupId(other.groupId) {}
-
-  Split(const Split& other)
-      : connectorSplit(other.connectorSplit), groupId(other.groupId) {}
-
-  void operator=(Split&& other) {
-    connectorSplit = std::move(other.connectorSplit);
-    groupId = other.groupId;
-  }
-
-  void operator=(const Split& other) {
-    connectorSplit = other.connectorSplit;
-    groupId = other.groupId;
-  }
+  Split(Split&& other) = default;
+  Split(const Split& other) = default;
+  Split& operator=(Split&& other) = default;
+  Split& operator=(const Split& other) = default;
 
   inline bool hasConnectorSplit() const {
     return connectorSplit != nullptr;
diff --git a/velox/exec/StreamingAggregation.cpp b/velox/exec/StreamingAggregation.cpp
index 4d160839f91be..e4b0aa598c8e0 100644
--- a/velox/exec/StreamingAggregation.cpp
+++ b/velox/exec/StreamingAggregation.cpp
@@ -13,9 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/exec/StreamingAggregation.h"
-#include "velox/exec/Aggregate.h"
-#include "velox/exec/RowContainer.h"
 
 namespace facebook::velox::exec {
 
@@ -32,98 +31,62 @@ StreamingAggregation::StreamingAggregation(
               ? "PartialAggregation"
               : "Aggregation"),
       outputBatchSize_{outputBatchRows()},
+      aggregationNode_{aggregationNode},
       step_{aggregationNode->step()} {
-  auto numKeys = aggregationNode->groupingKeys().size();
+  if (aggregationNode_->ignoreNullKeys()) {
+    VELOX_UNSUPPORTED(
+        "Streaming aggregation doesn't support ignoring null keys yet");
+  }
+}
+
+void StreamingAggregation::initialize() {
+  Operator::initialize();
+
+  auto numKeys = aggregationNode_->groupingKeys().size();
   decodedKeys_.resize(numKeys);
 
-  auto inputType = aggregationNode->sources()[0]->outputType();
+  auto inputType = aggregationNode_->sources()[0]->outputType();
 
   std::vector<TypePtr> groupingKeyTypes;
   groupingKeyTypes.reserve(numKeys);
 
   groupingKeys_.reserve(numKeys);
-  for (const auto& key : aggregationNode->groupingKeys()) {
+  for (const auto& key : aggregationNode_->groupingKeys()) {
     auto channel = exprToChannel(key.get(), inputType);
     groupingKeys_.push_back(channel);
     groupingKeyTypes.push_back(inputType->childAt(channel));
   }
 
-  auto numAggregates = aggregationNode->aggregates().size();
-  aggregates_.reserve(numAggregates);
-  std::vector<std::optional<column_index_t>> maskChannels;
-  maskChannels.reserve(numAggregates);
-  for (auto i = 0; i < numAggregates; i++) {
-    const auto& aggregate = aggregationNode->aggregates()[i];
-
-    std::vector<column_index_t> channels;
-    std::vector<VectorPtr> constants;
-    std::vector<TypePtr> argTypes;
-    for (auto& arg : aggregate.call->inputs()) {
-      argTypes.push_back(arg->type());
-      channels.push_back(exprToChannel(arg.get(), inputType));
-      if (channels.back() == kConstantChannel) {
-        auto constant = static_cast<const core::ConstantTypedExpr*>(arg.get());
-        constants.push_back(BaseVector::createConstant(
-            constant->type(), constant->value(), 1, operatorCtx_->pool()));
-      } else {
-        constants.push_back(nullptr);
-      }
-    }
-
-    if (const auto& mask = aggregate.mask) {
-      maskChannels.emplace_back(inputType->asRow().getChildIdx(mask->name()));
-    } else {
-      maskChannels.emplace_back(std::nullopt);
-    }
-
-    const auto& aggResultType = outputType_->childAt(numKeys + i);
-    aggregates_.push_back(Aggregate::create(
-        aggregate.call->name(),
-        aggregationNode->step(),
-        argTypes,
-        aggResultType,
-        driverCtx->queryConfig()));
-    args_.push_back(channels);
-    constantArgs_.push_back(constants);
-  }
-
-  if (aggregationNode->ignoreNullKeys()) {
-    VELOX_NYI("Streaming aggregation doesn't support ignoring null keys yet");
-  }
+  std::shared_ptr<core::ExpressionEvaluator> expressionEvaluator;
+  aggregates_ = toAggregateInfo(
+      *aggregationNode_, *operatorCtx_, numKeys, expressionEvaluator, true);
 
-  masks_ = std::make_unique<AggregationMasks>(std::move(maskChannels));
+  // Setup SortedAggregations.
+  sortedAggregations_ =
+      SortedAggregations::create(aggregates_, inputType, pool());
 
-  std::vector<Accumulator> accumulators;
-  accumulators.reserve(aggregates_.size());
+  distinctAggregations_.reserve(aggregates_.size());
   for (auto& aggregate : aggregates_) {
-    accumulators.push_back(Accumulator{aggregate.get()});
+    if (aggregate.distinct) {
+      distinctAggregations_.emplace_back(
+          DistinctAggregations::create({&aggregate}, inputType, pool()));
+    } else {
+      distinctAggregations_.push_back(nullptr);
+    }
   }
 
-  rows_ = std::make_unique<RowContainer>(
-      groupingKeyTypes,
-      !aggregationNode->ignoreNullKeys(),
-      accumulators,
-      std::vector<TypePtr>{},
-      false,
-      false,
-      false,
-      false,
-      pool());
+  masks_ = std::make_unique<AggregationMasks>(extractMaskChannels(aggregates_));
+  rows_ = makeRowContainer(groupingKeyTypes);
 
-  for (auto i = 0; i < aggregates_.size(); ++i) {
-    aggregates_[i]->setAllocator(&rows_->stringAllocator());
+  initializeAggregates(numKeys);
 
-    const auto rowColumn = rows_->columnAt(numKeys + i);
-    aggregates_[i]->setOffsets(
-        rowColumn.offset(),
-        rowColumn.nullByte(),
-        rowColumn.nullMask(),
-        rows_->rowSizeOffset());
-  }
+  aggregationNode_.reset();
 }
 
 void StreamingAggregation::close() {
-  rows_->clear();
+  if (rows_ != nullptr) {
+    rows_->clear();
+  }
   Operator::close();
 }
 
@@ -182,12 +145,33 @@ RowVectorPtr StreamingAggregation::createOutput(size_t numGroups) {
 
   auto numKeys = groupingKeys_.size();
   for (auto i = 0; i < aggregates_.size(); ++i) {
-    auto& aggregate = aggregates_[i];
+    const auto& aggregate = aggregates_.at(i);
+    if (!aggregate.sortingKeys.empty()) {
+      continue;
+    }
+
+    if (aggregate.distinct) {
+      continue;
+    }
+
+    const auto& function = aggregate.function;
     auto& result = output->childAt(numKeys + i);
     if (isPartialOutput(step_)) {
-      aggregate->extractAccumulators(groups_.data(), numGroups, &result);
+      function->extractAccumulators(groups_.data(), numGroups, &result);
     } else {
-      aggregate->extractValues(groups_.data(), numGroups, &result);
+      function->extractValues(groups_.data(), numGroups, &result);
+    }
+  }
+
+  if (sortedAggregations_) {
+    sortedAggregations_->extractValues(
+        folly::Range<char**>(groups_.data(), numGroups), output);
+  }
+
+  for (const auto& aggregation : distinctAggregations_) {
+    if (aggregation != nullptr) {
+      aggregation->extractValues(
+          folly::Range<char**>(groups_.data(), numGroups), output);
     }
   }
 
@@ -243,25 +227,44 @@ const SelectivityVector& StreamingAggregation::getSelectivityVector(
 
 void StreamingAggregation::evaluateAggregates() {
   for (auto i = 0; i < aggregates_.size(); ++i) {
-    auto& aggregate = aggregates_[i];
+    const auto& aggregate = aggregates_.at(i);
+    if (!aggregate.sortingKeys.empty()) {
+      continue;
+    }
+
+    const auto& rows = getSelectivityVector(i);
+    if (!rows.hasSelections()) {
+      continue;
+    }
+
+    if (aggregate.distinct) {
+      distinctAggregations_.at(i)->addInput(inputGroups_.data(), input_, rows);
+      continue;
+    }
+
+    const auto& function = aggregate.function;
+    const auto& inputs = aggregate.inputs;
+    const auto& constantInputs = aggregate.constantInputs;
 
     std::vector<VectorPtr> args;
-    for (auto j = 0; j < args_[i].size(); ++j) {
-      if (args_[i][j] == kConstantChannel) {
-        args.push_back(constantArgs_[i][j]);
+    for (auto j = 0; j < inputs.size(); ++j) {
+      if (inputs[j] == kConstantChannel) {
+        args.push_back(constantInputs[j]);
       } else {
-        args.push_back(input_->childAt(args_[i][j]));
+        args.push_back(input_->childAt(inputs[j]));
       }
     }
 
-    const auto& rows = getSelectivityVector(i);
-
     if (isRawInput(step_)) {
-      aggregate->addRawInput(inputGroups_.data(), rows, args, false);
+      function->addRawInput(inputGroups_.data(), rows, args, false);
     } else {
-      aggregate->addIntermediateResults(inputGroups_.data(), rows, args, false);
+      function->addIntermediateResults(inputGroups_.data(), rows, args, false);
     }
   }
+
+  if (sortedAggregations_) {
+    sortedAggregations_->addInput(inputGroups_.data(), input_);
+  }
 }
 
 bool StreamingAggregation::isFinished() {
@@ -287,19 +290,7 @@ RowVectorPtr StreamingAggregation::getOutput() {
   auto numPrevGroups = numGroups_;
 
   assignGroups();
-
-  // Initialize aggregates for the new groups.
-  std::vector<vector_size_t> newGroups;
-  newGroups.resize(numGroups_ - numPrevGroups);
-  std::iota(newGroups.begin(), newGroups.end(), numPrevGroups);
-
-  for (auto i = 0; i < aggregates_.size(); ++i) {
-    auto& aggregate = aggregates_[i];
-
-    aggregate->initializeNewGroups(
-        groups_.data(), folly::Range(newGroups.data(), newGroups.size()));
-  }
-
+  initializeNewGroups(numPrevGroups);
   evaluateAggregates();
 
   RowVectorPtr output;
@@ -324,4 +315,111 @@ RowVectorPtr StreamingAggregation::getOutput() {
   return output;
 }
 
+std::unique_ptr<RowContainer> StreamingAggregation::makeRowContainer(
+    const std::vector<TypePtr>& groupingKeyTypes) {
+  std::vector<Accumulator> accumulators;
+  accumulators.reserve(aggregates_.size());
+  for (const auto& aggregate : aggregates_) {
+    accumulators.emplace_back(
+        aggregate.function.get(), aggregate.intermediateType);
+  }
+
+  if (sortedAggregations_ != nullptr) {
+    accumulators.push_back(sortedAggregations_->accumulator());
+  }
+
+  for (const auto& aggregation : distinctAggregations_) {
+    if (aggregation != nullptr) {
+      accumulators.push_back(aggregation->accumulator());
+    }
+  }
+
+  return std::make_unique<RowContainer>(
+      groupingKeyTypes,
+      !aggregationNode_->ignoreNullKeys(),
+      accumulators,
+      std::vector<TypePtr>{},
+      false,
+      false,
+      false,
+      false,
+      pool());
+}
+
+void StreamingAggregation::initializeNewGroups(size_t numPrevGroups) {
+  if (numGroups_ == numPrevGroups) {
+    return;
+  }
+
+  std::vector<vector_size_t> newGroups;
+  newGroups.resize(numGroups_ - numPrevGroups);
+  std::iota(newGroups.begin(), newGroups.end(), numPrevGroups);
+
+  for (auto i = 0; i < aggregates_.size(); ++i) {
+    const auto& aggregate = aggregates_.at(i);
+    if (!aggregate.sortingKeys.empty()) {
+      continue;
+    }
+
+    if (aggregate.distinct) {
+      distinctAggregations_.at(i)->initializeNewGroups(
+          groups_.data(), newGroups);
+      continue;
+    }
+
+    aggregate.function->initializeNewGroups(groups_.data(), newGroups);
+  }
+
+  if (sortedAggregations_) {
+    sortedAggregations_->initializeNewGroups(groups_.data(), newGroups);
+  }
+}
+
+void StreamingAggregation::initializeAggregates(uint32_t numKeys) {
+  int32_t columnIndex = numKeys;
+  for (auto& aggregate : aggregates_) {
+    auto& function = aggregate.function;
+    function->setAllocator(&rows_->stringAllocator());
+
+    const auto rowColumn = rows_->columnAt(columnIndex);
+    function->setOffsets(
+        rowColumn.offset(),
+        rowColumn.nullByte(),
+        rowColumn.nullMask(),
+        rowColumn.initializedByte(),
+        rowColumn.initializedMask(),
+        rows_->rowSizeOffset());
+    columnIndex++;
+  }
+
+  if (sortedAggregations_) {
+    sortedAggregations_->setAllocator(&rows_->stringAllocator());
+    const auto& rowColumn = rows_->columnAt(columnIndex);
+    sortedAggregations_->setOffsets(
+        rowColumn.offset(),
+        rowColumn.nullByte(),
+        rowColumn.nullMask(),
+        rowColumn.initializedByte(),
+        rowColumn.initializedMask(),
+        rows_->rowSizeOffset());
+    columnIndex++;
+  }
+
+  for (const auto& aggregation : distinctAggregations_) {
+    if (aggregation != nullptr) {
+      aggregation->setAllocator(&rows_->stringAllocator());
+
+      const auto& rowColumn = rows_->columnAt(columnIndex);
+      aggregation->setOffsets(
+          rowColumn.offset(),
+          rowColumn.nullByte(),
+          rowColumn.nullMask(),
+          rowColumn.initializedByte(),
+          rowColumn.initializedMask(),
+          rows_->rowSizeOffset());
+      columnIndex++;
+    }
+  }
+};
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/StreamingAggregation.h b/velox/exec/StreamingAggregation.h
index bfe6bb699498b..ee70a1e8e627e 100644
--- a/velox/exec/StreamingAggregation.h
+++ b/velox/exec/StreamingAggregation.h
@@ -16,8 +16,11 @@
 #pragma once
 
 #include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateInfo.h"
 #include "velox/exec/AggregationMasks.h"
+#include "velox/exec/DistinctAggregations.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/SortedAggregations.h"
 
 namespace facebook::velox::exec {
 
@@ -30,6 +33,8 @@ class StreamingAggregation : public Operator {
       DriverCtx* driverCtx,
       const std::shared_ptr<const core::AggregationNode>& aggregationNode);
 
+  void initialize() override;
+
   void addInput(RowVectorPtr input) override;
 
   RowVectorPtr getOutput() override;
@@ -68,16 +73,29 @@ class StreamingAggregation : public Operator {
   // Add input data to accumulators.
   void evaluateAggregates();
 
+  // Initialize the new groups calculated through current and previous groups.
+  void initializeNewGroups(size_t numPrevGroups);
+
+  // Create accumulators and RowContainer for aggregations.
+  std::unique_ptr<RowContainer> makeRowContainer(
+      const std::vector<TypePtr>& groupingKeyTypes);
+
+  // Initialize the aggregations setting allocator and offsets.
+  void initializeAggregates(uint32_t numKeys);
+
   /// Maximum number of rows in the output batch.
-  const uint32_t outputBatchSize_;
+  const vector_size_t outputBatchSize_;
+
+  // Used at initialize() and gets reset() afterward.
+  std::shared_ptr<const core::AggregationNode> aggregationNode_;
 
   const core::AggregationNode::Step step_;
 
   std::vector<column_index_t> groupingKeys_;
-  std::vector<std::unique_ptr<Aggregate>> aggregates_;
+  std::vector<AggregateInfo> aggregates_;
+  std::unique_ptr<SortedAggregations> sortedAggregations_;
+  std::vector<std::unique_ptr<DistinctAggregations>> distinctAggregations_;
   std::unique_ptr<AggregationMasks> masks_;
-  std::vector<std::vector<column_index_t>> args_;
-  std::vector<std::vector<VectorPtr>> constantArgs_;
   std::vector<DecodedVector> decodedKeys_;
 
   // Storage of grouping keys and accumulators.
diff --git a/velox/exec/StreamingWindowBuild.cpp b/velox/exec/StreamingWindowBuild.cpp
deleted file mode 100644
index 034b896e0ffe9..0000000000000
--- a/velox/exec/StreamingWindowBuild.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/exec/StreamingWindowBuild.h"
-
-namespace facebook::velox::exec {
-
-StreamingWindowBuild::StreamingWindowBuild(
-    const std::shared_ptr<const core::WindowNode>& windowNode,
-    velox::memory::MemoryPool* pool)
-    : WindowBuild(windowNode, pool) {}
-
-void StreamingWindowBuild::buildNextPartition() {
-  partitionStartRows_.push_back(sortedRows_.size());
-  sortedRows_.insert(sortedRows_.end(), inputRows_.begin(), inputRows_.end());
-  inputRows_.clear();
-}
-
-void StreamingWindowBuild::addInput(RowVectorPtr input) {
-  for (auto col = 0; col < input->childrenSize(); ++col) {
-    decodedInputVectors_[col].decode(*input->childAt(col));
-  }
-
-  for (auto row = 0; row < input->size(); ++row) {
-    char* newRow = data_->newRow();
-
-    for (auto col = 0; col < input->childrenSize(); ++col) {
-      data_->store(decodedInputVectors_[col], row, newRow, col);
-    }
-
-    if (previousRow_ != nullptr &&
-        compareRowsWithKeys(previousRow_, newRow, partitionKeyInfo_)) {
-      buildNextPartition();
-    }
-
-    inputRows_.push_back(newRow);
-    previousRow_ = newRow;
-  }
-}
-
-void StreamingWindowBuild::noMoreInput() {
-  buildNextPartition();
-
-  // Help for last partition related calculations.
-  partitionStartRows_.push_back(sortedRows_.size());
-}
-
-std::unique_ptr<WindowPartition> StreamingWindowBuild::nextPartition() {
-  VELOX_CHECK_GT(
-      partitionStartRows_.size(), 0, "No window partitions available")
-
-  currentPartition_++;
-  VELOX_CHECK_LE(
-      currentPartition_,
-      partitionStartRows_.size() - 2,
-      "All window partitions consumed");
-
-  // Erase previous partition.
-  if (currentPartition_ > 0) {
-    auto numPreviousPartitionRows = partitionStartRows_[currentPartition_];
-    data_->eraseRows(
-        folly::Range<char**>(sortedRows_.data(), numPreviousPartitionRows));
-    sortedRows_.erase(
-        sortedRows_.begin(), sortedRows_.begin() + numPreviousPartitionRows);
-    for (int i = currentPartition_; i < partitionStartRows_.size(); i++) {
-      partitionStartRows_[i] =
-          partitionStartRows_[i] - numPreviousPartitionRows;
-    }
-  }
-
-  auto windowPartition = std::make_unique<WindowPartition>(
-      data_.get(), inputColumns_, sortKeyInfo_);
-  auto partitionSize = partitionStartRows_[currentPartition_ + 1] -
-      partitionStartRows_[currentPartition_];
-  auto partition = folly::Range(
-      sortedRows_.data() + partitionStartRows_[currentPartition_],
-      partitionSize);
-  windowPartition->resetPartition(partition);
-
-  return windowPartition;
-}
-
-bool StreamingWindowBuild::hasNextPartition() {
-  return partitionStartRows_.size() > 0 &&
-      currentPartition_ < int(partitionStartRows_.size() - 2);
-}
-
-} // namespace facebook::velox::exec
diff --git a/velox/exec/StreamingWindowBuild.h b/velox/exec/StreamingWindowBuild.h
deleted file mode 100644
index 33f37544c8d04..0000000000000
--- a/velox/exec/StreamingWindowBuild.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/exec/WindowBuild.h"
-
-namespace facebook::velox::exec {
-
-/// The StreamingWindowBuild is used when the input data is already sorted by
-/// {partition keys + order by keys}. The logic identifies partition changes
-/// when receiving input rows and splits out WindowPartitions for the Window
-/// operator to process.
-class StreamingWindowBuild : public WindowBuild {
- public:
-  StreamingWindowBuild(
-      const std::shared_ptr<const core::WindowNode>& windowNode,
-      velox::memory::MemoryPool* pool);
-
-  void addInput(RowVectorPtr input) override;
-
-  void noMoreInput() override;
-
-  bool hasNextPartition() override;
-
-  std::unique_ptr<WindowPartition> nextPartition() override;
-
-  bool needsInput() override {
-    // No partitions are available or the currentPartition is the last available
-    // one, so can consume input rows.
-    return partitionStartRows_.size() == 0 ||
-        currentPartition_ == partitionStartRows_.size() - 2;
-  }
-
- private:
-  void buildNextPartition();
-
-  // Vector of pointers to each input row in the data_ RowContainer.
-  // Rows are erased from data_ when they are output from the
-  // Window operator.
-  std::vector<char*> sortedRows_;
-
-  // Holds input rows within the current partition.
-  std::vector<char*> inputRows_;
-
-  // Indices of  the start row (in sortedRows_) of each partition in
-  // the RowContainer data_. This auxiliary structure helps demarcate
-  // partitions.
-  std::vector<vector_size_t> partitionStartRows_;
-
-  // Used to compare rows based on partitionKeys.
-  char* previousRow_ = nullptr;
-
-  // Current partition being output. Used to construct WindowPartitions
-  // during resetPartition.
-  vector_size_t currentPartition_ = -1;
-};
-
-} // namespace facebook::velox::exec
diff --git a/velox/exec/Strings.cpp b/velox/exec/Strings.cpp
index 8a951cdf55359..c99bcb0cc7b31 100644
--- a/velox/exec/Strings.cpp
+++ b/velox/exec/Strings.cpp
@@ -29,7 +29,7 @@ StringView Strings::append(StringView value, HashStringAllocator& allocator) {
   const int32_t requiredBytes =
       value.size() + HashStringAllocator::Header::kContinuedPtrSize + 8;
 
-  ByteStream stream(&allocator);
+  ByteOutputStream stream(&allocator);
   if (firstBlock == nullptr) {
     // Allocate first block.
     currentBlock = allocator.newWrite(stream, requiredBytes);
@@ -39,19 +39,20 @@ StringView Strings::append(StringView value, HashStringAllocator& allocator) {
   }
 
   // Check if there is enough space left.
-  if (stream.ranges().back().size < requiredBytes) {
+  auto& currentRange = stream.ranges().back();
+  if (currentRange.size - currentRange.position < requiredBytes) {
     // Not enough space. Allocate new block.
     ByteRange newRange;
     allocator.newContiguousRange(requiredBytes, &newRange);
 
-    stream.setRange(newRange);
+    stream.setRange(newRange, 0);
   }
 
   VELOX_DCHECK_LE(requiredBytes, stream.ranges().back().size);
 
   // Copy the string and return a StringView over the copy.
   char* start = stream.writePosition();
-  stream.appendStringPiece(folly::StringPiece(value.data(), value.size()));
+  stream.appendStringView(value);
   currentBlock = allocator.finishWrite(stream, maxStringSize * 4).second;
   return StringView(start, value.size());
 }
diff --git a/velox/exec/TableScan.cpp b/velox/exec/TableScan.cpp
index bbed926d186cc..1a61ba9be667a 100644
--- a/velox/exec/TableScan.cpp
+++ b/velox/exec/TableScan.cpp
@@ -14,21 +14,19 @@
  * limitations under the License.
  */
 #include "velox/exec/TableScan.h"
-
+#include "velox/common/testutil/TestValue.h"
 #include "velox/common/time/Timer.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/Expr.h"
 
-DEFINE_int32(split_preload_per_driver, 2, "Prefetch split metadata");
+using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
 
-std::atomic<uint64_t> TableScan::ioWaitNanos_;
-
 TableScan::TableScan(
     int32_t operatorId,
     DriverCtx* driverCtx,
-    std::shared_ptr<const core::TableScanNode> tableScanNode)
+    const std::shared_ptr<const core::TableScanNode>& tableScanNode)
     : SourceOperator(
           driverCtx,
           tableScanNode->outputType(),
@@ -44,22 +42,67 @@ TableScan::TableScan(
           driverCtx_->driverId,
           operatorType(),
           tableHandle_->connectorId())),
-      readBatchSize_(driverCtx_->task->queryCtx()
-                         ->queryConfig()
-                         .preferredOutputBatchRows()),
-      maxReadBatchSize_(
-          driverCtx_->task->queryCtx()->queryConfig().maxOutputBatchRows()) {
+      maxSplitPreloadPerDriver_(
+          driverCtx_->queryConfig().maxSplitPreloadPerDriver()),
+      readBatchSize_(driverCtx_->queryConfig().preferredOutputBatchRows()),
+      maxReadBatchSize_(driverCtx_->queryConfig().maxOutputBatchRows()),
+      getOutputTimeLimitMs_(
+          driverCtx_->queryConfig().tableScanGetOutputTimeLimitMs()) {
   connector_ = connector::getConnector(tableHandle_->connectorId());
 }
 
+folly::dynamic TableScan::toJson() const {
+  auto ret = SourceOperator::toJson();
+  ret["status"] = curStatus_.load();
+  return ret;
+}
+
+bool TableScan::shouldYield(StopReason taskStopReason, size_t startTimeMs)
+    const {
+  // Checks task-level yield signal, driver-level yield signal and table scan
+  // output processing time limit.
+  return taskStopReason == StopReason::kYield ||
+      driverCtx_->driver->shouldYield() ||
+      ((getOutputTimeLimitMs_ != 0) &&
+       (getCurrentTimeMs() - startTimeMs) >= getOutputTimeLimitMs_);
+}
+
+bool TableScan::shouldStop(StopReason taskStopReason) const {
+  return taskStopReason != StopReason::kNone &&
+      taskStopReason != StopReason::kYield;
+}
+
 RowVectorPtr TableScan::getOutput() {
+  auto exitCurStatusGuard = folly::makeGuard([this]() { curStatus_ = ""; });
+
   if (noMoreSplits_) {
     return nullptr;
   }
 
+  curStatus_ = "getOutput: enter";
+  const auto startTimeMs = getCurrentTimeMs();
   for (;;) {
     if (needNewSplit_) {
+      // Check if our Task needs us to yield or we've been running for too long
+      // w/o producing a result. In this case we return with the Yield blocking
+      // reason and an already fulfilled future.
+      curStatus_ = "getOutput: task->shouldStop";
+      const StopReason taskStopReason = driverCtx_->task->shouldStop();
+      if (shouldStop(taskStopReason) ||
+          shouldYield(taskStopReason, startTimeMs)) {
+        blockingReason_ = BlockingReason::kYield;
+        blockingFuture_ = ContinueFuture{folly::Unit{}};
+        // A point for test code injection.
+        TestValue::adjust(
+            "facebook::velox::exec::TableScan::getOutput::yield", this);
+        return nullptr;
+      }
+
+      // A point for test code injection.
+      TestValue::adjust("facebook::velox::exec::TableScan::getOutput", this);
+
       exec::Split split;
+      curStatus_ = "getOutput: task->getSplitOrFuture";
       blockingReason_ = driverCtx_->task->getSplitOrFuture(
           driverCtx_->splitGroupId,
           planNodeId(),
@@ -73,17 +116,15 @@ RowVectorPtr TableScan::getOutput() {
 
       if (!split.hasConnectorSplit()) {
         noMoreSplits_ = true;
+        dynamicFilters_.clear();
         if (dataSource_) {
-          auto connectorStats = dataSource_->runtimeStats();
+          curStatus_ = "getOutput: noMoreSplits_=1, updating stats_";
+          const auto connectorStats = dataSource_->runtimeStats();
           auto lockedStats = stats_.wlock();
           for (const auto& [name, counter] : connectorStats) {
-            if (name == "ioWaitNanos") {
-              ioWaitNanos_ += counter.value - lastIoWaitNanos_;
-              lastIoWaitNanos_ = counter.value;
-            }
-            if (UNLIKELY(lockedStats->runtimeStats.count(name) == 0)) {
-              lockedStats->runtimeStats.insert(
-                  std::make_pair(name, RuntimeMetric(counter.unit)));
+            if (FOLLY_UNLIKELY(lockedStats->runtimeStats.count(name) == 0)) {
+              lockedStats->runtimeStats.emplace(
+                  name, RuntimeMetric(counter.unit));
             } else {
               VELOX_CHECK_EQ(
                   lockedStats->runtimeStats.at(name).unit, counter.unit);
@@ -95,14 +136,20 @@ RowVectorPtr TableScan::getOutput() {
       }
 
       const auto& connectorSplit = split.connectorSplit;
+      currentSplitWeight_ = connectorSplit->splitWeight;
       needNewSplit_ = false;
 
+      // A point for test code injection.
+      TestValue::adjust(
+          "facebook::velox::exec::TableScan::getOutput::gotSplit", this);
+
       VELOX_CHECK_EQ(
           connector_->connectorId(),
           connectorSplit->connectorId,
           "Got splits with different connector IDs");
 
-      if (!dataSource_) {
+      if (dataSource_ == nullptr) {
+        curStatus_ = "getOutput: creating dataSource_";
         connectorQueryCtx_ = operatorCtx_->createConnectorQueryCtx(
             connectorSplit->connectorId, planNodeId(), connectorPool_);
         dataSource_ = connector_->createDataSource(
@@ -110,10 +157,9 @@ RowVectorPtr TableScan::getOutput() {
             tableHandle_,
             columnHandles_,
             connectorQueryCtx_.get());
-        for (const auto& entry : pendingDynamicFilters_) {
+        for (const auto& entry : dynamicFilters_) {
           dataSource_->addDynamicFilter(entry.first, entry.second);
         }
-        pendingDynamicFilters_.clear();
       }
 
       debugString_ = fmt::format(
@@ -127,12 +173,15 @@ RowVectorPtr TableScan::getOutput() {
            },
            &debugString_});
 
-      if (connectorSplit->dataSource) {
+      if (connectorSplit->dataSource != nullptr) {
+        curStatus_ = "getOutput: preloaded split";
         ++numPreloadedSplits_;
-        // The AsyncSource returns a unique_ptr to a shared_ptr. The
-        // unique_ptr will be nullptr if there was a cancellation.
+        // The AsyncSource returns a unique_ptr to a shared_ptr. The unique_ptr
+        // will be nullptr if there was a cancellation.
         numReadyPreloadedSplits_ += connectorSplit->dataSource->hasValue();
         auto preparedDataSource = connectorSplit->dataSource->move();
+        stats_.wlock()->getOutputTiming.add(
+            connectorSplit->dataSource->prepareTiming());
         if (!preparedDataSource) {
           // There must be a cancellation.
           VELOX_CHECK(operatorCtx_->task()->isCancelled());
@@ -140,55 +189,74 @@ RowVectorPtr TableScan::getOutput() {
         }
         dataSource_->setFromDataSource(std::move(preparedDataSource));
       } else {
-        dataSource_->addSplit(connectorSplit);
+        curStatus_ = "getOutput: adding split";
+        uint64_t addSplitTimeUs{0};
+        {
+          MicrosecondTimer timer(&addSplitTimeUs);
+          dataSource_->addSplit(connectorSplit);
+        }
+        stats_.wlock()->addRuntimeStat(
+            "dataSourceAddSplitWallNanos",
+            RuntimeCounter(
+                addSplitTimeUs * 1'000, RuntimeCounter::Unit::kNanos));
       }
+      curStatus_ = "getOutput: updating stats_.numSplits";
       ++stats_.wlock()->numSplits;
 
-      auto estimatedRowSize = dataSource_->estimatedRowSize();
+      curStatus_ = "getOutput: dataSource_->estimatedRowSize";
+      const auto estimatedRowSize = dataSource_->estimatedRowSize();
       readBatchSize_ =
           estimatedRowSize == connector::DataSource::kUnknownRowSize
           ? outputBatchRows()
           : outputBatchRows(estimatedRowSize);
     }
 
-    const auto ioTimeStartMicros = getCurrentTimeMicro();
     // Check for  cancellation since scans that filter everything out will not
     // hit the check in Driver.
+    curStatus_ = "getOutput: task->isCancelled";
     if (operatorCtx_->task()->isCancelled()) {
       return nullptr;
     }
+
     ExceptionContextSetter exceptionContext(
         {[](VeloxException::Type /*exceptionType*/, auto* debugString) {
            return *static_cast<std::string*>(debugString);
          },
          &debugString_});
 
-    int readBatchSize = readBatchSize_;
+    int32_t readBatchSize = readBatchSize_;
     if (maxFilteringRatio_ > 0) {
       readBatchSize = std::min(
           maxReadBatchSize_,
-          static_cast<int>(readBatchSize / maxFilteringRatio_));
+          static_cast<int32_t>(readBatchSize / maxFilteringRatio_));
+    }
+    curStatus_ = "getOutput: dataSource_->next";
+    uint64_t ioTimeUs{0};
+    std::optional<RowVectorPtr> dataOptional;
+    {
+      MicrosecondTimer timer(&ioTimeUs);
+      dataOptional = dataSource_->next(readBatchSize, blockingFuture_);
     }
-    auto dataOptional = dataSource_->next(readBatchSize, blockingFuture_);
-    checkPreload();
 
+    curStatus_ = "getOutput: checkPreload";
+    checkPreload();
     {
+      curStatus_ = "getOutput: updating stats_.dataSourceReadWallNanos";
       auto lockedStats = stats_.wlock();
       lockedStats->addRuntimeStat(
-          "dataSourceWallNanos",
-          RuntimeCounter(
-              (getCurrentTimeMicro() - ioTimeStartMicros) * 1'000,
-              RuntimeCounter::Unit::kNanos));
+          "dataSourceReadWallNanos",
+          RuntimeCounter(ioTimeUs * 1'000, RuntimeCounter::Unit::kNanos));
 
       if (!dataOptional.has_value()) {
         blockingReason_ = BlockingReason::kWaitForConnector;
         return nullptr;
       }
 
+      curStatus_ = "getOutput: updating stats_.rawInput";
       lockedStats->rawInputPositions = dataSource_->getCompletedRows();
       lockedStats->rawInputBytes = dataSource_->getCompletedBytes();
-      auto data = dataOptional.value();
-      if (data) {
+      RowVectorPtr data = std::move(dataOptional).value();
+      if (data != nullptr) {
         if (data->size() > 0) {
           lockedStats->addInputVector(data->estimateFlatSize(), data->size());
           constexpr int kMaxSelectiveBatchSizeMultiplier = 4;
@@ -203,6 +271,7 @@ RowVectorPtr TableScan::getOutput() {
     }
 
     {
+      curStatus_ = "getOutput: updating stats_.preloadedSplits";
       auto lockedStats = stats_.wlock();
       if (numPreloadedSplits_ > 0) {
         lockedStats->addRuntimeStat(
@@ -216,12 +285,14 @@ RowVectorPtr TableScan::getOutput() {
       }
     }
 
-    driverCtx_->task->splitFinished();
+    curStatus_ = "getOutput: task->splitFinished";
+    driverCtx_->task->splitFinished(true, currentSplitWeight_);
     needNewSplit_ = true;
   }
 }
 
-void TableScan::preload(std::shared_ptr<connector::ConnectorSplit> split) {
+void TableScan::preload(
+    const std::shared_ptr<connector::ConnectorSplit>& split) {
   // The AsyncSource returns a unique_ptr to the shared_ptr of the
   // DataSource. The callback may outlive the Task, hence it captures
   // a shared_ptr to it. This is required to keep memory pools live
@@ -235,6 +306,7 @@ void TableScan::preload(std::shared_ptr<connector::ConnectorSplit> split) {
        ctx = operatorCtx_->createConnectorQueryCtx(
            split->connectorId, planNodeId(), connectorPool_),
        task = operatorCtx_->task(),
+       dynamicFilters = dynamicFilters_,
        split]() -> std::unique_ptr<connector::DataSource> {
         if (task->isCancelled()) {
           return nullptr;
@@ -247,32 +319,37 @@ void TableScan::preload(std::shared_ptr<connector::ConnectorSplit> split) {
              },
              &debugString});
 
-        auto ptr = connector->createDataSource(type, table, columns, ctx.get());
+        auto dataSource =
+            connector->createDataSource(type, table, columns, ctx.get());
         if (task->isCancelled()) {
           return nullptr;
         }
-        ptr->addSplit(split);
-        return ptr;
+        for (const auto& entry : dynamicFilters) {
+          dataSource->addDynamicFilter(entry.first, entry.second);
+        }
+        dataSource->addSplit(split);
+        return dataSource;
       });
 }
 
 void TableScan::checkPreload() {
-  auto executor = connector_->executor();
-  if (FLAGS_split_preload_per_driver == 0 || !executor ||
+  auto* executor = connector_->executor();
+  if (maxSplitPreloadPerDriver_ == 0 || !executor ||
       !connector_->supportsSplitPreload()) {
     return;
   }
   if (dataSource_->allPrefetchIssued()) {
     maxPreloadedSplits_ = driverCtx_->task->numDrivers(driverCtx_->driver) *
-        FLAGS_split_preload_per_driver;
+        maxSplitPreloadPerDriver_;
     if (!splitPreloader_) {
       splitPreloader_ =
-          [executor, this](std::shared_ptr<connector::ConnectorSplit> split) {
+          [executor,
+           this](const std::shared_ptr<connector::ConnectorSplit>& split) {
             preload(split);
 
-            executor->add([taskHolder = operatorCtx_->task(), split]() mutable {
-              split->dataSource->prepare();
-              split.reset();
+            executor->add([connectorSplit = split]() mutable {
+              connectorSplit->dataSource->prepare();
+              connectorSplit.reset();
             });
           };
     }
@@ -284,13 +361,19 @@ bool TableScan::isFinished() {
 }
 
 void TableScan::addDynamicFilter(
+    const core::PlanNodeId& producer,
     column_index_t outputChannel,
     const std::shared_ptr<common::Filter>& filter) {
   if (dataSource_) {
     dataSource_->addDynamicFilter(outputChannel, filter);
+  }
+  auto& currentFilter = dynamicFilters_[outputChannel];
+  if (currentFilter) {
+    currentFilter = currentFilter->mergeWith(filter.get());
   } else {
-    pendingDynamicFilters_.emplace(outputChannel, filter);
+    currentFilter = filter;
   }
+  stats_.wlock()->dynamicFilterStats.producerNodeIds.emplace(producer);
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TableScan.h b/velox/exec/TableScan.h
index 5606c2aa49f32..deec109b02c1f 100644
--- a/velox/exec/TableScan.h
+++ b/velox/exec/TableScan.h
@@ -18,8 +18,6 @@
 #include "velox/core/PlanNode.h"
 #include "velox/exec/Operator.h"
 
-DECLARE_int32(split_preload_per_driver);
-
 namespace facebook::velox::exec {
 
 class TableScan : public SourceOperator {
@@ -27,7 +25,9 @@ class TableScan : public SourceOperator {
   TableScan(
       int32_t operatorId,
       DriverCtx* driverCtx,
-      std::shared_ptr<const core::TableScanNode> tableScanNode);
+      const std::shared_ptr<const core::TableScanNode>& tableScanNode);
+
+  folly::dynamic toJson() const override;
 
   RowVectorPtr getOutput() override;
 
@@ -46,31 +46,29 @@ class TableScan : public SourceOperator {
   }
 
   void addDynamicFilter(
+      const core::PlanNodeId& producer,
       column_index_t outputChannel,
       const std::shared_ptr<common::Filter>& filter) override;
 
-  /// Returns process-wide cumulative IO wait time for all table
-  /// scan. This is the blocked time. If running entirely from memory
-  /// this would be 0.
-  static uint64_t ioWaitNanos() {
-    return ioWaitNanos_;
-  }
-
  private:
-  // Sets 'maxPreloadSplits' and 'splitPreloader' if prefetching
-  // splits is appropriate. The preloader will be applied to the
-  // 'first 'maxPreloadSplits' of the Tasks's split queue for 'this'
-  // when getting splits.
-  void checkPreload();
+  // Checks if this table scan operator needs to yield before processing the
+  // next split.
+  bool shouldYield(StopReason taskStopReason, size_t startTimeMs) const;
 
-  // Sets 'split->dataSource' to be a Asyncsource that makes a
-  // DataSource to read 'split'. This source will be prepared in the
-  // background on the executor of the connector. If the DataSource is
-  // needed before prepare is done, it will be made when needed.
-  void preload(std::shared_ptr<connector::ConnectorSplit> split);
+  // Checks if this table scan operator needs to stop because the task has been
+  // terminated.
+  bool shouldStop(StopReason taskStopReason) const;
 
-  // Process-wide IO wait time.
-  static std::atomic<uint64_t> ioWaitNanos_;
+  // Sets 'maxPreloadSplits' and 'splitPreloader' if prefetching splits is
+  // appropriate. The preloader will be applied to the 'first 'maxPreloadSplits'
+  // of the Task's split queue for 'this' when getting splits.
+  void checkPreload();
+
+  // Sets 'split->dataSource' to be an AsyncSource that makes a DataSource to
+  // read 'split'. This source will be prepared in the background on the
+  // executor of the connector. If the DataSource is needed before prepare is
+  // done, it will be made when needed.
+  void preload(const std::shared_ptr<connector::ConnectorSplit>& split);
 
   const std::shared_ptr<connector::ConnectorTableHandle> tableHandle_;
   const std::
@@ -79,7 +77,8 @@ class TableScan : public SourceOperator {
   DriverCtx* const driverCtx_;
   memory::MemoryPool* const connectorPool_;
   ContinueFuture blockingFuture_{ContinueFuture::makeEmpty()};
-  BlockingReason blockingReason_;
+  BlockingReason blockingReason_{BlockingReason::kNotBlocked};
+  int64_t currentSplitWeight_{0};
   bool needNewSplit_ = true;
   std::shared_ptr<connector::Connector> connector_;
   std::shared_ptr<connector::ConnectorQueryCtx> connectorQueryCtx_;
@@ -87,16 +86,17 @@ class TableScan : public SourceOperator {
   bool noMoreSplits_ = false;
   // Dynamic filters to add to the data source when it gets created.
   std::unordered_map<column_index_t, std::shared_ptr<common::Filter>>
-      pendingDynamicFilters_;
+      dynamicFilters_;
 
   int32_t maxPreloadedSplits_{0};
 
-  // Callback passed to getSplitOrFuture() for triggering async
-  // preload. The callback's lifetime is the lifetime of 'this'. This
-  // callback can schedule preloads on an executor. These preloads may
-  // outlive the Task and therefore need to capture a shared_ptr to
-  // it.
-  std::function<void(std::shared_ptr<connector::ConnectorSplit>)>
+  const int32_t maxSplitPreloadPerDriver_{0};
+
+  // Callback passed to getSplitOrFuture() for triggering async preload. The
+  // callback's lifetime is the lifetime of 'this'. This callback can schedule
+  // preloads on an executor. These preloads may outlive the Task and therefore
+  // need to capture a shared_ptr to it.
+  std::function<void(const std::shared_ptr<connector::ConnectorSplit>&)>
       splitPreloader_{nullptr};
 
   // Count of splits that started background preload.
@@ -105,15 +105,20 @@ class TableScan : public SourceOperator {
   // Count of splits that finished preloading before being read.
   int32_t numReadyPreloadedSplits_{0};
 
-  int32_t readBatchSize_;
-  int32_t maxReadBatchSize_;
+  vector_size_t readBatchSize_;
+  vector_size_t maxReadBatchSize_;
+
+  // Exits getOutput() method after this many milliseconds. Zero means 'no
+  // limit'.
+  size_t getOutputTimeLimitMs_{0};
+
   double maxFilteringRatio_{0};
 
   // String shown in ExceptionContext inside DataSource and LazyVector loading.
   std::string debugString_;
 
-  // The last value of the IO wait time of 'this' that has been added to the
-  // global static 'ioWaitNanos_'.
-  uint64_t lastIoWaitNanos_{0};
+  // Holds the current status of the operator. Used when debugging to understand
+  // what operator is doing.
+  std::atomic<const char*> curStatus_{""};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TableWriteMerge.cpp b/velox/exec/TableWriteMerge.cpp
index 41f783b53b01d..69528e9338e36 100644
--- a/velox/exec/TableWriteMerge.cpp
+++ b/velox/exec/TableWriteMerge.cpp
@@ -64,6 +64,13 @@ TableWriteMerge::TableWriteMerge(
   }
 }
 
+void TableWriteMerge::initialize() {
+  Operator::initialize();
+  if (aggregation_ != nullptr) {
+    aggregation_->initialize();
+  }
+}
+
 void TableWriteMerge::addInput(RowVectorPtr input) {
   VELOX_CHECK(!noMoreInput_);
   VELOX_CHECK_GT(input->size(), 0);
diff --git a/velox/exec/TableWriteMerge.h b/velox/exec/TableWriteMerge.h
index 0b5002a5ae049..9e915aa6574c3 100644
--- a/velox/exec/TableWriteMerge.h
+++ b/velox/exec/TableWriteMerge.h
@@ -31,6 +31,8 @@ class TableWriteMerge : public Operator {
       const std::shared_ptr<const core::TableWriteMergeNode>&
           tableWriteMergeNode);
 
+  void initialize() override;
+
   BlockingReason isBlocked(ContinueFuture* /* future */) override {
     return BlockingReason::kNotBlocked;
   }
diff --git a/velox/exec/TableWriter.cpp b/velox/exec/TableWriter.cpp
index ed317e41c32e2..9bd199cfe9ffc 100644
--- a/velox/exec/TableWriter.cpp
+++ b/velox/exec/TableWriter.cpp
@@ -44,7 +44,7 @@ TableWriter::TableWriter(
       insertTableHandle_(
           tableWriteNode->insertTableHandle()->connectorInsertTableHandle()),
       commitStrategy_(tableWriteNode->commitStrategy()) {
-  setConnectorOrWriterMemoryReclaimer(connectorPool_);
+  setConnectorMemoryReclaimer();
   if (tableWriteNode->outputType()->size() == 1) {
     VELOX_USER_CHECK_NULL(tableWriteNode->aggregationNode());
   } else {
@@ -62,9 +62,6 @@ TableWriter::TableWriter(
       connectorId,
       planNodeId(),
       connectorPool_,
-      [this](memory::MemoryPool* pool) {
-        setConnectorOrWriterMemoryReclaimer(pool);
-      },
       spillConfig_.has_value() ? &(spillConfig_.value()) : nullptr);
 
   auto names = tableWriteNode->columnNames();
@@ -84,6 +81,9 @@ void TableWriter::initialize() {
   Operator::initialize();
   VELOX_CHECK_NULL(dataSink_);
   createDataSink();
+  if (aggregation_ != nullptr) {
+    aggregation_->initialize();
+  }
 }
 
 void TableWriter::createDataSink() {
@@ -96,9 +96,14 @@ void TableWriter::createDataSink() {
 
 void TableWriter::abortDataSink() {
   VELOX_CHECK(!closed_);
-  closed_ = true;
+  auto abortGuard = folly::makeGuard([this]() { closed_ = true; });
   if (dataSink_ != nullptr) {
-    dataSink_->close(false);
+    try {
+      dataSink_->abort();
+    } catch (const std::exception& e) {
+      LOG(WARNING) << "Failed to abort data sink from table writer: "
+                   << toString() << ", error: " << e.what();
+    }
   }
 }
 
@@ -106,8 +111,8 @@ std::vector<std::string> TableWriter::closeDataSink() {
   // We only expect closeDataSink called once.
   VELOX_CHECK(!closed_);
   VELOX_CHECK_NOT_NULL(dataSink_);
-  closed_ = true;
-  return dataSink_->close(true);
+  auto closeGuard = folly::makeGuard([this]() { closed_ = true; });
+  return dataSink_->close();
 }
 
 void TableWriter::addInput(RowVectorPtr input) {
@@ -131,7 +136,7 @@ void TableWriter::addInput(RowVectorPtr input) {
 
   dataSink_->appendData(mappedInput);
   numWrittenRows_ += input->size();
-  updateWrittenBytes();
+  updateStats(dataSink_->stats());
 
   if (aggregation_ != nullptr) {
     aggregation_->addInput(input);
@@ -161,9 +166,8 @@ RowVectorPtr TableWriter::getOutput() {
   }
 
   finished_ = true;
-  updateWrittenBytes();
-  updateNumWrittenFiles();
   const std::vector<std::string> fragments = closeDataSink();
+  updateStats(dataSink_->stats());
 
   if (outputType_->size() == 1) {
     // NOTE: this is for non-prestissimo use cases.
@@ -176,10 +180,10 @@ RowVectorPtr TableWriter::getOutput() {
             pool(), 1, false /*isNull*/, BIGINT(), numWrittenRows_)});
   }
 
-  vector_size_t numOutputRows = fragments.size() + 1;
+  const vector_size_t numOutputRows = fragments.size() + 1;
 
   // Page layout:
-  // row     fragments     context    [partition]    [stats]
+  // row     fragments     context    [partition]     [stats]
   // X         null          X        [null]          [null]
   // null       X            X        [null]          [null]
   // null       X            X        [null]          [null]
@@ -237,19 +241,30 @@ std::string TableWriter::createTableCommitContext(bool lastOutput) {
   // clang-format on
 }
 
-void TableWriter::updateWrittenBytes() {
-  const auto writtenBytes = dataSink_->getCompletedBytes();
-  auto lockedStats = stats_.wlock();
-  lockedStats->physicalWrittenBytes = writtenBytes;
-}
-
-void TableWriter::updateNumWrittenFiles() {
-  auto lockedStats = stats_.wlock();
-  lockedStats->addRuntimeStat(
-      "numWrittenFiles", RuntimeCounter(dataSink_->numWrittenFiles()));
+void TableWriter::updateStats(const connector::DataSink::Stats& stats) {
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->physicalWrittenBytes = stats.numWrittenBytes;
+    if (!closed_) {
+      // NOTE: the other stats is only set when hive data sink is closed.
+      VELOX_CHECK_EQ(stats.numWrittenFiles, 0);
+      VELOX_CHECK(stats.spillStats.empty());
+      return;
+    }
+    lockedStats->addRuntimeStat(
+        "numWrittenFiles", RuntimeCounter(stats.numWrittenFiles));
+    lockedStats->addRuntimeStat(
+        "writeIOTime",
+        RuntimeCounter(
+            stats.writeIOTimeUs * 1000, RuntimeCounter::Unit::kNanos));
+  }
+  if (!stats.spillStats.empty()) {
+    *spillStats_.wlock() += stats.spillStats;
+  }
 }
 
 void TableWriter::close() {
+  Operator::close();
   if (!closed_) {
     // Abort the data sink if the query has already failed and no need for
     // regular close.
@@ -260,44 +275,76 @@ void TableWriter::close() {
   }
 }
 
-void TableWriter::setConnectorOrWriterMemoryReclaimer(
-    memory::MemoryPool* pool) {
-  VELOX_CHECK_NOT_NULL(pool);
-  if (operatorCtx_->pool()->reclaimer() != nullptr) {
-    pool->setReclaimer(
-        TableWriter::MemoryReclaimer::create(operatorCtx_->driverCtx(), this));
+void TableWriter::setConnectorMemoryReclaimer() {
+  VELOX_CHECK_NOT_NULL(connectorPool_);
+  if (connectorPool_->parent()->reclaimer() != nullptr) {
+    connectorPool_->setReclaimer(TableWriter::ConnectorReclaimer::create(
+        spillConfig_, operatorCtx_->driverCtx(), this));
   }
 }
 
-std::unique_ptr<memory::MemoryReclaimer> TableWriter::MemoryReclaimer::create(
+std::unique_ptr<memory::MemoryReclaimer>
+TableWriter::ConnectorReclaimer::create(
+    const std::optional<common::SpillConfig>& spillConfig,
     DriverCtx* driverCtx,
     Operator* op) {
   return std::unique_ptr<memory::MemoryReclaimer>(
-      new TableWriter::MemoryReclaimer(
-          driverCtx->driver->shared_from_this(), op));
+      new TableWriter::ConnectorReclaimer(
+          spillConfig, driverCtx->driver->shared_from_this(), op));
 }
 
-bool TableWriter::MemoryReclaimer::reclaimableBytes(
+bool TableWriter::ConnectorReclaimer::reclaimableBytes(
     const memory::MemoryPool& pool,
     uint64_t& reclaimableBytes) const {
-  VELOX_CHECK(!pool.isLeaf());
   reclaimableBytes = 0;
-  return false;
+  if (!canReclaim_) {
+    return false;
+  }
+  std::shared_ptr<Driver> driver = ensureDriver();
+  if (FOLLY_UNLIKELY(driver == nullptr)) {
+    return false;
+  }
+  return memory::MemoryReclaimer::reclaimableBytes(pool, reclaimableBytes);
 }
 
-uint64_t TableWriter::MemoryReclaimer::reclaim(
+uint64_t TableWriter::ConnectorReclaimer::reclaim(
     memory::MemoryPool* pool,
-    uint64_t /*unused*/,
-    memory::MemoryReclaimer::Stats& /*unused*/) {
-  VELOX_CHECK(!pool->isLeaf());
-  return 0;
-}
+    uint64_t targetBytes,
+    uint64_t maxWaitMs,
+    memory::MemoryReclaimer::Stats& stats) {
+  if (!canReclaim_) {
+    return 0;
+  }
+  std::shared_ptr<Driver> driver = ensureDriver();
+  if (FOLLY_UNLIKELY(driver == nullptr)) {
+    return 0;
+  }
+  VELOX_CHECK(
+      !driver->state().isOnThread() || driver->state().suspended() ||
+      driver->state().isTerminated);
+  VELOX_CHECK(driver->task()->pauseRequested());
+
+  auto* writer = dynamic_cast<TableWriter*>(op_);
+  if (writer->closed_) {
+    // TODO: reduce the log frequency if it is too verbose.
+    ++stats.numNonReclaimableAttempts;
+    LOG(WARNING) << "Can't reclaim from a closed writer connector pool: "
+                 << pool->name()
+                 << ", memory usage: " << succinctBytes(pool->reservedBytes());
+    return 0;
+  }
 
-void TableWriter::MemoryReclaimer::abort(
-    memory::MemoryPool* pool,
-    const std::exception_ptr& /* error */) {
-  VELOX_CHECK(!pool->isLeaf());
-  return;
+  if (writer->dataSink_ == nullptr) {
+    // TODO: reduce the log frequency if it is too verbose.
+    ++stats.numNonReclaimableAttempts;
+    LOG(WARNING)
+        << "Can't reclaim from a writer connector pool which hasn't initialized yet: "
+        << pool->name()
+        << ", memory usage: " << succinctBytes(pool->reservedBytes());
+    return 0;
+  }
+  RuntimeStatWriterScopeGuard opStatsGuard(op_);
+  return ParallelMemoryReclaimer::reclaim(pool, targetBytes, maxWaitMs, stats);
 }
 
 // static
diff --git a/velox/exec/TableWriter.h b/velox/exec/TableWriter.h
index 35583a36831d2..7d8cf245c0f95 100644
--- a/velox/exec/TableWriter.h
+++ b/velox/exec/TableWriter.h
@@ -16,7 +16,9 @@
 
 #pragma once
 
+#include "OperatorUtils.h"
 #include "velox/core/PlanNode.h"
+#include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/Operator.h"
 
 namespace facebook::velox::exec {
@@ -95,9 +97,6 @@ class TableWriteTraits {
       velox::memory::MemoryPool* pool);
 };
 
-/**
- * Implements a simple table writer operator.
- */
 class TableWriter : public Operator {
  public:
   TableWriter(
@@ -127,19 +126,37 @@ class TableWriter : public Operator {
     return finished_;
   }
 
+  /// NOTE: we don't reclaim memory from table write operator directly but from
+  /// its paired connector pool which reclaims memory from the file writers
+  /// created inside the connector.
+  bool canReclaim() const override {
+    return false;
+  }
+
+  OperatorStats stats(bool clear) override {
+    auto stats = Operator::stats(clear);
+    // NOTE: file writers allocates memory through 'connectorPool_', not from
+    // the table writer operator pool. So we report the memory usage from
+    // 'connectorPool_'.
+    stats.memoryStats = MemoryStats::memStatsFromPool(connectorPool_);
+    return stats;
+  }
+
  private:
-  // The memory reclaimer customized for connector and file writer memory pools.
-  //
-  // NOTE: we shall always reclaim memory from table write operator's reclaimer
-  // instead of file or connector writer's reclaimer. So the customized memory
-  // reclaimer here only handle memory arbitration enter/leave but does nothing
-  // for the actual memory reclamation related operations.
-  class MemoryReclaimer : public Operator::MemoryReclaimer {
+  // The memory reclaimer customized for connector which interface with the
+  // memory arbitrator to reclaim memory from the file writers created within
+  // the connector.
+  class ConnectorReclaimer : public exec::ParallelMemoryReclaimer {
    public:
     static std::unique_ptr<memory::MemoryReclaimer> create(
+        const std::optional<common::SpillConfig>& spillConfig,
         DriverCtx* driverCtx,
         Operator* op);
 
+    void enterArbitration() override {}
+
+    void leaveArbitration() noexcept override {}
+
     bool reclaimableBytes(
         const memory::MemoryPool& pool,
         uint64_t& reclaimableBytes) const override;
@@ -147,14 +164,30 @@ class TableWriter : public Operator {
     uint64_t reclaim(
         memory::MemoryPool* pool,
         uint64_t targetBytes,
+        uint64_t maxWaitMs,
         memory::MemoryReclaimer::Stats& stats) override;
 
     void abort(memory::MemoryPool* pool, const std::exception_ptr& /* error */)
-        override;
+        override {}
+
+    std::shared_ptr<Driver> ensureDriver() const {
+      return driver_.lock();
+    }
 
    private:
-    MemoryReclaimer(const std::shared_ptr<Driver>& driver, Operator* op)
-        : Operator::MemoryReclaimer(driver, op) {}
+    ConnectorReclaimer(
+        const std::optional<common::SpillConfig>& spillConfig,
+        const std::shared_ptr<Driver>& driver,
+        Operator* op)
+        : ParallelMemoryReclaimer(
+              spillConfig.has_value() ? spillConfig.value().executor : nullptr),
+          canReclaim_(spillConfig.has_value()),
+          driver_(driver),
+          op_(op) {}
+
+    const bool canReclaim_{false};
+    const std::weak_ptr<Driver> driver_;
+    Operator* const op_;
   };
 
   void createDataSink();
@@ -163,22 +196,18 @@ class TableWriter : public Operator {
 
   void abortDataSink();
 
-  // Updates physicalWrittenBytes in OperatorStats with current written bytes.
-  void updateWrittenBytes();
-
-  // Updates numWrittenFiles in runtimeStats.
-  void updateNumWrittenFiles();
+  void updateStats(const connector::DataSink::Stats& stats);
 
   std::string createTableCommitContext(bool lastOutput);
 
-  // Invoked to set memory reclaimer for connector and file writer memory pool.
-  void setConnectorOrWriterMemoryReclaimer(memory::MemoryPool* pool);
+  void setConnectorMemoryReclaimer();
 
   const DriverCtx* const driverCtx_;
   memory::MemoryPool* const connectorPool_;
   const std::shared_ptr<connector::ConnectorInsertTableHandle>
       insertTableHandle_;
   const connector::CommitStrategy commitStrategy_;
+
   std::unique_ptr<Operator> aggregation_;
   std::shared_ptr<connector::Connector> connector_;
   std::shared_ptr<connector::ConnectorQueryCtx> connectorQueryCtx_;
diff --git a/velox/exec/Task.cpp b/velox/exec/Task.cpp
index 20c18b92e0a25..6c108dafd1960 100644
--- a/velox/exec/Task.cpp
+++ b/velox/exec/Task.cpp
@@ -18,22 +18,20 @@
 #include <boost/uuid/uuid_io.hpp>
 #include <string>
 
-#include "velox/codegen/Codegen.h"
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/StatsReporter.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/common/time/Timer.h"
 #include "velox/exec/Exchange.h"
 #include "velox/exec/HashBuild.h"
 #include "velox/exec/LocalPlanner.h"
 #include "velox/exec/MemoryReclaimer.h"
-#include "velox/exec/Merge.h"
 #include "velox/exec/NestedLoopJoinBuild.h"
 #include "velox/exec/OperatorUtils.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/Task.h"
-#if CODEGEN_ENABLED == 1
-#include "velox/experimental/codegen/CodegenLogger.h"
-#endif
-#include "velox/common/testutil/TestValue.h"
+#include "velox/exec/trace/QueryTraceUtil.h"
 
 using facebook::velox::common::testutil::TestValue;
 
@@ -45,7 +43,7 @@ namespace {
 // Inactive on creation. Must be activated explicitly by calling 'activate'.
 class EventCompletionNotifier {
  public:
-  /// Calls notify() if it hasn't been called yet.
+  // Calls notify() if it hasn't been called yet.
   ~EventCompletionNotifier() {
     notify();
   }
@@ -132,7 +130,8 @@ void buildSplitStates(
     // Not all leaf nodes require splits. ValuesNode doesn't. Check if this plan
     // node requires splits.
     if (planNode->requiresSplits()) {
-      splitStateMap[planNode->id()];
+      splitStateMap[planNode->id()].sourceIsTableScan =
+          (dynamic_cast<const core::TableScanNode*>(planNode) != nullptr);
     }
     return;
   }
@@ -161,8 +160,38 @@ std::string makeUuid() {
 bool isHashJoinOperator(const std::string& operatorType) {
   return (operatorType == "HashBuild") || (operatorType == "HashProbe");
 }
+
+// Moves split promises from one vector to another.
+void movePromisesOut(
+    std::vector<ContinuePromise>& from,
+    std::vector<ContinuePromise>& to) {
+  if (to.empty()) {
+    to.swap(from);
+    return;
+  }
+
+  for (auto& promise : from) {
+    to.emplace_back(std::move(promise));
+  }
+  from.clear();
+}
 } // namespace
 
+std::string executionModeString(Task::ExecutionMode mode) {
+  switch (mode) {
+    case Task::ExecutionMode::kSerial:
+      return "Serial";
+    case Task::ExecutionMode::kParallel:
+      return "Parallel";
+    default:
+      return fmt::format("Unknown {}", static_cast<int>(mode));
+  }
+}
+
+std::ostream& operator<<(std::ostream& out, Task::ExecutionMode mode) {
+  return out << executionModeString(mode);
+}
+
 std::string taskStateString(TaskState state) {
   switch (state) {
     case TaskState::kRunning:
@@ -216,6 +245,7 @@ std::shared_ptr<Task> Task::create(
     core::PlanFragment planFragment,
     int destination,
     std::shared_ptr<core::QueryCtx> queryCtx,
+    ExecutionMode mode,
     Consumer consumer,
     std::function<void(std::exception_ptr)> onError) {
   return Task::create(
@@ -223,16 +253,19 @@ std::shared_ptr<Task> Task::create(
       std::move(planFragment),
       destination,
       std::move(queryCtx),
+      mode,
       (consumer ? [c = std::move(consumer)]() { return c; }
                 : ConsumerSupplier{}),
       std::move(onError));
 }
 
+// static
 std::shared_ptr<Task> Task::create(
     const std::string& taskId,
     core::PlanFragment planFragment,
     int destination,
     std::shared_ptr<core::QueryCtx> queryCtx,
+    ExecutionMode mode,
     ConsumerSupplier consumerSupplier,
     std::function<void(std::exception_ptr)> onError) {
   auto task = std::shared_ptr<Task>(new Task(
@@ -240,6 +273,7 @@ std::shared_ptr<Task> Task::create(
       std::move(planFragment),
       destination,
       std::move(queryCtx),
+      mode,
       std::move(consumerSupplier),
       std::move(onError)));
   task->initTaskPool();
@@ -251,6 +285,7 @@ Task::Task(
     core::PlanFragment planFragment,
     int destination,
     std::shared_ptr<core::QueryCtx> queryCtx,
+    ExecutionMode mode,
     ConsumerSupplier consumerSupplier,
     std::function<void(std::exception_ptr)> onError)
     : uuid_{makeUuid()},
@@ -258,26 +293,66 @@ Task::Task(
       planFragment_(std::move(planFragment)),
       destination_(destination),
       queryCtx_(std::move(queryCtx)),
+      traceConfig_(maybeMakeTraceConfig()),
+      mode_(mode),
       consumerSupplier_(std::move(consumerSupplier)),
-      onError_(onError),
+      onError_(std::move(onError)),
       splitsStates_(buildSplitStates(planFragment_.planNode)),
-      bufferManager_(PartitionedOutputBufferManager::getInstance()) {}
+      bufferManager_(OutputBufferManager::getInstance()) {
+  // NOTE: the executor must not be folly::InlineLikeExecutor for parallel
+  // execution.
+  if (mode_ == Task::ExecutionMode::kParallel) {
+    VELOX_CHECK_NULL(
+        dynamic_cast<const folly::InlineLikeExecutor*>(queryCtx_->executor()));
+  }
+
+  maybeInitQueryTrace();
+}
 
 Task::~Task() {
-  TestValue::adjust("facebook::velox::exec::Task::~Task", this);
+  // TODO(spershin): Temporary code designed to reveal what causes SIGABRT in
+  // jemalloc when destroying some Tasks.
+  std::string clearStage;
+  facebook::velox::process::ThreadDebugInfo debugInfoForTask{
+      queryCtx_->queryId(), taskId_, [&]() {
+        LOG(ERROR) << "Task::~Task(" << taskId_
+                   << "), failure during clearing stage: " << clearStage;
+      }};
+  facebook::velox::process::ScopedThreadDebugInfo scopedInfo(debugInfoForTask);
 
-  try {
-    if (hasPartitionedOutput()) {
-      if (auto bufferManager = bufferManager_.lock()) {
-        bufferManager->removeTask(taskId_);
-      }
-    }
-  } catch (const std::exception& e) {
-    LOG(WARNING) << "Caught exception in Task " << taskId()
-                 << " destructor: " << e.what();
-  }
+  TestValue::adjust("facebook::velox::exec::Task::~Task", this);
 
+  clearStage = "removeSpillDirectoryIfExists";
   removeSpillDirectoryIfExists();
+
+  // TODO(spershin): Temporary code designed to reveal what causes SIGABRT in
+  // jemalloc when destroying some Tasks.
+#define CLEAR(_action_)   \
+  clearStage = #_action_; \
+  _action_;
+  CLEAR(threadFinishPromises_.clear());
+  CLEAR(splitGroupStates_.clear());
+  CLEAR(taskStats_ = TaskStats());
+  CLEAR(stateChangePromises_.clear());
+  CLEAR(taskCompletionPromises_.clear());
+  CLEAR(splitsStates_.clear());
+  CLEAR(drivers_.clear());
+  CLEAR(driverFactories_.clear());
+  CLEAR(onError_ = [](std::exception_ptr) {});
+  CLEAR(exchangeClientByPlanNode_.clear());
+  CLEAR(exchangeClients_.clear());
+  CLEAR(exception_ = nullptr);
+  CLEAR(nodePools_.clear());
+  CLEAR(childPools_.clear());
+  CLEAR(pool_.reset());
+  CLEAR(planFragment_ = core::PlanFragment());
+  clearStage = "exiting ~Task()";
+
+  // Ful-fill the task deletion promises at the end.
+  auto taskDeletionPromises = std::move(taskDeletionPromises_);
+  for (auto& promise : taskDeletionPromises) {
+    promise.setValue();
+  }
 }
 
 uint64_t Task::timeSinceStartMsLocked() const {
@@ -309,18 +384,49 @@ bool Task::allNodesReceivedNoMoreSplitsMessageLocked() const {
   return true;
 }
 
+const std::string& Task::getOrCreateSpillDirectory() {
+  VELOX_CHECK(!spillDirectory_.empty(), "Spill directory not set");
+  if (spillDirectoryCreated_) {
+    return spillDirectory_;
+  }
+
+  std::lock_guard<std::mutex> l(spillDirCreateMutex_);
+  if (spillDirectoryCreated_) {
+    return spillDirectory_;
+  }
+  try {
+    auto fileSystem = filesystems::getFileSystem(spillDirectory_, nullptr);
+    fileSystem->mkdir(spillDirectory_);
+  } catch (const std::exception& e) {
+    VELOX_FAIL(
+        "Failed to create spill directory '{}' for Task {}: {}",
+        spillDirectory_,
+        taskId(),
+        e.what());
+  }
+  spillDirectoryCreated_ = true;
+  return spillDirectory_;
+}
+
 void Task::removeSpillDirectoryIfExists() {
-  if (!spillDirectory_.empty()) {
-    try {
-      auto fs = filesystems::getFileSystem(spillDirectory_, nullptr);
-      fs->rmdir(spillDirectory_);
-    } catch (const std::exception& e) {
-      LOG(ERROR) << "Failed to remove spill directory '" << spillDirectory_
-                 << "' for Task " << taskId() << ": " << e.what();
-    }
+  if (spillDirectory_.empty() || !spillDirectoryCreated_) {
+    return;
+  }
+  try {
+    auto fs = filesystems::getFileSystem(spillDirectory_, nullptr);
+    fs->rmdir(spillDirectory_);
+  } catch (const std::exception& e) {
+    LOG(ERROR) << "Failed to remove spill directory '" << spillDirectory_
+               << "' for Task " << taskId() << ": " << e.what();
   }
 }
 
+uint64_t Task::driverCpuTimeSliceLimitMs() const {
+  return mode_ == Task::ExecutionMode::kSerial
+      ? 0
+      : queryCtx_->queryConfig().driverCpuTimeSliceLimitMs();
+}
+
 void Task::initTaskPool() {
   VELOX_CHECK_NULL(pool_);
   pool_ = queryCtx_->pool()->addAggregateChild(
@@ -328,18 +434,33 @@ void Task::initTaskPool() {
 }
 
 velox::memory::MemoryPool* Task::getOrAddNodePool(
-    const core::PlanNodeId& planNodeId,
-    bool isHashJoinNode) {
+    const core::PlanNodeId& planNodeId) {
   if (nodePools_.count(planNodeId) == 1) {
     return nodePools_[planNodeId];
   }
   childPools_.push_back(pool_->addAggregateChild(
-      fmt::format("node.{}", planNodeId), createNodeReclaimer(isHashJoinNode)));
+      fmt::format("node.{}", planNodeId), createNodeReclaimer(false)));
   auto* nodePool = childPools_.back().get();
   nodePools_[planNodeId] = nodePool;
   return nodePool;
 }
 
+memory::MemoryPool* Task::getOrAddJoinNodePool(
+    const core::PlanNodeId& planNodeId,
+    uint32_t splitGroupId) {
+  const std::string nodeId = splitGroupId == kUngroupedGroupId
+      ? planNodeId
+      : fmt::format("{}[{}]", planNodeId, splitGroupId);
+  if (nodePools_.count(nodeId) == 1) {
+    return nodePools_[nodeId];
+  }
+  childPools_.push_back(pool_->addAggregateChild(
+      fmt::format("node.{}", nodeId), createNodeReclaimer(true)));
+  auto* nodePool = childPools_.back().get();
+  nodePools_[nodeId] = nodePool;
+  return nodePool;
+}
+
 std::unique_ptr<memory::MemoryReclaimer> Task::createNodeReclaimer(
     bool isHashJoinNode) const {
   if (pool()->reclaimer() == nullptr) {
@@ -347,8 +468,9 @@ std::unique_ptr<memory::MemoryReclaimer> Task::createNodeReclaimer(
   }
   // Sets memory reclaimer for the parent node memory pool on the first child
   // operator construction which has set memory reclaimer.
-  return isHashJoinNode ? HashJoinMemoryReclaimer::create()
-                        : exec::MemoryReclaimer::create();
+  return isHashJoinNode
+      ? HashJoinMemoryReclaimer::create()
+      : exec::ParallelMemoryReclaimer::create(queryCtx_->spillExecutor());
 }
 
 std::unique_ptr<memory::MemoryReclaimer> Task::createExchangeClientReclaimer()
@@ -371,11 +493,16 @@ std::unique_ptr<memory::MemoryReclaimer> Task::createTaskReclaimer() {
 
 velox::memory::MemoryPool* Task::addOperatorPool(
     const core::PlanNodeId& planNodeId,
+    uint32_t splitGroupId,
     int pipelineId,
     uint32_t driverId,
     const std::string& operatorType) {
-  auto* nodePool =
-      getOrAddNodePool(planNodeId, isHashJoinOperator(operatorType));
+  velox::memory::MemoryPool* nodePool;
+  if (isHashJoinOperator(operatorType)) {
+    nodePool = getOrAddJoinNodePool(planNodeId, splitGroupId);
+  } else {
+    nodePool = getOrAddNodePool(planNodeId);
+  }
   childPools_.push_back(nodePool->addLeafChild(fmt::format(
       "op.{}.{}.{}.{}", planNodeId, pipelineId, driverId, operatorType)));
   return childPools_.back().get();
@@ -402,7 +529,7 @@ velox::memory::MemoryPool* Task::addMergeSourcePool(
     const core::PlanNodeId& planNodeId,
     uint32_t pipelineId,
     uint32_t sourceId) {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   auto* nodePool = getOrAddNodePool(planNodeId);
   childPools_.push_back(nodePool->addLeafChild(
       fmt::format(
@@ -423,7 +550,7 @@ velox::memory::MemoryPool* Task::addExchangeClientPool(
   return childPools_.back().get();
 }
 
-bool Task::supportsSingleThreadedExecution() const {
+bool Task::supportSerialExecutionMode() const {
   if (consumerSupplier_) {
     return false;
   }
@@ -433,7 +560,7 @@ bool Task::supportsSingleThreadedExecution() const {
       planFragment_, nullptr, &driverFactories, queryCtx_->queryConfig(), 1);
 
   for (const auto& factory : driverFactories) {
-    if (!factory->supportsSingleThreadedExecution()) {
+    if (!factory->supportsSerialExecution()) {
       return false;
     }
   }
@@ -442,38 +569,43 @@ bool Task::supportsSingleThreadedExecution() const {
 }
 
 RowVectorPtr Task::next(ContinueFuture* future) {
-  // NOTE: Task::next() is single-threaded execution so locking is not required
+  checkExecutionMode(ExecutionMode::kSerial);
+  // NOTE: Task::next() is serial execution so locking is not required
   // to access Task object.
   VELOX_CHECK_EQ(
       core::ExecutionStrategy::kUngrouped,
       planFragment_.executionStrategy,
-      "Single-threaded execution supports only ungrouped execution");
+      "Serial execution mode supports only ungrouped execution");
 
   if (!splitsStates_.empty()) {
     for (const auto& it : splitsStates_) {
       VELOX_CHECK(
           it.second.noMoreSplits,
-          "Single-threaded execution requires all splits to be added before "
+          "Serial execution mode requires all splits to be added before "
           "calling Task::next().");
     }
   }
 
-  VELOX_CHECK_EQ(state_, kRunning, "Task has already finished processing.");
+  VELOX_CHECK_EQ(
+      static_cast<int>(state_),
+      static_cast<int>(kRunning),
+      "Task has already finished processing.");
 
   // On first call, create the drivers.
   if (driverFactories_.empty()) {
     VELOX_CHECK_NULL(
         consumerSupplier_,
-        "Single-threaded execution doesn't support delivering results to a "
+        "Serial execution mode doesn't support delivering results to a "
         "callback");
 
+    taskStats_.executionStartTimeMs = getCurrentTimeMs();
     LocalPlanner::plan(
         planFragment_, nullptr, &driverFactories_, queryCtx_->queryConfig(), 1);
     exchangeClients_.resize(driverFactories_.size());
 
     // In Task::next() we always assume ungrouped execution.
     for (const auto& factory : driverFactories_) {
-      VELOX_CHECK(factory->supportsSingleThreadedExecution());
+      VELOX_CHECK(factory->supportsSerialExecution());
       numDriversUngrouped_ += factory->numDrivers;
       numTotalDrivers_ += factory->numTotalDrivers;
       taskStats_.pipelineStats.emplace_back(
@@ -481,16 +613,14 @@ RowVectorPtr Task::next(ContinueFuture* future) {
     }
 
     // Create drivers.
-    auto self = shared_from_this();
-    std::vector<std::shared_ptr<Driver>> drivers;
-    drivers.reserve(numDriversUngrouped_);
     createSplitGroupStateLocked(kUngroupedGroupId);
-    createDriversLocked(self, kUngroupedGroupId, drivers);
-    if (self->pool_->stats().currentBytes != 0) {
+    std::vector<std::shared_ptr<Driver>> drivers =
+        createDriversLocked(kUngroupedGroupId);
+    if (pool_->reservedBytes() != 0) {
       VELOX_FAIL(
           "Unexpected memory pool allocations during task[{}] driver initialization: {}",
-          self->taskId_,
-          self->pool_->treeMemoryUsage());
+          taskId_,
+          pool_->treeMemoryUsage());
     }
 
     drivers_ = std::move(drivers);
@@ -521,14 +651,14 @@ RowVectorPtr Task::next(ContinueFuture* future) {
 
       ++runnableDrivers;
 
-      std::shared_ptr<BlockingState> blockingState;
-      auto result = drivers_[i]->next(blockingState);
+      ContinueFuture driverFuture = ContinueFuture::makeEmpty();
+      auto result = drivers_[i]->next(&driverFuture);
       if (result) {
         return result;
       }
 
-      if (blockingState) {
-        futures[i] = blockingState->future();
+      if (driverFuture.valid()) {
+        futures[i] = std::move(driverFuture);
       }
 
       if (error()) {
@@ -556,14 +686,12 @@ RowVectorPtr Task::next(ContinueFuture* future) {
   }
 }
 
-// static
-void Task::start(
-    std::shared_ptr<Task> self,
-    uint32_t maxDrivers,
-    uint32_t concurrentSplitGroups) {
+void Task::start(uint32_t maxDrivers, uint32_t concurrentSplitGroups) {
   facebook::velox::process::ThreadDebugInfo threadDebugInfo{
-      self->queryCtx()->queryId(), self->taskId_, nullptr};
+      queryCtx()->queryId(), taskId_, nullptr};
   facebook::velox::process::ScopedThreadDebugInfo scopedInfo(threadDebugInfo);
+  checkExecutionMode(ExecutionMode::kParallel);
+
   try {
     VELOX_CHECK_GE(
         maxDrivers,
@@ -574,242 +702,278 @@ void Task::start(
         1,
         "concurrentSplitGroups parameter must be greater then or equal to 1");
 
-    uint32_t numPipelines;
     {
-      std::unique_lock<std::mutex> l(self->mutex_);
-      VELOX_CHECK(self->drivers_.empty());
-      self->concurrentSplitGroups_ = concurrentSplitGroups;
-      self->taskStats_.executionStartTimeMs = getCurrentTimeMs();
-
-#if CODEGEN_ENABLED == 1
-      const auto& config = self->queryCtx()->queryConfig();
-      if (config.codegenEnabled() &&
-          config.codegenConfigurationFilePath().length() != 0) {
-        auto codegenLogger =
-            std::make_shared<codegen::DefaultLogger>(self->taskId_);
-        auto codegen = codegen::Codegen(codegenLogger);
-        auto lazyLoading = config.codegenLazyLoading();
-        codegen.initializeFromFile(
-            config.codegenConfigurationFilePath(), lazyLoading);
-        if (auto newPlanNode =
-                codegen.compile(*(self->planFragment_.planNode))) {
-          self->planFragment_.planNode = newPlanNode;
-        }
+      std::unique_lock<std::timed_mutex> l(mutex_);
+      taskStats_.executionStartTimeMs = getCurrentTimeMs();
+      if (!isRunningLocked()) {
+        LOG(WARNING) << "Task " << taskId_
+                     << " has already been terminated before start: "
+                     << errorMessageLocked();
+        return;
       }
-#endif
-
-      // Here we create driver factories.
-      LocalPlanner::plan(
-          self->planFragment_,
-          self->consumerSupplier(),
-          &self->driverFactories_,
-          self->queryCtx_->queryConfig(),
-          maxDrivers);
-
-      // Keep one exchange client per pipeline (NULL if not used).
-      numPipelines = self->driverFactories_.size();
-      self->exchangeClients_.resize(numPipelines);
-
-      // For each pipeline we have a corresponding driver factory.
-      // Here we count how many drivers in total we need and create
-      // pipeline stats.
-      for (auto& factory : self->driverFactories_) {
-        if (factory->groupedExecution) {
-          self->numDriversPerSplitGroup_ += factory->numDrivers;
-        } else {
-          self->numDriversUngrouped_ += factory->numDrivers;
-        }
-        self->numTotalDrivers_ += factory->numTotalDrivers;
-        self->taskStats_.pipelineStats.emplace_back(
-            factory->inputDriver, factory->outputDriver);
+      createDriverFactoriesLocked(maxDrivers);
+    }
+    initializePartitionOutput();
+    createAndStartDrivers(concurrentSplitGroups);
+  } catch (const std::exception&) {
+    if (isRunning()) {
+      setError(std::current_exception());
+    } else {
+      maybeRemoveFromOutputBufferManager();
+      {
+        // NOTE: the async task error might be triggered in the middle of task
+        // start processing, and we need to mark all the drivers have been
+        // finished.
+        std::unique_lock<std::timed_mutex> l(mutex_);
+        VELOX_CHECK_EQ(numRunningDrivers_, 0);
+        VELOX_CHECK_EQ(numFinishedDrivers_, 0);
+        numFinishedDrivers_ = numTotalDrivers_;
       }
+    }
+    throw;
+  }
+}
+
+void Task::checkExecutionMode(ExecutionMode mode) {
+  VELOX_CHECK_EQ(mode, mode_, "Inconsistent task execution mode.");
+}
+
+void Task::createDriverFactoriesLocked(uint32_t maxDrivers) {
+  VELOX_CHECK(isRunningLocked());
+  VELOX_CHECK(driverFactories_.empty());
 
-      self->validateGroupedExecutionLeafNodes();
+  // Create driver factories.
+  LocalPlanner::plan(
+      planFragment_,
+      consumerSupplier(),
+      &driverFactories_,
+      queryCtx_->queryConfig(),
+      maxDrivers);
+
+  // Calculates total number of drivers and create pipeline stats.
+  for (auto& factory : driverFactories_) {
+    if (factory->groupedExecution) {
+      numDriversPerSplitGroup_ += factory->numDrivers;
+    } else {
+      numDriversUngrouped_ += factory->numDrivers;
     }
+    numTotalDrivers_ += factory->numTotalDrivers;
+    taskStats_.pipelineStats.emplace_back(
+        factory->inputDriver, factory->outputDriver);
+  }
 
-    // Register self for possible memory recovery callback. Do this
-    // after sizing 'drivers_' but before starting the
-    // Drivers. 'drivers_' can be read by memory recovery or
-    // cancellation while Drivers are being made, so the array should
-    // have final size from the start.
-    auto bufferManager = self->bufferManager_.lock();
-    VELOX_CHECK_NOT_NULL(
-        bufferManager,
-        "Unable to initialize task. "
-        "PartitionedOutputBufferManager was already destructed");
+  validateGroupedExecutionLeafNodes();
+}
 
-    // In this loop we prepare the global state of pipelines: partitioned output
-    // buffer and exchange client(s).
-    for (auto pipeline = 0; pipeline < numPipelines; ++pipeline) {
-      auto& factory = self->driverFactories_[pipeline];
+void Task::createAndStartDrivers(uint32_t concurrentSplitGroups) {
+  checkExecutionMode(Task::ExecutionMode::kParallel);
+  std::unique_lock<std::timed_mutex> l(mutex_);
+  VELOX_CHECK(
+      isRunningLocked(),
+      "Task {} has already been terminated before start: {}",
+      taskId_,
+      errorMessageLocked());
+  VELOX_CHECK(!driverFactories_.empty());
+  VELOX_CHECK_EQ(concurrentSplitGroups_, 1);
+  VELOX_CHECK(drivers_.empty());
 
-      if (auto partitionedOutputNode = factory->needsPartitionedOutput()) {
-        VELOX_CHECK(
-            !self->hasPartitionedOutput(),
-            "Only one output pipeline per task is supported");
-        self->numDriversInPartitionedOutput_ = factory->numDrivers;
-        self->groupedPartitionedOutput_ = factory->groupedExecution;
-        const auto totalOutputDrivers = factory->groupedExecution
-            ? factory->numDrivers * self->planFragment_.numSplitGroups
-            : factory->numDrivers;
-        bufferManager->initializeTask(
-            self,
-            partitionedOutputNode->kind(),
-            partitionedOutputNode->numPartitions(),
-            totalOutputDrivers);
-      }
+  concurrentSplitGroups_ = concurrentSplitGroups;
+  // Pre-allocates slots for maximum possible number of drivers.
+  if (numDriversPerSplitGroup_ > 0) {
+    drivers_.resize(numDriversPerSplitGroup_ * concurrentSplitGroups_);
+  }
 
-      // NOTE: MergeExchangeNode doesn't use the exchange client created here to
-      // fetch data from the merge source but only uses it to send abortResults
-      // to the merge source of the split which is added after the task has
-      // failed. Correspondingly, MergeExchangeNode creates one exchange client
-      // for each merge source to fetch data as we can't mix the data from
-      // different sources for merging.
-      if (auto exchangeNodeId = factory->needsExchangeClient()) {
-        self->createExchangeClient(pipeline, exchangeNodeId.value());
-      }
+  // First, create drivers for ungrouped execution.
+  if (numDriversUngrouped_ > 0) {
+    createSplitGroupStateLocked(kUngroupedGroupId);
+    // Create drivers.
+    std::vector<std::shared_ptr<Driver>> drivers =
+        createDriversLocked(kUngroupedGroupId);
+    if (pool_->reservedBytes() != 0) {
+      VELOX_FAIL(
+          "Unexpected memory pool allocations during task[{}] driver initialization: {}",
+          taskId_,
+          pool_->treeMemoryUsage());
     }
 
-    std::unique_lock<std::mutex> l(self->mutex_);
-
-    // Preallocate a bunch of slots for max concurrent grouped execution
-    // drivers, if needed.
-    if (self->numDriversPerSplitGroup_ > 0) {
-      self->drivers_.resize(
-          self->numDriversPerSplitGroup_ * self->concurrentSplitGroups_);
+    // Prevent the connecting structures from being cleaned up before all
+    // split groups are finished during the grouped execution mode.
+    if (isGroupedExecution()) {
+      splitGroupStates_[kUngroupedGroupId].mixedExecutionMode = true;
     }
 
-    // We create the drivers running pipelines in ungrouped execution mode
-    // first.
-    if (self->numDriversUngrouped_ > 0) {
-      // Create the drivers we are going to run for this task.
-      std::vector<std::shared_ptr<Driver>> drivers;
-      drivers.reserve(self->numDriversUngrouped_);
-      self->createSplitGroupStateLocked(kUngroupedGroupId);
-      self->createDriversLocked(self, kUngroupedGroupId, drivers);
-      if (self->pool_->stats().currentBytes != 0) {
-        VELOX_FAIL(
-            "Unexpected memory pool allocations during task[{}] driver initialization: {}",
-            self->taskId_,
-            self->pool_->treeMemoryUsage());
+    // Slots in the front are used by grouped execution drivers. Ungrouped
+    // execution drivers come after these.
+    if (drivers_.empty()) {
+      drivers_ = std::move(drivers);
+    } else {
+      drivers_.reserve(drivers_.size() + numDriversUngrouped_);
+      for (auto& driver : drivers) {
+        drivers_.emplace_back(std::move(driver));
       }
+    }
 
-      // Prevent the connecting structures from being cleaned up before all
-      // split groups are finished during the grouped execution mode.
-      if (self->isGroupedExecution()) {
-        self->splitGroupStates_[kUngroupedGroupId].mixedExecutionMode = true;
+    // Set and start all Drivers together inside 'mutex_' so that
+    // cancellations and pauses have the well-defined timing. For example, do
+    // not pause and restart a task while it is still adding Drivers.
+    //
+    // We might have first slots taken for grouped execution drivers, so need
+    // only to enqueue the ungrouped execution drivers.
+    for (auto it = drivers_.end() - numDriversUngrouped_; it != drivers_.end();
+         ++it) {
+      if (*it) {
+        ++numRunningDrivers_;
+        Driver::enqueue(*it);
       }
+    }
+  }
 
-      // We might have first slots taken for grouped execution drivers, so need
-      // to append the ungrouped execution drivers afterwards in that case.
-      if (self->drivers_.empty()) {
-        self->drivers_ = std::move(drivers);
-      } else {
-        self->drivers_.reserve(
-            self->drivers_.size() + self->numDriversUngrouped_);
-        for (auto& driver : drivers) {
-          self->drivers_.emplace_back(std::move(driver));
-        }
-      }
+  // As some splits for grouped execution could have been added before the
+  // task start, ensure we start running drivers for them.
+  if (numDriversPerSplitGroup_ > 0) {
+    ensureSplitGroupsAreBeingProcessedLocked();
+  }
+}
 
-      // Set and start all Drivers together inside 'mutex_' so that
-      // cancellations and pauses have well defined timing. For example, do not
-      // pause and restart a task while it is still adding Drivers. If the given
-      // executor is folly::InlineLikeExecutor (or it's child), since the
-      // drivers will be executed synchronously on the same thread as the
-      // current task, so we need release the lock to avoid the deadlock.
-      if (dynamic_cast<const folly::InlineLikeExecutor*>(
-              self->queryCtx()->executor())) {
-        l.unlock();
-      }
-      // We might have first slots taken for grouped execution drivers, so need
-      // only to enqueue the ungrouped execution drivers.
-      for (auto it = self->drivers_.end() - self->numDriversUngrouped_;
-           it != self->drivers_.end();
-           ++it) {
-        if (*it) {
-          ++self->numRunningDrivers_;
-          Driver::enqueue(*it);
+void Task::initializePartitionOutput() {
+  VELOX_CHECK(
+      isRunningLocked(),
+      "Task {} has already been terminated before start: {}",
+      taskId_,
+      errorMessageLocked());
+
+  auto bufferManager = bufferManager_.lock();
+  VELOX_CHECK_NOT_NULL(
+      bufferManager,
+      "Unable to initialize task. "
+      "PartitionedOutputBufferManager was already destructed");
+  std::shared_ptr<const core::PartitionedOutputNode> partitionedOutputNode{
+      nullptr};
+  int numOutputDrivers{0};
+  {
+    std::unique_lock<std::timed_mutex> l(mutex_);
+    const auto numPipelines = driverFactories_.size();
+    exchangeClients_.resize(numPipelines);
+
+    // In this loop we prepare the global state of pipelines: partitioned
+    // output buffer and exchange client(s).
+    for (auto pipeline = 0; pipeline < numPipelines; ++pipeline) {
+      auto& factory = driverFactories_[pipeline];
+
+      if (hasPartitionedOutput()) {
+        VELOX_CHECK_NULL(
+            factory->needsPartitionedOutput(),
+            "Only one output pipeline per task is supported");
+      } else {
+        partitionedOutputNode = factory->needsPartitionedOutput();
+        if (partitionedOutputNode != nullptr) {
+          numDriversInPartitionedOutput_ = factory->numDrivers;
+          groupedPartitionedOutput_ = factory->groupedExecution;
+          numOutputDrivers = factory->groupedExecution
+              ? factory->numDrivers * planFragment_.numSplitGroups
+              : factory->numDrivers;
         }
       }
-    }
-
-    // As some splits for grouped execution could have been added before the
-    // task start, ensure we start running drivers for them.
-    if (self->numDriversPerSplitGroup_ > 0) {
-      if (!l.owns_lock()) {
-        l.lock();
+      // NOTE: MergeExchangeNode doesn't use the exchange client created here
+      // to fetch data from the merge source but only uses it to send
+      // abortResults to the merge source of the split which is added after
+      // the task has failed. Correspondingly, MergeExchangeNode creates one
+      // exchange client for each merge source to fetch data as we can't mix
+      // the data from different sources for merging.
+      if (auto exchangeNodeId = factory->needsExchangeClient()) {
+        createExchangeClientLocked(pipeline, exchangeNodeId.value());
       }
-      self->ensureSplitGroupsAreBeingProcessedLocked(self);
     }
+  }
 
-  } catch (const std::exception& e) {
-    self->setError(std::current_exception());
-    throw;
+  if (partitionedOutputNode != nullptr) {
+    VELOX_CHECK(hasPartitionedOutput());
+    VELOX_CHECK_GT(numOutputDrivers, 0);
+    bufferManager->initializeTask(
+        shared_from_this(),
+        partitionedOutputNode->kind(),
+        partitionedOutputNode->numPartitions(),
+        numOutputDrivers);
   }
 }
 
 // static
 void Task::resume(std::shared_ptr<Task> self) {
   std::vector<std::shared_ptr<Driver>> offThreadDrivers;
-  {
-    std::lock_guard<std::mutex> l(self->mutex_);
-    // Setting pause requested must be atomic with the resuming so that
-    // suspended sections do not go back on thread during resume.
-    self->pauseRequested_ = false;
-    if (!self->exception_) {
-      for (auto& driver : self->drivers_) {
-        if (driver) {
-          if (driver->state().isSuspended) {
-            // The Driver will come on thread in its own time as long as
-            // the cancel flag is reset. This check needs to be inside 'mutex_'.
-            continue;
-          }
-          if (driver->state().isEnqueued) {
-            // A Driver can wait for a thread and there can be a
-            // pause/resume during the wait. The Driver should not be
-            // enqueued twice.
-            continue;
-          }
-          VELOX_CHECK(!driver->isOnThread() && !driver->isTerminated());
-          if (!driver->state().hasBlockingFuture) {
-            // Do not continue a Driver that is blocked on external
-            // event. The Driver gets enqueued by the promise realization.
-            Driver::enqueue(driver);
-          }
-        }
-      }
-    } else {
-      // NOTE: no need to resume task execution if the task has been terminated.
-      // But we need to close the drivers which are off threads as task
-      // terminate code path skips closing the off thread drivers if the task
-      // has been requested pause and leave the task resume path to handle. If
-      // a task has been paused, then there might be concurrent memory
-      // arbitration thread to reclaim the memory resource from the off thread
-      // driver operators.
-      for (auto& driver : self->drivers_) {
-        if (driver == nullptr) {
+  std::vector<ContinuePromise> resumePromises;
+  SCOPE_EXIT {
+    // Get the stats and free the resources of Drivers that were not on
+    // thread.
+    for (auto& driver : offThreadDrivers) {
+      self->driversClosedByTask_.emplace_back(driver);
+      driver->closeByTask();
+    }
+    // Fulfill resume futures.
+    for (auto& promise : resumePromises) {
+      promise.setValue();
+    }
+  };
+
+  std::lock_guard<std::timed_mutex> l(self->mutex_);
+  // Setting pause requested must be atomic with the resuming so that
+  // suspended sections do not go back on thread during resume.
+  self->pauseRequested_ = false;
+  if (self->isRunningLocked()) {
+    for (auto& driver : self->drivers_) {
+      if (driver != nullptr) {
+        if (driver->state().suspended()) {
+          // The Driver will come on thread in its own time as long as
+          // the cancel flag is reset. This check needs to be inside 'mutex_'.
           continue;
         }
-        if (driver->isOnThread()) {
-          VELOX_CHECK(driver->isTerminated());
+        if (driver->state().isEnqueued) {
+          // A Driver can wait for a thread and there can be a
+          // pause/resume during the wait. The Driver should not be
+          // enqueued twice.
           continue;
         }
-        if (driver->isTerminated()) {
-          continue;
+        VELOX_CHECK(!driver->isOnThread() && !driver->isTerminated());
+        if (!driver->state().hasBlockingFuture &&
+            driver->task()->queryCtx()->isExecutorSupplied()) {
+          if (driver->state().endExecTimeMs != 0) {
+            driver->state().totalPauseTimeMs +=
+                getCurrentTimeMs() - driver->state().endExecTimeMs;
+          }
+          // Do not continue a Driver that is blocked on external
+          // event. The Driver gets enqueued by the promise realization.
+          //
+          // Do not continue the driver if no executor is supplied,
+          // This usually happens in serial execution mode.
+          Driver::enqueue(driver);
         }
-        driver->state().isTerminated = true;
-        driver->state().setThread();
-        self->driverClosedLocked();
-        offThreadDrivers.push_back(std::move(driver));
       }
     }
+  } else {
+    // NOTE: no need to resume task execution if the task has been terminated.
+    // But we need to close the drivers which are off threads as task
+    // terminate code path skips closing the off thread drivers if the task
+    // has been requested pause and leave the task resume path to handle. If
+    // a task has been paused, then there might be concurrent memory
+    // arbitration thread to reclaim the memory resource from the off thread
+    // driver operators.
+    for (auto& driver : self->drivers_) {
+      if (driver == nullptr) {
+        continue;
+      }
+      if (driver->isOnThread()) {
+        VELOX_CHECK(driver->isTerminated());
+        continue;
+      }
+      if (driver->isTerminated()) {
+        continue;
+      }
+      driver->state().isTerminated = true;
+      driver->state().setThread();
+      self->driverClosedLocked();
+      offThreadDrivers.push_back(std::move(driver));
+    }
   }
-
-  // Get the stats and free the resources of Drivers that were not on thread.
-  for (auto& driver : offThreadDrivers) {
-    driver->closeByTask();
-  }
+  resumePromises.swap(self->resumePromises_);
 }
 
 void Task::validateGroupedExecutionLeafNodes() {
@@ -872,15 +1036,15 @@ void Task::createSplitGroupStateLocked(uint32_t splitGroupId) {
   }
 }
 
-void Task::createDriversLocked(
-    std::shared_ptr<Task>& self,
-    uint32_t splitGroupId,
-    std::vector<std::shared_ptr<Driver>>& out) {
+std::vector<std::shared_ptr<Driver>> Task::createDriversLocked(
+    uint32_t splitGroupId) {
   TestValue::adjust("facebook::velox::exec::Task::createDriversLocked", this);
   const bool groupedExecutionDrivers = (splitGroupId != kUngroupedGroupId);
-  auto& splitGroupState = self->splitGroupStates_[splitGroupId];
+  auto& splitGroupState = splitGroupStates_[splitGroupId];
   const auto numPipelines = driverFactories_.size();
 
+  std::vector<std::shared_ptr<Driver>> drivers;
+  auto self = shared_from_this();
   for (auto pipeline = 0; pipeline < numPipelines; ++pipeline) {
     auto& factory = driverFactories_[pipeline];
     // We either create drivers for grouped execution or ungrouped.
@@ -894,7 +1058,7 @@ void Task::createDriversLocked(
         factory->numDrivers * (groupedExecutionDrivers ? splitGroupId : 0);
     for (uint32_t partitionId = 0; partitionId < factory->numDrivers;
          ++partitionId) {
-      out.emplace_back(factory->createDriver(
+      drivers.emplace_back(factory->createDriver(
           std::make_unique<DriverCtx>(
               self,
               driverIdOffset + partitionId,
@@ -926,7 +1090,7 @@ void Task::createDriversLocked(
     for (auto pipeline = 0; pipeline < numPipelines; ++pipeline) {
       auto& factory = driverFactories_[pipeline];
       if (factory->groupedExecution == groupedExecutionDrivers) {
-        out[firstPipelineDriverIndex]->initializeOperatorStats(
+        drivers[firstPipelineDriverIndex]->initializeOperatorStats(
             taskStats_.pipelineStats[pipeline].operatorStats);
         firstPipelineDriverIndex += factory->numDrivers;
       }
@@ -937,11 +1101,11 @@ void Task::createDriversLocked(
   for (auto& bridgeEntry : splitGroupState.bridges) {
     bridgeEntry.second->start();
   }
-
-  // Start all the spill groups before we start the driver execution.
-  for (auto& coordinatorEntry : splitGroupState.spillOperatorGroups) {
-    coordinatorEntry.second->start();
+  for (auto& bridgeEntry : splitGroupState.custom_bridges) {
+    bridgeEntry.second->start();
   }
+
+  return drivers;
 }
 
 // static
@@ -950,7 +1114,7 @@ void Task::removeDriver(std::shared_ptr<Task> self, Driver* driver) {
   bool allFinished = true;
   EventCompletionNotifier stateChangeNotifier;
   {
-    std::lock_guard<std::mutex> taskLock(self->mutex_);
+    std::lock_guard<std::timed_mutex> taskLock(self->mutex_);
     for (auto& driverPtr : self->drivers_) {
       if (driverPtr.get() != driver) {
         continue;
@@ -981,7 +1145,7 @@ void Task::removeDriver(std::shared_ptr<Task> self, Driver* driver) {
           self->taskStats_.completedSplitGroups.emplace(splitGroupId);
           stateChangeNotifier.activate(std::move(self->stateChangePromises_));
           splitGroupState.clear();
-          self->ensureSplitGroupsAreBeingProcessedLocked(self);
+          self->ensureSplitGroupsAreBeingProcessedLocked();
         } else {
           splitGroupState.clear();
         }
@@ -993,8 +1157,8 @@ void Task::removeDriver(std::shared_ptr<Task> self, Driver* driver) {
     if (self->numFinishedDrivers_ == self->numTotalDrivers_) {
       LOG(INFO) << "All drivers (" << self->numFinishedDrivers_
                 << ") finished for task " << self->taskId()
-                << " after running for " << self->timeSinceStartMsLocked()
-                << " ms.";
+                << " after running for "
+                << succinctMillis(self->timeSinceStartMsLocked());
     }
   }
   stateChangeNotifier.notify();
@@ -1008,8 +1172,7 @@ void Task::removeDriver(std::shared_ptr<Task> self, Driver* driver) {
   }
 }
 
-void Task::ensureSplitGroupsAreBeingProcessedLocked(
-    std::shared_ptr<Task>& self) {
+void Task::ensureSplitGroupsAreBeingProcessedLocked() {
   // Only try creating more drivers if we are running.
   if (not isRunningLocked() or (numDriversPerSplitGroup_ == 0)) {
     return;
@@ -1020,10 +1183,9 @@ void Task::ensureSplitGroupsAreBeingProcessedLocked(
     const uint32_t splitGroupId = queuedSplitGroups_.front();
     queuedSplitGroups_.pop();
 
-    std::vector<std::shared_ptr<Driver>> drivers;
-    drivers.reserve(numDriversPerSplitGroup_);
     createSplitGroupStateLocked(splitGroupId);
-    createDriversLocked(self, splitGroupId, drivers);
+    std::vector<std::shared_ptr<Driver>> drivers =
+        createDriversLocked(splitGroupId);
     // Move created drivers into the vacant spots in 'drivers_' and enqueue
     // them. We have vacant spots, because we initially allocate enough items in
     // the vector and keep null pointers for completed drivers.
@@ -1046,7 +1208,7 @@ void Task::ensureSplitGroupsAreBeingProcessedLocked(
 void Task::setMaxSplitSequenceId(
     const core::PlanNodeId& planNodeId,
     long maxSequenceId) {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   if (isRunningLocked()) {
     auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
     // We could have been sent an old split again, so only change max id, when
@@ -1064,7 +1226,7 @@ bool Task::addSplitWithSequence(
   bool added = false;
   bool isTaskRunning;
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     isTaskRunning = isRunningLocked();
     if (isTaskRunning) {
       // The same split can be added again in some systems. The systems that
@@ -1083,6 +1245,8 @@ bool Task::addSplitWithSequence(
   }
 
   if (!isTaskRunning) {
+    // Safe because 'split' is moved away above only if 'isTaskRunning'.
+    // @lint-ignore CLANGTIDY bugprone-use-after-move
     addRemoteSplit(planNodeId, split);
   }
 
@@ -1093,7 +1257,7 @@ void Task::addSplit(const core::PlanNodeId& planNodeId, exec::Split&& split) {
   bool isTaskRunning;
   std::unique_ptr<ContinuePromise> promise;
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     isTaskRunning = isRunningLocked();
     if (isTaskRunning) {
       promise = addSplitLocked(
@@ -1107,6 +1271,7 @@ void Task::addSplit(const core::PlanNodeId& planNodeId, exec::Split&& split) {
 
   if (!isTaskRunning) {
     // Safe because 'split' is moved away above only if 'isTaskRunning'.
+    // @lint-ignore CLANGTIDY bugprone-use-after-move
     addRemoteSplit(planNodeId, split);
   }
 }
@@ -1133,6 +1298,11 @@ std::unique_ptr<ContinuePromise> Task::addSplitLocked(
 
   if (split.connectorSplit) {
     VELOX_CHECK_NULL(split.connectorSplit->dataSource);
+    if (splitsState.sourceIsTableScan) {
+      ++taskStats_.numQueuedTableScanSplits;
+      taskStats_.queuedTableScanSplitWeights +=
+          split.connectorSplit->splitWeight;
+    }
   }
 
   if (!split.hasGroup()) {
@@ -1146,9 +1316,8 @@ std::unique_ptr<ContinuePromise> Task::addSplitLocked(
   if (seenSplitGroups_.find(splitGroupId) == seenSplitGroups_.end()) {
     seenSplitGroups_.emplace(splitGroupId);
     queuedSplitGroups_.push(splitGroupId);
-    auto self = shared_from_this();
     // We might have some free driver slots to process this split group.
-    ensureSplitGroupsAreBeingProcessedLocked(self);
+    ensureSplitGroupsAreBeingProcessedLocked();
   }
   return addSplitToStoreLocked(
       splitsState.groupSplitsStores[splitGroupId], std::move(split));
@@ -1173,7 +1342,7 @@ void Task::noMoreSplitsForGroup(
   std::vector<ContinuePromise> promises;
   EventCompletionNotifier stateChangeNotifier;
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
 
     auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
     auto& splitsStore = splitsState.groupSplitsStores[splitGroupId];
@@ -1198,24 +1367,41 @@ void Task::noMoreSplits(const core::PlanNodeId& planNodeId) {
   bool allFinished;
   std::shared_ptr<ExchangeClient> exchangeClient;
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
 
-    // Global 'no more splits' for a plan node comes in case of ungrouped
-    // execution when no more splits will arrive. For grouped execution it
-    // comes when no more split groups will arrive for that plan node.
+    // Global 'no more splits' message for a plan node comes in two cases:
+    // 1. For an ungrouped execution plan node when no more splits will
+    // arrive for that plan node.
+    // 2. For a grouped execution plan node when no more split groups will
+    // arrive for that plan node.
     auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
     splitsState.noMoreSplits = true;
-    if (not splitsState.groupSplitsStores.empty()) {
+    if (!planFragment_.leafNodeRunsGroupedExecution(planNodeId)) {
+      // Ungrouped execution branch.
+      if (!splitsState.groupSplitsStores.empty()) {
+        // Mark the only split store as 'no more splits'.
+        VELOX_CHECK_EQ(
+            splitsState.groupSplitsStores.size(),
+            1,
+            "Expect 1 split store in a plan node in ungrouped execution mode, has {}",
+            splitsState.groupSplitsStores.size());
+        auto it = splitsState.groupSplitsStores.begin();
+        it->second.noMoreSplits = true;
+        splitPromises.swap(it->second.splitPromises);
+      } else {
+        // For an ungrouped execution plan node, in the unlikely case when there
+        // are no split stores created (this means there were no splits at all),
+        // we create one.
+        splitsState.groupSplitsStores.emplace(
+            kUngroupedGroupId, SplitsStore{{}, true, {}});
+      }
+    } else {
+      // Grouped execution branch.
       // Mark all split stores as 'no more splits'.
       for (auto& it : splitsState.groupSplitsStores) {
         it.second.noMoreSplits = true;
-        splitPromises = std::move(it.second.splitPromises);
+        movePromisesOut(it.second.splitPromises, splitPromises);
       }
-    } else if (!planFragment_.leafNodeRunsGroupedExecution(planNodeId)) {
-      // During ungrouped execution, in the unlikely case there are no split
-      // stores (this means there were no splits at all), we create one.
-      splitsState.groupSplitsStores.emplace(
-          kUngroupedGroupId, SplitsStore{{}, true, {}});
     }
 
     allFinished = checkNoMoreSplitGroupsLocked();
@@ -1247,7 +1433,12 @@ bool Task::checkNoMoreSplitGroupsLocked() {
   // we should review the total number of drivers, which initially is set to
   // process all split groups, but in reality workers share split groups and
   // each worker processes only a part of them, meaning much less than all.
-  if (allNodesReceivedNoMoreSplitsMessageLocked()) {
+  //
+  // NOTE: we shall only do task finish check after the task has been started
+  // which initializes 'numDriversPerSplitGroup_', otherwise the task will
+  // finish early.
+  if ((numDriversPerSplitGroup_ != 0) &&
+      allNodesReceivedNoMoreSplitsMessageLocked()) {
     numTotalDrivers_ = seenSplitGroups_.size() * numDriversPerSplitGroup_ +
         numDriversUngrouped_;
     if (groupedPartitionedOutput_) {
@@ -1273,10 +1464,12 @@ BlockingReason Task::getSplitOrFuture(
     exec::Split& split,
     ContinueFuture& future,
     int32_t maxPreloadSplits,
-    std::function<void(std::shared_ptr<connector::ConnectorSplit>)> preload) {
-  std::lock_guard<std::mutex> l(mutex_);
+    const ConnectorSplitPreloadFunc& preload) {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
   return getSplitOrFutureLocked(
-      getPlanNodeSplitsStateLocked(planNodeId).groupSplitsStores[splitGroupId],
+      splitsState.sourceIsTableScan,
+      splitsState.groupSplitsStores[splitGroupId],
       split,
       future,
       maxPreloadSplits,
@@ -1284,11 +1477,12 @@ BlockingReason Task::getSplitOrFuture(
 }
 
 BlockingReason Task::getSplitOrFutureLocked(
+    bool forTableScan,
     SplitsStore& splitsStore,
     exec::Split& split,
     ContinueFuture& future,
     int32_t maxPreloadSplits,
-    std::function<void(std::shared_ptr<connector::ConnectorSplit>)> preload) {
+    const ConnectorSplitPreloadFunc& preload) {
   if (splitsStore.splits.empty()) {
     if (splitsStore.noMoreSplits) {
       return BlockingReason::kNotBlocked;
@@ -1300,36 +1494,47 @@ BlockingReason Task::getSplitOrFutureLocked(
     return BlockingReason::kWaitForSplit;
   }
 
-  split = getSplitLocked(splitsStore, maxPreloadSplits, preload);
+  split = getSplitLocked(forTableScan, splitsStore, maxPreloadSplits, preload);
   return BlockingReason::kNotBlocked;
 }
 
 exec::Split Task::getSplitLocked(
+    bool forTableScan,
     SplitsStore& splitsStore,
     int32_t maxPreloadSplits,
-    std::function<void(std::shared_ptr<connector::ConnectorSplit>)> preload) {
+    const ConnectorSplitPreloadFunc& preload) {
   int32_t readySplitIndex = -1;
-  if (maxPreloadSplits) {
+  if (maxPreloadSplits > 0) {
     for (auto i = 0; i < splitsStore.splits.size() && i < maxPreloadSplits;
          ++i) {
-      auto& split = splitsStore.splits[i].connectorSplit;
-      if (!split->dataSource) {
-        // Initializes split->dataSource
-        preload(split);
-      } else if (readySplitIndex == -1 && split->dataSource->hasValue()) {
+      auto& connectorSplit = splitsStore.splits[i].connectorSplit;
+      if (!connectorSplit->dataSource) {
+        // Initializes split->dataSource.
+        preload(connectorSplit);
+        preloadingSplits_.emplace(connectorSplit);
+      } else if (
+          (readySplitIndex == -1) && (connectorSplit->dataSource->hasValue())) {
         readySplitIndex = i;
+        preloadingSplits_.erase(connectorSplit);
       }
     }
   }
   if (readySplitIndex == -1) {
     readySplitIndex = 0;
   }
-  assert(!splitsStore.splits.empty());
+  VELOX_CHECK(!splitsStore.splits.empty());
   auto split = std::move(splitsStore.splits[readySplitIndex]);
   splitsStore.splits.erase(splitsStore.splits.begin() + readySplitIndex);
 
   --taskStats_.numQueuedSplits;
   ++taskStats_.numRunningSplits;
+  if (forTableScan && split.connectorSplit) {
+    --taskStats_.numQueuedTableScanSplits;
+    ++taskStats_.numRunningTableScanSplits;
+    taskStats_.queuedTableScanSplitWeights -= split.connectorSplit->splitWeight;
+    taskStats_.runningTableScanSplitWeights +=
+        split.connectorSplit->splitWeight;
+  }
   taskStats_.lastSplitStartTimeMs = getCurrentTimeMs();
   if (taskStats_.firstSplitStartTimeMs == 0) {
     taskStats_.firstSplitStartTimeMs = taskStats_.lastSplitStartTimeMs;
@@ -1338,19 +1543,30 @@ exec::Split Task::getSplitLocked(
   return split;
 }
 
-void Task::splitFinished() {
-  std::lock_guard<std::mutex> l(mutex_);
+void Task::splitFinished(bool fromTableScan, int64_t splitWeight) {
+  std::lock_guard<std::timed_mutex> l(mutex_);
   ++taskStats_.numFinishedSplits;
   --taskStats_.numRunningSplits;
+  if (fromTableScan) {
+    --taskStats_.numRunningTableScanSplits;
+    taskStats_.runningTableScanSplitWeights -= splitWeight;
+  }
   if (isAllSplitsFinishedLocked()) {
     taskStats_.executionEndTimeMs = getCurrentTimeMs();
   }
 }
 
-void Task::multipleSplitsFinished(int32_t numSplits) {
-  std::lock_guard<std::mutex> l(mutex_);
+void Task::multipleSplitsFinished(
+    bool fromTableScan,
+    int32_t numSplits,
+    int64_t splitsWeight) {
+  std::lock_guard<std::timed_mutex> l(mutex_);
   taskStats_.numFinishedSplits += numSplits;
   taskStats_.numRunningSplits -= numSplits;
+  if (fromTableScan) {
+    taskStats_.numRunningTableScanSplits -= numSplits;
+    taskStats_.runningTableScanSplitWeights -= splitsWeight;
+  }
   if (isAllSplitsFinishedLocked()) {
     taskStats_.executionEndTimeMs = getCurrentTimeMs();
   }
@@ -1364,14 +1580,21 @@ bool Task::isUngroupedExecution() const {
   return not isGroupedExecution();
 }
 
+bool Task::hasMixedExecutionGroup() const {
+  if (!isGroupedExecution()) {
+    return false;
+  }
+  return numDriversUngrouped_ > 0;
+}
+
 bool Task::isRunning() const {
-  std::lock_guard<std::mutex> l(mutex_);
-  return (state_ == TaskState::kRunning);
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  return isRunningLocked();
 }
 
 bool Task::isFinished() const {
-  std::lock_guard<std::mutex> l(mutex_);
-  return (state_ == TaskState::kFinished);
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  return isFinishedLocked();
 }
 
 bool Task::isRunningLocked() const {
@@ -1387,9 +1610,9 @@ bool Task::updateOutputBuffers(int numBuffers, bool noMoreBuffers) {
   VELOX_CHECK_NOT_NULL(
       bufferManager,
       "Unable to initialize task. "
-      "PartitionedOutputBufferManager was already destructed");
+      "OutputBufferManager was already destructed");
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     if (noMoreOutputBuffers_) {
       // Ignore messages received after no-more-buffers message.
       return false;
@@ -1414,7 +1637,7 @@ int Task::getOutputPipelineId() const {
 void Task::setAllOutputConsumed() {
   bool allFinished;
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     partitionedOutputConsumed_ = true;
     allFinished = checkIfFinishedLocked();
   }
@@ -1439,7 +1662,7 @@ bool Task::checkIfFinishedLocked() {
   // TODO Add support for terminating processing early in grouped execution.
   bool allFinished = numFinishedDrivers_ == numTotalDrivers_;
   if (!allFinished && isUngroupedExecution()) {
-    auto outputPipelineId = getOutputPipelineId();
+    const auto outputPipelineId = getOutputPipelineId();
     if (splitGroupStates_[kUngroupedGroupId].numFinishedOutputDrivers ==
         numDrivers(outputPipelineId)) {
       allFinished = true;
@@ -1469,7 +1692,8 @@ std::vector<Operator*> Task::findPeerOperators(
   std::vector<Operator*> peers;
   const auto operatorId = caller->operatorId();
   const auto& operatorType = caller->operatorType();
-  std::lock_guard<std::mutex> l(mutex_);
+  const auto splitGroupId = caller->splitGroupId();
+  std::lock_guard<std::timed_mutex> l(mutex_);
   for (auto& driver : drivers_) {
     if (driver == nullptr) {
       continue;
@@ -1477,6 +1701,9 @@ std::vector<Operator*> Task::findPeerOperators(
     if (driver->driverCtx()->pipelineId != pipelineId) {
       continue;
     }
+    if (driver->driverCtx()->splitGroupId != splitGroupId) {
+      continue;
+    }
     Operator* peer = driver->findOperator(operatorId);
     VELOX_CHECK_EQ(peer->operatorType(), operatorType);
     peers.push_back(peer);
@@ -1490,7 +1717,7 @@ bool Task::allPeersFinished(
     ContinueFuture* future,
     std::vector<ContinuePromise>& promises,
     std::vector<std::shared_ptr<Driver>>& peers) {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   if (exception_) {
     VELOX_FAIL(
         "Task is terminating because of error: {}",
@@ -1532,12 +1759,12 @@ void Task::addHashJoinBridgesLocked(
     const std::vector<core::PlanNodeId>& planNodeIds) {
   auto& splitGroupState = splitGroupStates_[splitGroupId];
   for (const auto& planNodeId : planNodeIds) {
-    splitGroupState.bridges.emplace(
-        planNodeId, std::make_shared<HashJoinBridge>());
-    splitGroupState.spillOperatorGroups.emplace(
-        planNodeId,
-        std::make_unique<SpillOperatorGroup>(
-            taskId_, splitGroupId, planNodeId));
+    auto const inserted =
+        splitGroupState.bridges
+            .emplace(planNodeId, std::make_shared<HashJoinBridge>())
+            .second;
+    VELOX_CHECK(
+        inserted, "Join bridge for node {} is already present", planNodeId);
   }
 }
 
@@ -1547,7 +1774,13 @@ void Task::addCustomJoinBridgesLocked(
   auto& splitGroupState = splitGroupStates_[splitGroupId];
   for (const auto& planNode : planNodes) {
     if (auto joinBridge = Operator::joinBridgeFromPlanNode(planNode)) {
-      splitGroupState.bridges.emplace(planNode->id(), std::move(joinBridge));
+      auto const inserted = splitGroupState.custom_bridges
+                                .emplace(planNode->id(), std::move(joinBridge))
+                                .second;
+      VELOX_CHECK(
+          inserted,
+          "Join bridge for node {} is already present",
+          planNode->id());
       return;
     }
   }
@@ -1556,7 +1789,7 @@ void Task::addCustomJoinBridgesLocked(
 std::shared_ptr<JoinBridge> Task::getCustomJoinBridge(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
-  return getJoinBridgeInternal<JoinBridge>(splitGroupId, planNodeId);
+  return getCustomJoinBridgeInternal(splitGroupId, planNodeId);
 }
 
 void Task::addNestedLoopJoinBridgesLocked(
@@ -1564,8 +1797,12 @@ void Task::addNestedLoopJoinBridgesLocked(
     const std::vector<core::PlanNodeId>& planNodeIds) {
   auto& splitGroupState = splitGroupStates_[splitGroupId];
   for (const auto& planNodeId : planNodeIds) {
-    splitGroupState.bridges.emplace(
-        planNodeId, std::make_shared<NestedLoopJoinBridge>());
+    auto const inserted =
+        splitGroupState.bridges
+            .emplace(planNodeId, std::make_shared<NestedLoopJoinBridge>())
+            .second;
+    VELOX_CHECK(
+        inserted, "Join bridge for node {} is already present", planNodeId);
   }
 }
 
@@ -1578,7 +1815,8 @@ std::shared_ptr<HashJoinBridge> Task::getHashJoinBridge(
 std::shared_ptr<HashJoinBridge> Task::getHashJoinBridgeLocked(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
-  return getJoinBridgeInternalLocked<HashJoinBridge>(splitGroupId, planNodeId);
+  return getJoinBridgeInternalLocked<HashJoinBridge>(
+      splitGroupId, planNodeId, &SplitGroupState::bridges);
 }
 
 std::shared_ptr<NestedLoopJoinBridge> Task::getNestedLoopJoinBridge(
@@ -1591,27 +1829,29 @@ template <class TBridgeType>
 std::shared_ptr<TBridgeType> Task::getJoinBridgeInternal(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
-  std::lock_guard<std::mutex> l(mutex_);
-  return getJoinBridgeInternalLocked<TBridgeType>(splitGroupId, planNodeId);
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  return getJoinBridgeInternalLocked<TBridgeType>(
+      splitGroupId, planNodeId, &SplitGroupState::bridges);
 }
 
-template <class TBridgeType>
+template <class TBridgeType, typename MemberType>
 std::shared_ptr<TBridgeType> Task::getJoinBridgeInternalLocked(
     uint32_t splitGroupId,
-    const core::PlanNodeId& planNodeId) {
+    const core::PlanNodeId& planNodeId,
+    MemberType SplitGroupState::*bridges_member) {
   const auto& splitGroupState = splitGroupStates_[splitGroupId];
 
-  auto it = splitGroupState.bridges.find(planNodeId);
-  if (it == splitGroupState.bridges.end()) {
+  auto it = (splitGroupState.*bridges_member).find(planNodeId);
+  if (it == (splitGroupState.*bridges_member).end()) {
     // We might be looking for a bridge between grouped and ungrouped execution.
     // It will belong to the 'ungrouped' state.
     if (isGroupedExecution() && splitGroupId != kUngroupedGroupId) {
       return getJoinBridgeInternalLocked<TBridgeType>(
-          kUngroupedGroupId, planNodeId);
+          kUngroupedGroupId, planNodeId, bridges_member);
     }
   }
   VELOX_CHECK(
-      it != splitGroupState.bridges.end(),
+      it != (splitGroupState.*bridges_member).end(),
       "Join bridge for plan node ID {} not found for group {}, task {}",
       planNodeId,
       splitGroupId,
@@ -1625,6 +1865,14 @@ std::shared_ptr<TBridgeType> Task::getJoinBridgeInternalLocked(
   return bridge;
 }
 
+std::shared_ptr<JoinBridge> Task::getCustomJoinBridgeInternal(
+    uint32_t splitGroupId,
+    const core::PlanNodeId& planNodeId) {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  return getJoinBridgeInternalLocked<JoinBridge>(
+      splitGroupId, planNodeId, &SplitGroupState::custom_bridges);
+}
+
 //  static
 std::string Task::shortId(const std::string& id) {
   if (id.size() < 12) {
@@ -1639,43 +1887,42 @@ std::string Task::shortId(const std::string& id) {
   return fmt::format("tk:{}", hash & 0xffff);
 }
 
-/// Moves split promises from one vector to another.
-static void movePromisesOut(
-    std::vector<ContinuePromise>& from,
-    std::vector<ContinuePromise>& to) {
-  for (auto& promise : from) {
-    to.push_back(std::move(promise));
-  }
-  from.clear();
-}
-
 ContinueFuture Task::terminate(TaskState terminalState) {
   std::vector<std::shared_ptr<Driver>> offThreadDrivers;
   EventCompletionNotifier taskCompletionNotifier;
   EventCompletionNotifier stateChangeNotifier;
   std::vector<std::shared_ptr<ExchangeClient>> exchangeClients;
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     if (taskStats_.executionEndTimeMs == 0) {
       taskStats_.executionEndTimeMs = getCurrentTimeMs();
     }
-    if (not isRunningLocked()) {
+    if (!isRunningLocked()) {
       return makeFinishFutureLocked("Task::terminate");
     }
     state_ = terminalState;
+    VELOX_CHECK_EQ(
+        taskStats_.terminationTimeMs,
+        0,
+        "Termination time has already been set, this should only happen once.");
+    taskStats_.terminationTimeMs = getCurrentTimeMs();
     if (state_ == TaskState::kCanceled || state_ == TaskState::kAborted) {
       try {
         VELOX_FAIL(
             state_ == TaskState::kCanceled ? "Cancelled"
                                            : "Aborted for external error");
-      } catch (const std::exception& e) {
+      } catch (const std::exception&) {
         exception_ = std::current_exception();
       }
     }
+    if (state_ != TaskState::kFinished) {
+      VELOX_CHECK(!cancellationSource_.isCancellationRequested());
+      cancellationSource_.requestCancellation();
+    }
 
     LOG(INFO) << "Terminating task " << taskId() << " with state "
               << taskStateString(state_) << " after running for "
-              << timeSinceStartMsLocked() << " ms.";
+              << succinctMillis(timeSinceStartMsLocked());
 
     taskCompletionNotifier.activate(
         std::move(taskCompletionPromises_), [&]() { onTaskCompletion(); });
@@ -1709,6 +1956,7 @@ ContinueFuture Task::terminate(TaskState terminalState) {
   // Get the stats and free the resources of Drivers that were not on
   // thread.
   for (auto& driver : offThreadDrivers) {
+    driversClosedByTask_.emplace_back(driver);
     driver->closeByTask();
   }
 
@@ -1716,11 +1964,7 @@ ContinueFuture Task::terminate(TaskState terminalState) {
   // Task. The Drivers are now detached from Task and therefore will
   // not go on thread. The reference in the future callback is
   // typically the last one.
-  if (hasPartitionedOutput()) {
-    if (auto bufferManager = bufferManager_.lock()) {
-      bufferManager->removeTask(taskId_);
-    }
-  }
+  maybeRemoveFromOutputBufferManager();
 
   for (auto& exchangeClient : exchangeClients) {
     if (exchangeClient != nullptr) {
@@ -1739,12 +1983,15 @@ ContinueFuture Task::terminate(TaskState terminalState) {
       unordered_map<core::PlanNodeId, std::pair<std::vector<exec::Split>, bool>>
           remainingRemoteSplits;
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     // Collect all the join bridges to clear them.
     for (auto& splitGroupState : splitGroupStates_) {
       for (auto& pair : splitGroupState.second.bridges) {
         oldBridges.emplace_back(std::move(pair.second));
       }
+      for (auto& pair : splitGroupState.second.custom_bridges) {
+        oldBridges.emplace_back(std::move(pair.second));
+      }
       splitGroupStates.push_back(std::move(splitGroupState.second));
     }
 
@@ -1760,7 +2007,8 @@ ContinueFuture Task::terminate(TaskState terminalState) {
         std::vector<exec::Split> splits;
         for (auto& [groupId, store] : splitState.groupSplitsStores) {
           while (!store.splits.empty()) {
-            splits.emplace_back(getSplitLocked(store, 0, nullptr));
+            splits.emplace_back(getSplitLocked(
+                splitState.sourceIsTableScan, store, 0, nullptr));
           }
         }
         if (!splits.empty()) {
@@ -1802,9 +2050,29 @@ ContinueFuture Task::terminate(TaskState terminalState) {
     bridge->cancel();
   }
 
+  for (auto split : preloadingSplits_) {
+    split->dataSource->close();
+  }
+  preloadingSplits_.clear();
+
   return makeFinishFuture("Task::terminate");
 }
 
+void Task::maybeRemoveFromOutputBufferManager() {
+  if (hasPartitionedOutput()) {
+    if (auto bufferManager = bufferManager_.lock()) {
+      // Capture output buffer stats before deleting the buffer.
+      {
+        std::lock_guard<std::timed_mutex> l(mutex_);
+        if (!taskStats_.outputBufferStats.has_value()) {
+          taskStats_.outputBufferStats = bufferManager->stats(taskId_);
+        }
+      }
+      bufferManager->removeTask(taskId_);
+    }
+  }
+}
+
 ContinueFuture Task::makeFinishFutureLocked(const char* comment) {
   auto [promise, future] = makeVeloxContinuePromiseContract(comment);
 
@@ -1817,7 +2085,7 @@ ContinueFuture Task::makeFinishFutureLocked(const char* comment) {
 }
 
 void Task::addOperatorStats(OperatorStats& stats) {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   VELOX_CHECK(
       stats.pipelineId >= 0 &&
       stats.pipelineId < taskStats_.pipelineStats.size());
@@ -1832,8 +2100,14 @@ void Task::addOperatorStats(OperatorStats& stats) {
       .add(stats);
 }
 
+void Task::addDriverStats(int pipelineId, DriverStats stats) {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  VELOX_CHECK(0 <= pipelineId && pipelineId < taskStats_.pipelineStats.size());
+  taskStats_.pipelineStats[pipelineId].driverStats.push_back(std::move(stats));
+}
+
 TaskStats Task::taskStats() const {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
 
   // 'taskStats_' contains task stats plus stats for the completed drivers
   // (their operators).
@@ -1861,31 +2135,114 @@ TaskStats Task::taskStats() const {
       ++taskStats.numRunningDrivers;
     } else if (driver->isTerminated()) {
       ++taskStats.numTerminatedDrivers;
+    } else if (driver->state().isEnqueued) {
+      ++taskStats.numQueuedDrivers;
     } else {
-      ++taskStats.numBlockedDrivers[driver->blockingReason()];
+      const auto blockingReason = driver->blockingReason();
+      if (blockingReason != BlockingReason::kNotBlocked) {
+        ++taskStats.numBlockedDrivers[blockingReason];
+      }
+    }
+    // Find the longest running operator.
+    auto ocs = driver->opCallStatus();
+    if (!ocs.empty()) {
+      const auto callDuration = ocs.callDuration();
+      if (callDuration > taskStats.longestRunningOpCallMs) {
+        taskStats.longestRunningOpCall =
+            ocs.formatCall(driver->findOperatorNoThrow(ocs.opId), ocs.method);
+        taskStats.longestRunningOpCallMs = callDuration;
+      }
     }
   }
 
+  // Don't bother with operator calls running under 30 seconds.
+  if (taskStats.longestRunningOpCallMs < 30000) {
+    taskStats.longestRunningOpCall.clear();
+    taskStats.longestRunningOpCallMs = 0;
+  }
+
   auto bufferManager = bufferManager_.lock();
   taskStats.outputBufferUtilization = bufferManager->getUtilization(taskId_);
   taskStats.outputBufferOverutilized = bufferManager->isOverutilized(taskId_);
-
+  if (!taskStats.outputBufferStats.has_value()) {
+    taskStats.outputBufferStats = bufferManager->stats(taskId_);
+  }
   return taskStats;
 }
 
+bool Task::getLongRunningOpCalls(
+    std::chrono::nanoseconds lockTimeout,
+    size_t thresholdDurationMs,
+    std::vector<OpCallInfo>& out) const {
+  std::unique_lock<std::timed_mutex> l(mutex_, lockTimeout);
+  if (!l.owns_lock()) {
+    return false;
+  }
+  for (const auto& driver : drivers_) {
+    if (driver) {
+      const auto opCallStatus = driver->opCallStatus();
+      if (!opCallStatus.empty()) {
+        auto callDurationMs = opCallStatus.callDuration();
+        if (callDurationMs > thresholdDurationMs) {
+          auto* op = driver->findOperatorNoThrow(opCallStatus.opId);
+          out.push_back({
+              .durationMs = callDurationMs,
+              .tid = driver->state().tid,
+              .opId = opCallStatus.opId,
+              .taskId = taskId_,
+              .opCall = OpCallStatusRaw::formatCall(op, opCallStatus.method),
+          });
+        }
+      }
+    }
+  }
+  return true;
+}
+
 uint64_t Task::timeSinceStartMs() const {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   return timeSinceStartMsLocked();
 }
 
 uint64_t Task::timeSinceEndMs() const {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   if (taskStats_.executionEndTimeMs == 0UL) {
     return 0UL;
   }
   return getCurrentTimeMs() - taskStats_.executionEndTimeMs;
 }
 
+uint64_t Task::timeSinceTerminationMs() const {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  if (taskStats_.terminationTimeMs == 0UL) {
+    return 0UL;
+  }
+  return getCurrentTimeMs() - taskStats_.terminationTimeMs;
+}
+
+Task::DriverCounts Task::driverCounts() const {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+
+  Task::DriverCounts ret;
+  for (auto& driver : drivers_) {
+    if (driver) {
+      if (driver->state().isEnqueued) {
+        ++ret.numQueuedDrivers;
+      } else if (driver->state().suspended()) {
+        ++ret.numSuspendedDrivers;
+      } else if (driver->isOnThread()) {
+        ++ret.numOnThreadDrivers;
+      } else {
+        const auto blockingReason = driver->blockingReason();
+        if (blockingReason != BlockingReason::kNotBlocked) {
+          ++ret.numBlockedDrivers[blockingReason];
+        }
+      }
+    }
+  }
+  return ret;
+}
+
 void Task::onTaskCompletion() {
   listeners().withRLock([&](auto& listeners) {
     if (listeners.empty()) {
@@ -1896,7 +2253,7 @@ void Task::onTaskCompletion() {
     TaskState state;
     std::exception_ptr exception;
     {
-      std::lock_guard<std::mutex> l(mutex_);
+      std::lock_guard<std::timed_mutex> l(mutex_);
       stats = taskStats_;
       state = state_;
       exception = exception_;
@@ -1909,7 +2266,7 @@ void Task::onTaskCompletion() {
 }
 
 ContinueFuture Task::stateChangeFuture(uint64_t maxWaitMicros) {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   // If 'this' is running, the future is realized on timeout or when
   // this no longer is running.
   if (not isRunningLocked()) {
@@ -1924,8 +2281,8 @@ ContinueFuture Task::stateChangeFuture(uint64_t maxWaitMicros) {
   return std::move(future);
 }
 
-ContinueFuture Task::taskCompletionFuture(uint64_t maxWaitMicros) {
-  std::lock_guard<std::mutex> l(mutex_);
+ContinueFuture Task::taskCompletionFuture() {
+  std::lock_guard<std::timed_mutex> l(mutex_);
   // If 'this' is running, the future is realized on timeout or when
   // this no longer is running.
   if (not isRunningLocked()) {
@@ -1935,86 +2292,116 @@ ContinueFuture Task::taskCompletionFuture(uint64_t maxWaitMicros) {
   auto [promise, future] = makeVeloxContinuePromiseContract(
       fmt::format("Task::taskCompletionFuture {}", taskId_));
   taskCompletionPromises_.emplace_back(std::move(promise));
-  if (maxWaitMicros > 0) {
-    return std::move(future).within(std::chrono::microseconds(maxWaitMicros));
-  }
+  return std::move(future);
+}
+
+ContinueFuture Task::taskDeletionFuture() {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  auto [promise, future] = makeVeloxContinuePromiseContract(
+      fmt::format("Task::taskDeletionFuture {}", taskId_));
+  taskDeletionPromises_.emplace_back(std::move(promise));
   return std::move(future);
 }
 
 std::string Task::toString() const {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   std::stringstream out;
-  out << "{Task " << shortId(taskId_) << " (" << taskId_ << ")";
+  out << "{Task " << shortId(taskId_) << " (" << taskId_ << ")" << std::endl;
 
   if (exception_) {
     out << "Error: " << errorMessageLocked() << std::endl;
   }
 
   if (planFragment_.planNode) {
-    out << "Plan: " << planFragment_.planNode->toString() << std::endl;
+    out << "Plan:\n"
+        << planFragment_.planNode->toString(true, true) << std::endl;
   }
 
-  out << " drivers:\n";
-  for (auto& driver : drivers_) {
+  size_t numRemainingDrivers{0};
+  for (const auto& driver : drivers_) {
     if (driver) {
-      out << driver->toString() << std::endl;
+      ++numRemainingDrivers;
+    }
+  }
+
+  if (numRemainingDrivers > 0) {
+    bool addedCaption{false};
+    for (auto& driver : drivers_) {
+      if (driver) {
+        if (!addedCaption) {
+          out << "drivers:\n";
+          addedCaption = true;
+        }
+        out << driver->toString() << std::endl;
+      }
+    }
+  }
+
+  if (!driversClosedByTask_.empty()) {
+    bool addedCaption{false};
+    for (auto& driver : driversClosedByTask_) {
+      auto zombieDriver = driver.lock();
+      if (zombieDriver) {
+        if (!addedCaption) {
+          out << "zombie drivers:\n";
+          addedCaption = true;
+        }
+        out << zombieDriver->toString()
+            << ", refcount: " << zombieDriver.use_count() - 1 << std::endl;
+      }
     }
   }
 
+  out << "}";
   return out.str();
 }
 
-std::string Task::toShortJsonString() const {
-  std::lock_guard<std::mutex> l(mutex_);
+folly::dynamic Task::toShortJsonLocked() const {
   folly::dynamic obj = folly::dynamic::object;
   obj["shortId"] = shortId(taskId_);
   obj["id"] = taskId_;
   obj["state"] = taskStateString(state_);
   obj["numRunningDrivers"] = numRunningDrivers_;
-  obj["numTotalDrivers_"] = numTotalDrivers_;
+  obj["numTotalDrivers"] = numTotalDrivers_;
   obj["numFinishedDrivers"] = numFinishedDrivers_;
   obj["numThreads"] = numThreads_;
-  obj["terminateRequested_"] = std::to_string(terminateRequested_);
-  obj["pauseRequested_"] = std::to_string(pauseRequested_);
-  return folly::toPrettyJson(obj);
+  obj["terminateRequested"] = terminateRequested_.load();
+  obj["pauseRequested"] = pauseRequested_.load();
+  return obj;
 }
 
-std::string Task::toJsonString() const {
-  std::lock_guard<std::mutex> l(mutex_);
-  folly::dynamic obj = folly::dynamic::object;
-  obj["shortId"] = shortId(taskId_);
-  obj["id"] = taskId_;
-  obj["state"] = taskStateString(state_);
-  obj["numRunningDrivers"] = numRunningDrivers_;
-  obj["numTotalDrivers_"] = numTotalDrivers_;
-  obj["numFinishedDrivers"] = numFinishedDrivers_;
+folly::dynamic Task::toShortJson() const {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  return toShortJsonLocked();
+}
+
+folly::dynamic Task::toJson() const {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  auto obj = toShortJsonLocked();
   obj["numDriversPerSplitGroup"] = numDriversPerSplitGroup_;
   obj["numDriversUngrouped"] = numDriversUngrouped_;
   obj["groupedPartitionedOutput"] = groupedPartitionedOutput_;
   obj["concurrentSplitGroups"] = concurrentSplitGroups_;
   obj["numRunningSplitGroups"] = numRunningSplitGroups_;
-  obj["numDriversUngrouped"] = numDriversUngrouped_;
   obj["partitionedOutputConsumed"] = partitionedOutputConsumed_;
   obj["noMoreOutputBuffers"] = noMoreOutputBuffers_;
-  obj["numThreads"] = numThreads_;
   obj["onThreadSince"] = std::to_string(onThreadSince_);
-  obj["terminateRequested_"] = std::to_string(terminateRequested_);
 
   if (exception_) {
     obj["exception"] = errorMessageLocked();
   }
 
   if (planFragment_.planNode) {
-    obj["plan"] = planFragment_.planNode->toString();
+    obj["plan"] = planFragment_.planNode->toString(true, true);
   }
 
-  folly::dynamic driverObj = folly::dynamic::object;
-  int index = 0;
-  for (auto& driver : drivers_) {
-    driverObj[std::to_string(index++)] =
-        driver ? driver->toJsonString() : "null";
+  folly::dynamic drivers = folly::dynamic::object;
+  for (auto i = 0; i < drivers_.size(); ++i) {
+    if (drivers_[i] != nullptr) {
+      drivers[i] = drivers_[i]->toJson();
+    }
   }
-  obj["drivers"] = driverObj;
+  obj["drivers"] = drivers;
 
   if (auto buffers = bufferManager_.lock()) {
     if (auto buffer = buffers->getBufferIfExists(taskId_)) {
@@ -2024,11 +2411,11 @@ std::string Task::toJsonString() const {
 
   folly::dynamic exchangeClients = folly::dynamic::object;
   for (const auto& [id, client] : exchangeClientByPlanNode_) {
-    exchangeClients[id] = client->toJsonString();
+    exchangeClients[id] = client->toJson();
   }
   obj["exchangeClientByPlanNode"] = exchangeClients;
 
-  return folly::toPrettyJson(obj);
+  return obj;
 }
 
 std::shared_ptr<MergeSource> Task::addLocalMergeSource(
@@ -2143,7 +2530,7 @@ Task::getLocalExchangeQueues(
 void Task::setError(const std::exception_ptr& exception) {
   TestValue::adjust("facebook::velox::exec::Task::setError", this);
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     if (not isRunningLocked()) {
       return;
     }
@@ -2163,7 +2550,7 @@ void Task::setError(const std::string& message) {
   // std::current_exception().
   try {
     throw std::runtime_error(message);
-  } catch (const std::runtime_error& e) {
+  } catch (const std::runtime_error&) {
     setError(std::current_exception());
   }
 }
@@ -2173,12 +2560,13 @@ std::string Task::errorMessageLocked() const {
 }
 
 std::string Task::errorMessage() const {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   return errorMessageLocked();
 }
 
 StopReason Task::enter(ThreadState& state, uint64_t nowMicros) {
-  std::lock_guard<std::mutex> l(mutex_);
+  TestValue::adjust("facebook::velox::exec::Task::enter", &state);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   VELOX_CHECK(state.isEnqueued);
   state.isEnqueued = false;
   if (state.isTerminated) {
@@ -2187,7 +2575,7 @@ StopReason Task::enter(ThreadState& state, uint64_t nowMicros) {
   if (state.isOnThread()) {
     return StopReason::kAlreadyOnThread;
   }
-  auto reason = shouldStopLocked();
+  const auto reason = shouldStopLocked();
   if (reason == StopReason::kTerminate) {
     state.isTerminated = true;
   }
@@ -2228,7 +2616,7 @@ void Task::leave(
   });
   StopReason reason;
   {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     if (!state.isTerminated) {
       reason = shouldStopLocked();
       if (reason == StopReason::kTerminate) {
@@ -2252,7 +2640,7 @@ void Task::leave(
   // the driver and remove it from the task.
   driverCb(reason);
 
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   if (--numThreads_ == 0) {
     threadFinishPromises = allThreadsFinishedLocked();
   }
@@ -2269,7 +2657,8 @@ StopReason Task::enterSuspended(ThreadState& state) {
       promise.setValue();
     }
   });
-  std::lock_guard<std::mutex> l(mutex_);
+
+  std::lock_guard<std::timed_mutex> l(mutex_);
   if (state.isTerminated) {
     return StopReason::kAlreadyTerminated;
   }
@@ -2285,10 +2674,15 @@ StopReason Task::enterSuspended(ThreadState& state) {
           reason == StopReason::kYield,
       "Unexpected stop reason on suspension: {}",
       reason);
-  state.isSuspended = true;
+  if (++state.numSuspensions > 1) {
+    // Only the first suspension request needs to update the running driver
+    // thread counter in the task.
+    return StopReason::kNone;
+  }
   if (--numThreads_ == 0) {
     threadFinishPromises = allThreadsFinishedLocked();
   }
+  VELOX_CHECK_GE(numThreads_, 0);
   return StopReason::kNone;
 }
 
@@ -2296,24 +2690,35 @@ StopReason Task::leaveSuspended(ThreadState& state) {
   VELOX_CHECK(!state.hasBlockingFuture);
   VELOX_CHECK(state.isOnThread());
 
+  TestValue::adjust("facebook::velox::exec::Task::leaveSuspended", this);
   for (;;) {
     {
-      std::lock_guard<std::mutex> l(mutex_);
-      ++numThreads_;
-      state.isSuspended = false;
-      if (state.isTerminated) {
-        return StopReason::kAlreadyTerminated;
-      }
-      if (terminateRequested_) {
-        state.isTerminated = true;
-        return StopReason::kTerminate;
-      }
-      if (!pauseRequested_) {
-        // For yield or anything but pause we return here.
+      std::lock_guard<std::timed_mutex> l(mutex_);
+      VELOX_CHECK_GT(state.numSuspensions, 0);
+      auto leaveGuard = folly::makeGuard([&]() {
+        VELOX_CHECK_GE(numThreads_, 0);
+        if (--state.numSuspensions == 0) {
+          // Only the last suspension leave needs to update the running driver
+          // thread counter in the task
+          ++numThreads_;
+        }
+      });
+      if (state.numSuspensions > 1 || !pauseRequested_) {
+        if (state.isTerminated) {
+          return StopReason::kAlreadyTerminated;
+        }
+        if (terminateRequested_) {
+          state.isTerminated = true;
+          return StopReason::kTerminate;
+        }
+        // If we have more than one suspension requests on this driver thread or
+        // the task has been resumed, then we return here.
         return StopReason::kNone;
       }
-      --numThreads_;
-      state.isSuspended = true;
+
+      VELOX_CHECK_GT(state.numSuspensions, 0);
+      VELOX_CHECK_GE(numThreads_, 0);
+      leaveGuard.dismiss();
     }
     // If the pause flag is on when trying to reenter, sleep a while outside of
     // the mutex and recheck. This is rare and not time critical. Can happen if
@@ -2324,14 +2729,14 @@ StopReason Task::leaveSuspended(ThreadState& state) {
 }
 
 StopReason Task::shouldStop() {
-  if (terminateRequested_) {
-    return StopReason::kTerminate;
-  }
   if (pauseRequested_) {
     return StopReason::kPause;
   }
+  if (terminateRequested_) {
+    return StopReason::kTerminate;
+  }
   if (toYield_) {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     return shouldStopLocked();
   }
   return StopReason::kNone;
@@ -2339,7 +2744,7 @@ StopReason Task::shouldStop() {
 
 int32_t Task::yieldIfDue(uint64_t startTimeMicros) {
   if (onThreadSince_ < startTimeMicros) {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     // Reread inside the mutex
     if (onThreadSince_ < startTimeMicros && numThreads_ && !toYield_ &&
         !terminateRequested_ && !pauseRequested_) {
@@ -2357,12 +2762,12 @@ std::vector<ContinuePromise> Task::allThreadsFinishedLocked() {
 }
 
 StopReason Task::shouldStopLocked() {
-  if (terminateRequested_) {
-    return StopReason::kTerminate;
-  }
   if (pauseRequested_) {
     return StopReason::kPause;
   }
+  if (terminateRequested_) {
+    return StopReason::kTerminate;
+  }
   if (toYield_ > 0) {
     --toYield_;
     return StopReason::kYield;
@@ -2371,16 +2776,33 @@ StopReason Task::shouldStopLocked() {
 }
 
 ContinueFuture Task::requestPause() {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   TestValue::adjust("facebook::velox::exec::Task::requestPauseLocked", this);
   pauseRequested_ = true;
   return makeFinishFutureLocked("Task::requestPause");
 }
 
-void Task::createExchangeClient(
+bool Task::pauseRequested(ContinueFuture* future) {
+  if (FOLLY_LIKELY(future == nullptr)) {
+    // It is ok to return 'pauseRequested_' without a mutex lock if user doesn't
+    // want to wait for task to resume.
+    return pauseRequested_;
+  }
+
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  if (!pauseRequested_) {
+    VELOX_CHECK(resumePromises_.empty());
+    VELOX_CHECK(!future->valid());
+    return false;
+  }
+  resumePromises_.emplace_back("Task::isPaused");
+  *future = resumePromises_.back().getSemiFuture();
+  return true;
+}
+
+void Task::createExchangeClientLocked(
     int32_t pipelineId,
     const core::PlanNodeId& planNodeId) {
-  std::unique_lock<std::mutex> l(mutex_);
   VELOX_CHECK_NULL(
       getExchangeClientLocked(pipelineId),
       "Exchange client has been created at pipeline: {} for planNode: {}",
@@ -2395,8 +2817,9 @@ void Task::createExchangeClient(
   exchangeClients_[pipelineId] = std::make_shared<ExchangeClient>(
       taskId_,
       destination_,
+      queryCtx()->queryConfig().maxExchangeBufferSize(),
       addExchangeClientPool(planNodeId, pipelineId),
-      queryCtx()->queryConfig().maxExchangeBufferSize());
+      queryCtx()->executor());
   exchangeClientByPlanNode_.emplace(planNodeId, exchangeClients_[pipelineId]);
 }
 
@@ -2415,23 +2838,45 @@ std::shared_ptr<ExchangeClient> Task::getExchangeClientLocked(
   return exchangeClients_[pipelineId];
 }
 
-std::shared_ptr<SpillOperatorGroup> Task::getSpillOperatorGroupLocked(
-    uint32_t splitGroupId,
-    const core::PlanNodeId& planNodeId) {
-  auto& groups = splitGroupStates_[splitGroupId].spillOperatorGroups;
-  auto it = groups.find(planNodeId);
-  VELOX_CHECK(it != groups.end(), "Split group is not set {}", splitGroupId);
-  auto group = it->second;
-  VELOX_CHECK_NOT_NULL(
-      group,
-      "Spill group for plan node ID {} is not set in split group {}",
-      planNodeId,
-      splitGroupId);
-  return group;
+std::optional<trace::QueryTraceConfig> Task::maybeMakeTraceConfig() const {
+  const auto& queryConfig = queryCtx_->queryConfig();
+  if (!queryConfig.queryTraceEnabled()) {
+    return std::nullopt;
+  }
+
+  VELOX_USER_CHECK(
+      !queryConfig.queryTraceDir().empty(),
+      "Query trace enabled but the trace dir is not set");
+
+  const auto queryTraceNodes = queryConfig.queryTraceNodeIds();
+  if (queryTraceNodes.empty()) {
+    return trace::QueryTraceConfig(queryConfig.queryTraceDir());
+  }
+
+  std::vector<std::string> nodes;
+  folly::split(',', queryTraceNodes, nodes);
+  std::unordered_set<std::string> nodeSet(nodes.begin(), nodes.end());
+  VELOX_CHECK_EQ(nodeSet.size(), nodes.size());
+  LOG(INFO) << "Query trace plan node ids: " << queryTraceNodes;
+  return trace::QueryTraceConfig(
+      std::move(nodeSet), queryConfig.queryTraceDir());
+}
+
+void Task::maybeInitQueryTrace() {
+  if (!traceConfig_) {
+    return;
+  }
+
+  const auto traceTaskDir =
+      fmt::format("{}/{}", traceConfig_->queryTraceDir, taskId_);
+  trace::createTraceDirectory(traceTaskDir);
+  const auto queryMetadatWriter = std::make_unique<trace::QueryMetadataWriter>(
+      traceTaskDir, memory::traceMemoryPool());
+  queryMetadatWriter->write(queryCtx_, planFragment_.planNode);
 }
 
 void Task::testingVisitDrivers(const std::function<void(Driver*)>& callback) {
-  std::lock_guard<std::mutex> l(mutex_);
+  std::lock_guard<std::timed_mutex> l(mutex_);
   for (int i = 0; i < drivers_.size(); ++i) {
     if (drivers_[i] != nullptr) {
       callback(drivers_[i].get());
@@ -2448,14 +2893,31 @@ std::unique_ptr<memory::MemoryReclaimer> Task::MemoryReclaimer::create(
 uint64_t Task::MemoryReclaimer::reclaim(
     memory::MemoryPool* pool,
     uint64_t targetBytes,
+    uint64_t maxWaitMs,
     memory::MemoryReclaimer::Stats& stats) {
   auto task = ensureTask();
   if (FOLLY_UNLIKELY(task == nullptr)) {
     return 0;
   }
   VELOX_CHECK_EQ(task->pool()->name(), pool->name());
-  task->requestPause().wait();
-  auto guard = folly::makeGuard([&]() {
+
+  uint64_t reclaimWaitTimeUs{0};
+  uint64_t reclaimedBytes{0};
+  {
+    MicrosecondTimer timer{&reclaimWaitTimeUs};
+    reclaimedBytes = reclaimTask(task, targetBytes, maxWaitMs, stats);
+  }
+  ++task->taskStats_.memoryReclaimCount;
+  task->taskStats_.memoryReclaimMs += reclaimWaitTimeUs / 1'000;
+  return reclaimedBytes;
+}
+
+uint64_t Task::MemoryReclaimer::reclaimTask(
+    const std::shared_ptr<Task>& task,
+    uint64_t targetBytes,
+    uint64_t maxWaitMs,
+    memory::MemoryReclaimer::Stats& stats) {
+  auto resumeGuard = folly::makeGuard([&]() {
     try {
       Task::resume(task);
     } catch (const VeloxRuntimeError& exception) {
@@ -2463,11 +2925,55 @@ uint64_t Task::MemoryReclaimer::reclaim(
                    << " after memory reclamation: " << exception.message();
     }
   });
+
+  uint64_t reclaimWaitTimeUs{0};
+  bool paused{true};
+  {
+    MicrosecondTimer timer{&reclaimWaitTimeUs};
+    if (maxWaitMs == 0) {
+      task->requestPause().wait();
+    } else {
+      paused = task->requestPause().wait(std::chrono::milliseconds(maxWaitMs));
+    }
+  }
+  VELOX_CHECK(paused || maxWaitMs != 0);
+  if (!paused) {
+    RECORD_METRIC_VALUE(kMetricTaskMemoryReclaimWaitTimeoutCount, 1);
+    VELOX_FAIL(
+        "Memory reclaim failed to wait for task {} to pause after {} with max timeout {}",
+        task->taskId(),
+        succinctMicros(reclaimWaitTimeUs),
+        succinctMillis(maxWaitMs));
+  }
+
+  stats.reclaimWaitTimeUs += reclaimWaitTimeUs;
+  RECORD_METRIC_VALUE(kMetricTaskMemoryReclaimCount);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricTaskMemoryReclaimWaitTimeMs, reclaimWaitTimeUs / 1'000);
+
   // Don't reclaim from a cancelled task as it will terminate soon.
   if (task->isCancelled()) {
     return 0;
   }
-  return memory::MemoryReclaimer::reclaim(pool, targetBytes, stats);
+
+  uint64_t reclaimedBytes{0};
+  try {
+    uint64_t reclaimExecTimeUs{0};
+    {
+      MicrosecondTimer timer{&reclaimExecTimeUs};
+      reclaimedBytes = memory::MemoryReclaimer::reclaim(
+          task->pool(), targetBytes, maxWaitMs, stats);
+    }
+    RECORD_HISTOGRAM_METRIC_VALUE(
+        kMetricTaskMemoryReclaimExecTimeMs, reclaimExecTimeUs / 1'000);
+  } catch (...) {
+    // Set task error before resumes the task execution as the task operator
+    // might not be in consistent state anymore. This prevents any off thread
+    // from running again.
+    task->setError(std::current_exception());
+    std::rethrow_exception(std::current_exception());
+  }
+  return reclaimedBytes;
 }
 
 void Task::MemoryReclaimer::abort(
@@ -2478,10 +2984,21 @@ void Task::MemoryReclaimer::abort(
     return;
   }
   VELOX_CHECK_EQ(task->pool()->name(), pool->name());
+
   task->setError(error);
-  // Set timeout to zero to infinite wait until task completes.
-  task->taskCompletionFuture(0).wait();
-  memory::MemoryReclaimer::abort(pool, error);
+  // TODO: respect the memory arbitration request timeout later.
+  const static uint32_t maxTaskAbortWaitUs = 6'000'000; // 60s
+  if (task->taskCompletionFuture().wait(
+          std::chrono::microseconds(maxTaskAbortWaitUs))) {
+    // If task is completed within 60s wait, we can safely propagate abortion.
+    // Otherwise long running operators might be in the middle of processing,
+    // making it unsafe to force abort. In this case we let running operators
+    // finish by hitting operator boundary, and rely on cleanup mechanism to
+    // release the resource.
+    memory::MemoryReclaimer::abort(pool, error);
+  } else {
+    LOG(WARNING)
+        << "Timeout waiting for task to complete during query memory aborting.";
+  }
 }
-
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Task.h b/velox/exec/Task.h
index cfdfec8ad9d74..b237f42202319 100644
--- a/velox/exec/Task.h
+++ b/velox/exec/Task.h
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #pragma once
+
 #include "velox/core/PlanFragment.h"
 #include "velox/core/QueryCtx.h"
 #include "velox/exec/Driver.h"
@@ -23,16 +24,33 @@
 #include "velox/exec/Split.h"
 #include "velox/exec/TaskStats.h"
 #include "velox/exec/TaskStructs.h"
+#include "velox/exec/trace/QueryMetadataWriter.h"
+#include "velox/exec/trace/QueryTraceConfig.h"
 #include "velox/vector/ComplexVector.h"
 
 namespace facebook::velox::exec {
 
-class PartitionedOutputBufferManager;
+class OutputBufferManager;
 
 class HashJoinBridge;
 class NestedLoopJoinBridge;
+
+using ConnectorSplitPreloadFunc =
+    std::function<void(const std::shared_ptr<connector::ConnectorSplit>&)>;
+
 class Task : public std::enable_shared_from_this<Task> {
  public:
+  /// Threading mode the task is executed.
+  enum class ExecutionMode {
+    /// Mode that executes the query serially (single-threaded) on the calling
+    /// thread. Task is executed via the Task::next() API.
+    kSerial,
+    /// Mode that executes the query in parallel (multi-threaded) using provided
+    /// executor. Task is executed via the Task::start() API that starts up
+    /// multiple driver threads and manages their lifecycle.
+    kParallel,
+  };
+
   /// Creates a task to execute a plan fragment, but doesn't start execution
   /// until Task::start() method is called.
   /// @param taskId Unique task identifier.
@@ -44,8 +62,10 @@ class Task : public std::enable_shared_from_this<Task> {
   /// @param queryCtx Query context containing MemoryPool and MemoryAllocator
   /// instances to use for memory allocations during execution, executor to
   /// schedule operators on, and session properties.
+  /// @param mode Execution mode for this task. The task can be executed in
+  /// Serial and Parallel mode.
   /// @param consumer Optional factory function to get callbacks to pass the
-  /// results of the execution. In a multi-threaded execution, results from each
+  /// results of the execution. In a parallel execution mode, results from each
   /// thread are passed on to a separate consumer.
   /// @param onError Optional callback to receive an exception if task
   /// execution fails.
@@ -54,6 +74,7 @@ class Task : public std::enable_shared_from_this<Task> {
       core::PlanFragment planFragment,
       int destination,
       std::shared_ptr<core::QueryCtx> queryCtx,
+      ExecutionMode mode,
       Consumer consumer = nullptr,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
@@ -62,22 +83,31 @@ class Task : public std::enable_shared_from_this<Task> {
       core::PlanFragment planFragment,
       int destination,
       std::shared_ptr<core::QueryCtx> queryCtx,
+      ExecutionMode mode,
       ConsumerSupplier consumerSupplier,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
+  /// Convenience function for shortening a Presto taskId. To be used
+  /// in debugging messages and listings.
+  static std::string shortId(const std::string& id);
+
   ~Task();
 
   /// Specify directory to which data will be spilled if spilling is enabled and
-  /// required.
-  void setSpillDirectory(const std::string& spillDirectory) {
+  /// required. Set 'alreadyCreated' to true if the directory has already been
+  /// created by the caller.
+  void setSpillDirectory(
+      const std::string& spillDirectory,
+      bool alreadyCreated = true) {
     spillDirectory_ = spillDirectory;
+    spillDirectoryCreated_ = alreadyCreated;
   }
 
   std::string toString() const;
 
-  std::string toJsonString() const;
+  folly::dynamic toJson() const;
 
-  std::string toShortJsonString() const;
+  folly::dynamic toShortJson() const;
 
   /// Returns universally unique identifier of the task.
   const std::string& uuid() const {
@@ -93,9 +123,9 @@ class Task : public std::enable_shared_from_this<Task> {
     return destination_;
   }
 
-  // Convenience function for shortening a Presto taskId. To be used
-  // in debugging messages and listings.
-  static std::string shortId(const std::string& id);
+  /// Configured cpu slice time limit for drivers. 0 (meaning slicing/yield
+  /// disabled) when task is under serial mode.
+  uint64_t driverCpuTimeSliceLimitMs() const;
 
   /// Returns QueryCtx specified in the constructor.
   const std::shared_ptr<core::QueryCtx>& queryCtx() const {
@@ -117,6 +147,13 @@ class Task : public std::enable_shared_from_this<Task> {
 
   bool isUngroupedExecution() const;
 
+  /// Returns true if this task has ungrouped execution split under grouped
+  /// execution mode.
+  ///
+  /// NOTE: calls this function after task has been started as the number of
+  /// ungrouped drivers is set during task startup.
+  bool hasMixedExecutionGroup() const;
+
   /// Starts executing the plan fragment specified in the constructor. If leaf
   /// nodes require splits (e.g. TableScan, Exchange, etc.), these splits can be
   /// added before or after calling start().
@@ -127,14 +164,11 @@ class Task : public std::enable_shared_from_this<Task> {
   /// nodes require splits and there are not enough of these.
   /// @param concurrentSplitGroups In grouped execution, maximum number of
   /// splits groups processed concurrently.
-  static void start(
-      std::shared_ptr<Task> self,
-      uint32_t maxDrivers,
-      uint32_t concurrentSplitGroups = 1);
+  void start(uint32_t maxDrivers, uint32_t concurrentSplitGroups = 1);
 
-  /// If this returns true, this Task supports the single-threaded execution API
+  /// If this returns true, this Task supports the serial execution API
   /// next().
-  bool supportsSingleThreadedExecution() const;
+  bool supportSerialExecutionMode() const;
 
   /// Single-threaded execution API. Runs the query and returns results one
   /// batch at a time. Returns nullptr if query evaluation is finished and no
@@ -220,7 +254,7 @@ class Task : public std::enable_shared_from_this<Task> {
 
   /// Returns current state of execution.
   TaskState state() const {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     return state_;
   }
 
@@ -235,13 +269,16 @@ class Task : public std::enable_shared_from_this<Task> {
   /// Returns a future which is realized when the task is no longer in
   /// running state.
   /// If the task is not in running state at the time of call, the future is
-  /// immediately realized. The future is realized with an exception after
-  /// maxWaitMicros. A zero max wait means no timeout.
-  ContinueFuture taskCompletionFuture(uint64_t maxWaitMicros);
+  /// immediately realized.
+  ContinueFuture taskCompletionFuture();
+
+  /// Returns a future which is realized when the task has been deleted, and all
+  /// the background activities have finished at that point.
+  ContinueFuture taskDeletionFuture();
 
   /// Returns task execution error or nullptr if no error occurred.
   std::exception_ptr error() const {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     return exception_;
   }
 
@@ -253,6 +290,25 @@ class Task : public std::enable_shared_from_this<Task> {
   /// structure.
   TaskStats taskStats() const;
 
+  /// Information about an operator call that helps debugging stuck calls.
+  struct OpCallInfo {
+    size_t durationMs;
+    /// Thread id of where the operator got stuck.
+    int32_t tid;
+    int32_t opId;
+    std::string taskId;
+    /// Call in the format of "<operatorType>.<nodeId>::<operatorMethod>".
+    std::string opCall;
+  };
+
+  /// Collect long running operator calls across all drivers in this task.
+  /// Return false when the lock cannot be taken within the timeout, in that
+  /// case the result is not populated.  Return true if everything works well.
+  bool getLongRunningOpCalls(
+      std::chrono::nanoseconds lockTimeout,
+      size_t thresholdDurationMs,
+      std::vector<OpCallInfo>& out) const;
+
   /// Returns time (ms) since the task execution started or zero, if not
   /// started.
   uint64_t timeSinceStartMs() const;
@@ -260,30 +316,49 @@ class Task : public std::enable_shared_from_this<Task> {
   /// Returns time (ms) since the task execution ended or zero, if not finished.
   uint64_t timeSinceEndMs() const;
 
+  /// Returns time (ms) since the task was terminated or zero, if not terminated
+  /// yet.
+  uint64_t timeSinceTerminationMs() const;
+
   /// Returns the total number of drivers in the output pipeline, e.g. the
   /// pipeline that produces the results.
   uint32_t numOutputDrivers() const {
     return numDrivers(getOutputPipelineId());
   }
 
+  /// Stores the number of drivers in various states of execution.
+  struct DriverCounts {
+    uint32_t numQueuedDrivers{0};
+    uint32_t numOnThreadDrivers{0};
+    uint32_t numSuspendedDrivers{0};
+    std::unordered_map<BlockingReason, uint64_t> numBlockedDrivers;
+  };
+
+  /// Returns the number of drivers in various states of execution.
+  DriverCounts driverCounts() const;
+
   /// Returns the number of running drivers.
   uint32_t numRunningDrivers() const {
-    std::lock_guard<std::mutex> taskLock(mutex_);
+    std::lock_guard<std::timed_mutex> taskLock(mutex_);
     return numRunningDrivers_;
   }
 
   /// Returns the total number of drivers the task needs to run.
   uint32_t numTotalDrivers() const {
-    std::lock_guard<std::mutex> taskLock(mutex_);
+    std::lock_guard<std::timed_mutex> taskLock(mutex_);
     return numTotalDrivers_;
   }
 
   /// Returns the number of finished drivers so far.
   uint32_t numFinishedDrivers() const {
-    std::lock_guard<std::mutex> taskLock(mutex_);
+    std::lock_guard<std::timed_mutex> taskLock(mutex_);
     return numFinishedDrivers_;
   }
 
+  const std::vector<std::weak_ptr<Driver>>& testingDriversClosedByTask() const {
+    return driversClosedByTask_;
+  }
+
   /// Internal public methods. These methods are intended to be used by internal
   /// library components (Driver, Operator, etc.) and should not be called by
   /// the library users.
@@ -293,6 +368,7 @@ class Task : public std::enable_shared_from_this<Task> {
   /// be called from the Operator's constructor.
   velox::memory::MemoryPool* addOperatorPool(
       const core::PlanNodeId& planNodeId,
+      uint32_t splitGroupId,
       int pipelineId,
       uint32_t driverId,
       const std::string& operatorType);
@@ -335,12 +411,14 @@ class Task : public std::enable_shared_from_this<Task> {
       exec::Split& split,
       ContinueFuture& future,
       int32_t maxPreloadSplits = 0,
-      std::function<void(std::shared_ptr<connector::ConnectorSplit>)> preload =
-          nullptr);
+      const ConnectorSplitPreloadFunc& preload = nullptr);
 
-  void splitFinished();
+  void splitFinished(bool fromTableScan, int64_t splitWeight);
 
-  void multipleSplitsFinished(int32_t numSplits);
+  void multipleSplitsFinished(
+      bool fromTableScan,
+      int32_t numSplits,
+      int64_t splitsWeight);
 
   /// Adds a MergeSource for the specified splitGroupId and planNodeId.
   std::shared_ptr<MergeSource> addLocalMergeSource(
@@ -451,10 +529,6 @@ class Task : public std::enable_shared_from_this<Task> {
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId);
 
-  std::shared_ptr<SpillOperatorGroup> getSpillOperatorGroupLocked(
-      uint32_t splitGroupId,
-      const core::PlanNodeId& planNodeId);
-
   /// Transitions this to kFinished state if all Drivers are
   /// finished. Otherwise sets a flag so that the last Driver to finish
   /// will transition the state.
@@ -464,6 +538,9 @@ class Task : public std::enable_shared_from_this<Task> {
   /// stats. Called from Drivers upon their closure.
   void addOperatorStats(OperatorStats& stats);
 
+  /// Adds per driver statistics.  Called from Drivers upon their closure.
+  void addDriverStats(int pipelineId, DriverStats stats);
+
   /// Returns kNone if no pause or terminate is requested. The thread count is
   /// incremented if kNone is returned. If something else is returned the
   /// calling thread should unwind and return itself to its pool. If 'this' goes
@@ -535,7 +612,7 @@ class Task : public std::enable_shared_from_this<Task> {
   }
 
   void requestYield() {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     toYield_ = numThreads_;
   }
 
@@ -544,14 +621,12 @@ class Task : public std::enable_shared_from_this<Task> {
   /// 'this' at the time of requesting yield. Returns 0 if yield not requested.
   int32_t yieldIfDue(uint64_t startTimeMicros);
 
-  /// Once 'pauseRequested_' is set, it will not be cleared until
-  /// task::resume(). It is therefore OK to read it without a mutex
-  /// from a thread that this flag concerns.
-  bool pauseRequested() const {
-    return pauseRequested_;
-  }
+  /// Check if the task is requested to pause. If it is true and 'future' is not
+  /// null, a task resume future is returned which will be fulfilled once the
+  /// task is resumed.
+  bool pauseRequested(ContinueFuture* future = nullptr);
 
-  std::mutex& mutex() {
+  std::timed_mutex& mutex() {
     return mutex_;
   }
 
@@ -574,23 +649,64 @@ class Task : public std::enable_shared_from_this<Task> {
     return spillDirectory_;
   }
 
-  /// True if produces output via PartitionedOutputBufferManager.
+  /// Returns the spill directory path. Ensures that the spill directory is
+  /// created before returning. Is thread safe. Returns an empty string if
+  /// either the spill directory is not specified during task creation or the
+  /// folder could not be created.
+  const std::string& getOrCreateSpillDirectory();
+
+  /// True if produces output via OutputBufferManager.
   bool hasPartitionedOutput() const {
     return numDriversInPartitionedOutput_ > 0;
   }
 
+  /// Returns the cancellation token to check if this task has been terminated
+  /// or not. This helps the Velox integration with query system using folly
+  /// cancellation mechanism.
+  folly::CancellationToken getCancellationToken() {
+    return cancellationSource_.getToken();
+  }
+
+  void testingIncrementThreads() {
+    std::lock_guard l(mutex_);
+    ++numThreads_;
+  }
+
   /// Invoked to run provided 'callback' on each alive driver of the task.
   void testingVisitDrivers(const std::function<void(Driver*)>& callback);
 
+  /// Invoked to finish the task for test purpose.
+  void testingFinish() {
+    terminate(TaskState::kFinished).wait();
+  }
+
  private:
   Task(
       const std::string& taskId,
       core::PlanFragment planFragment,
       int destination,
       std::shared_ptr<core::QueryCtx> queryCtx,
+      ExecutionMode mode,
       ConsumerSupplier consumerSupplier,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
+  // Consistency check of the task execution to make sure the execution mode
+  // stays the same.
+  void checkExecutionMode(ExecutionMode mode);
+
+  // Creates driver factories.
+  void createDriverFactoriesLocked(uint32_t maxDrivers);
+
+  // Creates the output buffer in partitioned output buffer manager if needed.
+  void initializePartitionOutput();
+
+  // Creates and starts drivers.
+  void createAndStartDrivers(uint32_t concurrentSplitGroups);
+
+  // Creates a bunch of drivers for the given split group.
+  std::vector<std::shared_ptr<Driver>> createDriversLocked(
+      uint32_t splitGroupId);
+
   // Returns time (ms) since the task execution started or zero, if not started.
   uint64_t timeSinceStartMsLocked() const;
 
@@ -612,11 +728,16 @@ class Task : public std::enable_shared_from_this<Task> {
   // Invoked to initialize the memory pool for this task on creation.
   void initTaskPool();
 
-  // Creates new instance of MemoryPool for a plan node, stores it in the task
+  // Creates new instance of memory pool for a plan node, stores it in the task
   // to ensure lifetime and returns a raw pointer.
-  memory::MemoryPool* getOrAddNodePool(
+  memory::MemoryPool* getOrAddNodePool(const core::PlanNodeId& planNodeId);
+
+  // Similar to getOrAddNodePool but creates the memory pool instance for a hash
+  // join plan node. If 'splitGroupId' is not kUngroupedGroupId, it specifies
+  // the split group id under the grouped execution mode.
+  memory::MemoryPool* getOrAddJoinNodePool(
       const core::PlanNodeId& planNodeId,
-      bool isHashJoinNode = false);
+      uint32_t splitGroupId);
 
   // Creates a memory reclaimer instance for a plan node if the task memory
   // pool has set memory reclaimer. If 'isHashJoinNode' is true, it creates a
@@ -644,10 +765,16 @@ class Task : public std::enable_shared_from_this<Task> {
       const core::PlanNodeId& planNodeId,
       uint32_t pipelineId);
 
-  /// Returns task execution error message or empty string if not error
-  /// occurred. This should only be called inside mutex_ protection.
+  // Invoked to remove this task from the output buffer manager if it has set
+  // output buffer.
+  void maybeRemoveFromOutputBufferManager();
+
+  // Returns task execution error message or empty string if not error
+  // occurred. This should only be called inside mutex_ protection.
   std::string errorMessageLocked() const;
 
+  folly::dynamic toShortJsonLocked() const;
+
   class MemoryReclaimer : public exec::MemoryReclaimer {
    public:
     static std::unique_ptr<memory::MemoryReclaimer> create(
@@ -656,6 +783,7 @@ class Task : public std::enable_shared_from_this<Task> {
     uint64_t reclaim(
         memory::MemoryPool* pool,
         uint64_t targetBytes,
+        uint64_t maxWaitMs,
         memory::MemoryReclaimer::Stats& stats) override;
 
     void abort(memory::MemoryPool* pool, const std::exception_ptr& error)
@@ -674,6 +802,12 @@ class Task : public std::enable_shared_from_this<Task> {
       return task_.lock();
     }
 
+    uint64_t reclaimTask(
+        const std::shared_ptr<Task>& task,
+        uint64_t targetBytes,
+        uint64_t maxWaitMs,
+        memory::MemoryReclaimer::Stats& stats);
+
     std::weak_ptr<Task> task_;
   };
 
@@ -704,8 +838,13 @@ class Task : public std::enable_shared_from_this<Task> {
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId);
 
-  template <class TBridgeType>
+  template <class TBridgeType, typename MemberType>
   std::shared_ptr<TBridgeType> getJoinBridgeInternalLocked(
+      uint32_t splitGroupId,
+      const core::PlanNodeId& planNodeId,
+      MemberType SplitGroupState::*bridges_member);
+
+  std::shared_ptr<JoinBridge> getCustomJoinBridgeInternal(
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId);
 
@@ -717,53 +856,48 @@ class Task : public std::enable_shared_from_this<Task> {
 
   /// Retrieve a split or split future from the given split store structure.
   BlockingReason getSplitOrFutureLocked(
+      bool forTableScan,
       SplitsStore& splitsStore,
       exec::Split& split,
       ContinueFuture& future,
-      int32_t maxPreloadSplits = 0,
-      std::function<void(std::shared_ptr<connector::ConnectorSplit>)> preload =
-          nullptr);
+      int32_t maxPreloadSplits,
+      const ConnectorSplitPreloadFunc& preload);
 
   /// Returns next split from the store. The caller must ensure the store is not
   /// empty.
   exec::Split getSplitLocked(
+      bool forTableScan,
       SplitsStore& splitsStore,
       int32_t maxPreloadSplits,
-      std::function<void(std::shared_ptr<connector::ConnectorSplit>)> preload);
+      const ConnectorSplitPreloadFunc& preload);
 
-  /// Creates for the given split group and fills up the 'SplitGroupState'
-  /// structure, which stores inter-operator state (local exchange, bridges).
+  // Creates for the given split group and fills up the 'SplitGroupState'
+  // structure, which stores inter-operator state (local exchange, bridges).
   void createSplitGroupStateLocked(uint32_t splitGroupId);
 
-  /// Creates a bunch of drivers for the given split group.
-  void createDriversLocked(
-      std::shared_ptr<Task>& self,
-      uint32_t splitGroupId,
-      std::vector<std::shared_ptr<Driver>>& out);
-
-  /// Checks if we have splits in a split group that haven't been processed yet
-  /// and have capacity in terms of number of concurrent split groups being
-  /// processed. If yes, creates split group state and Drivers and runs them.
-  void ensureSplitGroupsAreBeingProcessedLocked(std::shared_ptr<Task>& self);
+  // Checks if we have splits in a split group that haven't been processed yet
+  // and have capacity in terms of number of concurrent split groups being
+  // processed. If yes, creates split group state and Drivers and runs them.
+  void ensureSplitGroupsAreBeingProcessedLocked();
 
   void driverClosedLocked();
 
-  /// Returns true if Task is in kRunning state, but all output drivers finished
-  /// processing and all output has been consumed. In other words, returns true
-  /// if task should transition to kFinished state.
-  ///
-  /// In case of grouped execution, checks that all drivers, not just output
-  /// drivers finished processing.
+  // Returns true if Task is in kRunning state, but all output drivers finished
+  // processing and all output has been consumed. In other words, returns true
+  // if task should transition to kFinished state.
+  //
+  // In case of grouped execution, checks that all drivers, not just output
+  // drivers finished processing.
   bool checkIfFinishedLocked();
 
-  /// Check if we have no more split groups coming and adjust the total number
-  /// of drivers if more split groups coming. Returns true if Task is in
-  /// kRunning state, but no more split groups are commit and all drivers
-  /// finished processing and all output has been consumed. In other words,
-  /// returns true if task should transition to kFinished state.
+  // Check if we have no more split groups coming and adjust the total number
+  // of drivers if more split groups coming. Returns true if Task is in
+  // kRunning state, but no more split groups are commit and all drivers
+  // finished processing and all output has been consumed. In other words,
+  // returns true if task should transition to kFinished state.
   bool checkNoMoreSplitGroupsLocked();
 
-  /// Notifies listeners that the task is now complete.
+  // Notifies listeners that the task is now complete.
   void onTaskCompletion();
 
   // Returns true if all splits are finished processing and there are no more
@@ -798,7 +932,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // executing for 'this'. 'comment' is used as a debugging label on
   // the promise/future pair.
   ContinueFuture makeFinishFuture(const char* comment) {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     return makeFinishFutureLocked(comment);
   }
 
@@ -816,7 +950,7 @@ class Task : public std::enable_shared_from_this<Task> {
 
   // Create an exchange client for the specified exchange plan node at a given
   // pipeline.
-  void createExchangeClient(
+  void createExchangeClientLocked(
       int32_t pipelineId,
       const core::PlanNodeId& planNodeId);
 
@@ -825,7 +959,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // created for 'planNodeId' in 'exchangeClientByPlanNode_'.
   std::shared_ptr<ExchangeClient> getExchangeClient(
       const core::PlanNodeId& planNodeId) const {
-    std::lock_guard<std::mutex> l(mutex_);
+    std::lock_guard<std::timed_mutex> l(mutex_);
     return getExchangeClientLocked(planNodeId);
   }
 
@@ -838,6 +972,13 @@ class Task : public std::enable_shared_from_this<Task> {
   std::shared_ptr<ExchangeClient> getExchangeClientLocked(
       int32_t pipelineId) const;
 
+  // Builds the query trace config.
+  std::optional<trace::QueryTraceConfig> maybeMakeTraceConfig() const;
+
+  // Create a 'QueryMetadtaWriter' to trace the query metadata if the query
+  // trace enabled.
+  void maybeInitQueryTrace();
+
   // The helper class used to maintain 'numCreatedTasks_' and 'numDeletedTasks_'
   // on task construction and destruction.
   class TaskCounter {
@@ -868,6 +1009,11 @@ class Task : public std::enable_shared_from_this<Task> {
   core::PlanFragment planFragment_;
   const int destination_;
   const std::shared_ptr<core::QueryCtx> queryCtx_;
+  const std::optional<trace::QueryTraceConfig> traceConfig_;
+
+  // The execution mode of the task. It is enforced that a task can only be
+  // executed in a single mode throughout its lifetime
+  const ExecutionMode mode_;
 
   // Root MemoryPool for this Task. All member variables that hold references
   // to pool_ must be defined after pool_, childPools_.
@@ -881,9 +1027,9 @@ class Task : public std::enable_shared_from_this<Task> {
   // pointer.
   //
   // NOTE: 'childPools_' holds the ownerships of node memory pools.
-  std::unordered_map<core::PlanNodeId, memory::MemoryPool*> nodePools_;
+  std::unordered_map<std::string, memory::MemoryPool*> nodePools_;
 
-  // Set to true by PartitionedOutputBufferManager when all output is
+  // Set to true by OutputBufferManager when all output is
   // acknowledged. If this happens before Drivers are at end, the last
   // Driver to finish will set state_ to kFinished. If Drivers have
   // finished then setting this to true will also set state_ to
@@ -893,7 +1039,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // Set if terminated by an error. This is the first error reported
   // by any of the instances.
   std::exception_ptr exception_ = nullptr;
-  mutable std::mutex mutex_;
+  mutable std::timed_mutex mutex_;
 
   // Exchange clients. One per pipeline / source. Null for pipelines, which
   // don't need it.
@@ -917,84 +1063,92 @@ class Task : public std::enable_shared_from_this<Task> {
 
   std::vector<std::unique_ptr<DriverFactory>> driverFactories_;
   std::vector<std::shared_ptr<Driver>> drivers_;
-  /// The total number of running drivers in all pipelines.
-  /// This number changes over time as drivers finish their work and maybe new
-  /// get created.
+  // When Drivers are closed by the Task, there is a chance that race and/or
+  // bugs can cause such Drivers to be held forever, in turn holding a pointer
+  // to the Task making it a zombie Tasks. This vector is used to keep track of
+  // such drivers to assist debugging zombie Tasks.
+  std::vector<std::weak_ptr<Driver>> driversClosedByTask_;
+  // The total number of running drivers in all pipelines.
+  // This number changes over time as drivers finish their work and maybe new
+  // get created.
   uint32_t numRunningDrivers_{0};
-  /// The total number of drivers we need to run in all pipelines. It is sum of
-  /// the Ungrouped Execution drivers plus the number of Grouped Execution
-  /// drivers per split group times the number of split groups. In practice for
-  /// tasks with Grouped Execution the final number would be much less (roughly
-  /// divided by the number of workers), so this will be adjusted in the end of
-  /// task's work.
+  // The total number of drivers we need to run in all pipelines. It is sum of
+  // the Ungrouped Execution drivers plus the number of Grouped Execution
+  // drivers per split group times the number of split groups. In practice for
+  // tasks with Grouped Execution the final number would be much less (roughly
+  // divided by the number of workers), so this will be adjusted in the end of
+  // task's work.
   uint32_t numTotalDrivers_{0};
-  /// The number of completed drivers so far.
-  /// This number increases over time as drivers finish their work.
-  /// We use this number to detect when the Task is completed.
+  // The number of completed drivers so far. This number increases over time as
+  // drivers finish their work. We use this number to detect when the Task is
+  // completed.
   uint32_t numFinishedDrivers_{0};
-  /// Reflects number of drivers required to process single split group during
-  /// grouped execution. Zero for a completely ungrouped execution.
+  // Reflects number of drivers required to process single split group during
+  // grouped execution. Zero for a completely ungrouped execution.
   uint32_t numDriversPerSplitGroup_{0};
-  /// Reflects number of drivers required to run ungrouped execution in the
-  /// fragment. Zero for a completely grouped execution.
+  // Reflects number of drivers required to run ungrouped execution in the
+  // fragment. Zero for a completely grouped execution.
   uint32_t numDriversUngrouped_{0};
-  /// Number of drivers running in the pipeline hosting the Partitioned Output
-  /// (in a single split group). We use it to recalculate the number of
-  /// producing drivers at the end during the Grouped Execution mode.
+  // Number of drivers running in the pipeline hosting the Partitioned Output
+  // (in a single split group). We use it to recalculate the number of producing
+  // drivers at the end during the Grouped Execution mode.
   uint32_t numDriversInPartitionedOutput_{0};
-  /// True if the pipeline hosting the Partitioned Output runs in the Grouped
-  /// Execution mode. In this case we will need to update the number of output
-  /// drivers in the end. False otherwise.
+  // True if the pipeline hosting the Partitioned Output runs in the Grouped
+  // Execution mode. In this case we will need to update the number of output
+  // drivers in the end. False otherwise.
   bool groupedPartitionedOutput_{false};
-  /// The number of splits groups we run concurrently.
+  // The number of splits groups we run concurrently.
   uint32_t concurrentSplitGroups_{1};
 
-  /// Have we already initialized stats of operators in the drivers for Grouped
-  /// Execution?
+  // Have we already initialized stats of operators in the drivers for Grouped
+  // Execution?
   bool initializedGroupedOpStats_{false};
-  /// Have we already initialized stats of operators in the drivers for
-  /// Ungrouped Execution?
+  // Have we already initialized stats of operators in the drivers for Ungrouped
+  // Execution?
   bool initializedUngroupedOpStats_{false};
 
-  /// How many splits groups we are processing at the moment. Used to control
-  /// split group concurrency. Ungrouped Split Group is not included here.
+  // How many splits groups we are processing at the moment. Used to control
+  // split group concurrency. Ungrouped Split Group is not included here.
   uint32_t numRunningSplitGroups_{0};
-  /// Split groups for which we have received at least one split - meaning our
-  /// task is to process these. This set only grows. Used to deduplicate split
-  /// groups for different nodes and to determine how many split groups we to
-  /// process in total.
+  // Split groups for which we have received at least one split - meaning our
+  // task is to process these. This set only grows. Used to deduplicate split
+  // groups for different nodes and to determine how many split groups we to
+  // process in total.
   std::unordered_set<uint32_t> seenSplitGroups_;
-  /// Split groups for which we have received splits but haven't started
-  /// processing. It grows with arrival of the 1st split of a previously not
-  /// seen split group and depletes with creating new sets of drivers to process
-  /// queued split groups.
+  // Split groups for which we have received splits but haven't started
+  // processing. It grows with arrival of the 1st split of a previously not seen
+  // split group and depletes with creating new sets of drivers to process
+  // queued split groups.
   std::queue<uint32_t> queuedSplitGroups_;
 
-  TaskState state_ = TaskState::kRunning;
+  TaskState state_{TaskState::kRunning};
 
-  /// Stores splits state structure for each plan node.
-  /// At construction populated with all leaf plan nodes that require splits.
-  /// Afterwards accessed with getPlanNodeSplitsStateLocked() to ensure we only
-  /// manage splits of the plan nodes that expect splits.
+  // Stores splits state structure for each plan node. At construction populated
+  // with all leaf plan nodes that require splits. Afterwards accessed with
+  // getPlanNodeSplitsStateLocked() to ensure we only manage splits of the plan
+  // nodes that expect splits.
   std::unordered_map<core::PlanNodeId, SplitsState> splitsStates_;
 
   // Promises that are fulfilled when the task is completed (terminated).
   std::vector<ContinuePromise> taskCompletionPromises_;
 
+  // Promises that are fulfilled when the task is destroyed.
+  std::vector<ContinuePromise> taskDeletionPromises_;
+
   // Promises that are fulfilled when the task's state has changed and ready to
   // report some progress (such as split group finished or task is completed).
   std::vector<ContinuePromise> stateChangePromises_;
 
   TaskStats taskStats_;
 
-  /// Stores inter-operator state (exchange, bridges) per split group.
-  /// During ungrouped execution we use the [0] entry in this vector.
+  // Stores inter-operator state (exchange, bridges) per split group. During
+  // ungrouped execution we use the [0] entry in this vector.
   std::unordered_map<uint32_t, SplitGroupState> splitGroupStates_;
 
-  std::weak_ptr<PartitionedOutputBufferManager> bufferManager_;
+  std::weak_ptr<OutputBufferManager> bufferManager_;
 
-  /// Boolean indicating that we have already received no-more-output-buffers
-  /// message. Subsequent messages will be ignored.
+  // Boolean indicating that we have already received no-more-output-buffers
+  // message. Subsequent messages will be ignored.
   bool noMoreOutputBuffers_{false};
 
   // Thread counts and cancellation -related state.
@@ -1015,9 +1169,24 @@ class Task : public std::enable_shared_from_this<Task> {
   // terminate(). They are fulfilled when the last thread stops
   // running for 'this'.
   std::vector<ContinuePromise> threadFinishPromises_;
-
+  // Promises for the futures returned to callers of pauseRequested().
+  // They are fulfilled when `resume()` is called for this task.
+  std::vector<ContinuePromise> resumePromises_;
   // Base spill directory for this task.
   std::string spillDirectory_;
+
+  // Mutex to ensure only the first caller thread of 'getOrCreateSpillDirectory'
+  // creates the directory.
+  mutable std::mutex spillDirCreateMutex_;
+
+  // Indicates whether the spill directory has been created.
+  std::atomic<bool> spillDirectoryCreated_{false};
+
+  // Stores unconsumed preloading splits to ensure they are closed promptly.
+  folly::F14FastSet<std::shared_ptr<connector::ConnectorSplit>>
+      preloadingSplits_;
+
+  folly::CancellationSource cancellationSource_;
 };
 
 /// Listener invoked on task completion.
@@ -1044,4 +1213,18 @@ bool registerTaskListener(std::shared_ptr<TaskListener> listener);
 /// unregistered successfuly, false if listener was not found.
 bool unregisterTaskListener(const std::shared_ptr<TaskListener>& listener);
 
+std::string executionModeString(Task::ExecutionMode mode);
+
+std::ostream& operator<<(std::ostream& out, Task::ExecutionMode mode);
+
 } // namespace facebook::velox::exec
+
+template <>
+struct fmt::formatter<facebook::velox::exec::Task::ExecutionMode>
+    : formatter<std::string> {
+  auto format(facebook::velox::exec::Task::ExecutionMode m, format_context& ctx)
+      const {
+    return formatter<std::string>::format(
+        facebook::velox::exec::executionModeString(m), ctx);
+  }
+};
diff --git a/velox/exec/TaskDriverOperatorLifecycle.md b/velox/exec/TaskDriverOperatorLifecycle.md
index 1abd7ff60ee3f..dbfb1d1e0edcd 100644
--- a/velox/exec/TaskDriverOperatorLifecycle.md
+++ b/velox/exec/TaskDriverOperatorLifecycle.md
@@ -5,21 +5,21 @@ Tasks and Drivers which are cleared when Task drops references to Drivers.
 Task::terminate contains catch-all logic to clear things up in case of abnormal
 or early termination.
 
-## PartitionedOutputBufferManager
+## OutputBufferManager
 
-PartitionedOutputBuffer holds a reference to the task. This reference is used to
+OutputBuffer holds a reference to the task. This reference is used to
 notify the task that all output has been consumed by calling
-task->setAllOutputConsumed() from PartitionedOutputBuffer::deleteResults.
+task->setAllOutputConsumed() from OutputBuffer::deleteResults.
 
-This reference is dropped when PartitionedOutputBuffer is destroyed which
-happens in (1) PartitionedOutputBufferManager::deleteResults (happy path) and
-(2) PartitionedOutputBufferManager::removeTask (error path).
+This reference is dropped when OutputBuffer is destroyed which
+happens in (1) OutputBufferManager::deleteResults (happy path) and
+(2) OutputBufferManager::removeTask (error path).
 
-In Prestissimo application, PartitionedOutputBufferManager::deleteResults is called by
+In Prestissimo application, OutputBufferManager::deleteResults is called by
 TaskManager::abortResults which is called by TaskResource::abortResults
 attached to HTTP DELETE /v1/task/(.+)/results/(.+)
 
-PartitionedOutputBufferManager::removeTask is called by Task::terminate.
+OutputBufferManager::removeTask is called by Task::terminate.
 
 ## Operator
 
diff --git a/velox/exec/TaskStats.h b/velox/exec/TaskStats.h
index ac64dd4d769f8..25a3ae63a15f6 100644
--- a/velox/exec/TaskStats.h
+++ b/velox/exec/TaskStats.h
@@ -21,6 +21,7 @@
 #include <vector>
 
 #include "velox/exec/Driver.h"
+#include "velox/exec/OutputBuffer.h"
 
 namespace facebook::velox::exec {
 
@@ -28,15 +29,18 @@ struct OperatorStats;
 
 /// Stores execution stats per pipeline.
 struct PipelineStats {
-  // Cumulative OperatorStats for finished Drivers. The subscript is the
-  // operator id, which is the initial ordinal position of the
-  // operator in the DriverFactory.
+  /// Cumulative OperatorStats for finished Drivers. The subscript is the
+  /// operator id, which is the initial ordinal position of the operator in the
+  /// DriverFactory.
   std::vector<OperatorStats> operatorStats;
 
-  // True if contains the source node for the task.
+  /// Runtime statistics per driver.
+  std::vector<DriverStats> driverStats;
+
+  /// True if contains the source node for the task.
   bool inputPipeline;
 
-  // True if contains the sync node for the task.
+  /// True if contains the sync node for the task.
   bool outputPipeline;
 
   PipelineStats(bool _inputPipeline, bool _outputPipeline)
@@ -51,6 +55,12 @@ struct TaskStats {
   int32_t numQueuedSplits{0};
   std::unordered_set<int32_t> completedSplitGroups;
 
+  /// Table scan split stats.
+  int32_t numRunningTableScanSplits{0};
+  int32_t numQueuedTableScanSplits{0};
+  int64_t runningTableScanSplitWeights{0};
+  int64_t queuedTableScanSplitWeights{0};
+
   /// The subscript is given by each Operator's
   /// DriverCtx::pipelineId. This is a sum total reflecting fully
   /// processed Splits for Drivers of this pipeline.
@@ -73,8 +83,15 @@ struct TaskStats {
   /// and results have been consumed.
   uint64_t endTimeMs{0};
 
+  /// Epoch time (ms) when the task was terminated, i.e. its terminal state
+  /// has been set, whether by finishing successfully or with an error, or
+  /// being cancelled or aborted.
+  uint64_t terminationTimeMs{0};
+
   /// Total number of drivers.
   uint64_t numTotalDrivers{0};
+  /// Total number of drivers queued on an executor but not on thread.
+  uint64_t numQueuedDrivers{0};
   /// The number of completed drivers (which slots are null in Task 'drivers_'
   /// list).
   uint64_t numCompletedDrivers{0};
@@ -91,6 +108,19 @@ struct TaskStats {
   double outputBufferUtilization{0};
   /// Indicates if output buffer is over-utilized and thus blocks the producers.
   bool outputBufferOverutilized{false};
+
+  /// Output buffer stats if present.
+  std::optional<OutputBuffer::Stats> outputBufferStats;
+
+  /// The longest still running operator call in "op::call" format.
+  std::string longestRunningOpCall;
+  /// The longest still running operator call's duration in ms.
+  size_t longestRunningOpCallMs{0};
+
+  /// The total memory reclamation count.
+  uint32_t memoryReclaimCount{0};
+  /// The total memory reclamation time.
+  uint64_t memoryReclaimMs{0};
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TaskStructs.h b/velox/exec/TaskStructs.h
index d80d93dafebcb..3ddc147b65274 100644
--- a/velox/exec/TaskStructs.h
+++ b/velox/exec/TaskStructs.h
@@ -18,8 +18,6 @@
 #include <unordered_set>
 #include <vector>
 
-#include "velox/exec/SpillOperatorGroup.h"
-
 namespace facebook::velox::exec {
 
 class Driver;
@@ -27,14 +25,20 @@ class JoinBridge;
 class LocalExchangeMemoryManager;
 class MergeSource;
 class MergeJoinSource;
-class Split;
-class SpillOperatorGroup;
+struct Split;
 
 /// Corresponds to Presto TaskState, needed for reporting query completion.
 enum TaskState { kRunning, kFinished, kCanceled, kAborted, kFailed };
 
 std::string taskStateString(TaskState state);
 
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    TaskState state) {
+  os << taskStateString(state);
+  return os;
+}
+
 struct BarrierState {
   int32_t numRequested;
   std::vector<std::shared_ptr<Driver>> drivers;
@@ -57,6 +61,9 @@ struct SplitsStore {
 
 /// Structure contains the current info on splits for a particular plan node.
 struct SplitsState {
+  /// True if the source node is a table scan.
+  bool sourceIsTableScan{false};
+
   /// Plan node-wide 'no more splits'.
   bool noMoreSplits{false};
 
@@ -81,12 +88,11 @@ struct LocalExchangeState {
 /// Stores inter-operator state (exchange, bridges) for split groups.
 struct SplitGroupState {
   /// Map from the plan node id of the join to the corresponding JoinBridge.
+  /// This map will contain only HashJoinBridge and NestedLoopJoinBridge.
   std::unordered_map<core::PlanNodeId, std::shared_ptr<JoinBridge>> bridges;
-
-  /// Map from the plan node id to the associated spill operator group if disk
-  /// spill is enabled for the corresponding plan operator.
-  std::unordered_map<core::PlanNodeId, std::shared_ptr<SpillOperatorGroup>>
-      spillOperatorGroups;
+  /// This map will contain all other custom bridges.
+  std::unordered_map<core::PlanNodeId, std::shared_ptr<JoinBridge>>
+      custom_bridges;
 
   /// Holds states for Task::allPeersFinished.
   std::unordered_map<core::PlanNodeId, BarrierState> barriers;
@@ -123,7 +129,7 @@ struct SplitGroupState {
   void clear() {
     if (!mixedExecutionMode) {
       bridges.clear();
-      spillOperatorGroups.clear();
+      custom_bridges.clear();
       barriers.clear();
     }
     localMergeSources.clear();
diff --git a/velox/exec/TopN.cpp b/velox/exec/TopN.cpp
index 3553bf81d1470..1c7af49247716 100644
--- a/velox/exec/TopN.cpp
+++ b/velox/exec/TopN.cpp
@@ -13,8 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/exec/TopN.h"
+#include <folly/container/F14Map.h>
+
 #include "velox/exec/ContainerRowSerde.h"
+#include "velox/exec/TopN.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::exec {
@@ -36,14 +38,34 @@ TopN::TopN(
           topNNode->sortingOrders(),
           data_.get()),
       topRows_(comparator_),
-      decodedVectors_(outputType_->children().size()) {}
+      decodedVectors_(outputType_->children().size()) {
+  const auto numColumns{outputType_->children().size()};
+  const auto numSortingKeys{topNNode->sortingKeys().size()};
+  sortingKeyColumns_.reserve(numSortingKeys);
+  std::vector<bool> isSortingKey(numColumns);
+  for (const auto& key : topNNode->sortingKeys()) {
+    sortingKeyColumns_.emplace_back(exprToChannel(key.get(), outputType_));
+    isSortingKey[sortingKeyColumns_.back()] = true;
+  }
+  if (numColumns > numSortingKeys) {
+    nonKeyColumns_.reserve(numColumns - numSortingKeys);
+    for (column_index_t i = 0; i < numColumns; ++i) {
+      if (!isSortingKey[i]) {
+        nonKeyColumns_.emplace_back(i);
+      }
+    }
+  }
+}
 
 void TopN::addInput(RowVectorPtr input) {
-  // TODO Decode keys first, then decode the rest only for passing positions
-  for (auto col = 0; col < input->childrenSize(); ++col) {
+  for (const auto col : sortingKeyColumns_) {
     decodedVectors_[col].decode(*input->childAt(col));
   }
 
+  const bool hasNonKeyColumn{!nonKeyColumns_.empty()};
+  // Maps passed rows of 'data_' to the corresponding input row number. These
+  // input rows of non-key columns are later stored into data_.
+  folly::F14FastMap<void*, vector_size_t> passedRows;
   for (auto row = 0; row < input->size(); ++row) {
     char* newRow = nullptr;
     if (topRows_.size() < count_) {
@@ -59,11 +81,28 @@ void TopN::addInput(RowVectorPtr input) {
       newRow = data_->initializeRow(topRow, true /* reuse */);
     }
 
-    for (auto col = 0; col < input->childrenSize(); ++col) {
+    data_->initializeFields(newRow);
+    for (const auto col : sortingKeyColumns_) {
       data_->store(decodedVectors_[col], row, newRow, col);
     }
 
     topRows_.push(newRow);
+    if (hasNonKeyColumn) {
+      passedRows[newRow] = row;
+    }
+  }
+
+  if (hasNonKeyColumn && !passedRows.empty()) {
+    for (const auto col : nonKeyColumns_) {
+      decodedVectors_[col].decode(*input->childAt(col));
+      for (const auto [dataRow, inputRow] : passedRows) {
+        data_->store(
+            decodedVectors_[col],
+            inputRow,
+            reinterpret_cast<char*>(dataRow),
+            col);
+      }
+    }
   }
 }
 
diff --git a/velox/exec/TopN.h b/velox/exec/TopN.h
index 9810d0cd66b7f..3df196420aef0 100644
--- a/velox/exec/TopN.h
+++ b/velox/exec/TopN.h
@@ -49,6 +49,9 @@ class TopN : public Operator {
   bool finished_ = false;
   uint32_t numRowsReturned_ = 0;
 
+  std::vector<column_index_t> sortingKeyColumns_;
+  std::vector<column_index_t> nonKeyColumns_;
+
   // As the inputs are added to TopN operator, we use topRows_ (a priority
   // queue) to keep track of the pointers to rows stored in the
   // RowContainer (data_). We only update the RowContainer if a row is a
diff --git a/velox/exec/TopNRowNumber.cpp b/velox/exec/TopNRowNumber.cpp
index ddd9511857bfa..a85bf26881855 100644
--- a/velox/exec/TopNRowNumber.cpp
+++ b/velox/exec/TopNRowNumber.cpp
@@ -14,9 +14,93 @@
  * limitations under the License.
  */
 #include "velox/exec/TopNRowNumber.h"
+#include "velox/exec/OperatorUtils.h"
 
 namespace facebook::velox::exec {
 
+namespace {
+
+std::vector<column_index_t> reorderInputChannels(
+    const RowTypePtr& inputType,
+    const std::vector<core::FieldAccessTypedExprPtr>& partitionKeys,
+    const std::vector<core::FieldAccessTypedExprPtr>& sortingKeys) {
+  const auto size = inputType->size();
+
+  std::vector<column_index_t> channels;
+  channels.reserve(size);
+
+  std::unordered_set<std::string> keyNames;
+
+  for (const auto& key : partitionKeys) {
+    channels.push_back(exprToChannel(key.get(), inputType));
+    keyNames.insert(key->name());
+  }
+
+  for (const auto& key : sortingKeys) {
+    channels.push_back(exprToChannel(key.get(), inputType));
+    keyNames.insert(key->name());
+  }
+
+  for (auto i = 0; i < size; ++i) {
+    if (keyNames.count(inputType->nameOf(i)) == 0) {
+      channels.push_back(i);
+    }
+  }
+
+  return channels;
+}
+
+RowTypePtr reorderInputType(
+    const RowTypePtr& inputType,
+    const std::vector<column_index_t>& channels) {
+  const auto size = inputType->size();
+
+  VELOX_CHECK_EQ(size, channels.size());
+
+  std::vector<std::string> names;
+  names.reserve(size);
+
+  std::vector<TypePtr> types;
+  types.reserve(size);
+
+  for (auto channel : channels) {
+    names.push_back(inputType->nameOf(channel));
+    types.push_back(inputType->childAt(channel));
+  }
+
+  return ROW(std::move(names), std::move(types));
+}
+
+std::vector<CompareFlags> makeSpillCompareFlags(
+    int32_t numPartitionKeys,
+    const std::vector<core::SortOrder>& sortingOrders) {
+  std::vector<CompareFlags> compareFlags;
+  compareFlags.reserve(numPartitionKeys + sortingOrders.size());
+
+  for (auto i = 0; i < numPartitionKeys; ++i) {
+    compareFlags.push_back({});
+  }
+
+  for (const auto& order : sortingOrders) {
+    compareFlags.push_back(
+        {order.isNullsFirst(), order.isAscending(), false /*equalsOnly*/});
+  }
+
+  return compareFlags;
+}
+
+// Returns a [start, end) slice of the 'types' vector.
+std::vector<TypePtr>
+slice(const std::vector<TypePtr>& types, int32_t start, int32_t end) {
+  std::vector<TypePtr> result;
+  result.reserve(end - start);
+  for (auto i = start; i < end; ++i) {
+    result.push_back(types[i]);
+  }
+  return result;
+}
+} // namespace
+
 TopNRowNumber::TopNRowNumber(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -26,25 +110,52 @@ TopNRowNumber::TopNRowNumber(
           node->outputType(),
           operatorId,
           node->id(),
-          "TopNRowNumber"),
+          "TopNRowNumber",
+          node->canSpill(driverCtx->queryConfig())
+              ? driverCtx->makeSpillConfig(operatorId)
+              : std::nullopt),
       limit_{node->limit()},
       generateRowNumber_{node->generateRowNumber()},
-      inputType_{node->sources()[0]->outputType()},
-      data_(std::make_unique<RowContainer>(inputType_->children(), pool())),
+      numPartitionKeys_{node->partitionKeys().size()},
+      inputChannels_{reorderInputChannels(
+          node->inputType(),
+          node->partitionKeys(),
+          node->sortingKeys())},
+      inputType_{reorderInputType(node->inputType(), inputChannels_)},
+      spillCompareFlags_{
+          makeSpillCompareFlags(numPartitionKeys_, node->sortingOrders())},
+      abandonPartialMinRows_(
+          driverCtx->queryConfig().abandonPartialTopNRowNumberMinRows()),
+      abandonPartialMinPct_(
+          driverCtx->queryConfig().abandonPartialTopNRowNumberMinPct()),
+      data_(std::make_unique<RowContainer>(
+          slice(inputType_->children(), 0, spillCompareFlags_.size()),
+          slice(
+              inputType_->children(),
+              spillCompareFlags_.size(),
+              inputType_->size()),
+          pool())),
       comparator_(
           inputType_,
           node->sortingKeys(),
           node->sortingOrders(),
           data_.get()),
-      decodedVectors_(inputType_->children().size()) {
+      decodedVectors_(inputType_->size()) {
   const auto& keys = node->partitionKeys();
   const auto numKeys = keys.size();
 
   if (numKeys > 0) {
-    Accumulator accumulator{true, sizeof(TopRows), false, 1, [](auto) {}};
+    Accumulator accumulator{
+        true,
+        sizeof(TopRows),
+        false,
+        1,
+        nullptr,
+        [](auto, auto) { VELOX_UNREACHABLE(); },
+        [](auto) {}};
 
     table_ = std::make_unique<HashTable<false>>(
-        createVectorHashers(inputType_, keys),
+        createVectorHashers(node->inputType(), keys),
         std::vector<Accumulator>{accumulator},
         std::vector<TypePtr>{},
         false, // allowDuplicates
@@ -59,28 +170,30 @@ TopNRowNumber::TopNRowNumber(
     singlePartition_ = std::make_unique<TopRows>(allocator_.get(), comparator_);
   }
 
-  identityProjections_.reserve(inputType_->size());
-  for (auto i = 0; i < inputType_->size(); ++i) {
-    identityProjections_.emplace_back(i, i);
-  }
-
   if (generateRowNumber_) {
-    resultProjections_.emplace_back(0, inputType_->size());
     results_.resize(1);
   }
 }
 
 void TopNRowNumber::addInput(RowVectorPtr input) {
+  if (abandonedPartial_) {
+    input_ = std::move(input);
+    return;
+  }
+
   const auto numInput = input->size();
 
-  for (auto i = 0; i < inputType_->size(); ++i) {
-    decodedVectors_[i].decode(*input->childAt(i));
+  for (auto i = 0; i < inputChannels_.size(); ++i) {
+    decodedVectors_[i].decode(*input->childAt(inputChannels_[i]));
   }
 
   if (table_) {
+    ensureInputFits(input);
+
     SelectivityVector rows(numInput);
-    table_->prepareForProbe(*lookup_, input, rows, false);
-    table_->groupProbe(*lookup_);
+    table_->prepareForGroupProbe(
+        *lookup_, input, rows, BaseHashTable::kNoSpillInputStartPartitionBit);
+    table_->groupProbe(*lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
 
     // Initialize new partitions.
     initializeNewPartitions();
@@ -90,15 +203,38 @@ void TopNRowNumber::addInput(RowVectorPtr input) {
     // if row should replace an existing row or be discarded.
     for (auto i = 0; i < numInput; ++i) {
       auto& partition = partitionAt(lookup_->hits[i]);
-      processInputRow(input, i, partition);
+      processInputRow(i, partition);
+    }
+
+    if (abandonPartialEarly()) {
+      abandonedPartial_ = true;
+      addRuntimeStat("abandonedPartial", RuntimeCounter(1));
+
+      updateEstimatedOutputRowSize();
+      outputBatchSize_ = outputBatchRows(estimatedOutputRowSize_);
+      outputRows_.resize(outputBatchSize_);
     }
   } else {
     for (auto i = 0; i < numInput; ++i) {
-      processInputRow(input, i, *singlePartition_);
+      processInputRow(i, *singlePartition_);
     }
   }
 }
 
+bool TopNRowNumber::abandonPartialEarly() const {
+  if (table_ == nullptr || generateRowNumber_ || spiller_ != nullptr) {
+    return false;
+  }
+
+  const auto numInput = stats_.rlock()->inputPositions;
+  if (numInput < abandonPartialMinRows_) {
+    return false;
+  }
+
+  const auto numOutput = data_->numRows();
+  return (100 * numOutput / numInput) >= abandonPartialMinPct_;
+}
+
 void TopNRowNumber::initializeNewPartitions() {
   for (auto index : lookup_->newGroups) {
     new (lookup_->hits[index] + partitionOffset_)
@@ -106,10 +242,7 @@ void TopNRowNumber::initializeNewPartitions() {
   }
 }
 
-void TopNRowNumber::processInputRow(
-    const RowVectorPtr& input,
-    vector_size_t index,
-    TopRows& partition) {
+void TopNRowNumber::processInputRow(vector_size_t index, TopRows& partition) {
   auto& topRows = partition.rows;
 
   char* newRow = nullptr;
@@ -130,7 +263,7 @@ void TopNRowNumber::processInputRow(
     newRow = data_->initializeRow(topRow, true /* reuse */);
   }
 
-  for (auto col = 0; col < input->childrenSize(); ++col) {
+  for (auto col = 0; col < decodedVectors_.size(); ++col) {
     data_->store(decodedVectors_[col], index, newRow, col);
   }
 
@@ -140,13 +273,42 @@ void TopNRowNumber::processInputRow(
 void TopNRowNumber::noMoreInput() {
   Operator::noMoreInput();
 
-  auto rowSize = data_->estimateRowSize();
+  updateEstimatedOutputRowSize();
+  outputBatchSize_ = outputBatchRows(estimatedOutputRowSize_);
+
+  if (spiller_ != nullptr) {
+    // Spill remaining data to avoid running out of memory while sort-merging
+    // spilled data.
+    spill();
+
+    VELOX_CHECK_NULL(merge_);
+    SpillPartitionSet spillPartitionSet;
+    spiller_->finishSpill(spillPartitionSet);
+    VELOX_CHECK_EQ(spillPartitionSet.size(), 1);
+    merge_ = spillPartitionSet.begin()->second->createOrderedReader(
+        spillConfig_->readBufferSize, pool(), &spillStats_);
+  } else {
+    outputRows_.resize(outputBatchSize_);
+  }
+}
+
+void TopNRowNumber::updateEstimatedOutputRowSize() {
+  const auto optionalRowSize = data_->estimateRowSize();
+  if (!optionalRowSize.has_value()) {
+    return;
+  }
+
+  auto rowSize = optionalRowSize.value();
+
   if (rowSize && generateRowNumber_) {
-    rowSize.value() += sizeof(int64_t);
+    rowSize += sizeof(int64_t);
   }
 
-  outputBatchSize_ = outputBatchRows(rowSize);
-  outputRows_.resize(outputBatchSize_);
+  if (!estimatedOutputRowSize_.has_value()) {
+    estimatedOutputRowSize_ = rowSize;
+  } else if (rowSize > estimatedOutputRowSize_.value()) {
+    estimatedOutputRowSize_ = rowSize;
+  }
 }
 
 TopNRowNumber::TopRows* TopNRowNumber::nextPartition() {
@@ -210,17 +372,56 @@ void TopNRowNumber::appendPartitionRows(
 }
 
 RowVectorPtr TopNRowNumber::getOutput() {
-  if (finished_ || !noMoreInput_) {
+  if (finished_) {
+    return nullptr;
+  }
+
+  if (abandonedPartial_) {
+    if (input_ != nullptr) {
+      auto output = std::move(input_);
+      input_.reset();
+      return output;
+    }
+
+    // We may have input accumulated in 'data_'.
+    if (data_->numRows() > 0) {
+      return getOutputFromMemory();
+    }
+
+    if (noMoreInput_) {
+      finished_ = true;
+    }
+
     return nullptr;
   }
 
+  if (!noMoreInput_) {
+    return nullptr;
+  }
+
+  RowVectorPtr output;
+  if (merge_ != nullptr) {
+    output = getOutputFromSpill();
+  } else {
+    output = getOutputFromMemory();
+  }
+
+  if (output == nullptr) {
+    finished_ = true;
+  }
+
+  return output;
+}
+
+RowVectorPtr TopNRowNumber::getOutputFromMemory() {
+  VELOX_CHECK_GT(outputBatchSize_, 0);
+
   // Loop over partitions and emit sorted rows along with row numbers.
   auto output =
       BaseVector::create<RowVector>(outputType_, outputBatchSize_, pool());
   FlatVector<int64_t>* rowNumbers = nullptr;
   if (generateRowNumber_) {
     rowNumbers = output->children().back()->as<FlatVector<int64_t>>();
-    rowNumbers->resize(outputBatchSize_);
   }
 
   vector_size_t offset = 0;
@@ -258,7 +459,11 @@ RowVectorPtr TopNRowNumber::getOutput() {
   }
 
   if (offset == 0) {
-    finished_ = true;
+    data_->clear();
+    if (table_ != nullptr) {
+      table_->clear();
+    }
+    pool()->release();
     return nullptr;
   }
 
@@ -267,18 +472,150 @@ RowVectorPtr TopNRowNumber::getOutput() {
   }
   output->resize(offset);
 
-  for (int i = 0; i < inputType_->size(); ++i) {
-    data_->extractColumn(outputRows_.data(), offset, i, output->childAt(i));
+  for (int i = 0; i < inputChannels_.size(); ++i) {
+    data_->extractColumn(
+        outputRows_.data(), offset, i, output->childAt(inputChannels_[i]));
   }
 
   return output;
 }
 
+bool TopNRowNumber::isNewPartition(
+    const RowVectorPtr& output,
+    vector_size_t index,
+    SpillMergeStream* next) {
+  VELOX_CHECK_GT(index, 0);
+
+  for (auto i = 0; i < numPartitionKeys_; ++i) {
+    if (!output->childAt(inputChannels_[i])
+             ->equalValueAt(
+                 next->current().childAt(i).get(),
+                 index - 1,
+                 next->currentIndex())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void TopNRowNumber::setupNextOutput(
+    const RowVectorPtr& output,
+    int32_t rowNumber) {
+  nextRowNumber_ = rowNumber;
+
+  auto lookAhead = merge_->next();
+  if (lookAhead == nullptr) {
+    nextRowNumber_ = 0;
+    return;
+  }
+
+  if (isNewPartition(output, output->size(), lookAhead)) {
+    nextRowNumber_ = 0;
+    return;
+  }
+
+  if (nextRowNumber_ < limit_) {
+    return;
+  }
+
+  // Skip remaining rows for this partition.
+  lookAhead->pop();
+
+  while (auto next = merge_->next()) {
+    if (isNewPartition(output, output->size(), next)) {
+      nextRowNumber_ = 0;
+      return;
+    }
+    next->pop();
+  }
+
+  // This partition is the last partition.
+  nextRowNumber_ = 0;
+}
+
+RowVectorPtr TopNRowNumber::getOutputFromSpill() {
+  VELOX_CHECK_NOT_NULL(merge_);
+
+  // merge_->next() produces data sorted by partition keys, then sorting keys.
+  // All rows from the same partition will appear together.
+  // We'll identify partition boundaries by comparing partition keys of the
+  // current row with the previous row. When new partition starts, we'll reset
+  // row number to zero. Once row number reaches the 'limit_', we'll start
+  // dropping rows until the next partition starts.
+  // We'll emit output every time we accumulate 'outputBatchSize_' rows.
+
+  auto output =
+      BaseVector::create<RowVector>(outputType_, outputBatchSize_, pool());
+  FlatVector<int64_t>* rowNumbers = nullptr;
+  if (generateRowNumber_) {
+    rowNumbers = output->children().back()->as<FlatVector<int64_t>>();
+  }
+
+  // Index of the next row to append to output.
+  vector_size_t index = 0;
+
+  // Row number of the next row in the current partition.
+  vector_size_t rowNumber = nextRowNumber_;
+  VELOX_CHECK_LT(rowNumber, limit_);
+  for (;;) {
+    auto next = merge_->next();
+    if (next == nullptr) {
+      break;
+    }
+
+    // Check if this row comes from a new partition.
+    if (index > 0 && isNewPartition(output, index, next)) {
+      rowNumber = 0;
+    }
+
+    if (rowNumber < limit_) {
+      for (auto i = 0; i < inputChannels_.size(); ++i) {
+        output->childAt(inputChannels_[i])
+            ->copy(
+                next->current().childAt(i).get(),
+                index,
+                next->currentIndex(),
+                1);
+      }
+      if (rowNumbers) {
+        // Row numbers start with 1.
+        rowNumbers->set(index, rowNumber + 1);
+      }
+      ++index;
+    } else {
+      // Drop the row.
+    }
+
+    ++rowNumber;
+    next->pop();
+
+    if (index == outputBatchSize_) {
+      // Check if next row is from a new partition. Reset 'nextRowNumber_' if
+      // so. Check if next row is from the current partition, but we have
+      // reached the 'limit_'. Skip to the start of the next partition if so.
+      setupNextOutput(output, rowNumber);
+
+      return output;
+    }
+  }
+
+  if (index > 0) {
+    output->resize(index);
+  } else {
+    output = nullptr;
+  }
+
+  finished_ = true;
+  return output;
+}
+
 bool TopNRowNumber::isFinished() {
   return finished_;
 }
 
 void TopNRowNumber::close() {
+  Operator::close();
+
   if (table_) {
     partitionIt_.reset();
     partitions_.resize(1000);
@@ -295,4 +632,120 @@ void TopNRowNumber::close() {
   }
 }
 
+void TopNRowNumber::reclaim(
+    uint64_t /*targetBytes*/,
+    memory::MemoryReclaimer::Stats& stats) {
+  VELOX_CHECK(canReclaim());
+  VELOX_CHECK(!nonReclaimableSection_);
+
+  if (data_->numRows() == 0) {
+    // Nothing to spill.
+    return;
+  }
+
+  if (noMoreInput_) {
+    ++stats.numNonReclaimableAttempts;
+    // TODO Add support for spilling after noMoreInput().
+    LOG(WARNING)
+        << "Can't reclaim from topNRowNumber operator which has started producing output: "
+        << pool()->name() << ", usage: " << succinctBytes(pool()->usedBytes())
+        << ", reservation: " << succinctBytes(pool()->reservedBytes());
+    return;
+  }
+
+  if (abandonedPartial_) {
+    return;
+  }
+
+  spill();
+}
+
+void TopNRowNumber::ensureInputFits(const RowVectorPtr& input) {
+  if (!spillEnabled()) {
+    // Spilling is disabled.
+    return;
+  }
+
+  if (data_->numRows() == 0) {
+    // Nothing to spill.
+    return;
+  }
+
+  // Test-only spill path.
+  if (testingTriggerSpill(pool()->name())) {
+    spill();
+    return;
+  }
+
+  auto [freeRows, outOfLineFreeBytes] = data_->freeSpace();
+  const auto outOfLineBytes =
+      data_->stringAllocator().retainedSize() - outOfLineFreeBytes;
+  const auto outOfLineBytesPerRow = outOfLineBytes / data_->numRows();
+
+  const auto currentUsage = pool()->usedBytes();
+  const auto minReservationBytes =
+      currentUsage * spillConfig_->minSpillableReservationPct / 100;
+  const auto availableReservationBytes = pool()->availableReservation();
+  const auto tableIncrementBytes = table_->hashTableSizeIncrease(input->size());
+  const auto incrementBytes =
+      data_->sizeIncrement(
+          input->size(), outOfLineBytesPerRow * input->size()) +
+      tableIncrementBytes;
+
+  // First to check if we have sufficient minimal memory reservation.
+  if (availableReservationBytes >= minReservationBytes) {
+    if ((tableIncrementBytes == 0) && (freeRows > input->size()) &&
+        (outOfLineBytes == 0 ||
+         outOfLineFreeBytes >= outOfLineBytesPerRow * input->size())) {
+      // Enough free rows for input rows and enough variable length free space.
+      return;
+    }
+  }
+
+  // Check if we can increase reservation. The increment is the largest of twice
+  // the maximum increment from this input and 'spillableReservationGrowthPct_'
+  // of the current memory usage.
+  const auto targetIncrementBytes = std::max<int64_t>(
+      incrementBytes * 2,
+      currentUsage * spillConfig_->spillableReservationGrowthPct / 100);
+  {
+    ReclaimableSectionGuard guard(this);
+    if (pool()->maybeReserve(targetIncrementBytes)) {
+      return;
+    }
+  }
+
+  LOG(WARNING) << "Failed to reserve " << succinctBytes(targetIncrementBytes)
+               << " for memory pool " << pool()->name()
+               << ", usage: " << succinctBytes(pool()->usedBytes())
+               << ", reservation: " << succinctBytes(pool()->reservedBytes());
+}
+
+void TopNRowNumber::spill() {
+  if (spiller_ == nullptr) {
+    setupSpiller();
+  }
+
+  updateEstimatedOutputRowSize();
+
+  spiller_->spill();
+  table_->clear();
+  data_->clear();
+  pool()->release();
+}
+
+void TopNRowNumber::setupSpiller() {
+  VELOX_CHECK_NULL(spiller_);
+  VELOX_CHECK(spillConfig_.has_value());
+
+  spiller_ = std::make_unique<Spiller>(
+      // TODO Replace Spiller::Type::kOrderBy.
+      Spiller::Type::kOrderByInput,
+      data_.get(),
+      inputType_,
+      spillCompareFlags_.size(),
+      spillCompareFlags_,
+      &spillConfig_.value(),
+      &spillStats_);
+}
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TopNRowNumber.h b/velox/exec/TopNRowNumber.h
index 2557a29072242..1136422a3afce 100644
--- a/velox/exec/TopNRowNumber.h
+++ b/velox/exec/TopNRowNumber.h
@@ -42,6 +42,12 @@ class TopNRowNumber : public Operator {
       const std::shared_ptr<const core::TopNRowNumberNode>& node);
 
   bool needsInput() const override {
+    if (abandonedPartial_ && (data_->numRows() > 0 || input_ != nullptr)) {
+      // This operator switched to a pass-through and needs to produce output
+      // before receiving more input.
+      return false;
+    }
+
     return true;
   }
 
@@ -59,8 +65,11 @@ class TopNRowNumber : public Operator {
 
   void close() override;
 
+  void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
+      override;
+
  private:
-  /// A priority queue to keep track of top 'limit' rows for a given partition.
+  // A priority queue to keep track of top 'limit' rows for a given partition.
   struct TopRows {
     struct Compare {
       RowComparator& comparator;
@@ -83,21 +92,18 @@ class TopNRowNumber : public Operator {
     return *reinterpret_cast<TopRows*>(group + partitionOffset_);
   }
 
-  /// Adds input row to a partition or discards the row.
-  void processInputRow(
-      const RowVectorPtr& input,
-      vector_size_t index,
-      TopRows& partition);
+  // Adds input row to a partition or discards the row.
+  void processInputRow(vector_size_t index, TopRows& partition);
 
-  /// Returns next partition to add to output or nullptr if there are no
-  /// partitions left.
+  // Returns next partition to add to output or nullptr if there are no
+  // partitions left.
   TopRows* nextPartition();
 
-  /// Returns partition that was partially added to the previous output batch.
+  // Returns partition that was partially added to the previous output batch.
   TopRows& currentPartition();
 
-  /// Appends partition rows to outputRows_ and optionally populates row
-  /// numbers.
+  // Appends partition rows to outputRows_ and optionally populates row
+  // numbers.
   void appendPartitionRows(
       TopRows& partition,
       vector_size_t start,
@@ -105,23 +111,88 @@ class TopNRowNumber : public Operator {
       vector_size_t outputOffset,
       FlatVector<int64_t>* rowNumbers);
 
+  bool spillEnabled() const {
+    return spillConfig_.has_value();
+  }
+
+  void ensureInputFits(const RowVectorPtr& input);
+
+  // Sorts, spills and clears all of 'data_'. Clears 'table_'.
+  void spill();
+
+  void setupSpiller();
+
+  RowVectorPtr getOutputFromSpill();
+
+  RowVectorPtr getOutputFromMemory();
+
+  // Returns true if 'next' row belongs to a different partition then index-1
+  // row of output.
+  bool isNewPartition(
+      const RowVectorPtr& output,
+      vector_size_t index,
+      SpillMergeStream* next);
+
+  // Sets nextRowNumber_ to rowNumber. Checks if next row in 'merge_' belongs to
+  // a different partition than last row in 'output' and if so updates
+  // nextRowNumber_ to 0. Also, checks current partition reached the limit on
+  // number of rows and if so advances 'merge_' to the first row on the next
+  // partition and sets nextRowNumber_ to 0.
+  //
+  // @post 'merge_->next()' is either at end or points to a row that should be
+  // included in the next output batch using 'nextRowNumber_'.
+  void setupNextOutput(const RowVectorPtr& output, int32_t rowNumber);
+
+  // Called in noMoreInput() and spill().
+  void updateEstimatedOutputRowSize();
+
+  // Return true if this operator runs a 'partial' stage and doesn't not reduce
+  // cardinality sufficiently. Returns false if spilling was triggered earlier.
+  bool abandonPartialEarly() const;
+
   const int32_t limit_;
   const bool generateRowNumber_;
+  const size_t numPartitionKeys_;
+
+  // Input columns in the order of: partition keys, sorting keys, the rest.
+  const std::vector<column_index_t> inputChannels_;
+
+  // Input column types in 'inputChannels_' order.
   const RowTypePtr inputType_;
 
-  /// Hash table to keep track of partitions. Not used if there are no
-  /// partitioning keys. For each partition, stores an instance of TopRows
-  /// struct.
+  // Compare flags for partition and sorting keys. Compare flags for partition
+  // keys are set to default values. Compare flags for sorting keys match
+  // sorting order specified in the plan node.
+  //
+  // Used to sort 'data_' while spilling.
+  const std::vector<CompareFlags> spillCompareFlags_;
+
+  const vector_size_t abandonPartialMinRows_;
+  const int32_t abandonPartialMinPct_;
+
+  // True if this operator runs a 'partial' stage without sufficient reduction
+  // in cardinality. In this case, it becomes a pass-through.
+  bool abandonedPartial_{false};
+
+  // Hash table to keep track of partitions. Not used if there are no
+  // partitioning keys. For each partition, stores an instance of TopRows
+  // struct.
   std::unique_ptr<BaseHashTable> table_;
   std::unique_ptr<HashLookup> lookup_;
   int32_t partitionOffset_;
 
-  /// TopRows struct to keep track of top rows for a single partition, when
-  /// there are no partitioning keys.
+  // TopRows struct to keep track of top rows for a single partition, when
+  // there are no partitioning keys.
   std::unique_ptr<HashStringAllocator> allocator_;
   std::unique_ptr<TopRows> singlePartition_;
 
-  /// Stores row data. For each partition, only up to 'limit' rows are stored.
+  // Stores input data. For each partition, only up to 'limit_' rows are stored.
+  // Order of columns matches 'inputChannels_': partition keys, sorting keys,
+  // the rest.
+  //
+  // Partition and sorting columns are specified as 'keys'. The rest of the
+  // columns are specified as 'dependents'. This enables sorting 'data_' using
+  // 'spillCompareFlags_' when spilling.
   std::unique_ptr<RowContainer> data_;
 
   RowComparator comparator_;
@@ -130,12 +201,17 @@ class TopNRowNumber : public Operator {
 
   bool finished_{false};
 
-  /// Maximum number of rows in the output batch.
+  // Size of a single output row estimated using 'data_->estimateRowSize()'.
+  // If spilling, this value is set to max 'data_->estimateRowSize()' across all
+  // accumulated 'data_'.
+  std::optional<int64_t> estimatedOutputRowSize_;
+
+  // Maximum number of rows in the output batch.
   vector_size_t outputBatchSize_;
   std::vector<char*> outputRows_;
 
-  /// Number of partitions to fetch from a HashTable in a single listAllRows
-  /// call.
+  // Number of partitions to fetch from a HashTable in a single listAllRows
+  // call.
   static const size_t kPartitionBatchSize = 100;
 
   BaseHashTable::RowsIterator partitionIt_;
@@ -143,5 +219,14 @@ class TopNRowNumber : public Operator {
   size_t numPartitions_{0};
   std::optional<int32_t> currentPartition_;
   vector_size_t remainingRowsInPartition_{0};
+
+  // Spiller for contents of the 'data_'.
+  std::unique_ptr<Spiller> spiller_;
+
+  // Used to sort-merge spilled data.
+  std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge_;
+
+  // Row number for the first row in the next output batch.
+  int32_t nextRowNumber_{0};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Unnest.cpp b/velox/exec/Unnest.cpp
index 71c0c84f9470d..7e3733044c2f0 100644
--- a/velox/exec/Unnest.cpp
+++ b/velox/exec/Unnest.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/exec/Unnest.h"
 #include "velox/common/base/Nulls.h"
-#include "velox/exec/OperatorUtils.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::exec {
@@ -35,7 +34,7 @@ Unnest::Unnest(
   const auto& unnestVariables = unnestNode->unnestVariables();
   for (const auto& variable : unnestVariables) {
     if (!variable->type()->isArray() && !variable->type()->isMap()) {
-      VELOX_UNSUPPORTED("Unnest operator supports only ARRAY and MAP types")
+      VELOX_UNSUPPORTED("Unnest operator supports only ARRAY and MAP types");
     }
     unnestChannels_.push_back(inputType->getChildIdx(variable->name()));
   }
@@ -46,7 +45,7 @@ Unnest::Unnest(
     VELOX_CHECK_EQ(
         outputType_->children().back(),
         BIGINT(),
-        "Ordinality column should be BIGINT type.")
+        "Ordinality column should be BIGINT type.");
   }
 
   column_index_t outputChannel = 0;
@@ -58,184 +57,255 @@ Unnest::Unnest(
 
 void Unnest::addInput(RowVectorPtr input) {
   input_ = std::move(input);
-}
 
-RowVectorPtr Unnest::getOutput() {
-  if (!input_) {
-    return nullptr;
+  for (auto& child : input_->children()) {
+    child->loadedVector();
   }
 
-  auto size = input_->size();
-  inputRows_.resize(size);
+  const auto size = input_->size();
 
   // The max number of elements at each row across all unnested columns.
-  auto maxSizes = AlignedBuffer::allocate<int64_t>(size, pool(), 0);
-  auto rawMaxSizes = maxSizes->asMutable<int64_t>();
+  maxSizes_ = allocateSizes(size, pool());
+  rawMaxSizes_ = maxSizes_->asMutable<vector_size_t>();
 
-  std::vector<const vector_size_t*> rawSizes;
-  std::vector<const vector_size_t*> rawOffsets;
-  std::vector<const vector_size_t*> rawIndices;
-
-  rawSizes.resize(unnestChannels_.size());
-  rawOffsets.resize(unnestChannels_.size());
-  rawIndices.resize(unnestChannels_.size());
+  rawSizes_.resize(unnestChannels_.size());
+  rawOffsets_.resize(unnestChannels_.size());
+  rawIndices_.resize(unnestChannels_.size());
 
   for (auto channel = 0; channel < unnestChannels_.size(); ++channel) {
     const auto& unnestVector = input_->childAt(unnestChannels_[channel]);
-    unnestDecoded_[channel].decode(*unnestVector, inputRows_);
 
     auto& currentDecoded = unnestDecoded_[channel];
-    rawIndices[channel] = currentDecoded.indices();
+    currentDecoded.decode(*unnestVector);
+
+    rawIndices_[channel] = currentDecoded.indices();
 
-    const ArrayVector* unnestBaseArray;
-    const MapVector* unnestBaseMap;
     if (unnestVector->typeKind() == TypeKind::ARRAY) {
-      unnestBaseArray = currentDecoded.base()->as<ArrayVector>();
-      rawSizes[channel] = unnestBaseArray->rawSizes();
-      rawOffsets[channel] = unnestBaseArray->rawOffsets();
+      const auto* unnestBaseArray = currentDecoded.base()->as<ArrayVector>();
+      rawSizes_[channel] = unnestBaseArray->rawSizes();
+      rawOffsets_[channel] = unnestBaseArray->rawOffsets();
     } else {
       VELOX_CHECK(unnestVector->typeKind() == TypeKind::MAP);
-      unnestBaseMap = currentDecoded.base()->as<MapVector>();
-      rawSizes[channel] = unnestBaseMap->rawSizes();
-      rawOffsets[channel] = unnestBaseMap->rawOffsets();
+      const auto* unnestBaseMap = currentDecoded.base()->as<MapVector>();
+      rawSizes_[channel] = unnestBaseMap->rawSizes();
+      rawOffsets_[channel] = unnestBaseMap->rawOffsets();
     }
 
     // Count max number of elements per row.
-    auto currentSizes = rawSizes[channel];
-    auto currentIndices = rawIndices[channel];
+    auto* currentSizes = rawSizes_[channel];
+    auto* currentIndices = rawIndices_[channel];
     for (auto row = 0; row < size; ++row) {
       if (!currentDecoded.isNullAt(row)) {
-        auto unnestSize = currentSizes[currentIndices[row]];
-        if (rawMaxSizes[row] < unnestSize) {
-          rawMaxSizes[row] = unnestSize;
+        const auto unnestSize = currentSizes[currentIndices[row]];
+        if (rawMaxSizes_[row] < unnestSize) {
+          rawMaxSizes_[row] = unnestSize;
         }
       }
     }
   }
+}
+
+RowVectorPtr Unnest::getOutput() {
+  if (!input_) {
+    return nullptr;
+  }
 
-  // Calculate the number of rows in the unnest result.
-  int numElements = 0;
-  for (auto row = 0; row < size; ++row) {
-    numElements += rawMaxSizes[row];
+  const auto size = input_->size();
+  const auto maxOutputSize = outputBatchRows();
+
+  // Limit the number of input rows to keep output batch size within
+  // 'maxOutputSize' if possible. Process each input row fully. Do not break
+  // single row's output into multiple batches.
+  vector_size_t numInput = 0;
+  vector_size_t numElements = 0;
+  for (auto row = nextInputRow_; row < size; ++row) {
+    numElements += rawMaxSizes_[row];
+    ++numInput;
+
+    if (numElements >= maxOutputSize) {
+      break;
+    }
   }
 
   if (numElements == 0) {
     // All arrays/maps are null or empty.
     input_ = nullptr;
+    nextInputRow_ = 0;
     return nullptr;
   }
 
+  auto output = generateOutput(nextInputRow_, numInput, numElements);
+
+  nextInputRow_ += numInput;
+
+  if (nextInputRow_ >= size) {
+    input_ = nullptr;
+    nextInputRow_ = 0;
+  }
+
+  return output;
+}
+
+void Unnest::generateRepeatedColumns(
+    vector_size_t start,
+    vector_size_t size,
+    vector_size_t numElements,
+    std::vector<VectorPtr>& outputs) {
   // Create "indices" buffer to repeat rows as many times as there are elements
   // in the array (or map) in unnestDecoded.
   auto repeatedIndices = allocateIndices(numElements, pool());
   auto* rawRepeatedIndices = repeatedIndices->asMutable<vector_size_t>();
   vector_size_t index = 0;
-  for (auto row = 0; row < size; ++row) {
-    for (auto i = 0; i < rawMaxSizes[row]; i++) {
+  for (auto row = start; row < start + size; ++row) {
+    for (auto i = 0; i < rawMaxSizes_[row]; i++) {
       rawRepeatedIndices[index++] = row;
     }
   }
 
   // Wrap "replicated" columns in a dictionary using 'repeatedIndices'.
-  std::vector<VectorPtr> outputs(outputType_->size());
   for (const auto& projection : identityProjections_) {
-    outputs[projection.outputChannel] = wrapChild(
-        numElements, repeatedIndices, input_->childAt(projection.inputChannel));
+    outputs.at(projection.outputChannel) = BaseVector::wrapInDictionary(
+        nullptr /*nulls*/,
+        repeatedIndices,
+        numElements,
+        input_->childAt(projection.inputChannel));
   }
+}
 
-  // Create unnest columns.
-  vector_size_t outputsIndex = identityProjections_.size();
-  for (auto channel = 0; channel < unnestChannels_.size(); ++channel) {
-    auto& currentDecoded = unnestDecoded_[channel];
-    auto currentSizes = rawSizes[channel];
-    auto currentOffsets = rawOffsets[channel];
-    auto currentIndices = rawIndices[channel];
+const Unnest::UnnestChannelEncoding Unnest::generateEncodingForChannel(
+    column_index_t channel,
+    vector_size_t start,
+    vector_size_t size,
+    vector_size_t numElements) {
+  BufferPtr elementIndices = allocateIndices(numElements, pool());
+  auto* rawElementIndices = elementIndices->asMutable<vector_size_t>();
 
-    BufferPtr elementIndices = allocateIndices(numElements, pool());
-    auto* rawElementIndices = elementIndices->asMutable<vector_size_t>();
+  auto nulls = allocateNulls(numElements, pool());
+  auto rawNulls = nulls->asMutable<uint64_t>();
 
-    auto nulls =
-        AlignedBuffer::allocate<bool>(numElements, pool(), bits::kNotNull);
-    auto rawNulls = nulls->asMutable<uint64_t>();
+  auto& currentDecoded = unnestDecoded_[channel];
+  auto* currentSizes = rawSizes_[channel];
+  auto* currentOffsets = rawOffsets_[channel];
+  auto* currentIndices = rawIndices_[channel];
 
-    // Make dictionary index for elements column since they may be out of order.
-    index = 0;
-    bool identityMapping = true;
-    for (auto row = 0; row < size; ++row) {
-      auto maxSize = rawMaxSizes[row];
+  // Make dictionary index for elements column since they may be out of order.
+  vector_size_t index = 0;
+  bool identityMapping = true;
+  for (auto row = start; row < start + size; ++row) {
+    const auto maxSize = rawMaxSizes_[row];
 
-      if (!currentDecoded.isNullAt(row)) {
-        auto offset = currentOffsets[currentIndices[row]];
-        auto unnestSize = currentSizes[currentIndices[row]];
+    if (!currentDecoded.isNullAt(row)) {
+      const auto offset = currentOffsets[currentIndices[row]];
+      const auto unnestSize = currentSizes[currentIndices[row]];
 
-        if (index != offset || unnestSize < maxSize) {
-          identityMapping = false;
-        }
+      if (index != offset || unnestSize < maxSize) {
+        identityMapping = false;
+      }
 
-        for (auto i = 0; i < unnestSize; i++) {
-          rawElementIndices[index++] = offset + i;
-        }
+      for (auto i = 0; i < unnestSize; i++) {
+        rawElementIndices[index++] = offset + i;
+      }
 
-        for (auto i = unnestSize; i < maxSize; ++i) {
-          bits::setNull(rawNulls, index++, true);
-        }
-      } else if (maxSize > 0) {
-        identityMapping = false;
+      for (auto i = unnestSize; i < maxSize; ++i) {
+        bits::setNull(rawNulls, index++, true);
+      }
+    } else if (maxSize > 0) {
+      identityMapping = false;
 
-        for (auto i = 0; i < maxSize; ++i) {
-          bits::setNull(rawNulls, index++, true);
-        }
+      for (auto i = 0; i < maxSize; ++i) {
+        bits::setNull(rawNulls, index++, true);
       }
     }
+  }
+  return {elementIndices, nulls, identityMapping};
+}
+
+VectorPtr Unnest::generateOrdinalityVector(
+    vector_size_t start,
+    vector_size_t size,
+    vector_size_t numElements) {
+  auto ordinalityVector =
+      BaseVector::create<FlatVector<int64_t>>(BIGINT(), numElements, pool());
+
+  // Set the ordinality at each result row to be the index of the element in
+  // the original array (or map) plus one.
+  auto* rawOrdinality = ordinalityVector->mutableRawValues();
+  for (auto row = start; row < start + size; ++row) {
+    const auto maxSize = rawMaxSizes_[row];
+    std::iota(rawOrdinality, rawOrdinality + maxSize, 1);
+    rawOrdinality += maxSize;
+  }
+
+  return ordinalityVector;
+}
 
+RowVectorPtr Unnest::generateOutput(
+    vector_size_t start,
+    vector_size_t size,
+    vector_size_t numElements) {
+  std::vector<VectorPtr> outputs(outputType_->size());
+  generateRepeatedColumns(start, size, numElements, outputs);
+
+  // Create unnest columns.
+  vector_size_t outputsIndex = identityProjections_.size();
+  for (auto channel = 0; channel < unnestChannels_.size(); ++channel) {
+    const auto unnestChannelEncoding =
+        generateEncodingForChannel(channel, start, size, numElements);
+
+    auto& currentDecoded = unnestDecoded_[channel];
     if (currentDecoded.base()->typeKind() == TypeKind::ARRAY) {
       // Construct unnest column using Array elements wrapped using above
       // created dictionary.
-      auto unnestBaseArray = currentDecoded.base()->as<ArrayVector>();
-      outputs[outputsIndex++] = identityMapping
-          ? unnestBaseArray->elements()
-          : wrapChild(
-                numElements,
-                elementIndices,
-                unnestBaseArray->elements(),
-                nulls);
+      const auto* unnestBaseArray = currentDecoded.base()->as<ArrayVector>();
+      outputs[outputsIndex++] =
+          unnestChannelEncoding.wrap(unnestBaseArray->elements(), numElements);
     } else {
       // Construct two unnest columns for Map keys and values vectors wrapped
       // using above created dictionary.
-      auto unnestBaseMap = currentDecoded.base()->as<MapVector>();
-      outputs[outputsIndex++] = identityMapping
-          ? unnestBaseMap->mapKeys()
-          : wrapChild(
-                numElements, elementIndices, unnestBaseMap->mapKeys(), nulls);
-      outputs[outputsIndex++] = identityMapping
-          ? unnestBaseMap->mapValues()
-          : wrapChild(
-                numElements, elementIndices, unnestBaseMap->mapValues(), nulls);
+      const auto* unnestBaseMap = currentDecoded.base()->as<MapVector>();
+      outputs[outputsIndex++] =
+          unnestChannelEncoding.wrap(unnestBaseMap->mapKeys(), numElements);
+      outputs[outputsIndex++] =
+          unnestChannelEncoding.wrap(unnestBaseMap->mapValues(), numElements);
     }
   }
 
   if (withOrdinality_) {
-    auto ordinalityVector = std::dynamic_pointer_cast<FlatVector<int64_t>>(
-        BaseVector::create(BIGINT(), numElements, pool()));
-
-    // Set the ordinality at each result row to be the index of the element in
-    // the original array (or map) plus one.
-    auto rawOrdinality = ordinalityVector->mutableRawValues();
-    for (auto row = 0; row < size; ++row) {
-      auto maxSize = rawMaxSizes[row];
-      std::iota(rawOrdinality, rawOrdinality + maxSize, 1);
-      rawOrdinality += maxSize;
-    }
-
     // Ordinality column is always at the end.
-    outputs.back() = std::move(ordinalityVector);
+    outputs.back() = generateOrdinalityVector(start, size, numElements);
   }
 
-  input_ = nullptr;
   return std::make_shared<RowVector>(
       pool(), outputType_, BufferPtr(nullptr), numElements, std::move(outputs));
 }
 
+VectorPtr Unnest::UnnestChannelEncoding::wrap(
+    const VectorPtr& base,
+    vector_size_t wrapSize) const {
+  if (identityMapping) {
+    return base;
+  }
+
+  const auto result =
+      BaseVector::wrapInDictionary(nulls, indices, wrapSize, base);
+
+  // Dictionary vectors whose size is much smaller than the size of the
+  // 'alphabet' (base vector) create efficiency problems downstream. For
+  // example, expression evaluation may peel the dictionary encoding and
+  // evaluate the expression on the base vector. If a dictionary references
+  // 1K rows of the base vector with row numbers 1'000'000...1'000'999, the
+  // expression needs to allocate a result vector of size 1'001'000. This
+  // causes large number of large allocations and wastes a lot of
+  // resources.
+  //
+  // Make a flat copy of the necessary rows to avoid inefficient downstream
+  // processing.
+  //
+  // TODO A better fix might be to change expression evaluation (and all other
+  // operations) to handle dictionaries with large alphabets efficiently.
+  return BaseVector::copy(*result);
+}
+
 bool Unnest::isFinished() {
   return noMoreInput_ && input_ == nullptr;
 }
diff --git a/velox/exec/Unnest.h b/velox/exec/Unnest.h
index a62eefe21e54b..f1ae04e1137af 100644
--- a/velox/exec/Unnest.h
+++ b/velox/exec/Unnest.h
@@ -29,7 +29,7 @@ class Unnest : public Operator {
   }
 
   bool needsInput() const override {
-    return true;
+    return input_ == nullptr;
   }
 
   void addInput(RowVectorPtr input) override;
@@ -39,11 +39,59 @@ class Unnest : public Operator {
   bool isFinished() override;
 
  private:
+  // Generate output for 'size' input rows starting from 'start' input row.
+  //
+  // @param start First input row to include in the output.
+  // @param size Number of input rows to include in the output.
+  // @param outputSize Pre-computed number of output rows.
+  RowVectorPtr generateOutput(
+      vector_size_t start,
+      vector_size_t size,
+      vector_size_t outputSize);
+
+  // Invoked by generateOutput function above to generate the repeated output
+  // columns.
+  void generateRepeatedColumns(
+      vector_size_t start,
+      vector_size_t size,
+      vector_size_t numElements,
+      std::vector<VectorPtr>& outputs);
+
+  struct UnnestChannelEncoding {
+    BufferPtr indices;
+    BufferPtr nulls;
+    bool identityMapping;
+
+    VectorPtr wrap(const VectorPtr& base, vector_size_t wrapSize) const;
+  };
+
+  // Invoked by generateOutput above to generate the encoding for the unnested
+  // Array or Map.
+  const UnnestChannelEncoding generateEncodingForChannel(
+      column_index_t channel,
+      vector_size_t start,
+      vector_size_t size,
+      vector_size_t numElements);
+
+  // Invoked by generateOutput for the ordinality column.
+  VectorPtr generateOrdinalityVector(
+      vector_size_t start,
+      vector_size_t size,
+      vector_size_t numElements);
+
+  const bool withOrdinality_;
   std::vector<column_index_t> unnestChannels_;
 
-  SelectivityVector inputRows_;
   std::vector<DecodedVector> unnestDecoded_;
 
-  const bool withOrdinality_;
+  BufferPtr maxSizes_;
+  vector_size_t* rawMaxSizes_{nullptr};
+
+  std::vector<const vector_size_t*> rawSizes_;
+  std::vector<const vector_size_t*> rawOffsets_;
+  std::vector<const vector_size_t*> rawIndices_;
+
+  // Next 'input_' row to process in getOutput().
+  vector_size_t nextInputRow_{0};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Values.cpp b/velox/exec/Values.cpp
index aeb377dbe8565..6cd8b80fabc41 100644
--- a/velox/exec/Values.cpp
+++ b/velox/exec/Values.cpp
@@ -30,15 +30,31 @@ Values::Values(
           operatorId,
           values->id(),
           "Values"),
-      roundsLeft_(values->repeatTimes()) {
+      valueNodes_(std::move(values)),
+      roundsLeft_(valueNodes_->repeatTimes()) {}
+
+void Values::initialize() {
+  Operator::initialize();
+  VELOX_CHECK_NOT_NULL(valueNodes_);
+  VELOX_CHECK(values_.empty());
   // Drop empty vectors. Operator::getOutput is expected to return nullptr or a
   // non-empty vector.
-  values_.reserve(values->values().size());
-  for (auto& vector : values->values()) {
+  values_.reserve(valueNodes_->values().size());
+  for (auto& vector : valueNodes_->values()) {
     if (vector->size() > 0) {
-      values_.emplace_back(vector);
+      if (valueNodes_->isParallelizable()) {
+        // If this is parallelizable, copy the values to prevent Vectors from
+        // being shared across threads.  Note that the contract in ValuesNode is
+        // that this should only be enabled for testing.
+        values_.emplace_back(std::static_pointer_cast<RowVector>(
+            vector->copyPreserveEncodings()));
+      } else {
+        values_.emplace_back(vector);
+      }
     }
   }
+  // Drop the reference on the value nodes.
+  valueNodes_ = nullptr;
 }
 
 RowVectorPtr Values::getOutput() {
diff --git a/velox/exec/Values.h b/velox/exec/Values.h
index ab24b68496bc2..2cc0998537b2e 100644
--- a/velox/exec/Values.h
+++ b/velox/exec/Values.h
@@ -25,6 +25,8 @@ class Values : public SourceOperator {
       DriverCtx* driverCtx,
       std::shared_ptr<const core::ValuesNode> values);
 
+  void initialize() override;
+
   RowVectorPtr getOutput() override;
 
   BlockingReason isBlocked(ContinueFuture* /* unused */) override {
@@ -55,6 +57,7 @@ class Values : public SourceOperator {
   }
 
  private:
+  std::shared_ptr<const core::ValuesNode> valueNodes_;
   std::vector<RowVectorPtr> values_;
   int32_t current_ = 0;
   size_t roundsLeft_ = 1;
diff --git a/velox/exec/VectorHasher.cpp b/velox/exec/VectorHasher.cpp
index 9e296e4610e05..ed16155c18e68 100644
--- a/velox/exec/VectorHasher.cpp
+++ b/velox/exec/VectorHasher.cpp
@@ -19,6 +19,7 @@
 #include "velox/common/base/Portability.h"
 #include "velox/common/base/SimdUtil.h"
 #include "velox/common/memory/HashStringAllocator.h"
+#include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::exec {
 
@@ -53,14 +54,19 @@ namespace facebook::velox::exec {
 namespace {
 template <TypeKind Kind>
 uint64_t hashOne(DecodedVector& decoded, vector_size_t index) {
-  if (Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
+  if constexpr (
+      Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
       Kind == TypeKind::MAP) {
     // Virtual function call for complex type.
     return decoded.base()->hashValueAt(decoded.index(index));
   }
   // Inlined for scalars.
   using T = typename KindToFlatVector<Kind>::HashRowType;
-  return folly::hasher<T>()(decoded.valueAt<T>(index));
+  if constexpr (std::is_floating_point_v<T>) {
+    return util::floating_point::NaNAwareHash<T>()(decoded.valueAt<T>(index));
+  } else {
+    return folly::hasher<T>()(decoded.valueAt<T>(index));
+  }
 }
 } // namespace
 
@@ -77,16 +83,9 @@ void VectorHasher::hashValues(
     rows.applyToSelected([&](vector_size_t row) {
       result[row] = mix ? bits::hashMix(result[row], hash) : hash;
     });
-  } else if (decoded_.isIdentityMapping()) {
-    rows.applyToSelected([&](vector_size_t row) {
-      if (decoded_.isNullAt(row)) {
-        result[row] = mix ? bits::hashMix(result[row], kNullHash) : kNullHash;
-        return;
-      }
-      auto hash = hashOne<Kind>(decoded_, row);
-      result[row] = mix ? bits::hashMix(result[row], hash) : hash;
-    });
-  } else {
+  } else if (
+      !decoded_.isIdentityMapping() &&
+      rows.countSelected() > decoded_.base()->size()) {
     cachedHashes_.resize(decoded_.base()->size());
     std::fill(cachedHashes_.begin(), cachedHashes_.end(), kNullHash);
     rows.applyToSelected([&](vector_size_t row) {
@@ -102,6 +101,15 @@ void VectorHasher::hashValues(
       }
       result[row] = mix ? bits::hashMix(result[row], hash) : hash;
     });
+  } else {
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decoded_.isNullAt(row)) {
+        result[row] = mix ? bits::hashMix(result[row], kNullHash) : kNullHash;
+        return;
+      }
+      auto hash = hashOne<Kind>(decoded_, row);
+      result[row] = mix ? bits::hashMix(result[row], hash) : hash;
+    });
   }
 }
 
@@ -158,7 +166,7 @@ bool VectorHasher::makeValueIdsFlatWithNulls<bool>(
     const SelectivityVector& rows,
     uint64_t* result) {
   const auto* values = decoded_.data<uint64_t>();
-  const auto* nulls = decoded_.nulls();
+  const auto* nulls = decoded_.nulls(&rows);
   rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
     if (bits::isBitNull(nulls, row)) {
       if (multiplier_ == 1) {
@@ -173,6 +181,36 @@ bool VectorHasher::makeValueIdsFlatWithNulls<bool>(
   return true;
 }
 
+template <typename T, bool mayHaveNulls>
+void VectorHasher::makeValueIdForOneRow(
+    const uint64_t* nulls,
+    vector_size_t row,
+    const T* values,
+    vector_size_t valueRow,
+    uint64_t* result,
+    bool& success) {
+  if constexpr (mayHaveNulls) {
+    if (bits::isBitNull(nulls, row)) {
+      if (multiplier_ == 1) {
+        result[row] = 0;
+      }
+      return;
+    }
+  }
+  T value = values[valueRow];
+  if (!success) {
+    analyzeValue(value);
+    return;
+  }
+  auto id = valueId(value);
+  if (id == kUnmappable) {
+    success = false;
+    analyzeValue(value);
+  } else {
+    result[row] = multiplier_ == 1 ? id : result[row] + multiplier_ * id;
+  }
+}
+
 template <typename T>
 bool VectorHasher::makeValueIdsFlatNoNulls(
     const SelectivityVector& rows,
@@ -184,20 +222,7 @@ bool VectorHasher::makeValueIdsFlatNoNulls(
 
   bool success = true;
   rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
-    T value = values[row];
-    if (!success) {
-      // If all were not mappable and we do not remove unmappable,
-      // we just analyze the remaining so we can decide the hash mode.
-      analyzeValue(value);
-      return;
-    }
-    uint64_t id = valueId(value);
-    if (id == kUnmappable) {
-      success = false;
-      analyzeValue(value);
-      return;
-    }
-    result[row] = multiplier_ == 1 ? id : result[row] + multiplier_ * id;
+    makeValueIdForOneRow<T, false>(nullptr, row, values, row, result, success);
   });
 
   return success;
@@ -208,30 +233,11 @@ bool VectorHasher::makeValueIdsFlatWithNulls(
     const SelectivityVector& rows,
     uint64_t* result) {
   const auto* values = decoded_.data<T>();
-  const auto* nulls = decoded_.nulls();
+  const auto* nulls = decoded_.nulls(&rows);
 
   bool success = true;
   rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
-    if (bits::isBitNull(nulls, row)) {
-      if (multiplier_ == 1) {
-        result[row] = 0;
-      }
-      return;
-    }
-    T value = values[row];
-    if (!success) {
-      // If all were not mappable we just analyze the remaining so we can decide
-      // the hash mode.
-      analyzeValue(value);
-      return;
-    }
-    uint64_t id = valueId(value);
-    if (id == kUnmappable) {
-      success = false;
-      analyzeValue(value);
-      return;
-    }
-    result[row] = multiplier_ == 1 ? id : result[row] + multiplier_ * id;
+    makeValueIdForOneRow<T, true>(nulls, row, values, row, result, success);
   });
   return success;
 }
@@ -240,13 +246,23 @@ template <typename T, bool mayHaveNulls>
 bool VectorHasher::makeValueIdsDecoded(
     const SelectivityVector& rows,
     uint64_t* result) {
-  cachedHashes_.resize(decoded_.base()->size());
-  std::fill(cachedHashes_.begin(), cachedHashes_.end(), 0);
-
   auto indices = decoded_.indices();
   auto values = decoded_.data<T>();
-
   bool success = true;
+
+  if (rows.countSelected() <= decoded_.base()->size()) {
+    // Cache is not beneficial in this case and we don't use them.
+    auto* nulls = decoded_.nulls(&rows);
+    rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
+      makeValueIdForOneRow<T, mayHaveNulls>(
+          nulls, row, values, indices[row], result, success);
+    });
+    return success;
+  }
+
+  cachedHashes_.resize(decoded_.base()->size());
+  std::fill(cachedHashes_.begin(), cachedHashes_.end(), 0);
+
   int numCachedHashes = 0;
   rows.testSelected([&](vector_size_t row) INLINE_LAMBDA {
     if constexpr (mayHaveNulls) {
@@ -378,8 +394,7 @@ void VectorHasher::lookupValueIdsTyped(
     const DecodedVector& decoded,
     SelectivityVector& rows,
     raw_vector<uint64_t>& hashes,
-    uint64_t* result,
-    bool noNulls) const {
+    uint64_t* result) const {
   using T = typename TypeTraits<Kind>::NativeType;
   if (decoded.isConstantMapping()) {
     if (decoded.isNullAt(rows.begin())) {
@@ -399,9 +414,9 @@ void VectorHasher::lookupValueIdsTyped(
       });
     }
   } else if (decoded.isIdentityMapping()) {
-    if (Kind == TypeKind::BIGINT && isRange_ && noNulls) {
+    if (Kind == TypeKind::BIGINT && isRange_) {
       lookupIdsRangeSimd<int64_t>(decoded, rows, result);
-    } else if (Kind == TypeKind::INTEGER && isRange_ && noNulls) {
+    } else if (Kind == TypeKind::INTEGER && isRange_) {
       lookupIdsRangeSimd<int32_t>(decoded, rows, result);
     } else {
       rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
@@ -508,8 +523,7 @@ void VectorHasher::lookupValueIds(
     const BaseVector& values,
     SelectivityVector& rows,
     ScratchMemory& scratchMemory,
-    raw_vector<uint64_t>& result,
-    bool noNulls) const {
+    raw_vector<uint64_t>& result) const {
   scratchMemory.decoded.decode(values, rows);
   VALUE_ID_TYPE_DISPATCH(
       lookupValueIdsTyped,
@@ -517,8 +531,7 @@ void VectorHasher::lookupValueIds(
       scratchMemory.decoded,
       rows,
       scratchMemory.hashes,
-      result.data(),
-      noNulls);
+      result.data());
 }
 
 void VectorHasher::hash(
@@ -850,10 +863,14 @@ void VectorHasher::merge(const VectorHasher& other) {
 
 std::string VectorHasher::toString() const {
   std::stringstream out;
-  out << "<VectorHasher type=" << type_->toString() << "  isRange_=" << isRange_
-      << " rangeSize= " << rangeSize_ << " min=" << min_ << " max=" << max_
-      << " multiplier=" << multiplier_
-      << " numDistinct=" << uniqueValues_.size() << ">";
+  out << "VectorHasher channel: " << channel_ << " " << type_->toString()
+      << " multiplier: " << multiplier_;
+  if (isRange_) {
+    out << " range size " << rangeSize_ << ": [" << min_ << ", " << max_ << "]";
+  }
+  if (!distinctOverflow_) {
+    out << " numDistinct: " << uniqueValues_.size();
+  }
   return out.str();
 }
 
diff --git a/velox/exec/VectorHasher.h b/velox/exec/VectorHasher.h
index 1dd6bdd283320..339f6deee64c8 100644
--- a/velox/exec/VectorHasher.h
+++ b/velox/exec/VectorHasher.h
@@ -227,14 +227,13 @@ class VectorHasher {
   // have a miss if any of the keys has a value that is not represented.
   //
   // This method can be called concurrently from multiple threads. To allow for
-  // that the caller must provide 'scratchMemory'. 'noNulls' means that the
-  // positions in 'rows' are not checked for null values.
+  // that the caller must provide 'scratchMemory'. Values in 'rows' are
+  // expected to have no nulls.
   void lookupValueIds(
       const BaseVector& values,
       SelectivityVector& rows,
       ScratchMemory& scratchMemory,
-      raw_vector<uint64_t>& result,
-      bool noNulls = true) const;
+      raw_vector<uint64_t>& result) const;
 
   // Returns true if either range or distinct values have not overflowed.
   bool mayUseValueIds() const {
@@ -339,6 +338,15 @@ class VectorHasher {
   template <TypeKind Kind>
   bool makeValueIds(const SelectivityVector& rows, uint64_t* result);
 
+  template <typename T, bool mayHaveNulls>
+  FOLLY_ALWAYS_INLINE void makeValueIdForOneRow(
+      const uint64_t* nulls,
+      vector_size_t row,
+      const T* values,
+      vector_size_t valueRow,
+      uint64_t* result,
+      bool& success);
+
   template <typename T>
   bool makeValueIdsFlatNoNulls(const SelectivityVector& rows, uint64_t* result);
 
@@ -381,8 +389,7 @@ class VectorHasher {
       const DecodedVector& decoded,
       SelectivityVector& rows,
       raw_vector<uint64_t>& hashes,
-      uint64_t* result,
-      bool noNulls) const;
+      uint64_t* result) const;
 
   // Fast path for range mapping of int64/int32 keys.
   template <typename T>
diff --git a/velox/exec/Window.cpp b/velox/exec/Window.cpp
index 32014218fb1a0..6f60f9fcf5e39 100644
--- a/velox/exec/Window.cpp
+++ b/velox/exec/Window.cpp
@@ -15,8 +15,9 @@
  */
 #include "velox/exec/Window.h"
 #include "velox/exec/OperatorUtils.h"
+#include "velox/exec/PartitionStreamingWindowBuild.h"
+#include "velox/exec/RowsStreamingWindowBuild.h"
 #include "velox/exec/SortWindowBuild.h"
-#include "velox/exec/StreamingWindowBuild.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
@@ -30,15 +31,27 @@ Window::Window(
           windowNode->outputType(),
           operatorId,
           windowNode->id(),
-          "Window"),
-      numInputColumns_(windowNode->sources()[0]->outputType()->size()),
+          "Window",
+          windowNode->canSpill(driverCtx->queryConfig())
+              ? driverCtx->makeSpillConfig(operatorId)
+              : std::nullopt),
+      numInputColumns_(windowNode->inputType()->size()),
       windowNode_(windowNode),
       currentPartition_(nullptr),
       stringAllocator_(pool()) {
+  auto* spillConfig =
+      spillConfig_.has_value() ? &spillConfig_.value() : nullptr;
   if (windowNode->inputsSorted()) {
-    windowBuild_ = std::make_unique<StreamingWindowBuild>(windowNode, pool());
+    if (supportRowsStreaming()) {
+      windowBuild_ = std::make_unique<RowsStreamingWindowBuild>(
+          windowNode_, pool(), spillConfig, &nonReclaimableSection_);
+    } else {
+      windowBuild_ = std::make_unique<PartitionStreamingWindowBuild>(
+          windowNode, pool(), spillConfig, &nonReclaimableSection_);
+    }
   } else {
-    windowBuild_ = std::make_unique<SortWindowBuild>(windowNode, pool());
+    windowBuild_ = std::make_unique<SortWindowBuild>(
+        windowNode, pool(), spillConfig, &nonReclaimableSection_, &spillStats_);
   }
 }
 
@@ -47,24 +60,73 @@ void Window::initialize() {
   VELOX_CHECK_NOT_NULL(windowNode_);
   createWindowFunctions();
   createPeerAndFrameBuffers();
+  windowBuild_->setNumRowsPerOutput(numRowsPerOutput_);
   windowNode_.reset();
 }
 
+namespace {
+void checkRowFrameBounds(const core::WindowNode::Frame& frame) {
+  auto frameBoundCheck = [&](const core::TypedExprPtr& frameValue) -> void {
+    if (frameValue == nullptr) {
+      return;
+    }
+
+    VELOX_USER_CHECK(
+        frameValue->type() == INTEGER() || frameValue->type() == BIGINT(),
+        "k frame bound must be INTEGER or BIGINT type");
+  };
+  frameBoundCheck(frame.startValue);
+  frameBoundCheck(frame.endValue);
+}
+
+void checkKRangeFrameBounds(
+    const std::shared_ptr<const core::WindowNode>& windowNode,
+    const core::WindowNode::Frame& frame,
+    const RowTypePtr& inputType) {
+  // For k Range frame bound:
+  // i) The order by needs to be a single column for bound comparisons
+  // (Checked in WindowNode constructor).
+  // ii) The bounds values are pre-computed in the start(end)Value bound
+  // fields. So, start(end)Value bounds cannot be constants.
+  // iii) The frame bound column and the ORDER BY column must have
+  // the same type for correct comparisons.
+  const auto& orderByType = windowNode->sortingKeys()[0]->type();
+  const auto frameBoundCheck =
+      [&](const core::TypedExprPtr& frameValue) -> void {
+    if (frameValue == nullptr) {
+      return;
+    }
+
+    auto frameChannel = exprToChannel(frameValue.get(), inputType);
+    VELOX_USER_CHECK_NE(
+        frameChannel,
+        kConstantChannel,
+        "Window frame of type RANGE does not support constant arguments");
+
+    auto frameType = inputType->childAt(frameChannel);
+    VELOX_USER_CHECK(
+        *frameType == *orderByType,
+        "Window frame of type RANGE does not match types of the ORDER BY"
+        " and frame column");
+  };
+
+  frameBoundCheck(frame.startValue);
+  frameBoundCheck(frame.endValue);
+}
+
+} // namespace
+
 Window::WindowFrame Window::createWindowFrame(
-    core::WindowNode::Frame frame,
+    const std::shared_ptr<const core::WindowNode>& windowNode,
+    const core::WindowNode::Frame& frame,
     const RowTypePtr& inputType) {
   if (frame.type == core::WindowNode::WindowType::kRows) {
-    auto frameBoundCheck = [&](const core::TypedExprPtr& frame) -> void {
-      if (frame == nullptr) {
-        return;
-      }
+    checkRowFrameBounds(frame);
+  }
 
-      VELOX_USER_CHECK(
-          frame->type() == INTEGER() || frame->type() == BIGINT(),
-          "k frame bound must be INTEGER or BIGINT type");
-    };
-    frameBoundCheck(frame.startValue);
-    frameBoundCheck(frame.endValue);
+  if (frame.type == core::WindowNode::WindowType::kRange &&
+      (frame.startValue || frame.endValue)) {
+    checkKRangeFrameBounds(windowNode, frame, inputType);
   }
 
   auto createFrameChannelArg =
@@ -75,9 +137,7 @@ Window::WindowFrame Window::createWindowFrame(
     }
     auto frameChannel = exprToChannel(frame.get(), inputType);
     if (frameChannel == kConstantChannel) {
-      auto constant =
-          std::dynamic_pointer_cast<const core::ConstantTypedExpr>(frame)
-              ->value();
+      auto constant = core::TypedExprs::asConstant(frame)->value();
       VELOX_CHECK(!constant.isNull(), "Window frame offset must not be null");
       auto value = VariantConverter::convert(constant, TypeKind::BIGINT)
                        .value<int64_t>();
@@ -93,12 +153,14 @@ Window::WindowFrame Window::createWindowFrame(
     }
   };
 
+  auto startFrameArg = createFrameChannelArg(frame.startValue);
+  auto endFrameArg = createFrameChannelArg(frame.endValue);
   return WindowFrame(
       {frame.type,
        frame.startType,
        frame.endType,
-       createFrameChannelArg(frame.startValue),
-       createFrameChannelArg(frame.endValue)});
+       std::move(startFrameArg),
+       std::move(endFrameArg)});
 }
 
 void Window::createWindowFunctions() {
@@ -111,10 +173,9 @@ void Window::createWindowFunctions() {
     std::vector<WindowFunctionArg> functionArgs;
     functionArgs.reserve(windowNodeFunction.functionCall->inputs().size());
     for (auto& arg : windowNodeFunction.functionCall->inputs()) {
-      auto channel = exprToChannel(arg.get(), inputType);
+      const auto channel = exprToChannel(arg.get(), inputType);
       if (channel == kConstantChannel) {
-        auto constantArg =
-            std::dynamic_pointer_cast<const core::ConstantTypedExpr>(arg);
+        const auto constantArg = core::TypedExprs::asConstant(arg);
         functionArgs.push_back(
             {arg->type(), constantArg->toConstantVector(pool()), std::nullopt});
       } else {
@@ -132,15 +193,59 @@ void Window::createWindowFunctions() {
         operatorCtx_->driverCtx()->queryConfig()));
 
     windowFrames_.push_back(
-        createWindowFrame(windowNodeFunction.frame, inputType));
+        createWindowFrame(windowNode_, windowNodeFunction.frame, inputType));
   }
 }
 
+bool Window::supportRowsStreaming() {
+  for (const auto& windowFunction : windowNode_->windowFunctions()) {
+    const auto& functionName = windowFunction.functionCall->name();
+    const auto windowFunctionMetadata =
+        exec::getWindowFunctionMetadata(functionName);
+
+    if (windowFunctionMetadata.processMode !=
+        exec::WindowFunction::ProcessMode::kRows) {
+      return false;
+    }
+
+    const auto& frame = windowFunction.frame;
+    // The default frame spans from the start of the partition to current row.
+    const bool isDefaultFrame =
+        (frame.startType == core::WindowNode::BoundType::kUnboundedPreceding &&
+         frame.endType == core::WindowNode::BoundType::kCurrentRow);
+
+    if (windowFunctionMetadata.isAggregate && !isDefaultFrame) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 void Window::addInput(RowVectorPtr input) {
   windowBuild_->addInput(input);
   numRows_ += input->size();
 }
 
+void Window::reclaim(
+    uint64_t targetBytes,
+    memory::MemoryReclaimer::Stats& stats) {
+  VELOX_CHECK(canReclaim());
+  VELOX_CHECK(!nonReclaimableSection_);
+
+  if (noMoreInput_) {
+    ++stats.numNonReclaimableAttempts;
+    // TODO Add support for spilling after noMoreInput().
+    LOG(WARNING)
+        << "Can't reclaim from window operator which has started producing output: "
+        << pool()->name() << ", usage: " << succinctBytes(pool()->usedBytes())
+        << ", reservation: " << succinctBytes(pool()->reservedBytes());
+    return;
+  }
+
+  windowBuild_->spill();
+}
+
 void Window::createPeerAndFrameBuffers() {
   // TODO: This computation needs to be revised. It only takes into account
   // the input columns size. We need to also account for the output columns.
@@ -151,7 +256,7 @@ void Window::createPeerAndFrameBuffers() {
   peerEndBuffer_ = AlignedBuffer::allocate<vector_size_t>(
       numRowsPerOutput_, operatorCtx_->pool());
 
-  auto numFuncs = windowFunctions_.size();
+  const auto numFuncs = windowFunctions_.size();
   frameStartBuffers_.reserve(numFuncs);
   frameEndBuffers_.reserve(numFuncs);
   validFrames_.reserve(numFuncs);
@@ -179,7 +284,7 @@ void Window::callResetPartition() {
   currentPartition_ = nullptr;
   if (windowBuild_->hasNextPartition()) {
     currentPartition_ = windowBuild_->nextPartition();
-    for (int i = 0; i < windowFunctions_.size(); i++) {
+    for (int i = 0; i < windowFunctions_.size(); ++i) {
       windowFunctions_[i]->resetPartition(currentPartition_.get());
     }
   }
@@ -194,8 +299,8 @@ void updateKRowsOffsetsColumn(
     vector_size_t startRow,
     vector_size_t numRows,
     vector_size_t* rawFrameBounds) {
-  auto offsets = value->values()->as<T>();
-  for (auto i = 0; i < numRows; i++) {
+  auto* offsets = value->values()->as<T>();
+  for (auto i = 0; i < numRows; ++i) {
     VELOX_USER_CHECK(
         !value->isNullAt(i), "Window frame offset must not be null");
     VELOX_USER_CHECK_GE(
@@ -207,14 +312,25 @@ void updateKRowsOffsetsColumn(
 
   // Preceding involves subtracting from the current position, while following
   // moves ahead.
-  int precedingFactor = isKPreceding ? -1 : 1;
-  for (auto i = 0; i < numRows; i++) {
-    rawFrameBounds[i] =
-        (startRow + i) + vector_size_t(precedingFactor * offsets[i]);
+  const int precedingFactor = isKPreceding ? -1 : 1;
+  for (auto i = 0; i < numRows; ++i) {
+    const auto startValue =
+        (int64_t)(startRow + i) + precedingFactor * offsets[i];
+    if (startValue < INT32_MIN) {
+      // Same as the handling of startValue < INT32_MIN in
+      // updateKRowsFrameBounds.
+      rawFrameBounds[i] = -1;
+    } else if (startValue > INT32_MAX) {
+      // computeValidFrames will replace INT32_MAX set here
+      // with partition's final row index.
+      rawFrameBounds[i] = INT32_MAX;
+    } else {
+      rawFrameBounds[i] = startValue;
+    }
   }
 }
 
-}; // namespace
+} // namespace
 
 void Window::updateKRowsFrameBounds(
     bool isKPreceding,
@@ -223,9 +339,43 @@ void Window::updateKRowsFrameBounds(
     vector_size_t numRows,
     vector_size_t* rawFrameBounds) {
   if (frameArg.index == kConstantChannel) {
-    auto constantOffset = frameArg.constant.value();
-    auto startValue =
-        startRow + (isKPreceding ? -constantOffset : constantOffset);
+    const auto constantOffset = frameArg.constant.value();
+    const auto startValue =
+        (int64_t)startRow + (isKPreceding ? -constantOffset : constantOffset);
+
+    if (isKPreceding) {
+      if (startValue < INT32_MIN) {
+        // For overflow in kPreceding frames, i.e., k < INT32_MIN, we set the
+        // frame bound to -1. For frames whose original frame start is below
+        // INT32_MIN, the new frame start becomes -1 and will be corrected to 0
+        // by the subsequent computeValidFrames call. For frames whose original
+        // frame end is below INT32_MIN, the new frame end becomes -1 and will
+        // be marked invalid by the subsequent computeValidFrames call. This is
+        // expected because the max number of rows in a partition is INT32_MAX,
+        // so a frame end below INT32_MIN always results in an empty frame.
+        std::fill_n(rawFrameBounds, numRows, -1);
+        return;
+      }
+      std::iota(rawFrameBounds, rawFrameBounds + numRows, startValue);
+      return;
+    }
+
+    // KFollowing.
+    // The start index that overflow happens.
+    int32_t overflowStart;
+    if (startValue > (int64_t)INT32_MAX) {
+      overflowStart = 0;
+    } else {
+      overflowStart = INT32_MAX - startValue + 1;
+    }
+    if (overflowStart >= 0 && overflowStart < numRows) {
+      std::iota(rawFrameBounds, rawFrameBounds + overflowStart, startValue);
+      // For remaining rows that overflow happens, use INT32_MAX.
+      // computeValidFrames will replace it with partition's final row index.
+      std::fill_n(
+          rawFrameBounds + overflowStart, numRows - overflowStart, INT32_MAX);
+      return;
+    }
     std::iota(rawFrameBounds, rawFrameBounds + numRows, startValue);
   } else {
     currentPartition_->extractColumn(
@@ -248,10 +398,13 @@ void Window::updateFrameBounds(
     const vector_size_t* rawPeerStarts,
     const vector_size_t* rawPeerEnds,
     vector_size_t* rawFrameBounds) {
-  auto windowType = windowFrame.type;
-  auto boundType = isStartBound ? windowFrame.startType : windowFrame.endType;
-  auto frameArg = isStartBound ? windowFrame.start : windowFrame.end;
+  const auto windowType = windowFrame.type;
+  const auto boundType =
+      isStartBound ? windowFrame.startType : windowFrame.endType;
+  const auto frameArg = isStartBound ? windowFrame.start : windowFrame.end;
 
+  const vector_size_t* rawPeerBuffer =
+      isStartBound ? rawPeerStarts : rawPeerEnds;
   switch (boundType) {
     case core::WindowNode::BoundType::kUnboundedPreceding:
       std::fill_n(rawFrameBounds, numRows, 0);
@@ -261,8 +414,6 @@ void Window::updateFrameBounds(
       break;
     case core::WindowNode::BoundType::kCurrentRow: {
       if (windowType == core::WindowNode::WindowType::kRange) {
-        const vector_size_t* rawPeerBuffer =
-            isStartBound ? rawPeerStarts : rawPeerEnds;
         std::copy(rawPeerBuffer, rawPeerBuffer + numRows, rawFrameBounds);
       } else {
         // Fills the frameBound buffer with increasing value of row indices
@@ -277,7 +428,14 @@ void Window::updateFrameBounds(
         updateKRowsFrameBounds(
             true, frameArg.value(), startRow, numRows, rawFrameBounds);
       } else {
-        VELOX_NYI("k preceding frame is only supported in ROWS mode");
+        currentPartition_->computeKRangeFrameBounds(
+            isStartBound,
+            true,
+            frameArg.value().index,
+            startRow,
+            numRows,
+            rawPeerBuffer,
+            rawFrameBounds);
       }
       break;
     }
@@ -286,7 +444,14 @@ void Window::updateFrameBounds(
         updateKRowsFrameBounds(
             false, frameArg.value(), startRow, numRows, rawFrameBounds);
       } else {
-        VELOX_NYI("k following frame is only supported in ROWS mode");
+        currentPartition_->computeKRangeFrameBounds(
+            isStartBound,
+            false,
+            frameArg.value().index,
+            startRow,
+            numRows,
+            rawPeerBuffer,
+            rawFrameBounds);
       }
       break;
     }
@@ -308,12 +473,9 @@ void computeValidFrames(
     vector_size_t* rawFrameStarts,
     vector_size_t* rawFrameEnds,
     SelectivityVector& validFrames) {
-  auto frameStart = 0;
-  auto frameEnd = 0;
-
-  for (auto i = 0; i < numRows; i++) {
-    frameStart = rawFrameStarts[i];
-    frameEnd = rawFrameEnds[i];
+  for (auto i = 0; i < numRows; ++i) {
+    const vector_size_t frameStart = rawFrameStarts[i];
+    const vector_size_t frameEnd = rawFrameEnds[i];
     // All valid frames require frameStart <= frameEnd to define the frame rows.
     // Also, frameEnd >= 0, so that the frameEnd doesn't fall before the
     // partition. And frameStart <= lastRow so that the frameStart doesn't fall
@@ -327,32 +489,31 @@ void computeValidFrames(
   }
   validFrames.updateBounds();
 }
-
-}; // namespace
+} // namespace
 
 void Window::computePeerAndFrameBuffers(
     vector_size_t startRow,
     vector_size_t endRow) {
-  vector_size_t numRows = endRow - startRow;
-  vector_size_t numFuncs = windowFunctions_.size();
+  const vector_size_t numRows = endRow - startRow;
+  const vector_size_t numFuncs = windowFunctions_.size();
 
   // Size buffers for the call to WindowFunction::apply.
-  auto bufferSize = numRows * sizeof(vector_size_t);
+  const auto bufferSize = numRows * sizeof(vector_size_t);
   peerStartBuffer_->setSize(bufferSize);
   peerEndBuffer_->setSize(bufferSize);
-  auto rawPeerStarts = peerStartBuffer_->asMutable<vector_size_t>();
-  auto rawPeerEnds = peerEndBuffer_->asMutable<vector_size_t>();
+  auto* rawPeerStarts = peerStartBuffer_->asMutable<vector_size_t>();
+  auto* rawPeerEnds = peerEndBuffer_->asMutable<vector_size_t>();
 
   std::vector<vector_size_t*> rawFrameStarts;
   std::vector<vector_size_t*> rawFrameEnds;
   rawFrameStarts.reserve(numFuncs);
   rawFrameEnds.reserve(numFuncs);
-  for (auto w = 0; w < numFuncs; w++) {
-    frameStartBuffers_[w]->setSize(bufferSize);
-    frameEndBuffers_[w]->setSize(bufferSize);
+  for (auto i = 0; i < numFuncs; ++i) {
+    frameStartBuffers_[i]->setSize(bufferSize);
+    frameEndBuffers_[i]->setSize(bufferSize);
 
-    auto rawFrameStart = frameStartBuffers_[w]->asMutable<vector_size_t>();
-    auto rawFrameEnd = frameEndBuffers_[w]->asMutable<vector_size_t>();
+    auto* rawFrameStart = frameStartBuffers_[i]->asMutable<vector_size_t>();
+    auto* rawFrameEnd = frameEndBuffers_[i]->asMutable<vector_size_t>();
     rawFrameStarts.push_back(rawFrameStart);
     rawFrameEnds.push_back(rawFrameEnd);
   }
@@ -360,7 +521,7 @@ void Window::computePeerAndFrameBuffers(
   std::tie(peerStartRow_, peerEndRow_) = currentPartition_->computePeerBuffers(
       startRow, endRow, peerStartRow_, peerEndRow_, rawPeerStarts, rawPeerEnds);
 
-  for (auto i = 0; i < numFuncs; i++) {
+  for (auto i = 0; i < numFuncs; ++i) {
     const auto& windowFrame = windowFrames_[i];
     // Default all rows to have validFrames. The invalidity of frames is only
     // computed for k rows/range frames at a later point.
@@ -382,12 +543,12 @@ void Window::computePeerAndFrameBuffers(
         rawPeerEnds,
         rawFrameEnds[i]);
     if (windowFrames_[i].start || windowFrames_[i].end) {
-      // k preceding and k following bounds can be problematic. They can
-      // go over the partition limits or result in empty frames. Fix the
-      // frame boundaries and compute the validFrames SelectivityVector
-      // for these cases. Not all functions care about validFrames viz.
-      // Ranking functions do not care about frames. So the function decides
-      // further what to do with empty frames.
+      // k preceding and k following bounds can be problematic. They can go over
+      // the partition limits or result in empty frames. Fix the frame
+      // boundaries and compute the validFrames SelectivityVector for these
+      // cases. Not all functions care about validFrames viz. Ranking functions
+      // do not care about frames. So the function decides further what to do
+      // with empty frames.
       computeValidFrames(
           currentPartition_->numRows() - 1,
           numRows,
@@ -403,7 +564,7 @@ void Window::getInputColumns(
     vector_size_t endRow,
     vector_size_t resultOffset,
     const RowVectorPtr& result) {
-  auto numRows = endRow - startRow;
+  const auto numRows = endRow - startRow;
   for (int i = 0; i < numInputColumns_; ++i) {
     currentPartition_->extractColumn(
         i, partitionOffset_, numRows, resultOffset, result->childAt(i));
@@ -415,24 +576,32 @@ void Window::callApplyForPartitionRows(
     vector_size_t endRow,
     vector_size_t resultOffset,
     const RowVectorPtr& result) {
-  getInputColumns(startRow, endRow, resultOffset, result);
-
+  // NOTE: for a partial window partition, the last row of the previously
+  // processed rows (used for peer group comparison) will be deleted by
+  // computePeerAndFrameBuffers after peer group comparison. Hence we need to
+  // call getInputColumns after computePeerAndFrameBuffers.
   computePeerAndFrameBuffers(startRow, endRow);
+
+  getInputColumns(startRow, endRow, resultOffset, result);
   vector_size_t numFuncs = windowFunctions_.size();
-  for (auto w = 0; w < numFuncs; w++) {
-    windowFunctions_[w]->apply(
+  for (auto i = 0; i < numFuncs; ++i) {
+    windowFunctions_[i]->apply(
         peerStartBuffer_,
         peerEndBuffer_,
-        frameStartBuffers_[w],
-        frameEndBuffers_[w],
-        validFrames_[w],
+        frameStartBuffers_[i],
+        frameEndBuffers_[i],
+        validFrames_[i],
         resultOffset,
-        result->childAt(numInputColumns_ + w));
+        result->childAt(numInputColumns_ + i));
   }
 
-  vector_size_t numRows = endRow - startRow;
+  const vector_size_t numRows = endRow - startRow;
   numProcessedRows_ += numRows;
   partitionOffset_ += numRows;
+
+  if (currentPartition_->partial()) {
+    currentPartition_->removeProcessedRows(numRows);
+  }
 }
 
 vector_size_t Window::callApplyLoop(
@@ -446,20 +615,27 @@ vector_size_t Window::callApplyLoop(
   // This function requires that the currentPartition_ is available for output.
   VELOX_DCHECK_NOT_NULL(currentPartition_);
   while (numOutputRowsLeft > 0) {
-    auto rowsForCurrentPartition =
-        currentPartition_->numRows() - partitionOffset_;
-    if (rowsForCurrentPartition <= numOutputRowsLeft) {
+    const auto numPartitionRows =
+        currentPartition_->numRowsForProcessing(partitionOffset_);
+    if (numPartitionRows <= numOutputRowsLeft) {
       // Current partition can fit completely in the output buffer.
       // So output all its rows.
       callApplyForPartitionRows(
           partitionOffset_,
-          partitionOffset_ + rowsForCurrentPartition,
+          partitionOffset_ + numPartitionRows,
           resultIndex,
           result);
-      resultIndex += rowsForCurrentPartition;
-      numOutputRowsLeft -= rowsForCurrentPartition;
+      resultIndex += numPartitionRows;
+      numOutputRowsLeft -= numPartitionRows;
+
+      if (!currentPartition_->complete()) {
+        // There are more data need to process for a partial partition.
+        VELOX_CHECK(currentPartition_->partial());
+        break;
+      }
+
       callResetPartition();
-      if (!currentPartition_) {
+      if (currentPartition_ == nullptr) {
         // The WindowBuild doesn't have any more partitions to process right
         // now. So break until the next getOutput call.
         break;
@@ -487,29 +663,28 @@ RowVectorPtr Window::getOutput() {
     return nullptr;
   }
 
-  auto numRowsLeft = numRows_ - numProcessedRows_;
+  const auto numRowsLeft = numRows_ - numProcessedRows_;
   if (numRowsLeft == 0) {
     return nullptr;
   }
 
-  if (!currentPartition_) {
+  if (currentPartition_ == nullptr) {
     callResetPartition();
-    if (!currentPartition_) {
+    if (currentPartition_ == nullptr) {
       // WindowBuild doesn't have a partition to output.
       return nullptr;
     }
   }
 
-  auto numOutputRows = std::min(numRowsPerOutput_, numRowsLeft);
-  auto result = std::dynamic_pointer_cast<RowVector>(
-      BaseVector::create(outputType_, numOutputRows, operatorCtx_->pool()));
-
-  for (int i = numInputColumns_; i < outputType_->size(); i++) {
-    auto output = BaseVector::create(
-        outputType_->childAt(i), numOutputRows, operatorCtx_->pool());
-    result->childAt(i) = output;
+  if (!currentPartition_->complete() &&
+      (currentPartition_->numRowsForProcessing(partitionOffset_) == 0)) {
+    return nullptr;
   }
 
+  const auto numOutputRows = std::min(numRowsPerOutput_, numRowsLeft);
+  auto result = BaseVector::create<RowVector>(
+      outputType_, numOutputRows, operatorCtx_->pool());
+
   // Compute the output values of window functions.
   auto numResultRows = callApplyLoop(numOutputRows, result);
   return numResultRows < numOutputRows
diff --git a/velox/exec/Window.h b/velox/exec/Window.h
index c7233f8520881..eb3389369a230 100644
--- a/velox/exec/Window.h
+++ b/velox/exec/Window.h
@@ -64,6 +64,9 @@ class Window : public Operator {
     return noMoreInput_ && numRows_ == numProcessedRows_;
   }
 
+  void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
+      override;
+
  private:
   // Used for k preceding/following frames. Index is the column index if k is a
   // column. value is used to read column values from the column index when k
@@ -85,9 +88,20 @@ class Window : public Operator {
     const std::optional<FrameChannelArg> end;
   };
 
+  // Returns if a window operator support rows-wise streaming processing or not.
+  // Currently we supports 'rank', 'dense_rank' and 'row_number' functions with
+  // any frame type. Also supports the agg window function with default frame.
+  bool supportRowsStreaming();
+
   // Creates WindowFunction and frame objects for this operator.
   void createWindowFunctions();
 
+  // Converts WindowNode::Frame to Window::WindowFrame.
+  WindowFrame createWindowFrame(
+      const std::shared_ptr<const core::WindowNode>& windowNode,
+      const core::WindowNode::Frame& frame,
+      const RowTypePtr& inputType);
+
   // Creates the buffers for peer and frame row
   // indices to send in window function apply invocations.
   void createPeerAndFrameBuffers();
@@ -127,11 +141,6 @@ class Window : public Operator {
       vector_size_t numOutputRows,
       const RowVectorPtr& result);
 
-  // Converts WindowNode::Frame to Window::WindowFrame.
-  WindowFrame createWindowFrame(
-      core::WindowNode::Frame frame,
-      const RowTypePtr& inputType);
-
   // Update frame bounds for kPreceding, kFollowing row frames.
   void updateKRowsFrameBounds(
       bool isKPreceding,
@@ -161,7 +170,7 @@ class Window : public Operator {
 
   // Used to access window partition rows and columns by the window
   // operator and functions. This structure is owned by the WindowBuild.
-  std::unique_ptr<WindowPartition> currentPartition_;
+  std::shared_ptr<WindowPartition> currentPartition_;
 
   // HashStringAllocator required by functions that allocate out of line
   // buffers.
@@ -171,40 +180,39 @@ class Window : public Operator {
   // WindowFunction is the base API implemented by all the window functions.
   // The functions are ordered by their positions in the output columns.
   std::vector<std::unique_ptr<exec::WindowFunction>> windowFunctions_;
+
   // Vector of WindowFrames corresponding to each windowFunction above.
   // It represents the frame spec for the function computation.
   std::vector<WindowFrame> windowFrames_;
 
-  // Number of input rows.
-  vector_size_t numRows_ = 0;
-
-  // Number of rows that be fit into an output block.
-  vector_size_t numRowsPerOutput_;
-
-  // The following 4 Buffers are used to pass peer and frame start and
-  // end values to the WindowFunction::apply method. These
-  // buffers can be allocated once and reused across all the getOutput
-  // calls.
+  // The following 4 Buffers are used to pass peer and frame start and end
+  // values to the WindowFunction::apply method. These buffers can be allocated
+  // once and reused across all the getOutput calls.
   // Only a single peer start and peer end buffer is needed across all
   // functions (as the peer values are based on the ORDER BY clause).
   BufferPtr peerStartBuffer_;
   BufferPtr peerEndBuffer_;
-  // A separate BufferPtr is required for the frame indexes of each
-  // function. Each function has its own frame clause and style. So we
-  // have as many buffers as the number of functions.
+  // A separate BufferPtr is required for the frame indexes of each function.
+  // Each function has its own frame clause and style. So we have as many
+  // buffers as the number of functions.
   std::vector<BufferPtr> frameStartBuffers_;
   std::vector<BufferPtr> frameEndBuffers_;
 
-  // Frame types for kPreceding or kFollowing could result in empty
-  // frames if the frameStart > frameEnds, or frameEnds < firstPartitionRow
-  // or frameStarts > lastPartitionRow. Such frames usually evaluate to NULL
-  // in the window function.
-  // This SelectivityVector captures the valid (non-empty) frames in the
-  // buffer being worked on. The window function can use this to compute
-  // output values.
+  // Frame types for kPreceding or kFollowing could result in empty frames if
+  // the frameStart > frameEnds, or frameEnds < firstPartitionRow or frameStarts
+  // > lastPartitionRow. Such frames usually evaluate to NULL in the window
+  // function.
+  // This SelectivityVector captures the valid (non-empty) frames in the buffer
+  // being worked on. The window function can use this to compute output values.
   // There is one SelectivityVector per window function.
   std::vector<SelectivityVector> validFrames_;
 
+  // Number of input rows.
+  vector_size_t numRows_ = 0;
+
+  // Number of rows that be fit into an output block.
+  vector_size_t numRowsPerOutput_;
+
   // Number of rows output from the WindowOperator so far. The rows
   // are output in the same order of the pointers in sortedRows. This
   // value is updated as the WindowFunction::apply() function is
@@ -214,14 +222,13 @@ class Window : public Operator {
   // Tracks how far along the partition rows have been output.
   vector_size_t partitionOffset_ = 0;
 
-  // When traversing input partition rows, the peers are the rows
-  // with the same values for the ORDER BY clause. These rows
-  // are equal in some ways and affect the results of ranking functions.
-  // Since all rows between the peerStartRow_ and peerEndRow_ have the same
-  // values for peerStartRow_ and peerEndRow_, we needn't compute
-  // them for each row independently. Since these rows might
-  // cross getOutput boundaries and be called in subsequent calls to
-  // computePeerBuffers they are saved here.
+  // When traversing input partition rows, the peers are the rows with the same
+  // values for the ORDER BY clause. These rows are equal in some ways and
+  // affect the results of ranking functions. Since all rows between the
+  // peerStartRow_ and peerEndRow_ have the same values for peerStartRow_ and
+  // peerEndRow_, we needn't compute them for each row independently. Since
+  // these rows might cross getOutput boundaries and be called in subsequent
+  // calls to computePeerBuffers they are saved here.
   vector_size_t peerStartRow_ = 0;
   vector_size_t peerEndRow_ = 0;
 };
diff --git a/velox/exec/WindowBuild.cpp b/velox/exec/WindowBuild.cpp
index 7142749d9f26d..2c5096be472cd 100644
--- a/velox/exec/WindowBuild.cpp
+++ b/velox/exec/WindowBuild.cpp
@@ -21,47 +21,98 @@
 namespace facebook::velox::exec {
 
 namespace {
-void initKeyInfo(
-    const RowTypePtr& type,
-    const std::vector<core::FieldAccessTypedExprPtr>& keys,
-    const std::vector<core::SortOrder>& orders,
-    std::vector<std::pair<column_index_t, core::SortOrder>>& keyInfo) {
-  const core::SortOrder defaultPartitionSortOrder(true, true);
-
-  keyInfo.reserve(keys.size());
-  for (auto i = 0; i < keys.size(); ++i) {
-    auto channel = exprToChannel(keys[i].get(), type);
-    VELOX_CHECK(
-        channel != kConstantChannel,
-        "Window doesn't allow constant partition or sort keys");
-    if (i < orders.size()) {
-      keyInfo.push_back(std::make_pair(channel, orders[i]));
-    } else {
-      keyInfo.push_back(std::make_pair(channel, defaultPartitionSortOrder));
+std::tuple<std::vector<column_index_t>, std::vector<column_index_t>, RowTypePtr>
+reorderInputChannels(
+    const RowTypePtr& inputType,
+    const std::vector<core::FieldAccessTypedExprPtr>& partitionKeys,
+    const std::vector<core::FieldAccessTypedExprPtr>& sortingKeys) {
+  const auto size = inputType->size();
+
+  std::vector<column_index_t> channels;
+  std::vector<column_index_t> inversedChannels;
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  channels.reserve(size);
+  inversedChannels.resize(size);
+  names.reserve(size);
+  types.reserve(size);
+
+  std::unordered_set<std::string> keyNames;
+
+  auto appendChannel =
+      [&inputType, &channels, &inversedChannels, &names, &types](
+          column_index_t channel) {
+        channels.push_back(channel);
+        inversedChannels[channel] = channels.size() - 1;
+        names.push_back(inputType->nameOf(channel));
+        types.push_back(inputType->childAt(channel));
+      };
+
+  for (const auto& key : partitionKeys) {
+    auto channel = exprToChannel(key.get(), inputType);
+    appendChannel(channel);
+    keyNames.insert(key->name());
+  }
+
+  for (const auto& key : sortingKeys) {
+    auto channel = exprToChannel(key.get(), inputType);
+    appendChannel(channel);
+    keyNames.insert(key->name());
+  }
+
+  for (auto i = 0; i < size; ++i) {
+    if (keyNames.count(inputType->nameOf(i)) == 0) {
+      appendChannel(i);
     }
   }
+
+  return std::make_tuple(
+      channels, inversedChannels, ROW(std::move(names), std::move(types)));
+}
+
+// Returns a [start, end) slice of the 'types' vector.
+std::vector<TypePtr>
+slice(const std::vector<TypePtr>& types, int32_t start, int32_t end) {
+  std::vector<TypePtr> result;
+  result.reserve(end - start);
+  for (auto i = start; i < end; ++i) {
+    result.push_back(types[i]);
+  }
+  return result;
 }
-}; // namespace
+
+} // namespace
 
 WindowBuild::WindowBuild(
     const std::shared_ptr<const core::WindowNode>& windowNode,
-    velox::memory::MemoryPool* pool)
-    : numInputColumns_(windowNode->sources()[0]->outputType()->size()),
-      data_(std::make_unique<RowContainer>(
-          windowNode->sources()[0]->outputType()->children(),
-          pool)),
-      decodedInputVectors_(windowNode->sources()[0]->outputType()->size()) {
-  auto inputType = windowNode->sources()[0]->outputType();
-  for (int i = 0; i < inputType->children().size(); i++) {
-    inputColumns_.push_back(data_->columnAt(i));
+    velox::memory::MemoryPool* pool,
+    const common::SpillConfig* spillConfig,
+    tsan_atomic<bool>* nonReclaimableSection)
+    : spillConfig_{spillConfig},
+      nonReclaimableSection_{nonReclaimableSection},
+      decodedInputVectors_(windowNode->inputType()->size()) {
+  std::tie(inputChannels_, inversedInputChannels_, inputType_) =
+      reorderInputChannels(
+          windowNode->inputType(),
+          windowNode->partitionKeys(),
+          windowNode->sortingKeys());
+
+  const auto numPartitionKeys = windowNode->partitionKeys().size();
+  const auto numSortingKeys = windowNode->sortingKeys().size();
+  const auto numKeys = numPartitionKeys + numSortingKeys;
+  data_ = std::make_unique<RowContainer>(
+      slice(inputType_->children(), 0, numKeys),
+      slice(inputType_->children(), numKeys, inputType_->size()),
+      pool);
+
+  for (auto i = 0; i < numPartitionKeys; ++i) {
+    partitionKeyInfo_.push_back(std::make_pair(i, core::SortOrder{true, true}));
   }
 
-  initKeyInfo(inputType, windowNode->partitionKeys(), {}, partitionKeyInfo_);
-  initKeyInfo(
-      inputType,
-      windowNode->sortingKeys(),
-      windowNode->sortingOrders(),
-      sortKeyInfo_);
+  for (auto i = 0; i < numSortingKeys; ++i) {
+    sortKeyInfo_.push_back(
+        std::make_pair(numPartitionKeys + i, windowNode->sortingOrders()[i]));
+  }
 }
 
 bool WindowBuild::compareRowsWithKeys(
diff --git a/velox/exec/WindowBuild.h b/velox/exec/WindowBuild.h
index 50b3495bae7a1..01c470803ed70 100644
--- a/velox/exec/WindowBuild.h
+++ b/velox/exec/WindowBuild.h
@@ -20,82 +20,104 @@
 
 namespace facebook::velox::exec {
 
-// The Window operator needs to see all input rows, and separate them into
-// partitions based on a partitioning key. There are many approaches to do
-// this. e.g with a full-sort, HashTable, streaming etc. This abstraction
-// is used by the Window operator to hold the input rows and provide
-// partitions to it for processing. Varied implementations of the
-// WindowBuild can use different algorithms.
+/// The Window operator needs to see all input rows, and separate them into
+/// partitions based on a partitioning key. There are many approaches to do
+/// this. e.g with a full-sort, HashTable, streaming etc. This abstraction is
+/// used by the Window operator to hold the input rows and provide partitions to
+/// it for processing. Varied implementations of the WindowBuild can use
+/// different algorithms.
 class WindowBuild {
  public:
   WindowBuild(
       const std::shared_ptr<const core::WindowNode>& windowNode,
-      velox::memory::MemoryPool* pool);
+      velox::memory::MemoryPool* pool,
+      const common::SpillConfig* spillConfig,
+      tsan_atomic<bool>* nonReclaimableSection);
 
   virtual ~WindowBuild() = default;
 
-  // The Window operator invokes this function to check if the WindowBuild can
-  // accept input. The Streaming Window build doesn't accept input if it has a
-  // partition to output.
+  /// The Window operator invokes this function to check if the WindowBuild can
+  /// accept input. The Streaming Window build doesn't accept input if it has a
+  /// partition to output.
   virtual bool needsInput() = 0;
 
-  // Adds new input rows to the WindowBuild.
+  /// Adds new input rows to the WindowBuild.
   virtual void addInput(RowVectorPtr input) = 0;
 
-  // The Window operator invokes this function to indicate that no
-  // more input rows will be passed from the Window operator to the
-  // WindowBuild.
-  // When using a sort based build, all input rows need to be
-  // seen before any partitions are determined. So this function is
-  // used to indicate to the WindowBuild that it can proceed with
-  // building partitions.
+  /// Can be called any time before noMoreInput().
+  virtual void spill() = 0;
+
+  /// Returns the spiller stats including total bytes and rows spilled so far.
+  virtual std::optional<common::SpillStats> spilledStats() const = 0;
+
+  /// The Window operator invokes this function to indicate that no more input
+  /// rows will be passed from the Window operator to the WindowBuild. When
+  /// using a sort based build, all input rows need to be seen before any
+  /// partitions are determined. So this function is used to indicate to the
+  /// WindowBuild that it can proceed with building partitions.
   virtual void noMoreInput() = 0;
 
-  // Returns true if a new Window partition is available for the Window
-  // operator to consume.
+  /// Returns true if a new Window partition is available for the Window
+  /// operator to consume.
   virtual bool hasNextPartition() = 0;
 
-  // The Window operator invokes this function to get the next Window partition
-  // to pass along to the WindowFunction. The WindowPartition has APIs to access
-  // the underlying columns of Window partition data.
-  // Check hasNextPartition() before invoking this function. This function fails
-  // if called when no partition is available.
-  virtual std::unique_ptr<WindowPartition> nextPartition() = 0;
+  /// The Window operator invokes this function to get the next Window partition
+  /// to pass along to the WindowFunction. The WindowPartition has APIs to
+  /// access the underlying columns of Window partition data. Check
+  /// hasNextPartition() before invoking this function. This function fails if
+  /// called when no partition is available.
+  virtual std::shared_ptr<WindowPartition> nextPartition() = 0;
 
-  // Returns the average size of input rows in bytes stored in the
-  // data container of the WindowBuild.
+  /// Returns the average size of input rows in bytes stored in the data
+  /// container of the WindowBuild.
   std::optional<int64_t> estimateRowSize() {
     return data_->estimateRowSize();
   }
 
+  void setNumRowsPerOutput(vector_size_t numRowsPerOutput) {
+    numRowsPerOutput_ = numRowsPerOutput;
+  }
+
  protected:
   bool compareRowsWithKeys(
       const char* lhs,
       const char* rhs,
       const std::vector<std::pair<column_index_t, core::SortOrder>>& keys);
 
-  // The below 2 vectors represent the ChannelIndex of the partition keys
-  // and the order by keys. These keyInfo are used for sorting by those
-  // key combinations during the processing.
-  // partitionKeyInfo_ is used to separate partitions in the rows.
-  // sortKeyInfo_ is used to identify peer rows in a partition.
+  const common::SpillConfig* const spillConfig_;
+  tsan_atomic<bool>* const nonReclaimableSection_;
+
+  /// The below 2 vectors represent the ChannelIndex of the partition keys
+  /// and the order by keys. These keyInfo are used for sorting by those
+  /// key combinations during the processing. partitionKeyInfo_ is used to
+  /// separate partitions in the rows. sortKeyInfo_ is used to identify peer
+  /// rows in a partition.
   std::vector<std::pair<column_index_t, core::SortOrder>> partitionKeyInfo_;
   std::vector<std::pair<column_index_t, core::SortOrder>> sortKeyInfo_;
 
-  const vector_size_t numInputColumns_;
+  /// Input columns in the order of: partition keys, sorting keys, the rest.
+  std::vector<column_index_t> inputChannels_;
 
-  // The RowContainer holds all the input rows in WindowBuild.
+  /// The mapping from original input column index to the index after column
+  /// reordering. This is the inversed mapping of inputChannels_.
+  std::vector<column_index_t> inversedInputChannels_;
+
+  /// Input column types in 'inputChannels_' order.
+  RowTypePtr inputType_;
+
+  /// The RowContainer holds all the input rows in WindowBuild. Columns are
+  /// already reordered according to inputChannels_.
   std::unique_ptr<RowContainer> data_;
 
-  // The decodedInputVectors_ are reused across addInput() calls to decode
-  // the partition and sort keys for the above RowContainer.
+  /// The decodedInputVectors_ are reused across addInput() calls to decode the
+  /// partition and sort keys for the above RowContainer.
   std::vector<DecodedVector> decodedInputVectors_;
 
-  // RowColumns for window build used to construct WindowPartition.
-  std::vector<exec::RowColumn> inputColumns_;
-
-  // Number of input rows.
+  /// Number of input rows.
   vector_size_t numRows_ = 0;
+
+  // The maximum number of rows that can fit into an output block.
+  vector_size_t numRowsPerOutput_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/WindowFunction.cpp b/velox/exec/WindowFunction.cpp
index e1029dbed28e4..30c3d4840b700 100644
--- a/velox/exec/WindowFunction.cpp
+++ b/velox/exec/WindowFunction.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/exec/WindowFunction.h"
 #include "velox/expression/FunctionSignature.h"
+#include "velox/expression/SignatureBinder.h"
 
 namespace facebook::velox::exec {
 
@@ -40,13 +41,24 @@ std::optional<const WindowFunctionEntry*> getWindowFunctionEntry(
 bool registerWindowFunction(
     const std::string& name,
     std::vector<FunctionSignaturePtr> signatures,
+    WindowFunction::Metadata metadata,
     WindowFunctionFactory factory) {
   auto sanitizedName = sanitizeName(name);
   windowFunctions()[sanitizedName] = {
-      std::move(signatures), std::move(factory)};
+      std::move(signatures), std::move(factory), std::move(metadata)};
   return true;
 }
 
+WindowFunction::Metadata getWindowFunctionMetadata(const std::string& name) {
+  const auto sanitizedName = sanitizeName(name);
+  if (auto func = getWindowFunctionEntry(sanitizedName)) {
+    return func.value()->metadata;
+  } else {
+    VELOX_USER_FAIL(
+        "Window function metadata not found for function: {}", name);
+  }
+}
+
 std::optional<std::vector<FunctionSignaturePtr>> getWindowFunctionSignatures(
     const std::string& name) {
   auto sanitizedName = sanitizeName(name);
@@ -66,25 +78,59 @@ std::unique_ptr<WindowFunction> WindowFunction::create(
     const core::QueryConfig& config) {
   // Lookup the function in the new registry first.
   if (auto func = getWindowFunctionEntry(name)) {
-    return func.value()->factory(
-        args, resultType, ignoreNulls, pool, stringAllocator, config);
+    std::vector<TypePtr> argTypes;
+    argTypes.reserve(args.size());
+    for (const auto& arg : args) {
+      argTypes.push_back(arg.type);
+    }
+
+    const auto& signatures = func.value()->signatures;
+    for (auto& signature : signatures) {
+      SignatureBinder binder(*signature, argTypes);
+      if (binder.tryBind()) {
+        auto type = binder.tryResolveType(signature->returnType());
+        VELOX_USER_CHECK(
+            type->equivalent(*resultType),
+            "Unexpected return type for window function {}. Expected {}. Got {}.",
+            toString(name, argTypes),
+            type->toString(),
+            resultType->toString());
+        return func.value()->factory(
+            args, resultType, ignoreNulls, pool, stringAllocator, config);
+      }
+    }
+
+    VELOX_USER_FAIL(
+        "Window function signature is not supported: {}. Supported signatures: {}.",
+        toString(name, argTypes),
+        toString(signatures));
   }
 
   VELOX_USER_FAIL("Window function not registered: {}", name);
 }
 
-void WindowFunction::setNullEmptyFramesResults(
+void WindowFunction::setEmptyFramesResult(
     const SelectivityVector& validRows,
     vector_size_t resultOffset,
+    const VectorPtr& defaultResult,
     const VectorPtr& result) {
   if (validRows.isAllSelected()) {
     return;
   }
+  // Set the null bit for all rows to true if the defaultResult is NULL and
+  // there are no valid rows.
+  if (!validRows.hasSelections() && defaultResult->isNullAt(0)) {
+    uint64_t* rawNulls = result->mutableRawNulls();
+    bits::fillBits(
+        rawNulls, resultOffset, resultOffset + validRows.size(), bits::kNull);
+    return;
+  }
 
   invalidRows_.resizeFill(validRows.size(), true);
   invalidRows_.deselect(validRows);
-  invalidRows_.applyToSelected(
-      [&](auto i) { result->setNull(resultOffset + i, true); });
+  invalidRows_.applyToSelected([&](auto i) {
+    result->copy(defaultResult.get(), resultOffset + i, 0, 1);
+  });
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/WindowFunction.h b/velox/exec/WindowFunction.h
index 996391d913a38..e9bea92ee2c23 100644
--- a/velox/exec/WindowFunction.h
+++ b/velox/exec/WindowFunction.h
@@ -33,6 +33,28 @@ struct WindowFunctionArg {
 
 class WindowFunction {
  public:
+  /// The data process mode for calculating the window function.
+  enum class ProcessMode {
+    /// Process can only start after all the rows from a partition become
+    /// available.
+    kPartition,
+    /// Process can start as soon as rows are available within a partition,
+    /// without waiting for all the rows in the partition to be ready.
+    kRows,
+  };
+
+  /// Indicates whether this is an aggregate window function and its process
+  /// unit.
+  struct Metadata {
+    ProcessMode processMode;
+    bool isAggregate;
+
+    static Metadata defaultMetadata() {
+      static Metadata defaultValue{ProcessMode::kPartition, false};
+      return defaultValue;
+    }
+  };
+
   explicit WindowFunction(
       TypePtr resultType,
       memory::MemoryPool* pool,
@@ -111,10 +133,14 @@ class WindowFunction {
       const core::QueryConfig& config);
 
  protected:
-  // Set result NULL for rows with invalid frames in the input.
-  void setNullEmptyFramesResults(
+  // defaultResult is a vector of size 1 containing the default value to be
+  // returned for rows with empty frames. For aggregate window functions,
+  // defaultResult contains the value returned by the aggregate when there are
+  // no input rows.
+  void setEmptyFramesResult(
       const SelectivityVector& validRows,
       vector_size_t resultOffset,
+      const VectorPtr& defaultResult,
       const VectorPtr& result);
 
   const TypePtr resultType_;
@@ -145,6 +171,7 @@ using WindowFunctionFactory = std::function<std::unique_ptr<WindowFunction>(
 bool registerWindowFunction(
     const std::string& name,
     std::vector<FunctionSignaturePtr> signatures,
+    WindowFunction::Metadata metadata,
     WindowFunctionFactory factory);
 
 /// Returns signatures of the window function with the specified name.
@@ -155,8 +182,12 @@ std::optional<std::vector<FunctionSignaturePtr>> getWindowFunctionSignatures(
 struct WindowFunctionEntry {
   std::vector<FunctionSignaturePtr> signatures;
   WindowFunctionFactory factory;
+  WindowFunction::Metadata metadata;
 };
 
+/// Returns window function metadata.
+WindowFunction::Metadata getWindowFunctionMetadata(const std::string& name);
+
 using WindowFunctionMap = std::unordered_map<std::string, WindowFunctionEntry>;
 
 /// Returns a map of all window function names to their registrations.
diff --git a/velox/exec/WindowPartition.cpp b/velox/exec/WindowPartition.cpp
index e3bcc6cc83c88..162817e80d4de 100644
--- a/velox/exec/WindowPartition.cpp
+++ b/velox/exec/WindowPartition.cpp
@@ -19,12 +19,73 @@ namespace facebook::velox::exec {
 
 WindowPartition::WindowPartition(
     RowContainer* data,
-    const std::vector<exec::RowColumn>& columns,
+    const folly::Range<char**>& rows,
+    const std::vector<column_index_t>& inputMapping,
+    const std::vector<std::pair<column_index_t, core::SortOrder>>& sortKeyInfo,
+    bool partial,
+    bool complete)
+    : partial_(partial),
+      data_(data),
+      partition_(rows),
+      complete_(complete),
+      inputMapping_(inputMapping),
+      sortKeyInfo_(sortKeyInfo) {
+  VELOX_CHECK_NE(partial_, complete_);
+  VELOX_CHECK_NE(complete_, partition_.empty());
+
+  for (auto index : inputMapping_) {
+    columns_.emplace_back(data_->columnAt(index));
+  }
+}
+
+WindowPartition::WindowPartition(
+    RowContainer* data,
+    const folly::Range<char**>& rows,
+    const std::vector<column_index_t>& inputMapping,
+    const std::vector<std::pair<column_index_t, core::SortOrder>>& sortKeyInfo)
+    : WindowPartition(data, rows, inputMapping, sortKeyInfo, false, true) {}
+
+WindowPartition::WindowPartition(
+    RowContainer* data,
+    const std::vector<column_index_t>& inputMapping,
     const std::vector<std::pair<column_index_t, core::SortOrder>>& sortKeyInfo)
-    : data_(data), columns_(columns), sortKeyInfo_(sortKeyInfo) {}
+    : WindowPartition(data, {}, inputMapping, sortKeyInfo, true, false) {}
+
+void WindowPartition::addRows(const std::vector<char*>& rows) {
+  checkPartial();
+  rows_.insert(rows_.end(), rows.begin(), rows.end());
+  partition_ = folly::Range(rows_.data(), rows_.size());
+}
 
-void WindowPartition::resetPartition(const folly::Range<char**>& rows) {
-  partition_ = rows;
+void WindowPartition::eraseRows(vector_size_t numRows) {
+  checkPartial();
+  VELOX_CHECK_GE(data_->numRows(), numRows);
+  data_->eraseRows(folly::Range<char**>(rows_.data(), numRows));
+}
+
+void WindowPartition::removeProcessedRows(vector_size_t numRows) {
+  checkPartial();
+
+  VELOX_CHECK_NULL(previousRow_);
+  if (complete_ && rows_.size() == numRows) {
+    eraseRows(numRows);
+  } else {
+    eraseRows(numRows - 1);
+    previousRow_ = rows_[numRows - 1];
+  }
+
+  rows_.erase(rows_.begin(), rows_.begin() + numRows);
+  partition_ = folly::Range(rows_.data(), rows_.size());
+  startRow_ += numRows;
+}
+
+vector_size_t WindowPartition::numRowsForProcessing(
+    vector_size_t partitionOffset) const {
+  if (partial_) {
+    return partition_.size();
+  } else {
+    return partition_.size() - partitionOffset;
+  }
 }
 
 void WindowPartition::extractColumn(
@@ -36,6 +97,7 @@ void WindowPartition::extractColumn(
       partition_.data(),
       rowNumbers,
       columns_[columnIndex],
+      data_->columnHasNulls(inputMapping_[columnIndex]),
       resultOffset,
       result);
 }
@@ -46,10 +108,12 @@ void WindowPartition::extractColumn(
     vector_size_t numRows,
     vector_size_t resultOffset,
     const VectorPtr& result) const {
+  VELOX_CHECK_GE(partitionOffset, startRow_);
   RowContainer::extractColumn(
-      partition_.data() + partitionOffset,
+      partition_.data() + partitionOffset - startRow_,
       numRows,
       columns_[columnIndex],
+      data_->columnHasNulls(inputMapping_[columnIndex]),
       resultOffset,
       result);
 }
@@ -85,7 +149,7 @@ std::pair<vector_size_t, vector_size_t> findMinMaxFrameBounds(
   return {minFrame, maxFrame};
 }
 
-}; // namespace
+} // namespace
 
 std::optional<std::pair<vector_size_t, vector_size_t>>
 WindowPartition::extractNulls(
@@ -126,49 +190,250 @@ bool WindowPartition::compareRowsWithSortKeys(const char* lhs, const char* rhs)
   return false;
 }
 
+vector_size_t WindowPartition::findPeerRowEndIndex(
+    vector_size_t startRow,
+    vector_size_t lastRow,
+    const std::function<bool(const char*, const char*)>& peerCompare) {
+  auto peerEnd = startRow;
+  while (peerEnd <= lastRow) {
+    if (peerCompare(
+            partition_[startRow - startRow_],
+            partition_[peerEnd - startRow_])) {
+      break;
+    }
+    ++peerEnd;
+  }
+  return peerEnd;
+}
+
+void WindowPartition::removePreviousRow() {
+  VELOX_CHECK_NOT_NULL(previousRow_);
+  data_->eraseRows(folly::Range<char**>(&previousRow_, 1));
+  previousRow_ = nullptr;
+}
+
 std::pair<vector_size_t, vector_size_t> WindowPartition::computePeerBuffers(
     vector_size_t start,
     vector_size_t end,
     vector_size_t prevPeerStart,
     vector_size_t prevPeerEnd,
     vector_size_t* rawPeerStarts,
-    vector_size_t* rawPeerEnds) const {
-  auto peerCompare = [&](const char* lhs, const char* rhs) -> bool {
+    vector_size_t* rawPeerEnds) {
+  const auto peerCompare = [&](const char* lhs, const char* rhs) -> bool {
     return compareRowsWithSortKeys(lhs, rhs);
   };
 
-  VELOX_CHECK_LE(end, numRows());
+  VELOX_CHECK_LE(end, numRows() + startRow_);
 
-  auto lastPartitionRow = numRows() - 1;
+  auto lastPartitionRow = numRows() + startRow_ - 1;
   auto peerStart = prevPeerStart;
   auto peerEnd = prevPeerEnd;
-  for (auto i = start, j = 0; i < end; i++, j++) {
-    // When traversing input partition rows, the peers are the rows
-    // with the same values for the ORDER BY clause. These rows
-    // are equal in some ways and affect the results of ranking functions.
-    // This logic exploits the fact that all rows between the peerStart
-    // and peerEnd have the same values for rawPeerStarts and rawPeerEnds.
-    // So we can compute them just once and reuse across the rows in that peer
-    // interval. Note: peerStart and peerEnd can be maintained across
-    // getOutput calls. Hence, they are returned to the caller.
-
-    if (i == 0 || i >= peerEnd) {
+
+  size_t next = start;
+  size_t index{0};
+  if (partial_ && start > 0) {
+    const auto peerGroup = peerCompare(previousRow_, partition_[0]);
+
+    // The first row is the last row in previous batch so delete it after used
+    // for the first peer group detection.
+    removePreviousRow();
+
+    if (!peerGroup) {
+      peerEnd = findPeerRowEndIndex(start, lastPartitionRow, peerCompare);
+
+      for (; next < std::min(end, peerEnd); ++next, ++index) {
+        rawPeerStarts[index] = peerStart;
+        rawPeerEnds[index] = peerEnd - 1;
+      }
+    }
+  }
+
+  for (; next < end; ++next, ++index) {
+    // When traversing input partition rows, the peers are the rows with the
+    // same values for the ORDER BY clause. These rows are equal in some ways
+    // and affect the results of ranking functions. This logic exploits the fact
+    // that all rows between the peerStart and peerEnd have the same values for
+    // rawPeerStarts and rawPeerEnds. So we can compute them just once and reuse
+    // across the rows in that peer interval. Note: peerStart and peerEnd can be
+    // maintained across getOutput calls. Hence, they are returned to the
+    // caller.
+    if (next == 0 || next >= peerEnd) {
       // Compute peerStart and peerEnd rows for the first row of the partition
       // or when past the previous peerGroup.
-      peerStart = i;
-      peerEnd = i;
-      while (peerEnd <= lastPartitionRow) {
-        if (peerCompare(partition_[peerStart], partition_[peerEnd])) {
-          break;
-        }
-        peerEnd++;
-      }
+      peerStart = next;
+      peerEnd = findPeerRowEndIndex(peerStart, lastPartitionRow, peerCompare);
     }
 
-    rawPeerStarts[j] = peerStart;
-    rawPeerEnds[j] = peerEnd - 1;
+    rawPeerStarts[index] = peerStart;
+    rawPeerEnds[index] = peerEnd - 1;
   }
+  VELOX_CHECK_EQ(index, end - start);
   return {peerStart, peerEnd};
 }
 
+// Searches for start[frameColumn] in orderByColumn.
+// The search could return the first or last row matching start[frameColumn].
+// If a matching row is not present, then the index of the first row greater
+// than value is returned if the rows are in ascending order. For descending,
+// first row smaller than value is returned.
+// The search starts with a binary search for a starting point that is the
+// largest value < frame bound or (smallest value > frame bound for
+// descending). After finding that point it does a sequential search for the
+// required value.
+vector_size_t WindowPartition::searchFrameValue(
+    bool firstMatch,
+    vector_size_t start,
+    vector_size_t end,
+    vector_size_t currentRow,
+    column_index_t orderByColumn,
+    column_index_t frameColumn,
+    const CompareFlags& flags) const {
+  auto current = partition_[currentRow];
+  vector_size_t begin = start;
+  vector_size_t finish = end;
+  while (finish - begin >= 2) {
+    auto mid = (begin + finish) / 2;
+    auto compareResult = data_->compare(
+        partition_[mid], current, orderByColumn, frameColumn, flags);
+
+    if (compareResult >= 0) {
+      // Search in the first half of the column.
+      finish = mid;
+    } else {
+      // Search in the second half of the column.
+      begin = mid;
+    }
+  }
+
+  return linearSearchFrameValue(
+      firstMatch, begin, end, currentRow, orderByColumn, frameColumn, flags);
+}
+
+vector_size_t WindowPartition::linearSearchFrameValue(
+    bool firstMatch,
+    vector_size_t start,
+    vector_size_t end,
+    vector_size_t currentRow,
+    column_index_t orderByColumn,
+    column_index_t frameColumn,
+    const CompareFlags& flags) const {
+  auto current = partition_[currentRow];
+  for (vector_size_t i = start; i < end; ++i) {
+    auto compareResult = data_->compare(
+        partition_[i], current, orderByColumn, frameColumn, flags);
+
+    // The bound value was found. Return if firstMatch required.
+    // If the last match is required, then we need to find the first row that
+    // crosses the bound and return the prior row.
+    if (compareResult == 0) {
+      if (firstMatch) {
+        return i;
+      }
+    }
+
+    // Bound is crossed. Last match needs the previous row.
+    // But for first row matches, this is the first
+    // row that has crossed, but not equals boundary (The equal boundary case
+    // is covered by the condition above). So the bound matches this row itself.
+    if (compareResult > 0) {
+      if (firstMatch) {
+        return i;
+      } else {
+        return i - 1;
+      }
+    }
+  }
+
+  // Return a row beyond the partition boundary. The logic to determine valid
+  // frames handles the out of bound and empty frames from this value.
+  return end == numRows() ? numRows() + 1 : -1;
+}
+
+void WindowPartition::updateKRangeFrameBounds(
+    bool firstMatch,
+    bool isPreceding,
+    const CompareFlags& flags,
+    vector_size_t startRow,
+    vector_size_t numRows,
+    column_index_t frameColumn,
+    const vector_size_t* rawPeerBounds,
+    vector_size_t* rawFrameBounds) const {
+  column_index_t orderByColumn = sortKeyInfo_[0].first;
+  column_index_t mappedFrameColumn = inputMapping_[frameColumn];
+
+  vector_size_t start = 0;
+  vector_size_t end;
+  RowColumn frameRowColumn = columns_[frameColumn];
+  RowColumn orderByRowColumn = columns_[inputMapping_[orderByColumn]];
+  for (auto i = 0; i < numRows; i++) {
+    auto currentRow = startRow + i;
+    auto* partitionRow = partition_[currentRow];
+
+    // The user is expected to set the frame column equal to NULL when the
+    // ORDER BY value is NULL and not in any other case. Validate this
+    // assumption.
+    VELOX_DCHECK_EQ(
+        RowContainer::isNullAt(
+            partitionRow, frameRowColumn.nullByte(), frameRowColumn.nullMask()),
+        RowContainer::isNullAt(
+            partitionRow,
+            orderByRowColumn.nullByte(),
+            orderByRowColumn.nullMask()));
+
+    // If the frame is NULL or 0 preceding or 0 following then the current row
+    // has same values for order by and frame column. In that case
+    // the bound matches the peer row for this row.
+    if (data_->compare(
+            partitionRow,
+            partitionRow,
+            orderByColumn,
+            mappedFrameColumn,
+            flags) == 0) {
+      rawFrameBounds[i] = rawPeerBounds[i];
+    } else {
+      // If the search is for a preceding bound then rows between
+      // [0, currentRow] are examined. For following bounds, rows between
+      // [currentRow, numRows()) are checked.
+      if (isPreceding) {
+        start = 0;
+        end = currentRow + 1;
+      } else {
+        start = currentRow;
+        end = partition_.size();
+      }
+      rawFrameBounds[i] = searchFrameValue(
+          firstMatch,
+          start,
+          end,
+          currentRow,
+          orderByColumn,
+          mappedFrameColumn,
+          flags);
+    }
+  }
+}
+
+void WindowPartition::computeKRangeFrameBounds(
+    bool isStartBound,
+    bool isPreceding,
+    column_index_t frameColumn,
+    vector_size_t startRow,
+    vector_size_t numRows,
+    const vector_size_t* rawPeerBuffer,
+    vector_size_t* rawFrameBounds) const {
+  CompareFlags flags;
+  flags.ascending = sortKeyInfo_[0].second.isAscending();
+  flags.nullsFirst = sortKeyInfo_[0].second.isNullsFirst();
+  // Start bounds require first match. End bounds require last match.
+  updateKRangeFrameBounds(
+      isStartBound,
+      isPreceding,
+      flags,
+      startRow,
+      numRows,
+      frameColumn,
+      rawPeerBuffer,
+      rawFrameBounds);
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/WindowPartition.h b/velox/exec/WindowPartition.h
index 5c4dcd8776458..7948611a98295 100644
--- a/velox/exec/WindowPartition.h
+++ b/velox/exec/WindowPartition.h
@@ -20,30 +20,72 @@
 
 /// Simple WindowPartition that builds over the RowContainer used for storing
 /// the input rows in the Window Operator. This works completely in-memory.
+/// WindowPartition supports partial window partitioning to facilitate
+/// RowsStreamingWindowBuild which can start data processing with a portion set
+/// of rows without having to wait until an entire partition of rows are ready.
+
 /// TODO: This implementation will be revised for Spill to disk semantics.
 
 namespace facebook::velox::exec {
+
 class WindowPartition {
  public:
   /// The WindowPartition is used by the Window operator and WindowFunction
   /// objects to access the underlying data and columns of a partition of rows.
   /// The WindowPartition is constructed by WindowBuild from the input data.
   /// 'data' : Underlying RowContainer of the WindowBuild.
-  /// 'columns' : Input rows of 'data' used for accessing column data from it.
+  /// 'rows' : Pointers to rows in the RowContainer belonging to this partition.
+  /// 'inputMapping' : Mapping from Window input column to the column position
+  /// in 'data' for it. This is required because the WindowBuild re-orders
+  /// the columns in 'data' for use with the spiller.
   /// 'sortKeyInfo' : Order by columns used by the the Window operator. Used to
   /// get peer rows from the input partition.
   WindowPartition(
       RowContainer* data,
-      const std::vector<exec::RowColumn>& columns,
+      const folly::Range<char**>& rows,
+      const std::vector<column_index_t>& inputMapping,
+      const std::vector<std::pair<column_index_t, core::SortOrder>>&
+          sortKeyInfo);
+
+  /// The WindowPartition is used for RowStreamingWindowBuild which allows to
+  /// start data processing with a subset of partition rows. 'partial_' flag is
+  /// set for the constructed window partition.
+  WindowPartition(
+      RowContainer* data,
+      const std::vector<column_index_t>& inputMapping,
       const std::vector<std::pair<column_index_t, core::SortOrder>>&
           sortKeyInfo);
 
+  /// Adds remaining input 'rows' for a partial window partition.
+  void addRows(const std::vector<char*>& rows);
+
+  /// Removes the first 'numRows' in 'rows_' from a partial window partition
+  /// after been processed.
+  void removeProcessedRows(vector_size_t numRows);
+
   /// Returns the number of rows in the current WindowPartition.
   vector_size_t numRows() const {
     return partition_.size();
   }
 
-  void resetPartition(const folly::Range<char**>& rows);
+  /// Returns the number of rows in a window partition remaining for data
+  /// processing.
+  vector_size_t numRowsForProcessing(vector_size_t partitionOffset) const;
+
+  bool complete() const {
+    return complete_;
+  }
+
+  bool partial() const {
+    return partial_;
+  }
+
+  void setComplete() {
+    VELOX_CHECK(!complete_);
+    checkPartial();
+
+    complete_ = true;
+  }
 
   /// Copies the values at 'columnIndex' into 'result' (starting at
   /// 'resultOffset') for the rows at positions in the 'rowNumbers'
@@ -105,14 +147,115 @@ class WindowPartition {
       vector_size_t prevPeerStart,
       vector_size_t prevPeerEnd,
       vector_size_t* rawPeerStarts,
-      vector_size_t* rawPeerEnds) const;
+      vector_size_t* rawPeerEnds);
+
+  /// Sets in 'rawFrameBounds' the frame boundary for the k range
+  /// preceding/following frame.
+  /// @param isStartBound start or end boundary of the frame.
+  /// @param isPreceding preceding or following boundary.
+  /// @param frameColumn column which has the range boundary for that row.
+  /// @param startRow starting row in the partition for this buffer computation.
+  /// @param numRows number of rows to compute buffer for.
+  /// @param rawPeerStarts buffer of peer row values for each row. If the frame
+  /// column is null, then its peer row value is the frame boundary.
+  void computeKRangeFrameBounds(
+      bool isStartBound,
+      bool isPreceding,
+      column_index_t frameColumn,
+      vector_size_t startRow,
+      vector_size_t numRows,
+      const vector_size_t* rawPeerStarts,
+      vector_size_t* rawFrameBounds) const;
 
  private:
+  WindowPartition(
+      RowContainer* data,
+      const folly::Range<char**>& rows,
+      const std::vector<column_index_t>& inputMapping,
+      const std::vector<std::pair<column_index_t, core::SortOrder>>&
+          sortKeyInfo,
+      bool partial,
+      bool complete);
+
   bool compareRowsWithSortKeys(const char* lhs, const char* rhs) const;
 
+  // Finds the index of the last peer row in range of ['startRow', 'lastRow'].
+  vector_size_t findPeerRowEndIndex(
+      vector_size_t startRow,
+      vector_size_t lastRow,
+      const std::function<bool(const char*, const char*)>& peerCompare);
+
+  // Removes 'numRows' from 'data_' and 'rows_'.
+  void eraseRows(vector_size_t numRows);
+
+  void checkPartial() const {
+    VELOX_CHECK(partial_, "WindowPartition should be partial");
+  }
+
+  // Removes the previous row from 'data_'.
+  void removePreviousRow();
+
+  // Searches for 'currentRow[frameColumn]' in 'orderByColumn' of rows between
+  // 'start' and 'end' in the partition. 'firstMatch' specifies if first or last
+  // row is matched.
+  vector_size_t searchFrameValue(
+      bool firstMatch,
+      vector_size_t start,
+      vector_size_t end,
+      vector_size_t currentRow,
+      column_index_t orderByColumn,
+      column_index_t frameColumn,
+      const CompareFlags& flags) const;
+
+  vector_size_t linearSearchFrameValue(
+      bool firstMatch,
+      vector_size_t start,
+      vector_size_t end,
+      vector_size_t currentRow,
+      column_index_t orderByColumn,
+      column_index_t frameColumn,
+      const CompareFlags& flags) const;
+
+  // Iterates over 'numBlockRows' and searches frame value for each row.
+  void updateKRangeFrameBounds(
+      bool firstMatch,
+      bool isPreceding,
+      const CompareFlags& flags,
+      vector_size_t startRow,
+      vector_size_t numRows,
+      column_index_t frameColumn,
+      const vector_size_t* rawPeerBounds,
+      vector_size_t* rawFrameBounds) const;
+
+  // Indicates if this is a partial partition for RowStreamWindowBuild
+  // processing.
+  const bool partial_;
+
   // The RowContainer associated with the partition.
   // It is owned by the WindowBuild that creates the partition.
-  RowContainer* data_;
+  RowContainer* const data_;
+
+  // Points to the input rows for partial partition.
+  std::vector<char*> rows_;
+
+  // folly::Range is for the partition rows iterator provided by the
+  // Window operator. The pointers are to rows from a RowContainer owned
+  // by the operator. We can assume these are valid values for the lifetime
+  // of WindowPartition.
+  folly::Range<char**> partition_;
+
+  // Indicates if a partial partition has received all the input rows. For a
+  // non-partial partition, this is always true.
+  bool complete_ = true;
+
+  // Mapping from window input column -> index in data_. This is required
+  // because the WindowBuild reorders data_ to place partition and sort keys
+  // before other columns in data_. But the Window Operator and Function code
+  // accesses WindowPartition using the indexes of Window input type.
+  const std::vector<column_index_t> inputMapping_;
+
+  // ORDER BY column info for this partition.
+  const std::vector<std::pair<column_index_t, core::SortOrder>> sortKeyInfo_;
 
   // Copy of the input RowColumn objects that are used for
   // accessing the partition row columns. These RowColumn objects
@@ -123,13 +266,14 @@ class WindowPartition {
   // They will request for column vector values at the respective index.
   std::vector<exec::RowColumn> columns_;
 
-  // folly::Range is for the partition rows iterator provided by the
-  // Window operator. The pointers are to rows from a RowContainer owned
-  // by the operator. We can assume these are valid values for the lifetime
-  // of WindowPartition.
-  folly::Range<char**> partition_;
+  // The partition offset of the first row in 'rows_'. It is updated for
+  // partial partition during the data processing but always zero for
+  // non-partial partition.
+  vector_size_t startRow_{0};
 
-  // ORDER BY column info for this partition.
-  const std::vector<std::pair<column_index_t, core::SortOrder>> sortKeyInfo_;
+  // Points to the last row from the previous processed peer group if not null.
+  // This is only set for a partial window partition and always null for a
+  // non-partial one.
+  char* previousRow_{nullptr};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/benchmarks/CMakeLists.txt b/velox/exec/benchmarks/CMakeLists.txt
index 2b45027a6703f..bf4e517f459ee 100644
--- a/velox/exec/benchmarks/CMakeLists.txt
+++ b/velox/exec/benchmarks/CMakeLists.txt
@@ -13,26 +13,85 @@
 # limitations under the License.
 add_executable(velox_exec_vector_hasher_benchmark VectorHasherBenchmark.cpp)
 
-target_link_libraries(velox_exec_vector_hasher_benchmark velox_exec
-                      velox_vector_test_lib ${FOLLY_BENCHMARK})
+target_link_libraries(
+  velox_exec_vector_hasher_benchmark velox_exec velox_vector_test_lib
+  ${FOLLY_BENCHMARK})
 
 add_executable(velox_filter_project_benchmark FilterProjectBenchmark.cpp)
 
 target_link_libraries(
-  velox_filter_project_benchmark velox_exec velox_vector_test_lib
-  velox_exec_test_lib ${FOLLY_BENCHMARK})
+  velox_filter_project_benchmark
+  velox_exec
+  velox_vector_test_lib
+  velox_exec_test_lib
+  ${FOLLY_BENCHMARK})
 
 add_executable(velox_exchange_benchmark ExchangeBenchmark.cpp)
 
-target_link_libraries(velox_exchange_benchmark velox_exec velox_exec_test_lib
-                      velox_vector_test_lib ${FOLLY_BENCHMARK})
+target_link_libraries(
+  velox_exchange_benchmark
+  velox_exec
+  velox_exec_test_lib
+  velox_vector_test_lib
+  ${FOLLY_BENCHMARK})
 
 add_executable(velox_merge_benchmark MergeBenchmark.cpp)
 
-target_link_libraries(velox_merge_benchmark velox_exec velox_vector_test_lib
-                      ${FOLLY_BENCHMARK} gtest gtest_main)
+target_link_libraries(
+  velox_merge_benchmark
+  velox_exec
+  velox_vector_test_lib
+  ${FOLLY_BENCHMARK}
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(velox_hash_benchmark HashTableBenchmark.cpp)
 
-target_link_libraries(velox_hash_benchmark velox_exec velox_exec_test_lib
-                      velox_vector_test_lib ${FOLLY_BENCHMARK})
+target_link_libraries(
+  velox_hash_benchmark
+  velox_exec
+  velox_exec_test_lib
+  velox_vector_test_lib
+  ${FOLLY_BENCHMARK})
+
+add_executable(velox_hash_join_list_result_benchmark
+               HashJoinListResultBenchmark.cpp)
+
+target_link_libraries(
+  velox_hash_join_list_result_benchmark
+  velox_exec
+  velox_exec_test_lib
+  velox_vector_test_lib
+  ${FOLLY_BENCHMARK})
+
+add_executable(velox_hash_join_prepare_join_table_benchmark
+               HashJoinPrepareJoinTableBenchmark.cpp)
+
+target_link_libraries(
+  velox_hash_join_prepare_join_table_benchmark
+  velox_exec
+  velox_exec_test_lib
+  velox_vector_test_lib
+  ${FOLLY_BENCHMARK})
+
+if(${VELOX_ENABLE_PARQUET})
+  add_executable(velox_sort_benchmark RowContainerSortBenchmark.cpp)
+
+  target_link_libraries(
+    velox_sort_benchmark
+    velox_exec
+    velox_exec_test_lib
+    velox_vector_test_lib
+    ${FOLLY_BENCHMARK}
+    arrow
+    thrift)
+endif()
+
+add_executable(velox_prefixsort_benchmark PrefixSortBenchmark.cpp)
+
+target_link_libraries(
+  velox_prefixsort_benchmark
+  velox_exec
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  ${FOLLY_BENCHMARK})
diff --git a/velox/exec/benchmarks/ExchangeBenchmark.cpp b/velox/exec/benchmarks/ExchangeBenchmark.cpp
index e46e4fb2c9c3b..2ac2e27501aae 100644
--- a/velox/exec/benchmarks/ExchangeBenchmark.cpp
+++ b/velox/exec/benchmarks/ExchangeBenchmark.cpp
@@ -40,6 +40,7 @@ DEFINE_int64(
     32,
     "task-wide buffer in local exchange");
 DEFINE_int64(exchange_buffer_mb, 32, "task-wide buffer in remote exchange");
+DEFINE_int32(dict_pct, 0, "Percentage of columns wrapped in dictionary");
 
 /// Benchmarks repartition/exchange with different batch sizes,
 /// numbers of destinations and data type mixes.  Generates a plan
@@ -59,20 +60,46 @@ struct Counters {
   int64_t bytes{0};
   int64_t rows{0};
   int64_t usec{0};
+  int64_t repartitionNanos{0};
+  int64_t exchangeNanos{0};
+  int64_t exchangeRows{0};
+  int64_t exchangeBatches{0};
 
   std::string toString() {
-    return fmt::format("{} MB/s", (bytes / (1024 * 1024.0)) / (usec / 1.0e6));
+    if (exchangeBatches == 0) {
+      return "N/A";
+    }
+    return fmt::format(
+        "{}/s repartition={} exchange={} exchange batch={}",
+        succinctBytes(bytes / (usec / 1.0e6)),
+        succinctNanos(repartitionNanos),
+        succinctNanos(exchangeNanos),
+        exchangeRows / exchangeBatches);
   }
 };
 
 class ExchangeBenchmark : public VectorTestBase {
  public:
-  std::vector<RowVectorPtr>
-  makeRows(RowTypePtr type, int32_t numVectors, int32_t rowsPerVector) {
+  std::vector<RowVectorPtr> makeRows(
+      RowTypePtr type,
+      int32_t numVectors,
+      int32_t rowsPerVector,
+      int32_t dictPct = 0) {
     std::vector<RowVectorPtr> vectors;
+    BufferPtr indices;
     for (int32_t i = 0; i < numVectors; ++i) {
       auto vector = std::dynamic_pointer_cast<RowVector>(
           BatchMaker::createBatch(type, rowsPerVector, *pool_));
+      auto width = vector->childrenSize();
+      for (auto child = 0; child < width; ++child) {
+        if (100 * child / width > dictPct) {
+          if (!indices) {
+            indices = makeIndices(vector->size(), [&](auto i) { return i; });
+          }
+          vector->childAt(child) = BaseVector::wrapInDictionary(
+              nullptr, indices, vector->size(), vector->childAt(child));
+        }
+      }
       vectors.push_back(vector);
     }
     return vectors;
@@ -86,6 +113,7 @@ class ExchangeBenchmark : public VectorTestBase {
     assert(!vectors.empty());
     configSettings_[core::QueryConfig::kMaxPartitionedOutputBufferSize] =
         fmt::format("{}", FLAGS_exchange_buffer_mb << 20);
+    auto iteration = ++iteration_;
     std::vector<std::shared_ptr<Task>> tasks;
     std::vector<std::string> leafTaskIds;
     auto leafPlan = exec::test::PlanBuilder()
@@ -95,11 +123,11 @@ class ExchangeBenchmark : public VectorTestBase {
 
     auto startMicros = getCurrentTimeMicro();
     for (int32_t counter = 0; counter < width; ++counter) {
-      auto leafTaskId = makeTaskId("leaf", counter);
+      auto leafTaskId = makeTaskId(iteration, "leaf", counter);
       leafTaskIds.push_back(leafTaskId);
       auto leafTask = makeTask(leafTaskId, leafPlan, counter);
       tasks.push_back(leafTask);
-      Task::start(leafTask, taskWidth);
+      leafTask->start(taskWidth);
     }
 
     core::PlanNodePtr finalAggPlan;
@@ -112,12 +140,12 @@ class ExchangeBenchmark : public VectorTestBase {
 
     std::vector<exec::Split> finalAggSplits;
     for (int i = 0; i < width; i++) {
-      auto taskId = makeTaskId("final-agg", i);
+      auto taskId = makeTaskId(iteration, "final-agg", i);
       finalAggSplits.push_back(
           exec::Split(std::make_shared<exec::RemoteConnectorSplit>(taskId)));
       auto task = makeTask(taskId, finalAggPlan, i);
       tasks.push_back(task);
-      Task::start(task, taskWidth);
+      task->start(taskWidth);
       addRemoteSplits(task, leafTaskIds);
     }
 
@@ -136,12 +164,23 @@ class ExchangeBenchmark : public VectorTestBase {
         .assertResults(expected);
     auto elapsed = getCurrentTimeMicro() - startMicros;
     int64_t bytes = 0;
+    int64_t repartitionNanos = 0;
+    int64_t exchangeNanos = 0;
+    int64_t exchangeBatches = 0;
+    int64_t exchangeRows = 0;
     for (auto& task : tasks) {
       auto stats = task->taskStats();
       for (auto& pipeline : stats.pipelineStats) {
         for (auto& op : pipeline.operatorStats) {
-          if (op.operatorType == "Exchange") {
+          if (op.operatorType == "PartitionedOutput") {
+            repartitionNanos +=
+                op.addInputTiming.cpuNanos + op.getOutputTiming.cpuNanos;
+          } else if (op.operatorType == "Exchange") {
             bytes += op.rawInputBytes;
+            exchangeRows += op.outputPositions;
+            exchangeBatches += op.outputVectors;
+            exchangeNanos +=
+                op.addInputTiming.cpuNanos + op.getOutputTiming.cpuNanos;
           }
         }
       }
@@ -150,6 +189,10 @@ class ExchangeBenchmark : public VectorTestBase {
     counters.bytes += bytes;
     counters.rows += width * vectors.size() * vectors[0]->size();
     counters.usec += elapsed;
+    counters.repartitionNanos += repartitionNanos;
+    counters.exchangeNanos += exchangeNanos;
+    counters.exchangeRows += exchangeRows;
+    counters.exchangeBatches += exchangeBatches;
   }
 
   void runLocal(
@@ -234,8 +277,9 @@ class ExchangeBenchmark : public VectorTestBase {
  private:
   static constexpr int64_t kMaxMemory = 6UL << 30; // 6GB
 
-  static std::string makeTaskId(const std::string& prefix, int num) {
-    return fmt::format("local://{}-{}", prefix, num);
+  static std::string
+  makeTaskId(int32_t iteration, const std::string& prefix, int num) {
+    return fmt::format("local://{}-{}-{}", iteration, prefix, num);
   }
 
   std::shared_ptr<Task> makeTask(
@@ -245,17 +289,17 @@ class ExchangeBenchmark : public VectorTestBase {
       Consumer consumer = nullptr,
       int64_t maxMemory = kMaxMemory) {
     auto configCopy = configSettings_;
-    auto queryCtx = std::make_shared<core::QueryCtx>(
+    auto queryCtx = core::QueryCtx::create(
         executor_.get(), core::QueryConfig(std::move(configCopy)));
     queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), maxMemory));
+        memory::memoryManager()->addRootPool(queryCtx->queryId(), maxMemory));
     core::PlanFragment planFragment{planNode};
     return Task::create(
         taskId,
         std::move(planFragment),
         destination,
         std::move(queryCtx),
+        Task::ExecutionMode::kParallel,
         std::move(consumer));
   }
 
@@ -292,51 +336,28 @@ class ExchangeBenchmark : public VectorTestBase {
   }
 
   std::unordered_map<std::string, std::string> configSettings_;
+  // Serial number to differentiate consecutive benchmark repeats.
+  static int32_t iteration_;
 };
 
-ExchangeBenchmark bm;
-
-std::vector<RowVectorPtr> flat10k;
-std::vector<RowVectorPtr> deep10k;
-std::vector<RowVectorPtr> flat50;
-std::vector<RowVectorPtr> deep50;
-
-Counters flat10kCounters;
-Counters deep10kCounters;
-Counters flat50Counters;
-Counters deep50Counters;
-Counters localFlat10kCounters;
-
-BENCHMARK(exchangeFlat10k) {
-  bm.run(flat10k, FLAGS_width, FLAGS_task_width, flat10kCounters);
-}
-
-BENCHMARK_RELATIVE(exchangeFlat50) {
-  bm.run(flat50, FLAGS_width, FLAGS_task_width, flat50Counters);
-}
+int32_t ExchangeBenchmark::iteration_;
 
-BENCHMARK(exchangeDeep10k) {
-  bm.run(deep10k, FLAGS_width, FLAGS_task_width, deep10kCounters);
-}
+std::unique_ptr<ExchangeBenchmark> bm;
 
-BENCHMARK_RELATIVE(exchangeDeep50) {
-  bm.run(deep50, FLAGS_width, FLAGS_task_width, deep50Counters);
-}
+void runBenchmarks() {
+  std::vector<RowVectorPtr> flat10k;
+  std::vector<RowVectorPtr> deep10k;
+  std::vector<RowVectorPtr> flat50;
+  std::vector<RowVectorPtr> deep50;
+  std::vector<RowVectorPtr> struct1k;
 
-BENCHMARK(localFlat10k) {
-  bm.runLocal(
-      flat10k, FLAGS_width, FLAGS_num_local_tasks, localFlat10kCounters);
-}
+  Counters flat10kCounters;
+  Counters deep10kCounters;
+  Counters flat50Counters;
+  Counters deep50Counters;
+  Counters localFlat10kCounters;
+  Counters struct1kCounters;
 
-} // namespace
-
-int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
-  functions::prestosql::registerAllScalarFunctions();
-  aggregate::prestosql::registerAllAggregateFunctions();
-  parse::registerTypeResolver();
-  serializer::presto::PrestoVectorSerde::registerVectorSerde();
-  exec::ExchangeSource::registerFactory(exec::test::createLocalExchangeSource);
   std::vector<std::string> flatNames = {"c0"};
   std::vector<TypePtr> flatTypes = {BIGINT()};
   std::vector<TypePtr> typeSelection = {
@@ -365,6 +386,21 @@ int main(int argc, char** argv) {
   }
   auto flatType = ROW(std::move(flatNames), std::move(flatTypes));
 
+  auto structType = ROW(
+      {{"c0", BIGINT()},
+       {"r1",
+        ROW(
+            {{"k2", BIGINT()},
+             {"r2",
+              ROW(
+                  {{"i1", BIGINT()},
+                   {"i2", BIGINT()},
+                   {"r3}, ROW({{s3", VARCHAR()},
+                   {"i5", INTEGER()},
+                   {"d5", DOUBLE()},
+                   {"b5", BOOLEAN()},
+                   {"a5", ARRAY(TINYINT())}})}})}});
+
   auto deepType = ROW(
       {{"c0", BIGINT()},
        {"long_array_val", ARRAY(ARRAY(BIGINT()))},
@@ -375,16 +411,65 @@ int main(int argc, char** argv) {
             MAP(BIGINT(),
                 ROW({{"s2_int", INTEGER()}, {"s2_string", VARCHAR()}})))}});
 
-  flat10k = bm.makeRows(flatType, 10, 10000);
-  deep10k = bm.makeRows(deepType, 10, 10000);
-  flat50 = bm.makeRows(flatType, 2000, 50);
-  deep50 = bm.makeRows(deepType, 2000, 50);
+  flat10k = bm->makeRows(flatType, 10, 10000, FLAGS_dict_pct);
+  deep10k = bm->makeRows(deepType, 10, 10000, FLAGS_dict_pct);
+  flat50 = bm->makeRows(flatType, 2000, 50, FLAGS_dict_pct);
+  deep50 = bm->makeRows(deepType, 2000, 50, FLAGS_dict_pct);
+  struct1k = bm->makeRows(structType, 100, 1000, FLAGS_dict_pct);
+
+  folly::addBenchmark(__FILE__, "exchangeFlat10k", [&]() {
+    bm->run(flat10k, FLAGS_width, FLAGS_task_width, flat10kCounters);
+    return 1;
+  });
+
+  folly::addBenchmark(__FILE__, "exchangeFlat50", [&]() {
+    bm->run(flat50, FLAGS_width, FLAGS_task_width, flat50Counters);
+    return 1;
+  });
+
+  folly::addBenchmark(__FILE__, "exchangeDeep10k", [&]() {
+    bm->run(deep10k, FLAGS_width, FLAGS_task_width, deep10kCounters);
+    return 1;
+  });
+
+  folly::addBenchmark(__FILE__, "exchangeDeep50", [&]() {
+    bm->run(deep50, FLAGS_width, FLAGS_task_width, deep50Counters);
+    return 1;
+  });
+
+  folly::addBenchmark(__FILE__, "exchangeStruct1K", [&]() {
+    bm->run(struct1k, FLAGS_width, FLAGS_task_width, struct1kCounters);
+    return 1;
+  });
+
+  folly::addBenchmark(__FILE__, "localFlat10k", [&]() {
+    bm->runLocal(
+        flat10k, FLAGS_width, FLAGS_num_local_tasks, localFlat10kCounters);
+    return 1;
+  });
 
   folly::runBenchmarks();
   std::cout << "flat10k: " << flat10kCounters.toString() << std::endl
             << "flat50: " << flat50Counters.toString() << std::endl
             << "deep10k: " << deep10kCounters.toString() << std::endl
-            << "deep50: " << deep50Counters.toString() << std::endl;
-  return 0;
+            << "deep50: " << deep50Counters.toString() << std::endl
+            << "struct1k: " << struct1kCounters.toString() << std::endl;
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
+  functions::prestosql::registerAllScalarFunctions();
+  aggregate::prestosql::registerAllAggregateFunctions();
+  parse::registerTypeResolver();
+  serializer::presto::PrestoVectorSerde::registerVectorSerde();
+  exec::ExchangeSource::registerFactory(exec::test::createLocalExchangeSource);
+
+  bm = std::make_unique<ExchangeBenchmark>();
+  runBenchmarks();
+  bm.reset();
+
   return 0;
 }
diff --git a/velox/exec/benchmarks/FilterProjectBenchmark.cpp b/velox/exec/benchmarks/FilterProjectBenchmark.cpp
index fd74c1e8359e0..073c19cc4c8a5 100644
--- a/velox/exec/benchmarks/FilterProjectBenchmark.cpp
+++ b/velox/exec/benchmarks/FilterProjectBenchmark.cpp
@@ -181,7 +181,7 @@ class FilterProjectBenchmark : public VectorTestBase {
       bool shareStringDicts,
       bool stringNulls) {
     assert(!rows.empty());
-    auto type = rows[0]->type()->as<TypeKind::ROW>();
+    auto& type = rows[0]->type()->as<TypeKind::ROW>();
     auto numColumns = rows[0]->type()->size();
     for (auto column = 0; column < numColumns; ++column) {
       if (type.childAt(column)->kind() == TypeKind::VARCHAR) {
@@ -253,9 +253,7 @@ class FilterProjectBenchmark : public VectorTestBase {
 
   int64_t run(std::shared_ptr<const core::PlanNode> plan) {
     auto start = getCurrentTimeMicro();
-    int32_t numRows = 0;
     auto result = exec::test::AssertQueryBuilder(plan).copyResults(pool_.get());
-    numRows += result->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
     auto elapsedMicros = getCurrentTimeMicro() - start;
     return elapsedMicros;
   }
@@ -266,7 +264,7 @@ class FilterProjectBenchmark : public VectorTestBase {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   functions::prestosql::registerAllScalarFunctions();
   aggregate::prestosql::registerAllAggregateFunctions();
   parse::registerTypeResolver();
diff --git a/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp b/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp
new file mode 100644
index 0000000000000..6945900aee890
--- /dev/null
+++ b/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp
@@ -0,0 +1,591 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/HashTable.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+#include <folly/Benchmark.h>
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/init/Init.h>
+#include <iostream>
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::test;
+
+namespace {
+struct HashTableBenchmarkParams {
+  HashTableBenchmarkParams() = default;
+
+  // Benchmark params, we need to provide:
+  //  -the expect hash mode,
+  //  -the build & probe row schema,
+  //  -the expected hash table size,
+  //  -number of probing rows,
+  //  -build key repetition distribution.
+  HashTableBenchmarkParams(
+      BaseHashTable::HashMode mode,
+      const TypePtr& buildType,
+      int64_t hashTableSize,
+      int64_t probeSize,
+      const std::vector<std::pair<int32_t, int32_t>>&
+          keyRepeatTimesDistribution,
+      bool runErase)
+      : mode{mode},
+        buildType{buildType},
+        hashTableSize{hashTableSize},
+        probeSize{probeSize},
+        keyRepeatTimesDistribution{keyRepeatTimesDistribution},
+        runErase{runErase} {
+    int32_t distSum = 0;
+    buildSize = 0;
+    buildKeyRepeat.reserve(keyRepeatTimesDistribution.size());
+    for (auto dist : keyRepeatTimesDistribution) {
+      if (dist.first > 100 || dist.first < 0 || dist.second < 0) {
+        VELOX_FAIL(
+            "Bad distribution: [distribution:{}, key duplicate count:{}]",
+            dist.first,
+            dist.second);
+      }
+      buildSize += (hashTableSize * dist.first / 100) * (dist.second + 1);
+      distSum += dist.first;
+      buildKeyRepeat.emplace_back(
+          std::make_pair(hashTableSize * distSum / 100, dist.second));
+    }
+    VELOX_CHECK_EQ(distSum, 100, "Sum of distributions should be 100");
+
+    if (hashTableSize > BaseHashTable::kArrayHashMaxSize &&
+        mode == BaseHashTable::HashMode::kArray) {
+      VELOX_FAIL("Bad hash mode.");
+    }
+
+    numDependentFields = buildType->size() - 1;
+    if (mode == BaseHashTable::HashMode::kNormalizedKey) {
+      extraValue = BaseHashTable::kArrayHashMaxSize + 100;
+    } else if (mode == BaseHashTable::HashMode::kHash) {
+      extraValue = std::numeric_limits<int64_t>::max() - 1;
+    } else {
+      extraValue = 0;
+    }
+    std::string modeString = mode == BaseHashTable::HashMode::kArray ? "array"
+        : mode == BaseHashTable::HashMode::kHash                     ? "hash"
+                                                 : "normalized key";
+    std::stringstream distStr;
+    for (auto dist : keyRepeatTimesDistribution) {
+      distStr << fmt::format("{}%:{};", dist.first, dist.second);
+    }
+    title = fmt::format(
+        "{},probe:{},buildDist:{}", modeString, probeSize, distStr.str());
+    if (runErase) {
+      title += ",withErase";
+    }
+  }
+
+  // Expected mode.
+  BaseHashTable::HashMode mode;
+
+  // Type of build & probe row.
+  TypePtr buildType;
+
+  // Distinct rows in the table.
+  int64_t hashTableSize;
+
+  // Number of probe rows.
+  int64_t probeSize;
+
+  // Key repeation distribution: {{80, 1}, {20, 0}}: 80% keys have 1
+  // duplication, 20$ keys have no duplication.
+  std::vector<std::pair<int32_t, int32_t>> keyRepeatTimesDistribution;
+
+  bool runErase;
+
+  // Title for reporting
+  std::string title;
+
+  // Number of build rows.
+  int64_t buildSize;
+
+  // This parameter controls the hashing mode. It is incorporated into the keys
+  // on the build side. If the expected mode is an array, its value is 0. If
+  // the expected mode is a normalized key, its value is 'kArrayHashMaxSize' +
+  // 100 to make the key range > 'kArrayHashMaxSize'. If the expected mode is a
+  // hash, its value is the maximum value of int64_t minus 1 to make the key
+  // range  == 'kRangeTooLarge'.
+  int64_t extraValue;
+
+  std::vector<std::pair<int32_t, int32_t>> buildKeyRepeat;
+
+  // Number of dependent fields.
+  int32_t numDependentFields;
+
+  // Number of the tables: 1 top talbe + 7 other tables.
+  int32_t numTables{8};
+
+  std::string toString() const {
+    std::stringstream distStr;
+    for (auto dist : keyRepeatTimesDistribution) {
+      distStr << fmt::format("{}%:{}; ", dist.first, dist.second);
+    }
+    return fmt::format(
+        "HashTableSize:{}, BuildInputSize:{}, ProbeInputSize:{}, ExpectHashMode:{}, KeyRepeatTimesDistribution: {}",
+        hashTableSize,
+        buildSize,
+        probeSize,
+        BaseHashTable::modeString(mode),
+        distStr.str());
+  }
+};
+
+struct HashTableBenchmarkResult {
+  HashTableBenchmarkParams params;
+
+  // Number of output rows after 'listJoinResult'.
+  int64_t numOutput;
+
+  int32_t numIter{1};
+
+  double buildClocks{0};
+
+  double listJoinResultClocks{0};
+
+  double totalClock{0};
+
+  double eraseClock{0};
+
+  uint64_t peakMemoryBytes{0};
+
+  // The mode of the table.
+  BaseHashTable::HashMode hashMode;
+
+  void merge(const HashTableBenchmarkResult& other) {
+    ++numIter;
+    buildClocks += other.buildClocks;
+    listJoinResultClocks += other.listJoinResultClocks;
+    totalClock += other.totalClock;
+    eraseClock += other.eraseClock;
+    peakMemoryBytes += other.peakMemoryBytes;
+  }
+
+  std::string toString() const {
+    std::stringstream out;
+    out << params.toString();
+    out << std::endl
+        << " mode=" << BaseHashTable::modeString(hashMode)
+        << " numOutput=" << numOutput << " totalClock=" << totalClock
+        << " listJoinResultClocks=" << listJoinResultClocks << "("
+        << (listJoinResultClocks / totalClock * 100)
+        << "%) buildClocks=" << buildClocks << "("
+        << (buildClocks / totalClock * 100) << "%)"
+        << " peakMemoryBytes=" << succinctBytes(peakMemoryBytes);
+    if (params.runErase) {
+      out << " eraseClock=" << eraseClock << "("
+          << (eraseClock / totalClock * 100) << "%)";
+    }
+    return out.str();
+  }
+};
+
+class HashTableListJoinResultBenchmark : public VectorTestBase {
+ public:
+  HashTableListJoinResultBenchmark()
+      : randomEngine_((std::random_device{}())) {}
+
+  HashTableBenchmarkResult run(HashTableBenchmarkParams params) {
+    std::shared_ptr<memory::MemoryPool> tableAggregatePool =
+        rootPool_->addAggregateChild("tableAggregate");
+    std::vector<std::shared_ptr<memory::MemoryPool>> tablePools;
+    tablePools.reserve(params.numTables);
+    for (int i = 0; i < params_.numTables; ++i) {
+      tablePools.push_back(
+          tableAggregatePool->addLeafChild(fmt::format("table{}", i)));
+    }
+    params_ = params;
+    HashTableBenchmarkResult result;
+    result.params = params_;
+    uint64_t totalClocks{0};
+    {
+      ClockTimer timer(totalClocks);
+      buildTable(tablePools);
+      result.numOutput = probeTableAndListResult();
+      result.hashMode = topTable_->hashMode();
+      VELOX_CHECK_EQ(result.hashMode, params_.mode);
+      if (params.runErase) {
+        eraseTable();
+        result.eraseClock += eraseTime_;
+      }
+      topTable_.reset();
+    }
+    result.buildClocks += buildTime_;
+    result.listJoinResultClocks += listJoinResultTime_;
+    result.totalClock = totalClocks;
+    result.peakMemoryBytes = tableAggregatePool->peakBytes();
+    return result;
+  }
+
+ private:
+  // Generate buiild key based on current key and key repetition distribution.
+  int64_t getBuildKey(int64_t& buildKey, int32_t& iterTimes, int32_t& repeat) {
+    if (iterTimes >= repeat) {
+      iterTimes = 0;
+      buildKey++;
+      for (auto iter : params_.buildKeyRepeat) {
+        if (buildKey < iter.first) {
+          repeat = iter.second;
+          break;
+        }
+      }
+    } else {
+      iterTimes++;
+    }
+    return buildKey;
+  }
+
+  // Create the row vector for the build side, where the first column is used
+  // as the join key, and the remaining columns are dependent fields.
+  // If expect mode is array, the key is within the range [0, hashTableSize];
+  // If expect mode is normalized key, the key is within the range
+  // [0, hashTableSize] + extraValue(kArrayHashMaxSize + 100);
+  // If expect mode is hash, the key is within the range [0, hashTableSize] +
+  // extraValue(max_int64 -1);
+  RowVectorPtr makeBuildRows(
+      int64_t maxKey,
+      bool addExtraValue,
+      int64_t& buildKey,
+      int32_t& iterTimes,
+      int32_t& repeat) {
+    std::vector<int64_t> data;
+    while (buildKey < maxKey) {
+      auto key = getBuildKey(buildKey, iterTimes, repeat);
+      data.emplace_back(key);
+    }
+    if (addExtraValue) {
+      data[0] = params_.extraValue;
+    }
+
+    std::shuffle(data.begin(), data.end(), randomEngine_);
+    std::vector<VectorPtr> children;
+    children.push_back(makeFlatVector<int64_t>(data));
+    for (int32_t i = 0; i < params_.numDependentFields; ++i) {
+      children.push_back(makeFlatVector<int64_t>(
+          data.size(),
+          [&](vector_size_t row) { return row + maxKey; },
+          nullptr));
+    }
+    return makeRowVector(children);
+  }
+
+  // Generate the build side data batches, one batch pre table.
+  void makeBuildBatches(std::vector<RowVectorPtr>& batches) {
+    int64_t buildKey = -1;
+    int32_t iterTimes = 0;
+    int32_t repeat = 0;
+    int64_t maxKey = 0;
+    for (auto i = 0; i < params_.numTables; ++i) {
+      if (i == params_.numTables - 1) {
+        maxKey = params_.hashTableSize;
+      } else {
+        maxKey += params_.hashTableSize / params_.numTables;
+      }
+      batches.push_back(makeBuildRows(
+          maxKey, i == params_.numTables - 1, buildKey, iterTimes, repeat));
+    }
+  }
+
+  // Create the row vector for the probe side, where the first column is used
+  // as the join key, and the remaining columns are dependent fields.
+  // Probe key is within the range [0, hashTableSize].
+  RowVectorPtr
+  makeProbeVector(int32_t size, int64_t hashTableSize, int64_t& sequence) {
+    std::vector<VectorPtr> children;
+    children.push_back(makeFlatVector<int64_t>(
+        size,
+        [&](vector_size_t row) { return (sequence + row) % hashTableSize; },
+        nullptr));
+    sequence += size;
+    for (int32_t i = 0; i < params_.numDependentFields; ++i) {
+      children.push_back(makeFlatVector<int64_t>(
+          size, [&](vector_size_t row) { return row + size; }, nullptr));
+    }
+    return makeRowVector(children);
+  }
+
+  void copyVectorsToTable(RowVectorPtr batch, BaseHashTable* table) {
+    int32_t batchSize = batch->size();
+    raw_vector<uint64_t> dummy(batchSize);
+    auto rowContainer = table->rows();
+    auto& hashers = table->hashers();
+    auto numKeys = hashers.size();
+    auto numDependentFields = batch->childrenSize() - numKeys;
+
+    std::vector<DecodedVector> decoders;
+    decoders.reserve(numDependentFields);
+    SelectivityVector rows(batchSize);
+
+    for (auto i = 0; i < batch->childrenSize(); ++i) {
+      if (i < numKeys) {
+        auto hasher = table->hashers()[i].get();
+        hasher->decode(*batch->childAt(i), rows);
+        if (table->hashMode() != BaseHashTable::HashMode::kHash &&
+            hasher->mayUseValueIds()) {
+          hasher->computeValueIds(rows, dummy);
+        }
+      } else {
+        decoders[i - numKeys].decode(*batch->childAt(i), rows);
+      }
+    }
+    rows.applyToSelected([&](auto rowIndex) {
+      char* newRow = rowContainer->newRow();
+      *reinterpret_cast<char**>(newRow + rowContainer->nextOffset()) = nullptr;
+      for (auto i = 0; i < numKeys; ++i) {
+        rowContainer->store(hashers[i]->decodedVector(), rowIndex, newRow, i);
+      }
+      for (auto i = 0; i < numDependentFields; ++i) {
+        rowContainer->store(decoders[i], rowIndex, newRow, i + numKeys);
+      }
+    });
+  }
+
+  // Prepare join table.
+  void buildTable(
+      const std::vector<std::shared_ptr<memory::MemoryPool>>& tablePools) {
+    std::vector<TypePtr> dependentTypes;
+    std::vector<std::unique_ptr<BaseHashTable>> otherTables;
+    std::vector<RowVectorPtr> batches;
+    makeBuildBatches(batches);
+    for (auto i = 0; i < params_.numTables; ++i) {
+      std::vector<std::unique_ptr<VectorHasher>> keyHashers;
+      keyHashers.emplace_back(
+          std::make_unique<VectorHasher>(params_.buildType->childAt(0), 0));
+      auto table = HashTable<true>::createForJoin(
+          std::move(keyHashers),
+          dependentTypes,
+          true,
+          false,
+          1'000,
+          tablePools[i].get());
+
+      copyVectorsToTable(batches[i], table.get());
+      if (i == 0) {
+        topTable_ = std::move(table);
+      } else {
+        otherTables.push_back(std::move(table));
+      }
+    }
+    uint64_t buildClocks{0};
+    {
+      ClockTimer timer(buildClocks);
+      topTable_->prepareJoinTable(
+          std::move(otherTables),
+          BaseHashTable::kNoSpillInputStartPartitionBit,
+          executor_.get());
+    }
+    buildTime_ = buildClocks;
+  }
+
+  void probeTable(
+      HashLookup& lookup,
+      const RowVectorPtr& batch,
+      const int64_t batchSize) {
+    auto& hashers = topTable_->hashers();
+    auto mode = topTable_->hashMode();
+    SelectivityVector rows(batchSize);
+    VectorHasher::ScratchMemory scratchMemory;
+    lookup.reset(batch->size());
+    for (auto i = 0; i < hashers.size(); ++i) {
+      auto key = batch->childAt(i);
+      if (mode != BaseHashTable::HashMode::kHash) {
+        hashers[i]->lookupValueIds(*key, rows, scratchMemory, lookup.hashes);
+      } else {
+        hashers[i]->decode(*key, rows);
+        hashers[i]->hash(rows, i > 0, lookup.hashes);
+      }
+    }
+    lookup.rows.resize(rows.size());
+    std::iota(lookup.rows.begin(), lookup.rows.end(), 0);
+    topTable_->joinProbe(lookup);
+  }
+
+  BaseHashTable::JoinResultIterator createResultIterator() {
+    std::vector<vector_size_t> listColumns{};
+    for (int32_t i = 0; i < topTable_->rows()->columnTypes().size(); i++) {
+      listColumns.push_back(i);
+    }
+    std::vector<vector_size_t> varSizeListColumns;
+    uint64_t fixedSizeListColumnsSizeSum{0};
+    varSizeListColumns.reserve(listColumns.size());
+    for (const auto column : listColumns) {
+      if (topTable_->rows()->columnTypes()[column]->isFixedWidth()) {
+        fixedSizeListColumnsSizeSum += topTable_->rows()->fixedSizeAt(column);
+      } else {
+        varSizeListColumns.push_back(column);
+      }
+    }
+    return BaseHashTable::JoinResultIterator(
+        std::move(varSizeListColumns), fixedSizeListColumnsSizeSum);
+  }
+
+  // Hash probe and list join result.
+  int64_t probeTableAndListResult() {
+    auto lookup = std::make_unique<HashLookup>(topTable_->hashers());
+    const auto numBatch = params_.probeSize / params_.hashTableSize;
+    const auto batchSize = params_.hashTableSize;
+    BufferPtr outputRowMapping;
+    auto outputBatchSize = batchSize;
+    std::vector<char*> outputTableRows;
+    int64_t sequence = 0;
+    int64_t numJoinListResult = 0;
+    BaseHashTable::JoinResultIterator resultsIter = createResultIterator();
+    for (auto i = 0; i < numBatch; ++i) {
+      auto batch = makeProbeVector(batchSize, params_.hashTableSize, sequence);
+      probeTable(*lookup, batch, batchSize);
+      resultsIter.reset(*lookup);
+      auto mapping = initializeRowNumberMapping(
+          outputRowMapping, outputBatchSize, pool_.get());
+      outputTableRows.resize(outputBatchSize);
+      uint64_t listJoinResultClocks{0};
+      {
+        ClockTimer timer(listJoinResultClocks);
+        while (!resultsIter.atEnd()) {
+          numJoinListResult += topTable_->listJoinResults(
+              resultsIter,
+              false,
+              mapping,
+              folly::Range(outputTableRows.data(), outputTableRows.size()),
+              std::numeric_limits<uint64_t>::max());
+        }
+      }
+      listJoinResultTime_ += listJoinResultClocks;
+    }
+    return numJoinListResult;
+  }
+
+  void eraseTable() {
+    auto lookup = std::make_unique<HashLookup>(topTable_->hashers());
+    auto batchSize = 10000;
+    auto mode = topTable_->hashMode();
+    BufferPtr outputRowMapping;
+    auto outputBatchSize = topTable_->rows()->numRows() + 2;
+    std::vector<char*> outputTableRows;
+    int64_t sequence = 0;
+    auto batch = makeProbeVector(batchSize, batchSize, sequence);
+    probeTable(*lookup, batch, batchSize);
+    auto mapping = initializeRowNumberMapping(
+        outputRowMapping, outputBatchSize, pool_.get());
+    outputTableRows.resize(outputBatchSize);
+    BaseHashTable::JoinResultIterator resultIter = createResultIterator();
+    resultIter.reset(*lookup);
+    auto num = topTable_->listJoinResults(
+        resultIter,
+        false,
+        mapping,
+        folly::Range(outputTableRows.data(), outputTableRows.size()),
+        std::numeric_limits<uint64_t>::max());
+    uint64_t eraseClocks{0};
+    {
+      ClockTimer timer(eraseClocks);
+      topTable_->rows()->eraseRows(
+          folly::Range<char**>(outputTableRows.data(), num));
+    }
+    eraseTime_ = eraseClocks;
+  }
+
+  std::default_random_engine randomEngine_;
+  std::unique_ptr<HashTable<true>> topTable_;
+  HashTableBenchmarkParams params_;
+
+  double buildTime_{0};
+  double eraseTime_{0};
+  double listJoinResultTime_{0};
+};
+
+void combineResults(
+    std::vector<HashTableBenchmarkResult>& results,
+    HashTableBenchmarkResult run) {
+  if (!results.empty() && results.back().params.title == run.params.title) {
+    results.back().merge(run);
+    return;
+  }
+  results.push_back(run);
+}
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManagerOptions options;
+  options.useMmapAllocator = true;
+  options.allocatorCapacity = 10UL << 30;
+  options.useMmapArena = true;
+  options.mmapArenaCapacityRatio = 1;
+  memory::MemoryManager::initialize(options);
+
+  auto bm = std::make_unique<HashTableListJoinResultBenchmark>();
+  std::vector<HashTableBenchmarkResult> results;
+
+  auto hashTableSize = (2L << 20) - 3;
+  auto probeRowSize = 100000000L;
+
+  TypePtr onlyKeyType{ROW({"k1"}, {BIGINT()})};
+
+  TypePtr keyAndDependentType{
+      ROW({"k1", "d1", "d2"}, {BIGINT(), BIGINT(), BIGINT()})};
+
+  std::vector<BaseHashTable::HashMode> hashModes = {
+      BaseHashTable::HashMode::kArray,
+      BaseHashTable::HashMode::kNormalizedKey,
+      BaseHashTable::HashMode::kHash};
+
+  std::vector<std::vector<std::pair<int32_t, int32_t>>> keyRepeatDists = {
+      // 20% of the rows are repeated only once, and 80% of the rows are not
+      // repeated.
+      {{20, 1}, {80, 0}},
+      {{20, 5}, {80, 0}},
+      {{20, 10}, {80, 0}},
+      {{20, 20}, {80, 0}},
+      {{20, 50}, {80, 0}},
+      {{10, 5}, {10, 1}, {80, 0}},
+      {{10, 10}, {10, 5}, {10, 1}, {70, 0}},
+      {{10, 20}, {10, 10}, {10, 5}, {10, 1}, {60, 0}},
+      {{10, 50}, {10, 20}, {10, 10}, {10, 5}, {10, 1}, {50, 0}},
+      {{100, 1}},
+      {{100, 5}},
+      {{100, 10}},
+      {{100, 15}},
+      {{100, 20}},
+      {{100, 25}}};
+  std::vector<HashTableBenchmarkParams> params;
+  for (auto withErase : {false, true}) {
+    for (auto mode : hashModes) {
+      for (auto& dist : keyRepeatDists) {
+        params.emplace_back(HashTableBenchmarkParams(
+            mode, onlyKeyType, hashTableSize, probeRowSize, dist, withErase));
+      }
+    }
+  }
+
+  for (auto& param : params) {
+    folly::addBenchmark(__FILE__, param.title, [param, &bm, &results]() {
+      combineResults(results, bm->run(param));
+      return 1;
+    });
+  }
+  folly::runBenchmarks();
+  std::cout << "*** Results:" << std::endl;
+  for (auto& result : results) {
+    std::cout << result.toString() << std::endl;
+  }
+  return 0;
+}
diff --git a/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp b/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp
new file mode 100644
index 0000000000000..bd3d3d54323a7
--- /dev/null
+++ b/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp
@@ -0,0 +1,327 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/HashTable.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+#include <folly/Benchmark.h>
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/init/Init.h>
+#include <iostream>
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::test;
+
+namespace {
+struct HashTableBenchmarkParams {
+  HashTableBenchmarkParams() = default;
+
+  // Benchmark params, we need to provide:
+  //  -the expect hash mode,
+  //  -the build row schema,
+  //  -the expected hash table size,
+  //  -number of building rows,
+  //  -number of build RowContainers.
+  HashTableBenchmarkParams(
+      BaseHashTable::HashMode mode,
+      const TypePtr& buildType,
+      int64_t hashTableSize,
+      int64_t buildSize,
+      int32_t numWays)
+      : mode{mode},
+        buildType{buildType},
+        hashTableSize{hashTableSize},
+        buildSize{buildSize},
+        numWays{numWays} {
+    VELOX_CHECK_LE(hashTableSize, buildSize);
+    VELOX_CHECK_GE(numWays, 1);
+
+    if (hashTableSize > BaseHashTable::kArrayHashMaxSize &&
+        mode == BaseHashTable::HashMode::kArray) {
+      VELOX_FAIL("Bad hash mode.");
+    }
+
+    numFields = buildType->size();
+    if (mode == BaseHashTable::HashMode::kNormalizedKey) {
+      extraValue = BaseHashTable::kArrayHashMaxSize + 100;
+    } else if (mode == BaseHashTable::HashMode::kHash) {
+      extraValue = std::numeric_limits<int64_t>::max() - 1;
+    } else {
+      extraValue = 0;
+    }
+
+    title = fmt::format(
+        "Size:{},parallel:{},withDup:{},{}",
+        buildSize,
+        numWays > 1,
+        buildSize > hashTableSize,
+        BaseHashTable::modeString(mode));
+  }
+
+  // Expected mode.
+  BaseHashTable::HashMode mode;
+
+  // Type of build & probe row.
+  TypePtr buildType;
+
+  // Distinct rows in the table.
+  int64_t hashTableSize;
+
+  // Number of build rows.
+  int64_t buildSize;
+
+  // Number of build RowContainers.
+  int32_t numWays;
+
+  // Title for reporting
+  std::string title;
+
+  // This parameter controls the hashing mode. It is incorporated into the keys
+  // on the build side. If the expected mode is an array, its value is 0. If
+  // the expected mode is a normalized key, its value is 'kArrayHashMaxSize' +
+  // 100 to make the key range > 'kArrayHashMaxSize'. If the expected mode is a
+  // hash, its value is the maximum value of int64_t minus 1 to make the key
+  // range  == 'kRangeTooLarge'.
+  int64_t extraValue;
+
+  // Number of fields.
+  int32_t numFields;
+
+  std::string toString() const {
+    return fmt::format(
+        "HashTableSize:{}, BuildInputSize:{}, ExpectHashMode:{}",
+        hashTableSize,
+        buildSize,
+        BaseHashTable::modeString(mode));
+  }
+};
+
+class HashJoinPrepareJoinTableBenchmark : public VectorTestBase {
+ public:
+  HashJoinPrepareJoinTableBenchmark()
+      : randomEngine_((std::random_device{}())) {}
+
+  // Create join tables.
+  void prepare(HashTableBenchmarkParams params) {
+    params_ = params;
+    topTable_.reset();
+    otherTables_.clear();
+    createTable();
+  }
+
+  // Run 'prepareJoinTable'.
+  void run() {
+    topTable_->prepareJoinTable(
+        std::move(otherTables_),
+        BaseHashTable::kNoSpillInputStartPartitionBit,
+        executor_.get());
+    VELOX_CHECK_EQ(topTable_->hashMode(), params_.mode);
+  }
+
+ private:
+  // Create the row vector for the build side, where the first column is used
+  // as the join key, and the remaining columns are dependent fields.
+  // If expect mode is array, the key is within the range [0, hashTableSize];
+  // If expect mode is normalized key, the key is within the range
+  // [0, hashTableSize] + extraValue(kArrayHashMaxSize + 100);
+  // If expect mode is hash, the key is within the range [0, hashTableSize] +
+  // extraValue(max_int64 -1);
+  RowVectorPtr makeBuildRows(
+      int64_t numKeys,
+      int64_t maxKey,
+      int64_t& buildKey,
+      bool addExtraValue) {
+    std::vector<int64_t> data;
+    auto makeData = [&]() {
+      data.clear();
+      for (auto i = 0; i < numKeys; ++i) {
+        data.emplace_back((buildKey++) % maxKey);
+      }
+      if (addExtraValue) {
+        data[0] = params_.extraValue;
+      }
+      std::shuffle(data.begin(), data.end(), randomEngine_);
+    };
+
+    std::vector<VectorPtr> children;
+    for (int32_t i = 0; i < params_.numFields; ++i) {
+      makeData();
+      children.push_back(makeFlatVector<int64_t>(data));
+    }
+    return makeRowVector(children);
+  }
+
+  // Generate the build side data batches, one batch pre table.
+  void makeBuildBatches(std::vector<RowVectorPtr>& batches) {
+    int64_t buildKey = 0;
+    for (auto i = 0; i < params_.numWays; ++i) {
+      batches.push_back(makeBuildRows(
+          params_.buildSize / params_.numWays,
+          params_.hashTableSize,
+          buildKey,
+          i == params_.numWays - 1));
+    }
+  }
+
+  void copyVectorsToTable(RowVectorPtr batch, BaseHashTable* table) {
+    int32_t batchSize = batch->size();
+    raw_vector<uint64_t> dummy(batchSize);
+    auto rowContainer = table->rows();
+    auto& hashers = table->hashers();
+    auto numKeys = hashers.size();
+    SelectivityVector rows(batchSize);
+
+    for (auto i = 0; i < batch->childrenSize(); ++i) {
+      auto hasher = table->hashers()[i].get();
+      hasher->decode(*batch->childAt(i), rows);
+      if (table->hashMode() != BaseHashTable::HashMode::kHash &&
+          hasher->mayUseValueIds()) {
+        hasher->computeValueIds(rows, dummy);
+      }
+    }
+    rows.applyToSelected([&](auto rowIndex) {
+      char* newRow = rowContainer->newRow();
+      *reinterpret_cast<char**>(newRow + rowContainer->nextOffset()) = nullptr;
+      for (auto i = 0; i < numKeys; ++i) {
+        rowContainer->store(hashers[i]->decodedVector(), rowIndex, newRow, i);
+      }
+    });
+  }
+
+  // Create join table.
+  void createTable() {
+    std::vector<TypePtr> dependentTypes;
+    std::vector<RowVectorPtr> batches;
+    makeBuildBatches(batches);
+    for (auto i = 0; i < params_.numWays; ++i) {
+      std::vector<std::unique_ptr<VectorHasher>> keyHashers;
+      for (int j = 0; j < params_.numFields; ++j) {
+        keyHashers.emplace_back(
+            std::make_unique<VectorHasher>(params_.buildType->childAt(j), j));
+      }
+      auto table = HashTable<true>::createForJoin(
+          std::move(keyHashers),
+          dependentTypes,
+          true,
+          false,
+          1'000,
+          pool_.get());
+
+      copyVectorsToTable(batches[i], table.get());
+      if (i == 0) {
+        topTable_ = std::move(table);
+      } else {
+        otherTables_.push_back(std::move(table));
+      }
+    }
+  }
+
+  std::default_random_engine randomEngine_;
+  std::unique_ptr<HashTable<true>> topTable_;
+  std::vector<std::unique_ptr<BaseHashTable>> otherTables_;
+  HashTableBenchmarkParams params_;
+};
+
+void initArrayModeBenchmarkParams(
+    std::vector<HashTableBenchmarkParams>& params) {
+  TypePtr oneKeyType{ROW({"k1"}, {BIGINT()})};
+  std::vector<int64_t> buildSizeVector = {100000, (2L << 20) - 3};
+  std::vector<int64_t> numTablesVector = {1, 8};
+  std::vector<int64_t> dupFactorVector = {1, 8};
+  for (auto buildSize : buildSizeVector) {
+    for (auto dupFactor : dupFactorVector) {
+      for (auto numTables : numTablesVector) {
+        params.push_back(HashTableBenchmarkParams(
+            BaseHashTable::HashMode::kArray,
+            oneKeyType,
+            buildSize / dupFactor,
+            buildSize,
+            numTables));
+      }
+    }
+  }
+}
+
+void initNormalizedKeyModeBenchmarkParams(
+    std::vector<HashTableBenchmarkParams>& params) {
+  TypePtr twoKeyType{ROW({"k1", "k2"}, {BIGINT(), BIGINT()})};
+  std::vector<int64_t> buildSizeVector = {100000, (2L << 20) - 3, 2L << 23};
+  std::vector<int64_t> numTablesVector = {1, 8};
+  std::vector<int64_t> dupFactorVector = {1, 8};
+  for (auto buildSize : buildSizeVector) {
+    for (auto dupFactor : dupFactorVector) {
+      for (auto numTables : numTablesVector) {
+        params.push_back(HashTableBenchmarkParams(
+            BaseHashTable::HashMode::kNormalizedKey,
+            twoKeyType,
+            buildSize / dupFactor,
+            buildSize,
+            numTables));
+      }
+    }
+  }
+}
+
+void initHashModeBenchmarkParams(
+    std::vector<HashTableBenchmarkParams>& params) {
+  TypePtr threeKeyType{ROW({"k1", "k2", "k3"}, {BIGINT(), BIGINT(), BIGINT()})};
+  std::vector<int64_t> buildSizeVector = {(2L << 20) - 3, 2L << 23};
+  std::vector<int64_t> numTablesVector = {1, 8};
+  std::vector<int64_t> dupFactorVector = {1, 8};
+  for (auto buildSize : buildSizeVector) {
+    for (auto dupFactor : dupFactorVector) {
+      for (auto numTables : numTablesVector) {
+        params.push_back(HashTableBenchmarkParams(
+            BaseHashTable::HashMode::kHash,
+            threeKeyType,
+            buildSize / dupFactor,
+            buildSize,
+            numTables));
+      }
+    }
+  }
+}
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManagerOptions options;
+  options.useMmapAllocator = true;
+  options.allocatorCapacity = 10UL << 30;
+  options.useMmapArena = true;
+  options.mmapArenaCapacityRatio = 1;
+  memory::MemoryManager::initialize(options);
+
+  auto bm = std::make_unique<HashJoinPrepareJoinTableBenchmark>();
+  std::vector<HashTableBenchmarkParams> params;
+  // initArrayModeBenchmarkParams(params);
+  initNormalizedKeyModeBenchmarkParams(params);
+  initHashModeBenchmarkParams(params);
+
+  for (auto& param : params) {
+    folly::addBenchmark(__FILE__, param.title, [param, &bm]() {
+      folly::BenchmarkSuspender suspender;
+      bm->prepare(param);
+      suspender.dismiss();
+      bm->run();
+      return 1;
+    });
+  }
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/benchmarks/HashTableBenchmark.cpp b/velox/exec/benchmarks/HashTableBenchmark.cpp
index e7a8c73c85a22..12a60562683b6 100644
--- a/velox/exec/benchmarks/HashTableBenchmark.cpp
+++ b/velox/exec/benchmarks/HashTableBenchmark.cpp
@@ -28,12 +28,18 @@
 #include <gtest/gtest.h>
 #include <memory>
 
+#include "velox/common/process/Profiler.h"
+
 DEFINE_int64(custom_size, 0, "Custom number of entries");
 DEFINE_int32(custom_hit_rate, 0, "Percentage of hits in custom test");
 DEFINE_int32(custom_key_spacing, 1, "Spacing between key values");
 
 DEFINE_int32(custom_num_ways, 10, "Number of build threads");
 
+DEFINE_bool(profile, false, "Generate perf profiles and memory stats");
+
+DECLARE_bool(velox_time_allocations);
+
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::test;
@@ -189,7 +195,10 @@ class HashTableBenchmark : public VectorTestBase {
       batches_.insert(batches_.end(), batches.begin(), batches.end());
       startOffset += params_.size;
     }
-    topTable_->prepareJoinTable(std::move(otherTables), executor_.get());
+    topTable_->prepareJoinTable(
+        std::move(otherTables),
+        BaseHashTable::kNoSpillInputStartPartitionBit,
+        executor_.get());
     LOG(INFO) << "Made table " << topTable_->toString();
 
     if (topTable_->hashMode() == BaseHashTable::HashMode::kNormalizedKey) {
@@ -263,12 +272,13 @@ class HashTableBenchmark : public VectorTestBase {
 
     if (rehash) {
       if (table.hashMode() != BaseHashTable::HashMode::kHash) {
-        table.decideHashMode(input.size());
+        table.decideHashMode(
+            input.size(), BaseHashTable::kNoSpillInputStartPartitionBit);
       }
       insertGroups(input, rows, lookup, table);
       return;
     }
-    table.groupProbe(lookup);
+    table.groupProbe(lookup, BaseHashTable::kNoSpillInputStartPartitionBit);
   }
 
   void copyVectorsToTable(
@@ -321,7 +331,6 @@ class HashTableBenchmark : public VectorTestBase {
     int32_t mask = powerOfTwo - 1;
     int32_t position = 0;
     int32_t delta = 1;
-    int32_t numInserted = 0;
     auto nextOffset = rowContainer->nextOffset();
 
     // We insert values in a geometric skip order. 1, 2, 4, 7,
@@ -340,7 +349,6 @@ class HashTableBenchmark : public VectorTestBase {
         if (nextOffset) {
           *reinterpret_cast<char**>(newRow + nextOffset) = nullptr;
         }
-        ++numInserted;
         for (auto i = 0; i < batches[batchIndex]->type()->size(); ++i) {
           rowContainer->store(decoded[batchIndex][i], rowIndex, newRow, i);
         }
@@ -560,9 +568,10 @@ class HashTableBenchmark : public VectorTestBase {
         << std::endl;
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  std::unique_ptr<test::VectorMaker> vectorMaker_{
-      std::make_unique<test::VectorMaker>(pool_.get())};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  std::unique_ptr<VectorMaker> vectorMaker_{
+      std::make_unique<VectorMaker>(pool_.get())};
   // Bitmap of positions in batches_ that end up in the table.
   std::vector<uint64_t> isInTable_;
   // Test payload, keys first.
@@ -611,18 +620,25 @@ void combineResults(
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
-  memory::MmapAllocator::Options options;
-  options.capacity = 10UL << 30;
+  folly::Init init{&argc, &argv};
+  memory::MemoryManagerOptions options;
+  options.useMmapAllocator = true;
+  options.allocatorCapacity = 10UL << 30;
   options.useMmapArena = true;
   options.mmapArenaCapacityRatio = 1;
-
-  auto allocator = std::make_shared<memory::MmapAllocator>(options);
-  memory::MemoryAllocator::setDefaultInstance(allocator.get());
-  memory::MemoryManager::getInstance(memory::MemoryManagerOptions{
-      .capacity = static_cast<int64_t>(options.capacity),
-      .allocator = allocator.get()});
-
+  memory::MemoryManager::initialize(options);
+  if (FLAGS_profile) {
+    auto allocator = memory::MemoryManager::getInstance()->allocator();
+    std::function<void()> reportInit;
+    std::function<std::string()> report;
+    allocator->getTracingHooks(reportInit, report, nullptr);
+    FLAGS_profiler_check_interval_seconds = 20;
+    FLAGS_profiler_min_cpu_pct = 50;
+    FLAGS_profiler_max_sample_seconds = 30;
+    FLAGS_velox_time_allocations = true;
+    filesystems::registerLocalFileSystem();
+    process::Profiler::start("/tmp/hashprof", reportInit, report);
+  }
   auto bm = std::make_unique<HashTableBenchmark>();
   std::vector<HashTableBenchmarkRun> results;
 
diff --git a/velox/exec/benchmarks/MergeBenchmark.cpp b/velox/exec/benchmarks/MergeBenchmark.cpp
index e44819e57c8e3..cb8e8dba2c976 100644
--- a/velox/exec/benchmarks/MergeBenchmark.cpp
+++ b/velox/exec/benchmarks/MergeBenchmark.cpp
@@ -54,7 +54,7 @@ BENCHMARK_RELATIVE(wideArray) {
 }
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   MergeTestBase test;
   test.seed(1);
diff --git a/velox/exec/benchmarks/PrefixSortBenchmark.cpp b/velox/exec/benchmarks/PrefixSortBenchmark.cpp
new file mode 100644
index 0000000000000..0af6a9f90bdf9
--- /dev/null
+++ b/velox/exec/benchmarks/PrefixSortBenchmark.cpp
@@ -0,0 +1,393 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "glog/logging.h"
+#include "velox/exec/PrefixSort.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+namespace {
+
+class TestCase {
+ public:
+  TestCase(
+      memory::MemoryPool* pool,
+      const std::string& testName,
+      size_t numRows,
+      const RowTypePtr& rowType,
+      int numKeys)
+      : testName_(testName), numRows_(numRows), pool_(pool), rowType_(rowType) {
+    // Initialize a RowContainer that holds fuzzed rows to be sorted.
+    std::vector<TypePtr> keyTypes;
+    std::vector<TypePtr> dependentTypes;
+    for (auto i = 0; i < rowType->size(); ++i) {
+      if (i < numKeys) {
+        keyTypes.push_back(rowType->childAt(i));
+      } else {
+        dependentTypes.push_back(rowType->childAt(i));
+      }
+    }
+    data_ = std::make_unique<RowContainer>(keyTypes, dependentTypes, pool);
+    RowVectorPtr sortedRows = fuzzRows(numRows, numKeys);
+    storeRows(numRows, sortedRows);
+
+    // Initialize CompareFlags, it could be same for each key in benchmark.
+    for (int i = 0; i < numKeys; ++i) {
+      compareFlags_.push_back(
+          {true, true, false, CompareFlags::NullHandlingMode::kNullAsValue});
+    }
+  };
+
+  const std::string& testName() const {
+    return testName_;
+  }
+
+  size_t numRows() const {
+    return numRows_;
+  }
+
+  const std::vector<char*>& rows() const {
+    return rows_;
+  }
+
+  RowContainer* rowContainer() const {
+    return data_.get();
+  }
+
+  const std::vector<CompareFlags>& compareFlags() const {
+    return compareFlags_;
+  }
+
+ private:
+  // Store data into the RowContainer to mock the behavior of SortBuffer.
+  void storeRows(int numRows, const RowVectorPtr& data) {
+    rows_.resize(numRows);
+    for (auto row = 0; row < numRows; ++row) {
+      rows_[row] = rowContainer()->newRow();
+    }
+    for (auto column = 0; column < data->childrenSize(); ++column) {
+      DecodedVector decoded(*data->childAt(column));
+      rowContainer()->store(
+          decoded, folly::Range(rows_.data(), numRows), column);
+    }
+  }
+
+  RowVectorPtr fuzzRows(size_t numRows, int numKeys) {
+    VectorFuzzer fuzzer({.vectorSize = numRows}, pool_);
+    VectorFuzzer fuzzerWithNulls(
+        {.vectorSize = numRows, .nullRatio = 0.7}, pool_);
+    std::vector<VectorPtr> children;
+
+    // Fuzz keys: for front keys (column 0 to numKeys -2) use high
+    // nullRatio to enforce all columns to be compared.
+    {
+      for (auto i = 0; i < numKeys - 1; ++i) {
+        children.push_back(fuzzerWithNulls.fuzz(rowType_->childAt(i)));
+      }
+      children.push_back(fuzzer.fuzz(rowType_->childAt(numKeys - 1)));
+    }
+    // Fuzz payload
+    {
+      for (auto i = numKeys; i < rowType_->size(); ++i) {
+        children.push_back(fuzzer.fuzz(rowType_->childAt(i)));
+      }
+    }
+    return std::make_shared<RowVector>(
+        pool_, rowType_, nullptr, numRows, std::move(children));
+  }
+
+  const std::string testName_;
+  const size_t numRows_;
+  // Rows address stored in RowContainer
+  std::vector<char*> rows_;
+  std::unique_ptr<RowContainer> data_;
+  memory::MemoryPool* const pool_;
+  const RowTypePtr rowType_;
+  std::vector<CompareFlags> compareFlags_;
+};
+
+// You could config threshold, e.i. 0, to test prefix-sort for small
+// dateset.
+static const common::PrefixSortConfig kDefaultSortConfig(1024, 100);
+
+// For small dataset, in some test environments, if std-sort is defined in the
+// benchmark file, the test results may be strangely regressed. When the
+// threshold is particularly large, PrefixSort is actually std-sort, hence, we
+// can use this as std-sort benchmark base.
+static const common::PrefixSortConfig kStdSortConfig(
+    1024,
+    std::numeric_limits<int>::max());
+
+class PrefixSortBenchmark {
+ public:
+  PrefixSortBenchmark(memory::MemoryPool* pool) : pool_(pool) {}
+
+  void runPrefixSort(
+      const std::vector<char*>& rows,
+      RowContainer* rowContainer,
+      const std::vector<CompareFlags>& compareFlags) {
+    // Copy rows to avoid sort rows already sorted.
+    std::vector<char*> sortedRows = rows;
+    PrefixSort::sort(
+        sortedRows, pool_, rowContainer, compareFlags, kDefaultSortConfig);
+  }
+
+  void runStdSort(
+      const std::vector<char*>& rows,
+      RowContainer* rowContainer,
+      const std::vector<CompareFlags>& compareFlags) {
+    std::vector<char*> sortedRows = rows;
+    PrefixSort::sort(
+        sortedRows, pool_, rowContainer, compareFlags, kStdSortConfig);
+  }
+
+  // Add benchmark manually to avoid writing a lot of BENCHMARK.
+  void addBenchmark(
+      const std::string& testName,
+      size_t numRows,
+      const RowTypePtr& rowType,
+      int iterations,
+      int numKeys,
+      bool testStdSort) {
+    auto testCase =
+        std::make_unique<TestCase>(pool_, testName, numRows, rowType, numKeys);
+    // Add benchmarks for std-sort and prefix-sort.
+    {
+      if (testStdSort) {
+        folly::addBenchmark(
+            __FILE__,
+            "StdSort_" + testCase->testName(),
+            [rows = testCase->rows(),
+             container = testCase->rowContainer(),
+             sortFlags = testCase->compareFlags(),
+             iterations = iterations,
+             this]() {
+              for (auto i = 0; i < iterations; ++i) {
+                runStdSort(rows, container, sortFlags);
+              }
+              return rows.size() * iterations;
+            });
+      }
+      folly::addBenchmark(
+          __FILE__,
+          testStdSort ? "%PrefixSort" : "PrefixSort_" + testCase->testName(),
+          [rows = testCase->rows(),
+           container = testCase->rowContainer(),
+           sortFlags = testCase->compareFlags(),
+           iterations = iterations,
+           this]() {
+            for (auto i = 0; i < iterations; ++i) {
+              runPrefixSort(rows, container, sortFlags);
+            }
+            return rows.size() * iterations;
+          });
+    }
+    testCases_.push_back(std::move(testCase));
+  }
+
+  void benchmark(
+      const std::string& prefix,
+      const std::string& keyName,
+      const std::vector<vector_size_t>& batchSizes,
+      const std::vector<RowTypePtr>& rowTypes,
+      const std::vector<int>& numKeys,
+      int32_t iterations,
+      bool testStdSort = true) {
+    for (auto batchSize : batchSizes) {
+      for (auto i = 0; i < rowTypes.size(); ++i) {
+        const auto name = fmt::format(
+            "{}_{}_{}_{}k", prefix, numKeys[i], keyName, batchSize / 1000.0);
+        addBenchmark(
+            name, batchSize, rowTypes[i], iterations, numKeys[i], testStdSort);
+      }
+    }
+  }
+
+  std::vector<RowTypePtr> bigintRowTypes(bool noPayload) {
+    if (noPayload) {
+      return {
+          ROW({BIGINT()}),
+          ROW({BIGINT(), BIGINT()}),
+          ROW({BIGINT(), BIGINT(), BIGINT()}),
+          ROW({BIGINT(), BIGINT(), BIGINT(), BIGINT()}),
+      };
+    } else {
+      return {
+          ROW({BIGINT(), VARCHAR(), VARCHAR()}),
+          ROW({BIGINT(), BIGINT(), VARCHAR(), VARCHAR()}),
+          ROW({BIGINT(), BIGINT(), BIGINT(), VARCHAR(), VARCHAR()}),
+          ROW({BIGINT(), BIGINT(), BIGINT(), BIGINT(), VARCHAR(), VARCHAR()}),
+      };
+    }
+  }
+
+  std::vector<RowTypePtr> smallintRowTypes(bool noPayload) {
+    if (noPayload) {
+      return {
+          ROW({SMALLINT()}),
+          ROW({SMALLINT(), SMALLINT()}),
+          ROW({SMALLINT(), SMALLINT(), SMALLINT()}),
+          ROW({SMALLINT(), SMALLINT(), SMALLINT(), SMALLINT()}),
+      };
+    } else {
+      return {
+          ROW({SMALLINT(), VARCHAR(), VARCHAR()}),
+          ROW({SMALLINT(), SMALLINT(), VARCHAR(), VARCHAR()}),
+          ROW({SMALLINT(), SMALLINT(), SMALLINT(), VARCHAR(), VARCHAR()}),
+          ROW(
+              {SMALLINT(),
+               SMALLINT(),
+               SMALLINT(),
+               SMALLINT(),
+               VARCHAR(),
+               VARCHAR()}),
+      };
+    }
+  }
+
+  void bigint(
+      bool noPayload,
+      int numIterations,
+      const std::vector<vector_size_t>& batchSizes) {
+    std::vector<RowTypePtr> rowTypes = bigintRowTypes(noPayload);
+    std::vector<int> numKeys = {1, 2, 3, 4};
+    benchmark(
+        noPayload ? "no-payload" : "payload",
+        "bigint",
+        batchSizes,
+        rowTypes,
+        numKeys,
+        numIterations);
+  }
+
+  void smallBigint() {
+    // For small dateset, iterations need to be large enough to ensure that the
+    // benchmark runs for enough time.
+    const auto iterations = 100'000;
+    const std::vector<vector_size_t> batchSizes = {10, 50, 100, 500};
+    bigint(true, iterations, batchSizes);
+  }
+
+  void smallBigintWithPayload() {
+    const auto iterations = 100'000;
+    const std::vector<vector_size_t> batchSizes = {10, 50, 100, 500};
+    bigint(false, iterations, batchSizes);
+  }
+
+  void largeBigint() {
+    const auto iterations = 10;
+    const std::vector<vector_size_t> batchSizes = {
+        1'000, 10'000, 100'000, 1'000'000};
+    bigint(true, iterations, batchSizes);
+  }
+
+  void largeBigintWithPayloads() {
+    const auto iterations = 10;
+    const std::vector<vector_size_t> batchSizes = {
+        1'000, 10'000, 100'000, 1'000'000};
+    bigint(false, iterations, batchSizes);
+  }
+
+  void largeVarchar() {
+    const auto iterations = 10;
+    const std::vector<vector_size_t> batchSizes = {
+        1'000, 10'000, 100'000, 1'000'000};
+    std::vector<RowTypePtr> rowTypes = {
+        ROW({VARCHAR()}),
+        ROW({VARCHAR(), VARCHAR()}),
+        ROW({VARCHAR(), VARCHAR(), VARCHAR()}),
+        ROW({VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR()}),
+    };
+    std::vector<int> numKeys = {1, 2, 3, 4};
+    benchmark(
+        "no-payloads", "varchar", batchSizes, rowTypes, numKeys, iterations);
+  }
+
+  void smallint(
+      bool noPayload,
+      int numIterations,
+      const std::vector<vector_size_t>& batchSizes) {
+    std::vector<RowTypePtr> rowTypes = smallintRowTypes(noPayload);
+    std::vector<int> numKeys = {1, 2, 3, 4};
+    benchmark(
+        noPayload ? "no-payload" : "payload",
+        "smallint",
+        batchSizes,
+        rowTypes,
+        numKeys,
+        numIterations);
+  }
+
+  void smallSmallint() {
+    // For small dateset, iterations need to be large enough to ensure that the
+    // benchmark runs for enough time.
+    const auto iterations = 100'000;
+    const std::vector<vector_size_t> batchSizes = {10, 50, 100, 500};
+    smallint(true, iterations, batchSizes);
+  }
+
+  void smallSmallintWithPayload() {
+    const auto iterations = 100'000;
+    const std::vector<vector_size_t> batchSizes = {10, 50, 100, 500};
+    smallint(false, iterations, batchSizes);
+  }
+
+  void largeSmallint() {
+    const auto iterations = 10;
+    const std::vector<vector_size_t> batchSizes = {
+        1'000, 10'000, 100'000, 1'000'000};
+    smallint(true, iterations, batchSizes);
+  }
+
+  void largeSmallintWithPayloads() {
+    const auto iterations = 10;
+    const std::vector<vector_size_t> batchSizes = {
+        1'000, 10'000, 100'000, 1'000'000};
+    smallint(false, iterations, batchSizes);
+  }
+
+ private:
+  std::vector<std::unique_ptr<TestCase>> testCases_;
+  memory::MemoryPool* pool_;
+};
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+
+  memory::MemoryManager::initialize({});
+  auto rootPool = memory::memoryManager()->addRootPool();
+  auto leafPool = rootPool->addLeafChild("leaf");
+
+  PrefixSortBenchmark bm(leafPool.get());
+
+  bm.smallBigint();
+  bm.largeBigint();
+  bm.largeBigintWithPayloads();
+  bm.smallBigintWithPayload();
+  bm.largeVarchar();
+  bm.smallSmallint();
+  bm.largeSmallint();
+  bm.smallSmallintWithPayload();
+  bm.largeSmallintWithPayloads();
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/benchmarks/RowContainerSortBenchmark.cpp b/velox/exec/benchmarks/RowContainerSortBenchmark.cpp
new file mode 100644
index 0000000000000..7059d9a73c6b5
--- /dev/null
+++ b/velox/exec/benchmarks/RowContainerSortBenchmark.cpp
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/dwio/common/tests/utils/DataFiles.h"
+#include "velox/dwio/parquet/reader/ParquetReader.h"
+#include "velox/exec/RowContainer.h"
+#include "velox/external/timsort/TimSort.hpp"
+#include "velox/type/StringView.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/SimpleVector.h"
+#include "velox/vector/tests/VectorTestUtils.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+namespace facebook::velox::test {
+namespace {
+std::string getExampleFilePath(const std::string& fileName) {
+  return test::getDataFilePath(
+      "velox/dwio/parquet/tests/reader", "../examples/" + fileName);
+}
+
+dwio::common::RowReaderOptions getReaderOpts(
+    const RowTypePtr& rowType,
+    bool fileColumnNamesReadAsLowerCase = false) {
+  dwio::common::RowReaderOptions rowReaderOpts;
+  rowReaderOpts.select(
+      std::make_shared<facebook::velox::dwio::common::ColumnSelector>(
+          rowType, rowType->names(), nullptr, fileColumnNamesReadAsLowerCase));
+  return rowReaderOpts;
+}
+
+std::shared_ptr<velox::common::ScanSpec> makeScanSpec(
+    const RowTypePtr& rowType) {
+  auto scanSpec = std::make_shared<velox::common::ScanSpec>("");
+  scanSpec->addAllChildFields(*rowType);
+  return scanSpec;
+}
+
+facebook::velox::parquet::ParquetReader createReader(
+    const std::string& path,
+    const facebook::velox::dwio::common::ReaderOptions& opts) {
+  return facebook::velox::parquet::ParquetReader(
+      std::make_unique<facebook::velox::dwio::common::BufferedInput>(
+          std::make_shared<LocalReadFile>(path), opts.memoryPool()),
+      opts);
+}
+
+std::vector<std::optional<StringView>> getDataFromFile() {
+  const std::string sample(getExampleFilePath("str_sort.parquet"));
+  auto rowType = ROW({"query_sig", "result_sig"}, {VARCHAR(), VARCHAR()});
+  auto pool = memory::memoryManager()->addLeafPool();
+  facebook::velox::dwio::common::ReaderOptions readerOptions{pool.get()};
+  facebook::velox::parquet::ParquetReader reader =
+      createReader(sample, readerOptions);
+  auto rowReaderOpts = getReaderOpts(rowType);
+  auto scanSpec = makeScanSpec(rowType);
+  rowReaderOpts.setScanSpec(scanSpec);
+  auto rowReader = reader.createRowReader(rowReaderOpts);
+  auto data = BaseVector::create(rowType, 50000, pool.get());
+  rowReader->next(50000, data);
+  auto querySigCol =
+      data->as<RowVector>()->childAt(0)->asFlatVector<StringView>();
+  auto resSigCol =
+      data->as<RowVector>()->childAt(1)->asFlatVector<StringView>();
+  std::vector<std::optional<StringView>> stdVector(querySigCol->size());
+  for (int i = 0; i < querySigCol->size(); i++) {
+    auto merge =
+        querySigCol->valueAt(i).getString() + resSigCol->valueAt(i).getString();
+    stdVector[i] = StringView(merge);
+  }
+  return stdVector;
+}
+
+std::vector<char*> store(
+    velox::exec::RowContainer& rowContainer,
+    DecodedVector& decodedVector,
+    vector_size_t size) {
+  std::vector<char*> rows(size);
+  for (size_t row = 0; row < size; ++row) {
+    rows[row] = rowContainer.newRow();
+    rowContainer.store(decodedVector, row, rows[row], 0);
+  }
+  return rows;
+}
+
+template <typename T>
+void rowContainerStdSortBenchmark(uint32_t iterations, size_t cardinality) {
+  folly::BenchmarkSuspender suspender;
+  auto pool = memory::memoryManager()->addLeafPool();
+  VectorMaker vectorMaker(pool.get());
+
+  for (size_t k = 0; k < iterations; ++k) {
+    // Use std::nullopt for seed to generate unpredictable pseudo-random for
+    // benchmark.
+    auto data =
+        genTestData<T>(cardinality, CppToType<T>::create(), true, false, false);
+    auto vector =
+        vectorMaker.encodedVector<T>(VectorEncoding::Simple::FLAT, data.data());
+    DecodedVector decoded(*vector);
+    // Create row container.
+    std::vector<TypePtr> types{vector->type()};
+    // Store the vector in the rowContainer.
+    auto rowContainer =
+        std::make_unique<velox::exec::RowContainer>(types, pool.get());
+    int size = data.data().size();
+    auto rows = store(*rowContainer, decoded, size);
+    suspender.dismiss();
+    std::sort(
+        rows.begin(), rows.end(), [&](const char* left, const char* right) {
+          return rowContainer->compareRows(left, right) < 0;
+        });
+    suspender.rehire();
+  }
+}
+
+template <typename T>
+void rowContainerTimSortBenchmark(uint32_t iterations, size_t cardinality) {
+  folly::BenchmarkSuspender suspender;
+  auto pool = memory::memoryManager()->addLeafPool();
+  VectorMaker vectorMaker(pool.get());
+
+  for (size_t k = 0; k < iterations; ++k) {
+    auto data =
+        genTestData<T>(cardinality, CppToType<T>::create(), true, false, false);
+    auto vector =
+        vectorMaker.encodedVector<T>(VectorEncoding::Simple::FLAT, data.data());
+    DecodedVector decoded(*vector);
+    // Create row container.
+    std::vector<TypePtr> types{vector->type()};
+    // Store the vector in the rowContainer.
+    auto rowContainer =
+        std::make_unique<velox::exec::RowContainer>(types, pool.get());
+    int size = vector->size();
+    auto rows = store(*rowContainer, decoded, size);
+    suspender.dismiss();
+    gfx::timsort(
+        rows.begin(), rows.end(), [&](const char* left, const char* right) {
+          return rowContainer->compareRows(left, right) < 0;
+        });
+    suspender.rehire();
+  }
+}
+
+void BM_Int64_stdSort(uint32_t iterations, size_t cardinality) {
+  rowContainerStdSortBenchmark<int64_t>(iterations, cardinality);
+}
+
+void BM_Int64_timSort(uint32_t iterations, size_t cardinality) {
+  rowContainerTimSortBenchmark<int64_t>(iterations, cardinality);
+}
+
+void BM_STR_stdSort(uint32_t iterations) {
+  folly::BenchmarkSuspender suspender;
+  auto pool = memory::memoryManager()->addLeafPool();
+  VectorMaker vectorMaker(pool.get());
+  auto data = getDataFromFile();
+  auto vector =
+      vectorMaker.encodedVector<StringView>(VectorEncoding::Simple::FLAT, data);
+  DecodedVector decoded(*vector);
+  // Create row container.
+  std::vector<TypePtr> types{vector->type()};
+  // Store the vector in the rowContainer.
+  auto rowContainer =
+      std::make_unique<velox::exec::RowContainer>(types, pool.get());
+  int size = data.size();
+  auto rows = store(*rowContainer, decoded, size);
+  for (size_t k = 0; k < iterations; ++k) {
+    suspender.dismiss();
+    std::sort(
+        rows.begin(), rows.end(), [&](const char* left, const char* right) {
+          return rowContainer->compareRows(left, right) < 0;
+        });
+    suspender.rehire();
+  }
+}
+
+void BM_STR_timSort(uint32_t iterations) {
+  folly::BenchmarkSuspender suspender;
+  auto pool = memory::memoryManager()->addLeafPool();
+  VectorMaker vectorMaker(pool.get());
+  auto data = getDataFromFile();
+  auto vector =
+      vectorMaker.encodedVector<StringView>(VectorEncoding::Simple::FLAT, data);
+  DecodedVector decoded(*vector);
+  // Create row container.
+  std::vector<TypePtr> types{vector->type()};
+  // Store the vector in the rowContainer.
+  auto rowContainer =
+      std::make_unique<velox::exec::RowContainer>(types, pool.get());
+  int size = vector->size();
+  auto rows = store(*rowContainer, decoded, size);
+  for (size_t k = 0; k < iterations; ++k) {
+    suspender.dismiss();
+    gfx::timsort(
+        rows.begin(), rows.end(), [&](const char* left, const char* right) {
+          return rowContainer->compareRows(left, right) < 0;
+        });
+    suspender.rehire();
+  }
+}
+} // namespace
+
+BENCHMARK_NAMED_PARAM(BM_Int64_stdSort, 100k_uni_noseq, 100000);
+BENCHMARK_RELATIVE_NAMED_PARAM(BM_Int64_timSort, 100k_uni_noseq, 100000);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(BM_Int64_stdSort, 10k_uni_noseq, 10000);
+BENCHMARK_RELATIVE_NAMED_PARAM(BM_Int64_timSort, 10k_uni_noseq, 10000);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(BM_Int64_stdSort, 1k_uni_noseq, 1000);
+BENCHMARK_RELATIVE_NAMED_PARAM(BM_Int64_timSort, 1k_uni_noseq, 1000);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(BM_STR_stdSort, RealWorldData_stdSort);
+BENCHMARK_RELATIVE_NAMED_PARAM(BM_STR_timSort, RealWorldData_timSort);
+BENCHMARK_DRAW_LINE();
+} // namespace facebook::velox::test
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  facebook::velox::memory::MemoryManager::initialize({});
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/benchmarks/SetAccumulatorBenchmark.cpp b/velox/exec/benchmarks/SetAccumulatorBenchmark.cpp
new file mode 100644
index 0000000000000..72211a7ca814d
--- /dev/null
+++ b/velox/exec/benchmarks/SetAccumulatorBenchmark.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/exec/SetAccumulator.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+namespace {
+
+// Adds 10M mostly unique values to a single SetAccumulator, then extracts
+// unique values from it.
+class SetAccumulatorBenchmark : public facebook::velox::test::VectorTestBase {
+ public:
+  void setup() {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = 1'000'000;
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto rowType = ROW({"a", "b", "c"}, {BIGINT(), BIGINT(), VARCHAR()});
+    for (auto i = 0; i < 10; ++i) {
+      rowVectors_.emplace_back(fuzzer.fuzzInputRow(rowType));
+    }
+  }
+
+  void runBigint() {
+    runPrimitive<int64_t>("a");
+  }
+
+  void runVarchar() {
+    runPrimitive<StringView>("c");
+  }
+
+  void runTwoBigints() {
+    HashStringAllocator allocator(pool());
+    const TypePtr type = ROW({BIGINT(), BIGINT()});
+    aggregate::prestosql::SetAccumulator<ComplexType> accumulator(
+        type, &allocator);
+
+    for (const auto& rowVector : rowVectors_) {
+      auto vector =
+          makeRowVector({rowVector->childAt("a"), rowVector->childAt("b")});
+      DecodedVector decoded(*vector);
+      for (auto i = 0; i < rowVector->size(); ++i) {
+        accumulator.addValue(decoded, i, &allocator);
+      }
+    }
+
+    auto result = BaseVector::create(type, accumulator.size(), pool());
+    accumulator.extractValues(*result, 0);
+    folly::doNotOptimizeAway(result);
+  }
+
+ private:
+  template <typename T>
+  void runPrimitive(const std::string& name) {
+    const auto& type = rowVectors_[0]->childAt(name)->type();
+
+    HashStringAllocator allocator(pool());
+    aggregate::prestosql::SetAccumulator<T> accumulator(type, &allocator);
+
+    for (const auto& rowVector : rowVectors_) {
+      DecodedVector decoded(*rowVector->childAt(name));
+      for (auto i = 0; i < rowVector->size(); ++i) {
+        accumulator.addValue(decoded, i, &allocator);
+      }
+    }
+
+    auto result =
+        BaseVector::create<FlatVector<T>>(type, accumulator.size(), pool());
+    accumulator.extractValues(*result, 0);
+    folly::doNotOptimizeAway(result);
+  }
+
+  std::vector<RowVectorPtr> rowVectors_;
+};
+
+std::unique_ptr<SetAccumulatorBenchmark> bm;
+
+BENCHMARK(bigint) {
+  bm->runBigint();
+}
+
+BENCHMARK(varchar) {
+  bm->runVarchar();
+}
+
+BENCHMARK(twoBigints) {
+  bm->runTwoBigints();
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+
+  bm = std::make_unique<SetAccumulatorBenchmark>();
+  bm->setup();
+
+  folly::runBenchmarks();
+
+  bm.reset();
+
+  return 0;
+}
diff --git a/velox/exec/benchmarks/VectorHasherBenchmark.cpp b/velox/exec/benchmarks/VectorHasherBenchmark.cpp
index ea9c6a880f4d2..93cc0f7d16894 100644
--- a/velox/exec/benchmarks/VectorHasherBenchmark.cpp
+++ b/velox/exec/benchmarks/VectorHasherBenchmark.cpp
@@ -57,7 +57,8 @@ class BenchmarkBase {
   }
 
  private:
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   VectorMaker vectorMaker_{pool_.get()};
 };
 
@@ -238,8 +239,39 @@ BENCHMARK(computeValueIdsLowCardinalityNotAllUsed) {
   }
 }
 
+BENCHMARK(computeValueIdsDictionaryForFiltering) {
+  folly::BenchmarkSuspender suspender;
+
+  vector_size_t cardinality = 30'000'000;
+  vector_size_t batchSize = 300;
+  BenchmarkBase base;
+
+  auto data = base.vectorMaker().flatVector<int64_t>(
+      cardinality, [](vector_size_t row) { return row; });
+  BufferPtr indices = allocateIndices(batchSize, base.pool());
+  auto rawIndices = indices->asMutable<vector_size_t>();
+  // Assign indices such that array is reversed.
+  for (size_t i = 0; i < batchSize; ++i) {
+    rawIndices[i] = i * 1000;
+  }
+  auto values = BaseVector::wrapInDictionary(nullptr, indices, batchSize, data);
+
+  for (int i = 0; i < 10; i++) {
+    raw_vector<uint64_t> hashes(batchSize);
+    SelectivityVector rows(batchSize);
+    VectorHasher hasher(BIGINT(), 0);
+    hasher.decode(*values, rows);
+    suspender.dismiss();
+
+    bool ok = hasher.computeValueIds(rows, hashes);
+    folly::doNotOptimizeAway(ok);
+    suspender.rehire();
+  }
+}
+
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/exec/fuzzer/AggregationFuzzer.cpp b/velox/exec/fuzzer/AggregationFuzzer.cpp
new file mode 100644
index 0000000000000..76cc93afd3a4b
--- /dev/null
+++ b/velox/exec/fuzzer/AggregationFuzzer.cpp
@@ -0,0 +1,1239 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/fuzzer/AggregationFuzzer.h"
+
+#include <boost/random/uniform_int_distribution.hpp>
+
+#include "velox/common/base/Portability.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/fuzzer/AggregationFuzzerBase.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/vector/VectorSaver.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_bool(
+    enable_sorted_aggregations,
+    true,
+    "When true, generates plans with aggregations over sorted inputs");
+
+DEFINE_bool(
+    enable_window_reference_verification,
+    false,
+    "When true, the results of the window aggregation are compared to reference DB results");
+
+using facebook::velox::fuzzer::CallableSignature;
+using facebook::velox::fuzzer::SignatureTemplate;
+
+namespace facebook::velox::exec::test {
+
+class AggregationFuzzerBase;
+
+namespace {
+
+class AggregationFuzzer : public AggregationFuzzerBase {
+ public:
+  AggregationFuzzer(
+      AggregateFunctionSignatureMap signatureMap,
+      size_t seed,
+      const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>&
+          customVerificationFunctions,
+      const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
+          customInputGenerators,
+      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      const std::unordered_map<std::string, std::string>& queryConfigs,
+      const std::unordered_map<std::string, std::string>& hiveConfigs,
+      bool orderableGroupKeys,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
+
+  void go();
+  void go(const std::string& planPath);
+
+ private:
+  struct Stats : public AggregationFuzzerBase::Stats {
+    // Number of iterations using masked aggregation.
+    size_t numMask{0};
+
+    // Number of iterations using group-by aggregation.
+    size_t numGroupBy{0};
+
+    // Number of iterations using global aggregation.
+    size_t numGlobal{0};
+
+    // Number of iterations using distinct aggregation.
+    size_t numDistinct{0};
+
+    // Number of iterations using aggregations over distinct inputs.
+    size_t numDistinctInputs{0};
+    // Number of iterations using window expressions.
+    size_t numWindow{0};
+
+    void print(size_t numIterations) const;
+  };
+
+  // Return 'true' if query plans failed.
+  bool verifyWindow(
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<std::string>& sortingKeys,
+      const std::string& aggregate,
+      const std::vector<RowVectorPtr>& input,
+      bool customVerification,
+      bool enableWindowVerification);
+
+  // Return 'true' if query plans failed.
+  bool verifyAggregation(
+      const std::vector<std::string>& groupingKeys,
+      const std::vector<std::string>& aggregates,
+      const std::vector<std::string>& masks,
+      const std::vector<RowVectorPtr>& input,
+      bool customVerification,
+      const std::shared_ptr<ResultVerifier>& customVerifier);
+
+  // Return 'true' if query plans failed.
+  bool verifySortedAggregation(
+      const std::vector<std::string>& groupingKeys,
+      const std::string& aggregate,
+      const std::vector<std::string>& masks,
+      const std::vector<RowVectorPtr>& input,
+      bool customVerification,
+      const std::shared_ptr<ResultVerifier>& customVerifier);
+
+  void verifyAggregation(const std::vector<PlanWithSplits>& plans);
+
+  // Use the result of the first plan in the plans as the expected result to
+  // compare or verify it with the results of other equivalent plans.
+  bool compareEquivalentPlanResults(
+      const std::vector<PlanWithSplits>& plans,
+      bool customVerification,
+      const std::vector<RowVectorPtr>& input,
+      const std::shared_ptr<ResultVerifier>& customVerifier,
+      int32_t maxDrivers = 2,
+      bool testWithSpilling = true);
+
+  // Return 'true' if query plans failed.
+  bool verifyDistinctAggregation(
+      const std::vector<std::string>& groupingKeys,
+      const std::string& aggregate,
+      const std::vector<std::string>& masks,
+      const std::vector<RowVectorPtr>& input,
+      bool customVerification,
+      const std::shared_ptr<ResultVerifier>& customVerifier);
+
+  static bool hasPartialGroupBy(const core::PlanNodePtr& plan) {
+    auto partialAgg = core::PlanNode::findFirstNode(
+        plan.get(), [](const core::PlanNode* node) {
+          if (auto aggregation =
+                  dynamic_cast<const core::AggregationNode*>(node)) {
+            return aggregation->step() ==
+                core::AggregationNode::Step::kPartial &&
+                !aggregation->groupingKeys().empty();
+          }
+
+          return false;
+        });
+    return partialAgg != nullptr;
+  }
+
+  void testPlans(
+      const std::vector<PlanWithSplits>& plans,
+      bool customVerification,
+      const std::vector<std::shared_ptr<ResultVerifier>>& customVerifiers,
+      const velox::fuzzer::ResultOrError& expected,
+      int32_t maxDrivers = 2,
+      bool testWithSpilling = true) {
+    for (auto i = 0; i < plans.size(); ++i) {
+      const auto& planWithSplits = plans[i];
+
+      LOG(INFO) << "Testing plan #" << i;
+      testPlan(
+          planWithSplits,
+          false /*injectSpill*/,
+          false /*abandonPartial*/,
+          customVerification,
+          customVerifiers,
+          expected,
+          maxDrivers);
+
+      if (testWithSpilling) {
+        LOG(INFO) << "Testing plan #" << i << " with spilling";
+        testPlan(
+            planWithSplits,
+            true /*injectSpill*/,
+            false /*abandonPartial*/,
+            customVerification,
+            customVerifiers,
+            expected,
+            maxDrivers);
+      }
+
+      if (hasPartialGroupBy(planWithSplits.plan)) {
+        LOG(INFO) << "Testing plan #" << i
+                  << " with forced abandon-partial-aggregation";
+        testPlan(
+            planWithSplits,
+            false /*injectSpill*/,
+            true /*abandonPartial*/,
+            customVerification,
+            customVerifiers,
+            expected,
+            maxDrivers);
+      }
+    }
+  }
+
+  Stats stats_;
+};
+} // namespace
+
+void aggregateFuzzer(
+    AggregateFunctionSignatureMap signatureMap,
+    size_t seed,
+    const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>&
+        customVerificationFunctions,
+    const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
+        customInputGenerators,
+    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    const std::unordered_map<std::string, std::string>& queryConfigs,
+    const std::unordered_map<std::string, std::string>& hiveConfigs,
+    bool orderableGroupKeys,
+    const std::optional<std::string>& planPath,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
+  auto aggregationFuzzer = AggregationFuzzer(
+      std::move(signatureMap),
+      seed,
+      customVerificationFunctions,
+      customInputGenerators,
+      timestampPrecision,
+      queryConfigs,
+      hiveConfigs,
+      orderableGroupKeys,
+      std::move(referenceQueryRunner));
+  planPath.has_value() ? aggregationFuzzer.go(planPath.value())
+                       : aggregationFuzzer.go();
+}
+
+namespace {
+
+AggregationFuzzer::AggregationFuzzer(
+    AggregateFunctionSignatureMap signatureMap,
+    size_t seed,
+    const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>&
+        customVerificationFunctions,
+    const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
+        customInputGenerators,
+    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    const std::unordered_map<std::string, std::string>& queryConfigs,
+    const std::unordered_map<std::string, std::string>& hiveConfigs,
+    bool orderableGroupKeys,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner)
+    : AggregationFuzzerBase{
+          seed,
+          customVerificationFunctions,
+          customInputGenerators,
+          timestampPrecision,
+          queryConfigs,
+          hiveConfigs,
+          orderableGroupKeys,
+          std::move(referenceQueryRunner)} {
+  VELOX_CHECK(!signatureMap.empty(), "No function signatures available.");
+
+  if (persistAndRunOnce_ && reproPersistPath_.empty()) {
+    std::cout
+        << "--repro_persist_path must be specified if --persist_and_run_once is specified"
+        << std::endl;
+    exit(1);
+  }
+
+  addAggregationSignatures(signatureMap);
+  printStats(functionsStats);
+
+  sortCallableSignatures(signatures_);
+  sortSignatureTemplates(signatureTemplates_);
+
+  signatureStats_.resize(signatures_.size() + signatureTemplates_.size());
+}
+
+void AggregationFuzzer::go(const std::string& planPath) {
+  Type::registerSerDe();
+  connector::hive::HiveTableHandle::registerSerDe();
+  connector::hive::LocationHandle::registerSerDe();
+  connector::hive::HiveColumnHandle::registerSerDe();
+  connector::hive::HiveInsertTableHandle::registerSerDe();
+  core::ITypedExpr::registerSerDe();
+  core::PlanNode::registerSerDe();
+  registerPartitionFunctionSerDe();
+
+  LOG(INFO) << "Attempting to use serialized plan at: " << planPath;
+  auto planString = restoreStringFromFile(planPath.c_str());
+  auto parsedPlans = folly::parseJson(planString);
+  std::vector<PlanWithSplits> plans(parsedPlans.size());
+  std::transform(
+      parsedPlans.begin(),
+      parsedPlans.end(),
+      plans.begin(),
+      [&](const folly::dynamic& obj) { return deserialize(obj); });
+
+  verifyAggregation(plans);
+}
+
+// Returns true if specified aggregate function can be applied to sorted inputs,
+// i.e. function takes 1 or more arguments (count(1) doesn't qualify) and types
+// of all arguments are orderable (no maps).
+bool canSortInputs(const CallableSignature& signature) {
+  if (signature.args.empty()) {
+    return false;
+  }
+
+  for (const auto& arg : signature.args) {
+    if (!arg->isOrderable()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// Returns true if specified aggregate function can be applied to distinct
+// inputs. If 'orderableGroupKeys' is true the argument type must be orderable,
+// otherwise it must be comparable.
+bool supportsDistinctInputs(
+    const CallableSignature& signature,
+    bool orderableGroupKeys) {
+  if (signature.args.empty()) {
+    return false;
+  }
+
+  const auto& arg = signature.args.at(0);
+  if (orderableGroupKeys) {
+    return arg->isOrderable();
+  }
+  return arg->isComparable();
+}
+
+void AggregationFuzzer::go() {
+  VELOX_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+
+  auto startTime = std::chrono::system_clock::now();
+  size_t iteration = 0;
+
+  while (!isDone(iteration, startTime)) {
+    LOG(INFO) << "==============================> Started iteration "
+              << iteration << " (seed: " << currentSeed_ << ")";
+
+    // 10% of times test distinct aggregation.
+    if (vectorFuzzer_.coinToss(0.1)) {
+      ++stats_.numDistinct;
+
+      std::vector<TypePtr> types;
+      std::vector<std::string> names;
+
+      auto groupingKeys = generateKeys("g", names, types);
+      auto input = generateInputData(names, types, std::nullopt);
+
+      logVectors(input);
+
+      verifyAggregation(groupingKeys, {}, {}, input, false, {});
+    } else {
+      // Pick a random signature.
+      auto signatureWithStats = pickSignature();
+      signatureWithStats.second.numRuns++;
+
+      auto signature = signatureWithStats.first;
+      stats_.functionNames.insert(signature.name);
+
+      const bool customVerification =
+          customVerificationFunctions_.count(signature.name) != 0;
+
+      std::vector<TypePtr> argTypes = signature.args;
+      std::vector<std::string> argNames = makeNames(argTypes.size());
+
+      // 10% of times test window operator.
+      if (vectorFuzzer_.coinToss(0.1)) {
+        ++stats_.numWindow;
+
+        auto call = makeFunctionCall(signature.name, argNames, false);
+
+        auto partitionKeys = generateKeys("p", argNames, argTypes);
+        auto sortingKeys = generateSortingKeys("s", argNames, argTypes);
+        auto input = generateInputDataWithRowNumber(
+            argNames, argTypes, partitionKeys, signature);
+
+        logVectors(input);
+
+        bool failed = verifyWindow(
+            partitionKeys,
+            sortingKeys,
+            call,
+            input,
+            customVerification,
+            FLAGS_enable_window_reference_verification);
+        if (failed) {
+          signatureWithStats.second.numFailed++;
+        }
+      } else {
+        const bool sortedInputs = FLAGS_enable_sorted_aggregations &&
+            canSortInputs(signature) && vectorFuzzer_.coinToss(0.2);
+
+        // Exclude approx_xxx aggregations since their verifiers may not be able
+        // to verify the results. The approx_percentile verifier would discard
+        // the distinct property when calculating the expected result, say the
+        // expected result of the verifier would be approx_percentile(x), which
+        // may be different from the actual result of approx_percentile(distinct
+        // x).
+        const bool distinctInputs = !sortedInputs &&
+            (signature.name.find("approx_") == std::string::npos) &&
+            supportsDistinctInputs(signature, orderableGroupKeys_) &&
+            vectorFuzzer_.coinToss(0.2);
+
+        auto call = makeFunctionCall(
+            signature.name, argNames, sortedInputs, distinctInputs);
+
+        // 20% of times use mask.
+        std::vector<std::string> masks;
+        if (vectorFuzzer_.coinToss(0.2)) {
+          ++stats_.numMask;
+
+          masks.push_back("m0");
+          argTypes.push_back(BOOLEAN());
+          argNames.push_back(masks.back());
+        }
+
+        // 10% of times use global aggregation (no grouping keys).
+        std::vector<std::string> groupingKeys;
+        if (vectorFuzzer_.coinToss(0.1)) {
+          ++stats_.numGlobal;
+        } else {
+          ++stats_.numGroupBy;
+          groupingKeys = generateKeys("g", argNames, argTypes);
+        }
+
+        auto input = generateInputData(argNames, argTypes, signature);
+
+        logVectors(input);
+
+        std::shared_ptr<ResultVerifier> customVerifier;
+        if (customVerification) {
+          customVerifier = customVerificationFunctions_.at(signature.name);
+        }
+
+        if (sortedInputs) {
+          ++stats_.numSortedInputs;
+          bool failed = verifySortedAggregation(
+              groupingKeys,
+              call,
+              masks,
+              input,
+              customVerification,
+              customVerifier);
+          if (failed) {
+            signatureWithStats.second.numFailed++;
+          }
+        } else if (distinctInputs) {
+          ++stats_.numDistinctInputs;
+          bool failed = verifyDistinctAggregation(
+              groupingKeys,
+              call,
+              masks,
+              input,
+              customVerification,
+              customVerifier);
+          if (failed) {
+            signatureWithStats.second.numFailed++;
+          }
+        } else {
+          bool failed = verifyAggregation(
+              groupingKeys,
+              {call},
+              masks,
+              input,
+              customVerification,
+              customVerifier);
+          if (failed) {
+            signatureWithStats.second.numFailed++;
+          }
+        }
+      }
+    }
+    LOG(INFO) << "==============================> Done with iteration "
+              << iteration;
+
+    if (persistAndRunOnce_) {
+      LOG(WARNING)
+          << "Iteration succeeded with --persist_and_run_once flag enabled "
+             "(expecting crash failure)";
+      exit(0);
+    }
+
+    reSeed();
+    ++iteration;
+  }
+
+  stats_.print(iteration);
+
+  printSignatureStats();
+}
+
+void makeAlternativePlansWithValues(
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& masks,
+    const std::vector<RowVectorPtr>& inputVectors,
+    std::vector<core::PlanNodePtr>& plans) {
+  // Partial -> final aggregation plan.
+  plans.push_back(PlanBuilder()
+                      .values(inputVectors)
+                      .partialAggregation(groupingKeys, aggregates, masks)
+                      .finalAggregation()
+                      .planNode());
+
+  // Partial -> intermediate -> final aggregation plan.
+  plans.push_back(PlanBuilder()
+                      .values(inputVectors)
+                      .partialAggregation(groupingKeys, aggregates, masks)
+                      .intermediateAggregation()
+                      .finalAggregation()
+                      .planNode());
+
+  // Partial -> local exchange -> final aggregation plan.
+  auto numSources = std::min<size_t>(4, inputVectors.size());
+  std::vector<std::vector<RowVectorPtr>> sourceInputs(numSources);
+  for (auto i = 0; i < inputVectors.size(); ++i) {
+    sourceInputs[i % numSources].push_back(inputVectors[i]);
+  }
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<core::PlanNodePtr> sources;
+  for (const auto& sourceInput : sourceInputs) {
+    sources.push_back(PlanBuilder(planNodeIdGenerator)
+                          .values({sourceInput})
+                          .partialAggregation(groupingKeys, aggregates, masks)
+                          .planNode());
+  }
+
+// There is a known issue where LocalPartition will send DictionaryVectors
+// with the same underlying base Vector to multiple threads.  This triggers
+// TSAN to report data races, particularly if that base Vector is from the
+// TableScan and reused.  Don't run these tests when TSAN is enabled to avoid
+// the false negatives.
+#ifndef TSAN_BUILD
+  plans.push_back(PlanBuilder(planNodeIdGenerator)
+                      .localPartition(groupingKeys, sources)
+                      .finalAggregation()
+                      .planNode());
+#endif
+}
+
+void makeAlternativePlansWithTableScan(
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& masks,
+    const RowTypePtr& inputRowType,
+    std::vector<core::PlanNodePtr>& plans) {
+// There is a known issue where LocalPartition will send DictionaryVectors
+// with the same underlying base Vector to multiple threads.  This triggers
+// TSAN to report data races, particularly if that base Vector is from the
+// TableScan and reused.  Don't run these tests when TSAN is enabled to avoid
+// the false negatives.
+#ifndef TSAN_BUILD
+  // Partial -> final aggregation plan.
+  plans.push_back(PlanBuilder()
+                      .tableScan(inputRowType)
+                      .partialAggregation(groupingKeys, aggregates, masks)
+                      .localPartition(groupingKeys)
+                      .finalAggregation()
+                      .planNode());
+
+  // Partial -> intermediate -> final aggregation plan.
+  plans.push_back(PlanBuilder()
+                      .tableScan(inputRowType)
+                      .partialAggregation(groupingKeys, aggregates, masks)
+                      .localPartition(groupingKeys)
+                      .intermediateAggregation()
+                      .finalAggregation()
+                      .planNode());
+#endif
+}
+
+void makeStreamingPlansWithValues(
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& masks,
+    const std::vector<RowVectorPtr>& inputVectors,
+    std::vector<core::PlanNodePtr>& plans) {
+  // Single aggregation.
+  plans.push_back(PlanBuilder()
+                      .values(inputVectors)
+                      .orderBy(groupingKeys, false)
+                      .streamingAggregation(
+                          groupingKeys,
+                          aggregates,
+                          masks,
+                          core::AggregationNode::Step::kSingle,
+                          false)
+                      .planNode());
+
+  // Partial -> final aggregation plan.
+  plans.push_back(
+      PlanBuilder()
+          .values(inputVectors)
+          .orderBy(groupingKeys, false)
+          .partialStreamingAggregation(groupingKeys, aggregates, masks)
+          .finalAggregation()
+          .planNode());
+
+  // Partial -> intermediate -> final aggregation plan.
+  plans.push_back(
+      PlanBuilder()
+          .values(inputVectors)
+          .orderBy(groupingKeys, false)
+          .partialStreamingAggregation(groupingKeys, aggregates, masks)
+          .intermediateAggregation()
+          .finalAggregation()
+          .planNode());
+
+  // Partial -> local merge -> final aggregation plan.
+  auto numSources = std::min<size_t>(4, inputVectors.size());
+  std::vector<std::vector<RowVectorPtr>> sourceInputs(numSources);
+  for (auto i = 0; i < inputVectors.size(); ++i) {
+    sourceInputs[i % numSources].push_back(inputVectors[i]);
+  }
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<core::PlanNodePtr> sources;
+  for (const auto& sourceInput : sourceInputs) {
+    sources.push_back(
+        PlanBuilder(planNodeIdGenerator)
+            .values({sourceInput})
+            .orderBy(groupingKeys, false)
+            .partialStreamingAggregation(groupingKeys, aggregates, masks)
+            .planNode());
+  }
+  plans.push_back(PlanBuilder(planNodeIdGenerator)
+                      .localMerge(groupingKeys, sources)
+                      .finalAggregation()
+                      .planNode());
+}
+
+void makeStreamingPlansWithTableScan(
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& masks,
+    const RowTypePtr& inputRowType,
+    std::vector<core::PlanNodePtr>& plans) {
+  // Single aggregation.
+  plans.push_back(PlanBuilder()
+                      .tableScan(inputRowType)
+                      .orderBy(groupingKeys, false)
+                      .streamingAggregation(
+                          groupingKeys,
+                          aggregates,
+                          masks,
+                          core::AggregationNode::Step::kSingle,
+                          false)
+                      .planNode());
+
+  // Partial -> final aggregation plan.
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .orderBy(groupingKeys, false)
+          .partialStreamingAggregation(groupingKeys, aggregates, masks)
+          .finalAggregation()
+          .planNode());
+
+  // Partial -> intermediate -> final aggregation plan.
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .orderBy(groupingKeys, false)
+          .partialStreamingAggregation(groupingKeys, aggregates, masks)
+          .intermediateAggregation()
+          .finalAggregation()
+          .planNode());
+
+  // Partial -> local merge -> final aggregation plan.
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .orderBy(groupingKeys, true)
+          .partialStreamingAggregation(groupingKeys, aggregates, masks)
+          .localMerge(groupingKeys)
+          .finalAggregation()
+          .planNode());
+}
+
+bool AggregationFuzzer::verifyWindow(
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<std::string>& sortingKeys,
+    const std::string& aggregate,
+    const std::vector<RowVectorPtr>& input,
+    bool customVerification,
+    bool enableWindowVerification) {
+  std::stringstream frame;
+  if (!partitionKeys.empty()) {
+    frame << "partition by " << folly::join(", ", partitionKeys);
+  }
+  if (!sortingKeys.empty()) {
+    frame << " order by " << folly::join(", ", sortingKeys);
+  }
+
+  auto plan = PlanBuilder()
+                  .values(input)
+                  .window({fmt::format("{} over ({})", aggregate, frame.str())})
+                  .planNode();
+  if (persistAndRunOnce_) {
+    persistReproInfo({{plan, {}}}, reproPersistPath_);
+  }
+  try {
+    auto resultOrError = execute(plan);
+    if (resultOrError.exceptionPtr) {
+      ++stats_.numFailed;
+    }
+
+    if (!customVerification && enableWindowVerification) {
+      if (resultOrError.result) {
+        auto referenceResult =
+            computeReferenceResults(plan, input, referenceQueryRunner_.get());
+        stats_.updateReferenceQueryStats(referenceResult.second);
+        if (auto expectedResult = referenceResult.first) {
+          ++stats_.numVerified;
+          VELOX_CHECK(
+              assertEqualResults(
+                  expectedResult.value(),
+                  plan->outputType(),
+                  {resultOrError.result}),
+              "Velox and reference DB results don't match");
+          LOG(INFO) << "Verified results against reference DB";
+        }
+      }
+    } else {
+      ++stats_.numVerificationSkipped;
+    }
+
+    return resultOrError.exceptionPtr != nullptr;
+  } catch (...) {
+    if (!reproPersistPath_.empty()) {
+      persistReproInfo({{plan, {}}}, reproPersistPath_);
+    }
+    throw;
+  }
+}
+
+bool AggregationFuzzer::verifyAggregation(
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& masks,
+    const std::vector<RowVectorPtr>& input,
+    bool customVerification,
+    const std::shared_ptr<ResultVerifier>& customVerifier) {
+  auto firstPlan = PlanBuilder()
+                       .values(input)
+                       .singleAggregation(groupingKeys, aggregates, masks)
+                       .planNode();
+
+  if (customVerification && customVerifier != nullptr) {
+    const auto& aggregationNode =
+        std::dynamic_pointer_cast<const core::AggregationNode>(firstPlan);
+
+    customVerifier->initialize(
+        input,
+        groupingKeys,
+        aggregationNode->aggregates()[0],
+        aggregationNode->aggregateNames()[0]);
+  }
+
+  SCOPE_EXIT {
+    if (customVerification && customVerifier != nullptr) {
+      customVerifier->reset();
+    }
+  };
+
+  // Create all the plans upfront.
+  std::vector<PlanWithSplits> plans;
+  plans.push_back({firstPlan, {}});
+
+  auto directory = exec::test::TempDirectoryPath::create();
+
+  // Alternate between using Values and TableScan node.
+
+  const auto inputRowType = asRowType(input[0]->type());
+  if (isTableScanSupported(inputRowType) && vectorFuzzer_.coinToss(0.5)) {
+    auto splits = makeSplits(input, directory->getPath(), writerPool_);
+
+    std::vector<core::PlanNodePtr> tableScanPlans;
+    makeAlternativePlansWithTableScan(
+        groupingKeys, aggregates, masks, inputRowType, tableScanPlans);
+
+    if (!groupingKeys.empty()) {
+      // Use OrderBy + StreamingAggregation on original input.
+      makeStreamingPlansWithTableScan(
+          groupingKeys, aggregates, masks, inputRowType, tableScanPlans);
+    }
+
+    for (const auto& plan : tableScanPlans) {
+      plans.push_back({plan, splits});
+    }
+  } else {
+    std::vector<core::PlanNodePtr> valuesPlans;
+    makeAlternativePlansWithValues(
+        groupingKeys, aggregates, masks, input, valuesPlans);
+
+    // Evaluate same plans on flat inputs.
+    std::vector<RowVectorPtr> flatInput;
+    for (const auto& vector : input) {
+      auto flat = BaseVector::create<RowVector>(
+          vector->type(), vector->size(), vector->pool());
+      flat->copy(vector.get(), 0, 0, vector->size());
+      flatInput.push_back(flat);
+    }
+
+    makeAlternativePlansWithValues(
+        groupingKeys, aggregates, masks, flatInput, valuesPlans);
+
+    if (!groupingKeys.empty()) {
+      // Use OrderBy + StreamingAggregation on original input.
+      makeStreamingPlansWithValues(
+          groupingKeys, aggregates, masks, input, valuesPlans);
+
+      // Use OrderBy + StreamingAggregation on flattened input.
+      makeStreamingPlansWithValues(
+          groupingKeys, aggregates, masks, flatInput, valuesPlans);
+    }
+
+    for (const auto& plan : valuesPlans) {
+      plans.push_back({plan, {}});
+    }
+  }
+
+  if (persistAndRunOnce_) {
+    persistReproInfo(plans, reproPersistPath_);
+  }
+
+  return compareEquivalentPlanResults(
+      plans, customVerification, input, customVerifier);
+}
+
+bool AggregationFuzzer::verifySortedAggregation(
+    const std::vector<std::string>& groupingKeys,
+    const std::string& aggregate,
+    const std::vector<std::string>& masks,
+    const std::vector<RowVectorPtr>& input,
+    bool customVerification,
+    const std::shared_ptr<ResultVerifier>& customVerifier) {
+  auto firstPlan = PlanBuilder()
+                       .values(input)
+                       .singleAggregation(groupingKeys, {aggregate}, masks)
+                       .planNode();
+
+  bool aggregateOrderSensitive = false;
+
+  if (customVerification && customVerifier != nullptr) {
+    const auto& aggregationNode =
+        std::dynamic_pointer_cast<const core::AggregationNode>(firstPlan);
+    const auto& aggregateFunctionCall = aggregationNode->aggregates()[0];
+    const std::string& aggregateFunctionName =
+        aggregateFunctionCall.call->name();
+
+    customVerifier->initialize(
+        input,
+        groupingKeys,
+        aggregateFunctionCall,
+        aggregationNode->aggregateNames()[0]);
+
+    auto* aggregateFunctionEntry =
+        getAggregateFunctionEntry(aggregateFunctionName);
+    aggregateOrderSensitive = aggregateFunctionEntry->metadata.orderSensitive;
+  }
+
+  SCOPE_EXIT {
+    if (customVerification && customVerifier != nullptr) {
+      customVerifier->reset();
+    }
+  };
+
+  std::vector<PlanWithSplits> plans;
+  plans.push_back({firstPlan, {}});
+
+  if (!groupingKeys.empty()) {
+    plans.push_back(
+        {PlanBuilder()
+             .values(input)
+             .orderBy(groupingKeys, false)
+             .streamingAggregation(
+                 groupingKeys,
+                 {aggregate},
+                 masks,
+                 core::AggregationNode::Step::kSingle,
+                 false)
+             .planNode(),
+         {}});
+  }
+
+  std::shared_ptr<exec::test::TempDirectoryPath> directory;
+  const auto inputRowType = asRowType(input[0]->type());
+  if (isTableScanSupported(inputRowType)) {
+    directory = exec::test::TempDirectoryPath::create();
+    auto splits = makeSplits(input, directory->getPath(), writerPool_);
+
+    plans.push_back(
+        {PlanBuilder()
+             .tableScan(inputRowType)
+             .singleAggregation(groupingKeys, {aggregate}, masks)
+             .planNode(),
+         splits});
+
+    if (!groupingKeys.empty()) {
+      plans.push_back(
+          {PlanBuilder()
+               .tableScan(inputRowType)
+               .orderBy(groupingKeys, false)
+               .streamingAggregation(
+                   groupingKeys,
+                   {aggregate},
+                   masks,
+                   core::AggregationNode::Step::kSingle,
+                   false)
+               .planNode(),
+           splits});
+    }
+  }
+
+  if (customVerification &&
+      (!aggregateOrderSensitive || customVerifier == nullptr ||
+       customVerifier->supportsVerify())) {
+    // We have custom verification enabled and:
+    // 1) the aggregate function is not order sensitive (sorting the input won't
+    //    have an effect on the output) or
+    // 2) the custom verifier is null (we've deliberately turned off
+    //    verification of this aggregation) or
+    // 3) the custom verifier supports verification (it can't compare the
+    //    results of the aggregation with the reference DB)
+    // keep the custom verifier enabled.
+    return compareEquivalentPlanResults(
+        plans, customVerification, input, customVerifier, 1);
+  } else {
+    // If custom verification is not enabled or the custom verifier is used for
+    // compare and the aggregation is order sensitive (the result shoudl be
+    // deterministic if the input is sorted), then compare the results directly.
+    return compareEquivalentPlanResults(plans, false, input, nullptr, 1);
+  }
+}
+
+// verifyAggregation(std::vector<core::PlanNodePtr> plans) is tied to plan
+// created by previous verifyAggregation function. Changes in nodes there will
+// require corresponding changes here.
+void AggregationFuzzer::verifyAggregation(
+    const std::vector<PlanWithSplits>& plans) {
+  VELOX_CHECK_GT(plans.size(), 0);
+  const auto& plan = plans.front().plan;
+
+  const auto node = dynamic_cast<const core::AggregationNode*>(plan.get());
+  VELOX_CHECK_NOT_NULL(node);
+
+  // Get groupingKeys.
+  auto groupingKeys = node->groupingKeys();
+  std::vector<std::string> groupingKeyNames;
+  groupingKeyNames.reserve(groupingKeys.size());
+
+  for (const auto& key : groupingKeys) {
+    groupingKeyNames.push_back(key->name());
+  }
+
+  // Get masks.
+  std::vector<std::string> maskNames;
+  maskNames.reserve(node->aggregates().size());
+
+  for (const auto& aggregate : node->aggregates()) {
+    if (aggregate.mask) {
+      maskNames.push_back(aggregate.mask->name());
+    }
+  }
+
+  // Get inputs.
+  std::vector<RowVectorPtr> input;
+  input.reserve(node->sources().size());
+
+  for (auto source : node->sources()) {
+    auto valueNode = dynamic_cast<const core::ValuesNode*>(source.get());
+    VELOX_CHECK_NOT_NULL(valueNode);
+    auto values = valueNode->values();
+    input.insert(input.end(), values.begin(), values.end());
+  }
+
+  auto resultOrError = execute(plan);
+  if (resultOrError.exceptionPtr) {
+    ++stats_.numFailed;
+  }
+
+  // Get aggregations and determine if order dependent.
+  const int32_t numAggregates = node->aggregates().size();
+
+  std::vector<std::string> aggregateStrings;
+  aggregateStrings.reserve(numAggregates);
+
+  bool customVerification = false;
+  std::vector<std::shared_ptr<ResultVerifier>> customVerifiers(numAggregates);
+  for (auto aggregate : node->aggregates()) {
+    aggregateStrings.push_back(aggregate.call->toString());
+
+    const auto& name = aggregate.call->name();
+    auto it = customVerificationFunctions_.find(name);
+    if (it != customVerificationFunctions_.end()) {
+      customVerification = true;
+      customVerifiers.push_back(it->second);
+    } else {
+      customVerifiers.push_back(nullptr);
+    }
+  }
+
+  std::optional<MaterializedRowMultiset> expectedResult;
+  if (!customVerification) {
+    auto referenceResult =
+        computeReferenceResults(plan, input, referenceQueryRunner_.get());
+    stats_.updateReferenceQueryStats(referenceResult.second);
+    expectedResult = referenceResult.first;
+  }
+
+  if (expectedResult && resultOrError.result) {
+    ++stats_.numVerified;
+    VELOX_CHECK(
+        assertEqualResults(
+            expectedResult.value(), plan->outputType(), {resultOrError.result}),
+        "Velox and reference DB results don't match");
+    LOG(INFO) << "Verified results against reference DB";
+  }
+
+  // Test all plans.
+  testPlans(plans, customVerification, customVerifiers, resultOrError);
+}
+
+void AggregationFuzzer::Stats::print(size_t numIterations) const {
+  LOG(INFO) << "Total masked aggregations: "
+            << printPercentageStat(numMask, numIterations);
+  LOG(INFO) << "Total global aggregations: "
+            << printPercentageStat(numGlobal, numIterations);
+  LOG(INFO) << "Total group-by aggregations: "
+            << printPercentageStat(numGroupBy, numIterations);
+  LOG(INFO) << "Total distinct aggregations: "
+            << printPercentageStat(numDistinct, numIterations);
+  LOG(INFO) << "Total aggregations over distinct inputs: "
+            << printPercentageStat(numDistinctInputs, numIterations);
+  LOG(INFO) << "Total window expressions: "
+            << printPercentageStat(numWindow, numIterations);
+  AggregationFuzzerBase::Stats::print(numIterations);
+}
+
+namespace {
+// Merges a vector of RowVectors into one RowVector.
+RowVectorPtr mergeRowVectors(
+    const std::vector<RowVectorPtr>& results,
+    velox::memory::MemoryPool* pool) {
+  auto totalCount = 0;
+  for (const auto& result : results) {
+    totalCount += result->size();
+  }
+  auto copy =
+      BaseVector::create<RowVector>(results[0]->type(), totalCount, pool);
+  auto copyCount = 0;
+  for (const auto& result : results) {
+    copy->copy(result.get(), copyCount, 0, result->size());
+    copyCount += result->size();
+  }
+  return copy;
+}
+
+} // namespace
+
+bool AggregationFuzzer::compareEquivalentPlanResults(
+    const std::vector<PlanWithSplits>& plans,
+    bool customVerification,
+    const std::vector<RowVectorPtr>& input,
+    const std::shared_ptr<ResultVerifier>& customVerifier,
+    int32_t maxDrivers,
+    bool testWithSpilling) {
+  try {
+    auto firstPlan = plans.at(0).plan;
+    auto resultOrError = execute(firstPlan);
+    if (resultOrError.exceptionPtr) {
+      ++stats_.numFailed;
+    }
+
+    // If Velox successfully executes a plan, we attempt to verify
+    // the plan against the reference DB as follows:
+    // 1) If deterministic function (i.e. customVerification is false)
+    //    then try and have the reference DB execute the plan and assert
+    //    results are equal.
+    // 2) If Non deterministic function, and if the reference query runner
+    //    supports Velox vectors then we have the reference DB execute the plan
+    //    and use ResultVerifier::compare api (if supported ) to validate the
+    //    results.
+
+    if (resultOrError.result != nullptr) {
+      if (!customVerification) {
+        auto referenceResult = computeReferenceResults(
+            firstPlan, input, referenceQueryRunner_.get());
+        stats_.updateReferenceQueryStats(referenceResult.second);
+        auto expectedResult = referenceResult.first;
+
+        if (expectedResult) {
+          ++stats_.numVerified;
+          VELOX_CHECK(
+              assertEqualResults(
+                  expectedResult.value(),
+                  firstPlan->outputType(),
+                  {resultOrError.result}),
+              "Velox and reference DB results don't match");
+          LOG(INFO) << "Verified results against reference DB";
+        }
+      } else if (referenceQueryRunner_->supportsVeloxVectorResults()) {
+        if (isSupportedType(firstPlan->outputType()) &&
+            isSupportedType(input.front()->type())) {
+          auto referenceResult = computeReferenceResultsAsVector(
+              firstPlan, input, referenceQueryRunner_.get());
+          stats_.updateReferenceQueryStats(referenceResult.second);
+
+          if (referenceResult.first) {
+            velox::fuzzer::ResultOrError expected;
+            expected.result =
+                mergeRowVectors(referenceResult.first.value(), pool_.get());
+
+            compare(
+                resultOrError, customVerification, {customVerifier}, expected);
+            ++stats_.numVerified;
+          }
+        }
+      }
+    }
+
+    testPlans(
+        plans,
+        customVerification,
+        {customVerifier},
+        resultOrError,
+        maxDrivers,
+        testWithSpilling);
+
+    return resultOrError.exceptionPtr != nullptr;
+  } catch (...) {
+    if (!reproPersistPath_.empty()) {
+      persistReproInfo(plans, reproPersistPath_);
+    }
+    throw;
+  }
+}
+
+bool AggregationFuzzer::verifyDistinctAggregation(
+    const std::vector<std::string>& groupingKeys,
+    const std::string& aggregate,
+    const std::vector<std::string>& masks,
+    const std::vector<RowVectorPtr>& input,
+    bool customVerification,
+    const std::shared_ptr<ResultVerifier>& customVerifier) {
+  const auto firstPlan =
+      PlanBuilder()
+          .values(input)
+          .singleAggregation(groupingKeys, {aggregate}, masks)
+          .planNode();
+
+  if (customVerification) {
+    if (customVerification && customVerifier != nullptr) {
+      const auto& aggregationNode =
+          std::dynamic_pointer_cast<const core::AggregationNode>(firstPlan);
+
+      customVerifier->initialize(
+          input,
+          groupingKeys,
+          aggregationNode->aggregates()[0],
+          aggregationNode->aggregateNames()[0]);
+    }
+  }
+
+  SCOPE_EXIT {
+    if (customVerification && customVerifier != nullptr) {
+      customVerifier->reset();
+    }
+  };
+
+  // Create all the plans upfront.
+  std::vector<PlanWithSplits> plans;
+  plans.push_back({firstPlan, {}});
+
+  if (!groupingKeys.empty()) {
+    plans.push_back(
+        {PlanBuilder()
+             .values(input)
+             .orderBy(groupingKeys, false)
+             .streamingAggregation(
+                 groupingKeys,
+                 {aggregate},
+                 masks,
+                 core::AggregationNode::Step::kSingle,
+                 false)
+             .planNode(),
+         {}});
+  }
+
+  // Alternate between using Values and TableScan node.
+
+  std::shared_ptr<exec::test::TempDirectoryPath> directory;
+  const auto inputRowType = asRowType(input[0]->type());
+  if (isTableScanSupported(inputRowType) && vectorFuzzer_.coinToss(0.5)) {
+    directory = exec::test::TempDirectoryPath::create();
+    auto splits = makeSplits(input, directory->getPath(), writerPool_);
+
+    plans.push_back(
+        {PlanBuilder()
+             .tableScan(inputRowType)
+             .singleAggregation(groupingKeys, {aggregate}, masks)
+             .planNode(),
+         splits});
+
+    if (!groupingKeys.empty()) {
+      plans.push_back(
+          {PlanBuilder()
+               .tableScan(inputRowType)
+               .orderBy(groupingKeys, false)
+               .streamingAggregation(
+                   groupingKeys,
+                   {aggregate},
+                   masks,
+                   core::AggregationNode::Step::kSingle,
+                   false)
+               .planNode(),
+           splits});
+    }
+  }
+
+  if (persistAndRunOnce_) {
+    persistReproInfo(plans, reproPersistPath_);
+  }
+
+  // Distinct aggregation must run single-threaded or data must be partitioned
+  // on group-by keys among threads.
+  return compareEquivalentPlanResults(
+      plans, customVerification, input, customVerifier, 1, false);
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/AggregationFuzzer.h b/velox/exec/fuzzer/AggregationFuzzer.h
similarity index 75%
rename from velox/exec/tests/utils/AggregationFuzzer.h
rename to velox/exec/fuzzer/AggregationFuzzer.h
index 8f52c2d29efb0..9c5e2199c26e0 100644
--- a/velox/exec/tests/utils/AggregationFuzzer.h
+++ b/velox/exec/fuzzer/AggregationFuzzer.h
@@ -16,18 +16,19 @@
 #pragma once
 
 #include "velox/exec/Aggregate.h"
-#include "velox/exec/tests/utils/ReferenceQueryRunner.h"
+#include "velox/exec/fuzzer/AggregationFuzzerBase.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 namespace facebook::velox::exec::test {
 
-static constexpr const std::string_view kPlanNodeFileName = "plan_nodes";
-
 /// Runs the aggregation fuzzer.
 /// @param signatureMap Map of all aggregate function signatures.
 /// @param seed Random seed - Pass the same seed for reproducibility.
 /// @param orderDependentFunctions Map of functions that depend on order of
 /// input.
+/// @param orderableGroupKeys Whether group keys must be orderable or be just
+/// comparable.
 /// @param planPath Path to persisted plan information. If this is
 /// supplied, fuzzer will only verify the plans.
 /// @param referenceQueryRunner Reference query runner for results
@@ -35,9 +36,15 @@ static constexpr const std::string_view kPlanNodeFileName = "plan_nodes";
 void aggregateFuzzer(
     AggregateFunctionSignatureMap signatureMap,
     size_t seed,
-    const std::unordered_map<std::string, std::string>& orderDependentFunctions,
+    const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>&
+        orderDependentFunctions,
+    const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
+        customInputGenerators,
     VectorFuzzer::Options::TimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
+    const std::unordered_map<std::string, std::string>& hiveConfigs,
+    bool orderableGroupKeys,
     const std::optional<std::string>& planPath,
     std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/AggregationFuzzerBase.cpp b/velox/exec/fuzzer/AggregationFuzzerBase.cpp
new file mode 100644
index 0000000000000..db6796d5bdea5
--- /dev/null
+++ b/velox/exec/fuzzer/AggregationFuzzerBase.cpp
@@ -0,0 +1,772 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/fuzzer/AggregationFuzzerBase.h"
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include "velox/common/base/Fs.h"
+#include "velox/common/base/VeloxException.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/exec/fuzzer/DuckQueryRunner.h"
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/expression/SignatureBinder.h"
+#include "velox/expression/fuzzer/ArgumentTypeFuzzer.h"
+#include "velox/vector/VectorSaver.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int32(steps, 10, "Number of plans to generate and execute.");
+
+DEFINE_int32(
+    duration_sec,
+    0,
+    "For how long it should run (in seconds). If zero, "
+    "it executes exactly --steps iterations and exits.");
+
+DEFINE_int32(
+    batch_size,
+    100,
+    "The number of elements on each generated vector.");
+
+DEFINE_int32(num_batches, 10, "The number of generated vectors.");
+
+DEFINE_int32(
+    max_num_varargs,
+    5,
+    "The maximum number of variadic arguments fuzzer will generate for "
+    "functions that accept variadic arguments. Fuzzer will generate up to "
+    "max_num_varargs arguments for the variadic list in addition to the "
+    "required arguments by the function.");
+
+DEFINE_double(
+    null_ratio,
+    0.1,
+    "Chance of adding a null constant to the plan, or null value in a vector "
+    "(expressed as double from 0 to 1).");
+
+DEFINE_string(
+    repro_persist_path,
+    "",
+    "Directory path for persistence of data and SQL when fuzzer fails for "
+    "future reproduction. Empty string disables this feature.");
+
+DEFINE_bool(
+    persist_and_run_once,
+    false,
+    "Persist repro info before evaluation and only run one iteration. "
+    "This is to rerun with the seed number and persist repro info upon a "
+    "crash failure. Only effective if repro_persist_path is set.");
+
+DEFINE_bool(
+    log_signature_stats,
+    false,
+    "Log statistics about function signatures");
+
+DEFINE_bool(
+    enable_oom_injection,
+    false,
+    "When enabled OOMs will randomly be triggered while executing query "
+    "plans. The goal of this mode is to ensure unexpected exceptions "
+    "aren't thrown and the process isn't killed in the process of cleaning "
+    "up after failures. Therefore, results are not compared when this is "
+    "enabled. Note that this option only works in debug builds.");
+
+namespace facebook::velox::exec::test {
+
+int32_t AggregationFuzzerBase::randInt(int32_t min, int32_t max) {
+  return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
+}
+
+bool AggregationFuzzerBase::isSupportedType(const TypePtr& type) const {
+  // Date / IntervalDayTime/ Unknown are not currently supported by DWRF.
+  if (type->isDate() || type->isIntervalDayTime() || type->isUnKnown()) {
+    return false;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (!isSupportedType(type->childAt(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool AggregationFuzzerBase::addSignature(
+    const std::string& name,
+    const FunctionSignaturePtr& signature) {
+  ++functionsStats.numSignatures;
+
+  if (signature->variableArity()) {
+    LOG(WARNING) << "Skipping variadic function signature: " << name
+                 << signature->toString();
+    return false;
+  }
+
+  if (!signature->variables().empty()) {
+    bool skip = false;
+    std::unordered_set<std::string> typeVariables;
+    for (auto& [variableName, variable] : signature->variables()) {
+      if (variable.isIntegerParameter()) {
+        LOG(WARNING) << "Skipping generic function signature: " << name
+                     << signature->toString();
+        skip = true;
+        break;
+      }
+
+      typeVariables.insert(variableName);
+    }
+    if (skip) {
+      return false;
+    }
+
+    signatureTemplates_.push_back(
+        {name, signature.get(), std::move(typeVariables)});
+  } else {
+    CallableSignature callable{
+        .name = name,
+        .args = {},
+        .returnType =
+            SignatureBinder::tryResolveType(signature->returnType(), {}, {}),
+        .constantArgs = {}};
+    VELOX_CHECK_NOT_NULL(callable.returnType);
+
+    // Process each argument and figure out its type.
+    for (const auto& arg : signature->argumentTypes()) {
+      auto resolvedType = SignatureBinder::tryResolveType(arg, {}, {});
+      VELOX_CHECK_NOT_NULL(resolvedType);
+
+      // SignatureBinder::tryResolveType produces ROW types with empty
+      // field names. These won't work with TableScan.
+      if (resolvedType->isRow()) {
+        std::vector<std::string> names;
+        for (auto i = 0; i < resolvedType->size(); ++i) {
+          names.push_back(fmt::format("field{}", i));
+        }
+
+        std::vector<TypePtr> types = resolvedType->asRow().children();
+
+        resolvedType = ROW(std::move(names), std::move(types));
+      }
+
+      callable.args.emplace_back(resolvedType);
+    }
+
+    signatures_.emplace_back(callable);
+  }
+
+  ++functionsStats.numSupportedSignatures;
+  return true;
+}
+
+void AggregationFuzzerBase::addAggregationSignatures(
+    const AggregateFunctionSignatureMap& signatureMap) {
+  for (auto& [name, signatures] : signatureMap) {
+    ++functionsStats.numFunctions;
+    bool hasSupportedSignature = false;
+    for (auto& signature : signatures) {
+      hasSupportedSignature |= addSignature(name, signature);
+    }
+    if (hasSupportedSignature) {
+      ++functionsStats.numSupportedFunctions;
+    }
+  }
+}
+
+std::pair<CallableSignature, AggregationFuzzerBase::SignatureStats&>
+AggregationFuzzerBase::pickSignature() {
+  size_t idx = boost::random::uniform_int_distribution<uint32_t>(
+      0, signatures_.size() + signatureTemplates_.size() - 1)(rng_);
+  CallableSignature signature;
+  if (idx < signatures_.size()) {
+    signature = signatures_[idx];
+  } else {
+    const auto& signatureTemplate =
+        signatureTemplates_[idx - signatures_.size()];
+    signature.name = signatureTemplate.name;
+    velox::fuzzer::ArgumentTypeFuzzer typeFuzzer(
+        *signatureTemplate.signature, rng_);
+    VELOX_CHECK(typeFuzzer.fuzzArgumentTypes(FLAGS_max_num_varargs));
+    signature.args = typeFuzzer.argumentTypes();
+  }
+
+  return {signature, signatureStats_[idx]};
+}
+
+std::vector<std::string> AggregationFuzzerBase::generateKeys(
+    const std::string& prefix,
+    std::vector<std::string>& names,
+    std::vector<TypePtr>& types) {
+  static const std::vector<TypePtr> kNonFloatingPointTypes{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      VARCHAR(),
+      VARBINARY(),
+      TIMESTAMP(),
+  };
+
+  auto numKeys = boost::random::uniform_int_distribution<uint32_t>(1, 5)(rng_);
+  std::vector<std::string> keys;
+  for (auto i = 0; i < numKeys; ++i) {
+    keys.push_back(fmt::format("{}{}", prefix, i));
+
+    // Pick random, possibly complex, type.
+    if (orderableGroupKeys_) {
+      types.push_back(
+          vectorFuzzer_.randOrderableType(kNonFloatingPointTypes, 2));
+    } else {
+      types.push_back(vectorFuzzer_.randType(kNonFloatingPointTypes, 2));
+    }
+    names.push_back(keys.back());
+  }
+  return keys;
+}
+
+std::vector<std::string> AggregationFuzzerBase::generateSortingKeys(
+    const std::string& prefix,
+    std::vector<std::string>& names,
+    std::vector<TypePtr>& types) {
+  std::vector<std::string> keys;
+  auto numKeys = boost::random::uniform_int_distribution<uint32_t>(1, 5)(rng_);
+  for (auto i = 0; i < numKeys; ++i) {
+    keys.push_back(fmt::format("{}{}", prefix, i));
+
+    // Pick random, possibly complex, type.
+    types.push_back(vectorFuzzer_.randOrderableType(2));
+    names.push_back(keys.back());
+  }
+
+  return keys;
+}
+
+std::shared_ptr<InputGenerator> AggregationFuzzerBase::findInputGenerator(
+    const CallableSignature& signature) {
+  auto generatorIt = customInputGenerators_.find(signature.name);
+  if (generatorIt != customInputGenerators_.end()) {
+    return generatorIt->second;
+  }
+
+  return nullptr;
+}
+
+std::vector<RowVectorPtr> AggregationFuzzerBase::generateInputData(
+    std::vector<std::string> names,
+    std::vector<TypePtr> types,
+    const std::optional<CallableSignature>& signature) {
+  std::shared_ptr<InputGenerator> generator;
+  if (signature.has_value()) {
+    generator = findInputGenerator(signature.value());
+  }
+
+  const auto size = vectorFuzzer_.getOptions().vectorSize;
+
+  auto inputType = ROW(std::move(names), std::move(types));
+  std::vector<RowVectorPtr> input;
+  for (auto i = 0; i < FLAGS_num_batches; ++i) {
+    std::vector<VectorPtr> children;
+
+    if (generator != nullptr) {
+      children = generator->generate(
+          signature->args, vectorFuzzer_, rng_, pool_.get());
+    }
+
+    for (auto j = children.size(); j < inputType->size(); ++j) {
+      children.push_back(vectorFuzzer_.fuzz(inputType->childAt(j), size));
+    }
+
+    input.push_back(std::make_shared<RowVector>(
+        pool_.get(), inputType, nullptr, size, std::move(children)));
+  }
+
+  if (generator != nullptr) {
+    generator->reset();
+  }
+
+  return input;
+}
+
+std::vector<RowVectorPtr> AggregationFuzzerBase::generateInputDataWithRowNumber(
+    std::vector<std::string> names,
+    std::vector<TypePtr> types,
+    const std::vector<std::string>& partitionKeys,
+    const CallableSignature& signature) {
+  names.push_back("row_number");
+  types.push_back(BIGINT());
+
+  auto generator = findInputGenerator(signature);
+
+  std::vector<RowVectorPtr> input;
+  vector_size_t size = vectorFuzzer_.getOptions().vectorSize;
+  velox::test::VectorMaker vectorMaker{pool_.get()};
+  int64_t rowNumber = 0;
+
+  std::unordered_set<std::string> partitionKeySet;
+  partitionKeySet.reserve(partitionKeys.size());
+  for (auto partitionKey : partitionKeys) {
+    partitionKeySet.insert(partitionKey);
+  }
+
+  for (auto j = 0; j < FLAGS_num_batches; ++j) {
+    std::vector<VectorPtr> children;
+
+    if (generator != nullptr) {
+      children =
+          generator->generate(signature.args, vectorFuzzer_, rng_, pool_.get());
+    }
+
+    // Number of partitions is randomly generated and is at least 1.
+    auto numPartitions = size ? randInt(1, size) : 1;
+    auto indices = vectorFuzzer_.fuzzIndices(size, numPartitions);
+    auto nulls = vectorFuzzer_.fuzzNulls(size);
+    for (auto i = children.size(); i < types.size() - 1; ++i) {
+      if (partitionKeySet.find(names[i]) != partitionKeySet.end()) {
+        // The partition keys are built with a dictionary over a smaller set of
+        // values. This is done to introduce some repetition of key values for
+        // windowing.
+        auto baseVector = vectorFuzzer_.fuzz(types[i], numPartitions);
+        children.push_back(
+            BaseVector::wrapInDictionary(nulls, indices, size, baseVector));
+      } else {
+        children.push_back(vectorFuzzer_.fuzz(types[i], size));
+      }
+    }
+    children.push_back(vectorMaker.flatVector<int64_t>(
+        size, [&](auto /*row*/) { return rowNumber++; }));
+    input.push_back(vectorMaker.rowVector(names, children));
+  }
+
+  if (generator != nullptr) {
+    generator->reset();
+  }
+
+  return input;
+}
+
+AggregationFuzzerBase::PlanWithSplits AggregationFuzzerBase::deserialize(
+    const folly::dynamic& obj) {
+  auto plan = velox::ISerializable::deserialize<core::PlanNode>(
+      obj["plan"], pool_.get());
+
+  std::vector<exec::Split> splits;
+  if (obj.count("splits") > 0) {
+    auto paths =
+        ISerializable::deserialize<std::vector<std::string>>(obj["splits"]);
+    for (const auto& path : paths) {
+      splits.push_back(makeSplit(path));
+    }
+  }
+
+  return PlanWithSplits{plan, splits};
+}
+
+void AggregationFuzzerBase::printSignatureStats() {
+  if (!FLAGS_log_signature_stats) {
+    return;
+  }
+
+  for (auto i = 0; i < signatureStats_.size(); ++i) {
+    const auto& stats = signatureStats_[i];
+    if (stats.numRuns == 0) {
+      continue;
+    }
+
+    if (stats.numFailed * 1.0 / stats.numRuns < 0.5) {
+      continue;
+    }
+
+    if (i < signatures_.size()) {
+      LOG(INFO) << "Signature #" << i << " failed " << stats.numFailed
+                << " out of " << stats.numRuns
+                << " times: " << signatures_[i].toString();
+    } else {
+      const auto& signatureTemplate =
+          signatureTemplates_[i - signatures_.size()];
+      LOG(INFO) << "Signature template #" << i << " failed " << stats.numFailed
+                << " out of " << stats.numRuns
+                << " times: " << signatureTemplate.name << "("
+                << signatureTemplate.signature->toString() << ")";
+    }
+  }
+}
+
+void AggregationFuzzerBase::logVectors(
+    const std::vector<RowVectorPtr>& vectors) {
+  if (!VLOG_IS_ON(1)) {
+    return;
+  }
+  for (auto i = 0; i < vectors.size(); ++i) {
+    VLOG(1) << "Input batch " << i << ":";
+    for (auto j = 0; j < vectors[i]->size(); ++j) {
+      VLOG(1) << "\tRow " << j << ": " << vectors[i]->toString(j);
+    }
+  }
+}
+
+velox::fuzzer::ResultOrError AggregationFuzzerBase::execute(
+    const core::PlanNodePtr& plan,
+    const std::vector<exec::Split>& splits,
+    bool injectSpill,
+    bool abandonPartial,
+    int32_t maxDrivers) {
+  LOG(INFO) << "Executing query plan: " << std::endl
+            << plan->toString(true, true);
+
+  velox::fuzzer::ResultOrError resultOrError;
+  try {
+    std::shared_ptr<TempDirectoryPath> spillDirectory;
+    AssertQueryBuilder builder(plan);
+
+    builder.configs(queryConfigs_);
+
+    int32_t spillPct{0};
+    if (injectSpill) {
+      spillDirectory = exec::test::TempDirectoryPath::create();
+      builder.spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(core::QueryConfig::kAggregationSpillEnabled, "true")
+          .config(core::QueryConfig::kMaxSpillRunRows, randInt(32, 1L << 30));
+      // Randomized the spill injection with a percentage less than 100.
+      spillPct = 20;
+    }
+
+    if (abandonPartial) {
+      builder.config(core::QueryConfig::kAbandonPartialAggregationMinRows, "1")
+          .config(core::QueryConfig::kAbandonPartialAggregationMinPct, "0")
+          .config(core::QueryConfig::kMaxPartialAggregationMemory, "0")
+          .config(core::QueryConfig::kMaxExtendedPartialAggregationMemory, "0");
+    }
+
+    if (!splits.empty()) {
+      builder.splits(splits);
+    }
+
+    ScopedOOMInjector oomInjector(
+        []() -> bool { return folly::Random::oneIn(10); },
+        10); // Check the condition every 10 ms.
+    if (FLAGS_enable_oom_injection) {
+      oomInjector.enable();
+    }
+
+    TestScopedSpillInjection scopedSpillInjection(spillPct);
+    resultOrError.result =
+        builder.maxDrivers(maxDrivers).copyResults(pool_.get());
+  } catch (VeloxUserError&) {
+    // NOTE: velox user exception is accepted as it is caused by the invalid
+    // fuzzer test inputs.
+    resultOrError.exceptionPtr = std::current_exception();
+  } catch (VeloxRuntimeError& e) {
+    if (FLAGS_enable_oom_injection &&
+        e.errorCode() == facebook::velox::error_code::kMemCapExceeded &&
+        e.message() == ScopedOOMInjector::kErrorMessage) {
+      // If we enabled OOM injection we expect the exception thrown by the
+      // ScopedOOMInjector. Set the exceptionPtr, in case anything up stream
+      // attempts to use the results if exceptionPtr is not set.
+      resultOrError.exceptionPtr = std::current_exception();
+    } else {
+      throw e;
+    }
+  }
+
+  return resultOrError;
+}
+
+void AggregationFuzzerBase::testPlan(
+    const PlanWithSplits& planWithSplits,
+    bool injectSpill,
+    bool abandonPartial,
+    bool customVerification,
+    const std::vector<std::shared_ptr<ResultVerifier>>& customVerifiers,
+    const velox::fuzzer::ResultOrError& expected,
+    int32_t maxDrivers) {
+  auto actual = execute(
+      planWithSplits.plan,
+      planWithSplits.splits,
+      injectSpill,
+      abandonPartial,
+      maxDrivers);
+  compare(actual, customVerification, customVerifiers, expected);
+}
+
+void AggregationFuzzerBase::compare(
+    const velox::fuzzer::ResultOrError& actual,
+    bool customVerification,
+    const std::vector<std::shared_ptr<ResultVerifier>>& customVerifiers,
+    const velox::fuzzer::ResultOrError& expected) {
+  // Compare results or exceptions (if any). Fail is anything is different.
+  if (FLAGS_enable_oom_injection) {
+    // If OOM injection is enabled and we've made it this far and the test
+    // is considered a success.  We don't bother checking the results.
+    return;
+  }
+
+  // Compare results or exceptions (if any). Fail if anything is different.
+  if (expected.exceptionPtr || actual.exceptionPtr) {
+    // Throws in case exceptions are not compatible.
+    velox::fuzzer::compareExceptions(
+        expected.exceptionPtr, actual.exceptionPtr);
+    return;
+  }
+
+  if (!customVerification) {
+    VELOX_CHECK(
+        assertEqualResults({expected.result}, {actual.result}),
+        "Logically equivalent plans produced different results");
+    return;
+  }
+
+  VELOX_CHECK_NOT_NULL(expected.result);
+  VELOX_CHECK_NOT_NULL(actual.result);
+
+  VELOX_CHECK_EQ(
+      expected.result->size(),
+      actual.result->size(),
+      "Logically equivalent plans produced different number of rows");
+
+  for (auto& verifier : customVerifiers) {
+    if (verifier == nullptr) {
+      continue;
+    }
+
+    if (verifier->supportsCompare()) {
+      VELOX_CHECK(
+          verifier->compare(expected.result, actual.result),
+          "Logically equivalent plans produced different results");
+    } else if (verifier->supportsVerify()) {
+      VELOX_CHECK(
+          verifier->verify(actual.result),
+          "Result of a logically equivalent plan failed custom verification");
+    } else {
+      VELOX_UNREACHABLE(
+          "Custom verifier must support either 'compare' or 'verify' API.");
+    }
+  }
+}
+
+namespace {
+void writeToFile(
+    const std::string& path,
+    const VectorPtr& vector,
+    memory::MemoryPool* pool) {
+  dwrf::WriterOptions options;
+  options.schema = vector->type();
+  options.memoryPool = pool;
+  auto writeFile = std::make_unique<LocalWriteFile>(path, true, false);
+  auto sink =
+      std::make_unique<dwio::common::WriteFileSink>(std::move(writeFile), path);
+  dwrf::Writer writer(std::move(sink), options);
+  writer.write(vector);
+  writer.close();
+}
+} // namespace
+
+void AggregationFuzzerBase::Stats::updateReferenceQueryStats(
+    ReferenceQueryErrorCode errorCode) {
+  if (errorCode == ReferenceQueryErrorCode::kReferenceQueryFail) {
+    ++numReferenceQueryFailed;
+  } else if (errorCode == ReferenceQueryErrorCode::kReferenceQueryUnsupported) {
+    ++numReferenceQueryNotSupported;
+  } else {
+    VELOX_CHECK(
+        errorCode == ReferenceQueryErrorCode::kSuccess,
+        "Error should be handled by branches above.");
+  }
+}
+
+void AggregationFuzzerBase::Stats::print(size_t numIterations) const {
+  LOG(INFO) << "Total functions tested: " << functionNames.size();
+  LOG(INFO) << "Total iterations requiring sorted inputs: "
+            << printPercentageStat(numSortedInputs, numIterations);
+  LOG(INFO) << "Total iterations verified against reference DB: "
+            << printPercentageStat(numVerified, numIterations);
+  LOG(INFO)
+      << "Total functions not verified (verification skipped / not supported by reference DB / reference DB failed): "
+      << printPercentageStat(numVerificationSkipped, numIterations) << " / "
+      << printPercentageStat(numReferenceQueryNotSupported, numIterations)
+      << " / " << printPercentageStat(numReferenceQueryFailed, numIterations);
+  LOG(INFO) << "Total failed functions: "
+            << printPercentageStat(numFailed, numIterations);
+}
+
+std::string printPercentageStat(size_t n, size_t total) {
+  return fmt::format("{} ({:.2f}%)", n, (double)n / total * 100);
+}
+
+void printStats(const AggregationFuzzerBase::FunctionsStats& stats) {
+  LOG(INFO) << fmt::format(
+      "Total functions: {} ({} signatures)",
+      stats.numFunctions,
+      stats.numSignatures);
+  LOG(INFO) << "Functions with at least one supported signature: "
+            << printPercentageStat(
+                   stats.numSupportedFunctions, stats.numFunctions);
+
+  size_t numNotSupportedFunctions =
+      stats.numFunctions - stats.numSupportedFunctions;
+  LOG(INFO) << "Functions with no supported signature: "
+            << printPercentageStat(
+                   numNotSupportedFunctions, stats.numFunctions);
+  LOG(INFO) << "Supported function signatures: "
+            << printPercentageStat(
+                   stats.numSupportedSignatures, stats.numSignatures);
+
+  size_t numNotSupportedSignatures =
+      stats.numSignatures - stats.numSupportedSignatures;
+  LOG(INFO) << "Unsupported function signatures: "
+            << printPercentageStat(
+                   numNotSupportedSignatures, stats.numSignatures);
+}
+
+std::string makeFunctionCall(
+    const std::string& name,
+    const std::vector<std::string>& argNames,
+    bool sortedInputs,
+    bool distinctInputs,
+    bool ignoreNulls) {
+  std::ostringstream call;
+  call << name << "(";
+
+  const auto args = folly::join(", ", argNames);
+  if (sortedInputs) {
+    call << args << " ORDER BY " << args;
+  } else if (distinctInputs) {
+    call << "distinct " << args;
+  } else {
+    call << args;
+  }
+  if (ignoreNulls) {
+    call << " IGNORE NULLS";
+  }
+  call << ")";
+
+  return call.str();
+}
+
+std::vector<std::string> makeNames(size_t n) {
+  std::vector<std::string> names;
+  for (auto i = 0; i < n; ++i) {
+    names.push_back(fmt::format("c{}", i));
+  }
+  return names;
+}
+
+folly::dynamic serialize(
+    const AggregationFuzzerBase::PlanWithSplits& planWithSplits,
+    const std::string& dirPath,
+    std::unordered_map<std::string, std::string>& filePaths) {
+  folly::dynamic obj = folly::dynamic::object();
+  obj["plan"] = planWithSplits.plan->serialize();
+  if (planWithSplits.splits.empty()) {
+    return obj;
+  }
+
+  folly::dynamic jsonSplits = folly::dynamic::array();
+  jsonSplits.reserve(planWithSplits.splits.size());
+  for (const auto& split : planWithSplits.splits) {
+    const auto filePath =
+        std::dynamic_pointer_cast<connector::hive::HiveConnectorSplit>(
+            split.connectorSplit)
+            ->filePath;
+    if (filePaths.count(filePath) == 0) {
+      const auto newFilePath = fmt::format("{}/{}", dirPath, filePaths.size());
+      fs::copy(filePath, newFilePath);
+      filePaths.insert({filePath, newFilePath});
+    }
+    jsonSplits.push_back(filePaths.at(filePath));
+  }
+  obj["splits"] = jsonSplits;
+  return obj;
+}
+
+void persistReproInfo(
+    const std::vector<AggregationFuzzerBase::PlanWithSplits>& plans,
+    const std::string& basePath) {
+  if (!common::generateFileDirectory(basePath.c_str())) {
+    return;
+  }
+
+  // Create a new directory
+  const auto dirPathOptional =
+      common::generateTempFolderPath(basePath.c_str(), "aggregationVerifier");
+  if (!dirPathOptional.has_value()) {
+    LOG(ERROR)
+        << "Failed to create directory for persisting plans using base path: "
+        << basePath;
+    return;
+  }
+
+  const auto dirPath = dirPathOptional.value();
+
+  // Save plans and splits.
+  const std::string planPath = fmt::format("{}/{}", dirPath, kPlanNodeFileName);
+  std::unordered_map<std::string, std::string> filePaths;
+  try {
+    folly::dynamic array = folly::dynamic::array();
+    array.reserve(plans.size());
+    for (auto planWithSplits : plans) {
+      array.push_back(serialize(planWithSplits, dirPath, filePaths));
+    }
+    auto planJson = folly::toJson(array);
+    saveStringToFile(planJson, planPath.c_str());
+    LOG(INFO) << "Persisted aggregation plans to " << planPath;
+  } catch (std::exception& e) {
+    LOG(ERROR) << "Failed to store aggregation plans to " << planPath << ": "
+               << e.what();
+  }
+}
+
+std::unique_ptr<ReferenceQueryRunner> setupReferenceQueryRunner(
+    memory::MemoryPool* aggregatePool,
+    const std::string& prestoUrl,
+    const std::string& runnerName,
+    const uint32_t& reqTimeoutMs) {
+  if (prestoUrl.empty()) {
+    auto duckQueryRunner = std::make_unique<DuckQueryRunner>(aggregatePool);
+    duckQueryRunner->disableAggregateFunctions({
+        "skewness",
+        // DuckDB results on constant inputs are incorrect. Should be NaN,
+        // but DuckDB returns some random value.
+        "kurtosis",
+        "entropy",
+        // Regr_count result in DuckDB is incorrect when the input data is null.
+        "regr_count",
+    });
+    LOG(INFO) << "Using DuckDB as the reference DB.";
+    return duckQueryRunner;
+  } else {
+    return std::make_unique<PrestoQueryRunner>(
+        aggregatePool,
+        prestoUrl,
+        runnerName,
+        static_cast<std::chrono::milliseconds>(reqTimeoutMs));
+    LOG(INFO) << "Using Presto as the reference DB.";
+  }
+}
+
+std::vector<std::string> retrieveWindowFunctionName(
+    const core::PlanNodePtr& node) {
+  auto windowNode = std::dynamic_pointer_cast<const core::WindowNode>(node);
+  VELOX_CHECK_NOT_NULL(windowNode);
+  std::vector<std::string> functionNames;
+  for (const auto& function : windowNode->windowFunctions()) {
+    functionNames.push_back(function.functionCall->name());
+  }
+  return functionNames;
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/AggregationFuzzerBase.h b/velox/exec/fuzzer/AggregationFuzzerBase.h
new file mode 100644
index 0000000000000..3a314605db52b
--- /dev/null
+++ b/velox/exec/fuzzer/AggregationFuzzerBase.h
@@ -0,0 +1,328 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/Split.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+DECLARE_int32(steps);
+
+DECLARE_int32(duration_sec);
+
+DECLARE_int32(batch_size);
+
+DECLARE_int32(num_batches);
+
+DECLARE_int32(max_num_varargs);
+
+DECLARE_double(null_ratio);
+
+DECLARE_string(repro_persist_path);
+
+DECLARE_bool(persist_and_run_once);
+
+DECLARE_bool(log_signature_stats);
+
+namespace facebook::velox::exec::test {
+
+using facebook::velox::fuzzer::CallableSignature;
+using facebook::velox::fuzzer::SignatureTemplate;
+
+constexpr const std::string_view kPlanNodeFileName = "plan_nodes";
+
+class AggregationFuzzerBase {
+ public:
+  AggregationFuzzerBase(
+      size_t initialSeed,
+      const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>&
+          customVerificationFunctions,
+      const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
+          customInputGenerators,
+      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      const std::unordered_map<std::string, std::string>& queryConfigs,
+      const std::unordered_map<std::string, std::string>& hiveConfigs,
+      bool orderableGroupKeys,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner)
+      : customVerificationFunctions_{customVerificationFunctions},
+        customInputGenerators_{customInputGenerators},
+        queryConfigs_{queryConfigs},
+        orderableGroupKeys_{orderableGroupKeys},
+        persistAndRunOnce_{FLAGS_persist_and_run_once},
+        reproPersistPath_{FLAGS_repro_persist_path},
+        referenceQueryRunner_{std::move(referenceQueryRunner)},
+        vectorFuzzer_{getFuzzerOptions(timestampPrecision), pool_.get()} {
+    filesystems::registerLocalFileSystem();
+    auto configs = hiveConfigs;
+    auto hiveConnector =
+        connector::getConnectorFactory(
+            connector::hive::HiveConnectorFactory::kHiveConnectorName)
+            ->newConnector(
+                kHiveConnectorId,
+                std::make_shared<config::ConfigBase>(std::move(configs)));
+    connector::registerConnector(hiveConnector);
+
+    seed(initialSeed);
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    std::vector<exec::Split> splits;
+  };
+
+  struct FunctionsStats {
+    size_t numFunctions = 0;
+    size_t numSignatures = 0;
+    size_t numSupportedFunctions = 0;
+    size_t numSupportedSignatures = 0;
+  };
+
+  struct SignatureStats {
+    /// Number of times a signature was chosen.
+    size_t numRuns{0};
+
+    /// Number of times generated query plan failed.
+    size_t numFailed{0};
+  };
+
+ protected:
+  struct Stats {
+    // Names of functions that were tested.
+    std::unordered_set<std::string> functionNames;
+
+    // Number of iterations using aggregations over sorted inputs.
+    size_t numSortedInputs{0};
+
+    // Number of iterations where results were verified against reference DB,
+    size_t numVerified{0};
+
+    // Number of iterations where results verification was skipped because
+    // function results are non-determinisic.
+    size_t numVerificationSkipped{0};
+
+    // Number of iterations where results verification was skipped because
+    // reference DB doesn't support the query.
+    size_t numReferenceQueryNotSupported{0};
+
+    // Number of iterations where results verification was skipped because
+    // reference DB failed to execute the query.
+    size_t numReferenceQueryFailed{0};
+
+    // Number of iterations where aggregation failed.
+    size_t numFailed{0};
+
+    void print(size_t numIterations) const;
+
+    void updateReferenceQueryStats(ReferenceQueryErrorCode errorCode);
+  };
+
+  int32_t randInt(int32_t min, int32_t max);
+
+  bool addSignature(
+      const std::string& name,
+      const FunctionSignaturePtr& signature);
+
+  void addAggregationSignatures(
+      const AggregateFunctionSignatureMap& signatureMap);
+
+  std::shared_ptr<InputGenerator> findInputGenerator(
+      const CallableSignature& signature);
+
+  PlanWithSplits deserialize(const folly::dynamic& obj);
+
+  static VectorFuzzer::Options getFuzzerOptions(
+      VectorFuzzer::Options::TimestampPrecision timestampPrecision) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = FLAGS_batch_size;
+    opts.stringVariableLength = true;
+    opts.stringLength = 4'000;
+    opts.nullRatio = FLAGS_null_ratio;
+    opts.timestampPrecision = timestampPrecision;
+    return opts;
+  }
+
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    vectorFuzzer_.reSeed(seed);
+    rng_.seed(currentSeed_);
+  }
+
+  void reSeed() {
+    seed(rng_());
+  }
+
+  // Generates at least one and up to 5 scalar columns to be used as grouping,
+  // partition or sorting keys.
+  // Column names are generated using template '<prefix>N', where N is
+  // zero-based ordinal number of the column.
+  std::vector<std::string> generateKeys(
+      const std::string& prefix,
+      std::vector<std::string>& names,
+      std::vector<TypePtr>& types);
+
+  // Similar to generateKeys, but restricts types to orderable types (i.e. no
+  // maps).
+  std::vector<std::string> generateSortingKeys(
+      const std::string& prefix,
+      std::vector<std::string>& names,
+      std::vector<TypePtr>& types);
+
+  std::pair<CallableSignature, SignatureStats&> pickSignature();
+
+  std::vector<RowVectorPtr> generateInputData(
+      std::vector<std::string> names,
+      std::vector<TypePtr> types,
+      const std::optional<CallableSignature>& signature);
+
+  // Generate a RowVector of the given types of children with an additional
+  // child named "row_number" of BIGINT row numbers that differentiates every
+  // row. Row numbers start from 0. This additional input vector is needed for
+  // result verification of window aggregations.
+  std::vector<RowVectorPtr> generateInputDataWithRowNumber(
+      std::vector<std::string> names,
+      std::vector<TypePtr> types,
+      const std::vector<std::string>& partitionKeys,
+      const CallableSignature& signature);
+
+  velox::fuzzer::ResultOrError execute(
+      const core::PlanNodePtr& plan,
+      const std::vector<exec::Split>& splits = {},
+      bool injectSpill = false,
+      bool abandonPartial = false,
+      int32_t maxDrivers = 2);
+
+  void compare(
+      const velox::fuzzer::ResultOrError& actual,
+      bool customVerification,
+      const std::vector<std::shared_ptr<ResultVerifier>>& customVerifiers,
+      const velox::fuzzer::ResultOrError& expected);
+
+  /// Returns false if the type or its children are unsupported.
+  /// Currently returns false if type is Date,IntervalDayTime or Unknown.
+  /// @param type
+  /// @return bool
+  bool isSupportedType(const TypePtr& type) const;
+
+  // @param customVerification If false, results are compared as is. Otherwise,
+  // only row counts are compared.
+  // @param customVerifiers Custom verifier for each aggregate function. These
+  // can be null. If not null and customVerification is true, custom verifier is
+  // used to further verify the results.
+  void testPlan(
+      const PlanWithSplits& planWithSplits,
+      bool injectSpill,
+      bool abandonPartial,
+      bool customVerification,
+      const std::vector<std::shared_ptr<ResultVerifier>>& customVerifiers,
+      const velox::fuzzer::ResultOrError& expected,
+      int32_t maxDrivers = 2);
+
+  void printSignatureStats();
+
+  void logVectors(const std::vector<RowVectorPtr>& vectors);
+
+  const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>
+      customVerificationFunctions_;
+  const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>
+      customInputGenerators_;
+  const std::unordered_map<std::string, std::string> queryConfigs_;
+
+  // Whether group keys must be orderable or be just comparable.
+  bool orderableGroupKeys_;
+  const bool persistAndRunOnce_;
+  const std::string reproPersistPath_;
+
+  std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner_;
+
+  std::vector<CallableSignature> signatures_;
+  std::vector<SignatureTemplate> signatureTemplates_;
+
+  FunctionsStats functionsStats;
+
+  // Stats for 'signatures_' and 'signatureTemplates_'. Stats for 'signatures_'
+  // come before stats for 'signatureTemplates_'.
+  std::vector<SignatureStats> signatureStats_;
+
+  FuzzerGenerator rng_;
+  size_t currentSeed_{0};
+
+  std::shared_ptr<memory::MemoryPool> rootPool_{
+      memory::memoryManager()->addRootPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild("leaf")};
+  std::shared_ptr<memory::MemoryPool> writerPool_{
+      rootPool_->addAggregateChild("aggregationFuzzerWriter")};
+  VectorFuzzer vectorFuzzer_;
+};
+
+// Returns true if the elapsed time is greater than or equal to
+// FLAGS_duration_sec. If FLAGS_duration_sec is 0, returns true if the
+// iterations is greater than or equal to FLAGS_steps.
+template <typename T>
+bool isDone(size_t i, T startTime) {
+  if (FLAGS_duration_sec > 0) {
+    std::chrono::duration<double> elapsed =
+        std::chrono::system_clock::now() - startTime;
+    return elapsed.count() >= FLAGS_duration_sec;
+  }
+  return i >= FLAGS_steps;
+}
+
+// Prints statistics about supported and unsupported function signatures.
+void printStats(const AggregationFuzzerBase::FunctionsStats& stats);
+
+// Prints (n / total) in percentage format.
+std::string printPercentageStat(size_t n, size_t total);
+
+// Makes an aggregation call string for the given function name and arguments.
+std::string makeFunctionCall(
+    const std::string& name,
+    const std::vector<std::string>& argNames,
+    bool sortedInputs = false,
+    bool distinctInputs = false,
+    bool ignoreNulls = false);
+
+// Returns a list of column names from c0 to cn.
+std::vector<std::string> makeNames(size_t n);
+
+// Persists plans to files under basePath.
+void persistReproInfo(
+    const std::vector<AggregationFuzzerBase::PlanWithSplits>& plans,
+    const std::string& basePath);
+
+// Returns a PrestoQueryRunner instance if prestoUrl is non-empty. Otherwise,
+// returns a DuckQueryRunner instance and set disabled aggregation functions
+// properly.
+std::unique_ptr<ReferenceQueryRunner> setupReferenceQueryRunner(
+    memory::MemoryPool* aggregatePool,
+    const std::string& prestoUrl,
+    const std::string& runnerName,
+    const uint32_t& reqTimeoutMs);
+
+// Returns the function name used in a WindowNode. The input `node` should be a
+// pointer to a WindowNode.
+std::vector<std::string> retrieveWindowFunctionName(
+    const core::PlanNodePtr& node);
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/AggregationFuzzerOptions.h b/velox/exec/fuzzer/AggregationFuzzerOptions.h
new file mode 100644
index 0000000000000..71807617817f4
--- /dev/null
+++ b/velox/exec/fuzzer/AggregationFuzzerOptions.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+
+namespace facebook::velox::exec::test {
+
+struct AggregationFuzzerOptions {
+  /// Comma-separated list of functions to test. By default, all functions
+  /// are tested.
+  std::string onlyFunctions;
+
+  /// Set of functions to not test.
+  std::unordered_set<std::string> skipFunctions;
+
+  /// Set of functions whose results are non-deterministic. These can be
+  /// order-dependent functions whose results depend on the order of input
+  /// rows, or functions that return complex-typed results containing
+  /// floating-point fields.
+  ///
+  /// For some functions, the result can be transformed to a deterministic
+  /// value. If such transformation exists, it can be specified to be used for
+  /// results verification. If no transformation is specified, results are not
+  /// verified.
+  ///
+  /// Keys are function names. Values are optional transformations. "{}"
+  /// should be used to indicate the original value, i.e. "f({})"
+  /// transformation applies function 'f' to aggregation result.
+  std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>
+      customVerificationFunctions;
+
+  std::unordered_map<std::string, std::shared_ptr<InputGenerator>>
+      customInputGenerators;
+
+  std::unordered_set<std::string> orderDependentFunctions;
+
+  /// Timestamp precision to use when generating inputs of type TIMESTAMP.
+  VectorFuzzer::Options::TimestampPrecision timestampPrecision{
+      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds};
+
+  /// A set of configuration properties to use when running query plans.
+  /// Could be used to specify timezone or enable/disable settings that
+  /// affect semantics of individual aggregate functions.
+  std::unordered_map<std::string, std::string> queryConfigs;
+
+  /// A set of hive configuration properties to use when running query plans.
+  /// Could be used to specify different timestamp units for Presto and Spark
+  /// fuzzer test.
+  std::unordered_map<std::string, std::string> hiveConfigs;
+
+  // Whether group keys must be orderable or be just comparable.
+  bool orderableGroupKeys = false;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/AggregationFuzzerRunner.h b/velox/exec/fuzzer/AggregationFuzzerRunner.h
new file mode 100644
index 0000000000000..f60b1861908cc
--- /dev/null
+++ b/velox/exec/fuzzer/AggregationFuzzerRunner.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/String.h>
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/fuzzer/AggregationFuzzer.h"
+#include "velox/exec/fuzzer/AggregationFuzzerOptions.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+/// AggregationFuzzerRunner leverages AggregationFuzzer and VectorFuzzer to
+/// automatically generate and execute aggregation tests. It works by:
+///
+///  1. Taking an initial set of available function signatures.
+///  2. Generating a random query plan based on the available function
+///     signatures.
+///  3. Generating a random set of input data (vector), with a variety of
+///     encodings and data layouts.
+///  4. Executing a variety of logically equivalent query plans and
+///     asserting results are the same.
+///  5. Rinse and repeat.
+///
+/// The common usage pattern is as following:
+///
+///  $ ./velox_aggregate_fuzzer_test --steps 10000
+///
+/// The important flags that control AggregateFuzzer's behavior are:
+///
+///  --steps: how many iterations to run.
+///  --duration_sec: alternatively, for how many seconds it should run (takes
+///          precedence over --steps).
+///  --seed: pass a deterministic seed to reproduce the behavior (each iteration
+///          will print a seed as part of the logs).
+///  --v=1: verbose logging; print a lot more details about the execution.
+///  --only: restrict the functions to fuzz.
+///  --batch_size: size of input vector batches generated.
+///
+/// e.g:
+///
+///  $ ./velox_aggregation_fuzzer_test \
+///         --steps 10000 \
+///         --seed 123 \
+///         --v=1 \
+///         --only "min,max"
+class AggregationFuzzerRunner {
+ public:
+  static int run(
+      size_t seed,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner,
+      const AggregationFuzzerOptions& options) {
+    return runFuzzer(
+        seed, std::nullopt, std::move(referenceQueryRunner), options);
+  }
+
+  static int runRepro(
+      const std::optional<std::string>& planPath,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
+    return runFuzzer(0, planPath, std::move(referenceQueryRunner), {});
+  }
+
+ protected:
+  static int runFuzzer(
+      size_t seed,
+      const std::optional<std::string>& planPath,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner,
+      const AggregationFuzzerOptions& options) {
+    auto signatures = facebook::velox::exec::getAggregateFunctionSignatures();
+    if (signatures.empty()) {
+      LOG(ERROR) << "No aggregate functions registered.";
+      exit(1);
+    }
+
+    auto filteredSignatures = velox::fuzzer::filterSignatures(
+        signatures, options.onlyFunctions, options.skipFunctions);
+    if (filteredSignatures.empty()) {
+      LOG(ERROR)
+          << "No aggregate functions left after filtering using 'only' and 'skip' lists.";
+      exit(1);
+    }
+
+    facebook::velox::parse::registerTypeResolver();
+    facebook::velox::serializer::presto::PrestoVectorSerde::
+        registerVectorSerde();
+    facebook::velox::filesystems::registerLocalFileSystem();
+
+    facebook::velox::exec::test::aggregateFuzzer(
+        filteredSignatures,
+        seed,
+        options.customVerificationFunctions,
+        options.customInputGenerators,
+        options.timestampPrecision,
+        options.queryConfigs,
+        options.hiveConfigs,
+        options.orderableGroupKeys,
+        planPath,
+        std::move(referenceQueryRunner));
+    // Calling gtest here so that it can be recognized as tests in CI systems.
+    return RUN_ALL_TESTS();
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/CMakeLists.txt b/velox/exec/fuzzer/CMakeLists.txt
new file mode 100644
index 0000000000000..a58ef6d79a20f
--- /dev/null
+++ b/velox/exec/fuzzer/CMakeLists.txt
@@ -0,0 +1,120 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_fuzzer_util DuckQueryRunner.cpp PrestoQueryRunner.cpp
+                              FuzzerUtil.cpp ToSQLUtil.cpp)
+
+target_link_libraries(
+  velox_fuzzer_util
+  velox_vector_fuzzer
+  velox_core
+  velox_exec_test_lib
+  cpr::cpr
+  Boost::regex
+  velox_type_parser
+  Folly::folly
+  velox_hive_connector
+  velox_dwio_dwrf_reader
+  velox_dwio_dwrf_writer
+  velox_dwio_catalog_fbhive)
+
+add_library(velox_aggregation_fuzzer_base AggregationFuzzerBase.cpp)
+
+target_link_libraries(
+  velox_aggregation_fuzzer_base
+  velox_exec_test_lib
+  velox_temp_path
+  velox_common_base
+  velox_file
+  velox_hive_connector
+  velox_dwio_dwrf_reader
+  velox_dwio_dwrf_writer
+  velox_type
+  velox_vector_fuzzer
+  velox_fuzzer_util
+  velox_expression_test_utility
+  velox_vector
+  velox_core)
+
+add_library(velox_aggregation_fuzzer AggregationFuzzer.cpp)
+
+target_link_libraries(
+  velox_aggregation_fuzzer
+  velox_type
+  velox_vector_fuzzer
+  velox_exec_test_lib
+  velox_expression_test_utility
+  velox_aggregation_fuzzer_base
+  velox_fuzzer_util)
+
+add_library(velox_window_fuzzer WindowFuzzer.cpp)
+
+target_link_libraries(
+  velox_window_fuzzer
+  velox_fuzzer_util
+  velox_type
+  velox_vector_fuzzer
+  velox_exec_test_lib
+  velox_expression_test_utility
+  velox_aggregation_fuzzer_base
+  velox_temp_path)
+
+add_library(velox_row_number_fuzzer RowNumberFuzzer.cpp)
+
+target_link_libraries(
+  velox_row_number_fuzzer
+  velox_fuzzer_util
+  velox_type
+  velox_vector_fuzzer
+  velox_exec_test_lib
+  velox_expression_test_utility)
+
+add_library(velox_join_fuzzer JoinFuzzer.cpp)
+
+target_link_libraries(
+  velox_join_fuzzer
+  velox_type
+  velox_vector_fuzzer
+  velox_fuzzer_util
+  velox_exec_test_lib
+  velox_expression_test_utility)
+
+add_library(velox_writer_fuzzer WriterFuzzer.cpp)
+
+target_link_libraries(
+  velox_writer_fuzzer
+  velox_fuzzer_util
+  velox_type
+  velox_vector_fuzzer
+  velox_exec_test_lib
+  velox_expression_test_utility
+  velox_temp_path
+  velox_vector_test_lib)
+
+add_library(velox_memory_arbitration_fuzzer MemoryArbitrationFuzzer.cpp)
+
+target_link_libraries(
+  velox_memory_arbitration_fuzzer
+  velox_fuzzer_util
+  velox_type
+  velox_vector_fuzzer
+  velox_exec_test_lib
+  velox_expression_test_utility
+  velox_functions_prestosql
+  velox_aggregates)
+
+add_library(velox_cache_fuzzer CacheFuzzer.cpp)
+
+target_link_libraries(
+  velox_cache_fuzzer velox_dwio_common velox_temp_path velox_vector_test_lib)
diff --git a/velox/exec/fuzzer/CacheFuzzer.cpp b/velox/exec/fuzzer/CacheFuzzer.cpp
new file mode 100644
index 0000000000000..323173b7a5f26
--- /dev/null
+++ b/velox/exec/fuzzer/CacheFuzzer.cpp
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/CacheFuzzer.h"
+
+#include <boost/random/uniform_int_distribution.hpp>
+
+#include <folly/executors/IOThreadPoolExecutor.h>
+#include <gtest/gtest.h>
+#include "velox/common/caching/FileIds.h"
+#include "velox/common/caching/SsdCache.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/common/memory/MmapAllocator.h"
+#include "velox/dwio/common/CachedBufferedInput.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int32(steps, 10, "Number of plans to generate and test.");
+
+DEFINE_int32(
+    duration_sec,
+    0,
+    "For how long it should run (in seconds). If zero, "
+    "it executes exactly --steps iterations and exits.");
+
+DEFINE_int32(num_threads, 16, "Number of read threads.");
+
+DEFINE_int32(
+    read_iteration_sec,
+    10,
+    "For how long each read thread should run (in seconds).");
+
+DEFINE_int32(num_source_files, 8, "Number of data files to be created.");
+
+DEFINE_uint64(
+    min_source_file_bytes,
+    32 << 20,
+    "Minimum source file size in bytes.");
+
+DEFINE_uint64(
+    max_source_file_bytes,
+    64 << 20,
+    "Maximum source file size in bytes.");
+
+DEFINE_int64(memory_cache_bytes, 32 << 20, "Memory cache size in bytes.");
+
+DEFINE_uint64(ssd_cache_bytes, 128 << 20, "Ssd cache size in bytes.");
+
+DEFINE_int32(num_ssd_cache_shards, 4, "Number of SSD cache shards.");
+
+DEFINE_uint64(
+    ssd_checkpoint_interval_bytes,
+    64 << 20,
+    "Checkpoint after every 'ssd_checkpoint_interval_bytes'/'num_ssd_cache_shards', "
+    "written into each file. 0 means no checkpointing.");
+
+DEFINE_bool(enable_checksum, true, "Enable checksum write to SSD.");
+
+DEFINE_bool(
+    enable_checksum_read_verification,
+    true,
+    "Enable checksum read verification from SSD.");
+
+using namespace facebook::velox::cache;
+using namespace facebook::velox::dwio::common;
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class CacheFuzzer {
+ public:
+  explicit CacheFuzzer(size_t seed);
+
+  void go();
+
+ private:
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    rng_.seed(currentSeed_);
+  }
+
+  void reSeed() {
+    seed(rng_());
+  }
+
+  void initSourceDataFiles();
+
+  void initializeCache();
+
+  void initializeInputs();
+
+  void readCache();
+
+  void reset();
+
+  void read(uint32_t fileIdx, int32_t fragmentIdx);
+
+  FuzzerGenerator rng_;
+  size_t currentSeed_{0};
+  std::shared_ptr<memory::MemoryPool> rootPool_{
+      memory::memoryManager()->addRootPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild("leaf")};
+  std::shared_ptr<filesystems::FileSystem> fs_;
+  std::vector<std::string> fileNames_;
+  std::vector<StringIdLease> fileIds_;
+  std::vector<size_t> fileSizes_;
+  // The file fragments used to perform random reads by different threads.
+  // NOTE: the production file reader reads from the specific offset from a file
+  // instead of random location for cache reuse.
+  std::vector<std::vector<std::pair<int32_t, int32_t>>> fileFragments_;
+  std::vector<std::unique_ptr<CachedBufferedInput>> inputs_;
+  std::shared_ptr<exec::test::TempDirectoryPath> sourceDataDir_;
+  std::unique_ptr<memory::MemoryManager> memoryManager_;
+  std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
+  std::shared_ptr<AsyncDataCache> cache_;
+};
+
+template <typename T>
+bool isDone(size_t i, T startTime) {
+  if (FLAGS_duration_sec > 0) {
+    const std::chrono::duration<double> elapsed =
+        std::chrono::system_clock::now() - startTime;
+    return elapsed.count() >= FLAGS_duration_sec;
+  }
+  return i >= FLAGS_steps;
+}
+
+CacheFuzzer::CacheFuzzer(size_t initialSeed) {
+  seed(initialSeed);
+  filesystems::registerLocalFileSystem();
+}
+
+void CacheFuzzer::initSourceDataFiles() {
+  sourceDataDir_ = exec::test::TempDirectoryPath::create();
+  fs_ = filesystems::getFileSystem(sourceDataDir_->getPath(), nullptr);
+
+  // Create files with random sizes.
+  if (fileIds_.empty()) {
+    for (auto i = 0; i < FLAGS_num_source_files; ++i) {
+      const auto fileName =
+          fmt::format("{}/file_{}", sourceDataDir_->getPath(), i);
+      const size_t fileSize = boost::random::uniform_int_distribution<int64_t>(
+          FLAGS_min_source_file_bytes, FLAGS_max_source_file_bytes)(rng_);
+      auto writeFile = fs_->openFileForWrite(fileName);
+      size_t writtenSize = 0;
+      int32_t offset = 0;
+      while (writtenSize < fileSize) {
+        const size_t chunkSize = std::min(
+            fileSize - writtenSize,
+            size_t(4 << 20)); // Write in chunks of 4MB
+        auto buffer = folly::IOBuf::create(chunkSize);
+        buffer->append(chunkSize);
+        // Fill buffer with data.
+        std::generate_n(
+            buffer->writableData(), chunkSize, [&offset]() -> uint8_t {
+              return static_cast<uint8_t>(offset++ % 256);
+            });
+        writeFile->append(std::move(buffer));
+        writtenSize += chunkSize;
+      }
+      writeFile->close();
+
+      fileNames_.emplace_back(fileName);
+      fileIds_.emplace_back(fileIds(), fileName);
+      fileSizes_.emplace_back(fileSize);
+    }
+  }
+}
+
+void CacheFuzzer::initializeCache() {
+  // We have up to 20 threads and 16 threads are used for reading so
+  // there are some threads left over for SSD background write.
+  executor_ = std::make_unique<folly::IOThreadPoolExecutor>(20);
+
+  std::unique_ptr<SsdCache> ssdCache;
+  if (FLAGS_ssd_cache_bytes > 0) {
+    SsdCache::Config config(
+        fmt::format("{}/cache", sourceDataDir_->getPath()),
+        FLAGS_ssd_cache_bytes,
+        FLAGS_num_ssd_cache_shards,
+        executor_.get(),
+        FLAGS_ssd_checkpoint_interval_bytes,
+        false,
+        FLAGS_enable_checksum,
+        FLAGS_enable_checksum_read_verification);
+    ssdCache = std::make_unique<SsdCache>(config);
+  }
+
+  memory::MemoryManagerOptions options;
+  options.useMmapAllocator = true;
+  options.allocatorCapacity = FLAGS_memory_cache_bytes;
+  options.arbitratorCapacity = FLAGS_memory_cache_bytes;
+  options.arbitratorReservedCapacity = 0;
+  options.trackDefaultUsage = true;
+  memoryManager_ = std::make_unique<memory::MemoryManager>(options);
+
+  // TODO: Test different ssd write behaviors with AsyncDataCache::Options.
+  cache_ = AsyncDataCache::create(
+      dynamic_cast<memory::MmapAllocator*>(memoryManager_->allocator()),
+      std::move(ssdCache),
+      {});
+}
+
+void CacheFuzzer::initializeInputs() {
+  const auto readOptions = io::ReaderOptions(pool_.get());
+  auto tracker = std::make_shared<ScanTracker>(
+      "testTracker", nullptr, 256 << 10 /*256KB*/);
+  auto ioStats = std::make_shared<IoStatistics>();
+  inputs_.reserve(FLAGS_num_source_files);
+  for (auto i = 0; i < FLAGS_num_source_files; ++i) {
+    // Initialize buffered input.
+    auto readFile = fs_->openFileForRead(fileNames_[i]);
+    auto const withExecutor = !folly::Random::oneIn(3, rng_);
+    inputs_.emplace_back(std::make_unique<CachedBufferedInput>(
+        std::move(readFile),
+        MetricsLog::voidLog(),
+        fileIds_[i].id(), // NOLINT
+        cache_.get(),
+        tracker,
+        fileIds_[i].id(), // NOLINT
+        ioStats,
+        withExecutor ? executor_.get() : nullptr,
+        readOptions));
+
+    // Divide file into fragments.
+    std::vector<std::pair<int32_t, int32_t>> fragments;
+    int32_t offset = 0;
+    while (offset < fileSizes_[i]) {
+      const auto length = boost::random::uniform_int_distribution<int32_t>(
+          1, fileSizes_[i] - offset)(rng_);
+      fragments.emplace_back(offset, length);
+      offset += length;
+    }
+    fileFragments_.emplace_back(std::move(fragments));
+  }
+}
+
+void CacheFuzzer::readCache() {
+  std::atomic_bool readStopped{false};
+  std::vector<std::thread> threads;
+  threads.reserve(FLAGS_num_threads);
+  for (int32_t i = 0; i < FLAGS_num_threads; ++i) {
+    threads.emplace_back([&, i]() {
+      FuzzerGenerator rng(currentSeed_ + i);
+      while (!readStopped) {
+        const auto fileIdx = boost::random::uniform_int_distribution<int32_t>(
+            0, FLAGS_num_source_files - 1)(rng);
+        const auto fragmentIdx =
+            boost::random::uniform_int_distribution<int32_t>(
+                0, fileFragments_[fileIdx].size() - 1)(rng);
+        read(fileIdx, fragmentIdx);
+      }
+    });
+  }
+  std::this_thread::sleep_for(std::chrono::seconds(FLAGS_read_iteration_sec));
+  readStopped = true;
+  for (auto& thread : threads) {
+    thread.join();
+  }
+}
+
+void CacheFuzzer::reset() {
+  cache_->shutdown();
+  cache_->ssdCache()->waitForWriteToFinish();
+  executor_->join();
+  executor_.reset();
+  fileNames_.clear();
+  fileIds_.clear();
+  fileSizes_.clear();
+  fileFragments_.clear();
+  inputs_.clear();
+  fs_.reset();
+  cache_.reset();
+  memoryManager_.reset();
+  sourceDataDir_.reset();
+  fileIds().testingReset();
+}
+
+void CacheFuzzer::read(uint32_t fileIdx, int32_t fragmentIdx) {
+  // TODO: Faulty injection.
+  const auto [offset, length] = fileFragments_[fileIdx][fragmentIdx];
+  auto stream = inputs_[fileIdx]->read(offset, length, LogType::TEST);
+  const void* buffer;
+  int32_t size;
+  int32_t numRead = 0;
+  while (numRead < length) {
+    try {
+      if (stream->Next(&buffer, &size)) {
+        if (folly::Random::oneIn(4)) {
+          // Verify read content.
+          const auto* data = reinterpret_cast<const uint8_t*>(buffer);
+          for (int32_t sequence = 0; sequence < size; ++sequence) {
+            ASSERT_EQ(data[sequence], (offset + numRead + sequence) % 256);
+          }
+        }
+        numRead += size;
+      } else {
+        break;
+      }
+    } catch (const VeloxException& e) {
+      if (e.errorCode() == error_code::kNoCacheSpace.c_str()) {
+        LOG(WARNING) << e.what();
+      } else {
+        std::rethrow_exception(std::current_exception());
+      }
+    }
+  }
+  ASSERT_EQ(numRead, length);
+}
+
+void CacheFuzzer::go() {
+  VELOX_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+
+  auto startTime = std::chrono::system_clock::now();
+  size_t iteration = 0;
+
+  while (!isDone(iteration, startTime)) {
+    LOG(INFO) << "==============================> Started iteration "
+              << iteration << " (seed: " << currentSeed_ << ")";
+
+    initSourceDataFiles();
+
+    initializeCache();
+
+    initializeInputs();
+
+    readCache();
+
+    // TODO: Test cache restart.
+
+    LOG(INFO) << cache_->refreshStats().toString();
+
+    reset();
+
+    LOG(INFO) << "==============================> Done with iteration "
+              << iteration;
+
+    reSeed();
+    ++iteration;
+  }
+}
+
+} // namespace
+
+void cacheFuzzer(size_t seed) {
+  auto cacheFuzzer = CacheFuzzer(seed);
+  cacheFuzzer.go();
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/CacheFuzzer.h b/velox/exec/fuzzer/CacheFuzzer.h
new file mode 100644
index 0000000000000..985735ccdbf35
--- /dev/null
+++ b/velox/exec/fuzzer/CacheFuzzer.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstddef>
+
+namespace facebook::velox::exec::test {
+/// Runs the async data cache fuzzer.
+/// @param seed Random seed - Pass the same seed for reproducibility.
+void cacheFuzzer(size_t seed);
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/CacheFuzzerRunner.h b/velox/exec/fuzzer/CacheFuzzerRunner.h
new file mode 100644
index 0000000000000..cde1e4f368e93
--- /dev/null
+++ b/velox/exec/fuzzer/CacheFuzzerRunner.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/String.h>
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/fuzzer/CacheFuzzer.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+class CacheRunner {
+ public:
+  static int run(size_t seed) {
+    filesystems::registerLocalFileSystem();
+    cacheFuzzer(seed);
+    return RUN_ALL_TESTS();
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/DuckQueryRunner.cpp b/velox/exec/fuzzer/DuckQueryRunner.cpp
new file mode 100644
index 0000000000000..1491333c4948d
--- /dev/null
+++ b/velox/exec/fuzzer/DuckQueryRunner.cpp
@@ -0,0 +1,439 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/fuzzer/DuckQueryRunner.h"
+#include "velox/exec/fuzzer/ToSQLUtil.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+
+namespace facebook::velox::exec::test {
+
+namespace {
+
+bool isSupported(const TypePtr& type) {
+  // DuckDB doesn't support nanosecond precision for timestamps.
+  if (type->kind() == TypeKind::TIMESTAMP) {
+    return false;
+  }
+  for (auto i = 0; i < type->size(); ++i) {
+    if (!isSupported(type->childAt(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+std::unordered_set<std::string> getAggregateFunctions() {
+  std::string sql =
+      "SELECT distinct on(function_name) function_name "
+      "FROM duckdb_functions() "
+      "WHERE function_type = 'aggregate'";
+
+  DuckDbQueryRunner queryRunner;
+  auto result = queryRunner.executeOrdered(sql, ROW({VARCHAR()}));
+
+  std::unordered_set<std::string> names;
+  for (const auto& row : result) {
+    names.insert(row[0].value<std::string>());
+  }
+
+  return names;
+}
+} // namespace
+
+DuckQueryRunner::DuckQueryRunner(memory::MemoryPool* aggregatePool)
+    : ReferenceQueryRunner(aggregatePool),
+      aggregateFunctionNames_{getAggregateFunctions()} {}
+
+void DuckQueryRunner::disableAggregateFunctions(
+    const std::vector<std::string>& names) {
+  for (const auto& name : names) {
+    aggregateFunctionNames_.erase(name);
+  }
+}
+
+const std::vector<TypePtr>& DuckQueryRunner::supportedScalarTypes() const {
+  static const std::vector<TypePtr> kScalarTypes{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      REAL(),
+      DOUBLE(),
+      VARCHAR(),
+      DATE(),
+  };
+  return kScalarTypes;
+}
+
+std::multiset<std::vector<velox::variant>> DuckQueryRunner::execute(
+    const std::string& sql,
+    const std::vector<RowVectorPtr>& input,
+    const RowTypePtr& resultType) {
+  DuckDbQueryRunner queryRunner;
+  queryRunner.createTable("tmp", input);
+  return queryRunner.execute(sql, resultType);
+}
+
+std::multiset<std::vector<velox::variant>> DuckQueryRunner::execute(
+    const std::string& sql,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    const RowTypePtr& resultType) {
+  DuckDbQueryRunner queryRunner;
+  queryRunner.createTable("t", probeInput);
+  queryRunner.createTable("u", buildInput);
+  return queryRunner.execute(sql, resultType);
+}
+
+std::optional<std::string> DuckQueryRunner::toSql(
+    const core::PlanNodePtr& plan) {
+  if (!isSupported(plan->outputType())) {
+    return std::nullopt;
+  }
+
+  for (const auto& source : plan->sources()) {
+    if (!isSupported(source->outputType())) {
+      return std::nullopt;
+    }
+  }
+
+  if (const auto projectNode =
+          std::dynamic_pointer_cast<const core::ProjectNode>(plan)) {
+    return toSql(projectNode);
+  }
+
+  if (const auto windowNode =
+          std::dynamic_pointer_cast<const core::WindowNode>(plan)) {
+    return toSql(windowNode);
+  }
+
+  if (const auto aggregationNode =
+          std::dynamic_pointer_cast<const core::AggregationNode>(plan)) {
+    return toSql(aggregationNode);
+  }
+
+  if (const auto rowNumberNode =
+          std::dynamic_pointer_cast<const core::RowNumberNode>(plan)) {
+    return toSql(rowNumberNode);
+  }
+
+  if (const auto joinNode =
+          std::dynamic_pointer_cast<const core::HashJoinNode>(plan)) {
+    return toSql(joinNode);
+  }
+
+  if (const auto joinNode =
+          std::dynamic_pointer_cast<const core::NestedLoopJoinNode>(plan)) {
+    return toSql(joinNode);
+  }
+
+  VELOX_NYI();
+}
+
+namespace {
+bool containsMap(const TypePtr& type) {
+  if (type->isMap()) {
+    return true;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (containsMap(type->childAt(i))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+} // namespace
+
+std::optional<std::string> DuckQueryRunner::toSql(
+    const std::shared_ptr<const core::AggregationNode>& aggregationNode) {
+  // Assume plan is Aggregation over Values.
+  VELOX_CHECK(aggregationNode->step() == core::AggregationNode::Step::kSingle);
+
+  for (const auto& agg : aggregationNode->aggregates()) {
+    if (aggregateFunctionNames_.count(agg.call->name()) == 0) {
+      return std::nullopt;
+    }
+  }
+
+  std::vector<std::string> groupingKeys;
+  for (const auto& key : aggregationNode->groupingKeys()) {
+    // Aggregations with group by keys that contain maps are buggy.
+    if (containsMap(key->type())) {
+      return std::nullopt;
+    }
+    groupingKeys.push_back(key->name());
+  }
+
+  std::stringstream sql;
+  sql << "SELECT " << folly::join(", ", groupingKeys);
+
+  const auto& aggregates = aggregationNode->aggregates();
+  if (!aggregates.empty()) {
+    if (!groupingKeys.empty()) {
+      sql << ", ";
+    }
+
+    for (auto i = 0; i < aggregates.size(); ++i) {
+      appendComma(i, sql);
+      const auto& aggregate = aggregates[i];
+      sql << toAggregateCallSql(
+          aggregate.call,
+          aggregate.sortingKeys,
+          aggregate.sortingOrders,
+          aggregate.distinct);
+
+      if (aggregate.mask != nullptr) {
+        sql << " filter (where " << aggregate.mask->name() << ")";
+      }
+      sql << " as " << aggregationNode->aggregateNames()[i];
+    }
+  }
+
+  sql << " FROM tmp";
+
+  if (!groupingKeys.empty()) {
+    sql << " GROUP BY " << folly::join(", ", groupingKeys);
+  }
+
+  return sql.str();
+}
+
+std::optional<std::string> DuckQueryRunner::toSql(
+    const std::shared_ptr<const core::ProjectNode>& projectNode) {
+  auto sourceSql = toSql(projectNode->sources()[0]);
+  if (!sourceSql.has_value()) {
+    return std::nullopt;
+  }
+
+  std::stringstream sql;
+  sql << "SELECT ";
+
+  for (auto i = 0; i < projectNode->names().size(); ++i) {
+    appendComma(i, sql);
+    auto projection = projectNode->projections()[i];
+    if (auto field =
+            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+                projection)) {
+      sql << field->name();
+    } else if (
+        auto call =
+            std::dynamic_pointer_cast<const core::CallTypedExpr>(projection)) {
+      sql << toCallSql(call);
+    } else {
+      VELOX_NYI();
+    }
+
+    sql << " as " << projectNode->names()[i];
+  }
+
+  sql << " FROM (" << sourceSql.value() << ")";
+  return sql.str();
+}
+
+std::optional<std::string> DuckQueryRunner::toSql(
+    const std::shared_ptr<const core::WindowNode>& windowNode) {
+  std::stringstream sql;
+  sql << "SELECT ";
+
+  const auto& inputType = windowNode->sources()[0]->outputType();
+  for (auto i = 0; i < inputType->size(); ++i) {
+    appendComma(i, sql);
+    sql << inputType->nameOf(i);
+  }
+
+  sql << ", ";
+
+  const auto& functions = windowNode->windowFunctions();
+  for (auto i = 0; i < functions.size(); ++i) {
+    appendComma(i, sql);
+    sql << toCallSql(functions[i].functionCall);
+  }
+  sql << " OVER (";
+
+  const auto& partitionKeys = windowNode->partitionKeys();
+  if (!partitionKeys.empty()) {
+    sql << "partition by ";
+    for (auto i = 0; i < partitionKeys.size(); ++i) {
+      appendComma(i, sql);
+      sql << partitionKeys[i]->name();
+    }
+  }
+
+  const auto& sortingKeys = windowNode->sortingKeys();
+  const auto& sortingOrders = windowNode->sortingOrders();
+
+  if (!sortingKeys.empty()) {
+    sql << " order by ";
+    for (auto i = 0; i < sortingKeys.size(); ++i) {
+      appendComma(i, sql);
+      sql << sortingKeys[i]->name() << " " << sortingOrders[i].toString();
+    }
+  }
+
+  sql << ") FROM tmp";
+
+  return sql.str();
+}
+
+std::optional<std::string> DuckQueryRunner::toSql(
+    const std::shared_ptr<const core::RowNumberNode>& rowNumberNode) {
+  std::stringstream sql;
+  sql << "SELECT ";
+
+  const auto& inputType = rowNumberNode->sources()[0]->outputType();
+  for (auto i = 0; i < inputType->size(); ++i) {
+    appendComma(i, sql);
+    sql << inputType->nameOf(i);
+  }
+
+  sql << ", row_number() OVER (";
+
+  const auto& partitionKeys = rowNumberNode->partitionKeys();
+  if (!partitionKeys.empty()) {
+    sql << "partition by ";
+    for (auto i = 0; i < partitionKeys.size(); ++i) {
+      appendComma(i, sql);
+      sql << partitionKeys[i]->name();
+    }
+  }
+
+  sql << ") as row_number FROM tmp";
+
+  return sql.str();
+}
+
+std::optional<std::string> DuckQueryRunner::toSql(
+    const std::shared_ptr<const core::HashJoinNode>& joinNode) {
+  const auto& joinKeysToSql = [](auto keys) {
+    std::stringstream out;
+    for (auto i = 0; i < keys.size(); ++i) {
+      if (i > 0) {
+        out << ", ";
+      }
+      out << keys[i]->name();
+    }
+    return out.str();
+  };
+
+  const auto& equiClausesToSql = [](auto joinNode) {
+    std::stringstream out;
+    for (auto i = 0; i < joinNode->leftKeys().size(); ++i) {
+      if (i > 0) {
+        out << " AND ";
+      }
+      out << joinNode->leftKeys()[i]->name() << " = "
+          << joinNode->rightKeys()[i]->name();
+    }
+    return out.str();
+  };
+
+  const auto& outputNames = joinNode->outputType()->names();
+
+  std::stringstream sql;
+  if (joinNode->isLeftSemiProjectJoin()) {
+    sql << "SELECT "
+        << folly::join(", ", outputNames.begin(), --outputNames.end());
+  } else {
+    sql << "SELECT " << folly::join(", ", outputNames);
+  }
+
+  switch (joinNode->joinType()) {
+    case core::JoinType::kInner:
+      sql << " FROM t INNER JOIN u ON " << equiClausesToSql(joinNode);
+      break;
+    case core::JoinType::kLeft:
+      sql << " FROM t LEFT JOIN u ON " << equiClausesToSql(joinNode);
+      break;
+    case core::JoinType::kFull:
+      sql << " FROM t FULL OUTER JOIN u ON " << equiClausesToSql(joinNode);
+      break;
+    case core::JoinType::kLeftSemiFilter:
+      if (joinNode->leftKeys().size() > 1) {
+        return std::nullopt;
+      }
+      sql << " FROM t WHERE " << joinKeysToSql(joinNode->leftKeys())
+          << " IN (SELECT " << joinKeysToSql(joinNode->rightKeys())
+          << " FROM u)";
+      break;
+    case core::JoinType::kLeftSemiProject:
+      if (joinNode->isNullAware()) {
+        sql << ", " << joinKeysToSql(joinNode->leftKeys()) << " IN (SELECT "
+            << joinKeysToSql(joinNode->rightKeys()) << " FROM u) FROM t";
+      } else {
+        sql << ", EXISTS (SELECT * FROM u WHERE " << equiClausesToSql(joinNode)
+            << ") FROM t";
+      }
+      break;
+    case core::JoinType::kAnti:
+      if (joinNode->isNullAware()) {
+        sql << " FROM t WHERE " << joinKeysToSql(joinNode->leftKeys())
+            << " NOT IN (SELECT " << joinKeysToSql(joinNode->rightKeys())
+            << " FROM u)";
+      } else {
+        sql << " FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE "
+            << equiClausesToSql(joinNode) << ")";
+      }
+      break;
+    default:
+      VELOX_UNREACHABLE(
+          "Unknown join type: {}", static_cast<int>(joinNode->joinType()));
+  }
+
+  return sql.str();
+}
+
+std::optional<std::string> DuckQueryRunner::toSql(
+    const std::shared_ptr<const core::NestedLoopJoinNode>& joinNode) {
+  const auto& joinKeysToSql = [](auto keys) {
+    std::stringstream out;
+    for (auto i = 0; i < keys.size(); ++i) {
+      if (i > 0) {
+        out << ", ";
+      }
+      out << keys[i]->name();
+    }
+    return out.str();
+  };
+
+  const auto& outputNames = joinNode->outputType()->names();
+  std::stringstream sql;
+
+  // Nested loop join without filter.
+  VELOX_CHECK(
+      joinNode->joinCondition() == nullptr,
+      "This code path should be called only for nested loop join without filter");
+  const std::string joinCondition{"(1 = 1)"};
+  switch (joinNode->joinType()) {
+    case core::JoinType::kInner:
+      sql << " FROM t INNER JOIN u ON " << joinCondition;
+      break;
+    case core::JoinType::kLeft:
+      sql << " FROM t LEFT JOIN u ON " << joinCondition;
+      break;
+    case core::JoinType::kFull:
+      sql << " FROM t FULL OUTER JOIN u ON " << joinCondition;
+      break;
+    default:
+      VELOX_UNREACHABLE(
+          "Unknown join type: {}", static_cast<int>(joinNode->joinType()));
+  }
+
+  return sql.str();
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/DuckQueryRunner.h b/velox/exec/fuzzer/DuckQueryRunner.h
new file mode 100644
index 0000000000000..491cc14aa368f
--- /dev/null
+++ b/velox/exec/fuzzer/DuckQueryRunner.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+
+namespace facebook::velox::exec::test {
+
+class DuckQueryRunner : public ReferenceQueryRunner {
+ public:
+  explicit DuckQueryRunner(memory::MemoryPool* aggregatePool);
+
+  RunnerType runnerType() const override {
+    return RunnerType::kDuckQueryRunner;
+  }
+
+  /// Skip Timestamp, Varbinary, Unknown, and IntervalDayTime types. DuckDB
+  /// doesn't support nanosecond precision for timestamps or casting from Bigint
+  /// to Interval.
+  ///
+  /// TODO Investigate mismatches reported when comparing Varbinary.
+  const std::vector<TypePtr>& supportedScalarTypes() const override;
+
+  /// Specify names of aggregate function to exclude from the list of supported
+  /// functions. Used to exclude functions that are non-determonistic, have bugs
+  /// or whose semantics differ from Velox.
+  void disableAggregateFunctions(const std::vector<std::string>& names);
+
+  /// Supports AggregationNode and WindowNode with optional ProjectNode on top.
+  /// Assumes that source of AggregationNode or Window Node is 'tmp' table.
+  std::optional<std::string> toSql(const core::PlanNodePtr& plan) override;
+
+  /// Creates 'tmp' table with 'input' data and runs 'sql' query. Returns
+  /// results according to 'resultType' schema.
+  std::multiset<std::vector<velox::variant>> execute(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& input,
+      const RowTypePtr& resultType) override;
+
+  std::multiset<std::vector<velox::variant>> execute(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const RowTypePtr& resultType) override;
+
+ private:
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::AggregationNode>& aggregationNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::WindowNode>& windowNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::ProjectNode>& projectNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::RowNumberNode>& rowNumberNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::HashJoinNode>& joinNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::NestedLoopJoinNode>& joinNode);
+
+  std::unordered_set<std::string> aggregateFunctionNames_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/FuzzerUtil.cpp b/velox/exec/fuzzer/FuzzerUtil.cpp
new file mode 100644
index 0000000000000..c136884559187
--- /dev/null
+++ b/velox/exec/fuzzer/FuzzerUtil.cpp
@@ -0,0 +1,293 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include <re2/re2.h>
+#include <filesystem>
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/catalog/fbhive/FileUtils.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+
+using namespace facebook::velox::dwio::catalog::fbhive;
+
+namespace facebook::velox::exec::test {
+
+const std::string kPartitionDelimiter{"="};
+
+// Extracts partition column name and partition value from directoryName.
+std::pair<std::string, std::string> extractPartition(
+    const std::string& directoryName) {
+  auto partitionColumn =
+      directoryName.substr(0, directoryName.find(kPartitionDelimiter));
+  auto partitionValue = FileUtils::unescapePathName(
+      directoryName.substr(directoryName.find(kPartitionDelimiter) + 1));
+  return std::pair(partitionColumn, partitionValue);
+}
+
+std::optional<int32_t> getBucketNum(const std::string& fileName) {
+  if (RE2::FullMatch(fileName, "0[0-9]+_0_TaskCursorQuery_[0-9]+")) {
+    return std::optional(stoi(fileName.substr(0, fileName.find("+"))));
+  }
+  return std::nullopt;
+}
+
+void writeToFile(
+    const std::string& path,
+    const VectorPtr& vector,
+    memory::MemoryPool* pool) {
+  dwrf::WriterOptions options;
+  options.schema = vector->type();
+  options.memoryPool = pool;
+  auto writeFile = std::make_unique<LocalWriteFile>(path, true, false);
+  auto sink =
+      std::make_unique<dwio::common::WriteFileSink>(std::move(writeFile), path);
+  dwrf::Writer writer(std::move(sink), options);
+  writer.write(vector);
+  writer.close();
+}
+
+// Recursive function to create splits with their corresponding schemas and
+// store in splits.
+// In a table directory, each partition would be stored as a
+// sub-directory, multiple partition columns would make up nested directory
+// structure.
+//
+// For example for a file path such as /p0=0/p1=0/0000_file1, creates
+// split with partition keys (p0, 0), (p1 0)
+void makeSplitsWithSchema(
+    const std::string& directory,
+    std::unordered_map<std::string, std::optional<std::string>>& partitionKeys,
+    std::vector<Split>& splits) {
+  for (auto const& entry : std::filesystem::directory_iterator{directory}) {
+    if (entry.is_directory()) {
+      auto directoryName = entry.path().string();
+      auto partition =
+          extractPartition(directoryName.substr(directory.size() + 1));
+      partitionKeys.insert(
+          {partition.first,
+           partition.second == FileUtils::kDefaultPartitionValue
+               ? std::nullopt
+               : std::optional(partition.second)});
+      makeSplitsWithSchema(directoryName, partitionKeys, splits);
+      partitionKeys.erase(partition.first);
+    } else {
+      const auto bucketNum =
+          getBucketNum(entry.path().string().substr(directory.size() + 1));
+      splits.emplace_back(
+          makeSplit(entry.path().string(), partitionKeys, bucketNum));
+    }
+  }
+}
+
+std::vector<Split> makeSplits(
+    const std::vector<RowVectorPtr>& inputs,
+    const std::string& path,
+    const std::shared_ptr<memory::MemoryPool>& writerPool) {
+  std::vector<Split> splits;
+  for (auto i = 0; i < inputs.size(); ++i) {
+    const std::string filePath = fmt::format("{}/{}", path, i);
+    writeToFile(filePath, inputs[i], writerPool.get());
+    splits.push_back(makeSplit(filePath));
+  }
+
+  return splits;
+}
+
+std::vector<Split> makeSplits(const std::string& directory) {
+  std::vector<Split> splits;
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+  makeSplitsWithSchema(directory, partitionKeys, splits);
+  return splits;
+}
+
+Split makeSplit(
+    const std::string& filePath,
+    const std::unordered_map<std::string, std::optional<std::string>>&
+        partitionKeys,
+    std::optional<int32_t> tableBucketNumber) {
+  return Split{std::make_shared<connector::hive::HiveConnectorSplit>(
+      kHiveConnectorId,
+      filePath,
+      dwio::common::FileFormat::DWRF,
+      0,
+      std::numeric_limits<uint64_t>::max(),
+      partitionKeys,
+      tableBucketNumber)};
+}
+
+std::shared_ptr<connector::ConnectorSplit> makeConnectorSplit(
+    const std::string& filePath) {
+  return std::make_shared<connector::hive::HiveConnectorSplit>(
+      kHiveConnectorId, filePath, dwio::common::FileFormat::DWRF);
+}
+
+std::vector<std::string> makeNames(const std::string& prefix, size_t n) {
+  std::vector<std::string> names;
+  names.reserve(n);
+  for (auto i = 0; i < n; ++i) {
+    names.push_back(fmt::format("{}{}", prefix, i));
+  }
+  return names;
+}
+
+RowVectorPtr makeNullRows(
+    const std::vector<velox::RowVectorPtr>& input,
+    const std::string& colName,
+    memory::MemoryPool* pool) {
+  vector_size_t numInput = 0;
+  for (const auto& v : input) {
+    numInput += v->size();
+  }
+
+  auto column = BaseVector::createNullConstant(BIGINT(), numInput, pool);
+  return std::make_shared<RowVector>(
+      pool,
+      ROW({colName}, {BIGINT()}),
+      nullptr,
+      numInput,
+      std::vector<VectorPtr>{column});
+}
+
+RowTypePtr concat(const RowTypePtr& a, const RowTypePtr& b) {
+  std::vector<std::string> names = a->names();
+  std::vector<TypePtr> types = a->children();
+
+  for (auto i = 0; i < b->size(); ++i) {
+    names.push_back(b->nameOf(i));
+    types.push_back(b->childAt(i));
+  }
+
+  return ROW(std::move(names), std::move(types));
+}
+
+// Sometimes we generate zero-column input of type ROW({}) or a column of type
+// UNKNOWN(). Such data cannot be written to a file and therefore cannot
+// be tested with TableScan.
+bool isTableScanSupported(const TypePtr& type) {
+  if (type->kind() == TypeKind::ROW && type->size() == 0) {
+    return false;
+  }
+  if (type->kind() == TypeKind::UNKNOWN) {
+    return false;
+  }
+  if (type->kind() == TypeKind::HUGEINT) {
+    return false;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (!isTableScanSupported(type->childAt(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool containsType(const TypePtr& type, const TypePtr& search) {
+  if (type->equivalent(*search)) {
+    return true;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (containsType(type->childAt(i), search)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool containsTypeKind(const TypePtr& type, const TypeKind& search) {
+  if (type->kind() == search) {
+    return true;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (containsTypeKind(type->childAt(i), search)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool containsUnsupportedTypes(const TypePtr& type) {
+  return containsTypeKind(type, TypeKind::TIMESTAMP) ||
+      containsTypeKind(type, TypeKind::VARBINARY) ||
+      containsType(type, INTERVAL_DAY_TIME());
+}
+
+void setupMemory(int64_t allocatorCapacity, int64_t arbitratorCapacity) {
+  FLAGS_velox_enable_memory_usage_track_in_default_memory_pool = true;
+  FLAGS_velox_memory_leak_check_enabled = true;
+  facebook::velox::memory::SharedArbitrator::registerFactory();
+  facebook::velox::memory::MemoryManagerOptions options;
+  options.allocatorCapacity = allocatorCapacity;
+  options.arbitratorCapacity = arbitratorCapacity;
+  options.arbitratorKind = "SHARED";
+  options.checkUsageLeak = true;
+  options.arbitrationStateCheckCb = memoryArbitrationStateCheck;
+  facebook::velox::memory::MemoryManager::initialize(options);
+}
+
+std::pair<std::optional<MaterializedRowMultiset>, ReferenceQueryErrorCode>
+computeReferenceResults(
+    const core::PlanNodePtr& plan,
+    const std::vector<RowVectorPtr>& input,
+    ReferenceQueryRunner* referenceQueryRunner) {
+  if (auto sql = referenceQueryRunner->toSql(plan)) {
+    try {
+      return std::make_pair(
+          referenceQueryRunner->execute(sql.value(), input, plan->outputType()),
+          ReferenceQueryErrorCode::kSuccess);
+    } catch (...) {
+      LOG(WARNING) << "Query failed in the reference DB";
+      return std::make_pair(
+          std::nullopt, ReferenceQueryErrorCode::kReferenceQueryFail);
+    }
+  }
+
+  LOG(INFO) << "Query not supported by the reference DB";
+  return std::make_pair(
+      std::nullopt, ReferenceQueryErrorCode::kReferenceQueryUnsupported);
+}
+
+std::pair<std::optional<std::vector<RowVectorPtr>>, ReferenceQueryErrorCode>
+computeReferenceResultsAsVector(
+    const core::PlanNodePtr& plan,
+    const std::vector<RowVectorPtr>& input,
+    ReferenceQueryRunner* referenceQueryRunner) {
+  VELOX_CHECK(referenceQueryRunner->supportsVeloxVectorResults());
+
+  if (auto sql = referenceQueryRunner->toSql(plan)) {
+    try {
+      return std::make_pair(
+          referenceQueryRunner->executeVector(
+              sql.value(), input, plan->outputType()),
+          ReferenceQueryErrorCode::kSuccess);
+    } catch (...) {
+      LOG(WARNING) << "Query failed in the reference DB";
+      return std::make_pair(
+          std::nullopt, ReferenceQueryErrorCode::kReferenceQueryFail);
+    }
+  } else {
+    LOG(INFO) << "Query not supported by the reference DB";
+  }
+
+  return std::make_pair(
+      std::nullopt, ReferenceQueryErrorCode::kReferenceQueryUnsupported);
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/FuzzerUtil.h b/velox/exec/fuzzer/FuzzerUtil.h
new file mode 100644
index 0000000000000..fc06df1577219
--- /dev/null
+++ b/velox/exec/fuzzer/FuzzerUtil.h
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/Split.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+
+namespace facebook::velox::exec::test {
+const std::string kHiveConnectorId = "test-hive";
+
+struct SortingKeyAndOrder {
+  const std::string key_;
+  const core::SortOrder sortOrder_;
+
+  SortingKeyAndOrder(std::string key, core::SortOrder sortOrder)
+      : key_(std::move(key)), sortOrder_(std::move(sortOrder)) {}
+};
+
+/// Write the vector to the path.
+void writeToFile(
+    const std::string& path,
+    const VectorPtr& vector,
+    memory::MemoryPool* pool);
+
+/// Write vectors into the path, one file per vector, and create spilts from
+/// those files.
+std::vector<Split> makeSplits(
+    const std::vector<RowVectorPtr>& inputs,
+    const std::string& path,
+    const std::shared_ptr<memory::MemoryPool>& writerPool);
+
+/// Create splits with schema information from a directory.
+/// For example under directory /table1:
+/// /table1/p0=0/p1=0/00000_file1
+/// /table1/p0=0/p1=1/00000_file1
+/// It would return splits:
+/// split1 with partition keys (p0, 0), (p1, 0)
+/// split2 with partition keys (p0, 0), (p1, 1)
+std::vector<Split> makeSplits(const std::string& directory);
+
+/// Create a split from an exsiting file.
+Split makeSplit(
+    const std::string& filePath,
+    const std::unordered_map<std::string, std::optional<std::string>>&
+        partitionKeys = {},
+    std::optional<int32_t> tableBucketNumber = std::nullopt);
+
+/// Create a connector split from an exsiting file.
+std::shared_ptr<connector::ConnectorSplit> makeConnectorSplit(
+    const std::string& filePath);
+
+/// Create column names with the pattern '${prefix}${i}'.
+std::vector<std::string> makeNames(const std::string& prefix, size_t n);
+
+/// Create a batch consists of single all-null BIGINT column with as many rows
+/// as original input. Used when the query doesn't need to read any columns, but
+/// it needs to see a specific number of rows. This way we will be able to
+/// create a temporary test table with the necessary number of rows.
+RowVectorPtr makeNullRows(
+    const std::vector<velox::RowVectorPtr>& input,
+    const std::string& colName,
+    memory::MemoryPool* pool);
+
+/// Returns whether type is supported in TableScan. Empty Row type and Unknown
+/// type are not supported.
+bool isTableScanSupported(const TypePtr& type);
+
+/// Concat tow RowTypes.
+RowTypePtr concat(const RowTypePtr& a, const RowTypePtr& b);
+
+/// Skip queries that use Timestamp, Varbinary, and IntervalDayTime types.
+/// DuckDB doesn't support nanosecond precision for timestamps or casting from
+/// Bigint to Interval.
+///
+/// TODO Investigate mismatches reported when comparing Varbinary.
+bool containsUnsupportedTypes(const TypePtr& type);
+
+// Invoked to set up memory system with arbitration.
+void setupMemory(int64_t allocatorCapacity, int64_t arbitratorCapacity);
+
+enum ReferenceQueryErrorCode {
+  kSuccess,
+  kReferenceQueryFail,
+  kReferenceQueryUnsupported
+};
+
+// Converts 'plan' into an SQL query and runs it on 'input' in the reference DB.
+// Result is returned as a MaterializedRowMultiset with the
+// ReferenceQueryErrorCode::kSuccess if successful, or an std::nullopt with a
+// ReferenceQueryErrorCode if the query fails.
+std::pair<std::optional<MaterializedRowMultiset>, ReferenceQueryErrorCode>
+computeReferenceResults(
+    const core::PlanNodePtr& plan,
+    const std::vector<RowVectorPtr>& input,
+    ReferenceQueryRunner* referenceQueryRunner);
+
+// Similar to computeReferenceResults(), but returns the result as a
+// std::vector<RowVectorPtr>. This API throws if referenceQueryRunner doesn't
+// support returning results as a vector.
+std::pair<std::optional<std::vector<RowVectorPtr>>, ReferenceQueryErrorCode>
+computeReferenceResultsAsVector(
+    const core::PlanNodePtr& plan,
+    const std::vector<RowVectorPtr>& input,
+    ReferenceQueryRunner* referenceQueryRunner);
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/InputGenerator.h b/velox/exec/fuzzer/InputGenerator.h
new file mode 100644
index 0000000000000..3da5f820b137a
--- /dev/null
+++ b/velox/exec/fuzzer/InputGenerator.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+class InputGenerator {
+ public:
+  virtual ~InputGenerator() = default;
+
+  /// Generates function inputs of the specified types. May return an empty list
+  /// to let Fuzzer use randomly-generated inputs.
+  virtual std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) = 0;
+
+  /// Called after generating all inputs for a given fuzzer iteration.
+  virtual void reset() = 0;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/JoinFuzzer.cpp b/velox/exec/fuzzer/JoinFuzzer.cpp
new file mode 100644
index 0000000000000..0d9c5187fa9b8
--- /dev/null
+++ b/velox/exec/fuzzer/JoinFuzzer.cpp
@@ -0,0 +1,1500 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/fuzzer/JoinFuzzer.h"
+#include <boost/random/uniform_int_distribution.hpp>
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/PartitionIdGenerator.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int32(steps, 10, "Number of plans to generate and test.");
+
+DEFINE_int32(
+    duration_sec,
+    0,
+    "For how long it should run (in seconds). If zero, "
+    "it executes exactly --steps iterations and exits.");
+
+DEFINE_int32(
+    batch_size,
+    100,
+    "The number of elements on each generated vector.");
+
+DEFINE_int32(num_batches, 10, "The number of generated vectors.");
+
+DEFINE_double(
+    null_ratio,
+    0.1,
+    "Chance of adding a null value in a vector "
+    "(expressed as double from 0 to 1).");
+
+DEFINE_bool(enable_spill, true, "Whether to test plans with spilling enabled");
+
+DEFINE_bool(
+    enable_oom_injection,
+    false,
+    "When enabled OOMs will randomly be triggered while executing query "
+    "plans. The goal of this mode is to ensure unexpected exceptions "
+    "aren't thrown and the process isn't killed in the process of cleaning "
+    "up after failures. Therefore, results are not compared when this is "
+    "enabled. Note that this option only works in debug builds.");
+
+namespace facebook::velox::exec::test {
+
+namespace {
+
+std::string makePercentageString(size_t value, size_t total) {
+  return fmt::format("{} ({:.2f}%)", value, (double)value / total * 100);
+}
+
+class JoinFuzzer {
+ public:
+  JoinFuzzer(
+      size_t initialSeed,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
+
+  void go();
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    std::unordered_map<core::PlanNodeId, std::vector<velox::exec::Split>>
+        splits;
+    core::ExecutionStrategy executionStrategy{
+        core::ExecutionStrategy::kUngrouped};
+    int32_t numGroups;
+
+    explicit PlanWithSplits(
+        const core::PlanNodePtr& _plan,
+        const core::PlanNodeId& _probeScanId = "",
+        const core::PlanNodeId& _buildScanId = "",
+        const std::unordered_map<
+            core::PlanNodeId,
+            std::vector<velox::exec::Split>>& _splits = {},
+        core::ExecutionStrategy _executionStrategy =
+            core::ExecutionStrategy::kUngrouped,
+        int32_t _numGroups = 0)
+        : plan(_plan),
+          probeScanId(_probeScanId),
+          buildScanId(_buildScanId),
+          splits(_splits),
+          executionStrategy(_executionStrategy),
+          numGroups(_numGroups) {}
+  };
+
+ private:
+  static VectorFuzzer::Options getFuzzerOptions() {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = FLAGS_batch_size;
+    opts.stringVariableLength = true;
+    opts.stringLength = 100;
+    opts.nullRatio = FLAGS_null_ratio;
+    opts.timestampPrecision =
+        VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+    return opts;
+  }
+
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    vectorFuzzer_.reSeed(seed);
+    rng_.seed(currentSeed_);
+  }
+
+  void reSeed() {
+    seed(rng_());
+  }
+
+  // Randomly pick a join type to test.
+  core::JoinType pickJoinType();
+
+  // Makes the query plan with default settings in JoinFuzzer and value inputs
+  // for both probe and build sides.
+  //
+  // NOTE: 'probeInput' and 'buildInput' could either input rows with lazy
+  // vectors or flatten ones.
+  JoinFuzzer::PlanWithSplits makeDefaultPlan(
+      core::JoinType joinType,
+      bool nullAware,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const std::vector<std::string>& outputColumns);
+
+  JoinFuzzer::PlanWithSplits makeMergeJoinPlan(
+      core::JoinType joinType,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const std::vector<std::string>& outputColumns);
+
+  // Returns a PlanWithSplits for NestedLoopJoin with inputs from Values nodes.
+  // If withFilter is true, uses the equality filter between probeKeys and
+  // buildKeys as the join filter. Uses empty join filter otherwise.
+  JoinFuzzer::PlanWithSplits makeNestedLoopJoinPlan(
+      core::JoinType joinType,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const std::vector<std::string>& outputColumns,
+      bool withFilter = true);
+
+  // Makes the default query plan with table scan as inputs for both probe and
+  // build sides.
+  JoinFuzzer::PlanWithSplits makeDefaultPlanWithTableScan(
+      core::JoinType joinType,
+      bool nullAware,
+      const RowTypePtr& probeType,
+      const RowTypePtr& buildType,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<Split>& probeSplits,
+      const std::vector<Split>& buildSplits,
+      const std::vector<std::string>& outputColumns);
+
+  JoinFuzzer::PlanWithSplits makeMergeJoinPlanWithTableScan(
+      core::JoinType joinType,
+      const RowTypePtr& probeType,
+      const RowTypePtr& buildType,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<Split>& probeSplits,
+      const std::vector<Split>& buildSplits,
+      const std::vector<std::string>& outputColumns);
+
+  // Returns a PlanWithSplits for NestedLoopJoin with inputs from TableScan
+  // nodes. If withFilter is true, uses the equiality filter between probeKeys
+  // and buildKeys as the join filter. Uses empty join filter otherwise.
+  JoinFuzzer::PlanWithSplits makeNestedLoopJoinPlanWithTableScan(
+      core::JoinType joinType,
+      const RowTypePtr& probeType,
+      const RowTypePtr& buildType,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<Split>& probeSplits,
+      const std::vector<Split>& buildSplits,
+      const std::vector<std::string>& outputColumns,
+      bool withFilter = true);
+
+  void makeAlternativePlans(
+      const core::PlanNodePtr& plan,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      std::vector<JoinFuzzer::PlanWithSplits>& plans);
+
+  // Makes the query plan from 'planWithTableScan' with grouped execution mode.
+  // Correspondingly, it replaces the table scan input splits with grouped ones.
+  JoinFuzzer::PlanWithSplits makeGroupedExecutionPlanWithTableScan(
+      const JoinFuzzer::PlanWithSplits& planWithTableScan,
+      int32_t numGroups,
+      const std::vector<exec::Split>& groupedProbeScanSplits,
+      const std::vector<exec::Split>& groupedBuildScanSplits);
+
+  // Runs one test iteration from query plans generations, executions and result
+  // verifications.
+  void verify(core::JoinType joinType);
+
+  // Returns a list of randomly generated join key types.
+  std::vector<TypePtr> generateJoinKeyTypes(int32_t numKeys);
+
+  // Returns randomly generated probe input with upto 3 additional payload
+  // columns.
+  std::vector<RowVectorPtr> generateProbeInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
+  // Same as generateProbeInput() but copies over 10% of the input in the probe
+  // columns to ensure some matches during joining. Also generates an empty
+  // input with a 10% chance.
+  std::vector<RowVectorPtr> generateBuildInput(
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys);
+
+  void shuffleJoinKeys(
+      std::vector<std::string>& probeKeys,
+      std::vector<std::string>& buildKeys);
+
+  void addPlansWithTableScan(
+      const std::string& tableDir,
+      core::JoinType joinType,
+      bool nullAware,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const std::vector<std::string>& outputColumns,
+      std::vector<PlanWithSplits>& altPlans);
+
+  // Splits the input into groups by partitioning on the join keys.
+  std::vector<std::vector<RowVectorPtr>> splitInputByGroup(
+      int32_t numGroups,
+      size_t numKeys,
+      const std::vector<RowVectorPtr>& inputs);
+
+  // Generates the grouped splits.
+  std::vector<exec::Split> generateSplitsWithGroup(
+      const std::string& tableDir,
+      int32_t numGroups,
+      bool isProbe,
+      size_t numKeys,
+      const std::vector<RowVectorPtr>& input);
+
+  RowVectorPtr execute(const PlanWithSplits& plan, bool injectSpill);
+
+  std::optional<MaterializedRowMultiset> computeReferenceResults(
+      const core::PlanNodePtr& plan,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput);
+
+  // Generates and executes plans using NestedLoopJoin without filters. The
+  // result is compared to DuckDB. Returns the result vector of the cross
+  // product.
+  RowVectorPtr testCrossProduct(
+      const std::string& tableDir,
+      core::JoinType joinType,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput);
+
+  int32_t randInt(int32_t min, int32_t max) {
+    return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
+  }
+
+  FuzzerGenerator rng_;
+  size_t currentSeed_{0};
+
+  std::shared_ptr<memory::MemoryPool> rootPool_{
+      memory::memoryManager()->addRootPool(
+          "joinFuzzer",
+          memory::kMaxMemory,
+          memory::MemoryReclaimer::create())};
+  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild(
+      "joinFuzzerLeaf",
+      true,
+      exec::MemoryReclaimer::create())};
+  std::shared_ptr<memory::MemoryPool> writerPool_{rootPool_->addAggregateChild(
+      "joinFuzzerWriter",
+      exec::MemoryReclaimer::create())};
+
+  VectorFuzzer vectorFuzzer_;
+  std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner_;
+
+  struct Stats {
+    // The total number of iterations tested.
+    size_t numIterations{0};
+
+    // The number of iterations verified against reference DB.
+    size_t numVerified{0};
+
+    // The number of iterations that test cross product.
+    size_t numCrossProduct{0};
+
+    std::string toString() const {
+      std::stringstream out;
+      out << "\nTotal iterations tested: " << numIterations << std::endl;
+      out << "Total iterations verified against reference DB: "
+          << makePercentageString(numVerified, numIterations) << std::endl;
+      out << "Total iterations testing cross product: "
+          << makePercentageString(numCrossProduct, numIterations) << std::endl;
+
+      return out.str();
+    }
+  };
+
+  Stats stats_;
+};
+
+JoinFuzzer::JoinFuzzer(
+    size_t initialSeed,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner)
+    : vectorFuzzer_{getFuzzerOptions(), pool_.get()},
+      referenceQueryRunner_{std::move(referenceQueryRunner)} {
+  filesystems::registerLocalFileSystem();
+
+  // Make sure not to run out of open file descriptors.
+  std::unordered_map<std::string, std::string> hiveConfig = {
+      {connector::hive::HiveConfig::kNumCacheFileHandles, "1000"}};
+  auto hiveConnector =
+      connector::getConnectorFactory(
+          connector::hive::HiveConnectorFactory::kHiveConnectorName)
+          ->newConnector(
+              kHiveConnectorId,
+              std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
+  connector::registerConnector(hiveConnector);
+
+  seed(initialSeed);
+}
+
+template <typename T>
+bool isDone(size_t i, T startTime) {
+  if (FLAGS_duration_sec > 0) {
+    std::chrono::duration<double> elapsed =
+        std::chrono::system_clock::now() - startTime;
+    return elapsed.count() >= FLAGS_duration_sec;
+  }
+  return i >= FLAGS_steps;
+}
+
+core::JoinType JoinFuzzer::pickJoinType() {
+  // Right joins are tested by flipping sides of the left joins.
+  static std::vector<core::JoinType> kJoinTypes = {
+      core::JoinType::kInner,
+      core::JoinType::kLeft,
+      core::JoinType::kFull,
+      core::JoinType::kLeftSemiFilter,
+      core::JoinType::kLeftSemiProject,
+      core::JoinType::kAnti};
+
+  const size_t idx = randInt(0, kJoinTypes.size() - 1);
+  return kJoinTypes[idx];
+}
+
+std::vector<TypePtr> JoinFuzzer::generateJoinKeyTypes(int32_t numKeys) {
+  std::vector<TypePtr> types;
+  types.reserve(numKeys);
+  for (auto i = 0; i < numKeys; ++i) {
+    // Pick random scalar type.
+    types.push_back(vectorFuzzer_.randType(
+        referenceQueryRunner_->supportedScalarTypes(), /*maxDepth=*/0));
+  }
+  return types;
+}
+
+std::vector<RowVectorPtr> JoinFuzzer::generateProbeInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  std::vector<std::string> names = keyNames;
+  std::vector<TypePtr> types = keyTypes;
+
+  bool keyTypesAllBool = true;
+  for (const auto& type : keyTypes) {
+    if (!type->isBoolean()) {
+      keyTypesAllBool = false;
+      break;
+    }
+  }
+
+  // Add up to 3 payload columns.
+  const auto numPayload = randInt(0, 3);
+  for (auto i = 0; i < numPayload; ++i) {
+    names.push_back(fmt::format("tp{}", i + keyNames.size()));
+    types.push_back(vectorFuzzer_.randType(
+        referenceQueryRunner_->supportedScalarTypes(), /*maxDepth=*/2));
+  }
+
+  const auto inputType = ROW(std::move(names), std::move(types));
+  std::vector<RowVectorPtr> input;
+  for (auto i = 0; i < FLAGS_num_batches; ++i) {
+    if (keyTypesAllBool) {
+      // Joining on just boolean keys creates so many hits it explodes the
+      // output size, reduce the batch size to 10% to control the output size
+      // while still covering this case.
+      input.push_back(
+          vectorFuzzer_.fuzzRow(inputType, FLAGS_batch_size / 10, false));
+    } else {
+      input.push_back(vectorFuzzer_.fuzzInputRow(inputType));
+    }
+  }
+  return input;
+}
+
+std::vector<RowVectorPtr> JoinFuzzer::generateBuildInput(
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys) {
+  std::vector<std::string> names = buildKeys;
+  std::vector<TypePtr> types;
+  for (const auto& key : probeKeys) {
+    types.push_back(asRowType(probeInput[0]->type())->findChild(key));
+  }
+
+  // Add up to 3 payload columns.
+  const auto numPayload = randInt(0, 3);
+  for (auto i = 0; i < numPayload; ++i) {
+    names.push_back(fmt::format("bp{}", i + buildKeys.size()));
+    types.push_back(vectorFuzzer_.randType(
+        referenceQueryRunner_->supportedScalarTypes(), /*maxDepth=*/2));
+  }
+
+  const auto rowType = ROW(std::move(names), std::move(types));
+
+  // 1 in 10 times use empty build.
+  // TODO Use non-empty build with no matches sometimes.
+  if (vectorFuzzer_.coinToss(0.1)) {
+    return {BaseVector::create<RowVector>(rowType, 0, pool_.get())};
+  }
+
+  // TODO Remove the assumption that probeKeys are the first columns in
+  // probeInput.
+
+  // To ensure there are some matches, sample with replacement 10% of probe join
+  // keys and use these as 80% of build keys. The rest build keys are randomly
+  // generated. This allows the build side to have unmatched rows that should
+  // appear in right join and full join.
+  std::vector<RowVectorPtr> input;
+  for (const auto& probe : probeInput) {
+    auto numRows = 1 + probe->size() / 8;
+    auto build = vectorFuzzer_.fuzzRow(rowType, numRows, false);
+
+    // Pick probe side rows to copy.
+    std::vector<vector_size_t> rowNumbers(numRows);
+    SelectivityVector rows(numRows, false);
+    for (auto i = 0; i < numRows; ++i) {
+      if (vectorFuzzer_.coinToss(0.8) && probe->size() > 0) {
+        rowNumbers[i] = randInt(0, probe->size() - 1);
+        rows.setValid(i, true);
+      }
+    }
+
+    for (auto i = 0; i < probeKeys.size(); ++i) {
+      build->childAt(i)->resize(numRows);
+      build->childAt(i)->copy(probe->childAt(i).get(), rows, rowNumbers.data());
+    }
+
+    for (auto i = 0; i < numPayload; ++i) {
+      auto column = i + probeKeys.size();
+      build->childAt(column) =
+          vectorFuzzer_.fuzz(rowType->childAt(column), numRows);
+    }
+
+    input.push_back(build);
+  }
+
+  return input;
+}
+
+std::vector<RowVectorPtr> flatten(const std::vector<RowVectorPtr>& vectors) {
+  std::vector<RowVectorPtr> flatVectors;
+  for (const auto& vector : vectors) {
+    auto flat = BaseVector::create<RowVector>(
+        vector->type(), vector->size(), vector->pool());
+    flat->copy(vector.get(), 0, 0, vector->size());
+    flatVectors.push_back(flat);
+  }
+
+  return flatVectors;
+}
+
+RowVectorPtr JoinFuzzer::execute(const PlanWithSplits& plan, bool injectSpill) {
+  LOG(INFO) << "Executing query plan with "
+            << executionStrategyToString(plan.executionStrategy) << " strategy["
+            << (plan.executionStrategy == core::ExecutionStrategy::kGrouped
+                    ? plan.numGroups
+                    : 0)
+            << " groups]" << (injectSpill ? " and spilling injection" : "")
+            << ": " << std::endl
+            << plan.plan->toString(true, true);
+
+  AssertQueryBuilder builder(plan.plan);
+  for (const auto& [planNodeId, nodeSplits] : plan.splits) {
+    builder.splits(planNodeId, nodeSplits);
+  }
+
+  if (plan.executionStrategy == core::ExecutionStrategy::kGrouped) {
+    builder.executionStrategy(core::ExecutionStrategy::kGrouped);
+    builder.groupedExecutionLeafNodeIds({plan.probeScanId, plan.buildScanId});
+    builder.numSplitGroups(plan.numGroups);
+    builder.numConcurrentSplitGroups(randInt(1, plan.numGroups));
+  }
+
+  std::shared_ptr<TempDirectoryPath> spillDirectory;
+  int32_t spillPct{0};
+  if (injectSpill) {
+    spillDirectory = exec::test::TempDirectoryPath::create();
+    builder.config(core::QueryConfig::kSpillEnabled, true)
+        .config(core::QueryConfig::kJoinSpillEnabled, true)
+        .spillDirectory(spillDirectory->getPath());
+    spillPct = 10;
+  }
+
+  ScopedOOMInjector oomInjector(
+      []() -> bool { return folly::Random::oneIn(10); },
+      10); // Check the condition every 10 ms.
+  if (FLAGS_enable_oom_injection) {
+    oomInjector.enable();
+  }
+
+  TestScopedSpillInjection scopedSpillInjection(spillPct);
+  RowVectorPtr result;
+  try {
+    result = builder.maxDrivers(2).copyResults(pool_.get());
+  } catch (VeloxRuntimeError& e) {
+    if (FLAGS_enable_oom_injection &&
+        e.errorCode() == facebook::velox::error_code::kMemCapExceeded &&
+        e.message() == ScopedOOMInjector::kErrorMessage) {
+      // If we enabled OOM injection we expect the exception thrown by the
+      // ScopedOOMInjector.
+      return nullptr;
+    }
+
+    throw e;
+  }
+  LOG(INFO) << "Results: " << result->toString();
+  if (VLOG_IS_ON(1)) {
+    VLOG(1) << std::endl << result->toString(0, result->size());
+  }
+  // Wait for the task to be destroyed before start next query execution to
+  // avoid the potential interference of the background activities across query
+  // executions.
+  waitForAllTasksToBeDeleted();
+  return result;
+}
+
+std::optional<core::JoinType> tryFlipJoinType(core::JoinType joinType) {
+  switch (joinType) {
+    case core::JoinType::kInner:
+      return joinType;
+    case core::JoinType::kLeft:
+      return core::JoinType::kRight;
+    case core::JoinType::kRight:
+      return core::JoinType::kLeft;
+    case core::JoinType::kFull:
+      return joinType;
+    case core::JoinType::kLeftSemiFilter:
+      return core::JoinType::kRightSemiFilter;
+    case core::JoinType::kLeftSemiProject:
+      return core::JoinType::kRightSemiProject;
+    case core::JoinType::kRightSemiFilter:
+      return core::JoinType::kLeftSemiFilter;
+    case core::JoinType::kRightSemiProject:
+      return core::JoinType::kLeftSemiProject;
+    default:
+      return std::nullopt;
+  }
+}
+
+// Returns a plan with flipped join sides of the input hash join node. If the
+// join type doesn't allow flipping, returns a nullptr.
+core::PlanNodePtr tryFlipJoinSides(const core::HashJoinNode& joinNode) {
+  auto flippedJoinType = tryFlipJoinType(joinNode.joinType());
+  if (!flippedJoinType.has_value()) {
+    return nullptr;
+  }
+
+  return std::make_shared<core::HashJoinNode>(
+      joinNode.id(),
+      flippedJoinType.value(),
+      joinNode.isNullAware(),
+      joinNode.rightKeys(),
+      joinNode.leftKeys(),
+      joinNode.filter(),
+      joinNode.sources()[1],
+      joinNode.sources()[0],
+      joinNode.outputType());
+}
+
+// Returns a plan with flipped join sides of the input merge join node. If the
+// join type doesn't allow flipping, returns a nullptr.
+core::PlanNodePtr tryFlipJoinSides(const core::MergeJoinNode& joinNode) {
+  // Merge join only supports inner and left join, so only inner join can be
+  // flipped.
+  if (joinNode.joinType() != core::JoinType::kInner) {
+    return nullptr;
+  }
+  auto flippedJoinType = core::JoinType::kInner;
+
+  return std::make_shared<core::MergeJoinNode>(
+      joinNode.id(),
+      flippedJoinType,
+      joinNode.rightKeys(),
+      joinNode.leftKeys(),
+      joinNode.filter(),
+      joinNode.sources()[1],
+      joinNode.sources()[0],
+      joinNode.outputType());
+}
+
+// Returns a plan with flipped join sides of the input nested loop join node. If
+// the join type doesn't allow flipping, returns a nullptr.
+core::PlanNodePtr tryFlipJoinSides(const core::NestedLoopJoinNode& joinNode) {
+  auto flippedJoinType = tryFlipJoinType(joinNode.joinType());
+  if (!flippedJoinType.has_value()) {
+    return nullptr;
+  }
+
+  return std::make_shared<core::NestedLoopJoinNode>(
+      joinNode.id(),
+      flippedJoinType.value(),
+      joinNode.joinCondition(),
+      joinNode.sources()[1],
+      joinNode.sources()[0],
+      joinNode.outputType());
+}
+
+std::optional<MaterializedRowMultiset> JoinFuzzer::computeReferenceResults(
+    const core::PlanNodePtr& plan,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput) {
+  if (referenceQueryRunner_->runnerType() ==
+      ReferenceQueryRunner::RunnerType::kDuckQueryRunner) {
+    VELOX_CHECK(!containsUnsupportedTypes(probeInput[0]->type()));
+    VELOX_CHECK(!containsUnsupportedTypes(buildInput[0]->type()));
+  }
+
+  if (auto sql = referenceQueryRunner_->toSql(plan)) {
+    return referenceQueryRunner_->execute(
+        sql.value(), probeInput, buildInput, plan->outputType());
+  }
+
+  LOG(INFO) << "Query not supported by the reference DB";
+  return std::nullopt;
+}
+
+std::vector<std::string> fieldNames(
+    const std::vector<core::FieldAccessTypedExprPtr>& fields) {
+  std::vector<std::string> names;
+  names.reserve(fields.size());
+  for (const auto& field : fields) {
+    names.push_back(field->name());
+  }
+  return names;
+}
+
+JoinFuzzer::PlanWithSplits JoinFuzzer::makeDefaultPlan(
+    core::JoinType joinType,
+    bool nullAware,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    const std::vector<std::string>& outputColumns) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(probeInput)
+          .hashJoin(
+              probeKeys,
+              buildKeys,
+              PlanBuilder(planNodeIdGenerator).values(buildInput).planNode(),
+              /*filter=*/"",
+              outputColumns,
+              joinType,
+              nullAware)
+          .planNode();
+  return PlanWithSplits{plan};
+}
+
+JoinFuzzer::PlanWithSplits JoinFuzzer::makeDefaultPlanWithTableScan(
+    core::JoinType joinType,
+    bool nullAware,
+    const RowTypePtr& probeType,
+    const RowTypePtr& buildType,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<Split>& probeSplits,
+    const std::vector<Split>& buildSplits,
+    const std::vector<std::string>& outputColumns) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId buildScanId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(probeType)
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      probeKeys,
+                      buildKeys,
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(buildType)
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      /*filter=*/"",
+                      outputColumns,
+                      joinType,
+                      nullAware)
+                  .planNode();
+  return PlanWithSplits{
+      plan,
+      probeScanId,
+      buildScanId,
+      {{probeScanId, probeSplits}, {buildScanId, buildSplits}}};
+}
+
+JoinFuzzer::PlanWithSplits JoinFuzzer::makeGroupedExecutionPlanWithTableScan(
+    const JoinFuzzer::PlanWithSplits& planWithTableScan,
+    int32_t numGroups,
+    const std::vector<exec::Split>& groupedProbeScanSplits,
+    const std::vector<exec::Split>& groupedBuildScanSplits) {
+  return PlanWithSplits{
+      planWithTableScan.plan,
+      planWithTableScan.probeScanId,
+      planWithTableScan.buildScanId,
+      {{planWithTableScan.probeScanId, groupedProbeScanSplits},
+       {planWithTableScan.buildScanId, groupedBuildScanSplits}},
+      core::ExecutionStrategy::kGrouped,
+      numGroups};
+}
+
+std::vector<core::PlanNodePtr> makeSources(
+    const std::vector<RowVectorPtr>& input,
+    std::shared_ptr<core::PlanNodeIdGenerator>& planNodeIdGenerator) {
+  auto numSources = std::min<size_t>(4, input.size());
+  std::vector<std::vector<RowVectorPtr>> sourceInputs(numSources);
+  for (auto i = 0; i < input.size(); ++i) {
+    sourceInputs[i % numSources].push_back(input[i]);
+  }
+
+  std::vector<core::PlanNodePtr> sourceNodes;
+  for (const auto& sourceInput : sourceInputs) {
+    sourceNodes.push_back(
+        PlanBuilder(planNodeIdGenerator).values(sourceInput).planNode());
+  }
+
+  return sourceNodes;
+}
+
+// Returns an equality join filter between probeKeys and buildKeys.
+std::string makeJoinFilter(
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys) {
+  const auto numKeys = probeKeys.size();
+  std::string filter;
+  VELOX_CHECK_EQ(numKeys, buildKeys.size());
+  for (auto i = 0; i < numKeys; ++i) {
+    if (i > 0) {
+      filter += " AND ";
+    }
+    filter += fmt::format("{} = {}", probeKeys[i], buildKeys[i]);
+  }
+  return filter;
+}
+
+template <typename TNode>
+void addFlippedJoinPlan(
+    const core::PlanNodePtr& plan,
+    std::vector<JoinFuzzer::PlanWithSplits>& plans,
+    const core::PlanNodeId& probeScanId = "",
+    const core::PlanNodeId& buildScanId = "",
+    const std::unordered_map<core::PlanNodeId, std::vector<velox::exec::Split>>&
+        splits = {},
+    core::ExecutionStrategy executionStrategy =
+        core::ExecutionStrategy::kUngrouped,
+    int32_t numGroups = 0) {
+  auto joinNode = std::dynamic_pointer_cast<const TNode>(plan);
+  VELOX_CHECK_NOT_NULL(joinNode);
+  if (auto flippedPlan = tryFlipJoinSides(*joinNode)) {
+    plans.push_back(JoinFuzzer::PlanWithSplits{
+        flippedPlan,
+        probeScanId,
+        buildScanId,
+        splits,
+        executionStrategy,
+        numGroups});
+  }
+}
+
+JoinFuzzer::PlanWithSplits JoinFuzzer::makeMergeJoinPlan(
+    core::JoinType joinType,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    const std::vector<std::string>& outputColumns) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  return JoinFuzzer::PlanWithSplits{PlanBuilder(planNodeIdGenerator)
+                                        .values(probeInput)
+                                        .orderBy(probeKeys, false)
+                                        .mergeJoin(
+                                            probeKeys,
+                                            buildKeys,
+                                            PlanBuilder(planNodeIdGenerator)
+                                                .values(buildInput)
+                                                .orderBy(buildKeys, false)
+                                                .planNode(),
+                                            /*filter=*/"",
+                                            outputColumns,
+                                            joinType)
+                                        .planNode()};
+}
+
+JoinFuzzer::PlanWithSplits JoinFuzzer::makeNestedLoopJoinPlan(
+    core::JoinType joinType,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    const std::vector<std::string>& outputColumns,
+    bool withFilter) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const std::string filter =
+      withFilter ? makeJoinFilter(probeKeys, buildKeys) : "";
+  return JoinFuzzer::PlanWithSplits{
+      PlanBuilder(planNodeIdGenerator)
+          .values(probeInput)
+          .nestedLoopJoin(
+              PlanBuilder(planNodeIdGenerator).values(buildInput).planNode(),
+              filter,
+              outputColumns,
+              joinType)
+          .planNode()};
+}
+
+void JoinFuzzer::makeAlternativePlans(
+    const core::PlanNodePtr& plan,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    std::vector<JoinFuzzer::PlanWithSplits>& plans) {
+  auto joinNode = std::dynamic_pointer_cast<const core::HashJoinNode>(plan);
+  VELOX_CHECK_NOT_NULL(joinNode);
+
+  // Flip join sides.
+  addFlippedJoinPlan<core::HashJoinNode>(plan, plans);
+
+  // Parallelize probe and build sides.
+  const auto probeKeys = fieldNames(joinNode->leftKeys());
+  const auto buildKeys = fieldNames(joinNode->rightKeys());
+  const auto outputColumns = joinNode->outputType()->names();
+  const auto joinType = joinNode->joinType();
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  plans.push_back(JoinFuzzer::PlanWithSplits{
+      PlanBuilder(planNodeIdGenerator)
+          .localPartitionRoundRobin(
+              makeSources(probeInput, planNodeIdGenerator))
+          .hashJoin(
+              probeKeys,
+              buildKeys,
+              PlanBuilder(planNodeIdGenerator)
+                  .localPartitionRoundRobin(
+                      makeSources(buildInput, planNodeIdGenerator))
+                  .planNode(),
+              /*filter=*/"",
+              outputColumns,
+              joinType,
+              joinNode->isNullAware())
+          .planNode()});
+
+  // Use OrderBy + MergeJoin
+  if (core::MergeJoinNode::isSupported(joinNode->joinType())) {
+    auto planWithSplits = makeMergeJoinPlan(
+        joinType, probeKeys, buildKeys, probeInput, buildInput, outputColumns);
+    plans.push_back(planWithSplits);
+
+    addFlippedJoinPlan<core::MergeJoinNode>(planWithSplits.plan, plans);
+  }
+
+  // Use NestedLoopJoin.
+  if (core::NestedLoopJoinNode::isSupported(joinNode->joinType())) {
+    auto planWithSplits = makeNestedLoopJoinPlan(
+        joinType, probeKeys, buildKeys, probeInput, buildInput, outputColumns);
+    plans.push_back(planWithSplits);
+
+    addFlippedJoinPlan<core::NestedLoopJoinNode>(planWithSplits.plan, plans);
+  }
+}
+
+void JoinFuzzer::shuffleJoinKeys(
+    std::vector<std::string>& probeKeys,
+    std::vector<std::string>& buildKeys) {
+  auto numKeys = probeKeys.size();
+  if (numKeys == 1) {
+    return;
+  }
+
+  std::vector<column_index_t> columnIndices(numKeys);
+  std::iota(columnIndices.begin(), columnIndices.end(), 0);
+  std::shuffle(columnIndices.begin(), columnIndices.end(), rng_);
+
+  auto copyProbeKeys = probeKeys;
+  auto copyBuildKeys = buildKeys;
+
+  for (auto i = 0; i < numKeys; ++i) {
+    probeKeys[i] = copyProbeKeys[columnIndices[i]];
+    buildKeys[i] = copyBuildKeys[columnIndices[i]];
+  }
+}
+
+RowVectorPtr JoinFuzzer::testCrossProduct(
+    const std::string& tableDir,
+    core::JoinType joinType,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput) {
+  VELOX_CHECK_GT(probeInput.size(), 0);
+  VELOX_CHECK_GT(buildInput.size(), 0);
+
+  const auto probeType = asRowType(probeInput[0]->type());
+  const auto buildType = asRowType(buildInput[0]->type());
+  auto outputColumns =
+      concat(asRowType(probeInput[0]->type()), asRowType(buildInput[0]->type()))
+          ->names();
+
+  auto plan = makeNestedLoopJoinPlan(
+      joinType,
+      probeKeys,
+      buildKeys,
+      probeInput,
+      buildInput,
+      outputColumns,
+      /*withFilter*/ false);
+  const auto expected = execute(plan, /*injectSpill=*/false);
+
+  // If OOM injection is not enabled verify the results against Reference query
+  // runner.
+  if (!FLAGS_enable_oom_injection) {
+    if (auto referenceResult =
+            computeReferenceResults(plan.plan, probeInput, buildInput)) {
+      VELOX_CHECK(
+          assertEqualResults(
+              referenceResult.value(), plan.plan->outputType(), {expected}),
+          "Velox and DuckDB results don't match");
+
+      LOG(INFO) << "Result matches with referenc DB.";
+      stats_.numVerified++;
+    }
+  }
+
+  std::vector<PlanWithSplits> altPlans;
+  if (isTableScanSupported(probeInput[0]->type()) &&
+      isTableScanSupported(buildInput[0]->type())) {
+    std::vector<Split> probeScanSplits =
+        makeSplits(probeInput, fmt::format("{}/probe", tableDir), writerPool_);
+    std::vector<Split> buildScanSplits =
+        makeSplits(buildInput, fmt::format("{}/build", tableDir), writerPool_);
+
+    altPlans.push_back(makeNestedLoopJoinPlanWithTableScan(
+        joinType,
+        probeType,
+        buildType,
+        probeKeys,
+        buildKeys,
+        probeScanSplits,
+        buildScanSplits,
+        outputColumns,
+        /*withFilter*/ false));
+  }
+  addFlippedJoinPlan<core::NestedLoopJoinNode>(plan.plan, altPlans);
+
+  for (const auto& altPlan : altPlans) {
+    auto actual = execute(altPlan, /*injectSpill=*/false);
+    if (actual != nullptr && expected != nullptr) {
+      VELOX_CHECK(
+          assertEqualResults({expected}, {actual}),
+          "Logically equivalent plans produced different results");
+    }
+  }
+  return expected;
+}
+
+void JoinFuzzer::verify(core::JoinType joinType) {
+  const bool nullAware =
+      isNullAwareSupported(joinType) && vectorFuzzer_.coinToss(0.5);
+
+  const auto numKeys = nullAware ? 1 : randInt(1, 5);
+
+  // Pick number and types of join keys.
+  const std::vector<TypePtr> keyTypes = generateJoinKeyTypes(numKeys);
+  std::vector<std::string> probeKeys = makeNames("t", keyTypes.size());
+  std::vector<std::string> buildKeys = makeNames("u", keyTypes.size());
+
+  auto probeInput = generateProbeInput(probeKeys, keyTypes);
+  auto buildInput = generateBuildInput(probeInput, probeKeys, buildKeys);
+
+  // Flatten inputs.
+  auto flatProbeInput = flatten(probeInput);
+  auto flatBuildInput = flatten(buildInput);
+
+  if (VLOG_IS_ON(1)) {
+    VLOG(1) << "Probe input: " << probeInput[0]->toString();
+    for (const auto& v : flatProbeInput) {
+      VLOG(1) << std::endl << v->toString(0, v->size());
+    }
+
+    VLOG(1) << "Build input: " << buildInput[0]->toString();
+    for (const auto& v : flatBuildInput) {
+      VLOG(1) << std::endl << v->toString(0, v->size());
+    }
+  }
+
+  const auto tableScanDir = exec::test::TempDirectoryPath::create();
+
+  // Test cross product without filter with 10% chance. Avoid testing cross
+  // product if input size is too large.
+  if ((core::isInnerJoin(joinType) || core::isLeftJoin(joinType) ||
+       core::isFullJoin(joinType)) &&
+      FLAGS_batch_size * FLAGS_num_batches <= 500) {
+    if (vectorFuzzer_.coinToss(0.1)) {
+      stats_.numCrossProduct++;
+
+      auto result = testCrossProduct(
+          tableScanDir->getPath(),
+          joinType,
+          probeKeys,
+          buildKeys,
+          probeInput,
+          buildInput);
+      auto flatResult = testCrossProduct(
+          tableScanDir->getPath(),
+          joinType,
+          probeKeys,
+          buildKeys,
+          flatProbeInput,
+          flatBuildInput);
+      assertEqualResults({result}, {flatResult});
+    }
+  }
+
+  auto outputColumns =
+      (core::isLeftSemiProjectJoin(joinType) ||
+       core::isLeftSemiFilterJoin(joinType) || core::isAntiJoin(joinType))
+      ? asRowType(probeInput[0]->type())->names()
+      : concat(
+            asRowType(probeInput[0]->type()), asRowType(buildInput[0]->type()))
+            ->names();
+
+  // Shuffle output columns.
+  std::shuffle(outputColumns.begin(), outputColumns.end(), rng_);
+
+  // Remove some output columns.
+  const auto numOutput = randInt(1, outputColumns.size());
+  outputColumns.resize(numOutput);
+
+  if (core::isLeftSemiProjectJoin(joinType) ||
+      core::isRightSemiProjectJoin(joinType)) {
+    outputColumns.push_back("match");
+  }
+
+  shuffleJoinKeys(probeKeys, buildKeys);
+
+  const auto defaultPlan = makeDefaultPlan(
+      joinType,
+      nullAware,
+      probeKeys,
+      buildKeys,
+      probeInput,
+      buildInput,
+      outputColumns);
+
+  const auto expected = execute(defaultPlan, /*injectSpill=*/false);
+
+  // If OOM injection is not enabled verify the results against Reference query
+  // runner.
+  if (!FLAGS_enable_oom_injection) {
+    if (auto referenceResult =
+            computeReferenceResults(defaultPlan.plan, probeInput, buildInput)) {
+      VELOX_CHECK(
+          assertEqualResults(
+              referenceResult.value(),
+              defaultPlan.plan->outputType(),
+              {expected}),
+          "Velox and Reference results don't match");
+
+      LOG(INFO) << "Result matches with referenc DB.";
+      stats_.numVerified++;
+    }
+  }
+
+  std::vector<PlanWithSplits> altPlans;
+  altPlans.push_back(makeDefaultPlan(
+      joinType,
+      nullAware,
+      probeKeys,
+      buildKeys,
+      flatProbeInput,
+      flatBuildInput,
+      outputColumns));
+
+  makeAlternativePlans(defaultPlan.plan, probeInput, buildInput, altPlans);
+  makeAlternativePlans(
+      defaultPlan.plan, flatProbeInput, flatBuildInput, altPlans);
+
+  addPlansWithTableScan(
+      tableScanDir->getPath(),
+      joinType,
+      nullAware,
+      probeKeys,
+      buildKeys,
+      flatProbeInput,
+      flatBuildInput,
+      outputColumns,
+      altPlans);
+
+  for (auto i = 0; i < altPlans.size(); ++i) {
+    LOG(INFO) << "Testing plan #" << i;
+    auto actual = execute(altPlans[i], /*injectSpill=*/false);
+    if (actual != nullptr && expected != nullptr) {
+      VELOX_CHECK(
+          assertEqualResults({expected}, {actual}),
+          "Logically equivalent plans produced different results");
+    } else {
+      VELOX_CHECK(
+          FLAGS_enable_oom_injection, "Got unexpected nullptr for results");
+    }
+
+    if (FLAGS_enable_spill) {
+      // Spilling for right semi project doesn't work yet.
+      if (auto hashJoin = std::dynamic_pointer_cast<const core::HashJoinNode>(
+              altPlans[i].plan)) {
+        if (hashJoin->isRightSemiProjectJoin()) {
+          continue;
+        }
+      }
+
+      LOG(INFO) << "Testing plan #" << i << " with spilling";
+      actual = execute(altPlans[i], /*=injectSpill=*/true);
+      if (actual != nullptr && expected != nullptr) {
+        try {
+          VELOX_CHECK(
+              assertEqualResults({expected}, {actual}),
+              "Logically equivalent plans produced different results");
+        } catch (const VeloxException&) {
+          LOG(ERROR) << "Expected\n"
+                     << expected->toString(0, expected->size()) << "\nActual\n"
+                     << actual->toString(0, actual->size());
+          throw;
+        }
+      } else {
+        VELOX_CHECK(
+            FLAGS_enable_oom_injection, "Got unexpected nullptr for results");
+      }
+    }
+  }
+}
+
+JoinFuzzer::PlanWithSplits JoinFuzzer::makeMergeJoinPlanWithTableScan(
+    core::JoinType joinType,
+    const RowTypePtr& probeType,
+    const RowTypePtr& buildType,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<Split>& probeSplits,
+    const std::vector<Split>& buildSplits,
+    const std::vector<std::string>& outputColumns) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId buildScanId;
+
+  return JoinFuzzer::PlanWithSplits{
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(probeType)
+          .capturePlanNodeId(probeScanId)
+          .orderBy(probeKeys, false)
+          .mergeJoin(
+              probeKeys,
+              buildKeys,
+              PlanBuilder(planNodeIdGenerator)
+                  .tableScan(buildType)
+                  .capturePlanNodeId(buildScanId)
+                  .orderBy(buildKeys, false)
+                  .planNode(),
+              /*filter=*/"",
+              outputColumns,
+              joinType)
+          .planNode(),
+      probeScanId,
+      buildScanId,
+      {{probeScanId, probeSplits}, {buildScanId, buildSplits}}};
+}
+
+JoinFuzzer::PlanWithSplits JoinFuzzer::makeNestedLoopJoinPlanWithTableScan(
+    core::JoinType joinType,
+    const RowTypePtr& probeType,
+    const RowTypePtr& buildType,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<Split>& probeSplits,
+    const std::vector<Split>& buildSplits,
+    const std::vector<std::string>& outputColumns,
+    bool withFilter) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId buildScanId;
+
+  const std::string filter =
+      withFilter ? makeJoinFilter(probeKeys, buildKeys) : "";
+  return JoinFuzzer::PlanWithSplits{
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(probeType)
+          .capturePlanNodeId(probeScanId)
+          .nestedLoopJoin(
+              PlanBuilder(planNodeIdGenerator)
+                  .tableScan(buildType)
+                  .capturePlanNodeId(buildScanId)
+                  .planNode(),
+              filter,
+              outputColumns,
+              joinType)
+          .planNode(),
+      probeScanId,
+      buildScanId,
+      {{probeScanId, probeSplits}, {buildScanId, buildSplits}}};
+}
+
+void JoinFuzzer::addPlansWithTableScan(
+    const std::string& tableDir,
+    core::JoinType joinType,
+    bool nullAware,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    const std::vector<std::string>& outputColumns,
+    std::vector<PlanWithSplits>& altPlans) {
+  VELOX_CHECK(!tableDir.empty());
+
+  if (!isTableScanSupported(probeInput[0]->type()) ||
+      !isTableScanSupported(buildInput[0]->type())) {
+    return;
+  }
+
+  std::vector<Split> probeScanSplits =
+      makeSplits(probeInput, fmt::format("{}/probe", tableDir), writerPool_);
+  std::vector<Split> buildScanSplits =
+      makeSplits(buildInput, fmt::format("{}/build", tableDir), writerPool_);
+
+  const auto probeType = asRowType(probeInput[0]->type());
+  const auto buildType = asRowType(buildInput[0]->type());
+
+  std::vector<PlanWithSplits> plansWithTableScan;
+  auto defaultPlan = makeDefaultPlanWithTableScan(
+      joinType,
+      nullAware,
+      probeType,
+      buildType,
+      probeKeys,
+      buildKeys,
+      probeScanSplits,
+      buildScanSplits,
+      outputColumns);
+  plansWithTableScan.push_back(defaultPlan);
+
+  auto joinNode =
+      std::dynamic_pointer_cast<const core::HashJoinNode>(defaultPlan.plan);
+  VELOX_CHECK_NOT_NULL(joinNode);
+
+  // Flip join sides.
+  addFlippedJoinPlan<core::HashJoinNode>(
+      defaultPlan.plan,
+      plansWithTableScan,
+      defaultPlan.probeScanId,
+      defaultPlan.buildScanId,
+      defaultPlan.splits);
+
+  const int32_t numGroups = randInt(1, probeScanSplits.size());
+  const std::vector<exec::Split> groupedProbeScanSplits =
+      generateSplitsWithGroup(
+          tableDir,
+          numGroups,
+          /*isProbe=*/true,
+          probeKeys.size(),
+          probeInput);
+  const std::vector<exec::Split> groupedBuildScanSplits =
+      generateSplitsWithGroup(
+          tableDir,
+          numGroups,
+          /*isProbe=*/false,
+          buildKeys.size(),
+          buildInput);
+
+  for (const auto& planWithTableScan : plansWithTableScan) {
+    altPlans.push_back(planWithTableScan);
+    altPlans.push_back(makeGroupedExecutionPlanWithTableScan(
+        planWithTableScan,
+        numGroups,
+        groupedProbeScanSplits,
+        groupedBuildScanSplits));
+  }
+
+  // Add ungrouped MergeJoin with TableScan.
+  if (core::MergeJoinNode::isSupported(joinNode->joinType())) {
+    auto planWithSplits = makeMergeJoinPlanWithTableScan(
+        joinType,
+        probeType,
+        buildType,
+        probeKeys,
+        buildKeys,
+        probeScanSplits,
+        buildScanSplits,
+        outputColumns);
+    altPlans.push_back(planWithSplits);
+
+    addFlippedJoinPlan<core::MergeJoinNode>(
+        planWithSplits.plan,
+        altPlans,
+        planWithSplits.probeScanId,
+        planWithSplits.buildScanId,
+        {{planWithSplits.probeScanId, probeScanSplits},
+         {planWithSplits.buildScanId, buildScanSplits}});
+  }
+
+  // Add ungrouped NestedLoopJoin with TableScan.
+  if (core::NestedLoopJoinNode::isSupported(joinNode->joinType())) {
+    auto planWithSplits = makeNestedLoopJoinPlanWithTableScan(
+        joinType,
+        probeType,
+        buildType,
+        probeKeys,
+        buildKeys,
+        probeScanSplits,
+        buildScanSplits,
+        outputColumns);
+    altPlans.push_back(planWithSplits);
+
+    addFlippedJoinPlan<core::NestedLoopJoinNode>(
+        planWithSplits.plan,
+        altPlans,
+        planWithSplits.probeScanId,
+        planWithSplits.buildScanId,
+        {{planWithSplits.probeScanId, probeScanSplits},
+         {planWithSplits.buildScanId, buildScanSplits}});
+  }
+}
+
+std::vector<exec::Split> JoinFuzzer::generateSplitsWithGroup(
+    const std::string& tableDir,
+    int32_t numGroups,
+    bool isProbe,
+    size_t numKeys,
+    const std::vector<RowVectorPtr>& input) {
+  const std::vector<std::vector<RowVectorPtr>> inputVectorsByGroup =
+      splitInputByGroup(numGroups, numKeys, input);
+
+  std::vector<exec::Split> splitsWithGroup;
+  for (int32_t groupId = 0; groupId < numGroups; ++groupId) {
+    for (auto i = 0; i < inputVectorsByGroup[groupId].size(); ++i) {
+      const std::string filePath = fmt::format(
+          "{}/grouped[{}].{}.{}",
+          tableDir,
+          groupId,
+          isProbe ? "probe" : "build",
+          i);
+      writeToFile(filePath, inputVectorsByGroup[groupId][i], writerPool_.get());
+      splitsWithGroup.emplace_back(makeConnectorSplit(filePath), groupId);
+    }
+    splitsWithGroup.emplace_back(nullptr, groupId);
+  }
+  return splitsWithGroup;
+}
+
+std::vector<std::vector<RowVectorPtr>> JoinFuzzer::splitInputByGroup(
+    int32_t numGroups,
+    size_t numKeys,
+    const std::vector<RowVectorPtr>& inputs) {
+  if (numGroups == 1) {
+    return {inputs};
+  }
+
+  // Partition 'input' based on the join keys for group execution with one
+  // partition per each group.
+  const RowTypePtr& inputType = asRowType(inputs[0]->type());
+  std::vector<column_index_t> partitionChannels(numKeys);
+  std::iota(partitionChannels.begin(), partitionChannels.end(), 0);
+  std::vector<std::unique_ptr<exec::VectorHasher>> hashers;
+  hashers.reserve(numKeys);
+  for (auto channel : partitionChannels) {
+    hashers.emplace_back(
+        exec::VectorHasher::create(inputType->childAt(channel), channel));
+  }
+
+  std::vector<std::vector<RowVectorPtr>> inputsByGroup{
+      static_cast<size_t>(numGroups)};
+  raw_vector<uint64_t> groupHashes;
+  std::vector<BufferPtr> groupRows(numGroups);
+  std::vector<vector_size_t*> rawGroupRows(numGroups);
+  std::vector<vector_size_t> groupSizes(numGroups, 0);
+  SelectivityVector inputRows;
+
+  for (const auto& input : inputs) {
+    const int numRows = input->size();
+    inputRows.resize(numRows);
+    inputRows.setAll();
+    groupHashes.resize(numRows);
+    std::fill(groupSizes.begin(), groupSizes.end(), 0);
+    std::fill(groupHashes.begin(), groupHashes.end(), 0);
+
+    for (auto i = 0; i < hashers.size(); ++i) {
+      auto& hasher = hashers[i];
+      auto* keyVector = input->childAt(hashers[i]->channel())->loadedVector();
+      hashers[i]->decode(*keyVector, inputRows);
+      if (hasher->channel() != kConstantChannel) {
+        hashers[i]->hash(inputRows, i > 0, groupHashes);
+      } else {
+        hashers[i]->hashPrecomputed(inputRows, i > 0, groupHashes);
+      }
+    }
+
+    for (int row = 0; row < numRows; ++row) {
+      const int32_t groupId = groupHashes[row] % numGroups;
+      if (groupRows[groupId] == nullptr ||
+          (groupRows[groupId]->capacity() < numRows * sizeof(vector_size_t))) {
+        groupRows[groupId] = allocateIndices(numRows, pool_.get());
+        rawGroupRows[groupId] = groupRows[groupId]->asMutable<vector_size_t>();
+      }
+      rawGroupRows[groupId][groupSizes[groupId]++] = row;
+    }
+
+    for (int32_t groupId = 0; groupId < numGroups; ++groupId) {
+      const size_t groupSize = groupSizes[groupId];
+      if (groupSize != 0) {
+        VELOX_CHECK_NOT_NULL(groupRows[groupId]);
+        groupRows[groupId]->setSize(
+            groupSizes[groupId] * sizeof(vector_size_t));
+        inputsByGroup[groupId].push_back(
+            (groupSize == numRows)
+                ? input
+                : exec::wrap(groupSize, std::move(groupRows[groupId]), input));
+      }
+    }
+  }
+  return inputsByGroup;
+}
+
+void JoinFuzzer::go() {
+  VELOX_USER_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+  VELOX_USER_CHECK_GE(FLAGS_batch_size, 10, "Batch size must be at least 10.");
+
+  const auto startTime = std::chrono::system_clock::now();
+
+  while (!isDone(stats_.numIterations, startTime)) {
+    LOG(WARNING) << "==============================> Started iteration "
+                 << stats_.numIterations << " (seed: " << currentSeed_ << ")";
+
+    // Pick join type.
+    const auto joinType = pickJoinType();
+
+    verify(joinType);
+
+    LOG(WARNING) << "==============================> Done with iteration "
+                 << stats_.numIterations;
+
+    reSeed();
+    ++stats_.numIterations;
+  }
+  LOG(INFO) << stats_.toString();
+}
+
+} // namespace
+
+void joinFuzzer(
+    size_t seed,
+    std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner) {
+  JoinFuzzer(seed, std::move(referenceQueryRunner)).go();
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/JoinFuzzer.h b/velox/exec/fuzzer/JoinFuzzer.h
similarity index 82%
rename from velox/exec/tests/JoinFuzzer.h
rename to velox/exec/fuzzer/JoinFuzzer.h
index 578522d627c71..01a5085d3876b 100644
--- a/velox/exec/tests/JoinFuzzer.h
+++ b/velox/exec/fuzzer/JoinFuzzer.h
@@ -16,7 +16,10 @@
 #pragma once
 
 #include <cstddef>
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 
 namespace facebook::velox::exec::test {
-void joinFuzzer(size_t seed);
+void joinFuzzer(
+    size_t seed,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
 }
diff --git a/velox/exec/fuzzer/JoinFuzzerRunner.h b/velox/exec/fuzzer/JoinFuzzerRunner.h
new file mode 100644
index 0000000000000..195aab5b292a8
--- /dev/null
+++ b/velox/exec/fuzzer/JoinFuzzerRunner.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/exec/MemoryReclaimer.h"
+#include "velox/exec/fuzzer/JoinFuzzer.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+/// Join FuzzerRunner leverages JoinFuzzer and VectorFuzzer to
+/// automatically generate and execute join tests. It works by:
+///
+///  1. Picking a random join type.
+///  2. Generating a random set of input data (vector), with a variety of
+///     encodings and data layouts.
+///  3. Executing a variety of logically equivalent query plans and
+///     asserting results are the same.
+///  4. Rinse and repeat.
+///
+/// The common usage pattern is as following:
+///
+///  $ ./velox_join_fuzzer_test --steps 10000
+///
+/// The important flags that control JoinFuzzer's behavior are:
+///
+///  --steps: how many iterations to run.
+///  --duration_sec: alternatively, for how many seconds it should run (takes
+///          precedence over --steps).
+///  --seed: pass a deterministic seed to reproduce the behavior (each iteration
+///          will print a seed as part of the logs).
+///  --v=1: verbose logging; print a lot more details about the execution.
+///  --batch_size: size of input vector batches generated.
+///  --num_batches: number if input vector batches to generate.
+///
+/// e.g:
+///
+///  $ ./velox_join_fuzzer_test \
+///         --steps 10000 \
+///         --seed 123 \
+///         --v=1
+
+namespace facebook::velox::exec::test {
+
+class JoinFuzzerRunner {
+ public:
+  static int run(
+      size_t seed,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
+    serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    filesystems::registerLocalFileSystem();
+    functions::prestosql::registerAllScalarFunctions();
+    parse::registerTypeResolver();
+    joinFuzzer(seed, std::move(referenceQueryRunner));
+    return RUN_ALL_TESTS();
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp b/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp
new file mode 100644
index 0000000000000..ec8df7f45f344
--- /dev/null
+++ b/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp
@@ -0,0 +1,771 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/MemoryArbitrationFuzzer.h"
+
+#include <boost/random/uniform_int_distribution.hpp>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/exec/MemoryReclaimer.h"
+#include "velox/exec/TableWriter.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/functions/lib/aggregates/AverageAggregateBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int32(steps, 10, "Number of test iterations.");
+
+DEFINE_int32(
+    duration_sec,
+    0,
+    "For how long it should run (in seconds). If zero, "
+    "it executes exactly --steps iterations and exits.");
+
+DEFINE_int32(
+    iteration_duration_sec,
+    10,
+    "For how long it should run (in seconds) per iteration.");
+
+DEFINE_int32(
+    batch_size,
+    100,
+    "The number of elements on each generated vector.");
+
+DEFINE_int32(num_batches, 32, "The number of generated vectors.");
+
+DEFINE_double(
+    null_ratio,
+    0.2,
+    "Chance of adding a null value in a vector "
+    "(expressed as double from 0 to 1).");
+
+DEFINE_int32(
+    num_threads,
+    72,
+    "The number of threads to run queries concurrently for each iteration.");
+
+DEFINE_int64(arbitrator_capacity, 256L << 20, "Arbitrator capacity in bytes.");
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class MemoryArbitrationFuzzer {
+ public:
+  explicit MemoryArbitrationFuzzer(size_t initialSeed);
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    std::unordered_map<core::PlanNodeId, std::vector<Split>> splits;
+
+    PlanWithSplits(
+        core::PlanNodePtr _plan,
+        const std::unordered_map<core::PlanNodeId, std::vector<Split>>& _splits)
+        : plan(std::move(_plan)), splits(_splits) {}
+  };
+
+  struct Stats {
+    size_t successCount{0};
+    size_t failureCount{0};
+    size_t oomCount{0};
+    size_t abortCount{0};
+
+    void print() const {
+      std::stringstream ss;
+      ss << "Success count = " << successCount
+         << ", failure count = " << failureCount
+         << ". OOM count  = " << oomCount << " Abort count = " << abortCount;
+      LOG(INFO) << ss.str();
+    }
+  };
+
+  void go();
+
+ private:
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    vectorFuzzer_.reSeed(seed);
+    rng_.seed(currentSeed_);
+  }
+
+  void reSeed() {
+    seed(rng_());
+  }
+
+  int32_t randInt(int32_t min, int32_t max) {
+    return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
+  }
+
+  // Returns a list of randomly generated key types for join and aggregation.
+  std::vector<TypePtr> generateKeyTypes(int32_t numKeys);
+
+  std::pair<std::vector<std::string>, std::vector<TypePtr>>
+  generatePartitionKeys();
+
+  // Returns randomly generated input with up to 3 additional payload columns.
+  std::vector<RowVectorPtr> generateInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
+  // Reuses the 'generateInput' method to return randomly generated
+  // probe input.
+  std::vector<RowVectorPtr> generateProbeInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
+  // Reuses the 'generateInput' method to return randomly generated
+  // aggregation input.
+  std::vector<RowVectorPtr> generateAggregateInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
+  // Reuses the 'generateInput' method to return randomly generated
+  // row number input.
+  std::vector<RowVectorPtr> generateRowNumberInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
+  // Reuses the 'generateInput' method to return randomly generated
+  // order by input.
+  std::vector<RowVectorPtr> generateOrderByInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
+  // Same as generateProbeInput() but copies over 10% of the input in the probe
+  // columns to ensure some matches during joining. Also generates an empty
+  // input with a 10% chance.
+  std::vector<RowVectorPtr> generateBuildInput(
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys);
+
+  static std::vector<PlanWithSplits> hashJoinPlans(
+      const core::JoinType& joinType,
+      const std::vector<std::string>& probeKeys,
+      const std::vector<std::string>& buildKeys,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const std::vector<Split>& probeSplits,
+      const std::vector<Split>& buildSplits);
+
+  std::vector<PlanWithSplits> hashJoinPlans(const std::string& tableDir);
+
+  std::vector<PlanWithSplits> aggregatePlans(const std::string& tableDir);
+
+  std::vector<PlanWithSplits> rowNumberPlans(const std::string& tableDir);
+
+  std::vector<PlanWithSplits> orderByPlans(const std::string& tableDir);
+
+  void verify();
+
+  static VectorFuzzer::Options getFuzzerOptions() {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = FLAGS_batch_size;
+    opts.stringVariableLength = true;
+    opts.stringLength = 100;
+    opts.nullRatio = FLAGS_null_ratio;
+    return opts;
+  }
+
+  FuzzerGenerator rng_;
+  size_t currentSeed_{0};
+  std::unordered_map<std::string, std::string> queryConfigsWithSpill_{
+      {core::QueryConfig::kSpillEnabled, "true"},
+      {core::QueryConfig::kJoinSpillEnabled, "true"},
+      {core::QueryConfig::kSpillStartPartitionBit, "29"},
+      {core::QueryConfig::kAggregationSpillEnabled, "true"},
+      {core::QueryConfig::kRowNumberSpillEnabled, "true"},
+      {core::QueryConfig::kOrderBySpillEnabled, "true"},
+  };
+
+  std::shared_ptr<memory::MemoryPool> rootPool_{
+      memory::memoryManager()->addRootPool(
+          "memoryArbitrationFuzzer",
+          memory::kMaxMemory,
+          memory::MemoryReclaimer::create())};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->testingDefaultRoot().addLeafChild(
+          "memoryArbitrationFuzzerLeaf",
+          true)};
+  std::shared_ptr<memory::MemoryPool> writerPool_{rootPool_->addAggregateChild(
+      "joinFuzzerWriter",
+      exec::MemoryReclaimer::create())};
+
+  VectorFuzzer vectorFuzzer_;
+  std::shared_ptr<folly::Executor> executor_{
+      std::make_shared<folly::CPUThreadPoolExecutor>(
+          std::thread::hardware_concurrency())};
+  folly::Synchronized<Stats> stats_;
+};
+
+MemoryArbitrationFuzzer::MemoryArbitrationFuzzer(size_t initialSeed)
+    : vectorFuzzer_{getFuzzerOptions(), pool_.get()} {
+  // Make sure not to run out of open file descriptors.
+  std::unordered_map<std::string, std::string> hiveConfig = {
+      {connector::hive::HiveConfig::kNumCacheFileHandles, "1000"}};
+  const auto hiveConnector =
+      connector::getConnectorFactory(
+          connector::hive::HiveConnectorFactory::kHiveConnectorName)
+          ->newConnector(
+              kHiveConnectorId,
+              std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
+  connector::registerConnector(hiveConnector);
+  seed(initialSeed);
+}
+
+template <typename T>
+bool isDone(size_t i, T startTime) {
+  if (FLAGS_duration_sec > 0) {
+    const std::chrono::duration<double> elapsed =
+        std::chrono::system_clock::now() - startTime;
+    return elapsed.count() >= FLAGS_duration_sec;
+  }
+  return i >= FLAGS_steps;
+}
+
+std::vector<TypePtr> MemoryArbitrationFuzzer::generateKeyTypes(
+    int32_t numKeys) {
+  std::vector<TypePtr> types;
+  types.reserve(numKeys);
+  for (auto i = 0; i < numKeys; ++i) {
+    // Pick random scalar type.
+    types.push_back(vectorFuzzer_.randType(0 /*maxDepth*/));
+  }
+  return types;
+}
+
+std::pair<std::vector<std::string>, std::vector<TypePtr>>
+MemoryArbitrationFuzzer::generatePartitionKeys() {
+  const auto numKeys = randInt(1, 3);
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  for (auto i = 0; i < numKeys; ++i) {
+    names.push_back(fmt::format("c{}", i));
+    types.push_back(vectorFuzzer_.randType(/*maxDepth=*/1));
+  }
+  return std::make_pair(names, types);
+}
+
+std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  std::vector<std::string> names = keyNames;
+  std::vector<TypePtr> types = keyTypes;
+
+  bool keyTypesAllBool = true;
+  for (const auto& type : keyTypes) {
+    if (!type->isBoolean()) {
+      keyTypesAllBool = false;
+      break;
+    }
+  }
+
+  // Add up to 3 payload columns.
+  const auto numPayload = randInt(0, 3);
+  for (auto i = 0; i < numPayload; ++i) {
+    names.push_back(fmt::format("tp{}", i + keyNames.size()));
+    types.push_back(vectorFuzzer_.randType(2 /*maxDepth*/));
+  }
+
+  const auto inputType = ROW(std::move(names), std::move(types));
+  std::vector<RowVectorPtr> input;
+  for (auto i = 0; i < FLAGS_num_batches; ++i) {
+    if (keyTypesAllBool) {
+      // Joining on just boolean keys creates so many hits it explodes the
+      // output size, reduce the batch size to 10% to control the output size
+      // while still covering this case.
+      input.push_back(
+          vectorFuzzer_.fuzzRow(inputType, FLAGS_batch_size / 10, false));
+    } else {
+      input.push_back(vectorFuzzer_.fuzzInputRow(inputType));
+    }
+  }
+  return input;
+}
+
+std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateProbeInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  return generateInput(keyNames, keyTypes);
+}
+
+std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateBuildInput(
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys) {
+  std::vector<std::string> names = buildKeys;
+  std::vector<TypePtr> types;
+  for (const auto& key : probeKeys) {
+    types.push_back(asRowType(probeInput[0]->type())->findChild(key));
+  }
+
+  // Add up to 3 payload columns.
+  const auto numPayload = randInt(0, 3);
+  for (auto i = 0; i < numPayload; ++i) {
+    names.push_back(fmt::format("bp{}", i + buildKeys.size()));
+    types.push_back(vectorFuzzer_.randType(2 /*maxDepth*/));
+  }
+
+  const auto rowType = ROW(std::move(names), std::move(types));
+
+  // 1 in 10 times use empty build.
+  if (vectorFuzzer_.coinToss(0.1)) {
+    return {BaseVector::create<RowVector>(rowType, 0, pool_.get())};
+  }
+
+  // To ensure there are some matches, sample with replacement 10% of probe join
+  // keys and use these as build keys.
+  std::vector<RowVectorPtr> input;
+  for (const auto& probe : probeInput) {
+    const auto numRows = 1 + probe->size() / 10;
+    auto build = BaseVector::create<RowVector>(rowType, numRows, probe->pool());
+
+    // Pick probe side rows to copy.
+    std::vector<vector_size_t> rowNumbers(numRows);
+    for (auto i = 0; i < numRows; ++i) {
+      rowNumbers[i] = randInt(0, probe->size() - 1);
+    }
+
+    SelectivityVector rows(numRows);
+    for (auto i = 0; i < probeKeys.size(); ++i) {
+      build->childAt(i)->resize(numRows);
+      build->childAt(i)->copy(probe->childAt(i).get(), rows, rowNumbers.data());
+    }
+
+    for (auto i = 0; i < numPayload; ++i) {
+      const auto column = i + probeKeys.size();
+      build->childAt(column) =
+          vectorFuzzer_.fuzz(rowType->childAt(column), numRows);
+    }
+
+    input.push_back(build);
+  }
+
+  return input;
+}
+
+std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateAggregateInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  return generateInput(keyNames, keyTypes);
+}
+
+std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateRowNumberInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  return generateInput(keyNames, keyTypes);
+}
+
+std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateOrderByInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  return generateInput(keyNames, keyTypes);
+}
+
+std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
+MemoryArbitrationFuzzer::hashJoinPlans(
+    const core::JoinType& joinType,
+    const std::vector<std::string>& probeKeys,
+    const std::vector<std::string>& buildKeys,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    const std::vector<Split>& probeSplits,
+    const std::vector<Split>& buildSplits) {
+  auto outputColumns =
+      (core::isLeftSemiProjectJoin(joinType) ||
+       core::isLeftSemiFilterJoin(joinType) || core::isAntiJoin(joinType))
+      ? asRowType(probeInput[0]->type())->names()
+      : concat(
+            asRowType(probeInput[0]->type()), asRowType(buildInput[0]->type()))
+            ->names();
+
+  if (core::isLeftSemiProjectJoin(joinType) ||
+      core::isRightSemiProjectJoin(joinType)) {
+    outputColumns.emplace_back("match");
+  }
+
+  std::vector<PlanWithSplits> plans;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(probeInput)
+          .hashJoin(
+              probeKeys,
+              buildKeys,
+              PlanBuilder(planNodeIdGenerator).values(buildInput).planNode(),
+              /*filter=*/"",
+              outputColumns,
+              joinType,
+              false)
+          .planNode();
+  plans.push_back(PlanWithSplits{std::move(plan), {}});
+
+  if (!isTableScanSupported(probeInput[0]->type()) ||
+      !isTableScanSupported(buildInput[0]->type())) {
+    return plans;
+  }
+
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto probeType = asRowType(probeInput[0]->type());
+  const auto buildType = asRowType(buildInput[0]->type());
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId buildScanId;
+  plan = PlanBuilder(planNodeIdGenerator)
+             .tableScan(probeType)
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 probeKeys,
+                 buildKeys,
+                 PlanBuilder(planNodeIdGenerator)
+                     .tableScan(buildType)
+                     .capturePlanNodeId(buildScanId)
+                     .planNode(),
+                 /*filter=*/"",
+                 outputColumns,
+                 joinType,
+                 false)
+             .planNode();
+  plans.push_back(PlanWithSplits{
+      std::move(plan),
+      {{probeScanId, probeSplits}, {buildScanId, buildSplits}}});
+  return plans;
+}
+
+std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
+MemoryArbitrationFuzzer::hashJoinPlans(const std::string& tableDir) {
+  static const std::vector<core::JoinType> kJoinTypes = {
+      core::JoinType::kInner,
+      core::JoinType::kLeft,
+      core::JoinType::kFull,
+      core::JoinType::kLeftSemiFilter,
+      core::JoinType::kLeftSemiProject,
+      core::JoinType::kAnti};
+
+  const auto numKeys = randInt(1, 5);
+  const std::vector<TypePtr> keyTypes = generateKeyTypes(numKeys);
+  std::vector<std::string> probeKeys = makeNames("t", keyTypes.size());
+  std::vector<std::string> buildKeys = makeNames("u", keyTypes.size());
+  const auto probeInput = generateProbeInput(probeKeys, keyTypes);
+  const auto buildInput = generateBuildInput(probeInput, probeKeys, buildKeys);
+  const std::vector<Split> probeScanSplits =
+      makeSplits(probeInput, fmt::format("{}/probe", tableDir), writerPool_);
+  const std::vector<Split> buildScanSplits =
+      makeSplits(buildInput, fmt::format("{}/build", tableDir), writerPool_);
+
+  std::vector<PlanWithSplits> totalPlans;
+  for (const auto& joinType : kJoinTypes) {
+    auto plans = hashJoinPlans(
+        joinType,
+        probeKeys,
+        buildKeys,
+        probeInput,
+        buildInput,
+        probeScanSplits,
+        buildScanSplits);
+    totalPlans.insert(
+        totalPlans.end(),
+        std::make_move_iterator(plans.begin()),
+        std::make_move_iterator(plans.end()));
+  }
+  return totalPlans;
+}
+
+std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
+MemoryArbitrationFuzzer::aggregatePlans(const std::string& tableDir) {
+  const auto numKeys = randInt(1, 5);
+  // Reuse the hash join utilities to generate aggregation keys and inputs.
+  const std::vector<TypePtr> keyTypes = generateKeyTypes(numKeys);
+  const std::vector<std::string> groupingKeys = makeNames("g", keyTypes.size());
+  const auto aggregateInput = generateAggregateInput(groupingKeys, keyTypes);
+  const std::vector<std::string> aggregates{"count(1)"};
+  const std::vector<Split> splits = makeSplits(
+      aggregateInput, fmt::format("{}/aggregate", tableDir), writerPool_);
+
+  std::vector<PlanWithSplits> plans;
+  const auto inputRowType = asRowType(aggregateInput[0]->type());
+  {
+    // Single final aggregation plan.
+    const auto planNodeIdGenerator =
+        std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+    auto plan = PlanWithSplits{
+        PlanBuilder(planNodeIdGenerator)
+            .tableScan(inputRowType)
+            .capturePlanNodeId(scanId)
+            .singleAggregation(groupingKeys, aggregates, {})
+            .planNode(),
+        {{scanId, splits}}};
+    plans.push_back(std::move(plan));
+
+    plan = PlanWithSplits{
+        PlanBuilder()
+            .values(aggregateInput)
+            .singleAggregation(groupingKeys, aggregates, {})
+            .planNode(),
+        {}};
+    plans.push_back(std::move(plan));
+  }
+
+  {
+    // Partial -> final aggregation plan.
+    const auto planNodeIdGenerator =
+        std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+    auto plan = PlanWithSplits{
+        PlanBuilder(planNodeIdGenerator)
+            .tableScan(inputRowType)
+            .capturePlanNodeId(scanId)
+            .partialAggregation(groupingKeys, aggregates, {})
+            .finalAggregation()
+            .planNode(),
+        {{scanId, splits}}};
+    plans.push_back(std::move(plan));
+
+    plan = PlanWithSplits{
+        PlanBuilder()
+            .values(aggregateInput)
+            .partialAggregation(groupingKeys, aggregates, {})
+            .finalAggregation()
+            .planNode(),
+        {}};
+    plans.push_back(std::move(plan));
+  }
+
+  {
+    // Partial -> intermediate -> final aggregation plan.
+    const auto planNodeIdGenerator =
+        std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+    auto plan = PlanWithSplits{
+        PlanBuilder(planNodeIdGenerator)
+            .tableScan(inputRowType)
+            .capturePlanNodeId(scanId)
+            .partialAggregation(groupingKeys, aggregates, {})
+            .intermediateAggregation()
+            .finalAggregation()
+            .planNode(),
+        {{scanId, splits}}};
+    plans.push_back(std::move(plan));
+
+    plan = PlanWithSplits{
+        PlanBuilder()
+            .values(aggregateInput)
+            .partialAggregation(groupingKeys, aggregates, {})
+            .intermediateAggregation()
+            .finalAggregation()
+            .planNode(),
+        {}};
+    plans.push_back(std::move(plan));
+  }
+
+  return plans;
+}
+
+std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
+MemoryArbitrationFuzzer::rowNumberPlans(const std::string& tableDir) {
+  const auto [keyNames, keyTypes] = generatePartitionKeys();
+  const auto input = generateRowNumberInput(keyNames, keyTypes);
+
+  std::vector<PlanWithSplits> plans;
+
+  std::vector<std::string> projectFields = keyNames;
+  projectFields.emplace_back("row_number");
+  auto plan = PlanWithSplits{
+      PlanBuilder()
+          .values(input)
+          .rowNumber(keyNames)
+          .project(projectFields)
+          .planNode(),
+      {}};
+  plans.push_back(std::move(plan));
+
+  if (!isTableScanSupported(input[0]->type())) {
+    return plans;
+  }
+
+  const std::vector<Split> splits =
+      makeSplits(input, fmt::format("{}/row_number", tableDir), writerPool_);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanId;
+  plan = PlanWithSplits{
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(asRowType(input[0]->type()))
+          .capturePlanNodeId(scanId)
+          .rowNumber(keyNames)
+          .project(projectFields)
+          .planNode(),
+      {{scanId, splits}}};
+  plans.push_back(std::move(plan));
+
+  return plans;
+}
+
+std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
+MemoryArbitrationFuzzer::orderByPlans(const std::string& tableDir) {
+  const auto [keyNames, keyTypes] = generatePartitionKeys();
+  const auto input = generateOrderByInput(keyNames, keyTypes);
+
+  std::vector<PlanWithSplits> plans;
+
+  auto plan = PlanWithSplits{
+      PlanBuilder().values(input).orderBy(keyNames, false).planNode(), {}};
+  plans.push_back(std::move(plan));
+
+  if (!isTableScanSupported(input[0]->type())) {
+    return plans;
+  }
+
+  const std::vector<Split> splits =
+      makeSplits(input, fmt::format("{}/order_by", tableDir), writerPool_);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanId;
+  plan = PlanWithSplits{
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(asRowType(input[0]->type()))
+          .capturePlanNodeId(scanId)
+          .orderBy(keyNames, false)
+          .planNode(),
+      {{scanId, splits}}};
+  plans.push_back(std::move(plan));
+
+  return plans;
+}
+
+void MemoryArbitrationFuzzer::verify() {
+  const auto outputDirectory = TempDirectoryPath::create();
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto tableScanDir = exec::test::TempDirectoryPath::create();
+
+  std::vector<PlanWithSplits> plans;
+  for (const auto& plan : hashJoinPlans(tableScanDir->getPath())) {
+    plans.push_back(plan);
+  }
+  for (const auto& plan : aggregatePlans(tableScanDir->getPath())) {
+    plans.push_back(plan);
+  }
+  for (const auto& plan : rowNumberPlans(tableScanDir->getPath())) {
+    plans.push_back(plan);
+  }
+  for (const auto& plan : orderByPlans(tableScanDir->getPath())) {
+    plans.push_back(plan);
+  }
+
+  SCOPE_EXIT {
+    waitForAllTasksToBeDeleted();
+  };
+
+  const auto numThreads = FLAGS_num_threads;
+  std::atomic_bool stop{false};
+  std::vector<std::thread> queryThreads;
+  queryThreads.reserve(numThreads);
+  for (int i = 0; i < numThreads; ++i) {
+    auto seed = rng_();
+    queryThreads.emplace_back([&, i, seed]() {
+      FuzzerGenerator rng(seed);
+      while (!stop) {
+        try {
+          const auto queryCtx = newQueryCtx(
+              memory::memoryManager(),
+              executor_.get(),
+              FLAGS_arbitrator_capacity);
+          const auto plan = plans.at(getRandomIndex(rng, plans.size() - 1));
+          AssertQueryBuilder builder(plan.plan);
+          builder.queryCtx(queryCtx);
+          for (const auto& [planNodeId, nodeSplits] : plan.splits) {
+            builder.splits(planNodeId, nodeSplits);
+          }
+
+          if (coinToss(rng, 0.3)) {
+            builder.queryCtx(queryCtx).copyResults(pool_.get());
+          } else {
+            auto res =
+                builder.configs(queryConfigsWithSpill_)
+                    .spillDirectory(
+                        spillDirectory->getPath() + fmt::format("/{}/", i))
+                    .queryCtx(queryCtx)
+                    .copyResults(pool_.get());
+          }
+          ++stats_.wlock()->successCount;
+        } catch (const VeloxException& e) {
+          auto lockedStats = stats_.wlock();
+          if (e.errorCode() == error_code::kMemCapExceeded.c_str()) {
+            ++lockedStats->oomCount;
+          } else if (e.errorCode() == error_code::kMemAborted.c_str()) {
+            ++lockedStats->abortCount;
+          } else {
+            ++lockedStats->failureCount;
+            std::rethrow_exception(std::current_exception());
+          }
+        }
+      }
+    });
+  }
+
+  std::this_thread::sleep_for(
+      std::chrono::seconds(FLAGS_iteration_duration_sec));
+  stop = true;
+
+  for (auto& queryThread : queryThreads) {
+    queryThread.join();
+  }
+}
+
+void MemoryArbitrationFuzzer::go() {
+  VELOX_USER_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+  VELOX_USER_CHECK_GE(FLAGS_batch_size, 10, "Batch size must be at least 10.");
+
+  const auto startTime = std::chrono::system_clock::now();
+  size_t iteration = 0;
+
+  bool enableGlobalArbitration = true;
+  while (!isDone(iteration, startTime)) {
+    LOG(WARNING) << "==============================> Started iteration "
+                 << iteration << " (seed: " << currentSeed_ << ")";
+
+    // Test enable/disable global arbitration.
+    dynamic_cast<memory::SharedArbitrator*>(
+        memory::memoryManager()->arbitrator())
+        ->testingSetGlobalArbitration(enableGlobalArbitration);
+
+    verify();
+
+    LOG(INFO) << "==============================> Done with iteration "
+              << iteration;
+    stats_.rlock()->print();
+
+    reSeed();
+    ++iteration;
+    // Revert the flag.
+    enableGlobalArbitration = !enableGlobalArbitration;
+  }
+}
+
+} // namespace
+
+void memoryArbitrationFuzzer(size_t seed) {
+  MemoryArbitrationFuzzer(seed).go();
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/MemoryArbitrationFuzzer.h b/velox/exec/fuzzer/MemoryArbitrationFuzzer.h
new file mode 100644
index 0000000000000..73f32e2215d0a
--- /dev/null
+++ b/velox/exec/fuzzer/MemoryArbitrationFuzzer.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstddef>
+
+namespace facebook::velox::exec::test {
+void memoryArbitrationFuzzer(size_t seed);
+}
diff --git a/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.h b/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.h
new file mode 100644
index 0000000000000..05961bfb625a9
--- /dev/null
+++ b/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include "velox/common/file/FileSystems.h"
+
+#include "velox/exec/fuzzer/MemoryArbitrationFuzzer.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+namespace facebook::velox::exec::test {
+
+class MemoryArbitrationFuzzerRunner {
+ public:
+  static int run(size_t seed) {
+    serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    filesystems::registerLocalFileSystem();
+    functions::prestosql::registerAllScalarFunctions();
+    aggregate::prestosql::registerAllAggregateFunctions();
+    memoryArbitrationFuzzer(seed);
+    return RUN_ALL_TESTS();
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/PrestoQueryRunner.cpp b/velox/exec/fuzzer/PrestoQueryRunner.cpp
new file mode 100644
index 0000000000000..4aa20ca8c4a9c
--- /dev/null
+++ b/velox/exec/fuzzer/PrestoQueryRunner.cpp
@@ -0,0 +1,859 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include <cpr/cpr.h> // @manual
+#include <folly/json.h>
+#include <velox/dwio/dwrf/writer/Writer.h>
+#include <iostream>
+#include "velox/common/base/Fs.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveDataSink.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/core/Expressions.h"
+#include "velox/dwio/common/WriterFactory.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/ToSQLUtil.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/type/parser/TypeParser.h"
+
+#include <utility>
+
+using namespace facebook::velox;
+
+namespace facebook::velox::exec::test {
+namespace {
+
+void writeToFile(
+    const std::string& path,
+    const std::vector<RowVectorPtr>& data,
+    memory::MemoryPool* pool) {
+  VELOX_CHECK_GT(data.size(), 0);
+
+  std::shared_ptr<dwio::common::WriterOptions> options =
+      std::make_shared<dwrf::WriterOptions>();
+  options->schema = data[0]->type();
+  options->memoryPool = pool;
+
+  auto writeFile = std::make_unique<LocalWriteFile>(path, true, false);
+  auto sink =
+      std::make_unique<dwio::common::WriteFileSink>(std::move(writeFile), path);
+  auto writer = dwio::common::getWriterFactory(dwio::common::FileFormat::DWRF)
+                    ->createWriter(std::move(sink), options);
+  for (const auto& vector : data) {
+    writer->write(vector);
+  }
+  writer->close();
+}
+
+std::unique_ptr<ByteInputStream> toByteStream(const std::string& input) {
+  std::vector<ByteRange> ranges;
+  ranges.push_back(
+      {reinterpret_cast<uint8_t*>(const_cast<char*>(input.data())),
+       (int32_t)input.length(),
+       0});
+  return std::make_unique<BufferInputStream>(std::move(ranges));
+}
+
+RowVectorPtr deserialize(
+    const RowTypePtr& rowType,
+    const std::string& input,
+    memory::MemoryPool* pool) {
+  auto byteStream = toByteStream(input);
+  auto serde = std::make_unique<serializer::presto::PrestoVectorSerde>();
+  RowVectorPtr result;
+  serde->deserialize(byteStream.get(), pool, rowType, &result, nullptr);
+  return result;
+}
+
+class ServerResponse {
+ public:
+  explicit ServerResponse(const std::string& responseJson)
+      : response_(folly::parseJson(responseJson)) {}
+
+  void throwIfFailed() const {
+    if (response_.count("error") == 0) {
+      return;
+    }
+
+    const auto& error = response_["error"];
+
+    VELOX_FAIL(
+        "Presto query failed: {} {}",
+        error["errorCode"].asInt(),
+        error["message"].asString());
+  }
+
+  std::string queryId() const {
+    return response_["id"].asString();
+  }
+
+  bool queryCompleted() const {
+    return response_.count("nextUri") == 0;
+  }
+
+  std::string nextUri() const {
+    return response_["nextUri"].asString();
+  }
+
+  std::vector<RowVectorPtr> queryResults(memory::MemoryPool* pool) const {
+    if (!response_.count("binaryData")) {
+      return {};
+    }
+
+    std::vector<std::string> names;
+    std::vector<TypePtr> types;
+    for (const auto& column : response_["columns"]) {
+      names.push_back(column["name"].asString());
+      types.push_back(parseType(column["type"].asString()));
+    }
+
+    auto rowType = ROW(std::move(names), std::move(types));
+
+    // There should be a single column with possibly multiple rows. Each row
+    // contains base64-encoded PrestoPage of results.
+
+    std::vector<RowVectorPtr> vectors;
+    for (auto& encodedData : response_["binaryData"]) {
+      const std::string data =
+          encoding::Base64::decode(encodedData.stringPiece());
+      vectors.push_back(deserialize(rowType, data, pool));
+    }
+    return vectors;
+  }
+
+ private:
+  folly::dynamic response_;
+};
+
+} // namespace
+
+PrestoQueryRunner::PrestoQueryRunner(
+    memory::MemoryPool* pool,
+    std::string coordinatorUri,
+    std::string user,
+    std::chrono::milliseconds timeout)
+    : ReferenceQueryRunner(pool),
+      coordinatorUri_{std::move(coordinatorUri)},
+      user_{std::move(user)},
+      timeout_(timeout) {
+  eventBaseThread_.start("PrestoQueryRunner");
+  pool_ = aggregatePool()->addLeafChild("leaf");
+}
+
+std::optional<std::string> PrestoQueryRunner::toSql(
+    const core::PlanNodePtr& plan) {
+  if (const auto projectNode =
+          std::dynamic_pointer_cast<const core::ProjectNode>(plan)) {
+    return toSql(projectNode);
+  }
+
+  if (const auto windowNode =
+          std::dynamic_pointer_cast<const core::WindowNode>(plan)) {
+    return toSql(windowNode);
+  }
+
+  if (const auto aggregationNode =
+          std::dynamic_pointer_cast<const core::AggregationNode>(plan)) {
+    return toSql(aggregationNode);
+  }
+
+  if (const auto rowNumberNode =
+          std::dynamic_pointer_cast<const core::RowNumberNode>(plan)) {
+    return toSql(rowNumberNode);
+  }
+
+  if (auto tableWriteNode =
+          std::dynamic_pointer_cast<const core::TableWriteNode>(plan)) {
+    return toSql(tableWriteNode);
+  }
+
+  if (const auto joinNode =
+          std::dynamic_pointer_cast<const core::HashJoinNode>(plan)) {
+    return toSql(joinNode);
+  }
+
+  if (const auto joinNode =
+          std::dynamic_pointer_cast<const core::NestedLoopJoinNode>(plan)) {
+    return toSql(joinNode);
+  }
+
+  VELOX_NYI();
+}
+
+namespace {
+
+std::string toTypeSql(const TypePtr& type) {
+  switch (type->kind()) {
+    case TypeKind::ARRAY:
+      return fmt::format("array({})", toTypeSql(type->childAt(0)));
+    case TypeKind::MAP:
+      return fmt::format(
+          "map({}, {})",
+          toTypeSql(type->childAt(0)),
+          toTypeSql(type->childAt(1)));
+    case TypeKind::ROW: {
+      const auto& rowType = type->asRow();
+      std::stringstream sql;
+      sql << "row(";
+      for (auto i = 0; i < type->size(); ++i) {
+        appendComma(i, sql);
+        sql << rowType.nameOf(i) << " ";
+        sql << toTypeSql(type->childAt(i));
+      }
+      sql << ")";
+      return sql.str();
+    }
+    default:
+      if (type->isPrimitiveType()) {
+        return type->toString();
+      }
+      VELOX_UNSUPPORTED("Type is not supported: {}", type->toString());
+  }
+}
+
+std::string toWindowCallSql(
+    const core::CallTypedExprPtr& call,
+    bool ignoreNulls = false) {
+  std::stringstream sql;
+  sql << call->name() << "(";
+  toCallInputsSql(call->inputs(), sql);
+  sql << ")";
+  if (ignoreNulls) {
+    sql << " IGNORE NULLS";
+  }
+  return sql.str();
+}
+
+bool isSupportedDwrfType(const TypePtr& type) {
+  if (type->isDate() || type->isIntervalDayTime() || type->isUnKnown()) {
+    return false;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (!isSupportedDwrfType(type->childAt(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+} // namespace
+
+const std::vector<TypePtr>& PrestoQueryRunner::supportedScalarTypes() const {
+  static const std::vector<TypePtr> kScalarTypes{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      REAL(),
+      DOUBLE(),
+      VARCHAR(),
+      VARBINARY(),
+      TIMESTAMP(),
+  };
+  return kScalarTypes;
+}
+
+std::optional<std::string> PrestoQueryRunner::toSql(
+    const std::shared_ptr<const core::AggregationNode>& aggregationNode) {
+  // Assume plan is Aggregation over Values.
+  VELOX_CHECK(aggregationNode->step() == core::AggregationNode::Step::kSingle);
+
+  if (!isSupportedDwrfType(aggregationNode->sources()[0]->outputType())) {
+    return std::nullopt;
+  }
+
+  std::vector<std::string> groupingKeys;
+  for (const auto& key : aggregationNode->groupingKeys()) {
+    groupingKeys.push_back(key->name());
+  }
+
+  std::stringstream sql;
+  sql << "SELECT " << folly::join(", ", groupingKeys);
+
+  const auto& aggregates = aggregationNode->aggregates();
+  if (!aggregates.empty()) {
+    if (!groupingKeys.empty()) {
+      sql << ", ";
+    }
+
+    for (auto i = 0; i < aggregates.size(); ++i) {
+      appendComma(i, sql);
+      const auto& aggregate = aggregates[i];
+      sql << toAggregateCallSql(
+          aggregate.call,
+          aggregate.sortingKeys,
+          aggregate.sortingOrders,
+          aggregate.distinct);
+
+      if (aggregate.mask != nullptr) {
+        sql << " filter (where " << aggregate.mask->name() << ")";
+      }
+      sql << " as " << aggregationNode->aggregateNames()[i];
+    }
+  }
+
+  sql << " FROM tmp";
+
+  if (!groupingKeys.empty()) {
+    sql << " GROUP BY " << folly::join(", ", groupingKeys);
+  }
+
+  return sql.str();
+}
+
+std::optional<std::string> PrestoQueryRunner::toSql(
+    const std::shared_ptr<const core::ProjectNode>& projectNode) {
+  auto sourceSql = toSql(projectNode->sources()[0]);
+  if (!sourceSql.has_value()) {
+    return std::nullopt;
+  }
+
+  std::stringstream sql;
+  sql << "SELECT ";
+
+  for (auto i = 0; i < projectNode->names().size(); ++i) {
+    appendComma(i, sql);
+    auto projection = projectNode->projections()[i];
+    if (auto field =
+            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+                projection)) {
+      sql << field->name();
+    } else if (
+        auto call =
+            std::dynamic_pointer_cast<const core::CallTypedExpr>(projection)) {
+      sql << toCallSql(call);
+    } else {
+      VELOX_NYI();
+    }
+
+    sql << " as " << projectNode->names()[i];
+  }
+
+  sql << " FROM (" << sourceSql.value() << ")";
+  return sql.str();
+}
+
+namespace {
+
+void appendWindowFrame(
+    const core::WindowNode::Frame& frame,
+    std::stringstream& sql) {
+  // TODO: Add support for k Range Frames by retrieving the original range bound
+  // from WindowNode.
+  switch (frame.type) {
+    case core::WindowNode::WindowType::kRange:
+      sql << " RANGE";
+      break;
+    case core::WindowNode::WindowType::kRows:
+      sql << " ROWS";
+      break;
+    default:
+      VELOX_UNREACHABLE();
+  }
+  sql << " BETWEEN";
+
+  auto appendBound = [&sql](
+                         const core::WindowNode::BoundType& bound,
+                         const core::TypedExprPtr& value) {
+    switch (bound) {
+      case core::WindowNode::BoundType::kUnboundedPreceding:
+        sql << " UNBOUNDED PRECEDING";
+        break;
+      case core::WindowNode::BoundType::kUnboundedFollowing:
+        sql << " UNBOUNDED FOLLOWING";
+        break;
+      case core::WindowNode::BoundType::kCurrentRow:
+        sql << " CURRENT ROW";
+        break;
+      case core::WindowNode::BoundType::kPreceding:
+        sql << " " << value->toString() << " PRECEDING";
+        break;
+      case core::WindowNode::BoundType::kFollowing:
+        sql << " " << value->toString() << " FOLLOWING";
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+  };
+
+  appendBound(frame.startType, frame.startValue);
+  sql << " AND";
+  appendBound(frame.endType, frame.endValue);
+}
+
+} // namespace
+
+std::optional<std::string> PrestoQueryRunner::toSql(
+    const std::shared_ptr<const core::WindowNode>& windowNode) {
+  if (!isSupportedDwrfType(windowNode->sources()[0]->outputType())) {
+    return std::nullopt;
+  }
+
+  std::stringstream sql;
+  sql << "SELECT ";
+
+  const auto& inputType = windowNode->sources()[0]->outputType();
+  for (auto i = 0; i < inputType->size(); ++i) {
+    appendComma(i, sql);
+    sql << inputType->nameOf(i);
+  }
+
+  sql << ", ";
+
+  const auto& functions = windowNode->windowFunctions();
+  for (auto i = 0; i < functions.size(); ++i) {
+    appendComma(i, sql);
+    sql << toWindowCallSql(functions[i].functionCall, functions[i].ignoreNulls);
+
+    sql << " OVER (";
+
+    const auto& partitionKeys = windowNode->partitionKeys();
+    if (!partitionKeys.empty()) {
+      sql << "PARTITION BY ";
+      for (auto j = 0; j < partitionKeys.size(); ++j) {
+        appendComma(j, sql);
+        sql << partitionKeys[j]->name();
+      }
+    }
+
+    const auto& sortingKeys = windowNode->sortingKeys();
+    const auto& sortingOrders = windowNode->sortingOrders();
+
+    if (!sortingKeys.empty()) {
+      sql << " ORDER BY ";
+      for (auto j = 0; j < sortingKeys.size(); ++j) {
+        appendComma(j, sql);
+        sql << sortingKeys[j]->name() << " " << sortingOrders[j].toString();
+      }
+    }
+
+    appendWindowFrame(functions[i].frame, sql);
+    sql << ")";
+  }
+
+  sql << " FROM tmp";
+
+  return sql.str();
+}
+
+std::optional<std::string> PrestoQueryRunner::toSql(
+    const std::shared_ptr<const core::RowNumberNode>& rowNumberNode) {
+  if (!isSupportedDwrfType(rowNumberNode->sources()[0]->outputType())) {
+    return std::nullopt;
+  }
+
+  std::stringstream sql;
+  sql << "SELECT ";
+
+  const auto& inputType = rowNumberNode->sources()[0]->outputType();
+  for (auto i = 0; i < inputType->size(); ++i) {
+    appendComma(i, sql);
+    sql << inputType->nameOf(i);
+  }
+
+  sql << ", row_number() OVER (";
+
+  const auto& partitionKeys = rowNumberNode->partitionKeys();
+  if (!partitionKeys.empty()) {
+    sql << "partition by ";
+    for (auto i = 0; i < partitionKeys.size(); ++i) {
+      appendComma(i, sql);
+      sql << partitionKeys[i]->name();
+    }
+  }
+
+  sql << ") as row_number FROM tmp";
+
+  return sql.str();
+}
+
+std::optional<std::string> PrestoQueryRunner::toSql(
+    const std::shared_ptr<const core::TableWriteNode>& tableWriteNode) {
+  auto insertTableHandle =
+      std::dynamic_pointer_cast<connector::hive::HiveInsertTableHandle>(
+          tableWriteNode->insertTableHandle()->connectorInsertTableHandle());
+
+  // Returns a CTAS sql with specified table properties from TableWriteNode,
+  // example sql:
+  // CREATE TABLE tmp_write WITH (
+  // PARTITIONED_BY = ARRAY['p0'],
+  // BUCKETED_COUNT = 2, BUCKETED_BY = ARRAY['b0', 'b1'],
+  // SORTED_BY = ARRAY['s0 ASC', 's1 DESC'],
+  // FORMAT = 'ORC'
+  // )
+  // AS SELECT * FROM tmp
+  std::stringstream sql;
+  sql << "CREATE TABLE tmp_write";
+  std::vector<std::string> partitionKeys;
+  for (auto i = 0; i < tableWriteNode->columnNames().size(); ++i) {
+    if (insertTableHandle->inputColumns()[i]->isPartitionKey()) {
+      partitionKeys.push_back(insertTableHandle->inputColumns()[i]->name());
+    }
+  }
+  sql << " WITH (";
+
+  if (insertTableHandle->isPartitioned()) {
+    sql << " PARTITIONED_BY = ARRAY[";
+    for (int i = 0; i < partitionKeys.size(); ++i) {
+      appendComma(i, sql);
+      sql << "'" << partitionKeys[i] << "'";
+    }
+    sql << "], ";
+
+    if (insertTableHandle->bucketProperty() != nullptr) {
+      const auto bucketCount =
+          insertTableHandle->bucketProperty()->bucketCount();
+      const auto bucketColumns =
+          insertTableHandle->bucketProperty()->bucketedBy();
+      sql << " BUCKET_COUNT = " << bucketCount << ", BUCKETED_BY = ARRAY[";
+      for (int i = 0; i < bucketColumns.size(); ++i) {
+        appendComma(i, sql);
+        sql << "'" << bucketColumns[i] << "'";
+      }
+      sql << "], ";
+
+      const auto sortColumns = insertTableHandle->bucketProperty()->sortedBy();
+      if (!sortColumns.empty()) {
+        sql << " SORTED_BY = ARRAY[";
+        for (int i = 0; i < sortColumns.size(); ++i) {
+          appendComma(i, sql);
+          sql << "'" << sortColumns[i]->sortColumn() << " "
+              << (sortColumns[i]->sortOrder().isAscending() ? "ASC" : "DESC")
+              << "'";
+        }
+        sql << "], ";
+      }
+    }
+  }
+
+  sql << "FORMAT = 'ORC')  AS SELECT * FROM tmp";
+  return sql.str();
+}
+
+std::optional<std::string> PrestoQueryRunner::toSql(
+    const std::shared_ptr<const core::HashJoinNode>& joinNode) {
+  if (!isSupportedDwrfType(joinNode->sources()[0]->outputType())) {
+    return std::nullopt;
+  }
+
+  if (!isSupportedDwrfType(joinNode->sources()[1]->outputType())) {
+    return std::nullopt;
+  }
+
+  const auto joinKeysToSql = [](auto keys) {
+    std::stringstream out;
+    for (auto i = 0; i < keys.size(); ++i) {
+      if (i > 0) {
+        out << ", ";
+      }
+      out << keys[i]->name();
+    }
+    return out.str();
+  };
+
+  const auto equiClausesToSql = [](auto joinNode) {
+    std::stringstream out;
+    for (auto i = 0; i < joinNode->leftKeys().size(); ++i) {
+      if (i > 0) {
+        out << " AND ";
+      }
+      out << joinNode->leftKeys()[i]->name() << " = "
+          << joinNode->rightKeys()[i]->name();
+    }
+    return out.str();
+  };
+
+  const auto& outputNames = joinNode->outputType()->names();
+
+  std::stringstream sql;
+  if (joinNode->isLeftSemiProjectJoin()) {
+    sql << "SELECT "
+        << folly::join(", ", outputNames.begin(), --outputNames.end());
+  } else {
+    sql << "SELECT " << folly::join(", ", outputNames);
+  }
+
+  switch (joinNode->joinType()) {
+    case core::JoinType::kInner:
+      sql << " FROM t INNER JOIN u ON " << equiClausesToSql(joinNode);
+      break;
+    case core::JoinType::kLeft:
+      sql << " FROM t LEFT JOIN u ON " << equiClausesToSql(joinNode);
+      break;
+    case core::JoinType::kFull:
+      sql << " FROM t FULL OUTER JOIN u ON " << equiClausesToSql(joinNode);
+      break;
+    case core::JoinType::kLeftSemiFilter:
+      if (joinNode->leftKeys().size() > 1) {
+        return std::nullopt;
+      }
+      sql << " FROM t WHERE " << joinKeysToSql(joinNode->leftKeys())
+          << " IN (SELECT " << joinKeysToSql(joinNode->rightKeys())
+          << " FROM u)";
+      break;
+    case core::JoinType::kLeftSemiProject:
+      if (joinNode->isNullAware()) {
+        sql << ", " << joinKeysToSql(joinNode->leftKeys()) << " IN (SELECT "
+            << joinKeysToSql(joinNode->rightKeys()) << " FROM u) FROM t";
+      } else {
+        sql << ", EXISTS (SELECT * FROM u WHERE " << equiClausesToSql(joinNode)
+            << ") FROM t";
+      }
+      break;
+    case core::JoinType::kAnti:
+      if (joinNode->isNullAware()) {
+        sql << " FROM t WHERE " << joinKeysToSql(joinNode->leftKeys())
+            << " NOT IN (SELECT " << joinKeysToSql(joinNode->rightKeys())
+            << " FROM u)";
+      } else {
+        sql << " FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE "
+            << equiClausesToSql(joinNode) << ")";
+      }
+      break;
+    default:
+      VELOX_UNREACHABLE(
+          "Unknown join type: {}", static_cast<int>(joinNode->joinType()));
+  }
+
+  return sql.str();
+}
+
+std::optional<std::string> PrestoQueryRunner::toSql(
+    const std::shared_ptr<const core::NestedLoopJoinNode>& joinNode) {
+  const auto& joinKeysToSql = [](auto keys) {
+    std::stringstream out;
+    for (auto i = 0; i < keys.size(); ++i) {
+      if (i > 0) {
+        out << ", ";
+      }
+      out << keys[i]->name();
+    }
+    return out.str();
+  };
+
+  const auto& outputNames = joinNode->outputType()->names();
+  std::stringstream sql;
+
+  // Nested loop join without filter.
+  VELOX_CHECK(
+      joinNode->joinCondition() == nullptr,
+      "This code path should be called only for nested loop join without filter");
+  const std::string joinCondition{"(1 = 1)"};
+  switch (joinNode->joinType()) {
+    case core::JoinType::kInner:
+      sql << " FROM t INNER JOIN u ON " << joinCondition;
+      break;
+    case core::JoinType::kLeft:
+      sql << " FROM t LEFT JOIN u ON " << joinCondition;
+      break;
+    case core::JoinType::kFull:
+      sql << " FROM t FULL OUTER JOIN u ON " << joinCondition;
+      break;
+    default:
+      VELOX_UNREACHABLE(
+          "Unknown join type: {}", static_cast<int>(joinNode->joinType()));
+  }
+
+  return sql.str();
+}
+
+std::multiset<std::vector<variant>> PrestoQueryRunner::execute(
+    const std::string& sql,
+    const std::vector<RowVectorPtr>& input,
+    const RowTypePtr& resultType) {
+  return exec::test::materialize(executeVector(sql, input, resultType));
+}
+
+std::multiset<std::vector<velox::variant>> PrestoQueryRunner::execute(
+    const std::string& sql,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    const RowTypePtr& resultType) {
+  return exec::test::materialize(
+      executeVector(sql, probeInput, buildInput, resultType));
+}
+
+std::string PrestoQueryRunner::createTable(
+    const std::string& name,
+    const TypePtr& type) {
+  auto inputType = asRowType(type);
+  std::stringstream nullValues;
+  for (auto i = 0; i < inputType->size(); ++i) {
+    appendComma(i, nullValues);
+    nullValues << fmt::format(
+        "cast(null as {})", toTypeSql(inputType->childAt(i)));
+  }
+
+  execute(fmt::format("DROP TABLE IF EXISTS {}", name));
+
+  execute(fmt::format(
+      "CREATE TABLE {}({}) WITH (format = 'DWRF') AS SELECT {}",
+      name,
+      folly::join(", ", inputType->names()),
+      nullValues.str()));
+
+  // Query Presto to find out table's location on disk.
+  auto results = execute(fmt::format("SELECT \"$path\" FROM {}", name));
+
+  auto filePath = extractSingleValue<StringView>(results);
+  auto tableDirectoryPath = fs::path(filePath).parent_path();
+
+  // Delete the all-null row.
+  execute(fmt::format("DELETE FROM {}", name));
+
+  return tableDirectoryPath;
+}
+
+std::vector<velox::RowVectorPtr> PrestoQueryRunner::executeVector(
+    const std::string& sql,
+    const std::vector<RowVectorPtr>& probeInput,
+    const std::vector<RowVectorPtr>& buildInput,
+    const velox::RowTypePtr& resultType) {
+  auto probeType = asRowType(probeInput[0]->type());
+  if (probeType->size() == 0) {
+    auto rowVector = makeNullRows(probeInput, "x", pool());
+    return executeVector(sql, {rowVector}, buildInput, resultType);
+  }
+
+  auto buildType = asRowType(buildInput[0]->type());
+  if (probeType->size() == 0) {
+    auto rowVector = makeNullRows(buildInput, "y", pool());
+    return executeVector(sql, probeInput, {rowVector}, resultType);
+  }
+
+  auto probeTableDirectoryPath = createTable("t", probeInput[0]->type());
+  auto buildTableDirectoryPath = createTable("u", buildInput[0]->type());
+
+  // Create a new file in table's directory with fuzzer-generated data.
+  auto probeFilePath = fs::path(probeTableDirectoryPath)
+                           .append("probe.dwrf")
+                           .string()
+                           .substr(strlen("file:"));
+
+  auto buildFilePath = fs::path(buildTableDirectoryPath)
+                           .append("build.dwrf")
+                           .string()
+                           .substr(strlen("file:"));
+
+  auto writerPool = aggregatePool()->addAggregateChild("writer");
+  writeToFile(probeFilePath, probeInput, writerPool.get());
+  writeToFile(buildFilePath, buildInput, writerPool.get());
+
+  // Run the query.
+  return execute(sql);
+}
+
+std::vector<velox::RowVectorPtr> PrestoQueryRunner::executeVector(
+    const std::string& sql,
+    const std::vector<velox::RowVectorPtr>& input,
+    const velox::RowTypePtr& resultType) {
+  auto inputType = asRowType(input[0]->type());
+  if (inputType->size() == 0) {
+    auto rowVector = makeNullRows(input, "x", pool());
+    return executeVector(sql, {rowVector}, resultType);
+  }
+
+  auto tableDirectoryPath = createTable("tmp", input[0]->type());
+
+  // Create a new file in table's directory with fuzzer-generated data.
+  auto newFilePath = fs::path(tableDirectoryPath)
+                         .append("fuzzer.dwrf")
+                         .string()
+                         .substr(strlen("file:"));
+
+  auto writerPool = aggregatePool()->addAggregateChild("writer");
+  writeToFile(newFilePath, input, writerPool.get());
+
+  // Run the query.
+  return execute(sql);
+}
+
+std::vector<RowVectorPtr> PrestoQueryRunner::execute(const std::string& sql) {
+  return execute(sql, "");
+}
+
+std::vector<RowVectorPtr> PrestoQueryRunner::execute(
+    const std::string& sql,
+    const std::string& sessionProperty) {
+  LOG(INFO) << "Execute presto sql: " << sql;
+  auto response = ServerResponse(startQuery(sql, sessionProperty));
+  response.throwIfFailed();
+
+  std::vector<RowVectorPtr> queryResults;
+  for (;;) {
+    for (auto& result : response.queryResults(pool_.get())) {
+      queryResults.push_back(result);
+    }
+
+    if (response.queryCompleted()) {
+      break;
+    }
+
+    response = ServerResponse(fetchNext(response.nextUri()));
+    response.throwIfFailed();
+  }
+
+  return queryResults;
+}
+
+std::string PrestoQueryRunner::startQuery(
+    const std::string& sql,
+    const std::string& sessionProperty) {
+  auto uri = fmt::format("{}/v1/statement?binaryResults=true", coordinatorUri_);
+  cpr::Url url{uri};
+  cpr::Body body{sql};
+  cpr::Header header(
+      {{"X-Presto-User", user_},
+       {"X-Presto-Catalog", "hive"},
+       {"X-Presto-Schema", "tpch"},
+       {"Content-Type", "text/plain"},
+       {"X-Presto-Session", sessionProperty}});
+  cpr::Timeout timeout{timeout_};
+  cpr::Response response = cpr::Post(url, body, header, timeout);
+  VELOX_CHECK_EQ(
+      response.status_code,
+      200,
+      "POST to {} failed: {}",
+      uri,
+      response.error.message);
+  return response.text;
+}
+
+std::string PrestoQueryRunner::fetchNext(const std::string& nextUri) {
+  cpr::Url url(nextUri);
+  cpr::Header header({{"X-Presto-Client-Binary-Results", "true"}});
+  cpr::Timeout timeout{timeout_};
+  cpr::Response response = cpr::Get(url, header, timeout);
+  VELOX_CHECK_EQ(
+      response.status_code,
+      200,
+      "GET from {} failed: {}",
+      nextUri,
+      response.error.message);
+  return response.text;
+}
+
+bool PrestoQueryRunner::supportsVeloxVectorResults() const {
+  return true;
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/PrestoQueryRunner.h b/velox/exec/fuzzer/PrestoQueryRunner.h
new file mode 100644
index 0000000000000..b5a20b4d1cbe9
--- /dev/null
+++ b/velox/exec/fuzzer/PrestoQueryRunner.h
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/SocketAddress.h>
+#include <folly/io/async/EventBaseThread.h>
+#include "velox/common/memory/Memory.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+template <typename T>
+T extractSingleValue(const std::vector<RowVectorPtr>& data) {
+  auto simpleVector = data[0]->childAt(0)->as<SimpleVector<T>>();
+  VELOX_CHECK(!simpleVector->isNullAt(0));
+  return simpleVector->valueAt(0);
+}
+
+class PrestoQueryRunner : public velox::exec::test::ReferenceQueryRunner {
+ public:
+  /// @param coordinatorUri Presto REST API endpoint, e.g. http://127.0.0.1:8080
+  /// @param user Username to use in X-Presto-User header.
+  /// @param timeout Timeout in milliseconds of an HTTP request.
+  PrestoQueryRunner(
+      memory::MemoryPool* aggregatePool,
+      std::string coordinatorUri,
+      std::string user,
+      std::chrono::milliseconds timeout);
+
+  RunnerType runnerType() const override {
+    return RunnerType::kPrestoQueryRunner;
+  }
+
+  const std::vector<TypePtr>& supportedScalarTypes() const override;
+
+  /// Converts Velox query plan to Presto SQL. Supports Values -> Aggregation or
+  /// Window with an optional Project on top.
+  ///
+  /// Values node is converted into reading from 'tmp' table.
+  ///
+  /// @return std::nullopt if Values node uses types not supported by DWRF file
+  /// format (DATE, INTERVAL, UNKNOWN).
+  std::optional<std::string> toSql(
+      const velox::core::PlanNodePtr& plan) override;
+
+  /// Creates 'tmp' table using specified data, executes SQL query generated by
+  /// 'toSql' and returns the results.
+  ///
+  /// @param sql SQL generated by 'toSql' method.
+  /// @param input Data used in the Values node in the plan passed to 'toSql'
+  /// method.
+  /// @param resultType Expected type of the results.
+  /// @return Data received from Presto.
+  std::multiset<std::vector<velox::variant>> execute(
+      const std::string& sql,
+      const std::vector<velox::RowVectorPtr>& input,
+      const velox::RowTypePtr& resultType) override;
+
+  std::multiset<std::vector<velox::variant>> execute(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const RowTypePtr& resultType) override;
+
+  /// Executes Presto SQL query and returns the results. Tables referenced by
+  /// the query must already exist.
+  std::vector<velox::RowVectorPtr> execute(const std::string& sql) override;
+
+  /// Executes Presto SQL query with extra presto session property.
+  std::vector<velox::RowVectorPtr> execute(
+      const std::string& sql,
+      const std::string& sessionProperty) override;
+
+  bool supportsVeloxVectorResults() const override;
+
+  std::vector<RowVectorPtr> executeVector(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& input,
+      const RowTypePtr& resultType) override;
+
+  std::vector<RowVectorPtr> executeVector(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const RowTypePtr& resultType) override;
+
+ private:
+  memory::MemoryPool* pool() {
+    return pool_.get();
+  }
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const velox::core::AggregationNode>&
+          aggregationNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const velox::core::WindowNode>& windowNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const velox::core::ProjectNode>& projectNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const velox::core::RowNumberNode>& rowNumberNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::TableWriteNode>& tableWriteNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const velox::core::HashJoinNode>& joinNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::NestedLoopJoinNode>& joinNode);
+
+  std::string startQuery(
+      const std::string& sql,
+      const std::string& sessionProperty = "");
+
+  std::string fetchNext(const std::string& nextUri);
+
+  // Creates an empty table with given data type and table name. The function
+  // returns the root directory of table files.
+  std::string createTable(const std::string& name, const TypePtr& type);
+
+  const std::string coordinatorUri_;
+  const std::string user_;
+  const std::chrono::milliseconds timeout_;
+  folly::EventBaseThread eventBaseThread_{false};
+  std::shared_ptr<memory::MemoryPool> pool_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/ReferenceQueryRunner.h b/velox/exec/fuzzer/ReferenceQueryRunner.h
new file mode 100644
index 0000000000000..c666eeb6a7890
--- /dev/null
+++ b/velox/exec/fuzzer/ReferenceQueryRunner.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <set>
+#include "velox/core/PlanNode.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+/// Query runner that uses reference database, i.e. DuckDB, Presto, Spark.
+class ReferenceQueryRunner {
+ public:
+  enum class RunnerType {
+    kPrestoQueryRunner,
+    kDuckQueryRunner,
+    kSparkQueryRunner
+  };
+
+  // @param aggregatePool Used to allocate memory needed for vectors produced by
+  // 'execute' methods.
+  explicit ReferenceQueryRunner(memory::MemoryPool* aggregatePool)
+      : aggregatePool_(aggregatePool) {}
+
+  virtual ~ReferenceQueryRunner() = default;
+
+  virtual RunnerType runnerType() const = 0;
+
+  // Scalar types supported by the reference database, to be used to restrict
+  // candidates when generating random types for fuzzers.
+  virtual const std::vector<TypePtr>& supportedScalarTypes() const {
+    return defaultScalarTypes();
+  }
+
+  /// Converts Velox plan into SQL accepted by the reference database.
+  /// @return std::nullopt if the plan uses features not supported by the
+  /// reference database.
+  virtual std::optional<std::string> toSql(const core::PlanNodePtr& plan) = 0;
+
+  /// Executes SQL query returned by the 'toSql' method using 'input' data.
+  /// Converts results using 'resultType' schema.
+  virtual std::multiset<std::vector<velox::variant>> execute(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& input,
+      const RowTypePtr& resultType) = 0;
+
+  /// Executes SQL query returned by the 'toSql' method using 'probeInput' and
+  /// 'buildInput' data for join node.
+  /// Converts results using 'resultType' schema.
+  virtual std::multiset<std::vector<velox::variant>> execute(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const RowTypePtr& resultType) = 0;
+
+  /// Returns true if 'executeVector' can be called to get results as Velox
+  /// Vector.
+  virtual bool supportsVeloxVectorResults() const {
+    return false;
+  }
+
+  /// Similar to 'execute' but returns results in RowVector format.
+  /// Caller should ensure 'supportsVeloxVectorResults' returns true.
+  virtual std::vector<RowVectorPtr> executeVector(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& input,
+      const RowTypePtr& resultType) {
+    VELOX_UNSUPPORTED();
+  }
+
+  /// Similar to above but for join node with 'probeInput' and 'buildInput'.
+  virtual std::vector<RowVectorPtr> executeVector(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const RowTypePtr& resultType) {
+    VELOX_UNSUPPORTED();
+  }
+
+  virtual std::vector<velox::RowVectorPtr> execute(const std::string& sql) {
+    VELOX_UNSUPPORTED();
+  }
+
+  virtual std::vector<velox::RowVectorPtr> execute(
+      const std::string& sql,
+      const std::string& sessionProperty) {
+    VELOX_UNSUPPORTED();
+  }
+
+ protected:
+  memory::MemoryPool* aggregatePool() {
+    return aggregatePool_;
+  }
+
+ private:
+  memory::MemoryPool* aggregatePool_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/ResultVerifier.h b/velox/exec/fuzzer/ResultVerifier.h
new file mode 100644
index 0000000000000..bda5ccecc7f15
--- /dev/null
+++ b/velox/exec/fuzzer/ResultVerifier.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+/// Verifies aggregation results either directly or by comparing with results
+/// from a logically equivalent plan or reference DB.
+///
+/// Can be used to sort results of array_agg before comparing (uses 'compare'
+/// API) or verify approx_distinct by comparing its results with results of
+/// count(distinct) (uses 'verify' API).
+class ResultVerifier {
+ public:
+  virtual ~ResultVerifier() = default;
+
+  /// Returns true if 'compare' API is supported. The verifier must support
+  /// either 'compare' or 'verify' API. If both are supported, 'compare' API is
+  /// used and 'verify' API is ignored.
+  virtual bool supportsCompare() = 0;
+
+  /// Return true if 'verify' API is support. The verifier must support either
+  /// 'compare' or 'verify' API.
+  virtual bool supportsVerify() = 0;
+
+  /// Called once before possibly multiple calls to 'compare' or 'verify' APIs
+  /// to specify the input data, grouping keys (may be empty), the aggregate
+  /// function and the name of the column that will store aggregate function
+  /// results.
+  ///
+  /// Can be used by array_distinct verifier to compute count(distinct) once and
+  /// re-use its results for multiple 'verify' calls.
+  virtual void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) = 0;
+
+  /// Called once on a window operation before possibly multiple calls to the
+  /// 'compare' or 'verify' APIs. to specify the input data, window partition-by
+  /// keys, the window function, the window frame, and the name of the column
+  /// that will store the window function results.
+  virtual void initializeWindow(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<std::string>& /*partitionByKeys*/,
+      const std::vector<SortingKeyAndOrder>& /*sortingKeysAndOrders*/,
+      const core::WindowNode::Function& /*function*/,
+      const std::string& /*frame*/,
+      const std::string& /*windowName*/) {
+    VELOX_NYI();
+  }
+
+  /// Compares results of two logically equivalent Velox plans or a Velox plan
+  /// and a reference DB query.
+  ///
+  /// 'initialize' must be called first. 'compare' may be called multiple times
+  /// after single 'initialize' call.
+  virtual bool compare(
+      const RowVectorPtr& result,
+      const RowVectorPtr& otherResult) = 0;
+
+  /// Verifies results of a Velox plan or reference DB query.
+  ///
+  /// 'initialize' must be called first. 'verify' may be called multiple times
+  /// after single 'initialize' call.
+  virtual bool verify(const RowVectorPtr& result) = 0;
+
+  /// Clears internal state after possibly multiple calls to 'compare' and
+  /// 'verify'. 'initialize' must be called again after 'reset' to allow calling
+  /// 'compare' or 'verify' again.
+  virtual void reset() = 0;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/RowNumberFuzzer.cpp b/velox/exec/fuzzer/RowNumberFuzzer.cpp
new file mode 100644
index 0000000000000..a14edab6fd080
--- /dev/null
+++ b/velox/exec/fuzzer/RowNumberFuzzer.cpp
@@ -0,0 +1,487 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/RowNumberFuzzer.h"
+#include <boost/random/uniform_int_distribution.hpp>
+#include <utility>
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int32(steps, 10, "Number of plans to generate and test.");
+
+DEFINE_int32(
+    duration_sec,
+    0,
+    "For how long it should run (in seconds). If zero, "
+    "it executes exactly --steps iterations and exits.");
+
+DEFINE_int32(
+    batch_size,
+    100,
+    "The number of elements on each generated vector.");
+
+DEFINE_int32(num_batches, 10, "The number of generated vectors.");
+
+DEFINE_double(
+    null_ratio,
+    0.1,
+    "Chance of adding a null value in a vector "
+    "(expressed as double from 0 to 1).");
+
+DEFINE_bool(enable_spill, true, "Whether to test plans with spilling enabled.");
+
+DEFINE_int32(
+    max_spill_level,
+    -1,
+    "Max spill level, -1 means random [0, 7], otherwise the actual level.");
+
+DEFINE_bool(
+    enable_oom_injection,
+    false,
+    "When enabled OOMs will randomly be triggered while executing query "
+    "plans. The goal of this mode is to ensure unexpected exceptions "
+    "aren't thrown and the process isn't killed in the process of cleaning "
+    "up after failures. Therefore, results are not compared when this is "
+    "enabled. Note that this option only works in debug builds.");
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class RowNumberFuzzer {
+ public:
+  explicit RowNumberFuzzer(
+      size_t initialSeed,
+      std::unique_ptr<ReferenceQueryRunner>);
+
+  void go();
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    std::vector<Split> splits;
+
+    explicit PlanWithSplits(
+        core::PlanNodePtr _plan,
+        const std::vector<Split>& _splits = {})
+        : plan(std::move(_plan)), splits(_splits) {}
+  };
+
+ private:
+  static VectorFuzzer::Options getFuzzerOptions() {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = FLAGS_batch_size;
+    opts.stringVariableLength = true;
+    opts.stringLength = 100;
+    opts.nullRatio = FLAGS_null_ratio;
+    return opts;
+  }
+
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    vectorFuzzer_.reSeed(seed);
+    rng_.seed(currentSeed_);
+  }
+
+  void reSeed() {
+    seed(rng_());
+  }
+
+  // Runs one test iteration from query plans generations, executions and result
+  // verifications.
+  void verify();
+
+  int32_t randInt(int32_t min, int32_t max) {
+    return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
+  }
+
+  std::pair<std::vector<std::string>, std::vector<TypePtr>>
+  generatePartitionKeys();
+
+  std::vector<RowVectorPtr> generateInput(
+      const std::vector<std::string>& keyNames,
+      const std::vector<TypePtr>& keyTypes);
+
+  std::optional<MaterializedRowMultiset> computeReferenceResults(
+      core::PlanNodePtr& plan,
+      const std::vector<RowVectorPtr>& input);
+
+  RowVectorPtr execute(const PlanWithSplits& plan, bool injectSpill);
+
+  void addPlansWithTableScan(
+      const std::string& tableDir,
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<RowVectorPtr>& input,
+      std::vector<PlanWithSplits>& altPlans);
+
+  // Makes the query plan with default settings in RowNumberFuzzer and value
+  // inputs for both probe and build sides.
+  //
+  // NOTE: 'input' could either input rows with lazy
+  // vectors or flatten ones.
+  static PlanWithSplits makeDefaultPlan(
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<RowVectorPtr>& input);
+
+  static PlanWithSplits makePlanWithTableScan(
+      const RowTypePtr& type,
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<Split>& splits);
+
+  FuzzerGenerator rng_;
+  size_t currentSeed_{0};
+
+  std::shared_ptr<memory::MemoryPool> rootPool_{
+      memory::memoryManager()->addRootPool(
+          "rowNumberFuzzer",
+          memory::kMaxMemory,
+          memory::MemoryReclaimer::create())};
+  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild(
+      "rowNumberFuzzerLeaf",
+      true,
+      exec::MemoryReclaimer::create())};
+  std::shared_ptr<memory::MemoryPool> writerPool_{rootPool_->addAggregateChild(
+      "rowNumberFuzzerWriter",
+      exec::MemoryReclaimer::create())};
+  VectorFuzzer vectorFuzzer_;
+  std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner_;
+};
+
+RowNumberFuzzer::RowNumberFuzzer(
+    size_t initialSeed,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner)
+    : vectorFuzzer_{getFuzzerOptions(), pool_.get()},
+      referenceQueryRunner_{std::move(referenceQueryRunner)} {
+  filesystems::registerLocalFileSystem();
+
+  // Make sure not to run out of open file descriptors.
+  std::unordered_map<std::string, std::string> hiveConfig = {
+      {connector::hive::HiveConfig::kNumCacheFileHandles, "1000"}};
+  auto hiveConnector =
+      connector::getConnectorFactory(
+          connector::hive::HiveConnectorFactory::kHiveConnectorName)
+          ->newConnector(
+              kHiveConnectorId,
+              std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
+  connector::registerConnector(hiveConnector);
+
+  seed(initialSeed);
+}
+
+template <typename T>
+bool isDone(size_t i, T startTime) {
+  if (FLAGS_duration_sec > 0) {
+    std::chrono::duration<double> elapsed =
+        std::chrono::system_clock::now() - startTime;
+    return elapsed.count() >= FLAGS_duration_sec;
+  }
+  return i >= FLAGS_steps;
+}
+
+std::vector<RowVectorPtr> flatten(const std::vector<RowVectorPtr>& vectors) {
+  std::vector<RowVectorPtr> flatVectors;
+  for (const auto& vector : vectors) {
+    auto flat = BaseVector::create<RowVector>(
+        vector->type(), vector->size(), vector->pool());
+    flat->copy(vector.get(), 0, 0, vector->size());
+    flatVectors.push_back(flat);
+  }
+
+  return flatVectors;
+}
+
+std::pair<std::vector<std::string>, std::vector<TypePtr>>
+RowNumberFuzzer::generatePartitionKeys() {
+  const auto numKeys = randInt(1, 3);
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  for (auto i = 0; i < numKeys; ++i) {
+    names.push_back(fmt::format("c{}", i));
+    types.push_back(vectorFuzzer_.randType(/*maxDepth=*/1));
+  }
+  return std::make_pair(names, types);
+}
+
+std::vector<RowVectorPtr> RowNumberFuzzer::generateInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  std::vector<std::string> names = keyNames;
+  std::vector<TypePtr> types = keyTypes;
+  // Add up to 3 payload columns.
+  const auto numPayload = randInt(0, 3);
+  for (auto i = 0; i < numPayload; ++i) {
+    names.push_back(fmt::format("c{}", i + keyNames.size()));
+    types.push_back(vectorFuzzer_.randType(/*maxDepth=*/2));
+  }
+
+  const auto inputType = ROW(std::move(names), std::move(types));
+  std::vector<RowVectorPtr> input;
+  input.reserve(FLAGS_num_batches);
+  for (auto i = 0; i < FLAGS_num_batches; ++i) {
+    input.push_back(vectorFuzzer_.fuzzInputRow(inputType));
+  }
+
+  return input;
+}
+
+RowNumberFuzzer::PlanWithSplits RowNumberFuzzer::makeDefaultPlan(
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<RowVectorPtr>& input) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<std::string> projectFields = partitionKeys;
+  projectFields.emplace_back("row_number");
+  auto plan = PlanBuilder()
+                  .values(input)
+                  .rowNumber(partitionKeys)
+                  .project(projectFields)
+                  .planNode();
+  return PlanWithSplits{std::move(plan)};
+}
+
+std::optional<MaterializedRowMultiset> RowNumberFuzzer::computeReferenceResults(
+    core::PlanNodePtr& plan,
+    const std::vector<RowVectorPtr>& input) {
+  if (containsUnsupportedTypes(input[0]->type())) {
+    return std::nullopt;
+  }
+
+  if (auto sql = referenceQueryRunner_->toSql(plan)) {
+    return referenceQueryRunner_->execute(
+        sql.value(), input, plan->outputType());
+  }
+
+  LOG(INFO) << "Query not supported by the reference DB";
+  return std::nullopt;
+}
+
+RowVectorPtr RowNumberFuzzer::execute(
+    const PlanWithSplits& plan,
+    bool injectSpill) {
+  LOG(INFO) << "Executing query plan: " << plan.plan->toString(true, true);
+
+  AssertQueryBuilder builder(plan.plan);
+  if (!plan.splits.empty()) {
+    builder.splits(plan.splits);
+  }
+
+  std::shared_ptr<TempDirectoryPath> spillDirectory;
+  int32_t spillPct{0};
+  if (injectSpill) {
+    spillDirectory = exec::test::TempDirectoryPath::create();
+    const auto maxSpillLevel =
+        FLAGS_max_spill_level == -1 ? randInt(0, 7) : FLAGS_max_spill_level;
+    builder.config(core::QueryConfig::kSpillEnabled, true)
+        .config(core::QueryConfig::kMaxSpillLevel, maxSpillLevel)
+        .config(core::QueryConfig::kRowNumberSpillEnabled, true)
+        .spillDirectory(spillDirectory->getPath());
+    spillPct = 10;
+  }
+
+  ScopedOOMInjector oomInjector(
+      []() -> bool { return folly::Random::oneIn(10); },
+      10); // Check the condition every 10 ms.
+  if (FLAGS_enable_oom_injection) {
+    oomInjector.enable();
+  }
+
+  // Wait for the task to be destroyed before start next query execution to
+  // avoid the potential interference of the background activities across query
+  // executions.
+  auto stopGuard = folly::makeGuard([&]() { waitForAllTasksToBeDeleted(); });
+
+  TestScopedSpillInjection scopedSpillInjection(spillPct);
+  RowVectorPtr result;
+  try {
+    result = builder.copyResults(pool_.get());
+  } catch (VeloxRuntimeError& e) {
+    if (FLAGS_enable_oom_injection &&
+        e.errorCode() == facebook::velox::error_code::kMemCapExceeded &&
+        e.message() == ScopedOOMInjector::kErrorMessage) {
+      // If we enabled OOM injection we expect the exception thrown by the
+      // ScopedOOMInjector.
+      return nullptr;
+    }
+
+    throw e;
+  }
+
+  if (VLOG_IS_ON(1)) {
+    VLOG(1) << std::endl << result->toString(0, result->size());
+  }
+
+  return result;
+}
+
+RowNumberFuzzer::PlanWithSplits RowNumberFuzzer::makePlanWithTableScan(
+    const RowTypePtr& type,
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<Split>& splits) {
+  std::vector<std::string> projectFields = partitionKeys;
+  projectFields.emplace_back("row_number");
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(type)
+                  .rowNumber(partitionKeys)
+                  .project(projectFields)
+                  .planNode();
+  return PlanWithSplits{plan, splits};
+}
+
+bool isTableScanSupported(const TypePtr& type) {
+  if (type->kind() == TypeKind::ROW && type->size() == 0) {
+    return false;
+  }
+  if (type->kind() == TypeKind::UNKNOWN) {
+    return false;
+  }
+  if (type->kind() == TypeKind::HUGEINT) {
+    return false;
+  }
+  // Disable testing with TableScan when input contains TIMESTAMP type, due to
+  // the issue #8127.
+  if (type->kind() == TypeKind::TIMESTAMP) {
+    return false;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (!isTableScanSupported(type->childAt(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void RowNumberFuzzer::addPlansWithTableScan(
+    const std::string& tableDir,
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<RowVectorPtr>& input,
+    std::vector<PlanWithSplits>& altPlans) {
+  VELOX_CHECK(!tableDir.empty());
+
+  if (!isTableScanSupported(input[0]->type())) {
+    return;
+  }
+
+  const std::vector<Split> inputSplits =
+      makeSplits(input, fmt::format("{}/row_number", tableDir), writerPool_);
+  altPlans.push_back(makePlanWithTableScan(
+      asRowType(input[0]->type()), partitionKeys, inputSplits));
+}
+
+void RowNumberFuzzer::verify() {
+  const auto [keyNames, keyTypes] = generatePartitionKeys();
+  const auto input = generateInput(keyNames, keyTypes);
+  // Flatten inputs.
+  const auto flatInput = flatten(input);
+
+  if (VLOG_IS_ON(1)) {
+    VLOG(1) << "Input: " << input[0]->toString();
+    for (const auto& v : flatInput) {
+      VLOG(1) << std::endl << v->toString(0, v->size());
+    }
+  }
+
+  auto defaultPlan = makeDefaultPlan(keyNames, input);
+  const auto expected = execute(defaultPlan, /*injectSpill=*/false);
+
+  if (expected != nullptr) {
+    if (const auto referenceResult =
+            computeReferenceResults(defaultPlan.plan, input)) {
+      VELOX_CHECK(
+          assertEqualResults(
+              referenceResult.value(),
+              defaultPlan.plan->outputType(),
+              {expected}),
+          "Velox and Reference results don't match");
+    }
+  }
+
+  std::vector<PlanWithSplits> altPlans;
+  altPlans.push_back(std::move(defaultPlan));
+
+  const auto tableScanDir = exec::test::TempDirectoryPath::create();
+  addPlansWithTableScan(tableScanDir->getPath(), keyNames, input, altPlans);
+
+  for (auto i = 0; i < altPlans.size(); ++i) {
+    LOG(INFO) << "Testing plan #" << i;
+    auto actual = execute(altPlans[i], /*injectSpill=*/false);
+    if (actual != nullptr && expected != nullptr) {
+      VELOX_CHECK(
+          assertEqualResults({expected}, {actual}),
+          "Logically equivalent plans produced different results");
+    } else {
+      VELOX_CHECK(
+          FLAGS_enable_oom_injection, "Got unexpected nullptr for results");
+    }
+
+    if (FLAGS_enable_spill) {
+      LOG(INFO) << "Testing plan #" << i << " with spilling";
+      actual = execute(altPlans[i], /*=injectSpill=*/true);
+      if (actual != nullptr && expected != nullptr) {
+        try {
+          VELOX_CHECK(
+              assertEqualResults({expected}, {actual}),
+              "Logically equivalent plans produced different results");
+        } catch (const VeloxException&) {
+          LOG(ERROR) << "Expected\n"
+                     << expected->toString(0, expected->size()) << "\nActual\n"
+                     << actual->toString(0, actual->size());
+          throw;
+        }
+      } else {
+        VELOX_CHECK(
+            FLAGS_enable_oom_injection, "Got unexpected nullptr for results");
+      }
+    }
+  }
+}
+
+void RowNumberFuzzer::go() {
+  VELOX_USER_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+  VELOX_USER_CHECK_GE(FLAGS_batch_size, 10, "Batch size must be at least 10.");
+
+  const auto startTime = std::chrono::system_clock::now();
+  size_t iteration = 0;
+
+  while (!isDone(iteration, startTime)) {
+    LOG(INFO) << "==============================> Started iteration "
+              << iteration << " (seed: " << currentSeed_ << ")";
+    verify();
+    LOG(INFO) << "==============================> Done with iteration "
+              << iteration;
+
+    reSeed();
+    ++iteration;
+  }
+}
+} // namespace
+
+void rowNumberFuzzer(
+    size_t seed,
+    std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner) {
+  RowNumberFuzzer(seed, std::move(referenceQueryRunner)).go();
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/RowNumberFuzzer.h b/velox/exec/fuzzer/RowNumberFuzzer.h
new file mode 100644
index 0000000000000..30cd960e327f4
--- /dev/null
+++ b/velox/exec/fuzzer/RowNumberFuzzer.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstddef>
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+
+namespace facebook::velox::exec::test {
+void rowNumberFuzzer(
+    size_t seed,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
+}
diff --git a/velox/exec/fuzzer/RowNumberFuzzerRunner.h b/velox/exec/fuzzer/RowNumberFuzzerRunner.h
new file mode 100644
index 0000000000000..2d018f81d3068
--- /dev/null
+++ b/velox/exec/fuzzer/RowNumberFuzzerRunner.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include "velox/common/file/FileSystems.h"
+
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/exec/fuzzer/RowNumberFuzzer.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+/// RowNumber FuzzerRunner leverages RowNumberFuzzer and VectorFuzzer to
+/// automatically generate and execute tests. It works as follows:
+///
+///  1. Plan Generation: Generate two equivalent query plans, one is row-number
+///     over ValuesNode and the other is over TableScanNode.
+///  2. Executes a variety of logically equivalent query plans and checks the
+///     results are the same.
+///  3. Rinse and repeat.
+///
+/// It is used as follows:
+///
+///  $ ./velox_row_number_fuzzer_test --duration_sec 600
+///
+/// The flags that configure RowNumberFuzzer's behavior are:
+///
+///  --steps: how many iterations to run.
+///  --duration_sec: alternatively, for how many seconds it should run (takes
+///          precedence over --steps).
+///  --seed: pass a deterministic seed to reproduce the behavior (each iteration
+///          will print a seed as part of the logs).
+///  --v=1: verbose logging; print a lot more details about the execution.
+///  --batch_size: size of input vector batches generated.
+///  --num_batches: number if input vector batches to generate.
+///  --enable_spill: test plans with spilling enabled.
+///  --enable_oom_injection: randomly trigger OOM while executing query plans.
+/// e.g:
+///
+///  $ ./velox_row_number_fuzzer_test \
+///         --seed 123 \
+///         --duration_sec 600 \
+///         --v=1
+
+namespace facebook::velox::exec::test {
+
+class RowNumberFuzzerRunner {
+ public:
+  static int run(
+      size_t seed,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
+    serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    filesystems::registerLocalFileSystem();
+    rowNumberFuzzer(seed, std::move(referenceQueryRunner));
+    return RUN_ALL_TESTS();
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/ToSQLUtil.cpp b/velox/exec/fuzzer/ToSQLUtil.cpp
new file mode 100644
index 0000000000000..638de8f0b1fa0
--- /dev/null
+++ b/velox/exec/fuzzer/ToSQLUtil.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/ToSQLUtil.h"
+
+namespace facebook::velox::exec::test {
+
+void appendComma(int32_t i, std::stringstream& sql) {
+  if (i > 0) {
+    sql << ", ";
+  }
+}
+
+void toCallInputsSql(
+    const std::vector<core::TypedExprPtr>& inputs,
+    std::stringstream& sql) {
+  for (auto i = 0; i < inputs.size(); ++i) {
+    appendComma(i, sql);
+
+    const auto& input = inputs.at(i);
+    if (auto field =
+            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+                input)) {
+      sql << field->name();
+    } else if (
+        auto call =
+            std::dynamic_pointer_cast<const core::CallTypedExpr>(input)) {
+      sql << toCallSql(call);
+    } else if (
+        auto lambda =
+            std::dynamic_pointer_cast<const core::LambdaTypedExpr>(input)) {
+      const auto& signature = lambda->signature();
+      const auto& body =
+          std::dynamic_pointer_cast<const core::CallTypedExpr>(lambda->body());
+      VELOX_CHECK_NOT_NULL(body);
+
+      sql << "(";
+      for (auto j = 0; j < signature->size(); ++j) {
+        appendComma(j, sql);
+        sql << signature->nameOf(j);
+      }
+
+      sql << ") -> " << toCallSql(body);
+    } else {
+      VELOX_NYI("Unsupported input expression: {}.", input->toString());
+    }
+  }
+}
+
+std::string toCallSql(const core::CallTypedExprPtr& call) {
+  std::stringstream sql;
+  sql << call->name() << "(";
+  toCallInputsSql(call->inputs(), sql);
+  sql << ")";
+  return sql.str();
+}
+
+std::string toAggregateCallSql(
+    const core::CallTypedExprPtr& call,
+    const std::vector<core::FieldAccessTypedExprPtr>& sortingKeys,
+    const std::vector<core::SortOrder>& sortingOrders,
+    bool distinct) {
+  VELOX_CHECK_EQ(sortingKeys.size(), sortingOrders.size());
+  std::stringstream sql;
+  sql << call->name() << "(";
+
+  if (distinct) {
+    sql << "distinct ";
+  }
+
+  toCallInputsSql(call->inputs(), sql);
+
+  if (!sortingKeys.empty()) {
+    sql << " ORDER BY ";
+
+    for (int i = 0; i < sortingKeys.size(); i++) {
+      appendComma(i, sql);
+      sql << sortingKeys[i]->name() << " " << sortingOrders[i].toString();
+    }
+  }
+
+  sql << ")";
+  return sql.str();
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/ToSQLUtil.h b/velox/exec/fuzzer/ToSQLUtil.h
new file mode 100644
index 0000000000000..2175658225c69
--- /dev/null
+++ b/velox/exec/fuzzer/ToSQLUtil.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/core/PlanNode.h"
+
+namespace facebook::velox::exec::test {
+
+/// Appends a comma to a given stringstream if the provided integer is greater
+/// than 0.
+void appendComma(int32_t i, std::stringstream& sql);
+
+// Converts input expressions into SQL string and appends to a given
+// stringstream.
+void toCallInputsSql(
+    const std::vector<core::TypedExprPtr>& inputs,
+    std::stringstream& sql);
+
+// Converts a call expression into a SQL string.
+std::string toCallSql(const core::CallTypedExprPtr& call);
+
+// Converts aggregate call expression into a SQL string.
+std::string toAggregateCallSql(
+    const core::CallTypedExprPtr& call,
+    const std::vector<core::FieldAccessTypedExprPtr>& sortingKeys,
+    const std::vector<core::SortOrder>& sortingOrders,
+    bool distinct);
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/TransformResultVerifier.h b/velox/exec/fuzzer/TransformResultVerifier.h
new file mode 100644
index 0000000000000..15776275103b1
--- /dev/null
+++ b/velox/exec/fuzzer/TransformResultVerifier.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+// Applies specified SQL transformation to the results before comparing. For
+// example, sorts an array before comparing results of array_agg.
+//
+// Supports 'compare' API.
+class TransformResultVerifier : public ResultVerifier {
+ public:
+  // @param transform fmt::format-compatible SQL expression to use to transform
+  // aggregation results before comparison. The string must have a single
+  // placeholder for the column name that contains aggregation results. For
+  // example, "array_sort({})".
+  explicit TransformResultVerifier(const std::string& transform)
+      : transform_{transform} {}
+
+  static std::shared_ptr<ResultVerifier> create(const std::string& transform) {
+    return std::make_shared<TransformResultVerifier>(transform);
+  }
+
+  bool supportsCompare() override {
+    return true;
+  }
+
+  bool supportsVerify() override {
+    return false;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& /*aggregate*/,
+      const std::string& aggregateName) override {
+    projections_ = groupingKeys;
+    projections_.push_back(
+        fmt::format(fmt::runtime(transform_), aggregateName));
+  }
+
+  bool compare(const RowVectorPtr& result, const RowVectorPtr& altResult)
+      override {
+    return assertEqualResults({transform(result)}, {transform(altResult)});
+  }
+
+  bool verify(const RowVectorPtr& /*result*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void reset() override {
+    projections_.clear();
+  }
+
+ private:
+  RowVectorPtr transform(const RowVectorPtr& data) {
+    VELOX_CHECK(!projections_.empty());
+    auto plan = PlanBuilder().values({data}).project(projections_).planNode();
+    return AssertQueryBuilder(plan).copyResults(data->pool());
+  }
+
+  const std::string transform_;
+
+  std::vector<std::string> projections_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/WindowFuzzer.cpp b/velox/exec/fuzzer/WindowFuzzer.cpp
new file mode 100644
index 0000000000000..405e30f292c1c
--- /dev/null
+++ b/velox/exec/fuzzer/WindowFuzzer.cpp
@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/fuzzer/WindowFuzzer.h"
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include "velox/common/base/Portability.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+
+DEFINE_bool(
+    enable_window_reference_verification,
+    false,
+    "When true, the results of the window aggregation are compared to reference DB results");
+
+namespace facebook::velox::exec::test {
+
+namespace {
+
+bool supportIgnoreNulls(const std::string& name) {
+  // Below are all functions that support ignore nulls. Aggregation functions in
+  // window operations do not support ignore nulls.
+  // https://github.com/prestodb/presto/issues/21304.
+  static std::unordered_set<std::string> supportedFunctions{
+      "first_value",
+      "last_value",
+      "nth_value",
+      "lead",
+      "lag",
+  };
+  return supportedFunctions.count(name) > 0;
+}
+
+} // namespace
+
+void WindowFuzzer::addWindowFunctionSignatures(
+    const WindowFunctionMap& signatureMap) {
+  for (const auto& [name, entry] : signatureMap) {
+    ++functionsStats.numFunctions;
+    bool hasSupportedSignature = false;
+    for (auto& signature : entry.signatures) {
+      hasSupportedSignature |= addSignature(name, signature);
+    }
+    if (hasSupportedSignature) {
+      ++functionsStats.numSupportedFunctions;
+    }
+  }
+}
+
+std::string WindowFuzzer::generateFrameClause(
+    std::vector<std::string>& argNames,
+    std::vector<TypePtr>& argTypes,
+    bool& isRowsFrame) {
+  auto frameType = [](int value) -> const std::string {
+    switch (value) {
+      case 0:
+        return "RANGE";
+      case 1:
+        return "ROWS";
+      default:
+        VELOX_UNREACHABLE("Unknown value for frame type generation");
+    }
+  };
+  isRowsFrame = boost::random::uniform_int_distribution<uint32_t>(0, 1)(rng_);
+  auto frameTypeString = frameType(isRowsFrame);
+
+  constexpr int64_t kMax = std::numeric_limits<int64_t>::max();
+  constexpr int64_t kMin = std::numeric_limits<int64_t>::min();
+  // For frames with kPreceding, kFollowing bounds, pick a valid k, in the range
+  // of 1 to 10, 70% of times. Test for random k values remaining times.
+  int64_t minKValue, maxKValue;
+  if (vectorFuzzer_.coinToss(0.7)) {
+    minKValue = 1;
+    maxKValue = 10;
+  } else {
+    minKValue = kMin;
+    maxKValue = kMax;
+  }
+
+  // Generating column bounded frames 50% of the time and constant
+  // bounded the rest of the times. The column bounded frames are of
+  // type INTEGER and only have positive values as Window functions
+  // reject negative values for them.
+  auto frameBound = [this, minKValue, maxKValue, &argNames, &argTypes](
+                        core::WindowNode::BoundType boundType,
+                        const std::string& colName) -> const std::string {
+    auto kValue = boost::random::uniform_int_distribution<int64_t>(
+        minKValue, maxKValue)(rng_);
+    switch (boundType) {
+      case core::WindowNode::BoundType::kUnboundedPreceding:
+        return "UNBOUNDED PRECEDING";
+      case core::WindowNode::BoundType::kPreceding:
+        if (vectorFuzzer_.coinToss(0.5)) {
+          argTypes.push_back(INTEGER());
+          argNames.push_back(colName);
+          return fmt::format("{} PRECEDING", colName);
+        }
+        return fmt::format("{} PRECEDING", kValue);
+      case core::WindowNode::BoundType::kCurrentRow:
+        return "CURRENT ROW";
+      case core::WindowNode::BoundType::kFollowing:
+        if (vectorFuzzer_.coinToss(0.5)) {
+          argTypes.push_back(INTEGER());
+          argNames.push_back(colName);
+          return fmt::format("{} FOLLOWING", colName);
+        }
+        return fmt::format("{} FOLLOWING", kValue);
+      case core::WindowNode::BoundType::kUnboundedFollowing:
+        return "UNBOUNDED FOLLOWING";
+      default:
+        VELOX_UNREACHABLE("Unknown option for frame clause generation");
+    }
+  };
+
+  // Generating k PRECEDING and k FOLLOWING frames only for ROWS type.
+  // k RANGE frames require more work as we have to generate columns with the
+  // frame bound values.
+  std::vector<core::WindowNode::BoundType> startBoundOptions, endBoundOptions;
+  if (isRowsFrame) {
+    startBoundOptions = {
+        core::WindowNode::BoundType::kUnboundedPreceding,
+        core::WindowNode::BoundType::kPreceding,
+        core::WindowNode::BoundType::kCurrentRow,
+        core::WindowNode::BoundType::kFollowing};
+    endBoundOptions = {
+        core::WindowNode::BoundType::kPreceding,
+        core::WindowNode::BoundType::kCurrentRow,
+        core::WindowNode::BoundType::kFollowing,
+        core::WindowNode::BoundType::kUnboundedFollowing};
+  } else {
+    startBoundOptions = {
+        core::WindowNode::BoundType::kUnboundedPreceding,
+        core::WindowNode::BoundType::kCurrentRow};
+    endBoundOptions = {
+        core::WindowNode::BoundType::kCurrentRow,
+        core::WindowNode::BoundType::kUnboundedFollowing};
+  }
+
+  // End bound option should not be greater than start bound option as this
+  // would result in an invalid frame.
+  auto startBoundIndex = boost::random::uniform_int_distribution<uint32_t>(
+      0, startBoundOptions.size() - 1)(rng_);
+  auto endBoundMinIdx = std::max(0, static_cast<int>(startBoundIndex) - 1);
+  auto endBoundIndex = boost::random::uniform_int_distribution<uint32_t>(
+      endBoundMinIdx, endBoundOptions.size() - 1)(rng_);
+  auto frameStartBound = frameBound(startBoundOptions[startBoundIndex], "k0");
+  auto frameEndBound = frameBound(endBoundOptions[endBoundIndex], "k1");
+
+  return frameTypeString + " BETWEEN " + frameStartBound + " AND " +
+      frameEndBound;
+}
+
+std::string WindowFuzzer::generateOrderByClause(
+    const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders) {
+  std::stringstream frame;
+  frame << " order by ";
+  for (auto i = 0; i < sortingKeysAndOrders.size(); ++i) {
+    if (i != 0) {
+      frame << ", ";
+    }
+    frame << sortingKeysAndOrders[i].key_ << " "
+          << sortingKeysAndOrders[i].sortOrder_.toString();
+  }
+  return frame.str();
+}
+
+std::string WindowFuzzer::getFrame(
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+    const std::string& frameClause) {
+  std::stringstream frame;
+  VELOX_CHECK(!partitionKeys.empty());
+  frame << "partition by " << folly::join(", ", partitionKeys);
+  if (!sortingKeysAndOrders.empty()) {
+    frame << generateOrderByClause(sortingKeysAndOrders);
+  }
+  frame << " " << frameClause;
+  return frame.str();
+}
+
+std::vector<SortingKeyAndOrder> WindowFuzzer::generateSortingKeysAndOrders(
+    const std::string& prefix,
+    std::vector<std::string>& names,
+    std::vector<TypePtr>& types) {
+  auto keys = generateSortingKeys(prefix, names, types);
+  std::vector<SortingKeyAndOrder> results;
+  for (auto i = 0; i < keys.size(); ++i) {
+    auto asc = vectorFuzzer_.coinToss(0.5);
+    auto nullsFirst = vectorFuzzer_.coinToss(0.5);
+    results.emplace_back(keys[i], core::SortOrder(asc, nullsFirst));
+  }
+  return results;
+}
+
+void WindowFuzzer::go() {
+  VELOX_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+
+  auto startTime = std::chrono::system_clock::now();
+  size_t iteration = 0;
+
+  while (!isDone(iteration, startTime)) {
+    LOG(INFO) << "==============================> Started iteration "
+              << iteration << " (seed: " << currentSeed_ << ")";
+
+    auto signatureWithStats = pickSignature();
+    signatureWithStats.second.numRuns++;
+
+    const auto signature = signatureWithStats.first;
+    stats_.functionNames.insert(signature.name);
+
+    const bool customVerification =
+        customVerificationFunctions_.count(signature.name) != 0;
+    std::shared_ptr<ResultVerifier> customVerifier = nullptr;
+    if (customVerification) {
+      customVerifier = customVerificationFunctions_.at(signature.name);
+    }
+    const bool requireSortedInput =
+        orderDependentFunctions_.count(signature.name) != 0;
+
+    std::vector<TypePtr> argTypes = signature.args;
+    std::vector<std::string> argNames = makeNames(argTypes.size());
+
+    const bool ignoreNulls =
+        supportIgnoreNulls(signature.name) && vectorFuzzer_.coinToss(0.5);
+    const auto call =
+        makeFunctionCall(signature.name, argNames, false, false, ignoreNulls);
+
+    std::vector<SortingKeyAndOrder> sortingKeysAndOrders;
+    // 50% chance without order-by clause.
+    if (vectorFuzzer_.coinToss(0.5)) {
+      sortingKeysAndOrders =
+          generateSortingKeysAndOrders("s", argNames, argTypes);
+    }
+    const auto partitionKeys = generateSortingKeys("p", argNames, argTypes);
+    bool isRowsFrame = false;
+    const auto frameClause =
+        generateFrameClause(argNames, argTypes, isRowsFrame);
+    const auto input = generateInputDataWithRowNumber(
+        argNames, argTypes, partitionKeys, signature);
+    // If the function is order-dependent or uses "rows" frame, sort all input
+    // rows by row_number additionally.
+    if (requireSortedInput || isRowsFrame) {
+      sortingKeysAndOrders.emplace_back("row_number", core::kAscNullsLast);
+      ++stats_.numSortedInputs;
+    }
+
+    logVectors(input);
+
+    bool failed = verifyWindow(
+        partitionKeys,
+        sortingKeysAndOrders,
+        frameClause,
+        call,
+        input,
+        customVerification,
+        customVerifier,
+        FLAGS_enable_window_reference_verification);
+    if (failed) {
+      signatureWithStats.second.numFailed++;
+    }
+
+    LOG(INFO) << "==============================> Done with iteration "
+              << iteration;
+
+    if (persistAndRunOnce_) {
+      LOG(WARNING)
+          << "Iteration succeeded with --persist_and_run_once flag enabled "
+             "(expecting crash failure)";
+      exit(0);
+    }
+
+    reSeed();
+    ++iteration;
+  }
+
+  stats_.print(iteration);
+  printSignatureStats();
+}
+
+void WindowFuzzer::go(const std::string& /*planPath*/) {
+  // TODO: allow running window fuzzer with saved plans and splits.
+  VELOX_NYI();
+}
+
+void WindowFuzzer::testAlternativePlans(
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+    const std::string& frame,
+    const std::string& functionCall,
+    const std::vector<RowVectorPtr>& input,
+    bool customVerification,
+    const std::shared_ptr<ResultVerifier>& customVerifier,
+    const velox::fuzzer::ResultOrError& expected) {
+  std::vector<AggregationFuzzerBase::PlanWithSplits> plans;
+
+  std::vector<std::string> allKeys;
+  for (const auto& key : partitionKeys) {
+    allKeys.emplace_back(key + " NULLS FIRST");
+  }
+  for (const auto& keyAndOrder : sortingKeysAndOrders) {
+    allKeys.emplace_back(fmt::format(
+        "{} {}", keyAndOrder.key_, keyAndOrder.sortOrder_.toString()));
+  }
+
+  // Streaming window from values.
+  if (!allKeys.empty()) {
+    plans.push_back(
+        {PlanBuilder()
+             .values(input)
+             .orderBy(allKeys, false)
+             .streamingWindow(
+                 {fmt::format("{} over ({})", functionCall, frame)})
+             .planNode(),
+         {}});
+  }
+
+  // With TableScan.
+  auto directory = exec::test::TempDirectoryPath::create();
+  const auto inputRowType = asRowType(input[0]->type());
+  if (isTableScanSupported(inputRowType)) {
+    auto splits = makeSplits(input, directory->getPath(), writerPool_);
+
+// There is a known issue where LocalPartition will send DictionaryVectors
+// with the same underlying base Vector to multiple threads.  This triggers
+// TSAN to report data races, particularly if that base Vector is from the
+// TableScan and reused.  Don't run these tests when TSAN is enabled to avoid
+// the false negatives.
+#ifndef TSAN_BUILD
+    plans.push_back(
+        {PlanBuilder()
+             .tableScan(inputRowType)
+             .localPartition(partitionKeys)
+             .window({fmt::format("{} over ({})", functionCall, frame)})
+             .planNode(),
+         splits});
+#endif
+
+    if (!allKeys.empty()) {
+      plans.push_back(
+          {PlanBuilder()
+               .tableScan(inputRowType)
+               .orderBy(allKeys, false)
+               .streamingWindow(
+                   {fmt::format("{} over ({})", functionCall, frame)})
+               .planNode(),
+           splits});
+    }
+  }
+
+  for (const auto& plan : plans) {
+    testPlan(
+        plan, false, false, customVerification, {customVerifier}, expected);
+  }
+}
+
+namespace {
+void initializeVerifier(
+    const core::PlanNodePtr& plan,
+    const std::shared_ptr<ResultVerifier>& customVerifier,
+    const std::vector<RowVectorPtr>& input,
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+    const std::string& frame) {
+  const auto& windowNode =
+      std::dynamic_pointer_cast<const core::WindowNode>(plan);
+  customVerifier->initializeWindow(
+      input,
+      partitionKeys,
+      sortingKeysAndOrders,
+      windowNode->windowFunctions()[0],
+      frame,
+      "w0");
+}
+} // namespace
+
+bool WindowFuzzer::verifyWindow(
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+    const std::string& frameClause,
+    const std::string& functionCall,
+    const std::vector<RowVectorPtr>& input,
+    bool customVerification,
+    const std::shared_ptr<ResultVerifier>& customVerifier,
+    bool enableWindowVerification) {
+  SCOPE_EXIT {
+    if (customVerifier) {
+      customVerifier->reset();
+    }
+  };
+
+  auto frame = getFrame(partitionKeys, sortingKeysAndOrders, frameClause);
+  auto plan = PlanBuilder()
+                  .values(input)
+                  .window({fmt::format("{} over ({})", functionCall, frame)})
+                  .planNode();
+
+  if (persistAndRunOnce_) {
+    persistReproInfo({{plan, {}}}, reproPersistPath_);
+  }
+
+  velox::fuzzer::ResultOrError resultOrError;
+  try {
+    resultOrError = execute(plan);
+    if (resultOrError.exceptionPtr) {
+      ++stats_.numFailed;
+    }
+
+    if (!customVerification) {
+      if (resultOrError.result && enableWindowVerification) {
+        auto referenceResult =
+            computeReferenceResults(plan, input, referenceQueryRunner_.get());
+        stats_.updateReferenceQueryStats(referenceResult.second);
+        if (auto expectedResult = referenceResult.first) {
+          ++stats_.numVerified;
+          stats_.verifiedFunctionNames.insert(
+              retrieveWindowFunctionName(plan)[0]);
+          VELOX_CHECK(
+              assertEqualResults(
+                  expectedResult.value(),
+                  plan->outputType(),
+                  {resultOrError.result}),
+              "Velox and reference DB results don't match");
+          LOG(INFO) << "Verified results against reference DB";
+        }
+      }
+    } else {
+      LOG(INFO) << "Verification through custom verifier";
+      ++stats_.numVerificationSkipped;
+
+      if (customVerifier && resultOrError.result) {
+        VELOX_CHECK(
+            customVerifier->supportsVerify(),
+            "Window fuzzer only uses custom verify() methods.");
+        initializeVerifier(
+            plan,
+            customVerifier,
+            input,
+            partitionKeys,
+            sortingKeysAndOrders,
+            frame);
+        customVerifier->verify(resultOrError.result);
+      }
+    }
+
+    testAlternativePlans(
+        partitionKeys,
+        sortingKeysAndOrders,
+        frame,
+        functionCall,
+        input,
+        customVerification,
+        customVerifier,
+        resultOrError);
+
+    return resultOrError.exceptionPtr != nullptr;
+  } catch (...) {
+    if (!reproPersistPath_.empty()) {
+      persistReproInfo({{plan, {}}}, reproPersistPath_);
+    }
+    throw;
+  }
+}
+
+void windowFuzzer(
+    AggregateFunctionSignatureMap aggregationSignatureMap,
+    WindowFunctionMap windowSignatureMap,
+    size_t seed,
+    const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>&
+        customVerificationFunctions,
+    const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
+        customInputGenerators,
+    const std::unordered_set<std::string>& orderDependentFunctions,
+    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    const std::unordered_map<std::string, std::string>& queryConfigs,
+    const std::unordered_map<std::string, std::string>& hiveConfigs,
+    bool orderableGroupKeys,
+    const std::optional<std::string>& planPath,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
+  auto windowFuzzer = WindowFuzzer(
+      std::move(aggregationSignatureMap),
+      std::move(windowSignatureMap),
+      seed,
+      customVerificationFunctions,
+      customInputGenerators,
+      orderDependentFunctions,
+      timestampPrecision,
+      queryConfigs,
+      hiveConfigs,
+      orderableGroupKeys,
+      std::move(referenceQueryRunner));
+  planPath.has_value() ? windowFuzzer.go(planPath.value()) : windowFuzzer.go();
+}
+
+void WindowFuzzer::Stats::print(size_t numIterations) const {
+  AggregationFuzzerBase::Stats::print(numIterations);
+  LOG(INFO) << "Total functions verified in reference DB: "
+            << verifiedFunctionNames.size();
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/WindowFuzzer.h b/velox/exec/fuzzer/WindowFuzzer.h
new file mode 100644
index 0000000000000..227b4668c3c5d
--- /dev/null
+++ b/velox/exec/fuzzer/WindowFuzzer.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/WindowFunction.h"
+#include "velox/exec/fuzzer/AggregationFuzzerBase.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DECLARE_bool(enable_window_reference_verification);
+
+namespace facebook::velox::exec::test {
+
+class WindowFuzzer : public AggregationFuzzerBase {
+ public:
+  WindowFuzzer(
+      AggregateFunctionSignatureMap aggregationSignatureMap,
+      WindowFunctionMap windowSignatureMap,
+      size_t seed,
+      const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>&
+          customVerificationFunctions,
+      const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
+          customInputGenerators,
+      const std::unordered_set<std::string>& orderDependentFunctions,
+      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      const std::unordered_map<std::string, std::string>& queryConfigs,
+      const std::unordered_map<std::string, std::string>& hiveConfigs,
+      bool orderableGroupKeys,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner)
+      : AggregationFuzzerBase{seed, customVerificationFunctions, customInputGenerators, timestampPrecision, queryConfigs, hiveConfigs, orderableGroupKeys, std::move(referenceQueryRunner)},
+        orderDependentFunctions_{orderDependentFunctions} {
+    VELOX_CHECK(
+        !aggregationSignatureMap.empty() || !windowSignatureMap.empty(),
+        "No function signatures available.");
+
+    if (persistAndRunOnce_ && reproPersistPath_.empty()) {
+      std::cerr
+          << "--repro_persist_path must be specified if --persist_and_run_once is specified"
+          << std::endl;
+      exit(1);
+    }
+
+    // Presto doesn't allow complex-typed vectors with NULL elements to be
+    // partition keys, so we disable it for all inputs.
+    // TODO: allow complex-typed vectors with NULL elements as non-key columns.
+    if (dynamic_cast<PrestoQueryRunner*>(referenceQueryRunner_.get())) {
+      auto options = vectorFuzzer_.getOptions();
+      options.containerHasNulls = false;
+      vectorFuzzer_.setOptions(options);
+    }
+
+    addAggregationSignatures(aggregationSignatureMap);
+    addWindowFunctionSignatures(windowSignatureMap);
+    printStats(functionsStats);
+
+    sortCallableSignatures(signatures_);
+    sortSignatureTemplates(signatureTemplates_);
+
+    signatureStats_.resize(signatures_.size() + signatureTemplates_.size());
+  }
+
+  void go();
+  void go(const std::string& planPath);
+
+ private:
+  void addWindowFunctionSignatures(const WindowFunctionMap& signatureMap);
+
+  // Return a randomly generated frame clause string together with a boolean
+  // flag indicating whether it is a ROWS frame.
+  std::string generateFrameClause(
+      std::vector<std::string>& argNames,
+      std::vector<TypePtr>& argTypes,
+      bool& isRowsFrame);
+
+  std::string generateOrderByClause(
+      const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders);
+
+  std::string getFrame(
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+      const std::string& frameClause);
+
+  std::vector<SortingKeyAndOrder> generateSortingKeysAndOrders(
+      const std::string& prefix,
+      std::vector<std::string>& names,
+      std::vector<TypePtr>& types);
+
+  // Return 'true' if query plans failed.
+  bool verifyWindow(
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+      const std::string& frameClause,
+      const std::string& functionCall,
+      const std::vector<RowVectorPtr>& input,
+      bool customVerification,
+      const std::shared_ptr<ResultVerifier>& customVerifier,
+      bool enableWindowVerification);
+
+  void testAlternativePlans(
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+      const std::string& frame,
+      const std::string& functionCall,
+      const std::vector<RowVectorPtr>& input,
+      bool customVerification,
+      const std::shared_ptr<ResultVerifier>& customVerifier,
+      const velox::fuzzer::ResultOrError& expected);
+
+  const std::unordered_set<std::string> orderDependentFunctions_;
+
+  struct Stats : public AggregationFuzzerBase::Stats {
+    std::unordered_set<std::string> verifiedFunctionNames;
+
+    void print(size_t numIterations) const;
+  } stats_;
+};
+
+/// Runs the window fuzzer.
+/// @param aggregationSignatureMap Map of all aggregate function signatures.
+/// @param windowSignatureMap Map of all window function signatures.
+/// @param seed Random seed - Pass the same seed for reproducibility.
+/// @param orderDependentFunctions Map of functions that depend on order of
+/// input.
+/// @param planPath Path to persisted plan information. If this is
+/// supplied, fuzzer will only verify the plans.
+/// @param referenceQueryRunner Reference query runner for results
+/// verification.
+void windowFuzzer(
+    AggregateFunctionSignatureMap aggregationSignatureMap,
+    WindowFunctionMap windowSignatureMap,
+    size_t seed,
+    const std::unordered_map<std::string, std::shared_ptr<ResultVerifier>>&
+        customVerificationFunctions,
+    const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
+        customInputGenerators,
+    const std::unordered_set<std::string>& orderDependentFunctions,
+    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    const std::unordered_map<std::string, std::string>& queryConfigs,
+    const std::unordered_map<std::string, std::string>& hiveConfigs,
+    bool orderableGroupKeys,
+    const std::optional<std::string>& planPath,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/WindowFuzzerRunner.h b/velox/exec/fuzzer/WindowFuzzerRunner.h
new file mode 100644
index 0000000000000..46bdc73635840
--- /dev/null
+++ b/velox/exec/fuzzer/WindowFuzzerRunner.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/String.h>
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/fuzzer/AggregationFuzzerOptions.h"
+#include "velox/exec/fuzzer/WindowFuzzer.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+class WindowFuzzerRunner {
+ public:
+  static int run(
+      size_t seed,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner,
+      const AggregationFuzzerOptions& options) {
+    return runFuzzer(
+        seed, std::nullopt, std::move(referenceQueryRunner), options);
+  }
+
+  static int runRepro(
+      const std::optional<std::string>& planPath,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
+    return runFuzzer(0, planPath, std::move(referenceQueryRunner), {});
+  }
+
+ protected:
+  static int runFuzzer(
+      size_t seed,
+      const std::optional<std::string>& planPath,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner,
+      const AggregationFuzzerOptions& options) {
+    auto aggregationSignatures =
+        facebook::velox::exec::getAggregateFunctionSignatures();
+    auto windowSignatures = facebook::velox::exec::windowFunctions();
+    if (aggregationSignatures.empty() && windowSignatures.empty()) {
+      LOG(ERROR) << "No function registered.";
+      exit(1);
+    }
+
+    auto filteredAggregationSignatures = velox::fuzzer::filterSignatures(
+        aggregationSignatures, options.onlyFunctions, options.skipFunctions);
+    auto filteredWindowSignatures = velox::fuzzer::filterSignatures(
+        windowSignatures, options.onlyFunctions, options.skipFunctions);
+    if (filteredAggregationSignatures.empty() &&
+        filteredWindowSignatures.empty()) {
+      LOG(ERROR)
+          << "No function left after filtering using 'only' and 'skip' lists.";
+      exit(1);
+    }
+
+    facebook::velox::parse::registerTypeResolver();
+    facebook::velox::serializer::presto::PrestoVectorSerde::
+        registerVectorSerde();
+    facebook::velox::filesystems::registerLocalFileSystem();
+
+    facebook::velox::exec::test::windowFuzzer(
+        filteredAggregationSignatures,
+        filteredWindowSignatures,
+        seed,
+        options.customVerificationFunctions,
+        options.customInputGenerators,
+        options.orderDependentFunctions,
+        options.timestampPrecision,
+        options.queryConfigs,
+        options.hiveConfigs,
+        options.orderableGroupKeys,
+        planPath,
+        std::move(referenceQueryRunner));
+    // Calling gtest here so that it can be recognized as tests in CI systems.
+    return RUN_ALL_TESTS();
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/WriterFuzzer.cpp b/velox/exec/fuzzer/WriterFuzzer.cpp
new file mode 100644
index 0000000000000..f6b58411d18f7
--- /dev/null
+++ b/velox/exec/fuzzer/WriterFuzzer.cpp
@@ -0,0 +1,759 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/fuzzer/WriterFuzzer.h"
+
+#include <boost/random/uniform_int_distribution.hpp>
+
+#include <re2/re2.h>
+#include <unordered_set>
+#include "velox/common/base/Fs.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/VectorSaver.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int32(steps, 10, "Number of plans to generate and test.");
+
+DEFINE_int32(
+    duration_sec,
+    0,
+    "For how long it should run (in seconds). If zero, "
+    "it executes exactly --steps iterations and exits.");
+
+DEFINE_int32(
+    batch_size,
+    100,
+    "The number of elements on each generated vector.");
+
+DEFINE_int32(num_batches, 10, "The number of generated vectors.");
+
+DEFINE_double(
+    null_ratio,
+    0.1,
+    "Chance of adding a null value in a vector "
+    "(expressed as double from 0 to 1).");
+
+using namespace facebook::velox::connector::hive;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::exec::test {
+
+namespace {
+
+class WriterFuzzer {
+ public:
+  WriterFuzzer(
+      size_t seed,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
+
+  void go();
+
+ private:
+  static VectorFuzzer::Options getFuzzerOptions() {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = FLAGS_batch_size;
+    opts.stringLength = 10;
+    opts.nullRatio = FLAGS_null_ratio;
+    opts.timestampPrecision =
+        VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+    return opts;
+  }
+
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    vectorFuzzer_.reSeed(seed);
+    rng_.seed(currentSeed_);
+  }
+
+  void reSeed() {
+    seed(rng_());
+  }
+
+  // Generates at least one and up to maxNumColumns columns to be
+  // used as columns of table write.
+  // Column names are generated using template '<prefix>N', where N is
+  // zero-based ordinal number of the column.
+  // Data types is chosen from '<columnTypes>' and for nested complex data type,
+  // maxDepth limits the max layers of nesting.
+  std::vector<std::string> generateColumns(
+      int32_t maxNumColumns,
+      const std::string& prefix,
+      const std::vector<TypePtr>& dataTypes,
+      int32_t maxDepth,
+      std::vector<std::string>& names,
+      std::vector<TypePtr>& types);
+
+  // Generates input data for table write.
+  std::vector<RowVectorPtr> generateInputData(
+      std::vector<std::string> names,
+      std::vector<TypePtr> types,
+      size_t partitionOffset);
+
+  void verifyWriter(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& names,
+      const std::vector<TypePtr>& types,
+      int32_t partitionOffset,
+      const std::vector<std::string>& partitionKeys,
+      int32_t bucketCount,
+      const std::vector<std::string>& bucketColumns,
+      int32_t sortColumnOffset,
+      const std::vector<std::shared_ptr<const HiveSortingColumn>>& sortBy,
+      const std::string& outputDirectoryPath);
+
+  // Generates table column handles based on table column properties
+  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+  getTableColumnHandles(
+      const std::vector<std::string>& names,
+      const std::vector<TypePtr>& types,
+      int32_t partitionOffset,
+      const int32_t bucketCount);
+
+  // Executes velox query plan and returns the result.
+  RowVectorPtr execute(
+      const core::PlanNodePtr& plan,
+      const int32_t maxDrivers = 2,
+      const std::vector<exec::Split>& splits = {});
+
+  RowVectorPtr veloxToPrestoResult(const RowVectorPtr& result);
+
+  // Query Presto to find out table's location on disk.
+  std::string getReferenceOutputDirectoryPath(int32_t layers);
+
+  // Compares if two directories have same partitions and each partition has
+  // same number of buckets.
+  void comparePartitionAndBucket(
+      const std::string& outputDirectoryPath,
+      const std::string& referenceOutputDirectoryPath,
+      int32_t bucketCount);
+
+  // Returns all the partition name and how many files in each partition.
+  std::map<std::string, int32_t> getPartitionNameAndFilecount(
+      const std::string& tableDirectoryPath);
+
+  // Generates output data type based on table column properties.
+  RowTypePtr generateOutputType(
+      const std::vector<std::string>& names,
+      const std::vector<TypePtr>& types,
+      const int32_t bucketCount);
+
+  // Generates a sql that reads sorted columns from a single split of a bucketed
+  // and sorted table.
+  // For example, for a table sorted by age, reading a split that belongs to ds
+  // = 2022-01-01 and bucket 1:
+  // SELECT age FROM temp_write where ds = '2022-01-01' and "$bucket" = 1
+  std::string sortSql(
+      const std::shared_ptr<HiveConnectorSplit>& split,
+      const std::vector<std::string>& names,
+      const std::vector<TypePtr>& types,
+      int32_t partitionOffset,
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<std::shared_ptr<const HiveSortingColumn>>& sortBy);
+
+  // When concatenating a partition value, if it's non-varchar, no change, eg:
+  // age = 10
+  // If it's varchar, we need to add single quote and also escape the single
+  // quote in partition value, eg:
+  // city = '''SF'''
+  std::string partitionToSql(const TypePtr& type, std::string partitionValue);
+
+  const std::vector<TypePtr> kRegularColumnTypes_{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      VARCHAR(),
+      VARBINARY(),
+      TIMESTAMP(),
+  };
+
+  // Supported sorted column types:
+  const std::vector<TypePtr> kSupportedSortColumnTypes_{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      VARCHAR(),
+      TIMESTAMP(),
+  };
+
+  // Supported order types:
+  // https://github.com/prestodb/presto/blob/c542429ba989887de6208daaed4d7b4e34b49b3b/presto-hive-metastore/src/main/java/com/facebook/presto/hive/metastore/SortingColumn.java#L101
+  // ASCENDING(ASC_NULLS_FIRST, 1),
+  // DESCENDING(DESC_NULLS_LAST, 0);
+  const std::vector<core::SortOrder> kSortOrderTypes_{
+      core::SortOrder{true, true},
+      core::SortOrder{false, false},
+  };
+
+  // Supported bucket column types:
+  // https://github.com/prestodb/presto/blob/10143be627beb2c61aba5b3d36af473d2a8ef65e/presto-hive/src/main/java/com/facebook/presto/hive/HiveBucketing.java#L133
+  const std::vector<TypePtr> kSupportedBucketColumnTypes_{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      VARCHAR(),
+      TIMESTAMP(),
+  };
+
+  // Supported partition key column types
+  // According to VectorHasher::typeKindSupportsValueIds and
+  // https://github.com/prestodb/presto/blob/10143be627beb2c61aba5b3d36af473d2a8ef65e/presto-hive/src/main/java/com/facebook/presto/hive/HiveUtil.java#L593
+  const std::vector<TypePtr> kPartitionKeyTypes_{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      VARCHAR()};
+
+  FuzzerGenerator rng_;
+  size_t currentSeed_{0};
+  std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner_;
+  std::shared_ptr<memory::MemoryPool> rootPool_{
+      memory::memoryManager()->addRootPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild("leaf")};
+  std::shared_ptr<memory::MemoryPool> writerPool_{
+      rootPool_->addAggregateChild("writerFuzzerWriter")};
+  VectorFuzzer vectorFuzzer_;
+};
+} // namespace
+
+void writerFuzzer(
+    size_t seed,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
+  auto writerFuzzer = WriterFuzzer(seed, std::move(referenceQueryRunner));
+  writerFuzzer.go();
+}
+
+std::vector<std::string> listFolders(std::string_view path) {
+  std::vector<std::string> folders;
+  auto fileSystem = filesystems::getFileSystem("/", nullptr);
+  for (auto& p : std::filesystem::recursive_directory_iterator(
+           fileSystem->extractPath(path))) {
+    if (p.is_directory())
+      folders.push_back(p.path().string());
+  }
+  return folders;
+}
+
+namespace {
+template <typename T>
+bool isDone(size_t i, T startTime) {
+  if (FLAGS_duration_sec > 0) {
+    std::chrono::duration<double> elapsed =
+        std::chrono::system_clock::now() - startTime;
+    return elapsed.count() >= FLAGS_duration_sec;
+  }
+  return i >= FLAGS_steps;
+}
+
+WriterFuzzer::WriterFuzzer(
+    size_t initialSeed,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner)
+    : referenceQueryRunner_{std::move(referenceQueryRunner)},
+      vectorFuzzer_{getFuzzerOptions(), pool_.get()} {
+  seed(initialSeed);
+}
+
+void WriterFuzzer::go() {
+  VELOX_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+
+  auto startTime = std::chrono::system_clock::now();
+  size_t iteration = 0;
+
+  while (!isDone(iteration, startTime)) {
+    LOG(INFO) << "==============================> Started iteration "
+              << iteration << " (seed: " << currentSeed_ << ")";
+
+    std::vector<std::string> names;
+    std::vector<TypePtr> types;
+    int32_t partitionOffset = 0;
+    std::vector<std::string> partitionKeys;
+    int32_t bucketCount = 0;
+    std::vector<std::string> bucketColumns;
+    int32_t sortColumnOffset = 0;
+    std::vector<std::shared_ptr<const HiveSortingColumn>> sortBy;
+
+    // Regular table columns
+    generateColumns(5, "c", kRegularColumnTypes_, 2, names, types);
+
+    // 50% of times test partitioned write.
+    if (vectorFuzzer_.coinToss(0.5)) {
+      // 50% of times test bucketed write.
+      if (vectorFuzzer_.coinToss(0.5)) {
+        bucketColumns = generateColumns(
+            5, "b", kSupportedBucketColumnTypes_, 1, names, types);
+        bucketCount =
+            boost::random::uniform_int_distribution<int32_t>(1, 3)(rng_);
+
+        // TODO: sort columns can overlap as bucket columns
+        // 50% of times test ordered write.
+        if (vectorFuzzer_.coinToss(0.5)) {
+          sortColumnOffset = names.size();
+          auto sortColumns = generateColumns(
+              3, "s", kSupportedSortColumnTypes_, 1, names, types);
+          sortBy.reserve(sortColumns.size());
+          for (const auto& sortByColumn : sortColumns) {
+            sortBy.push_back(std::make_shared<const HiveSortingColumn>(
+                sortByColumn,
+                kSortOrderTypes_.at(
+                    boost::random::uniform_int_distribution<uint32_t>(
+                        0, 1)(rng_))));
+          }
+        }
+      }
+
+      partitionOffset = names.size();
+      partitionKeys =
+          generateColumns(3, "p", kPartitionKeyTypes_, 1, names, types);
+    }
+    auto input = generateInputData(names, types, partitionOffset);
+
+    auto tempDirPath = exec::test::TempDirectoryPath::create();
+    verifyWriter(
+        input,
+        names,
+        types,
+        partitionOffset,
+        partitionKeys,
+        bucketCount,
+        bucketColumns,
+        sortColumnOffset,
+        sortBy,
+        tempDirPath->getPath());
+
+    LOG(INFO) << "==============================> Done with iteration "
+              << iteration++;
+    reSeed();
+  }
+}
+
+std::vector<std::string> WriterFuzzer::generateColumns(
+    int32_t maxNumColumns,
+    const std::string& prefix,
+    const std::vector<TypePtr>& dataTypes,
+    int32_t maxDepth,
+    std::vector<std::string>& names,
+    std::vector<TypePtr>& types) {
+  const auto numColumns =
+      boost::random::uniform_int_distribution<uint32_t>(1, maxNumColumns)(rng_);
+  std::vector<std::string> columns;
+  for (auto i = 0; i < numColumns; ++i) {
+    columns.push_back(fmt::format("{}{}", prefix, i));
+
+    // Pick random, possibly complex, type.
+    types.push_back(vectorFuzzer_.randType(dataTypes, maxDepth));
+    names.push_back(columns.back());
+  }
+  return columns;
+}
+
+std::vector<RowVectorPtr> WriterFuzzer::generateInputData(
+    std::vector<std::string> names,
+    std::vector<TypePtr> types,
+    size_t partitionOffset) {
+  const auto size = vectorFuzzer_.getOptions().vectorSize;
+  auto inputType = ROW(std::move(names), std::move(types));
+  std::vector<RowVectorPtr> input;
+
+  // For partition keys, limit the distinct value to 4. Since we could have up
+  // to 3 partition keys, it would generate up to 64 partitions.
+  std::vector<VectorPtr> partitionValues;
+  for (auto i = partitionOffset; i < inputType->size(); ++i) {
+    partitionValues.push_back(vectorFuzzer_.fuzz(inputType->childAt(i), 4));
+  }
+
+  for (auto i = 0; i < FLAGS_num_batches; ++i) {
+    std::vector<VectorPtr> children;
+    for (auto j = children.size(); j < inputType->size(); ++j) {
+      if (j < partitionOffset) {
+        // For regular columns.
+        children.push_back(vectorFuzzer_.fuzz(inputType->childAt(j), size));
+      } else {
+        // TODO Add other encoding support here besides DictionaryVector.
+        children.push_back(vectorFuzzer_.fuzzDictionary(
+            partitionValues.at(j - partitionOffset), size));
+      }
+    }
+    input.push_back(std::make_shared<RowVector>(
+        pool_.get(), inputType, nullptr, size, std::move(children)));
+  }
+
+  return input;
+}
+
+void WriterFuzzer::verifyWriter(
+    const std::vector<RowVectorPtr>& input,
+    const std::vector<std::string>& names,
+    const std::vector<TypePtr>& types,
+    const int32_t partitionOffset,
+    const std::vector<std::string>& partitionKeys,
+    const int32_t bucketCount,
+    const std::vector<std::string>& bucketColumns,
+    const int32_t sortColumnOffset,
+    const std::vector<std::shared_ptr<const HiveSortingColumn>>& sortBy,
+    const std::string& outputDirectoryPath) {
+  const auto plan = PlanBuilder()
+                        .values(input)
+                        .tableWrite(
+                            outputDirectoryPath,
+                            partitionKeys,
+                            bucketCount,
+                            bucketColumns,
+                            sortBy)
+                        .planNode();
+
+  const auto maxDrivers =
+      boost::random::uniform_int_distribution<int32_t>(1, 16)(rng_);
+  const auto result = veloxToPrestoResult(execute(plan, maxDrivers));
+
+  const auto dropSql = "DROP TABLE IF EXISTS tmp_write";
+  const auto sql = referenceQueryRunner_->toSql(plan).value();
+  std::multiset<std::vector<variant>> expectedResult;
+  try {
+    referenceQueryRunner_->execute(dropSql);
+    expectedResult =
+        referenceQueryRunner_->execute(sql, input, plan->outputType());
+  } catch (...) {
+    LOG(WARNING) << "Query failed in the reference DB";
+    return;
+  }
+
+  // 1. Verifies the table writer output result: the inserted number of rows.
+  VELOX_CHECK_EQ(
+      expectedResult.size(), // Presto sql only produces one row which is how
+                             // many rows are inserted.
+      1,
+      "Query returned unexpected result in the reference DB");
+  VELOX_CHECK(
+      assertEqualResults(expectedResult, plan->outputType(), {result}),
+      "Velox and reference DB results don't match");
+
+  // 2. Verifies directory layout for partitioned (bucketed) table.
+  if (!partitionKeys.empty()) {
+    const auto referencedOutputDirectoryPath =
+        getReferenceOutputDirectoryPath(partitionKeys.size());
+    comparePartitionAndBucket(
+        outputDirectoryPath, referencedOutputDirectoryPath, bucketCount);
+  }
+
+  // 3. Verifies data itself.
+  auto splits = makeSplits(outputDirectoryPath);
+  auto columnHandles =
+      getTableColumnHandles(names, types, partitionOffset, bucketCount);
+  const auto rowType = generateOutputType(names, types, bucketCount);
+
+  auto readPlan = PlanBuilder()
+                      .tableScan(rowType, {}, "", rowType, columnHandles)
+                      .planNode();
+  auto actual = execute(readPlan, maxDrivers, splits);
+  std::string bucketSql = "";
+  if (bucketCount > 0) {
+    bucketSql = ", \"$bucket\"";
+  }
+  try {
+    auto referenceData = referenceQueryRunner_->execute(
+        "SELECT *" + bucketSql + " FROM tmp_write");
+    VELOX_CHECK(
+        assertEqualResults(referenceData, {actual}),
+        "Velox and reference DB results don't match");
+  } catch (...) {
+    LOG(WARNING) << "Query failed in the reference DB";
+    return;
+  }
+
+  // 4. Verifies sorting.
+  if (sortBy.size() > 0) {
+    const std::vector<std::string> sortColumnNames = {
+        names.begin() + sortColumnOffset,
+        names.begin() + sortColumnOffset + sortBy.size()};
+    const std::vector<TypePtr> sortColumnTypes = {
+        types.begin() + sortColumnOffset,
+        types.begin() + sortColumnOffset + sortBy.size()};
+
+    // Read from each file and check if data is sorted as presto sorted result.
+    for (const auto& split : splits) {
+      auto splitReadPlan = PlanBuilder()
+                               .tableScan(generateOutputType(
+                                   sortColumnNames, sortColumnTypes, 0))
+                               .planNode();
+      auto singleSplitData = execute(splitReadPlan, 1, {split});
+
+      auto const singleSplitReferenceSql = sortSql(
+          std::dynamic_pointer_cast<HiveConnectorSplit>(split.connectorSplit),
+          names,
+          types,
+          partitionOffset,
+          partitionKeys,
+          sortBy);
+
+      std::vector<velox::RowVectorPtr> referenceResult;
+      try {
+        referenceResult = referenceQueryRunner_->execute(
+            singleSplitReferenceSql, "task_concurrency=1");
+      } catch (...) {
+        LOG(WARNING) << "Query failed in the reference DB";
+        return;
+      }
+      const auto& referenceData = referenceResult.at(0);
+      for (int i = 1; i < referenceResult.size(); ++i) {
+        referenceData->append(referenceResult.at(i).get());
+      }
+      fuzzer::compareVectors(
+          singleSplitData, referenceData, "velox", "prestoDB");
+      LOG(INFO) << "Sort Verification succeed for split: "
+                << split.connectorSplit->toString();
+    }
+  }
+
+  LOG(INFO) << "Verified results against reference DB";
+}
+
+std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+WriterFuzzer::getTableColumnHandles(
+    const std::vector<std::string>& names,
+    const std::vector<TypePtr>& types,
+    const int32_t partitionOffset,
+    const int32_t bucketCount) {
+  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+      columnHandle;
+  for (int i = 0; i < names.size(); ++i) {
+    HiveColumnHandle::ColumnType columnType;
+    if (i < partitionOffset) {
+      columnType = HiveColumnHandle::ColumnType::kRegular;
+    } else {
+      columnType = HiveColumnHandle::ColumnType::kPartitionKey;
+    }
+    columnHandle.insert(
+        {names.at(i),
+         std::make_shared<HiveColumnHandle>(
+             names.at(i), columnType, types.at(i), types.at(i))});
+  }
+  // If table is bucketed, add synthesized $bucket column.
+  if (bucketCount > 0) {
+    columnHandle.insert(
+        {"$bucket",
+         std::make_shared<HiveColumnHandle>(
+             "$bucket",
+             HiveColumnHandle::ColumnType::kSynthesized,
+             INTEGER(),
+             INTEGER())});
+  }
+  return columnHandle;
+}
+
+RowVectorPtr WriterFuzzer::execute(
+    const core::PlanNodePtr& plan,
+    const int32_t maxDrivers,
+    const std::vector<exec::Split>& splits) {
+  LOG(INFO) << "Executing query plan: " << std::endl
+            << plan->toString(true, true);
+  fuzzer::ResultOrError resultOrError;
+  AssertQueryBuilder builder(plan);
+  if (!splits.empty()) {
+    builder.splits(splits);
+  }
+  return builder.maxDrivers(maxDrivers)
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kMaxPartitionsPerWritersSession,
+          "400")
+      .copyResults(pool_.get());
+}
+
+RowVectorPtr WriterFuzzer::veloxToPrestoResult(const RowVectorPtr& result) {
+  // Velox TableWrite node produces results of following layout
+  // row     fragments     context
+  // X         null          X
+  // null       X            X
+  // null       X            X
+  // Extract inserted rows from velox execution result.
+  std::vector<VectorPtr> insertedRows = {result->childAt(0)->slice(0, 1)};
+  return std::make_shared<RowVector>(
+      pool_.get(),
+      ROW({"count"}, {insertedRows[0]->type()}),
+      nullptr,
+      1,
+      insertedRows);
+}
+
+std::string WriterFuzzer::getReferenceOutputDirectoryPath(int32_t layers) {
+  auto filePath =
+      referenceQueryRunner_->execute("SELECT \"$path\" FROM tmp_write");
+  auto tableDirectoryPath =
+      fs::path(extractSingleValue<StringView>(filePath)).parent_path();
+  while (layers-- > 0) {
+    tableDirectoryPath = tableDirectoryPath.parent_path();
+  }
+  return tableDirectoryPath.string();
+}
+
+void WriterFuzzer::comparePartitionAndBucket(
+    const std::string& outputDirectoryPath,
+    const std::string& referenceOutputDirectoryPath,
+    int32_t bucketCount) {
+  LOG(INFO) << "Velox output directory:" << outputDirectoryPath << std::endl;
+  const auto partitionNameAndFileCount =
+      getPartitionNameAndFilecount(outputDirectoryPath);
+  LOG(INFO) << "Partitions and file count:" << std::endl;
+  std::vector<std::string> partitionNames;
+  partitionNames.reserve(partitionNameAndFileCount.size());
+  for (const auto& i : partitionNameAndFileCount) {
+    LOG(INFO) << i.first << ":" << i.second << std::endl;
+    partitionNames.emplace_back(i.first);
+  }
+
+  LOG(INFO) << "Presto output directory:" << referenceOutputDirectoryPath
+            << std::endl;
+  const auto referencedPartitionNameAndFileCount =
+      getPartitionNameAndFilecount(referenceOutputDirectoryPath);
+  LOG(INFO) << "Partitions and file count:" << std::endl;
+  std::vector<std::string> referencePartitionNames;
+  referencePartitionNames.reserve(referencedPartitionNameAndFileCount.size());
+  for (const auto& i : referencedPartitionNameAndFileCount) {
+    LOG(INFO) << i.first << ":" << i.second << std::endl;
+    referencePartitionNames.emplace_back(i.first);
+  }
+
+  if (bucketCount == 0) {
+    // If not bucketed, only verify if their partition names match
+    VELOX_CHECK(
+        partitionNames == referencePartitionNames,
+        "Velox and reference DB output partitions don't match");
+  } else {
+    VELOX_CHECK(
+        partitionNameAndFileCount == referencedPartitionNameAndFileCount,
+        "Velox and reference DB output partition and bucket don't match");
+  }
+}
+
+// static
+std::map<std::string, int32_t> WriterFuzzer::getPartitionNameAndFilecount(
+    const std::string& tableDirectoryPath) {
+  auto fileSystem = filesystems::getFileSystem("/", nullptr);
+  auto directories = listFolders(tableDirectoryPath);
+  std::map<std::string, int32_t> partitionNameAndFileCount;
+
+  for (std::string directory : directories) {
+    // If it's a hidden directory, ignore
+    if (directory.find("/.") != std::string::npos) {
+      continue;
+    }
+
+    // Count non-empty non-hidden files
+    const auto files = fileSystem->list(directory);
+    int32_t fileCount = 0;
+    for (const auto& file : files) {
+      // Presto query runner sometime creates empty files, ignore those.
+      if (file.find("/.") == std::string::npos &&
+          fileSystem->openFileForRead(file)->size() > 0) {
+        fileCount++;
+      }
+    }
+
+    // Remove the path prefix to get the partition name
+    // For example: /test/tmp_write/p0=1/p1=2020
+    // partition name is /p0=1/p1=2020
+    directory.erase(0, fileSystem->extractPath(tableDirectoryPath).length());
+
+    partitionNameAndFileCount.emplace(directory, fileCount);
+  }
+
+  return partitionNameAndFileCount;
+}
+
+RowTypePtr WriterFuzzer::generateOutputType(
+    const std::vector<std::string>& names,
+    const std::vector<TypePtr>& types,
+    const int32_t bucketCount) {
+  std::vector<std::string> outputNames{names};
+  std::vector<TypePtr> outputTypes;
+  for (auto type : types) {
+    outputTypes.emplace_back(type);
+  }
+  if (bucketCount > 0) {
+    outputNames.emplace_back("$bucket");
+    outputTypes.emplace_back(INTEGER());
+  }
+
+  return {ROW(std::move(outputNames), std::move(outputTypes))};
+}
+
+std::string WriterFuzzer::sortSql(
+    const std::shared_ptr<HiveConnectorSplit>& split,
+    const std::vector<std::string>& names,
+    const std::vector<TypePtr>& types,
+    int32_t partitionOffset,
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<std::shared_ptr<const HiveSortingColumn>>& sortBy) {
+  // For a split, extract the partition filters and bucket filters.
+  std::stringstream whereSql;
+  whereSql << "WHERE ";
+  for (int i = partitionOffset; i < partitionOffset + partitionKeys.size();
+       ++i) {
+    const auto& partitionKey = names.at(i);
+    auto partitionValue = split->partitionKeys.at(partitionKey);
+    if (partitionValue.has_value()) {
+      whereSql << partitionKey << " = "
+               << partitionToSql(types.at(i), partitionValue.value());
+    } else {
+      whereSql << partitionKey << " IS NULL";
+    }
+    whereSql << " AND ";
+  }
+  whereSql << "\"$bucket\" = " << split->tableBucketNumber.value();
+
+  std::stringstream selectedColumns;
+  for (int i = 0; i < sortBy.size(); ++i) {
+    if (i > 0) {
+      selectedColumns << ", ";
+    }
+    selectedColumns << sortBy.at(i)->sortColumn();
+  }
+  return "SELECT " + selectedColumns.str() + " FROM tmp_write " +
+      whereSql.str();
+}
+
+std::string WriterFuzzer::partitionToSql(
+    const TypePtr& type,
+    std::string partitionValue) {
+  if (type->isVarchar()) {
+    RE2::GlobalReplace(&partitionValue, "'", "''");
+    return "'" + partitionValue + "'";
+  }
+  return partitionValue;
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/WriterFuzzer.h b/velox/exec/fuzzer/WriterFuzzer.h
new file mode 100644
index 0000000000000..0c5bd2c585ae8
--- /dev/null
+++ b/velox/exec/fuzzer/WriterFuzzer.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DECLARE_bool(enable_window_reference_verification);
+
+namespace facebook::velox::exec::test {
+/// Runs the writer fuzzer.
+/// @param seed Random seed - Pass the same seed for reproducibility.
+/// @param referenceQueryRunner Reference query runner for results
+/// verification.
+void writerFuzzer(
+    size_t seed,
+    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
+
+/// Returns all the folders in a local fs path recursively.
+std::vector<std::string> listFolders(std::string_view path);
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/WriterFuzzerRunner.h b/velox/exec/fuzzer/WriterFuzzerRunner.h
new file mode 100644
index 0000000000000..a5f45a32fc61b
--- /dev/null
+++ b/velox/exec/fuzzer/WriterFuzzerRunner.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/String.h>
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/WriterFuzzer.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+/// WriterFuzzerRunner leverages WriterFuzzer and VectorFuzzer to
+/// automatically generate and execute table writer tests.
+/// It works in following steps:
+///
+///  1. Pick different table write properties. Eg: partitioned, bucketed,
+///  sorted.
+///  2. Generate corresponding table write query plan.
+///  3. Generate a random set of input data (vector).
+///  4. Execute the query plan.
+///  5. Generate corresponding sql in reference DB and execute the sql.
+///  6. Assert results from step 4 and 5 are the same.
+///  7. Rinse and repeat.
+///
+/// The common usage pattern is as following:
+///
+///  $ ./velox_writer_fuzzer_test --steps 10000
+///
+/// The important flags that control WriterFuzzer's behavior are:
+///
+///  --steps: how many iterations to run.
+///  --duration_sec: alternatively, for how many seconds it should run (takes
+///          precedence over --steps).
+///  --seed: pass a deterministic seed to reproduce the behavior (each iteration
+///          will print a seed as part of the logs).
+///  --batch_size: size of input vector batches generated.
+///
+/// e.g:
+///
+///  $ ./velox_writer_fuzzer_test \
+///         --steps 10000 \
+///         --seed 123
+
+class WriterFuzzerRunner {
+ public:
+  static int run(
+      size_t seed,
+      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
+    filesystems::registerLocalFileSystem();
+    auto hiveConnector =
+        connector::getConnectorFactory(
+            connector::hive::HiveConnectorFactory::kHiveConnectorName)
+            ->newConnector(
+                kHiveConnectorId,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
+    connector::registerConnector(hiveConnector);
+    facebook::velox::exec::test::writerFuzzer(
+        seed, std::move(referenceQueryRunner));
+    // Calling gtest here so that it can be recognized as tests in CI systems.
+    return RUN_ALL_TESTS();
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/prefixsort/CMakeLists.txt b/velox/exec/prefixsort/CMakeLists.txt
new file mode 100644
index 0000000000000..aac7db501ecdb
--- /dev/null
+++ b/velox/exec/prefixsort/CMakeLists.txt
@@ -0,0 +1,23 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+elseif(${VELOX_BUILD_TEST_UTILS})
+  add_subdirectory(tests/utils)
+endif()
+
+if(${VELOX_ENABLE_BENCHMARKS})
+  add_subdirectory(benchmarks)
+endif()
diff --git a/velox/exec/prefixsort/PrefixSortAlgorithm.h b/velox/exec/prefixsort/PrefixSortAlgorithm.h
new file mode 100644
index 0000000000000..385a449c3509e
--- /dev/null
+++ b/velox/exec/prefixsort/PrefixSortAlgorithm.h
@@ -0,0 +1,353 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/SimdUtil.h"
+
+namespace facebook::velox::exec::prefixsort {
+
+namespace detail {
+/// Provides LegacyRandomAccessIterator but not ValueSwappable semantic
+/// iterator for PrefixSort`s sort algorithm, see:
+/// https://en.cppreference.com/w/cpp/algorithm/sort
+/// https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator
+/// https://en.cppreference.com/w/cpp/named_req/ValueSwappable
+/// The difference is operator*(), the LegacyInputIterator return "reference,
+/// convertible to value_type", see:
+/// https://en.cppreference.com/w/cpp/named_req/InputIterator
+/// In contrast, PrefixSortIterator returns char* point to the prefix data
+/// (not a "value_type" but a memory buffer store normalized keys) for memcmp
+/// and memcpy operators, means not ValueSwappable.
+/// This is also the reason we can not use std::sort directly, and implement
+/// quickSort in PrefixSortRunner.
+class PrefixSortIterator {
+ public:
+  PrefixSortIterator(char* prefix, const uint64_t entrySize)
+      : entrySize_(entrySize), prefix_(prefix) {}
+
+  PrefixSortIterator(const PrefixSortIterator& other)
+      : entrySize_(other.entrySize_), prefix_(other.prefix_) {}
+
+  // Inline functions should be placed in header file to avoid link error.
+  FOLLY_ALWAYS_INLINE char* operator*() const {
+    return prefix_;
+  }
+
+  FOLLY_ALWAYS_INLINE PrefixSortIterator& operator++() {
+    prefix_ += entrySize_;
+    return *this;
+  }
+
+  FOLLY_ALWAYS_INLINE PrefixSortIterator& operator--() {
+    prefix_ -= entrySize_;
+    return *this;
+  }
+
+  FOLLY_ALWAYS_INLINE PrefixSortIterator operator++(int) {
+    const auto tmp = *this;
+    prefix_ += entrySize_;
+    return tmp;
+  }
+
+  FOLLY_ALWAYS_INLINE PrefixSortIterator operator--(int) {
+    const auto tmp = *this;
+    prefix_ -= entrySize_;
+    return tmp;
+  }
+
+  FOLLY_ALWAYS_INLINE PrefixSortIterator operator+(const uint64_t i) const {
+    auto result = *this;
+    result.prefix_ += i * entrySize_;
+    return result;
+  }
+
+  FOLLY_ALWAYS_INLINE PrefixSortIterator operator-(const uint64_t i) const {
+    PrefixSortIterator result = *this;
+    result.prefix_ -= i * entrySize_;
+    return result;
+  }
+
+  FOLLY_ALWAYS_INLINE PrefixSortIterator& operator=(
+      const PrefixSortIterator& other) {
+    prefix_ = other.prefix_;
+    return *this;
+  }
+
+  FOLLY_ALWAYS_INLINE uint64_t
+  operator-(const PrefixSortIterator& other) const {
+    return (prefix_ - other.prefix_) / other.entrySize_;
+  }
+
+  FOLLY_ALWAYS_INLINE bool operator<(const PrefixSortIterator& other) const {
+    return prefix_ < other.prefix_;
+  }
+
+  FOLLY_ALWAYS_INLINE bool operator>(const PrefixSortIterator& other) const {
+    return prefix_ > other.prefix_;
+  }
+
+  FOLLY_ALWAYS_INLINE bool operator>=(const PrefixSortIterator& other) const {
+    return prefix_ >= other.prefix_;
+  }
+
+  FOLLY_ALWAYS_INLINE bool operator<=(const PrefixSortIterator& other) const {
+    return prefix_ <= other.prefix_;
+  }
+
+  FOLLY_ALWAYS_INLINE bool operator==(const PrefixSortIterator& other) const {
+    return prefix_ == other.prefix_;
+  }
+
+  FOLLY_ALWAYS_INLINE bool operator!=(const PrefixSortIterator& other) const {
+    return prefix_ != other.prefix_;
+  }
+
+ private:
+  const uint64_t entrySize_;
+  char* prefix_;
+};
+} // namespace detail
+
+/// Provides methods (mostly required by the sort
+/// algorithm) for PrefixSort. Maintains the buffer for swap operations and
+/// some necessary context information such as entrySize.
+class PrefixSortRunner {
+ public:
+  /// @param swapBuffer The buffer must be at least entrySize bytes long.
+  PrefixSortRunner(uint64_t entrySize, char* swapBuffer)
+      : entrySize_(entrySize), swapBuffer_(swapBuffer) {
+    VELOX_CHECK_NOT_NULL(swapBuffer_);
+  }
+
+  // Within quickSort, when the input data length < kSmallSort, use insert-sort
+  // in place of quick-sort.
+  // With finding a central element, there are extra comparisons. While
+  // this is cheap for large arrays, it is expensive for small arrays.
+  // Therefore, chooses the middle element of smaller arrays (=kSmallSort),
+  // the median of the first, middle and last elements of a mid-sized array
+  // (> kSmallSort and < kMediumSort),
+  // and the pseudo-median of nine evenly spaced elements of a large
+  // array(> kMediumSort).
+  // The two threshold values are given in the reference paper "Engineering a
+  // Sort Function".
+  static const int kSmallSort = 7;
+  static const int kMediumSort = 40;
+
+  template <typename TCompare>
+  void quickSort(char* start, char* end, TCompare compare) const {
+    quickSort(
+        detail::PrefixSortIterator(start, entrySize_),
+        detail::PrefixSortIterator(end, entrySize_),
+        compare);
+  }
+
+  /// For testing only.
+  template <typename TCompare>
+  FOLLY_ALWAYS_INLINE static char* testingMedian3(
+      char* a,
+      char* b,
+      char* c,
+      const uint64_t entrySize,
+      TCompare cmp) {
+    return *median3(
+        detail::PrefixSortIterator(a, entrySize),
+        detail::PrefixSortIterator(b, entrySize),
+        detail::PrefixSortIterator(c, entrySize),
+        cmp);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE void swap(
+      const detail::PrefixSortIterator& lhs,
+      const detail::PrefixSortIterator& rhs) const {
+    simd::memcpy(swapBuffer_, *lhs, entrySize_);
+    simd::memcpy(*lhs, *rhs, entrySize_);
+    simd::memcpy(*rhs, swapBuffer_, entrySize_);
+  }
+
+  FOLLY_ALWAYS_INLINE void rangeSwap(
+      const detail::PrefixSortIterator& start1,
+      const detail::PrefixSortIterator& start2,
+      uint64_t length) const {
+    for (uint64_t i = 0; i < length; i++) {
+      swap(start1 + i, start2 + i);
+    }
+  }
+
+  // Calculate which one has median of three input iterators.
+  // The compare logic is (the symbol '<' and '>' means value compare result):
+  //            ---------cmp(a, b)--------
+  //           |                          |
+  //        a<b|                      a>=b|
+  //       cmp(b, c)                  cmp(b, c)
+  //       |       |                  |       |
+  //    b<c|   b>=c|               b>c|   b<=c|
+  //   a<=b<=c  cmp(a, c)        c<=b<=a   cmp(a, c)
+  //             |      |                   |      |
+  //          a<c|  a>=c|                a>c|  a<=c|
+  //         a<=c<=b  c<=a<=b           b<=c<=a  b<=a<=c
+  // case a<=b=<c return b
+  // case a<=c=<b return c
+  // case c<=a<=b return a
+  // case c<=b<=a return b
+  // case b<=c<=a return c
+  // case b<=a<=c return a
+  template <typename TCompare>
+  FOLLY_ALWAYS_INLINE static detail::PrefixSortIterator median3(
+      const detail::PrefixSortIterator& a,
+      const detail::PrefixSortIterator& b,
+      const detail::PrefixSortIterator& c,
+      TCompare cmp) {
+    return cmp(*a, *b) < 0 ? (cmp(*b, *c) < 0       ? b
+                                  : cmp(*a, *c) < 0 ? c
+                                                    : a)
+                           : (cmp(*b, *c) > 0       ? b
+                                  : cmp(*a, *c) > 0 ? c
+                                                    : a);
+  }
+
+  template <typename TCompare>
+  FOLLY_ALWAYS_INLINE void insertSort(
+      const detail::PrefixSortIterator& start,
+      const detail::PrefixSortIterator& end,
+      TCompare compare) const {
+    for (auto i = start; i < end; ++i) {
+      for (auto j = i; j > start && (compare(*(j - 1), *j) > 0); --j) {
+        swap(j, j - 1);
+      }
+    }
+  }
+
+  // Sort prefix data in range [start, end) using quick-sort.
+  // Algorithm implementation reference:
+  // 1. J.L.Bentley and M.McIlroy’s paper:
+  // “Engineering a Sort Function”
+  // 2. Presto`s quickSort implementation
+  //
+  // Note:The compare parameter should be defined as a template type parameter
+  // like std::sort, which is much faster than using a function type, because
+  // of this, quickSort`s implementations also need to be placed in the header
+  // file.
+  // TCompare is a compare function : int compare(char*, char*).
+  template <typename TCompare>
+  void quickSort(
+      const detail::PrefixSortIterator& start,
+      const detail::PrefixSortIterator& end,
+      TCompare compare) const {
+    VELOX_CHECK(end >= start, "Invalid sort range.");
+    const uint64_t len = end - start;
+
+    // Insertion sort on smallest arrays
+    if (len < kSmallSort) {
+      insertSort(start, end, compare);
+      return;
+    }
+
+    // Choose a partition element: m.
+
+    // For small arrays, median is the middle element.
+    auto m = start + len / 2;
+    if (len > kSmallSort) {
+      auto l = start;
+      auto n = end - 1;
+      // For big arrays, median is the pseudo-median of nine evenly spaced
+      // elements.
+      if (len > kMediumSort) {
+        const uint64_t s = len / 8;
+        l = median3(l, l + s, l + 2 * s, compare);
+        m = median3(m - s, m, m + s, compare);
+        n = median3(n - 2 * s, n - s, n, compare);
+      }
+      // For mid-sized array, median is the median of the first, middle and last
+      // elements.
+      m = median3(l, m, n, compare);
+    }
+    auto a = start;
+    auto b = a;
+    auto c = end - 1;
+    auto d = c;
+
+    // Establish invariant: v* (<v)* (>v)* v*,
+    // v* means elements that value equal to partition element v,
+    // (<v)* means elements that value little than partition element v,
+    // (>v)* means elements that value bigger than partition element v.
+    while (true) {
+      int comparison;
+      while (b <= c && ((comparison = compare(*b, *m)) <= 0)) {
+        if (comparison == 0) {
+          if (a == m) {
+            m = b;
+          } else if (b == m) {
+            m = a;
+          }
+          swap(a++, b);
+        }
+        b++;
+      }
+      while (c >= b && ((comparison = compare(*c, *m)) >= 0)) {
+        if (comparison == 0) {
+          if (c == m) {
+            m = d;
+          } else if (d == m) {
+            m = c;
+          }
+          swap(c, d--);
+        }
+        c--;
+      }
+      if (b > c) {
+        break;
+      }
+      if (b == m) {
+        m = d;
+      }
+      // There is a useless assignment statement in the implementation of presto
+      // when c == m, remove it here,
+      // see: https://github.com/prestodb/presto/blob
+      // /542beb8d89fa86feb15008611f8900f0f316ef5f/
+      // presto-main/src/main/java/com/facebook/presto/operator
+      // /PagesIndexOrdering.java
+      swap(b++, c--);
+    }
+
+    // Swap partition elements back end middle
+    uint64_t s;
+    auto n = end;
+    s = std::min(a - start, b - a);
+    rangeSwap(start, b - s, s);
+    s = std::min(d - c, n - d - 1);
+    rangeSwap(b, n - s, s);
+
+    // Recursively sort non-partition-elements
+    s = b - a;
+    if (s > 1) {
+      quickSort(start, start + s, compare);
+    }
+    s = d - c;
+    if (s > 1) {
+      quickSort(n - s, n, compare);
+    }
+  }
+
+  const uint64_t entrySize_;
+  char* const swapBuffer_;
+};
+} // namespace facebook::velox::exec::prefixsort
diff --git a/velox/exec/prefixsort/PrefixSortEncoder.h b/velox/exec/prefixsort/PrefixSortEncoder.h
new file mode 100644
index 0000000000000..dec4b6166a4f8
--- /dev/null
+++ b/velox/exec/prefixsort/PrefixSortEncoder.h
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/SimdUtil.h"
+#include "velox/type/Timestamp.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::exec::prefixsort {
+
+/// Provides encode/decode methods for PrefixSort.
+class PrefixSortEncoder {
+ public:
+  PrefixSortEncoder(bool ascending, bool nullsFirst)
+      : ascending_(ascending), nullsFirst_(nullsFirst){};
+
+  /// Encode native primitive types(such as uint64_t, int64_t, uint32_t,
+  /// int32_t, float, double, Timestamp). TODO: Add support for strings.
+  /// 1. The first byte of the encoded result is null byte. The value is 0 if
+  ///    (nulls first and value is null) or (nulls last and value is not null).
+  ///    Otherwise, the value is 1.
+  /// 2. The remaining bytes are the encoding result of value:
+  ///    -If value is null, we set the remaining sizeof(T) bytes to '0', they
+  ///     do not affect the comparison results at all.
+  ///    -If value is not null, the result is set by calling encodeNoNulls.
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void encode(std::optional<T> value, char* dest) const {
+    if (value.has_value()) {
+      dest[0] = nullsFirst_ ? 1 : 0;
+      encodeNoNulls(value.value(), dest + 1);
+    } else {
+      dest[0] = nullsFirst_ ? 0 : 1;
+      simd::memset(dest + 1, 0, sizeof(T));
+    }
+  }
+
+  /// @tparam T Type of value. Supported type are: uint64_t, int64_t, uint32_t,
+  /// int32_t, int16_t, uint16_t, float, double, Timestamp.
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void encodeNoNulls(T value, char* dest) const;
+
+  bool isAscending() const {
+    return ascending_;
+  }
+
+  bool isNullsFirst() const {
+    return nullsFirst_;
+  }
+
+  /// @return For supported types, returns the encoded size, assume nullable.
+  ///         For not supported types, returns 'std::nullopt'.
+  FOLLY_ALWAYS_INLINE static std::optional<uint32_t> encodedSize(
+      TypeKind typeKind) {
+    switch ((typeKind)) {
+      case ::facebook::velox::TypeKind::SMALLINT: {
+        return 3;
+      }
+      case ::facebook::velox::TypeKind::INTEGER: {
+        return 5;
+      }
+      case ::facebook::velox::TypeKind::BIGINT: {
+        return 9;
+      }
+      case ::facebook::velox::TypeKind::REAL: {
+        return 5;
+      }
+      case ::facebook::velox::TypeKind::DOUBLE: {
+        return 9;
+      }
+      case ::facebook::velox::TypeKind::TIMESTAMP: {
+        return 17;
+      }
+      default:
+        return std::nullopt;
+    }
+  }
+
+ private:
+  const bool ascending_;
+  const bool nullsFirst_;
+};
+
+/// Assuming that value is little-endian encoded, means:
+/// for an unsigned integer '0x aa bb cc dd', The content of bytes,
+/// starting at the address of it, would be '0xdd 0xcc 0xbb 0xaa'. If we store
+/// them into a buffer, and reverse the bytes of the buffer : [0xaa, 0xbb,
+/// 0xcc, 0xdd], and then we can compare two buffers from the first byte to
+/// last byte, the compare result is equal to value-compare. For any two
+/// unsigned integers, a < b <==> ~a > ~b so we invert bits when descending
+/// order.
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    uint32_t value,
+    char* dest) const {
+  auto& v = *reinterpret_cast<uint32_t*>(dest);
+  v = __builtin_bswap32(value);
+  if (!ascending_) {
+    v = ~v;
+  }
+}
+
+/// Compare two positive signed integers: storage layout is as same as
+/// unsigned integer, their sign-bit are same, flip sign-bit do not change
+/// result. Compare two negative signed integers: -n = ~n + 1, we can treat ~n
+/// + 1 as an unsigned integer, so the logic is as same as unsigned integer,
+/// also flip sign-bit do not change result. Compare positive vs negative:
+/// flip sign-bit to promise that positive always bigger than negative.
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    int32_t value,
+    char* dest) const {
+  encodeNoNulls((uint32_t)(value ^ (1u << 31)), dest);
+}
+
+/// Logic is as same as int32_t.
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    uint64_t value,
+    char* dest) const {
+  auto& v = *reinterpret_cast<uint64_t*>(dest);
+  v = __builtin_bswap64(value);
+  if (!ascending_) {
+    v = ~v;
+  }
+}
+
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    int64_t value,
+    char* dest) const {
+  encodeNoNulls((uint64_t)(value ^ (1ull << 63)), dest);
+}
+
+/// Logic is as same as int32_t.
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    uint16_t value,
+    char* dest) const {
+  auto& v = *reinterpret_cast<uint16_t*>(dest);
+  v = __builtin_bswap16(value);
+  if (!ascending_) {
+    v = ~v;
+  }
+}
+
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    int16_t value,
+    char* dest) const {
+  encodeNoNulls(static_cast<uint16_t>(value ^ (1u << 15)), dest);
+}
+
+namespace detail {
+/// Convert double to a uint64_t, their value comparison semantics remain
+/// consistent.
+static FOLLY_ALWAYS_INLINE uint64_t encodeDouble(double value) {
+  // Zero is the smallest positive value.
+  if (value == 0) {
+    return 1ull << 63;
+  }
+  // Nan is max value.
+  if (std::isnan(value)) {
+    return std::numeric_limits<uint64_t>::max();
+  }
+  // Infinity is the second max value.
+  if (value > std::numeric_limits<double>::max()) {
+    return std::numeric_limits<uint64_t>::max() - 1;
+  }
+  // -Infinity is the smallest value.
+  if (value < -std::numeric_limits<double>::max()) {
+    return 0;
+  }
+  auto encoded = *reinterpret_cast<uint64_t*>(&value);
+  if ((encoded & (1ull << 63)) == 0) {
+    // For positive numbers, set sign bit to 1.
+    encoded |= (1ull << 63);
+  } else {
+    // For negative numbers, invert bits to get the opposite order.
+    encoded = ~encoded;
+  }
+  return encoded;
+}
+
+// Logic is as same as double.
+static FOLLY_ALWAYS_INLINE uint32_t encodeFloat(float value) {
+  if (value == 0) {
+    return 1u << 31;
+  }
+  if (std::isnan(value)) {
+    return std::numeric_limits<uint32_t>::max();
+  }
+  if (value > std::numeric_limits<float>::max()) {
+    return std::numeric_limits<uint32_t>::max() - 1;
+  }
+  if (value < -std::numeric_limits<float>::max()) {
+    return 0;
+  }
+  auto encoded = *reinterpret_cast<uint32_t*>(&value);
+  if ((encoded & (1u << 31)) == 0) {
+    encoded |= (1u << 31);
+  } else {
+    encoded = ~encoded;
+  }
+  return encoded;
+}
+} // namespace detail
+
+/// The result of encodeDouble() keeps value comparison semantics, then we
+/// can treat it as an unsigned-integer.
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    double value,
+    char* dest) const {
+  encodeNoNulls(detail::encodeDouble(value), dest);
+}
+
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    float value,
+    char* dest) const {
+  encodeNoNulls(detail::encodeFloat(value), dest);
+}
+
+/// When comparing Timestamp, first compare seconds and then compare nanos, so
+/// when encoding, just encode seconds and nanos in sequence.
+template <>
+FOLLY_ALWAYS_INLINE void PrefixSortEncoder::encodeNoNulls(
+    Timestamp value,
+    char* dest) const {
+  encodeNoNulls(value.getSeconds(), dest);
+  encodeNoNulls(value.getNanos(), dest + 8);
+}
+
+} // namespace facebook::velox::exec::prefixsort
diff --git a/velox/exec/prefixsort/benchmarks/CMakeLists.txt b/velox/exec/prefixsort/benchmarks/CMakeLists.txt
new file mode 100644
index 0000000000000..7d29a84f520d6
--- /dev/null
+++ b/velox/exec/prefixsort/benchmarks/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+add_executable(velox_prefix_sort_algorithm_benchmark
+               PrefixSortAlgorithmBenchmark.cpp)
+target_link_libraries(
+  velox_prefix_sort_algorithm_benchmark velox_exec_prefixsort_test_lib
+  velox_vector_test_lib ${FOLLY_BENCHMARK})
diff --git a/velox/exec/prefixsort/benchmarks/PrefixSortAlgorithmBenchmark.cpp b/velox/exec/prefixsort/benchmarks/PrefixSortAlgorithmBenchmark.cpp
new file mode 100644
index 0000000000000..87c1c33bc21db
--- /dev/null
+++ b/velox/exec/prefixsort/benchmarks/PrefixSortAlgorithmBenchmark.cpp
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include "velox/buffer/Buffer.h"
+#include "velox/exec/prefixsort/PrefixSortAlgorithm.h"
+#include "velox/exec/prefixsort/tests/utils/EncoderTestUtils.h"
+
+DEFINE_int32(sort_data_seed, 1, "random test data generate seed.");
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+namespace {
+
+class PrefixSortAlgorithmBenchmark {
+ public:
+  void seed(int32_t seed) {
+    rng_.seed(seed);
+  }
+
+  void runQuickSort(std::vector<int64_t> vec) {
+    char* start = (char*)vec.data();
+    uint32_t entrySize = sizeof(int64_t);
+    auto swapBuffer = AlignedBuffer::allocate<char>(entrySize, pool_.get());
+    auto sortRunner =
+        prefixsort::PrefixSortRunner(entrySize, swapBuffer->asMutable<char>());
+    sortRunner.quickSort(
+        start, start + entrySize * vec.size(), [&](char* a, char* b) {
+          return memcmp(a, b, 8);
+        });
+  }
+
+  std::vector<int64_t> generateTestVector(int32_t size) {
+    std::vector<int64_t> randomTestVec(size);
+    std::generate(randomTestVec.begin(), randomTestVec.end(), [&]() {
+      return folly::Random::rand64(rng_);
+    });
+    prefixsort::test::encodeInPlace(randomTestVec);
+    return randomTestVec;
+  }
+
+ private:
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  folly::Random::DefaultGenerator rng_;
+};
+
+std::unique_ptr<PrefixSortAlgorithmBenchmark> bm;
+
+std::vector<int64_t> data10k;
+std::vector<int64_t> data100k;
+std::vector<int64_t> data1000k;
+std::vector<int64_t> data10000k;
+
+BENCHMARK(PrefixSort_algorithm_10k) {
+  bm->runQuickSort(data10k);
+}
+
+BENCHMARK(PrefixSort_algorithm_100k) {
+  bm->runQuickSort(data100k);
+}
+
+BENCHMARK(PrefixSort_algorithm_1000k) {
+  bm->runQuickSort(data1000k);
+}
+
+BENCHMARK(PrefixSort_algorithm_10000k) {
+  bm->runQuickSort(data10000k);
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+  bm = std::make_unique<PrefixSortAlgorithmBenchmark>();
+  bm->seed(FLAGS_sort_data_seed);
+  data10k = bm->generateTestVector(10'000);
+  data100k = bm->generateTestVector(100'000);
+  data1000k = bm->generateTestVector(1'000'000);
+  data10000k = bm->generateTestVector(10'000'000);
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/prefixsort/tests/CMakeLists.txt b/velox/exec/prefixsort/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..85e0748d9dea9
--- /dev/null
+++ b/velox/exec/prefixsort/tests/CMakeLists.txt
@@ -0,0 +1,28 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+add_subdirectory(utils)
+
+add_executable(velox_exec_prefixsort_test PrefixSortAlgorithmTest.cpp
+                                          PrefixEncoderTest.cpp)
+
+add_test(
+  NAME velox_exec_prefixsort_test
+  COMMAND velox_exec_prefixsort_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+set_tests_properties(velox_exec_prefixsort_test PROPERTIES TIMEOUT 3000)
+
+target_link_libraries(
+  velox_exec_prefixsort_test velox_exec_prefixsort_test_lib velox_vector_fuzzer
+  velox_vector_test_lib)
diff --git a/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp b/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp
new file mode 100644
index 0000000000000..7f25b4d5cae2e
--- /dev/null
+++ b/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp
@@ -0,0 +1,377 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+
+#include "velox/exec/prefixsort/PrefixSortEncoder.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/VectorTestUtils.h"
+
+namespace facebook::velox::exec::prefixsort::test {
+
+namespace {
+// Since 'std::numeric_limit<Timestamp>' has not yet implemented: is_integer,
+// is_signed, quiet_NaN(), add TypeLimits struct to skip this.
+template <typename T>
+struct TypeLimits {
+  static const bool isFloat = !std::numeric_limits<T>::is_integer;
+  static const bool isSigned = std::numeric_limits<T>::is_signed;
+
+  static FOLLY_ALWAYS_INLINE T min() {
+    // Since std::numeric_limits<T>::min() returns 'the minimum finite value, or
+    // for floating types with denormalization, the minimum positive normalized
+    // value', we use -max as min in float types.
+    return std::numeric_limits<T>::is_integer ? std::numeric_limits<T>::min()
+                                              : -std::numeric_limits<T>::max();
+  }
+
+  // For signed numbers mid is 0.
+  // For unsigned numbers mid is max / 2.
+  static FOLLY_ALWAYS_INLINE T mid() {
+    return isSigned ? (T)0 : std::numeric_limits<T>::max() / 2;
+  }
+
+  static FOLLY_ALWAYS_INLINE T nan() {
+    return std::numeric_limits<T>::quiet_NaN();
+  }
+};
+
+template <>
+struct TypeLimits<Timestamp> {
+  static const bool isFloat = false;
+  static FOLLY_ALWAYS_INLINE Timestamp min() {
+    return std::numeric_limits<Timestamp>::min();
+  }
+
+  static FOLLY_ALWAYS_INLINE Timestamp mid() {
+    return Timestamp();
+  }
+
+  // Never be called, just for skipping compile error.
+  static FOLLY_ALWAYS_INLINE Timestamp nan() {
+    VELOX_UNSUPPORTED("Timestamp not support nan()");
+  }
+};
+} // namespace
+
+class PrefixEncoderTest : public testing::Test,
+                          public velox::test::VectorTestBase {
+ public:
+  template <typename T>
+  void testEncodeNoNull(T value, char* expectedAsc, char* expectedDesc) {
+    char encoded[sizeof(T)];
+    ascNullsFirstEncoder_.encodeNoNulls(value, (char*)encoded);
+    ASSERT_EQ(std::memcmp(encoded, expectedAsc, sizeof(T)), 0);
+    descNullsFirstEncoder_.encodeNoNulls(value, (char*)encoded);
+    ASSERT_EQ(std::memcmp(encoded, expectedDesc, sizeof(T)), 0);
+  }
+
+  template <typename T>
+  void testEncodeWithNull(T testValue, char* expectedAsc, char* expectedDesc) {
+    std::optional<T> nullValue = std::nullopt;
+    std::optional<T> value = testValue;
+    char encoded[sizeof(T) + 1];
+    char nullFirst[sizeof(T) + 1];
+    char nullLast[sizeof(T) + 1];
+    memset(nullFirst, 0, sizeof(T) + 1);
+    memset(nullLast, 1, 1);
+    memset(nullLast + 1, 0, sizeof(T));
+
+    auto compare = [](char* left, char* right) {
+      return std::memcmp(left, right, sizeof(T) + 1);
+    };
+
+    ascNullsFirstEncoder_.encode(nullValue, encoded);
+    ASSERT_EQ(compare(nullFirst, encoded), 0);
+    ascNullsLastEncoder_.encode(nullValue, encoded);
+    ASSERT_EQ(compare(nullLast, encoded), 0);
+
+    ascNullsFirstEncoder_.encode(value, encoded);
+    ASSERT_EQ(encoded[0], 1);
+    ASSERT_EQ(std::memcmp(encoded + 1, expectedAsc, sizeof(T)), 0);
+    ascNullsLastEncoder_.encode(value, encoded);
+    ASSERT_EQ(encoded[0], 0);
+    ASSERT_EQ(std::memcmp(encoded + 1, expectedAsc, sizeof(T)), 0);
+    descNullsFirstEncoder_.encode(value, encoded);
+    ASSERT_EQ(encoded[0], 1);
+    ASSERT_EQ(std::memcmp(encoded + 1, expectedDesc, sizeof(T)), 0);
+    descNullsLastEncoder_.encode(value, encoded);
+    ASSERT_EQ(encoded[0], 0);
+    ASSERT_EQ(std::memcmp(encoded + 1, expectedDesc, sizeof(T)), 0);
+  }
+
+  template <typename T>
+  void testEncode(T value, char* expectedAsc, char* expectedDesc) {
+    testEncodeNoNull<T>(value, expectedAsc, expectedDesc);
+    testEncodeWithNull<T>(value, expectedAsc, expectedDesc);
+  }
+
+  template <typename T>
+  void testNullCompare() {
+    std::optional<T> nullValue = std::nullopt;
+    std::optional<T> max = std::numeric_limits<T>::max();
+    std::optional<T> min = std::numeric_limits<T>::min();
+    char encodedNull[sizeof(T) + 1];
+    char encodedMax[sizeof(T) + 1];
+    char encodedMin[sizeof(T) + 1];
+
+    auto encode = [&](auto& encoder) {
+      encoder.encode(nullValue, encodedNull);
+      encoder.encode(min, encodedMin);
+      encoder.encode(max, encodedMax);
+    };
+
+    auto compare = [](char* left, char* right) {
+      return std::memcmp(left, right, sizeof(T) + 1);
+    };
+
+    // Nulls first: NULL < non-NULL.
+    encode(ascNullsFirstEncoder_);
+    ASSERT_LT(compare(encodedNull, encodedMin), 0);
+    encode(descNullsFirstEncoder_);
+    ASSERT_LT(compare(encodedNull, encodedMin), 0);
+
+    // Nulls last: NULL > non-NULL.
+    encode(ascNullsLastEncoder_);
+    ASSERT_GT(compare(encodedNull, encodedMax), 0);
+    encode(descNullsLastEncoder_);
+    ASSERT_GT(compare(encodedNull, encodedMax), 0);
+
+    // For float / double`s NaN.
+    if (TypeLimits<T>::isFloat) {
+      std::optional<T> nan = TypeLimits<T>::nan();
+      char encodedNaN[sizeof(T) + 1];
+
+      ascNullsFirstEncoder_.encode(nan, encodedNaN);
+      ascNullsFirstEncoder_.encode(max, encodedMax);
+      ASSERT_GT(compare(encodedNaN, encodedMax), 0);
+
+      ascNullsFirstEncoder_.encode(nan, encodedNaN);
+      ascNullsFirstEncoder_.encode(nullValue, encodedNull);
+      ASSERT_LT(compare(encodedNull, encodedNaN), 0);
+    }
+  }
+
+  template <typename T>
+  void testValidValueCompare() {
+    std::optional<T> max = std::numeric_limits<T>::max();
+    std::optional<T> min = TypeLimits<T>::min();
+    std::optional<T> mid = TypeLimits<T>::mid();
+    char encodedMax[sizeof(T) + 1];
+    char encodedMin[sizeof(T) + 1];
+    char encodedMid[sizeof(T) + 1];
+    auto encode = [&](auto& encoder) {
+      encoder.encode(mid, encodedMid);
+      encoder.encode(min, encodedMin);
+      encoder.encode(max, encodedMax);
+    };
+
+    auto compare = [](char* left, char* right) {
+      return std::memcmp(left, right, sizeof(T) + 1);
+    };
+
+    encode(ascNullsFirstEncoder_);
+    // ASC: min < mid < max.
+    ASSERT_GT(compare(encodedMid, encodedMin), 0);
+    ASSERT_LT(compare(encodedMid, encodedMax), 0);
+
+    encode(descNullsFirstEncoder_);
+    // DESC: max < mid < min.
+    ASSERT_LT(compare(encodedMid, encodedMin), 0);
+    ASSERT_GT(compare(encodedMid, encodedMax), 0);
+
+    encode(ascNullsLastEncoder_);
+    // ASC: min < mid < max.
+    ASSERT_GT(compare(encodedMid, encodedMin), 0);
+    ASSERT_LT(compare(encodedMid, encodedMax), 0);
+
+    encode(descNullsLastEncoder_);
+    // DESC: max < mid < min.
+    ASSERT_LT(compare(encodedMid, encodedMin), 0);
+    ASSERT_GT(compare(encodedMid, encodedMax), 0);
+  }
+
+  template <typename T>
+  void testCompare() {
+    testNullCompare<T>();
+    testValidValueCompare<T>();
+  }
+
+  template <TypeKind Kind>
+  void testFuzz() {
+    using ValueDataType = typename TypeTraits<Kind>::NativeType;
+    const int vectorSize = 1024;
+
+    auto compare = [](char* left, char* right) {
+      const auto result = std::memcmp(left, right, sizeof(ValueDataType) + 1);
+      // Keeping the result of memory compare consistent with the result of
+      // Vector`s compare method can facilitate ASSERT_EQ.
+      return result < 0 ? -1 : (result > 0 ? 1 : 0);
+    };
+
+    auto test = [&](const PrefixSortEncoder& encoder) {
+      TypePtr type = TypeTraits<Kind>::ImplType::create();
+      VectorFuzzer fuzzer({.vectorSize = vectorSize, .nullRatio = 0.1}, pool());
+
+      CompareFlags compareFlag = {
+          encoder.isNullsFirst(),
+          encoder.isAscending(),
+          false,
+          CompareFlags::NullHandlingMode::kNullAsValue};
+      SCOPED_TRACE(compareFlag.toString());
+      const auto leftVector =
+          std::dynamic_pointer_cast<FlatVector<ValueDataType>>(
+              fuzzer.fuzzFlat(type, vectorSize));
+      const auto rightVector =
+          std::dynamic_pointer_cast<FlatVector<ValueDataType>>(
+              fuzzer.fuzzFlat(type, vectorSize));
+
+      char leftEncoded[sizeof(ValueDataType) + 1];
+      char rightEncoded[sizeof(ValueDataType) + 1];
+
+      for (auto i = 0; i < vectorSize; ++i) {
+        const auto leftValue = leftVector->isNullAt(i)
+            ? std::nullopt
+            : std::optional<ValueDataType>(leftVector->valueAt(i));
+        const auto rightValue = rightVector->isNullAt(i)
+            ? std::nullopt
+            : std::optional<ValueDataType>(rightVector->valueAt(i));
+        encoder.encode(leftValue, leftEncoded);
+        encoder.encode(rightValue, rightEncoded);
+
+        const auto result = compare(leftEncoded, rightEncoded);
+        const auto expected =
+            leftVector->compare(rightVector.get(), i, i, compareFlag).value();
+        ASSERT_EQ(result, expected);
+      }
+    };
+
+    test(ascNullsFirstEncoder_);
+    test(ascNullsLastEncoder_);
+    test(descNullsFirstEncoder_);
+    test(descNullsLastEncoder_);
+  };
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+ private:
+  const PrefixSortEncoder ascNullsFirstEncoder_ = {true, true};
+  const PrefixSortEncoder ascNullsLastEncoder_ = {true, false};
+  const PrefixSortEncoder descNullsFirstEncoder_ = {false, true};
+  const PrefixSortEncoder descNullsLastEncoder_ = {false, false};
+};
+
+TEST_F(PrefixEncoderTest, encode) {
+  {
+    uint64_t ascExpected = 0x8877665544332211;
+    uint64_t descExpected = 0x778899aabbccddee;
+    testEncode<uint64_t>(
+        0x1122334455667788, (char*)&ascExpected, (char*)&descExpected);
+  }
+
+  {
+    int64_t ascExpected = 0x8877665544332291;
+    int64_t descExpected = 0x778899aabbccdd6e;
+    testEncode<int64_t>(
+        0x1122334455667788, (char*)&ascExpected, (char*)&descExpected);
+  }
+  {
+    uint32_t ascExpected = 0x44332211;
+    uint32_t descExpected = 0xbbccddee;
+    testEncode<uint32_t>(0x11223344, (char*)&ascExpected, (char*)&descExpected);
+  }
+  {
+    int32_t ascExpected = 0x44332291;
+    int32_t descExpected = 0xbbccdd6e;
+    testEncode<int32_t>(0x11223344, (char*)&ascExpected, (char*)&descExpected);
+  }
+
+  {
+    uint16_t ascExpected = 0x2211;
+    uint16_t descExpected = 0xddee;
+    testEncode<uint16_t>(0x1122, (char*)&ascExpected, (char*)&descExpected);
+  }
+  {
+    int16_t ascExpected = 0x2291;
+    int16_t descExpected = 0xdd6e;
+    testEncode<int16_t>(0x1122, (char*)&ascExpected, (char*)&descExpected);
+  }
+
+  {
+    uint32_t ascExpected = 0x0050c3c7;
+    uint32_t descExpected = 0xffaf3c38;
+    testEncode<float>(100000.00, (char*)&ascExpected, (char*)&descExpected);
+  }
+
+  {
+    uint64_t ascExpected = 0x00000000006af8c0;
+    uint64_t descExpected = 0xffffffffff95073f;
+    testEncode<double>(100000.00, (char*)&ascExpected, (char*)&descExpected);
+  }
+
+  {
+    Timestamp value = Timestamp(0x000000011223344, 0x000000011223344);
+    uint64_t ascExpected[2];
+    uint64_t descExpected[2];
+    ascExpected[0] = 0x4433221100000080;
+    ascExpected[1] = 0x4433221100000000;
+    descExpected[0] = 0xbbccddeeffffff7f;
+    descExpected[1] = 0xbbccddeeffffffff;
+    testEncode<Timestamp>(value, (char*)ascExpected, (char*)descExpected);
+  }
+}
+
+TEST_F(PrefixEncoderTest, compare) {
+  testCompare<uint64_t>();
+  testCompare<uint32_t>();
+  testCompare<uint16_t>();
+  testCompare<int64_t>();
+  testCompare<int32_t>();
+  testCompare<int16_t>();
+  testCompare<float>();
+  testCompare<double>();
+  testCompare<Timestamp>();
+}
+
+TEST_F(PrefixEncoderTest, fuzzySmallInt) {
+  testFuzz<TypeKind::SMALLINT>();
+}
+
+TEST_F(PrefixEncoderTest, fuzzyInteger) {
+  testFuzz<TypeKind::INTEGER>();
+}
+
+TEST_F(PrefixEncoderTest, fuzzyBigint) {
+  testFuzz<TypeKind::BIGINT>();
+}
+
+TEST_F(PrefixEncoderTest, fuzzyReal) {
+  testFuzz<TypeKind::REAL>();
+}
+
+TEST_F(PrefixEncoderTest, fuzzyDouble) {
+  testFuzz<TypeKind::DOUBLE>();
+}
+
+TEST_F(PrefixEncoderTest, fuzzyTimestamp) {
+  testFuzz<TypeKind::TIMESTAMP>();
+}
+
+} // namespace facebook::velox::exec::prefixsort::test
diff --git a/velox/exec/prefixsort/tests/PrefixSortAlgorithmTest.cpp b/velox/exec/prefixsort/tests/PrefixSortAlgorithmTest.cpp
new file mode 100644
index 0000000000000..f379561b140f5
--- /dev/null
+++ b/velox/exec/prefixsort/tests/PrefixSortAlgorithmTest.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Random.h>
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+
+#include "velox/exec/prefixsort/PrefixSortAlgorithm.h"
+#include "velox/exec/prefixsort/PrefixSortEncoder.h"
+#include "velox/exec/prefixsort/tests/utils/EncoderTestUtils.h"
+#include "velox/vector/tests/VectorTestUtils.h"
+
+namespace facebook::velox::exec::prefixsort::test {
+
+class PrefixSortAlgorithmTest : public testing::Test,
+                                public velox::test::VectorTestBase {
+ public:
+  void testQuickSort(size_t size) {
+    // Data1 will be sorted by quickSort.
+    std::vector<int64_t> data1(size);
+    std::generate(
+        data1.begin(), data1.end(), [&]() { return folly::Random::rand64(); });
+
+    // Data2 will be sorted by std::sort.
+    std::vector<int64_t> data2 = data1;
+
+    // Sort data1 with quick-sort.
+    {
+      char* start = (char*)data1.data();
+      char* end = start + sizeof(int64_t) * data1.size();
+      uint32_t entrySize = sizeof(int64_t);
+      auto swapBuffer = AlignedBuffer::allocate<char>(entrySize, pool());
+      PrefixSortRunner sortRunner(entrySize, swapBuffer->asMutable<char>());
+      encodeInPlace(data1);
+      sortRunner.quickSort(
+          start, end, [&](char* a, char* b) { return memcmp(a, b, 8); });
+    }
+
+    // Sort data2 with std::sort.
+    std::sort(data2.begin(), data2.end());
+    decodeInPlace(data1);
+    ASSERT_EQ(data1, data2);
+  }
+
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(PrefixSortAlgorithmTest, quickSort) {
+  testQuickSort(PrefixSortRunner::kSmallSort - 1);
+  testQuickSort(PrefixSortRunner::kSmallSort);
+  testQuickSort(PrefixSortRunner::kSmallSort + 1);
+  testQuickSort(PrefixSortRunner::kMediumSort);
+  // Any number bigger than kMediumSort is sufficient for testing.
+  testQuickSort(PrefixSortRunner::kMediumSort + 1000);
+}
+
+TEST_F(PrefixSortAlgorithmTest, testingMedian3) {
+  // Generate 3 elements randomly as input data.
+  std::vector<int64_t> data1(3);
+  std::generate(
+      data1.begin(), data1.end(), [&]() { return folly::Random::rand64(); });
+  std::vector<int64_t> data2(data1);
+  encodeInPlace(data1);
+
+  size_t entrySize = sizeof(int64_t);
+  auto ptr1 = (char*)data1.data();
+  auto ptr2 = ptr1 + entrySize;
+  auto ptr3 = ptr2 + entrySize;
+  auto medianPtr = PrefixSortRunner::testingMedian3(
+      ptr1, ptr2, ptr3, entrySize, [&](char* a, char* b) {
+        return memcmp(a, b, entrySize);
+      });
+  decodeInPlace(data1);
+  auto median = *(reinterpret_cast<int64_t*>(medianPtr));
+  // Sort the input vector data, the middle element must be equal to the
+  // median we calculated.
+  std::sort(data2.begin(), data2.end());
+  ASSERT_EQ(median, data2[1]);
+}
+
+} // namespace facebook::velox::exec::prefixsort::test
diff --git a/velox/exec/prefixsort/tests/utils/CMakeLists.txt b/velox/exec/prefixsort/tests/utils/CMakeLists.txt
new file mode 100644
index 0000000000000..813bd5696e7a7
--- /dev/null
+++ b/velox/exec/prefixsort/tests/utils/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_exec_prefixsort_test_lib EncoderTestUtils.cpp)
+
+target_link_libraries(
+  velox_exec_prefixsort_test_lib velox_vector_test_lib)
diff --git a/velox/exec/prefixsort/tests/utils/EncoderTestUtils.cpp b/velox/exec/prefixsort/tests/utils/EncoderTestUtils.cpp
new file mode 100644
index 0000000000000..d1773def0a3f8
--- /dev/null
+++ b/velox/exec/prefixsort/tests/utils/EncoderTestUtils.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/prefixsort/tests/utils/EncoderTestUtils.h"
+
+namespace facebook::velox::exec::prefixsort::test {
+
+namespace {
+
+/// The decode method will only be used in testing scenarios. In production
+/// code, we have no scenarios that require decoding a normalized key.
+void decodeNoNulls(char* encoded, int64_t& value) {
+  value = *reinterpret_cast<uint64_t*>(encoded);
+  value = __builtin_bswap64(value ^ 128);
+}
+
+} // namespace
+
+void encodeInPlace(std::vector<int64_t>& data) {
+  const static auto encoder = PrefixSortEncoder(true, true);
+  for (auto i = 0; i < data.size(); i++) {
+    encoder.encodeNoNulls(data[i], (char*)data.data() + i * sizeof(int64_t));
+  }
+}
+
+void decodeInPlace(std::vector<int64_t>& data) {
+  for (auto i = 0; i < data.size(); i++) {
+    decodeNoNulls((char*)data.data() + i * sizeof(int64_t), data[i]);
+  }
+}
+
+} // namespace facebook::velox::exec::prefixsort::test
diff --git a/velox/exec/prefixsort/tests/utils/EncoderTestUtils.h b/velox/exec/prefixsort/tests/utils/EncoderTestUtils.h
new file mode 100644
index 0000000000000..65da5d89a794a
--- /dev/null
+++ b/velox/exec/prefixsort/tests/utils/EncoderTestUtils.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/prefixsort/PrefixSortEncoder.h"
+
+namespace facebook::velox::exec::prefixsort::test {
+
+/// Replace the elements in data with encoded ones(compatible with sorting in
+/// ascending order), assuming that the elements in data are all non-null.
+void encodeInPlace(std::vector<int64_t>& data);
+
+/// Replace the elements in data with decoded ones, assuming that the elements
+/// in data are all non-null and encoded(compatible with sorting in ascending
+/// order).
+void decodeInPlace(std::vector<int64_t>& data);
+
+} // namespace facebook::velox::exec::prefixsort::test
diff --git a/velox/exec/tests/AddressableNonNullValueListTest.cpp b/velox/exec/tests/AddressableNonNullValueListTest.cpp
index bd74386ec3c89..bb4983ea0308a 100644
--- a/velox/exec/tests/AddressableNonNullValueListTest.cpp
+++ b/velox/exec/tests/AddressableNonNullValueListTest.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/exec/AddressableNonNullValueList.h"
 #include <gtest/gtest.h>
+#include "velox/common/base/IOUtils.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox::aggregate::prestosql {
@@ -24,14 +25,21 @@ namespace {
 class AddressableNonNullValueListTest : public testing::Test,
                                         public test::VectorTestBase {
  protected:
-  void test(const VectorPtr& data, const VectorPtr& uniqueData) {
-    using T = HashStringAllocator::Position;
-    using Set = folly::F14FastSet<
-        T,
-        AddressableNonNullValueList::Hash,
-        AddressableNonNullValueList::EqualTo,
-        AlignedStlAllocator<T, 16>>;
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  using T = AddressableNonNullValueList::Entry;
+  using Set = folly::F14FastSet<
+      T,
+      AddressableNonNullValueList::Hash,
+      AddressableNonNullValueList::EqualTo,
+      AlignedStlAllocator<T, 16>>;
+
+  static constexpr size_t kSizeOfHash = sizeof(uint64_t);
+  static constexpr size_t kSizeOfLength = sizeof(vector_size_t);
 
+  void test(const VectorPtr& data, const VectorPtr& uniqueData) {
     Set uniqueValues{
         0,
         AddressableNonNullValueList::Hash{},
@@ -40,37 +48,107 @@ class AddressableNonNullValueListTest : public testing::Test,
 
     AddressableNonNullValueList values;
 
-    std::vector<HashStringAllocator::Position> positions;
+    std::vector<T> entries;
+
+    // Tracks the number of bytes for serializing the
+    // AddressableNonNullValueList.
+    vector_size_t totalSize = 0;
 
     DecodedVector decodedVector(*data);
     for (auto i = 0; i < data->size(); ++i) {
-      auto position = values.append(decodedVector, i, allocator());
+      auto entry = values.append(decodedVector, i, allocator());
 
-      if (uniqueValues.contains(position)) {
-        values.removeLast(position);
+      if (uniqueValues.contains(entry)) {
+        values.removeLast(entry);
         continue;
       }
 
-      positions.push_back(position);
+      entries.push_back(entry);
+      // The total size for serialization is
+      // (size of length + size of hash + actual value size) for each entry.
+      totalSize += entry.size + kSizeOfHash + kSizeOfLength;
 
-      ASSERT_TRUE(uniqueValues.insert(position).second);
-      ASSERT_TRUE(uniqueValues.contains(position));
-      ASSERT_FALSE(uniqueValues.insert(position).second);
+      ASSERT_TRUE(uniqueValues.insert(entry).second);
+      ASSERT_TRUE(uniqueValues.contains(entry));
+      ASSERT_FALSE(uniqueValues.insert(entry).second);
     }
 
     ASSERT_EQ(uniqueData->size(), values.size());
     ASSERT_EQ(uniqueData->size(), uniqueValues.size());
 
-    auto copy = BaseVector::create(data->type(), uniqueData->size(), pool());
-    for (auto i = 0; i < positions.size(); ++i) {
-      auto position = positions[i];
-      ASSERT_TRUE(uniqueValues.contains(position));
-      AddressableNonNullValueList::read(position, *copy, i);
+    testDirectRead(entries, uniqueValues, uniqueData);
+    testSerialization(entries, totalSize, uniqueData);
+  }
+
+  // Test direct read from AddressableNonNullValueList.
+  // Reads AddressableNonNullValueList into a vector, and validates its
+  // content.
+  void testDirectRead(
+      const std::vector<T>& entries,
+      const Set& uniqueValues,
+      const VectorPtr& uniqueData) {
+    auto copy =
+        BaseVector::create(uniqueData->type(), uniqueData->size(), pool());
+    for (auto i = 0; i < entries.size(); ++i) {
+      auto entry = entries[i];
+      ASSERT_TRUE(uniqueValues.contains(entry));
+      AddressableNonNullValueList::read(entry, *copy, i);
     }
 
     test::assertEqualVectors(uniqueData, copy);
   }
 
+  // Test copy/appendSerialized round-trip for AddressableNonNullValueList.
+  // Steps in the test:
+  // i) Copy entry length, hash and value of each entry to a stream.
+  // ii) Deserialize stream to a new set of entries.
+  // iii) Read deserialized entries back into a vector.
+  // iv) Validate the result vector.
+  void testSerialization(
+      const std::vector<T>& entries,
+      vector_size_t totalSize,
+      const VectorPtr& uniqueData) {
+    size_t offset = 0;
+    auto buffer = AlignedBuffer::allocate<char>(totalSize, pool());
+    auto* rawBuffer = buffer->asMutable<char>();
+
+    auto append = [&](const void* value, size_t size) {
+      memcpy((void*)(rawBuffer + offset), value, size);
+      offset += size;
+    };
+
+    for (const auto& entry : entries) {
+      append(&entry.size, kSizeOfLength);
+      append(&entry.hash, kSizeOfHash);
+      AddressableNonNullValueList::readSerialized(
+          entry, (char*)(rawBuffer + offset));
+      offset += entry.size;
+    }
+    ASSERT_EQ(offset, totalSize);
+
+    // Deserialize entries from the stream.
+    AddressableNonNullValueList deserialized;
+    std::vector<T> deserializedEntries;
+    common::InputByteStream stream(rawBuffer);
+    while (stream.offset() < totalSize) {
+      auto length = stream.read<vector_size_t>();
+      auto hash = stream.read<uint64_t>();
+      StringView contents(stream.read<char>(length), length);
+      auto position = deserialized.appendSerialized(contents, allocator());
+      deserializedEntries.push_back({position, contents.size(), hash});
+    }
+
+    // Direct read from deserialized AddressableNonNullValueList. Validate the
+    // results.
+    auto deserializedCopy =
+        BaseVector::create(uniqueData->type(), uniqueData->size(), pool());
+    for (auto i = 0; i < deserializedEntries.size(); ++i) {
+      auto entry = deserializedEntries[i];
+      AddressableNonNullValueList::read(entry, *deserializedCopy, i);
+    }
+    test::assertEqualVectors(uniqueData, deserializedCopy);
+  }
+
   HashStringAllocator* allocator() {
     return allocator_.get();
   }
@@ -174,6 +252,7 @@ TEST_F(AddressableNonNullValueListTest, row) {
       makeNullableFlatVector<int64_t>(
           {std::nullopt, 22, 22, 33, std::nullopt, 55, 33}),
   });
+  test(dataWithDuplicates, data);
 }
 
 } // namespace
diff --git a/velox/exec/tests/AggregateFunctionRegistryTest.cpp b/velox/exec/tests/AggregateFunctionRegistryTest.cpp
index 6640645c37498..a3b9d189054b4 100644
--- a/velox/exec/tests/AggregateFunctionRegistryTest.cpp
+++ b/velox/exec/tests/AggregateFunctionRegistryTest.cpp
@@ -17,6 +17,7 @@
 #include "velox/exec/AggregateFunctionRegistry.h"
 #include <gtest/gtest.h>
 #include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateUtil.h"
 #include "velox/exec/WindowFunction.h"
 #include "velox/functions/Registerer.h"
 #include "velox/type/Type.h"
@@ -33,10 +34,6 @@ class AggregateFunc : public Aggregate {
     return 0;
   }
 
-  void initializeNewGroups(
-      char** /*groups*/,
-      folly::Range<const vector_size_t*> /*indices*/) override {}
-
   void addRawInput(
       char** /*groups*/,
       const SelectivityVector& /*rows*/,
@@ -92,6 +89,11 @@ class AggregateFunc : public Aggregate {
     };
     return signatures;
   }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** /*groups*/,
+      folly::Range<const vector_size_t*> /*indices*/) override {}
 };
 
 bool registerAggregateFunc(const std::string& name, bool overwrite = false) {
@@ -221,4 +223,73 @@ TEST_F(FunctionRegistryTest, duplicateRegistration) {
   EXPECT_TRUE(registerAggregateFunc("aggregate_func", true));
 }
 
+TEST_F(FunctionRegistryTest, multipleNames) {
+  auto signatures = AggregateFunc::signatures();
+  auto factory = [&](core::AggregationNode::Step step,
+                     const std::vector<TypePtr>& argTypes,
+                     const TypePtr& resultType,
+                     const core::QueryConfig& /*config*/) {
+    if (isPartialOutput(step)) {
+      if (argTypes.empty()) {
+        return std::make_unique<AggregateFunc>(resultType);
+      }
+      return std::make_unique<AggregateFunc>(ARRAY(resultType));
+    }
+    return std::make_unique<AggregateFunc>(resultType);
+  };
+
+  auto registrationResult = registerAggregateFunction(
+      "aggregate_func1",
+      signatures,
+      factory,
+      /*registerCompanionFunctions*/ true,
+      /*overwrite*/ false);
+  exec::AggregateRegistrationResult allSuccess{true, true, true, true, true};
+  EXPECT_EQ(registrationResult, allSuccess);
+  testResolveAggregateFunction(
+      "aggregate_func1", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
+  testResolveAggregateFunction(
+      "aggregate_func1_partial",
+      {BIGINT(), DOUBLE()},
+      ARRAY(BIGINT()),
+      ARRAY(BIGINT()));
+
+  registrationResult = registerAggregateFunction(
+      {std::string("aggregate_func2")},
+      signatures,
+      factory,
+      /*registerCompanionFunctions*/ false,
+      /*overwrite*/ false);
+  exec::AggregateRegistrationResult onlyMainSuccess{
+      true, false, false, false, false};
+  EXPECT_EQ(registrationResult, onlyMainSuccess);
+  testResolveAggregateFunction(
+      "aggregate_func2", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
+
+  auto registrationResults = registerAggregateFunction(
+      std::vector<std::string>{"aggregate_func2", "aggregate_func3"},
+      signatures,
+      factory,
+      /*registerCompanionFunctions*/ true,
+      /*overwrite*/ false);
+  exec::AggregateRegistrationResult allSuccessExceptMain{
+      false, true, true, true, true};
+  EXPECT_EQ(registrationResults[0], allSuccessExceptMain);
+  EXPECT_EQ(registrationResults[1], allSuccess);
+  testResolveAggregateFunction(
+      "aggregate_func2", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
+  testResolveAggregateFunction(
+      "aggregate_func2_partial",
+      {BIGINT(), DOUBLE()},
+      ARRAY(BIGINT()),
+      ARRAY(BIGINT()));
+  testResolveAggregateFunction(
+      "aggregate_func3", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
+  testResolveAggregateFunction(
+      "aggregate_func3_partial",
+      {BIGINT(), DOUBLE()},
+      ARRAY(BIGINT()),
+      ARRAY(BIGINT()));
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/AggregateSpillBenchmarkBase.cpp b/velox/exec/tests/AggregateSpillBenchmarkBase.cpp
new file mode 100644
index 0000000000000..8464157a7e096
--- /dev/null
+++ b/velox/exec/tests/AggregateSpillBenchmarkBase.cpp
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/AggregateSpillBenchmarkBase.h"
+
+#include <gflags/gflags.h>
+#include <deque>
+
+using namespace facebook::velox;
+using namespace facebook::velox::common;
+using namespace facebook::velox::memory;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::exec::test {
+
+namespace {
+std::unique_ptr<RowContainer> makeRowContainer(
+    const std::vector<TypePtr>& keyTypes,
+    const std::vector<TypePtr>& dependentTypes,
+    std::shared_ptr<velox::memory::MemoryPool>& pool) {
+  return std::make_unique<RowContainer>(
+      keyTypes,
+      true, // nullableKeys
+      std::vector<Accumulator>{},
+      dependentTypes,
+      false, // hasNext
+      false, // isJoinBuild
+      false, // hasProbedFlag
+      false, // hasNormalizedKey
+      pool.get());
+}
+
+std::unique_ptr<RowContainer> setupSpillContainer(
+    const RowTypePtr& rowType,
+    uint32_t numKeys,
+    std::shared_ptr<velox::memory::MemoryPool>& pool) {
+  const auto& childTypes = rowType->children();
+  std::vector<TypePtr> keys(childTypes.begin(), childTypes.begin() + numKeys);
+  std::vector<TypePtr> dependents;
+  if (numKeys < childTypes.size()) {
+    dependents.insert(
+        dependents.end(), childTypes.begin() + numKeys, childTypes.end());
+  }
+  return makeRowContainer(keys, dependents, pool);
+}
+} // namespace
+
+void AggregateSpillBenchmarkBase::setUp() {
+  SpillerBenchmarkBase::setUp();
+
+  rowContainer_ = setupSpillContainer(
+      rowType_, FLAGS_spiller_benchmark_num_key_columns, pool_);
+  writeSpillData();
+  spiller_ = makeSpiller();
+}
+
+void AggregateSpillBenchmarkBase::run() {
+  MicrosecondTimer timer(&executionTimeUs_);
+  if (spillerType_ == Spiller::Type::kAggregateInput) {
+    spiller_->spill();
+  } else {
+    spiller_->spill(RowContainerIterator{});
+  }
+  rowContainer_->clear();
+}
+
+void AggregateSpillBenchmarkBase::printStats() const {
+  LOG(INFO) << "======Aggregate " << Spiller::typeName(spillerType_)
+            << " spilling statistics======";
+  LOG(INFO) << "total execution time: " << succinctMicros(executionTimeUs_);
+  LOG(INFO) << numInputVectors_ << " vectors each with " << inputVectorSize_
+            << " rows have been processed";
+  const auto memStats = memory::spillMemoryPool()->stats();
+  LOG(INFO) << "peak memory usage[" << succinctBytes(memStats.peakBytes)
+            << "] cumulative memory usage["
+            << succinctBytes(memStats.cumulativeBytes) << "]";
+  LOG(INFO) << spiller_->stats().toString();
+  // List files under file path.
+  SpillPartitionSet partitionSet;
+  spiller_->finishSpill(partitionSet);
+  const auto files = fs_->list(spillDir_);
+  for (const auto& file : files) {
+    auto rfile = fs_->openFileForRead(file);
+    LOG(INFO) << "spilled file " << file << " size "
+              << succinctBytes(rfile->size());
+  }
+}
+
+void AggregateSpillBenchmarkBase::writeSpillData() {
+  vector_size_t numRows = 0;
+  for (const auto& rowVector : rowVectors_) {
+    numRows += rowVector->size();
+  }
+
+  std::vector<char*> rows;
+  rows.resize(numRows);
+  for (int i = 0; i < numRows; ++i) {
+    rows[i] = rowContainer_->newRow();
+  }
+
+  vector_size_t nextRow = 0;
+  for (const auto& rowVector : rowVectors_) {
+    const SelectivityVector allRows(rowVector->size());
+    for (int index = 0; index < rowVector->size(); ++index, ++nextRow) {
+      for (int i = 0; i < rowType_->size(); ++i) {
+        DecodedVector decodedVector(*rowVector->childAt(i), allRows);
+        rowContainer_->store(decodedVector, index, rows[nextRow], i);
+      }
+    }
+  }
+}
+
+std::unique_ptr<Spiller> AggregateSpillBenchmarkBase::makeSpiller() {
+  common::SpillConfig spillConfig;
+  spillConfig.getSpillDirPathCb = [&]() -> std::string_view {
+    return spillDir_;
+  };
+  spillConfig.updateAndCheckSpillLimitCb = [&](uint64_t) {};
+  spillConfig.fileNamePrefix = FLAGS_spiller_benchmark_name;
+  spillConfig.writeBufferSize = FLAGS_spiller_benchmark_write_buffer_size;
+  spillConfig.executor = executor_.get();
+  spillConfig.compressionKind =
+      stringToCompressionKind(FLAGS_spiller_benchmark_compression_kind);
+  spillConfig.maxSpillRunRows = 0;
+  spillConfig.fileCreateConfig = {};
+  // The default value of QueryConfig kSpillStartPartitionBit.
+  spillConfig.startPartitionBit = 48;
+  // The default value of QueryConfig spillNumPartitionBits.
+  spillConfig.numPartitionBits = 3;
+
+  if (spillerType_ == Spiller::Type::kAggregateInput) {
+    return std::make_unique<Spiller>(
+        spillerType_,
+        rowContainer_.get(),
+        rowType_,
+        HashBitRange{
+            spillConfig.startPartitionBit,
+            static_cast<uint8_t>(
+                spillConfig.startPartitionBit + spillConfig.numPartitionBits)},
+        rowContainer_->keyTypes().size(),
+        std::vector<CompareFlags>{},
+        &spillConfig,
+        &spillStats_);
+  } else {
+    // TODO: Add config flag to control the max spill rows.
+    return std::make_unique<Spiller>(
+        spillerType_,
+        rowContainer_.get(),
+        rowType_,
+        &spillConfig,
+        &spillStats_);
+  }
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/AggregateSpillBenchmarkBase.h b/velox/exec/tests/AggregateSpillBenchmarkBase.h
new file mode 100644
index 0000000000000..15b3bb853d661
--- /dev/null
+++ b/velox/exec/tests/AggregateSpillBenchmarkBase.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/SpillerBenchmarkBase.h"
+
+namespace facebook::velox::exec::test {
+class AggregateSpillBenchmarkBase : public SpillerBenchmarkBase {
+ public:
+  explicit AggregateSpillBenchmarkBase(Spiller::Type spillerType)
+      : spillerType_(spillerType){};
+
+  /// Sets up the test.
+  void setUp() override;
+
+  /// Runs the test.
+  void run() override;
+
+  void printStats() const override;
+
+ private:
+  void writeSpillData();
+  std::unique_ptr<Spiller> makeSpiller();
+
+  const Spiller::Type spillerType_;
+  std::unique_ptr<RowContainer> rowContainer_;
+  std::shared_ptr<velox::memory::MemoryPool> spillerPool_;
+};
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/AggregationFuzzerTest.cpp b/velox/exec/tests/AggregationFuzzerTest.cpp
deleted file mode 100644
index f57e3d76d033e..0000000000000
--- a/velox/exec/tests/AggregationFuzzerTest.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/init/Init.h>
-#include <gflags/gflags.h>
-#include <gtest/gtest.h>
-#include <unordered_set>
-
-#include "velox/exec/tests/utils/AggregationFuzzerRunner.h"
-#include "velox/exec/tests/utils/DuckQueryRunner.h"
-#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-
-DEFINE_int64(
-    seed,
-    0,
-    "Initial seed for random number generator used to reproduce previous "
-    "results (0 means start with random seed).");
-
-DEFINE_string(
-    only,
-    "",
-    "If specified, Fuzzer will only choose functions from "
-    "this comma separated list of function names "
-    "(e.g: --only \"min\" or --only \"sum,avg\").");
-
-int main(int argc, char** argv) {
-  facebook::velox::aggregate::prestosql::registerAllAggregateFunctions();
-  facebook::velox::functions::prestosql::registerAllScalarFunctions();
-
-  ::testing::InitGoogleTest(&argc, argv);
-
-  // Calls common init functions in the necessary order, initializing
-  // singletons, installing proper signal handlers for better debugging
-  // experience, and initialize glog and gflags.
-  folly::init(&argc, &argv);
-
-  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
-
-  auto duckQueryRunner =
-      std::make_unique<facebook::velox::exec::test::DuckQueryRunner>();
-
-  // List of functions that have known bugs that cause crashes or failures.
-  static const std::unordered_set<std::string> skipFunctions = {
-      // https://github.com/facebookincubator/velox/issues/3493
-      "stddev_pop",
-      // Lambda functions are not supported yet.
-      "reduce_agg",
-  };
-
-  // Functions whose results verification should be skipped. These can be
-  // order-dependent functions whose results depend on the order of input rows,
-  // or functions that return complex-typed results containing floating-point
-  // fields. For some functions, the result can be transformed to a value that
-  // can be verified. If such transformation exists, it can be specified to be
-  // used for results verification. If no transformation is specified, results
-  // are not verified.
-  static const std::unordered_map<std::string, std::string>
-      customVerificationFunctions = {
-          // Order-dependent functions.
-          {"approx_distinct", ""},
-          {"approx_distinct_partial", ""},
-          {"approx_distinct_merge", ""},
-          {"approx_set", ""},
-          {"approx_set_partial", ""},
-          {"approx_set_merge", ""},
-          {"approx_percentile_partial", ""},
-          {"approx_percentile_merge", ""},
-          {"arbitrary", ""},
-          {"array_agg", "array_sort({})"},
-          {"array_agg_partial", "array_sort({})"},
-          {"array_agg_merge", "array_sort({})"},
-          {"array_agg_merge_extract", "array_sort({})"},
-          {"set_agg", "array_sort({})"},
-          {"set_union", "array_sort({})"},
-          {"map_agg", "array_sort(map_keys({}))"},
-          {"map_union", "array_sort(map_keys({}))"},
-          {"map_union_sum", "array_sort(map_keys({}))"},
-          {"max_by", ""},
-          {"min_by", ""},
-          {"map_union_sum", "array_sort(map_keys({}))"},
-          {"multimap_agg", "transform_values({}, (k, v) -> array_sort(v))"},
-          // TODO: Skip result verification of companion functions that return
-          // complex types that contain floating-point fields for now, until we
-          // fix
-          // test utilities in QueryAssertions to tolerate floating-point
-          // imprecision in complex types.
-          // https://github.com/facebookincubator/velox/issues/4481
-          {"avg_partial", ""},
-          {"avg_merge", ""},
-          // Semantically inconsistent functions
-          {"skewness", ""},
-          {"kurtosis", ""},
-          {"entropy", ""},
-          // https://github.com/facebookincubator/velox/issues/6330
-          {"max_data_size_for_stats", ""},
-          {"sum_data_size_for_stats", ""},
-      };
-
-  using Runner = facebook::velox::exec::test::AggregationFuzzerRunner;
-
-  Runner::Options options;
-  options.onlyFunctions = FLAGS_only;
-  options.skipFunctions = skipFunctions;
-  options.customVerificationFunctions = customVerificationFunctions;
-  options.timestampPrecision =
-      facebook::velox::VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
-  return Runner::run(initialSeed, std::move(duckQueryRunner), options);
-}
diff --git a/velox/exec/tests/AggregationRunnerTest.cpp b/velox/exec/tests/AggregationRunnerTest.cpp
index 744b3d9f68ca2..0eb5d38bfd3fb 100644
--- a/velox/exec/tests/AggregationRunnerTest.cpp
+++ b/velox/exec/tests/AggregationRunnerTest.cpp
@@ -20,8 +20,8 @@
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 #include "velox/common/base/Fs.h"
-#include "velox/exec/tests/utils/AggregationFuzzerRunner.h"
-#include "velox/exec/tests/utils/DuckQueryRunner.h"
+#include "velox/exec/fuzzer/AggregationFuzzerRunner.h"
+#include "velox/exec/fuzzer/DuckQueryRunner.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 
@@ -40,6 +40,19 @@ DEFINE_string(
     "Path for plan nodes to be restored from disk. This will enable single run "
     "of the fuzzer with the on-disk persisted plan information.");
 
+DEFINE_string(
+    presto_url,
+    "",
+    "Presto coordinator URI along with port. If set, we use Presto "
+    "source of truth. Otherwise, use DuckDB. Example: "
+    "--presto_url=http://127.0.0.1:8080");
+
+DEFINE_uint32(
+    req_timeout_ms,
+    3000,
+    "Timeout in milliseconds for HTTP requests made to reference DB, "
+    "such as Presto. Example: --req_timeout_ms=2000");
+
 static std::string checkAndReturnFilePath(
     const std::string_view& fileName,
     const std::string& flagName) {
@@ -66,7 +79,8 @@ static void checkDirForExpectedFiles() {
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
 
-  folly::init(&argc, &argv);
+  folly::Init init(&argc, &argv);
+  facebook::velox::memory::MemoryManager::initialize({});
 
   if (!FLAGS_aggregation_fuzzer_repro_path.empty()) {
     checkDirForExpectedFiles();
@@ -75,8 +89,13 @@ int main(int argc, char** argv) {
   facebook::velox::aggregate::prestosql::registerAllAggregateFunctions();
   facebook::velox::functions::prestosql::registerAllScalarFunctions();
 
-  auto duckQueryRunner =
-      std::make_unique<facebook::velox::exec::test::DuckQueryRunner>();
+  std::shared_ptr<memory::MemoryPool> rootPool{
+      memory::memoryManager()->addRootPool()};
+  auto queryRunner = facebook::velox::exec::test::setupReferenceQueryRunner(
+      rootPool.get(),
+      FLAGS_presto_url,
+      "aggregation_fuzzer",
+      FLAGS_req_timeout_ms);
   return exec::test::AggregationFuzzerRunner::runRepro(
-      FLAGS_plan_nodes_path, std::move(duckQueryRunner));
+      FLAGS_plan_nodes_path, std::move(queryRunner));
 }
diff --git a/velox/exec/tests/AggregationTest.cpp b/velox/exec/tests/AggregationTest.cpp
index 85bc92277dcaa..3f7dd0736e8d6 100644
--- a/velox/exec/tests/AggregationTest.cpp
+++ b/velox/exec/tests/AggregationTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <fmt/format.h>
 #include <folly/Math.h>
 #include <re2/re2.h>
 
@@ -25,13 +26,12 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/GroupingSet.h"
 #include "velox/exec/PlanNodeStats.h"
-#include "velox/exec/RowContainer.h"
+#include "velox/exec/Values.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/SumNonPODAggregate.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
 
 namespace facebook::velox::exec::test {
 
@@ -61,10 +61,6 @@ class AggregateFunc : public Aggregate {
     return Aggregate::isNull(group);
   }
 
-  void initializeNewGroups(
-      char** /*groups*/,
-      folly::Range<const vector_size_t*> /*indices*/) override {}
-
   void addRawInput(
       char** /*groups*/,
       const SelectivityVector& /*rows*/,
@@ -98,8 +94,48 @@ class AggregateFunc : public Aggregate {
       char** /*groups*/,
       int32_t /*numGroups*/,
       VectorPtr* /*result*/) override {}
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** /*groups*/,
+      folly::Range<const vector_size_t*> /*indices*/) override {}
 };
 
+void checkSpillStats(PlanNodeStats& stats, bool expectedSpill) {
+  if (expectedSpill) {
+    ASSERT_GT(stats.spilledRows, 0);
+    ASSERT_GT(stats.spilledInputBytes, 0);
+    ASSERT_GT(stats.spilledBytes, 0);
+    ASSERT_EQ(stats.spilledPartitions, 8);
+    ASSERT_GT(stats.customStats[Operator::kSpillRuns].sum, 0);
+    ASSERT_GT(stats.customStats[Operator::kSpillFillTime].sum, 0);
+    ASSERT_GT(stats.customStats[Operator::kSpillSortTime].sum, 0);
+    ASSERT_GT(stats.customStats[Operator::kSpillSerializationTime].sum, 0);
+    ASSERT_GT(stats.customStats[Operator::kSpillFlushTime].sum, 0);
+    ASSERT_GT(stats.customStats[Operator::kSpillWrites].sum, 0);
+    ASSERT_GT(stats.customStats[Operator::kSpillWriteTime].sum, 0);
+  } else {
+    ASSERT_EQ(stats.spilledRows, 0);
+    ASSERT_EQ(stats.spilledInputBytes, 0);
+    ASSERT_EQ(stats.spilledBytes, 0);
+    ASSERT_EQ(stats.spilledPartitions, 0);
+    ASSERT_EQ(stats.spilledFiles, 0);
+    ASSERT_EQ(stats.customStats[Operator::kSpillRuns].sum, 0);
+    ASSERT_EQ(stats.customStats[Operator::kSpillFillTime].sum, 0);
+    ASSERT_EQ(stats.customStats[Operator::kSpillSortTime].sum, 0);
+    ASSERT_EQ(stats.customStats[Operator::kSpillSerializationTime].sum, 0);
+    ASSERT_EQ(stats.customStats[Operator::kSpillFlushTime].sum, 0);
+    ASSERT_EQ(stats.customStats[Operator::kSpillWrites].sum, 0);
+    ASSERT_EQ(stats.customStats[Operator::kSpillWriteTime].sum, 0);
+  }
+  ASSERT_EQ(
+      stats.customStats[Operator::kSpillSerializationTime].count,
+      stats.customStats[Operator::kSpillFlushTime].count);
+  ASSERT_EQ(
+      stats.customStats[Operator::kSpillWrites].count,
+      stats.customStats[Operator::kSpillWriteTime].count);
+}
+
 class AggregationTest : public OperatorTestBase {
  protected:
   static void SetUpTestCase() {
@@ -114,12 +150,11 @@ class AggregationTest : public OperatorTestBase {
   }
 
   std::vector<RowVectorPtr>
-  makeVectors(const RowTypePtr& rowType, vector_size_t size, int numVectors) {
+  makeVectors(const RowTypePtr& rowType, size_t size, int numVectors) {
     std::vector<RowVectorPtr> vectors;
+    VectorFuzzer fuzzer({.vectorSize = size}, pool());
     for (int32_t i = 0; i < numVectors; ++i) {
-      auto vector = std::dynamic_pointer_cast<RowVector>(
-          velox::test::BatchMaker::createBatch(rowType, size, *pool_));
-      vectors.push_back(vector);
+      vectors.push_back(fuzzer.fuzzInputRow(rowType));
     }
     return vectors;
   }
@@ -352,6 +387,12 @@ class AggregationTest : public OperatorTestBase {
            VARCHAR()})};
   folly::Random::DefaultGenerator rng_;
   memory::MemoryReclaimer::Stats reclaimerStats_;
+  VectorFuzzer::Options fuzzerOpts_{
+      .vectorSize = 1024,
+      .nullRatio = 0,
+      .stringLength = 1024,
+      .stringVariableLength = false,
+      .allowLazyVector = false};
 };
 
 template <>
@@ -393,7 +434,9 @@ TEST_F(AggregationTest, missingFunctionOrSignature) {
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
-          -> std::unique_ptr<exec::Aggregate> { VELOX_UNREACHABLE(); });
+          -> std::unique_ptr<exec::Aggregate> { VELOX_UNREACHABLE(); },
+      false /*registerCompanionFunctions*/,
+      true /*overwrite*/);
 
   std::vector<core::TypedExprPtr> inputs = {
       std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0"),
@@ -536,6 +579,59 @@ TEST_F(AggregationTest, global) {
       "SELECT sum(15), sum(c1), sum(c2), sum(c4), sum(c5), "
       "min(15), min(c1), min(c2), min(c3), min(c4), min(c5), "
       "max(15), max(c1), max(c2), max(c3), max(c4), max(c5), sum(1) FROM tmp");
+}
+
+TEST_F(AggregationTest, manyGlobalAggregations) {
+  // Test a query with a large number of global aggregations.
+  // Global aggregations have a separate code path that does not use a
+  // HashTable, but rather a single row outside of a RowContainer.  Having many
+  // aggregations can expose issues with that single row that may not occur with
+  // only a few aggregations.
+  auto rowType =
+      velox::test::VectorMaker::rowType(std::vector<TypePtr>(100, SMALLINT()));
+  auto vectors = makeVectors(rowType, 10, 100);
+  createDuckDbTable(vectors);
+
+  std::vector<std::string> aggregates;
+  for (int i = 0; i < rowType->size(); i++) {
+    aggregates.push_back(fmt::format("sum({})", rowType->nameOf(i)));
+  }
+
+  auto op = PlanBuilder()
+                .values(vectors)
+                .singleAggregation({}, aggregates)
+                .planNode();
+
+  assertQuery(op, "SELECT " + folly::join(", ", aggregates) + " FROM tmp");
+
+  aggregates.clear();
+  for (int i = 0; i < rowType->size(); i++) {
+    aggregates.push_back(fmt::format("sum(distinct {})", rowType->nameOf(i)));
+  }
+
+  op = PlanBuilder()
+           .values(vectors)
+           .singleAggregation({}, aggregates)
+           .planNode();
+
+  assertQuery(op, "SELECT " + folly::join(", ", aggregates) + " FROM tmp");
+
+  rowType =
+      velox::test::VectorMaker::rowType(std::vector<TypePtr>(32, SMALLINT()));
+  vectors = makeVectors(rowType, 10, 32);
+  createDuckDbTable(vectors);
+  aggregates.clear();
+  for (int i = 0; i < rowType->size(); i++) {
+    aggregates.push_back(fmt::format(
+        "array_agg({} ORDER BY {})", rowType->nameOf(i), rowType->nameOf(i)));
+  }
+
+  op = PlanBuilder()
+           .values(vectors)
+           .singleAggregation({}, aggregates)
+           .planNode();
+
+  assertQuery(op, "SELECT " + folly::join(", ", aggregates) + " FROM tmp");
 
   EXPECT_EQ(NonPODInt64::constructed, NonPODInt64::destructed);
 }
@@ -621,11 +717,13 @@ TEST_F(AggregationTest, aggregateOfNulls) {
 // Verify behavior of setNull method.
 TEST_F(AggregationTest, setNull) {
   AggregateFunc aggregate(BIGINT());
-  int32_t nullOffset = 0;
+  int32_t accumulatorFlagsOffset = 0;
   aggregate.setOffsets(
       0,
-      RowContainer::nullByte(nullOffset),
-      RowContainer::nullMask(nullOffset),
+      RowContainer::nullByte(accumulatorFlagsOffset),
+      RowContainer::nullMask(accumulatorFlagsOffset),
+      RowContainer::initializedByte(accumulatorFlagsOffset),
+      RowContainer::initializedMask(accumulatorFlagsOffset),
       0);
   char group{0};
   aggregate.clearNullTest(&group);
@@ -652,10 +750,10 @@ TEST_F(AggregationTest, hashmodes) {
   makeModeTestKeys(rowType, 20000, 2, 2, 2, 4, 4, 4, batches);
   // 20K rows with all at slightly higher cardinality, still in array range.
   makeModeTestKeys(rowType, 20000, 2, 2, 2, 4, 16, 4, batches);
-  // 100K rows with cardinality outside of array range. We transit to
+  // 25K rows with cardinality outside of array range. We transit to
   // generic hash table from normalized keys when running out of quota
   // for distinct string storage for the sixth key.
-  makeModeTestKeys(rowType, 100000, 1000000, 2, 2, 4, 4, 1000000, batches);
+  makeModeTestKeys(rowType, 25000, 1000000, 2, 2, 4, 4, 1000000, batches);
   createDuckDbTable(batches);
   auto op =
       PlanBuilder()
@@ -663,10 +761,19 @@ TEST_F(AggregationTest, hashmodes) {
           .singleAggregation({"c0", "c1", "c2", "c3", "c4", "c5"}, {"sum(1)"})
           .planNode();
 
+  std::atomic<BaseHashTable::HashMode> mode{BaseHashTable::HashMode::kArray};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashTable::setHashMode",
+      std::function<void(void*)>([&](void* newMode) {
+        mode = *reinterpret_cast<BaseHashTable::HashMode*>(newMode);
+      }));
   assertQuery(
       op,
       "SELECT c0, c1, C2, C3, C4, C5, sum(1) FROM tmp "
       " GROUP BY c0, c1, c2, c3, c4, c5");
+#ifndef NDEBUG
+  EXPECT_EQ(mode, BaseHashTable::HashMode::kHash);
+#endif
 }
 
 TEST_F(AggregationTest, rangeToDistinct) {
@@ -741,7 +848,7 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Distinct aggregation.
   core::PlanNodeId aggNodeId;
   auto task = AssertQueryBuilder(duckDbQueryRunner_)
-                  .config(QueryConfig::kMaxPartialAggregationMemory, "100")
+                  .config(QueryConfig::kMaxPartialAggregationMemory, 100)
                   .plan(PlanBuilder()
                             .values(vectors)
                             .partialAggregation({"c0"}, {})
@@ -764,7 +871,7 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
 
   // Count aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
-             .config(QueryConfig::kMaxPartialAggregationMemory, "1")
+             .config(QueryConfig::kMaxPartialAggregationMemory, 1)
              .plan(PlanBuilder()
                        .values(vectors)
                        .partialAggregation({"c0"}, {"count(1)"})
@@ -787,7 +894,7 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
 
   // Global aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
-             .config(QueryConfig::kMaxPartialAggregationMemory, "1")
+             .config(QueryConfig::kMaxPartialAggregationMemory, 1)
              .plan(PlanBuilder()
                        .values(vectors)
                        .partialAggregation({}, {"sum(c0)"})
@@ -825,9 +932,9 @@ TEST_F(AggregationTest, partialDistinctWithAbandon) {
 
   // Distinct aggregation.
   auto task = AssertQueryBuilder(duckDbQueryRunner_)
-                  .config(QueryConfig::kAbandonPartialAggregationMinRows, "100")
-                  .config(QueryConfig::kAbandonPartialAggregationMinPct, "50")
-                  .config("max_drivers_per_task", "1")
+                  .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
+                  .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
+                  .config("max_drivers_per_task", 1)
                   .plan(PlanBuilder()
                             .values(vectors)
                             .partialAggregation({"c0"}, {})
@@ -837,9 +944,9 @@ TEST_F(AggregationTest, partialDistinctWithAbandon) {
 
   // with aggregation, just in case.
   task = AssertQueryBuilder(duckDbQueryRunner_)
-             .config(QueryConfig::kAbandonPartialAggregationMinRows, "100")
-             .config(QueryConfig::kAbandonPartialAggregationMinPct, "50")
-             .config("max_drivers_per_task", "1")
+             .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
+             .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
+             .config("max_drivers_per_task", 1)
              .plan(PlanBuilder()
                        .values(vectors)
                        .partialAggregation({"c0"}, {"sum(c0)"})
@@ -994,17 +1101,14 @@ TEST_F(AggregationTest, partialAggregationMaybeReservationReleaseCheck) {
   const int64_t kMaxUserMemoryUsage = 2 * kMaxPartialMemoryUsage;
   // Make sure partial aggregation runs out of memory after first batch.
   CursorParameters params;
-  params.queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+  params.queryCtx = core::QueryCtx::create(executor_.get());
   params.queryCtx->testingOverrideConfigUnsafe({
       {QueryConfig::kMaxPartialAggregationMemory,
        std::to_string(kMaxPartialMemoryUsage)},
       {QueryConfig::kMaxExtendedPartialAggregationMemory,
        std::to_string(kMaxPartialMemoryUsage)},
   });
-  {
-    static_cast<memory::MemoryPoolImpl*>(params.queryCtx->pool())
-        ->testingSetCapacity(kMaxUserMemoryUsage);
-  }
+
   core::PlanNodeId aggNodeId;
   params.planNode = PlanBuilder()
                         .values(vectors)
@@ -1020,344 +1124,11 @@ TEST_F(AggregationTest, partialAggregationMaybeReservationReleaseCheck) {
   EXPECT_EQ(0, runtimeStats.count("partialAggregationPct"));
   // Check all the reserved memory have been released.
   EXPECT_EQ(0, task->pool()->availableReservation());
-  EXPECT_GT(kMaxPartialMemoryUsage, task->pool()->currentBytes());
-}
-
-TEST_F(AggregationTest, spillWithMemoryLimit) {
-  constexpr int32_t kNumDistinct = 2000;
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  rng_.seed(1);
-  rowType_ = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({}, pool());
-  const int32_t numBatches = 5;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType_));
-  }
-  struct {
-    uint64_t aggregationMemLimit;
-    bool expectSpill;
-
-    std::string debugString() const {
-      return fmt::format(
-          "aggregationMemLimit:{}, expectSpill:{}",
-          aggregationMemLimit,
-          expectSpill);
-    }
-  } testSettings[] = {// Memory limit is disabled so spilling is not triggered.
-                      {0, false},
-                      // Memory limit is too small so always trigger spilling.
-                      {1, true},
-                      // Memory limit is too large so spilling is not triggered.
-                      {1'000'000'000, false}};
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
-    auto results = AssertQueryBuilder(
-                       PlanBuilder()
-                           .values(batches)
-                           .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                           .planNode())
-                       .queryCtx(queryCtx)
-                       .copyResults(pool_.get());
-    auto task = AssertQueryBuilder(
-                    PlanBuilder()
-                        .values(batches)
-                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                        .planNode())
-                    .queryCtx(queryCtx)
-                    .spillDirectory(tempDirectory->path)
-                    .config(QueryConfig::kSpillEnabled, "true")
-                    .config(QueryConfig::kAggregationSpillEnabled, "true")
-                    .config(
-                        QueryConfig::kAggregationSpillMemoryThreshold,
-                        std::to_string(testData.aggregationMemLimit))
-                    .assertResults(results);
-
-    auto stats = task->taskStats().pipelineStats[0].operatorStats[1];
-    if (testData.expectSpill) {
-      ASSERT_GT(stats.spilledRows, 0);
-      ASSERT_GT(stats.spilledInputBytes, 0);
-      ASSERT_GT(stats.spilledBytes, 0);
-      ASSERT_GT(stats.spilledPartitions, 0);
-      ASSERT_EQ(stats.spilledFiles, batches.size());
-      ASSERT_GT(stats.runtimeStats["spillRuns"].sum, 0);
-      ASSERT_GT(stats.runtimeStats["spillFillTime"].sum, 0);
-      ASSERT_GT(stats.runtimeStats["spillSortTime"].sum, 0);
-      ASSERT_GT(stats.runtimeStats["spillSerializationTime"].sum, 0);
-      ASSERT_GT(stats.runtimeStats["spillFlushTime"].sum, 0);
-      ASSERT_GT(stats.runtimeStats["spillDiskWrites"].sum, 0);
-      ASSERT_GT(stats.runtimeStats["spillWriteTime"].sum, 0);
-    } else {
-      ASSERT_EQ(stats.spilledRows, 0);
-      ASSERT_EQ(stats.spilledInputBytes, 0);
-      ASSERT_EQ(stats.spilledBytes, 0);
-      ASSERT_EQ(stats.spilledPartitions, 0);
-      ASSERT_EQ(stats.spilledFiles, 0);
-      ASSERT_EQ(stats.runtimeStats["spillRuns"].sum, 0);
-      ASSERT_EQ(stats.runtimeStats["spillFillTime"].sum, 0);
-      ASSERT_EQ(stats.runtimeStats["spillSortTime"].sum, 0);
-      ASSERT_EQ(stats.runtimeStats["spillSerializationTime"].sum, 0);
-      ASSERT_EQ(stats.runtimeStats["spillFlushTime"].sum, 0);
-      ASSERT_EQ(stats.runtimeStats["spillDiskWrites"].sum, 0);
-      ASSERT_EQ(stats.runtimeStats["spillWriteTime"].sum, 0);
-    }
-    ASSERT_EQ(
-        stats.runtimeStats["spillSerializationTime"].count,
-        stats.runtimeStats["spillFlushTime"].count);
-    ASSERT_EQ(
-        stats.runtimeStats["spillDiskWrites"].count,
-        stats.runtimeStats["spillWriteTime"].count);
-    OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
-  }
-}
-
-DEBUG_ONLY_TEST_F(AggregationTest, spillWithEmptyPartition) {
-  constexpr int32_t kNumDistinct = 100'000;
-  constexpr int64_t kMaxBytes = 20LL << 20; // 20 MB
-  rowType_ = ROW({"c0", "a"}, {INTEGER(), VARCHAR()});
-  // Used to calculate the aggregation spilling partition number.
-  const int kPartitionStartBit = 29;
-  const int kPartitionsBits = 2;
-  const HashBitRange hashBits{
-      kPartitionStartBit, kPartitionStartBit + kPartitionsBits};
-  const int kNumPartitions = hashBits.numPartitions();
-  std::vector<uint64_t> hashes(1);
-
-  for (int emptyPartitionNum : {0, 1, 3}) {
-    SCOPED_TRACE(fmt::format("emptyPartitionNum: {}", emptyPartitionNum));
-    rng_.seed(1);
-    // The input batch has kNumDistinct distinct keys. The repeat count of a key
-    // is given by min(1, (k % 100) - 90). The batch is repeated 3 times, each
-    // time in a different order.
-    auto rowVector =
-        BaseVector::create<RowVector>(rowType_, kNumDistinct, pool_.get());
-    SelectivityVector allRows(kNumDistinct);
-    const TypePtr keyType = rowVector->type()->childAt(0);
-    const TypePtr valueType = rowVector->type()->childAt(1);
-    auto rowContainer = makeRowContainer({keyType}, {valueType});
-    // Used to check hash aggregation partition.
-    char* testRow = rowContainer->newRow();
-    std::vector<char*> testRows(1, testRow);
-    const auto testRowSet = folly::Range<char**>(testRows.data(), 1);
-
-    folly::F14FastSet<uint64_t> order1;
-    folly::F14FastSet<uint64_t> order2;
-    folly::F14FastSet<uint64_t> order3;
-
-    auto keyVector = rowVector->childAt(0)->as<FlatVector<int32_t>>();
-    keyVector->resize(kNumDistinct);
-    auto valueVector = rowVector->childAt(1)->as<FlatVector<StringView>>();
-    valueVector->resize(kNumDistinct);
-
-    DecodedVector decodedVector(*keyVector, allRows);
-    int32_t totalCount = 0;
-    for (int key = 0, index = 0; index < kNumDistinct; ++key) {
-      keyVector->set(index, key);
-      // Skip the empty partition.
-      rowContainer->store(decodedVector, index, testRow, 0);
-      // Calculate hashes for this batch of spill candidates.
-      rowContainer->hash(0, testRowSet, false, hashes.data());
-      const int partitionNum = hashBits.partition(hashes[0], kNumPartitions);
-      if (partitionNum == emptyPartitionNum) {
-        continue;
-      }
-      std::string str = fmt::format("{}{}", key, key);
-      valueVector->set(index, StringView(str));
-      const int numRepeats = std::max(1, (index % 100) - 90);
-      // We make random permutations of the data by adding the indices into a
-      // set with a random 6 high bits followed by a serial number. These are
-      // inlined in the F14FastSet in an order that depends on the hash number.
-      for (auto i = 0; i < numRepeats; ++i) {
-        ++totalCount;
-        insertRandomOrder(index, totalCount, order1);
-        insertRandomOrder(index, totalCount, order2);
-        insertRandomOrder(index, totalCount, order3);
-      }
-      ++index;
-    }
-    std::vector<RowVectorPtr> batches;
-    makeBatches(rowVector, order1, batches);
-    makeBatches(rowVector, order2, batches);
-    makeBatches(rowVector, order3, batches);
-    auto results =
-        AssertQueryBuilder(PlanBuilder()
-                               .values(batches)
-                               .singleAggregation({"c0"}, {"array_agg(c1)"})
-                               .planNode())
-            .copyResults(pool_.get());
-
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
-
-    SCOPED_TESTVALUE_SET(
-        "facebook::velox::exec::Spiller",
-        std::function<void(const HashBitRange*)>(
-            ([&](const HashBitRange* spillerBitRange) {
-              ASSERT_EQ(kPartitionStartBit, spillerBitRange->begin());
-              ASSERT_EQ(
-                  kPartitionStartBit + kPartitionsBits, spillerBitRange->end());
-            })));
-
-    auto task =
-        AssertQueryBuilder(PlanBuilder()
-                               .values(batches)
-                               .singleAggregation({"c0"}, {"array_agg(c1)"})
-                               .planNode())
-            .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(QueryConfig::kSpillEnabled, "true")
-            .config(QueryConfig::kAggregationSpillEnabled, "true")
-            .config(QueryConfig::kMinSpillRunSize, std::to_string(1000'000'000))
-            .config(
-                QueryConfig::kAggregationSpillPartitionBits,
-                std::to_string(kPartitionsBits))
-            .config(
-                QueryConfig::kSpillStartPartitionBit,
-                std::to_string(kPartitionStartBit))
-            .config(QueryConfig::kPreferredOutputBatchBytes, "1024")
-            .assertResults(results);
-
-    auto stats = task->taskStats().pipelineStats;
-    // Check spilled bytes.
-    EXPECT_LT(0, stats[0].operatorStats[1].spilledInputBytes);
-    EXPECT_LT(0, stats[0].operatorStats[1].spilledBytes);
-    EXPECT_GE(kNumPartitions - 1, stats[0].operatorStats[1].spilledPartitions);
-    OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
-  }
-}
-
-TEST_F(AggregationTest, spillWithNonSpillingPartition) {
-  constexpr int32_t kNumDistinct = 100'000;
-  constexpr int64_t kMaxBytes = 20LL << 20; // 20 MB
-  rowType_ = ROW({"c0", "a"}, {INTEGER(), VARCHAR()});
-  // Used to calculate the aggregation spilling partition number.
-  const int kPartitionsBits = 2;
-  const HashBitRange hashBits{29, 31};
-  const int kNumPartitions = hashBits.numPartitions();
-  std::vector<uint64_t> hashes(1);
-
-  // Build two partitions one with large amount of data and the other with a
-  // small amount of data (only one row).
-  const int kLargePartitionNum = 1;
-  const int kSmallPartitionNum = 0;
-  rng_.seed(1);
-  // The input batch has kNumDistinct distinct keys. The repeat count of a key
-  // is given by min(1, (k % 100) - 90). The batch is repeated 3 times, each
-  // time in a different order.
-  auto rowVector =
-      BaseVector::create<RowVector>(rowType_, kNumDistinct, pool_.get());
-  SelectivityVector allRows(kNumDistinct);
-  const TypePtr keyType = rowVector->type()->childAt(0);
-  const TypePtr valueType = rowVector->type()->childAt(1);
-  auto rowContainer = makeRowContainer({keyType}, {valueType});
-  // Used to check hash aggregation partition.
-  char* testRow = rowContainer->newRow();
-  std::vector<char*> testRows(1, testRow);
-  const auto testRowSet = folly::Range<char**>(testRows.data(), 1);
-
-  folly::F14FastSet<uint64_t> order1;
-  folly::F14FastSet<uint64_t> order2;
-  folly::F14FastSet<uint64_t> order3;
-
-  auto keyVector = rowVector->childAt(0)->as<FlatVector<int32_t>>();
-  keyVector->resize(kNumDistinct);
-  auto valueVector = rowVector->childAt(1)->as<FlatVector<StringView>>();
-  valueVector->resize(kNumDistinct);
-
-  DecodedVector decodedVector(*keyVector, allRows);
-  int32_t totalCount = 0;
-  int32_t numRowsFromSmallPartition = 0;
-  for (int key = 0, index = 0; index < kNumDistinct; ++key) {
-    keyVector->set(index, key);
-    // Skip the empty partition.
-    rowContainer->store(decodedVector, index, testRow, 0);
-    // Calculate hashes for this batch of spill candidates.
-    rowContainer->hash(0, testRowSet, false, hashes.data());
-    const int partitionNum = hashBits.partition(hashes[0], kNumPartitions);
-    if (partitionNum != kSmallPartitionNum &&
-        partitionNum != kLargePartitionNum) {
-      continue;
-    }
-    if (partitionNum == kSmallPartitionNum && numRowsFromSmallPartition > 0) {
-      continue;
-    }
-    numRowsFromSmallPartition += partitionNum == kSmallPartitionNum;
-    std::string str = fmt::format("{}{}", key, key);
-    valueVector->set(index, StringView(str));
-    const int numRepeats = std::max(1, (index % 100) - 90);
-    // We make random permutations of the data by adding the indices into a
-    // set with a random 6 high bits followed by a serial number. These are
-    // inlined in the F14FastSet in an order that depends on the hash number.
-    for (auto i = 0; i < numRepeats; ++i) {
-      ++totalCount;
-      insertRandomOrder(index, totalCount, order1);
-      insertRandomOrder(index, totalCount, order2);
-      insertRandomOrder(index, totalCount, order3);
-    }
-    ++index;
-  }
-  std::vector<RowVectorPtr> batches;
-  makeBatches(rowVector, order1, batches);
-  makeBatches(rowVector, order2, batches);
-  makeBatches(rowVector, order3, batches);
-  auto results =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(batches)
-                             .singleAggregation({"c0"}, {"array_agg(c1)"})
-                             .planNode())
-          .copyResults(pool_.get());
-
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  queryCtx->testingOverrideMemoryPool(
-      memory::defaultMemoryManager().addRootPool(
-          queryCtx->queryId(), kMaxBytes));
-
-  auto task =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(batches)
-                             .singleAggregation({"c0"}, {"array_agg(c1)"})
-                             .planNode())
-          .queryCtx(queryCtx)
-          .spillDirectory(tempDirectory->path)
-          .config(QueryConfig::kSpillEnabled, "true")
-          .config(QueryConfig::kAggregationSpillEnabled, "true")
-          .config(QueryConfig::kAggregationSpillAll, "false")
-          .config(
-              QueryConfig::kAggregationSpillPartitionBits,
-              std::to_string(kPartitionsBits))
-          // Set to increase the hash table a little bit to only trigger spill
-          // on the partition with most spillable data.
-          .config(QueryConfig::kSpillableReservationGrowthPct, "25")
-          .config(QueryConfig::kPreferredOutputBatchBytes, "1024")
-          .assertResults(results);
-
-  auto stats = task->taskStats().pipelineStats;
-  // Check spilled bytes.
-  EXPECT_LT(0, stats[0].operatorStats[1].spilledInputBytes);
-  EXPECT_LT(0, stats[0].operatorStats[1].spilledBytes);
-  EXPECT_EQ(1, stats[0].operatorStats[1].spilledPartitions);
-  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+  EXPECT_GT(kMaxPartialMemoryUsage, task->pool()->reservedBytes());
 }
 
 TEST_F(AggregationTest, spillAll) {
-  VectorFuzzer::Options options;
-  options.vectorSize = 100;
-  VectorFuzzer fuzzer(options, pool());
-  const int numVectors = 10;
-  std::vector<RowVectorPtr> inputs;
-  for (int i = 0; i < numVectors; ++i) {
-    inputs.push_back(fuzzer.fuzzRow(rowType_));
-  }
+  auto inputs = makeVectors(rowType_, 100, 10);
 
   const auto numDistincts =
       AssertQueryBuilder(PlanBuilder()
@@ -1374,28 +1145,31 @@ TEST_F(AggregationTest, spillAll) {
 
   auto results = AssertQueryBuilder(plan).copyResults(pool_.get());
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  auto task = AssertQueryBuilder(plan)
-                  .spillDirectory(tempDirectory->path)
-                  .config(QueryConfig::kSpillEnabled, "true")
-                  .config(QueryConfig::kAggregationSpillEnabled, "true")
-                  // Set one spill partition to avoid the test flakiness.
-                  .config(QueryConfig::kAggregationSpillPartitionBits, "0")
-                  // Set the memory trigger limit to be a very small value.
-                  .config(QueryConfig::kAggregationSpillMemoryThreshold, "1024")
-                  .config(QueryConfig::kAggregationSpillAll, "true")
-                  .assertResults(results);
+  for (int numPartitionBits : {1, 2, 3}) {
+    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    TestScopedSpillInjection scopedSpillInjection(100);
+    auto task = AssertQueryBuilder(plan)
+                    .spillDirectory(tempDirectory->getPath())
+                    .config(QueryConfig::kSpillEnabled, true)
+                    .config(QueryConfig::kAggregationSpillEnabled, true)
+                    .config(
+                        QueryConfig::kSpillNumPartitionBits,
+                        std::to_string(numPartitionBits))
+                    .assertResults(results);
 
-  auto stats = task->taskStats().pipelineStats;
-  ASSERT_LT(0, stats[0].operatorStats[1].runtimeStats["spillRuns"].count);
-  // Check spilled bytes.
-  ASSERT_LT(0, stats[0].operatorStats[1].spilledInputBytes);
-  ASSERT_LT(0, stats[0].operatorStats[1].spilledBytes);
-  ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 1);
-  // Verifies all the rows have been spilled.
-  ASSERT_EQ(stats[0].operatorStats[1].spilledRows, numDistincts);
-  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+    auto stats = task->taskStats().pipelineStats;
+    ASSERT_LT(
+        0, stats[0].operatorStats[1].runtimeStats[Operator::kSpillRuns].count);
+    // Check spilled bytes.
+    ASSERT_LT(0, stats[0].operatorStats[1].spilledInputBytes);
+    ASSERT_LT(0, stats[0].operatorStats[1].spilledBytes);
+    ASSERT_EQ(
+        stats[0].operatorStats[1].spilledPartitions, 1 << numPartitionBits);
+    // Verifies all the rows have been spilled.
+    ASSERT_EQ(stats[0].operatorStats[1].spilledRows, numDistincts);
+    OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+  }
 }
 
 // Verify number of memory allocations in the HashAggregation operator.
@@ -1423,11 +1197,9 @@ TEST_F(AggregationTest, memoryAllocations) {
 
   auto task = assertQuery(plan, "SELECT sum(c0 + c1) FROM tmp");
 
-  // Verify memory allocations. Project operator should allocate a single vector
-  // and re-use it. Aggregation should make 2 allocations: 1 for the
+  // Verify memory allocations. Aggregation should make 2 allocations: 1 for the
   // RowContainer holding single accumulator and 1 for the result.
   auto planStats = toPlanStats(task->taskStats());
-  ASSERT_EQ(1, planStats.at(projectNodeId).numMemoryAllocations);
   ASSERT_EQ(2, planStats.at(aggNodeId).numMemoryAllocations);
 
   plan = PlanBuilder()
@@ -1440,13 +1212,11 @@ TEST_F(AggregationTest, memoryAllocations) {
 
   task = assertQuery(plan, "SELECT c0, sum(c0 + c1) FROM tmp GROUP BY 1");
 
-  // Verify memory allocations. Project operator should allocate a single vector
-  // and re-use it. Aggregation should make 5 allocations: 1 for the hash table,
-  // 1 for the RowContainer holding accumulators, 3 for results (2 for values
-  // and nulls buffers of the grouping key column, 1 for sum column).
+  // Verify memory allocations. Aggregation should make 4 allocations: 1 for the
+  // hash table, 1 for the RowContainer holding accumulators, 2 for results (1
+  // for values of the grouping key column, 1 for sum column).
   planStats = toPlanStats(task->taskStats());
-  ASSERT_EQ(1, planStats.at(projectNodeId).numMemoryAllocations);
-  ASSERT_EQ(5, planStats.at(aggNodeId).numMemoryAllocations);
+  ASSERT_EQ(4, planStats.at(aggNodeId).numMemoryAllocations);
 }
 
 TEST_F(AggregationTest, groupingSets) {
@@ -1477,6 +1247,28 @@ TEST_F(AggregationTest, groupingSets) {
       plan,
       "SELECT k1, k2, count(1), sum(a), max(b) FROM tmp GROUP BY GROUPING SETS ((k1), (k2))");
 
+  // Distinct aggregations.
+  plan = PlanBuilder()
+             .values({data})
+             .groupId({"k1", "k2"}, {{"k1"}, {"k2"}}, {})
+             .singleAggregation({"k1", "k2", "group_id"}, {})
+             .project({"k1", "k2"})
+             .planNode();
+
+  assertQuery(
+      plan, "SELECT k1, k2 FROM tmp GROUP BY GROUPING SETS ((k1), (k2))");
+
+  // Distinct aggregations with global grouping sets.
+  plan = PlanBuilder()
+             .values({data})
+             .groupId({"k1", "k2"}, {{"k1"}, {"k2"}, {}}, {})
+             .singleAggregation({"k1", "k2", "group_id"}, {})
+             .project({"k1", "k2"})
+             .planNode();
+
+  assertQuery(
+      plan, "SELECT k1, k2 FROM tmp GROUP BY GROUPING SETS ((k1), (k2), ())");
+
   // Compute a subset of aggregates per grouping set by using masks based on
   // group_id column.
   plan = PlanBuilder()
@@ -1618,6 +1410,135 @@ TEST_F(AggregationTest, groupingSetsSameKey) {
       "select o_key, o_key as o_key_1, o_status FROM tmp) GROUP BY GROUPING SETS ((o_key, o_key_1), (o_key), (o_key_1), ())");
 }
 
+TEST_F(AggregationTest, groupingSetsEmptyInput) {
+  auto data = makeRowVector(
+      {"c1", "c2"},
+      {makeFlatVector<int64_t>({0, 1, 2, 3, 4}),
+       makeFlatVector<std::string>({"", "x", "xx", "xxx", "xxxx"})});
+
+  createDuckDbTable({data});
+
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .filter("c1 < 0")
+          .groupId({"c1"}, {{"c1"}, {}}, {"c2"})
+          .singleAggregation({"c1", "group_id"}, {"count(c2) as count_c2"}, {})
+          .project({"count_c2"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT count(c2) as count_c2 FROM tmp WHERE c1 < 0 GROUP BY GROUPING SETS ((c1), ())");
+
+  plan =
+      PlanBuilder()
+          .values({data})
+          .filter("c1 < 0")
+          .groupId({"c1"}, {{"c1"}, {}}, {"c2"})
+          .partialAggregation({"c1", "group_id"}, {"count(c2) as count_c2"}, {})
+          .finalAggregation()
+          .project({"count_c2"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT count(c2) as count_c2 FROM tmp WHERE c1 < 0 GROUP BY GROUPING SETS ((c1), ())");
+
+  plan =
+      PlanBuilder()
+          .values({data})
+          .filter("c1 < 0")
+          .groupId({"c1"}, {{"c1"}, {}}, {"c2"})
+          .partialAggregation({"c1", "group_id"}, {"count(c2) as count_c2"}, {})
+          .intermediateAggregation()
+          .finalAggregation()
+          .project({"count_c2"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT count(c2) as count_c2 FROM tmp WHERE c1 < 0 GROUP BY GROUPING SETS ((c1), ())");
+
+  // Distinct aggregations with GROUPING SETS.
+  plan = PlanBuilder()
+             .values({data})
+             .filter("c1 < 0")
+             .groupId({"c1"}, {{"c1"}, {}}, {})
+             .partialAggregation({"c1", "group_id"}, {}, {})
+             .finalAggregation()
+             .project({"c1"})
+             .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT c1 FROM tmp WHERE c1 < 0 GROUP BY GROUPING SETS ((c1), ())");
+
+  plan =
+      PlanBuilder()
+          .values({data})
+          .filter("c1 < 0")
+          .groupId({"c1"}, {{}, {}}, {"c2"})
+          .partialAggregation({"c1", "group_id"}, {"count(c2) as count_c2"}, {})
+          .intermediateAggregation()
+          .finalAggregation()
+          .project({"count_c2"})
+          .planNode();
+
+  assertQuery(plan, makeRowVector({makeFlatVector<int64_t>({0, 0})}));
+
+  // Distinct aggregations over empty input with global GROUPING SETs.
+  plan = PlanBuilder()
+             .values({data})
+             .filter("c1 < 0")
+             .groupId({"c1"}, {{}, {}}, {})
+             .singleAggregation({"c1", "group_id"}, {}, {})
+             .planNode();
+
+  assertQuery(
+      plan,
+      makeRowVector({
+          makeAllNullFlatVector<int64_t>(2),
+          makeFlatVector<int64_t>({0, 1}),
+      }));
+
+  // Aggregations over distinct inputs over empty input with global grouping
+  // sets.
+  plan = PlanBuilder()
+             .values({data})
+             .filter("c1 < 0")
+             .groupId({"c1"}, {{}, {}}, {"c2"})
+             .singleAggregation(
+                 {"c1", "group_id"}, {"count(distinct c2)", "min(distinct c2)"})
+             .planNode();
+
+  assertQuery(
+      plan,
+      makeRowVector({
+          makeAllNullFlatVector<int64_t>(2),
+          makeFlatVector<int64_t>({0, 1}),
+          makeFlatVector<int64_t>({0, 0}),
+          makeAllNullFlatVector<std::string>(2),
+      }));
+
+  // Aggregations over sorted inputs over empty input with global grouping sets.
+  plan =
+      PlanBuilder()
+          .values({data})
+          .filter("c1 < 0")
+          .groupId({"c1"}, {{}, {}}, {"c2"})
+          .singleAggregation({"c1", "group_id"}, {"array_agg(c2 order by c2)"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      makeRowVector({
+          makeAllNullFlatVector<int64_t>(2),
+          makeFlatVector<int64_t>({0, 1}),
+          makeAllNullArrayVector(2, VARCHAR()),
+      }));
+}
+
 TEST_F(AggregationTest, outputBatchSizeCheckWithSpill) {
   const int numVectors = 5;
   const int vectorSize = 20;
@@ -1682,21 +1603,17 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithSpill) {
     createDuckDbTable(inputs);
     auto tempDirectory = exec::test::TempDirectoryPath::create();
     core::PlanNodeId aggrNodeId;
+    TestScopedSpillInjection scopedSpillInjection(100);
     auto task =
         AssertQueryBuilder(duckDbQueryRunner_)
-            .spillDirectory(tempDirectory->path)
-            .config(QueryConfig::kSpillEnabled, "true")
-            .config(QueryConfig::kAggregationSpillEnabled, "true")
-            // Set one spill partition to avoid the test flakiness.
-            .config(QueryConfig::kAggregationSpillPartitionBits, "0")
-            // Set the memory trigger limit to be a very small value.
-            .config(QueryConfig::kAggregationSpillMemoryThreshold, "1")
-            .config(QueryConfig::kAggregationSpillAll, "true")
+            .spillDirectory(tempDirectory->getPath())
+            .config(QueryConfig::kSpillEnabled, true)
+            .config(QueryConfig::kAggregationSpillEnabled, true)
             .config(
                 QueryConfig::kPreferredOutputBatchBytes,
                 std::to_string(testData.maxOutputBytes))
             .config(
-                QueryConfig::kPreferredOutputBatchRows,
+                QueryConfig::kMaxOutputBatchRows,
                 std::to_string(testData.maxOutputRows))
             .plan(PlanBuilder()
                       .values(inputs)
@@ -1729,21 +1646,20 @@ TEST_F(AggregationTest, spillDuringOutputProcessing) {
   const int numOutputRows = 5;
   auto tempDirectory = exec::test::TempDirectoryPath::create();
   core::PlanNodeId aggrNodeId;
+  TestScopedSpillInjection scopedSpillInjection(100);
   auto task =
       AssertQueryBuilder(duckDbQueryRunner_)
-          .spillDirectory(tempDirectory->path)
-          .config(QueryConfig::kSpillEnabled, "true")
-          .config(QueryConfig::kAggregationSpillEnabled, "true")
-          .config(QueryConfig::kAggregationSpillPartitionBits, "2")
-          .config(QueryConfig::kTestingSpillPct, "100")
+          .spillDirectory(tempDirectory->getPath())
+          .config(QueryConfig::kSpillEnabled, true)
+          .config(QueryConfig::kAggregationSpillEnabled, true)
           // Set very large output buffer size, the number of output rows is
           // effectively controlled by 'kPreferredOutputBatchBytes'.
           .config(
               QueryConfig::kPreferredOutputBatchBytes,
               std::to_string(1'000'000'000))
           .config(
-              QueryConfig::kPreferredOutputBatchRows,
-              std::to_string(numOutputRows))
+              QueryConfig::kMaxOutputBatchRows, std::to_string(numOutputRows))
+          .config(QueryConfig::kSpillNumPartitionBits, "0")
           .plan(PlanBuilder()
                     .values({input})
                     .singleAggregation({"c0", "c1"}, {"max(c2)", "min(c3)"})
@@ -1822,7 +1738,7 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithoutSpill) {
                 QueryConfig::kPreferredOutputBatchBytes,
                 std::to_string(testData.maxOutputBytes))
             .config(
-                QueryConfig::kPreferredOutputBatchRows,
+                QueryConfig::kMaxOutputBatchRows,
                 std::to_string(testData.maxOutputRows))
             .plan(PlanBuilder()
                       .values(inputs)
@@ -1850,6 +1766,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
   for (int32_t i = 0; i < numBatches; ++i) {
     batches.push_back(fuzzer.fuzzRow(rowType_));
   }
+
   createDuckDbTable(batches);
 
   for (int32_t minSpillableReservationPct : {5, 50, 100}) {
@@ -1863,7 +1780,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
               memory::MemoryPool& pool = groupingSet->testingPool();
               const auto availableReservationBytes =
                   pool.availableReservation();
-              const auto currentUsedBytes = pool.currentBytes();
+              const auto currentUsedBytes = pool.usedBytes();
               // Verifies we always have min reservation after ensuring the
               // input.
               ASSERT_GE(
@@ -1874,9 +1791,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
     auto spillDirectory = exec::test::TempDirectoryPath::create();
     auto task =
         AssertQueryBuilder(duckDbQueryRunner_)
-            .spillDirectory(spillDirectory->path)
-            .config(QueryConfig::kSpillEnabled, "true")
-            .config(QueryConfig::kAggregationSpillEnabled, "true")
+            .spillDirectory(spillDirectory->getPath())
+            .config(QueryConfig::kSpillEnabled, true)
+            .config(QueryConfig::kAggregationSpillEnabled, true)
             .config(
                 QueryConfig::kMinSpillableReservationPct,
                 std::to_string(minSpillableReservationPct))
@@ -1894,50 +1811,135 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
 }
 
 TEST_F(AggregationTest, distinctWithSpilling) {
-  auto vectors = makeVectors(rowType_, 10, 100);
-  createDuckDbTable(vectors);
-  auto spillDirectory = exec::test::TempDirectoryPath::create();
-  core::PlanNodeId aggrNodeId;
-  auto task = AssertQueryBuilder(duckDbQueryRunner_)
-                  .spillDirectory(spillDirectory->path)
-                  .config(QueryConfig::kSpillEnabled, "true")
-                  .config(QueryConfig::kAggregationSpillEnabled, "true")
-                  .config(QueryConfig::kTestingSpillPct, "100")
-                  .plan(PlanBuilder()
-                            .values(vectors)
-                            .singleAggregation({"c0"}, {}, {})
-                            .capturePlanNodeId(aggrNodeId)
-                            .planNode())
-                  .assertResults("SELECT distinct c0 FROM tmp");
-  // Verify that spilling is not triggered.
-  ASSERT_EQ(toPlanStats(task->taskStats()).at(aggrNodeId).spilledInputBytes, 0);
-  ASSERT_EQ(toPlanStats(task->taskStats()).at(aggrNodeId).spilledBytes, 0);
-  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
-}
+  struct TestParam {
+    std::vector<RowVectorPtr> inputs;
+    std::function<void(uint32_t)> expectedSpillFilesCheck{nullptr};
+  };
 
-TEST_F(AggregationTest, preGroupedAggregationWithSpilling) {
-  std::vector<RowVectorPtr> vectors;
-  int64_t val = 0;
-  for (int32_t i = 0; i < 4; ++i) {
-    vectors.push_back(makeRowVector(
-        {// Pre-grouped key.
-         makeFlatVector<int64_t>(10, [&](auto /*row*/) { return val++ / 5; }),
-         // Payload.
-         makeFlatVector<int64_t>(10, [](auto row) { return row; }),
-         makeFlatVector<int64_t>(10, [](auto row) { return row; })}));
+  std::vector<TestParam> testParams{
+      {makeVectors(rowType_, 10, 100),
+       [](uint32_t spilledFiles) { ASSERT_GE(spilledFiles, 100); }},
+      {{makeRowVector(
+           {"c0"},
+           {makeFlatVector<int64_t>(
+               2'000, [](vector_size_t /* unused */) { return 100; })})},
+       [](uint32_t spilledFiles) { ASSERT_EQ(spilledFiles, 1); }}};
+
+  for (const auto& testParam : testParams) {
+    createDuckDbTable(testParam.inputs);
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    core::PlanNodeId aggrNodeId;
+    TestScopedSpillInjection scopedSpillInjection(100);
+    auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                    .spillDirectory(spillDirectory->getPath())
+                    .config(QueryConfig::kSpillEnabled, true)
+                    .config(QueryConfig::kAggregationSpillEnabled, true)
+                    .plan(PlanBuilder()
+                              .values(testParam.inputs)
+                              .singleAggregation({"c0"}, {}, {})
+                              .capturePlanNodeId(aggrNodeId)
+                              .planNode())
+                    .assertResults("SELECT distinct c0 FROM tmp");
+
+    // Verify that spilling is not triggered.
+    const auto planNodeStatsMap = toPlanStats(task->taskStats());
+    const auto& aggrNodeStats = planNodeStatsMap.at(aggrNodeId);
+    ASSERT_GT(aggrNodeStats.spilledInputBytes, 0);
+    ASSERT_EQ(aggrNodeStats.spilledPartitions, 8);
+    ASSERT_GT(aggrNodeStats.spilledBytes, 0);
+    testParam.expectedSpillFilesCheck(aggrNodeStats.spilledFiles);
+    OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
   }
+}
+
+TEST_F(AggregationTest, spillingForAggrsWithDistinct) {
+  auto vectors = makeVectors(rowType_, 100, 10);
   createDuckDbTable(vectors);
   auto spillDirectory = exec::test::TempDirectoryPath::create();
   core::PlanNodeId aggrNodeId;
+  TestScopedSpillInjection scopedSpillInjection(100);
   auto task =
       AssertQueryBuilder(duckDbQueryRunner_)
-          .spillDirectory(spillDirectory->path)
-          .config(QueryConfig::kSpillEnabled, "true")
-          .config(QueryConfig::kAggregationSpillEnabled, "true")
-          .config(QueryConfig::kTestingSpillPct, "100")
+          .spillDirectory(spillDirectory->getPath())
+          .config(QueryConfig::kSpillEnabled, true)
+          .config(QueryConfig::kAggregationSpillEnabled, true)
           .plan(PlanBuilder()
                     .values(vectors)
-                    .aggregation(
+                    .singleAggregation({"c1"}, {"count(DISTINCT c0)"}, {})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
+          .assertResults("SELECT c1, count(DISTINCT c0) FROM tmp GROUP BY c1");
+  // Verify that spilling is not triggered.
+  const auto& queryConfig = task->queryCtx()->queryConfig();
+  ASSERT_TRUE(queryConfig.spillEnabled());
+  ASSERT_TRUE(queryConfig.aggregationSpillEnabled());
+  ASSERT_EQ(toPlanStats(task->taskStats()).at(aggrNodeId).spilledBytes, 0);
+  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+}
+
+TEST_F(AggregationTest, spillingForAggrsWithSorting) {
+  auto vectors = makeVectors(rowType_, 100, 10);
+  createDuckDbTable(vectors);
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+
+  core::PlanNodeId aggrNodeId;
+
+  auto testPlan = [&](const core::PlanNodePtr& plan, const std::string& sql) {
+    SCOPED_TRACE(sql);
+    TestScopedSpillInjection scopedSpillInjection(100);
+    auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                    .spillDirectory(spillDirectory->getPath())
+                    .config(QueryConfig::kSpillEnabled, true)
+                    .config(QueryConfig::kAggregationSpillEnabled, true)
+                    .plan(plan)
+                    .assertResults(sql);
+
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& stats = taskStats.at(aggrNodeId);
+    checkSpillStats(stats, true);
+    OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+  };
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .singleAggregation({"c0"}, {"array_agg(c1 ORDER BY c1)"}, {})
+                  .capturePlanNodeId(aggrNodeId)
+                  .planNode();
+  testPlan(plan, "SELECT c0, array_agg(c1 ORDER BY c1) FROM tmp GROUP BY 1");
+
+  plan = PlanBuilder()
+             .values(vectors)
+             .project({"c0 % 7", "c1"})
+             .singleAggregation({"p0"}, {"array_agg(c1 ORDER BY c1)"}, {})
+             .capturePlanNodeId(aggrNodeId)
+             .planNode();
+  testPlan(
+      plan, "SELECT c0 % 7, array_agg(c1 ORDER BY c1) FROM tmp GROUP BY 1");
+}
+
+TEST_F(AggregationTest, preGroupedAggregationWithSpilling) {
+  std::vector<RowVectorPtr> vectors;
+  int64_t val = 0;
+  for (int32_t i = 0; i < 4; ++i) {
+    vectors.push_back(makeRowVector(
+        {// Pre-grouped key.
+         makeFlatVector<int64_t>(10, [&](auto /*row*/) { return val++ / 5; }),
+         // Payload.
+         makeFlatVector<int64_t>(10, [](auto row) { return row; }),
+         makeFlatVector<int64_t>(10, [](auto row) { return row; })}));
+  }
+  createDuckDbTable(vectors);
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  core::PlanNodeId aggrNodeId;
+  TestScopedSpillInjection scopedSpillInjection(100);
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .spillDirectory(spillDirectory->getPath())
+          .config(QueryConfig::kSpillEnabled, true)
+          .config(QueryConfig::kAggregationSpillEnabled, true)
+          .plan(PlanBuilder()
+                    .values(vectors)
+                    .aggregation(
                         {"c0", "c1"},
                         {"c0"},
                         {"sum(c2)"},
@@ -2005,12 +2007,8 @@ TEST_F(AggregationTest, adaptiveOutputBatchRows) {
 DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringInputProcessing) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
+  const int numBatches = 10;
+  auto batches = makeVectors(rowType, 1000, numBatches);
 
   struct {
     // 0: trigger reclaim with some input processed.
@@ -2032,10 +2030,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringInputProcessing) {
     SCOPED_TRACE(testData.debugString());
 
     auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -2050,7 +2047,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringInputProcessing) {
     folly::EventCount testWait;
     auto testWaitKey = testWait.prepareWait();
 
-    std::atomic<int> numInputs{0};
+    std::atomic_int numInputs{0};
     Operator* op;
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::addInput",
@@ -2086,19 +2083,17 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringInputProcessing) {
 
     std::thread taskThread([&]() {
       if (testData.spillEnabled) {
-        auto task =
-            AssertQueryBuilder(
-                PlanBuilder()
-                    .values(batches)
-                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                    .planNode())
-                .queryCtx(queryCtx)
-                .spillDirectory(tempDirectory->path)
-                .config(QueryConfig::kSpillEnabled, "true")
-                .config(QueryConfig::kAggregationSpillEnabled, "true")
-                .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
-                .maxDrivers(1)
-                .assertResults(expectedResult);
+        auto task = AssertQueryBuilder(
+                        PlanBuilder()
+                            .values(batches)
+                            .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                            .planNode())
+                        .queryCtx(queryCtx)
+                        .spillDirectory(tempDirectory->getPath())
+                        .config(QueryConfig::kSpillEnabled, true)
+                        .config(QueryConfig::kAggregationSpillEnabled, true)
+                        .maxDrivers(1)
+                        .assertResults(expectedResult);
       } else {
         auto task = AssertQueryBuilder(
                         PlanBuilder()
@@ -2129,19 +2124,29 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringInputProcessing) {
     }
 
     if (testData.expectedReclaimable) {
-      const auto usedMemory = op->pool()->currentBytes();
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-          reclaimerStats_);
+      const auto usedMemory = op->pool()->usedBytes();
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        op->pool()->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+            0,
+            reclaimerStats_);
+      }
+      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+      ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+      reclaimerStats_.reset();
       // The hash table itself in the grouping set is not cleared so it still
       // uses some memory.
-      ASSERT_LT(op->pool()->currentBytes(), usedMemory);
+      ASSERT_LT(op->pool()->usedBytes(), usedMemory);
     } else {
-      VELOX_ASSERT_THROW(
-          op->reclaim(
-              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-              reclaimerStats_),
-          "");
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        VELOX_ASSERT_THROW(
+            op->reclaim(
+                folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+                reclaimerStats_),
+            "");
+      }
     }
 
     Task::resume(task);
@@ -2151,7 +2156,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringInputProcessing) {
     auto stats = task->taskStats().pipelineStats;
     if (testData.expectedReclaimable) {
       ASSERT_GT(stats[0].operatorStats[1].spilledBytes, 0);
-      ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 4);
+      ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 8);
     } else {
       ASSERT_EQ(stats[0].operatorStats[1].spilledBytes, 0);
       ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 0);
@@ -2173,10 +2178,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
   }
 
   auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  queryCtx->testingOverrideMemoryPool(
-      memory::defaultMemoryManager().addRootPool(
-          queryCtx->queryId(), kMaxBytes));
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   auto expectedResult =
       AssertQueryBuilder(PlanBuilder()
                              .values(batches)
@@ -2201,7 +2205,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
         op = testOp;
       })));
 
-  std::atomic<bool> injectOnce{true};
+  std::atomic_bool injectOnce{true};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
       std::function<void(memory::MemoryPoolImpl*)>(
@@ -2231,10 +2235,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
                            .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
                            .planNode())
         .queryCtx(queryCtx)
-        .spillDirectory(tempDirectory->path)
-        .config(QueryConfig::kSpillEnabled, "true")
-        .config(QueryConfig::kAggregationSpillEnabled, "true")
-        .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
+        .spillDirectory(tempDirectory->getPath())
+        .config(QueryConfig::kSpillEnabled, true)
+        .config(QueryConfig::kAggregationSpillEnabled, true)
         .maxDrivers(1)
         .assertResults(expectedResult);
   });
@@ -2251,13 +2254,20 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
   ASSERT_TRUE(reclaimable);
   ASSERT_GT(reclaimableBytes, 0);
 
-  const auto usedMemory = op->pool()->currentBytes();
-  op->reclaim(
-      folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-      reclaimerStats_);
+  const auto usedMemory = op->pool()->usedBytes();
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    op->pool()->reclaim(
+        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+        0,
+        reclaimerStats_);
+  }
+  ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+  ASSERT_GE(reclaimerStats_.reclaimedBytes, 0);
+  reclaimerStats_.reset();
   // The hash table itself in the grouping set is not cleared so it still
   // uses some memory.
-  ASSERT_LT(op->pool()->currentBytes(), usedMemory);
+  ASSERT_LT(op->pool()->usedBytes(), usedMemory);
 
   driverWait.notify();
   Task::resume(task);
@@ -2265,7 +2275,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
 
   auto stats = task->taskStats().pipelineStats;
   ASSERT_GT(stats[0].operatorStats[1].spilledBytes, 0);
-  ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 4);
+  ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 8);
   OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
   ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{});
 }
@@ -2273,22 +2283,16 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
 DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringAllocation) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
+  auto batches = makeVectors(rowType, 1000, 10);
 
-  std::vector<bool> enableSpillings = {false, true};
+  const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
 
     auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+    auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
+        memory::memoryManager()->addRootPool(queryCtx->queryId(), kMaxBytes));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -2314,7 +2318,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringAllocation) {
           op = testOp;
         })));
 
-    std::atomic<bool> injectOnce{true};
+    std::atomic_bool injectOnce{true};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
         std::function<void(memory::MemoryPoolImpl*)>(
@@ -2350,10 +2354,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringAllocation) {
                 .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
                 .planNode())
             .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(QueryConfig::kSpillEnabled, "true")
-            .config(QueryConfig::kAggregationSpillEnabled, "true")
-            .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
+            .spillDirectory(tempDirectory->getPath())
+            .config(QueryConfig::kSpillEnabled, true)
+            .config(QueryConfig::kAggregationSpillEnabled, true)
             .maxDrivers(1)
             .assertResults(expectedResult);
       } else {
@@ -2381,20 +2384,14 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringAllocation) {
 
     if (enableSpilling) {
       ASSERT_GT(reclaimableBytes, 0);
-      const auto usedMemory = op->pool()->currentBytes();
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-          reclaimerStats_);
-      // No reclaim as the operator is under non-reclaimable section.
-      ASSERT_EQ(usedMemory, op->pool()->currentBytes());
     } else {
       ASSERT_EQ(reclaimableBytes, 0);
-      VELOX_ASSERT_THROW(
-          op->reclaim(
-              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-              reclaimerStats_),
-          "");
     }
+    VELOX_ASSERT_THROW(
+        op->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+            reclaimerStats_),
+        "");
 
     driverWait.notify();
     Task::resume(task);
@@ -2406,27 +2403,22 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringAllocation) {
     ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 0);
     OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
   }
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{1});
+  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{0});
 }
 
 DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringOutputProcessing) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
+  auto batches = makeVectors(rowType, 1000, 10);
 
-  std::vector<bool> enableSpillings = {false, true};
+  const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
+
     auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -2436,12 +2428,12 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringOutputProcessing) {
             .queryCtx(queryCtx)
             .copyResults(pool_.get());
 
-    std::atomic<bool> driverWaitFlag{true};
+    std::atomic_bool driverWaitFlag{true};
     folly::EventCount driverWait;
-    std::atomic<bool> testWaitFlag{true};
+    std::atomic_bool testWaitFlag{true};
     folly::EventCount testWait;
 
-    std::atomic<bool> injectNoMoreInputOnce{true};
+    std::atomic_bool injectNoMoreInputOnce{true};
     Operator* op{nullptr};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::noMoreInput",
@@ -2476,10 +2468,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringOutputProcessing) {
                 .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
                 .planNode())
             .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(QueryConfig::kSpillEnabled, "true")
-            .config(QueryConfig::kAggregationSpillEnabled, "true")
-            .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
+            .spillDirectory(tempDirectory->getPath())
+            .config(QueryConfig::kSpillEnabled, true)
+            .config(QueryConfig::kAggregationSpillEnabled, true)
             .maxDrivers(1)
             .assertResults(expectedResult);
       } else {
@@ -2509,14 +2500,20 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringOutputProcessing) {
     ASSERT_EQ(reclaimable, enableSpilling);
     if (enableSpilling) {
       ASSERT_GT(reclaimableBytes, 0);
-      const auto usedMemory = op->pool()->currentBytes();
-      op->reclaim(
+      const auto usedMemory = op->pool()->usedBytes();
+      memory::ScopedMemoryArbitrationContext ctx(op->pool());
+      op->pool()->reclaim(
           folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+          0,
           reclaimerStats_);
       ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 0);
-      ASSERT_GT(usedMemory, op->pool()->currentBytes());
+      ASSERT_GT(usedMemory, op->pool()->usedBytes());
+      ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+      reclaimerStats_.reset();
     } else {
       ASSERT_EQ(reclaimableBytes, 0);
+      memory::ScopedMemoryArbitrationContext ctx(op->pool());
       VELOX_ASSERT_THROW(
           op->reclaim(
               folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
@@ -2545,12 +2542,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringOutputProcessing) {
 DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringNonReclaimableSection) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
+  auto batches = makeVectors(rowType, 1000, 10);
 
   struct {
     bool enableSpilling;
@@ -2569,10 +2561,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringNonReclaimableSection) {
     SCOPED_TRACE(fmt::format("testData {}", testData.debugString()));
 
     auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+    auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
+        memory::memoryManager()->addRootPool(queryCtx->queryId(), kMaxBytes));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -2588,19 +2579,19 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringNonReclaimableSection) {
         std::function<void(Driver*)>(
             [&](Driver* testDriver) { driver = testDriver; }));
 
-    std::atomic<bool> driverWaitFlag{true};
+    std::atomic_bool driverWaitFlag{true};
     folly::EventCount driverWait;
-    std::atomic<bool> testWaitFlag{true};
+    std::atomic_bool testWaitFlag{true};
     folly::EventCount testWait;
 
-    std::atomic<bool> injectNonReclaimableSectionOnce{true};
+    std::atomic_bool injectNonReclaimableSectionOnce{true};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::GroupingSet::addInputForActiveRows",
         std::function<void(GroupingSet*)>(([&](GroupingSet* groupSet) {
           if (!testData.nonReclaimableInput) {
             return;
           }
-          if (groupSet->testingPool().currentBytes() == 0) {
+          if (groupSet->testingPool().usedBytes() == 0) {
             return;
           }
           if (!injectNonReclaimableSectionOnce.exchange(false)) {
@@ -2653,10 +2644,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringNonReclaimableSection) {
                 .capturePlanNodeId(aggregationPlanNodeId)
                 .planNode())
             .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(QueryConfig::kSpillEnabled, "true")
-            .config(QueryConfig::kAggregationSpillEnabled, "true")
-            .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
+            .spillDirectory(tempDirectory->getPath())
+            .config(QueryConfig::kSpillEnabled, true)
+            .config(QueryConfig::kAggregationSpillEnabled, true)
             .maxDrivers(1)
             .assertResults(expectedResult);
       } else {
@@ -2688,20 +2678,15 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringNonReclaimableSection) {
     ASSERT_EQ(reclaimable, testData.enableSpilling);
     if (testData.enableSpilling) {
       ASSERT_GT(reclaimableBytes, 0);
-      const auto usedMemory = op->pool()->currentBytes();
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-          reclaimerStats_);
-      ASSERT_EQ(usedMemory, op->pool()->currentBytes());
-      ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
     } else {
       ASSERT_EQ(reclaimableBytes, 0);
-      VELOX_ASSERT_THROW(
-          op->reclaim(
-              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-              reclaimerStats_),
-          "");
     }
+    VELOX_ASSERT_THROW(
+        op->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+            reclaimerStats_),
+        "");
+    ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 0);
 
     driverWaitFlag = false;
     driverWait.notifyAll();
@@ -2722,20 +2707,16 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringNonReclaimableSection) {
 DEBUG_ONLY_TEST_F(AggregationTest, reclaimWithEmptyAggregationTable) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
-  std::vector<bool> enableSpillings = {false, true};
+  auto batches = makeVectors(rowType, 1000, 10);
+
+  const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
+
     auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+    auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
+        memory::memoryManager()->addRootPool(queryCtx->queryId(), kMaxBytes));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -2758,7 +2739,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimWithEmptyAggregationTable) {
             .capturePlanNodeId(aggregationPlanNodeId)
             .planNode();
 
-    std::atomic<bool> injectOnce{true};
+    std::atomic_bool injectOnce{true};
     Operator* op;
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal",
@@ -2779,10 +2760,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimWithEmptyAggregationTable) {
         AssertQueryBuilder(nullptr)
             .plan(aggregationPlan)
             .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(QueryConfig::kSpillEnabled, "true")
-            .config(QueryConfig::kAggregationSpillEnabled, "true")
-            .config(core::QueryConfig::kAggregationSpillPartitionBits, "2")
+            .spillDirectory(tempDirectory->getPath())
+            .config(QueryConfig::kSpillEnabled, true)
+            .config(QueryConfig::kAggregationSpillEnabled, true)
             .maxDrivers(1)
             .assertResults(expectedResult);
       } else {
@@ -2810,12 +2790,14 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimWithEmptyAggregationTable) {
     ASSERT_EQ(reclaimable, enableSpilling);
     if (enableSpilling) {
       ASSERT_EQ(reclaimableBytes, 0);
-      const auto usedMemory = op->pool()->currentBytes();
-      op->reclaim(
+      const auto usedMemory = op->pool()->usedBytes();
+      op->pool()->reclaim(
           folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+          0,
           reclaimerStats_);
+      ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{});
       // No reclaim as the operator has started output processing.
-      ASSERT_EQ(usedMemory, op->pool()->currentBytes());
+      ASSERT_EQ(usedMemory, op->pool()->usedBytes());
     } else {
       ASSERT_EQ(reclaimableBytes, 0);
       VELOX_ASSERT_THROW(
@@ -2841,21 +2823,15 @@ namespace {
 void abortPool(memory::MemoryPool* pool) {
   try {
     VELOX_FAIL("Memory pool manually aborted");
-  } catch (const VeloxException& e) {
+  } catch (const VeloxException&) {
     pool->abort(std::current_exception());
   }
 }
 } // namespace
 
 DEBUG_ONLY_TEST_F(AggregationTest, abortDuringOutputProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
+  auto batches = makeVectors(rowType, 1000, 10);
 
   struct {
     bool abortFromRootMemoryPool;
@@ -2871,33 +2847,21 @@ DEBUG_ONLY_TEST_F(AggregationTest, abortDuringOutputProcessing) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
                 .values(batches)
                 .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
                 .planNode())
-            .queryCtx(queryCtx)
             .copyResults(pool_.get());
 
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
-
-    std::atomic<bool> injectOnce{true};
-    Operator* op;
+    std::atomic_bool injectOnce{true};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::noMoreInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "Aggregation") {
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "Aggregation") {
             return;
           }
-          op = testOp;
           if (!injectOnce.exchange(false)) {
             return;
           }
@@ -2905,51 +2869,33 @@ DEBUG_ONLY_TEST_F(AggregationTest, abortDuringOutputProcessing) {
           ASSERT_EQ(
               driver->task()->enterSuspended(driver->state()),
               StopReason::kNone);
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          // We can't directly reclaim memory from this hash build operator as
+          // its driver thread is running and in suspension state.
+          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
           ASSERT_EQ(
               driver->task()->leaveSuspended(driver->state()),
               StopReason::kAlreadyTerminated);
           VELOX_MEM_POOL_ABORTED("Memory pool aborted");
         })));
 
-    std::thread taskThread([&]() {
-      VELOX_ASSERT_THROW(
-          AssertQueryBuilder(
-              PlanBuilder()
-                  .values(batches)
-                  .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                  .planNode())
-              .queryCtx(queryCtx)
-              .maxDrivers(testData.numDrivers)
-              .assertResults(expectedResult),
-          "");
-    });
-
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->testingOperatorCtx()->task();
-    testData.abortFromRootMemoryPool ? abortPool(queryCtx->pool())
-                                     : abortPool(op->pool());
-    ASSERT_TRUE(op->pool()->aborted());
-    ASSERT_TRUE(queryCtx->pool()->aborted());
-    ASSERT_EQ(queryCtx->pool()->currentBytes(), 0);
-    driverWait.notify();
-    taskThread.join();
-    task.reset();
+    VELOX_ASSERT_THROW(
+        AssertQueryBuilder(
+            PlanBuilder()
+                .values(batches)
+                .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                .planNode())
+            .maxDrivers(testData.numDrivers)
+            .assertResults(expectedResult),
+        "Memory pool manually aborted");
     waitForAllTasksToBeDeleted();
   }
 }
 
 DEBUG_ONLY_TEST_F(AggregationTest, abortDuringInputgProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
+  auto batches = makeVectors(rowType, 1000, 10);
 
   struct {
     bool abortFromRootMemoryPool;
@@ -2965,73 +2911,50 @@ DEBUG_ONLY_TEST_F(AggregationTest, abortDuringInputgProcessing) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
                 .values(batches)
                 .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
                 .planNode())
-            .queryCtx(queryCtx)
             .copyResults(pool_.get());
 
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
-
-    std::atomic<int> numInputs{0};
-    Operator* op;
+    std::atomic_int numInputs{0};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "Aggregation") {
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "Aggregation") {
             return;
           }
-          op = testOp;
-          ++numInputs;
-          if (numInputs != 2) {
+          if (++numInputs != 2) {
             return;
           }
           auto* driver = op->testingOperatorCtx()->driver();
           ASSERT_EQ(
               driver->task()->enterSuspended(driver->state()),
               StopReason::kNone);
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          // We can't directly reclaim memory from this hash build operator as
+          // its driver thread is running and in suspension state.
+          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
           ASSERT_EQ(
               driver->task()->leaveSuspended(driver->state()),
               StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
           VELOX_MEM_POOL_ABORTED("Memory pool aborted");
         })));
 
-    std::thread taskThread([&]() {
-      VELOX_ASSERT_THROW(
-          AssertQueryBuilder(
-              PlanBuilder()
-                  .values(batches)
-                  .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                  .planNode())
-              .queryCtx(queryCtx)
-              .maxDrivers(testData.numDrivers)
-              .assertResults(expectedResult),
-          "");
-    });
-
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->testingOperatorCtx()->task();
-    testData.abortFromRootMemoryPool ? abortPool(queryCtx->pool())
-                                     : abortPool(op->pool());
-    ASSERT_TRUE(op->pool()->aborted());
-    ASSERT_TRUE(queryCtx->pool()->aborted());
-    ASSERT_EQ(queryCtx->pool()->currentBytes(), 0);
-    driverWait.notify();
-    taskThread.join();
-    task.reset();
+    VELOX_ASSERT_THROW(
+        AssertQueryBuilder(
+            PlanBuilder()
+                .values(batches)
+                .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                .planNode())
+            .maxDrivers(testData.numDrivers)
+            .assertResults(expectedResult),
+        "Memory pool manually aborted");
     waitForAllTasksToBeDeleted();
   }
 }
@@ -3054,4 +2977,764 @@ TEST_F(AggregationTest, noAggregationsNoGroupingKeys) {
   // Zero columns.
   ASSERT_EQ(result->type()->size(), 0);
 }
+
+// Reproduces hang in partial distinct aggregation described in
+// https://github.com/facebookincubator/velox/issues/7967 .
+TEST_F(AggregationTest, distinctHang) {
+  static const int64_t kMin = std::numeric_limits<int32_t>::min();
+  static const int64_t kMax = std::numeric_limits<int32_t>::max();
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(
+          5'000,
+          [](auto row) {
+            if (row % 2 == 0) {
+              return kMin + row;
+            } else {
+              return kMax - row;
+            }
+          }),
+      makeFlatVector<int64_t>(
+          5'000,
+          [](auto row) {
+            if (row % 2 == 0) {
+              return kMin - row;
+            } else {
+              return kMax + row;
+            }
+          }),
+  });
+
+  auto newData = makeRowVector({
+      makeFlatVector<int64_t>(
+          5'000, [](auto row) { return kMin + row + 5'000; }),
+      makeFlatVector<int64_t>(5'000, [](auto row) { return kMin - row; }),
+  });
+
+  createDuckDbTable({data, newData});
+
+  core::PlanNodeId aggNodeId;
+  auto plan = PlanBuilder()
+                  .values({data, newData, data})
+                  .partialAggregation({"c0", "c1"}, {})
+                  .capturePlanNodeId(aggNodeId)
+                  .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(QueryConfig::kMaxPartialAggregationMemory, 400000)
+      .assertResults("SELECT distinct c0, c1 FROM tmp");
+}
+
+// Trigger memory pool allocation at HashAggregation::populateAggregateInputs by
+// aggregating null constant. Ensure the allocation happens outside of
+// HashAggregation's constructor.
+TEST_F(AggregationTest, memoryPoolAllocationAtInit) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+  });
+  createDuckDbTable({data});
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .aggregation(
+                      {"c0"},
+                      {"sum(cast(NULL as INT))"},
+                      {},
+                      core::AggregationNode::Step::kPartial,
+                      false)
+                  .planNode();
+
+  assertQuery(plan, "SELECT c0, cast(NULL as INT) FROM tmp GROUP BY c0");
+}
+
+DEBUG_ONLY_TEST_F(AggregationTest, reclaimEmptyInput) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const int32_t numBatches = 5;
+  auto batches = makeVectors(rowType, numBatches, 100);
+
+  std::atomic_bool injectReclaimOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        if (!injectReclaimOnce.exchange(false)) {
+          return;
+        }
+        auto* driver = values->testingOperatorCtx()->driver();
+        auto task = values->testingOperatorCtx()->task();
+        // Shrink all the capacity before reclaim.
+        memory::memoryManager()->arbitrator()->shrinkCapacity(task->pool(), 0);
+        {
+          MemoryReclaimer::Stats stats;
+          SuspendedSection suspendedSection(driver);
+          task->pool()->reclaim(kMaxBytes, 0, stats);
+          ASSERT_EQ(stats.numNonReclaimableAttempts, 0);
+          ASSERT_GE(stats.reclaimExecTimeUs, 0);
+          ASSERT_EQ(stats.reclaimedBytes, 0);
+          ASSERT_GT(stats.reclaimWaitTimeUs, 0);
+        }
+      }));
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  core::PlanNodeId aggNodeId;
+  auto task =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(batches)
+              // Set fake filter to ensure empty input to aggregation operator.
+              .filter("c0 != c0")
+              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+              .capturePlanNodeId(aggNodeId)
+              .planNode(),
+          duckDbQueryRunner_)
+          .spillDirectory(tempDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(QueryConfig::kSpillEnabled, true)
+          .config(QueryConfig::kAggregationSpillEnabled, true)
+          .assertEmptyResults();
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  ASSERT_EQ(taskStats.at(aggNodeId).spilledBytes, 0);
+  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+}
+
+DEBUG_ONLY_TEST_F(AggregationTest, reclaimEmptyOutput) {
+  constexpr int64_t kMaxBytes = 4LL << 30; // 4GB
+  auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  auto batches = makeVectors(rowType, 100, 5);
+
+  auto expectedResult =
+      AssertQueryBuilder(PlanBuilder()
+                             .values(batches)
+                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                             .planNode())
+          .copyResults(pool_.get());
+
+  std::atomic_int numGetOutput{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "Aggregation") {
+          return;
+        }
+        // Inject reclaim after the aggregation operator has received all the
+        // inputs.
+        if (!op->testingNoMoreInput()) {
+          return;
+        }
+        // Inject reclaim after the aggregation operator has produced all the
+        // output and before it has finished.
+        if (++numGetOutput != 2) {
+          return;
+        }
+        auto* driver = op->testingOperatorCtx()->driver();
+        auto task = op->testingOperatorCtx()->task();
+        // Shrink all the capacity before reclaim.
+        memory::memoryManager()->arbitrator()->shrinkCapacity(task->pool(), 0);
+        {
+          MemoryReclaimer::Stats stats;
+          SuspendedSection suspendedSection(driver);
+          memory::ScopedMemoryArbitrationContext ctx(op->pool());
+          task->pool()->reclaim(kMaxBytes, 0, stats);
+          ASSERT_EQ(stats.numNonReclaimableAttempts, 0);
+          ASSERT_GT(stats.reclaimExecTimeUs, 0);
+          ASSERT_EQ(stats.reclaimedBytes, 0);
+          ASSERT_GT(stats.reclaimWaitTimeUs, 0);
+        }
+      })));
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  core::PlanNodeId aggNodeId;
+  auto task =
+      AssertQueryBuilder(PlanBuilder()
+                             .values(batches)
+                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                             .capturePlanNodeId(aggNodeId)
+                             .planNode())
+          .spillDirectory(tempDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(QueryConfig::kSpillEnabled, true)
+          .config(QueryConfig::kAggregationSpillEnabled, true)
+          // Set the output query configs to ensure fetch the result in one
+          // output batch.
+          .config(QueryConfig::kPreferredOutputBatchBytes, 1UL << 30)
+          .config(QueryConfig::kMaxOutputBatchRows, 1024)
+          .assertResults(expectedResult);
+  // Since the spilling is triggered after the aggregation operator has produced
+  // all the output, we don't expect any spilled data.
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  ASSERT_EQ(taskStats.at(aggNodeId).spilledBytes, 0);
+  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+}
+
+TEST_F(AggregationTest, maxSpillBytes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto vectors = createVectors(rowType, 128, 1 << 20);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aggregationNodeId;
+  const auto plan = PlanBuilder(planNodeIdGenerator)
+                        .values(vectors)
+                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                        .capturePlanNodeId(aggregationNodeId)
+                        .planNode();
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {1, true}, {0, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kAggregationSpillEnabled, true)
+          .config(QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find("Query exceeded per-query local spill limit of 1B"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregation) {
+  const int numInputs = 8;
+  std::vector<RowVectorPtr> vectors =
+      createVectors(numInputs, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  for (const auto maxSpillRunRows : std::vector<uint32_t>({32, 1UL << 30})) {
+    SCOPED_TRACE(fmt::format("maxSpillRunRows {}", maxSpillRunRows));
+
+    std::atomic_int inputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(exec::Operator*)>(([&](exec::Operator* op) {
+          if (op->testingOperatorCtx()->operatorType() != "Aggregation") {
+            return;
+          }
+          // Inject spill in the middle of aggregation input processing.
+          if (++inputCount != numInputs / 2) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        })));
+
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    core::PlanNodeId aggrNodeId;
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kAggregationSpillEnabled, true)
+            .config(
+                core::QueryConfig::kMaxSpillRunRows,
+                std::to_string(maxSpillRunRows))
+            .plan(PlanBuilder()
+                      .values(vectors)
+                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                      .capturePlanNodeId(aggrNodeId)
+                      .planNode())
+            .assertResults(
+                "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(aggrNodeId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_GT(planStats.customStats["memoryArbitrationWallNanos"].sum, 0);
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromDistinctAggregation) {
+  const int numInputs = 32;
+  std::vector<RowVectorPtr> vectors =
+      createVectors(numInputs, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  for (const auto maxSpillRunRows : std::vector<uint32_t>({32, 1UL << 30})) {
+    SCOPED_TRACE(fmt::format("maxSpillRunRows {}", maxSpillRunRows));
+
+    std::atomic_int inputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(exec::Operator*)>(([&](exec::Operator* op) {
+          if (op->testingOperatorCtx()->operatorType() != "Aggregation") {
+            return;
+          }
+          // Inject spill at the end of aggregation input processing.
+          if (++inputCount != numInputs / 2) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        })));
+
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    core::PlanNodeId aggrNodeId;
+    auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                    .spillDirectory(spillDirectory->getPath())
+                    .config(core::QueryConfig::kSpillEnabled, true)
+                    .config(core::QueryConfig::kAggregationSpillEnabled, true)
+                    .config(
+                        core::QueryConfig::kMaxSpillRunRows,
+                        std::to_string(maxSpillRunRows))
+                    .plan(PlanBuilder()
+                              .values(vectors)
+                              .singleAggregation({"c0"}, {})
+                              .capturePlanNodeId(aggrNodeId)
+                              .planNode())
+                    .assertResults("SELECT distinct c0 FROM tmp");
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(aggrNodeId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationOnNoMoreInput) {
+  std::vector<RowVectorPtr> vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  std::vector<bool> sameQueries = {false, true};
+  for (bool sameQuery : sameQueries) {
+    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    std::shared_ptr<core::QueryCtx> fakeQueryCtx =
+        core::QueryCtx::create(executor_.get());
+    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
+    if (sameQuery) {
+      aggregationQueryCtx = fakeQueryCtx;
+    } else {
+      aggregationQueryCtx = core::QueryCtx::create(executor_.get());
+    }
+
+    folly::EventCount arbitrationWait;
+    std::atomic_bool arbitrationWaitFlag{true};
+    folly::EventCount taskPauseWait;
+    std::atomic_bool taskPauseWaitFlag{true};
+    std::atomic<memory::MemoryPool*> injectedPool{nullptr};
+
+    std::atomic<bool> injectNoMoreInputOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::noMoreInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "Aggregation") {
+            return;
+          }
+
+          if (!injectNoMoreInputOnce.exchange(false)) {
+            return;
+          }
+
+          injectedPool = op->pool();
+          arbitrationWaitFlag = false;
+          arbitrationWait.notifyAll();
+
+          // Wait for task pause to be triggered.
+          taskPauseWait.await([&] { return !taskPauseWaitFlag.load(); });
+        })));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Task::requestPauseLocked",
+        std::function<void(Task*)>(([&](Task* /*unused*/) {
+          taskPauseWaitFlag = false;
+          taskPauseWait.notifyAll();
+        })));
+
+    std::thread aggregationThread([&]() {
+      auto task =
+          AssertQueryBuilder(duckDbQueryRunner_)
+              .spillDirectory(spillDirectory->getPath())
+              .config(core::QueryConfig::kSpillEnabled, true)
+              .config(core::QueryConfig::kAggregationSpillEnabled, true)
+              .queryCtx(aggregationQueryCtx)
+              .maxDrivers(1)
+              .plan(PlanBuilder()
+                        .values(vectors)
+                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                        .planNode())
+              .assertResults(
+                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
+      auto stats = task->taskStats().pipelineStats;
+      ASSERT_GT(stats[0].operatorStats[1].spilledBytes, 0);
+    });
+
+    arbitrationWait.await([&] { return !arbitrationWaitFlag.load(); });
+    ASSERT_TRUE(injectedPool != nullptr);
+
+    auto fakePool = fakeQueryCtx->pool()->addLeafChild(
+        "fakePool", true, exec::MemoryReclaimer::create());
+    fakePool->maybeReserve(memory::memoryManager()->arbitrator()->capacity());
+
+    aggregationThread.join();
+
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationDuringOutput) {
+  const int numVectors = 32;
+  std::vector<RowVectorPtr> vectors;
+  VectorFuzzer fuzzer(fuzzerOpts_, pool());
+  int numRows{0};
+  for (int i = 0; i < numVectors; ++i) {
+    vectors.push_back(fuzzer.fuzzRow(rowType_));
+    numRows += vectors.back()->size();
+  }
+
+  createDuckDbTable(vectors);
+  std::vector<bool> sameQueries = {false, true};
+  for (bool sameQuery : sameQueries) {
+    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    std::shared_ptr<core::QueryCtx> fakeQueryCtx =
+        core::QueryCtx::create(executor_.get());
+    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
+    if (sameQuery) {
+      aggregationQueryCtx = fakeQueryCtx;
+    } else {
+      aggregationQueryCtx = core::QueryCtx::create(executor_.get());
+    }
+
+    folly::EventCount arbitrationWait;
+    std::atomic_bool arbitrationWaitFlag{true};
+    folly::EventCount taskPauseWait;
+    std::atomic_bool taskPauseWaitFlag{true};
+
+    std::atomic_int numInputs{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "Aggregation") {
+            return;
+          }
+          if (++numInputs != 5) {
+            return;
+          }
+          arbitrationWaitFlag = false;
+          arbitrationWait.notifyAll();
+
+          // Wait for task pause to be triggered.
+          taskPauseWait.await([&] { return !taskPauseWaitFlag.load(); });
+        })));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Task::requestPauseLocked",
+        std::function<void(Task*)>(([&](Task* /*unused*/) {
+          taskPauseWaitFlag = false;
+          taskPauseWait.notifyAll();
+        })));
+
+    std::thread aggregationThread([&]() {
+      auto task =
+          AssertQueryBuilder(duckDbQueryRunner_)
+              .spillDirectory(spillDirectory->getPath())
+              .config(core::QueryConfig::kSpillEnabled, true)
+              .config(core::QueryConfig::kAggregationSpillEnabled, true)
+              .config(
+                  core::QueryConfig::kPreferredOutputBatchRows, numRows / 10)
+              .maxDrivers(1)
+              .queryCtx(aggregationQueryCtx)
+              .plan(PlanBuilder()
+                        .values(vectors)
+                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                        .planNode())
+              .assertResults(
+                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
+      auto stats = task->taskStats().pipelineStats;
+      ASSERT_GT(stats[0].operatorStats[1].spilledBytes, 0);
+    });
+
+    arbitrationWait.await([&] { return !arbitrationWaitFlag.load(); });
+
+    auto fakePool = fakeQueryCtx->pool()->addLeafChild(
+        "fakePool", true, exec::MemoryReclaimer::create());
+    fakePool->maybeReserve(memory::memoryManager()->arbitrator()->capacity());
+
+    aggregationThread.join();
+
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+TEST_F(AggregationTest, reclaimFromCompletedAggregation) {
+  std::vector<RowVectorPtr> vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  std::vector<bool> sameQueries = {false, true};
+  for (bool sameQuery : sameQueries) {
+    SCOPED_TRACE(fmt::format("sameQuery {}", sameQuery));
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    std::shared_ptr<core::QueryCtx> fakeQueryCtx =
+        core::QueryCtx::create(executor_.get());
+    std::shared_ptr<core::QueryCtx> aggregationQueryCtx;
+    if (sameQuery) {
+      aggregationQueryCtx = fakeQueryCtx;
+    } else {
+      aggregationQueryCtx = core::QueryCtx::create(executor_.get());
+    }
+
+    folly::EventCount arbitrationWait;
+    std::atomic_bool arbitrationWaitFlag{true};
+
+    std::thread aggregationThread([&]() {
+      auto task =
+          AssertQueryBuilder(duckDbQueryRunner_)
+              .queryCtx(aggregationQueryCtx)
+              .plan(PlanBuilder()
+                        .values(vectors)
+                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                        .planNode())
+              .assertResults(
+                  "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
+      waitForTaskCompletion(task.get());
+      arbitrationWaitFlag = false;
+      arbitrationWait.notifyAll();
+    });
+
+    arbitrationWait.await([&] { return !arbitrationWaitFlag.load(); });
+
+    auto fakePool = fakeQueryCtx->pool()->addLeafChild(
+        "fakePool", true, exec::MemoryReclaimer::create());
+    fakePool->maybeReserve(memory::memoryManager()->arbitrator()->capacity());
+
+    aggregationThread.join();
+
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+TEST_F(AggregationTest, ignoreNullKeys) {
+  // Some keys are null.
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, 1, std::nullopt, 2, std::nullopt, 1, 2}),
+      makeFlatVector<int32_t>({-1, 1, -2, 2, -3, 3, 4}),
+  });
+
+  auto makePlan = [&](bool ignoreNullKeys) {
+    return PlanBuilder()
+        .values({data})
+        .aggregation(
+            {"c0"},
+            {"sum(c1)"},
+            {},
+            core::AggregationNode::Step::kPartial,
+            ignoreNullKeys)
+        .planNode();
+  };
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<int64_t>({4, 6}),
+  });
+  AssertQueryBuilder(makePlan(true)).assertResults(expected);
+
+  expected = makeRowVector({
+      makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
+      makeFlatVector<int64_t>({-6, 4, 6}),
+  });
+  AssertQueryBuilder(makePlan(false)).assertResults(expected);
+
+  // All keys are null.
+  data = makeRowVector({
+      makeAllNullFlatVector<int32_t>(3),
+      makeFlatVector<int32_t>({1, 2, 3}),
+  });
+
+  AssertQueryBuilder(makePlan(true)).assertEmptyResults();
+}
+
+// Verify that ORDER BY clause is ignored for aggregates that are not order
+// sensitive.
+TEST_F(AggregationTest, ignoreOrderBy) {
+  auto data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2, 1, 2, 1}),
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7}),
+      makeFlatVector<int64_t>({10, 20, 30, 40, 50, 60, 70}),
+      makeFlatVector<int32_t>({11, 44, 22, 55, 33, 66, 77}),
+  });
+
+  createDuckDbTable({data});
+
+  // Sorted aggregations over same inputs.
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .partialAggregation(
+              {"c0"}, {"sum(c1 ORDER BY c2 DESC)", "avg(c1 ORDER BY c3)"})
+          .finalAggregation()
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults("SELECT c0, sum(c1), avg(c1) FROM tmp GROUP BY 1");
+}
+
+class TestAccumulator {
+ public:
+  ~TestAccumulator() {
+    VELOX_FAIL("Destructor should not be called.");
+  }
+};
+
+class TestAggregate : public Aggregate {
+ public:
+  explicit TestAggregate(TypePtr resultType) : Aggregate(resultType) {}
+
+  void addRawInput(
+      char** /*groups*/,
+      const SelectivityVector& /*rows*/,
+      const std::vector<VectorPtr>& /*args*/,
+      bool /*mayPushdown*/) override {
+    VELOX_UNSUPPORTED("This shouldn't get called.");
+  }
+
+  void extractValues(
+      char** /*groups*/,
+      int32_t /*numGroups*/,
+      VectorPtr* /*result*/) override {
+    VELOX_UNSUPPORTED("This shouldn't get called.");
+  }
+
+  void addIntermediateResults(
+      char** /*groups*/,
+      const SelectivityVector& /*rows*/,
+      const std::vector<VectorPtr>& /*args*/,
+      bool /*mayPushdown*/) override {
+    VELOX_UNSUPPORTED("This shouldn't get called.");
+  }
+
+  void addSingleGroupRawInput(
+      char* /*group*/,
+      const SelectivityVector& /*rows*/,
+      const std::vector<VectorPtr>& /*args*/,
+      bool /*mayPushdown*/) override {
+    VELOX_UNSUPPORTED("This shouldn't get called.");
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* /*group*/,
+      const SelectivityVector& /*rows*/,
+      const std::vector<VectorPtr>& /*args*/,
+      bool /*mayPushdown*/) override {
+    VELOX_UNSUPPORTED("This shouldn't get called.");
+  }
+
+  void extractAccumulators(
+      char** /*groups*/,
+      int32_t /*numGroups*/,
+      VectorPtr* /*result*/) override {
+    VELOX_UNSUPPORTED("This shouldn't get called.");
+  }
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(TestAccumulator);
+  }
+
+  bool destroyCalled = false;
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** /*groups*/,
+      folly::Range<const vector_size_t*> /*indices*/) override {
+    VELOX_UNSUPPORTED("This shouldn't get called.");
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyCalled = true;
+    destroyAccumulators<TestAccumulator>(groups);
+  }
+};
+
+TEST_F(AggregationTest, destroyAfterPartialInitialization) {
+  TestAggregate agg(INTEGER());
+
+  Accumulator accumulator(
+      true, // isFixedSize
+      sizeof(TestAccumulator), // fixedSize
+      true, // usesExternalMemory, this is set to force RowContainer.clear() to
+            // call eraseRows.
+      1, // alignment
+      INTEGER(), // spillType,
+      [](folly::Range<char**>, VectorPtr&) {
+        VELOX_UNSUPPORTED("This shouldn't get called.");
+      },
+      [&agg](folly::Range<char**> groups) { agg.destroy(groups); });
+
+  RowContainer rows(
+      {}, // keyTypes
+      false, // nullableKeys
+      {accumulator},
+      {}, // dependentTypes
+      false, // hasNext
+      false, // isJoinBuild
+      false, // hasProbedFlag
+      false, // hasNormalizedKeys
+      pool());
+  const auto rowColumn = rows.columnAt(0);
+  agg.setOffsets(
+      rowColumn.offset(),
+      rowColumn.nullByte(),
+      rowColumn.nullMask(),
+      rowColumn.initializedByte(),
+      rowColumn.initializedMask(),
+      rows.rowSizeOffset());
+  rows.newRow();
+  rows.clear();
+
+  ASSERT_TRUE(agg.destroyCalled);
+}
+
+TEST_F(AggregationTest, nanKeys) {
+  // Some keys are NaNs.
+  auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+  // Columns reused across test cases.
+  auto c0 = makeFlatVector<double>({kNaN, 1, kNaN, 2, kSNaN, 1, 2});
+  auto c1 = makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 1});
+  // Expected result columns reused across test cases. A deduplicated version of
+  // c0 and c1.
+  auto e0 = makeFlatVector<double>({1, 2, kNaN});
+  auto e1 = makeFlatVector<int32_t>({1, 1, 1});
+
+  auto testDistinctAgg = [&](std::vector<std::string> aggKeys,
+                             std::vector<VectorPtr> inputCols,
+                             std::vector<VectorPtr> expectedCols) {
+    auto plan = PlanBuilder()
+                    .values({makeRowVector(inputCols)})
+                    .singleAggregation(aggKeys, {}, {})
+                    .planNode();
+    AssertQueryBuilder(plan).assertResults(makeRowVector(expectedCols));
+  };
+
+  // Test with a primitive type key.
+  testDistinctAgg({"c0"}, {c0}, {e0});
+  // Multiple key columns.
+  testDistinctAgg({"c0", "c1"}, {c0, c1}, {e0, e1});
+
+  // Test with a complex type key.
+  testDistinctAgg({"c0"}, {makeRowVector({c0, c1})}, {makeRowVector({e0, e1})});
+  // Multiple key columns.
+  testDistinctAgg(
+      {"c0", "c1"},
+      {makeRowVector({c0, c1}), c1},
+      {makeRowVector({e0, e1}), e1});
+}
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/ArrowStreamTest.cpp b/velox/exec/tests/ArrowStreamTest.cpp
index f0fe9b37e04e0..b8bda1b534fe8 100644
--- a/velox/exec/tests/ArrowStreamTest.cpp
+++ b/velox/exec/tests/ArrowStreamTest.cpp
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
+#include "velox/vector/arrow/Bridge.h"
+
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec::test;
@@ -45,7 +46,7 @@ class ArrowStreamTest : public OperatorTestBase {
 
     int getNext(struct ArrowArray* outArray) {
       if (vectorIndex_ < vectors_.size()) {
-        exportToArrow(vectors_[vectorIndex_], *outArray, pool_.get());
+        exportToArrow(vectors_[vectorIndex_], *outArray, pool_.get(), options_);
         vectorIndex_ += 1;
       } else {
         // End of stream. Mark the array released.
@@ -56,12 +57,13 @@ class ArrowStreamTest : public OperatorTestBase {
     }
 
     int getArrowSchema(ArrowSchema& out) {
-      exportToArrow(BaseVector::create(type_, 0, pool_.get()), out);
+      exportToArrow(BaseVector::create(type_, 0, pool_.get()), out, options_);
       return failGetSchema_ ? (int)ErrorCode::kGetSchemaFailed
                             : (int)ErrorCode::kNoError;
     }
 
    private:
+    ArrowOptions options_;
     const std::shared_ptr<memory::MemoryPool> pool_;
     const std::vector<RowVectorPtr>& vectors_;
     const TypePtr type_;
@@ -184,7 +186,11 @@ TEST_F(ArrowStreamTest, basic) {
                return StringView::makeInline(
                    std::to_string(100000000000 + (uint64_t)(row % 100)));
              },
-             nullEvery(7))}));
+             nullEvery(7)),
+         makeFlatVector<Timestamp>(
+             size,
+             [&](vector_size_t row) { return Timestamp(row, row * 1000); },
+             nullEvery(5))}));
   }
   createDuckDbTable(vectors);
   auto type = asRowType(vectors[0]->type());
diff --git a/velox/exec/tests/AssertQueryBuilderTest.cpp b/velox/exec/tests/AssertQueryBuilderTest.cpp
index 8c0b7ceacc814..573d7349e509f 100644
--- a/velox/exec/tests/AssertQueryBuilderTest.cpp
+++ b/velox/exec/tests/AssertQueryBuilderTest.cpp
@@ -34,6 +34,19 @@ TEST_F(AssertQueryBuilderTest, basic) {
       .assertResults(data);
 }
 
+TEST_F(AssertQueryBuilderTest, serialExecution) {
+  auto data = makeRowVector({makeFlatVector<int32_t>({1, 2, 3})});
+
+  PlanBuilder builder;
+  const auto& plan = builder.values({data}).planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .serialExecution(true)
+      .assertResults("VALUES (1), (2), (3)");
+
+  AssertQueryBuilder(plan).serialExecution(true).assertResults(data);
+}
+
 TEST_F(AssertQueryBuilderTest, orderedResults) {
   auto data = makeRowVector({makeFlatVector<int32_t>({1, 2, 3})});
 
@@ -70,13 +83,13 @@ TEST_F(AssertQueryBuilderTest, hiveSplits) {
   auto data = makeRowVector({makeFlatVector<int32_t>({1, 2, 3})});
 
   auto file = TempFilePath::create();
-  writeToFile(file->path, {data});
+  writeToFile(file->getPath(), {data});
 
   // Single leaf node.
   AssertQueryBuilder(
       PlanBuilder().tableScan(asRowType(data->type())).planNode(),
       duckDbQueryRunner_)
-      .split(makeHiveConnectorSplit(file->path))
+      .split(makeHiveConnectorSplit(file->getPath()))
       .assertResults("VALUES (1), (2), (3)");
 
   // Split with partition key.
@@ -86,13 +99,14 @@ TEST_F(AssertQueryBuilderTest, hiveSplits) {
 
   AssertQueryBuilder(
       PlanBuilder()
-          .tableScan(
-              ROW({"c0", "ds"}, {INTEGER(), VARCHAR()}),
-              makeTableHandle(),
-              assignments)
+          .startTableScan()
+          .outputType(ROW({"c0", "ds"}, {INTEGER(), VARCHAR()}))
+          .tableHandle(makeTableHandle())
+          .assignments(assignments)
+          .endTableScan()
           .planNode(),
       duckDbQueryRunner_)
-      .split(HiveConnectorSplitBuilder(file->path)
+      .split(HiveConnectorSplitBuilder(file->getPath())
                  .partitionKey("ds", "2022-05-10")
                  .build())
       .assertResults(
@@ -101,7 +115,7 @@ TEST_F(AssertQueryBuilderTest, hiveSplits) {
   // Two leaf nodes.
   auto buildData = makeRowVector({makeFlatVector<int32_t>({2, 3})});
   auto buildFile = TempFilePath::create();
-  writeToFile(buildFile->path, {buildData});
+  writeToFile(buildFile->getPath(), {buildData});
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId probeScanId;
@@ -123,8 +137,8 @@ TEST_F(AssertQueryBuilderTest, hiveSplits) {
                       .planNode();
 
   AssertQueryBuilder(joinPlan, duckDbQueryRunner_)
-      .split(probeScanId, makeHiveConnectorSplit(file->path))
-      .split(buildScanId, makeHiveConnectorSplit(buildFile->path))
+      .split(probeScanId, makeHiveConnectorSplit(file->getPath()))
+      .split(buildScanId, makeHiveConnectorSplit(buildFile->getPath()))
       .assertResults("SELECT 2");
 }
 
diff --git a/velox/exec/tests/AssignUniqueIdTest.cpp b/velox/exec/tests/AssignUniqueIdTest.cpp
index c41b92b091ec4..a4f1f41eb13ca 100644
--- a/velox/exec/tests/AssignUniqueIdTest.cpp
+++ b/velox/exec/tests/AssignUniqueIdTest.cpp
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
@@ -26,22 +28,20 @@ class AssignUniqueIdTest : public OperatorTestBase {
  protected:
   void verifyUniqueId(
       const std::shared_ptr<const core::PlanNode>& plan,
-      const std::vector<RowVectorPtr>& inputRows,
-      const int numThreads = 1) {
+      const std::vector<RowVectorPtr>& input) {
     CursorParameters params;
     params.planNode = plan;
-    params.maxDrivers = numThreads;
 
     auto result = readCursor(params, [](auto /*task*/) {});
     auto numColumns = result.second[0]->childrenSize();
-    ASSERT_EQ(numColumns, inputRows[0]->childrenSize() + 1);
+    ASSERT_EQ(numColumns, input[0]->childrenSize() + 1);
 
     std::set<int64_t> ids;
     for (int i = 0; i < numColumns; i++) {
-      for (auto output : result.second) {
-        auto column = output->childAt(i);
+      for (auto batch = 0; batch < result.second.size(); ++batch) {
+        auto column = result.second[batch]->childAt(i);
         if (i < numColumns - 1) {
-          assertEqualVectors(inputRows[0]->childAt(i), column);
+          assertEqualVectors(input[batch]->childAt(i), column);
         } else {
           auto idValues = column->asFlatVector<int64_t>()->rawValues();
           std::copy(
@@ -51,12 +51,13 @@ class AssignUniqueIdTest : public OperatorTestBase {
         }
       }
     }
-    vector_size_t totalInputSize = std::accumulate(
-        inputRows.begin(),
-        inputRows.end(),
-        0,
-        [](vector_size_t sum, RowVectorPtr row) { return sum + row->size(); });
-    ASSERT_EQ(totalInputSize * numThreads, ids.size());
+
+    vector_size_t totalInputSize = 0;
+    for (const auto& vector : input) {
+      totalInputSize += vector->size();
+    }
+
+    ASSERT_EQ(totalInputSize, ids.size());
 
     auto task = result.first->task();
 
@@ -65,7 +66,7 @@ class AssignUniqueIdTest : public OperatorTestBase {
     // ID vector. Memory should be allocated when producing first batch of
     // output and re-used for subsequent batches.
     auto stats = toPlanStats(task->taskStats());
-    ASSERT_EQ(numThreads, stats.at(uniqueNodeId_).numMemoryAllocations);
+    ASSERT_EQ(1, stats.at(uniqueNodeId_).numMemoryAllocations);
   }
 
   core::PlanNodeId uniqueNodeId_;
@@ -75,9 +76,8 @@ TEST_F(AssignUniqueIdTest, multiBatch) {
   vector_size_t batchSize = 1000;
   std::vector<RowVectorPtr> input;
   for (int i = 0; i < 3; ++i) {
-    auto column =
-        makeFlatVector<int32_t>(batchSize, [](auto row) { return row; });
-    input.push_back(makeRowVector({column}));
+    input.push_back(
+        makeRowVector({makeFlatVector<int32_t>(batchSize, folly::identity)}));
   }
 
   auto plan = PlanBuilder()
@@ -91,8 +91,12 @@ TEST_F(AssignUniqueIdTest, multiBatch) {
 
 TEST_F(AssignUniqueIdTest, exceedRequestLimit) {
   vector_size_t requestLimit = 1 << 20L;
-  auto input = {makeRowVector({makeFlatVector<int32_t>(
-      requestLimit + 1, [](auto row) { return row; })})};
+  auto input = {
+      makeRowVector(
+          {makeFlatVector<int32_t>(requestLimit - 10, folly::identity)}),
+      makeRowVector({makeFlatVector<int32_t>(100, folly::identity)}),
+      makeRowVector({makeFlatVector<int32_t>(100, folly::identity)}),
+  };
 
   auto plan = PlanBuilder()
                   .values(input)
@@ -106,42 +110,58 @@ TEST_F(AssignUniqueIdTest, exceedRequestLimit) {
 TEST_F(AssignUniqueIdTest, multiThread) {
   for (int i = 0; i < 3; i++) {
     vector_size_t batchSize = 1000;
-    auto input = {makeRowVector(
-        {makeFlatVector<int32_t>(batchSize, [](auto row) { return row; })})};
+    auto input = {
+        makeRowVector({makeFlatVector<int32_t>(batchSize, folly::identity)})};
     auto plan = PlanBuilder()
                     .values(input, true)
                     .assignUniqueId()
                     .capturePlanNodeId(uniqueNodeId_)
                     .planNode();
 
-    verifyUniqueId(plan, input, 8);
+    std::shared_ptr<exec::Task> task;
+    auto result =
+        AssertQueryBuilder(plan).maxDrivers(8).copyResults(pool(), task);
+    ASSERT_EQ(batchSize * 8, result->size());
+
+    std::set<int64_t> ids;
+    auto idValues =
+        result->children().back()->asFlatVector<int64_t>()->rawValues();
+    std::copy(
+        idValues, idValues + result->size(), std::inserter(ids, ids.end()));
+
+    ASSERT_EQ(batchSize * 8, ids.size());
+
+    // Verify number of memory allocations. There should be exactly one
+    // allocation (per thread of execution) for the values buffer of the unique
+    // ID vector. Memory should be allocated when producing first batch of
+    // output and re-used for subsequent batches.
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(8, stats.at(uniqueNodeId_).numMemoryAllocations);
   }
 }
 
 TEST_F(AssignUniqueIdTest, maxRowIdLimit) {
   auto input = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
 
-  auto plan = PlanBuilder()
-                  .values(input)
-                  .assignUniqueId()
-                  .capturePlanNodeId(uniqueNodeId_)
-                  .planNode();
+  auto plan = PlanBuilder().values(input).assignUniqueId().planNode();
+
   // Increase the counter to kMaxRowId.
   std::dynamic_pointer_cast<const core::AssignUniqueIdNode>(plan)
       ->uniqueIdCounter()
       ->fetch_add(1L << 40);
 
-  EXPECT_THROW(verifyUniqueId(plan, input), VeloxRuntimeError);
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Ran out of unique IDs at 1099511627776");
 }
 
 TEST_F(AssignUniqueIdTest, taskUniqueIdLimit) {
   auto input = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
 
-  auto plan = PlanBuilder()
-                  .values(input)
-                  .assignUniqueId("unique", 1L << 24)
-                  .capturePlanNodeId(uniqueNodeId_)
-                  .planNode();
+  auto plan =
+      PlanBuilder().values(input).assignUniqueId("unique", 1L << 24).planNode();
 
-  EXPECT_THROW(verifyUniqueId(plan, input), VeloxRuntimeError);
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "(16777216 vs. 16777216) Unique 24-bit ID specified for AssignUniqueId exceeds the limit");
 }
diff --git a/velox/exec/tests/AsyncConnectorTest.cpp b/velox/exec/tests/AsyncConnectorTest.cpp
index 30e4f8fb0dd50..b4c532bdfa6f6 100644
--- a/velox/exec/tests/AsyncConnectorTest.cpp
+++ b/velox/exec/tests/AsyncConnectorTest.cpp
@@ -133,8 +133,7 @@ class TestDataSource : public connector::DataSource {
 
 class TestConnector : public connector::Connector {
  public:
-  TestConnector(const std::string& id, std::shared_ptr<const Config> properties)
-      : connector::Connector(id, std::move(properties)) {}
+  TestConnector(const std::string& id) : connector::Connector(id) {}
 
   std::unique_ptr<connector::DataSource> createDataSource(
       const RowTypePtr& /* outputType */,
@@ -164,9 +163,9 @@ class TestConnectorFactory : public connector::ConnectorFactory {
 
   std::shared_ptr<connector::Connector> newConnector(
       const std::string& id,
-      std::shared_ptr<const Config> properties,
+      std::shared_ptr<const config::ConfigBase> config,
       folly::Executor* /* executor */) override {
-    return std::make_shared<TestConnector>(id, std::move(properties));
+    return std::make_shared<TestConnector>(id);
   }
 };
 } // namespace
@@ -179,7 +178,11 @@ class AsyncConnectorTest : public OperatorTestBase {
         std::make_shared<TestConnectorFactory>());
     auto testConnector =
         connector::getConnectorFactory(TestConnectorFactory::kTestConnectorName)
-            ->newConnector(kTestConnectorId, nullptr, nullptr);
+            ->newConnector(
+                kTestConnectorId,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()),
+                nullptr);
     connector::registerConnector(testConnector);
   }
 
@@ -193,7 +196,10 @@ TEST_F(AsyncConnectorTest, basic) {
   auto tableHandle = std::make_shared<TestTableHandle>();
   core::PlanNodeId scanId;
   auto plan = PlanBuilder()
-                  .tableScan(ROW({"a"}, {BIGINT()}), tableHandle, {})
+                  .startTableScan()
+                  .outputType(ROW({"a"}, {BIGINT()}))
+                  .tableHandle(tableHandle)
+                  .endTableScan()
                   .capturePlanNodeId(scanId)
                   .singleAggregation({}, {"min(a)"})
                   .planNode();
diff --git a/velox/exec/tests/CMakeLists.txt b/velox/exec/tests/CMakeLists.txt
index e9287a7a494f9..32a46e398432b 100644
--- a/velox/exec/tests/CMakeLists.txt
+++ b/velox/exec/tests/CMakeLists.txt
@@ -23,8 +23,12 @@ add_test(
   COMMAND aggregate_companion_functions_test
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 
-target_link_libraries(aggregate_companion_functions_test velox_exec
-                      velox_function_registry gtest gtest_main)
+target_link_libraries(
+  aggregate_companion_functions_test
+  velox_exec
+  velox_function_registry
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(
   velox_exec_test
@@ -38,48 +42,53 @@ add_executable(
   CustomJoinTest.cpp
   EnforceSingleRowTest.cpp
   ExchangeClientTest.cpp
+  ExpandTest.cpp
   FilterProjectTest.cpp
   FunctionResolutionTest.cpp
+  HashBitRangeTest.cpp
   HashJoinBridgeTest.cpp
   HashJoinTest.cpp
-  HashBitRangeTest.cpp
   HashPartitionFunctionTest.cpp
   HashTableTest.cpp
   LimitTest.cpp
   LocalPartitionTest.cpp
   Main.cpp
+  MarkDistinctTest.cpp
   MemoryReclaimerTest.cpp
   MergeJoinTest.cpp
   MergeTest.cpp
   MultiFragmentTest.cpp
   NestedLoopJoinTest.cpp
   OrderByTest.cpp
-  PartitionedOutputBufferManagerTest.cpp
+  OutputBufferManagerTest.cpp
+  PartitionedOutputTest.cpp
   PlanNodeSerdeTest.cpp
   PlanNodeToStringTest.cpp
+  PrefixSortTest.cpp
   PrintPlanWithStatsTest.cpp
   ProbeOperatorStateTest.cpp
   RoundRobinPartitionFunctionTest.cpp
   RowContainerTest.cpp
   RowNumberTest.cpp
-  MarkDistinctTest.cpp
-  SpillTest.cpp
-  SpillOperatorGroupTest.cpp
+  SortBufferTest.cpp
   SpillerTest.cpp
+  SpillTest.cpp
   SplitToStringTest.cpp
   SqlTest.cpp
   StreamingAggregationTest.cpp
   TableScanTest.cpp
   TableWriteTest.cpp
   TaskListenerTest.cpp
-  TopNTest.cpp
+  ThreadDebugInfoTest.cpp
   TopNRowNumberTest.cpp
-  UnorderedStreamReaderTest.cpp
+  TopNTest.cpp
   UnnestTest.cpp
-  VectorHasherTest.cpp
+  UnorderedStreamReaderTest.cpp
   ValuesTest.cpp
+  VectorHasherTest.cpp
   WindowFunctionRegistryTest.cpp
-  SortBufferTest.cpp)
+  WindowTest.cpp
+  WriterFuzzerUtilTest.cpp)
 
 add_executable(
   velox_exec_infra_test
@@ -89,8 +98,8 @@ add_executable(
   GroupedExecutionTest.cpp
   Main.cpp
   OperatorUtilsTest.cpp
-  ParseTypeSignatureTest.cpp
   PlanBuilderTest.cpp
+  PrestoQueryRunnerTest.cpp
   QueryAssertionsTest.cpp
   TaskTest.cpp
   TreeOfLosersTest.cpp)
@@ -117,6 +126,7 @@ target_link_libraries(
   velox_dwio_parquet_writer
   velox_exec
   velox_exec_test_lib
+  velox_file_test_utils
   velox_functions_json
   velox_functions_lib
   velox_functions_prestosql
@@ -128,6 +138,8 @@ target_link_libraries(
   velox_type
   velox_vector
   velox_vector_fuzzer
+  velox_writer_fuzzer
+  velox_window
   Boost::atomic
   Boost::context
   Boost::date_time
@@ -136,9 +148,9 @@ target_link_libraries(
   Boost::regex
   Boost::thread
   Boost::system
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   Folly::folly
   gflags::gflags
   glog::glog
@@ -152,9 +164,11 @@ target_link_libraries(
   velox_dwio_common_test_utils
   velox_exec
   velox_exec_test_lib
+  velox_fuzzer_util
   velox_functions_lib
   velox_functions_prestosql
   velox_functions_test_lib
+  velox_window
   velox_hive_connector
   velox_memory
   velox_serialization
@@ -162,6 +176,8 @@ target_link_libraries(
   velox_type
   velox_vector
   velox_vector_fuzzer
+  velox_presto_serializer
+  velox_dwio_dwrf_writer
   Boost::atomic
   Boost::context
   Boost::date_time
@@ -170,9 +186,9 @@ target_link_libraries(
   Boost::regex
   Boost::thread
   Boost::system
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   Folly::folly
   gflags::gflags
   glog::glog
@@ -192,71 +208,131 @@ target_link_libraries(
   velox_tpch_connector
   velox_memory)
 
-# Aggregation Fuzzer.
-add_executable(velox_aggregation_fuzzer_test AggregationFuzzerTest.cpp)
+# RowNumber Fuzzer.
+add_executable(velox_row_number_fuzzer_test RowNumberFuzzerTest.cpp)
 
 target_link_libraries(
-  velox_aggregation_fuzzer_test
-  velox_aggregation_fuzzer
-  velox_aggregates
-  velox_window
-  velox_vector_test_lib
-  gtest
-  gtest_main)
+  velox_row_number_fuzzer_test velox_row_number_fuzzer GTest::gtest
+  GTest::gtest_main)
 
-add_executable(spark_aggregation_fuzzer_test SparkAggregationFuzzerTest.cpp)
+# Join Fuzzer.
+add_executable(velox_join_fuzzer_test JoinFuzzerTest.cpp)
 
 target_link_libraries(
-  spark_aggregation_fuzzer_test
-  velox_aggregation_fuzzer
-  velox_functions_spark_aggregates
-  velox_window
-  velox_vector_test_lib
-  gtest
-  gtest_main)
+  velox_join_fuzzer_test velox_join_fuzzer GTest::gtest GTest::gtest_main)
 
-# Join Fuzzer.
+# Arbitration Fuzzer.
+add_executable(velox_memory_arbitration_fuzzer_test
+               MemoryArbitrationFuzzerTest.cpp)
 
-add_library(velox_join_fuzzer JoinFuzzer.cpp)
+target_link_libraries(
+  velox_memory_arbitration_fuzzer_test velox_memory_arbitration_fuzzer
+  GTest::gtest GTest::gtest_main)
 
-target_link_libraries(velox_join_fuzzer velox_type velox_vector_fuzzer
-                      velox_exec_test_lib velox_expression_test_utility)
+# Cache Fuzzer
+add_executable(velox_cache_fuzzer_test CacheFuzzerTest.cpp)
 
-add_executable(velox_join_fuzzer_test JoinFuzzerTest.cpp)
+target_link_libraries(
+  velox_cache_fuzzer_test
+  velox_cache_fuzzer
+  velox_fuzzer_util
+  GTest::gtest
+  GTest::gtest_main)
+
+add_executable(velox_exchange_fuzzer_test ExchangeFuzzer.cpp)
 
-target_link_libraries(velox_join_fuzzer_test velox_join_fuzzer gtest gtest_main)
+target_link_libraries(
+  velox_exchange_fuzzer_test
+  velox_exec_test_lib
+  velox_aggregates
+  velox_vector_test_lib
+  velox_vector_fuzzer
+  GTest::gtest
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(velox_aggregation_runner_test AggregationRunnerTest.cpp)
 
-target_link_libraries(velox_aggregation_runner_test velox_aggregation_fuzzer
-                      velox_aggregates velox_vector_test_lib gtest gtest_main)
+target_link_libraries(
+  velox_aggregation_runner_test
+  velox_aggregation_fuzzer
+  velox_fuzzer_util
+  velox_aggregates
+  velox_vector_test_lib
+  GTest::gtest
+  GTest::gtest_main)
 
 add_library(velox_simple_aggregate SimpleAverageAggregate.cpp
                                    SimpleArrayAggAggregate.cpp)
 
-target_link_libraries(velox_simple_aggregate velox_exec velox_expression
-                      velox_expression_functions velox_aggregates)
+target_link_libraries(
+  velox_simple_aggregate
+  velox_exec
+  velox_expression
+  velox_expression_functions
+  velox_aggregates)
 
-add_executable(velox_simple_aggregate_test SimpleAggregateAdapterTest.cpp)
+add_executable(velox_simple_aggregate_test SimpleAggregateAdapterTest.cpp
+                                           Main.cpp)
 
 target_link_libraries(
-  velox_simple_aggregate_test velox_simple_aggregate velox_exec
-  velox_functions_aggregates_test_lib gtest gtest_main)
-
-add_library(velox_spiller_benchmark_base SpillerBenchmarkBase.cpp)
+  velox_simple_aggregate_test
+  velox_simple_aggregate
+  velox_exec
+  velox_functions_aggregates_test_lib
+  GTest::gtest
+  GTest::gtest_main)
 
-target_link_libraries(velox_spiller_benchmark_base velox_exec
-                      velox_exec_test_lib velox_memory velox_vector_fuzzer)
+add_library(velox_spiller_join_benchmark_base JoinSpillInputBenchmarkBase.cpp
+                                              SpillerBenchmarkBase.cpp)
+target_link_libraries(
+  velox_spiller_join_benchmark_base
+  velox_exec
+  velox_exec_test_lib
+  velox_memory
+  velox_vector_fuzzer
+  glog::glog
+  gflags::gflags
+  Folly::folly
+  pthread)
 
-add_executable(velox_spiller_benchmark SpillerBenchmark.cpp)
+add_executable(velox_spiller_join_benchmark SpillerJoinInputBenchmarkTest.cpp)
+target_link_libraries(
+  velox_spiller_join_benchmark velox_exec velox_exec_test_lib
+  velox_spiller_join_benchmark_base)
 
+add_library(velox_spiller_aggregate_benchmark_base
+            AggregateSpillBenchmarkBase.cpp SpillerBenchmarkBase.cpp)
 target_link_libraries(
-  velox_spiller_benchmark
+  velox_spiller_aggregate_benchmark_base
   velox_exec
   velox_exec_test_lib
-  velox_spiller_benchmark_base
+  velox_memory
   velox_vector_fuzzer
   glog::glog
   gflags::gflags
   Folly::folly
   pthread)
+
+add_executable(velox_spiller_aggregate_benchmark
+               SpillerAggregateBenchmarkTest.cpp)
+target_link_libraries(
+  velox_spiller_aggregate_benchmark velox_exec velox_exec_test_lib
+  velox_spiller_aggregate_benchmark_base)
+
+add_executable(cpr_http_client_test CprHttpClientTest.cpp)
+add_test(
+  NAME cpr_http_client_test
+  COMMAND cpr_http_client_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(
+  cpr_http_client_test cpr::cpr GTest::gtest GTest::gtest_main)
+
+add_executable(velox_driver_test OperatorReplacement.cpp Main.cpp)
+add_test(
+  NAME velox_driver_test
+  COMMAND velox_driver_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(
+  velox_driver_test velox_exec velox_exec_test_lib GTest::gtest)
diff --git a/velox/exec/tests/CacheFuzzerTest.cpp b/velox/exec/tests/CacheFuzzerTest.cpp
new file mode 100644
index 0000000000000..c66b15eaf2a0a
--- /dev/null
+++ b/velox/exec/tests/CacheFuzzerTest.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+
+#include "velox/exec/fuzzer/CacheFuzzerRunner.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+
+  facebook::velox::memory::MemoryManager::initialize({});
+
+  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+
+  using Runner = facebook::velox::exec::test::CacheRunner;
+
+  return Runner::run(initialSeed);
+}
diff --git a/velox/exec/tests/ContainerRowSerdeTest.cpp b/velox/exec/tests/ContainerRowSerdeTest.cpp
index 1899bc5ff44c1..8663d75287b74 100644
--- a/velox/exec/tests/ContainerRowSerdeTest.cpp
+++ b/velox/exec/tests/ContainerRowSerdeTest.cpp
@@ -13,8 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/exec/ContainerRowSerde.h"
+
 #include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/HashStringAllocator.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -26,13 +30,20 @@ namespace {
 class ContainerRowSerdeTest : public testing::Test,
                               public velox::test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   // Writes all rows together and returns a position at the start of this
   // combined write.
-  HashStringAllocator::Position serialize(const VectorPtr& data) {
-    ByteStream out(&allocator_);
+  HashStringAllocator::Position serialize(
+      const VectorPtr& data,
+      bool isKey = true) {
+    ByteOutputStream out(&allocator_);
     auto position = allocator_.newWrite(out);
+    exec::ContainerRowSerdeOptions options{.isKey = isKey};
     for (auto i = 0; i < data->size(); ++i) {
-      ContainerRowSerde::serialize(*data, i, out);
+      ContainerRowSerde::serialize(*data, i, out, options);
     }
     allocator_.finishWrite(out, 0);
     return position;
@@ -40,15 +51,17 @@ class ContainerRowSerdeTest : public testing::Test,
 
   // Writes each row individually and returns positions for individual rows.
   std::vector<HashStringAllocator::Position> serializeWithPositions(
-      const VectorPtr& data) {
+      const VectorPtr& data,
+      bool isKey = true) {
     std::vector<HashStringAllocator::Position> positions;
     auto size = data->size();
     positions.reserve(size);
+    exec::ContainerRowSerdeOptions options{.isKey = isKey};
 
     for (auto i = 0; i < size; ++i) {
-      ByteStream out(&allocator_);
+      ByteOutputStream out(&allocator_);
       auto position = allocator_.newWrite(out);
-      ContainerRowSerde::serialize(*data, i, out);
+      ContainerRowSerde::serialize(*data, i, out, options);
       allocator_.finishWrite(out, 0);
       positions.emplace_back(position);
     }
@@ -67,10 +80,9 @@ class ContainerRowSerdeTest : public testing::Test,
       data->setNull(i, true);
     }
 
-    ByteStream in;
-    HashStringAllocator::prepareRead(position.header, in);
+    auto in = HashStringAllocator::prepareRead(position.header);
     for (auto i = 0; i < numRows; ++i) {
-      ContainerRowSerde::deserialize(in, i, data.get());
+      ContainerRowSerde::deserialize(*in, i, data.get());
     }
     return data;
   }
@@ -83,6 +95,9 @@ class ContainerRowSerdeTest : public testing::Test,
     allocator_.clear();
   }
 
+  // If the mode is NullAsIndeterminate with equalsOnly is false, and expected
+  // is kIndeterminate, then the test ensures that an exception is thrown with
+  // the message "Ordering nulls is not supported".
   void testCompareWithNulls(
       const DecodedVector& decodedVector,
       const std::vector<HashStringAllocator::Position>& positions,
@@ -96,35 +111,92 @@ class ContainerRowSerdeTest : public testing::Test,
         mode};
 
     for (auto i = 0; i < expected.size(); ++i) {
-      ByteStream stream;
-      HashStringAllocator::prepareRead(positions.at(i).header, stream);
-      ASSERT_EQ(
-          expected.at(i),
-          ContainerRowSerde::compareWithNulls(
-              stream, decodedVector, i, compareFlags));
+      auto stream = HashStringAllocator::prepareRead(positions.at(i).header);
+      if (expected.at(i) == kIndeterminate &&
+          mode == CompareFlags::NullHandlingMode::kNullAsIndeterminate &&
+          !equalsOnly) {
+        VELOX_ASSERT_THROW(
+            ContainerRowSerde::compareWithNulls(
+                *stream, decodedVector, i, compareFlags),
+            "Ordering nulls is not supported");
+      } else {
+        ASSERT_EQ(
+            expected.at(i),
+            ContainerRowSerde::compareWithNulls(
+                *stream, decodedVector, i, compareFlags));
+      }
     }
   }
 
-  void testCompare(const VectorPtr& vector) {
-    auto positions = serializeWithPositions(vector);
-
+  // If the mode is NullAsIndeterminate with equalsOnly is false, and expected
+  // is kIndeterminate, then the test ensures that an exception is thrown with
+  // the message "Ordering nulls is not supported".
+  void testCompareByteStreamWithNulls(
+      const std::vector<HashStringAllocator::Position>& leftPositions,
+      const std::vector<HashStringAllocator::Position>& rightPositions,
+      const std::vector<std::optional<int32_t>>& expected,
+      const TypePtr& type,
+      bool equalsOnly,
+      CompareFlags::NullHandlingMode mode) {
     CompareFlags compareFlags{
         true, // nullsFirst
         true, // ascending
-        true,
-        CompareFlags::NullHandlingMode::NoStop};
+        equalsOnly,
+        mode};
+
+    for (auto i = 0; i < expected.size(); ++i) {
+      auto leftStream =
+          HashStringAllocator::prepareRead(leftPositions.at(i).header);
+      auto rightStream =
+          HashStringAllocator::prepareRead(rightPositions.at(i).header);
+      if (expected.at(i) == kIndeterminate &&
+          mode == CompareFlags::NullHandlingMode::kNullAsIndeterminate &&
+          !equalsOnly) {
+        VELOX_ASSERT_THROW(
+            ContainerRowSerde::compareWithNulls(
+                *leftStream, *rightStream, type.get(), compareFlags),
+            "Ordering nulls is not supported");
+      } else {
+        ASSERT_EQ(
+            expected.at(i),
+            ContainerRowSerde::compareWithNulls(
+                *leftStream, *rightStream, type.get(), compareFlags));
+      }
+    }
+  }
+
+  void testCompare(const VectorPtr& vector) {
+    auto positions = serializeWithPositions(vector);
+
+    CompareFlags compareFlags =
+        CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
 
     DecodedVector decodedVector(*vector);
 
     for (auto i = 0; i < positions.size(); ++i) {
-      ByteStream stream;
-      HashStringAllocator::prepareRead(positions.at(i).header, stream);
+      auto stream = HashStringAllocator::prepareRead(positions.at(i).header);
       ASSERT_EQ(
-          0, ContainerRowSerde::compare(stream, decodedVector, i, compareFlags))
+          0,
+          ContainerRowSerde::compare(*stream, decodedVector, i, compareFlags))
           << "at " << i << ": " << vector->toString(i);
     }
   }
 
+  void assertNotEqualVectors(
+      const VectorPtr& actual,
+      const VectorPtr& expected) {
+    ASSERT_EQ(actual->size(), expected->size());
+    ASSERT_TRUE(actual->type()->equivalent(*expected->type()))
+        << "Expected " << expected->type()->toString() << ", but got "
+        << actual->type()->toString();
+    for (auto i = 0; i < expected->size(); i++) {
+      if (!actual->equalValueAt(expected.get(), i, i)) {
+        return;
+      }
+    }
+    FAIL() << "Expect two vectors are not equal.";
+  }
+
   HashStringAllocator allocator_{pool()};
 };
 
@@ -186,6 +258,33 @@ TEST_F(ContainerRowSerdeTest, arrayOfString) {
   testRoundTrip(data);
 }
 
+TEST_F(ContainerRowSerdeTest, map) {
+  auto data = makeMapVector<int64_t, int64_t>({
+      {{2, 20}, {3, 30}, {1, 10}},
+      {{4, 40}},
+  });
+
+  testRoundTrip(data);
+
+  // When sortMap is not set, serialized Map has the same order of map entries
+  // as the input.
+  {
+    auto position = serialize(data, false);
+    auto deserialized = deserialize(position, data->type(), data->size());
+    test::assertEqualVectors(
+        data->mapKeys(), deserialized->as<MapVector>()->mapKeys());
+  }
+
+  // When sortMap is set, serialized Map has map entries sorted and thus in a
+  // different order than the input.
+  {
+    auto position = serialize(data, true);
+    auto deserialized = deserialize(position, data->type(), data->size());
+    assertNotEqualVectors(
+        data->mapKeys(), deserialized->as<MapVector>()->mapKeys());
+  }
+}
+
 TEST_F(ContainerRowSerdeTest, nested) {
   auto data = makeRowVector(
       {makeNullableFlatVector<int64_t>({1, 2, 3}),
@@ -232,19 +331,19 @@ TEST_F(ContainerRowSerdeTest, compareNullsInArrayVector) {
       positions,
       {{0}, {1}, {-1}, std::nullopt, std::nullopt, std::nullopt},
       false,
-      CompareFlags::NullHandlingMode::StopAtNull);
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
   testCompareWithNulls(
       decodedVector,
       positions,
       {{0}, {1}, {1}, {1}, std::nullopt, {1}},
       true,
-      CompareFlags::NullHandlingMode::StopAtNull);
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
   testCompareWithNulls(
       decodedVector,
       positions,
       {{0}, {1}, {-1}, {1}, {0}, {-1}},
       false,
-      CompareFlags::NullHandlingMode::NoStop);
+      CompareFlags::NullHandlingMode::kNullAsValue);
 
   allocator_.clear();
 }
@@ -270,37 +369,27 @@ TEST_F(ContainerRowSerdeTest, compareNullsInMapVector) {
       positions,
       {{-1}, {0}, {1}, std::nullopt},
       false,
-      CompareFlags::NullHandlingMode::StopAtNull);
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
   testCompareWithNulls(
       decodedVector,
       positions,
       {{1}, {0}, {1}, std::nullopt},
       true,
-      CompareFlags::NullHandlingMode::StopAtNull);
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
   testCompareWithNulls(
       decodedVector,
       positions,
       {{1}, {0}, {1}, {0}},
       true,
-      CompareFlags::NullHandlingMode::NoStop);
+      CompareFlags::NullHandlingMode::kNullAsValue);
 
   allocator_.clear();
 }
 
 TEST_F(ContainerRowSerdeTest, compareNullsInRowVector) {
-  auto data = makeRowVector({makeFlatVector<int32_t>({
-      1,
-      2,
-      3,
-      4,
-  })});
+  auto data = makeRowVector({makeFlatVector<int32_t>({1, 2, 3, 4})});
   auto positions = serializeWithPositions(data);
-  auto someNulls = makeNullableFlatVector<int32_t>({
-      1,
-      3,
-      2,
-      std::nullopt,
-  });
+  auto someNulls = makeNullableFlatVector<int32_t>({1, 3, 2, std::nullopt});
   auto rowVector = makeRowVector({someNulls});
   DecodedVector decodedVector(*rowVector);
 
@@ -309,13 +398,129 @@ TEST_F(ContainerRowSerdeTest, compareNullsInRowVector) {
       positions,
       {{0}, {-1}, {1}, std::nullopt},
       false,
-      CompareFlags::NullHandlingMode::StopAtNull);
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
   testCompareWithNulls(
       decodedVector,
       positions,
       {{0}, {-1}, {1}, {1}},
       false,
-      CompareFlags::NullHandlingMode::NoStop);
+      CompareFlags::NullHandlingMode::kNullAsValue);
+
+  allocator_.clear();
+}
+
+TEST_F(ContainerRowSerdeTest, compareNullsInArrayByteStream) {
+  auto left = makeNullableArrayVector<int64_t>({
+      {1, 2},
+      {1, 5},
+      {1, 3, 5},
+      {1, 2, 3, 4},
+      {1, 2, std::nullopt, 4},
+      {1, std::nullopt, 5},
+  });
+  auto leftPositions = serializeWithPositions(left);
+
+  auto right = makeNullableArrayVector<int64_t>({
+      {1, 2},
+      {1, 3},
+      {1, 5},
+      {std::nullopt, 1},
+      {1, 2, std::nullopt, 4},
+      {1, 5},
+  });
+  auto rightPositions = serializeWithPositions(right);
+
+  testCompareByteStreamWithNulls(
+      leftPositions,
+      rightPositions,
+      {{0}, {1}, {-1}, std::nullopt, std::nullopt, std::nullopt},
+      ARRAY(BIGINT()),
+      false,
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  testCompareByteStreamWithNulls(
+      leftPositions,
+      rightPositions,
+      {{0}, {1}, {1}, {1}, std::nullopt, {1}},
+      ARRAY(BIGINT()),
+      true,
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  testCompareByteStreamWithNulls(
+      leftPositions,
+      rightPositions,
+      {{0}, {1}, {-1}, {1}, {0}, {-1}},
+      ARRAY(BIGINT()),
+      false,
+      CompareFlags::NullHandlingMode::kNullAsValue);
+
+  allocator_.clear();
+}
+
+TEST_F(ContainerRowSerdeTest, compareNullsInRowByteStream) {
+  auto left = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2, 3, 4}),
+       makeFlatVector<int32_t>({1, 2, 3, 4})});
+  auto leftPositions = serializeWithPositions(left);
+  auto right = makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, 3, 2, std::nullopt}),
+       makeFlatVector<int32_t>({1, 2, 3, 4})});
+  auto rightPositions = serializeWithPositions(right);
+
+  testCompareByteStreamWithNulls(
+      leftPositions,
+      rightPositions,
+      {{0}, {-1}, {1}, std::nullopt},
+      ROW({INTEGER(), INTEGER()}),
+      false,
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  testCompareByteStreamWithNulls(
+      leftPositions,
+      rightPositions,
+      {{0}, {-1}, {1}, {1}},
+      ROW({INTEGER(), INTEGER()}),
+      false,
+      CompareFlags::NullHandlingMode::kNullAsValue);
+
+  allocator_.clear();
+}
+
+TEST_F(ContainerRowSerdeTest, compareNullsInMapByteStream) {
+  auto left = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 10}, {4, 30}, {2, 3}}},
+      {{{2, 20}}},
+      {{{3, 50}}},
+      {{{4, std::nullopt}}},
+  });
+  auto leftPositions = serializeWithPositions(left);
+
+  auto right = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 10}, {3, 20}}},
+      {{{2, 20}}},
+      {{{3, 40}}},
+      {{{4, std::nullopt}}},
+  });
+  auto rightPositions = serializeWithPositions(right);
+
+  testCompareByteStreamWithNulls(
+      leftPositions,
+      rightPositions,
+      {{-1}, {0}, {1}, std::nullopt},
+      MAP(BIGINT(), BIGINT()),
+      false,
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  testCompareByteStreamWithNulls(
+      leftPositions,
+      rightPositions,
+      {{1}, {0}, {1}, std::nullopt},
+      MAP(BIGINT(), BIGINT()),
+      true,
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  testCompareByteStreamWithNulls(
+      leftPositions,
+      rightPositions,
+      {{1}, {0}, {1}, {0}},
+      MAP(BIGINT(), BIGINT()),
+      true,
+      CompareFlags::NullHandlingMode::kNullAsValue);
 
   allocator_.clear();
 }
@@ -367,5 +572,38 @@ TEST_F(ContainerRowSerdeTest, fuzzCompare) {
   }
 }
 
+TEST_F(ContainerRowSerdeTest, nans) {
+  // Verify that the NaNs with different representations are considered equal
+  // and have the same hash value.
+  auto vector = makeNullableFlatVector<double>(
+      {std::nan("1"),
+       std::nan("2"),
+       std::numeric_limits<double>::quiet_NaN(),
+       std::numeric_limits<double>::signaling_NaN()});
+
+  // Compare with the same NaN value
+  auto expected = makeConstant(std::nan("1"), 4, vector->type());
+
+  auto positions = serializeWithPositions(vector);
+
+  CompareFlags compareFlags =
+      CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
+
+  DecodedVector decodedVector(*expected);
+
+  for (auto i = 0; i < positions.size(); ++i) {
+    auto stream = HashStringAllocator::prepareRead(positions.at(i).header);
+    ASSERT_EQ(
+        0, ContainerRowSerde::compare(*stream, decodedVector, i, compareFlags))
+        << "at " << i << ": " << vector->toString(i);
+
+    stream = HashStringAllocator::prepareRead(positions.at(i).header);
+    ASSERT_EQ(
+        expected->hashValueAt(i),
+        ContainerRowSerde::hash(*stream, vector->type().get()))
+        << "at " << i << ": " << vector->toString(i);
+  }
+}
+
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/CprHttpClientTest.cpp b/velox/exec/tests/CprHttpClientTest.cpp
new file mode 100644
index 0000000000000..9a19ccaaed245
--- /dev/null
+++ b/velox/exec/tests/CprHttpClientTest.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+
+#include <cpr/cpr.h>
+#include <map>
+
+class CprHttpClientTest : public testing::Test {};
+
+// This test requires open access to internet and most places test runners might
+// be closed off from the general internet. And this test case is just an
+// illustration of how to use cpr, so disable it by default.
+TEST_F(CprHttpClientTest, DISABLED_basic) {
+  auto response = cpr::Get(
+      cpr::Url{"https://facebookincubator.github.io/velox/"},
+      cpr::Timeout{std::chrono::seconds{3}});
+  ASSERT_EQ(response.status_code, 200);
+  ASSERT_FALSE(response.text.empty());
+
+  response = cpr::Get(cpr::Url{"null"});
+  ASSERT_NE(response.status_code, 200);
+  ASSERT_TRUE(response.text.empty());
+
+  response = cpr::Post(
+      cpr::Url{"https://facebookincubator.github.io/velox/"},
+      cpr::Body{"select * from nation limit 1"},
+      cpr::Header({{"Content-Type", "text/plain"}}));
+  ASSERT_EQ(response.status_code, 405);
+  ASSERT_FALSE(response.text.empty());
+
+  response = cpr::Post(
+      cpr::Url{"null"},
+      cpr::Body{"select * from nation limit 1"},
+      cpr::Header({{"Content-Type", "text/plain"}}));
+  ASSERT_NE(response.status_code, 200);
+  ASSERT_TRUE(response.text.empty());
+}
diff --git a/velox/exec/tests/DriverTest.cpp b/velox/exec/tests/DriverTest.cpp
index 8516161a0999c..d96205502d207 100644
--- a/velox/exec/tests/DriverTest.cpp
+++ b/velox/exec/tests/DriverTest.cpp
@@ -16,15 +16,18 @@
 #include <folly/Unit.h>
 #include <folly/init/Init.h>
 #include <velox/exec/Driver.h>
+#include <memory>
 #include "folly/experimental/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/Values.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/Cursor.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/Udf.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -99,6 +102,7 @@ class DriverTest : public OperatorTestBase {
     // NOTE: destroy the tasks first to release all the allocated memory held
     // by the plan nodes (Values) in tasks.
     tasks_.clear();
+    waitForAllTasksToBeDeleted();
 
     if (wakeupInitialized_) {
       wakeupCancelled_ = true;
@@ -172,8 +176,10 @@ class DriverTest : public OperatorTestBase {
       // To be realized either after 1s wall time or when the corresponding Task
       // is no longer running.
       auto& executor = folly::QueuedImmediateExecutor::instance();
-      auto future =
-          tasks_.back()->taskCompletionFuture(1'000'000).via(&executor);
+      auto future = tasks_.back()
+                        ->taskCompletionFuture()
+                        .within(std::chrono::microseconds(1'000'000))
+                        .via(&executor);
       stateFutures_.emplace(threadId, std::move(future));
 
       EXPECT_FALSE(stateFutures_.at(threadId).isReady());
@@ -261,75 +267,87 @@ class DriverTest : public OperatorTestBase {
         "t0",
         plan,
         0,
-        std::make_shared<core::QueryCtx>(driverExecutor_.get()),
+        core::QueryCtx::create(driverExecutor_.get()),
+        Task::ExecutionMode::kParallel,
         [](RowVectorPtr /*unused*/, ContinueFuture* /*unused*/) {
           return exec::BlockingReason::kNotBlocked;
         });
-    task->start(task, numDrivers, 1);
+    task->start(numDrivers, 1);
     return task;
   }
 
   void testDriverSuspensionWithTaskOperationRace(
       int numDrivers,
       StopReason expectedEnterSuspensionStopReason,
-      StopReason expectedLeaveSuspensionStopReason,
+      std::optional<StopReason> expectedLeaveSuspensionStopReason,
       TaskState expectedTaskState,
       std::function<void(Task*)> preSuspensionTaskFunc = nullptr,
       std::function<void(Task*)> inSuspensionTaskFunc = nullptr,
       std::function<void(Task*)> leaveSuspensionTaskFunc = nullptr) {
+    std::atomic_bool driverExecutionWaitFlag{true};
     folly::EventCount driverExecutionWait;
-    auto driverExecutionWaitKey = driverExecutionWait.prepareWait();
+    std::atomic_bool enterSuspensionWaitFlag{true};
     folly::EventCount enterSuspensionWait;
-    auto enterSuspensionKey = enterSuspensionWait.prepareWait();
+    std::atomic_bool suspensionNotifyFlag{true};
     folly::EventCount suspensionNotify;
-    auto suspensionNotifyKey = suspensionNotify.prepareWait();
+    std::atomic_bool leaveSuspensionWaitFlag{true};
     folly::EventCount leaveSuspensionWait;
-    auto leaveSuspensionKey = leaveSuspensionWait.prepareWait();
+    std::atomic_bool leaveSuspensionNotifyFlag{true};
     folly::EventCount leaveSuspensionNotify;
-    auto leaveSuspensionNotifyKey = leaveSuspensionNotify.prepareWait();
 
-    std::atomic<bool> injectSuspension{true};
+    std::atomic<bool> injectSuspensionOnce{true};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Values::getOutput",
         std::function<void(const exec::Values*)>(
             ([&](const exec::Values* values) {
-              driverExecutionWait.notify();
-              if (!injectSuspension.exchange(false)) {
+              driverExecutionWaitFlag = false;
+              driverExecutionWait.notifyAll();
+              if (!injectSuspensionOnce.exchange(false)) {
                 return;
               }
               auto* driver = values->testingOperatorCtx()->driver();
-              enterSuspensionWait.wait(enterSuspensionKey);
+              enterSuspensionWait.await(
+                  [&]() { return !enterSuspensionWaitFlag.load(); });
               ASSERT_EQ(
                   driver->task()->enterSuspended(driver->state()),
                   expectedEnterSuspensionStopReason);
-              suspensionNotify.notify();
-              leaveSuspensionWait.wait(leaveSuspensionKey);
-              ASSERT_EQ(
-                  driver->task()->leaveSuspended(driver->state()),
-                  expectedLeaveSuspensionStopReason);
-              leaveSuspensionNotify.notify();
+              suspensionNotifyFlag = false;
+              suspensionNotify.notifyAll();
+              leaveSuspensionWait.await(
+                  [&]() { return !leaveSuspensionWaitFlag.load(); });
+              if (expectedLeaveSuspensionStopReason.has_value()) {
+                ASSERT_EQ(
+                    driver->task()->leaveSuspended(driver->state()),
+                    expectedLeaveSuspensionStopReason.value());
+              }
+              leaveSuspensionNotifyFlag = false;
+              leaveSuspensionNotify.notifyAll();
             })));
 
     auto task = createAndStartTaskToReadValues(numDrivers);
 
-    driverExecutionWait.wait(driverExecutionWaitKey);
+    driverExecutionWait.await(
+        [&]() { return !driverExecutionWaitFlag.load(); });
 
     if (preSuspensionTaskFunc != nullptr) {
       preSuspensionTaskFunc(task.get());
     }
-    enterSuspensionWait.notify();
+    enterSuspensionWaitFlag = false;
+    enterSuspensionWait.notifyAll();
 
-    suspensionNotify.wait(suspensionNotifyKey);
+    suspensionNotify.await([&]() { return !suspensionNotifyFlag.load(); });
     if (inSuspensionTaskFunc != nullptr) {
       inSuspensionTaskFunc(task.get());
     }
-    leaveSuspensionWait.notify();
+    leaveSuspensionWaitFlag = false;
+    leaveSuspensionWait.notifyAll();
 
     // NOTE: this callback is executed in par with driver suspension leave.
     if (leaveSuspensionTaskFunc != nullptr) {
       leaveSuspensionTaskFunc(task.get());
     }
-    leaveSuspensionNotify.wait(leaveSuspensionNotifyKey);
+    leaveSuspensionNotify.await(
+        [&]() { return !leaveSuspensionNotifyFlag.load(); });
     if (expectedTaskState == TaskState::kFinished) {
       ASSERT_TRUE(waitForTaskCompletion(task.get(), 1000'000'000));
     } else if (expectedTaskState == TaskState::kCanceled) {
@@ -448,7 +466,10 @@ TEST_F(DriverTest, error) {
   EXPECT_EQ(numRead, 0);
   EXPECT_TRUE(stateFutures_.at(0).isReady());
   // Realized immediately since task not running.
-  EXPECT_TRUE(tasks_[0]->taskCompletionFuture(1'000'000).isReady());
+  EXPECT_TRUE(tasks_[0]
+                  ->taskCompletionFuture()
+                  .within(std::chrono::microseconds(1'000'000))
+                  .isReady());
   EXPECT_EQ(tasks_[0]->state(), TaskState::kFailed);
 }
 
@@ -470,7 +491,10 @@ TEST_F(DriverTest, cancel) {
   }
   EXPECT_GE(numRead, 1'000'000);
   auto& executor = folly::QueuedImmediateExecutor::instance();
-  auto future = tasks_[0]->taskCompletionFuture(1'000'000).via(&executor);
+  auto future = tasks_[0]
+                    ->taskCompletionFuture()
+                    .within(std::chrono::microseconds(1'000'000))
+                    .via(&executor);
   future.wait();
   EXPECT_TRUE(stateFutures_.at(0).isReady());
 
@@ -523,7 +547,10 @@ TEST_F(DriverTest, slow) {
   // are updated some tens of instructions after this. Determinism
   // requires a barrier.
   auto& executor = folly::QueuedImmediateExecutor::instance();
-  auto future = tasks_[0]->taskCompletionFuture(1'000'000).via(&executor);
+  auto future = tasks_[0]
+                    ->taskCompletionFuture()
+                    .within(std::chrono::microseconds(1'000'000))
+                    .via(&executor);
   future.wait();
   // Note that the driver count drops after the last thread stops and
   // realizes the future.
@@ -553,13 +580,14 @@ TEST_F(DriverTest, pause) {
   // Make sure CPU usage tracking is enabled.
   std::unordered_map<std::string, std::string> queryConfig{
       {core::QueryConfig::kOperatorTrackCpuUsage, "true"}};
-  params.queryCtx = std::make_shared<core::QueryCtx>(
+  params.queryCtx = core::QueryCtx::create(
       executor_.get(), core::QueryConfig(std::move(queryConfig)));
   int32_t numRead = 0;
   readResults(params, ResultOperation::kPause, 370'000'000, &numRead);
   // Each thread will fully read the 1M rows in values.
   EXPECT_EQ(numRead, 10 * hits);
-  auto stateFuture = tasks_[0]->taskCompletionFuture(100'000'000);
+  auto stateFuture = tasks_[0]->taskCompletionFuture().within(
+      std::chrono::microseconds(100'000'000));
   auto& executor = folly::QueuedImmediateExecutor::instance();
   auto state = std::move(stateFuture).via(&executor);
   state.wait();
@@ -686,7 +714,7 @@ class TestingPauser : public Operator {
   }
 
   BlockingReason isBlocked(ContinueFuture* future) override {
-    VELOX_CHECK(!operatorCtx_->driver()->state().isSuspended);
+    VELOX_CHECK(!operatorCtx_->driver()->state().suspended());
     if (future_.valid()) {
       *future = std::move(future_);
       return BlockingReason::kWaitForConsumer;
@@ -775,7 +803,7 @@ TEST_F(DriverTest, pauserNode) {
   std::vector<CursorParameters> params(kNumTasks);
   int32_t hits{0};
   for (int32_t i = 0; i < kNumTasks; ++i) {
-    params[i].queryCtx = std::make_shared<core::QueryCtx>(executor.get());
+    params[i].queryCtx = core::QueryCtx::create(executor.get());
     params[i].planNode = makeValuesFilterProject(
         rowType_,
         "m1 % 10 > 0",
@@ -959,6 +987,74 @@ class ThrowNodeFactory : public Operator::PlanNodeTranslator {
   uint32_t driversCreated{0};
 };
 
+class BlockedNoFutureNode : public core::PlanNode {
+ public:
+  BlockedNoFutureNode(
+      const core::PlanNodeId& id,
+      const core::PlanNodePtr& input)
+      : PlanNode(id), sources_{input} {}
+
+  const RowTypePtr& outputType() const override {
+    return sources_[0]->outputType();
+  }
+
+  const std::vector<std::shared_ptr<const PlanNode>>& sources() const override {
+    return sources_;
+  }
+
+  std::string_view name() const override {
+    return "BlockedNoFuture";
+  }
+
+ private:
+  void addDetails(std::stringstream& /* stream */) const override {}
+  std::vector<core::PlanNodePtr> sources_;
+};
+
+class BlockedNoFutureOperator : public Operator {
+ public:
+  BlockedNoFutureOperator(
+      DriverCtx* ctx,
+      int32_t id,
+      const std::shared_ptr<const BlockedNoFutureNode>& node)
+      : Operator(ctx, node->outputType(), id, node->id(), "BlockedNoFuture") {}
+
+  bool needsInput() const override {
+    return !noMoreInput_ && !input_;
+  }
+
+  void addInput(RowVectorPtr input) override {
+    input_ = std::move(input);
+  }
+
+  RowVectorPtr getOutput() override {
+    return std::move(input_);
+  }
+
+  bool isFinished() override {
+    return noMoreInput_ && input_ == nullptr;
+  }
+
+  BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    // Report being blocked, but do not set the future to trigger the error.
+    return BlockingReason::kYield;
+  }
+};
+
+class BlockedNoFutureNodeFactory : public Operator::PlanNodeTranslator {
+ public:
+  std::unique_ptr<Operator> toOperator(
+      DriverCtx* ctx,
+      int32_t id,
+      const core::PlanNodePtr& node) override {
+    return std::make_unique<BlockedNoFutureOperator>(
+        ctx, id, std::dynamic_pointer_cast<const BlockedNoFutureNode>(node));
+  }
+
+  std::optional<uint32_t> maxDrivers(const core::PlanNodePtr& node) override {
+    return 1;
+  }
+};
 } // namespace
 
 // Use a node for which driver factory would throw on any driver beyond id 0.
@@ -971,7 +1067,8 @@ TEST_F(DriverTest, driverCreationThrow) {
 
   auto plan = PlanBuilder()
                   .values({rows}, true)
-                  .addNode([](std::string id, core::PlanNodePtr input) {
+                  .addNode([](const core::PlanNodeId& id,
+                              const core::PlanNodePtr& input) {
                     return std::make_shared<ThrowNode>(
                         id, ThrowNode::OperatorMethod::kAddInput, input);
                   })
@@ -979,13 +1076,31 @@ TEST_F(DriverTest, driverCreationThrow) {
   CursorParameters params;
   params.planNode = plan;
   params.maxDrivers = 5;
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   auto task = cursor->task();
   // Ensure execution threw correct error.
   VELOX_ASSERT_THROW(cursor->moveNext(), "Too many drivers");
   EXPECT_EQ(TaskState::kFailed, task->state());
 }
 
+TEST_F(DriverTest, blockedNoFuture) {
+  Operator::registerOperator(std::make_unique<BlockedNoFutureNodeFactory>());
+
+  auto rows = makeRowVector({makeFlatVector<int32_t>({1, 2, 3})});
+
+  auto plan = PlanBuilder()
+                  .values({rows}, true)
+                  .addNode([](const core::PlanNodeId& id,
+                              const core::PlanNodePtr& input) {
+                    return std::make_shared<BlockedNoFutureNode>(id, input);
+                  })
+                  .planNode();
+  // Ensure execution threw correct error.
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "The operator BlockedNoFuture is blocked but blocking future is not valid");
+}
+
 TEST_F(DriverTest, nonVeloxOperatorException) {
   Operator::registerOperator(
       std::make_unique<ThrowNodeFactory>(std::numeric_limits<uint32_t>::max()));
@@ -1093,7 +1208,7 @@ DEBUG_ONLY_TEST_F(DriverTest, driverSuspensionRaceWithTaskPause) {
             std::this_thread::sleep_for(std::chrono::milliseconds(100));
             bool hasSuspendedDriver{false};
             task->testingVisitDrivers([&](Driver* driver) {
-              hasSuspendedDriver |= driver->state().isSuspended;
+              hasSuspendedDriver |= driver->state().suspended();
             });
             ASSERT_TRUE(hasSuspendedDriver);
             Task::resume(task->shared_from_this());
@@ -1126,7 +1241,7 @@ DEBUG_ONLY_TEST_F(DriverTest, driverSuspensionRaceWithTaskPause) {
             std::this_thread::sleep_for(std::chrono::milliseconds(100));
             bool hasSuspendedDriver{false};
             task->testingVisitDrivers([&](Driver* driver) {
-              hasSuspendedDriver |= driver->state().isSuspended;
+              hasSuspendedDriver |= driver->state().suspended();
             });
             ASSERT_TRUE(hasSuspendedDriver);
             Task::resume(task->shared_from_this());
@@ -1152,7 +1267,7 @@ DEBUG_ONLY_TEST_F(DriverTest, driverSuspensionRaceWithTaskTerminate) {
     bool enterSuspensionAfterTaskTerminated;
     bool abort;
     StopReason expectedEnterSuspensionStopReason;
-    StopReason expectedLeaveSuspensionStopReason;
+    std::optional<StopReason> expectedLeaveSuspensionStopReason;
 
     std::string debugString() const {
       return fmt::format(
@@ -1161,7 +1276,9 @@ DEBUG_ONLY_TEST_F(DriverTest, driverSuspensionRaceWithTaskTerminate) {
           enterSuspensionAfterTaskTerminated,
           abort,
           expectedEnterSuspensionStopReason,
-          expectedLeaveSuspensionStopReason);
+          expectedLeaveSuspensionStopReason.has_value()
+              ? stopReasonString(expectedLeaveSuspensionStopReason.value())
+              : "NULL");
     }
   } testSettings[] = {
       // This test case (1) uses TestValue to block one of the task driver
@@ -1171,17 +1288,9 @@ DEBUG_ONLY_TEST_F(DriverTest, driverSuspensionRaceWithTaskTerminate) {
       // terminated; (4) leaves the suspension from the blocked driver thread
       // and expects the same stop reason; (5) wait and expects the task to be
       // aborted.
-      {1,
-       true,
-       true,
-       StopReason::kAlreadyTerminated,
-       StopReason::kAlreadyTerminated},
+      {1, true, true, StopReason::kAlreadyTerminated, std::nullopt},
       // The same as above with different number of driver threads.
-      {4,
-       true,
-       true,
-       StopReason::kAlreadyTerminated,
-       StopReason::kAlreadyTerminated},
+      {4, true, true, StopReason::kAlreadyTerminated, std::nullopt},
       // This test case (1) uses TestValue to block one of the task driver
       // threads when it processes the input values; (2) enters suspension from
       // the blocked driver thread and expects to get kNone stop reason as the
@@ -1194,16 +1303,8 @@ DEBUG_ONLY_TEST_F(DriverTest, driverSuspensionRaceWithTaskTerminate) {
       {4, false, true, StopReason::kNone, StopReason::kAlreadyTerminated},
 
       // Repeated the above test cases by terminating task by cancel.
-      {1,
-       true,
-       false,
-       StopReason::kAlreadyTerminated,
-       StopReason::kAlreadyTerminated},
-      {4,
-       true,
-       false,
-       StopReason::kAlreadyTerminated,
-       StopReason::kAlreadyTerminated},
+      {1, true, false, StopReason::kAlreadyTerminated, std::nullopt},
+      {4, true, false, StopReason::kAlreadyTerminated, std::nullopt},
       {1, false, false, StopReason::kNone, StopReason::kAlreadyTerminated},
       {4, false, false, StopReason::kNone, StopReason::kAlreadyTerminated}};
   for (const auto& testData : testSettings) {
@@ -1310,8 +1411,51 @@ DEBUG_ONLY_TEST_F(DriverTest, driverSuspensionCalledFromOffThread) {
   while (driver->isOnThread()) {
     std::this_thread::sleep_for(std::chrono::milliseconds(1));
   }
-  ASSERT_ANY_THROW(driver->task()->enterSuspended(driver->state()));
-  ASSERT_ANY_THROW(driver->task()->leaveSuspended(driver->state()));
+  VELOX_ASSERT_THROW(driver->task()->enterSuspended(driver->state()), "");
+  VELOX_ASSERT_THROW(driver->task()->leaveSuspended(driver->state()), "");
+}
+
+// This test case verifies that the driver thread leaves suspended state after
+// task termiates and before resuming.
+DEBUG_ONLY_TEST_F(DriverTest, driverSuspendedAfterTaskTerminateBeforeResume) {
+  std::shared_ptr<Driver> driver;
+  std::atomic_bool triggerSuspended{false};
+  std::atomic_bool taskPaused{false};
+  // std::atomic_bool driverExecutionWaitFlag{true};
+  folly::EventCount taskPausedWait;
+  std::atomic_bool driverLeaveSuspended{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        if (triggerSuspended.exchange(true)) {
+          return;
+        }
+        driver = values->testingOperatorCtx()->driver()->shared_from_this();
+        driver->task()->enterSuspended(driver->state());
+        driver->task()->requestPause().wait();
+        taskPaused = true;
+        taskPausedWait.notifyAll();
+        const StopReason ret = driver->task()->leaveSuspended(driver->state());
+        ASSERT_EQ(ret, StopReason::kAlreadyTerminated);
+        driverLeaveSuspended = true;
+      }));
+
+  auto task = createAndStartTaskToReadValues(1);
+
+  taskPausedWait.await([&]() { return taskPaused.load(); });
+  task->requestCancel().wait();
+  // Wait for 1 second and check the driver is still under suspended state
+  // without resuming.
+  std::this_thread::sleep_for(std::chrono::milliseconds(1'000));
+  ASSERT_FALSE(driverLeaveSuspended);
+
+  Task::resume(task);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1'000));
+  // Check the driver leaves the suspended state after task is resumed. Wait for
+  // 1 second to avoid timing flakiness.
+  ASSERT_TRUE(driverLeaveSuspended);
+
+  ASSERT_TRUE(waitForTaskCancelled(task.get(), 100'000'000));
 }
 
 DEBUG_ONLY_TEST_F(DriverTest, driverThreadContext) {
@@ -1339,3 +1483,284 @@ DEBUG_ONLY_TEST_F(DriverTest, driverThreadContext) {
                   .assertResults("SELECT * FROM tmp");
   ASSERT_EQ(task.get(), capturedTask);
 }
+
+DEBUG_ONLY_TEST_F(DriverTest, nonReclaimableSection) {
+  // The driver framework will set non-reclaimable section flag when start
+  // executing operator method.
+  // Checks before getOutput method called.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        ASSERT_FALSE(values->testingNonReclaimable());
+      }));
+  // Checks inside getOutput method execution.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        ASSERT_TRUE(values->testingNonReclaimable());
+      }));
+
+  std::vector<RowVectorPtr> batches;
+  for (int i = 0; i < 2; ++i) {
+    batches.push_back(makeRowVector({makeFlatVector<int32_t>({1, 2, 3})}));
+  }
+  auto plan = PlanBuilder().values(batches).planNode();
+  ASSERT_NO_THROW(AssertQueryBuilder(plan).copyResults(pool()));
+}
+
+DEBUG_ONLY_TEST_F(DriverTest, driverCpuTimeSlicingCheck) {
+  const int numBatches = 3;
+  std::vector<RowVectorPtr> batches;
+  for (int i = 0; i < numBatches; ++i) {
+    batches.push_back(
+        makeRowVector({"c0"}, {makeFlatVector<int32_t>({1, 2, 3})}));
+  }
+
+  struct TestParam {
+    bool hasCpuTimeSliceLimit;
+    Task::ExecutionMode executionMode;
+  };
+  std::vector<TestParam> testParams{
+      {true, Task::ExecutionMode::kParallel},
+      {false, Task::ExecutionMode::kParallel},
+      {true, Task::ExecutionMode::kSerial},
+      {false, Task::ExecutionMode::kSerial}};
+
+  for (const auto& testParam : testParams) {
+    SCOPED_TRACE(
+        fmt::format("hasCpuSliceLimit: {}", testParam.hasCpuTimeSliceLimit));
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Values::getOutput",
+        std::function<void(const exec::Values*)>([&](const exec::Values*
+                                                         values) {
+          // Verify that no matter driver cpu time slicing is enforced or not,
+          // the driver start execution time is set properly.
+          ASSERT_NE(
+              values->testingOperatorCtx()->driver()->state().startExecTimeMs,
+              0);
+          if (testParam.hasCpuTimeSliceLimit) {
+            std::this_thread::sleep_for(std::chrono::seconds(1)); // NOLINT
+            ASSERT_GT(
+                values->testingOperatorCtx()->driver()->state().execTimeMs(),
+                0);
+          }
+        }));
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto fragment =
+        PlanBuilder(planNodeIdGenerator).values(batches).planFragment();
+    std::unordered_map<std::string, std::string> queryConfig;
+    if (testParam.hasCpuTimeSliceLimit) {
+      queryConfig.emplace(core::QueryConfig::kDriverCpuTimeSliceLimitMs, "500");
+    }
+    const uint64_t oldYieldCount = Driver::yieldCount();
+
+    std::shared_ptr<Task> task;
+    if (testParam.executionMode == Task::ExecutionMode::kParallel) {
+      task = Task::create(
+          "t0",
+          fragment,
+          0,
+          core::QueryCtx::create(
+              driverExecutor_.get(), core::QueryConfig{std::move(queryConfig)}),
+          testParam.executionMode,
+          [](RowVectorPtr /*unused*/, ContinueFuture* /*unused*/) {
+            return exec::BlockingReason::kNotBlocked;
+          });
+      task->start(1, 1);
+    } else {
+      task = Task::create(
+          "t0",
+          fragment,
+          0,
+          core::QueryCtx::create(
+              driverExecutor_.get(), core::QueryConfig{std::move(queryConfig)}),
+          testParam.executionMode);
+      while (task->next() != nullptr) {
+      }
+    }
+
+    ASSERT_TRUE(waitForTaskCompletion(task.get(), 600'000'000));
+    if (testParam.hasCpuTimeSliceLimit &&
+        testParam.executionMode == Task::ExecutionMode::kParallel) {
+      // NOTE: there is one additional yield for the empty output.
+      ASSERT_GE(Driver::yieldCount(), oldYieldCount + numBatches + 1);
+    } else {
+      ASSERT_EQ(Driver::yieldCount(), oldYieldCount);
+    }
+  }
+}
+
+namespace {
+
+template <typename T>
+struct ThrowRuntimeExceptionFunction {
+  template <typename TResult, typename TInput>
+  void call(TResult& out, const TInput& in) {
+    VELOX_CHECK(false, "Throwing exception");
+  }
+};
+} // namespace
+
+TEST_F(DriverTest, additionalContextInRuntimeException) {
+  // Ensures that exceptions thrown during execution of an operator contain the
+  // expected context. This is done by executing a plan using project filter
+  // that uses expressions which setup hierarchical contexts. Finally, we verify
+  // that all essential context are present.
+  auto vector = makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6})});
+  registerFunction<ThrowRuntimeExceptionFunction, int64_t, int64_t>(
+      {"throwException"});
+  auto op = PlanBuilder(std::make_shared<core::PlanNodeIdGenerator>(13))
+                .values({vector})
+                .project({"c0 + throwException(c0)"})
+                .planNode();
+  try {
+    assertQuery(op, vector);
+  } catch (VeloxException& e) {
+    ASSERT_EQ(e.context(), "throwexception(c0)");
+    auto additionalContext = e.additionalContext();
+    // Remove the string following `TaskId` from the additional context since
+    // its indeterministic.
+    ASSERT_EQ(
+        additionalContext,
+        "Top-level Expression: plus(c0, throwexception(c0)) Operator: "
+        "FilterProject[14] 1");
+  }
+}
+
+class OpCallStatusTest : public OperatorTestBase {};
+
+// Test that the opCallStatus is returned properly and formats the call as
+// expected.
+TEST_F(OpCallStatusTest, basic) {
+  std::vector<RowVectorPtr> data{
+      makeRowVector({"c0"}, {makeFlatVector<int32_t>({1, 2, 3})})};
+
+  const int firstNodeId{17};
+  auto planNodeIdGenerator =
+      std::make_shared<core::PlanNodeIdGenerator>(firstNodeId);
+  auto fragment = PlanBuilder(planNodeIdGenerator).values(data).planFragment();
+
+  std::unordered_map<std::string, std::string> queryConfig;
+  auto task = Task::create(
+      "t19",
+      fragment,
+      0,
+      core::QueryCtx::create(
+          driverExecutor_.get(), core::QueryConfig{std::move(queryConfig)}),
+      Task::ExecutionMode::kParallel,
+      [](RowVectorPtr /*unused*/, ContinueFuture* /*unused*/) {
+        return exec::BlockingReason::kNotBlocked;
+      });
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        auto* driver = values->testingOperatorCtx()->driver();
+        auto ocs = driver->opCallStatus();
+        // Check osc to be not empty and the correct format.
+        EXPECT_FALSE(ocs.empty());
+        const auto formattedOpCall =
+            ocs.formatCall(driver->findOperatorNoThrow(ocs.opId), ocs.method);
+        EXPECT_EQ(
+            formattedOpCall,
+            fmt::format("Values.{}::{}", firstNodeId, ocs.method));
+        // Check the correct format when operator is not found.
+        ocs.method = "randomName";
+        EXPECT_EQ(
+            ocs.formatCall(
+                driver->findOperatorNoThrow(ocs.opId + 10), ocs.method),
+            fmt::format("null::{}", ocs.method));
+
+        // Check that the task returns correct long running op call.
+        std::vector<Task::OpCallInfo> stuckCalls;
+        const std::chrono::milliseconds lockTimeoutMs(10);
+        task->getLongRunningOpCalls(lockTimeoutMs, 10, stuckCalls);
+        EXPECT_EQ(stuckCalls.size(), 1);
+        if (!stuckCalls.empty()) {
+          const auto& stuckCall = stuckCalls[0];
+          EXPECT_EQ(stuckCall.opId, ocs.opId);
+          EXPECT_GE(stuckCall.durationMs, 100);
+          EXPECT_EQ(stuckCall.tid, driver->state().tid);
+          EXPECT_EQ(stuckCall.taskId, task->taskId());
+          EXPECT_EQ(stuckCall.opCall, formattedOpCall);
+        }
+      }));
+
+  task->start(1, 1);
+  ASSERT_TRUE(waitForTaskCompletion(task.get(), 600'000'000));
+  task.reset();
+  waitForAllTasksToBeDeleted();
+};
+
+// This test verifies that SuspendedSection dtor won't throw with a terminated
+// task. Otherwise, it might cause server crash in production use case.
+DEBUG_ONLY_TEST_F(DriverTest, suspendedSectionLeaveWithTerminatedTask) {
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        auto* driver = values->testingOperatorCtx()->driver();
+        SuspendedSection suspendedSection(driver);
+        {
+          ASSERT_TRUE(driver->state().suspended());
+          SuspendedSection suspendedSection(driver);
+          ASSERT_TRUE(driver->state().suspended());
+          values->testingOperatorCtx()->task()->requestAbort();
+        }
+      }));
+
+  auto task = createAndStartTaskToReadValues(1);
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(DriverTest, recursiveSuspensionCheck) {
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        auto* driver = values->testingOperatorCtx()->driver();
+        {
+          SuspendedSection suspendedSection1(driver);
+          ASSERT_TRUE(driver->state().suspended());
+          SuspendedSection suspendedSection2(driver);
+          ASSERT_TRUE(driver->state().suspended());
+          {
+            ASSERT_TRUE(driver->state().suspended());
+            SuspendedSection suspendedSection(driver);
+            ASSERT_TRUE(driver->state().suspended());
+          }
+          ASSERT_TRUE(driver->state().suspended());
+        }
+        ASSERT_FALSE(driver->state().suspended());
+        SuspendedSection suspendedSection(driver);
+        ASSERT_TRUE(driver->state().suspended());
+      }));
+
+  createAndStartTaskToReadValues(1);
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(DriverTest, recursiveSuspensionThrow) {
+  auto suspendDriverFn = [&](Driver* driver) {
+    SuspendedSection suspendedSection(driver);
+  };
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        auto* driver = values->testingOperatorCtx()->driver();
+        {
+          SuspendedSection suspendedSection(driver);
+          ASSERT_TRUE(driver->state().suspended());
+          values->testingOperatorCtx()->task()->requestAbort();
+          {
+            ASSERT_TRUE(driver->state().suspended());
+            VELOX_ASSERT_THROW(suspendDriverFn(driver), "");
+          }
+          ASSERT_TRUE(driver->state().suspended());
+        }
+        ASSERT_FALSE(driver->state().suspended());
+      }));
+
+  createAndStartTaskToReadValues(1);
+  waitForAllTasksToBeDeleted();
+}
diff --git a/velox/exec/tests/DummyAggregateFunction.h b/velox/exec/tests/DummyAggregateFunction.h
index f42d9805f3403..e3f66f390030a 100644
--- a/velox/exec/tests/DummyAggregateFunction.h
+++ b/velox/exec/tests/DummyAggregateFunction.h
@@ -28,10 +28,6 @@ class DummyDicitonaryFunction : public exec::Aggregate {
     return 0;
   }
 
-  void initializeNewGroups(
-      char** /*groups*/,
-      folly::Range<const vector_size_t*> /*indices*/) override {}
-
   void addRawInput(
       char** /*groups*/,
       const SelectivityVector& /*rows*/,
@@ -65,6 +61,11 @@ class DummyDicitonaryFunction : public exec::Aggregate {
       char** /*groups*/,
       int32_t /*numGroups*/,
       VectorPtr* /*result*/) override {}
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** /*groups*/,
+      folly::Range<const vector_size_t*> /*indices*/) override {}
 };
 
 AggregateRegistrationResult registerDummyAggregateFunction(
diff --git a/velox/exec/tests/ExchangeClientTest.cpp b/velox/exec/tests/ExchangeClientTest.cpp
index d77c3c3ac1c03..8376b58ab38d8 100644
--- a/velox/exec/tests/ExchangeClientTest.cpp
+++ b/velox/exec/tests/ExchangeClientTest.cpp
@@ -13,13 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <folly/ScopeGuard.h>
 #include <gtest/gtest.h>
+#include <atomic>
+#include <thread>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/Exchange.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/Task.h"
 #include "velox/exec/tests/utils/LocalExchangeSource.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -30,14 +34,26 @@ namespace {
 class ExchangeClientTest : public testing::Test,
                            public velox::test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
+    test::testingStartLocalExchangeSource();
+    executor_ = std::make_unique<folly::CPUThreadPoolExecutor>(16);
     exec::ExchangeSource::factories().clear();
     exec::ExchangeSource::registerFactory(test::createLocalExchangeSource);
     if (!isRegisteredVectorSerde()) {
       velox::serializer::presto::PrestoVectorSerde::registerVectorSerde();
     }
+    bufferManager_ = OutputBufferManager::getInstance().lock();
+
+    common::testutil::TestValue::enable();
+  }
 
-    bufferManager_ = PartitionedOutputBufferManager::getInstance().lock();
+  void TearDown() override {
+    exec::test::waitForAllTasksToBeDeleted();
+    test::testingShutdownLocalExchangeSource();
   }
 
   std::unique_ptr<SerializedPage> toSerializedPage(const RowVectorPtr& vector) {
@@ -49,19 +65,28 @@ class ExchangeClientTest : public testing::Test,
     auto listener = bufferManager_->newListener();
     IOBufOutputStream stream(*pool(), listener.get(), data->size());
     data->flush(&stream);
-    return std::make_unique<SerializedPage>(stream.getIOBuf());
+    return std::make_unique<SerializedPage>(stream.getIOBuf(), nullptr, size);
   }
 
   std::shared_ptr<Task> makeTask(
       const std::string& taskId,
-      const core::PlanNodePtr& planNode,
-      int destination) {
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+      const std::optional<uint64_t> maxOutputBufferSizeInBytes = {}) {
+    std::unordered_map<std::string, std::string> config;
+    if (maxOutputBufferSizeInBytes.has_value()) {
+      config[core::QueryConfig::kMaxOutputBufferSize] =
+          std::to_string(maxOutputBufferSizeInBytes.value());
+    }
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(), core::QueryConfig{std::move(config)});
     queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(queryCtx->queryId()));
-    core::PlanFragment planFragment{planNode};
+        memory::memoryManager()->addRootPool(queryCtx->queryId()));
+    auto plan = test::PlanBuilder().values({}).planNode();
     return Task::create(
-        taskId, std::move(planFragment), destination, std::move(queryCtx));
+        taskId,
+        core::PlanFragment{plan},
+        0,
+        std::move(queryCtx),
+        Task::ExecutionMode::kParallel);
   }
 
   int32_t enqueue(
@@ -77,16 +102,60 @@ class ExchangeClientTest : public testing::Test,
     return pageSize;
   }
 
-  void fetchPages(ExchangeClient& client, int32_t numPages) {
+  std::vector<std::unique_ptr<SerializedPage>> fetchPages(
+      ExchangeClient& client,
+      int32_t numPages) {
+    std::vector<std::unique_ptr<SerializedPage>> allPages;
     for (auto i = 0; i < numPages; ++i) {
       bool atEnd;
       ContinueFuture future;
-      auto page = client.next(&atEnd, &future);
-      ASSERT_TRUE(page != nullptr);
+      auto pages = client.next(1, &atEnd, &future);
+      if (pages.empty()) {
+        auto& exec = folly::QueuedImmediateExecutor::instance();
+        std::move(future).via(&exec).wait();
+        pages = client.next(1, &atEnd, &future);
+      }
+      EXPECT_EQ(1, pages.size());
+      allPages.push_back(std::move(pages.at(0)));
     }
+    return allPages;
+  }
+
+  static void addSources(ExchangeQueue& queue, int32_t numSources) {
+    {
+      std::lock_guard<std::mutex> l(queue.mutex());
+      for (auto i = 0; i < numSources; ++i) {
+        queue.addSourceLocked();
+      }
+    }
+    queue.noMoreSources();
+  }
+
+  static void enqueue(
+      ExchangeQueue& queue,
+      std::unique_ptr<SerializedPage> page) {
+    std::vector<ContinuePromise> promises;
+    {
+      std::lock_guard<std::mutex> l(queue.mutex());
+      queue.enqueueLocked(std::move(page), promises);
+    }
+    for (auto& promise : promises) {
+      promise.setValue();
+    }
+  }
+
+  static std::unique_ptr<SerializedPage> makePage(uint64_t size) {
+    auto ioBuf = folly::IOBuf::create(size);
+    ioBuf->append(size);
+    return std::make_unique<SerializedPage>(std::move(ioBuf), nullptr, 1);
+  }
+
+  folly::Executor* executor() const {
+    return executor_.get();
   }
 
-  std::shared_ptr<PartitionedOutputBufferManager> bufferManager_;
+  std::unique_ptr<folly::CPUThreadPoolExecutor> executor_;
+  std::shared_ptr<OutputBufferManager> bufferManager_;
 };
 
 TEST_F(ExchangeClientTest, nonVeloxCreateExchangeSourceException) {
@@ -96,16 +165,20 @@ TEST_F(ExchangeClientTest, nonVeloxCreateExchangeSourceException) {
         throw std::runtime_error("Testing error");
       });
 
-  ExchangeClient client("t", 1, pool(), ExchangeClient::kDefaultMaxQueuedBytes);
+  auto client = std::make_shared<ExchangeClient>(
+      "t", 1, ExchangeClient::kDefaultMaxQueuedBytes, pool(), executor());
+
   VELOX_ASSERT_THROW(
-      client.addRemoteTaskId("task.1.2.3"),
+      client->addRemoteTaskId("task.1.2.3"),
       "Failed to create ExchangeSource: Testing error. Task ID: task.1.2.3.");
 
   // Test with a very long task ID. Make sure it is truncated.
   VELOX_ASSERT_THROW(
-      client.addRemoteTaskId(std::string(1024, 'x')),
+      client->addRemoteTaskId(std::string(1024, 'x')),
       "Failed to create ExchangeSource: Testing error. "
       "Task ID: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.");
+
+  client->close();
 }
 
 TEST_F(ExchangeClientTest, stats) {
@@ -115,19 +188,15 @@ TEST_F(ExchangeClientTest, stats) {
       makeRowVector({makeFlatVector<int32_t>({1, 2})}),
   };
 
-  auto plan = test::PlanBuilder()
-                  .values(data)
-                  .partitionedOutput({"c0"}, 100)
-                  .planNode();
   auto taskId = "local://t1";
-  auto task = makeTask(taskId, plan, 17);
+  auto task = makeTask(taskId);
 
   bufferManager_->initializeTask(
       task, core::PartitionedOutputNode::Kind::kPartitioned, 100, 16);
 
-  ExchangeClient client(
-      "t", 17, pool(), ExchangeClient::kDefaultMaxQueuedBytes);
-  client.addRemoteTaskId(taskId);
+  auto client = std::make_shared<ExchangeClient>(
+      "t", 17, ExchangeClient::kDefaultMaxQueuedBytes, pool(), executor());
+  client->addRemoteTaskId(taskId);
 
   // Enqueue 3 pages.
   std::vector<uint64_t> pageBytes;
@@ -138,15 +207,20 @@ TEST_F(ExchangeClientTest, stats) {
     pageBytes.push_back(pageSize);
   }
 
-  fetchPages(client, 3);
+  fetchPages(*client, 3);
 
-  auto stats = client.stats();
-  EXPECT_EQ(totalBytes, stats.at("peakBytes").sum);
-  EXPECT_EQ(data.size(), stats.at("numReceivedPages").sum);
-  EXPECT_EQ(totalBytes / data.size(), stats.at("averageReceivedPageBytes").sum);
+  auto stats = client->stats();
+  // Since we run exchange source response callback in an executor, then we
+  // might start to fetch from the client before all the source buffers are
+  // enqueued.
+  ASSERT_GE(totalBytes, stats.at("peakBytes").sum);
+  ASSERT_EQ(data.size(), stats.at("numReceivedPages").sum);
+  ASSERT_EQ(totalBytes / data.size(), stats.at("averageReceivedPageBytes").sum);
 
   task->requestCancel();
   bufferManager_->removeTask(taskId);
+
+  client->close();
 }
 
 // Test scenario where fetching data from all sources at once would exceed queue
@@ -160,17 +234,14 @@ TEST_F(ExchangeClientTest, flowControl) {
   auto page = toSerializedPage(data);
 
   // Set limit at 3.5 pages.
-  ExchangeClient client("flow.control", 17, pool(), page->size() * 3.5);
+  auto client = std::make_shared<ExchangeClient>(
+      "flow.control", 17, page->size() * 3.5, pool(), executor());
 
-  auto plan = test::PlanBuilder()
-                  .values({data})
-                  .partitionedOutput({"c0"}, 100)
-                  .planNode();
   // Make 10 tasks.
   std::vector<std::shared_ptr<Task>> tasks;
   for (auto i = 0; i < 10; ++i) {
     auto taskId = fmt::format("local://t{}", i);
-    auto task = makeTask(taskId, plan, 17);
+    auto task = makeTask(taskId);
 
     bufferManager_->initializeTask(
         task, core::PartitionedOutputNode::Kind::kPartitioned, 100, 16);
@@ -181,12 +252,12 @@ TEST_F(ExchangeClientTest, flowControl) {
     }
 
     tasks.push_back(task);
-    client.addRemoteTaskId(taskId);
+    client->addRemoteTaskId(taskId);
   }
 
-  fetchPages(client, 3 * tasks.size());
+  fetchPages(*client, 3 * tasks.size());
 
-  auto stats = client.stats();
+  const auto stats = client->stats();
   EXPECT_LE(stats.at("peakBytes").sum, page->size() * 4);
   EXPECT_EQ(30, stats.at("numReceivedPages").sum);
   EXPECT_EQ(page->size(), stats.at("averageReceivedPageBytes").sum);
@@ -195,6 +266,349 @@ TEST_F(ExchangeClientTest, flowControl) {
     task->requestCancel();
     bufferManager_->removeTask(task->taskId());
   }
+
+  client->close();
+}
+
+TEST_F(ExchangeClientTest, largeSinglePage) {
+  auto data = {
+      makeRowVector({makeFlatVector<int64_t>(10000, folly::identity)}),
+      makeRowVector({makeFlatVector<int64_t>(1, folly::identity)}),
+  };
+  auto client =
+      std::make_shared<ExchangeClient>("test", 1, 1000, pool(), executor());
+  auto task = makeTask("local://producer");
+  bufferManager_->initializeTask(
+      task, core::PartitionedOutputNode::Kind::kArbitrary, 1, 1);
+  for (auto& batch : data) {
+    enqueue(task->taskId(), 0, batch);
+  }
+  client->addRemoteTaskId(task->taskId());
+  auto pages = fetchPages(*client, 1);
+  ASSERT_EQ(pages.size(), 1);
+  ASSERT_GT(pages[0]->size(), 1000);
+  pages = fetchPages(*client, 1);
+  ASSERT_EQ(pages.size(), 1);
+  ASSERT_LT(pages[0]->size(), 1000);
+  task->requestCancel();
+  bufferManager_->removeTask(task->taskId());
+  client->close();
+}
+
+TEST_F(ExchangeClientTest, multiPageFetch) {
+  auto client =
+      std::make_shared<ExchangeClient>("test", 17, 1 << 20, pool(), executor());
+
+  {
+    bool atEnd;
+    ContinueFuture future = ContinueFuture::makeEmpty();
+    auto pages = client->next(1, &atEnd, &future);
+    ASSERT_EQ(0, pages.size());
+    ASSERT_FALSE(atEnd);
+    ASSERT_TRUE(future.valid());
+  }
+
+  const auto& queue = client->queue();
+  addSources(*queue, 1);
+
+  for (auto i = 0; i < 10; ++i) {
+    enqueue(*queue, makePage(1'000 + i));
+  }
+
+  // Fetch one page.
+  bool atEnd;
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto pages = client->next(1, &atEnd, &future);
+  ASSERT_EQ(1, pages.size());
+  ASSERT_FALSE(atEnd);
+  ASSERT_FALSE(future.valid());
+
+  // Fetch multiple pages. Each page is slightly larger than 1K bytes, hence,
+  // only 4 pages fit.
+  pages = client->next(5'000, &atEnd, &future);
+  ASSERT_EQ(4, pages.size());
+  ASSERT_FALSE(atEnd);
+  ASSERT_FALSE(future.valid());
+
+  // Fetch the rest of the pages.
+  pages = client->next(10'000, &atEnd, &future);
+  ASSERT_EQ(5, pages.size());
+  ASSERT_FALSE(atEnd);
+  ASSERT_FALSE(future.valid());
+
+  // Signal no-more-data.
+  enqueue(*queue, nullptr);
+
+  pages = client->next(10'000, &atEnd, &future);
+  ASSERT_EQ(0, pages.size());
+  ASSERT_TRUE(atEnd);
+  ASSERT_FALSE(future.valid());
+
+  client->close();
+}
+
+TEST_F(ExchangeClientTest, sourceTimeout) {
+  constexpr int32_t kNumSources = 3;
+  auto client =
+      std::make_shared<ExchangeClient>("test", 17, 1 << 20, pool(), executor());
+
+  bool atEnd;
+  ContinueFuture future;
+  auto pages = client->next(1, &atEnd, &future);
+  ASSERT_EQ(0, pages.size());
+  ASSERT_FALSE(atEnd);
+
+  for (auto i = 0; i < kNumSources; ++i) {
+    client->addRemoteTaskId(fmt::format("local://{}", i));
+  }
+  client->noMoreRemoteTasks();
+
+  // Fetch a page. No page is found. All sources are fetching.
+  pages = client->next(1, &atEnd, &future);
+  EXPECT_TRUE(pages.empty());
+
+  std::mutex mutex;
+  std::unordered_set<void*> sourcesWithTimeout;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::test::LocalExchangeSource::timeout",
+      std::function<void(void*)>(([&](void* source) {
+        std::lock_guard<std::mutex> l(mutex);
+        sourcesWithTimeout.insert(source);
+        LOG(INFO) << "inside lambda" << source
+                  << " n=" << sourcesWithTimeout.size();
+      })));
+
+#ifndef NDEBUG
+  // Wait until all sources have timed out at least once.
+  auto deadline = std::chrono::system_clock::now() +
+      3 * kNumSources *
+          std::chrono::seconds(ExchangeClient::kRequestDataSizesMaxWait);
+  while (std::chrono::system_clock::now() < deadline) {
+    {
+      std::lock_guard<std::mutex> l(mutex);
+      if (sourcesWithTimeout.size() >= kNumSources) {
+        break;
+      }
+    }
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+  }
+  EXPECT_LT(std::chrono::system_clock::now(), deadline);
+#endif
+
+  const auto& queue = client->queue();
+  for (auto i = 0; i < 10; ++i) {
+    enqueue(*queue, makePage(1'000 + i));
+  }
+
+  // Fetch one page.
+  pages = client->next(1, &atEnd, &future);
+  EXPECT_EQ(1, pages.size());
+  EXPECT_FALSE(atEnd);
+
+  // Fetch multiple pages. Each page is slightly larger than 1K bytes, hence,
+  // only 4 pages fit.
+  pages = client->next(5'000, &atEnd, &future);
+  EXPECT_EQ(4, pages.size());
+  EXPECT_FALSE(atEnd);
+
+  // Fetch the rest of the pages.
+  pages = client->next(10'000, &atEnd, &future);
+  EXPECT_EQ(5, pages.size());
+  EXPECT_FALSE(atEnd);
+
+  // Signal no-more-data for all sources.
+  for (auto i = 0; i < kNumSources; ++i) {
+    enqueue(*queue, nullptr);
+  }
+  pages = client->next(10'000, &atEnd, &future);
+  EXPECT_EQ(0, pages.size());
+  EXPECT_TRUE(atEnd);
+
+  client->close();
+}
+
+TEST_F(ExchangeClientTest, callNextAfterClose) {
+  constexpr int32_t kNumSources = 3;
+  common::testutil::TestValue::enable();
+  auto client =
+      std::make_shared<ExchangeClient>("test", 17, 1 << 20, pool(), executor());
+
+  bool atEnd;
+  ContinueFuture future;
+  auto pages = client->next(1, &atEnd, &future);
+  ASSERT_EQ(0, pages.size());
+  ASSERT_FALSE(atEnd);
+
+  for (auto i = 0; i < kNumSources; ++i) {
+    client->addRemoteTaskId(fmt::format("local://{}", i));
+  }
+  client->noMoreRemoteTasks();
+
+  // Fetch a page. No page is found. All sources are fetching.
+  pages = client->next(1, &atEnd, &future);
+  EXPECT_TRUE(pages.empty());
+
+  const auto& queue = client->queue();
+  for (auto i = 0; i < 10; ++i) {
+    enqueue(*queue, makePage(1'000 + i));
+  }
+
+  // Fetch multiple pages. Each page is slightly larger than 1K bytes, hence,
+  // only 4 pages fit.
+  pages = client->next(5'000, &atEnd, &future);
+  EXPECT_EQ(4, pages.size());
+  EXPECT_FALSE(atEnd);
+
+  // Close the client and try calling next again.
+  client->close();
+
+  // Here we should have no pages returned, be at end (we are closed) and the
+  // future should be invalid (not based on a valid promise).
+  ContinueFuture futureFinal{ContinueFuture::makeEmpty()};
+  pages = client->next(10'000, &atEnd, &futureFinal);
+  EXPECT_EQ(0, pages.size());
+  EXPECT_TRUE(atEnd);
+  EXPECT_FALSE(futureFinal.valid());
+
+  client->close();
+}
+
+TEST_F(ExchangeClientTest, acknowledge) {
+  const int64_t pageSize = 1024;
+  const int64_t clientBufferSize = pageSize;
+  const int64_t serverBufferSize = 2 * pageSize;
+
+  const auto sourceTaskId = "local://test-acknowledge-source-task";
+  const auto task = makeTask(sourceTaskId, serverBufferSize);
+  auto taskRemoveGuard =
+      folly::makeGuard([bufferManager = bufferManager_, task]() {
+        task->requestCancel();
+        bufferManager->removeTask(task->taskId());
+      });
+
+  bufferManager_->initializeTask(
+      task, core::PartitionedOutputNode::Kind::kPartitioned, 2, 1);
+
+  auto client = std::make_shared<ExchangeClient>(
+      "local://test-acknowledge-client-task",
+      1,
+      clientBufferSize,
+      pool(),
+      executor());
+  auto clientCloseGuard = folly::makeGuard([client]() { client->close(); });
+
+  std::atomic_int numberOfAcknowledgeRequests{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::test::LocalExchangeSource::pause",
+      std::function<void(void*)>(([&numberOfAcknowledgeRequests](void*) {
+        numberOfAcknowledgeRequests++;
+      })));
+
+  {
+    // adding the first page should not block as there is enough space in
+    // the output buffer for two pages
+    ContinueFuture future;
+    bufferManager_->enqueue(sourceTaskId, 1, makePage(pageSize), &future);
+    ASSERT_TRUE(future.isReady());
+  }
+
+  {
+    // adding the second page may block but will get unblocked once the
+    // client fetches a single page
+    ContinueFuture future;
+    bufferManager_->enqueue(sourceTaskId, 1, makePage(pageSize), &future);
+
+    // start fetching
+    client->addRemoteTaskId(sourceTaskId);
+    client->noMoreRemoteTasks();
+
+    ASSERT_TRUE(std::move(future)
+                    .via(executor())
+                    .wait(std::chrono::seconds{10})
+                    .isReady());
+
+#ifndef NDEBUG
+    // The client knew there is more data available but could not fetch any more
+    // Explicit acknowledge was required
+    EXPECT_EQ(numberOfAcknowledgeRequests, 1);
+#endif
+  }
+
+  {
+    // adding the third page should block (one page is in the exchange queue,
+    // another two pages are in the output buffer)
+    ContinueFuture enqueueDetachedFuture;
+    bufferManager_->enqueue(
+        sourceTaskId, 1, makePage(pageSize), &enqueueDetachedFuture);
+    ASSERT_FALSE(enqueueDetachedFuture.isReady());
+
+    auto enqueueFuture = std::move(enqueueDetachedFuture)
+                             .via(executor())
+                             .wait(std::chrono::milliseconds{100});
+    ASSERT_FALSE(enqueueFuture.isReady());
+
+    // removing one page from the exchange queue should trigger a fetch and
+    // a subsequent acknowledge to release the output buffer memory
+    bool atEnd;
+    ContinueFuture dequeueDetachedFuture;
+    auto pages = client->next(1, &atEnd, &dequeueDetachedFuture);
+    ASSERT_EQ(1, pages.size());
+    ASSERT_FALSE(atEnd);
+    ASSERT_TRUE(dequeueDetachedFuture.isReady());
+
+    ASSERT_TRUE(
+        std::move(enqueueFuture).wait(std::chrono::seconds{10}).isReady());
+#ifndef NDEBUG
+    // The client knew there is more data available but could not fetch any more
+    // Explicit acknowledge was required
+    EXPECT_EQ(numberOfAcknowledgeRequests, 2);
+#endif
+  }
+
+  // one page is still in the buffer at this point
+  ASSERT_EQ(bufferManager_->getUtilization(sourceTaskId), 0.5);
+
+  auto pages = fetchPages(*client, 1);
+  ASSERT_EQ(1, pages.size());
+
+  {
+    // at this point the output buffer is expected to be empty
+    int attempts = 100;
+    bool outputBuffersEmpty;
+    while (attempts > 0) {
+      attempts--;
+      outputBuffersEmpty = bufferManager_->getUtilization(sourceTaskId) == 0;
+      if (outputBuffersEmpty) {
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds{100});
+    }
+    ASSERT_TRUE(outputBuffersEmpty);
+#ifndef NDEBUG
+    // The output buffer is empty now
+    // Explicit acknowledge is not necessary as a blocking getDataSize is sent
+    // right away
+    EXPECT_EQ(numberOfAcknowledgeRequests, 2);
+#endif
+  }
+
+  pages = fetchPages(*client, 1);
+  ASSERT_EQ(1, pages.size());
+
+  bufferManager_->noMoreData(sourceTaskId);
+
+  bool atEnd;
+  ContinueFuture dequeueEndOfDataFuture;
+  pages = client->next(1, &atEnd, &dequeueEndOfDataFuture);
+  ASSERT_EQ(0, pages.size());
+
+  ASSERT_TRUE(std::move(dequeueEndOfDataFuture)
+                  .via(executor())
+                  .wait(std::chrono::seconds{10})
+                  .isReady());
+  pages = client->next(1, &atEnd, &dequeueEndOfDataFuture);
+  ASSERT_EQ(0, pages.size());
+  ASSERT_TRUE(atEnd);
 }
 
 } // namespace
diff --git a/velox/exec/tests/ExchangeFuzzer.cpp b/velox/exec/tests/ExchangeFuzzer.cpp
new file mode 100644
index 0000000000000..d449b5972324c
--- /dev/null
+++ b/velox/exec/tests/ExchangeFuzzer.cpp
@@ -0,0 +1,556 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include <folly/init/Init.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/common/memory/MmapAllocator.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/exec/Exchange.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/LocalExchangeSource.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/VectorSaver.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+#include <fstream>
+
+DEFINE_int32(max_tasks_per_stage, 16, "Max number of sources/destinations");
+DEFINE_int32(drivers_per_task, 4, "Number of threads in each task in shuffle");
+DEFINE_int64(shuffle_bytes, 4UL << 30, "Shuffle data volume in each step");
+DEFINE_int32(max_buffer_mb, 20, "Max buffer size for output/exchange per task");
+DEFINE_uint64(seed, 0, "Seed, 0 means random");
+
+DEFINE_int32(steps, 10, "Number of plans to generate and test.");
+
+DEFINE_int32(duration_sec, 0, "Run duration in seconds");
+
+DEFINE_bool(inject_failure, false, "Inject a failure for testing repro");
+
+DEFINE_string(
+    repro_path,
+    ".",
+    "Path for writing repro files in case of failure");
+
+DEFINE_string(
+    replay,
+    "",
+    "File to replay. Files are produced on failure in --repro_path");
+
+DEFINE_bool(
+    enable_oom_injection,
+    false,
+    "When enabled OOMs will randomly be triggered while executing query "
+    "plans. The goal of this mode is to ensure unexpected exceptions "
+    "aren't thrown and the process isn't killed in the process of cleaning "
+    "up after failures. Therefore, results are not compared when this is "
+    "enabled. Note that this option only works in debug builds.");
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::test;
+
+/// Generates random data and runs this through repartition and
+/// exchange. Varies numbers of sources and destinations, batch and
+/// buffer sizes. Checks that dataset checksum is preserved over remote
+/// shuffle. Supports saving and replaying generated test cases.
+class ExchangeFuzzer : public VectorTestBase {
+ public:
+  static constexpr int64_t kMaxMemory = 6UL << 30; // 6GB
+
+  /// Parameters for one test case.
+  struct Params {
+    int32_t numSourceTasks;
+    int32_t numDestinationTasks;
+    int32_t numDriversPerTask;
+    int32_t outputBufferBytes;
+    int32_t exchangeBufferBytes;
+
+    /// target size of batch to produce in receiving exchange.
+    int32_t batchBytes;
+  };
+
+  ExchangeFuzzer() : fuzzer_(options_, pool_.get()) {}
+
+  /// Runs one test case, checks result and saves repro on failure.
+  bool runOne(const std::vector<RowVectorPtr>& vectors, Params params) {
+    VELOX_CHECK(!vectors.empty());
+    auto iteration = ++iteration_;
+    LOG(INFO) << "Iteration " << iteration << " shuffle "
+              << params.numSourceTasks << "x" << params.numDestinationTasks
+              << " drivers=" << params.numDriversPerTask << " Type "
+              << vectors.front()->type()->toString()
+              << " output buffer=" << params.outputBufferBytes
+              << " exchange buffer=" << params.exchangeBufferBytes
+              << " target batch=" << params.batchBytes;
+    configSettings_[core::QueryConfig::kMaxPartitionedOutputBufferSize] =
+        fmt::format("{}", params.outputBufferBytes);
+    configSettings_[core::QueryConfig::kMaxExchangeBufferSize] =
+        fmt::format("{}", params.exchangeBufferBytes);
+    configSettings_[core::QueryConfig::kPreferredOutputBatchBytes] =
+        fmt::format("{}", params.batchBytes);
+
+    const auto& rowType = vectors.front()->type()->as<TypeKind::ROW>();
+    std::vector<std::string> aggregates;
+    std::vector<std::vector<TypePtr>> rawInputTypes;
+
+    // make a checksum aggregate for all but the partitioning key.
+    for (auto i = 1; i < rowType.size(); ++i) {
+      rawInputTypes.push_back({rowType.childAt(i)});
+    }
+    auto expected = expectedChecksums(
+        vectors,
+        rawInputTypes,
+        params.numSourceTasks * params.numDriversPerTask);
+
+    std::vector<std::shared_ptr<Task>> tasks;
+
+    std::vector<std::string> leafTaskIds;
+    auto leafPlan = exec::test::PlanBuilder()
+                        .values(vectors, true)
+                        .partitionedOutput({"c0"}, params.numDestinationTasks)
+                        .planNode();
+
+    for (int32_t counter = 0; counter < params.numSourceTasks; ++counter) {
+      auto leafTaskId = makeTaskId(iteration, "leaf", counter);
+      leafTaskIds.push_back(leafTaskId);
+      auto leafTask = makeTask(leafTaskId, leafPlan, counter);
+      tasks.push_back(leafTask);
+      leafTask->start(params.numDriversPerTask);
+    }
+    auto partialAggPlan =
+        exec::test::PlanBuilder()
+            .exchange(leafPlan->outputType())
+            .partialAggregation({}, makeAggregates(rowType, 1))
+            .partitionedOutput({}, 1)
+            .planNode();
+
+    std::vector<std::string> partialAggTaskIds;
+    for (int i = 0; i < params.numDestinationTasks; i++) {
+      auto taskId = makeTaskId(iteration, "partial-agg", i);
+      partialAggTaskIds.push_back(taskId);
+      auto task = makeTask(taskId, partialAggPlan, i);
+      tasks.push_back(task);
+      task->start(params.numDriversPerTask);
+      addRemoteSplits(task, leafTaskIds);
+    }
+
+    auto plan = exec::test::PlanBuilder()
+                    .exchange(partialAggPlan->outputType())
+                    .finalAggregation(
+                        {},
+                        makeAggregates(*partialAggPlan->outputType(), 0),
+                        rawInputTypes)
+                    .planNode();
+
+    try {
+      // Create the Task to do the final aggregation using a TaskCursor so we
+      // can inspect the results.
+      CursorParameters cursorParams;
+      cursorParams.planNode = plan;
+
+      auto cursor = TaskCursor::create(cursorParams);
+      cursor->start();
+
+      auto task = cursor->task();
+      tasks.push_back(task);
+      addRemoteSplits(task, partialAggTaskIds);
+
+      // Setup listeners for each Task that will abandon the other Tasks if the
+      // given Task fails.  This acts sort of like the Presto coordinator
+      // cleaning up the query if any portition of it fails.
+      for (const auto& otherTask : tasks) {
+        auto* taskPtr = otherTask.get();
+        otherTask->taskCompletionFuture()
+            .via(executor_.get())
+            .thenValue([&tasks, taskPtr](auto) {
+              VELOX_CHECK(!taskPtr->isRunning());
+
+              if (taskPtr->state() == TaskState::kFailed) {
+                for (const auto& taskToAbort : tasks) {
+                  taskToAbort->requestAbort();
+                }
+              }
+            });
+      }
+
+      ScopedOOMInjector oomInjector(
+          []() -> bool { return folly::Random::oneIn(10); },
+          10); // Check the condition every 10 ms.
+      if (FLAGS_enable_oom_injection) {
+        oomInjector.enable();
+      }
+
+      std::vector<RowVectorPtr> result;
+
+      while (cursor->moveNext()) {
+        result.push_back(cursor->current());
+      }
+
+      assertEqualResults({expected}, result);
+
+      if (FLAGS_inject_failure) {
+        VELOX_FAIL("Testing error");
+      }
+    } catch (const std::exception& e) {
+      if (FLAGS_enable_oom_injection) {
+        // If we enabled OOM injection go through the tasks to see if any threw
+        // an exception other than the one we expect the ScopedOOMInjector to
+        // have thrown.  We log the first instance of an unexpected exception we
+        // find (this should be towards the top of the tree of Tasks).
+
+        if (const auto* veloxException =
+                dynamic_cast<const VeloxRuntimeError*>(&e)) {
+          const bool isInjectedOomException = veloxException->errorCode() ==
+                  facebook::velox::error_code::kMemCapExceeded &&
+              veloxException->message() == ScopedOOMInjector::kErrorMessage;
+          const bool isTaskAbortedException = veloxException->errorCode() ==
+                  facebook::velox::error_code::kInvalidState &&
+              veloxException->message() == "Aborted for external error";
+          // It's expected that execution of the final Task will either fail
+          // with the exception thrown by the ScopedOomInjector or the exception
+          // thrown when a Task is abandoned because an upstream Task failed
+          // with the exception thrown by the ScopedOomInjector.
+          // If the Task was abandoned because an upstream Task failed for a
+          // different reason, that will be handled in the for loop below.
+          if (!isInjectedOomException && !isTaskAbortedException) {
+            LOG(ERROR) << "Terminating with error: " << e.what();
+
+            saveRepro(vectors, params);
+            return false;
+          }
+        }
+
+        for (const auto& task : tasks) {
+          if (!waitForTaskCompletion(task.get(), 1'000'000)) {
+            if (task->state() == TaskState::kFailed) {
+              try {
+                std::rethrow_exception(task->error());
+              } catch (const std::exception& taskException) {
+                if (const auto* veloxException =
+                        dynamic_cast<const VeloxRuntimeError*>(
+                            &taskException)) {
+                  if (veloxException->errorCode() ==
+                          facebook::velox::error_code::kMemCapExceeded &&
+                      veloxException->message() ==
+                          ScopedOOMInjector::kErrorMessage) {
+                    // This is the expected exception from the
+                    // ScopedOOMInjector.
+                    continue;
+                  }
+                }
+
+                // This must be an unexpected exception.
+                LOG(ERROR) << "Task " << task->toString()
+                           << " failed with error " << taskException.what();
+                saveRepro(vectors, params);
+                return false;
+              }
+            }
+          } else {
+            VELOX_FAIL(
+                "Timed out waiting for task to complete, task: {}",
+                task->toString());
+          }
+        }
+
+        // All exceptions were expected.
+        return true;
+      }
+
+      LOG(ERROR) << "Terminating with error: " << e.what();
+
+      saveRepro(vectors, params);
+      return false;
+    }
+    return true;
+  }
+
+  /// Runs multiple test cases up to first failure. Duration is either in
+  /// --duratin_sec or --steps.
+  void run() {
+    auto start = getCurrentTimeMicro();
+    for (auto counter = 0;; ++counter) {
+      auto type = fuzzer_.randRowType();
+      // Add a bigint c0 partition key column in front
+      auto types = type->children();
+      auto names = type->names();
+      std::vector<TypePtr> allTypes = {BIGINT()};
+      std::vector<std::string> allNames = {"c0"};
+      allTypes.insert(allTypes.end(), types.begin(), types.end());
+      allNames.insert(allNames.end(), names.begin(), names.end());
+      auto rowType = ROW(std::move(allNames), std::move(allTypes));
+      Params params;
+      params.numDriversPerTask = FLAGS_drivers_per_task;
+      params.outputBufferBytes = randInt(4, std::max(5, FLAGS_max_buffer_mb))
+          << 20;
+      params.exchangeBufferBytes = randInt(4, std::max(5, FLAGS_max_buffer_mb))
+          << 20;
+      params.batchBytes = randInt(100000, 10000000);
+      params.numSourceTasks = randInt(1, FLAGS_max_tasks_per_stage);
+      params.numDestinationTasks = randInt(2, FLAGS_max_tasks_per_stage);
+
+      options_.vectorSize = 100;
+      options_.nullRatio = 0;
+      options_.containerHasNulls = fuzzer_.coinToss(0.2);
+      options_.dictionaryHasNulls = false;
+      // TODO: fuzzer_.coinToss(0.2); This does not work because
+      // toElementRows with null adding dicts ignores nulls added by
+      // dicts..
+      options_.stringLength = randInt(1, 100);
+      options_.stringVariableLength = true;
+      options_.containerLength = randInt(1, 50);
+      options_.containerVariableLength = true;
+      options_.complexElementsMaxSize = 20000;
+      options_.maxConstantContainerSize = 2;
+      options_.normalizeMapKeys = fuzzer_.coinToss(0.95);
+      options_.timestampPrecision =
+          static_cast<VectorFuzzer::Options::TimestampPrecision>(randInt(0, 3));
+      options_.allowLazyVector = false;
+
+      fuzzer_.setOptions(options_);
+
+      // We make a first vector of 100 elements to see the bytes per
+      // row. We then make as many vectors as it takes to reach a
+      // shuffle volume of --shuffle_bytes. Each row is produced once
+      // by each Driver in each task of the source
+      // stage. 'shuffledBytesPerRow' is the row size times source
+      // stage task count times drivers per task.
+      auto row = fuzzer_.fuzzInputRow(rowType);
+      size_t shuffleBytes = row->estimateFlatSize();
+      size_t shufledBytesPerRow = 20 +
+          (shuffleBytes / row->size() * params.numSourceTasks *
+           FLAGS_drivers_per_task);
+      std::vector<RowVectorPtr> vectors;
+
+      vectors.push_back(row);
+      auto maxBatch = std::min<int32_t>(
+          10000,
+          std::max<int64_t>(10, FLAGS_shuffle_bytes / shufledBytesPerRow));
+
+      while (shuffleBytes < FLAGS_shuffle_bytes) {
+        if (fuzzer_.coinToss(0.2)) {
+          options_.nullRatio = 0;
+        } else {
+          // Sometimes 1.0, so all null.
+          options_.nullRatio = randInt(1, 10) / 10.0;
+        }
+        options_.vectorSize = randInt(1, maxBatch);
+        fuzzer_.setOptions(options_);
+
+        auto newRow = fuzzer_.fuzzInputRow(rowType);
+        vectors.push_back(newRow);
+        auto newSize = newRow->estimateFlatSize() * params.numSourceTasks *
+            FLAGS_drivers_per_task;
+        shuffleBytes += newSize;
+      }
+
+      if (!runOne(vectors, params)) {
+        LOG(INFO) << "Terminating with error";
+        exit(1);
+      }
+      LOG(INFO) << "Memory after run="
+                << succinctBytes(memory::AllocationTraits::pageBytes(
+                       memory::memoryManager()->allocator()->numAllocated()));
+
+      if (FLAGS_duration_sec == 0 && FLAGS_steps &&
+          counter + 1 >= FLAGS_steps) {
+        break;
+      }
+      if (FLAGS_duration_sec &&
+          (getCurrentTimeMicro() - start) / 1000000 > FLAGS_duration_sec) {
+        break;
+      }
+      size_t newSeed = randInt(0, 2000000000);
+      LOG(INFO) << "Seed = " << newSeed;
+      seed(newSeed);
+    }
+    LOG(INFO) << "Finishing after " << iteration_ << " cases, "
+              << (getCurrentTimeMicro() - start) / 1000000 << "s";
+  }
+
+  bool replay() {
+    std::ifstream in(FLAGS_replay);
+    Params params;
+    in >> params.numSourceTasks;
+    in >> params.numDestinationTasks;
+    in >> params.numDriversPerTask;
+    in >> params.outputBufferBytes;
+    in >> params.exchangeBufferBytes;
+    in >> params.batchBytes;
+    int32_t numVectors;
+    in >> numVectors;
+
+    char newLine;
+    do {
+      in.read(&newLine, 1);
+    } while (newLine != 10);
+
+    std::vector<RowVectorPtr> vectors;
+    for (auto i = 0; i < numVectors; ++i) {
+      auto vector = restoreVector(in, pool_.get());
+      vectors.push_back(std::dynamic_pointer_cast<RowVector>(vector));
+    }
+    return runOne(vectors, params);
+  }
+
+  /// Sets an initial seed for run().
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    fuzzer_.reSeed(seed);
+    rng_.seed(currentSeed_);
+  }
+
+ private:
+  void saveRepro(const std::vector<RowVectorPtr>& vectors, Params params) {
+    if (!FLAGS_replay.empty()) {
+      LOG(INFO) << "No replay saved since --replay is specified";
+      return;
+    }
+
+    auto filePath =
+        fmt::format("{}/exchange_fuzzer_repro.{}", FLAGS_repro_path, getpid());
+    std::ofstream out(filePath, std::ofstream::binary);
+    out << params.numSourceTasks << " " << params.numDestinationTasks << " "
+        << params.numDriversPerTask << " " << params.outputBufferBytes << " "
+        << params.exchangeBufferBytes << " " << params.batchBytes << " "
+        << vectors.size() << std::endl;
+    for (const auto& vector : vectors) {
+      saveVector(*vector, out);
+    }
+    LOG(ERROR)
+        << "Saved repro. To replay, do velox_exchange_fuzzer_test --replay "
+        << filePath;
+  }
+
+  int64_t randInt(int64_t min, int64_t max) {
+    return boost::random::uniform_int_distribution<int64_t>(min, max)(rng_);
+  }
+
+  // Returns a row of checksums for all non-first columns.
+  RowVectorPtr expectedChecksums(
+      std::vector<RowVectorPtr> vectors,
+      const std::vector<std::vector<TypePtr>>& rawInputTypes,
+      int32_t width) {
+    const auto& rowType = vectors.front()->type()->as<TypeKind::ROW>();
+    auto plan = exec::test::PlanBuilder()
+                    .values(vectors, true)
+                    .partialAggregation({}, makeAggregates(rowType, 1))
+                    .localPartition({})
+                    .finalAggregation()
+                    .planNode();
+    return exec::test::AssertQueryBuilder(plan).maxDrivers(width).copyResults(
+        pool_.get());
+  }
+
+  std::vector<std::string> makeAggregates(const RowType& row, int firstColumn) {
+    std::vector<std::string> aggregates;
+    for (auto i = firstColumn; i < row.size(); ++i) {
+      aggregates.push_back(fmt::format("checksum({})", row.nameOf(i)));
+    }
+    return aggregates;
+  }
+
+  static std::string
+  makeTaskId(int32_t iteration, const std::string& prefix, int num) {
+    return fmt::format("local://{}-{}-{}", iteration, prefix, num);
+  }
+
+  std::shared_ptr<Task> makeTask(
+      const std::string& taskId,
+      std::shared_ptr<const core::PlanNode> planNode,
+      int destination,
+      Consumer consumer = nullptr,
+      int64_t maxMemory = kMaxMemory) {
+    auto configCopy = configSettings_;
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(), core::QueryConfig(std::move(configCopy)));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(queryCtx->queryId(), maxMemory));
+    core::PlanFragment planFragment{planNode};
+    return Task::create(
+        taskId,
+        std::move(planFragment),
+        destination,
+        std::move(queryCtx),
+        Task::ExecutionMode::kParallel,
+        std::move(consumer));
+  }
+
+  void addRemoteSplits(
+      std::shared_ptr<Task> task,
+      const std::vector<std::string>& remoteTaskIds) {
+    for (const auto& taskId : remoteTaskIds) {
+      auto split =
+          exec::Split(std::make_shared<RemoteConnectorSplit>(taskId), -1);
+      task->addSplit("0", std::move(split));
+    }
+    task->noMoreSplits("0");
+  }
+
+  struct VectorFuzzer::Options options_;
+  VectorFuzzer fuzzer_;
+  FuzzerGenerator rng_;
+  size_t currentSeed_{0};
+
+  std::unordered_map<std::string, std::string> configSettings_;
+  // Serial number to differentiate consecutive benchmark repeats.
+  static int32_t iteration_;
+};
+
+int32_t ExchangeFuzzer::iteration_;
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  folly::Init init{&argc, &argv};
+  memory::MemoryManagerOptions options;
+  options.useMmapAllocator = true;
+  options.allocatorCapacity = 15UL << 30;
+  options.useMmapArena = true;
+  options.mmapArenaCapacityRatio = 1;
+  memory::MemoryManager::initialize(options);
+
+  functions::prestosql::registerAllScalarFunctions();
+  aggregate::prestosql::registerAllAggregateFunctions();
+  parse::registerTypeResolver();
+  serializer::presto::PrestoVectorSerde::registerVectorSerde();
+  exec::ExchangeSource::registerFactory(exec::test::createLocalExchangeSource);
+
+  ExchangeFuzzer fuzzer;
+
+  if (!FLAGS_replay.empty()) {
+    return fuzzer.replay() ? 0 : 1;
+  }
+  if (FLAGS_seed != 0) {
+    LOG(INFO) << "Starting  from user supplied seed " << FLAGS_seed;
+    fuzzer.seed(FLAGS_seed);
+  } else {
+    size_t seed = getCurrentTimeMicro();
+    LOG(INFO) << "Generating initial seed " << seed;
+    fuzzer.seed(seed);
+  }
+  fuzzer.run();
+  exec::test::testingShutdownLocalExchangeSource();
+  return 0;
+}
diff --git a/velox/exec/tests/ExpandTest.cpp b/velox/exec/tests/ExpandTest.cpp
new file mode 100644
index 0000000000000..f541d20c04a5b
--- /dev/null
+++ b/velox/exec/tests/ExpandTest.cpp
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::exec {
+
+namespace {
+class ExpandTest : public OperatorTestBase {
+ public:
+  RowVectorPtr makeRowVectorData(vector_size_t size) {
+    return makeRowVector(
+        {"k1", "k2", "a", "b"},
+        {
+            makeFlatVector<int64_t>(size, [](auto row) { return row % 11; }),
+            makeFlatVector<int64_t>(size, [](auto row) { return row % 17; }),
+            makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+            makeFlatVector<std::string>(
+                size, [](auto row) { return std::string(row % 15, 'x'); }),
+        });
+  }
+};
+} // anonymous namespace
+
+TEST_F(ExpandTest, groupingSets) {
+  auto data = makeRowVectorData(1'000);
+
+  createDuckDbTable({data});
+
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .expand(
+              {{"k1",
+                "null::bigint as k2",
+                "a",
+                "b",
+                "0 as group_id_0",
+                "0 as group_id_1"},
+               {"k1", "null", "a", "b", "0", "1"},
+               {"null", "k2", "a", "b", "1", "2"}})
+          .singleAggregation(
+              {"k1", "k2", "group_id_0", "group_id_1"},
+              {"count(1) as count_1", "sum(a) as sum_a", "max(b) as max_b"})
+          .project({"k1", "k2", "count_1", "sum_a", "max_b"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, count(1), sum(a), max(b) FROM tmp GROUP BY GROUPING SETS ((k1), (k1), (k2))");
+}
+
+TEST_F(ExpandTest, cube) {
+  auto data = makeRowVectorData(1'000);
+
+  createDuckDbTable({data});
+
+  // Cube.
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .expand({
+              {"k1", "k2", "a", "b", "0 as gid"},
+              {"k1", "null", "a", "b", "1"},
+              {"null", "k2", "a", "b", "2"},
+              {"null", "null", "a", "b", "3"},
+          })
+          .singleAggregation(
+              {"k1", "k2", "gid"},
+              {"count(1) as count_1", "sum(a) as sum_a", "max(b) as max_b"})
+          .project({"k1", "k2", "count_1", "sum_a", "max_b"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, count(1), sum(a), max(b) FROM tmp GROUP BY CUBE (k1, k2)");
+}
+
+TEST_F(ExpandTest, rollup) {
+  auto data = makeRowVectorData(1'000);
+
+  createDuckDbTable({data});
+
+  // Rollup.
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .expand(
+              {{"k1 as foo", "k2", "a", "b", "0 as gid"},
+               {"k1", "null", "a", "b", "1"},
+               {"null", "null", "a", "b", "2"}})
+          .singleAggregation(
+              {"foo", "k2", "gid"},
+              {"count(1) as count_1", "sum(a) as sum_a", "max(b) as max_b"})
+          .project({"foo", "k2", "count_1", "sum_a", "max_b"})
+          .planNode();
+
+  assertQuery(
+      plan,
+      "SELECT k1, k2, count(1), sum(a), max(b) FROM tmp GROUP BY ROLLUP (k1, k2)");
+}
+
+TEST_F(ExpandTest, countDistinct) {
+  auto data = makeRowVectorData(1'000);
+
+  createDuckDbTable({data});
+
+  // count distinct.
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .expand({{"a", "null::varchar as b", "1 as gid"}, {"null", "b", "2"}})
+          .singleAggregation({"a", "b", "gid"}, {})
+          .singleAggregation({}, {"count(a) as count_a", "count(b) as count_b"})
+          .planNode();
+
+  assertQuery(plan, "SELECT count(distinct a), count(distinct b) FROM tmp");
+}
+
+TEST_F(ExpandTest, invalidUseCases) {
+  auto data = makeRowVector(
+      ROW({"k1", "k2", "a", "b"}, {BIGINT(), BIGINT(), BIGINT(), VARCHAR()}),
+      10);
+
+  VELOX_ASSERT_USER_THROW(
+      PlanBuilder().values({data}).expand(
+          {{"k1", "k1", "a", "b", "0 as gid"},
+           {"k1", "null", "a", "b", "1"},
+           {"null", "null", "a", "b", "2"}}),
+      "Found duplicate column name in Expand plan node: k1.");
+
+  VELOX_ASSERT_RUNTIME_THROW(
+      PlanBuilder().values({data}).expand({}),
+      "projections must not be empty.");
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/FilterProjectTest.cpp b/velox/exec/tests/FilterProjectTest.cpp
index d3ae14bce673b..57e8d8280be1e 100644
--- a/velox/exec/tests/FilterProjectTest.cpp
+++ b/velox/exec/tests/FilterProjectTest.cpp
@@ -325,84 +325,21 @@ TEST_F(FilterProjectTest, projectAndIdentityOverLazy) {
   assertQuery(plan, "SELECT c0 < 10 AND c1 < 10, c1 FROM tmp");
 }
 
-// Verify that nulls on nested parent are propagated to child without copying
-// the child.  Note that null on top level columns are handled separately in
-// Expr::evalWithNulls; this happens only once per expression tree so we are not
-// optimizing that code.  We are testing the optimization of potentially more
-// expensive case of FieldReference::evalSpecialForm here.
-TEST_F(FilterProjectTest, nestedFieldReference) {
-  auto vector = makeRowVector({
-      makeRowVector({
-          makeRowVector(
-              {
-                  makeRowVector({
-                      makeFlatVector<int32_t>(10, folly::identity),
-                  }),
-              },
-              [](auto i) { return i % 2 == 0; }),
-      }),
-  });
-  // Project c0.c0.c0.c0.  Duck DB fails to parse such an expression.
-  std::shared_ptr<const core::IExpr> expr = std::make_shared<core::InputExpr>();
-  for (int i = 0; i < 4; ++i) {
-    std::vector<std::shared_ptr<const core::IExpr>> inputs;
-    inputs.push_back(expr);
-    expr = std::make_shared<core::FieldAccessExpr>(
-        "c0", std::nullopt, std::move(inputs));
-  }
-  CursorParameters params;
-  params.planNode =
-      PlanBuilder().values({vector}).projectExpressions({expr}).planNode();
-  params.copyResult = false;
-  TaskCursor cursor(params);
-  ASSERT_TRUE(cursor.moveNext());
-  auto result = cursor.current();
-  auto* actual = result->as<RowVector>()->childAt(0).get();
-  const BaseVector* expected = vector.get();
-  for (int i = 0; i < 4; ++i) {
-    expected = expected->as<RowVector>()->childAt(0).get();
-  }
-  ASSERT_EQ(*actual->type(), *expected->type());
-  ASSERT_EQ(actual, expected);
-  for (int i = 0; i < actual->size(); ++i) {
-    ASSERT_EQ(actual->isNullAt(i), i % 2 == 0);
-  }
-}
-
 // Verify the optimization of avoiding copy in null propagation does not break
 // the case when the field is shared between multiple parents.
 TEST_F(FilterProjectTest, nestedFieldReferenceSharedChild) {
   auto shared = makeFlatVector<int64_t>(10, folly::identity);
   auto vector = makeRowVector({
       makeRowVector({
-          makeRowVector({shared}, [](auto i) { return i % 2 == 0; }),
-          makeRowVector({shared}, [](auto i) { return i % 3 == 0; }),
+          makeRowVector({shared}, nullEvery(2)),
+          makeRowVector({shared}, nullEvery(3)),
       }),
   });
-  // coalesce(c0.c0.c0, 0) + coalesce(c0.c1.c0, 0).  Duck DB fails to infer the
-  // correct type.
-  std::shared_ptr<const core::IExpr> expr;
-  std::vector<std::shared_ptr<const core::IExpr>> plusInputs;
-  for (int j = 0; j < 2; ++j) {
-    expr = std::make_shared<core::InputExpr>();
-    std::vector<std::shared_ptr<const core::IExpr>> inputs;
-    for (int i = 0; i < 3; ++i) {
-      inputs.push_back(expr);
-      expr = std::make_shared<core::FieldAccessExpr>(
-          i == 1 && j == 1 ? "c1" : "c0", std::nullopt, std::move(inputs));
-    }
-    inputs.push_back(expr);
-    expr = std::make_shared<core::ConstantExpr>(
-        BIGINT(), variant(0ll), std::nullopt);
-    inputs.push_back(expr);
-    expr = std::make_shared<core::CallExpr>(
-        "coalesce", std::move(inputs), std::nullopt);
-    plusInputs.push_back(expr);
-  }
-  expr = std::make_shared<core::CallExpr>(
-      "plus", std::move(plusInputs), std::nullopt);
   auto plan =
-      PlanBuilder().values({vector}).projectExpressions({expr}).planNode();
+      PlanBuilder()
+          .values({vector})
+          .project({"coalesce((c0).c0.c0, 0) + coalesce((c0).c1.c0, 0)"})
+          .planNode();
   auto expected = makeFlatVector<int64_t>(10);
   for (int i = 0; i < 10; ++i) {
     expected->set(i, (i % 2 == 0 ? 0 : i) + (i % 3 == 0 ? 0 : i));
diff --git a/velox/exec/tests/FunctionResolutionTest.cpp b/velox/exec/tests/FunctionResolutionTest.cpp
index 79e0b82c9147f..c580739939990 100644
--- a/velox/exec/tests/FunctionResolutionTest.cpp
+++ b/velox/exec/tests/FunctionResolutionTest.cpp
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+#include <optional>
+
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/SimpleFunctionRegistry.h"
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
@@ -316,5 +319,119 @@ TEST_F(FunctionResolutionTest, resolveCustomTypeTimestampWithTimeZone) {
       exec::simpleFunctions().resolveFunction("f_timestampzone", {})->type();
   EXPECT_EQ(type->toString(), TIMESTAMP_WITH_TIME_ZONE()->toString());
 }
+
+// A function that takes TInput and returns int, TInput determined at
+// registration.
+template <typename T>
+struct SingleInputFunc {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  template <typename TInput>
+  void call(int64_t& out, const TInput&) {
+    out = 1;
+  }
+};
+
+// A function that takes two inputs of types TInput1, TInput2 and return int,
+// input types determined at registration.
+template <typename T>
+struct TwoInputFunc {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  template <typename TInput1, typename TInput2>
+  void call(int64_t& out, const TInput1&, const TInput2&) {
+    out = 1;
+  }
+};
+
+TEST_F(FunctionResolutionTest, constrainedGenerics) {
+  registerFunction<SingleInputFunc, int64_t, Orderable<T1>>({"orderable"});
+  registerFunction<SingleInputFunc, int64_t, Comparable<T1>>({"comparable"});
+  registerFunction<SingleInputFunc, int64_t, Generic<T1>>({"generic"});
+
+  auto& registry = exec::simpleFunctions();
+
+  auto testSingleInput = [&](const auto& inputType) {
+    // Test orderable.
+    {
+      auto resolved = registry.resolveFunction("orderable", {inputType});
+      if (inputType->isOrderable()) {
+        EXPECT_EQ(TypeKind::BIGINT, resolved->type()->kind());
+      } else {
+        EXPECT_EQ(std::nullopt, resolved);
+      }
+    }
+
+    // Test comparable.
+    {
+      auto resolved = registry.resolveFunction("comparable", {inputType});
+
+      if (inputType->isComparable()) {
+        EXPECT_EQ(TypeKind::BIGINT, resolved->type()->kind());
+      } else {
+        EXPECT_EQ(std::nullopt, resolved);
+      }
+    }
+
+    // Test generic.
+    EXPECT_EQ(
+        TypeKind::BIGINT,
+        registry.resolveFunction("generic", {inputType})->type()->kind());
+  };
+
+  auto functionType = std::make_shared<FunctionType>(
+      std::vector<TypePtr>{BIGINT(), VARCHAR()}, BOOLEAN());
+
+  testSingleInput(INTEGER());
+  testSingleInput(functionType);
+  testSingleInput(ARRAY(INTEGER()));
+  testSingleInput(MAP(INTEGER(), INTEGER()));
+  testSingleInput(ROW({INTEGER(), MAP(INTEGER(), INTEGER())}));
+  testSingleInput(ARRAY(ARRAY(INTEGER())));
+
+  // Make sure we can't assign different properties to the same variable.
+  VELOX_ASSERT_THROW(
+      (registerFunction<TwoInputFunc, int64_t, Generic<T1>, Comparable<T1>>(
+          {"generic"})),
+      "Cant assign different properties to the same variable __user_T1");
+  VELOX_ASSERT_THROW(
+      (registerFunction<TwoInputFunc, int64_t, Orderable<T1>, Comparable<T1>>(
+          {"generic"})),
+      "Cant assign different properties to the same variable __user_T1");
+
+  // Expect two args to be the same and comprable.
+  registerFunction<TwoInputFunc, int64_t, Comparable<T1>, Comparable<T1>>(
+      {"same_comparable"});
+
+  EXPECT_EQ(
+      TypeKind::BIGINT,
+      registry.resolveFunction("same_comparable", {BIGINT(), BIGINT()})
+          ->type()
+          ->kind());
+
+  EXPECT_EQ(
+      std::nullopt,
+      registry.resolveFunction(
+          "same_comparable",
+          {MAP(INTEGER(), functionType), MAP(INTEGER(), functionType)}));
+  EXPECT_EQ(
+      std::nullopt,
+      registry.resolveFunction("same_comparable", {BIGINT(), DOUBLE()}));
+
+  // Orderable nested in array.
+  registerFunction<SingleInputFunc, int64_t, Array<Orderable<T1>>>(
+      {"nested_orderable"});
+
+  EXPECT_EQ(
+      std::nullopt,
+      registry.resolveFunction(
+          "nested_orderable", {ARRAY(MAP(BIGINT(), BIGINT()))}));
+  EXPECT_EQ(
+      std::nullopt, registry.resolveFunction("nested_orderable", {INTEGER()}));
+  EXPECT_EQ(
+      TypeKind::BIGINT,
+      registry.resolveFunction("nested_orderable", {ARRAY(INTEGER())})
+          ->type()
+          ->kind());
+}
+
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/FunctionSignatureBuilderTest.cpp b/velox/exec/tests/FunctionSignatureBuilderTest.cpp
index 1411cc7aed43a..00563a3e6a3ca 100644
--- a/velox/exec/tests/FunctionSignatureBuilderTest.cpp
+++ b/velox/exec/tests/FunctionSignatureBuilderTest.cpp
@@ -86,7 +86,7 @@ TEST_F(FunctionSignatureBuilderTest, basicTypeTests) {
           .argumentType("T")
           .argumentType("array(M)")
           .build(),
-      "Type doesn't exist: M");
+      "Type doesn't exist: 'M'");
 
   // Only supported types.
   VELOX_ASSERT_THROW(
@@ -95,7 +95,7 @@ TEST_F(FunctionSignatureBuilderTest, basicTypeTests) {
           .returnType("nosuchtype")
           .argumentType("array(T)")
           .build(),
-      "Type doesn't exist: NOSUCHTYPE");
+      "Type doesn't exist: 'NOSUCHTYPE'");
 
   // Any Type.
   EXPECT_TRUE(
@@ -115,16 +115,16 @@ TEST_F(FunctionSignatureBuilderTest, typeParamTests) {
           .returnType("integer")
           .argumentType("Any(T)")
           .build(),
-      "Type 'Any' cannot have parameters");
+      "Failed to parse type signature [Any(T)]: syntax error, unexpected LPAREN, expecting YYEOF");
 
   // Variable Arity in argument fails.
   VELOX_ASSERT_THROW(
       FunctionSignatureBuilder()
           .typeVariable("T")
           .returnType("integer")
-          .argumentType("row(T ..., varchar)")
+          .argumentType("row(..., varchar)")
           .build(),
-      "Type doesn't exist: T ...");
+      "Failed to parse type signature [row(..., varchar)]: syntax error, unexpected COMMA");
 
   // Type params cant have type params.
   VELOX_ASSERT_THROW(
@@ -134,7 +134,7 @@ TEST_F(FunctionSignatureBuilderTest, typeParamTests) {
           .returnType("integer")
           .argumentType("T(M)")
           .build(),
-      "Named type cannot have parameters : T(M)");
+      "Failed to parse type signature [T(M)]: syntax error, unexpected LPAREN, expecting YYEOF");
 }
 
 TEST_F(FunctionSignatureBuilderTest, anyInReturn) {
@@ -177,8 +177,7 @@ TEST_F(FunctionSignatureBuilderTest, scalarConstantFlags) {
                          .argumentType("double")
                          .constantArgumentType("T")
                          .argumentType("bigint")
-                         .constantArgumentType("boolean")
-                         .variableArity()
+                         .constantVariableArity("boolean")
                          .build();
     EXPECT_FALSE(signature->constantArguments().at(0));
     EXPECT_TRUE(signature->constantArguments().at(1));
@@ -214,8 +213,7 @@ TEST_F(FunctionSignatureBuilderTest, aggregateConstantFlags) {
                             .argumentType("bigint")
                             .constantArgumentType("T")
                             .argumentType("T")
-                            .constantArgumentType("double")
-                            .variableArity()
+                            .constantVariableArity("double")
                             .build();
     EXPECT_FALSE(aggSignature->constantArguments().at(0));
     EXPECT_TRUE(aggSignature->constantArguments().at(1));
@@ -338,3 +336,15 @@ TEST_F(FunctionSignatureBuilderTest, orderableComparableAggregate) {
           .build(),
       "Variable T declared twice");
 }
+
+TEST_F(FunctionSignatureBuilderTest, allowVariablesForIntermediateType) {
+  ASSERT_NO_THROW(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .integerVariable("i_precision", "min(38, a_precision + 10)")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("ROW(DECIMAL(i_precision, a_scale), BIGINT)")
+          .returnType("DECIMAL(a_precision, a_scale)")
+          .build());
+}
diff --git a/velox/exec/tests/GroupedExecutionTest.cpp b/velox/exec/tests/GroupedExecutionTest.cpp
index 92e6e74d27062..e2e788506a89c 100644
--- a/velox/exec/tests/GroupedExecutionTest.cpp
+++ b/velox/exec/tests/GroupedExecutionTest.cpp
@@ -13,14 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <velox/type/Timestamp.h>
+#include <regex>
+
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/connectors/hive/HiveConnectorSplit.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
-#include "velox/exec/TableScan.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/exec/OutputBufferManager.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/Cursor.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::exec::test {
@@ -39,8 +41,8 @@ class GroupedExecutionTest : public virtual HiveConnectorTestBase {
       int32_t count,
       int32_t rowsPerVector,
       const RowTypePtr& rowType = nullptr) {
-    auto inputs = rowType ? rowType : rowType_;
-    return HiveConnectorTestBase::makeVectors(inputs, count, rowsPerVector);
+    auto inputType = rowType ? rowType : rowType_;
+    return HiveConnectorTestBase::makeVectors(inputType, count, rowsPerVector);
   }
 
   exec::Split makeHiveSplitWithGroup(std::string path, int32_t group) {
@@ -117,19 +119,29 @@ TEST_F(GroupedExecutionTest, groupedExecutionErrors) {
   planFragment.executionStrategy = core::ExecutionStrategy::kUngrouped;
   planFragment.groupedExecutionLeafNodeIds.clear();
   planFragment.groupedExecutionLeafNodeIds.emplace(tableScanNodeId);
-  queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  task = exec::Task::create("0", planFragment, 0, std::move(queryCtx));
+  queryCtx = core::QueryCtx::create(executor_.get());
+  task = exec::Task::create(
+      "0",
+      planFragment,
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
   VELOX_ASSERT_THROW(
-      task->start(task, 3, 1),
+      task->start(3, 1),
       "groupedExecutionLeafNodeIds must be empty in ungrouped execution mode");
 
   // Check grouped execution without supplied leaf node ids.
   planFragment.executionStrategy = core::ExecutionStrategy::kGrouped;
   planFragment.groupedExecutionLeafNodeIds.clear();
-  queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  task = exec::Task::create("0", planFragment, 0, std::move(queryCtx));
+  queryCtx = core::QueryCtx::create(executor_.get());
+  task = exec::Task::create(
+      "0",
+      planFragment,
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
   VELOX_ASSERT_THROW(
-      task->start(task, 3, 1),
+      task->start(3, 1),
       "groupedExecutionLeafNodeIds must not be empty in "
       "grouped execution mode");
 
@@ -137,10 +149,15 @@ TEST_F(GroupedExecutionTest, groupedExecutionErrors) {
   planFragment.executionStrategy = core::ExecutionStrategy::kGrouped;
   planFragment.groupedExecutionLeafNodeIds.clear();
   planFragment.groupedExecutionLeafNodeIds.emplace(projectNodeId);
-  queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  task = exec::Task::create("0", planFragment, 0, std::move(queryCtx));
+  queryCtx = core::QueryCtx::create(executor_.get());
+  task = exec::Task::create(
+      "0",
+      planFragment,
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
   VELOX_ASSERT_THROW(
-      task->start(task, 3, 1),
+      task->start(3, 1),
       fmt::format(
           "Grouped execution leaf node {} is not a leaf node in any pipeline",
           projectNodeId));
@@ -150,10 +167,15 @@ TEST_F(GroupedExecutionTest, groupedExecutionErrors) {
   planFragment.groupedExecutionLeafNodeIds.clear();
   planFragment.groupedExecutionLeafNodeIds.emplace(tableScanNodeId);
   planFragment.groupedExecutionLeafNodeIds.emplace(projectNodeId);
-  queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  task = exec::Task::create("0", planFragment, 0, std::move(queryCtx));
+  queryCtx = core::QueryCtx::create(executor_.get());
+  task = exec::Task::create(
+      "0",
+      planFragment,
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
   VELOX_ASSERT_THROW(
-      task->start(task, 3, 1),
+      task->start(3, 1),
       fmt::format(
           "Grouped execution leaf node {} is not a leaf node in any pipeline",
           projectNodeId));
@@ -163,10 +185,15 @@ TEST_F(GroupedExecutionTest, groupedExecutionErrors) {
   planFragment.executionStrategy = core::ExecutionStrategy::kGrouped;
   planFragment.groupedExecutionLeafNodeIds.clear();
   planFragment.groupedExecutionLeafNodeIds.emplace(localPartitionNodeId);
-  queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  task = exec::Task::create("0", planFragment, 0, std::move(queryCtx));
+  queryCtx = core::QueryCtx::create(executor_.get());
+  task = exec::Task::create(
+      "0",
+      planFragment,
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
   VELOX_ASSERT_THROW(
-      task->start(task, 3, 1),
+      task->start(3, 1),
       fmt::format(
           "Grouped execution leaf node {} not found or it is not a leaf node",
           localPartitionNodeId));
@@ -178,7 +205,7 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithOutputBuffer) {
   // Create source file - we will read from it in 6 splits.
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
 
   // A chain of three pipelines separated by local exchange with the leaf one
   // having scan running grouped execution - this will make all three pipelines
@@ -199,17 +226,21 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithOutputBuffer) {
   planFragment.executionStrategy = core::ExecutionStrategy::kGrouped;
   planFragment.groupedExecutionLeafNodeIds.emplace(tableScanNodeId);
   planFragment.numSplitGroups = 10;
-  auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  auto task =
-      exec::Task::create("0", std::move(planFragment), 0, std::move(queryCtx));
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  auto task = exec::Task::create(
+      "0",
+      std::move(planFragment),
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
   // 3 drivers max and 1 concurrent split group.
-  task->start(task, 3, 1);
+  task->start(3, 1);
 
   // All pipelines run grouped execution, so no drivers should be running.
   EXPECT_EQ(0, task->numRunningDrivers());
 
   // Add one split for group (8).
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 8));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 8));
 
   // Only one split group should be in the processing mode, so 9 drivers (3 per
   // pipeline).
@@ -217,11 +248,11 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithOutputBuffer) {
   EXPECT_EQ(std::unordered_set<int32_t>{}, getCompletedSplitGroups(task));
 
   // Add the rest of splits
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 1));
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 5));
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 8));
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 5));
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 8));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 1));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 5));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 8));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 5));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 8));
 
   // One split group should be in the processing mode, so 9 drivers.
   EXPECT_EQ(9, task->numRunningDrivers());
@@ -256,8 +287,7 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithOutputBuffer) {
 
   // 'Delete results' from output buffer triggers 'set all output consumed',
   // which should finish the task.
-  auto outputBufferManager =
-      exec::PartitionedOutputBufferManager::getInstance().lock();
+  auto outputBufferManager = exec::OutputBufferManager::getInstance().lock();
   outputBufferManager->deleteResults(task->taskId(), 0);
 
   // Task must be finished at this stage.
@@ -282,13 +312,188 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithOutputBuffer) {
   EXPECT_EQ(18, taskStats.pipelineStats[1].operatorStats[1].inputVectors);
 }
 
+DEBUG_ONLY_TEST_F(
+    GroupedExecutionTest,
+    groupedExecutionWithHashJoinSpillCheck) {
+  // Create source file to read as split input.
+  auto vectors = makeVectors(24, 20);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  const int numDriversPerGroup{3};
+
+  struct {
+    bool enableSpill;
+    bool mixedExecutionMode;
+    int groupConcurrency;
+    int expectedNumDrivers;
+    bool expectedSpill;
+
+    std::string debugString() const {
+      return fmt::format(
+          "enableSpill {}, mixedExecutionMode {}, groupConcurrency {}, expectedNumDrivers {}, expectedSpill {}",
+          enableSpill,
+          mixedExecutionMode,
+          groupConcurrency,
+          expectedNumDrivers,
+          groupConcurrency,
+          expectedSpill);
+    }
+  } testSettings[] = {
+      {false, false, 1, 12, false},
+      {false, true, 1, 9, false},
+      {true, false, 1, 12, true},
+      {true, true, 1, 9, false},
+      {false, false, 2, 12, false},
+      {false, true, 2, 9, false},
+      {true, false, 2, 12, true},
+      {true, true, 2, 9, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId probeScanNodeId;
+    core::PlanNodeId buildScanNodeId;
+
+    PlanBuilder planBuilder(planNodeIdGenerator, pool_.get());
+    planBuilder.tableScan(rowType_)
+        .capturePlanNodeId(probeScanNodeId)
+        .project({"c0 as x"});
+    // Hash join.
+    core::PlanNodeId joinNodeId;
+    auto planFragment = planBuilder
+                            .hashJoin(
+                                {"x"},
+                                {"y"},
+                                PlanBuilder(planNodeIdGenerator, pool_.get())
+                                    .tableScan(rowType_, {"c0 > 0"})
+                                    .capturePlanNodeId(buildScanNodeId)
+                                    .project({"c0 as y"})
+                                    .planNode(),
+                                "",
+                                {"x", "y"})
+                            .capturePlanNodeId(joinNodeId)
+                            .partitionedOutput({}, 1, {"x", "y"})
+                            .planFragment();
+
+    planFragment.executionStrategy = core::ExecutionStrategy::kGrouped;
+    planFragment.groupedExecutionLeafNodeIds.emplace(probeScanNodeId);
+    if (!testData.mixedExecutionMode) {
+      planFragment.groupedExecutionLeafNodeIds.emplace(buildScanNodeId);
+    }
+    planFragment.numSplitGroups = 2;
+
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    if (testData.enableSpill) {
+      std::unordered_map<std::string, std::string> configs;
+      configs.emplace(core::QueryConfig::kSpillEnabled, "true");
+      configs.emplace(core::QueryConfig::kJoinSpillEnabled, "true");
+      queryCtx->testingOverrideConfigUnsafe(std::move(configs));
+    }
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::noMoreInput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (op->operatorType() == "HashProbe") {
+            ASSERT_NE(op->splitGroupId(), kUngroupedGroupId);
+            const int pipelineId =
+                op->testingOperatorCtx()->driverCtx()->pipelineId;
+            const auto peerOps =
+                op->testingOperatorCtx()->task()->findPeerOperators(
+                    pipelineId, op);
+            ASSERT_LE(peerOps.size(), numDriversPerGroup);
+          }
+          if (op->operatorType() != "HashBuild") {
+            return;
+          }
+          if (testData.mixedExecutionMode) {
+            ASSERT_EQ(op->splitGroupId(), kUngroupedGroupId);
+          } else {
+            ASSERT_NE(op->splitGroupId(), kUngroupedGroupId);
+          }
+          const int pipelineId =
+              op->testingOperatorCtx()->driverCtx()->pipelineId;
+          const auto peerOps =
+              op->testingOperatorCtx()->task()->findPeerOperators(
+                  pipelineId, op);
+          ASSERT_LE(peerOps.size(), numDriversPerGroup);
+
+          ASSERT_EQ(op->canReclaim(), testData.expectedSpill);
+          if (testData.enableSpill) {
+            memory::testingRunArbitration(op->pool());
+          }
+        }));
+
+    auto task = exec::Task::create(
+        "0",
+        std::move(planFragment),
+        0,
+        std::move(queryCtx),
+        Task::ExecutionMode::kParallel);
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    if (testData.enableSpill) {
+      task->setSpillDirectory(spillDirectory->getPath());
+    }
+
+    // 'numDriversPerGroup' drivers max to execute one group at a time.
+    task->start(numDriversPerGroup, testData.groupConcurrency);
+    ASSERT_EQ(task->hasMixedExecutionGroup(), testData.mixedExecutionMode);
+
+    // Add split(s) to the build scan.
+    if (testData.mixedExecutionMode) {
+      task->addSplit(buildScanNodeId, makeHiveSplit(filePath->getPath()));
+    } else {
+      task->addSplit(
+          buildScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 0));
+      task->addSplit(
+          buildScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 1));
+    }
+    // Add one split for probe split group (0).
+    task->addSplit(
+        probeScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 0));
+    // Add one split for probe split group (1).
+    task->addSplit(
+        probeScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 1));
+
+    // Finalize the build split(s).
+    if (testData.mixedExecutionMode) {
+      task->noMoreSplits(buildScanNodeId);
+    } else {
+      task->noMoreSplitsForGroup(buildScanNodeId, 0);
+      task->noMoreSplitsForGroup(buildScanNodeId, 1);
+    }
+    // Finalize probe split groups.
+    task->noMoreSplitsForGroup(probeScanNodeId, 0);
+    task->noMoreSplitsForGroup(probeScanNodeId, 1);
+
+    waitForFinishedDrivers(task, testData.expectedNumDrivers);
+
+    // 'Delete results' from output buffer triggers 'set all output consumed',
+    // which should finish the task.
+    auto outputBufferManager = exec::OutputBufferManager::getInstance().lock();
+    outputBufferManager->deleteResults(task->taskId(), 0);
+
+    // Task must be finished at this stage.
+    ASSERT_EQ(task->state(), exec::TaskState::kFinished);
+
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(joinNodeId);
+    if (testData.expectedSpill) {
+      ASSERT_GT(planStats.spilledBytes, 0);
+    } else {
+      ASSERT_EQ(planStats.spilledBytes, 0);
+    }
+  }
+}
+
 // Here we test various aspects of grouped/bucketed execution involving
 // output buffer and 3 pipelines.
 TEST_F(GroupedExecutionTest, groupedExecutionWithHashAndNestedLoopJoin) {
   // Create source file - we will read from it in 6 splits.
   auto vectors = makeVectors(4, 20);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
 
   // Run the test twice - for Hash and Cross Join.
   for (size_t i = 0; i < 2; ++i) {
@@ -301,6 +506,7 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithHashAndNestedLoopJoin) {
         .capturePlanNodeId(probeScanNodeId)
         .project({"c3 as x", "c2 as y", "c1 as z", "c0 as w", "c4", "c5"});
     // Hash or Nested Loop join.
+    core::PlanNodeId joinNodeId;
     if (i == 0) {
       planBuilder
           .hashJoin(
@@ -313,6 +519,7 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithHashAndNestedLoopJoin) {
                   .planNode(),
               "",
               {"x", "y", "z", "w", "c4", "c5"})
+          .capturePlanNodeId(joinNodeId)
           .localPartitionRoundRobinRow()
           .project({"w as c0", "z as c1", "y as c2", "x as c3", "c4", "c5"})
           .planNode();
@@ -337,21 +544,26 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithHashAndNestedLoopJoin) {
     planFragment.executionStrategy = core::ExecutionStrategy::kGrouped;
     planFragment.groupedExecutionLeafNodeIds.emplace(probeScanNodeId);
     planFragment.numSplitGroups = 10;
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+    auto queryCtx = core::QueryCtx::create(executor_.get());
     auto task = exec::Task::create(
-        "0", std::move(planFragment), 0, std::move(queryCtx));
+        "0",
+        std::move(planFragment),
+        0,
+        std::move(queryCtx),
+        Task::ExecutionMode::kParallel);
     // 3 drivers max and 1 concurrent split group.
-    task->start(task, 3, 1);
+    task->start(3, 1);
 
     // Build pipeline runs ungrouped execution, so it should have drivers
     // running.
     EXPECT_EQ(3, task->numRunningDrivers());
 
     // Add single split to the build scan.
-    task->addSplit(buildScanNodeId, makeHiveSplit(filePath->path));
+    task->addSplit(buildScanNodeId, makeHiveSplit(filePath->getPath()));
 
     // Add one split for group (8).
-    task->addSplit(probeScanNodeId, makeHiveSplitWithGroup(filePath->path, 8));
+    task->addSplit(
+        probeScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 8));
 
     // Only one split group should be in the processing mode, so 9 drivers (3
     // per pipeline) grouped + 3 ungrouped.
@@ -359,11 +571,16 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithHashAndNestedLoopJoin) {
     EXPECT_EQ(std::unordered_set<int32_t>{}, getCompletedSplitGroups(task));
 
     // Add the rest of splits
-    task->addSplit(probeScanNodeId, makeHiveSplitWithGroup(filePath->path, 1));
-    task->addSplit(probeScanNodeId, makeHiveSplitWithGroup(filePath->path, 5));
-    task->addSplit(probeScanNodeId, makeHiveSplitWithGroup(filePath->path, 8));
-    task->addSplit(probeScanNodeId, makeHiveSplitWithGroup(filePath->path, 5));
-    task->addSplit(probeScanNodeId, makeHiveSplitWithGroup(filePath->path, 8));
+    task->addSplit(
+        probeScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 1));
+    task->addSplit(
+        probeScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 5));
+    task->addSplit(
+        probeScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 8));
+    task->addSplit(
+        probeScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 5));
+    task->addSplit(
+        probeScanNodeId, makeHiveSplitWithGroup(filePath->getPath(), 8));
 
     // One split group should be in the processing mode, so 9 drivers (3 per
     // pipeline) grouped + 3 ungrouped.
@@ -410,14 +627,36 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithHashAndNestedLoopJoin) {
 
     // 'Delete results' from output buffer triggers 'set all output consumed',
     // which should finish the task.
-    auto outputBufferManager =
-        exec::PartitionedOutputBufferManager::getInstance().lock();
+    auto outputBufferManager = exec::OutputBufferManager::getInstance().lock();
     outputBufferManager->deleteResults(task->taskId(), 0);
 
     // Task must be finished at this stage.
     EXPECT_EQ(exec::TaskState::kFinished, task->state());
     EXPECT_EQ(
         std::unordered_set<int32_t>({1, 5, 8}), getCompletedSplitGroups(task));
+    if (i == 0) {
+      // Check each split group has a separate hash join node pool.
+      const std::unordered_set<int32_t> expectedSplitGroupIds({1, 5, 8});
+      int numSplitGroupJoinNodes{0};
+      task->pool()->visitChildren([&](memory::MemoryPool* childPool) -> bool {
+        if (folly::StringPiece(childPool->name())
+                .startsWith(fmt::format("node.{}[", joinNodeId))) {
+          ++numSplitGroupJoinNodes;
+          std::vector<std::string> parts;
+          folly::split(".", childPool->name(), parts);
+          const std::string name = parts[1];
+          parts.clear();
+          folly::split("[", name, parts);
+          const std::string splitGroupIdStr =
+              parts[1].substr(0, parts[1].size() - 1);
+          EXPECT_TRUE(
+              expectedSplitGroupIds.count(atoi(splitGroupIdStr.c_str())))
+              << splitGroupIdStr;
+        }
+        return true;
+      });
+      ASSERT_EQ(numSplitGroupJoinNodes, expectedSplitGroupIds.size());
+    }
   }
 }
 
@@ -427,7 +666,7 @@ TEST_F(GroupedExecutionTest, groupedExecution) {
   const size_t numSplits{6};
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
 
   CursorParameters params;
   params.planNode = tableScanNode(ROW({}, {}));
@@ -443,11 +682,11 @@ TEST_F(GroupedExecutionTest, groupedExecution) {
   params.numConcurrentSplitGroups = 2;
 
   // Create the cursor with the task underneath. It is not started yet.
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   auto task = cursor->task();
 
   // Add one splits before start to ensure we can handle such cases.
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 8));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 8));
 
   // Start task now.
   cursor->start();
@@ -457,11 +696,11 @@ TEST_F(GroupedExecutionTest, groupedExecution) {
   EXPECT_EQ(std::unordered_set<int32_t>{}, getCompletedSplitGroups(task));
 
   // Add the rest of splits
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 1));
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 5));
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 8));
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 5));
-  task->addSplit("0", makeHiveSplitWithGroup(filePath->path, 8));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 1));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 5));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 8));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 5));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 8));
 
   // Only two split groups should be in the processing mode, so 4 drivers.
   EXPECT_EQ(4, task->numRunningDrivers());
@@ -515,4 +754,50 @@ TEST_F(GroupedExecutionTest, groupedExecution) {
   EXPECT_EQ(numRead, numSplits * 10'000);
 }
 
+TEST_F(GroupedExecutionTest, allGroupSplitsReceivedBeforeTaskStart) {
+  // Create source file - we will read from it in 6 splits.
+  const size_t numSplits{6};
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  CursorParameters params;
+  params.planNode = tableScanNode(ROW({}, {}));
+  params.maxDrivers = 1;
+  params.executionStrategy = core::ExecutionStrategy::kGrouped;
+  params.groupedExecutionLeafNodeIds.emplace(params.planNode->id());
+  params.numSplitGroups = 3;
+  params.numConcurrentSplitGroups = 1;
+
+  // Create the cursor with the task underneath. It is not started yet.
+  auto cursor = TaskCursor::create(params);
+  auto task = cursor->task();
+
+  // Add all split groups before start to ensure we can handle such cases.
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 0));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 1));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 2));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 0));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 1));
+  task->addSplit("0", makeHiveSplitWithGroup(filePath->getPath(), 2));
+  task->noMoreSplits("0");
+
+  // Start task now.
+  cursor->start();
+  waitForFinishedDrivers(task, 3);
+  ASSERT_EQ(
+      getCompletedSplitGroups(task), std::unordered_set<int32_t>({0, 1, 2}));
+
+  // Make sure we've got the right number of rows.
+  int32_t numReadRows{0};
+  while (cursor->moveNext()) {
+    auto vector = cursor->current();
+    EXPECT_EQ(vector->childrenSize(), 0);
+    numReadRows += vector->size();
+  }
+
+  // Task must be finished at this stage.
+  ASSERT_EQ(task->state(), exec::TaskState::kFinished);
+  ASSERT_EQ(numSplits * 10'000, numReadRows);
+}
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HashBitRangeTest.cpp b/velox/exec/tests/HashBitRangeTest.cpp
index 0b562f88342e6..fd67ddd017b45 100644
--- a/velox/exec/tests/HashBitRangeTest.cpp
+++ b/velox/exec/tests/HashBitRangeTest.cpp
@@ -20,7 +20,12 @@
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 
-class HashRangeBitTest : public test::VectorTestBase, public testing::Test {};
+class HashRangeBitTest : public test::VectorTestBase, public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 TEST_F(HashRangeBitTest, hashBitRange) {
   HashBitRange bitRange(29, 31);
diff --git a/velox/exec/tests/HashJoinBridgeTest.cpp b/velox/exec/tests/HashJoinBridgeTest.cpp
index d7b2d80e8ca46..fce7c01303f85 100644
--- a/velox/exec/tests/HashJoinBridgeTest.cpp
+++ b/velox/exec/tests/HashJoinBridgeTest.cpp
@@ -24,6 +24,26 @@ using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using facebook::velox::exec::test::TempDirectoryPath;
 
+namespace facebook::velox::exec::test {
+
+class HashJoinBridgeTestHelper {
+ public:
+  static HashJoinBridgeTestHelper create(HashJoinBridge* bridge) {
+    return HashJoinBridgeTestHelper(bridge);
+  }
+
+  std::optional<HashJoinBridge::HashBuildResult>& buildResult() const {
+    return bridge_->buildResult_;
+  }
+
+ private:
+  explicit HashJoinBridgeTestHelper(HashJoinBridge* bridge) : bridge_(bridge) {
+    VELOX_CHECK_NOT_NULL(bridge_);
+  }
+
+  HashJoinBridge* const bridge_;
+};
+
 struct TestParam {
   int32_t numProbers{1};
   int32_t numBuilders{1};
@@ -39,6 +59,7 @@ class HashJoinBridgeTest : public testing::Test,
 
  protected:
   static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
     filesystems::registerLocalFileSystem();
   }
 
@@ -87,26 +108,21 @@ class HashJoinBridgeTest : public testing::Test,
     return futures;
   }
 
-  void createFile(const std::string& filePath) {
-    auto fs = filesystems::getFileSystem(filePath, nullptr);
-    // File object dtor will close the file.
-    auto file = fs->openFileForWrite(filePath);
-  }
-
   SpillFiles makeFakeSpillFiles(int32_t numFiles) {
+    static uint32_t fakeFileId{0};
     SpillFiles files;
     files.reserve(numFiles);
+    const std::string filePathPrefix = tempDir_->getPath() + "/Spill";
     for (int32_t i = 0; i < numFiles; ++i) {
-      files.push_back(std::make_unique<SpillFile>(
-          rowType_,
-          1,
-          std::vector<CompareFlags>({}),
-          tempDir_->path + "/Spill",
-          common::CompressionKind_NONE,
-          pool_.get()));
-      // Create a fake file to avoid too many exception logs in test when spill
-      // file deletion fails.
-      createFile(files.back()->testingFilePath());
+      const auto fileId = fakeFileId;
+      files.push_back(
+          {fileId,
+           rowType_,
+           tempDir_->getPath() + "/Spill_" + std::to_string(fileId),
+           1024,
+           1,
+           std::vector<CompareFlags>({}),
+           common::CompressionKind_NONE});
     }
     return files;
   }
@@ -137,8 +153,9 @@ class HashJoinBridgeTest : public testing::Test,
   const uint32_t maxNumPartitions_{8};
   const uint32_t numSpillFilesPerPartition_{20};
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  memory::MemoryAllocator* allocator_{memory::MemoryAllocator::getInstance()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  memory::MemoryAllocator* allocator_{memory::memoryManager()->allocator()};
   std::shared_ptr<TempDirectoryPath> tempDir_;
 
   std::mutex mutex_;
@@ -153,17 +170,20 @@ TEST_P(HashJoinBridgeTest, withoutSpill) {
     auto joinBridge = createJoinBridge();
     // Can't call any other APIs except addBuilder() before start a join bridge
     // first.
-    ASSERT_ANY_THROW(
-        joinBridge->setHashTable(createFakeHashTable(), {}, false));
-    ASSERT_ANY_THROW(joinBridge->setAntiJoinHasNullKeys());
-    ASSERT_ANY_THROW(joinBridge->probeFinished());
-    ASSERT_ANY_THROW(joinBridge->tableOrFuture(&futures[0]));
-    ASSERT_ANY_THROW(joinBridge->spillInputOrFuture(&futures[0]));
+    VELOX_ASSERT_THROW(
+        joinBridge->setHashTable(createFakeHashTable(), {}, false), "");
+    VELOX_ASSERT_THROW(joinBridge->setAntiJoinHasNullKeys(), "");
+    VELOX_ASSERT_THROW(joinBridge->probeFinished(), "");
+    VELOX_ASSERT_THROW(joinBridge->tableOrFuture(&futures[0]), "");
+    VELOX_ASSERT_THROW(joinBridge->spillInputOrFuture(&futures[0]), "");
+    VELOX_ASSERT_THROW(
+        joinBridge->setSpilledHashTable(makeFakeSpillPartitionSet(0)), "");
 
     // Can't start a bridge without any builders.
-    ASSERT_ANY_THROW(joinBridge->start());
+    VELOX_ASSERT_THROW(joinBridge->start(), "");
 
     joinBridge = createJoinBridge();
+    auto helper = HashJoinBridgeTestHelper::create(joinBridge.get());
 
     for (int32_t i = 0; i < numBuilders_; ++i) {
       joinBridge->addBuilder();
@@ -175,18 +195,20 @@ TEST_P(HashJoinBridgeTest, withoutSpill) {
       ASSERT_FALSE(tableOr.has_value());
       ASSERT_TRUE(futures[i].valid());
     }
+    ASSERT_FALSE(helper.buildResult().has_value());
 
     BaseHashTable* rawTable = nullptr;
     if (hasNullKeys) {
       joinBridge->setAntiJoinHasNullKeys();
-      ASSERT_ANY_THROW(joinBridge->setAntiJoinHasNullKeys());
+      VELOX_ASSERT_THROW(joinBridge->setAntiJoinHasNullKeys(), "");
     } else {
       auto table = createFakeHashTable();
       rawTable = table.get();
       joinBridge->setHashTable(std::move(table), {}, false);
-      ASSERT_ANY_THROW(
-          joinBridge->setHashTable(createFakeHashTable(), {}, false));
+      VELOX_ASSERT_THROW(
+          joinBridge->setHashTable(createFakeHashTable(), {}, false), "");
     }
+    ASSERT_TRUE(helper.buildResult().has_value());
 
     for (int32_t i = 0; i < numProbers_; ++i) {
       futures[i].wait();
@@ -211,16 +233,28 @@ TEST_P(HashJoinBridgeTest, withoutSpill) {
         ASSERT_TRUE(tableOr.value().spillPartitionIds.empty());
       }
     }
+    ASSERT_TRUE(helper.buildResult().has_value());
 
-    // Verify builder will see no spill input.
+    // Verify builder will wait for probe side finish signal even if there is no
+    // spill input.
     auto inputOr = joinBridge->spillInputOrFuture(&futures[0]);
+    ASSERT_FALSE(inputOr.has_value());
+    ASSERT_TRUE(futures[0].valid());
+
+    // Probe side completion.
+    ASSERT_FALSE(joinBridge->probeFinished());
+    ASSERT_FALSE(helper.buildResult().has_value());
+
+    futures[0].wait();
+
+    futures = createEmptyFutures(1);
+    inputOr = joinBridge->spillInputOrFuture(&futures[0]);
     ASSERT_TRUE(inputOr.has_value());
     ASSERT_FALSE(futures[0].valid());
     ASSERT_TRUE(inputOr.value().spillPartition == nullptr);
 
-    // Probe side completion.
-    ASSERT_FALSE(joinBridge->probeFinished());
-    ASSERT_ANY_THROW(joinBridge->probeFinished());
+    VELOX_ASSERT_THROW(joinBridge->probeFinished(), "");
+    ASSERT_FALSE(helper.buildResult().has_value());
   }
 }
 
@@ -272,15 +306,23 @@ TEST_P(HashJoinBridgeTest, withSpill) {
       } else {
         spillPartitionSet = makeFakeSpillPartitionSet(startPartitionBitOffset_);
       }
-      bool hasMoreSpill;
+
+      bool spillByProber{false};
+      bool hasMoreSpill{false};
       if (spillLevel >= testData.spillLevel && testData.endWithNull) {
         joinBridge->setAntiJoinHasNullKeys();
         hasMoreSpill = false;
       } else {
         numSpilledPartitions += spillPartitionSet.size();
-        spillPartitionIdSet = toSpillPartitionIdSet(spillPartitionSet);
-        hasMoreSpill = joinBridge->setHashTable(
-            createFakeHashTable(), std::move(spillPartitionSet), false);
+        if (oneIn(2)) {
+          spillPartitionIdSet = toSpillPartitionIdSet(spillPartitionSet);
+          joinBridge->setHashTable(
+              createFakeHashTable(), std::move(spillPartitionSet), false);
+        } else {
+          spillByProber = !spillPartitionSet.empty();
+          joinBridge->setHashTable(createFakeHashTable(), {}, false);
+        }
+        hasMoreSpill = numSpilledPartitions > numRestoredPartitions;
       }
 
       // Get built table from probe side.
@@ -299,22 +341,33 @@ TEST_P(HashJoinBridgeTest, withSpill) {
       }
 
       // Wait for probe to complete from build side.
+      for (int32_t i = 0; i < numBuilders_; ++i) {
+        ASSERT_FALSE(
+            joinBridge->spillInputOrFuture(&buildFutures[i]).has_value());
+      }
+
+      if (spillByProber) {
+        VELOX_ASSERT_THROW(
+            joinBridge->setSpilledHashTable({}),
+            "Spilled table partitions can't be empty");
+        joinBridge->setSpilledHashTable(std::move(spillPartitionSet));
+      }
+
+      // Probe table.
+      ASSERT_EQ(hasMoreSpill, joinBridge->probeFinished());
+      // Probe can't set spilled table partitions after it finishes probe.
+      VELOX_ASSERT_THROW(
+          joinBridge->setSpilledHashTable({}),
+          "Spilled table partitions can't be empty");
+      VELOX_ASSERT_THROW(
+          joinBridge->setSpilledHashTable(makeFakeSpillPartitionSet(0)), "");
+
       if (!hasMoreSpill) {
         for (int32_t i = 0; i < numBuilders_; ++i) {
           auto inputOr = joinBridge->spillInputOrFuture(&buildFutures[i]);
           ASSERT_TRUE(inputOr.has_value());
           ASSERT_TRUE(inputOr.value().spillPartition == nullptr);
         }
-      } else {
-        for (int32_t i = 0; i < numBuilders_; ++i) {
-          ASSERT_FALSE(
-              joinBridge->spillInputOrFuture(&buildFutures[i]).has_value());
-        }
-      }
-
-      // Probe table.
-      ASSERT_EQ(hasMoreSpill, joinBridge->probeFinished());
-      if (!hasMoreSpill) {
         break;
       }
 
@@ -431,23 +484,20 @@ TEST_P(HashJoinBridgeTest, multiThreading) {
             tableOr = joinBridge->tableOrFuture(&tableFuture);
             ASSERT_TRUE(tableOr.has_value());
           }
-          if (tableOr.value().hasNullKeys) {
-            break;
-          }
-          ASSERT_TRUE(tableOr.value().table != nullptr);
-          for (const auto& id : tableOr.value().spillPartitionIds) {
-            ASSERT_FALSE(spillPartitionIdSet.contains(id));
-            spillPartitionIdSet.insert(id);
-          }
-          if (tableOr.value().restoredPartitionId.has_value()) {
-            ASSERT_TRUE(spillPartitionIdSet.contains(
-                tableOr.value().restoredPartitionId.value()));
-            spillPartitionIdSet.erase(
-                tableOr.value().restoredPartitionId.value());
-          }
-
-          if (spillPartitionIdSet.empty()) {
-            break;
+          if (!tableOr.value().hasNullKeys) {
+            ASSERT_TRUE(tableOr.value().table != nullptr);
+            for (const auto& id : tableOr.value().spillPartitionIds) {
+              ASSERT_FALSE(spillPartitionIdSet.contains(id));
+              spillPartitionIdSet.insert(id);
+            }
+            if (tableOr.value().restoredPartitionId.has_value()) {
+              ASSERT_TRUE(spillPartitionIdSet.contains(
+                  tableOr.value().restoredPartitionId.value()));
+              spillPartitionIdSet.erase(
+                  tableOr.value().restoredPartitionId.value());
+            }
+          } else {
+            spillPartitionIdSet.clear();
           }
 
           // Wait for probe to finish.
@@ -468,11 +518,15 @@ TEST_P(HashJoinBridgeTest, multiThreading) {
             probeFuture.wait();
           } else {
             proberBarrier.reset(new BarrierState());
-            ASSERT_TRUE(joinBridge->probeFinished());
+            ASSERT_EQ(
+                joinBridge->probeFinished(), !spillPartitionIdSet.empty());
             for (auto& promise : promises) {
               promise.setValue();
             }
           }
+          if (spillPartitionIdSet.empty()) {
+            break;
+          }
         }
       });
     }
@@ -486,7 +540,78 @@ TEST_P(HashJoinBridgeTest, multiThreading) {
   }
 }
 
+TEST_P(HashJoinBridgeTest, isHashJoinMemoryPools) {
+  auto root = memory::memoryManager()->addRootPool("isHashBuildMemoryPool");
+  struct {
+    std::string poolName;
+    bool isHashBuildPool;
+    bool isHashProbePool;
+
+    std::string debugString() const {
+      return fmt::format(
+          "poolName: {}, isHashBuildPool: {}, isHashProbePool: {}",
+          poolName,
+          isHashBuildPool,
+          isHashProbePool);
+    }
+  } testSettings[] = {
+      {"HashBuild", true, false},
+      {"HashBuildd", false, false},
+      {"hHashBuild", true, false},
+      {"hHashProbe", false, true},
+      {"HashProbe", false, true},
+      {"HashProbeh", false, false}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto pool = root->addLeafChild(testData.poolName);
+    ASSERT_EQ(isHashBuildMemoryPool(*pool), testData.isHashBuildPool);
+    ASSERT_EQ(isHashProbeMemoryPool(*pool), testData.isHashProbePool);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     HashJoinBridgeTest,
     HashJoinBridgeTest,
     testing::ValuesIn(HashJoinBridgeTest::getTestParams()));
+
+TEST(HashJoinBridgeTest, needRightSideJoin) {
+  for (int i = 0; i < static_cast<int>(core::JoinType::kNumJoinTypes); ++i) {
+    const core::JoinType joinType = static_cast<core::JoinType>(i);
+    if (isRightJoin(joinType) || isFullJoin(joinType) ||
+        isRightSemiFilterJoin(joinType) || isRightSemiProjectJoin(joinType)) {
+      ASSERT_TRUE(needRightSideJoin(joinType));
+    } else {
+      ASSERT_FALSE(needRightSideJoin(joinType));
+    }
+  }
+}
+
+TEST(HashJoinBridgeTest, hashJoinTableSpillType) {
+  const RowTypePtr tableType = ROW({"k1", "k2"}, {BIGINT(), BIGINT()});
+  const RowTypePtr spillTypeWithProbedFlag =
+      ROW({"k1", "k2", "__probedFlag"}, {BIGINT(), BIGINT(), BOOLEAN()});
+  struct {
+    core::JoinType joinType;
+    RowTypePtr expectedTableSpillType;
+
+    std::string debugString() const {
+      return fmt::format(
+          "joinType: {}, expectedTableSpillType: {}",
+          joinTypeName(joinType),
+          expectedTableSpillType->toString());
+    }
+  } testSettings[] = {
+      {core::JoinType::kFull, spillTypeWithProbedFlag},
+      {core::JoinType::kRight, spillTypeWithProbedFlag},
+      {core::JoinType::kLeft, tableType}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    const RowTypePtr spillType =
+        hashJoinTableSpillType(tableType, testData.joinType);
+    ASSERT_TRUE(spillType->equivalent(*testData.expectedTableSpillType));
+    ASSERT_EQ(spillType->names(), testData.expectedTableSpillType->names());
+  }
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HashJoinTest.cpp b/velox/exec/tests/HashJoinTest.cpp
index a7449fc8d4002..07c65c40348f8 100644
--- a/velox/exec/tests/HashJoinTest.cpp
+++ b/velox/exec/tests/HashJoinTest.cpp
@@ -16,13 +16,16 @@
 
 #include <re2/re2.h>
 
+#include <fmt/format.h>
 #include "folly/experimental/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/HashBuild.h"
 #include "velox/exec/HashJoinBridge.h"
 #include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/Cursor.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
@@ -66,9 +69,10 @@ std::function<void(Task* task)> makeAddSplit(
 }
 
 // Returns aggregated spilled stats by build and probe operators from 'task'.
-std::pair<SpillStats, SpillStats> taskSpilledStats(const exec::Task& task) {
-  SpillStats buildStats;
-  SpillStats probeStats;
+std::pair<common::SpillStats, common::SpillStats> taskSpilledStats(
+    const exec::Task& task) {
+  common::SpillStats buildStats;
+  common::SpillStats probeStats;
   auto stats = task.taskStats();
   for (auto& pipeline : stats.pipelineStats) {
     for (auto op : pipeline.operatorStats) {
@@ -99,33 +103,46 @@ void verifyTaskSpilledRuntimeStats(const exec::Task& task, bool expectedSpill) {
       if ((op.operatorType == "HashBuild") ||
           (op.operatorType == "HashProbe")) {
         if (!expectedSpill) {
-          ASSERT_EQ(op.runtimeStats["spillRuns"].count, 0);
-          ASSERT_EQ(op.runtimeStats["spillFillTime"].count, 0);
-          ASSERT_EQ(op.runtimeStats["spillSortTime"].count, 0);
-          ASSERT_EQ(op.runtimeStats["spillSerializationTime"].count, 0);
-          ASSERT_EQ(op.runtimeStats["spillFlushTime"].count, 0);
-          ASSERT_EQ(op.runtimeStats["spillDiskWrites"].count, 0);
-          ASSERT_EQ(op.runtimeStats["spillWriteTime"].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillRuns].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillFillTime].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillSortTime].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[Operator::kSpillSerializationTime].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillFlushTime].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillWrites].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillWriteTime].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillReadBytes].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillReads].count, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillReadTime].count, 0);
+          ASSERT_EQ(
+              op.runtimeStats[Operator::kSpillDeserializationTime].count, 0);
         } else {
-          ASSERT_GT(op.runtimeStats["spillRuns"].count, 0);
           if (op.operatorType == "HashBuild") {
-            ASSERT_GT(op.runtimeStats["spillFillTime"].sum, 0);
+            ASSERT_GT(op.runtimeStats[Operator::kSpillRuns].count, 0);
+            ASSERT_GT(op.runtimeStats[Operator::kSpillFillTime].sum, 0);
           } else {
-            ASSERT_EQ(op.runtimeStats["spillFillTime"].sum, 0);
+            // The table spilling might also be triggered from hash probe side.
+            ASSERT_GE(op.runtimeStats[Operator::kSpillRuns].count, 0);
+            ASSERT_GE(op.runtimeStats[Operator::kSpillFillTime].sum, 0);
           }
-          ASSERT_EQ(op.runtimeStats["spillSortTime"].sum, 0);
-          ASSERT_GT(op.runtimeStats["spillSerializationTime"].sum, 0);
-          ASSERT_GE(op.runtimeStats["spillFlushTime"].sum, 0);
+          ASSERT_EQ(op.runtimeStats[Operator::kSpillSortTime].sum, 0);
+          ASSERT_GT(op.runtimeStats[Operator::kSpillSerializationTime].sum, 0);
+          ASSERT_GE(op.runtimeStats[Operator::kSpillFlushTime].sum, 0);
           // NOTE: spill flush might take less than one microsecond.
           ASSERT_GE(
-              op.runtimeStats["spillSerializationTime"].count,
-              op.runtimeStats["spillFlushTime"].count);
-          ASSERT_GT(op.runtimeStats["spillDiskWrites"].sum, 0);
-          ASSERT_GE(op.runtimeStats["spillWriteTime"].sum, 0);
+              op.runtimeStats[Operator::kSpillSerializationTime].count,
+              op.runtimeStats[Operator::kSpillFlushTime].count);
+          ASSERT_GT(op.runtimeStats[Operator::kSpillWrites].sum, 0);
+          ASSERT_GE(op.runtimeStats[Operator::kSpillWriteTime].sum, 0);
           // NOTE: spill flush might take less than one microsecond.
           ASSERT_GE(
-              op.runtimeStats["spillDiskWrites"].count,
-              op.runtimeStats["spillWriteTime"].count);
+              op.runtimeStats[Operator::kSpillWrites].count,
+              op.runtimeStats[Operator::kSpillWriteTime].count);
+          ASSERT_GT(op.runtimeStats[Operator::kSpillReadBytes].sum, 0);
+          ASSERT_GT(op.runtimeStats[Operator::kSpillReads].sum, 0);
+          ASSERT_GT(op.runtimeStats[Operator::kSpillReadTime].sum, 0);
+          ASSERT_GT(
+              op.runtimeStats[Operator::kSpillDeserializationTime].sum, 0);
         }
       }
     }
@@ -186,7 +203,7 @@ std::pair<int32_t, int32_t> numTaskSpillFiles(const exec::Task& task) {
 void abortPool(memory::MemoryPool* pool) {
   try {
     VELOX_FAIL("Manual MemoryPool Abortion");
-  } catch (const VeloxException& error) {
+  } catch (const VeloxException&) {
     pool->abort(std::current_exception());
   }
 }
@@ -210,8 +227,14 @@ class HashJoinBuilder {
     fuzzerOpts_.containerVariableLength = true;
   }
 
-  HashJoinBuilder& numDrivers(int32_t numDrivers) {
+  HashJoinBuilder& numDrivers(
+      int32_t numDrivers,
+      std::optional<bool> runParallelProbe = std::nullopt,
+      std::optional<bool> runParallelBuild = std::nullopt) {
+    VELOX_CHECK_EQ(runParallelProbe.has_value(), runParallelBuild.has_value());
     numDrivers_ = numDrivers;
+    runParallelProbe_ = runParallelProbe;
+    runParallelBuild_ = runParallelBuild;
     return *this;
   }
 
@@ -367,11 +390,6 @@ class HashJoinBuilder {
     return *this;
   }
 
-  HashJoinBuilder& spillMemoryThreshold(uint64_t threshold) {
-    spillMemoryThreshold_ = threshold;
-    return *this;
-  }
-
   HashJoinBuilder& injectSpill(bool injectSpill) {
     injectSpill_ = injectSpill;
     return *this;
@@ -440,13 +458,20 @@ class HashJoinBuilder {
     };
 
     std::vector<TestSettings> testSettings;
-    testSettings.push_back({
-        true,
-        true,
-    });
-    if (numDrivers_ != 1) {
-      testSettings.push_back({true, false});
-      testSettings.push_back({false, true});
+    if (!runParallelBuild_.has_value()) {
+      ASSERT_FALSE(runParallelProbe_.has_value());
+      testSettings.push_back({
+          true,
+          true,
+      });
+      if (numDrivers_ != 1) {
+        testSettings.push_back({true, false});
+        testSettings.push_back({false, true});
+      }
+    } else {
+      ASSERT_TRUE(runParallelProbe_.has_value());
+      testSettings.push_back(
+          {runParallelProbe_.value(), runParallelBuild_.value()});
     }
 
     for (const auto& testData : testSettings) {
@@ -455,7 +480,7 @@ class HashJoinBuilder {
       auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
       std::shared_ptr<const core::HashJoinNode> joinNode;
       auto planNode =
-          PlanBuilder(planNodeIdGenerator)
+          PlanBuilder(planNodeIdGenerator, &pool_)
               .values(
                   testData.probeParallelize ? probeVectors_ : allProbeVectors_,
                   testData.probeParallelize)
@@ -559,10 +584,10 @@ class HashJoinBuilder {
     runTest(planNode, false, maxSpillLevel_.value_or(-1));
     if (injectSpill_) {
       if (maxSpillLevel_.has_value()) {
-        runTest(planNode, true, maxSpillLevel_.value());
+        runTest(planNode, true, maxSpillLevel_.value(), 100);
       } else {
-        runTest(planNode, true, 0);
-        runTest(planNode, true, 2);
+        runTest(planNode, true, 0, 100);
+        runTest(planNode, true, 2, 100);
       }
     }
   }
@@ -570,7 +595,8 @@ class HashJoinBuilder {
   void runTest(
       const core::PlanNodePtr& planNode,
       bool injectSpill,
-      int32_t maxSpillLevel = -1) {
+      int32_t maxSpillLevel = -1,
+      uint32_t maxDriverYieldTimeMs = 0) {
     AssertQueryBuilder builder(planNode, duckDbQueryRunner_);
     builder.maxDrivers(numDrivers_);
     if (makeInputSplits_) {
@@ -578,27 +604,28 @@ class HashJoinBuilder {
         builder.splits(splitEntry.first, splitEntry.second);
       }
     }
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_);
+    auto queryCtx = core::QueryCtx::create(
+        executor_,
+        core::QueryConfig{{}},
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+        cache::AsyncDataCache::getInstance(),
+        memory::MemoryManager::getInstance()->addRootPool(
+            "query_pool",
+            memory::kMaxMemory,
+            memory::MemoryReclaimer::create()));
     std::shared_ptr<TempDirectoryPath> spillDirectory;
+    int32_t spillPct{0};
     if (injectSpill) {
       spillDirectory = exec::test::TempDirectoryPath::create();
-      builder.spillDirectory(spillDirectory->path);
+      builder.spillDirectory(spillDirectory->getPath());
       config(core::QueryConfig::kSpillEnabled, "true");
       config(core::QueryConfig::kMaxSpillLevel, std::to_string(maxSpillLevel));
       config(core::QueryConfig::kJoinSpillEnabled, "true");
-      // Disable write buffering to ease test verification. For example, we want
-      // many spilled vectors in a spilled file to trigger recursive spilling.
+      // Disable write buffering to ease test verification. For example, we
+      // want many spilled vectors in a spilled file to trigger recursive
+      // spilling.
       config(core::QueryConfig::kSpillWriteBufferSize, std::to_string(0));
-      config(core::QueryConfig::kTestingSpillPct, "100");
-    } else if (spillMemoryThreshold_ != 0) {
-      spillDirectory = exec::test::TempDirectoryPath::create();
-      builder.spillDirectory(spillDirectory->path);
-      config(core::QueryConfig::kSpillEnabled, "true");
-      config(core::QueryConfig::kMaxSpillLevel, std::to_string(maxSpillLevel));
-      config(core::QueryConfig::kJoinSpillEnabled, "true");
-      config(
-          core::QueryConfig::kJoinSpillMemoryThreshold,
-          std::to_string(spillMemoryThreshold_));
+      spillPct = 100;
     } else if (!spillDirectory_.empty()) {
       builder.spillDirectory(spillDirectory_);
       config(core::QueryConfig::kSpillEnabled, "true");
@@ -609,6 +636,11 @@ class HashJoinBuilder {
     config(
         core::QueryConfig::kHashProbeFinishEarlyOnEmptyBuild,
         hashProbeFinishEarlyOnEmptyBuild_ ? "true" : "false");
+    if (maxDriverYieldTimeMs != 0) {
+      config(
+          core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+          std::to_string(maxDriverYieldTimeMs));
+    }
 
     if (!configs_.empty()) {
       auto configCopy = configs_;
@@ -622,9 +654,28 @@ class HashJoinBuilder {
     SCOPED_TRACE(
         injectSpill ? fmt::format("With Max Spill Level: {}", maxSpillLevel)
                     : "Without Spill");
-    ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
-    const uint64_t peakSpillMemoryUsage = Spiller::pool()->stats().peakBytes;
+    ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
+    const uint64_t peakSpillMemoryUsage =
+        memory::spillMemoryPool()->stats().peakBytes;
+    TestScopedSpillInjection scopedSpillInjection(spillPct);
     auto task = builder.assertResults(referenceQuery_);
+    // Wait up to 5 seconds for all the task background activities to complete.
+    // Then we can collect the stats from all the operators.
+    //
+    // TODO: replace this with task utility to ensure all the background
+    // activities to finish and all the drivers stats have been reported.
+    uint64_t totalTaskWaitTimeUs{0};
+    while (task.use_count() != 1) {
+      constexpr uint64_t kWaitInternalUs = 1'000;
+      std::this_thread::sleep_for(std::chrono::microseconds(kWaitInternalUs));
+      totalTaskWaitTimeUs += kWaitInternalUs;
+      if (totalTaskWaitTimeUs >= 5'000'000) {
+        VELOX_FAIL(
+            "Failed to wait for all the background activities of task {} to finish, pending reference count: {}",
+            task->taskId(),
+            task.use_count());
+      }
+    }
     const auto statsPair = taskSpilledStats(*task);
     if (injectSpill) {
       if (checkSpillStats_) {
@@ -643,14 +694,15 @@ class HashJoinBuilder {
         }
         verifyTaskSpilledRuntimeStats(*task, true);
       }
-      ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
-      if (statsPair.first.spilledBytes > 0 && Spiller::pool()->trackUsage()) {
-        ASSERT_GT(Spiller::pool()->stats().peakBytes, 0);
-        ASSERT_GE(Spiller::pool()->stats().peakBytes, peakSpillMemoryUsage);
+      if (statsPair.first.spilledBytes > 0 &&
+          memory::spillMemoryPool()->trackUsage()) {
+        ASSERT_GT(memory::spillMemoryPool()->stats().peakBytes, 0);
+        ASSERT_GE(
+            memory::spillMemoryPool()->stats().peakBytes, peakSpillMemoryUsage);
       }
-      // NOTE: if 'spillDirectory_' is not empty and spill threshold is not
-      // set, the test might trigger spilling by its own.
-    } else if (spillDirectory_.empty() && spillMemoryThreshold_ == 0) {
+      // NOTE: if 'spillDirectory_' is not empty, the test might trigger
+      // spilling by its own.
+    } else if (spillDirectory_.empty()) {
       ASSERT_EQ(statsPair.first.spilledRows, 0);
       ASSERT_EQ(statsPair.first.spilledInputBytes, 0);
       ASSERT_EQ(statsPair.first.spilledBytes, 0);
@@ -663,13 +715,12 @@ class HashJoinBuilder {
       ASSERT_EQ(statsPair.second.spilledFiles, 0);
       verifyTaskSpilledRuntimeStats(*task, false);
     }
-    ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
     // Customized test verification.
     if (testVerifier_ != nullptr) {
       testVerifier_(task, injectSpill);
     }
-
     OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+    ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
   }
 
   VectorFuzzer::Options fuzzerOpts_;
@@ -698,8 +749,9 @@ class HashJoinBuilder {
   std::string joinFilter_;
   std::vector<std::string> joinOutputLayout_;
   std::vector<std::string> outputProjections_;
+  std::optional<bool> runParallelProbe_;
+  std::optional<bool> runParallelBuild_;
 
-  uint64_t spillMemoryThreshold_{0};
   bool injectSpill_{true};
   // If not set, then the test will run the test with different settings:
   // 0, 2.
@@ -732,6 +784,12 @@ class HashJoinTest : public HiveConnectorTestBase {
         ROW({{"t_k1", INTEGER()}, {"t_k2", VARCHAR()}, {"t_v1", VARCHAR()}});
     buildType_ =
         ROW({{"u_k1", INTEGER()}, {"u_k2", VARCHAR()}, {"u_v1", INTEGER()}});
+    fuzzerOpts_ = {
+        .vectorSize = 1024,
+        .nullRatio = 0.1,
+        .stringLength = 1024,
+        .stringVariableLength = false,
+        .allowLazyVector = false};
   }
 
   // Make splits with each plan node having a number of source files.
@@ -744,13 +802,75 @@ class HashJoinTest : public HiveConnectorTestBase {
       std::vector<exec::Split> splits;
       splits.reserve(files[i].size());
       for (const auto& file : files[i]) {
-        splits.push_back(exec::Split(makeHiveConnectorSplit(file->path)));
+        splits.push_back(exec::Split(makeHiveConnectorSplit(file->getPath())));
       }
       splitInput.emplace(nodeIds[i], std::move(splits));
     }
     return splitInput;
   }
 
+  void testLazyVectorsWithFilter(
+      const core::JoinType joinType,
+      const std::string& filter,
+      const std::vector<std::string>& outputLayout,
+      const std::string& referenceQuery) {
+    const vector_size_t vectorSize = 1'000;
+    auto probeVectors = makeBatches(1, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {makeFlatVector<int32_t>(vectorSize, folly::identity),
+           makeFlatVector<int64_t>(
+               vectorSize, [](auto row) { return row % 23; }),
+           makeFlatVector<int32_t>(
+               vectorSize, [](auto row) { return row % 31; })});
+    });
+
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(1, [&](int32_t /*unused*/) {
+          return makeRowVector({makeFlatVector<int32_t>(
+              vectorSize, [](auto row) { return row * 3; })});
+        });
+
+    std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
+    writeToFile(probeFile->getPath(), probeVectors);
+
+    std::shared_ptr<TempFilePath> buildFile = TempFilePath::create();
+    writeToFile(buildFile->getPath(), buildVectors);
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", buildVectors);
+
+    // Lazy vector is part of the filter but never gets loaded.
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    auto op = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(asRowType(probeVectors[0]->type()))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"c0"},
+                      {"c0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(asRowType(buildVectors[0]->type()))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      filter,
+                      outputLayout,
+                      joinType)
+                  .planNode();
+    SplitInput splitInput = {
+        {probeScanId,
+         {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
+        {buildScanId,
+         {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
+    };
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .inputSplits(splitInput)
+        .checkSpillStats(false)
+        .referenceQuery(referenceQuery)
+        .run();
+  }
+
   static uint64_t getInputPositions(
       const std::shared_ptr<Task>& task,
       int operatorIndex) {
@@ -801,6 +921,13 @@ class HashJoinTest : public HiveConnectorTestBase {
     return stats[operatorIndex].runtimeStats[statsName];
   }
 
+  // Get the operator index from the plan node id. Only used in the probe-side
+  // pipeline. The plan node id starts from "1" and the operator index starts
+  // from 0. Plan node IDs map to operators 1:1.
+  static int32_t getOperatorIndex(const core::PlanNodeId& planNodeId) {
+    return folly::to<int32_t>(planNodeId) - 1;
+  }
+
   static core::JoinType flipJoinType(core::JoinType joinType) {
     switch (joinType) {
       case core::JoinType::kInner:
@@ -844,6 +971,7 @@ class HashJoinTest : public HiveConnectorTestBase {
   // The default left and right table types used for test.
   RowTypePtr probeType_;
   RowTypePtr buildType_;
+  VectorFuzzer::Options fuzzerOpts_;
 
   memory::MemoryReclaimer::Stats reclaimerStats_;
   friend class HashJoinBuilder;
@@ -879,7 +1007,7 @@ TEST_P(MultiThreadedHashJoinTest, outOfJoinKeyColumnOrder) {
       .probeVectors(5, 10)
       .buildType(buildType_)
       .buildKeys({"u_k2"})
-      .buildVectors(5, 15)
+      .buildVectors(64, 15)
       .joinOutputLayout({"t_k1", "t_k2", "u_k1", "u_k2", "u_v1"})
       .referenceQuery(
           "SELECT t_k1, t_k2, u_k1, u_k2, u_v1 FROM t, u WHERE t_k2 = u_k2")
@@ -887,8 +1015,8 @@ TEST_P(MultiThreadedHashJoinTest, outOfJoinKeyColumnOrder) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, emptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
-  for (auto finishOnEmpty : finishOnEmptys) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
@@ -958,104 +1086,6 @@ TEST_P(MultiThreadedHashJoinTest, emptyProbe) {
       .run();
 }
 
-TEST_P(MultiThreadedHashJoinTest, emptyProbeWithSpillMemoryThreshold) {
-  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-      .numDrivers(numDrivers_)
-      .keyTypes({BIGINT()})
-      .probeVectors(0, 5)
-      .buildVectors(1500, 5)
-      .injectSpill(false)
-      .spillMemoryThreshold(1)
-      .maxSpillLevel(0)
-      .referenceQuery(
-          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t_k0 = u_k0")
-      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
-        const auto statsPair = taskSpilledStats(*task);
-        ASSERT_GT(statsPair.first.spilledRows, 0);
-        ASSERT_GT(statsPair.first.spilledBytes, 0);
-        ASSERT_GT(statsPair.first.spilledPartitions, 0);
-        ASSERT_GT(statsPair.first.spilledFiles, 0);
-        ASSERT_EQ(statsPair.second.spilledRows, 0);
-        ASSERT_EQ(statsPair.second.spilledBytes, 0);
-        ASSERT_GT(statsPair.second.spilledPartitions, 0);
-        ASSERT_EQ(statsPair.second.spilledFiles, 0);
-      })
-      .run();
-}
-
-DEBUG_ONLY_TEST_P(
-    MultiThreadedHashJoinTest,
-    raceBetweenTaskTerminationAndThesholdTriggeredSpill) {
-  std::atomic<Task*> task{nullptr};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::addInput",
-      std::function<void(Operator*)>([&](Operator* op) {
-        if (op->operatorType() != "HashBuild") {
-          return;
-        }
-        task = op->testingOperatorCtx()->task().get();
-      }));
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::SpillOperatorGroup::runSpill",
-      std::function<void(Operator*)>([&](Operator* op) {
-        ASSERT_TRUE(task.load() != nullptr);
-        task.load()->requestAbort();
-        // Wait a bit to ensure the other peer hash build drivers have been
-        // closed.
-        std::this_thread::sleep_for(std::chrono::milliseconds(1'000));
-      }));
-
-  VectorFuzzer fuzzer({.vectorSize = 10}, pool());
-  const int32_t numBuildVectors = 2;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    auto vector = fuzzer.fuzzRow(buildType_);
-    // Build the build vector with the same join key to make sure there is only
-    // one hash build operator running.
-    vector->childAt(0) = makeFlatVector<int32_t>(
-        vector->size(), [](auto /*unused*/) { return 1; });
-    buildVectors.push_back(std::move(vector));
-  }
-  const int32_t numProbeVectors = 2;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
-
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", buildVectors);
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .values(probeVectors, true)
-                  .hashJoin(
-                      {"t_k1"},
-                      {"u_k1"},
-                      PlanBuilder(planNodeIdGenerator)
-                          .values(buildVectors, true)
-                          // NOTE: add local partition here to ensure all the
-                          // build inputs go to the same hash build operator.
-                          .localPartition({"u_k1"})
-                          .planNode(),
-                      "",
-                      {"t_k1", "t_k2"},
-                      core::JoinType::kInner)
-                  .planNode();
-
-  VELOX_ASSERT_THROW(
-      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-          .planNode(plan)
-          .injectSpill(false)
-          .checkSpillStats(false)
-          .spillMemoryThreshold(1)
-          .maxSpillLevel(0)
-          .numDrivers(numDrivers_)
-          .referenceQuery(
-              "SELECT t.t_k1, t.t_k2 from t, u WHERE t.t_k1 = u.u_k1")
-          .run(),
-      "Aborted for external error");
-}
-
 TEST_P(MultiThreadedHashJoinTest, normalizedKey) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
@@ -1090,6 +1120,14 @@ DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, parallelJoinBuildCheck) {
       .referenceQuery(
           "SELECT t_k0, t_k1, t_data, u_k0, u_k1, u_data FROM t, u WHERE t_k0 = u_k0 AND t_k1 = u_k1")
       .injectSpill(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto joinStats = task->taskStats()
+                             .pipelineStats.back()
+                             .operatorStats.back()
+                             .runtimeStats;
+        ASSERT_GT(joinStats["hashtable.buildWallNanos"].sum, 0);
+        ASSERT_GE(joinStats["hashtable.buildWallNanos"].count, 1);
+      })
       .run();
   ASSERT_EQ(numDrivers_ == 1, !isParallelBuild);
 }
@@ -1343,7 +1381,7 @@ TEST_P(MultiThreadedHashJoinTest, joinSidesDifferentSchema) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, innerJoinWithEmptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
+  const std::vector<bool> finishOnEmptys = {false, true};
   for (auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
@@ -1414,8 +1452,8 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilter) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithEmptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
-  for (auto finishOnEmpty : finishOnEmptys) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
     std::vector<RowVectorPtr> probeVectors =
@@ -1523,8 +1561,8 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilter) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithEmptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
-  for (auto finishOnEmpty : finishOnEmptys) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
     // probeVectors size is greater than buildVector size.
@@ -1725,10 +1763,10 @@ TEST_P(MultiThreadedHashJoinTest, semiFilterOverLazyVectors) {
   });
 
   std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
-  writeToFile(probeFile->path, probeVectors);
+  writeToFile(probeFile->getPath(), probeVectors);
 
   std::shared_ptr<TempFilePath> buildFile = TempFilePath::create();
-  writeToFile(buildFile->path, buildVectors);
+  writeToFile(buildFile->getPath(), buildVectors);
 
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
@@ -1752,8 +1790,10 @@ TEST_P(MultiThreadedHashJoinTest, semiFilterOverLazyVectors) {
                   .planNode();
 
   SplitInput splitInput = {
-      {probeScanId, {exec::Split(makeHiveConnectorSplit(probeFile->path))}},
-      {buildScanId, {exec::Split(makeHiveConnectorSplit(buildFile->path))}},
+      {probeScanId,
+       {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
+      {buildScanId,
+       {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
   };
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
@@ -1934,8 +1974,8 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilter) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndEmptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
-  for (auto finishOnEmpty : finishOnEmptys) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
     auto probeVectors = makeBatches(4, [&](int32_t /*unused*/) {
@@ -2150,7 +2190,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, antiJoin) {
-  auto probeVectors = makeBatches(4, [&](int32_t /*unused*/) {
+  auto probeVectors = makeBatches(64, [&](int32_t /*unused*/) {
     return makeRowVector(
         {"t0", "t1"},
         {
@@ -2158,7 +2198,7 @@ TEST_P(MultiThreadedHashJoinTest, antiJoin) {
             makeFlatVector<int32_t>({0, 1, 2}),
         });
   });
-  auto buildVectors = makeBatches(4, [&](int32_t /*unused*/) {
+  auto buildVectors = makeBatches(64, [&](int32_t /*unused*/) {
     return makeRowVector(
         {"u0", "u1"},
         {
@@ -2188,6 +2228,10 @@ TEST_P(MultiThreadedHashJoinTest, antiJoin) {
       // should not evaluate filter on those rows and therefore should not
       // fail.
       "t1 / coalesce(u1, 0::integer) is not null",
+      // This filter triggers memory pool allocation at
+      // HashBuild::setupFilterForAntiJoins, which should not be invoked in
+      // operator's constructor.
+      "contains(array[1, 2, NULL], 1)",
   });
   for (const std::string& filter : filters) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
@@ -2207,8 +2251,8 @@ TEST_P(MultiThreadedHashJoinTest, antiJoin) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, antiJoinWithFilterAndEmptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
-  for (auto finishOnEmpty : finishOnEmptys) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
     auto probeVectors = makeBatches(4, [&](int32_t /*unused*/) {
@@ -2311,16 +2355,90 @@ TEST_P(MultiThreadedHashJoinTest, leftJoin) {
       .buildVectors(std::move(buildVectors))
       .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
       .joinType(core::JoinType::kLeft)
-      //.joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
       .joinOutputLayout({"row_number", "c0", "c1", "u_c0"})
       .referenceQuery(
           "SELECT t.row_number, t.c0, t.c1, u.c0 FROM t LEFT JOIN u ON t.c0 = u.c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        int nullJoinBuildKeyCount = 0;
+        int nullJoinProbeKeyCount = 0;
+
+        for (auto& pipeline : task->taskStats().pipelineStats) {
+          for (auto op : pipeline.operatorStats) {
+            if (op.operatorType == "HashBuild") {
+              nullJoinBuildKeyCount += op.numNullKeys;
+            }
+            if (op.operatorType == "HashProbe") {
+              nullJoinProbeKeyCount += op.numNullKeys;
+            }
+          }
+        }
+        ASSERT_EQ(nullJoinBuildKeyCount, 33 * GetParam().numDrivers);
+        ASSERT_EQ(nullJoinProbeKeyCount, 34 * GetParam().numDrivers);
+      })
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, nullStatsWithEmptyBuild) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"c0", "c1", "row_number"},
+            {
+                makeFlatVector<int32_t>(
+                    77, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+            });
+      });
+
+  // All null keys on build side.
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                1, [](auto row) { return row % 5; }, nullEvery(1)),
+            makeFlatVector<int32_t>(
+                1, [](auto row) { return -111 + row * 2; }, nullEvery(1)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kLeft)
+      .joinOutputLayout({"row_number", "c0", "c1", "u_c0"})
+      .referenceQuery(
+          "SELECT t.row_number, t.c0, t.c1, u.c0 FROM t LEFT JOIN u ON t.c0 = u.c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        int nullJoinBuildKeyCount = 0;
+        int nullJoinProbeKeyCount = 0;
+
+        for (auto& pipeline : task->taskStats().pipelineStats) {
+          for (auto op : pipeline.operatorStats) {
+            if (op.operatorType == "HashBuild") {
+              nullJoinBuildKeyCount += op.numNullKeys;
+            }
+            if (op.operatorType == "HashProbe") {
+              nullJoinProbeKeyCount += op.numNullKeys;
+            }
+          }
+        }
+        // Due to inaccurate stats tracking in case of empty build side,
+        // we will report 0 null keys on probe side.
+        ASSERT_EQ(nullJoinProbeKeyCount, 0);
+        ASSERT_EQ(nullJoinBuildKeyCount, 1 * GetParam().numDrivers);
+      })
+      .checkSpillStats(false)
       .run();
 }
 
 TEST_P(MultiThreadedHashJoinTest, leftJoinWithEmptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
-  for (auto finishOnEmpty : finishOnEmptys) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
     // Left side keys are [0, 1, 2,..10].
@@ -2611,7 +2729,13 @@ TEST_P(MultiThreadedHashJoinTest, leftJoinWithNullableFilter) {
 
   std::vector<RowVectorPtr> buildVectors =
       makeBatches(5, [&](int32_t /*unused*/) {
-        return makeRowVector({makeFlatVector<int32_t>({1, 2, 10, 30, 40})});
+        return makeRowVector(
+            {makeFlatVector<int32_t>(128, [](vector_size_t row) {
+              if (row < 3) {
+                return row;
+              }
+              return row + 10;
+            })});
       });
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
@@ -2680,8 +2804,8 @@ TEST_P(MultiThreadedHashJoinTest, rightJoin) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, rightJoinWithEmptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
-  for (auto finishOnEmpty : finishOnEmptys) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
     // Left side keys are [0, 1, 2,..10].
@@ -2914,8 +3038,8 @@ TEST_P(MultiThreadedHashJoinTest, fullJoin) {
 }
 
 TEST_P(MultiThreadedHashJoinTest, fullJoinWithEmptyBuild) {
-  std::vector<bool> finishOnEmptys = {false, true};
-  for (auto finishOnEmpty : finishOnEmptys) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
     SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
 
     // Left side keys are [0, 1, 2,..10].
@@ -3107,7 +3231,7 @@ TEST_P(MultiThreadedHashJoinTest, noSpillLevelLimit) {
           "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
       .maxSpillLevel(-1)
       .config(core::QueryConfig::kSpillStartPartitionBit, "48")
-      .config(core::QueryConfig::kJoinSpillPartitionBits, "3")
+      .config(core::QueryConfig::kSpillNumPartitionBits, "3")
       .checkSpillStats(false)
       .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
         if (!hasSpill) {
@@ -3118,6 +3242,64 @@ TEST_P(MultiThreadedHashJoinTest, noSpillLevelLimit) {
       .run();
 }
 
+// Verify that dynamic filter pushed down from null-aware right semi project
+// join into table scan doesn't filter out nulls.
+TEST_F(HashJoinTest, nullAwareRightSemiProjectOverScan) {
+  auto probe = makeRowVector(
+      {"t0"},
+      {
+          makeNullableFlatVector<int32_t>({1, std::nullopt, 2}),
+      });
+
+  auto build = makeRowVector(
+      {"u0"},
+      {
+          makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+      });
+
+  std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
+  writeToFile(probeFile->getPath(), {probe});
+
+  std::shared_ptr<TempFilePath> buildFile = TempFilePath::create();
+  writeToFile(buildFile->getPath(), {build});
+
+  createDuckDbTable("t", {probe});
+  createDuckDbTable("u", {build});
+
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId buildScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(asRowType(probe->type()))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(asRowType(build->type()))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      "",
+                      {"u0", "match"},
+                      core::JoinType::kRightSemiProject,
+                      true /*nullAware*/)
+                  .planNode();
+
+  SplitInput splitInput = {
+      {probeScanId,
+       {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
+      {buildScanId,
+       {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
+  };
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .inputSplits(splitInput)
+      .checkSpillStats(false)
+      .referenceQuery("SELECT u0, u0 IN (SELECT t0 FROM t) FROM u")
+      .run();
+}
+
 TEST_F(HashJoinTest, duplicateJoinKeys) {
   auto leftVectors = makeBatches(3, [&](int32_t /*unused*/) {
     return makeRowVector({
@@ -3575,10 +3757,12 @@ TEST_F(HashJoinTest, semiProjectWithFilter) {
 
     plan = makePlan(false /*nullAware*/, filter);
 
+    // DuckDB Exists operator returns NULL when u0 or t0 is NULL. We exclude
+    // these values.
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .planNode(plan)
         .referenceQuery(fmt::format(
-            "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND {}) FROM t",
+            "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE (u0 is not null OR t0 is not null) AND u0 = t0 AND {}) FROM t",
             filter))
         .injectSpill(false)
         .run();
@@ -3676,10 +3860,10 @@ TEST_F(HashJoinTest, semiProjectOverLazyVectors) {
   });
 
   std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
-  writeToFile(probeFile->path, probeVectors);
+  writeToFile(probeFile->getPath(), probeVectors);
 
   std::shared_ptr<TempFilePath> buildFile = TempFilePath::create();
-  writeToFile(buildFile->path, buildVectors);
+  writeToFile(buildFile->getPath(), buildVectors);
 
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
@@ -3703,8 +3887,10 @@ TEST_F(HashJoinTest, semiProjectOverLazyVectors) {
                   .planNode();
 
   SplitInput splitInput = {
-      {probeScanId, {exec::Split(makeHiveConnectorSplit(probeFile->path))}},
-      {buildScanId, {exec::Split(makeHiveConnectorSplit(buildFile->path))}},
+      {probeScanId,
+       {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
+      {buildScanId,
+       {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
   };
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
@@ -3794,10 +3980,10 @@ TEST_F(HashJoinTest, memory) {
                         .project({"t_k1 % 1000 AS k1", "u_k1 % 1000 AS k2"})
                         .singleAggregation({}, {"sum(k1)", "sum(k2)"})
                         .planNode();
-  params.queryCtx = std::make_shared<core::QueryCtx>(driverExecutor_.get());
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
   auto [taskCursor, rows] = readCursor(params, [](Task*) {});
   EXPECT_GT(3'500, params.queryCtx->pool()->stats().numAllocs);
-  EXPECT_GT(7'500'000, params.queryCtx->pool()->stats().cumulativeBytes);
+  EXPECT_GT(40'000'000, params.queryCtx->pool()->stats().cumulativeBytes);
 }
 
 TEST_F(HashJoinTest, lazyVectors) {
@@ -3826,13 +4012,13 @@ TEST_F(HashJoinTest, lazyVectors) {
 
   for (const auto& probeVector : probeVectors) {
     tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->path, probeVector);
+    writeToFile(tempFiles.back()->getPath(), probeVector);
   }
   createDuckDbTable("t", probeVectors);
 
   for (const auto& buildVector : buildVectors) {
     tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->path, buildVector);
+    writeToFile(tempFiles.back()->getPath(), buildVector);
   }
   createDuckDbTable("u", buildVectors);
 
@@ -3842,12 +4028,12 @@ TEST_F(HashJoinTest, lazyVectors) {
       std::vector<exec::Split> probeSplits;
       for (int i = 0; i < probeVectors.size(); ++i) {
         probeSplits.push_back(
-            exec::Split(makeHiveConnectorSplit(tempFiles[i]->path)));
+            exec::Split(makeHiveConnectorSplit(tempFiles[i]->getPath())));
       }
       std::vector<exec::Split> buildSplits;
       for (int i = 0; i < buildVectors.size(); ++i) {
-        buildSplits.push_back(exec::Split(
-            makeHiveConnectorSplit(tempFiles[probeSplits.size() + i]->path)));
+        buildSplits.push_back(exec::Split(makeHiveConnectorSplit(
+            tempFiles[probeSplits.size() + i]->getPath())));
       }
       SplitInput splits;
       splits.emplace(probeScanId, probeSplits);
@@ -3914,6 +4100,90 @@ TEST_F(HashJoinTest, lazyVectors) {
   }
 }
 
+TEST_F(HashJoinTest, lazyVectorNotLoadedInFilter) {
+  // Ensure that if lazy vectors are temporarily wrapped during a filter's
+  // execution and remain unloaded, the temporary wrap is promptly
+  // discarded. This precaution prevents the generation of the probe's output
+  // from wrapping an unloaded vector while the temporary wrap is
+  // still alive.
+  // This is done by generating a sufficiently small batch to allow the lazy
+  // vector to remain unloaded, as it doesn't need to be split between batches.
+  // Then we use a filter that skips the execution of the expression containing
+  // the lazy vector, thereby avoiding its loading.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kInner,
+      "c1 >= 0 OR c2 > 0",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0");
+}
+
+TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kLeft,
+      "c1 > 0 AND c2 > 0",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (c1 > 0 AND c2 > 0)");
+}
+
+TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterFullJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kFull,
+      "c1 > 0 AND c2 > 0",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (c1 > 0 AND c2 > 0)");
+}
+
+TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiProject) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kLeftSemiProject,
+      "c1 > 0 AND c2 > 0",
+      {"c1", "c2", "match"},
+      "SELECT t.c1, t.c2, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0)) FROM t");
+}
+
+TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterAntiJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kAnti,
+      "c1 > 0 AND c2 > 0",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND (t.c1 > 0 AND t.c2 > 0))");
+}
+
+TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterInnerJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kInner,
+      "not (c1 < 15 and c2 >= 0)",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0 AND NOT (c1 < 15 AND c2 >= 0)");
+}
+
+TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiFilter) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  testLazyVectorsWithFilter(
+      core::JoinType::kLeftSemiFilter,
+      "not (c1 < 15 and c2 >= 0)",
+      {"c1", "c2"},
+      "SELECT t.c1, t.c2 FROM t WHERE c0 IN (SELECT u.c0 FROM u WHERE t.c0 = u.c0 AND NOT (t.c1 < 15 AND t.c2 >= 0))");
+}
+
 TEST_F(HashJoinTest, dynamicFilters) {
   const int32_t numSplits = 10;
   const int32_t numRowsProbe = 333;
@@ -3931,13 +4201,14 @@ TEST_F(HashJoinTest, dynamicFilters) {
     });
     probeVectors.push_back(rowVector);
     tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->path, rowVector);
+    writeToFile(tempFiles.back()->getPath(), rowVector);
   }
   auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
     return [&] {
       std::vector<exec::Split> probeSplits;
       for (auto& file : tempFiles) {
-        probeSplits.push_back(exec::Split(makeHiveConnectorSplit(file->path)));
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(file->getPath())));
       }
       SplitInput splits;
       splits.emplace(nodeId, probeSplits);
@@ -3983,6 +4254,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
   {
     // Inner join.
     core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
                   .tableScan(probeType)
                   .capturePlanNodeId(probeScanId)
@@ -3993,6 +4265,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
                       "",
                       {"c0", "c1", "u_c1"},
                       core::JoinType::kInner)
+                  .capturePlanNodeId(joinId)
                   .project({"c0", "c1 + 1", "c1 + u_c1"})
                   .planNode();
     {
@@ -4003,16 +4276,21 @@ TEST_F(HashJoinTest, dynamicFilters) {
               "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
           .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
             SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
             if (hasSpill) {
               // Dynamic filtering should be disabled with spilling triggered.
               ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
             } else {
               ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
             }
           })
           .run();
@@ -4029,6 +4307,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
                  "",
                  {"c0", "c1"},
                  core::JoinType::kLeftSemiFilter)
+             .capturePlanNodeId(joinId)
              .project({"c0", "c1 + 1"})
              .planNode();
 
@@ -4040,17 +4319,22 @@ TEST_F(HashJoinTest, dynamicFilters) {
               "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u)")
           .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
             SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
             if (hasSpill) {
               // Dynamic filtering should be disabled with spilling triggered.
               ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
               ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
             } else {
               ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
               ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
             }
           })
           .run();
@@ -4067,6 +4351,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
                  "",
                  {"u_c0", "u_c1"},
                  core::JoinType::kRightSemiFilter)
+             .capturePlanNodeId(joinId)
              .project({"u_c0", "u_c1 + 1"})
              .planNode();
 
@@ -4078,17 +4363,22 @@ TEST_F(HashJoinTest, dynamicFilters) {
               "SELECT u.c0, u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t)")
           .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
             SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
             if (hasSpill) {
               // Dynamic filtering should be disabled with spilling triggered.
               ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
             } else {
               ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
             }
           })
           .run();
@@ -4104,16 +4394,17 @@ TEST_F(HashJoinTest, dynamicFilters) {
     assignments["b"] = regularColumn("c1", BIGINT());
 
     core::PlanNodeId probeScanId;
-    auto op =
-        PlanBuilder(planNodeIdGenerator, pool_.get())
-            .tableScan(
-                scanOutputType,
-                makeTableHandle(common::test::SubfieldFiltersBuilder().build()),
-                assignments)
-            .capturePlanNodeId(probeScanId)
-            .hashJoin({"a"}, {"u_c0"}, buildSide, "", {"a", "b", "u_c1"})
-            .project({"a", "b + 1", "b + u_c1"})
-            .planNode();
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .startTableScan()
+                  .outputType(scanOutputType)
+                  .assignments(assignments)
+                  .endTableScan()
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin({"a"}, {"u_c0"}, buildSide, "", {"a", "b", "u_c1"})
+                  .capturePlanNodeId(joinId)
+                  .project({"a", "b + 1", "b + u_c1"})
+                  .planNode();
 
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .planNode(std::move(op))
@@ -4122,17 +4413,22 @@ TEST_F(HashJoinTest, dynamicFilters) {
             "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
         .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
           SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
           if (hasSpill) {
             // Dynamic filtering should be disabled with spilling triggered.
             ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
             ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
             ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
           } else {
             ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
             ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
             ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
           }
         })
         .run();
@@ -4141,10 +4437,12 @@ TEST_F(HashJoinTest, dynamicFilters) {
   // Push-down that requires merging filters.
   {
     core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
                   .tableScan(probeType, {"c0 < 500::INTEGER"})
                   .capturePlanNodeId(probeScanId)
                   .hashJoin({"c0"}, {"u_c0"}, buildSide, "", {"c1", "u_c1"})
+                  .capturePlanNodeId(joinId)
                   .project({"c1 + u_c1"})
                   .planNode();
 
@@ -4155,17 +4453,22 @@ TEST_F(HashJoinTest, dynamicFilters) {
             "SELECT t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 500")
         .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
           SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
           if (hasSpill) {
             // Dynamic filtering should be disabled with spilling triggered.
             ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
             ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
             ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
           } else {
             ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
             ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
             ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
           }
         })
         .run();
@@ -4174,11 +4477,13 @@ TEST_F(HashJoinTest, dynamicFilters) {
   // Push-down that turns join into a no-op.
   {
     core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
     auto op =
         PlanBuilder(planNodeIdGenerator, pool_.get())
             .tableScan(probeType)
             .capturePlanNodeId(probeScanId)
             .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c0", "c1"})
+            .capturePlanNodeId(joinId)
             .project({"c0", "c1 + 1"})
             .planNode();
 
@@ -4188,12 +4493,14 @@ TEST_F(HashJoinTest, dynamicFilters) {
         .referenceQuery("SELECT t.c0, t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
         .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
           SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
           if (hasSpill) {
             // Dynamic filtering should be disabled with spilling triggered.
             ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
             ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
             ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
           } else {
             ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
@@ -4201,6 +4508,9 @@ TEST_F(HashJoinTest, dynamicFilters) {
                 getReplacedWithFilterRows(task, 1).sum,
                 numRowsBuild * numSplits);
             ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
           }
         })
         .run();
@@ -4210,10 +4520,12 @@ TEST_F(HashJoinTest, dynamicFilters) {
   // number of columns than the input.
   {
     core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
                   .tableScan(probeType)
                   .capturePlanNodeId(probeScanId)
                   .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c0"})
+                  .capturePlanNodeId(joinId)
                   .planNode();
 
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
@@ -4222,12 +4534,14 @@ TEST_F(HashJoinTest, dynamicFilters) {
         .referenceQuery("SELECT t.c0 FROM t JOIN u ON (t.c0 = u.c0)")
         .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
           SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
           if (hasSpill) {
             // Dynamic filtering should be disabled with spilling triggered.
             ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
             ASSERT_EQ(0, getReplacedWithFilterRows(task, 1).sum);
             ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
           } else {
             ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
@@ -4235,6 +4549,9 @@ TEST_F(HashJoinTest, dynamicFilters) {
                 getReplacedWithFilterRows(task, 1).sum,
                 numRowsBuild * numSplits);
             ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
           }
         })
         .run();
@@ -4243,10 +4560,12 @@ TEST_F(HashJoinTest, dynamicFilters) {
   // Push-down that requires merging filters and turns join into a no-op.
   {
     core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
                   .tableScan(probeType, {"c0 < 500::INTEGER"})
                   .capturePlanNodeId(probeScanId)
                   .hashJoin({"c0"}, {"u_c0"}, keyOnlyBuildSide, "", {"c1"})
+                  .capturePlanNodeId(joinId)
                   .project({"c1 + 1"})
                   .planNode();
 
@@ -4257,17 +4576,22 @@ TEST_F(HashJoinTest, dynamicFilters) {
             "SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 500")
         .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
           SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+          auto planStats = toPlanStats(task->taskStats());
           if (hasSpill) {
             // Dynamic filtering should be disabled with spilling triggered.
             ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
             ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
             ASSERT_EQ(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
           } else {
             ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
             ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
             ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
             ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+            ASSERT_EQ(
+                planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                std::unordered_set<core::PlanNodeId>({joinId}));
           }
         })
         .run();
@@ -4277,12 +4601,14 @@ TEST_F(HashJoinTest, dynamicFilters) {
   {
     // Inner join.
     core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
     auto op =
         PlanBuilder(planNodeIdGenerator, pool_.get())
             .tableScan(probeType, {"c0 < 200::INTEGER"})
             .capturePlanNodeId(probeScanId)
             .hashJoin(
                 {"c0"}, {"u_c0"}, buildSide, "", {"c1"}, core::JoinType::kInner)
+            .capturePlanNodeId(joinId)
             .project({"c1 + 1"})
             .planNode();
 
@@ -4294,17 +4620,22 @@ TEST_F(HashJoinTest, dynamicFilters) {
               "SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0 AND t.c0 < 200")
           .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
             SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
             if (hasSpill) {
               // Dynamic filtering should be disabled with spilling triggered.
               ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
             } else {
               ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
               ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
             }
           })
           .run();
@@ -4321,6 +4652,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
                  "",
                  {"c1"},
                  core::JoinType::kLeftSemiFilter)
+             .capturePlanNodeId(joinId)
              .project({"c1 + 1"})
              .planNode();
 
@@ -4332,17 +4664,22 @@ TEST_F(HashJoinTest, dynamicFilters) {
               "SELECT t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u) AND t.c0 < 200")
           .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
             SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
             if (hasSpill) {
               // Dynamic filtering should be disabled with spilling triggered.
               ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
             } else {
               ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
               ASSERT_GT(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
             }
           })
           .run();
@@ -4359,6 +4696,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
                  "",
                  {"u_c1"},
                  core::JoinType::kRightSemiFilter)
+             .capturePlanNodeId(joinId)
              .project({"u_c1 + 1"})
              .planNode();
 
@@ -4370,17 +4708,22 @@ TEST_F(HashJoinTest, dynamicFilters) {
               "SELECT u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t) AND u.c0 < 200")
           .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
             SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            auto planStats = toPlanStats(task->taskStats());
             if (hasSpill) {
               // Dynamic filtering should be disabled with spilling triggered.
               ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
             } else {
               ASSERT_EQ(1, getFiltersProduced(task, 1).sum);
               ASSERT_EQ(1, getFiltersAccepted(task, 0).sum);
               ASSERT_EQ(getReplacedWithFilterRows(task, 1).sum, 0);
               ASSERT_LT(getInputPositions(task, 1), numRowsProbe * numSplits);
+              ASSERT_EQ(
+                  planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+                  std::unordered_set<core::PlanNodeId>({joinId}));
             }
           })
           .run();
@@ -4389,9 +4732,11 @@ TEST_F(HashJoinTest, dynamicFilters) {
 
   // Disable filter push-down by using values in place of scan.
   {
+    core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
                   .values(probeVectors)
                   .hashJoin({"c0"}, {"u_c0"}, buildSide, "", {"c1"})
+                  .capturePlanNodeId(joinId)
                   .project({"c1 + 1"})
                   .planNode();
 
@@ -4399,6 +4744,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
         .planNode(std::move(op))
         .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
         .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          auto planStats = toPlanStats(task->taskStats());
           ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
           ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
           ASSERT_EQ(numRowsProbe * numSplits, getInputPositions(task, 1));
@@ -4410,11 +4756,13 @@ TEST_F(HashJoinTest, dynamicFilters) {
   // probe side.
   {
     core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
                   .tableScan(probeType)
                   .capturePlanNodeId(probeScanId)
                   .project({"cast(c0 + 1 as integer) AS t_key", "c1"})
                   .hashJoin({"t_key"}, {"u_c0"}, buildSide, "", {"c1"})
+                  .capturePlanNodeId(joinId)
                   .project({"c1 + 1"})
                   .planNode();
 
@@ -4423,14 +4771,113 @@ TEST_F(HashJoinTest, dynamicFilters) {
         .makeInputSplits(makeInputSplits(probeScanId))
         .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE (t.c0 + 1) = u.c0")
         .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          auto planStats = toPlanStats(task->taskStats());
           ASSERT_EQ(0, getFiltersProduced(task, 1).sum);
           ASSERT_EQ(0, getFiltersAccepted(task, 0).sum);
           ASSERT_EQ(numRowsProbe * numSplits, getInputPositions(task, 1));
+          ASSERT_TRUE(planStats.at(probeScanId).dynamicFilterStats.empty());
         })
         .run();
   }
 }
 
+TEST_F(HashJoinTest, dynamicFiltersStatsWithChainedJoins) {
+  const int32_t numSplits = 10;
+  const int32_t numProbeRows = 333;
+  const int32_t numBuildRows = 100;
+
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(numSplits);
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto rowVector = makeRowVector({
+        makeFlatVector<int32_t>(
+            numProbeRows, [&](auto row) { return row - i * 10; }),
+        makeFlatVector<int64_t>(numProbeRows, [](auto row) { return row; }),
+    });
+    probeVectors.push_back(rowVector);
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), rowVector);
+  }
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      std::vector<exec::Split> probeSplits;
+      for (auto& file : tempFiles) {
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(file->getPath())));
+      }
+      SplitInput splits;
+      splits.emplace(nodeId, probeSplits);
+      return splits;
+    };
+  };
+
+  // 100 key values in [35, 233] range.
+  std::vector<RowVectorPtr> buildVectors;
+  for (int i = 0; i < 5; ++i) {
+    buildVectors.push_back(makeRowVector({
+        makeFlatVector<int32_t>(
+            numBuildRows / 5,
+            [i](auto row) { return 35 + 2 * (row + i * numBuildRows / 5); }),
+        makeFlatVector<int64_t>(numBuildRows / 5, [](auto row) { return row; }),
+    }));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto buildSide1 = PlanBuilder(planNodeIdGenerator, pool_.get())
+                        .values(buildVectors)
+                        .project({"c0 AS u_c0", "c1 AS u_c1"})
+                        .planNode();
+  auto buildSide2 = PlanBuilder(planNodeIdGenerator, pool_.get())
+                        .values(buildVectors)
+                        .project({"c0 AS u_c0", "c1 AS u_c1"})
+                        .planNode();
+  // Inner join pushdown.
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId joinId1;
+  core::PlanNodeId joinId2;
+  auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                .tableScan(probeType)
+                .capturePlanNodeId(probeScanId)
+                .hashJoin(
+                    {"c0"},
+                    {"u_c0"},
+                    buildSide1,
+                    "",
+                    {"c0", "c1"},
+                    core::JoinType::kInner)
+                .capturePlanNodeId(joinId1)
+                .hashJoin(
+                    {"c0"},
+                    {"u_c0"},
+                    buildSide2,
+                    "",
+                    {"c0", "c1", "u_c1"},
+                    core::JoinType::kInner)
+                .capturePlanNodeId(joinId2)
+                .project({"c0", "c1 + 1", "c1 + u_c1"})
+                .planNode();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .makeInputSplits(makeInputSplits(probeScanId))
+      .injectSpill(false)
+      .referenceQuery(
+          "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto planStats = toPlanStats(task->taskStats());
+        ASSERT_EQ(
+            planStats.at(probeScanId).dynamicFilterStats.producerNodeIds,
+            std::unordered_set<core::PlanNodeId>({joinId1, joinId2}));
+      })
+      .run();
+}
+
 TEST_F(HashJoinTest, dynamicFiltersWithSkippedSplits) {
   const int32_t numSplits = 20;
   const int32_t numNonSkippedSplits = 10;
@@ -4457,21 +4904,23 @@ TEST_F(HashJoinTest, dynamicFiltersWithSkippedSplits) {
     });
     probeVectors.push_back(rowVector);
     tempFiles.push_back(TempFilePath::create());
-    writeToFile(tempFiles.back()->path, rowVector);
+    writeToFile(tempFiles.back()->getPath(), rowVector);
   }
 
   auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
     return [&] {
       std::vector<exec::Split> probeSplits;
       for (auto& file : tempFiles) {
-        probeSplits.push_back(exec::Split(makeHiveConnectorSplit(file->path)));
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(file->getPath())));
       }
       // We add splits that have no rows.
       auto makeEmpty = [&]() {
-        return exec::Split(HiveConnectorSplitBuilder(tempFiles.back()->path)
-                               .start(10000000)
-                               .length(1)
-                               .build());
+        return exec::Split(
+            HiveConnectorSplitBuilder(tempFiles.back()->getPath())
+                .start(10000000)
+                .length(1)
+                .build());
       };
       std::vector<exec::Split> emptyFront = {makeEmpty(), makeEmpty()};
       std::vector<exec::Split> emptyMiddle = {makeEmpty(), makeEmpty()};
@@ -4651,6 +5100,159 @@ TEST_F(HashJoinTest, dynamicFiltersWithSkippedSplits) {
   }
 }
 
+TEST_F(HashJoinTest, dynamicFiltersAppliedToPreloadedSplits) {
+  vector_size_t size = 1000;
+  const int32_t numSplits = 5;
+
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(numSplits);
+
+  // Prepare probe side table.
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  std::vector<exec::Split> probeSplits;
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto rowVector = makeRowVector(
+        {"p0", "p1"},
+        {
+            makeFlatVector<int64_t>(
+                size, [&](auto row) { return (row + 1) * (i + 1); }),
+            makeFlatVector<int64_t>(size, [&](auto /*row*/) { return i; }),
+        });
+    probeVectors.push_back(rowVector);
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), rowVector);
+    auto split = HiveConnectorSplitBuilder(tempFiles.back()->getPath())
+                     .partitionKey("p1", std::to_string(i))
+                     .build();
+    probeSplits.push_back(exec::Split(split));
+  }
+
+  auto outputType = ROW({"p0", "p1"}, {BIGINT(), BIGINT()});
+  ColumnHandleMap assignments = {
+      {"p0", regularColumn("p0", BIGINT())},
+      {"p1", partitionKey("p1", BIGINT())}};
+  createDuckDbTable("p", probeVectors);
+
+  // Prepare build side table.
+  std::vector<RowVectorPtr> buildVectors{
+      makeRowVector({"b0"}, {makeFlatVector<int64_t>({0, numSplits})})};
+  createDuckDbTable("b", buildVectors);
+
+  // Executing the join with p1=b0, we expect a dynamic filter for p1 to prune
+  // the entire file/split. There are total of five splits, and all except the
+  // first one are expected to be pruned. The result 'preloadedSplits' > 1
+  // confirms the successful push of dynamic filters to the preloading data
+  // source.
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId joinNodeId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .startTableScan()
+          .outputType(outputType)
+          .assignments(assignments)
+          .endTableScan()
+          .capturePlanNodeId(probeScanId)
+          .hashJoin(
+              {"p1"},
+              {"b0"},
+              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+              "",
+              {"p0"},
+              core::JoinType::kInner)
+          .capturePlanNodeId(joinNodeId)
+          .project({"p0"})
+          .planNode();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .config(core::QueryConfig::kMaxSplitPreloadPerDriver, "3")
+      .injectSpill(false)
+      .inputSplits({{probeScanId, probeSplits}})
+      .referenceQuery("select p.p0 from p, b where b.b0 = p.p1")
+      .checkSpillStats(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*hasSpill*/) {
+        auto planStats = toPlanStats(task->taskStats());
+        auto getStatSum = [&](const core::PlanNodeId& id,
+                              const std::string& name) {
+          return planStats.at(id).customStats.at(name).sum;
+        };
+        ASSERT_EQ(1, getStatSum(joinNodeId, "dynamicFiltersProduced"));
+        ASSERT_EQ(1, getStatSum(probeScanId, "dynamicFiltersAccepted"));
+        ASSERT_EQ(4, getStatSum(probeScanId, "skippedSplits"));
+        ASSERT_LT(1, getStatSum(probeScanId, "preloadedSplits"));
+      })
+      .run();
+}
+
+TEST_F(HashJoinTest, dynamicFiltersPushDownThroughAgg) {
+  const int32_t numRowsProbe = 300;
+  const int32_t numRowsBuild = 100;
+
+  // Create probe data
+  std::vector<RowVectorPtr> probeVectors{makeRowVector({
+      makeFlatVector<int32_t>(numRowsProbe, [&](auto row) { return row - 10; }),
+      makeFlatVector<int64_t>(numRowsProbe, folly::identity),
+  })};
+  std::shared_ptr<TempFilePath> probeFile = TempFilePath::create();
+  writeToFile(probeFile->getPath(), probeVectors);
+
+  // Create build data
+  std::vector<RowVectorPtr> buildVectors{makeRowVector(
+      {"u0"}, {makeFlatVector<int32_t>(numRowsBuild, [&](auto row) {
+        return 35 + 2 * (row + numRowsBuild / 5);
+      })})};
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto buildSide =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+
+  // Inner join.
+  core::PlanNodeId scanNodeId;
+  core::PlanNodeId joinNodeId;
+  core::PlanNodeId aggNodeId;
+  auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                .tableScan(probeType)
+                .capturePlanNodeId(scanNodeId)
+                .partialAggregation({"c0"}, {"sum(c1)"})
+                .capturePlanNodeId(aggNodeId)
+                .hashJoin(
+                    {"c0"},
+                    {"u0"},
+                    buildSide,
+                    "",
+                    {"c0", "a0"},
+                    core::JoinType::kInner)
+                .capturePlanNodeId(joinNodeId)
+                .planNode();
+
+  SplitInput splitInput = {
+      {scanNodeId, {Split(makeHiveConnectorSplit(probeFile->getPath()))}}};
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .inputSplits(splitInput)
+      .injectSpill(false)
+      .checkSpillStats(false)
+      .referenceQuery("SELECT c0, sum(c1) FROM t, u WHERE c0 = u0 group by c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+        auto planStats = toPlanStats(task->taskStats());
+        auto dynamicFilterStats = planStats.at(scanNodeId).dynamicFilterStats;
+        ASSERT_EQ(
+            1, getFiltersProduced(task, getOperatorIndex(joinNodeId)).sum);
+        ASSERT_EQ(
+            1, getFiltersAccepted(task, getOperatorIndex(scanNodeId)).sum);
+        ASSERT_LT(
+            getInputPositions(task, getOperatorIndex(aggNodeId)), numRowsProbe);
+        ASSERT_EQ(
+            dynamicFilterStats.producerNodeIds,
+            std::unordered_set({joinNodeId}));
+      })
+      .run();
+}
+
 // Verify the size of the join output vectors when projecting build-side
 // variable-width column.
 TEST_F(HashJoinTest, memoryUsage) {
@@ -4766,7 +5368,7 @@ TEST_F(HashJoinTest, spillFileSize) {
         .referenceQuery(
             "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
         .config(core::QueryConfig::kSpillStartPartitionBit, "48")
-        .config(core::QueryConfig::kJoinSpillPartitionBits, "3")
+        .config(core::QueryConfig::kSpillNumPartitionBits, "3")
         .config(
             core::QueryConfig::kMaxSpillFileSize, std::to_string(spillFileSize))
         .checkSpillStats(false)
@@ -4790,6 +5392,22 @@ TEST_F(HashJoinTest, spillFileSize) {
   }
 }
 
+TEST_F(HashJoinTest, spillPartitionBitsOverlap) {
+  auto builder =
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .keyTypes({BIGINT(), BIGINT()})
+          .probeVectors(2'000, 3)
+          .buildVectors(2'000, 3)
+          .referenceQuery(
+              "SELECT t_k0, t_k1, t_data, u_k0, u_k1, u_data FROM t, u WHERE t_k0 = u_k0 and t_k1 = u_k1")
+          .config(core::QueryConfig::kSpillStartPartitionBit, "8")
+          .config(core::QueryConfig::kSpillNumPartitionBits, "1")
+          .checkSpillStats(false)
+          .maxSpillLevel(0);
+  VELOX_ASSERT_THROW(builder.run(), "vs. 8");
+}
+
 // The test is to verify if the hash build reservation has been released on
 // task error.
 DEBUG_ONLY_TEST_F(HashJoinTest, buildReservationReleaseCheck) {
@@ -4816,19 +5434,18 @@ DEBUG_ONLY_TEST_F(HashJoinTest, buildReservationReleaseCheck) {
                             "",
                             concat(probeType_->names(), buildType_->names()))
                         .planNode();
-  params.queryCtx = std::make_shared<core::QueryCtx>(driverExecutor_.get());
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
   // NOTE: the spilling setup is to trigger memory reservation code path which
   // only gets executed when spilling is enabled. We don't care about if
   // spilling is really triggered in test or not.
   auto spillDirectory = exec::test::TempDirectoryPath::create();
-  params.spillDirectory = spillDirectory->path;
+  params.spillDirectory = spillDirectory->getPath();
   params.queryCtx->testingOverrideConfigUnsafe(
       {{core::QueryConfig::kSpillEnabled, "true"},
-       {core::QueryConfig::kMaxSpillLevel, "0"},
-       {core::QueryConfig::kJoinSpillEnabled, "true"}});
+       {core::QueryConfig::kMaxSpillLevel, "0"}});
   params.maxDrivers = 1;
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   auto* task = cursor->task().get();
 
   // Set up a testvalue to trigger task abort when hash build tries to reserve
@@ -4851,17 +5468,15 @@ TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
   auto rowVector = makeRowVector(
       {makeFlatVector<int64_t>(size, [&](auto row) { return row; })});
   createDuckDbTable("u", {rowVector});
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   std::vector<RowVectorPtr> buildVectors{
       makeRowVector({"c0"}, {makeFlatVector<int64_t>({0, 1, 2})})};
   createDuckDbTable("t", buildVectors);
-  auto split =
-      facebook::velox::exec::test::HiveConnectorSplitBuilder(filePaths[0]->path)
-          .partitionKey("k", "0")
-          .build();
+  auto split = facebook::velox::exec::test::HiveConnectorSplitBuilder(
+                   filePaths[0]->getPath())
+                   .partitionKey("k", "0")
+                   .build();
   auto outputType = ROW({"n1_0", "n1_1"}, {BIGINT(), BIGINT()});
-  std::shared_ptr<connector::hive::HiveTableHandle> tableHandle =
-      makeTableHandle();
   ColumnHandleMap assignments = {
       {"n1_0", regularColumn("c0", BIGINT())},
       {"n1_1", partitionKey("k", BIGINT())}};
@@ -4870,7 +5485,10 @@ TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   auto op =
       PlanBuilder(planNodeIdGenerator)
-          .tableScan(outputType, tableHandle, assignments)
+          .startTableScan()
+          .outputType(outputType)
+          .assignments(assignments)
+          .endTableScan()
           .capturePlanNodeId(probeScanId)
           .hashJoin(
               {"n1_1"},
@@ -4891,6 +5509,87 @@ TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
       .run();
 }
 
+TEST_F(HashJoinTest, probeMemoryLimitOnBuildProjection) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {makeFlatVector<int32_t>(1'000, [](auto row) { return row % 5; })});
+      });
+
+  // Build side has 4KB + 4B per row.
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"u_c0", "u_c1", {"u_c2"}},
+            {makeFlatVector<int32_t>({0, 1, 2}),
+             makeFlatVector<std::string>({
+                 std::string(4096, 'a'),
+                 std::string(4096, 'b'),
+                 std::string(4096, 'c'),
+             }),
+             makeFlatVector<std::string>({
+                 std::string(4096, 'd'),
+                 std::string(4096, 'e'),
+                 std::string(4096, 'f'),
+             })});
+      });
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  struct TestParam {
+    int32_t numVarSizeColumn;
+    int32_t numExpectedBatches;
+    std::string referenceQuery;
+    std::string debugString() const {
+      return fmt::format(
+          "numVarSizeColumn {}, numExpectedBatches {}, referenceQuery '{}'",
+          numVarSizeColumn,
+          numExpectedBatches,
+          referenceQuery);
+    }
+  };
+
+  std::vector<TestParam> testParams{
+      {0, 10, "SELECT t.c0 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {1, 3000, "SELECT t.c0, u.u_c1 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {2, 6000, "SELECT t.c0, u.u_c1, u.u_c2 FROM t JOIN u ON t.c0 = u.u_c0"}};
+  for (const auto& testParam : testParams) {
+    SCOPED_TRACE(testParam.debugString());
+    core::PlanNodeId joinNodeId;
+    std::vector<std::string> outputLayout;
+    outputLayout.push_back("c0");
+    for (int32_t i = 0; i < testParam.numVarSizeColumn; i++) {
+      outputLayout.push_back(fmt::format("u_c{}", i + 1));
+    }
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"c0"},
+                        {"u_c0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values({buildVectors})
+                            .planNode(),
+                        "",
+                        outputLayout)
+                    .capturePlanNodeId(joinNodeId)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(plan))
+        .config(core::QueryConfig::kPreferredOutputBatchBytes, "8192")
+        .injectSpill(false)
+        .referenceQuery(testParam.referenceQuery)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /* unused */) {
+          auto planStats = toPlanStats(task->taskStats());
+          auto outputBatches = planStats.at(joinNodeId).outputVectors;
+          ASSERT_EQ(outputBatches, testParam.numExpectedBatches);
+        })
+        .run();
+  }
+}
+
 DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
@@ -4928,7 +5627,8 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
     SCOPED_TRACE(testData.debugString());
 
     auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryPool = memory::defaultMemoryManager().addRootPool("", kMaxBytes);
+    auto queryPool = memory::memoryManager()->addRootPool(
+        "", kMaxBytes, memory::MemoryReclaimer::create());
 
     core::PlanNodeId probeScanId;
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -4955,7 +5655,6 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
         "facebook::velox::exec::Driver::runInternal::addInput",
         std::function<void(Operator*)>(([&](Operator* testOp) {
           if (testOp->operatorType() != "HashBuild") {
-            ASSERT_FALSE(testOp->canReclaim());
             return;
           }
           op = testOp;
@@ -4989,16 +5688,17 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
           .planNode(plan)
           .queryPool(std::move(queryPool))
           .injectSpill(false)
-          .spillDirectory(testData.spillEnabled ? tempDirectory->path : "")
+          .spillDirectory(testData.spillEnabled ? tempDirectory->getPath() : "")
           .referenceQuery(
               "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+          .config(core::QueryConfig::kSpillStartPartitionBit, "29")
           .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
             const auto statsPair = taskSpilledStats(*task);
             if (testData.expectedReclaimable) {
               ASSERT_GT(statsPair.first.spilledBytes, 0);
-              ASSERT_EQ(statsPair.first.spilledPartitions, 4);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 8);
               ASSERT_GT(statsPair.second.spilledBytes, 0);
-              ASSERT_EQ(statsPair.second.spilledPartitions, 4);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 8);
               verifyTaskSpilledRuntimeStats(*task, true);
             } else {
               ASSERT_EQ(statsPair.first.spilledBytes, 0);
@@ -5029,10 +5729,17 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
     }
 
     if (testData.expectedReclaimable) {
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-          reclaimerStats_);
-      ASSERT_EQ(op->pool()->currentBytes(), 0);
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        op->pool()->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+            0,
+            reclaimerStats_);
+      }
+      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+      ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+      reclaimerStats_.reset();
+      ASSERT_EQ(op->pool()->usedBytes(), 0);
     } else {
       VELOX_ASSERT_THROW(
           op->reclaim(
@@ -5054,7 +5761,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
   const int32_t numBuildVectors = 3;
   std::vector<RowVectorPtr> buildVectors;
   for (int32_t i = 0; i < numBuildVectors; ++i) {
-    const size_t size = i == 0 ? 100 : 40000;
+    const size_t size = i == 0 ? 1 : 1'000;
     VectorFuzzer fuzzer({.vectorSize = size}, pool());
     buildVectors.push_back(fuzzer.fuzzRow(buildType_));
   }
@@ -5062,7 +5769,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
   const int32_t numProbeVectors = 3;
   std::vector<RowVectorPtr> probeVectors;
   for (int32_t i = 0; i < numProbeVectors; ++i) {
-    VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+    VectorFuzzer fuzzer({.vectorSize = 1'000}, pool());
     probeVectors.push_back(fuzzer.fuzzRow(probeType_));
   }
 
@@ -5070,9 +5777,9 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
   createDuckDbTable("u", buildVectors);
 
   auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryPool = memory::defaultMemoryManager().addRootPool("", kMaxBytes);
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
 
-  core::PlanNodeId probeScanId;
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   auto plan = PlanBuilder(planNodeIdGenerator)
                   .values(probeVectors, false)
@@ -5087,16 +5794,15 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
                   .planNode();
 
   folly::EventCount driverWait;
-  auto driverWaitKey = driverWait.prepareWait();
+  std::atomic_bool driverWaitFlag{true};
   folly::EventCount testWait;
-  auto testWaitKey = testWait.prepareWait();
+  std::atomic_bool testWaitFlag{true};
 
-  Operator* op;
+  Operator* op{nullptr};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal::addInput",
       std::function<void(Operator*)>(([&](Operator* testOp) {
         if (testOp->operatorType() != "HashBuild") {
-          ASSERT_FALSE(testOp->canReclaim());
           return;
         }
         op = testOp;
@@ -5108,22 +5814,27 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
       std::function<void(memory::MemoryPoolImpl*)>(
           ([&](memory::MemoryPoolImpl* pool) {
             ASSERT_TRUE(op != nullptr);
-            const std::string re(".*HashBuild");
-            if (!RE2::FullMatch(pool->name(), re)) {
+            if (!isHashBuildMemoryPool(*pool)) {
+              return;
+            }
+            ASSERT_TRUE(op->canReclaim());
+            if (op->pool()->usedBytes() == 0) {
+              // We skip trigger memory reclaim when the hash table is empty on
+              // memory reservation.
               return;
             }
             if (!injectOnce.exchange(false)) {
               return;
             }
-            ASSERT_TRUE(op->canReclaim());
             uint64_t reclaimableBytes{0};
             const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
             ASSERT_TRUE(reclaimable);
             ASSERT_GT(reclaimableBytes, 0);
             auto* driver = op->testingOperatorCtx()->driver();
             SuspendedSection suspendedSection(driver);
-            testWait.notify();
-            driverWait.wait(driverWaitKey);
+            testWaitFlag = false;
+            testWait.notifyAll();
+            driverWait.await([&]() { return !driverWaitFlag.load(); });
           })));
 
   std::thread taskThread([&]() {
@@ -5132,25 +5843,25 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
         .planNode(plan)
         .queryPool(std::move(queryPool))
         .injectSpill(false)
-        .spillDirectory(tempDirectory->path)
+        .spillDirectory(tempDirectory->getPath())
         .referenceQuery(
             "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
         .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
           const auto statsPair = taskSpilledStats(*task);
           ASSERT_GT(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 4);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 8);
           ASSERT_GT(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 4);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 8);
           verifyTaskSpilledRuntimeStats(*task, true);
         })
         .run();
   });
 
-  testWait.wait(testWaitKey);
+  testWait.await([&]() { return !testWaitFlag.load(); });
   ASSERT_TRUE(op != nullptr);
   auto task = op->testingOperatorCtx()->task();
-  auto taskPauseWait = task->requestPause();
-  taskPauseWait.wait();
+  task->requestPause().wait();
 
   uint64_t reclaimableBytes{0};
   const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
@@ -5158,16 +5869,23 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
   ASSERT_TRUE(reclaimable);
   ASSERT_GT(reclaimableBytes, 0);
 
-  op->reclaim(
-      folly::Random::oneIn(2) ? 0 : folly::Random::rand32(), reclaimerStats_);
-  ASSERT_EQ(op->pool()->currentBytes(), 0);
-
-  driverWait.notify();
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    op->pool()->reclaim(
+        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+        0,
+        reclaimerStats_);
+  }
+  ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+  ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+  ASSERT_EQ(op->pool()->usedBytes(), 0);
+
+  driverWaitFlag = false;
+  driverWait.notifyAll();
   Task::resume(task);
   task.reset();
 
   taskThread.join();
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{});
 }
 
 DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
@@ -5187,12 +5905,12 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
 
-  std::vector<bool> enableSpillings = {false, true};
+  const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
 
     auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryPool = memory::defaultMemoryManager().addRootPool("", kMaxBytes);
+    auto queryPool = memory::memoryManager()->addRootPool("", kMaxBytes);
 
     core::PlanNodeId probeScanId;
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -5218,7 +5936,6 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
         "facebook::velox::exec::Driver::runInternal::addInput",
         std::function<void(Operator*)>(([&](Operator* testOp) {
           if (testOp->operatorType() != "HashBuild") {
-            ASSERT_FALSE(testOp->canReclaim());
             return;
           }
           op = testOp;
@@ -5258,7 +5975,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
           .planNode(plan)
           .queryPool(std::move(queryPool))
           .injectSpill(false)
-          .spillDirectory(enableSpilling ? tempDirectory->path : "")
+          .spillDirectory(enableSpilling ? tempDirectory->getPath() : "")
           .referenceQuery(
               "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
           .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
@@ -5284,17 +6001,14 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
     ASSERT_EQ(reclaimable, enableSpilling);
     if (enableSpilling) {
       ASSERT_GE(reclaimableBytes, 0);
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-          reclaimerStats_);
     } else {
-      VELOX_ASSERT_THROW(
-          op->reclaim(
-              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-              reclaimerStats_),
-          "");
       ASSERT_EQ(reclaimableBytes, 0);
     }
+    VELOX_ASSERT_THROW(
+        op->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+            reclaimerStats_),
+        "");
 
     driverWait.notify();
     Task::resume(task);
@@ -5302,7 +6016,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
 
     taskThread.join();
   }
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{1});
+  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{0});
 }
 
 DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
@@ -5322,11 +6036,12 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
 
-  std::vector<bool> enableSpillings = {false, true};
+  const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
     auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryPool = memory::defaultMemoryManager().addRootPool("", kMaxBytes);
+    auto queryPool = memory::memoryManager()->addRootPool(
+        "", kMaxBytes, memory::MemoryReclaimer::create());
 
     core::PlanNodeId probeScanId;
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -5342,10 +6057,10 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
                         concat(probeType_->names(), buildType_->names()))
                     .planNode();
 
+    std::atomic_bool driverWaitFlag{true};
     folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
+    std::atomic_bool testWaitFlag{true};
     folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
 
     std::atomic<bool> injectOnce{true};
     Operator* op;
@@ -5353,7 +6068,6 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
         "facebook::velox::exec::Driver::runInternal::noMoreInput",
         std::function<void(Operator*)>(([&](Operator* testOp) {
           if (testOp->operatorType() != "HashBuild") {
-            ASSERT_FALSE(testOp->canReclaim());
             return;
           }
           op = testOp;
@@ -5369,8 +6083,9 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
           } else {
             ASSERT_EQ(reclaimableBytes, 0);
           }
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
+          testWaitFlag = false;
+          testWait.notifyAll();
+          driverWait.await([&]() { return !testWaitFlag.load(); });
         })));
 
     std::thread taskThread([&]() {
@@ -5379,7 +6094,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
           .planNode(plan)
           .queryPool(std::move(queryPool))
           .injectSpill(false)
-          .spillDirectory(enableSpilling ? tempDirectory->path : "")
+          .spillDirectory(enableSpilling ? tempDirectory->getPath() : "")
           .referenceQuery(
               "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
           .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
@@ -5393,11 +6108,12 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
           .run();
     });
 
-    testWait.wait(testWaitKey);
+    testWait.await([&]() { return !testWaitFlag.load(); });
     ASSERT_TRUE(op != nullptr);
     auto task = op->testingOperatorCtx()->task();
     auto taskPauseWait = task->requestPause();
-    driverWait.notify();
+    driverWaitFlag = false;
+    driverWait.notifyAll();
     taskPauseWait.wait();
 
     uint64_t reclaimableBytes{0};
@@ -5407,12 +6123,18 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
 
     if (enableSpilling) {
       ASSERT_GT(reclaimableBytes, 0);
-      const auto usedMemoryBytes = op->pool()->currentBytes();
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
-          reclaimerStats_);
+      const auto usedMemoryBytes = op->pool()->usedBytes();
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        op->pool()->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+            0,
+            reclaimerStats_);
+      }
+      ASSERT_GE(reclaimerStats_.reclaimedBytes, 0);
+      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
       // No reclaim as the operator has started output processing.
-      ASSERT_EQ(usedMemoryBytes, op->pool()->currentBytes());
+      ASSERT_EQ(usedMemoryBytes, op->pool()->usedBytes());
     } else {
       ASSERT_EQ(reclaimableBytes, 0);
       VELOX_ASSERT_THROW(
@@ -5427,7 +6149,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
 
     taskThread.join();
   }
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{1});
+  ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
 }
 
 DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
@@ -5448,7 +6170,8 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
   createDuckDbTable("u", buildVectors);
 
   auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryPool = memory::defaultMemoryManager().addRootPool("", kMaxBytes);
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
 
   core::PlanNodeId probeScanId;
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -5464,10 +6187,10 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
                       concat(probeType_->names(), buildType_->names()))
                   .planNode();
 
+  std::atomic_bool driverWaitFlag{true};
   folly::EventCount driverWait;
-  auto driverWaitKey = driverWait.prepareWait();
+  std::atomic_bool testWaitFlag{true};
   folly::EventCount testWait;
-  auto testWaitKey = testWait.prepareWait();
 
   Operator* op;
   std::atomic<bool> injectSpillOnce{true};
@@ -5475,7 +6198,6 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
       "facebook::velox::exec::Driver::runInternal::addInput",
       std::function<void(Operator*)>(([&](Operator* testOp) {
         if (testOp->operatorType() != "HashBuild") {
-          ASSERT_FALSE(testOp->canReclaim());
           return;
         }
         op = testOp;
@@ -5484,6 +6206,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
         }
         auto* driver = op->testingOperatorCtx()->driver();
         auto task = driver->task();
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
         SuspendedSection suspendedSection(driver);
         auto taskPauseWait = task->requestPause();
         taskPauseWait.wait();
@@ -5498,7 +6221,6 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
         if (testOp->operatorType() != "HashProbe") {
           return;
         }
-        ASSERT_FALSE(testOp->canReclaim());
         if (!injectOnce.exchange(false)) {
           return;
         }
@@ -5508,11 +6230,12 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
         const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
         ASSERT_TRUE(reclaimable);
         ASSERT_GT(reclaimableBytes, 0);
-        testWait.notify();
+        testWaitFlag = false;
+        testWait.notifyAll();
         auto* driver = testOp->testingOperatorCtx()->driver();
         auto task = driver->task();
         SuspendedSection suspendedSection(driver);
-        driverWait.wait(driverWaitKey);
+        driverWait.await([&]() { return !driverWaitFlag.load(); });
       })));
 
   std::thread taskThread([&]() {
@@ -5521,20 +6244,21 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
         .planNode(plan)
         .queryPool(std::move(queryPool))
         .injectSpill(false)
-        .spillDirectory(tempDirectory->path)
+        .spillDirectory(tempDirectory->getPath())
         .referenceQuery(
             "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
         .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
           const auto statsPair = taskSpilledStats(*task);
           ASSERT_GT(statsPair.first.spilledBytes, 0);
-          ASSERT_EQ(statsPair.first.spilledPartitions, 4);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 8);
           ASSERT_GT(statsPair.second.spilledBytes, 0);
-          ASSERT_EQ(statsPair.second.spilledPartitions, 4);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 8);
         })
         .run();
   });
 
-  testWait.wait(testWaitKey);
+  testWait.await([&]() { return !testWaitFlag.load(); });
   ASSERT_TRUE(op != nullptr);
   auto task = op->testingOperatorCtx()->task();
   auto taskPauseWait = task->requestPause();
@@ -5546,33 +6270,32 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
   ASSERT_TRUE(reclaimable);
   ASSERT_GT(reclaimableBytes, 0);
 
-  const auto usedMemoryBytes = op->pool()->currentBytes();
-  op->reclaim(
-      folly::Random::oneIn(2) ? 0 : folly::Random::rand32(), reclaimerStats_);
-  // No reclaim as the build operator is not in building table state.
-  ASSERT_EQ(usedMemoryBytes, op->pool()->currentBytes());
-
-  driverWait.notify();
+  const auto usedMemoryBytes = op->pool()->usedBytes();
+  reclaimerStats_.reset();
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    op->pool()->reclaim(
+        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+        0,
+        reclaimerStats_);
+  }
+  ASSERT_GE(reclaimerStats_.reclaimedBytes, 0);
+  ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+  //  No reclaim as the build operator is not in building table state.
+  ASSERT_EQ(usedMemoryBytes, op->pool()->usedBytes());
+
+  driverWaitFlag = false;
+  driverWait.notifyAll();
   Task::resume(task);
   task.reset();
 
   taskThread.join();
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{1});
+  ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
 }
 
 DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
+  const auto buildVectors = makeVectors(buildType_, 10, 128);
+  const auto probeVectors = makeVectors(probeType_, 5, 128);
 
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
@@ -5591,10 +6314,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto queryPool = memory::defaultMemoryManager().addRootPool(
-        "", kMaxBytes, memory::MemoryReclaimer::create());
 
-    core::PlanNodeId probeScanId;
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     auto plan = PlanBuilder(planNodeIdGenerator)
                     .values(probeVectors, true)
@@ -5608,76 +6328,50 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
                         concat(probeType_->names(), buildType_->names()))
                     .planNode();
 
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
-
     std::atomic<bool> injectOnce{true};
-    Operator* op;
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::noMoreInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "HashBuild") {
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashBuild") {
             return;
           }
-          op = testOp;
           if (!injectOnce.exchange(false)) {
             return;
           }
+          ASSERT_GT(op->pool()->usedBytes(), 0);
           auto* driver = op->testingOperatorCtx()->driver();
           ASSERT_EQ(
               driver->task()->enterSuspended(driver->state()),
               StopReason::kNone);
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          // We can't directly reclaim memory from this hash build operator as
+          // its driver thread is running and in suspension state.
+          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
           ASSERT_EQ(
               driver->task()->leaveSuspended(driver->state()),
               StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
           VELOX_MEM_POOL_ABORTED("Memory pool aborted");
         })));
 
-    std::thread taskThread([&]() {
-      VELOX_ASSERT_THROW(
-          HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-              .numDrivers(numDrivers_)
-              .planNode(plan)
-              .queryPool(std::move(queryPool))
-              .injectSpill(false)
-              .referenceQuery(
-                  "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-              .run(),
-          "");
-    });
-
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->testingOperatorCtx()->task();
-    testData.abortFromRootMemoryPool ? abortPool(queryPool.get())
-                                     : abortPool(op->pool());
-    ASSERT_TRUE(op->pool()->aborted());
-    ASSERT_TRUE(queryPool->aborted());
-    ASSERT_EQ(queryPool->currentBytes(), 0);
-    driverWait.notify();
-    taskThread.join();
-    task.reset();
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .planNode(plan)
+            .injectSpill(false)
+            .referenceQuery(
+                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+            .run(),
+        "Manual MemoryPool Abortion");
     waitForAllTasksToBeDeleted();
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringInputgProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
+DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringInputProcessing) {
+  const auto buildVectors = makeVectors(buildType_, 10, 128);
+  const auto probeVectors = makeVectors(probeType_, 5, 128);
 
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
@@ -5696,10 +6390,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringInputgProcessing) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto queryPool = memory::defaultMemoryManager().addRootPool(
-        "", kMaxBytes, memory::MemoryReclaimer::create());
 
-    core::PlanNodeId probeScanId;
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     auto plan = PlanBuilder(planNodeIdGenerator)
                     .values(probeVectors, true)
@@ -5713,77 +6404,51 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringInputgProcessing) {
                         concat(probeType_->names(), buildType_->names()))
                     .planNode();
 
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
-
     std::atomic<int> numInputs{0};
-    Operator* op;
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "HashBuild") {
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashBuild") {
             return;
           }
-          op = testOp;
-          ++numInputs;
-          if (numInputs != 2) {
+          if (++numInputs != 2) {
             return;
           }
+          ASSERT_GT(op->pool()->usedBytes(), 0);
           auto* driver = op->testingOperatorCtx()->driver();
           ASSERT_EQ(
               driver->task()->enterSuspended(driver->state()),
               StopReason::kNone);
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          // We can't directly reclaim memory from this hash build operator as
+          // its driver thread is running and in suspension state.
+          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
           ASSERT_EQ(
               driver->task()->leaveSuspended(driver->state()),
               StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
           VELOX_MEM_POOL_ABORTED("Memory pool aborted");
         })));
 
-    std::thread taskThread([&]() {
-      VELOX_ASSERT_THROW(
-          HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-              .numDrivers(numDrivers_)
-              .planNode(plan)
-              .queryPool(std::move(queryPool))
-              .injectSpill(false)
-              .referenceQuery(
-                  "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-              .run(),
-          "");
-    });
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .planNode(plan)
+            .injectSpill(false)
+            .referenceQuery(
+                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+            .run(),
+        "Manual MemoryPool Abortion");
 
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->testingOperatorCtx()->task();
-    testData.abortFromRootMemoryPool ? abortPool(queryPool.get())
-                                     : abortPool(op->pool());
-    ASSERT_TRUE(op->pool()->aborted());
-    ASSERT_TRUE(queryPool->aborted());
-    ASSERT_EQ(queryPool->currentBytes(), 0);
-    driverWait.notify();
-    taskThread.join();
-    task.reset();
     waitForAllTasksToBeDeleted();
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeAbortDuringInputProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBuildVectors = 10;
-  std::vector<RowVectorPtr> buildVectors;
-  for (int32_t i = 0; i < numBuildVectors; ++i) {
-    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
-  }
-  const int32_t numProbeVectors = 5;
-  std::vector<RowVectorPtr> probeVectors;
-  for (int32_t i = 0; i < numProbeVectors; ++i) {
-    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
-  }
+DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringAllocation) {
+  const auto buildVectors = makeVectors(buildType_, 10, 128);
+  const auto probeVectors = makeVectors(probeType_, 5, 128);
 
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", buildVectors);
@@ -5802,10 +6467,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeAbortDuringInputProcessing) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto queryPool = memory::defaultMemoryManager().addRootPool(
-        "", kMaxBytes, memory::MemoryReclaimer::create());
 
-    core::PlanNodeId probeScanId;
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     auto plan = PlanBuilder(planNodeIdGenerator)
                     .values(probeVectors, true)
@@ -5819,60 +6481,117 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeAbortDuringInputProcessing) {
                         concat(probeType_->names(), buildType_->names()))
                     .planNode();
 
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
+    std::atomic_bool injectOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+        std::function<void(memory::MemoryPoolImpl*)>(
+            ([&](memory::MemoryPoolImpl* pool) {
+              if (!isHashBuildMemoryPool(*pool)) {
+                return;
+              }
+              if (!injectOnce.exchange(false)) {
+                return;
+              }
+
+              auto& driverCtx = driverThreadContext()->driverCtx;
+              ASSERT_EQ(
+                  driverCtx.task->enterSuspended(driverCtx.driver->state()),
+                  StopReason::kNone);
+              testData.abortFromRootMemoryPool ? abortPool(pool->root())
+                                               : abortPool(pool);
+              // We can't directly reclaim memory from this hash build operator
+              // as its driver thread is running and in suspegnsion state.
+              ASSERT_GE(pool->root()->usedBytes(), 0);
+              ASSERT_EQ(
+                  driverCtx.task->leaveSuspended(driverCtx.driver->state()),
+                  StopReason::kAlreadyTerminated);
+              ASSERT_TRUE(pool->aborted());
+              ASSERT_TRUE(pool->root()->aborted());
+              VELOX_MEM_POOL_ABORTED("Memory pool aborted");
+            })));
+
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .planNode(plan)
+            .injectSpill(false)
+            .referenceQuery(
+                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+            .run(),
+        "Manual MemoryPool Abortion");
+
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeAbortDuringInputProcessing) {
+  const auto buildVectors = makeVectors(buildType_, 10, 128);
+  const auto probeVectors = makeVectors(probeType_, 5, 128);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  struct {
+    bool abortFromRootMemoryPool;
+    int numDrivers;
+
+    std::string debugString() const {
+      return fmt::format(
+          "abortFromRootMemoryPool {} numDrivers {}",
+          abortFromRootMemoryPool,
+          numDrivers);
+    }
+  } testSettings[] = {{true, 1}, {false, 1}, {true, 4}, {false, 4}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        "",
+                        concat(probeType_->names(), buildType_->names()))
+                    .planNode();
 
     std::atomic<int> numInputs{0};
-    Operator* op;
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "HashProbe") {
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashProbe") {
             return;
           }
-          op = testOp;
-          ++numInputs;
-          if (numInputs != 2) {
+          if (++numInputs != 2) {
             return;
           }
           auto* driver = op->testingOperatorCtx()->driver();
           ASSERT_EQ(
               driver->task()->enterSuspended(driver->state()),
               StopReason::kNone);
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
           ASSERT_EQ(
               driver->task()->leaveSuspended(driver->state()),
               StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
           VELOX_MEM_POOL_ABORTED("Memory pool aborted");
         })));
 
-    std::thread taskThread([&]() {
-      VELOX_ASSERT_THROW(
-          HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
-              .numDrivers(numDrivers_)
-              .planNode(plan)
-              .queryPool(std::move(queryPool))
-              .injectSpill(false)
-              .referenceQuery(
-                  "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
-              .run(),
-          "");
-    });
-
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->testingOperatorCtx()->task();
-    testData.abortFromRootMemoryPool ? abortPool(queryPool.get())
-                                     : abortPool(op->pool());
-    ASSERT_TRUE(op->pool()->aborted());
-    ASSERT_TRUE(queryPool->aborted());
-    ASSERT_EQ(queryPool->currentBytes(), 0);
-    driverWait.notify();
-    taskThread.join();
-    task.reset();
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .planNode(plan)
+            .injectSpill(false)
+            .referenceQuery(
+                "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+            .run(),
+        "Manual MemoryPool Abortion");
     waitForAllTasksToBeDeleted();
   }
 }
@@ -5908,7 +6627,6 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
         .planNode(plan)
         .injectSpill(false)
         .checkSpillStats(false)
-        .spillMemoryThreshold(1)
         .maxSpillLevel(0)
         .numDrivers(1)
         .config(
@@ -5960,7 +6678,6 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
         .planNode(plan)
         .injectSpill(false)
         .checkSpillStats(false)
-        .spillMemoryThreshold(1)
         .maxSpillLevel(0)
         .numDrivers(1)
         .config(
@@ -5978,4 +6695,1477 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
   // with tk_2 = 4 to get written.
   test("t_k2 != 4 and t_k2 != 8");
 }
+
+TEST_F(HashJoinTest, leftJoinPreserveProbeOrder) {
+  const std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector(
+          {"k1", "v1"},
+          {
+              makeConstant<int64_t>(0, 2),
+              makeFlatVector<int64_t>({1, 0}),
+          }),
+  };
+  const std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector(
+          {"k2", "v2"},
+          {
+              makeConstant<int64_t>(0, 2),
+              makeConstant<int64_t>(0, 2),
+          }),
+  };
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(probeVectors)
+          .hashJoin(
+              {"k1"},
+              {"k2"},
+              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+              "v1 % 2 = v2 % 2",
+              {"v1"},
+              core::JoinType::kLeft)
+          .planNode();
+  auto result = AssertQueryBuilder(plan)
+                    .config(core::QueryConfig::kPreferredOutputBatchRows, "1")
+                    .serialExecution(true)
+                    .copyResults(pool_.get());
+  ASSERT_EQ(result->size(), 3);
+  auto* v1 =
+      result->childAt(0)->loadedVector()->asUnchecked<SimpleVector<int64_t>>();
+  ASSERT_FALSE(v1->mayHaveNulls());
+  ASSERT_EQ(v1->valueAt(0), 1);
+  ASSERT_EQ(v1->valueAt(1), 0);
+  ASSERT_EQ(v1->valueAt(2), 0);
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 10;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzInputRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzInputRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, false)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  for (int32_t minSpillableReservationPct : {5, 50, 100}) {
+    SCOPED_TRACE(fmt::format(
+        "minSpillableReservationPct: {}", minSpillableReservationPct));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::HashBuild::addInput",
+        std::function<void(exec::HashBuild*)>(([&](exec::HashBuild* hashBuild) {
+          memory::MemoryPool* pool = hashBuild->pool();
+          const auto availableReservationBytes = pool->availableReservation();
+          const auto currentUsedBytes = pool->usedBytes();
+          // Verifies we always have min reservation after ensuring the input.
+          ASSERT_GE(
+              availableReservationBytes,
+              currentUsedBytes * minSpillableReservationPct / 100);
+        })));
+
+    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .planNode(plan)
+        .injectSpill(false)
+        .spillDirectory(tempDirectory->getPath())
+        .referenceQuery(
+            "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, exceededMaxSpillLevel) {
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 10;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, false)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  const int exceededMaxSpillLevelCount =
+      common::globalSpillStats().spillMaxLevelExceededCount;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::addInput",
+      std::function<void(exec::HashBuild*)>(([&](exec::HashBuild* hashBuild) {
+        Operator::ReclaimableSectionGuard guard(hashBuild);
+        testingRunArbitration(hashBuild->pool());
+      })));
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .planNode(plan)
+      // Always trigger spilling.
+      .injectSpill(false)
+      .maxSpillLevel(0)
+      .spillDirectory(tempDirectory->getPath())
+      .referenceQuery(
+          "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_EQ(
+            opStats.at("HashProbe")
+                .runtimeStats[Operator::kExceededMaxSpillLevel]
+                .sum,
+            8);
+        ASSERT_EQ(
+            opStats.at("HashProbe")
+                .runtimeStats[Operator::kExceededMaxSpillLevel]
+                .count,
+            1);
+        ASSERT_EQ(
+            opStats.at("HashBuild")
+                .runtimeStats[Operator::kExceededMaxSpillLevel]
+                .sum,
+            8);
+        ASSERT_EQ(
+            opStats.at("HashBuild")
+                .runtimeStats[Operator::kExceededMaxSpillLevel]
+                .count,
+            1);
+      })
+      .run();
+  ASSERT_EQ(
+      common::globalSpillStats().spillMaxLevelExceededCount,
+      exceededMaxSpillLevelCount + 16);
+}
+
+TEST_F(HashJoinTest, maxSpillBytes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto probeVectors = createVectors(rowType, 1024, 10 << 20);
+  const auto buildVectors = createVectors(rowType, 1024, 10 << 20);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, true)
+                  .project({"c0", "c1", "c2"})
+                  .hashJoin(
+                      {"c0"},
+                      {"u1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, true)
+                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                          .planNode(),
+                      "",
+                      {"c0", "c1", "c2"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {16 << 20, true}, {0, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kJoinSpillEnabled, true)
+          .config(core::QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find(
+              "Query exceeded per-query local spill limit of 16.00MB"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+  }
+}
+
+TEST_F(HashJoinTest, onlyHashBuildMaxSpillBytes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto probeVectors = createVectors(rowType, 32, 128);
+  const auto buildVectors = createVectors(rowType, 1024, 10 << 20);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, true)
+                  .hashJoin(
+                      {"c0"},
+                      {"u1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, true)
+                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                          .planNode(),
+                      "",
+                      {"c0", "c1", "c2"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {16 << 20, true}, {0, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kJoinSpillEnabled, true)
+          .config(core::QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find(
+              "Query exceeded per-query local spill limit of 16.00MB"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+  }
+}
+
+TEST_F(HashJoinTest, reclaimFromJoinBuilderWithMultiDrivers) {
+  auto rowType = ROW({
+      {"c0", INTEGER()},
+      {"c1", INTEGER()},
+      {"c2", VARCHAR()},
+  });
+  const auto vectors = createVectors(rowType, 64 << 20, fuzzerOpts_);
+  const int numDrivers = 4;
+
+  memory::MemoryManagerOptions options;
+  options.allocatorCapacity = 8L << 30;
+  auto memoryManagerWithoutArbitrator =
+      std::make_unique<memory::MemoryManager>(options);
+  const auto expectedResult =
+      runHashJoinTask(
+          vectors,
+          newQueryCtx(
+              memoryManagerWithoutArbitrator.get(), executor_.get(), 8L << 30),
+          false,
+          numDrivers,
+          pool(),
+          false)
+          .data;
+
+  auto memoryManagerWithArbitrator = createMemoryManager();
+  const auto& arbitrator = memoryManagerWithArbitrator->arbitrator();
+  // Create a query ctx with a small capacity to trigger spilling.
+  auto result = runHashJoinTask(
+      vectors,
+      newQueryCtx(
+          memoryManagerWithArbitrator.get(), executor_.get(), 128 << 20),
+      false,
+      numDrivers,
+      pool(),
+      true,
+      expectedResult);
+  auto taskStats = exec::toPlanStats(result.task->taskStats());
+  auto& planStats = taskStats.at(result.planNodeId);
+  ASSERT_GT(planStats.spilledBytes, 0);
+  result.task.reset();
+
+  // This test uses on-demand created memory manager instead of the global
+  // one. We need to make sure any used memory got cleaned up before exiting
+  // the scope
+  waitForAllTasksToBeDeleted();
+  ASSERT_GT(arbitrator->stats().numRequests, 0);
+  ASSERT_GT(arbitrator->stats().numReclaimedBytes, 0);
+}
+
+DEBUG_ONLY_TEST_F(
+    HashJoinTest,
+    failedToReclaimFromHashJoinBuildersInNonReclaimableSection) {
+  auto rowType = ROW({
+      {"c0", INTEGER()},
+      {"c1", INTEGER()},
+      {"c2", VARCHAR()},
+  });
+  const auto vectors = createVectors(rowType, 64 << 20, fuzzerOpts_);
+  const int numDrivers = 1;
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memory::memoryManager(), executor_.get(), 512 << 20);
+  const auto expectedResult =
+      runHashJoinTask(vectors, queryCtx, false, numDrivers, pool(), false).data;
+
+  std::atomic_bool nonReclaimableSectionWaitFlag{true};
+  std::atomic_bool reclaimerInitializationWaitFlag{true};
+  folly::EventCount nonReclaimableSectionWait;
+  std::atomic_bool memoryArbitrationWaitFlag{true};
+  folly::EventCount memoryArbitrationWait;
+
+  std::atomic<uint32_t> numInitializedDrivers{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal",
+      std::function<void(exec::Driver*)>([&](exec::Driver* driver) {
+        numInitializedDrivers++;
+        // We need to make sure reclaimers on both build and probe side are set
+        // (in Operator::initialize) to avoid race conditions, producing
+        // consistent test results.
+        if (numInitializedDrivers.load() == 2) {
+          reclaimerInitializationWaitFlag = false;
+          nonReclaimableSectionWait.notifyAll();
+        }
+      }));
+
+  std::atomic<bool> injectNonReclaimableSectionOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+      std::function<void(memory::MemoryPoolImpl*)>(
+          ([&](memory::MemoryPoolImpl* pool) {
+            if (!isHashBuildMemoryPool(*pool)) {
+              return;
+            }
+            if (!injectNonReclaimableSectionOnce.exchange(false)) {
+              return;
+            }
+
+            // Signal the test control that one of the hash build operator has
+            // entered into non-reclaimable section.
+            nonReclaimableSectionWaitFlag = false;
+            nonReclaimableSectionWait.notifyAll();
+
+            // Suspend the driver to simulate the arbitration.
+            pool->reclaimer()->enterArbitration();
+            // Wait for the memory arbitration to complete.
+            memoryArbitrationWait.await(
+                [&]() { return !memoryArbitrationWaitFlag.load(); });
+            pool->reclaimer()->leaveArbitration();
+          })));
+
+  std::thread joinThread([&]() {
+    const auto result = runHashJoinTask(
+        vectors, queryCtx, false, numDrivers, pool(), true, expectedResult);
+    auto taskStats = exec::toPlanStats(result.task->taskStats());
+    auto& planStats = taskStats.at(result.planNodeId);
+    ASSERT_EQ(planStats.spilledBytes, 0);
+  });
+
+  // Wait for the hash build operators to enter into non-reclaimable section.
+  nonReclaimableSectionWait.await([&]() {
+    return (
+        !nonReclaimableSectionWaitFlag.load() &&
+        !reclaimerInitializationWaitFlag.load());
+  });
+
+  // We expect capacity grow fails as we can't reclaim from hash join operators.
+  memory::testingRunArbitration();
+
+  // Notify the hash build operator that memory arbitration has been done.
+  memoryArbitrationWaitFlag = false;
+  memoryArbitrationWait.notifyAll();
+
+  joinThread.join();
+
+  // This test uses on-demand created memory manager instead of the global
+  // one. We need to make sure any used memory got cleaned up before exiting
+  // the scope
+  waitForAllTasksToBeDeleted();
+  ASSERT_EQ(
+      memory::memoryManager()->arbitrator()->stats().numNonReclaimableAttempts,
+      2);
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringTableBuild) {
+  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
+  const int32_t numBuildVectors = 5;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+  const int32_t numProbeVectors = 5;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors, false)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  std::atomic_bool injectSpillOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!injectSpillOnce.exchange(false)) {
+          return;
+        }
+        Operator::ReclaimableSectionGuard guard(op);
+        testingRunArbitration(op->pool());
+      }));
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(4)
+      .planNode(plan)
+      .injectSpill(false)
+      .maxSpillLevel(0)
+      .spillDirectory(tempDirectory->getPath())
+      .referenceQuery(
+          "SELECT t_k1, t_k2, t_v1, u_k1, u_k2, u_v1 FROM t, u WHERE t.t_k1 = u.u_k1")
+      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_GT(
+            opStats.at("HashBuild").runtimeStats[Operator::kSpillWrites].sum,
+            0);
+      })
+      .run();
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, exceptionDuringFinishJoinBuild) {
+  // This test is to make sure there is no memory leak when exceptions are
+  // thrown while parallelly preparing join table.
+  auto memoryManager = memory::memoryManager();
+  const auto& arbitrator = memoryManager->arbitrator();
+  const uint64_t numDrivers = 2;
+  const auto expectedFreeCapacityBytes = arbitrator->stats().freeCapacityBytes;
+
+  const uint64_t numBuildSideRows = 500;
+  auto buildKeyVector = makeFlatVector<int64_t>(
+      numBuildSideRows,
+      [](vector_size_t row) { return folly::Random::rand64(); });
+  auto buildSideVector =
+      makeRowVector({"b0", "b1"}, {buildKeyVector, buildKeyVector});
+  std::vector<RowVectorPtr> buildSideVectors;
+  for (int i = 0; i < numDrivers; ++i) {
+    buildSideVectors.push_back(buildSideVector);
+  }
+  createDuckDbTable("build", buildSideVectors);
+
+  const uint64_t numProbeSideRows = 10;
+  auto probeKeyVector = makeFlatVector<int64_t>(
+      numProbeSideRows,
+      [&](vector_size_t row) { return buildKeyVector->valueAt(row); });
+  auto probeSideVector =
+      makeRowVector({"p0", "p1"}, {probeKeyVector, probeKeyVector});
+  std::vector<RowVectorPtr> probeSideVectors;
+  for (int i = 0; i < numDrivers; ++i) {
+    probeSideVectors.push_back(probeSideVector);
+  }
+  createDuckDbTable("probe", probeSideVectors);
+
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
+
+  // We set the task to fail right before we reserve memory for other operators.
+  // We rely on the driver suspension before parallel join build to throw
+  // exceptions (suspension on an already terminated task throws).
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::ensureTableFits",
+      std::function<void(HashBuild*)>([&](HashBuild* buildOp) {
+        try {
+          VELOX_FAIL("Simulated failure");
+        } catch (VeloxException& e) {
+          buildOp->testingOperatorCtx()->task()->setError(
+              std::current_exception());
+        }
+      }));
+
+  std::vector<RowVectorPtr> probeInput = {probeSideVector};
+  std::vector<RowVectorPtr> buildInput = {buildSideVector};
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kJoinSpillEnabled, true)
+          .queryCtx(
+              newQueryCtx(memoryManager, executor_.get(), kMemoryCapacity))
+          .maxDrivers(numDrivers)
+          .plan(PlanBuilder(planNodeIdGenerator)
+                    .values(probeInput, true)
+                    .hashJoin(
+                        {"p0"},
+                        {"b0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildInput, true)
+                            .planNode(),
+                        "",
+                        {"p0", "p1", "b0", "b1"},
+                        core::JoinType::kInner)
+                    .planNode())
+          .assertResults(
+              "SELECT probe.p0, probe.p1, build.b0, build.b1 FROM probe "
+              "INNER JOIN build ON probe.p0 = build.b0"),
+      "Simulated failure");
+  // This test uses on-demand created memory manager instead of the global
+  // one. We need to make sure any used memory got cleaned up before exiting
+  // the scope
+  waitForAllTasksToBeDeleted();
+  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredDuringParallelJoinBuild) {
+  std::unique_ptr<memory::MemoryManager> memoryManager = createMemoryManager();
+  const auto& arbitrator = memoryManager->arbitrator();
+  const uint64_t numDrivers = 2;
+
+  // Large build side key product to bump hash mode to kHash instead of kArray
+  // to trigger parallel join build.
+  const uint64_t numBuildSideRows = 500;
+  auto buildKeyVector = makeFlatVector<int64_t>(
+      numBuildSideRows,
+      [](vector_size_t row) { return folly::Random::rand64(); });
+  auto buildSideVector = makeRowVector(
+      {"b0", "b1", "b2"}, {buildKeyVector, buildKeyVector, buildKeyVector});
+  std::vector<RowVectorPtr> buildSideVectors;
+  for (int i = 0; i < numDrivers; ++i) {
+    buildSideVectors.push_back(buildSideVector);
+  }
+  createDuckDbTable("build", buildSideVectors);
+
+  const uint64_t numProbeSideRows = 10;
+  auto probeKeyVector = makeFlatVector<int64_t>(
+      numProbeSideRows,
+      [&](vector_size_t row) { return buildKeyVector->valueAt(row); });
+  auto probeSideVector = makeRowVector(
+      {"p0", "p1", "p2"}, {probeKeyVector, probeKeyVector, probeKeyVector});
+  std::vector<RowVectorPtr> probeSideVectors;
+  for (int i = 0; i < numDrivers; ++i) {
+    probeSideVectors.push_back(probeSideVector);
+  }
+  createDuckDbTable("probe", probeSideVectors);
+
+  std::shared_ptr<core::QueryCtx> joinQueryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+
+  const int64_t allocSize = 512LL << 20;
+  std::atomic<bool> parallelBuildTriggered{false};
+  std::atomic<memory::MemoryPool*> joinBuildPool{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashTable::parallelJoinBuild",
+      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+        parallelBuildTriggered = true;
+        // Pick the last running driver threads' pool for later memory
+        // allocation. This pick is rather arbitrary, as it is un-important
+        // which pool is going to be allocated from later in a parallel join's
+        // off-driver thread.
+        joinBuildPool = pool;
+      }));
+
+  std::atomic_bool offThreadAllocationTriggered{false};
+  folly::EventCount asyncMoveWait;
+  std::atomic<bool> asyncMoveWaitFlag{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::AsyncSource::prepare",
+      std::function<void(void*)>([&](void* /* unused */) {
+        if (!offThreadAllocationTriggered.exchange(true)) {
+          SCOPE_EXIT {
+            asyncMoveWaitFlag = false;
+            asyncMoveWait.notifyAll();
+          };
+          // Executed by the first thread hitting the test value location. This
+          // allocation will trigger arbitration and fail.
+          VELOX_ASSERT_THROW(
+              joinBuildPool.load()->allocate(allocSize),
+              "Exceeded memory pool cap");
+        }
+      }));
+
+  // Wait for allocation (hence arbitration) on the prepare thread to finish
+  // before calling AsyncSource::move(). This is to ensure no other AsyncSource
+  // (hence arbitration) is running on the driver thread (on-thread) before the
+  // ongoing arbitration finishes. Without ensuring this, the on-thread
+  // arbitration (triggered by calling AsyncSource::move() first) has
+  // thread-local driver context by default, defying the purpose of this test.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::AsyncSource::move",
+      std::function<void(void*)>([&](void* /* unused */) {
+        asyncMoveWait.await([&]() { return !asyncMoveWaitFlag.load(); });
+      }));
+
+  std::vector<RowVectorPtr> probeInput = {probeSideVector};
+  std::vector<RowVectorPtr> buildInput = {buildSideVector};
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kJoinSpillEnabled, true)
+      // Set very low table size threshold to trigger parallel build.
+      .config(core::QueryConfig::kMinTableRowsForParallelJoinBuild, 0)
+      // Set multiple hash build drivers to trigger parallel build.
+      .maxDrivers(numDrivers)
+      .queryCtx(joinQueryCtx)
+      .plan(PlanBuilder(planNodeIdGenerator)
+                .values(probeInput, true)
+                .hashJoin(
+                    {"p0", "p1", "p2"},
+                    {"b0", "b1", "b2"},
+                    PlanBuilder(planNodeIdGenerator)
+                        .values(buildInput, true)
+                        .planNode(),
+                    "",
+                    {"p0", "p1", "b0", "b1"},
+                    core::JoinType::kInner)
+                .planNode())
+      .assertResults(
+          "SELECT probe.p0, probe.p1, build.b0, build.b1 FROM probe "
+          "INNER JOIN build ON probe.p0 = build.b0 AND probe.p1 = build.b1 AND "
+          "probe.p2 = build.b2");
+  ASSERT_TRUE(parallelBuildTriggered);
+
+  // This test uses on-demand created memory manager instead of the global
+  // one. We need to make sure any used memory got cleaned up before exiting
+  // the scope
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredByEnsureJoinTableFit) {
+  // Use manual spill injection other than spill injection framework. This is
+  // because spill injection framework does not allow fine grain spill within a
+  // single operator (We do not want to spill during addInput() but only during
+  // finishHashBuild()).
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::ensureTableFits",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        Operator::ReclaimableSectionGuard guard(op);
+        memory::testingRunArbitration(op->pool());
+      })));
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .injectSpill(false)
+      .spillDirectory(tempDirectory->getPath())
+      .keyTypes({BIGINT()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        const auto statsPair = taskSpilledStats(*task);
+        ASSERT_GT(statsPair.first.spilledBytes, 0);
+      })
+      .run();
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, joinBuildSpillError) {
+  const int kMemoryCapacity = 32 << 20;
+  // Set a small memory capacity to trigger spill.
+  std::unique_ptr<memory::MemoryManager> memoryManager =
+      createMemoryManager(kMemoryCapacity, 0);
+  const auto& arbitrator = memoryManager->arbitrator();
+  auto rowType = ROW(
+      {{"c0", INTEGER()},
+       {"c1", INTEGER()},
+       {"c2", VARCHAR()},
+       {"c3", VARCHAR()}});
+
+  std::vector<RowVectorPtr> vectors = createVectors(16, rowType, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  std::shared_ptr<core::QueryCtx> joinQueryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+
+  const int numDrivers = 4;
+  std::atomic<int> numAppends{0};
+  const std::string injectedErrorMsg("injected spillError");
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::SpillState::appendToPartition",
+      std::function<void(exec::SpillState*)>([&](exec::SpillState* state) {
+        if (++numAppends != numDrivers) {
+          return;
+        }
+        VELOX_FAIL(injectedErrorMsg);
+      }));
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(vectors)
+                  .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(vectors)
+                          .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                          .planNode(),
+                      "",
+                      {"t1"},
+                      core::JoinType::kAnti)
+                  .planNode();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan)
+          .queryCtx(joinQueryCtx)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .copyResults(pool()),
+      injectedErrorMsg);
+
+  waitForAllTasksToBeDeleted();
+  ASSERT_EQ(arbitrator->stats().numFailures, 1);
+
+  // Wait again here as this test uses on-demand created memory manager instead
+  // of the global one. We need to make sure any used memory got cleaned up
+  // before exiting the scope
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, taskWaitTimeout) {
+  const int queryMemoryCapacity = 128 << 20;
+  // Creates a large number of vectors based on the query capacity to trigger
+  // memory arbitration.
+  fuzzerOpts_.vectorSize = 10'000;
+  auto rowType = ROW(
+      {{"c0", INTEGER()},
+       {"c1", INTEGER()},
+       {"c2", VARCHAR()},
+       {"c3", VARCHAR()}});
+  const auto vectors =
+      createVectors(rowType, queryMemoryCapacity / 2, fuzzerOpts_);
+  const int numDrivers = 4;
+  const auto expectedResult =
+      runHashJoinTask(vectors, nullptr, false, numDrivers, pool(), false).data;
+
+  for (uint64_t timeoutMs : {0, 1'000, 30'000}) {
+    SCOPED_TRACE(fmt::format("timeout {}", succinctMillis(timeoutMs)));
+    auto memoryManager = createMemoryManager(512 << 20, 0, 0, timeoutMs);
+    auto queryCtx =
+        newQueryCtx(memoryManager.get(), executor_.get(), queryMemoryCapacity);
+
+    // Set test injection to block one hash build operator to inject delay when
+    // memory reclaim waits for task to pause.
+    folly::EventCount buildBlockWait;
+    std::atomic<bool> buildBlockWaitFlag{true};
+    std::atomic<bool> blockOneBuild{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+          const std::string re(".*HashBuild");
+          if (!RE2::FullMatch(pool->name(), re)) {
+            return;
+          }
+          if (!blockOneBuild.exchange(false)) {
+            return;
+          }
+          buildBlockWait.await([&]() { return !buildBlockWaitFlag.load(); });
+        }));
+
+    folly::EventCount taskPauseWait;
+    std::atomic<bool> taskPauseWaitFlag{false};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Task::requestPauseLocked",
+        std::function<void(Task*)>(([&](Task* /*unused*/) {
+          taskPauseWaitFlag = true;
+          taskPauseWait.notifyAll();
+        })));
+
+    std::thread queryThread([&]() {
+      // We expect failure on short time out.
+      if (timeoutMs == 1'000) {
+        VELOX_ASSERT_THROW(
+            runHashJoinTask(
+                vectors,
+                queryCtx,
+                false,
+                numDrivers,
+                pool(),
+                true,
+                expectedResult),
+            "Memory reclaim failed to wait");
+      } else {
+        // We expect succeed on large time out or no timeout.
+        const auto result = runHashJoinTask(
+            vectors, queryCtx, false, numDrivers, pool(), true, expectedResult);
+        auto taskStats = exec::toPlanStats(result.task->taskStats());
+        auto& planStats = taskStats.at(result.planNodeId);
+        ASSERT_GT(planStats.spilledBytes, 0);
+      }
+    });
+
+    // Wait for task pause to reach, and then delay for a while before unblock
+    // the blocked hash build operator.
+    taskPauseWait.await([&]() { return taskPauseWaitFlag.load(); });
+    // Wait for two seconds and expect the short reclaim wait timeout.
+    std::this_thread::sleep_for(std::chrono::seconds(2));
+    // Unblock the blocked build operator to let memory reclaim proceed.
+    buildBlockWaitFlag = false;
+    buildBlockWait.notifyAll();
+
+    queryThread.join();
+
+    // This test uses on-demand created memory manager instead of the global
+    // one. We need to make sure any used memory got cleaned up before exiting
+    // the scope
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpill) {
+  struct {
+    bool triggerBuildSpill;
+    // Triggers after no more input or not.
+    bool afterNoMoreInput;
+    // The index of get output call to trigger probe side spilling.
+    int probeOutputIndex;
+
+    std::string debugString() const {
+      return fmt::format(
+          "triggerBuildSpill: {}, afterNoMoreInput: {}, probeOutputIndex: {}",
+          triggerBuildSpill,
+          afterNoMoreInput,
+          probeOutputIndex);
+    }
+  } testSettings[] = {
+      {false, false, 0},
+      {false, false, 1},
+      {false, false, 10},
+      {false, true, 0},
+      {true, false, 0},
+      {true, false, 1},
+      {true, false, 10},
+      {true, true, 0}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::atomic_bool injectBuildSpillOnce{true};
+    std::atomic_int buildInputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (!testData.triggerBuildSpill) {
+            return;
+          }
+          if (!isHashBuildMemoryPool(*op->pool())) {
+            return;
+          }
+          if (buildInputCount++ != 1) {
+            return;
+          }
+          if (!injectBuildSpillOnce.exchange(false)) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    std::atomic_bool injectProbeSpillOnce{true};
+    std::atomic_int probeOutputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (!isHashProbeMemoryPool(*op->pool())) {
+            return;
+          }
+          if (testData.afterNoMoreInput) {
+            if (!op->testingNoMoreInput()) {
+              return;
+            }
+          } else {
+            if (probeOutputCount++ != testData.probeOutputIndex) {
+              return;
+            }
+          }
+          if (!injectProbeSpillOnce.exchange(false)) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    fuzzerOpts_.vectorSize = 128;
+    auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
+    auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .probeKeys({"t_k1"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_k1"})
+        .buildVectors(std::move(buildVectors))
+        .config(core::QueryConfig::kJoinSpillEnabled, "true")
+        .joinType(core::JoinType::kRight)
+        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+        .referenceQuery(
+            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
+        .injectSpill(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          auto opStats = toOperatorStats(task->taskStats());
+          ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+          if (testData.triggerBuildSpill) {
+            ASSERT_GT(opStats.at("HashBuild").spilledBytes, 0);
+          } else {
+            ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+          }
+
+          const auto* arbitrator = memory::memoryManager()->arbitrator();
+          ASSERT_GT(arbitrator->stats().numRequests, 0);
+          ASSERT_GT(arbitrator->stats().numReclaimedBytes, 0);
+        })
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfLastOutputProcessing) {
+  std::atomic_int outputCountAfterNoMoreInout{0};
+  std::atomic_bool injectOnce{true};
+  ::facebook::velox::common::testutil::ScopedTestValue abc(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (!op->testingNoMoreInput()) {
+          return;
+        }
+        if (outputCountAfterNoMoreInout++ != 1) {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        testingRunArbitration(op->pool());
+      }));
+
+  fuzzerOpts_.vectorSize = 128;
+  auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
+  auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .probeKeys({"t_k1"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_k1"})
+      .buildVectors(std::move(buildVectors))
+      .config(core::QueryConfig::kJoinSpillEnabled, "true")
+      .config(core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+      .joinType(core::JoinType::kRight)
+      .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+      .referenceQuery(
+          "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
+      .injectSpill(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+        // Verifies that we only spill the output which is single partitioned
+        // but not the hash table.
+        ASSERT_EQ(opStats.at("HashProbe").spilledPartitions, 1);
+      })
+      .run();
+}
+
+// Inject probe-side spilling in the middle of output processing. If
+// 'recursiveSpill' is true, we trigger probe-spilling when probe the hash table
+// built from spilled data.
+DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfOutputProcessing) {
+  for (bool recursiveSpill : {false, true}) {
+    std::atomic_int buildInputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (!isHashBuildMemoryPool(*op->pool())) {
+            return;
+          }
+          if (!recursiveSpill) {
+            return;
+          }
+          // Trigger spill after the build side has processed some rows.
+          if (buildInputCount++ != 1) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    std::atomic_bool injectProbeSpillOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (!isHashProbeMemoryPool(*op->pool())) {
+            return;
+          }
+
+          if (op->testingHasInput()) {
+            return;
+          }
+          if (recursiveSpill) {
+            if (static_cast<HashProbe*>(op)->testingHasInputSpiller()) {
+              return;
+            }
+          }
+          if (!injectProbeSpillOnce.exchange(false)) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    fuzzerOpts_.vectorSize = 128;
+    auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
+    auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
+
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .probeKeys({"t_k1"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_k1"})
+        .buildVectors(std::move(buildVectors))
+        .config(core::QueryConfig::kJoinSpillEnabled, "true")
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .joinType(core::JoinType::kRight)
+        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+        .referenceQuery(
+            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
+        .injectSpill(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          auto opStats = toOperatorStats(task->taskStats());
+          ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+          ASSERT_GT(opStats.at("HashProbe").spilledPartitions, 1);
+        })
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillWhenOneOfProbeFinish) {
+  const int numDrivers{3};
+
+  std::atomic_bool probeWaitFlag{true};
+  folly::EventCount probeWait;
+  std::atomic_int numBlockedProbeOps{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (++numBlockedProbeOps <= numDrivers - 1) {
+          probeWait.await([&]() { return !probeWaitFlag.load(); });
+          return;
+        }
+      }));
+
+  std::atomic_bool notifyOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (!notifyOnce.exchange(false)) {
+          return;
+        }
+        probeWaitFlag = false;
+        probeWait.notifyAll();
+      }));
+
+  std::thread queryThread([&]() {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers, true, true)
+        .spillDirectory(spillDirectory->getPath())
+        .keyTypes({BIGINT()})
+        .probeVectors(32, 5)
+        .buildVectors(32, 5)
+        .config(core::QueryConfig::kJoinSpillEnabled, "true")
+        .referenceQuery(
+            "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+        .injectSpill(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          auto opStats = toOperatorStats(task->taskStats());
+          ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+          ASSERT_EQ(opStats.at("HashProbe").spilledBytes, 0);
+        })
+        .run();
+  });
+  // Wait until one of the hash probe operator has finished.
+  probeWait.await([&]() { return !probeWaitFlag.load(); });
+  memory::testingRunArbitration();
+  queryThread.join();
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillExceedLimit) {
+  // If 'buildTriggerSpill' is true, then spilling is triggered by hash build.
+  for (const bool buildTriggerSpill : {false, true}) {
+    SCOPED_TRACE(fmt::format("buildTriggerSpill {}", buildTriggerSpill));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+          if (buildTriggerSpill && !isHashBuildMemoryPool(*pool)) {
+            return;
+          }
+          if (!buildTriggerSpill && !isHashProbeMemoryPool(*pool)) {
+            return;
+          }
+          testingRunArbitration(pool);
+        }));
+
+    fuzzerOpts_.vectorSize = 128;
+    auto probeVectors = createVectors(32, probeType_, fuzzerOpts_);
+    auto buildVectors = createVectors(32, buildType_, fuzzerOpts_);
+
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .probeKeys({"t_k1"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_k1"})
+        .buildVectors(std::move(buildVectors))
+        .config(core::QueryConfig::kMaxSpillLevel, "1")
+        .config(core::QueryConfig::kSpillNumPartitionBits, "1")
+        .config(core::QueryConfig::kJoinSpillEnabled, "true")
+        // Set small write buffer size to have small vectors to read from
+        // spilled data.
+        .config(core::QueryConfig::kSpillWriteBufferSize, "1")
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .joinType(core::JoinType::kRight)
+        .joinOutputLayout({"t_k1", "t_k2", "u_k1", "t_v1"})
+        .referenceQuery(
+            "SELECT t.t_k1, t.t_k2, u.u_k1, t.t_v1 FROM t RIGHT JOIN u ON t.t_k1 = u.u_k1")
+        .injectSpill(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          auto opStats = toOperatorStats(task->taskStats());
+          if (buildTriggerSpill) {
+            ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+            ASSERT_GT(opStats.at("HashBuild").spilledBytes, 0);
+          } else {
+            ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+            ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+          }
+          ASSERT_GT(
+              opStats.at("HashProbe")
+                  .runtimeStats[Operator::kExceededMaxSpillLevel]
+                  .sum,
+              0);
+          ASSERT_GT(
+              opStats.at("HashBuild")
+                  .runtimeStats[Operator::kExceededMaxSpillLevel]
+                  .sum,
+              0);
+        })
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillUnderNonReclaimableSection) {
+  std::atomic_bool injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+        if (!isHashProbeMemoryPool(*pool)) {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        auto* arbitrator = memory::memoryManager()->arbitrator();
+        const auto numNonReclaimableAttempts =
+            arbitrator->stats().numNonReclaimableAttempts;
+        testingRunArbitration(pool);
+        // Verifies that we run into non-reclaimable section when reclaim from
+        // hash probe.
+        ASSERT_EQ(
+            arbitrator->stats().numNonReclaimableAttempts,
+            numNonReclaimableAttempts + 1);
+      }));
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .keyTypes({BIGINT()})
+      .probeVectors(32, 5)
+      .buildVectors(32, 5)
+      .config(core::QueryConfig::kJoinSpillEnabled, "true")
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+      .injectSpill(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_EQ(opStats.at("HashProbe").spilledBytes, 0);
+        ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+      })
+      .run();
+}
+
+// This test case is to cover the case that hash probe trigger spill for right
+// semi join types and the pending input needs to be processed in multiple
+// steps.
+DEBUG_ONLY_TEST_F(HashJoinTest, spillOutputWithRightSemiJoins) {
+  for (const auto joinType :
+       {core::JoinType::kRightSemiFilter, core::JoinType::kRightSemiProject}) {
+    std::atomic_bool injectOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (op->testingOperatorCtx()->operatorType() != "HashProbe") {
+            return;
+          }
+          if (!op->testingHasInput()) {
+            return;
+          }
+          if (!injectOnce.exchange(false)) {
+            return;
+          }
+          testingRunArbitration(op->pool());
+        }));
+
+    std::string duckDbSqlReference;
+    std::vector<std::string> joinOutputLayout;
+    bool nullAware{false};
+    if (joinType == core::JoinType::kRightSemiProject) {
+      duckDbSqlReference = "SELECT u_k2, u_k1 IN (SELECT t_k1 FROM t) FROM u";
+      joinOutputLayout = {"u_k2", "match"};
+      // Null aware is only supported for semi projection join type.
+      nullAware = true;
+    } else {
+      duckDbSqlReference =
+          "SELECT u_k2 FROM u WHERE u_k1 IN (SELECT t_k1 FROM t)";
+      joinOutputLayout = {"u_k2"};
+    }
+
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .probeType(probeType_)
+        .probeVectors(128, 3)
+        .probeKeys({"t_k1"})
+        .buildType(buildType_)
+        .buildVectors(128, 4)
+        .buildKeys({"u_k1"})
+        .joinType(joinType)
+        // Set a small number of output rows to process the input in multiple
+        // steps.
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .injectSpill(false)
+        .joinOutputLayout(std::move(joinOutputLayout))
+        .nullAware(nullAware)
+        .referenceQuery(duckDbSqlReference)
+        .run();
+  }
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, spillCheckOnLeftSemiFilterWithDynamicFilters) {
+  const int32_t numSplits = 10;
+  const int32_t numRowsProbe = 333;
+  const int32_t numRowsBuild = 100;
+
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(numSplits);
+
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto rowVector = makeRowVector({
+        makeFlatVector<int32_t>(
+            numRowsProbe, [&](auto row) { return row - i * 10; }),
+        makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
+    });
+    probeVectors.push_back(rowVector);
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), rowVector);
+  }
+  auto makeInputSplits = [&](const core::PlanNodeId& nodeId) {
+    return [&] {
+      std::vector<exec::Split> probeSplits;
+      for (auto& file : tempFiles) {
+        probeSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(file->getPath())));
+      }
+      SplitInput splits;
+      splits.emplace(nodeId, probeSplits);
+      return splits;
+    };
+  };
+
+  // 100 key values in [35, 233] range.
+  std::vector<RowVectorPtr> buildVectors;
+  for (int i = 0; i < 5; ++i) {
+    buildVectors.push_back(makeRowVector({
+        makeFlatVector<int32_t>(
+            numRowsBuild / 5,
+            [i](auto row) { return 35 + 2 * (row + i * numRowsBuild / 5); }),
+        makeFlatVector<int64_t>(numRowsBuild / 5, [](auto row) { return row; }),
+    }));
+  }
+  std::vector<RowVectorPtr> keyOnlyBuildVectors;
+  for (int i = 0; i < 5; ++i) {
+    keyOnlyBuildVectors.push_back(
+        makeRowVector({makeFlatVector<int32_t>(numRowsBuild / 5, [i](auto row) {
+          return 35 + 2 * (row + i * numRowsBuild / 5);
+        })}));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto buildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                       .values(buildVectors)
+                       .project({"c0 AS u_c0", "c1 AS u_c1"})
+                       .planNode();
+
+  // Left semi join.
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId joinNodeId;
+  const auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                      .tableScan(probeType)
+                      .capturePlanNodeId(probeScanId)
+                      .hashJoin(
+                          {"c0"},
+                          {"u_c0"},
+                          buildSide,
+                          "",
+                          {"c0", "c1"},
+                          core::JoinType::kLeftSemiFilter)
+                      .capturePlanNodeId(joinNodeId)
+                      .project({"c0", "c1 + 1"})
+                      .planNode();
+
+  std::atomic_bool injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (op->testingOperatorCtx()->operatorType() != "HashProbe") {
+          return;
+        }
+        if (!op->testingHasInput()) {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        testingRunArbitration(op->pool());
+      }));
+
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .makeInputSplits(makeInputSplits(probeScanId))
+      .spillDirectory(spillDirectory->getPath())
+      .injectSpill(false)
+      .referenceQuery(
+          "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u)")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        // Verify spill hasn't triggered.
+        auto taskStats = exec::toPlanStats(task->taskStats());
+        auto& planStats = taskStats.at(joinNodeId);
+        ASSERT_GT(planStats.spilledBytes, 0);
+      })
+      .run();
+}
+
+TEST_F(HashJoinTest, nanKeys) {
+  // Verify the NaN values with different binary representations are considered
+  // equal.
+  static const double kNan = std::numeric_limits<double>::quiet_NaN();
+  static const double kSNaN = std::numeric_limits<double>::signaling_NaN();
+  auto probeInput = makeRowVector(
+      {makeFlatVector<double>({kNan, kSNaN}), makeFlatVector<int64_t>({1, 2})});
+  auto buildInput = makeRowVector({makeFlatVector<double>({kNan, 1})});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeInput})
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildInput})
+                          .project({"c0 AS u0"})
+                          .planNode(),
+                      "",
+                      {"t0", "u0", "t1"},
+                      core::JoinType::kLeft)
+                  .planNode();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  auto result =
+      AssertQueryBuilder(plan).queryCtx(queryCtx).copyResults(pool_.get());
+  auto expected = makeRowVector(
+      {makeFlatVector<double>({kNan, kNan}),
+       makeFlatVector<double>({kNan, kNan}),
+       makeFlatVector<int64_t>({1, 2})});
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
 } // namespace
diff --git a/velox/exec/tests/HashPartitionFunctionTest.cpp b/velox/exec/tests/HashPartitionFunctionTest.cpp
index 2e8e114a2e76d..a41604c2df1bb 100644
--- a/velox/exec/tests/HashPartitionFunctionTest.cpp
+++ b/velox/exec/tests/HashPartitionFunctionTest.cpp
@@ -15,14 +15,18 @@
  */
 
 #include "velox/exec/HashPartitionFunction.h"
-#include "velox/core/ITypedExpr.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 
 class HashPartitionFunctionTest : public test::VectorTestBase,
-                                  public testing::Test {};
+                                  public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 TEST_F(HashPartitionFunctionTest, function) {
   const int numRows = 10'000;
@@ -33,85 +37,85 @@ TEST_F(HashPartitionFunctionTest, function) {
 
   // The test case the two hash partition functions having the same config.
   {
-    std::vector<uint32_t> partitonsWithoutBits(numRows);
+    std::vector<uint32_t> partitionsWithoutBits(numRows);
     HashPartitionFunction functionWithoutBits(4, rowType, {0});
-    functionWithoutBits.partition(*vector, partitonsWithoutBits);
+    functionWithoutBits.partition(*vector, partitionsWithoutBits);
     EXPECT_EQ(4, functionWithoutBits.numPartitions());
 
-    std::vector<uint32_t> partitonsWithBits(numRows);
+    std::vector<uint32_t> partitionsWithBits(numRows);
     HashPartitionFunction functionWithBits(HashBitRange{0, 2}, rowType, {0});
-    functionWithBits.partition(*vector, partitonsWithBits);
-    EXPECT_EQ(partitonsWithoutBits, partitonsWithBits);
+    functionWithBits.partition(*vector, partitionsWithBits);
+    EXPECT_EQ(partitionsWithoutBits, partitionsWithBits);
     EXPECT_EQ(4, functionWithBits.numPartitions());
   }
 
   // The test case the two hash partition functions with different configs.
   {
-    std::vector<uint32_t> partitonsWithoutBits(numRows);
+    std::vector<uint32_t> partitionsWithoutBits(numRows);
     HashPartitionFunction functionWithoutBits(4, rowType, {0});
-    functionWithoutBits.partition(*vector, partitonsWithoutBits);
+    functionWithoutBits.partition(*vector, partitionsWithoutBits);
     EXPECT_EQ(4, functionWithoutBits.numPartitions());
 
-    std::vector<uint32_t> partitonsWithBits(numRows);
+    std::vector<uint32_t> partitionsWithBits(numRows);
     HashPartitionFunction functionWithBits(HashBitRange{0, 3}, rowType, {0});
-    functionWithBits.partition(*vector, partitonsWithBits);
-    EXPECT_NE(partitonsWithoutBits, partitonsWithBits);
+    functionWithBits.partition(*vector, partitionsWithBits);
+    EXPECT_NE(partitionsWithoutBits, partitionsWithBits);
     EXPECT_EQ(8, functionWithBits.numPartitions());
   }
 
   // The test case the two hash partition functions with different configs.
   {
-    std::vector<uint32_t> partitonsWithoutBits(numRows);
+    std::vector<uint32_t> partitionsWithoutBits(numRows);
     HashPartitionFunction functionWithoutBits(4, rowType, {0});
-    functionWithoutBits.partition(*vector, partitonsWithoutBits);
+    functionWithoutBits.partition(*vector, partitionsWithoutBits);
     EXPECT_EQ(4, functionWithoutBits.numPartitions());
 
-    std::vector<uint32_t> partitonsWithBits(numRows);
+    std::vector<uint32_t> partitionsWithBits(numRows);
     HashPartitionFunction functionWithBits(HashBitRange{29, 31}, rowType, {0});
-    functionWithBits.partition(*vector, partitonsWithBits);
-    EXPECT_NE(partitonsWithoutBits, partitonsWithBits);
+    functionWithBits.partition(*vector, partitionsWithBits);
+    EXPECT_NE(partitionsWithoutBits, partitionsWithBits);
     EXPECT_EQ(4, functionWithBits.numPartitions());
   }
 
   // The test case the two hash partition functions with different configs.
   {
-    std::vector<uint32_t> partitonsWithBits1(numRows);
+    std::vector<uint32_t> partitionsWithBits1(numRows);
     HashPartitionFunction functionWithBits1(HashBitRange{40, 42}, rowType, {0});
-    functionWithBits1.partition(*vector, partitonsWithBits1);
+    functionWithBits1.partition(*vector, partitionsWithBits1);
     EXPECT_EQ(4, functionWithBits1.numPartitions());
 
-    std::vector<uint32_t> partitonsWithBits2(numRows);
+    std::vector<uint32_t> partitionsWithBits2(numRows);
     HashPartitionFunction functionWithBits2(HashBitRange{29, 31}, rowType, {0});
-    functionWithBits2.partition(*vector, partitonsWithBits2);
-    EXPECT_NE(partitonsWithBits1, partitonsWithBits2);
+    functionWithBits2.partition(*vector, partitionsWithBits2);
+    EXPECT_NE(partitionsWithBits1, partitionsWithBits2);
     EXPECT_EQ(4, functionWithBits2.numPartitions());
   }
 
   // The test case the two hash partition functions with different configs.
   {
-    std::vector<uint32_t> partitonsWithBits1(numRows);
+    std::vector<uint32_t> partitionsWithBits1(numRows);
     HashPartitionFunction functionWithBits1(HashBitRange{20, 31}, rowType, {0});
-    functionWithBits1.partition(*vector, partitonsWithBits1);
+    functionWithBits1.partition(*vector, partitionsWithBits1);
     EXPECT_EQ(1 << 11, functionWithBits1.numPartitions());
 
-    std::vector<uint32_t> partitonsWithBits2(numRows);
+    std::vector<uint32_t> partitionsWithBits2(numRows);
     HashPartitionFunction functionWithBits2(HashBitRange{29, 31}, rowType, {0});
-    functionWithBits2.partition(*vector, partitonsWithBits2);
-    EXPECT_NE(partitonsWithBits1, partitonsWithBits2);
+    functionWithBits2.partition(*vector, partitionsWithBits2);
+    EXPECT_NE(partitionsWithBits1, partitionsWithBits2);
     EXPECT_EQ(4, functionWithBits2.numPartitions());
   }
 
   // The test case the two hash partition functions having the same config.
   {
-    std::vector<uint32_t> partitonsWithBits1(numRows);
+    std::vector<uint32_t> partitionsWithBits1(numRows);
     HashPartitionFunction functionWithBits1(HashBitRange{29, 31}, rowType, {0});
-    functionWithBits1.partition(*vector, partitonsWithBits1);
+    functionWithBits1.partition(*vector, partitionsWithBits1);
     EXPECT_EQ(4, functionWithBits1.numPartitions());
 
-    std::vector<uint32_t> partitonsWithBits2(numRows);
+    std::vector<uint32_t> partitionsWithBits2(numRows);
     HashPartitionFunction functionWithBits2(HashBitRange{29, 31}, rowType, {0});
-    functionWithBits2.partition(*vector, partitonsWithBits2);
-    EXPECT_EQ(partitonsWithBits1, partitonsWithBits2);
+    functionWithBits2.partition(*vector, partitionsWithBits2);
+    EXPECT_EQ(partitionsWithBits1, partitionsWithBits2);
     EXPECT_EQ(4, functionWithBits2.numPartitions());
   }
 }
@@ -130,7 +134,7 @@ TEST_F(HashPartitionFunctionTest, spec) {
         inputType,
         std::vector<column_index_t>{0, kConstantChannel, 2, 3, 4},
         std::vector<VectorPtr>{makeConstant(123, 1)});
-    ASSERT_EQ("HASH(c0, \"123\", c2, c3, c4)", hashSpec->toString());
+    ASSERT_EQ(R"(HASH(c0, "123", c2, c3, c4))", hashSpec->toString());
 
     auto serialized = hashSpec->serialize();
     ASSERT_EQ(serialized["constants"].size(), 1);
diff --git a/velox/exec/tests/HashTableTest.cpp b/velox/exec/tests/HashTableTest.cpp
index e6bbc88a79ff6..5bde20a135a55 100644
--- a/velox/exec/tests/HashTableTest.cpp
+++ b/velox/exec/tests/HashTableTest.cpp
@@ -22,7 +22,7 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/VectorHasher.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <folly/executors/CPUThreadPoolExecutor.h>
 #include <gmock/gmock-matchers.h>
@@ -33,6 +33,54 @@ using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::test;
 
+namespace facebook::velox::exec::test {
+
+template <bool ignoreNullKeys>
+class HashTableTestHelper {
+ public:
+  static HashTableTestHelper create(HashTable<ignoreNullKeys>* table) {
+    return HashTableTestHelper(table);
+  }
+
+  int64_t nextBucketOffset(int64_t offset) const {
+    return table_->nextBucketOffset(offset);
+  }
+
+  uint64_t bucketSize() const {
+    return HashTable<ignoreNullKeys>::kBucketSize;
+  }
+
+  void allocateTables(uint64_t size) {
+    table_->allocateTables(size, BaseHashTable::kNoSpillInputStartPartitionBit);
+  }
+
+  size_t tableSlotSize() const {
+    return table_->tableSlotSize();
+  }
+
+  void insertForJoin(
+      RowContainer* rows,
+      char** groups,
+      uint64_t* hashes,
+      int32_t numGroups,
+      TableInsertPartitionInfo* partitionInfo) {
+    table_->insertForJoin(rows, groups, hashes, numGroups, partitionInfo);
+  }
+
+  void setHashMode(BaseHashTable::HashMode mode, int32_t numNew) {
+    table_->setHashMode(
+        mode, numNew, BaseHashTable::kNoSpillInputStartPartitionBit);
+  }
+
+ private:
+  explicit HashTableTestHelper(HashTable<ignoreNullKeys>* table)
+      : table_(table) {
+    VELOX_CHECK_NOT_NULL(table_);
+  }
+
+  HashTable<ignoreNullKeys>* const table_;
+};
+
 // Test framework for join hash tables. Generates probe keys, of which
 // some percent are inserted in a hashTable. The placement of the
 // payload is shuffled so as not to correlate with the probe
@@ -40,8 +88,13 @@ using namespace facebook::velox::test;
 // measures the time for computing hashes/value ids vs the time spent
 // probing the table. Covers kArray, kNormalizedKey and kHash hash
 // modes.
-class HashTableTest : public testing::TestWithParam<bool> {
+class HashTableTest : public testing::TestWithParam<bool>,
+                      public VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
     common::testutil::TestValue::enable();
     if (GetParam()) {
@@ -84,18 +137,14 @@ class HashTableTest : public testing::TestWithParam<bool> {
             buildType->childAt(channel), channel));
       }
       auto table = HashTable<true>::createForJoin(
-          std::move(keyHashers),
-          dependentTypes,
-          true,
-          false,
-          1'000,
-          pool_.get());
+          std::move(keyHashers), dependentTypes, true, false, 1'000, pool());
 
       makeRows(size, 1, sequence, buildType, batches);
       copyVectorsToTable(batches, startOffset, table.get());
       sequence += size;
-      if (!topTable_) {
+      if (topTable_ == nullptr) {
         topTable_ = std::move(table);
+        numRows += topTable_->rows()->numRows();
       } else {
         numRows += table->rows()->numRows();
         otherTables.push_back(std::move(table));
@@ -103,15 +152,25 @@ class HashTableTest : public testing::TestWithParam<bool> {
       batches_.insert(batches_.end(), batches.begin(), batches.end());
       startOffset += size;
     }
-    numRows += topTable_->rows()->numRows();
+
     const uint64_t estimatedTableSize =
         topTable_->estimateHashTableSize(numRows);
-    const uint64_t usedMemoryBytes = topTable_->rows()->pool()->currentBytes();
-    topTable_->prepareJoinTable(std::move(otherTables), executor_.get());
+    const uint64_t usedMemoryBytes = topTable_->rows()->pool()->usedBytes();
+    topTable_->prepareJoinTable(
+        std::move(otherTables),
+        BaseHashTable::kNoSpillInputStartPartitionBit,
+        executor_.get());
     ASSERT_GE(
         estimatedTableSize,
-        topTable_->rows()->pool()->currentBytes() - usedMemoryBytes);
+        topTable_->rows()->pool()->usedBytes() - usedMemoryBytes);
     ASSERT_EQ(topTable_->hashMode(), mode);
+    ASSERT_EQ(topTable_->allRows().size(), numWays);
+    uint64_t rowCount{0};
+    for (auto* rowContainer : topTable_->allRows()) {
+      rowCount += rowContainer->numRows();
+    }
+    ASSERT_EQ(rowCount, numRows);
+
     LOG(INFO) << "Made table " << describeTable();
     testProbe();
     testEraseEveryN(3);
@@ -119,6 +178,13 @@ class HashTableTest : public testing::TestWithParam<bool> {
     testEraseEveryN(4);
     testProbe();
     testGroupBySpill(size, buildType, numKeys);
+    const auto memoryUsage = pool()->usedBytes();
+    topTable_->clear(true);
+    for (const auto* rowContainer : topTable_->allRows()) {
+      ASSERT_EQ(rowContainer->numRows(), 0);
+    }
+    ASSERT_EQ(topTable_->numDistinct(), 0);
+    ASSERT_LT(pool()->usedBytes(), memoryUsage);
   }
 
   // Inserts and deletes rows in a HashTable, similarly to a group by
@@ -172,7 +238,7 @@ class HashTableTest : public testing::TestWithParam<bool> {
     }
 
     return HashTable<false>::createForAggregation(
-        std::move(keyHashers), std::vector<Accumulator>{}, pool_.get());
+        std::move(keyHashers), std::vector<Accumulator>{}, pool());
   }
 
   void insertGroups(
@@ -209,12 +275,13 @@ class HashTableTest : public testing::TestWithParam<bool> {
 
     if (rehash) {
       if (table.hashMode() != BaseHashTable::HashMode::kHash) {
-        table.decideHashMode(input.size());
+        table.decideHashMode(
+            input.size(), BaseHashTable::kNoSpillInputStartPartitionBit);
       }
       insertGroups(input, rows, lookup, table);
       return;
     }
-    table.groupProbe(lookup);
+    table.groupProbe(lookup, BaseHashTable::kNoSpillInputStartPartitionBit);
   }
 
   std::string describeTable() {
@@ -236,11 +303,11 @@ class HashTableTest : public testing::TestWithParam<bool> {
     return out.str();
   }
 
-  void copyVectorsToTable(
+  std::vector<char*> copyVectorsToTable(
       const std::vector<RowVectorPtr>& batches,
       int32_t tableOffset,
       BaseHashTable* table) {
-    int32_t batchSize = batches[0]->size();
+    const int32_t batchSize = batches[0]->size();
     raw_vector<uint64_t> dummy(batchSize);
     int32_t batchOffset = 0;
     rowOfKey_.resize(tableOffset + batchSize * batches.size());
@@ -249,12 +316,12 @@ class HashTableTest : public testing::TestWithParam<bool> {
     auto numKeys = hashers.size();
     // We init a DecodedVector for each member of the RowVectors in 'batches'.
     std::vector<std::vector<DecodedVector>> decoded;
-    SelectivityVector rows(batchSize);
+    SelectivityVector allRows(batchSize);
     SelectivityVector insertedRows(batchSize);
     for (auto& batch : batches) {
-      // If we are only inserting a fraction of the rows, we set
-      // insertedRows to that fraction so that the VectorHashers only
-      // see keys that will actually be inserted.
+      // If we are only inserting a fraction of the rows, we set insertedRows to
+      // that fraction so that the VectorHashers only see keys that will
+      // actually be inserted.
       if (insertPct_ < 100) {
         bits::copyBits(
             isInTable_.data(),
@@ -268,7 +335,7 @@ class HashTableTest : public testing::TestWithParam<bool> {
       VELOX_CHECK_EQ(batch->size(), batchSize);
       auto& decoders = decoded.back();
       for (auto i = 0; i < batch->childrenSize(); ++i) {
-        decoders[i].decode(*batch->childAt(i), rows);
+        decoders[i].decode(*batch->childAt(i), allRows);
         if (i < numKeys) {
           auto hasher = table->hashers()[i].get();
           hasher->decode(*batch->childAt(i), insertedRows);
@@ -281,14 +348,14 @@ class HashTableTest : public testing::TestWithParam<bool> {
       batchOffset += batchSize;
     }
 
-    auto size = batchSize * batches.size();
-    auto powerOfTwo = bits::nextPowerOfTwo(size);
-    int32_t mask = powerOfTwo - 1;
+    const auto size = batchSize * batches.size();
+    const auto powerOfTwo = bits::nextPowerOfTwo(size);
+    const int32_t mask = powerOfTwo - 1;
     int32_t position = 0;
     int32_t delta = 1;
-    int32_t numInserted = 0;
-    auto nextOffset = rowContainer->nextOffset();
+    const auto nextOffset = rowContainer->nextOffset();
 
+    std::vector<char*> rows;
     // We insert values in a geometric skip order. 1, 2, 4, 7,
     // 11,... where the skip increments by one. We wrap around at the
     // power of two boundary. This sequence hits every place in the
@@ -300,19 +367,20 @@ class HashTableTest : public testing::TestWithParam<bool> {
            bits::isBitSet(isInTable_.data(), tableOffset + position))) {
         char* newRow = rowContainer->newRow();
         rowOfKey_[tableOffset + position] = newRow;
-        auto batchIndex = position / batchSize;
-        auto rowIndex = position % batchSize;
-        if (nextOffset) {
+        const auto batchIndex = position / batchSize;
+        const auto rowIndex = position % batchSize;
+        if (nextOffset > 0) {
           *reinterpret_cast<char**>(newRow + nextOffset) = nullptr;
         }
-        ++numInserted;
         for (auto i = 0; i < batches[batchIndex]->type()->size(); ++i) {
           rowContainer->store(decoded[batchIndex][i], rowIndex, newRow, i);
         }
+        rows.push_back(newRow);
       }
       position = (position + delta) & mask;
       ++delta;
     }
+    return rows;
   }
 
   // Makes a vector of 'type' with 'size' unique elements, initialized
@@ -322,16 +390,17 @@ class HashTableTest : public testing::TestWithParam<bool> {
   VectorPtr makeVector(TypePtr type, int32_t size, int32_t sequence) {
     switch (type->kind()) {
       case TypeKind::BIGINT:
-        return vectorMaker_->flatVector<int64_t>(
+        return makeFlatVector<int64_t>(
             size,
             [&](vector_size_t row) { return keySpacing_ * (sequence + row); },
             nullptr);
 
       case TypeKind::VARCHAR: {
-        auto strings = BaseVector::create<FlatVector<StringView>>(
-            VARCHAR(), size, pool_.get());
+        auto strings =
+            BaseVector::create<FlatVector<StringView>>(VARCHAR(), size, pool());
         for (auto row = 0; row < size; ++row) {
-          auto string = fmt::format("{}", keySpacing_ * (sequence + row));
+          auto string =
+              fmt::format("{}{}", baseString_, keySpacing_ * (sequence + row));
           // Make strings that overflow the inline limit for 1/10 of
           // the values after 10K,000. Datasets with only
           // range-encodable small strings can be made within the
@@ -349,7 +418,7 @@ class HashTableTest : public testing::TestWithParam<bool> {
         for (auto i = 0; i < type->size(); ++i) {
           children.push_back(makeVector(type->childAt(i), size, sequence));
         }
-        return vectorMaker_->rowVector(children);
+        return makeRowVector(children);
       }
       default:
         VELOX_FAIL("Unsupported kind for makeVector {}", type->kind());
@@ -369,27 +438,39 @@ class HashTableTest : public testing::TestWithParam<bool> {
     }
   }
 
+  void store(RowContainer& rowContainer, const RowVectorPtr& data) {
+    std::vector<DecodedVector> decodedVectors;
+    for (auto& vector : data->children()) {
+      decodedVectors.emplace_back(*vector);
+    }
+
+    std::vector<char*> rows;
+    for (auto i = 0; i < data->size(); ++i) {
+      auto* row = rowContainer.newRow();
+
+      for (auto j = 0; j < decodedVectors.size(); ++j) {
+        rowContainer.store(decodedVectors[j], i, row, j);
+      }
+    }
+  }
+
   void testProbe() {
     auto lookup = std::make_unique<HashLookup>(topTable_->hashers());
-    auto batchSize = batches_[0]->size();
+    const auto batchSize = batches_[0]->size();
     SelectivityVector rows(batchSize);
-    auto mode = topTable_->hashMode();
+    const auto mode = topTable_->hashMode();
     SelectivityInfo hashTime;
     SelectivityInfo probeTime;
-    int32_t numHashed = 0;
-    int32_t numProbed = 0;
-    int32_t numHit = 0;
     auto& hashers = topTable_->hashers();
     VectorHasher::ScratchMemory scratchMemory;
     for (auto batchIndex = 0; batchIndex < batches_.size(); ++batchIndex) {
-      auto batch = batches_[batchIndex];
+      const auto& batch = batches_[batchIndex];
       lookup->reset(batch->size());
       rows.setAll();
-      numHashed += batch->size();
       {
         SelectivityTimer timer(hashTime, 0);
         for (auto i = 0; i < hashers.size(); ++i) {
-          auto key = batch->childAt(i);
+          auto& key = batch->childAt(i);
           if (mode != BaseHashTable::HashMode::kHash) {
             hashers[i]->lookupValueIds(
                 *key, rows, scratchMemory, lookup->hashes);
@@ -407,11 +488,12 @@ class HashTableTest : public testing::TestWithParam<bool> {
       } else {
         constexpr int32_t kPadding = simd::kPadding / sizeof(int32_t);
         lookup->rows.resize(bits::roundUp(rows.size() + kPadding, kPadding));
-        auto numRows = simd::indicesOfSetBits(
+        const auto numRows = simd::indicesOfSetBits(
             rows.asRange().bits(), 0, batch->size(), lookup->rows.data());
         lookup->rows.resize(numRows);
       }
-      auto startOffset = batchIndex * batchSize;
+
+      const auto startOffset = batchIndex * batchSize;
       if (lookup->rows.empty()) {
         // the keys disqualify all entries. The table is not consulted.
         for (auto i = startOffset; i < startOffset + batch->size(); ++i) {
@@ -419,26 +501,15 @@ class HashTableTest : public testing::TestWithParam<bool> {
         }
       } else {
         {
-          numProbed += lookup->rows.size();
           SelectivityTimer timer(probeTime, 0);
           topTable_->joinProbe(*lookup);
         }
         for (auto i = 0; i < lookup->rows.size(); ++i) {
-          auto key = lookup->rows[i];
-          numHit += lookup->hits[key] != nullptr;
+          const auto key = lookup->rows[i];
           ASSERT_EQ(rowOfKey_[startOffset + key], lookup->hits[key]);
         }
       }
     }
-    LOG(INFO)
-        << fmt::format(
-               "Hashed: {} Probed: {} Hit: {} Hash time/row {} probe time/row {}",
-               numHashed,
-               numProbed,
-               numHit,
-               hashTime.timeToDropValue() / numHashed,
-               probeTime.timeToDropValue() / numProbed)
-        << std::endl;
   }
 
   // Erases every strideth non-erased item in the hash table.
@@ -464,22 +535,22 @@ class HashTableTest : public testing::TestWithParam<bool> {
         nullValues.insert(i);
       }
     }
-    auto batch = vectorMaker_->rowVector(
-        {keys,
-         vectorMaker_->flatVector<int64_t>(keys->size(), folly::identity)});
+    auto batch = makeRowVector(
+        {keys, makeFlatVector<int64_t>(keys->size(), folly::identity)});
     std::vector<std::unique_ptr<VectorHasher>> hashers;
     hashers.push_back(std::make_unique<VectorHasher>(keys->type(), 0));
     auto table = HashTable<false>::createForJoin(
-        std::move(hashers), {BIGINT()}, true, false, 1'000, pool_.get());
+        std::move(hashers), {BIGINT()}, true, false, 1'000, pool());
     copyVectorsToTable({batch}, 0, table.get());
-    table->prepareJoinTable({}, executor_.get());
+    table->prepareJoinTable(
+        {}, BaseHashTable::kNoSpillInputStartPartitionBit, executor_.get());
     ASSERT_EQ(table->hashMode(), mode);
     std::vector<char*> rows(nullValues.size());
     BaseHashTable::NullKeyRowsIterator iter;
     auto numRows = table->listNullKeyRows(&iter, rows.size(), rows.data());
     ASSERT_EQ(numRows, nullValues.size());
     auto actual =
-        BaseVector::create<FlatVector<int64_t>>(BIGINT(), numRows, pool_.get());
+        BaseVector::create<FlatVector<int64_t>>(BIGINT(), numRows, pool());
     table->rows()->extractColumn(rows.data(), numRows, 1, actual);
     for (int i = 0; i < actual->size(); ++i) {
       auto it = nullValues.find(actual->valueAt(i));
@@ -490,12 +561,6 @@ class HashTableTest : public testing::TestWithParam<bool> {
     ASSERT_EQ(0, table->listNullKeyRows(&iter, rows.size(), rows.data()));
   }
 
-  std::shared_ptr<memory::MemoryPool> rootPool_{
-      memory::defaultMemoryManager().addRootPool("HashTableTest")};
-  std::shared_ptr<memory::MemoryPool> pool_{
-      rootPool_->addLeafChild("HashTableTest")};
-  std::unique_ptr<test::VectorMaker> vectorMaker_{
-      std::make_unique<test::VectorMaker>(pool_.get())};
   // Bitmap of positions in batches_ that end up in the table.
   std::vector<uint64_t> isInTable_;
   // Test payload, keys first.
@@ -512,6 +577,8 @@ class HashTableTest : public testing::TestWithParam<bool> {
   // Spacing between consecutive generated keys. Affects whether
   // Vectorhashers make ranges or ids of distinct values.
   int64_t keySpacing_ = 1;
+  // Base string for varchar fields when making string vector.
+  std::string baseString_;
   std::unique_ptr<folly::CPUThreadPoolExecutor> executor_;
 };
 
@@ -576,9 +643,11 @@ TEST_P(HashTableTest, clear) {
       BIGINT(),
       config);
 
-  auto table = HashTable<true>::createForAggregation(
-      std::move(keyHashers), {Accumulator{aggregate.get()}}, pool_.get());
-  ASSERT_NO_THROW(table->clear());
+  for (const bool clearTable : {false, true}) {
+    auto table = HashTable<true>::createForAggregation(
+        std::move(keyHashers), {Accumulator{aggregate.get(), nullptr}}, pool());
+    ASSERT_NO_THROW(table->clear(clearTable));
+  }
 }
 
 // Test a specific code path in HashTable::decodeHashMode where
@@ -610,14 +679,11 @@ TEST_P(HashTableTest, bestWithReserveOverflow) {
   // the VectorHasher, which caused the combined value IDs to be computed using
   // only the last VectorHasher. Hence, all values where last key was the same
   // were assigned the same value IDs.
-  auto data = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>(
-          20'000, [](auto row) { return row * 10; }),
-      vectorMaker_->flatVector<int64_t>(
-          20'000, [](auto row) { return 1 + row * 10; }),
-      vectorMaker_->flatVector<int64_t>(
-          20'000, [](auto row) { return 2 + row * 10; }),
-      vectorMaker_->flatVector<int64_t>(
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(20'000, [](auto row) { return row * 10; }),
+      makeFlatVector<int64_t>(20'000, [](auto row) { return 1 + row * 10; }),
+      makeFlatVector<int64_t>(20'000, [](auto row) { return 2 + row * 10; }),
+      makeFlatVector<int64_t>(
           20'000, [](auto row) { return 3 + (row / 2) * 10; }),
   });
 
@@ -677,12 +743,12 @@ TEST_P(HashTableTest, enableRangeWhereCan) {
     c.push_back(std::string(15, '.') + std::to_string(i));
   }
 
-  auto data = vectorMaker_->rowVector({
-      vectorMaker_->flatVector<int64_t>(
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(
           2'000, [&](auto row) { return a[row % a.size()]; }),
-      vectorMaker_->flatVector<StringView>(
+      makeFlatVector<StringView>(
           2'000, [&](auto row) { return StringView(b[row % b.size()]); }),
-      vectorMaker_->flatVector<StringView>(
+      makeFlatVector<StringView>(
           2'000, [&](auto row) { return StringView(c[row % c.size()]); }),
   });
 
@@ -695,8 +761,8 @@ TEST_P(HashTableTest, arrayProbeNormalizedKey) {
   auto lookup = std::make_unique<HashLookup>(table->hashers());
 
   for (auto i = 0; i < 200; ++i) {
-    auto data = vectorMaker_->rowVector({
-        vectorMaker_->flatVector<int64_t>(
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>(
             10'000, [&](auto row) { return i * 10'000 + row; }),
     });
 
@@ -708,7 +774,7 @@ TEST_P(HashTableTest, arrayProbeNormalizedKey) {
     rows.setValidRange(5'000, 10'000, true);
     rows.updateBounds();
     insertGroups(*data, rows, *lookup, *table);
-    EXPECT_LE(table->stats().numDistinct, table->rehashSize());
+    EXPECT_LE(table->stats().numDistinct, table->testingRehashSize());
   }
 
   ASSERT_EQ(table->hashMode(), BaseHashTable::HashMode::kNormalizedKey);
@@ -724,13 +790,14 @@ TEST_P(HashTableTest, regularHashingTableSize) {
           std::make_unique<VectorHasher>(type->childAt(channel), channel));
     }
     auto table = HashTable<true>::createForJoin(
-        std::move(keyHashers), {}, true, false, 1'000, pool_.get());
+        std::move(keyHashers), {}, true, false, 1'000, pool());
     std::vector<RowVectorPtr> batches;
     makeRows(1 << 12, 1, 0, type, batches);
     copyVectorsToTable(batches, 0, table.get());
-    table->prepareJoinTable({}, executor_.get());
+    table->prepareJoinTable(
+        {}, BaseHashTable::kNoSpillInputStartPartitionBit, executor_.get());
     ASSERT_EQ(table->hashMode(), mode);
-    EXPECT_GE(table->rehashSize(), table->numDistinct());
+    EXPECT_GE(table->testingRehashSize(), table->numDistinct());
   };
   {
     auto type = ROW({"key"}, {ROW({"k1"}, {BIGINT()})});
@@ -742,6 +809,102 @@ TEST_P(HashTableTest, regularHashingTableSize) {
   }
 }
 
+TEST_P(HashTableTest, listJoinResultsSize) {
+  baseString_ =
+      "If you count carefully, you will notice there are exactly 105 characters"
+      " in this string including space.";
+  const size_t kNumRows = 1024;
+  auto buildType = ROW(
+      {"f0", "v0", "v1"}, {BIGINT(), VARCHAR(), ROW({BIGINT(), VARCHAR()})});
+  std::vector<std::unique_ptr<VectorHasher>> keyHashers;
+  for (auto i = 0; i < buildType->size(); ++i) {
+    keyHashers.emplace_back(
+        std::make_unique<VectorHasher>(buildType->childAt(i), i));
+  }
+
+  auto table = HashTable<true>::createForJoin(
+      std::move(keyHashers),
+      {BIGINT(), VARCHAR()},
+      true,
+      false,
+      kNumRows,
+      pool());
+  std::vector<RowVectorPtr> batches;
+  makeRows(kNumRows, 1, 0, buildType, batches);
+  auto rows = copyVectorsToTable(batches, 0, table.get());
+
+  std::vector<vector_size_t> inputRowsBuf;
+  inputRowsBuf.resize(kNumRows);
+  auto inputRows =
+      folly::Range(static_cast<vector_size_t*>(inputRowsBuf.data()), kNumRows);
+  std::vector<char*> outputRowsBuf;
+  outputRowsBuf.resize(kNumRows);
+  auto outputRows = folly::Range(outputRowsBuf.data(), kNumRows);
+
+  HashLookup lookup(table->hashers());
+  lookup.rows.reserve(kNumRows);
+  lookup.hits.reserve(kNumRows);
+  for (auto i = 0; i < kNumRows; i++) {
+    lookup.rows.push_back(i);
+    lookup.hits.push_back(rows[i]);
+  }
+
+  struct TestParam {
+    std::vector<vector_size_t> varSizeListColumns;
+    std::vector<vector_size_t> fixedSizeListColumns;
+    uint64_t maxBytes;
+    int64_t expectedRows;
+
+    std::string debugString() const {
+      std::stringstream ss;
+      ss << "varSizeListColumns ";
+      ss << "[";
+      for (auto i = 0; i < varSizeListColumns.size(); i++) {
+        ss << varSizeListColumns[i];
+        if (i != varSizeListColumns.size() - 1) {
+          ss << ", ";
+        }
+      }
+      ss << "] fixedSizeListColumns [";
+      for (auto i = 0; i < fixedSizeListColumns.size(); i++) {
+        ss << fixedSizeListColumns[i];
+        if (i != fixedSizeListColumns.size() - 1) {
+          ss << ", ";
+        }
+      }
+      ss << "] maxBytes " << maxBytes;
+
+      return ss.str();
+    }
+  };
+
+  // Key types: BIGINT, VARCHAR, ROW(BIGINT, VARCHAR)
+  // Dependent types: BIGINT, VARCHAR
+  std::vector<TestParam> testParams{
+      {{}, {0}, 1024, 128},
+      {{1}, {}, 2048, 20},
+      {{1}, {}, 1 << 20, 1024},
+      {{1}, {}, 1 << 14, 154},
+      {{1}, {0}, 2048, 18},
+      {{}, {0, 3}, 1024, 64},
+      {{2}, {}, 2048, 17},
+      {{1, 2, 4}, {0, 3}, 1 << 14, 66}};
+  for (const auto& testParam : testParams) {
+    SCOPED_TRACE(testParam.debugString());
+    uint64_t fixedColumnSizeSum{0};
+    for (const auto column : testParam.fixedSizeListColumns) {
+      fixedColumnSizeSum += table->rows()->fixedSizeAt(column);
+    }
+    BaseHashTable::JoinResultIterator iter(
+        std::vector<vector_size_t>(testParam.varSizeListColumns),
+        fixedColumnSizeSum);
+    iter.reset(lookup);
+    auto numRows = table->listJoinResults(
+        iter, true, inputRows, outputRows, testParam.maxBytes);
+    ASSERT_EQ(numRows, testParam.expectedRows);
+  }
+}
+
 TEST_P(HashTableTest, groupBySpill) {
   auto type = ROW({"k1"}, {BIGINT()});
   testGroupBySpill(5'000'000, type, 1, 1000, 1000);
@@ -751,26 +914,27 @@ TEST_P(HashTableTest, checkSizeValidation) {
   auto rowType = ROW({"a"}, {BIGINT()});
   auto table = createHashTableForAggregation(rowType, 1);
   auto lookup = std::make_unique<HashLookup>(table->hashers());
+  auto testHelper = HashTableTestHelper<false>::create(table.get());
 
   // The initial set hash mode with table size of 256K entries.
-  table->testingSetHashMode(BaseHashTable::HashMode::kHash, 131'072);
+  testHelper.setHashMode(BaseHashTable::HashMode::kHash, 131'072);
   ASSERT_EQ(table->capacity(), 256 << 10);
 
-  auto vector1 = vectorMaker_->rowVector({vectorMaker_->flatVector<int64_t>(
-      131'072, [&](auto row) { return row; })});
+  auto vector1 = makeRowVector(
+      {makeFlatVector<int64_t>(131'072, [&](auto row) { return row; })});
   // The first insertion of 128KB distinct entries.
   insertGroups(*vector1, *lookup, *table);
   ASSERT_EQ(table->capacity(), 256 << 10);
 
-  auto vector2 = vectorMaker_->rowVector({vectorMaker_->flatVector<int64_t>(
+  auto vector2 = makeRowVector({makeFlatVector<int64_t>(
       131'072, [&](auto row) { return 131'072 + row; })});
   // The second insertion of 128KB distinct entries triggers the table resizing.
   // And we expect the table size bumps up to 512KB.
   insertGroups(*vector2, *lookup, *table);
   ASSERT_EQ(table->capacity(), 512 << 10);
 
-  auto vector3 = vectorMaker_->rowVector(
-      {vectorMaker_->flatVector<int64_t>(1, [&](auto row) { return row; })});
+  auto vector3 = makeRowVector(
+      {makeFlatVector<int64_t>(1, [&](auto row) { return row; })});
   // The last insertion triggers the check size which see the table size matches
   // the number of distinct entries that it stores.
   insertGroups(*vector3, *lookup, *table);
@@ -778,21 +942,16 @@ TEST_P(HashTableTest, checkSizeValidation) {
 }
 
 TEST_P(HashTableTest, listNullKeyRows) {
-  VectorPtr keys = vectorMaker_->flatVector<int64_t>(500, folly::identity);
+  VectorPtr keys = makeFlatVector<int64_t>(500, folly::identity);
   testListNullKeyRows(keys, BaseHashTable::HashMode::kArray);
   {
-    auto flat = vectorMaker_->flatVector<int64_t>(
-        10'000, [](auto i) { return i * 1000; });
-    keys = vectorMaker_->rowVector({flat, flat});
+    auto flat =
+        makeFlatVector<int64_t>(10'000, [](auto i) { return i * 1000; });
+    keys = makeRowVector({flat, flat});
   }
   testListNullKeyRows(keys, BaseHashTable::HashMode::kHash);
 }
 
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    HashTableTests,
-    HashTableTest,
-    testing::Values(true, false));
-
 TEST(HashTableTest, modeString) {
   ASSERT_EQ("HASH", BaseHashTable::modeString(BaseHashTable::HashMode::kHash));
   ASSERT_EQ(
@@ -805,6 +964,79 @@ TEST(HashTableTest, modeString) {
       BaseHashTable::modeString(static_cast<BaseHashTable::HashMode>(100)));
 }
 
+DEBUG_ONLY_TEST_P(HashTableTest, nextBucketOffset) {
+  auto runTest = [&](BaseHashTable::HashMode mode, const RowTypePtr& type) {
+    std::vector<std::unique_ptr<VectorHasher>> keyHashers;
+    for (auto channel = 0; channel < type->size(); ++channel) {
+      keyHashers.emplace_back(
+          std::make_unique<VectorHasher>(type->childAt(channel), channel));
+    }
+    auto table = HashTable<true>::createForJoin(
+        std::move(keyHashers), {}, true, false, 1'000, pool());
+    auto testHelper = HashTableTestHelper<true>::create(table.get());
+    const uint64_t numDistincts = bits::nextPowerOfTwo(
+        2UL * std::numeric_limits<int32_t>::max() / testHelper.tableSlotSize());
+    const uint64_t totalSize = numDistincts * testHelper.tableSlotSize();
+    testHelper.allocateTables(numDistincts);
+    const auto bucketSize = testHelper.bucketSize();
+
+    struct {
+      uint64_t offset;
+      bool expectedNextOffsetError;
+      uint64_t expectedNextOffset;
+
+      std::string debugString() const {
+        return fmt::format(
+            "offset {}, expectedNextOffsetError {}, expectedNextOffset {}",
+            succinctBytes(offset),
+            expectedNextOffsetError,
+            succinctBytes(expectedNextOffset));
+      }
+    } testSettings[] = {
+        {1, true, 0},
+        {bucketSize - 1, true, 0},
+        {bucketSize + 1, true, 0},
+        {0, false, bucketSize},
+        {bucketSize, false, bucketSize + bucketSize},
+        {bits::nextPowerOfTwo(std::numeric_limits<int32_t>::max()),
+         false,
+         bits::nextPowerOfTwo(std::numeric_limits<int32_t>::max()) +
+             bucketSize},
+        {bits::nextPowerOfTwo(std::numeric_limits<int32_t>::max()) + 1,
+         true,
+         0},
+        {bits::nextPowerOfTwo(std::numeric_limits<int32_t>::max()) + bucketSize,
+         false,
+         bits::nextPowerOfTwo(std::numeric_limits<int32_t>::max()) +
+             2 * bucketSize},
+        {totalSize, true, 0},
+        {totalSize + bucketSize, true, 0},
+        {totalSize + 1, true, 0},
+        {totalSize - bucketSize, false, 0}};
+
+    for (const auto& testData : testSettings) {
+      SCOPED_TRACE(testData.debugString());
+
+      if (testData.expectedNextOffsetError) {
+        VELOX_ASSERT_THROW(testHelper.nextBucketOffset(testData.offset), "");
+      } else {
+        ASSERT_EQ(
+            testHelper.nextBucketOffset(testData.offset),
+            testData.expectedNextOffset);
+      }
+    }
+  };
+
+  const auto type = ROW({"key"}, {ROW({"k1"}, {BIGINT()})});
+  runTest(BaseHashTable::HashMode::kHash, type);
+  runTest(BaseHashTable::HashMode::kNormalizedKey, type);
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    HashTableTests,
+    HashTableTest,
+    testing::Values(true, false));
+
 /// This tests an issue only seen when the number of unique entries
 /// in the HashTable, crosses over int32 limit. The HashTable::loadTag()
 /// offset argument was int32 and for positions greater than int32 max,
@@ -841,24 +1073,27 @@ DEBUG_ONLY_TEST_P(HashTableTest, failureInCreateRowPartitions) {
   std::unique_ptr<HashTable<false>> topTable;
   std::vector<std::unique_ptr<BaseHashTable>> otherTables;
   for (int i = 0; i < 4; i++) {
-    auto batch = vectorMaker_->rowVector(
-        {vectorMaker_->flatVector<int64_t>(10, folly::identity)});
+    auto batch = makeRowVector({makeFlatVector<int64_t>(10, folly::identity)});
     std::vector<std::unique_ptr<VectorHasher>> hashers;
     hashers.push_back(std::make_unique<VectorHasher>(BIGINT(), 0));
     // Set minTableSizeForParallelJoinBuild to be really small so we can trigger
     // a parallel join build without needing a lot of data.
     auto table = HashTable<false>::createForJoin(
-        std::move(hashers), {BIGINT()}, true, false, 1, pool_.get());
+        std::move(hashers), {BIGINT()}, true, false, 1, pool());
     copyVectorsToTable({batch}, 0, table.get());
 
-    if (!topTable) {
+    if (topTable == nullptr) {
       topTable = std::move(table);
     } else {
       otherTables.emplace_back(std::move(table));
     }
   }
 
-  topTable->prepareJoinTable(std::move(otherTables), executor_.get());
+  topTable->prepareJoinTable(
+      std::move(otherTables),
+      BaseHashTable::kNoSpillInputStartPartitionBit,
+      executor_.get());
+  auto topTabletestHelper = HashTableTestHelper<false>::create(topTable.get());
 
   const std::string expectedFailureMessage =
       "Triggering expected failure in allocation";
@@ -916,7 +1151,7 @@ DEBUG_ONLY_TEST_P(HashTableTest, failureInCreateRowPartitions) {
   // Set hash mode to HASH and numNew to something much larger than the
   // capacity to trigger a rehash.
   VELOX_ASSERT_THROW(
-      topTable->testingSetHashMode(
+      topTabletestHelper.setHashMode(
           BaseHashTable::HashMode::kHash, topTable->capacity() * 2),
       expectedFailureMessage);
 
@@ -926,3 +1161,101 @@ DEBUG_ONLY_TEST_P(HashTableTest, failureInCreateRowPartitions) {
   // Any outstanding async work should be finish cleanly despite the exception.
   executor_->join();
 }
+
+TEST_P(HashTableTest, toStringSingleKey) {
+  std::vector<std::unique_ptr<VectorHasher>> hashers;
+  hashers.push_back(std::make_unique<VectorHasher>(BIGINT(), 0));
+
+  auto table = HashTable<false>::createForJoin(
+      std::move(hashers),
+      {}, /*dependentTypes*/
+      true /*allowDuplicates*/,
+      false /*hasProbedFlag*/,
+      1 /*minTableSizeForParallelJoinBuild*/,
+      pool());
+
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row / 2; }),
+  });
+
+  store(*table->rows(), data);
+
+  table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
+
+  ASSERT_NO_THROW(table->toString());
+  ASSERT_NO_THROW(table->toString(0));
+  ASSERT_NO_THROW(table->toString(10));
+  ASSERT_NO_THROW(table->toString(1000));
+  ASSERT_NO_THROW(table->toString(31, 5));
+}
+
+TEST_P(HashTableTest, toStringMultipleKeys) {
+  std::vector<std::unique_ptr<VectorHasher>> hashers;
+  hashers.push_back(std::make_unique<VectorHasher>(BIGINT(), 0));
+  hashers.push_back(std::make_unique<VectorHasher>(VARCHAR(), 1));
+
+  auto table = HashTable<false>::createForJoin(
+      std::move(hashers),
+      {}, /*dependentTypes*/
+      true /*allowDuplicates*/,
+      false /*hasProbedFlag*/,
+      1 /*minTableSizeForParallelJoinBuild*/,
+      pool());
+
+  vector_size_t size = 1'000;
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(size, [](auto row) { return row / 2; }),
+      makeFlatVector<std::string>(
+          size, [](auto row) { return std::string(row, 'x'); }),
+  });
+
+  store(*table->rows(), data);
+
+  table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
+
+  ASSERT_NO_THROW(table->toString());
+}
+
+TEST(HashTableTest, tableInsertPartitionInfo) {
+  std::vector<char*> overflows;
+  const auto testFn = [&](PartitionBoundIndexType start,
+                          PartitionBoundIndexType end) {
+    TableInsertPartitionInfo info{start, end, overflows};
+  };
+  struct {
+    PartitionBoundIndexType start;
+    PartitionBoundIndexType end;
+
+    std::string debugString() const {
+      return fmt::format("start {}, end {}", start, end);
+    }
+  } badSettings[] = {
+      {0, 0}, {-2, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {32, 1}, {32, 32}};
+  for (const auto& badData : badSettings) {
+    SCOPED_TRACE(badData.debugString());
+    VELOX_ASSERT_THROW(testFn(badData.start, badData.end), "");
+  }
+  ASSERT_TRUE(overflows.empty());
+
+  TableInsertPartitionInfo info{1, 1000, overflows};
+  ASSERT_TRUE(info.inRange(1));
+  ASSERT_FALSE(info.inRange(0));
+  ASSERT_FALSE(info.inRange(-1));
+  ASSERT_TRUE(info.inRange(999));
+  ASSERT_FALSE(info.inRange(1'000));
+  ASSERT_FALSE(info.inRange(12'000));
+  ASSERT_TRUE(overflows.empty());
+
+  const std::vector<uint64_t> insertBuffers{100, 200, 300, 500};
+  for (const auto insertBuffer : insertBuffers) {
+    info.addOverflow(reinterpret_cast<char*>(insertBuffer));
+  }
+  ASSERT_EQ(overflows.size(), insertBuffers.size());
+  for (int i = 0; i < insertBuffers.size(); ++i) {
+    ASSERT_EQ(insertBuffers[i], reinterpret_cast<uint64_t>(info.overflows[i]));
+  }
+  for (int i = 0; i < overflows.size(); ++i) {
+    ASSERT_EQ(overflows[i], info.overflows[i]);
+  }
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/JoinFuzzer.cpp b/velox/exec/tests/JoinFuzzer.cpp
deleted file mode 100644
index 78e4c89045c82..0000000000000
--- a/velox/exec/tests/JoinFuzzer.cpp
+++ /dev/null
@@ -1,734 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/exec/tests/JoinFuzzer.h"
-#include <boost/random/uniform_int_distribution.hpp>
-#include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-
-DEFINE_int32(steps, 10, "Number of plans to generate and test.");
-
-DEFINE_int32(
-    duration_sec,
-    0,
-    "For how long it should run (in seconds). If zero, "
-    "it executes exactly --steps iterations and exits.");
-
-DEFINE_int32(
-    batch_size,
-    100,
-    "The number of elements on each generated vector.");
-
-DEFINE_int32(num_batches, 5, "The number of generated vectors.");
-
-DEFINE_double(
-    null_ratio,
-    0.1,
-    "Chance of adding a null value in a vector "
-    "(expressed as double from 0 to 1).");
-
-DEFINE_bool(enable_spill, true, "Whether to test plans with spilling enabled");
-
-namespace facebook::velox::exec::test {
-
-namespace {
-
-class JoinFuzzer {
- public:
-  explicit JoinFuzzer(size_t initialSeed);
-
-  void go();
-
- private:
-  static VectorFuzzer::Options getFuzzerOptions() {
-    VectorFuzzer::Options opts;
-    opts.vectorSize = FLAGS_batch_size;
-    opts.stringVariableLength = true;
-    opts.stringLength = 100;
-    opts.nullRatio = FLAGS_null_ratio;
-    return opts;
-  }
-
-  void seed(size_t seed) {
-    currentSeed_ = seed;
-    vectorFuzzer_.reSeed(seed);
-    rng_.seed(currentSeed_);
-  }
-
-  void reSeed() {
-    seed(rng_());
-  }
-
-  /// Randomly pick a join type to test.
-  core::JoinType pickJoinType();
-
-  void verify(core::JoinType joinType);
-
-  /// Returns a list of randomly generated join key types.
-  std::vector<TypePtr> generateJoinKeyTypes(int32_t numKeys);
-
-  /// Returns randomly generated probe input with upto 3 additional payload
-  /// columns.
-  std::vector<RowVectorPtr> generateProbeInput(
-      const std::vector<std::string>& keyNames,
-      const std::vector<TypePtr>& keyTypes);
-
-  /// Same as generateProbeInput() but copies over 10% of the input in the probe
-  /// columns to ensure some matches during joining. Also generates an empty
-  /// input with a 10% chance.
-  std::vector<RowVectorPtr> generateBuildInput(
-      const std::vector<RowVectorPtr>& probeInput,
-      const std::vector<std::string>& probeKeys,
-      const std::vector<std::string>& buildKeys);
-
-  void shuffleJoinKeys(
-      std::vector<std::string>& probeKeys,
-      std::vector<std::string>& buildKeys);
-
-  RowVectorPtr execute(const core::PlanNodePtr& plan, bool injectSpill);
-
-  std::optional<MaterializedRowMultiset> computeDuckDbResult(
-      const std::vector<RowVectorPtr>& probeInput,
-      const std::vector<RowVectorPtr>& buildInput,
-      const core::PlanNodePtr& plan);
-
-  int32_t randInt(int32_t min, int32_t max) {
-    return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
-  }
-
-  FuzzerGenerator rng_;
-  size_t currentSeed_{0};
-
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  VectorFuzzer vectorFuzzer_;
-};
-
-JoinFuzzer::JoinFuzzer(size_t initialSeed)
-    : vectorFuzzer_{getFuzzerOptions(), pool_.get()} {
-  seed(initialSeed);
-}
-
-template <typename T>
-bool isDone(size_t i, T startTime) {
-  if (FLAGS_duration_sec > 0) {
-    std::chrono::duration<double> elapsed =
-        std::chrono::system_clock::now() - startTime;
-    return elapsed.count() >= FLAGS_duration_sec;
-  }
-  return i >= FLAGS_steps;
-}
-
-core::JoinType JoinFuzzer::pickJoinType() {
-  // Right joins are tested by flipping sides of the left joins.
-  static std::vector<core::JoinType> kJoinTypes = {
-      core::JoinType::kInner,
-      core::JoinType::kLeft,
-      core::JoinType::kFull,
-      core::JoinType::kLeftSemiFilter,
-      core::JoinType::kLeftSemiProject,
-      core::JoinType::kAnti,
-  };
-
-  size_t idx = randInt(0, kJoinTypes.size() - 1);
-  return kJoinTypes[idx];
-}
-
-std::vector<TypePtr> JoinFuzzer::generateJoinKeyTypes(int32_t numKeys) {
-  std::vector<TypePtr> types;
-  types.reserve(numKeys);
-  for (auto i = 0; i < numKeys; ++i) {
-    // Pick random scalar type.
-    types.push_back(vectorFuzzer_.randType(0 /*maxDepth*/));
-  }
-  return types;
-}
-
-std::vector<RowVectorPtr> JoinFuzzer::generateProbeInput(
-    const std::vector<std::string>& keyNames,
-    const std::vector<TypePtr>& keyTypes) {
-  std::vector<std::string> names = keyNames;
-  std::vector<TypePtr> types = keyTypes;
-
-  // Add up to 3 payload columns.
-  auto numPayload = randInt(0, 3);
-  for (auto i = 0; i < numPayload; ++i) {
-    names.push_back(fmt::format("tp{}", i + keyNames.size()));
-    types.push_back(vectorFuzzer_.randType(2 /*maxDepth*/));
-  }
-
-  auto inputType = ROW(std::move(names), std::move(types));
-  std::vector<RowVectorPtr> input;
-  for (auto i = 0; i < FLAGS_num_batches; ++i) {
-    input.push_back(vectorFuzzer_.fuzzInputRow(inputType));
-  }
-  return input;
-}
-
-std::vector<RowVectorPtr> JoinFuzzer::generateBuildInput(
-    const std::vector<RowVectorPtr>& probeInput,
-    const std::vector<std::string>& probeKeys,
-    const std::vector<std::string>& buildKeys) {
-  std::vector<std::string> names = buildKeys;
-  std::vector<TypePtr> types;
-  for (const auto& key : probeKeys) {
-    types.push_back(asRowType(probeInput[0]->type())->findChild(key));
-  }
-
-  // Add up to 3 payload columns.
-  auto numPayload = randInt(0, 3);
-  for (auto i = 0; i < numPayload; ++i) {
-    names.push_back(fmt::format("bp{}", i + buildKeys.size()));
-    types.push_back(vectorFuzzer_.randType(2 /*maxDepth*/));
-  }
-
-  auto rowType = ROW(std::move(names), std::move(types));
-
-  // 1 in 10 times use empty build.
-  // TODO Use non-empty build with no matches sometimes.
-  if (vectorFuzzer_.coinToss(0.1)) {
-    return {BaseVector::create<RowVector>(rowType, 0, pool_.get())};
-  }
-
-  // TODO Remove the assumption that probeKeys are the first columns in
-  // probeInput.
-
-  // To ensure there are some matches, sample with replacement 10% of probe join
-  // keys and use these as build keys.
-  // TODO Add a few random rows as well.
-  std::vector<RowVectorPtr> input;
-  for (const auto& probe : probeInput) {
-    auto numRows = 1 + probe->size() / 10;
-    auto build = BaseVector::create<RowVector>(rowType, numRows, probe->pool());
-
-    // Pick probe side rows to copy.
-    std::vector<vector_size_t> rowNumbers(numRows);
-    for (auto i = 0; i < numRows; ++i) {
-      rowNumbers[i] = randInt(0, probe->size() - 1);
-    }
-
-    SelectivityVector rows(numRows);
-    for (auto i = 0; i < probeKeys.size(); ++i) {
-      build->childAt(i)->resize(numRows);
-      build->childAt(i)->copy(probe->childAt(i).get(), rows, rowNumbers.data());
-    }
-
-    for (auto i = 0; i < numPayload; ++i) {
-      auto column = i + probeKeys.size();
-      build->childAt(column) =
-          vectorFuzzer_.fuzz(rowType->childAt(column), numRows);
-    }
-
-    input.push_back(build);
-  }
-
-  return input;
-}
-
-std::vector<RowVectorPtr> flatten(const std::vector<RowVectorPtr>& vectors) {
-  std::vector<RowVectorPtr> flatVectors;
-  for (const auto& vector : vectors) {
-    auto flat = BaseVector::create<RowVector>(
-        vector->type(), vector->size(), vector->pool());
-    flat->copy(vector.get(), 0, 0, vector->size());
-    flatVectors.push_back(flat);
-  }
-
-  return flatVectors;
-}
-
-RowVectorPtr JoinFuzzer::execute(
-    const core::PlanNodePtr& plan,
-    bool injectSpill) {
-  LOG(INFO) << "Executing query plan: " << std::endl
-            << plan->toString(true, true);
-
-  AssertQueryBuilder builder(plan);
-  std::shared_ptr<TempDirectoryPath> spillDirectory;
-  if (injectSpill) {
-    spillDirectory = exec::test::TempDirectoryPath::create();
-    builder.config(core::QueryConfig::kSpillEnabled, "true")
-        .config(core::QueryConfig::kAggregationSpillEnabled, "true")
-        .config(core::QueryConfig::kTestingSpillPct, "100")
-        .spillDirectory(spillDirectory->path);
-  }
-
-  auto result = builder.maxDrivers(2).copyResults(pool_.get());
-  LOG(INFO) << "Results: " << result->toString();
-  if (VLOG_IS_ON(1)) {
-    VLOG(1) << std::endl << result->toString(0, result->size());
-  }
-  return result;
-}
-
-std::optional<core::JoinType> tryFlipJoinType(core::JoinType joinType) {
-  switch (joinType) {
-    case core::JoinType::kInner:
-      return joinType;
-    case core::JoinType::kLeft:
-      return core::JoinType::kRight;
-    case core::JoinType::kRight:
-      return core::JoinType::kLeft;
-    case core::JoinType::kFull:
-      return joinType;
-    case core::JoinType::kLeftSemiFilter:
-      return core::JoinType::kRightSemiFilter;
-    case core::JoinType::kLeftSemiProject:
-      return core::JoinType::kRightSemiProject;
-    case core::JoinType::kRightSemiFilter:
-      return core::JoinType::kLeftSemiFilter;
-    case core::JoinType::kRightSemiProject:
-      return core::JoinType::kLeftSemiProject;
-    default:
-      return std::nullopt;
-  }
-}
-
-core::PlanNodePtr tryFlipJoinSides(const core::HashJoinNode& joinNode) {
-  auto flippedJoinType = tryFlipJoinType(joinNode.joinType());
-  if (!flippedJoinType.has_value()) {
-    return nullptr;
-  }
-
-  return std::make_shared<core::HashJoinNode>(
-      joinNode.id(),
-      flippedJoinType.value(),
-      joinNode.isNullAware(),
-      joinNode.rightKeys(),
-      joinNode.leftKeys(),
-      joinNode.filter(),
-      joinNode.sources()[1],
-      joinNode.sources()[0],
-      joinNode.outputType());
-}
-
-bool containsTypeKind(const TypePtr& type, const TypeKind& search) {
-  if (type->kind() == search) {
-    return true;
-  }
-
-  for (auto i = 0; i < type->size(); ++i) {
-    if (containsTypeKind(type->childAt(i), search)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool containsType(const TypePtr& type, const TypePtr& search) {
-  if (type->equivalent(*search)) {
-    return true;
-  }
-
-  for (auto i = 0; i < type->size(); ++i) {
-    if (containsType(type->childAt(i), search)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool containsUnsupportedTypes(const TypePtr& type) {
-  // Skip queries that use Timestamp, Varbinary, and IntervalDayTime types.
-  // DuckDB doesn't support nanosecond precision for timestamps or casting from
-  // Bigint to Interval.
-  // TODO Investigate mismatches reported when comparing Varbinary.
-  return containsTypeKind(type, TypeKind::TIMESTAMP) ||
-      containsTypeKind(type, TypeKind::VARBINARY) ||
-      containsType(type, INTERVAL_DAY_TIME());
-}
-
-std::optional<MaterializedRowMultiset> JoinFuzzer::computeDuckDbResult(
-    const std::vector<RowVectorPtr>& probeInput,
-    const std::vector<RowVectorPtr>& buildInput,
-    const core::PlanNodePtr& plan) {
-  if (containsUnsupportedTypes(probeInput[0]->type())) {
-    return std::nullopt;
-  }
-
-  if (containsUnsupportedTypes(buildInput[0]->type())) {
-    return std::nullopt;
-  }
-
-  DuckDbQueryRunner queryRunner;
-  queryRunner.createTable("t", probeInput);
-  queryRunner.createTable("u", buildInput);
-
-  auto joinNode = dynamic_cast<const core::HashJoinNode*>(plan.get());
-  VELOX_CHECK_NOT_NULL(joinNode);
-
-  auto joinKeysToSql = [](auto keys) {
-    std::stringstream out;
-    for (auto i = 0; i < keys.size(); ++i) {
-      if (i > 0) {
-        out << ", ";
-      }
-      out << keys[i]->name();
-    }
-    return out.str();
-  };
-
-  auto equiClausesToSql = [](auto joinNode) {
-    std::stringstream out;
-    for (auto i = 0; i < joinNode->leftKeys().size(); ++i) {
-      if (i > 0) {
-        out << " AND ";
-      }
-      out << joinNode->leftKeys()[i]->name() << " = "
-          << joinNode->rightKeys()[i]->name();
-    }
-    return out.str();
-  };
-
-  const auto& outputNames = plan->outputType()->names();
-
-  std::stringstream sql;
-  if (joinNode->isLeftSemiProjectJoin()) {
-    sql << "SELECT "
-        << folly::join(", ", outputNames.begin(), --outputNames.end());
-  } else {
-    sql << "SELECT " << folly::join(", ", outputNames);
-  }
-
-  switch (joinNode->joinType()) {
-    case core::JoinType::kInner:
-      sql << " FROM t INNER JOIN u ON " << equiClausesToSql(joinNode);
-      break;
-    case core::JoinType::kLeft:
-      sql << " FROM t LEFT JOIN u ON " << equiClausesToSql(joinNode);
-      break;
-    case core::JoinType::kFull:
-      sql << " FROM t FULL OUTER JOIN u ON " << equiClausesToSql(joinNode);
-      break;
-    case core::JoinType::kLeftSemiFilter:
-      if (joinNode->leftKeys().size() > 1) {
-        return std::nullopt;
-      }
-      sql << " FROM t WHERE " << joinKeysToSql(joinNode->leftKeys())
-          << " IN (SELECT " << joinKeysToSql(joinNode->rightKeys())
-          << " FROM u)";
-      break;
-    case core::JoinType::kLeftSemiProject:
-      if (joinNode->isNullAware()) {
-        sql << ", " << joinKeysToSql(joinNode->leftKeys()) << " IN (SELECT "
-            << joinKeysToSql(joinNode->rightKeys()) << " FROM u) FROM t";
-      } else {
-        sql << ", EXISTS (SELECT * FROM u WHERE " << equiClausesToSql(joinNode)
-            << ") FROM t";
-      }
-      break;
-    case core::JoinType::kAnti:
-      if (joinNode->isNullAware()) {
-        sql << " FROM t WHERE " << joinKeysToSql(joinNode->leftKeys())
-            << " NOT IN (SELECT " << joinKeysToSql(joinNode->rightKeys())
-            << " FROM u)";
-      } else {
-        sql << " FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE "
-            << equiClausesToSql(joinNode) << ")";
-      }
-      break;
-    default:
-      VELOX_UNREACHABLE();
-  }
-
-  return queryRunner.execute(sql.str(), plan->outputType());
-}
-
-std::vector<std::string> fieldNames(
-    const std::vector<core::FieldAccessTypedExprPtr>& fields) {
-  std::vector<std::string> names;
-  names.reserve(fields.size());
-  for (const auto& field : fields) {
-    names.push_back(field->name());
-  }
-  return names;
-}
-
-core::PlanNodePtr makeDefaultPlan(
-    core::JoinType joinType,
-    bool nullAware,
-    const std::vector<std::string>& probeKeys,
-    const std::vector<std::string>& buildKeys,
-    const std::vector<RowVectorPtr>& probeInput,
-    const std::vector<RowVectorPtr>& buildInput,
-    const std::vector<std::string>& output) {
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  return PlanBuilder(planNodeIdGenerator)
-      .values(probeInput)
-      .hashJoin(
-          probeKeys,
-          buildKeys,
-          PlanBuilder(planNodeIdGenerator).values(buildInput).planNode(),
-          "" /*filter*/,
-          output,
-          joinType,
-          nullAware)
-      .planNode();
-}
-
-std::vector<core::PlanNodePtr> makeSources(
-    const std::vector<RowVectorPtr>& input,
-    std::shared_ptr<core::PlanNodeIdGenerator>& planNodeIdGenerator) {
-  auto numSources = std::min<size_t>(4, input.size());
-  std::vector<std::vector<RowVectorPtr>> sourceInputs(numSources);
-  for (auto i = 0; i < input.size(); ++i) {
-    sourceInputs[i % numSources].push_back(input[i]);
-  }
-
-  std::vector<core::PlanNodePtr> sourceNodes;
-  for (const auto& sourceInput : sourceInputs) {
-    sourceNodes.push_back(
-        PlanBuilder(planNodeIdGenerator).values(sourceInput).planNode());
-  }
-
-  return sourceNodes;
-}
-
-void makeAlternativePlans(
-    const core::PlanNodePtr& plan,
-    const std::vector<RowVectorPtr>& probeInput,
-    const std::vector<RowVectorPtr>& buildInput,
-    std::vector<core::PlanNodePtr>& plans) {
-  auto joinNode = std::dynamic_pointer_cast<const core::HashJoinNode>(plan);
-  VELOX_CHECK_NOT_NULL(joinNode);
-
-  // Flip join sides.
-  if (auto flippedPlan = tryFlipJoinSides(*joinNode)) {
-    plans.push_back(flippedPlan);
-  }
-
-  // Parallelize probe and build sides.
-  auto probeKeys = fieldNames(joinNode->leftKeys());
-  auto buildKeys = fieldNames(joinNode->rightKeys());
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  plans.push_back(PlanBuilder(planNodeIdGenerator)
-                      .localPartitionRoundRobin(
-                          makeSources(probeInput, planNodeIdGenerator))
-                      .hashJoin(
-                          probeKeys,
-                          buildKeys,
-                          PlanBuilder(planNodeIdGenerator)
-                              .localPartitionRoundRobin(
-                                  makeSources(buildInput, planNodeIdGenerator))
-                              .planNode(),
-                          "" /*filter*/,
-                          joinNode->outputType()->names(),
-                          joinNode->joinType(),
-                          joinNode->isNullAware())
-                      .planNode());
-
-  // Use OrderBy + MergeJoin (if join type is inner or left).
-  if (joinNode->isInnerJoin() || joinNode->isLeftJoin()) {
-    planNodeIdGenerator->reset();
-    plans.push_back(PlanBuilder(planNodeIdGenerator)
-                        .values(probeInput)
-                        .orderBy(probeKeys, false)
-                        .mergeJoin(
-                            probeKeys,
-                            buildKeys,
-                            PlanBuilder(planNodeIdGenerator)
-                                .values(buildInput)
-                                .orderBy(buildKeys, false)
-                                .planNode(),
-                            "" /*filter*/,
-                            asRowType(joinNode->outputType())->names(),
-                            joinNode->joinType())
-                        .planNode());
-  }
-}
-
-std::vector<std::string> makeNames(const std::string& prefix, size_t n) {
-  std::vector<std::string> names;
-  names.reserve(n);
-  for (auto i = 0; i < n; ++i) {
-    names.push_back(fmt::format("{}{}", prefix, i));
-  }
-  return names;
-}
-
-void JoinFuzzer::shuffleJoinKeys(
-    std::vector<std::string>& probeKeys,
-    std::vector<std::string>& buildKeys) {
-  auto numKeys = probeKeys.size();
-  if (numKeys == 1) {
-    return;
-  }
-
-  std::vector<column_index_t> columnIndices(numKeys);
-  std::iota(columnIndices.begin(), columnIndices.end(), 0);
-  std::shuffle(columnIndices.begin(), columnIndices.end(), rng_);
-
-  auto copyProbeKeys = probeKeys;
-  auto copyBuildKeys = buildKeys;
-
-  for (auto i = 0; i < numKeys; ++i) {
-    probeKeys[i] = copyProbeKeys[columnIndices[i]];
-    buildKeys[i] = copyBuildKeys[columnIndices[i]];
-  }
-}
-
-RowTypePtr concat(const RowTypePtr& a, const RowTypePtr& b) {
-  std::vector<std::string> names = a->names();
-  std::vector<TypePtr> types = a->children();
-
-  for (auto i = 0; i < b->size(); ++i) {
-    names.push_back(b->nameOf(i));
-    types.push_back(b->childAt(i));
-  }
-
-  return ROW(std::move(names), std::move(types));
-}
-
-void JoinFuzzer::verify(core::JoinType joinType) {
-  const bool nullAware =
-      isNullAwareSupported(joinType) && vectorFuzzer_.coinToss(0.5);
-
-  const auto numKeys = nullAware ? 1 : randInt(1, 5);
-
-  // Pick number and types of join keys.
-  std::vector<TypePtr> keyTypes = generateJoinKeyTypes(numKeys);
-  std::vector<std::string> probeKeys = makeNames("t", keyTypes.size());
-  std::vector<std::string> buildKeys = makeNames("u", keyTypes.size());
-
-  auto probeInput = generateProbeInput(probeKeys, keyTypes);
-  auto buildInput = generateBuildInput(probeInput, probeKeys, buildKeys);
-
-  // Flatten inputs.
-  auto flatProbeInput = flatten(probeInput);
-  auto flatBuildInput = flatten(buildInput);
-
-  if (VLOG_IS_ON(1)) {
-    VLOG(1) << "Probe input: " << probeInput[0]->toString();
-    for (const auto& v : flatProbeInput) {
-      VLOG(1) << std::endl << v->toString(0, v->size());
-    }
-
-    VLOG(1) << "Build input: " << buildInput[0]->toString();
-    for (const auto& v : flatBuildInput) {
-      VLOG(1) << std::endl << v->toString(0, v->size());
-    }
-  }
-
-  auto output =
-      (core::isLeftSemiProjectJoin(joinType) ||
-       core::isLeftSemiFilterJoin(joinType) || core::isAntiJoin(joinType))
-      ? asRowType(probeInput[0]->type())->names()
-      : concat(
-            asRowType(probeInput[0]->type()), asRowType(buildInput[0]->type()))
-            ->names();
-
-  // Shuffle output columns.
-  std::shuffle(output.begin(), output.end(), rng_);
-
-  // Remove some output columns.
-  auto numOutput = randInt(1, output.size());
-  output.resize(numOutput);
-
-  if (core::isLeftSemiProjectJoin(joinType) ||
-      core::isRightSemiProjectJoin(joinType)) {
-    output.push_back("match");
-  }
-
-  shuffleJoinKeys(probeKeys, buildKeys);
-
-  auto plan = makeDefaultPlan(
-      joinType,
-      nullAware,
-      probeKeys,
-      buildKeys,
-      probeInput,
-      buildInput,
-      output);
-
-  auto expected = execute(plan, false /*injectSpill*/);
-
-  // Verify results against DuckDB.
-  if (auto duckDbResult = computeDuckDbResult(probeInput, buildInput, plan)) {
-    VELOX_CHECK(
-        assertEqualResults(duckDbResult.value(), {expected}),
-        "Velox and DuckDB results don't match");
-  }
-
-  std::vector<core::PlanNodePtr> altPlans;
-  altPlans.push_back(makeDefaultPlan(
-      joinType,
-      nullAware,
-      probeKeys,
-      buildKeys,
-      flatProbeInput,
-      flatBuildInput,
-      output));
-  makeAlternativePlans(plan, probeInput, buildInput, altPlans);
-  makeAlternativePlans(plan, flatProbeInput, flatBuildInput, altPlans);
-
-  for (auto i = 0; i < altPlans.size(); ++i) {
-    LOG(INFO) << "Testing plan #" << i;
-    auto actual = execute(altPlans[i], false /*injectSpill*/);
-    VELOX_CHECK(
-        assertEqualResults({expected}, {actual}),
-        "Logically equivalent plans produced different results");
-
-    if (FLAGS_enable_spill) {
-      // Spilling for right semi project doesn't work yet.
-      if (auto hashJoin = std::dynamic_pointer_cast<const core::HashJoinNode>(
-              altPlans[i])) {
-        if (hashJoin->isRightSemiProjectJoin()) {
-          continue;
-        }
-      }
-
-      LOG(INFO) << "Testing plan #" << i << " with spilling";
-      actual = execute(altPlans[i], true /*injectSpill*/);
-      VELOX_CHECK(
-          assertEqualResults({expected}, {actual}),
-          "Logically equivalent plans produced different results");
-    }
-  }
-}
-
-void JoinFuzzer::go() {
-  VELOX_CHECK(
-      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
-      "Either --steps or --duration_sec needs to be greater than zero.")
-
-  auto startTime = std::chrono::system_clock::now();
-  size_t iteration = 0;
-
-  while (!isDone(iteration, startTime)) {
-    LOG(INFO) << "==============================> Started iteration "
-              << iteration << " (seed: " << currentSeed_ << ")";
-
-    // Pick join type.
-    auto joinType = pickJoinType();
-
-    verify(joinType);
-
-    LOG(INFO) << "==============================> Done with iteration "
-              << iteration;
-
-    reSeed();
-    ++iteration;
-  }
-}
-
-} // namespace
-
-void joinFuzzer(size_t seed) {
-  JoinFuzzer(seed).go();
-}
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/JoinFuzzerRunner.h b/velox/exec/tests/JoinFuzzerRunner.h
deleted file mode 100644
index e50646538b04f..0000000000000
--- a/velox/exec/tests/JoinFuzzerRunner.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <gtest/gtest.h>
-
-#include "velox/common/file/FileSystems.h"
-#include "velox/exec/tests/JoinFuzzer.h"
-#include "velox/serializers/PrestoSerializer.h"
-
-/// Join FuzzerRunner leverages JoinFuzzer and VectorFuzzer to
-/// automatically generate and execute join tests. It works by:
-///
-///  1. Picking a random join type.
-///  2. Generating a random set of input data (vector), with a variety of
-///     encodings and data layouts.
-///  3. Executing a variety of logically equivalent query plans and
-///     asserting results are the same.
-///  4. Rinse and repeat.
-///
-/// The common usage pattern is as following:
-///
-///  $ ./velox_join_fuzzer_test --steps 10000
-///
-/// The important flags that control JoinFuzzer's behavior are:
-///
-///  --steps: how many iterations to run.
-///  --duration_sec: alternatively, for how many seconds it should run (takes
-///          precedence over --steps).
-///  --seed: pass a deterministic seed to reproduce the behavior (each iteration
-///          will print a seed as part of the logs).
-///  --v=1: verbose logging; print a lot more details about the execution.
-///  --batch_size: size of input vector batches generated.
-///  --num_batches: number if input vector batches to generate.
-///
-/// e.g:
-///
-///  $ ./velox_join_fuzzer_test \
-///         --steps 10000 \
-///         --seed 123 \
-///         --v=1
-
-class JoinFuzzerRunner {
- public:
-  static int run(size_t seed) {
-    facebook::velox::serializer::presto::PrestoVectorSerde::
-        registerVectorSerde();
-    facebook::velox::filesystems::registerLocalFileSystem();
-
-    facebook::velox::exec::test::joinFuzzer(seed);
-    return RUN_ALL_TESTS();
-  }
-};
diff --git a/velox/exec/tests/JoinFuzzerTest.cpp b/velox/exec/tests/JoinFuzzerTest.cpp
index 78097953ec4c2..9d6f6bf38bd10 100644
--- a/velox/exec/tests/JoinFuzzerTest.cpp
+++ b/velox/exec/tests/JoinFuzzerTest.cpp
@@ -19,7 +19,11 @@
 #include <gtest/gtest.h>
 #include <unordered_set>
 
-#include "velox/exec/tests/JoinFuzzerRunner.h"
+#include "velox/exec/fuzzer/DuckQueryRunner.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/JoinFuzzerRunner.h"
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 
 DEFINE_int64(
     seed,
@@ -27,14 +31,60 @@ DEFINE_int64(
     "Initial seed for random number generator used to reproduce previous "
     "results (0 means start with random seed).");
 
+DEFINE_string(
+    presto_url,
+    "",
+    "Presto coordinator URI along with port. If set, we use Presto "
+    "source of truth. Otherwise, use DuckDB. Example: "
+    "--presto_url=http://127.0.0.1:8080");
+
+DEFINE_uint32(
+    req_timeout_ms,
+    1000,
+    "Timeout in milliseconds for HTTP requests made to reference DB, "
+    "such as Presto. Example: --req_timeout_ms=2000");
+
+DEFINE_int64(allocator_capacity, 8L << 30, "Allocator capacity in bytes.");
+
+DEFINE_int64(arbitrator_capacity, 6L << 30, "Arbitrator capacity in bytes.");
+
+using namespace facebook::velox::exec;
+
+namespace {
+std::unique_ptr<test::ReferenceQueryRunner> setupReferenceQueryRunner(
+    facebook::velox::memory::MemoryPool* aggregatePool,
+    const std::string& prestoUrl,
+    const std::string& runnerName,
+    const uint32_t& reqTimeoutMs) {
+  if (prestoUrl.empty()) {
+    auto duckQueryRunner =
+        std::make_unique<test::DuckQueryRunner>(aggregatePool);
+    LOG(INFO) << "Using DuckDB as the reference DB.";
+    return duckQueryRunner;
+  }
+
+  LOG(INFO) << "Using Presto as the reference DB.";
+  return std::make_unique<test::PrestoQueryRunner>(
+      aggregatePool,
+      prestoUrl,
+      runnerName,
+      static_cast<std::chrono::milliseconds>(reqTimeoutMs));
+}
+} // namespace
+
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
 
   // Calls common init functions in the necessary order, initializing
   // singletons, installing proper signal handlers for better debugging
   // experience, and initialize glog and gflags.
-  folly::init(&argc, &argv);
-
-  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
-  return JoinFuzzerRunner::run(initialSeed);
+  folly::Init init(&argc, &argv);
+  test::setupMemory(FLAGS_allocator_capacity, FLAGS_arbitrator_capacity);
+  std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
+      facebook::velox::memory::memoryManager()->addRootPool()};
+  auto referenceQueryRunner = setupReferenceQueryRunner(
+      rootPool.get(), FLAGS_presto_url, "join_fuzzer", FLAGS_req_timeout_ms);
+  const size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+  return test::JoinFuzzerRunner::run(
+      initialSeed, std::move(referenceQueryRunner));
 }
diff --git a/velox/exec/tests/JoinSpillInputBenchmarkBase.cpp b/velox/exec/tests/JoinSpillInputBenchmarkBase.cpp
new file mode 100644
index 0000000000000..46d9d9582cb7d
--- /dev/null
+++ b/velox/exec/tests/JoinSpillInputBenchmarkBase.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <deque>
+#include "velox/serializers/PrestoSerializer.h"
+
+#include "velox/exec/tests/JoinSpillInputBenchmarkBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::common;
+using namespace facebook::velox::memory;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::exec::test {
+namespace {
+const int numSampleVectors = 100;
+} // namespace
+
+void JoinSpillInputBenchmarkBase::setUp() {
+  SpillerBenchmarkBase::setUp();
+  common::SpillConfig spillConfig;
+  spillConfig.getSpillDirPathCb = [&]() -> std::string_view {
+    return spillDir_;
+  };
+  spillConfig.updateAndCheckSpillLimitCb = [&](uint64_t) {};
+  spillConfig.fileNamePrefix = FLAGS_spiller_benchmark_name;
+  spillConfig.writeBufferSize = FLAGS_spiller_benchmark_write_buffer_size;
+  spillConfig.executor = executor_.get();
+  spillConfig.compressionKind =
+      stringToCompressionKind(FLAGS_spiller_benchmark_compression_kind);
+  spillConfig.maxFileSize = FLAGS_spiller_benchmark_max_spill_file_size;
+  spillConfig.maxSpillRunRows = 0;
+  spillConfig.fileCreateConfig = {};
+
+  spiller_ = std::make_unique<Spiller>(
+      exec::Spiller::Type::kHashJoinProbe,
+      rowType_,
+      HashBitRange{29, 29},
+      &spillConfig,
+      &spillStats_);
+  spiller_->setPartitionsSpilled({0});
+}
+
+void JoinSpillInputBenchmarkBase::run() {
+  MicrosecondTimer timer(&executionTimeUs_);
+  for (auto i = 0; i < numInputVectors_; ++i) {
+    spiller_->spill(0, rowVectors_[i % numSampleVectors]);
+  }
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/JoinSpillInputBenchmarkBase.h b/velox/exec/tests/JoinSpillInputBenchmarkBase.h
new file mode 100644
index 0000000000000..3130808026725
--- /dev/null
+++ b/velox/exec/tests/JoinSpillInputBenchmarkBase.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/SpillerBenchmarkBase.h"
+
+namespace facebook::velox::exec::test {
+// This test measures the spill input overhead in spill join & probe.
+class JoinSpillInputBenchmarkBase : public SpillerBenchmarkBase {
+ public:
+  JoinSpillInputBenchmarkBase() = default;
+
+  /// Sets up the test.
+  void setUp() override;
+
+  /// Runs the test.
+  void run() override;
+};
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/LimitTest.cpp b/velox/exec/tests/LimitTest.cpp
index fc1e7ccb63e58..0c1cae8fe15e4 100644
--- a/velox/exec/tests/LimitTest.cpp
+++ b/velox/exec/tests/LimitTest.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
@@ -35,18 +36,27 @@ TEST_F(LimitTest, basic) {
   }
   createDuckDbTable(vectors);
 
-  auto makePlan = [&](int32_t offset, int32_t limit) {
+  auto makePlan = [&](int64_t offset, int64_t limit) {
     return PlanBuilder().values(vectors).limit(offset, limit, true).planNode();
   };
 
   assertQuery(makePlan(0, 10), "SELECT * FROM tmp LIMIT 10");
-  assertQuery(makePlan(0, 1'000), "SELECT * FROM tmp LIMIT 1000");
+  int64_t limit = (int64_t)(std::numeric_limits<int32_t>::max()) + 1000000;
+  int64_t offset = (int64_t)(std::numeric_limits<int32_t>::max()) + 1000;
+  assertQuery(
+      makePlan(0, limit), fmt::format("SELECT * FROM tmp LIMIT {}", limit));
   assertQuery(makePlan(0, 1'234), "SELECT * FROM tmp LIMIT 1234");
 
   assertQuery(makePlan(17, 10), "SELECT * FROM tmp OFFSET 17 LIMIT 10");
   assertQuery(makePlan(17, 983), "SELECT * FROM tmp OFFSET 17 LIMIT 983");
-  assertQuery(makePlan(17, 1'000), "SELECT * FROM tmp OFFSET 17 LIMIT 1000");
   assertQuery(makePlan(17, 2'000), "SELECT * FROM tmp OFFSET 17 LIMIT 2000");
+  assertQuery(
+      makePlan(offset, limit),
+      fmt::format("SELECT * FROM tmp OFFSET {} LIMIT {}", offset, limit));
+
+  assertQuery(
+      makePlan(offset, 2000),
+      fmt::format("SELECT * FROM tmp OFFSET {} LIMIT 2000", offset));
 
   assertQuery(makePlan(1'000, 145), "SELECT * FROM tmp OFFSET 1000 LIMIT 145");
   assertQuery(
@@ -69,7 +79,7 @@ TEST_F(LimitTest, limitOverLocalExchange) {
       {makeFlatVector<int32_t>(1'000, [](auto row) { return row; })});
 
   auto file = TempFilePath::create();
-  writeToFile(file->path, {data});
+  writeToFile(file->getPath(), {data});
 
   core::PlanNodeId scanNodeId;
 
@@ -81,13 +91,13 @@ TEST_F(LimitTest, limitOverLocalExchange) {
                         .limit(0, 20, true)
                         .planNode();
 
-  TaskCursor cursor(params);
-  cursor.task()->addSplit(
-      scanNodeId, exec::Split(makeHiveConnectorSplit(file->path)));
+  auto cursor = TaskCursor::create(params);
+  cursor->task()->addSplit(
+      scanNodeId, exec::Split(makeHiveConnectorSplit(file->getPath())));
 
   int32_t numRead = 0;
-  while (cursor.moveNext()) {
-    auto vector = cursor.current();
+  while (cursor->moveNext()) {
+    auto vector = cursor->current();
     numRead += vector->size();
   }
 
@@ -95,5 +105,39 @@ TEST_F(LimitTest, limitOverLocalExchange) {
   // receiving that message.
 
   ASSERT_EQ(20, numRead);
-  ASSERT_TRUE(waitForTaskCompletion(cursor.task().get()));
+  ASSERT_TRUE(waitForTaskCompletion(cursor->task().get()));
+}
+
+TEST_F(LimitTest, partialLimitEagerFlush) {
+  std::vector<RowVectorPtr> batches(
+      10, makeRowVector({makeFlatVector(std::vector<int64_t>(1, 0))}));
+  auto test = [&](bool projectInBetween) {
+    SCOPED_TRACE(fmt::format("projectInBetween={}", projectInBetween));
+    CursorParameters params;
+    auto builder = PlanBuilder().values(batches).limit(0, 10, true);
+    if (projectInBetween) {
+      builder = builder.project({"c0 + 1 as c0"});
+    }
+    params.planNode = builder.partitionedOutput({}, 1).planNode();
+    auto cursor = TaskCursor::create(params);
+    ASSERT_FALSE(cursor->moveNext());
+    auto bufferManager = exec::OutputBufferManager::getInstance().lock();
+    auto [numPagesPromise, numPagesFuture] = folly::makePromiseContract<int>();
+    ASSERT_TRUE(bufferManager->getData(
+        cursor->task()->taskId(),
+        0,
+        INT32_MAX,
+        0,
+        [numPagesPromise =
+             std::make_shared<folly::Promise<int>>(std::move(numPagesPromise))](
+            std::vector<std::unique_ptr<folly::IOBuf>> pages,
+            int64_t /*sequence*/,
+            std::vector<int64_t> /*remainingBytes*/) {
+          numPagesPromise->setValue(pages.size());
+        }));
+    ASSERT_GE(std::move(numPagesFuture).get(std::chrono::seconds(1)), 10);
+    cursor->task()->requestCancel();
+  };
+  test(true);
+  test(false);
 }
diff --git a/velox/exec/tests/LocalPartitionTest.cpp b/velox/exec/tests/LocalPartitionTest.cpp
index 219d7db2b3f1f..969b6b270e6a0 100644
--- a/velox/exec/tests/LocalPartitionTest.cpp
+++ b/velox/exec/tests/LocalPartitionTest.cpp
@@ -43,7 +43,7 @@ class LocalPartitionTest : public HiveConnectorTestBase {
       const std::vector<RowVectorPtr>& vectors) {
     auto filePaths = makeFilePaths(vectors.size());
     for (auto i = 0; i < vectors.size(); i++) {
-      writeToFile(filePaths[i]->path, vectors[i]);
+      writeToFile(filePaths[i]->getPath(), vectors[i]);
     }
     return filePaths;
   }
@@ -78,7 +78,9 @@ class LocalPartitionTest : public HiveConnectorTestBase {
       exec::TaskState expected) {
     if (task->state() != expected) {
       auto& executor = folly::QueuedImmediateExecutor::instance();
-      auto future = task->taskCompletionFuture(1'000'000).via(&executor);
+      auto future = task->taskCompletionFuture()
+                        .within(std::chrono::microseconds(1'000'000))
+                        .via(&executor);
       future.wait();
       EXPECT_EQ(expected, task->state());
     }
@@ -138,7 +140,7 @@ TEST_F(LocalPartitionTest, gather) {
   AssertQueryBuilder queryBuilder(op, duckDbQueryRunner_);
   for (auto i = 0; i < filePaths.size(); ++i) {
     queryBuilder.split(
-        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->path));
+        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->getPath()));
   }
 
   task = queryBuilder.assertResults("SELECT 300, -71, 152");
@@ -184,7 +186,7 @@ TEST_F(LocalPartitionTest, partition) {
   queryBuilder.maxDrivers(2);
   for (auto i = 0; i < filePaths.size(); ++i) {
     queryBuilder.split(
-        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->path));
+        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->getPath()));
   }
 
   auto task =
@@ -265,7 +267,7 @@ TEST_F(LocalPartitionTest, maxBufferSizePartition) {
     queryBuilder.maxDrivers(2);
     for (auto i = 0; i < filePaths.size(); ++i) {
       queryBuilder.split(
-          scanNodeIds[i % 3], makeHiveConnectorSplit(filePaths[i]->path));
+          scanNodeIds[i % 3], makeHiveConnectorSplit(filePaths[i]->getPath()));
     }
     queryBuilder.config(
         core::QueryConfig::kMaxLocalExchangeBufferSize, bufferSize);
@@ -283,13 +285,66 @@ TEST_F(LocalPartitionTest, maxBufferSizePartition) {
   verifyExchangeSourceOperatorStats(task, 2100, 42);
 }
 
+TEST_F(LocalPartitionTest, indicesBufferCapacity) {
+  std::vector<RowVectorPtr> vectors;
+  for (auto i = 0; i < 21; i++) {
+    vectors.emplace_back(makeRowVector({makeFlatVector<int32_t>(
+        100, [i](auto row) { return -71 + i * 10 + row; })}));
+  }
+  auto filePaths = writeToFiles(vectors);
+  auto rowType = asRowType(vectors[0]->type());
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<core::PlanNodeId> scanNodeIds;
+  auto scanNode = [&]() {
+    auto node = PlanBuilder(planNodeIdGenerator).tableScan(rowType).planNode();
+    scanNodeIds.push_back(node->id());
+    return node;
+  };
+  CursorParameters params;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .localPartition(
+                            {"c0"},
+                            {
+                                scanNode(),
+                                scanNode(),
+                                scanNode(),
+                            })
+                        .planNode();
+  params.copyResult = false;
+  params.maxDrivers = 2;
+  auto cursor = TaskCursor::create(params);
+  for (auto i = 0; i < filePaths.size(); ++i) {
+    auto id = scanNodeIds[i % 3];
+    cursor->task()->addSplit(
+        id, Split(makeHiveConnectorSplit(filePaths[i]->getPath())));
+    cursor->task()->noMoreSplits(id);
+  }
+  int numRows = 0;
+  int capacity = 0;
+  while (cursor->moveNext()) {
+    auto* batch = cursor->current()->as<RowVector>();
+    ASSERT_EQ(batch->childrenSize(), 1);
+    auto& column = batch->childAt(0);
+    ASSERT_EQ(column->encoding(), VectorEncoding::Simple::DICTIONARY);
+    numRows += batch->size();
+    capacity += column->wrapInfo()->capacity();
+  }
+  ASSERT_EQ(numRows, 2100);
+  // MemoryPool::preferredSize is capped at 1.5 times the requested size.
+  ASSERT_LE(capacity, 1.5 * numRows * sizeof(vector_size_t));
+}
+
 TEST_F(LocalPartitionTest, blockingOnLocalExchangeQueue) {
   auto localExchangeBufferSize = "1024";
   auto baseVector = vectorMaker_.flatVector<int64_t>(
       10240, [](auto row) { return row / 10; });
-  // Make a small dictionary vector of one row and roughly 8 bytes that is
+  // Make a small flat vector of one row and roughly 8 bytes that is
   // smaller than the localExchangeBufferSize.
   auto smallInput = vectorMaker_.rowVector(
+      {"c0"}, {makeFlatVector<int64_t>(1, folly::identity)});
+  // Make a small dictionary vector of one row with a base vector larger than
+  // the localExchangeBufferSize.
+  auto dictionaryInput = vectorMaker_.rowVector(
       {"c0"}, {wrapInDictionary(makeIndices({0}), baseVector)});
   // Make a large dictionary vector of 1024 rows and roughly 8KB that is larger
   // than the localExchangeBufferSize.
@@ -311,6 +366,8 @@ TEST_F(LocalPartitionTest, blockingOnLocalExchangeQueue) {
     }
   } testSettings[] = {
       {smallInput, 0}, // Small input will not make LocalPartition blocked.
+      {dictionaryInput, 1}, // Large dictiionary values will make LocalPartition
+                            // blocked.
       {largeInput, 1}}; // Large input will make LocalPartition blocked.
 
   for (const auto& test : testSettings) {
@@ -399,7 +456,7 @@ TEST_F(LocalPartitionTest, multipleExchanges) {
   AssertQueryBuilder queryBuilder(op, duckDbQueryRunner_);
   for (auto i = 0; i < filePaths.size(); ++i) {
     queryBuilder.split(
-        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->path));
+        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->getPath()));
   }
 
   queryBuilder.maxDrivers(2).assertResults(
@@ -454,7 +511,7 @@ TEST_F(LocalPartitionTest, earlyCancelation) {
   // Make sure results are queued one batch at a time.
   params.bufferedBytes = 100;
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   const auto& task = cursor->task();
 
   // Fetch first batch of data.
@@ -471,7 +528,7 @@ TEST_F(LocalPartitionTest, earlyCancelation) {
       ;
       FAIL() << "Expected a throw due to cancellation";
     }
-  } catch (const std::exception& e) {
+  } catch (const std::exception&) {
   }
 
   // Wait for task to transition to final state.
@@ -504,12 +561,11 @@ TEST_F(LocalPartitionTest, producerError) {
   CursorParameters params;
   params.planNode = plan;
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   const auto& task = cursor->task();
 
   // Expect division by zero error.
-  ASSERT_THROW(
-      while (cursor->moveNext()) { ; }, VeloxException);
+  ASSERT_THROW(while (cursor->moveNext()) { ; }, VeloxException);
 
   // Wait for task to transition to failed state.
   waitForTaskCompletion(task, exec::kFailed);
diff --git a/velox/exec/tests/Main.cpp b/velox/exec/tests/Main.cpp
index 970f35d8180a4..164b6422fe828 100644
--- a/velox/exec/tests/Main.cpp
+++ b/velox/exec/tests/Main.cpp
@@ -24,6 +24,6 @@ int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   // Signal handler required for ThreadDebugInfoTest
   facebook::velox::process::addDefaultFatalSignalHandler();
-  folly::init(&argc, &argv, false);
+  folly::Init init(&argc, &argv, false);
   return RUN_ALL_TESTS();
 }
diff --git a/velox/exec/tests/MemoryArbitrationFuzzerTest.cpp b/velox/exec/tests/MemoryArbitrationFuzzerTest.cpp
new file mode 100644
index 0000000000000..1ad0247fb8878
--- /dev/null
+++ b/velox/exec/tests/MemoryArbitrationFuzzerTest.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <unordered_set>
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/MemoryReclaimer.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.h"
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+
+DEFINE_int64(allocator_capacity, 32L << 30, "Allocator capacity in bytes.");
+
+DECLARE_int64(arbitrator_capacity);
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+using namespace facebook::velox::exec;
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+  test::setupMemory(FLAGS_allocator_capacity, FLAGS_arbitrator_capacity);
+  const size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+  return test::MemoryArbitrationFuzzerRunner::run(initialSeed);
+}
diff --git a/velox/exec/tests/MemoryReclaimerTest.cpp b/velox/exec/tests/MemoryReclaimerTest.cpp
index 2f906ff11d07c..697caf9d18cb6 100644
--- a/velox/exec/tests/MemoryReclaimerTest.cpp
+++ b/velox/exec/tests/MemoryReclaimerTest.cpp
@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-#include "velox/exec/MemoryReclaimer.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/common/memory/MemoryPool.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -26,7 +27,7 @@ using namespace facebook::velox::memory;
 
 class MemoryReclaimerTest : public OperatorTestBase {
  protected:
-  MemoryReclaimerTest() : pool_(memory::addDefaultLeafMemoryPool()) {
+  MemoryReclaimerTest() : pool_(memory::memoryManager()->addLeafPool()) {
     const auto seed =
         std::chrono::system_clock::now().time_since_epoch().count();
     rng_.seed(seed);
@@ -44,13 +45,16 @@ class MemoryReclaimerTest : public OperatorTestBase {
         "MemoryReclaimerTest",
         std::move(fakePlanFragment),
         0,
-        std::make_shared<core::QueryCtx>());
+        core::QueryCtx::create(executor_.get()),
+        Task::ExecutionMode::kParallel);
   }
 
   void SetUp() override {}
 
   void TearDown() override {}
 
+  std::shared_ptr<folly::CPUThreadPoolExecutor> executor_{
+      std::make_shared<folly::CPUThreadPoolExecutor>(4)};
   const std::shared_ptr<memory::MemoryPool> pool_;
   RowTypePtr rowType_;
   std::shared_ptr<Task> fakeTask_;
@@ -64,20 +68,247 @@ TEST_F(MemoryReclaimerTest, enterArbitrationTest) {
     auto reclaimer = exec::MemoryReclaimer::create();
     auto driver = Driver::testingCreate(
         std::make_unique<DriverCtx>(fakeTask_, 0, 0, 0, 0));
+    fakeTask_->testingIncrementThreads();
     if (underDriverContext) {
       driver->state().setThread();
       ScopedDriverThreadContext scopedDriverThreadCtx{*driver->driverCtx()};
       reclaimer->enterArbitration();
       ASSERT_TRUE(driver->state().isOnThread());
-      ASSERT_TRUE(driver->state().isSuspended);
+      ASSERT_TRUE(driver->state().suspended());
       reclaimer->leaveArbitration();
       ASSERT_TRUE(driver->state().isOnThread());
-      ASSERT_FALSE(driver->state().isSuspended);
+      ASSERT_FALSE(driver->state().suspended());
     } else {
       reclaimer->enterArbitration();
       ASSERT_FALSE(driver->state().isOnThread());
-      ASSERT_FALSE(driver->state().isSuspended);
+      ASSERT_FALSE(driver->state().suspended());
       reclaimer->leaveArbitration();
     }
   }
 }
+
+TEST_F(MemoryReclaimerTest, abortTest) {
+  for (const auto& leafPool : {false, true}) {
+    const std::string testName = fmt::format("leafPool: {}", leafPool);
+    SCOPED_TRACE(testName);
+    auto rootPool = memory::memoryManager()->addRootPool(
+        testName, kMaxMemory, exec::MemoryReclaimer::create());
+    ASSERT_FALSE(rootPool->aborted());
+    if (leafPool) {
+      auto leafPool = rootPool->addLeafChild(
+          "leafAbortTest", true, exec::MemoryReclaimer::create());
+      try {
+        VELOX_FAIL("abortTest error");
+      } catch (const VeloxRuntimeError&) {
+        leafPool->abort(std::current_exception());
+      }
+      ASSERT_TRUE(rootPool->aborted());
+      ASSERT_TRUE(leafPool->aborted());
+    } else {
+      auto aggregatePool = rootPool->addAggregateChild(
+          "nonLeafAbortTest", exec::MemoryReclaimer::create());
+      try {
+        VELOX_FAIL("abortTest error");
+      } catch (const VeloxRuntimeError&) {
+        aggregatePool->abort(std::current_exception());
+      }
+      ASSERT_TRUE(rootPool->aborted());
+      ASSERT_TRUE(aggregatePool->aborted());
+    }
+  }
+}
+
+TEST(ReclaimableSectionGuard, basic) {
+  tsan_atomic<bool> nonReclaimableSection{false};
+  {
+    memory::NonReclaimableSectionGuard guard(&nonReclaimableSection);
+    ASSERT_TRUE(nonReclaimableSection);
+    {
+      memory::ReclaimableSectionGuard guard(&nonReclaimableSection);
+      ASSERT_FALSE(nonReclaimableSection);
+      {
+        memory::ReclaimableSectionGuard guard(&nonReclaimableSection);
+        ASSERT_FALSE(nonReclaimableSection);
+        {
+          memory::NonReclaimableSectionGuard guard(&nonReclaimableSection);
+          ASSERT_TRUE(nonReclaimableSection);
+        }
+        ASSERT_FALSE(nonReclaimableSection);
+      }
+      ASSERT_FALSE(nonReclaimableSection);
+    }
+    ASSERT_TRUE(nonReclaimableSection);
+  }
+  ASSERT_FALSE(nonReclaimableSection);
+  nonReclaimableSection = true;
+  {
+    memory::ReclaimableSectionGuard guard(&nonReclaimableSection);
+    ASSERT_FALSE(nonReclaimableSection);
+    {
+      memory::NonReclaimableSectionGuard guard(&nonReclaimableSection);
+      ASSERT_TRUE(nonReclaimableSection);
+      {
+        memory::ReclaimableSectionGuard guard(&nonReclaimableSection);
+        ASSERT_FALSE(nonReclaimableSection);
+        {
+          memory::ReclaimableSectionGuard guard(&nonReclaimableSection);
+          ASSERT_FALSE(nonReclaimableSection);
+        }
+        ASSERT_FALSE(nonReclaimableSection);
+        {
+          memory::NonReclaimableSectionGuard guard(&nonReclaimableSection);
+          ASSERT_TRUE(nonReclaimableSection);
+        }
+        ASSERT_FALSE(nonReclaimableSection);
+      }
+      ASSERT_TRUE(nonReclaimableSection);
+    }
+    ASSERT_FALSE(nonReclaimableSection);
+  }
+  ASSERT_TRUE(nonReclaimableSection);
+}
+
+namespace {
+class MockMemoryReclaimer : public memory::MemoryReclaimer {
+ public:
+  static std::unique_ptr<MemoryReclaimer> create(
+      bool reclaimable,
+      uint64_t memoryBytes,
+      const std::function<void(memory::MemoryPool*)>& reclaimCallback =
+          nullptr) {
+    return std::unique_ptr<MemoryReclaimer>(
+        new MockMemoryReclaimer(reclaimable, memoryBytes, reclaimCallback));
+  }
+
+  bool reclaimableBytes(const MemoryPool& pool, uint64_t& reclaimableBytes)
+      const override {
+    reclaimableBytes = 0;
+    if (!reclaimable_) {
+      return false;
+    }
+    reclaimableBytes = memoryBytes_;
+    return true;
+  }
+
+  uint64_t reclaim(
+      MemoryPool* pool,
+      uint64_t targetBytes,
+      uint64_t maxWaitMs,
+      Stats& stats) override {
+    VELOX_CHECK(underMemoryArbitration());
+    VELOX_CHECK(reclaimable_);
+    if (reclaimCallback_) {
+      reclaimCallback_(pool);
+    }
+    const uint64_t reclaimedBytes = memoryBytes_;
+    memoryBytes_ = 0;
+    return reclaimedBytes;
+  }
+
+  uint64_t memoryBytes() const {
+    return memoryBytes_;
+  }
+
+ private:
+  MockMemoryReclaimer(
+      bool reclaimable,
+      uint64_t memoryBytes,
+      const std::function<void(memory::MemoryPool*)>& reclaimCallback)
+      : reclaimCallback_(reclaimCallback),
+        reclaimable_(reclaimable),
+        memoryBytes_(memoryBytes) {}
+
+  const std::function<void(memory::MemoryPool*)> reclaimCallback_;
+  bool reclaimable_{false};
+  int reclaimCount_{0};
+  uint64_t memoryBytes_{0};
+};
+} // namespace
+
+TEST_F(MemoryReclaimerTest, parallelMemoryReclaimer) {
+  struct TestReclaimer {
+    bool reclaimable;
+    uint64_t memoryBytes;
+    uint64_t expectedMemoryBytesAfterReclaim;
+  };
+
+  struct {
+    bool hasExecutor;
+    uint64_t bytesToReclaim;
+    std::vector<TestReclaimer> testReclaimers;
+  } testSettings[] = {
+      {false, 100, {{true, 100, 0}, {true, 90, 90}, {false, 200, 200}}},
+      {true, 100, {{true, 100, 0}, {true, 90, 0}, {false, 200, 200}}},
+      {false, 110, {{true, 100, 0}, {true, 90, 0}, {false, 200, 200}}},
+      {true, 110, {{true, 100, 0}, {true, 90, 0}, {false, 200, 200}}},
+      {false, 100, {{true, 100, 100}, {true, 90, 90}, {true, 200, 0}}},
+      {true, 100, {{true, 100, 0}, {true, 90, 0}, {true, 200, 0}}},
+      {false, 80, {{true, 100, 100}, {true, 90, 90}, {true, 200, 0}}},
+      {true, 80, {{true, 100, 0}, {true, 90, 0}, {true, 200, 0}}}};
+
+  for (const auto& testData : testSettings) {
+    auto rootPool = memory::memoryManager()->addRootPool(
+        "parallelMemoryReclaimer",
+        kMaxMemory,
+        exec::ParallelMemoryReclaimer::create(
+            testData.hasExecutor ? executor_.get() : nullptr));
+    std::vector<MockMemoryReclaimer*> memoryReclaimers;
+    std::vector<std::shared_ptr<MemoryPool>> leafPools;
+    int reclaimerIdx{0};
+    for (const auto& testReclaimer : testData.testReclaimers) {
+      auto reclaimer = MockMemoryReclaimer::create(
+          testReclaimer.reclaimable, testReclaimer.memoryBytes);
+      leafPools.push_back(rootPool->addLeafChild(
+          std::to_string(reclaimerIdx++), true, std::move(reclaimer)));
+      memoryReclaimers.push_back(
+          static_cast<MockMemoryReclaimer*>(leafPools.back()->reclaimer()));
+    }
+
+    ScopedMemoryArbitrationContext context(rootPool.get());
+    memory::MemoryReclaimer::Stats stats;
+    rootPool->reclaim(testData.bytesToReclaim, 0, stats);
+    for (int i = 0; i < memoryReclaimers.size(); ++i) {
+      auto* memoryReclaimer = memoryReclaimers[i];
+      ASSERT_EQ(
+          memoryReclaimer->memoryBytes(),
+          testData.testReclaimers[i].expectedMemoryBytesAfterReclaim)
+          << i;
+    }
+  }
+}
+
+// This test is to verify if the parallel memory reclaimer can prevent recursive
+// arbitration.
+TEST_F(MemoryReclaimerTest, recursiveArbitrationWithParallelReclaim) {
+  std::atomic_bool reclaimExecuted{false};
+  auto rootPool = memory::memoryManager()->addRootPool(
+      "recursiveArbitrationWithParallelReclaim",
+      32 << 20,
+      exec::ParallelMemoryReclaimer::create(executor_.get()));
+  const auto reclaimCallback = [&](memory::MemoryPool* pool) {
+    void* buffer = pool->allocate(64 << 20);
+    pool->free(buffer, 64 << 20);
+    reclaimExecuted = true;
+  };
+  const int numLeafPools = 10;
+  const int bufferSize = 1 << 20;
+  std::vector<MockMemoryReclaimer*> memoryReclaimers;
+  std::vector<std::shared_ptr<MemoryPool>> leafPools;
+  std::vector<void*> buffers;
+  for (int i = 0; i < numLeafPools; ++i) {
+    auto reclaimer =
+        MockMemoryReclaimer::create(true, bufferSize, reclaimCallback);
+    leafPools.push_back(
+        rootPool->addLeafChild(std::to_string(i), true, std::move(reclaimer)));
+    buffers.push_back(leafPools.back()->allocate(bufferSize));
+    memoryReclaimers.push_back(
+        static_cast<MockMemoryReclaimer*>(leafPools.back()->reclaimer()));
+  }
+
+  memory::testingRunArbitration();
+
+  for (int i = 0; i < numLeafPools; ++i) {
+    leafPools[i]->free(buffers[i], bufferSize);
+  }
+  ASSERT_TRUE(reclaimExecuted);
+}
diff --git a/velox/exec/tests/MergeJoinTest.cpp b/velox/exec/tests/MergeJoinTest.cpp
index 4868419e83fdd..34102753b208e 100644
--- a/velox/exec/tests/MergeJoinTest.cpp
+++ b/velox/exec/tests/MergeJoinTest.cpp
@@ -14,11 +14,16 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
+#include "folly/experimental/EventCount.h"
+
 using namespace facebook::velox;
+using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 
@@ -29,7 +34,7 @@ class MergeJoinTest : public HiveConnectorTestBase {
   CursorParameters makeCursorParameters(
       const std::shared_ptr<const core::PlanNode>& planNode,
       uint32_t preferredOutputBatchSize) {
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+    auto queryCtx = core::QueryCtx::create(executor_.get());
 
     CursorParameters params;
     params.planNode = planNode;
@@ -150,34 +155,100 @@ class MergeJoinTest : public HiveConnectorTestBase {
 
     // Test LEFT join.
     planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    plan = PlanBuilder(planNodeIdGenerator)
-               .values(left)
-               .mergeJoin(
-                   {"c0"},
-                   {"u_c0"},
-                   PlanBuilder(planNodeIdGenerator)
-                       .values(right)
-                       .project({"c1 as u_c1", "c0 as u_c0"})
-                       .planNode(),
-                   "",
-                   {"c0", "c1", "u_c1"},
-                   core::JoinType::kLeft)
-               .planNode();
+    auto leftPlan = PlanBuilder(planNodeIdGenerator)
+                        .values(left)
+                        .mergeJoin(
+                            {"c0"},
+                            {"u_c0"},
+                            PlanBuilder(planNodeIdGenerator)
+                                .values(right)
+                                .project({"c1 as u_c1", "c0 as u_c0"})
+                                .planNode(),
+                            "",
+                            {"c0", "c1", "u_c1"},
+                            core::JoinType::kLeft)
+                        .planNode();
 
     // Use very small output batch size.
     assertQuery(
-        makeCursorParameters(plan, 16),
+        makeCursorParameters(leftPlan, 16),
         "SELECT t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0");
 
     // Use regular output batch size.
     assertQuery(
-        makeCursorParameters(plan, 1024),
+        makeCursorParameters(leftPlan, 1024),
         "SELECT t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0");
 
     // Use very large output batch size.
     assertQuery(
-        makeCursorParameters(plan, 10'000),
+        makeCursorParameters(leftPlan, 10'000),
         "SELECT t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0");
+
+    // Test RIGHT join.
+    planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto rightPlan = PlanBuilder(planNodeIdGenerator)
+                         .values(right)
+                         .mergeJoin(
+                             {"c0"},
+                             {"u_c0"},
+                             PlanBuilder(planNodeIdGenerator)
+                                 .values(left)
+                                 .project({"c1 as u_c1", "c0 as u_c0"})
+                                 .planNode(),
+                             "",
+                             {"u_c0", "u_c1", "c1"},
+                             core::JoinType::kRight)
+                         .planNode();
+
+    // Use very small output batch size.
+    assertQuery(
+        makeCursorParameters(rightPlan, 16),
+        "SELECT t.c0, t.c1, u.c1 FROM u RIGHT JOIN t ON t.c0 = u.c0");
+
+    // Use regular output batch size.
+    assertQuery(
+        makeCursorParameters(rightPlan, 1024),
+        "SELECT t.c0, t.c1, u.c1 FROM u RIGHT JOIN t ON t.c0 = u.c0");
+
+    // Use very large output batch size.
+    assertQuery(
+        makeCursorParameters(rightPlan, 10'000),
+        "SELECT t.c0, t.c1, u.c1 FROM u RIGHT JOIN t ON t.c0 = u.c0");
+
+    // Test right join and left join with same result.
+    auto expectedResult = AssertQueryBuilder(leftPlan).copyResults(pool_.get());
+    AssertQueryBuilder(rightPlan).assertResults(expectedResult);
+
+    // Test FULL join.
+    planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto fullPlan = PlanBuilder(planNodeIdGenerator)
+                        .values(right)
+                        .mergeJoin(
+                            {"c0"},
+                            {"u_c0"},
+                            PlanBuilder(planNodeIdGenerator)
+                                .values(left)
+                                .project({"c1 as u_c1", "c0 as u_c0"})
+                                .planNode(),
+                            "",
+                            {"u_c0", "u_c1", "c1"},
+                            core::JoinType::kFull)
+                        .planNode();
+
+    // Use very small output batch size.
+    assertQuery(
+        makeCursorParameters(fullPlan, 16),
+        "SELECT t.c0, t.c1, u.c1 FROM u FULL OUTER JOIN t ON t.c0 = u.c0");
+
+    // Use regular output batch size.
+    assertQuery(
+        makeCursorParameters(fullPlan, 1024),
+        "SELECT t.c0, t.c1, u.c1 FROM u FULL OUTER JOIN t ON t.c0 = u.c0");
+
+    // Use very large output batch size.
+    assertQuery(
+        makeCursorParameters(fullPlan, 10'000),
+        "SELECT t.c0, t.c1, u.c1 FROM u FULL OUTER JOIN t ON t.c0 = u.c0");
   }
 };
 
@@ -341,7 +412,7 @@ TEST_F(MergeJoinTest, innerJoinFilter) {
       "SELECT t_c0, u_c0, u_c1 FROM t, u WHERE t_c0 = u_c0 AND (t_c1 + u_c1) % 2 = 0");
 }
 
-TEST_F(MergeJoinTest, leftJoinFilter) {
+TEST_F(MergeJoinTest, leftAndRightJoinFilter) {
   // Each row on the left side has at most one match on the right side.
   auto left = makeRowVector(
       {"t_c0", "t_c1"},
@@ -361,7 +432,7 @@ TEST_F(MergeJoinTest, leftJoinFilter) {
   createDuckDbTable("u", {right});
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = [&](const std::string& filter) {
+  auto leftPlan = [&](const std::string& filter) {
     return PlanBuilder(planNodeIdGenerator)
         .values({left})
         .mergeJoin(
@@ -374,11 +445,28 @@ TEST_F(MergeJoinTest, leftJoinFilter) {
         .planNode();
   };
 
+  auto rightPlan = [&](const std::string& filter) {
+    return PlanBuilder(planNodeIdGenerator)
+        .values({right})
+        .mergeJoin(
+            {"u_c0"},
+            {"t_c0"},
+            PlanBuilder(planNodeIdGenerator).values({left}).planNode(),
+            filter,
+            {"t_c0", "t_c1", "u_c1"},
+            core::JoinType::kRight)
+        .planNode();
+  };
+
   // Test with different output batch sizes.
   for (auto batchSize : {1, 3, 16}) {
     assertQuery(
-        makeCursorParameters(plan("(t_c1 + u_c1) % 2 = 0"), batchSize),
+        makeCursorParameters(leftPlan("(t_c1 + u_c1) % 2 = 0"), batchSize),
         "SELECT t_c0, t_c1, u_c1 FROM t LEFT JOIN u ON t_c0 = u_c0 AND (t_c1 + u_c1) % 2 = 0");
+
+    assertQuery(
+        makeCursorParameters(rightPlan("(t_c1 + u_c1) % 2 = 0"), batchSize),
+        "SELECT t_c0, t_c1, u_c1 FROM u RIGHT JOIN t ON t_c0 = u_c0 AND (t_c1 + u_c1) % 2 = 0");
   }
 
   // A left-side row with multiple matches on the right side.
@@ -407,10 +495,15 @@ TEST_F(MergeJoinTest, leftJoinFilter) {
           "t_c1 + u_c1 > 100",
           "t_c1 + u_c1 < 100"}) {
       assertQuery(
-          makeCursorParameters(plan(filter), batchSize),
+          makeCursorParameters(leftPlan(filter), batchSize),
           fmt::format(
               "SELECT t_c0, t_c1, u_c1 FROM t LEFT JOIN u ON t_c0 = u_c0 AND {}",
               filter));
+      assertQuery(
+          makeCursorParameters(rightPlan(filter), batchSize),
+          fmt::format(
+              "SELECT t_c0, t_c1, u_c1 FROM u RIGHT JOIN t ON t_c0 = u_c0 AND {}",
+              filter));
     }
   }
 }
@@ -465,11 +558,11 @@ TEST_F(MergeJoinTest, lazyVectors) {
        makeFlatVector<int64_t>(10'000, [](auto row) { return row % 31; })});
 
   auto leftFile = TempFilePath::create();
-  writeToFile(leftFile->path, leftVectors);
+  writeToFile(leftFile->getPath(), leftVectors);
   createDuckDbTable("t", {leftVectors});
 
   auto rightFile = TempFilePath::create();
-  writeToFile(rightFile->path, rightVectors);
+  writeToFile(rightFile->getPath(), rightVectors);
   createDuckDbTable("u", {rightVectors});
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -492,12 +585,147 @@ TEST_F(MergeJoinTest, lazyVectors) {
                 .planNode();
 
   AssertQueryBuilder(op, duckDbQueryRunner_)
-      .split(rightScanId, makeHiveConnectorSplit(rightFile->path))
-      .split(leftScanId, makeHiveConnectorSplit(leftFile->path))
+      .split(rightScanId, makeHiveConnectorSplit(rightFile->getPath()))
+      .split(leftScanId, makeHiveConnectorSplit(leftFile->getPath()))
       .assertResults(
           "SELECT c0, rc0, c1, rc1, c2, c3  FROM t, u WHERE t.c0 = u.rc0 and c1 + rc1 < 30");
 }
 
+// Ensures the output of merge joins are dictionaries.
+TEST_F(MergeJoinTest, dictionaryOutput) {
+  auto left =
+      makeRowVector({"t_c0"}, {makeFlatVector<int32_t>({1, 2, 3, 4, 5})});
+  auto right = makeRowVector({"u_c0"}, {makeFlatVector<int32_t>({2, 4, 6})});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t_c0"},
+              {"u_c0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t_c0", "u_c0"},
+              core::JoinType::kInner)
+          .planFragment();
+
+  // Run task with special callback so we can capture results without them being
+  // copied/flattened.
+  RowVectorPtr output;
+  auto task = Task::create(
+      "0",
+      std::move(plan),
+      0,
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel,
+      [&](const RowVectorPtr& vector, ContinueFuture* future) {
+        if (vector) {
+          output = vector;
+        }
+        return BlockingReason::kNotBlocked;
+      });
+
+  task->start(2);
+  waitForTaskCompletion(task.get());
+
+  for (const auto& child : output->children()) {
+    EXPECT_TRUE(isDictionary(child->encoding()));
+  }
+
+  // Output can't outlive the task.
+  output.reset();
+}
+
+TEST_F(MergeJoinTest, semiJoin) {
+  auto left = makeRowVector(
+      {"t0"}, {makeNullableFlatVector<int64_t>({1, 2, 2, 6, std::nullopt})});
+
+  auto right = makeRowVector(
+      {"u0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 2, 2, 7, std::nullopt, std::nullopt})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  auto testSemiJoin = [&](const std::string& filter,
+                          const std::string& sql,
+                          const std::vector<std::string>& outputLayout,
+                          core::JoinType joinType) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                filter,
+                outputLayout,
+                joinType)
+            .planNode();
+    AssertQueryBuilder(plan, duckDbQueryRunner_).assertResults(sql);
+  };
+
+  testSemiJoin(
+      "t0 >1",
+      "SELECT t0 FROM t where t0 IN (SELECT u0 from u) and t0 > 1",
+      {"t0"},
+      core::JoinType::kLeftSemiFilter);
+  testSemiJoin(
+      "u0 > 1",
+      "SELECT u0 FROM u where u0 IN (SELECT t0 from t) and u0 > 1",
+      {"u0"},
+      core::JoinType::kRightSemiFilter);
+}
+
+TEST_F(MergeJoinTest, rightJoin) {
+  auto left = makeRowVector(
+      {"t0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 2, std::nullopt, 5, 6, std::nullopt})});
+
+  auto right = makeRowVector(
+      {"u0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 5, 6, 8, std::nullopt, std::nullopt})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Right join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto rightPlan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "t0 > 2",
+              {"t0", "u0"},
+              core::JoinType::kRight)
+          .planNode();
+  AssertQueryBuilder(rightPlan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT * FROM t RIGHT JOIN u ON t.t0 = u.u0 AND t.t0 > 2");
+
+  auto leftPlan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({right})
+          .mergeJoin(
+              {"u0"},
+              {"t0"},
+              PlanBuilder(planNodeIdGenerator).values({left}).planNode(),
+              "t0 > 2",
+              {"t0", "u0"},
+              core::JoinType::kLeft)
+          .planNode();
+  auto expectedResult = AssertQueryBuilder(leftPlan).copyResults(pool_.get());
+  AssertQueryBuilder(rightPlan).assertResults(expectedResult);
+}
+
 TEST_F(MergeJoinTest, nullKeys) {
   auto left = makeRowVector(
       {"t0"}, {makeNullableFlatVector<int64_t>({1, 2, 5, std::nullopt})});
@@ -540,6 +768,301 @@ TEST_F(MergeJoinTest, nullKeys) {
       .assertResults("SELECT * FROM t LEFT JOIN u ON t.t0 = u.u0");
 }
 
+TEST_F(MergeJoinTest, antiJoinWithFilter) {
+  auto left = makeRowVector(
+      {"t0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 2, 4, 5, 8, 9, std::nullopt, 10, std::nullopt})});
+
+  auto right = makeRowVector(
+      {"u0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 5, 6, 7, std::nullopt, std::nullopt, 8, 9, 10})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Anti join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "t0 > 2",
+              {"t0"},
+              core::JoinType::kAnti)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT t0 FROM t WHERE NOT exists (select 1 from u where t0 = u0 AND t.t0 > 2 ) ");
+}
+
+TEST_F(MergeJoinTest, antiJoinFailed) {
+  auto size = 1'00;
+  auto left = makeRowVector(
+      {"t0"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+
+  auto right = makeRowVector(
+      {"u0"}, {makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Anti join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(split(left, 10))
+          .orderBy({"t0"}, false)
+          .mergeJoin(
+              {"t0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t0"},
+              core::JoinType::kAnti)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kMaxOutputBatchRows, "10")
+      .assertResults(
+          "SELECT t0 FROM t WHERE NOT exists (select 1 from u where t0 = u0) ");
+}
+
+TEST_F(MergeJoinTest, antiJoinWithTwoJoinKeys) {
+  auto left = makeRowVector(
+      {"a", "b"},
+      {makeNullableFlatVector<int32_t>(
+           {1, 1, 2, 2, 3, std::nullopt, std::nullopt, 6}),
+       makeNullableFlatVector<double>(
+           {2.0, 2.0, 1.0, 1.0, 3.0, std::nullopt, 5.0, std::nullopt})});
+
+  auto right = makeRowVector(
+      {"c", "d"},
+      {makeNullableFlatVector<int32_t>(
+           {2, 2, 3, 4, std::nullopt, std::nullopt, 6}),
+       makeNullableFlatVector<double>(
+           {3.0, 3.0, 2.0, 1.0, std::nullopt, 5.0, std::nullopt})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Anti join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"a"},
+              {"c"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "b < d",
+              {"a", "b"},
+              core::JoinType::kAnti)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT * FROM t WHERE NOT exists (select * from u where t.a = u.c and t.b < u.d)");
+}
+
+TEST_F(MergeJoinTest, antiJoinWithUniqueJoinKeys) {
+  auto left = makeRowVector(
+      {"a", "b"},
+      {makeNullableFlatVector<int32_t>(
+           {1, 1, 2, 2, 3, std::nullopt, std::nullopt, 6}),
+       makeNullableFlatVector<double>(
+           {2.0, 2.0, 1.0, 1.0, 3.0, std::nullopt, 5.0, std::nullopt})});
+
+  auto right = makeRowVector(
+      {"c", "d"},
+      {makeNullableFlatVector<int32_t>({2, 3, 4, std::nullopt, 6}),
+       makeNullableFlatVector<double>({3.0, 2.0, 1.0, 5.0, std::nullopt})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Anti join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"a"},
+              {"c"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "b < d",
+              {"a", "b"},
+              core::JoinType::kAnti)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT * FROM t WHERE NOT exists (select * from u where t.a = u.c and t.b < u.d)");
+}
+
+TEST_F(MergeJoinTest, antiJoinNoFilter) {
+  auto left = makeRowVector(
+      {"t0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 2, 4, 5, 8, 9, std::nullopt, 10, std::nullopt})});
+
+  auto right = makeRowVector(
+      {"u0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 5, 6, 7, std::nullopt, std::nullopt, 8, 9, 10})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Anti join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t0"},
+              core::JoinType::kAnti)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT t0 FROM t WHERE NOT exists (select 1 from u where t0 = u0)");
+}
+
+TEST_F(MergeJoinTest, fullOuterJoin) {
+  auto left = makeRowVector(
+      {"t0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 2, std::nullopt, 5, 6, std::nullopt})});
+
+  auto right = makeRowVector(
+      {"u0"},
+      {makeNullableFlatVector<int64_t>(
+          {1, 5, 6, 8, std::nullopt, std::nullopt})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Full outer join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "t0 > 2",
+              {"t0", "u0"},
+              core::JoinType::kFull)
+          .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT * FROM t FULL OUTER JOIN u ON t.t0 = u.u0 AND t.t0 > 2");
+}
+
+TEST_F(MergeJoinTest, fullOuterJoinNoFilter) {
+  auto left = makeRowVector(
+      {"t0", "t1", "t2", "t3"},
+      {makeNullableFlatVector<int64_t>(
+           {7854252584298216695,
+            5874550437257860379,
+            6694700278390749883,
+            6952978413716179087,
+            2785313305792069690,
+            5306984336093303849,
+            2249699434807719017,
+            std::nullopt,
+            std::nullopt,
+            std::nullopt,
+            8814597374860168988}),
+       makeNullableFlatVector<int64_t>(
+           {1, 2, 3, 4, 5, 6, 7, std::nullopt, 8, 9, 10}),
+       makeNullableFlatVector<bool>(
+           {false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false}),
+       makeNullableFlatVector<int64_t>(
+           {58, 112, 125, 52, 69, 39, 73, 29, 101, std::nullopt, 51})});
+
+  auto right = makeRowVector(
+      {"u0", "u1", "u2", "u3"},
+      {makeNullableFlatVector<int64_t>({std::nullopt}),
+       makeNullableFlatVector<int64_t>({11}),
+       makeNullableFlatVector<bool>({false}),
+       makeNullableFlatVector<int64_t>({77})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Full outer join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t0", "t1", "t2", "t3"},
+              {"u0", "u1", "u2", "u3"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t0", "t1"},
+              core::JoinType::kFull)
+          .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT t0, t1 FROM t FULL OUTER JOIN u ON t3 = u3 and t2 = u2 and t1 = u1 and t.t0 = u.u0");
+}
+
+TEST_F(MergeJoinTest, fullOuterJoinWithNullCompare) {
+  auto right = makeRowVector(
+      {"u0", "u1"},
+      {makeNullableFlatVector<bool>({false, true}),
+       makeNullableFlatVector<int64_t>({std::nullopt, std::nullopt})});
+
+  auto left = makeRowVector(
+      {"t0", "t1"},
+      {makeNullableFlatVector<bool>({false, false, std::nullopt}),
+       makeNullableFlatVector<int64_t>(
+           {std::nullopt, 1195665568, std::nullopt})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Full outer join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({left})
+          .mergeJoin(
+              {"t0", "t1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+              "",
+              {"t0", "t1", "u0", "u1"},
+              core::JoinType::kFull)
+          .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .assertResults(
+          "SELECT t0, t1, u0, u1 FROM t FULL OUTER JOIN u ON t.t0 = u.u0 and t1 = u1");
+}
+
 TEST_F(MergeJoinTest, complexTypedFilter) {
   constexpr vector_size_t size{1000};
 
@@ -576,12 +1099,14 @@ TEST_F(MergeJoinTest, complexTypedFilter) {
           }
         }
 
-        assertQuery(
-            plan,
-            fmt::format(
-                "SELECT {} FROM t LEFT JOIN u ON t_c0 = u_c0 AND {}",
-                outputs,
-                queryFilter));
+        for (size_t outputBatchSize : {1000, 1024, 13}) {
+          assertQuery(
+              makeCursorParameters(plan, outputBatchSize),
+              fmt::format(
+                  "SELECT {} FROM t LEFT JOIN u ON t_c0 = u_c0 AND {}",
+                  outputs,
+                  queryFilter));
+        }
       };
 
   std::vector<std::vector<std::string>> outputLayouts{
@@ -643,4 +1168,80 @@ TEST_F(MergeJoinTest, complexTypedFilter) {
           left, "cardinality(t_c1) > 4", "cardinality(t_c1) > 4", outputLayout);
     }
   }
-};
+}
+
+DEBUG_ONLY_TEST_F(MergeJoinTest, failureOnRightSide) {
+  // Test that the Task terminates cleanly when the right side of the join
+  // throws an exception.
+
+  auto leftKeys = makeFlatVector<int32_t>(1'234, [](auto row) { return row; });
+  auto rightKeys = makeFlatVector<int32_t>(1'234, [](auto row) { return row; });
+  std::vector<RowVectorPtr> left;
+  auto payload = makeFlatVector<int32_t>(
+      leftKeys->size(), [](auto row) { return row * 10; });
+  left.push_back(makeRowVector({leftKeys, payload}));
+
+  std::vector<RowVectorPtr> right;
+  payload = makeFlatVector<int32_t>(
+      rightKeys->size(), [](auto row) { return row * 20; });
+  right.push_back(makeRowVector({rightKeys, payload}));
+
+  createDuckDbTable("t", left);
+  createDuckDbTable("u", right);
+
+  // Test INNER join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(left)
+                  .mergeJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(right)
+                          .project({"c1 AS u_c1", "c0 AS u_c0"})
+                          .planNode(),
+                      "",
+                      {"c0", "c1", "u_c1"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  std::atomic_bool nextCalled = false;
+  folly::EventCount nextCalledWait;
+  std::atomic_bool enqueueCalled = false;
+
+  // The left side will call next to fetch data from the right side.  We want
+  // this to be called at least once to ensure consumerPromise_ is created in
+  // the MergeSource.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::MergeSource::next",
+      std::function<void(const MergeJoinSource*)>([&](const MergeJoinSource*) {
+        nextCalled = true;
+        nextCalledWait.notifyAll();
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::MergeSource::enqueue",
+      std::function<void(const MergeJoinSource*)>([&](const MergeJoinSource*) {
+        // Only call this the first time, otherwise if we throw an exception
+        // during Driver.close the process will crash.
+        if (!enqueueCalled.load()) {
+          // The first time the right side calls enqueue, wait for the left side
+          // to call next.  Since enqueue never finished executing there won't
+          // be any data available and enqueue will create a consumerPromise_.
+          enqueueCalled = true;
+          nextCalledWait.await([&]() { return nextCalled.load(); });
+          // Throw an exception so that the task terminates and consumerPromise_
+          // is not fulfilled.
+          VELOX_FAIL("Expected");
+        }
+      }));
+
+  // Use very small output batch size.
+  VELOX_ASSERT_THROW(
+      assertQuery(
+          makeCursorParameters(plan, 16),
+          "SELECT t.c0, t.c1, u.c1 FROM t, u WHERE t.c0 = u.c0"),
+      "Expected");
+
+  waitForAllTasksToBeDeleted();
+}
diff --git a/velox/exec/tests/MergeTest.cpp b/velox/exec/tests/MergeTest.cpp
index 0fa110228ceb5..743c462a37753 100644
--- a/velox/exec/tests/MergeTest.cpp
+++ b/velox/exec/tests/MergeTest.cpp
@@ -71,7 +71,7 @@ class MergeTest : public OperatorTestBase {
       const std::vector<RowVectorPtr>& inputVectors,
       const std::string& key1,
       const std::string& key2) {
-    auto rowType = inputVectors[0]->type()->asRow();
+    auto& rowType = inputVectors[0]->type()->asRow();
     auto sortingKeys = {rowType.getChildIdx(key1), rowType.getChildIdx(key2)};
 
     std::vector<core::SortOrder> sortOrders = {
@@ -177,7 +177,7 @@ TEST_F(MergeTest, offByOne) {
 
   CursorParameters params;
   params.planNode = plan;
-  params.queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+  params.queryCtx = core::QueryCtx::create(executor_.get());
   params.queryCtx->testingOverrideConfigUnsafe(
       {{core::QueryConfig::kPreferredOutputBatchRows, "6"}});
   assertQueryOrdered(params, "VALUES (0), (1), (2), (3), (4), (5), (10)", {0});
diff --git a/velox/exec/tests/MultiFragmentTest.cpp b/velox/exec/tests/MultiFragmentTest.cpp
index 6b4d8e90337eb..57e42dfb64e45 100644
--- a/velox/exec/tests/MultiFragmentTest.cpp
+++ b/velox/exec/tests/MultiFragmentTest.cpp
@@ -21,7 +21,8 @@
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Exchange.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/OutputBufferManager.h"
+#include "velox/exec/PartitionedOutput.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/RoundRobinPartitionFunction.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
@@ -45,6 +46,11 @@ class MultiFragmentTest : public HiveConnectorTestBase {
     exec::ExchangeSource::registerFactory(createLocalExchangeSource);
   }
 
+  void TearDown() override {
+    vectors_.clear();
+    HiveConnectorTestBase::TearDown();
+  }
+
   static std::string makeTaskId(const std::string& prefix, int num) {
     return fmt::format("local://{}-{}", prefix, num);
   }
@@ -62,21 +68,21 @@ class MultiFragmentTest : public HiveConnectorTestBase {
   std::shared_ptr<Task> makeTask(
       const std::string& taskId,
       const core::PlanNodePtr& planNode,
-      int destination,
+      int destination = 0,
       Consumer consumer = nullptr,
       int64_t maxMemory = memory::kMaxMemory) {
     auto configCopy = configSettings_;
-    auto queryCtx = std::make_shared<core::QueryCtx>(
+    auto queryCtx = core::QueryCtx::create(
         executor_.get(), core::QueryConfig(std::move(configCopy)));
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), maxMemory));
+    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+        queryCtx->queryId(), maxMemory, MemoryReclaimer::create()));
     core::PlanFragment planFragment{planNode};
     return Task::create(
         taskId,
         std::move(planFragment),
         destination,
         std::move(queryCtx),
+        Task::ExecutionMode::kParallel,
         std::move(consumer));
   }
 
@@ -97,11 +103,11 @@ class MultiFragmentTest : public HiveConnectorTestBase {
       auto split = exec::Split(
           std::make_shared<connector::hive::HiveConnectorSplit>(
               kHiveConnectorId,
-              "file:" + filePath->path,
+              "file:" + filePath->getPath(),
               facebook::velox::dwio::common::FileFormat::DWRF),
           -1);
       task->addSplit("0", std::move(split));
-      VLOG(1) << filePath->path << "\n";
+      VLOG(1) << filePath->getPath() << "\n";
     }
     task->noMoreSplits("0");
   }
@@ -143,17 +149,47 @@ class MultiFragmentTest : public HiveConnectorTestBase {
     filePaths_ = makeFilePaths(filePathCount);
     vectors_ = makeVectors(filePaths_.size(), rowsPerVector);
     for (int i = 0; i < filePaths_.size(); i++) {
-      writeToFile(filePaths_[i]->path, vectors_[i]);
+      writeToFile(filePaths_[i]->getPath(), vectors_[i]);
     }
     createDuckDbTable(vectors_);
   }
 
+  std::unique_ptr<SerializedPage> toSerializedPage(const RowVectorPtr& vector) {
+    auto data = std::make_unique<VectorStreamGroup>(pool());
+    auto size = vector->size();
+    auto range = IndexRange{0, size};
+    data->createStreamTree(asRowType(vector->type()), size);
+    data->append(vector, folly::Range(&range, 1));
+    auto listener = bufferManager_->newListener();
+    IOBufOutputStream stream(*pool(), listener.get(), data->size());
+    data->flush(&stream);
+    return std::make_unique<SerializedPage>(stream.getIOBuf(), nullptr, size);
+  }
+
+  int32_t enqueue(
+      const std::string& taskId,
+      int32_t destination,
+      const RowVectorPtr& data) {
+    auto page = toSerializedPage(data);
+    const auto pageSize = page->size();
+
+    ContinueFuture unused;
+    auto blocked =
+        bufferManager_->enqueue(taskId, destination, std::move(page), &unused);
+    VELOX_CHECK(!blocked);
+    return pageSize;
+  }
+
   void verifyExchangeStats(
       const std::shared_ptr<Task>& task,
       int32_t expectedNumPagesCount,
       int32_t expectedBackgroundCpuCount) const {
-    auto exchangeStats =
-        task->taskStats().pipelineStats[0].operatorStats[0].runtimeStats;
+    auto taskStats = exec::toPlanStats(task->taskStats());
+
+    const auto& exchangeOperatorStats = taskStats.at("0");
+    ASSERT_GT(exchangeOperatorStats.rawInputBytes, 0);
+    ASSERT_GT(exchangeOperatorStats.rawInputRows, 0);
+    const auto& exchangeStats = taskStats.at("0").customStats;
     ASSERT_EQ(1, exchangeStats.count("localExchangeSource.numPages"));
     ASSERT_EQ(
         expectedNumPagesCount,
@@ -161,9 +197,8 @@ class MultiFragmentTest : public HiveConnectorTestBase {
     ASSERT_EQ(
         expectedBackgroundCpuCount,
         exchangeStats.at(ExchangeClient::kBackgroundCpuTimeMs).count);
-    auto cpuBackgroundTimeMs =
-        task->taskStats().pipelineStats[0].operatorStats[0].backgroundTiming;
-    ASSERT_EQ(expectedBackgroundCpuCount, cpuBackgroundTimeMs.count);
+    ASSERT_EQ(
+        expectedBackgroundCpuCount, taskStats.at("0").backgroundTiming.count);
   }
 
   RowTypePtr rowType_{
@@ -172,6 +207,8 @@ class MultiFragmentTest : public HiveConnectorTestBase {
   std::unordered_map<std::string, std::string> configSettings_;
   std::vector<std::shared_ptr<TempFilePath>> filePaths_;
   std::vector<RowVectorPtr> vectors_;
+  std::shared_ptr<OutputBufferManager> bufferManager_{
+      OutputBufferManager::getInstance().lock()};
 };
 
 TEST_F(MultiFragmentTest, aggregationSingleKey) {
@@ -189,7 +226,7 @@ TEST_F(MultiFragmentTest, aggregationSingleKey) {
 
     auto leafTask = makeTask(leafTaskId, partialAggPlan, 0);
     tasks.push_back(leafTask);
-    Task::start(leafTask, 4);
+    leafTask->start(4);
     addHiveSplits(leafTask, filePaths_);
   }
 
@@ -205,7 +242,7 @@ TEST_F(MultiFragmentTest, aggregationSingleKey) {
     finalAggTaskIds.push_back(makeTaskId("final-agg", i));
     auto task = makeTask(finalAggTaskIds.back(), finalAggPlan, i);
     tasks.push_back(task);
-    Task::start(task, 1);
+    task->start(1);
     addRemoteSplits(task, {leafTaskId});
   }
 
@@ -276,7 +313,7 @@ TEST_F(MultiFragmentTest, aggregationMultiKey) {
 
     auto leafTask = makeTask(leafTaskId, partialAggPlan, 0);
     tasks.push_back(leafTask);
-    Task::start(leafTask, 4);
+    leafTask->start(4);
     addHiveSplits(leafTask, filePaths_);
   }
 
@@ -293,7 +330,7 @@ TEST_F(MultiFragmentTest, aggregationMultiKey) {
     finalAggTaskIds.push_back(makeTaskId("final-agg", i));
     auto task = makeTask(finalAggTaskIds.back(), finalAggPlan, i);
     tasks.push_back(task);
-    Task::start(task, 1);
+    task->start(1);
     addRemoteSplits(task, {leafTaskId});
   }
 
@@ -322,7 +359,7 @@ TEST_F(MultiFragmentTest, distributedTableScan) {
                         .planNode();
 
     auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-    Task::start(leafTask, 4);
+    leafTask->start(4);
     addHiveSplits(leafTask, filePaths_);
 
     auto op = PlanBuilder().exchange(leafPlan->outputType()).planNode();
@@ -368,20 +405,22 @@ TEST_F(MultiFragmentTest, mergeExchange) {
 
     auto sortTask = makeTask(sortTaskId, partialSortPlan, tasks.size());
     tasks.push_back(sortTask);
-    Task::start(sortTask, 4);
+    sortTask->start(4);
     addHiveSplits(sortTask, filePathsList[i]);
     outputType = partialSortPlan->outputType();
   }
 
   auto finalSortTaskId = makeTaskId("orderby", tasks.size());
+  core::PlanNodeId mergeExchangeId;
   auto finalSortPlan = PlanBuilder()
                            .mergeExchange(outputType, {"c0"})
+                           .capturePlanNodeId(mergeExchangeId)
                            .partitionedOutput({}, 1)
                            .planNode();
 
   auto task = makeTask(finalSortTaskId, finalSortPlan, 0);
   tasks.push_back(task);
-  Task::start(task, 1);
+  task->start(1);
   addRemoteSplits(task, partialSortTaskIds);
 
   auto op = PlanBuilder().exchange(outputType).planNode();
@@ -391,6 +430,15 @@ TEST_F(MultiFragmentTest, mergeExchange) {
   for (auto& task : tasks) {
     ASSERT_TRUE(waitForTaskCompletion(task.get())) << task->taskId();
   }
+
+  const auto finalSortStats = toPlanStats(task->taskStats());
+  const auto& mergeExchangeStats = finalSortStats.at(mergeExchangeId);
+
+  EXPECT_EQ(20'000, mergeExchangeStats.inputRows);
+  EXPECT_EQ(20'000, mergeExchangeStats.rawInputRows);
+
+  EXPECT_LT(0, mergeExchangeStats.inputBytes);
+  EXPECT_LT(0, mergeExchangeStats.rawInputBytes);
 }
 
 // Test reordering and dropping columns in PartitionedOutput operator.
@@ -405,7 +453,7 @@ TEST_F(MultiFragmentTest, partitionedOutput) {
                         .partitionedOutput({}, 1, {"c0", "c1"})
                         .planNode();
     auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-    Task::start(leafTask, 4);
+    leafTask->start(4);
     auto op = PlanBuilder().exchange(leafPlan->outputType()).planNode();
 
     assertQuery(op, {leafTaskId}, "SELECT c0, c1 FROM tmp");
@@ -421,7 +469,7 @@ TEST_F(MultiFragmentTest, partitionedOutput) {
                         .partitionedOutput({}, 1, {"c3", "c0", "c2"})
                         .planNode();
     auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-    Task::start(leafTask, 4);
+    leafTask->start(4);
     auto op = PlanBuilder().exchange(leafPlan->outputType()).planNode();
 
     assertQuery(op, {leafTaskId}, "SELECT c3, c0, c2 FROM tmp");
@@ -439,7 +487,7 @@ TEST_F(MultiFragmentTest, partitionedOutput) {
                 {}, 1, {"c0", "c1", "c2", "c3", "c4", "c3", "c2", "c1", "c0"})
             .planNode();
     auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-    Task::start(leafTask, 4);
+    leafTask->start(4);
     auto op = PlanBuilder().exchange(leafPlan->outputType()).planNode();
 
     assertQuery(
@@ -457,7 +505,7 @@ TEST_F(MultiFragmentTest, partitionedOutput) {
                         .partitionedOutput({"c5"}, kFanout, {"c2", "c0", "c3"})
                         .planNode();
     auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-    Task::start(leafTask, 4);
+    leafTask->start(4);
 
     auto intermediatePlan = PlanBuilder()
                                 .exchange(leafPlan->outputType())
@@ -468,7 +516,7 @@ TEST_F(MultiFragmentTest, partitionedOutput) {
       intermediateTaskIds.push_back(makeTaskId("intermediate", i));
       auto intermediateTask =
           makeTask(intermediateTaskIds.back(), intermediatePlan, i);
-      Task::start(intermediateTask, 1);
+      intermediateTask->start(1);
       addRemoteSplits(intermediateTask, {leafTaskId});
     }
 
@@ -495,7 +543,7 @@ TEST_F(MultiFragmentTest, partitionedOutput) {
                             })
                         .planNode();
     auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-    Task::start(leafTask, 4);
+    leafTask->start(4);
     leafTask->updateOutputBuffers(1, true);
 
     auto op = PlanBuilder().exchange(leafPlan->outputType()).planNode();
@@ -522,15 +570,83 @@ TEST_F(MultiFragmentTest, partitionedOutput) {
                         .partitionedOutput({}, 1, {"c0", "c1"})
                         .planNode();
     auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-    Task::start(leafTask, 4);
-    auto bufferMgr = PartitionedOutputBufferManager::getInstance().lock();
+    leafTask->start(4);
     // Delete the results asynchronously to simulate abort from downstream.
-    bufferMgr->deleteResults(leafTaskId, 0);
+    bufferManager_->deleteResults(leafTaskId, 0);
 
     ASSERT_TRUE(waitForTaskCompletion(leafTask.get())) << leafTask->taskId();
   }
 }
 
+TEST_F(MultiFragmentTest, partitionedOutputWithLargeInput) {
+  // Verify that partitionedOutput operator is able to split a single input
+  // vector if it hits memory or row limits.
+  // We create a large vector that hits the row limit (70% - 120% of 10,000).
+  // This test exercises splitting up the input both from the edges and the
+  // middle as it ends up splitting it into at least 3.
+  setupSources(1, 30'000);
+  // Single Partition
+  {
+    auto leafTaskId = makeTaskId("leaf", 0);
+    auto leafPlan =
+        PlanBuilder()
+            .values(vectors_)
+            .partitionedOutput({}, 1, {"c0", "c1", "c2", "c3", "c4"})
+            .planNode();
+    auto leafTask = makeTask(leafTaskId, leafPlan, 0, nullptr, 4 << 20);
+    leafTask->start(1);
+    auto op = PlanBuilder().exchange(leafPlan->outputType()).planNode();
+
+    auto task =
+        assertQuery(op, {leafTaskId}, "SELECT c0, c1, c2, c3, c4 FROM tmp");
+    ASSERT_TRUE(waitForTaskCompletion(leafTask.get()))
+        << leafTask->taskId() << "state: " << leafTask->state();
+    auto taskStats = toPlanStats(leafTask->taskStats());
+    ASSERT_GT(taskStats.at("1").outputVectors, 2);
+  }
+
+  // Multiple partitions but round-robin.
+  {
+    constexpr int32_t kFanout = 2;
+    auto leafTaskId = makeTaskId("leaf", 0);
+    auto leafPlan =
+        PlanBuilder()
+            .values(vectors_)
+            .partitionedOutput(
+                {},
+                kFanout,
+                false,
+                std::make_shared<exec::RoundRobinPartitionFunctionSpec>(),
+                {"c0", "c1", "c2", "c3", "c4"})
+            .planNode();
+    auto leafTask = makeTask(leafTaskId, leafPlan, 0);
+    leafTask->start(1);
+
+    auto intermediatePlan =
+        PlanBuilder()
+            .exchange(leafPlan->outputType())
+            .partitionedOutput({}, 1, {"c0", "c1", "c2", "c3", "c4"})
+            .planNode();
+    std::vector<std::string> intermediateTaskIds;
+    for (auto i = 0; i < kFanout; ++i) {
+      intermediateTaskIds.push_back(makeTaskId("intermediate", i));
+      auto intermediateTask =
+          makeTask(intermediateTaskIds.back(), intermediatePlan, i);
+      intermediateTask->start(1);
+      addRemoteSplits(intermediateTask, {leafTaskId});
+    }
+
+    auto op = PlanBuilder().exchange(intermediatePlan->outputType()).planNode();
+
+    auto task = assertQuery(
+        op, intermediateTaskIds, "SELECT c0, c1, c2, c3, c4 FROM tmp");
+    ASSERT_TRUE(waitForTaskCompletion(leafTask.get()))
+        << "state: " << leafTask->state();
+    auto taskStats = toPlanStats(leafTask->taskStats());
+    ASSERT_GT(taskStats.at("1").outputVectors, 2);
+  }
+}
+
 TEST_F(MultiFragmentTest, broadcast) {
   auto data = makeRowVector(
       {makeFlatVector<int32_t>(1'000, [](auto row) { return row; })});
@@ -542,7 +658,7 @@ TEST_F(MultiFragmentTest, broadcast) {
       PlanBuilder().values({data}).partitionedOutputBroadcast().planNode();
   auto leafTask = makeTask(leafTaskId, leafPlan, 0);
   tasks.emplace_back(leafTask);
-  Task::start(leafTask, 1);
+  leafTask->start(1);
 
   // Make next stage tasks.
   core::PlanNodePtr finalAggPlan;
@@ -557,7 +673,7 @@ TEST_F(MultiFragmentTest, broadcast) {
     finalAggTaskIds.push_back(makeTaskId("final-agg", i));
     auto task = makeTask(finalAggTaskIds.back(), finalAggPlan, i);
     tasks.emplace_back(task);
-    Task::start(task, 1);
+    task->start(1);
     leafTask->updateOutputBuffers(i + 1, false);
     addRemoteSplits(task, {leafTaskId});
   }
@@ -609,7 +725,7 @@ TEST_F(MultiFragmentTest, roundRobinPartition) {
   auto addTask = [&](std::shared_ptr<Task> task,
                      const std::vector<std::string>& remoteTaskIds) {
     tasks.emplace_back(task);
-    Task::start(task, 1);
+    task->start(1);
     if (!remoteTaskIds.empty()) {
       addRemoteSplits(task, remoteTaskIds);
     }
@@ -641,6 +757,67 @@ TEST_F(MultiFragmentTest, roundRobinPartition) {
   }
 }
 
+// Test PartitionedOutput operator with constant partitioning keys.
+TEST_F(MultiFragmentTest, constantKeys) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(
+          1'000, [](auto row) { return row; }, nullEvery(7)),
+  });
+
+  std::vector<std::shared_ptr<Task>> tasks;
+  auto addTask = [&](std::shared_ptr<Task> task,
+                     const std::vector<std::string>& remoteTaskIds) {
+    tasks.emplace_back(task);
+    task->start(1);
+    if (!remoteTaskIds.empty()) {
+      addRemoteSplits(task, remoteTaskIds);
+    }
+  };
+
+  // Make leaf task: Values -> Repartitioning (3-way)
+  auto leafTaskId = makeTaskId("leaf", 0);
+  auto leafPlan = PlanBuilder()
+                      .values({data})
+                      .partitionedOutput({"c0", "123"}, 3, true, {"c0"})
+                      .planNode();
+  auto leafTask = makeTask(leafTaskId, leafPlan, 0);
+  addTask(leafTask, {});
+
+  // Make next stage tasks to count nulls.
+  core::PlanNodePtr finalAggPlan;
+  std::vector<std::string> finalAggTaskIds;
+  for (int i = 0; i < 3; i++) {
+    finalAggPlan =
+        PlanBuilder()
+            .exchange(leafPlan->outputType())
+            .project({"c0 is null AS co_is_null"})
+            .partialAggregation({}, {"count_if(co_is_null)", "count(1)"})
+            .partitionedOutput({}, 1)
+            .planNode();
+
+    finalAggTaskIds.push_back(makeTaskId("final-agg", i));
+    auto task = makeTask(finalAggTaskIds.back(), finalAggPlan, i);
+    addTask(task, {leafTaskId});
+  }
+
+  // Collect results and verify number of nulls is 3 times larger than in the
+  // original data.
+  auto op = PlanBuilder()
+                .exchange(finalAggPlan->outputType())
+                .finalAggregation(
+                    {}, {"sum(a0)", "sum(a1)"}, {{BIGINT()}, {BIGINT()}})
+                .planNode();
+
+  assertQuery(
+      op,
+      finalAggTaskIds,
+      "SELECT 3 * ceil(1000.0 / 7) /* number of null rows */, 1000 + 2 * ceil(1000.0 / 7) /* total number of rows */");
+
+  for (auto& task : tasks) {
+    ASSERT_TRUE(waitForTaskCompletion(task.get())) << task->taskId();
+  }
+}
+
 TEST_F(MultiFragmentTest, replicateNullsAndAny) {
   auto data = makeRowVector({makeFlatVector<int32_t>(
       1'000, [](auto row) { return row; }, nullEvery(7))});
@@ -649,7 +826,7 @@ TEST_F(MultiFragmentTest, replicateNullsAndAny) {
   auto addTask = [&](std::shared_ptr<Task> task,
                      const std::vector<std::string>& remoteTaskIds) {
     tasks.emplace_back(task);
-    Task::start(task, 1);
+    task->start(1);
     if (!remoteTaskIds.empty()) {
       addRemoteSplits(task, remoteTaskIds);
     }
@@ -705,7 +882,7 @@ TEST_F(MultiFragmentTest, limit) {
       1'000, [](auto row) { return row; }, nullEvery(7))});
 
   auto file = TempFilePath::create();
-  writeToFile(file->path, {data});
+  writeToFile(file->getPath(), {data});
 
   // Make leaf task: Values -> PartialLimit(10) -> Repartitioning(0).
   auto leafTaskId = makeTaskId("leaf", 0);
@@ -716,10 +893,10 @@ TEST_F(MultiFragmentTest, limit) {
           .partitionedOutput({}, 1)
           .planNode();
   auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-  Task::start(leafTask, 1);
+  leafTask->start(1);
 
   leafTask.get()->addSplit(
-      "0", exec::Split(makeHiveConnectorSplit(file->path)));
+      "0", exec::Split(makeHiveConnectorSplit(file->getPath())));
 
   // Make final task: Exchange -> FinalLimit(10).
   auto plan = PlanBuilder()
@@ -760,7 +937,7 @@ TEST_F(MultiFragmentTest, mergeExchangeOverEmptySources) {
 
     auto task = makeTask(taskId, plan, tasks.size());
     tasks.push_back(task);
-    Task::start(task, 4);
+    task->start(4);
   }
 
   auto exchangeTaskId = makeTaskId("exchange-", 0);
@@ -827,7 +1004,7 @@ TEST_F(MultiFragmentTest, earlyCompletion) {
 
   auto task = makeTask(leafTaskId, plan, tasks.size());
   tasks.push_back(task);
-  Task::start(task, 1);
+  task->start(1);
 
   // Create intermediate tasks.
   std::vector<std::string> joinTaskIds;
@@ -851,7 +1028,7 @@ TEST_F(MultiFragmentTest, earlyCompletion) {
 
     auto task = makeTask(taskId, joinPlan, i);
     tasks.push_back(task);
-    Task::start(task, 4);
+    task->start(4);
 
     addRemoteSplits(task, {leafTaskId});
   }
@@ -890,7 +1067,7 @@ TEST_F(MultiFragmentTest, earlyCompletionBroadcast) {
 
   auto leafTask = makeTask(leafTaskId, plan, tasks.size());
   tasks.push_back(leafTask);
-  Task::start(leafTask, 1);
+  leafTask->start(1);
 
   // Create intermediate tasks.
   std::vector<std::string> joinTaskIds;
@@ -914,7 +1091,7 @@ TEST_F(MultiFragmentTest, earlyCompletionBroadcast) {
 
     auto task = makeTask(taskId, joinPlan, i);
     tasks.push_back(task);
-    Task::start(task, 4);
+    task->start(4);
 
     leafTask->updateOutputBuffers(i + 1, false);
 
@@ -954,7 +1131,7 @@ TEST_F(MultiFragmentTest, earlyCompletionMerge) {
 
   auto task = makeTask(leafTaskId, plan, tasks.size());
   tasks.push_back(task);
-  Task::start(task, 1);
+  task->start(1);
 
   // Create intermediate tasks.
   std::vector<std::string> joinTaskIds;
@@ -988,7 +1165,7 @@ TEST_F(MultiFragmentTest, earlyCompletionMerge) {
 
     auto task = makeTask(taskId, joinPlan, i);
     tasks.push_back(task);
-    Task::start(task, 4);
+    task->start(4);
 
     addRemoteSplits(task, {leafTaskId});
   }
@@ -1104,7 +1281,7 @@ TEST_F(MultiFragmentTest, exchangeDestruction) {
                  .planNode();
 
   auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-  Task::start(leafTask, 1);
+  leafTask->start(1);
   addHiveSplits(leafTask, filePaths_);
 
   auto rootPlan =
@@ -1117,7 +1294,7 @@ TEST_F(MultiFragmentTest, exchangeDestruction) {
           .planNode();
 
   auto rootTask = makeTask("root-task", rootPlan, 0);
-  Task::start(rootTask, 1);
+  rootTask->start(1);
   addRemoteSplits(rootTask, {leafTaskId});
 
   ASSERT_FALSE(waitForTaskCompletion(rootTask.get(), 1'000'000));
@@ -1148,7 +1325,7 @@ TEST_F(MultiFragmentTest, cancelledExchange) {
   auto exchangeTask =
       makeTask("output.0.0.1", planFragmentWithExchange.planNode, 0);
   // Start the task and abort it straight away.
-  Task::start(exchangeTask, 2);
+  exchangeTask->start(2);
   exchangeTask->requestAbort();
 
   /* sleep override */
@@ -1196,7 +1373,7 @@ class TestCustomExchange : public exec::Exchange {
  public:
   TestCustomExchange(
       int32_t operatorId,
-      DriverCtx* FOLLY_NONNULL ctx,
+      DriverCtx* ctx,
       const std::shared_ptr<const TestCustomExchangeNode>& customExchangeNode,
       std::shared_ptr<ExchangeClient> exchangeClient)
       : exec::Exchange(
@@ -1236,7 +1413,7 @@ TEST_F(MultiFragmentTest, customPlanNodeWithExchangeClient) {
   auto leafPlan =
       PlanBuilder().values(vectors_).partitionedOutput({}, 1).planNode();
   auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-  Task::start(leafTask, 1);
+  leafTask->start(1);
 
   CursorParameters params;
   core::PlanNodeId testNodeId;
@@ -1250,7 +1427,7 @@ TEST_F(MultiFragmentTest, customPlanNodeWithExchangeClient) {
           .capturePlanNodeId(testNodeId)
           .planNode();
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   auto task = cursor->task();
   addRemoteSplits(task, {leafTaskId});
   while (cursor->moveNext()) {
@@ -1287,7 +1464,7 @@ DEBUG_ONLY_TEST_F(
                                    .partitionedOutput({}, 1)
                                    .planNode();
   auto leafTask = makeTask(leafTaskId, leafPlan, 0);
-  Task::start(leafTask, 1);
+  leafTask->start(1);
   addHiveSplits(leafTask, filePaths_);
 
   const std::string kRootTaskId("root-task");
@@ -1329,7 +1506,7 @@ DEBUG_ONLY_TEST_F(
       [](RowVectorPtr /*unused*/, ContinueFuture* /*unused*/)
           -> BlockingReason { return BlockingReason::kNotBlocked; },
       kRootMemoryLimit);
-  Task::start(rootTask, 1);
+  rootTask->start(1);
   rootTask->addSplit("0", remoteSplit(leafTaskId));
   blockNoMoreSplits.await([&]() { return noMoreSplits.load(); });
   rootTask->noMoreSplits("0");
@@ -1347,10 +1524,9 @@ TEST_F(MultiFragmentTest, taskTerminateWithPendingOutputBuffers) {
       PlanBuilder().tableScan(rowType_).partitionedOutput({}, 1).planNode();
 
   auto task = makeTask(taskId, leafPlan, 0);
-  Task::start(task, 1);
+  task->start(1);
   addHiveSplits(task, filePaths_);
 
-  auto bufferManager = PartitionedOutputBufferManager::getInstance().lock();
   const uint64_t maxBytes = std::numeric_limits<uint64_t>::max();
   const int destination = 0;
   std::vector<std::unique_ptr<folly::IOBuf>> receivedIobufs;
@@ -1358,13 +1534,14 @@ TEST_F(MultiFragmentTest, taskTerminateWithPendingOutputBuffers) {
   for (;;) {
     auto dataPromise = ContinuePromise("WaitForOutput");
     bool complete{false};
-    ASSERT_TRUE(bufferManager->getData(
+    ASSERT_TRUE(bufferManager_->getData(
         taskId,
         destination,
         maxBytes,
         sequence,
         [&](std::vector<std::unique_ptr<folly::IOBuf>> iobufs,
-            int64_t inSequence) {
+            int64_t inSequence,
+            std::vector<int64_t> /*remainingBytes*/) {
           for (auto& iobuf : iobufs) {
             if (iobuf != nullptr) {
               ++inSequence;
@@ -1405,7 +1582,9 @@ TEST_F(MultiFragmentTest, taskTerminateWithPendingOutputBuffers) {
   task.reset();
 }
 
-TEST_F(MultiFragmentTest, taskTerminateWithProblematicRemainingRemoteSplits) {
+DEBUG_ONLY_TEST_F(
+    MultiFragmentTest,
+    taskTerminateWithProblematicRemainingRemoteSplits) {
   // Start the task with 2 drivers.
   auto probeData =
       makeRowVector({"p_c0"}, {makeFlatVector<int64_t>({1, 2, 3})});
@@ -1426,32 +1605,52 @@ TEST_F(MultiFragmentTest, taskTerminateWithProblematicRemainingRemoteSplits) {
                   .planNode();
   auto taskId = makeTaskId("final", 0);
   auto task = makeTask(taskId, plan, 0);
-  Task::start(task, 2);
-
-  // Wait for all drivers to be blocked, so that the promises will be made.
-  bool allDriversBlocked = false;
-  while (!allDriversBlocked) {
-    allDriversBlocked = true;
-    task->testingVisitDrivers([&](Driver* driver) {
-      if (driver->isOnThread() ||
-          (driver->blockingReason() != BlockingReason::kWaitForSplit &&
-           driver->blockingReason() != BlockingReason::kWaitForProducer &&
-           driver->blockingReason() != BlockingReason::kWaitForJoinBuild)) {
-        allDriversBlocked = false;
-      }
-    });
-  }
+  task->start(2);
 
-  // Add one bad remote split and trigger Task::terminate.
-  task->addSplit(exchangeNodeId, remoteSplit(makeBadTaskId("leaf", 0)));
+  std::atomic<bool> driverRunWaitFlag{true};
+  folly::EventCount driverRunWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal",
+      std::function<void(const Driver*)>([&](const Driver* /* unused */) {
+        // Block on driver run so that added bad split is not immediately
+        // consumed. It gets unblocked when task termination state is set.
+        driverRunWait.await([&]() { return !(driverRunWaitFlag.load()); });
+      }));
+
+  std::atomic<bool> taskSetErrorWaitFlag{true};
+  folly::EventCount taskSetErrorWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::setError",
+      std::function<void(const Task*)>([&](const Task* /* unused */) {
+        taskSetErrorWait.await(
+            [&]() { return !(taskSetErrorWaitFlag.load()); });
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::terminate",
+      std::function<void(const Task*)>([&](const Task* /* unused */) {
+        driverRunWaitFlag = false;
+        driverRunWait.notifyAll();
+      }));
+
+  std::thread failThread([&]() {
+    try {
+      VELOX_FAIL("Test terminate task");
+    } catch (const VeloxException& e) {
+      task->setError(std::current_exception());
+    }
+  });
 
   // Add one more bad split, making sure `remainingRemoteSplits` is not empty
   // and processing it would cause an exception.
-  task->addSplit(exchangeNodeId, remoteSplit(makeBadTaskId("leaf", 1)));
+  task->addSplit(exchangeNodeId, remoteSplit(makeBadTaskId("leaf", 0)));
+  taskSetErrorWaitFlag = false;
+  taskSetErrorWait.notifyAll();
 
   // Wait for the task to fail, and make sure the task has been deleted instead
   // of hanging as a zombie task.
   ASSERT_TRUE(waitForTaskFailure(task.get(), 3'000'000)) << task->taskId();
+  failThread.join();
 }
 
 DEBUG_ONLY_TEST_F(MultiFragmentTest, mergeWithEarlyTermination) {
@@ -1475,7 +1674,7 @@ DEBUG_ONLY_TEST_F(MultiFragmentTest, mergeWithEarlyTermination) {
                              .planNode();
 
   auto partialSortTask = makeTask(sortTaskId, partialSortPlan, 1);
-  Task::start(partialSortTask, 1);
+  partialSortTask->start(1);
   addHiveSplits(partialSortTask, filePaths);
 
   std::atomic<bool> blockMergeOnce{true};
@@ -1501,7 +1700,7 @@ DEBUG_ONLY_TEST_F(MultiFragmentTest, mergeWithEarlyTermination) {
                            .partitionedOutput({}, 1)
                            .planNode();
   auto finalSortTask = makeTask(finalSortTaskId, finalSortPlan, 0);
-  Task::start(finalSortTask, 1);
+  finalSortTask->start(1);
   addRemoteSplits(finalSortTask, partialSortTaskIds);
 
   mergeIsBlockedReady.store(true);
@@ -1547,23 +1746,19 @@ class DataFetcher {
  private:
   static constexpr int64_t kInitialSequence = 0;
 
-  std::shared_ptr<PartitionedOutputBufferManager> bufferManager() {
-    return PartitionedOutputBufferManager::getInstance().lock();
-  }
-
   void doFetch(int64_t sequence) {
-    bool ok = bufferManager()->getData(
+    bool ok = bufferManager_->getData(
         taskId_,
         destination_,
         maxBytes_,
         sequence,
-        [&](auto pages, auto sequence) mutable {
+        [&](auto pages, auto sequence, auto /*remainingBytes*/) mutable {
           const auto nextSequence = sequence + pages.size();
           const bool atEnd = processData(std::move(pages), sequence);
-          bufferManager()->acknowledge(taskId_, destination_, nextSequence);
+          bufferManager_->acknowledge(taskId_, destination_, nextSequence);
 
           if (atEnd) {
-            bufferManager()->deleteResults(taskId_, destination_);
+            bufferManager_->deleteResults(taskId_, destination_);
             promise_.setValue();
           } else {
             doFetch(nextSequence);
@@ -1600,6 +1795,9 @@ class DataFetcher {
   int32_t numPackets_{0};
   int32_t numPages_{0};
   int64_t totalBytes_{0};
+
+  std::shared_ptr<OutputBufferManager> bufferManager_{
+      OutputBufferManager::getInstance().lock()};
 };
 
 /// Verify that POBM::getData() honors maxBytes parameter roughly at 1MB
@@ -1608,14 +1806,19 @@ class DataFetcher {
 /// sizes to no more than 1MB give and take 30%.
 TEST_F(MultiFragmentTest, maxBytes) {
   std::string s(25, 'x');
+  // Keep the row count under 7000 to avoid hitting the row limit in the
+  // operator instead.
   auto data = makeRowVector({
-      makeFlatVector<int64_t>(10'000, [](auto row) { return row; }),
-      makeConstant(StringView(s), 10'000),
+      makeFlatVector<int64_t>(5'000, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(5'000, [](auto row) { return row; }),
+      makeConstant(StringView(s), 5'000),
   });
 
+  core::PlanNodeId outputNodeId;
   auto plan = PlanBuilder()
                   .values({data}, false, 100)
                   .partitionedOutput({}, 1)
+                  .capturePlanNodeId(outputNodeId)
                   .planNode();
 
   int32_t testIteration = 0;
@@ -1626,7 +1829,7 @@ TEST_F(MultiFragmentTest, maxBytes) {
 
     SCOPED_TRACE(taskId);
     auto task = makeTask(taskId, plan, 0);
-    Task::start(task, 1);
+    task->start(1);
     task->updateOutputBuffers(1, true);
 
     // Allow for data to accumulate.
@@ -1646,11 +1849,13 @@ TEST_F(MultiFragmentTest, maxBytes) {
 
     ASSERT_LT(stats.averagePacketBytes(), maxBytes * 1.5);
 
-    prevStats = stats;
-  };
+    auto taskStats = toPlanStats(task->taskStats());
+    const auto& outputStats = taskStats.at(outputNodeId);
 
-  auto verifyStats = [](auto prev, auto current) {
-    EXPECT_EQ(prev.numPages, current.numPages);
+    ASSERT_EQ(outputStats.outputBytes, stats.totalBytes);
+    ASSERT_EQ(outputStats.inputRows, 100 * data->size());
+    ASSERT_EQ(outputStats.outputRows, 100 * data->size());
+    prevStats = stats;
   };
 
   static const int64_t kMB = 1 << 20;
@@ -1662,17 +1867,22 @@ TEST_F(MultiFragmentTest, maxBytes) {
   test(32 * kMB);
 }
 
-/// Verify that ExchangeClient stats are populated even if task fails.
+// Verifies that ExchangeClient stats are populated even if task fails.
 DEBUG_ONLY_TEST_F(MultiFragmentTest, exchangeStatsOnFailure) {
-  // Trigger a failure after fetching first 10 pages.
+  // Triggers a failure after fetching first 10 pages.
+  std::atomic_uint64_t expectedReceivedPages{0};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::test::LocalExchangeSource",
-      std::function<void(void* data)>([&](void* data) {
-        int32_t numPages = *static_cast<int32_t*>(data);
-        if (numPages > 10) {
-          VELOX_FAIL("Forced failure after {} pages", numPages);
-        }
-      }));
+      std::function<void(exec::ExchangeSource * data)>(
+          [&](exec::ExchangeSource* source) {
+            auto* queue = source->testingQueue();
+            const auto receivedPages = queue->receivedPages();
+            if (receivedPages > 10) {
+              expectedReceivedPages = receivedPages;
+
+              VELOX_FAIL("Forced failure after {} pages", receivedPages);
+            }
+          }));
 
   std::string s(25, 'x');
   auto data = makeRowVector({
@@ -1687,13 +1897,13 @@ DEBUG_ONLY_TEST_F(MultiFragmentTest, exchangeStatsOnFailure) {
 
   auto producerTaskId = makeTaskId("producer", 0);
   auto producerTask = makeTask(producerTaskId, producerPlan, 0);
-  Task::start(producerTask, 1);
+  producerTask->start(1);
   producerTask->updateOutputBuffers(1, true);
 
   auto plan = PlanBuilder().exchange(producerPlan->outputType()).planNode();
 
   auto task = makeTask("t", plan, 0, noopConsumer());
-  Task::start(task, 4);
+  task->start(4);
   task->addSplit("0", remoteSplit(producerTaskId));
   task->noMoreSplits("0");
 
@@ -1703,10 +1913,184 @@ DEBUG_ONLY_TEST_F(MultiFragmentTest, exchangeStatsOnFailure) {
       << "Got: [" << task->errorMessage() << "]";
 
   auto stats = toPlanStats(task->taskStats());
-  EXPECT_EQ(10, stats.at("0").customStats.at("numReceivedPages").sum);
+
+  EXPECT_EQ(
+      expectedReceivedPages,
+      stats.at("0").customStats.at("numReceivedPages").sum);
 
   ASSERT_TRUE(waitForTaskCompletion(producerTask.get(), 3'000'000));
 }
 
+TEST_F(MultiFragmentTest, earlyTaskFailure) {
+  setupSources(1, 10);
+
+  const auto partialSortTaskId = makeTaskId("partialSortBy", 0);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto partialSortPlan = PlanBuilder(planNodeIdGenerator)
+                             .localMerge(
+                                 {"c0"},
+                                 {PlanBuilder(planNodeIdGenerator)
+                                      .tableScan(rowType_)
+                                      .orderBy({"c0"}, true)
+                                      .planNode()})
+                             .partitionedOutput({}, 1)
+                             .planNode();
+  for (bool internalFailure : {false, true}) {
+    SCOPED_TRACE(fmt::format("internalFailure: {}", internalFailure));
+
+    auto partialSortTask = makeTask(partialSortTaskId, partialSortPlan, 1);
+    partialSortTask->start(1);
+    addHiveSplits(partialSortTask, filePaths_);
+    auto outputType = partialSortPlan->outputType();
+
+    auto finalSortTaskId = makeTaskId("finalSortBy", 0);
+    auto finalSortPlan = PlanBuilder()
+                             .mergeExchange(outputType, {"c0"})
+                             .partitionedOutput({}, 1)
+                             .planNode();
+
+    auto finalSortTask = makeTask(finalSortTaskId, finalSortPlan, 0);
+    if (internalFailure) {
+      try {
+        VELOX_FAIL("memoryAbortTest");
+      } catch (const VeloxRuntimeError& e) {
+        finalSortTask->pool()->abort(std::current_exception());
+      }
+    } else {
+      finalSortTask->requestAbort().wait();
+    }
+
+    finalSortTask->start(1);
+    addRemoteSplits(finalSortTask, std::vector<std::string>{partialSortTaskId});
+    partialSortTask->requestAbort().wait();
+
+    if (internalFailure) {
+      ASSERT_TRUE(waitForTaskFailure(finalSortTask.get()))
+          << finalSortTask->taskId();
+    } else {
+      ASSERT_TRUE(waitForTaskAborted(finalSortTask.get()))
+          << finalSortTask->taskId();
+    }
+    ASSERT_TRUE(waitForTaskAborted(partialSortTask.get()))
+        << partialSortTask->taskId();
+  }
+}
+
+TEST_F(MultiFragmentTest, mergeSmallBatchesInExchange) {
+  auto data = makeRowVector({makeFlatVector<int32_t>({1, 2, 3})});
+
+  const int32_t numPartitions = 100;
+  auto producerPlan = test::PlanBuilder()
+                          .values({data})
+                          .partitionedOutput({"c0"}, numPartitions)
+                          .planNode();
+  const auto producerTaskId = "local://t1";
+
+  auto plan = test::PlanBuilder().exchange(asRowType(data->type())).planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>(3'000, [](auto row) { return 1 + row % 3; }),
+  });
+
+  auto test = [&](uint64_t maxBytes, int32_t expectedBatches) {
+    auto producerTask = makeTask(producerTaskId, producerPlan);
+
+    bufferManager_->initializeTask(
+        producerTask,
+        core::PartitionedOutputNode::Kind::kPartitioned,
+        numPartitions,
+        1);
+
+    auto cleanupGuard = folly::makeGuard([&]() {
+      producerTask->requestCancel();
+      bufferManager_->removeTask(producerTaskId);
+    });
+
+    // Enqueue many small pages.
+    const int32_t numPages = 1'000;
+    for (auto i = 0; i < numPages; ++i) {
+      enqueue(producerTaskId, 17, data);
+    }
+    bufferManager_->noMoreData(producerTaskId);
+
+    auto task = test::AssertQueryBuilder(plan)
+                    .split(remoteSplit(producerTaskId))
+                    .destination(17)
+                    .config(
+                        core::QueryConfig::kPreferredOutputBatchBytes,
+                        std::to_string(maxBytes))
+                    .assertResults(expected);
+
+    auto taskStats = exec::toPlanStats(task->taskStats());
+    const auto& stats = taskStats.at("0");
+
+    ASSERT_EQ(expected->size(), stats.outputRows);
+    ASSERT_EQ(expectedBatches, stats.outputVectors);
+    ASSERT_EQ(numPages, stats.customStats.at("numReceivedPages").sum);
+  };
+
+  test(1, 1'000);
+  test(1'000, 56);
+  test(10'000, 6);
+  test(100'000, 1);
+}
+
+TEST_F(MultiFragmentTest, compression) {
+  bufferManager_->testingSetCompression(
+      common::CompressionKind::CompressionKind_LZ4);
+  auto guard = folly::makeGuard([&]() {
+    bufferManager_->testingSetCompression(
+        common::CompressionKind::CompressionKind_NONE);
+  });
+
+  constexpr int32_t kNumRepeats = 1'000'000;
+  const auto data = makeRowVector({makeFlatVector<int64_t>({1, 2, 3})});
+
+  const auto producerPlan = test::PlanBuilder()
+                                .values({data}, false, kNumRepeats)
+                                .partitionedOutput({}, 1)
+                                .planNode();
+
+  const auto plan = test::PlanBuilder()
+                        .exchange(asRowType(data->type()))
+                        .singleAggregation({}, {"sum(c0)"})
+                        .planNode();
+
+  const auto expected =
+      makeRowVector({makeFlatVector<int64_t>(std::vector<int64_t>{6000000})});
+
+  const auto test = [&](const std::string& producerTaskId,
+                        float minCompressionRatio,
+                        bool expectSkipCompression) {
+    PartitionedOutput::testingSetMinCompressionRatio(minCompressionRatio);
+    auto producerTask = makeTask(producerTaskId, producerPlan);
+    producerTask->start(1);
+
+    auto consumerTask = test::AssertQueryBuilder(plan)
+                            .split(remoteSplit(producerTaskId))
+                            .destination(0)
+                            .assertResults(expected);
+
+    auto consumerTaskStats = exec::toPlanStats(consumerTask->taskStats());
+    const auto& consumerPlanStats = consumerTaskStats.at("0");
+    ASSERT_EQ(data->size() * kNumRepeats, consumerPlanStats.outputRows);
+
+    auto producerTaskStats = exec::toPlanStats(producerTask->taskStats());
+    const auto& producerStats = producerTaskStats.at("1");
+    // The data is extremely compressible, 1, 2, 3 repeated 1000000 times.
+    if (!expectSkipCompression) {
+      EXPECT_LT(
+          producerStats.customStats.at("compressedBytes").sum,
+          producerStats.customStats.at("compressionInputBytes").sum);
+      EXPECT_EQ(0, producerStats.customStats.at("compressionSkippedBytes").sum);
+    } else {
+      EXPECT_LT(0, producerStats.customStats.at("compressionSkippedBytes").sum);
+    }
+  };
+
+  test("local://t1", 0.7, false);
+  test("local://t2", 0.0000001, true);
+}
+
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/NestedLoopJoinTest.cpp b/velox/exec/tests/NestedLoopJoinTest.cpp
index d0825a3aa7518..475046fad67be 100644
--- a/velox/exec/tests/NestedLoopJoinTest.cpp
+++ b/velox/exec/tests/NestedLoopJoinTest.cpp
@@ -13,14 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/VectorTestUtil.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
-using namespace facebook::velox;
-using namespace facebook::velox::exec;
-using namespace facebook::velox::exec::test;
+namespace facebook::velox::exec::test {
+namespace {
+
+using facebook::velox::test::assertEqualVectors;
 
 class NestedLoopJoinTest : public HiveConnectorTestBase {
  protected:
@@ -69,16 +71,27 @@ class NestedLoopJoinTest : public HiveConnectorTestBase {
       const std::vector<RowVectorPtr>& buildVectors) {
     runTest(probeVectors, buildVectors, 1);
     runTest(probeVectors, buildVectors, 4);
+    runTest(
+        probeVectors,
+        buildVectors,
+        4,
+        4); // Run with smaller output batch size.
   }
 
   void runTest(
       const std::vector<RowVectorPtr>& probeVectors,
       const std::vector<RowVectorPtr>& buildVectors,
-      int32_t numDrivers) {
+      int32_t numDrivers,
+      size_t preferredOutputBatchSize = 1024) {
     createDuckDbTable("t", probeVectors);
     createDuckDbTable("u", buildVectors);
+    auto queryCtx = core::QueryCtx::create(executor_.get());
 
     CursorParameters params;
+    params.queryCtx = queryCtx;
+    params.queryCtx->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kPreferredOutputBatchRows,
+          std::to_string(preferredOutputBatchSize)}});
     params.maxDrivers = numDrivers;
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
 
@@ -122,7 +135,8 @@ class NestedLoopJoinTest : public HiveConnectorTestBase {
       core::JoinType::kInner,
       core::JoinType::kLeft,
       core::JoinType::kRight,
-      core::JoinType::kFull};
+      core::JoinType::kFull,
+  };
   std::vector<std::string> outputLayout_{probeKeyName_, buildKeyName_};
   std::string joinConditionStr_{probeKeyName_ + " {} " + buildKeyName_};
   std::string queryStr_{fmt::format(
@@ -131,6 +145,72 @@ class NestedLoopJoinTest : public HiveConnectorTestBase {
       buildKeyName_)};
 };
 
+TEST_F(NestedLoopJoinTest, emptyBuildOrProbeWithoutFilter) {
+  auto empty = makeRowVector({"u0"}, {makeFlatVector<StringView>({})});
+  auto nonEmpty = makeRowVector({"t0"}, {makeFlatVector<StringView>({"foo"})});
+  auto expected = makeRowVector({makeFlatVector<StringView>({"foo", "foo"})});
+
+  auto testJoin = [&](const std::vector<RowVectorPtr>& leftVectors,
+                      const std::vector<RowVectorPtr>& rightVectors,
+                      core::JoinType joinType,
+                      const std::vector<std::string>& outputLayout,
+                      const VectorPtr& expected) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(leftVectors)
+                    .localPartitionRoundRobinRow()
+                    .nestedLoopJoin(
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(rightVectors)
+                            .localPartition({})
+                            .planNode(),
+                        "",
+                        outputLayout,
+                        joinType)
+                    .planNode();
+    AssertQueryBuilder builder{plan};
+    auto result = builder.copyResults(pool());
+    facebook::velox::test::assertEqualVectors(expected, result);
+  };
+
+  testJoin({nonEmpty}, {empty}, core::JoinType::kLeft, {"t0"}, nonEmpty);
+  testJoin(
+      {nonEmpty, nonEmpty},
+      {empty, empty},
+      core::JoinType::kLeft,
+      {"t0"},
+      expected);
+  testJoin({empty}, {nonEmpty}, core::JoinType::kLeft, {"u0"}, empty);
+
+  testJoin({empty}, {nonEmpty}, core::JoinType::kRight, {"t0"}, nonEmpty);
+  testJoin(
+      {empty, empty},
+      {nonEmpty, nonEmpty},
+      core::JoinType::kRight,
+      {"t0"},
+      expected);
+  testJoin({nonEmpty}, {empty}, core::JoinType::kRight, {"u0"}, empty);
+
+  testJoin(
+      {nonEmpty, nonEmpty},
+      {empty, empty},
+      core::JoinType::kFull,
+      {"t0", "u0"},
+      makeRowVector({
+          makeFlatVector<StringView>({"foo", "foo"}),
+          makeNullableFlatVector<StringView>({std::nullopt, std::nullopt}),
+      }));
+  testJoin(
+      {empty, empty},
+      {nonEmpty, nonEmpty},
+      core::JoinType::kFull,
+      {"u0", "t0"},
+      makeRowVector({
+          makeNullableFlatVector<StringView>({std::nullopt, std::nullopt}),
+          makeFlatVector<StringView>({"foo", "foo"}),
+      }));
+}
+
 TEST_F(NestedLoopJoinTest, basic) {
   auto probeVectors = makeBatches(20, 5, probeType_, pool_.get());
   auto buildVectors = makeBatches(18, 5, buildType_, pool_.get());
@@ -259,7 +339,8 @@ TEST_F(NestedLoopJoinTest, basicCrossJoin) {
 
   OperatorTestBase::assertQuery(
       params,
-      "SELECT * FROM t, (SELECT * FROM UNNEST (ARRAY[10, 17, 10, 17, 10, 17, 10, 17])) u");
+      "SELECT * FROM t, "
+      "(SELECT * FROM UNNEST (ARRAY[10, 17, 10, 17, 10, 17, 10, 17])) u");
 }
 
 TEST_F(NestedLoopJoinTest, outerJoinWithoutCondition) {
@@ -381,8 +462,8 @@ TEST_F(NestedLoopJoinTest, zeroColumnBuild) {
 }
 
 TEST_F(NestedLoopJoinTest, bigintArray) {
-  auto probeVectors = makeBatches(1000, 5, probeType_, pool_.get());
-  auto buildVectors = makeBatches(900, 5, buildType_, pool_.get());
+  auto probeVectors = makeBatches(100, 5, probeType_, pool_.get());
+  auto buildVectors = makeBatches(90, 5, buildType_, pool_.get());
   setComparisons({"="});
   setJoinTypes({core::JoinType::kFull});
   runSingleAndMultiDriverTest(probeVectors, buildVectors);
@@ -421,3 +502,72 @@ TEST_F(NestedLoopJoinTest, allTypes) {
       "SELECT t0, u0 FROM t {0} JOIN u ON t.t0 {1} u0 AND t1 {1} u1 AND t2 {1} u2 AND t3 {1} u3 AND t4 {1} u4 AND t5 {1} u5 AND t6 {1} u6");
   runSingleAndMultiDriverTest(probeVectors, buildVectors);
 }
+
+// Ensures output order follows the probe input order for inner and left joins.
+TEST_F(NestedLoopJoinTest, outputOrder) {
+  auto probeVectors = makeRowVector(
+      {"l1", "l2"},
+      {
+          makeNullableFlatVector<int64_t>({1, 8, 6, std::nullopt, 7, 4}),
+          makeFlatVector<StringView>({"a", "b", "c", "d", "e", "f"}),
+      });
+  auto buildVector1 = makeRowVector(
+      {"r1", "r2"},
+      {
+          makeNullableFlatVector<int64_t>({4, 6, 1}),
+          makeFlatVector<StringView>({"z", "x", "y"}),
+      });
+
+  auto buildVector2 = makeRowVector(
+      {"r1", "r2"},
+      {
+          makeNullableFlatVector<int64_t>({10, std::nullopt, 6}),
+          makeFlatVector<StringView>({"z", "p", "u"}),
+      });
+
+  const auto createPlan = [&](core::JoinType joinType) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values({probeVectors})
+        .nestedLoopJoin(
+            PlanBuilder(planNodeIdGenerator)
+                .values({buildVector1, buildVector2})
+                .project({"r1", "r2"})
+                .planNode(),
+            "l1 < r1",
+            {"l1", "l2", "r1", "r2"},
+            joinType)
+        .planNode();
+  };
+
+  // Inner.
+  auto results = AssertQueryBuilder(createPlan(core::JoinType::kInner))
+                     .copyResults(pool());
+  auto expectedInner = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, 1, 1, 1, 8, 6, 7, 4, 4, 4}),
+      makeFlatVector<StringView>(
+          {"a", "a", "a", "a", "b", "c", "e", "f", "f", "f"}),
+      makeNullableFlatVector<int64_t>({4, 6, 10, 6, 10, 10, 10, 6, 10, 6}),
+      makeFlatVector<StringView>(
+          {"z", "x", "z", "u", "z", "z", "z", "x", "z", "u"}),
+  });
+  assertEqualVectors(expectedInner, results);
+
+  // Left.
+  results =
+      AssertQueryBuilder(createPlan(core::JoinType::kLeft)).copyResults(pool());
+  auto expectedLeft = makeRowVector({
+      makeNullableFlatVector<int64_t>(
+          {1, 1, 1, 1, 8, 6, std::nullopt, 7, 4, 4, 4}),
+      makeNullableFlatVector<StringView>(
+          {"a", "a", "a", "a", "b", "c", "d", "e", "f", "f", "f"}),
+      makeNullableFlatVector<int64_t>(
+          {4, 6, 10, 6, 10, 10, std::nullopt, 10, 6, 10, 6}),
+      makeNullableFlatVector<StringView>(
+          {"z", "x", "z", "u", "z", "z", std::nullopt, "z", "x", "z", "u"}),
+  });
+  assertEqualVectors(expectedLeft, results);
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/OperatorReplacement.cpp b/velox/exec/tests/OperatorReplacement.cpp
new file mode 100644
index 0000000000000..dd39ea32e7f7b
--- /dev/null
+++ b/velox/exec/tests/OperatorReplacement.cpp
@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/JoinBridge.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace {
+using ReplacedJoinNode = typename facebook::velox::core::HashJoinNode;
+
+class CustomJoinBridge : public JoinBridge {
+ public:
+  void setNumRows(std::optional<int32_t> numRows) {
+    std::vector<ContinuePromise> promises;
+    {
+      std::lock_guard<std::mutex> l(mutex_);
+      VELOX_CHECK(!numRows_.has_value(), "setNumRows may be called only once");
+      numRows_ = numRows;
+      promises = std::move(promises_);
+    }
+    notify(std::move(promises));
+  }
+
+  std::optional<int32_t> numRowsOrFuture(ContinueFuture* future) {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(!cancelled_, "Getting data after the build side is aborted");
+    if (numRows_.has_value()) {
+      return numRows_;
+    }
+    promises_.emplace_back("CustomJoinBridge::numRowsOrFuture");
+    *future = promises_.back().getSemiFuture();
+    return std::nullopt;
+  }
+
+ private:
+  std::optional<int32_t> numRows_;
+};
+
+class CustomJoinBuild : public Operator {
+ public:
+  CustomJoinBuild(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      std::shared_ptr<const ReplacedJoinNode> joinNode)
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            joinNode->id(),
+            "CustomJoinBuild") {}
+  CustomJoinBuild(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const core::PlanNodeId& joinNodeid)
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            joinNodeid,
+            "CustomJoinBuild") {}
+
+  void addInput(RowVectorPtr input) override {
+    auto inputSize = input->size();
+    if (inputSize > 0) {
+      numRows_ += inputSize;
+    }
+  }
+
+  bool needsInput() const override {
+    return !noMoreInput_;
+  }
+
+  RowVectorPtr getOutput() override {
+    return nullptr;
+  }
+
+  void noMoreInput() override {
+    Operator::noMoreInput();
+    std::vector<ContinuePromise> promises;
+    std::vector<std::shared_ptr<Driver>> peers;
+    // The last Driver to hit CustomJoinBuild::finish gathers the data from
+    // all build Drivers and hands it over to the probe side. At this
+    // point all build Drivers are continued and will free their
+    // state. allPeersFinished is true only for the last Driver of the
+    // build pipeline.
+    if (!operatorCtx_->task()->allPeersFinished(
+            planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
+      return;
+    }
+
+    for (auto& peer : peers) {
+      auto op = peer->findOperator(planNodeId());
+      auto* build = dynamic_cast<CustomJoinBuild*>(op);
+      VELOX_CHECK(build);
+      numRows_ += build->numRows_;
+    }
+
+    // Realize the promises so that the other Drivers (which were not
+    // the last to finish) can continue from the barrier and finish.
+    peers.clear();
+    for (auto& promise : promises) {
+      promise.setValue();
+    }
+
+    auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
+        operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+    auto customJoinBridge =
+        std::dynamic_pointer_cast<CustomJoinBridge>(joinBridge);
+
+    // checks
+    VELOX_CHECK_NOT_NULL(
+        customJoinBridge,
+        "Join bridge for plan node ID is of the wrong type: {}",
+        planNodeId());
+    customJoinBridge->setNumRows(std::make_optional(numRows_));
+  }
+
+  BlockingReason isBlocked(ContinueFuture* future) override {
+    if (!future_.valid()) {
+      return BlockingReason::kNotBlocked;
+    }
+    *future = std::move(future_);
+    return BlockingReason::kWaitForJoinBuild;
+  }
+
+  bool isFinished() override {
+    return !future_.valid() && noMoreInput_;
+  }
+
+ private:
+  int32_t numRows_ = 0;
+
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+};
+
+class CustomJoinProbe : public Operator {
+ public:
+  CustomJoinProbe(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      std::shared_ptr<const ReplacedJoinNode> joinNode)
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            joinNode->id(),
+            "CustomJoinProbe") {}
+  CustomJoinProbe(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const core::PlanNodeId& joinNodeid)
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            joinNodeid,
+            "CustomJoinProbe") {}
+
+  bool needsInput() const override {
+    return !finished_ && input_ == nullptr;
+  }
+
+  void addInput(RowVectorPtr input) override {
+    input_ = std::move(input);
+  }
+
+  RowVectorPtr getOutput() override {
+    if (!input_) {
+      return nullptr;
+    }
+
+    const auto inputSize = input_->size();
+    if (remainingLimit_ <= inputSize) {
+      finished_ = true;
+    }
+
+    if (remainingLimit_ >= inputSize) {
+      remainingLimit_ -= inputSize;
+      auto output = input_;
+      input_.reset();
+      return output;
+    }
+
+    // Return nullptr if there is no data to return.
+    if (remainingLimit_ == 0) {
+      input_.reset();
+      return nullptr;
+    }
+
+    auto output = std::make_shared<RowVector>(
+        input_->pool(),
+        input_->type(),
+        input_->nulls(),
+        remainingLimit_,
+        input_->children());
+    input_.reset();
+    remainingLimit_ = 0;
+    return output;
+  }
+
+  BlockingReason isBlocked(ContinueFuture* future) override {
+    if (numRows_.has_value()) {
+      return BlockingReason::kNotBlocked;
+    }
+
+    auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
+        operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+    auto customJoinBridge =
+        std::dynamic_pointer_cast<CustomJoinBridge>(joinBridge);
+
+    // checks
+    VELOX_CHECK_NOT_NULL(
+        customJoinBridge,
+        "Join bridge for plan node ID is of the wrong type: {}",
+        planNodeId());
+    auto numRows = customJoinBridge->numRowsOrFuture(future);
+
+    if (!numRows.has_value()) {
+      return BlockingReason::kWaitForJoinBuild;
+    }
+    numRows_ = std::move(numRows);
+    remainingLimit_ = numRows_.value();
+
+    return BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override {
+    return finished_ || (noMoreInput_ && input_ == nullptr);
+  }
+
+ private:
+  int32_t remainingLimit_;
+  std::optional<int32_t> numRows_;
+
+  bool finished_{false};
+};
+
+class CustomJoinBridgeTranslator : public Operator::PlanNodeTranslator {
+  std::unique_ptr<Operator>
+  toOperator(DriverCtx* ctx, int32_t id, const core::PlanNodePtr& node) {
+    if (auto joinNode =
+            std::dynamic_pointer_cast<const ReplacedJoinNode>(node)) {
+      return std::make_unique<CustomJoinProbe>(id, ctx, joinNode);
+    }
+    return nullptr;
+  }
+
+  std::unique_ptr<JoinBridge> toJoinBridge(const core::PlanNodePtr& node) {
+    if (auto joinNode =
+            std::dynamic_pointer_cast<const ReplacedJoinNode>(node)) {
+      auto joinBridge = std::make_unique<CustomJoinBridge>();
+      return std::move(joinBridge);
+    }
+    return nullptr;
+  }
+
+  OperatorSupplier toOperatorSupplier(const core::PlanNodePtr& node) {
+    if (auto joinNode =
+            std::dynamic_pointer_cast<const ReplacedJoinNode>(node)) {
+      return [joinNode](int32_t operatorId, DriverCtx* ctx) {
+        return std::make_unique<CustomJoinBuild>(operatorId, ctx, joinNode);
+      };
+    }
+    return nullptr;
+  }
+};
+
+bool CustomDriverAdapter(
+    const exec::DriverFactory& driverFactory_,
+    exec::Driver& driver_) {
+  auto operators = driver_.operators();
+  // Make sure operator states are initialized.  We will need to inspect some of
+  // them during the transformation.
+  driver_.initializeOperators();
+  auto ctx = driver_.driverCtx();
+  // Replace HashBuild and HashProbe operators with CustomHashBuild and
+  // CustomHashProbe operators.
+  for (int32_t operatorIndex = 0; operatorIndex < operators.size();
+       ++operatorIndex) {
+    std::vector<std::unique_ptr<exec::Operator>> replace_op;
+
+    facebook::velox::exec::Operator* oper = operators[operatorIndex];
+    VELOX_CHECK(oper);
+    if (auto joinBuildOp =
+            dynamic_cast<facebook::velox::exec::HashBuild*>(oper)) {
+      auto planid = joinBuildOp->planNodeId();
+      auto id = joinBuildOp->operatorId();
+      replace_op.push_back(std::make_unique<CustomJoinBuild>(id, ctx, planid));
+      replace_op[0]->initialize();
+      auto replaced = driverFactory_.replaceOperators(
+          driver_, operatorIndex, operatorIndex + 1, std::move(replace_op));
+    } else if (
+        auto joinProbeOp =
+            dynamic_cast<facebook::velox::exec::HashProbe*>(oper)) {
+      auto planid = joinProbeOp->planNodeId();
+      auto id = joinProbeOp->operatorId();
+      replace_op.push_back(std::make_unique<CustomJoinProbe>(id, ctx, planid));
+      replace_op[0]->initialize();
+      auto replaced = driverFactory_.replaceOperators(
+          driver_, operatorIndex, operatorIndex + 1, std::move(replace_op));
+    }
+  }
+  return true;
+}
+
+void registerCustomDriver() {
+  exec::DriverAdapter custAdapter{"opRep", {}, CustomDriverAdapter};
+  exec::DriverFactory::registerAdapter(custAdapter);
+}
+
+void registerOperatorReplacement() {
+  // Registering Translator
+  exec::Operator::registerOperator(
+      std::make_unique<CustomJoinBridgeTranslator>());
+  // Registering Custom Driver Adapter
+  registerCustomDriver();
+}
+} // namespace
+
+/// This test will show the operator replacement with other operators using
+/// driver adapter and usage of custom join bridge for replaced velox
+/// join operators. It uses same custom operators from CustomJoinTest,
+/// which will emit number of input rows.
+class OperatorReplacementTest : public OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    registerOperatorReplacement();
+  }
+
+  RowVectorPtr makeSimpleRowVector(vector_size_t size) {
+    return makeRowVector(
+        {makeFlatVector<int32_t>(size, [](auto row) { return row; })});
+  }
+
+  void testOperatorReplacement(
+      int32_t numThreads,
+      const std::vector<RowVectorPtr>& leftBatch,
+      const std::vector<RowVectorPtr>& rightBatch,
+      const std::string& referenceQuery) {
+    createDuckDbTable("t", {leftBatch});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+    CursorParameters params;
+    params.maxDrivers = numThreads;
+    params.planNode = PlanBuilder(planNodeIdGenerator)
+                          .values({leftBatch}, false)
+                          .hashJoin(
+                              {"c0"},
+                              {"u1"},
+                              PlanBuilder(planNodeIdGenerator)
+                                  .values(rightBatch, false)
+                                  .project({"c0 AS u1"})
+                                  .planNode(),
+                              "",
+                              {"c0"})
+                          .project({"c0"})
+                          .planNode();
+
+    OperatorTestBase::assertQuery(params, referenceQuery);
+  }
+};
+
+TEST_F(OperatorReplacementTest, basic) {
+  auto leftBatch = {makeSimpleRowVector(100)};
+  auto rightBatch = {makeSimpleRowVector(10)};
+  testOperatorReplacement(
+      1, leftBatch, rightBatch, "SELECT c0 FROM t LIMIT 10");
+}
diff --git a/velox/exec/tests/OperatorUtilsTest.cpp b/velox/exec/tests/OperatorUtilsTest.cpp
index df40347dfe29c..5d4bab633b4b6 100644
--- a/velox/exec/tests/OperatorUtilsTest.cpp
+++ b/velox/exec/tests/OperatorUtilsTest.cpp
@@ -23,10 +23,37 @@
 using namespace facebook::velox;
 using namespace facebook::velox::test;
 using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
 
-class OperatorUtilsTest
-    : public ::facebook::velox::exec::test::OperatorTestBase {
+class OperatorUtilsTest : public OperatorTestBase {
  protected:
+  void TearDown() override {
+    driverCtx_.reset();
+    driver_.reset();
+    task_.reset();
+    OperatorTestBase::TearDown();
+  }
+
+  OperatorUtilsTest() {
+    VectorMaker vectorMaker{pool_.get()};
+    std::vector<RowVectorPtr> values = {vectorMaker.rowVector(
+        {vectorMaker.flatVector<int32_t>(1, [](auto row) { return row; })})};
+    core::PlanFragment planFragment;
+    const core::PlanNodeId id{"0"};
+    planFragment.planNode = std::make_shared<core::ValuesNode>(id, values);
+    executor_ = std::make_shared<folly::CPUThreadPoolExecutor>(4);
+
+    task_ = Task::create(
+        "SpillOperatorGroupTest_task",
+        std::move(planFragment),
+        0,
+        core::QueryCtx::create(executor_.get()),
+        Task::ExecutionMode::kParallel);
+    driver_ = Driver::testingCreate();
+    driverCtx_ = std::make_unique<DriverCtx>(task_, 0, 0, 0, 0);
+    driverCtx_->driver = driver_.get();
+  }
+
   void gatherCopyTest(
       const std::shared_ptr<const RowType>& targetType,
       const std::shared_ptr<const RowType>& sourceType,
@@ -106,7 +133,60 @@ class OperatorUtilsTest
     }
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  void setTaskOutputBatchConfig(
+      uint32_t preferredBatchSize,
+      uint32_t maxRows,
+      uint64_t preferredBytes) {
+    std::unordered_map<std::string, std::string> configs;
+    configs[core::QueryConfig::kPreferredOutputBatchRows] =
+        std::to_string(preferredBatchSize);
+    configs[core::QueryConfig::kMaxOutputBatchRows] = std::to_string(maxRows);
+    configs[core::QueryConfig::kPreferredOutputBatchBytes] =
+        std::to_string(preferredBytes);
+    task_->queryCtx()->testingOverrideConfigUnsafe(std::move(configs));
+  }
+
+  class MockOperator : public Operator {
+   public:
+    MockOperator(
+        DriverCtx* driverCtx,
+        RowTypePtr rowType,
+        std::string operatorType = "MockType")
+        : Operator(
+              driverCtx,
+              std::move(rowType),
+              0,
+              "MockOperator",
+              operatorType) {}
+
+    bool needsInput() const override {
+      return false;
+    }
+
+    void addInput(RowVectorPtr input) override {}
+
+    RowVectorPtr getOutput() override {
+      return nullptr;
+    }
+
+    BlockingReason isBlocked(ContinueFuture* future) override {
+      return BlockingReason::kNotBlocked;
+    }
+
+    bool isFinished() override {
+      return false;
+    }
+
+    vector_size_t outputRows(
+        std::optional<uint64_t> averageRowSize = std::nullopt) const {
+      return outputBatchRows(averageRowSize);
+    }
+  };
+
+  std::shared_ptr<folly::CPUThreadPoolExecutor> executor_;
+  std::shared_ptr<Task> task_;
+  std::shared_ptr<Driver> driver_;
+  std::unique_ptr<DriverCtx> driverCtx_;
 };
 
 TEST_F(OperatorUtilsTest, wrapChildConstant) {
@@ -311,12 +391,15 @@ TEST_F(OperatorUtilsTest, projectChildren) {
 
   {
     std::vector<IdentityProjection> emptyProjection;
-    auto destRowVector =
-        BaseVector::create<RowVector>(srcRowType, srcVectorSize, pool());
+    std::vector<VectorPtr> projectedChildren(srcRowType->size());
     projectChildren(
-        destRowVector, srcRowVector, emptyProjection, srcVectorSize, nullptr);
-    for (vector_size_t i = 0; i < destRowVector->childrenSize(); ++i) {
-      ASSERT_EQ(destRowVector->childAt(i)->size(), 0);
+        projectedChildren,
+        srcRowVector,
+        emptyProjection,
+        srcVectorSize,
+        nullptr);
+    for (vector_size_t i = 0; i < projectedChildren.size(); ++i) {
+      ASSERT_EQ(projectedChildren[i], nullptr);
     }
   }
 
@@ -325,17 +408,16 @@ TEST_F(OperatorUtilsTest, projectChildren) {
     for (auto i = 0; i < srcRowType->size(); ++i) {
       identicalProjections.emplace_back(i, i);
     }
-    auto destRowVector =
-        BaseVector::create<RowVector>(srcRowType, srcVectorSize, pool());
+    std::vector<VectorPtr> projectedChildren(srcRowType->size());
     projectChildren(
-        destRowVector,
+        projectedChildren,
         srcRowVector,
         identicalProjections,
         srcVectorSize,
         nullptr);
     for (const auto& projection : identicalProjections) {
       ASSERT_EQ(
-          destRowVector->childAt(projection.outputChannel).get(),
+          projectedChildren[projection.outputChannel].get(),
           srcRowVector->childAt(projection.inputChannel).get());
     }
   }
@@ -348,14 +430,104 @@ TEST_F(OperatorUtilsTest, projectChildren) {
     std::vector<IdentityProjection> projections{};
     projections.emplace_back(2, 0);
     projections.emplace_back(0, 1);
-    auto destRowVector =
-        BaseVector::create<RowVector>(destRowType, srcVectorSize, pool());
+    std::vector<VectorPtr> projectedChildren(srcRowType->size());
     projectChildren(
-        destRowVector, srcRowVector, projections, srcVectorSize, nullptr);
+        projectedChildren, srcRowVector, projections, srcVectorSize, nullptr);
     for (const auto& projection : projections) {
       ASSERT_EQ(
-          destRowVector->childAt(projection.outputChannel).get(),
+          projectedChildren[projection.outputChannel].get(),
           srcRowVector->childAt(projection.inputChannel).get());
     }
   }
 }
+
+TEST_F(OperatorUtilsTest, reclaimableSectionGuard) {
+  RowTypePtr rowType = ROW({"c0"}, {INTEGER()});
+
+  MockOperator mockOp(driverCtx_.get(), rowType);
+  ASSERT_FALSE(mockOp.testingNonReclaimable());
+  {
+    Operator::NonReclaimableSectionGuard guard(&mockOp);
+    ASSERT_TRUE(mockOp.testingNonReclaimable());
+    {
+      Operator::NonReclaimableSectionGuard guard(&mockOp);
+      ASSERT_TRUE(mockOp.testingNonReclaimable());
+    }
+    ASSERT_TRUE(mockOp.testingNonReclaimable());
+    {
+      Operator::ReclaimableSectionGuard guard(&mockOp);
+      ASSERT_FALSE(mockOp.testingNonReclaimable());
+      {
+        Operator::NonReclaimableSectionGuard guard(&mockOp);
+        ASSERT_TRUE(mockOp.testingNonReclaimable());
+      }
+      ASSERT_FALSE(mockOp.testingNonReclaimable());
+      {
+        Operator::NonReclaimableSectionGuard guard(&mockOp);
+        ASSERT_TRUE(mockOp.testingNonReclaimable());
+      }
+      ASSERT_FALSE(mockOp.testingNonReclaimable());
+    }
+    ASSERT_TRUE(mockOp.testingNonReclaimable());
+  }
+  ASSERT_FALSE(mockOp.testingNonReclaimable());
+}
+
+TEST_F(OperatorUtilsTest, memStatsFromPool) {
+  auto leafPool = rootPool_->addLeafChild("leaf-1.0");
+  void* buffer;
+  buffer = leafPool->allocate(2L << 20);
+  leafPool->free(buffer, 2L << 20);
+  const auto stats = MemoryStats::memStatsFromPool(leafPool.get());
+  ASSERT_EQ(stats.userMemoryReservation, 0);
+  ASSERT_EQ(stats.systemMemoryReservation, 0);
+  ASSERT_EQ(stats.peakUserMemoryReservation, 2L << 20);
+  ASSERT_EQ(stats.peakSystemMemoryReservation, 0);
+  ASSERT_EQ(stats.numMemoryAllocations, 1);
+}
+
+TEST_F(OperatorUtilsTest, dynamicFilterStats) {
+  DynamicFilterStats dynamicFilterStats;
+  ASSERT_TRUE(dynamicFilterStats.empty());
+  const std::string nodeId1{"node1"};
+  const std::string nodeId2{"node2"};
+  dynamicFilterStats.producerNodeIds.emplace(nodeId1);
+  ASSERT_FALSE(dynamicFilterStats.empty());
+  DynamicFilterStats dynamicFilterStatsToMerge;
+  dynamicFilterStatsToMerge.producerNodeIds.emplace(nodeId1);
+  ASSERT_FALSE(dynamicFilterStatsToMerge.empty());
+  dynamicFilterStats.add(dynamicFilterStatsToMerge);
+  ASSERT_EQ(dynamicFilterStats.producerNodeIds.size(), 1);
+  ASSERT_EQ(
+      dynamicFilterStats.producerNodeIds,
+      std::unordered_set<core::PlanNodeId>({nodeId1}));
+
+  dynamicFilterStatsToMerge.producerNodeIds.emplace(nodeId2);
+  dynamicFilterStats.add(dynamicFilterStatsToMerge);
+  ASSERT_EQ(dynamicFilterStats.producerNodeIds.size(), 2);
+  ASSERT_EQ(
+      dynamicFilterStats.producerNodeIds,
+      std::unordered_set<core::PlanNodeId>({nodeId1, nodeId2}));
+
+  dynamicFilterStats.clear();
+  ASSERT_TRUE(dynamicFilterStats.empty());
+}
+
+TEST_F(OperatorUtilsTest, outputBatchRows) {
+  RowTypePtr rowType = ROW({"c0"}, {INTEGER()});
+  {
+    setTaskOutputBatchConfig(10, 20, 234);
+    MockOperator mockOp(driverCtx_.get(), rowType, "MockType1");
+    ASSERT_EQ(10, mockOp.outputRows(std::nullopt));
+    ASSERT_EQ(20, mockOp.outputRows(1));
+    ASSERT_EQ(20, mockOp.outputRows(0));
+    ASSERT_EQ(1, mockOp.outputRows(UINT64_MAX));
+    ASSERT_EQ(1, mockOp.outputRows(1000));
+    ASSERT_EQ(234 / 40, mockOp.outputRows(40));
+  }
+  {
+    setTaskOutputBatchConfig(10, INT32_MAX, 3'000'000'000'000);
+    MockOperator mockOp(driverCtx_.get(), rowType, "MockType2");
+    ASSERT_EQ(1000, mockOp.outputRows(3'000'000'000));
+  }
+}
diff --git a/velox/exec/tests/OrderByTest.cpp b/velox/exec/tests/OrderByTest.cpp
index c7b6bc910497e..ca40cb7e1b765 100644
--- a/velox/exec/tests/OrderByTest.cpp
+++ b/velox/exec/tests/OrderByTest.cpp
@@ -15,13 +15,16 @@
  */
 #include <re2/re2.h>
 
+#include <fmt/format.h>
 #include "folly/experimental/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/core/QueryConfig.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/Spiller.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -35,10 +38,11 @@ using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::core;
 using namespace facebook::velox::exec::test;
 
+namespace facebook::velox::exec::test {
 namespace {
 // Returns aggregated spilled stats by 'task'.
-SpillStats spilledStats(const exec::Task& task) {
-  SpillStats spilledStats;
+common::SpillStats spilledStats(const exec::Task& task) {
+  common::SpillStats spilledStats;
   auto stats = task.taskStats();
   for (auto& pipeline : stats.pipelineStats) {
     for (auto op : pipeline.operatorStats) {
@@ -55,7 +59,7 @@ SpillStats spilledStats(const exec::Task& task) {
 void abortPool(memory::MemoryPool* pool) {
   try {
     VELOX_FAIL("Manual MemoryPool Abortion");
-  } catch (const VeloxException& error) {
+  } catch (const VeloxException&) {
     pool->abort(std::current_exception());
   }
 }
@@ -64,11 +68,20 @@ void abortPool(memory::MemoryPool* pool) {
 class OrderByTest : public OperatorTestBase {
  protected:
   void SetUp() override {
+    OperatorTestBase::SetUp();
     filesystems::registerLocalFileSystem();
-    if (!isRegisteredVectorSerde()) {
-      this->registerVectorSerde();
-    }
     rng_.seed(123);
+
+    rowType_ = ROW(
+        {{"c0", INTEGER()},
+         {"c1", INTEGER()},
+         {"c2", VARCHAR()},
+         {"c3", VARCHAR()}});
+    fuzzerOpts_.vectorSize = 1024;
+    fuzzerOpts_.nullRatio = 0;
+    fuzzerOpts_.stringVariableLength = false;
+    fuzzerOpts_.stringLength = 1024;
+    fuzzerOpts_.allowLazyVector = false;
   }
 
   void testSingleKey(
@@ -137,7 +150,7 @@ class OrderByTest : public OperatorTestBase {
       const std::vector<RowVectorPtr>& input,
       const std::string& key1,
       const std::string& key2) {
-    auto rowType = input[0]->type()->asRow();
+    auto& rowType = input[0]->type()->asRow();
     auto keyIndices = {rowType.getChildIdx(key1), rowType.getChildIdx(key2)};
 
     std::vector<core::SortOrder> sortOrders = {
@@ -181,31 +194,33 @@ class OrderByTest : public OperatorTestBase {
     {
       SCOPED_TRACE("run with spilling");
       auto spillDirectory = exec::test::TempDirectoryPath::create();
-      auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+      auto queryCtx = core::QueryCtx::create(executor_.get());
+      TestScopedSpillInjection scopedSpillInjection(100);
       queryCtx->testingOverrideConfigUnsafe({
-          {core::QueryConfig::kTestingSpillPct, "100"},
           {core::QueryConfig::kSpillEnabled, "true"},
           {core::QueryConfig::kOrderBySpillEnabled, "true"},
       });
       CursorParameters params;
       params.planNode = planNode;
       params.queryCtx = queryCtx;
-      params.spillDirectory = spillDirectory->path;
+      params.spillDirectory = spillDirectory->getPath();
       auto task = assertQueryOrdered(params, duckDbSql, sortingKeys);
       auto inputRows = toPlanStats(task->taskStats()).at(orderById).inputRows;
-      const uint64_t peakSpillMemoryUsage = Spiller::pool()->stats().peakBytes;
-      ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
+      const uint64_t peakSpillMemoryUsage =
+          memory::spillMemoryPool()->stats().peakBytes;
+      ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
       if (inputRows > 0) {
         EXPECT_LT(0, spilledStats(*task).spilledInputBytes);
         EXPECT_LT(0, spilledStats(*task).spilledBytes);
         EXPECT_EQ(1, spilledStats(*task).spilledPartitions);
         EXPECT_LT(0, spilledStats(*task).spilledFiles);
-        // NOTE: the last input batch won't go spilling.
-        EXPECT_GT(inputRows, spilledStats(*task).spilledRows);
-        ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
-        if (Spiller::pool()->trackUsage()) {
-          ASSERT_GT(Spiller::pool()->stats().peakBytes, 0);
-          ASSERT_GE(Spiller::pool()->stats().peakBytes, peakSpillMemoryUsage);
+        EXPECT_EQ(inputRows, spilledStats(*task).spilledRows);
+        ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
+        if (memory::spillMemoryPool()->trackUsage()) {
+          ASSERT_GT(memory::spillMemoryPool()->stats().peakBytes, 0);
+          ASSERT_GE(
+              memory::spillMemoryPool()->stats().peakBytes,
+              peakSpillMemoryUsage);
         }
       } else {
         EXPECT_EQ(0, spilledStats(*task).spilledInputBytes);
@@ -215,8 +230,23 @@ class OrderByTest : public OperatorTestBase {
     }
   }
 
+  std::vector<RowVectorPtr> makeVectors(
+      const RowTypePtr& rowType,
+      int32_t numVectors,
+      int32_t rowsPerVector) {
+    std::vector<RowVectorPtr> vectors;
+    for (int32_t i = 0; i < numVectors; ++i) {
+      auto vector = std::dynamic_pointer_cast<RowVector>(
+          velox::test::BatchMaker::createBatch(rowType, rowsPerVector, *pool_));
+      vectors.push_back(vector);
+    }
+    return vectors;
+  }
+
   folly::Random::DefaultGenerator rng_;
   memory::MemoryReclaimer::Stats reclaimerStats_;
+  RowTypePtr rowType_;
+  VectorFuzzer::Options fuzzerOpts_;
 };
 
 TEST_F(OrderByTest, selectiveFilter) {
@@ -389,19 +419,26 @@ TEST_F(OrderByTest, outputBatchRows) {
   struct {
     int numRowsPerBatch;
     int preferredOutBatchBytes;
+    int maxOutBatchRows;
     int expectedOutputVectors;
 
+    // TODO: add output size check with spilling enabled
     std::string debugString() const {
       return fmt::format(
-          "numRowsPerBatch:{}, preferredOutBatchSize:{}, expectedOutputVectors:{}",
+          "numRowsPerBatch:{}, preferredOutBatchBytes:{}, maxOutBatchRows:{}, expectedOutputVectors:{}",
           numRowsPerBatch,
           preferredOutBatchBytes,
+          maxOutBatchRows,
           expectedOutputVectors);
     }
-    // Output kPreferredOutputBatchRows by default and thus include all rows in
-    // a single vector.
-    // TODO(gaoge): change after determining output batch rows adaptively.
-  } testSettings[] = {{1024, 1, 1}};
+  } testSettings[] = {
+      {1024, 1, 100, 1024},
+      // estimated size per row is ~2092, set preferredOutBatchBytes to 20920,
+      // so each batch has 10 rows, so it would return 100 batches
+      {1000, 20920, 100, 100},
+      // same as above, but maxOutBatchRows is 1, so it would return 1000
+      // batches
+      {1000, 20920, 1, 1000}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
@@ -425,10 +462,12 @@ TEST_F(OrderByTest, outputBatchRows) {
                     .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
                     .capturePlanNodeId(orderById)
                     .planNode();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+    auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideConfigUnsafe(
         {{core::QueryConfig::kPreferredOutputBatchBytes,
-          std::to_string(testData.preferredOutBatchBytes)}});
+          std::to_string(testData.preferredOutBatchBytes)},
+         {core::QueryConfig::kMaxOutputBatchRows,
+          std::to_string(testData.maxOutBatchRows)}});
     CursorParameters params;
     params.planNode = plan;
     params.queryCtx = queryCtx;
@@ -441,127 +480,51 @@ TEST_F(OrderByTest, outputBatchRows) {
 }
 
 TEST_F(OrderByTest, spill) {
-  const int kNumBatches = 3;
-  const int kNumRows = 100'000;
-  std::vector<RowVectorPtr> batches;
-  for (int i = 0; i < kNumBatches; ++i) {
-    batches.push_back(makeRowVector(
-        {makeFlatVector<int64_t>(kNumRows, [](auto row) { return row * 3; }),
-         makeFlatVector<StringView>(kNumRows, [](auto row) {
-           return StringView::makeInline(std::to_string(row * 3));
-         })}));
-  }
-  createDuckDbTable(batches);
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto vectors = createVectors(rowType, 1024, 48 << 20);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId orderNodeId;
+  const auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(vectors)
+          .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
+          .capturePlanNodeId(orderNodeId)
+          .planNode();
+
+  const auto expectedResult = AssertQueryBuilder(plan).copyResults(pool_.get());
 
-  auto plan = PlanBuilder()
-                  .values(batches)
-                  .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                  .planNode();
   auto spillDirectory = exec::test::TempDirectoryPath::create();
-  auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  constexpr int64_t kMaxBytes = 20LL << 20; // 20 MB
-  queryCtx->testingOverrideMemoryPool(
-      memory::defaultMemoryManager().addRootPool(
-          queryCtx->queryId(), kMaxBytes));
-  // Set 'kSpillableReservationGrowthPct' to an extreme large value to trigger
-  // disk spilling by failed memory growth reservation.
-  queryCtx->testingOverrideConfigUnsafe({
-      {core::QueryConfig::kSpillEnabled, "true"},
-      {core::QueryConfig::kOrderBySpillEnabled, "true"},
-      {core::QueryConfig::kSpillableReservationGrowthPct, "1000"},
-  });
-  CursorParameters params;
-  params.planNode = plan;
-  params.queryCtx = queryCtx;
-  params.spillDirectory = spillDirectory->path;
-  auto task = assertQueryOrdered(
-      params, "SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST", {0});
-  auto stats = task->taskStats().pipelineStats[0].operatorStats[1];
-  ASSERT_GT(stats.spilledRows, 0);
-  ASSERT_LT(stats.spilledRows, kNumBatches * kNumRows);
-  ASSERT_GT(stats.spilledBytes, 0);
-  ASSERT_GT(stats.spilledInputBytes, 0);
-  ASSERT_EQ(stats.spilledPartitions, 1);
-  ASSERT_EQ(stats.spilledFiles, 2);
-  ASSERT_GT(stats.runtimeStats["spillRuns"].count, 0);
-  ASSERT_GT(stats.runtimeStats["spillFillTime"].sum, 0);
-  ASSERT_GT(stats.runtimeStats["spillSortTime"].sum, 0);
-  ASSERT_GT(stats.runtimeStats["spillSerializationTime"].sum, 0);
-  ASSERT_GT(stats.runtimeStats["spillFlushTime"].sum, 0);
+  TestScopedSpillInjection scopedSpillInjection(100);
+  auto task = AssertQueryBuilder(plan)
+                  .spillDirectory(spillDirectory->getPath())
+                  .config(core::QueryConfig::kSpillEnabled, true)
+                  .config(core::QueryConfig::kOrderBySpillEnabled, true)
+                  .assertResults(expectedResult);
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  auto& planStats = taskStats.at(orderNodeId);
+  ASSERT_GT(planStats.spilledBytes, 0);
+  ASSERT_GT(planStats.spilledRows, 0);
+  ASSERT_GT(planStats.spilledBytes, 0);
+  ASSERT_GT(planStats.spilledInputBytes, 0);
+  ASSERT_EQ(planStats.spilledPartitions, 1);
+  ASSERT_GT(planStats.spilledFiles, 0);
+  ASSERT_GT(planStats.customStats[Operator::kSpillRuns].count, 0);
+  ASSERT_GT(planStats.customStats[Operator::kSpillFillTime].sum, 0);
+  ASSERT_GT(planStats.customStats[Operator::kSpillSortTime].sum, 0);
+  ASSERT_GT(planStats.customStats[Operator::kSpillSerializationTime].sum, 0);
+  ASSERT_GT(planStats.customStats[Operator::kSpillFlushTime].sum, 0);
   ASSERT_EQ(
-      stats.runtimeStats["spillSerializationTime"].count,
-      stats.runtimeStats["spillFlushTime"].count);
-  ASSERT_GT(stats.runtimeStats["spillDiskWrites"].sum, 0);
-  ASSERT_GT(stats.runtimeStats["spillWriteTime"].sum, 0);
+      planStats.customStats[Operator::kSpillSerializationTime].count,
+      planStats.customStats[Operator::kSpillFlushTime].count);
+  ASSERT_GT(planStats.customStats[Operator::kSpillWrites].sum, 0);
+  ASSERT_GT(planStats.customStats[Operator::kSpillWriteTime].sum, 0);
   ASSERT_EQ(
-      stats.runtimeStats["spillDiskWrites"].count,
-      stats.runtimeStats["spillWriteTime"].count);
-
+      planStats.customStats[Operator::kSpillWrites].count,
+      planStats.customStats[Operator::kSpillWriteTime].count);
   OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
 }
 
-TEST_F(OrderByTest, spillWithMemoryLimit) {
-  constexpr int32_t kNumRows = 2000;
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
-  auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({}, pool());
-  const int32_t numBatches = 5;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
-  struct {
-    uint64_t orderByMemLimit;
-    bool expectSpill;
-
-    std::string debugString() const {
-      return fmt::format(
-          "orderByMemLimit:{}, expectSpill:{}", orderByMemLimit, expectSpill);
-    }
-  } testSettings[] = {// Memory limit is disabled so spilling is not triggered.
-                      {0, false},
-                      // Memory limit is too small so always trigger spilling.
-                      {1, true},
-                      // Memory limit is too large so spilling is not triggered.
-                      {1'000'000'000, false}};
-  for (const auto& testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
-    auto results =
-        AssertQueryBuilder(
-            PlanBuilder()
-                .values(batches)
-                .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                .planNode())
-            .queryCtx(queryCtx)
-            .copyResults(pool_.get());
-    auto task =
-        AssertQueryBuilder(
-            PlanBuilder()
-                .values(batches)
-                .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                .planNode())
-            .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kOrderBySpillEnabled, "true")
-            .config(
-                QueryConfig::kOrderBySpillMemoryThreshold,
-                std::to_string(testData.orderByMemLimit))
-            .assertResults(results);
-
-    auto stats = task->taskStats().pipelineStats;
-    ASSERT_EQ(
-        testData.expectSpill, stats[0].operatorStats[1].spilledInputBytes > 0);
-    ASSERT_EQ(testData.expectSpill, stats[0].operatorStats[1].spilledBytes > 0);
-    OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
-  }
-}
-
 DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringInputProcessing) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
@@ -591,11 +554,10 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringInputProcessing) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -652,9 +614,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringInputProcessing) {
                 .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
                 .planNode())
             .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kOrderBySpillEnabled, "true")
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kOrderBySpillEnabled, true)
             .maxDrivers(1)
             .assertResults(expectedResult);
       } else {
@@ -687,10 +649,17 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringInputProcessing) {
     }
 
     if (testData.expectedReclaimable) {
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-          reclaimerStats_);
-      ASSERT_EQ(op->pool()->currentBytes(), 0);
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        op->pool()->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+            0,
+            reclaimerStats_);
+      }
+      ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+      reclaimerStats_.reset();
+      ASSERT_EQ(op->pool()->usedBytes(), 0);
     } else {
       VELOX_ASSERT_THROW(
           op->reclaim(
@@ -727,11 +696,10 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringReserve) {
     batches.push_back(fuzzer.fuzzRow(rowType));
   }
 
-  auto tempDirectory = exec::test::TempDirectoryPath::create();
-  auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-  queryCtx->testingOverrideMemoryPool(
-      memory::defaultMemoryManager().addRootPool(
-          queryCtx->queryId(), kMaxBytes));
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   auto expectedResult =
       AssertQueryBuilder(
           PlanBuilder()
@@ -788,9 +756,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringReserve) {
             .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
             .planNode())
         .queryCtx(queryCtx)
-        .spillDirectory(tempDirectory->path)
-        .config(core::QueryConfig::kSpillEnabled, "true")
-        .config(core::QueryConfig::kOrderBySpillEnabled, "true")
+        .spillDirectory(spillDirectory->getPath())
+        .config(core::QueryConfig::kSpillEnabled, true)
+        .config(core::QueryConfig::kOrderBySpillEnabled, true)
         .maxDrivers(1)
         .assertResults(expectedResult);
   });
@@ -807,10 +775,17 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringReserve) {
   ASSERT_TRUE(reclaimable);
   ASSERT_GT(reclaimableBytes, 0);
 
-  op->reclaim(
-      folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-      reclaimerStats_);
-  ASSERT_EQ(op->pool()->currentBytes(), 0);
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    op->pool()->reclaim(
+        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+        0,
+        reclaimerStats_);
+  }
+  ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+  ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
+  reclaimerStats_.reset();
+  ASSERT_EQ(op->pool()->usedBytes(), 0);
 
   driverWait.notify();
   Task::resume(task);
@@ -834,14 +809,13 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringAllocation) {
     batches.push_back(fuzzer.fuzzRow(rowType));
   }
 
-  std::vector<bool> enableSpillings = {false, true};
+  const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
     queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
+        memory::memoryManager()->addRootPool(queryCtx->queryId(), kMaxBytes));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -903,9 +877,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringAllocation) {
                 .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
                 .planNode())
             .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kOrderBySpillEnabled, "true")
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kOrderBySpillEnabled, true)
             .maxDrivers(1)
             .assertResults(expectedResult);
       } else {
@@ -936,17 +910,11 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringAllocation) {
       ASSERT_EQ(reclaimableBytes, 0);
     }
 
-    if (enableSpilling) {
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-          reclaimerStats_);
-    } else {
-      VELOX_ASSERT_THROW(
-          op->reclaim(
-              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-              reclaimerStats_),
-          "");
-    }
+    VELOX_ASSERT_THROW(
+        op->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+            reclaimerStats_),
+        "");
 
     driverWait.notify();
     Task::resume(task);
@@ -958,27 +926,26 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringAllocation) {
     ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 0);
     OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
   }
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{1});
+  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{0});
 }
 
 DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringOutputProcessing) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
+  const int32_t numBatches = 200;
   std::vector<RowVectorPtr> batches;
   for (int32_t i = 0; i < numBatches; ++i) {
     batches.push_back(fuzzer.fuzzRow(rowType));
   }
 
-  std::vector<bool> enableSpillings = {false, true};
+  const std::vector<bool> enableSpillings = {false, true};
   for (const auto enableSpilling : enableSpillings) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
-    auto tempDirectory = exec::test::TempDirectoryPath::create();
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes));
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -1027,9 +994,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringOutputProcessing) {
                 .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
                 .planNode())
             .queryCtx(queryCtx)
-            .spillDirectory(tempDirectory->path)
-            .config(core::QueryConfig::kSpillEnabled, "true")
-            .config(core::QueryConfig::kOrderBySpillEnabled, "true")
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kOrderBySpillEnabled, true)
             .maxDrivers(1)
             .assertResults(expectedResult);
       } else {
@@ -1058,41 +1025,41 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringOutputProcessing) {
 
     if (enableSpilling) {
       ASSERT_GT(reclaimableBytes, 0);
-      const auto usedMemoryBytes = op->pool()->currentBytes();
-      op->reclaim(
-          folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-          reclaimerStats_);
-      // No reclaim as the operator has started output processing.
-      ASSERT_EQ(usedMemoryBytes, op->pool()->currentBytes());
+      reclaimerStats_.reset();
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        op->pool()->reclaim(reclaimableBytes, 0, reclaimerStats_);
+      }
+      ASSERT_GT(reclaimerStats_.reclaimedBytes, 0);
+      ASSERT_LE(reclaimerStats_.reclaimedBytes, reclaimableBytes);
+      ASSERT_GT(reclaimerStats_.reclaimExecTimeUs, 0);
     } else {
       ASSERT_EQ(reclaimableBytes, 0);
-      VELOX_ASSERT_THROW(
-          op->reclaim(
-              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
-              reclaimerStats_),
-          "");
+      {
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        VELOX_ASSERT_THROW(
+            op->reclaim(
+                folly::Random::oneIn(2) ? 0 : folly::Random::rand32(rng_),
+                reclaimerStats_),
+            "");
+      }
     }
 
     Task::resume(task);
     taskThread.join();
 
     auto stats = task->taskStats().pipelineStats;
-    ASSERT_EQ(stats[0].operatorStats[1].spilledBytes, 0);
-    ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 0);
+    ASSERT_TRUE(!enableSpilling || stats[0].operatorStats[1].spilledBytes > 0);
+    ASSERT_TRUE(
+        !enableSpilling || stats[0].operatorStats[1].spilledPartitions > 0);
     OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
   }
-  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{1});
+  ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 0);
 }
 
 DEBUG_ONLY_TEST_F(OrderByTest, abortDuringOutputProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
+  const auto batches = makeVectors(rowType, 10, 128);
 
   struct {
     bool abortFromRootMemoryPool;
@@ -1108,85 +1075,58 @@ DEBUG_ONLY_TEST_F(OrderByTest, abortDuringOutputProcessing) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
                 .values(batches)
                 .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
                 .planNode())
-            .queryCtx(queryCtx)
             .copyResults(pool_.get());
 
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
-
-    std::atomic<bool> injectOnce{true};
-    Operator* op;
+    std::atomic_bool injectOnce{true};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::noMoreInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "OrderBy") {
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "OrderBy") {
             return;
           }
-          op = testOp;
           if (!injectOnce.exchange(false)) {
             return;
           }
+          ASSERT_GT(op->pool()->usedBytes(), 0);
           auto* driver = op->testingOperatorCtx()->driver();
           ASSERT_EQ(
               driver->task()->enterSuspended(driver->state()),
               StopReason::kNone);
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          // We can't directly reclaim memory from this hash build operator as
+          // its driver thread is running and in suspension state.
+          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
           ASSERT_EQ(
               driver->task()->leaveSuspended(driver->state()),
               StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
           VELOX_MEM_POOL_ABORTED("Memory pool aborted");
         })));
 
-    std::thread taskThread([&]() {
-      VELOX_ASSERT_THROW(
-          AssertQueryBuilder(
-              PlanBuilder()
-                  .values(batches)
-                  .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                  .planNode())
-              .queryCtx(queryCtx)
-              .maxDrivers(1)
-              .assertResults(expectedResult),
-          "");
-    });
-
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->testingOperatorCtx()->task();
-    testData.abortFromRootMemoryPool ? abortPool(queryCtx->pool())
-                                     : abortPool(op->pool());
-    ASSERT_TRUE(op->pool()->aborted());
-    ASSERT_TRUE(queryCtx->pool()->aborted());
-    ASSERT_EQ(queryCtx->pool()->currentBytes(), 0);
-    driverWait.notify();
-    taskThread.join();
-    task.reset();
+    VELOX_ASSERT_THROW(
+        AssertQueryBuilder(
+            PlanBuilder()
+                .values(batches)
+                .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
+                .planNode())
+            .maxDrivers(1)
+            .assertResults(expectedResult),
+        "Manual MemoryPool Abortion");
     waitForAllTasksToBeDeleted();
   }
 }
 
 DEBUG_ONLY_TEST_F(OrderByTest, abortDuringInputgProcessing) {
-  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   auto rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()});
-  VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
-  const int32_t numBatches = 10;
-  std::vector<RowVectorPtr> batches;
-  for (int32_t i = 0; i < numBatches; ++i) {
-    batches.push_back(fuzzer.fuzzRow(rowType));
-  }
+  const auto batches = makeVectors(rowType, 10, 128);
 
   struct {
     bool abortFromRootMemoryPool;
@@ -1202,74 +1142,227 @@ DEBUG_ONLY_TEST_F(OrderByTest, abortDuringInputgProcessing) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
-    queryCtx->testingOverrideMemoryPool(
-        memory::defaultMemoryManager().addRootPool(
-            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
                 .values(batches)
                 .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
                 .planNode())
-            .queryCtx(queryCtx)
             .copyResults(pool_.get());
 
-    folly::EventCount driverWait;
-    auto driverWaitKey = driverWait.prepareWait();
-    folly::EventCount testWait;
-    auto testWaitKey = testWait.prepareWait();
-
-    std::atomic<int> numInputs{0};
-    Operator* op;
+    std::atomic_int numInputs{0};
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::Driver::runInternal::addInput",
-        std::function<void(Operator*)>(([&](Operator* testOp) {
-          if (testOp->operatorType() != "OrderBy") {
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "OrderBy") {
             return;
           }
-          op = testOp;
-          ++numInputs;
-          if (numInputs != 2) {
+          if (++numInputs != 2) {
             return;
           }
           auto* driver = op->testingOperatorCtx()->driver();
           ASSERT_EQ(
               driver->task()->enterSuspended(driver->state()),
               StopReason::kNone);
-          testWait.notify();
-          driverWait.wait(driverWaitKey);
+          testData.abortFromRootMemoryPool ? abortPool(op->pool()->root())
+                                           : abortPool(op->pool());
+          // We can't directly reclaim memory from this hash build operator as
+          // its driver thread is running and in suspension state.
+          ASSERT_GT(op->pool()->root()->usedBytes(), 0);
           ASSERT_EQ(
               driver->task()->leaveSuspended(driver->state()),
               StopReason::kAlreadyTerminated);
+          ASSERT_TRUE(op->pool()->aborted());
+          ASSERT_TRUE(op->pool()->root()->aborted());
           // Simulate the memory abort by memory arbitrator.
           VELOX_MEM_POOL_ABORTED("Memory pool aborted");
         })));
 
-    std::thread taskThread([&]() {
-      VELOX_ASSERT_THROW(
-          AssertQueryBuilder(
-              PlanBuilder()
-                  .values(batches)
-                  .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
-                  .planNode())
-              .queryCtx(queryCtx)
-              .maxDrivers(1)
-              .assertResults(expectedResult),
-          "");
-    });
-
-    testWait.wait(testWaitKey);
-    ASSERT_TRUE(op != nullptr);
-    auto task = op->testingOperatorCtx()->task();
-    testData.abortFromRootMemoryPool ? abortPool(queryCtx->pool())
-                                     : abortPool(op->pool());
-    ASSERT_TRUE(op->pool()->aborted());
-    ASSERT_TRUE(queryCtx->pool()->aborted());
-    ASSERT_EQ(queryCtx->pool()->currentBytes(), 0);
-    driverWait.notify();
-    taskThread.join();
-    task.reset();
+    VELOX_ASSERT_THROW(
+        AssertQueryBuilder(
+            PlanBuilder()
+                .values(batches)
+                .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
+                .planNode())
+            .maxDrivers(1)
+            .assertResults(expectedResult),
+        "Manual MemoryPool Abortion");
     waitForAllTasksToBeDeleted();
   }
 }
+
+DEBUG_ONLY_TEST_F(OrderByTest, spillWithNoMoreOutput) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto vectors = createVectors(rowType, 1024, 4 << 20);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId orderNodeId;
+  const auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(vectors)
+          .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
+          .capturePlanNodeId(orderNodeId)
+          .planNode();
+
+  const auto expectedResult = AssertQueryBuilder(plan).copyResults(pool_.get());
+
+  std::atomic_int numOutputs{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "OrderBy") {
+          return;
+        }
+        if (!op->testingNoMoreInput()) {
+          return;
+        }
+        if (++numOutputs != 2) {
+          return;
+        }
+        ASSERT_TRUE(!op->isFinished());
+        op->reclaim(1'000'000'000, reclaimerStats_);
+        ASSERT_EQ(reclaimerStats_.reclaimedBytes, 0);
+      })));
+
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto task =
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kOrderBySpillEnabled, true)
+          // Set output buffer size to extreme large to read all the
+          // output rows in one vector.
+          .config(QueryConfig::kPreferredOutputBatchRows, 1'000'000'000)
+          .config(QueryConfig::kMaxOutputBatchRows, 1'000'000'000)
+          .config(QueryConfig::kPreferredOutputBatchBytes, 1'000'000'000)
+          .config(QueryConfig::kMaxSpillBytes, 1)
+          .maxDrivers(1)
+          .assertResults(expectedResult);
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  auto& planStats = taskStats.at(orderNodeId);
+  ASSERT_EQ(planStats.spilledBytes, 0);
+  ASSERT_EQ(planStats.spilledRows, 0);
+  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+}
+
+TEST_F(OrderByTest, maxSpillBytes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto vectors = createVectors(rowType, 1024, 15 << 20);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId orderNodeId;
+  const auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(vectors)
+          .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
+          .capturePlanNodeId(orderNodeId)
+          .planNode();
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {16 << 20, true}, {0, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kOrderBySpillEnabled, true)
+          .config(QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find(
+              "Query exceeded per-query local spill limit of 16.00MB"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+  }
+}
+
+DEBUG_ONLY_TEST_F(OrderByTest, reclaimFromOrderBy) {
+  std::vector<RowVectorPtr> vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  std::atomic_int numInputs{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "OrderBy") {
+          return;
+        }
+        if (++numInputs != 5) {
+          return;
+        }
+        auto* driver = op->testingOperatorCtx()->driver();
+        SuspendedSection suspendedSection(driver);
+        memory::testingRunArbitration();
+      })));
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  core::PlanNodeId orderById;
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kOrderBySpillEnabled, true)
+          .plan(PlanBuilder()
+                    .values(vectors)
+                    .orderBy({"c0 ASC NULLS LAST"}, false)
+                    .capturePlanNodeId(orderById)
+                    .planNode())
+          .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  auto& planStats = taskStats.at(orderById);
+  ASSERT_GT(planStats.spilledBytes, 0);
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(OrderByTest, reclaimFromEmptyOrderBy) {
+  const std::vector<RowVectorPtr> vectors =
+      createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  std::atomic<bool> injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "OrderBy") {
+          return;
+        }
+
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        testingRunArbitration(op->pool());
+      })));
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto task =
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kOrderBySpillEnabled, true)
+          .plan(PlanBuilder()
+                    .values(vectors)
+                    .orderBy({"c0 ASC NULLS LAST"}, false)
+                    .planNode())
+          .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
+  // Verify no spill has been triggered.
+  const auto stats = task->taskStats().pipelineStats;
+  ASSERT_EQ(stats[0].operatorStats[1].spilledBytes, 0);
+  ASSERT_EQ(stats[0].operatorStats[1].spilledPartitions, 0);
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/OutputBufferManagerTest.cpp b/velox/exec/tests/OutputBufferManagerTest.cpp
new file mode 100644
index 0000000000000..ecf438eb13938
--- /dev/null
+++ b/velox/exec/tests/OutputBufferManagerTest.cpp
@@ -0,0 +1,1555 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/OutputBufferManager.h"
+#include <gtest/gtest.h>
+#include "folly/experimental/EventCount.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/Task.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::core;
+
+using facebook::velox::test::BatchMaker;
+
+class OutputBufferManagerTest : public testing::Test {
+ protected:
+  OutputBufferManagerTest() {
+    std::vector<std::string> names = {"c0", "c1"};
+    std::vector<TypePtr> types = {BIGINT(), VARCHAR()};
+    rowType_ = ROW(std::move(names), std::move(types));
+  }
+
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool();
+    bufferManager_ = OutputBufferManager::getInstance().lock();
+    if (!isRegisteredVectorSerde()) {
+      facebook::velox::serializer::presto::PrestoVectorSerde::
+          registerVectorSerde();
+      bufferManager_->setListenerFactory([]() {
+        return std::make_unique<
+            serializer::presto::PrestoOutputStreamListener>();
+      });
+    }
+  }
+
+  std::shared_ptr<Task> initializeTask(
+      const std::string& taskId,
+      const RowTypePtr& rowType,
+      PartitionedOutputNode::Kind kind,
+      int numDestinations,
+      int numDrivers,
+      int maxOutputBufferSize = 0) {
+    bufferManager_->removeTask(taskId);
+
+    auto planFragment = exec::test::PlanBuilder()
+                            .values({std::dynamic_pointer_cast<RowVector>(
+                                BatchMaker::createBatch(rowType, 100, *pool_))})
+                            .planFragment();
+    std::unordered_map<std::string, std::string> configSettings;
+    if (maxOutputBufferSize != 0) {
+      configSettings[core::QueryConfig::kMaxPartitionedOutputBufferSize] =
+          std::to_string(maxOutputBufferSize);
+    }
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(), core::QueryConfig(std::move(configSettings)));
+
+    auto task = Task::create(
+        taskId,
+        std::move(planFragment),
+        0,
+        std::move(queryCtx),
+        Task::ExecutionMode::kParallel);
+
+    bufferManager_->initializeTask(task, kind, numDestinations, numDrivers);
+    return task;
+  }
+
+  std::unique_ptr<SerializedPage> makeSerializedPage(
+      RowTypePtr rowType,
+      vector_size_t size) {
+    auto vector = std::dynamic_pointer_cast<RowVector>(
+        BatchMaker::createBatch(rowType, size, *pool_));
+    return toSerializedPage(vector);
+  }
+
+  std::unique_ptr<SerializedPage> toSerializedPage(VectorPtr vector) {
+    auto data = std::make_unique<VectorStreamGroup>(pool_.get());
+    auto size = vector->size();
+    auto range = IndexRange{0, size};
+    data->createStreamTree(
+        std::dynamic_pointer_cast<const RowType>(vector->type()), size);
+    data->append(
+        std::dynamic_pointer_cast<RowVector>(vector), folly::Range(&range, 1));
+    auto listener = bufferManager_->newListener();
+    IOBufOutputStream stream(*pool_, listener.get(), data->size());
+    data->flush(&stream);
+    return std::make_unique<SerializedPage>(stream.getIOBuf(), nullptr, size);
+  }
+
+  void enqueue(
+      const std::string& taskId,
+      const RowTypePtr& rowType,
+      vector_size_t size,
+      bool expectedBlock = false) {
+    enqueue(taskId, 0, rowType, size);
+  }
+
+  // Returns the enqueued page byte size.
+  uint64_t enqueue(
+      const std::string& taskId,
+      int destination,
+      const RowTypePtr& rowType,
+      vector_size_t size,
+      bool expectedBlock = false) {
+    ContinueFuture future;
+    auto page = makeSerializedPage(rowType, size);
+    const uint64_t pageSize = page->size();
+    auto blocked =
+        bufferManager_->enqueue(taskId, destination, std::move(page), &future);
+    if (!expectedBlock) {
+      EXPECT_FALSE(blocked);
+    }
+    if (blocked) {
+      future.wait();
+    }
+    return pageSize;
+  }
+
+  OutputBuffer::Stats getStats(const std::string& taskId) {
+    const auto stats = bufferManager_->stats(taskId);
+    EXPECT_TRUE(stats.has_value());
+    return stats.value();
+  }
+
+  void noMoreData(const std::string& taskId) {
+    bufferManager_->noMoreData(taskId);
+  }
+
+  void fetch(
+      const std::string& taskId,
+      int destination,
+      int64_t sequence,
+      uint64_t maxBytes = 1024,
+      int expectedGroups = 1,
+      bool expectedEndMarker = false) {
+    bool receivedData = false;
+    ASSERT_TRUE(bufferManager_->getData(
+        taskId,
+        destination,
+        maxBytes,
+        sequence,
+        [destination,
+         sequence,
+         expectedGroups,
+         expectedEndMarker,
+         &receivedData](
+            std::vector<std::unique_ptr<folly::IOBuf>> pages,
+            int64_t inSequence,
+            std::vector<int64_t> /*remainingBytes*/) {
+          ASSERT_FALSE(receivedData) << "for destination " << destination;
+          ASSERT_EQ(pages.size(), expectedGroups)
+              << "for destination " << destination;
+          for (int i = 0; i < pages.size(); ++i) {
+            if (i == pages.size() - 1) {
+              ASSERT_EQ(expectedEndMarker, pages[i] == nullptr)
+                  << "for destination " << destination;
+            } else {
+              ASSERT_TRUE(pages[i] != nullptr)
+                  << "for destination " << destination;
+            }
+          }
+          ASSERT_EQ(inSequence, sequence) << "for destination " << destination;
+          receivedData = true;
+        },
+        [&]() {
+          // Verifies the active buffer check only applies for arbitrary output
+          // buffer.
+          const auto stats = bufferManager_->stats(taskId).value();
+          if (stats.kind == core::PartitionedOutputNode::Kind::kArbitrary) {
+            return true;
+          } else {
+            return false;
+          }
+        }));
+    ASSERT_TRUE(receivedData) << "for destination " << destination;
+  }
+
+  void fetchOne(
+      const std::string& taskId,
+      int destination,
+      int64_t sequence,
+      uint64_t maxBytes = 1024) {
+    fetch(taskId, destination, sequence, maxBytes, 1);
+  }
+
+  void
+  acknowledge(const std::string& taskId, int destination, int64_t sequence) {
+    bufferManager_->acknowledge(taskId, destination, sequence);
+  }
+
+  void
+  fetchOneAndAck(const std::string& taskId, int destination, int64_t sequence) {
+    fetchOne(taskId, destination, sequence);
+    acknowledge(taskId, destination, sequence + 1);
+  }
+
+  DataAvailableCallback
+  receiveEndMarker(int destination, int64_t sequence, bool& receivedEndMarker) {
+    return [destination, sequence, &receivedEndMarker](
+               std::vector<std::unique_ptr<folly::IOBuf>> pages,
+               int64_t inSequence,
+               std::vector<int64_t> remainingBytes) {
+      EXPECT_FALSE(receivedEndMarker) << "for destination " << destination;
+      EXPECT_EQ(pages.size(), 1) << "for destination " << destination;
+      EXPECT_TRUE(pages[0] == nullptr) << "for destination " << destination;
+      EXPECT_EQ(inSequence, sequence) << "for destination " << destination;
+      EXPECT_TRUE(remainingBytes.empty());
+      receivedEndMarker = true;
+    };
+  }
+
+  void
+  fetchEndMarker(const std::string& taskId, int destination, int64_t sequence) {
+    bool receivedData = false;
+    ASSERT_TRUE(bufferManager_->getData(
+        taskId,
+        destination,
+        std::numeric_limits<uint64_t>::max(),
+        sequence,
+        receiveEndMarker(destination, sequence, receivedData)));
+    EXPECT_TRUE(receivedData) << "for destination " << destination;
+    bufferManager_->deleteResults(taskId, destination);
+  }
+
+  void deleteResults(const std::string& taskId, int destination) {
+    bufferManager_->deleteResults(taskId, destination);
+  }
+
+  void registerForEndMarker(
+      const std::string& taskId,
+      int destination,
+      int64_t sequence,
+      bool& receivedEndMarker) {
+    receivedEndMarker = false;
+    ASSERT_TRUE(bufferManager_->getData(
+        taskId,
+        destination,
+        std::numeric_limits<uint64_t>::max(),
+        sequence,
+        receiveEndMarker(destination, sequence, receivedEndMarker)));
+    EXPECT_FALSE(receivedEndMarker) << "for destination " << destination;
+  }
+
+  DataAvailableCallback receiveData(
+      int destination,
+      int64_t sequence,
+      int expectedGroups,
+      bool& receivedData) {
+    receivedData = false;
+    return [destination, sequence, expectedGroups, &receivedData](
+               std::vector<std::unique_ptr<folly::IOBuf>> pages,
+               int64_t inSequence,
+               std::vector<int64_t> /*remainingBytes*/) {
+      EXPECT_FALSE(receivedData) << "for destination " << destination;
+      EXPECT_EQ(pages.size(), expectedGroups)
+          << "for destination " << destination;
+      for (int i = 0; i < expectedGroups; i++) {
+        EXPECT_TRUE(pages[i] != nullptr) << "for destination " << destination;
+      }
+      EXPECT_EQ(inSequence, sequence) << "for destination " << destination;
+      receivedData = true;
+    };
+  }
+
+  void registerForData(
+      const std::string& taskId,
+      int destination,
+      int64_t sequence,
+      int expectedGroups,
+      bool& receivedData) {
+    receivedData = false;
+    ASSERT_TRUE(bufferManager_->getData(
+        taskId,
+        destination,
+        1024,
+        sequence,
+        receiveData(destination, sequence, expectedGroups, receivedData)));
+    EXPECT_FALSE(receivedData) << "for destination " << destination;
+  }
+
+  void dataFetcher(
+      const std::string& taskId,
+      int destination,
+      int64_t& fetchedPages,
+      bool earlyTermination) {
+    folly::Random::DefaultGenerator rng;
+    rng.seed(destination);
+    int64_t nextSequence{0};
+    while (true) {
+      if (earlyTermination && folly::Random().oneIn(200)) {
+        bufferManager_->deleteResults(taskId, destination);
+        return;
+      }
+      const int64_t maxBytes = folly::Random().oneIn(4, rng) ? 32'000'000 : 1;
+      int64_t receivedSequence;
+      bool atEnd{false};
+      folly::EventCount dataWait;
+      auto dataWaitKey = dataWait.prepareWait();
+      bufferManager_->getData(
+          taskId,
+          destination,
+          maxBytes,
+          nextSequence,
+          [&](std::vector<std::unique_ptr<folly::IOBuf>> pages,
+              int64_t inSequence,
+              std::vector<int64_t> /*remainingBytes*/) {
+            ASSERT_EQ(inSequence, nextSequence);
+            for (int i = 0; i < pages.size(); ++i) {
+              if (pages[i] != nullptr) {
+                ++nextSequence;
+              } else {
+                ASSERT_EQ(i, pages.size() - 1);
+                atEnd = true;
+              }
+            }
+            dataWait.notify();
+          });
+      dataWait.wait(dataWaitKey);
+      if (atEnd) {
+        break;
+      }
+    }
+    bufferManager_->deleteResults(taskId, destination);
+    // out of order requests are allowed (fetch after delete)
+    {
+      struct Response {
+        std::vector<std::unique_ptr<folly::IOBuf>> pages;
+        int64_t sequence;
+        std::vector<int64_t> remainingBytes;
+      };
+      folly::Promise<Response> promise;
+      auto future = promise.getSemiFuture();
+      bufferManager_->getData(
+          taskId,
+          destination,
+          32'000'000,
+          nextSequence,
+          [&promise](
+              std::vector<std::unique_ptr<folly::IOBuf>> pages,
+              int64_t inSequence,
+              std::vector<int64_t> remainingBytes) {
+            promise.setValue(Response{
+                std::move(pages), inSequence, std::move(remainingBytes)});
+          });
+      future.wait();
+      ASSERT_TRUE(future.isReady());
+      auto& response = future.value();
+      ASSERT_EQ(response.sequence, nextSequence);
+      ASSERT_EQ(response.remainingBytes.size(), 0);
+      ASSERT_EQ(response.pages.size(), 1);
+      ASSERT_EQ(response.pages.at(0), nullptr);
+    }
+
+    fetchedPages = nextSequence;
+  }
+
+  // Define the states of output buffer for testing purpose.
+  enum class OutputBufferStatus {
+    kInitiated,
+    kRunning,
+    kBlocked,
+    kFinished,
+    kNoMoreProducer
+  };
+
+  void verifyOutputBuffer(
+      std::shared_ptr<Task> task,
+      OutputBufferStatus outputBufferStatus) {
+    TaskStats finishStats = task->taskStats();
+    const auto utilization = finishStats.outputBufferUtilization;
+    const auto overutilized = finishStats.outputBufferOverutilized;
+    if (outputBufferStatus == OutputBufferStatus::kInitiated ||
+        outputBufferStatus == OutputBufferStatus::kFinished) {
+      // zero utilization on a fresh new output buffer
+      ASSERT_EQ(utilization, 0);
+      ASSERT_FALSE(overutilized);
+    }
+    if (outputBufferStatus == OutputBufferStatus::kRunning) {
+      // non-blocking running, 0 < utilization < 1
+      ASSERT_GT(utilization, 0);
+      ASSERT_LT(utilization, 1);
+      if (utilization > 0.5) {
+        ASSERT_TRUE(overutilized);
+      } else {
+        ASSERT_FALSE(overutilized);
+      }
+    }
+    if (outputBufferStatus == OutputBufferStatus::kBlocked) {
+      // output buffer is over utilized and blocked
+      ASSERT_GT(utilization, 0.5);
+      ASSERT_TRUE(overutilized);
+    }
+    if (outputBufferStatus == OutputBufferStatus::kNoMoreProducer) {
+      // output buffer is over utilized if no more producer is set.
+      ASSERT_TRUE(overutilized);
+    }
+  }
+
+  std::shared_ptr<folly::Executor> executor_{
+      std::make_shared<folly::CPUThreadPoolExecutor>(
+          std::thread::hardware_concurrency())};
+  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
+  std::shared_ptr<OutputBufferManager> bufferManager_;
+  RowTypePtr rowType_;
+};
+
+struct TestParam {
+  PartitionedOutputNode::Kind kind;
+};
+
+class AllOutputBufferManagerTest
+    : public OutputBufferManagerTest,
+      public testing::WithParamInterface<PartitionedOutputNode::Kind> {
+ public:
+  AllOutputBufferManagerTest() : kind_(GetParam()) {}
+
+  static std::vector<PartitionedOutputNode::Kind> getTestParams() {
+    static std::vector<PartitionedOutputNode::Kind> params = {
+        PartitionedOutputNode::Kind::kBroadcast,
+        PartitionedOutputNode::Kind::kPartitioned,
+        PartitionedOutputNode::Kind::kArbitrary};
+    return params;
+  }
+
+ protected:
+  PartitionedOutputNode::Kind kind_;
+};
+
+TEST_F(OutputBufferManagerTest, arbitrayBuffer) {
+  {
+    ArbitraryBuffer buffer;
+    ASSERT_TRUE(buffer.empty());
+    ASSERT_FALSE(buffer.hasNoMoreData());
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[false]]");
+    VELOX_ASSERT_THROW(buffer.enqueue(nullptr), "Unexpected null page");
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[false]]");
+    buffer.noMoreData();
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[true]]");
+  }
+
+  {
+    ArbitraryBuffer buffer;
+    ASSERT_TRUE(buffer.empty());
+    ASSERT_FALSE(buffer.hasNoMoreData());
+    auto page1 = makeSerializedPage(rowType_, 100);
+    auto* rawPage1 = page1.get();
+    buffer.enqueue(std::move(page1));
+    ASSERT_FALSE(buffer.empty());
+    ASSERT_FALSE(buffer.hasNoMoreData());
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[1] NO MORE DATA[false]]");
+    auto page2 = makeSerializedPage(rowType_, 100);
+    auto* rawPage2 = page2.get();
+    buffer.enqueue(std::move(page2));
+    ASSERT_FALSE(buffer.empty());
+    ASSERT_FALSE(buffer.hasNoMoreData());
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[2] NO MORE DATA[false]]");
+
+    auto pages = buffer.getPages(1);
+    ASSERT_EQ(pages.size(), 1);
+    ASSERT_EQ(pages[0].get(), rawPage1);
+    auto page3 = makeSerializedPage(rowType_, 100);
+    auto* rawPage3 = page3.get();
+    buffer.enqueue(std::move(page3));
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[2] NO MORE DATA[false]]");
+    ASSERT_TRUE(buffer.getPages(0).empty());
+    buffer.noMoreData();
+    ASSERT_FALSE(buffer.empty());
+    ASSERT_TRUE(buffer.hasNoMoreData());
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[2] NO MORE DATA[true]]");
+    pages = buffer.getPages(1'000'000'000);
+    ASSERT_EQ(pages.size(), 3);
+    ASSERT_EQ(pages[0].get(), rawPage2);
+    ASSERT_EQ(pages[1].get(), rawPage3);
+    ASSERT_EQ(pages[2].get(), nullptr);
+    ASSERT_TRUE(buffer.empty());
+    ASSERT_TRUE(buffer.hasNoMoreData());
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[true]]");
+    auto page4 = makeSerializedPage(rowType_, 100);
+    VELOX_ASSERT_THROW(
+        buffer.enqueue(std::move(page4)),
+        "Arbitrary buffer has set no more data marker");
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[true]]");
+    buffer.noMoreData();
+    pages = buffer.getPages(0);
+    ASSERT_EQ(pages.size(), 1);
+    ASSERT_FALSE(pages[0]);
+    // Verify the end marker is persistent.
+    for (int i = 0; i < 3; ++i) {
+      pages = buffer.getPages(100);
+      ASSERT_EQ(pages.size(), 1);
+      ASSERT_EQ(pages[0].get(), nullptr);
+    }
+  }
+}
+
+TEST_F(OutputBufferManagerTest, outputType) {
+  ASSERT_EQ(
+      PartitionedOutputNode::kindString(
+          PartitionedOutputNode::Kind::kPartitioned),
+      "PARTITIONED");
+  ASSERT_EQ(
+      PartitionedOutputNode::kindString(
+          PartitionedOutputNode::Kind::kArbitrary),
+      "ARBITRARY");
+  ASSERT_EQ(
+      PartitionedOutputNode::kindString(
+          PartitionedOutputNode::Kind::kBroadcast),
+      "BROADCAST");
+  ASSERT_EQ(
+      PartitionedOutputNode::kindString(
+          static_cast<PartitionedOutputNode::Kind>(100)),
+      "INVALID OUTPUT KIND 100");
+}
+
+TEST_F(OutputBufferManagerTest, destinationBuffer) {
+  {
+    ArbitraryBuffer buffer;
+    DestinationBuffer destinationBuffer;
+    destinationBuffer.loadData(&buffer, 0);
+    destinationBuffer.loadData(&buffer, 100);
+    std::atomic<bool> notified{false};
+    auto buffers = destinationBuffer.getData(
+        1'000'000,
+        0,
+        [&](std::vector<std::unique_ptr<folly::IOBuf>> buffers,
+            int64_t sequence,
+            std::vector<int64_t> remainingBytes) {
+          ASSERT_EQ(buffers.size(), 1);
+          ASSERT_TRUE(buffers[0].get() == nullptr);
+          ASSERT_EQ(sequence, 0);
+          ASSERT_TRUE(remainingBytes.empty());
+          notified = true;
+        },
+        nullptr);
+    ASSERT_FALSE(buffers.immediate);
+    ASSERT_TRUE(buffer.empty());
+    ASSERT_FALSE(buffer.hasNoMoreData());
+    ASSERT_FALSE(notified);
+    VELOX_ASSERT_THROW(destinationBuffer.maybeLoadData(&buffer), "");
+    buffer.noMoreData();
+    destinationBuffer.maybeLoadData(&buffer);
+    destinationBuffer.getAndClearNotify().notify();
+    ASSERT_TRUE(notified);
+  }
+
+  {
+    ArbitraryBuffer buffer;
+    int64_t expectedNumBytes{0};
+    for (int i = 0; i < 10; ++i) {
+      auto page = makeSerializedPage(rowType_, 100);
+      expectedNumBytes += page->size();
+      buffer.enqueue(std::move(page));
+    }
+    DestinationBuffer destinationBuffer;
+    destinationBuffer.loadData(&buffer, 1);
+    ASSERT_EQ(
+        buffer.toString(), "[ARBITRARY_BUFFER PAGES[9] NO MORE DATA[false]]");
+    std::atomic<bool> notified{false};
+    int64_t numBytes{0};
+    auto buffers = destinationBuffer.getData(
+        1'000'000'000,
+        0,
+        [&](std::vector<std::unique_ptr<folly::IOBuf>> /*unused*/,
+            int64_t /*unused*/,
+            std::vector<int64_t> /*remainingBytes*/) { notified = true; },
+        []() { return true; });
+    ASSERT_TRUE(buffers.immediate);
+    ASSERT_TRUE(buffers.remainingBytes.empty());
+    for (const auto& iobuf : buffers.data) {
+      numBytes += iobuf->length();
+    }
+    ASSERT_GT(numBytes, 0);
+    ASSERT_FALSE(notified);
+    {
+      auto result = destinationBuffer.getAndClearNotify();
+      ASSERT_EQ(result.callback, nullptr);
+      ASSERT_TRUE(result.data.empty());
+      ASSERT_EQ(result.sequence, 0);
+    }
+    auto pages = destinationBuffer.acknowledge(1, false);
+    ASSERT_EQ(pages.size(), 1);
+
+    buffers = destinationBuffer.getData(
+        1'000'000,
+        1,
+        [&](std::vector<std::unique_ptr<folly::IOBuf>> buffers,
+            int64_t sequence,
+            std::vector<int64_t> remainingBytes) {
+          ASSERT_EQ(sequence, 1);
+          ASSERT_EQ(buffers.size(), 9);
+          ASSERT_TRUE(remainingBytes.empty());
+          for (const auto& buffer : buffers) {
+            numBytes += buffer->length();
+          }
+          notified = true;
+        },
+        []() { return true; });
+    ASSERT_FALSE(buffers.immediate);
+    ASSERT_TRUE(buffers.data.empty());
+    ASSERT_FALSE(notified);
+
+    destinationBuffer.maybeLoadData(&buffer);
+    destinationBuffer.getAndClearNotify().notify();
+    ASSERT_TRUE(notified);
+    ASSERT_TRUE(buffer.empty());
+    ASSERT_FALSE(buffer.hasNoMoreData());
+    ASSERT_EQ(numBytes, expectedNumBytes);
+  }
+
+  auto noNotify = [](std::vector<std::unique_ptr<folly::IOBuf>> /*buffers*/,
+                     int64_t /*sequence*/,
+                     std::vector<int64_t> /*remainingBytes*/) { FAIL(); };
+
+  {
+    ArbitraryBuffer buffer;
+    for (int i = 0; i < 10; ++i) {
+      buffer.enqueue(makeSerializedPage(rowType_, 100));
+    }
+    DestinationBuffer destinationBuffer;
+    destinationBuffer.loadData(&buffer, 1e9);
+    ASSERT_TRUE(buffer.empty());
+    int64_t sequence = 0;
+
+    auto buffers =
+        destinationBuffer.getData(1, sequence, noNotify, [] { return true; });
+    ASSERT_TRUE(buffers.immediate);
+    ASSERT_EQ(buffers.data.size(), 1);
+    ASSERT_GT(buffers.data[0]->length(), 0);
+    ASSERT_EQ(buffers.remainingBytes.size(), 9);
+    ++sequence;
+    ASSERT_EQ(destinationBuffer.acknowledge(sequence, false).size(), 1);
+
+    auto bytes = buffers.remainingBytes[0];
+    buffers = destinationBuffer.getData(
+        bytes, sequence, noNotify, [] { return true; });
+    ASSERT_TRUE(buffers.immediate);
+    ASSERT_EQ(buffers.data.size(), 1);
+    ASSERT_EQ(buffers.data[0]->length(), bytes);
+    ASSERT_EQ(buffers.remainingBytes.size(), 8);
+    ++sequence;
+    ASSERT_EQ(destinationBuffer.acknowledge(sequence, false).size(), 1);
+
+    bytes = buffers.remainingBytes[0];
+    auto bytes2 = buffers.remainingBytes[1];
+    buffers = destinationBuffer.getData(
+        bytes + 1, sequence, noNotify, [] { return true; });
+    ASSERT_TRUE(buffers.immediate);
+    ASSERT_EQ(buffers.data.size(), 2);
+    ASSERT_EQ(buffers.data[0]->length(), bytes);
+    ASSERT_EQ(buffers.data[1]->length(), bytes2);
+    ASSERT_EQ(buffers.remainingBytes.size(), 6);
+    sequence += 2;
+    ASSERT_EQ(destinationBuffer.acknowledge(sequence, false).size(), 2);
+
+    bytes = std::accumulate(
+        buffers.remainingBytes.begin(), buffers.remainingBytes.end(), 0ll);
+    buffers = destinationBuffer.getData(
+        bytes, sequence, noNotify, [] { return true; });
+    ASSERT_TRUE(buffers.immediate);
+    ASSERT_EQ(buffers.data.size(), 6);
+    ASSERT_EQ(buffers.remainingBytes.size(), 0);
+    sequence += 6;
+    ASSERT_EQ(destinationBuffer.acknowledge(sequence, false).size(), 6);
+
+    bool notified = false;
+    buffers = destinationBuffer.getData(
+        1,
+        sequence,
+        [&](std::vector<std::unique_ptr<folly::IOBuf>> buffers,
+            int64_t sequence2,
+            std::vector<int64_t> remainingBytes) {
+          ASSERT_EQ(buffers.size(), 1);
+          ASSERT_TRUE(buffers[0]);
+          ASSERT_EQ(sequence2, sequence);
+          ASSERT_TRUE(remainingBytes.empty());
+          notified = true;
+        },
+        [] { return true; });
+    ASSERT_FALSE(buffers.immediate);
+    ASSERT_FALSE(notified);
+    for (int i = 0; i < 10; ++i) {
+      buffer.enqueue(makeSerializedPage(rowType_, 100));
+    }
+    destinationBuffer.maybeLoadData(&buffer);
+    destinationBuffer.getAndClearNotify().notify();
+    ASSERT_TRUE(notified);
+  }
+
+  {
+    ArbitraryBuffer buffer;
+    for (int i = 0; i < 10; ++i) {
+      buffer.enqueue(makeSerializedPage(rowType_, 100));
+    }
+    DestinationBuffer destinationBuffer;
+    auto buffers =
+        destinationBuffer.getData(1, 0, noNotify, [] { return true; }, &buffer);
+    ASSERT_TRUE(buffers.immediate);
+    ASSERT_EQ(buffers.data.size(), 1);
+    ASSERT_GT(buffers.data[0]->length(), 0);
+    ASSERT_EQ(buffers.remainingBytes.size(), 9);
+  }
+}
+
+TEST_F(OutputBufferManagerTest, basicPartitioned) {
+  vector_size_t size = 100;
+  std::string taskId = "t0";
+  auto task = initializeTask(
+      taskId, rowType_, PartitionedOutputNode::Kind::kPartitioned, 5, 1);
+  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
+
+  // Duplicateb update buffers with the same settings are allowed and ignored.
+  ASSERT_TRUE(bufferManager_->updateOutputBuffers(taskId, 5, true));
+  ASSERT_FALSE(bufferManager_->isFinished(taskId));
+  // Partitioned output buffer doesn't allow to update with different number of
+  // output buffers once created.
+  VELOX_ASSERT_THROW(
+      bufferManager_->updateOutputBuffers(taskId, 5 + 1, true), "");
+  // Partitioned output buffer doesn't expect more output buffers once created.
+  VELOX_ASSERT_THROW(bufferManager_->updateOutputBuffers(taskId, 5, false), "");
+  VELOX_ASSERT_THROW(
+      bufferManager_->updateOutputBuffers(taskId, 5 - 1, true), "");
+  VELOX_ASSERT_THROW(
+      bufferManager_->updateOutputBuffers(taskId, 5 - 1, false), "");
+
+  // - enqueue one group per destination
+  // - fetch and ask one group per destination
+  // - enqueue one more group for destinations 0-2
+  // - fetch and ask one group for destinations 0-2
+  // - register end-marker callback for destination 3 and data callback for 4
+  // - enqueue data for 4 and assert callback was called
+  // - enqueue end marker for all destinations
+  // - assert callback was called for destination 3
+  // - fetch end markers for destinations 0-2 and 4
+
+  for (int destination = 0; destination < 5; ++destination) {
+    enqueue(taskId, destination, rowType_, size);
+  }
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  for (int destination = 0; destination < 5; destination++) {
+    fetchOneAndAck(taskId, destination, 0);
+    // Try to re-fetch already ack-ed data - should fail
+    EXPECT_THROW(fetchOne(taskId, destination, 0), std::exception);
+  }
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  for (int destination = 0; destination < 3; destination++) {
+    enqueue(taskId, destination, rowType_, size);
+  }
+
+  for (int destination = 0; destination < 3; destination++) {
+    fetchOneAndAck(taskId, destination, 1);
+  }
+
+  // destinations 0-2 received and ack-ed 2 groups each
+  // destinations 3-4 received and ack-ed 1 group each
+
+  bool receivedEndMarker3;
+  registerForEndMarker(taskId, 3, 1, receivedEndMarker3);
+
+  bool receivedData4;
+  registerForData(taskId, 4, 1, 1, receivedData4);
+
+  enqueue(taskId, 4, rowType_, size);
+  EXPECT_TRUE(receivedData4);
+
+  noMoreData(taskId);
+  EXPECT_TRUE(receivedEndMarker3);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  for (int destination = 0; destination < 3; destination++) {
+    fetchEndMarker(taskId, destination, 2);
+  }
+  EXPECT_TRUE(task->isRunning());
+  verifyOutputBuffer(task, OutputBufferStatus::kNoMoreProducer);
+
+  deleteResults(taskId, 3);
+  fetchEndMarker(taskId, 4, 2);
+  bufferManager_->removeTask(taskId);
+  EXPECT_TRUE(task->isFinished());
+}
+
+TEST_F(OutputBufferManagerTest, basicBroadcast) {
+  vector_size_t size = 100;
+
+  std::string taskId = "t0";
+  auto task = initializeTask(
+      taskId, rowType_, PartitionedOutputNode::Kind::kBroadcast, 5, 1);
+  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
+  VELOX_ASSERT_THROW(enqueue(taskId, 1, rowType_, size), "Bad destination 1");
+
+  enqueue(taskId, rowType_, size);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  for (int destination = 0; destination < 5; destination++) {
+    fetchOneAndAck(taskId, destination, 0);
+    // Try to re-fetch already ack-ed data - should fail
+    EXPECT_THROW(fetchOne(taskId, destination, 0), std::exception);
+  }
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  enqueue(taskId, rowType_, size);
+
+  for (int destination = 0; destination < 5; destination++) {
+    fetchOneAndAck(taskId, destination, 1);
+  }
+
+  bool receivedEndMarker3;
+  registerForEndMarker(taskId, 3, 2, receivedEndMarker3);
+
+  noMoreData(taskId);
+  EXPECT_TRUE(receivedEndMarker3);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  for (int destination = 0; destination < 5; ++destination) {
+    if (destination != 3) {
+      fetchEndMarker(taskId, destination, 2);
+    }
+  }
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+  bufferManager_->updateOutputBuffers(taskId, 5, false);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+  bufferManager_->updateOutputBuffers(taskId, 6, false);
+  verifyOutputBuffer(task, OutputBufferStatus::kNoMoreProducer);
+
+  // Fetch all for the new added destinations.
+  fetch(taskId, 5, 0, 1'000'000'000, 3, true);
+  VELOX_ASSERT_THROW(
+      acknowledge(taskId, 5, 4),
+      "(4 vs. 3) Ack received for a not yet produced item");
+  acknowledge(taskId, 5, 0);
+  acknowledge(taskId, 5, 1);
+  acknowledge(taskId, 5, 2);
+  acknowledge(taskId, 5, 3);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+  deleteResults(taskId, 5);
+  fetch(taskId, 5, 0, 1'000'000'000, 1, true);
+
+  bufferManager_->updateOutputBuffers(taskId, 7, true);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+  fetch(taskId, 6, 0, 1'000'000'000, 3, true);
+  acknowledge(taskId, 6, 2);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+  deleteResults(taskId, 6);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  EXPECT_TRUE(task->isRunning());
+  deleteResults(taskId, 3);
+  EXPECT_TRUE(bufferManager_->isFinished(taskId));
+  bufferManager_->removeTask(taskId);
+  EXPECT_TRUE(task->isFinished());
+}
+
+TEST_F(OutputBufferManagerTest, basicArbitrary) {
+  const vector_size_t size = 100;
+  int numDestinations = 5;
+  const std::string taskId = "t0";
+  auto task = initializeTask(
+      taskId, rowType_, PartitionedOutputNode::Kind::kArbitrary, 5, 1);
+  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
+
+  VELOX_ASSERT_THROW(
+      enqueue(taskId, 1, rowType_, size), "(1 vs. 0) Bad destination 1");
+
+  for (int i = 0; i < numDestinations; ++i) {
+    enqueue(taskId, rowType_, size);
+  }
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  std::unordered_map<int, int> ackedSeqbyDestination;
+
+  for (int destination = 0; destination < numDestinations; destination++) {
+    fetchOne(taskId, destination, 0, 1);
+    acknowledge(taskId, destination, 1);
+    ackedSeqbyDestination[destination] = 1;
+    // Try to re-fetch already ack-ed data - should fail
+    VELOX_ASSERT_THROW(fetchOne(taskId, destination, 0), "");
+  }
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+  verifyOutputBuffer(task, OutputBufferStatus::kRunning);
+
+  bool receivedData0{false};
+  bool receivedData1{false};
+  registerForData(taskId, 0, 1, 1, receivedData0);
+  registerForData(taskId, 1, 1, 1, receivedData1);
+  enqueue(taskId, rowType_, size);
+  enqueue(taskId, rowType_, size);
+  ASSERT_TRUE(receivedData0);
+  ASSERT_TRUE(receivedData1);
+  acknowledge(taskId, 0, 2);
+  ackedSeqbyDestination[0] = 2;
+  acknowledge(taskId, 1, 2);
+  ackedSeqbyDestination[1] = 2;
+  bool receivedData{false};
+  registerForData(taskId, 4, 1, 1, receivedData);
+  enqueue(taskId, rowType_, size);
+  enqueue(taskId, rowType_, size);
+  ASSERT_TRUE(receivedData);
+  acknowledge(taskId, 4, 2);
+  ackedSeqbyDestination[4] = 2;
+
+  bufferManager_->updateOutputBuffers(taskId, ++numDestinations, false);
+  bufferManager_->updateOutputBuffers(taskId, ++numDestinations, false);
+  fetchOneAndAck(taskId, numDestinations - 1, 0);
+  ackedSeqbyDestination[numDestinations - 1] = 1;
+
+  bufferManager_->updateOutputBuffers(taskId, numDestinations - 1, false);
+  VELOX_ASSERT_THROW(
+      fetchOneAndAck(taskId, numDestinations - 1, 0),
+      "(0 vs. 1) Get received for an already acknowledged item");
+
+  receivedData = false;
+  registerForData(taskId, numDestinations - 2, 0, 1, receivedData);
+  enqueue(taskId, rowType_, size);
+  ASSERT_TRUE(receivedData);
+  acknowledge(taskId, numDestinations - 2, 1);
+  ackedSeqbyDestination[numDestinations - 2] = 1;
+
+  noMoreData(taskId);
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+  EXPECT_TRUE(task->isRunning());
+  for (int i = 0; i < numDestinations; ++i) {
+    fetchEndMarker(taskId, i, ackedSeqbyDestination[i]);
+  }
+  EXPECT_TRUE(bufferManager_->isFinished(taskId));
+  EXPECT_FALSE(task->isRunning());
+
+  // NOTE: arbitrary buffer finish condition doesn't depend on no more
+  // (destination )buffers update flag.
+  bufferManager_->updateOutputBuffers(taskId, numDestinations, true);
+
+  EXPECT_TRUE(bufferManager_->isFinished(taskId));
+  bufferManager_->removeTask(taskId);
+  EXPECT_TRUE(task->isFinished());
+}
+
+TEST_F(OutputBufferManagerTest, inactiveDestinationBuffer) {
+  const vector_size_t dataSize = 1'000;
+  const int maxBytes = 1;
+  int numDestinations = 2;
+  const std::string taskId = "t0";
+  auto task = initializeTask(
+      taskId,
+      rowType_,
+      PartitionedOutputNode::Kind::kArbitrary,
+      numDestinations,
+      1);
+  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
+
+  std::vector<std::atomic_int> sequences(numDestinations);
+  std::vector<std::atomic_bool> actives(numDestinations);
+
+  auto notifyCb = [&](int destination,
+                      std::vector<std::unique_ptr<folly::IOBuf>> pages,
+                      int64_t sequence) {
+    ASSERT_EQ(sequence, sequences[destination])
+        << "for destination " << destination;
+    sequences[destination] += pages.size();
+  };
+
+  for (int destination = 0; destination < numDestinations; destination++) {
+    sequences[destination] = 0;
+    // Set the second destination to inactive state to prevent load data with
+    // notify set.
+    actives[destination] = destination == 0 ? true : false;
+    // Calls to getData to register notify as there is no data.
+    ASSERT_TRUE(bufferManager_->getData(
+        taskId,
+        /*destination=*/destination,
+        maxBytes,
+        /*sequence=*/sequences[destination],
+        [&, destination](
+            std::vector<std::unique_ptr<folly::IOBuf>> pages,
+            int64_t sequence,
+            std::vector<int64_t> /*remainingBytes*/) {
+          notifyCb(destination, std::move(pages), sequence);
+        },
+        [&, destination]() { return actives[destination].load(); }));
+  }
+
+  // Enqueue two pages.
+  enqueue(taskId, rowType_, dataSize);
+  enqueue(taskId, rowType_, dataSize);
+
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+  verifyOutputBuffer(task, OutputBufferStatus::kRunning);
+
+  // Expect the first destination to receive one page.
+  while (sequences[0] != 1) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1)); // NOLINT
+  }
+  ASSERT_EQ(sequences[0], 1);
+  ASSERT_EQ(sequences[1], 0);
+
+  auto stats = bufferManager_->stats(taskId).value();
+  ASSERT_GT(stats.bufferedBytes, 0);
+  for (int i = 0; i < numDestinations; ++i) {
+    if (i == 0) {
+      // The buffered data from the first destination is not acked yet.
+      ASSERT_GT(stats.buffersStats[i].bytesBuffered, 0) << i;
+    } else {
+      ASSERT_EQ(stats.buffersStats[i].bytesBuffered, 0) << i;
+    }
+  }
+
+  // Get the second page from the first destination buffer.
+  ASSERT_TRUE(bufferManager_->getData(
+      taskId,
+      /*destination=*/0,
+      maxBytes,
+      /*sequence=*/sequences[0],
+      [&](std::vector<std::unique_ptr<folly::IOBuf>> pages,
+          int64_t sequence,
+          std::vector<int64_t> /*remainingBytes*/) {
+        notifyCb(0, std::move(pages), sequence);
+      }));
+  ASSERT_EQ(sequences[0], 2);
+  ASSERT_EQ(sequences[1], 0);
+  acknowledge(taskId, 0, sequences[0]);
+
+  stats = bufferManager_->stats(taskId).value();
+  ASSERT_EQ(stats.bufferedBytes, 0);
+  for (int i = 0; i < numDestinations; ++i) {
+    ASSERT_EQ(stats.buffersStats[i].bytesBuffered, 0);
+  }
+
+  // Set the second destination buffer active to load data with notify when data
+  // gets queued.
+  actives[1] = true;
+  ASSERT_TRUE(bufferManager_->getData(
+      taskId,
+      /*destination=*/1,
+      maxBytes,
+      /*sequence=*/sequences[1],
+      [&](std::vector<std::unique_ptr<folly::IOBuf>> pages,
+          int64_t sequence,
+          std::vector<int64_t> /*remainingBytes*/) {
+        notifyCb(1, std::move(pages), sequence);
+      },
+      [&]() { return actives[1].load(); }));
+  ASSERT_EQ(sequences[0], 2);
+  ASSERT_EQ(sequences[1], 0);
+
+  // Enqueue one more page and expect the second destination buffer to receive
+  // it.
+  enqueue(taskId, rowType_, dataSize);
+
+  while (sequences[1] != 1) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1)); // NOLINT
+  }
+
+  ASSERT_EQ(sequences[0], 2);
+  ASSERT_EQ(sequences[1], 1);
+  acknowledge(taskId, 1, sequences[1]);
+
+  stats = bufferManager_->stats(taskId).value();
+  ASSERT_EQ(stats.bufferedBytes, 0);
+  for (int i = 0; i < numDestinations; ++i) {
+    ASSERT_EQ(stats.buffersStats[i].bytesBuffered, 0);
+  }
+
+  // Finish the test.
+  bufferManager_->updateOutputBuffers(taskId, numDestinations, true);
+  noMoreData(taskId);
+  for (int i = 0; i < numDestinations; ++i) {
+    fetchEndMarker(taskId, i, sequences[i]);
+  }
+  EXPECT_TRUE(bufferManager_->isFinished(taskId));
+  EXPECT_FALSE(task->isRunning());
+  bufferManager_->removeTask(taskId);
+  EXPECT_TRUE(task->isFinished());
+}
+
+TEST_F(OutputBufferManagerTest, broadcastWithDynamicAddedDestination) {
+  vector_size_t size = 100;
+
+  std::string taskId = "t0";
+  auto task = initializeTask(
+      taskId, rowType_, PartitionedOutputNode::Kind::kBroadcast, 5, 1);
+
+  const int numPages = 10;
+  for (int i = 0; i < numPages; ++i) {
+    enqueue(taskId, rowType_, size);
+  }
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  for (int i = 0; i < numPages; ++i) {
+    for (int destination = 0; destination < 5; ++destination) {
+      fetchOneAndAck(taskId, destination, i);
+    }
+  }
+
+  // Dynamic added destination.
+  fetch(taskId, 5, 0, 1'000'000'000, 10);
+  bufferManager_->updateOutputBuffers(taskId, 4, false);
+  bufferManager_->updateOutputBuffers(taskId, 6, false);
+  bufferManager_->updateOutputBuffers(taskId, 7, false);
+
+  fetch(taskId, 6, 0, 1'000'000'000, 10);
+  fetch(taskId, 7, 0, 1'000'000'000, 10);
+  fetch(taskId, 8, 0, 1'000'000'000, 10);
+
+  bufferManager_->updateOutputBuffers(taskId, 7, true);
+
+  VELOX_ASSERT_THROW(fetch(taskId, 10, 0, 1'000'000'000, 10), "");
+
+  ASSERT_FALSE(bufferManager_->isFinished(taskId));
+  noMoreData(taskId);
+  for (int i = 0; i < 9; ++i) {
+    fetchEndMarker(taskId, i, numPages);
+  }
+  ASSERT_TRUE(bufferManager_->isFinished(taskId));
+
+  bufferManager_->removeTask(taskId);
+  EXPECT_TRUE(task->isFinished());
+}
+
+TEST_F(OutputBufferManagerTest, arbitraryWithDynamicAddedDestination) {
+  const vector_size_t size = 100;
+  int numDestinations = 5;
+  const std::string taskId = "t0";
+  auto task = initializeTask(
+      taskId, rowType_, PartitionedOutputNode::Kind::kArbitrary, 5, 1);
+
+  for (int i = 0; i < numDestinations; ++i) {
+    enqueue(taskId, rowType_, size);
+  }
+  std::unordered_map<int, int> ackedSeqbyDestination;
+
+  for (int destination = 0; destination < 5; destination++) {
+    fetchOne(taskId, destination, 0, 1);
+    acknowledge(taskId, destination, 1);
+    ackedSeqbyDestination[destination] = 1;
+  }
+  EXPECT_FALSE(bufferManager_->isFinished(taskId));
+
+  // Dynamic added destination.
+  enqueue(taskId, rowType_, size);
+  fetchOneAndAck(taskId, numDestinations, 0);
+  ackedSeqbyDestination[numDestinations] = 1;
+
+  bufferManager_->updateOutputBuffers(taskId, numDestinations - 1, false);
+  bufferManager_->updateOutputBuffers(taskId, numDestinations, false);
+  bufferManager_->updateOutputBuffers(taskId, numDestinations + 1, false);
+
+  enqueue(taskId, rowType_, size);
+  fetchOneAndAck(taskId, numDestinations + 10, 0);
+  ackedSeqbyDestination[numDestinations + 10] = 1;
+
+  bufferManager_->updateOutputBuffers(taskId, numDestinations, true);
+
+  enqueue(taskId, rowType_, size);
+  fetchOneAndAck(taskId, numDestinations + 9, 0);
+  ackedSeqbyDestination[numDestinations + 9] = 1;
+
+  VELOX_ASSERT_THROW(
+      fetch(taskId, numDestinations + 20, 0, 1'000'000'000, 1), "");
+
+  ASSERT_FALSE(bufferManager_->isFinished(taskId));
+
+  noMoreData(taskId);
+  EXPECT_TRUE(task->isRunning());
+  for (int i = 0; i <= numDestinations + 10; ++i) {
+    fetchEndMarker(taskId, i, ackedSeqbyDestination[i]);
+  }
+  EXPECT_TRUE(bufferManager_->isFinished(taskId));
+
+  EXPECT_FALSE(task->isRunning());
+  EXPECT_TRUE(bufferManager_->isFinished(taskId));
+  bufferManager_->removeTask(taskId);
+  EXPECT_TRUE(task->isFinished());
+}
+
+TEST_P(AllOutputBufferManagerTest, maxBytes) {
+  const vector_size_t size = 100;
+  const std::string taskId = "t0";
+  initializeTask(taskId, rowType_, kind_, 1, 1);
+
+  enqueue(taskId, 0, rowType_, size);
+  enqueue(taskId, 0, rowType_, size);
+  enqueue(taskId, 0, rowType_, size);
+
+  // fetch up to 1Kb - 1 group
+  fetchOne(taskId, 0, 0);
+  // re-fetch with larger size limit - 2 groups
+  fetch(taskId, 0, 0, std::numeric_limits<int64_t>::max(), 3);
+  // re-fetch with 1Kb limit - 1 group
+  fetchOneAndAck(taskId, 0, 0);
+  fetchOneAndAck(taskId, 0, 1);
+  fetchOneAndAck(taskId, 0, 2);
+
+  if (kind_ != PartitionedOutputNode::Kind::kPartitioned) {
+    bufferManager_->updateOutputBuffers(taskId, 0, true);
+  }
+  noMoreData(taskId);
+  fetchEndMarker(taskId, 0, 3);
+  bufferManager_->removeTask(taskId);
+}
+
+TEST_P(AllOutputBufferManagerTest, outputBufferUtilization) {
+  const std::string taskId = std::to_string(rand());
+  const auto destination = 0;
+  auto task = initializeTask(taskId, rowType_, kind_, 1, 1);
+  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
+  if (kind_ == facebook::velox::core::PartitionedOutputNode::Kind::kBroadcast) {
+    bufferManager_->updateOutputBuffers(taskId, destination, true);
+  }
+
+  bool blocked = false;
+  do {
+    ContinueFuture future;
+    blocked = bufferManager_->enqueue(
+        taskId, destination, makeSerializedPage(rowType_, 100), &future);
+    if (!blocked) {
+      verifyOutputBuffer(task, OutputBufferStatus::kRunning);
+    }
+  } while (!blocked);
+
+  verifyOutputBuffer(task, OutputBufferStatus::kBlocked);
+
+  int group = 0;
+  do {
+    fetchOneAndAck(taskId, destination, group);
+    group++;
+  } while (task->taskStats().outputBufferOverutilized);
+  verifyOutputBuffer(task, OutputBufferStatus::kRunning);
+
+  ContinueFuture future;
+  bufferManager_->enqueue(
+      taskId, destination, makeSerializedPage(rowType_, 200), &future);
+  verifyOutputBuffer(task, OutputBufferStatus::kBlocked);
+  auto oldUtilization = task->taskStats().outputBufferUtilization;
+
+  noMoreData(taskId);
+  verifyOutputBuffer(task, OutputBufferStatus::kNoMoreProducer);
+  ASSERT_EQ(oldUtilization, task->taskStats().outputBufferUtilization);
+
+  deleteResults(taskId, destination);
+  bufferManager_->removeTask(taskId);
+  verifyOutputBuffer(task, OutputBufferStatus::kFinished);
+}
+
+TEST_P(AllOutputBufferManagerTest, outputBufferStats) {
+  const vector_size_t vectorSize = 100;
+  const std::string taskId = std::to_string(folly::Random::rand32());
+  initializeTask(taskId, rowType_, kind_, 1, 1);
+  {
+    const auto stats = getStats(taskId);
+    ASSERT_EQ(stats.kind, kind_);
+    ASSERT_FALSE(stats.noMoreData);
+    ASSERT_FALSE(stats.finished);
+    ASSERT_FALSE(stats.noMoreBuffers);
+    ASSERT_EQ(stats.totalPagesSent, 0);
+    ASSERT_EQ(stats.totalBytesSent, 0);
+    ASSERT_EQ(stats.totalRowsSent, 0);
+    ASSERT_EQ(stats.bufferedPages, 0);
+    ASSERT_EQ(stats.bufferedBytes, 0);
+  }
+
+  const int numPages = 3;
+  int totalNumRows = 0;
+  int totalBytes = 0;
+  for (int pageId = 0; pageId < numPages; ++pageId) {
+    // Enqueue pages and check stats of buffered data.
+    const auto pageBytes = enqueue(taskId, 0, rowType_, vectorSize);
+    totalBytes += pageBytes;
+    totalNumRows += vectorSize;
+    // Force ArbitraryBuffer to load data, otherwise the data would
+    // not be buffered in DestinationBuffer.
+    if (kind_ == PartitionedOutputNode::Kind::kArbitrary) {
+      fetchOne(taskId, 0, pageId);
+    }
+    const auto statsEnqueue = getStats(taskId);
+    ASSERT_EQ(statsEnqueue.buffersStats[0].pagesBuffered, 1);
+    ASSERT_EQ(statsEnqueue.buffersStats[0].rowsBuffered, vectorSize);
+    if (kind_ == core::PartitionedOutputNode::Kind::kBroadcast) {
+      ASSERT_EQ(statsEnqueue.bufferedPages, pageId + 1);
+      ASSERT_EQ(statsEnqueue.bufferedBytes, totalBytes);
+    } else {
+      ASSERT_EQ(statsEnqueue.bufferedPages, 1);
+      ASSERT_EQ(statsEnqueue.bufferedBytes, pageBytes);
+    }
+    ASSERT_EQ(statsEnqueue.totalBytesSent, totalBytes);
+    ASSERT_EQ(statsEnqueue.totalPagesSent, pageId + 1);
+    ASSERT_EQ(statsEnqueue.totalRowsSent, totalNumRows);
+
+    // Ack pages and check stats of sent data.
+    fetchOneAndAck(taskId, 0, pageId);
+    const auto statsAck = getStats(taskId);
+    ASSERT_EQ(statsAck.buffersStats[0].pagesSent, pageId + 1);
+    ASSERT_EQ(statsAck.buffersStats[0].rowsSent, totalNumRows);
+    ASSERT_EQ(statsAck.buffersStats[0].pagesBuffered, 0);
+    ASSERT_EQ(statsAck.buffersStats[0].rowsBuffered, 0);
+    if (kind_ == core::PartitionedOutputNode::Kind::kBroadcast) {
+      ASSERT_EQ(statsAck.bufferedPages, pageId + 1);
+      ASSERT_EQ(statsAck.bufferedBytes, totalBytes);
+    } else {
+      ASSERT_EQ(statsAck.bufferedPages, 0);
+      ASSERT_EQ(statsAck.bufferedBytes, 0);
+    }
+    ASSERT_EQ(statsAck.totalBytesSent, totalBytes);
+    ASSERT_EQ(statsAck.totalPagesSent, pageId + 1);
+    ASSERT_EQ(statsAck.totalRowsSent, totalNumRows);
+  }
+
+  // Set outputBuffer to NoMoreBuffers and check stats.
+  bufferManager_->updateOutputBuffers(taskId, 1, true);
+  const auto statsNoMoreBuffers = getStats(taskId);
+  ASSERT_TRUE(statsNoMoreBuffers.noMoreBuffers);
+  ASSERT_FALSE(statsNoMoreBuffers.noMoreData);
+  ASSERT_EQ(statsNoMoreBuffers.bufferedPages, 0);
+  ASSERT_EQ(statsNoMoreBuffers.bufferedBytes, 0);
+  ASSERT_EQ(statsNoMoreBuffers.totalBytesSent, totalBytes);
+  ASSERT_EQ(statsNoMoreBuffers.totalPagesSent, numPages);
+  ASSERT_EQ(statsNoMoreBuffers.totalRowsSent, totalNumRows);
+
+  // Set outputBuffer to noMoreData and check stats.
+  noMoreData(taskId);
+  const auto statsNoMoreData = getStats(taskId);
+  ASSERT_TRUE(statsNoMoreData.noMoreData);
+
+  // DeleteResults and check stats.
+  fetchEndMarker(taskId, 0, numPages);
+  deleteResults(taskId, 0);
+  const auto statsDeleteResults = getStats(taskId);
+  ASSERT_TRUE(statsDeleteResults.buffersStats[0].finished);
+  ASSERT_TRUE(statsDeleteResults.finished);
+  ASSERT_EQ(statsNoMoreBuffers.bufferedPages, 0);
+  ASSERT_EQ(statsNoMoreBuffers.bufferedBytes, 0);
+  ASSERT_EQ(statsNoMoreBuffers.totalBytesSent, totalBytes);
+  ASSERT_EQ(statsNoMoreBuffers.totalPagesSent, numPages);
+  ASSERT_EQ(statsNoMoreBuffers.totalRowsSent, totalNumRows);
+
+  // Remove task and check stats.
+  bufferManager_->removeTask(taskId);
+  ASSERT_FALSE(bufferManager_->stats(taskId).has_value());
+}
+
+TEST_F(OutputBufferManagerTest, outOfOrderAcks) {
+  const vector_size_t size = 100;
+  const std::string taskId = "t0";
+  auto task = initializeTask(
+      taskId, rowType_, PartitionedOutputNode::Kind::kPartitioned, 5, 1);
+
+  enqueue(taskId, 0, rowType_, size);
+  for (int i = 0; i < 10; i++) {
+    enqueue(taskId, 1, rowType_, size);
+  }
+
+  // fetch first 3 groups
+  fetchOne(taskId, 1, 0);
+  fetchOne(taskId, 1, 1);
+  fetchOne(taskId, 1, 2);
+
+  // send acks out of order: 3, 1, 2
+  acknowledge(taskId, 1, 3);
+  acknowledge(taskId, 1, 1);
+  acknowledge(taskId, 1, 2);
+
+  // fetch and ack remaining 7 groups
+  fetch(taskId, 1, 3, std::numeric_limits<uint64_t>::max(), 7);
+  acknowledge(taskId, 1, 10);
+
+  noMoreData(taskId);
+  fetchEndMarker(taskId, 1, 10);
+  task->requestCancel();
+  bufferManager_->removeTask(taskId);
+}
+
+TEST_F(OutputBufferManagerTest, errorInQueue) {
+  auto queue = std::make_shared<ExchangeQueue>();
+  queue->setError("Forced failure");
+
+  std::lock_guard<std::mutex> l(queue->mutex());
+  ContinueFuture future;
+  bool atEnd = false;
+  VELOX_ASSERT_THROW(
+      queue->dequeueLocked(1, &atEnd, &future), "Forced failure");
+}
+
+TEST_F(OutputBufferManagerTest, setQueueErrorWithPendingPages) {
+  const uint64_t kBufferSize = 128;
+  auto iobuf = folly::IOBuf::create(kBufferSize);
+  const std::string payload("setQueueErrorWithPendingPages");
+  size_t payloadSize = payload.size();
+  std::memcpy(iobuf->writableData(), payload.data(), payloadSize);
+  iobuf->append(payloadSize);
+
+  auto page = std::make_unique<SerializedPage>(std::move(iobuf));
+
+  auto queue = std::make_shared<ExchangeQueue>();
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(queue->mutex());
+    queue->enqueueLocked(std::move(page), promises);
+  }
+
+  queue->setError("Forced failure");
+
+  // Expect a throw on dequeue after the queue has been set error.
+  std::lock_guard<std::mutex> l(queue->mutex());
+  ContinueFuture future;
+  bool atEnd = false;
+  VELOX_ASSERT_THROW(
+      queue->dequeueLocked(1, &atEnd, &future), "Forced failure");
+}
+
+TEST_F(OutputBufferManagerTest, getDataOnFailedTask) {
+  // Fetching data on a task which was either never initialized in the buffer
+  // manager or was removed by a parallel thread must return false. The `notify`
+  // callback must not be registered.
+  ASSERT_FALSE(bufferManager_->getData(
+      "test.0.1",
+      1,
+      10,
+      1,
+      [](std::vector<std::unique_ptr<folly::IOBuf>> /*pages*/,
+         int64_t /*sequence*/,
+         std::vector<int64_t> /*remainingBytes*/) { VELOX_UNREACHABLE(); }));
+
+  // Missing tasks should be ignored in this call.
+  ASSERT_FALSE(bufferManager_->updateNumDrivers("test.0.2", 1));
+}
+
+TEST_F(OutputBufferManagerTest, updateBrodcastBufferOnFailedTask) {
+  // Updating broadcast buffer count in the buffer manager for a given unknown
+  // task must not throw exception, instead must return FALSE.
+  ASSERT_FALSE(bufferManager_->updateOutputBuffers(
+      "test.0.1", /* unknown task */
+      10,
+      false));
+}
+
+TEST_P(AllOutputBufferManagerTest, multiFetchers) {
+  const std::vector<bool> earlyTerminations = {false, true};
+  for (const auto earlyTermination : earlyTerminations) {
+    SCOPED_TRACE(fmt::format("earlyTermination {}", earlyTermination));
+
+    const vector_size_t size = 10;
+    const std::string taskId = "t0";
+    int numPartitions = 10;
+    int extendedNumPartitions = numPartitions / 2;
+    initializeTask(
+        taskId,
+        rowType_,
+        kind_,
+        numPartitions,
+        1,
+        kind_ == PartitionedOutputNode::Kind::kBroadcast ? 256 << 20 : 0);
+
+    std::vector<std::thread> threads;
+    std::vector<int64_t> fetchedPages(numPartitions + extendedNumPartitions, 0);
+    for (size_t i = 0; i < numPartitions; ++i) {
+      threads.emplace_back([&, i]() {
+        dataFetcher(taskId, i, fetchedPages.at(i), earlyTermination);
+      });
+    }
+    folly::Random::DefaultGenerator rng;
+    rng.seed(1234);
+    const int totalPages = 10'000;
+    std::vector<int64_t> producedPages(
+        numPartitions + extendedNumPartitions, 0);
+    for (int i = 0; i < totalPages; ++i) {
+      const int partition = kind_ == PartitionedOutputNode::Kind::kPartitioned
+          ? folly::Random().rand32(rng) % numPartitions
+          : 0;
+      try {
+        enqueue(taskId, partition, rowType_, size, true);
+      } catch (...) {
+        // Early termination might cause the task to fail early.
+        ASSERT_TRUE(earlyTermination);
+        break;
+      }
+      ++producedPages[partition];
+      if (folly::Random().oneIn(4)) {
+        std::this_thread::sleep_for(std::chrono::microseconds(5)); // NOLINT
+      }
+      if (i == 1000 && (kind_ != PartitionedOutputNode::Kind::kPartitioned)) {
+        bufferManager_->updateOutputBuffers(
+            taskId, numPartitions + extendedNumPartitions, false);
+        for (size_t i = numPartitions;
+             i < numPartitions + extendedNumPartitions;
+             ++i) {
+          threads.emplace_back([&, i]() {
+            dataFetcher(taskId, i, fetchedPages.at(i), earlyTermination);
+          });
+          fetchedPages[i] = 0;
+        }
+        bufferManager_->updateOutputBuffers(taskId, 0, true);
+      }
+    }
+    noMoreData(taskId);
+
+    for (int i = 0; i < threads.size(); ++i) {
+      threads[i].join();
+    }
+
+    if (!earlyTermination) {
+      if (kind_ == PartitionedOutputNode::Kind::kPartitioned) {
+        for (int i = 0; i < numPartitions; ++i) {
+          ASSERT_EQ(fetchedPages[i], producedPages[i]);
+        }
+      } else if (kind_ == PartitionedOutputNode::Kind::kBroadcast) {
+        int64_t totalFetchedPages{0};
+        for (const auto& pages : fetchedPages) {
+          totalFetchedPages += pages;
+        }
+        ASSERT_EQ(
+            totalPages * (numPartitions + extendedNumPartitions),
+            totalFetchedPages);
+      } else {
+        int64_t totalFetchedPages{0};
+        for (const auto& pages : fetchedPages) {
+          totalFetchedPages += pages;
+        }
+        ASSERT_EQ(totalPages, totalFetchedPages);
+      }
+    }
+    bufferManager_->removeTask(taskId);
+  }
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    AllOutputBufferManagerTestSuite,
+    AllOutputBufferManagerTest,
+    testing::ValuesIn(AllOutputBufferManagerTest::getTestParams()));
diff --git a/velox/exec/tests/ParseTypeSignatureTest.cpp b/velox/exec/tests/ParseTypeSignatureTest.cpp
deleted file mode 100644
index 5d65bcfcd54f6..0000000000000
--- a/velox/exec/tests/ParseTypeSignatureTest.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <gtest/gtest.h>
-
-#include "velox/expression/FunctionSignature.h"
-#include "velox/type/Type.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::exec;
-
-namespace {
-std::string roundTrip(const std::string& typeSignature) {
-  return parseTypeSignature(typeSignature).toString();
-}
-
-void testScalarType(const std::string& typeSignature) {
-  auto signature = parseTypeSignature(typeSignature);
-  ASSERT_EQ(signature.baseName(), typeSignature);
-  ASSERT_EQ(signature.parameters().size(), 0);
-}
-} // namespace
-
-TEST(ParseTypeSignatureTest, scalar) {
-  testScalarType("tinyint");
-  testScalarType("smallint");
-  testScalarType("integer");
-  testScalarType("bigint");
-  testScalarType("real");
-  testScalarType("double");
-  testScalarType("timestamp");
-}
-
-TEST(ParseTypeSignatureTest, array) {
-  auto signature = parseTypeSignature("array(bigint)");
-  ASSERT_EQ(signature.baseName(), "array");
-  ASSERT_EQ(signature.parameters().size(), 1);
-
-  auto param = signature.parameters()[0];
-  ASSERT_EQ(param.baseName(), "bigint");
-  ASSERT_EQ(param.parameters().size(), 0);
-}
-
-TEST(ParseTypeSignatureTest, map) {
-  auto signature = parseTypeSignature("map(bigint, double)");
-  ASSERT_EQ(signature.baseName(), "map");
-  ASSERT_EQ(signature.parameters().size(), 2);
-
-  auto key = signature.parameters()[0];
-  ASSERT_EQ(key.baseName(), "bigint");
-  ASSERT_EQ(key.parameters().size(), 0);
-
-  auto value = signature.parameters()[1];
-  ASSERT_EQ(value.baseName(), "double");
-  ASSERT_EQ(value.parameters().size(), 0);
-}
-
-TEST(ParseTypeSignatureTest, roundTrip) {
-  ASSERT_EQ(roundTrip("bigint"), "bigint");
-
-  ASSERT_EQ(roundTrip("array(T)"), "array(T)");
-  ASSERT_EQ(roundTrip("array(array(T))"), "array(array(T))");
-  ASSERT_EQ(roundTrip("array(row(K,V))"), "array(row(K,V))");
-
-  ASSERT_EQ(roundTrip("map(K,V)"), "map(K,V)");
-
-  ASSERT_EQ(roundTrip("function(S,R)"), "function(S,R)");
-
-  // Test a complex type as the second field in a row
-  ASSERT_EQ(
-      roundTrip("row(map(K,V),map(bigint,array(double)))"),
-      "row(map(K,V),map(bigint,array(double)))");
-}
-
-TEST(ParseTypeSignatureTest, invalidSignatures) {
-  EXPECT_THROW(parseTypeSignature("array(varchar"), VeloxRuntimeError);
-  EXPECT_THROW(parseTypeSignature("array(array(T)"), VeloxRuntimeError);
-}
diff --git a/velox/exec/tests/PartitionedOutputBufferManagerTest.cpp b/velox/exec/tests/PartitionedOutputBufferManagerTest.cpp
deleted file mode 100644
index 8c66eef219f9a..0000000000000
--- a/velox/exec/tests/PartitionedOutputBufferManagerTest.cpp
+++ /dev/null
@@ -1,1149 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/exec/PartitionedOutputBufferManager.h"
-#include <gtest/gtest.h>
-#include "folly/experimental/EventCount.h"
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/dwio/common/tests/utils/BatchMaker.h"
-#include "velox/exec/Task.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/serializers/PrestoSerializer.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::exec;
-using namespace facebook::velox::core;
-
-using facebook::velox::test::BatchMaker;
-
-class PartitionedOutputBufferManagerTest : public testing::Test {
- protected:
-  PartitionedOutputBufferManagerTest() {
-    std::vector<std::string> names = {"c0", "c1"};
-    std::vector<TypePtr> types = {BIGINT(), VARCHAR()};
-    rowType_ = ROW(std::move(names), std::move(types));
-  }
-
-  void SetUp() override {
-    pool_ = facebook::velox::memory::addDefaultLeafMemoryPool();
-    bufferManager_ = PartitionedOutputBufferManager::getInstance().lock();
-    if (!isRegisteredVectorSerde()) {
-      facebook::velox::serializer::presto::PrestoVectorSerde::
-          registerVectorSerde();
-      bufferManager_->setListenerFactory([]() {
-        return std::make_unique<
-            serializer::presto::PrestoOutputStreamListener>();
-      });
-    }
-  }
-
-  std::shared_ptr<Task> initializeTask(
-      const std::string& taskId,
-      const RowTypePtr& rowType,
-      PartitionedOutputNode::Kind kind,
-      int numDestinations,
-      int numDrivers,
-      int maxPartitionedOutputBufferSize = 0) {
-    bufferManager_->removeTask(taskId);
-
-    auto planFragment = exec::test::PlanBuilder()
-                            .values({std::dynamic_pointer_cast<RowVector>(
-                                BatchMaker::createBatch(rowType, 100, *pool_))})
-                            .planFragment();
-    std::unordered_map<std::string, std::string> configSettings;
-    if (maxPartitionedOutputBufferSize != 0) {
-      configSettings[core::QueryConfig::kMaxPartitionedOutputBufferSize] =
-          std::to_string(maxPartitionedOutputBufferSize);
-    }
-    auto queryCtx = std::make_shared<core::QueryCtx>(
-        executor_.get(), core::QueryConfig(std::move(configSettings)));
-
-    auto task =
-        Task::create(taskId, std::move(planFragment), 0, std::move(queryCtx));
-
-    bufferManager_->initializeTask(task, kind, numDestinations, numDrivers);
-    return task;
-  }
-
-  std::unique_ptr<SerializedPage> makeSerializedPage(
-      RowTypePtr rowType,
-      vector_size_t size) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType, size, *pool_));
-    return toSerializedPage(vector);
-  }
-
-  std::unique_ptr<SerializedPage> toSerializedPage(VectorPtr vector) {
-    auto data = std::make_unique<VectorStreamGroup>(pool_.get());
-    auto size = vector->size();
-    auto range = IndexRange{0, size};
-    data->createStreamTree(
-        std::dynamic_pointer_cast<const RowType>(vector->type()), size);
-    data->append(
-        std::dynamic_pointer_cast<RowVector>(vector), folly::Range(&range, 1));
-    auto listener = bufferManager_->newListener();
-    IOBufOutputStream stream(*pool_, listener.get(), data->size());
-    data->flush(&stream);
-    return std::make_unique<SerializedPage>(stream.getIOBuf());
-  }
-
-  void enqueue(
-      const std::string& taskId,
-      const RowTypePtr& rowType,
-      vector_size_t size,
-      bool expectedBlock = false) {
-    enqueue(taskId, 0, rowType, size);
-  }
-
-  void enqueue(
-      const std::string& taskId,
-      int destination,
-      const RowTypePtr& rowType,
-      vector_size_t size,
-      bool expectedBlock = false) {
-    ContinueFuture future;
-    auto blocked = bufferManager_->enqueue(
-        taskId, destination, makeSerializedPage(rowType, size), &future);
-    if (!expectedBlock) {
-      ASSERT_FALSE(blocked);
-    }
-    if (blocked) {
-      future.wait();
-    }
-  }
-
-  void noMoreData(const std::string& taskId) {
-    bufferManager_->noMoreData(taskId);
-  }
-
-  void fetch(
-      const std::string& taskId,
-      int destination,
-      int64_t sequence,
-      uint64_t maxBytes = 1024,
-      int expectedGroups = 1,
-      bool expectedEndMarker = false) {
-    bool receivedData = false;
-    ASSERT_TRUE(bufferManager_->getData(
-        taskId,
-        destination,
-        maxBytes,
-        sequence,
-        [destination,
-         sequence,
-         expectedGroups,
-         expectedEndMarker,
-         &receivedData](
-            std::vector<std::unique_ptr<folly::IOBuf>> pages,
-            int64_t inSequence) {
-          ASSERT_FALSE(receivedData) << "for destination " << destination;
-          ASSERT_EQ(pages.size(), expectedGroups)
-              << "for destination " << destination;
-          for (int i = 0; i < pages.size(); ++i) {
-            if (i == pages.size() - 1) {
-              ASSERT_EQ(expectedEndMarker, pages[i] == nullptr)
-                  << "for destination " << destination;
-            } else {
-              ASSERT_TRUE(pages[i] != nullptr)
-                  << "for destination " << destination;
-            }
-          }
-          ASSERT_EQ(inSequence, sequence) << "for destination " << destination;
-          receivedData = true;
-        }));
-    ASSERT_TRUE(receivedData) << "for destination " << destination;
-  }
-
-  void fetchOne(
-      const std::string& taskId,
-      int destination,
-      int64_t sequence,
-      uint64_t maxBytes = 1024) {
-    fetch(taskId, destination, sequence, maxBytes, 1);
-  }
-
-  void
-  acknowledge(const std::string& taskId, int destination, int64_t sequence) {
-    bufferManager_->acknowledge(taskId, destination, sequence);
-  }
-
-  void
-  fetchOneAndAck(const std::string& taskId, int destination, int64_t sequence) {
-    fetchOne(taskId, destination, sequence);
-    acknowledge(taskId, destination, sequence + 1);
-  }
-
-  DataAvailableCallback
-  receiveEndMarker(int destination, int64_t sequence, bool& receivedEndMarker) {
-    return [destination, sequence, &receivedEndMarker](
-               std::vector<std::unique_ptr<folly::IOBuf>> pages,
-               int64_t inSequence) {
-      EXPECT_FALSE(receivedEndMarker) << "for destination " << destination;
-      EXPECT_EQ(pages.size(), 1) << "for destination " << destination;
-      EXPECT_TRUE(pages[0] == nullptr) << "for destination " << destination;
-      EXPECT_EQ(inSequence, sequence) << "for destination " << destination;
-      receivedEndMarker = true;
-    };
-  }
-
-  void
-  fetchEndMarker(const std::string& taskId, int destination, int64_t sequence) {
-    bool receivedData = false;
-    ASSERT_TRUE(bufferManager_->getData(
-        taskId,
-        destination,
-        std::numeric_limits<uint64_t>::max(),
-        sequence,
-        receiveEndMarker(destination, sequence, receivedData)));
-    EXPECT_TRUE(receivedData) << "for destination " << destination;
-    bufferManager_->deleteResults(taskId, destination);
-  }
-
-  void deleteResults(const std::string& taskId, int destination) {
-    bufferManager_->deleteResults(taskId, destination);
-  }
-
-  void registerForEndMarker(
-      const std::string& taskId,
-      int destination,
-      int64_t sequence,
-      bool& receivedEndMarker) {
-    receivedEndMarker = false;
-    ASSERT_TRUE(bufferManager_->getData(
-        taskId,
-        destination,
-        std::numeric_limits<uint64_t>::max(),
-        sequence,
-        receiveEndMarker(destination, sequence, receivedEndMarker)));
-    EXPECT_FALSE(receivedEndMarker) << "for destination " << destination;
-  }
-
-  DataAvailableCallback receiveData(
-      int destination,
-      int64_t sequence,
-      int expectedGroups,
-      bool& receivedData) {
-    receivedData = false;
-    return [destination, sequence, expectedGroups, &receivedData](
-               std::vector<std::unique_ptr<folly::IOBuf>> pages,
-               int64_t inSequence) {
-      EXPECT_FALSE(receivedData) << "for destination " << destination;
-      EXPECT_EQ(pages.size(), expectedGroups)
-          << "for destination " << destination;
-      for (int i = 0; i < expectedGroups; i++) {
-        EXPECT_TRUE(pages[i] != nullptr) << "for destination " << destination;
-      }
-      EXPECT_EQ(inSequence, sequence) << "for destination " << destination;
-      receivedData = true;
-    };
-  }
-
-  void registerForData(
-      const std::string& taskId,
-      int destination,
-      int64_t sequence,
-      int expectedGroups,
-      bool& receivedData) {
-    receivedData = false;
-    ASSERT_TRUE(bufferManager_->getData(
-        taskId,
-        destination,
-        1024,
-        sequence,
-        receiveData(destination, sequence, expectedGroups, receivedData)));
-    EXPECT_FALSE(receivedData) << "for destination " << destination;
-  }
-
-  void dataFetcher(
-      const std::string& taskId,
-      int destination,
-      int64_t& fetchedPages,
-      bool earlyTermination) {
-    folly::Random::DefaultGenerator rng;
-    rng.seed(destination);
-    int64_t nextSequence{0};
-    while (true) {
-      if (earlyTermination && folly::Random().oneIn(200)) {
-        bufferManager_->deleteResults(taskId, destination);
-        return;
-      }
-      const int64_t maxBytes = folly::Random().oneIn(4, rng) ? 32'000'000 : 1;
-      int64_t receivedSequence;
-      bool atEnd{false};
-      folly::EventCount dataWait;
-      auto dataWaitKey = dataWait.prepareWait();
-      bufferManager_->getData(
-          taskId,
-          destination,
-          maxBytes,
-          nextSequence,
-          [&](std::vector<std::unique_ptr<folly::IOBuf>> pages,
-              int64_t inSequence) {
-            ASSERT_EQ(inSequence, nextSequence);
-            for (int i = 0; i < pages.size(); ++i) {
-              if (pages[i] != nullptr) {
-                ++nextSequence;
-              } else {
-                ASSERT_EQ(i, pages.size() - 1);
-                atEnd = true;
-              }
-            }
-            dataWait.notify();
-          });
-      dataWait.wait(dataWaitKey);
-      if (atEnd) {
-        break;
-      }
-    }
-    bufferManager_->deleteResults(taskId, destination);
-    fetchedPages = nextSequence;
-  }
-
-  // Define the states of output buffer for testing purpose.
-  enum class OutputBufferStatus {
-    kInitiated,
-    kRunning,
-    kBlocked,
-    kFinished,
-    kNoMoreProducer
-  };
-
-  void verifyOutputBuffer(
-      std::shared_ptr<Task> task,
-      OutputBufferStatus outputBufferStatus) {
-    TaskStats finishStats = task->taskStats();
-    if (outputBufferStatus == OutputBufferStatus::kInitiated ||
-        outputBufferStatus == OutputBufferStatus::kFinished) {
-      // zero utilization on a fresh new output buffer
-      ASSERT_EQ(finishStats.outputBufferUtilization, 0);
-      ASSERT_FALSE(finishStats.outputBufferOverutilized);
-    }
-    if (outputBufferStatus == OutputBufferStatus::kRunning) {
-      // non-blocking running, 0 < utilization < 1
-      ASSERT_GT(finishStats.outputBufferUtilization, 0);
-      ASSERT_LT(finishStats.outputBufferUtilization, 1);
-      ASSERT_FALSE(finishStats.outputBufferOverutilized);
-    }
-    if (outputBufferStatus == OutputBufferStatus::kBlocked) {
-      // output buffer is over utilized and blocked
-      ASSERT_GT(finishStats.outputBufferUtilization, 1);
-      ASSERT_TRUE(finishStats.outputBufferOverutilized);
-    }
-    if (outputBufferStatus == OutputBufferStatus::kNoMoreProducer) {
-      // output buffer is over utilized but since there is no more producer
-      // outputBufferOverutilized is not true (producers are not blocked)
-      ASSERT_GT(finishStats.outputBufferUtilization, 1);
-      ASSERT_FALSE(finishStats.outputBufferOverutilized);
-    }
-  }
-
-  std::shared_ptr<folly::Executor> executor_{
-      std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
-  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
-  std::shared_ptr<PartitionedOutputBufferManager> bufferManager_;
-  RowTypePtr rowType_;
-};
-
-struct TestParam {
-  PartitionedOutputNode::Kind kind;
-};
-
-class AllPartitionedOutputBufferManagerTest
-    : public PartitionedOutputBufferManagerTest,
-      public testing::WithParamInterface<PartitionedOutputNode::Kind> {
- public:
-  AllPartitionedOutputBufferManagerTest() : kind_(GetParam()) {}
-
-  static std::vector<PartitionedOutputNode::Kind> getTestParams() {
-    static std::vector<PartitionedOutputNode::Kind> params = {
-        PartitionedOutputNode::Kind::kBroadcast,
-        PartitionedOutputNode::Kind::kPartitioned,
-        PartitionedOutputNode::Kind::kArbitrary};
-    return params;
-  }
-
- protected:
-  PartitionedOutputNode::Kind kind_;
-};
-
-TEST_F(PartitionedOutputBufferManagerTest, arbitrayBuffer) {
-  {
-    ArbitraryBuffer buffer;
-    ASSERT_TRUE(buffer.empty());
-    ASSERT_FALSE(buffer.hasNoMoreData());
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[false]]");
-    VELOX_ASSERT_THROW(buffer.enqueue(nullptr), "Unexpected null page");
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[false]]");
-    buffer.noMoreData();
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[true]]");
-  }
-
-  {
-    ArbitraryBuffer buffer;
-    ASSERT_TRUE(buffer.empty());
-    ASSERT_FALSE(buffer.hasNoMoreData());
-    auto page1 = makeSerializedPage(rowType_, 100);
-    auto* rawPage1 = page1.get();
-    buffer.enqueue(std::move(page1));
-    ASSERT_FALSE(buffer.empty());
-    ASSERT_FALSE(buffer.hasNoMoreData());
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[1] NO MORE DATA[false]]");
-    auto page2 = makeSerializedPage(rowType_, 100);
-    auto* rawPage2 = page2.get();
-    buffer.enqueue(std::move(page2));
-    ASSERT_FALSE(buffer.empty());
-    ASSERT_FALSE(buffer.hasNoMoreData());
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[2] NO MORE DATA[false]]");
-
-    auto pages = buffer.getPages(1);
-    ASSERT_EQ(pages.size(), 1);
-    ASSERT_EQ(pages[0].get(), rawPage1);
-    auto page3 = makeSerializedPage(rowType_, 100);
-    auto* rawPage3 = page3.get();
-    buffer.enqueue(std::move(page3));
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[2] NO MORE DATA[false]]");
-    buffer.noMoreData();
-    ASSERT_FALSE(buffer.empty());
-    ASSERT_TRUE(buffer.hasNoMoreData());
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[2] NO MORE DATA[true]]");
-    pages = buffer.getPages(1'000'000'000);
-    ASSERT_EQ(pages.size(), 3);
-    ASSERT_EQ(pages[0].get(), rawPage2);
-    ASSERT_EQ(pages[1].get(), rawPage3);
-    ASSERT_EQ(pages[2].get(), nullptr);
-    ASSERT_TRUE(buffer.empty());
-    ASSERT_TRUE(buffer.hasNoMoreData());
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[true]]");
-    auto page4 = makeSerializedPage(rowType_, 100);
-    VELOX_ASSERT_THROW(
-        buffer.enqueue(std::move(page4)),
-        "Arbitrary buffer has set no more data marker");
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[0] NO MORE DATA[true]]");
-    buffer.noMoreData();
-    VELOX_ASSERT_THROW(buffer.getPages(0), "maxBytes can't be zero");
-    // Verify the end marker is persistent.
-    for (int i = 0; i < 3; ++i) {
-      pages = buffer.getPages(100);
-      ASSERT_EQ(pages.size(), 1);
-      ASSERT_EQ(pages[0].get(), nullptr);
-    }
-  }
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, outputType) {
-  ASSERT_EQ(
-      PartitionedOutputNode::kindString(
-          PartitionedOutputNode::Kind::kPartitioned),
-      "PARTITIONED");
-  ASSERT_EQ(
-      PartitionedOutputNode::kindString(
-          PartitionedOutputNode::Kind::kArbitrary),
-      "ARBITRARY");
-  ASSERT_EQ(
-      PartitionedOutputNode::kindString(
-          PartitionedOutputNode::Kind::kBroadcast),
-      "BROADCAST");
-  ASSERT_EQ(
-      PartitionedOutputNode::kindString(
-          static_cast<PartitionedOutputNode::Kind>(100)),
-      "INVALID OUTPUT KIND 100");
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, destinationBuffer) {
-  {
-    ArbitraryBuffer buffer;
-    DestinationBuffer destinationBuffer;
-    VELOX_ASSERT_THROW(
-        destinationBuffer.loadData(&buffer, 0), "maxBytes can't be zero");
-    destinationBuffer.loadData(&buffer, 100);
-    std::atomic<bool> notified{false};
-    destinationBuffer.getData(
-        1'000'000,
-        0,
-        [&](std::vector<std::unique_ptr<folly::IOBuf>> buffers,
-            int64_t sequence) {
-          ASSERT_EQ(buffers.size(), 1);
-          ASSERT_TRUE(buffers[0].get() == nullptr);
-          notified = true;
-        });
-    ASSERT_TRUE(buffer.empty());
-    ASSERT_FALSE(buffer.hasNoMoreData());
-    ASSERT_FALSE(notified);
-    VELOX_ASSERT_THROW(destinationBuffer.maybeLoadData(&buffer), "");
-    buffer.noMoreData();
-    destinationBuffer.maybeLoadData(&buffer);
-    destinationBuffer.getAndClearNotify().notify();
-    ASSERT_TRUE(notified);
-  }
-
-  {
-    ArbitraryBuffer buffer;
-    int64_t expectedNumBytes{0};
-    for (int i = 0; i < 10; ++i) {
-      auto page = makeSerializedPage(rowType_, 100);
-      expectedNumBytes += page->size();
-      buffer.enqueue(std::move(page));
-    }
-    DestinationBuffer destinationBuffer;
-    destinationBuffer.loadData(&buffer, 1);
-    ASSERT_EQ(
-        buffer.toString(), "[ARBITRARY_BUFFER PAGES[9] NO MORE DATA[false]]");
-    std::atomic<bool> notified{false};
-    int64_t numBytes{0};
-    auto buffers = destinationBuffer.getData(
-        1'000'000'000,
-        0,
-        [&](std::vector<std::unique_ptr<folly::IOBuf>> /*unused*/,
-            int64_t /*unused*/) { notified = true; });
-    for (const auto& buffer : buffers) {
-      numBytes += buffer->length();
-    }
-    ASSERT_GT(numBytes, 0);
-    ASSERT_FALSE(notified);
-    {
-      auto result = destinationBuffer.getAndClearNotify();
-      ASSERT_EQ(result.callback, nullptr);
-      ASSERT_TRUE(result.data.empty());
-      ASSERT_EQ(result.sequence, 0);
-    }
-    auto pages = destinationBuffer.acknowledge(1, false);
-    ASSERT_EQ(pages.size(), 1);
-
-    buffers = destinationBuffer.getData(
-        1'000'000,
-        1,
-        [&](std::vector<std::unique_ptr<folly::IOBuf>> buffers,
-            int64_t sequence) {
-          ASSERT_EQ(sequence, 1);
-          ASSERT_EQ(buffers.size(), 9);
-          for (const auto& buffer : buffers) {
-            numBytes += buffer->length();
-          }
-          notified = true;
-        });
-    ASSERT_TRUE(buffers.empty());
-    ASSERT_FALSE(notified);
-
-    destinationBuffer.maybeLoadData(&buffer);
-    destinationBuffer.getAndClearNotify().notify();
-    ASSERT_TRUE(notified);
-    ASSERT_TRUE(buffer.empty());
-    ASSERT_FALSE(buffer.hasNoMoreData());
-    ASSERT_EQ(numBytes, expectedNumBytes);
-  }
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, basicPartitioned) {
-  vector_size_t size = 100;
-
-  std::string taskId = "t0";
-  auto task = initializeTask(
-      taskId, rowType_, PartitionedOutputNode::Kind::kPartitioned, 5, 1);
-  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
-
-  // Duplicateb update buffers with the same settings are allowed and ignored.
-  ASSERT_TRUE(bufferManager_->updateOutputBuffers(taskId, 5, true));
-  ASSERT_FALSE(bufferManager_->isFinished(taskId));
-  // Partitioned output buffer doesn't allow to update with different number of
-  // output buffers once created.
-  VELOX_ASSERT_THROW(
-      bufferManager_->updateOutputBuffers(taskId, 5 + 1, true), "");
-  // Partitioned output buffer doesn't expect more output buffers once created.
-  VELOX_ASSERT_THROW(bufferManager_->updateOutputBuffers(taskId, 5, false), "");
-  VELOX_ASSERT_THROW(
-      bufferManager_->updateOutputBuffers(taskId, 5 - 1, true), "");
-  VELOX_ASSERT_THROW(
-      bufferManager_->updateOutputBuffers(taskId, 5 - 1, false), "");
-
-  // - enqueue one group per destination
-  // - fetch and ask one group per destination
-  // - enqueue one more group for destinations 0-2
-  // - fetch and ask one group for destinations 0-2
-  // - register end-marker callback for destination 3 and data callback for 4
-  // - enqueue data for 4 and assert callback was called
-  // - enqueue end marker for all destinations
-  // - assert callback was called for destination 3
-  // - fetch end markers for destinations 0-2 and 4
-
-  for (int destination = 0; destination < 5; ++destination) {
-    enqueue(taskId, destination, rowType_, size);
-  }
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  for (int destination = 0; destination < 5; destination++) {
-    fetchOneAndAck(taskId, destination, 0);
-    // Try to re-fetch already ack-ed data - should fail
-    EXPECT_THROW(fetchOne(taskId, destination, 0), std::exception);
-  }
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  for (int destination = 0; destination < 3; destination++) {
-    enqueue(taskId, destination, rowType_, size);
-  }
-
-  for (int destination = 0; destination < 3; destination++) {
-    fetchOneAndAck(taskId, destination, 1);
-  }
-
-  // destinations 0-2 received and ack-ed 2 groups each
-  // destinations 3-4 received and ack-ed 1 group each
-
-  bool receivedEndMarker3;
-  registerForEndMarker(taskId, 3, 1, receivedEndMarker3);
-
-  bool receivedData4;
-  registerForData(taskId, 4, 1, 1, receivedData4);
-
-  enqueue(taskId, 4, rowType_, size);
-  EXPECT_TRUE(receivedData4);
-
-  noMoreData(taskId);
-  EXPECT_TRUE(receivedEndMarker3);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  for (int destination = 0; destination < 3; destination++) {
-    fetchEndMarker(taskId, destination, 2);
-  }
-  EXPECT_TRUE(task->isRunning());
-  verifyOutputBuffer(task, OutputBufferStatus::kRunning);
-
-  deleteResults(taskId, 3);
-  fetchEndMarker(taskId, 4, 2);
-  bufferManager_->removeTask(taskId);
-  EXPECT_TRUE(task->isFinished());
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, basicBroadcast) {
-  vector_size_t size = 100;
-
-  std::string taskId = "t0";
-  auto task = initializeTask(
-      taskId, rowType_, PartitionedOutputNode::Kind::kBroadcast, 5, 1);
-  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
-  VELOX_ASSERT_THROW(enqueue(taskId, 1, rowType_, size), "Bad destination 1");
-
-  enqueue(taskId, rowType_, size);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  for (int destination = 0; destination < 5; destination++) {
-    fetchOneAndAck(taskId, destination, 0);
-    // Try to re-fetch already ack-ed data - should fail
-    EXPECT_THROW(fetchOne(taskId, destination, 0), std::exception);
-  }
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  enqueue(taskId, rowType_, size);
-
-  for (int destination = 0; destination < 5; destination++) {
-    fetchOneAndAck(taskId, destination, 1);
-  }
-
-  bool receivedEndMarker3;
-  registerForEndMarker(taskId, 3, 2, receivedEndMarker3);
-
-  noMoreData(taskId);
-  EXPECT_TRUE(receivedEndMarker3);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  for (int destination = 0; destination < 5; ++destination) {
-    if (destination != 3) {
-      fetchEndMarker(taskId, destination, 2);
-    }
-  }
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-  bufferManager_->updateOutputBuffers(taskId, 5, false);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-  bufferManager_->updateOutputBuffers(taskId, 6, false);
-  verifyOutputBuffer(task, OutputBufferStatus::kRunning);
-
-  // Fetch all for the new added destinations.
-  fetch(taskId, 5, 0, 1'000'000'000, 3, true);
-  VELOX_ASSERT_THROW(
-      acknowledge(taskId, 5, 4),
-      "(4 vs. 3) Ack received for a not yet produced item");
-  acknowledge(taskId, 5, 0);
-  acknowledge(taskId, 5, 1);
-  acknowledge(taskId, 5, 2);
-  acknowledge(taskId, 5, 3);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-  deleteResults(taskId, 5);
-  VELOX_ASSERT_THROW(
-      fetch(taskId, 5, 0, 1'000'000'000, 2),
-      "getData received after its buffer is deleted. Destination: 5, sequence: 0");
-
-  bufferManager_->updateOutputBuffers(taskId, 7, true);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-  fetch(taskId, 6, 0, 1'000'000'000, 3, true);
-  acknowledge(taskId, 6, 2);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-  deleteResults(taskId, 6);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  EXPECT_TRUE(task->isRunning());
-  deleteResults(taskId, 3);
-  EXPECT_TRUE(bufferManager_->isFinished(taskId));
-  bufferManager_->removeTask(taskId);
-  EXPECT_TRUE(task->isFinished());
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, basicArbitrary) {
-  const vector_size_t size = 100;
-  int numDestinations = 5;
-  const std::string taskId = "t0";
-  auto task = initializeTask(
-      taskId, rowType_, PartitionedOutputNode::Kind::kArbitrary, 5, 1);
-  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
-
-  VELOX_ASSERT_THROW(
-      enqueue(taskId, 1, rowType_, size), "(1 vs. 0) Bad destination 1");
-
-  for (int i = 0; i < numDestinations; ++i) {
-    enqueue(taskId, rowType_, size);
-  }
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  std::unordered_map<int, int> ackedSeqbyDestination;
-
-  for (int destination = 0; destination < numDestinations; destination++) {
-    fetchOne(taskId, destination, 0, 1);
-    acknowledge(taskId, destination, 1);
-    ackedSeqbyDestination[destination] = 1;
-    // Try to re-fetch already ack-ed data - should fail
-    VELOX_ASSERT_THROW(fetchOne(taskId, destination, 0), "");
-  }
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-  verifyOutputBuffer(task, OutputBufferStatus::kRunning);
-
-  bool receivedData0{false};
-  bool receivedData1{false};
-  registerForData(taskId, 0, 1, 1, receivedData0);
-  registerForData(taskId, 1, 1, 1, receivedData1);
-  enqueue(taskId, rowType_, size);
-  enqueue(taskId, rowType_, size);
-  ASSERT_TRUE(receivedData0);
-  ASSERT_TRUE(receivedData1);
-  acknowledge(taskId, 0, 2);
-  ackedSeqbyDestination[0] = 2;
-  acknowledge(taskId, 1, 2);
-  ackedSeqbyDestination[1] = 2;
-  bool receivedData{false};
-  registerForData(taskId, 4, 1, 1, receivedData);
-  enqueue(taskId, rowType_, size);
-  enqueue(taskId, rowType_, size);
-  ASSERT_TRUE(receivedData);
-  acknowledge(taskId, 4, 2);
-  ackedSeqbyDestination[4] = 2;
-
-  bufferManager_->updateOutputBuffers(taskId, ++numDestinations, false);
-  bufferManager_->updateOutputBuffers(taskId, ++numDestinations, false);
-  fetchOneAndAck(taskId, numDestinations - 1, 0);
-  ackedSeqbyDestination[numDestinations - 1] = 1;
-
-  bufferManager_->updateOutputBuffers(taskId, numDestinations - 1, false);
-  VELOX_ASSERT_THROW(
-      fetchOneAndAck(taskId, numDestinations - 1, 0),
-      "(0 vs. 1) Get received for an already acknowledged item");
-
-  receivedData = false;
-  registerForData(taskId, numDestinations - 2, 0, 1, receivedData);
-  enqueue(taskId, rowType_, size);
-  ASSERT_TRUE(receivedData);
-  acknowledge(taskId, numDestinations - 2, 1);
-  ackedSeqbyDestination[numDestinations - 2] = 1;
-
-  noMoreData(taskId);
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-  EXPECT_TRUE(task->isRunning());
-  for (int i = 0; i < numDestinations; ++i) {
-    fetchEndMarker(taskId, i, ackedSeqbyDestination[i]);
-  }
-  EXPECT_TRUE(bufferManager_->isFinished(taskId));
-  EXPECT_FALSE(task->isRunning());
-
-  // NOTE: arbitrary buffer finish condition doesn't depend on no more
-  // (destination )buffers update flag.
-  bufferManager_->updateOutputBuffers(taskId, numDestinations, true);
-
-  EXPECT_TRUE(bufferManager_->isFinished(taskId));
-  bufferManager_->removeTask(taskId);
-  EXPECT_TRUE(task->isFinished());
-}
-
-TEST_F(
-    PartitionedOutputBufferManagerTest,
-    broadcastWithDynamicAddedDestination) {
-  vector_size_t size = 100;
-
-  std::string taskId = "t0";
-  auto task = initializeTask(
-      taskId, rowType_, PartitionedOutputNode::Kind::kBroadcast, 5, 1);
-
-  const int numPages = 10;
-  for (int i = 0; i < numPages; ++i) {
-    enqueue(taskId, rowType_, size);
-  }
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  for (int i = 0; i < numPages; ++i) {
-    for (int destination = 0; destination < 5; ++destination) {
-      fetchOneAndAck(taskId, destination, i);
-    }
-  }
-
-  // Dynamic added destination.
-  fetch(taskId, 5, 0, 1'000'000'000, 10);
-  bufferManager_->updateOutputBuffers(taskId, 4, false);
-  bufferManager_->updateOutputBuffers(taskId, 6, false);
-  bufferManager_->updateOutputBuffers(taskId, 7, false);
-
-  fetch(taskId, 6, 0, 1'000'000'000, 10);
-  fetch(taskId, 7, 0, 1'000'000'000, 10);
-  fetch(taskId, 8, 0, 1'000'000'000, 10);
-
-  bufferManager_->updateOutputBuffers(taskId, 7, true);
-
-  VELOX_ASSERT_THROW(fetch(taskId, 10, 0, 1'000'000'000, 10), "");
-
-  ASSERT_FALSE(bufferManager_->isFinished(taskId));
-  noMoreData(taskId);
-  for (int i = 0; i < 9; ++i) {
-    fetchEndMarker(taskId, i, numPages);
-  }
-  ASSERT_TRUE(bufferManager_->isFinished(taskId));
-
-  bufferManager_->removeTask(taskId);
-  EXPECT_TRUE(task->isFinished());
-}
-
-TEST_F(
-    PartitionedOutputBufferManagerTest,
-    arbitraryWithDynamicAddedDestination) {
-  const vector_size_t size = 100;
-  int numDestinations = 5;
-  const std::string taskId = "t0";
-  auto task = initializeTask(
-      taskId, rowType_, PartitionedOutputNode::Kind::kArbitrary, 5, 1);
-
-  for (int i = 0; i < numDestinations; ++i) {
-    enqueue(taskId, rowType_, size);
-  }
-  std::unordered_map<int, int> ackedSeqbyDestination;
-
-  for (int destination = 0; destination < 5; destination++) {
-    fetchOne(taskId, destination, 0, 1);
-    acknowledge(taskId, destination, 1);
-    ackedSeqbyDestination[destination] = 1;
-  }
-  EXPECT_FALSE(bufferManager_->isFinished(taskId));
-
-  // Dynamic added destination.
-  enqueue(taskId, rowType_, size);
-  fetchOneAndAck(taskId, numDestinations, 0);
-  ackedSeqbyDestination[numDestinations] = 1;
-
-  bufferManager_->updateOutputBuffers(taskId, numDestinations - 1, false);
-  bufferManager_->updateOutputBuffers(taskId, numDestinations, false);
-  bufferManager_->updateOutputBuffers(taskId, numDestinations + 1, false);
-
-  enqueue(taskId, rowType_, size);
-  fetchOneAndAck(taskId, numDestinations + 10, 0);
-  ackedSeqbyDestination[numDestinations + 10] = 1;
-
-  bufferManager_->updateOutputBuffers(taskId, numDestinations, true);
-
-  enqueue(taskId, rowType_, size);
-  fetchOneAndAck(taskId, numDestinations + 9, 0);
-  ackedSeqbyDestination[numDestinations + 9] = 1;
-
-  VELOX_ASSERT_THROW(
-      fetch(taskId, numDestinations + 20, 0, 1'000'000'000, 1), "");
-
-  ASSERT_FALSE(bufferManager_->isFinished(taskId));
-
-  noMoreData(taskId);
-  EXPECT_TRUE(task->isRunning());
-  for (int i = 0; i <= numDestinations + 10; ++i) {
-    fetchEndMarker(taskId, i, ackedSeqbyDestination[i]);
-  }
-  EXPECT_TRUE(bufferManager_->isFinished(taskId));
-
-  EXPECT_FALSE(task->isRunning());
-  EXPECT_TRUE(bufferManager_->isFinished(taskId));
-  bufferManager_->removeTask(taskId);
-  EXPECT_TRUE(task->isFinished());
-}
-
-TEST_P(AllPartitionedOutputBufferManagerTest, maxBytes) {
-  const vector_size_t size = 100;
-  const std::string taskId = "t0";
-  initializeTask(taskId, rowType_, kind_, 1, 1);
-
-  enqueue(taskId, 0, rowType_, size);
-  enqueue(taskId, 0, rowType_, size);
-  enqueue(taskId, 0, rowType_, size);
-
-  // fetch up to 1Kb - 1 group
-  fetchOne(taskId, 0, 0);
-  // re-fetch with larger size limit - 2 groups
-  fetch(taskId, 0, 0, std::numeric_limits<int64_t>::max(), 3);
-  // re-fetch with 1Kb limit - 1 group
-  fetchOneAndAck(taskId, 0, 0);
-  fetchOneAndAck(taskId, 0, 1);
-  fetchOneAndAck(taskId, 0, 2);
-
-  if (kind_ != PartitionedOutputNode::Kind::kPartitioned) {
-    bufferManager_->updateOutputBuffers(taskId, 0, true);
-  }
-  noMoreData(taskId);
-  fetchEndMarker(taskId, 0, 3);
-  bufferManager_->removeTask(taskId);
-}
-
-TEST_P(AllPartitionedOutputBufferManagerTest, outputBufferUtilization) {
-  const std::string taskId = std::to_string(rand());
-  const auto destination = 0;
-  auto task = initializeTask(taskId, rowType_, kind_, 1, 1);
-  verifyOutputBuffer(task, OutputBufferStatus::kInitiated);
-  if (kind_ == facebook::velox::core::PartitionedOutputNode::Kind::kBroadcast) {
-    bufferManager_->updateOutputBuffers(taskId, destination, true);
-  }
-
-  bool blocked = false;
-  do {
-    ContinueFuture future;
-    blocked = bufferManager_->enqueue(
-        taskId, destination, makeSerializedPage(rowType_, 100), &future);
-    if (!blocked) {
-      verifyOutputBuffer(task, OutputBufferStatus::kRunning);
-    }
-  } while (!blocked);
-
-  verifyOutputBuffer(task, OutputBufferStatus::kBlocked);
-
-  int group = 0;
-  do {
-    fetchOneAndAck(taskId, destination, group);
-    group++;
-  } while (task->taskStats().outputBufferOverutilized);
-  verifyOutputBuffer(task, OutputBufferStatus::kRunning);
-
-  ContinueFuture future;
-  bufferManager_->enqueue(
-      taskId, destination, makeSerializedPage(rowType_, 200), &future);
-  verifyOutputBuffer(task, OutputBufferStatus::kBlocked);
-  auto oldUtilization = task->taskStats().outputBufferUtilization;
-
-  noMoreData(taskId);
-  verifyOutputBuffer(task, OutputBufferStatus::kNoMoreProducer);
-  ASSERT_EQ(oldUtilization, task->taskStats().outputBufferUtilization);
-
-  deleteResults(taskId, destination);
-  bufferManager_->removeTask(taskId);
-  verifyOutputBuffer(task, OutputBufferStatus::kFinished);
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, outOfOrderAcks) {
-  const vector_size_t size = 100;
-  const std::string taskId = "t0";
-  auto task = initializeTask(
-      taskId, rowType_, PartitionedOutputNode::Kind::kPartitioned, 5, 1);
-
-  enqueue(taskId, 0, rowType_, size);
-  for (int i = 0; i < 10; i++) {
-    enqueue(taskId, 1, rowType_, size);
-  }
-
-  // fetch first 3 groups
-  fetchOne(taskId, 1, 0);
-  fetchOne(taskId, 1, 1);
-  fetchOne(taskId, 1, 2);
-
-  // send acks out of order: 3, 1, 2
-  acknowledge(taskId, 1, 3);
-  acknowledge(taskId, 1, 1);
-  acknowledge(taskId, 1, 2);
-
-  // fetch and ack remaining 7 groups
-  fetch(taskId, 1, 3, std::numeric_limits<uint64_t>::max(), 7);
-  acknowledge(taskId, 1, 10);
-
-  noMoreData(taskId);
-  fetchEndMarker(taskId, 1, 10);
-  task->requestCancel();
-  bufferManager_->removeTask(taskId);
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, errorInQueue) {
-  auto queue = std::make_shared<ExchangeQueue>();
-  queue->setError("Forced failure");
-
-  std::lock_guard<std::mutex> l(queue->mutex());
-  ContinueFuture future;
-  bool atEnd = false;
-  VELOX_ASSERT_THROW(queue->dequeueLocked(&atEnd, &future), "Forced failure");
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, setQueueErrorWithPendingPages) {
-  const uint64_t kBufferSize = 128;
-  auto iobuf = folly::IOBuf::create(kBufferSize);
-  const std::string payload("setQueueErrorWithPendingPages");
-  size_t payloadSize = payload.size();
-  std::memcpy(iobuf->writableData(), payload.data(), payloadSize);
-  iobuf->append(payloadSize);
-
-  auto page = std::make_unique<SerializedPage>(std::move(iobuf));
-
-  auto queue = std::make_shared<ExchangeQueue>();
-  std::vector<ContinuePromise> promises;
-  {
-    std::lock_guard<std::mutex> l(queue->mutex());
-    queue->enqueueLocked(std::move(page), promises);
-  }
-
-  queue->setError("Forced failure");
-
-  // Expect a throw on dequeue after the queue has been set error.
-  std::lock_guard<std::mutex> l(queue->mutex());
-  ContinueFuture future;
-  bool atEnd = false;
-  VELOX_ASSERT_THROW(queue->dequeueLocked(&atEnd, &future), "Forced failure");
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, getDataOnFailedTask) {
-  // Fetching data on a task which was either never initialized in the buffer
-  // manager or was removed by a parallel thread must return false. The `notify`
-  // callback must not be registered.
-  ASSERT_FALSE(bufferManager_->getData(
-      "test.0.1",
-      1,
-      10,
-      1,
-      [](std::vector<std::unique_ptr<folly::IOBuf>> pages, int64_t sequence) {
-        VELOX_UNREACHABLE();
-      }));
-}
-
-TEST_F(PartitionedOutputBufferManagerTest, updateBrodcastBufferOnFailedTask) {
-  // Updating broadcast buffer count in the buffer manager for a given unknown
-  // task must not throw exception, instead must return FALSE.
-  ASSERT_FALSE(bufferManager_->updateOutputBuffers(
-      "test.0.1", /* unknown task */
-      10,
-      false));
-}
-
-TEST_P(AllPartitionedOutputBufferManagerTest, multiFetchers) {
-  const std::vector<bool> earlyTerminations = {false, true};
-  for (const auto earlyTermination : earlyTerminations) {
-    SCOPED_TRACE(fmt::format("earlyTermination {}", earlyTermination));
-
-    const vector_size_t size = 10;
-    const std::string taskId = "t0";
-    int numPartitions = 10;
-    int extendedNumPartitions = numPartitions / 2;
-    initializeTask(
-        taskId,
-        rowType_,
-        kind_,
-        numPartitions,
-        1,
-        kind_ == PartitionedOutputNode::Kind::kBroadcast ? 256 << 20 : 0);
-
-    std::vector<std::thread> threads;
-    std::vector<int64_t> fetchedPages(numPartitions + extendedNumPartitions, 0);
-    for (size_t i = 0; i < numPartitions; ++i) {
-      threads.emplace_back([&, i]() {
-        dataFetcher(taskId, i, fetchedPages.at(i), earlyTermination);
-      });
-    }
-    folly::Random::DefaultGenerator rng;
-    rng.seed(1234);
-    const int totalPages = 10'000;
-    std::vector<int64_t> producedPages(
-        numPartitions + extendedNumPartitions, 0);
-    for (int i = 0; i < totalPages; ++i) {
-      const int partition = kind_ == PartitionedOutputNode::Kind::kPartitioned
-          ? folly::Random().rand32(rng) % numPartitions
-          : 0;
-      try {
-        enqueue(taskId, partition, rowType_, size, true);
-      } catch (...) {
-        // Early termination might cause the task to fail early.
-        ASSERT_TRUE(earlyTermination);
-        break;
-      }
-      ++producedPages[partition];
-      if (folly::Random().oneIn(4)) {
-        std::this_thread::sleep_for(std::chrono::microseconds(5)); // NOLINT
-      }
-      if (i == 1000 && (kind_ != PartitionedOutputNode::Kind::kPartitioned)) {
-        bufferManager_->updateOutputBuffers(
-            taskId, numPartitions + extendedNumPartitions, false);
-        for (size_t i = numPartitions;
-             i < numPartitions + extendedNumPartitions;
-             ++i) {
-          threads.emplace_back([&, i]() {
-            dataFetcher(taskId, i, fetchedPages.at(i), earlyTermination);
-          });
-          fetchedPages[i] = 0;
-        }
-        bufferManager_->updateOutputBuffers(taskId, 0, true);
-      }
-    }
-    noMoreData(taskId);
-
-    for (int i = 0; i < threads.size(); ++i) {
-      threads[i].join();
-    }
-
-    if (!earlyTermination) {
-      if (kind_ == PartitionedOutputNode::Kind::kPartitioned) {
-        for (int i = 0; i < numPartitions; ++i) {
-          ASSERT_EQ(fetchedPages[i], producedPages[i]);
-        }
-      } else if (kind_ == PartitionedOutputNode::Kind::kBroadcast) {
-        int64_t totalFetchedPages{0};
-        for (const auto& pages : fetchedPages) {
-          totalFetchedPages += pages;
-        }
-        ASSERT_EQ(
-            totalPages * (numPartitions + extendedNumPartitions),
-            totalFetchedPages);
-      } else {
-        int64_t totalFetchedPages{0};
-        for (const auto& pages : fetchedPages) {
-          totalFetchedPages += pages;
-        }
-        ASSERT_EQ(totalPages, totalFetchedPages);
-      }
-    }
-    bufferManager_->removeTask(taskId);
-  }
-}
-
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    AllPartitionedOutputBufferManagerTestSuite,
-    AllPartitionedOutputBufferManagerTest,
-    testing::ValuesIn(AllPartitionedOutputBufferManagerTest::getTestParams()));
diff --git a/velox/exec/tests/PartitionedOutputTest.cpp b/velox/exec/tests/PartitionedOutputTest.cpp
new file mode 100644
index 0000000000000..37f44de6f6f47
--- /dev/null
+++ b/velox/exec/tests/PartitionedOutputTest.cpp
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/PartitionedOutput.h"
+#include <gtest/gtest.h>
+#include "velox/exec/Task.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::exec::test {
+
+class PartitionedOutputTest : public OperatorTestBase {
+ protected:
+  std::shared_ptr<core::QueryCtx> createQueryContext(
+      std::unordered_map<std::string, std::string> config) {
+    return core::QueryCtx::create(
+        executor_.get(), core::QueryConfig(std::move(config)));
+  }
+
+  std::vector<std::unique_ptr<folly::IOBuf>>
+  getData(const std::string& taskId, int destination, int64_t sequence) {
+    auto [promise, semiFuture] = folly::makePromiseContract<
+        std::vector<std::unique_ptr<folly::IOBuf>>>();
+    VELOX_CHECK(bufferManager_->getData(
+        taskId,
+        destination,
+        PartitionedOutput::kMinDestinationSize,
+        sequence,
+        [result = std::make_shared<
+             folly::Promise<std::vector<std::unique_ptr<folly::IOBuf>>>>(
+             std::move(promise))](
+            std::vector<std::unique_ptr<folly::IOBuf>> pages,
+            int64_t /*inSequence*/,
+            std::vector<int64_t> /*remainingBytes*/) {
+          result->setValue(std::move(pages));
+        }));
+    auto future = std::move(semiFuture).via(executor_.get());
+    future.wait(std::chrono::seconds{10});
+    VELOX_CHECK(future.isReady());
+    return std::move(future).value();
+  }
+
+  std::vector<std::unique_ptr<folly::IOBuf>> getAllData(
+      const std::string& taskId,
+      int destination) {
+    std::vector<std::unique_ptr<folly::IOBuf>> result;
+    int attempts = 0;
+    bool done = false;
+    while (!done) {
+      attempts++;
+      VELOX_CHECK_LT(attempts, 100);
+      std::vector<std::unique_ptr<folly::IOBuf>> pages =
+          getData(taskId, destination, result.size());
+      for (auto& page : pages) {
+        if (page) {
+          result.push_back(std::move(page));
+        } else {
+          bufferManager_->deleteResults(taskId, destination);
+          done = true;
+          break;
+        }
+      }
+    }
+    return result;
+  }
+
+ private:
+  const std::shared_ptr<OutputBufferManager> bufferManager_{
+      OutputBufferManager::getInstance().lock()};
+};
+
+TEST_F(PartitionedOutputTest, flush) {
+  // This test verifies
+  //  - Flush thresholds are respected (flush doesn't happen neither too early
+  //  nor too late)
+  //  - Flush is done independently for each output partition (flush for one
+  //  partition doesn't trigger flush for another one)
+
+  auto input = makeRowVector(
+      {"p1", "v1"},
+      {makeFlatVector<int32_t>({0, 1}),
+       makeFlatVector<std::string>({
+           // twice as large to make sure it is always flushed (even if
+           // PartitionedOutput#setTargetSizePct rolls 120%)
+           std::string(PartitionedOutput::kMinDestinationSize * 2, '0'),
+           // 10 times smaller, so the data from 13 pages is always flushed as 2
+           // pages
+           // 130% > 120% (when PartitionedOutput#setTargetSizePct rolls 120%)
+           // 130% < 140% (when PartitionedOutput#setTargetSizePct rolls 70% two
+           // times in a row)
+           std::string(PartitionedOutput::kMinDestinationSize / 10, '1'),
+       })});
+
+  auto plan = PlanBuilder()
+                  // produce 13 pages
+                  .values({input}, false, 13)
+                  .partitionedOutput({"p1"}, 2, std::vector<std::string>{"v1"})
+                  .planNode();
+
+  auto taskId = "local://test-partitioned-output-flush-0";
+  auto task = Task::create(
+      taskId,
+      core::PlanFragment{plan},
+      0,
+      createQueryContext(
+          {{core::QueryConfig::kMaxPartitionedOutputBufferSize,
+            std::to_string(PartitionedOutput::kMinDestinationSize * 2)}}),
+      Task::ExecutionMode::kParallel);
+  task->start(1);
+
+  const auto partition0 = getAllData(taskId, 0);
+  const auto partition1 = getAllData(taskId, 1);
+
+  const auto taskWaitUs = std::chrono::duration_cast<std::chrono::microseconds>(
+                              std::chrono::seconds{10})
+                              .count();
+  auto future = task->taskCompletionFuture()
+                    .within(std::chrono::microseconds(taskWaitUs))
+                    .via(executor_.get());
+  future.wait();
+
+  ASSERT_TRUE(waitForTaskDriversToFinish(task.get(), taskWaitUs));
+
+  // Since each row for partition 0 is over the flush threshold as
+  // many pages as there are input pages are expected
+  EXPECT_EQ(partition0.size(), 13);
+  // Data for the second partition is much smaller and expected to be buffered
+  // up to a defined threshold
+  EXPECT_EQ(partition1.size(), 2);
+}
+
+TEST_F(PartitionedOutputTest, keyChannelNotAtBeginningWithNulls) {
+  // This test verifies that PartitionedOutput can handle the case where a key
+  // channel is not at the beginning of the input type when nulls are present in
+  // the key channel.  This triggers collectNullRows() to run which has special
+  // handling logic for the key channels.
+
+  auto input = makeRowVector(
+      // The key column p1 is the second column.
+      {"v1", "p1"},
+      {makeFlatVector<std::string>({"0", "1", "2", "3"}),
+       // Add nulls to the key column.
+       makeNullableFlatVector<int32_t>(std::vector<std::optional<int32_t>>{
+           0, std::nullopt, 1, std::nullopt})});
+
+  auto plan =
+      PlanBuilder()
+          .values({input}, false, 13)
+          // Set replicateNullsAndAny to true so we trigger the null path.
+          .partitionedOutput({"p1"}, 2, true, std::vector<std::string>{"v1"})
+          .planNode();
+
+  auto taskId = "local://test-partitioned-output-0";
+  auto task = Task::create(
+      taskId,
+      core::PlanFragment{plan},
+      0,
+      createQueryContext({}),
+      Task::ExecutionMode::kParallel);
+  task->start(1);
+
+  const auto partition0 = getAllData(taskId, 0);
+  const auto partition1 = getAllData(taskId, 1);
+
+  ASSERT_TRUE(waitForTaskCompletion(
+      task.get(),
+      std::chrono::duration_cast<std::chrono::microseconds>(
+          std::chrono::seconds(10))
+          .count()));
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PlanBuilderTest.cpp b/velox/exec/tests/PlanBuilderTest.cpp
index 06e1e6116828b..c4b22f3678b81 100644
--- a/velox/exec/tests/PlanBuilderTest.cpp
+++ b/velox/exec/tests/PlanBuilderTest.cpp
@@ -26,6 +26,10 @@ namespace facebook::velox::exec::test {
 class PlanBuilderTest : public testing::Test,
                         public velox::test::VectorTestBase {
  public:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   PlanBuilderTest() {
     functions::prestosql::registerAllScalarFunctions();
     aggregate::prestosql::registerAllAggregateFunctions();
@@ -33,6 +37,15 @@ class PlanBuilderTest : public testing::Test,
   }
 };
 
+TEST_F(PlanBuilderTest, invalidSourceNode) {
+  VELOX_ASSERT_THROW(
+      PlanBuilder().project({"c0 > 5"}).planNode(),
+      "Project cannot be the source node");
+  VELOX_ASSERT_THROW(
+      PlanBuilder().filter({"c0 > 5"}).planNode(),
+      "Filter cannot be the source node");
+}
+
 TEST_F(PlanBuilderTest, duplicateSubfield) {
   VELOX_ASSERT_THROW(
       PlanBuilder(pool_.get())
@@ -85,7 +98,11 @@ void registerWindowFunction() {
           .returnType("BIGINT")
           .build(),
   };
-  exec::registerWindowFunction("window1", std::move(signatures), nullptr);
+  exec::registerWindowFunction(
+      "window1",
+      std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
+      nullptr);
 }
 } // namespace
 
@@ -105,8 +122,8 @@ TEST_F(PlanBuilderTest, windowFunctionCall) {
           .window({"window1(c) over (partition by a order by b) as d"})
           .planNode()
           ->toString(true, false),
-      "-- Window[partition by [a] order by [b ASC NULLS LAST] "
-      "d := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and CURRENT ROW inputsSorted [0]] "
+      "-- Window[1][partition by [a] order by [b ASC NULLS LAST] "
+      "d := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and CURRENT ROW] "
       "-> a:VARCHAR, b:BIGINT, c:BIGINT, d:BIGINT\n");
 
   VELOX_CHECK_EQ(
@@ -115,8 +132,8 @@ TEST_F(PlanBuilderTest, windowFunctionCall) {
           .window({"window1(c) over (partition by a) as d"})
           .planNode()
           ->toString(true, false),
-      "-- Window[partition by [a] order by [] "
-      "d := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and CURRENT ROW inputsSorted [0]] "
+      "-- Window[1][partition by [a] "
+      "d := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and CURRENT ROW] "
       "-> a:VARCHAR, b:BIGINT, c:BIGINT, d:BIGINT\n");
 
   VELOX_CHECK_EQ(
@@ -125,8 +142,7 @@ TEST_F(PlanBuilderTest, windowFunctionCall) {
           .window({"window1(c) over ()"})
           .planNode()
           ->toString(true, false),
-      "-- Window[partition by [] order by [] "
-      "w0 := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and CURRENT ROW inputsSorted [0]] "
+      "-- Window[1][w0 := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and CURRENT ROW] "
       "-> a:VARCHAR, b:BIGINT, c:BIGINT, w0:BIGINT\n");
 
   VELOX_ASSERT_THROW(
@@ -165,7 +181,7 @@ TEST_F(PlanBuilderTest, windowFrame) {
                "window1(c) over (partition by a order by b range between unbounded preceding and unbounded following) as d10"})
           .planNode()
           ->toString(true, false),
-      "-- Window[partition by [a] order by [b ASC NULLS LAST] "
+      "-- Window[1][partition by [a] order by [b ASC NULLS LAST] "
       "d1 := window1(ROW[\"c\"]) ROWS between b PRECEDING and CURRENT ROW, "
       "d2 := window1(ROW[\"c\"]) RANGE between b PRECEDING and CURRENT ROW, "
       "d3 := window1(ROW[\"c\"]) ROWS between UNBOUNDED PRECEDING and CURRENT ROW, "
@@ -175,7 +191,7 @@ TEST_F(PlanBuilderTest, windowFrame) {
       "d7 := window1(ROW[\"c\"]) ROWS between CURRENT ROW and UNBOUNDED FOLLOWING, "
       "d8 := window1(ROW[\"c\"]) RANGE between CURRENT ROW and UNBOUNDED FOLLOWING, "
       "d9 := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and UNBOUNDED FOLLOWING, "
-      "d10 := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and UNBOUNDED FOLLOWING inputsSorted [0]] "
+      "d10 := window1(ROW[\"c\"]) RANGE between UNBOUNDED PRECEDING and UNBOUNDED FOLLOWING] "
       "-> a:VARCHAR, b:BIGINT, c:BIGINT, d1:BIGINT, d2:BIGINT, d3:BIGINT, d4:BIGINT, "
       "d5:BIGINT, d6:BIGINT, d7:BIGINT, d8:BIGINT, d9:BIGINT, d10:BIGINT\n");
 
@@ -206,5 +222,32 @@ TEST_F(PlanBuilderTest, windowFrame) {
                "window1(c) over (partition by a order by b desc rows between b preceding and current row) as d2"})
           .planNode(),
       "do not match ORDER BY clauses.");
+
+  VELOX_ASSERT_THROW(
+      PlanBuilder()
+          .tableScan(ROW(
+              {"a", "b", "c", "d"}, {VARCHAR(), BIGINT(), BIGINT(), BIGINT()}))
+          .window({
+              "window1(c) over (partition by a order by b, c range between d preceding and current row) as d1",
+          })
+          .planNode(),
+      "Window frame of type RANGE PRECEDING or FOLLOWING requires single sorting key in ORDER BY");
+
+  VELOX_ASSERT_THROW(
+      PlanBuilder()
+          .tableScan(ROW(
+              {"a", "b", "c", "d"}, {VARCHAR(), BIGINT(), BIGINT(), BIGINT()}))
+          .window({
+              "window1(c) over (partition by a, c range between d preceding and current row) as d1",
+          })
+          .planNode(),
+      "Window frame of type RANGE PRECEDING or FOLLOWING requires single sorting key in ORDER BY");
 }
+
+TEST_F(PlanBuilderTest, missingOutputType) {
+  VELOX_ASSERT_THROW(
+      PlanBuilder().startTableScan().endTableScan(),
+      "outputType must be specified");
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PlanNodeSerdeTest.cpp b/velox/exec/tests/PlanNodeSerdeTest.cpp
index de80bcde6d188..8f796b963ab61 100644
--- a/velox/exec/tests/PlanNodeSerdeTest.cpp
+++ b/velox/exec/tests/PlanNodeSerdeTest.cpp
@@ -28,6 +28,10 @@ namespace facebook::velox::exec::test {
 class PlanNodeSerdeTest : public testing::Test,
                           public velox::test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   PlanNodeSerdeTest() {
     functions::prestosql::registerAllScalarFunctions();
     aggregate::prestosql::registerAllAggregateFunctions();
@@ -87,6 +91,26 @@ TEST_F(PlanNodeSerdeTest, aggregation) {
              .planNode();
 
   testSerde(plan);
+
+  // Aggregation over GroupId with global grouping sets.
+  plan = PlanBuilder()
+             .values({data_})
+             .groupId({"c0"}, {{"c0"}, {}}, {"c1"})
+             .singleAggregation({"c0", "group_id"}, {"sum(c1) as sum_c1"}, {})
+             .project({"sum_c1"})
+             .planNode();
+
+  testSerde(plan);
+
+  // Aggregation over GroupId with multiple global grouping sets.
+  plan = PlanBuilder()
+             .values({data_})
+             .groupId({"c0"}, {{"c0"}, {}, {}}, {"c1"})
+             .singleAggregation({"c0", "group_id"}, {"sum(c1) as sum_c1"}, {})
+             .project({"sum_c1"})
+             .planNode();
+
+  testSerde(plan);
 }
 
 TEST_F(PlanNodeSerdeTest, assignUniqueId) {
@@ -175,6 +199,17 @@ TEST_F(PlanNodeSerdeTest, groupId) {
   testSerde(plan);
 }
 
+TEST_F(PlanNodeSerdeTest, expand) {
+  auto plan = PlanBuilder()
+                  .values({data_})
+                  .expand(
+                      {{"c0", "c1", "c2", "0 as gid"},
+                       {"c0", "c1", "null as c2", "1  as gid"},
+                       {"c0", "null as c1", "null as c2", "2  as gid"}})
+                  .planNode();
+  testSerde(plan);
+}
+
 TEST_F(PlanNodeSerdeTest, localPartition) {
   auto plan = PlanBuilder()
                   .values({data_})
@@ -503,6 +538,12 @@ TEST_F(PlanNodeSerdeTest, write) {
       PlanBuilder(pool_.get()).tableScan(rowTypePtr, {"c1 = true"}, "c0 < 100");
   auto plan = planBuilder.tableWrite("targetDirectory").planNode();
   testSerde(plan);
+
+  plan = PlanBuilder(pool_.get())
+             .values(data_)
+             .tableWrite("targetDirectory")
+             .planNode();
+  testSerde(plan);
 }
 
 TEST_F(PlanNodeSerdeTest, tableWriteMerge) {
@@ -514,6 +555,14 @@ TEST_F(PlanNodeSerdeTest, tableWriteMerge) {
                   .tableWriteMerge()
                   .planNode();
   testSerde(plan);
+
+  plan = PlanBuilder(pool_.get())
+             .values(data_)
+             .tableWrite("targetDirectory")
+             .localPartition(std::vector<std::string>{})
+             .tableWriteMerge()
+             .planNode();
+  testSerde(plan);
 }
 
 TEST_F(PlanNodeSerdeTest, tableWriteWithStats) {
diff --git a/velox/exec/tests/PlanNodeToStringTest.cpp b/velox/exec/tests/PlanNodeToStringTest.cpp
index 87182a126afc2..59485b89478f2 100644
--- a/velox/exec/tests/PlanNodeToStringTest.cpp
+++ b/velox/exec/tests/PlanNodeToStringTest.cpp
@@ -49,37 +49,42 @@ class PlanNodeToStringTest : public testing::Test, public test::VectorTestBase {
                 .planNode();
   }
 
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   RowVectorPtr data_;
   core::PlanNodePtr plan_;
 };
 
 TEST_F(PlanNodeToStringTest, basic) {
-  ASSERT_EQ("-- Project\n", plan_->toString());
+  ASSERT_EQ("-- Project[4]\n", plan_->toString());
 }
 
 TEST_F(PlanNodeToStringTest, recursive) {
   ASSERT_EQ(
-      "-- Project\n"
-      "  -- Filter\n"
-      "    -- Project\n"
-      "      -- Filter\n"
-      "        -- Values\n",
+      "-- Project[4]\n"
+      "  -- Filter[3]\n"
+      "    -- Project[2]\n"
+      "      -- Filter[1]\n"
+      "        -- Values[0]\n",
       plan_->toString(false, true));
 }
 
 TEST_F(PlanNodeToStringTest, detailed) {
   ASSERT_EQ(
-      "-- Project[expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n",
+      "-- Project[4][expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n",
       plan_->toString(true, false));
 }
 
 TEST_F(PlanNodeToStringTest, recursiveAndDetailed) {
   ASSERT_EQ(
-      "-- Project[expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n"
-      "  -- Filter[expression: lt(mod(cast ROW[\"out1\"] as BIGINT,10),8)] -> out1:SMALLINT, out2:BIGINT\n"
-      "    -- Project[expressions: (out1:SMALLINT, ROW[\"c0\"]), (out2:BIGINT, plus(mod(cast ROW[\"c0\"] as BIGINT,100),mod(cast ROW[\"c1\"] as BIGINT,50)))] -> out1:SMALLINT, out2:BIGINT\n"
-      "      -- Filter[expression: lt(mod(cast ROW[\"c0\"] as BIGINT,10),9)] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n"
-      "        -- Values[5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- Project[4][expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n"
+      "  -- Filter[3][expression: lt(mod(cast ROW[\"out1\"] as BIGINT,10),8)] -> out1:SMALLINT, out2:BIGINT\n"
+      "    -- Project[2][expressions: (out1:SMALLINT, ROW[\"c0\"]), (out2:BIGINT, plus(mod(cast ROW[\"c0\"] as BIGINT,100),mod(cast ROW[\"c1\"] as BIGINT,50)))] -> out1:SMALLINT, out2:BIGINT\n"
+      "      -- Filter[1][expression: lt(mod(cast ROW[\"c0\"] as BIGINT,10),9)] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n"
+      "        -- Values[0][5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan_->toString(true, true));
 }
 
@@ -91,38 +96,38 @@ TEST_F(PlanNodeToStringTest, withContext) {
   };
 
   ASSERT_EQ(
-      "-- Project\n"
+      "-- Project[4]\n"
       "   Context for 4\n",
       plan_->toString(false, false, addContext));
 
   ASSERT_EQ(
-      "-- Project[expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n"
+      "-- Project[4][expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n"
       "   Context for 4\n",
       plan_->toString(true, false, addContext));
 
   ASSERT_EQ(
-      "-- Project\n"
+      "-- Project[4]\n"
       "   Context for 4\n"
-      "  -- Filter\n"
+      "  -- Filter[3]\n"
       "     Context for 3\n"
-      "    -- Project\n"
+      "    -- Project[2]\n"
       "       Context for 2\n"
-      "      -- Filter\n"
+      "      -- Filter[1]\n"
       "         Context for 1\n"
-      "        -- Values\n"
+      "        -- Values[0]\n"
       "           Context for 0\n",
       plan_->toString(false, true, addContext));
 
   ASSERT_EQ(
-      "-- Project[expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n"
+      "-- Project[4][expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n"
       "   Context for 4\n"
-      "  -- Filter[expression: lt(mod(cast ROW[\"out1\"] as BIGINT,10),8)] -> out1:SMALLINT, out2:BIGINT\n"
+      "  -- Filter[3][expression: lt(mod(cast ROW[\"out1\"] as BIGINT,10),8)] -> out1:SMALLINT, out2:BIGINT\n"
       "     Context for 3\n"
-      "    -- Project[expressions: (out1:SMALLINT, ROW[\"c0\"]), (out2:BIGINT, plus(mod(cast ROW[\"c0\"] as BIGINT,100),mod(cast ROW[\"c1\"] as BIGINT,50)))] -> out1:SMALLINT, out2:BIGINT\n"
+      "    -- Project[2][expressions: (out1:SMALLINT, ROW[\"c0\"]), (out2:BIGINT, plus(mod(cast ROW[\"c0\"] as BIGINT,100),mod(cast ROW[\"c1\"] as BIGINT,50)))] -> out1:SMALLINT, out2:BIGINT\n"
       "       Context for 2\n"
-      "      -- Filter[expression: lt(mod(cast ROW[\"c0\"] as BIGINT,10),9)] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n"
+      "      -- Filter[1][expression: lt(mod(cast ROW[\"c0\"] as BIGINT,10),9)] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n"
       "         Context for 1\n"
-      "        -- Values[5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n"
+      "        -- Values[0][5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n"
       "           Context for 0\n",
       plan_->toString(true, true, addContext));
 }
@@ -136,13 +141,13 @@ TEST_F(PlanNodeToStringTest, withMultiLineContext) {
   };
 
   ASSERT_EQ(
-      "-- Project\n"
+      "-- Project[4]\n"
       "   Context for 4: line 1\n"
       "   Context for 4: line 2\n",
       plan_->toString(false, false, addContext));
 
   ASSERT_EQ(
-      "-- Project[expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n"
+      "-- Project[4][expressions: (out3:BIGINT, plus(cast ROW[\"out1\"] as BIGINT,10))] -> out3:BIGINT\n"
       "   Context for 4: line 1\n"
       "   Context for 4: line 2\n",
       plan_->toString(true, false, addContext));
@@ -151,30 +156,30 @@ TEST_F(PlanNodeToStringTest, withMultiLineContext) {
 TEST_F(PlanNodeToStringTest, values) {
   auto plan = PlanBuilder().values({data_}).planNode();
 
-  ASSERT_EQ("-- Values\n", plan->toString());
+  ASSERT_EQ("-- Values[0]\n", plan->toString());
   ASSERT_EQ(
-      "-- Values[5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- Values[0][5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder().values({data_}, true).planNode();
 
-  ASSERT_EQ("-- Values\n", plan->toString());
+  ASSERT_EQ("-- Values[0]\n", plan->toString());
   ASSERT_EQ(
-      "-- Values[5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- Values[0][5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder().values({data_}, false, 10).planNode();
 
-  ASSERT_EQ("-- Values\n", plan->toString());
+  ASSERT_EQ("-- Values[0]\n", plan->toString());
   ASSERT_EQ(
-      "-- Values[5 rows in 1 vectors, repeat 10 times] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- Values[0][5 rows in 1 vectors, repeat 10 times] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder().values({data_}, true, 10).planNode();
 
-  ASSERT_EQ("-- Values\n", plan->toString());
+  ASSERT_EQ("-- Values[0]\n", plan->toString());
   ASSERT_EQ(
-      "-- Values[5 rows in 1 vectors, repeat 10 times] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- Values[0][5 rows in 1 vectors, repeat 10 times] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -190,9 +195,9 @@ TEST_F(PlanNodeToStringTest, aggregation) {
                        "count(distinct c1)"})
                   .planNode();
 
-  ASSERT_EQ("-- Aggregation\n", plan->toString());
+  ASSERT_EQ("-- Aggregation[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Aggregation[PARTIAL a := sum(ROW[\"c0\"]), b := avg(ROW[\"c1\"]), c := min(ROW[\"c2\"]), a3 := count(ROW[\"c1\"]) distinct] "
+      "-- Aggregation[1][PARTIAL a := sum(ROW[\"c0\"]), b := avg(ROW[\"c1\"]), c := min(ROW[\"c2\"]), a3 := count(ROW[\"c1\"]) distinct] "
       "-> a:BIGINT, b:ROW<\"\":DOUBLE,\"\":BIGINT>, c:BIGINT, a3:BIGINT\n",
       plan->toString(true, false));
 
@@ -209,9 +214,9 @@ TEST_F(PlanNodeToStringTest, aggregation) {
                  {"m0", "", "m2"})
              .planNode();
 
-  ASSERT_EQ("-- Aggregation\n", plan->toString());
+  ASSERT_EQ("-- Aggregation[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Aggregation[PARTIAL a := sum(ROW[\"c0\"]) mask: m0, b := avg(ROW[\"c1\"]), c := min(ROW[\"c2\"]) mask: m2] -> a:BIGINT, b:ROW<\"\":DOUBLE,\"\":BIGINT>, c:BIGINT\n",
+      "-- Aggregation[1][PARTIAL a := sum(ROW[\"c0\"]) mask: m0, b := avg(ROW[\"c1\"]), c := min(ROW[\"c2\"]) mask: m2] -> a:BIGINT, b:ROW<\"\":DOUBLE,\"\":BIGINT>, c:BIGINT\n",
       plan->toString(true, false));
 
   // Group-by aggregation.
@@ -221,9 +226,9 @@ TEST_F(PlanNodeToStringTest, aggregation) {
                  {"c0"}, {"sum(c1) AS a", "avg(c2) AS b", "count(distinct c2)"})
              .planNode();
 
-  ASSERT_EQ("-- Aggregation\n", plan->toString());
+  ASSERT_EQ("-- Aggregation[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Aggregation[SINGLE [c0] a := sum(ROW[\"c1\"]), b := avg(ROW[\"c2\"]), a2 := count(ROW[\"c2\"]) distinct] "
+      "-- Aggregation[1][SINGLE [c0] a := sum(ROW[\"c1\"]), b := avg(ROW[\"c2\"]), a2 := count(ROW[\"c2\"]) distinct] "
       "-> c0:SMALLINT, a:BIGINT, b:DOUBLE, a2:BIGINT\n",
       plan->toString(true, false));
 
@@ -234,9 +239,9 @@ TEST_F(PlanNodeToStringTest, aggregation) {
                  {"c0"}, {"sum(c1) AS a", "avg(c2) AS b"}, {"m1", "m2"})
              .planNode();
 
-  ASSERT_EQ("-- Aggregation\n", plan->toString());
+  ASSERT_EQ("-- Aggregation[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Aggregation[SINGLE [c0] a := sum(ROW[\"c1\"]) mask: m1, b := avg(ROW[\"c2\"]) mask: m2] -> c0:BIGINT, a:BIGINT, b:DOUBLE\n",
+      "-- Aggregation[1][SINGLE [c0] a := sum(ROW[\"c1\"]) mask: m1, b := avg(ROW[\"c2\"]) mask: m2] -> c0:BIGINT, a:BIGINT, b:DOUBLE\n",
       plan->toString(true, false));
 
   // Aggregation over sorted inputs.
@@ -245,9 +250,52 @@ TEST_F(PlanNodeToStringTest, aggregation) {
              .singleAggregation({"c0"}, {"array_agg(c1 ORDER BY c2 DESC)"})
              .planNode();
 
-  ASSERT_EQ("-- Aggregation\n", plan->toString());
+  ASSERT_EQ("-- Aggregation[1]\n", plan->toString());
+  ASSERT_EQ(
+      "-- Aggregation[1][SINGLE [c0] a0 := array_agg(ROW[\"c1\"]) ORDER BY c2 DESC NULLS LAST] -> c0:BIGINT, a0:ARRAY<INTEGER>\n",
+      plan->toString(true, false));
+
+  // Aggregation over GroupId with global grouping sets.
+  plan = PlanBuilder()
+             .values({data_})
+             .groupId({"c0"}, {{"c0"}, {}}, {"c1"})
+             .singleAggregation({"c0", "group_id"}, {"sum(c1) as sum_c1"}, {})
+             .planNode();
+  ASSERT_EQ("-- Aggregation[2]\n", plan->toString());
+  ASSERT_EQ(
+      "-- Aggregation[2][SINGLE [c0, group_id] sum_c1 := sum(ROW[\"c1\"]) global group IDs: [ 1 ] Group Id key: group_id] -> c0:SMALLINT, group_id:BIGINT, sum_c1:BIGINT\n",
+      plan->toString(true, false));
+
+  // Aggregation over GroupId with > 1 global grouping sets.
+  plan = PlanBuilder()
+             .values({data_})
+             .groupId({"c0"}, {{"c0"}, {}, {}}, {"c1"})
+             .singleAggregation({"c0", "group_id"}, {"sum(c1) as sum_c1"}, {})
+             .planNode();
+  ASSERT_EQ("-- Aggregation[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- Aggregation[SINGLE [c0] a0 := array_agg(ROW[\"c1\"]) ORDER BY c2 DESC NULLS LAST] -> c0:BIGINT, a0:ARRAY<INTEGER>\n",
+      "-- Aggregation[2][SINGLE [c0, group_id] sum_c1 := sum(ROW[\"c1\"]) global group IDs: [ 1, 2 ] Group Id key: group_id] -> c0:SMALLINT, group_id:BIGINT, sum_c1:BIGINT\n",
+      plan->toString(true, false));
+
+  plan = PlanBuilder()
+             .values({data_})
+             .partialStreamingAggregation({"c0"}, {"sum(c1) AS a"})
+             .planNode();
+  ASSERT_EQ(
+      "-- Aggregation[1][PARTIAL STREAMING [c0] a := sum(ROW[\"c1\"])] -> c0:SMALLINT, a:BIGINT\n",
+      plan->toString(true, false));
+}
+
+TEST_F(PlanNodeToStringTest, expand) {
+  auto plan = PlanBuilder()
+                  .values({data_})
+                  .expand(
+                      {{"c0", "null::integer as c1", "c2", "0 as gid"},
+                       {"null as c0", "c1", "c2", "1 as gid"}})
+                  .planNode();
+  ASSERT_EQ("-- Expand[1]\n", plan->toString());
+  ASSERT_EQ(
+      "-- Expand[1][[c0, null, c2, 0], [null, c1, c2, 1]] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT, gid:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -256,27 +304,27 @@ TEST_F(PlanNodeToStringTest, groupId) {
                   .values({data_})
                   .groupId({"c0", "c1"}, {{"c0"}, {"c1"}}, {"c2"})
                   .planNode();
-  ASSERT_EQ("-- GroupId\n", plan->toString());
+  ASSERT_EQ("-- GroupId[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- GroupId[[c0], [c1]] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT, group_id:BIGINT\n",
+      "-- GroupId[1][[c0], [c1]] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT, group_id:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
              .values({data_})
              .groupId({"c0", "c1"}, {{"c0", "c1"}, {"c1"}}, {"c2"}, "gid")
              .planNode();
-  ASSERT_EQ("-- GroupId\n", plan->toString());
+  ASSERT_EQ("-- GroupId[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- GroupId[[c0, c1], [c1]] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT, gid:BIGINT\n",
+      "-- GroupId[1][[c0, c1], [c1]] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT, gid:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
              .values({data_})
              .groupId({"c0", "c0 as c1"}, {{"c0", "c1"}, {"c1"}}, {"c2"}, "gid")
              .planNode();
-  ASSERT_EQ("-- GroupId\n", plan->toString());
+  ASSERT_EQ("-- GroupId[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- GroupId[[c0, c1], [c1]] -> c0:SMALLINT, c1:SMALLINT, c2:BIGINT, gid:BIGINT\n",
+      "-- GroupId[1][[c0, c1], [c1]] -> c0:SMALLINT, c1:SMALLINT, c2:BIGINT, gid:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -295,9 +343,9 @@ TEST_F(PlanNodeToStringTest, hashJoin) {
                       {"t_c0", "t_c1", "u_c1"})
                   .planNode();
 
-  ASSERT_EQ("-- HashJoin\n", plan->toString());
+  ASSERT_EQ("-- HashJoin[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- HashJoin[INNER t_c0=u_c0] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
+      "-- HashJoin[2][INNER t_c0=u_c0] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -315,9 +363,9 @@ TEST_F(PlanNodeToStringTest, hashJoin) {
                  core::JoinType::kLeft)
              .planNode();
 
-  ASSERT_EQ("-- HashJoin\n", plan->toString());
+  ASSERT_EQ("-- HashJoin[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- HashJoin[LEFT t_c0=u_c0, filter: gt(ROW[\"t_c1\"],ROW[\"u_c1\"])] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
+      "-- HashJoin[2][LEFT t_c0=u_c0, filter: gt(ROW[\"t_c1\"],ROW[\"u_c1\"])] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -336,9 +384,9 @@ TEST_F(PlanNodeToStringTest, hashJoin) {
                  true /*nullAware*/)
              .planNode();
 
-  ASSERT_EQ("-- HashJoin\n", plan->toString());
+  ASSERT_EQ("-- HashJoin[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- HashJoin[ANTI t_c0=u_c0, null aware] -> t_c0:SMALLINT, t_c1:INTEGER\n",
+      "-- HashJoin[2][ANTI t_c0=u_c0, null aware] -> t_c0:SMALLINT, t_c1:INTEGER\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -357,9 +405,9 @@ TEST_F(PlanNodeToStringTest, hashJoin) {
                  false /*nullAware*/)
              .planNode();
 
-  ASSERT_EQ("-- HashJoin\n", plan->toString());
+  ASSERT_EQ("-- HashJoin[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- HashJoin[ANTI t_c0=u_c0] -> t_c0:SMALLINT, t_c1:INTEGER\n",
+      "-- HashJoin[2][ANTI t_c0=u_c0] -> t_c0:SMALLINT, t_c1:INTEGER\n",
       plan->toString(true, false));
 }
 
@@ -378,9 +426,9 @@ TEST_F(PlanNodeToStringTest, mergeJoin) {
                       {"t_c0", "t_c1", "u_c1"})
                   .planNode();
 
-  ASSERT_EQ("-- MergeJoin\n", plan->toString());
+  ASSERT_EQ("-- MergeJoin[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- MergeJoin[INNER t_c0=u_c0] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
+      "-- MergeJoin[2][INNER t_c0=u_c0] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -398,9 +446,9 @@ TEST_F(PlanNodeToStringTest, mergeJoin) {
                  core::JoinType::kLeft)
              .planNode();
 
-  ASSERT_EQ("-- MergeJoin\n", plan->toString());
+  ASSERT_EQ("-- MergeJoin[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- MergeJoin[LEFT t_c0=u_c0, filter: gt(ROW[\"t_c1\"],ROW[\"u_c1\"])] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
+      "-- MergeJoin[2][LEFT t_c0=u_c0, filter: gt(ROW[\"t_c1\"],ROW[\"u_c1\"])] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
       plan->toString(true, false));
 }
 
@@ -416,9 +464,9 @@ TEST_F(PlanNodeToStringTest, nestedLoopJoin) {
                       {"t_c0", "t_c1", "u_c1"})
                   .planNode();
 
-  ASSERT_EQ("-- NestedLoopJoin\n", plan->toString());
+  ASSERT_EQ("-- NestedLoopJoin[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- NestedLoopJoin[INNER] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
+      "-- NestedLoopJoin[2][INNER] -> t_c0:SMALLINT, t_c1:INTEGER, u_c1:INTEGER\n",
       plan->toString(true, false));
 }
 
@@ -428,9 +476,9 @@ TEST_F(PlanNodeToStringTest, orderBy) {
                   .orderBy({"c1 ASC NULLS FIRST"}, true)
                   .planNode();
 
-  ASSERT_EQ("-- OrderBy\n", plan->toString());
+  ASSERT_EQ("-- OrderBy[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- OrderBy[PARTIAL c1 ASC NULLS FIRST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- OrderBy[1][PARTIAL c1 ASC NULLS FIRST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -438,25 +486,25 @@ TEST_F(PlanNodeToStringTest, orderBy) {
              .orderBy({"c1 ASC NULLS FIRST", "c0 DESC NULLS LAST"}, false)
              .planNode();
 
-  ASSERT_EQ("-- OrderBy\n", plan->toString());
+  ASSERT_EQ("-- OrderBy[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- OrderBy[c1 ASC NULLS FIRST, c0 DESC NULLS LAST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- OrderBy[1][c1 ASC NULLS FIRST, c0 DESC NULLS LAST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 }
 
 TEST_F(PlanNodeToStringTest, limit) {
   auto plan = PlanBuilder().values({data_}).limit(0, 10, true).planNode();
 
-  ASSERT_EQ("-- Limit\n", plan->toString());
+  ASSERT_EQ("-- Limit[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Limit[PARTIAL 10] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- Limit[1][PARTIAL 10] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder().values({data_}).limit(7, 12, false).planNode();
 
-  ASSERT_EQ("-- Limit\n", plan->toString());
+  ASSERT_EQ("-- Limit[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Limit[12 offset 7] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- Limit[1][12 offset 7] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -466,9 +514,9 @@ TEST_F(PlanNodeToStringTest, topN) {
                   .topN({"c0 NULLS FIRST"}, 10, true)
                   .planNode();
 
-  ASSERT_EQ("-- TopN\n", plan->toString());
+  ASSERT_EQ("-- TopN[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- TopN[PARTIAL 10 c0 ASC NULLS FIRST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- TopN[1][PARTIAL 10 c0 ASC NULLS FIRST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -476,18 +524,18 @@ TEST_F(PlanNodeToStringTest, topN) {
              .topN({"c1 NULLS FIRST", "c0 DESC"}, 10, false)
              .planNode();
 
-  ASSERT_EQ("-- TopN\n", plan->toString());
+  ASSERT_EQ("-- TopN[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- TopN[10 c1 ASC NULLS FIRST, c0 DESC NULLS LAST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- TopN[1][10 c1 ASC NULLS FIRST, c0 DESC NULLS LAST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 }
 
 TEST_F(PlanNodeToStringTest, enforceSingleRow) {
   auto plan = PlanBuilder().values({data_}).enforceSingleRow().planNode();
 
-  ASSERT_EQ("-- EnforceSingleRow\n", plan->toString());
+  ASSERT_EQ("-- EnforceSingleRow[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- EnforceSingleRow[] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- EnforceSingleRow[1][] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -495,9 +543,9 @@ TEST_F(PlanNodeToStringTest, assignUniqueId) {
   auto plan =
       PlanBuilder().values({data_}).assignUniqueId("unique_id", 123).planNode();
 
-  ASSERT_EQ("-- AssignUniqueId\n", plan->toString());
+  ASSERT_EQ("-- AssignUniqueId[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- AssignUniqueId[] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT, unique_id:BIGINT\n",
+      "-- AssignUniqueId[1][] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT, unique_id:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -508,18 +556,18 @@ TEST_F(PlanNodeToStringTest, unnest) {
                   .unnest({"c1"}, {"a0"})
                   .planNode();
 
-  ASSERT_EQ("-- Unnest\n", plan->toString());
+  ASSERT_EQ("-- Unnest[2]\n", plan->toString());
   ASSERT_EQ(
-      "-- Unnest[a0] -> c1:INTEGER, a0_e:SMALLINT\n",
+      "-- Unnest[2][a0] -> c1:INTEGER, a0_e:SMALLINT\n",
       plan->toString(true, false));
 }
 
 TEST_F(PlanNodeToStringTest, localPartition) {
   auto plan = PlanBuilder().values({data_}).localPartition({"c0"}).planNode();
 
-  ASSERT_EQ("-- LocalPartition\n", plan->toString());
+  ASSERT_EQ("-- LocalPartition[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- LocalPartition[REPARTITION HASH(c0)] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- LocalPartition[1][REPARTITION HASH(c0)] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -527,16 +575,16 @@ TEST_F(PlanNodeToStringTest, localPartition) {
              .localPartition(std::vector<std::string>{})
              .planNode();
 
-  ASSERT_EQ("-- LocalPartition\n", plan->toString());
+  ASSERT_EQ("-- LocalPartition[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- LocalPartition[GATHER] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- LocalPartition[1][GATHER] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder().values({data_}).localPartitionRoundRobin().planNode();
 
-  ASSERT_EQ("-- LocalPartition\n", plan->toString());
+  ASSERT_EQ("-- LocalPartition[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- LocalPartition[REPARTITION ROUND ROBIN] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- LocalPartition[1][REPARTITION ROUND ROBIN] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -544,23 +592,23 @@ TEST_F(PlanNodeToStringTest, partitionedOutput) {
   auto plan =
       PlanBuilder().values({data_}).partitionedOutput({"c0"}, 4).planNode();
 
-  ASSERT_EQ("-- PartitionedOutput\n", plan->toString());
+  ASSERT_EQ("-- PartitionedOutput[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- PartitionedOutput[partitionFunction: HASH(c0) with 4 partitions] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- PartitionedOutput[1][partitionFunction: HASH(c0) with 4 partitions] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder().values({data_}).partitionedOutputBroadcast().planNode();
 
-  ASSERT_EQ("-- PartitionedOutput\n", plan->toString());
+  ASSERT_EQ("-- PartitionedOutput[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- PartitionedOutput[BROADCAST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- PartitionedOutput[1][BROADCAST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder().values({data_}).partitionedOutput({}, 1).planNode();
 
-  ASSERT_EQ("-- PartitionedOutput\n", plan->toString());
+  ASSERT_EQ("-- PartitionedOutput[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- PartitionedOutput[SINGLE] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- PartitionedOutput[1][SINGLE] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -568,9 +616,9 @@ TEST_F(PlanNodeToStringTest, partitionedOutput) {
              .partitionedOutput({"c1", "c2"}, 5, true)
              .planNode();
 
-  ASSERT_EQ("-- PartitionedOutput\n", plan->toString());
+  ASSERT_EQ("-- PartitionedOutput[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- PartitionedOutput[partitionFunction: HASH(c1, c2) with 5 partitions replicate nulls and any] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- PartitionedOutput[1][partitionFunction: HASH(c1, c2) with 5 partitions replicate nulls and any] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   auto hiveSpec = std::make_shared<connector::hive::HivePartitionFunctionSpec>(
@@ -583,9 +631,9 @@ TEST_F(PlanNodeToStringTest, partitionedOutput) {
              .values({data_})
              .partitionedOutput({"c1", "c2"}, 2, false, hiveSpec)
              .planNode();
-  ASSERT_EQ("-- PartitionedOutput\n", plan->toString());
+  ASSERT_EQ("-- PartitionedOutput[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- PartitionedOutput[partitionFunction: HIVE((1, 2) buckets: 4) with 2 partitions] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- PartitionedOutput[1][partitionFunction: HIVE((1, 2) buckets: 4) with 2 partitions] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -596,9 +644,9 @@ TEST_F(PlanNodeToStringTest, localMerge) {
               {"c1 NULLS FIRST"}, {PlanBuilder().values({data_}).planNode()})
           .planNode();
 
-  ASSERT_EQ("-- LocalMerge\n", plan->toString());
+  ASSERT_EQ("-- LocalMerge[0]\n", plan->toString());
   ASSERT_EQ(
-      "-- LocalMerge[c1 ASC NULLS FIRST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- LocalMerge[0][c1 ASC NULLS FIRST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -607,9 +655,9 @@ TEST_F(PlanNodeToStringTest, localMerge) {
                  {PlanBuilder().values({data_}).planNode()})
              .planNode();
 
-  ASSERT_EQ("-- LocalMerge\n", plan->toString());
+  ASSERT_EQ("-- LocalMerge[0]\n", plan->toString());
   ASSERT_EQ(
-      "-- LocalMerge[c1 ASC NULLS FIRST, c0 DESC NULLS LAST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
+      "-- LocalMerge[0][c1 ASC NULLS FIRST, c0 DESC NULLS LAST] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n",
       plan->toString(true, false));
 }
 
@@ -617,9 +665,9 @@ TEST_F(PlanNodeToStringTest, exchange) {
   auto plan =
       PlanBuilder().exchange(ROW({"a", "b"}, {BIGINT(), VARCHAR()})).planNode();
 
-  ASSERT_EQ("-- Exchange\n", plan->toString());
+  ASSERT_EQ("-- Exchange[0]\n", plan->toString());
   ASSERT_EQ(
-      "-- Exchange[] -> a:BIGINT, b:VARCHAR\n", plan->toString(true, false));
+      "-- Exchange[0][] -> a:BIGINT, b:VARCHAR\n", plan->toString(true, false));
 }
 
 TEST_F(PlanNodeToStringTest, tableScan) {
@@ -636,9 +684,9 @@ TEST_F(PlanNodeToStringTest, tableScan) {
                         "comment NOT LIKE '%special%request%'")
                     .planNode();
 
-    ASSERT_EQ("-- TableScan\n", plan->toString());
+    ASSERT_EQ("-- TableScan[0]\n", plan->toString());
     const char* output =
-        "-- TableScan[table: hive_table, "
+        "-- TableScan[0][table: hive_table, "
         "range filters: [(discount, DoubleRange: [0.050000, 0.070000] no nulls), "
         "(quantity, DoubleRange: (-inf, 24.000000) no nulls), "
         "(shipdate, BytesRange: [1994-01-01, 1994-12-31] no nulls)], "
@@ -653,7 +701,7 @@ TEST_F(PlanNodeToStringTest, tableScan) {
             .planNode();
 
     ASSERT_EQ(
-        "-- TableScan[table: hive_table, remaining filter: (not(like(ROW[\"comment\"],\"%special%request%\")))] "
+        "-- TableScan[0][table: hive_table, remaining filter: (not(like(ROW[\"comment\"],\"%special%request%\")))] "
         "-> discount:DOUBLE, quantity:DOUBLE, shipdate:VARCHAR, comment:VARCHAR\n",
         plan->toString(true, false));
   }
@@ -670,7 +718,7 @@ TEST_F(PlanNodeToStringTest, decimalConstant) {
                   .planNode();
 
   ASSERT_EQ(
-      "-- Project[expressions: (a:VARCHAR, ROW[\"a\"]), (p1:DECIMAL(4, 3), 1.234)] -> a:VARCHAR, p1:DECIMAL(4, 3)\n",
+      "-- Project[1][expressions: (a:VARCHAR, ROW[\"a\"]), (p1:DECIMAL(4, 3), 1.234)] -> a:VARCHAR, p1:DECIMAL(4, 3)\n",
       plan->toString(true));
 }
 
@@ -681,7 +729,11 @@ TEST_F(PlanNodeToStringTest, window) {
           .returnType("BIGINT")
           .build(),
   };
-  exec::registerWindowFunction("window1", std::move(signatures), nullptr);
+  exec::registerWindowFunction(
+      "window1",
+      std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
+      nullptr);
 
   auto plan =
       PlanBuilder()
@@ -689,22 +741,34 @@ TEST_F(PlanNodeToStringTest, window) {
           .window({"window1(c) over (partition by a order by b "
                    "range between 10 preceding and unbounded following) AS d"})
           .planNode();
-  ASSERT_EQ("-- Window\n", plan->toString());
+  ASSERT_EQ("-- Window[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Window[partition by [a] order by [b ASC NULLS LAST] "
-      "d := window1(ROW[\"c\"]) RANGE between 10 PRECEDING and UNBOUNDED FOLLOWING inputsSorted [0]] "
+      "-- Window[1][partition by [a] order by [b ASC NULLS LAST] "
+      "d := window1(ROW[\"c\"]) RANGE between 10 PRECEDING and UNBOUNDED FOLLOWING] "
       "-> a:VARCHAR, b:BIGINT, c:BIGINT, d:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
              .tableScan(ROW({"a", "b", "c"}, {VARCHAR(), BIGINT(), BIGINT()}))
              .window({"window1(c) over (partition by a "
+                      "rows between current row and b following)"})
+             .planNode();
+  ASSERT_EQ("-- Window[1]\n", plan->toString());
+  ASSERT_EQ(
+      "-- Window[1][partition by [a] "
+      "w0 := window1(ROW[\"c\"]) ROWS between CURRENT ROW and b FOLLOWING] "
+      "-> a:VARCHAR, b:BIGINT, c:BIGINT, w0:BIGINT\n",
+      plan->toString(true, false));
+
+  plan = PlanBuilder()
+             .tableScan(ROW({"a", "b", "c"}, {VARCHAR(), BIGINT(), BIGINT()}))
+             .window({"window1(c) over (order by a "
                       "range between current row and b following)"})
              .planNode();
-  ASSERT_EQ("-- Window\n", plan->toString());
+  ASSERT_EQ("-- Window[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Window[partition by [a] order by [] "
-      "w0 := window1(ROW[\"c\"]) RANGE between CURRENT ROW and b FOLLOWING inputsSorted [0]] "
+      "-- Window[1][order by [a ASC NULLS LAST] "
+      "w0 := window1(ROW[\"c\"]) RANGE between CURRENT ROW and b FOLLOWING] "
       "-> a:VARCHAR, b:BIGINT, c:BIGINT, w0:BIGINT\n",
       plan->toString(true, false));
 
@@ -714,22 +778,22 @@ TEST_F(PlanNodeToStringTest, window) {
                  {"window1(c) over (partition by a order by b "
                   "range between 10 preceding and unbounded following) AS d"})
              .planNode();
-  ASSERT_EQ("-- Window\n", plan->toString());
+  ASSERT_EQ("-- Window[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Window[partition by [a] order by [b ASC NULLS LAST] "
-      "d := window1(ROW[\"c\"]) RANGE between 10 PRECEDING and UNBOUNDED FOLLOWING inputsSorted [1]] "
+      "-- Window[1][STREAMING partition by [a] order by [b ASC NULLS LAST] "
+      "d := window1(ROW[\"c\"]) RANGE between 10 PRECEDING and UNBOUNDED FOLLOWING] "
       "-> a:VARCHAR, b:BIGINT, c:BIGINT, d:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
              .tableScan(ROW({"a", "b", "c"}, {VARCHAR(), BIGINT(), BIGINT()}))
              .streamingWindow({"window1(c) over (partition by a "
-                               "range between current row and b following)"})
+                               "rows between current row and b following)"})
              .planNode();
-  ASSERT_EQ("-- Window\n", plan->toString());
+  ASSERT_EQ("-- Window[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- Window[partition by [a] order by [] "
-      "w0 := window1(ROW[\"c\"]) RANGE between CURRENT ROW and b FOLLOWING inputsSorted [1]] "
+      "-- Window[1][STREAMING partition by [a] "
+      "w0 := window1(ROW[\"c\"]) ROWS between CURRENT ROW and b FOLLOWING] "
       "-> a:VARCHAR, b:BIGINT, c:BIGINT, w0:BIGINT\n",
       plan->toString(true, false));
 }
@@ -739,19 +803,19 @@ TEST_F(PlanNodeToStringTest, rowNumber) {
   auto plan =
       PlanBuilder().tableScan(ROW({"a"}, {VARCHAR()})).rowNumber({}).planNode();
 
-  ASSERT_EQ("-- RowNumber\n", plan->toString());
+  ASSERT_EQ("-- RowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- RowNumber[] -> a:VARCHAR, row_number:BIGINT\n",
+      "-- RowNumber[1][] -> a:VARCHAR, row_number:BIGINT\n",
       plan->toString(true, false));
 
-  // Dont' emit row number.
+  // Don't emit row number.
   plan = PlanBuilder()
              .tableScan(ROW({"a"}, {VARCHAR()}))
              .rowNumber({}, std::nullopt, false)
              .planNode();
 
-  ASSERT_EQ("-- RowNumber\n", plan->toString());
-  ASSERT_EQ("-- RowNumber[] -> a:VARCHAR\n", plan->toString(true, false));
+  ASSERT_EQ("-- RowNumber[1]\n", plan->toString());
+  ASSERT_EQ("-- RowNumber[1][] -> a:VARCHAR\n", plan->toString(true, false));
 
   // Emit row number.
   plan = PlanBuilder()
@@ -759,9 +823,9 @@ TEST_F(PlanNodeToStringTest, rowNumber) {
              .rowNumber({"a", "b"})
              .planNode();
 
-  ASSERT_EQ("-- RowNumber\n", plan->toString());
+  ASSERT_EQ("-- RowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- RowNumber[partition by (a, b)] -> a:BIGINT, b:VARCHAR, row_number:BIGINT\n",
+      "-- RowNumber[1][partition by (a, b)] -> a:BIGINT, b:VARCHAR, row_number:BIGINT\n",
       plan->toString(true, false));
 
   // Don't emit row number.
@@ -770,9 +834,9 @@ TEST_F(PlanNodeToStringTest, rowNumber) {
              .rowNumber({"a", "b"}, std::nullopt, false)
              .planNode();
 
-  ASSERT_EQ("-- RowNumber\n", plan->toString());
+  ASSERT_EQ("-- RowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- RowNumber[partition by (a, b)] -> a:BIGINT, b:VARCHAR\n",
+      "-- RowNumber[1][partition by (a, b)] -> a:BIGINT, b:VARCHAR\n",
       plan->toString(true, false));
 
   // Emit row number.
@@ -781,9 +845,9 @@ TEST_F(PlanNodeToStringTest, rowNumber) {
              .rowNumber({"b"}, 10)
              .planNode();
 
-  ASSERT_EQ("-- RowNumber\n", plan->toString());
+  ASSERT_EQ("-- RowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- RowNumber[partition by (b) limit 10] -> a:BIGINT, b:VARCHAR, row_number:BIGINT\n",
+      "-- RowNumber[1][partition by (b) limit 10] -> a:BIGINT, b:VARCHAR, row_number:BIGINT\n",
       plan->toString(true, false));
 
   // Don't emit row number.
@@ -792,9 +856,9 @@ TEST_F(PlanNodeToStringTest, rowNumber) {
              .rowNumber({"b"}, 10, false)
              .planNode();
 
-  ASSERT_EQ("-- RowNumber\n", plan->toString());
+  ASSERT_EQ("-- RowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- RowNumber[partition by (b) limit 10] -> a:BIGINT, b:VARCHAR\n",
+      "-- RowNumber[1][partition by (b) limit 10] -> a:BIGINT, b:VARCHAR\n",
       plan->toString(true, false));
 }
 
@@ -805,9 +869,9 @@ TEST_F(PlanNodeToStringTest, topNRowNumber) {
                   .topNRowNumber({}, {"a DESC"}, 10, false)
                   .planNode();
 
-  ASSERT_EQ("-- TopNRowNumber\n", plan->toString());
+  ASSERT_EQ("-- TopNRowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- TopNRowNumber[order by (a DESC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR\n",
+      "-- TopNRowNumber[1][order by (a DESC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -815,9 +879,9 @@ TEST_F(PlanNodeToStringTest, topNRowNumber) {
              .topNRowNumber({}, {"a DESC"}, 10, true)
              .planNode();
 
-  ASSERT_EQ("-- TopNRowNumber\n", plan->toString());
+  ASSERT_EQ("-- TopNRowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- TopNRowNumber[order by (a DESC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR, row_number:BIGINT\n",
+      "-- TopNRowNumber[1][order by (a DESC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR, row_number:BIGINT\n",
       plan->toString(true, false));
 
   plan = PlanBuilder()
@@ -825,9 +889,9 @@ TEST_F(PlanNodeToStringTest, topNRowNumber) {
              .topNRowNumber({"a"}, {"b"}, 10, false)
              .planNode();
 
-  ASSERT_EQ("-- TopNRowNumber\n", plan->toString());
+  ASSERT_EQ("-- TopNRowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- TopNRowNumber[partition by (a) order by (b ASC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR\n",
+      "-- TopNRowNumber[1][partition by (a) order by (b ASC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR\n",
       plan->toString(true, false));
 }
 
@@ -837,8 +901,8 @@ TEST_F(PlanNodeToStringTest, markDistinct) {
           .tableScan(ROW({"a", "b", "c"}, {VARCHAR(), BIGINT(), BIGINT()}))
           .markDistinct("marker", {"a", "b"})
           .planNode();
-  ASSERT_EQ("-- MarkDistinct\n", op->toString());
+  ASSERT_EQ("-- MarkDistinct[1]\n", op->toString());
   ASSERT_EQ(
-      "-- MarkDistinct[a, b] -> a:VARCHAR, b:BIGINT, c:BIGINT, marker:BOOLEAN\n",
+      "-- MarkDistinct[1][a, b] -> a:VARCHAR, b:BIGINT, c:BIGINT, marker:BOOLEAN\n",
       op->toString(true, false));
 }
diff --git a/velox/exec/tests/PrefixSortTest.cpp b/velox/exec/tests/PrefixSortTest.cpp
new file mode 100644
index 0000000000000..13f3ccf96fbf1
--- /dev/null
+++ b/velox/exec/tests/PrefixSortTest.cpp
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/exec/PrefixSort.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+
+namespace facebook::velox::exec::prefixsort::test {
+namespace {
+
+class PrefixSortTest : public exec::test::OperatorTestBase {
+ protected:
+  std::vector<char*>
+  storeRows(int numRows, const RowVectorPtr& sortedRows, RowContainer* data);
+
+  static constexpr CompareFlags kAsc{
+      true,
+      true,
+      false,
+      CompareFlags::NullHandlingMode::kNullAsValue};
+
+  static constexpr CompareFlags kDesc{
+      true,
+      false,
+      false,
+      CompareFlags::NullHandlingMode::kNullAsValue};
+
+  void testPrefixSort(
+      const std::vector<CompareFlags>& compareFlags,
+      const RowVectorPtr& data) {
+    const auto numRows = data->size();
+    const auto expectedResult =
+        generateExpectedResult(compareFlags, numRows, data);
+
+    const auto rowType = asRowType(data->type());
+
+    // Store data in a RowContainer.
+    const std::vector<TypePtr> keyTypes{
+        rowType->children().begin(),
+        rowType->children().begin() + compareFlags.size()};
+    const std::vector<TypePtr> payloadTypes{
+        rowType->children().begin() + compareFlags.size(),
+        rowType->children().end()};
+
+    RowContainer rowContainer(keyTypes, payloadTypes, pool_.get());
+    std::vector<char*> rows = storeRows(numRows, data, &rowContainer);
+
+    // Use PrefixSort to sort rows.
+    PrefixSort::sort(
+        rows,
+        pool_.get(),
+        &rowContainer,
+        compareFlags,
+        common::PrefixSortConfig{
+            1024,
+            // Set threshold to 0 to enable prefix-sort in small dataset.
+            0});
+
+    // Extract data from the RowContainer in order.
+    const RowVectorPtr actual =
+        BaseVector::create<RowVector>(rowType, numRows, pool_.get());
+    for (int column = 0; column < compareFlags.size(); ++column) {
+      rowContainer.extractColumn(
+          rows.data(), numRows, column, actual->childAt(column));
+    }
+
+    velox::test::assertEqualVectors(actual, expectedResult);
+  }
+
+ private:
+  // Use std::sort to generate expected result.
+  const RowVectorPtr generateExpectedResult(
+      const std::vector<CompareFlags>& compareFlags,
+      int numRows,
+      const RowVectorPtr& sortedRows);
+};
+
+std::vector<char*> PrefixSortTest::storeRows(
+    int numRows,
+    const RowVectorPtr& sortedRows,
+    RowContainer* data) {
+  std::vector<char*> rows;
+  SelectivityVector allRows(numRows);
+  rows.resize(numRows);
+  for (int row = 0; row < numRows; ++row) {
+    rows[row] = data->newRow();
+  }
+  for (int column = 0; column < sortedRows->childrenSize(); ++column) {
+    DecodedVector decoded(*sortedRows->childAt(column), allRows);
+    for (int i = 0; i < numRows; ++i) {
+      char* row = rows[i];
+      data->store(decoded, i, row, column);
+    }
+  }
+  return rows;
+}
+
+const RowVectorPtr PrefixSortTest::generateExpectedResult(
+    const std::vector<CompareFlags>& compareFlags,
+    int numRows,
+    const RowVectorPtr& sortedRows) {
+  const auto rowType = asRowType(sortedRows->type());
+  const int numKeys = compareFlags.size();
+  RowContainer rowContainer(rowType->children(), pool_.get());
+  std::vector<char*> rows = storeRows(numRows, sortedRows, &rowContainer);
+
+  std::sort(
+      rows.begin(), rows.end(), [&](const char* leftRow, const char* rightRow) {
+        for (auto i = 0; i < numKeys; ++i) {
+          if (auto result =
+                  rowContainer.compare(leftRow, rightRow, i, compareFlags[i])) {
+            return result < 0;
+          }
+        }
+        return false;
+      });
+
+  const RowVectorPtr result =
+      BaseVector::create<RowVector>(rowType, numRows, pool_.get());
+  for (int column = 0; column < compareFlags.size(); ++column) {
+    rowContainer.extractColumn(
+        rows.data(), numRows, column, result->childAt(column));
+  }
+  return result;
+}
+
+TEST_F(PrefixSortTest, singleKey) {
+  const int numRows = 5;
+  const int columnsSize = 7;
+
+  // Vectors without nulls.
+  const std::vector<VectorPtr> testData = {
+      makeFlatVector<int64_t>({5, 4, 3, 2, 1}),
+      makeFlatVector<int32_t>({5, 4, 3, 2, 1}),
+      makeFlatVector<int16_t>({5, 4, 3, 2, 1}),
+      makeFlatVector<float>({5.5, 4.4, 3.3, 2.2, 1.1}),
+      makeFlatVector<double>({5.5, 4.4, 3.3, 2.2, 1.1}),
+      makeFlatVector<Timestamp>(
+          {Timestamp(5, 5),
+           Timestamp(4, 4),
+           Timestamp(3, 3),
+           Timestamp(2, 2),
+           Timestamp(1, 1)}),
+      makeFlatVector<std::string_view>({"eee", "ddd", "ccc", "bbb", "aaa"})};
+  for (int i = 5; i < columnsSize; ++i) {
+    const auto data = makeRowVector({testData[i]});
+
+    testPrefixSort({kAsc}, data);
+    testPrefixSort({kDesc}, data);
+  }
+}
+
+TEST_F(PrefixSortTest, singleKeyWithNulls) {
+  const int numRows = 5;
+  const int columnsSize = 7;
+
+  Timestamp ts = {5, 5};
+  // Vectors with nulls.
+  const std::vector<VectorPtr> testData = {
+      makeNullableFlatVector<int64_t>({5, 4, std::nullopt, 2, 1}),
+      makeNullableFlatVector<int32_t>({5, 4, std::nullopt, 2, 1}),
+      makeNullableFlatVector<int16_t>({5, 4, std::nullopt, 2, 1}),
+      makeNullableFlatVector<float>({5.5, 4.4, std::nullopt, 2.2, 1.1}),
+      makeNullableFlatVector<double>({5.5, 4.4, std::nullopt, 2.2, 1.1}),
+      makeNullableFlatVector<Timestamp>(
+          {Timestamp(5, 5),
+           Timestamp(4, 4),
+           std::nullopt,
+           Timestamp(2, 2),
+           Timestamp(1, 1)}),
+      makeNullableFlatVector<std::string_view>(
+          {"eee", "ddd", std::nullopt, "bbb", "aaa"})};
+
+  for (int i = 5; i < columnsSize; ++i) {
+    const auto data = makeRowVector({testData[i]});
+
+    testPrefixSort({kAsc}, data);
+    testPrefixSort({kDesc}, data);
+  }
+}
+
+TEST_F(PrefixSortTest, multipleKeys) {
+  // Test all keys normalized : bigint, integer
+  {
+    const auto data = makeRowVector({
+        makeNullableFlatVector<int64_t>({5, 2, std::nullopt, 2, 1}),
+        makeNullableFlatVector<int32_t>({5, 4, std::nullopt, 2, 1}),
+    });
+
+    testPrefixSort({kAsc, kAsc}, data);
+    testPrefixSort({kDesc, kDesc}, data);
+  }
+
+  // Test keys with semi-normalized : bigint, varchar
+  {
+    const auto data = makeRowVector({
+        makeNullableFlatVector<int64_t>({5, 2, std::nullopt, 2, 1}),
+        makeNullableFlatVector<std::string_view>(
+            {"eee", "ddd", std::nullopt, "bbb", "aaa"}),
+    });
+
+    testPrefixSort({kAsc, kAsc}, data);
+    testPrefixSort({kDesc, kDesc}, data);
+  }
+}
+
+TEST_F(PrefixSortTest, fuzz) {
+  std::vector<TypePtr> keyTypes = {
+      INTEGER(),
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      BIGINT(),
+      HUGEINT(),
+      REAL(),
+      DOUBLE(),
+      TIMESTAMP(),
+      VARCHAR(),
+      VARBINARY()};
+  for (const auto& type : keyTypes) {
+    SCOPED_TRACE(fmt::format("{}", type->toString()));
+    VectorFuzzer fuzzer({.vectorSize = 10'240, .nullRatio = 0.1}, pool());
+    RowVectorPtr data = fuzzer.fuzzRow(ROW({type}));
+
+    testPrefixSort({kAsc}, data);
+    testPrefixSort({kDesc}, data);
+  }
+}
+
+TEST_F(PrefixSortTest, fuzzMulti) {
+  std::vector<TypePtr> keyTypes = {
+      INTEGER(),
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      BIGINT(),
+      HUGEINT(),
+      REAL(),
+      DOUBLE(),
+      TIMESTAMP(),
+      VARCHAR(),
+      VARBINARY()};
+
+  VectorFuzzer fuzzer({.vectorSize = 10'240, .nullRatio = 0.1}, pool());
+
+  for (auto i = 0; i < 20; ++i) {
+    auto type1 = fuzzer.randType(keyTypes, 0);
+    auto type2 = fuzzer.randType(keyTypes, 0);
+
+    SCOPED_TRACE(fmt::format("{}, {}", type1->toString(), type2->toString()));
+    auto data = fuzzer.fuzzRow(ROW({type1, type2, VARCHAR()}));
+
+    testPrefixSort({kAsc, kAsc}, data);
+    testPrefixSort({kDesc, kDesc}, data);
+  }
+}
+} // namespace
+} // namespace facebook::velox::exec::prefixsort::test
diff --git a/velox/exec/tests/PrestoQueryRunnerTest.cpp b/velox/exec/tests/PrestoQueryRunnerTest.cpp
new file mode 100644
index 0000000000000..cb17f6d773dbf
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerTest.cpp
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::exec::test {
+
+class PrestoQueryRunnerTest : public ::testing::Test,
+                              public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    velox::functions::prestosql::registerAllScalarFunctions();
+    facebook::velox::window::prestosql::registerAllWindowFunctions();
+    velox::aggregate::prestosql::registerAllAggregateFunctions();
+    velox::parse::registerTypeResolver();
+  }
+};
+
+// This test requires a Presto Coordinator running at localhost, so disable it
+// by default.
+TEST_F(PrestoQueryRunnerTest, DISABLED_basic) {
+  auto aggregatePool = rootPool_->addAggregateChild("basic");
+  auto queryRunner = std::make_unique<PrestoQueryRunner>(
+      aggregatePool.get(),
+      "http://127.0.0.1:8080",
+      "hive",
+      static_cast<std::chrono::milliseconds>(1000));
+
+  auto results = queryRunner->execute("SELECT count(*) FROM nation");
+  auto expected = makeRowVector({
+      makeConstant<int64_t>(25, 1),
+  });
+  velox::exec::test::assertEqualResults({expected}, {results});
+
+  results =
+      queryRunner->execute("SELECT regionkey, count(*) FROM nation GROUP BY 1");
+
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 2, 3, 4}),
+      makeFlatVector<int64_t>({5, 5, 5, 5, 5}),
+  });
+  velox::exec::test::assertEqualResults({expected}, {results});
+}
+
+// This test requires a Presto Coordinator running at localhost, so disable it
+// by default.
+TEST_F(PrestoQueryRunnerTest, DISABLED_fuzzer) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+      makeArrayVectorFromJson<int64_t>({
+          "[]",
+          "[1, 2, 3]",
+          "null",
+          "[1, 2, 3, 4]",
+      }),
+  });
+
+  auto plan = velox::exec::test::PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"min(c0)", "max(c0)", "set_agg(c1)"})
+                  .project({"a0", "a1", "array_sort(a2)"})
+                  .planNode();
+
+  auto aggregatePool = rootPool_->addAggregateChild("fuzzer");
+  auto queryRunner = std::make_unique<PrestoQueryRunner>(
+      aggregatePool.get(),
+      "http://127.0.0.1:8080",
+      "hive",
+      static_cast<std::chrono::milliseconds>(1000));
+  auto sql = queryRunner->toSql(plan);
+  ASSERT_TRUE(sql.has_value());
+
+  auto prestoResults = queryRunner->execute(
+      sql.value(),
+      {data},
+      ROW({"a", "b", "c"}, {BIGINT(), BIGINT(), ARRAY(BIGINT())}));
+
+  auto veloxResults =
+      velox::exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  velox::exec::test::assertEqualResults(
+      prestoResults, plan->outputType(), {veloxResults});
+}
+
+TEST_F(PrestoQueryRunnerTest, sortedAggregation) {
+  auto aggregatePool = rootPool_->addAggregateChild("sortedAggregation");
+  auto queryRunner = std::make_unique<PrestoQueryRunner>(
+      aggregatePool.get(),
+      "http://unused",
+      "hive",
+      static_cast<std::chrono::milliseconds>(1000));
+
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 1, 2, 1}),
+      makeFlatVector<int64_t>({2, 3, 4, 1, 4}),
+      makeFlatVector<int64_t>({5, 6, 7, 8, 3}),
+  });
+
+  auto plan =
+      velox::exec::test::PlanBuilder()
+          .values({data})
+          .singleAggregation({}, {"multimap_agg(c0, c1 order by c0 asc)"})
+          .planNode();
+
+  auto sql = queryRunner->toSql(plan);
+  ASSERT_TRUE(sql.has_value());
+
+  ASSERT_EQ(
+      "SELECT multimap_agg(c0, c1 ORDER BY c0 ASC NULLS LAST) as a0 FROM tmp",
+      sql.value());
+
+  // Plans with multiple order by's in the aggregate.
+
+  plan =
+      velox::exec::test::PlanBuilder()
+          .values({data})
+          .singleAggregation(
+              {},
+              {"multimap_agg(c0, c1 order by c1 asc nulls first, c0 desc nulls last, c2 asc nulls last)"})
+          .planNode();
+
+  sql = queryRunner->toSql(plan);
+  ASSERT_TRUE(sql.has_value());
+  ASSERT_EQ(
+      "SELECT multimap_agg(c0, c1 ORDER BY c1 ASC NULLS FIRST, c0 DESC NULLS LAST, c2 ASC NULLS LAST) as a0 FROM tmp",
+      sql.value());
+}
+
+TEST_F(PrestoQueryRunnerTest, distinctAggregation) {
+  auto aggregatePool = rootPool_->addAggregateChild("distinctAggregation");
+  auto queryRunner = std::make_unique<PrestoQueryRunner>(
+      aggregatePool.get(),
+      "http://unused",
+      "hive",
+      static_cast<std::chrono::milliseconds>(1000));
+
+  auto data =
+      makeRowVector({makeFlatVector<int64_t>({}), makeFlatVector<int64_t>({})});
+
+  auto plan = velox::exec::test::PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"array_agg(distinct c0)"})
+                  .planNode();
+
+  auto sql = queryRunner->toSql(plan);
+  ASSERT_TRUE(sql.has_value());
+  ASSERT_EQ("SELECT array_agg(distinct c0) as a0 FROM tmp", sql.value());
+}
+
+TEST_F(PrestoQueryRunnerTest, toSql) {
+  auto aggregatePool = rootPool_->addAggregateChild("toSql");
+  auto queryRunner = std::make_unique<PrestoQueryRunner>(
+      aggregatePool.get(),
+      "http://unused",
+      "hive",
+      static_cast<std::chrono::milliseconds>(1000));
+  auto dataType = ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), BOOLEAN()});
+
+  // Test window queries.
+  {
+    auto plan =
+        PlanBuilder()
+            .tableScan("tmp", dataType)
+            .window({"first_value(c0) over (partition by c1 order by c2)"})
+            .planNode();
+    EXPECT_EQ(
+        queryRunner->toSql(plan),
+        "SELECT c0, c1, c2, first_value(c0) OVER (PARTITION BY c1 ORDER BY c2 ASC NULLS LAST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM tmp");
+
+    plan =
+        PlanBuilder()
+            .tableScan("tmp", dataType)
+            .window(
+                {"first_value(c0) over (partition by c1 order by c2 desc nulls first rows between 1 following and unbounded following)",
+                 "last_value(c0) over (partition by c1 order by c2 desc nulls first)"})
+            .planNode();
+    EXPECT_EQ(
+        queryRunner->toSql(plan),
+        "SELECT c0, c1, c2, first_value(c0) OVER (PARTITION BY c1 ORDER BY c2 DESC NULLS FIRST ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING), last_value(c0) OVER (PARTITION BY c1 ORDER BY c2 DESC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM tmp");
+  }
+
+  // Test aggregation queries.
+  {
+    auto plan = PlanBuilder()
+                    .tableScan("tmp", dataType)
+                    .singleAggregation({"c1"}, {"avg(c0)"})
+                    .planNode();
+    EXPECT_EQ(
+        queryRunner->toSql(plan),
+        "SELECT c1, avg(c0) as a0 FROM tmp GROUP BY c1");
+
+    plan = PlanBuilder()
+               .tableScan("tmp", dataType)
+               .singleAggregation({"c1"}, {"sum(c0)"})
+               .project({"a0 + c1"})
+               .planNode();
+    EXPECT_EQ(
+        queryRunner->toSql(plan),
+        "SELECT plus(a0, c1) as p0 FROM (SELECT c1, sum(c0) as a0 FROM tmp GROUP BY c1)");
+
+    plan = PlanBuilder()
+               .tableScan("tmp", dataType)
+               .singleAggregation({}, {"avg(c0)", "avg(c1)"}, {"c2"})
+               .planNode();
+    EXPECT_EQ(
+        queryRunner->toSql(plan),
+        "SELECT avg(c0) filter (where c2) as a0, avg(c1) as a1 FROM tmp");
+  }
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrintPlanWithStatsTest.cpp b/velox/exec/tests/PrintPlanWithStatsTest.cpp
index 70325bff74c68..9b52725c3feea 100644
--- a/velox/exec/tests/PrintPlanWithStatsTest.cpp
+++ b/velox/exec/tests/PrintPlanWithStatsTest.cpp
@@ -18,12 +18,11 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <gtest/gtest.h>
 #include <re2/re2.h>
 
-DECLARE_int32(split_preload_per_driver);
-
 using namespace facebook::velox;
 using namespace facebook::velox::exec::test;
 
@@ -52,8 +51,7 @@ void compareOutputs(
     while (!RE2::FullMatch(line, expectedLine.line)) {
       potentialLines.push_back(expectedLine.line);
       if (!expectedLine.optional) {
-        ASSERT_FALSE(true) << "Output did not match "
-                           << "Source:" << testName
+        ASSERT_FALSE(true) << "Output did not match " << "Source:" << testName
                            << ", Line number:" << lineCount
                            << ", Line: " << line << ", Expected Line one of: "
                            << folly::join(",", potentialLines);
@@ -91,7 +89,7 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
         makeFlatVector<int64_t>(numRowsProbe, [](auto row) { return row; }),
     });
     leftVectors.push_back(rowVector);
-    writeToFile(leftFiles[i]->path, rowVector);
+    writeToFile(leftFiles[i]->getPath(), rowVector);
   }
   auto probeType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
 
@@ -134,34 +132,35 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
   compareOutputs(
       ::testing::UnitTest::GetInstance()->current_test_info()->name(),
       printPlanWithStats(*op, task->taskStats()),
-      {{"-- Project\\[expressions: \\(c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(p1:BIGINT, plus\\(ROW\\[\"c1\"\\],1\\)\\), \\(p2:BIGINT, plus\\(ROW\\[\"c1\"\\],ROW\\[\"u_c1\"\\]\\)\\)\\] -> c0:INTEGER, p1:BIGINT, p2:BIGINT"},
+      {{"-- Project\\[4\\]\\[expressions: \\(c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(p1:BIGINT, plus\\(ROW\\[\"c1\"\\],1\\)\\), \\(p2:BIGINT, plus\\(ROW\\[\"c1\"\\],ROW\\[\"u_c1\"\\]\\)\\)\\] -> c0:INTEGER, p1:BIGINT, p2:BIGINT"},
        {"   Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
-       {"  -- HashJoin\\[INNER c0=u_c0\\] -> c0:INTEGER, c1:BIGINT, u_c1:BIGINT"},
+       {"  -- HashJoin\\[3\\]\\[INNER c0=u_c0\\] -> c0:INTEGER, c1:BIGINT, u_c1:BIGINT"},
        {"     Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+"},
        {"     HashBuild: Input: 100 rows \\(.+\\), Output: 0 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+ Memory allocations: .+, Threads: 1"},
        {"     HashProbe: Input: 2000 rows \\(.+\\), Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
-       {"    -- TableScan\\[table: hive_table\\] -> c0:INTEGER, c1:BIGINT"},
-       {"       Input: 2000 rows \\(.+\\), Raw Input: 20480 rows \\(.+\\), Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 20"},
-       {"    -- Project\\[expressions: \\(u_c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(u_c1:BIGINT, ROW\\[\"c1\"\\]\\)\\] -> u_c0:INTEGER, u_c1:BIGINT"},
+       {"    -- TableScan\\[2\\]\\[table: hive_table\\] -> c0:INTEGER, c1:BIGINT"},
+       {"       Input: 2000 rows \\(.+\\), Raw Input: 20480 rows \\(.+\\), Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 20, DynamicFilter producer plan nodes: 3"},
+       {"    -- Project\\[1\\]\\[expressions: \\(u_c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(u_c1:BIGINT, ROW\\[\"c1\"\\]\\)\\] -> u_c0:INTEGER, u_c1:BIGINT"},
        {"       Output: 100 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: 0B, Memory allocations: .+, Threads: 1"},
-       {"      -- Values\\[100 rows in 1 vectors\\] -> c0:INTEGER, c1:BIGINT"},
+       {"      -- Values\\[0\\]\\[100 rows in 1 vectors\\] -> c0:INTEGER, c1:BIGINT"},
        {"         Input: 0 rows \\(.+\\), Output: 100 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: 0B, Memory allocations: .+, Threads: 1"}});
 
   // with custom stats
   compareOutputs(
       ::testing::UnitTest::GetInstance()->current_test_info()->name(),
       printPlanWithStats(*op, task->taskStats(), true),
-      {{"-- Project\\[expressions: \\(c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(p1:BIGINT, plus\\(ROW\\[\"c1\"\\],1\\)\\), \\(p2:BIGINT, plus\\(ROW\\[\"c1\"\\],ROW\\[\"u_c1\"\\]\\)\\)\\] -> c0:INTEGER, p1:BIGINT, p2:BIGINT"},
+      {{"-- Project\\[4\\]\\[expressions: \\(c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(p1:BIGINT, plus\\(ROW\\[\"c1\"\\],1\\)\\), \\(p2:BIGINT, plus\\(ROW\\[\"c1\"\\],ROW\\[\"u_c1\"\\]\\)\\)\\] -> c0:INTEGER, p1:BIGINT, p2:BIGINT"},
        {"   Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
        {"      dataSourceLazyCpuNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"      dataSourceLazyWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"  -- HashJoin\\[INNER c0=u_c0\\] -> c0:INTEGER, c1:BIGINT, u_c1:BIGINT"},
+       {"  -- HashJoin\\[3\\]\\[INNER c0=u_c0\\] -> c0:INTEGER, c1:BIGINT, u_c1:BIGINT"},
        {"     Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+"},
        {"     HashBuild: Input: 100 rows \\(.+\\), Output: 0 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
        {"        distinctKey0\\s+sum: 101, count: 1, min: 101, max: 101"},
+       {"        hashtable.buildWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        hashtable.capacity\\s+sum: 200, count: 1, min: 200, max: 200"},
        {"        hashtable.numDistinct\\s+sum: 100, count: 1, min: 100, max: 100"},
        {"        hashtable.numRehashes\\s+sum: 1, count: 1, min: 1, max: 1"},
@@ -185,22 +184,23 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
        {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"    -- TableScan\\[table: hive_table\\] -> c0:INTEGER, c1:BIGINT"},
-       {"       Input: 2000 rows \\(.+\\), Raw Input: 20480 rows \\(.+\\), Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 20"},
-       {"          dataSourceWallNanos [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"    -- TableScan\\[2\\]\\[table: hive_table\\] -> c0:INTEGER, c1:BIGINT"},
+       {"       Input: 2000 rows \\(.+\\), Raw Input: 20480 rows \\(.+\\), Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 20, DynamicFilter producer plan nodes: 3"},
+       {"          dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          dataSourceReadWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          dynamicFiltersAccepted[ ]* sum: 1, count: 1, min: 1, max: 1"},
        {"          flattenStringDictionaryValues [ ]* sum: 0, count: 1, min: 0, max: 0"},
-       {"          ioWaitNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
+       {"          ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
        {"          localReadBytes      [ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
+       {"          maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
        {"          numLocalRead        [ ]* sum: 0, count: 1, min: 0, max: 0"},
        {"          numPrefetch         [ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"          numRamRead          [ ]* sum: 40, count: 1, min: 40, max: 40"},
+       {"          numRamRead          [ ]* sum: 60, count: 1, min: 60, max: 60"},
        {"          numStorageRead      [ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
        {"          prefetchBytes       [ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
         true},
-       {"          queryThreadIoLatency[ ]* sum: .+, count: .+ min: .+, max: .+"},
        {"          ramReadBytes        [ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
         true},
@@ -211,13 +211,14 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
        {"          skippedSplits       [ ]* sum: 0, count: 1, min: 0, max: 0"},
        {"          skippedStrides      [ ]* sum: 0, count: 1, min: 0, max: 0"},
        {"          storageReadBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          totalRemainingFilterTime\\s+sum: .+, count: .+, min: .+, max: .+"},
        {"          totalScanTime       [ ]* sum: .+, count: .+, min: .+, max: .+"},
-       {"    -- Project\\[expressions: \\(u_c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(u_c1:BIGINT, ROW\\[\"c1\"\\]\\)\\] -> u_c0:INTEGER, u_c1:BIGINT"},
+       {"    -- Project\\[1\\]\\[expressions: \\(u_c0:INTEGER, ROW\\[\"c0\"\\]\\), \\(u_c1:BIGINT, ROW\\[\"c1\"\\]\\)\\] -> u_c0:INTEGER, u_c1:BIGINT"},
        {"       Output: 100 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: 0B, Memory allocations: .+, Threads: 1"},
        {"          runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"      -- Values\\[100 rows in 1 vectors\\] -> c0:INTEGER, c1:BIGINT"},
+       {"      -- Values\\[0\\]\\[100 rows in 1 vectors\\] -> c0:INTEGER, c1:BIGINT"},
        {"         Input: 0 rows \\(.+\\), Output: 100 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: 0B, Memory allocations: .+, Threads: 1"},
        {"            runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"            runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
@@ -235,9 +236,8 @@ TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
   for (const auto& numPrefetchSplit : numPrefetchSplits) {
     SCOPED_TRACE(fmt::format("numPrefetchSplit {}", numPrefetchSplit));
     asyncDataCache_->clear();
-    FLAGS_split_preload_per_driver = numPrefetchSplit;
     auto filePath = TempFilePath::create();
-    writeToFile(filePath->path, vectors);
+    writeToFile(filePath->getPath(), vectors);
 
     auto op =
         PlanBuilder()
@@ -246,24 +246,27 @@ TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
                 {"c5"}, {"max(c0)", "sum(c1)", "sum(c2)", "sum(c3)", "sum(c4)"})
             .planNode();
 
-    auto task = assertQuery(
-        op,
-        {filePath},
-        "SELECT c5, max(c0), sum(c1), sum(c2), sum(c3), sum(c4) FROM tmp group by c5");
-
+    auto task =
+        AssertQueryBuilder(op, duckDbQueryRunner_)
+            .config(
+                core::QueryConfig::kMaxSplitPreloadPerDriver,
+                std::to_string(numPrefetchSplit))
+            .splits(makeHiveConnectorSplits({filePath}))
+            .assertResults(
+                "SELECT c5, max(c0), sum(c1), sum(c2), sum(c3), sum(c4) FROM tmp group by c5");
     ensureTaskCompletion(task.get());
     compareOutputs(
         ::testing::UnitTest::GetInstance()->current_test_info()->name(),
         printPlanWithStats(*op, task->taskStats()),
-        {{"-- Aggregation\\[PARTIAL \\[c5\\] a0 := max\\(ROW\\[\"c0\"\\]\\), a1 := sum\\(ROW\\[\"c1\"\\]\\), a2 := sum\\(ROW\\[\"c2\"\\]\\), a3 := sum\\(ROW\\[\"c3\"\\]\\), a4 := sum\\(ROW\\[\"c4\"\\]\\)\\] -> c5:VARCHAR, a0:BIGINT, a1:BIGINT, a2:BIGINT, a3:DOUBLE, a4:DOUBLE"},
+        {{"-- Aggregation\\[1\\]\\[PARTIAL \\[c5\\] a0 := max\\(ROW\\[\"c0\"\\]\\), a1 := sum\\(ROW\\[\"c1\"\\]\\), a2 := sum\\(ROW\\[\"c2\"\\]\\), a3 := sum\\(ROW\\[\"c3\"\\]\\), a4 := sum\\(ROW\\[\"c4\"\\]\\)\\] -> c5:VARCHAR, a0:BIGINT, a1:BIGINT, a2:BIGINT, a3:DOUBLE, a4:DOUBLE"},
          {"   Output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
-         {"  -- TableScan\\[table: hive_table\\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR"},
+         {"  -- TableScan\\[0\\]\\[table: hive_table\\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR"},
          {"     Input: 10000 rows \\(.+\\), Output: 10000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1"}});
 
     compareOutputs(
         ::testing::UnitTest::GetInstance()->current_test_info()->name(),
         printPlanWithStats(*op, task->taskStats(), true),
-        {{"-- Aggregation\\[PARTIAL \\[c5\\] a0 := max\\(ROW\\[\"c0\"\\]\\), a1 := sum\\(ROW\\[\"c1\"\\]\\), a2 := sum\\(ROW\\[\"c2\"\\]\\), a3 := sum\\(ROW\\[\"c3\"\\]\\), a4 := sum\\(ROW\\[\"c4\"\\]\\)\\] -> c5:VARCHAR, a0:BIGINT, a1:BIGINT, a2:BIGINT, a3:DOUBLE, a4:DOUBLE"},
+        {{"-- Aggregation\\[1\\]\\[PARTIAL \\[c5\\] a0 := max\\(ROW\\[\"c0\"\\]\\), a1 := sum\\(ROW\\[\"c1\"\\]\\), a2 := sum\\(ROW\\[\"c2\"\\]\\), a3 := sum\\(ROW\\[\"c3\"\\]\\), a4 := sum\\(ROW\\[\"c4\"\\]\\)\\] -> c5:VARCHAR, a0:BIGINT, a1:BIGINT, a2:BIGINT, a3:DOUBLE, a4:DOUBLE"},
          {"   Output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
          {"      dataSourceLazyCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
          {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
@@ -276,22 +279,23 @@ TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
          {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
          {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
          {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
-         {"  -- TableScan\\[table: hive_table\\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR"},
+         {"  -- TableScan\\[0\\]\\[table: hive_table\\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR"},
          {"     Input: 10000 rows \\(.+\\), Output: 10000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1"},
-         {"        dataSourceWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+         {"        dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+         {"        dataSourceReadWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
          {"        flattenStringDictionaryValues [ ]* sum: 0, count: 1, min: 0, max: 0"},
-         {"        ioWaitNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
+         {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
          {"        localReadBytes   [ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
+         {"        maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
          {"        numLocalRead     [ ]* sum: 0, count: 1, min: 0, max: 0"},
          {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+"},
-         {"        numRamRead       [ ]* sum: 6, count: 1, min: 6, max: 6"},
+         {"        numRamRead       [ ]* sum: 7, count: 1, min: 7, max: 7"},
          {"        numStorageRead   [ ]* sum: .+, count: 1, min: .+, max: .+"},
          {"        overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
 
          {"        prefetchBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
          {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
           true},
-         {"        queryThreadIoLatency[ ]* sum: .+, count: .+ min: .+, max: .+"},
          {"        ramReadBytes     [ ]* sum: .+, count: 1, min: .+, max: .+"},
          {"        readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
           true},
@@ -302,6 +306,79 @@ TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
          {"        skippedSplits    [ ]* sum: 0, count: 1, min: 0, max: 0"},
          {"        skippedStrides   [ ]* sum: 0, count: 1, min: 0, max: 0"},
          {"        storageReadBytes [ ]* sum: .+, count: 1, min: .+, max: .+"},
+         {"        totalRemainingFilterTime\\s+sum: .+, count: .+, min: .+, max: .+"},
          {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"}});
   }
 }
+
+TEST_F(PrintPlanWithStatsTest, tableWriterWithTableScan) {
+  RowTypePtr rowType{
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+          {BIGINT(), INTEGER(), SMALLINT(), REAL(), DOUBLE(), VARCHAR()})};
+  auto vectors = makeVectors(rowType, 10, 10);
+
+  const auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  const auto writeDir = TempDirectoryPath::create();
+
+  auto writePlan = PlanBuilder()
+                       .tableScan(rowType)
+                       .tableWrite(writeDir->getPath())
+                       .planNode();
+
+  std::shared_ptr<exec::Task> task;
+  AssertQueryBuilder(writePlan)
+      .splits(makeHiveConnectorSplits({filePath}))
+      .copyResults(pool(), task);
+  ensureTaskCompletion(task.get());
+  compareOutputs(
+      ::testing::UnitTest::GetInstance()->current_test_info()->name(),
+      printPlanWithStats(*writePlan, task->taskStats()),
+      {{R"(-- TableWrite\[1\]\[.+InsertTableHandle .+)"},
+       {"   Output: .+, Physical written output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
+       {R"(  -- TableScan\[0\]\[table: hive_table\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR)"},
+       {R"(     Input: 100 rows \(.+\), Output: 100 rows \(.+\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1)"}});
+
+  compareOutputs(
+      ::testing::UnitTest::GetInstance()->current_test_info()->name(),
+      printPlanWithStats(*writePlan, task->taskStats(), true),
+      {{R"(-- TableWrite\[1\]\[.+InsertTableHandle .+)"},
+       {"   Output: .+, Physical written output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
+       {"      dataSourceLazyCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"      numWrittenFiles\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      stripeSize\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      writeIOTime\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {R"(  -- TableScan\[0\]\[table: hive_table\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR)"},
+       {R"(     Input: 100 rows \(.+\), Output: 100 rows \(.+\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1)"},
+       {"        dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        dataSourceReadWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        flattenStringDictionaryValues [ ]* sum: 0, count: 1, min: 0, max: 0"},
+       {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
+       {"        localReadBytes   [ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
+       {"        maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
+       {"        numLocalRead     [ ]* sum: 0, count: 1, min: 0, max: 0"},
+       {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"        numRamRead       [ ]* sum: 7, count: 1, min: 7, max: 7"},
+       {"        numStorageRead   [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
+
+       {"        prefetchBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"        ramReadBytes     [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"        skippedSplitBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
+       {"        skippedSplits    [ ]* sum: 0, count: 1, min: 0, max: 0"},
+       {"        skippedStrides   [ ]* sum: 0, count: 1, min: 0, max: 0"},
+       {"        storageReadBytes [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        totalRemainingFilterTime\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"}});
+}
diff --git a/velox/exec/tests/QueryAssertionsTest.cpp b/velox/exec/tests/QueryAssertionsTest.cpp
index 1421cdd541093..8d063ea43a808 100644
--- a/velox/exec/tests/QueryAssertionsTest.cpp
+++ b/velox/exec/tests/QueryAssertionsTest.cpp
@@ -19,6 +19,7 @@
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
 #include "velox/type/Variant.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox::exec::test;
@@ -26,7 +27,22 @@ using namespace facebook::velox;
 
 namespace facebook::velox::test {
 
-class QueryAssertionsTest : public OperatorTestBase {};
+class QueryAssertionsTest : public OperatorTestBase {
+ public:
+  void assertQueryWithThreadingConfigs(
+      const core::PlanNodePtr& plan,
+      const std::string& duckDbSql) {
+    CursorParameters parallelParams{};
+    parallelParams.planNode = plan;
+    parallelParams.serialExecution = false;
+    assertQuery(parallelParams, duckDbSql);
+
+    CursorParameters serialParams{};
+    serialParams.planNode = plan;
+    serialParams.serialExecution = true;
+    assertQuery(serialParams, duckDbSql);
+  }
+};
 
 TEST_F(QueryAssertionsTest, basic) {
   auto data = makeRowVector({
@@ -35,7 +51,7 @@ TEST_F(QueryAssertionsTest, basic) {
   createDuckDbTable({data});
 
   auto plan = PlanBuilder().values({data}).project({"c0"}).planNode();
-  assertQuery(plan, "SELECT c0 FROM tmp");
+  assertQueryWithThreadingConfigs(plan, "SELECT c0 FROM tmp");
 
   EXPECT_NONFATAL_FAILURE(
       assertQuery(plan, "SELECT c0 + 1 FROM tmp"),
@@ -343,6 +359,81 @@ TEST_F(QueryAssertionsTest, multiFloatColumnWithNonUniqueKeys) {
       "971 extra rows, 971 missing rows");
 }
 
+TEST_F(QueryAssertionsTest, complexTypesContainingFloat) {
+  auto size = 1000;
+  // Test array.
+  auto expected = makeRowVector(
+      {makeArrayVector<float>(
+           size,
+           [](auto /*row*/) { return 2; },
+           [](auto row) { return row % 2 + 0.01; },
+           [](auto row) { return row % 7 == 0; }),
+       makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+  auto actual = makeRowVector(
+      {makeArrayVector<float>(
+           size,
+           [&](auto /*row*/) { return 2; },
+           [&](auto row) {
+             auto value = row % 2 + 0.01;
+             return value + value * FLT_EPSILON;
+           },
+           [&](auto row) { return (size - row - 1) % 7 == 0; }),
+       makeFlatVector<int64_t>(
+           size, [&](auto row) { return size - row - 1; })});
+  EXPECT_TRUE(assertEqualResults({expected}, {actual}));
+
+  // Test map and row.
+  expected = makeRowVector(
+      {makeMapVector<int64_t, float>(
+           size,
+           [](auto /*row*/) { return 2; },
+           [](auto row) { return row; },
+           [](auto row) { return row % 5 + 0.01; },
+           [](auto /*row*/) { return false; },
+           [](auto row) { return row % 6 == 0; }),
+       makeRowVector(
+           {makeFlatVector<float>(
+                size, [](auto row) { return row % 5 + 0.01; }),
+            makeFlatVector<int64_t>(size, [](auto row) { return row % 5; }),
+            makeArrayVector<float>(
+                size,
+                [](auto /*row*/) { return 2; },
+                [](auto row) { return row % 2 + 0.01; },
+                [](auto row) { return row % 7 == 0; })}),
+       makeFlatVector<int64_t>(size, [](auto row) { return row; })});
+  actual = makeRowVector(
+      {makeMapVector<int64_t, float>(
+           size,
+           [](auto /*row*/) { return 2; },
+           [&](auto row) { return (size * 2 - row - 1); },
+           [&](auto row) {
+             auto value = (size * 2 - row - 1) % 5 + 0.01;
+             return value + value * FLT_EPSILON;
+           },
+           [&](auto /*row*/) { return false; },
+           [&](auto row) { return (size * 2 - row - 1) % 6 == 0; }),
+       makeRowVector(
+           {makeFlatVector<float>(
+                size,
+                [&](auto row) {
+                  auto value = (size - row - 1) % 5 + 0.01;
+                  return value + value * FLT_EPSILON;
+                }),
+            makeFlatVector<int64_t>(
+                size, [&](auto row) { return (size - row - 1) % 5; }),
+            makeArrayVector<float>(
+                size,
+                [](auto /*row*/) { return 2; },
+                [&](auto row) {
+                  auto value = row % 2 + 0.01;
+                  return value + value * FLT_EPSILON;
+                },
+                [&](auto row) { return (size - row - 1) % 7 == 0; })}),
+       makeFlatVector<int64_t>(
+           size, [&](auto row) { return (size - row - 1); })});
+  EXPECT_TRUE(assertEqualResults({expected}, {actual}));
+}
+
 TEST_F(QueryAssertionsTest, nullDecimalValue) {
   auto shortDecimal = makeRowVector(
       {makeNullableFlatVector<int64_t>({std::nullopt}, DECIMAL(5, 2))});
@@ -350,7 +441,7 @@ TEST_F(QueryAssertionsTest, nullDecimalValue) {
 
   createDuckDbTable({shortDecimal});
   auto plan = PlanBuilder().values({shortDecimal}).planNode();
-  assertQuery(plan, "SELECT c0 FROM tmp");
+  assertQueryWithThreadingConfigs(plan, "SELECT c0 FROM tmp");
 
   auto longDecimal = makeRowVector(
       {makeNullableFlatVector<int128_t>({std::nullopt}, DECIMAL(20, 2))});
@@ -358,13 +449,71 @@ TEST_F(QueryAssertionsTest, nullDecimalValue) {
 
   createDuckDbTable({longDecimal});
   plan = PlanBuilder().values({longDecimal}).planNode();
-  assertQuery(plan, "SELECT c0 FROM tmp");
+  assertQueryWithThreadingConfigs(plan, "SELECT c0 FROM tmp");
 
   EXPECT_NONFATAL_FAILURE(
       assertEqualResults({shortDecimal}, {longDecimal}),
       "Types of expected and actual results do not match");
 }
 
+TEST_F(QueryAssertionsTest, valuesMismatch) {
+  auto test = makeRowVector({
+      makeFlatVector<int64_t>({10, 20}, DECIMAL(12, 2)),
+  });
+  createDuckDbTable({test});
+
+  // The expected values should be off by 1.
+  auto plan = PlanBuilder().values({test}).project({"c0"}).planNode();
+  EXPECT_NONFATAL_FAILURE(
+      assertQuery(plan, "SELECT c0 + 1 FROM tmp"),
+      "Expected 2, got 2\n"
+      "2 extra rows, 2 missing rows\n"
+      "2 of extra rows:\n\t"
+      "0.10\n\t"
+      "0.20\n\n"
+      "2 of missing rows:\n\t"
+      "1.10\n\t"
+      "1.20");
+}
+
+TEST_F(QueryAssertionsTest, noExpectedRows) {
+  auto actual = makeRowVector({
+      makeFlatVector(std::vector<int64_t>{4000}, DECIMAL(6, 2)),
+  });
+  createDuckDbTable({actual});
+
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({}, BIGINT()),
+  });
+  auto plan = PlanBuilder().values({actual}).project({"c0"}).planNode();
+  EXPECT_NONFATAL_FAILURE(
+      assertQuery(plan, expected),
+      "Expected 0, got 1\n"
+      "1 extra rows, 0 missing rows\n"
+      "1 of extra rows:\n\t"
+      "40.00\n\n"
+      "0 of missing rows:");
+}
+
+TEST_F(QueryAssertionsTest, noActualRows) {
+  auto actual = makeRowVector({
+      makeFlatVector<int64_t>({}, BIGINT()),
+  });
+  createDuckDbTable({actual});
+
+  auto expected = makeRowVector({
+      makeFlatVector(std::vector<int64_t>{1000}, DECIMAL(6, 2)),
+  });
+  auto plan = PlanBuilder().values({actual}).project({"c0"}).planNode();
+  EXPECT_NONFATAL_FAILURE(
+      assertQuery(plan, expected),
+      "Expected 1, got 0\n"
+      "0 extra rows, 1 missing rows\n"
+      "0 of extra rows:\n\n"
+      "1 of missing rows:\n\t"
+      "10.00");
+}
+
 TEST_F(QueryAssertionsTest, nullVariant) {
   auto input = makeRowVector(
       {makeNullableArrayVector<int64_t>(
@@ -373,7 +522,7 @@ TEST_F(QueryAssertionsTest, nullVariant) {
            {{std::nullopt, 1.1}, {2.2, 3.3, 4.4}, {std::nullopt}})});
   createDuckDbTable({input});
   auto plan = PlanBuilder().values({input}).planNode();
-  assertQuery(plan, "SELECT * FROM tmp");
+  assertQueryWithThreadingConfigs(plan, "SELECT * FROM tmp");
 
   input = makeRowVector({makeNullableMapVector<int64_t, double>(
       {std::nullopt,
@@ -384,14 +533,80 @@ TEST_F(QueryAssertionsTest, nullVariant) {
        {{{6, std::nullopt}}}})});
   createDuckDbTable({input});
   plan = PlanBuilder().values({input}).planNode();
-  assertQuery(plan, "SELECT * FROM tmp");
+  assertQueryWithThreadingConfigs(plan, "SELECT * FROM tmp");
 
   input = makeRowVector({makeRowVector(
       {makeNullConstant(TypeKind::BIGINT, 10),
        makeNullConstant(TypeKind::DOUBLE, 10)})});
   createDuckDbTable({input});
   plan = PlanBuilder().values({input}).planNode();
-  assertQuery(plan, "SELECT * FROM tmp");
+  assertQueryWithThreadingConfigs(plan, "SELECT * FROM tmp");
+}
+
+TEST_F(QueryAssertionsTest, varbinary) {
+  auto data = makeRowVector({makeFlatVector<std::string>(
+      {"Short string", "Longer strings...", "abc"}, VARBINARY())});
+
+  auto rowType = asRowType(data->type());
+
+  createDuckDbTable({data});
+
+  auto duckResult = duckDbQueryRunner_.execute("SELECT * FROM tmp", rowType);
+  ASSERT_EQ(duckResult.size(), data->size());
+  ASSERT_EQ(duckResult.begin()->begin()->kind(), TypeKind::VARBINARY);
+  ASSERT_TRUE(assertEqualResults(duckResult, rowType, {data}));
+
+  auto plan = PlanBuilder().values({data}).planNode();
+  assertQueryWithThreadingConfigs(plan, "SELECT * FROM tmp");
+}
+
+TEST_F(QueryAssertionsTest, intervalDayTime) {
+  // INTERVAL_DAY_TIME needs special handling as it is a logical (vs physical)
+  // type mapping to BIGINT. Tests its use as a FLAT vector and in a MAP
+  // serialized to DuckDB to cover the specialized code-paths.
+  auto data = makeRowVector(
+      {makeFlatVector<int64_t>({5, 10, 15, 0}, INTERVAL_DAY_TIME())});
+
+  createDuckDbTable({data});
+  auto plan = PlanBuilder().values({data}).planNode();
+  assertQueryWithThreadingConfigs(plan, "SELECT * FROM tmp");
+
+  data = makeRowVector({makeMapVectorFromJson<int64_t, double>(
+      {"null",
+       "{1: 1.1, 2: null}",
+       "{}",
+       "{3: 3.3, 4: 4.4, 5: 5.5}",
+       "null",
+       "{6: null}"},
+      MAP(INTERVAL_DAY_TIME(), DOUBLE()))});
+  createDuckDbTable({data});
+  plan = PlanBuilder().values({data}).planNode();
+  assertQueryWithThreadingConfigs(plan, "SELECT * FROM tmp");
+}
+
+TEST_F(QueryAssertionsTest, plansWithEqualResults) {
+  VectorFuzzer::Options opts;
+  VectorFuzzer fuzzer(opts, pool());
+
+  auto input = fuzzer.fuzzInputRow(ROW({"c0"}, {INTEGER()}));
+  auto plan1 = PlanBuilder().values({input}).orderBy({"c0"}, false).planNode();
+
+  // The input plan has 100 rows. So the limit has no effect here.
+  auto plan2 = PlanBuilder()
+                   .values({input})
+                   .orderBy({"c0"}, false)
+                   .limit(0, 100, false)
+                   .planNode();
+  assertEqualResults(plan1, plan2);
+
+  // The limit drops 50 result rows from the original plan.
+  plan2 = PlanBuilder()
+              .values({input})
+              .orderBy({"c0"}, false)
+              .limit(0, 50, false)
+              .planNode();
+  EXPECT_NONFATAL_FAILURE(
+      assertEqualResults(plan1, plan2), "Expected 100, got 50");
 }
 
 } // namespace facebook::velox::test
diff --git a/velox/exec/tests/RoundRobinPartitionFunctionTest.cpp b/velox/exec/tests/RoundRobinPartitionFunctionTest.cpp
index 1a36740409a67..de3c43d087400 100644
--- a/velox/exec/tests/RoundRobinPartitionFunctionTest.cpp
+++ b/velox/exec/tests/RoundRobinPartitionFunctionTest.cpp
@@ -22,12 +22,17 @@ using namespace facebook::velox;
 using namespace facebook::velox::exec;
 
 class RoundRobinPartitionFunctionTest : public test::VectorTestBase,
-                                        public testing::Test {};
+                                        public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 TEST_F(RoundRobinPartitionFunctionTest, basic) {
   exec::RoundRobinPartitionFunction partitionFunction(10);
 
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   test::VectorMaker vm(pool.get());
 
   auto data = vm.rowVector(ROW({}, {}), 1024);
diff --git a/velox/exec/tests/RowContainerTest.cpp b/velox/exec/tests/RowContainerTest.cpp
index 55ce737b09ae0..129efad3411eb 100644
--- a/velox/exec/tests/RowContainerTest.cpp
+++ b/velox/exec/tests/RowContainerTest.cpp
@@ -14,16 +14,25 @@
  * limitations under the License.
  */
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/VectorHasher.h"
 #include "velox/exec/tests/utils/RowContainerTestBase.h"
+#include "velox/expression/VectorReaders.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::test;
+using namespace facebook::velox::common::testutil;
 
 class RowContainerTest : public exec::test::RowContainerTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+    TestValue::enable();
+  }
+
   void testExtractColumn(
       RowContainer& container,
       const std::vector<char*>& rows,
@@ -252,10 +261,31 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
     for (auto row : rows) {
       sum += data.rowSize(row) - data.fixedRowSize();
     }
-    auto usage = data.stringAllocator().cumulativeBytes();
+    auto usage = data.stringAllocator().currentBytes();
     EXPECT_EQ(usage, sum);
   }
 
+  std::vector<char*> store(
+      RowContainer& rowContainer,
+      const RowVectorPtr& data) {
+    std::vector<DecodedVector> decodedVectors;
+    for (auto& vector : data->children()) {
+      decodedVectors.emplace_back(*vector);
+    }
+
+    std::vector<char*> rows;
+    for (auto i = 0; i < data->size(); ++i) {
+      auto* row = rowContainer.newRow();
+      rows.push_back(row);
+
+      for (auto j = 0; j < decodedVectors.size(); ++j) {
+        rowContainer.store(decodedVectors[j], i, row, j);
+      }
+    }
+
+    return rows;
+  }
+
   std::vector<char*> store(
       RowContainer& rowContainer,
       DecodedVector& decodedVector,
@@ -284,121 +314,503 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
     return rowContainer;
   }
 
+  // Count number of nulls at the start of the list.
   template <typename T>
-  void testCompareFloats(TypePtr type, bool ascending, bool nullsFirst) {
-    // NOTE: set 'isJoinBuild' to true to enable nullable sort key in test.
-    auto rowContainer = makeRowContainer({type}, {type}, false);
-    auto lowest = std::numeric_limits<T>::lowest();
-    auto min = std::numeric_limits<T>::min();
-    auto max = std::numeric_limits<T>::max();
-    auto nan = std::numeric_limits<T>::quiet_NaN();
-    auto inf = std::numeric_limits<T>::infinity();
-
-    facebook::velox::test::VectorMaker vectorMaker{pool_.get()};
-    VectorPtr values = vectorMaker.flatVectorNullable<T>(
-        {std::nullopt, max, inf, 0.0, nan, lowest, min});
-    int numRows = values->size();
-
-    SelectivityVector allRows(numRows);
-    DecodedVector decoded(*values, allRows);
-    std::vector<char*> rows(numRows);
-    std::vector<std::pair<int, char*>> indexedRows(numRows);
-    for (size_t i = 0; i < numRows; ++i) {
-      rows[i] = rowContainer->newRow();
-      rowContainer->store(decoded, i, rows[i], 0);
-      indexedRows[i] = std::make_pair(i, rows[i]);
+  static size_t countLeadingNulls(const std::vector<std::optional<T>>& values) {
+    for (auto i = 0; i < values.size(); ++i) {
+      if (values[i].has_value()) {
+        return i;
+      }
     }
+    return values.size();
+  }
 
-    std::vector<std::optional<T>> expectedOrder = {
-        std::nullopt, lowest, 0.0, min, max, inf, nan};
-    if (!ascending) {
-      if (nullsFirst) {
-        std::reverse(expectedOrder.begin() + 1, expectedOrder.end());
+  // Given a list of values sorted in ascending order with nulls first re-orders
+  // the elements to reverse the order and / or put nulls last.
+  template <typename T>
+  void changeSortingOrder(
+      std::vector<std::optional<T>>& values,
+      const CompareFlags& flags) {
+    if (flags.ascending) {
+      if (flags.nullsFirst) {
+        // Nothing to do. 'values' are expected to be already sorted in
+        // ascending order with nulls first.
       } else {
-        std::reverse(expectedOrder.begin(), expectedOrder.end());
+        // Move the nulls from the start of the list to the end of the list.
+        const auto numNulls = countLeadingNulls(values);
+        for (auto i = 0; i < values.size() - numNulls; ++i) {
+          values[i] = values[i + numNulls];
+        }
+
+        for (auto i = values.size() - numNulls; i < values.size(); ++i) {
+          values[i].reset();
+        }
       }
     } else {
-      if (!nullsFirst) {
-        for (int i = 0; i < expectedOrder.size() - 1; ++i) {
-          expectedOrder[i] = expectedOrder[i + 1];
-        }
-        expectedOrder[expectedOrder.size() - 1] = std::nullopt;
+      if (flags.nullsFirst) {
+        // Keeps nulls at the start of the list. Reverse the order of remaining
+        // non-null elements.
+        const auto numNulls = countLeadingNulls(values);
+        std::reverse(values.begin() + numNulls, values.end());
+      } else {
+        // Reverse the order of all elements.
+        std::reverse(values.begin(), values.end());
       }
     }
-    VectorPtr expected = vectorMaker.flatVectorNullable<T>(expectedOrder);
+  }
+
+  using IndexAndRow = std::pair<vector_size_t, char*>;
+  // A list of rows with unique zero-based indices.
+  using IndexAndRowVector = std::vector<IndexAndRow>;
+
+  static IndexAndRowVector indexRows(const std::vector<char*>& rows) {
+    IndexAndRowVector indexedRows;
+    indexedRows.reserve(rows.size());
+    for (auto i = 0; i < rows.size(); ++i) {
+      indexedRows.push_back({i, rows[i]});
+    }
+    return indexedRows;
+  }
+
+  VectorPtr copyValues(
+      const IndexAndRowVector& indexedRows,
+      const VectorPtr& values) {
+    const auto numRows = indexedRows.size();
+    auto copy = BaseVector::create(values->type(), numRows, pool_.get());
+    for (auto i = 0; i < numRows; ++i) {
+      copy->copy(values.get(), i, indexedRows[i].first, 1);
+    }
+    return copy;
+  }
+
+  static std::vector<char*> storeRows(
+      const DecodedVector& decoded,
+      vector_size_t numRows,
+      RowContainer& rowContainer) {
+    std::vector<char*> rows(numRows);
+    for (size_t i = 0; i < numRows; ++i) {
+      rows[i] = rowContainer.newRow();
+      rowContainer.store(decoded, i, rows[i], 0);
+    }
+
+    return rows;
+  }
+
+  void testRowContainerCompareAPIs(
+      const TypePtr& type,
+      const VectorPtr& values,
+      const VectorPtr& expected,
+      std::optional<CompareFlags> flags) {
+    // If no flags provided then it must be the default of {true, true}.
+    SCOPED_TRACE(fmt::format(
+        "{}, ascending = {}, nullsFirst = {}",
+        type->toString(),
+        flags.has_value() ? flags.value().ascending : true,
+        flags.has_value() ? flags.value().nullsFirst : true));
+
+    // Set 'isJoinBuild' to true to enable nullable sort key in test.
+    auto rowContainer = makeRowContainer({type}, {type}, false);
+    int numRows = values->size();
+
+    DecodedVector decoded(*values);
+    auto rows = storeRows(decoded, numRows, *rowContainer);
+    auto indexedRows = indexRows(rows);
+
+    std::function<int(const char*, const char*)> compareRows =
+        [&](const auto& l, const auto& r) {
+          return rowContainer->compare(l, r, 0) < 0;
+        };
+
+    // If compare flags are specified pass them into the compare function.
+    if (flags.has_value()) {
+      compareRows = [&](const auto& l, const auto& r) {
+        return rowContainer->compare(l, r, 0, flags.value()) < 0;
+      };
+    }
+
+    // Verify compare method with two rows as input - using compareRows
     {
-      // Verify compare method with two rows as input
-      std::sort(rows.begin(), rows.end(), [&](const char* l, const char* r) {
-        return rowContainer->compare(l, r, 0, {nullsFirst, ascending}) < 0;
-      });
+      std::sort(rows.begin(), rows.end(), compareRows);
       VectorPtr result = BaseVector::create(type, numRows, pool_.get());
       rowContainer->extractColumn(rows.data(), numRows, 0, result);
       assertEqualVectors(expected, result);
     }
 
-    // Verify compare method with row and decoded vector as input
+    std::function<int(
+        const std::pair<int, char*>&, const std::pair<int, char*>&)>
+        compareDecodedAndRows = [&](const auto& l, const auto& r) {
+          return rowContainer->compare(
+                     l.second, rowContainer->columnAt(0), decoded, r.first) < 0;
+        };
+
+    if (flags.has_value()) {
+      compareDecodedAndRows = [&](const auto& l, const auto& r) {
+        return rowContainer->compare(
+                   l.second,
+                   rowContainer->columnAt(0),
+                   decoded,
+                   r.first,
+                   flags.value()) < 0;
+      };
+    }
+
+    // Verify compare method with row and decoded vector as input - using
+    // compareDecodedAndRows.
+    // This test assumes that the rows and decoded vector are in the same order
+    // so that indexRows can be sorted. The decoded vector is a different
+    // representation of the same row data. This allows for using sort which
+    // compares each element in decoded vector and each row value to each other
+    // testing the compare API as if the same row is sorted.
     {
-      std::sort(
-          indexedRows.begin(),
-          indexedRows.end(),
-          [&](const std::pair<int, char*>& l, const std::pair<int, char*>& r) {
-            return rowContainer->compare(
-                       l.second,
-                       rowContainer->columnAt(0),
-                       decoded,
-                       r.first,
-                       {nullsFirst, ascending}) < 0;
-          });
-      std::vector<std::optional<T>> sorted;
-      for (const auto& irow : indexedRows) {
-        if (decoded.isNullAt(irow.first)) {
-          sorted.push_back(std::nullopt);
-        } else {
-          sorted.push_back(decoded.valueAt<T>(irow.first));
-        }
-      }
-      VectorPtr result = vectorMaker.template flatVectorNullable<T>(sorted);
+      std::sort(indexedRows.begin(), indexedRows.end(), compareDecodedAndRows);
+      auto result = copyValues(indexedRows, values);
       assertEqualVectors(expected, result);
     }
+  }
 
-    // Verify compareRows method with row as input.
-    {
-      std::sort(
-          indexedRows.begin(),
-          indexedRows.end(),
-          [&](const std::pair<int, char*>& l, const std::pair<int, char*>& r) {
-            return rowContainer->compareRows(
-                       l.second, r.second, {{nullsFirst, ascending}}) < 0;
-          });
-      std::vector<std::optional<T>> sorted;
-      for (const auto& irow : indexedRows) {
-        if (decoded.isNullAt(irow.first)) {
-          sorted.push_back(std::nullopt);
-        } else {
-          sorted.push_back(decoded.valueAt<T>(irow.first));
-        }
+  template <bool canHandleNulls>
+  void testRowContainerEqualsAPI(
+      const TypePtr& type,
+      const VectorPtr& lhs,
+      const VectorPtr& rhs,
+      const std::vector<bool>& expected) {
+    auto numRows = lhs->size();
+    EXPECT_EQ(numRows, rhs->size());
+    EXPECT_EQ(numRows, expected.size());
+
+    auto rowContainer = makeRowContainer({type}, {type}, false);
+    DecodedVector lhsDecoded(*lhs);
+    auto rows = storeRows(lhsDecoded, numRows, *rowContainer);
+
+    DecodedVector rhsDecoded(*rhs);
+
+    int32_t index{0};
+    for (auto row : rows) {
+      ASSERT_EQ(
+          expected[index],
+          rowContainer->equals<canHandleNulls>(
+              row, rowContainer->columnAt(0), rhsDecoded, index))
+          << fmt::format(
+                 "Mismatch at index {} with canHandleNulls {}",
+                 index,
+                 canHandleNulls);
+      ++index;
+    }
+  }
+
+  void testRowContainerEqualityEdgeValues(
+      const TypePtr& type,
+      const VectorPtr& values) {
+    auto numRows = values->size();
+    if (values->mayHaveNulls()) {
+      auto numNulls = BaseVector::countNulls(values->nulls(), 0, numRows);
+      auto vecWithoutNulls = values->slice(numNulls, numRows - numNulls);
+      std::vector<bool> expectedResults(vecWithoutNulls->size(), true);
+      testRowContainerEqualsAPI<false>(
+          type, vecWithoutNulls, vecWithoutNulls, expectedResults);
+    } else {
+      std::vector<bool> expectedResults(numRows, true);
+      testRowContainerEqualsAPI<true>(type, values, values, expectedResults);
+    }
+  }
+
+  template <typename T>
+  void testOrderAndEqualsWithNullsFirstVariations(
+      const TypePtr& type,
+      const VectorPtr& values,
+      const std::vector<std::optional<T>>& ascNullsFirstOrder,
+      std::function<VectorPtr(const std::vector<std::optional<T>>&)>
+          generateExpectedVector) {
+    // The default flags are ascending == true, nullsFirst == true.
+    // std::nullopt means use the default for the compare function.
+    const std::vector<std::optional<CompareFlags>> compareFlags{
+        {{std::nullopt}}, {{true, false}}, {{false, true}}, {{false, false}}};
+
+    for (auto flags : compareFlags) {
+      std::vector<std::optional<T>> expectedOrder{ascNullsFirstOrder};
+      // The expectedOrder is ascNullsFirstOrder for the case
+      // where no compare flags are provided.
+      if (flags.has_value()) {
+        changeSortingOrder<T>(expectedOrder, flags.value());
       }
-      VectorPtr result = vectorMaker.template flatVectorNullable<T>(sorted);
-      assertEqualVectors(expected, result);
+      auto expected = generateExpectedVector(expectedOrder);
+
+      testRowContainerCompareAPIs(type, values, expected, flags);
     }
-    // Verify compareRows method with default compare flags.
-    if (ascending && nullsFirst) {
-      std::sort(
-          indexedRows.begin(),
-          indexedRows.end(),
-          [&](const std::pair<int, char*>& l, const std::pair<int, char*>& r) {
-            return rowContainer->compareRows(l.second, r.second) < 0;
-          });
-      std::vector<std::optional<T>> sorted;
-      for (const auto& irow : indexedRows) {
-        if (decoded.isNullAt(irow.first)) {
-          sorted.push_back(std::nullopt);
-        } else {
-          sorted.push_back(decoded.valueAt<T>(irow.first));
-        }
+
+    testRowContainerEqualityEdgeValues(type, values);
+  }
+
+#define TEST_FLOATING_TYPE_LIMIT_VARIABLES        \
+  auto lowest = std::numeric_limits<T>::lowest(); \
+  auto min = std::numeric_limits<T>::min();       \
+  auto max = std::numeric_limits<T>::max();       \
+  auto nan = std::numeric_limits<T>::quiet_NaN(); \
+  auto inf = std::numeric_limits<T>::infinity()
+
+  template <typename T>
+  void testComparePrimitiveFloats(const TypePtr& type) {
+    TEST_FLOATING_TYPE_LIMIT_VARIABLES;
+
+    auto values = makeNullableFlatVector<T>(
+        {std::nullopt, max, inf, 0.0, nan, lowest, min});
+
+    std::vector<std::optional<T>> ascNullsFirstOrder = {
+        std::nullopt, lowest, 0.0, min, max, inf, nan};
+
+    testOrderAndEqualsWithNullsFirstVariations<T>(
+        type, values, ascNullsFirstOrder, [&](const auto& expectedOrder) {
+          return makeNullableFlatVector<T>(expectedOrder);
+        });
+  }
+
+  /// This function constructions a vector of random floating point
+  /// values including special floating point values as well as an
+  /// boolean result vector. The result vector contains the expected
+  /// boolean result if a value at data vector position i is compared
+  /// with a NaN.
+  template <typename T>
+  void populateFloatingPointTestVectorsForNaNComparison(
+      int32_t numRows,
+      std::vector<std::optional<T>>& rawData,
+      std::vector<bool>& rawExpected) {
+    TEST_FLOATING_TYPE_LIMIT_VARIABLES;
+    std::mt19937 gen(numRows);
+
+    std::vector<std::optional<T>> rawSpecialValues = {
+        std::nullopt, min, 0.0, lowest, max, inf};
+    std::vector<bool> rawExpectedSpecialValues(rawSpecialValues.size(), false);
+    // Make sure the null value is at the beginning of the dataset.
+    // This knowledge is later used to build vectors without null values.
+    rawData.insert(
+        rawData.end(), rawSpecialValues.begin(), rawSpecialValues.end());
+    rawExpected.insert(
+        rawExpected.end(),
+        rawExpectedSpecialValues.begin(),
+        rawExpectedSpecialValues.end());
+
+    while (numRows) {
+      auto value = folly::Random::randDouble(min, max, gen);
+      // Intersperse nan values.
+      if (static_cast<int64_t>(std::fmod(value, 3.0)) == 0) {
+        rawData.push_back(nan);
+        rawExpected.push_back(true);
+      } else {
+        rawData.push_back(value);
+        rawExpected.push_back(false);
       }
-      VectorPtr result = vectorMaker.template flatVectorNullable<T>(sorted);
-      assertEqualVectors(expected, result);
+      --numRows;
+    }
+  }
+
+  template <typename T>
+  void runTestNanEquals(
+      const TypePtr& type,
+      const VectorPtr& lhs,
+      const VectorPtr& rhs,
+      const std::vector<bool>& rawExpected) {
+    auto numRows = lhs->size();
+    EXPECT_EQ(numRows, rawExpected.size());
+    EXPECT_EQ(numRows, rhs->size());
+
+    testRowContainerEqualsAPI<true>(type, lhs, rhs, rawExpected);
+
+    // Remove nulls and re-run.
+    auto numNulls = BaseVector::countNulls(lhs->nulls(), 0, numRows);
+    auto lhsNoNulls = lhs->slice(numNulls, numRows - numNulls);
+    auto rhsNoNulls = rhs->slice(numNulls, numRows - numNulls);
+    std::vector<bool> rawExpectedNoNulls(
+        rawExpected.cbegin() + numNulls, rawExpected.cend());
+    EXPECT_EQ(lhsNoNulls->size(), rawExpectedNoNulls.size());
+    testRowContainerEqualsAPI<false>(
+        type, lhsNoNulls, rhsNoNulls, rawExpectedNoNulls);
+  }
+
+  template <typename T>
+  void testNanEqualsPrimitiveFloats(const TypePtr& type) {
+    constexpr auto nan = std::numeric_limits<T>::quiet_NaN();
+    constexpr int32_t kNumRows = 100;
+    std::vector<std::optional<T>> rawValues;
+    std::vector<bool> rawExpected;
+
+    populateFloatingPointTestVectorsForNaNComparison<T>(
+        kNumRows, rawValues, rawExpected);
+    auto nanVector = makeConstant<T>(nan, rawValues.size());
+    auto values = makeNullableFlatVector<T>(rawValues);
+    runTestNanEquals<T>(type, values, nanVector, rawExpected);
+  }
+
+  template <typename T>
+  void testCompareArrayFloats(const TypePtr& type) {
+    TEST_FLOATING_TYPE_LIMIT_VARIABLES;
+
+    auto values = makeNullableArrayVector<T>(
+        {std::nullopt,
+         {{std::nullopt}},
+         {{max}},
+         {{inf}},
+         {{0.0}},
+         {{nan}},
+         {{lowest}},
+         {{min}}});
+
+    std::vector<std::optional<std::vector<std::optional<T>>>>
+        ascNullsFirstOrder = {
+            std::nullopt,
+            {{std::nullopt}},
+            {{lowest}},
+            {{0.0}},
+            {{min}},
+            {{max}},
+            {{inf}},
+            {{nan}}};
+
+    testOrderAndEqualsWithNullsFirstVariations<std::vector<std::optional<T>>>(
+        type, values, ascNullsFirstOrder, [&](const auto& expectedOrder) {
+          return makeNullableArrayVector<T>(expectedOrder);
+        });
+  }
+
+  template <typename T>
+  void testNanEqualsArrayFloats(const TypePtr& type) {
+    constexpr auto nan = std::numeric_limits<T>::quiet_NaN();
+    constexpr int32_t kNumRows = 100;
+    std::vector<std::optional<T>> rawValues;
+    std::vector<bool> rawExpected;
+    std::vector<std::optional<std::vector<std::optional<T>>>> rawArrayData;
+    std::vector<std::vector<T>> rawNanArrayData;
+
+    rawArrayData.push_back(std::nullopt);
+    rawExpected.push_back(false);
+    rawNanArrayData.push_back({nan});
+
+    populateFloatingPointTestVectorsForNaNComparison<T>(
+        kNumRows, rawValues, rawExpected);
+
+    for (auto value : rawValues) {
+      std::vector<std::optional<T>> temp = {value};
+      rawArrayData.push_back(temp);
+      rawNanArrayData.push_back({nan});
+    }
+
+    auto arrayData = makeNullableArrayVector<T>(rawArrayData);
+    auto nanArrayData = makeArrayVector<T>(rawNanArrayData);
+    runTestNanEquals<T>(type, arrayData, nanArrayData, rawExpected);
+  }
+
+  template <typename T>
+  void testCompareMapFloats(const TypePtr& type) {
+    TEST_FLOATING_TYPE_LIMIT_VARIABLES;
+
+    auto values = makeNullableMapVector<T, int32_t>(
+        {{{std::nullopt}},
+         {{{max, 1}}},
+         {{{inf, 2}}},
+         {{{0.0, 3}}},
+         {{{nan, 4}}},
+         {{{lowest, 5}}},
+         {{{min, 6}}}});
+
+    std::vector<
+        std::optional<std::vector<std::pair<T, std::optional<int32_t>>>>>
+        ascNullsFirstOrder{
+            {{std::nullopt}},
+            {{{lowest, 5}}},
+            {{{0.0, 3}}},
+            {{{min, 6}}},
+            {{{max, 1}}},
+            {{{inf, 2}}},
+            {{{nan, 4}}}};
+
+    testOrderAndEqualsWithNullsFirstVariations<
+        std::vector<std::pair<T, std::optional<int32_t>>>>(
+        type, values, ascNullsFirstOrder, [&](const auto& expectedOrder) {
+          return makeNullableMapVector<T, int32_t>(expectedOrder);
+        });
+  }
+
+  template <typename T>
+  void testNanEqualsMapFloats(const TypePtr& type) {
+    constexpr auto nan = std::numeric_limits<T>::quiet_NaN();
+    constexpr int32_t kNumRows = 100;
+    std::vector<std::optional<T>> rawValues;
+    std::vector<bool> rawExpected;
+    std::vector<
+        std::optional<std::vector<std::pair<T, std::optional<int32_t>>>>>
+        rawMapData;
+    std::vector<std::vector<std::pair<T, std::optional<int32_t>>>>
+        rawNanMapData;
+
+    rawMapData.push_back({std::nullopt});
+    rawExpected.push_back(false);
+    rawNanMapData.push_back({{{nan, std::nullopt}}});
+
+    populateFloatingPointTestVectorsForNaNComparison<T>(
+        kNumRows, rawValues, rawExpected);
+    // Remove nulls in data because keys cannot be null.
+    auto numNulls = countLeadingNulls(rawValues);
+    rawValues.erase(rawValues.begin(), rawValues.begin() + numNulls);
+    rawExpected.erase(rawExpected.begin(), rawExpected.begin() + numNulls);
+    std::optional<int32_t> second = 0;
+    for (auto value : rawValues) {
+      std::vector<std::pair<T, std::optional<int32_t>>> temp{
+          {{value.value(), second}}};
+      rawMapData.push_back(temp);
+      rawNanMapData.push_back({{{nan, second}}});
+      ++second.value();
+    }
+
+    auto mapData = makeNullableMapVector<T, int32_t>(rawMapData);
+    auto nanMapData = makeMapVector<T, int32_t>(rawNanMapData);
+    runTestNanEquals<T>(type, mapData, nanMapData, rawExpected);
+  }
+
+  template <typename T>
+  void testCompareRowFloats(const TypePtr& type) {
+    TEST_FLOATING_TYPE_LIMIT_VARIABLES;
+
+    auto values = makeRowVector({makeNullableFlatVector<T>(
+        {std::nullopt, max, inf, 0.0, nan, lowest, min})});
+
+    std::vector<std::optional<T>> ascNullsFirstOrder = {
+        std::nullopt, lowest, 0.0, min, max, inf, nan};
+
+    testOrderAndEqualsWithNullsFirstVariations<T>(
+        type, values, ascNullsFirstOrder, [&](const auto& expectedOrder) {
+          return makeRowVector({makeNullableFlatVector<T>(expectedOrder)});
+        });
+  }
+
+  template <typename T>
+  void testNanEqualsRowFloats(const TypePtr& type) {
+    constexpr auto nan = std::numeric_limits<T>::quiet_NaN();
+    constexpr int32_t kNumRows = 100;
+    std::vector<std::optional<T>> rawValues;
+    std::vector<bool> rawExpected;
+
+    populateFloatingPointTestVectorsForNaNComparison<T>(
+        kNumRows, rawValues, rawExpected);
+
+    auto rowData = makeRowVector({makeNullableFlatVector<T>(rawValues)});
+    auto nanRowData = makeRowVector({makeConstant<T>(nan, rawValues.size())});
+    runTestNanEquals<T>(type, rowData, nanRowData, rawExpected);
+  }
+#undef TEST_FLOATING_TYPE_LIMIT_VARIABLES
+
+  template <typename T>
+  void testEqualAndCompareRowContainerTypeFloat(const TypePtr& type) {
+    if (type->isPrimitiveType()) {
+      testComparePrimitiveFloats<T>(type);
+      testNanEqualsPrimitiveFloats<T>(type);
+    } else if (type->isArray()) {
+      testCompareArrayFloats<T>(type);
+      testNanEqualsArrayFloats<T>(type);
+    } else if (type->isMap()) {
+      testCompareMapFloats<T>(type);
+      testNanEqualsMapFloats<T>(type);
+    } else if (type->isRow()) {
+      testCompareRowFloats<T>(type);
+      testNanEqualsRowFloats<T>(type);
     }
   }
 };
@@ -592,10 +1004,14 @@ TEST_F(RowContainerTest, types) {
       if (column < keys.size()) {
         EXPECT_TRUE(
             data->equals<false>(rows[i], data->columnAt(column), decoded, i));
-      } else {
+      } else if (!columnType->isMap()) {
         EXPECT_TRUE(
             data->equals<true>(rows[i], data->columnAt(column), decoded, i));
       }
+      // Non-key map columns are not comparable, as the map keys are not sorted.
+      if (columnType->isMap() && column >= keys.size()) {
+        continue;
+      }
       if (i > 0) {
         // We compare the values on consecutive rows.
         auto result = sign(source->compare(source.get(), i, i - 1));
@@ -814,6 +1230,53 @@ TEST_F(RowContainerTest, rowSize) {
   EXPECT_EQ(rows, rowsFromContainer);
 }
 
+TEST_F(RowContainerTest, columnSize) {
+  const uint64_t kNumRows = 1000;
+  auto rowContainer =
+      makeRowContainer({BIGINT(), VARCHAR()}, {BIGINT(), VARCHAR()});
+
+  VectorFuzzer fuzzer(
+      {
+          .vectorSize = kNumRows,
+          .stringLength = 100,
+          .stringVariableLength = true,
+      },
+      pool());
+
+  auto rowVector =
+      fuzzer.fuzzInputFlatRow(ROW({BIGINT(), VARCHAR(), BIGINT(), VARCHAR()}));
+
+  std::vector<char*> rows;
+  rows.reserve(kNumRows);
+
+  ASSERT_EQ(rowContainer->numRows(), 0);
+  SelectivityVector allRows(kNumRows);
+  DecodedVector decodedKey1(*rowVector->childAt(0), allRows);
+  DecodedVector decodedKey2(*rowVector->childAt(1), allRows);
+  DecodedVector decodedDep1(*rowVector->childAt(2), allRows);
+  DecodedVector decodedDep2(*rowVector->childAt(3), allRows);
+  for (size_t i = 0; i < kNumRows; i++) {
+    auto row = rowContainer->newRow();
+    rowContainer->store(decodedKey1, i, row, 0);
+    rowContainer->store(decodedKey2, i, row, 1);
+    rowContainer->store(decodedDep1, i, row, 2);
+    rowContainer->store(decodedDep2, i, row, 3);
+    rows.push_back(row);
+  }
+  ASSERT_EQ(rowContainer->fixedSizeAt(0), 8);
+  ASSERT_EQ(rowContainer->fixedSizeAt(2), 8);
+  const auto key2Vector = rowVector->childAt(1)->asFlatVector<StringView>();
+  const auto dep2Vector = rowVector->childAt(3)->asFlatVector<StringView>();
+  for (size_t i = 0; i < kNumRows; i++) {
+    ASSERT_EQ(
+        rowContainer->variableSizeAt(rows[i], 1),
+        key2Vector->valueAt(i).size());
+    ASSERT_EQ(
+        rowContainer->variableSizeAt(rows[i], 3),
+        dep2Vector->valueAt(i).size());
+  }
+}
+
 TEST_F(RowContainerTest, rowSizeWithNormalizedKey) {
   auto data = makeRowContainer({SMALLINT()}, {VARCHAR()});
   data->newRow();
@@ -856,64 +1319,15 @@ TEST_F(RowContainerTest, estimateRowSize) {
   EXPECT_EQ(0x440000, rowContainer->stringAllocator().retainedSize());
 }
 
-class AggregateWithAlignment : public Aggregate {
- public:
-  explicit AggregateWithAlignment(TypePtr resultType, int alignment)
-      : Aggregate(std::move(resultType)), alignment_(alignment) {}
-
-  int32_t accumulatorFixedWidthSize() const override {
-    return 42;
-  }
-
-  int32_t accumulatorAlignmentSize() const override {
-    return alignment_;
-  }
-
-  void initializeNewGroups(
-      char** /*groups*/,
-      folly::Range<const vector_size_t*> /*indices*/) override {}
-
-  void addRawInput(
-      char** /*groups*/,
-      const SelectivityVector& /*rows*/,
-      const std::vector<VectorPtr>& /*args*/,
-      bool /*mayPushdown*/) override {}
-
-  void extractValues(
-      char** /*groups*/,
-      int32_t /*numGroups*/,
-      VectorPtr* /*result*/) override {}
-
-  void addIntermediateResults(
-      char** /*groups*/,
-      const SelectivityVector& /*rows*/,
-      const std::vector<VectorPtr>& /*args*/,
-      bool /*mayPushdown*/) override {}
-
-  void addSingleGroupRawInput(
-      char* /*group*/,
-      const SelectivityVector& /*rows*/,
-      const std::vector<VectorPtr>& /*args*/,
-      bool /*mayPushdown*/) override {}
-
-  void addSingleGroupIntermediateResults(
-      char* /*group*/,
-      const SelectivityVector& /*rows*/,
-      const std::vector<VectorPtr>& /*args*/,
-      bool /*mayPushdown*/) override {}
-
-  void extractAccumulators(
-      char** /*groups*/,
-      int32_t /*numGroups*/,
-      VectorPtr* /*result*/) override {}
-
- private:
-  int alignment_;
-};
-
 TEST_F(RowContainerTest, alignment) {
-  AggregateWithAlignment aggregate(BIGINT(), 64);
-  std::vector<Accumulator> accumulators{Accumulator(&aggregate)};
+  std::vector<Accumulator> accumulators{Accumulator(
+      true, // isFixedSize
+      42, // fixedSize
+      false, // usesExternalMemory
+      64, // alignment
+      nullptr, // spillType
+      [](auto, auto) { VELOX_UNREACHABLE(); },
+      [](auto) {})};
   RowContainer data(
       {SMALLINT()},
       true,
@@ -944,24 +1358,40 @@ TEST_F(RowContainerTest, alignment) {
   }
 }
 
-// Verify comparison of fringe float valuesg
-TEST_F(RowContainerTest, compareFloat) {
-  // Verify ascending order
-  testCompareFloats<float>(REAL(), true, true);
-  testCompareFloats<float>(REAL(), true, false);
-  //  Verify descending order
-  testCompareFloats<float>(REAL(), false, true);
-  testCompareFloats<float>(REAL(), false, false);
+// Verify comparison of fringe float values
+TEST_F(RowContainerTest, equalAndCompareFloat) {
+  testEqualAndCompareRowContainerTypeFloat<float>(REAL());
 }
 
 // Verify comparison of fringe double values
-TEST_F(RowContainerTest, compareDouble) {
-  // Verify ascending order
-  testCompareFloats<double>(DOUBLE(), true, true);
-  testCompareFloats<double>(DOUBLE(), true, false);
-  // Verify descending order
-  testCompareFloats<double>(DOUBLE(), false, true);
-  testCompareFloats<double>(DOUBLE(), false, false);
+TEST_F(RowContainerTest, equalAndCompareDouble) {
+  testEqualAndCompareRowContainerTypeFloat<double>(DOUBLE());
+}
+
+TEST_F(RowContainerTest, equalAndCompareArrayTypeFloat) {
+  testEqualAndCompareRowContainerTypeFloat<float>(ARRAY(REAL()));
+}
+
+TEST_F(RowContainerTest, equalAndCompareArrayTypeDouble) {
+  testEqualAndCompareRowContainerTypeFloat<double>(ARRAY(DOUBLE()));
+}
+
+TEST_F(RowContainerTest, equalAndCompareMapTypeFloat) {
+  testEqualAndCompareRowContainerTypeFloat<float>(MAP(REAL(), INTEGER()));
+}
+
+TEST_F(RowContainerTest, equalAndCompareMapTypeDouble) {
+  testEqualAndCompareRowContainerTypeFloat<double>(MAP(DOUBLE(), INTEGER()));
+}
+
+TEST_F(RowContainerTest, equalAndCompareRowTypeFloat) {
+  static const std::string colName{"floatCol"};
+  testEqualAndCompareRowContainerTypeFloat<float>(ROW({colName}, {REAL()}));
+}
+
+TEST_F(RowContainerTest, equalAndCompareRowTypeDouble) {
+  static const std::string colName{"doubleCol"};
+  testEqualAndCompareRowContainerTypeFloat<double>(ROW({colName}, {DOUBLE()}));
 }
 
 TEST_F(RowContainerTest, partition) {
@@ -1306,3 +1736,436 @@ TEST_F(RowContainerTest, unknown) {
         return rowContainer->compareRows(l.second, r.second) < 0;
       }));
 }
+
+TEST_F(RowContainerTest, nans) {
+  const static auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  const static auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+  static const auto kNaNHash = folly::hasher<double>{}(kNaN);
+  std::vector<TypePtr> types = {DOUBLE()};
+  auto rowContainer = std::make_unique<RowContainer>(types, pool_.get());
+
+  auto data = makeRowVector({
+      makeFlatVector<double>({kNaN, kSNaN}),
+  });
+
+  auto size = data->size();
+  DecodedVector decoded(*data->childAt(0));
+  auto rows = store(*rowContainer, decoded, size);
+
+  // Verify that the hashes are equal.
+  std::vector<uint64_t> hashes(size, 0);
+  rowContainer->hash(
+      0, folly::Range(rows.data(), rows.size()), false /*mix*/, hashes.data());
+  for (auto hash : hashes) {
+    ASSERT_EQ(kNaNHash, hash);
+  }
+
+  // Fill in hashes with sequential numbers: 0, 1, 2,..
+  std::iota(hashes.begin(), hashes.end(), 0);
+  rowContainer->hash(
+      0, folly::Range(rows.data(), rows.size()), true /*mix*/, hashes.data());
+  for (auto i = 0; i < size; ++i) {
+    ASSERT_EQ(bits::hashMix(i, kNaNHash), hashes[i]);
+  }
+
+  // Verify that they are considered equal.
+  for (size_t row = 0; row < size; ++row) {
+    ASSERT_TRUE(rowContainer->equals<false>(
+        rows[row], rowContainer->columnAt(0), decoded, row));
+  }
+  ASSERT_EQ(rowContainer->compare(rows[0], rows[1], 0, {}), 0);
+}
+
+TEST_F(RowContainerTest, toString) {
+  std::vector<TypePtr> keyTypes = {BIGINT(), VARCHAR()};
+  std::vector<TypePtr> dependentTypes = {TINYINT(), REAL(), ARRAY(BIGINT())};
+  auto rowContainer =
+      std::make_unique<RowContainer>(keyTypes, dependentTypes, pool_.get());
+
+  EXPECT_EQ(
+      rowContainer->toString(),
+      "Keys: BIGINT, VARCHAR Dependents: TINYINT, REAL, ARRAY<BIGINT> Num rows: 0");
+
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<std::string>({"summer", "fall", "winter", "spring"}),
+      makeFlatVector<int16_t>({11, 12, 13}),
+      makeFlatVector<float>({0.1, 2.34, 123.003}),
+      makeArrayVectorFromJson<int64_t>({"[1, 2, 3]", "[4, 5]", "null"}),
+  });
+
+  std::vector<DecodedVector> decoded;
+  for (auto i = 0; i < data->childrenSize(); ++i) {
+    decoded.emplace_back(*data->childAt(i));
+  }
+
+  const auto numRows = data->size();
+  std::vector<char*> rows(numRows);
+  for (auto row = 0; row < numRows; ++row) {
+    rows[row] = rowContainer->newRow();
+    for (auto i = 0; i < decoded.size(); ++i) {
+      rowContainer->store(decoded[i], row, rows[row], i);
+    }
+  }
+
+  EXPECT_EQ(
+      rowContainer->toString(),
+      "Keys: BIGINT, VARCHAR Dependents: TINYINT, REAL, ARRAY<BIGINT> Num rows: 3");
+
+  EXPECT_EQ(
+      rowContainer->toString(rows[0]),
+      "{1, summer, 11, 0.10000000149011612, 3 elements starting at 0 {1, 2, 3}}");
+  EXPECT_EQ(
+      rowContainer->toString(rows[1]),
+      "{2, fall, 0, 2.3399999141693115, 2 elements starting at 0 {4, 5}}");
+  EXPECT_EQ(
+      rowContainer->toString(rows[2]),
+      "{3, winter, 12, 123.00299835205078, null}");
+}
+
+TEST_F(RowContainerTest, partialWriteComplexTypedRow) {
+  auto data = makeRowVector(
+      {makeFlatVector<int64_t>(1, [](auto row) { return row; }),
+       makeFlatVector<std::string>({"non-inline string"}),
+       makeArrayVector<int64_t>({{1, 2, 3, 4, 5}}),
+       makeMapVector<int64_t, int64_t>({{{4, 41}}}),
+       makeRowVector({makeFlatVector<std::string>({"non-inline string"})})});
+
+  auto rowContainer = std::make_unique<RowContainer>(
+      data->type()->asRow().children(), pool_.get());
+
+  std::vector<DecodedVector> decodedVectors;
+  for (auto& vectorPtr : data->children()) {
+    decodedVectors.emplace_back(*vectorPtr);
+  }
+
+  // No write at all.
+  auto row = rowContainer->newRow();
+  rowContainer->initializeFields(row);
+  rowContainer->eraseRows(folly::Range<char**>(&row, 1));
+
+  row = rowContainer->newRow();
+  rowContainer->initializeFields(row);
+  for (auto i = 0; i < decodedVectors.size(); ++i) {
+    rowContainer->store(decodedVectors[i], 0, row, i);
+  }
+  // Partial writes should not break initializeRow for reuse.
+  rowContainer->initializeRow(row, true);
+  rowContainer->initializeFields(row);
+  for (auto i = 0; i < 3; ++i) {
+    rowContainer->store(decodedVectors[i], 0, row, i);
+  }
+  rowContainer->initializeRow(row, true);
+
+  rowContainer->initializeFields(row);
+  rowContainer->eraseRows(folly::Range<char**>(&row, 1));
+}
+
+TEST_F(RowContainerTest, extractSerializedRow) {
+  VectorFuzzer fuzzer(
+      {
+          .vectorSize = 100,
+          .nullRatio = 0.1,
+      },
+      pool());
+
+  for (auto i = 0; i < 100; ++i) {
+    SCOPED_TRACE(fmt::format("Iteration #: {}", i));
+
+    auto rowType = fuzzer.randRowType();
+    auto data = fuzzer.fuzzInputRow(rowType);
+
+    SCOPED_TRACE(data->toString());
+
+    RowContainer rowContainer{rowType->children(), pool()};
+
+    auto rows = store(rowContainer, data);
+
+    // Extract serialized rows.
+    auto serialized = BaseVector::create<FlatVector<StringView>>(
+        VARBINARY(), data->size(), pool());
+    rowContainer.extractSerializedRows(
+        folly::Range(rows.data(), rows.size()), serialized);
+
+    rowContainer.clear();
+    rows.clear();
+
+    // Load serialized rows back.
+    for (auto i = 0; i < data->size(); ++i) {
+      rows.push_back(rowContainer.newRow());
+      rowContainer.storeSerializedRow(*serialized, i, rows.back());
+    }
+
+    // Extract into regular vector.
+    auto copy = BaseVector::create<RowVector>(rowType, data->size(), pool());
+    for (auto i = 0; i < copy->childrenSize(); ++i) {
+      rowContainer.extractColumn(
+          rows.data(), copy->size(), i, copy->childAt(i));
+    }
+
+    assertEqualVectors(data, copy);
+  }
+}
+
+DEBUG_ONLY_TEST_F(RowContainerTest, eraseAfterOomStoringString) {
+  auto rowContainer = makeRowContainer({VARCHAR()}, {});
+
+  std::string str(StringView::kInlineSize * 2, 'a');
+  auto stringVector = vectorMaker_.flatVector<StringView>(
+      1, [&](auto /*row*/) { return StringView(str); });
+  SelectivityVector allRows(1);
+  DecodedVector decoded(*stringVector, allRows);
+  auto row = rowContainer->newRow();
+  const std::string exceptionMsg = "Expected simulated OOM.";
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+      std::function<void(memory::MemoryPool*)>(
+          [&](memory::MemoryPool*) { VELOX_FAIL(exceptionMsg); }));
+  VELOX_ASSERT_THROW(rowContainer->store(decoded, 0, row, 0), exceptionMsg);
+
+  std::vector<char*> rows(1);
+  RowContainerIterator iter;
+  auto numRows = rowContainer->listRows(&iter, 1, rows.data());
+  VELOX_CHECK_EQ(numRows, 1);
+  // If the StringView was placed in the row before the memory was
+  // allocated in the container's string allocator, this will fail
+  // attempting to free a string the allocator doesn't own.
+  rowContainer->eraseRows(folly::Range<char**>(rows.data(), numRows));
+}
+
+TEST_F(RowContainerTest, nextRowVector) {
+  int32_t numRows = 100;
+  auto data = makeRowContainer({SMALLINT()}, {SMALLINT()});
+  EXPECT_EQ(data->nextOffset(), 11);
+  std::unordered_set<char*> rowSet;
+  std::vector<char*> rows;
+
+  auto dataClear = [&]() {
+    data->clear();
+    EXPECT_EQ(0, data->numRows());
+    auto free = data->freeSpace();
+    EXPECT_EQ(0, free.first);
+    EXPECT_EQ(0, free.second);
+    rows.clear();
+    rowSet.clear();
+  };
+
+  auto validateNextRowVector = [&]() {
+    for (int i = 0; i < rows.size(); ++i) {
+      auto vector = data->getNextRowVector(rows[i]);
+      if (vector) {
+        auto iter = std::find(vector->begin(), vector->end(), rows[i]);
+        ASSERT_NE(iter, vector->end());
+        ASSERT_TRUE(vector->size() <= 2 && vector->size() > 0);
+        for (auto next : *vector) {
+          ASSERT_EQ(data->getNextRowVector(next), vector);
+          ASSERT_TRUE(std::find(rows.begin(), rows.end(), next) != rows.end());
+        }
+      }
+    }
+  };
+
+  auto nextRowVectorAppendValidation = [&]() {
+    for (int i = 0; i < numRows; ++i) {
+      rows.push_back(data->newRow());
+      rowSet.insert(rows.back());
+      ASSERT_EQ(data->getNextRowVector(rows.back()), nullptr);
+    }
+    ASSERT_EQ(numRows, data->numRows());
+    std::vector<char*> rowsFromContainer(numRows);
+    RowContainerIterator iter;
+    ASSERT_EQ(
+        data->listRows(&iter, numRows, rowsFromContainer.data()), numRows);
+    ASSERT_EQ(0, data->listRows(&iter, numRows, rows.data()));
+    ASSERT_EQ(rows, rowsFromContainer);
+
+    for (int i = 0; i + 2 <= numRows; i += 2) {
+      data->appendNextRow(rows[i], rows[i + 1], &data->stringAllocator());
+    }
+    validateNextRowVector();
+  };
+
+  auto nextRowVectorEraseValidation = [&](const std::vector<int>& eraseRows) {
+    dataClear();
+    nextRowVectorAppendValidation();
+    std::vector<char*> erasingRows;
+    for (auto index : eraseRows) {
+      erasingRows.emplace_back(rows[index]);
+    }
+    for (auto row : erasingRows) {
+      rows.erase(std::remove(rows.begin(), rows.end(), row), rows.end());
+    }
+    data->eraseRows(
+        folly::Range<char**>(erasingRows.data(), erasingRows.size()));
+    validateNextRowVector();
+    data->checkConsistency();
+  };
+
+  nextRowVectorAppendValidation();
+  nextRowVectorEraseValidation({0, 1});
+  nextRowVectorEraseValidation({34, 35, 98, 99});
+  nextRowVectorEraseValidation({2, 3, 22, 23, 88, 89, 58, 59});
+  std::vector<int> eraseRows(numRows);
+  std::iota(eraseRows.begin(), eraseRows.end(), 0);
+  nextRowVectorEraseValidation(eraseRows);
+  VELOX_ASSERT_THROW(
+      nextRowVectorEraseValidation({1}),
+      "All rows with the same keys must be present in 'rows'");
+
+  dataClear();
+}
+
+TEST_F(RowContainerTest, hugeIntStoreWithNulls) {
+  constexpr int32_t kNumRows = 100;
+  constexpr int32_t kColumnIndex = 0;
+
+  // wrap dictionary vector
+  std::vector<int128_t> rawData;
+  for (auto i = 0; i < kNumRows; ++i) {
+    rawData.push_back(HugeInt::build(i, i));
+  }
+  auto hugeIntVector = makeFlatVector<int128_t>(rawData);
+
+  auto isNullAt = [](vector_size_t i) { return i % 10 == 0; };
+
+  BufferPtr dictNulls = allocateNulls(kNumRows, pool());
+  auto rawDictNulls = dictNulls->asMutable<uint64_t>();
+  for (auto i = 0; i < kNumRows; ++i) {
+    bits::setNull(rawDictNulls, i, isNullAt(i));
+  }
+
+  BufferPtr dictIndices =
+      AlignedBuffer::allocate<vector_size_t>(kNumRows, pool());
+  auto rawDictIndices = dictIndices->asMutable<vector_size_t>();
+  for (auto i = 0; i < kNumRows; ++i) {
+    if (!isNullAt(i)) {
+      rawDictIndices[i] = i;
+    }
+    // indices of null indexes contain garbage values
+  }
+
+  auto source = BaseVector::wrapInDictionary(
+      dictNulls, dictIndices, kNumRows, hugeIntVector);
+
+  std::vector<TypePtr> keys;
+  auto data = makeRowContainer({HUGEINT()}, {}, false);
+  std::vector<char*> rows(kNumRows);
+  for (auto i = 0; i < kNumRows; ++i) {
+    rows[i] = data->newRow();
+  }
+  SelectivityVector allRows(kNumRows);
+  DecodedVector decoded(*source, allRows);
+  for (auto i = 0; i < kNumRows; ++i) {
+    data->store(decoded, i, rows[i], kColumnIndex);
+  }
+  auto extracted = BaseVector::copy(*source);
+  data->extractColumn(rows.data(), kNumRows, kColumnIndex, extracted);
+  assertEqualVectors(source, extracted);
+}
+
+TEST_F(RowContainerTest, columnHasNulls) {
+  auto rowContainer =
+      makeRowContainer({BIGINT(), BIGINT()}, {BIGINT(), BIGINT()}, false);
+  for (int i = 0; i < rowContainer->columnTypes().size(); ++i) {
+    ASSERT_TRUE(!rowContainer->columnHasNulls(i));
+  }
+
+  const uint64_t kNumRows = 1000;
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int64_t>(kNumRows, [](auto row) { return row % 5; }),
+       makeFlatVector<int64_t>(
+           kNumRows, [](auto row) { return row % 5; }, nullEvery(3)),
+       makeFlatVector<int64_t>(kNumRows, [](auto row) { return row % 7; }),
+       makeFlatVector<int64_t>(
+           kNumRows, [](auto row) { return row % 7; }, nullEvery(999))});
+
+  std::vector<char*> rows;
+  rows.reserve(kNumRows);
+
+  ASSERT_EQ(rowContainer->numRows(), 0);
+  SelectivityVector allRows(kNumRows);
+  for (size_t i = 0; i < kNumRows; i++) {
+    auto row = rowContainer->newRow();
+    rows.push_back(row);
+  }
+  for (int i = 0; i < rowContainer->columnTypes().size(); ++i) {
+    DecodedVector decoded(*rowVector->childAt(i), allRows);
+    for (int j = 0; j < kNumRows; ++j) {
+      char* row = rows[i];
+      rowContainer->store(decoded, j, row, i);
+    }
+  }
+  for (int i = 0; i < rowContainer->columnTypes().size(); ++i) {
+    if (i % 2 == 0) {
+      ASSERT_TRUE(!rowContainer->columnHasNulls(i));
+    } else {
+      ASSERT_TRUE(rowContainer->columnHasNulls(i));
+    }
+  }
+  // If the column's mayHaveNulls is false, the extracted vector's mayHaveNulls
+  // should be false.
+  for (int i = 0; i < rowContainer->columnTypes().size(); ++i) {
+    auto vector =
+        BaseVector::create(rowVector->childAt(i)->type(), kNumRows, pool());
+    rowContainer->extractColumn(rows.data(), kNumRows, i, vector);
+    if (i % 2 == 0) {
+      ASSERT_TRUE(!vector->mayHaveNulls());
+    } else {
+      ASSERT_TRUE(vector->mayHaveNulls());
+    }
+  }
+}
+
+TEST_F(RowContainerTest, store) {
+  const uint64_t kNumRows = 1000;
+  auto rowVectorWithNulls = makeRowVector({
+      makeFlatVector<int64_t>(
+          kNumRows, [](auto row) { return row % 5; }, nullEvery(6)),
+      makeFlatVector<std::string>(
+          kNumRows,
+          [](auto row) { return fmt::format("abcdefg123_{}", row); },
+          nullEvery(7)),
+      makeFlatVector<int64_t>(
+          kNumRows, [](auto row) { return row; }, nullEvery(8)),
+      makeArrayVector<int32_t>(
+          kNumRows,
+          [](auto i) { return i % 5; },
+          [](auto i) { return i % 10; },
+          nullEvery(10)),
+  });
+
+  auto rowVectorNoNulls = makeRowVector({
+      makeFlatVector<int64_t>(kNumRows, [](auto row) { return row % 5; }),
+      makeFlatVector<std::string>(
+          kNumRows, [](auto row) { return fmt::format("abcdefg12_{}", row); }),
+      makeFlatVector<int64_t>(kNumRows, [](auto row) { return row; }),
+      makeArrayVector<int64_t>(
+          kNumRows,
+          [](auto i) { return i % 3; },
+          [](auto i) { return i % 10; }),
+  });
+  for (auto& rowVector : {rowVectorWithNulls, rowVectorNoNulls}) {
+    auto rowContainer = makeRowContainer(
+        {BIGINT(), VARCHAR()}, {BIGINT(), ARRAY(BIGINT())}, false);
+    std::vector<char*> rows;
+    rows.reserve(kNumRows);
+
+    ASSERT_EQ(rowContainer->numRows(), 0);
+    SelectivityVector allRows(kNumRows);
+    for (size_t i = 0; i < kNumRows; i++) {
+      auto row = rowContainer->newRow();
+      rows.push_back(row);
+    }
+    for (int i = 0; i < rowContainer->columnTypes().size(); ++i) {
+      DecodedVector decoded(*rowVector->childAt(i), allRows);
+      rowContainer->store(decoded, folly::Range(rows.data(), kNumRows), i);
+    }
+    ASSERT_EQ(rowContainer->numRows(), kNumRows);
+    for (int i = 0; i < rowContainer->columnTypes().size(); ++i) {
+      auto vector =
+          BaseVector::create(rowVector->childAt(i)->type(), kNumRows, pool());
+      rowContainer->extractColumn(rows.data(), kNumRows, i, vector);
+      assertEqualVectors(rowVector->childAt(i), vector);
+    }
+  }
+}
diff --git a/velox/exec/tests/RowNumberFuzzerTest.cpp b/velox/exec/tests/RowNumberFuzzerTest.cpp
new file mode 100644
index 0000000000000..3813e0a7942f3
--- /dev/null
+++ b/velox/exec/tests/RowNumberFuzzerTest.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <unordered_set>
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/MemoryReclaimer.h"
+#include "velox/exec/fuzzer/DuckQueryRunner.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/exec/fuzzer/RowNumberFuzzerRunner.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+DEFINE_string(
+    presto_url,
+    "",
+    "Presto coordinator URI along with port. If set, we use Presto "
+    "source of truth. Otherwise, use DuckDB. Example: "
+    "--presto_url=http://127.0.0.1:8080");
+
+DEFINE_uint32(
+    req_timeout_ms,
+    1000,
+    "Timeout in milliseconds for HTTP requests made to reference DB, "
+    "such as Presto. Example: --req_timeout_ms=2000");
+
+DEFINE_int64(allocator_capacity, 8L << 30, "Allocator capacity in bytes.");
+
+DEFINE_int64(arbitrator_capacity, 6L << 30, "Arbitrator capacity in bytes.");
+
+using namespace facebook::velox::exec;
+
+namespace {
+std::unique_ptr<test::ReferenceQueryRunner> setupReferenceQueryRunner(
+    facebook::velox::memory::MemoryPool* aggregatePool,
+    const std::string& prestoUrl,
+    const std::string& runnerName,
+    const uint32_t& reqTimeoutMs) {
+  if (prestoUrl.empty()) {
+    auto duckQueryRunner =
+        std::make_unique<test::DuckQueryRunner>(aggregatePool);
+    LOG(INFO) << "Using DuckDB as the reference DB.";
+    return duckQueryRunner;
+  }
+
+  LOG(INFO) << "Using Presto as the reference DB.";
+  return std::make_unique<test::PrestoQueryRunner>(
+      aggregatePool,
+      prestoUrl,
+      runnerName,
+      static_cast<std::chrono::milliseconds>(reqTimeoutMs));
+}
+} // namespace
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+  test::setupMemory(FLAGS_allocator_capacity, FLAGS_arbitrator_capacity);
+  std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
+      facebook::velox::memory::memoryManager()->addRootPool()};
+  auto referenceQueryRunner = setupReferenceQueryRunner(
+      rootPool.get(),
+      FLAGS_presto_url,
+      "row_number_fuzzer",
+      FLAGS_req_timeout_ms);
+  const size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+  return test::RowNumberFuzzerRunner::run(
+      initialSeed, std::move(referenceQueryRunner));
+}
diff --git a/velox/exec/tests/RowNumberTest.cpp b/velox/exec/tests/RowNumberTest.cpp
index 22fee689601b3..635263d169cc1 100644
--- a/velox/exec/tests/RowNumberTest.cpp
+++ b/velox/exec/tests/RowNumberTest.cpp
@@ -13,12 +13,36 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 namespace facebook::velox::exec::test {
 
-class RowNumberTest : public OperatorTestBase {};
+class RowNumberTest : public OperatorTestBase {
+ protected:
+  RowNumberTest() {
+    filesystems::registerLocalFileSystem();
+    rowType_ = ROW(
+        {{"c0", INTEGER()},
+         {"c1", INTEGER()},
+         {"c2", VARCHAR()},
+         {"c3", VARCHAR()}});
+    fuzzerOpts_.vectorSize = 1024;
+    fuzzerOpts_.nullRatio = 0;
+    fuzzerOpts_.stringVariableLength = false;
+    fuzzerOpts_.stringLength = 1024;
+    fuzzerOpts_.allowLazyVector = false;
+  }
+
+  RowTypePtr rowType_;
+  VectorFuzzer::Options fuzzerOpts_;
+};
 
 TEST_F(RowNumberTest, basic) {
   auto data = makeRowVector({
@@ -166,4 +190,380 @@ TEST_F(RowNumberTest, largeInput) {
   testLimit(5'000);
 }
 
+TEST_F(RowNumberTest, spill) {
+  std::vector<RowVectorPtr> vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  struct {
+    uint32_t spillPartitionBits;
+
+    std::string debugString() const {
+      return fmt::format("SpillPartitionBits {}", spillPartitionBits);
+    }
+  } testSettings[] = {{2}, {3}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    TestScopedSpillInjection scopedSpillInjection(100, ".*", 1);
+
+    core::PlanNodeId rowNumberPlanNodeId;
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kRowNumberSpillEnabled, true)
+            .config(
+                core::QueryConfig::kSpillNumPartitionBits,
+                testData.spillPartitionBits)
+            .queryCtx(queryCtx)
+            .plan(PlanBuilder()
+                      .values(vectors)
+                      .rowNumber({"c0"})
+                      .capturePlanNodeId(rowNumberPlanNodeId)
+                      .planNode())
+            .assertResults(
+                "SELECT *, row_number() over (partition by c0) FROM tmp");
+    auto taskStats = toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(rowNumberPlanNodeId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_EQ(
+        planStats.spilledPartitions,
+        (static_cast<uint32_t>(1) << testData.spillPartitionBits) * 2);
+    ASSERT_GT(planStats.spilledFiles, 0);
+    ASSERT_GT(planStats.spilledRows, 0);
+    auto operatorStats =
+        task->taskStats().pipelineStats.back().operatorStats.at(1);
+    auto runtimeStats = operatorStats.runtimeStats;
+    ASSERT_EQ(
+        runtimeStats.at(Operator::kSpillReadBytes).sum,
+        operatorStats.spilledBytes);
+    ASSERT_GT(runtimeStats.at(Operator::kSpillReads).sum, 0);
+    ASSERT_GT(runtimeStats.at(Operator::kSpillReadTime).sum, 0);
+    ASSERT_GT(runtimeStats.at(Operator::kSpillDeserializationTime).sum, 0);
+
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+TEST_F(RowNumberTest, maxSpillBytes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto vectors = createVectors(rowType, 1024, 15 << 20);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(vectors)
+                  .rowNumber({"c0"}, 2, false)
+                  .project({"c0", "c1"})
+                  .planNode();
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {1 << 20, true}, {0, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100, ".*", 1);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kRowNumberSpillEnabled, true)
+          .config(core::QueryConfig::kMaxSpillBytes, testData.maxSpilledBytes)
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find(
+              "Query exceeded per-query local spill limit of 1.00MB"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+  }
+}
+
+TEST_F(RowNumberTest, memoryUsage) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto vectors = createVectors(rowType, 1024, 100 << 20);
+  core::PlanNodeId rowNumberId;
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .rowNumber({"c0", "c2"})
+                  .capturePlanNodeId(rowNumberId)
+                  .project({"c0", "c1"})
+                  .planNode();
+
+  struct {
+    uint8_t numSpills;
+
+    std::string debugString() const {
+      return fmt::format("numSpills {}", numSpills);
+    }
+  } testSettings[] = {{1}, {3}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    int64_t peakBytesWithSpilling = 0;
+    int64_t peakBytesWithOutSpilling = 0;
+
+    for (const auto& spillEnable : {false, true}) {
+      auto queryCtx = core::QueryCtx::create(executor_.get());
+      auto spillDirectory = exec::test::TempDirectoryPath::create();
+      const std::string spillEnableConfig = std::to_string(spillEnable);
+
+      std::shared_ptr<Task> task;
+      TestScopedSpillInjection scopedSpillInjection(
+          100, ".*", testData.numSpills);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, spillEnableConfig)
+          .config(core::QueryConfig::kRowNumberSpillEnabled, spillEnableConfig)
+          .spillDirectory(spillDirectory->getPath())
+          .copyResults(pool_.get(), task);
+
+      if (spillEnable) {
+        peakBytesWithSpilling = queryCtx->pool()->peakBytes();
+        auto taskStats = exec::toPlanStats(task->taskStats());
+        const auto& stats = taskStats.at(rowNumberId);
+
+        ASSERT_GT(stats.spilledBytes, 0);
+        ASSERT_GT(stats.spilledRows, 0);
+        ASSERT_GT(stats.spilledFiles, 0);
+        ASSERT_GT(stats.spilledPartitions, 0);
+      } else {
+        peakBytesWithOutSpilling = queryCtx->pool()->peakBytes();
+      }
+    }
+
+    ASSERT_GE(peakBytesWithOutSpilling / peakBytesWithSpilling, 2);
+  }
+}
+
+DEBUG_ONLY_TEST_F(RowNumberTest, spillOnlyDuringInputOrOutput) {
+  std::vector<RowVectorPtr> vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  struct {
+    std::string spillInjectionPoint;
+    uint32_t spillPartitionBits;
+
+    std::string debugString() const {
+      return fmt::format(
+          "Spill during {}, spillPartitionBits {}",
+          spillInjectionPoint,
+          spillPartitionBits);
+    }
+  } testSettings[] = {
+      {"facebook::velox::exec::Driver::runInternal::addInput", 2},
+      {"facebook::velox::exec::Driver::runInternal::getOutput", 2},
+      {"facebook::velox::exec::Driver::runInternal::addInput", 3},
+      {"facebook::velox::exec::Driver::runInternal::getOutput", 3}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+
+    std::atomic_int numRound{0};
+    SCOPED_TESTVALUE_SET(
+        testData.spillInjectionPoint,
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "RowNumber") {
+            return;
+          }
+
+          if (++numRound != 8) {
+            return;
+          }
+
+          testingRunArbitration(op->pool(), 0);
+        })));
+
+    core::PlanNodeId rowNumberPlanNodeId;
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kRowNumberSpillEnabled, true)
+            .config(
+                core::QueryConfig::kSpillNumPartitionBits,
+                testData.spillPartitionBits)
+            .queryCtx(queryCtx)
+            .plan(PlanBuilder()
+                      .values(vectors)
+                      .rowNumber({"c0"})
+                      .capturePlanNodeId(rowNumberPlanNodeId)
+                      .planNode())
+            .assertResults(
+                "SELECT *, row_number() over (partition by c0) FROM tmp");
+    auto taskStats = toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(rowNumberPlanNodeId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_EQ(
+        planStats.spilledPartitions,
+        (static_cast<uint32_t>(1) << testData.spillPartitionBits) * 2);
+    ASSERT_GT(planStats.spilledFiles, 0);
+    ASSERT_GT(planStats.spilledRows, 0);
+
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+DEBUG_ONLY_TEST_F(RowNumberTest, recursiveSpill) {
+  std::vector<RowVectorPtr> vectors = createVectors(32, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  struct {
+    int32_t numSpills;
+    int32_t maxSpillLevel;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numSpills {}, maxSpillLevel {}", numSpills, maxSpillLevel);
+    }
+  } testSettings[] = {{2, 3}, {8, 4}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+
+    std::atomic_int numSpills{0};
+    std::atomic_int numInputs{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "RowNumber") {
+            return;
+          }
+
+          if (++numInputs != 5) {
+            return;
+          }
+
+          ++numSpills;
+          testingRunArbitration(op->pool(), 0);
+        })));
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "RowNumber") {
+            return;
+          }
+
+          if (!op->testingNoMoreInput()) {
+            return;
+          }
+
+          if (numSpills++ >= testData.numSpills) {
+            return;
+          }
+
+          testingRunArbitration(op->pool(), 0);
+        })));
+
+    core::PlanNodeId rowNumberPlanNodeId;
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kRowNumberSpillEnabled, true)
+            .config(
+                core::QueryConfig::kMaxSpillLevel, testData.maxSpillLevel - 1)
+            .queryCtx(queryCtx)
+            .plan(PlanBuilder()
+                      .values(vectors)
+                      .rowNumber({"c0"})
+                      .capturePlanNodeId(rowNumberPlanNodeId)
+                      .planNode())
+            .assertResults(
+                "SELECT *, row_number() over (partition by c0) FROM tmp");
+    auto taskStats = toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(rowNumberPlanNodeId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_EQ(
+        planStats.spilledPartitions,
+        8 * 2 * std::min(testData.numSpills, testData.maxSpillLevel));
+    ASSERT_GT(planStats.spilledFiles, 0);
+    ASSERT_GT(planStats.spilledRows, 0);
+
+    auto runTimeStats =
+        task->taskStats().pipelineStats.back().operatorStats.at(1).runtimeStats;
+    if (testData.numSpills > testData.maxSpillLevel) {
+      ASSERT_GT(runTimeStats["exceededMaxSpillLevel"].sum, 0);
+    } else {
+      ASSERT_EQ(runTimeStats.count("exceededMaxSpillLevel"), 0);
+    }
+
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
+TEST_F(RowNumberTest, spillWithYield) {
+  std::vector<RowVectorPtr> vectors = createVectors(8, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+
+  struct {
+    uint32_t numSpills;
+    uint32_t cpuTimeSliceLimitMs;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numSpills {}, cpuTimeSliceLimitMs {}",
+          numSpills,
+          cpuTimeSliceLimitMs);
+    }
+  } testSettings[] = {{2, 0}, {2, 10}, {3, 0}, {3, 10}, {8, 10}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    TestScopedSpillInjection scopedSpillInjection(
+        100, ".*", testData.numSpills);
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+
+    core::PlanNodeId rowNumberPlanNodeId;
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .config(core::QueryConfig::kRowNumberSpillEnabled, true)
+            .config(
+                core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+                testData.cpuTimeSliceLimitMs)
+            .queryCtx(queryCtx)
+            .plan(PlanBuilder()
+                      .values(vectors)
+                      .rowNumber({"c0"})
+                      .capturePlanNodeId(rowNumberPlanNodeId)
+                      .planNode())
+            .assertResults(
+                "SELECT *, row_number() over (partition by c0) FROM tmp");
+    auto taskStats = toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(rowNumberPlanNodeId);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_GT(planStats.spilledFiles, 0);
+    ASSERT_GT(planStats.spilledRows, 0);
+
+    task.reset();
+    waitForAllTasksToBeDeleted();
+  }
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/SimpleAggregateAdapterTest.cpp b/velox/exec/tests/SimpleAggregateAdapterTest.cpp
index e707ff830a253..0a71f843a3f14 100644
--- a/velox/exec/tests/SimpleAggregateAdapterTest.cpp
+++ b/velox/exec/tests/SimpleAggregateAdapterTest.cpp
@@ -17,7 +17,7 @@
 #include "velox/exec/SimpleAggregateAdapter.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/tests/SimpleAggregateFunctionsRegistration.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
@@ -34,7 +34,6 @@ class SimpleAverageAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
 
     registerSimpleAverageAggregate(kSimpleAvg);
   }
@@ -114,7 +113,6 @@ class SimpleArrayAggAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    disallowInputShuffle();
 
     registerSimpleArrayAggAggregate(kSimpleArrayAgg);
   }
@@ -284,9 +282,9 @@ TEST_F(SimpleArrayAggAggregationTest, trackRowSize) {
                               bool testGlobal) {
     auto fn = Aggregate::create(
         "simple_array_agg",
-        step,
-        isRawInput(step) ? std::vector<TypePtr>{BIGINT()}
-                         : std::vector<TypePtr>{ARRAY(BIGINT())},
+        isPartialOutput(step) ? core::AggregationNode::Step::kPartial
+                              : core::AggregationNode::Step::kSingle,
+        std::vector<TypePtr>{BIGINT()},
         ARRAY(BIGINT()),
         queryConfig);
 
@@ -301,6 +299,8 @@ TEST_F(SimpleArrayAggAggregationTest, trackRowSize) {
         offset,
         RowContainer::nullByte(0),
         RowContainer::nullMask(0),
+        RowContainer::initializedByte(0),
+        RowContainer::initializedMask(0),
         rowSizeOffset);
 
     // Make two groups for odd and even rows.
@@ -331,9 +331,9 @@ TEST_F(SimpleArrayAggAggregationTest, trackRowSize) {
       }
     }
 
-    VELOX_CHECK_GT(groups[0][rowSizeOffset], 0);
+    VELOX_CHECK_GT(*reinterpret_cast<int32_t*>(groups[0] + rowSizeOffset), 0);
     if (!testGlobal) {
-      VELOX_CHECK_GT(groups[1][rowSizeOffset], 0);
+      VELOX_CHECK_GT(*reinterpret_cast<int32_t*>(groups[1] + rowSizeOffset), 0);
     }
   };
 
@@ -410,7 +410,8 @@ class CountNullsAggregate {
   using AccumulatorType = Accumulator;
 };
 
-bool registerSimpleCountNullsAggregate(const std::string& name) {
+exec::AggregateRegistrationResult registerSimpleCountNullsAggregate(
+    const std::string& name) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .returnType("bigint")
@@ -418,7 +419,7 @@ bool registerSimpleCountNullsAggregate(const std::string& name) {
           .argumentType("double")
           .build()};
 
-  exec::registerAggregateFunction(
+  return exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -431,8 +432,9 @@ bool registerSimpleCountNullsAggregate(const std::string& name) {
             argTypes.size(), 1, "{} takes at most one argument", name);
         return std::make_unique<SimpleAggregateAdapter<CountNullsAggregate>>(
             resultType);
-      });
-  return true;
+      },
+      false /*registerCompanionFunctions*/,
+      true /*overwrite*/);
 }
 
 void registerSimpleCountNullsAggregate() {
diff --git a/velox/exec/tests/SimpleArrayAggAggregate.cpp b/velox/exec/tests/SimpleArrayAggAggregate.cpp
index 2124468bb1398..e3998aadf2a23 100644
--- a/velox/exec/tests/SimpleArrayAggAggregate.cpp
+++ b/velox/exec/tests/SimpleArrayAggAggregate.cpp
@@ -18,33 +18,13 @@
 #include "velox/exec/SimpleAggregateAdapter.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/expression/VectorWriters.h"
-#include "velox/functions/prestosql/aggregates/ValueList.h"
+#include "velox/functions/lib/aggregates/ValueList.h"
 
 using namespace facebook::velox::exec;
 
 namespace facebook::velox::aggregate {
 
 namespace {
-
-// Write ValueList accumulators to Array-typed intermediate or final result
-// vectors.
-// TODO: This API only works if it is the only logic writing to `writer`.
-template <typename T>
-void copyValueListToArrayWriter(ArrayWriter<T>& writer, ValueList& elements) {
-  writer.resetLength();
-  auto size = elements.size();
-  if (size == 0) {
-    return;
-  }
-  writer.reserve(size);
-
-  ValueListReader reader(elements);
-  for (vector_size_t i = 0; i < size; ++i) {
-    reader.next(*writer.elementsVector(), writer.valuesOffset() + i);
-  }
-  writer.resize(size);
-}
-
 class ArrayAggAggregate {
  public:
   // Type(s) of input vector(s) wrapped in Row.
@@ -157,7 +137,8 @@ exec::AggregateRegistrationResult registerSimpleArrayAggAggregate(
         return std::make_unique<SimpleAggregateAdapter<ArrayAggAggregate>>(
             resultType);
       },
-      /*registerCompanionFunctions*/ true);
+      true /*registerCompanionFunctions*/,
+      true /*overwrite*/);
 }
 
 } // namespace facebook::velox::aggregate
diff --git a/velox/exec/tests/SimpleAverageAggregate.cpp b/velox/exec/tests/SimpleAverageAggregate.cpp
index 466f7f9b0d325..9f887f34eadf9 100644
--- a/velox/exec/tests/SimpleAverageAggregate.cpp
+++ b/velox/exec/tests/SimpleAverageAggregate.cpp
@@ -167,7 +167,8 @@ exec::AggregateRegistrationResult registerSimpleAverageAggregate(
           }
         }
       },
-      true);
+      true /*registerCompanionFunctions*/,
+      true /*overwrite*/);
 }
 
 } // namespace facebook::velox::aggregate
diff --git a/velox/exec/tests/SortBufferTest.cpp b/velox/exec/tests/SortBufferTest.cpp
index b107219cf68c3..45c50f7ea5aef 100644
--- a/velox/exec/tests/SortBufferTest.cpp
+++ b/velox/exec/tests/SortBufferTest.cpp
@@ -35,31 +35,39 @@ namespace facebook::velox::functions::test {
 class SortBufferTest : public OperatorTestBase {
  protected:
   void SetUp() override {
+    OperatorTestBase::SetUp();
     filesystems::registerLocalFileSystem();
-    if (!isRegisteredVectorSerde()) {
-      this->registerVectorSerde();
-    }
     rng_.seed(123);
   }
 
-  common::SpillConfig getSpillConfig(const std::string& spillFilePath) const {
+  void TearDown() override {
+    pool_.reset();
+    rootPool_.reset();
+    OperatorTestBase::TearDown();
+  }
+
+  common::SpillConfig getSpillConfig(const std::string& spillDir) const {
     return common::SpillConfig(
-        spillFilePath,
-        0,
+        [spillDir]() -> const std::string& { return spillDir; },
+        [&](uint64_t) {},
+        "0.0.0",
         0,
         0,
+        1 << 20,
         executor_.get(),
         5,
         10,
         0,
         0,
         0,
-        false,
         0,
         0,
         "none");
   }
 
+  const velox::common::PrefixSortConfig prefixSortConfig_ =
+      velox::common::PrefixSortConfig{std::numeric_limits<int32_t>::max(), 130};
+
   const RowTypePtr inputType_ = ROW(
       {{"c0", BIGINT()},
        {"c1", INTEGER()},
@@ -70,20 +78,14 @@ class SortBufferTest : public OperatorTestBase {
   // Specifies the sort columns ["c4", "c1"].
   std::vector<column_index_t> sortColumnIndices_{4, 1};
   std::vector<CompareFlags> sortCompareFlags_{
-      {true, true, false, CompareFlags::NullHandlingMode::NoStop},
-      {true, true, false, CompareFlags::NullHandlingMode::NoStop}};
-
-  const int64_t maxBytes_ = 20LL << 20; // 20 MB
-  const std::shared_ptr<memory::MemoryPool> rootPool_{
-      memory::defaultMemoryManager().addRootPool("SortBufferTest", maxBytes_)};
-  const std::shared_ptr<memory::MemoryPool> pool_{
-      rootPool_->addLeafChild("SortBufferTest", maxBytes_)};
+      {true, true, false, CompareFlags::NullHandlingMode::kNullAsValue},
+      {true, true, false, CompareFlags::NullHandlingMode::kNullAsValue}};
+
   const std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
           std::thread::hardware_concurrency())};
-  tsan_atomic<bool> nonReclaimableSection_{false};
-  uint32_t numSpillRuns_;
 
+  tsan_atomic<bool> nonReclaimableSection_{false};
   folly::Random::DefaultGenerator rng_;
 };
 
@@ -107,12 +109,12 @@ TEST_F(SortBufferTest, singleKey) {
       {{{true,
          true,
          false,
-         CompareFlags::NullHandlingMode::NoStop}}, // Ascending
+         CompareFlags::NullHandlingMode::kNullAsValue}}, // Ascending
        {1, 2, 3, 4, 5}},
       {{{true,
          false,
          false,
-         CompareFlags::NullHandlingMode::NoStop}}, // Descending
+         CompareFlags::NullHandlingMode::kNullAsValue}}, // Descending
        {5, 4, 3, 2, 1}}};
 
   // Specifies the sort columns ["c1"].
@@ -123,10 +125,9 @@ TEST_F(SortBufferTest, singleKey) {
         inputType_,
         sortColumnIndices_,
         testData.sortCompareFlags,
-        10000,
         pool_.get(),
         &nonReclaimableSection_,
-        &numSpillRuns_);
+        prefixSortConfig_);
 
     RowVectorPtr data = makeRowVector(
         {makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
@@ -139,7 +140,7 @@ TEST_F(SortBufferTest, singleKey) {
 
     sortBuffer->addInput(data);
     sortBuffer->noMoreInput();
-    auto output = sortBuffer->getOutput();
+    auto output = sortBuffer->getOutput(10000);
     ASSERT_EQ(output->size(), 5);
     int resultIndex = 0;
     for (int expectedValue : testData.expectedResult) {
@@ -155,10 +156,9 @@ TEST_F(SortBufferTest, multipleKeys) {
       inputType_,
       sortColumnIndices_,
       sortCompareFlags_,
-      10000,
       pool_.get(),
       &nonReclaimableSection_,
-      &numSpillRuns_);
+      prefixSortConfig_);
 
   RowVectorPtr data = makeRowVector(
       {makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
@@ -171,7 +171,7 @@ TEST_F(SortBufferTest, multipleKeys) {
 
   sortBuffer->addInput(data);
   sortBuffer->noMoreInput();
-  auto output = sortBuffer->getOutput();
+  auto output = sortBuffer->getOutput(10000);
   ASSERT_EQ(output->size(), 5);
   ASSERT_EQ(output->childAt(1)->asFlatVector<int32_t>()->valueAt(0), 5);
   ASSERT_EQ(output->childAt(1)->asFlatVector<int32_t>()->valueAt(1), 3);
@@ -209,7 +209,7 @@ TEST_F(SortBufferTest, DISABLED_randomData) {
             {"c4", DOUBLE()},
             {"c5", VARCHAR()}}),
        {2},
-       {{true, true, false, CompareFlags::NullHandlingMode::NoStop}}},
+       {{true, true, false, CompareFlags::NullHandlingMode::kNullAsValue}}},
       {ROW(
            {{"c0", BIGINT()},
             {"c1", INTEGER()},
@@ -218,8 +218,8 @@ TEST_F(SortBufferTest, DISABLED_randomData) {
             {"c4", DOUBLE()},
             {"c5", VARCHAR()}}),
        {4, 1},
-       {{true, true, false, CompareFlags::NullHandlingMode::NoStop},
-        {true, true, false, CompareFlags::NullHandlingMode::NoStop}}},
+       {{true, true, false, CompareFlags::NullHandlingMode::kNullAsValue},
+        {true, true, false, CompareFlags::NullHandlingMode::kNullAsValue}}},
       {ROW(
            {{"c0", BIGINT()},
             {"c1", INTEGER()},
@@ -228,8 +228,8 @@ TEST_F(SortBufferTest, DISABLED_randomData) {
             {"c4", DOUBLE()},
             {"c5", VARCHAR()}}),
        {4, 1},
-       {{true, true, false, CompareFlags::NullHandlingMode::NoStop},
-        {false, false, false, CompareFlags::NullHandlingMode::NoStop}}}};
+       {{true, true, false, CompareFlags::NullHandlingMode::kNullAsValue},
+        {false, false, false, CompareFlags::NullHandlingMode::kNullAsValue}}}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
@@ -237,13 +237,12 @@ TEST_F(SortBufferTest, DISABLED_randomData) {
         testData.inputType,
         testData.sortColumnIndices,
         testData.sortCompareFlags,
-        1000,
         pool_.get(),
         &nonReclaimableSection_,
-        &numSpillRuns_);
+        prefixSortConfig_);
 
     const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::addDefaultLeafMemoryPool("VectorFuzzer");
+        memory::memoryManager()->addLeafPool("VectorFuzzer");
 
     std::vector<RowVectorPtr> inputVectors;
     inputVectors.reserve(3);
@@ -263,19 +262,19 @@ TEST_F(SortBufferTest, batchOutput) {
   struct {
     bool triggerSpill;
     std::vector<size_t> numInputRows;
-    size_t outputBatchSize;
-    std::vector<size_t> expectedOutputBufferSizes;
+    size_t maxOutputRows;
+    std::vector<size_t> expectedOutputRowCount;
 
     std::string debugString() const {
       const std::string numInputRowsStr = folly::join(",", numInputRows);
-      const std::string expectedOutputBufferSizesStr =
-          folly::join(",", expectedOutputBufferSizes);
+      const std::string expectedOutputRowCountStr =
+          folly::join(",", expectedOutputRowCount);
       return fmt::format(
-          "triggerSpill:{}, numInputRows:{}, outputBatchSize:{}, expectedOutputBufferSizes:{}",
+          "triggerSpill:{}, numInputRows:{}, maxOutputRows:{}, expectedOutputRowCount:{}",
           triggerSpill,
           numInputRowsStr,
-          outputBatchSize,
-          expectedOutputBufferSizesStr);
+          maxOutputRows,
+          expectedOutputRowCountStr);
     }
   } testSettings[] = {
       {false, {2, 3, 3}, 1, {1, 1, 1, 1, 1, 1, 1, 1}},
@@ -287,38 +286,40 @@ TEST_F(SortBufferTest, batchOutput) {
       {false, {1024, 1024, 1024}, 1000, {1000, 1000, 1000, 72}},
       {true, {1024, 1024, 1024}, 1000, {1000, 1000, 1000, 72}}};
 
+  TestScopedSpillInjection scopedSpillInjection(100);
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     auto spillDirectory = exec::test::TempDirectoryPath::create();
-    auto filePath = makeOperatorSpillPath(spillDirectory->path, 0, 0, 0);
     auto spillConfig = common::SpillConfig(
-        filePath,
+        [&]() -> const std::string& { return spillDirectory->getPath(); },
+        [&](uint64_t) {},
+        "0.0.0",
         1000,
         0,
-        1000,
+        1 << 20,
         executor_.get(),
         5,
         10,
         0,
         0,
         0,
-        false,
         0,
-        100, //  testSpillPct
+        0,
         "none");
+    folly::Synchronized<common::SpillStats> spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
         inputType_,
         sortColumnIndices_,
         sortCompareFlags_,
-        testData.outputBatchSize,
         pool_.get(),
         &nonReclaimableSection_,
-        &numSpillRuns_,
+        prefixSortConfig_,
         testData.triggerSpill ? &spillConfig : nullptr,
-        0);
+        &spillStats);
+    ASSERT_EQ(sortBuffer->canSpill(), testData.triggerSpill);
 
     const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::addDefaultLeafMemoryPool("VectorFuzzer");
+        memory::memoryManager()->addLeafPool("VectorFuzzer");
 
     std::vector<RowVectorPtr> inputVectors;
     inputVectors.reserve(testData.numInputRows.size());
@@ -331,26 +332,24 @@ TEST_F(SortBufferTest, batchOutput) {
       totalNumInput += inputRows;
     }
     sortBuffer->noMoreInput();
-    auto spillStats = sortBuffer->spilledStats();
-
     int expectedOutputBufferIndex = 0;
-    RowVectorPtr output = sortBuffer->getOutput();
+    RowVectorPtr output = sortBuffer->getOutput(testData.maxOutputRows);
     while (output != nullptr) {
       ASSERT_EQ(
           output->size(),
-          testData.expectedOutputBufferSizes[expectedOutputBufferIndex++]);
-      output = sortBuffer->getOutput();
+          testData.expectedOutputRowCount[expectedOutputBufferIndex++]);
+      output = sortBuffer->getOutput(testData.maxOutputRows);
     }
 
     if (!testData.triggerSpill) {
-      ASSERT_FALSE(spillStats.has_value());
+      ASSERT_TRUE(spillStats.rlock()->empty());
     } else {
-      ASSERT_TRUE(spillStats.has_value());
-      ASSERT_GT(spillStats->spilledRows, 0);
-      ASSERT_LE(spillStats->spilledRows, totalNumInput);
-      ASSERT_GT(spillStats->spilledBytes, 0);
-      ASSERT_EQ(spillStats->spilledPartitions, 1);
-      ASSERT_GT(spillStats->spilledFiles, 0);
+      ASSERT_FALSE(spillStats.rlock()->empty());
+      ASSERT_GT(spillStats.rlock()->spilledRows, 0);
+      ASSERT_LE(spillStats.rlock()->spilledRows, totalNumInput);
+      ASSERT_GT(spillStats.rlock()->spilledBytes, 0);
+      ASSERT_EQ(spillStats.rlock()->spilledPartitions, 1);
+      ASSERT_GT(spillStats.rlock()->spilledFiles, 0);
     }
   }
 }
@@ -359,126 +358,189 @@ TEST_F(SortBufferTest, spill) {
   struct {
     bool spillEnabled;
     bool memoryReservationFailure;
-    uint64_t spillMemoryThreshold;
+    bool triggerSpill;
     bool spillTriggered;
 
     std::string debugString() const {
       return fmt::format(
-          "spillEnabled:{}, memoryReservationFailure:{}, spillMemoryThreshold:{}, spillTriggered:{}",
+          "spillEnabled:{}, memoryReservationFailure:{}, triggerSpill:{}, spillTriggered:{}",
           spillEnabled,
           memoryReservationFailure,
-          spillMemoryThreshold,
+          triggerSpill,
           spillTriggered);
     }
   } testSettings[] = {
       {false, true, 0, false}, // spilling is not enabled.
-      {true, true, 0, true}, // memory reservation failure triggers spilling.
-      {true, false, 1000, true}, // threshold is small, spilling is triggered.
-      {true, false, 1000000, false} // threshold is too large, not triggered
-  };
+      {true,
+       true,
+       0,
+       false}, // memory reservation failure won't trigger spilling.
+      {true, false, true, true},
+      {true, false, false, false}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     auto spillDirectory = exec::test::TempDirectoryPath::create();
-    auto filePath = makeOperatorSpillPath(spillDirectory->path, 0, 0, 0);
     // memory pool limit is 20M
     // Set 'kSpillableReservationGrowthPct' to an extreme large value to trigger
     // memory reservation failure and thus trigger disk spilling.
     auto spillableReservationGrowthPct =
         testData.memoryReservationFailure ? 100000 : 100;
     auto spillConfig = common::SpillConfig(
-        filePath,
+        [&]() -> const std::string& { return spillDirectory->getPath(); },
+        [&](uint64_t) {},
+        "0.0.0",
         1000,
         0,
-        1000,
+        1 << 20,
         executor_.get(),
         100,
         spillableReservationGrowthPct,
         0,
         0,
         0,
-        false,
         0,
         0,
         "none");
+    folly::Synchronized<common::SpillStats> spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
         inputType_,
         sortColumnIndices_,
         sortCompareFlags_,
-        1000,
         pool_.get(),
         &nonReclaimableSection_,
-        &numSpillRuns_,
+        prefixSortConfig_,
         testData.spillEnabled ? &spillConfig : nullptr,
-        testData.spillMemoryThreshold);
+        &spillStats);
 
     const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::addDefaultLeafMemoryPool("spillSource");
+        memory::memoryManager()->addLeafPool("spillSource");
     VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
     uint64_t totalNumInput = 0;
 
-    ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
-    const auto peakSpillMemoryUsage = Spiller::pool()->stats().peakBytes;
+    ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
+    const auto peakSpillMemoryUsage =
+        memory::spillMemoryPool()->stats().peakBytes;
 
+    TestScopedSpillInjection scopedSpillInjection(
+        testData.triggerSpill ? 100 : 0);
     for (int i = 0; i < 3; ++i) {
       sortBuffer->addInput(fuzzer.fuzzRow(inputType_));
       totalNumInput += 1024;
     }
     sortBuffer->noMoreInput();
-    auto spillStats = sortBuffer->spilledStats();
 
     if (!testData.spillTriggered) {
-      ASSERT_FALSE(spillStats.has_value());
+      ASSERT_TRUE(spillStats.rlock()->empty());
       if (!testData.spillEnabled) {
-        VELOX_ASSERT_THROW(sortBuffer->spill(0, 0), "spill config is null");
+        VELOX_ASSERT_THROW(sortBuffer->spill(), "spill config is null");
       }
     } else {
-      ASSERT_TRUE(spillStats.has_value());
-      ASSERT_GT(spillStats->spilledRows, 0);
-      ASSERT_LE(spillStats->spilledRows, totalNumInput);
-      ASSERT_GT(spillStats->spilledBytes, 0);
-      ASSERT_EQ(spillStats->spilledPartitions, 1);
+      ASSERT_FALSE(spillStats.rlock()->empty());
+      ASSERT_GT(spillStats.rlock()->spilledRows, 0);
+      ASSERT_LE(spillStats.rlock()->spilledRows, totalNumInput);
+      ASSERT_GT(spillStats.rlock()->spilledBytes, 0);
+      ASSERT_EQ(spillStats.rlock()->spilledPartitions, 1);
       // SortBuffer shall not respect maxFileSize. Total files should be num
       // addInput() calls minus one which is the first one that has nothing to
       // spill.
-      ASSERT_EQ(spillStats->spilledFiles, 2);
+      ASSERT_EQ(spillStats.rlock()->spilledFiles, 3);
       sortBuffer.reset();
-      ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
-      if (Spiller::pool()->trackUsage()) {
-        ASSERT_GT(Spiller::pool()->stats().peakBytes, 0);
-        ASSERT_GE(Spiller::pool()->stats().peakBytes, peakSpillMemoryUsage);
+      ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
+      if (memory::spillMemoryPool()->trackUsage()) {
+        ASSERT_GT(memory::spillMemoryPool()->stats().peakBytes, 0);
+        ASSERT_GE(
+            memory::spillMemoryPool()->stats().peakBytes, peakSpillMemoryUsage);
       }
     }
   }
 }
 
+DEBUG_ONLY_TEST_F(SortBufferTest, reserveMemoryGetOutput) {
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto spillConfig = common::SpillConfig(
+      [&]() -> const std::string& { return spillDirectory->getPath(); },
+      [&](uint64_t) {},
+      "0.0.0",
+      1000,
+      0,
+      1 << 20,
+      executor_.get(),
+      100,
+      100000,
+      0,
+      0,
+      0,
+      0,
+      0,
+      "none");
+  folly::Synchronized<common::SpillStats> spillStats;
+  auto sortBuffer = std::make_unique<SortBuffer>(
+      inputType_,
+      sortColumnIndices_,
+      sortCompareFlags_,
+      pool_.get(),
+      &nonReclaimableSection_,
+      prefixSortConfig_,
+      &spillConfig,
+      &spillStats);
+
+  const std::shared_ptr<memory::MemoryPool> fuzzerPool =
+      memory::memoryManager()->addLeafPool("spillSource");
+  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+
+  TestScopedSpillInjection scopedSpillInjection(0);
+  for (int i = 0; i < 3; ++i) {
+    sortBuffer->addInput(fuzzer.fuzzRow(inputType_));
+  }
+
+  std::atomic_bool noMoreInput{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::SortBuffer::noMoreInput",
+      std::function<void(SortBuffer*)>(
+          ([&](SortBuffer* sortBuffer) { noMoreInput.store(true); })));
+
+  std::atomic_int numInputs{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+      std::function<void(memory::MemoryPoolImpl*)>(
+          ([&](memory::MemoryPoolImpl* pool) {
+            if (noMoreInput) {
+              ++numInputs;
+            }
+          })));
+
+  sortBuffer->noMoreInput();
+  sortBuffer->getOutput(10000);
+  ASSERT_EQ(numInputs, 1);
+}
+
 TEST_F(SortBufferTest, emptySpill) {
   const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-      memory::addDefaultLeafMemoryPool("emptySpillSource");
+      memory::memoryManager()->addLeafPool("emptySpillSource");
 
   for (bool hasPostSpillData : {false, true}) {
     SCOPED_TRACE(fmt::format("hasPostSpillData {}", hasPostSpillData));
     auto spillDirectory = exec::test::TempDirectoryPath::create();
-    auto filePath = makeOperatorSpillPath(spillDirectory->path, 0, 0, 0);
-    auto spillConfig = getSpillConfig(filePath);
+    auto spillConfig = getSpillConfig(spillDirectory->getPath());
+    folly::Synchronized<common::SpillStats> spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
         inputType_,
         sortColumnIndices_,
         sortCompareFlags_,
-        1000,
         pool_.get(),
         &nonReclaimableSection_,
-        &numSpillRuns_,
+        prefixSortConfig_,
         &spillConfig,
-        0);
+        &spillStats);
 
-    sortBuffer->spill(0, 0);
+    sortBuffer->spill();
     if (hasPostSpillData) {
       VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
       sortBuffer->addInput(fuzzer.fuzzRow(inputType_));
     }
     sortBuffer->noMoreInput();
-    ASSERT_FALSE(sortBuffer->spilledStats());
+    ASSERT_TRUE(spillStats.rlock()->empty());
   }
 }
 } // namespace facebook::velox::functions::test
diff --git a/velox/exec/tests/SparkAggregationFuzzerTest.cpp b/velox/exec/tests/SparkAggregationFuzzerTest.cpp
deleted file mode 100644
index cc2fbd91cee2e..0000000000000
--- a/velox/exec/tests/SparkAggregationFuzzerTest.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/init/Init.h>
-#include <gflags/gflags.h>
-#include <gtest/gtest.h>
-#include <unordered_set>
-
-#include "velox/exec/tests/utils/AggregationFuzzerRunner.h"
-#include "velox/exec/tests/utils/DuckQueryRunner.h"
-#include "velox/functions/sparksql/aggregates/Register.h"
-
-DEFINE_int64(
-    seed,
-    0,
-    "Initial seed for random number generator used to reproduce previous "
-    "results (0 means start with random seed).");
-
-DEFINE_string(
-    only,
-    "",
-    "If specified, Fuzzer will only choose functions from "
-    "this comma separated list of function names "
-    "(e.g: --only \"min\" or --only \"sum,avg\").");
-
-int main(int argc, char** argv) {
-  facebook::velox::functions::aggregate::sparksql::registerAggregateFunctions(
-      "");
-
-  ::testing::InitGoogleTest(&argc, argv);
-
-  // Calls common init functions in the necessary order, initializing
-  // singletons, installing proper signal handlers for better debugging
-  // experience, and initialize glog and gflags.
-  folly::init(&argc, &argv);
-
-  // TODO: List of the functions that at some point crash or fail and need to
-  // be fixed before we can enable. Constant argument of bloom_filter_agg cause
-  // fuzzer test fail.
-  std::unordered_set<std::string> skipFunctions = {"bloom_filter_agg"};
-
-  // The results of the following functions depend on the order of input
-  // rows. For some functions, the result can be transformed to a value that
-  // doesn't depend on the order of inputs. If such transformation exists, it
-  // can be specified to be used for results verification. If no transformation
-  // is specified, results are not verified.
-  std::unordered_map<std::string, std::string> customVerificationFunctions = {
-      {"last", ""},
-      {"last_ignore_null", ""},
-      {"first", ""},
-      {"first_ignore_null", ""},
-      // TODO: Skip result verification of companion functions that return
-      // complex types that contain floating-point fields for now, until we
-      // fix test utilities in QueryAssertions to tolerate floating-point
-      // imprecision in complex types.
-      // https://github.com/facebookincubator/velox/issues/4481
-      {"avg_partial", ""},
-      {"avg_merge", ""},
-      {"max_by", ""},
-      {"min_by", ""}};
-
-  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
-  auto duckQueryRunner =
-      std::make_unique<facebook::velox::exec::test::DuckQueryRunner>();
-
-  using Runner = facebook::velox::exec::test::AggregationFuzzerRunner;
-
-  Runner::Options options;
-  options.onlyFunctions = FLAGS_only;
-  options.skipFunctions = skipFunctions;
-  options.customVerificationFunctions = customVerificationFunctions;
-  return Runner::run(initialSeed, std::move(duckQueryRunner), options);
-}
diff --git a/velox/exec/tests/SpillOperatorGroupTest.cpp b/velox/exec/tests/SpillOperatorGroupTest.cpp
deleted file mode 100644
index e560fdfbae0f2..0000000000000
--- a/velox/exec/tests/SpillOperatorGroupTest.cpp
+++ /dev/null
@@ -1,502 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/exec/SpillOperatorGroup.h"
-#include <memory>
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/common/memory/Memory.h"
-#include "velox/core/PlanFragment.h"
-#include "velox/exec/Driver.h"
-#include "velox/exec/Operator.h"
-#include "velox/exec/Task.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::test;
-using namespace facebook::velox::exec;
-
-class SpillOperatorGroupTest : public testing::Test {
- protected:
-  SpillOperatorGroupTest(int32_t numOperators = 1)
-      : numOperators_(numOperators), pool_(memory::addDefaultLeafMemoryPool()) {
-    // All this is to prepare valid driver context for our mock operators.
-    VectorMaker vectorMaker{pool_.get()};
-    std::vector<RowVectorPtr> values = {vectorMaker.rowVector(
-        {vectorMaker.flatVector<int32_t>(1, [](auto row) { return row; })})};
-    core::PlanFragment planFragment;
-    const core::PlanNodeId id{"0"};
-    planFragment.planNode = std::make_shared<core::ValuesNode>(id, values);
-
-    task_ = Task::create(
-        "SpillOperatorGroupTest_task",
-        std::move(planFragment),
-        0,
-        std::make_shared<core::QueryCtx>());
-    driver_ = Driver::testingCreate();
-    driverCtx_ = std::make_unique<DriverCtx>(task_, 0, 0, 0, 0);
-    driverCtx_->driver = driver_.get();
-  }
-
-  void SetUp() override {
-    rng_.seed(1245);
-    taskId_ = "SpillTask";
-    operatorId_ = 0;
-    splitGroupId_ = 0;
-    planNodeId_ = "SpillNode";
-  }
-
-  void TearDown() override {}
-
-  class MockOperator : public Operator {
-   public:
-    explicit MockOperator(
-        DriverCtx* driverCtx,
-        int32_t operatorId,
-        SpillOperatorGroup* spillGroup)
-        : Operator(
-              driverCtx,
-              nullptr,
-              operatorId,
-              // Ensure the spill plan node id is unique.
-              fmt::format("SpillNode{}", operatorId),
-              "SpillOperator"),
-          spillGroup_(spillGroup),
-          spillFuture_(ContinueFuture::makeEmpty()) {
-      spillGroup_->addOperator(
-          *this,
-          driverCtx->driver->shared_from_this(),
-          [&](const std::vector<Operator*>& ops) {
-            std::unordered_set<uint32_t> opIds;
-            for (const auto& op : ops) {
-              opIds.insert(op->stats().rlock()->operatorId);
-            }
-            ASSERT_EQ(opIds.size(), ops.size());
-            for (auto& op : ops) {
-              auto* spillOp = dynamic_cast<MockOperator*>(op);
-              ++spillOp->numSpillRuns_;
-            }
-          });
-    }
-
-    bool needsInput() const override {
-      return false;
-    }
-
-    void addInput(RowVectorPtr input) override {}
-
-    void noMoreInput() override {
-      Operator::noMoreInput();
-    }
-
-    RowVectorPtr getOutput() override {
-      return nullptr;
-    }
-
-    BlockingReason isBlocked(ContinueFuture* future) override {
-      return BlockingReason::kNotBlocked;
-    }
-
-    bool isFinished() override {
-      return false;
-    }
-
-    /// Methods used for spill test.
-    bool requestSpill() {
-      return spillGroup_->requestSpill(*this, spillFuture_);
-    }
-
-    bool waitSpill() {
-      return spillGroup_->waitSpill(*this, spillFuture_);
-    }
-
-    void stopSpill() {
-      spillStopped_ = true;
-      spillGroup_->operatorStopped(*this);
-    }
-
-    bool spillStopped() const {
-      return spillStopped_;
-    }
-
-    void restartSpill() {
-      spillStopped_ = false;
-    }
-
-    int32_t numSpillRuns() const {
-      return numSpillRuns_;
-    }
-
-    ContinueFuture& spillFuture() {
-      return spillFuture_;
-    }
-
-   private:
-    SpillOperatorGroup* const spillGroup_; // Not owned.
-
-    bool spillStopped_{false};
-    ContinueFuture spillFuture_;
-    int32_t numSpillRuns_{0};
-  };
-
-  std::unique_ptr<MockOperator> newSpillOperator(
-      SpillOperatorGroup* spillGroup) {
-    return std::make_unique<MockOperator>(
-        driverCtx_.get(), operatorId_++, spillGroup);
-  }
-
-  void setupSpillOperators() {
-    std::vector<std::unique_ptr<SpillOperatorGroupTest::MockOperator>> ops;
-    ops.reserve(numOperators_);
-    for (int32_t i = 0; i < numOperators_; ++i) {
-      ops.push_back(newSpillOperator(spillGroup_.get()));
-    }
-    spillOps_ = std::move(ops);
-    ASSERT_EQ(spillGroup_->state(), SpillOperatorGroup::State::kInit);
-  }
-
-  void setupSpillGroup() {
-    spillGroup_ = std::make_unique<SpillOperatorGroup>(
-        taskId_, splitGroupId_++, planNodeId_);
-    ASSERT_EQ(spillGroup_->state(), SpillOperatorGroup::State::kInit);
-    numSpillRuns_ = 0;
-
-    setupSpillOperators();
-  }
-
-  void runSpillOperators(
-      bool triggerSpill = true,
-      bool operatorStopped = false) {
-    SCOPED_TRACE(fmt::format(
-        "triggerSpill:{}, operatorStopped:{}", triggerSpill, operatorStopped));
-    ASSERT_TRUE(hasRunningOperators());
-
-    auto numRunningOpsLeft = numRunningOperators();
-    bool spillTriggered = false;
-    for (int32_t i = 0; i < spillOps_.size(); ++i) {
-      auto* op = spillOps_[i].get();
-      if (op->spillStopped()) {
-        continue;
-      }
-
-      --numRunningOpsLeft;
-      bool wait;
-      if (operatorStopped && oneIn(2)) {
-        op->stopSpill();
-        continue;
-      }
-      if (triggerSpill && (!spillTriggered || oneIn(3))) {
-        spillTriggered = true;
-        wait = op->requestSpill();
-      } else {
-        wait = op->waitSpill();
-      }
-      if (spillTriggered) {
-        if (numRunningOpsLeft != 0) {
-          ASSERT_TRUE(spillGroup_->needSpill());
-          ASSERT_TRUE(wait);
-          ASSERT_TRUE(op->spillFuture().valid());
-        } else {
-          ASSERT_FALSE(spillGroup_->needSpill());
-          ASSERT_FALSE(wait);
-          ASSERT_FALSE(op->spillFuture().valid());
-        }
-      } else {
-        ASSERT_FALSE(spillGroup_->needSpill());
-        ASSERT_FALSE(wait);
-        ASSERT_FALSE(op->spillFuture().valid());
-      }
-    }
-
-    ASSERT_FALSE(spillGroup_->needSpill());
-    if (hasRunningOperators()) {
-      ASSERT_EQ(spillGroup_->state(), SpillOperatorGroup::State::kRunning);
-    } else {
-      ASSERT_EQ(spillGroup_->state(), SpillOperatorGroup::State::kStopped);
-    }
-    if (spillTriggered) {
-      ++numSpillRuns_;
-      waitSpillOperators();
-    }
-    checkSpillOperators();
-  }
-
-  void checkSpillOperators() {
-    for (auto& op : spillOps_) {
-      ASSERT_EQ(op->numSpillRuns(), numSpillRuns_);
-    }
-  }
-
-  void waitSpillOperators() {
-    int32_t numNonWaitOperators = 0;
-    int32_t numStoppedOperators = 0;
-    for (auto& op : spillOps_) {
-      if (op->spillStopped()) {
-        ++numStoppedOperators;
-        ASSERT_FALSE(op->spillFuture().valid());
-        continue;
-      }
-      auto future = std::move(op->spillFuture());
-      if (future.valid()) {
-        future.wait();
-      } else {
-        ++numNonWaitOperators;
-      }
-    }
-    // NOTE: at most one spill operator doesn't need to wait.
-    if (numNonWaitOperators == 0) {
-      ASSERT_GT(numStoppedOperators, 0);
-    } else {
-      ASSERT_EQ(numNonWaitOperators, 1);
-    }
-  }
-
-  bool hasRunningOperators() const {
-    return numRunningOperators() != 0;
-  }
-
-  int32_t numRunningOperators() const {
-    int32_t numRunningOps = 0;
-    for (auto& op : spillOps_) {
-      if (!op->spillStopped()) {
-        ++numRunningOps;
-      }
-    }
-    return numRunningOps;
-  }
-
-  void startSpillGroup() {
-    if (spillGroup_->state() != SpillOperatorGroup::State::kStopped) {
-      spillGroup_->start();
-      return;
-    }
-    for (auto& op : spillOps_) {
-      ASSERT_TRUE(op->spillStopped());
-      op->restartSpill();
-    }
-    spillGroup_->restart();
-    ASSERT_EQ(spillGroup_->state(), SpillOperatorGroup::State::kRunning);
-  }
-
-  uint32_t randInt(uint32_t n) {
-    std::lock_guard<std::mutex> l(mutex_);
-    return folly::Random().rand64(rng_) % (n + 1);
-  }
-
-  bool oneIn(uint32_t n) {
-    std::lock_guard<std::mutex> l(mutex_);
-    return folly::Random().oneIn(n, rng_);
-  }
-
-  const int32_t numOperators_;
-
-  std::mutex mutex_;
-  folly::Random::DefaultGenerator rng_;
-
-  uint32_t operatorId_;
-  std::string taskId_;
-  uint32_t splitGroupId_;
-  core::PlanNodeId planNodeId_;
-  int32_t numSpillRuns_{0};
-  std::unique_ptr<SpillOperatorGroup> spillGroup_;
-  std::vector<std::unique_ptr<MockOperator>> spillOps_;
-  std::shared_ptr<memory::MemoryPool> pool_;
-  std::shared_ptr<Task> task_;
-  std::shared_ptr<Driver> driver_;
-  std::unique_ptr<DriverCtx> driverCtx_;
-};
-
-class MultiSpillOperatorGroupTest
-    : public SpillOperatorGroupTest,
-      public testing::WithParamInterface<int32_t> {
- public:
-  MultiSpillOperatorGroupTest() : SpillOperatorGroupTest(GetParam()) {}
-};
-
-TEST_P(MultiSpillOperatorGroupTest, spillRun) {
-  setupSpillGroup();
-
-  int32_t numRestarts = 0;
-  while (numRestarts++ < 3) {
-    SCOPED_TRACE(fmt::format("numRestarts: {}", numRestarts - 1));
-    startSpillGroup();
-
-    // The initial spill runs with all the operators involved.
-    for (int32_t run = 0; run < 4; ++run) {
-      ASSERT_FALSE(spillGroup_->needSpill());
-
-      // No spill triggered.
-      runSpillOperators(false);
-
-      // Spill triggered.
-      runSpillOperators(true);
-    }
-
-    // Continue run spills until all the operators have stopped.
-    while (hasRunningOperators()) {
-      runSpillOperators(true, true);
-    }
-  }
-}
-
-TEST_P(MultiSpillOperatorGroupTest, spillRunWithDriverGone) {
-  setupSpillGroup();
-  startSpillGroup();
-  for (int32_t i = 0; i < spillOps_.size() - 1; ++i) {
-    ASSERT_TRUE(spillOps_[i]->requestSpill());
-  }
-  driver_.reset();
-  VELOX_ASSERT_THROW(
-      spillOps_.back()->requestSpill(), "Task has already terminated");
-  // Verify the spill promises have been set by failed spill run.
-  for (int32_t i = 0; i < spillOps_.size() - 1; ++i) {
-    spillOps_[i]->spillFuture().valid();
-    spillOps_[i]->spillFuture().wait();
-  }
-}
-
-TEST_P(MultiSpillOperatorGroupTest, noSpillRun) {
-  setupSpillGroup();
-  startSpillGroup();
-  // Run test without triggering spill.
-  while (hasRunningOperators()) {
-    runSpillOperators(false, true);
-  }
-}
-
-TEST_P(MultiSpillOperatorGroupTest, error) {
-  setupSpillGroup();
-  startSpillGroup();
-
-  // Can't start spill group twice.
-  ASSERT_ANY_THROW(startSpillGroup());
-
-  // Can't add spill operator after the group started.
-  ASSERT_ANY_THROW(setupSpillOperators());
-
-  // Can't restart if the group is not stopped.
-  ASSERT_ANY_THROW(spillGroup_->restart());
-
-  for (auto& op : spillOps_) {
-    op->stopSpill();
-    // Can only stop an operator once.
-    ASSERT_ANY_THROW(op->stopSpill());
-  }
-
-  // Can't add op after the group has stopped.
-  ASSERT_ANY_THROW(newSpillOperator(spillGroup_.get()));
-
-  // Can't request spill or wait after the group has stopped.
-  for (auto& op : spillOps_) {
-    ASSERT_ANY_THROW(op->requestSpill());
-  }
-  for (auto& op : spillOps_) {
-    ASSERT_ANY_THROW(op->waitSpill());
-  }
-
-  // Restart the spill group and everything works fine.
-  startSpillGroup();
-  for (auto& op : spillOps_) {
-    op->waitSpill();
-  }
-  for (auto& op : spillOps_) {
-    op->requestSpill();
-  }
-}
-
-TEST_P(MultiSpillOperatorGroupTest, multiThreading) {
-  setupSpillGroup();
-  startSpillGroup();
-
-  std::vector<std::thread> opThreads;
-  opThreads.reserve(numOperators_);
-
-  struct BarrierState {
-    int32_t numRequested{0};
-    std::vector<ContinuePromise> promises;
-  };
-  const int32_t numIterations = 100;
-  std::mutex barrierLock;
-  std::vector<BarrierState> barriers(numIterations);
-
-  // Start one thread per each spill operator and then stop and sync at the end
-  // of each test iteration by BarrierState. Then restart the spill group to run
-  // the next test iteration.
-  for (size_t i = 0; i < numOperators_; ++i) {
-    auto* op = spillOps_[i].get();
-    opThreads.emplace_back([&, op]() {
-      for (int32_t iter = 0; iter < numIterations; ++iter) {
-        const auto maxNumActions = 1 + randInt(6);
-        int32_t action = 0;
-        while (++action < maxNumActions) {
-          if (oneIn(6)) {
-            op->stopSpill();
-            break;
-          }
-          bool wait;
-          if (oneIn(3)) {
-            wait = op->requestSpill();
-          } else {
-            wait = op->waitSpill();
-          }
-          auto future = std::move(op->spillFuture());
-          if (wait) {
-            ASSERT_TRUE(future.valid());
-            future.wait();
-          } else {
-            ASSERT_FALSE(future.valid());
-          }
-        }
-        if (!op->spillStopped()) {
-          op->stopSpill();
-        }
-
-        // Wait for peers.
-        std::vector<ContinuePromise> promises;
-        ContinueFuture future(ContinueFuture::makeEmpty());
-        {
-          std::lock_guard<std::mutex> l(barrierLock);
-          auto& barrier = barriers[iter];
-          if (++barrier.numRequested < numOperators_) {
-            barrier.promises.emplace_back(
-                "SpillOperatorGroupTest::multiThreading");
-            future = barrier.promises.back().getSemiFuture();
-          } else {
-            promises = std::move(barrier.promises);
-          }
-        }
-        if (future.valid()) {
-          future.wait();
-        } else {
-          startSpillGroup();
-
-          for (auto& promise : promises) {
-            promise.setValue();
-          }
-        }
-      }
-    });
-  }
-
-  for (auto& th : opThreads) {
-    th.join();
-  }
-  numSpillRuns_ = spillOps_[0]->numSpillRuns();
-  checkSpillOperators();
-}
-
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    SpillOperatorGroupTest,
-    MultiSpillOperatorGroupTest,
-    testing::ValuesIn({1, 4, 32}));
diff --git a/velox/exec/tests/SpillTest.cpp b/velox/exec/tests/SpillTest.cpp
index 365f48ff73864..e611bdb103cb4 100644
--- a/velox/exec/tests/SpillTest.cpp
+++ b/velox/exec/tests/SpillTest.cpp
@@ -59,6 +59,7 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
   explicit SpillTest()
       : statWriter_(std::make_unique<TestRuntimeStatWriter>(runtimeStats_)) {
     setThreadLocalRunTimeStatWriter(statWriter_.get());
+    updateSpilledBytesCb_ = [&](uint64_t) {};
   }
 
   ~SpillTest() {
@@ -66,8 +67,12 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
   }
 
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    allocator_ = memory::MemoryAllocator::getInstance();
+    allocator_ = memory::memoryManager()->allocator();
     tempDir_ = exec::test::TempDirectoryPath::create();
     if (!isRegisteredVectorSerde()) {
       facebook::velox::serializer::presto::PrestoVectorSerde::
@@ -103,9 +108,9 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     batchesByPartition_.clear();
     values_.clear();
     runtimeStats_.clear();
-    stats_.wlock()->reset();
+    spillStats_.wlock()->reset();
 
-    spillPath_ = tempDir_->path + "/test";
+    fileNamePrefix_ = "test";
     values_.resize(numBatches * numRowsPerBatch);
     // Create a sequence of sorted 'values' in ascending order starting at -10.
     // Each distinct value occurs 'numDuplicates' times. The sequence total has
@@ -150,9 +155,11 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     // vectors have the ith element = i * 'numBatches' + batch, where batch is
     // the batch number of the vector in the partition. When read back, both
     // partitions produce an ascending sequence of integers without gaps.
-    stats_.wlock()->reset();
+    spillStats_.wlock()->reset();
     state_ = std::make_unique<SpillState>(
-        spillPath_,
+        [&]() -> const std::string& { return tempDir_->getPath(); },
+        updateSpilledBytesCb_,
+        fileNamePrefix_,
         numPartitions,
         1,
         compareFlags,
@@ -160,16 +167,17 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
         writeBufferSize,
         compressionKind_,
         pool(),
-        &stats_);
+        &spillStats_);
     ASSERT_EQ(targetFileSize, state_->targetFileSize());
     ASSERT_EQ(numPartitions, state_->maxPartitions());
-    ASSERT_EQ(stats_.rlock()->spilledPartitions, 0);
-    ASSERT_EQ(stats_.rlock()->spilledPartitions, 0);
+    ASSERT_EQ(spillStats_.rlock()->spilledPartitions, 0);
+    ASSERT_EQ(spillStats_.rlock()->spilledPartitions, 0);
     ASSERT_TRUE(state_->spilledPartitionSet().empty());
     ASSERT_EQ(compressionKind_, state_->compressionKind());
 
     for (auto partition = 0; partition < state_->maxPartitions(); ++partition) {
       ASSERT_FALSE(state_->isPartitionSpilled(partition));
+      ASSERT_EQ(state_->numFinishedFiles(partition), 0);
       // Expect an exception if partition is not set to spill.
       {
         RowVectorPtr dummyInput;
@@ -179,7 +187,8 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
       }
       state_->setPartitionSpilled(partition);
       ASSERT_TRUE(state_->isPartitionSpilled(partition));
-      ASSERT_FALSE(state_->hasFiles(partition));
+      ASSERT_FALSE(
+          state_->testingNonEmptySpilledPartitionSet().contains(partition));
       for (auto iter = 0; iter < numBatches / 2; ++iter) {
         batchesByPartition_[partition].push_back(
             makeRowVector({makeFlatVector<int64_t>(
@@ -194,7 +203,8 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
                 })}));
         state_->appendToPartition(
             partition, batchesByPartition_[partition].back());
-        ASSERT_TRUE(state_->hasFiles(partition));
+        ASSERT_TRUE(
+            state_->testingNonEmptySpilledPartitionSet().contains(partition));
 
         batchesByPartition_[partition].push_back(makeRowVector({makeFlatVector<
             int64_t>(
@@ -212,15 +222,19 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
             })}));
         state_->appendToPartition(
             partition, batchesByPartition_[partition].back());
-        ASSERT_TRUE(state_->hasFiles(partition));
+        ASSERT_TRUE(
+            state_->testingNonEmptySpilledPartitionSet().contains(partition));
 
+        ASSERT_GE(state_->numFinishedFiles(partition), 0);
         // Indicates that the next additions to 'partition' are not sorted
         // with respect to the values added so far.
-        state_->finishWrite(partition);
-        ASSERT_TRUE(state_->hasFiles(partition));
+        state_->finishFile(partition);
+        ASSERT_GE(state_->numFinishedFiles(partition), 1);
+        ASSERT_TRUE(
+            state_->testingNonEmptySpilledPartitionSet().contains(partition));
       }
     }
-    ASSERT_EQ(stats_.rlock()->spilledPartitions, numPartitions);
+    ASSERT_EQ(spillStats_.rlock()->spilledPartitions, numPartitions);
     for (int i = 0; i < numPartitions; ++i) {
       ASSERT_TRUE(state_->spilledPartitionSet().contains(i));
     }
@@ -233,10 +247,15 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     if (targetFileSize > 1) {
       expectedFiles /= 2;
     }
-    ASSERT_EQ(stats_.rlock()->spilledFiles, expectedFiles);
+    ASSERT_EQ(spillStats_.rlock()->spilledFiles, expectedFiles);
     ASSERT_GT(
-        stats_.rlock()->spilledBytes,
+        spillStats_.rlock()->spilledBytes,
         numPartitions * numBatches * sizeof(int64_t));
+    int numFinishedFiles{0};
+    for (int partition = 0; partition < numPartitions; ++partition) {
+      numFinishedFiles += state_->numFinishedFiles(partition);
+    }
+    ASSERT_EQ(numFinishedFiles, expectedFiles);
   }
 
   // 'numDuplicates' specifies the number of duplicates generated for each
@@ -248,7 +267,7 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
       int numDuplicates,
       const std::vector<CompareFlags>& compareFlags,
       uint64_t expectedNumSpilledFiles) {
-    const int numRowsPerBatch = 20'000;
+    const int numRowsPerBatch = 1'000;
     SCOPED_TRACE(fmt::format(
         "targetFileSize: {}, numPartitions: {}, numBatches: {}, numDuplicates: {}, nullsFirst: {}, ascending: {}",
         targetFileSize,
@@ -258,7 +277,7 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
         compareFlags.empty() ? true : compareFlags[0].nullsFirst,
         compareFlags.empty() ? true : compareFlags[0].ascending));
 
-    const auto prevGStats = globalSpillStats();
+    const auto prevGStats = common::globalSpillStats();
     setupSpillState(
         targetFileSize,
         0,
@@ -267,18 +286,20 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
         numRowsPerBatch,
         numDuplicates,
         compareFlags);
-    const auto stats = stats_.copy();
+    const auto stats = spillStats_.copy();
     ASSERT_EQ(stats.spilledPartitions, numPartitions);
     ASSERT_EQ(stats.spilledFiles, expectedNumSpilledFiles);
     ASSERT_GT(stats.spilledBytes, 0);
-    ASSERT_GT(stats.spillDiskWrites, 0);
-    ASSERT_GT(stats.spillWriteTimeUs, 0);
-    ASSERT_GT(stats.spillFlushTimeUs, 0);
+    ASSERT_GT(stats.spillWrites, 0);
+    // NOTE: On fast machines we might have sub-microsecond in each write,
+    // resulting in 0us total write time.
+    ASSERT_GE(stats.spillWriteTimeNanos, 0);
+    ASSERT_GE(stats.spillFlushTimeNanos, 0);
     ASSERT_GT(stats.spilledRows, 0);
     // NOTE: the following stats are not collected by spill state.
-    ASSERT_EQ(stats.spillFillTimeUs, 0);
-    ASSERT_EQ(stats.spillSortTimeUs, 0);
-    const auto newGStats = globalSpillStats();
+    ASSERT_EQ(stats.spillFillTimeNanos, 0);
+    ASSERT_EQ(stats.spillSortTimeNanos, 0);
+    const auto newGStats = common::globalSpillStats();
     ASSERT_EQ(
         prevGStats.spilledPartitions + stats.spilledPartitions,
         newGStats.spilledPartitions);
@@ -287,23 +308,30 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     ASSERT_EQ(
         prevGStats.spilledBytes + stats.spilledBytes, newGStats.spilledBytes);
     ASSERT_EQ(
-        prevGStats.spillDiskWrites + stats.spillDiskWrites,
-        newGStats.spillDiskWrites);
+        prevGStats.spillWrites + stats.spillWrites, newGStats.spillWrites);
     ASSERT_EQ(
-        prevGStats.spillWriteTimeUs + stats.spillWriteTimeUs,
-        newGStats.spillWriteTimeUs);
+        prevGStats.spillWriteTimeNanos + stats.spillWriteTimeNanos,
+        newGStats.spillWriteTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillFlushTimeUs + stats.spillFlushTimeUs,
-        newGStats.spillFlushTimeUs);
+        prevGStats.spillFlushTimeNanos + stats.spillFlushTimeNanos,
+        newGStats.spillFlushTimeNanos);
     ASSERT_EQ(
         prevGStats.spilledRows + stats.spilledRows, newGStats.spilledRows);
     ASSERT_EQ(
-        prevGStats.spillFillTimeUs + stats.spillFillTimeUs,
-        newGStats.spillFillTimeUs);
+        prevGStats.spillFillTimeNanos + stats.spillFillTimeNanos,
+        newGStats.spillFillTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillSortTimeUs + stats.spillSortTimeUs,
-        newGStats.spillSortTimeUs);
-
+        prevGStats.spillSortTimeNanos + stats.spillSortTimeNanos,
+        newGStats.spillSortTimeNanos);
+
+    // Verifies the spill file id
+    for (auto& partitionNum : state_->spilledPartitionSet()) {
+      const auto spilledFileIds = state_->testingSpilledFileIds(partitionNum);
+      uint32_t expectedFileId{0};
+      for (auto spilledFileId : spilledFileIds) {
+        ASSERT_EQ(spilledFileId, expectedFileId++);
+      }
+    }
     std::vector<std::string> spilledFiles = state_->testingSpilledFilePaths();
     std::unordered_set<std::string> spilledFileSet(
         spilledFiles.begin(), spilledFiles.end());
@@ -311,7 +339,7 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     ASSERT_EQ(expectedNumSpilledFiles, spilledFileSet.size());
     // Verify the spilled file exist on file system.
     std::shared_ptr<FileSystem> fs =
-        filesystems::getFileSystem(tempDir_->path, nullptr);
+        filesystems::getFileSystem(tempDir_->getPath(), nullptr);
     uint64_t totalFileBytes{0};
     for (const auto& spilledFile : spilledFileSet) {
       auto readFile = fs->openFileForRead(spilledFile);
@@ -322,8 +350,13 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     ASSERT_EQ(prevGStats.spilledBytes + totalFileBytes, newGStats.spilledBytes);
 
     for (auto partition = 0; partition < state_->maxPartitions(); ++partition) {
+      auto spillFiles = state_->finish(partition);
+      ASSERT_EQ(state_->numFinishedFiles(partition), 0);
+      auto spillPartition =
+          SpillPartition(SpillPartitionId{0, partition}, std::move(spillFiles));
+      auto merge =
+          spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_);
       int numReadBatches = 0;
-      auto merge = state_->startMerge(partition, nullptr);
       // We expect all the rows in dense increasing order.
       for (auto i = 0; i < numBatches * numRowsPerBatch; ++i) {
         auto stream = merge->next();
@@ -358,24 +391,37 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
       // We do two append writes per each input batch.
       ASSERT_EQ(numBatches, numReadBatches);
     }
-    const auto finalStats = stats_.copy();
+
+    const auto finalStats = spillStats_.copy();
+    ASSERT_EQ(finalStats.spillReadBytes, finalStats.spilledBytes);
+    ASSERT_GT(finalStats.spillReads, 0);
+    ASSERT_GT(finalStats.spillReadTimeNanos, 0);
+    ASSERT_GT(finalStats.spillDeserializationTimeNanos, 0);
     ASSERT_EQ(
         finalStats.toString(),
         fmt::format(
-            "spillRuns[{}] spilledInputBytes[{}] spilledBytes[{}] spilledRows[{}] spilledPartitions[{}] spilledFiles[{}] spillFillTimeUs[{}] spillSortTime[{}] spillSerializationTime[{}] spillDiskWrites[{}] spillFlushTime[{}] spillWriteTime[{}]",
+            "spillRuns[{}] spilledInputBytes[{}] spilledBytes[{}] spilledRows[{}] "
+            "spilledPartitions[{}] spilledFiles[{}] spillFillTimeNanos[{}] "
+            "spillSortTimeNanos[{}] spillSerializationTimeNanos[{}] spillWrites[{}] "
+            "spillFlushTimeNanos[{}] spillWriteTimeNanos[{}] maxSpillExceededLimitCount[0] "
+            "spillReadBytes[{}] spillReads[{}] spillReadTimeNanos[{}] "
+            "spillReadDeserializationTimeNanos[{}]",
             finalStats.spillRuns,
             succinctBytes(finalStats.spilledInputBytes),
             succinctBytes(finalStats.spilledBytes),
             finalStats.spilledRows,
             finalStats.spilledPartitions,
             finalStats.spilledFiles,
-            succinctMicros(finalStats.spillFillTimeUs),
-            succinctMicros(finalStats.spillSortTimeUs),
-            succinctMicros(finalStats.spillSerializationTimeUs),
-            finalStats.spillDiskWrites,
-            succinctMicros(finalStats.spillFlushTimeUs),
-            succinctMicros(finalStats.spillWriteTimeUs)));
-
+            succinctNanos(finalStats.spillFillTimeNanos),
+            succinctNanos(finalStats.spillSortTimeNanos),
+            succinctNanos(finalStats.spillSerializationTimeNanos),
+            finalStats.spillWrites,
+            succinctNanos(finalStats.spillFlushTimeNanos),
+            succinctNanos(finalStats.spillWriteTimeNanos),
+            succinctBytes(finalStats.spillReadBytes),
+            finalStats.spillReads,
+            succinctNanos(finalStats.spillReadTimeNanos),
+            succinctNanos(finalStats.spillDeserializationTimeNanos)));
     // Verify the spilled files are still there after spill state destruction.
     for (const auto& spilledFile : spilledFileSet) {
       ASSERT_TRUE(fs->exists(spilledFile));
@@ -390,11 +436,12 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
   common::CompressionKind compressionKind_;
   std::vector<std::optional<int64_t>> values_;
   std::vector<std::vector<RowVectorPtr>> batchesByPartition_;
-  std::string spillPath_;
-  folly::Synchronized<SpillStats> stats_;
+  std::string fileNamePrefix_;
+  folly::Synchronized<common::SpillStats> spillStats_;
   std::unique_ptr<SpillState> state_;
   std::unordered_map<std::string, RuntimeMetric> runtimeStats_;
   std::unique_ptr<TestRuntimeStatWriter> statWriter_;
+  common::UpdateAndCheckSpillLimitCB updateSpilledBytesCb_;
 };
 
 TEST_P(SpillTest, spillState) {
@@ -402,18 +449,18 @@ TEST_P(SpillTest, spillState) {
   // triggered by batch write.
 
   // Test with distinct sort keys.
-  spillStateTest(kGB, 2, 10, 1, {CompareFlags{true, true}}, 10);
-  spillStateTest(kGB, 2, 10, 1, {CompareFlags{true, false}}, 10);
-  spillStateTest(kGB, 2, 10, 1, {CompareFlags{false, true}}, 10);
-  spillStateTest(kGB, 2, 10, 1, {CompareFlags{false, false}}, 10);
-  spillStateTest(kGB, 2, 10, 1, {}, 10);
+  spillStateTest(kGB, 2, 8, 1, {CompareFlags{true, true}}, 8);
+  spillStateTest(kGB, 2, 8, 1, {CompareFlags{true, false}}, 8);
+  spillStateTest(kGB, 2, 8, 1, {CompareFlags{false, true}}, 8);
+  spillStateTest(kGB, 2, 8, 1, {CompareFlags{false, false}}, 8);
+  spillStateTest(kGB, 2, 8, 1, {}, 8);
 
   // Test with duplicate sort keys.
-  spillStateTest(kGB, 2, 10, 10, {CompareFlags{true, true}}, 10);
-  spillStateTest(kGB, 2, 10, 10, {CompareFlags{true, false}}, 10);
-  spillStateTest(kGB, 2, 10, 10, {CompareFlags{false, true}}, 10);
-  spillStateTest(kGB, 2, 10, 10, {CompareFlags{false, false}}, 10);
-  spillStateTest(kGB, 2, 10, 10, {}, 10);
+  spillStateTest(kGB, 2, 8, 8, {CompareFlags{true, true}}, 8);
+  spillStateTest(kGB, 2, 8, 8, {CompareFlags{true, false}}, 8);
+  spillStateTest(kGB, 2, 8, 8, {CompareFlags{false, true}}, 8);
+  spillStateTest(kGB, 2, 8, 8, {CompareFlags{false, false}}, 8);
+  spillStateTest(kGB, 2, 8, 8, {}, 8);
 }
 
 TEST_P(SpillTest, spillTimestamp) {
@@ -421,7 +468,7 @@ TEST_P(SpillTest, spillTimestamp) {
   // read back.
   auto tempDirectory = exec::test::TempDirectoryPath::create();
   std::vector<CompareFlags> emptyCompareFlags;
-  const std::string spillPath = tempDirectory->path + "/test";
+  const std::string spillPath = tempDirectory->getPath() + "/test";
   std::vector<Timestamp> timeValues = {
       Timestamp{0, 0},
       Timestamp{12, 0},
@@ -432,7 +479,9 @@ TEST_P(SpillTest, spillTimestamp) {
       Timestamp{Timestamp::kMinSeconds, 0}};
 
   SpillState state(
-      spillPath,
+      [&]() -> const std::string& { return tempDirectory->getPath(); },
+      updateSpilledBytesCb_,
+      "test",
       1,
       1,
       emptyCompareFlags,
@@ -440,20 +489,28 @@ TEST_P(SpillTest, spillTimestamp) {
       0,
       compressionKind_,
       pool(),
-      &stats_);
+      &spillStats_);
   int partitionIndex = 0;
   state.setPartitionSpilled(partitionIndex);
-  EXPECT_TRUE(state.isPartitionSpilled(partitionIndex));
-  EXPECT_FALSE(state.hasFiles(partitionIndex));
+  ASSERT_TRUE(state.isPartitionSpilled(partitionIndex));
+  ASSERT_FALSE(
+      state.testingNonEmptySpilledPartitionSet().contains(partitionIndex));
   state.appendToPartition(
       partitionIndex, makeRowVector({makeFlatVector<Timestamp>(timeValues)}));
-  state.finishWrite(partitionIndex);
-  EXPECT_TRUE(state.hasFiles(partitionIndex));
-
-  auto merge = state.startMerge(partitionIndex, nullptr);
+  state.finishFile(partitionIndex);
+  EXPECT_TRUE(
+      state.testingNonEmptySpilledPartitionSet().contains(partitionIndex));
+
+  SpillPartition spillPartition(SpillPartitionId{0, 0}, state.finish(0));
+  auto merge =
+      spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_);
+  ASSERT_TRUE(merge != nullptr);
+  ASSERT_TRUE(
+      spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_) ==
+      nullptr);
   for (auto i = 0; i < timeValues.size(); ++i) {
-    auto stream = merge->next();
-    ASSERT_NE(nullptr, stream);
+    auto* stream = merge->next();
+    ASSERT_NE(stream, nullptr);
     ASSERT_EQ(
         timeValues[i],
         stream->decoded(0).valueAt<Timestamp>(stream->currentIndex()));
@@ -467,18 +524,18 @@ TEST_P(SpillTest, spillStateWithSmallTargetFileSize) {
   // write.
 
   // Test with distinct sort keys.
-  spillStateTest(1, 2, 10, 1, {CompareFlags{true, true}}, 10 * 2);
-  spillStateTest(1, 2, 10, 1, {CompareFlags{true, false}}, 10 * 2);
-  spillStateTest(1, 2, 10, 1, {CompareFlags{false, true}}, 10 * 2);
-  spillStateTest(1, 2, 10, 1, {CompareFlags{false, false}}, 10 * 2);
-  spillStateTest(1, 2, 10, 1, {}, 10 * 2);
+  spillStateTest(1, 2, 8, 1, {CompareFlags{true, true}}, 8 * 2);
+  spillStateTest(1, 2, 8, 1, {CompareFlags{true, false}}, 8 * 2);
+  spillStateTest(1, 2, 8, 1, {CompareFlags{false, true}}, 8 * 2);
+  spillStateTest(1, 2, 8, 1, {CompareFlags{false, false}}, 8 * 2);
+  spillStateTest(1, 2, 8, 1, {}, 8 * 2);
 
   // Test with duplicated sort keys.
-  spillStateTest(1, 2, 10, 10, {CompareFlags{true, false}}, 10 * 2);
-  spillStateTest(1, 2, 10, 10, {CompareFlags{true, true}}, 10 * 2);
-  spillStateTest(1, 2, 10, 10, {CompareFlags{false, false}}, 10 * 2);
-  spillStateTest(1, 2, 10, 10, {CompareFlags{false, true}}, 10 * 2);
-  spillStateTest(1, 2, 10, 10, {}, 10 * 2);
+  spillStateTest(1, 2, 8, 8, {CompareFlags{true, false}}, 8 * 2);
+  spillStateTest(1, 2, 8, 8, {CompareFlags{true, true}}, 8 * 2);
+  spillStateTest(1, 2, 8, 8, {CompareFlags{false, false}}, 8 * 2);
+  spillStateTest(1, 2, 8, 8, {CompareFlags{false, true}}, 8 * 2);
+  spillStateTest(1, 2, 8, 8, {}, 8 * 2);
 }
 
 TEST_P(SpillTest, spillPartitionId) {
@@ -494,7 +551,7 @@ TEST_P(SpillTest, spillPartitionId) {
   ASSERT_NE(partitionId1_2, partitionId1_3);
   ASSERT_LT(partitionId1_2, partitionId1_3);
 
-  for (int iter = 0; iter < 5; ++iter) {
+  for (int iter = 0; iter < 3; ++iter) {
     folly::Random::DefaultGenerator rng;
     rng.seed(iter);
     const int numIds = std::max<int>(1024, folly::Random::rand64(rng) % 4096);
@@ -529,7 +586,7 @@ TEST_P(SpillTest, spillPartitionId) {
 }
 
 TEST_P(SpillTest, spillPartitionSet) {
-  for (int iter = 0; iter < 5; ++iter) {
+  for (int iter = 0; iter < 3; ++iter) {
     folly::Random::DefaultGenerator rng;
     rng.seed(iter);
     const int numPartitions =
@@ -547,8 +604,13 @@ TEST_P(SpillTest, spillPartitionSet) {
       partitionIdSet.insert(id);
       spillPartitions.push_back(std::make_unique<SpillPartition>(id));
       ASSERT_EQ(id, spillPartitions.back()->id());
+      ASSERT_EQ(
+          spillPartitions.back()->toString(),
+          fmt::format(
+              "SPILLED PARTITION[ID:{} FILES:0 SIZE:0B]", id.toString()));
       // Expect an empty reader.
-      auto reader = spillPartitions.back()->createReader();
+      auto reader = spillPartitions.back()->createUnorderedReader(
+          1 << 20, pool(), &spillStats_);
       ASSERT_FALSE(reader->nextBatch(output));
     }
 
@@ -579,21 +641,28 @@ TEST_P(SpillTest, spillPartitionSet) {
   std::vector<std::vector<RowVectorPtr>> batchesByPartition(numPartitions);
   std::vector<std::unique_ptr<SpillPartition>> spillPartitions;
   int numBatchesPerPartition = 0;
-  const int numRowsPerBatch = 100;
+  const int numRowsPerBatch = 50;
+  std::vector<uint64_t> expectedPartitionSizes(numPartitions, 0);
+  std::vector<uint64_t> expectedPartitionFiles(numPartitions, 0);
   for (int iter = 0; iter < numSpillers; ++iter) {
     folly::Random::DefaultGenerator rng;
     rng.seed(iter);
     int numBatches = 2 * (1 + folly::Random::rand32(rng) % 16);
     setupSpillState(
-        iter % 2 ? 1 : kGB, numPartitions, numBatches, numRowsPerBatch);
+        iter % 2 ? 1 : kGB, 0, numPartitions, numBatches, numRowsPerBatch);
     numBatchesPerPartition += numBatches;
     for (int i = 0; i < numPartitions; ++i) {
       const SpillPartitionId id(0, i);
+      auto spillFiles = state_->finish(i);
+      for (const auto& fileInfo : spillFiles) {
+        expectedPartitionSizes[i] += fileInfo.size;
+        ++expectedPartitionFiles[i];
+      }
       if (iter == 0) {
         spillPartitions.emplace_back(
-            std::make_unique<SpillPartition>(id, state_->files(i)));
+            std::make_unique<SpillPartition>(id, std::move(spillFiles)));
       } else {
-        spillPartitions[i]->addFiles(state_->files(i));
+        spillPartitions[i]->addFiles(std::move(spillFiles));
       }
       std::copy(
           batchesByPartition_[i].begin(),
@@ -605,7 +674,16 @@ TEST_P(SpillTest, spillPartitionSet) {
   for (int i = 0; i < numPartitions; ++i) {
     RowVectorPtr output;
     {
-      auto reader = spillPartitions[i]->createReader();
+      ASSERT_EQ(spillPartitions[i]->size(), expectedPartitionSizes[i]);
+      ASSERT_EQ(
+          spillPartitions[i]->toString(),
+          fmt::format(
+              "SPILLED PARTITION[ID:[0,{}] FILES:{} SIZE:{}]",
+              i,
+              expectedPartitionFiles[i],
+              succinctBytes(expectedPartitionSizes[i])));
+      auto reader = spillPartitions[i]->createUnorderedReader(
+          1 << 20, pool(), &spillStats_);
       for (int j = 0; j < numBatchesPerPartition; ++j) {
         ASSERT_TRUE(reader->nextBatch(output));
         for (int row = 0; row < numRowsPerBatch; ++row) {
@@ -619,7 +697,8 @@ TEST_P(SpillTest, spillPartitionSet) {
     // Check spill partition state after creating the reader.
     ASSERT_EQ(0, spillPartitions[i]->numFiles());
     {
-      auto reader = spillPartitions[i]->createReader();
+      auto reader = spillPartitions[i]->createUnorderedReader(
+          1 << 20, pool(), &spillStats_);
       ASSERT_FALSE(reader->nextBatch(output));
     }
   }
@@ -628,16 +707,16 @@ TEST_P(SpillTest, spillPartitionSet) {
 TEST_P(SpillTest, spillPartitionSpilt) {
   for (int seed = 0; seed < 5; ++seed) {
     SCOPED_TRACE(fmt::format("seed: {}", seed));
-    int numBatches = 100;
+    int numBatches = 50;
     std::vector<RowVectorPtr> batches;
     batches.reserve(numBatches);
 
-    const int numRowsPerBatch = 100;
-    setupSpillState(seed % 2 ? 1 : kGB, 1, numBatches, numRowsPerBatch);
+    const int numRowsPerBatch = 50;
+    setupSpillState(seed % 2 ? 1 : kGB, 0, 1, numBatches, numRowsPerBatch);
     const SpillPartitionId id(0, 0);
 
     auto spillPartition =
-        std::make_unique<SpillPartition>(id, state_->files(0));
+        std::make_unique<SpillPartition>(id, state_->finish(0));
     std::copy(
         batchesByPartition_[0].begin(),
         batchesByPartition_[0].end(),
@@ -645,17 +724,28 @@ TEST_P(SpillTest, spillPartitionSpilt) {
 
     folly::Random::DefaultGenerator rng;
     rng.seed(seed);
-    const int32_t numSplits =
-        1 + folly::Random::rand32(spillPartition->numFiles() * 2 / 3);
-    auto spillPartitionSplits = spillPartition->split(numSplits);
-    for (const auto& partitionSplit : spillPartitionSplits) {
-      ASSERT_EQ(id, partitionSplit->id());
+    const auto totalNumFiles = spillPartition->numFiles();
+    const int32_t numShards = 1 + folly::Random::rand32(totalNumFiles * 2 / 3);
+    auto spillPartitionShards = spillPartition->split(numShards);
+    for (const auto& partitionShard : spillPartitionShards) {
+      ASSERT_EQ(id, partitionShard->id());
+    }
+
+    // Even split distribution verification.
+    int minNumFiles = std::numeric_limits<int>::max();
+    int maxNumFiles = std::numeric_limits<int>::min();
+    for (uint32_t i = 0; i < numShards; i++) {
+      auto numFiles = spillPartitionShards[i]->numFiles();
+      minNumFiles = std::min(minNumFiles, numFiles);
+      maxNumFiles = std::max(maxNumFiles, numFiles);
     }
+    ASSERT_LE(maxNumFiles - minNumFiles, 1);
 
     // Read verification.
     int batchIdx = 0;
-    for (int32_t i = 0; i < numSplits; ++i) {
-      auto reader = spillPartitionSplits[i]->createReader();
+    for (int32_t i = 0; i < numShards; ++i) {
+      auto reader = spillPartitionShards[i]->createUnorderedReader(
+          1 << 20, pool(), &spillStats_);
       RowVectorPtr output;
       while (reader->nextBatch(output)) {
         for (int row = 0; row < numRowsPerBatch; ++row) {
@@ -672,15 +762,108 @@ TEST_P(SpillTest, spillPartitionSpilt) {
 }
 
 TEST_P(SpillTest, nonExistSpillFileOnDeletion) {
-  const int32_t numRowsPerBatch = 100;
+  const int32_t numRowsPerBatch = 50;
   std::vector<RowVectorPtr> batches;
-  setupSpillState(kGB, 1, 2, numRowsPerBatch);
+  setupSpillState(kGB, 0, 1, 2, numRowsPerBatch);
   // Delete the tmp dir to verify the spill file deletion error won't fail the
   // test.
   tempDir_.reset();
   state_.reset();
 }
 
+namespace {
+SpillFiles makeFakeSpillFiles(int32_t numFiles) {
+  auto tempDir = exec::test::TempDirectoryPath::create();
+  static uint32_t fakeFileId{0};
+  SpillFiles files;
+  files.reserve(numFiles);
+  const std::string filePathPrefix = tempDir->getPath() + "/Spill";
+  for (int32_t i = 0; i < numFiles; ++i) {
+    const auto fileId = fakeFileId;
+    files.push_back(
+        {fileId,
+         ROW({"k1", "k2"}, {BIGINT(), BIGINT()}),
+         tempDir->getPath() + "/Spill_" + std::to_string(fileId),
+         1024,
+         1,
+         std::vector<CompareFlags>({}),
+         common::CompressionKind_NONE});
+  }
+  return files;
+}
+} // namespace
+
+TEST(SpillTest, removeEmptyPartitions) {
+  SpillPartitionSet partitionSet;
+  const int32_t partitionOffset = 8;
+  const int32_t numPartitions = 8;
+
+  for (int32_t partition = 0; partition < numPartitions; ++partition) {
+    const SpillPartitionId id(partitionOffset, partition);
+    if (partition & 0x01) {
+      partitionSet.emplace(
+          id,
+          std::make_unique<SpillPartition>(
+              id, makeFakeSpillFiles(1 + partition / 2)));
+    } else {
+      partitionSet.emplace(id, std::make_unique<SpillPartition>(id));
+    }
+  }
+  ASSERT_EQ(partitionSet.size(), numPartitions);
+
+  removeEmptyPartitions(partitionSet);
+  ASSERT_EQ(partitionSet.size(), numPartitions / 2);
+
+  for (int32_t partition = 0; partition < numPartitions / 2; ++partition) {
+    const int32_t partitionNum = partition * 2 + 1;
+    const SpillPartitionId id(partitionOffset, partitionNum);
+    ASSERT_EQ(partitionSet.at(id)->id().partitionBitOffset(), partitionOffset);
+    ASSERT_EQ(partitionSet.at(id)->id().partitionNumber(), partitionNum);
+    ASSERT_EQ(partitionSet.at(id)->numFiles(), 1 + partitionNum / 2);
+  }
+}
+
+TEST(SpillTest, scopedSpillInjectionRegex) {
+  {
+    TestScopedSpillInjection scopedSpillInjection(100, ".*?(TableWrite).*");
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.TableWrite"));
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.TableWrite.hive-xyz"));
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.TableWrite-hive-xyz"));
+    ASSERT_FALSE(testingTriggerSpill("op.1.0.0.RowNumber"));
+    ASSERT_TRUE(testingTriggerSpill(""));
+  }
+
+  {
+    TestScopedSpillInjection scopedSpillInjection(
+        100, ".*?(RowNumber|TableWrite|HashBuild).*");
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.RowNumber"));
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.TableWrite.hive-xyz"));
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.TableWrite-hive-xyz"));
+    ASSERT_TRUE(testingTriggerSpill("op.1..0.HashBuild"));
+    ASSERT_FALSE(testingTriggerSpill("op.1.0.0.Aggregation"));
+    ASSERT_TRUE(testingTriggerSpill(""));
+  }
+
+  {
+    TestScopedSpillInjection scopedSpillInjection(
+        100, R"(.*?(RowNumber|TableWrite|HashBuild)(?:\..*)?)");
+    ASSERT_TRUE(testingTriggerSpill("op.1.RowNumber"));
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.TableWrite.hive-xyz"));
+    ASSERT_FALSE(testingTriggerSpill("op.1.0.0.TableWrite-hive-xyz"));
+    ASSERT_FALSE(testingTriggerSpill("op.1.0.0.Aggregation"));
+    ASSERT_TRUE(testingTriggerSpill(""));
+  }
+
+  {
+    TestScopedSpillInjection scopedSpillInjection(100);
+    ASSERT_TRUE(testingTriggerSpill("op.1.RowNumber"));
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.TableWrite.hive-xyz"));
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.TableWrite-hive-xyz"));
+    ASSERT_TRUE(testingTriggerSpill("op.1.0.0.Aggregation"));
+    ASSERT_TRUE(testingTriggerSpill());
+  }
+}
+
 INSTANTIATE_TEST_SUITE_P(
     SpillTestSuite,
     SpillTest,
@@ -691,86 +874,3 @@ INSTANTIATE_TEST_SUITE_P(
         common::CompressionKind::CompressionKind_ZSTD,
         common::CompressionKind::CompressionKind_LZ4,
         common::CompressionKind::CompressionKind_GZIP));
-
-TEST(SpillTest, spillStats) {
-  SpillStats stats1;
-  ASSERT_TRUE(stats1.empty());
-  stats1.spillRuns = 100;
-  stats1.spilledInputBytes = 2048;
-  stats1.spilledBytes = 1024;
-  stats1.spilledPartitions = 1024;
-  stats1.spilledFiles = 1023;
-  stats1.spillWriteTimeUs = 1023;
-  stats1.spillFlushTimeUs = 1023;
-  stats1.spillDiskWrites = 1023;
-  stats1.spillSortTimeUs = 1023;
-  stats1.spillFillTimeUs = 1023;
-  stats1.spilledRows = 1023;
-  stats1.spillSerializationTimeUs = 1023;
-  ASSERT_FALSE(stats1.empty());
-  SpillStats stats2;
-  stats2.spillRuns = 100;
-  stats2.spilledInputBytes = 2048;
-  stats2.spilledBytes = 1024;
-  stats2.spilledPartitions = 1025;
-  stats2.spilledFiles = 1026;
-  stats2.spillWriteTimeUs = 1026;
-  stats2.spillFlushTimeUs = 1027;
-  stats2.spillDiskWrites = 1028;
-  stats2.spillSortTimeUs = 1029;
-  stats2.spillFillTimeUs = 1030;
-  stats2.spilledRows = 1031;
-  stats2.spillSerializationTimeUs = 1032;
-  ASSERT_TRUE(stats1 < stats2);
-  ASSERT_TRUE(stats1 <= stats2);
-  ASSERT_FALSE(stats1 > stats2);
-  ASSERT_FALSE(stats1 >= stats2);
-  ASSERT_TRUE(stats1 != stats2);
-  ASSERT_FALSE(stats1 == stats2);
-
-  ASSERT_TRUE(stats1 == stats1);
-  ASSERT_FALSE(stats1 != stats1);
-  ASSERT_FALSE(stats1 > stats1);
-  ASSERT_TRUE(stats1 >= stats1);
-  ASSERT_FALSE(stats1 < stats1);
-  ASSERT_TRUE(stats1 <= stats1);
-
-  SpillStats delta = stats2 - stats1;
-  ASSERT_EQ(delta.spilledInputBytes, 0);
-  ASSERT_EQ(delta.spilledBytes, 0);
-  ASSERT_EQ(delta.spilledPartitions, 1);
-  ASSERT_EQ(delta.spilledFiles, 3);
-  ASSERT_EQ(delta.spillWriteTimeUs, 3);
-  ASSERT_EQ(delta.spillFlushTimeUs, 4);
-  ASSERT_EQ(delta.spillDiskWrites, 5);
-  ASSERT_EQ(delta.spillSortTimeUs, 6);
-  ASSERT_EQ(delta.spillFillTimeUs, 7);
-  ASSERT_EQ(delta.spilledRows, 8);
-  ASSERT_EQ(delta.spillSerializationTimeUs, 9);
-  delta = stats1 - stats2;
-  ASSERT_EQ(delta.spilledInputBytes, 0);
-  ASSERT_EQ(delta.spilledBytes, 0);
-  ASSERT_EQ(delta.spilledPartitions, -1);
-  ASSERT_EQ(delta.spilledFiles, -3);
-  ASSERT_EQ(delta.spillWriteTimeUs, -3);
-  ASSERT_EQ(delta.spillFlushTimeUs, -4);
-  ASSERT_EQ(delta.spillDiskWrites, -5);
-  ASSERT_EQ(delta.spillSortTimeUs, -6);
-  ASSERT_EQ(delta.spillFillTimeUs, -7);
-  ASSERT_EQ(delta.spilledRows, -8);
-  ASSERT_EQ(delta.spillSerializationTimeUs, -9);
-  stats1.spilledInputBytes = 2060;
-  stats1.spilledBytes = 1030;
-  VELOX_ASSERT_THROW(stats1 < stats2, "");
-  VELOX_ASSERT_THROW(stats1 > stats2, "");
-  VELOX_ASSERT_THROW(stats1 <= stats2, "");
-  VELOX_ASSERT_THROW(stats1 >= stats2, "");
-  ASSERT_TRUE(stats1 != stats2);
-  ASSERT_FALSE(stats1 == stats2);
-  const SpillStats zeroStats;
-  stats1.reset();
-  ASSERT_EQ(zeroStats, stats1);
-  ASSERT_EQ(
-      stats2.toString(),
-      "spillRuns[100] spilledInputBytes[2.00KB] spilledBytes[1.00KB] spilledRows[1031] spilledPartitions[1025] spilledFiles[1026] spillFillTimeUs[1.03ms] spillSortTime[1.03ms] spillSerializationTime[1.03ms] spillDiskWrites[1028] spillFlushTime[1.03ms] spillWriteTime[1.03ms]");
-}
diff --git a/velox/exec/tests/SpillerAggregateBenchmarkTest.cpp b/velox/exec/tests/SpillerAggregateBenchmarkTest.cpp
new file mode 100644
index 0000000000000..7a8fc77a6c45b
--- /dev/null
+++ b/velox/exec/tests/SpillerAggregateBenchmarkTest.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/AggregateSpillBenchmarkBase.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+#include <gflags/gflags.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+int main(int argc, char* argv[]) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  memory::MemoryManager::initialize({});
+  serializer::presto::PrestoVectorSerde::registerVectorSerde();
+  filesystems::registerLocalFileSystem();
+
+  auto spillerTypeName = FLAGS_spiller_benchmark_spiller_type;
+  std::transform(
+      spillerTypeName.begin(),
+      spillerTypeName.end(),
+      spillerTypeName.begin(),
+      [](unsigned char c) { return std::toupper(c); });
+  Spiller::Type spillerType;
+  if (spillerTypeName == Spiller::typeName(Spiller::Type::kAggregateInput)) {
+    spillerType = Spiller::Type::kAggregateInput;
+  } else if (
+      spillerTypeName == Spiller::typeName(Spiller::Type::kAggregateOutput)) {
+    spillerType = Spiller::Type::kAggregateOutput;
+  } else {
+    VELOX_UNSUPPORTED(
+        "The spiller type {} is not one of [AGGREGATE_INPUT, AGGREGATE_OUTPUT], the aggregate spiller dose not support it.",
+        spillerTypeName);
+  }
+  auto test = std::make_unique<test::AggregateSpillBenchmarkBase>(spillerType);
+  test->setUp();
+  test->run();
+  test->printStats();
+  test->cleanup();
+
+  return 0;
+}
diff --git a/velox/exec/tests/SpillerBenchmark.cpp b/velox/exec/tests/SpillerBenchmark.cpp
deleted file mode 100644
index c8513040fe346..0000000000000
--- a/velox/exec/tests/SpillerBenchmark.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gflags/gflags.h>
-#include <deque>
-
-#include "velox/exec/tests/SpillerBenchmarkBase.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::common;
-using namespace facebook::velox::exec;
-
-int main(int argc, char* argv[]) {
-  gflags::ParseCommandLineFlags(&argc, &argv, true);
-  serializer::presto::PrestoVectorSerde::registerVectorSerde();
-  filesystems::registerLocalFileSystem();
-  auto test =
-      std::make_unique<facebook::velox::exec::test::JoinSpillInputTest>();
-  test->setUp();
-  test->run();
-  test->printStats();
-  test->cleanup();
-  return 0;
-}
diff --git a/velox/exec/tests/SpillerBenchmarkBase.cpp b/velox/exec/tests/SpillerBenchmarkBase.cpp
index 1961b05ef4796..ba3617517a4ff 100644
--- a/velox/exec/tests/SpillerBenchmarkBase.cpp
+++ b/velox/exec/tests/SpillerBenchmarkBase.cpp
@@ -14,54 +14,75 @@
  * limitations under the License.
  */
 
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+#include "velox/common/compression/Compression.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/MmapAllocator.h"
+#include "velox/exec/Spiller.h"
 #include "velox/exec/tests/SpillerBenchmarkBase.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
 
+DEFINE_string(
+    spiller_benchmark_name,
+    "SpillerBenchmarkTest",
+    "The name of this benchmark");
 DEFINE_string(
     spiller_benchmark_path,
     "",
-    "The file directory path for spilling");
-DEFINE_uint64(
-    spiller_benchmark_max_spill_file_size,
-    1 << 30,
-    "The max spill file size");
-DEFINE_uint64(
-    spiller_benchmark_write_buffer_size,
-    1 << 20,
-    "The spill write buffer size");
-DEFINE_uint64(
-    spiller_benchmark_min_spill_run_size,
-    1 << 30,
-    "The file directory path for spiller benchmark");
+    "The directory path for spilling. e.g. with '/path/to/dir' provided, spill "
+    "file like '/path/to/dir/SpillerBenchmarkTest-spill-0-0-0' will be "
+    "created.");
+DEFINE_string(
+    spiller_benchmark_compression_kind,
+    "none",
+    "The compression kind to compress spill rows before write to disk");
+DEFINE_string(
+    spiller_benchmark_spiller_type,
+    "AGGREGATE_INPUT",
+    "The spiller type name.");
 DEFINE_uint32(
     spiller_benchmark_num_spill_vectors,
     10'000,
     "The number of vectors for spilling");
 DEFINE_uint32(
-    spiller_benchmark_spill_vector_size,
-    1'000,
-    "The number of rows per each spill vector");
-DEFINE_string(
-    spiller_benchmark_compression_kind,
-    "none",
-    "The compression kind to compress spill rows before write to disk");
+    spiller_benchmark_num_key_columns,
+    2,
+    "The number of key columns");
 DEFINE_uint32(
     spiller_benchmark_spill_executor_size,
     std::thread::hardware_concurrency(),
     "The spiller executor size in number of threads");
+DEFINE_uint32(
+    spiller_benchmark_spill_vector_size,
+    100,
+    "The number of rows per each spill vector");
+DEFINE_uint64(
+    spiller_benchmark_max_spill_file_size,
+    2 << 30,
+    "The max spill file size");
+DEFINE_uint64(
+    spiller_benchmark_min_spill_run_size,
+    1 << 30,
+    "The minimum spiller run size");
+DEFINE_uint64(
+    spiller_benchmark_write_buffer_size,
+    1 << 20,
+    "The spill write buffer size");
 
-using namespace facebook::velox;
-using namespace facebook::velox::common;
 using namespace facebook::velox::memory;
-using namespace facebook::velox::exec;
 
 namespace facebook::velox::exec::test {
-namespace {
-static const int kNumSampleVectors = 100;
-}
 
-void JoinSpillInputTest::setUp() {
-  rootPool_ = defaultMemoryManager().addRootPool("JoinSpillInputTest");
-  pool_ = rootPool_->addLeafChild("JoinSpillInputTest");
+void SpillerBenchmarkBase::setUp() {
+  rootPool_ =
+      memory::memoryManager()->addRootPool(FLAGS_spiller_benchmark_name);
+  pool_ = rootPool_->addLeafChild(FLAGS_spiller_benchmark_name);
 
   rowType_ =
       ROW({"c0", "c1", "c2", "c3", "c4"},
@@ -74,47 +95,30 @@ void JoinSpillInputTest::setUp() {
     options.vectorSize = inputVectorSize_;
     vectorFuzzer_ = std::make_unique<VectorFuzzer>(options, pool_.get());
   }
-  rowVectors_.reserve(kNumSampleVectors);
-  for (int i = 0; i < kNumSampleVectors; ++i) {
+  rowVectors_.reserve(numInputVectors_);
+  for (int i = 0; i < numInputVectors_; ++i) {
     rowVectors_.push_back(vectorFuzzer_->fuzzRow(rowType_));
   }
 
   if (FLAGS_spiller_benchmark_spill_executor_size != 0) {
     executor_ = std::make_unique<folly::IOThreadPoolExecutor>(
         FLAGS_spiller_benchmark_spill_executor_size,
-        std::make_shared<folly::NamedThreadFactory>("Spiller"));
+        std::make_shared<folly::NamedThreadFactory>(
+            FLAGS_spiller_benchmark_name));
   }
+
   if (FLAGS_spiller_benchmark_path.empty()) {
     tempDir_ = exec::test::TempDirectoryPath::create();
-    spillDir_ = tempDir_->path;
+    spillDir_ = tempDir_->getPath();
   } else {
     spillDir_ = FLAGS_spiller_benchmark_path;
   }
+
   fs_ = filesystems::getFileSystem(spillDir_, {});
   fs_->mkdir(spillDir_);
-
-  spiller_ = std::make_unique<Spiller>(
-      exec::Spiller::Type::kHashJoinProbe,
-      rowType_,
-      HashBitRange{29, 29},
-      fmt::format("{}/{}", spillDir_, "JoinSpillInputTest"),
-      FLAGS_spiller_benchmark_max_spill_file_size,
-      FLAGS_spiller_benchmark_write_buffer_size,
-      FLAGS_spiller_benchmark_min_spill_run_size,
-      stringToCompressionKind(FLAGS_spiller_benchmark_compression_kind),
-      Spiller::pool(),
-      executor_.get());
-  spiller_->setPartitionsSpilled({0});
 }
 
-void JoinSpillInputTest::run() {
-  MicrosecondTimer timer(&executionTimeUs_);
-  for (auto i = 0; i < numInputVectors_; ++i) {
-    spiller_->spill(0, rowVectors_[i % kNumSampleVectors]);
-  }
-}
-
-void JoinSpillInputTest::printStats() {
+void SpillerBenchmarkBase::printStats() const {
   LOG(INFO) << "total execution time: " << succinctMicros(executionTimeUs_);
   LOG(INFO) << numInputVectors_ << " vectors each with " << inputVectorSize_
             << " rows have been processed";
@@ -135,8 +139,9 @@ void JoinSpillInputTest::printStats() {
   }
 }
 
-void JoinSpillInputTest::cleanup() {
+void SpillerBenchmarkBase::cleanup() {
   LOG(INFO) << "Remove spill dir: " << spillDir_;
   fs_->rmdir(spillDir_);
 }
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/SpillerBenchmarkBase.h b/velox/exec/tests/SpillerBenchmarkBase.h
index fec62361dd80f..2fd181cc015a7 100644
--- a/velox/exec/tests/SpillerBenchmarkBase.h
+++ b/velox/exec/tests/SpillerBenchmarkBase.h
@@ -15,57 +15,50 @@
  */
 
 #include <gflags/gflags.h>
-#include <glog/logging.h>
-#include <deque>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
 
 #include <folly/executors/IOThreadPoolExecutor.h>
-#include "velox/common/compression/Compression.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/MmapAllocator.h"
-#include "velox/common/time/Timer.h"
 #include "velox/exec/Spiller.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/serializers/PrestoSerializer.h"
 #include "velox/type/Type.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
+DECLARE_string(spiller_benchmark_compression_kind);
+DECLARE_string(spiller_benchmark_name);
 DECLARE_string(spiller_benchmark_path);
+DECLARE_string(spiller_benchmark_spiller_type);
+DECLARE_uint32(spiller_benchmark_num_key_columns);
+DECLARE_uint32(spiller_benchmark_num_spill_vectors);
+DECLARE_uint32(spiller_benchmark_spill_executor_size);
+DECLARE_uint32(spiller_benchmark_spill_vector_size);
 DECLARE_uint64(spiller_benchmark_max_spill_file_size);
 DECLARE_uint64(spiller_benchmark_min_spill_run_size);
-DECLARE_uint32(spiller_benchmark_num_input_vectors);
-DECLARE_uint32(spiller_benchmark_input_vector_size);
-DECLARE_string(spiller_benchmark_compression_kind);
-DECLARE_uint32(spiller_benchmark_spill_executor_size);
-
-using namespace facebook::velox;
-using namespace facebook::velox::common;
-using namespace facebook::velox::memory;
-using namespace facebook::velox::exec;
+DECLARE_uint64(spiller_benchmark_write_buffer_size);
 
 namespace facebook::velox::exec::test {
 // This test measures the spill input overhead in spill join & probe.
-class JoinSpillInputTest {
+class SpillerBenchmarkBase {
  public:
-  JoinSpillInputTest() = default;
+  SpillerBenchmarkBase() = default;
+
+  virtual ~SpillerBenchmarkBase() = default;
 
   /// Sets up the test.
-  void setUp();
+  virtual void setUp() = 0;
 
   /// Runs the test.
-  void run();
+  virtual void run() = 0;
 
   /// Prints out the measured test stats.
-  void printStats();
+  virtual void printStats() const;
 
   /// Cleans up the test.
-  void cleanup();
+  virtual void cleanup();
 
- private:
-  std::shared_ptr<MemoryPool> rootPool_;
-  std::shared_ptr<MemoryPool> pool_;
+ protected:
+  std::shared_ptr<velox::memory::MemoryPool> rootPool_;
+  std::shared_ptr<velox::memory::MemoryPool> pool_;
   RowTypePtr rowType_;
   uint32_t numInputVectors_;
   uint32_t inputVectorSize_;
@@ -78,5 +71,6 @@ class JoinSpillInputTest {
   std::unique_ptr<Spiller> spiller_;
   // Stats.
   uint64_t executionTimeUs_{0};
+  folly::Synchronized<common::SpillStats> spillStats_;
 };
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/SpillerJoinInputBenchmarkTest.cpp b/velox/exec/tests/SpillerJoinInputBenchmarkTest.cpp
new file mode 100644
index 0000000000000..f2a655a388c82
--- /dev/null
+++ b/velox/exec/tests/SpillerJoinInputBenchmarkTest.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gflags/gflags.h>
+#include "velox/serializers/PrestoSerializer.h"
+
+#include "velox/exec/tests/JoinSpillInputBenchmarkBase.h"
+
+using namespace facebook::velox;
+
+int main(int argc, char* argv[]) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  memory::MemoryManager::initialize({});
+  serializer::presto::PrestoVectorSerde::registerVectorSerde();
+  filesystems::registerLocalFileSystem();
+  auto test = std::make_unique<exec::test::JoinSpillInputBenchmarkBase>();
+  test->setUp();
+  test->run();
+  test->printStats();
+  test->cleanup();
+  return 0;
+}
diff --git a/velox/exec/tests/SpillerTest.cpp b/velox/exec/tests/SpillerTest.cpp
index 90c99bec0185d..4d1db05164b18 100644
--- a/velox/exec/tests/SpillerTest.cpp
+++ b/velox/exec/tests/SpillerTest.cpp
@@ -19,7 +19,9 @@
 #include <unordered_set>
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/HashJoinBridge.h"
 #include "velox/exec/HashPartitionFunction.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/RowContainer.h"
@@ -55,28 +57,44 @@ struct TestParam {
   // write path is executed inline with spiller control code path.
   int poolSize;
   common::CompressionKind compressionKind;
+  core::JoinType joinType;
 
   TestParam(
       Spiller::Type _type,
       int _poolSize,
-      common::CompressionKind _compressionKind)
-      : type(_type), poolSize(_poolSize), compressionKind(_compressionKind) {}
+      common::CompressionKind _compressionKind,
+      core::JoinType _joinType)
+      : type(_type),
+        poolSize(_poolSize),
+        compressionKind(_compressionKind),
+        joinType(_joinType) {}
 
   std::string toString() const {
-    return fmt::format("{}|{}", Spiller::typeName(type), poolSize);
+    return fmt::format(
+        "{}|{}|{}|{}",
+        Spiller::typeName(type),
+        poolSize,
+        compressionKindToString(compressionKind),
+        joinTypeName(joinType));
   }
 };
 
 struct TestParamsBuilder {
   std::vector<TestParam> getTestParams() {
     std::vector<TestParam> params;
-    for (int i = 0; i < Spiller::kNumTypes; ++i) {
+    const auto numSpillerTypes = static_cast<int8_t>(Spiller::Type::kNumTypes);
+    for (int i = 0; i < numSpillerTypes; ++i) {
       const auto type = static_cast<Spiller::Type>(i);
       if (typesToExclude.find(type) == typesToExclude.end()) {
         common::CompressionKind compressionKind =
-            static_cast<common::CompressionKind>(Spiller::kNumTypes % 6);
+            static_cast<common::CompressionKind>(numSpillerTypes % 6);
         for (int poolSize : {0, 8}) {
-          params.emplace_back(type, poolSize, compressionKind);
+          params.emplace_back(
+              type, poolSize, compressionKind, core::JoinType::kRight);
+          if (type == Spiller::Type::kHashJoinBuild) {
+            params.emplace_back(
+                type, poolSize, compressionKind, core::JoinType::kLeft);
+          }
         }
       }
     }
@@ -110,6 +128,8 @@ class SpillerTest : public exec::test::RowContainerTestBase {
  public:
   static void SetUpTestCase() {
     TestValue::enable();
+    memory::MemoryManager::testingSetInstance({});
+    facebook::velox::tests::utils::registerFaultyFileSystem();
   }
 
   explicit SpillerTest(const TestParam& param)
@@ -117,9 +137,14 @@ class SpillerTest : public exec::test::RowContainerTestBase {
         type_(param.type),
         executorPoolSize_(param.poolSize),
         compressionKind_(param.compressionKind),
+        joinType_(param.joinType),
+        spillProbedFlag_(
+            type_ == Spiller::Type::kHashJoinBuild &&
+            needRightSideJoin(joinType_)),
         hashBits_(
             0,
-            (type_ == Spiller::Type::kOrderBy ||
+            (type_ == Spiller::Type::kOrderByInput ||
+             type_ == Spiller::Type::kOrderByOutput ||
              type_ == Spiller::Type::kAggregateOutput)
                 ? 0
                 : 2),
@@ -135,9 +160,14 @@ class SpillerTest : public exec::test::RowContainerTestBase {
   void SetUp() override {
     RowContainerTestBase::SetUp();
     rng_.seed(1);
-    tempDirPath_ = exec::test::TempDirectoryPath::create();
-    fs_ = filesystems::getFileSystem(tempDirPath_->path, nullptr);
-    rowType_ = ROW({
+    const bool asyncRead = folly::Random::oneIn(2);
+    LOG(INFO) << "Async read " << asyncRead;
+    tempDirPath_ = exec::test::TempDirectoryPath::create(true);
+    fs_ = filesystems::getFileSystem(tempDirPath_->getPath(), nullptr);
+    faultyFs_ = static_cast<tests::utils::FaultyFileSystem*>(fs_.get());
+    fsExecutor_ = std::make_unique<folly::CPUThreadPoolExecutor>(32);
+    faultyFs_->setExecutor(fsExecutor_.get());
+    containerType_ = ROW({
         {"bool_val", BOOLEAN()},
         {"tiny_val", TINYINT()},
         {"small_val", SMALLINT()},
@@ -154,46 +184,61 @@ class SpillerTest : public exec::test::RowContainerTestBase {
              MAP(BIGINT(),
                  ROW({{"s2_int", INTEGER()}, {"s2_string", VARCHAR()}})))},
     });
+    if (type_ == Spiller::Type::kHashJoinBuild) {
+      rowType_ = hashJoinTableSpillType(containerType_, joinType_);
+    } else {
+      rowType_ = containerType_;
+    }
     numKeys_ = 6;
     keyChannels_.resize(numKeys_);
     std::iota(std::begin(keyChannels_), std::end(keyChannels_), 0);
     spillIndicesBuffers_.resize(numPartitions_);
     numPartitionInputs_.resize(numPartitions_, 0);
     // Check spiller memory pool properties.
-    ASSERT_EQ(Spiller::pool()->name(), "_sys.spilling");
-    ASSERT_EQ(Spiller::pool()->kind(), memory::MemoryPool::Kind::kLeaf);
-    ASSERT_TRUE(Spiller::pool()->threadSafe());
+    ASSERT_EQ(memory::spillMemoryPool()->name(), "__sys_spilling__");
+    ASSERT_EQ(
+        memory::spillMemoryPool()->kind(), memory::MemoryPool::Kind::kLeaf);
+    ASSERT_TRUE(memory::spillMemoryPool()->threadSafe());
+  }
+
+  void TearDown() override {
+    faultyFs_->setExecutor(nullptr);
   }
 
  protected:
+  SpillPartitionNumSet allPartitionNumSet() const {
+    std::vector<uint32_t> spillPartitionNums(numPartitions_);
+    std::iota(spillPartitionNums.begin(), spillPartitionNums.end(), 0);
+    return SpillPartitionNumSet(
+        spillPartitionNums.begin(), spillPartitionNums.end());
+  }
+
   void testSortedSpill(
-      int32_t spillPct,
       int numDuplicates,
       int32_t outputBatchSize = 0,
       bool ascending = true,
-      bool makeError = false) {
+      bool makeError = false,
+      uint64_t readBufferSize = 1 << 20) {
     SCOPED_TRACE(fmt::format(
-        "spillType: {} spillPct:{} numDuplicates:{} outputBatchSize:{} ascending:{} makeError:{}",
+        "spillType: {} numDuplicates: {} outputBatchSize: {} ascending: {} makeError: {}",
         Spiller::typeName(type_),
-        spillPct,
         numDuplicates,
         outputBatchSize,
         ascending,
         makeError));
     constexpr int32_t kNumRows = 5'000;
-    const auto prevGStats = globalSpillStats();
+    const auto prevGStats = common::globalSpillStats();
 
-    setupSpillData(
-        rowType_, numKeys_, kNumRows, numDuplicates, [&](RowVectorPtr rows) {
-          // Set ordinal so that the sorted order is unambiguous.
-          setSequentialValue(rows, 5);
-        });
+    setupSpillData(numKeys_, kNumRows, numDuplicates, [&](RowVectorPtr rows) {
+      // Set ordinal so that the sorted order is unambiguous.
+      setSequentialValue(rows, 5);
+    });
     sortSpillData(ascending);
 
-    setupSpiller(2'000'000, 0, 0, makeError);
+    setupSpiller(2'000'000, 0, makeError, 0, readBufferSize);
 
     // We spill spillPct% of the data in 10% increments.
-    runSpill(spillPct, 10, makeError);
+    runSpill(makeError);
     if (makeError) {
       return;
     }
@@ -214,60 +259,49 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       ASSERT_NE(readFile.get(), nullptr);
       totalSpilledBytes += readFile->size();
     }
-    if (spillPct == 100 || type_ == Spiller::Type::kAggregateOutput) {
-      ASSERT_TRUE(spiller_->isAnySpilled());
-      ASSERT_TRUE(spiller_->isAllSpilled());
-    }
-
-    Spiller::SpillRows unspilledPartitionRows = spiller_->finishSpill();
-    SpillPartitionNumSet expectedSpillPartitions;
-    if (spillPct == 100 || type_ == Spiller::Type::kAggregateOutput) {
-      ASSERT_TRUE(unspilledPartitionRows.empty());
-      ASSERT_EQ(0, rowContainer_->numRows());
+    ASSERT_TRUE(spiller_->isAnySpilled());
+    ASSERT_TRUE(spiller_->isAllSpilled());
+    ASSERT_FALSE(spiller_->finalized());
+    VELOX_ASSERT_THROW(spiller_->spill(0, nullptr), "Unexpected spiller type");
+    VELOX_ASSERT_THROW(
+        spiller_->setPartitionsSpilled({}), "Unexpected spiller type");
+    SpillPartitionSet spillPartitionSet;
+    spiller_->finishSpill(spillPartitionSet);
+    ASSERT_EQ(spillPartitionSet.size(), numPartitions_);
+    ASSERT_TRUE(spiller_->finalized());
+    ASSERT_EQ(rowContainer_->numRows(), 0);
+    ASSERT_EQ(numPartitions_, spiller_->stats().spilledPartitions);
+    ASSERT_EQ(numPartitions_, spiller_->state().spilledPartitionSet().size());
+    ASSERT_EQ(numSpilledFiles, spiller_->stats().spilledFiles);
 
-      for (int i = 0; i < numPartitions_; ++i) {
-        expectedSpillPartitions.insert(i);
-      }
-      ASSERT_EQ(
-          expectedSpillPartitions, spiller_->state().spilledPartitionSet());
-    } else {
-      ASSERT_GE(numPartitions_, spiller_->stats().spilledPartitions);
-      ASSERT_GE(numPartitions_, spiller_->state().spilledPartitionSet().size());
-      ASSERT_GE(numSpilledFiles, spiller_->stats().spilledFiles);
-    }
     // Assert we can't call any spill function after the spiller has been
     // finalized.
-    VELOX_ASSERT_THROW(
-        spiller_->spill(SpillPartitionNumSet{0}), "Spiller has been finalize");
+    VELOX_ASSERT_THROW(spiller_->spill(), "Spiller has been finalize");
     VELOX_ASSERT_THROW(
         spiller_->spill(0, nullptr), "Spiller has been finalize");
-    VELOX_ASSERT_THROW(spiller_->spill(100, 100), "Spiller has been finalize");
-    VELOX_ASSERT_THROW(
-        spiller_->spill(RowContainerIterator{}), "Spiller has been finalize");
+    VELOX_ASSERT_THROW(spiller_->spill(RowContainerIterator{}), "");
 
-    verifySortedSpillData(outputBatchSize);
+    verifySortedSpillData(spillPartitionSet, outputBatchSize);
 
     stats = spiller_->stats();
     ASSERT_EQ(stats.spilledFiles, spilledFileSet.size());
-    ASSERT_GT(stats.spilledRows, 0);
-    if (spillPct == 100) {
-      ASSERT_EQ(stats.spilledPartitions, expectedSpillPartitions.size());
-    } else {
-      ASSERT_LE(stats.spilledPartitions, numPartitions_);
-    }
+    ASSERT_EQ(stats.spilledPartitions, numPartitions_);
+    ASSERT_EQ(stats.spilledRows, kNumRows);
+
     ASSERT_EQ(stats.spilledBytes, totalSpilledBytes);
-    ASSERT_GT(stats.spillWriteTimeUs, 0);
+    ASSERT_EQ(stats.spillReadBytes, totalSpilledBytes);
+    ASSERT_GT(stats.spillWriteTimeNanos, 0);
     if (type_ == Spiller::Type::kAggregateOutput) {
-      ASSERT_EQ(stats.spillSortTimeUs, 0);
+      ASSERT_EQ(stats.spillSortTimeNanos, 0);
     } else {
-      ASSERT_GT(stats.spillSortTimeUs, 0);
+      ASSERT_GT(stats.spillSortTimeNanos, 0);
     }
-    ASSERT_GT(stats.spillFlushTimeUs, 0);
-    ASSERT_GT(stats.spillFillTimeUs, 0);
-    ASSERT_GT(stats.spillSerializationTimeUs, 0);
-    ASSERT_GT(stats.spillDiskWrites, 0);
+    ASSERT_GT(stats.spillFlushTimeNanos, 0);
+    ASSERT_GT(stats.spillFillTimeNanos, 0);
+    ASSERT_GT(stats.spillSerializationTimeNanos, 0);
+    ASSERT_GT(stats.spillWrites, 0);
 
-    const auto newGStats = globalSpillStats();
+    const auto newGStats = common::globalSpillStats();
     ASSERT_EQ(
         prevGStats.spilledFiles + stats.spilledFiles, newGStats.spilledFiles);
     ASSERT_EQ(
@@ -278,25 +312,36 @@ class SpillerTest : public exec::test::RowContainerTestBase {
     ASSERT_EQ(
         prevGStats.spilledBytes + stats.spilledBytes, newGStats.spilledBytes);
     ASSERT_EQ(
-        prevGStats.spillWriteTimeUs + stats.spillWriteTimeUs,
-        newGStats.spillWriteTimeUs);
+        prevGStats.spillReadBytes + stats.spillReadBytes,
+        newGStats.spillReadBytes);
+    ASSERT_EQ(prevGStats.spillReads + stats.spillReads, newGStats.spillReads);
     ASSERT_EQ(
-        prevGStats.spillSortTimeUs + stats.spillSortTimeUs,
-        newGStats.spillSortTimeUs);
+        prevGStats.spillReadTimeNanos + stats.spillReadTimeNanos,
+        newGStats.spillReadTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillFlushTimeUs + stats.spillFlushTimeUs,
-        newGStats.spillFlushTimeUs)
-        << prevGStats.spillFlushTimeUs << " " << stats.spillFlushTimeUs << " "
-        << newGStats.spillFlushTimeUs;
+        prevGStats.spillDeserializationTimeNanos +
+            stats.spillDeserializationTimeNanos,
+        newGStats.spillDeserializationTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillFillTimeUs + stats.spillFillTimeUs,
-        newGStats.spillFillTimeUs);
+        prevGStats.spillWriteTimeNanos + stats.spillWriteTimeNanos,
+        newGStats.spillWriteTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillSerializationTimeUs + stats.spillSerializationTimeUs,
-        newGStats.spillSerializationTimeUs);
+        prevGStats.spillSortTimeNanos + stats.spillSortTimeNanos,
+        newGStats.spillSortTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillDiskWrites + stats.spillDiskWrites,
-        newGStats.spillDiskWrites);
+        prevGStats.spillFlushTimeNanos + stats.spillFlushTimeNanos,
+        newGStats.spillFlushTimeNanos)
+        << prevGStats.spillFlushTimeNanos << " " << stats.spillFlushTimeNanos
+        << " " << newGStats.spillFlushTimeNanos;
+    ASSERT_EQ(
+        prevGStats.spillFillTimeNanos + stats.spillFillTimeNanos,
+        newGStats.spillFillTimeNanos);
+    ASSERT_EQ(
+        prevGStats.spillSerializationTimeNanos +
+            stats.spillSerializationTimeNanos,
+        newGStats.spillSerializationTimeNanos);
+    ASSERT_EQ(
+        prevGStats.spillWrites + stats.spillWrites, newGStats.spillWrites);
 
     spiller_.reset();
     // Verify the spilled files are still there after spiller destruction.
@@ -308,7 +353,6 @@ class SpillerTest : public exec::test::RowContainerTestBase {
   // 'numDuplicates' specifies the number of duplicate rows generated for each
   // distinct sorting key in test.
   void setupSpillData(
-      RowTypePtr rowType,
       int32_t numKeys,
       int32_t numRows,
       int32_t numDuplicates,
@@ -325,8 +369,8 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       VELOX_CHECK_EQ(totalCount, numRows);
     }
 
-    rowVector_ = BaseVector::create<RowVector>(rowType, numRows, pool_.get());
-    const auto& childTypes = rowType->children();
+    rowVector_ = BaseVector::create<RowVector>(rowType_, numRows, pool_.get());
+    const auto& childTypes = containerType_->children();
     std::vector<TypePtr> keys(childTypes.begin(), childTypes.begin() + numKeys);
     std::vector<TypePtr> dependents;
     if (numKeys < childTypes.size()) {
@@ -351,7 +395,7 @@ class SpillerTest : public exec::test::RowContainerTestBase {
 
     int numFilledRows = 0;
     do {
-      RowVectorPtr batch = makeDataset(rowType, numRows, customizeData);
+      RowVectorPtr batch = makeDataset(rowType_, numRows, customizeData);
       if (!numRowsPerPartition.empty()) {
         for (int index = 0; index < numRows; ++index) {
           for (int i = 0; i < keys.size(); ++i) {
@@ -383,15 +427,28 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       rows_[i] = rowContainer_->newRow();
     }
 
-    for (auto column = 0; column < rowVector_->childrenSize(); ++column) {
+    for (auto column = 0; column < containerType_->size(); ++column) {
       DecodedVector decoded(*rowVector_->childAt(column), allRows);
       for (auto index = 0; index < numRows; ++index) {
         rowContainer_->store(decoded, index, rows_[index], column);
       }
     }
+
+    if (spillProbedFlag_) {
+      auto* probedFlagVector =
+          rowVector_->childAt(containerType_->size())->asFlatVector<bool>();
+      // The probed flag vector used by hash build spilling has no nulls so
+      // clear them in test.
+      probedFlagVector->clearAllNulls();
+      for (auto index = 0; index < numRows; ++index) {
+        if (probedFlagVector->valueAt(index)) {
+          rowContainer_->setProbedFlag(&rows_[index], 1);
+        }
+      }
+    }
   }
 
-  void setupSpillContainer(RowTypePtr rowType, int32_t numKeys) {
+  void setupSpillContainer(const RowTypePtr& rowType, int32_t numKeys) {
     const auto& childTypes = rowType->children();
     std::vector<TypePtr> keys(childTypes.begin(), childTypes.begin() + numKeys);
     std::vector<TypePtr> dependents;
@@ -403,7 +460,7 @@ class SpillerTest : public exec::test::RowContainerTestBase {
     rowType_ = rowType;
   }
 
-  void writeSpillData(std::vector<RowVectorPtr> batches) {
+  void writeSpillData(const std::vector<RowVectorPtr>& batches) {
     vector_size_t numRows = 0;
     for (const auto& batch : batches) {
       numRows += batch->size();
@@ -457,7 +514,8 @@ class SpillerTest : public exec::test::RowContainerTestBase {
     // NOTE: for aggregation output type, we expect the merge read to produce
     // the output rows in the same order of the row insertion. So do need the
     // sort for testing.
-    if (type_ == Spiller::Type::kAggregateOutput) {
+    if (type_ == Spiller::Type::kAggregateOutput ||
+        type_ == Spiller::Type::kOrderByOutput) {
       return;
     }
     for (auto& partition : partitions_) {
@@ -474,117 +532,119 @@ class SpillerTest : public exec::test::RowContainerTestBase {
   void setupSpiller(
       uint64_t targetFileSize,
       uint64_t writeBufferSize,
-      uint64_t minSpillRunSize,
-      bool makeError) {
+      bool makeError,
+      uint64_t maxSpillRunRows = 0,
+      uint64_t readBufferSize = 1 << 20) {
+    static const std::string kBadSpillDirPath = "/bad/path";
+    common::GetSpillDirectoryPathCB badSpillDirCb = [&]() -> std::string_view {
+      return kBadSpillDirPath;
+    };
+    common::GetSpillDirectoryPathCB tempSpillDirCb = [&]() -> std::string_view {
+      return tempDirPath_->getPath();
+    };
     stats_.clear();
+    spillStats_ = folly::Synchronized<common::SpillStats>();
+
+    spillConfig_.getSpillDirPathCb = makeError ? badSpillDirCb : tempSpillDirCb;
+    spillConfig_.updateAndCheckSpillLimitCb = [&](uint64_t) {};
+    spillConfig_.fileNamePrefix = "prefix";
+    spillConfig_.writeBufferSize = writeBufferSize;
+    spillConfig_.readBufferSize = readBufferSize;
+    spillConfig_.executor = executor();
+    spillConfig_.compressionKind = compressionKind_;
+    spillConfig_.maxSpillRunRows = maxSpillRunRows;
+    spillConfig_.maxFileSize = targetFileSize;
+    spillConfig_.fileCreateConfig = {};
 
     if (type_ == Spiller::Type::kHashJoinProbe) {
       // kHashJoinProbe doesn't have associated row container.
+      spiller_ = std::make_unique<Spiller>(
+          type_, rowType_, hashBits_, &spillConfig_, &spillStats_);
+    } else if (type_ == Spiller::Type::kAggregateInput) {
       spiller_ = std::make_unique<Spiller>(
           type_,
+          rowContainer_.get(),
           rowType_,
           hashBits_,
-          makeError ? "/bad/path" : tempDirPath_->path,
-          targetFileSize,
-          writeBufferSize,
-          minSpillRunSize,
-          compressionKind_,
-          pool_.get(),
-          executor());
-    } else if (type_ == Spiller::Type::kOrderBy) {
-      // We spill 'data' in one partition in type of kOrderBy, otherwise in 4
-      // partitions.
+          rowContainer_->keyTypes().size(),
+          compareFlags_,
+          &spillConfig_,
+          &spillStats_);
+    } else if (type_ == Spiller::Type::kOrderByInput) {
+      // We spill 'data' in one partition in type of kOrderBy.
       spiller_ = std::make_unique<Spiller>(
           type_,
           rowContainer_.get(),
-          [&](folly::Range<char**> rows) { rowContainer_->eraseRows(rows); },
           rowType_,
           rowContainer_->keyTypes().size(),
           compareFlags_,
-          makeError ? "/bad/path" : tempDirPath_->path,
-          targetFileSize,
-          writeBufferSize,
-          minSpillRunSize,
-          compressionKind_,
-          pool_.get(),
-          executor());
-    } else if (type_ == Spiller::Type::kAggregateOutput) {
+          &spillConfig_,
+          &spillStats_);
+    } else if (
+        type_ == Spiller::Type::kAggregateOutput ||
+        type_ == Spiller::Type::kOrderByOutput) {
+      spiller_ = std::make_unique<Spiller>(
+          type_, rowContainer_.get(), rowType_, &spillConfig_, &spillStats_);
+    } else if (type_ == Spiller::Type::kRowNumber) {
       spiller_ = std::make_unique<Spiller>(
           type_,
           rowContainer_.get(),
-          [&](folly::Range<char**> rows) { rowContainer_->eraseRows(rows); },
           rowType_,
-          makeError ? "/bad/path" : tempDirPath_->path,
-          writeBufferSize,
-          compressionKind_,
-          pool_.get(),
-          executor());
+          hashBits_,
+          &spillConfig_,
+          &spillStats_);
     } else {
+      VELOX_CHECK_EQ(type_, Spiller::Type::kHashJoinBuild);
       spiller_ = std::make_unique<Spiller>(
           type_,
+          joinType_,
           rowContainer_.get(),
-          [&](folly::Range<char**> rows) { rowContainer_->eraseRows(rows); },
           rowType_,
           hashBits_,
-          rowContainer_->keyTypes().size(),
-          compareFlags_,
-          makeError ? "/bad/path" : tempDirPath_->path,
-          targetFileSize,
-          writeBufferSize,
-          minSpillRunSize,
-          compressionKind_,
-          pool_.get(),
-          executor());
-    }
-    if (type_ == Spiller::Type::kOrderBy) {
-      ASSERT_EQ(spiller_->state().maxPartitions(), 1);
-    } else {
-      ASSERT_EQ(spiller_->state().maxPartitions(), numPartitions_);
+          &spillConfig_,
+          &spillStats_);
     }
+    ASSERT_EQ(spiller_->state().maxPartitions(), numPartitions_);
     ASSERT_FALSE(spiller_->isAllSpilled());
     ASSERT_FALSE(spiller_->isAnySpilled());
     ASSERT_EQ(spiller_->hashBits(), hashBits_);
   }
 
-  void runSpill(int32_t spillPct, int32_t incPct, bool expectedError) {
-    if (type_ != Spiller::Type::kAggregateOutput) {
-      // We spill spillPct% of the data in 10% increments.
-      auto initialBytes = rowContainer_->allocatedBytes();
-      auto initialRows = rowContainer_->numRows();
-      for (int32_t pct = incPct; pct <= spillPct; pct += incPct) {
-        try {
-          spiller_->spill(
-              initialRows - (initialRows * pct / 100),
-              initialBytes - (initialBytes * pct / 100));
-          EXPECT_FALSE(expectedError);
-        } catch (const std::exception& e) {
-          if (!expectedError) {
-            throw;
-          }
-          return;
-        }
+  void runSpill(bool expectedError) {
+    try {
+      if (type_ != Spiller::Type::kAggregateOutput) {
+        spiller_->spill();
+      } else {
+        RowContainerIterator iter;
+        spiller_->spill(iter);
       }
-    } else {
-      RowContainerIterator iter;
-      spiller_->spill(iter);
+      rowContainer_->clear();
+      ASSERT_FALSE(expectedError);
+    } catch (const std::exception&) {
+      ASSERT_TRUE(expectedError);
     }
   }
 
-  void verifySortedSpillData(int32_t outputBatchSize = 0) {
-    // We read back the spilled and not spilled data in each of the
-    // partitions. We check that the data comes back in key order.
-    for (auto partitionIndex = 0; partitionIndex < numPartitions_;
-         ++partitionIndex) {
-      if (!spiller_->isSpilled(partitionIndex)) {
-        continue;
-      }
+  void verifySortedSpillData(
+      SpillPartitionSet& spillPartitionSet,
+      int32_t outputBatchSize = 0) {
+    for (auto& spillPartitionEntry : spillPartitionSet) {
+      ASSERT_TRUE(
+          spiller_->isSpilled(spillPartitionEntry.first.partitionNumber()));
+      const auto partition = spillPartitionEntry.first.partitionNumber();
+      auto* spillPartition = spillPartitionEntry.second.get();
       // We make a merge reader that merges the spill files and the rows that
       // are still in the RowContainer.
-      auto merge = spiller_->startMerge(partitionIndex);
+      auto merge = spillPartition->createOrderedReader(
+          spillConfig_.readBufferSize, pool(), &spillStats_);
+      ASSERT_TRUE(merge != nullptr);
+      ASSERT_TRUE(
+          spillPartition->createOrderedReader(
+              spillConfig_.readBufferSize, pool(), &spillStats_) == nullptr);
 
       // We read the spilled data back and check that it matches the sorted
       // order of the partition.
-      auto& indices = partitions_[partitionIndex];
+      auto& indices = partitions_[partition];
       if (outputBatchSize == 0) {
         for (auto i = 0; i < indices.size(); ++i) {
           auto stream = merge->next();
@@ -707,13 +767,17 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       int numSpillers,
       int numBatchRows,
       int numAppendBatches,
-      int targetFileSize) {
+      int targetFileSize,
+      uint64_t maxSpillRunRows,
+      uint64_t readBufferSize = 1 << 20) {
     ASSERT_TRUE(
         type_ == Spiller::Type::kHashJoinBuild ||
-        type_ == Spiller::Type::kHashJoinProbe);
+        type_ == Spiller::Type::kHashJoinProbe ||
+        type_ == Spiller::Type::kRowNumber);
 
-    const int numSpillPartitions =
-        1 + folly::Random().rand32() % numPartitions_;
+    const int numSpillPartitions = type_ != Spiller::Type::kHashJoinProbe
+        ? numPartitions_
+        : 1 + folly::Random().rand32() % numPartitions_;
     SpillPartitionNumSet spillPartitionNumSet;
     while (spillPartitionNumSet.size() < numSpillPartitions) {
       spillPartitionNumSet.insert(folly::Random().rand32() % numPartitions_);
@@ -735,32 +799,30 @@ class SpillerTest : public exec::test::RowContainerTestBase {
     // them by partition.
     std::vector<std::unique_ptr<Spiller>> spillers;
     for (int iter = 0; iter < numSpillers; ++iter) {
-      const auto prevGStats = globalSpillStats();
+      const auto prevGStats = common::globalSpillStats();
       setupSpillData(
-          rowType_,
           numKeys_,
-          type_ == Spiller::Type::kHashJoinBuild ? numBatchRows * 10 : 0,
+          type_ != Spiller::Type::kHashJoinProbe ? numBatchRows * 10 : 0,
           1,
           nullptr,
           {});
-      setupSpiller(targetFileSize, 0, 0, false);
+      setupSpiller(targetFileSize, 0, false, maxSpillRunRows, readBufferSize);
       // Can't append without marking a partition as spilling.
       VELOX_ASSERT_THROW(spiller_->spill(0, rowVector_), "");
-      // Can't create sorted stream reader from non-sorted spiller.
-      VELOX_ASSERT_THROW(spiller_->startMerge(0), "");
 
       splitByPartition(rowVector_, spillHashFunction, inputsByPartition);
-      std::vector<Spiller::SpillableStats> statsList;
       if (type_ == Spiller::Type::kHashJoinProbe) {
         spiller_->setPartitionsSpilled(spillPartitionNumSet);
 #ifndef NDEBUG
         VELOX_ASSERT_THROW(
             spiller_->setPartitionsSpilled(spillPartitionNumSet), "");
 #endif
-        VELOX_ASSERT_THROW(spiller_->fillSpillRuns(statsList), "");
       } else {
-        spiller_->fillSpillRuns(statsList);
-        spiller_->spill(spillPartitionNumSet);
+        VELOX_ASSERT_THROW(
+            spiller_->setPartitionsSpilled(spillPartitionNumSet), "");
+        spiller_->spill();
+        rowContainer_->clear();
+        ASSERT_TRUE(spiller_->isAllSpilled());
       }
       // Spill data.
       for (int i = 0; i < numAppendBatches; ++i) {
@@ -769,22 +831,15 @@ class SpillerTest : public exec::test::RowContainerTestBase {
         for (const auto& partition : spillPartitionNumSet) {
           spiller_->spill(partition, inputsByPartition[partition].back());
         }
-        if (type_ == Spiller::Type::kHashJoinBuild) {
-          statsList.clear();
-          spiller_->fillSpillRuns(statsList);
-          for (int partition = 0; partition < numPartitions_; ++partition) {
-            if (spillPartitionNumSet.count(partition) != 0) {
-              ASSERT_EQ(statsList[partition].numBytes, 0);
-              ASSERT_EQ(statsList[partition].numRows, 0);
-            }
-          }
-        } else {
-          VELOX_ASSERT_THROW(spiller_->fillSpillRuns(statsList), "");
-        }
       }
-      // Assert that non-sorted spiller type doesn't support incremental
+      // Assert that hash probe type of spiller type doesn't support incremental
       // spilling.
-      VELOX_ASSERT_THROW(spiller_->spill(100, 100), "");
+      if (type_ == Spiller::Type::kHashJoinProbe) {
+        VELOX_ASSERT_THROW(spiller_->spill(), "");
+      } else {
+        spiller_->spill();
+        ASSERT_TRUE(spiller_->isAllSpilled());
+      }
 
       const auto stats = spiller_->stats();
       ASSERT_GE(stats.spilledFiles, 0);
@@ -792,35 +847,36 @@ class SpillerTest : public exec::test::RowContainerTestBase {
         if (numAppendBatches == 0) {
           ASSERT_EQ(stats.spilledRows, 0);
           ASSERT_EQ(stats.spilledBytes, 0);
-          ASSERT_EQ(stats.spillWriteTimeUs, 0);
-          ASSERT_EQ(stats.spillFlushTimeUs, 0);
-          ASSERT_EQ(stats.spillSerializationTimeUs, 0);
-          ASSERT_EQ(stats.spillDiskWrites, 0);
+          ASSERT_EQ(stats.spillWriteTimeNanos, 0);
+          ASSERT_EQ(stats.spillFlushTimeNanos, 0);
+          ASSERT_EQ(stats.spillSerializationTimeNanos, 0);
+          ASSERT_EQ(stats.spillWrites, 0);
         } else {
           ASSERT_GT(stats.spilledRows, 0);
           ASSERT_GT(stats.spilledBytes, 0);
-          ASSERT_GT(stats.spillWriteTimeUs, 0);
-          ASSERT_GT(stats.spillFlushTimeUs, 0);
-          ASSERT_GT(stats.spillSerializationTimeUs, 0);
-          ASSERT_GT(stats.spillDiskWrites, 0);
+          ASSERT_GT(stats.spillWriteTimeNanos, 0);
+          ASSERT_GT(stats.spillFlushTimeNanos, 0);
+          ASSERT_GT(stats.spillSerializationTimeNanos, 0);
+          ASSERT_GT(stats.spillWrites, 0);
         }
       } else {
         ASSERT_GT(stats.spilledRows, 0);
         ASSERT_GT(stats.spilledBytes, 0);
-        ASSERT_GT(stats.spillWriteTimeUs, 0);
-        ASSERT_GT(stats.spillFlushTimeUs, 0);
-        ASSERT_GT(stats.spillSerializationTimeUs, 0);
-        ASSERT_GT(stats.spillDiskWrites, 0);
+        ASSERT_GT(stats.spillWriteTimeNanos, 0);
+        ASSERT_GT(stats.spillFlushTimeNanos, 0);
+        ASSERT_GT(stats.spillSerializationTimeNanos, 0);
+        ASSERT_GT(stats.spillWrites, 0);
       }
       ASSERT_GT(stats.spilledPartitions, 0);
-      ASSERT_EQ(stats.spillSortTimeUs, 0);
-      if (type_ == Spiller::Type::kHashJoinBuild) {
-        ASSERT_GT(stats.spillFillTimeUs, 0);
+      ASSERT_EQ(stats.spillSortTimeNanos, 0);
+      if (type_ == Spiller::Type::kHashJoinBuild ||
+          type_ == Spiller::Type::kRowNumber) {
+        ASSERT_GT(stats.spillFillTimeNanos, 0);
       } else {
-        ASSERT_EQ(stats.spillFillTimeUs, 0);
+        ASSERT_EQ(stats.spillFillTimeNanos, 0);
       }
 
-      const auto newGStats = globalSpillStats();
+      const auto newGStats = common::globalSpillStats();
       ASSERT_EQ(
           prevGStats.spilledFiles + stats.spilledFiles, newGStats.spilledFiles);
       ASSERT_EQ(
@@ -831,25 +887,25 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       ASSERT_EQ(
           prevGStats.spilledBytes + stats.spilledBytes, newGStats.spilledBytes);
       ASSERT_EQ(
-          prevGStats.spillWriteTimeUs + stats.spillWriteTimeUs,
-          newGStats.spillWriteTimeUs);
+          prevGStats.spillWriteTimeNanos + stats.spillWriteTimeNanos,
+          newGStats.spillWriteTimeNanos);
       ASSERT_EQ(
-          prevGStats.spillSortTimeUs + stats.spillSortTimeUs,
-          newGStats.spillSortTimeUs);
+          prevGStats.spillSortTimeNanos + stats.spillSortTimeNanos,
+          newGStats.spillSortTimeNanos);
       ASSERT_EQ(
-          prevGStats.spillFlushTimeUs + stats.spillFlushTimeUs,
-          newGStats.spillFlushTimeUs)
-          << prevGStats.spillFlushTimeUs << " " << stats.spillFlushTimeUs << " "
-          << newGStats.spillFlushTimeUs;
+          prevGStats.spillFlushTimeNanos + stats.spillFlushTimeNanos,
+          newGStats.spillFlushTimeNanos)
+          << prevGStats.spillFlushTimeNanos << " " << stats.spillFlushTimeNanos
+          << " " << newGStats.spillFlushTimeNanos;
       ASSERT_EQ(
-          prevGStats.spillFillTimeUs + stats.spillFillTimeUs,
-          newGStats.spillFillTimeUs);
+          prevGStats.spillFillTimeNanos + stats.spillFillTimeNanos,
+          newGStats.spillFillTimeNanos);
       ASSERT_EQ(
-          prevGStats.spillSerializationTimeUs + stats.spillSerializationTimeUs,
-          newGStats.spillSerializationTimeUs);
+          prevGStats.spillSerializationTimeNanos +
+              stats.spillSerializationTimeNanos,
+          newGStats.spillSerializationTimeNanos);
       ASSERT_EQ(
-          prevGStats.spillDiskWrites + stats.spillDiskWrites,
-          newGStats.spillDiskWrites);
+          prevGStats.spillWrites + stats.spillWrites, newGStats.spillWrites);
 
       spillers.push_back(std::move(spiller_));
     }
@@ -857,8 +913,11 @@ class SpillerTest : public exec::test::RowContainerTestBase {
     // Read back data from all the spilled partitions and verify.
     verifyNonSortedSpillData(
         std::move(spillers), spillPartitionNumSet, inputsByPartition);
+
     // Spilled file stats should be updated after finalizing spiller.
-    ASSERT_GT(globalSpillStats().spilledFiles, 0);
+    if (numAppendBatches > 0) {
+      ASSERT_GT(common::globalSpillStats().spilledFiles, 0);
+    }
   }
 
   void verifyNonSortedSpillData(
@@ -867,13 +926,15 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       const std::vector<std::vector<RowVectorPtr>>& inputsByPartition) {
     ASSERT_TRUE(
         type_ == Spiller::Type::kHashJoinBuild ||
+        type_ == Spiller::Type::kRowNumber ||
         type_ == Spiller::Type::kHashJoinProbe);
 
     SpillPartitionSet spillPartitionSet;
     for (auto& spiller : spillers) {
       spiller->finishSpill(spillPartitionSet);
-      ASSERT_ANY_THROW(spiller->spill(0, nullptr));
-      ASSERT_ANY_THROW(spiller->spill(SpillPartitionNumSet{0}));
+      VELOX_ASSERT_THROW(
+          spiller->spill(0, nullptr), "Spiller has been finalized");
+      VELOX_ASSERT_THROW(spiller->spill(), "Spiller has been finalized");
     }
     ASSERT_EQ(spillPartitionSet.size(), spillPartitionNumSet.size());
 
@@ -881,7 +942,8 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       const int partition = spillPartitionEntry.first.partitionNumber();
       ASSERT_EQ(
           hashBits_.begin(), spillPartitionEntry.first.partitionBitOffset());
-      auto reader = spillPartitionEntry.second->createReader();
+      auto reader = spillPartitionEntry.second->createUnorderedReader(
+          spillConfig_.readBufferSize, pool(), &spillStats_);
       if (type_ == Spiller::Type::kHashJoinProbe) {
         // For hash probe type, we append each input vector as one batch in
         // spill file so that we can do one-to-one comparison.
@@ -936,23 +998,23 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       const std::vector<std::vector<RowVectorPtr>>& inputsByPartition) {
     ASSERT_TRUE(
         type_ == Spiller::Type::kHashJoinBuild ||
+        type_ == Spiller::Type::kRowNumber ||
         type_ == Spiller::Type::kHashJoinProbe);
 
     SpillPartitionSet spillPartitionSet;
     spiller_->finishSpill(spillPartitionSet);
     VELOX_ASSERT_THROW(
         spiller_->spill(0, nullptr), "Spiller has been finalized");
-    VELOX_ASSERT_THROW(
-        spiller_->spill(SpillPartitionNumSet{0}), "Spiller has been finalized");
-    VELOX_ASSERT_THROW(
-        spiller_->spill(RowContainerIterator{}), "Spiller has been finalized");
+    VELOX_ASSERT_THROW(spiller_->spill(), "Spiller has been finalized");
+    VELOX_ASSERT_THROW(spiller_->spill(RowContainerIterator{}), "");
     ASSERT_EQ(spillPartitionSet.size(), spillPartitionNumSet.size());
 
     for (auto& spillPartitionEntry : spillPartitionSet) {
       const int partition = spillPartitionEntry.first.partitionNumber();
       ASSERT_EQ(
           hashBits_.begin(), spillPartitionEntry.first.partitionBitOffset());
-      auto reader = spillPartitionEntry.second->createReader();
+      auto reader = spillPartitionEntry.second->createUnorderedReader(
+          spillConfig_.readBufferSize, pool(), &spillStats_);
       if (type_ == Spiller::Type::kHashJoinProbe) {
         // For hash probe type, we append each input vector as one batch in
         // spill file so that we can do one-to-one comparison.
@@ -1027,6 +1089,8 @@ class SpillerTest : public exec::test::RowContainerTestBase {
   const Spiller::Type type_;
   const int32_t executorPoolSize_;
   const common::CompressionKind compressionKind_;
+  const core::JoinType joinType_;
+  const bool spillProbedFlag_;
   const HashBitRange hashBits_;
   const int32_t numPartitions_;
   std::unordered_map<std::string, RuntimeMetric> stats_;
@@ -1035,6 +1099,9 @@ class SpillerTest : public exec::test::RowContainerTestBase {
   std::unique_ptr<folly::IOThreadPoolExecutor> executor_;
   std::shared_ptr<TempDirectoryPath> tempDirPath_;
   std::shared_ptr<FileSystem> fs_;
+  std::unique_ptr<folly::CPUThreadPoolExecutor> fsExecutor_;
+  tests::utils::FaultyFileSystem* faultyFs_;
+  RowTypePtr containerType_;
   RowTypePtr rowType_;
   int32_t numKeys_;
   std::vector<column_index_t> keyChannels_;
@@ -1047,378 +1114,149 @@ class SpillerTest : public exec::test::RowContainerTestBase {
   std::vector<std::vector<int32_t>> partitions_;
   std::vector<CompareFlags> compareFlags_;
   std::unique_ptr<Spiller> spiller_;
+  common::SpillConfig spillConfig_;
+  folly::Synchronized<common::SpillStats> spillStats_;
+};
+
+struct AllTypesTestParam {
+  TestParam param;
+  uint64_t maxSpillRunRows;
 };
 
 class AllTypes : public SpillerTest,
-                 public testing::WithParamInterface<TestParam> {
+                 public testing::WithParamInterface<AllTypesTestParam> {
  public:
-  AllTypes() : SpillerTest(GetParam()) {}
+  AllTypes()
+      : SpillerTest(GetParam().param),
+        maxSpillRunRows_(GetParam().maxSpillRunRows) {}
+
+  static std::vector<AllTypesTestParam> getTestParams() {
+    auto testParams = TestParamsBuilder().getTestParams();
+
+    std::vector<AllTypesTestParam> allTypesTestParams;
+    for (const auto& testParam : testParams) {
+      for (const auto& maxSpillRunRows :
+           std::vector<uint64_t>{0, 101, 1'000'000}) {
+        allTypesTestParams.push_back({testParam, maxSpillRunRows});
+      }
+    }
 
-  static std::vector<TestParam> getTestParams() {
-    return TestParamsBuilder().getTestParams();
+    return allTypesTestParams;
   }
+
+ protected:
+  uint64_t maxSpillRunRows_;
 };
 
-class NoHashJoin : public SpillerTest,
-                   public testing::WithParamInterface<TestParam> {
- public:
-  NoHashJoin() : SpillerTest(GetParam()) {}
+TEST_P(AllTypes, nonSortedSpillFunctions) {
+  if (type_ == Spiller::Type::kOrderByInput ||
+      type_ == Spiller::Type::kOrderByOutput ||
+      type_ == Spiller::Type::kAggregateInput ||
+      type_ == Spiller::Type::kAggregateOutput) {
+    setupSpillData(numKeys_, 5'000, 1, nullptr, {});
+    sortSpillData();
+    setupSpiller(100'000, 0, false, maxSpillRunRows_);
+    {
+      RowVectorPtr dummyVector;
+      VELOX_ASSERT_THROW(
+          spiller_->spill(0, dummyVector), "Unexpected spiller type");
+    }
 
-  static std::vector<TestParam> getTestParams() {
-    return TestParamsBuilder{
-        .typesToExclude =
-            {Spiller::Type::kHashJoinProbe, Spiller::Type::kHashJoinBuild}}
-        .getTestParams();
+    if (type_ == Spiller::Type::kOrderByOutput) {
+      RowContainerIterator rowIter;
+      std::vector<char*> rows(5'000);
+      int numListedRows{0};
+      numListedRows = rowContainer_->listRows(&rowIter, 5000, rows.data());
+      ASSERT_EQ(numListedRows, 5000);
+      spiller_->spill(rows);
+    } else {
+      spiller_->spill();
+    }
+
+    ASSERT_FALSE(spiller_->finalized());
+    SpillPartitionSet spillPartitionSet;
+    spiller_->finishSpill(spillPartitionSet);
+    ASSERT_TRUE(spiller_->finalized());
+    ASSERT_EQ(spillPartitionSet.size(), numPartitions_);
+    verifySortedSpillData(spillPartitionSet);
+    return;
   }
-};
+  testNonSortedSpill(2, 5'000, 3, 1, maxSpillRunRows_);
+  testNonSortedSpill(2, 5'000, 3, 1'000'000'000, maxSpillRunRows_);
+  // Empty case.
+  testNonSortedSpill(1, 5'000, 0, 1, maxSpillRunRows_);
+}
+
+TEST_P(AllTypes, readaheadTest) {
+  if (type_ == Spiller::Type::kOrderByOutput ||
+      type_ == Spiller::Type::kAggregateOutput) {
+    return;
+  }
+  if (type_ == Spiller::Type::kOrderByInput ||
+      type_ == Spiller::Type::kAggregateInput) {
+    testSortedSpill(10, 10, false, false, 512);
+    return;
+  }
+  testNonSortedSpill(1, 5'000, 0, 1'000'000'000, maxSpillRunRows_, 512);
+}
 
-class AggregationInputOnly : public SpillerTest,
-                             public testing::WithParamInterface<TestParam> {
+class NoHashJoin : public SpillerTest,
+                   public testing::WithParamInterface<TestParam> {
  public:
-  AggregationInputOnly() : SpillerTest(GetParam()) {}
+  NoHashJoin() : SpillerTest(GetParam()) {}
 
   static std::vector<TestParam> getTestParams() {
     return TestParamsBuilder{
         .typesToExclude =
             {Spiller::Type::kHashJoinProbe,
              Spiller::Type::kHashJoinBuild,
-             Spiller::Type::kOrderBy,
-             Spiller::Type::kAggregateOutput}}
+             Spiller::Type::kRowNumber,
+             Spiller::Type::kOrderByOutput}}
         .getTestParams();
   }
 };
 
-TEST_P(NoHashJoin, spilFew) {
+TEST_P(NoHashJoin, spillFew) {
   // Test with distinct sort keys.
   testSortedSpill(10, 1);
-  testSortedSpill(10, 1, 0, false);
-  testSortedSpill(10, 1, 32);
-  testSortedSpill(10, 1, 32, false);
+  testSortedSpill(10, 1, false, false);
+  testSortedSpill(10, 1, true);
+  testSortedSpill(10, 1, true, false);
   // Test with duplicate sort keys.
   testSortedSpill(10, 10);
-  testSortedSpill(10, 10, 0, false);
-  testSortedSpill(10, 10, 32);
-  testSortedSpill(10, 10, 32, false);
+  testSortedSpill(10, 10, false, false);
+  testSortedSpill(10, 10, true);
+  testSortedSpill(10, 10, true, false);
 }
 
-TEST_P(NoHashJoin, spilMost) {
+TEST_P(NoHashJoin, spillMost) {
   // Test with distinct sort keys.
   testSortedSpill(60, 1);
-  testSortedSpill(60, 1, 0, false);
-  testSortedSpill(60, 1, 32);
-  testSortedSpill(60, 1, 32, false);
+  testSortedSpill(60, 1, false, false);
+  testSortedSpill(60, 1, true);
+  testSortedSpill(60, 1, true, false);
   // Test with duplicate sort keys.
   testSortedSpill(60, 10);
-  testSortedSpill(60, 10, 0, false);
-  testSortedSpill(60, 10, 32);
-  testSortedSpill(60, 10, 32, false);
+  testSortedSpill(60, 10, false, false);
+  testSortedSpill(60, 10, true);
+  testSortedSpill(60, 10, true, false);
 }
 
 TEST_P(NoHashJoin, spillAll) {
   // Test with distinct sort keys.
   testSortedSpill(100, 1);
-  testSortedSpill(100, 1, 0, false);
-  testSortedSpill(100, 1, 32);
-  testSortedSpill(100, 1, 32, false);
+  testSortedSpill(100, 1, false, false);
+  testSortedSpill(100, 1, true);
+  testSortedSpill(100, 1, true, false);
   // Test with duplicate sort keys.
   testSortedSpill(100, 10);
-  testSortedSpill(100, 10, 0, false);
-  testSortedSpill(100, 10, 32);
-  testSortedSpill(100, 10, 32, false);
+  testSortedSpill(100, 10, false, false);
+  testSortedSpill(100, 10, true);
+  testSortedSpill(100, 10, true, false);
 }
 
 TEST_P(NoHashJoin, error) {
-  testSortedSpill(100, 1, 0, true);
-}
-
-TEST_P(AggregationInputOnly, spillWithEmptyPartitions) {
-  // kOrderBy type which has only one partition which is not relevant for this
-  // test.
-  rowType_ = ROW({{"long_val", BIGINT()}, {"string_val", VARCHAR()}});
-  struct {
-    std::vector<int> rowsPerPartition;
-    int numDuplicates;
-
-    std::string debugString() const {
-      return fmt::format(
-          "rowsPerPartition: [{}], numDuplicates: {}",
-          folly::join(':', rowsPerPartition),
-          numDuplicates);
-    }
-  } testSettings[] = {// Test with distinct sort keys.
-                      {{5000, 0, 0, 0}, 1},
-                      {{5'000, 5'000, 0, 1'000}, 1},
-                      {{5'000, 0, 5'000, 1'000}, 1},
-                      {{5'000, 1'000, 5'000, 0}, 1},
-                      // Test with duplicate sort keys.
-                      {{5000, 0, 0, 0}, 10},
-                      {{5'000, 5'000, 0, 1'000}, 10},
-                      {{5'000, 0, 5'000, 1'000}, 10},
-                      {{5'000, 1'000, 5'000, 0}, 10}};
-  for (auto testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-    reset();
-    int32_t numRows = 0;
-    for (const auto partitionRows : testData.rowsPerPartition) {
-      numRows += partitionRows;
-    }
-    int64_t outputIndex = 0;
-    setupSpillData(
-        rowType_,
-        1,
-        numRows,
-        testData.numDuplicates,
-        [&](RowVectorPtr rowVector) {
-          // Set ordinal so that the sorted order is unambiguous.
-          setSequentialValue(rowVector, 0, outputIndex);
-          outputIndex += rowVector->size();
-        },
-        testData.rowsPerPartition);
-    sortSpillData();
-    // Setup a large target file size and spill only once to ensure the number
-    // of spilled files matches the number of spilled partitions.
-    setupSpiller(2'000'000'000, 0, 0, false);
-    // We spill spillPct% of the data all at once.
-    runSpill(100, 100, false);
-    ASSERT_TRUE(spiller_->isAnySpilled());
-    ASSERT_FALSE(spiller_->isAllSpilled());
-
-    uint64_t numNonEmptyPartitions = 0;
-    for (auto partition = 0; partition < numPartitions_; ++partition) {
-      if (testData.rowsPerPartition[partition] != 0) {
-        ASSERT_TRUE(spiller_->state().isPartitionSpilled(partition));
-        ++numNonEmptyPartitions;
-      } else {
-        ASSERT_FALSE(spiller_->state().isPartitionSpilled(partition))
-            << partition;
-      }
-    }
-    const auto stats = spiller_->stats();
-    ASSERT_EQ(stats.spilledFiles, numNonEmptyPartitions);
-    ASSERT_EQ(stats.spilledRows, numRows);
-    ASSERT_EQ(stats.spilledPartitions, numNonEmptyPartitions);
-    ASSERT_GT(stats.spilledBytes, 0);
-    ASSERT_GT(stats.spillWriteTimeUs, 0);
-    ASSERT_GT(stats.spillSortTimeUs, 0);
-    ASSERT_GT(stats.spillFlushTimeUs, 0);
-    ASSERT_GT(stats.spillFillTimeUs, 0);
-    ASSERT_GT(stats.spillSerializationTimeUs, 0);
-    ASSERT_GT(stats.spillDiskWrites, 0);
-    // Expect no non-spilling partitions.
-    ASSERT_TRUE(spiller_->finishSpill().empty());
-    const auto finalStats = spiller_->stats();
-    ASSERT_GT(finalStats, stats);
-    ASSERT_GT(finalStats.spillFillTimeUs, stats.spillFillTimeUs);
-    ASSERT_EQ(finalStats.spilledFiles, numNonEmptyPartitions);
-    ASSERT_EQ(finalStats.spilledRows, numRows);
-    ASSERT_EQ(finalStats.spilledPartitions, numNonEmptyPartitions);
-    verifySortedSpillData();
-  }
-}
-
-TEST_P(AggregationInputOnly, spillWithNonSpillingPartitions) {
-  // kOrderBy type which has only one partition, is irrelevant for this test.
-  rowType_ = ROW({{"long_val", BIGINT()}, {"string_val", VARCHAR()}});
-  struct {
-    std::vector<int> rowsPerPartition;
-    int numDuplicates;
-    int expectedSpillPartitionIndex;
-
-    std::string debugString() const {
-      return fmt::format(
-          "rowsPerPartition: [{}], numDuplicates: {}, expectedSpillPartitionIndex: {}",
-          folly::join(':', rowsPerPartition),
-          numDuplicates,
-          expectedSpillPartitionIndex);
-    }
-  } testSettings[] = {// Test with distinct sort keys.
-                      {{5'000, 1, 0, 0}, 1, 0},
-                      {{1, 1, 1, 5000}, 1, 3},
-                      // Test with duplicate sort keys.
-                      {{5'000, 1, 0, 0}, 10, 0},
-                      {{1, 1, 1, 5000}, 10, 3}};
-  for (auto testData : testSettings) {
-    SCOPED_TRACE(testData.debugString());
-    reset();
-    int32_t numRows = 0;
-    for (const auto partitionRows : testData.rowsPerPartition) {
-      numRows += partitionRows;
-    }
-    int64_t outputIndex = 0;
-    setupSpillData(
-        rowType_,
-        1,
-        numRows,
-        testData.numDuplicates,
-        [&](RowVectorPtr rowVector) {
-          // Set ordinal so that the sorted order is unambiguous.
-          setSequentialValue(rowVector, 0, outputIndex);
-          outputIndex += rowVector->size();
-        },
-        testData.rowsPerPartition);
-    sortSpillData();
-    // Setup a large target file size and spill only once to ensure the number
-    // of spilled files matches the number of spilled partitions.
-    setupSpiller(2'000'000'000, 0, 0, false);
-    // We spill spillPct% of the data all at once.
-    runSpill(20, 20, false);
-
-    for (int partition = 0; partition < numPartitions_; ++partition) {
-      EXPECT_EQ(
-          testData.expectedSpillPartitionIndex == partition,
-          spiller_->state().isPartitionSpilled(partition));
-    }
-    ASSERT_TRUE(spiller_->isAnySpilled());
-    ASSERT_FALSE(spiller_->isAllSpilled());
-    const auto stats = spiller_->stats();
-    ASSERT_EQ(1, stats.spilledFiles);
-    // Expect non-spilling partition.
-    EXPECT_FALSE(spiller_->finishSpill().empty());
-    verifySortedSpillData();
-    EXPECT_LT(0, spiller_->stats().spilledRows);
-    EXPECT_GT(numRows, spiller_->stats().spilledRows);
-  }
-}
-
-TEST_P(NoHashJoin, spillPartition) {
-  {
-    setupSpillData(rowType_, numKeys_, 1'000, 1, nullptr, {});
-    sortSpillData();
-    setupSpiller(100'000, 0, 0, false);
-    std::vector<Spiller::SpillableStats> statsList;
-    spiller_->fillSpillRuns(statsList);
-    spiller_->spill(SpillPartitionNumSet{0});
-    spiller_->spill(SpillPartitionNumSet{0});
-    spiller_->spill(
-        SpillPartitionNumSet{std::min<uint32_t>(1, numPartitions_ - 1)});
-    spiller_->spill(
-        SpillPartitionNumSet{std::min<uint32_t>(1, numPartitions_ - 1)});
-    spiller_->finishSpill();
-    verifySortedSpillData();
-    VELOX_ASSERT_THROW(
-        spiller_->spill(SpillPartitionNumSet{0}), "Spiller has been finalized");
-    VELOX_ASSERT_THROW(
-        spiller_->spill(RowContainerIterator{}), "Spiller has been finalized");
-  }
-  {
-    setupSpillData(rowType_, numKeys_, 1'000, 1, nullptr, {});
-    sortSpillData();
-    setupSpiller(100'000, 0, 0, false);
-    std::vector<Spiller::SpillableStats> statsList;
-    spiller_->fillSpillRuns(statsList);
-    std::vector<uint32_t> spillPartitionNums(numPartitions_);
-    std::iota(spillPartitionNums.begin(), spillPartitionNums.end(), 0);
-    spiller_->spill(SpillPartitionNumSet(
-        spillPartitionNums.begin(), spillPartitionNums.end()));
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    spiller_->spill(SpillPartitionNumSet(
-        spillPartitionNums.begin(), spillPartitionNums.end()));
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    spiller_->finishSpill();
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    verifySortedSpillData();
-    VELOX_ASSERT_THROW(
-        spiller_->spill(SpillPartitionNumSet(
-            spillPartitionNums.begin(), spillPartitionNums.end())),
-        "Spiller has been finalized");
-    VELOX_ASSERT_THROW(
-        spiller_->spill(RowContainerIterator{}), "Spiller has been finalized");
-  }
-  {
-    setupSpillData(rowType_, numKeys_, 1'000, 1, nullptr, {});
-    sortSpillData();
-    setupSpiller(100'000, 0, 0, false);
-    std::vector<Spiller::SpillableStats> statsList;
-    spiller_->fillSpillRuns(statsList);
-    std::vector<uint32_t> spillPartitionNums(numPartitions_);
-    std::iota(spillPartitionNums.begin(), spillPartitionNums.end(), 0);
-    spiller_->spill();
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    spiller_->spill();
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    spiller_->finishSpill();
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    verifySortedSpillData();
-    VELOX_ASSERT_THROW(
-        spiller_->spill(SpillPartitionNumSet{}), "Spiller has been finalized");
-    VELOX_ASSERT_THROW(
-        spiller_->spill(RowContainerIterator{}), "Spiller has been finalized");
-  }
-}
-
-TEST_P(AllTypes, nonSortedSpillFunctions) {
-  if (type_ == Spiller::Type::kOrderBy ||
-      type_ == Spiller::Type::kAggregateInput ||
-      type_ == Spiller::Type::kAggregateOutput) {
-    setupSpillData(rowType_, numKeys_, 1'000, 1, nullptr, {});
-    sortSpillData();
-    setupSpiller(100'000, 0, 0, false);
-    {
-      RowVectorPtr dummyVector;
-      EXPECT_ANY_THROW(spiller_->spill(0, dummyVector));
-    }
-    std::vector<Spiller::SpillableStats> statsList;
-    spiller_->fillSpillRuns(statsList);
-    std::vector<uint32_t> spillPartitionNums(numPartitions_);
-    std::iota(spillPartitionNums.begin(), spillPartitionNums.end(), 0);
-    spiller_->spill(SpillPartitionNumSet(
-        spillPartitionNums.begin(), spillPartitionNums.end()));
-    spiller_->finishSpill();
-    verifySortedSpillData();
-    return;
-  }
-  testNonSortedSpill(1, 1000, 1, 1);
-  testNonSortedSpill(1, 1000, 10, 1);
-  testNonSortedSpill(1, 1000, 1, 1'000'000'000);
-  testNonSortedSpill(1, 1000, 10, 1'000'000'000);
-  testNonSortedSpill(4, 1000, 1, 1);
-  testNonSortedSpill(4, 1000, 10, 1);
-  testNonSortedSpill(4, 1000, 1, 1'000'000'000);
-  testNonSortedSpill(4, 1000, 10, 1'000'000'000);
-  // Empty case.
-  testNonSortedSpill(1, 1000, 0, 1);
-}
-
-TEST_P(AggregationInputOnly, minSpillRunSize) {
-  std::vector<uint64_t> minSpillRunSizes({0, 1'000'000'000});
-  auto rowType = ROW({{"int1", BIGINT()}, {"int2", BIGINT()}});
-  for (const auto& minSpillRunSize : minSpillRunSizes) {
-    SCOPED_TRACE(fmt::format("minSpillRunSize: {}", minSpillRunSize));
-    setupSpillContainer(rowType, 1);
-    setupSpiller(2'000'000'000, 0, minSpillRunSize, false);
-    for (int i = 0; i < numPartitions_; ++i) {
-      VectorFuzzer::Options options;
-      options.vectorSize = 10 * numPartitions_;
-      std::vector<RowVectorPtr> batches;
-      const int32_t numBatches = 10;
-      VectorFuzzer fuzzer(options, pool_.get());
-      for (int32_t j = 0; j < numBatches; ++j) {
-        auto batch = fuzzer.fuzzRow(rowType);
-        batch->ensureWritable(SelectivityVector::empty(batch->size()));
-        auto vector = batch->as<RowVector>()->childAt(0);
-        auto* rawKeyValues =
-            vector->asFlatVector<int64_t>()->mutableRawValues();
-        for (int k = 0; k < batch->size(); ++k) {
-          rawKeyValues[k] = j;
-        }
-        batches.push_back(batch);
-      }
-      writeSpillData(batches);
-      // Each time spill 50% of rows to see if the impact of min spill run size
-      // config on the partition selection.
-      runSpill(50, 10, false);
-    }
-    ASSERT_TRUE(spiller_->isAnySpilled());
-    if (minSpillRunSize == 0) {
-      // If there is no min spill run size restriction, then only some
-      // partitions will be spilled.
-      ASSERT_FALSE(spiller_->isAllSpilled());
-    } else {
-      // If there is min spill run size restriction, then all the partitions
-      // will be spilled.
-      ASSERT_TRUE(spiller_->isAllSpilled());
-    }
-  }
+  testSortedSpill(100, 1, false, true);
 }
 
 class HashJoinBuildOnly : public SpillerTest,
@@ -1432,74 +1270,24 @@ class HashJoinBuildOnly : public SpillerTest,
             {Spiller::Type::kAggregateInput,
              Spiller::Type::kAggregateOutput,
              Spiller::Type::kHashJoinProbe,
-             Spiller::Type::kOrderBy}}
+             Spiller::Type::kOrderByInput,
+             Spiller::Type::kOrderByOutput}}
         .getTestParams();
   }
 };
 
 TEST_P(HashJoinBuildOnly, spillPartition) {
-  {
-    setupSpillData(rowType_, numKeys_, 1'000, 1, nullptr, {});
-    std::vector<std::vector<RowVectorPtr>> vectorsByPartition(numPartitions_);
-    HashPartitionFunction spillHashFunction(hashBits_, rowType_, keyChannels_);
-    splitByPartition(rowVector_, spillHashFunction, vectorsByPartition);
-    setupSpiller(100'000, 0, 0, false);
-    std::vector<Spiller::SpillableStats> statsList;
-    spiller_->fillSpillRuns(statsList);
-    spiller_->spill(SpillPartitionNumSet{0});
-    spiller_->spill(SpillPartitionNumSet{0});
-    spiller_->spill(
-        SpillPartitionNumSet{std::min<uint32_t>(1, numPartitions_ - 1)});
-    spiller_->spill(
-        SpillPartitionNumSet{std::min<uint32_t>(1, numPartitions_ - 1)});
-    verifyNonSortedSpillData(
-        {0, std::min<uint32_t>(1, numPartitions_ - 1)}, vectorsByPartition);
-    VELOX_ASSERT_THROW(
-        spiller_->spill(SpillPartitionNumSet{0}), "Spiller has been finalized");
-    VELOX_ASSERT_THROW(
-        spiller_->spill(
-            SpillPartitionNumSet{std::min<uint32_t>(1, numPartitions_ - 1)}),
-        "Spiller has been finalized");
-  }
-  {
-    setupSpillData(rowType_, numKeys_, 1'000, 1, nullptr, {});
-    std::vector<std::vector<RowVectorPtr>> vectorsByPartition(numPartitions_);
-    HashPartitionFunction spillHashFunction(hashBits_, rowType_, keyChannels_);
-    splitByPartition(rowVector_, spillHashFunction, vectorsByPartition);
-    setupSpiller(100'000, 0, 0, false);
-    std::vector<Spiller::SpillableStats> statsList;
-    spiller_->fillSpillRuns(statsList);
-    std::vector<uint32_t> spillPartitionNums(numPartitions_);
-    std::iota(spillPartitionNums.begin(), spillPartitionNums.end(), 0);
-    SpillPartitionNumSet spillPartitionSet(
-        spillPartitionNums.begin(), spillPartitionNums.end());
-    spiller_->spill(spillPartitionSet);
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    spiller_->spill(spillPartitionSet);
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    verifyNonSortedSpillData(spillPartitionSet, vectorsByPartition);
-    VELOX_ASSERT_THROW(spiller_->spill(spillPartitionSet), "");
-  }
-  {
-    setupSpillData(rowType_, numKeys_, 1'000, 1, nullptr, {});
-    setupSpiller(100'000, 0, 0, false);
-    std::vector<std::vector<RowVectorPtr>> vectorsByPartition(numPartitions_);
-    HashPartitionFunction spillHashFunction(hashBits_, rowType_, keyChannels_);
-    splitByPartition(rowVector_, spillHashFunction, vectorsByPartition);
-    std::vector<Spiller::SpillableStats> statsList;
-    spiller_->fillSpillRuns(statsList);
-    spiller_->spill();
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    spiller_->spill();
-    ASSERT_TRUE(spiller_->isAllSpilled());
-    std::vector<uint32_t> spillPartitionNums(numPartitions_);
-    std::iota(spillPartitionNums.begin(), spillPartitionNums.end(), 0);
-    SpillPartitionNumSet spillPartitionSet(
-        spillPartitionNums.begin(), spillPartitionNums.end());
-    verifyNonSortedSpillData(spillPartitionSet, vectorsByPartition);
-    VELOX_ASSERT_THROW(
-        spiller_->spill(SpillPartitionNumSet{}), "Spiller has been finalized");
-  }
+  setupSpillData(numKeys_, 1'000, 1, nullptr, {});
+  std::vector<std::vector<RowVectorPtr>> vectorsByPartition(numPartitions_);
+  HashPartitionFunction spillHashFunction(hashBits_, rowType_, keyChannels_);
+  splitByPartition(rowVector_, spillHashFunction, vectorsByPartition);
+  setupSpiller(100'000, 0, false);
+  spiller_->spill();
+  rowContainer_->clear();
+  spiller_->spill();
+  verifyNonSortedSpillData(allPartitionNumSet(), vectorsByPartition);
+  VELOX_ASSERT_THROW(spiller_->spill(), "Spiller has been finalized");
+  VELOX_ASSERT_THROW(spiller_->spill(RowContainerIterator{}), "");
 }
 
 TEST_P(HashJoinBuildOnly, writeBufferSize) {
@@ -1507,17 +1295,11 @@ TEST_P(HashJoinBuildOnly, writeBufferSize) {
   for (const auto writeBufferSize : writeBufferSizes) {
     SCOPED_TRACE(
         fmt::format("writeBufferSize {}", succinctBytes(writeBufferSize)));
-    setupSpillData(rowType_, numKeys_, 1'000, 1, nullptr, {});
-    setupSpiller(4'000'000'000, writeBufferSize, 0, false);
-    std::vector<Spiller::SpillableStats> statsList;
-    spiller_->fillSpillRuns(statsList);
-    std::vector<uint32_t> spillPartitionNums(numPartitions_);
-    std::iota(spillPartitionNums.begin(), spillPartitionNums.end(), 0);
-    SpillPartitionNumSet spillPartitionSet(
-        spillPartitionNums.begin(), spillPartitionNums.end());
-    spiller_->spill(spillPartitionSet);
+    setupSpillData(numKeys_, 1'000, 1, nullptr, {});
+    setupSpiller(4'000'000'000, writeBufferSize, false);
+    spiller_->spill();
     ASSERT_TRUE(spiller_->isAllSpilled());
-    const int numDiskWrites = spiller_->stats().spillDiskWrites;
+    const int numDiskWrites = spiller_->stats().spillWrites;
     if (writeBufferSize != 0) {
       ASSERT_EQ(numDiskWrites, 0);
     }
@@ -1551,16 +1333,20 @@ TEST_P(HashJoinBuildOnly, writeBufferSize) {
     std::vector<std::vector<RowVectorPtr>> expectedVectorByPartition(
         numPartitions_);
     splitByPartition(rowVector_, spillHashFunction, expectedVectorByPartition);
+    std::vector<uint32_t> spillPartitionNums(numPartitions_);
+    std::iota(spillPartitionNums.begin(), spillPartitionNums.end(), 0);
+    SpillPartitionNumSet spillPartitionSet(
+        spillPartitionNums.begin(), spillPartitionNums.end());
     verifyNonSortedSpillData(spillPartitionSet, expectedVectorByPartition);
 
     const auto stats = spiller_->stats();
     if (writeBufferSize > 0) {
       // With disk write buffering, all the input merged into one disk write per
       // partition.
-      ASSERT_EQ(stats.spillDiskWrites, numNonEmptySpilledPartitions);
+      ASSERT_EQ(stats.spillWrites, numNonEmptySpilledPartitions);
     } else {
       // By disable write buffering, then each spill input causes a disk write.
-      ASSERT_EQ(stats.spillDiskWrites, numDiskWrites + spillInputVectorCount);
+      ASSERT_EQ(stats.spillWrites, numDiskWrites + spillInputVectorCount);
     }
   }
 }
@@ -1575,8 +1361,10 @@ class AggregationOutputOnly : public SpillerTest,
         .typesToExclude =
             {Spiller::Type::kAggregateInput,
              Spiller::Type::kHashJoinBuild,
+             Spiller::Type::kRowNumber,
              Spiller::Type::kHashJoinProbe,
-             Spiller::Type::kOrderBy}}
+             Spiller::Type::kOrderByInput,
+             Spiller::Type::kOrderByOutput}}
         .getTestParams();
   }
 };
@@ -1585,20 +1373,50 @@ TEST_P(AggregationOutputOnly, basic) {
   const int numRows = 5'000;
   struct {
     int spillRowOffset;
-
+    uint64_t maxSpillRunRows;
+    uint64_t readBufferSize;
     std::string debugString() const {
-      return fmt::format("spillRowOffset {}", spillRowOffset);
+      return fmt::format(
+          "spillRowOffset {}, maxSpillRunRows {}, readBufferSize {}",
+          spillRowOffset,
+          maxSpillRunRows,
+          succinctBytes(readBufferSize));
     }
   } testSettings[] = {
-      {0}, {1}, {5'000 / 20}, {5'000 - 1}, {5'000 + 1}, {5'000 * 2}};
+      {0, 101, 1 << 20},
+      {1, 101, 1 << 20},
+      {5'000 / 20, 101, 1 << 20},
+      {5'000 - 1, 101, 1 << 20},
+      {5'000 + 1, 101, 1 << 20},
+      {5'000 * 2, 101, 1 << 20},
+      {0, 100'000, 1 << 20},
+      {1, 100'000, 1 << 20},
+      {5'000 / 20, 0, 1 << 20},
+      {5'000 - 1, 0, 1 << 20},
+      {5'000 + 1, 0, 1 << 20},
+      {5'000 * 2, 0, 1 << 20},
+
+      {0, 101, 512},
+      {1, 101, 512},
+      {5'000 / 20, 101, 512},
+      {5'000 - 1, 101, 512},
+      {5'000 + 1, 101, 512},
+      {5'000 * 2, 101, 512},
+      {0, 100'000, 512},
+      {1, 100'000, 512},
+      {5'000 / 20, 0, 512},
+      {5'000 - 1, 0, 512},
+      {5'000 + 1, 0, 512},
+      {5'000 * 2, 0, 512}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
-    setupSpillData(rowType_, numKeys_, numRows, 0);
+    setupSpillData(numKeys_, numRows, 0);
     sortSpillData();
     // NOTE: target file size is ignored by aggregation output spiller type.
-    setupSpiller(0, 1'000'000, 0, false);
+    setupSpiller(
+        0, 1'000'000, false, testData.maxSpillRunRows, testData.readBufferSize);
     RowContainerIterator rowIter;
     std::vector<char*> rows(numRows);
     int numListedRows{0};
@@ -1611,22 +1429,21 @@ TEST_P(AggregationOutputOnly, basic) {
       RowVectorPtr dummy;
       VELOX_ASSERT_THROW(
           spiller_->spill(0, dummy),
-          "Can't spill vector to a non-spilling partition");
+          "Unexpected spiller type: AGGREGATE_OUTPUT");
     }
     spiller_->spill(rowIter);
-    ASSERT_EQ(rowContainer_->numRows(), numListedRows);
-    VELOX_ASSERT_THROW(
-        spiller_->startMerge(1), "Spiller hasn't been finalized yet");
-    VELOX_ASSERT_THROW(
-        spiller_->startMerge(0), "Spiller hasn't been finalized yet");
-
+    ASSERT_EQ(rowContainer_->numRows(), numRows);
     rowContainer_->clear();
-    const Spiller::SpillRows unspilledRows = spiller_->finishSpill();
-    ASSERT_TRUE(unspilledRows.empty());
-    VELOX_ASSERT_THROW(spiller_->finishSpill(), "Spiller has been finalized");
+
+    SpillPartitionSet spillPartitionSet;
+    spiller_->finishSpill(spillPartitionSet);
+    ASSERT_EQ(spillPartitionSet.size(), 1);
+    ASSERT_TRUE(spiller_->finalized());
+    auto spillPartition = std::move(spillPartitionSet.begin()->second);
 
     const int expectedNumSpilledRows = numRows - numListedRows;
-    auto merge = spiller_->startMerge(0);
+    auto merge = spillPartition->createOrderedReader(
+        spillConfig_.readBufferSize, pool(), &spillStats_);
     if (expectedNumSpilledRows == 0) {
       ASSERT_TRUE(merge == nullptr);
     } else {
@@ -1640,13 +1457,112 @@ TEST_P(AggregationOutputOnly, basic) {
         stream->pop();
       }
     }
+
+    const auto stats = spiller_->stats();
+    if (expectedNumSpilledRows == 0) {
+      ASSERT_EQ(stats.spilledFiles, 0) << stats.toString();
+      ASSERT_EQ(stats.spilledRows, 0) << stats.toString();
+    } else {
+      ASSERT_EQ(stats.spilledFiles, 1) << stats.toString();
+      ASSERT_EQ(stats.spilledRows, expectedNumSpilledRows) << stats.toString();
+    }
+    ASSERT_EQ(stats.spillSortTimeNanos, 0);
+  }
+}
+
+class OrderByOutputOnly : public SpillerTest,
+                          public testing::WithParamInterface<TestParam> {
+ public:
+  OrderByOutputOnly() : SpillerTest(GetParam()) {}
+
+  static std::vector<TestParam> getTestParams() {
+    return TestParamsBuilder{
+        .typesToExclude =
+            {Spiller::Type::kAggregateInput,
+             Spiller::Type::kAggregateOutput,
+             Spiller::Type::kHashJoinBuild,
+             Spiller::Type::kHashJoinProbe,
+             Spiller::Type::kRowNumber,
+             Spiller::Type::kOrderByInput}}
+        .getTestParams();
+  }
+};
+
+TEST_P(OrderByOutputOnly, basic) {
+  const int numRows = 5'000;
+  struct {
+    int numSpillRows;
+    int readBufferSize;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numSpillRows {}, readBufferSize {}",
+          numSpillRows,
+          succinctBytes(readBufferSize));
+    }
+  } testSettings[] = {
+      {0, 1 << 20},
+      {1000, 1 << 20},
+      {5000, 1 << 20},
+      {5000 - 1, 1 << 20},
+      {5000 + 1, 1 << 20},
+      {50000 * 2, 1 << 20},
+      {0, 512},
+      {1000, 512},
+      {5000, 512},
+      {5000 - 1, 512},
+      {5000 + 1, 512},
+      {50000 * 2, 512}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    setupSpillData(numKeys_, numRows, 0);
+    sortSpillData();
+    // NOTE: target file size is ignored by aggregation output spiller type.
+    setupSpiller(0, 1'000'000, false);
+    RowContainerIterator rowIter;
+    std::vector<char*> rows(numRows);
+    int numListedRows{0};
+    numListedRows =
+        rowContainer_->listRows(&rowIter, testData.numSpillRows, rows.data());
+    ASSERT_LE(numListedRows, numRows);
     {
-      if (expectedNumSpilledRows == 0) {
-        ASSERT_TRUE(spiller_->startMerge(0) == nullptr);
-      } else {
-        VELOX_ASSERT_THROW(spiller_->startMerge(0), "");
+      RowVectorPtr dummy;
+      VELOX_ASSERT_THROW(
+          spiller_->spill(0, dummy),
+          "Unexpected spiller type: ORDER_BY_OUTPUT");
+    }
+    {
+      std::vector<char*> emptyRows;
+      VELOX_ASSERT_THROW(spiller_->spill(emptyRows), "");
+    }
+    auto spillRows =
+        std::vector<char*>(rows.begin(), rows.begin() + numListedRows);
+    spiller_->spill(spillRows);
+    ASSERT_EQ(rowContainer_->numRows(), numRows);
+    rowContainer_->clear();
+
+    rowContainer_->clear();
+    SpillPartitionSet spillPartitionSet;
+    spiller_->finishSpill(spillPartitionSet);
+    ASSERT_TRUE(spiller_->finalized());
+    ASSERT_EQ(spillPartitionSet.size(), 1);
+    auto spillPartition = std::move(spillPartitionSet.begin()->second);
+
+    const int expectedNumSpilledRows = numListedRows;
+    auto merge = spillPartition->createOrderedReader(
+        spillConfig_.readBufferSize, pool(), &spillStats_);
+    if (expectedNumSpilledRows == 0) {
+      ASSERT_TRUE(merge == nullptr);
+    } else {
+      for (auto i = 0; i < expectedNumSpilledRows; ++i) {
+        auto* stream = merge->next();
+        ASSERT_TRUE(stream != nullptr);
+        ASSERT_TRUE(rowVector_->equalValueAt(
+            &stream->current(), partitions_[0][i], stream->currentIndex()));
+        stream->pop();
       }
-      VELOX_ASSERT_THROW(spiller_->startMerge(1), "");
     }
 
     const auto stats = spiller_->stats();
@@ -1657,7 +1573,85 @@ TEST_P(AggregationOutputOnly, basic) {
       ASSERT_EQ(stats.spilledFiles, 1) << stats.toString();
       ASSERT_EQ(stats.spilledRows, expectedNumSpilledRows) << stats.toString();
     }
-    ASSERT_EQ(stats.spillSortTimeUs, 0);
+    ASSERT_EQ(stats.spillSortTimeNanos, 0);
+  }
+}
+
+class MaxSpillRunTest : public SpillerTest,
+                        public testing::WithParamInterface<TestParam> {
+ public:
+  MaxSpillRunTest() : SpillerTest(GetParam()) {}
+
+  static std::vector<TestParam> getTestParams() {
+    return TestParamsBuilder{
+        .typesToExclude =
+            {Spiller::Type::kHashJoinProbe, Spiller::Type::kOrderByOutput}}
+        .getTestParams();
+  }
+};
+
+TEST_P(MaxSpillRunTest, basic) {
+  struct {
+    uint64_t maxSpillRunRows;
+    uint8_t expectedNumFiles;
+    std::string debugString() const {
+      return fmt::format(
+          "maxSpillRunRows {}, expectedNumFiles {}",
+          maxSpillRunRows,
+          expectedNumFiles);
+    }
+  } testSettings[] = {{0, 1}, {101, 3}, {4095, 3}, {4096, 3}, {4097, 2}};
+
+  auto numRows = 10'000;
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    setupSpillData(numKeys_, numRows, 1, nullptr, {});
+    sortSpillData();
+    setupSpiller(
+        std::numeric_limits<uint64_t>::max(),
+        0,
+        false,
+        testData.maxSpillRunRows);
+    if (type_ == Spiller::Type::kOrderByOutput) {
+      RowContainerIterator rowIter;
+      std::vector<char*> rows(numRows);
+      int numListedRows{0};
+      numListedRows = rowContainer_->listRows(&rowIter, numRows, rows.data());
+      ASSERT_EQ(numListedRows, numRows);
+      spiller_->spill(rows);
+    } else {
+      spiller_->spill();
+    }
+    ASSERT_FALSE(spiller_->finalized());
+    SpillPartitionSet spillPartitionSet;
+    spiller_->finishSpill(spillPartitionSet);
+    ASSERT_TRUE(spiller_->finalized());
+
+    auto numFiles{0};
+    auto totalSize{0};
+    std::vector<std::string_view> spilledFiles;
+    for (const auto& [_, sp] : spillPartitionSet) {
+      numFiles += sp->numFiles();
+      totalSize += sp->size();
+    }
+
+    const auto& stats = spiller_->stats();
+    ASSERT_EQ(totalSize, stats.spilledBytes);
+    if (type_ == Spiller::Type::kAggregateOutput ||
+        type_ == Spiller::Type::kOrderByOutput) {
+      ASSERT_EQ(numFiles, numPartitions_);
+      ASSERT_EQ(spillPartitionSet.size(), numPartitions_);
+    } else if (type_ == Spiller::Type::kOrderByInput) {
+      // Need sort.
+      ASSERT_EQ(numFiles, testData.expectedNumFiles);
+      ASSERT_EQ(spillPartitionSet.size(), numPartitions_);
+    } else if (type_ == Spiller::Type::kAggregateInput) {
+      ASSERT_GE(numFiles, testData.expectedNumFiles);
+      ASSERT_EQ(spillPartitionSet.size(), numPartitions_);
+    } else {
+      ASSERT_EQ(numFiles, numPartitions_);
+      ASSERT_EQ(spillPartitionSet.size(), numFiles);
+    }
   }
 }
 
@@ -1671,11 +1665,6 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     NoHashJoin,
     testing::ValuesIn(NoHashJoin::getTestParams()));
 
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    SpillerTest,
-    AggregationInputOnly,
-    testing::ValuesIn(AggregationInputOnly::getTestParams()));
-
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SpillerTest,
     HashJoinBuildOnly,
@@ -1686,39 +1675,12 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     AggregationOutputOnly,
     testing::ValuesIn(AggregationOutputOnly::getTestParams()));
 
-TEST(SpillerTest, stats) {
-  SpillStats sumStats;
-  EXPECT_EQ(0, sumStats.spilledRows);
-  EXPECT_EQ(0, sumStats.spilledInputBytes);
-  EXPECT_EQ(0, sumStats.spilledBytes);
-  EXPECT_EQ(0, sumStats.spilledPartitions);
-  EXPECT_EQ(0, sumStats.spilledFiles);
-
-  SpillStats stats;
-  stats.spilledRows = 10;
-  stats.spilledInputBytes = 200;
-  stats.spilledBytes = 100;
-  stats.spilledPartitions = 2;
-  stats.spilledFiles = 3;
-
-  sumStats += stats;
-  EXPECT_EQ(stats.spilledRows, sumStats.spilledRows);
-  EXPECT_EQ(stats.spilledInputBytes, sumStats.spilledInputBytes);
-  EXPECT_EQ(stats.spilledBytes, sumStats.spilledBytes);
-  EXPECT_EQ(stats.spilledPartitions, sumStats.spilledPartitions);
-  EXPECT_EQ(stats.spilledFiles, sumStats.spilledFiles);
-
-  sumStats += stats;
-  EXPECT_EQ(2 * stats.spilledRows, sumStats.spilledRows);
-  EXPECT_EQ(2 * stats.spilledInputBytes, sumStats.spilledInputBytes);
-  EXPECT_EQ(2 * stats.spilledBytes, sumStats.spilledBytes);
-  EXPECT_EQ(2 * stats.spilledPartitions, sumStats.spilledPartitions);
-  EXPECT_EQ(2 * stats.spilledFiles, sumStats.spilledFiles);
-
-  sumStats += stats;
-  EXPECT_EQ(3 * stats.spilledRows, sumStats.spilledRows);
-  EXPECT_EQ(3 * stats.spilledInputBytes, sumStats.spilledInputBytes);
-  EXPECT_EQ(3 * stats.spilledBytes, sumStats.spilledBytes);
-  EXPECT_EQ(3 * stats.spilledPartitions, sumStats.spilledPartitions);
-  EXPECT_EQ(3 * stats.spilledFiles, sumStats.spilledFiles);
-}
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    SpillerTest,
+    OrderByOutputOnly,
+    testing::ValuesIn(OrderByOutputOnly::getTestParams()));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    SpillerTest,
+    MaxSpillRunTest,
+    testing::ValuesIn(MaxSpillRunTest::getTestParams()));
diff --git a/velox/exec/tests/SqlTest.cpp b/velox/exec/tests/SqlTest.cpp
index 73a3f29b2a980..8ad448474e9e0 100644
--- a/velox/exec/tests/SqlTest.cpp
+++ b/velox/exec/tests/SqlTest.cpp
@@ -21,13 +21,19 @@ namespace facebook::velox::exec::test {
 
 class SqlTest : public OperatorTestBase {
  protected:
+  void TearDown() override {
+    planner_.reset();
+    OperatorTestBase::TearDown();
+  }
+
   void assertSql(const std::string& sql, const std::string& duckSql = "") {
-    auto plan = planner_.plan(sql);
+    auto plan = planner_->plan(sql);
     AssertQueryBuilder(plan, duckDbQueryRunner_)
         .assertResults(duckSql.empty() ? sql : duckSql);
   }
 
-  core::DuckDbQueryPlanner planner_{pool()};
+  std::unique_ptr<core::DuckDbQueryPlanner> planner_{
+      std::make_unique<core::DuckDbQueryPlanner>(pool())};
 };
 
 TEST_F(SqlTest, values) {
@@ -40,20 +46,23 @@ TEST_F(SqlTest, values) {
 }
 
 TEST_F(SqlTest, customScalarFunctions) {
-  planner_.registerScalarFunction(
+  planner_->registerScalarFunction(
       "array_join", {ARRAY(BIGINT()), VARCHAR()}, VARCHAR());
 
   assertSql("SELECT array_join([1, 2, 3], '-')", "SELECT '1-2-3'");
 }
 
 TEST_F(SqlTest, customAggregateFunctions) {
-  planner_.registerAggregateFunction("count_if", {BOOLEAN()}, BIGINT());
+  // We need an aggregate that DuckDB does not support. 'every' fits the need.
+  // 'every' is an alias for bool_and().
+  planner_->registerAggregateFunction("every", {BOOLEAN()}, BOOLEAN());
 
   assertSql(
-      "SELECT count_if(x > 2) FROM UNNEST([1, 2, 3]) as t(x)", "SELECT 1");
+      "SELECT every(x) FROM UNNEST([true, false, true]) as t(x)",
+      "SELECT false");
   assertSql(
-      "SELECT x % 2, count_if(x > 0) FROM UNNEST([1, 2, 3]) as t(x) GROUP BY 1",
-      "VALUES (0, 1), (1, 2)");
+      "SELECT x, every(x) FROM UNNEST([true, false, true, false]) as t(x) GROUP BY 1",
+      "VALUES (true, true), (false, false)");
 }
 
 TEST_F(SqlTest, tableScan) {
@@ -78,8 +87,8 @@ TEST_F(SqlTest, tableScan) {
   createDuckDbTable("t", data.at("t"));
   createDuckDbTable("u", data.at("u"));
 
-  planner_.registerTable("t", data.at("t"));
-  planner_.registerTable("u", data.at("u"));
+  planner_->registerTable("t", data.at("t"));
+  planner_->registerTable("u", data.at("u"));
 
   assertSql("SELECT a, avg(b) FROM t WHERE c > 5 GROUP BY 1");
   assertSql("SELECT * FROM t, u WHERE t.a = u.a");
diff --git a/velox/exec/tests/StreamingAggregationTest.cpp b/velox/exec/tests/StreamingAggregationTest.cpp
index 36858e523f87f..bf0a4cf5b0c7b 100644
--- a/velox/exec/tests/StreamingAggregationTest.cpp
+++ b/velox/exec/tests/StreamingAggregationTest.cpp
@@ -13,6 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -30,7 +32,7 @@ class StreamingAggregationTest : public OperatorTestBase {
 
   void testAggregation(
       const std::vector<VectorPtr>& keys,
-      uint32_t outputBatchSize = 1'024) {
+      uint32_t outputBatchSize) {
     std::vector<RowVectorPtr> data;
 
     vector_size_t totalSize = 0;
@@ -52,6 +54,7 @@ class StreamingAggregationTest : public OperatorTestBase {
                          "max(c1)",
                          "sum(c1)",
                          "sumnonpod(1)",
+                         "sum(cast(NULL as INT))",
                          "approx_percentile(c1, 0.95)"})
                     .finalAggregation()
                     .planNode();
@@ -61,7 +64,7 @@ class StreamingAggregationTest : public OperatorTestBase {
             core::QueryConfig::kPreferredOutputBatchRows,
             std::to_string(outputBatchSize))
         .assertResults(
-            "SELECT c0, count(1), min(c1), max(c1), sum(c1), sum(1)"
+            "SELECT c0, count(1), min(c1), max(c1), sum(c1), sum(1), sum(cast(NULL as INT))"
             "     , approx_quantile(c1, 0.95) "
             "FROM tmp GROUP BY 1");
 
@@ -108,6 +111,95 @@ class StreamingAggregationTest : public OperatorTestBase {
             "FROM tmp GROUP BY 1");
   }
 
+  void testSortedAggregation(
+      const std::vector<VectorPtr>& keys,
+      uint32_t outputBatchSize) {
+    std::vector<RowVectorPtr> data;
+
+    vector_size_t totalSize = 0;
+    for (const auto& keyVector : keys) {
+      auto size = keyVector->size();
+      auto payload = makeFlatVector<int32_t>(
+          size, [totalSize](auto row) { return totalSize + row; });
+      data.push_back(makeRowVector({keyVector, payload, payload}));
+      totalSize += size;
+    }
+    createDuckDbTable(data);
+
+    auto plan = PlanBuilder()
+                    .values(data)
+                    .streamingAggregation(
+                        {"c0"},
+                        {"max(c1 order by c2)",
+                         "max(c1 order by c2 desc)",
+                         "array_agg(c1 order by c2)"},
+                        {},
+                        core::AggregationNode::Step::kSingle,
+                        false)
+                    .planNode();
+
+    AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows,
+            std::to_string(outputBatchSize))
+        .assertResults(
+            "SELECT c0, max(c1 order by c2), max(c1 order by c2 desc), array_agg(c1 order by c2) FROM tmp GROUP BY c0");
+  }
+
+  void testDistinctAggregation(
+      const std::vector<VectorPtr>& keys,
+      uint32_t outputBatchSize) {
+    std::vector<RowVectorPtr> data;
+
+    vector_size_t totalSize = 0;
+    for (const auto& keyVector : keys) {
+      auto size = keyVector->size();
+      auto payload = makeFlatVector<int32_t>(
+          size, [totalSize](auto row) { return totalSize + row; });
+      data.push_back(makeRowVector({keyVector, payload, payload}));
+      totalSize += size;
+    }
+    createDuckDbTable(data);
+
+    {
+      auto plan = PlanBuilder()
+                      .values(data)
+                      .streamingAggregation(
+                          {"c0"},
+                          {"array_agg(distinct c1)",
+                           "array_agg(c1 order by c2)",
+                           "count(distinct c1)",
+                           "array_agg(c2)"},
+                          {},
+                          core::AggregationNode::Step::kSingle,
+                          false)
+                      .planNode();
+
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(
+              core::QueryConfig::kPreferredOutputBatchRows,
+              std::to_string(outputBatchSize))
+          .assertResults(
+              "SELECT c0, array_agg(distinct c1), array_agg(c1 order by c2), "
+              "count(distinct c1), array_agg(c2) FROM tmp GROUP BY c0");
+    }
+
+    {
+      auto plan =
+          PlanBuilder()
+              .values(data)
+              .streamingAggregation(
+                  {"c0"}, {}, {}, core::AggregationNode::Step::kSingle, false)
+              .planNode();
+
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(
+              core::QueryConfig::kPreferredOutputBatchRows,
+              std::to_string(outputBatchSize))
+          .assertResults("SELECT distinct c0 FROM tmp");
+    }
+  }
+
   std::vector<RowVectorPtr> addPayload(const std::vector<RowVectorPtr>& keys) {
     auto numKeys = keys[0]->type()->size();
 
@@ -134,7 +226,7 @@ class StreamingAggregationTest : public OperatorTestBase {
 
   void testMultiKeyAggregation(
       const std::vector<RowVectorPtr>& keys,
-      uint32_t outputBatchSize = 1'024) {
+      uint32_t outputBatchSize) {
     testMultiKeyAggregation(
         keys, keys[0]->type()->asRow().names(), outputBatchSize);
   }
@@ -142,7 +234,7 @@ class StreamingAggregationTest : public OperatorTestBase {
   void testMultiKeyAggregation(
       const std::vector<RowVectorPtr>& keys,
       const std::vector<std::string>& preGroupedKeys,
-      uint32_t outputBatchSize = 1'024) {
+      uint32_t outputBatchSize) {
     auto data = addPayload(keys);
     createDuckDbTable(data);
 
@@ -186,6 +278,73 @@ class StreamingAggregationTest : public OperatorTestBase {
 
     EXPECT_EQ(NonPODInt64::constructed, NonPODInt64::destructed);
   }
+
+  void testMultiKeyDistinctAggregation(
+      const std::vector<RowVectorPtr>& keys,
+      uint32_t outputBatchSize) {
+    auto data = addPayload(keys);
+    createDuckDbTable(data);
+
+    {
+      auto plan =
+          PlanBuilder()
+              .values(data)
+              .streamingAggregation(
+                  keys[0]->type()->asRow().names(),
+                  {"count(distinct c1)", "array_agg(c1)", "sumnonpod(1)"},
+                  {},
+                  core::AggregationNode::Step::kSingle,
+                  false)
+              .planNode();
+
+      // Generate a list of grouping keys to use in the query: c0, c1, c2,..
+      std::ostringstream keySql;
+      keySql << "c0";
+      for (auto i = 1; i < numKeys(keys); i++) {
+        keySql << ", c" << i;
+      }
+
+      const auto sql = fmt::format(
+          "SELECT {}, count(distinct c1), array_agg(c1), sum(1) FROM tmp GROUP BY {}",
+          keySql.str(),
+          keySql.str());
+
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(
+              core::QueryConfig::kPreferredOutputBatchRows,
+              std::to_string(outputBatchSize))
+          .assertResults(sql);
+
+      EXPECT_EQ(NonPODInt64::constructed, NonPODInt64::destructed);
+    }
+
+    {
+      auto plan = PlanBuilder()
+                      .values(data)
+                      .streamingAggregation(
+                          keys[0]->type()->asRow().names(),
+                          {},
+                          {},
+                          core::AggregationNode::Step::kSingle,
+                          false)
+                      .planNode();
+
+      // Generate a list of grouping keys to use in the query: c0, c1, c2,..
+      std::ostringstream keySql;
+      keySql << "c0";
+      for (auto i = 1; i < numKeys(keys); i++) {
+        keySql << ", c" << i;
+      }
+
+      const auto sql = fmt::format("SELECT distinct {} FROM tmp", keySql.str());
+
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(
+              core::QueryConfig::kPreferredOutputBatchRows,
+              std::to_string(outputBatchSize))
+          .assertResults(sql);
+    }
+  }
 };
 
 TEST_F(StreamingAggregationTest, smallInputBatches) {
@@ -198,7 +357,7 @@ TEST_F(StreamingAggregationTest, smallInputBatches) {
       makeFlatVector<int32_t>({6, 7, 8}),
   };
 
-  testAggregation(keys);
+  testAggregation(keys, 1024);
 
   // Cut output into tiny batches of size 3.
   testAggregation(keys, 3);
@@ -220,7 +379,7 @@ TEST_F(StreamingAggregationTest, multipleKeys) {
       }),
   };
 
-  testMultiKeyAggregation(keys);
+  testMultiKeyAggregation(keys, 1024);
 
   // Cut output into tiny batches of size 3.
   testMultiKeyAggregation(keys, 3);
@@ -239,7 +398,7 @@ TEST_F(StreamingAggregationTest, regularSizeInputBatches) {
           78, [size](auto row) { return (3 * size + row) / 5; }),
   };
 
-  testAggregation(keys);
+  testAggregation(keys, 1024);
 
   // Cut output into small batches of size 100.
   testAggregation(keys, 100);
@@ -256,7 +415,7 @@ TEST_F(StreamingAggregationTest, uniqueKeys) {
       makeFlatVector<int32_t>(78, [size](auto row) { return 3 * size + row; }),
   };
 
-  testAggregation(keys);
+  testAggregation(keys, 1024);
 
   // Cut output into small batches of size 100.
   testAggregation(keys, 100);
@@ -297,5 +456,85 @@ TEST_F(StreamingAggregationTest, partialStreaming) {
       }),
   };
 
-  testMultiKeyAggregation(keys, {"c0"});
+  testMultiKeyAggregation(keys, {"c0"}, 1024);
+}
+
+// Test StreamingAggregation being closed without being initialized. Create a
+// pipeline with Project followed by StreamingAggregation. Make
+// Project::initialize fail by using non-existent function.
+TEST_F(StreamingAggregationTest, closeUninitialized) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+  });
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .addNode([](auto nodeId, auto source) -> core::PlanNodePtr {
+                    return std::make_shared<core::ProjectNode>(
+                        nodeId,
+                        std::vector<std::string>{"c0", "x"},
+                        std::vector<core::TypedExprPtr>{
+                            std::make_shared<core::FieldAccessTypedExpr>(
+                                BIGINT(), "c0"),
+                            std::make_shared<core::CallTypedExpr>(
+                                BIGINT(),
+                                std::vector<core::TypedExprPtr>{},
+                                "do-not-exist")},
+                        source);
+                  })
+                  .partialStreamingAggregation({"c0"}, {"sum(x)"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "Scalar function name not registered: do-not-exist");
+}
+
+TEST_F(StreamingAggregationTest, sortedAggregations) {
+  auto size = 1024;
+
+  std::vector<VectorPtr> keys = {
+      makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(size, [size](auto row) { return (size + row); }),
+      makeFlatVector<int32_t>(
+          size, [size](auto row) { return (2 * size + row); }),
+      makeFlatVector<int32_t>(
+          78, [size](auto row) { return (3 * size + row); }),
+  };
+
+  testSortedAggregation(keys, 1024);
+  testSortedAggregation(keys, 32);
+}
+
+TEST_F(StreamingAggregationTest, distinctAggregations) {
+  auto size = 1024;
+
+  std::vector<VectorPtr> keys = {
+      makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(size, [size](auto row) { return (size + row); }),
+      makeFlatVector<int32_t>(
+          size, [size](auto row) { return (2 * size + row); }),
+      makeFlatVector<int32_t>(
+          78, [size](auto row) { return (3 * size + row); }),
+  };
+
+  testDistinctAggregation(keys, 1024);
+  testDistinctAggregation(keys, 32);
+
+  std::vector<RowVectorPtr> multiKeys = {
+      makeRowVector({
+          makeFlatVector<int32_t>({1, 1, 2, 2, 2}),
+          makeFlatVector<int64_t>({10, 20, 20, 30, 30}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({2, 3, 3, 3, 4}),
+          makeFlatVector<int64_t>({30, 30, 40, 40, 40}),
+      }),
+      makeRowVector({
+          makeNullableFlatVector<int32_t>({5, 5, 6, 6, 6}),
+          makeNullableFlatVector<int64_t>({40, 50, 50, 50, 50}),
+      }),
+  };
+
+  testMultiKeyDistinctAggregation(multiKeys, 1024);
+  testMultiKeyDistinctAggregation(multiKeys, 3);
 }
diff --git a/velox/exec/tests/TableScanTest.cpp b/velox/exec/tests/TableScanTest.cpp
index 148923c1e20b8..fbf5723be09d7 100644
--- a/velox/exec/tests/TableScanTest.cpp
+++ b/velox/exec/tests/TableScanTest.cpp
@@ -13,19 +13,36 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/exec/TableScan.h"
+#include <atomic>
+#include <shared_mutex>
+
+#include <fmt/ranges.h>
+#include <folly/experimental/EventCount.h>
+#include <folly/synchronization/Baton.h>
+#include <folly/synchronization/Latch.h>
+
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/tests/FaultyFile.h"
+#include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveDataSource.h"
+#include "velox/connectors/hive/HivePartitionFunction.h"
+#include "velox/dwio/common/CacheInputStream.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/Exchange.h"
+#include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/TableScan.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/Cursor.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/LocalExchangeSource.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/type/Timestamp.h"
 #include "velox/type/Type.h"
@@ -37,6 +54,7 @@ using namespace facebook::velox::core;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::common::test;
 using namespace facebook::velox::exec::test;
+using namespace facebook::velox::tests::utils;
 
 namespace {
 void verifyCacheStats(
@@ -54,6 +72,8 @@ class TableScanTest : public virtual HiveConnectorTestBase {
  protected:
   void SetUp() override {
     HiveConnectorTestBase::SetUp();
+    exec::ExchangeSource::factories().clear();
+    exec::ExchangeSource::registerFactory(createLocalExchangeSource);
   }
 
   static void SetUpTestCase() {
@@ -68,31 +88,55 @@ class TableScanTest : public virtual HiveConnectorTestBase {
     return HiveConnectorTestBase::makeVectors(inputs, count, rowsPerVector);
   }
 
-  exec::Split makeHiveSplit(std::string path) {
-    return exec::Split(makeHiveConnectorSplit(std::move(path)));
+  exec::Split makeHiveSplit(std::string path, int64_t splitWeight = 0) {
+    return exec::Split(makeHiveConnectorSplit(
+        std::move(path), 0, std::numeric_limits<uint64_t>::max(), splitWeight));
   }
 
   std::shared_ptr<Task> assertQuery(
-      const std::shared_ptr<const core::PlanNode>& plan,
+      const PlanNodePtr& plan,
       const std::shared_ptr<connector::ConnectorSplit>& hiveSplit,
       const std::string& duckDbSql) {
     return OperatorTestBase::assertQuery(plan, {hiveSplit}, duckDbSql);
   }
 
   std::shared_ptr<Task> assertQuery(
-      const std::shared_ptr<const core::PlanNode>& plan,
+      const PlanNodePtr& plan,
       const exec::Split&& split,
       const std::string& duckDbSql) {
     return OperatorTestBase::assertQuery(plan, {split}, duckDbSql);
   }
 
   std::shared_ptr<Task> assertQuery(
-      const std::shared_ptr<const core::PlanNode>& plan,
+      const PlanNodePtr& plan,
       const std::vector<std::shared_ptr<TempFilePath>>& filePaths,
       const std::string& duckDbSql) {
     return HiveConnectorTestBase::assertQuery(plan, filePaths, duckDbSql);
   }
 
+  std::shared_ptr<Task> assertQuery(
+      const PlanNodePtr& plan,
+      const std::vector<std::shared_ptr<TempFilePath>>& filePaths,
+      const std::string& duckDbSql,
+      const int32_t numPrefetchSplit) {
+    return HiveConnectorTestBase::assertQuery(
+        plan, makeHiveConnectorSplits(filePaths), duckDbSql, numPrefetchSplit);
+  }
+
+  // Run query with spill enabled.
+  std::shared_ptr<Task> assertQuery(
+      const PlanNodePtr& plan,
+      const std::vector<std::shared_ptr<TempFilePath>>& filePaths,
+      const std::string& spillDirectory,
+      const std::string& duckDbSql) {
+    return AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .spillDirectory(spillDirectory)
+        .config(core::QueryConfig::kSpillEnabled, true)
+        .config(core::QueryConfig::kAggregationSpillEnabled, true)
+        .splits(makeHiveConnectorSplits(filePaths))
+        .assertResults(duckDbSql);
+  }
+
   core::PlanNodePtr tableScanNode() {
     return tableScanNode(rowType_);
   }
@@ -141,14 +185,16 @@ class TableScanTest : public virtual HiveConnectorTestBase {
                      .build();
     auto outputType =
         ROW({"pkey", "c0", "c1"}, {partitionType, BIGINT(), DOUBLE()});
-    auto tableHandle = makeTableHandle();
     ColumnHandleMap assignments = {
         {"pkey", partitionKey("pkey", partitionType)},
         {"c0", regularColumn("c0", BIGINT())},
         {"c1", regularColumn("c1", DOUBLE())}};
 
     auto op = PlanBuilder()
-                  .tableScan(outputType, tableHandle, assignments)
+                  .startTableScan()
+                  .outputType(outputType)
+                  .assignments(assignments)
+                  .endTableScan()
                   .planNode();
 
     std::string partitionValueStr =
@@ -158,7 +204,10 @@ class TableScanTest : public virtual HiveConnectorTestBase {
 
     outputType = ROW({"c0", "pkey", "c1"}, {BIGINT(), partitionType, DOUBLE()});
     op = PlanBuilder()
-             .tableScan(outputType, tableHandle, assignments)
+             .startTableScan()
+             .outputType(outputType)
+             .assignments(assignments)
+             .endTableScan()
              .planNode();
     assertQuery(
         op,
@@ -166,7 +215,10 @@ class TableScanTest : public virtual HiveConnectorTestBase {
         fmt::format("SELECT c0, {}, c1 FROM tmp", partitionValueStr));
     outputType = ROW({"c0", "c1", "pkey"}, {BIGINT(), DOUBLE(), partitionType});
     op = PlanBuilder()
-             .tableScan(outputType, tableHandle, assignments)
+             .startTableScan()
+             .outputType(outputType)
+             .assignments(assignments)
+             .endTableScan()
              .planNode();
     assertQuery(
         op,
@@ -177,7 +229,10 @@ class TableScanTest : public virtual HiveConnectorTestBase {
     assignments = {{"pkey", partitionKey("pkey", partitionType)}};
     outputType = ROW({"pkey"}, {partitionType});
     op = PlanBuilder()
-             .tableScan(outputType, tableHandle, assignments)
+             .startTableScan()
+             .outputType(outputType)
+             .assignments(assignments)
+             .endTableScan()
              .planNode();
     assertQuery(
         op, split, fmt::format("SELECT {} FROM tmp", partitionValueStr));
@@ -205,7 +260,7 @@ class TableScanTest : public virtual HiveConnectorTestBase {
 TEST_F(TableScanTest, allColumns) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   auto plan = tableScanNode();
@@ -218,7 +273,58 @@ TEST_F(TableScanTest, allColumns) {
   auto it = planStats.find(scanNodeId);
   ASSERT_TRUE(it != planStats.end());
   ASSERT_TRUE(it->second.peakMemoryBytes > 0);
-  EXPECT_LT(0, exec::TableScan::ioWaitNanos());
+  ASSERT_LT(0, it->second.customStats.at("ioWaitWallNanos").sum);
+  // Verifies there is no dynamic filter stats.
+  ASSERT_TRUE(it->second.dynamicFilterStats.empty());
+}
+
+TEST_F(TableScanTest, directBufferInputRawInputBytes) {
+  constexpr int kSize = 10;
+  auto vector = makeRowVector({
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeFlatVector<int64_t>(kSize, folly::identity),
+  });
+  auto filePath = TempFilePath::create();
+  createDuckDbTable({vector});
+  writeToFile(filePath->getPath(), {vector});
+
+  auto plan = PlanBuilder(pool_.get())
+                  .startTableScan()
+                  .outputType(ROW({"c0", "c2"}, {BIGINT(), BIGINT()}))
+                  .endTableScan()
+                  .planNode();
+
+  std::unordered_map<std::string, std::string> config;
+  std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
+      connectorConfigs = {};
+  auto queryCtx = core::QueryCtx::create(
+      executor_.get(),
+      core::QueryConfig(std::move(config)),
+      connectorConfigs,
+      nullptr);
+
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .plan(plan)
+                  .splits(makeHiveConnectorSplits({filePath}))
+                  .queryCtx(queryCtx)
+                  .assertResults("SELECT c0, c2 FROM tmp");
+
+  // A quick sanity check for memory usage reporting. Check that peak total
+  // memory usage for the project node is > 0.
+  auto planStats = toPlanStats(task->taskStats());
+  auto scanNodeId = plan->id();
+  auto it = planStats.find(scanNodeId);
+  ASSERT_TRUE(it != planStats.end());
+  auto rawInputBytes = it->second.rawInputBytes;
+  auto overreadBytes = getTableScanRuntimeStats(task).at("overreadBytes").sum;
+  ASSERT_GE(rawInputBytes, 500);
+  ASSERT_EQ(overreadBytes, 13);
+  ASSERT_EQ(
+      getTableScanRuntimeStats(task).at("storageReadBytes").sum,
+      rawInputBytes + overreadBytes);
+  ASSERT_GT(getTableScanRuntimeStats(task)["totalScanTime"].sum, 0);
+  ASSERT_GT(getTableScanRuntimeStats(task)["ioWaitWallNanos"].sum, 0);
 }
 
 TEST_F(TableScanTest, connectorStats) {
@@ -231,7 +337,7 @@ TEST_F(TableScanTest, connectorStats) {
   for (size_t i = 0; i < 99; i++) {
     auto vectors = makeVectors(10, 10);
     auto filePath = TempFilePath::create();
-    writeToFile(filePath->path, vectors);
+    writeToFile(filePath->getPath(), vectors);
     createDuckDbTable(vectors);
     auto plan = tableScanNode();
     assertQuery(plan, {filePath}, "SELECT * FROM tmp");
@@ -244,26 +350,40 @@ TEST_F(TableScanTest, connectorStats) {
 TEST_F(TableScanTest, columnAliases) {
   auto vectors = makeVectors(1, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   std::string tableName = "t";
   std::unordered_map<std::string, std::string> aliases = {{"a", "c0"}};
   auto outputType = ROW({"a"}, {BIGINT()});
   auto op = PlanBuilder(pool_.get())
-                .tableScan(tableName, outputType, aliases)
+                .startTableScan()
+                .tableName(tableName)
+                .outputType(outputType)
+                .columnAliases(aliases)
+                .endTableScan()
                 .planNode();
   assertQuery(op, {filePath}, "SELECT c0 FROM tmp");
 
   // Use aliased column in a range filter.
   op = PlanBuilder(pool_.get())
-           .tableScan(tableName, outputType, aliases, {"a < 10"})
+           .startTableScan()
+           .tableName(tableName)
+           .outputType(outputType)
+           .columnAliases(aliases)
+           .subfieldFilter("a < 10")
+           .endTableScan()
            .planNode();
   assertQuery(op, {filePath}, "SELECT c0 FROM tmp WHERE c0 <= 10");
 
   // Use aliased column in remaining filter.
   op = PlanBuilder(pool_.get())
-           .tableScan(tableName, outputType, aliases, {}, "a % 2 = 1")
+           .startTableScan()
+           .tableName(tableName)
+           .outputType(outputType)
+           .columnAliases(aliases)
+           .remainingFilter("a % 2 = 1")
+           .endTableScan()
            .planNode();
   assertQuery(op, {filePath}, "SELECT c0 FROM tmp WHERE c0 % 2 = 1");
 }
@@ -271,20 +391,23 @@ TEST_F(TableScanTest, columnAliases) {
 TEST_F(TableScanTest, partitionKeyAlias) {
   auto vectors = makeVectors(1, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   ColumnHandleMap assignments = {
       {"a", regularColumn("c0", BIGINT())},
       {"ds_alias", partitionKey("ds", VARCHAR())}};
 
-  auto split = HiveConnectorSplitBuilder(filePath->path)
+  auto split = HiveConnectorSplitBuilder(filePath->getPath())
                    .partitionKey("ds", "2021-12-02")
                    .build();
 
   auto outputType = ROW({"a", "ds_alias"}, {BIGINT(), VARCHAR()});
   auto op = PlanBuilder()
-                .tableScan(outputType, makeTableHandle(), assignments)
+                .startTableScan()
+                .outputType(outputType)
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
 
   assertQuery(op, split, "SELECT c0, '2021-12-02' FROM tmp");
@@ -293,7 +416,7 @@ TEST_F(TableScanTest, partitionKeyAlias) {
 TEST_F(TableScanTest, columnPruning) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   auto op = tableScanNode(ROW({"c0"}, {BIGINT()}));
@@ -330,7 +453,7 @@ TEST_F(TableScanTest, timestamp) {
            })});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {rowVector});
+  writeToFile(filePath->getPath(), {rowVector});
   createDuckDbTable({rowVector});
 
   auto dataColumns = ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()});
@@ -338,20 +461,20 @@ TEST_F(TableScanTest, timestamp) {
   assertQuery(op, {filePath}, "SELECT c0, c1 FROM tmp");
 
   op = PlanBuilder(pool_.get())
-           .tableScan(
-               ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()}),
-               {"c1 is null"},
-               "",
-               dataColumns)
+           .startTableScan()
+           .outputType(ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()}))
+           .subfieldFilter("c1 is null")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .planNode();
   assertQuery(op, {filePath}, "SELECT c0, c1 FROM tmp WHERE c1 is null");
 
   op = PlanBuilder(pool_.get())
-           .tableScan(
-               ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()}),
-               {"c1 < '1970-01-01 01:30:00'::TIMESTAMP"},
-               "",
-               dataColumns)
+           .startTableScan()
+           .outputType(ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()}))
+           .subfieldFilter("c1 < '1970-01-01 01:30:00'::TIMESTAMP")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .planNode();
   assertQuery(
       op,
@@ -359,21 +482,28 @@ TEST_F(TableScanTest, timestamp) {
       "SELECT c0, c1 FROM tmp WHERE c1 < timestamp '1970-01-01 01:30:00'");
 
   op = PlanBuilder(pool_.get())
-           .tableScan(ROW({"c0"}, {BIGINT()}), {}, "", dataColumns)
+           .startTableScan()
+           .outputType(ROW({"c0"}, {BIGINT()}))
+           .dataColumns(dataColumns)
+           .endTableScan()
            .planNode();
   assertQuery(op, {filePath}, "SELECT c0 FROM tmp");
 
   op = PlanBuilder(pool_.get())
-           .tableScan(ROW({"c0"}, {BIGINT()}), {"c1 is null"}, "", dataColumns)
+           .startTableScan()
+           .outputType(ROW({"c0"}, {BIGINT()}))
+           .subfieldFilter("c1 is null")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .planNode();
   assertQuery(op, {filePath}, "SELECT c0 FROM tmp WHERE c1 is null");
 
   op = PlanBuilder(pool_.get())
-           .tableScan(
-               ROW({"c0"}, {BIGINT()}),
-               {"c1 < timestamp'1970-01-01 01:30:00'"},
-               "",
-               dataColumns)
+           .startTableScan()
+           .outputType(ROW({"c0"}, {BIGINT()}))
+           .subfieldFilter("c1 < timestamp'1970-01-01 01:30:00'")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .planNode();
   assertQuery(
       op,
@@ -381,13 +511,115 @@ TEST_F(TableScanTest, timestamp) {
       "SELECT c0 FROM tmp WHERE c1 < timestamp'1970-01-01 01:30:00'");
 }
 
+TEST_F(TableScanTest, timestampPrecisionDefaultMillisecond) {
+  constexpr int kSize = 10;
+  auto vector = makeRowVector({
+      makeFlatVector<Timestamp>(
+          kSize, [](auto i) { return Timestamp(i, i * 1'001'001); }),
+  });
+  auto schema = asRowType(vector->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  auto split = makeHiveConnectorSplit(file->getPath());
+
+  auto plan = PlanBuilder().tableScan(schema).planNode();
+  auto expected = makeRowVector({
+      makeFlatVector<Timestamp>(
+          kSize, [](auto i) { return Timestamp(i, i * 1'000'000); }),
+  });
+  AssertQueryBuilder(plan).split(split).assertResults(expected);
+
+  plan = PlanBuilder(pool_.get())
+             .tableScan(schema, {"c0 = timestamp '1970-01-01 00:00:01.001'"})
+             .planNode();
+  expected = makeRowVector({
+      makeFlatVector<Timestamp>(
+          1, [](auto) { return Timestamp(1, 1'000'000); }),
+  });
+  AssertQueryBuilder(plan).split(split).assertResults(expected);
+}
+
+DEBUG_ONLY_TEST_F(TableScanTest, timeLimitInGetOutput) {
+  // Create two different row vectors: with some nulls and with no nulls.
+  vector_size_t numRows = 100;
+  auto tsFunc = [](vector_size_t row) {
+    return Timestamp(row, (row % 10) * Timestamp::kNanosecondsInMillisecond);
+  };
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int64_t>(numRows, [](vector_size_t row) { return row; }),
+       makeFlatVector<Timestamp>(numRows, tsFunc, [](vector_size_t row) {
+         return row % 5 == 0; /* null every 5 rows */
+       })});
+  auto rowVectorNoNulls = makeRowVector(
+      {makeFlatVector<int64_t>(numRows, [](vector_size_t row) { return row; }),
+       makeFlatVector<Timestamp>(numRows, tsFunc)});
+
+  // Prepare the data files and tables with 2/3 of them having no null row
+  // vector.
+  const size_t numFiles{20};
+  std::vector<std::shared_ptr<TempFilePath>> filePaths;
+  std::vector<RowVectorPtr> vectorsForDuckDb;
+  filePaths.reserve(numFiles);
+  vectorsForDuckDb.reserve(numFiles);
+  for (auto i = 0; i < numFiles; ++i) {
+    filePaths.emplace_back(TempFilePath::create());
+    const auto& vec = (i % 3 == 0) ? rowVector : rowVectorNoNulls;
+    writeToFile(filePaths.back()->getPath(), vec);
+    vectorsForDuckDb.emplace_back(vec);
+  }
+  createDuckDbTable(vectorsForDuckDb);
+
+  // Scan with filter. The filter ensures we filter ALL rows from the splits
+  // with no nulls, thus ending up with an empty result set for such splits.
+  auto dataColumns = ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()});
+  const size_t tableScanGetOutputTimeLimitMs{100};
+  auto plan = PlanBuilder(pool_.get())
+                  .startTableScan()
+                  .outputType(ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()}))
+                  .subfieldFilter("c1 is null")
+                  .dataColumns(dataColumns)
+                  .endTableScan()
+                  .planNode();
+
+  // Ensure the getOutput is long enough to trigger the maxGetOutputTimeMs in
+  // TableScan, so we can test early exit (bail) from the TableScan::getOutput.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::TableScan::getOutput",
+      std::function<void(const TableScan*)>(
+          ([&](const TableScan* /*tableScan*/) {
+            /* sleep override */
+            std::this_thread::sleep_for(
+                std::chrono::milliseconds(tableScanGetOutputTimeLimitMs));
+          })));
+
+  // Count how many times we bailed from getOutput.
+  size_t numBailed{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::TableScan::getOutput::yield",
+      std::function<void(const TableScan*)>(
+          ([&](const TableScan* /*tableScan*/) { ++numBailed; })));
+
+  // Ensure query runs correctly with bails.
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .plan(plan)
+      .splits(makeHiveConnectorSplits(filePaths))
+      .config(
+          QueryConfig::kTableScanGetOutputTimeLimitMs,
+          folly::to<std::string>(tableScanGetOutputTimeLimitMs))
+      .assertResults("SELECT c0, c1 FROM tmp WHERE c1 is null");
+
+  // We should have at least 12 splits (20/3*2) producing empty results and
+  // after each of them we should bail thanks to our 'sleep' injection.
+  EXPECT_GE(numBailed, 12);
+}
+
 TEST_F(TableScanTest, subfieldPruningRowType) {
   auto innerType = ROW({"a", "b"}, {BIGINT(), DOUBLE()});
   auto columnType = ROW({"c", "d"}, {innerType, BIGINT()});
   auto rowType = ROW({"e"}, {columnType});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   std::vector<common::Subfield> requiredSubfields;
   requiredSubfields.emplace_back("e.c");
   std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
@@ -399,9 +631,12 @@ TEST_F(TableScanTest, subfieldPruningRowType) {
       columnType,
       std::move(requiredSubfields));
   auto op = PlanBuilder()
-                .tableScan(rowType, makeTableHandle(), assignments)
+                .startTableScan()
+                .outputType(rowType)
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
   ASSERT_EQ(result->size(), 10'000);
   auto rows = result->as<RowVector>();
@@ -439,7 +674,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterSubfieldsMissing) {
   auto rowType = ROW({"e"}, {columnType});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   std::vector<common::Subfield> requiredSubfields;
   requiredSubfields.emplace_back("e.c");
   std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
@@ -452,13 +687,13 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterSubfieldsMissing) {
       std::move(requiredSubfields));
 
   auto op = PlanBuilder()
-                .tableScan(
-                    rowType,
-                    makeTableHandle(
-                        SubfieldFilters{}, parseExpr("e.a is null", rowType)),
-                    assignments)
+                .startTableScan()
+                .outputType(rowType)
+                .remainingFilter("e.a is null")
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
 
   auto rows = result->as<RowVector>();
@@ -478,20 +713,20 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterRootFieldMissing) {
   auto rowType = ROW({"d", "e"}, {BIGINT(), columnType});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
       assignments;
   assignments["d"] = std::make_shared<HiveColumnHandle>(
       "d", HiveColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
   auto op = PlanBuilder()
-                .tableScan(
-                    ROW({{"d", BIGINT()}}),
-                    makeTableHandle(
-                        SubfieldFilters{},
-                        parseExpr("e.a is null or e.b is null", rowType)),
-                    assignments)
+                .startTableScan()
+                .outputType(ROW({{"d", BIGINT()}}))
+                .remainingFilter("e.a is null or e.b is null")
+                .dataColumns(rowType)
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
   auto rows = result->as<RowVector>();
   ASSERT_TRUE(rows);
@@ -515,7 +750,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterStruct) {
   auto rowType = ROW({"c", "d"}, {structType, BIGINT()});
   auto vectors = makeVectors(3, 10, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   enum { kNoOutput = 0, kWholeColumn = 1, kSubfieldOnly = 2 };
   for (int outputColumn = kNoOutput; outputColumn <= kSubfieldOnly;
        ++outputColumn) {
@@ -538,22 +773,24 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterStruct) {
             structType,
             std::move(subfields));
       }
-      core::TypedExprPtr remainingFilter;
+      std::string remainingFilter;
       if (filterColumn == kWholeColumn) {
-        remainingFilter = parseExpr(
-            "coalesce(c, cast(null AS ROW(a BIGINT, b BIGINT))).a % 2 == 0",
-            rowType);
+        remainingFilter =
+            "coalesce(c, cast(null AS ROW(a BIGINT, b BIGINT))).a % 2 == 0";
       } else {
-        remainingFilter = parseExpr("c.a % 2 == 0", rowType);
+        remainingFilter = "c.a % 2 == 0";
       }
       auto op =
           PlanBuilder()
-              .tableScan(
-                  outputColumn == kNoOutput ? ROW({"d"}, {BIGINT()}) : rowType,
-                  makeTableHandle(SubfieldFilters{}, remainingFilter),
-                  assignments)
+              .startTableScan()
+              .outputType(
+                  outputColumn == kNoOutput ? ROW({"d"}, {BIGINT()}) : rowType)
+              .remainingFilter(remainingFilter)
+              .dataColumns(rowType)
+              .assignments(assignments)
+              .endTableScan()
               .planNode();
-      auto split = makeHiveConnectorSplit(filePath->path);
+      auto split = makeHiveConnectorSplit(filePath->getPath());
       auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
       int expectedSize = 0;
       std::vector<std::vector<BaseVector::CopyRange>> ranges;
@@ -599,7 +836,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterMap) {
       {"a", "b"}, {makeFlatVector<int64_t>(10, folly::identity), mapVector});
   auto rowType = asRowType(vector->type());
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {vector});
+  writeToFile(filePath->getPath(), {vector});
   enum { kNoOutput = 0, kWholeColumn = 1, kSubfieldOnly = 2 };
   for (int outputColumn = kNoOutput; outputColumn <= kSubfieldOnly;
        ++outputColumn) {
@@ -622,21 +859,24 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterMap) {
             mapType,
             std::move(subfields));
       }
-      core::TypedExprPtr remainingFilter;
+      std::string remainingFilter;
       if (filterColumn == kWholeColumn) {
-        remainingFilter = parseExpr(
-            "coalesce(b, cast(null AS MAP(BIGINT, BIGINT)))[0] == 0", rowType);
+        remainingFilter =
+            "coalesce(b, cast(null AS MAP(BIGINT, BIGINT)))[0] == 0";
       } else {
-        remainingFilter = parseExpr("b[0] == 0", rowType);
+        remainingFilter = "b[0] == 0";
       }
       auto op =
           PlanBuilder()
-              .tableScan(
-                  outputColumn == kNoOutput ? ROW({"a"}, {BIGINT()}) : rowType,
-                  makeTableHandle(SubfieldFilters{}, remainingFilter),
-                  assignments)
+              .startTableScan()
+              .outputType(
+                  outputColumn == kNoOutput ? ROW({"a"}, {BIGINT()}) : rowType)
+              .remainingFilter(remainingFilter)
+              .dataColumns(rowType)
+              .assignments(assignments)
+              .endTableScan()
               .planNode();
-      auto split = makeHiveConnectorSplit(filePath->path);
+      auto split = makeHiveConnectorSplit(filePath->getPath());
       auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
       auto expected = vector;
       auto a = vector->as<RowVector>()->childAt(0);
@@ -698,7 +938,7 @@ TEST_F(TableScanTest, subfieldPruningMapType) {
   }
   auto rowType = asRowType(vectors[0]->type());
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   std::vector<common::Subfield> requiredSubfields;
   requiredSubfields.emplace_back("c[0]");
   requiredSubfields.emplace_back("c[2]");
@@ -712,9 +952,12 @@ TEST_F(TableScanTest, subfieldPruningMapType) {
       mapType,
       std::move(requiredSubfields));
   auto op = PlanBuilder()
-                .tableScan(rowType, makeTableHandle(), assignments)
+                .startTableScan()
+                .outputType(rowType)
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
   ASSERT_EQ(result->size(), vectors.size() * kSize);
   auto rows = result->as<RowVector>();
@@ -770,7 +1013,7 @@ TEST_F(TableScanTest, subfieldPruningArrayType) {
   }
   auto rowType = asRowType(vectors[0]->type());
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   std::vector<common::Subfield> requiredSubfields;
   requiredSubfields.emplace_back("c[3]");
   std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
@@ -782,9 +1025,12 @@ TEST_F(TableScanTest, subfieldPruningArrayType) {
       arrayType,
       std::move(requiredSubfields));
   auto op = PlanBuilder()
-                .tableScan(rowType, makeTableHandle(), assignments)
+                .startTableScan()
+                .outputType(rowType)
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
   ASSERT_EQ(result->size(), vectors.size() * kSize);
   auto rows = result->as<RowVector>();
@@ -811,13 +1057,26 @@ TEST_F(TableScanTest, subfieldPruningArrayType) {
   }
 }
 
+TEST_F(TableScanTest, skipNullMapKeys) {
+  auto vector = makeRowVector({makeMapVector(
+      {0, 2},
+      makeNullableFlatVector<int64_t>({std::nullopt, 2}),
+      makeFlatVector<int64_t>({1, 2}))});
+  auto rowType = asRowType(vector->type());
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), {vector});
+  auto plan = PlanBuilder().tableScan(rowType).planNode();
+  auto split = makeHiveConnectorSplit(filePath->getPath());
+  auto expected = makeRowVector({makeMapVector(
+      {0, 1},
+      makeNullableFlatVector(std::vector<std::optional<int64_t>>(1, 2)),
+      makeFlatVector(std::vector<int64_t>(1, 2)))});
+  AssertQueryBuilder(plan).split(split).assertResults(expected);
+}
+
 // Test reading files written before schema change, e.g. missing newly added
 // columns.
 TEST_F(TableScanTest, missingColumns) {
-  // Disable preload so that we test one single data source.
-  auto oldSplitPreload = FLAGS_split_preload_per_driver;
-  FLAGS_split_preload_per_driver = 0;
-
   // Simulate schema change of adding a new column.
   // Create even files (old) with one column, odd ones (new) with two columns.
   const vector_size_t size = 1'000;
@@ -836,7 +1095,7 @@ TEST_F(TableScanTest, missingColumns) {
               size, [&](auto row) { return row * 0.1 + i * size; }),
       }));
     }
-    writeToFile(filePaths[i]->path, {rows.back()});
+    writeToFile(filePaths[i]->getPath(), {rows.back()});
   }
 
   // For duckdb ensure we have nulls for the missing column.
@@ -854,34 +1113,57 @@ TEST_F(TableScanTest, missingColumns) {
   auto outputTypeC0 = ROW({"c0"}, {BIGINT()});
 
   auto op = PlanBuilder(pool_.get())
-                .tableScan(outputType, {}, "", dataColumns)
+                .startTableScan()
+                .outputType(outputType)
+                .dataColumns(dataColumns)
+                .endTableScan()
                 .planNode();
-  assertQuery(op, filePaths, "SELECT * FROM tmp");
+  // Disable preload so that we test one single data source.
+  assertQuery(op, filePaths, "SELECT * FROM tmp", 0);
 
   // Use missing column in a tuple domain filter.
   op = PlanBuilder(pool_.get())
-           .tableScan(outputType, {"c1 <= 100.1"}, "", dataColumns)
+           .startTableScan()
+           .outputType(outputType)
+           .subfieldFilter("c1 <= 100.1")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .planNode();
-  assertQuery(op, filePaths, "SELECT * FROM tmp WHERE c1 <= 100.1");
+  assertQuery(op, filePaths, "SELECT * FROM tmp WHERE c1 <= 100.1", 0);
 
   // Use missing column in a tuple domain filter. Select *.
   op = PlanBuilder(pool_.get())
-           .tableScan(outputType, {"c1 <= 2000.1"}, "", dataColumns)
+           .startTableScan()
+           .outputType(outputType)
+           .subfieldFilter("c1 <= 2000.1")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .planNode();
-  assertQuery(op, filePaths, "SELECT * FROM tmp WHERE c1 <= 2000.1");
+
+  assertQuery(op, filePaths, "SELECT * FROM tmp WHERE c1 <= 2000.1", 0);
 
   // Use missing column in a tuple domain filter. Select c0.
   op = PlanBuilder(pool_.get())
-           .tableScan(outputTypeC0, {"c1 <= 3000.1"}, "", dataColumns)
+           .startTableScan()
+           .outputType(outputTypeC0)
+           .subfieldFilter("c1 <= 3000.1")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .planNode();
-  assertQuery(op, filePaths, "SELECT c0 FROM tmp WHERE c1 <= 3000.1");
+
+  assertQuery(op, filePaths, "SELECT c0 FROM tmp WHERE c1 <= 3000.1", 0);
 
   // Use missing column in a tuple domain filter. Select count(*).
   op = PlanBuilder(pool_.get())
-           .tableScan(ROW({}, {}), {"c1 <= 4000.1"}, "", dataColumns)
+           .startTableScan()
+           .outputType(ROW({}, {}))
+           .subfieldFilter("c1 <= 4000.1")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .singleAggregation({}, {"count(1)"})
            .planNode();
-  assertQuery(op, filePaths, "SELECT count(*) FROM tmp WHERE c1 <= 4000.1");
+
+  assertQuery(op, filePaths, "SELECT count(*) FROM tmp WHERE c1 <= 4000.1", 0);
 
   // Use missing column 'c1' in 'is null' filter, while not selecting 'c1'.
   SubfieldFilters filters;
@@ -891,17 +1173,26 @@ TEST_F(TableScanTest, missingColumns) {
   ColumnHandleMap assignments;
   assignments["c0"] = regularColumn("c0", BIGINT());
   op = PlanBuilder(pool_.get())
-           .tableScan(outputTypeC0, tableHandle, assignments)
+           .startTableScan()
+           .outputType(outputTypeC0)
+           .tableHandle(tableHandle)
+           .assignments(assignments)
+           .endTableScan()
            .planNode();
   assertQuery(
-      op, filePaths, "SELECT c0 FROM tmp WHERE c1 is null or c1 <= 1050.0");
+      op, filePaths, "SELECT c0 FROM tmp WHERE c1 is null or c1 <= 1050.0", 0);
 
   // Use missing column 'c1' in 'is null' filter, while not selecting anything.
   op = PlanBuilder(pool_.get())
-           .tableScan(ROW({}, {}), {"c1 is null"}, "", dataColumns)
+           .startTableScan()
+           .outputType(ROW({}, {}))
+           .subfieldFilter("c1 is null")
+           .dataColumns(dataColumns)
+           .endTableScan()
            .singleAggregation({}, {"count(1)"})
            .planNode();
-  assertQuery(op, filePaths, "SELECT count(*) FROM tmp WHERE c1 is null");
+
+  assertQuery(op, filePaths, "SELECT count(*) FROM tmp WHERE c1 is null", 0);
 
   // Use column aliases.
   outputType = ROW({"a", "b"}, {BIGINT(), DOUBLE()});
@@ -910,14 +1201,63 @@ TEST_F(TableScanTest, missingColumns) {
   assignments["a"] = regularColumn("c0", BIGINT());
   assignments["b"] = regularColumn("c1", DOUBLE());
 
-  tableHandle = makeTableHandle({}, nullptr, "hive_table", dataColumns);
-
   op = PlanBuilder(pool_.get())
-           .tableScan(outputType, tableHandle, assignments)
+           .startTableScan()
+           .outputType(outputType)
+           .dataColumns(dataColumns)
+           .assignments(assignments)
+           .endTableScan()
            .planNode();
-  assertQuery(op, filePaths, "SELECT * FROM tmp");
 
-  FLAGS_split_preload_per_driver = oldSplitPreload;
+  assertQuery(op, filePaths, "SELECT * FROM tmp", 0);
+}
+
+TEST_F(TableScanTest, missingColumnsInRepeatedColumns) {
+  constexpr int kSize = 10;
+  auto bigints = makeFlatVector<int64_t>(kSize, folly::identity);
+  auto structs =
+      makeRowVector({makeFlatVector<int64_t>(kSize, folly::identity)});
+  std::vector<vector_size_t> offsets(kSize);
+  std::iota(offsets.begin(), offsets.end(), 0);
+  auto vector = makeRowVector({
+      bigints,
+      makeArrayVector(offsets, structs),
+      makeMapVector(offsets, bigints, structs),
+  });
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  auto structType = ROW({"c0", "c1"}, {BIGINT(), BIGINT()});
+  auto c1Type = ARRAY(structType);
+  auto c2Type = MAP(BIGINT(), structType);
+  auto plan = PlanBuilder()
+                  .tableScan(
+                      ROW({"c1", "c2"}, {c1Type, c2Type}),
+                      {},
+                      "c0 % 2 = 0",
+                      ROW({"c0", "c1", "c2"}, {BIGINT(), c1Type, c2Type}))
+                  .planNode();
+  auto structs2 = makeRowVector({
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeNullConstant(TypeKind::BIGINT, kSize),
+  });
+  auto indices = makeIndices(kSize, [](auto i) {
+    auto index = 2 * i;
+    if (index >= kSize) {
+      index -= kSize;
+    }
+    return index;
+  });
+  auto expected = makeRowVector(
+      {"c1", "c2"},
+      {
+          wrapInDictionary(indices, makeArrayVector(offsets, structs2)),
+          wrapInDictionary(indices, makeMapVector(offsets, bigints, structs2)),
+      });
+  AssertQueryBuilder(plan)
+      .splits(
+          {makeHiveConnectorSplit(file->getPath()),
+           makeHiveConnectorSplit(file->getPath())})
+      .assertResults(expected);
 }
 
 // Tests queries that use Lazy vectors with multiple layers of wrapping.
@@ -933,7 +1273,7 @@ TEST_F(TableScanTest, constDictLazy) {
            [](auto row) { return row * 0.1; })});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {rowVector});
+  writeToFile(filePath->getPath(), {rowVector});
 
   createDuckDbTable({rowVector});
 
@@ -942,7 +1282,10 @@ TEST_F(TableScanTest, constDictLazy) {
   // Orchestrate a Const(Dict(Lazy)) by using remaining filter that passes on
   // exactly one row.
   auto op = PlanBuilder()
-                .tableScan(rowType, {}, "c0 % 1000 = 5")
+                .startTableScan()
+                .outputType(rowType)
+                .remainingFilter("c0 % 1000 = 5")
+                .endTableScan()
                 .project({"c1 + 10"})
                 .planNode();
 
@@ -950,14 +1293,20 @@ TEST_F(TableScanTest, constDictLazy) {
 
   // Orchestrate a Const(Dict(Lazy)) for a complex type (map)
   op = PlanBuilder()
-           .tableScan(rowType, {}, "c0 = 0")
+           .startTableScan()
+           .outputType(rowType)
+           .remainingFilter("c0 = 0")
+           .endTableScan()
            .project({"cardinality(c2)"})
            .planNode();
 
   assertQuery(op, {filePath}, "SELECT 0 FROM tmp WHERE c0 = 5");
 
   op = PlanBuilder()
-           .tableScan(rowType, {}, "c0 = 2")
+           .startTableScan()
+           .outputType(rowType)
+           .remainingFilter("c0 = 2")
+           .endTableScan()
            .project({"cardinality(c2)"})
            .planNode();
 
@@ -967,14 +1316,14 @@ TEST_F(TableScanTest, constDictLazy) {
 TEST_F(TableScanTest, count) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
 
   CursorParameters params;
   params.planNode = tableScanNode(ROW({}, {}));
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
 
-  cursor->task()->addSplit("0", makeHiveSplit(filePath->path));
+  cursor->task()->addSplit("0", makeHiveSplit(filePath->getPath()));
   cursor->task()->noMoreSplits("0");
 
   int32_t numRead = 0;
@@ -1006,7 +1355,7 @@ TEST_F(TableScanTest, batchSize) {
   auto vector = makeVectors(1, numRows, rowType);
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vector);
+  writeToFile(filePath->getPath(), vector);
 
   createDuckDbTable(vector);
 
@@ -1066,19 +1415,19 @@ TEST_F(TableScanTest, batchSize) {
 TEST_F(TableScanTest, sequentialSplitNoDoubleRead) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
 
   CursorParameters params;
   params.planNode = tableScanNode(ROW({}, {}));
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   // Add the same split with the same sequence id twice. The second should be
   // ignored.
   EXPECT_TRUE(cursor->task()->addSplitWithSequence(
-      "0", makeHiveSplit(filePath->path), 0));
+      "0", makeHiveSplit(filePath->getPath()), 0));
   cursor->task()->setMaxSplitSequenceId("0", 0);
   EXPECT_FALSE(cursor->task()->addSplitWithSequence(
-      "0", makeHiveSplit(filePath->path), 0));
+      "0", makeHiveSplit(filePath->getPath()), 0));
   cursor->task()->noMoreSplits("0");
 
   int32_t numRead = 0;
@@ -1096,18 +1445,18 @@ TEST_F(TableScanTest, sequentialSplitNoDoubleRead) {
 TEST_F(TableScanTest, outOfOrderSplits) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
 
   CursorParameters params;
   params.planNode = tableScanNode(ROW({}, {}));
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
 
   // Add splits out of order (1, 0). Both of them should be processed.
   EXPECT_TRUE(cursor->task()->addSplitWithSequence(
-      "0", makeHiveSplit(filePath->path), 1));
+      "0", makeHiveSplit(filePath->getPath()), 1));
   EXPECT_TRUE(cursor->task()->addSplitWithSequence(
-      "0", makeHiveSplit(filePath->path), 0));
+      "0", makeHiveSplit(filePath->getPath()), 0));
   cursor->task()->setMaxSplitSequenceId("0", 1);
   cursor->task()->noMoreSplits("0");
 
@@ -1126,17 +1475,17 @@ TEST_F(TableScanTest, outOfOrderSplits) {
 TEST_F(TableScanTest, splitDoubleRead) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
 
   CursorParameters params;
   params.planNode = tableScanNode(ROW({}, {}));
 
   for (size_t i = 0; i < 2; ++i) {
-    auto cursor = std::make_unique<TaskCursor>(params);
+    auto cursor = TaskCursor::create(params);
 
     // Add the same split twice - we should read twice the size.
-    cursor->task()->addSplit("0", makeHiveSplit(filePath->path));
-    cursor->task()->addSplit("0", makeHiveSplit(filePath->path));
+    cursor->task()->addSplit("0", makeHiveSplit(filePath->getPath()));
+    cursor->task()->addSplit("0", makeHiveSplit(filePath->getPath()));
     cursor->task()->noMoreSplits("0");
 
     int32_t numRead = 0;
@@ -1154,15 +1503,15 @@ TEST_F(TableScanTest, multipleSplits) {
   std::vector<int32_t> numPrefetchSplits = {0, 2};
   for (const auto& numPrefetchSplit : numPrefetchSplits) {
     SCOPED_TRACE(fmt::format("numPrefetchSplit {}", numPrefetchSplit));
-    FLAGS_split_preload_per_driver = numPrefetchSplit;
     auto filePaths = makeFilePaths(100);
     auto vectors = makeVectors(100, 100);
     for (int32_t i = 0; i < vectors.size(); i++) {
-      writeToFile(filePaths[i]->path, vectors[i]);
+      writeToFile(filePaths[i]->getPath(), vectors[i]);
     }
     createDuckDbTable(vectors);
 
-    auto task = assertQuery(tableScanNode(), filePaths, "SELECT * FROM tmp");
+    auto task = assertQuery(
+        tableScanNode(), filePaths, "SELECT * FROM tmp", numPrefetchSplit);
     auto stats = getTableScanRuntimeStats(task);
     if (numPrefetchSplit != 0) {
       ASSERT_GT(stats.at("preloadedSplits").sum, 10);
@@ -1172,11 +1521,47 @@ TEST_F(TableScanTest, multipleSplits) {
   }
 }
 
+TEST_F(TableScanTest, preloadingSplitClose) {
+  auto filePaths = makeFilePaths(100);
+  auto vectors = makeVectors(100, 100);
+  for (int32_t i = 0; i < vectors.size(); i++) {
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
+  }
+  createDuckDbTable(vectors);
+
+  auto executors = ioExecutor_.get();
+  folly::Latch latch(executors->numThreads());
+  std::vector<folly::Baton<>> batons(executors->numThreads());
+  // Simulate a busy IO thread pool by blocking all threads.
+  for (auto& baton : batons) {
+    executors->add([&]() {
+      baton.wait();
+      latch.count_down();
+    });
+  }
+  ASSERT_EQ(Task::numCreatedTasks(), Task::numDeletedTasks());
+  auto task = assertQuery(tableScanNode(), filePaths, "SELECT * FROM tmp", 2);
+  auto stats = getTableScanRuntimeStats(task);
+
+  // Verify that split preloading is enabled.
+  ASSERT_GT(stats.at("preloadedSplits").sum, 1);
+
+  task.reset();
+  // Once all task references are cleared, the count of deleted tasks should
+  // promptly match the count of created tasks.
+  ASSERT_EQ(Task::numCreatedTasks(), Task::numDeletedTasks());
+  // Clean blocking items in the IO thread pool.
+  for (auto& baton : batons) {
+    baton.post();
+  }
+  latch.wait();
+}
+
 TEST_F(TableScanTest, waitForSplit) {
   auto filePaths = makeFilePaths(10);
   auto vectors = makeVectors(10, 1'000);
   for (int32_t i = 0; i < vectors.size(); i++) {
-    writeToFile(filePaths[i]->path, vectors[i]);
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
   }
   createDuckDbTable(vectors);
 
@@ -1185,7 +1570,7 @@ TEST_F(TableScanTest, waitForSplit) {
       tableScanNode(),
       [&](Task* task) {
         if (fileIndex < filePaths.size()) {
-          task->addSplit("0", makeHiveSplit(filePaths[fileIndex++]->path));
+          task->addSplit("0", makeHiveSplit(filePaths[fileIndex++]->getPath()));
         }
         if (fileIndex == filePaths.size()) {
           task->noMoreSplits("0");
@@ -1195,31 +1580,188 @@ TEST_F(TableScanTest, waitForSplit) {
       duckDbQueryRunner_);
 }
 
+DEBUG_ONLY_TEST_F(TableScanTest, tableScanSplitsAndWeights) {
+  // Create 10 data files for 10 splits.
+  const size_t numSplits{10};
+  const auto filePaths = makeFilePaths(numSplits);
+  auto vectors = makeVectors(numSplits, 100);
+  for (auto i = 0; i < numSplits; i++) {
+    writeToFile(filePaths.at(i)->getPath(), vectors.at(i));
+  }
+
+  // Set the table scan operators wait twice:
+  // First, before acquiring a split and then after.
+  std::atomic_uint32_t numAcquiredSplits{0};
+  std::shared_mutex pauseTableScan;
+  std::shared_mutex pauseSplitProcessing;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::TableScan::getOutput",
+      std::function<void(const TableScan*)>(
+          ([&](const TableScan* /*tableScan*/) {
+            pauseTableScan.lock_shared();
+            pauseTableScan.unlock_shared();
+          })));
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::TableScan::getOutput::gotSplit",
+      std::function<void(const TableScan*)>(
+          ([&](const TableScan* /*tableScan*/) {
+            ++numAcquiredSplits;
+            pauseSplitProcessing.lock_shared();
+            pauseSplitProcessing.unlock_shared();
+          })));
+  // This will stop table scan operators from proceeding reading from the
+  // acquired splits.
+  pauseTableScan.lock();
+  pauseSplitProcessing.lock();
+
+  // Prepare leaf task for the remote exchange node to pull data from.
+  auto leafTaskId = "local://leaf-0";
+  auto leafPlan = PlanBuilder()
+                      .values(vectors)
+                      .partitionedOutput({}, 1, {"c0", "c1", "c2"})
+                      .planNode();
+  std::unordered_map<std::string, std::string> config;
+  auto queryCtx = core::QueryCtx::create(
+      executor_.get(), core::QueryConfig(std::move(config)));
+  core::PlanFragment planFragment{leafPlan};
+  Consumer consumer = nullptr;
+  auto leafTask = Task::create(
+      leafTaskId,
+      core::PlanFragment{leafPlan},
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel,
+      std::move(consumer));
+  leafTask->start(4);
+
+  // Main task plan with table scan and remote exchange.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanNodeId, exchangeNodeId;
+  auto planNode = PlanBuilder(planNodeIdGenerator, pool_.get())
+                      .tableScan(rowType_)
+                      .capturePlanNodeId(scanNodeId)
+                      .project({"c0 AS t0", "c1 AS t1", "c2 AS t2"})
+                      .hashJoin(
+                          {"t0"},
+                          {"u0"},
+                          PlanBuilder(planNodeIdGenerator, pool_.get())
+                              .exchange(leafPlan->outputType())
+                              .capturePlanNodeId(exchangeNodeId)
+                              // .values(vectors)
+                              // .partitionedOutput({}, 1, {"c0", "c1", "c2"})
+                              .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+                              .planNode(),
+                          "",
+                          {"t1"},
+                          core::JoinType::kAnti)
+                      .planNode();
+
+  // Create task, cursor, start the task and supply the table scan splits.
+  const int32_t numDrivers = 6;
+  CursorParameters params;
+  params.planNode = planNode;
+  params.maxDrivers = numDrivers;
+  auto cursor = TaskCursor::create(params);
+  cursor->start();
+  auto task = cursor->task();
+  int64_t totalSplitWeights{0};
+  for (auto fileIndex = 0; fileIndex < numSplits; ++fileIndex) {
+    const int64_t splitWeight = fileIndex * 10 + 1;
+    totalSplitWeights += splitWeight;
+    auto split = makeHiveSplit(filePaths.at(fileIndex)->getPath(), splitWeight);
+    task->addSplit(scanNodeId, std::move(split));
+  }
+  task->noMoreSplits(scanNodeId);
+  // Manage remote exchange splits.
+  task->addSplit(
+      exchangeNodeId,
+      exec::Split(std::make_shared<RemoteConnectorSplit>(leafTaskId)));
+  task->noMoreSplits(exchangeNodeId);
+
+  // Check the task stats.
+  auto stats = task->taskStats();
+  EXPECT_EQ(stats.numRunningTableScanSplits, 0);
+  EXPECT_EQ(stats.numQueuedTableScanSplits, numSplits);
+  EXPECT_EQ(stats.runningTableScanSplitWeights, 0);
+  EXPECT_EQ(stats.queuedTableScanSplitWeights, totalSplitWeights);
+  EXPECT_EQ(stats.numTotalSplits, numSplits + 1);
+
+  // Let all the operators proceed to acquire splits.
+  pauseTableScan.unlock();
+
+  // Wait till 6 out of 10 splits are acquired by the operators in 6 threads
+  while (numAcquiredSplits < numDrivers) {
+    /* sleep override */
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  // Check the task stats.
+  int64_t runningSplitWeights{0};
+  for (auto i = 0; i < numAcquiredSplits; ++i) {
+    runningSplitWeights += i * 10 + 1;
+  }
+  stats = task->taskStats();
+  const auto queuedSplitWeights = totalSplitWeights - runningSplitWeights;
+  EXPECT_EQ(stats.numRunningTableScanSplits, numDrivers);
+  EXPECT_EQ(stats.numQueuedTableScanSplits, numSplits - numDrivers);
+  EXPECT_EQ(stats.runningTableScanSplitWeights, runningSplitWeights);
+  EXPECT_EQ(stats.queuedTableScanSplitWeights, queuedSplitWeights);
+
+  // Let all the operators proceed.
+  pauseSplitProcessing.unlock();
+
+  // Finish the task.
+  std::vector<RowVectorPtr> result;
+  while (cursor->moveNext()) {
+    result.push_back(cursor->current());
+  }
+  EXPECT_TRUE(waitForTaskCompletion(leafTask.get())) << leafTask->taskId();
+  EXPECT_TRUE(waitForTaskCompletion(task.get())) << task->taskId();
+
+  // Check task stats again.
+  stats = task->taskStats();
+  EXPECT_EQ(stats.numRunningTableScanSplits, 0);
+  EXPECT_EQ(stats.numQueuedTableScanSplits, 0);
+  EXPECT_EQ(stats.runningTableScanSplitWeights, 0);
+  EXPECT_EQ(stats.queuedTableScanSplitWeights, 0);
+  EXPECT_EQ(numAcquiredSplits, numSplits);
+}
+
 TEST_F(TableScanTest, splitOffsetAndLength) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   assertQuery(
       tableScanNode(),
       makeHiveConnectorSplit(
-          filePath->path, 0, fs::file_size(filePath->path) / 2),
+          filePath->getPath(), 0, fs::file_size(filePath->getPath()) / 2),
       "SELECT * FROM tmp");
 
   assertQuery(
       tableScanNode(),
-      makeHiveConnectorSplit(filePath->path, fs::file_size(filePath->path) / 2),
+      makeHiveConnectorSplit(
+          filePath->getPath(), fs::file_size(filePath->getPath()) / 2),
       "SELECT * FROM tmp LIMIT 0");
 }
 
 TEST_F(TableScanTest, fileNotFound) {
-  CursorParameters params;
-  params.planNode = tableScanNode();
-
-  auto cursor = std::make_unique<TaskCursor>(params);
-  cursor->task()->addSplit("0", makeHiveSplit("/path/to/nowhere.orc"));
-  EXPECT_THROW(cursor->moveNext(), VeloxRuntimeError);
+  auto split = HiveConnectorSplitBuilder("/path/to/nowhere.orc").build();
+  auto assertMissingFile = [&](bool ignoreMissingFiles) {
+    AssertQueryBuilder(tableScanNode())
+        .connectorSessionProperty(
+            kHiveConnectorId,
+            connector::hive::HiveConfig::kIgnoreMissingFilesSession,
+            std::to_string(ignoreMissingFiles))
+        .split(split)
+        .assertEmptyResults();
+  };
+  assertMissingFile(true);
+  VELOX_ASSERT_RUNTIME_THROW_CODE(
+      assertMissingFile(false),
+      error_code::kFileNotFound,
+      "No such file or directory");
 }
 
 // A valid ORC file (containing headers) but no data.
@@ -1233,7 +1775,7 @@ TEST_F(TableScanTest, validFileNoData) {
                    .length(fs::file_size(filePath) / 2)
                    .build();
 
-  auto op = tableScanNode(rowType);
+  auto op = PlanBuilder().tableScan(rowType, {}, "", rowType).planNode();
   assertQuery(op, split, "");
 }
 
@@ -1244,7 +1786,7 @@ TEST_F(TableScanTest, emptyFile) {
   try {
     assertQuery(
         tableScanNode(),
-        makeHiveConnectorSplit(filePath->path),
+        makeHiveConnectorSplit(filePath->getPath()),
         "SELECT * FROM tmp");
     ASSERT_FALSE(true) << "Function should throw.";
   } catch (const VeloxException& e) {
@@ -1252,77 +1794,128 @@ TEST_F(TableScanTest, emptyFile) {
   }
 }
 
+TEST_F(TableScanTest, preloadEmptySplit) {
+  auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
+  auto emptyVector = makeVectors(1, 0, rowType);
+  auto vector = makeVectors(1, 1'000, rowType);
+  auto filePaths = makeFilePaths(2);
+  writeToFile(filePaths[0]->getPath(), vector[0]);
+  writeToFile(filePaths[1]->getPath(), emptyVector[0]);
+  createDuckDbTable(vector);
+  auto op = tableScanNode(rowType);
+  assertQuery(op, filePaths, "SELECT * FROM tmp", 1);
+}
+
 TEST_F(TableScanTest, partitionedTableVarcharKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
-  testPartitionedTable(filePath->path, VARCHAR(), "2020-11-01");
+  testPartitionedTable(filePath->getPath(), VARCHAR(), "2020-11-01");
 }
 
 TEST_F(TableScanTest, partitionedTableBigIntKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
-  testPartitionedTable(filePath->path, BIGINT(), "123456789123456789");
+  testPartitionedTable(filePath->getPath(), BIGINT(), "123456789123456789");
 }
 
 TEST_F(TableScanTest, partitionedTableIntegerKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
-  testPartitionedTable(filePath->path, INTEGER(), "123456789");
+  testPartitionedTable(filePath->getPath(), INTEGER(), "123456789");
 }
 
 TEST_F(TableScanTest, partitionedTableSmallIntKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
-  testPartitionedTable(filePath->path, SMALLINT(), "1");
+  testPartitionedTable(filePath->getPath(), SMALLINT(), "1");
 }
 
 TEST_F(TableScanTest, partitionedTableTinyIntKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
-  testPartitionedTable(filePath->path, TINYINT(), "1");
+  testPartitionedTable(filePath->getPath(), TINYINT(), "1");
 }
 
 TEST_F(TableScanTest, partitionedTableBooleanKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
-  testPartitionedTable(filePath->path, BOOLEAN(), "0");
+  testPartitionedTable(filePath->getPath(), BOOLEAN(), "0");
 }
 
 TEST_F(TableScanTest, partitionedTableRealKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
-  testPartitionedTable(filePath->path, REAL(), "3.5");
+  testPartitionedTable(filePath->getPath(), REAL(), "3.5");
 }
 
 TEST_F(TableScanTest, partitionedTableDoubleKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+  testPartitionedTable(filePath->getPath(), DOUBLE(), "3.5");
+}
+
+TEST_F(TableScanTest, partitionedTableDateKey) {
+  auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
+  auto vectors = makeVectors(10, 1'000, rowType);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
-  testPartitionedTable(filePath->path, DOUBLE(), "3.5");
+  const std::string partitionValue = "2023-10-27";
+  testPartitionedTable(filePath->getPath(), DATE(), partitionValue);
+
+  // Test partition filter on date column.
+  {
+    auto split = HiveConnectorSplitBuilder(filePath->getPath())
+                     .partitionKey("pkey", partitionValue)
+                     .build();
+    auto outputType = ROW({"pkey", "c0", "c1"}, {DATE(), BIGINT(), DOUBLE()});
+    ColumnHandleMap assignments = {
+        {"pkey", partitionKey("pkey", DATE())},
+        {"c0", regularColumn("c0", BIGINT())},
+        {"c1", regularColumn("c1", DOUBLE())}};
+
+    SubfieldFilters filters;
+    // pkey > 2020-09-01.
+    filters[common::Subfield("pkey")] = std::make_unique<common::BigintRange>(
+        18506, std::numeric_limits<int64_t>::max(), false);
+
+    auto tableHandle = std::make_shared<HiveTableHandle>(
+        "test-hive", "hive_table", true, std::move(filters), nullptr, nullptr);
+    auto op = std::make_shared<TableScanNode>(
+        "0",
+        std::move(outputType),
+        std::move(tableHandle),
+        std::move(assignments));
+
+    std::string partitionValueStr = "'" + partitionValue + "'";
+    assertQuery(
+        op, split, fmt::format("SELECT {}, * FROM tmp", partitionValueStr));
+  }
 }
 
 std::vector<StringView> toStringViews(const std::vector<std::string>& values) {
@@ -1343,7 +1936,7 @@ TEST_F(TableScanTest, statsBasedSkippingBool) {
        makeFlatVector<bool>(
            size, [](auto row) { return (row / 10'000) % 2 == 0; })});
 
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   auto assertQuery = [&](const std::string& filter) {
@@ -1369,7 +1962,7 @@ TEST_F(TableScanTest, statsBasedSkippingDouble) {
   auto rowVector = makeRowVector({makeFlatVector<double>(
       size, [](auto row) { return (double)(row + 0.0001); })});
 
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   // c0 <= -1.05 -> whole file should be skipped based on stats
@@ -1409,7 +2002,7 @@ TEST_F(TableScanTest, statsBasedSkippingFloat) {
   auto rowVector = makeRowVector({makeFlatVector<float>(
       size, [](auto row) { return (float)(row + 0.0001); })});
 
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   // c0 <= -1.05 -> whole file should be skipped based on stats
@@ -1472,7 +2065,7 @@ TEST_F(TableScanTest, statsBasedSkipping) {
              }
            })});
 
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   // c0 <= -1 -> whole file should be skipped based on stats
@@ -1488,7 +2081,11 @@ TEST_F(TableScanTest, statsBasedSkipping) {
         asRowType(rowVector->type()));
     return TableScanTest::assertQuery(
         PlanBuilder()
-            .tableScan(ROW({"c1"}, {INTEGER()}), tableHandle, assignments)
+            .startTableScan()
+            .outputType(ROW({"c1"}, {INTEGER()}))
+            .tableHandle(tableHandle)
+            .assignments(assignments)
+            .endTableScan()
             .planNode(),
         filePaths,
         query);
@@ -1594,7 +2191,7 @@ TEST_F(TableScanTest, statsBasedSkippingConstants) {
          return fruitViews[row / 10'000];
        })});
 
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   auto assertQuery = [&](const std::string& filter) {
@@ -1643,7 +2240,7 @@ TEST_F(TableScanTest, statsBasedSkippingNulls) {
       [](auto row) { return row >= 11'111; });
   auto rowVector = makeRowVector({noNulls, someNulls});
 
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   // c0 IS NULL - whole file should be skipped based on stats
@@ -1656,12 +2253,26 @@ TEST_F(TableScanTest, statsBasedSkippingNulls) {
         "SELECT * FROM tmp WHERE " + filter);
   };
 
-  auto task = assertQuery("c0 IS NULL");
+  auto task = TableScanTest::assertQuery(
+      PlanBuilder().tableScan(rowType).planNode(),
+      filePaths,
+      "SELECT * FROM tmp");
 
   auto stats = getTableScanStats(task);
+  EXPECT_EQ(31'234, stats.rawInputRows);
+  EXPECT_EQ(31'234, stats.inputRows);
+  EXPECT_EQ(31'234, stats.outputRows);
+  ASSERT_EQ(getTableScanRuntimeStats(task).at("skippedSplits").sum, 0);
+  ASSERT_EQ(getTableScanRuntimeStats(task).at("skippedStrides").sum, 0);
+
+  task = assertQuery("c0 IS NULL");
+
+  stats = getTableScanStats(task);
   EXPECT_EQ(0, stats.rawInputRows);
   EXPECT_EQ(0, stats.inputRows);
   EXPECT_EQ(0, stats.outputRows);
+  ASSERT_EQ(getTableScanRuntimeStats(task).at("skippedSplits").sum, 1);
+  ASSERT_EQ(getTableScanRuntimeStats(task).at("skippedStrides").sum, 0);
 
   // c1 IS NULL - first stride should be skipped based on stats
   task = assertQuery("c1 IS NULL");
@@ -1670,6 +2281,8 @@ TEST_F(TableScanTest, statsBasedSkippingNulls) {
   EXPECT_EQ(size - 10'000, stats.rawInputRows);
   EXPECT_EQ(size - 11'111, stats.inputRows);
   EXPECT_EQ(size - 11'111, stats.outputRows);
+  ASSERT_EQ(getTableScanRuntimeStats(task).at("skippedSplits").sum, 0);
+  ASSERT_EQ(getTableScanRuntimeStats(task).at("skippedStrides").sum, 1);
 
   // c1 IS NOT NULL - 3rd and 4th strides should be skipped based on stats
   task = assertQuery("c1 IS NOT NULL");
@@ -1678,6 +2291,8 @@ TEST_F(TableScanTest, statsBasedSkippingNulls) {
   EXPECT_EQ(20'000, stats.rawInputRows);
   EXPECT_EQ(11'111, stats.inputRows);
   EXPECT_EQ(11'111, stats.outputRows);
+  ASSERT_EQ(getTableScanRuntimeStats(task).at("skippedSplits").sum, 0);
+  ASSERT_EQ(getTableScanRuntimeStats(task).at("skippedStrides").sum, 2);
 }
 
 // Test skipping whole compression blocks without decompressing these.
@@ -1696,7 +2311,7 @@ TEST_F(TableScanTest, statsBasedSkippingWithoutDecompression) {
   auto rowVector = makeRowVector({makeFlatVector(strings)});
 
   auto filePaths = makeFilePaths(1);
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   // Skip 1st row group.
@@ -1741,7 +2356,7 @@ TEST_F(TableScanTest, filterBasedSkippingWithoutDecompression) {
   auto rowType = asRowType(rowVector->type());
 
   auto filePaths = makeFilePaths(1);
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   auto assertQuery = [&](const std::string& remainingFilter) {
@@ -1790,7 +2405,7 @@ TEST_F(TableScanTest, statsBasedSkippingNumerics) {
            size, [](auto row) { return row % 11 == 0; }, nullEvery(23))});
 
   auto filePaths = makeFilePaths(1);
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   // Skip whole file.
@@ -1853,7 +2468,7 @@ TEST_F(TableScanTest, statsBasedSkippingComplexTypes) {
            nullEvery(11))});
 
   auto filePaths = makeFilePaths(1);
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
   // TODO Figure out how to create DuckDB tables with columns of complex types
   // For now, using 1st element of the array and map element for key zero.
   createDuckDbTable({makeRowVector(
@@ -1925,7 +2540,7 @@ TEST_F(TableScanTest, statsBasedAndRegularSkippingComplexTypes) {
   });
 
   auto filePaths = makeFilePaths(1);
-  writeToFile(filePaths[0]->path, rowVector);
+  writeToFile(filePaths[0]->getPath(), rowVector);
 
   createDuckDbTable({makeRowVector({
       makeFlatVector<int64_t>(size, [](auto row) { return row; }),
@@ -1961,7 +2576,7 @@ TEST_F(TableScanTest, filterPushdown) {
   auto filePaths = makeFilePaths(10);
   auto vectors = makeVectors(10, 1'000, rowType);
   for (int32_t i = 0; i < vectors.size(); i++) {
-    writeToFile(filePaths[i]->path, vectors[i]);
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
   }
   createDuckDbTable(vectors);
 
@@ -1978,10 +2593,11 @@ TEST_F(TableScanTest, filterPushdown) {
 
   auto task = assertQuery(
       PlanBuilder()
-          .tableScan(
-              ROW({"c1", "c3", "c0"}, {BIGINT(), BOOLEAN(), TINYINT()}),
-              tableHandle,
-              assignments)
+          .startTableScan()
+          .outputType(ROW({"c1", "c3", "c0"}, {BIGINT(), BOOLEAN(), TINYINT()}))
+          .tableHandle(tableHandle)
+          .assignments(assignments)
+          .endTableScan()
           .planNode(),
       filePaths,
       "SELECT c1, c3, c0 FROM tmp WHERE (c1 >= 0 OR c1 IS NULL) AND c3");
@@ -1996,7 +2612,11 @@ TEST_F(TableScanTest, filterPushdown) {
   assignments["c0"] = regularColumn("c0", TINYINT());
   assertQuery(
       PlanBuilder()
-          .tableScan(ROW({"c0"}, {TINYINT()}), tableHandle, assignments)
+          .startTableScan()
+          .outputType(ROW({"c0"}, {TINYINT()}))
+          .tableHandle(tableHandle)
+          .assignments(assignments)
+          .endTableScan()
           .planNode(),
       filePaths,
       "SELECT c0 FROM tmp WHERE (c1 >= 0 OR c1 IS NULL) AND c3");
@@ -2005,7 +2625,11 @@ TEST_F(TableScanTest, filterPushdown) {
   assignments.clear();
   assertQuery(
       PlanBuilder()
-          .tableScan(ROW({}, {}), tableHandle, assignments)
+          .startTableScan()
+          .outputType(ROW({}, {}))
+          .tableHandle(tableHandle)
+          .assignments(assignments)
+          .endTableScan()
           .singleAggregation({}, {"sum(1)"})
           .planNode(),
       filePaths,
@@ -2017,7 +2641,11 @@ TEST_F(TableScanTest, filterPushdown) {
   tableHandle = makeTableHandle(std::move(subfieldFilters));
   assertQuery(
       PlanBuilder()
-          .tableScan(ROW({}, {}), tableHandle, assignments)
+          .startTableScan()
+          .outputType(ROW({}, {}))
+          .tableHandle(tableHandle)
+          .assignments(assignments)
+          .endTableScan()
           .singleAggregation({}, {"sum(1)"})
           .planNode(),
       filePaths,
@@ -2028,7 +2656,7 @@ TEST_F(TableScanTest, path) {
   auto rowType = ROW({"a"}, {BIGINT()});
   auto filePath = makeFilePaths(1)[0];
   auto vector = makeVectors(1, 1'000, rowType)[0];
-  writeToFile(filePath->path, vector);
+  writeToFile(filePath->getPath(), vector);
   createDuckDbTable({vector});
 
   static const char* kPath = "$path";
@@ -2036,32 +2664,111 @@ TEST_F(TableScanTest, path) {
   auto assignments = allRegularColumns(rowType);
   assignments[kPath] = synthesizedColumn(kPath, VARCHAR());
 
-  auto tableHandle = makeTableHandle();
-
-  auto pathValue = fmt::format("file:{}", filePath->path);
+  auto pathValue = fmt::format("file:{}", filePath->getPath());
   auto typeWithPath = ROW({kPath, "a"}, {VARCHAR(), BIGINT()});
   auto op = PlanBuilder()
-                .tableScan(typeWithPath, tableHandle, assignments)
+                .startTableScan()
+                .outputType(typeWithPath)
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
   assertQuery(
       op, {filePath}, fmt::format("SELECT '{}', * FROM tmp", pathValue));
 
   // use $path in a filter, but don't project it out
-  tableHandle = makeTableHandle(
+  auto tableHandle = makeTableHandle(
       SubfieldFilters{},
       parseExpr(fmt::format("\"{}\" = '{}'", kPath, pathValue), typeWithPath));
-
-  op = PlanBuilder().tableScan(rowType, tableHandle, assignments).planNode();
+  op = PlanBuilder()
+           .startTableScan()
+           .outputType(rowType)
+           .tableHandle(tableHandle)
+           .assignments(assignments)
+           .endTableScan()
+           .planNode();
   assertQuery(op, {filePath}, "SELECT * FROM tmp");
 
   // use $path in a filter and project it out
   op = PlanBuilder()
-           .tableScan(typeWithPath, tableHandle, assignments)
+           .startTableScan()
+           .outputType(typeWithPath)
+           .assignments(assignments)
+           .endTableScan()
            .planNode();
   assertQuery(
       op, {filePath}, fmt::format("SELECT '{}', * FROM tmp", pathValue));
 }
 
+TEST_F(TableScanTest, fileSizeAndModifiedTime) {
+  auto rowType = ROW({"a"}, {BIGINT()});
+  auto filePath = makeFilePaths(1)[0];
+  auto vector = makeVectors(1, 10, rowType)[0];
+  writeToFile(filePath->getPath(), vector);
+  createDuckDbTable({vector});
+
+  static const char* kSize = "$file_size";
+  static const char* kModifiedTime = "$file_modified_time";
+
+  auto allColumns =
+      ROW({"a", kSize, kModifiedTime}, {BIGINT(), BIGINT(), BIGINT()});
+
+  auto assignments = allRegularColumns(rowType);
+  assignments[kSize] = synthesizedColumn(kSize, BIGINT());
+  assignments[kModifiedTime] = synthesizedColumn(kModifiedTime, BIGINT());
+
+  auto fileSizeValue = fmt::format("{}", filePath->fileSize());
+  auto fileTimeValue = fmt::format("{}", filePath->fileModifiedTime());
+
+  // Select and project both '$file_size', '$file_modified_time'.
+  auto op = PlanBuilder()
+                .startTableScan()
+                .outputType(allColumns)
+                .dataColumns(allColumns)
+                .assignments(assignments)
+                .endTableScan()
+                .planNode();
+  assertQuery(
+      op,
+      {filePath},
+      fmt::format("SELECT *, {}, {} FROM tmp", fileSizeValue, fileTimeValue));
+
+  auto filterTest = [&](const std::string& filter) {
+    auto tableHandle = makeTableHandle(
+        SubfieldFilters{},
+        parseExpr(filter, allColumns),
+        "hive_table",
+        allColumns);
+
+    // Use synthesized column in a filter but don't project it.
+    op = PlanBuilder()
+             .startTableScan()
+             .outputType(rowType)
+             .dataColumns(allColumns)
+             .tableHandle(tableHandle)
+             .assignments(assignments)
+             .endTableScan()
+             .planNode();
+    assertQuery(op, {filePath}, "SELECT * FROM tmp");
+
+    // Use synthesized column in a filter and project it out.
+    op = PlanBuilder()
+             .startTableScan()
+             .outputType(allColumns)
+             .dataColumns(allColumns)
+             .tableHandle(tableHandle)
+             .assignments(assignments)
+             .endTableScan()
+             .planNode();
+    assertQuery(
+        op,
+        {filePath},
+        fmt::format("SELECT *, {}, {} FROM tmp", fileSizeValue, fileTimeValue));
+  };
+
+  filterTest(fmt::format("\"{}\" = {}", kSize, fileSizeValue));
+  filterTest(fmt::format("\"{}\" = {}", kModifiedTime, fileTimeValue));
+}
+
 TEST_F(TableScanTest, bucket) {
   vector_size_t size = 1'000;
   int numBatches = 5;
@@ -2082,10 +2789,10 @@ TEST_F(TableScanTest, bucket) {
         {makeFlatVector<int32_t>(size, [&](auto /*row*/) { return bucket; }),
          makeFlatVector<int64_t>(
              size, [&](auto row) { return bucket + row; })});
-    writeToFile(filePaths[i]->path, rowVector);
+    writeToFile(filePaths[i]->getPath(), rowVector);
     rowVectors.emplace_back(rowVector);
 
-    splits.emplace_back(HiveConnectorSplitBuilder(filePaths[i]->path)
+    splits.emplace_back(HiveConnectorSplitBuilder(filePaths[i]->getPath())
                             .tableBucketNumber(bucket)
                             .build());
   }
@@ -2101,23 +2808,27 @@ TEST_F(TableScanTest, bucket) {
   // Query that spans on all buckets
   auto typeWithBucket =
       ROW({kBucket, "c0", "c1"}, {INTEGER(), INTEGER(), BIGINT()});
-  auto tableHandle = makeTableHandle();
   auto op = PlanBuilder()
-                .tableScan(typeWithBucket, tableHandle, assignments)
+                .startTableScan()
+                .outputType(typeWithBucket)
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
   OperatorTestBase::assertQuery(op, splits, "SELECT c0, * FROM tmp");
 
   for (int i = 0; i < buckets.size(); ++i) {
     int bucketValue = buckets[i];
-    auto hsplit = HiveConnectorSplitBuilder(filePaths[i]->path)
+    auto hsplit = HiveConnectorSplitBuilder(filePaths[i]->getPath())
                       .tableBucketNumber(bucketValue)
                       .build();
-    tableHandle = makeTableHandle();
 
     // Filter on bucket and filter on first column should produce
     // identical result for each split
     op = PlanBuilder()
-             .tableScan(typeWithBucket, tableHandle, assignments)
+             .startTableScan()
+             .outputType(typeWithBucket)
+             .assignments(assignments)
+             .endTableScan()
              .planNode();
     assertQuery(
         op,
@@ -2127,10 +2838,15 @@ TEST_F(TableScanTest, bucket) {
 
     // Filter on bucket column, but don't project it out
     auto rowTypes = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
-    hsplit = HiveConnectorSplitBuilder(filePaths[i]->path)
+    hsplit = HiveConnectorSplitBuilder(filePaths[i]->getPath())
                  .tableBucketNumber(bucketValue)
                  .build();
-    op = PlanBuilder().tableScan(rowTypes, tableHandle, assignments).planNode();
+    op = PlanBuilder()
+             .startTableScan()
+             .outputType(rowTypes)
+             .assignments(assignments)
+             .endTableScan()
+             .planNode();
     assertQuery(
         op,
         hsplit,
@@ -2138,6 +2854,136 @@ TEST_F(TableScanTest, bucket) {
   }
 }
 
+TEST_F(TableScanTest, bucketConversion) {
+  constexpr int kSize = 100;
+  auto vector = makeRowVector({
+      makeFlatVector<int32_t>(kSize, [](auto i) { return 2 * i + 1; }),
+      makeFlatVector<int64_t>(kSize, folly::identity),
+  });
+  auto schema = asRowType(vector->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  constexpr int kNewNumBuckets = 16;
+  const int selectedBuckets[] = {3, 5, 11};
+  auto makeSplits = [&] {
+    std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
+    for (int bucket : selectedBuckets) {
+      std::vector<std::unique_ptr<HiveColumnHandle>> handles;
+      handles.push_back(makeColumnHandle("c0", INTEGER(), {}));
+      auto split = makeHiveConnectorSplit(file->getPath());
+      split->tableBucketNumber = bucket;
+      split->bucketConversion = {kNewNumBuckets, 2, std::move(handles)};
+      splits.push_back(split);
+    }
+    return splits;
+  };
+  {
+    auto outputType = ROW({"c1"}, {BIGINT()});
+    auto plan = PlanBuilder().tableScan(outputType, {}, "", schema).planNode();
+    std::vector<int64_t> c1;
+    for (int bucket : selectedBuckets) {
+      for (int i = bucket; i < 2 * kSize + 1; i += kNewNumBuckets) {
+        c1.push_back(i / 2);
+      }
+    }
+    auto expected = makeRowVector({makeFlatVector(c1)});
+    AssertQueryBuilder(plan).splits(makeSplits()).assertResults(expected);
+  }
+  {
+    SCOPED_TRACE("With remaining filter");
+    auto outputType = ROW({"c1"}, {BIGINT()});
+    auto plan = PlanBuilder()
+                    .tableScan(outputType, {}, "c1 % 7 != 0", schema)
+                    .planNode();
+    std::vector<int64_t> c1;
+    for (int bucket : selectedBuckets) {
+      for (int i = bucket; i < 2 * kSize + 1; i += kNewNumBuckets) {
+        if ((i / 2) % 7 != 0) {
+          c1.push_back(i / 2);
+        }
+      }
+    }
+    auto expected = makeRowVector({makeFlatVector(c1)});
+    AssertQueryBuilder(plan).splits(makeSplits()).assertResults(expected);
+  }
+  {
+    SCOPED_TRACE("With row number");
+    auto outputType = ROW({"c2", "c1"}, {BIGINT(), BIGINT()});
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .outputType(outputType)
+                    .dataColumns(schema)
+                    .assignments({
+                        {"c2",
+                         std::make_shared<HiveColumnHandle>(
+                             "c2",
+                             HiveColumnHandle::ColumnType::kRowIndex,
+                             BIGINT(),
+                             BIGINT())},
+                        {"c1", makeColumnHandle("c1", BIGINT(), {})},
+                    })
+                    .endTableScan()
+                    .planNode();
+    std::vector<int64_t> c1;
+    for (int bucket : selectedBuckets) {
+      for (int i = bucket; i < 2 * kSize + 1; i += kNewNumBuckets) {
+        c1.push_back(i / 2);
+      }
+    }
+    auto data = makeFlatVector(c1);
+    auto expected = makeRowVector({"c2", "c1"}, {data, data});
+    AssertQueryBuilder(plan).splits(makeSplits()).assertResults(expected);
+  }
+}
+
+TEST_F(TableScanTest, bucketConversionWithSubfieldPruning) {
+  constexpr int kSize = 100;
+  auto key = makeRowVector({
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeFlatVector<int64_t>(kSize, [](auto i) { return 2 * i; }),
+  });
+  auto vector = makeRowVector({key});
+  auto schema = asRowType(vector->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  constexpr int kNewNumBuckets = 16;
+  const int selectedBuckets[] = {3, 5, 11};
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
+  for (int bucket : selectedBuckets) {
+    std::vector<std::unique_ptr<HiveColumnHandle>> handles;
+    handles.push_back(makeColumnHandle("c0", key->type(), {}));
+    auto split = makeHiveConnectorSplit(file->getPath());
+    split->tableBucketNumber = bucket;
+    split->bucketConversion = {kNewNumBuckets, 1, std::move(handles)};
+    splits.push_back(split);
+  }
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(schema)
+                  .dataColumns(schema)
+                  .assignments({
+                      {"c0", makeColumnHandle("c0", key->type(), {"c0.c0"})},
+                  })
+                  .endTableScan()
+                  .planNode();
+  auto result =
+      AssertQueryBuilder(plan).splits(splits).copyResults(pool_.get());
+  HivePartitionFunction function(kNewNumBuckets, {0});
+  std::vector<uint32_t> partitions;
+  function.partition(*vector, partitions);
+  int j = 0;
+  for (int bucket : selectedBuckets) {
+    for (int i = 0; i < kSize; ++i) {
+      if (partitions[i] == bucket) {
+        ASSERT_LT(j, result->size());
+        ASSERT_TRUE(result->equalValueAt(vector.get(), j, i));
+        ++j;
+      }
+    }
+  }
+  ASSERT_EQ(j, result->size());
+}
+
 TEST_F(TableScanTest, integerNotEqualFilter) {
   auto rowType = ROW(
       {"c0", "c1", "c2", "c3"}, {TINYINT(), SMALLINT(), INTEGER(), BIGINT()});
@@ -2156,33 +3002,33 @@ TEST_F(TableScanTest, integerNotEqualFilter) {
            size, [](auto row) { return row % 210; }, nullEvery(11))});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, rowVector);
+  writeToFile(filePath->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   assertQuery(
       PlanBuilder(pool_.get())
-          .tableScan(rowType, {"c0 != 0::TINYINT"}, {})
+          .tableScan(rowType, {"c0 != 0::TINYINT"})
           .planNode(),
       {filePath},
       "SELECT * FROM tmp WHERE c0 != 0");
 
   assertQuery(
       PlanBuilder(pool_.get())
-          .tableScan(rowType, {"c1 != 1::SMALLINT"}, {})
+          .tableScan(rowType, {"c1 != 1::SMALLINT"})
           .planNode(),
       {filePath},
       "SELECT * FROM tmp WHERE c1 != 1");
 
   assertQuery(
       PlanBuilder(pool_.get())
-          .tableScan(rowType, {"c2 != (-2)::INTEGER"}, {})
+          .tableScan(rowType, {"c2 != (-2)::INTEGER"})
           .planNode(),
       {filePath},
       "SELECT * FROM tmp WHERE c2 != -2");
 
   assertQuery(
       PlanBuilder(pool_.get())
-          .tableScan(rowType, {"c3 != 3::BIGINT"}, {})
+          .tableScan(rowType, {"c3 != 3::BIGINT"})
           .planNode(),
       {filePath},
       "SELECT * FROM tmp WHERE c3 != 3");
@@ -2191,18 +3037,17 @@ TEST_F(TableScanTest, integerNotEqualFilter) {
 TEST_F(TableScanTest, floatingPointNotEqualFilter) {
   auto vectors = makeVectors(1, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   auto outputType = ROW({"c4"}, {DOUBLE()});
-  auto op = PlanBuilder(pool_.get())
-                .tableScan(outputType, {"c4 != 0.0"}, {})
-                .planNode();
+  auto op =
+      PlanBuilder(pool_.get()).tableScan(outputType, {"c4 != 0.0"}).planNode();
   assertQuery(op, {filePath}, "SELECT c4 FROM tmp WHERE c4 != 0.0");
 
   outputType = ROW({"c3"}, {REAL()});
   op = PlanBuilder(pool_.get())
-           .tableScan(outputType, {"c3 != cast(0.0 as REAL)"}, {})
+           .tableScan(outputType, {"c3 != cast(0.0 as REAL)"})
            .planNode();
   assertQuery(
       op, {filePath}, "SELECT c3 FROM tmp WHERE c3 != cast(0.0 as REAL)");
@@ -2230,18 +3075,18 @@ TEST_F(TableScanTest, stringNotEqualFilter) {
        })});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, rowVector);
+  writeToFile(filePath->getPath(), rowVector);
   createDuckDbTable({rowVector});
 
   assertQuery(
       PlanBuilder(pool_.get())
-          .tableScan(rowType, {"c0 != 'banana'"}, {})
+          .tableScan(rowType, {"c0 != 'banana'"})
           .planNode(),
       {filePath},
       "SELECT * FROM tmp WHERE c0 != 'banana'");
 
   assertQuery(
-      PlanBuilder(pool_.get()).tableScan(rowType, {"c1 != ''"}, {}).planNode(),
+      PlanBuilder(pool_.get()).tableScan(rowType, {"c1 != ''"}).planNode(),
       {filePath},
       "SELECT * FROM tmp WHERE c1 != ''");
 }
@@ -2261,7 +3106,7 @@ TEST_F(TableScanTest, arrayIsNullFilter) {
         [](vector_size_t, vector_size_t j) { return j; },
         isNullAt);
     vectors[i] = makeRowVector({"c0"}, {c0});
-    writeToFile(filePaths[i]->path, vectors[i]);
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
   }
   createDuckDbTable(vectors);
   auto rowType = asRowType(vectors[0]->type());
@@ -2294,7 +3139,7 @@ TEST_F(TableScanTest, mapIsNullFilter) {
         [](vector_size_t j) { return 2 * j; },
         isNullAt);
     vectors[i] = makeRowVector({"c0"}, {c0});
-    writeToFile(filePaths[i]->path, vectors[i]);
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
   }
   createDuckDbTable(vectors);
   auto rowType = asRowType(vectors[0]->type());
@@ -2311,24 +3156,102 @@ TEST_F(TableScanTest, mapIsNullFilter) {
       "SELECT * FROM tmp WHERE c0 is null");
 }
 
+TEST_F(TableScanTest, stringIsNullFilter) {
+  constexpr int kSize = 1000;
+  const char* baseStrings[] = {
+      "qwertyuiopasdfghjklzxcvbnm",
+      "qazwsxedcrfvtgbyhnujmikolp",
+  };
+  auto indices = allocateIndices(kSize, pool_.get());
+  for (int i = 0; i < kSize; ++i) {
+    indices->asMutable<vector_size_t>()[i] = i % 2;
+  }
+  auto nullBuffer =
+      AlignedBuffer::allocate<bool>(kSize, pool_.get(), bits::kNotNull);
+  auto* rawNullBuffer = nullBuffer->asMutable<uint64_t>();
+  for (int i = 0; i < kSize; i += 100) {
+    bits::setNull(rawNullBuffer, i);
+  }
+  auto dict = BaseVector::wrapInDictionary(
+      nullBuffer,
+      indices,
+      kSize,
+      makeFlatVector<std::string>({baseStrings[0], baseStrings[1]}));
+
+  auto rows = makeRowVector({"c0", "c1"}, {dict, dict});
+  auto tableType = asRowType(rows->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {rows});
+  createDuckDbTable({rows});
+
+  const auto outputType = ROW({"c1"}, {VARCHAR()});
+  auto makePlan = [&](const std::vector<std::string>& filters) {
+    return PlanBuilder()
+        .tableScan(outputType, filters, "", tableType)
+        .planNode();
+  };
+
+  assertQuery(
+      makePlan({"c0 is not null"}),
+      {file},
+      "SELECT c1 FROM tmp WHERE c0 is not null");
+  assertQuery(
+      makePlan({"c0 is null"}), {file}, "SELECT c1 FROM tmp WHERE c0 is null");
+}
+
+TEST_F(TableScanTest, compactComplexNulls) {
+  constexpr int kSize = 10;
+  auto iota = makeFlatVector<int64_t>(kSize, folly::identity);
+  std::vector<vector_size_t> offsets(kSize);
+  for (int i = 0; i < kSize; ++i) {
+    offsets[i] = (i + 1) / 2 * 2;
+  }
+  auto c0 = makeRowVector(
+      {
+          makeArrayVector(offsets, iota, {1, 3, 5, 7, 9}),
+          iota,
+      },
+      [](auto i) { return i == 2; });
+  auto data = makeRowVector({c0});
+  auto schema = asRowType(data->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {data});
+  auto plan = PlanBuilder().tableScan(schema, {"(c0).c1 > 0"}).planNode();
+  auto split = makeHiveConnectorSplit(file->getPath());
+  const vector_size_t indices[] = {1, 3, 4, 5, 6, 7, 8, 9};
+  auto expected = makeRowVector({wrapInDictionary(
+      makeIndices(8, [&](auto i) { return indices[i]; }), c0)});
+  AssertQueryBuilder(plan).split(split).assertResults(expected);
+}
+
 TEST_F(TableScanTest, remainingFilter) {
   auto rowType = ROW(
       {"c0", "c1", "c2", "c3"}, {INTEGER(), INTEGER(), DOUBLE(), BOOLEAN()});
   auto filePaths = makeFilePaths(10);
   auto vectors = makeVectors(10, 1'000, rowType);
   for (int32_t i = 0; i < vectors.size(); i++) {
-    writeToFile(filePaths[i]->path, vectors[i]);
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
   }
   createDuckDbTable(vectors);
 
   assertQuery(
-      PlanBuilder(pool_.get()).tableScan(rowType, {}, "c1 > c0").planNode(),
+      PlanBuilder(pool_.get())
+          .startTableScan()
+          .outputType(rowType)
+          .remainingFilter("c1 > c0")
+          .endTableScan()
+          .planNode(),
       filePaths,
       "SELECT * FROM tmp WHERE c1 > c0");
 
   // filter that never passes
   assertQuery(
-      PlanBuilder(pool_.get()).tableScan(rowType, {}, "c1 % 5 = 6").planNode(),
+      PlanBuilder(pool_.get())
+          .startTableScan()
+          .outputType(rowType)
+          .remainingFilter("c1 % 5 = 6")
+          .endTableScan()
+          .planNode(),
       filePaths,
       "SELECT * FROM tmp WHERE c1 % 5 = 6");
 
@@ -2342,11 +3265,15 @@ TEST_F(TableScanTest, remainingFilter) {
 
   // Remaining filter uses columns that are not used otherwise.
   ColumnHandleMap assignments = {{"c2", regularColumn("c2", DOUBLE())}};
-  auto tableHandle =
-      makeTableHandle(SubfieldFilters{}, parseExpr("c1 > c0", rowType));
+
   assertQuery(
       PlanBuilder(pool_.get())
-          .tableScan(ROW({"c2"}, {DOUBLE()}), tableHandle, assignments)
+          .startTableScan()
+          .outputType(ROW({"c2"}, {DOUBLE()}))
+          .remainingFilter("c1 > c0")
+          .dataColumns(rowType)
+          .assignments(assignments)
+          .endTableScan()
           .planNode(),
       filePaths,
       "SELECT c2 FROM tmp WHERE c1 > c0");
@@ -2356,14 +3283,15 @@ TEST_F(TableScanTest, remainingFilter) {
   assignments = {
       {"c1", regularColumn("c1", INTEGER())},
       {"c2", regularColumn("c2", DOUBLE())}};
-  tableHandle =
-      makeTableHandle(SubfieldFilters{}, parseExpr("c1 > c0", rowType));
+
   assertQuery(
       PlanBuilder(pool_.get())
-          .tableScan(
-              ROW({"c1", "c2"}, {INTEGER(), DOUBLE()}),
-              tableHandle,
-              assignments)
+          .startTableScan()
+          .outputType(ROW({"c1", "c2"}, {INTEGER(), DOUBLE()}))
+          .remainingFilter("c1 > c0")
+          .dataColumns(rowType)
+          .assignments(assignments)
+          .endTableScan()
           .planNode(),
       filePaths,
       "SELECT c1, c2 FROM tmp WHERE c1 > c0");
@@ -2383,6 +3311,128 @@ TEST_F(TableScanTest, remainingFilter) {
       "SELECT * FROM tmp WHERE not (c0 > 0 or c1 > c0)");
 }
 
+TEST_F(TableScanTest, remainingFilterLazyWithMultiReferences) {
+  constexpr int kSize = 10;
+  auto vector = makeRowVector({
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeFlatVector<int64_t>(kSize, folly::identity),
+  });
+  auto schema = asRowType(vector->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  CursorParameters params;
+  params.copyResult = false;
+  params.serialExecution = true;
+  params.planNode =
+      PlanBuilder()
+          .tableScan(schema, {}, "NOT (c0 % 2 == 0 AND c2 % 3 == 0)")
+          .planNode();
+  auto cursor = TaskCursor::create(params);
+  cursor->task()->addSplit(
+      "0", exec::Split(makeHiveConnectorSplit(file->getPath())));
+  cursor->task()->noMoreSplits("0");
+  int i = 0;
+  while (cursor->moveNext()) {
+    auto* result = cursor->current()->asUnchecked<RowVector>();
+    ASSERT_FALSE(isLazyNotLoaded(*result->childAt(0)));
+    ASSERT_TRUE(isLazyNotLoaded(*result->childAt(1)));
+    ASSERT_FALSE(isLazyNotLoaded(*result->childAt(2)));
+    for (int j = 0; j < result->size(); ++i) {
+      ASSERT_LT(i, vector->size());
+      if (i % 6 != 0) {
+        ASSERT_TRUE(result->loadedVector()->equalValueAt(vector.get(), j++, i));
+      }
+    }
+  }
+  ASSERT_EQ(i, vector->size());
+  ASSERT_TRUE(waitForTaskCompletion(cursor->task().get()));
+}
+
+TEST_F(TableScanTest, sharedNullBufferFromComplexResult) {
+  // Set the map vector to trigger map null buffer writable check.
+  const auto mapVector = makeNullableMapVector<StringView, int64_t>(
+      {{std::nullopt},
+       {{{"0"_sv, 0}, {"1"_sv, std::nullopt}}},
+       {{{"2"_sv, 2}, {"3"_sv, std::nullopt}}},
+       {{{"4"_sv, 4}, {"5"_sv, std::nullopt}}},
+       {{{"6"_sv, 6}, {"7"_sv, std::nullopt}}}});
+  auto file = TempFilePath::create();
+  const auto rowVector = makeRowVector({mapVector});
+  auto schema = asRowType(rowVector->type());
+  writeToFile(file->getPath(), {rowVector});
+
+  CursorParameters params;
+  params.copyResult = false;
+  params.serialExecution = true;
+  params.planNode = PlanBuilder().tableScan(schema, {}).planNode();
+  std::unordered_map<std::string, std::string> config;
+  // Set output buffer row limit to 1 to trigger one batch read at a time.
+  params.queryConfigs.emplace(
+      QueryConfig::kPreferredOutputBatchBytes, folly::to<std::string>(1));
+
+  auto cursor = TaskCursor::create(params);
+  cursor->task()->addSplit(
+      "0", exec::Split(makeHiveConnectorSplit(file->getPath())));
+  cursor->task()->noMoreSplits("0");
+  int i = 0;
+  BufferPtr nullBufferHolder;
+  while (cursor->moveNext()) {
+    auto* result = cursor->current()->asUnchecked<RowVector>();
+    ASSERT_TRUE(isLazyNotLoaded(*result->childAt(0)));
+    result->loadedVector();
+    // The first batch contains null in map child and hold a shared reference to
+    // trigger the case that the null buffer is not writable in second read.
+    if (i++ == 0) {
+      nullBufferHolder = result->childAt(0)->nulls();
+    }
+  }
+  ASSERT_TRUE(waitForTaskCompletion(cursor->task().get()));
+}
+
+// When the multi-referenced fields are in AND clauses without any other
+// conditionals, they should not be eagerly materialized.
+TEST_F(
+    TableScanTest,
+    remainingFilterLazyWithMultiReferencesDirectlyInAndClause) {
+  constexpr int kSize = 10;
+  auto vector = makeRowVector({
+      makeFlatVector<int64_t>(kSize, folly::identity),
+      makeFlatVector<int64_t>(kSize, folly::identity),
+  });
+  auto schema = asRowType(vector->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  CursorParameters params;
+  params.copyResult = false;
+  params.serialExecution = true;
+  params.planNode = PlanBuilder()
+                        .tableScan(schema, {}, "c0 % 7 == 0 AND c1 % 2 == 0")
+                        .planNode();
+  auto cursor = TaskCursor::create(params);
+  cursor->task()->addSplit(
+      "0", exec::Split(makeHiveConnectorSplit(file->getPath())));
+  cursor->task()->noMoreSplits("0");
+  ASSERT_TRUE(cursor->moveNext());
+  auto* result = cursor->current()->asUnchecked<RowVector>();
+  ASSERT_EQ(result->size(), 1);
+  auto* c0 =
+      result->childAt(0)->loadedVector()->asUnchecked<SimpleVector<int64_t>>();
+  ASSERT_FALSE(c0->isNullAt(0));
+  ASSERT_EQ(c0->valueAt(0), 0);
+  auto* c1 = result->childAt(1)->loadedVector();
+  ASSERT_EQ(c1->encoding(), VectorEncoding::Simple::DICTIONARY);
+  auto* c1Dict = c1->asUnchecked<DictionaryVector<int64_t>>();
+  ASSERT_FALSE(c1Dict->isNullAt(0));
+  ASSERT_EQ(c1Dict->valueAt(0), 0);
+  ASSERT_EQ(
+      c1Dict->valueVector()->encoding(), VectorEncoding::Simple::DICTIONARY);
+  c1Dict = c1Dict->valueVector()->asUnchecked<DictionaryVector<int64_t>>();
+  ASSERT_EQ(c1Dict->valueVector()->size(), 2);
+  ASSERT_FALSE(cursor->moveNext());
+  ASSERT_TRUE(waitForTaskCompletion(cursor->task().get()));
+}
+
 TEST_F(TableScanTest, remainingFilterSkippedStrides) {
   auto rowType = ROW({{"c0", BIGINT()}, {"c1", BIGINT()}});
   std::vector<RowVectorPtr> vectors(3);
@@ -2399,7 +3449,7 @@ TEST_F(TableScanTest, remainingFilterSkippedStrides) {
         nullptr,
         c->size(),
         std::vector<VectorPtr>({c, c}));
-    writeToFile(filePaths[j]->path, vectors[j]);
+    writeToFile(filePaths[j]->getPath(), vectors[j]);
   }
   createDuckDbTable(vectors);
   core::PlanNodeId tableScanNodeId;
@@ -2421,15 +3471,61 @@ TEST_F(TableScanTest, skipStridesForParentNulls) {
   auto a = makeRowVector({"b"}, {b}, [](auto i) { return i % 2 == 0; });
   auto vector = makeRowVector({"a"}, {a});
   auto file = TempFilePath::create();
-  writeToFile(file->path, {vector});
+  writeToFile(file->getPath(), {vector});
   auto plan = PlanBuilder()
                   .tableScan(asRowType(vector->type()), {"a.b IS NULL"})
                   .planNode();
-  auto split = makeHiveConnectorSplit(file->path);
+  auto split = makeHiveConnectorSplit(file->getPath());
   auto result = AssertQueryBuilder(plan).split(split).copyResults(pool());
   ASSERT_EQ(result->size(), 5000);
 }
 
+TEST_F(TableScanTest, randomSample) {
+  random::setSeed(42);
+  auto column = makeFlatVector<double>(
+      100, [](auto /*i*/) { return folly::Random::randDouble01(); });
+  auto rows = makeRowVector({column});
+  auto rowType = asRowType(rows->type());
+  std::vector<std::shared_ptr<TempFilePath>> files;
+  auto writeConfig = std::make_shared<dwrf::Config>();
+  writeConfig->set<uint64_t>(
+      dwrf::Config::STRIPE_SIZE, rows->size() * sizeof(double));
+  int numTotalRows = 0;
+  for (int i = 0; i < 10; ++i) {
+    auto file = TempFilePath::create();
+    if (i % 2 == 0) {
+      std::vector<RowVectorPtr> vectors;
+      for (int j = 0; j < 100; ++j) {
+        vectors.push_back(rows);
+      }
+      writeToFile(file->getPath(), vectors, writeConfig);
+      numTotalRows += rows->size() * vectors.size();
+    } else {
+      writeToFile(file->getPath(), {rows}, writeConfig);
+      numTotalRows += rows->size();
+    }
+    files.push_back(file);
+  }
+  CursorParameters params;
+  params.planNode =
+      PlanBuilder().tableScan(rowType, {}, "rand() < 0.01").planNode();
+  auto cursor = TaskCursor::create(params);
+  for (auto& file : files) {
+    cursor->task()->addSplit("0", makeHiveSplit(file->getPath()));
+  }
+  cursor->task()->noMoreSplits("0");
+  int numRows = 0;
+  while (cursor->moveNext()) {
+    auto result = cursor->current();
+    VELOX_CHECK_GT(result->size(), 0);
+    numRows += result->size();
+  }
+  ASSERT_TRUE(waitForTaskCompletion(cursor->task().get()));
+  ASSERT_GT(getSkippedStridesStat(cursor->task()), 0);
+  double expectedNumRows = 0.01 * numTotalRows;
+  ASSERT_LT(abs(numRows - expectedNumRows) / expectedNumRows, 0.1);
+}
+
 /// Test the handling of constant remaining filter results which occur when
 /// filter input is a dictionary vector with all indices being the same (i.e.
 /// DictionaryVector::isConstant() == true).
@@ -2465,7 +3561,7 @@ TEST_F(TableScanTest, remainingFilterConstantResult) {
   };
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, data);
+  writeToFile(filePath->getPath(), data);
   createDuckDbTable(data);
 
   auto rowType = asRowType(data[0]->type());
@@ -2484,7 +3580,7 @@ TEST_F(TableScanTest, remainingFilterConstantResult) {
 TEST_F(TableScanTest, aggregationPushdown) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   // Get the number of values processed via aggregation pushdown into scan.
@@ -2555,7 +3651,10 @@ TEST_F(TableScanTest, aggregationPushdown) {
   // Add remaining filter to scan to expose LazyVectors wrapped in Dictionary to
   // aggregation.
   op = PlanBuilder()
-           .tableScan(rowType_, {}, "length(c5) % 2 = 0")
+           .startTableScan()
+           .outputType(rowType_)
+           .remainingFilter("length(c5) % 2 = 0")
+           .endTableScan()
            .singleAggregation({"c5"}, {"max(c0)"})
            .planNode();
   task = assertQuery(
@@ -2600,7 +3699,7 @@ TEST_F(TableScanTest, aggregationPushdown) {
 TEST_F(TableScanTest, bitwiseAggregationPushdown) {
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   auto op = PlanBuilder()
@@ -2634,6 +3733,65 @@ TEST_F(TableScanTest, bitwiseAggregationPushdown) {
       "SELECT c5, bit_or(c0), bit_or(c1), bit_or(c2), bit_or(c6) FROM tmp group by c5");
 }
 
+TEST_F(TableScanTest, aggregationPushdownSchemaEvolution) {
+  const std::unordered_map<std::string, const char*> duckDbAgg = {
+      {"bitwise_and_agg", "bit_and"},
+      {"bitwise_or_agg", "bit_or"},
+  };
+  auto test = [&](const TypePtr& dataType,
+                  const TypePtr& schemaType,
+                  const std::vector<const char*>& aggs) {
+    SCOPED_TRACE(
+        fmt::format("{} to {}", dataType->toString(), schemaType->toString()));
+    constexpr int kSize = 1000;
+    auto vectors =
+        makeVectors(1, kSize, ROW({"c0", "c1"}, {TINYINT(), dataType}));
+    auto filePath = TempFilePath::create();
+    createDuckDbTable(vectors);
+    writeToFile(filePath->getPath(), vectors);
+    for (const char* agg : aggs) {
+      SCOPED_TRACE(agg);
+      auto plan = PlanBuilder()
+                      .tableScan(ROW({"c0", "c1"}, {TINYINT(), schemaType}))
+                      .singleAggregation({"c0"}, {fmt::format("{}(c1)", agg)})
+                      .planNode();
+      auto it = duckDbAgg.find(agg);
+      auto task = assertQuery(
+          plan,
+          {filePath},
+          fmt::format(
+              "SELECT c0, {}(c1) FROM tmp GROUP BY 1",
+              it == duckDbAgg.end() ? agg : it->second));
+      auto stats = task->taskStats();
+      ASSERT_EQ(
+          stats.pipelineStats[0]
+              .operatorStats[1]
+              .runtimeStats.at("loadedToValueHook")
+              .sum,
+          kSize);
+    }
+  };
+  test(BOOLEAN(), TINYINT(), {"min", "max"});
+  test(BOOLEAN(), BIGINT(), {"min", "max"});
+  test(
+      TINYINT(),
+      INTEGER(),
+      {"min", "max", "sum", "bitwise_and_agg", "bitwise_or_agg"});
+  test(
+      TINYINT(),
+      BIGINT(),
+      {"min", "max", "sum", "bitwise_and_agg", "bitwise_or_agg"});
+  test(
+      SMALLINT(),
+      INTEGER(),
+      {"min", "max", "sum", "bitwise_and_agg", "bitwise_or_agg"});
+  test(
+      INTEGER(),
+      BIGINT(),
+      {"min", "max", "sum", "bitwise_and_agg", "bitwise_or_agg"});
+  test(REAL(), DOUBLE(), {"min", "max", "sum"});
+}
+
 TEST_F(TableScanTest, structLazy) {
   vector_size_t size = 1'000;
   auto rowVector = makeRowVector(
@@ -2646,7 +3804,7 @@ TEST_F(TableScanTest, structLazy) {
            [](auto row) { return row * 0.1; })})});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {rowVector});
+  writeToFile(filePath->getPath(), {rowVector});
 
   // Exclude struct columns as DuckDB doesn't support complex types yet.
   createDuckDbTable(
@@ -2668,8 +3826,8 @@ TEST_F(TableScanTest, interleaveLazyEager) {
        makeRowVector({makeFlatVector<int64_t>(kSize, folly::identity)})});
   auto rows = makeRowVector({column});
   auto rowType = asRowType(rows->type());
-  auto lazyFile = TempFilePath::create();
-  writeToFile(lazyFile->path, {rows});
+  auto Lazyfile = TempFilePath::create();
+  writeToFile(Lazyfile->getPath(), {rows});
   auto rowsWithNulls = makeVectors(1, kSize, rowType);
   int numNonNull = 0;
   for (int i = 0; i < kSize; ++i) {
@@ -2681,24 +3839,28 @@ TEST_F(TableScanTest, interleaveLazyEager) {
     numNonNull += !c0c0->isNullAt(i);
   }
   auto eagerFile = TempFilePath::create();
-  writeToFile(eagerFile->path, rowsWithNulls);
-  auto tableHandle = makeTableHandle(
-      SubfieldFiltersBuilder().add("c0.c0", isNotNull()).build());
+  writeToFile(eagerFile->getPath(), rowsWithNulls);
+
   ColumnHandleMap assignments = {{"c0", regularColumn("c0", column->type())}};
   CursorParameters params;
-  params.planNode =
-      PlanBuilder().tableScan(rowType, tableHandle, assignments).planNode();
-  TaskCursor cursor(params);
-  cursor.task()->addSplit("0", makeHiveSplit(lazyFile->path));
-  cursor.task()->addSplit("0", makeHiveSplit(eagerFile->path));
-  cursor.task()->addSplit("0", makeHiveSplit(lazyFile->path));
-  cursor.task()->noMoreSplits("0");
+  params.planNode = PlanBuilder()
+                        .startTableScan()
+                        .outputType(rowType)
+                        .subfieldFilter("c0.c0 is not null")
+                        .assignments(assignments)
+                        .endTableScan()
+                        .planNode();
+  auto cursor = TaskCursor::create(params);
+  cursor->task()->addSplit("0", makeHiveSplit(Lazyfile->getPath()));
+  cursor->task()->addSplit("0", makeHiveSplit(eagerFile->getPath()));
+  cursor->task()->addSplit("0", makeHiveSplit(Lazyfile->getPath()));
+  cursor->task()->noMoreSplits("0");
   for (int i = 0; i < 3; ++i) {
-    ASSERT_TRUE(cursor.moveNext());
-    auto result = cursor.current();
+    ASSERT_TRUE(cursor->moveNext());
+    auto result = cursor->current();
     ASSERT_EQ(result->size(), i % 2 == 0 ? kSize : numNonNull);
   }
-  ASSERT_FALSE(cursor.moveNext());
+  ASSERT_FALSE(cursor->moveNext());
 }
 
 TEST_F(TableScanTest, lazyVectorAccessTwiceWithDifferentRows) {
@@ -2708,7 +3870,7 @@ TEST_F(TableScanTest, lazyVectorAccessTwiceWithDifferentRows) {
   });
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {data});
+  writeToFile(filePath->getPath(), {data});
   createDuckDbTable({data});
 
   auto plan =
@@ -2754,7 +3916,7 @@ TEST_F(TableScanTest, structInArrayOrMap) {
            innerRow)});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {rowVector});
+  writeToFile(filePath->getPath(), {rowVector});
 
   // Exclude struct columns as DuckDB doesn't support complex types yet.
   createDuckDbTable(
@@ -2774,7 +3936,7 @@ TEST_F(TableScanTest, addSplitsToFailedTask) {
       {makeFlatVector<int32_t>(12'000, [](auto row) { return row % 5; })});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {data});
+  writeToFile(filePath->getPath(), {data});
 
   core::PlanNodeId scanNodeId;
   exec::test::CursorParameters params;
@@ -2784,16 +3946,16 @@ TEST_F(TableScanTest, addSplitsToFailedTask) {
                         .project({"5 / c0"})
                         .planNode();
 
-  auto cursor = std::make_unique<exec::test::TaskCursor>(params);
-  cursor->task()->addSplit(scanNodeId, makeHiveSplit(filePath->path));
+  auto cursor = exec::test::TaskCursor::create(params);
+  cursor->task()->addSplit(scanNodeId, makeHiveSplit(filePath->getPath()));
 
   EXPECT_THROW(while (cursor->moveNext()){}, VeloxUserError);
 
   // Verify that splits can be added to the task ever after task has failed.
   // In this case these splits will be ignored.
-  cursor->task()->addSplit(scanNodeId, makeHiveSplit(filePath->path));
+  cursor->task()->addSplit(scanNodeId, makeHiveSplit(filePath->getPath()));
   cursor->task()->addSplitWithSequence(
-      scanNodeId, makeHiveSplit(filePath->path), 20L);
+      scanNodeId, makeHiveSplit(filePath->getPath()), 20L);
   cursor->task()->setMaxSplitSequenceId(scanNodeId, 20L);
 }
 
@@ -2802,7 +3964,7 @@ TEST_F(TableScanTest, errorInLoadLazy) {
   VELOX_CHECK_NOT_NULL(cache);
   auto vectors = makeVectors(10, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
 
   std::atomic<int32_t> counter = 0;
   cache->setVerifyHook([&](const cache::AsyncDataCacheEntry&) {
@@ -2829,7 +3991,7 @@ TEST_F(TableScanTest, errorInLoadLazy) {
     assertQuery(planNode, {filePath}, "");
     FAIL() << "Excepted exception";
   } catch (VeloxException& ex) {
-    EXPECT_TRUE(ex.context().find(filePath->path, 0) != std::string::npos)
+    EXPECT_TRUE(ex.context().find(filePath->getPath(), 0) != std::string::npos)
         << ex.context();
   }
 }
@@ -2838,12 +4000,11 @@ TEST_F(TableScanTest, parallelPrepare) {
   constexpr int32_t kNumParallel = 100;
   const char* kLargeRemainingFilter =
       "c0 + 1::BIGINT > 0::BIGINT or 1111 in (1, 2, 3, 4, 5) or array_sort(array_distinct(array[1, 1, 3, 4, 5, 6,7]))[1] = -5";
-  FLAGS_split_preload_per_driver = kNumParallel;
   auto data = makeRowVector(
       {makeFlatVector<int32_t>(10, [](auto row) { return row % 5; })});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {data});
+  writeToFile(filePath->getPath(), {data});
   auto plan =
       exec::test::PlanBuilder(pool_.get())
           .tableScan(ROW({"c0"}, {INTEGER()}), {}, kLargeRemainingFilter)
@@ -2852,9 +4013,14 @@ TEST_F(TableScanTest, parallelPrepare) {
 
   std::vector<exec::Split> splits;
   for (auto i = 0; i < kNumParallel; ++i) {
-    splits.push_back(makeHiveSplit(filePath->path));
+    splits.push_back(makeHiveSplit(filePath->getPath()));
   }
-  AssertQueryBuilder(plan).splits(splits).copyResults(pool_.get());
+  AssertQueryBuilder(plan)
+      .config(
+          core::QueryConfig::kMaxSplitPreloadPerDriver,
+          std::to_string(kNumParallel))
+      .splits(splits)
+      .copyResults(pool_.get());
 }
 
 TEST_F(TableScanTest, dictionaryMemo) {
@@ -2875,7 +4041,7 @@ TEST_F(TableScanTest, dictionaryMemo) {
   auto rows = makeRowVector({"a", "b"}, {dict, makeRowVector({"c"}, {dict})});
   auto rowType = asRowType(rows->type());
   auto file = TempFilePath::create();
-  writeToFile(file->path, {rows});
+  writeToFile(file->getPath(), {rows});
   auto plan = PlanBuilder()
                   .tableScan(rowType, {}, "a like '%m'")
                   .project({"length(b.c)"})
@@ -2893,7 +4059,7 @@ TEST_F(TableScanTest, dictionaryMemo) {
       }));
 #endif
   auto result = AssertQueryBuilder(plan)
-                    .splits({makeHiveSplit(file->path)})
+                    .splits({makeHiveSplit(file->getPath())})
                     .copyResults(pool_.get());
   ASSERT_EQ(result->size(), 50);
 #ifndef NDEBUG
@@ -2901,57 +4067,17 @@ TEST_F(TableScanTest, dictionaryMemo) {
 #endif
 }
 
-TEST_F(TableScanTest, filterPushdownDisabledChecks) {
-  auto data = makeRowVector({makeFlatVector<int32_t>(10, folly::identity)});
-  auto rowType = asRowType(data->type());
-  auto file = TempFilePath::create();
-  writeToFile(file->path, {data});
-  ColumnHandleMap assignments = {
-      {"ds", partitionKey("ds", VARCHAR())},
-      {"c0", regularColumn("c0", INTEGER())},
-  };
-  auto split = HiveConnectorSplitBuilder(file->path)
-                   .partitionKey("ds", "2023-07-12")
-                   .build();
-
-  auto tableHandle = makeTableHandle(
-      SubfieldFiltersBuilder().add("ds", equal("2023-07-12")).build(),
-      nullptr,
-      "hive_table",
-      nullptr,
-      false);
-  auto plan = exec::test::PlanBuilder(pool_.get())
-                  .tableScan(rowType, tableHandle, assignments)
-                  .planNode();
-  AssertQueryBuilder(plan).splits({split}).assertResults(data);
-
-  tableHandle = makeTableHandle(
-      SubfieldFiltersBuilder().add("c0", equal(5)).build(),
-      nullptr,
-      "hive_table",
-      nullptr,
-      false);
-  plan = exec::test::PlanBuilder(pool_.get())
-             .tableScan(rowType, tableHandle, assignments)
-             .planNode();
-  auto query = AssertQueryBuilder(plan);
-  query.splits({split});
-  VELOX_ASSERT_THROW(
-      query.copyResults(pool_.get()),
-      "Unexpected filter on table hive_table, field c0");
-}
-
 TEST_F(TableScanTest, reuseRowVector) {
   auto iota = makeFlatVector<int32_t>(10, folly::identity);
   auto data = makeRowVector({iota, makeRowVector({iota})});
   auto rowType = asRowType(data->type());
   auto file = TempFilePath::create();
-  writeToFile(file->path, {data});
+  writeToFile(file->getPath(), {data});
   auto plan = PlanBuilder()
                   .tableScan(rowType, {}, "c0 < 5")
                   .project({"c1.c0"})
                   .planNode();
-  auto split = HiveConnectorSplitBuilder(file->path).build();
+  auto split = HiveConnectorSplitBuilder(file->getPath()).build();
   auto expected = makeRowVector(
       {makeFlatVector<int32_t>(10, [](auto i) { return i % 5; })});
   AssertQueryBuilder(plan).splits({split, split}).assertResults(expected);
@@ -2963,12 +4089,12 @@ TEST_F(TableScanTest, readMissingFields) {
   auto iota = makeFlatVector<int64_t>(size, folly::identity);
   auto rowVector = makeRowVector({makeRowVector({iota, iota}), iota});
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {rowVector});
+  writeToFile(filePath->getPath(), {rowVector});
   // Create a row type with additional fields not present in the file.
   auto rowType = makeRowType(
       {makeRowType({BIGINT(), BIGINT(), BIGINT(), BIGINT()}), BIGINT()});
   auto op = PlanBuilder().tableScan(rowType).planNode();
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto nulls = makeNullConstant(TypeKind::BIGINT, size);
   auto expected =
       makeRowVector({makeRowVector({iota, iota, nulls, nulls}), iota});
@@ -2980,10 +4106,10 @@ TEST_F(TableScanTest, readExtraFields) {
   auto iota = makeFlatVector<int64_t>(size, folly::identity);
   auto rowVector = makeRowVector({makeRowVector({iota, iota}), iota});
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {rowVector});
+  writeToFile(filePath->getPath(), {rowVector});
   auto rowType = makeRowType({makeRowType({BIGINT()}), BIGINT()});
   auto op = PlanBuilder().tableScan(rowType).planNode();
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto nulls = makeNullConstant(TypeKind::BIGINT, size);
   auto expected = makeRowVector({makeRowVector({iota}), iota});
   AssertQueryBuilder(op).split(split).assertResults(expected);
@@ -2999,7 +4125,7 @@ TEST_F(TableScanTest, readMissingFieldsFilesVary) {
   })});
 
   auto missingFieldsFilePath = TempFilePath::create();
-  writeToFile(missingFieldsFilePath->path, {rowVectorMissingFields});
+  writeToFile(missingFieldsFilePath->getPath(), {rowVectorMissingFields});
 
   auto rowVectorWithAllFields = makeRowVector({makeRowVector({
       makeFlatVector<int64_t>(size, [](auto row) { return row; }),
@@ -3009,19 +4135,20 @@ TEST_F(TableScanTest, readMissingFieldsFilesVary) {
   })});
 
   auto allFieldsFilePath = TempFilePath::create();
-  writeToFile(allFieldsFilePath->path, {rowVectorWithAllFields});
+  writeToFile(allFieldsFilePath->getPath(), {rowVectorWithAllFields});
 
   auto op = PlanBuilder()
                 .tableScan(asRowType(rowVectorWithAllFields->type()))
                 .project({"c0.c0", "c0.c1", "c0.c2", "c0.c3"})
                 .planNode();
 
-  auto result = AssertQueryBuilder(op)
-                    .split(makeHiveConnectorSplit(missingFieldsFilePath->path))
-                    .split(makeHiveConnectorSplit(allFieldsFilePath->path))
-                    .split(makeHiveConnectorSplit(missingFieldsFilePath->path))
-                    .split(makeHiveConnectorSplit(allFieldsFilePath->path))
-                    .copyResults(pool());
+  auto result =
+      AssertQueryBuilder(op)
+          .split(makeHiveConnectorSplit(missingFieldsFilePath->getPath()))
+          .split(makeHiveConnectorSplit(allFieldsFilePath->getPath()))
+          .split(makeHiveConnectorSplit(missingFieldsFilePath->getPath()))
+          .split(makeHiveConnectorSplit(allFieldsFilePath->getPath()))
+          .copyResults(pool());
 
   ASSERT_EQ(result->size(), size * 4);
   auto rows = result->as<RowVector>();
@@ -3080,7 +4207,7 @@ TEST_F(TableScanTest, readMissingFieldsInArray) {
   auto arrayVector = makeArrayVector(offsets, rowVector);
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {makeRowVector({arrayVector})});
+  writeToFile(filePath->getPath(), {makeRowVector({arrayVector})});
   // Create a row type with additional fields not present in the file.
   auto rowType = makeRowType(
       {ARRAY(makeRowType({BIGINT(), BIGINT(), BIGINT(), BIGINT()}))});
@@ -3091,7 +4218,7 @@ TEST_F(TableScanTest, readMissingFieldsInArray) {
                 .project({"c0[1].c0", "c0[2].c1", "c0[3].c2", "c0[4].c3"})
                 .planNode();
 
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
 
   ASSERT_EQ(result->size(), size);
@@ -3137,7 +4264,7 @@ TEST_F(TableScanTest, readMissingFieldsInMap) {
   auto arrayVector = makeArrayVector(offsets, valuesVector);
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {makeRowVector({mapVector, arrayVector})});
+  writeToFile(filePath->getPath(), {makeRowVector({mapVector, arrayVector})});
 
   // Create a row type with additional fields in the structure not present in
   // the file ('c' and 'd') and with all columns having different names than in
@@ -3148,7 +4275,10 @@ TEST_F(TableScanTest, readMissingFieldsInMap) {
       ROW({"m1", "a2"}, {{MAP(BIGINT(), structType), ARRAY(structType)}});
 
   auto op = PlanBuilder()
-                .tableScan(rowType, {}, "", rowType)
+                .startTableScan()
+                .outputType(rowType)
+                .dataColumns(rowType)
+                .endTableScan()
                 .project(
                     {"m1[0].a",
                      "m1[1].b",
@@ -3160,7 +4290,7 @@ TEST_F(TableScanTest, readMissingFieldsInMap) {
                      "a2[4].d"})
                 .planNode();
 
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
 
   ASSERT_EQ(result->size(), size);
@@ -3207,9 +4337,9 @@ TEST_F(TableScanTest, readMissingFieldsInMap) {
   // Now run query with column mapping using names - we should not be able to
   // find any names.
   result = AssertQueryBuilder(op)
-               .connectorConfig(
+               .connectorSessionProperty(
                    kHiveConnectorId,
-                   connector::hive::HiveConfig::kOrcUseColumnNames,
+                   connector::hive::HiveConfig::kOrcUseColumnNamesSession,
                    "true")
                .split(split)
                .copyResults(pool());
@@ -3256,7 +4386,10 @@ TEST_F(TableScanTest, readMissingFieldsInMap) {
   rowType = ROW({"i1", "a2"}, {{INTEGER(), ARRAY(structType)}});
 
   op = PlanBuilder()
-           .tableScan(rowType, {}, "", rowType)
+           .startTableScan()
+           .outputType(rowType)
+           .dataColumns(rowType)
+           .endTableScan()
            .project({"i1"})
            .planNode();
 
@@ -3264,6 +4397,41 @@ TEST_F(TableScanTest, readMissingFieldsInMap) {
       AssertQueryBuilder(op).split(split).copyResults(pool()), VeloxUserError);
 }
 
+TEST_F(TableScanTest, filterMissingFields) {
+  constexpr int kSize = 10;
+  auto iota = makeFlatVector<int64_t>(kSize, folly::identity);
+  auto data = makeRowVector({makeRowVector({iota})});
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {data});
+  auto schema = makeRowType({
+      makeRowType({BIGINT(), BIGINT()}),
+      makeRowType({BIGINT()}),
+      BIGINT(),
+  });
+  auto test = [&](const std::vector<std::string>& subfieldFilters,
+                  int expectedSize) {
+    SCOPED_TRACE(fmt::format("{}", fmt::join(subfieldFilters, " AND ")));
+    auto plan = PlanBuilder()
+                    .tableScan(ROW({}, {}), subfieldFilters, "", schema)
+                    .planNode();
+    auto split = makeHiveConnectorSplit(file->getPath());
+    auto result = AssertQueryBuilder(plan).split(split).copyResults(pool());
+    ASSERT_EQ(result->size(), expectedSize);
+  };
+  test({"c0.c1 = 0"}, 0);
+  test({"c0.c1 IS NULL"}, kSize);
+  test({"c1 IS NOT NULL"}, 0);
+  test({"c1 IS NULL"}, kSize);
+  test({"c1.c0 = 0"}, 0);
+  test({"c1.c0 IS NULL"}, kSize);
+  test({"c2 = 0"}, 0);
+  test({"c2 IS NULL"}, kSize);
+  test({"c2 = 0", "c0.c1 IS NULL"}, 0);
+  test({"c2 IS NULL", "c0.c1 = 0"}, 0);
+  test({"c0.c0 = 0", "c1.c0 = 0"}, 0);
+  test({"c0.c0 = 0", "c1.c0 IS NULL"}, 1);
+}
+
 // Tests various projections of top level columns using the output type passed
 // into TableScan.
 TEST_F(TableScanTest, tableScanProjections) {
@@ -3276,7 +4444,7 @@ TEST_F(TableScanTest, tableScanProjections) {
   });
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {rowVector});
+  writeToFile(filePath->getPath(), {rowVector});
 
   auto testQueryRow = [&](const std::vector<int32_t>& projections) {
     std::vector<std::string> cols;
@@ -3287,7 +4455,7 @@ TEST_F(TableScanTest, tableScanProjections) {
         std::move(cols), std::vector<TypePtr>(projections.size(), BIGINT()));
     auto op = PlanBuilder().tableScan(scanRowType).planNode();
 
-    auto split = makeHiveConnectorSplit(filePath->path);
+    auto split = makeHiveConnectorSplit(filePath->getPath());
     auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
 
     ASSERT_EQ(result->size(), size);
@@ -3348,7 +4516,7 @@ TEST_F(TableScanTest, readMissingFieldsWithMoreColumns) {
        })});
 
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {rowVector});
+  writeToFile(filePath->getPath(), {rowVector});
 
   // Create a row type with additional fields in the structure not present in
   // the file ('c' and 'd') and with all columns having different names than in
@@ -3361,11 +4529,14 @@ TEST_F(TableScanTest, readMissingFieldsWithMoreColumns) {
 
   auto op =
       PlanBuilder()
-          .tableScan(rowType, {}, "", rowType)
+          .startTableScan()
+          .outputType(rowType)
+          .dataColumns(rowType)
+          .endTableScan()
           .project({"st1.a", "st1.b", "st1.c", "st1.d", "i2", "d3", "b4", "c4"})
           .planNode();
 
-  auto split = makeHiveConnectorSplit(filePath->path);
+  auto split = makeHiveConnectorSplit(filePath->getPath());
   auto result = AssertQueryBuilder(op).split(split).copyResults(pool());
 
   ASSERT_EQ(result->size(), size);
@@ -3426,9 +4597,9 @@ TEST_F(TableScanTest, readMissingFieldsWithMoreColumns) {
   // Now run query with column mapping using names - we should not be able to
   // find any names, except for the last string column.
   result = AssertQueryBuilder(op)
-               .connectorConfig(
+               .connectorSessionProperty(
                    kHiveConnectorId,
-                   connector::hive::HiveConfig::kOrcUseColumnNames,
+                   connector::hive::HiveConfig::kOrcUseColumnNamesSession,
                    "true")
                .split(split)
                .copyResults(pool());
@@ -3480,21 +4651,467 @@ TEST_F(TableScanTest, readMissingFieldsWithMoreColumns) {
 TEST_F(TableScanTest, varbinaryPartitionKey) {
   auto vectors = makeVectors(1, 1'000);
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, vectors);
+  writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
   ColumnHandleMap assignments = {
       {"a", regularColumn("c0", BIGINT())},
       {"ds_alias", partitionKey("ds", VARBINARY())}};
 
-  auto split = HiveConnectorSplitBuilder(filePath->path)
+  auto split = HiveConnectorSplitBuilder(filePath->getPath())
                    .partitionKey("ds", "2021-12-02")
                    .build();
 
   auto outputType = ROW({"a", "ds_alias"}, {BIGINT(), VARBINARY()});
   auto op = PlanBuilder()
-                .tableScan(outputType, makeTableHandle(), assignments)
+                .startTableScan()
+                .outputType(outputType)
+                .assignments(assignments)
+                .endTableScan()
                 .planNode();
 
   assertQuery(op, split, "SELECT c0, '2021-12-02' FROM tmp");
 }
+
+TEST_F(TableScanTest, timestampPartitionKey) {
+  const char* inputs[] = {"2023-10-14 07:00:00.0", "2024-01-06 04:00:00.0"};
+  auto expected = makeRowVector(
+      {"t"},
+      {
+          makeFlatVector<Timestamp>(
+              std::end(inputs) - std::begin(inputs),
+              [&](auto i) {
+                auto t = util::fromTimestampString(
+                             inputs[i], util::TimestampParseMode::kPrestoCast)
+                             .thenOrThrow(
+                                 folly::identity, [&](const Status& status) {
+                                   VELOX_USER_FAIL("{}", status.message());
+                                 });
+                t.toGMT(Timestamp::defaultTimezone());
+                return t;
+              }),
+      });
+  auto vectors = makeVectors(1, 1);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  ColumnHandleMap assignments = {{"t", partitionKey("t", TIMESTAMP())}};
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
+  for (auto& t : inputs) {
+    splits.push_back(HiveConnectorSplitBuilder(filePath->getPath())
+                         .partitionKey("t", t)
+                         .build());
+  }
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(ROW({"t"}, {TIMESTAMP()}))
+                  .assignments(assignments)
+                  .endTableScan()
+                  .planNode();
+  AssertQueryBuilder(plan).splits(std::move(splits)).assertResults(expected);
+}
+
+TEST_F(TableScanTest, partitionKeyNotMatchPartitionKeysHandle) {
+  auto vectors = makeVectors(1, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+
+  auto split = HiveConnectorSplitBuilder(filePath->getPath())
+                   .partitionKey("ds", "2021-12-02")
+                   .build();
+
+  auto outputType = ROW({"c0"}, {BIGINT()});
+  auto op = PlanBuilder()
+                .startTableScan()
+                .outputType(outputType)
+                .endTableScan()
+                .planNode();
+
+  assertQuery(op, split, "SELECT c0 FROM tmp");
+}
+
+TEST_F(TableScanTest, readFlatMapAsStruct) {
+  constexpr int kSize = 10;
+  std::vector<std::string> keys = {"1", "2", "3"};
+  auto vector = makeRowVector({makeRowVector(
+      keys,
+      {
+          makeFlatVector<int64_t>(kSize, folly::identity),
+          makeFlatVector<int64_t>(kSize, folly::identity, nullEvery(5)),
+          makeFlatVector<int64_t>(kSize, folly::identity, nullEvery(7)),
+      })});
+  auto config = std::make_shared<dwrf::Config>();
+  config->set(dwrf::Config::FLATTEN_MAP, true);
+  config->set<const std::vector<uint32_t>>(dwrf::Config::MAP_FLAT_COLS, {0});
+  config->set<const std::vector<std::vector<std::string>>>(
+      dwrf::Config::MAP_FLAT_COLS_STRUCT_KEYS, {keys});
+  auto file = TempFilePath::create();
+  auto writeSchema = ROW({"c0"}, {MAP(INTEGER(), BIGINT())});
+  writeToFile(file->getPath(), {vector}, config, writeSchema);
+  auto readSchema = asRowType(vector->type());
+  auto plan =
+      PlanBuilder().tableScan(readSchema, {}, "", writeSchema).planNode();
+  auto split = makeHiveConnectorSplit(file->getPath());
+  AssertQueryBuilder(plan).split(split).assertResults(vector);
+}
+
+TEST_F(TableScanTest, dynamicFilters) {
+  // Make sure filters on same column from multiple downstream operators are
+  // merged properly without overwriting each other.
+  auto aVector =
+      makeRowVector({"a"}, {makeFlatVector<int64_t>(20'000, folly::identity)});
+  auto bVector =
+      makeRowVector({"b"}, {makeFlatVector<int64_t>(10'000, folly::identity)});
+  auto cVector = makeRowVector(
+      {"c"},
+      {makeFlatVector<int64_t>(10'000, [](auto i) { return i + 10'000; })});
+  std::shared_ptr<TempFilePath> files[3];
+  files[0] = TempFilePath::create();
+  writeToFile(files[0]->getPath(), {aVector});
+  files[1] = TempFilePath::create();
+  writeToFile(files[1]->getPath(), {bVector});
+  files[2] = TempFilePath::create();
+  writeToFile(files[2]->getPath(), {cVector});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aScanId;
+  core::PlanNodeId bScanId;
+  core::PlanNodeId cScanId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(ROW({"a"}, {BIGINT()}))
+                  .capturePlanNodeId(aScanId)
+                  .hashJoin(
+                      {"a"},
+                      {"b"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(ROW({"b"}, {BIGINT()}))
+                          .capturePlanNodeId(bScanId)
+                          .planNode(),
+                      "", /*filter*/
+                      {"a"})
+                  .hashJoin(
+                      {"a"},
+                      {"c"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(ROW({"c"}, {BIGINT()}))
+                          .capturePlanNodeId(cScanId)
+                          .planNode(),
+                      "", /*filter*/
+                      {"a"})
+                  .planNode();
+  AssertQueryBuilder(plan)
+      .split(aScanId, makeHiveConnectorSplit(files[0]->getPath()))
+      .split(bScanId, makeHiveConnectorSplit(files[1]->getPath()))
+      .split(cScanId, makeHiveConnectorSplit(files[2]->getPath()))
+      .assertResults(makeRowVector({makeFlatVector<int64_t>(0)}));
+}
+
+TEST_F(TableScanTest, dynamicFilterWithRowIndexColumn) {
+  // This test ensures dynamic filters can be mapped to correct field when there
+  // is row_index column.
+  auto aVector =
+      makeRowVector({"a"}, {makeFlatVector<int64_t>(10, folly::identity)});
+  auto bVector = makeRowVector({"b"}, {makeFlatVector<int64_t>(10, [](auto i) {
+                                 if (i < 5) {
+                                   return i;
+                                 } else {
+                                   return 10 + i;
+                                 }
+                               })});
+  auto resVector = makeRowVector(
+      {"row_index", "a"},
+      {makeFlatVector<int64_t>(5, folly::identity),
+       makeFlatVector<int64_t>(5, folly::identity)});
+  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+      assignments;
+  assignments["a"] = std::make_shared<connector::hive::HiveColumnHandle>(
+      "a",
+      connector::hive::HiveColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      BIGINT());
+  assignments["row_index"] =
+      std::make_shared<connector::hive::HiveColumnHandle>(
+          "row_index",
+          connector::hive::HiveColumnHandle::ColumnType::kRowIndex,
+          BIGINT(),
+          BIGINT());
+  std::shared_ptr<TempFilePath> files[2];
+  files[0] = TempFilePath::create();
+  writeToFile(files[0]->getPath(), {aVector});
+  files[1] = TempFilePath::create();
+  writeToFile(files[1]->getPath(), {bVector});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aScanId;
+  core::PlanNodeId bScanId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(
+                      ROW({"row_index", "a"}, {BIGINT(), BIGINT()}),
+                      {},
+                      "",
+                      nullptr,
+                      assignments)
+                  .capturePlanNodeId(aScanId)
+                  .hashJoin(
+                      {"a"},
+                      {"b"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(ROW({"b"}, {BIGINT()}))
+                          .capturePlanNodeId(bScanId)
+                          .planNode(),
+                      "", /*filter*/
+                      {"row_index", "a"})
+                  .planNode();
+  AssertQueryBuilder(plan)
+      .split(aScanId, makeHiveConnectorSplit(files[0]->getPath()))
+      .split(bScanId, makeHiveConnectorSplit(files[1]->getPath()))
+      .assertResults(resVector);
+}
+
+// TODO: re-enable this test once we add back driver suspension support for
+// table scan.
+TEST_F(TableScanTest, DISABLED_memoryArbitrationWithSlowTableScan) {
+  const size_t numFiles{2};
+  std::vector<std::shared_ptr<TempFilePath>> filePaths;
+  std::vector<RowVectorPtr> vectorsForDuckDb;
+  filePaths.reserve(numFiles);
+  vectorsForDuckDb.reserve(numFiles);
+  for (auto i = 0; i < numFiles; ++i) {
+    auto vectors = makeVectors(5, 128);
+    filePaths.emplace_back(TempFilePath::create(true));
+    writeToFile(filePaths.back()->tempFilePath(), vectors);
+    for (const auto& vector : vectors) {
+      vectorsForDuckDb.emplace_back(vector);
+    }
+  }
+  createDuckDbTable(vectorsForDuckDb);
+
+  std::atomic_bool readWaitFlag{true};
+  folly::EventCount readWait;
+  std::atomic_bool readResumeFlag{true};
+  folly::EventCount readResume;
+
+  auto faultyFs = faultyFileSystem();
+  std::atomic_bool injectOnce{true};
+  faultyFs->setFileInjectionHook([&](FaultFileOperation* readOp) {
+    // Inject memory arbitration at the second read file so as to make sure the
+    // aggregation has accumulated state to spill.
+    if (readOp->path != filePaths.back()->getPath()) {
+      return;
+    }
+    if (!injectOnce.exchange(false)) {
+      return;
+    }
+    readWaitFlag = false;
+    readWait.notifyAll();
+    readResume.await([&]() { return !readResumeFlag.load(); });
+  });
+
+  // Get the number of values processed via aggregation pushdown into scan.
+  auto loadedToValueHook = [](const std::shared_ptr<Task> task,
+                              int operatorIndex = 0) {
+    auto stats = task->taskStats()
+                     .pipelineStats[0]
+                     .operatorStats[operatorIndex]
+                     .runtimeStats;
+    auto it = stats.find("loadedToValueHook");
+    return it != stats.end() ? it->second.sum : 0;
+  };
+
+  core::PlanNodeId aggNodeId;
+  auto op =
+      PlanBuilder()
+          .tableScan(rowType_)
+          .singleAggregation(
+              {"c5"}, {"max(c0)", "max(c1)", "max(c2)", "max(c3)", "max(c4)"})
+          .capturePlanNodeId(aggNodeId)
+          .planNode();
+
+  std::thread queryThread([&]() {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto task = assertQuery(
+        op,
+        filePaths,
+        spillDirectory->getPath(),
+        "SELECT c5, max(c0), max(c1), max(c2), max(c3), max(c4) FROM tmp group by c5");
+    EXPECT_EQ(6400, loadedToValueHook(task, 1));
+    EXPECT_GT(toPlanStats(task->taskStats()).at(aggNodeId).spilledBytes, 0);
+  });
+
+  readWait.await([&]() { return !readWaitFlag.load(); });
+
+  memory::testingRunArbitration();
+
+  readResumeFlag = false;
+  readResume.notifyAll();
+
+  queryThread.join();
+}
+
+// TODO: re-enable this test once we add back driver suspension support for
+// table scan.
+DEBUG_ONLY_TEST_F(
+    TableScanTest,
+    DISABLED_memoryArbitrationByTableScanAllocation) {
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+
+  std::atomic_bool injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe",
+      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+        const std::string re(".*TableScan.*");
+        if (!RE2::FullMatch(pool->name(), re)) {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        VELOX_ASSERT_THROW(
+            pool->allocate(memory::memoryManager()->capacity()), "");
+      }));
+
+  auto op =
+      PlanBuilder()
+          .tableScan(rowType_)
+          .singleAggregation(
+              {"c5"}, {"max(c0)", "max(c1)", "max(c2)", "max(c3)", "max(c4)"})
+          .planNode();
+  assertQuery(
+      op,
+      {filePath},
+      "SELECT c5, max(c0), max(c1), max(c2), max(c3), max(c4) FROM tmp group by c5");
+}
+
+TEST_F(TableScanTest, noCacheRetention) {
+  const auto vectors = makeVectors(10, 1'000);
+  const auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+
+  for (const bool noCacheRetention : {true}) {
+    SCOPED_TRACE(fmt::format("noCacheRetention: {}", noCacheRetention));
+
+    auto split = makeHiveConnectorSplit(
+        filePath->getPath(), 0, fs::file_size(filePath->getPath()));
+    AssertQueryBuilder(tableScanNode(), duckDbQueryRunner_)
+        .connectorSessionProperty(
+            kHiveConnectorId,
+            connector::hive::HiveConfig::kCacheNoRetentionSession,
+            noCacheRetention ? "true" : "false")
+        .split(std::move(split))
+        .assertResults("SELECT * FROM tmp");
+    waitForAllTasksToBeDeleted();
+
+    const auto cacheEntries = asyncDataCache_->testingCacheEntries();
+    if (noCacheRetention) {
+      for (const auto& cacheEntry : cacheEntries) {
+        if (!cacheEntry->testingFirstUse()) {
+          ASSERT_EQ(cacheEntry->testingAccessStats().lastUse, 0)
+              << cacheEntry->toString();
+        }
+        ASSERT_EQ(cacheEntry->testingAccessStats().numUses, 0)
+            << cacheEntry->toString();
+      }
+    } else {
+      for (const auto& cacheEntry : cacheEntries) {
+        if (cacheEntry->testingFirstUse()) {
+          ASSERT_EQ(cacheEntry->testingAccessStats().numUses, 0)
+              << cacheEntry->toString();
+        } else {
+          ASSERT_GT(cacheEntry->testingAccessStats().numUses, 0)
+              << cacheEntry->toString();
+        }
+        ASSERT_NE(cacheEntry->testingAccessStats().lastUse, 0)
+            << cacheEntry->toString();
+      }
+    }
+  }
+}
+
+DEBUG_ONLY_TEST_F(TableScanTest, cancellationToken) {
+  const auto vectors = makeVectors(10, 1'000);
+  const auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+
+  std::atomic_bool cancelled{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::connector::hive::HiveDataSource::next",
+      std::function<void(connector::hive::HiveDataSource*)>(
+          [&](connector::hive::HiveDataSource* source) {
+            auto cancellationToken =
+                source->testingConnectorQueryCtx()->cancellationToken();
+            while (true) {
+              cancelled = cancellationToken.isCancellationRequested();
+              if (cancelled) {
+                break;
+              }
+              std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            }
+          }));
+
+  std::atomic<Task*> task{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::TableScan::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        task = op->testingOperatorCtx()->task().get();
+      }));
+
+  std::thread queryThread([&]() {
+    auto split = makeHiveConnectorSplit(
+        filePath->getPath(), 0, fs::file_size(filePath->getPath()));
+    VELOX_ASSERT_THROW(
+        AssertQueryBuilder(tableScanNode(), duckDbQueryRunner_)
+            .split(std::move(split))
+            .assertResults("SELECT * FROM tmp"),
+        "Cancelled");
+    waitForAllTasksToBeDeleted();
+  });
+
+  while (task == nullptr) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+  ASSERT_FALSE(cancelled);
+
+  task.load()->requestCancel();
+  while (!cancelled) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+  queryThread.join();
+}
+
+TEST_F(TableScanTest, rowNumberInRemainingFilter) {
+  constexpr int kSize = 100;
+  auto vector = makeRowVector({
+      makeFlatVector<int64_t>(kSize, folly::identity),
+  });
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  auto outputType = ROW({"c1"}, {BIGINT()});
+  auto schema = ROW({"c1", "r1"}, {BIGINT(), BIGINT()});
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .dataColumns(schema)
+                  .assignments({
+                      {"c1", makeColumnHandle("c1", BIGINT(), {})},
+                      {"r1",
+                       std::make_shared<HiveColumnHandle>(
+                           "r1",
+                           HiveColumnHandle::ColumnType::kRowIndex,
+                           BIGINT(),
+                           BIGINT())},
+                  })
+                  .remainingFilter("r1 % 2 == 0")
+                  .endTableScan()
+                  .planNode();
+  auto expected = makeRowVector(
+      {"c1"}, {makeFlatVector<int64_t>(kSize / 2, [](vector_size_t row) {
+        return row * 2;
+      })});
+  AssertQueryBuilder(plan)
+      .split(makeHiveConnectorSplit(file->getPath()))
+      .assertResults(expected);
+}
diff --git a/velox/exec/tests/TableWriteTest.cpp b/velox/exec/tests/TableWriteTest.cpp
index 5df5ed9e68118..594193b1afe73 100644
--- a/velox/exec/tests/TableWriteTest.cpp
+++ b/velox/exec/tests/TableWriteTest.cpp
@@ -21,6 +21,7 @@
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HivePartitionFunction.h"
 #include "velox/dwio/common/WriterFactory.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/TableWriter.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
@@ -30,6 +31,12 @@
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 #include <re2/re2.h>
+#include <string>
+#include "folly/experimental/EventCount.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::core;
@@ -46,6 +53,7 @@ enum class TestMode {
   kUnpartitioned,
   kPartitioned,
   kBucketed,
+  kOnlyBucketed,
 };
 
 std::string testModeString(TestMode mode) {
@@ -56,7 +64,10 @@ std::string testModeString(TestMode mode) {
       return "PARTITIONED";
     case TestMode::kBucketed:
       return "BUCKETED";
+    case TestMode::kOnlyBucketed:
+      return "BUCKETED (NOT PARTITIONED)";
   }
+  VELOX_UNREACHABLE();
 }
 
 static std::shared_ptr<core::AggregationNode> generateAggregationNode(
@@ -106,6 +117,23 @@ std::function<PlanNodePtr(std::string, PlanNodePtr)> addTableWriter(
   };
 }
 
+RowTypePtr getNonPartitionsColumns(
+    const std::vector<std::string>& partitionedKeys,
+    const RowTypePtr& rowType) {
+  std::vector<std::string> dataColumnNames;
+  std::vector<TypePtr> dataColumnTypes;
+  for (auto i = 0; i < rowType->size(); i++) {
+    auto name = rowType->names()[i];
+    if (std::find(partitionedKeys.cbegin(), partitionedKeys.cend(), name) ==
+        partitionedKeys.cend()) {
+      dataColumnNames.emplace_back(name);
+      dataColumnTypes.emplace_back(rowType->findChild(name));
+    }
+  }
+
+  return ROW(std::move(dataColumnNames), std::move(dataColumnTypes));
+}
+
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(std::ostream& os, TestMode mode) {
   os << testModeString(mode);
   return os;
@@ -137,7 +165,7 @@ struct TestParam {
 
   CompressionKind compressionKind() const {
     return static_cast<facebook::velox::common::CompressionKind>(
-        (value & ((1L << 48) - 1)) >> 40);
+        (value & ((1L << 56) - 1)) >> 48);
   }
 
   bool multiDrivers() const {
@@ -167,13 +195,14 @@ struct TestParam {
 
   std::string toString() const {
     return fmt::format(
-        "FileFormat[{}] TestMode[{}] commitStrategy[{}] bucketKind[{}] bucketSort[{}] multiDrivers[{}]",
-        fileFormat(),
-        testMode(),
-        commitStrategy(),
-        bucketKind(),
+        "FileFormat[{}] TestMode[{}] commitStrategy[{}] bucketKind[{}] bucketSort[{}] multiDrivers[{}] compression[{}]",
+        dwio::common::toString((fileFormat())),
+        testModeString(testMode()),
+        commitStrategyToString(commitStrategy()),
+        HiveBucketProperty::kindString(bucketKind()),
         bucketSort(),
-        multiDrivers());
+        multiDrivers(),
+        compressionKindToString(compressionKind()));
   }
 };
 
@@ -195,23 +224,30 @@ class TableWriteTest : public HiveConnectorTestBase {
         ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
             {BIGINT(), INTEGER(), SMALLINT(), REAL(), DOUBLE(), VARCHAR()});
     setDataTypes(rowType);
-    if (testMode_ != TestMode::kUnpartitioned) {
+    if (testMode_ == TestMode::kPartitioned ||
+        testMode_ == TestMode::kBucketed) {
       const std::vector<std::string> partitionBy = {"c0", "c1"};
       setPartitionBy(partitionBy);
       numPartitionKeyValues_ = {4, 4};
     }
-    if (testMode_ == TestMode::kBucketed) {
+    if (testMode_ == TestMode::kBucketed ||
+        testMode_ == TestMode::kOnlyBucketed) {
       std::vector<std::string> bucketedBy = {"c3", "c5"};
       std::vector<TypePtr> bucketedTypes = {REAL(), VARCHAR()};
       std::vector<std::shared_ptr<const HiveSortingColumn>> sortedBy;
       if (testParam_.bucketSort()) {
-        sortedBy = {
-            std::make_shared<const HiveSortingColumn>(
-                "c4", core::SortOrder{true, true}),
-            std::make_shared<const HiveSortingColumn>(
-                "c1", core::SortOrder{false, false})};
-        sortColumnIndices_ = {4, 1};
-        sortedFlags_ = {{true, true}, {false, false}};
+        // The sortedBy key shouldn't contain partitionBy key.
+        sortedBy = {std::make_shared<const HiveSortingColumn>(
+            "c4", core::SortOrder{true, true})};
+        // The sortColumnIndices_ should represent the indices after removing
+        // the partition keys.
+        if (testMode_ == TestMode::kBucketed) {
+          sortColumnIndices_ = {2};
+        } else {
+          sortColumnIndices_ = {4};
+        }
+
+        sortedFlags_ = {{true, true}};
       }
       bucketProperty_ = std::make_shared<HiveBucketProperty>(
           testParam_.bucketKind(), 4, bucketedBy, bucketedTypes, sortedBy);
@@ -222,19 +258,34 @@ class TableWriteTest : public HiveConnectorTestBase {
     HiveConnectorTestBase::SetUp();
   }
 
-  void TearDown() override {
-    HiveConnectorTestBase::TearDown();
-  }
-
   std::shared_ptr<Task> assertQueryWithWriterConfigs(
       const core::PlanNodePtr& plan,
       std::vector<std::shared_ptr<TempFilePath>> filePaths,
-      const std::string& duckDbSql) {
+      const std::string& duckDbSql,
+      bool spillEnabled = false) {
     std::vector<Split> splits;
     for (const auto& filePath : filePaths) {
-      splits.push_back(exec::Split(makeHiveConnectorSplit(filePath->path)));
+      splits.push_back(
+          exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+    }
+    if (!spillEnabled) {
+      return AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .maxDrivers(
+              2 *
+              std::max(kNumTableWriterCount, kNumPartitionedTableWriterCount))
+          .config(
+              QueryConfig::kTaskWriterCount,
+              std::to_string(numTableWriterCount_))
+          .config(
+              QueryConfig::kTaskPartitionedWriterCount,
+              std::to_string(numPartitionedTableWriterCount_))
+          .splits(splits)
+          .assertResults(duckDbSql);
     }
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    TestScopedSpillInjection scopedSpillInjection(100);
     return AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .spillDirectory(spillDirectory->getPath())
         .maxDrivers(
             2 * std::max(kNumTableWriterCount, kNumPartitionedTableWriterCount))
         .config(
@@ -242,14 +293,37 @@ class TableWriteTest : public HiveConnectorTestBase {
         .config(
             QueryConfig::kTaskPartitionedWriterCount,
             std::to_string(numPartitionedTableWriterCount_))
+        .config(core::QueryConfig::kSpillEnabled, "true")
+        .config(QueryConfig::kWriterSpillEnabled, "true")
         .splits(splits)
         .assertResults(duckDbSql);
   }
 
   std::shared_ptr<Task> assertQueryWithWriterConfigs(
       const core::PlanNodePtr& plan,
-      const std::string& duckDbSql) {
+      const std::string& duckDbSql,
+      bool enableSpill = false) {
+    if (!enableSpill) {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      return AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .maxDrivers(
+              2 *
+              std::max(kNumTableWriterCount, kNumPartitionedTableWriterCount))
+          .config(
+              QueryConfig::kTaskWriterCount,
+              std::to_string(numTableWriterCount_))
+          .config(
+              QueryConfig::kTaskPartitionedWriterCount,
+              std::to_string(numPartitionedTableWriterCount_))
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(QueryConfig::kWriterSpillEnabled, "true")
+          .assertResults(duckDbSql);
+    }
+
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    TestScopedSpillInjection scopedSpillInjection(100);
     return AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .spillDirectory(spillDirectory->getPath())
         .maxDrivers(
             2 * std::max(kNumTableWriterCount, kNumPartitionedTableWriterCount))
         .config(
@@ -257,11 +331,32 @@ class TableWriteTest : public HiveConnectorTestBase {
         .config(
             QueryConfig::kTaskPartitionedWriterCount,
             std::to_string(numPartitionedTableWriterCount_))
+        .config(core::QueryConfig::kSpillEnabled, "true")
+        .config(QueryConfig::kWriterSpillEnabled, "true")
         .assertResults(duckDbSql);
   }
 
-  RowVectorPtr runQueryWithWriterConfigs(const core::PlanNodePtr& plan) {
+  RowVectorPtr runQueryWithWriterConfigs(
+      const core::PlanNodePtr& plan,
+      bool spillEnabled = false) {
+    if (!spillEnabled) {
+      return AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .maxDrivers(
+              2 *
+              std::max(kNumTableWriterCount, kNumPartitionedTableWriterCount))
+          .config(
+              QueryConfig::kTaskWriterCount,
+              std::to_string(numTableWriterCount_))
+          .config(
+              QueryConfig::kTaskPartitionedWriterCount,
+              std::to_string(numPartitionedTableWriterCount_))
+          .copyResults(pool());
+    }
+
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    TestScopedSpillInjection scopedSpillInjection(100);
     return AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .spillDirectory(spillDirectory->getPath())
         .maxDrivers(
             2 * std::max(kNumTableWriterCount, kNumPartitionedTableWriterCount))
         .config(
@@ -269,6 +364,8 @@ class TableWriteTest : public HiveConnectorTestBase {
         .config(
             QueryConfig::kTaskPartitionedWriterCount,
             std::to_string(numPartitionedTableWriterCount_))
+        .config(core::QueryConfig::kSpillEnabled, "true")
+        .config(QueryConfig::kWriterSpillEnabled, "true")
         .copyResults(pool());
   }
 
@@ -317,7 +414,7 @@ class TableWriteTest : public HiveConnectorTestBase {
   std::vector<std::shared_ptr<connector::ConnectorSplit>>
   makeHiveConnectorSplits(
       const std::shared_ptr<TempDirectoryPath>& directoryPath) {
-    return makeHiveConnectorSplits(directoryPath->path);
+    return makeHiveConnectorSplits(directoryPath->getPath());
   }
 
   std::vector<std::shared_ptr<connector::ConnectorSplit>>
@@ -362,12 +459,13 @@ class TableWriteTest : public HiveConnectorTestBase {
       int32_t rowsPerVector) {
     auto rowVectors =
         HiveConnectorTestBase::makeVectors(rowType_, numVectors, rowsPerVector);
-    if (testMode_ == TestMode::kUnpartitioned) {
+    if (testMode_ == TestMode::kUnpartitioned ||
+        testMode_ == TestMode::kOnlyBucketed) {
       return rowVectors;
     }
     // In case of partitioned table write test case, we ensure the number of
     // unique partition key values are capped.
-    for (auto& rowVecotr : rowVectors) {
+    for (auto& rowVector : rowVectors) {
       auto c0PartitionVector =
           makeFlatVector<int64_t>(rowsPerVector, [&](auto /*unused*/) {
             return folly::Random().rand32() % numPartitionKeyValues_[0];
@@ -376,8 +474,8 @@ class TableWriteTest : public HiveConnectorTestBase {
           makeFlatVector<int32_t>(rowsPerVector, [&](auto /*unused*/) {
             return folly::Random().rand32() % numPartitionKeyValues_[1];
           });
-      rowVecotr->childAt(0) = c0PartitionVector;
-      rowVecotr->childAt(1) = c1PartitionVector;
+      rowVector->childAt(0) = c0PartitionVector;
+      rowVector->childAt(1) = c1PartitionVector;
     }
     return rowVectors;
   }
@@ -587,28 +685,6 @@ class TableWriteTest : public HiveConnectorTestBase {
     }
   }
 
-  RowVectorPtr makePartitionsVector(
-      RowVectorPtr input,
-      const std::vector<column_index_t>& partitionChannels) {
-    std::vector<VectorPtr> partitions;
-    std::vector<std::string> partitonKeyNames;
-    std::vector<TypePtr> partitionKeyTypes;
-
-    RowTypePtr inputType = asRowType(input->type());
-    for (column_index_t channel : partitionChannels) {
-      partitions.push_back(input->childAt(channel));
-      partitonKeyNames.push_back(inputType->nameOf(channel));
-      partitionKeyTypes.push_back(inputType->childAt(channel));
-    }
-
-    return std::make_shared<RowVector>(
-        pool(),
-        ROW(std::move(partitonKeyNames), std::move(partitionKeyTypes)),
-        nullptr,
-        input->size(),
-        partitions);
-  }
-
   // Parameter partitionName is string formatted in the Hive style
   // key1=value1/key2=value2/... Parameter partitionTypes are types of partition
   // keys in the same order as in partitionName.The return value is a SQL
@@ -692,22 +768,41 @@ class TableWriteTest : public HiveConnectorTestBase {
     verifyUnbucketedFilePath(filePath, filePath.parent_path().string());
   }
 
+  // Verifies if the bucket file name is encoded properly.
+  void verifyBucketedFileName(const std::filesystem::path& filePath) {
+    if (commitStrategy_ == CommitStrategy::kNoCommit) {
+      if (fileFormat_ == FileFormat::PARQUET) {
+        ASSERT_TRUE(RE2::FullMatch(
+            filePath.filename().string(),
+            "0[0-9]+_0_TaskCursorQuery_[0-9]+\\.parquet$"))
+            << filePath.filename().string();
+      } else {
+        ASSERT_TRUE(RE2::FullMatch(
+            filePath.filename().string(), "0[0-9]+_0_TaskCursorQuery_[0-9]+"))
+            << filePath.filename().string();
+      }
+    } else {
+      if (fileFormat_ == FileFormat::PARQUET) {
+        ASSERT_TRUE(RE2::FullMatch(
+            filePath.filename().string(),
+            ".tmp.velox.0[0-9]+_0_TaskCursorQuery_[0-9]+_.+\\.parquet$"))
+            << filePath.filename().string();
+      } else {
+        ASSERT_TRUE(RE2::FullMatch(
+            filePath.filename().string(),
+            ".tmp.velox.0[0-9]+_0_TaskCursorQuery_[0-9]+_.+"))
+            << filePath.filename().string();
+      }
+    }
+  }
+
   // Verifies if a bucketed file path (directory and file name) is encoded
   // properly.
   void verifyBucketedFilePath(
       const std::filesystem::path& filePath,
       const std::string& targetDir) {
     verifyPartitionedDirPath(filePath, targetDir);
-    if (commitStrategy_ == CommitStrategy::kNoCommit) {
-      ASSERT_TRUE(RE2::FullMatch(
-          filePath.filename().string(), "0[0-9]+_0_TaskCursorQuery_[0-9]+"))
-          << filePath.filename().string();
-    } else {
-      ASSERT_TRUE(RE2::FullMatch(
-          filePath.filename().string(),
-          ".tmp.velox.0[0-9]+_0_TaskCursorQuery_[0-9]+_.+"))
-          << filePath.filename().string();
-    }
+    verifyBucketedFileName(filePath);
   }
 
   // Verifies if the given partitioned table directory (names) are encoded
@@ -760,7 +855,7 @@ class TableWriteTest : public HiveConnectorTestBase {
         PlanBuilder().tableScan(rowType_).planNode(),
         {makeHiveConnectorSplits(filePaths)},
         fmt::format(
-            "SELECT * FROM tmp WHERE {}",
+            "SELECT c2, c3, c4, c5 FROM tmp WHERE {}",
             partitionNameToPredicate(getPartitionDirNames(dirPath))));
   }
 
@@ -864,7 +959,18 @@ class TableWriteTest : public HiveConnectorTestBase {
       ASSERT_LE(filePaths.size(), numTableWriterCount_);
       verifyUnbucketedFilePath(filePaths[0], targetDir);
       return;
+    } else if (testMode_ == TestMode::kOnlyBucketed) {
+      ASSERT_EQ(dirPaths.size(), 0);
+      for (const auto& filePath : filePaths) {
+        ASSERT_EQ(filePath.parent_path().string(), targetDir);
+        verifyBucketedFileName(filePath);
+        if (verifyBucketedData) {
+          verifyBucketedFileData(filePath, bucketCheckFileType);
+        }
+      }
+      return;
     }
+    // Validation for both partitioned with and without buckets.
     ASSERT_EQ(numPartitionKeyValues_.size(), 2);
     const auto totalPartitions =
         numPartitionKeyValues_[0] * numPartitionKeyValues_[1];
@@ -952,18 +1058,18 @@ TEST_F(BasicTableWriteTest, roundTrip) {
   });
 
   auto sourceFilePath = TempFilePath::create();
-  writeToFile(sourceFilePath->path, data);
+  writeToFile(sourceFilePath->getPath(), data);
 
   auto targetDirectoryPath = TempDirectoryPath::create();
 
   auto rowType = asRowType(data->type());
   auto plan = PlanBuilder()
                   .tableScan(rowType)
-                  .tableWrite(targetDirectoryPath->path)
+                  .tableWrite(targetDirectoryPath->getPath())
                   .planNode();
 
   auto results = AssertQueryBuilder(plan)
-                     .split(makeHiveConnectorSplit(sourceFilePath->path))
+                     .split(makeHiveConnectorSplit(sourceFilePath->getPath()))
                      .copyResults(pool());
   ASSERT_EQ(2, results->size());
 
@@ -993,11 +1099,38 @@ TEST_F(BasicTableWriteTest, roundTrip) {
 
   auto copy = AssertQueryBuilder(plan)
                   .split(makeHiveConnectorSplit(fmt::format(
-                      "{}/{}", targetDirectoryPath->path, writeFileName)))
+                      "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
                   .copyResults(pool());
   assertEqualResults({data}, {copy});
 }
 
+TEST_F(BasicTableWriteTest, targetFileName) {
+  constexpr const char* kFileName = "test.dwrf";
+  auto data = makeRowVector({makeFlatVector<int64_t>(10, folly::identity)});
+  auto directory = TempDirectoryPath::create();
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .tableWrite(
+                      directory->getPath(),
+                      dwio::common::FileFormat::DWRF,
+                      {},
+                      nullptr,
+                      kFileName)
+                  .planNode();
+  auto results = AssertQueryBuilder(plan).copyResults(pool());
+  auto* details = results->childAt(TableWriteTraits::kFragmentChannel)
+                      ->asUnchecked<SimpleVector<StringView>>();
+  auto detail = folly::parseJson(details->valueAt(1));
+  auto fileWriteInfos = detail["fileWriteInfos"];
+  ASSERT_EQ(1, fileWriteInfos.size());
+  ASSERT_EQ(fileWriteInfos[0]["writeFileName"].asString(), kFileName);
+  plan = PlanBuilder().tableScan(asRowType(data->type())).planNode();
+  AssertQueryBuilder(plan)
+      .split(makeHiveConnectorSplit(
+          fmt::format("{}/{}", directory->getPath(), kFileName)))
+      .assertResults(data);
+}
+
 class PartitionedTableWriterTest
     : public TableWriteTest,
       public testing::WithParamInterface<uint64_t> {
@@ -1007,8 +1140,10 @@ class PartitionedTableWriterTest
   static std::vector<uint64_t> getTestParams() {
     std::vector<uint64_t> testParams;
     const std::vector<bool> multiDriverOptions = {false, true};
-    // Add Parquet with https://github.com/facebookincubator/velox/issues/5560
     std::vector<FileFormat> fileFormats = {FileFormat::DWRF};
+    if (hasWriterFactory(FileFormat::PARQUET)) {
+      fileFormats.push_back(FileFormat::PARQUET);
+    }
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         testParams.push_back(TestParam{
@@ -1116,85 +1251,132 @@ class BucketedTableOnlyWriteTest
  public:
   BucketedTableOnlyWriteTest() : TableWriteTest(GetParam()) {}
 
+  static std::vector<uint64_t> getTestParams() {
+    std::vector<uint64_t> testParams;
+    const std::vector<bool> multiDriverOptions = {false, true};
+    std::vector<FileFormat> fileFormats = {FileFormat::DWRF};
+    if (hasWriterFactory(FileFormat::PARQUET)) {
+      fileFormats.push_back(FileFormat::PARQUET);
+    }
+    const std::vector<TestMode> bucketModes = {
+        TestMode::kBucketed, TestMode::kOnlyBucketed};
+    for (bool multiDrivers : multiDriverOptions) {
+      for (FileFormat fileFormat : fileFormats) {
+        for (auto bucketMode : bucketModes) {
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kNoCommit,
+              HiveBucketProperty::Kind::kHiveCompatible,
+              false,
+              multiDrivers,
+              CompressionKind_ZSTD}
+                                   .value);
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kNoCommit,
+              HiveBucketProperty::Kind::kHiveCompatible,
+              true,
+              multiDrivers,
+              CompressionKind_ZSTD}
+                                   .value);
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kTaskCommit,
+              HiveBucketProperty::Kind::kHiveCompatible,
+              false,
+              multiDrivers,
+              CompressionKind_ZSTD}
+                                   .value);
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kTaskCommit,
+              HiveBucketProperty::Kind::kHiveCompatible,
+              true,
+              multiDrivers,
+              CompressionKind_ZSTD}
+                                   .value);
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kNoCommit,
+              HiveBucketProperty::Kind::kPrestoNative,
+              false,
+              multiDrivers,
+              CompressionKind_ZSTD}
+                                   .value);
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kNoCommit,
+              HiveBucketProperty::Kind::kPrestoNative,
+              true,
+              multiDrivers,
+              CompressionKind_ZSTD}
+                                   .value);
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kTaskCommit,
+              HiveBucketProperty::Kind::kPrestoNative,
+              false,
+              multiDrivers,
+              CompressionKind_ZSTD}
+                                   .value);
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kNoCommit,
+              HiveBucketProperty::Kind::kPrestoNative,
+              true,
+              multiDrivers,
+              CompressionKind_ZSTD}
+                                   .value);
+        }
+      }
+    }
+    return testParams;
+  }
+};
+
+class BucketSortOnlyTableWriterTest
+    : public TableWriteTest,
+      public testing::WithParamInterface<uint64_t> {
+ public:
+  BucketSortOnlyTableWriterTest() : TableWriteTest(GetParam()) {}
+
   static std::vector<uint64_t> getTestParams() {
     std::vector<uint64_t> testParams;
     const std::vector<bool> multiDriverOptions = {false, true};
     // Add Parquet with https://github.com/facebookincubator/velox/issues/5560
     std::vector<FileFormat> fileFormats = {FileFormat::DWRF};
+    const std::vector<TestMode> bucketModes = {
+        TestMode::kBucketed, TestMode::kOnlyBucketed};
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kBucketed,
-            CommitStrategy::kNoCommit,
-            HiveBucketProperty::Kind::kHiveCompatible,
-            false,
-            multiDrivers,
-            CompressionKind_ZSTD}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kBucketed,
-            CommitStrategy::kNoCommit,
-            HiveBucketProperty::Kind::kHiveCompatible,
-            true,
-            multiDrivers,
-            CompressionKind_ZSTD}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kBucketed,
-            CommitStrategy::kTaskCommit,
-            HiveBucketProperty::Kind::kHiveCompatible,
-            false,
-            multiDrivers,
-            CompressionKind_ZSTD}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kBucketed,
-            CommitStrategy::kTaskCommit,
-            HiveBucketProperty::Kind::kHiveCompatible,
-            true,
-            multiDrivers,
-            CompressionKind_ZSTD}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kBucketed,
-            CommitStrategy::kNoCommit,
-            HiveBucketProperty::Kind::kPrestoNative,
-            false,
-            multiDrivers,
-            CompressionKind_ZSTD}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kBucketed,
-            CommitStrategy::kNoCommit,
-            HiveBucketProperty::Kind::kPrestoNative,
-            true,
-            multiDrivers,
-            CompressionKind_ZSTD}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kBucketed,
-            CommitStrategy::kTaskCommit,
-            HiveBucketProperty::Kind::kPrestoNative,
-            false,
-            multiDrivers,
-            CompressionKind_ZSTD}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kBucketed,
-            CommitStrategy::kNoCommit,
-            HiveBucketProperty::Kind::kPrestoNative,
-            true,
-            multiDrivers,
-            CompressionKind_ZSTD}
-                                 .value);
+        for (auto bucketMode : bucketModes) {
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kNoCommit,
+              HiveBucketProperty::Kind::kHiveCompatible,
+              true,
+              multiDrivers,
+              facebook::velox::common::CompressionKind_ZSTD}
+                                   .value);
+          testParams.push_back(TestParam{
+              fileFormat,
+              bucketMode,
+              CommitStrategy::kTaskCommit,
+              HiveBucketProperty::Kind::kHiveCompatible,
+              true,
+              multiDrivers,
+              facebook::velox::common::CompressionKind_NONE}
+                                   .value);
+        }
       }
     }
     return testParams;
@@ -1210,8 +1392,10 @@ class PartitionedWithoutBucketTableWriterTest
   static std::vector<uint64_t> getTestParams() {
     std::vector<uint64_t> testParams;
     const std::vector<bool> multiDriverOptions = {false, true};
-    // Add Parquet with https://github.com/facebookincubator/velox/issues/5560
     std::vector<FileFormat> fileFormats = {FileFormat::DWRF};
+    if (hasWriterFactory(FileFormat::PARQUET)) {
+      fileFormats.push_back(FileFormat::PARQUET);
+    }
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         testParams.push_back(TestParam{
@@ -1246,8 +1430,10 @@ class AllTableWriterTest : public TableWriteTest,
   static std::vector<uint64_t> getTestParams() {
     std::vector<uint64_t> testParams;
     const std::vector<bool> multiDriverOptions = {false, true};
-    // Add Parquet with https://github.com/facebookincubator/velox/issues/5560
     std::vector<FileFormat> fileFormats = {FileFormat::DWRF};
+    if (hasWriterFactory(FileFormat::PARQUET)) {
+      fileFormats.push_back(FileFormat::PARQUET);
+    }
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         testParams.push_back(TestParam{
@@ -1322,6 +1508,42 @@ class AllTableWriterTest : public TableWriteTest,
             multiDrivers,
             CompressionKind_ZSTD}
                                  .value);
+        testParams.push_back(TestParam{
+            fileFormat,
+            TestMode::kOnlyBucketed,
+            CommitStrategy::kNoCommit,
+            HiveBucketProperty::Kind::kHiveCompatible,
+            false,
+            multiDrivers,
+            CompressionKind_ZSTD}
+                                 .value);
+        testParams.push_back(TestParam{
+            fileFormat,
+            TestMode::kOnlyBucketed,
+            CommitStrategy::kTaskCommit,
+            HiveBucketProperty::Kind::kHiveCompatible,
+            false,
+            multiDrivers,
+            CompressionKind_ZSTD}
+                                 .value);
+        testParams.push_back(TestParam{
+            fileFormat,
+            TestMode::kOnlyBucketed,
+            CommitStrategy::kNoCommit,
+            HiveBucketProperty::Kind::kPrestoNative,
+            false,
+            multiDrivers,
+            CompressionKind_ZSTD}
+                                 .value);
+        testParams.push_back(TestParam{
+            fileFormat,
+            TestMode::kOnlyBucketed,
+            CommitStrategy::kTaskCommit,
+            HiveBucketProperty::Kind::kPrestoNative,
+            false,
+            multiDrivers,
+            CompressionKind_ZSTD}
+                                 .value);
       }
     }
     return testParams;
@@ -1333,7 +1555,7 @@ TEST_P(AllTableWriterTest, scanFilterProjectWrite) {
   auto filePaths = makeFilePaths(5);
   auto vectors = makeVectors(filePaths.size(), 500);
   for (int i = 0; i < filePaths.size(); i++) {
-    writeToFile(filePaths[i]->path, vectors[i]);
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
   }
 
   createDuckDbTable(vectors);
@@ -1353,7 +1575,7 @@ TEST_P(AllTableWriterTest, scanFilterProjectWrite) {
   auto plan = createInsertPlan(
       project,
       outputType,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionedBy_,
       bucketProperty_,
       compressionKind_,
@@ -1367,30 +1589,39 @@ TEST_P(AllTableWriterTest, scanFilterProjectWrite) {
   // To test the correctness of the generated output,
   // We create a new plan that only read that file and then
   // compare that against a duckDB query that runs the whole query.
-  assertQuery(
-      PlanBuilder().tableScan(outputType).planNode(),
-      makeHiveConnectorSplits(outputDirectory),
-      "SELECT c0, c1, c3, c5, c2 + c3, substr(c5, 1, 1) FROM tmp WHERE c2 <> 0");
-
-  verifyTableWriterOutput(outputDirectory->path, outputType, false);
+  if (partitionedBy_.size() > 0) {
+    auto newOutputType = getNonPartitionsColumns(partitionedBy_, outputType);
+    assertQuery(
+        PlanBuilder().tableScan(newOutputType).planNode(),
+        makeHiveConnectorSplits(outputDirectory),
+        "SELECT c3, c5, c2 + c3, substr(c5, 1, 1) FROM tmp WHERE c2 <> 0");
+    verifyTableWriterOutput(outputDirectory->getPath(), newOutputType, false);
+  } else {
+    assertQuery(
+        PlanBuilder().tableScan(outputType).planNode(),
+        makeHiveConnectorSplits(outputDirectory),
+        "SELECT c0, c1, c3, c5, c2 + c3, substr(c5, 1, 1) FROM tmp WHERE c2 <> 0");
+    verifyTableWriterOutput(outputDirectory->getPath(), outputType, false);
+  }
 }
 
 TEST_P(AllTableWriterTest, renameAndReorderColumns) {
   auto filePaths = makeFilePaths(5);
   auto vectors = makeVectors(filePaths.size(), 500);
   for (int i = 0; i < filePaths.size(); ++i) {
-    writeToFile(filePaths[i]->path, vectors[i]);
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
   }
 
   createDuckDbTable(vectors);
 
   auto outputDirectory = TempDirectoryPath::create();
 
-  if (testMode_ != TestMode::kUnpartitioned) {
+  if (testMode_ == TestMode::kPartitioned || testMode_ == TestMode::kBucketed) {
     const std::vector<std::string> partitionBy = {"x", "y"};
     setPartitionBy(partitionBy);
   }
-  if (testMode_ == TestMode::kBucketed) {
+  if (testMode_ == TestMode::kBucketed ||
+      testMode_ == TestMode::kOnlyBucketed) {
     setBucketProperty(
         bucketProperty_->kind(),
         bucketProperty_->bucketCount(),
@@ -1411,7 +1642,7 @@ TEST_P(AllTableWriterTest, renameAndReorderColumns) {
       PlanBuilder().tableScan(rowType_),
       inputRowType,
       tableSchema_,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionedBy_,
       bucketProperty_,
       compressionKind_,
@@ -1421,12 +1652,22 @@ TEST_P(AllTableWriterTest, renameAndReorderColumns) {
 
   assertQueryWithWriterConfigs(plan, filePaths, "SELECT count(*) FROM tmp");
 
-  HiveConnectorTestBase::assertQuery(
-      PlanBuilder().tableScan(tableSchema_).planNode(),
-      makeHiveConnectorSplits(outputDirectory),
-      "SELECT c2, c5, c4, c1, c0, c3 FROM tmp");
+  if (partitionedBy_.size() > 0) {
+    auto newOutputType = getNonPartitionsColumns(partitionedBy_, tableSchema_);
+    HiveConnectorTestBase::assertQuery(
+        PlanBuilder().tableScan(newOutputType).planNode(),
+        makeHiveConnectorSplits(outputDirectory),
+        "SELECT c2, c5, c4, c3 FROM tmp");
+
+    verifyTableWriterOutput(outputDirectory->getPath(), newOutputType, false);
+  } else {
+    HiveConnectorTestBase::assertQuery(
+        PlanBuilder().tableScan(tableSchema_).planNode(),
+        makeHiveConnectorSplits(outputDirectory),
+        "SELECT c2, c5, c4, c1, c0, c3 FROM tmp");
 
-  verifyTableWriterOutput(outputDirectory->path, tableSchema_, false);
+    verifyTableWriterOutput(outputDirectory->getPath(), tableSchema_, false);
+  }
 }
 
 // Runs a pipeline with read + write.
@@ -1434,7 +1675,7 @@ TEST_P(AllTableWriterTest, directReadWrite) {
   auto filePaths = makeFilePaths(5);
   auto vectors = makeVectors(filePaths.size(), 200);
   for (int i = 0; i < filePaths.size(); i++) {
-    writeToFile(filePaths[i]->path, vectors[i]);
+    writeToFile(filePaths[i]->getPath(), vectors[i]);
   }
 
   createDuckDbTable(vectors);
@@ -1443,7 +1684,7 @@ TEST_P(AllTableWriterTest, directReadWrite) {
   auto plan = createInsertPlan(
       PlanBuilder().tableScan(rowType_),
       rowType_,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionedBy_,
       bucketProperty_,
       compressionKind_,
@@ -1457,12 +1698,22 @@ TEST_P(AllTableWriterTest, directReadWrite) {
   // We create a new plan that only read that file and then
   // compare that against a duckDB query that runs the whole query.
 
-  assertQuery(
-      PlanBuilder().tableScan(rowType_).planNode(),
-      makeHiveConnectorSplits(outputDirectory),
-      "SELECT * FROM tmp");
+  if (partitionedBy_.size() > 0) {
+    auto newOutputType = getNonPartitionsColumns(partitionedBy_, tableSchema_);
+    assertQuery(
+        PlanBuilder().tableScan(newOutputType).planNode(),
+        makeHiveConnectorSplits(outputDirectory),
+        "SELECT c2, c3, c4, c5 FROM tmp");
+    rowType_ = newOutputType;
+    verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+  } else {
+    assertQuery(
+        PlanBuilder().tableScan(rowType_).planNode(),
+        makeHiveConnectorSplits(outputDirectory),
+        "SELECT * FROM tmp");
 
-  verifyTableWriterOutput(outputDirectory->path, rowType_);
+    verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+  }
 }
 
 // Tests writing constant vectors.
@@ -1478,7 +1729,7 @@ TEST_P(AllTableWriterTest, constantVectors) {
   auto op = createInsertPlan(
       PlanBuilder().values({vector}),
       rowType_,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionedBy_,
       bucketProperty_,
       compressionKind_,
@@ -1488,12 +1739,22 @@ TEST_P(AllTableWriterTest, constantVectors) {
 
   assertQuery(op, fmt::format("SELECT {}", size));
 
-  assertQuery(
-      PlanBuilder().tableScan(rowType_).planNode(),
-      makeHiveConnectorSplits(outputDirectory),
-      "SELECT * FROM tmp");
+  if (partitionedBy_.size() > 0) {
+    auto newOutputType = getNonPartitionsColumns(partitionedBy_, tableSchema_);
+    assertQuery(
+        PlanBuilder().tableScan(newOutputType).planNode(),
+        makeHiveConnectorSplits(outputDirectory),
+        "SELECT c2, c3, c4, c5 FROM tmp");
+    rowType_ = newOutputType;
+    verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+  } else {
+    assertQuery(
+        PlanBuilder().tableScan(rowType_).planNode(),
+        makeHiveConnectorSplits(outputDirectory),
+        "SELECT * FROM tmp");
 
-  verifyTableWriterOutput(outputDirectory->path, rowType_);
+    verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+  }
 }
 
 TEST_P(AllTableWriterTest, emptyInput) {
@@ -1502,7 +1763,7 @@ TEST_P(AllTableWriterTest, emptyInput) {
   auto op = createInsertPlan(
       PlanBuilder().values({vector}),
       rowType_,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionedBy_,
       bucketProperty_,
       compressionKind_,
@@ -1527,7 +1788,7 @@ TEST_P(AllTableWriterTest, commitStrategies) {
     auto plan = createInsertPlan(
         PlanBuilder().values(vectors),
         rowType_,
-        outputDirectory->path,
+        outputDirectory->getPath(),
         partitionedBy_,
         bucketProperty_,
         compressionKind_,
@@ -1537,11 +1798,24 @@ TEST_P(AllTableWriterTest, commitStrategies) {
 
     assertQuery(plan, "SELECT count(*) FROM tmp");
 
-    assertQuery(
-        PlanBuilder().tableScan(rowType_).planNode(),
-        makeHiveConnectorSplits(outputDirectory),
-        "SELECT * FROM tmp");
-    verifyTableWriterOutput(outputDirectory->path, rowType_);
+    if (partitionedBy_.size() > 0) {
+      auto newOutputType =
+          getNonPartitionsColumns(partitionedBy_, tableSchema_);
+      assertQuery(
+          PlanBuilder().tableScan(newOutputType).planNode(),
+          makeHiveConnectorSplits(outputDirectory),
+          "SELECT c2, c3, c4, c5 FROM tmp");
+      auto originalRowType = rowType_;
+      rowType_ = newOutputType;
+      verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+      rowType_ = originalRowType;
+    } else {
+      assertQuery(
+          PlanBuilder().tableScan(rowType_).planNode(),
+          makeHiveConnectorSplits(outputDirectory),
+          "SELECT * FROM tmp");
+      verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+    }
   }
   // Test kNoCommit commit strategy writing to non-temporary files.
   {
@@ -1551,7 +1825,7 @@ TEST_P(AllTableWriterTest, commitStrategies) {
     auto plan = createInsertPlan(
         PlanBuilder().values(vectors),
         rowType_,
-        outputDirectory->path,
+        outputDirectory->getPath(),
         partitionedBy_,
         bucketProperty_,
         compressionKind_,
@@ -1561,11 +1835,22 @@ TEST_P(AllTableWriterTest, commitStrategies) {
 
     assertQuery(plan, "SELECT count(*) FROM tmp");
 
-    assertQuery(
-        PlanBuilder().tableScan(rowType_).planNode(),
-        makeHiveConnectorSplits(outputDirectory),
-        "SELECT * FROM tmp");
-    verifyTableWriterOutput(outputDirectory->path, rowType_);
+    if (partitionedBy_.size() > 0) {
+      auto newOutputType =
+          getNonPartitionsColumns(partitionedBy_, tableSchema_);
+      assertQuery(
+          PlanBuilder().tableScan(newOutputType).planNode(),
+          makeHiveConnectorSplits(outputDirectory),
+          "SELECT c2, c3, c4, c5 FROM tmp");
+      rowType_ = newOutputType;
+      verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+    } else {
+      assertQuery(
+          PlanBuilder().tableScan(rowType_).planNode(),
+          makeHiveConnectorSplits(outputDirectory),
+          "SELECT * FROM tmp");
+      verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+    }
   }
 }
 
@@ -1627,14 +1912,14 @@ TEST_P(PartitionedTableWriterTest, specialPartitionName) {
 
   auto inputFilePaths = makeFilePaths(numBatches);
   for (int i = 0; i < numBatches; i++) {
-    writeToFile(inputFilePaths[i]->path, vectors[i]);
+    writeToFile(inputFilePaths[i]->getPath(), vectors[i]);
   }
 
   auto outputDirectory = TempDirectoryPath::create();
   auto plan = createInsertPlan(
       PlanBuilder().tableScan(rowType),
       rowType,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionKeys,
       bucketProperty_,
       compressionKind_,
@@ -1645,7 +1930,7 @@ TEST_P(PartitionedTableWriterTest, specialPartitionName) {
   auto task = assertQuery(plan, inputFilePaths, "SELECT count(*) FROM tmp");
 
   std::set<std::string> actualPartitionDirectories =
-      getLeafSubdirectories(outputDirectory->path);
+      getLeafSubdirectories(outputDirectory->getPath());
 
   std::set<std::string> expectedPartitionDirectories;
   const std::vector<std::string> expectedCharsAfterEscape = {
@@ -1669,7 +1954,7 @@ TEST_P(PartitionedTableWriterTest, specialPartitionName) {
     auto partitionName = fmt::format(
         "p0={}/p1=str_{}{}", i, i, expectedCharsAfterEscape.at(i % 15));
     expectedPartitionDirectories.emplace(
-        fs::path(outputDirectory->path) / partitionName);
+        fs::path(outputDirectory->getPath()) / partitionName);
   }
   EXPECT_EQ(actualPartitionDirectories, expectedPartitionDirectories);
 }
@@ -1713,14 +1998,14 @@ TEST_P(PartitionedTableWriterTest, multiplePartitions) {
 
   auto inputFilePaths = makeFilePaths(numBatches);
   for (int i = 0; i < numBatches; i++) {
-    writeToFile(inputFilePaths[i]->path, vectors[i]);
+    writeToFile(inputFilePaths[i]->getPath(), vectors[i]);
   }
 
   auto outputDirectory = TempDirectoryPath::create();
   auto plan = createInsertPlan(
       PlanBuilder().tableScan(rowType),
       rowType,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionKeys,
       bucketProperty_,
       compressionKind_,
@@ -1732,7 +2017,7 @@ TEST_P(PartitionedTableWriterTest, multiplePartitions) {
 
   // Verify that there is one partition directory for each partition.
   std::set<std::string> actualPartitionDirectories =
-      getLeafSubdirectories(outputDirectory->path);
+      getLeafSubdirectories(outputDirectory->getPath());
 
   std::set<std::string> expectedPartitionDirectories;
   std::set<std::string> partitionNames;
@@ -1740,19 +2025,20 @@ TEST_P(PartitionedTableWriterTest, multiplePartitions) {
     auto partitionName = fmt::format("p0={}/p1=str_{}", i, i);
     partitionNames.emplace(partitionName);
     expectedPartitionDirectories.emplace(
-        fs::path(outputDirectory->path) / partitionName);
+        fs::path(outputDirectory->getPath()) / partitionName);
   }
   EXPECT_EQ(actualPartitionDirectories, expectedPartitionDirectories);
 
   // Verify distribution of records in partition directories.
   auto iterPartitionDirectory = actualPartitionDirectories.begin();
   auto iterPartitionName = partitionNames.begin();
+  auto newOutputType = getNonPartitionsColumns(partitionKeys, rowType);
   while (iterPartitionDirectory != actualPartitionDirectories.end()) {
     assertQuery(
-        PlanBuilder().tableScan(rowType).planNode(),
+        PlanBuilder().tableScan(newOutputType).planNode(),
         makeHiveConnectorSplits(*iterPartitionDirectory),
         fmt::format(
-            "SELECT * FROM tmp WHERE {}",
+            "SELECT c0, c1, c3, c5 FROM tmp WHERE {}",
             partitionNameToPredicate(*iterPartitionName, partitionTypes)));
     // In case of unbucketed partitioned table, one single file is written to
     // each partition directory for Hive connector.
@@ -1792,7 +2078,7 @@ TEST_P(PartitionedTableWriterTest, singlePartition) {
 
   auto inputFilePaths = makeFilePaths(numBatches);
   for (int i = 0; i < numBatches; i++) {
-    writeToFile(inputFilePaths[i]->path, vectors[i]);
+    writeToFile(inputFilePaths[i]->getPath(), vectors[i]);
   }
 
   auto outputDirectory = TempDirectoryPath::create();
@@ -1800,7 +2086,7 @@ TEST_P(PartitionedTableWriterTest, singlePartition) {
   auto plan = createInsertPlan(
       PlanBuilder().tableScan(rowType),
       rowType,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionKeys,
       bucketProperty_,
       compressionKind_,
@@ -1812,19 +2098,20 @@ TEST_P(PartitionedTableWriterTest, singlePartition) {
       plan, inputFilePaths, "SELECT count(*) FROM tmp");
 
   std::set<std::string> partitionDirectories =
-      getLeafSubdirectories(outputDirectory->path);
+      getLeafSubdirectories(outputDirectory->getPath());
 
   // Verify only a single partition directory is created.
   ASSERT_EQ(partitionDirectories.size(), 1);
   EXPECT_EQ(
       *partitionDirectories.begin(),
-      fs::path(outputDirectory->path) / "p0=365");
+      fs::path(outputDirectory->getPath()) / "p0=365");
 
   // Verify all data is written to the single partition directory.
+  auto newOutputType = getNonPartitionsColumns(partitionKeys, rowType);
   assertQuery(
-      PlanBuilder().tableScan(rowType).planNode(),
+      PlanBuilder().tableScan(newOutputType).planNode(),
       makeHiveConnectorSplits(outputDirectory),
-      "SELECT * FROM tmp");
+      "SELECT c0, c3, c5 FROM tmp");
 
   // In case of unbucketed partitioned table, one single file is written to
   // each partition directory for Hive connector.
@@ -1859,7 +2146,7 @@ TEST_P(PartitionedWithoutBucketTableWriterTest, fromSinglePartitionToMultiple) {
   auto plan = createInsertPlan(
       PlanBuilder().values(vectors),
       rowType,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionKeys,
       nullptr,
       compressionKind_,
@@ -1867,10 +2154,11 @@ TEST_P(PartitionedWithoutBucketTableWriterTest, fromSinglePartitionToMultiple) {
 
   assertQueryWithWriterConfigs(plan, "SELECT count(*) FROM tmp");
 
+  auto newOutputType = getNonPartitionsColumns(partitionKeys, rowType);
   assertQuery(
-      PlanBuilder().tableScan(rowType).planNode(),
+      PlanBuilder().tableScan(newOutputType).planNode(),
       makeHiveConnectorSplits(outputDirectory),
-      "SELECT * FROM tmp");
+      "SELECT c1 FROM tmp");
 }
 
 TEST_P(PartitionedTableWriterTest, maxPartitions) {
@@ -1914,7 +2202,7 @@ TEST_P(PartitionedTableWriterTest, maxPartitions) {
   auto plan = createInsertPlan(
       PlanBuilder().values({vector}),
       rowType,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionKeys,
       bucketProperty_,
       compressionKind_,
@@ -1925,9 +2213,9 @@ TEST_P(PartitionedTableWriterTest, maxPartitions) {
   if (testMode_ == TestMode::kPartitioned) {
     VELOX_ASSERT_THROW(
         AssertQueryBuilder(plan)
-            .connectorConfig(
+            .connectorSessionProperty(
                 kHiveConnectorId,
-                HiveConfig::kMaxPartitionsPerWriters,
+                HiveConfig::kMaxPartitionsPerWritersSession,
                 folly::to<std::string>(maxPartitions))
             .copyResults(pool()),
         fmt::format(
@@ -1935,9 +2223,9 @@ TEST_P(PartitionedTableWriterTest, maxPartitions) {
   } else {
     VELOX_ASSERT_THROW(
         AssertQueryBuilder(plan)
-            .connectorConfig(
+            .connectorSessionProperty(
                 kHiveConnectorId,
-                HiveConfig::kMaxPartitionsPerWriters,
+                HiveConfig::kMaxPartitionsPerWritersSession,
                 folly::to<std::string>(maxPartitions))
             .copyResults(pool()),
         "Exceeded open writer limit");
@@ -1950,7 +2238,7 @@ TEST_P(AllTableWriterTest, writeNoFile) {
   auto plan = createInsertPlan(
       PlanBuilder().tableScan(rowType_).filter("false"),
       rowType_,
-      outputDirectory->path);
+      outputDirectory->getPath());
 
   auto execute = [&](const std::shared_ptr<const core::PlanNode>& plan,
                      std::shared_ptr<core::QueryCtx> queryCtx) {
@@ -1960,8 +2248,8 @@ TEST_P(AllTableWriterTest, writeNoFile) {
     readCursor(params, [&](Task* task) { task->noMoreSplits("0"); });
   };
 
-  execute(plan, std::make_shared<core::QueryCtx>(executor_.get()));
-  ASSERT_TRUE(fs::is_empty(outputDirectory->path));
+  execute(plan, core::QueryCtx::create(executor_.get()));
+  ASSERT_TRUE(fs::is_empty(outputDirectory->getPath()));
 }
 
 TEST_P(UnpartitionedTableWriterTest, differentCompression) {
@@ -1983,7 +2271,7 @@ TEST_P(UnpartitionedTableWriterTest, differentCompression) {
           createInsertPlan(
               PlanBuilder().values(input),
               rowType_,
-              outputDirectory->path,
+              outputDirectory->getPath(),
               {},
               nullptr,
               compressionKind,
@@ -1995,7 +2283,7 @@ TEST_P(UnpartitionedTableWriterTest, differentCompression) {
     auto plan = createInsertPlan(
         PlanBuilder().values(input),
         rowType_,
-        outputDirectory->path,
+        outputDirectory->getPath(),
         {},
         nullptr,
         compressionKind,
@@ -2029,7 +2317,82 @@ TEST_P(UnpartitionedTableWriterTest, differentCompression) {
   }
 }
 
-TEST_P(UnpartitionedTableWriterTest, immutableSettings) {
+TEST_P(UnpartitionedTableWriterTest, runtimeStatsCheck) {
+  // The runtime stats test only applies for dwrf file format.
+  if (fileFormat_ != dwio::common::FileFormat::DWRF) {
+    return;
+  }
+  struct {
+    int numInputVectors;
+    std::string maxStripeSize;
+    int expectedNumStripes;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numInputVectors: {}, maxStripeSize: {}, expectedNumStripes: {}",
+          numInputVectors,
+          maxStripeSize,
+          expectedNumStripes);
+    }
+  } testSettings[] = {
+      {10, "1GB", 1},
+      {1, "1GB", 1},
+      {2, "1GB", 1},
+      {10, "1B", 10},
+      {2, "1B", 2},
+      {1, "1B", 1}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    auto rowType = ROW({"c0", "c1"}, {VARCHAR(), BIGINT()});
+
+    VectorFuzzer::Options options;
+    options.nullRatio = 0.0;
+    options.vectorSize = 1;
+    options.stringLength = 1L << 20;
+    VectorFuzzer fuzzer(options, pool());
+
+    std::vector<RowVectorPtr> vectors;
+    for (int i = 0; i < testData.numInputVectors; ++i) {
+      vectors.push_back(fuzzer.fuzzInputRow(rowType));
+    }
+
+    createDuckDbTable(vectors);
+
+    auto outputDirectory = TempDirectoryPath::create();
+    auto plan = createInsertPlan(
+        PlanBuilder().values(vectors),
+        rowType,
+        outputDirectory->getPath(),
+        {},
+        nullptr,
+        compressionKind_,
+        1,
+        connector::hive::LocationHandle::TableType::kNew);
+    const std::shared_ptr<Task> task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .config(QueryConfig::kTaskWriterCount, std::to_string(1))
+            .connectorSessionProperty(
+                kHiveConnectorId,
+                HiveConfig::kOrcWriterMaxStripeSizeSession,
+                testData.maxStripeSize)
+            .assertResults("SELECT count(*) FROM tmp");
+    auto stats = task->taskStats().pipelineStats.front().operatorStats;
+    if (testData.maxStripeSize == "1GB") {
+      ASSERT_GT(
+          stats[1].memoryStats.peakTotalMemoryReservation,
+          testData.numInputVectors * options.stringLength);
+    }
+    ASSERT_EQ(
+        stats[1].runtimeStats["stripeSize"].count, testData.expectedNumStripes);
+    ASSERT_EQ(stats[1].runtimeStats["numWrittenFiles"].sum, 1);
+    ASSERT_EQ(stats[1].runtimeStats["numWrittenFiles"].count, 1);
+    ASSERT_GE(stats[1].runtimeStats["writeIOTime"].sum, 0);
+    ASSERT_EQ(stats[1].runtimeStats["writeIOTime"].count, 1);
+  }
+}
+
+TEST_P(UnpartitionedTableWriterTest, immutableSettings) {
   struct {
     connector::hive::LocationHandle::TableType dataType;
     bool immutablePartitionsEnabled;
@@ -2053,16 +2416,16 @@ TEST_P(UnpartitionedTableWriterTest, immutableSettings) {
     std::unordered_map<std::string, std::string> propFromFile{
         {"hive.immutable-partitions",
          testData.immutablePartitionsEnabled ? "true" : "false"}};
-    std::shared_ptr<const Config> connectorProperties{
-        std::make_shared<core::MemConfig>(propFromFile)};
-    resetHiveConnector(connectorProperties);
+    std::shared_ptr<const config::ConfigBase> config{
+        std::make_shared<config::ConfigBase>(std::move(propFromFile))};
+    resetHiveConnector(config);
 
     auto input = makeVectors(10, 10);
     auto outputDirectory = TempDirectoryPath::create();
     auto plan = createInsertPlan(
         PlanBuilder().values(input),
         rowType_,
-        outputDirectory->path,
+        outputDirectory->getPath(),
         {},
         nullptr,
         CompressionKind_NONE,
@@ -2116,7 +2479,7 @@ TEST_P(BucketedTableOnlyWriteTest, bucketCountLimit) {
     auto plan = createInsertPlan(
         PlanBuilder().values({input}),
         rowType_,
-        outputDirectory->path,
+        outputDirectory->getPath(),
         partitionedBy_,
         bucketProperty_,
         compressionKind_,
@@ -2126,9 +2489,9 @@ TEST_P(BucketedTableOnlyWriteTest, bucketCountLimit) {
     if (testData.expectedError) {
       VELOX_ASSERT_THROW(
           AssertQueryBuilder(plan)
-              .connectorConfig(
+              .connectorSessionProperty(
                   kHiveConnectorId,
-                  HiveConfig::kMaxPartitionsPerWriters,
+                  HiveConfig::kMaxPartitionsPerWritersSession,
                   // Make sure we have a sufficient large writer limit.
                   folly::to<std::string>(testData.bucketCount * 2))
               .copyResults(pool()),
@@ -2136,11 +2499,24 @@ TEST_P(BucketedTableOnlyWriteTest, bucketCountLimit) {
     } else {
       assertQueryWithWriterConfigs(plan, "SELECT count(*) FROM tmp");
 
-      assertQuery(
-          PlanBuilder().tableScan(rowType_).planNode(),
-          makeHiveConnectorSplits(outputDirectory),
-          "SELECT * FROM tmp");
-      verifyTableWriterOutput(outputDirectory->path, rowType_);
+      if (partitionedBy_.size() > 0) {
+        auto newOutputType =
+            getNonPartitionsColumns(partitionedBy_, tableSchema_);
+        assertQuery(
+            PlanBuilder().tableScan(newOutputType).planNode(),
+            makeHiveConnectorSplits(outputDirectory),
+            "SELECT c2, c3, c4, c5 FROM tmp");
+        auto originalRowType = rowType_;
+        rowType_ = newOutputType;
+        verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+        rowType_ = originalRowType;
+      } else {
+        assertQuery(
+            PlanBuilder().tableScan(rowType_).planNode(),
+            makeHiveConnectorSplits(outputDirectory),
+            "SELECT * FROM tmp");
+        verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+      }
     }
   }
 }
@@ -2162,7 +2538,7 @@ TEST_P(BucketedTableOnlyWriteTest, mismatchedBucketTypes) {
   auto plan = createInsertPlan(
       PlanBuilder().values({input}),
       rowType_,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionedBy_,
       bucketProperty_,
       compressionKind_,
@@ -2190,7 +2566,7 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
   auto plan = createInsertPlan(
       PlanBuilder().values({input}),
       rowType_,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionedBy_,
       bucketProperty_,
       compressionKind_,
@@ -2228,8 +2604,8 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
       ASSERT_FALSE(fragmentVector->isNullAt(i));
       folly::dynamic obj = folly::parseJson(fragmentVector->valueAt(i));
       if (testMode_ == TestMode::kUnpartitioned) {
-        ASSERT_EQ(obj["targetPath"], outputDirectory->path);
-        ASSERT_EQ(obj["writePath"], outputDirectory->path);
+        ASSERT_EQ(obj["targetPath"], outputDirectory->getPath());
+        ASSERT_EQ(obj["writePath"], outputDirectory->getPath());
       } else {
         std::string partitionDirRe;
         for (const auto& partitionBy : partitionedBy_) {
@@ -2237,11 +2613,11 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
         }
         ASSERT_TRUE(RE2::FullMatch(
             obj["targetPath"].asString(),
-            fmt::format("{}{}", outputDirectory->path, partitionDirRe)))
+            fmt::format("{}{}", outputDirectory->getPath(), partitionDirRe)))
             << obj["targetPath"].asString();
         ASSERT_TRUE(RE2::FullMatch(
             obj["writePath"].asString(),
-            fmt::format("{}{}", outputDirectory->path, partitionDirRe)))
+            fmt::format("{}{}", outputDirectory->getPath(), partitionDirRe)))
             << obj["writePath"].asString();
       }
       numRows += obj["rowCount"].asInt();
@@ -2264,13 +2640,21 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
       if (commitStrategy_ == CommitStrategy::kNoCommit) {
         ASSERT_EQ(writeFileName, targetFileName);
       } else {
-        ASSERT_TRUE(writeFileName.find(targetFileName) != std::string::npos);
+        const std::string kParquetSuffix = ".parquet";
+        if (folly::StringPiece(targetFileName).endsWith(kParquetSuffix)) {
+          // Remove the .parquet suffix.
+          auto trimmedFilename = targetFileName.substr(
+              0, targetFileName.size() - kParquetSuffix.size());
+          ASSERT_TRUE(writeFileName.find(trimmedFilename) != std::string::npos);
+        } else {
+          ASSERT_TRUE(writeFileName.find(targetFileName) != std::string::npos);
+        }
       }
     }
     if (!commitContextVector->isNullAt(i)) {
       ASSERT_TRUE(RE2::FullMatch(
           commitContextVector->valueAt(i).getString(),
-          fmt::format(".*{}.*", commitStrategy_)))
+          fmt::format(".*{}.*", commitStrategyToString(commitStrategy_))))
           << commitContextVector->valueAt(i);
     }
   }
@@ -2279,7 +2663,7 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
     ASSERT_GT(writeFiles.size(), 0);
     ASSERT_LE(writeFiles.size(), numTableWriterCount_);
   }
-  auto diskFiles = listAllFiles(outputDirectory->path);
+  auto diskFiles = listAllFiles(outputDirectory->getPath());
   std::sort(diskFiles.begin(), diskFiles.end());
   std::sort(writeFiles.begin(), writeFiles.end());
   ASSERT_EQ(diskFiles, writeFiles)
@@ -2456,7 +2840,7 @@ TEST_P(AllTableWriterTest, columnStatsDataTypes) {
                               rowType_->children(),
                               partitionedBy_,
                               nullptr,
-                              makeLocationHandle(outputDirectory->path))),
+                              makeLocationHandle(outputDirectory->getPath()))),
                       false,
                       CommitStrategy::kNoCommit))
                   .planNode();
@@ -2545,7 +2929,7 @@ TEST_P(AllTableWriterTest, columnStats) {
                               rowType_->children(),
                               partitionedBy_,
                               bucketProperty_,
-                              makeLocationHandle(outputDirectory->path))),
+                              makeLocationHandle(outputDirectory->getPath()))),
                       false,
                       commitStrategy_))
                   .planNode();
@@ -2644,7 +3028,7 @@ TEST_P(AllTableWriterTest, columnStatsWithTableWriteMerge) {
               rowType_->children(),
               partitionedBy_,
               bucketProperty_,
-              makeLocationHandle(outputDirectory->path))),
+              makeLocationHandle(outputDirectory->getPath()))),
       false,
       commitStrategy_));
 
@@ -2736,7 +3120,7 @@ TEST_P(AllTableWriterTest, tableWriterStats) {
 
   auto inputFilePaths = makeFilePaths(numBatches);
   for (int i = 0; i < numBatches; i++) {
-    writeToFile(inputFilePaths[i]->path, vectors[i]);
+    writeToFile(inputFilePaths[i]->getPath(), vectors[i]);
   }
 
   auto outputDirectory = TempDirectoryPath::create();
@@ -2744,7 +3128,7 @@ TEST_P(AllTableWriterTest, tableWriterStats) {
   auto plan = createInsertPlan(
       PlanBuilder().tableScan(rowType),
       rowType,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionKeys,
       bucketProperty_,
       compressionKind_,
@@ -2760,17 +3144,26 @@ TEST_P(AllTableWriterTest, tableWriterStats) {
   // bucketNum, bucket number is 4
   const int numWrittenFiles =
       bucketProperty_ == nullptr ? numBatches : numBatches * 4;
-  for (int i = 0; i < task->taskStats().pipelineStats.size(); ++i) {
-    auto operatorStats = task->taskStats().pipelineStats.at(i).operatorStats;
-    for (int j = 0; j < operatorStats.size(); ++j) {
-      if (operatorStats.at(j).operatorType == "TableWrite") {
-        ASSERT_GT(operatorStats.at(j).physicalWrittenBytes, 0);
-        ASSERT_EQ(
-            operatorStats.at(j).runtimeStats.at("numWrittenFiles").sum,
-            numWrittenFiles);
-      }
-    }
-  }
+  // The size of bytes (ORC_MAGIC_LEN) written when the DWRF writer
+  // initializes a file.
+  const int32_t ORC_HEADER_LEN{3};
+  const auto fixedWrittenBytes =
+      numWrittenFiles * (fileFormat_ == FileFormat::DWRF ? ORC_HEADER_LEN : 0);
+
+  auto planStats = exec::toPlanStats(task->taskStats());
+  auto& stats = planStats.at(tableWriteNodeId_);
+  ASSERT_GT(stats.physicalWrittenBytes, fixedWrittenBytes);
+  ASSERT_GT(
+      stats.operatorStats.at("TableWrite")->physicalWrittenBytes,
+      fixedWrittenBytes);
+  ASSERT_EQ(
+      stats.operatorStats.at("TableWrite")
+          ->customStats.at("numWrittenFiles")
+          .sum,
+      numWrittenFiles);
+  ASSERT_GE(
+      stats.operatorStats.at("TableWrite")->customStats.at("writeIOTime").sum,
+      0);
 }
 
 DEBUG_ONLY_TEST_P(
@@ -2822,7 +3215,7 @@ DEBUG_ONLY_TEST_P(
   auto op = createInsertPlan(
       PlanBuilder().values(vectors),
       rowType_,
-      outputDirectory->path,
+      outputDirectory->getPath(),
       partitionedBy_,
       bucketProperty_,
       compressionKind_,
@@ -2835,6 +3228,179 @@ DEBUG_ONLY_TEST_P(
       "Aborted for external error");
 }
 
+DEBUG_ONLY_TEST_P(UnpartitionedTableWriterTest, dataSinkAbortError) {
+  if (fileFormat_ != FileFormat::DWRF) {
+    // NOTE: only test on dwrf writer format as we inject write error in dwrf
+    // writer.
+    return;
+  }
+  VectorFuzzer::Options options;
+  const int batchSize = 100;
+  options.vectorSize = batchSize;
+  VectorFuzzer fuzzer(options, pool());
+  auto vector = fuzzer.fuzzInputRow(rowType_);
+
+  std::atomic<bool> triggerWriterErrorOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::write",
+      std::function<void(dwrf::Writer*)>([&](dwrf::Writer* /*unused*/) {
+        if (!triggerWriterErrorOnce.exchange(false)) {
+          return;
+        }
+        VELOX_FAIL("inject writer error");
+      }));
+
+  std::atomic<bool> triggerAbortErrorOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::connector::hive::HiveDataSink::closeInternal",
+      std::function<void(const HiveDataSink*)>(
+          [&](const HiveDataSink* /*unused*/) {
+            if (!triggerAbortErrorOnce.exchange(false)) {
+              return;
+            }
+            VELOX_FAIL("inject abort error");
+          }));
+
+  auto outputDirectory = TempDirectoryPath::create();
+  auto plan = PlanBuilder()
+                  .values({vector})
+                  .tableWrite(outputDirectory->getPath(), fileFormat_)
+                  .planNode();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()), "inject writer error");
+  ASSERT_FALSE(triggerWriterErrorOnce);
+  ASSERT_FALSE(triggerAbortErrorOnce);
+}
+
+TEST_P(BucketSortOnlyTableWriterTest, sortWriterSpill) {
+  SCOPED_TRACE(testParam_.toString());
+
+  const auto vectors = makeVectors(5, 500);
+  createDuckDbTable(vectors);
+
+  auto outputDirectory = TempDirectoryPath::create();
+  auto op = createInsertPlan(
+      PlanBuilder().values(vectors),
+      rowType_,
+      outputDirectory->getPath(),
+      partitionedBy_,
+      bucketProperty_,
+      compressionKind_,
+      getNumWriters(),
+      connector::hive::LocationHandle::TableType::kNew,
+      commitStrategy_);
+
+  const auto spillStats = globalSpillStats();
+  auto task =
+      assertQueryWithWriterConfigs(op, fmt::format("SELECT {}", 5 * 500), true);
+  if (partitionedBy_.size() > 0) {
+    rowType_ = getNonPartitionsColumns(partitionedBy_, rowType_);
+    verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+  } else {
+    verifyTableWriterOutput(outputDirectory->getPath(), rowType_);
+  }
+
+  const auto updatedSpillStats = globalSpillStats();
+  ASSERT_GT(updatedSpillStats.spilledBytes, spillStats.spilledBytes);
+  ASSERT_GT(updatedSpillStats.spilledPartitions, spillStats.spilledPartitions);
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  auto& stats = taskStats.at(tableWriteNodeId_);
+  ASSERT_GT(stats.spilledRows, 0);
+  ASSERT_GT(stats.spilledBytes, 0);
+  // One spilled partition per each written files.
+  const int numWrittenFiles = stats.customStats["numWrittenFiles"].sum;
+  ASSERT_GE(stats.spilledPartitions, numWrittenFiles);
+  ASSERT_GT(stats.customStats[Operator::kSpillRuns].sum, 0);
+  ASSERT_GT(stats.customStats[Operator::kSpillFillTime].sum, 0);
+  ASSERT_GT(stats.customStats[Operator::kSpillSortTime].sum, 0);
+  ASSERT_GT(stats.customStats[Operator::kSpillSerializationTime].sum, 0);
+  ASSERT_GT(stats.customStats[Operator::kSpillFlushTime].sum, 0);
+  ASSERT_GT(stats.customStats[Operator::kSpillWrites].sum, 0);
+  ASSERT_GT(stats.customStats[Operator::kSpillWriteTime].sum, 0);
+}
+
+DEBUG_ONLY_TEST_P(BucketSortOnlyTableWriterTest, outputBatchRows) {
+  struct {
+    uint32_t maxOutputRows;
+    std::string maxOutputBytes;
+    int expectedOutputCount;
+
+    // TODO: add output size check with spilling enabled
+    std::string debugString() const {
+      return fmt::format(
+          "maxOutputRows: {}, maxOutputBytes: {}, expectedOutputCount: {}",
+          maxOutputRows,
+          maxOutputBytes,
+          expectedOutputCount);
+    }
+  } testSettings[] = {// we have 4 buckets thus 4 writers.
+                      {10000, "1000kB", 4},
+                      // when maxOutputRows = 1, 1000 rows triggers 1000 writes
+                      {1, "1kB", 1000},
+                      // estimatedRowSize is ~62bytes, when maxOutputSize = 62 *
+                      // 100, 1000 rows triggers ~10 writes
+                      {10000, "6200B", 12}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    std::atomic_int outputCount{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::dwrf::Writer::write",
+        std::function<void(dwrf::Writer*)>(
+            [&](dwrf::Writer* /*unused*/) { ++outputCount; }));
+
+    auto rowType =
+        ROW({"c0", "p0", "c1", "c3", "c4", "c5"},
+            {VARCHAR(), BIGINT(), INTEGER(), REAL(), DOUBLE(), VARCHAR()});
+    std::vector<std::string> partitionKeys = {"p0"};
+
+    // Partition vector is constant vector.
+    std::vector<RowVectorPtr> vectors = makeBatches(1, [&](auto) {
+      return makeRowVector(
+          rowType->names(),
+          {makeFlatVector<StringView>(
+               1'000,
+               [&](auto row) {
+                 return StringView::makeInline(fmt::format("str_{}", row));
+               }),
+           makeConstant((int64_t)365, 1'000),
+           makeConstant((int32_t)365, 1'000),
+           makeFlatVector<float>(1'000, [&](auto row) { return row + 33.23; }),
+           makeFlatVector<double>(1'000, [&](auto row) { return row + 33.23; }),
+           makeFlatVector<StringView>(1'000, [&](auto row) {
+             return StringView::makeInline(fmt::format("bucket_{}", row * 3));
+           })});
+    });
+    createDuckDbTable(vectors);
+
+    auto outputDirectory = TempDirectoryPath::create();
+    auto plan = createInsertPlan(
+        PlanBuilder().values({vectors}),
+        rowType,
+        outputDirectory->getPath(),
+        partitionKeys,
+        bucketProperty_,
+        compressionKind_,
+        1,
+        connector::hive::LocationHandle::TableType::kNew,
+        commitStrategy_);
+    const std::shared_ptr<Task> task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .config(QueryConfig::kTaskWriterCount, std::to_string(1))
+            .connectorSessionProperty(
+                kHiveConnectorId,
+                HiveConfig::kSortWriterMaxOutputRowsSession,
+                folly::to<std::string>(testData.maxOutputRows))
+            .connectorSessionProperty(
+                kHiveConnectorId,
+                HiveConfig::kSortWriterMaxOutputBytesSession,
+                folly::to<std::string>(testData.maxOutputBytes))
+            .assertResults("SELECT count(*) FROM tmp");
+    auto stats = task->taskStats().pipelineStats.front().operatorStats;
+    ASSERT_EQ(outputCount, testData.expectedOutputCount);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TableWriterTest,
     UnpartitionedTableWriterTest,
@@ -2860,3 +3426,929 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     PartitionedWithoutBucketTableWriterTest,
     testing::ValuesIn(
         PartitionedWithoutBucketTableWriterTest::getTestParams()));
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TableWriterTest,
+    BucketSortOnlyTableWriterTest,
+    testing::ValuesIn(BucketSortOnlyTableWriterTest::getTestParams()));
+
+class TableWriterArbitrationTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    filesystems::registerLocalFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      this->registerVectorSerde();
+    }
+
+    rowType_ = ROW(
+        {{"c0", INTEGER()},
+         {"c1", INTEGER()},
+         {"c2", VARCHAR()},
+         {"c3", VARCHAR()}});
+    fuzzerOpts_.vectorSize = 1024;
+    fuzzerOpts_.nullRatio = 0;
+    fuzzerOpts_.stringVariableLength = false;
+    fuzzerOpts_.stringLength = 1024;
+    fuzzerOpts_.allowLazyVector = false;
+  }
+
+  folly::Random::DefaultGenerator rng_;
+  RowTypePtr rowType_;
+  VectorFuzzer::Options fuzzerOpts_;
+};
+
+DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, reclaimFromTableWriter) {
+  VectorFuzzer::Options options;
+  const int batchSize = 1'000;
+  options.vectorSize = batchSize;
+  options.stringVariableLength = false;
+  options.stringLength = 1'000;
+  VectorFuzzer fuzzer(options, pool());
+  const int numBatches = 20;
+  std::vector<RowVectorPtr> vectors;
+  int numRows{0};
+  for (int i = 0; i < numBatches; ++i) {
+    numRows += batchSize;
+    vectors.push_back(fuzzer.fuzzRow(rowType_));
+  }
+  createDuckDbTable(vectors);
+
+  for (bool writerSpillEnabled : {false, true}) {
+    {
+      SCOPED_TRACE(fmt::format("writerSpillEnabled: {}", writerSpillEnabled));
+      auto memoryManager = createMemoryManager();
+      auto arbitrator = memoryManager->arbitrator();
+      auto queryCtx =
+          newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+      ASSERT_EQ(queryCtx->pool()->capacity(), kMemoryPoolInitCapacity);
+
+      std::atomic<int> numInputs{0};
+      SCOPED_TESTVALUE_SET(
+          "facebook::velox::exec::Driver::runInternal::addInput",
+          std::function<void(Operator*)>(([&](Operator* op) {
+            if (op->operatorType() != "TableWrite") {
+              return;
+            }
+            // We reclaim memory from table writer connector memory pool which
+            // connects to the memory pools inside the hive connector.
+            ASSERT_FALSE(op->canReclaim());
+            if (++numInputs != numBatches) {
+              return;
+            }
+
+            const auto fakeAllocationSize =
+                arbitrator->stats().maxCapacityBytes -
+                op->pool()->parent()->reservedBytes();
+            if (writerSpillEnabled) {
+              auto* buffer = op->pool()->allocate(fakeAllocationSize);
+              op->pool()->free(buffer, fakeAllocationSize);
+            } else {
+              VELOX_ASSERT_THROW(
+                  op->pool()->allocate(fakeAllocationSize),
+                  "Exceeded memory pool");
+            }
+          })));
+
+      auto spillDirectory = exec::test::TempDirectoryPath::create();
+      auto outputDirectory = TempDirectoryPath::create();
+      core::PlanNodeId tableWriteNodeId;
+      auto writerPlan =
+          PlanBuilder()
+              .values(vectors)
+              .tableWrite(outputDirectory->getPath())
+              .capturePlanNodeId(tableWriteNodeId)
+              .project({TableWriteTraits::rowCountColumnName()})
+              .singleAggregation(
+                  {},
+                  {fmt::format(
+                      "sum({})", TableWriteTraits::rowCountColumnName())})
+              .planNode();
+      {
+        auto task =
+            AssertQueryBuilder(duckDbQueryRunner_)
+                .queryCtx(queryCtx)
+                .maxDrivers(1)
+                .spillDirectory(spillDirectory->getPath())
+                .config(core::QueryConfig::kSpillEnabled, writerSpillEnabled)
+                .config(
+                    core::QueryConfig::kWriterSpillEnabled, writerSpillEnabled)
+                // Set 0 file writer flush threshold to always trigger flush in
+                // test.
+                .config(core::QueryConfig::kWriterFlushThresholdBytes, 0)
+                .plan(std::move(writerPlan))
+                .assertResults(fmt::format("SELECT {}", numRows));
+        auto planStats = exec::toPlanStats(task->taskStats());
+        auto& tableWriteStats =
+            planStats.at(tableWriteNodeId).operatorStats.at("TableWrite");
+        if (writerSpillEnabled) {
+          ASSERT_GT(
+              tableWriteStats->customStats
+                  .at(HiveDataSink::kEarlyFlushedRawBytes)
+                  .count,
+              0);
+          ASSERT_GT(
+              tableWriteStats->customStats
+                  .at(HiveDataSink::kEarlyFlushedRawBytes)
+                  .sum,
+              0);
+          ASSERT_EQ(arbitrator->stats().numFailures, 0);
+        } else {
+          ASSERT_EQ(
+              tableWriteStats->customStats.count(
+                  HiveDataSink::kEarlyFlushedRawBytes),
+              0);
+          ASSERT_EQ(arbitrator->stats().numFailures, 1);
+        }
+        ASSERT_EQ(arbitrator->stats().numNonReclaimableAttempts, 0);
+      }
+      waitForAllTasksToBeDeleted(3'000'000);
+    }
+  }
+}
+
+DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, reclaimFromSortTableWriter) {
+  VectorFuzzer::Options options;
+  const int batchSize = 1'000;
+  options.vectorSize = batchSize;
+  options.stringVariableLength = false;
+  options.stringLength = 1'000;
+  VectorFuzzer fuzzer(options, pool());
+  const int numBatches = 20;
+  std::vector<RowVectorPtr> vectors;
+  int numRows{0};
+  const auto partitionKeyVector = makeFlatVector<int32_t>(
+      batchSize, [&](vector_size_t /*unused*/) { return 0; });
+  for (int i = 0; i < numBatches; ++i) {
+    numRows += batchSize;
+    vectors.push_back(fuzzer.fuzzInputRow(rowType_));
+    vectors.back()->childAt(0) = partitionKeyVector;
+  }
+  createDuckDbTable(vectors);
+
+  for (bool writerSpillEnabled : {false, true}) {
+    {
+      SCOPED_TRACE(fmt::format("writerSpillEnabled: {}", writerSpillEnabled));
+      auto memoryManager = createMemoryManager();
+      auto arbitrator = memoryManager->arbitrator();
+      auto queryCtx =
+          newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+      ASSERT_EQ(queryCtx->pool()->capacity(), kMemoryPoolInitCapacity);
+
+      const auto spillStats = common::globalSpillStats();
+      std::atomic<int> numInputs{0};
+      SCOPED_TESTVALUE_SET(
+          "facebook::velox::exec::Driver::runInternal::addInput",
+          std::function<void(Operator*)>(([&](Operator* op) {
+            if (op->operatorType() != "TableWrite") {
+              return;
+            }
+            // We reclaim memory from table writer connector memory pool which
+            // connects to the memory pools inside the hive connector.
+            ASSERT_FALSE(op->canReclaim());
+            if (++numInputs != numBatches) {
+              return;
+            }
+
+            const auto fakeAllocationSize =
+                arbitrator->stats().maxCapacityBytes -
+                op->pool()->parent()->reservedBytes();
+            if (writerSpillEnabled) {
+              auto* buffer = op->pool()->allocate(fakeAllocationSize);
+              op->pool()->free(buffer, fakeAllocationSize);
+            } else {
+              VELOX_ASSERT_THROW(
+                  op->pool()->allocate(fakeAllocationSize),
+                  "Exceeded memory pool");
+            }
+          })));
+
+      auto spillDirectory = exec::test::TempDirectoryPath::create();
+      auto outputDirectory = TempDirectoryPath::create();
+      auto writerPlan =
+          PlanBuilder()
+              .values(vectors)
+              .tableWrite(
+                  outputDirectory->getPath(),
+                  {"c0"},
+                  4,
+                  {"c1"},
+                  {
+                      std::make_shared<HiveSortingColumn>(
+                          "c2", core::SortOrder{false, false}),
+                  })
+              .project({TableWriteTraits::rowCountColumnName()})
+              .singleAggregation(
+                  {},
+                  {fmt::format(
+                      "sum({})", TableWriteTraits::rowCountColumnName())})
+              .planNode();
+
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .queryCtx(queryCtx)
+          .maxDrivers(1)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, writerSpillEnabled)
+          .config(core::QueryConfig::kWriterSpillEnabled, writerSpillEnabled)
+          // Set 0 file writer flush threshold to always trigger flush in test.
+          .config(core::QueryConfig::kWriterFlushThresholdBytes, 0)
+          .plan(std::move(writerPlan))
+          .assertResults(fmt::format("SELECT {}", numRows));
+
+      ASSERT_EQ(arbitrator->stats().numFailures, writerSpillEnabled ? 0 : 1);
+      ASSERT_EQ(arbitrator->stats().numNonReclaimableAttempts, 0);
+
+      waitForAllTasksToBeDeleted(3'000'000);
+      const auto updatedSpillStats = common::globalSpillStats();
+      if (writerSpillEnabled) {
+        ASSERT_GT(updatedSpillStats.spilledBytes, spillStats.spilledBytes);
+        ASSERT_GT(
+            updatedSpillStats.spilledPartitions, spillStats.spilledPartitions);
+      } else {
+        ASSERT_EQ(updatedSpillStats, spillStats);
+      }
+    }
+  }
+}
+
+DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, writerFlushThreshold) {
+  VectorFuzzer::Options options;
+  const int batchSize = 1'000;
+  options.vectorSize = batchSize;
+  options.stringVariableLength = false;
+  options.stringLength = 1'000;
+  const int numBatches = 20;
+  const int numRows = numBatches * batchSize;
+  std::vector<RowVectorPtr> vectors =
+      createVectors(numBatches, rowType_, options);
+  createDuckDbTable(vectors);
+
+  struct TestParam {
+    uint64_t bytesToReserve{0};
+    uint64_t writerFlushThreshold{0};
+  };
+  const std::vector<TestParam> testParams{
+      {0, 0}, {0, 1UL << 30}, {64UL << 20, 1UL << 30}};
+  for (const auto& testParam : testParams) {
+    SCOPED_TRACE(fmt::format(
+        "bytesToReserve: {}, writerFlushThreshold: {}",
+        succinctBytes(testParam.bytesToReserve),
+        succinctBytes(testParam.writerFlushThreshold)));
+
+    auto memoryManager = createMemoryManager();
+    auto arbitrator = memoryManager->arbitrator();
+    auto queryCtx =
+        newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+    ASSERT_EQ(queryCtx->pool()->capacity(), kMemoryPoolInitCapacity);
+
+    memory::MemoryPool* compressionPool{nullptr};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::dwrf::Writer::write",
+        std::function<void(dwrf::Writer*)>([&](dwrf::Writer* writer) {
+          if (testParam.bytesToReserve == 0 || compressionPool != nullptr) {
+            return;
+          }
+          compressionPool = &(writer->getContext().getMemoryPool(
+              dwrf::MemoryUsageCategory::OUTPUT_STREAM));
+        }));
+
+    std::atomic<int> numInputs{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "TableWrite") {
+            return;
+          }
+          if (++numInputs != numBatches) {
+            return;
+          }
+
+          if (testParam.bytesToReserve > 0) {
+            ASSERT_TRUE(compressionPool != nullptr);
+            compressionPool->maybeReserve(testParam.bytesToReserve);
+          }
+
+          const auto fakeAllocationSize = arbitrator->stats().maxCapacityBytes -
+              op->pool()->parent()->usedBytes();
+          if (testParam.writerFlushThreshold == 0) {
+            auto* buffer = op->pool()->allocate(fakeAllocationSize);
+            op->pool()->free(buffer, fakeAllocationSize);
+          } else {
+            VELOX_ASSERT_THROW(
+                op->pool()->allocate(fakeAllocationSize),
+                "Exceeded memory pool");
+          }
+        })));
+
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+    auto outputDirectory = TempDirectoryPath::create();
+    auto writerPlan =
+        PlanBuilder()
+            .values(vectors)
+            .tableWrite(outputDirectory->getPath())
+            .project({TableWriteTraits::rowCountColumnName()})
+            .singleAggregation(
+                {},
+                {fmt::format(
+                    "sum({})", TableWriteTraits::rowCountColumnName())})
+            .planNode();
+
+    AssertQueryBuilder(duckDbQueryRunner_)
+        .queryCtx(queryCtx)
+        .maxDrivers(1)
+        .spillDirectory(spillDirectory->getPath())
+        .config(core::QueryConfig::kSpillEnabled, true)
+        .config(core::QueryConfig::kWriterSpillEnabled, true)
+        .config(
+            core::QueryConfig::kWriterFlushThresholdBytes,
+            testParam.writerFlushThreshold)
+        .plan(std::move(writerPlan))
+        .assertResults(fmt::format("SELECT {}", numRows));
+
+    ASSERT_EQ(
+        arbitrator->stats().numFailures,
+        testParam.writerFlushThreshold == 0 ? 0 : 1);
+    // We don't trigger reclaim on a writer if it doesn't meet the writer flush
+    // threshold.
+    ASSERT_EQ(arbitrator->stats().numNonReclaimableAttempts, 0);
+    ASSERT_GE(arbitrator->stats().numReclaimedBytes, testParam.bytesToReserve);
+    waitForAllTasksToBeDeleted(3'000'000);
+    queryCtx.reset();
+    ASSERT_EQ(arbitrator->stats().numShrinks, 1);
+  }
+}
+
+DEBUG_ONLY_TEST_F(
+    TableWriterArbitrationTest,
+    reclaimFromNonReclaimableTableWriter) {
+  VectorFuzzer::Options options;
+  const int batchSize = 1'000;
+  options.vectorSize = batchSize;
+  options.stringVariableLength = false;
+  options.stringLength = 1'000;
+  VectorFuzzer fuzzer(options, pool());
+  const int numBatches = 20;
+  std::vector<RowVectorPtr> vectors;
+  int numRows{0};
+  for (int i = 0; i < numBatches; ++i) {
+    numRows += batchSize;
+    vectors.push_back(fuzzer.fuzzRow(rowType_));
+  }
+
+  createDuckDbTable(vectors);
+
+  auto memoryManager = createMemoryManager();
+  auto arbitrator = memoryManager->arbitrator();
+  auto queryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+  ASSERT_EQ(queryCtx->pool()->capacity(), kMemoryPoolInitCapacity);
+
+  std::atomic<bool> injectFakeAllocationOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::write",
+      std::function<void(dwrf::Writer*)>(([&](dwrf::Writer* writer) {
+        if (!injectFakeAllocationOnce.exchange(false)) {
+          return;
+        }
+        auto& pool = writer->getContext().getMemoryPool(
+            dwrf::MemoryUsageCategory::GENERAL);
+        const auto fakeAllocationSize =
+            arbitrator->stats().maxCapacityBytes - pool.reservedBytes();
+        VELOX_ASSERT_THROW(
+            pool.allocate(fakeAllocationSize), "Exceeded memory pool");
+      })));
+
+  auto outputDirectory = TempDirectoryPath::create();
+  auto writerPlan =
+      PlanBuilder()
+          .values(vectors)
+          .tableWrite(outputDirectory->getPath())
+          .project({TableWriteTraits::rowCountColumnName()})
+          .singleAggregation(
+              {},
+              {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())})
+          .planNode();
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .queryCtx(queryCtx)
+      .maxDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kWriterSpillEnabled, true)
+      // Set file writer flush threshold of zero to always trigger flush in
+      // test.
+      .config(core::QueryConfig::kWriterFlushThresholdBytes, 0)
+      // Set large stripe and dictionary size thresholds to avoid writer
+      // internal stripe flush.
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kOrcWriterMaxStripeSizeSession,
+          "1GB")
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kOrcWriterMaxDictionaryMemorySession,
+          "1GB")
+      .plan(std::move(writerPlan))
+      .assertResults(fmt::format("SELECT {}", numRows));
+
+  ASSERT_EQ(arbitrator->stats().numFailures, 1);
+  ASSERT_EQ(arbitrator->stats().numNonReclaimableAttempts, 1);
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(
+    TableWriterArbitrationTest,
+    arbitrationFromTableWriterWithNoMoreInput) {
+  VectorFuzzer::Options options;
+  const int batchSize = 1'000;
+  options.vectorSize = batchSize;
+  options.stringVariableLength = false;
+  options.stringLength = 1'000;
+  VectorFuzzer fuzzer(options, pool());
+  const int numBatches = 10;
+  std::vector<RowVectorPtr> vectors;
+  int numRows{0};
+  for (int i = 0; i < numBatches; ++i) {
+    numRows += batchSize;
+    vectors.push_back(fuzzer.fuzzRow(rowType_));
+  }
+
+  createDuckDbTable(vectors);
+  auto memoryManager = createMemoryManager();
+  auto arbitrator = memoryManager->arbitrator();
+  auto queryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+  ASSERT_EQ(queryCtx->pool()->capacity(), kMemoryPoolInitCapacity);
+
+  std::atomic<bool> writerNoMoreInput{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "TableWrite") {
+          return;
+        }
+        writerNoMoreInput = true;
+      })));
+
+  std::atomic<bool> injectGetOutputOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "TableWrite") {
+          return;
+        }
+        if (!writerNoMoreInput) {
+          return;
+        }
+        if (!injectGetOutputOnce.exchange(false)) {
+          return;
+        }
+        const auto fakeAllocationSize = arbitrator->stats().maxCapacityBytes -
+            op->pool()->parent()->reservedBytes();
+        auto* buffer = op->pool()->allocate(fakeAllocationSize);
+        op->pool()->free(buffer, fakeAllocationSize);
+      })));
+
+  auto outputDirectory = TempDirectoryPath::create();
+  auto writerPlan =
+      PlanBuilder()
+          .values(vectors)
+          .tableWrite(outputDirectory->getPath())
+          .project({TableWriteTraits::rowCountColumnName()})
+          .singleAggregation(
+              {},
+              {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())})
+          .planNode();
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .queryCtx(queryCtx)
+      .maxDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kWriterSpillEnabled, true)
+      // Set 0 file writer flush threshold to always trigger flush in test.
+      .config(core::QueryConfig::kWriterFlushThresholdBytes, 0)
+      // Set large stripe and dictionary size thresholds to avoid writer
+      // internal stripe flush.
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kOrcWriterMaxStripeSizeSession,
+          "1GB")
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kOrcWriterMaxDictionaryMemorySession,
+          "1GB")
+      .plan(std::move(writerPlan))
+      .assertResults(fmt::format("SELECT {}", numRows));
+
+  ASSERT_EQ(arbitrator->stats().numNonReclaimableAttempts, 0);
+  ASSERT_EQ(arbitrator->stats().numFailures, 0);
+  ASSERT_GT(arbitrator->stats().numReclaimedBytes, 0);
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(
+    TableWriterArbitrationTest,
+    reclaimFromNonReclaimableSortTableWriter) {
+  VectorFuzzer::Options options;
+  const int batchSize = 1'000;
+  options.vectorSize = batchSize;
+  options.stringVariableLength = false;
+  options.stringLength = 1'000;
+  VectorFuzzer fuzzer(options, pool());
+  const int numBatches = 20;
+  std::vector<RowVectorPtr> vectors;
+  int numRows{0};
+  const auto partitionKeyVector = makeFlatVector<int32_t>(
+      batchSize, [&](vector_size_t /*unused*/) { return 0; });
+  for (int i = 0; i < numBatches; ++i) {
+    numRows += batchSize;
+    vectors.push_back(fuzzer.fuzzInputRow(rowType_));
+    vectors.back()->childAt(0) = partitionKeyVector;
+  }
+
+  createDuckDbTable(vectors);
+
+  auto memoryManager = createMemoryManager();
+  auto arbitrator = memoryManager->arbitrator();
+  auto queryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+  ASSERT_EQ(queryCtx->pool()->capacity(), kMemoryPoolInitCapacity);
+
+  std::atomic<bool> injectFakeAllocationOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe",
+      std::function<void(memory::MemoryPool*)>(([&](memory::MemoryPool* pool) {
+        const std::string re(".*sort");
+        if (!RE2::FullMatch(pool->name(), re)) {
+          return;
+        }
+        const int writerMemoryUsage = 4L << 20;
+        if (pool->parent()->reservedBytes() < writerMemoryUsage) {
+          return;
+        }
+        if (!injectFakeAllocationOnce.exchange(false)) {
+          return;
+        }
+        const auto fakeAllocationSize = arbitrator->stats().maxCapacityBytes -
+            pool->parent()->reservedBytes();
+        VELOX_ASSERT_THROW(
+            pool->allocate(fakeAllocationSize), "Exceeded memory pool");
+      })));
+
+  auto outputDirectory = TempDirectoryPath::create();
+  auto writerPlan =
+      PlanBuilder()
+          .values(vectors)
+          .tableWrite(
+              outputDirectory->getPath(),
+              {"c0"},
+              4,
+              {"c1"},
+              {
+                  std::make_shared<HiveSortingColumn>(
+                      "c2", core::SortOrder{false, false}),
+              })
+          .project({TableWriteTraits::rowCountColumnName()})
+          .singleAggregation(
+              {},
+              {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())})
+          .planNode();
+
+  const auto spillStats = common::globalSpillStats();
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .queryCtx(queryCtx)
+      .maxDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, "true")
+      .config(core::QueryConfig::kWriterSpillEnabled, "true")
+      // Set file writer flush threshold of zero to always trigger flush in
+      // test.
+      .config(core::QueryConfig::kWriterFlushThresholdBytes, "0")
+      // Set large stripe and dictionary size thresholds to avoid writer
+      // internal stripe flush.
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kOrcWriterMaxStripeSizeSession,
+          "1GB")
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kOrcWriterMaxDictionaryMemorySession,
+          "1GB")
+      .plan(std::move(writerPlan))
+      .assertResults(fmt::format("SELECT {}", numRows));
+
+  ASSERT_EQ(arbitrator->stats().numFailures, 1);
+  ASSERT_EQ(arbitrator->stats().numNonReclaimableAttempts, 1);
+  const auto updatedSpillStats = common::globalSpillStats();
+  ASSERT_EQ(updatedSpillStats, spillStats);
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableFileWriteError) {
+  const uint64_t memoryCapacity = 32 * MB;
+  VectorFuzzer::Options options;
+  const int batchSize = 1'000;
+  options.vectorSize = batchSize;
+  options.stringVariableLength = false;
+  options.stringLength = 1'000;
+  VectorFuzzer fuzzer(options, pool());
+  const int numBatches = 20;
+  std::vector<RowVectorPtr> vectors;
+  for (int i = 0; i < numBatches; ++i) {
+    vectors.push_back(fuzzer.fuzzRow(rowType_));
+  }
+
+  createDuckDbTable(vectors);
+
+  auto memoryManager =
+      createMemoryManager(memoryCapacity, kMemoryPoolInitCapacity);
+  auto arbitrator = memoryManager->arbitrator();
+  auto queryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), memoryCapacity);
+  ASSERT_EQ(queryCtx->pool()->capacity(), kMemoryPoolInitCapacity);
+  std::atomic<bool> injectWriterErrorOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::write",
+      std::function<void(dwrf::Writer*)>(([&](dwrf::Writer* writer) {
+        auto& context = writer->getContext();
+        auto& pool =
+            context.getMemoryPool(dwrf::MemoryUsageCategory::OUTPUT_STREAM);
+        if (static_cast<memory::MemoryPoolImpl*>(&pool)
+                ->testingMinReservationBytes() == 0) {
+          return;
+        }
+        if (!injectWriterErrorOnce.exchange(false)) {
+          return;
+        }
+        VELOX_FAIL("inject writer error");
+      })));
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto writerPlan = PlanBuilder()
+                        .values(vectors)
+                        .tableWrite(outputDirectory->getPath())
+                        .planNode();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .queryCtx(queryCtx)
+          .maxDrivers(1)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kWriterSpillEnabled, true)
+          // Set 0 file writer flush threshold to always reclaim memory from
+          // file writer.
+          .config(core::QueryConfig::kWriterFlushThresholdBytes, 0)
+          // Set stripe size to extreme large to avoid writer internal triggered
+          // flush.
+          .connectorSessionProperty(
+              kHiveConnectorId,
+              connector::hive::HiveConfig::kOrcWriterMaxStripeSizeSession,
+              "1GB")
+          .connectorSessionProperty(
+              kHiveConnectorId,
+              connector::hive::HiveConfig::kOrcWriterMaxDictionaryMemorySession,
+              "1GB")
+          .plan(std::move(writerPlan))
+          .copyResults(pool()),
+      "inject writer error");
+
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableWriteSpillUseMoreMemory) {
+  const uint64_t memoryCapacity = 256 * MB;
+  // Create a large number of vectors to trigger writer spill.
+  fuzzerOpts_.vectorSize = 1000;
+  fuzzerOpts_.stringLength = 2048;
+  fuzzerOpts_.stringVariableLength = false;
+  VectorFuzzer fuzzer(fuzzerOpts_, pool());
+
+  std::vector<RowVectorPtr> vectors;
+  for (int i = 0; i < 10; ++i) {
+    vectors.push_back(fuzzer.fuzzInputRow(rowType_));
+  }
+
+  auto memoryManager =
+      createMemoryManager(memoryCapacity, kMemoryPoolInitCapacity);
+  auto arbitrator = memoryManager->arbitrator();
+
+  std::shared_ptr<core::QueryCtx> queryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), memoryCapacity / 8);
+  std::shared_ptr<core::QueryCtx> fakeQueryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), memoryCapacity);
+  auto fakePool = fakeQueryCtx->pool()->addLeafChild(
+      "fakePool", true, FakeMemoryReclaimer::create());
+  TestAllocation injectedFakeAllocation{
+      fakePool.get(),
+      fakePool->allocate(memoryCapacity * 3 / 4),
+      memoryCapacity * 3 / 4};
+
+  void* allocatedBuffer;
+  TestAllocation injectedWriterAllocation;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::flushInternal",
+      std::function<void(dwrf::Writer*)>(([&](dwrf::Writer* writer) {
+        ASSERT_TRUE(memory::underMemoryArbitration());
+        injectedFakeAllocation.free();
+        auto& pool = writer->getContext().getMemoryPool(
+            dwrf::MemoryUsageCategory::GENERAL);
+        injectedWriterAllocation.pool = &pool;
+        injectedWriterAllocation.size = memoryCapacity / 8;
+        injectedWriterAllocation.buffer =
+            pool.allocate(injectedWriterAllocation.size);
+      })));
+
+  // Free the extra fake memory allocations to make memory pool state consistent
+  // at the end of test.
+  std::atomic<bool> clearAllocationOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::setError",
+      std::function<void(Task*)>(([&](Task* task) {
+        if (!clearAllocationOnce.exchange(false)) {
+          return;
+        }
+        ASSERT_EQ(injectedWriterAllocation.size, memoryCapacity / 8);
+        injectedWriterAllocation.free();
+      })));
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto writerPlan = PlanBuilder()
+                        .values(vectors)
+                        .tableWrite(outputDirectory->getPath())
+                        .planNode();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .queryCtx(queryCtx)
+          .maxDrivers(1)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kWriterSpillEnabled, true)
+          // Set 0 file writer flush threshold to always trigger flush in test.
+          .config(core::QueryConfig::kWriterFlushThresholdBytes, 0)
+          // Set stripe size to extreme large to avoid writer internal triggered
+          // flush.
+          .connectorSessionProperty(
+              kHiveConnectorId,
+              connector::hive::HiveConfig::kOrcWriterMaxStripeSizeSession,
+              "1GB")
+          .connectorSessionProperty(
+              kHiveConnectorId,
+              connector::hive::HiveConfig::kOrcWriterMaxDictionaryMemorySession,
+              "1GB")
+          .plan(std::move(writerPlan))
+          .copyResults(pool()),
+      "");
+
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableWriteReclaimOnClose) {
+  // Create a large number of vectors to trigger writer spill.
+  fuzzerOpts_.vectorSize = 1000;
+  fuzzerOpts_.stringLength = 1024;
+  fuzzerOpts_.stringVariableLength = false;
+  VectorFuzzer fuzzer(fuzzerOpts_, pool());
+  std::vector<RowVectorPtr> vectors;
+  int numRows{0};
+  for (int i = 0; i < 10; ++i) {
+    vectors.push_back(fuzzer.fuzzInputRow(rowType_));
+    numRows += vectors.back()->size();
+  }
+
+  auto memoryManager = createMemoryManager();
+  auto arbitrator = memoryManager->arbitrator();
+  auto queryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+  auto fakeQueryCtx =
+      newQueryCtx(memoryManager.get(), executor_.get(), kMemoryCapacity);
+  auto fakePool = fakeQueryCtx->pool()->addLeafChild(
+      "fakePool", true, FakeMemoryReclaimer::create());
+
+  std::atomic<bool> writerNoMoreInput{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "TableWrite") {
+          return;
+        }
+        writerNoMoreInput = true;
+      })));
+
+  std::atomic<bool> maybeReserveInjectOnce{true};
+  TestAllocation fakeAllocation;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+      std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool* pool) {
+        if (!writerNoMoreInput) {
+          return;
+        }
+        if (!maybeReserveInjectOnce.exchange(false)) {
+          return;
+        }
+        // The injection memory allocation to cause maybeReserve on writer close
+        // to trigger memory arbitration. The latter tries to reclaim memory
+        // from this file writer.
+        const size_t injectAllocationSize =
+            pool->freeBytes() + arbitrator->stats().freeCapacityBytes;
+        fakeAllocation = TestAllocation{
+            .pool = fakePool.get(),
+            .buffer = fakePool->allocate(injectAllocationSize),
+            .size = injectAllocationSize};
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::flushStripe",
+      std::function<void(dwrf::Writer*)>(
+          [&](dwrf::Writer* writer) { fakeAllocation.free(); }));
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto writerPlan =
+      PlanBuilder()
+          .values(vectors)
+          .tableWrite(outputDirectory->getPath())
+          .singleAggregation(
+              {},
+              {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())})
+          .planNode();
+
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .queryCtx(queryCtx)
+      .maxDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kWriterSpillEnabled, true)
+      // Set 0 file writer flush threshold to always trigger flush in test.
+      .config(core::QueryConfig::kWriterFlushThresholdBytes, 0)
+      // Set stripe size to extreme large to avoid writer internal triggered
+      // flush.
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kOrcWriterMaxStripeSizeSession,
+          "1GB")
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kOrcWriterMaxDictionaryMemorySession,
+          "1GB")
+      .plan(std::move(writerPlan))
+      .assertResults(fmt::format("SELECT {}", numRows));
+
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(
+    TableWriterArbitrationTest,
+    raceBetweenWriterCloseAndTaskReclaim) {
+  const uint64_t memoryCapacity = 512 * MB;
+  std::vector<RowVectorPtr> vectors =
+      createVectors(rowType_, memoryCapacity / 8, fuzzerOpts_);
+  const auto expectedResult =
+      runWriteTask(vectors, nullptr, false, 1, pool(), kHiveConnectorId, false)
+          .data;
+  auto queryCtx =
+      newQueryCtx(memory::memoryManager(), executor_.get(), memoryCapacity);
+
+  std::atomic_bool writerCloseWaitFlag{true};
+  folly::EventCount writerCloseWait;
+  std::atomic_bool taskReclaimWaitFlag{true};
+  folly::EventCount taskReclaimWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwrf::Writer::flushStripe",
+      std::function<void(dwrf::Writer*)>(([&](dwrf::Writer* writer) {
+        writerCloseWaitFlag = false;
+        writerCloseWait.notifyAll();
+        taskReclaimWait.await([&]() { return !taskReclaimWaitFlag.load(); });
+      })));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::requestPauseLocked",
+      std::function<void(Task*)>(([&](Task* /*unused*/) {
+        taskReclaimWaitFlag = false;
+        taskReclaimWait.notifyAll();
+      })));
+
+  std::thread queryThread([&]() {
+    const auto result = runWriteTask(
+        vectors,
+        queryCtx,
+        false,
+        1,
+        pool(),
+        kHiveConnectorId,
+        true,
+        expectedResult);
+  });
+
+  writerCloseWait.await([&]() { return !writerCloseWaitFlag.load(); });
+
+  memory::testingRunArbitration();
+
+  queryThread.join();
+  waitForAllTasksToBeDeleted();
+}
diff --git a/velox/exec/tests/TaskTest.cpp b/velox/exec/tests/TaskTest.cpp
index bb3708a096bbd..307d168a3f1a2 100644
--- a/velox/exec/tests/TaskTest.cpp
+++ b/velox/exec/tests/TaskTest.cpp
@@ -18,16 +18,20 @@
 #include "folly/experimental/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/future/VeloxPromise.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/testutil/TestValue.h"
-#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/Values.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/Cursor.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::common::testutil;
@@ -277,8 +281,8 @@ class ExternalBlocker {
 };
 
 // A test node that normally just re-project/passthrough the output from input
-// When the node is blocked by external even (via externalBlocker), the operator
-// will signal kBlocked. The pipeline can ONLY proceed again when it is
+// When the node is blocked by external event (via externalBlocker), the
+// operator will signal kBlocked. The pipeline can ONLY proceed again when it is
 // unblocked externally.
 class TestExternalBlockableNode : public core::PlanNode {
  public:
@@ -454,15 +458,20 @@ class TestBadMemoryTranslator : public exec::Operator::PlanNodeTranslator {
   }
 };
 } // namespace
+
 class TaskTest : public HiveConnectorTestBase {
  protected:
   static std::pair<std::shared_ptr<exec::Task>, std::vector<RowVectorPtr>>
-  executeSingleThreaded(
+  executeSerial(
       core::PlanFragment plan,
       const std::unordered_map<std::string, std::vector<std::string>>&
           filePaths = {}) {
     auto task = Task::create(
-        "single.execution.task.0", plan, 0, std::make_shared<core::QueryCtx>());
+        "single.execution.task.0",
+        plan,
+        0,
+        core::QueryCtx::create(),
+        Task::ExecutionMode::kSerial);
 
     for (const auto& [nodeId, paths] : filePaths) {
       for (const auto& path : paths) {
@@ -471,7 +480,7 @@ class TaskTest : public HiveConnectorTestBase {
       task->noMoreSplits(nodeId);
     }
 
-    VELOX_CHECK(task->supportsSingleThreadedExecution());
+    VELOX_CHECK(task->supportSerialExecutionMode());
 
     vector_size_t numRows = 0;
     std::vector<RowVectorPtr> results;
@@ -500,6 +509,45 @@ class TaskTest : public HiveConnectorTestBase {
   }
 };
 
+TEST_F(TaskTest, toJson) {
+  auto plan = PlanBuilder()
+                  .tableScan(ROW({"a", "b"}, {INTEGER(), DOUBLE()}))
+                  .project({"a * a", "b + b"})
+                  .planFragment();
+
+  auto task = Task::create(
+      "task-1",
+      std::move(plan),
+      0,
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
+
+  ASSERT_EQ(
+      task->toString(),
+      "{Task task-1 (task-1)\n"
+      "Plan:\n"
+      "-- Project[1][expressions: (p0:INTEGER, multiply(ROW[\"a\"],ROW[\"a\"])), (p1:DOUBLE, plus(ROW[\"b\"],ROW[\"b\"]))] -> p0:INTEGER, p1:DOUBLE\n"
+      "  -- TableScan[0][table: hive_table] -> a:INTEGER, b:DOUBLE\n"
+      "\n}");
+  ASSERT_EQ(
+      folly::toPrettyJson(task->toJson()),
+      "{\n  \"concurrentSplitGroups\": 1,\n  \"drivers\": {},\n  \"exchangeClientByPlanNode\": {},\n  \"groupedPartitionedOutput\": false,\n  \"id\": \"task-1\",\n  \"noMoreOutputBuffers\": false,\n  \"numDriversPerSplitGroup\": 0,\n  \"numDriversUngrouped\": 0,\n  \"numFinishedDrivers\": 0,\n  \"numRunningDrivers\": 0,\n  \"numRunningSplitGroups\": 0,\n  \"numThreads\": 0,\n  \"numTotalDrivers\": 0,\n  \"onThreadSince\": \"0\",\n  \"partitionedOutputConsumed\": false,\n  \"pauseRequested\": false,\n  \"plan\": \"-- Project[1][expressions: (p0:INTEGER, multiply(ROW[\\\"a\\\"],ROW[\\\"a\\\"])), (p1:DOUBLE, plus(ROW[\\\"b\\\"],ROW[\\\"b\\\"]))] -> p0:INTEGER, p1:DOUBLE\\n  -- TableScan[0][table: hive_table] -> a:INTEGER, b:DOUBLE\\n\",\n  \"shortId\": \"task-1\",\n  \"state\": \"Running\",\n  \"terminateRequested\": false\n}");
+  ASSERT_EQ(
+      folly::toPrettyJson(task->toShortJson()),
+      "{\n  \"id\": \"task-1\",\n  \"numFinishedDrivers\": 0,\n  \"numRunningDrivers\": 0,\n  \"numThreads\": 0,\n  \"numTotalDrivers\": 0,\n  \"pauseRequested\": false,\n  \"shortId\": \"task-1\",\n  \"state\": \"Running\",\n  \"terminateRequested\": false\n}");
+
+  task->start(2);
+
+  ASSERT_NO_THROW(task->toJson());
+  ASSERT_NO_THROW(task->toShortJson());
+
+  task->noMoreSplits("0");
+  waitForTaskCompletion(task.get());
+
+  ASSERT_NO_THROW(task->toJson());
+  ASSERT_NO_THROW(task->toShortJson());
+}
+
 TEST_F(TaskTest, wrongPlanNodeForSplit) {
   auto connectorSplit = std::make_shared<connector::hive::HiveConnectorSplit>(
       "test",
@@ -517,16 +565,8 @@ TEST_F(TaskTest, wrongPlanNodeForSplit) {
       "task-1",
       std::move(plan),
       0,
-      std::make_shared<core::QueryCtx>(driverExecutor_.get()));
-
-  ASSERT_EQ(
-      task->toString(), "{Task task-1 (task-1)Plan: -- Project\n\n drivers:\n");
-  ASSERT_EQ(
-      task->toJsonString(),
-      "{\n  \"concurrentSplitGroups\": 1,\n  \"drivers\": {},\n  \"exchangeClientByPlanNode\": {},\n  \"groupedPartitionedOutput\": false,\n  \"id\": \"task-1\",\n  \"noMoreOutputBuffers\": false,\n  \"numDriversPerSplitGroup\": 0,\n  \"numDriversUngrouped\": 0,\n  \"numFinishedDrivers\": 0,\n  \"numRunningDrivers\": 0,\n  \"numRunningSplitGroups\": 0,\n  \"numThreads\": 0,\n  \"numTotalDrivers_\": 0,\n  \"onThreadSince\": \"0\",\n  \"partitionedOutputConsumed\": false,\n  \"plan\": \"-- Project\\n\",\n  \"shortId\": \"task-1\",\n  \"state\": \"Running\",\n  \"terminateRequested_\": \"0\"\n}");
-  ASSERT_EQ(
-      task->toShortJsonString(),
-      "{\n  \"id\": \"task-1\",\n  \"numFinishedDrivers\": 0,\n  \"numRunningDrivers\": 0,\n  \"numThreads\": 0,\n  \"numTotalDrivers_\": 0,\n  \"pauseRequested_\": \"0\",\n  \"shortId\": \"task-1\",\n  \"state\": \"Running\",\n  \"terminateRequested_\": \"0\"\n}");
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
 
   // Add split for the source node.
   task->addSplit("0", exec::Split(folly::copy(connectorSplit)));
@@ -581,7 +621,8 @@ TEST_F(TaskTest, wrongPlanNodeForSplit) {
       "task-2",
       std::move(plan),
       0,
-      std::make_shared<core::QueryCtx>(driverExecutor_.get()));
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
   errorMessage =
       "Splits can be associated only with leaf plan nodes which require splits. Plan node ID 0 doesn't refer to such plan node.";
   VELOX_ASSERT_THROW(
@@ -607,7 +648,8 @@ TEST_F(TaskTest, duplicatePlanNodeIds) {
           "task-1",
           std::move(plan),
           0,
-          std::make_shared<core::QueryCtx>(driverExecutor_.get())),
+          core::QueryCtx::create(driverExecutor_.get()),
+          Task::ExecutionMode::kParallel),
       "Plan node IDs must be unique. Found duplicate ID: 0.")
 }
 
@@ -658,7 +700,7 @@ TEST_F(TaskTest, testTerminateDeadlock) {
           .project({"c0"})
           .planNode();
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
 
   folly::via(cursor->task()->queryCtx()->executor(), [&]() {
     // We abort after all but last join bridges finish execution. We do this
@@ -672,9 +714,20 @@ TEST_F(TaskTest, testTerminateDeadlock) {
   });
 
   VELOX_ASSERT_THROW(cursor->moveNext(), "Aborted for external error");
+
+  // There should be some Drivers closed by the Task due to termination.
+  // They also should all be empty, otherwise we have zombie Drivers.
+  const auto& driversClosedByTask =
+      cursor->task()->testingDriversClosedByTask();
+  EXPECT_GT(driversClosedByTask.size(), 0);
+  for (const auto& driverWeak : driversClosedByTask) {
+    EXPECT_EQ(driverWeak.lock(), nullptr);
+  }
+  EXPECT_EQ(
+      cursor->task()->toString().find("zombie drivers:"), std::string::npos);
 }
 
-TEST_F(TaskTest, singleThreadedExecution) {
+TEST_F(TaskTest, serialExecution) {
   auto data = makeRowVector({
       makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
   });
@@ -693,7 +746,7 @@ TEST_F(TaskTest, singleThreadedExecution) {
   uint64_t numCreatedTasks = Task::numCreatedTasks();
   uint64_t numDeletedTasks = Task::numDeletedTasks();
   {
-    auto [task, results] = executeSingleThreaded(plan);
+    auto [task, results] = executeSerial(plan);
     assertEqualResults(
         std::vector<RowVectorPtr>{expectedResult, expectedResult}, results);
   }
@@ -726,7 +779,7 @@ TEST_F(TaskTest, singleThreadedExecution) {
   ++numCreatedTasks;
   ++numDeletedTasks;
   {
-    auto [task, results] = executeSingleThreaded(plan);
+    auto [task, results] = executeSerial(plan);
     assertEqualResults({expectedResult}, results);
   }
   ASSERT_EQ(numCreatedTasks + 1, Task::numCreatedTasks());
@@ -734,7 +787,7 @@ TEST_F(TaskTest, singleThreadedExecution) {
 
   // Project + Aggregation over TableScan.
   auto filePath = TempFilePath::create();
-  writeToFile(filePath->path, {data, data});
+  writeToFile(filePath->getPath(), {data, data});
 
   core::PlanNodeId scanId;
   plan = PlanBuilder()
@@ -746,16 +799,16 @@ TEST_F(TaskTest, singleThreadedExecution) {
 
   {
     auto [task, results] =
-        executeSingleThreaded(plan, {{scanId, {filePath->path}}});
+        executeSerial(plan, {{scanId, {filePath->getPath()}}});
     assertEqualResults({expectedResult}, results);
   }
 
   // Query failure.
   plan = PlanBuilder().values({data, data}).project({"c0 / 0"}).planFragment();
-  VELOX_ASSERT_THROW(executeSingleThreaded(plan), "division by zero");
+  VELOX_ASSERT_THROW(executeSerial(plan), "division by zero");
 }
 
-TEST_F(TaskTest, singleThreadedHashJoin) {
+TEST_F(TaskTest, serialHashJoin) {
   auto left = makeRowVector(
       {"t_c0", "t_c1"},
       {
@@ -763,7 +816,7 @@ TEST_F(TaskTest, singleThreadedHashJoin) {
           makeFlatVector<int64_t>({10, 20, 30, 40}),
       });
   auto leftPath = TempFilePath::create();
-  writeToFile(leftPath->path, {left});
+  writeToFile(leftPath->getPath(), {left});
 
   auto right = makeRowVector(
       {"u_c0"},
@@ -771,7 +824,7 @@ TEST_F(TaskTest, singleThreadedHashJoin) {
           makeFlatVector<int64_t>({0, 1, 3, 5}),
       });
   auto rightPath = TempFilePath::create();
-  writeToFile(rightPath->path, {right});
+  writeToFile(rightPath->getPath(), {right});
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId leftScanId;
@@ -797,21 +850,22 @@ TEST_F(TaskTest, singleThreadedHashJoin) {
   });
 
   {
-    auto [task, results] = executeSingleThreaded(
+    auto [task, results] = executeSerial(
         plan,
-        {{leftScanId, {leftPath->path}}, {rightScanId, {rightPath->path}}});
+        {{leftScanId, {leftPath->getPath()}},
+         {rightScanId, {rightPath->getPath()}}});
     assertEqualResults({expectedResult}, results);
   }
 }
 
-TEST_F(TaskTest, singleThreadedCrossJoin) {
+TEST_F(TaskTest, serialCrossJoin) {
   auto left = makeRowVector({"t_c0"}, {makeFlatVector<int64_t>({1, 2, 3})});
   auto leftPath = TempFilePath::create();
-  writeToFile(leftPath->path, {left});
+  writeToFile(leftPath->getPath(), {left});
 
   auto right = makeRowVector({"u_c0"}, {makeFlatVector<int64_t>({10, 20})});
   auto rightPath = TempFilePath::create();
-  writeToFile(rightPath->path, {right});
+  writeToFile(rightPath->getPath(), {right});
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId leftScanId;
@@ -834,14 +888,15 @@ TEST_F(TaskTest, singleThreadedCrossJoin) {
   });
 
   {
-    auto [task, results] = executeSingleThreaded(
+    auto [task, results] = executeSerial(
         plan,
-        {{leftScanId, {leftPath->path}}, {rightScanId, {rightPath->path}}});
+        {{leftScanId, {leftPath->getPath()}},
+         {rightScanId, {rightPath->getPath()}}});
     assertEqualResults({expectedResult}, results);
   }
 }
 
-TEST_F(TaskTest, singleThreadedExecutionExternalBlockable) {
+TEST_F(TaskTest, serialExecutionExternalBlockable) {
   exec::Operator::registerOperator(
       std::make_unique<TestExternalBlockableTranslator>());
   auto data = makeRowVector({
@@ -863,7 +918,11 @@ TEST_F(TaskTest, singleThreadedExecutionExternalBlockable) {
   // First pass, we don't activate the external blocker, expect the task to run
   // without being blocked.
   auto nonBlockingTask = Task::create(
-      "single.execution.task.0", plan, 0, std::make_shared<core::QueryCtx>());
+      "single.execution.task.0",
+      plan,
+      0,
+      core::QueryCtx::create(),
+      Task::ExecutionMode::kSerial);
   std::vector<RowVectorPtr> results;
   for (;;) {
     auto result = nonBlockingTask->next(&continueFuture);
@@ -879,7 +938,11 @@ TEST_F(TaskTest, singleThreadedExecutionExternalBlockable) {
   continueFuture = ContinueFuture::makeEmpty();
   // Second pass, we will now use external blockers to block the task.
   auto blockingTask = Task::create(
-      "single.execution.task.1", plan, 0, std::make_shared<core::QueryCtx>());
+      "single.execution.task.1",
+      plan,
+      0,
+      core::QueryCtx::create(),
+      Task::ExecutionMode::kSerial);
   // Before we block, we expect `next` to get data normally.
   results.push_back(blockingTask->next(&continueFuture));
   EXPECT_TRUE(results.back() != nullptr);
@@ -904,18 +967,22 @@ TEST_F(TaskTest, singleThreadedExecutionExternalBlockable) {
   EXPECT_EQ(3, results.size());
 }
 
-TEST_F(TaskTest, supportsSingleThreadedExecution) {
+TEST_F(TaskTest, supportSerialExecutionMode) {
   auto plan = PlanBuilder()
                   .tableScan(ROW({"c0"}, {BIGINT()}))
                   .project({"c0 % 10"})
                   .partitionedOutput({}, 1, std::vector<std::string>{"p0"})
                   .planFragment();
   auto task = Task::create(
-      "single.execution.task.0", plan, 0, std::make_shared<core::QueryCtx>());
+      "single.execution.task.0",
+      plan,
+      0,
+      core::QueryCtx::create(),
+      Task::ExecutionMode::kSerial);
 
-  // PartitionedOutput does not support single threaded execution, therefore the
+  // PartitionedOutput does not support serial execution mode, therefore the
   // task doesn't support it either.
-  ASSERT_FALSE(task->supportsSingleThreadedExecution());
+  ASSERT_FALSE(task->supportSerialExecutionMode());
 }
 
 TEST_F(TaskTest, updateBroadCastOutputBuffers) {
@@ -924,12 +991,16 @@ TEST_F(TaskTest, updateBroadCastOutputBuffers) {
                   .project({"c0 % 10"})
                   .partitionedOutputBroadcast({})
                   .planFragment();
-  auto bufferManager = PartitionedOutputBufferManager::getInstance().lock();
+  auto bufferManager = OutputBufferManager::getInstance().lock();
   {
     auto task = Task::create(
-        "t0", plan, 0, std::make_shared<core::QueryCtx>(driverExecutor_.get()));
+        "t0",
+        plan,
+        0,
+        core::QueryCtx::create(driverExecutor_.get()),
+        Task::ExecutionMode::kParallel);
 
-    task->start(task, 1, 1);
+    task->start(1, 1);
 
     ASSERT_TRUE(task->updateOutputBuffers(10, true /*noMoreBuffers*/));
 
@@ -941,9 +1012,13 @@ TEST_F(TaskTest, updateBroadCastOutputBuffers) {
 
   {
     auto task = Task::create(
-        "t1", plan, 0, std::make_shared<core::QueryCtx>(driverExecutor_.get()));
+        "t1",
+        plan,
+        0,
+        core::QueryCtx::create(driverExecutor_.get()),
+        Task::ExecutionMode::kParallel);
 
-    task->start(task, 1, 1);
+    task->start(1, 1);
 
     ASSERT_TRUE(task->updateOutputBuffers(5, false));
     ASSERT_TRUE(task->updateOutputBuffers(10, false));
@@ -1016,12 +1091,12 @@ DEBUG_ONLY_TEST_F(TaskTest, outputDriverFinishEarly) {
 
   CursorParameters params;
   params.planNode = plan;
-  params.queryCtx = std::make_shared<core::QueryCtx>(driverExecutor_.get());
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
   params.queryCtx->testingOverrideConfigUnsafe(
       {{core::QueryConfig::kPreferredOutputBatchRows, "1"}});
 
   {
-    auto cursor = std::make_unique<TaskCursor>(params);
+    auto cursor = TaskCursor::create(params);
     std::vector<RowVectorPtr> result;
     auto* task = cursor->task().get();
     while (cursor->moveNext()) {
@@ -1033,6 +1108,7 @@ DEBUG_ONLY_TEST_F(TaskTest, outputDriverFinishEarly) {
         "VALUES (0)",
         duckDbQueryRunner_);
     ASSERT_TRUE(waitForTaskStateChange(task, TaskState::kFinished, 3'000'000));
+    ASSERT_FALSE(task->getCancellationToken().isCancellationRequested());
   }
   valuePromise.setValue();
   // Wait for Values driver to complete.
@@ -1062,11 +1138,11 @@ DEBUG_ONLY_TEST_F(TaskTest, liveStats) {
 
   CursorParameters params;
   params.planNode = plan;
-  params.queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+  params.queryCtx = core::QueryCtx::create(executor_.get());
   params.queryCtx->testingOverrideConfigUnsafe(
       {{core::QueryConfig::kPreferredOutputBatchRows, "1"}});
 
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   std::vector<RowVectorPtr> result;
   task = cursor->task().get();
   while (cursor->moveNext()) {
@@ -1089,11 +1165,16 @@ DEBUG_ONLY_TEST_F(TaskTest, liveStats) {
     EXPECT_EQ(0, liveStats[i].numCompletedDrivers);
     EXPECT_EQ(0, liveStats[i].numTerminatedDrivers);
     EXPECT_EQ(1, liveStats[i].numRunningDrivers);
+    EXPECT_EQ(0, liveStats[i].numQueuedDrivers);
     EXPECT_EQ(0, liveStats[i].numBlockedDrivers.size());
+
+    EXPECT_EQ(0, liveStats[i].executionEndTimeMs);
+    EXPECT_EQ(0, liveStats[i].terminationTimeMs);
   }
 
   EXPECT_EQ(1, finishStats.numTotalDrivers);
   EXPECT_EQ(1, finishStats.numCompletedDrivers);
+  EXPECT_EQ(0, finishStats.numQueuedDrivers);
   EXPECT_EQ(0, finishStats.numTerminatedDrivers);
   EXPECT_EQ(0, finishStats.numRunningDrivers);
   EXPECT_EQ(0, finishStats.numBlockedDrivers.size());
@@ -1106,12 +1187,26 @@ DEBUG_ONLY_TEST_F(TaskTest, liveStats) {
   EXPECT_EQ(1, operatorStats.finishTiming.count);
   // No operators with background CPU time yet.
   EXPECT_EQ(0, operatorStats.backgroundTiming.count);
+
+  EXPECT_NE(0, finishStats.executionEndTimeMs);
+  EXPECT_NE(0, finishStats.terminationTimeMs);
+  const auto terminationTimeMs = finishStats.terminationTimeMs;
+
+  // Sleep to allow time to pass, so the values change.
+  std::this_thread::sleep_for(std::chrono::milliseconds{5});
+  EXPECT_NE(0, task->timeSinceEndMs());
+  EXPECT_NE(0, task->timeSinceTerminationMs());
+
+  // This should be a no-op.
+  task->requestCancel();
+  EXPECT_EQ(terminationTimeMs, task->taskStats().terminationTimeMs);
 }
 
 TEST_F(TaskTest, outputBufferSize) {
   constexpr int32_t numBatches = 10;
   std::vector<RowVectorPtr> dataBatches;
   dataBatches.reserve(numBatches);
+  const int numRows = numBatches * 3;
   for (int32_t i = 0; i < numBatches; ++i) {
     dataBatches.push_back(makeRowVector({makeFlatVector<int64_t>({0, 1, 10})}));
   }
@@ -1124,27 +1219,91 @@ TEST_F(TaskTest, outputBufferSize) {
 
   CursorParameters params;
   params.planNode = plan;
-  params.queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+  params.queryCtx = core::QueryCtx::create(executor_.get());
 
   // Produce the results to output buffer manager but not consuming them to
   // check the buffer utilization in test.
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   std::vector<RowVectorPtr> result;
   Task* task = cursor->task().get();
   while (cursor->moveNext()) {
     result.push_back(cursor->current());
   }
 
-  TaskStats finishStats = task->taskStats();
+  const TaskStats finishStats = task->taskStats();
   // We only have one task and the task has outputBuffer which won't be
   // consumed, verify 0 < outputBufferUtilization < 1.
   // Need to call requestCancel to explicitly terminate the task.
-  EXPECT_GT(finishStats.outputBufferUtilization, 0);
-  EXPECT_LT(finishStats.outputBufferUtilization, 1);
-  EXPECT_FALSE(finishStats.outputBufferOverutilized);
+  ASSERT_GT(finishStats.outputBufferUtilization, 0);
+  ASSERT_LT(finishStats.outputBufferUtilization, 1);
+  ASSERT_TRUE(finishStats.outputBufferOverutilized);
+  ASSERT_TRUE(finishStats.outputBufferStats.has_value());
+  const auto outputStats = finishStats.outputBufferStats.value();
+  ASSERT_EQ(outputStats.kind, core::PartitionedOutputNode::Kind::kPartitioned);
+  ASSERT_EQ(outputStats.totalRowsSent, numRows);
+  ASSERT_GT(outputStats.totalPagesSent, 0);
+  ASSERT_GT(outputStats.bufferedBytes, 0);
+  ASSERT_EQ(outputStats.bufferedPages, outputStats.totalPagesSent);
   task->requestCancel();
 }
 
+DEBUG_ONLY_TEST_F(TaskTest, inconsistentExecutionMode) {
+  {
+    // Scenario 1: Parallel execution starts first then kicks in Serial
+    // execution.
+
+    // Let parallel execution pause a bit so that we can call serial API on Task
+    // to trigger inconsistent execution mode failure.
+    folly::EventCount getOutputWait;
+    std::atomic_bool getOutputWaitFlag{false};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Values::getOutput",
+        std::function<void(Values*)>([&](Values* /*unused*/) {
+          getOutputWait.await([&]() { return getOutputWaitFlag.load(); });
+        }));
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+    });
+
+    CursorParameters params;
+    params.planNode =
+        PlanBuilder().values({data, data, data}).project({"c0"}).planNode();
+    params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+    params.maxDrivers = 4;
+
+    auto cursor = TaskCursor::create(params);
+    auto* task = cursor->task().get();
+
+    cursor->start();
+    VELOX_ASSERT_THROW(task->next(), "Inconsistent task execution mode.");
+    getOutputWaitFlag = true;
+    getOutputWait.notify();
+    while (cursor->hasNext()) {
+      cursor->moveNext();
+    }
+    waitForTaskCompletion(task);
+  }
+
+  {
+    // Scenario 2: Serial execution starts first then kicks in Parallel
+    // execution mode.
+
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+    });
+    auto plan =
+        PlanBuilder().values({data, data, data}).project({"c0"}).planFragment();
+    auto queryCtx = core::QueryCtx::create(driverExecutor_.get());
+    auto task =
+        Task::create("task.0", plan, 0, queryCtx, Task::ExecutionMode::kSerial);
+
+    task->next();
+    VELOX_ASSERT_THROW(task->start(4, 1), "Inconsistent task execution mode.");
+    while (task->next() != nullptr) {
+    }
+  }
+}
+
 DEBUG_ONLY_TEST_F(TaskTest, findPeerOperators) {
   const std::vector<RowVectorPtr> probeVectors = {makeRowVector(
       {"t_c0", "t_c1"},
@@ -1175,10 +1334,10 @@ DEBUG_ONLY_TEST_F(TaskTest, findPeerOperators) {
                               "",
                               {"t_c0", "t_c1", "u_c0"})
                           .planNode();
-    params.queryCtx = std::make_shared<core::QueryCtx>(driverExecutor_.get());
+    params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
     params.maxDrivers = numDriver;
 
-    auto cursor = std::make_unique<TaskCursor>(params);
+    auto cursor = TaskCursor::create(params);
     auto* task = cursor->task().get();
 
     // Set up a testvalue to trigger task abort when hash build tries to reserve
@@ -1214,77 +1373,245 @@ DEBUG_ONLY_TEST_F(TaskTest, findPeerOperators) {
   }
 }
 
-DEBUG_ONLY_TEST_F(TaskTest, raceBetweenTaskPauseAndTerminate) {
-  const std::vector<RowVectorPtr> values = {makeRowVector(
-      {"t_c0", "t_c1"},
-      {
-          makeFlatVector<int64_t>({1, 2, 3, 4}),
-          makeFlatVector<int64_t>({10, 20, 30, 40}),
-      })};
+class TaskPauseTest : public TaskTest {
+ public:
+  void testPause() {
+    const std::vector<RowVectorPtr> values = {makeRowVector(
+        {"t_c0", "t_c1"},
+        {
+            makeFlatVector<int64_t>({1, 2, 3, 4}),
+            makeFlatVector<int64_t>({10, 20, 30, 40}),
+        })};
 
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  CursorParameters params;
-  params.planNode =
-      PlanBuilder(planNodeIdGenerator).values(values, true).planNode();
-  params.queryCtx = std::make_shared<core::QueryCtx>(driverExecutor_.get());
-  params.maxDrivers = 1;
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    CursorParameters params;
+    params.planNode =
+        PlanBuilder(planNodeIdGenerator).values(values, true).planNode();
+    params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+    params.maxDrivers = 1;
 
-  auto cursor = std::make_unique<TaskCursor>(params);
-  auto* task = cursor->task().get();
-  folly::EventCount taskPauseWait;
-  std::atomic<bool> taskPaused{false};
+    cursor_ = TaskCursor::create(params);
+    task_ = cursor_->task().get();
+    folly::EventCount taskPauseWait;
+    std::atomic<bool> taskPaused{false};
 
-  folly::EventCount taskPauseStartWait;
-  std::atomic<bool> taskPauseStarted{false};
+    folly::EventCount taskPauseStartWait;
+    std::atomic<bool> taskPauseStarted{false};
 
-  // Set up a testvalue to trigger task abort when hash build tries to reserve
-  // memory.
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::Driver::runInternal::addInput",
-      std::function<void(Operator*)>([&](Operator* testOp) {
-        if (taskPauseStarted.exchange(true)) {
-          return;
-        }
-        taskPauseStartWait.notifyAll();
-        taskPauseWait.await([&]() { return taskPaused.load(); });
-      }));
+    // Set up a testvalue to trigger task abort when hash build tries to reserve
+    // memory.
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>([&](Operator* testOp) {
+          if (taskPauseStarted.exchange(true)) {
+            return;
+          }
+          taskPauseStartWait.notifyAll();
+          taskPauseWait.await([&]() { return taskPaused.load(); });
+        }));
 
-  std::thread taskThread([&]() {
-    try {
-      while (cursor->moveNext()) {
-      };
-    } catch (VeloxRuntimeError& ex) {
-    }
+    taskThread_ = std::thread([&]() {
+      try {
+        while (cursor_->moveNext()) {
+        };
+      } catch (VeloxRuntimeError&) {
+      }
+    });
+
+    taskPauseStartWait.await([&]() { return taskPauseStarted.load(); });
+
+    ASSERT_EQ(task_->numTotalDrivers(), 1);
+    ASSERT_EQ(task_->numFinishedDrivers(), 0);
+    ASSERT_EQ(task_->numRunningDrivers(), 1);
+
+    auto pauseFuture = task_->requestPause();
+    taskPaused = true;
+    taskPauseWait.notifyAll();
+    pauseFuture.wait();
+
+    ASSERT_EQ(task_->numTotalDrivers(), 1);
+    ASSERT_EQ(task_->numFinishedDrivers(), 0);
+    ASSERT_EQ(task_->numRunningDrivers(), 1);
+    ASSERT_TRUE(task_->pauseRequested());
+  }
+
+  void TearDown() override {
+    cursor_.reset();
+    HiveConnectorTestBase::TearDown();
+  }
+
+ protected:
+  Task* task_{nullptr};
+  std::unique_ptr<TaskCursor> cursor_{};
+  std::thread taskThread_{};
+};
+
+DEBUG_ONLY_TEST_F(TaskPauseTest, raceBetweenTaskPauseAndTerminate) {
+  testPause();
+  task_->requestAbort().wait();
+
+  ASSERT_EQ(task_->numTotalDrivers(), 1);
+  ASSERT_EQ(task_->numFinishedDrivers(), 0);
+  ASSERT_EQ(task_->numRunningDrivers(), 0);
+
+  Task::resume(task_->shared_from_this());
+
+  ASSERT_EQ(task_->numTotalDrivers(), 1);
+  ASSERT_EQ(task_->numFinishedDrivers(), 1);
+  ASSERT_EQ(task_->numRunningDrivers(), 0);
+
+  taskThread_.join();
+}
+
+DEBUG_ONLY_TEST_F(TaskPauseTest, resumeFuture) {
+  // Test for trivial wait on Task::pauseRequested future.
+  testPause();
+  folly::EventCount taskResumeAllowedWait;
+  std::atomic<bool> taskResumeAllowed{false};
+  std::thread observeThread([&]() {
+    ContinueFuture future = ContinueFuture::makeEmpty();
+    const bool paused = task_->pauseRequested(&future);
+    ASSERT_TRUE(paused);
+    taskResumeAllowed = true;
+    taskResumeAllowedWait.notifyAll();
+    future.wait();
+    ASSERT_FALSE(task_->pauseRequested());
   });
 
-  taskPauseStartWait.await([&]() { return taskPauseStarted.load(); });
+  taskResumeAllowedWait.await([&]() { return taskResumeAllowed.load(); });
+  std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+  Task::resume(task_->shared_from_this());
 
-  ASSERT_EQ(task->numTotalDrivers(), 1);
-  ASSERT_EQ(task->numFinishedDrivers(), 0);
-  ASSERT_EQ(task->numRunningDrivers(), 1);
+  taskThread_.join();
+  observeThread.join();
 
-  auto pauseFuture = task->requestPause();
-  taskPaused = true;
-  taskPauseWait.notifyAll();
-  pauseFuture.wait();
+  ASSERT_EQ(task_->numTotalDrivers(), 1);
+  ASSERT_EQ(task_->numFinishedDrivers(), 1);
+  ASSERT_EQ(task_->numRunningDrivers(), 0);
+}
+
+DEBUG_ONLY_TEST_F(TaskPauseTest, resumeFutureAfterTaskTerminated) {
+  testPause();
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  const bool paused = task_->pauseRequested(&future);
+  ASSERT_TRUE(paused);
+  ASSERT_EQ(task_->numTotalDrivers(), 1);
+  ASSERT_EQ(task_->numFinishedDrivers(), 0);
+  ASSERT_EQ(task_->numRunningDrivers(), 1);
+  task_->requestCancel().wait();
+  ASSERT_EQ(task_->numTotalDrivers(), 1);
+  ASSERT_EQ(task_->numFinishedDrivers(), 0);
+  ASSERT_EQ(task_->numRunningDrivers(), 0);
+  std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+  ASSERT_FALSE(future.isReady());
+  Task::resume(task_->shared_from_this());
+  ASSERT_TRUE(future.isReady());
+  future.wait();
+  ASSERT_FALSE(task_->pauseRequested());
+  taskThread_.join();
+}
 
-  ASSERT_EQ(task->numTotalDrivers(), 1);
-  ASSERT_EQ(task->numFinishedDrivers(), 0);
-  ASSERT_EQ(task->numRunningDrivers(), 1);
+DEBUG_ONLY_TEST_F(TaskTest, driverCounters) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+  });
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), {data, data});
 
-  task->requestAbort().wait();
+  core::PlanNodeId scanNodeId;
+  auto plan = PlanBuilder()
+                  .tableScan(asRowType(data->type()))
+                  .capturePlanNodeId(scanNodeId)
+                  .project({"c0 % 5 as k", "c0"})
+                  .planFragment();
 
-  ASSERT_EQ(task->numTotalDrivers(), 1);
-  ASSERT_EQ(task->numFinishedDrivers(), 0);
-  ASSERT_EQ(task->numRunningDrivers(), 0);
+  CursorParameters params;
+  params.planNode = plan.planNode;
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+  // The queue size in the executor is 3, so we will have 1 driver queued.
+  params.maxDrivers = 4;
 
-  Task::resume(task->shared_from_this());
+  auto cursor = TaskCursor::create(params);
+  auto task = cursor->task();
 
-  ASSERT_EQ(task->numTotalDrivers(), 1);
-  ASSERT_EQ(task->numFinishedDrivers(), 1);
-  ASSERT_EQ(task->numRunningDrivers(), 0);
+  // Mutex used to pause drivers' execution, so they appear 'on thread'.
+  std::shared_mutex pauseDriverRunInternal;
+  pauseDriverRunInternal.lock();
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal",
+      std::function<void(Driver*)>([&](Driver*) {
+        pauseDriverRunInternal.lock_shared();
+        pauseDriverRunInternal.unlock_shared();
+      }));
 
+  // Run the task in this thread using cursor.
+  std::thread taskThread([&]() {
+    try {
+      while (cursor->moveNext()) {
+      };
+    } catch (VeloxRuntimeError&) {
+    }
+  });
+
+  // Convenience functtor allowing us to ensure the drivers are in the certain
+  // state.
+  Task::DriverCounts driverCounts;
+  auto waitForConditionFunc = [&](auto conditionFunc) {
+    // In case things go wrong, we want to bail out sooner and don't wait until
+    // the test times out, hence we limit waiting time for the condition.
+    size_t numTries{0};
+    while (numTries++ < 20) {
+      driverCounts = task->driverCounts();
+      if (conditionFunc()) {
+        break;
+      }
+      /* sleep override */
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+  };
+
+  // Wait till 3 drivers are on thread. They will be paused at the start with
+  // the help of the testvalue.
+  waitForConditionFunc(
+      [&]() { return (driverCounts.numOnThreadDrivers == 3); });
+  // Expect 3 drivers on the thread.
+  ASSERT_EQ(driverCounts.numOnThreadDrivers, 3);
+  ASSERT_EQ(driverCounts.numQueuedDrivers, 1);
+  ASSERT_EQ(driverCounts.numSuspendedDrivers, 0);
+  ASSERT_EQ(driverCounts.numBlockedDrivers.size(), 0);
+
+  // Allow drivers to proceed, all will be blocked as there are no splits
+  // supplied yet.
+  pauseDriverRunInternal.unlock();
+  waitForConditionFunc([&]() {
+    if (driverCounts.numBlockedDrivers.size() > 0) {
+      auto it = driverCounts.numBlockedDrivers.begin();
+      return (it->first == BlockingReason::kWaitForSplit && it->second == 4);
+    }
+    return false;
+  });
+  // Expect all drivers are blocked on waiting for the splits.
+  ASSERT_EQ(driverCounts.numOnThreadDrivers, 0);
+  ASSERT_EQ(driverCounts.numQueuedDrivers, 0);
+  ASSERT_EQ(driverCounts.numSuspendedDrivers, 0);
+  ASSERT_EQ(driverCounts.numBlockedDrivers.size(), 1);
+  auto it = driverCounts.numBlockedDrivers.begin();
+  ASSERT_EQ(it->first, BlockingReason::kWaitForSplit);
+  ASSERT_EQ(it->second, 4);
+
+  // Now add a split, finalize splits and wait for the task to finish.
+  auto split = exec::Split(makeHiveConnectorSplit(
+      filePath->getPath(), 0, std::numeric_limits<uint64_t>::max(), 1));
+  task->addSplit(scanNodeId, std::move(split));
+  task->noMoreSplits(scanNodeId);
   taskThread.join();
+  waitForConditionFunc(
+      [&]() { return (driverCounts.numOnThreadDrivers == 0); });
+  // Expect no drivers in any of the counters.
+  ASSERT_EQ(driverCounts.numOnThreadDrivers, 0);
+  ASSERT_EQ(driverCounts.numQueuedDrivers, 0);
+  ASSERT_EQ(driverCounts.numSuspendedDrivers, 0);
+  ASSERT_EQ(driverCounts.numBlockedDrivers.size(), 0);
 }
 
 TEST_F(TaskTest, driverCreationMemoryAllocationCheck) {
@@ -1305,13 +1632,629 @@ TEST_F(TaskTest, driverCreationMemoryAllocationCheck) {
         "driverCreationMemoryAllocationCheck",
         plan,
         0,
-        std::make_shared<core::QueryCtx>());
+        core::QueryCtx::create(
+            singleThreadExecution ? nullptr : driverExecutor_.get()),
+        singleThreadExecution ? Task::ExecutionMode::kSerial
+                              : Task::ExecutionMode::kParallel);
     if (singleThreadExecution) {
-      VELOX_ASSERT_THROW(
-          Task::start(badTask, 1), "Unexpected memory pool allocations");
-    } else {
       VELOX_ASSERT_THROW(badTask->next(), "Unexpected memory pool allocations");
+    } else {
+      VELOX_ASSERT_THROW(
+          badTask->start(1), "Unexpected memory pool allocations");
     }
   }
 }
+
+TEST_F(TaskTest, spillDirectoryLifecycleManagement) {
+  // Marks the spill directory as not already created and ensures that the Task
+  // handles creating it on first use and eventually deleting it on destruction.
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row % 300; }),
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+  });
+  core::PlanNodeId aggrNodeId;
+  const auto plan = PlanBuilder()
+                        .values({data})
+                        .singleAggregation({"c0"}, {"sum(c1)"}, {})
+                        .capturePlanNodeId(aggrNodeId)
+                        .planNode();
+  CursorParameters params;
+  params.planNode = plan;
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+  params.queryCtx->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kSpillEnabled, "true"},
+       {core::QueryConfig::kAggregationSpillEnabled, "true"}});
+  params.maxDrivers = 1;
+
+  auto cursor = TaskCursor::create(params);
+  std::shared_ptr<Task> task = cursor->task();
+  auto rootTempDir = exec::test::TempDirectoryPath::create();
+  auto tmpDirectoryPath =
+      rootTempDir->getPath() + "/spillDirectoryLifecycleManagement";
+  task->setSpillDirectory(tmpDirectoryPath, false);
+
+  TestScopedSpillInjection scopedSpillInjection(100);
+  while (cursor->moveNext()) {
+  }
+  ASSERT_TRUE(waitForTaskCompletion(task.get(), 5'000'000));
+  EXPECT_EQ(exec::TaskState::kFinished, task->state());
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  auto& stats = taskStats.at(aggrNodeId);
+  ASSERT_GT(stats.spilledRows, 0);
+  cursor.reset(); // ensure 'task' has no other shared pointer.
+  OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
+}
+
+TEST_F(TaskTest, spillDirNotCreated) {
+  // Verify that no spill directory is created if spilling is not engaged.
+  const std::vector<RowVectorPtr> probeVectors = {makeRowVector(
+      {"t_c0", "t_c1"},
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4}),
+          makeFlatVector<int64_t>({10, 20, 30, 40}),
+      })};
+
+  const std::vector<RowVectorPtr> buildVectors = {makeRowVector(
+      {"u_c0"},
+      {
+          makeFlatVector<int64_t>({0, 1, 3, 5}),
+      })};
+
+  core::PlanNodeId hashJoinNodeId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  // We use a hash join here as a Spiller object is created upfront which helps
+  // us ensure that the directory creation is delayed till spilling is executed.
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values(probeVectors, true)
+                        .hashJoin(
+                            {"t_c0"},
+                            {"u_c0"},
+                            PlanBuilder(planNodeIdGenerator)
+                                .values(buildVectors, true)
+                                .planNode(),
+                            "",
+                            {"t_c0", "t_c1", "u_c0"})
+                        .capturePlanNodeId(hashJoinNodeId)
+                        .planNode();
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+  params.queryCtx->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kSpillEnabled, "true"},
+       {core::QueryConfig::kJoinSpillEnabled, "true"}});
+  params.maxDrivers = 1;
+
+  auto cursor = TaskCursor::create(params);
+  auto* task = cursor->task().get();
+  auto rootTempDir = exec::test::TempDirectoryPath::create();
+  auto tmpDirectoryPath = rootTempDir->getPath() + "/spillDirNotCreated";
+  task->setSpillDirectory(tmpDirectoryPath, false);
+
+  while (cursor->moveNext()) {
+  }
+  ASSERT_TRUE(waitForTaskCompletion(task, 5'000'000));
+  ASSERT_EQ(exec::TaskState::kFinished, task->state());
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  auto& stats = taskStats.at(hashJoinNodeId);
+  ASSERT_EQ(stats.spilledRows, 0);
+  // Check for spill folder without destroying the Task object to ensure its
+  // destructor has not removed the directory if it was created earlier.
+  auto fs = filesystems::getFileSystem(tmpDirectoryPath, nullptr);
+  ASSERT_FALSE(fs->exists(tmpDirectoryPath));
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, resumeAfterTaskFinish) {
+  auto probeVector = makeRowVector(
+      {"t_c0"}, {makeFlatVector<int32_t>(10, [](auto row) { return row; })});
+  auto buildVector = makeRowVector(
+      {"u_c0"}, {makeFlatVector<int32_t>(10, [](auto row) { return row; })});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({probeVector})
+          .hashJoin(
+              {"t_c0"},
+              {"u_c0"},
+              PlanBuilder(planNodeIdGenerator).values({buildVector}).planNode(),
+              "",
+              {"t_c0", "u_c0"})
+          .planFragment();
+
+  std::atomic<bool> valuesWaitFlag{true};
+  folly::EventCount valuesWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const velox::exec::Values*)>(
+          ([&](const velox::exec::Values* values) {
+            valuesWait.await([&]() { return !valuesWaitFlag.load(); });
+          })));
+
+  auto task = Task::create(
+      "task",
+      std::move(plan),
+      0,
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
+  task->start(4, 1);
+
+  // Request pause and then unblock operators to proceed.
+  auto pauseWait = task->requestPause();
+  valuesWaitFlag = false;
+  valuesWait.notifyAll();
+  // Wait for task pause to complete.
+  pauseWait.wait();
+  // Finish the task and for a hash join, the probe operator should still be in
+  // waiting for build stage.
+  task->testingFinish();
+  // Resume the task and expect all drivers to close.
+  Task::resume(task);
+  ASSERT_TRUE(waitForTaskCompletion(task.get()));
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, serialLongRunningOperatorInTaskReclaimerAbort) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+  });
+
+  // Filter + Project.
+  auto plan =
+      PlanBuilder().values({data, data, data}).project({"c0"}).planFragment();
+
+  auto queryCtx = core::QueryCtx::create(driverExecutor_.get());
+
+  auto blockingTask = Task::create(
+      "blocking.task.0", plan, 0, queryCtx, Task::ExecutionMode::kSerial);
+
+  // Before we block, we expect `next` to get data normally.
+  EXPECT_NE(nullptr, blockingTask->next());
+
+  // Now, we want to block the pipeline by blocking Values operator. We expect
+  // `next` to return null.  The `future` should be updated for the caller to
+  // wait before calling next() again
+  folly::EventCount getOutputWait;
+  std::atomic_bool getOutputWaitFlag{false};
+  folly::EventCount abortWait;
+  std::atomic_bool abortWaitFlag{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(Values*)>([&](Values* /*unused*/) {
+        abortWaitFlag = true;
+        abortWait.notify();
+        getOutputWait.await([&]() { return getOutputWaitFlag.load(); });
+      }));
+
+  const std::string abortErrorMessage("Synthetic Exception");
+  auto thread = std::thread(
+      [&]() { VELOX_ASSERT_THROW(blockingTask->next(), abortErrorMessage); });
+
+  try {
+    VELOX_FAIL(abortErrorMessage);
+  } catch (VeloxException&) {
+    abortWait.await([&]() { return abortWaitFlag.load(); });
+    blockingTask->pool()->abort(std::current_exception());
+  }
+
+  waitForTaskCompletion(blockingTask.get(), 5'000'000);
+
+  // We expect that abort does not trigger the operator abort by checking if the
+  // memory pool memory has been released or not.
+  blockingTask->pool()->visitChildren([](auto* child) {
+    if (child->isLeaf()) {
+      EXPECT_EQ(child->stats().numReleases, 0);
+    }
+    return true;
+  });
+
+  getOutputWaitFlag = true;
+  getOutputWait.notify();
+
+  thread.join();
+
+  blockingTask->taskCompletionFuture().wait();
+  blockingTask->pool()->visitChildren([](auto* child) {
+    if (child->isLeaf()) {
+      EXPECT_EQ(child->stats().numReleases, 1);
+    }
+    return true;
+  });
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, longRunningOperatorInTaskReclaimerAbort) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+  });
+  folly::EventCount getOutputWait;
+  std::atomic_bool getOutputWaitFlag{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(Values*)>([&](Values* /*unused*/) {
+        getOutputWait.await([&]() { return getOutputWaitFlag.load(); });
+      }));
+
+  // Project only dummy plan
+  auto plan =
+      PlanBuilder().values({data, data, data}).project({"c0"}).planFragment();
+
+  auto queryCtx = core::QueryCtx::create(driverExecutor_.get());
+
+  auto blockingTask = Task::create(
+      "blocking.task.0", plan, 0, queryCtx, Task::ExecutionMode::kParallel);
+
+  blockingTask->start(4, 1);
+  const std::string abortErrorMessage("Synthetic Exception");
+  try {
+    VELOX_FAIL(abortErrorMessage);
+  } catch (VeloxException&) {
+    blockingTask->pool()->abort(std::current_exception());
+  }
+  waitForTaskCompletion(blockingTask.get());
+
+  // We expect that arbitration does not trigger release of the operator pools.
+  blockingTask->pool()->visitChildren([](auto* child) {
+    if (child->isLeaf()) {
+      EXPECT_EQ(child->stats().numReleases, 0);
+    }
+    return true;
+  });
+
+  getOutputWaitFlag = true;
+  getOutputWait.notify();
+
+  VELOX_ASSERT_THROW(
+      std::rethrow_exception(blockingTask->error()), abortErrorMessage);
+
+  blockingTask->taskCompletionFuture().wait();
+  blockingTask->pool()->visitChildren([](auto* child) {
+    if (child->isLeaf()) {
+      EXPECT_EQ(child->stats().numReleases, 1);
+    }
+    return true;
+  });
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, taskReclaimStats) {
+  const auto data = makeRowVector({
+      makeFlatVector<int64_t>(50, folly::identity),
+      makeFlatVector<int64_t>(50, folly::identity),
+  });
+  const auto plan =
+      PlanBuilder()
+          .values({data})
+          .partitionedOutput({}, 1, std::vector<std::string>{"c0"})
+          .planFragment();
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::requestPauseLocked",
+      std::function<void(Task*)>(([&](Task* /*unused*/) {
+        // Inject some delay for task memory reclaim stats verification.
+        std::this_thread::sleep_for(std::chrono::milliseconds(1)); // NOLINT
+      })));
+
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "taskReclaimStats", 1UL << 30, exec::MemoryReclaimer::create());
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig{{}},
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      nullptr,
+      std::move(queryPool),
+      nullptr);
+  auto task = Task::create(
+      "task",
+      std::move(plan),
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
+  task->start(4, 1);
+
+  const int numReclaims{10};
+  const uint64_t queryCapacity = task->pool()->parent()->capacity();
+  for (int i = 0; i < numReclaims; ++i) {
+    MemoryReclaimer::Stats stats;
+    task->pool()->reclaim(1000, 1UL << 30, stats);
+  }
+  const int64_t reclaimedQueryCapacity =
+      queryCapacity - task->pool()->parent()->capacity();
+  ASSERT_GE(reclaimedQueryCapacity, 0);
+  auto* arbitrator = dynamic_cast<memory::SharedArbitrator*>(
+      memory::memoryManager()->arbitrator());
+  if (arbitrator != nullptr) {
+    arbitrator->testingFreeCapacity(reclaimedQueryCapacity);
+  }
+
+  auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.memoryReclaimCount, numReclaims);
+  ASSERT_GT(taskStats.memoryReclaimMs, 0);
+
+  // Fail the task to finish test.
+  task->requestAbort();
+  ASSERT_TRUE(waitForTaskAborted(task.get()));
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, taskPauseTime) {
+  auto rowType = ROW({"c0", "c1"}, {INTEGER(), DOUBLE()});
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 32;
+  VectorFuzzer fuzzer(opts, pool_.get());
+  std::vector<RowVectorPtr> valueInputs;
+  for (int32_t i = 0; i < 4; ++i) {
+    valueInputs.push_back(fuzzer.fuzzRow(rowType));
+  }
+
+  const auto plan =
+      PlanBuilder()
+          .values(valueInputs)
+          .partitionedOutput({}, 1, std::vector<std::string>{"c0"})
+          .planFragment();
+
+  std::atomic_bool taskPauseWaitFlag{true};
+  folly::EventCount taskPauseWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Values::getOutput",
+      std::function<void(const exec::Values*)>([&](const exec::Values* values) {
+        if (taskPauseWaitFlag.exchange(false)) {
+          taskPauseWait.notifyAll();
+        }
+        // Inject some delay for task pause stats verification.
+        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // NOLINT
+      }));
+
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "taskPauseTime", 1UL << 30, exec::MemoryReclaimer::create());
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig{{}},
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      nullptr,
+      std::move(queryPool),
+      nullptr);
+  auto task = Task::create(
+      "task",
+      std::move(plan),
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kParallel);
+  task->start(4, 1);
+
+  // Wait for the task driver starts to run.
+  taskPauseWait.await([&]() { return !taskPauseWaitFlag.load(); });
+  // Pause the task
+  task->requestPause().wait();
+  // Inject some delay for task pause stats verification.
+  std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+  // Resume the task.
+  Task::resume(task);
+  // Inject some delay for task resume to run for a while.
+  std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+  // Fail the task to finish test.
+  task->requestAbort();
+  ASSERT_TRUE(waitForTaskAborted(task.get()));
+
+  auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.pipelineStats.size(), 1);
+  ASSERT_EQ(taskStats.pipelineStats[0].driverStats.size(), 1);
+  const auto& driverStats = taskStats.pipelineStats[0].driverStats[0];
+  const auto& totalPauseTime =
+      driverStats.runtimeStats.at(DriverStats::kTotalPauseTime);
+  ASSERT_EQ(totalPauseTime.count, 1);
+  ASSERT_GE(totalPauseTime.sum, 0);
+  const auto& totalOffThreadTime =
+      driverStats.runtimeStats.at(DriverStats::kTotalOffThreadTime);
+  ASSERT_EQ(totalOffThreadTime.count, 1);
+  ASSERT_GE(totalOffThreadTime.sum, 0);
+
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
+
+TEST_F(TaskTest, updateStatsWhileCloseOffThreadDriver) {
+  const auto data = makeRowVector({
+      makeFlatVector<int64_t>(50, folly::identity),
+      makeFlatVector<int64_t>(50, folly::identity),
+  });
+  const auto plan =
+      PlanBuilder()
+          .tableScan(asRowType(data->type()))
+          .partitionedOutput({}, 1, std::vector<std::string>{"c0"})
+          .planFragment();
+  auto task = Task::create(
+      "task",
+      std::move(plan),
+      0,
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
+  task->start(4, 1);
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  task->testingVisitDrivers(
+      [](Driver* driver) { VELOX_CHECK(!driver->isOnThread()); });
+  // Sleep a bit to make sure off thread time is not zero.
+  std::this_thread::sleep_for(std::chrono::milliseconds{2});
+  task->requestAbort();
+  ASSERT_TRUE(waitForTaskAborted(task.get()));
+  auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.pipelineStats.size(), 1);
+  ASSERT_EQ(taskStats.pipelineStats[0].driverStats.size(), 4);
+  const auto& driverStats = taskStats.pipelineStats[0].driverStats[0];
+  ASSERT_EQ(driverStats.runtimeStats.count(DriverStats::kTotalPauseTime), 0);
+  const auto& totalOffThreadTime =
+      driverStats.runtimeStats.at(DriverStats::kTotalOffThreadTime);
+  ASSERT_EQ(totalOffThreadTime.count, 1);
+  ASSERT_GE(totalOffThreadTime.sum, 0);
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, driverEnqueAfterFailedAndPausedTask) {
+  const auto data = makeRowVector({
+      makeFlatVector<int64_t>(50, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(50, [](auto row) { return row; }),
+  });
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto plan = PlanBuilder(planNodeIdGenerator)
+                        .values({data})
+                        .singleAggregation({"c0"}, {"sum(c1)"}, {})
+                        .planFragment();
+
+  std::atomic<bool> driverWaitFlag{true};
+  folly::EventCount driverWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::enter",
+      std::function<void(const velox::exec::ThreadState*)>(
+          ([&](const velox::exec::ThreadState* /*unused*/) {
+            driverWait.await([&]() { return !driverWaitFlag.load(); });
+          })));
+
+  auto task = Task::create(
+      "task",
+      std::move(plan),
+      0,
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
+  task->start(4, 1);
+
+  // Request pause.
+  auto pauseWait = task->requestPause();
+  // Fail the task.
+  task->requestAbort();
+
+  // Unblock drivers.
+  driverWaitFlag = false;
+  driverWait.notifyAll();
+  // Let driver threads run before resume.
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+  // Wait for task pause to complete.
+  pauseWait.wait();
+
+  // Resume the task and expect all drivers to close.
+  Task::resume(task);
+  ASSERT_TRUE(waitForTaskAborted(task.get()));
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, taskReclaimFailure) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), DOUBLE(), INTEGER()});
+  const auto inputVectors = makeVectors(rowType, 128, 256);
+  createDuckDbTable(inputVectors);
+
+  const std::string spillTableError{"spillTableError"};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Spiller",
+      std::function<void(Spiller*)>(
+          [&](Spiller* /*unused*/) { VELOX_FAIL(spillTableError); }));
+
+  TestScopedSpillInjection injection(100);
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .spillDirectory(spillDirectory->getPath())
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kAggregationSpillEnabled, true)
+          .maxDrivers(1)
+          .plan(PlanBuilder()
+                    .values(inputVectors)
+                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                    .planNode())
+          .assertResults(
+              "SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1"),
+      spillTableError);
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, taskDeletionPromise) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), DOUBLE(), INTEGER()});
+  const auto inputVectors = makeVectors(rowType, 128, 256);
+  createDuckDbTable(inputVectors);
+
+  std::atomic_bool terminateWaitFlag{true};
+  folly::EventCount terminateWait;
+  std::atomic<Task*> task{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::terminate",
+      std::function<void(Task*)>(([&](Task* _task) {
+        task = _task;
+        terminateWait.await([&]() { return !terminateWaitFlag.load(); });
+      })));
+
+  std::thread queryThread([&]() {
+    AssertQueryBuilder(duckDbQueryRunner_)
+        .maxDrivers(1)
+        .plan(PlanBuilder()
+                  .values(inputVectors)
+                  .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                  .planNode())
+        .assertResults("SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
+  });
+
+  while (task == nullptr) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+  // The task deletion future is not ful-filled as the task is not deleted.
+  ASSERT_FALSE(task.load()
+                   ->taskDeletionFuture()
+                   .within(std::chrono::microseconds(1'000'000))
+                   .wait()
+                   .hasValue());
+  auto deleteFuture = task.load()->taskDeletionFuture();
+  terminateWaitFlag = false;
+  terminateWait.notifyAll();
+  // The task deletion future is ful-filled after the wait.
+  ASSERT_TRUE(deleteFuture.wait().hasValue());
+  queryThread.join();
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, taskCancellation) {
+  const auto data = makeRowVector({
+      makeFlatVector<int64_t>(50, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(50, [](auto row) { return row; }),
+  });
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto plan = PlanBuilder(planNodeIdGenerator)
+                        .values({data})
+                        .singleAggregation({"c0"}, {"sum(c1)"}, {})
+                        .planFragment();
+
+  std::atomic<bool> driverWaitFlag{true};
+  folly::EventCount driverWait;
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::enter",
+      std::function<void(const velox::exec::ThreadState*)>(
+          ([&](const velox::exec::ThreadState* /*unused*/) {
+            driverWait.await([&]() { return !driverWaitFlag.load(); });
+          })));
+
+  auto task = Task::create(
+      "task",
+      std::move(plan),
+      0,
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
+  task->start(4, 1);
+  auto cancellationToken = task->getCancellationToken();
+  ASSERT_FALSE(cancellationToken.isCancellationRequested());
+
+  // Request pause.
+  auto pauseWait = task->requestPause();
+  // Fail the task.
+  task->requestAbort();
+  ASSERT_TRUE(cancellationToken.isCancellationRequested());
+
+  // Unblock drivers.
+  driverWaitFlag = false;
+  driverWait.notifyAll();
+  // Let driver threads run before resume.
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+  // Wait for task pause to complete.
+  pauseWait.wait();
+
+  // Resume the task and expect all drivers to close.
+  Task::resume(task);
+  ASSERT_TRUE(waitForTaskAborted(task.get()));
+  ASSERT_TRUE(cancellationToken.isCancellationRequested());
+
+  task.reset();
+  waitForAllTasksToBeDeleted();
+}
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/ThreadDebugInfoTest.cpp b/velox/exec/tests/ThreadDebugInfoTest.cpp
index 9d1c95439a925..3cecf27cb9230 100644
--- a/velox/exec/tests/ThreadDebugInfoTest.cpp
+++ b/velox/exec/tests/ThreadDebugInfoTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/common/process/ThreadDebugInfo.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -42,7 +43,6 @@ using namespace facebook::velox::exec::test;
 #endif
 #endif
 
-#if IS_BUILDING_WITH_ASAN() == 0
 // Ensure the test class name has "DeathTest" as a prefix to ensure this runs in
 // a single thread since the ASSERT_DEATH forks the process.
 class ThreadDebugInfoDeathTest : public OperatorTestBase {};
@@ -59,47 +59,63 @@ struct InduceSegFaultFunction {
 };
 } // namespace
 
-TEST_F(ThreadDebugInfoDeathTest, withinSeperateDriverThread) {
+DEBUG_ONLY_TEST_F(ThreadDebugInfoDeathTest, withinSeperateDriverThread) {
   auto vector = makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6})});
   registerFunction<InduceSegFaultFunction, int64_t, int64_t>({"segFault"});
   auto op = PlanBuilder().values({vector}).project({"segFault(c0)"}).planNode();
+#if IS_BUILDING_WITH_ASAN() == 0
   ASSERT_DEATH(
       (assertQuery(op, vector)),
       ".*Fatal signal handler. Query Id= TaskCursorQuery_0 Task Id= test_cursor 1.*");
+#endif
 }
 
-TEST_F(ThreadDebugInfoDeathTest, withinQueryCompilation) {
+DEBUG_ONLY_TEST_F(ThreadDebugInfoDeathTest, withinQueryCompilation) {
   auto vector = makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6})});
   registerFunction<InduceSegFaultFunction, int64_t, int64_t>({"segFault"});
   // Call expression with a constant to trigger the constant folding during
   // compilation.
   auto op = PlanBuilder().values({vector}).project({"segFault(1)"}).planNode();
 
+#if IS_BUILDING_WITH_ASAN() == 0
   ASSERT_DEATH(
       (assertQuery(op, vector)),
       ".*Fatal signal handler. Query Id= TaskCursorQuery_0 Task Id= test_cursor 1.*");
+#endif
 }
 
-TEST_F(ThreadDebugInfoDeathTest, withinTheCallingThread) {
+DEBUG_ONLY_TEST_F(ThreadDebugInfoDeathTest, withinTheCallingThread) {
   auto vector = makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6})});
   registerFunction<InduceSegFaultFunction, int64_t, int64_t>({"segFault"});
   auto plan =
       PlanBuilder().values({vector}).project({"segFault(c0)"}).planFragment();
 
-  auto queryCtx = std::make_shared<core::QueryCtx>(
+  auto queryCtx = core::QueryCtx::create(
       executor_.get(),
-      std::unordered_map<std::string, std::string>{},
-      std::unordered_map<std::string, std::shared_ptr<Config>>{},
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
       cache::AsyncDataCache::getInstance(),
       nullptr,
       nullptr,
       "TaskCursorQuery_0");
   auto task = exec::Task::create(
-      "single.execution.task.0", std::move(plan), 0, queryCtx);
+      "single.execution.task.0",
+      std::move(plan),
+      0,
+      queryCtx,
+      exec::Task::ExecutionMode::kSerial);
 
+#if IS_BUILDING_WITH_ASAN() == 0
   ASSERT_DEATH(
       (task->next()),
       ".*Fatal signal handler. Query Id= TaskCursorQuery_0 Task Id= single.execution.task.0.*");
+#endif
 }
 
+DEBUG_ONLY_TEST_F(ThreadDebugInfoDeathTest, noThreadContextSet) {
+  int* nullpointer = nullptr;
+#if IS_BUILDING_WITH_ASAN() == 0
+  ASSERT_DEATH((*nullpointer = 6), ".*ThreadDebugInfo object not found.*");
 #endif
+  folly::compiler_must_not_elide(nullpointer);
+}
diff --git a/velox/exec/tests/TopNRowNumberTest.cpp b/velox/exec/tests/TopNRowNumberTest.cpp
index 5d7d913157fcf..a7518accc7390 100644
--- a/velox/exec/tests/TopNRowNumberTest.cpp
+++ b/velox/exec/tests/TopNRowNumberTest.cpp
@@ -13,9 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox::exec::test;
 
@@ -23,7 +27,12 @@ namespace facebook::velox::exec {
 
 namespace {
 
-class TopNRowNumberTest : public OperatorTestBase {};
+class TopNRowNumberTest : public OperatorTestBase {
+ protected:
+  TopNRowNumberTest() {
+    filesystems::registerLocalFileSystem();
+  }
+};
 
 TEST_F(TopNRowNumberTest, basic) {
   auto data = makeRowVector({
@@ -83,41 +92,75 @@ TEST_F(TopNRowNumberTest, basic) {
 }
 
 TEST_F(TopNRowNumberTest, largeOutput) {
+  // Make 10 vectors. Use different types for partitioning key, sorting key and
+  // data. Use order of columns different from partitioning keys, followed by
+  // sorting keys, followed by data.
   const vector_size_t size = 10'000;
-  auto data = makeRowVector({
-      // Partitioning key.
-      makeFlatVector<int64_t>(size, [](auto row) { return row % 7; }),
-      // Sorting key.
-      makeFlatVector<int64_t>(size, [](auto row) { return (size - row) * 10; }),
-      // Data.
-      makeFlatVector<int64_t>(size, [](auto row) { return row; }),
-  });
+  auto data = split(
+      makeRowVector(
+          {"d", "p", "s"},
+          {
+              // Data.
+              makeFlatVector<float>(size, [](auto row) { return row; }),
+              // Partitioning key.
+              makeFlatVector<int16_t>(size, [](auto row) { return row % 7; }),
+              // Sorting key.
+              makeFlatVector<int32_t>(
+                  size, [](auto row) { return (size - row) * 10; }),
+          }),
+      10);
 
-  createDuckDbTable({data});
+  createDuckDbTable(data);
+
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
 
   auto testLimit = [&](auto limit) {
+    SCOPED_TRACE(fmt::format("Limit: {}", limit));
+    core::PlanNodeId topNRowNumberId;
     auto plan = PlanBuilder()
-                    .values({data})
-                    .topNRowNumber({"c0"}, {"c1"}, limit, true)
+                    .values(data)
+                    .topNRowNumber({"p"}, {"s"}, limit, true)
+                    .capturePlanNodeId(topNRowNumberId)
                     .planNode();
 
+    auto sql = fmt::format(
+        "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
+        " WHERE rn <= {}",
+        limit);
     AssertQueryBuilder(plan, duckDbQueryRunner_)
         .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
-        .assertResults(fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (partition by c0 order by c1) as rn FROM tmp) "
-            " WHERE rn <= {}",
-            limit));
+        .assertResults(sql);
+
+    // Spilling.
+    {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      auto task =
+          AssertQueryBuilder(plan, duckDbQueryRunner_)
+              .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+              .config(core::QueryConfig::kSpillEnabled, "true")
+              .config(core::QueryConfig::kTopNRowNumberSpillEnabled, "true")
+              .spillDirectory(spillDirectory->getPath())
+              .assertResults(sql);
+
+      auto taskStats = exec::toPlanStats(task->taskStats());
+      const auto& stats = taskStats.at(topNRowNumberId);
+
+      ASSERT_GT(stats.spilledBytes, 0);
+      ASSERT_GT(stats.spilledRows, 0);
+      ASSERT_GT(stats.spilledFiles, 0);
+      ASSERT_GT(stats.spilledPartitions, 0);
+    }
 
     // No partitioning keys.
     plan = PlanBuilder()
-               .values({data})
-               .topNRowNumber({}, {"c1"}, limit, true)
+               .values(data)
+               .topNRowNumber({}, {"s"}, limit, true)
                .planNode();
 
     AssertQueryBuilder(plan, duckDbQueryRunner_)
         .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
         .assertResults(fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (order by c1) as rn FROM tmp) "
+            "SELECT * FROM (SELECT *, row_number() over (order by s) as rn FROM tmp) "
             " WHERE rn <= {}",
             limit));
   };
@@ -131,39 +174,210 @@ TEST_F(TopNRowNumberTest, largeOutput) {
 
 TEST_F(TopNRowNumberTest, manyPartitions) {
   const vector_size_t size = 10'000;
-  auto data = makeRowVector({
-      // Partitioning key.
-      makeFlatVector<int64_t>(
-          size, [](auto row) { return row / 2; }, nullEvery(7)),
-      // Sorting key.
-      makeFlatVector<int64_t>(
-          size,
-          [](auto row) { return (size - row) * 10; },
-          [](auto row) { return row == 123; }),
-      // Data.
-      makeFlatVector<int64_t>(
-          size, [](auto row) { return row; }, nullEvery(11)),
-  });
+  auto data = split(
+      makeRowVector(
+          {"d", "s", "p"},
+          {
+              // Data.
+              makeFlatVector<int64_t>(
+                  size, [](auto row) { return row; }, nullEvery(11)),
+              // Sorting key.
+              makeFlatVector<int64_t>(
+                  size,
+                  [](auto row) { return (size - row) * 10; },
+                  [](auto row) { return row == 123; }),
+              // Partitioning key. Make sure to spread rows from the same
+              // partition across multiple batches to trigger de-dup logic when
+              // reading back spilled data.
+              makeFlatVector<int64_t>(
+                  size, [](auto row) { return row % 5'000; }, nullEvery(7)),
+          }),
+      10);
 
-  createDuckDbTable({data});
+  createDuckDbTable(data);
 
-  auto testLimit = [&](auto limit) {
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+
+  auto testLimit = [&](auto limit, size_t outputBatchBytes = 1024) {
+    SCOPED_TRACE(fmt::format("Limit: {}", limit));
+    core::PlanNodeId topNRowNumberId;
     auto plan = PlanBuilder()
-                    .values({data})
-                    .topNRowNumber({"c0"}, {"c1"}, limit, true)
+                    .values(data)
+                    .topNRowNumber({"p"}, {"s"}, limit, true)
+                    .capturePlanNodeId(topNRowNumberId)
                     .planNode();
 
-    assertQuery(
-        plan,
-        fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (partition by c0 order by c1) as rn FROM tmp) "
-            " WHERE rn <= {}",
-            limit));
+    auto sql = fmt::format(
+        "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
+        " WHERE rn <= {}",
+        limit);
+    assertQuery(plan, sql);
+
+    // Spilling.
+    {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      auto task =
+          AssertQueryBuilder(plan, duckDbQueryRunner_)
+              .config(
+                  core::QueryConfig::kPreferredOutputBatchBytes,
+                  fmt::format("{}", outputBatchBytes))
+              .config(core::QueryConfig::kSpillEnabled, "true")
+              .config(core::QueryConfig::kTopNRowNumberSpillEnabled, "true")
+              .spillDirectory(spillDirectory->getPath())
+              .assertResults(sql);
+
+      auto taskStats = exec::toPlanStats(task->taskStats());
+      const auto& stats = taskStats.at(topNRowNumberId);
+
+      ASSERT_GT(stats.spilledBytes, 0);
+      ASSERT_GT(stats.spilledRows, 0);
+      ASSERT_GT(stats.spilledFiles, 0);
+      ASSERT_GT(stats.spilledPartitions, 0);
+    }
   };
 
   testLimit(1);
   testLimit(2);
   testLimit(100);
+
+  testLimit(1, 1);
+}
+
+TEST_F(TopNRowNumberTest, abandonPartialEarly) {
+  auto data = makeRowVector(
+      {"p", "s"},
+      {
+          makeFlatVector<int64_t>(1'000, [](auto row) { return row % 10; }),
+          makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  core::PlanNodeId topNRowNumberId;
+  auto runPlan = [&](int32_t minRows) {
+    auto plan = PlanBuilder()
+                    .values(split(data, 10))
+                    .topNRowNumber({"p"}, {"s"}, 99, false)
+                    .capturePlanNodeId(topNRowNumberId)
+                    .topNRowNumber({"p"}, {"s"}, 99, true)
+                    .planNode();
+    auto task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .config(
+                core::QueryConfig::kAbandonPartialTopNRowNumberMinRows,
+                fmt::format("{}", minRows))
+            .config(core::QueryConfig::kAbandonPartialTopNRowNumberMinPct, "80")
+            .assertResults(
+                "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
+                "WHERE rn <= 99");
+
+    return exec::toPlanStats(task->taskStats());
+  };
+
+  // Partial operator is abandoned after 2 input batches.
+  {
+    auto taskStats = runPlan(100);
+    const auto& stats = taskStats.at(topNRowNumberId);
+    ASSERT_EQ(stats.outputRows, 1'000);
+    ASSERT_EQ(stats.customStats.at("abandonedPartial").sum, 1);
+  }
+
+  // Partial operator continues for all of input.
+  {
+    auto taskStats = runPlan(100'000);
+    const auto& stats = taskStats.at(topNRowNumberId);
+    ASSERT_EQ(stats.outputRows, 990);
+    ASSERT_EQ(stats.customStats.count("abandonedPartial"), 0);
+  }
+}
+
+TEST_F(TopNRowNumberTest, planNodeValidation) {
+  auto data = makeRowVector(
+      ROW({"a", "b", "c", "d", "e"},
+          {
+              BIGINT(),
+              BIGINT(),
+              BIGINT(),
+              BIGINT(),
+              BIGINT(),
+          }),
+      10);
+
+  auto plan = [&](const std::vector<std::string>& partitionKeys,
+                  const std::vector<std::string>& sortingKeys,
+                  int32_t limit = 10) {
+    PlanBuilder()
+        .values({data})
+        .topNRowNumber(partitionKeys, sortingKeys, limit, true)
+        .planNode();
+  };
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "a"}, {"b"}),
+      "Partitioning keys must be unique. Found duplicate key: a");
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "b"}, {"c", "d", "c"}),
+      "Sorting keys must be unique and not overlap with partitioning keys. Found duplicate key: c");
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "b"}, {"c", "b"}),
+      "Sorting keys must be unique and not overlap with partitioning keys. Found duplicate key: b");
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "b"}, {}), "Number of sorting keys must be greater than zero");
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "b"}, {"c"}, -5), "Limit must be greater than zero");
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "b"}, {"c"}, 0), "Limit must be greater than zero");
+}
+
+TEST_F(TopNRowNumberTest, maxSpillBytes) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
+  const auto vectors = createVectors(rowType, 1024, 15 << 20);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(vectors)
+                  .topNRowNumber({"c0"}, {"c1"}, 100, true)
+                  .planNode();
+  struct {
+    int32_t maxSpilledBytes;
+    bool expectedExceedLimit;
+    std::string debugString() const {
+      return fmt::format("maxSpilledBytes {}", maxSpilledBytes);
+    }
+  } testSettings[] = {{1 << 30, false}, {13 << 20, true}, {0, false}};
+
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    try {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(core::QueryConfig::kTopNRowNumberSpillEnabled, "true")
+          .config(
+              core::QueryConfig::kMaxSpillBytes,
+              std::to_string(testData.maxSpilledBytes))
+          .copyResults(pool_.get());
+      ASSERT_FALSE(testData.expectedExceedLimit);
+    } catch (const VeloxRuntimeError& e) {
+      ASSERT_TRUE(testData.expectedExceedLimit);
+      ASSERT_NE(
+          e.message().find(
+              "Query exceeded per-query local spill limit of 13.00MB"),
+          std::string::npos);
+      ASSERT_EQ(
+          e.errorCode(), facebook::velox::error_code::kSpillLimitExceeded);
+    }
+  }
 }
 
 } // namespace
diff --git a/velox/exec/tests/TopNTest.cpp b/velox/exec/tests/TopNTest.cpp
index ece6e897ea0d8..dc36a6c5a2b66 100644
--- a/velox/exec/tests/TopNTest.cpp
+++ b/velox/exec/tests/TopNTest.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
@@ -76,7 +77,7 @@ class TopNTest : public OperatorTestBase {
       const std::string& key1,
       const std::string& key2,
       int32_t limit) {
-    auto rowType = input[0]->type()->asRow();
+    auto& rowType = input[0]->type()->asRow();
     auto keyIndices = {rowType.getChildIdx(key1), rowType.getChildIdx(key2)};
 
     auto sortOrderSqls = getSortOrderSqls();
@@ -202,7 +203,10 @@ TEST_F(TopNTest, varchar) {
           return StringView::makeInline(std::to_string(row));
         },
         nullEvery(31));
-    vectors.push_back(makeRowVector({c0, c1, c2}));
+    auto c3 = makeFlatVector<std::string>(batchSize, [](vector_size_t row) {
+      return "non inline string " + std::to_string(row);
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2, c3}));
   }
   createDuckDbTable(vectors);
 
@@ -261,3 +265,43 @@ TEST_F(TopNTest, lowCardinality) {
 
   testTwoKeys(vectors, "c0", "c1", 200);
 }
+
+// All columns are sorting keys.
+TEST_F(TopNTest, onlyKeys) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 2; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize,
+        [](vector_size_t row) { return row % 20; },
+        nullEvery(31, 1));
+    auto c1 = makeFlatVector<int32_t>(
+        batchSize, [](vector_size_t row) { return row; }, nullEvery(17));
+    vectors.push_back(makeRowVector({c0, c1}));
+  }
+  createDuckDbTable(vectors);
+
+  testTwoKeys(vectors, "c0", "c1", 200);
+}
+
+TEST_F(TopNTest, planNodeValidation) {
+  auto data = makeRowVector(
+      ROW({"a", "b"},
+          {
+              BIGINT(),
+              BIGINT(),
+          }),
+      10);
+  auto plan = [&](const std::vector<std::string>& sortingKeys,
+                  int32_t count = 10) {
+    PlanBuilder().values({data}).topN(sortingKeys, count, false).planNode();
+  };
+
+  VELOX_ASSERT_THROW(plan({}), "TopN must specify sorting keys");
+  VELOX_ASSERT_THROW(
+      plan({"a"}, 0),
+      "TopN must specify greater than zero number of rows to keep");
+  VELOX_ASSERT_THROW(
+      plan({"a", "b", "a"}),
+      "TopN must specify unique sorting keys. Found duplicate key: a");
+}
diff --git a/velox/exec/tests/UnnestTest.cpp b/velox/exec/tests/UnnestTest.cpp
index 771e2520d8793..afaad1b3530f5 100644
--- a/velox/exec/tests/UnnestTest.cpp
+++ b/velox/exec/tests/UnnestTest.cpp
@@ -13,6 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
@@ -403,3 +405,56 @@ TEST_F(UnnestTest, allEmptyOrNullMaps) {
            .planNode();
   assertQueryReturnsEmptyResult(op);
 }
+
+TEST_F(UnnestTest, batchSize) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(10'000, [](auto row) { return row; }),
+  });
+
+  // Unnest 10K rows into 30K rows.
+  core::PlanNodeId unnestId;
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .project({"sequence(1, 3) as s"})
+                  .unnest({}, {"s"})
+                  .capturePlanNodeId(unnestId)
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(10'000 * 3, [](auto row) { return 1 + row % 3; }),
+  });
+
+  // 17 rows per output allows to unnest 6 input rows at a time.
+  {
+    auto task = AssertQueryBuilder(plan)
+                    .config(core::QueryConfig::kPreferredOutputBatchRows, "17")
+                    .assertResults({expected});
+    auto stats = exec::toPlanStats(task->taskStats());
+
+    ASSERT_EQ(30'000, stats.at(unnestId).outputRows);
+    ASSERT_EQ(1 + 10'000 / 6, stats.at(unnestId).outputVectors);
+  }
+
+  // 2 rows per output allows to unnest 1 input row at a time.
+  {
+    auto task = AssertQueryBuilder(plan)
+                    .config(core::QueryConfig::kPreferredOutputBatchRows, "2")
+                    .assertResults({expected});
+    auto stats = exec::toPlanStats(task->taskStats());
+
+    ASSERT_EQ(30'000, stats.at(unnestId).outputRows);
+    ASSERT_EQ(10'000, stats.at(unnestId).outputVectors);
+  }
+
+  // 100K rows per output allows to unnest all at once.
+  {
+    auto task =
+        AssertQueryBuilder(plan)
+            .config(core::QueryConfig::kPreferredOutputBatchRows, "100000")
+            .assertResults({expected});
+    auto stats = exec::toPlanStats(task->taskStats());
+
+    ASSERT_EQ(30'000, stats.at(unnestId).outputRows);
+    ASSERT_EQ(1, stats.at(unnestId).outputVectors);
+  }
+}
diff --git a/velox/exec/tests/ValuesTest.cpp b/velox/exec/tests/ValuesTest.cpp
index fc58e6351470a..368fb17bfb521 100644
--- a/velox/exec/tests/ValuesTest.cpp
+++ b/velox/exec/tests/ValuesTest.cpp
@@ -25,6 +25,12 @@ namespace facebook::velox::exec::test {
 
 class ValuesTest : public OperatorTestBase {
  protected:
+  void TearDown() override {
+    input_.reset();
+    input2_.reset();
+    OperatorTestBase::TearDown();
+  }
+
   // Sample row vectors.
   RowVectorPtr input_{makeRowVector({
       makeFlatVector<int32_t>({0, 1, 2, 3, 5}),
diff --git a/velox/exec/tests/VectorHasherTest.cpp b/velox/exec/tests/VectorHasherTest.cpp
index f1fce0842c27c..bceb6bf24febe 100644
--- a/velox/exec/tests/VectorHasherTest.cpp
+++ b/velox/exec/tests/VectorHasherTest.cpp
@@ -17,19 +17,22 @@
 #include <gtest/gtest.h>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/type/Type.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
+using namespace facebook::velox::test;
 
-class VectorHasherTest : public testing::Test {
+class VectorHasherTest : public testing::Test, public VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = facebook::velox::memory::addDefaultLeafMemoryPool();
     allRows_ = SelectivityVector(100);
 
     oddRows_ = VectorHasherTest::makeOddRows(100);
-    vectorMaker_ = std::make_unique<test::VectorMaker>(pool_.get());
   }
 
   static SelectivityVector makeOddRows(vector_size_t size) {
@@ -47,15 +50,15 @@ class VectorHasherTest : public testing::Test {
     auto isNullAt = withNulls ? test::VectorMaker::nullEvery(5) : nullptr;
 
     // values in the middle of the range
-    auto vector = vectorMaker_->flatVector<T>(
+    auto vector = makeFlatVector<T>(
         size, [](vector_size_t row) { return row % 17; }, isNullAt);
-    auto outOfRangeVector = vectorMaker_->flatVector<T>(
+    auto outOfRangeVector = makeFlatVector<T>(
         size, [](vector_size_t row) { return row % 19; }, isNullAt);
     testComputeValueIds(vector, outOfRangeVector);
     testComputeValueIds(vector, outOfRangeVector, 27);
 
     // values at the lower end of the range
-    vector = vectorMaker_->flatVector<T>(
+    vector = makeFlatVector<T>(
         size,
         [](vector_size_t row) {
           return std::numeric_limits<T>::min() + row % 17;
@@ -64,7 +67,7 @@ class VectorHasherTest : public testing::Test {
     testComputeValueIds(vector);
 
     // values at the upper end of the range
-    vector = vectorMaker_->flatVector<T>(
+    vector = makeFlatVector<T>(
         size,
         [](vector_size_t row) {
           return std::numeric_limits<T>::max() - 16 + row % 17;
@@ -134,8 +137,7 @@ class VectorHasherTest : public testing::Test {
   BufferPtr makeIndices(
       vector_size_t size,
       std::function<vector_size_t(vector_size_t)> indexAt) {
-    BufferPtr indices =
-        AlignedBuffer::allocate<vector_size_t>(size, pool_.get());
+    BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(size, pool());
     auto rawIndices = indices->asMutable<vector_size_t>();
     for (auto i = 0; i < size; i++) {
       rawIndices[i] = indexAt(i);
@@ -153,10 +155,8 @@ class VectorHasherTest : public testing::Test {
         base);
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_;
   SelectivityVector allRows_;
   SelectivityVector oddRows_;
-  std::unique_ptr<test::VectorMaker> vectorMaker_;
 };
 
 TEST_F(VectorHasherTest, flat) {
@@ -164,7 +164,7 @@ TEST_F(VectorHasherTest, flat) {
   ASSERT_EQ(hasher->channel(), 1);
   ASSERT_EQ(hasher->typeKind(), TypeKind::BIGINT);
 
-  auto vector = BaseVector::create(BIGINT(), 100, pool_.get());
+  auto vector = BaseVector::create(BIGINT(), 100, pool());
   auto flatVector = vector->asFlatVector<int64_t>();
   for (int32_t i = 0; i < 100; i++) {
     if (i % 5 == 0) {
@@ -224,9 +224,41 @@ TEST_F(VectorHasherTest, flat) {
   }
 }
 
+TEST_F(VectorHasherTest, nans) {
+  // Sanity check to ensure the NaNs are correctly hashed, that is, all NaNs are
+  // considered equal and therefore should have the same hash.
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+  folly::hasher<double> hasher;
+  static const auto kNaNHash = hasher(kNaN);
+  auto vectorHasher = exec::VectorHasher::create(DOUBLE(), 1);
+  ASSERT_EQ(vectorHasher->channel(), 1);
+  ASSERT_EQ(vectorHasher->typeKind(), TypeKind::DOUBLE);
+
+  // Using two different binary representations of NaN.
+  std::vector<double> inputValues = {1.0, -1.0, kNaN, kSNaN, 0.0, -0.0};
+
+  auto vector = BaseVector::create(DOUBLE(), inputValues.size(), pool());
+  auto flatVector = vector->asFlatVector<double>();
+  for (int32_t i = 0; i < inputValues.size(); i++) {
+    flatVector->set(i, inputValues[i]);
+  }
+
+  raw_vector<uint64_t> hashes(inputValues.size());
+  std::fill(hashes.begin(), hashes.end(), 0);
+  SelectivityVector allRows = SelectivityVector(inputValues.size());
+  vectorHasher->decode(*vector, allRows);
+  vectorHasher->hash(allRows, false, hashes);
+  std::vector<uint64_t> expected = {
+      hasher(1.0), hasher(-1.0), kNaNHash, kNaNHash, hasher(0.0), hasher(0.0)};
+  for (int32_t i = 0; i < inputValues.size(); i++) {
+    EXPECT_EQ(hashes[i], expected[i]) << "at " << i;
+  }
+}
+
 TEST_F(VectorHasherTest, nonNullConstant) {
   auto hasher = exec::VectorHasher::create(INTEGER(), 1);
-  auto vector = BaseVector::createConstant(INTEGER(), 123, 100, pool_.get());
+  auto vector = BaseVector::createConstant(INTEGER(), 123, 100, pool());
 
   auto hash = folly::hasher<int32_t>()(123);
 
@@ -247,7 +279,7 @@ TEST_F(VectorHasherTest, nonNullConstant) {
 
 TEST_F(VectorHasherTest, nullConstant) {
   auto hasher = exec::VectorHasher::create(INTEGER(), 1);
-  auto vector = BaseVector::createNullConstant(INTEGER(), 100, pool_.get());
+  auto vector = BaseVector::createNullConstant(INTEGER(), 100, pool());
 
   raw_vector<uint64_t> hashes(100);
   std::fill(hashes.begin(), hashes.end(), 0);
@@ -267,7 +299,7 @@ TEST_F(VectorHasherTest, nullConstant) {
 
 TEST_F(VectorHasherTest, unknown) {
   auto hasher = exec::VectorHasher::create(UNKNOWN(), 1);
-  auto vector = vectorMaker_->allNullFlatVector<UnknownValue>(100);
+  auto vector = makeAllNullFlatVector<UnknownValue>(100);
 
   // Test hashing without mixing.
   raw_vector<uint64_t> hashes(100);
@@ -298,14 +330,14 @@ TEST_F(VectorHasherTest, dictionary) {
   auto hasher = exec::VectorHasher::create(BIGINT(), 1);
 
   // 10 consecutive values: 3, 4, 5..12
-  auto vector = BaseVector::create(BIGINT(), 100, pool_.get());
+  auto vector = BaseVector::create(BIGINT(), 100, pool());
   auto flatVector = vector->asFlatVector<int64_t>();
   for (int32_t i = 0; i < 10; i++) {
     flatVector->set(i, i + 3);
   }
 
   // above sequence repeated 10 times: 3, 4, 5..12, 3, 4, 5..12,..
-  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(100, pool_.get());
+  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(100, pool());
   auto indicesPtr = indices->asMutable<vector_size_t>();
   for (int32_t i = 0; i < 100; i++) {
     indicesPtr[i] = i % 10;
@@ -336,7 +368,7 @@ TEST_F(VectorHasherTest, dictionary) {
 // consecutive ids of distinct values for the general case.
 TEST_F(VectorHasherTest, stringIds) {
   auto hasher = exec::VectorHasher::create(VARCHAR(), 1);
-  auto vector = BaseVector::create(VARCHAR(), 100, pool_.get());
+  auto vector = BaseVector::create(VARCHAR(), 100, pool());
   auto flatVector = vector->asFlatVector<StringView>();
   char zeros[9] = {};
   char digits[10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
@@ -427,7 +459,7 @@ TEST_F(VectorHasherTest, stringDistinctOverflow) {
   for (auto i = 0; i < 7; ++i) {
     auto& stringVec = strings[i];
     stringVec.resize(numRows);
-    batches.emplace_back(vectorMaker_->flatVector<StringView>(
+    batches.emplace_back(makeFlatVector<StringView>(
         numRows, [&i, &stringVec, numRows](vector_size_t row) {
           const auto num = numRows * i + row;
           stringVec[row] = (row != 0)
@@ -455,7 +487,7 @@ TEST_F(VectorHasherTest, stringDistinctOverflow) {
 }
 
 TEST_F(VectorHasherTest, integerIds) {
-  auto vector = BaseVector::create(BIGINT(), 100, pool_.get());
+  auto vector = BaseVector::create(BIGINT(), 100, pool());
   auto ints = vector->as<FlatVector<int64_t>>();
   static constexpr int64_t kMin = std::numeric_limits<int64_t>::min();
   ints->setNull(0, true);
@@ -519,7 +551,7 @@ TEST_F(VectorHasherTest, integerIds) {
 }
 
 TEST_F(VectorHasherTest, dateIds) {
-  auto vector = BaseVector::create(DATE(), 100, pool_.get());
+  auto vector = BaseVector::create(DATE(), 100, pool());
   auto* dates = vector->as<FlatVector<int32_t>>();
   static constexpr int32_t kMin = std::numeric_limits<int32_t>::min();
   dates->setNull(0, true);
@@ -574,7 +606,7 @@ TEST_F(VectorHasherTest, dateIds) {
 }
 
 TEST_F(VectorHasherTest, boolNoNulls) {
-  auto vector = BaseVector::create(BOOLEAN(), 100, pool_.get());
+  auto vector = BaseVector::create(BOOLEAN(), 100, pool());
   auto bools = vector->as<FlatVector<bool>>();
   bools->resize(3);
   bools->set(0, true);
@@ -600,7 +632,7 @@ TEST_F(VectorHasherTest, boolNoNulls) {
 }
 
 TEST_F(VectorHasherTest, boolWithNulls) {
-  auto vector = BaseVector::create(BOOLEAN(), 100, pool_.get());
+  auto vector = BaseVector::create(BOOLEAN(), 100, pool());
   auto bools = vector->as<FlatVector<bool>>();
   bools->resize(3);
   bools->setNull(0, true);
@@ -627,17 +659,17 @@ TEST_F(VectorHasherTest, boolWithNulls) {
 
 TEST_F(VectorHasherTest, merge) {
   constexpr vector_size_t kSize = 100;
-  auto vector = vectorMaker_->flatVector<int64_t>(
-      kSize, [](vector_size_t row) { return row; });
+  auto vector =
+      makeFlatVector<int64_t>(kSize, [](vector_size_t row) { return row; });
 
   VectorHasher hasher(BIGINT(), 0);
   SelectivityVector rows(kSize);
   raw_vector<uint64_t> hashes(kSize);
   hasher.decode(*vector, rows);
   hasher.computeValueIds(rows, hashes);
-  auto otherVector = vectorMaker_->flatVector<int64_t>(
-      kSize,
-      [](vector_size_t row) { return row < kSize / 2 ? row : row + 1000; });
+  auto otherVector = makeFlatVector<int64_t>(kSize, [](vector_size_t row) {
+    return row < kSize / 2 ? row : row + 1000;
+  });
   VectorHasher otherHasher(BIGINT(), 0);
   otherHasher.decode(*otherVector, rows);
   otherHasher.computeValueIds(rows, hashes);
@@ -707,10 +739,8 @@ TEST_F(VectorHasherTest, computeValueIdsTinyint) {
 
 TEST_F(VectorHasherTest, computeValueIdsBoolDictionary) {
   vector_size_t size = 1'000;
-  auto vector =
-      makeDictionary(size, vectorMaker_->flatVector<bool>(11, [](auto row) {
-        return row % 2 == 0;
-      }));
+  auto vector = makeDictionary(
+      size, makeFlatVector<bool>(11, [](auto row) { return row % 2 == 0; }));
 
   SelectivityVector allRows(size);
   auto hasher = exec::VectorHasher::create(BOOLEAN(), 0);
@@ -729,12 +759,12 @@ TEST_F(VectorHasherTest, computeValueIdsBoolDictionary) {
 }
 
 TEST_F(VectorHasherTest, computeValueIdsStrings) {
-  auto b0 = vectorMaker_->flatVector({"2021-02-02", "2021-02-01"});
-  auto b1 = vectorMaker_->flatVector({"red", "green"});
-  auto b2 = vectorMaker_->flatVector(
+  auto b0 = makeFlatVector<StringView>({"2021-02-02", "2021-02-01"});
+  auto b1 = makeFlatVector<StringView>({"red", "green"});
+  auto b2 = makeFlatVector<StringView>(
       {"apple", "orange", "grapefruit", "banana", "star fruit", "potato"});
   auto b3 =
-      vectorMaker_->flatVector({"pine", "birch", "elm", "maple", "chestnut"});
+      makeFlatVector<StringView>({"pine", "birch", "elm", "maple", "chestnut"});
   std::vector<VectorPtr> baseVectors = {b0, b1, b2, b3};
 
   vector_size_t size = 1'111;
@@ -797,6 +827,24 @@ TEST_F(VectorHasherTest, computeValueIdsStrings) {
   }
 
   ASSERT_LE(uniqueValues.size(), multiplier);
+
+  {
+    result[42] = 0xAAAAAAAAAAAAAAAA;
+    VectorHasher hasher(dictionaryVectors[0]->type(), 0);
+    SelectivityVector oneRow(size, false);
+    oneRow.setValid(42, true);
+    oneRow.updateBounds();
+    hasher.decode(*dictionaryVectors[0], oneRow);
+    ASSERT_FALSE(hasher.computeValueIds(oneRow, result));
+    uint64_t asRange;
+    uint64_t asDistinct;
+    hasher.cardinality(0, asRange, asDistinct);
+    ASSERT_EQ(asDistinct, 2);
+    hasher.enableValueIds(1, 0);
+    hasher.decode(*dictionaryVectors[0], oneRow);
+    ASSERT_TRUE(hasher.computeValueIds(oneRow, result));
+    ASSERT_EQ(result[42], 1);
+  }
 }
 
 namespace {
@@ -842,11 +890,10 @@ TEST_F(VectorHasherTest, endOfRange) {
 
   // Make samples of 8, 16 and 32 bit values such that when rounding, the
   // extended range will cover both ends of the type.
-  auto tinySample = vectorMaker_->flatVector(std::vector<int8_t>{-100, 110});
-  auto smallSample =
-      vectorMaker_->flatVector(std::vector<int16_t>{-30000, 31000});
+  auto tinySample = makeFlatVector(std::vector<int8_t>{-100, 110});
+  auto smallSample = makeFlatVector(std::vector<int16_t>{-30000, 31000});
   auto intSample =
-      vectorMaker_->flatVector(std::vector<int32_t>{-2001000000, 2000000000});
+      makeFlatVector(std::vector<int32_t>{-2001000000, 2000000000});
   auto tinyHasher = VectorHasher::create(TINYINT(), 0);
   auto smallHasher = VectorHasher::create(SMALLINT(), 1);
   auto intHasher = VectorHasher::create(INTEGER(), 2);
@@ -891,12 +938,10 @@ TEST_F(VectorHasherTest, endOfRange) {
 
   // Make test data. Each vector of 8, 16 and 32 bit values has the min, 0, max
   // of its type and null.
-  auto tinyData =
-      BaseVector::create<FlatVector<int8_t>>(TINYINT(), 0, pool_.get());
+  auto tinyData = BaseVector::create<FlatVector<int8_t>>(TINYINT(), 0, pool());
   auto smallData =
-      BaseVector::create<FlatVector<int16_t>>(SMALLINT(), 0, pool_.get());
-  auto intData =
-      BaseVector::create<FlatVector<int32_t>>(INTEGER(), 0, pool_.get());
+      BaseVector::create<FlatVector<int16_t>>(SMALLINT(), 0, pool());
+  auto intData = BaseVector::create<FlatVector<int32_t>>(INTEGER(), 0, pool());
   std::vector<Value> values = {
       Value::kNull, Value::kMin, Value::kZero, Value::kMax};
 
@@ -948,11 +993,10 @@ TEST_F(VectorHasherTest, simdRange) {
   using exec::VectorHasher;
 
   auto smallValues =
-      vectorMaker_->flatVector<int16_t>(kNumRows, [](auto i) { return i; });
-  auto intValues =
-      vectorMaker_->flatVector<int32_t>(kNumRows, [](auto i) { return i; });
+      makeFlatVector<int16_t>(kNumRows, [](auto i) { return i; });
+  auto intValues = makeFlatVector<int32_t>(kNumRows, [](auto i) { return i; });
   auto int64Values =
-      vectorMaker_->flatVector<int64_t>(kNumRows, [](auto i) { return i; });
+      makeFlatVector<int64_t>(kNumRows, [](auto i) { return i; });
 
   auto smallHasher = VectorHasher::create(SMALLINT(), 0);
   auto intHasher = VectorHasher::create(INTEGER(), 1);
@@ -1017,7 +1061,7 @@ TEST_F(VectorHasherTest, simdRange) {
 TEST_F(VectorHasherTest, typeMismatch) {
   auto hasher = VectorHasher::create(BIGINT(), 0);
 
-  auto data = vectorMaker_->flatVector<std::string>(
+  auto data = makeFlatVector<std::string>(
       {"a",
        "b"
        "c"});
diff --git a/velox/exec/tests/VeloxIn10MinDemo.cpp b/velox/exec/tests/VeloxIn10MinDemo.cpp
index 47cae22e11dac..f7ad1fd41abb6 100644
--- a/velox/exec/tests/VeloxIn10MinDemo.cpp
+++ b/velox/exec/tests/VeloxIn10MinDemo.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include <folly/init/Init.h>
+#include "velox/common/memory/Memory.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/connectors/tpch/TpchConnectorSplit.h"
 #include "velox/core/Expressions.h"
@@ -50,7 +51,10 @@ class VeloxIn10MinDemo : public VectorTestBase {
     auto tpchConnector =
         connector::getConnectorFactory(
             connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(kTpchConnectorId, nullptr);
+            ->newConnector(
+                kTpchConnectorId,
+                std::make_shared<config::ConfigBase>(
+                    std::unordered_map<std::string, std::string>()));
     connector::registerConnector(tpchConnector);
   }
 
@@ -100,7 +104,7 @@ class VeloxIn10MinDemo : public VectorTestBase {
       std::make_shared<folly::CPUThreadPoolExecutor>(
           std::thread::hardware_concurrency())};
   std::shared_ptr<core::QueryCtx> queryCtx_{
-      std::make_shared<core::QueryCtx>(executor_.get())};
+      core::QueryCtx::create(executor_.get())};
   std::unique_ptr<core::ExecCtx> execCtx_{
       std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
 };
@@ -233,7 +237,7 @@ void VeloxIn10MinDemo::run() {
   // nation table and print first 10 rows.
 
   plan = PlanBuilder()
-             .tableScan(
+             .tpchTableScan(
                  tpch::Table::TBL_NATION,
                  {"n_nationkey", "n_name"},
                  1 /*scaleFactor*/)
@@ -259,14 +263,14 @@ void VeloxIn10MinDemo::run() {
   core::PlanNodeId nationScanId;
   core::PlanNodeId regionScanId;
   plan = PlanBuilder(planNodeIdGenerator)
-             .tableScan(
+             .tpchTableScan(
                  tpch::Table::TBL_NATION, {"n_regionkey"}, 1 /*scaleFactor*/)
              .capturePlanNodeId(nationScanId)
              .hashJoin(
                  {"n_regionkey"},
                  {"r_regionkey"},
                  PlanBuilder(planNodeIdGenerator)
-                     .tableScan(
+                     .tpchTableScan(
                          tpch::Table::TBL_REGION,
                          {"r_regionkey", "r_name"},
                          1 /*scaleFactor*/)
@@ -290,7 +294,10 @@ void VeloxIn10MinDemo::run() {
 }
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
+
+  // Initializes the process-wide memory-manager with the default options.
+  memory::initializeMemoryManager({});
 
   VeloxIn10MinDemo demo;
   demo.run();
diff --git a/velox/exec/tests/WindowFunctionRegistryTest.cpp b/velox/exec/tests/WindowFunctionRegistryTest.cpp
index 60ec228be08b0..f78b18a050248 100644
--- a/velox/exec/tests/WindowFunctionRegistryTest.cpp
+++ b/velox/exec/tests/WindowFunctionRegistryTest.cpp
@@ -17,7 +17,7 @@
 
 #include "velox/exec/WindowFunction.h"
 #include "velox/expression/SignatureBinder.h"
-#include "velox/type/Type.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
 
 namespace facebook::velox::exec::test {
 
@@ -37,7 +37,11 @@ void registerWindowFunction(const std::string& name) {
           .build(),
       exec::FunctionSignatureBuilder().returnType("date").build(),
   };
-  exec::registerWindowFunction(name, std::move(signatures), nullptr);
+  exec::registerWindowFunction(
+      name,
+      std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
+      nullptr);
 }
 } // namespace
 
@@ -107,4 +111,27 @@ TEST_F(WindowFunctionRegistryTest, mixedCaseName) {
       "window_fUNC_alias", {BIGINT(), DOUBLE()}, BIGINT());
 }
 
+TEST_F(WindowFunctionRegistryTest, prefix) {
+  // Remove all functions and check for no entries.
+  exec::windowFunctions().clear();
+  EXPECT_EQ(0, exec::windowFunctions().size());
+
+  // Register without prefix and memorize function maps.
+  window::prestosql::registerAllWindowFunctions();
+  const auto windowFuncMapBase = exec::windowFunctions();
+
+  // Remove all functions and check for no entries.
+  exec::windowFunctions().clear();
+  EXPECT_EQ(0, exec::windowFunctions().size());
+
+  // Register with prefix and check all functions have the prefix.
+  const std::string prefix{"test.abc_schema."};
+  window::prestosql::registerAllWindowFunctions(prefix);
+  auto& windowFuncMap = exec::windowFunctions();
+  for (const auto& entry : windowFuncMap) {
+    EXPECT_EQ(prefix, entry.first.substr(0, prefix.size()));
+    EXPECT_EQ(1, windowFuncMapBase.count(entry.first.substr(prefix.size())));
+  }
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/WindowTest.cpp b/velox/exec/tests/WindowTest.cpp
new file mode 100644
index 0000000000000..21df032f58a4c
--- /dev/null
+++ b/velox/exec/tests/WindowTest.cpp
@@ -0,0 +1,491 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/RowsStreamingWindowBuild.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::exec {
+
+namespace {
+
+class WindowTest : public OperatorTestBase {
+ public:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    window::prestosql::registerAllWindowFunctions();
+    filesystems::registerLocalFileSystem();
+  }
+};
+
+TEST_F(WindowTest, spill) {
+  const vector_size_t size = 1'000;
+  auto data = makeRowVector(
+      {"d", "p", "s"},
+      {
+          // Payload.
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+          // Partition key.
+          makeFlatVector<int16_t>(size, [](auto row) { return row % 11; }),
+          // Sorting key.
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  core::PlanNodeId windowId;
+  auto plan = PlanBuilder()
+                  .values(split(data, 10))
+                  .window({"row_number() over (partition by p order by s)"})
+                  .capturePlanNodeId(windowId)
+                  .planNode();
+
+  auto spillDirectory = TempDirectoryPath::create();
+  TestScopedSpillInjection scopedSpillInjection(100);
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(core::QueryConfig::kWindowSpillEnabled, "true")
+          .spillDirectory(spillDirectory->getPath())
+          .assertResults(
+              "SELECT *, row_number() over (partition by p order by s) FROM tmp");
+
+  auto taskStats = exec::toPlanStats(task->taskStats());
+  const auto& stats = taskStats.at(windowId);
+
+  ASSERT_GT(stats.spilledBytes, 0);
+  ASSERT_GT(stats.spilledRows, 0);
+  ASSERT_GT(stats.spilledFiles, 0);
+  ASSERT_GT(stats.spilledPartitions, 0);
+}
+
+TEST_F(WindowTest, rowBasedStreamingWindowOOM) {
+  const vector_size_t size = 1'000'000;
+  auto data = makeRowVector(
+      {"d", "p", "s"},
+      {
+          // Payload.
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+          // Partition key.
+          makeFlatVector<int16_t>(size, [](auto row) { return row; }),
+          // Sorting key.
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  // Abstract the common values vector split.
+  auto valuesSplit = split(data, 10);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+      queryCtx->queryId(),
+      8'388'608 /* 8MB */,
+      exec::MemoryReclaimer::create()));
+
+  params.queryCtx = queryCtx;
+
+  auto testWindowBuild = [&](bool useStreamingWindow) {
+    if (useStreamingWindow) {
+      params.planNode =
+          PlanBuilder(planNodeIdGenerator)
+              .values(valuesSplit)
+              .streamingWindow(
+                  {"row_number() over (partition by p order by s)"})
+              .project({"d"})
+              .singleAggregation({}, {"sum(d)"})
+              .planNode();
+
+      readCursor(params, [](Task*) {});
+    } else {
+      params.planNode =
+          PlanBuilder(planNodeIdGenerator)
+              .values(valuesSplit)
+              .window({"row_number() over (partition by p order by s)"})
+              .project({"d"})
+              .singleAggregation({}, {"sum(d)"})
+              .planNode();
+
+      VELOX_ASSERT_THROW(
+          readCursor(params, [](Task*) {}),
+          "Exceeded memory pool capacity after attempt to grow capacity through arbitration.");
+    }
+  };
+  // RowStreamingWindow will not OOM.
+  testWindowBuild(true);
+  // SortBasedWindow will OOM.
+  testWindowBuild(false);
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, aggWindowResultMismatch) {
+  auto data = makeRowVector(
+      {"id", "order_num"},
+      {makeFlatVector<int64_t>(4500, [](auto row) { return row; }),
+       makeConstant(1, 4500)});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "sum(order_num) over (order by order_num DESC)"};
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .orderBy({"order_num"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(core::QueryConfig::kPreferredOutputBatchRows, "2")
+      .config(core::QueryConfig::kMaxOutputBatchRows, "2")
+      .assertResults(
+          "SELECT *, sum(order_num) over (order by order_num DESC) FROM tmp");
+  ASSERT_TRUE(isStreamCreated.load());
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, rankRowStreamingWindowBuild) {
+  auto data = makeRowVector(
+      {"c1"},
+      {makeFlatVector<int64_t>(std::vector<int64_t>{1, 1, 1, 1, 1, 2, 2})});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "rank() over (order by c1 rows unbounded preceding)"};
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .orderBy({"c1"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(core::QueryConfig::kPreferredOutputBatchRows, "2")
+      .config(core::QueryConfig::kMaxOutputBatchRows, "2")
+      .assertResults(
+          "SELECT *, rank() over (order by c1 rows unbounded preceding) FROM tmp");
+
+  ASSERT_TRUE(isStreamCreated.load());
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, valuesRowsStreamingWindowBuild) {
+  const vector_size_t size = 1'00;
+
+  auto data = makeRowVector(
+      {makeFlatVector<int32_t>(size, [](auto row) { return row % 5; }),
+       makeFlatVector<int32_t>(size, [](auto row) { return row % 50; }),
+       makeFlatVector<int64_t>(
+           size, [](auto row) { return row % 3 + 1; }, nullEvery(5)),
+       makeFlatVector<int32_t>(size, [](auto row) { return row % 40; }),
+       makeFlatVector<int32_t>(size, [](auto row) { return row; })});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "rank() over (partition by c0, c2 order by c1, c3)",
+      "dense_rank() over (partition by c0, c2 order by c1, c3)",
+      "row_number() over (partition by c0, c2 order by c1, c3)",
+      "sum(c4) over (partition by c0, c2 order by c1, c3)"};
+
+  auto plan = PlanBuilder()
+                  .values({split(data, 10)})
+                  .orderBy({"c0", "c2", "c1", "c3"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .assertResults(
+          "SELECT *, rank() over (partition by c0, c2 order by c1, c3), dense_rank() over (partition by c0, c2 order by c1, c3), row_number() over (partition by c0, c2 order by c1, c3), sum(c4) over (partition by c0, c2 order by c1, c3) FROM tmp");
+  ASSERT_TRUE(isStreamCreated.load());
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, aggregationWithNonDefaultFrame) {
+  const vector_size_t size = 1'00;
+
+  auto data = makeRowVector(
+      {makeFlatVector<int32_t>(size, [](auto row) { return row % 5; }),
+       makeFlatVector<int32_t>(size, [](auto row) { return row % 50; }),
+       makeFlatVector<int64_t>(
+           size, [](auto row) { return row % 3 + 1; }, nullEvery(5)),
+       makeFlatVector<int32_t>(size, [](auto row) { return row % 40; }),
+       makeFlatVector<int32_t>(size, [](auto row) { return row; })});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "sum(c4) over (partition by c0, c2 order by c1, c3 range between unbounded preceding and unbounded following)"};
+
+  auto plan = PlanBuilder()
+                  .values({split(data, 10)})
+                  .orderBy({"c0", "c2", "c1", "c3"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .assertResults(
+          "SELECT *, sum(c4) over (partition by c0, c2 order by c1, c3 range between unbounded preceding and unbounded following) FROM tmp");
+
+  ASSERT_FALSE(isStreamCreated.load());
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, nonRowsStreamingWindow) {
+  auto data = makeRowVector(
+      {"c1"},
+      {makeFlatVector<int64_t>(std::vector<int64_t>{1, 1, 1, 1, 1, 2, 2})});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "first_value(c1) over (order by c1 rows unbounded preceding)",
+      "nth_value(c1, 1) over (order by c1 rows unbounded preceding)"};
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .orderBy({"c1"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(core::QueryConfig::kPreferredOutputBatchRows, "2")
+      .config(core::QueryConfig::kMaxOutputBatchRows, "2")
+      .assertResults(
+          "SELECT *, first_value(c1) over (order by c1 rows unbounded preceding), nth_value(c1, 1) over (order by c1 rows unbounded preceding) FROM tmp");
+  ASSERT_FALSE(isStreamCreated.load());
+}
+
+TEST_F(WindowTest, missingFunctionSignature) {
+  auto input = {makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<std::string>({"A", "B", "C"}),
+      makeFlatVector<int64_t>({10, 20, 30}),
+  })};
+
+  auto runWindow = [&](const core::CallTypedExprPtr& callExpr) {
+    core::WindowNode::Frame frame{
+        core::WindowNode::WindowType::kRows,
+        core::WindowNode::BoundType::kUnboundedPreceding,
+        nullptr,
+        core::WindowNode::BoundType::kUnboundedFollowing,
+        nullptr};
+
+    core::WindowNode::Function windowFunction{callExpr, frame, false};
+
+    CursorParameters params;
+    params.planNode =
+        PlanBuilder()
+            .values(input)
+            .addNode([&](auto nodeId, auto source) -> core::PlanNodePtr {
+              return std::make_shared<core::WindowNode>(
+                  nodeId,
+                  std::vector<core::FieldAccessTypedExprPtr>{
+                      std::make_shared<core::FieldAccessTypedExpr>(
+                          BIGINT(), "c0")},
+                  std::vector<core::FieldAccessTypedExprPtr>{}, // sortingKeys
+                  std::vector<core::SortOrder>{}, // sortingOrders
+                  std::vector<std::string>{"w"},
+                  std::vector<core::WindowNode::Function>{windowFunction},
+                  false,
+                  source);
+            })
+            .planNode();
+
+    readCursor(params, [](auto*) {});
+  };
+
+  auto callExpr = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1")},
+      "sum");
+
+  VELOX_ASSERT_THROW(
+      runWindow(callExpr),
+      "Window function signature is not supported: sum(VARCHAR). Supported signatures:");
+
+  callExpr = std::make_shared<core::CallTypedExpr>(
+      VARCHAR(),
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c2")},
+      "sum");
+
+  VELOX_ASSERT_THROW(
+      runWindow(callExpr),
+      "Unexpected return type for window function sum(BIGINT). Expected BIGINT. Got VARCHAR.");
+}
+
+TEST_F(WindowTest, duplicateOrOverlappingKeys) {
+  auto data = makeRowVector(
+      ROW({"a", "b", "c", "d", "e"},
+          {
+              BIGINT(),
+              BIGINT(),
+              BIGINT(),
+              BIGINT(),
+              BIGINT(),
+          }),
+      10);
+
+  auto plan = [&](const std::vector<std::string>& partitionKeys,
+                  const std::vector<std::string>& sortingKeys) {
+    std::ostringstream sql;
+    sql << "row_number() over (";
+    if (!partitionKeys.empty()) {
+      sql << " partition by ";
+      sql << folly::join(", ", partitionKeys);
+    }
+    if (!sortingKeys.empty()) {
+      sql << " order by ";
+      sql << folly::join(", ", sortingKeys);
+    }
+    sql << ")";
+
+    PlanBuilder().values({data}).window({sql.str()}).planNode();
+  };
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "a"}, {"b"}),
+      "Partitioning keys must be unique. Found duplicate key: a");
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "b"}, {"c", "d", "c"}),
+      "Sorting keys must be unique and not overlap with partitioning keys. Found duplicate key: c");
+
+  VELOX_ASSERT_THROW(
+      plan({"a", "b"}, {"c", "b"}),
+      "Sorting keys must be unique and not overlap with partitioning keys. Found duplicate key: b");
+}
+
+TEST_F(WindowTest, nagativeFrameArg) {
+  const vector_size_t size = 1'000;
+
+  auto sizeAt = [](vector_size_t row) { return row % 5; };
+  auto keyAt = [](vector_size_t row) { return row % 11; };
+  auto valueAt = [](vector_size_t row) { return row % 13; };
+  auto keys = makeArrayVector<float>(size, sizeAt, keyAt);
+  auto data = makeRowVector(
+      {"c0", "c1", "p0", "p1", "k0", "row_number"},
+      {
+          // Payload.
+          makeFlatVector<float>(size, [](auto row) { return row; }),
+          makeFlatVector<float>(size, [](auto row) { return row; }),
+          // Partition key.
+          keys,
+          makeFlatVector<std::string>(
+              size, [](auto row) { return fmt::format("{}", row + 20); }),
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+          // Sorting key.
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  struct {
+    std::string fragmentStart;
+    std::string fragmentEnd;
+
+    std::string debugString() const {
+      if (fragmentStart[0] == '-') {
+        return fmt::format(
+            "Window frame {} offset must not be negative", fragmentStart);
+      } else {
+        return fmt::format(
+            "Window frame {} offset must not be negative", fragmentEnd);
+      }
+    }
+  } testSettings[] = {
+      {"k0", "-1"}, // Negative end
+      {"-1", "k0"}, // Negative start
+      {"-1", "-3"} // Negative start, negative end
+  };
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto& startOffset = testData.fragmentStart;
+    const auto& endOffset = testData.fragmentEnd;
+    auto plan =
+        PlanBuilder()
+            .values(split(data, 10))
+            .window({fmt::format(
+                "regr_count(c0, c1) over (partition by p0, p1 order by row_number ROWS between {} PRECEDING and {} FOLLOWING)",
+                startOffset,
+                endOffset)})
+            .planNode();
+    VELOX_ASSERT_USER_THROW(
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .assertResults(fmt::format(
+                "SELECT *, regr_count(c0, c1) over (partition by p0, p1 order by row_number  ROWS between {} PRECEDING and {} FOLLOWING) from tmp",
+                startOffset,
+                endOffset)),
+        testData.debugString());
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/WriterFuzzerUtilTest.cpp b/velox/exec/tests/WriterFuzzerUtilTest.cpp
new file mode 100644
index 0000000000000..d0b765dd8133a
--- /dev/null
+++ b/velox/exec/tests/WriterFuzzerUtilTest.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/fuzzer/WriterFuzzer.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec::test;
+
+TEST(WriterFuzzerUtilTest, listFolders) {
+  facebook::velox::filesystems::registerLocalFileSystem();
+  const auto tempFolder = exec::test::TempDirectoryPath::create();
+  // Directory layout:
+  // First layer:   dir1/   dir2/      dir3/    a
+  // Second layer:  b       dir2_1/
+  const auto dir1 = fmt::format("{}/dir1", tempFolder->getPath());
+  const auto dir2 = fmt::format("{}/dir2", tempFolder->getPath());
+  const auto dir2_1 = fmt::format("{}/dir2/dir2_1", tempFolder->getPath());
+  const auto dir3 = fmt::format("{}/dir3", tempFolder->getPath());
+  const auto a = fmt::format("{}/a", tempFolder->getPath());
+  const auto b = fmt::format("{}/dir1/b", tempFolder->getPath());
+
+  auto localFs = filesystems::getFileSystem(a, nullptr);
+  {
+    localFs->mkdir(dir1);
+    localFs->mkdir(dir2);
+    localFs->mkdir(dir2_1);
+    localFs->mkdir(dir3);
+    auto writeFile = localFs->openFileForWrite(a);
+    writeFile = localFs->openFileForWrite(b);
+  }
+  auto folder = listFolders(std::string_view(tempFolder->getPath()));
+  std::sort(folder.begin(), folder.end());
+  ASSERT_EQ(folder, std::vector<std::string>({dir1, dir2, dir2_1, dir3}));
+
+  localFs->remove(b);
+  localFs->remove(dir1);
+  folder = listFolders(std::string_view(tempFolder->getPath()));
+  std::sort(folder.begin(), folder.end());
+  ASSERT_EQ(folder, std::vector<std::string>({dir2, dir2_1, dir3}));
+
+  localFs->remove(dir2_1);
+  localFs->remove(dir2);
+  localFs->remove(dir3);
+  ASSERT_TRUE(listFolders(std::string_view(tempFolder->getPath())).empty());
+}
diff --git a/velox/exec/tests/utils/AggregationFuzzer.cpp b/velox/exec/tests/utils/AggregationFuzzer.cpp
deleted file mode 100644
index e1c969d86883f..0000000000000
--- a/velox/exec/tests/utils/AggregationFuzzer.cpp
+++ /dev/null
@@ -1,1410 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/exec/tests/utils/AggregationFuzzer.h"
-#include <boost/random/uniform_int_distribution.hpp>
-#include "velox/common/base/Fs.h"
-
-#include "velox/common/file/FileSystems.h"
-#include "velox/connectors/hive/HiveConnector.h"
-#include "velox/connectors/hive/HiveConnectorSplit.h"
-#include "velox/connectors/hive/TableHandle.h"
-#include "velox/dwio/dwrf/reader/DwrfReader.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
-
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/expression/SignatureBinder.h"
-#include "velox/expression/tests/ArgumentTypeFuzzer.h"
-
-#include "velox/exec/PartitionFunction.h"
-#include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/expression/tests/FuzzerToolkit.h"
-#include "velox/vector/VectorSaver.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
-
-DEFINE_int32(steps, 10, "Number of plans to generate and execute.");
-
-DEFINE_int32(
-    duration_sec,
-    0,
-    "For how long it should run (in seconds). If zero, "
-    "it executes exactly --steps iterations and exits.");
-
-DEFINE_int32(
-    batch_size,
-    100,
-    "The number of elements on each generated vector.");
-
-DEFINE_int32(num_batches, 10, "The number of generated vectors.");
-
-DEFINE_int32(
-    max_num_varargs,
-    5,
-    "The maximum number of variadic arguments fuzzer will generate for "
-    "functions that accept variadic arguments. Fuzzer will generate up to "
-    "max_num_varargs arguments for the variadic list in addition to the "
-    "required arguments by the function.");
-
-DEFINE_double(
-    null_ratio,
-    0.1,
-    "Chance of adding a null constant to the plan, or null value in a vector "
-    "(expressed as double from 0 to 1).");
-
-DEFINE_string(
-    repro_persist_path,
-    "",
-    "Directory path for persistence of data and SQL when fuzzer fails for "
-    "future reproduction. Empty string disables this feature.");
-
-DEFINE_bool(
-    enable_window_reference_verification,
-    false,
-    "When true, the results of the window aggregation will be compared to reference DB results");
-
-DEFINE_bool(
-    persist_and_run_once,
-    false,
-    "Persist repro info before evaluation and only run one iteration. "
-    "This is to rerun with the seed number and persist repro info upon a "
-    "crash failure. Only effective if repro_persist_path is set.");
-
-using facebook::velox::test::CallableSignature;
-using facebook::velox::test::SignatureTemplate;
-
-namespace facebook::velox::exec::test {
-namespace {
-
-class AggregationFuzzer {
- public:
-  AggregationFuzzer(
-      AggregateFunctionSignatureMap signatureMap,
-      size_t seed,
-      const std::unordered_map<std::string, std::string>&
-          customVerificationFunctions,
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
-      const std::unordered_map<std::string, std::string>& queryConfigs,
-      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner);
-
-  struct PlanWithSplits {
-    core::PlanNodePtr plan;
-    std::vector<exec::Split> splits;
-  };
-
-  void go();
-  void go(const std::string& planPath);
-
- private:
-  static inline const std::string kHiveConnectorId = "test-hive";
-
-  static exec::Split makeSplit(const std::string& filePath);
-
-  PlanWithSplits deserialize(const folly::dynamic& obj);
-
-  struct Stats {
-    // Names of functions that were tested.
-    std::unordered_set<std::string> functionNames;
-
-    // Number of iterations using masked aggregation.
-    size_t numMask{0};
-
-    // Number of iterations using group-by aggregation.
-    size_t numGroupBy{0};
-
-    // Number of iterations using global aggregation.
-    size_t numGlobal{0};
-
-    // Number of iterations using distinct aggregation.
-    size_t numDistinct{0};
-
-    // Number of iterations using window expressions.
-    size_t numWindow{0};
-
-    // Number of iterations where results were verified against reference DB,
-    size_t numVerified{0};
-
-    // Number of iterations where results verification was skipped because
-    // function results are non-determinisic.
-    size_t numVerificationSkipped{0};
-
-    // Number of iterations where results verification was skipped because
-    // reference DB doesn't support the function.
-    size_t numVerificationNotSupported{0};
-
-    // Number of iterations where results verification was skipped because
-    // reference DB failed to execute the query.
-    size_t numReferenceQueryFailed{0};
-
-    // Number of iterations where aggregation failed.
-    size_t numFailed{0};
-
-    void print(size_t numIterations) const;
-  };
-
-  static VectorFuzzer::Options getFuzzerOptions(
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision) {
-    VectorFuzzer::Options opts;
-    opts.vectorSize = FLAGS_batch_size;
-    opts.stringVariableLength = true;
-    opts.stringLength = 100;
-    opts.nullRatio = FLAGS_null_ratio;
-    opts.timestampPrecision = timestampPrecision;
-    return opts;
-  }
-
-  void seed(size_t seed) {
-    currentSeed_ = seed;
-    vectorFuzzer_.reSeed(seed);
-    rng_.seed(currentSeed_);
-  }
-
-  void reSeed() {
-    seed(rng_());
-  }
-
-  // Generate at least one and up to 5 scalar columns to be used as grouping,
-  // partition or sorting keys.
-  // Column names are generated using template '<prefix>N', where N is
-  // zero-based ordinal number of the column.
-  std::vector<std::string> generateKeys(
-      const std::string& prefix,
-      std::vector<std::string>& names,
-      std::vector<TypePtr>& types);
-
-  CallableSignature pickSignature();
-
-  std::vector<RowVectorPtr> generateInputData(
-      std::vector<std::string> names,
-      std::vector<TypePtr> types);
-
-  // Generate a RowVector of the given types of children with an additional
-  // child named "row_number" of BIGINT row numbers that differentiates every
-  // row. Row numbers start from 0. This additional input vector is needed for
-  // result verification of window aggregations.
-  std::vector<RowVectorPtr> generateInputDataWithRowNumber(
-      std::vector<std::string> names,
-      std::vector<TypePtr> types);
-
-  void verifyWindow(
-      const std::vector<std::string>& partitionKeys,
-      const std::vector<std::string>& sortingKeys,
-      const std::vector<std::string>& aggregates,
-      const std::vector<RowVectorPtr>& input,
-      bool customVerification,
-      bool enableWindowVerification);
-
-  void verifyAggregation(
-      const std::vector<std::string>& groupingKeys,
-      const std::vector<std::string>& aggregates,
-      const std::vector<std::string>& masks,
-      const std::vector<RowVectorPtr>& input,
-      bool customVerification,
-      const std::vector<std::string>& projections);
-
-  void verifyAggregation(const std::vector<PlanWithSplits>& plans);
-
-  std::optional<MaterializedRowMultiset> computeReferenceResults(
-      const core::PlanNodePtr& plan,
-      const std::vector<RowVectorPtr>& input);
-
-  velox::test::ResultOrError execute(
-      const core::PlanNodePtr& plan,
-      const std::vector<exec::Split>& splits = {},
-      bool injectSpill = false,
-      bool abandonPartial = false);
-
-  static bool hasPartialGroupBy(const core::PlanNodePtr& plan) {
-    auto partialAgg = core::PlanNode::findFirstNode(
-        plan.get(), [](const core::PlanNode* node) {
-          if (auto aggregation =
-                  dynamic_cast<const core::AggregationNode*>(node)) {
-            return aggregation->step() ==
-                core::AggregationNode::Step::kPartial &&
-                !aggregation->groupingKeys().empty();
-          }
-
-          return false;
-        });
-    return partialAgg != nullptr;
-  }
-
-  void testPlans(
-      const std::vector<PlanWithSplits>& plans,
-      bool verifyResults,
-      const velox::test::ResultOrError& expected) {
-    for (auto i = 0; i < plans.size(); ++i) {
-      const auto& planWithSplits = plans[i];
-
-      LOG(INFO) << "Testing plan #" << i;
-      testPlan(
-          planWithSplits,
-          false /*injectSpill*/,
-          false /*abandonPartial*/,
-          verifyResults,
-          expected);
-
-      LOG(INFO) << "Testing plan #" << i << " with spilling";
-      testPlan(
-          planWithSplits,
-          true /*injectSpill*/,
-          false /*abandonPartial*/,
-          verifyResults,
-          expected);
-
-      if (hasPartialGroupBy(planWithSplits.plan)) {
-        LOG(INFO) << "Testing plan #" << i
-                  << " with forced abandon-partial-aggregation";
-        testPlan(
-            planWithSplits,
-            false /*injectSpill*/,
-            true /*abandonPartial*/,
-            verifyResults,
-            expected);
-      }
-    }
-  }
-
-  void testPlan(
-      const PlanWithSplits& planWithSplits,
-      bool injectSpill,
-      bool abandonPartial,
-      bool verifyResults,
-      const velox::test::ResultOrError& expected);
-
-  const std::unordered_map<std::string, std::string>
-      customVerificationFunctions_;
-  const std::unordered_map<std::string, std::string> queryConfigs_;
-  const bool persistAndRunOnce_;
-  const std::string reproPersistPath_;
-
-  std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner_;
-
-  std::vector<CallableSignature> signatures_;
-  std::vector<SignatureTemplate> signatureTemplates_;
-
-  FuzzerGenerator rng_;
-  size_t currentSeed_{0};
-
-  std::shared_ptr<memory::MemoryPool> rootPool_{
-      memory::defaultMemoryManager().addRootPool()};
-  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild("leaf")};
-  VectorFuzzer vectorFuzzer_;
-
-  Stats stats_;
-};
-} // namespace
-
-void aggregateFuzzer(
-    AggregateFunctionSignatureMap signatureMap,
-    size_t seed,
-    const std::unordered_map<std::string, std::string>&
-        customVerificationFunctions,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
-    const std::unordered_map<std::string, std::string>& queryConfigs,
-    const std::optional<std::string>& planPath,
-    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
-  auto aggregationFuzzer = AggregationFuzzer(
-      std::move(signatureMap),
-      seed,
-      customVerificationFunctions,
-      timestampPrecision,
-      queryConfigs,
-      std::move(referenceQueryRunner));
-  planPath.has_value() ? aggregationFuzzer.go(planPath.value())
-                       : aggregationFuzzer.go();
-}
-
-namespace {
-
-std::string printStat(size_t n, size_t total) {
-  return fmt::format("{} ({:.2f}%)", n, (double)n / total * 100);
-}
-
-void printStats(
-    size_t numFunctions,
-    size_t numSignatures,
-    size_t numSupportedFunctions,
-    size_t numSupportedSignatures) {
-  LOG(INFO) << fmt::format(
-      "Total functions: {} ({} signatures)", numFunctions, numSignatures);
-  LOG(INFO) << "Functions with at least one supported signature: "
-            << printStat(numSupportedFunctions, numFunctions);
-
-  size_t numNotSupportedFunctions = numFunctions - numSupportedFunctions;
-  LOG(INFO) << "Functions with no supported signature: "
-            << printStat(numNotSupportedFunctions, numFunctions);
-  LOG(INFO) << "Supported function signatures: "
-            << printStat(numSupportedSignatures, numSignatures);
-
-  size_t numNotSupportedSignatures = numSignatures - numSupportedSignatures;
-  LOG(INFO) << "Unsupported function signatures: "
-            << printStat(numNotSupportedSignatures, numSignatures);
-}
-
-AggregationFuzzer::AggregationFuzzer(
-    AggregateFunctionSignatureMap signatureMap,
-    size_t initialSeed,
-    const std::unordered_map<std::string, std::string>&
-        customVerificationFunctions,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
-    const std::unordered_map<std::string, std::string>& queryConfigs,
-    std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner)
-    : customVerificationFunctions_{customVerificationFunctions},
-      queryConfigs_{queryConfigs},
-      persistAndRunOnce_{FLAGS_persist_and_run_once},
-      reproPersistPath_{FLAGS_repro_persist_path},
-      referenceQueryRunner_{std::move(referenceQueryRunner)},
-      vectorFuzzer_{getFuzzerOptions(timestampPrecision), pool_.get()} {
-  filesystems::registerLocalFileSystem();
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(kHiveConnectorId, nullptr);
-  connector::registerConnector(hiveConnector);
-
-  seed(initialSeed);
-  VELOX_CHECK(!signatureMap.empty(), "No function signatures available.");
-
-  if (persistAndRunOnce_ && reproPersistPath_.empty()) {
-    std::cout
-        << "--repro_persist_path must be specified if --persist_and_run_once is specified"
-        << std::endl;
-    exit(1);
-  }
-
-  size_t numFunctions = 0;
-  size_t numSignatures = 0;
-  size_t numSupportedFunctions = 0;
-  size_t numSupportedSignatures = 0;
-
-  for (auto& [name, signatures] : signatureMap) {
-    ++numFunctions;
-    bool hasSupportedSignature = false;
-    for (auto& signature : signatures) {
-      ++numSignatures;
-
-      if (signature->variableArity()) {
-        LOG(WARNING) << "Skipping variadic function signature: " << name
-                     << signature->toString();
-        continue;
-      }
-
-      if (!signature->variables().empty()) {
-        bool skip = false;
-        std::unordered_set<std::string> typeVariables;
-        for (auto& [name, variable] : signature->variables()) {
-          if (variable.isIntegerParameter()) {
-            LOG(WARNING) << "Skipping generic function signature: " << name
-                         << signature->toString();
-            skip = true;
-            break;
-          }
-
-          typeVariables.insert(name);
-        }
-        if (skip) {
-          continue;
-        }
-
-        signatureTemplates_.push_back(
-            {name, signature.get(), std::move(typeVariables)});
-      } else {
-        CallableSignature callable{
-            .name = name,
-            .args = {},
-            .returnType = SignatureBinder::tryResolveType(
-                signature->returnType(), {}, {}),
-            .constantArgs = {}};
-        VELOX_CHECK_NOT_NULL(callable.returnType);
-
-        // Process each argument and figure out its type.
-        for (const auto& arg : signature->argumentTypes()) {
-          auto resolvedType = SignatureBinder::tryResolveType(arg, {}, {});
-          VELOX_CHECK_NOT_NULL(resolvedType);
-
-          // SignatureBinder::tryResolveType produces ROW types with empty field
-          // names. These won't work with TableScan.
-          if (resolvedType->isRow()) {
-            std::vector<std::string> names;
-            for (auto i = 0; i < resolvedType->size(); ++i) {
-              names.push_back(fmt::format("field{}", i));
-            }
-
-            std::vector<TypePtr> types = resolvedType->asRow().children();
-
-            resolvedType = ROW(std::move(names), std::move(types));
-          }
-
-          callable.args.emplace_back(resolvedType);
-        }
-
-        signatures_.emplace_back(callable);
-      }
-
-      ++numSupportedSignatures;
-      hasSupportedSignature = true;
-    }
-    if (hasSupportedSignature) {
-      ++numSupportedFunctions;
-    }
-  }
-
-  printStats(
-      numFunctions,
-      numSignatures,
-      numSupportedFunctions,
-      numSupportedSignatures);
-
-  sortCallableSignatures(signatures_);
-  sortSignatureTemplates(signatureTemplates_);
-}
-
-template <typename T>
-bool isDone(size_t i, T startTime) {
-  if (FLAGS_duration_sec > 0) {
-    std::chrono::duration<double> elapsed =
-        std::chrono::system_clock::now() - startTime;
-    return elapsed.count() >= FLAGS_duration_sec;
-  }
-  return i >= FLAGS_steps;
-}
-
-std::string makeFunctionCall(
-    const std::string& name,
-    const std::vector<std::string>& argNames) {
-  std::ostringstream call;
-  call << name << "(";
-  for (auto i = 0; i < argNames.size(); ++i) {
-    if (i > 0) {
-      call << ", ";
-    }
-    call << argNames[i];
-  }
-  call << ")";
-
-  return call.str();
-}
-
-std::vector<std::string> makeNames(size_t n) {
-  std::vector<std::string> names;
-  for (auto i = 0; i < n; ++i) {
-    names.push_back(fmt::format("c{}", i));
-  }
-  return names;
-}
-
-folly::dynamic serialize(
-    const AggregationFuzzer::PlanWithSplits& planWithSplits,
-    const std::string& dirPath,
-    std::unordered_map<std::string, std::string>& filePaths) {
-  folly::dynamic obj = folly::dynamic::object();
-  obj["plan"] = planWithSplits.plan->serialize();
-  if (planWithSplits.splits.empty()) {
-    return obj;
-  }
-
-  folly::dynamic jsonSplits = folly::dynamic::array();
-  jsonSplits.reserve(planWithSplits.splits.size());
-  for (const auto& split : planWithSplits.splits) {
-    const auto filePath =
-        std::dynamic_pointer_cast<connector::hive::HiveConnectorSplit>(
-            split.connectorSplit)
-            ->filePath;
-    if (filePaths.count(filePath) == 0) {
-      const auto newFilePath = fmt::format("{}/{}", dirPath, filePaths.size());
-      fs::copy(filePath, newFilePath);
-      filePaths.insert({filePath, newFilePath});
-    }
-    jsonSplits.push_back(filePaths.at(filePath));
-  }
-  obj["splits"] = jsonSplits;
-  return obj;
-}
-
-void persistReproInfo(
-    const std::vector<AggregationFuzzer::PlanWithSplits>& plans,
-    const std::string& basePath) {
-  if (!common::generateFileDirectory(basePath.c_str())) {
-    return;
-  }
-
-  // Create a new directory
-  const auto dirPathOptional =
-      common::generateTempFolderPath(basePath.c_str(), "aggregationVerifier");
-  if (!dirPathOptional.has_value()) {
-    LOG(ERROR)
-        << "Failed to create directory for persisting plans using base path: "
-        << basePath;
-    return;
-  }
-
-  const auto dirPath = dirPathOptional.value();
-
-  // Save plans and splits.
-  const std::string planPath = fmt::format("{}/{}", dirPath, kPlanNodeFileName);
-  std::unordered_map<std::string, std::string> filePaths;
-  try {
-    folly::dynamic array = folly::dynamic::array();
-    array.reserve(plans.size());
-    for (auto planWithSplits : plans) {
-      array.push_back(serialize(planWithSplits, dirPath, filePaths));
-    }
-    auto planJson = folly::toJson(array);
-    saveStringToFile(planJson, planPath.c_str());
-    LOG(INFO) << "Persisted aggregation plans to " << planPath;
-  } catch (std::exception& e) {
-    LOG(ERROR) << "Failed to store aggregation plans to " << planPath << ": "
-               << e.what();
-  }
-}
-
-CallableSignature AggregationFuzzer::pickSignature() {
-  size_t idx = boost::random::uniform_int_distribution<uint32_t>(
-      0, signatures_.size() + signatureTemplates_.size() - 1)(rng_);
-  CallableSignature signature;
-  if (idx < signatures_.size()) {
-    signature = signatures_[idx];
-  } else {
-    const auto& signatureTemplate =
-        signatureTemplates_[idx - signatures_.size()];
-    signature.name = signatureTemplate.name;
-    velox::test::ArgumentTypeFuzzer typeFuzzer(
-        *signatureTemplate.signature, rng_);
-    VELOX_CHECK(typeFuzzer.fuzzArgumentTypes(FLAGS_max_num_varargs));
-    signature.args = typeFuzzer.argumentTypes();
-  }
-
-  return signature;
-}
-
-std::vector<std::string> AggregationFuzzer::generateKeys(
-    const std::string& prefix,
-    std::vector<std::string>& names,
-    std::vector<TypePtr>& types) {
-  static const std::vector<TypePtr> kNonFloatingPointTypes{
-      BOOLEAN(),
-      TINYINT(),
-      SMALLINT(),
-      INTEGER(),
-      BIGINT(),
-      VARCHAR(),
-      VARBINARY(),
-      TIMESTAMP(),
-  };
-
-  auto numKeys = boost::random::uniform_int_distribution<uint32_t>(1, 5)(rng_);
-  std::vector<std::string> keys;
-  for (auto i = 0; i < numKeys; ++i) {
-    keys.push_back(fmt::format("{}{}", prefix, i));
-
-    // Pick random, possibly complex, type.
-    types.push_back(vectorFuzzer_.randType(kNonFloatingPointTypes, 2));
-    names.push_back(keys.back());
-  }
-  return keys;
-}
-
-std::vector<RowVectorPtr> AggregationFuzzer::generateInputData(
-    std::vector<std::string> names,
-    std::vector<TypePtr> types) {
-  auto inputType = ROW(std::move(names), std::move(types));
-  std::vector<RowVectorPtr> input;
-  for (auto i = 0; i < FLAGS_num_batches; ++i) {
-    input.push_back(vectorFuzzer_.fuzzInputRow(inputType));
-  }
-  return input;
-}
-
-std::vector<RowVectorPtr> AggregationFuzzer::generateInputDataWithRowNumber(
-    std::vector<std::string> names,
-    std::vector<TypePtr> types) {
-  names.push_back("row_number");
-  types.push_back(BIGINT());
-
-  std::vector<RowVectorPtr> input;
-  auto size = vectorFuzzer_.getOptions().vectorSize;
-  velox::test::VectorMaker vectorMaker{pool_.get()};
-  int64_t rowNumber = 0;
-  for (auto j = 0; j < FLAGS_num_batches; ++j) {
-    std::vector<VectorPtr> children;
-    for (auto i = 0; i < types.size() - 1; ++i) {
-      children.push_back(vectorFuzzer_.fuzz(types[i], size));
-    }
-    children.push_back(vectorMaker.flatVector<int64_t>(
-        size, [&](auto /*row*/) { return rowNumber++; }));
-    input.push_back(vectorMaker.rowVector(names, children));
-  }
-  return input;
-}
-
-// static
-exec::Split AggregationFuzzer::makeSplit(const std::string& filePath) {
-  return exec::Split{std::make_shared<connector::hive::HiveConnectorSplit>(
-      kHiveConnectorId, filePath, dwio::common::FileFormat::DWRF)};
-}
-
-AggregationFuzzer::PlanWithSplits AggregationFuzzer::deserialize(
-    const folly::dynamic& obj) {
-  auto plan = velox::ISerializable::deserialize<core::PlanNode>(
-      obj["plan"], pool_.get());
-
-  std::vector<exec::Split> splits;
-  if (obj.count("splits") > 0) {
-    auto paths =
-        ISerializable::deserialize<std::vector<std::string>>(obj["splits"]);
-    for (const auto& path : paths) {
-      splits.push_back(makeSplit(path));
-    }
-  }
-
-  return PlanWithSplits{plan, splits};
-}
-
-void AggregationFuzzer::go(const std::string& planPath) {
-  Type::registerSerDe();
-  connector::hive::HiveTableHandle::registerSerDe();
-  connector::hive::LocationHandle::registerSerDe();
-  connector::hive::HiveColumnHandle::registerSerDe();
-  connector::hive::HiveInsertTableHandle::registerSerDe();
-  core::ITypedExpr::registerSerDe();
-  core::PlanNode::registerSerDe();
-  registerPartitionFunctionSerDe();
-
-  LOG(INFO) << "Attempting to use serialized plan at: " << planPath;
-  auto planString = restoreStringFromFile(planPath.c_str());
-  auto parsedPlans = folly::parseJson(planString);
-  std::vector<PlanWithSplits> plans(parsedPlans.size());
-  std::transform(
-      parsedPlans.begin(),
-      parsedPlans.end(),
-      plans.begin(),
-      [&](const folly::dynamic& obj) { return deserialize(obj); });
-
-  verifyAggregation(plans);
-}
-
-void AggregationFuzzer::go() {
-  VELOX_CHECK(
-      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
-      "Either --steps or --duration_sec needs to be greater than zero.")
-
-  auto startTime = std::chrono::system_clock::now();
-  size_t iteration = 0;
-
-  while (!isDone(iteration, startTime)) {
-    LOG(INFO) << "==============================> Started iteration "
-              << iteration << " (seed: " << currentSeed_ << ")";
-
-    // 10% of times test distinct aggregation.
-    if (vectorFuzzer_.coinToss(0.1)) {
-      ++stats_.numDistinct;
-
-      std::vector<TypePtr> types;
-      std::vector<std::string> names;
-
-      auto groupingKeys = generateKeys("g", names, types);
-      auto input = generateInputData(names, types);
-
-      verifyAggregation(groupingKeys, {}, {}, input, false, {});
-    } else {
-      // Pick a random signature.
-      CallableSignature signature = pickSignature();
-      stats_.functionNames.insert(signature.name);
-
-      const bool customVerification =
-          customVerificationFunctions_.count(signature.name) != 0;
-
-      std::vector<TypePtr> argTypes = signature.args;
-      std::vector<std::string> argNames = makeNames(argTypes.size());
-      auto call = makeFunctionCall(signature.name, argNames);
-
-      // 10% of times test window operator.
-      if (vectorFuzzer_.coinToss(0.1)) {
-        ++stats_.numWindow;
-
-        auto partitionKeys = generateKeys("p", argNames, argTypes);
-        auto sortingKeys = generateKeys("s", argNames, argTypes);
-        auto input = generateInputDataWithRowNumber(argNames, argTypes);
-
-        verifyWindow(
-            partitionKeys,
-            sortingKeys,
-            {call},
-            input,
-            customVerification,
-            FLAGS_enable_window_reference_verification);
-      } else {
-        // 20% of times use mask.
-        std::vector<std::string> masks;
-        if (vectorFuzzer_.coinToss(0.2)) {
-          ++stats_.numMask;
-
-          masks.push_back("m0");
-          argTypes.push_back(BOOLEAN());
-          argNames.push_back(masks.back());
-        }
-
-        // 10% of times use global aggregation (no grouping keys).
-        std::vector<std::string> groupingKeys;
-        if (vectorFuzzer_.coinToss(0.1)) {
-          ++stats_.numGlobal;
-        } else {
-          ++stats_.numGroupBy;
-          groupingKeys = generateKeys("g", argNames, argTypes);
-        }
-
-        std::vector<std::string> projections;
-        if (customVerification) {
-          // Add optional projection on the original result to make it order
-          // independent for comparison.
-          auto mitigation = customVerificationFunctions_.at(signature.name);
-          if (!mitigation.empty()) {
-            projections = groupingKeys;
-            projections.push_back(fmt::format(fmt::runtime(mitigation), "a0"));
-          }
-        }
-
-        auto input = generateInputData(argNames, argTypes);
-
-        verifyAggregation(
-            groupingKeys,
-            {call},
-            masks,
-            input,
-            customVerification,
-            projections);
-      }
-    }
-    LOG(INFO) << "==============================> Done with iteration "
-              << iteration;
-
-    if (persistAndRunOnce_) {
-      LOG(WARNING)
-          << "Iteration succeeded with --persist_and_run_once flag enabled "
-             "(expecting crash failure)";
-      exit(0);
-    }
-
-    reSeed();
-    ++iteration;
-  }
-
-  stats_.print(iteration);
-}
-
-velox::test::ResultOrError AggregationFuzzer::execute(
-    const core::PlanNodePtr& plan,
-    const std::vector<exec::Split>& splits,
-    bool injectSpill,
-    bool abandonPartial) {
-  LOG(INFO) << "Executing query plan: " << std::endl
-            << plan->toString(true, true);
-
-  velox::test::ResultOrError resultOrError;
-  try {
-    std::shared_ptr<TempDirectoryPath> spillDirectory;
-    AssertQueryBuilder builder(plan);
-
-    builder.configs(queryConfigs_);
-
-    if (injectSpill) {
-      spillDirectory = exec::test::TempDirectoryPath::create();
-      builder.spillDirectory(spillDirectory->path)
-          .config(core::QueryConfig::kSpillEnabled, "true")
-          .config(core::QueryConfig::kAggregationSpillEnabled, "true")
-          .config(core::QueryConfig::kTestingSpillPct, "100");
-    }
-
-    if (abandonPartial) {
-      builder.config(core::QueryConfig::kAbandonPartialAggregationMinRows, "1")
-          .config(core::QueryConfig::kAbandonPartialAggregationMinPct, "0")
-          .config(core::QueryConfig::kMaxPartialAggregationMemory, "0")
-          .config(core::QueryConfig::kMaxExtendedPartialAggregationMemory, "0");
-    }
-
-    if (!splits.empty()) {
-      builder.splits(splits);
-    }
-
-    resultOrError.result = builder.maxDrivers(2).copyResults(pool_.get());
-    LOG(INFO) << resultOrError.result->toString();
-  } catch (VeloxUserError& e) {
-    // NOTE: velox user exception is accepted as it is caused by the invalid
-    // fuzzer test inputs.
-    resultOrError.exceptionPtr = std::current_exception();
-  }
-
-  return resultOrError;
-}
-
-std::optional<MaterializedRowMultiset>
-AggregationFuzzer::computeReferenceResults(
-    const core::PlanNodePtr& plan,
-    const std::vector<RowVectorPtr>& input) {
-  if (auto sql = referenceQueryRunner_->toSql(plan)) {
-    try {
-      return referenceQueryRunner_->execute(
-          sql.value(), input, plan->outputType());
-    } catch (std::exception& e) {
-      ++stats_.numReferenceQueryFailed;
-      LOG(WARNING) << "Couldn't get results from reference DB";
-      return std::nullopt;
-    }
-  } else {
-    ++stats_.numVerificationNotSupported;
-  }
-
-  return std::nullopt;
-}
-
-void makeAlternativePlansWithValues(
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& masks,
-    const std::vector<std::string>& projections,
-    const std::vector<RowVectorPtr>& inputVectors,
-    std::vector<core::PlanNodePtr>& plans) {
-  // Partial -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .finalAggregation()
-                      .optionalProject(projections)
-                      .planNode());
-
-  // Partial -> intermediate -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .intermediateAggregation()
-                      .finalAggregation()
-                      .optionalProject(projections)
-                      .planNode());
-
-  // Partial -> local exchange -> final aggregation plan.
-  auto numSources = std::min<size_t>(4, inputVectors.size());
-  std::vector<std::vector<RowVectorPtr>> sourceInputs(numSources);
-  for (auto i = 0; i < inputVectors.size(); ++i) {
-    sourceInputs[i % numSources].push_back(inputVectors[i]);
-  }
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  std::vector<core::PlanNodePtr> sources;
-  for (const auto& sourceInput : sourceInputs) {
-    sources.push_back(PlanBuilder(planNodeIdGenerator)
-                          .values({sourceInput})
-                          .partialAggregation(groupingKeys, aggregates, masks)
-                          .planNode());
-  }
-  plans.push_back(PlanBuilder(planNodeIdGenerator)
-                      .localPartition(groupingKeys, sources)
-                      .finalAggregation()
-                      .optionalProject(projections)
-                      .planNode());
-}
-
-void makeAlternativePlansWithTableScan(
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& masks,
-    const std::vector<std::string>& projections,
-    const RowTypePtr& inputRowType,
-    std::vector<core::PlanNodePtr>& plans) {
-  // Partial -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .localPartition(groupingKeys)
-                      .finalAggregation()
-                      .optionalProject(projections)
-                      .planNode());
-
-  // Partial -> intermediate -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .localPartition(groupingKeys)
-                      .intermediateAggregation()
-                      .finalAggregation()
-                      .optionalProject(projections)
-                      .planNode());
-}
-
-void makeStreamingPlansWithValues(
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& masks,
-    const std::vector<std::string>& projections,
-    const std::vector<RowVectorPtr>& inputVectors,
-    std::vector<core::PlanNodePtr>& plans) {
-  // Single aggregation.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .orderBy(groupingKeys, false)
-                      .streamingAggregation(
-                          groupingKeys,
-                          aggregates,
-                          masks,
-                          core::AggregationNode::Step::kSingle,
-                          false)
-                      .optionalProject(projections)
-                      .planNode());
-
-  // Partial -> final aggregation plan.
-  plans.push_back(
-      PlanBuilder()
-          .values(inputVectors)
-          .orderBy(groupingKeys, false)
-          .partialStreamingAggregation(groupingKeys, aggregates, masks)
-          .finalAggregation()
-          .optionalProject(projections)
-          .planNode());
-
-  // Partial -> intermediate -> final aggregation plan.
-  plans.push_back(
-      PlanBuilder()
-          .values(inputVectors)
-          .orderBy(groupingKeys, false)
-          .partialStreamingAggregation(groupingKeys, aggregates, masks)
-          .intermediateAggregation()
-          .finalAggregation()
-          .optionalProject(projections)
-          .planNode());
-
-  // Partial -> local merge -> final aggregation plan.
-  auto numSources = std::min<size_t>(4, inputVectors.size());
-  std::vector<std::vector<RowVectorPtr>> sourceInputs(numSources);
-  for (auto i = 0; i < inputVectors.size(); ++i) {
-    sourceInputs[i % numSources].push_back(inputVectors[i]);
-  }
-
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  std::vector<core::PlanNodePtr> sources;
-  for (const auto& sourceInput : sourceInputs) {
-    sources.push_back(
-        PlanBuilder(planNodeIdGenerator)
-            .values({sourceInput})
-            .orderBy(groupingKeys, false)
-            .partialStreamingAggregation(groupingKeys, aggregates, masks)
-            .planNode());
-  }
-  plans.push_back(PlanBuilder(planNodeIdGenerator)
-                      .localMerge(groupingKeys, sources)
-                      .finalAggregation()
-                      .optionalProject(projections)
-                      .planNode());
-}
-
-void makeStreamingPlansWithTableScan(
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& masks,
-    const std::vector<std::string>& projections,
-    const RowTypePtr& inputRowType,
-    std::vector<core::PlanNodePtr>& plans) {
-  // Single aggregation.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .orderBy(groupingKeys, false)
-                      .streamingAggregation(
-                          groupingKeys,
-                          aggregates,
-                          masks,
-                          core::AggregationNode::Step::kSingle,
-                          false)
-                      .optionalProject(projections)
-                      .planNode());
-
-  // Partial -> final aggregation plan.
-  plans.push_back(
-      PlanBuilder()
-          .tableScan(inputRowType)
-          .orderBy(groupingKeys, false)
-          .partialStreamingAggregation(groupingKeys, aggregates, masks)
-          .finalAggregation()
-          .optionalProject(projections)
-          .planNode());
-
-  // Partial -> intermediate -> final aggregation plan.
-  plans.push_back(
-      PlanBuilder()
-          .tableScan(inputRowType)
-          .orderBy(groupingKeys, false)
-          .partialStreamingAggregation(groupingKeys, aggregates, masks)
-          .intermediateAggregation()
-          .finalAggregation()
-          .optionalProject(projections)
-          .planNode());
-
-  // Partial -> local merge -> final aggregation plan.
-  plans.push_back(
-      PlanBuilder()
-          .tableScan(inputRowType)
-          .orderBy(groupingKeys, true)
-          .partialStreamingAggregation(groupingKeys, aggregates, masks)
-          .localMerge(groupingKeys)
-          .finalAggregation()
-          .optionalProject(projections)
-          .planNode());
-}
-
-void AggregationFuzzer::testPlan(
-    const PlanWithSplits& planWithSplits,
-    bool injectSpill,
-    bool abandonPartial,
-    bool verifyResults,
-    const velox::test::ResultOrError& expected) {
-  auto actual = execute(
-      planWithSplits.plan, planWithSplits.splits, injectSpill, abandonPartial);
-
-  // Compare results or exceptions (if any). Fail is anything is different.
-  if (expected.exceptionPtr || actual.exceptionPtr) {
-    // Throws in case exceptions are not compatible.
-    velox::test::compareExceptions(expected.exceptionPtr, actual.exceptionPtr);
-  } else if (verifyResults) {
-    VELOX_CHECK(
-        assertEqualResults({expected.result}, {actual.result}),
-        "Logically equivalent plans produced different results");
-  } else {
-    VELOX_CHECK_EQ(
-        expected.result->size(),
-        actual.result->size(),
-        "Logically equivalent plans produced different number of rows");
-  }
-}
-
-void AggregationFuzzer::verifyWindow(
-    const std::vector<std::string>& partitionKeys,
-    const std::vector<std::string>& sortingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<RowVectorPtr>& input,
-    bool customVerification,
-    bool enableWindowVerification) {
-  std::stringstream frame;
-  if (!partitionKeys.empty()) {
-    frame << "partition by " << folly::join(", ", partitionKeys);
-  }
-  if (!sortingKeys.empty()) {
-    frame << " order by " << folly::join(", ", sortingKeys);
-  }
-
-  auto plan =
-      PlanBuilder()
-          .values(input)
-          .window({fmt::format("{} over ({})", aggregates[0], frame.str())})
-          .planNode();
-  if (persistAndRunOnce_) {
-    persistReproInfo({{plan, {}}}, reproPersistPath_);
-  }
-  try {
-    auto resultOrError = execute(plan);
-    if (resultOrError.exceptionPtr) {
-      ++stats_.numFailed;
-    }
-
-    if (!customVerification && enableWindowVerification) {
-      if (resultOrError.result) {
-        if (auto expectedResult = computeReferenceResults(plan, input)) {
-          ++stats_.numVerified;
-          VELOX_CHECK(
-              assertEqualResults(
-                  expectedResult.value(), {resultOrError.result}),
-              "Velox and reference DB results don't match");
-        }
-      }
-    } else {
-      ++stats_.numVerificationSkipped;
-    }
-  } catch (...) {
-    if (!reproPersistPath_.empty()) {
-      persistReproInfo({{plan, {}}}, reproPersistPath_);
-    }
-    throw;
-  }
-}
-
-namespace {
-void writeToFile(
-    const std::string& path,
-    const VectorPtr& vector,
-    memory::MemoryPool* pool) {
-  dwrf::WriterOptions options;
-  options.schema = vector->type();
-  options.memoryPool = pool;
-  auto writeFile = std::make_unique<LocalWriteFile>(path, true, false);
-  auto sink =
-      std::make_unique<dwio::common::WriteFileSink>(std::move(writeFile), path);
-  dwrf::Writer writer(std::move(sink), options);
-  writer.write(vector);
-  writer.close();
-}
-
-bool isTableScanSupported(const TypePtr& type) {
-  if (type->kind() == TypeKind::ROW && type->size() == 0) {
-    return false;
-  }
-  if (type->kind() == TypeKind::UNKNOWN) {
-    return false;
-  }
-
-  for (auto i = 0; i < type->size(); ++i) {
-    if (!isTableScanSupported(type->childAt(i))) {
-      return false;
-    }
-  }
-
-  return true;
-}
-} // namespace
-
-void AggregationFuzzer::verifyAggregation(
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& masks,
-    const std::vector<RowVectorPtr>& input,
-    bool customVerification,
-    const std::vector<std::string>& projections) {
-  auto firstPlan = PlanBuilder()
-                       .values(input)
-                       .singleAggregation(groupingKeys, aggregates, masks)
-                       .optionalProject(projections)
-                       .planNode();
-
-  // Create all the plans upfront.
-  std::vector<PlanWithSplits> plans;
-  plans.push_back({firstPlan, {}});
-
-  auto directory = exec::test::TempDirectoryPath::create();
-
-  // Alternate between using Values and TableScan node.
-
-  // Sometimes we generate zero-column input of type ROW({}) or a column of type
-  // UNKNOWN(). Such data cannot be written to a file and therefore cannot
-  // be tested with TableScan.
-  if (isTableScanSupported(input[0]->type()) && vectorFuzzer_.coinToss(0.5)) {
-    std::vector<exec::Split> splits;
-    auto writerPool = rootPool_->addAggregateChild("writer");
-    for (auto i = 0; i < input.size(); ++i) {
-      const std::string filePath = fmt::format("{}/{}", directory->path, i);
-      writeToFile(filePath, input[i], writerPool.get());
-      splits.push_back(makeSplit(filePath));
-    }
-
-    const auto inputRowType = asRowType(input[0]->type());
-
-    std::vector<core::PlanNodePtr> tableScanPlans;
-    makeAlternativePlansWithTableScan(
-        groupingKeys,
-        aggregates,
-        masks,
-        projections,
-        inputRowType,
-        tableScanPlans);
-
-    if (!groupingKeys.empty()) {
-      // Use OrderBy + StreamingAggregation on original input.
-      makeStreamingPlansWithTableScan(
-          groupingKeys,
-          aggregates,
-          masks,
-          projections,
-          inputRowType,
-          tableScanPlans);
-    }
-
-    for (const auto& plan : tableScanPlans) {
-      plans.push_back({plan, splits});
-    }
-  } else {
-    std::vector<core::PlanNodePtr> valuesPlans;
-    makeAlternativePlansWithValues(
-        groupingKeys, aggregates, masks, projections, input, valuesPlans);
-
-    // Evaluate same plans on flat inputs.
-    std::vector<RowVectorPtr> flatInput;
-    for (const auto& vector : input) {
-      auto flat = BaseVector::create<RowVector>(
-          vector->type(), vector->size(), vector->pool());
-      flat->copy(vector.get(), 0, 0, vector->size());
-      flatInput.push_back(flat);
-    }
-
-    makeAlternativePlansWithValues(
-        groupingKeys, aggregates, masks, projections, flatInput, valuesPlans);
-
-    if (!groupingKeys.empty()) {
-      // Use OrderBy + StreamingAggregation on original input.
-      makeStreamingPlansWithValues(
-          groupingKeys, aggregates, masks, projections, input, valuesPlans);
-
-      // Use OrderBy + StreamingAggregation on flattened input.
-      makeStreamingPlansWithValues(
-          groupingKeys, aggregates, masks, projections, flatInput, valuesPlans);
-    }
-
-    for (const auto& plan : valuesPlans) {
-      plans.push_back({plan, {}});
-    }
-  }
-
-  if (persistAndRunOnce_) {
-    persistReproInfo(plans, reproPersistPath_);
-  }
-
-  try {
-    auto resultOrError = execute(firstPlan);
-    if (resultOrError.exceptionPtr) {
-      ++stats_.numFailed;
-    }
-
-    const bool verifyResults = !customVerification || !projections.empty();
-
-    std::optional<MaterializedRowMultiset> expectedResult;
-    if (verifyResults) {
-      expectedResult = computeReferenceResults(firstPlan, input);
-    } else {
-      ++stats_.numVerificationSkipped;
-    }
-
-    if (expectedResult && resultOrError.result) {
-      ++stats_.numVerified;
-      VELOX_CHECK(
-          assertEqualResults(expectedResult.value(), {resultOrError.result}),
-          "Velox and reference DB results don't match");
-    }
-
-    testPlans(plans, verifyResults, resultOrError);
-
-  } catch (...) {
-    if (!reproPersistPath_.empty()) {
-      persistReproInfo(plans, reproPersistPath_);
-    }
-    throw;
-  }
-}
-
-// verifyAggregation(std::vector<core::PlanNodePtr> plans) is tied to plan
-// created by previous verifyAggregation function. Changes in nodes there will
-// require corresponding changes here.
-void AggregationFuzzer::verifyAggregation(
-    const std::vector<PlanWithSplits>& plans) {
-  VELOX_CHECK_GT(plans.size(), 0);
-  const auto& plan = plans.front().plan;
-  auto node = dynamic_cast<const core::AggregationNode*>(plan.get());
-  auto projectionNode = dynamic_cast<const core::ProjectNode*>(plan.get());
-  VELOX_CHECK(node || projectionNode);
-
-  if (!node) {
-    VELOX_CHECK_GT(projectionNode->sources().size(), 0);
-    node = dynamic_cast<const core::AggregationNode*>(
-        projectionNode->sources()[0].get());
-    VELOX_CHECK_NOT_NULL(node, "Unable to create aggregation node!");
-  }
-
-  // Get groupingKeys.
-  auto groupingKeys = node->groupingKeys();
-  std::vector<std::string> groupingKeyNames;
-  groupingKeyNames.reserve(groupingKeys.size());
-
-  for (const auto& key : groupingKeys) {
-    groupingKeyNames.push_back(key->name());
-  }
-
-  // Get masks.
-  std::vector<std::string> maskNames;
-  maskNames.reserve(node->aggregates().size());
-
-  for (const auto& aggregate : node->aggregates()) {
-    if (aggregate.mask) {
-      maskNames.push_back(aggregate.mask->name());
-    }
-  }
-
-  // Get projections.
-  auto projections =
-      projectionNode ? projectionNode->names() : std::vector<std::string>{};
-
-  // Get inputs.
-  std::vector<RowVectorPtr> input;
-  input.reserve(node->sources().size());
-
-  for (auto source : node->sources()) {
-    auto valueNode = dynamic_cast<const core::ValuesNode*>(source.get());
-    VELOX_CHECK_NOT_NULL(valueNode);
-    auto values = valueNode->values();
-    input.insert(input.end(), values.begin(), values.end());
-  }
-
-  auto resultOrError = execute(plan);
-  if (resultOrError.exceptionPtr) {
-    ++stats_.numFailed;
-  }
-
-  // Get aggregations and determine if order dependent.
-  std::vector<std::string> aggregateStrings;
-  aggregateStrings.reserve(node->aggregates().size());
-
-  bool customVerification = false;
-  for (auto aggregate : node->aggregates()) {
-    aggregateStrings.push_back(aggregate.call->toString());
-    customVerification |=
-        customVerificationFunctions_.count(aggregate.call->name()) != 0;
-  }
-
-  const bool verifyResults = !customVerification || !projections.empty();
-
-  std::optional<MaterializedRowMultiset> expectedResult;
-  if (verifyResults) {
-    expectedResult = computeReferenceResults(plan, input);
-  }
-
-  if (expectedResult && resultOrError.result) {
-    ++stats_.numVerified;
-    VELOX_CHECK(
-        assertEqualResults(expectedResult.value(), {resultOrError.result}),
-        "Velox and reference DB results don't match");
-  }
-
-  // Test all plans.
-  testPlans(plans, verifyResults, resultOrError);
-}
-
-void AggregationFuzzer::Stats::print(size_t numIterations) const {
-  LOG(INFO) << "Total functions tested: " << functionNames.size();
-  LOG(INFO) << "Total masked aggregations: "
-            << printStat(numMask, numIterations);
-  LOG(INFO) << "Total global aggregations: "
-            << printStat(numGlobal, numIterations);
-  LOG(INFO) << "Total group-by aggregations: "
-            << printStat(numGroupBy, numIterations);
-  LOG(INFO) << "Total distinct aggregations: "
-            << printStat(numDistinct, numIterations);
-  LOG(INFO) << "Total window expressions: "
-            << printStat(numWindow, numIterations);
-  LOG(INFO) << "Total aggregations verified against reference DB: "
-            << printStat(numVerified, numIterations);
-  LOG(INFO)
-      << "Total aggregations not verified (non-deterministic function / not supported by reference DB / reference DB failed): "
-      << printStat(numVerificationSkipped, numIterations) << " / "
-      << printStat(numVerificationNotSupported, numIterations) << " / "
-      << printStat(numReferenceQueryFailed, numIterations);
-  LOG(INFO) << "Total failed aggregations: "
-            << printStat(numFailed, numIterations);
-}
-
-} // namespace
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/AggregationFuzzerRunner.h b/velox/exec/tests/utils/AggregationFuzzerRunner.h
deleted file mode 100644
index 31285f87aa6ad..0000000000000
--- a/velox/exec/tests/utils/AggregationFuzzerRunner.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <folly/String.h>
-#include <folly/init/Init.h>
-#include <gtest/gtest.h>
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include "velox/common/file/FileSystems.h"
-#include "velox/exec/Aggregate.h"
-#include "velox/exec/tests/utils/AggregationFuzzer.h"
-#include "velox/parse/TypeResolver.h"
-#include "velox/serializers/PrestoSerializer.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-
-namespace facebook::velox::exec::test {
-
-/// AggregationFuzzerRunner leverages AggregationFuzzer and VectorFuzzer to
-/// automatically generate and execute aggregation tests. It works by:
-///
-///  1. Taking an initial set of available function signatures.
-///  2. Generating a random query plan based on the available function
-///     signatures.
-///  3. Generating a random set of input data (vector), with a variety of
-///     encodings and data layouts.
-///  4. Executing a variety of logically equivalent query plans and
-///     asserting results are the same.
-///  5. Rinse and repeat.
-///
-/// The common usage pattern is as following:
-///
-///  $ ./velox_aggregate_fuzzer_test --steps 10000
-///
-/// The important flags that control AggregateFuzzer's behavior are:
-///
-///  --steps: how many iterations to run.
-///  --duration_sec: alternatively, for how many seconds it should run (takes
-///          precedence over --steps).
-///  --seed: pass a deterministic seed to reproduce the behavior (each iteration
-///          will print a seed as part of the logs).
-///  --v=1: verbose logging; print a lot more details about the execution.
-///  --only: restrict the functions to fuzz.
-///  --batch_size: size of input vector batches generated.
-///
-/// e.g:
-///
-///  $ ./velox_aggregation_fuzzer_test \
-///         --steps 10000 \
-///         --seed 123 \
-///         --v=1 \
-///         --only "min,max"
-
-class AggregationFuzzerRunner {
- public:
-  struct Options {
-    /// Comma-separated list of functions to test. By default, all functions
-    /// are tested.
-    std::string onlyFunctions;
-
-    /// Set of functions to not test.
-    std::unordered_set<std::string> skipFunctions;
-
-    /// Set of functions whose results are non-deterministic. These can be
-    /// order-dependent functions whose results depend on the order of input
-    /// rows, or functions that return complex-typed results containing
-    /// floating-point fields.
-    ///
-    /// For some functions, the result can be transformed to a deterministic
-    /// value. If such transformation exists, it can be specified to be used for
-    /// results verification. If no transformation is specified, results are not
-    /// verified.
-    ///
-    /// Keys are function names. Values are optional transformations. "{}"
-    /// should be used to indicate the original value, i.e. "f({})"
-    /// transformation applies function 'f' to aggregation result.
-    std::unordered_map<std::string, std::string> customVerificationFunctions;
-
-    /// Timestamp precision to use when generating inputs of type TIMESTAMP.
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision{
-        VectorFuzzer::Options::TimestampPrecision::kNanoSeconds};
-
-    /// A set of configuration properties to use when running query plans.
-    /// Could be used to specify timezone or enable/disable settings that
-    /// affect semantics of individual aggregate functions.
-    std::unordered_map<std::string, std::string> queryConfigs;
-  };
-
-  static int run(
-      size_t seed,
-      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner,
-      const Options& options) {
-    return runFuzzer(
-        seed, std::nullopt, std::move(referenceQueryRunner), options);
-  }
-
-  static int runRepro(
-      const std::optional<std::string>& planPath,
-      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
-    return runFuzzer(0, planPath, std::move(referenceQueryRunner), {});
-  }
-
- private:
-  static int runFuzzer(
-      size_t seed,
-      const std::optional<std::string>& planPath,
-      std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner,
-      const Options& options) {
-    auto signatures = facebook::velox::exec::getAggregateFunctionSignatures();
-    if (signatures.empty()) {
-      LOG(ERROR) << "No aggregate functions registered.";
-      exit(1);
-    }
-
-    auto filteredSignatures = filterSignatures(
-        signatures, options.onlyFunctions, options.skipFunctions);
-    if (filteredSignatures.empty()) {
-      LOG(ERROR)
-          << "No aggregate functions left after filtering using 'only' and 'skip' lists.";
-      exit(1);
-    }
-
-    facebook::velox::parse::registerTypeResolver();
-    facebook::velox::serializer::presto::PrestoVectorSerde::
-        registerVectorSerde();
-    facebook::velox::filesystems::registerLocalFileSystem();
-
-    facebook::velox::exec::test::aggregateFuzzer(
-        filteredSignatures,
-        seed,
-        options.customVerificationFunctions,
-        options.timestampPrecision,
-        options.queryConfigs,
-        planPath,
-        std::move(referenceQueryRunner));
-    // Calling gtest here so that it can be recognized as tests in CI systems.
-    return RUN_ALL_TESTS();
-  }
-
-  static std::unordered_set<std::string> splitNames(const std::string& names) {
-    // Parse, lower case and trim it.
-    std::vector<folly::StringPiece> nameList;
-    folly::split(',', names, nameList);
-    std::unordered_set<std::string> nameSet;
-
-    for (const auto& it : nameList) {
-      auto str = folly::trimWhitespace(it).toString();
-      folly::toLowerAscii(str);
-      nameSet.insert(str);
-    }
-    return nameSet;
-  }
-
-  // Parse the comma separated list of function names, and use it to filter the
-  // input signatures.
-  static facebook::velox::exec::AggregateFunctionSignatureMap filterSignatures(
-      const facebook::velox::exec::AggregateFunctionSignatureMap& input,
-      const std::string& onlyFunctions,
-      const std::unordered_set<std::string>& skipFunctions) {
-    if (onlyFunctions.empty() && skipFunctions.empty()) {
-      return input;
-    }
-
-    facebook::velox::exec::AggregateFunctionSignatureMap output;
-    if (!onlyFunctions.empty()) {
-      // Parse, lower case and trim it.
-      auto nameSet = splitNames(onlyFunctions);
-      for (const auto& it : input) {
-        if (nameSet.count(it.first) > 0) {
-          output.insert(it);
-        }
-      }
-    } else {
-      output = input;
-    }
-
-    for (auto s : skipFunctions) {
-      auto str = s;
-      folly::toLowerAscii(str);
-      output.erase(str);
-    }
-    return output;
-  }
-};
-
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/ArbitratorTestUtil.cpp b/velox/exec/tests/utils/ArbitratorTestUtil.cpp
new file mode 100644
index 0000000000000..f971526db8724
--- /dev/null
+++ b/velox/exec/tests/utils/ArbitratorTestUtil.cpp
@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
+#include "velox/exec/TableWriter.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::memory;
+
+namespace facebook::velox::exec::test {
+
+std::shared_ptr<core::QueryCtx> newQueryCtx(
+    MemoryManager* memoryManager,
+    folly::Executor* executor,
+    int64_t memoryCapacity,
+    std::unique_ptr<MemoryReclaimer>&& reclaimer) {
+  std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>> configs;
+  std::shared_ptr<MemoryPool> pool =
+      memoryManager->addRootPool("", memoryCapacity);
+  auto queryCtx = core::QueryCtx::create(
+      executor,
+      core::QueryConfig({}),
+      configs,
+      cache::AsyncDataCache::getInstance(),
+      std::move(pool));
+  return queryCtx;
+}
+
+std::unique_ptr<memory::MemoryManager> createMemoryManager(
+    int64_t arbitratorCapacity,
+    uint64_t memoryPoolInitCapacity,
+    uint64_t memoryPoolTransferCapacity,
+    uint64_t maxReclaimWaitMs,
+    uint64_t fastExponentialGrowthCapacityLimit,
+    double slowCapacityGrowPct) {
+  memory::MemoryManagerOptions options;
+  options.arbitratorCapacity = arbitratorCapacity;
+  options.arbitratorReservedCapacity = 0;
+  // Avoid allocation failure in unit tests.
+  options.allocatorCapacity = arbitratorCapacity * 2;
+  options.arbitratorKind = "SHARED";
+  options.memoryPoolInitCapacity = memoryPoolInitCapacity;
+  options.memoryPoolTransferCapacity = memoryPoolTransferCapacity;
+  options.memoryPoolReservedCapacity = 0;
+  options.memoryReclaimWaitMs = maxReclaimWaitMs;
+  options.globalArbitrationEnabled = true;
+  options.checkUsageLeak = true;
+  options.fastExponentialGrowthCapacityLimit =
+      fastExponentialGrowthCapacityLimit;
+  options.slowCapacityGrowPct = slowCapacityGrowPct;
+  options.arbitrationStateCheckCb = memoryArbitrationStateCheck;
+  return std::make_unique<memory::MemoryManager>(options);
+}
+
+core::PlanNodePtr hashJoinPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& joinNodeId) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  return PlanBuilder(planNodeIdGenerator)
+      .values(vectors, true)
+      .project({"c0", "c1", "c2"})
+      .hashJoin(
+          {"c0"},
+          {"u1"},
+          PlanBuilder(planNodeIdGenerator)
+              .values(vectors, true)
+              .project({"c0 AS u0", "c1 AS u1", "c2 AS u2"})
+              .planNode(),
+          "",
+          {"c0", "c1", "c2"},
+          core::JoinType::kInner)
+      .capturePlanNodeId(joinNodeId)
+      .planNode();
+}
+
+QueryTestResult runHashJoinTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult) {
+  QueryTestResult result;
+  const auto plan = hashJoinPlan(vectors, result.planNodeId);
+  if (enableSpilling) {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .spillDirectory(spillDirectory->getPath())
+                      .config(core::QueryConfig::kSpillEnabled, true)
+                      .config(core::QueryConfig::kJoinSpillEnabled, true)
+                      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  } else {
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  }
+  if (expectedResult != nullptr) {
+    assertEqualResults({result.data}, {expectedResult});
+  }
+  return result;
+}
+
+core::PlanNodePtr aggregationPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& aggregateNodeId) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  return PlanBuilder(planNodeIdGenerator)
+      .values(vectors)
+      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+      .capturePlanNodeId(aggregateNodeId)
+      .planNode();
+}
+
+QueryTestResult runAggregateTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    bool enableSpilling,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    const RowVectorPtr& expectedResult) {
+  QueryTestResult result;
+  const auto plan = aggregationPlan(vectors, result.planNodeId);
+  if (enableSpilling) {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    result.data =
+        AssertQueryBuilder(plan)
+            .serialExecution(serialExecution)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, "true")
+            .config(core::QueryConfig::kAggregationSpillEnabled, "true")
+            .queryCtx(queryCtx)
+            .maxDrivers(numDrivers)
+            .copyResults(pool, result.task);
+  } else {
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  }
+  if (expectedResult != nullptr) {
+    assertEqualResults({result.data}, {expectedResult});
+  }
+  return result;
+}
+
+core::PlanNodePtr orderByPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& orderNodeId) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  return PlanBuilder(planNodeIdGenerator)
+      .values(vectors)
+      .project({"c0", "c1", "c2"})
+      .orderBy({"c2 ASC NULLS LAST"}, false)
+      .capturePlanNodeId(orderNodeId)
+      .planNode();
+}
+
+QueryTestResult runOrderByTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult) {
+  QueryTestResult result;
+  const auto plan = orderByPlan(vectors, result.planNodeId);
+  if (enableSpilling) {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .spillDirectory(spillDirectory->getPath())
+                      .config(core::QueryConfig::kSpillEnabled, "true")
+                      .config(core::QueryConfig::kOrderBySpillEnabled, "true")
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  } else {
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  }
+  if (expectedResult != nullptr) {
+    assertEqualResults({result.data}, {expectedResult});
+  }
+  return result;
+}
+
+core::PlanNodePtr rowNumberPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& rowNumberNodeId) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  return PlanBuilder(planNodeIdGenerator)
+      .values(vectors)
+      .rowNumber({"c0"}, 2, false)
+      .project({"c0", "c1"})
+      .capturePlanNodeId(rowNumberNodeId)
+      .planNode();
+}
+
+QueryTestResult runRowNumberTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult) {
+  QueryTestResult result;
+  const auto plan = rowNumberPlan(vectors, result.planNodeId);
+  if (enableSpilling) {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .spillDirectory(spillDirectory->getPath())
+                      .config(core::QueryConfig::kSpillEnabled, "true")
+                      .config(core::QueryConfig::kRowNumberSpillEnabled, "true")
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  } else {
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  }
+  if (expectedResult != nullptr) {
+    assertEqualResults({result.data}, {expectedResult});
+  }
+  return result;
+}
+
+core::PlanNodePtr topNPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& topNodeId) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  return PlanBuilder(planNodeIdGenerator)
+      .values(vectors)
+      .project({"c1"})
+      .topN({"c1 NULLS FIRST"}, 10, false)
+      .capturePlanNodeId(topNodeId)
+      .planNode();
+}
+
+QueryTestResult runTopNTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult) {
+  QueryTestResult result;
+  const auto plan = topNPlan(vectors, result.planNodeId);
+  if (enableSpilling) {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    result.data =
+        AssertQueryBuilder(plan)
+            .serialExecution(serialExecution)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, "true")
+            .config(core::QueryConfig::kTopNRowNumberSpillEnabled, "true")
+            .queryCtx(queryCtx)
+            .maxDrivers(numDrivers)
+            .copyResults(pool, result.task);
+  } else {
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  }
+  if (expectedResult != nullptr) {
+    assertEqualResults({result.data}, {expectedResult});
+  }
+  return result;
+}
+
+core::PlanNodePtr writePlan(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::string& outputDirPath,
+    core::PlanNodeId& writeNodeId) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  return PlanBuilder(planNodeIdGenerator)
+      .values(vectors)
+      .tableWrite(outputDirPath)
+      .singleAggregation(
+          {}, {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())})
+      .capturePlanNodeId(writeNodeId)
+      .planNode();
+}
+
+QueryTestResult runWriteTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    const std::string& kHiveConnectorId,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult) {
+  QueryTestResult result;
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto plan = writePlan(vectors, outputDirectory->getPath(), result.planNodeId);
+  if (enableSpilling) {
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    result.data =
+        AssertQueryBuilder(plan)
+            .serialExecution(serialExecution)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, "true")
+            .config(core::QueryConfig::kAggregationSpillEnabled, "false")
+            .config(core::QueryConfig::kWriterSpillEnabled, "true")
+            // Set 0 file writer flush threshold to always trigger flush in
+            // test.
+            .config(core::QueryConfig::kWriterFlushThresholdBytes, "0")
+            // Set stripe size to extreme large to avoid writer internal
+            // triggered flush.
+            .connectorSessionProperty(
+                kHiveConnectorId,
+                connector::hive::HiveConfig::kOrcWriterMaxStripeSizeSession,
+                "1GB")
+            .connectorSessionProperty(
+                kHiveConnectorId,
+                connector::hive::HiveConfig::
+                    kOrcWriterMaxDictionaryMemorySession,
+                "1GB")
+            .connectorSessionProperty(
+                kHiveConnectorId,
+                connector::hive::HiveConfig::
+                    kOrcWriterMaxDictionaryMemorySession,
+                "1GB")
+            .queryCtx(queryCtx)
+            .maxDrivers(numDrivers)
+            .copyResults(pool, result.task);
+  } else {
+    result.data = AssertQueryBuilder(plan)
+                      .serialExecution(serialExecution)
+                      .queryCtx(queryCtx)
+                      .maxDrivers(numDrivers)
+                      .copyResults(pool, result.task);
+  }
+  if (expectedResult != nullptr) {
+    assertEqualResults({result.data}, {expectedResult});
+  }
+  return result;
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/ArbitratorTestUtil.h b/velox/exec/tests/utils/ArbitratorTestUtil.h
new file mode 100644
index 0000000000000..9aa50153b17d9
--- /dev/null
+++ b/velox/exec/tests/utils/ArbitratorTestUtil.h
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/MemoryPool.h"
+#include "velox/exec/Driver.h"
+#include "velox/exec/MemoryReclaimer.h"
+#include "velox/exec/Task.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+
+namespace facebook::velox::exec::test {
+
+constexpr int64_t KB = 1024L;
+constexpr int64_t MB = 1024L * KB;
+
+constexpr uint64_t kMemoryCapacity = 512 * MB;
+constexpr uint64_t kMemoryPoolInitCapacity = 16 * MB;
+constexpr uint64_t kMemoryPoolTransferCapacity = 8 * MB;
+
+class FakeMemoryReclaimer : public exec::MemoryReclaimer {
+ public:
+  FakeMemoryReclaimer() = default;
+
+  static std::unique_ptr<MemoryReclaimer> create() {
+    return std::make_unique<FakeMemoryReclaimer>();
+  }
+
+  void enterArbitration() override {
+    auto* driverThreadCtx = driverThreadContext();
+    if (driverThreadCtx == nullptr) {
+      return;
+    }
+    auto* driver = driverThreadCtx->driverCtx.driver;
+    ASSERT_TRUE(driver != nullptr);
+    if (driver->task()->enterSuspended(driver->state()) != StopReason::kNone) {
+      VELOX_FAIL("Terminate detected when entering suspension");
+    }
+  }
+
+  void leaveArbitration() noexcept override {
+    auto* driverThreadCtx = driverThreadContext();
+    if (driverThreadCtx == nullptr) {
+      return;
+    }
+    auto* driver = driverThreadCtx->driverCtx.driver;
+    ASSERT_TRUE(driver != nullptr);
+    driver->task()->leaveSuspended(driver->state());
+  }
+};
+
+struct TestAllocation {
+  memory::MemoryPool* pool{nullptr};
+  void* buffer{nullptr};
+  size_t size{0};
+
+  size_t free() {
+    const size_t freedBytes = size;
+    if (pool == nullptr) {
+      VELOX_CHECK_EQ(freedBytes, 0);
+      return freedBytes;
+    }
+    VELOX_CHECK_GT(freedBytes, 0);
+    pool->free(buffer, freedBytes);
+    pool = nullptr;
+    buffer = nullptr;
+    size = 0;
+    return freedBytes;
+  }
+};
+
+std::shared_ptr<core::QueryCtx> newQueryCtx(
+    facebook::velox::memory::MemoryManager* memoryManager,
+    folly::Executor* executor,
+    int64_t memoryCapacity = facebook::velox::memory::kMaxMemory,
+    std::unique_ptr<MemoryReclaimer>&& reclaimer = nullptr);
+
+std::unique_ptr<memory::MemoryManager> createMemoryManager(
+    int64_t arbitratorCapacity = kMemoryCapacity,
+    uint64_t memoryPoolInitCapacity = kMemoryPoolInitCapacity,
+    uint64_t memoryPoolTransferCapacity = kMemoryPoolTransferCapacity,
+    uint64_t maxReclaimWaitMs = 0,
+    uint64_t fastExponentialGrowthCapacityLimit = 0,
+    double slowCapacityGrowPct = 0);
+
+// Contains the query result.
+struct QueryTestResult {
+  std::shared_ptr<Task> task;
+  RowVectorPtr data;
+  core::PlanNodeId planNodeId;
+};
+
+core::PlanNodePtr hashJoinPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& joinNodeId);
+
+QueryTestResult runHashJoinTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult = nullptr);
+
+core::PlanNodePtr aggregationPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& aggregateNodeId);
+
+QueryTestResult runAggregateTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    bool enableSpilling,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    const RowVectorPtr& expectedResult = nullptr);
+
+core::PlanNodePtr orderByPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& orderNodeId);
+
+QueryTestResult runOrderByTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult = nullptr);
+
+core::PlanNodePtr rowNumberPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& rowNumberNodeId);
+
+QueryTestResult runRowNumberTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult = nullptr);
+
+core::PlanNodePtr topNPlan(
+    const std::vector<RowVectorPtr>& vectors,
+    core::PlanNodeId& topNodeId);
+
+QueryTestResult runTopNTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult = nullptr);
+
+core::PlanNodePtr writePlan(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::string& outputDirPath,
+    core::PlanNodeId& writeNodeId);
+
+QueryTestResult runWriteTask(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool serialExecution,
+    uint32_t numDrivers,
+    memory::MemoryPool* pool,
+    const std::string& kHiveConnectorId,
+    bool enableSpilling,
+    const RowVectorPtr& expectedResult = nullptr);
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/AssertQueryBuilder.cpp b/velox/exec/tests/utils/AssertQueryBuilder.cpp
index a6e18147cb48b..b7792d42a43ee 100644
--- a/velox/exec/tests/utils/AssertQueryBuilder.cpp
+++ b/velox/exec/tests/utils/AssertQueryBuilder.cpp
@@ -57,6 +57,22 @@ AssertQueryBuilder& AssertQueryBuilder::maxDrivers(int32_t maxDrivers) {
   return *this;
 }
 
+AssertQueryBuilder& AssertQueryBuilder::destination(int32_t destination) {
+  params_.destination = destination;
+  return *this;
+}
+
+AssertQueryBuilder& AssertQueryBuilder::serialExecution(bool serial) {
+  if (serial) {
+    params_.serialExecution = true;
+    executor_ = nullptr;
+    return *this;
+  }
+  params_.serialExecution = false;
+  executor_ = newExecutor();
+  return *this;
+}
+
 AssertQueryBuilder& AssertQueryBuilder::config(
     const std::string& key,
     const std::string& value) {
@@ -72,11 +88,11 @@ AssertQueryBuilder& AssertQueryBuilder::configs(
   return *this;
 }
 
-AssertQueryBuilder& AssertQueryBuilder::connectorConfig(
+AssertQueryBuilder& AssertQueryBuilder::connectorSessionProperty(
     const std::string& connectorId,
     const std::string& key,
     const std::string& value) {
-  connectorConfigs_[connectorId][key] = value;
+  connectorSessionProperties_[connectorId][key] = value;
   return *this;
 }
 
@@ -188,9 +204,17 @@ std::shared_ptr<Task> AssertQueryBuilder::assertTypeAndNumRows(
 }
 
 RowVectorPtr AssertQueryBuilder::copyResults(memory::MemoryPool* pool) {
+  std::shared_ptr<Task> unused;
+  return copyResults(pool, unused);
+}
+
+RowVectorPtr AssertQueryBuilder::copyResults(
+    memory::MemoryPool* pool,
+    std::shared_ptr<Task>& task) {
   auto [cursor, results] = readCursor();
 
   if (results.empty()) {
+    task = cursor->task();
     return BaseVector::create<RowVector>(
         params_.planNode->outputType(), 0, pool);
   }
@@ -199,7 +223,6 @@ RowVectorPtr AssertQueryBuilder::copyResults(memory::MemoryPool* pool) {
   for (const auto& result : results) {
     totalCount += result->size();
   }
-
   auto copy =
       BaseVector::create<RowVector>(results[0]->type(), totalCount, pool);
   auto copyCount = 0;
@@ -208,6 +231,7 @@ RowVectorPtr AssertQueryBuilder::copyResults(memory::MemoryPool* pool) {
     copyCount += result->size();
   }
 
+  task = cursor->task();
   return copy;
 }
 
@@ -215,15 +239,16 @@ std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
 AssertQueryBuilder::readCursor() {
   VELOX_CHECK_NOT_NULL(params_.planNode);
 
-  if (!configs_.empty() || !connectorConfigs_.empty()) {
+  if (!configs_.empty() || !connectorSessionProperties_.empty()) {
     if (params_.queryCtx == nullptr) {
       // NOTE: the destructor of 'executor_' will wait for all the async task
       // activities to finish on AssertQueryBuilder dtor.
       static std::atomic<uint64_t> cursorQueryId{0};
-      params_.queryCtx = std::make_shared<core::QueryCtx>(
+      params_.queryCtx = core::QueryCtx::create(
           executor_.get(),
           core::QueryConfig({}),
-          std::unordered_map<std::string, std::shared_ptr<Config>>{},
+          std::
+              unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
           cache::AsyncDataCache::getInstance(),
           nullptr,
           nullptr,
@@ -233,10 +258,10 @@ AssertQueryBuilder::readCursor() {
   if (!configs_.empty()) {
     params_.queryCtx->testingOverrideConfigUnsafe(std::move(configs_));
   }
-  if (!connectorConfigs_.empty()) {
-    for (auto& [connectorId, configs] : connectorConfigs_) {
-      params_.queryCtx->setConnectorConfigOverridesUnsafe(
-          connectorId, std::move(configs));
+  if (!connectorSessionProperties_.empty()) {
+    for (auto& [connectorId, sessionProperties] : connectorSessionProperties_) {
+      params_.queryCtx->setConnectorSessionOverridesUnsafe(
+          connectorId, std::move(sessionProperties));
     }
   }
 
diff --git a/velox/exec/tests/utils/AssertQueryBuilder.h b/velox/exec/tests/utils/AssertQueryBuilder.h
index af6d48b49618c..257fe624a7f85 100644
--- a/velox/exec/tests/utils/AssertQueryBuilder.h
+++ b/velox/exec/tests/utils/AssertQueryBuilder.h
@@ -35,17 +35,32 @@ class AssertQueryBuilder {
   /// Change requested number of drivers. Default is 1.
   AssertQueryBuilder& maxDrivers(int32_t maxDrivers);
 
+  /// Change task's 'destination', the partition number assigned to the task.
+  /// Default is 0.
+  AssertQueryBuilder& destination(int32_t destination);
+
+  /// Use serial execution mode to execute the Velox plan.
+  /// Default is false.
+  AssertQueryBuilder& serialExecution(bool serial);
+
   /// Set configuration property. May be called multiple times to set multiple
   /// properties.
   AssertQueryBuilder& config(const std::string& key, const std::string& value);
 
+  template <typename T>
+  typename std::enable_if<std::is_arithmetic<T>::value, AssertQueryBuilder&>::
+      type
+      config(const std::string& key, const T& value) {
+    return config(key, std::to_string(value));
+  }
+
   /// Set multiple configuration properties.
   AssertQueryBuilder& configs(
       const std::unordered_map<std::string, std::string>& values);
 
-  /// Set connector-specific configuration property. May be called multiple
-  /// times to set multiple properties for one or multiple connectors.
-  AssertQueryBuilder& connectorConfig(
+  /// Set connector-specific configuration session property. May be called
+  /// multiple times to set multiple properties for one or multiple connectors.
+  AssertQueryBuilder& connectorSessionProperty(
       const std::string& connectorId,
       const std::string& key,
       const std::string& value);
@@ -103,7 +118,31 @@ class AssertQueryBuilder {
     return *this;
   }
 
-  // Methods to run the query and verify the results.
+  /// Methods to configure the group execution mode.
+  AssertQueryBuilder& executionStrategy(
+      core::ExecutionStrategy executionStrategy) {
+    params_.executionStrategy = executionStrategy;
+    return *this;
+  }
+
+  AssertQueryBuilder& numSplitGroups(int numSplitGroups) {
+    params_.numSplitGroups = numSplitGroups;
+    return *this;
+  }
+
+  AssertQueryBuilder& numConcurrentSplitGroups(
+      int32_t numConcurrentSplitGroups) {
+    params_.numConcurrentSplitGroups = numConcurrentSplitGroups;
+    return *this;
+  }
+
+  AssertQueryBuilder& groupedExecutionLeafNodeIds(
+      const std::unordered_set<core::PlanNodeId>& groupedExecutionLeafNodeIds) {
+    params_.groupedExecutionLeafNodeIds = groupedExecutionLeafNodeIds;
+    return *this;
+  }
+
+  /// Methods to run the query and verify the results.
 
   /// Run the query and verify results against DuckDB. Requires
   /// duckDbQueryRunner to be provided in the constructor.
@@ -129,20 +168,29 @@ class AssertQueryBuilder {
 
   /// Run the query and collect all results into a single vector. Throws if
   /// query returns empty result.
-  RowVectorPtr copyResults(memory::MemoryPool* FOLLY_NONNULL pool);
+  RowVectorPtr copyResults(memory::MemoryPool* pool);
+
+  /// Similar to above method and also returns the task.
+  RowVectorPtr copyResults(
+      memory::MemoryPool* pool,
+      std::shared_ptr<Task>& task);
 
  private:
   std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
   readCursor();
 
+  static std::unique_ptr<folly::Executor> newExecutor() {
+    return std::make_unique<folly::CPUThreadPoolExecutor>(
+        std::thread::hardware_concurrency());
+  }
+
   // Used by the created task as the default driver executor.
-  std::unique_ptr<folly::Executor> executor_{
-      new folly::CPUThreadPoolExecutor(std::thread::hardware_concurrency())};
-  DuckDbQueryRunner* FOLLY_NULLABLE const duckDbQueryRunner_;
+  std::unique_ptr<folly::Executor> executor_{newExecutor()};
+  DuckDbQueryRunner* const duckDbQueryRunner_;
   CursorParameters params_;
   std::unordered_map<std::string, std::string> configs_;
   std::unordered_map<std::string, std::unordered_map<std::string, std::string>>
-      connectorConfigs_;
+      connectorSessionProperties_;
   std::unordered_map<core::PlanNodeId, std::vector<Split>> splits_;
 };
 
diff --git a/velox/exec/tests/utils/CMakeLists.txt b/velox/exec/tests/utils/CMakeLists.txt
index bcdb2a0303c5d..8e28b4dcdc89e 100644
--- a/velox/exec/tests/utils/CMakeLists.txt
+++ b/velox/exec/tests/utils/CMakeLists.txt
@@ -14,13 +14,14 @@
 
 add_library(velox_temp_path TempFilePath.cpp TempDirectoryPath.cpp)
 
-target_link_libraries(velox_temp_path velox_exception)
+target_link_libraries(
+  velox_temp_path velox_exception)
 
 add_library(
   velox_exec_test_lib
   AssertQueryBuilder.cpp
+  ArbitratorTestUtil.cpp
   Cursor.cpp
-  DuckQueryRunner.cpp
   HiveConnectorTestBase.cpp
   LocalExchangeSource.cpp
   OperatorTestBase.cpp
@@ -28,7 +29,8 @@ add_library(
   QueryAssertions.cpp
   SumNonPODAggregate.cpp
   TpchQueryBuilder.cpp
-  VectorTestUtil.cpp)
+  VectorTestUtil.cpp
+  PortUtil.cpp)
 
 target_link_libraries(
   velox_exec_test_lib
@@ -43,14 +45,10 @@ target_link_libraries(
   velox_dwio_dwrf_reader
   velox_dwio_dwrf_writer
   velox_dwio_common_test_utils
+  velox_file_test_utils
   velox_type_fbhive
   velox_hive_connector
   velox_tpch_connector
   velox_presto_serializer
   velox_functions_prestosql
   velox_aggregates)
-
-add_library(velox_aggregation_fuzzer AggregationFuzzer.cpp)
-
-target_link_libraries(velox_aggregation_fuzzer velox_type velox_vector_fuzzer
-                      velox_exec_test_lib velox_expression_test_utility)
diff --git a/velox/exec/tests/utils/Cursor.cpp b/velox/exec/tests/utils/Cursor.cpp
index aaf48d2a02990..1aed8908206b9 100644
--- a/velox/exec/tests/utils/Cursor.cpp
+++ b/velox/exec/tests/utils/Cursor.cpp
@@ -32,10 +32,9 @@ bool waitForTaskDriversToFinish(exec::Task* task, uint64_t maxWaitMicros) {
   }
 
   if (task->numFinishedDrivers() != task->numTotalDrivers()) {
-    LOG(ERROR)
-        << "Timed out waiting for all task drivers to finish. Finished drivers: "
-        << task->numFinishedDrivers()
-        << ". Total drivers: " << task->numTotalDrivers();
+    LOG(ERROR) << "Timed out waiting for all drivers of task " << task->taskId()
+               << " to finish. Finished drivers: " << task->numFinishedDrivers()
+               << ". Total drivers: " << task->numTotalDrivers();
   }
 
   return task->numFinishedDrivers() == task->numTotalDrivers();
@@ -83,6 +82,10 @@ RowVectorPtr TaskQueue::dequeue() {
     std::vector<ContinuePromise> mayContinue;
     {
       std::lock_guard<std::mutex> l(mutex_);
+      if (closed_) {
+        return nullptr;
+      }
+
       if (!queue_.empty()) {
         auto result = std::move(queue_.front());
         queue_.pop_front();
@@ -115,10 +118,17 @@ RowVectorPtr TaskQueue::dequeue() {
 void TaskQueue::close() {
   std::lock_guard<std::mutex> l(mutex_);
   closed_ = true;
+  // Unblock producers.
   for (auto& promise : producerUnblockPromises_) {
     promise.setValue();
   }
   producerUnblockPromises_.clear();
+
+  // Unblock consumers.
+  if (consumerBlocked_) {
+    consumerBlocked_ = false;
+    consumerPromise_.setValue();
+  }
 }
 
 bool TaskQueue::hasNext() {
@@ -126,108 +136,276 @@ bool TaskQueue::hasNext() {
   return !queue_.empty();
 }
 
-std::atomic<int32_t> TaskCursor::serial_;
-
-TaskCursor::TaskCursor(const CursorParameters& params)
-    : maxDrivers_{params.maxDrivers},
-      numConcurrentSplitGroups_{params.numConcurrentSplitGroups},
-      numSplitGroups_{params.numSplitGroups} {
-  std::shared_ptr<core::QueryCtx> queryCtx;
-  if (params.queryCtx) {
-    queryCtx = params.queryCtx;
-  } else {
-    // NOTE: the destructor of 'executor_' will wait for all the async task
-    // activities to finish on TaskCursor destruction.
-    executor_ = std::make_shared<folly::CPUThreadPoolExecutor>(
-        std::thread::hardware_concurrency());
-    static std::atomic<uint64_t> cursorQueryId{0};
-    queryCtx = std::make_shared<core::QueryCtx>(
-        executor_.get(),
-        core::QueryConfig({}),
-        std::unordered_map<std::string, std::shared_ptr<Config>>{},
-        cache::AsyncDataCache::getInstance(),
-        nullptr,
-        nullptr,
-        fmt::format("TaskCursorQuery_{}", cursorQueryId++));
+class TaskCursorBase : public TaskCursor {
+ public:
+  TaskCursorBase(
+      const CursorParameters& params,
+      const std::shared_ptr<folly::Executor>& executor) {
+    static std::atomic<int32_t> cursorId;
+    taskId_ = fmt::format("test_cursor {}", ++cursorId);
+
+    if (params.queryCtx) {
+      queryCtx_ = params.queryCtx;
+    } else {
+      // NOTE: the destructor of 'executor_' will wait for all the async task
+      // activities to finish on TaskCursor destruction.
+      executor_ = executor;
+      static std::atomic<uint64_t> cursorQueryId{0};
+      queryCtx_ = core::QueryCtx::create(
+          executor_.get(),
+          core::QueryConfig({}),
+          std::
+              unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+          cache::AsyncDataCache::getInstance(),
+          nullptr,
+          nullptr,
+          fmt::format("TaskCursorQuery_{}", cursorQueryId++));
+    }
+
+    if (!params.queryConfigs.empty()) {
+      auto configCopy = params.queryConfigs;
+      queryCtx_->testingOverrideConfigUnsafe(std::move(configCopy));
+    }
+
+    planFragment_ = {
+        params.planNode,
+        params.executionStrategy,
+        params.numSplitGroups,
+        params.groupedExecutionLeafNodeIds};
+
+    if (!params.spillDirectory.empty()) {
+      taskSpillDirectory_ = params.spillDirectory + "/" + taskId_;
+      auto fileSystem =
+          velox::filesystems::getFileSystem(taskSpillDirectory_, nullptr);
+      VELOX_CHECK_NOT_NULL(fileSystem, "File System is null!");
+      try {
+        fileSystem->mkdir(taskSpillDirectory_);
+      } catch (...) {
+        LOG(ERROR) << "Faield to create task spill directory "
+                   << taskSpillDirectory_ << " base director "
+                   << params.spillDirectory << " exists["
+                   << std::filesystem::exists(taskSpillDirectory_) << "]";
+
+        std::rethrow_exception(std::current_exception());
+      }
+
+      LOG(INFO) << "Task spill directory[" << taskSpillDirectory_
+                << "] created";
+    }
   }
 
-  queue_ = std::make_shared<TaskQueue>(params.bufferedBytes);
-  // Captured as a shared_ptr by the consumer callback of task_.
-  auto queue = queue_;
-  core::PlanFragment planFragment{
-      params.planNode,
-      params.executionStrategy,
-      params.numSplitGroups,
-      params.groupedExecutionLeafNodeIds};
-  const std::string taskId = fmt::format("test_cursor {}", ++serial_);
-
-  task_ = Task::create(
-      taskId,
-      std::move(planFragment),
-      params.destination,
-      std::move(queryCtx),
-      // consumer
-      [queue, copyResult = params.copyResult](
-          RowVectorPtr vector, velox::ContinueFuture* future) {
-        if (!vector || !copyResult) {
-          return queue->enqueue(vector, future);
-        }
-        // Make sure to load lazy vector if not loaded already.
-        for (auto& child : vector->children()) {
-          child->loadedVector();
-        }
-        auto copy = BaseVector::create<RowVector>(
-            vector->type(), vector->size(), queue->pool());
-        copy->copy(vector.get(), 0, 0, vector->size());
-        return queue->enqueue(std::move(copy), future);
-      });
-
-  if (!params.spillDirectory.empty()) {
-    std::string taskSpillDirectory = params.spillDirectory + "/" + taskId;
-    auto fileSystem =
-        velox::filesystems::getFileSystem(taskSpillDirectory, nullptr);
-    VELOX_CHECK_NOT_NULL(fileSystem, "File System is null!");
-    try {
-      fileSystem->mkdir(taskSpillDirectory);
-    } catch (...) {
-      LOG(ERROR) << "Faield to create task spill directory "
-                 << taskSpillDirectory << " base director "
-                 << params.spillDirectory << " exists["
-                 << std::filesystem::exists(taskSpillDirectory) << "]";
-
-      std::rethrow_exception(std::current_exception());
+ protected:
+  std::string taskId_;
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+  core::PlanFragment planFragment_;
+  std::string taskSpillDirectory_;
+
+ private:
+  std::shared_ptr<folly::Executor> executor_;
+};
+
+class MultiThreadedTaskCursor : public TaskCursorBase {
+ public:
+  explicit MultiThreadedTaskCursor(const CursorParameters& params)
+      : TaskCursorBase(
+            params,
+            std::make_shared<folly::CPUThreadPoolExecutor>(
+                std::thread::hardware_concurrency())),
+        maxDrivers_{params.maxDrivers},
+        numConcurrentSplitGroups_{params.numConcurrentSplitGroups},
+        numSplitGroups_{params.numSplitGroups} {
+    VELOX_CHECK(!params.serialExecution);
+    VELOX_CHECK(
+        queryCtx_->isExecutorSupplied(),
+        "Executor should be set in parallel task cursor");
+
+    queue_ = std::make_shared<TaskQueue>(params.bufferedBytes);
+    // Captured as a shared_ptr by the consumer callback of task_.
+    auto queue = queue_;
+    task_ = Task::create(
+        taskId_,
+        std::move(planFragment_),
+        params.destination,
+        std::move(queryCtx_),
+        Task::ExecutionMode::kParallel,
+        // consumer
+        [queue, copyResult = params.copyResult](
+            const RowVectorPtr& vector, velox::ContinueFuture* future) {
+          if (!vector || !copyResult) {
+            return queue->enqueue(vector, future);
+          }
+          // Make sure to load lazy vector if not loaded already.
+          for (auto& child : vector->children()) {
+            child->loadedVector();
+          }
+          auto copy = BaseVector::create<RowVector>(
+              vector->type(), vector->size(), queue->pool());
+          copy->copy(vector.get(), 0, 0, vector->size());
+          return queue->enqueue(std::move(copy), future);
+        },
+        [queue](std::exception_ptr) {
+          // onError close the queue to unblock producers and consumers.
+          // moveNext will handle rethrowing the error once it's
+          // unblocked.
+          queue->close();
+        });
+
+    if (!taskSpillDirectory_.empty()) {
+      task_->setSpillDirectory(taskSpillDirectory_);
     }
+  }
 
-    LOG(INFO) << "Task spill directory[" << taskSpillDirectory << "] created";
-    task_->setSpillDirectory(taskSpillDirectory);
+  ~MultiThreadedTaskCursor() override {
+    queue_->close();
+    if (task_ && !atEnd_) {
+      task_->requestCancel();
+    }
   }
-}
 
-void TaskCursor::start() {
-  if (!started_) {
-    started_ = true;
-    exec::Task::start(task_, maxDrivers_, numConcurrentSplitGroups_);
-    queue_->setNumProducers(numSplitGroups_ * task_->numOutputDrivers());
+  /// Starts the task if not started yet.
+  void start() override {
+    if (!started_) {
+      started_ = true;
+      task_->start(maxDrivers_, numConcurrentSplitGroups_);
+      queue_->setNumProducers(numSplitGroups_ * task_->numOutputDrivers());
+    }
+  }
+
+  /// Fetches another batch from the task queue.
+  /// Starts the task if not started yet.
+  bool moveNext() override {
+    start();
+    current_ = queue_->dequeue();
+    if (task_->error()) {
+      // Wait for the task to finish (there's' a small period of time between
+      // when the error is set on the Task and terminate is called).
+      task_->taskCompletionFuture()
+          .within(std::chrono::microseconds(5'000'000))
+          .wait();
+
+      // Wait for all task drivers to finish to avoid destroying the executor_
+      // before task_ finished using it and causing a crash.
+      waitForTaskDriversToFinish(task_.get());
+      std::rethrow_exception(task_->error());
+    }
+    if (!current_) {
+      atEnd_ = true;
+    }
+    return current_ != nullptr;
   }
-}
 
-bool TaskCursor::moveNext() {
-  start();
-  current_ = queue_->dequeue();
-  if (task_->error()) {
-    // Wait for all task drivers to finish to avoid destroying the executor_
-    // before task_ finished using it and causing a crash.
-    waitForTaskDriversToFinish(task_.get());
-    std::rethrow_exception(task_->error());
+  bool hasNext() override {
+    return queue_->hasNext();
   }
-  if (!current_) {
-    atEnd_ = true;
+
+  RowVectorPtr& current() override {
+    return current_;
   }
-  return current_ != nullptr;
-}
 
-bool TaskCursor::hasNext() {
-  return queue_->hasNext();
+  const std::shared_ptr<Task>& task() override {
+    return task_;
+  }
+
+ private:
+  const int32_t maxDrivers_;
+  const int32_t numConcurrentSplitGroups_;
+  const int32_t numSplitGroups_;
+
+  bool started_{false};
+  std::shared_ptr<TaskQueue> queue_;
+  std::shared_ptr<exec::Task> task_;
+  RowVectorPtr current_;
+  bool atEnd_{false};
+};
+
+class SingleThreadedTaskCursor : public TaskCursorBase {
+ public:
+  explicit SingleThreadedTaskCursor(const CursorParameters& params)
+      : TaskCursorBase(params, nullptr) {
+    VELOX_CHECK(params.serialExecution);
+    VELOX_CHECK(
+        !queryCtx_->isExecutorSupplied(),
+        "Executor should not be set in serial task cursor");
+
+    task_ = Task::create(
+        taskId_,
+        std::move(planFragment_),
+        params.destination,
+        std::move(queryCtx_),
+        Task::ExecutionMode::kSerial);
+
+    if (!taskSpillDirectory_.empty()) {
+      task_->setSpillDirectory(taskSpillDirectory_);
+    }
+
+    VELOX_CHECK(
+        task_->supportSerialExecutionMode(),
+        "Plan doesn't support serial execution mode");
+  }
+
+  ~SingleThreadedTaskCursor() override {
+    if (task_ && !SingleThreadedTaskCursor::hasNext()) {
+      task_->requestCancel().wait();
+    }
+  }
+
+  void start() override {
+    // no-op
+  }
+
+  bool moveNext() override {
+    if (!hasNext()) {
+      return false;
+    }
+    current_ = next_;
+    next_ = nullptr;
+    return true;
+  };
+
+  bool hasNext() override {
+    if (next_) {
+      return true;
+    }
+    if (!task_->isRunning()) {
+      return false;
+    }
+    while (true) {
+      ContinueFuture future = ContinueFuture::makeEmpty();
+      RowVectorPtr next = task_->next(&future);
+      if (next != nullptr) {
+        next_ = next;
+        return true;
+      }
+      // When next is returned from task as a null pointer.
+      if (!future.valid()) {
+        VELOX_CHECK(!task_->isRunning());
+        return false;
+      }
+      // Task is blocked for some reason. Wait and try again.
+      VELOX_CHECK_NULL(next);
+      future.wait();
+    }
+  };
+
+  RowVectorPtr& current() override {
+    return current_;
+  }
+
+  const std::shared_ptr<Task>& task() override {
+    return task_;
+  }
+
+ private:
+  std::shared_ptr<exec::Task> task_;
+  RowVectorPtr current_;
+  RowVectorPtr next_;
+};
+
+std::unique_ptr<TaskCursor> TaskCursor::create(const CursorParameters& params) {
+  if (params.serialExecution) {
+    return std::make_unique<SingleThreadedTaskCursor>(params);
+  }
+  return std::make_unique<MultiThreadedTaskCursor>(params);
 }
 
 bool RowCursor::next() {
diff --git a/velox/exec/tests/utils/Cursor.h b/velox/exec/tests/utils/Cursor.h
index 4532038638acc..314eb89587609 100644
--- a/velox/exec/tests/utils/Cursor.h
+++ b/velox/exec/tests/utils/Cursor.h
@@ -46,15 +46,15 @@ struct CursorParameters {
 
   uint64_t bufferedBytes = 512 * 1024;
 
-  // Ungrouped (by default) or grouped (bucketed) execution.
+  /// Ungrouped (by default) or grouped (bucketed) execution.
   core::ExecutionStrategy executionStrategy{
       core::ExecutionStrategy::kUngrouped};
 
   /// Contains leaf plan nodes that need to be executed in the grouped mode.
   std::unordered_set<core::PlanNodeId> groupedExecutionLeafNodeIds;
 
-  // Number of splits groups the task will be processing. Must be 1 for
-  // ungrouped execution.
+  /// Number of splits groups the task will be processing. Must be 1 for
+  /// ungrouped execution.
   int numSplitGroups{1};
 
   /// Spilling directory, if not empty, then the task's spilling directory would
@@ -62,6 +62,13 @@ struct CursorParameters {
   std::string spillDirectory;
 
   bool copyResult = true;
+
+  /// If true, use serial execution mode. Use parallel execution mode otherwise.
+  bool serialExecution = false;
+
+  /// If both 'queryConfigs' and 'queryCtx' are specified, the configurations in
+  /// 'queryCtx' will be overridden by 'queryConfig'.
+  std::unordered_map<std::string, std::string> queryConfigs;
 };
 
 class TaskQueue {
@@ -72,7 +79,7 @@ class TaskQueue {
   };
 
   explicit TaskQueue(uint64_t maxBytes)
-      : pool_(memory::addDefaultLeafMemoryPool()), maxBytes_(maxBytes) {}
+      : pool_(memory::memoryManager()->addLeafPool()), maxBytes_(maxBytes) {}
 
   void setNumProducers(int32_t n) {
     numProducers_ = n;
@@ -117,51 +124,28 @@ class TaskQueue {
 
 class TaskCursor {
  public:
-  explicit TaskCursor(const CursorParameters& params);
+  virtual ~TaskCursor() = default;
 
-  ~TaskCursor() {
-    queue_->close();
-    if (task_ && !atEnd_) {
-      task_->requestCancel();
-    }
-  }
+  static std::unique_ptr<TaskCursor> create(const CursorParameters& params);
 
   /// Starts the task if not started yet.
-  void start();
+  virtual void start() = 0;
 
   /// Fetches another batch from the task queue.
   /// Starts the task if not started yet.
-  bool moveNext();
-
-  bool hasNext();
+  virtual bool moveNext() = 0;
 
-  RowVectorPtr& current() {
-    return current_;
-  }
+  virtual bool hasNext() = 0;
 
-  const std::shared_ptr<Task>& task() {
-    return task_;
-  }
+  virtual RowVectorPtr& current() = 0;
 
- private:
-  static std::atomic<int32_t> serial_;
-
-  const int32_t maxDrivers_;
-  const int32_t numConcurrentSplitGroups_;
-  const int32_t numSplitGroups_;
-
-  std::shared_ptr<folly::Executor> executor_;
-  bool started_ = false;
-  std::shared_ptr<TaskQueue> queue_;
-  std::shared_ptr<exec::Task> task_;
-  RowVectorPtr current_;
-  bool atEnd_{false};
+  virtual const std::shared_ptr<Task>& task() = 0;
 };
 
 class RowCursor {
  public:
   explicit RowCursor(CursorParameters& params) {
-    cursor_ = std::make_unique<TaskCursor>(params);
+    cursor_ = TaskCursor::create(params);
   }
 
   bool isNullAt(int32_t columnIndex) const {
diff --git a/velox/exec/tests/utils/DuckQueryRunner.cpp b/velox/exec/tests/utils/DuckQueryRunner.cpp
deleted file mode 100644
index e02b63ecfa3a9..0000000000000
--- a/velox/exec/tests/utils/DuckQueryRunner.cpp
+++ /dev/null
@@ -1,258 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/exec/tests/utils/DuckQueryRunner.h"
-#include "velox/exec/tests/utils/QueryAssertions.h"
-
-namespace facebook::velox::exec::test {
-
-namespace {
-
-void appendComma(int32_t i, std::stringstream& sql) {
-  if (i > 0) {
-    sql << ", ";
-  }
-}
-
-std::string toCallSql(const core::CallTypedExprPtr& call) {
-  std::stringstream sql;
-  sql << call->name() << "(";
-  for (auto i = 0; i < call->inputs().size(); ++i) {
-    appendComma(i, sql);
-    sql << std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-               call->inputs()[i])
-               ->name();
-  }
-  sql << ")";
-  return sql.str();
-}
-
-bool isSupported(const TypePtr& type) {
-  // DuckDB doesn't support nanosecond precision for timestamps.
-  if (type->kind() == TypeKind::TIMESTAMP) {
-    return false;
-  }
-  for (auto i = 0; i < type->size(); ++i) {
-    if (!isSupported(type->childAt(i))) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-std::unordered_set<std::string> getAggregateFunctions() {
-  std::string sql =
-      "SELECT distinct on(function_name) function_name "
-      "FROM duckdb_functions() "
-      "WHERE function_type = 'aggregate'";
-
-  DuckDbQueryRunner queryRunner;
-  auto result = queryRunner.executeOrdered(sql, ROW({VARCHAR()}));
-
-  std::unordered_set<std::string> names;
-  for (const auto& row : result) {
-    names.insert(row[0].value<std::string>());
-  }
-
-  return names;
-}
-} // namespace
-
-DuckQueryRunner::DuckQueryRunner()
-    : aggregateFunctionNames_{getAggregateFunctions()} {}
-
-std::multiset<std::vector<velox::variant>> DuckQueryRunner::execute(
-    const std::string& sql,
-    const std::vector<RowVectorPtr>& input,
-    const RowTypePtr& resultType) {
-  DuckDbQueryRunner queryRunner;
-  queryRunner.createTable("tmp", input);
-  return queryRunner.execute(sql, resultType);
-}
-
-std::optional<std::string> DuckQueryRunner::toSql(
-    const core::PlanNodePtr& plan) {
-  if (!isSupported(plan->outputType())) {
-    return std::nullopt;
-  }
-
-  for (const auto& source : plan->sources()) {
-    if (!isSupported(source->outputType())) {
-      return std::nullopt;
-    }
-  }
-
-  if (auto projectNode =
-          std::dynamic_pointer_cast<const core::ProjectNode>(plan)) {
-    return toSql(projectNode);
-  }
-
-  if (auto windowNode =
-          std::dynamic_pointer_cast<const core::WindowNode>(plan)) {
-    return toSql(windowNode);
-  }
-
-  if (auto aggregationNode =
-          std::dynamic_pointer_cast<const core::AggregationNode>(plan)) {
-    return toSql(aggregationNode);
-  }
-
-  VELOX_NYI();
-}
-
-namespace {
-bool containsMap(const TypePtr& type) {
-  if (type->isMap()) {
-    return true;
-  }
-
-  for (auto i = 0; i < type->size(); ++i) {
-    if (containsMap(type->childAt(i))) {
-      return true;
-    }
-  }
-
-  return false;
-}
-} // namespace
-
-std::optional<std::string> DuckQueryRunner::toSql(
-    const std::shared_ptr<const core::AggregationNode>& aggregationNode) {
-  // Assume plan is Aggregation over Values.
-  VELOX_CHECK(aggregationNode->step() == core::AggregationNode::Step::kSingle);
-
-  for (const auto& agg : aggregationNode->aggregates()) {
-    if (aggregateFunctionNames_.count(agg.call->name()) == 0) {
-      return std::nullopt;
-    }
-  }
-
-  std::vector<std::string> groupingKeys;
-  for (const auto& key : aggregationNode->groupingKeys()) {
-    // Aggregations with group by keys that contain maps are buggy.
-    if (containsMap(key->type())) {
-      return std::nullopt;
-    }
-    groupingKeys.push_back(key->name());
-  }
-
-  std::stringstream sql;
-  sql << "SELECT " << folly::join(", ", groupingKeys);
-
-  const auto& aggregates = aggregationNode->aggregates();
-  if (!aggregates.empty()) {
-    if (!groupingKeys.empty()) {
-      sql << ", ";
-    }
-
-    for (auto i = 0; i < aggregates.size(); ++i) {
-      appendComma(i, sql);
-      const auto& aggregate = aggregates[i];
-      sql << toCallSql(aggregate.call);
-
-      if (aggregate.mask != nullptr) {
-        sql << " filter (where " << aggregate.mask->name() << ")";
-      }
-      sql << " as " << aggregationNode->aggregateNames()[i];
-    }
-  }
-
-  sql << " FROM tmp";
-
-  if (!groupingKeys.empty()) {
-    sql << " GROUP BY " << folly::join(", ", groupingKeys);
-  }
-
-  return sql.str();
-}
-
-std::optional<std::string> DuckQueryRunner::toSql(
-    const std::shared_ptr<const core::ProjectNode>& projectNode) {
-  auto sourceSql = toSql(projectNode->sources()[0]);
-  if (!sourceSql.has_value()) {
-    return std::nullopt;
-  }
-
-  std::stringstream sql;
-  sql << "SELECT ";
-
-  for (auto i = 0; i < projectNode->names().size(); ++i) {
-    appendComma(i, sql);
-    auto projection = projectNode->projections()[i];
-    if (auto field =
-            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-                projection)) {
-      sql << field->name();
-    } else if (
-        auto call =
-            std::dynamic_pointer_cast<const core::CallTypedExpr>(projection)) {
-      sql << toCallSql(call);
-    } else {
-      VELOX_NYI();
-    }
-
-    sql << " as " << projectNode->names()[i];
-  }
-
-  sql << " FROM (" << sourceSql.value() << ")";
-  return sql.str();
-}
-
-std::optional<std::string> DuckQueryRunner::toSql(
-    const std::shared_ptr<const core::WindowNode>& windowNode) {
-  std::stringstream sql;
-  sql << "SELECT ";
-
-  const auto& inputType = windowNode->sources()[0]->outputType();
-  for (auto i = 0; i < inputType->size(); ++i) {
-    appendComma(i, sql);
-    sql << inputType->nameOf(i);
-  }
-
-  sql << ", ";
-
-  const auto& functions = windowNode->windowFunctions();
-  for (auto i = 0; i < functions.size(); ++i) {
-    appendComma(i, sql);
-    sql << toCallSql(functions[i].functionCall);
-  }
-  sql << " OVER (";
-
-  const auto& partitionKeys = windowNode->partitionKeys();
-  if (!partitionKeys.empty()) {
-    sql << "partition by ";
-    for (auto i = 0; i < partitionKeys.size(); ++i) {
-      appendComma(i, sql);
-      sql << partitionKeys[i]->name();
-    }
-  }
-
-  const auto& sortingKeys = windowNode->sortingKeys();
-  const auto& sortingOrders = windowNode->sortingOrders();
-
-  if (!sortingKeys.empty()) {
-    sql << " order by ";
-    for (auto i = 0; i < sortingKeys.size(); ++i) {
-      appendComma(i, sql);
-      sql << sortingKeys[i]->name() << " " << sortingOrders[i].toString();
-    }
-  }
-
-  sql << ") FROM tmp";
-
-  return sql.str();
-}
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/DuckQueryRunner.h b/velox/exec/tests/utils/DuckQueryRunner.h
deleted file mode 100644
index 426d1d94515a4..0000000000000
--- a/velox/exec/tests/utils/DuckQueryRunner.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/exec/tests/utils/ReferenceQueryRunner.h"
-
-namespace facebook::velox::exec::test {
-
-class DuckQueryRunner : public ReferenceQueryRunner {
- public:
-  DuckQueryRunner();
-
-  /// Supports AggregationNode and WindowNode with optional ProjectNode on top.
-  /// Assumes that source of AggregationNode or Window Node is 'tmp' table.
-  std::optional<std::string> toSql(const core::PlanNodePtr& plan) override;
-
-  /// Creates 'tmp' table with 'input' data and runs 'sql' query. Returns
-  /// results according to 'resultType' schema.
-  std::multiset<std::vector<velox::variant>> execute(
-      const std::string& sql,
-      const std::vector<RowVectorPtr>& input,
-      const RowTypePtr& resultType) override;
-
- private:
-  std::optional<std::string> toSql(
-      const std::shared_ptr<const core::AggregationNode>& aggregationNode);
-
-  std::optional<std::string> toSql(
-      const std::shared_ptr<const core::WindowNode>& windowNode);
-
-  std::optional<std::string> toSql(
-      const std::shared_ptr<const core::ProjectNode>& projectNode);
-
-  std::unordered_set<std::string> aggregateFunctionNames_;
-};
-
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/HiveConnectorTestBase.cpp b/velox/exec/tests/utils/HiveConnectorTestBase.cpp
index 4035cf859d7e6..b393621393c38 100644
--- a/velox/exec/tests/utils/HiveConnectorTestBase.cpp
+++ b/velox/exec/tests/utils/HiveConnectorTestBase.cpp
@@ -17,15 +17,18 @@
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 
 #include "velox/common/file/FileSystems.h"
-#include "velox/connectors/hive/HiveDataSink.h"
+#include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
+#include "velox/dwio/dwrf/writer/FlushPolicy.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 
 namespace facebook::velox::exec::test {
 
 HiveConnectorTestBase::HiveConnectorTestBase() {
   filesystems::registerLocalFileSystem();
+  tests::utils::registerFaultyFileSystem();
 }
 
 void HiveConnectorTestBase::SetUp() {
@@ -35,7 +38,8 @@ void HiveConnectorTestBase::SetUp() {
           connector::hive::HiveConnectorFactory::kHiveConnectorName)
           ->newConnector(
               kHiveConnectorId,
-              std::make_shared<core::MemConfig>(),
+              std::make_shared<config::ConfigBase>(
+                  std::unordered_map<std::string, std::string>()),
               ioExecutor_.get());
   connector::registerConnector(hiveConnector);
 }
@@ -49,13 +53,12 @@ void HiveConnectorTestBase::TearDown() {
 }
 
 void HiveConnectorTestBase::resetHiveConnector(
-    const std::shared_ptr<const Config>& connectorProperties) {
+    const std::shared_ptr<const config::ConfigBase>& config) {
   connector::unregisterConnector(kHiveConnectorId);
   auto hiveConnector =
       connector::getConnectorFactory(
           connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              kHiveConnectorId, connectorProperties, ioExecutor_.get());
+          ->newConnector(kHiveConnectorId, config, ioExecutor_.get());
   connector::registerConnector(hiveConnector);
 }
 
@@ -68,15 +71,34 @@ void HiveConnectorTestBase::writeToFile(
 void HiveConnectorTestBase::writeToFile(
     const std::string& filePath,
     const std::vector<RowVectorPtr>& vectors,
-    std::shared_ptr<dwrf::Config> config) {
+    std::shared_ptr<dwrf::Config> config,
+    const std::function<std::unique_ptr<dwrf::DWRFFlushPolicy>()>&
+        flushPolicyFactory) {
+  writeToFile(
+      filePath,
+      vectors,
+      std::move(config),
+      vectors[0]->type(),
+      flushPolicyFactory);
+}
+
+void HiveConnectorTestBase::writeToFile(
+    const std::string& filePath,
+    const std::vector<RowVectorPtr>& vectors,
+    std::shared_ptr<dwrf::Config> config,
+    const TypePtr& schema,
+    const std::function<std::unique_ptr<dwrf::DWRFFlushPolicy>()>&
+        flushPolicyFactory) {
   velox::dwrf::WriterOptions options;
   options.config = config;
-  options.schema = vectors[0]->type();
+  options.schema = schema;
   auto localWriteFile = std::make_unique<LocalWriteFile>(filePath, true, false);
   auto sink = std::make_unique<dwio::common::WriteFileSink>(
       std::move(localWriteFile), filePath);
   auto childPool = rootPool_->addAggregateChild("HiveConnectorTestBase.Writer");
   options.memoryPool = childPool.get();
+  options.flushPolicyFactory = flushPolicyFactory;
+
   facebook::velox::dwrf::Writer writer{std::move(sink), options};
   for (size_t i = 0; i < vectors.size(); ++i) {
     writer.write(vectors[i]);
@@ -105,6 +127,19 @@ std::shared_ptr<exec::Task> HiveConnectorTestBase::assertQuery(
       plan, makeHiveConnectorSplits(filePaths), duckDbSql);
 }
 
+std::shared_ptr<Task> HiveConnectorTestBase::assertQuery(
+    const core::PlanNodePtr& plan,
+    const std::vector<std::shared_ptr<connector::ConnectorSplit>>& splits,
+    const std::string& duckDbSql,
+    const int32_t numPrefetchSplit) {
+  return AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(
+          core::QueryConfig::kMaxSplitPreloadPerDriver,
+          std::to_string(numPrefetchSplit))
+      .splits(splits)
+      .assertResults(duckDbSql);
+}
+
 std::vector<std::shared_ptr<TempFilePath>> HiveConnectorTestBase::makeFilePaths(
     int count) {
   std::vector<std::shared_ptr<TempFilePath>> filePaths;
@@ -120,7 +155,12 @@ std::vector<std::shared_ptr<connector::hive::HiveConnectorSplit>>
 HiveConnectorTestBase::makeHiveConnectorSplits(
     const std::string& filePath,
     uint32_t splitCount,
-    dwio::common::FileFormat format) {
+    dwio::common::FileFormat format,
+    const std::optional<
+        std::unordered_map<std::string, std::optional<std::string>>>&
+        partitionKeys,
+    const std::optional<std::unordered_map<std::string, std::string>>&
+        infoColumns) {
   auto file =
       filesystems::getFileSystem(filePath, nullptr)->openFileForRead(filePath);
   const int64_t fileSize = file->size();
@@ -129,17 +169,28 @@ HiveConnectorTestBase::makeHiveConnectorSplits(
   std::vector<std::shared_ptr<connector::hive::HiveConnectorSplit>> splits;
   // Add all the splits.
   for (int i = 0; i < splitCount; i++) {
-    auto split = HiveConnectorSplitBuilder(filePath)
-                     .fileFormat(format)
-                     .start(i * splitSize)
-                     .length(splitSize)
-                     .build();
+    auto splitBuilder = HiveConnectorSplitBuilder(filePath)
+                            .fileFormat(format)
+                            .start(i * splitSize)
+                            .length(splitSize);
+    if (infoColumns.has_value()) {
+      for (auto infoColumn : infoColumns.value()) {
+        splitBuilder.infoColumn(infoColumn.first, infoColumn.second);
+      }
+    }
+    if (partitionKeys.has_value()) {
+      for (auto partitionKey : partitionKeys.value()) {
+        splitBuilder.partitionKey(partitionKey.first, partitionKey.second);
+      }
+    }
+
+    auto split = splitBuilder.build();
     splits.push_back(std::move(split));
   }
   return splits;
 }
 
-std::shared_ptr<connector::hive::HiveColumnHandle>
+std::unique_ptr<connector::hive::HiveColumnHandle>
 HiveConnectorTestBase::makeColumnHandle(
     const std::string& name,
     const TypePtr& type,
@@ -147,24 +198,21 @@ HiveConnectorTestBase::makeColumnHandle(
   return makeColumnHandle(name, type, type, requiredSubfields);
 }
 
-std::shared_ptr<connector::hive::HiveColumnHandle>
+std::unique_ptr<connector::hive::HiveColumnHandle>
 HiveConnectorTestBase::makeColumnHandle(
     const std::string& name,
     const TypePtr& dataType,
     const TypePtr& hiveType,
-    const std::vector<std::string>& requiredSubfields) {
+    const std::vector<std::string>& requiredSubfields,
+    connector::hive::HiveColumnHandle::ColumnType columnType) {
   std::vector<common::Subfield> subfields;
   subfields.reserve(requiredSubfields.size());
   for (auto& path : requiredSubfields) {
     subfields.emplace_back(path);
   }
 
-  return std::make_shared<connector::hive::HiveColumnHandle>(
-      name,
-      connector::hive::HiveColumnHandle::ColumnType::kRegular,
-      dataType,
-      hiveType,
-      std::move(subfields));
+  return std::make_unique<connector::hive::HiveColumnHandle>(
+      name, columnType, dataType, hiveType, std::move(subfields));
 }
 
 std::vector<std::shared_ptr<connector::ConnectorSplit>>
@@ -172,17 +220,39 @@ HiveConnectorTestBase::makeHiveConnectorSplits(
     const std::vector<std::shared_ptr<TempFilePath>>& filePaths) {
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   for (auto filePath : filePaths) {
-    splits.push_back(makeHiveConnectorSplit(filePath->path));
+    splits.push_back(makeHiveConnectorSplit(
+        filePath->getPath(),
+        filePath->fileSize(),
+        filePath->fileModifiedTime(),
+        0,
+        std::numeric_limits<uint64_t>::max()));
   }
   return splits;
 }
 
-std::shared_ptr<connector::ConnectorSplit>
+std::shared_ptr<connector::hive::HiveConnectorSplit>
 HiveConnectorTestBase::makeHiveConnectorSplit(
     const std::string& filePath,
     uint64_t start,
+    uint64_t length,
+    int64_t splitWeight) {
+  return HiveConnectorSplitBuilder(filePath)
+      .start(start)
+      .length(length)
+      .splitWeight(splitWeight)
+      .build();
+}
+
+std::shared_ptr<connector::hive::HiveConnectorSplit>
+HiveConnectorTestBase::makeHiveConnectorSplit(
+    const std::string& filePath,
+    int64_t fileSize,
+    int64_t fileModifiedTime,
+    uint64_t start,
     uint64_t length) {
   return HiveConnectorSplitBuilder(filePath)
+      .infoColumn("$file_size", fmt::format("{}", fileSize))
+      .infoColumn("$file_modified_time", fmt::format("{}", fileModifiedTime))
       .start(start)
       .length(length)
       .build();
@@ -196,7 +266,8 @@ HiveConnectorTestBase::makeHiveInsertTableHandle(
     const std::vector<std::string>& partitionedBy,
     std::shared_ptr<connector::hive::LocationHandle> locationHandle,
     const dwio::common::FileFormat tableStorageFormat,
-    const std::optional<common::CompressionKind> compressionKind) {
+    const std::optional<common::CompressionKind> compressionKind,
+    const std::shared_ptr<dwio::common::WriterOptions>& writerOptions) {
   return makeHiveInsertTableHandle(
       tableColumnNames,
       tableColumnTypes,
@@ -204,7 +275,8 @@ HiveConnectorTestBase::makeHiveInsertTableHandle(
       nullptr,
       std::move(locationHandle),
       tableStorageFormat,
-      compressionKind);
+      compressionKind,
+      writerOptions);
 }
 
 // static
@@ -216,7 +288,8 @@ HiveConnectorTestBase::makeHiveInsertTableHandle(
     std::shared_ptr<connector::hive::HiveBucketProperty> bucketProperty,
     std::shared_ptr<connector::hive::LocationHandle> locationHandle,
     const dwio::common::FileFormat tableStorageFormat,
-    const std::optional<common::CompressionKind> compressionKind) {
+    const std::optional<common::CompressionKind> compressionKind,
+    const std::shared_ptr<dwio::common::WriterOptions>& writerOptions) {
   std::vector<std::shared_ptr<const connector::hive::HiveColumnHandle>>
       columnHandles;
   std::vector<std::string> bucketedBy;
@@ -265,12 +338,15 @@ HiveConnectorTestBase::makeHiveInsertTableHandle(
   VELOX_CHECK_EQ(numPartitionColumns, partitionedBy.size());
   VELOX_CHECK_EQ(numBucketColumns, bucketedBy.size());
   VELOX_CHECK_EQ(numSortingColumns, sortedBy.size());
+
   return std::make_shared<connector::hive::HiveInsertTableHandle>(
       columnHandles,
       locationHandle,
       tableStorageFormat,
       bucketProperty,
-      compressionKind);
+      compressionKind,
+      std::unordered_map<std::string, std::string>{},
+      writerOptions);
 }
 
 std::shared_ptr<connector::hive::HiveColumnHandle>
diff --git a/velox/exec/tests/utils/HiveConnectorTestBase.h b/velox/exec/tests/utils/HiveConnectorTestBase.h
index 56682a63f29f0..b7ab31d4e16d2 100644
--- a/velox/exec/tests/utils/HiveConnectorTestBase.h
+++ b/velox/exec/tests/utils/HiveConnectorTestBase.h
@@ -20,6 +20,7 @@
 #include "velox/connectors/hive/HiveDataSink.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/dwio/dwrf/common/Config.h"
+#include "velox/dwio/dwrf/writer/FlushPolicy.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/TempFilePath.h"
@@ -40,7 +41,7 @@ class HiveConnectorTestBase : public OperatorTestBase {
   void TearDown() override;
 
   void resetHiveConnector(
-      const std::shared_ptr<const Config>& connectorProperties);
+      const std::shared_ptr<const config::ConfigBase>& config);
 
   void writeToFile(const std::string& filePath, RowVectorPtr vector);
 
@@ -48,7 +49,17 @@ class HiveConnectorTestBase : public OperatorTestBase {
       const std::string& filePath,
       const std::vector<RowVectorPtr>& vectors,
       std::shared_ptr<dwrf::Config> config =
-          std::make_shared<facebook::velox::dwrf::Config>());
+          std::make_shared<facebook::velox::dwrf::Config>(),
+      const std::function<std::unique_ptr<dwrf::DWRFFlushPolicy>()>&
+          flushPolicyFactory = nullptr);
+
+  void writeToFile(
+      const std::string& filePath,
+      const std::vector<RowVectorPtr>& vectors,
+      std::shared_ptr<dwrf::Config> config,
+      const TypePtr& schema,
+      const std::function<std::unique_ptr<dwrf::DWRFFlushPolicy>()>&
+          flushPolicyFactory = nullptr);
 
   std::vector<RowVectorPtr> makeVectors(
       const RowTypePtr& rowType,
@@ -63,16 +74,32 @@ class HiveConnectorTestBase : public OperatorTestBase {
       const std::vector<std::shared_ptr<TempFilePath>>& filePaths,
       const std::string& duckDbSql);
 
+  std::shared_ptr<Task> assertQuery(
+      const core::PlanNodePtr& plan,
+      const std::vector<std::shared_ptr<connector::ConnectorSplit>>& splits,
+      const std::string& duckDbSql,
+      const int32_t numPrefetchSplit);
+
   static std::vector<std::shared_ptr<TempFilePath>> makeFilePaths(int count);
 
   static std::vector<std::shared_ptr<connector::ConnectorSplit>>
   makeHiveConnectorSplits(
       const std::vector<std::shared_ptr<TempFilePath>>& filePaths);
 
-  static std::shared_ptr<connector::ConnectorSplit> makeHiveConnectorSplit(
+  static std::shared_ptr<connector::hive::HiveConnectorSplit>
+  makeHiveConnectorSplit(
       const std::string& filePath,
       uint64_t start = 0,
-      uint64_t length = std::numeric_limits<uint64_t>::max());
+      uint64_t length = std::numeric_limits<uint64_t>::max(),
+      int64_t splitWeight = 0);
+
+  static std::shared_ptr<connector::hive::HiveConnectorSplit>
+  makeHiveConnectorSplit(
+      const std::string& filePath,
+      int64_t fileSize,
+      int64_t fileModifiedTime,
+      uint64_t start,
+      uint64_t length);
 
   /// Split file at path 'filePath' into 'splitCount' splits. If not local file,
   /// file size can be given as 'externalSize'.
@@ -80,7 +107,12 @@ class HiveConnectorTestBase : public OperatorTestBase {
   makeHiveConnectorSplits(
       const std::string& filePath,
       uint32_t splitCount,
-      dwio::common::FileFormat format);
+      dwio::common::FileFormat format,
+      const std::optional<
+          std::unordered_map<std::string, std::optional<std::string>>>&
+          partitionKeys = {},
+      const std::optional<std::unordered_map<std::string, std::string>>&
+          infoColumns = {});
 
   static std::shared_ptr<connector::hive::HiveTableHandle> makeTableHandle(
       common::test::SubfieldFilters subfieldFilters = {},
@@ -100,7 +132,7 @@ class HiveConnectorTestBase : public OperatorTestBase {
   /// @param name Column name.
   /// @param type Column type.
   /// @param Required subfields of this column.
-  static std::shared_ptr<connector::hive::HiveColumnHandle> makeColumnHandle(
+  static std::unique_ptr<connector::hive::HiveColumnHandle> makeColumnHandle(
       const std::string& name,
       const TypePtr& type,
       const std::vector<std::string>& requiredSubfields);
@@ -109,11 +141,13 @@ class HiveConnectorTestBase : public OperatorTestBase {
   /// @param type Column type.
   /// @param type Hive type.
   /// @param Required subfields of this column.
-  static std::shared_ptr<connector::hive::HiveColumnHandle> makeColumnHandle(
+  static std::unique_ptr<connector::hive::HiveColumnHandle> makeColumnHandle(
       const std::string& name,
       const TypePtr& dataType,
       const TypePtr& hiveType,
-      const std::vector<std::string>& requiredSubfields);
+      const std::vector<std::string>& requiredSubfields,
+      connector::hive::HiveColumnHandle::ColumnType columnType =
+          connector::hive::HiveColumnHandle::ColumnType::kRegular);
 
   /// @param targetDirectory Final directory of the target table after commit.
   /// @param writeDirectory Write directory of the target table before commit.
@@ -148,7 +182,9 @@ class HiveConnectorTestBase : public OperatorTestBase {
       std::shared_ptr<connector::hive::LocationHandle> locationHandle,
       const dwio::common::FileFormat tableStorageFormat =
           dwio::common::FileFormat::DWRF,
-      const std::optional<common::CompressionKind> compressionKind = {});
+      const std::optional<common::CompressionKind> compressionKind = {},
+      const std::shared_ptr<dwio::common::WriterOptions>& writerOptions =
+          nullptr);
 
   static std::shared_ptr<connector::hive::HiveInsertTableHandle>
   makeHiveInsertTableHandle(
@@ -158,7 +194,9 @@ class HiveConnectorTestBase : public OperatorTestBase {
       std::shared_ptr<connector::hive::LocationHandle> locationHandle,
       const dwio::common::FileFormat tableStorageFormat =
           dwio::common::FileFormat::DWRF,
-      const std::optional<common::CompressionKind> compressionKind = {});
+      const std::optional<common::CompressionKind> compressionKind = {},
+      const std::shared_ptr<dwio::common::WriterOptions>& writerOptions =
+          nullptr);
 
   static std::shared_ptr<connector::hive::HiveColumnHandle> regularColumn(
       const std::string& name,
@@ -181,10 +219,6 @@ class HiveConnectorTestBase : public OperatorTestBase {
     }
     return assignments;
   }
-
-  memory::MemoryAllocator* allocator() {
-    return memory::MemoryAllocator::getInstance();
-  }
 };
 
 class HiveConnectorSplitBuilder {
@@ -202,11 +236,23 @@ class HiveConnectorSplitBuilder {
     return *this;
   }
 
+  HiveConnectorSplitBuilder& splitWeight(int64_t splitWeight) {
+    splitWeight_ = splitWeight;
+    return *this;
+  }
+
   HiveConnectorSplitBuilder& fileFormat(dwio::common::FileFormat format) {
     fileFormat_ = format;
     return *this;
   }
 
+  HiveConnectorSplitBuilder& infoColumn(
+      const std::string& name,
+      const std::string& value) {
+    infoColumns_.emplace(std::move(name), std::move(value));
+    return *this;
+  }
+
   HiveConnectorSplitBuilder& partitionKey(
       std::string name,
       std::optional<std::string> value) {
@@ -219,15 +265,47 @@ class HiveConnectorSplitBuilder {
     return *this;
   }
 
+  HiveConnectorSplitBuilder& customSplitInfo(
+      const std::unordered_map<std::string, std::string>& customSplitInfo) {
+    customSplitInfo_ = customSplitInfo;
+    return *this;
+  }
+
+  HiveConnectorSplitBuilder& extraFileInfo(
+      const std::shared_ptr<std::string>& extraFileInfo) {
+    extraFileInfo_ = extraFileInfo;
+    return *this;
+  }
+
+  HiveConnectorSplitBuilder& serdeParameters(
+      const std::unordered_map<std::string, std::string>& serdeParameters) {
+    serdeParameters_ = serdeParameters;
+    return *this;
+  }
+
+  HiveConnectorSplitBuilder& connectorId(const std::string& connectorId) {
+    connectorId_ = connectorId;
+    return *this;
+  }
+
   std::shared_ptr<connector::hive::HiveConnectorSplit> build() const {
+    static const std::unordered_map<std::string, std::string> customSplitInfo;
+    static const std::shared_ptr<std::string> extraFileInfo;
+    static const std::unordered_map<std::string, std::string> serdeParameters;
     return std::make_shared<connector::hive::HiveConnectorSplit>(
-        kHiveConnectorId,
+        connectorId_,
         filePath_.find("/") == 0 ? "file:" + filePath_ : filePath_,
         fileFormat_,
         start_,
         length_,
         partitionKeys_,
-        tableBucketNumber_);
+        tableBucketNumber_,
+        customSplitInfo,
+        extraFileInfo,
+        serdeParameters,
+        splitWeight_,
+        infoColumns_,
+        std::nullopt);
   }
 
  private:
@@ -237,6 +315,12 @@ class HiveConnectorSplitBuilder {
   uint64_t length_{std::numeric_limits<uint64_t>::max()};
   std::unordered_map<std::string, std::optional<std::string>> partitionKeys_;
   std::optional<int32_t> tableBucketNumber_;
+  std::unordered_map<std::string, std::string> customSplitInfo_ = {};
+  std::shared_ptr<std::string> extraFileInfo_ = {};
+  std::unordered_map<std::string, std::string> serdeParameters_ = {};
+  std::unordered_map<std::string, std::string> infoColumns_ = {};
+  std::string connectorId_ = kHiveConnectorId;
+  int64_t splitWeight_{0};
 };
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/LocalExchangeSource.cpp b/velox/exec/tests/utils/LocalExchangeSource.cpp
index 1366e25d17565..9d012c908c95e 100644
--- a/velox/exec/tests/utils/LocalExchangeSource.cpp
+++ b/velox/exec/tests/utils/LocalExchangeSource.cpp
@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 #include "velox/exec/tests/utils/LocalExchangeSource.h"
+#include <folly/executors/IOThreadPoolExecutor.h>
+#include <atomic>
 #include "velox/common/testutil/TestValue.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/OutputBufferManager.h"
 
 namespace facebook::velox::exec::test {
 namespace {
@@ -29,7 +31,7 @@ class LocalExchangeSource : public exec::ExchangeSource {
       memory::MemoryPool* pool)
       : ExchangeSource(taskId, destination, queue, pool) {}
 
-  bool supportsFlowControlV2() const override {
+  bool supportsMetrics() const override {
     return true;
   }
 
@@ -42,127 +44,228 @@ class LocalExchangeSource : public exec::ExchangeSource {
 
   folly::SemiFuture<Response> request(
       uint32_t maxBytes,
-      uint32_t /*maxWaitSeconds*/) override {
+      std::chrono::microseconds maxWait) override {
     ++numRequests_;
 
     auto promise = VeloxPromise<Response>("LocalExchangeSource::request");
     auto future = promise.getSemiFuture();
 
-    if (numRequests_ % 2 == 0) {
-      {
-        std::lock_guard<std::mutex> l(queue_->mutex());
-        requestPending_ = false;
-      }
-      // Simulate no-data.
-      promise.setValue(Response{0, false});
-      return future;
-    }
-
     promise_ = std::move(promise);
 
-    auto buffers = PartitionedOutputBufferManager::getInstance().lock();
-    VELOX_CHECK_NOT_NULL(buffers, "invalid PartitionedOutputBufferManager");
+    auto buffers = OutputBufferManager::getInstance().lock();
+    VELOX_CHECK_NOT_NULL(buffers, "invalid OutputBufferManager");
     VELOX_CHECK(requestPending_);
     auto requestedSequence = sequence_;
     auto self = shared_from_this();
-    buffers->getData(
-        taskId_,
-        destination_,
-        maxBytes,
-        sequence_,
-        // Since this lambda may outlive 'this', we need to capture a
-        // shared_ptr to the current object (self).
-        [self, requestedSequence, buffers, this](
-            std::vector<std::unique_ptr<folly::IOBuf>> data, int64_t sequence) {
-          if (requestedSequence > sequence) {
-            VLOG(2) << "Receives earlier sequence than requested: task "
-                    << taskId_ << ", destination " << destination_
-                    << ", requested " << sequence << ", received "
-                    << requestedSequence;
-            int64_t nExtra = requestedSequence - sequence;
-            VELOX_CHECK(nExtra < data.size());
-            data.erase(data.begin(), data.begin() + nExtra);
-            sequence = requestedSequence;
+    // Since this lambda may outlive 'this', we need to capture a
+    // shared_ptr to the current object (self).
+    auto resultCallback = [self, requestedSequence, buffers, this](
+                              std::vector<std::unique_ptr<folly::IOBuf>> data,
+                              int64_t sequence,
+                              std::vector<int64_t> remainingBytes) {
+      {
+        std::lock_guard<std::mutex> l(mutex_);
+        // This function is called either for a result or timeout. Only the
+        // first of these calls has an effect.
+        auto iter = timeouts_.find(self);
+        if (iter == timeouts_.end()) {
+          return;
+        }
+        timeouts_.erase(iter);
+      }
+
+      if (requestedSequence > sequence && !data.empty()) {
+        VLOG(2) << "Receives earlier sequence than requested: task " << taskId_
+                << ", destination " << destination_ << ", requested "
+                << sequence << ", received " << requestedSequence;
+        int64_t nExtra = requestedSequence - sequence;
+        VELOX_CHECK(nExtra < data.size());
+        data.erase(data.begin(), data.begin() + nExtra);
+        sequence = requestedSequence;
+      }
+      if (data.empty()) {
+        sequence = requestedSequence;
+      }
+      std::vector<std::unique_ptr<SerializedPage>> pages;
+      bool atEnd = false;
+      int64_t totalBytes = 0;
+      for (auto& inputPage : data) {
+        if (!inputPage) {
+          atEnd = true;
+          // Keep looping, there could be extra end markers.
+          continue;
+        }
+        totalBytes += inputPage->length();
+        inputPage->unshare();
+        pages.push_back(std::make_unique<SerializedPage>(std::move(inputPage)));
+        inputPage = nullptr;
+      }
+      numPages_ += pages.size();
+      totalBytes_ += totalBytes;
+      if (data.empty()) {
+        common::testutil::TestValue::adjust(
+            "facebook::velox::exec::test::LocalExchangeSource::timeout", this);
+      }
+
+      try {
+        common::testutil::TestValue::adjust(
+            "facebook::velox::exec::test::LocalExchangeSource", this);
+      } catch (const std::exception& e) {
+        queue_->setError(e.what());
+        checkSetRequestPromise();
+        return;
+      }
+
+      VeloxPromise<Response> requestPromise;
+      {
+        std::vector<ContinuePromise> queuePromises;
+        {
+          std::lock_guard<std::mutex> l(queue_->mutex());
+          requestPending_ = false;
+          requestPromise = std::move(promise_);
+          for (auto& page : pages) {
+            queue_->enqueueLocked(std::move(page), queuePromises);
           }
-          std::vector<std::unique_ptr<SerializedPage>> pages;
-          bool atEnd = false;
-          int64_t totalBytes = 0;
-          for (auto& inputPage : data) {
-            if (!inputPage) {
-              atEnd = true;
-              // Keep looping, there could be extra end markers.
-              continue;
-            }
-            totalBytes += inputPage->length();
-            inputPage->unshare();
-            pages.push_back(
-                std::make_unique<SerializedPage>(std::move(inputPage)));
-            inputPage = nullptr;
+          if (atEnd) {
+            queue_->enqueueLocked(nullptr, queuePromises);
+            atEnd_ = true;
           }
-          numPages_ += pages.size();
-          totalBytes_ += totalBytes;
-
-          try {
-            common::testutil::TestValue::adjust(
-                "facebook::velox::exec::test::LocalExchangeSource", &numPages_);
-          } catch (const std::exception& e) {
-            queue_->setError(e.what());
-            checkSetRequestPromise();
-            return;
+          if (!data.empty()) {
+            sequence_ = sequence + pages.size();
           }
+        }
+        for (auto& promise : queuePromises) {
+          promise.setValue();
+        }
+      }
+      // Outside of queue mutex.
+      if (atEnd_) {
+        buffers->deleteResults(taskId_, destination_);
+      }
 
-          int64_t ackSequence;
-          VeloxPromise<Response> requestPromise;
-          {
-            std::vector<ContinuePromise> queuePromises;
-            {
-              std::lock_guard<std::mutex> l(queue_->mutex());
-              requestPending_ = false;
-              requestPromise = std::move(promise_);
-              for (auto& page : pages) {
-                queue_->enqueueLocked(std::move(page), queuePromises);
-              }
-              if (atEnd) {
-                queue_->enqueueLocked(nullptr, queuePromises);
-                atEnd_ = true;
-              }
-              ackSequence = sequence_ = sequence + pages.size();
-            }
-            for (auto& promise : queuePromises) {
-              promise.setValue();
-            }
-          }
-          // Outside of queue mutex.
-          if (atEnd_) {
-            buffers->deleteResults(taskId_, destination_);
-          } else {
-            buffers->acknowledge(taskId_, destination_, ackSequence);
-          }
+      if (!requestPromise.isFulfilled()) {
+        requestPromise.setValue(Response{totalBytes, atEnd_, remainingBytes});
+      }
+    };
 
-          if (!requestPromise.isFulfilled()) {
-            requestPromise.setValue(Response{totalBytes, atEnd_});
-          }
-        });
+    registerTimeout(self, resultCallback, maxWait);
+
+    buffers->getData(
+        taskId_, destination_, maxBytes, sequence_, resultCallback);
 
     return future;
   }
 
+  folly::SemiFuture<Response> requestDataSizes(
+      std::chrono::microseconds maxWait) override {
+    return request(0, maxWait);
+  }
+
+  void pause() override {
+    common::testutil::TestValue::adjust(
+        "facebook::velox::exec::test::LocalExchangeSource::pause", nullptr);
+    auto buffers = OutputBufferManager::getInstance().lock();
+    VELOX_CHECK_NOT_NULL(buffers, "invalid OutputBufferManager");
+    int64_t ackSequence;
+    {
+      std::lock_guard<std::mutex> l(queue_->mutex());
+      ackSequence = sequence_;
+    }
+    buffers->acknowledge(taskId_, destination_, ackSequence);
+  }
+
   void close() override {
     checkSetRequestPromise();
 
-    auto buffers = PartitionedOutputBufferManager::getInstance().lock();
+    auto buffers = OutputBufferManager::getInstance().lock();
     buffers->deleteResults(taskId_, destination_);
   }
 
-  folly::F14FastMap<std::string, int64_t> stats() const override {
+  folly::F14FastMap<std::string, RuntimeMetric> metrics() const override {
     return {
-        {"localExchangeSource.numPages", numPages_},
-        {"localExchangeSource.totalBytes", totalBytes_},
-        {ExchangeClient::kBackgroundCpuTimeMs, 123},
+        {"localExchangeSource.numPages", RuntimeMetric(numPages_)},
+        {"localExchangeSource.totalBytes",
+         RuntimeMetric(totalBytes_, RuntimeCounter::Unit::kBytes)},
+        {ExchangeClient::kBackgroundCpuTimeMs,
+         RuntimeMetric(123 * 1000000, RuntimeCounter::Unit::kNanos)},
     };
   }
 
+  // Invoked to start exchange source to run. It clears 'stop_' which allows
+  // the background timeout executor to run on the first exchange source
+  // request.
+  static void start() {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK_NULL(timerThread_);
+    VELOX_CHECK(timeouts_.empty());
+    stop_ = false;
+  }
+
+  // Invoked to stop the exchange source. It sets 'stop_', clears the current
+  // pending request 'timeouts_' and join/destroy 'timeoutCheckExecutor_' if
+  // created.
+  static void stop() {
+    {
+      std::lock_guard<std::mutex> l(mutex_);
+      if (stop_) {
+        VELOX_CHECK(timeouts_.empty());
+        return;
+      }
+      stop_ = true;
+      if (timerThread_ == nullptr) {
+        VELOX_CHECK(timeouts_.empty());
+        return;
+      }
+      timeouts_.clear();
+    }
+    timerThread_->join();
+    timerThread_.reset();
+  }
+
  private:
+  using ResultCallback = std::function<void(
+      std::vector<std::unique_ptr<folly::IOBuf>> data,
+      int64_t sequence,
+      std::vector<int64_t> remainingBytes)>;
+
+  static void registerTimeout(
+      const std::shared_ptr<ExchangeSource>& self,
+      ResultCallback callback,
+      std::chrono::microseconds maxWait) {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(!stop_, "Local exchange source has stopped");
+
+    if (timerThread_ == nullptr) {
+      timerThread_ = std::make_unique<std::thread>([&]() {
+        while (!stop_) {
+          auto now = std::chrono::system_clock::now();
+          ResultCallback callback = nullptr;
+          {
+            std::lock_guard<std::mutex> t(mutex_);
+            for (auto& pair : timeouts_) {
+              if (pair.second.second < now) {
+                callback = pair.second.first;
+                break;
+              }
+            }
+          }
+          if (callback) {
+            // Outside of mutex.
+            callback({}, 0, {});
+            continue;
+          }
+          std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+      });
+      if (!exitInitialized_) {
+        exitInitialized_ = true;
+        atexit([]() { stop(); });
+      }
+    }
+    timeouts_[self] =
+        std::make_pair(callback, std::chrono::system_clock::now() + maxWait);
+  }
+
   bool checkSetRequestPromise() {
     VeloxPromise<Response> promise;
     {
@@ -170,20 +273,28 @@ class LocalExchangeSource : public exec::ExchangeSource {
       promise = std::move(promise_);
     }
     if (promise.valid() && !promise.isFulfilled()) {
-      promise.setValue(Response{0, false});
+      promise.setValue(Response{0, false, {}});
       return true;
     }
 
     return false;
   }
 
+  static inline std::mutex mutex_;
+  static inline folly::F14FastMap<
+      std::shared_ptr<ExchangeSource>,
+      std::pair<ResultCallback, std::chrono::system_clock::time_point>>
+      timeouts_;
+  static inline std::unique_ptr<std::thread> timerThread_;
+  static inline std::atomic_bool stop_{false};
+  static inline bool exitInitialized_{false};
+
   // Records the total number of pages fetched from sources.
   std::atomic<int64_t> numPages_{0};
   std::atomic<uint64_t> totalBytes_{0};
   VeloxPromise<Response> promise_{VeloxPromise<Response>::makeEmpty()};
   int32_t numRequests_{0};
 };
-
 } // namespace
 
 std::unique_ptr<ExchangeSource> createLocalExchangeSource(
@@ -200,4 +311,12 @@ std::unique_ptr<ExchangeSource> createLocalExchangeSource(
   return nullptr;
 }
 
+void testingStartLocalExchangeSource() {
+  LocalExchangeSource::start();
+}
+
+void testingShutdownLocalExchangeSource() {
+  LocalExchangeSource::stop();
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/LocalExchangeSource.h b/velox/exec/tests/utils/LocalExchangeSource.h
index 7e366cecc62b7..2a69f6343af26 100644
--- a/velox/exec/tests/utils/LocalExchangeSource.h
+++ b/velox/exec/tests/utils/LocalExchangeSource.h
@@ -19,11 +19,21 @@
 namespace facebook::velox::exec::test {
 
 /// Given taskId that starts with local:// returns an instance of ExchangeSource
-/// that fetches data from local PartitionedoutputBufferManager.
+/// that fetches data from local OutputBufferManager.
 std::unique_ptr<exec::ExchangeSource> createLocalExchangeSource(
     const std::string& taskId,
     int destination,
     std::shared_ptr<exec::ExchangeQueue> queue,
     memory::MemoryPool* pool);
 
+/// Sets the local exchange source to start by clearing 'stop_'. This is used
+/// when we run multiple test cases sequentially and restarts the local exchange
+/// source between tests.
+void testingStartLocalExchangeSource();
+
+/// Ensures that there are no references to ExchangeSource callbacks,
+/// e.g. while waiting for timing out. Call this before end of unit
+/// tests to ensure no ASAN errors at exit.
+void testingShutdownLocalExchangeSource();
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/OperatorTestBase.cpp b/velox/exec/tests/utils/OperatorTestBase.cpp
index d88a0072e76fb..762f94e07e3a2 100644
--- a/velox/exec/tests/utils/OperatorTestBase.cpp
+++ b/velox/exec/tests/utils/OperatorTestBase.cpp
@@ -15,28 +15,40 @@
  */
 
 #include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/common/base/PeriodicStatsReporter.h"
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/memory/MallocAllocator.h"
+#include "velox/common/memory/SharedArbitrator.h"
 #include "velox/common/testutil/TestValue.h"
-#include "velox/dwio/common/FileSink.h"
-#include "velox/exec/Exchange.h"
-#include "velox/exec/PartitionedOutputBufferManager.h"
+#include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/LocalExchangeSource.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 #include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
-using namespace facebook::velox::common::testutil;
-
+DECLARE_bool(velox_memory_leak_check_enabled);
 DECLARE_bool(velox_enable_memory_usage_track_in_default_memory_pool);
 
+using namespace facebook::velox::common::testutil;
+using namespace facebook::velox::memory;
+
 namespace facebook::velox::exec::test {
 
 OperatorTestBase::OperatorTestBase() {
+  // Overloads the memory pools used by VectorTestBase to work with memory
+  // arbitrator.
+  rootPool_ = memory::memoryManager()->addRootPool(
+      "", memory::kMaxMemory, exec::MemoryReclaimer::create());
+  pool_ = rootPool_->addLeafChild("", true, exec::MemoryReclaimer::create());
+  vectorMaker_ = velox::test::VectorMaker(pool_.get());
+
   parse::registerTypeResolver();
 }
 
@@ -47,21 +59,52 @@ void OperatorTestBase::registerVectorSerde() {
 OperatorTestBase::~OperatorTestBase() {
   // Wait for all the tasks to be deleted.
   exec::test::waitForAllTasksToBeDeleted();
-  // Revert to default process-wide MemoryAllocator.
-  memory::MemoryAllocator::setDefaultInstance(nullptr);
 }
 
 void OperatorTestBase::SetUpTestCase() {
   FLAGS_velox_enable_memory_usage_track_in_default_memory_pool = true;
-  memory::MemoryArbitrator::registerAllFactories();
+  FLAGS_velox_memory_leak_check_enabled = true;
+  memory::SharedArbitrator::registerFactory();
+  resetMemory();
   functions::prestosql::registerAllScalarFunctions();
   aggregate::prestosql::registerAllAggregateFunctions();
   TestValue::enable();
 }
 
 void OperatorTestBase::TearDownTestCase() {
+  asyncDataCache_->shutdown();
   waitForAllTasksToBeDeleted();
-  memory::MemoryArbitrator::unregisterAllFactories();
+  memory::SharedArbitrator::unregisterFactory();
+}
+
+void OperatorTestBase::setupMemory(
+    int64_t allocatorCapacity,
+    int64_t arbitratorCapacity,
+    int64_t arbitratorReservedCapacity,
+    int64_t memoryPoolInitCapacity,
+    int64_t memoryPoolReservedCapacity) {
+  if (asyncDataCache_ != nullptr) {
+    asyncDataCache_->clear();
+    asyncDataCache_.reset();
+  }
+  MemoryManagerOptions options;
+  options.allocatorCapacity = allocatorCapacity;
+  options.arbitratorCapacity = arbitratorCapacity;
+  options.arbitratorReservedCapacity = arbitratorReservedCapacity;
+  options.memoryPoolInitCapacity = memoryPoolInitCapacity;
+  options.memoryPoolReservedCapacity = memoryPoolReservedCapacity;
+  options.arbitratorKind = "SHARED";
+  options.checkUsageLeak = true;
+  options.globalArbitrationEnabled = true;
+  options.arbitrationStateCheckCb = memoryArbitrationStateCheck;
+  memory::MemoryManager::testingSetInstance(options);
+  asyncDataCache_ =
+      cache::AsyncDataCache::create(memory::memoryManager()->allocator());
+  cache::AsyncDataCache::setInstance(asyncDataCache_.get());
+}
+
+void OperatorTestBase::resetMemory() {
+  OperatorTestBase::setupMemory(8L << 30, 6L << 30, 0, 512 << 20, 0);
 }
 
 void OperatorTestBase::SetUp() {
@@ -70,18 +113,29 @@ void OperatorTestBase::SetUp() {
   }
   driverExecutor_ = std::make_unique<folly::CPUThreadPoolExecutor>(3);
   ioExecutor_ = std::make_unique<folly::IOThreadPoolExecutor>(3);
-  allocator_ = std::make_shared<memory::MallocAllocator>(8L << 30);
-  if (!asyncDataCache_) {
-    asyncDataCache_ = cache::AsyncDataCache::create(allocator_.get());
-    cache::AsyncDataCache::setInstance(asyncDataCache_.get());
-  }
-  memory::MemoryAllocator::setDefaultInstance(allocator_.get());
+  PeriodicStatsReporter::Options options;
+  options.allocator = memory::memoryManager()->allocator();
+  options.allocatorStatsIntervalMs = 2'000;
+  options.cache = asyncDataCache_.get();
+  options.cacheStatsIntervalMs = 2'000;
+  options.arbitrator = memory::memoryManager()->arbitrator();
+  options.arbitratorStatsIntervalMs = 2'000;
+  options.spillMemoryPool = memory::spillMemoryPool();
+  options.spillStatsIntervalMs = 2'000;
+  startPeriodicStatsReporter(options);
+  testingStartLocalExchangeSource();
 }
 
 void OperatorTestBase::TearDown() {
-  if (asyncDataCache_ != nullptr) {
-    asyncDataCache_->shutdown();
-  }
+  waitForAllTasksToBeDeleted();
+  stopPeriodicStatsReporter();
+  // There might be lingering exchange source on executor even after all tasks
+  // are deleted. This can cause memory leak because exchange source holds
+  // reference to memory pool. We need to make sure they are properly cleaned.
+  testingShutdownLocalExchangeSource();
+  pool_.reset();
+  rootPool_.reset();
+  resetMemory();
 }
 
 std::shared_ptr<Task> OperatorTestBase::assertQuery(
diff --git a/velox/exec/tests/utils/OperatorTestBase.h b/velox/exec/tests/utils/OperatorTestBase.h
index 7900b94f95aab..15141fbc09387 100644
--- a/velox/exec/tests/utils/OperatorTestBase.h
+++ b/velox/exec/tests/utils/OperatorTestBase.h
@@ -21,6 +21,7 @@
 #include "velox/common/caching/SsdCache.h"
 #include "velox/core/Expressions.h"
 #include "velox/core/PlanNode.h"
+#include "velox/exec/HashProbe.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/type/Variant.h"
@@ -31,6 +32,27 @@
 namespace facebook::velox::exec::test {
 class OperatorTestBase : public testing::Test,
                          public velox::test::VectorTestBase {
+ public:
+  /// The following methods are used by google unit test framework to do
+  /// one-time setup/teardown for all the unit tests from OperatorTestBase. We
+  /// make them public as some benchmark like ReduceAgg also call these methods
+  /// to setup/teardown benchmark test environment.
+  static void SetUpTestCase();
+  static void TearDownTestCase();
+
+  /// Sets up the velox memory system.
+  ///
+  /// NOTE: a second call to this will clear the previous memory system
+  /// instances and create a new set.
+  static void setupMemory(
+      int64_t allocatorCapacity,
+      int64_t arbitratorCapacity,
+      int64_t arbitratorReservedCapacity,
+      int64_t memoryPoolInitCapacity,
+      int64_t memoryPoolReservedCapacity);
+
+  static void resetMemory();
+
  protected:
   OperatorTestBase();
   ~OperatorTestBase() override;
@@ -43,10 +65,6 @@ class OperatorTestBase : public testing::Test,
   /// By default, registers Presto-compatible serde.
   virtual void registerVectorSerde();
 
-  static void SetUpTestCase();
-
-  static void TearDownTestCase();
-
   void createDuckDbTable(const std::vector<RowVectorPtr>& data) {
     duckDbQueryRunner_.createTable("tmp", data);
   }
@@ -139,13 +157,10 @@ class OperatorTestBase : public testing::Test,
   static void deleteTaskAndCheckSpillDirectory(std::shared_ptr<Task>& task);
 
  protected:
-  DuckDbQueryRunner duckDbQueryRunner_;
-
-  // Used as default MemoryAllocator.
-  std::shared_ptr<memory::MemoryAllocator> allocator_;
-
   // Used as default AsyncDataCache.
-  std::shared_ptr<cache::AsyncDataCache> asyncDataCache_;
+  static inline std::shared_ptr<cache::AsyncDataCache> asyncDataCache_;
+
+  DuckDbQueryRunner duckDbQueryRunner_;
 
   // Used for driver thread execution.
   std::unique_ptr<folly::CPUThreadPoolExecutor> driverExecutor_;
diff --git a/velox/exec/tests/utils/PlanBuilder.cpp b/velox/exec/tests/utils/PlanBuilder.cpp
index aacedfd75c2ba..27baada36c32e 100644
--- a/velox/exec/tests/utils/PlanBuilder.cpp
+++ b/velox/exec/tests/utils/PlanBuilder.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/TableHandle.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/duckdb/conversion/DuckParser.h"
 #include "velox/exec/Aggregate.h"
@@ -24,21 +25,13 @@
 #include "velox/exec/TableWriter.h"
 #include "velox/exec/WindowFunction.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/expression/Expr.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/expression/FunctionCallToSpecialForm.h"
 #include "velox/expression/SignatureBinder.h"
 #include "velox/parse/Expressions.h"
 #include "velox/parse/TypeResolver.h"
 
-#ifndef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-#include "velox/connectors/hive/TableHandle.h"
-#include "velox/expression/Expr.h"
-#else
-#include <velox/core/ITypedExpr.h>
-#include "velox/common/memory/Memory.h"
-#include "velox/parse/ExpressionsParser.h"
-#endif
-
 using namespace facebook::velox;
 using namespace facebook::velox::connector;
 using namespace facebook::velox::connector::hive;
@@ -47,10 +40,6 @@ namespace facebook::velox::exec::test {
 
 namespace {
 
-// TODO Avoid duplication.
-static const std::string kHiveConnectorId = "test-hive";
-static const std::string kTpchConnectorId = "test-tpch";
-
 core::TypedExprPtr parseExpr(
     const std::string& text,
     const RowTypePtr& rowType,
@@ -60,9 +49,22 @@ core::TypedExprPtr parseExpr(
   return core::Expressions::inferTypes(untyped, rowType, pool);
 }
 
-template <TypeKind FromKind, TypeKind ToKind>
-typename TypeTraits<ToKind>::NativeType cast(const variant& v) {
-  return util::Converter<ToKind, void, false>::cast(v.value<FromKind>());
+std::shared_ptr<HiveBucketProperty> buildHiveBucketProperty(
+    const RowTypePtr rowType,
+    int32_t bucketCount,
+    const std::vector<std::string>& bucketColumns,
+    const std::vector<std::shared_ptr<const HiveSortingColumn>>& sortBy) {
+  std::vector<TypePtr> bucketTypes;
+  bucketTypes.reserve(bucketColumns.size());
+  for (const auto& bucketColumn : bucketColumns) {
+    bucketTypes.push_back(rowType->childAt(rowType->getChildIdx(bucketColumn)));
+  }
+  return std::make_shared<HiveBucketProperty>(
+      HiveBucketProperty::Kind::kHiveCompatible,
+      bucketCount,
+      bucketColumns,
+      bucketTypes,
+      sortBy);
 }
 } // namespace
 
@@ -70,14 +72,18 @@ PlanBuilder& PlanBuilder::tableScan(
     const RowTypePtr& outputType,
     const std::vector<std::string>& subfieldFilters,
     const std::string& remainingFilter,
-    const RowTypePtr& dataColumns) {
-  return tableScan(
-      "hive_table",
-      outputType,
-      {},
-      subfieldFilters,
-      remainingFilter,
-      dataColumns);
+    const RowTypePtr& dataColumns,
+    const std::unordered_map<
+        std::string,
+        std::shared_ptr<connector::ColumnHandle>>& assignments) {
+  return TableScanBuilder(*this)
+      .outputType(outputType)
+      .assignments(assignments)
+      .subfieldFilters(subfieldFilters)
+      .remainingFilter(remainingFilter)
+      .dataColumns(dataColumns)
+      .assignments(assignments)
+      .endTableScan();
 }
 
 PlanBuilder& PlanBuilder::tableScan(
@@ -86,48 +92,91 @@ PlanBuilder& PlanBuilder::tableScan(
     const std::unordered_map<std::string, std::string>& columnAliases,
     const std::vector<std::string>& subfieldFilters,
     const std::string& remainingFilter,
-    const RowTypePtr& dataColumns) {
+    const RowTypePtr& dataColumns,
+    const std::unordered_map<
+        std::string,
+        std::shared_ptr<connector::ColumnHandle>>& assignments) {
+  return TableScanBuilder(*this)
+      .tableName(tableName)
+      .outputType(outputType)
+      .columnAliases(columnAliases)
+      .subfieldFilters(subfieldFilters)
+      .remainingFilter(remainingFilter)
+      .dataColumns(dataColumns)
+      .assignments(assignments)
+      .endTableScan();
+}
+
+PlanBuilder& PlanBuilder::tpchTableScan(
+    tpch::Table table,
+    std::vector<std::string>&& columnNames,
+    double scaleFactor) {
   std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+      assignmentsMap;
+  std::vector<TypePtr> outputTypes;
+
+  assignmentsMap.reserve(columnNames.size());
+  outputTypes.reserve(columnNames.size());
+
+  for (const auto& columnName : columnNames) {
+    assignmentsMap.emplace(
+        columnName,
+        std::make_shared<connector::tpch::TpchColumnHandle>(columnName));
+    outputTypes.emplace_back(resolveTpchColumn(table, columnName));
+  }
+  auto rowType = ROW(std::move(columnNames), std::move(outputTypes));
+  return TableScanBuilder(*this)
+      .outputType(rowType)
+      .tableHandle(std::make_shared<connector::tpch::TpchTableHandle>(
+          std::string(kTpchDefaultConnectorId), table, scaleFactor))
+      .assignments(assignmentsMap)
+      .endTableScan();
+}
+
+core::PlanNodePtr PlanBuilder::TableScanBuilder::build(core::PlanNodeId id) {
+  VELOX_CHECK_NOT_NULL(outputType_, "outputType must be specified");
   std::unordered_map<std::string, core::TypedExprPtr> typedMapping;
-  for (uint32_t i = 0; i < outputType->size(); ++i) {
-    const auto& name = outputType->nameOf(i);
-    const auto& type = outputType->childAt(i);
+  bool hasAssignments = !(assignments_.empty());
+  for (uint32_t i = 0; i < outputType_->size(); ++i) {
+    const auto& name = outputType_->nameOf(i);
+    const auto& type = outputType_->childAt(i);
 
     std::string hiveColumnName = name;
-    auto it = columnAliases.find(name);
-    if (it != columnAliases.end()) {
+    auto it = columnAliases_.find(name);
+    if (it != columnAliases_.end()) {
       hiveColumnName = it->second;
       typedMapping.emplace(
           name,
           std::make_shared<core::FieldAccessTypedExpr>(type, hiveColumnName));
     }
 
-    assignments.insert(
-        {name,
-         std::make_shared<HiveColumnHandle>(
-             hiveColumnName,
-             HiveColumnHandle::ColumnType::kRegular,
-             type,
-             type)});
+    if (!hasAssignments) {
+      assignments_.insert(
+          {name,
+           std::make_shared<HiveColumnHandle>(
+               hiveColumnName,
+               HiveColumnHandle::ColumnType::kRegular,
+               type,
+               type)});
+    }
   }
 
-  const RowTypePtr& parseType = dataColumns ? dataColumns : outputType;
+  const RowTypePtr& parseType = dataColumns_ ? dataColumns_ : outputType_;
 
   SubfieldFilters filters;
-  filters.reserve(subfieldFilters.size());
-  core::QueryCtx queryCtx;
-  exec::SimpleExpressionEvaluator evaluator(&queryCtx, pool_);
-  for (const auto& filter : subfieldFilters) {
-    auto filterExpr = parseExpr(filter, parseType, options_, pool_);
+  filters.reserve(subfieldFilters_.size());
+  auto queryCtx = core::QueryCtx::create();
+  exec::SimpleExpressionEvaluator evaluator(queryCtx.get(), planBuilder_.pool_);
+  for (const auto& filter : subfieldFilters_) {
+    auto filterExpr =
+        parseExpr(filter, parseType, planBuilder_.options_, planBuilder_.pool_);
     auto [subfield, subfieldFilter] =
         exec::toSubfieldFilter(filterExpr, &evaluator);
 
-    auto it = columnAliases.find(subfield.toString());
-    if (it != columnAliases.end()) {
+    auto it = columnAliases_.find(subfield.toString());
+    if (it != columnAliases_.end()) {
       subfield = common::Subfield(it->second);
     }
-
     VELOX_CHECK_EQ(
         filters.count(subfield),
         0,
@@ -138,61 +187,33 @@ PlanBuilder& PlanBuilder::tableScan(
   }
 
   core::TypedExprPtr remainingFilterExpr;
-  if (!remainingFilter.empty()) {
-    remainingFilterExpr = parseExpr(remainingFilter, parseType, options_, pool_)
+  if (!remainingFilter_.empty()) {
+    remainingFilterExpr = parseExpr(
+                              remainingFilter_,
+                              parseType,
+                              planBuilder_.options_,
+                              planBuilder_.pool_)
                               ->rewriteInputNames(typedMapping);
   }
 
-  auto tableHandle = std::make_shared<HiveTableHandle>(
-      kHiveConnectorId,
-      tableName,
-      true,
-      std::move(filters),
-      remainingFilterExpr,
-      dataColumns);
-  return tableScan(outputType, tableHandle, assignments);
-}
-
-PlanBuilder& PlanBuilder::tableScan(
-    const RowTypePtr& outputType,
-    const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& assignments) {
-  planNode_ = std::make_shared<core::TableScanNode>(
-      nextPlanNodeId(), outputType, tableHandle, assignments);
-  return *this;
-}
-
-PlanBuilder& PlanBuilder::tableScan(
-    tpch::Table table,
-    std::vector<std::string>&& columnNames,
-    double scaleFactor) {
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignmentsMap;
-  std::vector<TypePtr> outputTypes;
-
-  assignmentsMap.reserve(columnNames.size());
-  outputTypes.reserve(columnNames.size());
-
-  for (const auto& columnName : columnNames) {
-    assignmentsMap.emplace(
-        columnName,
-        std::make_shared<connector::tpch::TpchColumnHandle>(columnName));
-    outputTypes.emplace_back(resolveTpchColumn(table, columnName));
+  if (!tableHandle_) {
+    tableHandle_ = std::make_shared<HiveTableHandle>(
+        connectorId_,
+        tableName_,
+        true,
+        std::move(filters),
+        remainingFilterExpr,
+        dataColumns_);
   }
-  auto rowType = ROW(std::move(columnNames), std::move(outputTypes));
-  return tableScan(
-      rowType,
-      std::make_shared<connector::tpch::TpchTableHandle>(
-          kTpchConnectorId, table, scaleFactor),
-      assignmentsMap);
+  return std::make_shared<core::TableScanNode>(
+      id, outputType_, tableHandle_, assignments_);
 }
 
 PlanBuilder& PlanBuilder::values(
     const std::vector<RowVectorPtr>& values,
     bool parallelizable,
     size_t repeatTimes) {
+  VELOX_CHECK_NULL(planNode_, "Values must be the source node");
   auto valuesCopy = values;
   planNode_ = std::make_shared<core::ValuesNode>(
       nextPlanNodeId(), std::move(valuesCopy), parallelizable, repeatTimes);
@@ -200,7 +221,7 @@ PlanBuilder& PlanBuilder::values(
 }
 
 PlanBuilder& PlanBuilder::exchange(const RowTypePtr& outputType) {
-  VELOX_CHECK_NULL(planNode_, "exchange() must be the first call");
+  VELOX_CHECK_NULL(planNode_, "Exchange must be the source node");
   planNode_ =
       std::make_shared<core::ExchangeNode>(nextPlanNodeId(), outputType);
   return *this;
@@ -238,6 +259,7 @@ parseOrderByClauses(
 PlanBuilder& PlanBuilder::mergeExchange(
     const RowTypePtr& outputType,
     const std::vector<std::string>& keys) {
+  VELOX_CHECK_NULL(planNode_, "MergeExchange must be the source node");
   auto [sortingKeys, sortingOrders] =
       parseOrderByClauses(keys, outputType, pool_);
 
@@ -280,6 +302,7 @@ PlanBuilder& PlanBuilder::projectExpressions(
 }
 
 PlanBuilder& PlanBuilder::project(const std::vector<std::string>& projections) {
+  VELOX_CHECK_NOT_NULL(planNode_, "Project cannot be the source node");
   std::vector<std::shared_ptr<const core::IExpr>> expressions;
   for (auto i = 0; i < projections.size(); ++i) {
     expressions.push_back(parse::parseExpr(projections[i], options_));
@@ -287,6 +310,17 @@ PlanBuilder& PlanBuilder::project(const std::vector<std::string>& projections) {
   return projectExpressions(expressions);
 }
 
+PlanBuilder& PlanBuilder::appendColumns(
+    const std::vector<std::string>& newColumns) {
+  VELOX_CHECK_NOT_NULL(planNode_, "Project cannot be the source node");
+  std::vector<std::string> allProjections = planNode_->outputType()->names();
+  for (const auto& column : newColumns) {
+    allProjections.push_back(column);
+  }
+
+  return project(allProjections);
+}
+
 PlanBuilder& PlanBuilder::optionalFilter(const std::string& optionalFilter) {
   if (optionalFilter.empty()) {
     return *this;
@@ -295,6 +329,7 @@ PlanBuilder& PlanBuilder::optionalFilter(const std::string& optionalFilter) {
 }
 
 PlanBuilder& PlanBuilder::filter(const std::string& filter) {
+  VELOX_CHECK_NOT_NULL(planNode_, "Filter cannot be the source node");
   planNode_ = std::make_shared<core::FilterNode>(
       nextPlanNodeId(),
       parseExpr(filter, planNode_->outputType(), options_, pool_),
@@ -305,15 +340,90 @@ PlanBuilder& PlanBuilder::filter(const std::string& filter) {
 PlanBuilder& PlanBuilder::tableWrite(
     const std::string& outputDirectoryPath,
     const dwio::common::FileFormat fileFormat,
-    const std::vector<std::string>& aggregates) {
+    const std::vector<std::string>& aggregates,
+    const std::shared_ptr<dwio::common::WriterOptions>& options,
+    const std::string& outputFileName) {
+  return tableWrite(
+      outputDirectoryPath,
+      {},
+      0,
+      {},
+      {},
+      fileFormat,
+      aggregates,
+      kHiveDefaultConnectorId,
+      {},
+      options,
+      outputFileName);
+}
+
+PlanBuilder& PlanBuilder::tableWrite(
+    const std::string& outputDirectoryPath,
+    const std::vector<std::string>& partitionBy,
+    const dwio::common::FileFormat fileFormat,
+    const std::vector<std::string>& aggregates,
+    const std::shared_ptr<dwio::common::WriterOptions>& options) {
+  return tableWrite(
+      outputDirectoryPath,
+      partitionBy,
+      0,
+      {},
+      {},
+      fileFormat,
+      aggregates,
+      kHiveDefaultConnectorId,
+      {},
+      options);
+}
+
+PlanBuilder& PlanBuilder::tableWrite(
+    const std::string& outputDirectoryPath,
+    const std::vector<std::string>& partitionBy,
+    int32_t bucketCount,
+    const std::vector<std::string>& bucketedBy,
+    const dwio::common::FileFormat fileFormat,
+    const std::vector<std::string>& aggregates,
+    const std::shared_ptr<dwio::common::WriterOptions>& options) {
+  return tableWrite(
+      outputDirectoryPath,
+      partitionBy,
+      bucketCount,
+      bucketedBy,
+      {},
+      fileFormat,
+      aggregates,
+      kHiveDefaultConnectorId,
+      {},
+      options);
+}
+
+PlanBuilder& PlanBuilder::tableWrite(
+    const std::string& outputDirectoryPath,
+    const std::vector<std::string>& partitionBy,
+    int32_t bucketCount,
+    const std::vector<std::string>& bucketedBy,
+    const std::vector<std::shared_ptr<const HiveSortingColumn>>& sortBy,
+    const dwio::common::FileFormat fileFormat,
+    const std::vector<std::string>& aggregates,
+    const std::string_view& connectorId,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
+    const std::shared_ptr<dwio::common::WriterOptions>& options,
+    const std::string& outputFileName) {
+  VELOX_CHECK_NOT_NULL(planNode_, "TableWrite cannot be the source node");
   auto rowType = planNode_->outputType();
 
   std::vector<std::shared_ptr<const connector::hive::HiveColumnHandle>>
       columnHandles;
   for (auto i = 0; i < rowType->size(); ++i) {
+    const auto column = rowType->nameOf(i);
+    const bool isPartitionKey =
+        std::find(partitionBy.begin(), partitionBy.end(), column) !=
+        partitionBy.end();
     columnHandles.push_back(std::make_shared<connector::hive::HiveColumnHandle>(
-        rowType->nameOf(i),
-        connector::hive::HiveColumnHandle::ColumnType::kRegular,
+        column,
+        isPartitionKey
+            ? connector::hive::HiveColumnHandle::ColumnType::kPartitionKey
+            : connector::hive::HiveColumnHandle::ColumnType::kRegular,
         rowType->childAt(i),
         rowType->childAt(i)));
   }
@@ -321,16 +431,24 @@ PlanBuilder& PlanBuilder::tableWrite(
   auto locationHandle = std::make_shared<connector::hive::LocationHandle>(
       outputDirectoryPath,
       outputDirectoryPath,
-      connector::hive::LocationHandle::TableType::kNew);
+      connector::hive::LocationHandle::TableType::kNew,
+      outputFileName);
+  std::shared_ptr<HiveBucketProperty> bucketProperty;
+  if (!partitionBy.empty() && bucketCount != 0) {
+    bucketProperty =
+        buildHiveBucketProperty(rowType, bucketCount, bucketedBy, sortBy);
+  }
   auto hiveHandle = std::make_shared<connector::hive::HiveInsertTableHandle>(
       columnHandles,
       locationHandle,
       fileFormat,
-      nullptr, // bucketProperty,
-      common::CompressionKind_NONE);
+      bucketProperty,
+      common::CompressionKind_NONE,
+      serdeParameters,
+      options);
 
-  auto insertHandle =
-      std::make_shared<core::InsertTableHandle>(kHiveConnectorId, hiveHandle);
+  auto insertHandle = std::make_shared<core::InsertTableHandle>(
+      std::string(connectorId), hiveHandle);
 
   std::shared_ptr<core::AggregationNode> aggregationNode;
   if (!aggregates.empty()) {
@@ -676,10 +794,15 @@ PlanBuilder::AggregatesAndNames PlanBuilder::createAggregateExpressionsAndNames(
     agg.distinct = untypedExpr.distinct;
 
     if (!untypedExpr.orderBy.empty()) {
-      VELOX_CHECK(
-          step == core::AggregationNode::Step::kSingle,
-          "Aggregations over sorted inputs cannot be split into partial and final: {}.",
-          aggregate)
+      auto* entry = exec::getAggregateFunctionEntry(agg.call->name());
+      const auto& metadata = entry->metadata;
+      if (metadata.orderSensitive) {
+        VELOX_CHECK(
+            step == core::AggregationNode::Step::kSingle,
+            "Order sensitive aggregation over sorted inputs cannot be split "
+            "into partial and final: {}.",
+            aggregate);
+      }
     }
 
     for (const auto& [keyExpr, order] : untypedExpr.orderBy) {
@@ -717,6 +840,25 @@ PlanBuilder& PlanBuilder::aggregation(
     const std::vector<std::vector<TypePtr>>& rawInputTypes) {
   auto aggregatesAndNames = createAggregateExpressionsAndNames(
       aggregates, masks, step, rawInputTypes);
+
+  // If the aggregationNode is over a GroupId, then global grouping sets
+  // need to be populated.
+  std::vector<vector_size_t> globalGroupingSets;
+  std::optional<core::FieldAccessTypedExprPtr> groupId;
+  if (auto groupIdNode =
+          dynamic_cast<const core::GroupIdNode*>(planNode_.get())) {
+    for (auto i = 0; i < groupIdNode->groupingSets().size(); i++) {
+      if (groupIdNode->groupingSets().at(i).empty()) {
+        globalGroupingSets.push_back(i);
+      }
+    }
+
+    if (!globalGroupingSets.empty()) {
+      // GroupId is the last column of the GroupIdNode.
+      groupId = field(groupIdNode->outputType()->names().back());
+    }
+  }
+
   planNode_ = std::make_shared<core::AggregationNode>(
       nextPlanNodeId(),
       step,
@@ -724,6 +866,8 @@ PlanBuilder& PlanBuilder::aggregation(
       fields(preGroupedKeys),
       aggregatesAndNames.names,
       aggregatesAndNames.aggregates,
+      globalGroupingSets,
+      groupId,
       ignoreNullKeys,
       planNode_);
   return *this;
@@ -811,6 +955,59 @@ PlanBuilder& PlanBuilder::localMerge(const std::vector<std::string>& keys) {
   return *this;
 }
 
+PlanBuilder& PlanBuilder::expand(
+    const std::vector<std::vector<std::string>>& projections) {
+  VELOX_CHECK(!projections.empty(), "projections must not be empty.");
+  const auto numColumns = projections[0].size();
+  const auto numRows = projections.size();
+  std::vector<std::string> aliases;
+  aliases.reserve(numColumns);
+
+  std::vector<std::vector<core::TypedExprPtr>> projectExprs;
+  projectExprs.reserve(projections.size());
+
+  for (auto i = 0; i < numRows; i++) {
+    std::vector<core::TypedExprPtr> projectExpr;
+    VELOX_CHECK_EQ(numColumns, projections[i].size());
+    for (auto j = 0; j < numColumns; j++) {
+      auto untypedExpression = parse::parseExpr(projections[i][j], options_);
+      auto typedExpression = inferTypes(untypedExpression);
+
+      if (i == 0) {
+        if (untypedExpression->alias().has_value()) {
+          aliases.push_back(untypedExpression->alias().value());
+        } else {
+          auto fieldExpr = dynamic_cast<const core::FieldAccessExpr*>(
+              untypedExpression.get());
+          VELOX_CHECK_NOT_NULL(fieldExpr);
+          aliases.push_back(fieldExpr->getFieldName());
+        }
+        projectExpr.push_back(typedExpression);
+      } else {
+        // The types of values in 2nd and subsequent rows must much types in the
+        //  1st row.
+        const auto& expectedType = projectExprs[0][j]->type();
+        if (typedExpression->type()->equivalent(*expectedType)) {
+          projectExpr.push_back(typedExpression);
+        } else {
+          auto constantExpr =
+              dynamic_cast<const core::ConstantExpr*>(untypedExpression.get());
+          VELOX_CHECK_NOT_NULL(constantExpr);
+          VELOX_CHECK(constantExpr->value().isNull());
+          projectExpr.push_back(std::make_shared<core::ConstantTypedExpr>(
+              expectedType, variant::null(expectedType->kind())));
+        }
+      }
+    }
+    projectExprs.push_back(projectExpr);
+  }
+
+  planNode_ = std::make_shared<core::ExpandNode>(
+      nextPlanNodeId(), projectExprs, std::move(aliases), planNode_);
+
+  return *this;
+}
+
 PlanBuilder& PlanBuilder::localMerge(
     const std::vector<std::string>& keys,
     std::vector<core::PlanNodePtr> sources) {
@@ -826,6 +1023,7 @@ PlanBuilder& PlanBuilder::localMerge(
 PlanBuilder& PlanBuilder::orderBy(
     const std::vector<std::string>& keys,
     bool isPartial) {
+  VELOX_CHECK_NOT_NULL(planNode_, "OrderBy cannot be the source node");
   auto [sortingKeys, sortingOrders] =
       parseOrderByClauses(keys, planNode_->outputType(), pool_);
 
@@ -839,6 +1037,7 @@ PlanBuilder& PlanBuilder::topN(
     const std::vector<std::string>& keys,
     int32_t count,
     bool isPartial) {
+  VELOX_CHECK_NOT_NULL(planNode_, "TopN cannot be the source node");
   auto [sortingKeys, sortingOrders] =
       parseOrderByClauses(keys, planNode_->outputType(), pool_);
   planNode_ = std::make_shared<core::TopNNode>(
@@ -851,7 +1050,7 @@ PlanBuilder& PlanBuilder::topN(
   return *this;
 }
 
-PlanBuilder& PlanBuilder::limit(int32_t offset, int32_t count, bool isPartial) {
+PlanBuilder& PlanBuilder::limit(int64_t offset, int64_t count, bool isPartial) {
   planNode_ = std::make_shared<core::LimitNode>(
       nextPlanNodeId(), offset, count, isPartial, planNode_);
   return *this;
@@ -874,17 +1073,33 @@ PlanBuilder& PlanBuilder::assignUniqueId(
 namespace {
 core::PartitionFunctionSpecPtr createPartitionFunctionSpec(
     const RowTypePtr& inputType,
-    const std::vector<std::string>& keys) {
+    const std::vector<core::TypedExprPtr>& keys,
+    memory::MemoryPool* pool) {
   if (keys.empty()) {
     return std::make_shared<core::GatherPartitionFunctionSpec>();
   } else {
     std::vector<column_index_t> keyIndices;
     keyIndices.reserve(keys.size());
+
+    std::vector<VectorPtr> constValues;
+    constValues.reserve(keys.size());
+
     for (const auto& key : keys) {
-      keyIndices.push_back(inputType->getChildIdx(key));
+      if (auto field =
+              std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+                  key)) {
+        keyIndices.push_back(inputType->getChildIdx(field->name()));
+      } else if (
+          auto constant =
+              std::dynamic_pointer_cast<const core::ConstantTypedExpr>(key)) {
+        keyIndices.push_back(kConstantChannel);
+        constValues.push_back(constant->toConstantVector(pool));
+      } else {
+        VELOX_UNREACHABLE();
+      }
     }
     return std::make_shared<HashPartitionFunctionSpec>(
-        inputType, std::move(keyIndices));
+        inputType, std::move(keyIndices), std::move(constValues));
   }
 }
 
@@ -924,10 +1139,11 @@ RowTypePtr rename(
 
 core::PlanNodePtr createLocalPartitionNode(
     const core::PlanNodeId& planNodeId,
-    const std::vector<std::string>& keys,
-    const std::vector<core::PlanNodePtr>& sources) {
+    const std::vector<core::TypedExprPtr>& keys,
+    const std::vector<core::PlanNodePtr>& sources,
+    memory::MemoryPool* pool) {
   auto partitionFunctionFactory =
-      createPartitionFunctionSpec(sources[0]->outputType(), keys);
+      createPartitionFunctionSpec(sources[0]->outputType(), keys, pool);
   return std::make_shared<core::LocalPartitionNode>(
       planNodeId,
       keys.empty() ? core::LocalPartitionNode::Type::kGather
@@ -949,11 +1165,15 @@ PlanBuilder& PlanBuilder::partitionedOutput(
     int numPartitions,
     bool replicateNullsAndAny,
     const std::vector<std::string>& outputLayout) {
+  VELOX_CHECK_NOT_NULL(
+      planNode_, "PartitionedOutput cannot be the source node");
+
+  auto keyExprs = exprs(keys, planNode_->outputType());
   return partitionedOutput(
       keys,
       numPartitions,
       replicateNullsAndAny,
-      createPartitionFunctionSpec(planNode_->outputType(), keys),
+      createPartitionFunctionSpec(planNode_->outputType(), keyExprs, pool_),
       outputLayout);
 }
 
@@ -963,13 +1183,15 @@ PlanBuilder& PlanBuilder::partitionedOutput(
     bool replicateNullsAndAny,
     core::PartitionFunctionSpecPtr partitionFunctionSpec,
     const std::vector<std::string>& outputLayout) {
+  VELOX_CHECK_NOT_NULL(
+      planNode_, "PartitionedOutput cannot be the source node");
   auto outputType = outputLayout.empty()
       ? planNode_->outputType()
       : extract(planNode_->outputType(), outputLayout);
   planNode_ = std::make_shared<core::PartitionedOutputNode>(
       nextPlanNodeId(),
       core::PartitionedOutputNode::Kind::kPartitioned,
-      exprs(keys),
+      exprs(keys, planNode_->outputType()),
       numPartitions,
       replicateNullsAndAny,
       std::move(partitionFunctionSpec),
@@ -980,6 +1202,8 @@ PlanBuilder& PlanBuilder::partitionedOutput(
 
 PlanBuilder& PlanBuilder::partitionedOutputBroadcast(
     const std::vector<std::string>& outputLayout) {
+  VELOX_CHECK_NOT_NULL(
+      planNode_, "PartitionedOutput cannot be the source node");
   auto outputType = outputLayout.empty()
       ? planNode_->outputType()
       : extract(planNode_->outputType(), outputLayout);
@@ -988,22 +1212,40 @@ PlanBuilder& PlanBuilder::partitionedOutputBroadcast(
   return *this;
 }
 
+PlanBuilder& PlanBuilder::partitionedOutputArbitrary(
+    const std::vector<std::string>& outputLayout) {
+  VELOX_CHECK_NOT_NULL(
+      planNode_, "PartitionedOutput cannot be the source node");
+  auto outputType = outputLayout.empty()
+      ? planNode_->outputType()
+      : extract(planNode_->outputType(), outputLayout);
+  planNode_ = core::PartitionedOutputNode::arbitrary(
+      nextPlanNodeId(), outputType, planNode_);
+  return *this;
+}
+
 PlanBuilder& PlanBuilder::localPartition(
     const std::vector<std::string>& keys,
     const std::vector<core::PlanNodePtr>& sources) {
   VELOX_CHECK_NULL(planNode_, "localPartition() must be the first call");
-  planNode_ = createLocalPartitionNode(nextPlanNodeId(), keys, sources);
+  planNode_ = createLocalPartitionNode(
+      nextPlanNodeId(), exprs(keys, sources[0]->outputType()), sources, pool_);
   return *this;
 }
 
 PlanBuilder& PlanBuilder::localPartition(const std::vector<std::string>& keys) {
-  planNode_ = createLocalPartitionNode(nextPlanNodeId(), keys, {planNode_});
+  planNode_ = createLocalPartitionNode(
+      nextPlanNodeId(),
+      exprs(keys, planNode_->outputType()),
+      {planNode_},
+      pool_);
   return *this;
 }
 
 PlanBuilder& PlanBuilder::localPartitionByBucket(
     const std::shared_ptr<connector::hive::HiveBucketProperty>&
         bucketProperty) {
+  VELOX_CHECK_NOT_NULL(planNode_, "LocalPartition cannot be the source node");
   std::vector<column_index_t> bucketChannels;
   for (const auto& bucketColumn : bucketProperty->bucketedBy()) {
     bucketChannels.push_back(
@@ -1112,6 +1354,7 @@ PlanBuilder& PlanBuilder::hashJoin(
     const std::vector<std::string>& outputLayout,
     core::JoinType joinType,
     bool nullAware) {
+  VELOX_CHECK_NOT_NULL(planNode_, "HashJoin cannot be the source node");
   VELOX_CHECK_EQ(leftKeys.size(), rightKeys.size());
 
   auto leftType = planNode_->outputType();
@@ -1162,6 +1405,7 @@ PlanBuilder& PlanBuilder::mergeJoin(
     const std::string& filter,
     const std::vector<std::string>& outputLayout,
     core::JoinType joinType) {
+  VELOX_CHECK_NOT_NULL(planNode_, "MergeJoin cannot be the source node");
   VELOX_CHECK_EQ(leftKeys.size(), rightKeys.size());
 
   auto leftType = planNode_->outputType();
@@ -1199,6 +1443,7 @@ PlanBuilder& PlanBuilder::nestedLoopJoin(
     const std::string& joinCondition,
     const std::vector<std::string>& outputLayout,
     core::JoinType joinType) {
+  VELOX_CHECK_NOT_NULL(planNode_, "NestedLoopJoin cannot be the source node");
   auto resultType = concat(planNode_->outputType(), right->outputType());
   auto outputType = extract(resultType, outputLayout);
 
@@ -1221,6 +1466,7 @@ PlanBuilder& PlanBuilder::unnest(
     const std::vector<std::string>& replicateColumns,
     const std::vector<std::string>& unnestColumns,
     const std::optional<std::string>& ordinalColumn) {
+  VELOX_CHECK_NOT_NULL(planNode_, "Unnest cannot be the source node");
   std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>>
       replicateFields;
   replicateFields.reserve(replicateColumns.size());
@@ -1451,6 +1697,7 @@ bool equalSortOrderList(
 PlanBuilder& PlanBuilder::window(
     const std::vector<std::string>& windowFunctions,
     bool inputSorted) {
+  VELOX_CHECK_NOT_NULL(planNode_, "Window cannot be the source node");
   VELOX_CHECK_GT(
       windowFunctions.size(),
       0,
@@ -1568,6 +1815,7 @@ PlanBuilder& PlanBuilder::topNRowNumber(
     const std::vector<std::string>& sortingKeys,
     int32_t limit,
     bool generateRowNumber) {
+  VELOX_CHECK_NOT_NULL(planNode_, "TopNRowNumber cannot be the source node");
   auto [sortingFields, sortingOrders] =
       parseOrderByClauses(sortingKeys, planNode_->outputType(), pool_);
   std::optional<std::string> rowNumberColumnName;
@@ -1588,6 +1836,7 @@ PlanBuilder& PlanBuilder::topNRowNumber(
 PlanBuilder& PlanBuilder::markDistinct(
     std::string markerKey,
     const std::vector<std::string>& distinctKeys) {
+  VELOX_CHECK_NOT_NULL(planNode_, "MarkDistinct cannot be the source node");
   planNode_ = std::make_shared<core::MarkDistinctNode>(
       nextPlanNodeId(),
       std::move(markerKey),
@@ -1644,38 +1893,54 @@ PlanBuilder::fields(
 
 std::shared_ptr<const core::FieldAccessTypedExpr> PlanBuilder::field(
     column_index_t index) {
+  VELOX_CHECK_NOT_NULL(planNode_);
   return field(planNode_->outputType(), index);
 }
 
 std::shared_ptr<const core::FieldAccessTypedExpr> PlanBuilder::field(
     const std::string& name) {
+  VELOX_CHECK_NOT_NULL(planNode_);
   return field(planNode_->outputType(), name);
 }
 
 std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>>
 PlanBuilder::fields(const std::vector<std::string>& names) {
+  VELOX_CHECK_NOT_NULL(planNode_);
   return fields(planNode_->outputType(), names);
 }
 
 std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>>
 PlanBuilder::fields(const std::vector<column_index_t>& indices) {
+  VELOX_CHECK_NOT_NULL(planNode_);
   return fields(planNode_->outputType(), indices);
 }
 
 std::vector<core::TypedExprPtr> PlanBuilder::exprs(
-    const std::vector<std::string>& names) {
-  auto flds = fields(planNode_->outputType(), names);
-  std::vector<core::TypedExprPtr> expressions;
-  expressions.reserve(flds.size());
-  for (const auto& fld : flds) {
-    expressions.emplace_back(
-        std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(fld));
+    const std::vector<std::string>& expressions,
+    const RowTypePtr& inputType) {
+  std::vector<core::TypedExprPtr> typedExpressions;
+  for (auto& expr : expressions) {
+    auto typedExpression = core::Expressions::inferTypes(
+        parse::parseExpr(expr, options_), inputType, pool_);
+
+    if (auto field = dynamic_cast<const core::FieldAccessTypedExpr*>(
+            typedExpression.get())) {
+      typedExpressions.push_back(typedExpression);
+    } else if (
+        auto constant = dynamic_cast<const core::ConstantTypedExpr*>(
+            typedExpression.get())) {
+      typedExpressions.push_back(typedExpression);
+    } else {
+      VELOX_FAIL("Expected field name or constant: {}", expr);
+    }
   }
-  return expressions;
+
+  return typedExpressions;
 }
 
 core::TypedExprPtr PlanBuilder::inferTypes(
     const std::shared_ptr<const core::IExpr>& untypedExpr) {
+  VELOX_CHECK_NOT_NULL(planNode_);
   return core::Expressions::inferTypes(
       untypedExpr, planNode_->outputType(), pool_);
 }
diff --git a/velox/exec/tests/utils/PlanBuilder.h b/velox/exec/tests/utils/PlanBuilder.h
index adb7983b0999d..0b0f2eb180dec 100644
--- a/velox/exec/tests/utils/PlanBuilder.h
+++ b/velox/exec/tests/utils/PlanBuilder.h
@@ -95,6 +95,9 @@ class PlanBuilder {
   explicit PlanBuilder(memory::MemoryPool* pool = nullptr)
       : PlanBuilder(std::make_shared<core::PlanNodeIdGenerator>(), pool) {}
 
+  static constexpr const std::string_view kHiveDefaultConnectorId{"test-hive"};
+  static constexpr const std::string_view kTpchDefaultConnectorId{"test-tpch"};
+
   /// Add a TableScanNode to scan a Hive table.
   ///
   /// @param outputType List of column names and types to read from the table.
@@ -111,11 +114,15 @@ class PlanBuilder {
   /// types (for all columns) in this argument as opposed to 'outputType', where
   /// you define the output types only. See 'missingColumns' test in
   /// 'TableScanTest'.
+  /// @param assignments Optional ColumnHandles.
   PlanBuilder& tableScan(
       const RowTypePtr& outputType,
       const std::vector<std::string>& subfieldFilters = {},
       const std::string& remainingFilter = "",
-      const RowTypePtr& dataColumns = nullptr);
+      const RowTypePtr& dataColumns = nullptr,
+      const std::unordered_map<
+          std::string,
+          std::shared_ptr<connector::ColumnHandle>>& assignments = {});
 
   /// Add a TableScanNode to scan a Hive table.
   ///
@@ -144,21 +151,10 @@ class PlanBuilder {
       const std::unordered_map<std::string, std::string>& columnAliases = {},
       const std::vector<std::string>& subfieldFilters = {},
       const std::string& remainingFilter = "",
-      const RowTypePtr& dataColumns = nullptr);
-
-  /// Add a TableScanNode using a connector-specific table handle and
-  /// assignments. Supports any connector, not just Hive connector.
-  ///
-  /// @param outputType List of column names and types to project out. Column
-  /// names should match the keys in the 'assignments' map. The 'assignments'
-  /// map may contain more columns then 'outputType' if some columns are only
-  /// used by pushed-down filters.
-  PlanBuilder& tableScan(
-      const RowTypePtr& outputType,
-      const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
+      const RowTypePtr& dataColumns = nullptr,
       const std::unordered_map<
           std::string,
-          std::shared_ptr<connector::ColumnHandle>>& assignments);
+          std::shared_ptr<connector::ColumnHandle>>& assignments = {});
 
   /// Add a TableScanNode to scan a TPC-H table.
   ///
@@ -166,11 +162,136 @@ class PlanBuilder {
   /// and scale factor.
   /// @param columnNames The columns to be returned from that table.
   /// @param scaleFactor The TPC-H scale factor.
-  PlanBuilder& tableScan(
+  PlanBuilder& tpchTableScan(
       tpch::Table table,
       std::vector<std::string>&& columnNames,
       double scaleFactor = 1);
 
+  /// Helper class to build a custom TableScanNode.
+  /// Uses a planBuilder instance to get the next plan id, memory pool, and
+  /// parse options.
+  ///
+  /// Uses the hive connector by default. Specify outputType, tableHandle, and
+  /// assignments for other connectors. If these three are specified, all other
+  /// builder arguments will be ignored.
+  class TableScanBuilder {
+   public:
+    TableScanBuilder(PlanBuilder& builder) : planBuilder_(builder) {}
+
+    /// @param tableName The name of the table to scan.
+    TableScanBuilder& tableName(std::string tableName) {
+      tableName_ = std::move(tableName);
+      return *this;
+    }
+
+    /// @param connectorId The id of the connector to scan.
+    TableScanBuilder& connectorId(std::string connectorId) {
+      connectorId_ = std::move(connectorId);
+      return *this;
+    }
+
+    /// @param outputType List of column names and types to read from the table.
+    /// This property is required.
+    TableScanBuilder& outputType(RowTypePtr outputType) {
+      outputType_ = std::move(outputType);
+      return *this;
+    }
+
+    /// @param subfieldFilters A list of SQL expressions for the range filters
+    /// to apply to individual columns. Supported filters are: column <= value,
+    /// column < value, column >= value, column > value, column = value, column
+    /// IN (v1, v2,.. vN), column < v1 OR column >= v2.
+    TableScanBuilder& subfieldFilters(
+        std::vector<std::string> subfieldFilters) {
+      subfieldFilters_ = std::move(subfieldFilters);
+      return *this;
+    }
+
+    /// @param subfieldFilter A SQL expression for the range filter
+    /// to apply to an individual column. Supported filters are: column <=
+    /// value, column < value, column >= value, column > value, column = value,
+    /// column IN (v1, v2,.. vN), column < v1 OR column >= v2.
+    TableScanBuilder& subfieldFilter(std::string subfieldFilter) {
+      subfieldFilters_.emplace_back(std::move(subfieldFilter));
+      return *this;
+    }
+
+    /// @param remainingFilter SQL expression for the additional conjunct. May
+    /// include multiple columns and SQL functions. The remainingFilter is
+    /// AND'ed with all the subfieldFilters.
+    TableScanBuilder& remainingFilter(std::string remainingFilter) {
+      remainingFilter_ = std::move(remainingFilter);
+      return *this;
+    }
+
+    /// @param dataColumns can be different from 'outputType' for the purposes
+    /// of testing queries using missing columns. It is used, if specified, for
+    /// parseExpr call and as 'dataColumns' for the TableHandle. You supply more
+    /// types (for all columns) in this argument as opposed to 'outputType',
+    /// where you define the output types only. See 'missingColumns' test in
+    /// 'TableScanTest'.
+    TableScanBuilder& dataColumns(RowTypePtr dataColumns) {
+      dataColumns_ = std::move(dataColumns);
+      return *this;
+    }
+
+    /// @param columnAliases Optional aliases for the column names. The key is
+    /// the alias (name in 'outputType'), value is the name in the files.
+    TableScanBuilder& columnAliases(
+        std::unordered_map<std::string, std::string> columnAliases) {
+      columnAliases_ = std::move(columnAliases);
+      return *this;
+    }
+
+    /// @param tableHandle Optional tableHandle. Other builder arguments such as
+    /// the subfieldFilters and remainingFilter will be ignored.
+    TableScanBuilder& tableHandle(
+        std::shared_ptr<connector::ConnectorTableHandle> tableHandle) {
+      tableHandle_ = std::move(tableHandle);
+      return *this;
+    }
+
+    /// @param assignments Optional ColumnHandles.
+    /// outputType names should match the keys in the 'assignments' map. The
+    /// 'assignments' map may contain more columns than 'outputType' if some
+    /// columns are only used by pushed-down filters.
+    TableScanBuilder& assignments(
+        std::unordered_map<
+            std::string,
+            std::shared_ptr<connector::ColumnHandle>> assignments) {
+      assignments_ = std::move(assignments);
+      return *this;
+    }
+
+    /// Stop the TableScanBuilder.
+    PlanBuilder& endTableScan() {
+      planBuilder_.planNode_ = build(planBuilder_.nextPlanNodeId());
+      return planBuilder_;
+    }
+
+   private:
+    /// Build the plan node TableScanNode.
+    core::PlanNodePtr build(core::PlanNodeId id);
+
+    PlanBuilder& planBuilder_;
+    std::string tableName_{"hive_table"};
+    std::string connectorId_{kHiveDefaultConnectorId};
+    RowTypePtr outputType_;
+    std::vector<std::string> subfieldFilters_;
+    std::string remainingFilter_;
+    RowTypePtr dataColumns_;
+    std::unordered_map<std::string, std::string> columnAliases_;
+    std::shared_ptr<connector::ConnectorTableHandle> tableHandle_;
+    std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+        assignments_;
+  };
+
+  /// Start a TableScanBuilder.
+  TableScanBuilder& startTableScan() {
+    tableScanBuilder_.reset(new TableScanBuilder(*this));
+    return *tableScanBuilder_;
+  }
+
   /// Add a ValuesNode using specified data.
   ///
   /// @param values The data to use.
@@ -228,6 +349,12 @@ class PlanBuilder {
   /// will produce projected columns named sum_ab, c and p2.
   PlanBuilder& project(const std::vector<std::string>& projections);
 
+  /// Add a ProjectNode to keep all existing columns and append more columns
+  /// using specified expressions.
+  /// @param newColumns A list of one or more expressions to use for computing
+  /// additional columns.
+  PlanBuilder& appendColumns(const std::vector<std::string>& newColumns);
+
   /// Variation of project that takes untyped expressions.  Used for access
   /// deeply nested types, in which case Duck DB often fails to parse or infer
   /// the type.
@@ -254,7 +381,11 @@ class PlanBuilder {
   /// @param outputDirectoryPath Path to a directory to write data to.
   /// @param fileFormat File format to use for the written data.
   /// @param aggregates Aggregations for column statistics collection during
+  /// @param polymorphic options object to be passed to the writer.
   /// write, supported aggregation types vary for different column types.
+  /// @param outputFileName Optional file name of the output. If specified
+  /// (non-empty), use it instead of generating the file name in Velox. Should
+  /// only be specified in non-bucketing write.
   /// For example:
   /// Boolean: count, countIf.
   /// NumericType/Date/Timestamp: min, max, approx_distinct, count.
@@ -264,7 +395,79 @@ class PlanBuilder {
       const std::string& outputDirectoryPath,
       const dwio::common::FileFormat fileFormat =
           dwio::common::FileFormat::DWRF,
-      const std::vector<std::string>& aggregates = {});
+      const std::vector<std::string>& aggregates = {},
+      const std::shared_ptr<dwio::common::WriterOptions>& options = nullptr,
+      const std::string& outputFileName = "");
+
+  /// Adds a TableWriteNode to write all input columns into a partitioned Hive
+  /// table without compression.
+  ///
+  /// @param outputDirectoryPath Path to a directory to write data to.
+  /// @param partitionBy Specifies the partition key columns.
+  /// @param fileFormat File format to use for the written data.
+  /// @param aggregates Aggregations for column statistics collection during
+  /// write.
+  /// @param polymorphic options object to be passed to the writer.
+  PlanBuilder& tableWrite(
+      const std::string& outputDirectoryPath,
+      const std::vector<std::string>& partitionBy,
+      const dwio::common::FileFormat fileFormat =
+          dwio::common::FileFormat::DWRF,
+      const std::vector<std::string>& aggregates = {},
+      const std::shared_ptr<dwio::common::WriterOptions>& options = nullptr);
+
+  /// Adds a TableWriteNode to write all input columns into a non-sorted
+  /// bucketed Hive table without compression.
+  ///
+  /// @param outputDirectoryPath Path to a directory to write data to.
+  /// @param partitionBy Specifies the partition key columns.
+  /// @param bucketCount Specifies the bucket count.
+  /// @param bucketedBy Specifies the bucket by columns.
+  /// @param fileFormat File format to use for the written data.
+  /// @param aggregates Aggregations for column statistics collection during
+  /// write.
+  /// @param polymorphic options object to be passed to the writer.
+  PlanBuilder& tableWrite(
+      const std::string& outputDirectoryPath,
+      const std::vector<std::string>& partitionBy,
+      int32_t bucketCount,
+      const std::vector<std::string>& bucketedBy,
+      const dwio::common::FileFormat fileFormat =
+          dwio::common::FileFormat::DWRF,
+      const std::vector<std::string>& aggregates = {},
+      const std::shared_ptr<dwio::common::WriterOptions>& options = nullptr);
+
+  /// Adds a TableWriteNode to write all input columns into a sorted bucket Hive
+  /// table without compression.
+  ///
+  /// @param outputDirectoryPath Path to a directory to write data to.
+  /// @param partitionBy Specifies the partition key columns.
+  /// @param bucketCount Specifies the bucket count.
+  /// @param bucketedBy Specifies the bucket by columns.
+  /// @param sortBy Specifies the sort by columns.
+  /// @param fileFormat File format to use for the written data.
+  /// @param aggregates Aggregations for column statistics collection during
+  /// write.
+  /// @param connectorId Name used to register the connector.
+  /// @param serdeParameters Additional parameters passed to the writer.
+  /// @param Option objects passed to the writer.
+  /// @param outputFileName Optional file name of the output. If specified
+  /// (non-empty), use it instead of generating the file name in Velox. Should
+  /// only be specified in non-bucketing write.
+  PlanBuilder& tableWrite(
+      const std::string& outputDirectoryPath,
+      const std::vector<std::string>& partitionBy,
+      int32_t bucketCount,
+      const std::vector<std::string>& bucketedBy,
+      const std::vector<
+          std::shared_ptr<const connector::hive::HiveSortingColumn>>& sortBy,
+      const dwio::common::FileFormat fileFormat =
+          dwio::common::FileFormat::DWRF,
+      const std::vector<std::string>& aggregates = {},
+      const std::string_view& connectorId = kHiveDefaultConnectorId,
+      const std::unordered_map<std::string, std::string>& serdeParameters = {},
+      const std::shared_ptr<dwio::common::WriterOptions>& options = nullptr,
+      const std::string& outputFileName = "");
 
   /// Add a TableWriteMergeNode.
   PlanBuilder& tableWriteMerge(
@@ -462,6 +665,25 @@ class PlanBuilder {
       const std::vector<std::string>& aggregationInputs,
       std::string groupIdName = "group_id");
 
+  /// Add an ExpandNode using specified projections. See comments for
+  /// ExpandNode class for description of this plan node.
+  ///
+  /// @param projections A list of projection expressions. Each expression is
+  /// either a column name, null or non-null constant.
+  ///
+  /// For example,
+  ///
+  ///     .expand(
+  ///            {{"k1", "null:: bigint k2", "a", "b", "0 as gid"}, //
+  ///            Column name will be extracted from the first projection. If the
+  ///            column is null, it is also necessary to specify the column
+  ///            type.
+  ///             {"k1", "null", "a", "b", "1"},
+  ///             {"null", "null", "a", "b", "2"}})
+  ///
+  ///
+  PlanBuilder& expand(const std::vector<std::vector<std::string>>& projections);
+
   /// Add a LocalMergeNode using specified ORDER BY clauses.
   ///
   /// For example,
@@ -507,7 +729,7 @@ class PlanBuilder {
   /// @param isPartial Boolean indicating whether the limit node is partial or
   /// final. Partial limit can run multi-threaded. Final limit must run
   /// single-threaded.
-  PlanBuilder& limit(int32_t offset, int32_t count, bool isPartial);
+  PlanBuilder& limit(int64_t offset, int64_t count, bool isPartial);
 
   /// Add an EnforceSingleRowNode to ensure input has at most one row at
   /// runtime.
@@ -560,7 +782,7 @@ class PlanBuilder {
       core::PartitionFunctionSpecPtr partitionFunctionSpec,
       const std::vector<std::string>& outputLayout = {});
 
-  /// Add a PartitionedOutputNode to broadcast the input data.
+  /// Adds a PartitionedOutputNode to broadcast the input data.
   ///
   /// @param outputLayout Optional output layout in case it is different then
   /// the input. Output columns may appear in different order from the input,
@@ -569,7 +791,11 @@ class PlanBuilder {
   PlanBuilder& partitionedOutputBroadcast(
       const std::vector<std::string>& outputLayout = {});
 
-  /// Add a LocalPartitionNode to hash-partition the input on the specified
+  /// Adds a PartitionedOutputNode to put data into arbitrary buffer.
+  PlanBuilder& partitionedOutputArbitrary(
+      const std::vector<std::string>& outputLayout = {});
+
+  /// Adds a LocalPartitionNode to hash-partition the input on the specified
   /// keys using exec::HashPartitionFunction. Number of partitions is determined
   /// at runtime based on parallelism of the downstream pipeline.
   ///
@@ -811,7 +1037,9 @@ class PlanBuilder {
   std::shared_ptr<const core::FieldAccessTypedExpr> field(
       const std::string& name);
 
-  std::vector<core::TypedExprPtr> exprs(const std::vector<std::string>& names);
+  std::vector<core::TypedExprPtr> exprs(
+      const std::vector<std::string>& expressions,
+      const RowTypePtr& inputType);
 
   std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>> fields(
       const std::vector<std::string>& names);
@@ -865,6 +1093,7 @@ class PlanBuilder {
  protected:
   core::PlanNodePtr planNode_;
   parse::ParseOptions options_;
+  std::shared_ptr<TableScanBuilder> tableScanBuilder_;
 
  private:
   std::shared_ptr<core::PlanNodeIdGenerator> planNodeIdGenerator_;
diff --git a/velox/exec/tests/utils/PortUtil.cpp b/velox/exec/tests/utils/PortUtil.cpp
index 52622f0007c73..059f22c4e9bd3 100644
--- a/velox/exec/tests/utils/PortUtil.cpp
+++ b/velox/exec/tests/utils/PortUtil.cpp
@@ -52,7 +52,7 @@ void getFreePortsImpl(int numPorts, int* ports) {
 
 } // namespace
 
-std::vector<int> getFreePorts(size_t numPorts) {
+std::vector<int> getFreePorts(std::size_t numPorts) {
   std::vector<int> ports;
   ports.resize(numPorts);
   getFreePortsImpl(numPorts, &ports[0]);
diff --git a/velox/exec/tests/utils/PortUtil.h b/velox/exec/tests/utils/PortUtil.h
index e72e787d018cb..6c65f18e59fca 100644
--- a/velox/exec/tests/utils/PortUtil.h
+++ b/velox/exec/tests/utils/PortUtil.h
@@ -31,6 +31,6 @@ namespace facebook::velox::exec::test {
 /// port multiple times, unless you started listening to the provided port
 /// before calling the function again.
 int getFreePort();
-std::vector<int> getFreePorts(size_t numPorts);
+std::vector<int> getFreePorts(std::size_t numPorts);
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/PrefixSortUtils.h b/velox/exec/tests/utils/PrefixSortUtils.h
new file mode 100644
index 0000000000000..871eea3b226a8
--- /dev/null
+++ b/velox/exec/tests/utils/PrefixSortUtils.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <limits>
+#include "velox/common/base/PrefixSortConfig.h"
+
+namespace facebook::velox::exec::test {
+/// PrefixSortConfig is obtained from QueryConfig in production code. In many
+/// UTs etc. HiveConnector`s UT, there is no QueryConfig. This method returns a
+/// default PrefixSortConfig for these cases.
+inline velox::common::PrefixSortConfig defaultPrefixSortConfig() {
+  return velox::common::PrefixSortConfig{128, 130};
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/QueryAssertions.cpp b/velox/exec/tests/utils/QueryAssertions.cpp
index b3d9db52ba0ae..50e7a668a94e0 100644
--- a/velox/exec/tests/utils/QueryAssertions.cpp
+++ b/velox/exec/tests/utils/QueryAssertions.cpp
@@ -17,7 +17,9 @@
 #include <gtest/gtest.h>
 #include <chrono>
 
+#include "duckdb/common/types.hpp" // @manual
 #include "velox/duckdb/conversion/DuckConversion.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/Cursor.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
 #include "velox/vector/VectorTypeUtils.h"
@@ -25,6 +27,8 @@
 using facebook::velox::duckdb::duckdbTimestampToVelox;
 using facebook::velox::duckdb::veloxTimestampToDuckDB;
 
+DEFINE_int32(max_error_rows, 10, "Max number of listed error rows");
+
 namespace facebook::velox::exec::test {
 namespace {
 
@@ -39,6 +43,30 @@ ::duckdb::Value duckValueAt(const VectorPtr& vector, vector_size_t index) {
   return ::duckdb::Value(vector->as<SimpleVector<T>>()->valueAt(index));
 }
 
+template <>
+::duckdb::Value duckValueAt<TypeKind::TINYINT>(
+    const VectorPtr& vector,
+    vector_size_t index) {
+  return ::duckdb::Value::TINYINT(
+      vector->as<SimpleVector<int8_t>>()->valueAt(index));
+}
+
+template <>
+::duckdb::Value duckValueAt<TypeKind::SMALLINT>(
+    const VectorPtr& vector,
+    vector_size_t index) {
+  return ::duckdb::Value::SMALLINT(
+      vector->as<SimpleVector<int16_t>>()->valueAt(index));
+}
+
+template <>
+::duckdb::Value duckValueAt<TypeKind::BOOLEAN>(
+    const VectorPtr& vector,
+    vector_size_t index) {
+  return ::duckdb::Value::BOOLEAN(
+      vector->as<SimpleVector<bool>>()->valueAt(index));
+}
+
 template <>
 ::duckdb::Value duckValueAt<TypeKind::VARCHAR>(
     const VectorPtr& vector,
@@ -67,6 +95,18 @@ ::duckdb::Value duckValueAt<TypeKind::TIMESTAMP>(
       veloxTimestampToDuckDB(vector->as<SimpleVector<T>>()->valueAt(index)));
 }
 
+template <>
+::duckdb::Value duckValueAt<TypeKind::INTEGER>(
+    const VectorPtr& vector,
+    vector_size_t index) {
+  auto type = vector->type();
+  if (type->isDate()) {
+    return ::duckdb::Value::DATE(::duckdb::Date::EpochDaysToDate(
+        vector->as<SimpleVector<int32_t>>()->valueAt(index)));
+  }
+  return ::duckdb::Value(vector->as<SimpleVector<int32_t>>()->valueAt(index));
+}
+
 template <>
 ::duckdb::Value duckValueAt<TypeKind::BIGINT>(
     const VectorPtr& vector,
@@ -80,6 +120,16 @@ ::duckdb::Value duckValueAt<TypeKind::BIGINT>(
         decimalType.precision(),
         decimalType.scale());
   }
+
+  if (type->isIntervalDayTime()) {
+    static constexpr int64_t kMicrosecondsInDay =
+        1000L * 1000L * 60L * 60L * 24L;
+    const auto interval = vector->as<SimpleVector<int64_t>>()->valueAt(index);
+    const int64_t microseconds = interval % kMicrosecondsInDay;
+    const int64_t days = interval / kMicrosecondsInDay;
+    return ::duckdb::Value::INTERVAL(0, days, microseconds);
+  }
+
   return ::duckdb::Value(vector->as<SimpleVector<T>>()->valueAt(index));
 }
 
@@ -88,12 +138,17 @@ ::duckdb::Value duckValueAt<TypeKind::HUGEINT>(
     const VectorPtr& vector,
     vector_size_t index) {
   using T = typename KindToFlatVector<TypeKind::HUGEINT>::WrapperType;
-  auto type = vector->type()->asLongDecimal();
   auto val = vector->as<SimpleVector<T>>()->valueAt(index);
   auto duckVal = ::duckdb::hugeint_t();
   duckVal.lower = (val << 64) >> 64;
   duckVal.upper = (val >> 64);
-  return ::duckdb::Value::DECIMAL(duckVal, type.precision(), type.scale());
+  if (vector->type()->isLongDecimal()) {
+    auto type = vector->type()->asLongDecimal();
+    return ::duckdb::Value::DECIMAL(
+        std::move(duckVal), type.precision(), type.scale());
+  }
+  // Flat vector is HUGEINT type and not the logical decimal type.
+  return ::duckdb::Value::HUGEINT(std::move(duckVal));
 }
 
 template <>
@@ -110,12 +165,13 @@ ::duckdb::Value duckValueAt<TypeKind::ARRAY>(
     return ::duckdb::Value::EMPTYLIST(duckdb::fromVeloxType(elements->type()));
   }
 
-  std::vector<::duckdb::Value> array;
+  ::duckdb::vector<::duckdb::Value> array;
   array.reserve(size);
   for (auto i = 0; i < size; i++) {
     auto innerRow = offset + i;
     if (elements->isNullAt(innerRow)) {
-      array.emplace_back(::duckdb::Value(nullptr));
+      array.emplace_back(
+          ::duckdb::Value(duckdb::fromVeloxType(elements->type())));
     } else {
       array.emplace_back(VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
           duckValueAt, elements->typeKind(), elements, innerRow));
@@ -133,7 +189,7 @@ ::duckdb::Value duckValueAt<TypeKind::ROW>(
   auto rowRow = vector->wrappedIndex(row);
   auto rowType = asRowType(rowVector->type());
 
-  std::vector<std::pair<std::string, ::duckdb::Value>> fields;
+  ::duckdb::vector<std::pair<std::string, ::duckdb::Value>> fields;
   for (auto i = 0; i < rowType->size(); ++i) {
     if (rowVector->childAt(i)->isNullAt(rowRow)) {
       fields.push_back({rowType->nameOf(i), ::duckdb::Value(nullptr)});
@@ -161,68 +217,78 @@ ::duckdb::Value duckValueAt<TypeKind::MAP>(
   const auto& mapValues = mapVector->mapValues();
   auto offset = mapVector->offsetAt(mapRow);
   auto size = mapVector->sizeAt(mapRow);
+  auto mapType = ::duckdb::ListType::GetChildType(::duckdb::LogicalType::MAP(
+      duckdb::fromVeloxType(mapKeys->type()),
+      duckdb::fromVeloxType(mapValues->type())));
   if (size == 0) {
-    return ::duckdb::Value::MAP(
-        ::duckdb::Value::EMPTYLIST(duckdb::fromVeloxType(mapKeys->type())),
-        ::duckdb::Value::EMPTYLIST(duckdb::fromVeloxType(mapValues->type())));
+    return ::duckdb::Value::MAP(mapType, ::duckdb::vector<::duckdb::Value>());
   }
 
-  std::vector<::duckdb::Value> duckKeysVector;
-  std::vector<::duckdb::Value> duckValuesVector;
-  duckKeysVector.reserve(size);
-  duckValuesVector.reserve(size);
+  ::duckdb::vector<::duckdb::Value> duckMap;
   for (auto i = 0; i < size; i++) {
     auto innerRow = offset + i;
-    duckKeysVector.emplace_back(VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-        duckValueAt, mapKeys->typeKind(), mapKeys, innerRow));
+    auto key = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        duckValueAt, mapKeys->typeKind(), mapKeys, innerRow);
+    ::duckdb::Value value;
     if (mapValues->isNullAt(innerRow)) {
-      duckValuesVector.emplace_back(::duckdb::Value(nullptr));
+      value = ::duckdb::Value(duckdb::fromVeloxType(mapValues->type()));
     } else {
-      duckValuesVector.emplace_back(VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-          duckValueAt, mapValues->typeKind(), mapValues, innerRow));
+      value = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          duckValueAt, mapValues->typeKind(), mapValues, innerRow);
     }
+    ::duckdb::child_list_t<::duckdb::Value> mapStruct;
+    mapStruct.push_back(make_pair("key", key));
+    mapStruct.push_back(make_pair("value", value));
+    duckMap.push_back(::duckdb::Value::STRUCT(mapStruct));
   }
-  return ::duckdb::Value::MAP(
-      ::duckdb::Value::LIST(duckKeysVector),
-      ::duckdb::Value::LIST(duckValuesVector));
+  return ::duckdb::Value::MAP(mapType, duckMap);
 }
 
 template <TypeKind kind>
-velox::variant
-variantAt(::duckdb::DataChunk* dataChunk, int32_t row, int32_t column) {
+variant variantAt(::duckdb::DataChunk* dataChunk, int32_t row, int32_t column) {
   using T = typename KindToFlatVector<kind>::WrapperType;
-  return velox::variant(dataChunk->GetValue(column, row).GetValue<T>());
+  return variant(dataChunk->GetValue(column, row).GetValue<T>());
 }
 
 template <>
-velox::variant variantAt<TypeKind::VARCHAR>(
+variant variantAt<TypeKind::VARCHAR>(
     ::duckdb::DataChunk* dataChunk,
     int32_t row,
     int32_t column) {
-  return velox::variant(
+  return variant(
       StringView(::duckdb::StringValue::Get(dataChunk->GetValue(column, row))));
 }
 
 template <>
-velox::variant variantAt<TypeKind::VARBINARY>(
+velox::variant variantAt<TypeKind::HUGEINT>(
     ::duckdb::DataChunk* dataChunk,
     int32_t row,
     int32_t column) {
-  return velox::variant(
+  auto unscaledValue =
+      dataChunk->GetValue(column, row).GetValue<::duckdb::hugeint_t>();
+  return variant(HugeInt::build(unscaledValue.upper, unscaledValue.lower));
+}
+
+template <>
+variant variantAt<TypeKind::VARBINARY>(
+    ::duckdb::DataChunk* dataChunk,
+    int32_t row,
+    int32_t column) {
+  return variant::binary(
       StringView(::duckdb::StringValue::Get(dataChunk->GetValue(column, row))));
 }
 
 template <>
-velox::variant variantAt<TypeKind::TIMESTAMP>(
+variant variantAt<TypeKind::TIMESTAMP>(
     ::duckdb::DataChunk* dataChunk,
     int32_t row,
     int32_t column) {
-  return velox::variant::timestamp(duckdbTimestampToVelox(
+  return variant::timestamp(duckdbTimestampToVelox(
       dataChunk->GetValue(column, row).GetValue<::duckdb::timestamp_t>()));
 }
 
 template <TypeKind kind>
-velox::variant variantAt(const ::duckdb::Value& value) {
+variant variantAt(const ::duckdb::Value& value) {
   if (value.type() == ::duckdb::LogicalType::INTERVAL) {
     return ::duckdb::Interval::GetMicro(value.GetValue<::duckdb::interval_t>());
   } else if (value.type() == ::duckdb::LogicalType::DATE) {
@@ -231,34 +297,38 @@ velox::variant variantAt(const ::duckdb::Value& value) {
     // NOTE: duckdb only support native cpp type for GetValue so we need to use
     // DeepCopiedType instead of WrapperType here.
     using T = typename TypeTraits<kind>::DeepCopiedType;
-    return velox::variant(value.GetValue<T>());
+    return variant(value.GetValue<T>());
   }
 }
 
 template <>
-velox::variant variantAt<TypeKind::TIMESTAMP>(const ::duckdb::Value& value) {
-  return velox::variant::timestamp(
+velox::variant variantAt<TypeKind::HUGEINT>(const ::duckdb::Value& value) {
+  auto hugeInt = ::duckdb::HugeIntValue::Get(value);
+  return velox::variant(HugeInt::build(hugeInt.upper, hugeInt.lower));
+}
+
+template <>
+variant variantAt<TypeKind::TIMESTAMP>(const ::duckdb::Value& value) {
+  return variant::timestamp(
       duckdbTimestampToVelox(value.GetValue<::duckdb::timestamp_t>()));
 }
 
 template <>
-velox::variant variantAt<TypeKind::VARCHAR>(const ::duckdb::Value& value) {
-  return velox::variant(StringView(::duckdb::StringValue::Get(value)));
+variant variantAt<TypeKind::VARCHAR>(const ::duckdb::Value& value) {
+  return variant(StringView(::duckdb::StringValue::Get(value)));
 }
 
 template <>
-velox::variant variantAt<TypeKind::VARBINARY>(const ::duckdb::Value& value) {
-  return velox::variant(StringView(::duckdb::StringValue::Get(value)));
+variant variantAt<TypeKind::VARBINARY>(const ::duckdb::Value& value) {
+  return variant::binary(StringView(::duckdb::StringValue::Get(value)));
 }
 
 variant nullVariant(const TypePtr& type) {
   return variant(type->kind());
 }
 
-velox::variant rowVariantAt(
-    const ::duckdb::Value& vector,
-    const TypePtr& rowType) {
-  std::vector<velox::variant> values;
+variant rowVariantAt(const ::duckdb::Value& vector, const TypePtr& rowType) {
+  std::vector<variant> values;
   const auto& structValue = ::duckdb::StructValue::GetChildren(vector);
   for (size_t i = 0; i < structValue.size(); ++i) {
     auto currChild = structValue[i];
@@ -274,45 +344,41 @@ velox::variant rowVariantAt(
       values.push_back(value);
     }
   }
-  return velox::variant::row(std::move(values));
+  return variant::row(std::move(values));
 }
 
-velox::variant mapVariantAt(
-    const ::duckdb::Value& vector,
-    const TypePtr& mapType) {
+variant mapVariantAt(const ::duckdb::Value& vector, const TypePtr& mapType) {
   std::map<variant, variant> map;
 
-  const auto& mapValue = ::duckdb::StructValue::GetChildren(vector);
-  VELOX_CHECK_EQ(mapValue.size(), 2);
-
   auto mapTypePtr = dynamic_cast<const MapType*>(mapType.get());
   auto keyType = mapTypePtr->keyType();
   auto valueType = mapTypePtr->valueType();
-  const auto& keyList = ::duckdb::ListValue::GetChildren(mapValue[0]);
-  const auto& valueList = ::duckdb::ListValue::GetChildren(mapValue[1]);
-  VELOX_CHECK_EQ(keyList.size(), valueList.size());
-  for (int i = 0; i < keyList.size(); i++) {
+
+  VELOX_CHECK_EQ(vector.type().id(), ::duckdb::LogicalTypeId::MAP);
+
+  const auto& valueList = ::duckdb::ListValue::GetChildren(vector);
+  for (int i = 0; i < valueList.size(); i++) {
     // TODO: Add support for complex key and value types.
     variant variantKey;
-    if (keyList[i].IsNull()) {
-      variantKey = nullVariant(keyType);
-    } else {
-      variantKey = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-          variantAt, keyType->kind(), keyList[i]);
-    }
     variant variantValue;
-    if (valueList[i].IsNull()) {
+    auto value = ::duckdb::StructValue::GetChildren(valueList[i]);
+    // Map key cannot be null.
+    VELOX_CHECK(!value[0].IsNull());
+    variantKey = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        variantAt, keyType->kind(), value[0]);
+
+    if (value[1].IsNull()) {
       variantValue = nullVariant(valueType);
     } else {
       variantValue = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-          variantAt, valueType->kind(), valueList[i]);
+          variantAt, valueType->kind(), value[1]);
     }
     map.insert({variantKey, variantValue});
   }
-  return velox::variant::map(map);
+  return variant::map(map);
 }
 
-velox::variant arrayVariantAt(
+variant arrayVariantAt(
     const ::duckdb::Value& vector,
     const TypePtr& arrayType) {
   std::vector<variant> array;
@@ -334,12 +400,12 @@ velox::variant arrayVariantAt(
       array.push_back(variant);
     }
   }
-  return velox::variant::array(std::move(array));
+  return variant::array(std::move(array));
 }
 
 std::vector<MaterializedRow> materialize(
     ::duckdb::DataChunk* dataChunk,
-    const std::shared_ptr<const RowType>& rowType) {
+    const RowTypePtr& rowType) {
   VELOX_CHECK_EQ(
       rowType->size(), dataChunk->GetTypes().size(), "Wrong number of columns");
 
@@ -389,14 +455,19 @@ std::vector<MaterializedRow> materialize(
 }
 
 template <TypeKind kind>
-velox::variant variantAt(VectorPtr vector, int32_t row) {
+variant variantAt(VectorPtr vector, int32_t row) {
   using T = typename KindToFlatVector<kind>::WrapperType;
-  return velox::variant(vector->as<SimpleVector<T>>()->valueAt(row));
+  return variant(vector->as<SimpleVector<T>>()->valueAt(row));
+}
+
+template <>
+variant variantAt<TypeKind::VARBINARY>(VectorPtr vector, int32_t row) {
+  return variant::binary(vector->as<SimpleVector<StringView>>()->valueAt(row));
 }
 
 variant variantAt(const VectorPtr& vector, vector_size_t row);
 
-velox::variant arrayVariantAt(const VectorPtr& vector, vector_size_t row) {
+variant arrayVariantAt(const VectorPtr& vector, vector_size_t row) {
   auto arrayVector = vector->wrappedVector()->as<ArrayVector>();
   auto& elements = arrayVector->elements();
 
@@ -404,16 +475,16 @@ velox::variant arrayVariantAt(const VectorPtr& vector, vector_size_t row) {
   auto offset = arrayVector->offsetAt(wrappedRow);
   auto size = arrayVector->sizeAt(wrappedRow);
 
-  std::vector<velox::variant> array;
+  std::vector<variant> array;
   array.reserve(size);
   for (auto i = 0; i < size; i++) {
     auto innerRow = offset + i;
     array.push_back(variantAt(elements, innerRow));
   }
-  return velox::variant::array(array);
+  return variant::array(array);
 }
 
-velox::variant mapVariantAt(const VectorPtr& vector, vector_size_t row) {
+variant mapVariantAt(const VectorPtr& vector, vector_size_t row) {
   auto mapVector = vector->wrappedVector()->as<MapVector>();
   auto& mapKeys = mapVector->mapKeys();
   auto& mapValues = mapVector->mapValues();
@@ -429,18 +500,18 @@ velox::variant mapVariantAt(const VectorPtr& vector, vector_size_t row) {
     auto value = variantAt(mapValues, innerRow);
     map.insert({key, value});
   }
-  return velox::variant::map(map);
+  return variant::map(map);
 }
 
-velox::variant rowVariantAt(const VectorPtr& vector, vector_size_t row) {
+variant rowVariantAt(const VectorPtr& vector, vector_size_t row) {
   auto rowValues = vector->wrappedVector()->as<RowVector>();
   auto wrappedRow = vector->wrappedIndex(row);
 
-  std::vector<velox::variant> values;
+  std::vector<variant> values;
   for (auto& child : rowValues->children()) {
     values.push_back(variantAt(child, wrappedRow));
   }
-  return velox::variant::row(std::move(values));
+  return variant::row(std::move(values));
 }
 
 variant variantAt(const VectorPtr& vector, vector_size_t row) {
@@ -475,16 +546,19 @@ MaterializedRow getColumns(
   return columns;
 }
 
-void printRow(const MaterializedRow& row, std::ostringstream& out) {
-  out << row[0];
+void printRow(
+    const MaterializedRow& row,
+    const TypePtr& type,
+    std::ostringstream& out) {
+  out << row[0].toJson(type->childAt(0));
   for (int32_t i = 1; i < row.size(); ++i) {
-    out << " | " << row[i];
+    out << " | " << row[i].toJson(type->childAt(i));
   }
 }
 
-std::string toString(const MaterializedRow& row) {
+std::string toString(const MaterializedRow& row, const TypePtr& type) {
   std::ostringstream oss;
-  printRow(row, oss);
+  printRow(row, type, oss);
   return oss.str();
 }
 
@@ -514,7 +588,7 @@ struct MaterializedRowEpsilonComparator {
   /// Returns user-friendly diff message generated by epsilon comparison of rows
   /// sorted by non-floating point columns. Should be called only after
   /// areEqual() returned false.
-  std::string getUserFriendlyDiff() const;
+  std::string getUserFriendlyDiff(const TypePtr& type) const;
 
  private:
   bool customLessThan(
@@ -597,34 +671,38 @@ std::string makeErrorMessage(
     const std::vector<MaterializedRow>& missingRows,
     const std::vector<MaterializedRow>& extraRows,
     size_t expectedSize,
-    size_t actualSize) {
+    size_t actualSize,
+    const TypePtr& type) {
   std::ostringstream message;
   message << "Expected " << expectedSize << ", got " << actualSize << std::endl;
   message << extraRows.size() << " extra rows, " << missingRows.size()
           << " missing rows" << std::endl;
 
-  auto extraRowsToPrint = std::min((size_t)10, extraRows.size());
+  auto extraRowsToPrint =
+      std::min((size_t)FLAGS_max_error_rows, extraRows.size());
   message << extraRowsToPrint << " of extra rows:" << std::endl;
 
   for (int32_t i = 0; i < extraRowsToPrint; i++) {
     message << "\t";
-    printRow(extraRows[i], message);
+    printRow(extraRows[i], type, message);
     message << std::endl;
   }
   message << std::endl;
 
-  auto missingRowsToPrint = std::min((size_t)10, missingRows.size());
+  auto missingRowsToPrint =
+      std::min((size_t)FLAGS_max_error_rows, missingRows.size());
   message << missingRowsToPrint << " of missing rows:" << std::endl;
   for (int32_t i = 0; i < missingRowsToPrint; i++) {
     message << "\t";
-    printRow(missingRows[i], message);
+    printRow(missingRows[i], type, message);
     message << std::endl;
   }
   message << std::endl;
   return message.str();
 }
 
-std::string MaterializedRowEpsilonComparator::getUserFriendlyDiff() const {
+std::string MaterializedRowEpsilonComparator::getUserFriendlyDiff(
+    const TypePtr& type) const {
   VELOX_CHECK(
       notEqual_, "This method must be called after compare() returned false.");
 
@@ -656,7 +734,11 @@ std::string MaterializedRowEpsilonComparator::getUserFriendlyDiff() const {
   }
 
   return makeErrorMessage(
-      missingRows, extraRows, expectedSorted_.size(), actualSorted_.size());
+      missingRows,
+      extraRows,
+      expectedSorted_.size(),
+      actualSorted_.size(),
+      type);
 }
 
 bool MaterializedRowEpsilonComparator::equalKeys(
@@ -760,7 +842,8 @@ std::optional<bool> MaterializedRowEpsilonComparator::areEqual(
 
 std::string generateUserFriendlyDiff(
     const MaterializedRowMultiset& expectedRows,
-    const MaterializedRowMultiset& actualRows) {
+    const MaterializedRowMultiset& actualRows,
+    const TypePtr& type) {
   std::vector<MaterializedRow> extraRows;
   std::set_difference(
       actualRows.begin(),
@@ -778,12 +861,15 @@ std::string generateUserFriendlyDiff(
       std::inserter(missingRows, missingRows.end()));
 
   return makeErrorMessage(
-      missingRows, extraRows, expectedRows.size(), actualRows.size());
+      missingRows, extraRows, expectedRows.size(), actualRows.size(), type);
 }
 
 void verifyDuckDBResult(const DuckDBQueryResult& result, std::string_view sql) {
   VELOX_CHECK(
-      result->success, "DuckDB query failed: {}\n{}", result->error, sql);
+      !result->HasError(),
+      "DuckDB query failed: {}\n{}",
+      result->GetError(),
+      sql);
 }
 
 } // namespace
@@ -793,14 +879,20 @@ std::vector<MaterializedRow> materialize(const RowVectorPtr& vector) {
   std::vector<MaterializedRow> rows;
   rows.reserve(size);
 
-  auto rowType = vector->type()->as<TypeKind::ROW>();
+  auto numColumns = vector->childrenSize();
+  std::vector<VectorPtr> simpleVectors(numColumns);
+
+  // variantAt() assumes you can upcast to SimpleVector, so we need to take
+  // the inner vector out of lazies first.
+  for (size_t i = 0; i < numColumns; ++i) {
+    simpleVectors[i] = BaseVector::loadedVectorShared(vector->childAt(i));
+  }
 
   for (size_t i = 0; i < size; ++i) {
-    auto numColumns = rowType.size();
     MaterializedRow row;
     row.reserve(numColumns);
     for (size_t j = 0; j < numColumns; ++j) {
-      row.push_back(variantAt(vector->childAt(j), i));
+      row.push_back(variantAt(simpleVectors[j], i));
     }
     rows.push_back(row);
   }
@@ -814,15 +906,15 @@ void DuckDbQueryRunner::createTable(
   auto query = fmt::format("DROP TABLE IF EXISTS {}", name);
   execute(query);
 
-  auto rowType = data[0]->type()->as<TypeKind::ROW>();
+  auto& rowType = data[0]->type()->as<TypeKind::ROW>();
   ::duckdb::Connection con(db_);
   auto sql = duckdb::makeCreateTableSql(name, rowType);
   auto res = con.Query(sql);
   verifyDuckDBResult(res, sql);
 
+  ::duckdb::Appender appender(con, name);
   for (auto& vector : data) {
     for (int32_t row = 0; row < vector->size(); row++) {
-      ::duckdb::Appender appender(con, name);
       appender.BeginRow();
       for (int32_t column = 0; column < rowType.size(); column++) {
         auto columnVector = vector->childAt(column);
@@ -839,15 +931,12 @@ void DuckDbQueryRunner::createTable(
           appender.Append(duckValueAt<TypeKind::BIGINT>(columnVector, row));
         } else if (rowType.childAt(column)->isLongDecimal()) {
           appender.Append(duckValueAt<TypeKind::HUGEINT>(columnVector, row));
-        } else if (type->isIntervalDayTime()) {
-          auto value = ::duckdb::Value::INTERVAL(
-              0, 0, columnVector->as<SimpleVector<int64_t>>()->valueAt(row));
-          appender.Append(value);
-        } else if (type->isDate()) {
-          auto value = ::duckdb::Value::DATE(::duckdb::Date::EpochDaysToDate(
-              columnVector->as<SimpleVector<int32_t>>()->valueAt(row)));
-          appender.Append(value);
         } else {
+          VELOX_CHECK(
+              type->equivalent(*columnVector->type()),
+              "{} vs. {}",
+              type->toString(),
+              columnVector->toString());
           auto value = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
               duckValueAt, type->kind(), columnVector, row);
           appender.Append(value);
@@ -865,12 +954,12 @@ DuckDBQueryResult DuckDbQueryRunner::execute(const std::string& sql) {
   con.Query("PRAGMA default_null_order='NULLS LAST'");
   auto duckDbResult = con.Query(sql);
   verifyDuckDBResult(duckDbResult, sql);
-  return duckDbResult;
+  return std::move(duckDbResult);
 }
 
 void DuckDbQueryRunner::execute(
     const std::string& sql,
-    const std::shared_ptr<const RowType>& resultRowType,
+    const RowTypePtr& resultRowType,
     std::function<void(std::vector<MaterializedRow>&)> resultCallback) {
   auto duckDbResult = execute(sql);
 
@@ -949,8 +1038,22 @@ bool assertEqualResults(
         rows.end(),
         std::inserter(expectedRows, expectedRows.end()));
   }
+  const auto& expectedType =
+      (expected.size() == 0) ? nullptr : expected.at(0)->type();
+  return assertEqualResults(expectedRows, expectedType, actual);
+}
+
+bool assertEqualResults(
+    const core::PlanNodePtr& plan1,
+    const core::PlanNodePtr& plan2) {
+  CursorParameters params1;
+  params1.planNode = plan1;
+  auto [cursor1, results1] = readCursor(params1, [](Task*) {});
 
-  return assertEqualResults(expectedRows, actual);
+  CursorParameters params2;
+  params2.planNode = plan2;
+  auto [cursor2, results2] = readCursor(params2, [](Task*) {});
+  return assertEqualResults(results1, results2);
 }
 
 void assertEqualTypeAndNumRows(
@@ -965,26 +1068,44 @@ void assertEqualTypeAndNumRows(
   EXPECT_EQ(expectedNumRows, actualNumRows);
 }
 
+bool containsFloatingPoint(const TypePtr& type) {
+  if (type->isPrimitiveType()) {
+    return type->isReal() || type->isDouble();
+  } else if (type->isArray()) {
+    return containsFloatingPoint(type->as<TypeKind::ARRAY>().elementType());
+  } else if (type->isMap()) {
+    // We currently don't support comparing maps with floating-point keys with
+    // epsilon. This is because fuzzer can generate floating-point keys that are
+    // very close, causing one key incorrectly match another during the
+    // comparison.
+    return containsFloatingPoint(type->as<TypeKind::MAP>().valueType());
+  } else if (type->isRow()) {
+    for (auto& child : type->as<TypeKind::ROW>().children()) {
+      if (containsFloatingPoint(child)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 /// Returns the number of floating-point columns and a list of columns indices
 /// with floating-point columns placed at the end.
 std::tuple<uint32_t, std::vector<velox::column_index_t>>
-findFloatingPointColumns(const MaterializedRow& row) {
-  auto isFloatingPointColumn = [&](size_t i) {
-    return row[i].kind() == TypeKind::REAL || row[i].kind() == TypeKind::DOUBLE;
-  };
-
+findFloatingPointColumns(const TypePtr& type) {
+  const auto rowType = asRowType(type);
   uint32_t numFloatingPointColumns = 0;
   std::vector<velox::column_index_t> indices;
-  for (auto i = 0; i < row.size(); ++i) {
-    if (isFloatingPointColumn(i)) {
+  for (auto i = 0; i < rowType->children().size(); ++i) {
+    if (containsFloatingPoint(rowType->childAt(i))) {
       ++numFloatingPointColumns;
     } else {
       indices.push_back(i);
     }
   }
 
-  for (auto i = 0; i < row.size(); ++i) {
-    if (isFloatingPointColumn(i)) {
+  for (auto i = 0; i < rowType->children().size(); ++i) {
+    if (containsFloatingPoint(rowType->childAt(i))) {
       indices.push_back(i);
     }
   }
@@ -1000,10 +1121,13 @@ findFloatingPointColumns(const MaterializedRow& row) {
 // hence can be compared directly.
 bool assertEqualResults(
     const MaterializedRowMultiset& expectedRows,
+    const TypePtr& expectedType,
     const MaterializedRowMultiset& actualRows,
+    const TypePtr& actualType,
     const std::string& message) {
+  const auto& type = (!expectedRows.empty()) ? expectedType : actualType;
   if (expectedRows.empty() != actualRows.empty()) {
-    ADD_FAILURE() << generateUserFriendlyDiff(expectedRows, actualRows)
+    ADD_FAILURE() << generateUserFriendlyDiff(expectedRows, actualRows, type)
                   << message;
     return false;
   }
@@ -1019,14 +1143,14 @@ bool assertEqualResults(
     return false;
   }
 
-  auto [numFloatingPointColumns, columns] =
-      findFloatingPointColumns(*expectedRows.begin());
+  auto [numFloatingPointColumns, columns] = findFloatingPointColumns(type);
   if (numFloatingPointColumns) {
     MaterializedRowEpsilonComparator comparator{
         numFloatingPointColumns, columns};
     if (auto result = comparator.areEqual(expectedRows, actualRows)) {
       if (!result.value()) {
-        ADD_FAILURE() << comparator.getUserFriendlyDiff() << message;
+        ADD_FAILURE() << comparator.getUserFriendlyDiff(expectedType)
+                      << message;
         return false;
       }
       return true;
@@ -1040,7 +1164,8 @@ bool assertEqualResults(
     std::string note = numFloatingPointColumns > 0
         ? "\nNote: results are compared without epsilon because values at non-floating-point columns do not form unique keys."
         : "";
-    ADD_FAILURE() << generateUserFriendlyDiff(expectedRows, actualRows)
+    ADD_FAILURE() << generateUserFriendlyDiff(
+                         expectedRows, actualRows, expectedType)
                   << message << note;
     return false;
   }
@@ -1061,27 +1186,41 @@ MaterializedRowMultiset materialize(const std::vector<RowVectorPtr>& vectors) {
 
 bool assertEqualResults(
     const MaterializedRowMultiset& expectedRows,
+    const TypePtr& expectedType,
     const std::vector<RowVectorPtr>& actual) {
+  const auto& actualType =
+      (actual.size() == 0) ? nullptr : actual.at(0)->type();
   return assertEqualResults(
-      expectedRows, materialize(actual), "Unexpected results");
+      expectedRows,
+      expectedType,
+      materialize(actual),
+      actualType,
+      "Unexpected results");
 }
 
 void assertResults(
     const std::vector<RowVectorPtr>& results,
-    const std::shared_ptr<const RowType>& resultType,
+    const RowTypePtr& resultType,
     const std::string& duckDbSql,
     DuckDbQueryRunner& duckDbQueryRunner) {
   MaterializedRowMultiset actualRows;
+  MaterializedRowMultiset expectedRows;
   for (const auto& vector : results) {
     auto rows = materialize(vector);
     std::copy(
         rows.begin(), rows.end(), std::inserter(actualRows, actualRows.end()));
   }
 
-  auto expectedRows = duckDbQueryRunner.execute(duckDbSql, resultType);
+  if (!duckDbSql.empty()) {
+    expectedRows = duckDbQueryRunner.execute(duckDbSql, resultType);
+  }
+  const auto& actualType =
+      (results.size() == 0) ? nullptr : results.at(0)->type();
   assertEqualResults(
       expectedRows,
+      resultType,
       actualRows,
+      actualType,
       kDuckDbTimestampWarning + "\nDuckDB query: " + duckDbSql);
 }
 
@@ -1092,10 +1231,11 @@ using OrderedPartition = std::pair<MaterializedRow, MaterializedRowMultiset>;
 
 // Special function to compare ordered partitions in a way that
 // we compare all floating point values inside using 'epsilon' constant.
-// Returns true if equal.
+// Returns true if equal. valueType is the type of expected.second.
 static bool compareOrderedPartitions(
     const OrderedPartition& expected,
-    const OrderedPartition& actual) {
+    const OrderedPartition& actual,
+    const RowTypePtr& valueType) {
   if (expected.first.size() != actual.first.size() or
       expected.second.size() != actual.second.size()) {
     return false;
@@ -1116,8 +1256,9 @@ static bool compareOrderedPartitions(
     return false;
   }
 
-  auto [numFloatingPointColumns, columns] =
-      findFloatingPointColumns(*expected.second.begin());
+  // valueType is needed by findFloatingPointColumns() to avoid having to infer
+  // the type from expected.second.
+  auto [numFloatingPointColumns, columns] = findFloatingPointColumns(valueType);
   if (numFloatingPointColumns) {
     MaterializedRowEpsilonComparator comparator{
         numFloatingPointColumns, columns};
@@ -1133,16 +1274,17 @@ static bool compareOrderedPartitions(
 
 // Special function to compare vectors of ordered partitions in a way that
 // we compare all floating point values inside using 'epsilon' constant.
-// Returns true if equal.
+// Returns true if equal. valueType is the type of expected[i].second.
 static bool compareOrderedPartitionsVectors(
     const std::vector<OrderedPartition>& expected,
-    const std::vector<OrderedPartition>& actual) {
+    const std::vector<OrderedPartition>& actual,
+    const RowTypePtr& valueType) {
   if (expected.size() != actual.size()) {
     return false;
   }
 
   for (size_t i = 0; i < expected.size(); ++i) {
-    if (not compareOrderedPartitions(expected[i], actual[i])) {
+    if (not compareOrderedPartitions(expected[i], actual[i], valueType)) {
       return false;
     }
   }
@@ -1152,7 +1294,7 @@ static bool compareOrderedPartitionsVectors(
 
 void assertResultsOrdered(
     const std::vector<RowVectorPtr>& results,
-    const std::shared_ptr<const RowType>& resultType,
+    const RowTypePtr& resultType,
     const std::string& duckDbSql,
     DuckDbQueryRunner& duckDbQueryRunner,
     const std::vector<uint32_t>& sortingKeys) {
@@ -1180,12 +1322,13 @@ void assertResultsOrdered(
   }
 
   if (not compareOrderedPartitionsVectors(
-          expectedPartitions, actualPartitions)) {
+          expectedPartitions, actualPartitions, resultType)) {
     auto actualPartIter = actualPartitions.begin();
     auto expectedPartIter = expectedPartitions.begin();
     while (expectedPartIter != expectedPartitions.end() &&
            actualPartIter != actualPartitions.end()) {
-      if (not compareOrderedPartitions(*expectedPartIter, *actualPartIter)) {
+      if (not compareOrderedPartitions(
+              *expectedPartIter, *actualPartIter, resultType)) {
         break;
       }
       ++expectedPartIter;
@@ -1193,19 +1336,21 @@ void assertResultsOrdered(
     }
     std::ostringstream oss;
     if (expectedPartIter == expectedPartitions.end()) {
-      oss << "Got extra rows: keys: " << toString(actualPartIter->first)
-          << std::endl;
+      oss << "Got extra rows: keys: "
+          << toString(actualPartIter->first, resultType) << std::endl;
     } else if (actualPartIter == actualPartitions.end()) {
-      oss << "Missing rows: keys: " << toString(expectedPartIter->first)
-          << std::endl;
+      oss << "Missing rows: keys: "
+          << toString(expectedPartIter->first, resultType) << std::endl;
     } else {
       if (actualPartIter->first != expectedPartIter->first) {
-        oss << "Expected keys: " << toString(expectedPartIter->first)
-            << ", actual: " << toString(actualPartIter->first) << std::endl;
+        oss << "Expected keys: "
+            << toString(expectedPartIter->first, resultType)
+            << ", actual: " << toString(actualPartIter->first, resultType)
+            << std::endl;
       } else {
-        oss << "Keys: " << toString(expectedPartIter->first) << " ";
+        oss << "Keys: " << toString(expectedPartIter->first, resultType) << " ";
         oss << generateUserFriendlyDiff(
-            expectedPartIter->second, actualPartIter->second);
+            expectedPartIter->second, actualPartIter->second, resultType);
       }
       ADD_FAILURE() << oss.str() << kDuckDbTimestampWarning
                     << "\nDuckDB query: " << duckDbSql;
@@ -1213,11 +1358,48 @@ void assertResultsOrdered(
   }
 }
 
+tsan_atomic<int32_t>& testingAbortPct() {
+  static tsan_atomic<int32_t> abortPct = 0;
+  return abortPct;
+}
+
+tsan_atomic<int32_t>& testingAbortCounter() {
+  static tsan_atomic<int32_t> counter = 0;
+  return counter;
+}
+
+TestScopedAbortInjection::TestScopedAbortInjection(
+    int32_t abortPct,
+    int32_t maxInjections) {
+  testingAbortPct() = abortPct;
+  testingAbortCounter() = maxInjections;
+}
+
+TestScopedAbortInjection::~TestScopedAbortInjection() {
+  testingAbortPct() = 0;
+  testingAbortCounter() = 0;
+}
+
+bool testingMaybeTriggerAbort(exec::Task* task) {
+  if (testingAbortPct() <= 0 || testingAbortCounter() <= 0) {
+    return false;
+  }
+
+  if ((folly::Random::rand32() % 100) < testingAbortPct()) {
+    if (testingAbortCounter()-- > 0) {
+      task->requestAbort();
+      return true;
+    }
+  }
+
+  return false;
+}
+
 std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>> readCursor(
     const CursorParameters& params,
     std::function<void(exec::Task*)> addSplits,
     uint64_t maxWaitMicros) {
-  auto cursor = std::make_unique<TaskCursor>(params);
+  auto cursor = TaskCursor::create(params);
   // 'result' borrows memory from cursor so the life cycle must be shorter.
   std::vector<RowVectorPtr> result;
   auto* task = cursor->task().get();
@@ -1226,9 +1408,25 @@ std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>> readCursor(
   while (cursor->moveNext()) {
     result.push_back(cursor->current());
     addSplits(task);
+    testingMaybeTriggerAbort(task);
+  }
+
+  if (!waitForTaskCompletion(task, maxWaitMicros)) {
+    // NOTE: there is async memory arbitration might fail the task after all the
+    // results have been consumed and before the task finishes. So we might run
+    // into the failed task state in some rare case such as exposed by
+    // concurrent memory arbitration test.
+    if (task->state() != TaskState::kFinished &&
+        task->state() != TaskState::kRunning) {
+      waitForTaskDriversToFinish(task, maxWaitMicros);
+      std::rethrow_exception(task->error());
+    } else {
+      VELOX_FAIL(
+          "Failed to wait for task to complete after {}, task: {}",
+          succinctMicros(maxWaitMicros),
+          task->toString());
+    }
   }
-
-  EXPECT_TRUE(waitForTaskCompletion(task, maxWaitMicros)) << task->taskId();
   return {std::move(cursor), std::move(result)};
 }
 
@@ -1266,7 +1464,9 @@ bool waitForTaskStateChange(
   // Wait for task to transition to finished state.
   if (task->state() != state) {
     auto& executor = folly::QueuedImmediateExecutor::instance();
-    auto future = task->taskCompletionFuture(maxWaitMicros).via(&executor);
+    auto future = task->taskCompletionFuture()
+                      .within(std::chrono::microseconds(maxWaitMicros))
+                      .via(&executor);
     future.wait();
   }
 
@@ -1375,9 +1575,7 @@ std::shared_ptr<Task> assertQuery(
   return result.first->task();
 }
 
-velox::variant readSingleValue(
-    const core::PlanNodePtr& plan,
-    int32_t maxDrivers) {
+variant readSingleValue(const core::PlanNodePtr& plan, int32_t maxDrivers) {
   CursorParameters params;
   params.planNode = plan;
   params.maxDrivers = maxDrivers;
@@ -1392,9 +1590,35 @@ velox::variant readSingleValue(
 
 void printResults(const RowVectorPtr& result, std::ostream& out) {
   auto materializedRows = materialize(result);
+  const auto& type = result->type();
   for (const auto& row : materializedRows) {
-    out << toString(row) << std::endl;
+    out << toString(row, type) << std::endl;
+  }
+}
+
+std::unordered_map<std::string, OperatorStats> toOperatorStats(
+    const TaskStats& taskStats) {
+  std::unordered_map<std::string, OperatorStats> opStatsMap;
+
+  for (const auto& pipelineStats : taskStats.pipelineStats) {
+    for (const auto& opStats : pipelineStats.operatorStats) {
+      const auto& opType = opStats.operatorType;
+      auto it = opStatsMap.find(opType);
+      if (it != opStatsMap.end()) {
+        it->second.add(opStats);
+      } else {
+        opStatsMap.emplace(opType, opStats);
+      }
+    }
   }
+  return opStatsMap;
 }
 
 } // namespace facebook::velox::exec::test
+
+template <>
+struct fmt::formatter<::duckdb::LogicalTypeId> : formatter<int> {
+  auto format(::duckdb::LogicalTypeId s, format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/exec/tests/utils/QueryAssertions.h b/velox/exec/tests/utils/QueryAssertions.h
index 4391ecc80e61c..217d12351e324 100644
--- a/velox/exec/tests/utils/QueryAssertions.h
+++ b/velox/exec/tests/utils/QueryAssertions.h
@@ -14,13 +14,16 @@
  * limitations under the License.
  */
 #pragma once
+#include <chrono>
+
+#include "velox/common/testutil/TestValue.h"
 #include "velox/core/PlanNode.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/tests/utils/Cursor.h"
-#include "velox/external/duckdb/duckdb.hpp"
-#include "velox/external/duckdb/tpch/include/tpch-extension.hpp"
 #include "velox/vector/ComplexVector.h"
 
+#include <duckdb.hpp> // @manual
+
 namespace facebook::velox::exec::test {
 
 using MaterializedRow = std::vector<velox::variant>;
@@ -47,7 +50,7 @@ class DuckDbQueryRunner {
 
   MaterializedRowMultiset execute(
       const std::string& sql,
-      const std::shared_ptr<const RowType>& resultRowType) {
+      const RowTypePtr& resultRowType) {
     MaterializedRowMultiset allRows;
     execute(
         sql,
@@ -61,7 +64,7 @@ class DuckDbQueryRunner {
 
   std::vector<MaterializedRow> executeOrdered(
       const std::string& sql,
-      const std::shared_ptr<const RowType>& resultRowType) {
+      const RowTypePtr& resultRowType) {
     std::vector<MaterializedRow> allRows;
     execute(
         sql,
@@ -77,14 +80,102 @@ class DuckDbQueryRunner {
 
   void execute(
       const std::string& sql,
-      const std::shared_ptr<const RowType>& resultRowType,
+      const RowTypePtr& resultRowType,
       std::function<void(std::vector<MaterializedRow>&)> resultCallback);
 };
 
+/// Scoped abort percentage utility that allows user to trigger abort during the
+///  query execution.
+/// 'abortPct' specifies the probability of of triggering abort. 100% means
+/// abort will always be triggered.
+/// 'maxInjections' indicates the max number of actual triggering, e.g. when
+/// 'abortPct' is 20 and 'maxInjections' is 10, continuous calls to
+/// testingMaybeTriggerAbort() will keep rolling the dice that has a chance of
+/// 20% triggering until 10 triggers have been invoked.
+class TestScopedAbortInjection {
+ public:
+  explicit TestScopedAbortInjection(
+      int32_t abortPct,
+      int32_t maxInjections = std::numeric_limits<int32_t>::max());
+
+  ~TestScopedAbortInjection();
+};
+
+// This class leverages TestValue to inject OOMs into query execution.
+// Therefore, it can only be used in debug builds, and only one instance
+// of this class can be enabled at a time.
+class ScopedOOMInjector {
+ public:
+  ScopedOOMInjector(
+      const std::function<bool()>& oomConditionChecker,
+      uint64_t oomCheckIntervalMs)
+      : oomConditionChecker_(oomConditionChecker),
+        oomCheckIntervalMs_(oomCheckIntervalMs) {}
+
+  inline static const std::string kErrorMessage = "Injected OOM";
+
+  void enable() {
+    // Since this relies on TestValue to trigger the OOMs, it only supports
+    // debug builds.
+#ifdef NDEBUG
+    VELOX_FAIL("OOM injection can only be used in debug builds");
+#endif
+
+    if (enabled_.exchange(true)) {
+      VELOX_FAIL("Already enabled");
+    }
+
+    // Make sure TestValues are enabled.
+    common::testutil::TestValue::enable();
+
+    common::testutil::TestValue::set(
+        kInjectionPoint,
+        std::function<void(memory::MemoryPool*)>([&](memory::MemoryPool*) {
+          const auto currentTime = now();
+          if (currentTime - lastOomCheckTime_ >= oomCheckIntervalMs_) {
+            lastOomCheckTime_ = currentTime;
+            if (oomConditionChecker_()) {
+              LOG(INFO) << "<-- Triggering OOM --";
+              VELOX_MEM_POOL_CAP_EXCEEDED(kErrorMessage);
+            }
+          }
+        }));
+  }
+
+  ~ScopedOOMInjector() {
+    common::testutil::TestValue::clear(kInjectionPoint);
+    enabled_ = false;
+  }
+
+ private:
+  inline static const std::string kInjectionPoint =
+      "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe";
+  // If more than one instance of this class is enabled, they'll overwrite
+  // each other, so make sure no one does this by accident.
+  inline static std::atomic_bool enabled_{false};
+
+  static size_t now() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+               std::chrono::system_clock::now().time_since_epoch())
+        .count();
+  }
+
+  // When this function returns true, an OOM will be triggered.
+  const std::function<bool()> oomConditionChecker_;
+  // The interval between each check of the condition.
+  const uint64_t oomCheckIntervalMs_;
+
+  std::atomic<size_t> lastOomCheckTime_{0};
+};
+
+/// Test utility that might trigger task abort. The function returns true if
+/// abortion triggers otherwise false.
+bool testingMaybeTriggerAbort(exec::Task* task);
+
 std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>> readCursor(
     const CursorParameters& params,
     std::function<void(exec::Task*)> addSplits,
-    uint64_t maxWaitMicros = 1'000'000);
+    uint64_t maxWaitMicros = 5'000'000);
 
 /// The Task can return results before the Driver is finished executing.
 /// Wait upto maxWaitMicros for the Task to finish as 'expectedState' before
@@ -155,13 +246,13 @@ void assertEmptyResults(const std::vector<RowVectorPtr>& results);
 
 void assertResults(
     const std::vector<RowVectorPtr>& results,
-    const std::shared_ptr<const RowType>& resultType,
+    const RowTypePtr& resultType,
     const std::string& duckDbSql,
     DuckDbQueryRunner& duckDbQueryRunner);
 
 void assertResultsOrdered(
     const std::vector<RowVectorPtr>& results,
-    const std::shared_ptr<const RowType>& resultType,
+    const RowTypePtr& resultType,
     const std::string& duckDbSql,
     DuckDbQueryRunner& duckDbQueryRunner,
     const std::vector<uint32_t>& sortingKeys);
@@ -202,9 +293,15 @@ bool assertEqualResults(
     const std::vector<RowVectorPtr>& actual);
 
 bool assertEqualResults(
-    const MaterializedRowMultiset& expected,
+    const MaterializedRowMultiset& expectedRows,
+    const TypePtr& expectedRowType,
     const std::vector<RowVectorPtr>& actual);
 
+/// Ensure both plans have the same results.
+bool assertEqualResults(
+    const core::PlanNodePtr& plan1,
+    const core::PlanNodePtr& plan2);
+
 /// Ensure both datasets have the same type and number of rows.
 void assertEqualTypeAndNumRows(
     const TypePtr& expectedType,
@@ -213,4 +310,10 @@ void assertEqualTypeAndNumRows(
 
 void printResults(const RowVectorPtr& result, std::ostream& out);
 
+/// Aggregates operator stats by operator type. If a task has more than one plan
+/// nodes having the same operator types, then their operator stats are merged
+/// together.
+std::unordered_map<std::string, OperatorStats> toOperatorStats(
+    const TaskStats& taskStats);
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/ReferenceQueryRunner.h b/velox/exec/tests/utils/ReferenceQueryRunner.h
deleted file mode 100644
index b9e5b3dd048c7..0000000000000
--- a/velox/exec/tests/utils/ReferenceQueryRunner.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/core/PlanNode.h"
-
-namespace facebook::velox::exec::test {
-
-/// Query runner that uses reference database, i.e. DuckDB, Presto, Spark.
-class ReferenceQueryRunner {
- public:
-  virtual ~ReferenceQueryRunner() = default;
-
-  /// Converts Velox plan into SQL accepted by the reference database.
-  /// @return std::nullopt if the plan uses features not supported by the
-  /// reference database.
-  virtual std::optional<std::string> toSql(const core::PlanNodePtr& plan) = 0;
-
-  /// Executes SQL query returned by the 'toSql' method using 'input' data.
-  /// Converts results using 'resultType' schema.
-  virtual std::multiset<std::vector<velox::variant>> execute(
-      const std::string& sql,
-      const std::vector<RowVectorPtr>& input,
-      const RowTypePtr& resultType) = 0;
-};
-
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/SumNonPODAggregate.cpp b/velox/exec/tests/utils/SumNonPODAggregate.cpp
index a78a1a465338d..b6e3a80b2f852 100644
--- a/velox/exec/tests/utils/SumNonPODAggregate.cpp
+++ b/velox/exec/tests/utils/SumNonPODAggregate.cpp
@@ -46,22 +46,6 @@ class SumNonPODAggregate : public Aggregate {
     return true;
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const velox::vector_size_t*> indices) override {
-    for (auto i : indices) {
-      char* group = value<char>(groups[i]);
-      VELOX_CHECK_EQ(reinterpret_cast<uintptr_t>(group) % alignment_, 0);
-      new (group) NonPODInt64(0);
-    }
-  }
-
-  void destroy(folly::Range<char**> groups) override {
-    for (auto group : groups) {
-      value<NonPODInt64>(group)->~NonPODInt64();
-    }
-  }
-
   void extractAccumulators(
       char** groups,
       int32_t numGroups,
@@ -134,6 +118,25 @@ class SumNonPODAggregate : public Aggregate {
     addSingleGroupIntermediateResults(group, rows, args, mayPushdown);
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const velox::vector_size_t*> indices) override {
+    for (auto i : indices) {
+      char* group = value<char>(groups[i]);
+      VELOX_CHECK_EQ(reinterpret_cast<uintptr_t>(group) % alignment_, 0);
+      new (group) NonPODInt64(0);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        value<NonPODInt64>(group)->~NonPODInt64();
+      }
+    }
+  }
+
  private:
   const int32_t alignment_;
 };
@@ -162,7 +165,9 @@ exec::AggregateRegistrationResult registerSumNonPODAggregate(
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<velox::exec::Aggregate> {
         return std::make_unique<SumNonPODAggregate>(velox::BIGINT(), alignment);
-      });
+      },
+      false /*registerCompanionFunctions*/,
+      true /*overwrite*/);
 }
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TempDirectoryPath.cpp b/velox/exec/tests/utils/TempDirectoryPath.cpp
index 146cbff328a72..358aa3229646c 100644
--- a/velox/exec/tests/utils/TempDirectoryPath.cpp
+++ b/velox/exec/tests/utils/TempDirectoryPath.cpp
@@ -20,21 +20,26 @@
 
 namespace facebook::velox::exec::test {
 
-std::shared_ptr<TempDirectoryPath> TempDirectoryPath::create() {
-  struct SharedTempDirectoryPath : public TempDirectoryPath {
-    SharedTempDirectoryPath() : TempDirectoryPath() {}
-  };
-  return std::make_shared<SharedTempDirectoryPath>();
+std::shared_ptr<TempDirectoryPath> TempDirectoryPath::create(bool injectFault) {
+  auto* tempDirPath = new TempDirectoryPath(injectFault);
+  return std::shared_ptr<TempDirectoryPath>(tempDirPath);
 }
 
 TempDirectoryPath::~TempDirectoryPath() {
-  LOG(INFO) << "TempDirectoryPath:: removing all files from" << path;
+  LOG(INFO) << "TempDirectoryPath:: removing all files from " << tempPath_;
   try {
-    boost::filesystem::remove_all(path.c_str());
+    boost::filesystem::remove_all(tempPath_.c_str());
   } catch (...) {
     LOG(WARNING)
         << "TempDirectoryPath:: destructor failed while calling boost::filesystem::remove_all";
   }
 }
 
+std::string TempDirectoryPath::createTempDirectory() {
+  char tempPath[] = "/tmp/velox_test_XXXXXX";
+  const char* tempDirectoryPath = ::mkdtemp(tempPath);
+  VELOX_CHECK_NOT_NULL(tempDirectoryPath, "Cannot open temp directory");
+  return tempDirectoryPath;
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TempDirectoryPath.h b/velox/exec/tests/utils/TempDirectoryPath.h
index 31d8d5dbea161..5c5124f536803 100644
--- a/velox/exec/tests/utils/TempDirectoryPath.h
+++ b/velox/exec/tests/utils/TempDirectoryPath.h
@@ -24,27 +24,39 @@
 
 namespace facebook::velox::exec::test {
 
-// It manages the lifetime of a temporary directory.
+/// Manages the lifetime of a temporary directory.
 class TempDirectoryPath {
  public:
-  static std::shared_ptr<TempDirectoryPath> create();
+  /// If 'enableFaultInjection' is true, we enable fault injection on the
+  /// created file directory.
+  static std::shared_ptr<TempDirectoryPath> create(
+      bool enableFaultInjection = false);
 
   virtual ~TempDirectoryPath();
 
-  const std::string path;
-
   TempDirectoryPath(const TempDirectoryPath&) = delete;
   TempDirectoryPath& operator=(const TempDirectoryPath&) = delete;
 
-  TempDirectoryPath() : path(createTempDirectory()) {}
-
-  static std::string createTempDirectory() {
-    char path[] = "/tmp/velox_test_XXXXXX";
-    const char* tempDirectoryPath = mkdtemp(path);
-    if (tempDirectoryPath == nullptr) {
-      throw std::logic_error("Cannot open temp directory");
-    }
-    return tempDirectoryPath;
+  /// If fault injection is enabled, the returned the file path has the faulty
+  /// file system prefix scheme. The velox fs then opens the directory through
+  /// the faulty file system. The actual file operation might either fails or
+  /// delegate to the actual file.
+  const std::string& getPath() const {
+    return path_;
   }
+
+ private:
+  static std::string createTempDirectory();
+
+  explicit TempDirectoryPath(bool enableFaultInjection)
+      : enableFaultInjection_(enableFaultInjection),
+        tempPath_(createTempDirectory()),
+        path_(
+            enableFaultInjection_ ? fmt::format("faulty:{}", tempPath_)
+                                  : tempPath_) {}
+
+  const bool enableFaultInjection_{false};
+  const std::string tempPath_;
+  const std::string path_;
 };
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TempFilePath.cpp b/velox/exec/tests/utils/TempFilePath.cpp
index 7c5cbe7370c18..d61245b61aab2 100644
--- a/velox/exec/tests/utils/TempFilePath.cpp
+++ b/velox/exec/tests/utils/TempFilePath.cpp
@@ -18,11 +18,22 @@
 
 namespace facebook::velox::exec::test {
 
-std::shared_ptr<TempFilePath> TempFilePath::create() {
-  struct SharedTempFilePath : public TempFilePath {
-    SharedTempFilePath() : TempFilePath() {}
-  };
-  return std::make_shared<SharedTempFilePath>();
+TempFilePath::~TempFilePath() {
+  ::unlink(tempPath_.c_str());
+  ::close(fd_);
 }
 
+std::shared_ptr<TempFilePath> TempFilePath::create(bool enableFaultInjection) {
+  auto* tempFilePath = new TempFilePath(enableFaultInjection);
+  return std::shared_ptr<TempFilePath>(tempFilePath);
+}
+
+std::string TempFilePath::createTempFile(TempFilePath* tempFilePath) {
+  char path[] = "/tmp/velox_test_XXXXXX";
+  tempFilePath->fd_ = ::mkstemp(path);
+  if (tempFilePath->fd_ == -1) {
+    VELOX_FAIL("Cannot open temp file: {}", folly::errnoStr(errno));
+  }
+  return path;
+}
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TempFilePath.h b/velox/exec/tests/utils/TempFilePath.h
index cf615b4131383..4683b84a97de8 100644
--- a/velox/exec/tests/utils/TempFilePath.h
+++ b/velox/exec/tests/utils/TempFilePath.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <sys/stat.h>
 #include <unistd.h>
 #include <cstdlib>
 #include <fstream>
@@ -25,43 +26,68 @@
 
 namespace facebook::velox::exec::test {
 
-// It manages the lifetime of a temporary file.
+/// Manages the lifetime of a temporary file.
 class TempFilePath {
  public:
-  static std::shared_ptr<TempFilePath> create();
+  /// If 'enableFaultInjection' is true, we enable fault injection on the
+  /// created file.
+  static std::shared_ptr<TempFilePath> create(
+      bool enableFaultInjection = false);
 
-  virtual ~TempFilePath() {
-    unlink(path.c_str());
-    close(fd);
-  }
-
-  const std::string path;
+  ~TempFilePath();
 
   TempFilePath(const TempFilePath&) = delete;
   TempFilePath& operator=(const TempFilePath&) = delete;
 
   void append(std::string data) {
-    std::ofstream file(path, std::ios_base::app);
+    std::ofstream file(tempPath_, std::ios_base::app);
     file << data;
     file.flush();
     file.close();
   }
 
- private:
-  int fd;
+  const int64_t fileSize() {
+    struct stat st;
+    ::stat(tempPath_.data(), &st);
+    return st.st_size;
+  }
+
+  int64_t fileModifiedTime() {
+    struct stat st;
+    ::stat(tempPath_.data(), &st);
+    return st.st_mtime;
+  }
 
-  TempFilePath() : path(createTempFile(this)) {
-    VELOX_CHECK_NE(fd, -1);
+  /// If fault injection is enabled, the returned the file path has the faulty
+  /// file system prefix scheme. The velox fs then opens the file through the
+  /// faulty file system. The actual file operation might either fails or
+  /// delegate to the actual file.
+  const std::string& getPath() const {
+    return path_;
   }
 
-  static std::string createTempFile(TempFilePath* tempFilePath) {
-    char path[] = "/tmp/velox_test_XXXXXX";
-    tempFilePath->fd = mkstemp(path);
-    if (tempFilePath->fd == -1) {
-      throw std::logic_error("Cannot open temp file");
-    }
-    return path;
+  // Returns the delegated file path if fault injection is enabled.
+  const std::string& tempFilePath() const {
+    return tempPath_;
   }
+
+ private:
+  static std::string createTempFile(TempFilePath* tempFilePath);
+
+  TempFilePath(bool enableFaultInjection)
+      : enableFaultInjection_(enableFaultInjection),
+        tempPath_(createTempFile(this)),
+        path_(
+            enableFaultInjection_ ? fmt::format("faulty:{}", tempPath_)
+                                  : tempPath_) {
+    VELOX_CHECK_NE(fd_, -1);
+  }
+
+  const bool enableFaultInjection_;
+  const std::string tempPath_;
+  const std::string path_;
+
+  int fd_;
 };
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/TpchQueryBuilder.cpp b/velox/exec/tests/utils/TpchQueryBuilder.cpp
index 1ef49e824d483..ea8a04bf6f731 100644
--- a/velox/exec/tests/utils/TpchQueryBuilder.cpp
+++ b/velox/exec/tests/utils/TpchQueryBuilder.cpp
@@ -25,9 +25,6 @@
 namespace facebook::velox::exec::test {
 
 namespace {
-int64_t toDate(std::string_view stringDate) {
-  return DATE()->toDays(stringDate);
-}
 
 /// DWRF does not support Date type and Varchar is used.
 /// Return the Date filter expression as per data format.
@@ -80,9 +77,9 @@ void TpchQueryBuilder::readFileSchema(
   std::shared_ptr<ReadFile> readFile;
   readFile.reset(uniqueReadFile.release());
   auto input = std::make_unique<dwio::common::BufferedInput>(
-      readFile, readerOptions.getMemoryPool());
+      readFile, readerOptions.memoryPool());
   std::unique_ptr<dwio::common::Reader> reader =
-      dwio::common::getReaderFactory(readerOptions.getFileFormat())
+      dwio::common::getReaderFactory(readerOptions.fileFormat())
           ->createReader(std::move(input), readerOptions);
   const auto fileType = reader->rowType();
   const auto fileColumnNames = fileType->names();
@@ -145,8 +142,12 @@ TpchPlan TpchQueryBuilder::getQueryPlan(int queryId) const {
   switch (queryId) {
     case 1:
       return getQ1Plan();
+    case 2:
+      return getQ2Plan();
     case 3:
       return getQ3Plan();
+    case 4:
+      return getQ4Plan();
     case 5:
       return getQ5Plan();
     case 6:
@@ -159,6 +160,8 @@ TpchPlan TpchQueryBuilder::getQueryPlan(int queryId) const {
       return getQ9Plan();
     case 10:
       return getQ10Plan();
+    case 11:
+      return getQ11Plan();
     case 12:
       return getQ12Plan();
     case 13:
@@ -239,6 +242,207 @@ TpchPlan TpchQueryBuilder::getQ1Plan() const {
   return context;
 }
 
+TpchPlan TpchQueryBuilder::getQ2Plan() const {
+  std::vector<std::string> supplierColumnsSubQuery = {
+      "s_suppkey", "s_nationkey"};
+  std::vector<std::string> nationColumnsSubQuery = {
+      "n_nationkey", "n_regionkey"};
+  std::vector<std::string> supplierColumns = {
+      "s_acctbal",
+      "s_name",
+      "s_address",
+      "s_phone",
+      "s_comment",
+      "s_suppkey",
+      "s_nationkey"};
+  std::vector<std::string> partColumns = {
+      "p_partkey", "p_mfgr", "p_size", "p_type"};
+  std::vector<std::string> partsuppColumns = {
+      "ps_partkey", "ps_suppkey", "ps_supplycost"};
+  std::vector<std::string> nationColumns = {
+      "n_nationkey", "n_name", "n_regionkey"};
+  std::vector<std::string> regionColumns = {"r_regionkey", "r_name"};
+
+  auto supplierSelectedRowTypeSubQuery =
+      getRowType(kSupplier, supplierColumnsSubQuery);
+  const auto& supplierFileColumnsSubQuery = getFileColumnNames(kSupplier);
+  auto nationSelectedRowTypeSubQuery =
+      getRowType(kNation, nationColumnsSubQuery);
+  const auto& nationFileColumnsSubQuery = getFileColumnNames(kNation);
+  auto partSelectedRowType = getRowType(kPart, partColumns);
+  const auto& partFileColumns = getFileColumnNames(kPart);
+  auto supplierSelectedRowType = getRowType(kSupplier, supplierColumns);
+  const auto& supplierFileColumns = getFileColumnNames(kSupplier);
+  auto partsuppSelectedRowType = getRowType(kPartsupp, partsuppColumns);
+  const auto& partsuppFileColumns = getFileColumnNames(kPartsupp);
+  auto nationSelectedRowType = getRowType(kNation, nationColumns);
+  const auto& nationFileColumns = getFileColumnNames(kNation);
+  auto regionSelectedRowType = getRowType(kRegion, regionColumns);
+  const auto& regionFileColumns = getFileColumnNames(kRegion);
+
+  const std::string regionNameFilter = "r_name = 'EUROPE'";
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId supplierScanIdSubQuery;
+  core::PlanNodeId partsuppScanIdSubQuery;
+  core::PlanNodeId nationScanIdSubQuery;
+  core::PlanNodeId regionScanIdSubQuery;
+  core::PlanNodeId partScanId;
+  core::PlanNodeId supplierScanId;
+  core::PlanNodeId partsuppScanId;
+  core::PlanNodeId nationScanId;
+  core::PlanNodeId regionScanId;
+
+  auto regionSubQuery = PlanBuilder(planNodeIdGenerator)
+                            .tableScan(
+                                kRegion,
+                                regionSelectedRowType,
+                                regionFileColumns,
+                                {regionNameFilter})
+                            .capturePlanNodeId(regionScanIdSubQuery)
+                            .planNode();
+
+  auto nationJoinRegionSubQuery =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(
+              kNation, nationSelectedRowTypeSubQuery, nationFileColumnsSubQuery)
+          .capturePlanNodeId(nationScanIdSubQuery)
+          .hashJoin(
+              {"n_regionkey"},
+              {"r_regionkey"},
+              regionSubQuery,
+              "",
+              {"n_nationkey"})
+          .planNode();
+
+  auto supplierJoinNationJoinRegionSubQuery =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(
+              kSupplier,
+              supplierSelectedRowTypeSubQuery,
+              supplierFileColumnsSubQuery)
+          .capturePlanNodeId(supplierScanIdSubQuery)
+          .hashJoin(
+              {"s_nationkey"},
+              {"n_nationkey"},
+              nationJoinRegionSubQuery,
+              "",
+              {"s_suppkey"})
+          .planNode();
+
+  auto part = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(
+                      kPart,
+                      partSelectedRowType,
+                      partFileColumns,
+                      {},
+                      "p_type like '%BRASS'")
+                  .capturePlanNodeId(partScanId)
+                  .filter("p_size = 15")
+                  .planNode();
+
+  auto region = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(
+                        kRegion,
+                        regionSelectedRowType,
+                        regionFileColumns,
+                        {regionNameFilter})
+                    .capturePlanNodeId(regionScanId)
+                    .planNode();
+
+  auto nationJoinRegion =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(kNation, nationSelectedRowType, nationFileColumns)
+          .capturePlanNodeId(nationScanId)
+          .hashJoin(
+              {"n_regionkey"},
+              {"r_regionkey"},
+              region,
+              "",
+              {"n_nationkey", "n_name"})
+          .planNode();
+
+  auto supplierJoinNationJoinRegion =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(kSupplier, supplierSelectedRowType, supplierFileColumns)
+          .capturePlanNodeId(supplierScanId)
+          .hashJoin(
+              {"s_nationkey"},
+              {"n_nationkey"},
+              nationJoinRegion,
+              "",
+              mergeColumnNames(supplierColumns, {"s_suppkey", "n_name"}))
+          .planNode();
+
+  auto partsuppJoinPartJoinSupplierJoinNationJoinRegion =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(kPartsupp, partsuppSelectedRowType, partsuppFileColumns)
+          .capturePlanNodeId(partsuppScanId)
+          .hashJoin(
+              {"ps_partkey"},
+              {"p_partkey"},
+              part,
+              "",
+              {"ps_suppkey", "ps_supplycost", "p_partkey", "p_mfgr"})
+          .hashJoin(
+              {"ps_suppkey"},
+              {"s_suppkey"},
+              supplierJoinNationJoinRegion,
+              "",
+              mergeColumnNames(
+                  supplierColumns,
+                  {"ps_supplycost", "p_partkey", "p_mfgr", "n_name"}))
+          .planNode();
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(kPartsupp, partsuppSelectedRowType, partsuppFileColumns)
+          .capturePlanNodeId(partsuppScanIdSubQuery)
+          .hashJoin(
+              {"ps_suppkey"},
+              {"s_suppkey"},
+              supplierJoinNationJoinRegionSubQuery,
+              "",
+              {"ps_supplycost", "ps_partkey"})
+          .partialAggregation(
+              {"ps_partkey"}, {"min(ps_supplycost) AS min_supplycost"})
+          .localPartition({"ps_partkey"})
+          .finalAggregation()
+          .hashJoin(
+              {"ps_partkey"},
+              {"p_partkey"},
+              partsuppJoinPartJoinSupplierJoinNationJoinRegion,
+              "ps_supplycost = min_supplycost",
+              mergeColumnNames(
+                  supplierColumns, {"p_partkey", "p_mfgr", "n_name"}))
+          .orderBy({"s_acctbal DESC", "n_name", "s_name", "p_partkey"}, false)
+          .project(
+              {"s_acctbal",
+               "s_name",
+               "n_name",
+               "p_partkey",
+               "p_mfgr",
+               "s_address",
+               "s_phone",
+               "s_comment"})
+          .limit(0, 100, false)
+          .planNode();
+
+  TpchPlan context;
+  context.plan = std::move(plan);
+  context.dataFiles[supplierScanIdSubQuery] = getTableFilePaths(kSupplier);
+  context.dataFiles[partsuppScanIdSubQuery] = getTableFilePaths(kPartsupp);
+  context.dataFiles[nationScanIdSubQuery] = getTableFilePaths(kNation);
+  context.dataFiles[regionScanIdSubQuery] = getTableFilePaths(kRegion);
+  context.dataFiles[partScanId] = getTableFilePaths(kPart);
+  context.dataFiles[supplierScanId] = getTableFilePaths(kSupplier);
+  context.dataFiles[partsuppScanId] = getTableFilePaths(kPartsupp);
+  context.dataFiles[nationScanId] = getTableFilePaths(kNation);
+  context.dataFiles[regionScanId] = getTableFilePaths(kRegion);
+  context.dataFileFormat = format_;
+  return context;
+}
+
 TpchPlan TpchQueryBuilder::getQ3Plan() const {
   std::vector<std::string> lineitemColumns = {
       "l_shipdate", "l_orderkey", "l_extendedprice", "l_discount"};
@@ -327,6 +531,65 @@ TpchPlan TpchQueryBuilder::getQ3Plan() const {
   return context;
 }
 
+TpchPlan TpchQueryBuilder::getQ4Plan() const {
+  std::vector<std::string> ordersColumns = {
+      "o_orderdate", "o_orderpriority", "o_orderkey"};
+  std::vector<std::string> lineitemColumns = {
+      "l_orderkey", "l_commitdate", "l_receiptdate"};
+
+  auto ordersSelectedRowType = getRowType(kOrders, ordersColumns);
+  const auto& ordersFileColumns = getFileColumnNames(kOrders);
+  auto lineitemSelectedRowType = getRowType(kLineitem, lineitemColumns);
+  const auto& lineitemFileColumns = getFileColumnNames(kLineitem);
+
+  std::string orderDateFilter = formatDateFilter(
+      "o_orderdate", ordersSelectedRowType, "'1993-07-01'", "'1993-09-30'");
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId lineitemPlanNodeId;
+  core::PlanNodeId ordersPlanNodeId;
+
+  auto orders = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .tableScan(
+                        kOrders,
+                        ordersSelectedRowType,
+                        ordersFileColumns,
+                        {orderDateFilter})
+                    .capturePlanNodeId(ordersPlanNodeId)
+                    .planNode();
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator, pool_.get())
+          .tableScan(
+              kLineitem,
+              lineitemSelectedRowType,
+              lineitemFileColumns,
+              {},
+              "l_commitdate < l_receiptdate")
+          .capturePlanNodeId(lineitemPlanNodeId)
+          .partialAggregation({"l_orderkey"}, {}, {})
+          .localPartition({"l_orderkey"})
+          .finalAggregation()
+          .hashJoin(
+              {"l_orderkey"},
+              {"o_orderkey"},
+              orders,
+              "",
+              {"o_orderpriority"},
+              core::JoinType::kRightSemiFilter)
+          .partialAggregation({"o_orderpriority"}, {"count(0) AS order_count"})
+          .finalAggregation()
+          .orderBy({"o_orderpriority"}, false)
+          .planNode();
+
+  TpchPlan context;
+  context.plan = std::move(plan);
+  context.dataFiles[lineitemPlanNodeId] = getTableFilePaths(kLineitem);
+  context.dataFiles[ordersPlanNodeId] = getTableFilePaths(kOrders);
+  context.dataFileFormat = format_;
+  return context;
+}
+
 TpchPlan TpchQueryBuilder::getQ5Plan() const {
   std::vector<std::string> customerColumns = {"c_custkey", "c_nationkey"};
   std::vector<std::string> ordersColumns = {
@@ -1060,6 +1323,132 @@ TpchPlan TpchQueryBuilder::getQ10Plan() const {
   return context;
 }
 
+TpchPlan TpchQueryBuilder::getQ11Plan() const {
+  // Column definitions.
+  std::vector<std::string> partsuppColumns = {
+      "ps_partkey", "ps_suppkey", "ps_availqty", "ps_supplycost"};
+  std::vector<std::string> partsuppColumnsSubQuery = {
+      "ps_availqty", "ps_suppkey", "ps_supplycost"};
+  std::vector<std::string> supplierColumns = {"s_suppkey", "s_nationkey"};
+  std::vector<std::string> nationColumns = {"n_nationkey", "n_name"};
+
+  // Row type definitions.
+  auto partsuppRowType = getRowType(kPartsupp, partsuppColumns);
+  auto partsuppRowTypeSubQuery = getRowType(kPartsupp, partsuppColumnsSubQuery);
+  auto supplierRowType = getRowType(kSupplier, supplierColumns);
+  auto nationRowType = getRowType(kNation, nationColumns);
+
+  // File columns.
+  const auto& partsuppFileColumns = getFileColumnNames(kPartsupp);
+  const auto& partsuppFileColumnsSubQuery = getFileColumnNames(kPartsupp);
+  const auto& supplierFileColumns = getFileColumnNames(kSupplier);
+  const auto& nationFileColumns = getFileColumnNames(kNation);
+
+  // Filter for nation name.
+  const std::string nationNameFilter = "n_name = 'GERMANY'";
+
+  // Plan node ID generator.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  // Subquery plan nodes.
+  core::PlanNodeId partsuppScanIdSubQuery;
+  core::PlanNodeId supplierScanIdSubQuery;
+  core::PlanNodeId nationScanIdSubQuery;
+
+  // Main query plan nodes.
+  core::PlanNodeId partsuppScanId;
+  core::PlanNodeId supplierScanId;
+  core::PlanNodeId nationScanId;
+
+  // Subquery plan to calculate filter cost.
+  auto nationSubQuery =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(
+              kNation, nationRowType, nationFileColumns, {nationNameFilter})
+          .capturePlanNodeId(nationScanIdSubQuery)
+          .planNode();
+
+  auto supplierJoinNationSubQuery =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(kSupplier, supplierRowType, supplierFileColumns)
+          .capturePlanNodeId(supplierScanIdSubQuery)
+          .hashJoin(
+              {"s_nationkey"},
+              {"n_nationkey"},
+              nationSubQuery,
+              "",
+              {"s_suppkey"})
+          .planNode();
+
+  auto subQueryPlan =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(
+              kPartsupp, partsuppRowTypeSubQuery, partsuppFileColumnsSubQuery)
+          .capturePlanNodeId(partsuppScanIdSubQuery)
+          .hashJoin(
+              {"ps_suppkey"},
+              {"s_suppkey"},
+              supplierJoinNationSubQuery,
+              "",
+              {"ps_availqty", "ps_suppkey", "ps_supplycost"})
+          .project({"ps_supplycost * ps_availqty AS product_cost_qty"})
+          .partialAggregation({}, {"sum(product_cost_qty) AS sum_cost_qty"})
+          .localPartition({})
+          .finalAggregation()
+          .project({"sum_cost_qty * 0.0001 AS filter_cost_qty"})
+          .planNode();
+
+  // Query plan.
+  auto nation =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(
+              kNation, nationRowType, nationFileColumns, {nationNameFilter})
+          .capturePlanNodeId(nationScanId)
+          .planNode();
+
+  auto supplierJoinNation =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(kSupplier, supplierRowType, supplierFileColumns)
+          .capturePlanNodeId(supplierScanId)
+          .hashJoin({"s_nationkey"}, {"n_nationkey"}, nation, "", {"s_suppkey"})
+          .planNode();
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(kPartsupp, partsuppRowType, partsuppFileColumns)
+          .capturePlanNodeId(partsuppScanId)
+          .hashJoin(
+              {"ps_suppkey"},
+              {"s_suppkey"},
+              supplierJoinNation,
+              "",
+              {"ps_partkey", "ps_availqty", "ps_supplycost"})
+          .project(
+              {"ps_supplycost * ps_availqty AS product_cost_qty", "ps_partkey"})
+          .partialAggregation(
+              {"ps_partkey"}, {"sum(product_cost_qty) AS value"})
+          .localPartition({"ps_partkey"})
+          .finalAggregation()
+          .nestedLoopJoin(
+              subQueryPlan, {"ps_partkey", "value", "filter_cost_qty"})
+          .filter("value > filter_cost_qty")
+          .project({"ps_partkey", "value"})
+          .orderBy({"value DESC"}, false)
+          .planNode();
+
+  // Create context and return.
+  TpchPlan context;
+  context.plan = std::move(plan);
+  context.dataFiles[partsuppScanIdSubQuery] = getTableFilePaths(kPartsupp);
+  context.dataFiles[supplierScanIdSubQuery] = getTableFilePaths(kSupplier);
+  context.dataFiles[nationScanIdSubQuery] = getTableFilePaths(kNation);
+  context.dataFiles[partsuppScanId] = getTableFilePaths(kPartsupp);
+  context.dataFiles[supplierScanId] = getTableFilePaths(kSupplier);
+  context.dataFiles[nationScanId] = getTableFilePaths(kNation);
+  context.dataFileFormat = format_;
+  return context;
+}
+
 TpchPlan TpchQueryBuilder::getQ12Plan() const {
   std::vector<std::string> ordersColumns = {"o_orderkey", "o_orderpriority"};
   std::vector<std::string> lineitemColumns = {
diff --git a/velox/exec/tests/utils/TpchQueryBuilder.h b/velox/exec/tests/utils/TpchQueryBuilder.h
index 0bcc8f594a4ae..65f20f9a8af6c 100644
--- a/velox/exec/tests/utils/TpchQueryBuilder.h
+++ b/velox/exec/tests/utils/TpchQueryBuilder.h
@@ -91,13 +91,16 @@ class TpchQueryBuilder {
       const std::vector<std::string>& columns);
 
   TpchPlan getQ1Plan() const;
+  TpchPlan getQ2Plan() const;
   TpchPlan getQ3Plan() const;
+  TpchPlan getQ4Plan() const;
   TpchPlan getQ5Plan() const;
   TpchPlan getQ6Plan() const;
   TpchPlan getQ7Plan() const;
   TpchPlan getQ8Plan() const;
   TpchPlan getQ9Plan() const;
   TpchPlan getQ10Plan() const;
+  TpchPlan getQ11Plan() const;
   TpchPlan getQ12Plan() const;
   TpchPlan getQ13Plan() const;
   TpchPlan getQ14Plan() const;
@@ -143,7 +146,7 @@ class TpchQueryBuilder {
   static constexpr const char* kSupplier = "supplier";
   static constexpr const char* kPartsupp = "partsupp";
   std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::addDefaultLeafMemoryPool();
+      memory::memoryManager()->addLeafPool();
 };
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/trace/CMakeLists.txt b/velox/exec/trace/CMakeLists.txt
new file mode 100644
index 0000000000000..f8cc53e08ae4f
--- /dev/null
+++ b/velox/exec/trace/CMakeLists.txt
@@ -0,0 +1,48 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(
+  velox_query_trace_exec
+  QueryMetadataWriter.cpp
+  QueryTraceConfig.cpp
+  QueryDataWriter.cpp
+  QueryTraceUtil.cpp)
+
+velox_link_libraries(
+  velox_query_trace_exec
+  PRIVATE
+    velox_common_io
+    velox_file
+    velox_core
+    velox_vector
+    velox_connector
+    velox_common_base
+    velox_presto_serializer)
+
+velox_add_library(velox_query_trace_retrieve QueryDataReader.cpp
+                  QueryMetadataReader.cpp)
+
+velox_link_libraries(
+  velox_query_trace_retrieve
+  velox_common_io
+  velox_file
+  velox_core
+  velox_vector
+  velox_connector
+  velox_common_base
+  velox_hive_connector)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(test)
+endif()
diff --git a/velox/exec/trace/QueryDataReader.cpp b/velox/exec/trace/QueryDataReader.cpp
new file mode 100644
index 0000000000000..f0175fe11b367
--- /dev/null
+++ b/velox/exec/trace/QueryDataReader.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryDataReader.h"
+
+#include "velox/common/file/File.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryDataReader::QueryDataReader(std::string path, memory::MemoryPool* pool)
+    : path_(std::move(path)),
+      fs_(filesystems::getFileSystem(path_, nullptr)),
+      pool_(pool),
+      dataType_(getTraceDataType()),
+      dataStream_(getDataInputStream()) {
+  VELOX_CHECK_NOT_NULL(dataType_);
+  VELOX_CHECK_NOT_NULL(dataStream_);
+}
+
+bool QueryDataReader::read(RowVectorPtr& batch) const {
+  if (dataStream_->atEnd()) {
+    batch = nullptr;
+    return false;
+  }
+
+  VectorStreamGroup::read(
+      dataStream_.get(), pool_, dataType_, &batch, &readOptions_);
+  return true;
+}
+
+RowTypePtr QueryDataReader::getTraceDataType() const {
+  const auto summaryFile = fs_->openFileForRead(
+      fmt::format("{}/{}", path_, QueryTraceTraits::kDataSummaryFileName));
+  const auto summary = summaryFile->pread(0, summaryFile->size());
+  VELOX_USER_CHECK(!summary.empty());
+  folly::dynamic obj = folly::parseJson(summary);
+  return ISerializable::deserialize<RowType>(obj["rowType"]);
+}
+
+std::unique_ptr<common::FileInputStream> QueryDataReader::getDataInputStream()
+    const {
+  auto dataFile = fs_->openFileForRead(
+      fmt::format("{}/{}", path_, QueryTraceTraits::kDataFileName));
+  // TODO: Make the buffer size configurable.
+  return std::make_unique<common::FileInputStream>(
+      std::move(dataFile), 1 << 20, pool_);
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryDataReader.h b/velox/exec/trace/QueryDataReader.h
new file mode 100644
index 0000000000000..ad61bde5886f2
--- /dev/null
+++ b/velox/exec/trace/QueryDataReader.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/FileInputStream.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec::trace {
+
+class QueryDataReader {
+ public:
+  explicit QueryDataReader(std::string path, memory::MemoryPool* pool);
+
+  /// Reads from 'dataStream_' and deserializes to 'batch'. Returns false if
+  /// reaches to end of the stream and 'batch' is set to nullptr.
+  bool read(RowVectorPtr& batch) const;
+
+ private:
+  RowTypePtr getTraceDataType() const;
+
+  std::unique_ptr<common::FileInputStream> getDataInputStream() const;
+
+  const std::string path_;
+  const serializer::presto::PrestoVectorSerde::PrestoOptions readOptions_{
+      true,
+      common::CompressionKind_ZSTD, // TODO: Use trace config.
+      /*nullsFirst=*/true};
+  const std::shared_ptr<filesystems::FileSystem> fs_;
+  memory::MemoryPool* const pool_;
+  const RowTypePtr dataType_;
+  const std::unique_ptr<common::FileInputStream> dataStream_;
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryDataWriter.cpp b/velox/exec/trace/QueryDataWriter.cpp
new file mode 100644
index 0000000000000..57dc4284cd10b
--- /dev/null
+++ b/velox/exec/trace/QueryDataWriter.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryDataWriter.h"
+#include "velox/common/base/SpillStats.h"
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryDataWriter::QueryDataWriter(
+    const std::string& path,
+    memory::MemoryPool* pool)
+    : dirPath_(path),
+      fs_(filesystems::getFileSystem(dirPath_, nullptr)),
+      pool_(pool) {
+  dataFile_ = fs_->openFileForWrite(
+      fmt::format("{}/{}", dirPath_, QueryTraceTraits::kDataFileName));
+  VELOX_CHECK_NOT_NULL(dataFile_);
+}
+
+void QueryDataWriter::write(const RowVectorPtr& rows) {
+  if (batch_ == nullptr) {
+    batch_ = std::make_unique<VectorStreamGroup>(pool_);
+    batch_->createStreamTree(
+        std::static_pointer_cast<const RowType>(rows->type()),
+        1'000,
+        &options_);
+  }
+  batch_->append(rows);
+  dataType_ = rows->type();
+
+  // Serialize and write out each batch.
+  IOBufOutputStream out(
+      *pool_, nullptr, std::max<int64_t>(64 * 1024, batch_->size()));
+  batch_->flush(&out);
+  batch_->clear();
+  auto iobuf = out.getIOBuf();
+  dataFile_->append(std::move(iobuf));
+}
+
+void QueryDataWriter::finish() {
+  VELOX_CHECK_NOT_NULL(
+      dataFile_, "The query data writer has already been finished");
+  dataFile_->close();
+  dataFile_.reset();
+  batch_.reset();
+  writeSummary();
+}
+
+void QueryDataWriter::writeSummary() const {
+  const auto summaryFilePath =
+      fmt::format("{}/{}", dirPath_, QueryTraceTraits::kDataSummaryFileName);
+  const auto file = fs_->openFileForWrite(summaryFilePath);
+  folly::dynamic obj = folly::dynamic::object;
+  obj[QueryTraceTraits::kDataTypeKey] = dataType_->serialize();
+  file->append(folly::toJson(obj));
+  file->close();
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryDataWriter.h b/velox/exec/trace/QueryDataWriter.h
new file mode 100644
index 0000000000000..435a0bccc00f9
--- /dev/null
+++ b/velox/exec/trace/QueryDataWriter.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec::trace {
+
+/// Used to serialize and write the input vectors from a given operator into a
+/// file.
+class QueryDataWriter {
+ public:
+  explicit QueryDataWriter(const std::string& path, memory::MemoryPool* pool);
+
+  /// Serializes rows and writes out each batch.
+  void write(const RowVectorPtr& rows);
+
+  /// Closes the data file and writes out the data summary.
+  ///
+  /// NOTE: This method should be only called once.
+  void finish();
+
+ private:
+  // Flushes the trace data summaries to the disk.
+  //
+  // TODO: add more summaries such as number of rows etc.
+  void writeSummary() const;
+
+  const std::string dirPath_;
+  // TODO: make 'useLosslessTimestamp' configuerable.
+  const serializer::presto::PrestoVectorSerde::PrestoOptions options_ = {
+      true,
+      common::CompressionKind::CompressionKind_ZSTD,
+      /*nullsFirst=*/true};
+  const std::shared_ptr<filesystems::FileSystem> fs_;
+  memory::MemoryPool* const pool_;
+  std::unique_ptr<WriteFile> dataFile_;
+  TypePtr dataType_;
+  std::unique_ptr<VectorStreamGroup> batch_;
+};
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryMetadataReader.cpp b/velox/exec/trace/QueryMetadataReader.cpp
new file mode 100644
index 0000000000000..99fe7cc8c4353
--- /dev/null
+++ b/velox/exec/trace/QueryMetadataReader.cpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryMetadataReader.h"
+
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryMetadataReader::QueryMetadataReader(
+    std::string traceDir,
+    memory::MemoryPool* pool)
+    : traceDir_(std::move(traceDir)),
+      fs_(filesystems::getFileSystem(traceDir_, nullptr)),
+      metaFilePath_(fmt::format(
+          "{}/{}",
+          traceDir_,
+          QueryTraceTraits::kQueryMetaFileName)),
+      pool_(pool) {
+  VELOX_CHECK_NOT_NULL(fs_);
+  VELOX_CHECK(fs_->exists(metaFilePath_));
+}
+
+void QueryMetadataReader::read(
+    std::unordered_map<std::string, std::string>& queryConfigs,
+    std::unordered_map<
+        std::string,
+        std::unordered_map<std::string, std::string>>& connectorProperties,
+    core::PlanNodePtr& queryPlan) const {
+  const auto file = fs_->openFileForRead(metaFilePath_);
+  VELOX_CHECK_NOT_NULL(file);
+  const auto metadata = file->pread(0, file->size());
+  VELOX_USER_CHECK(!metadata.empty());
+  folly::dynamic obj = folly::parseJson(metadata);
+
+  const auto& queryConfigObj = obj[QueryTraceTraits::kQueryConfigKey];
+  for (const auto& [key, value] : queryConfigObj.items()) {
+    queryConfigs[key.asString()] = value.asString();
+  }
+
+  const auto& connectorPropertiesObj =
+      obj[QueryTraceTraits::kConnectorPropertiesKey];
+  for (const auto& [connectorId, configs] : connectorPropertiesObj.items()) {
+    const auto connectorIdStr = connectorId.asString();
+    connectorProperties[connectorIdStr] = {};
+    for (const auto& [key, value] : configs.items()) {
+      connectorProperties[connectorIdStr][key.asString()] = value.asString();
+    }
+  }
+
+  queryPlan = ISerializable::deserialize<core::PlanNode>(
+      obj[QueryTraceTraits::kPlanNodeKey], pool_);
+}
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryMetadataReader.h b/velox/exec/trace/QueryMetadataReader.h
new file mode 100644
index 0000000000000..71217653d4dc3
--- /dev/null
+++ b/velox/exec/trace/QueryMetadataReader.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec::trace {
+class QueryMetadataReader {
+ public:
+  explicit QueryMetadataReader(std::string traceDir, memory::MemoryPool* pool);
+
+  void read(
+      std::unordered_map<std::string, std::string>& queryConfigs,
+      std::unordered_map<
+          std::string,
+          std::unordered_map<std::string, std::string>>& connectorProperties,
+      core::PlanNodePtr& queryPlan) const;
+
+ private:
+  const std::string traceDir_;
+  const std::shared_ptr<filesystems::FileSystem> fs_;
+  const std::string metaFilePath_;
+  memory::MemoryPool* const pool_;
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryMetadataWriter.cpp b/velox/exec/trace/QueryMetadataWriter.cpp
new file mode 100644
index 0000000000000..e14cdb197f446
--- /dev/null
+++ b/velox/exec/trace/QueryMetadataWriter.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryMetadataWriter.h"
+#include "velox/common/config/Config.h"
+#include "velox/common/file/File.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryMetadataWriter::QueryMetadataWriter(
+    std::string traceDir,
+    memory::MemoryPool* pool)
+    : traceDir_(std::move(traceDir)),
+      fs_(filesystems::getFileSystem(traceDir_, nullptr)),
+      metaFilePath_(fmt::format(
+          "{}/{}",
+          traceDir_,
+          QueryTraceTraits::kQueryMetaFileName)),
+      pool_(pool) {
+  VELOX_CHECK_NOT_NULL(fs_);
+  VELOX_CHECK(!fs_->exists(metaFilePath_));
+}
+
+void QueryMetadataWriter::write(
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    const core::PlanNodePtr& planNode) {
+  VELOX_CHECK(!finished_, "Query metadata can only be written once");
+  finished_ = true;
+  folly::dynamic queryConfigObj = folly::dynamic::object;
+  const auto configValues = queryCtx->queryConfig().rawConfigsCopy();
+  for (const auto& [key, value] : configValues) {
+    queryConfigObj[key] = value;
+  }
+
+  folly::dynamic connectorPropertiesObj = folly::dynamic::object;
+  for (const auto& [connectorId, configs] :
+       queryCtx->connectorSessionProperties()) {
+    folly::dynamic obj = folly::dynamic::object;
+    for (const auto& [key, value] : configs->rawConfigsCopy()) {
+      obj[key] = value;
+    }
+    connectorPropertiesObj[connectorId] = obj;
+  }
+
+  folly::dynamic metaObj = folly::dynamic::object;
+  metaObj[QueryTraceTraits::kQueryConfigKey] = queryConfigObj;
+  metaObj[QueryTraceTraits::kConnectorPropertiesKey] = connectorPropertiesObj;
+  metaObj[QueryTraceTraits::kPlanNodeKey] = planNode->serialize();
+
+  const auto metaStr = folly::toJson(metaObj);
+  const auto file = fs_->openFileForWrite(metaFilePath_);
+  file->append(metaStr);
+  file->close();
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryMetadataWriter.h b/velox/exec/trace/QueryMetadataWriter.h
new file mode 100644
index 0000000000000..f2cc661238514
--- /dev/null
+++ b/velox/exec/trace/QueryMetadataWriter.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec::trace {
+class QueryMetadataWriter {
+ public:
+  explicit QueryMetadataWriter(std::string traceDir, memory::MemoryPool* pool);
+
+  void write(
+      const std::shared_ptr<core::QueryCtx>& queryCtx,
+      const core::PlanNodePtr& planNode);
+
+ private:
+  const std::string traceDir_;
+  const std::shared_ptr<filesystems::FileSystem> fs_;
+  const std::string metaFilePath_;
+  memory::MemoryPool* const pool_;
+  bool finished_{false};
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceConfig.cpp b/velox/exec/trace/QueryTraceConfig.cpp
new file mode 100644
index 0000000000000..233226ebccf50
--- /dev/null
+++ b/velox/exec/trace/QueryTraceConfig.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryTraceConfig.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryTraceConfig::QueryTraceConfig(
+    std::unordered_set<std::string> _queryNodeIds,
+    std::string _queryTraceDir)
+    : queryNodes(std::move(_queryNodeIds)),
+      queryTraceDir(std::move(_queryTraceDir)) {}
+
+QueryTraceConfig::QueryTraceConfig(std::string _queryTraceDir)
+    : QueryTraceConfig(
+          std::unordered_set<std::string>{},
+          std::move(_queryTraceDir)) {}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceConfig.h b/velox/exec/trace/QueryTraceConfig.h
new file mode 100644
index 0000000000000..0e9c22818c342
--- /dev/null
+++ b/velox/exec/trace/QueryTraceConfig.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <unordered_set>
+
+namespace facebook::velox::exec::trace {
+struct QueryTraceConfig {
+  /// Target query trace nodes.
+  std::unordered_set<std::string> queryNodes;
+  /// Base dir of query trace.
+  std::string queryTraceDir;
+
+  QueryTraceConfig(
+      std::unordered_set<std::string> _queryNodeIds,
+      std::string _queryTraceDir);
+
+  QueryTraceConfig(std::string _queryTraceDir);
+
+  QueryTraceConfig() = default;
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceTraits.h b/velox/exec/trace/QueryTraceTraits.h
new file mode 100644
index 0000000000000..5e3a91f783d3e
--- /dev/null
+++ b/velox/exec/trace/QueryTraceTraits.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::exec::trace {
+/// Defines the shared constants used by query trace implementation.
+struct QueryTraceTraits {
+  static inline const std::string kPlanNodeKey = "planNode";
+  static inline const std::string kQueryConfigKey = "queryConfig";
+  static inline const std::string kDataTypeKey = "rowType";
+  static inline const std::string kConnectorPropertiesKey =
+      "connectorProperties";
+
+  static inline const std::string kQueryMetaFileName = "query_meta.json";
+  static inline const std::string kDataSummaryFileName = "data_summary.json";
+  static inline const std::string kDataFileName = "trace.data";
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceUtil.cpp b/velox/exec/trace/QueryTraceUtil.cpp
new file mode 100644
index 0000000000000..437d3eee224e5
--- /dev/null
+++ b/velox/exec/trace/QueryTraceUtil.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryTraceUtil.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/file/FileSystems.h"
+
+namespace facebook::velox::exec::trace {
+
+void createTraceDirectory(const std::string& traceDir) {
+  try {
+    const auto fs = filesystems::getFileSystem(traceDir, nullptr);
+    if (fs->exists(traceDir)) {
+      fs->rmdir(traceDir);
+    }
+    fs->mkdir(traceDir);
+  } catch (const std::exception& e) {
+    VELOX_FAIL(
+        "Failed to create trace directory '{}' with error: {}",
+        traceDir,
+        e.what());
+  }
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceUtil.h b/velox/exec/trace/QueryTraceUtil.h
new file mode 100644
index 0000000000000..826aa35283a28
--- /dev/null
+++ b/velox/exec/trace/QueryTraceUtil.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::exec::trace {
+
+/// Creates a directory to store the query trace metdata and data.
+void createTraceDirectory(const std::string& traceDir);
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/test/CMakeLists.txt b/velox/exec/trace/test/CMakeLists.txt
new file mode 100644
index 0000000000000..861b5ffb339ad
--- /dev/null
+++ b/velox/exec/trace/test/CMakeLists.txt
@@ -0,0 +1,38 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_exec_trace_test QueryTraceTest.cpp)
+
+add_test(
+  NAME velox_exec_trace_test
+  COMMAND velox_exec_trace_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+set_tests_properties(velox_exec_trace_test PROPERTIES TIMEOUT 3000)
+
+target_link_libraries(
+  velox_exec_trace_test
+  velox_exec
+  velox_exec_test_lib
+  velox_memory
+  velox_query_trace_exec
+  velox_query_trace_retrieve
+  velox_vector_fuzzer
+  GTest::gtest_main
+  GTest::gmock
+  Folly::folly
+  gflags::gflags
+  glog::glog
+  fmt::fmt
+  ${FILESYSTEM})
diff --git a/velox/exec/trace/test/QueryTraceTest.cpp b/velox/exec/trace/test/QueryTraceTest.cpp
new file mode 100644
index 0000000000000..171c7cea138a8
--- /dev/null
+++ b/velox/exec/trace/test/QueryTraceTest.cpp
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <algorithm>
+#include <memory>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/QueryDataReader.h"
+#include "velox/exec/trace/QueryDataWriter.h"
+#include "velox/exec/trace/QueryMetadataReader.h"
+#include "velox/exec/trace/QueryMetadataWriter.h"
+#include "velox/exec/trace/QueryTraceUtil.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::exec::test {
+class QueryTracerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+    HiveConnectorTestBase::SetUpTestCase();
+    filesystems::registerLocalFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveTableHandle::registerSerDe();
+    connector::hive::LocationHandle::registerSerDe();
+    connector::hive::HiveColumnHandle::registerSerDe();
+    connector::hive::HiveInsertTableHandle::registerSerDe();
+    core::PlanNode::registerSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  static VectorFuzzer::Options getFuzzerOptions() {
+    return VectorFuzzer::Options{
+        .vectorSize = 16,
+        .nullRatio = 0.2,
+        .stringLength = 1024,
+        .stringVariableLength = false,
+        .allowLazyVector = false,
+    };
+  }
+
+  QueryTracerTest() : vectorFuzzer_{getFuzzerOptions(), pool_.get()} {
+    filesystems::registerLocalFileSystem();
+  }
+
+  RowTypePtr generateTypes(size_t numColumns) {
+    std::vector<std::string> names;
+    names.reserve(numColumns);
+    std::vector<TypePtr> types;
+    types.reserve(numColumns);
+    for (auto i = 0; i < numColumns; ++i) {
+      names.push_back(fmt::format("c{}", i));
+      types.push_back(vectorFuzzer_.randType((2)));
+    }
+    return ROW(std::move(names), std::move(types));
+    ;
+  }
+
+  bool isSamePlan(
+      const core::PlanNodePtr& left,
+      const core::PlanNodePtr& right) {
+    if (left->id() != right->id() || left->name() != right->name()) {
+      return false;
+    }
+
+    if (left->sources().size() != right->sources().size()) {
+      return false;
+    }
+
+    for (auto i = 0; i < left->sources().size(); ++i) {
+      isSamePlan(left->sources().at(i), right->sources().at(i));
+    }
+    return true;
+  }
+
+  VectorFuzzer vectorFuzzer_;
+};
+
+TEST_F(QueryTracerTest, traceData) {
+  const auto rowType = generateTypes(5);
+  std::vector<RowVectorPtr> inputVectors;
+  constexpr auto numBatch = 3;
+  inputVectors.reserve(numBatch);
+  for (auto i = 0; i < numBatch; ++i) {
+    inputVectors.push_back(vectorFuzzer_.fuzzInputRow(rowType));
+  }
+
+  const auto outputDir = TempDirectoryPath::create();
+  auto writer = trace::QueryDataWriter(outputDir->getPath(), pool());
+  for (auto i = 0; i < numBatch; ++i) {
+    writer.write(inputVectors[i]);
+  }
+  writer.finish();
+
+  const auto reader = trace::QueryDataReader(outputDir->getPath(), pool());
+  RowVectorPtr actual;
+  size_t numOutputVectors{0};
+  while (reader.read(actual)) {
+    const auto expected = inputVectors[numOutputVectors];
+    const auto size = actual->size();
+    ASSERT_EQ(size, expected->size());
+    for (auto i = 0; i < size; ++i) {
+      actual->compare(expected.get(), i, i, {.nullsFirst = true});
+    }
+    ++numOutputVectors;
+  }
+  ASSERT_EQ(numOutputVectors, inputVectors.size());
+}
+
+TEST_F(QueryTracerTest, traceMetadata) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+          {BIGINT(), SMALLINT(), TINYINT(), VARCHAR(), VARCHAR(), VARCHAR()});
+  std::vector<RowVectorPtr> rows;
+  constexpr auto numBatch = 1;
+  rows.reserve(numBatch);
+  for (auto i = 0; i < numBatch; ++i) {
+    rows.push_back(vectorFuzzer_.fuzzRow(rowType, 2));
+  }
+
+  const auto outputDir = TempDirectoryPath::create();
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values(rows, false)
+          .project({"c0", "c1", "c2"})
+          .hashJoin(
+              {"c0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator)
+                  .values(rows, true)
+                  .singleAggregation({"c0", "c1"}, {"min(c2)"})
+                  .project({"c0 AS u0", "c1 AS u1", "a0 AS u2"})
+                  .planNode(),
+              "c0 < 135",
+              {"c0", "c1", "c2"},
+              core::JoinType::kInner)
+          .planNode();
+  const auto expectedQueryConfigs =
+      std::unordered_map<std::string, std::string>{
+          {core::QueryConfig::kSpillEnabled, "true"},
+          {core::QueryConfig::kSpillNumPartitionBits, "17"},
+          {"key1", "value1"},
+      };
+  const auto expectedConnectorProperties =
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{
+          {"test_trace",
+           std::make_shared<config::ConfigBase>(
+               std::unordered_map<std::string, std::string>{
+                   {"cKey1", "cVal1"}})}};
+  const auto queryCtx = core::QueryCtx::create(
+      executor_.get(),
+      core::QueryConfig(expectedQueryConfigs),
+      expectedConnectorProperties);
+  auto writer = trace::QueryMetadataWriter(outputDir->getPath(), pool());
+  writer.write(queryCtx, planNode);
+
+  std::unordered_map<std::string, std::string> acutalQueryConfigs;
+  std::unordered_map<std::string, std::unordered_map<std::string, std::string>>
+      actualConnectorProperties;
+  core::PlanNodePtr actualQueryPlan;
+  auto reader = trace::QueryMetadataReader(outputDir->getPath(), pool());
+  reader.read(acutalQueryConfigs, actualConnectorProperties, actualQueryPlan);
+
+  ASSERT_TRUE(isSamePlan(actualQueryPlan, planNode));
+  ASSERT_EQ(acutalQueryConfigs.size(), expectedQueryConfigs.size());
+  for (const auto& [key, value] : acutalQueryConfigs) {
+    ASSERT_EQ(acutalQueryConfigs.at(key), expectedQueryConfigs.at(key));
+  }
+
+  ASSERT_EQ(
+      actualConnectorProperties.size(), expectedConnectorProperties.size());
+  ASSERT_EQ(actualConnectorProperties.count("test_trace"), 1);
+  const auto expectedConnectorConfigs =
+      expectedConnectorProperties.at("test_trace")->rawConfigsCopy();
+  const auto actualConnectorConfigs =
+      actualConnectorProperties.at("test_trace");
+  for (const auto& [key, value] : actualConnectorConfigs) {
+    ASSERT_EQ(actualConnectorConfigs.at(key), expectedConnectorConfigs.at(key));
+  }
+}
+
+TEST_F(QueryTracerTest, task) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+          {BIGINT(), SMALLINT(), TINYINT(), VARCHAR(), VARCHAR(), VARCHAR()});
+  std::vector<RowVectorPtr> rows;
+  constexpr auto numBatch = 1;
+  rows.reserve(numBatch);
+  for (auto i = 0; i < numBatch; ++i) {
+    rows.push_back(vectorFuzzer_.fuzzRow(rowType, 2));
+  }
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values(rows, false)
+          .project({"c0", "c1", "c2"})
+          .hashJoin(
+              {"c0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator)
+                  .values(rows, true)
+                  .singleAggregation({"c0", "c1"}, {"min(c2)"})
+                  .project({"c0 AS u0", "c1 AS u1", "a0 AS u2"})
+                  .planNode(),
+              "c0 < 135",
+              {"c0", "c1", "c2"},
+              core::JoinType::kInner)
+          .planNode();
+  const auto expectedResult =
+      AssertQueryBuilder(planNode).maxDrivers(1).copyResults(pool());
+
+  for (const auto& queryTraceNodeIds : {"1,2", ""}) {
+    const auto outputDir = TempDirectoryPath::create();
+    const auto expectedQueryConfigs =
+        std::unordered_map<std::string, std::string>{
+            {core::QueryConfig::kSpillEnabled, "true"},
+            {core::QueryConfig::kSpillNumPartitionBits, "17"},
+            {core::QueryConfig::kQueryTraceEnabled, "true"},
+            {core::QueryConfig::kQueryTraceDir, outputDir->getPath()},
+            {core::QueryConfig::kQueryTraceEnabled, queryTraceNodeIds},
+            {"key1", "value1"},
+        };
+    const auto expectedConnectorProperties =
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{
+            {"test_trace",
+             std::make_shared<config::ConfigBase>(
+                 std::unordered_map<std::string, std::string>{
+                     {"cKey1", "cVal1"}})}};
+    const auto queryCtx = core::QueryCtx::create(
+        executor_.get(),
+        core::QueryConfig(expectedQueryConfigs),
+        expectedConnectorProperties);
+
+    std::shared_ptr<Task> task;
+    const auto result = AssertQueryBuilder(planNode)
+                            .queryCtx(queryCtx)
+                            .maxDrivers(1)
+                            .copyResults(pool(), task);
+    assertEqualResults({result}, {expectedResult});
+
+    const auto expectedDir =
+        fmt::format("{}/{}", outputDir->getPath(), task->taskId());
+    const auto fs = filesystems::getFileSystem(expectedDir, nullptr);
+    const auto actaulDirs = fs->list(outputDir->getPath());
+    ASSERT_EQ(actaulDirs.size(), 1);
+    ASSERT_EQ(actaulDirs.at(0), expectedDir);
+
+    std::unordered_map<std::string, std::string> acutalQueryConfigs;
+    std::
+        unordered_map<std::string, std::unordered_map<std::string, std::string>>
+            actualConnectorProperties;
+    core::PlanNodePtr actualQueryPlan;
+    auto reader = trace::QueryMetadataReader(expectedDir, pool());
+    reader.read(acutalQueryConfigs, actualConnectorProperties, actualQueryPlan);
+
+    ASSERT_TRUE(isSamePlan(actualQueryPlan, planNode));
+    ASSERT_EQ(acutalQueryConfigs.size(), expectedQueryConfigs.size());
+    for (const auto& [key, value] : acutalQueryConfigs) {
+      ASSERT_EQ(acutalQueryConfigs.at(key), expectedQueryConfigs.at(key));
+    }
+
+    ASSERT_EQ(
+        actualConnectorProperties.size(), expectedConnectorProperties.size());
+    ASSERT_EQ(actualConnectorProperties.count("test_trace"), 1);
+    const auto expectedConnectorConfigs =
+        expectedConnectorProperties.at("test_trace")->rawConfigsCopy();
+    const auto actualConnectorConfigs =
+        actualConnectorProperties.at("test_trace");
+    for (const auto& [key, value] : actualConnectorConfigs) {
+      ASSERT_EQ(
+          actualConnectorConfigs.at(key), expectedConnectorConfigs.at(key));
+    }
+  }
+}
+
+TEST_F(QueryTracerTest, error) {
+  const auto planNode = PlanBuilder().values({}).planNode();
+  const auto expectedQueryConfigs =
+      std::unordered_map<std::string, std::string>{
+          {core::QueryConfig::kSpillEnabled, "true"},
+          {core::QueryConfig::kSpillNumPartitionBits, "17"},
+          {core::QueryConfig::kQueryTraceEnabled, "true"},
+      };
+  const auto queryCtx = core::QueryCtx::create(
+      executor_.get(), core::QueryConfig(expectedQueryConfigs));
+  VELOX_ASSERT_USER_THROW(
+      AssertQueryBuilder(planNode).queryCtx(queryCtx).maxDrivers(1).copyResults(
+          pool()),
+      "Query trace enabled but the trace dir is not set");
+}
+
+TEST_F(QueryTracerTest, traceDir) {
+  const auto outputDir = TempDirectoryPath::create();
+  const auto rootDir = outputDir->getPath();
+  const auto fs = filesystems::getFileSystem(rootDir, nullptr);
+  auto dir1 = fmt::format("{}/{}", outputDir->getPath(), "t1");
+  trace::createTraceDirectory(dir1);
+  ASSERT_TRUE(fs->exists(dir1));
+
+  auto dir2 = fmt::format("{}/{}", dir1, "t1_1");
+  trace::createTraceDirectory(dir2);
+  ASSERT_TRUE(fs->exists(dir2));
+
+  // It will remove the old dir1 along with its subdir when created the dir1
+  // again.
+  trace::createTraceDirectory(dir1);
+  ASSERT_TRUE(fs->exists(dir1));
+  ASSERT_FALSE(fs->exists(dir2));
+
+  const auto parentDir = fmt::format("{}/{}", outputDir->getPath(), "p");
+  fs->mkdir(parentDir);
+
+  constexpr auto numThreads = 5;
+  std::vector<std::thread> traceThreads;
+  traceThreads.reserve(numThreads);
+  std::mutex mutex;
+  std::set<std::string> expectedDirs;
+  for (int i = 0; i < numThreads; ++i) {
+    traceThreads.emplace_back([&, i]() {
+      const auto dir = fmt::format("{}/s{}", parentDir, i);
+      trace::createTraceDirectory(dir);
+      std::lock_guard<std::mutex> l(mutex);
+      expectedDirs.insert(dir);
+    });
+  }
+
+  for (auto& traceThread : traceThreads) {
+    traceThread.join();
+  }
+
+  const auto actualDirs = fs->list(parentDir);
+  ASSERT_EQ(actualDirs.size(), numThreads);
+  ASSERT_EQ(actualDirs.size(), expectedDirs.size());
+  for (const auto& dir : actualDirs) {
+    ASSERT_EQ(expectedDirs.count(dir), 1);
+  }
+}
+} // namespace facebook::velox::exec::test
+
+// This main is needed for some tests on linux.
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  // Signal handler required for ThreadDebugInfoTest
+  facebook::velox::process::addDefaultFatalSignalHandler();
+  folly::Init init(&argc, &argv, false);
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/experimental/codegen/CMakeLists.txt b/velox/experimental/codegen/CMakeLists.txt
deleted file mode 100644
index ad94acbce2333..0000000000000
--- a/velox/experimental/codegen/CMakeLists.txt
+++ /dev/null
@@ -1,55 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-execute_process(
-  COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR}/proto
-  COMMAND
-    ${PROTOBUF_PROTOC_EXECUTABLE}
-    --proto_path=${CMAKE_CURRENT_SOURCE_DIR}/proto/ codegen_proto.proto
-    --cpp_out=${CMAKE_CURRENT_SOURCE_DIR}/proto)
-
-add_subdirectory(proto)
-add_subdirectory(compiler_utils)
-add_subdirectory(library_loader)
-add_subdirectory(transform)
-add_subdirectory(external_process)
-add_subdirectory(code_generator)
-add_subdirectory(ast)
-add_subdirectory(udf_manager)
-add_subdirectory(utils)
-add_subdirectory(functions)
-add_subdirectory(vector_function)
-
-add_library(velox_experimental_codegen Codegen.cpp CodegenStubs.cpp
-                                       CodegenLogger.cpp)
-target_link_libraries(
-  velox_experimental_codegen
-  velox_codegen_transform
-  velox_codegen_compiler_utils
-  velox_codegen_proto
-  velox_codegen_library_loader
-  velox_codegen_code_generator
-  velox_codegen_ast
-  velox_codegen_udf_manager
-  velox_codegen_external_process
-  velox_core
-  velox_exec
-  velox_expression)
-
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
-if(${VELOX_ENABLE_BENCHMARKS})
-  add_subdirectory(benchmark)
-endif()
diff --git a/velox/experimental/codegen/Codegen.cpp b/velox/experimental/codegen/Codegen.cpp
deleted file mode 100644
index 549a2c7c9ca00..0000000000000
--- a/velox/experimental/codegen/Codegen.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/Codegen.h"
-#include <glog/logging.h>
-#include <memory>
-#include "velox/core/PlanNode.h"
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/CodegenExceptions.h"
-#include "velox/experimental/codegen/external_process/Command.h"
-#include "velox/experimental/codegen/external_process/subprocess.h"
-#include "velox/experimental/codegen/proto/ProtoUtils.h"
-#include "velox/experimental/codegen/udf_manager/UDFManager.h"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-bool Codegen::initialize(
-    const std::string_view& codegenOptionsJson,
-    bool lazyLoading) {
-  try {
-    codegenLogger_->onInitialize(lazyLoading);
-    auto codegenOptionsProto = proto::proto_utils::ProtoUtils<
-        proto::CodegenOptionsProto>::loadProtoFromJson(codegenOptionsJson);
-
-    useSymbolsForArithmetic_ = codegenOptionsProto.usesymbolsforarithmetic();
-    initializeCodeManager(codegenOptionsProto.compileroptions());
-    initializeUDFManager();
-    initializeTransform();
-
-    if (!lazyLoading) {
-      runInitializationTests();
-    }
-  } catch (std::exception& e) {
-    throw CodegenInitializationException(e.what());
-  }
-
-  return true;
-}
-
-bool Codegen::initializeFromFile(
-    const std::filesystem::path& codegenOptionsJsonFile,
-    bool lazyLoading) {
-  codegenLogger_->onInitializeFromFile(codegenOptionsJsonFile, lazyLoading);
-  return initialize(
-      proto::proto_utils::readFromFile(codegenOptionsJsonFile).str(),
-      lazyLoading);
-}
-
-std::shared_ptr<const core::PlanNode> Codegen::compile(
-    const core::PlanNode& planNode) {
-  codegenLogger_->onCompileStart(planNode);
-  auto transformedPlanNode = transform_->transform(planNode);
-  codegenLogger_->onCompileEnd(
-      *std::static_pointer_cast<DefaultScopedTimer::EventSequence>(
-          eventSequence_),
-      planNode);
-  return transformedPlanNode;
-}
-
-bool Codegen::initializeCodeManager(
-    const proto::CompilerOptionsProto& compilerOptionsProto) {
-  LOG(INFO) << "Codegen: initializing CodeManager";
-  eventSequence_ = std::make_shared<DefaultScopedTimer::EventSequence>();
-  codeManager_ = std::make_shared<CodeManager>(
-      CompilerOptions::fromProto(compilerOptionsProto),
-      *std::static_pointer_cast<DefaultEventSequence>(eventSequence_));
-
-  return true;
-}
-
-bool Codegen::initializeUDFManager() {
-  LOG(INFO) << "Codegen: initializing UDFManager";
-  // TODO: we want to register UDFs via config files rather than in code
-  udfManager_ = std::make_shared<UDFManager>();
-  registerVeloxArithmeticUDFs(*udfManager_);
-  return true;
-}
-
-bool Codegen::initializeTransform() {
-  LOG(INFO) << "Codegen: initializing Transform";
-  transform_ = std::make_shared<CodegenCompiledExpressionTransform>(
-      CodegenCompiledExpressionTransform(
-          codeManager_->compiler().compilerOptions(),
-          *udfManager_,
-          useSymbolsForArithmetic_,
-          *std::static_pointer_cast<DefaultEventSequence>(eventSequence_)));
-  return true;
-}
-
-bool Codegen::runInitializationTests() {
-  LOG(INFO) << "Codegen: running initialization tests";
-
-  auto sourceCode1 = R"a(
-  extern "C" {
-  int f() {
-    return 24;
-  };
-  }
-  )a";
-
-  auto sourceCode2 = R"a(
-  extern "C" {
-  int g() {
-    return 32;
-  };
-  }
-  )a";
-
-  Compiler compiler = codeManager_->compiler();
-
-  LOG(INFO) << "Codegen: attempting to compile test binary1";
-
-  auto binary = compiler.compileString({}, sourceCode1);
-  VELOX_CHECK(std::filesystem::exists(binary));
-  VELOX_CHECK_GT(std::filesystem::file_size(binary), 0);
-
-  LOG(INFO) << "Codegen: attempting to compile test binary2";
-
-  auto binary2 = compiler.compileString({}, sourceCode2);
-  VELOX_CHECK(std::filesystem::exists(binary2));
-  VELOX_CHECK_GT(std::filesystem::file_size(binary2), 0);
-
-  LOG(INFO) << "Codegen: attempting to link test sharedObject";
-
-  auto sharedObject = compiler.link({}, {binary, binary2});
-  VELOX_CHECK(std::filesystem::exists(sharedObject));
-  VELOX_CHECK_GT(std::filesystem::file_size(sharedObject), 0);
-
-  // From dlopen man page, one of RTLD_NOW or RTLD_LAZY must be set
-  // in linux machines. Note that mac has no such requirements.
-  // https://man7.org/linux/man-pages/man3/dlopen.3.html
-  auto libraryPtr =
-      dlopen(sharedObject.string().c_str(), RTLD_LOCAL | RTLD_LAZY);
-  VELOX_CHECK_EQ(dlerror(), nullptr);
-
-  auto sym_g = (int (*)())dlsym(libraryPtr, "g");
-  VELOX_CHECK_EQ(dlerror(), nullptr);
-  VELOX_CHECK_EQ(sym_g(), 32);
-
-  auto sym_f = (int (*)())dlsym(libraryPtr, "f");
-  VELOX_CHECK_EQ(dlerror(), nullptr);
-  VELOX_CHECK_EQ(sym_f(), 24);
-
-  LOG(INFO) << "Codegen: initialization tests done";
-  return true;
-}
-
-} // namespace codegen
-} // namespace velox
-}; // namespace facebook
diff --git a/velox/experimental/codegen/Codegen.h b/velox/experimental/codegen/Codegen.h
deleted file mode 100644
index b2dc719ed174d..0000000000000
--- a/velox/experimental/codegen/Codegen.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <filesystem>
-#include <string>
-#include "velox/core/PlanNode.h"
-#include "velox/experimental/codegen/CodegenLogger.h"
-#include "velox/experimental/codegen/proto/codegen_proto.pb.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-class CodeManager;
-class UDFManager;
-class CodegenCompiledExpressionTransform;
-class ICodegenLogger;
-
-/// Main interface/entry point with the  code generation system.
-/// The init method has to be called before any other method on this object.
-class Codegen {
- public:
-  explicit Codegen(std::shared_ptr<ICodegenLogger> codegenLogger)
-      : codegenLogger_(codegenLogger) {}
-
-  bool initialize(
-      const std::string_view& codegenOptionsJson,
-      bool lazyLoading = true);
-
-  bool initializeFromFile(
-      const std::filesystem::path& codegenOptionsJsonFile,
-      bool lazyLoading = true);
-
-  std::shared_ptr<const core::PlanNode> compile(const core::PlanNode& planNode);
-
- private:
-  std::shared_ptr<ICodegenLogger> codegenLogger_;
-
-  std::shared_ptr<CodeManager> codeManager_;
-  std::shared_ptr<UDFManager> udfManager_;
-  std::shared_ptr<CodegenCompiledExpressionTransform> transform_;
-
-  // We need to type erase DefaultEventSequence here to break the dep. with
-  // NestedScopedTimer.h
-  std::shared_ptr<void /*DefaultEventSequence*/> eventSequence_;
-
-  // Follows Velox, defaults to false
-  bool useSymbolsForArithmetic_ = false;
-
-  bool initializeCodeManager(
-      const proto::CompilerOptionsProto& compilerOptionsProto);
-
-  bool initializeUDFManager();
-
-  bool initializeTransform();
-
-  bool runInitializationTests();
-};
-
-} // namespace codegen
-} // namespace velox
-}; // namespace facebook
diff --git a/velox/experimental/codegen/CodegenASTAnalysis.h b/velox/experimental/codegen/CodegenASTAnalysis.h
deleted file mode 100644
index c1df7eb8b3df9..0000000000000
--- a/velox/experimental/codegen/CodegenASTAnalysis.h
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/core/PlanNode.h"
-#include "velox/experimental/codegen/code_generator/ExprCodeGenerator.h"
-#include "velox/experimental/codegen/library_loader/NativeLibraryLoader.h"
-#include "velox/experimental/codegen/transform/PlanNodeTransform.h"
-#include "velox/experimental/codegen/transform/utils/adapters.h"
-#include "velox/experimental/codegen/transform/utils/utils.h"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-
-namespace facebook::velox::codegen {
-
-using velox::codegen::ExprCodeGenerator;
-using velox::core::ITypedExpr;
-using velox::transform::PlanNodeAnalysis;
-using velox::transform::utils::dfsApply;
-
-namespace {
-class generateAstVisitor {
- public:
-  generateAstVisitor(
-      std::map<std::shared_ptr<const ITypedExpr>, CodegenASTNode>& astNodes_,
-      const UDFManager& udfManager,
-      bool useSymbolsForArithmetic,
-      DefaultScopedTimer::EventSequence& eventSequence)
-      : astNodes_(astNodes_),
-        generator_(udfManager, useSymbolsForArithmetic, false),
-        eventSequence_(eventSequence) {}
-
-  void visit(const core::PlanNode& planNode) {
-    if (auto projectNode = dynamic_cast<const core::ProjectNode*>(&planNode)) {
-      visitProjection(*projectNode);
-    } else if (
-        auto filterNode = dynamic_cast<const core::FilterNode*>(&planNode)) {
-      visitFilter(*filterNode);
-    } else if (
-        auto valueNode = dynamic_cast<const core::ValuesNode*>(&planNode)) {
-    } else if (
-        dynamic_cast<const core::TableWriteNode*>(&planNode) ||
-        dynamic_cast<const core::TableScanNode*>(&planNode)) {
-      // Those plan nodes do not have expressions to transform
-    } else {
-      throw std::logic_error("Unknown node type:\n" + planNode.toString());
-    }
-  }
-
- private:
-  std::optional<CodegenASTNode> generateAst(
-      const std::shared_ptr<const core::ITypedExpr>& expr,
-      const RowType& inputType) {
-    auto outputType =
-        std::dynamic_pointer_cast<const velox::RowType>(expr->type());
-
-    try {
-      // convert velox expression tree to codegen AST
-      auto codegenExprTree =
-          generator_.convertVeloxExpressionToCodegenAST(expr, inputType);
-
-      // validate the generated tree
-      codegenExprTree->validate();
-
-      return codegenExprTree;
-
-    } catch (const std::runtime_error& error) {
-      LOG(INFO) << fmt::format("Expression failed {}", error.what());
-      return {};
-    };
-  }
-
-  void visitProjection(const core::ProjectNode& projection) {
-    const auto& inputType = *projection.sources()[0]->outputType().get();
-    for (const auto& expr : projection.projections()) {
-      auto ast = generateAst(expr, inputType);
-      if (ast.has_value()) {
-        astNodes_[expr] = ast.value();
-      }
-    }
-  }
-
-  void visitFilter(const core::FilterNode& filterNode) {
-    const auto& inputType = *filterNode.sources()[0]->outputType().get();
-    auto ast = generateAst(filterNode.filter(), inputType);
-    if (ast.has_value()) {
-      astNodes_[filterNode.filter()] = ast.value();
-    }
-  }
-
-  std::map<std::shared_ptr<const ITypedExpr>, CodegenASTNode>& astNodes_;
-  ExprCodeGenerator generator_;
-  [[maybe_unused]] DefaultScopedTimer::EventSequence& eventSequence_;
-};
-
-} // namespace
-
-/// AST generation Analysis
-/// Scan a given plan node and generate a map ITypedExpr -> CodegenASTNode
-// for every encountered expression
-class CodegenASTAnalysis : PlanNodeAnalysis {
- public:
-  CodegenASTAnalysis(
-      const UDFManager& udfManager,
-      bool useSymbolsForArithmetic,
-      DefaultScopedTimer::EventSequence& eventSequence)
-      : astNodes_(),
-        visitor_(astNodes_, udfManager, useSymbolsForArithmetic, eventSequence),
-        eventSequence_(eventSequence) {}
-
-  ~CodegenASTAnalysis() override {}
-
-  void run(const core::PlanNode& rootNode) override {
-    DefaultScopedTimer timer("CodegenASTAnalysis", eventSequence_);
-    dfsApply(rootNode, [this](const auto& planNode) {
-      this->visitor_.visit(planNode);
-    });
-  }
-  const std::map<std::shared_ptr<const ITypedExpr>, CodegenASTNode>& nodes()
-      const {
-    return astNodes_;
-  }
-
- private:
-  std::map<std::shared_ptr<const ITypedExpr>, CodegenASTNode> astNodes_;
-  generateAstVisitor visitor_;
-  [[maybe_unused]] DefaultScopedTimer::EventSequence& eventSequence_;
-};
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/CodegenCompiledExpressionTransform.h b/velox/experimental/codegen/CodegenCompiledExpressionTransform.h
deleted file mode 100644
index fb1a6a418bac5..0000000000000
--- a/velox/experimental/codegen/CodegenCompiledExpressionTransform.h
+++ /dev/null
@@ -1,717 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-// This file defines the tranasformation that replaces velox expressions with
-// codegen compiled expressions
-
-#include <functional>
-#include <optional>
-#include "velox/core/PlanNode.h"
-#include "velox/experimental/codegen/CompiledExpressionAnalysis.h"
-#include "velox/experimental/codegen/code_generator/ExprCodeGenerator.h"
-#include "velox/experimental/codegen/compiler_utils/CodeManager.h"
-#include "velox/experimental/codegen/compiler_utils/ICompiledCall.h"
-#include "velox/experimental/codegen/transform/PlanNodeTransform.h"
-#include "velox/experimental/codegen/transform/utils/ranges_utils.h"
-#include "velox/experimental/codegen/transform/utils/utils.h"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-#include "velox/parse/Expressions.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-using namespace transform;
-
-/// Code generator visitor
-class CompiledExpressionTransformVisitor {
- public:
-  CompiledExpressionTransformVisitor(
-      const CompiledExpressionAnalysisResult& compiledExprAnalysisResult,
-      const CompilerOptions& options,
-      DefaultScopedTimer::EventSequence& eventSequence,
-      bool compileFilter = true,
-      bool mergeFilter = true)
-      : codeManager_(options, eventSequence),
-        compiledExprAnalysisResult_(compiledExprAnalysisResult),
-        compileFilter_(compileFilter),
-        mergeFilter_(mergeFilter) {}
-
-  template <typename Children>
-  std::shared_ptr<core::PlanNode> visit(
-      const core::PlanNode& planNode,
-      const Children& transformedChildren) {
-    if (auto projectNode = dynamic_cast<const core::ProjectNode*>(&planNode)) {
-      return visitProjection(*projectNode, transformedChildren);
-    };
-
-    if (auto filterNode = dynamic_cast<const core::FilterNode*>(&planNode)) {
-      if (!compileFilter_ || mergeFilter_) {
-        return utils::adapter::FilterCopy::copyWith(
-            *filterNode,
-            std::placeholders::_1,
-            std::placeholders::_1,
-            *ranges::begin(transformedChildren));
-      }
-      return visitFilter(*filterNode, transformedChildren);
-    };
-
-    if (auto valueNode = dynamic_cast<const core::ValuesNode*>(&planNode)) {
-      return std::make_shared<core::ValuesNode>(
-          valueNode->id(), valueNode->values());
-    }
-
-    if (auto tableWriteNode =
-            dynamic_cast<const core::TableWriteNode*>(&planNode)) {
-      // Return the same node with new children.
-      return utils::adapter::TableWriteNodeCopy::copyWith(
-          *tableWriteNode,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          *ranges::begin(transformedChildren));
-    };
-
-    if (auto tableScanNode =
-            dynamic_cast<const core::TableScanNode*>(&planNode)) {
-      // Return a copy.
-      return utils::adapter::TableScanNodeCopy::copyWith(
-          *tableScanNode,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1);
-    };
-
-    throw std::logic_error("Unknown node type");
-  }
-
- private:
-  CodeManager codeManager_;
-
-  const CompiledExpressionAnalysisResult& compiledExprAnalysisResult_;
-
-  bool compileFilter_;
-  bool mergeFilter_;
-
-  std::optional<std::reference_wrapper<const GeneratedExpressionStruct>>
-  getGeneratedCode(const std::shared_ptr<const ITypedExpr>& expression) {
-    auto it = compiledExprAnalysisResult_.generatedCode_.find(expression);
-    if (it == compiledExprAnalysisResult_.generatedCode_.end()) {
-      return std::nullopt;
-    }
-    return it->second;
-  }
-
-  bool isDefaultNull(const core::PlanNodeId& planId) {
-    auto it = compiledExprAnalysisResult_.isDefaultNull_.find(planId);
-    if (it == compiledExprAnalysisResult_.isDefaultNull_.end()) {
-      return false;
-    }
-    return it->second;
-  }
-
-  bool isDefaultNullStrict(const core::PlanNodeId& planId) {
-    auto it = compiledExprAnalysisResult_.isDefaultNullStrict_.find(planId);
-    if (it == compiledExprAnalysisResult_.isDefaultNullStrict_.end()) {
-      return false;
-    }
-    return it->second;
-  }
-
-  const std::string& fileFormat() {
-    // TODO: Move this into a file
-    static const std::string fileFormat_ = R"(
-    #include "velox/experimental/codegen/vector_function/VectorFunctionLoadUtils.h" // @manual
-    {includes}
-
-    using namespace facebook;
-    using namespace facebook::velox;
-    using namespace facebook::velox::codegen;
-
-    {GeneratedCode}
-
-    struct GeneratedVectorFunctionConfig {{
-      using GeneratedCodeClass =  {GeneratedCodeClass};
-      static constexpr bool isDefaultNull = {isDefaultNull};
-      static constexpr bool isDefaultNullStrict = {isDefaultNullStrict};
-
-    }};
-
-    std::shared_ptr<FunctionTable> functionTable;
-
-    std::unique_ptr<GeneratedVectorFunctionBase> newInstance() {{
-          return std::make_unique<GeneratedVectorFunction<GeneratedVectorFunctionConfig>>();
-    }};
-
-    extern "C" {{
-        bool init(void *) {{
-          functionTable = std::make_shared<FunctionTable>();
-          registerFunction("newInstance",&newInstance,*functionTable);
-          return true;
-        }}
-        void release(void  * ) {{ }};
-        std::shared_ptr<FunctionTable> getFunctionTable() {{return functionTable; }};
-    }};
-)";
-    return fileFormat_;
-  }
-
-  /// Compute the union of a given set of RowTypes.
-  /// eg ROW({'a','b,'c'}, {DOUBLETYPE,DOUBLETYPE,DOUBLETTYPE}) +
-  ///  ROW({'a','d,}, {DOUBLETYPE,DOUBLETYPE})
-  /// -> ROW({'a','b,'c','d'}, {DOUBLETYPE,DOUBLETYPE,DOUBLETYPE,DOUBLETTYPE})
-  /// Throws when the union of type is inconsistent  (eg the same column exists
-  /// with different types).
-  /// TODO: use a range_view instead of a containers as arg
-  /// \param types
-  /// \return union type
-  std::shared_ptr<RowType> computeUnionType(
-      const std::vector<std::reference_wrapper<const RowType>>& rowTypes) {
-    std::map<std::string, TypePtr> columnsTypes;
-
-    for (auto& rowType_ : rowTypes) {
-      auto& rowType = rowType_.get();
-      for (size_t childId = 0; childId < rowType.size(); ++childId) {
-        auto columnName = rowType.nameOf(childId);
-        if (auto nameIterator = columnsTypes.find(columnName);
-            nameIterator == columnsTypes.end()) {
-          columnsTypes[columnName] = rowType.childAt(childId);
-        } else {
-          // If the column name has already been encountered, we check if the
-          // type is the same we saw last time
-          VELOX_CHECK_EQ(rowType.childAt(childId), (*nameIterator).second);
-        }
-      };
-    }
-
-    std::vector<std::string> names;
-    std::vector<TypePtr> types;
-
-    // TODO: We probably need here to have a better ordering of the columns
-    for (auto& [name, type] : columnsTypes) {
-      names.push_back(name);
-      types.push_back(type);
-    }
-    return std::make_shared<RowType>(std::move(names), std::move(types));
-  }
-
-  /// Computes the input map of a given column give it's Rowtype
-  /// eg if columnType = [ {"c",DOUBLE()}, {"a",DOUBLE()} ]
-  /// and @concatanatedColumnType = [ {"a",DOUBLE()},
-  /// {"b",DOUBLE()},{"c",DOUBLE()} ] return is "std::index_sequence<2,0>"
-  std::string computeInputMap(
-      const RowType& columnType,
-      const RowType& concatanatedColumnType) {
-    if (columnType.size() == 0) {
-      return "std::index_sequence<>";
-    }
-
-    std::stringstream sstring;
-    sstring << "std::index_sequence<"
-            << concatanatedColumnType.getChildIdx(columnType.nameOf(0));
-
-    for (size_t index = 1; index < columnType.size(); ++index) {
-      sstring << ", "
-              << concatanatedColumnType.getChildIdx(columnType.nameOf(index));
-    };
-    sstring << ">";
-    return sstring.str();
-  }
-
-  /// Generate the cpp code for a given column.
-  /// \param generatedCode
-  /// \param unionType
-  /// \param columnName
-  /// \param outputIndex
-  /// \param out
-  /// \return the name of the final class
-  std::string generateColumnCode(
-      const GeneratedExpressionStruct& generatedCode,
-      const RowType& unionType,
-      const std::string& columnName,
-      const size_t outputIndex,
-      std::stringstream& out) {
-    constexpr auto formatString = R"(
-        {generatedStructCode}
-        using {usingDeclName} = std::tuple<{className},{inputMap},
-                  std::index_sequence<{outputIndex}>>;
-    )";
-
-    const std::string className = fmt::format("col_{}", columnName);
-    const std::string usingDeclName = fmt::format("typeCol{}", columnName);
-
-    const std::string inputMap =
-        computeInputMap(generatedCode.inputRowType(), unionType);
-
-    out << fmt::format(
-               formatString,
-               fmt::arg("className", className),
-               fmt::arg("usingDeclName", usingDeclName),
-               fmt::arg("inputMap", inputMap),
-               fmt::arg(
-                   "generatedStructCode", generatedCode.toStruct(className)),
-               fmt::arg("outputIndex", outputIndex))
-        << std::endl;
-
-    return usingDeclName;
-  }
-
-  std::string generateConcatCode(
-      const RowType& inputType,
-      const RowType& outputType,
-      const std::vector<std::string>& classNames,
-      const std::string& mainClassName,
-      const bool hasFilter) {
-    const std::string inImplTypes =
-        codegenUtils::codegenImplTypeName(inputType);
-    const std::string outImplTypes =
-        codegenUtils::codegenImplTypeName(outputType);
-
-    std::stringstream decls;
-    decls << classNames[0];
-
-    for (size_t index = 1; index < classNames.size(); ++index) {
-      decls << ", " << classNames[index];
-    }
-
-    return fmt::format(
-        "using {} = facebook::velox::codegen::ConcatExpression<{},{},{},{}>;",
-        mainClassName,
-        hasFilter,
-        inImplTypes,
-        outImplTypes,
-        decls.str());
-  }
-
-  /// Generate a templated instance of Concat Expression
-  /// \param mainClassName
-  /// \param outputType
-  /// \param generatedColumns = [columnIndex,generatedCode] pairs
-  /// \param newInputType
-  /// \param newOutputType
-  /// \return cpp code.
-  std::string generateConcatExpr(
-      const std::string& mainClassName,
-      const RowType& outputType, // Used just for the column names
-      std::optional<GeneratedExpressionStruct>& filterExpr,
-      const std::vector<std::pair<size_t, GeneratedExpressionStruct>>&
-          generatedColumns,
-      std::shared_ptr<RowType>& newInputType,
-      std::shared_ptr<RowType>& newOutputType) {
-    VELOX_CHECK_GT(generatedColumns.size(), 0);
-
-    std::stringstream sstring;
-
-    std::vector<std::reference_wrapper<const RowType>> selectedInputTypes;
-
-    if (filterExpr) {
-      selectedInputTypes.push_back(std::ref(filterExpr->inputRowType()));
-    }
-    for (auto& [columnIndex, generatedCode] : generatedColumns) {
-      selectedInputTypes.push_back(std::ref(generatedCode.inputRowType()));
-    };
-
-    /// RowType of the concatenated  expression
-    newInputType = computeUnionType(selectedInputTypes);
-
-    /// Generate class definitions for each supported columns
-    size_t outputIndex = 0;
-    std::vector<std::string> selectedOutputNames;
-    std::vector<std::string> usingDeclNames;
-    std::vector<TypePtr> selectedOutputTypes;
-
-    if (filterExpr) {
-      usingDeclNames.push_back(generateColumnCode(
-          *filterExpr, *newInputType, "selected", outputIndex, sstring));
-      sstring << std::endl;
-    }
-    for (const auto& [column, generatedCode] : generatedColumns) {
-      const std::string columnName = outputType.nameOf(column);
-      const std::string usingDeclName = generateColumnCode(
-          generatedCode, *newInputType, columnName, outputIndex, sstring);
-      sstring << std::endl;
-      usingDeclNames.push_back(usingDeclName);
-      outputIndex++;
-      selectedOutputNames.push_back(columnName);
-      selectedOutputTypes.push_back(outputType.childAt(column));
-    };
-
-    newOutputType = std::make_shared<RowType>(
-        std::move(selectedOutputNames), std::move(selectedOutputTypes));
-
-    // Concatenate all the expression into a single macro expression
-    const std::string concatDeclaration = generateConcatCode(
-        *newInputType,
-        *newOutputType,
-        usingDeclNames,
-        mainClassName,
-        filterExpr.has_value());
-
-    sstring << std::endl << concatDeclaration << std::endl;
-    return sstring.str();
-  }
-
-  /// Return FieldAccess expression for each Column in rowType
-  /// eg [ROW({'a','b'}, {DOUBLETYPE,DOUBLETYPE} ->
-  /// [FieldAcess(a),FieldAccess(b)])
-  /// @param rowType
-  /// @param input input expression to link the generated FieldAccess
-  /// @return vector of FieldAccess, one for each column in rowType
-  std::vector<std::shared_ptr<const core::ITypedExpr>> buildFieldAccessor(
-      const RowType& rowType,
-      std::shared_ptr<const core::ITypedExpr> input = nullptr) {
-    std::vector<std::shared_ptr<const core::ITypedExpr>> fieldAccessVector;
-
-    for (size_t childIdx = 0; childIdx < rowType.size(); ++childIdx) {
-      auto name = rowType.nameOf(childIdx);
-      auto type = rowType.childAt(childIdx);
-      if (input) {
-        auto fieldAccess = std::make_shared<const core::FieldAccessTypedExpr>(
-            type, input, std::move(name));
-        fieldAccessVector.push_back(fieldAccess);
-      } else {
-        auto fieldAccess = std::make_shared<const core::FieldAccessTypedExpr>(
-            type, std::move(name));
-        fieldAccessVector.push_back(fieldAccess);
-      }
-    };
-
-    return fieldAccessVector;
-  }
-
-  /// Build the expressions trees using the generated code.
-  /// In general, we would replace the set of expressions {a + b, a -b} :
-  /// [ IcallExpr(+) -> FieldsAccess(b) -> InputExpr({a,b},{DOUBLE,DOUBLE})
-  ///                -> FieldsAccess(a) /
-  ///  IcallExpr(-) -> FieldsAccess(b) -> InputExpr({a,b},{DOUBLE,DOUBLE})
-  ///               -> FieldsAccess(a) /
-  /// ]
-  /// into                    {PlusExpr,MinusExpr}
-  /// [   -> FieldsAccess(c) -> CompiledEpr{c,d}  -> FieldsAccess(b) ->
-  /// InputExpr({a,b},{DOUBLE,DOUBLE}) [   -> FieldsAccess(d) / \
-  /// FieldsAccess(a) / \param dynamicObjectPath  compiled code path \param
-  /// callOutputType compiled expression output row type \param callInputType
-  /// compiled expression input  row type \param projectionInputType input type
-  /// of the original projection \return
-  std::vector<std::shared_ptr<const ITypedExpr>> buildCompiledCallExpr(
-      const std::filesystem::path& dynamicObjectPath,
-      const std::shared_ptr<const RowType>& callOutputType,
-      const std::shared_ptr<const RowType>& callInputType,
-      const std::shared_ptr<const RowType>& projectionInputType) {
-    // Create the input FieldAccess expression node to the read input data
-    // Note we could reuse the one already existing in the current expressions.
-    auto inputFieldAccessVector = buildFieldAccessor(*callInputType);
-
-    // Create ICompiledExpression
-    auto compiledExpression = std::make_shared<codegen::ICompiledCall>(
-        dynamicObjectPath, inputFieldAccessVector, callOutputType);
-
-    // Create the field accessor to read the output of the compiled call
-    auto outputFieldAccessVector =
-        buildFieldAccessor(*callOutputType, compiledExpression);
-
-    return outputFieldAccessVector;
-  }
-
-  template <typename Children>
-  std::shared_ptr<core::PlanNode> visitFilter(
-      const core::FilterNode& filter,
-      const Children& children) {
-    std::vector<std::pair<size_t, GeneratedExpressionStruct>> generatedColumns;
-    generatedColumns.push_back({0, getGeneratedCode(filter.filter()).value()});
-    if (generatedColumns[0].second.inputRowType().size() == 0) {
-      // it's a constant expression, don't compile it
-      return utils::adapter::FilterCopy::copyWith(
-          filter,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          *ranges::begin(children));
-    }
-
-    VELOX_CHECK_EQ(filter.sources().size(), 1);
-
-    const auto outputType = //*filter.outputType().get();
-        *ROW({"selected"}, std::vector<TypePtr>{BOOLEAN()});
-
-    std::shared_ptr<RowType> concatInputType;
-    std::shared_ptr<RowType> concatOutputType;
-
-    std::optional<GeneratedExpressionStruct> noFilter(std::nullopt);
-
-    // when filter is compiled separately, it's treated similar to projection on
-    // one boolean expr, so here no filter argument but instead has projection
-    // argument
-    const std::string genCode = generateConcatExpr(
-        "FilterExpr",
-        outputType,
-        noFilter,
-        generatedColumns,
-        concatInputType,
-        concatOutputType);
-
-    std::stringstream includes;
-    std::unordered_set<std::string> includeSet;
-    for (const auto& [columnIndex, expressionStruct] : generatedColumns) {
-      includeSet.insert(
-          expressionStruct.headers().begin(), expressionStruct.headers().end());
-    };
-
-    for (const auto& includePath : includeSet) {
-      includes << fmt::format("#include {}\n", includePath);
-    };
-    const std::string fileString = fmt::vformat(
-        fileFormat(),
-        fmt::make_format_args(
-            fmt::arg("includes", includes.str()),
-            fmt::arg("GeneratedCode", genCode),
-            fmt::arg("GeneratedCodeClass", "FilterExpr"),
-            fmt::arg(
-                "isDefaultNull", isDefaultNull(filter.id()) ? "true" : "false"),
-            fmt::arg(
-                "isDefaultNullStrict",
-                isDefaultNullStrict(filter.id()) ? "true" : "false")));
-    auto compiledObject = codeManager_.compiler().compileString({}, fileString);
-    auto dynamicObject = codeManager_.compiler().link({}, {compiledObject});
-
-    // Extract the row input expression from the current filter
-    const auto inputType = filter.sources()[0]->outputType();
-
-    std::shared_ptr<const ITypedExpr> newFilter = buildCompiledCallExpr(
-        dynamicObject, concatOutputType, concatInputType, inputType)[0];
-
-    // Build new filter node with newly generated expressions
-    return utils::adapter::FilterCopy::copyWith(
-        filter, std::placeholders::_1, newFilter, *ranges::begin(children));
-  }
-
-  template <typename Children>
-  std::shared_ptr<core::PlanNode> visitProjection(
-      const core::ProjectNode& projection,
-      const Children& children) {
-    std::vector<std::pair<size_t, GeneratedExpressionStruct>> generatedColumns;
-
-    std::shared_ptr<const core::PlanNode> source = *ranges::begin(children);
-
-    // Check for filter
-    std::optional<GeneratedExpressionStruct> filterExpr = std::nullopt;
-    auto filterNode = std::dynamic_pointer_cast<const core::FilterNode>(source);
-    if (compileFilter_ && mergeFilter_ && filterNode) {
-      if (auto filterCode = getGeneratedCode(filterNode->filter())) {
-        source = filterNode->sources()[0]; // change source to filter's source
-        filterExpr.emplace(filterCode.value());
-      }
-    }
-
-    // Collect all the columns with generated code.
-    for (size_t outputColumn = 0;
-         outputColumn < projection.projections().size();
-         ++outputColumn) {
-      // TODO: We should exclude here direct access columns.
-      if (auto generatedCode =
-              getGeneratedCode(projection.projections()[outputColumn])) {
-        generatedColumns.push_back({outputColumn, generatedCode.value()});
-      }
-    }
-
-    VELOX_CHECK_EQ(projection.sources().size(), 1);
-
-    const auto& outputType = *projection.outputType().get();
-
-    std::shared_ptr<RowType> concatInputType;
-    std::shared_ptr<RowType> concatOutputType;
-
-    const std::string genCode = generateConcatExpr(
-        "ProjectExpr",
-        outputType,
-        filterExpr,
-        generatedColumns,
-        concatInputType,
-        concatOutputType);
-
-    if (concatInputType->size() == 0) {
-      // the whole expression doesn't take input, don't compile it
-      return utils::adapter::ProjectCopy::copyWith(
-          projection,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          *ranges::begin(children));
-    }
-
-    std::stringstream includes;
-    std::unordered_set<std::string> includeSet;
-    for (const auto& [columnIndex, expressionStruct] : generatedColumns) {
-      includeSet.insert(
-          expressionStruct.headers().begin(), expressionStruct.headers().end());
-    };
-
-    for (const auto& includePath : includeSet) {
-      includes << fmt::format("#include {}\n", includePath);
-    };
-
-    bool isDefaultNull, isDefaultNullStrict;
-    if (filterExpr) {
-      isDefaultNull = this->isDefaultNull(filterNode->id());
-      isDefaultNullStrict = this->isDefaultNullStrict(filterNode->id());
-    } else {
-      isDefaultNull = this->isDefaultNull(projection.id());
-      isDefaultNullStrict = this->isDefaultNullStrict(projection.id());
-    }
-
-    const std::string fileString = fmt::vformat(
-        fileFormat(),
-        fmt::make_format_args(
-            fmt::arg("includes", includes.str()),
-            fmt::arg("GeneratedCode", genCode),
-            fmt::arg("GeneratedCodeClass", "ProjectExpr"),
-            fmt::arg("isDefaultNull", isDefaultNull ? "true" : "false"),
-            fmt::arg(
-                "isDefaultNullStrict",
-                isDefaultNullStrict ? "true" : "false")));
-
-    auto compiledObject = codeManager_.compiler().compileString({}, fileString);
-    auto dynamicObject = codeManager_.compiler().link({}, {compiledObject});
-    std::vector<std::shared_ptr<const ITypedExpr>> newProjections;
-
-    // Extract the row input expression from the current projection
-    const auto inputType = projection.sources()[0]->outputType();
-
-    std::vector<std::shared_ptr<const ITypedExpr>> newExpressions =
-        buildCompiledCallExpr(
-            dynamicObject, concatOutputType, concatInputType, inputType);
-
-    // oldToNewExpressionColumnMap[Index] in the new projection list maps to
-    // projection.projections()[Index] in the old;
-    std::map<size_t, std::shared_ptr<const ITypedExpr>>
-        oldToNewExpressionColumnMap;
-
-    for (size_t newExpressionIdx = 0; newExpressionIdx < newExpressions.size();
-         ++newExpressionIdx) {
-      auto oldColumnIndex = generatedColumns[newExpressionIdx].first;
-      oldToNewExpressionColumnMap[oldColumnIndex] =
-          newExpressions[newExpressionIdx];
-    }
-
-    // Replace the selected columns with new generated expressions
-    for (size_t outputColumn = 0;
-         outputColumn < projection.projections().size();
-         ++outputColumn) {
-      if (auto expr = oldToNewExpressionColumnMap.find(outputColumn);
-          expr != oldToNewExpressionColumnMap.end()) {
-        newProjections.push_back(
-            std::dynamic_pointer_cast<const ITypedExpr>(expr->second));
-      } else {
-        newProjections.push_back(projection.projections()[outputColumn]);
-      }
-    }
-    // Build new projection node with newly generated expressions
-    return utils::adapter::ProjectCopy::copyWith(
-        projection,
-        std::placeholders::_1,
-        std::placeholders::_1,
-        std::move(newProjections),
-        source);
-  }
-};
-
-union TransformFlags {
-  struct {
-    bool compileFilter : 1; // use codegen for filter expr
-
-    // merge filter into projection
-    // invalid if compileFilter not set
-    bool mergeFilter : 1;
-
-    bool enableDefaultNullOpt : 1; // enable default null optimization
-
-    // use extended default null definition for filter
-    // invalid if enableDefaultNullOpt not set
-    bool enableFilterDefaultNull : 1;
-
-    // up for more flags in the future
-  };
-
-  // make it easily comparable, may need to increase size as more flags added
-  uint8_t flagVal;
-};
-
-class CodegenCompiledExpressionTransform final : PlanNodeTransform {
- public:
-  constexpr static TransformFlags defaultFlags = {{1, 1, 1, 1}};
-  CodegenCompiledExpressionTransform(
-      const CompilerOptions& options,
-      const UDFManager& udfManager,
-      bool useSymbolsForArithmetic,
-      NamedSteadyClockEventSequence& eventSequence,
-      const TransformFlags& flags = defaultFlags)
-      : compilerOptions_(options),
-        udfManager_(udfManager),
-        useSymbolsForArithmetic_(useSymbolsForArithmetic),
-        eventSequence_(eventSequence),
-        flags_(flags) {}
-
-  std::shared_ptr<core::PlanNode> transform(
-      const core::PlanNode& plan) override {
-    DefaultScopedTimer timer(
-        "CodegenCompiledExpressionTransform", eventSequence_);
-
-    CompiledExpressionAnalysis expressionAnalysis(
-        udfManager_,
-        useSymbolsForArithmetic_,
-        eventSequence_,
-        flags_.enableDefaultNullOpt,
-        flags_.enableFilterDefaultNull);
-
-    expressionAnalysis.run(plan);
-
-    CompiledExpressionTransformVisitor visitor(
-        expressionAnalysis.results(),
-        compilerOptions_,
-        eventSequence_,
-        flags_.compileFilter,
-        flags_.mergeFilter);
-
-    auto nodeTransformer = [&visitor](
-                               auto& node, const auto& transformedChildren) {
-      return visitor.visit(node, transformedChildren);
-    };
-
-    auto [treeRoot, nodeMap] =
-        transform::utils::isomorphicTreeTransform(plan, nodeTransformer);
-    return treeRoot;
-  }
-
-  void setTransformFlags(const TransformFlags& flags) {
-    flags_ = flags;
-  }
-
- private:
-  CompilerOptions compilerOptions_;
-  const UDFManager& udfManager_;
-  bool useSymbolsForArithmetic_;
-  NamedSteadyClockEventSequence& eventSequence_;
-  TransformFlags flags_;
-};
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/CodegenExceptions.h b/velox/experimental/codegen/CodegenExceptions.h
deleted file mode 100644
index 9f134a44cc3b6..0000000000000
--- a/velox/experimental/codegen/CodegenExceptions.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <fmt/format.h>
-#include <exception>
-#include <string>
-
-namespace facebook::velox::codegen {
-/// An exception that is thrown during codegen if an expression/data type that
-/// is not supported in code gen is encountered.
-class CodegenNotSupported : public std::runtime_error {
- public:
-  explicit CodegenNotSupported(const std::string& message)
-      : std::runtime_error(
-            fmt::format("CodegenNotSupported exception : {}", message)
-                .c_str()) {}
-};
-
-/// An exception thrown by ASTNode::validate() when the validation does not
-/// succeed.
-class ASTValidationException : public std::runtime_error {
- public:
-  explicit ASTValidationException(const std::string& message)
-      : std::runtime_error(
-            fmt::format("ASTNodeValidationException exception : {}", message)
-                .c_str()) {}
-};
-
-/// An exception that is thrown if symbols in CodegenStubs.h is accidentally
-/// linked in.
-class CodegenStubsException : public std::runtime_error {
- public:
-  explicit CodegenStubsException(const std::string& message)
-      : std::runtime_error(
-            fmt::format("CodegenStubsException exception : {}", message)
-                .c_str()) {}
-};
-
-/// An exception that is thrown if codegen initialization failed
-class CodegenInitializationException : public std::runtime_error {
- public:
-  explicit CodegenInitializationException(const std::string& message)
-      : std::runtime_error(fmt::format(
-                               "CodegenInitializationException exception : {}",
-                               message)
-                               .c_str()) {}
-};
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/CodegenIncludes.h b/velox/experimental/codegen/CodegenIncludes.h
deleted file mode 100644
index 1700b16002531..0000000000000
--- a/velox/experimental/codegen/CodegenIncludes.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/Codegen.h"
-#include "velox/experimental/codegen/CodegenStubs.h"
diff --git a/velox/experimental/codegen/CodegenLogger.cpp b/velox/experimental/codegen/CodegenLogger.cpp
deleted file mode 100644
index d3f4118913192..0000000000000
--- a/velox/experimental/codegen/CodegenLogger.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/experimental/codegen/CodegenLogger.h"
-#include <glog/logging.h>
-#include "velox/experimental/codegen/Codegen.h"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-
-namespace facebook::velox::codegen {
-
-void CodegenTaskLoggerBase::onCompileEnd(
-    DefaultScopedTimer::EventSequence& eventSequence,
-    const core::PlanNode& planNode) const {
-  LOG(INFO) << "Finished codegen planNode transformation for planNode "
-            << planNode.toString() << ", taskId " << taskId_;
-  LOG(INFO) << std::endl
-            << DefaultScopedTimer::printCounters(eventSequence) << std::endl;
-}
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/CodegenLogger.h b/velox/experimental/codegen/CodegenLogger.h
deleted file mode 100644
index eb6b4ab4166ec..0000000000000
--- a/velox/experimental/codegen/CodegenLogger.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <glog/logging.h>
-#include "velox/experimental/codegen/Codegen.h"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-
-namespace facebook::velox::codegen {
-
-class Codegen;
-
-class ICodegenLogger {
- public:
-  virtual ~ICodegenLogger() {}
-  virtual void onInitialize(bool lazyLoading) const = 0;
-  virtual void onInitializeFromFile(
-      const std::filesystem::path& codegenOptionsJsonFile,
-      bool lazyLoading) const = 0;
-  virtual void onCompileStart(const core::PlanNode& planNode) const = 0;
-  virtual void onCompileEnd(
-      DefaultScopedTimer::EventSequence& eventSequence,
-      const core::PlanNode& planNode) const = 0;
-};
-
-class CodegenTaskLoggerBase : public ICodegenLogger {
- public:
-  explicit CodegenTaskLoggerBase(const std::string& taskId) : taskId_(taskId) {}
-  virtual ~CodegenTaskLoggerBase() override {}
-
-  void onInitialize(bool lazyLoading) const override {
-    auto status = lazyLoading ? "enabled" : "disabled";
-    LOG(INFO) << "Initializing codegen with lazyLoading " << status;
-  }
-
-  void onInitializeFromFile(
-      const std::filesystem::path& codegenOptionsJsonFile,
-      bool lazyLoading) const override {
-    auto status = lazyLoading ? "enabled" : "disabled";
-    LOG(INFO) << "Initializing using CodegenOptions from "
-              << codegenOptionsJsonFile << "with lazyLoading " << status;
-  }
-
-  void onCompileStart(const core::PlanNode& planNode) const override {
-    LOG(INFO) << "Starting codegen planNode transformation for planNode "
-              << planNode.toString() << ", taskId " << taskId_;
-  }
-
-  void onCompileEnd(
-      DefaultScopedTimer::EventSequence& eventSequence,
-      const core::PlanNode& planNode) const override;
-
- protected:
-  const std::string& taskId_;
-};
-
-using DefaultLogger = CodegenTaskLoggerBase;
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/CodegenStubs.cpp b/velox/experimental/codegen/CodegenStubs.cpp
deleted file mode 100644
index 9eaf520164e97..0000000000000
--- a/velox/experimental/codegen/CodegenStubs.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <glog/logging.h>
-#include "velox/experimental/codegen/Codegen.h"
-#include "velox/experimental/codegen/CodegenExceptions.h"
-#include "velox/experimental/codegen/CodegenLogger.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-__attribute__((weak)) bool Codegen::initialize(
-    [[maybe_unused]] const std::string_view& codegenOptionsJson,
-    [[maybe_unused]] bool lazyLoading) {
-  throw CodegenStubsException("Codegen::initialize()");
-}
-
-__attribute__((weak)) bool Codegen::initializeFromFile(
-    [[maybe_unused]] const std::filesystem::path& codegenOptionsJsonFile,
-    [[maybe_unused]] bool lazyLoading) {
-  throw CodegenStubsException("Codegen::initializeFromFile()");
-}
-
-__attribute__((weak)) std::shared_ptr<const core::PlanNode> Codegen::compile(
-    [[maybe_unused]] const core::PlanNode& planNode) {
-  throw CodegenStubsException("Codegen::compile()");
-}
-
-bool Codegen::initializeCodeManager(
-    [[maybe_unused]] const proto::CompilerOptionsProto& compilerOptionsProto) {
-  throw CodegenStubsException("Codegen::initializeCodeManager()");
-}
-
-bool Codegen::initializeUDFManager() {
-  throw CodegenStubsException("Codegen::initializeUDFManager()");
-}
-
-bool Codegen::initializeTransform() {
-  throw CodegenStubsException("Codegen::initializeTransform()");
-}
-
-bool Codegen::runInitializationTests() {
-  throw CodegenStubsException("Codegen::runInitializationTests()");
-}
-
-} // namespace codegen
-} // namespace velox
-}; // namespace facebook
diff --git a/velox/experimental/codegen/CompiledExpressionAnalysis.h b/velox/experimental/codegen/CompiledExpressionAnalysis.h
deleted file mode 100644
index 966cdeecd0527..0000000000000
--- a/velox/experimental/codegen/CompiledExpressionAnalysis.h
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-// This file defines the tranasformation pass that analyses pre-generated
-// codegen-ast trees and generates the code for each of the supported
-// expressions, in addition to some other analysis about the
-// expressions.
-
-#include <functional>
-#include "velox/core/PlanNode.h"
-#include "velox/experimental/codegen/CodegenASTAnalysis.h"
-#include "velox/experimental/codegen/ast/AST.h"
-#include "velox/experimental/codegen/ast/ASTAnalysis.h"
-#include "velox/experimental/codegen/ast/ASTNode.h"
-#include "velox/experimental/codegen/transform/PlanNodeTransform.h"
-
-namespace facebook::velox::codegen {
-
-using velox::core::ITypedExpr;
-using velox::transform::PlanNodeAnalysis;
-
-struct CompiledExpressionAnalysisResult {
-  /// TOOD: Merge
-  /// std::map<std::string,std::pair<size_t,facebook::velox::TypePtr>> into
-  /// GeneratedExpressionStruct
-  std::map<std::shared_ptr<const ITypedExpr>, GeneratedExpressionStruct>
-      generatedCode_;
-  std::map<core::PlanNodeId, bool> isDefaultNull_;
-  std::map<core::PlanNodeId, bool> isDefaultNullStrict_;
-};
-
-namespace {
-
-/// TODO: create a generic base visitor class for PlanNode
-class GenerateCompiledExpressionVisitor {
- public:
-  GenerateCompiledExpressionVisitor(
-      const std::map<std::shared_ptr<const ITypedExpr>, CodegenASTNode>&
-          astNodes,
-      CompiledExpressionAnalysisResult& result,
-      const UDFManager& udfManager,
-      bool useSymbolsForArithmetic,
-      DefaultScopedTimer::EventSequence& eventSequence,
-      bool enableDefaultNullOpt = true,
-      bool enableFilterDefaultNull = true)
-      : enableDefaultNullOpt_(enableDefaultNullOpt),
-        enableFilterDefaultNull_(enableFilterDefaultNull),
-        astNodes_(astNodes),
-        result_(result),
-        generator_(udfManager, useSymbolsForArithmetic, false),
-        eventSequence_(eventSequence) {}
-
-  void visit(const core::PlanNode& planNode) {
-    if (auto projectNode = dynamic_cast<const core::ProjectNode*>(&planNode)) {
-      visitProjection(*projectNode);
-    } else if (
-        auto filterNode = dynamic_cast<const core::FilterNode*>(&planNode)) {
-      visitFilter(*filterNode);
-    } else if (
-        auto valueNode = dynamic_cast<const core::ValuesNode*>(&planNode)) {
-    } else if (
-        dynamic_cast<const core::TableWriteNode*>(&planNode) ||
-        dynamic_cast<const core::TableScanNode*>(&planNode)) {
-      // Those plan nodes do not have expressions to transform
-    } else {
-      throw std::logic_error("Unknown node type:\n" + planNode.toString());
-    }
-  }
-
- private:
-  bool enableDefaultNullOpt_ = true;
-
-  // enable the extended default null analysis for filter
-  bool enableFilterDefaultNull_ = true;
-
-  const std::map<std::shared_ptr<const ITypedExpr>, CodegenASTNode>& astNodes_;
-  CompiledExpressionAnalysisResult& result_;
-  ExprCodeGenerator generator_;
-  DefaultScopedTimer::EventSequence eventSequence_;
-
-  const ASTNodePtr getCodegenAST(
-      const std::shared_ptr<const core::ITypedExpr>& expr) {
-    auto astIt = astNodes_.find(expr);
-    if (astIt == astNodes_.end()) {
-      return nullptr;
-    }
-    return astIt->second;
-  }
-
-  void generateCompiledExpression(
-      const std::shared_ptr<const core::ITypedExpr>& expr,
-      bool markAllInputsNotNullable) {
-    auto ast = getCodegenAST(expr);
-    if (!ast) {
-      return;
-    }
-
-    auto outputExpression = std::make_shared<MakeRowExpression>(
-        ast->typePtr(), std::vector<ASTNodePtr>{ast});
-
-    if (markAllInputsNotNullable) {
-      ast->markAllInputsNotNullable();
-    }
-
-    ast->propagateNullability();
-
-    auto codeStruct = generator_.codegenExpression(*outputExpression.get());
-    result_.generatedCode_.emplace(expr, codeStruct);
-  }
-
-  void visitProjection(const core::ProjectNode& projection) {
-    VELOX_CHECK(!projection.sources().empty());
-    VELOX_CHECK(projection.sources()[0] != nullptr);
-
-    // check if the generated fused expression is default null.
-    // for now its a property of the whole operator since we fuse all
-    // expressions into one expression.
-    bool isDefaultNull = false;
-    bool isDefaultNullStrict = false;
-
-    // currently when projection is after a filter, then only use default null
-    // for filter
-    if (enableDefaultNullOpt_ &&
-        std::dynamic_pointer_cast<const core::FilterNode>(
-            projection.sources()[0]) == nullptr) {
-      isDefaultNull = true;
-      isDefaultNullStrict = true;
-      std::set<std::string> inputAttrs;
-      auto& cxt = generator_.getContext();
-      auto firstExpr = true;
-      for (const auto& expr : projection.projections()) {
-        auto ast = getCodegenAST(expr);
-        if (!ast) {
-          continue;
-        }
-        cxt.columnNameToIndexMap().clear();
-        cxt.setComputeInputTypeDuringCodegen(true);
-        ast->generateCode(cxt, "outputTuple");
-
-        std::set<std::string> curAttrs;
-        for (auto& [name, _] : cxt.columnNameToIndexMap()) {
-          curAttrs.insert(name);
-        }
-
-        if (firstExpr) {
-          // first column, define the attribute set
-          inputAttrs = curAttrs;
-          firstExpr = false;
-        } else {
-          // check if it's the same set of attributes
-          if (inputAttrs != curAttrs) {
-            isDefaultNull = isDefaultNullStrict = false;
-            break;
-          }
-        }
-
-        isDefaultNull = isDefaultNull && analysis::isDefaultNull(*ast.get());
-        isDefaultNullStrict =
-            isDefaultNullStrict && analysis::isDefaultNullStrict(*ast.get());
-      }
-
-      result_.isDefaultNull_[projection.id()] = isDefaultNull;
-      result_.isDefaultNullStrict_[projection.id()] = isDefaultNullStrict;
-    }
-    for (const auto& expr : projection.projections()) {
-      // when the compiled expression is default null we generate code
-      // assuming all inputs are not nullable and the vector function only
-      // executes not nullable inputs
-      generateCompiledExpression(expr, isDefaultNullStrict || isDefaultNull);
-    }
-  }
-
-  void visitFilter(const core::FilterNode& filterNode) {
-    VELOX_CHECK(!filterNode.sources().empty());
-    VELOX_CHECK(filterNode.sources()[0] != nullptr);
-    auto ast = getCodegenAST(filterNode.filter());
-    if (!ast) {
-      return;
-    }
-    bool isDefaultNull = false;
-    if (enableDefaultNullOpt_) {
-      isDefaultNull = result_.isDefaultNull_[filterNode.id()] =
-          enableFilterDefaultNull_ ? analysis::isFilterDefaultNull(*ast.get())
-                                   : analysis::isDefaultNull(*ast.get());
-      // filter doesn't care default null strict since it doesn't use
-      // VectorWriter
-    }
-    generateCompiledExpression(filterNode.filter(), isDefaultNull);
-  }
-};
-} // namespace
-
-/// This analysis builds generates GeneratedExpressionStruct for each
-/// expressions in the planNode.
-class CompiledExpressionAnalysis : PlanNodeAnalysis {
- public:
-  CompiledExpressionAnalysis(
-      const UDFManager& udfManager,
-      bool useSymbolsForArithmetic,
-      DefaultScopedTimer::EventSequence& eventSequence,
-      bool enableDefaultNullOpt = true,
-      bool enableFilterDefaultNull = true)
-      : udfManager_(udfManager),
-        useSymbolsForArithmetic_(useSymbolsForArithmetic),
-        eventSequence_(eventSequence),
-        enableDefaultNullOpt_(enableDefaultNullOpt),
-        enableFilterDefaultNull_(enableFilterDefaultNull) {}
-
-  ~CompiledExpressionAnalysis() override {}
-
-  void run(const core::PlanNode& plan) override {
-    DefaultScopedTimer timer("CompiledExpressionAnalysis", eventSequence_);
-    CodegenASTAnalysis astAnalysis(
-        udfManager_, useSymbolsForArithmetic_, eventSequence_);
-    astAnalysis.run(plan);
-    GenerateCompiledExpressionVisitor visitor(
-        astAnalysis.nodes(),
-        result_,
-        udfManager_,
-        useSymbolsForArithmetic_,
-        eventSequence_,
-        enableDefaultNullOpt_,
-        enableFilterDefaultNull_);
-    dfsApply(
-        plan, [&visitor](const auto& planNode) { visitor.visit(planNode); });
-  }
-
-  const auto& results() const {
-    return result_;
-  }
-
- private:
-  CompiledExpressionAnalysisResult result_;
-  const UDFManager& udfManager_;
-  bool useSymbolsForArithmetic_;
-  DefaultScopedTimer::EventSequence& eventSequence_;
-  bool enableDefaultNullOpt_, enableFilterDefaultNull_;
-};
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/ast/AST.h b/velox/experimental/codegen/ast/AST.h
deleted file mode 100644
index b3b74b12441be..0000000000000
--- a/velox/experimental/codegen/ast/AST.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include "velox/experimental/codegen/ast/ASTNode.h"
-#include "velox/experimental/codegen/ast/BinaryExpressions.h"
-#include "velox/experimental/codegen/ast/ConstantExpressions.h"
-#include "velox/experimental/codegen/ast/UnaryExpressions.h"
diff --git a/velox/experimental/codegen/ast/ASTAnalysis.cpp b/velox/experimental/codegen/ast/ASTAnalysis.cpp
deleted file mode 100644
index 8aa7920e434a0..0000000000000
--- a/velox/experimental/codegen/ast/ASTAnalysis.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/experimental/codegen/ast/ASTAnalysis.h"
-#include "boost/logic/tribool.hpp"
-#include "velox/experimental/codegen/ast/ASTNode.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::codegen::analysis {
-
-bool isDefaultNull(const ASTNode& node) {
-  if (node.as<const InputRefExpr>() || node.isConstantExpression()) {
-    return true;
-  }
-
-  if (node.getNullMode() == ExpressionNullMode::NullInNullOut) {
-    for (auto child : node.children()) {
-      if (!isDefaultNull(*child)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-
-bool isDefaultNullStrict(const ASTNode& node) {
-  if (node.as<const InputRefExpr>()) {
-    return true;
-  }
-
-  if (node.isConstantExpression()) {
-    // maybe null for constant expressions is preset.
-    return !node.maybeNull();
-  }
-
-  if (auto udfCallExpr = node.as<const UDFCallExpr>();
-      node.getNullMode() == ExpressionNullMode::NullInNullOut &&
-      (udfCallExpr == nullptr || !udfCallExpr->isNullableOutput())) {
-    for (auto child : node.children()) {
-      if (!isDefaultNullStrict(*child)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  return false;
-}
-
-namespace {
-// default null clauses connected by logical operators
-bool isDefaultNullOrLogical(const ASTNode& node) {
-  // logical operators
-  if (node.as<const NotExpr>() || node.as<const LogicalAnd>() ||
-      node.as<const LogicalOr>() || node.as<const IsNullExpr>()) {
-    for (auto child : node.children()) {
-      if (!isDefaultNullOrLogical(*child)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  // when node is not logical, the entire subtree must be default null
-  return isDefaultNull(node);
-}
-
-using namespace boost::logic;
-
-// needed to put tribool in a set
-struct triboolLT {
-  bool operator()(const tribool& l, const tribool& r) const {
-    return l.value < r.value;
-  }
-};
-
-bool isConstExpr(const ASTNode& node) {
-  if (node.as<const InputRefExpr>()) {
-    return false;
-  }
-
-  auto ret = true;
-  for (const auto& child : node.children()) {
-    ret = ret && isConstExpr(*child);
-  }
-  return ret;
-}
-
-/// return the set of all possible logical result given at least one input
-/// variable is null. Example: "(a>b) AND (c>d)" returns {null, false}
-/// the logic:
-/// a or b is null => lhs is null => null AND {true, null, false} gets {null,
-/// false};
-/// c or d is null => rhs is null => {true, null, false} AND null gets {null,
-/// false};
-/// then the union of the 2 is the final output {null, false} U {null, false} =
-/// {null, false}
-std::set<tribool, triboolLT> outputIfNullIn(const ASTNode& node) {
-  const static std::set<tribool, triboolLT> fullSet = {
-      true, false, indeterminate}; // indeterminate == null
-  std::set<tribool, triboolLT> out;
-  if (node.as<const LogicalAnd>()) {
-    std::set<tribool, triboolLT> childOut;
-    for (auto& child : node.children()) {
-      childOut.merge(outputIfNullIn(*child));
-    }
-    for (auto& val : childOut) {
-      /* assuming if the null variable comes from one side then the other side
-       can be any truth value (same below for LogicalOr). this doesn't
-       guarantee the most accurate result (e.g. when a variable appears in
-       both sides), but it ensures no non-default null expression will be
-       treated as default null. */
-      for (auto& otherVal : fullSet) {
-        out.insert(val && otherVal);
-      }
-    }
-    return out;
-  }
-
-  if (node.as<const LogicalOr>()) {
-    std::set<tribool, triboolLT> childOut;
-    for (auto& child : node.children()) {
-      childOut.merge(outputIfNullIn(*child));
-    }
-    for (auto& val : childOut) {
-      for (auto& otherVal : fullSet) {
-        out.insert(val || otherVal);
-      }
-    }
-    return out;
-  }
-
-  if (auto notExpr = node.as<const NotExpr>()) {
-    for (auto& val : outputIfNullIn(*notExpr->child())) {
-      out.insert(!val);
-    }
-    return out;
-  }
-
-  if (auto isNullExpr = node.as<const IsNullExpr>()) {
-    auto childOut = outputIfNullIn(*isNullExpr->child());
-    if (childOut.count(indeterminate)) {
-      // (null) IS NULL => true
-      out.insert(true);
-    }
-    if (childOut.count(true) || childOut.count(false)) {
-      // (anything not null) IS NULL => false
-      out.insert(false);
-    }
-    return out;
-  }
-
-  // not logical operator, we know it's default null boolean expr at this point
-
-  // if it's a default null constant expression, the result should be a fixed
-  // value, but we don't know without evaluation, so just return fullSet
-  if (isConstExpr(node)) {
-    return fullSet;
-  }
-
-  // a default null boolean expr that's not constant (has variable), then it
-  // only evaluates to null if any input is null
-  return {indeterminate};
-}
-} // namespace
-
-/*
-Filter Default Null: an extended default null definition for filter.
-A boolean expression that eventually evaluates to false or null are treated the
-same - both as false by the filter, therefore the default null analysis can be
-stretched for filter: "If at least one input variable is null, then the
-expression cannot evaluate to true".
-*/
-bool isFilterDefaultNull(const ASTNode& node) {
-  if (isDefaultNull(node)) {
-    // a regular default null is also an extended default null
-    return true;
-  }
-
-  if (!isDefaultNullOrLogical(node)) {
-    return false;
-  }
-
-  auto outSet = outputIfNullIn(node);
-  return outSet.find(true) == outSet.end();
-}
-} // namespace facebook::velox::codegen::analysis
diff --git a/velox/experimental/codegen/ast/ASTAnalysis.h b/velox/experimental/codegen/ast/ASTAnalysis.h
deleted file mode 100644
index 802dfbdd557fe..0000000000000
--- a/velox/experimental/codegen/ast/ASTAnalysis.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/experimental/codegen/ast/AST.h"
-
-namespace facebook::velox::codegen::analysis {
-
-// output is null if any input is null
-bool isDefaultNull(const ASTNode& node);
-
-// output is null iff any input is null
-bool isDefaultNullStrict(const ASTNode& node);
-
-// output is null or false if any input is null
-bool isFilterDefaultNull(const ASTNode& node);
-
-}; // namespace facebook::velox::codegen::analysis
diff --git a/velox/experimental/codegen/ast/ASTNode.cpp b/velox/experimental/codegen/ast/ASTNode.cpp
deleted file mode 100644
index 42656fdbaa789..0000000000000
--- a/velox/experimental/codegen/ast/ASTNode.cpp
+++ /dev/null
@@ -1,385 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/ast/ASTNode.h"
-#include <sstream>
-#include "velox/common/base/Exceptions.h"
-#include "velox/experimental/codegen/ast/CodegenUtils.h"
-#include "velox/experimental/codegen/ast/UnaryExpressions.h"
-
-namespace facebook::velox::codegen {
-
-ASTNode::~ASTNode(){};
-
-void ASTNode::markAllInputsNotNullable() {
-  if (auto* inputRefExpr = this->as<InputRefExpr>()) {
-    inputRefExpr->setMaybeNull(false);
-  }
-  for (auto& child : children()) {
-    child->markAllInputsNotNullable();
-  }
-}
-
-// Implements codegen for inputRef expression
-CodeSnippet InputRefExpr::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::string code;
-  auto inputRowIndex = exprCodegenCtx.computeInputTypeDuringCodegen()
-      ? exprCodegenCtx.computeIndexForColumn(name(), typePtr())
-      : this->index();
-  auto inputArgAccess =
-      codegenUtils::codegenTupleAccess("inputTuple", inputRowIndex);
-
-  code = codegenUtils::codegenAssignment(outputVarName, inputArgAccess);
-
-  return CodeSnippet(outputVarName, code);
-}
-
-// Implements codegen for output expression
-CodeSnippet MakeRowExpression::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::stringstream code;
-  for (auto i = 0; i < children_.size(); i++) {
-    // Write results in output tuple fields directly
-    auto childCodeSnippet = children_[i]->generateCode(
-        exprCodegenCtx, codegenUtils::codegenTupleAccess(outputVarName, i));
-    code << childCodeSnippet.code();
-  }
-
-  return CodeSnippet(outputVarName, code.str());
-}
-
-CodeSnippet IfExpression::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::stringstream code;
-  auto conditionOutputVariable = exprCodegenCtx.getUniqueTemp("condition");
-  code << codegenUtils::codegenTempVarDecl(
-      BooleanType(), conditionOutputVariable);
-  auto conditionExprCodeSnippet =
-      condition_->generateCode(exprCodegenCtx, conditionOutputVariable);
-
-  auto thenExprCodeSnippet =
-      thenPart_->generateCode(exprCodegenCtx, outputVarName);
-
-  CodeSnippet elseExprCodeSnippet;
-  if (elsePart_) {
-    elseExprCodeSnippet =
-        elsePart_->generateCode(exprCodegenCtx, outputVarName);
-  } else {
-    // Default is null
-    auto outputVar = exprCodegenCtx.getUniqueTemp();
-
-    elseExprCodeSnippet = CodeSnippet(
-        outputVarName,
-        codegenUtils::codegenAssignment(outputVarName, "std::nullopt"));
-  }
-
-  std::string condition;
-  if (!condition_->maybeNull()) {
-    condition = fmt::format("*{}", conditionOutputVariable);
-  } else {
-    condition = fmt::format("{0}.has_value() && *{0}", conditionOutputVariable);
-  }
-
-  // TODO: support eager format
-  if (isEager_) {
-    throw CodegenNotSupported("eager if not supported");
-  }
-
-  constexpr auto lazyFormat =
-      "{conditionCode} if ({condition}) "
-      "{{ {thenCode}  }} else {{ {elseCode} }}";
-
-  code << fmt::format(
-      lazyFormat,
-      fmt::arg("conditionCode", conditionExprCodeSnippet.code()),
-      fmt::arg("elseCode", elseExprCodeSnippet.code()),
-      fmt::arg("thenCode", thenExprCodeSnippet.code()),
-      fmt::arg("condition", condition));
-
-  return CodeSnippet(outputVarName, code.str());
-}
-
-void IfExpression::propagateNullability() {
-  condition_->propagateNullability();
-  thenPart_->propagateNullability();
-  if (elsePart_) {
-    elsePart_->propagateNullability();
-  }
-
-  // TODO: double check if we need to check on eagerness here.
-  setMaybeNull(
-      thenPart_->maybeNull() || elsePart_ == nullptr || elsePart_->maybeNull());
-}
-
-void IfExpression::validate() const {
-  validateTyped();
-}
-
-CodeSnippet SwitchExpression::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::stringstream code;
-
-  for (int i = 0; i < inputs_.size() / 2; i++) {
-    auto conditionOutputVariable = exprCodegenCtx.getUniqueTemp("condition");
-    auto whenPart = inputs_[2 * i];
-    auto thenPart = inputs_[2 * i + 1];
-
-    auto conditionExprCodeSnippet =
-        whenPart->generateCode(exprCodegenCtx, conditionOutputVariable);
-    auto thenExprCodeSnippet =
-        thenPart->generateCode(exprCodegenCtx, outputVarName);
-
-    std::string condition;
-    if (!whenPart->maybeNull()) {
-      condition = fmt::format("*{}", conditionOutputVariable);
-    } else {
-      condition =
-          fmt::format("{0}.has_value() && *{0}", conditionOutputVariable);
-    }
-
-    constexpr auto lazyFormat =
-        "{maybeElse}if (({{ {conditionVar} {conditionCode}{condition}; }})) "
-        "{{ {thenCode}  }}";
-
-    code << fmt::format(
-        lazyFormat,
-        fmt::arg("maybeElse", (i > 0) ? "else " : ""),
-        fmt::arg(
-            "conditionVar",
-            codegenUtils::codegenTempVarDecl(
-                BooleanType(), conditionOutputVariable)),
-        fmt::arg("conditionCode", conditionExprCodeSnippet.code()),
-        fmt::arg("thenCode", thenExprCodeSnippet.code()),
-        fmt::arg("condition", condition));
-  }
-
-  CodeSnippet elseExprCodeSnippet;
-  if (inputs_.size() & 1) { // has ELSE
-    elseExprCodeSnippet =
-        inputs_.back()->generateCode(exprCodegenCtx, outputVarName);
-  } else {
-    // Default is null
-    auto outputVar = exprCodegenCtx.getUniqueTemp();
-
-    elseExprCodeSnippet = CodeSnippet(
-        outputVarName,
-        codegenUtils::codegenAssignment(outputVarName, "std::nullopt"));
-  }
-
-  constexpr auto lazyFormat = "else {{ {elseCode} }}";
-
-  code << fmt::format(
-      lazyFormat, fmt::arg("elseCode", elseExprCodeSnippet.code()));
-
-  return CodeSnippet(outputVarName, code.str());
-}
-
-void SwitchExpression::propagateNullability() {
-  bool maybeNull = false;
-  for (int i = 0; i < inputs_.size() / 2; i++) {
-    auto whenPart = inputs_[2 * i];
-    auto thenPart = inputs_[2 * i + 1];
-    whenPart->propagateNullability();
-    thenPart->propagateNullability();
-    maybeNull |= thenPart->maybeNull();
-  }
-
-  if (inputs_.size() & 1) { // has ELSE
-    auto elsePart = inputs_.back();
-    elsePart->maybeNull();
-    maybeNull |= elsePart->maybeNull();
-  } else {
-    // FIXME: Unless query optimizer took care of this already, othersie this
-    // isn't a careful enough check, if the cases cover all possibilities, then
-    // it won't NULL even without ELSE.
-    maybeNull = true;
-  }
-
-  setMaybeNull(maybeNull);
-}
-
-void SwitchExpression::validate() const {
-  validateTyped();
-}
-
-// UDF Call expression
-void UDFCallExpr::validate() const {
-  if (getNullMode() == ExpressionNullMode::Custom) {
-    throw CodegenNotSupported(
-        "udf does not support custom nullable propagation");
-  }
-  validateTyped();
-}
-
-CodeSnippet UDFCallExpr::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  for (auto& header : getHeaderFiles()) {
-    exprCodegenCtx.addHeaderPath(header);
-  }
-
-  exprCodegenCtx.addLibs(getLibs());
-
-  std::stringstream code;
-  std::stringstream inputArguments;
-
-  bool first = true;
-  std::vector<std::string> nullableArgs;
-  size_t i = 0;
-  for (auto child : children()) {
-    if (!first) {
-      inputArguments << ", ";
-    }
-
-    if (first) {
-      first = false;
-    }
-
-    // UDF arguments are always materialized even for complex types,
-    // if things can benefit from a lazy eval, they should be implemented as
-    // built in.
-    // In theory we can allow UDFs to accept lambdas with a lazy arg configs.
-    auto childResultVariable =
-        exprCodegenCtx.getUniqueTemp(fmt::format("udf_arg_{}", i++));
-
-    code << codegenUtils::codegenTempVarDecl(
-        child->type(), childResultVariable);
-    if (child->maybeNull()) {
-      nullableArgs.push_back(childResultVariable);
-    }
-
-    auto childCode = child->generateCode(exprCodegenCtx, childResultVariable);
-    code << childCode.code();
-
-    // TODO: this is a work around for UDFs that do not respect the templated
-    // interface as input. i.e: cast udfs with string inputs.
-    inputArguments
-        << (udfInformation_.isOptionalArguments()
-                ? childResultVariable
-                : codegenUtils::codegenOptionalAccess(childResultVariable));
-  }
-
-  std::string work;
-  if (udfInformation_.getOutputForm() == OutputForm::Return) {
-    VELOX_CHECK(type().kind() != TypeKind::VARCHAR);
-    std::string functionCall;
-
-    if (udfInformation_.isOptionalOutput()) {
-      functionCall =
-          fmt::format("{}({})", getFunctionName(), inputArguments.str());
-    } else {
-      functionCall = fmt::format(
-          "{}{{ {}({}) }}",
-          codegenUtils::codegenNullableNativeType(
-              type(), codegenUtils::TypePlacement::Temp),
-          getFunctionName(),
-          inputArguments.str());
-    }
-    work = codegenUtils::codegenAssignment(outputVarName, functionCall);
-  } else if (udfInformation_.getOutputForm() == OutputForm::InOut) {
-    // Generate output argument
-    std::string outputInOutArg;
-    if (udfInformation_.isOptionalOutput()) {
-      VELOX_CHECK(type().kind() != TypeKind::VARCHAR);
-      outputInOutArg = outputVarName;
-    } else {
-      outputInOutArg = fmt::format("*{}", outputVarName);
-    }
-
-    // Add output argument to the beginning
-    auto allArguments = inputArguments.str();
-    if (allArguments.size() == 0) {
-      allArguments = outputInOutArg;
-    } else {
-      allArguments = fmt::format("{},{}", outputInOutArg, allArguments);
-    }
-
-    // Generate function call
-    work = fmt::format("{}({});", getFunctionName(), allArguments);
-    // Call finalize for strings
-    if (udfInformation_.getOutputForm() == OutputForm::InOut &&
-        type().kind() == TypeKind::VARCHAR) {
-      work += fmt::format("({}).finalize();", outputInOutArg);
-    }
-  }
-
-  if (udfInformation_.codegenNullInNullOutChecks()) {
-    code << codegenUtils::codegenNullInNullOut(
-        work, nullableArgs, outputVarName);
-  } else {
-    code << work;
-  }
-  return CodeSnippet(outputVarName, code.str());
-}
-
-void CoalesceExpr::propagateNullability() {
-  for (auto& child : children()) {
-    child->propagateNullability();
-  }
-
-  // If any is not nullable output is not nullable
-  for (auto& child : children()) {
-    if (!child->maybeNull()) {
-      setMaybeNull(false);
-      return;
-    }
-  }
-
-  // All  inputs maybe null
-  setMaybeNull(true);
-}
-
-CodeSnippet CoalesceExpr::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::stringstream code;
-
-  auto children_ = children();
-  std::function<void(int)> generateChildrenCode = [&](int idx) {
-    if (idx == children_.size()) {
-      // write null to output
-      code << codegenUtils::codegenAssignment(outputVarName, "std::nullopt");
-      return;
-    }
-
-    auto& child = children_[idx];
-
-    // We need to make sure we can shallow copy the writers of complex types in
-    // efficient way.
-    auto childCodeSnippet = child->generateCode(exprCodegenCtx, outputVarName);
-    code << childCodeSnippet.code() << "\n";
-
-    code << fmt::format(
-        "if (!{condition}) {{ ",
-        fmt::arg(
-            "condition",
-            child->maybeNull()
-                ? codegenUtils::codegenOptionalValueCheck(outputVarName)
-                : "true"));
-    generateChildrenCode(idx + 1);
-    // Close else
-    code << "}";
-  };
-
-  generateChildrenCode(0);
-  return CodeSnippet(outputVarName, code.str());
-}
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/ast/ASTNode.h b/velox/experimental/codegen/ast/ASTNode.h
deleted file mode 100644
index 60305585beb29..0000000000000
--- a/velox/experimental/codegen/ast/ASTNode.h
+++ /dev/null
@@ -1,451 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <memory>
-#include <optional>
-#include <shared_mutex>
-#include <sstream>
-#include <string>
-#include <vector>
-#include "velox/experimental/codegen/CodegenExceptions.h"
-#include "velox/experimental/codegen/ast/CodegenCtx.h"
-#include "velox/experimental/codegen/compiler_utils/LibraryDescriptor.h"
-#include "velox/experimental/codegen/udf_manager/ExpressionNullMode.h"
-#include "velox/experimental/codegen/udf_manager/UDFManager.h"
-#include "velox/type/Type.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-using ASTNodePtr = std::shared_ptr<class ASTNode>;
-// A structure that represent the intermediate partial code generated by the
-// generateCode.
-struct CodeSnippet {
- public:
-  CodeSnippet(
-      const std::string& outputVarName = "",
-      const std::string& code = "")
-      : outputVarName_(outputVarName), code_(code) {}
-
-  const std::string& code() const {
-    return code_;
-  }
-
-  // Return a lambda that executes the code and returns the result value stored
-  // in the output variable.
-  std::string getAsLambda(const std::string& lambdaName) const {
-    return fmt::format(
-        "auto {name} = [](){{ {code} return {outputVar}; }}",
-        fmt::arg("code", code_),
-        fmt::arg("outputVar", outputVarName_),
-        fmt::arg("name", lambdaName));
-  }
-
- private:
-  // The name of the output variable that holds the expression result value
-  std::string outputVarName_;
-
-  // The code that need to be executed
-  std::string code_;
-};
-
-/// Abstract class for all expression supported in codegen
-class ASTNode {
- public:
-  explicit ASTNode(const TypePtr& type)
-      : type_(std::const_pointer_cast<Type>(type)) {}
-
-  virtual ~ASTNode() = 0;
-
-  // Validate if the expression node is complete and ready for codeGen
-  virtual void validate() const = 0;
-
-  // Returns a list of all the children expressions
-  virtual const std::vector<ASTNodePtr> children() const = 0;
-
-  // Uses default propagation, can be overridden
-  virtual void propagateNullability() {
-    defaultNullabilityPropagation();
-  }
-
-  // List of include files required for the expression to be executed
-  virtual std::vector<std::string> getHeaderFiles() const {
-    return {};
-  }
-
-  // List of libs required for the expression to be executed
-  virtual std::vector<compiler_utils::LibraryDescriptor> getLibs() const {
-    return {};
-  }
-
-  template <typename T>
-  const T* as() const {
-    return dynamic_cast<const T*>(this);
-  }
-
-  template <typename T>
-  T* as() {
-    return dynamic_cast<T*>(this);
-  }
-
-  virtual bool isConstantExpression() const {
-    return false;
-  }
-
-  // Generate code with nullable info and return the name of the variable
-  // storing the results. Result should be written to output. For complex types
-  // output should not be null before written.
-  virtual CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const = 0;
-
-  // Return the null mode of the expression, used in default
-  // propagateNullability.
-  virtual ExpressionNullMode getNullMode() const = 0;
-
-  // Return the sql data type of the expression
-  const velox::Type& type() const {
-    return *type_.get();
-  }
-
-  /// Return the sql data type of the expression
-  const velox::TypePtr typePtr() const {
-    return type_;
-  }
-
-  /// Check weather the expression is typed
-  bool typed() const {
-    return type_ != nullptr && type_->kind() != TypeKind::INVALID;
-  }
-
-  void validateTyped() const {
-    if (!typed()) {
-      throw ASTValidationException("ast node not typed");
-    }
-  }
-
-  // Returns the nullability of the node
-  bool maybeNull() const {
-    return maybeNull_;
-  }
-
-  void markAllInputsNotNullable();
-
- protected:
-  // Set the nullability of the node
-  void setMaybeNull(bool maybeNull) {
-    maybeNull_ = maybeNull;
-  }
-
- private:
-  // The default function that propagates nullability for function call, which
-  // depends on FunctionNullMode.
-  void defaultNullabilityPropagation() {
-    for (auto& child : children()) {
-      child->propagateNullability();
-    }
-
-    switch (getNullMode()) {
-      case ExpressionNullMode::NullInNullOut:
-      case ExpressionNullMode::NullableInNullableOut:
-        for (auto& child : children()) {
-          if (child->maybeNull()) {
-            setMaybeNull(true);
-            return;
-          }
-        }
-      case ExpressionNullMode::NotNull:
-        setMaybeNull(false);
-        return;
-      case ExpressionNullMode::Custom:
-        throw CodegenNotSupported(
-            "Error in AST Design, propagateNullability must be overridden");
-    }
-  }
-
-  // Stores the type of the expression
-  std::shared_ptr<velox::Type> type_ = nullptr;
-
-  // Stores the nullability of the node
-  bool maybeNull_ = true;
-};
-
-/// Node represents input value reference (reference to value/col in the input
-/// row)
-class InputRefExpr final : public ASTNode {
- public:
-  InputRefExpr(const TypePtr& type, const std::string& name, size_t index)
-      : ASTNode(type), name_(name), index_(index) {}
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  const std::vector<ASTNodePtr> children() const override {
-    return {};
-  }
-
-  ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::Custom;
-  }
-
-  void propagateNullability() override {
-    // set in constructor
-  }
-
-  /// Set the nullability of the input
-  void setMaybeNull(bool maybeNull) {
-    ASTNode::setMaybeNull(maybeNull);
-  }
-
-  void validate() const override {
-    validateTyped();
-    if (index_ < 0) {
-      throw ASTValidationException(
-          "input reference expression expect a positive index");
-    }
-  }
-
-  /// Return the index of referenced column
-  size_t index() const {
-    return index_;
-  }
-  /// Return the column name
-  const std::string& name() const {
-    return name_;
-  }
-
- private:
-  /// Name of the referenced column
-  std::string name_;
-
-  // The index of referenced column
-  size_t index_;
-};
-
-// An expression that combines the children expressions into a row (tuple)
-class MakeRowExpression final : public ASTNode {
- public:
-  MakeRowExpression(
-      const TypePtr& type,
-      const std::vector<ASTNodePtr>& children)
-      : ASTNode(type), children_(children) {}
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  const std::vector<ASTNodePtr> children() const override {
-    return children_;
-  }
-
-  ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::NotNull;
-  }
-
-  void validate() const override {
-    validateTyped();
-    if (children_.size() == 0) {
-      throw ASTValidationException(
-          "output expression should have at least one child");
-    }
-    for (auto& child : children_) {
-      child->validate();
-    }
-  }
-
-  /// Return the size of the output tuple
-  size_t width() {
-    return children_.size();
-  }
-
- private:
-  /// The output expression, a child at index X write to output[X]
-  std::vector<ASTNodePtr> children_;
-};
-
-// If expression AST node
-class IfExpression final : public ASTNode {
- public:
-  IfExpression(
-      const TypePtr& type,
-      ASTNodePtr condition,
-      ASTNodePtr thenPart,
-      ASTNodePtr elsePart,
-      bool isEager = false)
-      : ASTNode(type),
-        condition_(condition),
-        thenPart_(thenPart),
-        elsePart_(elsePart),
-        isEager_(isEager) {}
-
-  IfExpression(
-      const TypePtr& type,
-      ASTNodePtr condition,
-      ASTNodePtr thenPart,
-      bool isEager = false)
-      : ASTNode(type),
-        condition_(condition),
-        thenPart_(thenPart),
-        elsePart_(nullptr),
-        isEager_(isEager) {}
-
-  void propagateNullability() override;
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  void validate() const override;
-
-  const std::vector<ASTNodePtr> children() const override {
-    return {condition_, thenPart_, elsePart_};
-  }
-
-  ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::Custom;
-  }
-
- private:
-  // AST node representing the condition
-  ASTNodePtr condition_;
-
-  // AST node representing then part
-  ASTNodePtr thenPart_;
-
-  // AST node representing else part
-  ASTNodePtr elsePart_;
-
-  // If isEager_ then and else always executed for side effects but only one
-  // value returned
-  bool isEager_;
-};
-
-// Switch expression AST node
-class SwitchExpression final : public ASTNode {
- public:
-  SwitchExpression(const TypePtr& type, std::vector<ASTNodePtr>& inputs)
-      : ASTNode(type), inputs_(inputs) {}
-
-  void propagateNullability() override;
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  void validate() const override;
-
-  const std::vector<ASTNodePtr> children() const override {
-    return inputs_;
-  }
-
-  ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::Custom;
-  }
-
- private:
-  // A sequence of WHEN ... THEN ... and maybe a trailing ELSE
-  std::vector<ASTNodePtr> inputs_;
-};
-
-/// AST node represent a general function call with no code-gen specific
-/// optimizations and handling.
-class UDFCallExpr final : public ASTNode {
- public:
-  UDFCallExpr(
-      const TypePtr& type,
-      const UDFInformation& udfInformation,
-      const std::vector<ASTNodePtr>& children)
-      : ASTNode(type), udfInformation_(udfInformation), children_(children) {
-    udfInformation.validate(false /*veloxNamesMustBeSet*/);
-  }
-
-  void validate() const override;
-
-  const std::vector<ASTNodePtr> children() const override {
-    return children_;
-  }
-
-  std::vector<std::string> getHeaderFiles() const override {
-    if (udfInformation_.hasHeaderFiles()) {
-      return udfInformation_.getHeaderFiles();
-    }
-    return {};
-  }
-
-  std::vector<compiler_utils::LibraryDescriptor> getLibs() const override {
-    if (udfInformation_.hasLibs()) {
-      return udfInformation_.getLibs();
-    }
-    return {};
-  }
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  ExpressionNullMode getNullMode() const override {
-    return udfInformation_.getNullMode();
-  }
-
-  bool isNullableOutput() const {
-    return udfInformation_.isOptionalOutput();
-  }
-
- protected:
-  // Return the function name used in the generated code
-  const std::string getFunctionName() const {
-    return udfInformation_.getCalledFunctionName();
-  }
-
- private:
-  // Information about the called udf are stored in this structure
-  const UDFInformation udfInformation_;
-
-  // Function call input arguments
-  std::vector<ASTNodePtr> children_;
-};
-
-class CoalesceExpr final : public ASTNode {
- public:
-  CoalesceExpr(const TypePtr& type, const std::vector<ASTNodePtr>& children)
-      : ASTNode(type), children_(children) {}
-
-  void validate() const override {
-    validateTyped();
-  }
-
-  const std::vector<ASTNodePtr> children() const override {
-    return children_;
-  }
-
-  void propagateNullability() override;
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  virtual ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::Custom;
-  }
-
- private:
-  std::vector<ASTNodePtr> children_;
-};
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/ast/BinaryExpressions.cpp b/velox/experimental/codegen/ast/BinaryExpressions.cpp
deleted file mode 100644
index 37d72bddaa074..0000000000000
--- a/velox/experimental/codegen/ast/BinaryExpressions.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/ast/BinaryExpressions.h"
-#include "velox/experimental/codegen/ast/CodegenUtils.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-// Presto reference semantics
-// Reference semantics https://prestodb.io/docs/current/functions/logical.html
-
-CodeSnippet LogicalAnd::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::stringstream code;
-
-  // Execute lhs
-  auto lhsResultVar = exprCodegenCtx.getUniqueTemp("lhsAnd");
-  code << codegenUtils::codegenTempVarDecl(lhs()->type(), lhsResultVar);
-  auto lhsCodeSnippet = lhs()->generateCode(exprCodegenCtx, lhsResultVar);
-
-  // Execute rhs
-  auto rhsResultVar = exprCodegenCtx.getUniqueTemp("rhsAnd");
-  code << codegenUtils::codegenTempVarDecl(rhs()->type(), rhsResultVar);
-  auto rhsCodeSnippet = rhs()->generateCode(exprCodegenCtx, rhsResultVar);
-
-  // Turn off dynamic check for nullability when we can
-  std::string rhsHasValue =
-      codegenUtils::codegenHasValueCheck(rhsResultVar, rhs()->maybeNull());
-  std::string lhsHasValue =
-      codegenUtils::codegenHasValueCheck(lhsResultVar, lhs()->maybeNull());
-
-  code << fmt::format(
-      "{lhsCode} {rhsCode}"
-      "" // Both true return true
-      "if({lhsHasValue} && *{lhs} && {rhsHasValue} && *{rhs}) {{"
-      "   {outVar} = true; "
-      "}}"
-      "" // Any false return false
-      "else if({lhsHasValue} && !*{lhs}) {{"
-      "   {outVar} = false;"
-      "}}"
-      ""
-      "else if({rhsHasValue} && !*{rhs}) {{"
-      "   {outVar} = false;"
-      "}}"
-      "" // Return null
-      "else {{"
-      "  {outVar} = std::nullopt;"
-      "}}",
-      fmt::arg("lhsCode", lhsCodeSnippet.code()),
-      fmt::arg("rhsCode", rhsCodeSnippet.code()),
-      fmt::arg("lhs", lhsResultVar),
-      fmt::arg("rhs", rhsResultVar),
-      fmt::arg("rhsHasValue", rhsHasValue),
-      fmt::arg("lhsHasValue", lhsHasValue),
-      fmt::arg("outVar", outputVarName));
-
-  return CodeSnippet(outputVarName, code.str());
-}
-
-CodeSnippet LogicalOr::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::stringstream code;
-  // Execute lhs
-  auto lhsResultVar = exprCodegenCtx.getUniqueTemp("lhsOr");
-  code << codegenUtils::codegenTempVarDecl(lhs()->type(), lhsResultVar);
-  auto lhsCodeSnippet = lhs()->generateCode(exprCodegenCtx, lhsResultVar);
-
-  // Execute rhs
-  auto rhsResultVar = exprCodegenCtx.getUniqueTemp("rhsOr");
-  code << codegenUtils::codegenTempVarDecl(rhs()->type(), rhsResultVar);
-  auto rhsCodeSnippet = rhs()->generateCode(exprCodegenCtx, rhsResultVar);
-
-  // Turn off dynamic check for nullability when we can
-  std::string rhsHasValue =
-      codegenUtils::codegenHasValueCheck(rhsResultVar, rhs()->maybeNull());
-  std::string lhsHasValue =
-      codegenUtils::codegenHasValueCheck(lhsResultVar, lhs()->maybeNull());
-
-  code << fmt::format(
-      "{lhsCode} {rhsCode}"
-      "" // Both false return false
-      "if({lhsHasValue} && !*{lhs} && {rhsHasValue} && !*{rhs}) {{"
-      "   {outVar} = false; "
-      "}}"
-      "" // Any true return true
-      "else if({lhsHasValue} && *{lhs}) {{"
-      "   {outVar} = true;"
-      "}}"
-      ""
-      "else if({rhsHasValue} && *{rhs}) {{"
-      "   {outVar} = true;"
-      "}}"
-      "" // Return null
-      "else {{"
-      "  {outVar} = std::nullopt;"
-      "}}",
-      fmt::arg("lhsCode", lhsCodeSnippet.code()),
-      fmt::arg("rhsCode", rhsCodeSnippet.code()),
-      fmt::arg("lhs", lhsResultVar),
-      fmt::arg("rhs", rhsResultVar),
-      fmt::arg("rhsHasValue", rhsHasValue),
-      fmt::arg("lhsHasValue", lhsHasValue),
-      fmt::arg("outVar", outputVarName));
-
-  return CodeSnippet(outputVarName, code.str());
-}
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/ast/BinaryExpressions.h b/velox/experimental/codegen/ast/BinaryExpressions.h
deleted file mode 100644
index 7507274211ce5..0000000000000
--- a/velox/experimental/codegen/ast/BinaryExpressions.h
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include "velox/experimental/codegen/ast/ASTNode.h"
-#include "velox/experimental/codegen/ast/CodegenUtils.h"
-
-namespace facebook::velox::codegen {
-
-/// Abstract class that represents binary expression.
-class BinaryExpr : public ASTNode {
- public:
-  BinaryExpr(const TypePtr& type, const ASTNodePtr& lhs, const ASTNodePtr& rhs)
-      : ASTNode(type), lhs_(lhs), rhs_(rhs) {}
-
-  ~BinaryExpr() override {}
-
-  virtual CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override = 0;
-
-  const std::vector<ASTNodePtr> children() const override {
-    return {lhs_, rhs_};
-  }
-
-  ASTNodePtr lhs() const {
-    return lhs_;
-  }
-
-  ASTNodePtr rhs() const {
-    return rhs_;
-  }
-
- private:
-  // LHS child expression
-  ASTNodePtr lhs_;
-
-  /// RHS child expression
-  ASTNodePtr rhs_;
-};
-
-/// A template class to used to implement SymbolBinaryExpr, templated on a
-/// binary symbol. Null mode is NullInNullOut for such expressions implemented
-/// using this class.
-template <const char* symbol>
-class SymbolBinaryExpr final : public BinaryExpr {
- public:
-  SymbolBinaryExpr(
-      const TypePtr& type,
-      const ASTNodePtr& lhs,
-      const ASTNodePtr& rhs)
-      : BinaryExpr(type, lhs, rhs) {}
-
- private:
-  // Default code generation for symbol binary expression
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::NullInNullOut;
-  }
-
-  void validate() const override {
-    if (getNullMode() != ExpressionNullMode::NullInNullOut) {
-      throw ASTValidationException(
-          "expecting NullInNullOut for default symbol binary expression, if getNullMode is overridden validate should be overridden as well");
-    }
-    validateTyped();
-  }
-};
-
-class LogicalAnd final : public BinaryExpr {
- public:
-  LogicalAnd(const ASTNodePtr& lhs, const ASTNodePtr& rhs)
-      : BinaryExpr(BOOLEAN(), lhs, rhs) {}
-
- private:
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputs) const override;
-
-  ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::NullableInNullableOut;
-  }
-
-  void validate() const override {
-    validateTyped();
-  }
-};
-
-class LogicalOr final : public BinaryExpr {
- public:
-  LogicalOr(const ASTNodePtr& lhs, const ASTNodePtr& rhs)
-      : BinaryExpr(BOOLEAN(), lhs, rhs) {}
-
- private:
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::NullableInNullableOut;
-  }
-
-  void validate() const override {
-    validateTyped();
-  }
-};
-
-// Default code generation for symbol binary expressions, it assumes null in
-// null out semantics
-template <const char* symbol>
-CodeSnippet SymbolBinaryExpr<symbol>::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::stringstream code;
-  auto lhsResultVar = exprCodegenCtx.getUniqueTemp("symbol_lhs_arg");
-  auto rhsResultVar = exprCodegenCtx.getUniqueTemp("symbol_rhs_arg");
-
-  // Execute lhs
-  code << codegenUtils::codegenTempVarDecl(lhs()->type(), lhsResultVar);
-  auto lhsCodeSnippet = lhs()->generateCode(exprCodegenCtx, lhsResultVar);
-  code << lhsCodeSnippet.code();
-
-  // Execute rhs
-  code << codegenUtils::codegenTempVarDecl(rhs()->type(), rhsResultVar);
-  auto rhsCodeSnippet = rhs()->generateCode(exprCodegenCtx, rhsResultVar);
-  code << rhsCodeSnippet.code();
-
-  auto assignmentRHS =
-      codegenUtils::codegenBinarySymbolCall(symbol, lhsResultVar, rhsResultVar);
-  auto evalWork = codegenUtils::codegenAssignment(outputVarName, assignmentRHS);
-
-  std::vector<std::string> nullableArgs;
-
-  if (lhs()->maybeNull()) {
-    nullableArgs.push_back(lhsResultVar);
-  }
-
-  if (rhs()->maybeNull()) {
-    nullableArgs.push_back(rhsResultVar);
-  }
-
-  code << codegenUtils::codegenNullInNullOut(
-      evalWork, nullableArgs, outputVarName);
-  return CodeSnippet(outputVarName, code.str());
-}
-
-const char kAddSymbol[] = "+";
-using AddExpr = SymbolBinaryExpr<kAddSymbol>;
-
-const char kSubtractSymbol[] = "-";
-using SubtractExpr = SymbolBinaryExpr<kSubtractSymbol>;
-
-const char kMultiplySymbol[] = "*";
-using MultiplyExpr = SymbolBinaryExpr<kMultiplySymbol>;
-
-const char kGreaterThantSymbol[] = ">";
-using GreaterThan = SymbolBinaryExpr<kGreaterThantSymbol>;
-
-const char kGreaterThanEqualSymbol[] = ">=";
-using GreaterThanEquel = SymbolBinaryExpr<kGreaterThanEqualSymbol>;
-
-const char kLessThantSymbol[] = "<";
-using LessThan = SymbolBinaryExpr<kLessThantSymbol>;
-
-const char kLessThanEqualSymbol[] = "<=";
-using LessThanEqual = SymbolBinaryExpr<kLessThanEqualSymbol>;
-
-const char kEqualSymbol[] = "==";
-using Equal = SymbolBinaryExpr<kEqualSymbol>;
-
-const char kNotEqualSymbol[] = "!=";
-using NotEqual = SymbolBinaryExpr<kNotEqualSymbol>;
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/ast/CMakeLists.txt b/velox/experimental/codegen/ast/CMakeLists.txt
deleted file mode 100644
index 3376a8039a3ed..0000000000000
--- a/velox/experimental/codegen/ast/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(
-  velox_codegen_ast ASTNode.cpp BinaryExpressions.cpp UnaryExpressions.cpp
-                    AST.h ConstantExpression.cpp ASTAnalysis.cpp)
-
-target_link_libraries(velox_codegen_ast velox_type fmt::fmt)
diff --git a/velox/experimental/codegen/ast/CodegenCtx.h b/velox/experimental/codegen/ast/CodegenCtx.h
deleted file mode 100644
index adc52b6cfdfdd..0000000000000
--- a/velox/experimental/codegen/ast/CodegenCtx.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <fmt/format.h>
-#include <map>
-#include <string>
-#include <unordered_set>
-#include <vector>
-#include "velox/experimental/codegen/compiler_utils/LibraryDescriptor.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::codegen {
-
-/// A context that holds global information needed during and after code
-/// generation.
-///
-/// TODO: Since we are now tracking inputs on a per expression basis,
-/// this class should probably not be store in the code generator.
-class CodegenCtx {
- public:
-  /// Return a temp variable name that is unique within the context
-  std::string getUniqueTemp(const std::string& prefix = "") {
-    return fmt::format("{}_tmp_{}", prefix, getUniqueId());
-  }
-
-  std::string getUniqueLambda() {
-    return fmt::format("lambda_{}", getUniqueId());
-  }
-
-  size_t getUniqueId() {
-    return nextId_++;
-  }
-
-  void addHeaderPath(const std::string& headerPath) {
-    headers_.insert(headerPath);
-  }
-
-  void addHeaderPaths(const std::vector<std::string>& headers) {
-    for (auto& header : headers) {
-      headers_.insert(header);
-    }
-  }
-
-  void addLib(const compiler_utils::LibraryDescriptor& lib) {
-    libs_.insert(lib);
-  }
-
-  void addLibs(const std::vector<compiler_utils::LibraryDescriptor>& libs) {
-    for (auto& lib : libs) {
-      addLib(lib);
-    }
-  }
-
-  std::set<compiler_utils::LibraryDescriptor> getLibs() const {
-    return libs_;
-  }
-
-  std::vector<compiler_utils::LibraryDescriptor> getLibsAsList() const {
-    return {libs_.begin(), libs_.end()};
-  }
-
-  const std::unordered_set<std::string>& headers() const {
-    return headers_;
-  }
-
-  std::map<std::string, std::pair<size_t, facebook::velox::TypePtr>>&
-  columnNameToIndexMap() {
-    return columnNameToIndexMap_;
-  }
-
-  bool computeInputTypeDuringCodegen() const {
-    return computeInputType_;
-  }
-
-  void setComputeInputTypeDuringCodegen(bool flag) {
-    computeInputType_ = flag;
-  }
-
-  size_t computeIndexForColumn(
-      const std::string& columnName,
-      const velox::TypePtr& type) {
-    if (auto indexIterator = columnNameToIndexMap().find(columnName);
-        indexIterator != columnNameToIndexMap().end()) {
-      return indexIterator->second.first;
-    }
-
-    // If this is the first time we encounter this column name, assign
-    // a new index value
-    auto nextIndex = columnNameToIndexMap().size();
-    columnNameToIndexMap()[columnName] = {nextIndex, type};
-    return nextIndex;
-  }
-
-  std::string addConstantStringDecl(const std::string& string) {
-    auto varName = fmt::format("string_constant_{}", getUniqueId());
-    constantDeclarations.push_back(fmt::format(
-        "const StringView {}= StringView(\"{}\")", varName, string));
-    return varName;
-  }
-
-  const std::vector<std::string>& declarations() const {
-    return constantDeclarations;
-  }
-
- private:
-  void addConstantDeclaration(const std::string& decl) {
-    constantDeclarations.push_back(decl);
-  }
-
-  /// A storage for constant declarations that will be added to the generated
-  /// expression structure as member
-  std::vector<std::string> constantDeclarations;
-
-  /// Counter that tracks unique ids and assign them to variables
-  size_t nextId_ = 0;
-  /// Header files required to execute the expressions generated
-  std::unordered_set<std::string> headers_ = {"<optional>"};
-
-  /// Libs required to execute the expressions generated
-  std::set<compiler_utils::LibraryDescriptor> libs_;
-
-  /// Mapping between InputRef names and index in the input tuple
-  /// [columnName -> {index,velox::type}
-  std::map<std::string, std::pair<size_t, facebook::velox::TypePtr>>
-      columnNameToIndexMap_;
-
-  /// Flag to decide how to compute the input indexes.
-  /// When true, we assign increasing index number to each column as we
-  /// discover them in the current expression
-  bool computeInputType_ = false;
-};
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/ast/CodegenUtils.h b/velox/experimental/codegen/ast/CodegenUtils.h
deleted file mode 100644
index 0d071be6fccc8..0000000000000
--- a/velox/experimental/codegen/ast/CodegenUtils.h
+++ /dev/null
@@ -1,319 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <exception>
-#include <memory>
-#include <optional>
-#include <sstream>
-#include <string>
-#include "velox/experimental/codegen/CodegenExceptions.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::codegen::codegenUtils {
-
-/// TODO: Why is this in an anon namespace
-namespace {
-
-enum TypePlacement { Input, Constant, Temp };
-
-inline std::string codegenFixedWidthNativeType(TypeKind kind) {
-  switch (kind) {
-    case TypeKind::BOOLEAN:
-      return "bool";
-    case TypeKind::TINYINT:
-      return "int8_t";
-    case TypeKind::SMALLINT:
-      return "int16_t";
-    case TypeKind::INTEGER:
-      return "int32_t";
-    case TypeKind::BIGINT:
-      return "int64_t";
-    case TypeKind::REAL:
-      return "float";
-    case TypeKind::DOUBLE:
-      return "double";
-    default:
-      VELOX_UNREACHABLE();
-  }
-}
-
-inline std::string codegenStringNullableNativeType(
-    TypePlacement typePlacement) {
-  if (typePlacement == TypePlacement::Input) {
-    return "facebook::velox::codegen::InputReferenceStringNullable";
-  }
-  if (typePlacement == TypePlacement::Constant) {
-    return "facebook::velox::codegen::ConstantStringNullable";
-  }
-  if (typePlacement == TypePlacement::Temp) {
-    return "facebook::velox::codegen::TempStringNullable<codegen::TempsAllocator>";
-  }
-  VELOX_UNREACHABLE();
-}
-
-/// Codegen the corresponding nullable native type
-inline std::string codegenNullableNativeType(
-    const velox::TypeKind& typeKind,
-    TypePlacement typePlacement) {
-  if (typeKind == TypeKind::VARCHAR) {
-    return codegenStringNullableNativeType(typePlacement);
-  }
-
-  // will throw if not supported
-  return fmt::format(
-      "std::optional<{}>", codegenFixedWidthNativeType(typeKind));
-}
-
-/// Codegen the corresponding nullable type
-inline std::string codegenNullableNativeType(
-    const velox::Type& type,
-    TypePlacement typePlacement) {
-  return codegenNullableNativeType(type.kind(), typePlacement);
-}
-
-/// Convert Type to implType (static types)
-inline std::string codegenImplTypeName(const velox::Type& type) {
-  switch (type.kind()) {
-    case TypeKind::BOOLEAN:
-    case TypeKind::TINYINT:
-    case TypeKind::SMALLINT:
-    case TypeKind::INTEGER:
-    case TypeKind::BIGINT:
-    case TypeKind::REAL:
-    case TypeKind::DOUBLE:
-    case TypeKind::VARCHAR:
-      return fmt::format("ScalarType<TypeKind::{}>", type.kindName());
-    case TypeKind::ROW: {
-      std::stringstream ss;
-      ss << "std::tuple<"
-         << ((type.size() > 0) ? codegenImplTypeName(*type.childAt(0).get())
-                               : "");
-      for (size_t index = 1; index < type.size(); ++index) {
-        ss << ", " << codegenImplTypeName(*type.childAt(index).get());
-      };
-      ss << ">";
-      return ss.str();
-    }
-    default:
-      throw CodegenNotSupported(fmt::format(
-          "ImplType of {} Kind not supported in code-gen", type.kindName()));
-  };
-};
-
-/// Convert Type to implType (static types) tuples
-inline std::string codegenImplTypeName(
-    const std::vector<std::reference_wrapper<const velox::Type>>& types) {
-  std::stringstream ss;
-  ss << "std::tuple<"
-     << (types.size() > 0 ? codegenImplTypeName(types[0]) : "");
-  for (size_t index = 1; index < types.size(); ++index) {
-    ss << ", " << codegenImplTypeName(types[index]);
-  };
-  ss << ">";
-  return ss.str();
-}
-
-/// Codegen the corresponding native type
-// TODO: change this to be controlled in a header i.e ret CodegenType<type,
-// mode>
-inline std::string codegenNativeType(
-    const velox::Type& type,
-    TypePlacement typePlacement) {
-  if (type.isFixedWidth()) {
-    return codegenFixedWidthNativeType(type.kind());
-  }
-
-  // ROW type
-  if (auto rowType = dynamic_cast<const velox::RowType*>(&type)) {
-    std::stringstream outputType;
-    outputType << "std::tuple<";
-    bool first = true;
-    for (auto child : rowType->children()) {
-      if (!first) {
-        outputType << ",";
-      }
-      first = false;
-      outputType << codegenNullableNativeType(*child.get(), typePlacement);
-    }
-    outputType << ">";
-    return outputType.str();
-  }
-
-  throw CodegenNotSupported(fmt::format(
-      "ImplType of {} Kind not supported in code-gen as not optional",
-      type.kindName()));
-}
-
-inline std::string codegenNativeType(
-    const std::vector<std::reference_wrapper<const velox::Type>>& types) {
-  std::stringstream ss;
-  ss << "std::tuple<"
-     << (types.size() > 0 ? codegenNativeType(types[0], TypePlacement::Input)
-                          : "");
-  for (size_t index = 1; index < types.size(); ++index) {
-    ss << ", " << codegenNativeType(types[index], TypePlacement::Input);
-  };
-  ss << ">";
-  return ss.str();
-}
-
-/// Codegen assignment
-template <typename T, typename B>
-std::string codegenAssignment(const T& lhs, const B& rhs) {
-  return fmt::format("{} = {};", lhs, rhs);
-}
-
-/// Codegen if statement
-inline std::string codegenIfStatement(
-    const std::string& condition,
-    const std::string& thenPart,
-    const std::string& elsePart = "") {
-  return fmt::format(
-      R""""(
-     if ({}) {{
-       {}
-     }} else{{
-       {}
-     }})"""",
-      condition,
-      thenPart,
-      elsePart);
-}
-
-/// Codegen a function call
-inline std::string codegenFunctionCall(
-    const std::string& functionName,
-    const std::vector<std::string>& args) {
-  std::stringstream argList;
-  for (int i = 0; i < args.size(); i++) {
-    argList << ((i == 0) ? "" : ",") << args[i];
-  }
-  return fmt::format("{}({})", functionName, argList.str());
-}
-
-/// Codegen a binary symbol operator application on optional arguments
-inline std::string codegenBinarySymbolCall(
-    const std::string& symbol,
-    const std::string& lhs,
-    const std::string& rhs) {
-  return fmt::format("*{} {} *{}", lhs, symbol, rhs);
-}
-
-/// Codegen a unary symbol operator application on optional argument
-inline std::string codegenUnarySymbolCall(
-    const std::string& symbol,
-    const std::string& child) {
-  return fmt::format("{} *{}", symbol, child);
-}
-
-/// Codegen code to access the value of the optional
-inline std::string codegenOptionalAccess(
-    const std::string& optionalVariableName) {
-  return fmt::format("(*{}) ", optionalVariableName);
-}
-
-/// Codegen code to check if optional has value
-inline std::string codegenOptionalValueCheck(
-    const std::string& optionalVariableName) {
-  return fmt::format("{}.has_value()", optionalVariableName);
-}
-
-inline std::string codegenHasValueCheck(
-    const std::string& variable,
-    bool maybeNull) {
-  return maybeNull ? fmt::format("{}.has_value()", variable) : "true";
-}
-
-/// Codegen code that execute workCodeSnippet if non of the nullableArgs is
-/// null, otherwise assigns outputVar to std::nullopt
-inline std::string codegenNullInNullOut(
-    const std::string& workCodeSnippet,
-    const std::vector<std::string>& nullableArgs,
-    const std::string& outputVar) {
-  if (nullableArgs.size() == 0) {
-    return workCodeSnippet;
-  }
-
-  std::stringstream ifCondition;
-  ifCondition << "true";
-  for (int i = 0; i < nullableArgs.size(); i++) {
-    ifCondition << " && " << codegenOptionalValueCheck(nullableArgs[i]);
-  }
-
-  return codegenUtils::codegenIfStatement(
-      ifCondition.str(),
-      workCodeSnippet,
-      codegenAssignment(outputVar, "std::nullopt"));
-}
-
-/// Codegen variable declaration, initialized by default constructor (For now)
-inline std::string codegenTempVarDecl(
-    const velox::Type& type,
-    const std::string& variableName) {
-  VELOX_CHECK(type.isPrimitiveType());
-
-  auto args = std::string("std::in_place") +
-      (type.isFixedWidth() ? "" : ", state.allocator");
-
-  return fmt::format(
-      "{0} {1} ({2});", // initialize optional
-      codegenUtils::codegenNullableNativeType(type, TypePlacement::Temp),
-      variableName,
-      args);
-}
-
-/// Codegen variable declaration with initial value
-inline std::string codegenVarDecl(
-    [[maybe_unused]] const velox::Type& type,
-    const std::string& variableName,
-    const std::string& initialValue,
-    bool constantVar = false) {
-  return fmt::format(
-      "{} {} {} = {};",
-      constantVar ? "const" : "",
-      "auto",
-      variableName,
-      initialValue);
-}
-
-/// Codegen variable declaration with initial value
-inline std::string codegenRefVarDecl(
-    [[maybe_unused]] const velox::Type& type,
-    const std::string& variableName,
-    const std::string& initialValue) {
-  return fmt::format("auto {} = {};", variableName, initialValue);
-}
-
-/// Codegen tuple access
-inline std::string codegenTupleAccess(
-    const std::string& variableName,
-    size_t index) {
-  return fmt::format("std::get<{}>({})", index, variableName);
-}
-
-/// Codegen code to write data, and size in output string writer
-inline std::string codegenStringWriteFromCharPtr(
-    const std::string& stringWriterVariable,
-    const std::string& charPtrVariable) {
-  return fmt::format(
-      "({0}).resize(strlen({1}));"
-      "std::memcpy(({0}).data(), {1}, strlen({1}));",
-      codegenOptionalAccess(stringWriterVariable),
-      charPtrVariable);
-}
-
-} // namespace
-} // namespace facebook::velox::codegen::codegenUtils
diff --git a/velox/experimental/codegen/ast/ConstantExpression.cpp b/velox/experimental/codegen/ast/ConstantExpression.cpp
deleted file mode 100644
index a6eda16c26728..0000000000000
--- a/velox/experimental/codegen/ast/ConstantExpression.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/ast/ConstantExpressions.h"
-namespace facebook::velox::codegen {
-
-template <>
-std::vector<std::string> ConstantExpression<std::string>::getHeaderFiles()
-    const {
-  return {"<cstring>"};
-}
-
-template <>
-CodeSnippet ConstantExpression<std::string>::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  exprCodegenCtx.addHeaderPaths(getHeaderFiles());
-
-  std::string code;
-  if (isNull()) {
-    code = codegenUtils::codegenAssignment(outputVarName, "std::nullopt");
-  } else {
-    // TODO: here constants strings are copied only when assigned to
-    // Reader::PointerType.
-    // An optimization for the future, is to allocate them on a buffer of the
-    // same type as the one used by Velox and then we wont have to recopy them
-    // per row!
-    auto constVariable = exprCodegenCtx.addConstantStringDecl(
-        codegenValue<std::string>(value_.value()));
-    auto rhs = fmt::format(
-        "{0} {{codegen::ConstantString{{{1}}} }}",
-        codegenUtils::codegenNullableNativeType(
-            TypeKind::VARCHAR, codegenUtils::TypePlacement::Constant),
-        constVariable);
-    code = codegenUtils::codegenAssignment(outputVarName, rhs);
-  }
-
-  return CodeSnippet(outputVarName, code);
-}
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/ast/ConstantExpressions.h b/velox/experimental/codegen/ast/ConstantExpressions.h
deleted file mode 100644
index 5806327f53ff3..0000000000000
--- a/velox/experimental/codegen/ast/ConstantExpressions.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <string>
-
-#include "velox/experimental/codegen/CodegenExceptions.h"
-#include "velox/experimental/codegen/ast/ASTNode.h"
-#include "velox/experimental/codegen/ast/CodegenUtils.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-namespace {
-// Interesting discussion
-// https://stackoverflow.com/questions/208433/how-do-i-write-a-short-literal-in-c
-// the compiler optimizes the static cast away and const fold it
-
-/// Converts a value to its code string representation
-/// Only this needed to be implemented to extend constant expression to a
-/// new type
-template <typename T>
-std::string codegenValue([[maybe_unused]] const T& value) {
-  throw CodegenNotSupported(
-      fmt::format("unsupported type {} for codegenValue", typeid(T).name()));
-}
-
-template <>
-inline std::string codegenValue<bool>(const bool& value) {
-  if (value) {
-    return "true";
-  } else {
-    return "false";
-  }
-}
-
-template <>
-inline std::string codegenValue<int8_t>(const int8_t& value) {
-  return fmt::format("static_cast<int8_t>({})", value);
-}
-
-template <>
-inline std::string codegenValue<int16_t>(const int16_t& value) {
-  return fmt::format("static_cast<int16_t>({})", value);
-}
-
-template <>
-inline std::string codegenValue<int32_t>(const int32_t& value) {
-  return fmt::format("static_cast<int32_t>({})", value);
-}
-
-template <>
-inline std::string codegenValue<int64_t>(const int64_t& value) {
-  return fmt::format("static_cast<int64_t>({})", value);
-}
-
-template <>
-inline std::string codegenValue<float>(const float& value) {
-  return fmt::format("static_cast<float>({})", value);
-}
-
-template <>
-inline std::string codegenValue<double>(const double& value) {
-  return fmt::format("static_cast<double>({})", value);
-}
-
-template <>
-inline std::string codegenValue<std::string>(const std::string& value) {
-  return value;
-}
-} // namespace
-
-/// Template class that used to implement constant expressions
-template <typename T>
-class ConstantExpression final : public ASTNode {
- public:
-  ConstantExpression(const TypePtr& type, const std::optional<T>& value)
-      : ASTNode(type), value_(value) {
-    setMaybeNull(isNull());
-  }
-
-  ~ConstantExpression() override {}
-
-  bool isConstantExpression() const override {
-    return true;
-  }
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override {
-    exprCodegenCtx.addHeaderPaths(getHeaderFiles());
-
-    auto constantValue =
-        isNull() ? "std::nullopt" : codegenValue<T>(value_.value());
-    auto code = codegenUtils::codegenAssignment(
-        codegenUtils::codegenOptionalAccess(outputVarName), constantValue);
-    return CodeSnippet(outputVarName, code);
-  }
-
-  const std::vector<ASTNodePtr> children() const override {
-    return {};
-  }
-
-  std::vector<std::string> getHeaderFiles() const override {
-    return {};
-  }
-
-  ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::Custom;
-  }
-
-  bool isNull() const {
-    return value_ == std::nullopt;
-  }
-
-  void propagateNullability() override {
-    if (isNull()) {
-      setMaybeNull(true);
-    } else {
-      setMaybeNull(false);
-    }
-  }
-
-  void validate() const override {
-    validateTyped();
-  }
-
- private:
-  /// Child expression
-  const std::optional<T> value_;
-}; // namespace codegen
-
-using Int8Literal = ConstantExpression<int8_t>;
-using Int16Literal = ConstantExpression<int16_t>;
-using Int32Literal = ConstantExpression<int32_t>;
-using Int64Literal = ConstantExpression<int64_t>;
-using Int32Literal = ConstantExpression<int32_t>;
-using Int32Literal = ConstantExpression<int32_t>;
-
-using FloatLiteral = ConstantExpression<float>;
-using DoubleLiteral = ConstantExpression<double>;
-
-using StringLiteral = ConstantExpression<std::string>;
-
-template <>
-std::vector<std::string> ConstantExpression<std::string>::getHeaderFiles()
-    const;
-
-template <>
-CodeSnippet ConstantExpression<std::string>::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const;
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/ast/UnaryExpressions.cpp b/velox/experimental/codegen/ast/UnaryExpressions.cpp
deleted file mode 100644
index b161482ea01d8..0000000000000
--- a/velox/experimental/codegen/ast/UnaryExpressions.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/ast/UnaryExpressions.h"
-#include "velox/experimental/codegen/ast/CodegenUtils.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-CodeSnippet IsNullExpr::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  /// FIXME: the below optimization is only correct if child expr has no side
-  /// effect Need to add a side effect detection property and fix the code
-  if (!child()->maybeNull()) {
-    /// here we don't need the code of its child because we can directly return
-    /// false, but we still need to traverse down so it sees all the input
-    /// variables, this matters because of filter default null since at runtime
-    /// it needs to enumerate all input and deselect null
-    auto childCodeSnippet =
-        child()->generateCode(exprCodegenCtx, "place_holder");
-    return CodeSnippet(
-        outputVarName, codegenUtils::codegenAssignment(outputVarName, "false"));
-  }
-
-  std::stringstream code;
-  auto inputVar = exprCodegenCtx.getUniqueTemp("input");
-  code << codegenUtils::codegenTempVarDecl(child()->type(), inputVar);
-  auto childCodeSnippet = child()->generateCode(exprCodegenCtx, inputVar);
-  code << childCodeSnippet.code();
-
-  std::string inputNotNull = fmt::format("{}.has_value()", inputVar);
-  code << codegenUtils::codegenAssignment(
-      outputVarName,
-      fmt::format(
-          "{inputNotNull}?false:true", fmt::arg("inputNotNull", inputNotNull)));
-
-  return CodeSnippet(outputVarName, code.str());
-}
-
-CodeSnippet NotExpr::generateCode(
-    CodegenCtx& exprCodegenCtx,
-    const std::string& outputVarName) const {
-  std::stringstream code;
-  auto inputVar = exprCodegenCtx.getUniqueTemp("input");
-  code << codegenUtils::codegenTempVarDecl(child()->type(), inputVar);
-  auto childCodeSnippet = child()->generateCode(exprCodegenCtx, inputVar);
-  code << childCodeSnippet.code();
-
-  std::string inputNotNull =
-      child()->maybeNull() ? fmt::format("{}.has_value()", inputVar) : "true";
-  std::string notInput = fmt::format("std::make_optional(!*{})", inputVar);
-
-  code << codegenUtils::codegenAssignment(
-      outputVarName,
-      fmt::format(
-          "{inputNotNull}?{notInput}:std::nullopt",
-          fmt::arg("inputNotNull", inputNotNull),
-          fmt::arg("notInput", notInput)));
-
-  return CodeSnippet(outputVarName, code.str());
-}
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/ast/UnaryExpressions.h b/velox/experimental/codegen/ast/UnaryExpressions.h
deleted file mode 100644
index 4cc1823a492b6..0000000000000
--- a/velox/experimental/codegen/ast/UnaryExpressions.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/common/base/Exceptions.h"
-#include "velox/experimental/codegen/ast/ASTNode.h"
-
-namespace facebook::velox::codegen {
-
-/// Abstract class that represents unary expression.
-class UnaryExpr : public ASTNode {
- public:
-  UnaryExpr(const TypePtr& type, const ASTNodePtr& child)
-      : ASTNode(type), child_(child) {}
-
-  ~UnaryExpr() override {}
-
-  virtual CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override = 0;
-
-  const std::vector<ASTNodePtr> children() const override {
-    return {child_};
-  }
-
-  ASTNodePtr child() const {
-    return child_;
-  }
-
- private:
-  /// Child expression
-  ASTNodePtr child_;
-};
-
-class IsNullExpr final : public UnaryExpr {
- public:
-  IsNullExpr(const TypePtr& type, const ASTNodePtr& child)
-      : UnaryExpr(type, child) {}
-
-  void validate() const override {
-    validateTyped();
-  }
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  virtual ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::NotNull;
-  }
-};
-
-class NotExpr final : public UnaryExpr {
- public:
-  NotExpr(const TypePtr& type, const ASTNodePtr& child)
-      : UnaryExpr(type, child) {}
-
-  void validate() const override {
-    validateTyped();
-  }
-
-  CodeSnippet generateCode(
-      CodegenCtx& exprCodegenCtx,
-      const std::string& outputVarName) const override;
-
-  virtual ExpressionNullMode getNullMode() const override {
-    return ExpressionNullMode::NullInNullOut;
-  }
-};
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/benchmark/BooleanBenchmarks.cpp b/velox/experimental/codegen/benchmark/BooleanBenchmarks.cpp
deleted file mode 100644
index 7835e88bebc21..0000000000000
--- a/velox/experimental/codegen/benchmark/BooleanBenchmarks.cpp
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/benchmark/CodegenBenchmark.h"
-using namespace facebook::velox;
-using namespace facebook::velox::codegen;
-namespace {
-class BooleanBenchmark : public BenchmarkGTest {
- public:
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d", "e"},
-          std::vector<TypePtr>{
-              BOOLEAN(),
-              BOOLEAN(),
-              BOOLEAN(),
-              DOUBLE(),
-              DOUBLE()});
-};
-} // namespace
-
-// computeDepth5_10x100000_compiled 166.12%    16.59ns   60.27M
-// computeDepth5_10x100000_vectorFunc 172.54%    15.97ns   62.60M
-// computeDepth5_10x100000_compileTime 0.26%    10.66us   93.85K
-// computeDepth5_100x10000_reference                           21.38ns   46.77M
-// computeDepth5_100x10000_compiled 190.56%    11.22ns   89.13M
-// computeDepth5_100x10000_vectorFunc               238.95%     8.95n    119.04K
-//============================================================================
-TEST_F(BooleanBenchmark, DISABLED_singleAnd) {
-  CodegenBenchmark benchmark;
-
-  benchmark.benchmarkExpressionsMult<BooleanType>(
-      "singleAnd", {"a and b"}, inputRowType, typicalBatches, true);
-
-  folly::runBenchmarks();
-  benchmark.compareResults();
-}
-
-// ifSingleAnd_1000x1000_reference                             25.68ns   38.94M
-// ifSingleAnd_1000x1000_compiled                   164.73%    15.59ns   64.15M
-// ifSingleAnd_1000x1000_vectorFunc                 754.81%     3.40ns  293.96M
-// ifSingleAnd_100x10000_reference                             23.47ns   42.60M
-// ifSingleAnd_100x10000_compiled                   220.57%    10.64ns   93.96M
-// ifSingleAnd_100x10000_vectorFunc                 317.58%     7.39ns  135.29M
-//============================================================================
-TEST_F(BooleanBenchmark, DISABLED_ifSingleAnd) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "d", "e"},
-          std::vector<TypePtr>{BOOLEAN(), BOOLEAN(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "ifSingleAnd",
-      {"if(a and b, 1.1, 1.2)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// andOrAnd_100x10000_reference                                51.02ns   19.60M
-// andOrAnd_100x10000_compiled                      215.86%    23.64ns   42.31M
-// andOrAnd_100x10000_vectorFunc                    246.50%    20.70ns   48.31M
-// andOrAnd_1000x1000_reference                                56.85ns   17.59M
-// andOrAnd_1000x1000_compiled                      293.00%    19.40ns   51.54M
-// andOrAnd_1000x1000_vectorFunc                    756.52%     7.51ns  133.07M
-//============================================================================
-TEST_F(BooleanBenchmark, DISABLED_andOrAnd) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BOOLEAN(), BOOLEAN(), BOOLEAN(), BOOLEAN()});
-
-  benchmark.benchmarkExpressionsMult<BooleanType>(
-      "andOrAnd", {"a and b or c and d"}, inputRowType, typicalBatches, true);
-}
-
-// nestedIfTwoLevel_1000x1000_reference                        46.90ns   21.32M
-// nestedIfTwoLevel_1000x1000_compiled              245.76%    19.08ns   52.40M
-// nestedIfTwoLevel_1000x1000_vectorFunc            788.00%     5.95ns  168.02M
-// nestedIfTwoLevel_100x10000_reference                        44.47ns   22.49M
-// nestedIfTwoLevel_100x10000_compiled              173.31%    25.66ns   38.97M
-// nestedIfTwoLevel_100x10000_vectorFunc            259.96%    17.11ns   58.46M
-//============================================================================
-TEST_F(BooleanBenchmark, DISABLED_nestedIfTwoLevel) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BOOLEAN(), BOOLEAN(), BOOLEAN(), BOOLEAN()});
-
-  benchmark.benchmarkExpressionsMult<BooleanType>(
-      "nestedIfTwoLevel",
-      {"if(a and b, if(c and d,1,2), if(c or d,3,4))"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// gt_100x10000_reference                        12.35ns   80.99M
-// gt_100x10000_compiled              157.45%     7.84ns  127.52M
-// gt_100x10000_vectorFunc            222.92%     5.54ns  180.54M
-// gt_1000x1000_reference                        19.69ns   50.79M
-// gt_1000x1000_compiled              127.68%    15.42ns   64.85M
-// gt_1000x1000_vectorFunc            605.84%     3.25ns  307.69M
-TEST_F(BooleanBenchmark, DISABLED_gt) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BooleanType>(
-      "gt", {"a>b"}, inputRowType, typicalBatches, true);
-}
-
-// gt_and_gt_1000x1000_reference                               43.57ns   22.95M
-// gt_and_gt_1000x1000_compiled                     236.43%    18.43ns   54.26M
-// gt_and_gt_1000x1000_vectorFunc                   725.26%     6.01ns  166.45M
-// gt_and_gt_100x10000_reference                               41.66ns   24.00M
-// gt_and_gt_100x10000_compiled                     240.07%    17.35ns   57.62M
-// gt_and_gt_100x10000_vectorFunc                   318.82%    13.07ns   76.53M
-//============================================================================
-TEST_F(BooleanBenchmark, DISABLED_gt_and_gt) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BooleanType>(
-      "gt_and_gt", {"a>b and c >d"}, inputRowType, typicalBatches, true);
-}
-
-// Awesome speedup1
-// gt_and_gt_100x10000_reference                               92.06ns   10.86M
-// gt_and_gt_100x10000_compiled                     462.31%    19.91ns   50.22M
-// gt_and_gt_100x10000_vectorFunc                   583.30%    15.78ns   63.36M
-// gt_and_gt_1000x1000_reference                              104.90ns    9.53M
-// gt_and_gt_1000x1000_compiled                     503.32%    20.84ns   47.98M
-// gt_and_gt_1000x1000_vectorFunc                  1424.11%     7.37ns  135.76M
-TEST_F(BooleanBenchmark, DISABLED_gt_and_gt_or_gt_gt) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BooleanType>(
-      "gt_and_gt_or_gt_gt",
-      {"(a>b and c >d) or (a<b and c <d) "},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// Very interesting case where codegen is very worse
-// basically when the if condition is a constant bool
-// nestedIfThreeLevelCodegenWorse_100x10000_refere              4.83ns  206.99M
-// nestedIfThreeLevelCodegenWorse_100x10000_compil   23.51%    20.55ns   48.65M
-// nestedIfThreeLevelCodegenWorse_100x10000_vector   28.88%    16.73ns   59.77M
-// nestedIfThreeLevelCodegenWorse_100x10000_compil    0.09%     5.32us  188.01K
-// nestedIfThreeLevelCodegenWorse_1000x1000_refere             16.90ns   59.17M
-// nestedIfThreeLevelCodegenWorse_1000x1000_compil   86.42%    19.56ns   51.14M
-// nestedIfThreeLevelCodegenWorse_1000x1000_vector  253.37%     6.67ns  149.91M
-TEST_F(BooleanBenchmark, DISABLED_nestedIfThreeLevelCodegenWorse) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BOOLEAN(), BOOLEAN(), BOOLEAN(), BOOLEAN()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "nestedIfThreeLevelCodegenWorse",
-      {"if(a, if(b, if(c, 1, 2), if(d, 4, 5)), if(b, if(c, 6, 7), if(d, 8,9)))"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// codegenWorseSimple_100x10000_reference                       3.55ns  281.92M
-// codegenWorseSimple_100x10000_compiled             54.55%     6.50ns  153.79M
-// codegenWorseSimple_100x10000_vectorFunc          238.30%     1.49ns  671.83M
-// codegenWorseSimple_1000x1000_reference                      13.23ns   75.60M
-// codegenWorseSimple_1000x1000_compiled             90.25%    14.66ns   68.24M
-// codegenWorseSimple_1000x1000_vectorFunc           530.57%     2.49ns 401.13M
-//============================================================================
-TEST_F(BooleanBenchmark, DISABLED_codegenWorseSimple) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BOOLEAN(), BOOLEAN(), BOOLEAN(), BOOLEAN()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "codegenWorseSimple",
-      {"if(a, 1, 2)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// Introducing computation in the condition make it fine
-//============================================================================
-//
-// codegenWorseVariant1_100x10000_reference 22.34ns 44.76M
-// codegenWorseVariant1_100x10000_compiled 210.03%    10.64ns   94.02M
-// codegenWorseVariant1_100x10000_vectorFunc        296.61%     7.53ns   132.77M
-// codegenWorseVariant1_1000x1000_reference 26.07ns 38.35M
-// codegenWorseVariant1_1000x1000_compiled 170.71%    15.27ns   65.47M
-// codegenWorseVariant1_1000x1000_vectorFunc        784.61%     3.32ns   300.91M
-TEST_F(BooleanBenchmark, DISABLED_codegenWorseVariant1) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BOOLEAN(), BOOLEAN(), BOOLEAN(), BOOLEAN()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "codegenWorseVariant1",
-      {"if(a or b, 1, 2)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// Introducing computation in branches does not make codegen better
-//============================================================================
-// codegenWorseVariant2_100x10000_reference                     9.00ns   111.11M
-// codegenWorseVariant2_100x10000_compiled 61.61 %           m 14.61ns    68.45M
-// codegenWorseVariant2_100x10000_vectorFunc         98.30%     9.16ns   109.22M
-// codegenWorseVariant2_1000x1000_reference 23.35ns 42.82M
-// codegenWorseVariant2_1000x1000_compiled 129.37%    18.05ns   55.40M
-// codegenWorseVariant2_1000x1000_vectorFunc        540.04%     4.32ns   231.27M
-//============================================================================
-TEST_F(BooleanBenchmark, DISABLED_codegenWorseVariant2) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "c", "d"}, std::vector<TypePtr>{BOOLEAN(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "codegenWorseVariant2",
-      {"if(a, c+1, d+2)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// mix_100x10000_reference              55.62ns 17.98M
-// mix_100x10000_compiled    225.47%    24.67ns   40.54M
-// mix_100x10000_vectorFunc  263.39%    21.12ns   47.36M
-// mix_1000x1000_reference               64.53ns 15.50M
-// mix_1000x1000_compiled    215.35%    29.97ns   33.37M
-// mix_1000x1000_vectorFunc  364.60%    17.70ns   56.50M
-//============================================================================
-TEST_F(BooleanBenchmark, DISABLED_mix) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c"}, std::vector<TypePtr>{DOUBLE(), DOUBLE(), BOOLEAN()});
-
-  benchmark.benchmarkExpressionsMult<BooleanType>(
-      "mix",
-      {"c or round(a,cast(1 as int))==round(b, cast (2 as int))"},
-
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// TODO we should do better for such deep expression
-// mix2_100x10000_reference 84.87ns 11.78M
-// mix2_100x10000_compiled   289.58%    29.31ns   34.12M
-// mix2_100x10000_vectorFunc 346.25%    24.51ns   40.80M
-// mix2_1000x1000_reference             93.99ns 10.64M
-// mix2_1000x1000_compiled   316.56%    29.69ns   33.68M
-// mix2_1000x1000_vectorFunc 585.03%    16.07ns   62.24M
-TEST_F(BooleanBenchmark, DISABLED_mix2) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), BOOLEAN(), BOOLEAN()});
-
-  benchmark.benchmarkExpressionsMult<BooleanType>(
-      "mix2",
-      {"(d and c) or round(a, cast (5 as int))==round(b,cast (4 as int))"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
diff --git a/velox/experimental/codegen/benchmark/CMakeLists.txt b/velox/experimental/codegen/benchmark/CMakeLists.txt
deleted file mode 100644
index 8541b47383ba5..0000000000000
--- a/velox/experimental/codegen/benchmark/CMakeLists.txt
+++ /dev/null
@@ -1,104 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_executable(
-  velox_codegen_benchmark_single_output
-  SingleOutputDefaultNullsBenchmark.cpp
-  SingleOutputNotDefaultNullsBenchmark.cpp BooleanBenchmarks.cpp)
-
-target_link_libraries(
-  velox_codegen_benchmark_single_output
-  velox_exec_test_lib
-  velox_codegen_utils_resource_path
-  velox_codegen_code_generator
-  velox_hive_connector
-  ${FOLLY_BENCHMARK}
-  Folly::folly
-  Boost::filesystem
-  gtest
-  gtest_main
-  gflags::gflags
-  fmt::fmt
-  velox_core
-  velox_exec
-  velox_exec_test_lib
-  velox_functions_lib
-  velox_functions_prestosql
-  velox_dwio_common_test_utils)
-
-add_test(velox_codegen_benchmark_single_output
-         velox_codegen_benchmark_single_output)
-
-add_executable(velox_codegen_benchmark CodegenBenchmarks.cpp)
-target_link_libraries(velox_codegen_benchmark velox_hive_connector)
-
-add_compile_definitions(velox_codegen_test BASEFOLDER="${PROJECT_SOURCE_DIR}")
-add_compile_definitions(velox_codegen_test COMPFLAGS="${CMAKE_CXX_FLAGS}")
-add_compile_definitions(velox_codegen_test MYFOLLY="gflags::gflags")
-
-# find a better way to do this
-add_compile_definitions(velox_codegen_test
-                        VELOX_CORE="$<TARGET_LINKER_FILE:velox_core>")
-add_compile_definitions(
-  velox_codegen_test
-  CODEGEN="$<TARGET_LINKER_FILE:velox_codegen_code_generator>")
-
-add_compile_definitions(
-  velox_codegen_test
-  VELOX_FUNCTIONS_LIB="$<TARGET_LINKER_FILE:velox_functions_lib>")
-add_compile_definitions(velox_codegen_test
-                        CODEGEN_AST="$<TARGET_LINKER_FILE:velox_codegen_ast>")
-add_compile_definitions(velox_codegen_test
-                        VELOX_EXEC="$<TARGET_LINKER_FILE:velox_exec>")
-add_compile_definitions(velox_codegen_test
-                        VELOX_VECTOR="$<TARGET_LINKER_FILE:velox_vector>")
-add_compile_definitions(velox_codegen_test
-                        VELOX_TYPE="$<TARGET_LINKER_FILE:velox_type>")
-add_compile_definitions(velox_codegen_test
-                        CODEGEN_AST="$<TARGET_LINKER_FILE:velox_codegen_ast>")
-add_compile_definitions(velox_codegen_test
-                        VELOX_EXCEPTION="$<TARGET_LINKER_FILE:velox_exception>")
-add_compile_definitions(
-  velox_codegen_test
-  VELOX_SERIALIZATION="$<TARGET_LINKER_FILE:velox_serialization>")
-add_compile_definitions(velox_codegen_test
-                        VELOX_PROCESS="$<TARGET_LINKER_FILE:velox_process>")
-add_compile_definitions(velox_codegen_test
-                        VELOX_MEMORY="$<TARGET_LINKER_FILE:velox_memory>")
-add_compile_definitions(velox_codegen_test
-                        VELOX_ENCODE="$<TARGET_LINKER_FILE:velox_encode>")
-add_compile_definitions(velox_codegen_test
-                        VELOX_CACHING="$<TARGET_LINKER_FILE:velox_caching>")
-
-add_compile_definitions(velox_codegen_test GFLAGS_LI="${GFLAGS_INCLUDES}")
-
-target_link_libraries(
-  velox_codegen_benchmark
-  velox_exec_test_lib
-  velox_codegen_code_generator
-  ${FOLLY_BENCHMARK}
-  Folly::folly
-  Boost::filesystem
-  gtest
-  gtest_main
-  gflags::gflags
-  glog::glog
-  fmt::fmt
-  velox_core
-  velox_exec
-  velox_codegen_utils_resource_path
-  velox_exec_test_lib
-  velox_functions_lib
-  velox_functions_prestosql
-  velox_dwio_common_test_utils)
diff --git a/velox/experimental/codegen/benchmark/CodegenBenchmark.h b/velox/experimental/codegen/benchmark/CodegenBenchmark.h
deleted file mode 100644
index 745201246fc32..0000000000000
--- a/velox/experimental/codegen/benchmark/CodegenBenchmark.h
+++ /dev/null
@@ -1,608 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <folly/Benchmark.h>
-#include <folly/init/Init.h>
-
-#include <algorithm>
-#include "velox/common/base/Exceptions.h"
-#include "velox/exec/OperatorUtils.h"
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/benchmark/ValueNodeReplacer.h"
-#include "velox/experimental/codegen/tests/CodegenTestBase.h"
-
-namespace facebook::velox::codegen {
-
-// Benchmark utility class
-class CodegenBenchmark : public CodegenTestCore {
- public:
-  bool enableVectorFunctionCompare = false;
-
-  /// Since the class CodegenBenchmark  manage the creation and registration of
-  /// benchmarks we need to make sure that the planNode and other required
-  /// objects are still "live" when runbenchmark(). So we use BenchmarkInfo to
-  /// store all those objects, and pass references down to each lambda.
-  struct BenchmarkInfo {
-    std::string name;
-    std::string filterExpr; // ""(empty string) -> no filter
-    std::vector<std::string> projectionExprs;
-    std::shared_ptr<const RowType> inputRowType;
-    TransformFlags transformFlags = defaultFlags;
-
-    std::vector<RowVectorPtr> inputVector;
-
-    // reference run
-    std::shared_ptr<const core::PlanNode> refPlanNodes;
-    std::unique_ptr<TaskCursor> referenceTaskCursors;
-    std::vector<RowVectorPtr> referenceResults;
-
-    // compiled run
-    std::shared_ptr<const core::PlanNode> compiledPlanNodes;
-    std::unique_ptr<TaskCursor> compiledTaskCursors;
-    std::vector<RowVectorPtr> compiledResults;
-
-    // generated function run
-    std::unique_ptr<GeneratedVectorFunctionBase> filterFunc = nullptr;
-    std::unique_ptr<GeneratedVectorFunctionBase> projectionFunc;
-    std::vector<RowVectorPtr> generatedFunctionResults;
-
-    std::map<std::string, size_t> argNameToIndex;
-
-    void clearStringEncoding() {
-      for (auto& rowVector : inputVector) {
-        for (auto& columns : rowVector->children()) {
-          if (auto stringVector = columns->asFlatVector<StringView>()) {
-            stringVector->invalidateIsAscii();
-          }
-        }
-      }
-    }
-
-    /// Given a compiled plan node, this method extracts the IcompiledCall
-    /// inside it and assign benchmarkinfo's fields
-    /// @param plan
-    auto setGeneratedFunctionFromProjection(const core::ProjectNode& plan) {
-      auto getCompiledExpression =
-          [](const std::shared_ptr<const core::ITypedExpr>& typedExpr) {
-            if (auto fieldReference =
-                    std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-                        typedExpr);
-                fieldReference != nullptr) {
-              return std::dynamic_pointer_cast<const ICompiledCall>(
-                  fieldReference->inputs()[0]);
-            };
-            return std::shared_ptr<const ICompiledCall>{};
-          };
-
-      if (!filterExpr.empty() && transformFlags.compileFilter &&
-          !transformFlags.mergeFilter) {
-        // has filter, and is compiled separately
-        filterFunc = getCompiledExpression(
-                         std::dynamic_pointer_cast<const core::FilterNode>(
-                             plan.sources()[0])
-                             ->filter())
-                         ->newInstance();
-        filterFunc->setRowType(
-            ROW({"selected"}, std::vector<TypePtr>{BOOLEAN()}));
-      }
-
-      std::set<std::shared_ptr<const ICompiledCall>> compiledCalls;
-      std::transform(
-          plan.projections().begin(),
-          plan.projections().end(),
-          std::inserter(compiledCalls, compiledCalls.begin()),
-          getCompiledExpression);
-
-      VELOX_CHECK(
-          compiledCalls.size() == 1 && (*compiledCalls.begin()) != nullptr);
-
-      auto compiledCall = (*compiledCalls.begin());
-      projectionFunc = compiledCall->newInstance();
-      projectionFunc->setRowType(refPlanNodes->outputType());
-      auto i = 0;
-      for (auto& child : compiledCall->inputs()) {
-        argNameToIndex
-            [std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(child)
-                 ->name()] = i++;
-      }
-    }
-  };
-
-  CodegenBenchmark() {
-    CodegenTestCore::init();
-    queryCtx = std::make_shared<core::QueryCtx>();
-    pool = memory::addDefaultLeafMemoryPool();
-    execCtx = std::make_unique<core::ExecCtx>(pool.get(), queryCtx_.get());
-  }
-
-  std::vector<BenchmarkInfo> templateBenchmarkInfo;
-  std::shared_ptr<core::QueryCtx> queryCtx;
-  std::shared_ptr<memory::MemoryPool> pool;
-  std::unique_ptr<core::ExecCtx> execCtx;
-  std::vector<BenchmarkInfo> benchmarkInfos;
-  bool reusePlanNode = true;
-
-  auto findTemplateBenchmarkInfo(
-      const std::string& benchmarkName,
-      const std::string& filterExpr,
-      const std::vector<std::string>& projectionExprs,
-      const std::shared_ptr<const RowType>& inputRowType,
-      const TransformFlags& flags) {
-    for (auto iterator = templateBenchmarkInfo.begin();
-         iterator != templateBenchmarkInfo.end();
-         ++iterator) {
-      if (benchmarkName == iterator->name and
-          filterExpr == iterator->filterExpr and
-          projectionExprs == iterator->projectionExprs and
-          (*inputRowType) == (*iterator->inputRowType) and
-          flags.flagVal == iterator->transformFlags.flagVal) {
-        return iterator;
-      }
-    }
-    return templateBenchmarkInfo.end();
-  }
-  /// Create a new BenchmarkInfo object in append in to the list of
-  /// benchmarks
-  /// \tparam SQLType return types
-  /// \param benchmarkName
-  /// \param exprString
-  /// \param inputRowType
-  /// \param testBatches
-  /// \param rowPerBatch
-  /// \return index position inside benchmarkInfos
-  template <typename... SQLType>
-  auto prepareBenchmarkInfo(
-      const std::string& benchmarkName,
-      const std::string& filterExpr,
-      const std::vector<std::string>& projectionExprs,
-      const std::shared_ptr<const RowType>& inputRowType,
-      size_t batchCount,
-      size_t rowPerBatch,
-      const TransformFlags& flags) {
-    benchmarkInfos.push_back({});
-    auto benchmarkIndex = benchmarkInfos.size() - 1;
-    auto& newBenchmarkInfo = benchmarkInfos.back();
-
-    newBenchmarkInfo.name = benchmarkName;
-
-    // Creating the test plan
-    // create by default 10% nulls
-    auto inputVectors = createRowVector(
-        batchCount, rowPerBatch, inputRowType, [](vector_size_t index) {
-          return index % 10;
-        });
-
-    newBenchmarkInfo.inputVector = inputVectors;
-
-    auto templateBenchmark = findTemplateBenchmarkInfo(
-        benchmarkName, filterExpr, projectionExprs, inputRowType, flags);
-    if (!reusePlanNode or (templateBenchmark == templateBenchmarkInfo.end())) {
-      // First time we see this benchmark, regular path
-      newBenchmarkInfo.refPlanNodes = createPlanNodeFromExpr<SQLType...>(
-          filterExpr, projectionExprs, inputVectors);
-      codegenTransformation_->setTransformFlags(flags);
-      newBenchmarkInfo.compiledPlanNodes = codegenTransformation_->transform(
-          *benchmarkInfos.back().refPlanNodes);
-
-      templateBenchmarkInfo.push_back({});
-
-      templateBenchmarkInfo.back().name = benchmarkName;
-      templateBenchmarkInfo.back().filterExpr = filterExpr;
-      templateBenchmarkInfo.back().projectionExprs = projectionExprs;
-      templateBenchmarkInfo.back().inputRowType = inputRowType;
-      templateBenchmarkInfo.back().transformFlags = flags;
-
-      templateBenchmarkInfo.back().refPlanNodes = newBenchmarkInfo.refPlanNodes;
-      templateBenchmarkInfo.back().compiledPlanNodes =
-          newBenchmarkInfo.compiledPlanNodes;
-
-    } else {
-      VELOX_CHECK(templateBenchmark->refPlanNodes != nullptr);
-      VELOX_CHECK(templateBenchmark->compiledPlanNodes != nullptr);
-      ValueNodeReplacerTransform valueNodeReplacer(inputVectors);
-      newBenchmarkInfo.refPlanNodes =
-          valueNodeReplacer.transform(*templateBenchmark->refPlanNodes);
-      newBenchmarkInfo.compiledPlanNodes =
-          valueNodeReplacer.transform(*templateBenchmark->compiledPlanNodes);
-    }
-
-    newBenchmarkInfo.filterExpr = filterExpr;
-    // running directly the vector function
-    newBenchmarkInfo.setGeneratedFunctionFromProjection(
-        *std::dynamic_pointer_cast<const core::ProjectNode>(
-            newBenchmarkInfo.compiledPlanNodes));
-
-    return benchmarkIndex;
-  }
-
-  /// Returns a tuple of executable lambda functions for benchmarking,
-  /// those function can  be registered and run  separately.
-  /// @tparam SQLType
-  /// @param benchmarkName
-  /// @param exprString
-  /// @param inputRowType
-  /// @param testBatches
-  /// @param rowPerBatch
-  /// @param flags
-  /// @param rowPerBatch when true, the benchmark marker are normalized by  the
-  /// nomber of row
-  /// @return a pair of lambda functions
-
-  template <typename... SQLType>
-  auto createBenchmarkLambda(
-      const std::string& benchmarkName,
-      const std::string& filterExpr,
-      const std::vector<std::string>& projectionExprs,
-      const std::shared_ptr<const RowType>& inputRowType,
-      size_t batchCount,
-      size_t rowPerBatch,
-      const TransformFlags& flags,
-      bool perRowNumber) {
-    auto benchmarkIndex = prepareBenchmarkInfo<SQLType...>(
-        benchmarkName,
-        filterExpr,
-        projectionExprs,
-        inputRowType,
-        batchCount,
-        rowPerBatch,
-        flags);
-
-    auto numberIteration = perRowNumber ? rowPerBatch * batchCount : 1;
-
-    // reference run
-    auto referenceLambda = [ this, benchmarkIndex, numberIteration ]() -> auto {
-      BenchmarkInfo& info = this->benchmarkInfos[benchmarkIndex];
-      info.referenceResults.clear();
-      info.clearStringEncoding();
-      info.referenceResults = runQuery(
-          info.refPlanNodes,
-          this->benchmarkInfos[benchmarkIndex].referenceTaskCursors);
-      return numberIteration;
-    };
-
-    // codegen'd run
-    auto compiledLambda = [ this, benchmarkIndex, numberIteration ]() -> auto {
-      BenchmarkInfo& info = this->benchmarkInfos[benchmarkIndex];
-      info.compiledResults.clear();
-      info.compiledResults =
-          runQuery(info.compiledPlanNodes, info.compiledTaskCursors);
-      return numberIteration;
-    };
-
-    // running thee naked ICompiledCall class
-    auto generatedFunctionLambda =
-        [ this, benchmarkIndex, numberIteration, inputRowType ]() -> auto {
-      // We are including in the benchmark both the allocation of results
-      // and the selectivity vector building and setting. It's not clear
-      // that this is the right thing to do. Maybe we should move row to
-      // BenchmarkInfo
-
-      BenchmarkInfo& info = this->benchmarkInfos[benchmarkIndex];
-      info.clearStringEncoding();
-      SelectivityVector rows(info.inputVector[0]->size(), true);
-      info.generatedFunctionResults.clear();
-      auto evalBatch =
-          [this, &rows, &info, inputRowType](RowVectorPtr& batch) -> VectorPtr {
-        // Put the arguments in the correct expected order
-        std::vector<VectorPtr> arguments;
-        arguments.resize(info.argNameToIndex.size());
-
-        for (auto i = 0; i < inputRowType->size(); i++) {
-          if (!info.argNameToIndex.count(inputRowType->nameOf(i))) {
-            continue;
-          }
-
-          arguments[info.argNameToIndex[inputRowType->nameOf(i)]] =
-              batch.get()->children()[i];
-        };
-        auto context = exec::EvalCtx(execCtx_.get(), nullptr, batch.get());
-        VectorPtr batchResult;
-        if (info.filterFunc == nullptr) {
-          // no filter
-          dynamic_cast<facebook::velox::exec::VectorFunction*>(
-              info.projectionFunc.get())
-              ->apply(
-                  rows,
-                  arguments, // See D27826068
-                  // batch.get()->children(),
-                  nullptr,
-                  context,
-                  batchResult);
-          return batchResult;
-        }
-
-        // has separately compiled filter
-        rows.setAll();
-        VectorPtr filterResult;
-        FilterEvalCtx filterContext;
-
-        dynamic_cast<facebook::velox::exec::VectorFunction*>(
-            info.filterFunc.get())
-            ->apply(
-                rows,
-                arguments, // See D27826068
-                // batch.get()->children(),
-                nullptr,
-                context,
-                filterResult);
-
-        auto numOut = facebook::velox::exec::processFilterResults(
-            filterResult->as<RowVector>()->childAt(0),
-            rows,
-            filterContext,
-            context.pool());
-
-        if (numOut == 0) {
-          // nothing passed filter, no need to evaluate projection
-          return nullptr;
-        }
-
-        if (numOut != batch->size()) {
-          rows.setFromBits(
-              filterContext.selectedBits->as<uint64_t>(), batch->size());
-        }
-
-        dynamic_cast<facebook::velox::exec::VectorFunction*>(
-            info.projectionFunc.get())
-            ->apply(
-                rows, batch.get()->children(), nullptr, context, batchResult);
-
-        if (numOut != batch->size()) {
-          batchResult = facebook::velox::exec::wrap(
-              numOut,
-              filterContext.selectedIndices,
-              std::dynamic_pointer_cast<RowVector>(batchResult));
-        }
-
-        return batchResult;
-      };
-
-      for (auto& batch : info.inputVector) {
-        auto batchResult = evalBatch(batch);
-        if (batchResult != nullptr && batchResult->size() > 0) {
-          info.generatedFunctionResults.push_back(
-              std::dynamic_pointer_cast<RowVector>(batchResult));
-        }
-      };
-      return numberIteration;
-    };
-
-    // Compiled time run
-    auto compileTimeLambda =
-        [ this, benchmarkIndex, numberIteration ]() -> auto {
-      auto& info = benchmarkInfos[benchmarkIndex];
-      codegenTransformation_->transform(*info.refPlanNodes);
-      return numberIteration;
-    };
-
-    return std::make_tuple(
-        std::move(referenceLambda),
-        std::move(compiledLambda),
-        std::move(generatedFunctionLambda),
-        std::move(compileTimeLambda));
-  }
-
-  /// Register a set of benchmarks to be ran with runBenchmark later.
-  /// \tparam SQLType
-  /// \param benchmarkName
-  /// \param filterExpr
-  /// \param projectionExprs
-  /// \param inputRowType
-  /// \param testBatches
-  /// \param rowPerBatch
-  /// \param flags
-  /// \return
-  template <typename... SQLType>
-  auto benchmarkExpressions(
-      const std::string& benchmarkName,
-      const std::string& filterExpr,
-      const std::vector<std::string>& projectionExprs,
-      const std::shared_ptr<const RowType>& inputRowType,
-      size_t numberBatches,
-      size_t rowPerBatch,
-      const std::vector<TransformFlags>& flagsVec = {defaultFlags},
-      bool nomalizeNumbers = true) {
-    auto referenceName = fmt::format(
-        "{}_{}x{}_reference", benchmarkName, numberBatches, rowPerBatch);
-
-    // the % is used to enable relative benchmarks.
-    auto compiledName = fmt::format(
-        "%{}_{}x{}_compiled", benchmarkName, numberBatches, rowPerBatch);
-
-    // the % is used to enable relative benchmarks.
-    auto vectorFunctionName = fmt::format(
-        "%{}_{}x{}_vectorFunc", benchmarkName, numberBatches, rowPerBatch);
-
-    // the % is used to enable relative benchmarks.
-    auto compileTimeName = fmt::format(
-        "%{}_{}x{}_compileTime", benchmarkName, numberBatches, rowPerBatch);
-
-    for (const auto& flags : flagsVec) {
-      auto
-          [referenceLambda,
-           compiledLambda,
-           vectorFunctionLambda,
-           compileTimeLambda] =
-              createBenchmarkLambda(
-                  benchmarkName,
-                  filterExpr,
-                  projectionExprs,
-                  inputRowType,
-                  numberBatches,
-                  rowPerBatch,
-                  flags,
-                  nomalizeNumbers);
-
-      // ugly way of printing flag information
-      folly::addBenchmark(
-          __FILE__,
-          fmt::format(
-              "compile filter:{},merge:{},defaultnull:{}",
-              (int)flags.compileFilter,
-              (int)flags.mergeFilter,
-              (int)(flags.enableDefaultNullOpt && flags.enableFilterDefaultNull)),
-          []() -> unsigned { return 0; });
-
-      // technically we only need to run referenceLambda once, but for the sake
-      // of compareResults() we run it every time
-      folly::addBenchmark(__FILE__, referenceName, referenceLambda);
-      folly::addBenchmark(__FILE__, compiledName, compiledLambda);
-      folly::addBenchmark(__FILE__, vectorFunctionName, vectorFunctionLambda);
-      folly::addBenchmark(__FILE__, compileTimeName, compileTimeLambda);
-    }
-  }
-
-  /// Register a set of benchmarks to be ran with runBenchmark later.
-  /// with only projection
-  /// \tparam SQLType
-  /// \param benchmarkName
-  /// \param exprString
-  /// \param inputRowType
-  /// \param testBatches
-  /// \param rowPerBatch
-  /// \return
-  template <typename... SQLType>
-  auto benchmarkExpressions(
-      const std::string& benchmarkName,
-      const std::vector<std::string>& exprString,
-      const std::shared_ptr<const RowType>& inputRowType,
-      size_t numberBatches,
-      size_t rowPerBatch,
-      const std::vector<TransformFlags>& flags = {defaultFlags},
-      bool nomalizeNumbers = true) {
-    benchmarkExpressions<SQLType...>(
-        benchmarkName,
-        "",
-        exprString,
-        inputRowType,
-        numberBatches,
-        rowPerBatch,
-        flags,
-        nomalizeNumbers);
-  }
-
-  /// Register a set of benchmarks with multiple number_batches/row_per_batch
-  /// pairs
-  /// \tparam SQLType
-  /// \param benchmarkName
-  /// \param filter
-  /// \param projection
-  /// \param inputRowType
-  /// \param batches
-  template <typename... SQLType>
-  auto benchmarkExpressionsMult(
-      const std::string& benchmarkName,
-      const std::string& filterExpr,
-      const std::vector<std::string>& projectionExprs,
-      const std::shared_ptr<const RowType>& inputRowType,
-      const std::vector<std::pair<size_t, size_t>>& batches,
-      const std::vector<TransformFlags>& flagsVec = {defaultFlags},
-      bool normalizeNumbers = true) {
-    for (const auto& batch : batches) {
-      benchmarkExpressions<SQLType...>(
-          benchmarkName,
-          filterExpr,
-          projectionExprs,
-          inputRowType,
-          batch.first,
-          batch.second,
-          flagsVec,
-          normalizeNumbers);
-    }
-  }
-
-  /// Register a set of projection only benchmarks with multiple
-  /// number_batches/row_per_batch pairs
-  /// \tparam SQLType
-  /// \param benchmarkName
-  /// \param exprString
-  /// \param inputRowType
-  /// \param batches
-  template <typename... SQLType>
-  auto benchmarkExpressionsMult(
-      const std::string& benchmarkName,
-      const std::vector<std::string>& exprString,
-      const std::shared_ptr<const RowType>& inputRowType,
-      const std::vector<std::pair<size_t, size_t>>& batches,
-      bool normalizeNumbers = true) {
-    benchmarkExpressionsMult<SQLType...>(
-        benchmarkName,
-        "",
-        exprString,
-        inputRowType,
-        batches,
-        {defaultFlags}, // only interested other flags when there's filter
-        normalizeNumbers);
-  }
-
-  void compareResults() {
-    for (const auto& benchmarkInfo : benchmarkInfos) {
-      auto& refResult = benchmarkInfo.referenceResults;
-      auto& compiledResult = benchmarkInfo.compiledResults;
-      auto& vectorFunctionResult = benchmarkInfo.generatedFunctionResults;
-
-      VELOX_CHECK(refResult.size() == compiledResult.size());
-      VELOX_CHECK(refResult.size() == vectorFunctionResult.size());
-
-      for (size_t batchIndex = 0; batchIndex < refResult.size(); ++batchIndex) {
-        VELOX_CHECK(
-            refResult[batchIndex]->size() ==
-            compiledResult[batchIndex]->size());
-
-        // Disable untill i move back the fix diff for the input ordering
-        if (enableVectorFunctionCompare) {
-          VELOX_CHECK(
-              refResult[batchIndex]->size() ==
-              vectorFunctionResult[batchIndex]->size());
-          for (size_t index = 0; index < refResult[batchIndex]->size();
-               ++index) {
-            VELOX_CHECK(
-                refResult[batchIndex]->compare(
-                    compiledResult[batchIndex].get(), index, index, {}) == 0);
-            VELOX_CHECK(
-                refResult[batchIndex]->compare(
-                    vectorFunctionResult[batchIndex].get(), index, index, {}) ==
-                0);
-          }
-        }
-      }
-    };
-  }
-};
-
-class BenchmarkGTest : public CodegenTestBase {
- public:
-  static inline std::vector<std::pair<size_t, size_t>> typicalBatches = {
-      //{1, 1000000},
-      {10, 100000},
-      {100, 10000},
-      //{1000, 1000},
-  };
-  static inline std::vector<TransformFlags> defaultFilterFlags = {
-      {{0, 0, 1, 1}}, // not compiling filter (base)
-      {{1, 0, 1, 1}}, // compiling filter separately
-      {{1, 1, 0, 0}}, // compiling filter merged without default null
-      {{1, 1, 1, 1}}, // compiling filter merged with default null
-  };
-  static inline CodegenBenchmark benchmark;
-  static void TearDownTestSuite() {
-    folly::runBenchmarks();
-    benchmark.compareResults();
-  }
-};
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/benchmark/CodegenBenchmarks.cpp b/velox/experimental/codegen/benchmark/CodegenBenchmarks.cpp
deleted file mode 100644
index 7671d560d9bb1..0000000000000
--- a/velox/experimental/codegen/benchmark/CodegenBenchmarks.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Benchmark.h>
-#include <folly/Random.h>
-#include <folly/init/Init.h>
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/benchmark/CodegenBenchmark.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::codegen;
-
-int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
-
-  CodegenBenchmark benchmark;
-
-  auto inputRowType = ROW({"a", "b"}, std::vector<TypePtr>{DOUBLE(), DOUBLE()});
-  benchmark.benchmarkExpressions<DoubleType, DoubleType>(
-      "SimpleAddSub", {" a + b", "a - b"}, inputRowType, 100, 1000);
-
-  BENCHMARK_DRAW_LINE();
-
-  auto inputRowType2 =
-      ROW({"a", "b"}, std::vector<TypePtr>{DOUBLE(), DOUBLE()});
-  benchmark.benchmarkExpressions<DoubleType, DoubleType, DoubleType>(
-      "SimpleAddSubMul", {" a + b", "a - b", "a * b"}, inputRowType, 100, 1000);
-
-  folly::runBenchmarks();
-  benchmark.compareResults();
-  return 0;
-}
diff --git a/velox/experimental/codegen/benchmark/CodegenPerf.cpp b/velox/experimental/codegen/benchmark/CodegenPerf.cpp
deleted file mode 100644
index 6f7d5a97c279c..0000000000000
--- a/velox/experimental/codegen/benchmark/CodegenPerf.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// perf event counter for the generated code
-
-#include "velox/experimental/codegen/tests/CodegenTestBase.h"
-
-namespace facebook::velox::codegen {
-namespace {
-class CodegenPerfTest : public CodegenTestBase {
- public:
-  virtual void SetUp() override {
-    init({"-DCODEGEN_PERF"});
-  }
-};
-} // namespace
-
-/*
-defaultnull disabled
-branch instructions: 3993869
-branch misses: 207653
-cpu clock: 13575605
-task clock: 13570701
-defaultnull enabled
-branch instructions: 860547
-branch misses: 15796
-cpu clock: 10786259
-task clock: 10781911
-*/
-TEST_F(CodegenPerfTest, DISABLED_simpleProjectionDefaultNull) {
-  auto inputRowType = ROW({"a", "b"}, std::vector<TypePtr>{DOUBLE(), DOUBLE()});
-  testExpressions<DoubleType, DoubleType>(
-      {"a + b", "a - b"}, inputRowType, 1, 1000000);
-};
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/benchmark/FilterBenchmark.cpp b/velox/experimental/codegen/benchmark/FilterBenchmark.cpp
deleted file mode 100644
index 4b15553fce53c..0000000000000
--- a/velox/experimental/codegen/benchmark/FilterBenchmark.cpp
+++ /dev/null
@@ -1,1256 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Benchmark.h>
-#include <folly/Random.h>
-#include <folly/init/Init.h>
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/benchmark/CodegenBenchmark.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::codegen;
-namespace {
-class FilterBenchmark : public BenchmarkGTest {};
-} // namespace
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterSimple_10x100000_reference                            23.69ns   42.20M
-filterSimple_10x100000_compiled                  114.82%    20.63ns   48.46M
-filterSimple_10x100000_vectorFunc                455.95%     5.20ns  192.43M
-filterSimple_10x100000_compileTime                 0.39%     6.04us  165.51K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterSimple_10x100000_reference                            24.08ns   41.52M
-filterSimple_10x100000_compiled                  188.82%    12.75ns   78.41M
-filterSimple_10x100000_vectorFunc                928.46%     2.59ns  385.53M
-filterSimple_10x100000_compileTime                 0.40%     5.99us  166.86K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterSimple_10x100000_reference                            23.72ns   42.16M
-filterSimple_10x100000_compiled                  269.39%     8.81ns  113.57M
-filterSimple_10x100000_vectorFunc                270.59%     8.77ns  114.07M
-filterSimple_10x100000_compileTime                 0.37%     6.49us  154.00K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterSimple_10x100000_reference                            23.72ns   42.15M
-filterSimple_10x100000_compiled                  351.98%     6.74ns  148.37M
-filterSimple_10x100000_vectorFunc                344.23%     6.89ns  145.10M
-filterSimple_10x100000_compileTime                 0.40%     5.97us  167.42K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterSimple_100x10000_reference                            23.90ns   41.84M
-filterSimple_100x10000_compiled                  111.75%    21.39ns   46.75M
-filterSimple_100x10000_vectorFunc                914.51%     2.61ns  382.59M
-filterSimple_100x10000_compileTime                 0.36%     6.59us  151.83K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterSimple_100x10000_reference                            23.29ns   42.93M
-filterSimple_100x10000_compiled                  164.79%    14.14ns   70.75M
-filterSimple_100x10000_vectorFunc                876.63%     2.66ns  376.34M
-filterSimple_100x10000_compileTime                 0.34%     6.81us  146.85K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterSimple_100x10000_reference                            24.19ns   41.33M
-filterSimple_100x10000_compiled                  275.72%     8.78ns  113.96M
-filterSimple_100x10000_vectorFunc                397.05%     6.09ns  164.11M
-filterSimple_100x10000_compileTime                 0.40%     5.98us  167.27K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterSimple_100x10000_reference                            23.93ns   41.80M
-filterSimple_100x10000_compiled                  308.84%     7.75ns  129.08M
-filterSimple_100x10000_vectorFunc                466.19%     5.13ns  194.85M
-filterSimple_100x10000_compileTime                 0.38%     6.23us  160.43K
- */
-TEST_F(FilterBenchmark, DISABLED_FilterSimple) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterSimple",
-      "a > b",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull_10x100000_reference                       54.31ns   18.41M
-filterDefaultNull_10x100000_compiled             101.86%    53.32ns   18.75M
-filterDefaultNull_10x100000_vectorFunc          2138.89%     2.54ns  393.82M
-filterDefaultNull_10x100000_compileTime            0.75%     7.21us  138.78K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull_10x100000_reference                       51.54ns   19.40M
-filterDefaultNull_10x100000_compiled             443.70%    11.62ns   86.08M
-filterDefaultNull_10x100000_vectorFunc           733.92%     7.02ns  142.39M
-filterDefaultNull_10x100000_compileTime            0.66%     7.81us  128.03K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNull_10x100000_reference                       52.30ns   19.12M
-filterDefaultNull_10x100000_compiled             369.98%    14.14ns   70.74M
-filterDefaultNull_10x100000_vectorFunc           417.00%    12.54ns   79.73M
-filterDefaultNull_10x100000_compileTime            0.79%     6.63us  150.78K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull_10x100000_reference                       51.10ns   19.57M
-filterDefaultNull_10x100000_compiled             659.69%     7.75ns  129.10M
-filterDefaultNull_10x100000_vectorFunc           809.53%     6.31ns  158.42M
-filterDefaultNull_10x100000_compileTime            0.76%     6.72us  148.90K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull_100x10000_reference                       49.40ns   20.24M
-filterDefaultNull_100x10000_compiled             103.38%    47.78ns   20.93M
-filterDefaultNull_100x10000_vectorFunc          1923.72%     2.57ns  389.44M
-filterDefaultNull_100x10000_compileTime            0.72%     6.86us  145.81K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull_100x10000_reference                       50.03ns   19.99M
-filterDefaultNull_100x10000_compiled             426.95%    11.72ns   85.33M
-filterDefaultNull_100x10000_vectorFunc          1969.18%     2.54ns  393.58M
-filterDefaultNull_100x10000_compileTime            0.77%     6.49us  154.14K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNull_100x10000_reference                       50.13ns   19.95M
-filterDefaultNull_100x10000_compiled             340.61%    14.72ns   67.95M
-filterDefaultNull_100x10000_vectorFunc           413.38%    12.13ns   82.46M
-filterDefaultNull_100x10000_compileTime            0.76%     6.57us  152.26K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull_100x10000_reference                       49.54ns   20.18M
-filterDefaultNull_100x10000_compiled             645.31%     7.68ns  130.25M
-filterDefaultNull_100x10000_vectorFunc           996.83%     4.97ns  201.20M
-filterDefaultNull_100x10000_compileTime            0.72%     6.93us  144.34K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterDefaultNull) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterDefaultNull",
-      "a > b AND c > d",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// logically equivalent to FilterDefaultNull
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotOr_10x100000_reference                  51.00ns   19.61M
-filterDefaultNullNotOr_10x100000_compiled        104.25%    48.92ns   20.44M
-filterDefaultNullNotOr_10x100000_vectorFunc     2224.25%     2.29ns  436.10M
-filterDefaultNullNotOr_10x100000_compileTime       0.76%     6.69us  149.46K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotOr_10x100000_reference                  50.83ns   19.67M
-filterDefaultNullNotOr_10x100000_compiled        463.18%    10.97ns   91.13M
-filterDefaultNullNotOr_10x100000_vectorFunc     2243.22%     2.27ns  441.33M
-filterDefaultNullNotOr_10x100000_compileTime       0.75%     6.82us  146.63K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNullNotOr_10x100000_reference                  50.80ns   19.69M
-filterDefaultNullNotOr_10x100000_compiled        354.51%    14.33ns   69.79M
-filterDefaultNullNotOr_10x100000_vectorFunc      391.09%    12.99ns   76.99M
-filterDefaultNullNotOr_10x100000_compileTime       0.75%     6.74us  148.29K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotOr_10x100000_reference                  50.80ns   19.69M
-filterDefaultNullNotOr_10x100000_compiled        659.35%     7.70ns  129.79M
-filterDefaultNullNotOr_10x100000_vectorFunc      816.64%     6.22ns  160.76M
-filterDefaultNullNotOr_10x100000_compileTime       0.75%     6.82us  146.66K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotOr_100x10000_reference                  50.40ns   19.84M
-filterDefaultNullNotOr_100x10000_compiled        102.99%    48.94ns   20.43M
-filterDefaultNullNotOr_100x10000_vectorFunc     2016.70%     2.50ns  400.11M
-filterDefaultNullNotOr_100x10000_compileTime       0.76%     6.66us  150.11K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotOr_100x10000_reference                  49.42ns   20.24M
-filterDefaultNullNotOr_100x10000_compiled        416.44%    11.87ns   84.27M
-filterDefaultNullNotOr_100x10000_vectorFunc     2005.17%     2.46ns  405.76M
-filterDefaultNullNotOr_100x10000_compileTime       0.72%     6.88us  145.39K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNullNotOr_100x10000_reference                  51.43ns   19.44M
-filterDefaultNullNotOr_100x10000_compiled        331.69%    15.51ns   64.49M
-filterDefaultNullNotOr_100x10000_vectorFunc      401.82%    12.80ns   78.13M
-filterDefaultNullNotOr_100x10000_compileTime       0.75%     6.87us  145.60K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotOr_100x10000_reference                  50.59ns   19.77M
-filterDefaultNullNotOr_100x10000_compiled        727.55%     6.95ns  143.81M
-filterDefaultNullNotOr_100x10000_vectorFunc     1270.63%     3.98ns  251.15M
-filterDefaultNullNotOr_100x10000_compileTime       0.74%     6.85us  146.01K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterDefaultNullNotOr) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterDefaultNullNotOr",
-      "NOT (a <= b OR c <= d)",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullIsNull_10x100000_reference                 44.93ns   22.26M
-filterDefaultNullIsNull_10x100000_compiled       102.60%    43.79ns   22.84M
-filterDefaultNullIsNull_10x100000_vectorFunc    1918.78%     2.34ns  427.09M
-filterDefaultNullIsNull_10x100000_compileTime      0.74%     6.08us  164.59K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullIsNull_10x100000_reference                 44.86ns   22.29M
-filterDefaultNullIsNull_10x100000_compiled       327.74%    13.69ns   73.06M
-filterDefaultNullIsNull_10x100000_vectorFunc     864.16%     5.19ns  192.63M
-filterDefaultNullIsNull_10x100000_compileTime      0.73%     6.11us  163.71K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNullIsNull_10x100000_reference                 44.64ns   22.40M
-filterDefaultNullIsNull_10x100000_compiled       506.18%     8.82ns  113.39M
-filterDefaultNullIsNull_10x100000_vectorFunc     504.80%     8.84ns  113.08M
-filterDefaultNullIsNull_10x100000_compileTime      0.74%     6.04us  165.62K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullIsNull_10x100000_reference                 44.49ns   22.48M
-filterDefaultNullIsNull_10x100000_compiled       618.13%     7.20ns  138.94M
-filterDefaultNullIsNull_10x100000_vectorFunc     782.73%     5.68ns  175.94M
-filterDefaultNullIsNull_10x100000_compileTime      0.69%     6.41us  155.90K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullIsNull_100x10000_reference                 45.55ns   21.96M
-filterDefaultNullIsNull_100x10000_compiled       105.56%    43.15ns   23.18M
-filterDefaultNullIsNull_100x10000_vectorFunc    1760.15%     2.59ns  386.46M
-filterDefaultNullIsNull_100x10000_compileTime      0.65%     7.00us  142.83K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullIsNull_100x10000_reference                 45.88ns   21.80M
-filterDefaultNullIsNull_100x10000_compiled       296.67%    15.46ns   64.67M
-filterDefaultNullIsNull_100x10000_vectorFunc    1800.86%     2.55ns  392.55M
-filterDefaultNullIsNull_100x10000_compileTime      0.72%     6.34us  157.82K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNullIsNull_100x10000_reference                 45.38ns   22.03M
-filterDefaultNullIsNull_100x10000_compiled       507.90%     8.94ns  111.91M
-filterDefaultNullIsNull_100x10000_vectorFunc     739.18%     6.14ns  162.87M
-filterDefaultNullIsNull_100x10000_compileTime      0.79%     5.76us  173.75K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullIsNull_100x10000_reference                 45.33ns   22.06M
-filterDefaultNullIsNull_100x10000_compiled       611.13%     7.42ns  134.80M
-filterDefaultNullIsNull_100x10000_vectorFunc     899.93%     5.04ns  198.51M
-filterDefaultNullIsNull_100x10000_compileTime      0.77%     5.89us  169.80K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterDefaultNullIsNull) {
-  auto inputRowType4 =
-      ROW({"a", "b"}, std::vector<TypePtr>{BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterDefaultNullIsNull",
-      "b > 5 AND NOT a IS NULL",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull4_10x100000_reference                      64.09ns   15.60M
-filterDefaultNull4_10x100000_compiled            103.89%    61.69ns   16.21M
-filterDefaultNull4_10x100000_vectorFunc         2799.06%     2.29ns  436.75M
-filterDefaultNull4_10x100000_compileTime           0.97%     6.61us  151.19K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull4_10x100000_reference                      63.35ns   15.79M
-filterDefaultNull4_10x100000_compiled            570.52%    11.10ns   90.06M
-filterDefaultNull4_10x100000_vectorFunc         1241.39%     5.10ns  195.96M
-filterDefaultNull4_10x100000_compileTime           0.92%     6.86us  145.79K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNull4_10x100000_reference                      65.43ns   15.28M
-filterDefaultNull4_10x100000_compiled            352.98%    18.54ns   53.95M
-filterDefaultNull4_10x100000_vectorFunc          365.86%    17.88ns   55.92M
-filterDefaultNull4_10x100000_compileTime           0.94%     6.96us  143.69K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull4_10x100000_reference                      65.49ns   15.27M
-filterDefaultNull4_10x100000_compiled            761.44%     8.60ns  116.27M
-filterDefaultNull4_10x100000_vectorFunc          861.88%     7.60ns  131.60M
-filterDefaultNull4_10x100000_compileTime           0.90%     7.29us  137.15K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull4_100x10000_reference                      66.88ns   14.95M
-filterDefaultNull4_100x10000_compiled            102.92%    64.99ns   15.39M
-filterDefaultNull4_100x10000_vectorFunc         2970.84%     2.25ns  444.20M
-filterDefaultNull4_100x10000_compileTime           0.97%     6.89us  145.13K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull4_100x10000_reference                      66.06ns   15.14M
-filterDefaultNull4_100x10000_compiled            650.10%    10.16ns   98.41M
-filterDefaultNull4_100x10000_vectorFunc         2673.77%     2.47ns  404.73M
-filterDefaultNull4_100x10000_compileTime           0.95%     6.95us  143.84K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNull4_100x10000_reference                      65.37ns   15.30M
-filterDefaultNull4_100x10000_compiled            322.30%    20.28ns   49.30M
-filterDefaultNull4_100x10000_vectorFunc          370.32%    17.65ns   56.65M
-filterDefaultNull4_100x10000_compileTime           0.98%     6.69us  149.52K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNull4_100x10000_reference                      63.20ns   15.82M
-filterDefaultNull4_100x10000_compiled            837.25%     7.55ns  132.48M
-filterDefaultNull4_100x10000_vectorFunc         1215.43%     5.20ns  192.33M
-filterDefaultNull4_100x10000_compileTime           0.94%     6.72us  148.79K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterDefaultNull4) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterDefaultNull4",
-      "a > 5 AND b > 5 AND c > 5 and d > 5",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// filter columns are not superset of projection columns
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotSuper_10x100000_reference               50.69ns   19.73M
-filterDefaultNullNotSuper_10x100000_compiled     103.21%    49.12ns   20.36M
-filterDefaultNullNotSuper_10x100000_vectorFunc  2170.17%     2.34ns  428.09M
-filterDefaultNullNotSuper_10x100000_compileTime    0.75%     6.80us  147.08K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotSuper_10x100000_reference               52.45ns   19.07M
-filterDefaultNullNotSuper_10x100000_compiled     388.27%    13.51ns   74.03M
-filterDefaultNullNotSuper_10x100000_vectorFunc  2298.54%     2.28ns  438.23M
-filterDefaultNullNotSuper_10x100000_compileTime    0.79%     6.65us  150.28K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNullNotSuper_10x100000_reference               51.87ns   19.28M
-filterDefaultNullNotSuper_10x100000_compiled     413.22%    12.55ns   79.67M
-filterDefaultNullNotSuper_10x100000_vectorFunc   469.73%    11.04ns   90.57M
-filterDefaultNullNotSuper_10x100000_compileTime    0.76%     6.80us  147.15K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotSuper_10x100000_reference               50.28ns   19.89M
-filterDefaultNullNotSuper_10x100000_compiled     574.17%     8.76ns  114.20M
-filterDefaultNullNotSuper_10x100000_vectorFunc   592.90%     8.48ns  117.92M
-filterDefaultNullNotSuper_10x100000_compileTime    0.75%     6.73us  148.63K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotSuper_100x10000_reference               51.15ns   19.55M
-filterDefaultNullNotSuper_100x10000_compiled     103.73%    49.31ns   20.28M
-filterDefaultNullNotSuper_100x10000_vectorFunc  1759.57%     2.91ns  344.02M
-filterDefaultNullNotSuper_100x10000_compileTime    0.75%     6.85us  146.01K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotSuper_100x10000_reference               53.12ns   18.83M
-filterDefaultNullNotSuper_100x10000_compiled     357.03%    14.88ns   67.22M
-filterDefaultNullNotSuper_100x10000_vectorFunc  1996.39%     2.66ns  375.85M
-filterDefaultNullNotSuper_100x10000_compileTime    0.78%     6.83us  146.33K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterDefaultNullNotSuper_100x10000_reference               50.52ns   19.79M
-filterDefaultNullNotSuper_100x10000_compiled     381.40%    13.25ns   75.50M
-filterDefaultNullNotSuper_100x10000_vectorFunc   515.57%     9.80ns  102.05M
-filterDefaultNullNotSuper_100x10000_compileTime    0.75%     6.74us  148.43K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterDefaultNullNotSuper_100x10000_reference               52.33ns   19.11M
-filterDefaultNullNotSuper_100x10000_compiled     567.04%     9.23ns  108.36M
-filterDefaultNullNotSuper_100x10000_vectorFunc   812.88%     6.44ns  155.34M
-filterDefaultNullNotSuper_100x10000_compileTime    0.71%     7.33us  136.47K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterDefaultNullNotSuper) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterDefaultNullNotSuper",
-      "a > 5 AND b > 5",
-      {"c+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterNullOr_10x100000_reference                            32.06ns   31.19M
-filterNullOr_10x100000_compiled                  109.26%    29.35ns   34.08M
-filterNullOr_10x100000_vectorFunc                660.19%     4.86ns  205.91M
-filterNullOr_10x100000_compileTime                 0.49%     6.60us  151.48K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterNullOr_10x100000_reference                            33.29ns   30.04M
-filterNullOr_10x100000_compiled                  162.55%    20.48ns   48.83M
-filterNullOr_10x100000_vectorFunc                653.66%     5.09ns  196.36M
-filterNullOr_10x100000_compileTime                 0.49%     6.77us  147.79K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterNullOr_10x100000_reference                            33.81ns   29.58M
-filterNullOr_10x100000_compiled                  425.16%     7.95ns  125.75M
-filterNullOr_10x100000_vectorFunc                451.65%     7.49ns  133.59M
-filterNullOr_10x100000_compileTime                 0.49%     6.91us  144.72K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterNullOr_10x100000_reference                            34.32ns   29.14M
-filterNullOr_10x100000_compiled                  447.31%     7.67ns  130.35M
-filterNullOr_10x100000_vectorFunc                453.31%     7.57ns  132.10M
-filterNullOr_10x100000_compileTime                 0.52%     6.65us  150.38K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterNullOr_100x10000_reference                            34.82ns   28.72M
-filterNullOr_100x10000_compiled                  115.13%    30.24ns   33.07M
-filterNullOr_100x10000_vectorFunc               1432.15%     2.43ns  411.33M
-filterNullOr_100x10000_compileTime                 0.53%     6.53us  153.07K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterNullOr_100x10000_reference                            33.91ns   29.49M
-filterNullOr_100x10000_compiled                  171.28%    19.80ns   50.52M
-filterNullOr_100x10000_vectorFunc               1388.55%     2.44ns  409.53M
-filterNullOr_100x10000_compileTime                 0.52%     6.55us  152.67K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterNullOr_100x10000_reference                            33.88ns   29.51M
-filterNullOr_100x10000_compiled                  437.91%     7.74ns  129.24M
-filterNullOr_100x10000_vectorFunc                691.67%     4.90ns  204.13M
-filterNullOr_100x10000_compileTime                 0.51%     6.58us  151.94K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterNullOr_100x10000_reference                            33.62ns   29.74M
-filterNullOr_100x10000_compiled                  430.06%     7.82ns  127.91M
-filterNullOr_100x10000_vectorFunc                738.89%     4.55ns  219.77M
-filterNullOr_100x10000_compileTime                 0.48%     6.96us  143.63K
- */
-TEST_F(FilterBenchmark, DISABLED_FilterNullOr) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterNullOr",
-      "(NOT a IS NULL) OR (NOT b IS NULL) OR (NOT c IS NULL) OR (NOT d IS NULL)",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// logically equivalent to FilterNullOr
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterNullOrEquiv_10x100000_reference                       29.59ns   33.79M
-filterNullOrEquiv_10x100000_compiled             114.96%    25.74ns   38.85M
-filterNullOrEquiv_10x100000_vectorFunc           597.94%     4.95ns  202.05M
-filterNullOrEquiv_10x100000_compileTime            0.50%     5.89us  169.70K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterNullOrEquiv_10x100000_reference                       29.89ns   33.45M
-filterNullOrEquiv_10x100000_compiled             138.01%    21.66ns   46.17M
-filterNullOrEquiv_10x100000_vectorFunc           556.72%     5.37ns  186.24M
-filterNullOrEquiv_10x100000_compileTime            0.50%     6.02us  166.18K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterNullOrEquiv_10x100000_reference                       30.26ns   33.05M
-filterNullOrEquiv_10x100000_compiled             568.92%     5.32ns  188.01M
-filterNullOrEquiv_10x100000_vectorFunc           539.84%     5.61ns  178.40M
-filterNullOrEquiv_10x100000_compileTime            0.52%     5.85us  170.81K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterNullOrEquiv_10x100000_reference                       29.78ns   33.58M
-filterNullOrEquiv_10x100000_compiled             504.15%     5.91ns  169.30M
-filterNullOrEquiv_10x100000_vectorFunc           548.67%     5.43ns  184.25M
-filterNullOrEquiv_10x100000_compileTime            0.51%     5.84us  171.34K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterNullOrEquiv_100x10000_reference                       31.30ns   31.95M
-filterNullOrEquiv_100x10000_compiled             109.49%    28.58ns   34.99M
-filterNullOrEquiv_100x10000_vectorFunc           570.86%     5.48ns  182.41M
-filterNullOrEquiv_100x10000_compileTime            0.52%     6.05us  165.19K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterNullOrEquiv_100x10000_reference                       31.41ns   31.84M
-filterNullOrEquiv_100x10000_compiled             137.62%    22.82ns   43.82M
-filterNullOrEquiv_100x10000_vectorFunc          1212.68%     2.59ns  386.10M
-filterNullOrEquiv_100x10000_compileTime            0.54%     5.80us  172.36K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterNullOrEquiv_100x10000_reference                       30.19ns   33.13M
-filterNullOrEquiv_100x10000_compiled             593.72%     5.08ns  196.69M
-filterNullOrEquiv_100x10000_vectorFunc          1349.94%     2.24ns  447.20M
-filterNullOrEquiv_100x10000_compileTime            0.52%     5.78us  173.10K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterNullOrEquiv_100x10000_reference                       33.35ns   29.99M
-filterNullOrEquiv_100x10000_compiled             640.87%     5.20ns  192.17M
-filterNullOrEquiv_100x10000_vectorFunc           640.92%     5.20ns  192.19M
-filterNullOrEquiv_100x10000_compileTime            0.56%     5.96us  167.85K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterNullEquiv) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterNullOrEquiv",
-      "NOT COALESCE(a,b,c,d) IS NULL",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterIf_10x100000_reference                                45.34ns   22.06M
-filterIf_10x100000_compiled                      102.73%    44.13ns   22.66M
-filterIf_10x100000_vectorFunc                   2164.53%     2.09ns  477.41M
-filterIf_10x100000_compileTime                     0.66%     6.84us  146.26K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterIf_10x100000_reference                                46.81ns   21.36M
-filterIf_10x100000_compiled                      177.56%    26.36ns   37.93M
-filterIf_10x100000_vectorFunc                    961.21%     4.87ns  205.34M
-filterIf_10x100000_compileTime                     0.69%     6.74us  148.29K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterIf_10x100000_reference                                46.91ns   21.32M
-filterIf_10x100000_compiled                      265.05%    17.70ns   56.51M
-filterIf_10x100000_vectorFunc                    262.34%    17.88ns   55.93M
-filterIf_10x100000_compileTime                     0.70%     6.73us  148.66K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterIf_10x100000_reference                                45.32ns   22.06M
-filterIf_10x100000_compiled                      261.54%    17.33ns   57.70M
-filterIf_10x100000_vectorFunc                    257.24%    17.62ns   56.76M
-filterIf_10x100000_compileTime                     0.70%     6.45us  155.01K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterIf_100x10000_reference                                45.29ns   22.08M
-filterIf_100x10000_compiled                      103.01%    43.97ns   22.74M
-filterIf_100x10000_vectorFunc                   1834.37%     2.47ns  405.03M
-filterIf_100x10000_compileTime                     0.66%     6.82us  146.69K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterIf_100x10000_reference                                45.36ns   22.05M
-filterIf_100x10000_compiled                      168.23%    26.96ns   37.09M
-filterIf_100x10000_vectorFunc                   1695.21%     2.68ns  373.75M
-filterIf_100x10000_compileTime                     0.67%     6.74us  148.26K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterIf_100x10000_reference                                45.49ns   21.98M
-filterIf_100x10000_compiled                      244.71%    18.59ns   53.79M
-filterIf_100x10000_vectorFunc                    293.80%    15.48ns   64.58M
-filterIf_100x10000_compileTime                     0.66%     6.87us  145.50K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterIf_100x10000_reference                                47.80ns   20.92M
-filterIf_100x10000_compiled                      221.53%    21.58ns   46.35M
-filterIf_100x10000_vectorFunc                    304.63%    15.69ns   63.73M
-filterIf_100x10000_compileTime                     0.69%     6.94us  144.13K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterIf) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterIf",
-      "if(a>b,c,d) > 6",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterCase_10x100000_reference                              54.11ns   18.48M
-filterCase_10x100000_compiled                    106.86%    50.64ns   19.75M
-filterCase_10x100000_vectorFunc                 2372.79%     2.28ns  438.49M
-filterCase_10x100000_compileTime                   0.84%     6.45us  155.00K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterCase_10x100000_reference                              52.83ns   18.93M
-filterCase_10x100000_compiled                    348.09%    15.18ns   65.89M
-filterCase_10x100000_vectorFunc                 2285.78%     2.31ns  432.68M
-filterCase_10x100000_compileTime                   0.91%     5.80us  172.37K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterCase_10x100000_reference                              54.03ns   18.51M
-filterCase_10x100000_compiled                    837.21%     6.45ns  154.94M
-filterCase_10x100000_vectorFunc                  903.25%     5.98ns  167.17M
-filterCase_10x100000_compileTime                   0.92%     5.88us  169.94K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterCase_10x100000_reference                              55.38ns   18.06M
-filterCase_10x100000_compiled                    855.57%     6.47ns  154.49M
-filterCase_10x100000_vectorFunc                  951.02%     5.82ns  171.72M
-filterCase_10x100000_compileTime                   0.93%     5.96us  167.74K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterCase_100x10000_reference                              56.30ns   17.76M
-filterCase_100x10000_compiled                    110.03%    51.17ns   19.54M
-filterCase_100x10000_vectorFunc                 2036.41%     2.76ns  361.70M
-filterCase_100x10000_compileTime                   0.94%     6.00us  166.71K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterCase_100x10000_reference                              54.50ns   18.35M
-filterCase_100x10000_compiled                    348.59%    15.64ns   63.96M
-filterCase_100x10000_vectorFunc                 2117.75%     2.57ns  388.55M
-filterCase_100x10000_compileTime                   0.92%     5.93us  168.52K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterCase_100x10000_reference                              54.59ns   18.32M
-filterCase_100x10000_compiled                    879.51%     6.21ns  161.11M
-filterCase_100x10000_vectorFunc                 1460.48%     3.74ns  267.53M
-filterCase_100x10000_compileTime                   0.89%     6.11us  163.70K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterCase_100x10000_reference                              54.89ns   18.22M
-filterCase_100x10000_compiled                    799.39%     6.87ns  145.63M
-filterCase_100x10000_vectorFunc                 1428.02%     3.84ns  260.15M
-filterCase_100x10000_compileTime                   0.92%     5.95us  168.08K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterCase) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterCase",
-      "CASE a WHEN b THEN b WHEN c THEN c WHEN d THEN d ELSE a END < 5",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// logically equivalent to FilterCase
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterCaseEquiv_10x100000_reference                         25.71ns   38.89M
-filterCaseEquiv_10x100000_compiled               112.89%    22.78ns   43.90M
-filterCaseEquiv_10x100000_vectorFunc             530.98%     4.84ns  206.51M
-filterCaseEquiv_10x100000_compileTime              0.43%     5.98us  167.13K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterCaseEquiv_10x100000_reference                         26.13ns   38.27M
-filterCaseEquiv_10x100000_compiled               192.17%    13.60ns   73.54M
-filterCaseEquiv_10x100000_vectorFunc            1117.85%     2.34ns  427.78M
-filterCaseEquiv_10x100000_compileTime              0.44%     5.89us  169.78K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterCaseEquiv_10x100000_reference                         25.37ns   39.41M
-filterCaseEquiv_10x100000_compiled               403.17%     6.29ns  158.90M
-filterCaseEquiv_10x100000_vectorFunc             430.09%     5.90ns  169.51M
-filterCaseEquiv_10x100000_compileTime              0.43%     5.95us  168.13K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterCaseEquiv_10x100000_reference                         25.63ns   39.02M
-filterCaseEquiv_10x100000_compiled               368.84%     6.95ns  143.91M
-filterCaseEquiv_10x100000_vectorFunc             380.23%     6.74ns  148.36M
-filterCaseEquiv_10x100000_compileTime              0.39%     6.60us  151.61K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterCaseEquiv_100x10000_reference                         26.56ns   37.65M
-filterCaseEquiv_100x10000_compiled               111.18%    23.89ns   41.86M
-filterCaseEquiv_100x10000_vectorFunc             850.51%     3.12ns  320.18M
-filterCaseEquiv_100x10000_compileTime              0.44%     6.06us  164.94K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterCaseEquiv_100x10000_reference                         26.67ns   37.49M
-filterCaseEquiv_100x10000_compiled               173.30%    15.39ns   64.97M
-filterCaseEquiv_100x10000_vectorFunc            1029.77%     2.59ns  386.10M
-filterCaseEquiv_100x10000_compileTime              0.46%     5.78us  173.06K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterCaseEquiv_100x10000_reference                         28.31ns   35.33M
-filterCaseEquiv_100x10000_compiled               380.50%     7.44ns  134.41M
-filterCaseEquiv_100x10000_vectorFunc             795.45%     3.56ns  281.00M
-filterCaseEquiv_100x10000_compileTime              0.48%     5.84us  171.20K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterCaseEquiv_100x10000_reference                         26.74ns   37.39M
-filterCaseEquiv_100x10000_compiled               326.48%     8.19ns  122.09M
-filterCaseEquiv_100x10000_vectorFunc             498.32%     5.37ns  186.34M
-filterCaseEquiv_100x10000_compileTime              0.39%     6.81us  146.78K
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterCaseEquiv) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "filterCaseEquiv",
-      "a < 5",
-      {"a+1"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterComplex_10x100000_reference                          182.64ns    5.48M
-filterComplex_10x100000_compiled                 101.39%   180.13ns    5.55M
-filterComplex_10x100000_vectorFunc              8492.81%     2.15ns  464.99M
-filterComplex_10x100000_compileTime                2.92%     6.25us  160.03K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterComplex_10x100000_reference                          180.96ns    5.53M
-filterComplex_10x100000_compiled                 385.80%    46.91ns   21.32M
-filterComplex_10x100000_vectorFunc              8377.67%     2.16ns  462.96M
-filterComplex_10x100000_compileTime                2.68%     6.75us  148.04K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterComplex_10x100000_reference                          182.84ns    5.47M
-filterComplex_10x100000_compiled                4391.66%     4.16ns  240.19M
-filterComplex_10x100000_vectorFunc               437.74%    41.77ns   23.94M
-filterComplex_10x100000_compileTime                2.75%     6.66us  150.23K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterComplex_10x100000_reference                          188.13ns    5.32M
-filterComplex_10x100000_compiled                4421.71%     4.25ns  235.04M
-filterComplex_10x100000_vectorFunc               448.02%    41.99ns   23.81M
-filterComplex_10x100000_compileTime                2.87%     6.56us  152.45K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterComplex_100x10000_reference                          182.84ns    5.47M
-filterComplex_100x10000_compiled                 100.25%   182.39ns    5.48M
-filterComplex_100x10000_vectorFunc              3701.53%     4.94ns  202.45M
-filterComplex_100x10000_compileTime                2.68%     6.83us  146.52K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterComplex_100x10000_reference                          177.97ns    5.62M
-filterComplex_100x10000_compiled                 382.88%    46.48ns   21.51M
-filterComplex_100x10000_vectorFunc              8008.42%     2.22ns  449.99M
-filterComplex_100x10000_compileTime                2.76%     6.45us  155.00K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterComplex_100x10000_reference                          177.29ns    5.64M
-filterComplex_100x10000_compiled                47585.81%   372.56ps    2.68G
-filterComplex_100x10000_vectorFunc               418.21%    42.39ns   23.59M
-filterComplex_100x10000_compileTime                2.57%     6.91us  144.71K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterComplex_100x10000_reference                          180.17ns    5.55M
-filterComplex_100x10000_compiled                48966.06%   367.94ps    2.72G
-filterComplex_100x10000_vectorFunc               415.12%    43.40ns   23.04M
-filterComplex_100x10000_compileTime                2.77%     6.51us  153.55K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterComplex) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterComplex",
-      "CASE (CAST (COALESCE(a,1.0)*COALESCE(b, 1.0)/COALESCE(c,1.0)-COALESCE(d,1.0) AS INTEGER) % 4)"
-      "  WHEN 0 THEN a "
-      "  WHEN 1 THEN b "
-      "  WHEN 2 THEN c "
-      "  ELSE d "
-      "END > 1.0",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOp_10x100000_reference                                34.90ns   28.65M
-filterOp_10x100000_compiled                      101.35%    34.43ns   29.04M
-filterOp_10x100000_vectorFunc                    718.20%     4.86ns  205.80M
-filterOp_10x100000_compileTime                     0.56%     6.22us  160.71K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOp_10x100000_reference                                35.91ns   27.85M
-filterOp_10x100000_compiled                      244.47%    14.69ns   68.08M
-filterOp_10x100000_vectorFunc                   1669.49%     2.15ns  464.93M
-filterOp_10x100000_compileTime                     0.57%     6.29us  159.06K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOp_10x100000_reference                                35.82ns   27.92M
-filterOp_10x100000_compiled                      294.70%    12.16ns   82.27M
-filterOp_10x100000_vectorFunc                    363.60%     9.85ns  101.50M
-filterOp_10x100000_compileTime                     0.55%     6.48us  154.26K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOp_10x100000_reference                                34.48ns   29.00M
-filterOp_10x100000_compiled                      545.86%     6.32ns  158.32M
-filterOp_10x100000_vectorFunc                    850.64%     4.05ns  246.72M
-filterOp_10x100000_compileTime                     0.55%     6.30us  158.77K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOp_100x10000_reference                                30.91ns   32.36M
-filterOp_100x10000_compiled                      100.26%    30.82ns   32.44M
-filterOp_100x10000_vectorFunc                   1530.42%     2.02ns  495.20M
-filterOp_100x10000_compileTime                     0.49%     6.27us  159.60K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOp_100x10000_reference                                31.15ns   32.10M
-filterOp_100x10000_compiled                      192.59%    16.17ns   61.83M
-filterOp_100x10000_vectorFunc                   1663.29%     1.87ns  533.96M
-filterOp_100x10000_compileTime                     0.49%     6.35us  157.42K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOp_100x10000_reference                                33.01ns   30.30M
-filterOp_100x10000_compiled                      238.41%    13.84ns   72.23M
-filterOp_100x10000_vectorFunc                    333.52%     9.90ns  101.04M
-filterOp_100x10000_compileTime                     0.50%     6.65us  150.37K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOp_100x10000_reference                                31.54ns   31.71M
-filterOp_100x10000_compiled                      442.94%     7.12ns  140.46M
-filterOp_100x10000_vectorFunc                    826.79%     3.81ns  262.18M
-filterOp_100x10000_compileTime                     0.50%     6.32us  158.13K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterOp) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterOp",
-      "1.1*a+b/1.01+c*c > d",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-filterOpSimplifiable_10x100000_reference                    30.72ns   32.55M
-filterOpSimplifiable_10x100000_compiled          102.88%    29.86ns   33.49M
-filterOpSimplifiable_10x100000_vectorFunc       1401.37%     2.19ns  456.19M
-filterOpSimplifiable_10x100000_compileTime         0.47%     6.57us  152.13K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiable_10x100000_reference                    31.31ns   31.94M
-filterOpSimplifiable_10x100000_compiled          793.63%     3.95ns  253.47M
-filterOpSimplifiable_10x100000_vectorFunc       1357.78%     2.31ns  433.65M
-filterOpSimplifiable_10x100000_compileTime         0.48%     6.50us  153.85K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOpSimplifiable_10x100000_reference                    30.58ns   32.71M
-filterOpSimplifiable_10x100000_compiled         7861.42%   388.94ps    2.57G
-filterOpSimplifiable_10x100000_vectorFunc        793.46%     3.85ns  259.50M
-filterOpSimplifiable_10x100000_compileTime         0.42%     7.34us  136.15K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiable_10x100000_reference                    30.57ns   32.71M
-filterOpSimplifiable_10x100000_compiled         19807.14%   154.35ps    6.48G
-filterOpSimplifiable_10x100000_vectorFunc       1733.13%     1.76ns  566.88M
-filterOpSimplifiable_10x100000_compileTime         0.48%     6.39us  156.54K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiable_100x10000_reference                    25.87ns   38.66M
-filterOpSimplifiable_100x10000_compiled           97.23%    26.61ns   37.59M
-filterOpSimplifiable_100x10000_vectorFunc       1328.66%     1.95ns  513.60M
-filterOpSimplifiable_100x10000_compileTime         0.40%     6.44us  155.28K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiable_100x10000_reference                    25.16ns   39.75M
-filterOpSimplifiable_100x10000_compiled          549.74%     4.58ns  218.51M
-filterOpSimplifiable_100x10000_vectorFunc       1285.77%     1.96ns  511.06M
-filterOpSimplifiable_100x10000_compileTime         0.40%     6.26us  159.75K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOpSimplifiable_100x10000_reference                    24.79ns   40.34M
-filterOpSimplifiable_100x10000_compiled             inf%     0.00fs  Infinity
-filterOpSimplifiable_100x10000_vectorFunc        878.21%     2.82ns  354.26M
-filterOpSimplifiable_100x10000_compileTime         0.35%     7.07us  141.45K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiable_100x10000_reference                    25.07ns   39.89M
-filterOpSimplifiable_100x10000_compiled             inf%     0.00fs  Infinity
-filterOpSimplifiable_100x10000_vectorFunc       1310.60%     1.91ns  522.78M
-filterOpSimplifiable_100x10000_compileTime         0.41%     6.11us  163.57K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterOpSimplifiable) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterOpSimplifiable",
-      "a > b * b * b * (1.0/b) * (1.0/b) * (1.0/b)",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// logically equivalent FilterOpSimplifiable
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableEquiv_10x100000_reference               24.76ns   40.39M
-filterOpSimplifiableEquiv_10x100000_compiled     100.65%    24.60ns   40.66M
-filterOpSimplifiableEquiv_10x100000_vectorFunc  1138.77%     2.17ns  460.00M
-filterOpSimplifiableEquiv_10x100000_compileTime    0.39%     6.33us  157.96K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableEquiv_10x100000_reference               25.15ns   39.76M
-filterOpSimplifiableEquiv_10x100000_compiled     877.17%     2.87ns  348.77M
-filterOpSimplifiableEquiv_10x100000_vectorFunc   522.42%     4.81ns  207.72M
-filterOpSimplifiableEquiv_10x100000_compileTime    0.40%     6.23us  160.63K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOpSimplifiableEquiv_10x100000_reference               25.61ns   39.05M
-filterOpSimplifiableEquiv_10x100000_compiled    6770.06%   378.26ps    2.64G
-filterOpSimplifiableEquiv_10x100000_vectorFunc   612.61%     4.18ns  239.22M
-filterOpSimplifiableEquiv_10x100000_compileTime    0.42%     6.03us  165.84K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableEquiv_10x100000_reference               24.48ns   40.85M
-filterOpSimplifiableEquiv_10x100000_compiled    51113.54%    47.90ps   20.88G
-filterOpSimplifiableEquiv_10x100000_vectorFunc  3761.60%   650.83ps    1.54G
-filterOpSimplifiableEquiv_10x100000_compileTime    0.40%     6.10us  164.02K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableEquiv_100x10000_reference               24.27ns   41.20M
-filterOpSimplifiableEquiv_100x10000_compiled     100.67%    24.11ns   41.48M
-filterOpSimplifiableEquiv_100x10000_vectorFunc  1099.62%     2.21ns  453.03M
-filterOpSimplifiableEquiv_100x10000_compileTime    0.40%     6.06us  165.03K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableEquiv_100x10000_reference               24.14ns   41.42M
-filterOpSimplifiableEquiv_100x10000_compiled     778.47%     3.10ns  322.42M
-filterOpSimplifiableEquiv_100x10000_vectorFunc  1200.47%     2.01ns  497.20M
-filterOpSimplifiableEquiv_100x10000_compileTime    0.39%     6.15us  162.66K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOpSimplifiableEquiv_100x10000_reference               24.88ns   40.20M
-filterOpSimplifiableEquiv_100x10000_compiled        inf%     0.00fs  Infinity
-filterOpSimplifiableEquiv_100x10000_vectorFunc   706.63%     3.52ns  284.05M
-filterOpSimplifiableEquiv_100x10000_compileTime    0.40%     6.25us  160.09K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableEquiv_100x10000_reference               24.20ns   41.32M
-filterOpSimplifiableEquiv_100x10000_compiled        inf%     0.00fs  Infinity
-filterOpSimplifiableEquiv_100x10000_vectorFunc  2694.42%   898.19ps    1.11G
-filterOpSimplifiableEquiv_100x10000_compileTime    0.40%     6.06us  164.99K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterOpSimplifiableEquiv) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterOpSimplifiableEquiv",
-      "a > 1.0 AND b != 0.0",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// similar to DISABLED_FilterOpSimplifiable but not everything is filtered out
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmpty_10x100000_referenc             33.99ns   29.42M
-filterOpSimplifiableNotEmpty_10x100000_compiled  100.04%    33.98ns   29.43M
-filterOpSimplifiableNotEmpty_10x100000_vectorFu 1573.62%     2.16ns  462.91M
-filterOpSimplifiableNotEmpty_10x100000_compileT    0.55%     6.14us  162.99K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmpty_10x100000_referenc             33.75ns   29.63M
-filterOpSimplifiableNotEmpty_10x100000_compiled  628.16%     5.37ns  186.12M
-filterOpSimplifiableNotEmpty_10x100000_vectorFu 1556.36%     2.17ns  461.15M
-filterOpSimplifiableNotEmpty_10x100000_compileT    0.54%     6.23us  160.61K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOpSimplifiableNotEmpty_10x100000_referenc             34.27ns   29.18M
-filterOpSimplifiableNotEmpty_10x100000_compiled  288.11%    11.89ns   84.08M
-filterOpSimplifiableNotEmpty_10x100000_vectorFu  298.69%    11.47ns   87.17M
-filterOpSimplifiableNotEmpty_10x100000_compileT    0.56%     6.09us  164.11K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmpty_10x100000_referenc             33.98ns   29.43M
-filterOpSimplifiableNotEmpty_10x100000_compiled 1353.86%     2.51ns  398.41M
-filterOpSimplifiableNotEmpty_10x100000_vectorFu 1728.96%     1.97ns  508.80M
-filterOpSimplifiableNotEmpty_10x100000_compileT    0.57%     5.96us  167.88K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmpty_100x10000_referenc             29.92ns   33.42M
-filterOpSimplifiableNotEmpty_100x10000_compiled  103.50%    28.91ns   34.59M
-filterOpSimplifiableNotEmpty_100x10000_vectorFu 1511.38%     1.98ns  505.15M
-filterOpSimplifiableNotEmpty_100x10000_compileT    0.49%     6.11us  163.70K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmpty_100x10000_referenc             29.22ns   34.23M
-filterOpSimplifiableNotEmpty_100x10000_compiled  452.79%     6.45ns  154.97M
-filterOpSimplifiableNotEmpty_100x10000_vectorFu 1524.63%     1.92ns  521.82M
-filterOpSimplifiableNotEmpty_100x10000_compileT    0.47%     6.21us  161.08K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOpSimplifiableNotEmpty_100x10000_referenc             29.34ns   34.08M
-filterOpSimplifiableNotEmpty_100x10000_compiled  210.71%    13.92ns   71.81M
-filterOpSimplifiableNotEmpty_100x10000_vectorFu  251.03%    11.69ns   85.56M
-filterOpSimplifiableNotEmpty_100x10000_compileT    0.48%     6.14us  162.76K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmpty_100x10000_referenc             30.20ns   33.12M
-filterOpSimplifiableNotEmpty_100x10000_compiled  707.91%     4.27ns  234.44M
-filterOpSimplifiableNotEmpty_100x10000_vectorFu 1349.02%     2.24ns  446.76M
-filterOpSimplifiableNotEmpty_100x10000_compileT    0.46%     6.53us  153.12K
- */
-TEST_F(FilterBenchmark, DISABLED_FilterOpSimplifiableNotEmpty) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterOpSimplifiableNotEmpty",
-      "a > 0.99 * b * b * b * (1.0/b) * (1.0/b) * (1.0/b)",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// logically equivalent FilterOpSimplifiable
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmptyEquiv_10x100000_ref             27.69ns   36.12M
-filterOpSimplifiableNotEmptyEquiv_10x100000_com  104.36%    26.53ns   37.69M
-filterOpSimplifiableNotEmptyEquiv_10x100000_vec 1275.78%     2.17ns  460.75M
-filterOpSimplifiableNotEmptyEquiv_10x100000_com    0.42%     6.67us  149.93K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmptyEquiv_10x100000_ref             27.05ns   36.97M
-filterOpSimplifiableNotEmptyEquiv_10x100000_com  640.23%     4.22ns  236.72M
-filterOpSimplifiableNotEmptyEquiv_10x100000_vec 1246.42%     2.17ns  460.85M
-filterOpSimplifiableNotEmptyEquiv_10x100000_com    0.43%     6.35us  157.49K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOpSimplifiableNotEmptyEquiv_10x100000_ref             27.42ns   36.47M
-filterOpSimplifiableNotEmptyEquiv_10x100000_com  571.57%     4.80ns  208.47M
-filterOpSimplifiableNotEmptyEquiv_10x100000_vec  641.54%     4.27ns  233.99M
-filterOpSimplifiableNotEmptyEquiv_10x100000_com    0.46%     5.92us  169.06K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmptyEquiv_10x100000_ref             27.35ns   36.56M
-filterOpSimplifiableNotEmptyEquiv_10x100000_com 1899.69%     1.44ns  694.48M
-filterOpSimplifiableNotEmptyEquiv_10x100000_vec 3077.93%   888.71ps    1.13G
-filterOpSimplifiableNotEmptyEquiv_10x100000_com    0.43%     6.38us  156.73K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmptyEquiv_100x10000_ref             28.03ns   35.68M
-filterOpSimplifiableNotEmptyEquiv_100x10000_com  105.47%    26.58ns   37.63M
-filterOpSimplifiableNotEmptyEquiv_100x10000_vec  552.97%     5.07ns  197.28M
-filterOpSimplifiableNotEmptyEquiv_100x10000_com    0.45%     6.18us  161.88K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmptyEquiv_100x10000_ref             26.69ns   37.47M
-filterOpSimplifiableNotEmptyEquiv_100x10000_com  511.94%     5.21ns  191.81M
-filterOpSimplifiableNotEmptyEquiv_100x10000_vec 1336.96%     2.00ns  500.93M
-filterOpSimplifiableNotEmptyEquiv_100x10000_com    0.43%     6.14us  162.98K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterOpSimplifiableNotEmptyEquiv_100x10000_ref             26.49ns   37.76M
-filterOpSimplifiableNotEmptyEquiv_100x10000_com  461.76%     5.74ns  174.34M
-filterOpSimplifiableNotEmptyEquiv_100x10000_vec  835.89%     3.17ns  315.59M
-filterOpSimplifiableNotEmptyEquiv_100x10000_com    0.41%     6.51us  153.62K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterOpSimplifiableNotEmptyEquiv_100x10000_ref             26.54ns   37.68M
-filterOpSimplifiableNotEmptyEquiv_100x10000_com  906.64%     2.93ns  341.61M
-filterOpSimplifiableNotEmptyEquiv_100x10000_vec 2509.62%     1.06ns  945.60M
-filterOpSimplifiableNotEmptyEquiv_100x10000_com    0.44%     6.05us  165.41K
- */
-TEST_F(FilterBenchmark, DISABLED_FilterOpSimplifiableNotEmptyEquiv) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterOpSimplifiableNotEmptyEquiv",
-      "a > 0.99 AND b != 0.0",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogical_10x100000_reference                           66.29ns   15.09M
-filterLogical_10x100000_compiled                  99.43%    66.67ns   15.00M
-filterLogical_10x100000_vectorFunc              3035.95%     2.18ns  458.00M
-filterLogical_10x100000_compileTime                0.98%     6.76us  147.95K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogical_10x100000_reference                           66.33ns   15.08M
-filterLogical_10x100000_compiled                 238.31%    27.83ns   35.93M
-filterLogical_10x100000_vectorFunc              1324.54%     5.01ns  199.69M
-filterLogical_10x100000_compileTime                0.95%     6.98us  143.20K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterLogical_10x100000_reference                           70.55ns   14.17M
-filterLogical_10x100000_compiled                 444.79%    15.86ns   63.05M
-filterLogical_10x100000_vectorFunc               548.60%    12.86ns   77.76M
-filterLogical_10x100000_compileTime                1.01%     6.99us  143.12K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterLogical_10x100000_reference                           68.07ns   14.69M
-filterLogical_10x100000_compiled                 433.72%    15.69ns   63.72M
-filterLogical_10x100000_vectorFunc               455.72%    14.94ns   66.95M
-filterLogical_10x100000_compileTime                0.95%     7.13us  140.18K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogical_100x10000_reference                           60.13ns   16.63M
-filterLogical_100x10000_compiled                  99.04%    60.71ns   16.47M
-filterLogical_100x10000_vectorFunc              3216.47%     1.87ns  534.95M
-filterLogical_100x10000_compileTime                0.84%     7.15us  139.85K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogical_100x10000_reference                           58.30ns   17.15M
-filterLogical_100x10000_compiled                 216.03%    26.99ns   37.06M
-filterLogical_100x10000_vectorFunc              2932.57%     1.99ns  503.03M
-filterLogical_100x10000_compileTime                0.84%     6.96us  143.76K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterLogical_100x10000_reference                           58.17ns   17.19M
-filterLogical_100x10000_compiled                 360.65%    16.13ns   62.00M
-filterLogical_100x10000_vectorFunc               446.32%    13.03ns   76.72M
-filterLogical_100x10000_compileTime                0.82%     7.07us  141.43K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterLogical_100x10000_reference                           59.31ns   16.86M
-filterLogical_100x10000_compiled                 362.69%    16.35ns   61.15M
-filterLogical_100x10000_vectorFunc               458.41%    12.94ns   77.29M
-filterLogical_100x10000_compileTime                0.83%     7.14us  140.13K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterLogical) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterLogical",
-      "((1.01*b*c/d+3.141592653)*(1.0-1.0/a) > 2.71828 AND a > 1.0) OR (1.01*b*c/d+3.141592653)*(1.0-1.0/a) <= 2.71828",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// Logically equivalent to FilterLogical: (A and B) OR (NOT A) == (NOT A) OR B
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalEquiv_10x100000_reference                      60.09ns   16.64M
-filterLogicalEquiv_10x100000_compiled            100.79%    59.62ns   16.77M
-filterLogicalEquiv_10x100000_vectorFunc         2783.08%     2.16ns  463.17M
-filterLogicalEquiv_10x100000_compileTime           0.87%     6.94us  144.09K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalEquiv_10x100000_reference                      58.25ns   17.17M
-filterLogicalEquiv_10x100000_compiled            231.64%    25.14ns   39.77M
-filterLogicalEquiv_10x100000_vectorFunc         1242.39%     4.69ns  213.30M
-filterLogicalEquiv_10x100000_compileTime           0.83%     6.99us  142.99K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterLogicalEquiv_10x100000_reference                      58.99ns   16.95M
-filterLogicalEquiv_10x100000_compiled            508.36%    11.60ns   86.18M
-filterLogicalEquiv_10x100000_vectorFunc          654.73%     9.01ns  110.99M
-filterLogicalEquiv_10x100000_compileTime           0.74%     7.92us  126.22K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterLogicalEquiv_10x100000_reference                      60.64ns   16.49M
-filterLogicalEquiv_10x100000_compiled            502.93%    12.06ns   82.93M
-filterLogicalEquiv_10x100000_vectorFunc          676.38%     8.97ns  111.54M
-filterLogicalEquiv_10x100000_compileTime           0.89%     6.85us  146.09K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalEquiv_100x10000_reference                      55.05ns   18.17M
-filterLogicalEquiv_100x10000_compiled            106.39%    51.74ns   19.33M
-filterLogicalEquiv_100x10000_vectorFunc         2868.63%     1.92ns  521.12M
-filterLogicalEquiv_100x10000_compileTime           0.80%     6.90us  144.88K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalEquiv_100x10000_reference                      54.27ns   18.43M
-filterLogicalEquiv_100x10000_compiled            228.21%    23.78ns   42.05M
-filterLogicalEquiv_100x10000_vectorFunc         3005.04%     1.81ns  553.72M
-filterLogicalEquiv_100x10000_compileTime           0.77%     7.02us  142.41K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterLogicalEquiv_100x10000_reference                      53.87ns   18.56M
-filterLogicalEquiv_100x10000_compiled            326.25%    16.51ns   60.57M
-filterLogicalEquiv_100x10000_vectorFunc          588.15%     9.16ns  109.19M
-filterLogicalEquiv_100x10000_compileTime           0.80%     6.76us  147.98K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterLogicalEquiv_100x10000_reference                      52.49ns   19.05M
-filterLogicalEquiv_100x10000_compiled            447.01%    11.74ns   85.17M
-filterLogicalEquiv_100x10000_vectorFunc          566.99%     9.26ns  108.03M
-filterLogicalEquiv_100x10000_compileTime           0.80%     6.53us  153.13K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterLogicalEquiv) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterLogicalEquiv",
-      "(1.01*b*c/d+3.14159)*(1.0-1.0/a) <= 2.71828 OR a > 1.0",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// X > num AND X <= num == FALSE
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalse_10x100000_reference                      41.78ns   23.93M
-filterLogicalFalse_10x100000_compiled             99.34%    42.06ns   23.77M
-filterLogicalFalse_10x100000_vectorFunc          897.41%     4.66ns  214.78M
-filterLogicalFalse_10x100000_compileTime           0.58%     7.19us  139.18K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalse_10x100000_reference                      42.46ns   23.55M
-filterLogicalFalse_10x100000_compiled           1006.71%     4.22ns  237.10M
-filterLogicalFalse_10x100000_vectorFunc          821.95%     5.17ns  193.58M
-filterLogicalFalse_10x100000_compileTime           0.58%     7.35us  136.12K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterLogicalFalse_10x100000_reference                      42.84ns   23.34M
-filterLogicalFalse_10x100000_compiled           4096.41%     1.05ns  956.14M
-filterLogicalFalse_10x100000_vectorFunc          405.04%    10.58ns   94.54M
-filterLogicalFalse_10x100000_compileTime           0.62%     6.86us  145.73K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalse_10x100000_reference                      42.63ns   23.46M
-filterLogicalFalse_10x100000_compiled           619489.24%     6.88ps  145.32G
-filterLogicalFalse_10x100000_vectorFunc         19817.11%   215.12ps    4.65G
-filterLogicalFalse_10x100000_compileTime           0.59%     7.19us  139.13K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalse_100x10000_reference                      36.00ns   27.78M
-filterLogicalFalse_100x10000_compiled            101.13%    35.60ns   28.09M
-filterLogicalFalse_100x10000_vectorFunc          751.11%     4.79ns  208.63M
-filterLogicalFalse_100x10000_compileTime           0.53%     6.85us  146.02K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalse_100x10000_reference                      36.24ns   27.59M
-filterLogicalFalse_100x10000_compiled            694.53%     5.22ns  191.64M
-filterLogicalFalse_100x10000_vectorFunc         1792.43%     2.02ns  494.58M
-filterLogicalFalse_100x10000_compileTime           0.51%     7.14us  140.02K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterLogicalFalse_100x10000_reference                      37.42ns   26.72M
-filterLogicalFalse_100x10000_compiled           124300.65%    30.10ps   33.22G
-filterLogicalFalse_100x10000_vectorFunc          347.88%    10.76ns   92.97M
-filterLogicalFalse_100x10000_compileTime           0.51%     7.29us  137.12K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalse_100x10000_reference                      36.21ns   27.61M
-filterLogicalFalse_100x10000_compiled               inf%     0.00fs  Infinity
-filterLogicalFalse_100x10000_vectorFunc         9395.25%   385.44ps    2.59G
-filterLogicalFalse_100x10000_compileTime           0.50%     7.18us  139.33K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterLogicalFalse) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterLogicalFalse",
-      "(1.01*b*c/d+3.141592653)*(1.0-1.0/a) > 2.71828 AND (1.01*b*c/d+3.141592653)*(1.0-1.0/a) <= 2.71828",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
-
-// logically equivalent to FilterLogicalFalse
-/*
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_reference                  0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_compiled         -nan%     0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_vectorFunc       0.00%     2.11ns  473.06M
-filterLogicalFalseEquiv_10x100000_compileTime      0.00%     5.93us  168.51K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_reference                  0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_compiled         -nan%     0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_vectorFunc       0.00%     2.01ns  497.35M
-filterLogicalFalseEquiv_10x100000_compileTime      0.00%     5.84us  171.14K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_reference                  0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_compiled         -nan%     0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_vectorFunc       -nan%     0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_compileTime      0.00%     5.79us  172.85K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_reference                  0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_compiled         -nan%     0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_vectorFunc       -nan%     0.00fs  Infinity
-filterLogicalFalseEquiv_10x100000_compileTime      0.00%     7.02us  142.38K
-
-compile filter:0,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalseEquiv_100x10000_reference                265.63ps    3.76G
-filterLogicalFalseEquiv_100x10000_compiled       110.89%   239.54ps    4.17G
-filterLogicalFalseEquiv_100x10000_vectorFunc      14.26%     1.86ns  536.70M
-filterLogicalFalseEquiv_100x10000_compileTime      0.00%     5.87us  170.26K
-compile filter:1,merge:0,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalseEquiv_100x10000_reference                224.78ps    4.45G
-filterLogicalFalseEquiv_100x10000_compiled        96.29%   233.44ps    4.28G
-filterLogicalFalseEquiv_100x10000_vectorFunc      11.90%     1.89ns  529.60M
-filterLogicalFalseEquiv_100x10000_compileTime      0.00%     5.84us  171.29K
-compile filter:1,merge:1,defaultnull:0                       0.00fs  Infinity
-filterLogicalFalseEquiv_100x10000_reference                255.93ps    3.91G
-filterLogicalFalseEquiv_100x10000_compiled          inf%     0.00fs  Infinity
-filterLogicalFalseEquiv_100x10000_vectorFunc        inf%     0.00fs  Infinity
-filterLogicalFalseEquiv_100x10000_compileTime      0.00%     5.83us  171.50K
-compile filter:1,merge:1,defaultnull:1                       0.00fs  Infinity
-filterLogicalFalseEquiv_100x10000_reference                243.58ps    4.11G
-filterLogicalFalseEquiv_100x10000_compiled          inf%     0.00fs  Infinity
-filterLogicalFalseEquiv_100x10000_vectorFunc        inf%     0.00fs  Infinity
-filterLogicalFalseEquiv_100x10000_compileTime      0.00%     5.91us  169.29K
-*/
-TEST_F(FilterBenchmark, DISABLED_FilterLogicalFalseEquiv) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "filterLogicalFalseEquiv",
-      "1 > 2",
-      {"a+1.0"},
-      inputRowType4,
-      typicalBatches,
-      defaultFilterFlags,
-      true);
-}
diff --git a/velox/experimental/codegen/benchmark/SingleOutputDefaultNullsBenchmark.cpp b/velox/experimental/codegen/benchmark/SingleOutputDefaultNullsBenchmark.cpp
deleted file mode 100644
index 9697a37030ce8..0000000000000
--- a/velox/experimental/codegen/benchmark/SingleOutputDefaultNullsBenchmark.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Benchmark.h>
-#include <folly/Random.h>
-#include <folly/init/Init.h>
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/benchmark/CodegenBenchmark.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::codegen;
-namespace {
-class SingleOutputDefaultNullsBenchmark : public BenchmarkGTest {};
-} // namespace
-
-// Note: TODO investigate, re-run and optimize  when input is not null.
-
-// 0% null:
-// ============================================================================
-// computeDepth5_1x1000000_reference                           35.34ns   28.30M
-// computeDepth5_1x1000000_compiled                 326.65%    10.82ns   92.43M
-// computeDepth5_1x1000000_vectorFunc               749.55%     4.71ns  212.09M
-// computeDepth5_1x1000000_compileTime                0.73%     4.87us  205.30K
-// computeDepth5_10x100000_reference                           13.66ns   73.22M
-// computeDepth5_10x100000_compiled                 262.13%     5.21ns  191.93M
-// computeDepth5_10x100000_vectorFunc               326.40%     4.18ns  238.98M
-// computeDepth5_10x100000_compileTime                0.28%     4.94us  202.41K
-// computeDepth5_100x10000_reference                           11.21ns   89.18M
-// computeDepth5_100x10000_compiled                 127.40%     8.80ns  113.62M
-// computeDepth5_100x10000_vectorFunc               277.88%     4.04ns  247.83M
-// computeDepth5_100x10000_compileTime                0.21%     5.34us  187.18K
-// computeDepth5_1000x1000_reference                           26.78ns   37.34M
-// computeDepth5_1000x1000_compiled                 147.23%    18.19ns   54.98M
-// computeDepth5_1000x1000_vectorFunc               686.48%     3.90ns  256.34M
-// ============================================================================
-
-/*
-DefaultNull disabled
-computeDepth5_10x100000_reference                           17.12ns   58.41M
-computeDepth5_10x100000_compiled                 163.46%    10.47ns   95.47M
-computeDepth5_10x100000_vectorFunc               164.90%    10.38ns   96.31M
-computeDepth5_10x100000_compileTime                0.29%     5.93us  168.52K
-computeDepth5_100x10000_reference                           14.03ns   71.28M
-computeDepth5_100x10000_compiled                 146.19%     9.60ns  104.21M
-computeDepth5_100x10000_vectorFunc               139.90%    10.03ns   99.72M
-computeDepth5_100x10000_compileTime                0.22%     6.28us  159.24K
-
-DefaultNull enabled
-computeDepth5_10x100000_reference                           16.89ns   59.20M
-computeDepth5_10x100000_compiled                 280.56%     6.02ns  166.09M
-computeDepth5_10x100000_vectorFunc               287.03%     5.89ns  169.92M
-computeDepth5_10x100000_compileTime                0.29%     5.76us  173.67K
-computeDepth5_100x10000_reference                           13.95ns   71.66M
-computeDepth5_100x10000_compiled                 187.44%     7.44ns  134.32M
-computeDepth5_100x10000_vectorFunc               360.24%     3.87ns  258.16M
-computeDepth5_100x10000_compileTime                0.23%     6.07us  164.84K
-*/
-TEST_F(SingleOutputDefaultNullsBenchmark, DISABLED_computeDepth5) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "computeDepth5",
-      {"a/1.1 * b* abs(c)+ 100.11"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-/*
-DefaultNull disabled
-plusThreeTimes_10x100000_reference                          10.72ns   93.33M
-plusThreeTimes_10x100000_compiled                107.66%     9.95ns  100.48M
-plusThreeTimes_10x100000_vectorFunc              151.76%     7.06ns  141.63M
-plusThreeTimes_10x100000_compileTime               0.15%     7.07us  141.39K
-plusThreeTimes_100x10000_reference                           9.65ns  103.64M
-plusThreeTimes_100x10000_compiled                 67.74%    14.24ns   70.21M
-plusThreeTimes_100x10000_vectorFunc              161.96%     5.96ns  167.86M
-plusThreeTimes_100x10000_compileTime               0.16%     6.08us  164.60K
-
-DefaultNull enabled
-plusThreeTimes_10x100000_reference                           9.76ns  102.41M
-plusThreeTimes_10x100000_compiled                165.59%     5.90ns  169.58M
-plusThreeTimes_10x100000_vectorFunc              390.51%     2.50ns  399.93M
-plusThreeTimes_10x100000_compileTime               0.15%     6.33us  158.07K
-plusThreeTimes_100x10000_reference                           8.53ns  117.30M
-plusThreeTimes_100x10000_compiled                115.63%     7.37ns  135.63M
-plusThreeTimes_100x10000_vectorFunc              233.17%     3.66ns  273.51M
-plusThreeTimes_100x10000_compileTime               0.14%     6.07us  164.66K
-*/
-TEST_F(SingleOutputDefaultNullsBenchmark, DISABLED_plusThreeTimes) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "plusThreeTimes", {"a + b + c"}, inputRowType4, typicalBatches, true);
-}
-
-/*
-DefaultNull disabled
-plus4Times_10x100000_reference                              14.75ns   67.81M
-plus4Times_10x100000_compiled                    113.97%    12.94ns   77.29M
-plus4Times_10x100000_vectorFunc                  146.25%    10.08ns   99.17M
-plus4Times_10x100000_compileTime                   0.26%     5.77us  173.45K
-plus4Times_100x10000_reference                              11.80ns   84.74M
-plus4Times_100x10000_compiled                     97.78%    12.07ns   82.86M
-plus4Times_100x10000_vectorFunc                  137.29%     8.60ns  116.34M
-plus4Times_100x10000_compileTime                   0.20%     5.87us  170.44K
-
-DefaultNull enabled
-plus4Times_10x100000_reference                              14.42ns   69.35M
-plus4Times_10x100000_compiled                    191.67%     7.52ns  132.93M
-plus4Times_10x100000_vectorFunc                  382.67%     3.77ns  265.39M
-plus4Times_10x100000_compileTime                   0.23%     6.29us  158.90K
-plus4Times_100x10000_reference                              11.50ns   86.98M
-plus4Times_100x10000_compiled                     98.19%    11.71ns   85.41M
-plus4Times_100x10000_vectorFunc                  258.13%     4.45ns  224.52M
-plus4Times_100x10000_compileTime                   0.18%     6.54us  152.96K
-*/
-TEST_F(SingleOutputDefaultNullsBenchmark, DISABLED_plus4Times) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "plus4Times", {"a + b+ c + d"}, inputRowType4, typicalBatches, true);
-}
-
-/*
-DefaultNull disabled
-plus6Times_10x100000_reference                              20.17ns   49.58M
-plus6Times_10x100000_compiled                    105.96%    19.03ns   52.54M
-plus6Times_10x100000_vectorFunc                  129.69%    15.55ns   64.30M
-plus6Times_10x100000_compileTime                   0.34%     6.00us  166.65K
-plus6Times_100x10000_reference                              16.37ns   61.07M
-plus6Times_100x10000_compiled                     87.31%    18.75ns   53.32M
-plus6Times_100x10000_vectorFunc                  107.01%    15.30ns   65.36M
-plus6Times_100x10000_compileTime                   0.27%     6.08us  164.59K
-
-DefaultNull enabled
-plus6Times_10x100000_reference                              20.72ns   48.25M
-plus6Times_10x100000_compiled                    230.29%     9.00ns  111.12M
-plus6Times_10x100000_vectorFunc                  350.54%     5.91ns  169.15M
-plus6Times_10x100000_compileTime                   0.31%     6.58us  151.87K
-plus6Times_100x10000_reference                              17.18ns   58.19M
-plus6Times_100x10000_compiled                    121.95%    14.09ns   70.96M
-plus6Times_100x10000_vectorFunc                  260.44%     6.60ns  151.55M
-plus6Times_100x10000_compileTime                   0.28%     6.05us  165.18K
-*/
-TEST_F(SingleOutputDefaultNullsBenchmark, DISABLED_plus6Times) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d", "e", "f"},
-          std::vector<TypePtr>{
-              DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "plus6Times", {"a + b+ c + d+e+f"}, inputRowType4, typicalBatches, true);
-}
-
-/*
-DefaultNull disabled
-castAdd2_10x100000_reference                                36.38ns   27.49M
-castAdd2_10x100000_compiled                      151.72%    23.98ns   41.70M
-castAdd2_10x100000_vectorFunc                    167.53%    21.72ns   46.05M
-castAdd2_10x100000_compileTime                     0.58%     6.28us  159.32K
-castAdd2_100x10000_reference                                36.79ns   27.18M
-castAdd2_100x10000_compiled                      148.13%    24.84ns   40.26M
-castAdd2_100x10000_vectorFunc                    170.09%    21.63ns   46.23M
-castAdd2_100x10000_compileTime                     0.59%     6.27us  159.38K
-
-DefaultNull enabled
-castAdd2_10x100000_reference                                36.95ns   27.06M
-castAdd2_10x100000_compiled                      178.61%    20.69ns   48.34M
-castAdd2_10x100000_vectorFunc                    250.03%    14.78ns   67.66M
-castAdd2_10x100000_compileTime                     0.57%     6.46us  154.78K
-castAdd2_100x10000_reference                                37.71ns   26.52M
-castAdd2_100x10000_compiled                      149.58%    25.21ns   39.67M
-castAdd2_100x10000_vectorFunc                    245.98%    15.33ns   65.23M
-castAdd2_100x10000_compileTime                     0.58%     6.52us  153.43K
-*/
-TEST_F(SingleOutputDefaultNullsBenchmark, DISABLED_castAdd2) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "castAdd2",
-      {"cast (a as int) + cast (b as int)"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-/*
-DefaultNull disabled
-castAdd4_10x100000_reference                                62.79ns   15.93M
-castAdd4_10x100000_compiled                      109.81%    57.18ns   17.49M
-castAdd4_10x100000_vectorFunc                    115.29%    54.46ns   18.36M
-castAdd4_10x100000_compileTime                     1.02%     6.17us  161.95K
-castAdd4_100x10000_reference                                65.34ns   15.30M
-castAdd4_100x10000_compiled                      108.49%    60.23ns   16.60M
-castAdd4_100x10000_vectorFunc                    120.07%    54.42ns   18.38M
-castAdd4_100x10000_compileTime                     1.05%     6.21us  161.12K
-
-DefaultNull enabled
-castAdd4_10x100000_reference                                64.02ns   15.62M
-castAdd4_10x100000_compiled                      185.10%    34.59ns   28.91M
-castAdd4_10x100000_vectorFunc                    197.40%    32.43ns   30.83M
-castAdd4_10x100000_compileTime                     1.01%     6.36us  157.17K
-castAdd4_100x10000_reference                                66.39ns   15.06M
-castAdd4_100x10000_compiled                      171.30%    38.76ns   25.80M
-castAdd4_100x10000_vectorFunc                    199.87%    33.22ns   30.11M
-castAdd4_100x10000_compileTime                     1.05%     6.35us  157.47K
-*/
-TEST_F(SingleOutputDefaultNullsBenchmark, DISABLED_castAdd4) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "castAdd4",
-      {"cast (a as int) + cast (b as int)+ cast (c as int)+ cast (d as int)"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
diff --git a/velox/experimental/codegen/benchmark/SingleOutputNotDefaultNullsBenchmark.cpp b/velox/experimental/codegen/benchmark/SingleOutputNotDefaultNullsBenchmark.cpp
deleted file mode 100644
index f60bc52ec0dc4..0000000000000
--- a/velox/experimental/codegen/benchmark/SingleOutputNotDefaultNullsBenchmark.cpp
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Benchmark.h>
-#include <folly/Random.h>
-#include <folly/init/Init.h>
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/benchmark/CodegenBenchmark.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::codegen;
-namespace {
-class SingleOutputNotDefaultNullsBenchmark : public BenchmarkGTest {};
-} // namespace
-
-// This is the typical situation where codegen is much slower
-// constProjection_100x10000_reference                          1.68ns  594.03M
-// constProjection_100x10000_compiled                14.59%    11.54ns   86.69M
-// constProjection_100x10000_vectorFunc              66.92%     2.52ns  397.51M
-// constProjection_100x10000_compileTime              0.03%     5.49us  182.09K
-// constProjection_1000x1000_reference                         12.03ns   83.16M
-// constProjection_1000x1000_compiled                56.63%    21.23ns   47.10M
-// constProjection_1000x1000_vectorFunc             797.90%     1.51ns  663.53M
-// constProjection_1000x1000_compileTime              0.22%     5.57us  179.39K
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_Const) {
-  auto inputRowType4 = ROW({"a"}, std::vector<TypePtr>{BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "constProjection", {"1"}, inputRowType4, typicalBatches, true);
-}
-
-// if_And3_100x10000_reference                                 49.26ns   20.30M
-// if_And3_100x10000_compiled 246.60%    19.98ns   50.06M
-// if_And3_100x10000_vectorFunc 431.59%    11.41ns   87.61M
-// if_And3_1000x1000_reference                                 59.85ns   16.71M
-// if_And3_1000x1000_compiled 297.05%    20.15ns   49.63M
-// if_And3_1000x1000_vectorFunc                     982.23%     6.09ns 164.10M
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_if_And3) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "if_And3",
-      {"if(a > b and b> c, 1, d)"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-// test2_100x10000_reference                                   22.77ns   43.91M
-// test2_100x10000_compiled                         279.81%     8.14ns 122.87M
-// test2_100x10000_vectorFunc                       954.79%     2.39ns 419.25M
-// test2_1000x1000_reference                                   33.96ns   29.44M
-// test2_1000x1000_compiled 190.01%    17.87ns   55.95M
-// test2_1000x1000_vectorFunc                       912.77%     3.72ns 268.76M
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_test2) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "test2",
-      {"if(c>d, if(a > b,1,2), 0)"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-// switchForm1_100x10000_reference                             25.67ns   38.96M
-// switchForm1_100x10000_compiled 160.88%    15.96ns   62.67M
-// switchForm1_100x10000_vectorFunc                 291.69%     8.80ns 113.63M
-// switchForm1_1000x1000_reference                             40.22ns   24.86M
-// switchForm1_1000x1000_compiled 198.32%    20.28ns   49.30M
-// switchForm1_1000x1000_vectorFunc                 658.26%     6.11ns 163.65M
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_SwitchForm1) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType, BigintType>(
-      "switchForm1",
-      {"CASE a WHEN b THEN c WHEN c THEN d WHEN d THEN b ELSE a END"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-// switchForm2Eq_100x10000_reference                           27.53ns   36.33M
-// switchForm2Eq_100x10000_compiled 173.58%    15.86ns   63.06M
-// switchForm2Eq_100x10000_vectorFunc               310.13%     8.88ns 112.66M
-// switchForm2Eq_1000x1000_reference                           40.88ns   24.46M
-// switchForm2Eq_1000x1000_compiled 193.98%    21.08ns   47.45M
-// switchForm2Eq_1000x1000_vectorFunc               688.87%     5.93ns 168.50M
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_SwitchForm2Eq) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "switchForm2Eq",
-      {"CASE WHEN a=b THEN c WHEN a=c THEN d WHEN a=d THEN b ELSE a END"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-// switchForm2NE_100x10000_reference                           34.64ns   28.86M
-// switchForm2NE_100x10000_compiled 147.47%    23.49ns   42.57M
-// switchForm2NE_100x10000_vectorFunc 252.79%    13.71ns   72.97M
-// switchForm2NE_1000x1000_reference                           43.00ns   23.25M
-// switchForm2NE_1000x1000_compiled 213.81%    20.11ns   49.72M
-// switchForm2NE_1000x1000_vectorFunc               672.54%     6.39ns 156.40M
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_SwitchForm2NE) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "switchForm2NE",
-      {"CASE WHEN a>b THEN c WHEN a>c THEN d WHEN a>d THEN b ELSE a END"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-// switchForm2Null_100x10000_reference                 23.93ns   41.79M
-// switchForm2Null_100x10000_compiled       226.51%    10.56ns   94.66M
-// switchForm2Null_100x10000_vectorFunc     929.01%     2.58ns  388.22M
-// switchForm2Null_100x10000_compileTime      0.40%     5.92us  168.79K
-// switchForm2Null_1000x1000_reference                 38.95ns   25.68M
-// switchForm2Null_1000x1000_compiled       169.56%    22.97ns   43.54M
-// switchForm2Null_1000x1000_vectorFunc    1251.10%     3.11ns  321.24M
-// switchForm2Null_1000x1000_compileTime      0.57%     6.83us  146.37K
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_SwitchForm2NULL) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{BIGINT(), BIGINT(), BIGINT(), BIGINT()});
-
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "switchForm2Null",
-      {"CASE WHEN a IS NULL THEN 0 WHEN b IS NULL THEN 1 WHEN c IS NULL THEN 2 WHEN d is NULL THEN 3 ELSE 4 END"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-// There is nothing to fuse here we expect to be at partiy
-// TODO investigate why we are slower. @ 75%
-// Velox can move a to results saving a bunch of work
-// coalesce_100x10000_reference                                 8.27ns 120.85M
-// coalesce_100x10000_compiled                       59.73%    13.85ns   72.18M
-// coalesce_100x10000_vectorFunc                    141.34%     5.85ns 170.81M
-// coalesce_1000x1000_reference                                18.30ns   54.63M
-// coalesce_1000x1000_compiled                       96.30%    19.01ns   52.61M
-// coalesce_1000x1000_vectorFunc                    361.35%     5.07ns 197.42M
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_coalesce) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "coalesce",
-      {"\"coalesce\"(a,b,c,d)"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-// AddCoalesce_100x10000_reference                             30.24ns   33.07M
-// AddCoalesce_100x10000_compiled 287.56%    10.52ns   95.09M
-// AddCoalesce_100x10000_vectorFunc 291.76%    10.36ns   96.48M
-// AddCoalesce_1000x1000_reference                             42.23ns   23.68M
-// AddCoalesce_1000x1000_compiled 220.12%    19.18ns   52.13M
-// AddCoalesce_1000x1000_vectorFunc                 749.06%     5.64ns 177.39M
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_AddCoalesce) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "AddCoalesce",
-      {"\"coalesce\"(a,0.0)+\"coalesce\"(b,0.0)+\"coalesce\"(c,0.0)+\"coalesce\"(d,0.0)"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-// test2_100x10000_reference                                   15.75ns   63.48M
-// test2_100x10000_compiled 116.46%    13.53ns   73.93M
-// test2_100x10000_vectorFunc                       160.31%     9.83ns 101.75M
-// test2_1000x1000_reference                                   28.51ns   35.07M
-// test2_1000x1000_compiled 145.48%    19.60ns   51.02M
-// test2_1000x1000_vectorFunc                       560.56%     5.09ns 196.60M
-TEST_F(SingleOutputNotDefaultNullsBenchmark, DISABLED_CoalesceAdd) {
-  auto inputRowType4 =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  benchmark.benchmarkExpressionsMult<DoubleType>(
-      "test2",
-      {"\"coalesce\"(a+b, a+c, a+d)"},
-      inputRowType4,
-      typicalBatches,
-      true);
-}
-
-//****************************************************
-// filter benchmarks
-// TODO: add test with coalesce
diff --git a/velox/experimental/codegen/benchmark/StringBenchmarks.cpp b/velox/experimental/codegen/benchmark/StringBenchmarks.cpp
deleted file mode 100644
index affce93223203..0000000000000
--- a/velox/experimental/codegen/benchmark/StringBenchmarks.cpp
+++ /dev/null
@@ -1,418 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Benchmark.h>
-#include <folly/Random.h>
-#include <folly/init/Init.h>
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/benchmark/CodegenBenchmark.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::codegen;
-class StringBenchmarks : public BenchmarkGTest {
- public:
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"str1", "str2", "str3", "double1", "double2"},
-          std::vector<TypePtr>{
-              VARCHAR(),
-              VARCHAR(),
-              VARCHAR(),
-              DOUBLE(),
-              DOUBLE()});
-};
-// Note: the last part of the file contains tests on long strings, all others
-// uses the default (max 11 char).
-//*****************************************************************************
-//**************************Lower Case Study **********************************
-//*****************************************************************************
-
-// Note: small strings < 11 char
-//============================================================================
-// lower_100x10000_reference                                   59.77ns   16.73M
-// lower_100x10000_compiled                         115.01%    51.97ns   19.24M
-// lower_100x10000_vectorFunc                       293.85%    20.34ns   49.16M
-// lower_100x10000_compileTime                        1.07%     5.59us  179.01K
-// lower_1000x1000_reference                                   60.30ns   16.58M
-// lower_1000x1000_compiled                         100.93%    59.75ns   16.74M
-// lower_1000x1000_vectorFunc                       207.23%    29.10ns   34.37M
-TEST_F(StringBenchmarks, lower) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "lower", {"lower(str1)"}, inputRowType, typicalBatches, true);
-}
-
-// Lower after disabling the inplace optimization
-//============================================================================
-// lower_100x10000_reference                                   73.58ns   13.59M
-// lower_100x10000_compiled                         143.87%    51.14ns   19.55M
-// lower_100x10000_vectorFunc                       373.33%    19.71ns   50.74M
-// lower_100x10000_compileTime                        1.34%     5.49us  182.18K
-// lower_1000x1000_reference                                   84.47ns   11.84M
-// lower_1000x1000_compiled                         132.80%    63.61ns   15.72M
-// lower_1000x1000_vectorFunc                       309.38%    27.30ns   36.62M
-//============================================================================
-
-//*****************************************************************************
-//************************* coalesceLowerUpper Case Study *********************
-//*****************************************************************************
-
-// There is better speedups with vectorFunc so it might be something with the
-// engine here that is adding overhead.
-//============================================================================
-// coalesceLowerUpper_100x10000_reference                     101.99ns    9.81M
-// coalesceLowerUpper_100x10000_compiled            160.55%    63.52ns   15.74M
-// coalesceLowerUpper_100x10000_vectorFunc          248.86%    40.98ns   24.40M
-// coalesceLowerUpper_100x10000_compileTime           1.74%     5.88us  170.13K
-// coalesceLowerUpper_1000x1000_reference                     110.81ns    9.02M
-// coalesceLowerUpper_1000x1000_compiled            151.71%    73.04ns   13.69M
-//============================================================================
-TEST_F(StringBenchmarks, coalesceLowerUpper) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "coalesceLowerUpper",
-      {"\"coalesce\"(upper(str1), lower(str2))"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// Run coalesceLowerUpper with out in place optimizations.
-//============================================================================
-// coalesceLowerUpper_100x10000_reference                     129.95ns    7.70M
-// coalesceLowerUpper_100x10000_compiled            205.27%    63.31ns   15.80M
-// coalesceLowerUpper_100x10000_vectorFunc          297.29%    43.71ns   22.88M
-// coalesceLowerUpper_100x10000_compileTime           2.15%     6.04us  165.48K
-// coalesceLowerUpper_1000x1000_reference                     142.56ns    7.01M
-// coalesceLowerUpper_1000x1000_compiled            197.54%    72.17ns   13.86M
-// coalesceLowerUpper_1000x1000_vectorFunc          281.06%    50.72ns   19.72M
-//============================================================================
-
-//*****************************************************************************
-//************************** LowerOfUpper Case Study **************************
-//*****************************************************************************
-//============================================================================
-// lowerOfUpper_100x10000_reference                            79.09ns   12.64M
-// lowerOfUpper_100x10000_compiled                  103.49%    76.42ns   13.09M
-// lowerOfUpper_100x10000_vectorFunc                215.90%    36.63ns   27.30M
-// lowerOfUpper_100x10000_compileTime                 1.47%     5.39us  185.47K
-// lowerOfUpper_1000x1000_reference                            88.90ns   11.25M
-// lowerOfUpper_1000x1000_compiled                  103.44%    85.95ns   11.63M
-// lowerOfUpper_1000x1000_vectorFunc                216.15%    41.13ns   24.31M
-//============================================================================
-TEST_F(StringBenchmarks, lowerOfUpper) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "lowerOfUpper",
-      {"lower(upper(str1))"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-// !DID NOT RERUN THIS AFTER REBASE!
-// LowerOfUpper lower after disabling inplace optimizations
-// Result : in place opt contributes to +40%-80% in velox.
-//============================================================================
-// lowerOfUpper_100x10000_reference                           112.22ns    8.91M
-// lowerOfUpper_100x10000_compiled                  143.44%    78.24ns   12.78M
-// lowerOfUpper_100x10000_vectorFunc                298.01%    37.65ns   26.56M
-// lowerOfUpper_1000x1000_reference                           124.22ns    8.05M
-// lowerOfUpper_1000x1000_compiled                  141.67%    87.68ns   11.41M
-// lowerOfUpper_1000x1000_vectorFunc                260.12%    47.75ns   20.94M
-//============================================================================
-
-// !DID NOT RERUN THIS AFTER REBASE!
-// LowerOfUpper after also disabling the ASCII propagation and the inplace.
-// Result : propagation opt contributes to 15-20% of the regression.
-// With default nulls optimizations we will be even better
-//============================================================================
-// lowerOfUpper_1x1000000_reference                            96.47ns   10.37M
-// lowerOfUpper_1x1000000_compiled                  165.00%    58.47ns   17.10M
-// lowerOfUpper_1x1000000_vectorFunc                242.44%    39.79ns   25.13M
-// lowerOfUpper_1x1000000_compileTime                 1.11%     8.73us  114.61K
-// lowerOfUpper_10x100000_reference                           116.28ns    8.60M
-// lowerOfUpper_10x100000_compiled                  199.91%    58.17ns   17.19M
-// lowerOfUpper_10x100000_vectorFunc                271.71%    42.80ns   23.37M
-// lowerOfUpper_10x100000_compileTime                 1.42%     8.21us  121.87K
-// lowerOfUpper_100x10000_reference                            95.68ns   10.45M
-// lowerOfUpper_100x10000_compiled                  180.80%    52.92ns   18.90M
-// lowerOfUpper_100x10000_vectorFunc                230.10%    41.58ns   24.05M
-// lowerOfUpper_100x10000_compileTime                 1.20%     7.97us  125.52K
-//============================================================================
-
-//*****************************************************************************
-//************************** CastString Case Study ****************************
-//*****************************************************************************
-// Had to change batch maker manually to generate
-// string that represent numbers for the tests in this case study
-// TODO: enable generating strings that represent numbers
-
-//============================================================================
-// castAndAdd_1x1000000_reference                             111.81ns    8.94M
-// castAndAdd_1x1000000_compiled                    101.86%   109.77ns    9.11M
-// castAndAdd_1x1000000_vectorFunc                  105.62%   105.87ns    9.45M
-// castAndAdd_1x1000000_compileTime                   1.46%     7.67us  130.36K
-// castAndAdd_10x100000_reference                              91.28ns   10.95M
-// castAndAdd_10x100000_compiled                     98.65%    92.53ns   10.81M
-// castAndAdd_10x100000_vectorFunc                  100.22%    91.08ns   10.98M
-// castAndAdd_10x100000_compileTime                   1.23%     7.44us  134.41K
-// castAndAdd_100x10000_reference                              98.08ns   10.20M
-// castAndAdd_100x10000_compiled                    103.35%    94.91ns   10.54M
-// castAndAdd_100x10000_vectorFunc                  105.37%    93.09ns   10.74M
-// castAndAdd_100x10000_compileTime                   1.31%     7.50us  133.35K
-//============================================================================
-TEST_F(StringBenchmarks, DISABLED_castAndAdd) {
-  // TODO: Casting fails here because str1 is not a valid double string.
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "castAndAdd",
-      {"cast(str1 as double)+ cast(str2 as double)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-//============================================================================
-// coalesceCastAndAdd_1x1_reference                           123.74us    8.08K
-// coalesceCastAndAdd_1x1_compiled                  105.98%   116.76us    8.56K
-// coalesceCastAndAdd_1x1_vectorFunc               2701.34%     4.58us  218.30K
-// coalesceCastAndAdd_1x1_compileTime                 0.00%     12.17s   82.18m
-// coalesceCastAndAdd_100000x1_reference                       27.57us   36.28K
-// coalesceCastAndAdd_100000x1_compiled             125.13%    22.03us   45.39K
-// coalesceCastAndAdd_100000x1_vectorFunc           382.34%     7.21us  138.70K
-// coalesceCastAndAdd_100000x1_compileTime           19.02%   144.96us    6.90K
-// coalesceCastAndAdd_100x10000_reference                     171.70ns    5.82M
-// coalesceCastAndAdd_100x10000_compiled             96.52%   177.90ns    5.62M
-// coalesceCastAndAdd_100x10000_vectorFunc          104.83%   163.79ns    6.11M
-// coalesceCastAndAdd_100x10000_compileTime           1.59%    10.83us   92.37K
-//============================================================================
-TEST_F(StringBenchmarks, DISABLED_coalesceCastAndAdd) {
-  // TODO: This test is failling with a exceptioon  because str1 (and possibly
-  // str2) are random string and not always convertible to double
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "coalesceCastAndAdd",
-      {"\"coalesce\"(cast(str1 as double)+ cast(str2 as double), double1+ double2)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-//*****************************************************************************
-//************************** Compare Case Study *******************************
-//*****************************************************************************
-// compare2_100x10000_reference                                 9.48ns  105.44M
-// compare2_100x10000_compiled                       94.74%    10.01ns   99.89M
-// compare2_100x10000_vectorFunc                    120.84%     7.85ns  127.41M
-// compare2_100x10000_compileTime                     0.18%     5.19us  192.66K
-// compare2_1000x1000_reference                                20.29ns   49.29M
-// compare2_1000x1000_compiled                      108.08%    18.77ns   53.27M
-// compare2_1000x1000_vectorFunc                    312.85%     6.49ns  154.19M
-//============================================================================
-TEST_F(StringBenchmarks, compare2) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "compare2", {"str1 == str2"}, inputRowType, typicalBatches, true);
-}
-
-//============================================================================
-// compare3_100x10000_reference                                23.30ns   42.91M
-// compare3_100x10000_compiled                      153.21%    15.21ns   65.74M
-// compare3_100x10000_vectorFunc                    175.40%    13.29ns   75.27M
-// compare3_100x10000_compileTime                     0.44%     5.31us  188.19K
-// compare3_1000x1000_reference                                34.37ns   29.09M
-// compare3_1000x1000_compiled                      145.36%    23.65ns   42.29M
-// compare3_1000x1000_vectorFunc                    297.81%    11.54ns   86.64M
-//============================================================================
-TEST_F(StringBenchmarks, compare3) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "compare3",
-      {"str1 == str2 and str2 == 'aaa'"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-//*****************************************************************************
-//************************** coalesce  Case Study *********************
-//*****************************************************************************
-//============================================================================
-// coalesceStrings_100x10000_reference                         29.31ns   34.12M
-// coalesceStrings_100x10000_compiled                92.83%    31.58ns   31.67M
-// coalesceStrings_100x10000_vectorFunc             219.81%    13.33ns   74.99M
-// coalesceStrings_100x10000_compileTime              0.52%     5.66us  176.75K
-// coalesceStrings_1000x1000_reference                         40.18ns   24.89M
-// coalesceStrings_1000x1000_compiled                93.15%    43.13ns   23.18M
-// coalesceStrings_1000x1000_vectorFunc             236.10%    17.02ns   58.76M
-//============================================================================
-// TODO: investigate why vectorFunc is much faster than compiled
-TEST_F(StringBenchmarks, coalesceStrings) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "coalesceStrings",
-      {"\"coalesce\"(str1, str2, str3)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-//============================================================================
-// coalesceConstant_100x10000_compileTime             0.41%     5.02us  199.07K
-// coalesceConstant_1000x1000_reference                        30.84ns   32.43M
-// coalesceConstant_1000x1000_compiled               64.65%    47.70ns   20.96M
-// coalesceConstant_1000x1000_vectorFunc            113.27%    27.23ns   36.73M
-// coalesceConstant_100x10000_reference                        20.74ns   48.23M
-// coalesceConstant_100x10000_compiled               59.31%    34.96ns   28.60M
-// coalesceConstant_100x10000_vectorFunc            125.36%    16.54ns   60.45M
-//============================================================================
-// TODO: This basically here to track the benefit of constructing constant
-// string on velox buffers which is not done yet.
-TEST_F(StringBenchmarks, coalesceStringAndConstant) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "coalesceConstant",
-      {"\"coalesce\"( 'aabbccdd', str1)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-//*****************************************************************************
-//************************** if  Case Study ***********************************
-//*****************************************************************************
-//============================================================================
-// ifString1_100x10000_reference                               67.26ns   14.87M
-// ifString1_100x10000_compiled                     163.18%    41.22ns   24.26M
-// ifString1_100x10000_vectorFunc                   298.45%    22.54ns   44.37M
-// ifString1_100x10000_compileTime                    1.29%     5.20us  192.18K
-// ifString1_1000x1000_reference                               73.86ns   13.54M
-// ifString1_1000x1000_compiled                     149.50%    49.41ns   20.24M
-// ifString1_1000x1000_vectorFunc                   347.22%    21.27ns   47.01M
-//============================================================================
-// This is not default null, why is vectorFunc much faster
-TEST_F(StringBenchmarks, ifString1) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "ifString1",
-      {"if(length(str1)> 5, str2, str3)"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-//============================================================================
-// ifString2_100x10000_reference                              106.74ns    9.37M
-// ifString2_100x10000_compiled                     147.83%    72.20ns   13.85M
-// ifString2_100x10000_vectorFunc                   213.04%    50.10ns   19.96M
-// ifString2_1000x1000_reference                              123.24ns    8.11M
-// ifString2_1000x1000_compiled                     151.57%    81.31ns   12.30M
-// ifString2_1000x1000_vectorFunc                   215.71%    57.13ns   17.50M
-//============================================================================
-
-TEST_F(StringBenchmarks, ifString2) {
-  benchmark.benchmarkExpressionsMult<BigintType>(
-      "ifString2",
-      {"if(length(str1)> 5, upper(str1), lower(str3))"},
-      inputRowType,
-      typicalBatches,
-      true);
-}
-
-//*****************************************************************************
-//************************* Larger Strings numbers ****************************
-//*****************************************************************************
-
-// !DID NOT RERUN THIS AFTER REBASE!
-// Lower with max string length 1000
-//============================================================================
-// lower_1x1000000_reference                                    1.13us  887.33K
-// lower_1x1000000_compiled                         157.84%   714.01ns    1.40M
-// lower_1x1000000_vectorFunc                       320.97%   351.12ns    2.85M
-// lower_1x1000000_compileTime                       15.21%     7.41us  134.92K
-// lower_10x100000_reference                                  596.00ns    1.68M
-// lower_10x100000_compiled                         106.83%   557.89ns    1.79M
-// lower_10x100000_vectorFunc                       180.22%   330.71ns    3.02M
-// lower_10x100000_compileTime                        7.97%     7.48us  133.71K
-// lower_100x10000_reference                                  569.93ns    1.75M
-// lower_100x10000_compiled                         117.86%   483.56ns    2.07M
-// lower_100x10000_vectorFunc                       129.77%   439.19ns    2.28M
-// lower_100x10000_compileTime                        7.64%     7.46us  134.03K
-//============================================================================
-
-// !DID NOT RERUN THIS AFTER REBASE!
-// Lower with max string length 1000 and inplace disabled
-//============================================================================
-// lower_1x1000000_reference                                    1.07us  936.65K
-// lower_1x1000000_compiled                         146.64%   728.06ns    1.37M
-// lower_1x1000000_vectorFunc                       179.19%   595.80ns    1.68M
-// lower_1x1000000_compileTime                        8.55%    12.49us   80.08K
-// lower_10x100000_reference                                  709.59ns    1.41M
-// lower_10x100000_compiled                         120.58%   588.47ns    1.70M
-// lower_10x100000_vectorFunc                       150.83%   470.47ns    2.13M
-// lower_10x100000_compileTime                        7.28%     9.75us  102.59K
-// lower_100x10000_reference                                  702.65ns    1.42M
-// lower_100x10000_compiled                         119.94%   585.81ns    1.71M
-// lower_100x10000_vectorFunc                       162.58%   432.18ns    2.31M
-// lower_100x10000_compileTime                        7.87%     8.93us  111.94K
-//============================================================================
-
-// !DID NOT RERUN THIS AFTER REBASE!
-// LowerOfUpper max 1000
-//============================================================================
-// lower_1x1000000_reference                                    1.10us  907.63K
-// lower_1x1000000_compiled                         145.32%   758.17ns    1.32M
-// lower_1x1000000_vectorFunc                       222.77%   494.57ns    2.02M
-// lower_1x1000000_compileTime                       13.94%     7.90us  126.50K
-// lower_10x100000_reference                                  566.06ns    1.77M
-// lower_10x100000_compiled                          94.84%   596.88ns    1.68M
-// lower_10x100000_vectorFunc                       139.87%   404.71ns    2.47M
-// lower_10x100000_compileTime                        6.86%     8.25us  121.18K
-// lower_100x10000_reference                                  485.99ns    2.06M
-// lower_100x10000_compiled                          93.51%   519.74ns    1.92M
-// lower_100x10000_vectorFunc                       118.88%   408.81ns    2.45M
-// lower_100x10000_compileTime                        5.93%     8.19us  122.09K
-//============================================================================
-
-// !DID NOT RERUN THIS AFTER REBASE!
-// LowerOfUpper max 1000 and propagation disabled
-//============================================================================
-// lowerOfUpper_1x1000000_reference                             1.34us  745.20K
-// lowerOfUpper_1x1000000_compiled                  170.46%   787.23ns    1.27M
-// lowerOfUpper_1x1000000_vectorFunc                246.81%   543.71ns    1.84M
-// lowerOfUpper_1x1000000_compileTime                15.41%     8.71us  114.80K
-// lowerOfUpper_10x100000_reference                             1.14us  876.90K
-// lowerOfUpper_10x100000_compiled                  166.72%   684.03ns    1.46M
-// lowerOfUpper_10x100000_vectorFunc                183.13%   622.73ns    1.61M
-// lowerOfUpper_10x100000_compileTime                12.81%     8.90us  112.34K
-// lowerOfUpper_100x10000_reference                             1.98us  504.26K
-// lowerOfUpper_100x10000_compiled                  289.88%   684.12ns    1.46M
-// lowerOfUpper_100x10000_vectorFunc                362.56%   546.97ns    1.83M
-// lowerOfUpper_100x10000_compileTime                21.99%     9.02us  110.89K
-//============================================================================
-
-// TODO 1: Investigate copying
-// TODO 2: Investigate using a global bump allocator instead of std::string
-// TODO 3: Add ascii propagation optimization
-
-// !DID NOT RERUN THIS AFTER REBASE!
-// length = 100 fixed propagation disabled and in place disabled
-//============================================================================
-// lowerOfUpper_1x1000000_reference                           347.74ns    2.88M
-// lowerOfUpper_1x1000000_compiled                  136.95%   253.91ns    3.94M
-// lowerOfUpper_1x1000000_vectorFunc                185.57%   187.38ns    5.34M
-// lowerOfUpper_1x1000000_compileTime                 4.01%     8.66us  115.45K
-// lowerOfUpper_10x100000_reference                           314.14ns    3.18M
-// lowerOfUpper_10x100000_compiled                  133.83%   234.72ns    4.26M
-// lowerOfUpper_10x100000_vectorFunc                155.68%   201.79ns    4.96M
-// lowerOfUpper_10x100000_compileTime                 3.46%     9.09us  110.02K
-// lowerOfUpper_100x10000_reference                           289.79ns    3.45M
-// lowerOfUpper_100x10000_compiled                  124.11%   233.48ns    4.28M
-// lowerOfUpper_100x10000_vectorFunc                150.24%   192.88ns    5.18M
-// lowerOfUpper_100x10000_compileTime                 3.44%     8.42us  118.76K
-//============================================================================
-
-// compare2 large strings: (max 1000)
diff --git a/velox/experimental/codegen/benchmark/TARGETS_disabled b/velox/experimental/codegen/benchmark/TARGETS_disabled
deleted file mode 100644
index 018312aab648e..0000000000000
--- a/velox/experimental/codegen/benchmark/TARGETS_disabled
+++ /dev/null
@@ -1,160 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_binary.bzl", "cpp_binary")
-load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
-
-cpp_unittest(
-    name = "velox_experimental_codegen_benchmark_default_null",
-    srcs = [
-        "SingleOutputDefaultNullsBenchmark.cpp",
-    ],
-    headers = [
-        "CodegenBenchmark.h",
-        "ValueNodeReplacer.h",
-    ],
-    linker_flags = ["--export-dynamic"],
-    deps = [
-        "//folly:benchmark",
-        "//folly:random",
-        "//folly/init:init",
-        "//velox/common/base:velox_exception",
-        "//velox/core:velox_core",
-        "//velox/exec:velox_exec_lib",
-        "//velox/experimental/codegen:velox_experimental_codegen_impl",
-        "//velox/experimental/codegen/tests:velox_experimental_codegen_test_utils",
-        "//velox/experimental/codegen/transform:velox_transform",
-        "//velox/experimental/codegen/transform/utils:velox_transform_utils",
-    ],
-)
-
-cpp_unittest(
-    name = "velox_experimental_codegen_benchmark_not_default_null",
-    srcs = [
-        "SingleOutputNotDefaultNullsBenchmark.cpp",
-    ],
-    headers = [
-        "CodegenBenchmark.h",
-        "ValueNodeReplacer.h",
-    ],
-    linker_flags = ["--export-dynamic"],
-    deps = [
-        "//folly:benchmark",
-        "//folly:random",
-        "//folly/init:init",
-        "//velox/common/base:velox_exception",
-        "//velox/core:velox_core",
-        "//velox/exec:velox_exec_lib",
-        "//velox/experimental/codegen:velox_experimental_codegen_impl",
-        "//velox/experimental/codegen/tests:velox_experimental_codegen_test_utils",
-        "//velox/experimental/codegen/transform:velox_transform",
-        "//velox/experimental/codegen/transform/utils:velox_transform_utils",
-    ],
-)
-
-cpp_unittest(
-    name = "velox_experimental_codegen_benchmark_filter",
-    srcs = [
-        "FilterBenchmark.cpp",
-    ],
-    headers = [
-        "CodegenBenchmark.h",
-        "ValueNodeReplacer.h",
-    ],
-    linker_flags = ["--export-dynamic"],
-    deps = [
-        "//folly:benchmark",
-        "//folly:random",
-        "//folly/init:init",
-        "//velox/common/base:velox_exception",
-        "//velox/core:velox_core",
-        "//velox/exec:velox_exec_lib",
-        "//velox/experimental/codegen:velox_experimental_codegen_impl",
-        "//velox/experimental/codegen/tests:velox_experimental_codegen_test_utils",
-        "//velox/experimental/codegen/transform:velox_transform",
-        "//velox/experimental/codegen/transform/utils:velox_transform_utils",
-    ],
-)
-
-cpp_unittest(
-    name = "velox_experimental_codegen_benchmark_perf",
-    srcs = [
-        "CodegenPerf.cpp",
-    ],
-    headers = [
-    ],
-    linker_flags = ["--export-dynamic"],
-    deps = [
-        "//velox/experimental/codegen/tests:velox_experimental_codegen_test_utils",
-    ],
-)
-
-cpp_unittest(
-    # @autodeps-skip
-    name = "velox_experimental_codegen_benchmark_boolean",
-    srcs = [
-        "BooleanBenchmarks.cpp",
-    ],
-    headers = [
-        "CodegenBenchmark.h",
-        "ValueNodeReplacer.h",
-    ],
-    linker_flags = ["--export-dynamic"],
-    deps = [
-        "//folly:benchmark",
-        "//velox/common/base:velox_exception",
-        "//velox/core:velox_core",
-        "//velox/experimental/codegen/code_generator/tests:copy_dependencies",  #manual
-        "//velox/experimental/codegen/tests:velox_experimental_codegen_test_utils",
-        "//velox/experimental/codegen/transform:velox_transform",
-        "//velox/experimental/codegen/transform/utils:velox_transform_utils",
-        "//velox/functions/prestosql/registration:velox_functions_prestosql",
-    ],
-)
-
-cpp_binary(
-    name = "velox_experimental_codegen_benchmark",
-    srcs = [
-        "CodegenBenchmarks.cpp",
-        "SingleOutputDefaultNullsBenchmark.cpp",
-        "SingleOutputNotDefaultNullsBenchmark.cpp",
-    ],
-    headers = [
-        "CodegenBenchmark.h",
-        "ValueNodeReplacer.h",
-    ],
-    linker_flags = ["--export-dynamic"],
-    deps = [
-        "//folly:benchmark",
-        "//folly:random",
-        "//folly/init:init",
-        "//velox/common/base:velox_exception",
-        "//velox/core:velox_core",
-        "//velox/exec:velox_exec_lib",
-        "//velox/experimental/codegen:velox_experimental_codegen_impl",
-        "//velox/experimental/codegen/tests:velox_experimental_codegen_test_utils",
-        "//velox/experimental/codegen/transform:velox_transform",
-        "//velox/experimental/codegen/transform/utils:velox_transform_utils",
-    ],
-)
-
-cpp_unittest(
-    name = "velox_experimental_codegen_benchmark_string",
-    srcs = [
-        "StringBenchmarks.cpp",
-    ],
-    headers = [
-        "CodegenBenchmark.h",
-        "ValueNodeReplacer.h",
-    ],
-    linker_flags = ["--export-dynamic"],
-    deps = [
-        "//folly:benchmark",
-        "//folly:random",
-        "//folly/init:init",
-        "//velox/common/base:velox_exception",
-        "//velox/core:velox_core",
-        "//velox/exec:velox_exec_lib",
-        "//velox/experimental/codegen:velox_experimental_codegen_impl",
-        "//velox/experimental/codegen/tests:velox_experimental_codegen_test_utils",
-        "//velox/experimental/codegen/transform:velox_transform",
-        "//velox/experimental/codegen/transform/utils:velox_transform_utils",
-    ],
-)
diff --git a/velox/experimental/codegen/benchmark/ValueNodeReplacer.h b/velox/experimental/codegen/benchmark/ValueNodeReplacer.h
deleted file mode 100644
index 3059f4e771f19..0000000000000
--- a/velox/experimental/codegen/benchmark/ValueNodeReplacer.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/experimental/codegen/transform/PlanNodeTransform.h"
-#include "velox/experimental/codegen/transform/utils/adapters.h"
-#include "velox/experimental/codegen/transform/utils/ranges_utils.h"
-#include "velox/experimental/codegen/transform/utils/utils.h"
-
-#include "velox/core/PlanNode.h"
-
-namespace facebook::velox::codegen {
-namespace {
-struct ValueNodeReplacerVisitor {
-  explicit ValueNodeReplacerVisitor(std::vector<RowVectorPtr>&& inputVector)
-      : inputVector_(std::move(inputVector)) {}
-  explicit ValueNodeReplacerVisitor(
-      const std::vector<RowVectorPtr>& inputVector)
-      : inputVector_(inputVector) {}
-  std::vector<RowVectorPtr> inputVector_;
-
-  template <typename Children>
-  std::shared_ptr<core::PlanNode> visit(
-      const core::PlanNode& planNode,
-      const Children& children) {
-    if (auto projectNode = dynamic_cast<const core::ProjectNode*>(&planNode)) {
-      return transform::utils::adapter::ProjectCopy::copyWith(
-          *projectNode,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          *ranges::begin(children));
-    };
-    if (auto filterNode = dynamic_cast<const core::FilterNode*>(&planNode)) {
-      return transform::utils::adapter::FilterCopy::copyWith(
-          *filterNode,
-          std::placeholders::_1,
-          std::placeholders::_1,
-          *ranges::begin(children));
-    };
-    if (auto valueNode = dynamic_cast<const core::ValuesNode*>(&planNode)) {
-      return std::make_shared<core::ValuesNode>(valueNode->id(), inputVector_);
-    }
-    throw std::logic_error("Unknown node type");
-  }
-};
-} // namespace
-
-struct ValueNodeReplacerTransform final : transform::PlanNodeTransform {
-  explicit ValueNodeReplacerTransform(std::vector<RowVectorPtr>&& inputVector)
-      : visitor_(std::move(inputVector)) {}
-  explicit ValueNodeReplacerTransform(
-      const std::vector<RowVectorPtr>& inputVector)
-      : visitor_(inputVector) {}
-
-  std::shared_ptr<core::PlanNode> transform(
-      const core::PlanNode& plan) override {
-    using facebook::velox::transform::utils::isomorphicTreeTransform;
-    auto nodeTransformer = [this](auto& node, const auto& transformedChildren) {
-      return visitor_.visit(node, transformedChildren);
-    };
-    auto [treeRoot, nodeMap] = isomorphicTreeTransform(plan, nodeTransformer);
-    return treeRoot;
-  }
-
-  ValueNodeReplacerVisitor visitor_;
-};
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/code_generator/CMakeLists.txt b/velox/experimental/codegen/code_generator/CMakeLists.txt
deleted file mode 100644
index ac194d74ef72a..0000000000000
--- a/velox/experimental/codegen/code_generator/CMakeLists.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_all_link STATIC)
-target_link_libraries(
-  velox_all_link
-  velox_codegen_code_generator
-  velox_codegen_utils_resource_path
-  velox_core
-  velox_parse_parser
-  velox_exec_test_lib
-  velox_functions_lib
-  velox_functions_prestosql_impl
-  Folly::folly
-  gtest
-  gtest_main
-  gflags::gflags
-  glog::glog
-  fmt::fmt)
-
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
-add_library(velox_codegen_code_generator ExprCodeGenerator.cpp)
-target_link_libraries(velox_codegen_code_generator velox_core velox_codegen_ast
-                      velox_codegen_udf_manager velox_memory)
-target_link_libraries(velox_codegen_code_generator velox_codegen_proto)
diff --git a/velox/experimental/codegen/code_generator/ExprCodeGenerator.cpp b/velox/experimental/codegen/code_generator/ExprCodeGenerator.cpp
deleted file mode 100644
index a55cf86ab9f4c..0000000000000
--- a/velox/experimental/codegen/code_generator/ExprCodeGenerator.cpp
+++ /dev/null
@@ -1,437 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/code_generator/ExprCodeGenerator.h"
-#include <memory>
-#include <optional>
-#include <sstream>
-#include "velox/experimental/codegen/ast/ASTNode.h"
-
-namespace facebook::velox {
-namespace codegen {
-
-namespace {
-
-// TODO add codgenType inside velox type traits for now we are using
-// DeepCopiedType since use the same so far
-template <TypeKind kind>
-using ConstantExpressionNodeType =
-    codegen::ConstantExpression<typename TypeTraits<kind>::DeepCopiedType>;
-
-// Helper function to convert velox variant to codegen constantExpression
-template <TypeKind kind>
-std::shared_ptr<ConstantExpressionNodeType<kind>> toCodegenConstantExpr(
-    const TypePtr& type,
-    const velox::variant& value) {
-  return std::make_shared<ConstantExpressionNodeType<kind>>(
-      ConstantExpressionNodeType<kind>(
-          type,
-          value.isNull() ? std::nullopt
-                         : std::optional{value.template value<kind>()}));
-}
-
-} // namespace
-
-__attribute__((noinline)) size_t GeneratedExpressionStruct::uniqueId() {
-  static std::atomic<size_t> counter = 0;
-  return counter++;
-};
-
-// Might throw expression is not supported
-CodegenASTNode ExprCodeGenerator::convertVeloxExpressionToCodegenAST(
-    const std::shared_ptr<const core::ITypedExpr>& node,
-    const RowType& inputRowType,
-    std::vector<bool> inputRowNullability) {
-  // inputRefExpr in velox has one child referring to the input row that do not
-  // corresponds to any node in codegen AST and does not have any useful
-  // information.
-  if (auto inputRefExpr =
-          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(node)) {
-    auto codegenNode = std::make_shared<codegen::InputRefExpr>(
-        inputRefExpr->type(),
-        inputRefExpr->name(),
-        inputRowType.getChildIdx(inputRefExpr->name()));
-    if (inputRowNullability.size() != 0) {
-      /// TODO extract this onto a separate process
-      // set nullability of inputRefExpr from inputRowNullability
-      codegenNode->setMaybeNull(inputRowNullability.at(
-          inputRowType.getChildIdx(inputRefExpr->name())));
-    }
-    return codegenNode;
-  }
-
-  // convert the children subtrees to codegen AST
-  std::vector<CodegenASTNode> codegenInputs;
-  std::vector<velox::TypeKind> inputTypes;
-
-  for (auto& input : node->inputs()) {
-    auto inputNode = convertVeloxExpressionToCodegenAST(
-        input, inputRowType, inputRowNullability);
-
-    codegenInputs.push_back(inputNode);
-    inputTypes.push_back(input->type()->kind());
-  }
-
-  // Create codegen ASTNode and connect children subtrees
-  if (auto constantExpr =
-          std::dynamic_pointer_cast<const core::ConstantTypedExpr>(node)) {
-    switch (constantExpr->type()->kind()) {
-      case TypeKind::BOOLEAN:
-        return toCodegenConstantExpr<TypeKind::BOOLEAN>(
-            constantExpr->type(), constantExpr->value());
-      case TypeKind::TINYINT:
-        return toCodegenConstantExpr<TypeKind::TINYINT>(
-            constantExpr->type(), constantExpr->value());
-      case TypeKind::SMALLINT:
-        return toCodegenConstantExpr<TypeKind::SMALLINT>(
-            constantExpr->type(), constantExpr->value());
-      case TypeKind::INTEGER:
-        return toCodegenConstantExpr<TypeKind::INTEGER>(
-            constantExpr->type(), constantExpr->value());
-      case TypeKind::BIGINT:
-        return toCodegenConstantExpr<TypeKind::BIGINT>(
-            constantExpr->type(), constantExpr->value());
-      case TypeKind::REAL:
-        return toCodegenConstantExpr<TypeKind::REAL>(
-            constantExpr->type(), constantExpr->value());
-      case TypeKind::DOUBLE:
-        return toCodegenConstantExpr<TypeKind::DOUBLE>(
-            constantExpr->type(), constantExpr->value());
-      case TypeKind::VARCHAR:
-        return toCodegenConstantExpr<TypeKind::VARCHAR>(
-            constantExpr->type(), constantExpr->value());
-      default:
-        break; // not supported otherwise
-    }
-  }
-
-  // Cast expression
-  if (auto castExpr =
-          std::dynamic_pointer_cast<const core::CastTypedExpr>(node)) {
-    // TODO: support null on failure
-    if (castExpr->nullOnFailure() == false &&
-        castExpr->type()->isFixedWidth()) {
-      auto udfInformation =
-          getCastUDF(castExpr->type()->kind(), castIntByTruncate);
-      return std::make_shared<codegen::UDFCallExpr>(
-          node->type(), udfInformation, codegenInputs);
-    }
-  }
-
-  if (auto callExpr =
-          std::dynamic_pointer_cast<const core::CallTypedExpr>(node)) {
-    // Make row expression
-    if (callExpr->name() == "row_constructor") {
-      return std::make_shared<codegen::MakeRowExpression>(
-          node->type(), codegenInputs);
-    }
-
-    // If expression
-    if (callExpr->name() == "if") {
-      if (codegenInputs.size() == 3) {
-        return std::make_shared<codegen::IfExpression>(
-            node->type(), codegenInputs[0], codegenInputs[1], codegenInputs[2]);
-      }
-
-      if (codegenInputs.size() == 2) {
-        return std::make_shared<codegen::IfExpression>(
-            node->type(), codegenInputs[0], codegenInputs[1]);
-      }
-    }
-
-    // Switch expression
-    if (callExpr->name() == "switch") {
-      return std::make_shared<codegen::SwitchExpression>(
-          node->type(), codegenInputs);
-    }
-
-    // Symbol arithmetic expressions
-    if (useBuiltInArithmetic_) {
-      if (callExpr->name() == "plus") {
-        return std::make_shared<codegen::AddExpr>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "minus") {
-        return std::make_shared<codegen::SubtractExpr>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "multiply") {
-        return std::make_shared<codegen::MultiplyExpr>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-    }
-
-    if (useBuiltInLogical_) {
-      if (callExpr->name() == "gt") {
-        return std::make_shared<codegen::GreaterThan>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "gte") {
-        return std::make_shared<codegen::GreaterThanEquel>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "lt") {
-        return std::make_shared<codegen::LessThan>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "lte") {
-        return std::make_shared<codegen::LessThanEqual>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "eq") {
-        return std::make_shared<codegen::Equal>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "neq") {
-        return std::make_shared<codegen::NotEqual>(
-            node->type(), codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "and") {
-        return std::make_shared<codegen::LogicalAnd>(
-            codegenInputs.at(0), codegenInputs.at(1));
-      }
-
-      if (callExpr->name() == "or") {
-        return std::make_shared<codegen::LogicalOr>(
-            codegenInputs.at(0), codegenInputs.at(1));
-      }
-    }
-
-    if (callExpr->name() == ("coalesce")) {
-      return std::make_shared<codegen::CoalesceExpr>(
-          node->type(), codegenInputs);
-    }
-
-    if (callExpr->name() == ("is_null")) {
-      return std::make_shared<codegen::IsNullExpr>(
-          node->type(), codegenInputs.at(0));
-    }
-
-    if (callExpr->name() == ("not")) {
-      return std::make_shared<codegen::NotExpr>(
-          node->type(), codegenInputs.at(0));
-    }
-
-    // UDF calls
-    // First check if the name is a supported argument-typed udf
-    auto udfInformation =
-        udfManager_.getUDFInformationTypedArgs(callExpr->name(), inputTypes);
-    if (udfInformation.has_value()) {
-      return std::make_shared<codegen::UDFCallExpr>(
-          node->type(), *udfInformation, codegenInputs);
-    }
-
-    // Check name only udfs
-    udfInformation = udfManager_.getUDFInformationUnTypedArgs(callExpr->name());
-    if (udfInformation.has_value()) {
-      return std::make_shared<codegen::UDFCallExpr>(
-          node->type(), *udfInformation, codegenInputs);
-    }
-  }
-
-  // Another form of "Make Row" expression
-  if (auto concatExpr =
-          std::dynamic_pointer_cast<const core::ConcatTypedExpr>(node)) {
-    return std::make_shared<codegen::MakeRowExpression>(
-        node->type(), codegenInputs);
-  }
-
-  // Translation not supported
-  throw CodegenNotSupported(fmt::format(
-      "unsupported conversion from typed expression {}\n", node->toString()));
-}
-
-// Codegen expression a codegen ASTs(rooted at MakeRowExpression)
-GeneratedExpressionStruct ExprCodeGenerator::generateCodegenExpressionStruct(
-    const codegen::MakeRowExpression& expressionTree,
-    const RowType& inputType,
-    const RowType& outputType) {
-  auto codeSnippet = expressionTree.generateCode(codeGenCtx_, "outputTuple");
-  return GeneratedExpressionStruct(
-      inputType,
-      outputType,
-      codeGenCtx_.headers(),
-      codeGenCtx_.declarations(),
-      codeSnippet.code());
-}
-
-/// Codegen expression a codegen ASTs
-GeneratedExpressionStruct ExprCodeGenerator::codegenExpression(
-    const codegen::ASTNode& expressionTree,
-    const RowType& inputType,
-    const RowType& outputType) {
-  auto codeSnippet = expressionTree.generateCode(codeGenCtx_, "outputTuple");
-  return GeneratedExpressionStruct(
-      inputType,
-      outputType,
-      codeGenCtx_.headers(),
-      codeGenCtx_.declarations(),
-      codeSnippet.code());
-}
-
-/// Codegen expression from a codegen ASTs
-/// This Overload compute the expected input row type dynamically during
-/// codegen. The user should use the generated type to pass the inputs
-/// correctly.
-GeneratedExpressionStruct ExprCodeGenerator::codegenExpression(
-    const codegen::ASTNode& expressionTree) {
-  // Mapping needs to be reset.
-  codeGenCtx_.columnNameToIndexMap().clear();
-  codeGenCtx_.setComputeInputTypeDuringCodegen(true);
-
-  auto codeSnippet = expressionTree.generateCode(codeGenCtx_, "outputTuple");
-
-  // Compute input type based on the columns encountered during the tree
-  // traversal
-  std::vector<std::string> usedColumnName(
-      codeGenCtx_.columnNameToIndexMap().size());
-  std::vector<TypePtr> usedColumnType(
-      codeGenCtx_.columnNameToIndexMap().size());
-  for (auto& [name, indexTypePair] : codeGenCtx_.columnNameToIndexMap()) {
-    usedColumnName[indexTypePair.first] = name;
-    usedColumnType[indexTypePair.first] = indexTypePair.second;
-  };
-
-  RowType inputType(std::move(usedColumnName), std::move(usedColumnType));
-  RowType outputType({""}, {expressionTree.typePtr()});
-
-  return GeneratedExpressionStruct(
-      inputType,
-      outputType,
-      codeGenCtx_.headers(),
-      codeGenCtx_.declarations(),
-      codeSnippet.code());
-}
-
-/// Codegen a velox ITypeExpression tree rooted at concatTypedExpr
-GeneratedExpressionStruct
-ExprCodeGenerator::codegenExpressionStructFromVeloxExpr(
-    const std::shared_ptr<const core::ConcatTypedExpr>& node,
-    const RowType& inputType,
-    std::vector<bool> inputRowNullability) {
-  // Set nullability to default if not provided
-  if (inputRowNullability.size() == 0 && inputType.size() != 0) {
-    inputRowNullability.resize(inputType.size(), true);
-  }
-
-  auto outputType =
-      std::dynamic_pointer_cast<const velox::RowType>(node->type());
-
-  auto codegenAST =
-      convertVeloxExpressionToCodegenAST(node, inputType, inputRowNullability);
-
-  // convert velox expression tree to codegen AST
-  auto codegenExprTree =
-      std::dynamic_pointer_cast<codegen::MakeRowExpression>(codegenAST);
-
-  // propagate nullability information
-  codegenExprTree->propagateNullability();
-
-  // validate the generated tree
-  codegenExprTree->validate();
-
-  // codegen from codegen AST
-  return generateCodegenExpressionStruct(
-      *codegenExprTree.get(), inputType, *outputType.get());
-}
-
-std::pair<std::string, std::string>
-GeneratedExpressionStruct::wrapAsExternCallable(
-    const CodegenCtx& exprCodegenCtx,
-    const std::string& readersTupleType,
-    const std::string& writersTupleType) {
-  auto invokeSymbolName =
-      fmt::format("invoke_{}_{}", expressionName_, uniqueId());
-
-  std::stringstream stream;
-  for (auto& header : exprCodegenCtx.headers()) {
-    stream << fmt::format("#include{}\n", header);
-  }
-
-  if (exprCodegenCtx.headers().count("<tuple>") == 0) {
-    stream << "#include <tuple>\n";
-  }
-
-  stream << "namespace facebook {\n namespace velox {\n";
-
-  stream << "\n" << toStruct() << "\n\n";
-
-  // Add the extern invoke method
-  stream << fmt::format(
-      "extern \"C\" void {0}(const {1}& input, {2}& output){{\n"
-      "static {3} expressionObject;\n" // keep object allocated constant alive
-      "expressionObject.invoke(input, output);}}\n",
-      invokeSymbolName,
-      readersTupleType,
-      writersTupleType,
-      expressionName_);
-
-  // Close namespace
-  stream << "}}\n";
-  return {invokeSymbolName, stream.str()};
-}
-
-// Generate a cpp file that includes the generatedExpression
-// TODO: Rename this to something more descriptive
-const std::string& GeneratedExpressionStruct::toStruct(
-    const std::string& name) const {
-  if (structCode_.has_value()) {
-    return *structCode_;
-  }
-
-  std::stringstream structCode;
-  structCode << fmt::format("struct {} {{ ", name);
-  structCode << fmt::format("using inputTupleType = {};\n", inputType_);
-
-  // Add constant declarations
-  for (auto& decl : declarations_) {
-    structCode << decl << ";\n";
-  }
-
-  // Add state class
-  structCode << fmt::format(
-      "struct State {{ codegen::TempsAllocator allocator; }} state;\n\n");
-
-  // TODO: let's templatise the invoke function;
-  structCode << fmt::format(
-      "template<typename IN,typename OUT>"
-      "inline void invoke(IN && inputTuple, OUT&& outputTuple){{ {} }}",
-      invokeFunctionBody_);
-  structCode
-      << "template<typename IN,typename OUT>" << std::endl
-      << "inline void operator()(IN && inputTuple, OUT && outputTuple) {"
-      << std::endl
-      << "invoke(std::forward<IN>(inputTuple),std::forward<OUT>(outputTuple));"
-      << std::endl
-      << "};" << std::endl;
-  structCode << "};";
-  return *(structCode_ = std::optional{structCode.str()});
-}
-
-const std::string& GeneratedExpressionStruct::toStruct() const {
-  return toStruct(expressionName_);
-}
-
-} // namespace codegen
-} // namespace facebook::velox
diff --git a/velox/experimental/codegen/code_generator/ExprCodeGenerator.h b/velox/experimental/codegen/code_generator/ExprCodeGenerator.h
deleted file mode 100644
index ceb36491f5806..0000000000000
--- a/velox/experimental/codegen/code_generator/ExprCodeGenerator.h
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <string>
-
-#include "velox/core/Expressions.h"
-#include "velox/core/ITypedExpr.h"
-#include "velox/experimental/codegen/ast/AST.h"
-#include "velox/experimental/codegen/ast/CodegenCtx.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-using CodegenASTNode = std::shared_ptr<codegen::ASTNode>;
-
-/// A class that represent a code generated from codegen AST tree to be called
-/// from operators. (Not designed mainly for expression to expression calls)
-///
-/// TODO: Update this to reflected latest changes in D26383419
-/// struct generatedExpression {
-///  using InputTupleType = ...
-///  using OutputTupleType= ...
-///
-///  void invoke(const InputType& InputTupleType, OutputTupleType& outputTuple)
-///  {
-///
-///  }
-/// };
-class GeneratedExpressionStruct {
- public:
-  GeneratedExpressionStruct(
-      const RowType& inputRowTypeArg,
-      const RowType& outputRowtTypeArg,
-      const std::unordered_set<std::string>& headers,
-      const std::vector<std::string>& declarations,
-      const std::string& invokeFunctionBody,
-      const std::string& nameSuffix_ = "")
-      : inputRowType_(inputRowTypeArg),
-        outputRowType_(outputRowtTypeArg),
-        headers_(headers),
-        inputType_(codegenUtils::codegenNativeType(
-            inputRowTypeArg,
-            codegenUtils::TypePlacement::Input)),
-        outputImplType_(codegenUtils::codegenImplTypeName(outputRowtTypeArg)),
-        inputImplType_(codegenUtils::codegenImplTypeName(inputRowTypeArg)),
-        invokeFunctionBody_(invokeFunctionBody),
-        declarations_(declarations) {
-    expressionName_ =
-        fmt::format("generatedExpression_{}_{}", nameSuffix_, uniqueId());
-  }
-
-  /// Copy constructor need to be explicitly declared because of the reference
-  /// members
-  GeneratedExpressionStruct(const GeneratedExpressionStruct& other) = default;
-  GeneratedExpressionStruct(GeneratedExpressionStruct&& other) = delete;
-
-  GeneratedExpressionStruct& operator=(GeneratedExpressionStruct&& other) =
-      delete;
-  GeneratedExpressionStruct& operator=(const GeneratedExpressionStruct& other) =
-      delete;
-
-  static size_t uniqueId();
-
-  /// Create a cpp file that contains the generated expression along with an
-  /// extern function to execute the expression. return the generated extern
-  /// function name and the cpp file content
-  std::pair<std::string, std::string> wrapAsExternCallable(
-      const CodegenCtx& exprCodegenCtx,
-      const std::string& readersTupleType,
-      const std::string& writersTupleType);
-
-  // Generate a cpp file content that includes the generatedExpression struct
-  // definition
-  const std::string& toStruct() const;
-
-  const std::string& toStruct(const std::string& name) const;
-
-  const std::string& expressionName() const {
-    return expressionName_;
-  }
-
-  const std::string& inputTypeStr() const {
-    return inputType_;
-  }
-
-  const std::string& outputImplTypeStr() const {
-    return outputImplType_;
-  }
-
-  const std::string& inputImplTypeStr() const {
-    return inputImplType_;
-  }
-
-  const RowType& inputRowType() const {
-    return inputRowType_;
-  }
-
-  const RowType& outputRowType() const {
-    return outputRowType_;
-  }
-  const std::unordered_set<std::string>& headers() const {
-    return headers_;
-  }
-
- private:
-  RowType inputRowType_;
-
-  RowType outputRowType_;
-
-  /// TODO: We should really be story full library information here instead
-  /// of just headers.
-  /// Library headers required for compilation
-  const std::unordered_set<std::string> headers_;
-
-  /// Cache the struct definition of the expression to avoid recomputation in
-  /// toStruct()
-  mutable std::optional<std::string> structCode_;
-
-  /// A unique name assigned to the generated expression (the name of the struct
-  /// )
-  std::string expressionName_;
-
-  /// Code that represent the tuple input type
-  const std::string inputType_;
-
-  /// Code that represent the Implementation output type
-  const std::string outputImplType_;
-
-  /// Code that represent the Implementation input type
-  const std::string inputImplType_;
-
-  /// Body of the expression invoke member method
-  const std::string invokeFunctionBody_;
-
-  /// Members declarations to be added to the struct
-  std::vector<std::string> declarations_;
-};
-
-/// This class provide utilities to convert a velox::typed expression to codegen
-/// AST and to convert a codegen AST to GeneratedExpressionStruct
-class ExprCodeGenerator {
- public:
-  ExprCodeGenerator(
-      const UDFManager& udfManager,
-      bool useSymbolsForArithmetic,
-      bool castIntByTruncateFlag)
-      : castIntByTruncate(castIntByTruncateFlag),
-        useBuiltInArithmetic_(useSymbolsForArithmetic),
-        udfManager_(udfManager) {}
-
-  // Codegen expression from velox::ConcatTypedExpr all the way to expression
-  // struct.
-  GeneratedExpressionStruct codegenExpressionStructFromVeloxExpr(
-      const std::shared_ptr<const core::ConcatTypedExpr>& node,
-      const RowType& inputType,
-      std::vector<bool> inputRowNullability = std::vector<bool>());
-
-  CodegenCtx& getContext() {
-    return codeGenCtx_;
-  }
-
-  // Codegen expression from a codegen AST rooted at(MakeRowExpression)
-  GeneratedExpressionStruct generateCodegenExpressionStruct(
-      const codegen::MakeRowExpression& expressionTree,
-      const RowType& inputType,
-      const RowType& outputType);
-
-  // Codegen expression from a codegen AST rooted at(OutputExpression)
-  GeneratedExpressionStruct codegenExpression(
-      const codegen::ASTNode& expressionTree,
-      const RowType& inputType,
-      const RowType& outputType);
-
-  /// Codegen expression and compute inputType;
-  GeneratedExpressionStruct codegenExpression(
-      const codegen::ASTNode& expressionTree);
-
-  // Convert velox::ITypedExpr to codegen AST
-  CodegenASTNode convertVeloxExpressionToCodegenAST(
-      const std::shared_ptr<const core::ITypedExpr>& node,
-      const RowType& inputRowType,
-      std::vector<bool> inputRowNullability = std::vector<bool>{});
-
-  bool castIntByTruncate = false;
-
- private:
-  // Whether arithmetic should be codegen using symbol expressions instead
-  // of calling Velox UDFs
-  bool useBuiltInArithmetic_ = false;
-
-  bool useBuiltInLogical_ = true;
-
-  // The appropriate UDF manager to be used during codegen AST generation
-  const UDFManager& udfManager_;
-
-  // Context used during code generation
-  CodegenCtx codeGenCtx_;
-};
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/code_generator/tests/ASTAnalysisTest.cpp b/velox/experimental/codegen/code_generator/tests/ASTAnalysisTest.cpp
deleted file mode 100644
index 32fadd4fb836a..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/ASTAnalysisTest.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/ast/ASTAnalysis.h"
-#include "velox/experimental/codegen/ast/ASTNode.h"
-#include "velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h"
-#include "velox/experimental/codegen/udf_manager/UDFManager.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox {
-namespace codegen::expressions::test {
-class ASTAnalysisTest : public ExpressionCodegenTestBase {
-  void SetUp() override {
-    ExpressionCodegenTestBase::SetUp();
-    registerVeloxArithmeticUDFs(udfManager);
-  }
-
- public:
-  template <typename InputRowTypeTrait>
-  ASTNodePtr generateCodegenAST(const std::string& expression) {
-    auto inputRowType = makeRowType(InputRowTypeTrait::veloxDynamicTypes());
-    auto untypedExpr = parse::parseExpr(expression, options_);
-    auto typedExpr = core::Expressions::inferTypes(
-        untypedExpr, inputRowType, getExecContext().pool());
-
-    auto codegenExprTree =
-        getExprCodeGenerator().convertVeloxExpressionToCodegenAST(
-            typedExpr, *inputRowType.get());
-    return codegenExprTree;
-  }
-
-  template <typename InputRowTypeTrait>
-  void testDefaultNull(
-      bool strict,
-      const std::string& expression,
-      bool expectedResult) {
-    // Create velox row type
-    auto codegenExprTree = generateCodegenAST<InputRowTypeTrait>(expression);
-    testDefaultNull(strict, *codegenExprTree.get(), expectedResult);
-  }
-
-  void testDefaultNull(
-      bool strict,
-      const ASTNode& codegenExprTree,
-      bool expectedResult) {
-    if (strict) {
-      ASSERT_EQ(
-          codegen::analysis::isDefaultNullStrict(codegenExprTree),
-          expectedResult);
-    } else {
-      ASSERT_EQ(
-          codegen::analysis::isDefaultNull(codegenExprTree), expectedResult);
-    }
-  }
-
-  template <typename InputRowTypeTrait>
-  void testFilterDefaultNull(
-      const std::string& expression,
-      bool expectedResult) {
-    // Create velox row type
-    auto codegenExprTree = generateCodegenAST<InputRowTypeTrait>(expression);
-    testFilterDefaultNull(*codegenExprTree.get(), expectedResult);
-  }
-
-  void testFilterDefaultNull(
-      const ASTNode& codegenExprTree,
-      bool expectedResult) {
-    ASSERT_EQ(
-        codegen::analysis::isFilterDefaultNull(codegenExprTree),
-        expectedResult);
-  }
-
-  parse::ParseOptions options_;
-};
-
-TEST_F(ASTAnalysisTest, DefaultNullStrict) {
-  testDefaultNull<RowTypeTrait<>>(true, "12.9", true);
-  testDefaultNull<RowTypeTrait<TypeKind::REAL>>(true, "C0", true);
-  testDefaultNull<RowTypeTrait<TypeKind::REAL, TypeKind::REAL>>(
-      true, "C0+C1", true);
-  testDefaultNull<RowTypeTrait<TypeKind::REAL, TypeKind::REAL>>(
-      true, "C0+C1*12.1", true);
-
-  testDefaultNull<RowTypeTrait<TypeKind::REAL, TypeKind::REAL>>(
-      true, "if(C0>C1, C1, C0)", false);
-  testDefaultNull<RowTypeTrait<TypeKind::REAL, TypeKind::REAL>>(
-      true, "C0+if(C0>C1, C0, C1)", false);
-}
-
-TEST_F(ASTAnalysisTest, DefaultNull) {
-  // All default null strict are default nulls
-  testDefaultNull<RowTypeTrait<>>(false, "12.9", true);
-  testDefaultNull<RowTypeTrait<TypeKind::REAL>>(false, "C0", true);
-  testDefaultNull<RowTypeTrait<TypeKind::REAL, TypeKind::REAL>>(
-      false, "C0+C1", true);
-  testDefaultNull<RowTypeTrait<TypeKind::REAL, TypeKind::REAL>>(
-      false, "C0+C1*12.1", true);
-
-  testDefaultNull<RowTypeTrait<TypeKind::REAL, TypeKind::REAL>>(
-      false, "if(C0>C1, C1, C0)", false);
-  testDefaultNull<RowTypeTrait<TypeKind::REAL, TypeKind::REAL>>(
-      false, "C0+if(C0>C1, C0, C1)", false);
-
-  // default nulls but not defaul nulls strict
-  auto udf = UDFInformation()
-                 .withNullMode(ExpressionNullMode::NullInNullOut)
-                 .withIsOptionalArguments(false)
-                 .withIsOptionalOutput(true) // nullable
-                 .withOutputForm(OutputForm::Return)
-                 .withCodegenNullInNullOutChecks(true)
-                 .withCalledFunctionName("test");
-
-  auto ast = UDFCallExpr(
-      INTEGER(),
-      udf,
-      {generateCodegenAST<RowTypeTrait<TypeKind::BIGINT>>("C0"),
-       generateCodegenAST<RowTypeTrait<TypeKind::BIGINT>>("1")});
-
-  // not strict default null
-  testDefaultNull(true, ast, false);
-  // is default null
-  testDefaultNull(false, ast, true);
-
-  // TODO: once we support udfs with such behavior add more test
-}
-
-TEST_F(ASTAnalysisTest, FilterDefaultNull) {
-  // arithmetic + comparison
-  testFilterDefaultNull<RowTypeTrait<>>("1 < 2", true);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT>>("C0 < 1", true);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>>(
-      "C0 < C1", true);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>>(
-      "C0+1 < 2*C1/C0", true);
-
-  // logical
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>>(
-      "C0 < 1 AND C1 < 2", true);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>>(
-      "NOT (C0 < 1 OR C1 < 2)", true);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT>>("NOT C0 IS NULL", true);
-
-  // non-default null
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>>(
-      "IF(C0>1,C0,C1)", false);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>>(
-      "CASE WHEN C0 > 1 THEN C0 ELSE C1 END", false);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>>(
-      "C0 IS NULL", false);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>>(
-      "COALESCE(C0,C1)", false);
-
-  // example where the current analysis is failing us, all of the exprs below
-  // are supposed to be true but can't be detected by the algorithm yet
-  // FIXME: remove these when algorithm improved
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT>>(
-      "C0 > 1 OR C0 > 1", false);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT>>(
-      "C0 > 1 AND 1 < 2", false);
-  testFilterDefaultNull<RowTypeTrait<TypeKind::BIGINT>>(
-      "C0 > 1 AND 1 is NULL", false);
-}
-} // namespace codegen::expressions::test
-}; // namespace facebook::velox
diff --git a/velox/experimental/codegen/code_generator/tests/ArithmeticFunctionsTest.cpp b/velox/experimental/codegen/code_generator/tests/ArithmeticFunctionsTest.cpp
deleted file mode 100644
index d18978e24b8e2..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/ArithmeticFunctionsTest.cpp
+++ /dev/null
@@ -1,514 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h"
-
-namespace facebook::velox {
-namespace codegen::expressions::test {
-class ArithmeticFunctionsTest : public ExpressionCodegenTestBase {
-  void SetUp() override {
-    ExpressionCodegenTestBase::SetUp();
-    registerVeloxArithmeticUDFs(udfManager);
-  }
-
- public:
-  void runPlusTests();
-  void runMinusTests();
-  void runMultiplyTests();
-};
-
-void ArithmeticFunctionsTest::runPlusTests() {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "plus(C0, C0)", {{1}, {2}, {3}}, {{2}, {4}, {6}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "plus(C0, C0)", {{1}, {2}, {3}}, {{2}, {4}, {6}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "plus(C0, C0)", {{1}, {2}, {3}}, {{2}, {4}, {6}}, true);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "plus(C0, C0)", {{1}, {2}, {3}}, {{2}, {4}, {6}}, false);
-
-  // Not nullable inputs.
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "plus(C0, 1)",
-      {{1}, {2}, {3}},
-      {{2}, {3}, {4}},
-      false /*print code*/,
-      {false} /*input rows nullability*/);
-}
-
-TEST_F(ArithmeticFunctionsTest, testPlusSymbols) {
-  this->useBuiltInForArithmetic = true;
-  runPlusTests();
-}
-
-TEST_F(ArithmeticFunctionsTest, testPlus) {
-  this->useBuiltInForArithmetic = false;
-  runPlusTests();
-}
-
-void ArithmeticFunctionsTest::runMinusTests() {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "minus(c0, c0)", {{1}, {-1}, {0}}, {{0}, {0}, {0}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "minus(c0, c0)", {{1}, {-1}, {0}}, {{0}, {0}, {0}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "minus(c0, c0)", {{1}, {-1}, {0}}, {{0}, {0}, {0}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "minus(c0, c0)", {{1}, {-1}, {0}}, {{0}, {0}, {0}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "minus(c0, 1)", {{0}, {1}, {2}}, {{-1}, {0}, {1}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "c0-10",
-      {{1}, {2}, {3}},
-      {{-9}, {-8}, {-7}},
-      false /*print code*/,
-      {false} /*input rows nullability*/);
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "1-10", {{}}, {{-9}}, false /*print code*/);
-}
-
-TEST_F(ArithmeticFunctionsTest, testMinusSymbols) {
-  this->useBuiltInForArithmetic = true;
-  runMinusTests();
-}
-
-TEST_F(ArithmeticFunctionsTest, testMinus) {
-  this->useBuiltInForArithmetic = false;
-  runMinusTests();
-}
-
-void ArithmeticFunctionsTest::runMultiplyTests() {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "multiply(C0, 1)", {{0}, {1}, {2}}, {{-0}, {1}, {2}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "multiply(C0, C0)", {{0}, {1}, {2}}, {{0}, {1}, {4}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "multiply(C0, C0)", {{0}, {1}, {2}}, {{0}, {1}, {4}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "multiply(C0, C0)", {{0}, {1}, {2}}, {{0}, {1}, {4}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "multiply(C0, C0)", {{0}, {1}, {2}}, {{0}, {1}, {4}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "C0*10",
-      {{1}, {2}, {3}},
-      {{10}, {20}, {30}},
-      false /*print code*/,
-      {false} /*input rows nullability*/);
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "1*10*10", {{}}, {{100}}, false /*print code*/);
-}
-
-TEST_F(ArithmeticFunctionsTest, testMultiplySymbols) {
-  this->useBuiltInForArithmetic = true;
-  runMultiplyTests();
-}
-
-TEST_F(ArithmeticFunctionsTest, testNullability) {
-  auto runTests = [&]() {
-    evaluateAndCompare<
-        RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT, TypeKind::BIGINT>,
-        RowTypeTrait<TypeKind::BIGINT>>(
-        "plus(C0, plus(C1, C2))",
-        {{1, 2, 3}, {2, 3, 4}, {3, std::nullopt, 5}},
-        {{6}, {9}, {std::nullopt}});
-
-    evaluateAndCompare<
-        RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT, TypeKind::BIGINT>,
-        RowTypeTrait<TypeKind::BIGINT>>(
-        "plus(C0, plus(C1, C2))",
-        {{1, 2, 3}, {2, 3, 4}, {3, std::nullopt, 5}},
-        {{6}, {9}, {std::nullopt}},
-        false /*print code*/,
-        {false, true, false} /*input rows nullability*/);
-
-    evaluateAndCompare<
-        RowTypeTrait<TypeKind::DOUBLE, TypeKind::DOUBLE, TypeKind::DOUBLE>,
-        RowTypeTrait<TypeKind::DOUBLE>>(
-        "plus(C0 + 1.0, plus(C1, C2) - 2.0)",
-        {{1.1, 2, 3}, {2.1, 3, 4}, {3, std::nullopt, 5}},
-        {{5.1}, {8.1}, {std::nullopt}},
-        false /*print code*/,
-        {false, true, false} /*input rows nullability*/);
-  };
-
-  this->useBuiltInForArithmetic = true;
-  runTests();
-
-  this->useBuiltInForArithmetic = false;
-  runTests();
-}
-
-TEST_F(ArithmeticFunctionsTest, complexExpression) {
-  auto runTests = [&]() {
-    evaluateAndCompare<
-        RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT, TypeKind::BIGINT>,
-        RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT, TypeKind::BIGINT>>(
-        "row_constructor(C0+C2, C0*C1, C2-C1+10)",
-        {{1, 2, 3}, {2, 3, 4}, {3, 5, std::nullopt}},
-        {{4, 2, 11}, {6, 6, 11}, {std::nullopt, 15, std::nullopt}});
-  };
-
-  this->useBuiltInForArithmetic = true;
-  runTests();
-
-  this->useBuiltInForArithmetic = false;
-  runTests();
-}
-
-TEST_F(ArithmeticFunctionsTest, testMultiply) {
-  this->useBuiltInForArithmetic = false;
-  runMultiplyTests();
-}
-
-TEST_F(ArithmeticFunctionsTest, testDivideUDF) {
-  this->useBuiltInForArithmetic = false;
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL, TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "divide(C0, C1)", {{0, 1}, {1, 2}, {2, 0.1}}, {{0}, {0.5}, {20}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE, TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "divide(C0, C1)", {{0, 1}, {1, 2}, {2, .1}}, {{0}, {0.5}, {20}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "divide(C0, C1)", {{0, 1}, {1, 2}, {2, 1}}, {{0}, {0}, {2}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "divide(C0, C1)", {{0, 1}, {1, 2}, {2, 1}}, {{0}, {0}, {2}});
-}
-
-TEST_F(ArithmeticFunctionsTest, testModuleUDF) {
-  this->useBuiltInForArithmetic = false;
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "modulus(C0, C1)", {{0, 1}, {1, 2}, {2, 1}}, {{0}, {1}, {0}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT, TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "modulus(C0, C1)", {{0, 1}, {1, 2}, {2, 1}}, {{0}, {1}, {0}});
-
-  auto runModuleReal = [&]() {
-    evaluateAndCompare<
-        RowTypeTrait<TypeKind::REAL, TypeKind::REAL>,
-        RowTypeTrait<TypeKind::REAL>>(
-        "modulus(C0, C1)", {{0, 1}, {1, 2}, {2, 1}}, {{0}, {1}, {0}});
-  };
-
-  // This wont even be typed by Velox
-  ASSERT_THROW(runModuleReal(), std::invalid_argument);
-}
-
-TEST_F(ArithmeticFunctionsTest, testNegateUDF) {
-  this->useBuiltInForArithmetic = false;
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "negate(C0)", {{0}, {1.1}, {-1.1}}, {{0}, {-1.1}, {1.1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "negate(C0)", {{0}, {1.1}, {-1.1}}, {{0}, {-1.1}, {1.1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "negate(C0)", {{0}, {1}, {-1}}, {{0}, {-1}, {1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "negate(C0)", {{0}, {1}, {-1}}, {{0}, {-1}, {1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "negate(C0)", {{0}, {1}, {-1}}, {{0}, {-1}, {1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "negate(C0)", {{0}, {1}, {-1}}, {{0}, {-1}, {1}});
-}
-
-TEST_F(ArithmeticFunctionsTest, testAbs) {
-  this->useBuiltInForArithmetic = false;
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "abs(C0)", {{0}, {1.1}, {-1.1}}, {{0}, {1.1}, {1.1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "abs(C0)", {{0}, {1.1}, {-1.1}}, {{0}, {1.1}, {1.1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "abs(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "abs(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "abs(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "abs(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {1}});
-}
-
-TEST_F(ArithmeticFunctionsTest, testCeil) {
-  this->useBuiltInForArithmetic = false;
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "ceil(C0)", {{0}, {1.1}, {-1.1}}, {{0}, {2}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "ceiling(C0)", {{0}, {1.1}, {-1.1}}, {{0}, {2}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "ceil(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "ceiling(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "ceil(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "ceiling(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {-1}});
-}
-
-TEST_F(ArithmeticFunctionsTest, testFloor) {
-  this->useBuiltInForArithmetic = false;
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "floor(C0)", {{0}, {1.1}, {-1.1}}, {{0}, {1}, {-2}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "floor(C0)", {{0}, {1.1}, {-1.1}}, {{0}, {1}, {-2}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "floor(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "floor(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "floor(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "floor(C0)", {{0}, {1}, {-1}}, {{0}, {1}, {-1}});
-}
-
-TEST_F(ArithmeticFunctionsTest, DISABLED_testRound) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "round(C0,cast (1 as int))", {{0}, {1.1}, {-1.1}, {1.9}, {-1.9}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "round(C0)", {{0}, {1.1}, {-1.1}, {1.9}, {-1.9}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "round(C0,cast (1 as int))", {{0}, {1.1}, {-1.1}, {1.9}, {-1.9}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "round(C0)", {{0}, {1.1}, {-1.1}, {1.9}, {-1.9}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "round(C0,cast (-1 as int))", {{32}, {13}, {-13}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "round(C0)", {{32}, {13}, {-13}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "round(C0,cast (-1 as int))", {{32}, {13}, {-13}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "round(C0)", {{32}, {13}, {-13}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "round(C0,cast (-1 as int))", {{32}, {13}, {-13}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "round(C0)", {{32}, {13}, {-13}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "round(C0,cast (-1 as int))", {{32}, {13}, {-13}, {1}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "round(C0)", {{32}, {13}, {-13}, {1}, {-1}});
-}
-
-// FIXME: This test errors on macs:
-// velox/velox/functions/prestosql/HashImpl.h:22:31: error: implicit
-// instantiation
-// of undefined template 'folly::hasher<std::__1::basic_string_view<char, \
-// std::__1::char_traits<char> >, void>'
-TEST_F(ArithmeticFunctionsTest, DISABLED_testHash) {
-  StringView input("hi welcome");
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::BIGINT>>("hash(C0)", {input});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>("hash(C0)", {3});
-
-  //   evaluateAndCompare<
-  //       RowTypeTrait<TypeKind::INTEGER>,
-  //       RowTypeTrait<TypeKind::BIGINT>>("hash(C0)", {3});
-
-  //   evaluateAndCompare<
-  //       RowTypeTrait<TypeKind::SMALLINT>,
-  //       RowTypeTrait<TypeKind::BIGINT>>("hash(C0)", {3});
-
-  //   evaluateAndCompare<
-  //       RowTypeTrait<TypeKind::TINYINT>,
-  //       RowTypeTrait<TypeKind::BIGINT>>("hash(C0)", {3});
-
-  //   evaluateAndCompare<
-  //       RowTypeTrait<TypeKind::DOUBLE>,
-  //       RowTypeTrait<TypeKind::BIGINT>>("hash(C0)", {3.1312312321});
-
-  //   evaluateAndCompare<
-  //       RowTypeTrait<TypeKind::REAL>,
-  //       RowTypeTrait<TypeKind::BIGINT>>("hash(C0)", {3.1312312321});
-}
-
-TEST_F(ArithmeticFunctionsTest, testRand) {
-  // Rand is not deterministic, this assert the function is called with some
-  // non-null results
-  checkNullPropagation<RowTypeTrait<>>("rand()", {}, {false});
-}
-
-} // namespace codegen::expressions::test
-} // namespace facebook::velox
diff --git a/velox/experimental/codegen/code_generator/tests/BasicExprCodeGeneratorTest.cpp b/velox/experimental/codegen/code_generator/tests/BasicExprCodeGeneratorTest.cpp
deleted file mode 100644
index d99b6f46bd2d2..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/BasicExprCodeGeneratorTest.cpp
+++ /dev/null
@@ -1,308 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h"
-
-namespace facebook::velox {
-namespace codegen::expressions::test {
-
-class CodegenBasicExprTest : public ExpressionCodegenTestBase {
-  void SetUp() override {
-    ExpressionCodegenTestBase::SetUp();
-    registerVeloxArithmeticUDFs(udfManager);
-  }
-};
-
-TEST_F(CodegenBasicExprTest, testConstant) {
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "1", {{}, {}, {}}, {{1}, {1}, {1}});
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::DOUBLE>>(
-      "1.0", {{}, {}, {}}, {{1.0}, {1.0}, {1.0}});
-}
-
-TEST_F(CodegenBasicExprTest, testInputRef) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>("C0", {{1}, {2}, {3}}, {{1}, {2}, {3}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT, TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::BIGINT, TypeKind::DOUBLE>>(
-      "row_constructor(C0, C1)",
-      {{1, 1.2}, {2, 1.3}, {3, 1.4}},
-      {{1, 1.2}, {2, 1.3}, {3, 1.4}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT, TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::BIGINT, TypeKind::DOUBLE, TypeKind::BIGINT>>(
-      "row_constructor(C0, C1, C0)",
-      {{std::nullopt, 1.2}, {2, 1.3}, {3, 1.4}},
-      {{std::nullopt, 1.2, std::nullopt}, {2, 1.3, 2}, {3, 1.4, 3}});
-}
-
-TEST_F(CodegenBasicExprTest, testIfExpressionNotEager) {
-  // Constant inputs
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "if((1=1), 1, 2)", {{}, {}, {}}, {{1}, {1}, {1}});
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "if((1!=1), 1, 2)", {{}, {}, {}}, {{2}, {2}, {2}});
-
-  // C0 maybe null
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "if(C0, 1, 2)",
-      {{true}, {false}, {true}},
-      {{1}, {2}, {1}},
-      false,
-      {true});
-
-  // C0 not nullable
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "if(C0, 1, 2)",
-      {{true}, {false}, {true}},
-      {{1}, {2}, {1}},
-      false,
-      {false});
-
-  // Complex if expression
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BIGINT, TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "if(if(C0, (1!=1), (1=1)), C1+C2, C1-C2)",
-      {{true, 1, 2}, {false, 10, 15}, {true, 11, 11}},
-      {{-1}, {25}, {0}});
-
-  // Not supported in Velox parser
-  //  evaluateAndCompare<
-  //      RowTypeTrait<TypeKind::BIGINT>,
-  //      RowTypeTrait<TypeKind::BIGINT>>(
-  //      "if(C0 = 1, 1)",
-  //      {{1}, {2}, {3}},
-  //      {{1}, {std::nullopt}, {std::nullopt}},
-  //      false,
-  //      {},
-  //      false);
-
-  // String type if
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::VARCHAR>>(
-      "if(C0 = 1, 'is one','not one')",
-      {{1}, {2}, {3}},
-      {{StringView("is one")},
-       {StringView("not one")},
-       {StringView("not one")}});
-}
-
-TEST_F(CodegenBasicExprTest, testSwitchExpressionNotEager) {
-  // Constant inputs form 1
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE 1 WHEN 1 THEN 1 WHEN 2 THEN 2 ELSE 3 END",
-      {{}, {}, {}},
-      {{1}, {1}, {1}},
-      false,
-      {},
-      false);
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE 2 WHEN 1 THEN 1 WHEN 2 THEN 2 ELSE 3 END",
-      {{}, {}, {}},
-      {{2}, {2}, {2}},
-      false,
-      {},
-      false);
-
-  // NULL Return
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE 3 WHEN 1 THEN 1 WHEN 2 THEN 2 END",
-      {{}, {}, {}},
-      {{}, {}, {}},
-      false,
-      {},
-      false);
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE 0 WHEN 1 THEN 1 WHEN 2 THEN 2 ELSE 3 END",
-      {{}, {}, {}},
-      {{3}, {3}, {3}},
-      false,
-      {},
-      false);
-
-  // Constant inputs form 2
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE WHEN 1=1 THEN 1 ELSE 2 END",
-      {{}, {}, {}},
-      {{1}, {1}, {1}},
-      false,
-      {},
-      false);
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE WHEN 1!=1 THEN 1 ELSE 2 END",
-      {{}, {}, {}},
-      {{2}, {2}, {2}},
-      false,
-      {},
-      false);
-
-  // C0 maybe null
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE C0 WHEN 1 THEN 1 WHEN 2 THEN 2 ELSE 3 END",
-      {{1}, {2}, {}},
-      {{1}, {2}, {3}},
-      false,
-      {true},
-      false);
-
-  // C0 not nullable
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE C0 WHEN 1 THEN 1 WHEN 2 THEN 2 ELSE 3 END",
-      {{1}, {2}, {0}},
-      {{1}, {2}, {3}},
-      false,
-      {false},
-      false);
-
-  // nested case expression
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BIGINT, TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE C0"
-      "  WHEN TRUE THEN CASE "
-      "                   WHEN C1 > 10 THEN C1 + C2 "
-      "                   ELSE C1 - C2 "
-      "                 END "
-      "  ELSE 0 "
-      "END ",
-      {{true, 1, 2}, {true, 11, 12}, {false, 10, 15}},
-      {{-1}, {23}, {0}},
-      false,
-      {false, false, false},
-      false);
-
-  // String type case
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::VARCHAR>>(
-      "CASE C0 WHEN 1 THEN 'is one' WHEN 2 THEN 'is two' ELSE 'not one or two' END",
-      {{1}, {2}, {3}},
-      {{StringView("is one")},
-       {StringView("is two")},
-       {StringView("not one or two")}},
-      false,
-      {false},
-      false);
-}
-
-TEST_F(CodegenBasicExprTest, testIsNull) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 IS NULL", {{}, {1}, {}}, {{true}, {false}, {true}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE WHEN C0 IS NULL THEN 0 ELSE 1 END",
-      {{}, {1}, {}},
-      {{0}, {1}, {0}},
-      false);
-
-  // input not nullable, another one that will cause Velox Error
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "CASE WHEN C0 IS NULL THEN 0 ELSE 1 END",
-      {{0}, {1}, {0}},
-      {{1}, {1}, {1}},
-      false,
-      {false},
-      false);
-}
-
-TEST_F(CodegenBasicExprTest, testNot) {
-  // boolean input column
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "NOT C0", {{}, {true}, {false}}, {{}, {false}, {true}}, false);
-
-  // non-boolean input column
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "NOT C0 < 1", {{}, {0}, {2}}, {{}, {false}, {true}}, false);
-}
-
-TEST_F(CodegenBasicExprTest, testCoalesce) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "\"coalesce\"(C0, cast (1 as INT))",
-      {{std::nullopt}, {2}, {std::nullopt}},
-      {{1}, {2}, {1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "\"coalesce\"(C0, cast (0 as INT))",
-      {{1}, {2}, {3}},
-      {{1}, {2}, {3}},
-      false,
-      {false});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "\"coalesce\"(C0, cast (0 as INT))",
-      {{1}, {2}, {3}},
-      {{1}, {2}, {3}},
-      false,
-      {true});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::VARCHAR>>(
-      "\"coalesce\"(C0, 'no')",
-      {StringView("yes"), StringView("maybe"), std::nullopt},
-      {StringView("yes"), StringView("maybe"), StringView("no")});
-
-  checkNullPropagation<RowTypeTrait<TypeKind::INTEGER>>(
-      "\"coalesce\"(C0, cast (1 as INT))", {true}, {false});
-
-  checkNullPropagation<RowTypeTrait<TypeKind::INTEGER>>(
-      "\"coalesce\"(C0, cast (1 as INT))", {false}, {false});
-
-  checkNullPropagation<RowTypeTrait<TypeKind::INTEGER>>(
-      "\"coalesce\"(C0, C0)", {true}, {true});
-
-  checkNullPropagation<RowTypeTrait<TypeKind::INTEGER>>(
-      "\"coalesce\"(C0, C0)", {false}, {false});
-}
-
-} // namespace codegen::expressions::test
-} // namespace facebook::velox
-// ace facebook::velox
diff --git a/velox/experimental/codegen/code_generator/tests/CMakeLists.txt b/velox/experimental/codegen/code_generator/tests/CMakeLists.txt
deleted file mode 100644
index 515b1503d9764..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/CMakeLists.txt
+++ /dev/null
@@ -1,67 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# write all cmake var in a file for post-processing
-
-set(CODEGEN_LINK_PATH "$<TARGET_FILE:velox_all_link>")
-get_directory_property(DEFINED_VARIABLE VARIABLES)
-foreach(VR IN LISTS DEFINED_VARIABLE)
-  set(CMAKE_VARS "${CMAKE_VARS}\n${VR}=${${VR}}")
-endforeach()
-
-add_executable(
-  velox_codegen_expression_test
-  BasicExprCodeGeneratorTest.cpp
-  resources/UDFTest.h
-  LogicalExpressionsTest.cpp
-  CastExpressionTest.cpp
-  ArithmeticFunctionsTest.cpp
-  StringExpressionsTest.cpp
-  UDFCallTest.cpp)
-
-target_link_libraries(
-  velox_codegen_expression_test
-  velox_codegen_code_generator
-  gtest
-  gtest_main
-  gflags::gflags
-  glog::glog
-  fmt::fmt
-  velox_core
-  velox_parse_parser
-  velox_exec_test_lib
-  velox_functions_lib
-  velox_functions_prestosql
-  velox_all_link)
-
-add_test(velox_codegen_expression_test velox_codegen_expression_test)
-
-add_executable(velox_codegen_ast_analysis_test ASTAnalysisTest.cpp)
-
-target_link_libraries(
-  velox_codegen_ast_analysis_test
-  velox_codegen_code_generator
-  gtest
-  gtest_main
-  gflags::gflags
-  glog::glog
-  fmt::fmt
-  velox_core
-  velox_parse_parser
-  velox_exec_test_lib
-  velox_functions_lib
-  velox_functions_prestosql
-  velox_all_link)
-
-add_test(velox_codegen_ast_analysis_test velox_codegen_ast_analysis_test)
diff --git a/velox/experimental/codegen/code_generator/tests/CastExpressionTest.cpp b/velox/experimental/codegen/code_generator/tests/CastExpressionTest.cpp
deleted file mode 100644
index 05b9caa9f3702..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/CastExpressionTest.cpp
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h"
-
-namespace facebook::velox {
-namespace codegen::expressions::test {
-
-class CastExprTest : public ExpressionCodegenTestBase {
-  void SetUp() override {
-    ExpressionCodegenTestBase::SetUp();
-  }
-};
-
-TEST_F(CastExprTest, castByTruncate) {
-  getExprCodeGenerator().castIntByTruncate = true;
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "cast (C0 as INT)",
-      {{1.6}, {0.9}, {-1}},
-      {1, 0, -1},
-      false,
-      {},
-      false /*compare with velox*/);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "cast (C0 as INT)",
-      {{1.1}, {0.9}, {-1}},
-      {1, 0, -1},
-      false,
-      {},
-      false /*compare with velox*/);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)",
-      {{1.6}, {0.9}, {-1}},
-      {1, 0, -1},
-      false,
-      {},
-      false /*compare with velox*/);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)",
-      {{1.1}, {0.9}, {-1}},
-      {1, 0, -1},
-      false,
-      {},
-      false /*compare with velox*/);
-}
-
-TEST_F(CastExprTest, testCastToInteger) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "cast (C0 as INT)", {{1.6}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "cast (C0 as INT)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "cast (C0 as INT)", {{2147483647}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::INTEGER>>("cast (C0 as INT)", {{23}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::INTEGER>>("cast (C0 as INT)", {{1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::INTEGER>>("cast (C0 as INT)", {{1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::INTEGER>>(
-      "cast (C0 as INT)",
-      {{StringView("100")}, {StringView("1")}, {StringView("-1")}});
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::INTEGER>>(
-      "cast ('1' as INT)", {{}, {}});
-}
-
-TEST_F(CastExprTest, testCastToBigInt) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)", {{2147483647}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)", {{23}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)", {{1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)", {{1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "cast (C0 as BIGINT)",
-      {{StringView("100")}, {StringView("1")}, {StringView("-1")}});
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::BIGINT>>(
-      "cast ('2147483647 ' as BIGINT)", {{}, {}});
-}
-
-TEST_F(CastExprTest, testCastToSmallInt) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "cast (C0 as SMALLINT)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "cast (C0 as SMALLINT)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "cast (C0 as SMALLINT)", {{12}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "cast (C0 as SMALLINT)", {{23}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "cast (C0 as SMALLINT)", {{1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "cast (C0 as SMALLINT)", {{1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::SMALLINT>>(
-      "cast (C0 as SMALLINT)",
-      {{StringView("100")}, {StringView("1")}, {StringView("-1")}});
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::SMALLINT>>(
-      "cast ('2 ' as SMALLINT)", {{}, {}});
-}
-
-TEST_F(CastExprTest, testCastToTinyInt) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "cast (C0 as TINYINT)", {{1.1}, {0.9}, {-1}}, {{1}, {1}, {-1}}, true);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "cast (C0 as TINYINT)", {{1.1}, {0.9}, {-1}}, {{1}, {1}, {-1}}, false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "cast (C0 as TINYINT)", {{43}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "cast (C0 as TINYINT)", {{23}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "cast (C0 as TINYINT)", {{1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "cast (C0 as TINYINT)", {{1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::TINYINT>>(
-      "cast (C0 as TINYINT)",
-      {{StringView("100")}, {StringView("1")}, {StringView("-1")}});
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::TINYINT>>(
-      "cast ('2 ' as TINYINT)", {{}, {}});
-}
-
-TEST_F(CastExprTest, testCastDouble) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "cast (C0 as DOUBLE)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "cast (C0 as DOUBLE)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "cast (C0 as DOUBLE)", {{43.}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "cast (C0 as DOUBLE)", {{23.12}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "cast (C0 as DOUBLE)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "cast (C0 as DOUBLE)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::DOUBLE>>(
-      "cast (C0 as DOUBLE)",
-      {{StringView("100.12")}, {StringView("0.1")}, {StringView("-1")}});
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::DOUBLE>>(
-      "cast ('2.11' as DOUBLE)", {{}, {}});
-}
-
-TEST_F(CastExprTest, testCastReal) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::REAL>>("cast (C0 as REAL)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::REAL>>("cast (C0 as REAL)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::REAL>>("cast (C0 as REAL)", {{43.}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "cast (C0 as REAL)", {{23.12}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::REAL>>("cast (C0 as REAL)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::REAL>>("cast (C0 as REAL)", {{1.1}, {0.9}, {-1}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::REAL>>(
-      "cast (C0 as REAL)",
-      {{StringView("100.12")}, {StringView("0.1")}, {StringView("-1")}});
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::REAL>>(
-      "cast ('2.11' as REAL)", {{}, {}});
-}
-} // namespace codegen::expressions::test
-} // namespace facebook::velox
diff --git a/velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h b/velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h
deleted file mode 100644
index fbe6468a3a828..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h
+++ /dev/null
@@ -1,596 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include <sstream>
-#include <stdexcept>
-#include "velox/experimental/codegen/ast/CodegenUtils.h"
-#include "velox/experimental/codegen/code_generator/ExprCodeGenerator.h"
-#include "velox/experimental/codegen/compiler_utils/CodeManager.h"
-#include "velox/experimental/codegen/compiler_utils/CompilerOptions.h"
-#include "velox/experimental/codegen/compiler_utils/tests/definitions.h"
-#include "velox/experimental/codegen/utils/resources/ResourcePath.h"
-#include "velox/experimental/codegen/vector_function/StringTypes.h"
-#include "velox/expression/Expr.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/Expressions.h"
-#include "velox/parse/ExpressionsParser.h"
-#include "velox/parse/TypeResolver.h"
-#include "velox/type/StringView.h"
-#include "velox/type/Type.h"
-#include "velox/vector/ConstantVector.h"
-
-namespace facebook::velox::codegen {
-namespace expressions::test {
-
-template <TypeKind kind>
-struct CodegenTestTypeTraits {
-  using ReaderType = std::optional<typename TypeTraits<kind>::NativeType>;
-  using WriterType = std::optional<typename TypeTraits<kind>::NativeType>;
-  using ViewType = std::optional<typename TypeTraits<kind>::NativeType>;
-  using VeloxType = typename TypeTraits<kind>::NativeType;
-  static WriterType createWriter() {
-    return WriterType{std::in_place};
-  }
-};
-
-template <>
-struct CodegenTestTypeTraits<TypeKind::VARCHAR> {
-  // Simple object with string writer interface
-  using WriterType = TempStringNullable<TempsAllocator>;
-  using ReaderType = InputReferenceStringNullable;
-  using ViewType = std::optional<StringView>;
-  using VeloxType = StringView;
-  static WriterType createWriter() {
-    static TempsAllocator allocator;
-    return WriterType{std::in_place, allocator};
-  }
-};
-
-template <TypeKind... T>
-struct RowTypeTrait {
-  // The output tuple should be of this type
-  using CodegenTupleWritersType =
-      std::tuple<typename CodegenTestTypeTraits<T>::WriterType...>;
-
-  // The input tuple should be of this type
-  using CodegenTupleReadersType =
-      std::tuple<typename CodegenTestTypeTraits<T>::ReaderType...>;
-
-  // The compared types in the tests are from this
-  using ViewTupleType =
-      std::tuple<typename CodegenTestTypeTraits<T>::ViewType...>;
-
-  // The types in velox flat vectors.
-  using VeloxTypes =
-      std::tuple<typename CodegenTestTypeTraits<T>::VeloxType...>;
-
-  static constexpr TypeKind typeKinds[] = {T...};
-
-  static std::string codegenReadersType() {
-    std::stringstream ss;
-    ss << "std::tuple<";
-
-    for (int i = 0; i < rowWidth(); i++) {
-      if (i != 0) {
-        ss << ",";
-      }
-      ss << codegenUtils::codegenNullableNativeType(
-          typeKinds[i], codegenUtils::TypePlacement::Input);
-    }
-    ss << ">";
-    return ss.str();
-  }
-
-  static CodegenTupleWritersType createWritersTuple() {
-    return std::tuple<typename CodegenTestTypeTraits<T>::WriterType...>{
-        CodegenTestTypeTraits<T>::createWriter()...};
-  }
-
-  static std::string codegenWritersType() {
-    std::stringstream ss;
-    ss << "std::tuple<";
-    for (int i = 0; i < rowWidth(); i++) {
-      if (i != 0) {
-        ss << ",";
-      }
-
-      ss << codegenUtils::codegenNullableNativeType(
-          typeKinds[i], codegenUtils::TypePlacement::Temp);
-    }
-    ss << ">";
-    return ss.str();
-  }
-
-  static CodegenTupleReadersType convertViewTupleToInput(
-      const ViewTupleType& viewTuple) {
-    CodegenTupleReadersType out;
-    convertViewTupleToInput_<0>(viewTuple, out);
-    return out;
-  }
-
-  template <int index>
-  static void convertViewTupleToInput_(
-      const ViewTupleType& viewTuple,
-      CodegenTupleReadersType& out) {
-    if constexpr (index == sizeof...(T)) {
-      return;
-    } else {
-      if constexpr (std::is_same_v<
-                        TempStringNullable<TempsAllocator>,
-                        typename std::tuple_element<
-                            index,
-                            CodegenTupleWritersType>::type>) {
-        if (std::get<index>(viewTuple).has_value()) {
-          std::get<index>(out) = InputReferenceStringNullable{
-              InputReferenceString{*std::get<index>(viewTuple)}};
-        } else {
-          std::get<index>(out) = std::nullopt;
-        }
-      } else {
-        std::get<index>(out) = std::get<index>(viewTuple);
-      }
-      convertViewTupleToInput_<index + 1>(viewTuple, out);
-    }
-  }
-
-  static ViewTupleType convertWritersTupleToViewTuple(
-      const CodegenTupleWritersType& writers) {
-    ViewTupleType out;
-    convertWritersTupleToViewTuple_<0>(writers, out);
-    return out;
-  }
-
-  template <int index>
-  static void convertWritersTupleToViewTuple_(
-      const CodegenTupleWritersType& writers,
-      ViewTupleType& out) {
-    if constexpr (index == sizeof...(T)) {
-      return;
-
-    } else {
-      if constexpr (std::is_same_v<
-                        TempStringNullable<TempsAllocator>,
-                        typename std::tuple_element<
-                            index,
-                            CodegenTupleWritersType>::type>) {
-        if (std::get<index>(writers).has_value()) {
-          auto& tempString = *std::get<index>(writers);
-          std::get<index>(out) = {
-              StringView(tempString.data(), tempString.size())};
-
-        } else {
-          std::get<index>(out) = std::nullopt;
-        }
-      } else {
-        std::get<index>(out) = std::get<index>(writers);
-      }
-      convertWritersTupleToViewTuple_<index + 1>(writers, out);
-    }
-  }
-
-  static std::vector<std::shared_ptr<const Type>> veloxDynamicTypes() {
-    return {(ScalarType<T>::create())...};
-  }
-
-  static size_t rowWidth() {
-    return sizeof...(T);
-  }
-
-  // Convert array of codegen tuple rows to array of velox flat vectors
-  static auto getViewTupleRowsAsFlatVectors(
-      const std::vector<ViewTupleType>& tupleRows,
-      core::ExecCtx* execCtx_) {
-    auto vectors = std::vector<VectorPtr>{BaseVector::create(
-        CppToType<typename TypeTraits<T>::NativeType>::create(),
-        tupleRows.size(),
-        execCtx_->pool())...};
-
-    fillVectorsData<0>(tupleRows, vectors);
-    return vectors;
-  }
-
-  // Convert array of velox flat vectors to array of tuple rows
-  static std::vector<ViewTupleType> getVectorsAsViewTupleRows(
-      const std::vector<VectorPtr>& columns) {
-    if (columns.size() == 0) {
-      return {};
-    }
-
-    std::vector<ViewTupleType> resultTuples;
-    resultTuples.resize(columns[0]->size());
-    fillTuplesData<0>(columns, resultTuples);
-    return resultTuples;
-  }
-
-  // Convert a RowVector to array of tuples
-  static std::vector<ViewTupleType> getBaseVectorsAsViewTupleRows(
-      const BaseVector* vector,
-      const SelectivityVector& rows) {
-    // Regular Row vector
-    if (auto rowVector = vector->as<RowVector>()) {
-      return getVectorsAsViewTupleRows(rowVector->children());
-    };
-
-    // Constant vector of a complex (RowVector)
-    if (auto constantVector = vector->as<ConstantVector<ComplexType>>();
-        constantVector != nullptr) {
-      if (auto rowVector = constantVector->valueVector()->as<RowVector>()) {
-        auto columns = rowVector->children();
-        if (columns.size() == 0) {
-          return {};
-        }
-
-        std::vector<ViewTupleType> resultTuples;
-        resultTuples.resize(rows.size());
-        fillTuplesDataFromFoldedConstantInput<0>(
-            columns, resultTuples, rows.size());
-        return resultTuples;
-      };
-    };
-    throw std::logic_error("Unsupported");
-  }
-
- private:
-  template <int index>
-  static void fillVectorsData(
-      const std::vector<ViewTupleType>& tupleRows,
-      std::vector<VectorPtr>& columns) {
-    if constexpr (index == sizeof...(T)) {
-      return;
-    } else {
-      auto* vector =
-          columns[index]
-              ->template asFlatVector<typename std::tuple_element<
-                  index,
-                  VeloxTypes>::type>(); // view types matches FlatVector
-                                        // native types of Velox for now
-
-      for (int i = 0; i < tupleRows.size(); i++) {
-        if (std::get<index>(tupleRows[i]).has_value()) {
-          vector->set(i, std::get<index>(tupleRows[i]).value());
-        } else {
-          vector->setNull(i, true);
-        }
-      }
-      fillVectorsData<index + 1>(tupleRows, columns);
-    }
-  }
-
-  template <int index>
-  static void fillTuplesData(
-      const std::vector<VectorPtr>& columns,
-      std::vector<ViewTupleType>& tupleRows) {
-    if constexpr (index == sizeof...(T)) {
-      return;
-    } else {
-      auto* vector = columns[index]
-                         ->template as<SimpleVector<typename std::tuple_element<
-                             index,
-                             VeloxTypes>::type>>(); // view types matches
-                                                    // SimpleVector native
-                                                    // types of Velox for now
-
-      for (auto i = 0; i < vector->size(); i++) {
-        if (vector->isNullAt(i)) {
-          std::get<index>(tupleRows[i]) = std::nullopt;
-        } else {
-          std::get<index>(tupleRows[i]) = vector->valueAt(i);
-        }
-      }
-      fillTuplesData<index + 1>(columns, tupleRows);
-    }
-  }
-
-  template <int index>
-  static void fillTuplesDataFromFoldedConstantInput(
-      const std::vector<VectorPtr>& columns,
-      std::vector<ViewTupleType>& tupleRows,
-      size_t size) {
-    if constexpr (index != sizeof...(T)) {
-      auto* vector = columns[index]
-                         ->template as<SimpleVector<typename std::tuple_element<
-                             index,
-                             VeloxTypes>::type>>(); // view types matches
-                                                    // SimpleVector native
-                                                    // types of Velox for now
-
-      for (auto i = 0; i < size; i++) {
-        if (vector->isNullAt(0)) {
-          std::get<index>(tupleRows[i]) = std::nullopt;
-        } else {
-          std::get<index>(tupleRows[i]) = vector->valueAt(0);
-        }
-      }
-      fillTuplesDataFromFoldedConstantInput<index + 1>(
-          columns, tupleRows, size);
-    }
-  }
-};
-
-// A class with utilities for testing expression codegen
-class ExpressionCodegenTestBase : public testing::Test {
- public:
-  // Given an expression, assert that the nullability of the elements of the
-  // output row matches the expected nullability
-  template <typename InputRowTypeTrait>
-  void checkNullPropagation(
-      const std::string& sqlExpression,
-      std::vector<bool> inputRowNullability,
-      std::vector<bool> expectedOutputNullability) {
-    // Create velox row type
-    auto inputRowType = makeRowType(InputRowTypeTrait::veloxDynamicTypes());
-
-    // TODO convert to VELOX_ASSERT
-    VELOX_CHECK(inputRowNullability.size() == InputRowTypeTrait::rowWidth());
-
-    // Parse expression and convert it to velox typed expression
-    auto typedConcatExpr = makeConcatTypedExpr(sqlExpression, inputRowType);
-
-    auto codegenExprTree = std::dynamic_pointer_cast<MakeRowExpression>(
-        generator_->convertVeloxExpressionToCodegenAST(
-            typedConcatExpr, *inputRowType.get(), inputRowNullability));
-
-    codegenExprTree->propagateNullability();
-    auto idx = 0;
-    for (auto child : codegenExprTree->children()) {
-      ASSERT_EQ(child->maybeNull(), expectedOutputNullability[idx]);
-      idx++;
-    }
-  }
-
-  template <typename FuncType>
-  FuncType compileAndGetFunction(
-      const std::string& cppFileContent,
-      const std::string& invokeFunctionName,
-      bool printCode) {
-    auto& compiler = codeManager_->compiler();
-    auto compiledObjectPath = compiler.compileString(
-        generator_->getContext().getLibsAsList(), cppFileContent);
-
-    auto dynamicObjectPath = compiler.link(
-        generator_->getContext().getLibsAsList(), {compiledObjectPath});
-
-    if (printCode) {
-      // TODO re-enable this option
-    }
-
-    auto& loader = codeManager_->loader();
-    auto* dynamicLibPtr = loader.uncheckedLoadLibrary(dynamicObjectPath);
-    auto* function = loader.uncheckedGetFunction<FuncType>(
-        invokeFunctionName, dynamicLibPtr);
-    return function;
-  }
-
-  /**
-   * An interface that can be used to perform e2e testing for expression
-   * codegen. InputRowTypeTrait and OutputRowTypeTrait are implemented using
-   * RowTypeTrait.
-   * @param sqlExpression input sql expression
-   * @param inputTestRows vector of native input tuples
-   * @param expectedOutputRows vector of native expected output tuples, if not
-   * empty it will be used to verify the results of codegen.
-   * @param printCode print the generated code to std::cerr
-   * @param inputRowNullability provides information about the nullability of
-   * the input schema.
-   * @param compareWithVeloxOutput weather to compare with Velox
-   * interpretation engine output
-   **/
-  template <typename InputRowTypeTrait, typename OutputRowTypeTrait>
-  void evaluateAndCompare(
-      const std::string& sqlExpression,
-      const std::vector<typename InputRowTypeTrait::ViewTupleType>&
-          inputTestRows,
-      const std::vector<typename OutputRowTypeTrait::ViewTupleType>&
-          expectedOutputRows = {},
-      bool printCode = false,
-      std::vector<bool> inputRowNullability =
-          std::vector<bool>(InputRowTypeTrait::rowWidth(), true),
-      bool compareWithVeloxOutput = true) {
-    // Create velox row type
-    auto inputRowType = makeRowType(InputRowTypeTrait::veloxDynamicTypes());
-
-    // Parse expression and convert it to velox typed expression
-    auto typedConcatExpr = makeConcatTypedExpr(sqlExpression, inputRowType);
-
-    // Validate types of the parsed expression to match expected output types
-    auto outputRowType =
-        std::dynamic_pointer_cast<const RowType>(typedConcatExpr->type());
-    auto expectedOutputTypes = OutputRowTypeTrait::veloxDynamicTypes();
-
-    for (auto i = 0; i < expectedOutputTypes.size(); i++) {
-      ASSERT_EQ(
-          expectedOutputTypes[i]->kind(), outputRowType->children()[i]->kind());
-    }
-
-    // Codegen expression
-
-    auto generatedExpression = generator_->codegenExpressionStructFromVeloxExpr(
-        typedConcatExpr, *inputRowType.get(), inputRowNullability);
-
-    // Codegen expression
-    generator_->getContext().addHeaderPath(
-        "\"velox/experimental/codegen/vector_function/StringTypes.h\"");
-    generator_->getContext().addHeaderPath("\"velox/type/StringView.h\"");
-    generator_->getContext().addHeaderPath("<tuple>");
-    std::string cppFileContent;
-    std::string invokeFunctionName;
-    std::tie(invokeFunctionName, cppFileContent) =
-        generatedExpression.wrapAsExternCallable(
-            generator_->getContext(),
-            InputRowTypeTrait::codegenReadersType(),
-            OutputRowTypeTrait::codegenWritersType());
-
-    using codegenFunctionType = void (*)(
-        const typename InputRowTypeTrait::CodegenTupleReadersType&,
-        typename OutputRowTypeTrait::CodegenTupleWritersType&);
-
-    auto* function = compileAndGetFunction<codegenFunctionType>(
-        cppFileContent, invokeFunctionName, printCode);
-
-    // Compare with expected output if provided
-    if (expectedOutputRows.size() != 0) {
-      for (auto i = 0; i < inputTestRows.size(); i++) {
-        auto output = OutputRowTypeTrait::createWritersTuple();
-        auto input =
-            InputRowTypeTrait::convertViewTupleToInput(inputTestRows[i]);
-        function(input, output);
-        auto outView =
-            OutputRowTypeTrait::convertWritersTupleToViewTuple(output);
-        ASSERT_EQ(outView, expectedOutputRows[i])
-            << "failing test when compare with expected output case index is:"
-            << i;
-      }
-    }
-
-    // Compare with Velox output
-    if (compareWithVeloxOutput) {
-      // Execute Velox path
-      facebook::velox::exec::ExprSet exprSet({typedConcatExpr}, execCtx_.get());
-      auto rows = std::make_unique<SelectivityVector>(inputTestRows.size());
-
-      auto columns = InputRowTypeTrait::getViewTupleRowsAsFlatVectors(
-          inputTestRows, execCtx_.get());
-      auto rowVector = makeRowVector(columns, inputTestRows.size());
-
-      facebook::velox::exec::EvalCtx evalCtx(
-          execCtx_.get(), &exprSet, rowVector.get());
-      std::vector<VectorPtr> result(1);
-      exprSet.eval(*rows, evalCtx, result);
-      auto resultsRows = OutputRowTypeTrait::getBaseVectorsAsViewTupleRows(
-          result[0].get(), *rows);
-
-      // Compare
-      for (auto i = 0; i < inputTestRows.size(); i++) {
-        auto output = OutputRowTypeTrait::createWritersTuple();
-        auto input =
-            InputRowTypeTrait::convertViewTupleToInput(inputTestRows[i]);
-        function(input, output);
-        auto outView =
-            OutputRowTypeTrait::convertWritersTupleToViewTuple(output);
-        ASSERT_EQ(outView, resultsRows[i])
-            << "failing test when compare with Velox case index is:" << i;
-      }
-    }
-  }
-
-  bool useBuiltInForArithmetic = false;
-
-  UDFManager udfManager;
-
-  virtual void SetUp() override {
-    codeManager_ =
-        std::make_unique<CodeManager>(getCompilerOptions(), eventSequence_);
-    generator_ = std::make_unique<ExprCodeGenerator>(
-        udfManager, useBuiltInForArithmetic, false);
-
-    // Register velox functions since parsing expression depends on them
-    functions::prestosql::registerArithmeticFunctions();
-
-    // Register type resolver with the SQL parser.
-    parse::registerTypeResolver();
-  }
-
- protected:
-  ExprCodeGenerator& getExprCodeGenerator() {
-    return *generator_;
-  }
-
-  core::ExecCtx& getExecContext() {
-    return *execCtx_;
-  }
-
-  // Create a row with names of cols C1, C2, C3 ..etc
-  std::shared_ptr<const RowType> makeRowType(
-      std::vector<std::shared_ptr<const Type>>&& types) {
-    std::vector<std::string> names;
-    for (int32_t i = 0; i < types.size(); ++i) {
-      names.push_back(fmt::format("c{}", i));
-    }
-    return ROW(std::move(names), std::move(types));
-  }
-
- private:
-  compiler_utils::CompilerOptions getCompilerOptions() {
-    std::string packageJson = ResourcePath::getResourcePath();
-
-    LOG(INFO) << std::string(packageJson) << std::endl;
-    auto defaultCompilerOptions =
-        compiler_utils::CompilerOptions::fromJsonFile(packageJson);
-    return defaultCompilerOptions;
-  }
-
-  RowVectorPtr makeRowVector(
-      const std::vector<VectorPtr>& children,
-      size_t size) {
-    std::vector<std::shared_ptr<const Type>> childTypes;
-    childTypes.resize(children.size());
-    for (int i = 0; i < children.size(); i++) {
-      childTypes[i] = children[i]->type();
-    }
-    auto rowType = makeRowType(std::move(childTypes));
-
-    return std::make_shared<RowVector>(
-        execCtx_->pool(), rowType, BufferPtr(nullptr), size, children);
-  }
-
-  // Takes a string expression as input and returns the ITypeExpression with
-  // guaranteed top level concatTypedExpr.
-  std::shared_ptr<const core::ConcatTypedExpr> makeConcatTypedExpr(
-      const std::string& text,
-      const std::shared_ptr<const RowType>& inputRowType) {
-    auto untypedExpr = parse::parseExpr(text, options_);
-    auto typedExpr = core::Expressions::inferTypes(
-        untypedExpr, inputRowType, execCtx_->pool());
-
-    if (auto callExpr =
-            std::dynamic_pointer_cast<const core::CallTypedExpr>(typedExpr)) {
-      if (callExpr->name() == "row_constructor") {
-        std::vector<std::string> names;
-        for (auto i = 0; i < typedExpr->inputs().size(); i++) {
-          names.push_back(fmt::format("c{}", names.size()));
-        }
-        return std::make_shared<core::ConcatTypedExpr>(
-            core::ConcatTypedExpr(names, typedExpr->inputs()));
-      }
-    }
-
-    if (auto concatTypedExpr =
-            std::dynamic_pointer_cast<const core::ConcatTypedExpr>(typedExpr)) {
-      return concatTypedExpr;
-    }
-
-    // add a concatTypedExpr on the top of the expression
-    return std::make_shared<const core::ConcatTypedExpr>(
-        core::ConcatTypedExpr({"c0"}, {typedExpr}));
-  }
-
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  std::unique_ptr<core::ExecCtx> execCtx_{
-      std::make_unique<facebook::velox::core::ExecCtx>(
-          pool_.get(),
-          queryCtx_.get())};
-  std::unique_ptr<CodeManager> codeManager_;
-  std::unique_ptr<ExprCodeGenerator> generator_;
-  DefaultScopedTimer::EventSequence eventSequence_;
-  parse::ParseOptions options_;
-};
-
-} // namespace expressions::test
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/code_generator/tests/LogicalExpressionsTest.cpp b/velox/experimental/codegen/code_generator/tests/LogicalExpressionsTest.cpp
deleted file mode 100644
index 556c7f460bf44..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/LogicalExpressionsTest.cpp
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h"
-
-namespace facebook::velox {
-namespace codegen::expressions::test {
-
-class LogicalExprTest : public ExpressionCodegenTestBase {
-  void SetUp() override {
-    ExpressionCodegenTestBase::SetUp();
-    registerVeloxArithmeticUDFs(udfManager);
-  }
-};
-
-TEST_F(LogicalExprTest, testGt) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 > C1",
-      {{0, 1}, {1, 0}, {1, std::nullopt}},
-      {{false}, {true}, {std::nullopt}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL, TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 > C1",
-      {{0, 1}, {1, 0}, {1, std::nullopt}},
-      {{false}, {true}, {std::nullopt}});
-}
-
-TEST_F(LogicalExprTest, testLt) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 < C1",
-      {{0, 1}, {1, 0}, {1, std::nullopt}},
-      {{true}, {false}, {std::nullopt}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL, TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 < C1",
-      {{0, 1}, {1, 0}, {1, std::nullopt}},
-      {{true}, {false}, {std::nullopt}});
-}
-
-TEST_F(LogicalExprTest, testGte) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 >= C1",
-      {{0, 1}, {0, 0}, {1, std::nullopt}},
-      {{false}, {true}, {std::nullopt}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL, TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 >= C1",
-      {{0, 1}, {0, 0}, {1, std::nullopt}},
-      {{false}, {true}, {std::nullopt}});
-}
-
-TEST_F(LogicalExprTest, testLte) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 <= C1",
-      {{0, 1}, {0, 0}, {1, std::nullopt}},
-      {{true}, {true}, {std::nullopt}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL, TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 <= C1",
-      {{0, 1}, {0, 0}, {1, std::nullopt}},
-      {{true}, {true}, {std::nullopt}});
-}
-
-TEST_F(LogicalExprTest, testEq) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 = C1",
-      {{0, 1}, {0, 0}, {1, std::nullopt}},
-      {{false}, {true}, {std::nullopt}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL, TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 = C1",
-      {{0, 1}, {0, 0}, {1, std::nullopt}},
-      {{false}, {true}, {std::nullopt}});
-}
-
-TEST_F(LogicalExprTest, testNeq) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 != C1",
-      {{0, 1}, {0, 0}, {1, std::nullopt}},
-      {{true}, {false}, {std::nullopt}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL, TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 != C1",
-      {{0, 1}, {0, 0}, {1, std::nullopt}},
-      {{true}, {false}, {std::nullopt}});
-}
-
-TEST_F(LogicalExprTest, testAnd) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 and C1",
-      {{true, true},
-       {true, false},
-       {true, std::nullopt},
-       {false, true},
-       {false, false},
-       {false, std::nullopt},
-       {std::nullopt, true},
-       {std::nullopt, false},
-       {std::nullopt, std::nullopt}},
-      {{true},
-       {false},
-       {std::nullopt},
-       {false},
-       {false},
-       {false},
-       {std::nullopt},
-       {false},
-       {std::nullopt}},
-      true);
-
-  // Not nullable Inputs
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 and C1",
-      {{true, true}, {true, false}, {false, true}, {false, false}},
-      {{true}, {false}, {false}, {false}},
-      false,
-      {false, false});
-
-  // Not nullable lhs
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 and C1",
-      {{true, true},
-       {true, false},
-       {true, std::nullopt},
-       {false, true},
-       {false, false},
-       {false, std::nullopt}},
-      {{true}, {false}, {std::nullopt}, {false}, {false}, {false}},
-      false,
-      {false, true});
-
-  // Not nullable rhs
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 and C1",
-      {{true, true},
-       {true, false},
-       {false, true},
-       {false, false},
-       {std::nullopt, true},
-       {std::nullopt, false}},
-      {{true}, {false}, {false}, {false}, {std::nullopt}, {false}},
-      false,
-      {true, false});
-}
-
-TEST_F(LogicalExprTest, testOr) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 or C1",
-      {{true, true},
-       {true, false},
-       {true, std::nullopt},
-       {false, true},
-       {false, false},
-       {false, std::nullopt},
-       {std::nullopt, true},
-       {std::nullopt, false},
-       {std::nullopt, std::nullopt}},
-      {{true},
-       {true},
-       {true},
-       {true},
-       {false},
-       {std::nullopt},
-       {true},
-       {std::nullopt},
-       {std::nullopt}});
-
-  // Not nullable Inputs
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 or C1",
-      {{true, true}, {true, false}, {false, true}, {false, false}},
-      {{true}, {true}, {true}, {false}});
-
-  // Not nullable lhs
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 or C1",
-      {{true, true},
-       {true, false},
-       {true, std::nullopt},
-       {false, true},
-       {false, false},
-       {false, std::nullopt}},
-      {{true}, {true}, {true}, {true}, {false}, std::nullopt},
-      false,
-      {false, true});
-
-  // Not nullable rhs
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BOOLEAN, TypeKind::BOOLEAN>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 or C1",
-      {{true, true},
-       {true, false},
-       {false, true},
-       {false, false},
-       {std::nullopt, true},
-       {std::nullopt, false}},
-      {{true}, {true}, {true}, {false}, {true}, {std::nullopt}},
-      false,
-      {true, false});
-}
-
-TEST_F(LogicalExprTest, testBetween) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::INTEGER>,
-      RowTypeTrait<TypeKind::BOOLEAN>>("C0 between 3 and 4", {{3}, {4}, {5}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::BIGINT>,
-      RowTypeTrait<TypeKind::BOOLEAN>>("C0 between 3 and 4", {{3}, {4}, {5}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::TINYINT>,
-      RowTypeTrait<TypeKind::BOOLEAN>>("C0 between 3 and 4", {{3}, {4}, {5}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::SMALLINT>,
-      RowTypeTrait<TypeKind::BOOLEAN>>("C0 between 3 and 4", {{3}, {4}, {5}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::DOUBLE>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 between 3.0 and 4.0", {{3}, {4}, {5}});
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::REAL>,
-      RowTypeTrait<TypeKind::BOOLEAN>>(
-      "C0 between 3.0 and 4.0", {{3}, {4}, {5}});
-}
-
-} // namespace codegen::expressions::test
-} // namespace facebook::velox
diff --git a/velox/experimental/codegen/code_generator/tests/StringExpressionsTest.cpp b/velox/experimental/codegen/code_generator/tests/StringExpressionsTest.cpp
deleted file mode 100644
index 99c27ee0cb391..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/StringExpressionsTest.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h"
-namespace facebook::velox {
-namespace codegen::expressions::test {
-
-class StringExprTest : public ExpressionCodegenTestBase {
-  void SetUp() override {
-    ExpressionCodegenTestBase::SetUp();
-    registerVeloxArithmeticUDFs(udfManager);
-    registerVeloxStringFunctions(udfManager);
-  }
-};
-
-TEST_F(StringExprTest, testStringConstant) {
-  StringView str("1.0");
-
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::VARCHAR>>(
-      "'1.0'", {{}}, {{str}}, true);
-
-  std::string longString =
-      "*************************************not-inlined-string*********************************************";
-  evaluateAndCompare<RowTypeTrait<>, RowTypeTrait<TypeKind::VARCHAR>>(
-      fmt::format("'{}'", longString), {{}}, {{StringView(longString)}});
-}
-
-TEST_F(StringExprTest, ifString) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR, TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::VARCHAR, TypeKind::VARCHAR>>(
-      "row_constructor(C0,C1)",
-      {{StringView("one"), StringView("two")},
-       {StringView("one"), StringView("two")},
-       {StringView("one"), StringView("two")}});
-}
-
-TEST_F(StringExprTest, coalesceString) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR, TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::VARCHAR>>(
-      "\"coalesce\"(C0, C1, '3')",
-      {{std::nullopt, StringView("2")},
-       {StringView("1"), std::nullopt},
-       {std::nullopt, std::nullopt}},
-      {{StringView("2")}, {StringView("1")}, {StringView("3")}},
-      true);
-}
-
-TEST_F(StringExprTest, upperString) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::VARCHAR>>(
-      "upper(C0)",
-      {std::nullopt,
-       StringView("ascii"),
-       StringView("àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ")},
-      {std::nullopt,
-       StringView("ASCII"),
-       StringView("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ")},
-      true);
-}
-
-TEST_F(StringExprTest, lowerString) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::VARCHAR>>(
-      "lower(C0)",
-      {std::nullopt,
-       StringView("ASCII"),
-       StringView("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ")},
-      {std::nullopt,
-       StringView("ascii"),
-       StringView("àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ")},
-      false);
-}
-
-TEST_F(StringExprTest, concatString) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::VARCHAR>>(
-      "concat(C0, C0)",
-      {std::nullopt,
-       StringView("ASCII"),
-       StringView("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ")},
-      {std::nullopt,
-       StringView("ASCIIASCII"),
-       StringView(
-           "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ")},
-      false);
-
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR, TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::VARCHAR>>(
-      "concat(C0, '+', C1)",
-      {{std::nullopt, StringView("1")},
-       {StringView("1"), StringView("2")},
-       {StringView("1"), std::nullopt}});
-}
-
-TEST_F(StringExprTest, length) {
-  evaluateAndCompare<
-      RowTypeTrait<TypeKind::VARCHAR>,
-      RowTypeTrait<TypeKind::BIGINT>>(
-      "length(C0)",
-      {std::nullopt,
-       StringView("ASCII"),
-       StringView("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ")});
-}
-
-} // namespace codegen::expressions::test
-} // namespace facebook::velox
diff --git a/velox/experimental/codegen/code_generator/tests/UDFCallTest.cpp b/velox/experimental/codegen/code_generator/tests/UDFCallTest.cpp
deleted file mode 100644
index 915af1d651ea1..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/UDFCallTest.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/experimental/codegen/code_generator/tests/CodegenExpressionsTestBase.h"
-
-namespace facebook::velox {
-namespace codegen::expressions::test {
-
-class UDFCallExpressionTest : public ExpressionCodegenTestBase {
- public:
-  // The type of the input rows in the tests
-  using TestInputRowTypeTraits =
-      RowTypeTrait<TypeKind::INTEGER, TypeKind::INTEGER>;
-
-  // The type of the output row in the tests
-  using TestOutputRowTypeTraits = RowTypeTrait<TypeKind::INTEGER>;
-
-  // Test inputs
-  std::vector<TestInputRowTypeTraits::ViewTupleType> inputTestRows = {
-      {1, 2},
-      {1, 4},
-      {{}, 1},
-      {{}, {}},
-      {1, {}},
-  };
-
-  // Expected test outputs
-  std::vector<TestOutputRowTypeTraits::ViewTupleType> expectedOutputs = {
-      {3},
-      {5},
-      {},
-      {},
-      {},
-  };
-
-  // Test inputs
-  std::vector<TestInputRowTypeTraits::ViewTupleType> inputTestRowsNoNull = {
-      {1, 2},
-      {1, 4},
-  };
-
-  // Expected test outputs
-  std::vector<TestOutputRowTypeTraits::ViewTupleType> expectedOutputsNoNull = {
-      {3},
-      {5},
-  };
-
-  std::string headerPath =
-      "\"velox/experimental/codegen/code_generator/tests/resources/UDFTest.h\"";
-
-  // Build the AST and run tests to verify correct results
-  void runTest(
-      const UDFInformation& udfInformation,
-      bool argumentsNodesNullable,
-      bool printCode = false) {
-    // Build AST node
-    auto arg1Node =
-        std::make_shared<InputRefExpr>(InputRefExpr(INTEGER(), "C0", 0));
-    auto arg2Node =
-        std::make_shared<InputRefExpr>(InputRefExpr(INTEGER(), "C1", 1));
-
-    auto callNode = std::make_shared<UDFCallExpr>(
-        UDFCallExpr(INTEGER(), udfInformation, {arg1Node, arg2Node}));
-
-    auto makeRowExpression = std::make_shared<MakeRowExpression>(
-        MakeRowExpression(INTEGER(), {callNode}));
-
-    arg1Node->setMaybeNull(argumentsNodesNullable);
-    arg2Node->setMaybeNull(argumentsNodesNullable);
-
-    auto inputType = ROW({"C0", "C1"}, {INTEGER(), INTEGER()});
-    auto outputType = ROW({"C0"}, {INTEGER()});
-    getExprCodeGenerator().getContext().addHeaderPath(
-        "\"velox/experimental/codegen/vector_function/StringTypes.h\"");
-
-    auto generatedExpression =
-        getExprCodeGenerator().generateCodegenExpressionStruct(
-            *makeRowExpression.get(), *inputType.get(), *outputType.get());
-
-    // Create codegen expression struct and compile it
-    std::string cppFileContent;
-    std::string invokeFunctionName;
-    std::tie(invokeFunctionName, cppFileContent) =
-        generatedExpression.wrapAsExternCallable(
-            getExprCodeGenerator().getContext(),
-            TestInputRowTypeTraits::codegenReadersType(),
-            TestOutputRowTypeTraits::codegenWritersType());
-
-    using codegenFunctionType = void (*)(
-        const typename TestInputRowTypeTraits::CodegenTupleReadersType&,
-        typename TestOutputRowTypeTraits::CodegenTupleWritersType&);
-
-    auto* function = compileAndGetFunction<codegenFunctionType>(
-        cppFileContent, invokeFunctionName, printCode);
-
-    auto& testInputs =
-        argumentsNodesNullable ? inputTestRows : inputTestRowsNoNull;
-    auto& testExpectedOutputs =
-        argumentsNodesNullable ? expectedOutputs : expectedOutputsNoNull;
-
-    for (auto i = 0; i < testInputs.size(); i++) {
-      auto output = TestOutputRowTypeTraits::createWritersTuple();
-      function(testInputs[i], output);
-      ASSERT_EQ(output, testExpectedOutputs[i]);
-    }
-  }
-
- private:
-  UDFManager udfManager;
-};
-
-// Outputs and inputs are not optionals
-TEST_F(UDFCallExpressionTest, testOutAndInNotOptional) {
-  UDFInformation udf;
-  udf.setCalledFunctionName("testAdd1");
-  udf.setNullMode(ExpressionNullMode::NullInNullOut);
-  udf.setHeaderFiles({headerPath});
-
-  udf.setIsOptionalArguments(false);
-  udf.setIsOptionalOutput(false);
-  udf.setOutputForm(OutputForm::Return);
-  udf.setCodegenNullInNullOutChecks(true);
-
-  runTest(udf, true /*inputNodesNullable*/, false);
-  //  if (true && tmp0.has_value() && tmp1.has_value()) {
-  //    tmp2 = std::optional<int32_t>{testAdd1(*tmp0, *tmp1)};
-  //  } else {
-  //    tmp2 = std::nullopt;
-  //  }
-
-  runTest(udf, false /*inputNodesNullable*/, false);
-  // tmp2 = std::optional<int32_t>{testAdd1(*tmp0, *tmp1)};
-}
-
-// Output is optional
-TEST_F(UDFCallExpressionTest, testOutOptional) {
-  UDFInformation udf;
-  udf.setCalledFunctionName("testAdd2");
-  udf.setNullMode(ExpressionNullMode::NullInNullOut);
-  udf.setHeaderFiles({headerPath});
-
-  udf.setIsOptionalArguments(false);
-  udf.setIsOptionalOutput(true);
-  udf.setOutputForm(OutputForm::Return);
-  udf.setCodegenNullInNullOutChecks(true);
-
-  runTest(udf, true /*inputNodesNullable*/, false);
-  //  if (true && tmp0.has_value() && tmp1.has_value()) {
-  //    tmp2 = std::optional<int32_t>{testAdd1(*tmp0, *tmp1)};
-  //  } else {
-  //    tmp2 = std::nullopt;
-  //  }
-
-  runTest(udf, false /*inputNodesNullable*/, false);
-  //  tmp2 = testAdd2(*tmp0, *tmp1);
-}
-
-// Inputs and output optionals, codegenNullInNullOutChecks = false
-TEST_F(UDFCallExpressionTest, testOutAnInOptional) {
-  UDFInformation udf;
-  udf.setCalledFunctionName("testAdd3");
-  udf.setNullMode(ExpressionNullMode::NullInNullOut);
-  udf.setHeaderFiles({headerPath});
-
-  udf.setIsOptionalArguments(true);
-  udf.setIsOptionalOutput(true);
-  udf.setOutputForm(OutputForm::Return);
-  udf.setCodegenNullInNullOutChecks(false);
-
-  runTest(udf, true /*inputNodesNullable*/, false);
-  //  tmp2 = testAdd3(tmp0, tmp1);
-
-  runTest(udf, false /*inputNodesNullable*/, false);
-  //  tmp2 = testAdd3(tmp0, tmp1);
-}
-
-} // namespace codegen::expressions::test
-} // namespace facebook::velox
diff --git a/velox/experimental/codegen/code_generator/tests/resources/TARGETS_disabled b/velox/experimental/codegen/code_generator/tests/resources/TARGETS_disabled
deleted file mode 100644
index 6f99faa2c3d01..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/resources/TARGETS_disabled
+++ /dev/null
@@ -1,11 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
-
-cpp_library(
-    name = "velox_codegen_codegenerator_udftest",
-    srcs = [],
-    headers = [
-        "UDFTest.h",
-    ],
-    deps = [],
-    external_deps = [],
-)
diff --git a/velox/experimental/codegen/code_generator/tests/resources/UDFTest.h b/velox/experimental/codegen/code_generator/tests/resources/UDFTest.h
deleted file mode 100644
index a3511e8dc75fa..0000000000000
--- a/velox/experimental/codegen/code_generator/tests/resources/UDFTest.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <optional>
-
-// Not nullable output and not nullable inputs
-int testAdd1(int input1, int input2) {
-  return input1 + input2;
-}
-
-// Nullable outputs
-std::optional<int> testAdd2(int input1, int input2) {
-  return std::optional<int>(input1 + input2);
-}
-
-// Nullable outputs and inputs
-std::optional<int> testAdd3(
-    std::optional<int> input1,
-    std::optional<int> input2) {
-  if (input1.has_value() && input2.has_value()) {
-    return input1.value() + input2.value();
-  }
-  return {};
-}
diff --git a/velox/experimental/codegen/compiler_utils/CMakeLists.txt b/velox/experimental/codegen/compiler_utils/CMakeLists.txt
deleted file mode 100644
index 3f9c14f3da7de..0000000000000
--- a/velox/experimental/codegen/compiler_utils/CMakeLists.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_codegen_compiler_utils INTERFACE)
-add_dependencies(velox_codegen_compiler_utils velox_codegen_external_process
-                 velox_codegen_proto)
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
diff --git a/velox/experimental/codegen/compiler_utils/CodeManager.h b/velox/experimental/codegen/compiler_utils/CodeManager.h
deleted file mode 100644
index 8432dd261043c..0000000000000
--- a/velox/experimental/codegen/compiler_utils/CodeManager.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/experimental/codegen/compiler_utils/Compiler.h"
-#include "velox/experimental/codegen/compiler_utils/CompilerOptions.h"
-#include "velox/experimental/codegen/library_loader/NativeLibraryLoader.h"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-
-namespace facebook::velox::codegen {
-
-using compiler_utils::Compiler;
-using compiler_utils::CompilerOptions;
-using native_loader::NativeLibraryLoader;
-/// Manages the life cycle of a generated code
-/// Right now this is simply a combo of a compiler/loader object
-class CodeManager {
- public:
-  explicit CodeManager(DefaultScopedTimer::EventSequence& eventSequence)
-      : compiler_(eventSequence), loader_(), eventSequence_(eventSequence) {}
-  CodeManager(
-      const CompilerOptions& options,
-      DefaultScopedTimer::EventSequence& eventSequence)
-      : compiler_(options, eventSequence),
-        loader_(),
-        eventSequence_(eventSequence) {}
-  compiler_utils::Compiler& compiler() {
-    return compiler_;
-  };
-
-  NativeLibraryLoader& loader() {
-    return loader_;
-  }
-
- private:
-  Compiler compiler_;
-  NativeLibraryLoader loader_;
-  DefaultScopedTimer::EventSequence eventSequence_;
-};
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/compiler_utils/Compiler.h b/velox/experimental/codegen/compiler_utils/Compiler.h
deleted file mode 100644
index cbaeef042f479..0000000000000
--- a/velox/experimental/codegen/compiler_utils/Compiler.h
+++ /dev/null
@@ -1,304 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <glog/logging.h>
-#include "velox/common/base/Exceptions.h"
-#include "velox/experimental/codegen/compiler_utils/CompilerOptions.h"
-#include "velox/experimental/codegen/external_process/Command.h"
-#include "velox/experimental/codegen/external_process/subprocess.h"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-
-namespace facebook::velox::codegen::compiler_utils {
-
-/// Manage compilation of C++ code
-
-class Compiler {
-  CompilerOptions compilerOptions_;
-  std::vector<std::string> defaultCompilationArgs_;
-  std::vector<std::string> defaultLinkingArgs_;
-  filesystem::PathGenerator pathGenerator_;
-  DefaultScopedTimer::EventSequence& eventSequence_;
-
- public:
-  explicit Compiler(
-      const CompilerOptions& opt,
-      DefaultScopedTimer::EventSequence& eventSequence)
-      : compilerOptions_(opt), eventSequence_(eventSequence) {
-    defaultCompilationArgs_.insert(
-        defaultCompilationArgs_.end(),
-        compilerOptions_.extraCompileOptions.begin(),
-        compilerOptions_.extraCompileOptions.end());
-    defaultCompilationArgs_.push_back(compilerOptions_.optimizationLevel);
-
-    defaultLinkingArgs_.insert(
-        defaultLinkingArgs_.end(),
-        compilerOptions_.extraLinkOptions.begin(),
-        compilerOptions_.extraLinkOptions.end());
-    defaultLinkingArgs_.push_back(
-        compilerOptions_
-            .optimizationLevel); // Important when we start doing lto
-  }
-
-  explicit Compiler(DefaultScopedTimer::EventSequence& eventSequence)
-      : compilerOptions_(), eventSequence_(eventSequence) {
-    defaultCompilationArgs_.insert(
-        defaultCompilationArgs_.end(),
-        compilerOptions_.extraCompileOptions.begin(),
-        compilerOptions_.extraCompileOptions.end());
-    defaultCompilationArgs_.push_back(compilerOptions_.optimizationLevel);
-
-    defaultLinkingArgs_.insert(
-        defaultLinkingArgs_.end(),
-        compilerOptions_.extraLinkOptions.begin(),
-        compilerOptions_.extraLinkOptions.end());
-    defaultLinkingArgs_.push_back(
-        compilerOptions_
-            .optimizationLevel); // Important when we start doing lto
-  }
-
-  CompilerOptions& compilerOptions() {
-    return compilerOptions_;
-  }
-
-  std::vector<std::string>& defaultCompilationArgs() {
-    return defaultCompilationArgs_;
-  }
-
-  std::vector<std::string>& defaultLinkingArgs() {
-    return defaultLinkingArgs_;
-  }
-
-  /// Format in place a given cpp file
-  /// \param path
-  /// \return true iff the file was formatted
-  bool formatFile(const std::filesystem::path& path) {
-    if (!compilerOptions_.formatterPath) {
-      LOG(INFO) << "Missing format tool path" << std::endl;
-      return false;
-    };
-    auto format = formatCommand(path);
-    std::filesystem::path err, out;
-    auto proc = launchCommand(format, out, err);
-    proc.wait();
-    return true;
-  }
-
-  /// compiles a given c++ string
-  /// \param additionalLibraries
-  /// \param cppContent  c++ file content
-  /// \return path to the generated object file
-  std::filesystem::path compileString(
-      const std::vector<LibraryDescriptor>& additionalLibraries,
-      const std::string& cppContent) {
-    DefaultScopedTimer timer("CompileString", eventSequence_);
-
-    auto cppPath = pathGenerator_.tempPath("source", ".cpp");
-    auto objectPath = pathGenerator_.tempPath("source", ".o");
-    std::ofstream f(cppPath);
-    f << cppContent;
-    f.close();
-    formatFile(cppPath);
-    compile(additionalLibraries, cppPath, objectPath);
-    return objectPath;
-  }
-
-  /// Compile a file path
-  /// \param additionalLibraries
-  /// \param cppFile file path
-  /// \param outputFile path to the generated file
-  void compile(
-      const std::vector<LibraryDescriptor>& additionalLibraries,
-      const std::filesystem::path& cppFile,
-      const std::filesystem::path& outputFile) {
-    DefaultScopedTimer timer("Compile", eventSequence_);
-    auto command = compileCommand(additionalLibraries, cppFile, outputFile);
-    std::filesystem::path err, out;
-    auto proc = launchCommand(command, out, err);
-    proc.wait();
-    assert(!proc.running());
-    if (proc.exit_code() != 0) {
-      google::FlushLogFiles(google::INFO);
-      std::cerr << "Compilation failed, Process " << proc.id() << std::endl
-                << "====cerr content ====" << std::endl
-                << std::ifstream(err).rdbuf() << std::endl
-                << "====cout content ====" << std::endl
-                << std::ifstream(out).rdbuf() << std::endl;
-      throw std::logic_error(fmt::format(
-          "Compilation pid {} failed, err {} , out {}",
-          proc.id(),
-          err.string(),
-          out.string()));
-    };
-    return;
-  }
-
-  /// Link given object files into a final dynamic library
-  /// \param additionalLibraries
-  /// \param binaryFiles list of object to link
-  /// \param outputFile path the resulting .so
-  void link(
-      const std::vector<LibraryDescriptor>& additionalLibraries,
-      const std::vector<std::filesystem::path>& binaryFiles,
-      const std::filesystem::path& outputFile) {
-    DefaultScopedTimer timer("Link", eventSequence_);
-
-    auto command = linkCommand(additionalLibraries, binaryFiles, outputFile);
-    std::filesystem::path err, out;
-    auto proc = launchCommand(command, out, err);
-    proc.wait();
-    if (proc.exit_code() != 0) {
-      // TODO: Move printing err files in external_process
-      std::cerr << "Linking failed, pid" << proc.id() << std::endl
-                << "====cerr content ====" << std::endl
-                << std::ifstream(err).rdbuf() << std::endl
-                << "====cout content ====" << std::endl
-                << std::ifstream(out).rdbuf() << std::endl;
-      throw std::logic_error(fmt::format(
-          "Linking pid {} failed, err {} , out {}",
-          proc.id(),
-          err.string(),
-          out.string()));
-      // throw std::logic_error(fmt::format("Linking pid {} failed",
-      // proc.id()));
-    }
-    return;
-  }
-
-  /// link multiple binary files
-  /// \param additionalLibraries
-  /// \param binaryFiles
-  /// \return path the generated .so
-  std::filesystem::path link(
-      const std::vector<LibraryDescriptor>& additionalLibraries,
-      const std::vector<std::filesystem::path>& binaryFiles) {
-    auto dynamicLibPath = pathGenerator_.tempPath("dyn", ".so");
-    link(additionalLibraries, binaryFiles, dynamicLibPath);
-    return dynamicLibPath;
-  }
-
-  /// Construct a command object which execution would compile the give files.
-  /// \param additionalLibraries
-  /// \param cppFile
-  /// \param outputFile
-  /// \return Command object for later execution.
-  external_process::Command compileCommand(
-      const std::vector<LibraryDescriptor>& additionalLibraries,
-      const std::filesystem::path& cppFile,
-      const std::filesystem::path& outputFile) {
-    std::vector<std::string> args(defaultCompilationArgs_);
-
-    for (const auto& library : compilerOptions_.defaultLibraries) {
-      includePathArgs(library, args);
-    };
-
-    for (const auto& library : additionalLibraries) {
-      includePathArgs(library, args);
-    };
-
-    args.push_back("-c");
-    args.push_back(cppFile.string());
-    args.push_back("-o");
-    args.push_back(outputFile.string());
-
-    return {compilerOptions_.compilerPath, args};
-  }
-
-  /// Linking command.
-  /// \param additionalLibraries
-  /// \param objectFiles
-  /// \param outputFile
-  /// \return Command object for later execution
-  external_process::Command linkCommand(
-      const std::vector<LibraryDescriptor>& additionalLibraries,
-      const std::vector<std::filesystem::path>& objectFiles,
-      const std::filesystem::path& outputFile) {
-    std::vector<std::string> args(defaultLinkingArgs_);
-
-    if (compilerOptions_.linker.has_value()) {
-      args.push_back(
-          fmt::format("-fuse-ld={}", compilerOptions_.linker.value().string()));
-    }
-    args.push_back("-shared");
-
-    args.push_back("-o");
-    args.push_back(outputFile.string());
-
-    for (const auto& objectFile : objectFiles) {
-      args.push_back(objectFile.string());
-    }
-
-    for (const auto& library : compilerOptions_.defaultLibraries) {
-      linkingSearchPathArgs(library, args);
-      linkingLibrariesArgs(library, args);
-    };
-
-    for (const auto& library : additionalLibraries) {
-      linkingSearchPathArgs(library, args);
-      linkingLibrariesArgs(library, args);
-    };
-
-    return {compilerOptions_.compilerPath, args};
-  }
-
-  /// In place formatting of a given file using clang-format
-  /// \param cppFile file to  be formatted
-  /// \return excutable command
-  external_process::Command formatCommand(
-      const std::filesystem::path& cppFile) {
-    VELOX_CHECK(compilerOptions_.formatterPath);
-    std::vector<std::string> args;
-    args.push_back("-i");
-    args.push_back(cppFile.string());
-    args.push_back("--style=llvm");
-    return {*compilerOptions_.formatterPath, args};
-  }
-
- private:
-  void includePathArgs(
-      const LibraryDescriptor& library,
-      std::vector<std::string>& args) {
-    for (const auto& path : library.systemIncludePath) {
-      args.push_back("-isystem");
-      args.push_back(path.string());
-    }
-    for (const auto& path : library.includePath) {
-      args.push_back("-I");
-      args.push_back(path.string());
-    }
-  }
-
-  void linkingSearchPathArgs(
-      const LibraryDescriptor& library,
-      std::vector<std::string>& args) {
-    for (const auto& path : library.linkerSearchPath) {
-      args.push_back("-L");
-      args.push_back(path.string());
-    }
-  }
-
-  void linkingLibrariesArgs(
-      const LibraryDescriptor& library,
-      std::vector<std::string>& args) {
-    for (const auto& name : library.libraryNames) {
-      args.push_back("-l");
-      args.push_back(name);
-    };
-    for (const auto& arg : library.additionalLinkerObject) {
-      args.push_back(arg.string());
-    };
-  }
-};
-} // namespace facebook::velox::codegen::compiler_utils
diff --git a/velox/experimental/codegen/compiler_utils/CompilerOptions.h b/velox/experimental/codegen/compiler_utils/CompilerOptions.h
deleted file mode 100644
index d89f641434b40..0000000000000
--- a/velox/experimental/codegen/compiler_utils/CompilerOptions.h
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <fmt/format.h>
-#include <google/protobuf/util/json_util.h>
-#include <filesystem>
-#include <string>
-#include "velox/experimental/codegen/compiler_utils/LibraryDescriptor.h"
-#include "velox/experimental/codegen/proto/ProtoUtils.h"
-#include "velox/experimental/codegen/proto/codegen_proto.pb.h"
-
-namespace facebook::velox::codegen::compiler_utils {
-
-/// Compiler options
-struct CompilerOptions {
-  CompilerOptions() = default;
-  CompilerOptions(const CompilerOptions& options) = default;
-  CompilerOptions& operator=(const CompilerOptions& other) = default;
-
-  std::string optimizationLevel;
-  std::vector<std::string> extraCompileOptions;
-  std::vector<std::string> extraLinkOptions;
-  std::vector<LibraryDescriptor> defaultLibraries;
-  std::filesystem::path compilerPath;
-  std::optional<std::filesystem::path> linker;
-  std::optional<std::filesystem::path> formatterPath;
-  std::filesystem::path tempDirectory;
-
-  /// Converts a CompilerOptionsProto to a CompilerOptions
-  static CompilerOptions fromProto(
-      const proto::CompilerOptionsProto& compilerOptionsProto) {
-    using namespace google::protobuf;
-    using namespace proto;
-
-    std::vector<LibraryDescriptor> defaultLibraries;
-    std::transform(
-        compilerOptionsProto.defaultlibraries().begin(),
-        compilerOptionsProto.defaultlibraries().end(),
-        std::back_inserter(defaultLibraries),
-        [](const LibraryDescriptorProto& libraryDescriptorProto) {
-          return LibraryDescriptor::fromProto(libraryDescriptorProto);
-        });
-
-    auto compilerOptions =
-        CompilerOptions()
-            .withOptimizationLevel(compilerOptionsProto.optimizationlevel())
-            .withExtraCompileOptions(std::vector<std::string>(
-                compilerOptionsProto.extracompileoption().begin(),
-                compilerOptionsProto.extracompileoption().end()))
-            .withExtraLinkOptions(std::vector<std::string>(
-                compilerOptionsProto.extralinkoptions().begin(),
-                compilerOptionsProto.extralinkoptions().end()))
-            .withDefaultLibraries(defaultLibraries)
-            .withCompilerPath(compilerOptionsProto.compilerpath())
-            .withTempDirectory(compilerOptionsProto.tempdirectory());
-
-    if (!compilerOptionsProto.linker().empty()) {
-      compilerOptions.withLinker(compilerOptionsProto.linker());
-    }
-    if (!compilerOptionsProto.formatterpath().empty()) {
-      compilerOptions.withFormatterPath(compilerOptionsProto.formatterpath());
-    }
-    return compilerOptions;
-  }
-
-  static CompilerOptions fromJsonFile(std::filesystem::path jsonFilePath) {
-    /// Use std library instead of velox::common::file::LocalReadFile because
-    /// LocalReadFile does not automatically decode the binary representation
-    /// to string representation in memory
-    if (!std::filesystem::exists(jsonFilePath)) {
-      throw std::logic_error("Missing  JsonFile  : " + jsonFilePath.string());
-    };
-    std::stringstream ss;
-    ss << std::ifstream(jsonFilePath.string()).rdbuf();
-    return loadFromJson(ss.str());
-  }
-
-  /// Converts a Json string to a CompilerOptions
-  static CompilerOptions loadFromJson(std::string_view jsonString) {
-    proto::CompilerOptionsProto compilerOptionsProto;
-    auto status = google::protobuf::util::JsonStringToMessage(
-        jsonString.data(), &compilerOptionsProto);
-    if (!status.ok()) {
-      throw std::logic_error(
-          "Failed to load CompilerOptions from JsonString: " +
-          status.message().as_string());
-    }
-    return fromProto(compilerOptionsProto);
-  }
-
-  /// Sets the values of a CompilerOptionsProto using values from
-  /// CompilerOptions
-  static proto::CompilerOptionsProto& setProto(
-      const CompilerOptions& compilerOptions,
-      proto::CompilerOptionsProto& compilerOptionsProto) {
-    using namespace google::protobuf;
-    using namespace proto;
-
-    compilerOptionsProto.set_optimizationlevel(
-        compilerOptions.optimizationLevel);
-    // Reassignment using initializer list requires c++11
-    *compilerOptionsProto.mutable_extracompileoption() = {
-        compilerOptions.extraCompileOptions.begin(),
-        compilerOptions.extraCompileOptions.end()};
-    *compilerOptionsProto.mutable_extralinkoptions() = {
-        compilerOptions.extraLinkOptions.begin(),
-        compilerOptions.extraLinkOptions.end()};
-
-    std::for_each(
-        compilerOptions.defaultLibraries.begin(),
-        compilerOptions.defaultLibraries.end(),
-        [&](const LibraryDescriptor& libraryDescriptor) {
-          LibraryDescriptorProto* libraryDescriptorProto =
-              compilerOptionsProto.add_defaultlibraries();
-          LibraryDescriptor::setProto(
-              libraryDescriptor, *libraryDescriptorProto);
-        });
-
-    compilerOptionsProto.set_compilerpath(compilerOptions.compilerPath);
-    compilerOptionsProto.set_linker(compilerOptions.linker.value_or(""));
-    compilerOptionsProto.set_formatterpath(
-        compilerOptions.formatterPath.value_or(""));
-    compilerOptionsProto.set_tempdirectory(compilerOptions.tempDirectory);
-
-    return compilerOptionsProto;
-  }
-
-  /// Converts a CompilerOptions to CompilerOptionsProto.
-  static proto::CompilerOptionsProto asProto(
-      const CompilerOptions& compilerOptions) {
-    proto::CompilerOptionsProto compilerOptionsProto;
-    return setProto(compilerOptions, compilerOptionsProto);
-  }
-
-  /// Converts a CompilerOptions to its Json representation.
-  static std::string formatAsJson(const CompilerOptions& compilerOptions) {
-    std::string output;
-    auto status = google::protobuf::util::MessageToJsonString(
-        asProto(compilerOptions), &output);
-    if (!status.ok()) {
-      throw std::logic_error(
-          "Failed to format CompilerOptions as Json" +
-          status.message().as_string());
-    }
-    return output;
-  }
-
-  /// Fluent interface.
-
-  CompilerOptions& withOptimizationLevel(const std::string& opt) {
-    optimizationLevel = opt;
-    return *this;
-  }
-
-  CompilerOptions& withExtraCompileOptions(
-      const std::vector<std::string>& extraOptions) {
-    extraCompileOptions = extraOptions;
-    return *this;
-  }
-  CompilerOptions& withExtraLinkOptions(
-      const std::vector<std::string>& linkOptions) {
-    extraLinkOptions = linkOptions;
-    return *this;
-  }
-
-  CompilerOptions& withDefaultLibraries(
-      const std::vector<LibraryDescriptor>& libraries) {
-    defaultLibraries = libraries;
-    return *this;
-  }
-
-  CompilerOptions& withCompilerPath(const std::filesystem::path& path) {
-    compilerPath = path;
-    return *this;
-  }
-
-  CompilerOptions& withTempDirectory(const std::filesystem::path& temp) {
-    tempDirectory = temp;
-    return *this;
-  }
-
-  CompilerOptions& withLinker(const std::filesystem::path& path) {
-    linker = path;
-    return *this;
-  }
-
-  CompilerOptions& withFormatterPath(const std::filesystem::path& path) {
-    formatterPath = path;
-    return *this;
-  }
-};
-} // namespace facebook::velox::codegen::compiler_utils
diff --git a/velox/experimental/codegen/compiler_utils/ICompiledCall.h b/velox/experimental/codegen/compiler_utils/ICompiledCall.h
deleted file mode 100644
index 9c24ce4f5703d..0000000000000
--- a/velox/experimental/codegen/compiler_utils/ICompiledCall.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/core/Expressions.h"
-#include "velox/core/ITypedExpr.h"
-#include "velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-/// Models compiled expressions.
-/// In general, generation function from a dynamicLib produce multiple output.
-/// A compiled expression is represented by an dynamicLib
-/// And an index indicating which output of the loaded function
-/// this object represent
-class ICompiledCall : public core::CallTypedExpr {
- public:
-  using NewInstanceSignature =
-      std::unique_ptr<GeneratedVectorFunctionBase> (*)();
-
-  ICompiledCall(
-      const std::filesystem::path& dynamicLibPath,
-      const std::vector<std::shared_ptr<const ITypedExpr>>& inputs,
-      const std::shared_ptr<const RowType>& rowType)
-      : core::CallTypedExpr(rowType, inputs, ""),
-        dynamicLibPath_{dynamicLibPath} {}
-  ICompiledCall(const ICompiledCall&) = delete;
-  ICompiledCall(ICompiledCall&&) = delete;
-
-  virtual std::string toString() const override {
-    return "[Compiled] : " + core::CallTypedExpr::toString();
-  };
-
-  // TODO: Missing tests
-  virtual bool operator==(const ITypedExpr& other) const override {
-    if (auto otherCall = dynamic_cast<const ICompiledCall*>(&other);
-        otherCall != nullptr) {
-      return otherCall == this;
-    };
-    return false;
-  };
-
-  // The compiled function is registered right before
-  // we return its name. This allow for lazy initialization.
-  virtual const std::string& name() const override {
-    if (!name_.has_value()) {
-      name_ = registerFunction();
-    };
-    core::QueryConfig config({});
-    VELOX_CHECK_NOT_NULL(
-        exec::getVectorFunction(name_.value(), {}, {}, config));
-    return name_.value();
-  }
-
-  std::unique_ptr<GeneratedVectorFunctionBase> newInstance() const {
-    if (!newInstanceFunction_.has_value()) {
-      auto& loader = native_loader::NativeLibraryLoader::getDefaultLoader();
-      auto loadedLibrary = loader.loadLibrary(dynamicLibPath_, nullptr);
-      auto newInstance = loader.getFunction<NewInstanceSignature>(
-          "newInstance", loadedLibrary);
-      newInstanceFunction_ = newInstance;
-    }
-    auto generatedVectorFunction = newInstanceFunction_.value()();
-    return generatedVectorFunction;
-  }
-
- private:
-  std::string registerFunction() const {
-    auto generatedVectorFunction = newInstance();
-    VELOX_CHECK_NOT_NULL(
-        std::dynamic_pointer_cast<const RowType>(this->type()));
-    generatedVectorFunction->setRowType(
-        std::dynamic_pointer_cast<const RowType>(this->type()));
-
-    return insertFunction(std::move(generatedVectorFunction));
-  }
-
-  // Idealy we should push this code closer to vectorFunction.cpp
-  // In particular, we should had an "annonymous" registration where the map
-  // it self chose a random name, instead of us guessing.
-  std::string insertFunction(std::unique_ptr<GeneratedVectorFunctionBase>
-                                 generatedVectorFunction) const {
-    constexpr auto compiledFunctionNameFormat = "compiledFunction_{}";
-    static const size_t kMaxRegistrationTry = 100;
-    static const size_t kMaxRegisteredFunction = 10000;
-    // Seed with a real random value, if available
-    std::random_device r;
-    std::uniform_int_distribution<int> uniform_dist(1, kMaxRegisteredFunction);
-    int functionID = uniform_dist(r);
-    std::string functionName =
-        fmt::format(compiledFunctionNameFormat, functionID);
-    size_t tryCounter = 0;
-    while (!exec::registerVectorFunction(
-        functionName, {}, std::move(generatedVectorFunction))) {
-      if (tryCounter > kMaxRegistrationTry) {
-        throw std::runtime_error(fmt::format(
-            "Can't register new function after {} attempts", tryCounter));
-      }
-      functionID = uniform_dist(r);
-      functionName = fmt::format(compiledFunctionNameFormat, functionID);
-      tryCounter++;
-    };
-    return functionName;
-  };
-
-  std::filesystem::path dynamicLibPath_;
-  mutable std::optional<std::string> name_;
-  mutable std::optional<NewInstanceSignature> newInstanceFunction_;
-};
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/compiler_utils/LibraryDescriptor.h b/velox/experimental/codegen/compiler_utils/LibraryDescriptor.h
deleted file mode 100644
index fd2f5a1e1eee3..0000000000000
--- a/velox/experimental/codegen/compiler_utils/LibraryDescriptor.h
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <fmt/format.h>
-#include <google/protobuf/util/json_util.h>
-#include <filesystem>
-#include <fstream>
-#include <sstream>
-#include <string>
-#include <variant>
-#include <vector>
-#include "velox/experimental/codegen/proto/codegen_proto.pb.h"
-#include "velox/experimental/codegen/transform/utils/ranges_utils.h"
-
-namespace facebook::velox::codegen::compiler_utils {
-// TODO: Use Aggregate initialization C++20 instead of fluent interface
-// Information use to produce compilation and linking commands.
-struct LibraryDescriptor {
-  std::string name; // Library name, not used in command line
-  std::vector<std::filesystem::path> includePath; // -I
-  std::vector<std::filesystem::path> systemIncludePath; //-isystem
-  std::vector<std::filesystem::path> linkerSearchPath; // -L
-  std::vector<std::string> libraryNames; // -l
-
-  // Allow using LibraryDescriptor in set, assumes that name is unique
-  bool operator<(const LibraryDescriptor& rhs) const {
-    return name < rhs.name;
-  }
-
-  // Used to referenced linker object not in the default search paths.
-  std::vector<std::filesystem::path> additionalLinkerObject;
-
-  /// Converts a LibraryDescriptProto to LibraryDescriptor.
-  static LibraryDescriptor fromProto(
-      const proto::LibraryDescriptorProto& libraryDescriptorProto) {
-    using namespace google::protobuf;
-    using namespace proto;
-
-    return LibraryDescriptor()
-        .withName(libraryDescriptorProto.name())
-        .withIncludePath(std::vector<std::filesystem::path>(
-            libraryDescriptorProto.includepath().begin(),
-            libraryDescriptorProto.includepath().end()))
-        .withSystemIncludePath(std::vector<std::filesystem::path>(
-            libraryDescriptorProto.systemincludepath().begin(),
-            libraryDescriptorProto.systemincludepath().end()))
-        .withLinkerSearchPath(std::vector<std::filesystem::path>(
-            libraryDescriptorProto.linkersearchpath().begin(),
-            libraryDescriptorProto.linkersearchpath().end()))
-        .withLibraryNames(std::vector<std::string>(
-            libraryDescriptorProto.librarynames().begin(),
-            libraryDescriptorProto.librarynames().end()))
-        .withAdditionalLinkerObject(std::vector<std::filesystem::path>(
-            libraryDescriptorProto.additionallinkerobject().begin(),
-            libraryDescriptorProto.additionallinkerobject().end()));
-  }
-
-  static LibraryDescriptor fromJsonFile(std::filesystem::path jsonFilePath) {
-    /// Use std library instead of velox::common::file::LocalReadFile because
-    /// LocalReadFile does not automatically decode the binary representation
-    /// to string representation in memory
-    std::stringstream ss;
-    ss << std::ifstream(jsonFilePath.string()).rdbuf();
-    return loadFromJson(ss.str());
-  }
-
-  /// Converts a Json string to LibraryDescriptor.
-  static LibraryDescriptor loadFromJson(std::string_view jsonString) {
-    proto::LibraryDescriptorProto libraryDescriptorProto;
-    auto status = google::protobuf::util::JsonStringToMessage(
-        jsonString.data(), &libraryDescriptorProto);
-    if (!status.ok()) {
-      throw std::logic_error(
-          "Failed to load LibraryDescriptor from JsonString: " +
-          status.message().as_string());
-    }
-    return fromProto(libraryDescriptorProto);
-  }
-
-  /// Sets the values of a LibraryDescriptorProto to that of a
-  /// LibraryDescriptor.
-  static proto::LibraryDescriptorProto& setProto(
-      const LibraryDescriptor& libraryDescriptor,
-      proto::LibraryDescriptorProto& libraryDescriptorProto) {
-    using namespace google::protobuf;
-    using namespace proto;
-
-    libraryDescriptorProto.set_name(libraryDescriptor.name);
-    *libraryDescriptorProto.mutable_includepath() = {
-        libraryDescriptor.includePath.begin(),
-        libraryDescriptor.includePath.end()};
-    *libraryDescriptorProto.mutable_linkersearchpath() = {
-        libraryDescriptor.linkerSearchPath.begin(),
-        libraryDescriptor.linkerSearchPath.end()};
-    *libraryDescriptorProto.mutable_librarynames() = {
-        libraryDescriptor.libraryNames.begin(),
-        libraryDescriptor.libraryNames.end()};
-    *libraryDescriptorProto.mutable_additionallinkerobject() = {
-        libraryDescriptor.additionalLinkerObject.begin(),
-        libraryDescriptor.additionalLinkerObject.end()};
-
-    return libraryDescriptorProto;
-  }
-
-  /// Converts a LibraryDescriptor to LibraryDescriptorProto.
-  static proto::LibraryDescriptorProto asProto(
-      const LibraryDescriptor& libraryDescriptor) {
-    proto::LibraryDescriptorProto libraryDescriptorProto;
-    return setProto(libraryDescriptor, libraryDescriptorProto);
-  }
-
-  /// Converts a LibraryDescriptor to its Json representation.
-  static std::string formatAsJson(const LibraryDescriptor& libraryDescriptor) {
-    std::string output;
-    auto status = google::protobuf::util::MessageToJsonString(
-        asProto(libraryDescriptor), &output);
-    if (!status.ok()) {
-      throw std::logic_error(
-          "Failed to format LibraryDescriptor as Json" +
-          status.message().as_string());
-    }
-
-    return output;
-  }
-
-  LibraryDescriptor& withName(const std::string& newName) {
-    name = newName;
-    return *this;
-  }
-
-  LibraryDescriptor& withIncludePath(
-      const std::vector<std::filesystem::path>& path) {
-    includePath = path;
-    return *this;
-  }
-
-  LibraryDescriptor& withSystemIncludePath(
-      const std::vector<std::filesystem::path>& path) {
-    systemIncludePath = path;
-    return *this;
-  }
-
-  LibraryDescriptor& withLinkerSearchPath(
-      const std::vector<std::filesystem::path>& path) {
-    linkerSearchPath = path;
-    return *this;
-  }
-
-  LibraryDescriptor& withLibraryNames(const std::vector<std::string>& names) {
-    libraryNames = names;
-    return *this;
-  }
-
-  LibraryDescriptor& withAdditionalLinkerObject(
-      const std::vector<std::filesystem::path>& path) {
-    additionalLinkerObject = path;
-    return *this;
-  }
-};
-} // namespace facebook::velox::codegen::compiler_utils
diff --git a/velox/experimental/codegen/compiler_utils/UnresolvedLibrary.h b/velox/experimental/codegen/compiler_utils/UnresolvedLibrary.h
deleted file mode 100644
index 179ce1915c8a8..0000000000000
--- a/velox/experimental/codegen/compiler_utils/UnresolvedLibrary.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// (c) Facebook, Inc. and its affiliates. Confidential and proprietary.
-
-#pragma once
-
-namespace facebook::velox::codegen::compiler_utils {
-
-enum class UnresolvedLibrary : uint8_t {
-  VELOX,
-  FOLLY,
-};
-
-} // namespace facebook::velox::codegen::compiler_utils
diff --git a/velox/experimental/codegen/compiler_utils/tests/CMakeLists.txt b/velox/experimental/codegen/compiler_utils/tests/CMakeLists.txt
deleted file mode 100644
index 861f64a5b0ae2..0000000000000
--- a/velox/experimental/codegen/compiler_utils/tests/CMakeLists.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
-  add_executable(velox_codegen_compiler_utils_test compiler_utils_test.cpp
-                                                   macOSDefinitions.cpp)
-else()
-  add_executable(velox_codegen_compiler_utils_test compiler_utils_test.cpp
-                                                   circleCIDefinitions.cpp)
-endif()
-
-add_test(velox_codegen_compiler_utils_test velox_codegen_compiler_utils_test)
-add_dependencies(velox_codegen_compiler_utils_test velox_codegen_compiler_utils
-                 velox_transform_utils velox_codegen_proto velox_exception)
-target_link_libraries(
-  velox_codegen_compiler_utils_test
-  velox_codegen_compiler_utils
-  velox_transform_utils
-  velox_codegen_proto
-  velox_exception
-  Boost::filesystem
-  gtest
-  gtest_main
-  Folly::folly
-  gflags::gflags
-  glog::glog
-  fmt::fmt)
diff --git a/velox/experimental/codegen/compiler_utils/tests/TARGETS_disabled b/velox/experimental/codegen/compiler_utils/tests/TARGETS_disabled
deleted file mode 100644
index 522b85df93a1e..0000000000000
--- a/velox/experimental/codegen/compiler_utils/tests/TARGETS_disabled
+++ /dev/null
@@ -1,29 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
-load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
-
-cpp_library(
-    name = "velox_codegen_compiler_utils_test_definitions",
-    srcs = ["FBdevServerDefinitions.cpp"],
-    headers = ["definitions.h"],
-    preprocessor_flags = [
-    ],
-    deps = ["//velox/experimental/codegen/compiler_utils:velox_codegen_compiler_utils"],
-)
-
-cpp_unittest(
-    name = "velox_codegen_compiler_utils_test",
-    srcs = [
-        "compiler_utils_test.cpp",
-    ],
-    deps = [
-        "fbsource//third-party/fmt:fmt",
-        ":velox_codegen_compiler_utils_test_definitions",
-        "//velox/experimental/codegen/compiler_utils:velox_codegen_compiler_utils",
-        "//velox/experimental/codegen/external_process:velox_codegen_external_process",
-        "//velox/experimental/codegen/library_loader:velox_codegen_native_loader",
-    ],
-    external_deps = [
-        ("boost", None, "boost_filesystem"),
-        ("glibc", None, "dl"),
-    ],
-)
diff --git a/velox/experimental/codegen/compiler_utils/tests/circleCIDefinitions.cpp b/velox/experimental/codegen/compiler_utils/tests/circleCIDefinitions.cpp
deleted file mode 100644
index 7ca0677ee9c5c..0000000000000
--- a/velox/experimental/codegen/compiler_utils/tests/circleCIDefinitions.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <string>
-#include "velox/experimental/codegen/compiler_utils/tests/definitions.h"
-namespace facebook {
-namespace velox {
-namespace codegen {
-const std::string CLANG_PATH = "/usr/bin/clang";
-const std::string LD_PATH = "/usr/local/ld.lld";
-const std::string FMT_INCLUDE = "/usr/local/include/";
-const std::string FMT_LIB = "/usr/local/lib64";
-
-compiler_utils::CompilerOptions testCompilerOptions() {
-  return compiler_utils::CompilerOptions()
-      .withCompilerPath(CLANG_PATH)
-      .withOptimizationLevel("-O3")
-      .withLinkerPath(LD_PATH)
-      .withTempDirectory("/tmp")
-      .withExtraCompileOptions({"-std=c++17", "-fPIC", "-g"})
-      .withFormatterPath("/usr/local/bin/clang-format");
-}
-
-};
-} // namespace codegen
-} // namespace velox
-}
-; // namespace facebook
diff --git a/velox/experimental/codegen/compiler_utils/tests/compiler_utils_test.cpp b/velox/experimental/codegen/compiler_utils/tests/compiler_utils_test.cpp
deleted file mode 100644
index ad55e6ba676d0..0000000000000
--- a/velox/experimental/codegen/compiler_utils/tests/compiler_utils_test.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dlfcn.h>
-#include <gtest/gtest.h>
-#include <fstream>
-#include <iostream>
-#include <regex>
-#include "boost/filesystem.hpp"
-#include "velox/experimental/codegen/compiler_utils/Compiler.h"
-#include "velox/experimental/codegen/compiler_utils/tests/definitions.h"
-#include "velox/experimental/codegen/external_process/Filesystem.h"
-#include "velox/experimental/codegen/library_loader/NativeLibraryLoader.h"
-
-namespace facebook::velox::codegen::compiler_utils::test {
-
-TEST(CompilerUtils, Command) {
-  auto testOptions = CompilerOptions()
-                         .withCompilerPath("/usr/bin/clang")
-                         .withOptimizationLevel("-O3")
-                         .withExtraCompileOptions({"-std=c++17"})
-                         .withFormatterPath("/usr/local/bin/clang-format");
-
-  DefaultScopedTimer::EventSequence eventSequence;
-  Compiler compiler(testOptions, eventSequence);
-  auto command = compiler.compileCommand({}, "/user/test.cpp", "user.o");
-  auto expected =
-      "/usr/bin/clang\n"
-      "-std=c++17\n"
-      "-O3\n"
-      "-c\n"
-      "/user/test.cpp\n"
-      "-o\n"
-      "user.o";
-  ASSERT_EQ(command.executablePath, "/usr/bin/clang");
-  ASSERT_EQ(command.arguments.size(), 6);
-  ASSERT_EQ(command.toString(), expected);
-}
-
-struct LibraryDescriptorProtoTest : public ::testing::Test {
-  void SetUp() override {
-    testLibraryDescriptor.withName("libraryDescriptorName")
-        .withIncludePath({"/usr/local/include/"})
-        .withLinkerSearchPath({"/usr/local/ld.lld"})
-        .withLibraryNames({"libName1", "libName2", "libName3"})
-        .withAdditionalLinkerObject(
-            {"/usr/local/lib/lib1", "/usr/local/lib/lib2"});
-  }
-  LibraryDescriptor testLibraryDescriptor;
-};
-
-TEST_F(LibraryDescriptorProtoTest, formatLoadJson) {
-  std::string libraryDescriptorJson =
-      proto::proto_utils::ProtoUtils<proto::LibraryDescriptorProto>::
-          formatAsJson(LibraryDescriptor::asProto(testLibraryDescriptor));
-
-  proto::LibraryDescriptorProto libraryDescriptorProto =
-      proto::proto_utils::ProtoUtils<proto::LibraryDescriptorProto>::
-          loadProtoFromJson(libraryDescriptorJson);
-
-  LibraryDescriptor newLibraryDescriptor =
-      LibraryDescriptor::fromProto(libraryDescriptorProto);
-
-  ASSERT_EQ(testLibraryDescriptor.name, newLibraryDescriptor.name);
-  ASSERT_EQ(
-      testLibraryDescriptor.includePath, newLibraryDescriptor.includePath);
-  ASSERT_EQ(
-      testLibraryDescriptor.linkerSearchPath,
-      newLibraryDescriptor.linkerSearchPath);
-  ASSERT_EQ(
-      testLibraryDescriptor.libraryNames, newLibraryDescriptor.libraryNames);
-  ASSERT_EQ(
-      testLibraryDescriptor.additionalLinkerObject,
-      newLibraryDescriptor.additionalLinkerObject);
-}
-
-TEST_F(LibraryDescriptorProtoTest, malformedJson) {
-  std::string malformedJson = "{field: data}";
-  EXPECT_THROW(
-      proto::proto_utils::ProtoUtils<
-          proto::LibraryDescriptorProto>::loadProtoFromJson(malformedJson),
-      std::logic_error);
-}
-
-TEST_F(LibraryDescriptorProtoTest, loadFromFile) {
-  auto tempPath = boost::filesystem::unique_path(
-                      fmt::format(
-                          "{}/%%%%-%%%%",
-                          boost::filesystem::temp_directory_path().string()))
-                      .string();
-  std::ofstream ostream(tempPath);
-  auto jsonString =
-      proto::proto_utils::ProtoUtils<proto::LibraryDescriptorProto>::
-          formatAsJson(LibraryDescriptor::asProto(testLibraryDescriptor));
-
-  ostream.write(jsonString.data(), jsonString.size());
-  ostream.close();
-
-  EXPECT_NO_THROW(
-      auto newLibraryDescriptorProto = proto::proto_utils::ProtoUtils<
-          proto::LibraryDescriptorProto>::loadProtoFromFile(tempPath);
-
-      ASSERT_EQ(
-          proto::proto_utils::ProtoUtils<proto::LibraryDescriptorProto>::
-              formatAsJson(newLibraryDescriptorProto),
-          jsonString););
-}
-
-struct CompilerOptionsProtoTest : LibraryDescriptorProtoTest {
-  void SetUp() override {
-    LibraryDescriptorProtoTest::SetUp();
-    testCompilerOptions_ = testCompilerOptions().withDefaultLibraries(
-        {testLibraryDescriptor, testLibraryDescriptor, testLibraryDescriptor});
-  }
-  CompilerOptions testCompilerOptions_;
-};
-
-TEST_F(CompilerOptionsProtoTest, malformedJson) {
-  std::string malformedJson = "{field: data}";
-  EXPECT_THROW(
-      proto::proto_utils::ProtoUtils<
-          proto::CompilerOptionsProto>::loadProtoFromJson(malformedJson),
-      std::logic_error);
-}
-
-TEST_F(CompilerOptionsProtoTest, loadFromFile) {
-  auto tempPath = boost::filesystem::unique_path(
-                      fmt::format(
-                          "{}/%%%%-%%%%",
-                          boost::filesystem::temp_directory_path().string()))
-                      .string();
-  std::ofstream ostream(tempPath);
-  auto jsonString =
-      proto::proto_utils::ProtoUtils<proto::CompilerOptionsProto>::formatAsJson(
-          CompilerOptions::asProto(testCompilerOptions_));
-  ostream.write(jsonString.data(), jsonString.size());
-  ostream.close();
-  EXPECT_NO_THROW(
-      auto newCompilerOptionsProto = proto::proto_utils::ProtoUtils<
-          proto::CompilerOptionsProto>::loadProtoFromFile(tempPath);
-
-      ASSERT_EQ(
-          proto::proto_utils::ProtoUtils<proto::CompilerOptionsProto>::
-              formatAsJson(newCompilerOptionsProto),
-          jsonString););
-}
-
-TEST_F(CompilerOptionsProtoTest, formatLoadJson) {
-  std::string compilerOptionsJson =
-      proto::proto_utils::ProtoUtils<proto::CompilerOptionsProto>::formatAsJson(
-          CompilerOptions::asProto(testCompilerOptions_));
-
-  proto::CompilerOptionsProto newCompilerOptionsProto = proto::proto_utils::
-      ProtoUtils<proto::CompilerOptionsProto>::loadProtoFromJson(
-          CompilerOptions::formatAsJson(testCompilerOptions_));
-  CompilerOptions newCompilerOptions =
-      CompilerOptions::loadFromJson(compilerOptionsJson);
-
-  ASSERT_EQ(
-      testCompilerOptions_.optimizationLevel,
-      newCompilerOptions.optimizationLevel);
-  ASSERT_EQ(
-      testCompilerOptions_.extraCompileOptions,
-      newCompilerOptions.extraCompileOptions);
-  ASSERT_EQ(
-      testCompilerOptions_.extraLinkOptions,
-      newCompilerOptions.extraLinkOptions);
-  ASSERT_EQ(newCompilerOptions.defaultLibraries.size(), 3);
-  auto newLibraryDescriptor = newCompilerOptions.defaultLibraries[0];
-  ASSERT_EQ(testLibraryDescriptor.name, newLibraryDescriptor.name);
-  ASSERT_EQ(
-      testLibraryDescriptor.includePath, newLibraryDescriptor.includePath);
-  ASSERT_EQ(
-      testLibraryDescriptor.linkerSearchPath,
-      newLibraryDescriptor.linkerSearchPath);
-  ASSERT_EQ(
-      testLibraryDescriptor.libraryNames, newLibraryDescriptor.libraryNames);
-  ASSERT_EQ(
-      testLibraryDescriptor.additionalLinkerObject,
-      newLibraryDescriptor.additionalLinkerObject);
-  ASSERT_EQ(testCompilerOptions_.compilerPath, newCompilerOptions.compilerPath);
-  ASSERT_EQ(testCompilerOptions_.linker, newCompilerOptions.linker);
-  ASSERT_EQ(
-      testCompilerOptions_.formatterPath, newCompilerOptions.formatterPath);
-  ASSERT_EQ(
-      testCompilerOptions_.tempDirectory, newCompilerOptions.tempDirectory);
-}
-
-TEST(Compiler, ExternalLibraries) {
-  using facebook::velox::codegen::compiler_utils::Compiler;
-  using facebook::velox::codegen::compiler_utils::CompilerOptions;
-
-  using facebook::velox::codegen::compiler_utils::filesystem::PathGenerator;
-
-  auto libraries = std::vector<LibraryDescriptor>{
-      LibraryDescriptor()
-          .withName("format")
-          .withIncludePath({FMT_INCLUDE})
-          .withAdditionalLinkerObject({FMT_LIB})};
-
-  auto sourceCode = R"a(
-  #include <fmt/format.h>
-  #include <string>
-  extern "C" {
-  std::string f() {
-    return fmt::format("test {}",2);
-  }
-  }
-  )a";
-
-  auto testOptions = testCompilerOptions();
-
-  DefaultScopedTimer::EventSequence eventSequence;
-  Compiler compiler(testOptions, eventSequence);
-  PathGenerator pathGenerator;
-  auto generated = pathGenerator.tempPath("compile", ".cpp");
-  auto binary = pathGenerator.tempPath("linkObject", ".o");
-  auto sharedObject = pathGenerator.tempPath("shared", ".so");
-
-  std::ofstream compileFile(generated);
-  compileFile << sourceCode << std::endl;
-  compileFile.close();
-
-  compiler.compile({libraries}, generated, binary);
-  compiler.link({libraries}, {binary}, sharedObject);
-
-  auto lib =
-      native_loader::NativeLibraryLoader::loadLibraryInternal(sharedObject);
-
-  auto func = (std::string(*)())dlsym(lib, "f");
-  ASSERT_EQ(func(), "test 2");
-}
-
-TEST(Compiler, CompileAndLink) {
-  auto sourceCode1 = R"a(
-  extern "C" {
-  int f() {
-    return 24;
-  };
-  }
-  )a";
-
-  auto sourceCode2 = R"a(
-  extern "C" {
-  int g() {
-    return 32;
-  };
-  }
-  )a";
-
-  auto options = testCompilerOptions();
-
-  DefaultScopedTimer::EventSequence eventSequence;
-
-  Compiler compiler(options, eventSequence);
-
-  auto binary = compiler.compileString({}, sourceCode1);
-  ASSERT_TRUE(std::filesystem::exists(binary));
-  ASSERT_GT(std::filesystem::file_size(binary), 0);
-
-  auto binary2 = compiler.compileString({}, sourceCode2);
-  ASSERT_TRUE(std::filesystem::exists(binary2));
-  ASSERT_GT(std::filesystem::file_size(binary2), 0);
-
-  auto sharedObject = compiler.link({}, {binary, binary2});
-  ASSERT_TRUE(std::filesystem::exists(sharedObject));
-  ASSERT_GT(std::filesystem::file_size(sharedObject), 0);
-
-  auto libraryPtr =
-      native_loader::NativeLibraryLoader::loadLibraryInternal(sharedObject);
-
-  auto g = (int (*)())dlsym(libraryPtr, "g");
-
-  ASSERT_EQ(g(), 32);
-
-  auto f = (int (*)())dlsym(libraryPtr, "f");
-  ASSERT_EQ(dlerror(), nullptr);
-  ASSERT_EQ(f(), 24);
-};
-} // namespace facebook::velox::codegen::compiler_utils::test
diff --git a/velox/experimental/codegen/compiler_utils/tests/definitions.h b/velox/experimental/codegen/compiler_utils/tests/definitions.h
deleted file mode 100644
index 7ebd624f82ed0..0000000000000
--- a/velox/experimental/codegen/compiler_utils/tests/definitions.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-#include "velox/experimental/codegen/compiler_utils/CompilerOptions.h"
-namespace facebook::velox::codegen::compiler_utils::test {
-
-extern const std::string CLANG_PATH;
-extern const std::string LD_PATH;
-extern const std::string FMT_INCLUDE;
-extern const std::string FMT_LIB;
-
-compiler_utils::CompilerOptions testCompilerOptions();
-} // namespace facebook::velox::codegen::compiler_utils::test
diff --git a/velox/experimental/codegen/compiler_utils/tests/macOSDefinitions.cpp b/velox/experimental/codegen/compiler_utils/tests/macOSDefinitions.cpp
deleted file mode 100644
index 20625e7c6dce1..0000000000000
--- a/velox/experimental/codegen/compiler_utils/tests/macOSDefinitions.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <string>
-#include "velox/experimental/codegen/compiler_utils/tests/definitions.h"
-namespace facebook {
-namespace velox {
-namespace codegen {
-namespace compiler_utils {
-namespace test {
-const std::string CLANG_PATH = "/usr/bin/clang";
-const std::string LD_PATH = "/usr/local/ld.lld";
-const std::string FMT_INCLUDE = "/usr/local/include/";
-const std::string FMT_LIB = "/usr/local/lib/libfmt.dylib";
-
-compiler_utils::CompilerOptions testCompilerOptions() {
-  return compiler_utils::CompilerOptions()
-      .withCompilerPath(CLANG_PATH)
-      .withOptimizationLevel("-O3")
-      .withTempDirectory("/tmp")
-      .withExtraCompileOptions({"-std=c++17", "-fPIC", "-g"})
-      .withFormatterPath("/usr/local/bin/clang-format")
-      .withExtraLinkOptions({"-Wl,-flat_namespace"});
-  ;
-}
-} // namespace test
-} // namespace compiler_utils
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/external_process/CMakeLists.txt b/velox/experimental/codegen/external_process/CMakeLists.txt
deleted file mode 100644
index deb7821b99e41..0000000000000
--- a/velox/experimental/codegen/external_process/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_codegen_external_process INTERFACE)
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
diff --git a/velox/experimental/codegen/external_process/Command.h b/velox/experimental/codegen/external_process/Command.h
deleted file mode 100644
index 705403e8f55c7..0000000000000
--- a/velox/experimental/codegen/external_process/Command.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <filesystem>
-#include <string>
-#include <vector>
-#include "velox/experimental/codegen/external_process/ExternalProcessException.h"
-
-namespace facebook::velox::codegen::external_process {
-
-///
-/// Represent an executable command line. This is essentially a list of
-/// substrings with the first substring beeing the command line name
-///
-/// TODO 1: add reference to the working directory, and the search path.
-struct Command {
-  std::filesystem::path executablePath;
-  std::vector<std::string> arguments;
-
-  /// Mainly for logging and debugging
-  /// \param sep separator
-  /// \return String representation
-  std::string toString(const std::string& sep = "\n") const {
-    std::string result = executablePath.string();
-    for (const auto& arg : arguments) {
-      result += sep + arg;
-    };
-    return result;
-  }
-
-  /// Parse strings init a command object
-  /// \param command
-  /// \return command object
-  /// TODO: Missing implementation
-  static Command fromString(const std::string& command) {
-    throw std::logic_error("Missing implementation");
-  }
-};
-} // namespace facebook::velox::codegen::external_process
diff --git a/velox/experimental/codegen/external_process/ExternalProcessException.h b/velox/experimental/codegen/external_process/ExternalProcessException.h
deleted file mode 100644
index a94c27c8b3c3a..0000000000000
--- a/velox/experimental/codegen/external_process/ExternalProcessException.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <stdexcept>
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-namespace external_process {
-// TODO: Investigate if std::sysem_error  would be a better choice here
-using ExternalProcessException = std::runtime_error;
-} // namespace external_process
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/external_process/Filesystem.h b/velox/experimental/codegen/external_process/Filesystem.h
deleted file mode 100644
index f2eda693ef017..0000000000000
--- a/velox/experimental/codegen/external_process/Filesystem.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <boost/filesystem.hpp>
-#include <fmt/format.h>
-#include <algorithm>
-#include <filesystem>
-#include <random>
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-namespace compiler_utils {
-namespace filesystem {
-
-/// Generates and manage temps filee
-/// TODO: Track files and cleanup after process closes
-class PathGenerator {
- public:
-  PathGenerator() : rootTempFolder_(std::filesystem::temp_directory_path()) {}
-
-  std::filesystem::path tempPath(
-      const std::filesystem::path& rootDir,
-      const std::string& prefix,
-      const std::string& extension) {
-    fmt::memory_buffer stringBuffer;
-
-    fmt::vformat_to(
-        std::back_insert_iterator(stringBuffer),
-        (rootDir / fileNameFormat).string(),
-        fmt::make_format_args(
-            fmt::arg("prefix", prefix), fmt::arg("ext", extension)));
-
-    // mkstemps expects a null terminated string.
-    stringBuffer.push_back('\0');
-
-    int returnValue = mkstemps(stringBuffer.begin(), extension.length());
-    int errorCode = errno;
-    if (returnValue == -1) {
-      char buffer[1024];
-      strerror_r(errorCode, buffer, 1024);
-      throw std::logic_error(fmt::format(
-          "Creating temp file failed with error code {}, and error message {}",
-          errorCode,
-          buffer));
-    };
-    return std::filesystem::path(stringBuffer.begin());
-  }
-
-  std::filesystem::path tempPath(
-      const std::string& prefix,
-      const std::string& extension) {
-    return tempPath(rootTempFolder_, prefix, extension);
-  }
-
- private:
-  std::filesystem::path rootTempFolder_;
-  const std::string fileNameFormat = "{prefix}XXXXXX{ext}";
-};
-
-} // namespace filesystem
-} // namespace compiler_utils
-} // namespace codegen
-} // namespace velox
-}; // namespace facebook
diff --git a/velox/experimental/codegen/external_process/subprocess.h b/velox/experimental/codegen/external_process/subprocess.h
deleted file mode 100644
index 3708edcda4a62..0000000000000
--- a/velox/experimental/codegen/external_process/subprocess.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <glog/logging.h>
-#include <filesystem>
-#include <string>
-#include <vector>
-#include "boost/process.hpp"
-#include "boost/process/extend.hpp"
-#include "velox/experimental/codegen/external_process/Command.h"
-#include "velox/experimental/codegen/external_process/ExternalProcessException.h"
-#include "velox/experimental/codegen/external_process/Filesystem.h"
-namespace facebook::velox::codegen::external_process {
-
-namespace bp = boost::process;
-
-static bool logExecuteCommand = true;
-
-__attribute__((weak)) inline auto launchCommand(
-    const Command& command,
-    std::filesystem::path& out,
-    std::filesystem::path& err) {
-  struct processInfo {
-    pid_t pid;
-    std::chrono::time_point<std::chrono::steady_clock> startTime;
-  };
-
-  auto fileStatus = std::filesystem::status(command.executablePath);
-  if (!std::filesystem::exists(fileStatus) or
-      ((fileStatus.permissions() &
-        (std::filesystem::perms::others_exec |
-         std::filesystem::perms::group_exec |
-         std::filesystem::perms::owner_exec)) ==
-       std::filesystem::perms::none)) {
-    throw ExternalProcessException(
-        fmt::format("{} is not executable", command.executablePath.string()));
-  };
-
-  compiler_utils::filesystem::PathGenerator pathGen;
-  out = pathGen.tempPath("stdout", ".txt");
-  err = pathGen.tempPath("stderr", ".txt");
-
-  // Communication channel between call backs;
-  // Ideally we would want to just use a promise to represent the communication
-  // channel, However, since we need the call backs lambda to be
-  // copy-constructable, we can't directly capture a std::promise/std::future
-  // because those classes are not copy constructable.
-  auto channel = std::make_shared<std::promise<processInfo>>();
-
-  auto on_exit = [channel, command = command, out, err](
-                     int exit_code, const std::error_code& code) mutable {
-    auto processInfo = channel.get()->get_future().get();
-    LOG_IF(INFO, logExecuteCommand)
-        << "Process completed, Pid : " << processInfo.pid
-        << " outLog : " << out.string() << ", errLog : " << err.string()
-        << ", command : " << command.toString(" ");
-  };
-
-  auto on_success = [channel, command, out, err](auto& executor) {
-    LOG_IF(INFO, logExecuteCommand)
-        << "Process started, Pid : " << executor.pid
-        << ", outLog : " << out.string() << ", errLog : " << err.string();
-    LOG_IF(INFO, logExecuteCommand)
-        << "Command for Pid " << executor.pid << " : " << command.toString(" ")
-        << std::endl;
-    channel.get()->set_value({executor.pid, std::chrono::steady_clock::now()});
-  };
-
-  try {
-    // TODO: the on_exit handler is not triggered
-    bp::child child(
-        command.executablePath.string(),
-        command.arguments,
-        bp::std_out > out,
-        bp::std_err > err,
-        bp::on_exit = on_exit,
-        bp::extend::on_success = on_success);
-    return child;
-  } catch (const std::system_error& e) {
-    // TODO: Normally, we would want to handle this in the on_error callback.
-    // Howevere, the on_error seems to not work properly on macos.
-    LOG(INFO) << "Process creation failed : " << command.executablePath.string()
-              << std::endl;
-    throw;
-  }
-}
-
-} // namespace facebook::velox::codegen::external_process
diff --git a/velox/experimental/codegen/external_process/tests/CMakeLists.txt b/velox/experimental/codegen/external_process/tests/CMakeLists.txt
deleted file mode 100644
index 274933f3de657..0000000000000
--- a/velox/experimental/codegen/external_process/tests/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_executable(velox_codegen_external_process_test external_process_test.cpp)
-add_test(velox_codegen_external_process_test
-         velox_codegen_external_process_test)
-add_dependencies(velox_codegen_external_process_test
-                 velox_codegen_external_process)
-target_link_libraries(
-  velox_codegen_external_process_test
-  gtest
-  gtest_main
-  Folly::folly
-  Boost::filesystem
-  ${DOUBLE_CONVERSION}
-  gflags::gflags
-  glog::glog
-  fmt::fmt)
diff --git a/velox/experimental/codegen/external_process/tests/TARGETS_disabled b/velox/experimental/codegen/external_process/tests/TARGETS_disabled
deleted file mode 100644
index deb3c908eae75..0000000000000
--- a/velox/experimental/codegen/external_process/tests/TARGETS_disabled
+++ /dev/null
@@ -1,15 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
-
-cpp_unittest(
-    name = "velox_codegen_external_process_test",
-    srcs = [
-        "external_process_test.cpp",
-    ],
-    headers = [],
-    deps = [
-        "//velox/experimental/codegen/external_process:velox_codegen_external_process",
-    ],
-    external_deps = [
-        "glog",
-    ],
-)
diff --git a/velox/experimental/codegen/external_process/tests/external_process_test.cpp b/velox/experimental/codegen/external_process/tests/external_process_test.cpp
deleted file mode 100644
index 22f3ddbbe9998..0000000000000
--- a/velox/experimental/codegen/external_process/tests/external_process_test.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <iostream>
-
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include "velox/experimental/codegen/external_process/Command.h"
-#include "velox/experimental/codegen/external_process/subprocess.h"
-
-using namespace facebook::velox::codegen::external_process;
-TEST(ExternalProcess, Command) {
-  Command command{"/bin/ls", {"-l", "-a"}};
-  ASSERT_EQ(command.toString(), "/bin/ls\n-l\n-a");
-}
-
-TEST(ExternalProcess, launchCommand) {
-  Command command{"/bin/ls", {"-l", "-a"}};
-  std::filesystem::path out, err;
-  auto proc = launchCommand(command, out, err);
-  proc.wait();
-  ASSERT_EQ(proc.exit_code(), 0);
-  ASSERT_GT(std::filesystem::file_size(out), 0);
-}
diff --git a/velox/experimental/codegen/functions/CMakeLists.txt b/velox/experimental/codegen/functions/CMakeLists.txt
deleted file mode 100644
index 400ce032c99da..0000000000000
--- a/velox/experimental/codegen/functions/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_codegen_functions INTERFACE)
-target_link_libraries(velox_codegen_functions INTERFACE fmt::fmt)
diff --git a/velox/experimental/codegen/functions/CastFunctionStub.h b/velox/experimental/codegen/functions/CastFunctionStub.h
deleted file mode 100644
index 239e416ea574a..0000000000000
--- a/velox/experimental/codegen/functions/CastFunctionStub.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/vector_function/StringTypes.h"
-#include "velox/type/Conversions.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::codegen {
-
-template <TypeKind kind, bool castByTruncate>
-struct CodegenConversionStub {
-  template <typename T>
-  using ReturnType = typename TypeTraits<kind>::DeepCopiedType;
-
-  template <typename T>
-  static ReturnType<T> cast(const T& arg) {
-    if constexpr (std::is_same_v<codegen::TempString<TempsAllocator>, T>) {
-      return util::Converter<kind, void, castByTruncate>::cast(
-          folly::StringPiece(arg.data(), arg.size()));
-    } else {
-      return util::Converter<kind, void, castByTruncate>::cast(arg);
-    }
-  }
-};
-
-}; // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/functions/HashFunctionStub.h b/velox/experimental/codegen/functions/HashFunctionStub.h
deleted file mode 100644
index 51d0064ebf0bd..0000000000000
--- a/velox/experimental/codegen/functions/HashFunctionStub.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <iostream>
-#include "velox/experimental/codegen/vector_function/StringTypes.h"
-#include "velox/functions/prestosql/HashImpl.h"
-#include "velox/type/Conversions.h"
-#include "velox/type/Type.h"
-
-#ifndef FOLLY_HAS_STRING_VIEW
-namespace folly {
-template <>
-struct hasher<std::string_view> {
-  using folly_is_avalanching = std::true_type;
-
-  size_t operator()(const std::string_view& key) const {
-    return static_cast<size_t>(
-        hash::SpookyHashV2::Hash64(key.data(), key.size(), 0));
-  }
-};
-} // namespace folly
-#endif
-
-namespace facebook::velox::codegen {
-
-template <typename T>
-FOLLY_ALWAYS_INLINE int64_t computeHashStub(const T& arg) {
-  if constexpr (std::is_same_v<codegen::TempString<TempsAllocator>, T>) {
-    //   std::cerr << std::string_view(arg.data(), arg.size());
-    return functions::computeHash(std::string_view(arg.data(), arg.size()));
-  } else {
-    return functions::computeHash(arg);
-  }
-}
-
-}; // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/library_loader/CMakeLists.txt b/velox/experimental/codegen/library_loader/CMakeLists.txt
deleted file mode 100644
index d52de2d58b997..0000000000000
--- a/velox/experimental/codegen/library_loader/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_codegen_library_loader INTERFACE)
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
diff --git a/velox/experimental/codegen/library_loader/FunctionTable.h b/velox/experimental/codegen/library_loader/FunctionTable.h
deleted file mode 100644
index c2d4069eff19d..0000000000000
--- a/velox/experimental/codegen/library_loader/FunctionTable.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-#include <map>
-#include <memory>
-#include <string>
-#include <typeinfo>
-#include <vector>
-
-/// This header file is meant to be included in the generated libraries (.so)
-/// and defines the interface expected by the library loader
-///
-/// Aggregate the information for each function symbol exported with a given
-/// library The loader relies on typeInfo to provide a
-/// type safe way to access defined functions
-struct FunctionInfo {
-  // Normaly we would use (void *) as to store a function address
-  // but it seems that (void *) is actually not meant to store function
-  // addresses only object addresses.
-  uint64_t functionAddress;
-  decltype(std::declval<std::type_info>().hash_code()) typeInfo;
-};
-
-/// Each library provide a function table listing all the exported functions
-struct FunctionTable {
-  std::map<std::string, FunctionInfo> exportedFunctions;
-};
-
-/// Register a function into a given function table. This compute the typeinfo
-/// \tparam Func type used to compute typeinfo
-/// \param functionName
-/// \param function
-/// \param functionTable
-template <typename Func>
-void registerFunction(
-    const std::string& functionName,
-    Func function,
-    FunctionTable& functionTable) {
-  using addressType = decltype(FunctionInfo::functionAddress);
-  static_assert(sizeof(function) == sizeof(addressType));
-  functionTable.exportedFunctions[functionName] = FunctionInfo{
-      reinterpret_cast<addressType>(function), typeid(function).hash_code()};
-};
-
-// loader/library interface.
-// Each libraries is expect to implement the interface below
-extern "C" {
-
-//
-// Apple clang version 11.0.3 (clang-1103.0.32.59) is emitting :
-// warning: 'getFunctionTable' has C-linkage specified,
-// but returns incomplete type 'std::shared_ptr<FunctionTable>'
-// which could be incompatible with C [-Wreturn-type-c-linkage]
-//
-// TODO: Investigate why std::shared_ptr here is seen as incomplete type
-// TODO: Is it safe to have std::shared_ptr cross ABI boundaries?
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
-std::shared_ptr<FunctionTable> getFunctionTable();
-#pragma clang diagnostic pop
-
-// TODO: Add interface to save/Restor the state of an expression
-bool init(void* arg);
-void release(void* arg);
-}
diff --git a/velox/experimental/codegen/library_loader/NativeLibraryLoader.h b/velox/experimental/codegen/library_loader/NativeLibraryLoader.h
deleted file mode 100644
index 5f261fedc06a1..0000000000000
--- a/velox/experimental/codegen/library_loader/NativeLibraryLoader.h
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-#include <dlfcn.h>
-#include <fmt/format.h>
-#include <algorithm>
-#include <filesystem>
-#include <map>
-#include <string>
-#include <vector>
-#include "velox/experimental/codegen/library_loader/FunctionTable.h"
-#include "velox/experimental/codegen/library_loader/NativeLibraryLoader.h"
-#include "velox/experimental/codegen/library_loader/NativeLibraryLoaderException.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-namespace native_loader {
-
-/// Load and manage the life cycle of dynamically generated libraries.
-
-class NativeLibraryLoader {
-  struct LoadedLibraryInfo {
-    std::filesystem::path path;
-    void* libraryPtr;
-    std::shared_ptr<FunctionTable> functionTable;
-  };
-
- public:
-  static NativeLibraryLoader& getDefaultLoader() {
-    static NativeLibraryLoader loader;
-    return loader;
-  }
-
-  // Force loading a dynamic library with out checking, intializing or
-  // extracting function table. Used in unit testing only.
-  void* uncheckedLoadLibrary(const std::filesystem::path& path) {
-    auto it = std::find_if(
-        loadedLibraries.begin(),
-        loadedLibraries.end(),
-        [&path](const auto& loadedLibraryEntry) {
-          const auto& libraryInfo = loadedLibraryEntry.second;
-          return libraryInfo.path == path;
-        });
-    if (it != loadedLibraries.end()) {
-      // What  happens when we have different library with the same path.
-      throw NativeLibraryLoaderException(
-          "Library : " + path.string() + "already loaded");
-    };
-    void* libraryPtr = loadLibraryInternal(path);
-    loadedLibraries.emplace(
-        libraryPtr, LoadedLibraryInfo{path, libraryPtr, nullptr});
-    return libraryPtr;
-  }
-
-  // Unload an unchecked laoded library. Used in unit testing only.
-  void uncheckedUnLoadLibrary(void* libraryPtr) {
-    if (auto mapIterator = loadedLibraries.find(libraryPtr);
-        mapIterator == loadedLibraries.end()) {
-      throw NativeLibraryLoaderException(fmt::format(
-          "Attempting to unload unknown library at {}", libraryPtr));
-    }
-
-    loadedLibraries.erase(loadedLibraries.find(libraryPtr));
-    dlclose(libraryPtr);
-    auto error = dlErrorToException();
-    if (error) {
-      throw error.value();
-    }
-  }
-
-  // Extract function with out checking function table. Used in unit testing
-  // only.
-  template <typename Func>
-  Func uncheckedGetFunction(const std::string& functionName, void* libraryPtr) {
-    constexpr bool isFunctionPtr = std::is_pointer_v<Func> &&
-        std::is_function_v<std::remove_pointer_t<Func>>;
-    static_assert(
-        isFunctionPtr, "Template argument need to be a function pointer");
-    if (loadedLibraries.find(libraryPtr) == loadedLibraries.end()) {
-      throw NativeLibraryLoaderException(
-          fmt::format("No library loaded at {}", libraryPtr));
-    };
-
-    return uncheckedGetSymbolPtr<Func>(libraryPtr, functionName);
-  }
-
-  /// Loads and verifies a given dynamic libraries
-  /// \param path
-  /// \return pointer to the loader libraries
-  void* loadLibrary(
-      const std::filesystem::path& path,
-      void* initArgument = nullptr) {
-    auto it = std::find_if(
-        loadedLibraries.begin(),
-        loadedLibraries.end(),
-        [&path](const auto& loadedLibraryEntry) {
-          const auto& libraryInfo = loadedLibraryEntry.second;
-          return libraryInfo.path == path;
-        });
-    if (it != loadedLibraries.end()) {
-      // What  happens when we have different library with the same path.
-      throw NativeLibraryLoaderException(
-          "Library : " + path.string() + "already loaded");
-    };
-    void* libraryPtr = loadLibraryInternal(path);
-    checkLibrary(libraryPtr);
-    auto functionTable = initLibrary(libraryPtr, initArgument);
-    loadedLibraries.emplace(
-        libraryPtr,
-        LoadedLibraryInfo{path, libraryPtr, std::move(functionTable)});
-    return libraryPtr;
-  }
-
-  ///
-  /// \tparam Func expected funuction's ype signature
-  /// \param functionName function name
-  /// \param libPtr previously loaded library pointer (typically return by
-  /// loadLibrary) \return Function object, or throw on errors
-  template <typename Func>
-  Func getFunction(const std::string& functionName, void* libraryPtr) {
-    constexpr bool isFunctionPtr = std::is_pointer_v<Func> &&
-        std::is_function_v<std::remove_pointer_t<Func>>;
-    static_assert(
-        isFunctionPtr, "Template argument need to be a function pointer");
-    if (loadedLibraries.find(libraryPtr) == loadedLibraries.end()) {
-      throw NativeLibraryLoaderException(
-          fmt::format("No library loaded at {}", libraryPtr));
-    };
-    auto func =
-        loadedLibraries[libraryPtr].functionTable->exportedFunctions.find(
-            functionName);
-    if (func ==
-        loadedLibraries[libraryPtr].functionTable->exportedFunctions.end()) {
-      throw NativeLibraryLoaderException(fmt::format(
-          "library loaded at {} doesn't export function {}",
-          libraryPtr,
-          functionName));
-    }
-    if (typeid(Func).hash_code() != func->second.typeInfo) {
-      throw NativeLibraryLoaderException(fmt::format(
-          "library loaded at {} exports function {} with a different type",
-          libraryPtr,
-          functionName));
-    };
-    return reinterpret_cast<Func>(func->second.functionAddress);
-  }
-
-  void unLoadLibrary(void* libraryPtr, void* releaseArgument) {
-    if (auto mapIterator = loadedLibraries.find(libraryPtr);
-        mapIterator == loadedLibraries.end()) {
-      throw NativeLibraryLoaderException(fmt::format(
-          "Attempting to unload unknown library at {}", libraryPtr));
-    }
-
-    uncheckedGetSymbolPtr<decltype(&release)>(
-        libraryPtr, "release")(releaseArgument);
-    loadedLibraries.erase(loadedLibraries.find(libraryPtr));
-    dlclose(libraryPtr);
-    auto error = dlErrorToException();
-    if (error) {
-      throw error.value();
-    }
-  }
-
-  /// Load library internal
-  /// \param path
-  /// \return library pointers
-  static void* loadLibraryInternal(const std::filesystem::path& path) {
-    void* loadedLib = dlopen(path.string().c_str(), kDefaultDlopenFlags);
-    auto error = dlErrorToException();
-    if (error) {
-      throw error.value();
-    }
-    return loadedLib;
-  }
-
- private:
-  /// Initialize library right after loading.
-  /// The initialization process start by loading the "init" function
-  /// defined in the provided library, and return the functionTable using
-  /// getFunctionTable \param libraryPtr \return Function table defined in
-  /// libraryPtr
-  std::shared_ptr<FunctionTable> initLibrary(
-      void* libraryPtr,
-      void* initArgument) {
-    auto initFunc = uncheckedGetSymbolPtr<decltype(&init)>(libraryPtr, "init");
-    bool initOK = initFunc(initArgument);
-    if (!initOK) {
-      throw NativeLibraryLoaderException(
-          "Call to init function returned false");
-    };
-    auto tableGetter = uncheckedGetSymbolPtr<decltype(&getFunctionTable)>(
-        libraryPtr, "getFunctionTable");
-    auto functionTable = tableGetter();
-    if (functionTable == nullptr) {
-      throw NativeLibraryLoaderException(
-          fmt::format("Failed to get function table from lib {}", libraryPtr));
-    };
-    return functionTable;
-  }
-
-  /// Return a function objection without safety checks
-  /// \tparam Func
-  /// \param libPtr
-  /// \param symbName
-  /// \return Function object
-  template <typename Func>
-  Func uncheckedGetSymbolPtr(void* libraryPtr, const std::string& symbolName) {
-    void* symbPtr = dlsym(libraryPtr, symbolName.c_str());
-    auto error = dlErrorToException();
-    if (error) {
-      throw error.value();
-    }
-    LOG(INFO) << fmt::format(
-        "{} {} loaded symbol {} at {} from library at {}",
-        __FILE__,
-        __LINE__,
-        symbolName,
-        symbPtr,
-        symbolName);
-
-    return reinterpret_cast<Func>(reinterpret_cast<uint64_t>(symbPtr));
-  }
-  /// Read dlError and converts the results into an exception object
-  /// \return NativeLibraryLoaderException if dlError has an error, empty
-  /// optional otherwise
-  static std::optional<NativeLibraryLoaderException> dlErrorToException() {
-    char* error = dlerror();
-    if (error == nullptr) {
-      return {};
-    }
-    LOG(INFO) << fmt::format(
-        "{}:{} dlerror message : {}", __FILE__, __LINE__, error);
-    return NativeLibraryLoaderException(error);
-  }
-
-  // Verify that the library exports the required functions.
-  // Loads the three required symbols and throws if something fails;
-  void checkLibrary(void* libraryPtr) {
-    try {
-      uncheckedGetSymbolPtr<decltype(&init)>(libraryPtr, "init");
-      uncheckedGetSymbolPtr<decltype(&release)>(libraryPtr, "release");
-      uncheckedGetSymbolPtr<decltype(&getFunctionTable)>(
-          libraryPtr, "getFunctionTable");
-    } catch (NativeLibraryLoaderException& exception) {
-      throw NativeLibraryLoaderException(fmt::format(
-          "Library verification failed with {} ", exception.what()));
-    }
-  }
-
-  static const int kDefaultDlopenFlags = RTLD_LOCAL | RTLD_LAZY;
-
-  /// map from addresses -> function table
-  std::map<void*, LoadedLibraryInfo> loadedLibraries;
-};
-} // namespace native_loader
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/library_loader/NativeLibraryLoaderException.h b/velox/experimental/codegen/library_loader/NativeLibraryLoaderException.h
deleted file mode 100644
index b08956a1e28fd..0000000000000
--- a/velox/experimental/codegen/library_loader/NativeLibraryLoaderException.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <stdexcept>
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-namespace native_loader {
-// TODO: Investigate if std::system_error  might
-//  be a more appropriate exception class
-using NativeLibraryLoaderException = std::runtime_error;
-} // namespace native_loader
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/library_loader/tests/CMakeLists.txt b/velox/experimental/codegen/library_loader/tests/CMakeLists.txt
deleted file mode 100644
index ae0d573c9279b..0000000000000
--- a/velox/experimental/codegen/library_loader/tests/CMakeLists.txt
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_subdirectory(resources)
-add_compile_definitions(
-  velox_codegen_native_loader_test
-  GOODLIBPATH="$<TARGET_FILE:velox_codegen_native_loader_resources_good_library>"
-)
-add_compile_definitions(
-  velox_codegen_native_loader_test
-  BADLIBPATH="$<TARGET_FILE:velox_codegen_native_loader_resources_bad_library>")
-add_compile_definitions(
-  velox_codegen_native_loader_test
-  TYPEINFO="$<TARGET_FILE:velox_codegen_native_loader_resources_typeinfo_library>"
-)
-add_executable(velox_codegen_native_loader_test NativeLoaderTest.cpp)
-add_test(velox_codegen_native_loader_test velox_codegen_native_loader_test)
-add_dependencies(
-  velox_codegen_native_loader_test
-  velox_codegen_native_loader_resources_good_library
-  velox_codegen_native_loader_resources_bad_library
-  velox_codegen_native_loader_resources_typeinfo_library)
-target_link_libraries(
-  velox_codegen_native_loader_test
-  gtest
-  gtest_main
-  Folly::folly
-  gflags::gflags
-  glog::glog
-  fmt::fmt)
diff --git a/velox/experimental/codegen/library_loader/tests/NativeLoaderTest.cpp b/velox/experimental/codegen/library_loader/tests/NativeLoaderTest.cpp
deleted file mode 100644
index df0b87b93ae7a..0000000000000
--- a/velox/experimental/codegen/library_loader/tests/NativeLoaderTest.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include <iostream>
-#include "velox/experimental/codegen/library_loader/NativeLibraryLoader.h"
-
-TEST(NativeLoaderTest, testCompatibleTypeInfo) {
-  using namespace facebook::velox::codegen::native_loader;
-  NativeLibraryLoader loader;
-  uint64_t initArgument;
-  auto libraryPtr = loader.loadLibrary(std::string(TYPEINFO), &initArgument);
-  auto getStringTypeInfoAddress =
-      loader.getFunction<const void* (*)()>("stringTypeInfo", libraryPtr);
-  ASSERT_EQ(getStringTypeInfoAddress(), &typeid(std::string));
-}
-
-TEST(NativeLoaderTest, testWrongPath) {
-  using namespace facebook::velox::codegen::native_loader;
-  NativeLibraryLoader loader;
-  EXPECT_THROW(
-      loader.loadLibrary(std::string("non-existng")),
-      NativeLibraryLoaderException);
-}
-
-TEST(NativeLoaderTest, illFormedLibrary) {
-  using namespace facebook::velox::codegen::native_loader;
-  NativeLibraryLoader loader;
-  EXPECT_THROW(loader.loadLibrary(BADLIBPATH), NativeLibraryLoaderException);
-};
-
-TEST(NativeLoaderTest, testWrongFunctionName) {
-  using namespace facebook::velox::codegen::native_loader;
-  NativeLibraryLoader loader;
-  uint64_t initArgument;
-  auto libraryPtr = loader.loadLibrary(
-      std::string(GOODLIBPATH),
-      &initArgument); // GOODLIBPATH defined in cmake file
-  using InitType = void (*)();
-  EXPECT_THROW(
-      loader.getFunction<InitType>("init", libraryPtr),
-      NativeLibraryLoaderException);
-}
-
-TEST(NativeLoaderTest, testWrongFunctionSignature) {
-  using namespace facebook::velox::codegen::native_loader;
-  NativeLibraryLoader loader;
-  uint64_t initArgument;
-  auto libraryPtr = loader.loadLibrary(
-      std::string(GOODLIBPATH),
-      &initArgument); // GOODLIBPATH defined in cmake file
-  using wrongType1 =
-      int (*)(int* a, void* b); // expected type is int (*)(void* a, void* b)
-  EXPECT_THROW(
-      loader.getFunction<wrongType1>("function1", libraryPtr),
-      NativeLibraryLoaderException);
-}
-
-TEST(NativeLoaderTest, testCallResult) {
-  using namespace facebook::velox::codegen::native_loader;
-  NativeLibraryLoader loader;
-  uint64_t initArgument;
-  auto libraryPtr = loader.loadLibrary(
-      std::string(GOODLIBPATH),
-      &initArgument); // GOODLIBPATH defined in cmake file
-  using Type1 = int (*)(void* a, void* b);
-  using Type2 = int (*)(void* a, void* b);
-
-  auto function1 = loader.getFunction<Type1>("function1", libraryPtr);
-  auto callResult1 =
-      function1(reinterpret_cast<void*>(1), reinterpret_cast<void*>(2));
-  auto function2 = loader.getFunction<Type2>("function2", libraryPtr);
-  auto callResult2 =
-      function2(reinterpret_cast<void*>(1), reinterpret_cast<void*>(2));
-  ASSERT_EQ(callResult1, 3);
-  ASSERT_EQ(callResult2, -1);
-}
-
-TEST(NativeLoaderTest, testlibraryUnload) {
-  using namespace facebook::velox::codegen::native_loader;
-  NativeLibraryLoader loader;
-  uint64_t initArgument = 45;
-  auto libraryPtr = loader.loadLibrary(
-      std::string(GOODLIBPATH),
-      &initArgument); // GOODLIBPATH defined in cmake file
-  uint64_t releaseArgument = 0;
-  loader.unLoadLibrary(libraryPtr, &releaseArgument);
-  ASSERT_EQ(initArgument, releaseArgument);
-}
diff --git a/velox/experimental/codegen/library_loader/tests/TARGETS_tests_disabled b/velox/experimental/codegen/library_loader/tests/TARGETS_tests_disabled
deleted file mode 100644
index ba8fc29046790..0000000000000
--- a/velox/experimental/codegen/library_loader/tests/TARGETS_tests_disabled
+++ /dev/null
@@ -1,25 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
-
-cpp_unittest(
-    name = "f4d_codegen_native_loader_test",
-    srcs = [
-        "NativeLoaderTest.cpp",
-    ],
-    headers = [],
-    linker_flags = ["-export-dynamic"],
-    preprocessor_flags = [
-        "-DCODEGEN_ENABLED=1",
-        "-DGOODLIBPATH=\"$(location //f4d/experimental/codegen/library_loader/tests/resources:f4d_codegen_native_loader_resources_good_library.so)\"",
-        "-DBADLIBPATH=\"$(location //f4d/experimental/codegen/library_loader/tests/resources:f4d_codegen_native_loader_resources_bad_library.so)\"",
-        "-DTYPEINFO=\"$(location //f4d/experimental/codegen/library_loader/tests/resources:f4d_codegen_native_loader_resources_typeinfo_library.so)\"",
-    ],
-    deps = [
-        "//f4d/experimental/codegen/library_loader:f4d_codegen_native_loader",
-        "//f4d/experimental/codegen/library_loader/tests/resources:f4d_codegen_native_loader_resources_bad_library.so",  # @manual
-        "//f4d/experimental/codegen/library_loader/tests/resources:f4d_codegen_native_loader_resources_good_library.so",  # @manual
-        "//f4d/experimental/codegen/library_loader/tests/resources:f4d_codegen_native_loader_resources_typeinfo_library.so",  # @manual
-    ],
-    external_deps = [
-        "glog",
-    ],
-)
diff --git a/velox/experimental/codegen/library_loader/tests/resources/CMakeLists.txt b/velox/experimental/codegen/library_loader/tests/resources/CMakeLists.txt
deleted file mode 100644
index 15fef116799d2..0000000000000
--- a/velox/experimental/codegen/library_loader/tests/resources/CMakeLists.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_codegen_native_loader_resources_good_library SHARED
-            SampleTestLibrary.cpp)
-add_library(velox_codegen_native_loader_resources_bad_library SHARED
-            SampleTestBadLibrary.cpp)
-add_library(velox_codegen_native_loader_resources_typeinfo_library SHARED
-            DynamicTestLibrary.cpp)
diff --git a/velox/experimental/codegen/library_loader/tests/resources/DynamicTestLibrary.cpp b/velox/experimental/codegen/library_loader/tests/resources/DynamicTestLibrary.cpp
deleted file mode 100644
index 6e5c9d719eda2..0000000000000
--- a/velox/experimental/codegen/library_loader/tests/resources/DynamicTestLibrary.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <iostream>
-#include <memory>
-#include <typeinfo>
-#include <vector>
-
-#include "velox/experimental/codegen/library_loader/FunctionTable.h"
-
-// Sample functions for testing only
-// Assume that the arguments to init/release are valid uint64 pointers
-
-const void* stringTypeInfo() {
-  return &typeid(std::string);
-}
-
-std::shared_ptr<FunctionTable> functionTable;
-static uint64_t saved;
-extern "C" {
-
-bool init(void* param) {
-  functionTable = std::make_shared<FunctionTable>();
-  registerFunction("stringTypeInfo", &stringTypeInfo, *functionTable);
-  saved = *static_cast<uint64_t*>(param);
-  return true;
-}
-
-void release(void* param) {
-  *static_cast<uint64_t*>(param) = saved;
-};
-
-std::shared_ptr<FunctionTable> getFunctionTable() {
-  return functionTable;
-};
-}
diff --git a/velox/experimental/codegen/library_loader/tests/resources/SampleTestBadLibrary.cpp b/velox/experimental/codegen/library_loader/tests/resources/SampleTestBadLibrary.cpp
deleted file mode 100644
index 42956fff853da..0000000000000
--- a/velox/experimental/codegen/library_loader/tests/resources/SampleTestBadLibrary.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <memory>
-#include <typeinfo>
-#include <vector>
-
-#include "velox/experimental/codegen/library_loader/FunctionTable.h"
-
-// Sample functions for testing only
-// Test ill formed libraries.
-
-extern "C" {
-
-// Missing required function;
-// bool init() {};
-void release(void*){};
-std::shared_ptr<FunctionTable> getFunctionTable() {
-  return nullptr;
-};
-}
diff --git a/velox/experimental/codegen/library_loader/tests/resources/SampleTestLibrary.cpp b/velox/experimental/codegen/library_loader/tests/resources/SampleTestLibrary.cpp
deleted file mode 100644
index c359a2497b0cc..0000000000000
--- a/velox/experimental/codegen/library_loader/tests/resources/SampleTestLibrary.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <iostream>
-#include <memory>
-#include <typeinfo>
-#include <vector>
-
-#include "velox/experimental/codegen/library_loader/FunctionTable.h"
-
-// Sample functions for testing only
-// Assume that the arguments to init/release are valid uint64 pointers
-
-int function1(void* a, void* b) {
-  return reinterpret_cast<int64_t>(a) + reinterpret_cast<int64_t>(b);
-}
-int function2(void* a, void* b) {
-  return reinterpret_cast<int64_t>(a) - reinterpret_cast<int64_t>(b);
-}
-std::shared_ptr<FunctionTable> functionTable;
-static uint64_t saved;
-extern "C" {
-
-bool init(void* param) {
-  functionTable = std::make_shared<FunctionTable>();
-  registerFunction("function1", &function1, *functionTable);
-  registerFunction("function2", &function2, *functionTable);
-  saved = *static_cast<uint64_t*>(param);
-  return true;
-}
-
-void release(void* param) {
-  *static_cast<uint64_t*>(param) = saved;
-};
-
-std::shared_ptr<FunctionTable> getFunctionTable() {
-  return functionTable;
-};
-}
diff --git a/velox/experimental/codegen/library_loader/tests/resources/TARGETS_disabled b/velox/experimental/codegen/library_loader/tests/resources/TARGETS_disabled
deleted file mode 100644
index fcef5efc28988..0000000000000
--- a/velox/experimental/codegen/library_loader/tests/resources/TARGETS_disabled
+++ /dev/null
@@ -1,46 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_binary.bzl", "cpp_binary")
-
-cpp_binary(
-    name = "velox_codegen_native_loader_resources_good_library.so",
-    srcs = [
-        "SampleTestLibrary.cpp",
-    ],
-    headers = [
-    ],
-    dlopen_enabled = True,
-    deps = [
-        "//velox/experimental/codegen/library_loader:velox_codegen_native_loader",
-    ],
-    external_deps = [
-    ],
-)
-
-cpp_binary(
-    name = "velox_codegen_native_loader_resources_bad_library.so",
-    srcs = [
-        "SampleTestBadLibrary.cpp",
-    ],
-    headers = [
-    ],
-    dlopen_enabled = True,
-    deps = [
-        "//velox/experimental/codegen/library_loader:velox_codegen_native_loader",
-    ],
-    external_deps = [
-    ],
-)
-
-cpp_binary(
-    name = "velox_codegen_native_loader_resources_typeinfo_library.so",
-    srcs = [
-        "DynamicTestLibrary.cpp",
-    ],
-    headers = [
-    ],
-    dlopen_enabled = True,
-    deps = [
-        "//velox/experimental/codegen/library_loader:velox_codegen_native_loader",
-    ],
-    external_deps = [
-    ],
-)
diff --git a/velox/experimental/codegen/proto/CMakeLists.txt b/velox/experimental/codegen/proto/CMakeLists.txt
deleted file mode 100644
index a5dbc59b8e474..0000000000000
--- a/velox/experimental/codegen/proto/CMakeLists.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_custom_command(
-  OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/codegen_proto.pb.cc"
-  COMMAND protoc codegen_proto.proto -I "${CMAKE_CURRENT_SOURCE_DIR}"
-          --cpp_out="${CMAKE_CURRENT_SOURCE_DIR}")
-
-add_library(velox_codegen_proto codegen_proto.pb.cc)
-target_link_libraries(velox_codegen_proto ${Protobuf_LIBRARIES})
diff --git a/velox/experimental/codegen/proto/CompilerOptionsTemplate.json b/velox/experimental/codegen/proto/CompilerOptionsTemplate.json
deleted file mode 100644
index 5fe68abdf72c4..0000000000000
--- a/velox/experimental/codegen/proto/CompilerOptionsTemplate.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "useSymbolsForArithmetic":false,
-    "compilerOptions":{
-        "optimizationLevel":"",
-        "extraCompileOption":[],
-        "extraLinkOptions":[],
-        "defaultLibraries":[
-            {
-                "name":"",
-                "includePath":[],
-                "linkerSearchPath":[],
-                "libraryNames":[],
-                "additionalLinkerObject":[]
-            }
-        ],
-        "compilerPath":"",
-        "linker":"",
-        "formatterPath":"",
-        "tempDirectory":""
-    }
-}
diff --git a/velox/experimental/codegen/proto/ProtoUtils.h b/velox/experimental/codegen/proto/ProtoUtils.h
deleted file mode 100644
index 86cbb34f31141..0000000000000
--- a/velox/experimental/codegen/proto/ProtoUtils.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-#include <google/protobuf/util/json_util.h>
-#include <fstream>
-
-namespace facebook::velox::codegen::proto {
-
-namespace proto_utils {
-static std::stringstream readFromFile(const std::filesystem::path& filePath) {
-  /// Use std library instead of velox::common::file::LocalReadFile because
-  /// LocalReadFile does not automatically decode the binary representation
-  /// to string representation in memory
-  std::stringstream ss;
-  ss << std::ifstream(filePath.string()).rdbuf();
-  return ss;
-}
-
-template <typename ProtoType>
-struct ProtoUtils {
-  static ProtoType loadProtoFromFile(
-      const std::filesystem::path& jsonFilePath) {
-    return loadProtoFromJson(readFromFile(jsonFilePath).str());
-  }
-
-  static ProtoType loadProtoFromJson(std::string_view jsonString) {
-    ProtoType proto;
-    auto status =
-        google::protobuf::util::JsonStringToMessage(jsonString.data(), &proto);
-    if (!status.ok()) {
-      throw std::logic_error(
-          "Failed to load proto from JsonString: " +
-          status.message().as_string());
-    }
-    return proto;
-  }
-
-  static std::string formatAsJson(const ProtoType& proto) {
-    std::string output;
-    auto status = google::protobuf::util::MessageToJsonString(proto, &output);
-    if (!status.ok()) {
-      throw std::logic_error(
-          "Failed to format proto as Json" + status.message().as_string());
-    }
-    return output;
-  }
-};
-
-}; // namespace proto_utils
-
-} // namespace facebook::velox::codegen::proto
diff --git a/velox/experimental/codegen/proto/codegen_proto.proto b/velox/experimental/codegen/proto/codegen_proto.proto
deleted file mode 100644
index 22e0d51639691..0000000000000
--- a/velox/experimental/codegen/proto/codegen_proto.proto
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-syntax = "proto3";
-
-package facebook.velox.codegen.proto;
-
-message LibraryDescriptorProto {
-  string name = 1; // Library name, not used in command line
-  repeated string includePath = 2; // -I
-  repeated string systemIncludePath = 3; // -isystem
-  repeated string linkerSearchPath = 4; // -L
-  repeated string libraryNames = 5; // -l
-  // Used to referenced linker object not in the default search paths.
-  repeated string additionalLinkerObject = 6;
-}
-
-message CompilerOptionsProto {
-  string optimizationLevel = 1;
-  repeated string extraCompileOption = 2;
-  repeated string extraLinkOptions = 3;
-  repeated LibraryDescriptorProto defaultLibraries = 4;
-  string compilerPath = 5;
-  string linker = 6;
-  string formatterPath = 7;
-  string tempDirectory = 8;
-}
-
-message CodegenOptionsProto {
-  bool useSymbolsForArithmetic = 1;
-  CompilerOptionsProto compilerOptions = 2;
-}
diff --git a/velox/experimental/codegen/proto/protobuf.sh b/velox/experimental/codegen/proto/protobuf.sh
deleted file mode 100755
index 7f3348f4eeaca..0000000000000
--- a/velox/experimental/codegen/proto/protobuf.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"${PROTOC}" "${PROTO_FILE}" "--${LANG}_out=$INSTALL_DIR"
diff --git a/velox/experimental/codegen/tests/CMakeLists.txt b/velox/experimental/codegen/tests/CMakeLists.txt
deleted file mode 100644
index b3f91ca078d4a..0000000000000
--- a/velox/experimental/codegen/tests/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_executable(velox_experimental_codegen_test CodegenTest.cpp)
-add_dependencies(velox_experimental_codegen_test velox_codegen_expression_test)
-target_link_libraries(
-  velox_experimental_codegen_test
-  gtest
-  gtest_main
-  velox_core
-  velox_exec
-  velox_experimental_codegen
-  velox_exec_test_lib
-  velox_functions_prestosql
-  velox_hive_connector
-  velox_codegen_utils_resource_path)
-
-add_test(velox_experimental_codegen_test velox_experimental_codegen_test)
diff --git a/velox/experimental/codegen/tests/CodegenASTAnalysisTest.cpp b/velox/experimental/codegen/tests/CodegenASTAnalysisTest.cpp
deleted file mode 100644
index f1ad02f758c9a..0000000000000
--- a/velox/experimental/codegen/tests/CodegenASTAnalysisTest.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/CodegenASTAnalysis.h"
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include <iostream>
-#include <memory>
-#include "velox/core/PlanNode.h"
-#include "velox/dwio_move/common/tests/utils/BatchMaker.h"
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/CompiledExpressionAnalysis.h"
-#include "velox/experimental/codegen/tests/CodegenTestBase.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/Expressions.h"
-#include "velox/parse/ExpressionsParser.h"
-#include "velox/parse/TypeResolver.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::codegen;
-using namespace facebook::velox::core;
-using namespace facebook::velox::test;
-
-namespace facebook::velox::codegen {
-
-auto parseTypedExprs(
-    const std::vector<std::string>& stringExprs,
-    std::shared_ptr<const RowType>& rowType,
-    const parse::ParseOptions& options) {
-  std::vector<std::shared_ptr<const core::ITypedExpr>> typedExprs;
-  for (const auto& stringExpr : stringExprs) {
-    auto untyped = parse::parseExpr(stringExpr, options);
-    auto typed = core::Expressions::inferTypes(untyped, rowType);
-    typedExprs.push_back(std::move(typed));
-  };
-  return typedExprs;
-}
-
-class GenerateAstTest : public CodegenTestBase {
- protected:
-  void SetUp() override {
-    functions::prestosql::registerAllFunctions();
-
-    registerVeloxArithmeticUDFs(udfManager_);
-    useBuiltInForArithmetic_ = false;
-
-    pool_ = memory::addDefaultLeafMemoryPool();
-
-    rowType_ = ROW({"c0", "c1", "c2"}, {DOUBLE(), DOUBLE(), DOUBLE()});
-
-    vector_ = std::vector<RowVectorPtr>{std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 10, *pool_))};
-
-    auto valueNode = std::make_shared<ValuesNode>(
-        "valueNode", std::vector<RowVectorPtr>{vector_});
-
-    std::vector<std::string> exprString{"c0 + c1", "c1 - c0"};
-
-    auto projections = parseTypedExprs(exprString, rowType_, options_);
-
-    project_ = std::make_shared<ProjectNode>(
-        "projection",
-        std::vector<std::string>{"p", "m"},
-        projections,
-        valueNode);
-  };
-
-  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
-
-  std::shared_ptr<ProjectNode> project_;
-  std::shared_ptr<const RowType> rowType_;
-  std::vector<RowVectorPtr> vector_;
-
-  bool useBuiltInForArithmetic_;
-  UDFManager udfManager_;
-  parse::ParseOptions options_;
-};
-
-TEST_F(GenerateAstTest, CreateAST) {
-  CodegenASTAnalysis astAnalysis(udfManager_, useBuiltInForArithmetic_);
-  astAnalysis.run(*project_.get());
-
-  EXPECT_EQ(astAnalysis.nodes().size(), 2);
-
-  for (const auto& projection : project_->projections()) {
-    EXPECT_EQ(astAnalysis.nodes().count(projection), 1);
-  }
-};
-
-TEST_F(GenerateAstTest, CreateASTSourceCode) {
-  CompiledExpressionAnalysis compiled(udfManager_, useBuiltInForArithmetic_);
-  compiled.run(*project_.get());
-
-  EXPECT_EQ(compiled.code().size(), 2);
-
-  for (const auto& projection : project_->projections()) {
-    EXPECT_EQ(compiled.code().count(projection), 1);
-  }
-};
-
-TEST_F(GenerateAstTest, CompiledExpr) {
-  CompiledExpressionAnalysis expressionAnalysis(
-      udfManager_, useBuiltInForArithmetic_);
-  expressionAnalysis.run(*project_.get());
-  facebook::velox::codegen::detail::Visitor visitor(
-      expressionAnalysis.code(), this->defaultCompilerOptions());
-  auto newProject =
-      std::dynamic_pointer_cast<facebook::velox::core::ProjectNode>(
-          visitor.visit(*project_.get(), project_->sources()));
-  for (const auto projectExpr : newProject->projections()) {
-    // Check we generated ICompiledCode nodes.
-    auto callExpression =
-        std::dynamic_pointer_cast<const codegen::ICompiledCall>(
-            projectExpr->inputs()[0]);
-    ASSERT_NE(callExpression, nullptr);
-  };
-};
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/tests/CodegenTest.cpp b/velox/experimental/codegen/tests/CodegenTest.cpp
deleted file mode 100644
index c3431ea2cb1d2..0000000000000
--- a/velox/experimental/codegen/tests/CodegenTest.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/Codegen.h"
-#include <gtest/gtest.h>
-#include "velox/core/PlanNode.h"
-#include "velox/experimental/codegen/CodegenExceptions.h"
-#include "velox/experimental/codegen/tests/CodegenTestBase.h"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-#include "velox/type/Type.h"
-namespace facebook::velox::codegen {
-class CodegenTest : public CodegenTestBase {};
-
-TEST_F(CodegenTest, simpleProjectionDefaultNull) {
-  auto inputRowType = ROW({"a", "b"}, std::vector<TypePtr>{DOUBLE(), DOUBLE()});
-  testExpressions<DoubleType, DoubleType>(
-      {"a + b", "a - b"}, inputRowType, 10, 100);
-};
-
-TEST_F(CodegenTest, simpleProjectionNotDefaultNull) {
-  auto inputRowType = ROW({"a", "b"}, std::vector<TypePtr>{DOUBLE(), DOUBLE()});
-  testExpressions<DoubleType, DoubleType>({"a", "b"}, inputRowType, 10, 100);
-  testExpressions<DoubleType, DoubleType>(
-      {"if(a > b , a + b, a - b)", "if( a < b , a - b, a + b)"},
-      inputRowType,
-      10,
-      100);
-};
-
-TEST_F(CodegenTest, compile) {
-  auto codegenLogger = std::make_shared<codegen::DefaultLogger>("codegen test");
-  Codegen codegen(codegenLogger);
-  // check that the correct weak symbol is used
-  EXPECT_THROW(
-      codegen.initialize("dummy json string"), CodegenInitializationException);
-};
-
-TEST_F(CodegenTest, simpleProjectionWithConstantFields) {
-  auto inputRowType = ROW({"a", "b"}, std::vector<TypePtr>{DOUBLE(), DOUBLE()});
-  testExpressions<DoubleType>("a>b", {"2.0"}, inputRowType, 10, 100);
-};
-
-TEST_F(CodegenTest, DISABLED_simpleProjectionWithFilter) {
-  auto inputRowType = ROW({"a", "b"}, std::vector<TypePtr>{DOUBLE(), DOUBLE()});
-  testExpressions<DoubleType, DoubleType>(
-      "a > b", {" a + b", "a - b"}, inputRowType, 10, 100);
-  testExpressions<DoubleType>("NOT a IS NULL", {"a"}, inputRowType, 10, 100);
-};
-
-TEST_F(CodegenTest, reorderedInput) {
-  std::shared_ptr<const RowType> inputRowType =
-      ROW({"a", "b", "c", "d"},
-          std::vector<TypePtr>{DOUBLE(), DOUBLE(), DOUBLE(), DOUBLE()});
-
-  testExpressions<DoubleType>({"if(d>c , b, a)"}, inputRowType, 10, 100);
-};
-
-TEST_F(CodegenTest, booleanProjection) {
-  auto inputRowType = ROW(
-      {"a", "b", "d"}, std::vector<TypePtr>{BOOLEAN(), BOOLEAN(), DOUBLE()});
-  testExpressions<DoubleType>({"if(a and b, 1.1, 1.2)"}, inputRowType, 1, 10);
-};
-
-TEST_F(CodegenTest, stringInputProjection) {
-  auto inputRowType = ROW({"a"}, std::vector<TypePtr>{VARCHAR()});
-  testExpressions<BigintType>({"length(a)"}, inputRowType, 10, 100);
-};
-
-TEST_F(CodegenTest, stringInputProjection2) {
-  auto inputRowType =
-      ROW({"a", "b"}, std::vector<TypePtr>{VARCHAR(), VARCHAR()});
-  testExpressions<BooleanType>({"length(a)>length(b)"}, inputRowType, 10, 100);
-};
-
-// T94073748
-// TEST_F(CodegenTest, stringOutputProjectionInput) {
-//   auto inputRowType =
-//       ROW({"a", "b"}, std::vector<TypePtr>{VARCHAR(), VARCHAR()});
-//   testExpressions<VarcharType, VarcharType>({"a", "b"}, inputRowType, 10,
-//   100);
-// };
-
-TEST_F(CodegenTest, stringOutputProjectionUDF) {
-  auto inputRowType =
-      ROW({"a", "b"}, std::vector<TypePtr>{VARCHAR(), VARCHAR()});
-  testExpressions<VarcharType, VarcharType, VarcharType>(
-      {"upper(a)", "lower(b)", "concat(a,'aaa',b)"}, inputRowType, 1, 100);
-};
-
-TEST_F(CodegenTest, stringCompound) {
-  auto inputRowType = ROW({"a"}, std::vector<TypePtr>{VARCHAR()});
-  testExpressions<VarcharType>({"lower(upper(a))"}, inputRowType, 10, 100);
-};
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/tests/CodegenTestBase.h b/velox/experimental/codegen/tests/CodegenTestBase.h
deleted file mode 100644
index 0f4bb17960496..0000000000000
--- a/velox/experimental/codegen/tests/CodegenTestBase.h
+++ /dev/null
@@ -1,426 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-
-#include <folly/Benchmark.h>
-#include <folly/init/Init.h>
-
-#include <optional>
-#include "velox/core/PlanNode.h"
-#include "velox/dwio/common/tests/utils/BatchMaker.h"
-#include "velox/exec/Operator.h"
-#include "velox/exec/tests/utils/Cursor.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/experimental/codegen/CodegenCompiledExpressionTransform.h"
-#include "velox/experimental/codegen/CodegenLogger.h"
-#include "velox/experimental/codegen/code_generator/ExprCodeGenerator.h"
-#include "velox/experimental/codegen/utils/resources/ResourcePath.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/Expressions.h"
-#include "velox/parse/ExpressionsParser.h"
-#include "velox/parse/TypeResolver.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::codegen {
-
-using namespace facebook::velox;
-using namespace facebook::velox::exec;
-using namespace facebook::velox::exec::test;
-
-using facebook::velox::test::BatchMaker;
-
-class CodegenTestCore {
- protected:
-  constexpr static TransformFlags defaultFlags =
-      CodegenCompiledExpressionTransform::defaultFlags;
-  /// For future use, evaluate expression without creating a plan node.
-  /// \tparam SQLType
-  /// \param inputRowBatches input  data
-  /// \param selectedRows
-  /// \param exprString string representation of the expression to evaluate
-  /// \return RowPtr results
-  template <typename... SQLType>
-  std::vector<VectorPtr> evalExpr(
-      RowVector& inputRowBatches,
-      SelectivityVector& selectedRows,
-      const std::vector<std::string>& exprString) {
-    auto types = std::vector<std::shared_ptr<const Type>>{
-        std::make_shared<SQLType>()...,
-    };
-
-    std::vector<std::shared_ptr<const core::ITypedExpr>> typedExprs;
-    for (auto& expr : exprString) {
-      typedExprs.push_back(makeTypedExpr(expr, inputRowBatches.type()));
-    };
-
-    facebook::velox::exec::ExprSet exprSet(
-        std::move(typedExprs), execCtx_.get());
-    EvalCtx context(execCtx_.get(), &exprSet, &inputRowBatches);
-    std::vector<VectorPtr> results(sizeof...(SQLType));
-    exprSet.eval(
-        0, sizeof...(SQLType) - 1, true, selectedRows, context, results);
-    return results;
-  }
-
-  // Copied from ExprTest.cpp
-  std::shared_ptr<const core::ITypedExpr> makeTypedExpr(
-      const std::string& text,
-      const TypePtr& rowType) {
-    auto untyped = parse::parseExpr(text, options_);
-    return core::Expressions::inferTypes(untyped, rowType, pool_.get());
-  }
-
-  void init(const std::vector<std::string>& customCompilerOptions = {}) {
-    CompilerOptions compilerOptions = defaultCompilerOptions();
-
-    compilerOptions.extraCompileOptions.insert(
-        compilerOptions.extraCompileOptions.end(),
-        customCompilerOptions.begin(),
-        customCompilerOptions.end());
-
-    registerVeloxArithmeticUDFs(udfManager_);
-    registerVeloxStringFunctions(udfManager_);
-
-    useSymbolForArithmetic_ = false;
-    codegenTransformation_ =
-        std::make_unique<CodegenCompiledExpressionTransform>(
-            compilerOptions,
-            udfManager_,
-            useSymbolForArithmetic_,
-            eventSequence_);
-    pool_ = memory::addDefaultLeafMemoryPool();
-    queryCtx_ = std::make_shared<core::QueryCtx>(executor_.get());
-    execCtx_ = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get());
-
-    parse::registerTypeResolver();
-    functions::prestosql::registerAllScalarFunctions();
-  }
-
-  /// Creates a plan node given filter and a list of projection
-  /// \tparam SQLType input row type
-  /// \param filterString filter expression
-  /// \param projectionString projection expression list
-  /// \param names
-  /// \param inputVectors
-  /// \return projectionNode Pointer
-  template <typename... SQLType>
-  auto createPlanNodeFromExpr(
-      const std::string& filterExpr,
-      const std::vector<std::string>& projectionExprs,
-      const std::vector<RowVectorPtr>& inputVectors) {
-    auto plan = PlanBuilder().values(inputVectors);
-    if (!filterExpr.empty()) {
-      plan.filter(filterExpr);
-    }
-    if (!projectionExprs.empty()) {
-      plan.project(projectionExprs);
-    }
-    return plan.planNode();
-  }
-
-  template <typename... SQLType>
-  auto createRowType(std::vector<std::string> names) {
-    std::vector<std::shared_ptr<const Type>>&& types{
-        std::make_shared<SQLType>()...,
-    };
-    return ROW(std::move(names), std::move(types));
-  }
-
-  /// Default compiler options.
-  /// \return default testing option.
-  CompilerOptions defaultCompilerOptions() {
-    std::string packageJson = ResourcePath::getResourcePath();
-    auto defaultCompilerOptions =
-        compiler_utils::CompilerOptions::fromJsonFile(packageJson);
-    return defaultCompilerOptions;
-  }
-
-  /// Create input datasets.
-  /// \param batches Number of splits
-  /// \param rowPerBatch number of rows per split
-  /// \param type
-  /// \return list of data rows
-  std::vector<RowVectorPtr> createRowVector(
-      size_t batches,
-      size_t rowPerBatch,
-      const std::shared_ptr<const Type>& type,
-      const std::function<bool(vector_size_t /*index*/)>& isNullAt = nullptr) {
-    std::vector<RowVectorPtr> vectors;
-    for (int32_t i = 0; i < batches; ++i) {
-      auto vector = std::dynamic_pointer_cast<RowVector>(
-          BatchMaker::createBatch(type, rowPerBatch, *pool_, isNullAt));
-      vectors.push_back(vector);
-    }
-    return vectors;
-  }
-
-  /// Run a given planNode
-  /// \param planNode
-  /// \param [out] taskCursor a reference to the execution context.
-  /// \return list of  Row vector
-  std::vector<RowVectorPtr> runQuery(
-      const std::shared_ptr<const core::PlanNode>& planNode,
-      std::unique_ptr<TaskCursor>& taskCursor) {
-    CursorParameters params;
-    params.planNode = planNode;
-
-    taskCursor = std::make_unique<TaskCursor>(params);
-
-    std::vector<RowVectorPtr> actualResults;
-    while (taskCursor->moveNext()) {
-      actualResults.push_back(taskCursor->current());
-    };
-    return actualResults;
-  }
-
-  /// Read optional<NativeType> from a given flat vector
-  /// \tparam NativeType
-  /// \param rowVector
-  /// \param rowIndex
-  /// \return optional value
-  template <typename NativeType>
-  std::optional<NativeType> readVectorOptional(
-      const VectorPtr& rowVector,
-      size_t rowIndex) {
-    if (rowVector->as<SimpleVector<NativeType>>()->isNullAt(rowIndex)) {
-      return std::nullopt;
-    };
-    return rowVector->as<SimpleVector<NativeType>>()->valueAt(rowIndex);
-  }
-
-  /// Compares two flat vector of a givent type
-  /// \tparam NativeType
-  /// \param reference
-  /// \param result
-  /// \return nullopt if the vector are equal, or an error string otherwise
-  template <typename NativeType>
-  std::optional<std::string> compareSimpleVector(
-      const VectorPtr& reference,
-      const VectorPtr& result) {
-    // Sanity checks
-    VELOX_CHECK(reference->as<SimpleVector<NativeType>>() != nullptr);
-    VELOX_CHECK_EQ(reference->size(), result->size());
-
-    bool failed = false;
-
-    // Helper function
-    auto printOptional = [](const auto& optional, std::ostream& out) {
-      if (optional.has_value()) {
-        out << *optional;
-      } else {
-        out << "null";
-      };
-    };
-
-    std::stringstream message;
-    for (size_t rowIndex = 0; rowIndex < reference->size(); ++rowIndex) {
-      auto referenceValue = readVectorOptional<NativeType>(reference, rowIndex);
-      auto resultValue = readVectorOptional<NativeType>(result, rowIndex);
-      if (referenceValue != resultValue) {
-        message << rowIndex << ",\t";
-        printOptional(referenceValue, message);
-        message << ",\t";
-        printOptional(resultValue, message);
-        message << ",\n";
-        failed = true;
-      };
-    }
-    return failed ? std::make_optional(message.str()) : std::nullopt;
-  }
-
-  /// Compares two RowVector given a sequence of native types
-  /// \tparam NativeType
-  /// \tparam Index
-  /// \param reference
-  /// \param result
-  /// \return
-  template <typename... NativeType, size_t... Index>
-  bool compareRowVector(
-      const RowVectorPtr& reference,
-      const RowVectorPtr& result,
-      const std::index_sequence<Index...>&) {
-    if (reference->size() != result->size()) {
-      return true;
-    }
-
-    std::array<std::optional<std::string>, sizeof...(NativeType)> errors{
-        compareSimpleVector<NativeType>(
-            reference->childAt(Index), result->childAt(Index))...,
-    };
-
-    bool failed = false;
-    for (size_t idx = 0; idx < sizeof...(NativeType); ++idx) {
-      if (errors[idx].has_value()) {
-        std::cout << fmt::format(
-                         "Column {} with name {} failed to compare",
-                         idx,
-                         std::dynamic_pointer_cast<const RowType>(
-                             reference->type())
-                             ->nameOf(idx))
-                  << std::endl;
-        std::cout << errors[idx].value() << std::endl;
-        failed = true;
-      }
-    }
-    return failed;
-  }
-
-  std::shared_ptr<folly::Executor> executor_{
-      std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
-  std::unique_ptr<CodegenCompiledExpressionTransform> codegenTransformation_;
-  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
-  std::unique_ptr<core::ExecCtx> execCtx_;
-  std::shared_ptr<core::QueryCtx> queryCtx_;
-  UDFManager udfManager_;
-  bool useSymbolForArithmetic_;
-  NamedSteadyClockEventSequence eventSequence_;
-  parse::ParseOptions options_;
-};
-
-class CodegenTestBase : public CodegenTestCore, public testing::Test {
- protected:
-  /// Run the  same expressions with and without the codegen and
-  /// compare the results
-  /// \tparam SQLType
-  /// \param filter
-  /// \param projection
-  /// \param inputRowType
-  /// \param testBatches
-  /// \param rowPerBatch
-  /// \param transform flags
-  /// \return void
-  template <typename... SQLType>
-  auto testExpressionsWithFlags(
-      const std::string& filterExpr,
-      const std::vector<std::string>& projectionExprs,
-      const std::shared_ptr<const RowType>& inputRowType,
-      size_t testBatches,
-      size_t rowPerBatch,
-      const TransformFlags flags) {
-    auto codegenLogger = std::make_shared<codegen::DefaultLogger>(filterExpr);
-    // Creating the test plan
-    // Create input vectors with 10% nulls each
-    auto inputVectors = createRowVector(
-        testBatches, rowPerBatch, inputRowType, [](vector_size_t index) {
-          return index % 10;
-        });
-
-    auto plan = createPlanNodeFromExpr<SQLType...>(
-        filterExpr, projectionExprs, inputVectors);
-
-    // Reference execution
-    std::unique_ptr<TaskCursor> referenceTaskCursor;
-    auto references = runQuery(plan, referenceTaskCursor);
-
-    // Set transform flags
-    codegenTransformation_->setTransformFlags(flags);
-
-    // Compiled execution
-    codegenLogger->onCompileStart(*(plan));
-    auto compiledPlan = codegenTransformation_->transform(*plan);
-
-    // Print timing information
-    codegenLogger->onCompileEnd(eventSequence_, *(plan));
-    eventSequence_.clear();
-
-    std::unique_ptr<TaskCursor> compiledTaskCursor;
-    auto results = runQuery(compiledPlan, compiledTaskCursor);
-
-    ASSERT_EQ(results.size(), testBatches)
-        << "expected result size is " << testBatches << " but got "
-        << results.size();
-
-    for (size_t batchIdx = 0; batchIdx < testBatches; ++batchIdx) {
-      ASSERT_FALSE(
-          compareRowVector<typename SQLType::NativeType::NativeType...>(
-              references[batchIdx],
-              results[batchIdx],
-              std::index_sequence_for<SQLType...>()));
-    };
-  }
-
-  /// Run the  same expressions with and without the codegen and
-  /// compare the results with only projection
-  /// \tparam SQLType
-  /// \param exprStrings
-  /// \param inputRowType
-  /// \param testBatches
-  /// \param rowPerBatch
-  /// \return void
-  template <typename... SQLType>
-  auto testExpressions(
-      const std::vector<std::string>& exprStrings,
-      const std::shared_ptr<const RowType>& inputRowType,
-      size_t testBatches,
-      size_t rowPerBatch) {
-    testExpressions<SQLType...>(
-        "", exprStrings, inputRowType, testBatches, rowPerBatch);
-  }
-
-  /// Run the  same expressions with and without the codegen and
-  /// compare the results
-  /// \tparam SQLType
-  /// \param filter
-  /// \param projection
-  /// \param inputRowType
-  /// \param testBatches
-  /// \param rowPerBatch
-  /// \param transform flags
-  /// \return void
-  template <typename... SQLType>
-  auto testExpressions(
-      const std::string& filterExpr,
-      const std::vector<std::string>& projectionExprs,
-      const std::shared_ptr<const RowType>& inputRowType,
-      size_t testBatches,
-      size_t rowPerBatch) {
-    testExpressionsWithFlags<SQLType...>(
-        filterExpr,
-        projectionExprs,
-        inputRowType,
-        testBatches,
-        rowPerBatch,
-        defaultFlags);
-
-    /// if it's filter + projection, then also test separated filter and
-    /// projection w/ & w/o compiling filter
-    if (!filterExpr.empty()) {
-      testExpressionsWithFlags<SQLType...>(
-          filterExpr,
-          projectionExprs,
-          inputRowType,
-          testBatches,
-          rowPerBatch,
-          {{0, 0, 1, 1}});
-      testExpressionsWithFlags<SQLType...>(
-          filterExpr,
-          projectionExprs,
-          inputRowType,
-          testBatches,
-          rowPerBatch,
-          {{1, 0, 1, 1}});
-    }
-  }
-
-  virtual void SetUp() override {
-    init();
-  }
-};
-}; // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/tests/TARGETS_disabled b/velox/experimental/codegen/tests/TARGETS_disabled
deleted file mode 100644
index cec8a824271b3..0000000000000
--- a/velox/experimental/codegen/tests/TARGETS_disabled
+++ /dev/null
@@ -1,51 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
-load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
-
-cpp_library(
-    name = "velox_experimental_codegen_test_utils",
-    headers = ["CodegenTestBase.h"],
-    resources = {
-        "include": "//velox/experimental/codegen/code_generator/tests:copy_dependencies[include]",
-        "package_json": "//velox/experimental/codegen/code_generator/tests:copy_dependencies[package.json]",
-    },
-    exported_deps = [
-        "fbsource//third-party/googletest:gtest",
-        "//folly:benchmark",
-        "//velox/core:velox_core",
-        "//velox/dwio/common/tests/utils:lib_test_batch_maker",
-        "//velox/exec:velox_exec_lib",
-        "//velox/exec/tests/utils:velox_exec_test_lib",
-        "//velox/experimental/codegen:velox_experimental_codegen_header",
-        "//velox/experimental/codegen:velox_experimental_codegen_impl",
-        "//velox/experimental/codegen/code_generator:velox_codegen_code_generator",
-        "//velox/experimental/codegen/utils/resources:velox_experimental_codegen_utils_resource_path",
-        "//velox/functions/prestosql/registration:velox_functions_prestosql",
-        "//velox/parse:velox_parse",
-        "//velox/parse:velox_parse_expression",
-        "//velox/type:velox_type",
-    ],
-    exported_external_deps = [
-        "glog",
-    ],
-)
-
-cpp_unittest(
-    name = "velox_experimental_codegen_test",
-    srcs = [
-        "CodegenTest.cpp",
-    ],
-    linker_flags = ["--export-dynamic"],
-    resources = {
-        "include": "//velox/experimental/codegen/code_generator/tests:copy_dependencies[include]",
-        "package_json": "//velox/experimental/codegen/code_generator/tests:copy_dependencies[package.json]",
-    },
-    deps = [
-        ":velox_experimental_codegen_test_utils",
-        "//velox/core:velox_core",
-        "//velox/experimental/codegen:velox_experimental_codegen_exceptions",
-        "//velox/experimental/codegen:velox_experimental_codegen_impl",
-        "//velox/experimental/codegen/utils/timer:velox_codegen_utils_timer",
-        "//velox/functions/prestosql/registration:velox_functions_prestosql",
-        "//velox/type:velox_type",
-    ],
-)
diff --git a/velox/experimental/codegen/transform/CMakeLists.txt b/velox/experimental/codegen/transform/CMakeLists.txt
deleted file mode 100644
index 91d4c9ad1c067..0000000000000
--- a/velox/experimental/codegen/transform/CMakeLists.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-add_library(velox_codegen_transform INTERFACE)
-add_subdirectory(utils)
diff --git a/velox/experimental/codegen/transform/PlanNodeTransform.h b/velox/experimental/codegen/transform/PlanNodeTransform.h
deleted file mode 100644
index cc0893e6cde44..0000000000000
--- a/velox/experimental/codegen/transform/PlanNodeTransform.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <functional>
-#include <map>
-#include <memory>
-#include <optional>
-#include <vector>
-#include "velox/core/PlanNode.h"
-
-/// This header introduces base/abstract classes for the plan node
-/// transformation framework.
-
-namespace facebook {
-namespace velox {
-namespace transform {
-
-// Transformation Base class
-struct PlanNodeTransform {
-  virtual ~PlanNodeTransform() {}
-
-  /// Main entry point to run a transformation
-  /// \param plan
-  /// \return A new transformed plan
-  virtual std::shared_ptr<core::PlanNode> transform(
-      const core::PlanNode& plan) = 0;
-};
-
-auto planNodeTransformCompare = [](const PlanNodeTransform& a,
-                                   const PlanNodeTransform& b) {
-  return &a < &b;
-};
-
-/// Base clases for all analysis
-struct PlanNodeAnalysis {
-  virtual ~PlanNodeAnalysis() {}
-
-  // Run the analysis on the given plan
-  virtual void run(const core::PlanNode& plan) = 0;
-};
-
-struct transformationOptions {
-  std::map<std::string, std::shared_ptr<void>> options;
-};
-
-struct transformationContext {
-  transformationOptions options;
-};
-
-// A transformation sequence is a linear sequence of transformation applied to a
-// planNode.
-struct PlanNodeTransformSequence : public PlanNodeTransform {
-  ~PlanNodeTransformSequence() override {}
-
-  std::vector<std::reference_wrapper<PlanNodeTransform>> transformations;
-  std::map<
-      std::reference_wrapper<PlanNodeTransform>,
-      bool,
-      decltype(planNodeTransformCompare)>
-      shouldRun{planNodeTransformCompare};
-  PlanNodeTransformSequence(
-      const std::vector<std::reference_wrapper<PlanNodeTransform>>&
-          transformations_)
-      : transformations(transformations_) {
-    for (const auto& transformation : transformations_) {
-      shouldRun[transformation] = true;
-    }
-  };
-};
-
-} // namespace transform
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/transform/utils/CMakeLists.txt b/velox/experimental/codegen/transform/utils/CMakeLists.txt
deleted file mode 100644
index c0efdea14bf1b..0000000000000
--- a/velox/experimental/codegen/transform/utils/CMakeLists.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_transform_utils INTERFACE)
-target_link_libraries(velox_transform_utils INTERFACE velox_core)
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
-target_compile_definitions(velox_transform_utils INTERFACE ENABLE_CONCEPTS=0
-                                                           USE_STD_RANGE=0)
diff --git a/velox/experimental/codegen/transform/utils/adapters.h b/velox/experimental/codegen/transform/utils/adapters.h
deleted file mode 100644
index 41169374237d0..0000000000000
--- a/velox/experimental/codegen/transform/utils/adapters.h
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <velox/experimental/codegen/transform/utils/ranges_utils.h>
-#include <functional>
-#include <map>
-#include <memory>
-#include <optional>
-#include <vector>
-#include "velox/core/PlanNode.h"
-
-namespace facebook {
-namespace velox {
-namespace core {
-// Adapter function so core::PlanNode respect the Tree concept
-static auto children(const core::PlanNode& node) {
-  // TODO:  this assume that nodePtr is never null, we need to add a constraints
-  auto getNodes = [](auto& nodePtr) -> auto& {
-    return *nodePtr;
-  };
-
-  auto filterNullptr = [](auto& nodePtr) -> bool { return nodePtr != nullptr; };
-  return node.sources() /*| ranges::views::filter(filterNullptr) */ |
-      ranges::views::transform(getNodes);
-};
-
-// Adapter function so core::ITypedExpr respect the Tree concept
-static auto children(const core::ITypedExpr& node) {
-  auto getNodes = [](auto& inputPtr) -> auto& {
-    return *inputPtr;
-  };
-
-  auto filterNullptr = [](auto& inputPtr) -> bool {
-    return inputPtr != nullptr;
-  };
-
-  return node.inputs() /*| ranges::views::filter(filterNullptr)*/ |
-      ranges::views::transform(getNodes);
-};
-
-} // namespace core
-
-namespace transform {
-namespace utils {
-namespace adapter {
-
-// Adapter function so core::PlanNode respect the Tree concept
-static auto children(const core::PlanNode& node) {
-  // TODO:  this assume that nodePtr is never null, we need to add a constraints
-  auto getNodes = [](auto& nodePtr) -> auto& {
-    return *nodePtr;
-  };
-
-  auto filterNullptr = [](auto& nodePtr) -> bool { return nodePtr != nullptr; };
-
-  return node.sources() /*| ranges::views::filter(filterNullptr)*/ |
-      ranges::views::transform(getNodes);
-};
-
-// Adapter function so core::ITypedExpr respect the Tree concept
-static auto children(const core::ITypedExpr& node) {
-  // TODO:  this assume that nodePtr is never null, we need to add a constraints
-  auto getNodes = [](auto& inputPtr) -> auto& {
-    return *inputPtr;
-  };
-
-  auto filterNullptr = [](auto& nodePtr) -> bool { return nodePtr != nullptr; };
-
-  return node.inputs() /*| ranges::views::filter(filterNullptr)*/ |
-      ranges::views::transform(getNodes);
-};
-
-/**
- * Most of the tree nodes (PlanNode and IExpr) are immutable. This makes
- * implementing tree transformations somewhat verbose. This helper classes
- * simplifies the frequent case where we want to copy a given node and change
- * some(but not all) of it fields.
- *
- * In general this class is not meant to be used directly, and custom
- * specializations are provided bellow for the most important types
- * (core::PlanNode etc... etc...). Example : Given a class A {field1, field2,
- * field3,...} NodeCopy<A>::copyWith(a, newField1, _2,newField3) =  {
- * newField1,field2,newField3}
- *
- * Constraints (TODO : define formaly those constraints in term of c++ concepts)
- *
- * @tparam T
- * @tparam ValueReader
- */
-template <typename CopyType, typename ValueReader>
-struct NodeCopy {
-  using ArgsType =
-      std::invoke_result<decltype(&ValueReader::operator()), CopyType>;
-
-  template <typename... Args>
-  static std::shared_ptr<CopyType> copyWith(const CopyType& t, Args&&... args) {
-    auto oldValues = ValueReader()(t);
-    auto newValues = std::forward_as_tuple(std::forward<Args>(args)...);
-    auto newArguments = copyWithHelper(
-        std::forward<decltype(oldValues)>(oldValues),
-        std::forward<decltype(newValues)>(newValues),
-        std::index_sequence_for<Args...>{});
-    // return std::apply(std::make_shared<T>,newArguments); for some reason
-    // doesn't work
-    return std::apply(
-        [](auto&&... args_) {
-          return std::make_shared<CopyType>(
-              std::forward<decltype(args_)>(args_)...);
-        },
-        std::forward<decltype(newArguments)>(newArguments));
-  }
-
- private:
-  template <typename OldVals, typename NewVals, size_t... I>
-  static auto copyWithHelper(
-      OldVals&& oldVals,
-      NewVals&& newVals,
-      const std::index_sequence<I...>& indices) {
-    // Returns oldVal if newVal is a placeHolder, oldVal otherwise
-    // This is use to select which value to preserve between the original
-    // object and the copy, and which value to replace.
-    auto selectValue = [](auto&& oldVal, auto&& newVal) -> auto&& {
-      if constexpr (std::is_placeholder_v<std::decay_t<decltype(newVal)>>) {
-        return std::forward<decltype(oldVal)>(oldVal);
-      } else {
-        return std::forward<decltype(newVal)>(newVal);
-      }
-    };
-
-    return std::forward_as_tuple(selectValue(
-        std::get<I>(std::forward<OldVals>(oldVals)),
-        std::get<I>(std::forward<NewVals>(newVals)))...);
-  }
-};
-
-// Specializations
-
-// TODO: probably can introduce a macro here.
-struct ProjectNodeReader {
-  auto operator()(const core::ProjectNode& project) {
-    return std::forward_as_tuple(
-        project.id(),
-        project.names(),
-        project.projections(),
-        project.sources()[0]);
-  }
-};
-
-using ProjectCopy = facebook::velox::transform::utils::adapter::
-    NodeCopy<core::ProjectNode, ProjectNodeReader>;
-
-struct FilterNodeReader {
-  auto operator()(const core::FilterNode& filter) {
-    return std::forward_as_tuple(
-        filter.id(), filter.filter(), filter.sources()[0]);
-  }
-};
-
-using FilterCopy = facebook::velox::transform::utils::adapter::
-    NodeCopy<core::FilterNode, FilterNodeReader>;
-
-struct TableWriteNodeReader {
-  auto operator()(const core::TableWriteNode& node) {
-    return std::forward_as_tuple(
-        node.id(),
-        node.columns(),
-        node.columnNames(),
-        node.aggregationNode(),
-        node.insertTableHandle(),
-        node.hasPartitioningScheme(),
-        node.outputType(),
-        node.commitStrategy(),
-        node.sources()[0]);
-  }
-};
-
-using TableWriteNodeCopy = facebook::velox::transform::utils::adapter::
-    NodeCopy<core::TableWriteNode, TableWriteNodeReader>;
-
-struct TableScanNodeReader {
-  auto operator()(const core::TableScanNode& node) {
-    return std::forward_as_tuple(
-        node.id(), node.outputType(), node.tableHandle(), node.assignments());
-  }
-};
-
-using TableScanNodeCopy = facebook::velox::transform::utils::adapter::
-    NodeCopy<core::TableScanNode, TableScanNodeReader>;
-
-struct ValuesNodeNodeReader {
-  auto operator()(const core::ValuesNode& values) {
-    return std::forward_as_tuple(
-        values.id(), values.values(), values.isParallelizable());
-  }
-};
-
-using ValuesCopy = facebook::velox::transform::utils::adapter::
-    NodeCopy<core::ValuesNode, ValuesNodeNodeReader>;
-
-} // namespace adapter
-} // namespace utils
-
-} // namespace transform
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/transform/utils/ranges_utils.h b/velox/experimental/codegen/transform/utils/ranges_utils.h
deleted file mode 100644
index 546e2fbd717c8..0000000000000
--- a/velox/experimental/codegen/transform/utils/ranges_utils.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * This header is used to select between std::ranges and range-v3 depending on
- * the build env
- */
-#pragma once
-
-#if USE_STD_RANGE
-#include <ranges> // @manual
-using namespace ranges = std::ranges
-#else
-#include <range/v3/range.hpp>
-#include <range/v3/view.hpp>
-namespace views = ranges::views;
-#endif
diff --git a/velox/experimental/codegen/transform/utils/tests/CMakeLists.txt b/velox/experimental/codegen/transform/utils/tests/CMakeLists.txt
deleted file mode 100644
index e73a2e452dcc0..0000000000000
--- a/velox/experimental/codegen/transform/utils/tests/CMakeLists.txt
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_executable(velox_transform_utils_test TestUtils.cpp ../ranges_utils.h)
-
-add_test(velox_transform_utils_test velox_transform_utils_test)
-# target_compile_features(velox_transform_utils_test INTERFACE cxx_std_20)
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  target_compile_options(velox_transform_utils_test
-                         PUBLIC -fconcepts-diagnostics-depth=6)
-endif()
-
-target_link_libraries(
-  velox_transform_utils_test
-  velox_transform_utils
-  ${ANTLR4_RUNTIME}
-  Boost::atomic
-  Boost::context
-  Boost::date_time
-  Boost::filesystem
-  Boost::program_options
-  Boost::regex
-  Boost::thread
-  Boost::system
-  gflags::gflags
-  gtest
-  gtest_main
-  Folly::folly
-  gflags::gflags
-  glog::glog
-  fmt::fmt
-  dl)
diff --git a/velox/experimental/codegen/transform/utils/tests/TARGETS_disabled b/velox/experimental/codegen/transform/utils/tests/TARGETS_disabled
deleted file mode 100644
index 42ea60bf13b62..0000000000000
--- a/velox/experimental/codegen/transform/utils/tests/TARGETS_disabled
+++ /dev/null
@@ -1,16 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
-
-cpp_unittest(
-    name = "velox_transform_utils_test",
-    srcs = [
-        "TestUtils.cpp",
-    ],
-    headers = [],
-    deps = [
-        "//folly:conv",
-        "//velox/experimental/codegen/transform/utils:velox_transform_utils",
-    ],
-    external_deps = [
-        "glog",
-    ],
-)
diff --git a/velox/experimental/codegen/transform/utils/tests/TestUtils.cpp b/velox/experimental/codegen/transform/utils/tests/TestUtils.cpp
deleted file mode 100644
index 4be8bc9e9bde9..0000000000000
--- a/velox/experimental/codegen/transform/utils/tests/TestUtils.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include <algorithm>
-#include <memory>
-#include "folly/Conv.h"
-#include "velox/experimental/codegen/transform/utils/adapters.h"
-#include "velox/experimental/codegen/transform/utils/utils.h"
-
-using facebook::velox::transform::utils::topologicalTraversal;
-
-// Test Tree with labeled node.
-template <typename LabelType>
-struct TestTree {
-  explicit TestTree(const LabelType& label) : label(label) {}
-  TestTree(
-      const LabelType& label,
-      const std::vector<std::shared_ptr<TestTree<LabelType>>>& children)
-      : label(label), childrenPtr(children) {}
-  template <typename Iterator>
-  TestTree(const LabelType& label, Iterator begin, Iterator end)
-      : label(label), childrenPtr(begin, end) {}
-  LabelType label;
-  std::vector<std::shared_ptr<TestTree<LabelType>>> childrenPtr;
-  auto children() const {
-    return views::transform(
-        childrenPtr, [](const auto& node) -> auto& { return *node; });
-  }
-
-  static std::pair<
-      std::shared_ptr<TestTree<LabelType>>,
-      std::vector<std::shared_ptr<TestTree<LabelType>>>>
-  randomTree(std::vector<LabelType> labels) {
-    assert(!labels.empty());
-    std::srand(
-        std::time(nullptr)); // use current time as seed for random generator
-    std::vector<std::shared_ptr<TestTree<LabelType>>> nodes;
-    auto rootNode = std::make_shared<TestTree<LabelType>>(labels.back());
-    labels.pop_back();
-    nodes.push_back(rootNode);
-    while (!labels.empty()) {
-      // Randomly select where to insert the new node in the tree
-      auto selectedNode = nodes[std::rand() % nodes.size()];
-      auto newNode = std::make_shared<TestTree<LabelType>>(labels.back());
-      selectedNode->childrenPtr.push_back(newNode);
-      nodes.push_back(newNode);
-      labels.pop_back();
-    };
-    return {rootNode, nodes};
-  }
-};
-template <typename LabelType>
-auto children(const TestTree<LabelType>& tree) {
-  return tree.children();
-};
-static_assert(
-    ranges::viewable_range<topologicalTraversal<TestTree<std::string>>>);
-
-struct TestStruct {
-  TestStruct(double a, int b) : i(a), j(b) {}
-  double i;
-  int j;
-};
-
-struct TestStructValueReader {
-  auto operator()(const TestStruct& a) {
-    return std::forward_as_tuple(a.i, a.j);
-  }
-};
-using copyTestStruct = facebook::velox::transform::utils::adapter::
-    NodeCopy<TestStruct, TestStructValueReader>;
-
-TEST(TransformUtilsTestSuite, copyWith) {
-  TestStruct testStruct{1, 3};
-  auto newTestStruct =
-      copyTestStruct::copyWith(testStruct, 5.0, std::placeholders::_1);
-  ASSERT_EQ(newTestStruct->i, 5.0);
-  ASSERT_EQ(newTestStruct->j, 3);
-}
-
-TEST(TransformUtilsTestSuite, topologicalOrder) {
-  // build random node
-  auto [tree, nodes_] =
-      TestTree<std::string>::randomTree({"a", "b", "c", "f", "e"});
-  topologicalTraversal orderedNode(*tree);
-
-  // validation
-  std::map<const TestTree<std::string>*, bool> visited;
-  std::set<const TestTree<std::string>*> nodes;
-  std::transform(
-      nodes_.begin(),
-      nodes_.end(),
-      std::inserter(nodes, nodes.begin()),
-      [](auto& node) { return &*node; });
-
-  for (const auto& node : orderedNode) {
-    // test that the node is actually from the tree, this guard against shadow
-    // copies
-    ASSERT_TRUE(nodes.find(&node.get()) != nodes.end());
-    visited[&node.get()] = true;
-    // test that we already visited all the children
-    auto children = node.get().children();
-    bool childrenVisited = std::all_of(
-        children.begin(),
-        children.end(),
-        [&visited](const TestTree<std::string>& node) {
-          return visited[&node];
-        });
-    ASSERT_EQ(true, childrenVisited);
-  }
-}
-
-TEST(TransformUtilsTestSuite, topologicalOrder2) {
-  TestTree<std::string> bottomLeft{"bottom left", {}};
-  TestTree<std::string> bottomRight{"bottom right", {}};
-  TestTree<std::string> top{
-      "top",
-      {std::make_shared<TestTree<std::string>>(bottomLeft),
-       std::make_shared<TestTree<std::string>>(bottomRight)}};
-  topologicalTraversal orderedNode(top);
-  auto dataView = ranges::transform_view(
-      orderedNode, [](auto& node) { return node.get().label; });
-
-  std::vector<std::string> results(dataView.begin(), dataView.end());
-  std::vector<std::string> expected{"bottom right", "bottom left", "top"};
-  ASSERT_EQ(expected, results);
-};
-
-TEST(TransformUtilsTestSuite, treeTranform) {
-  using facebook::velox::transform::utils::isomorphicTreeTransform;
-  TestTree<int> bottomLeft{1, {}};
-  TestTree<int> bottomRight{2, {}};
-  TestTree<int> tree{
-      3,
-      {std::make_shared<TestTree<int>>(bottomLeft),
-       std::make_shared<TestTree<int>>(bottomRight)}};
-
-  auto doubleTransform = [](const TestTree<int>& node, auto& children_) {
-    return std::make_shared<TestTree<int>>(
-        2 * node.label, children_.begin(), children_.end());
-  };
-  auto [newTree, newNodeMap] = isomorphicTreeTransform(tree, doubleTransform);
-
-  topologicalTraversal orderedNodes(tree);
-  for (auto& node : orderedNodes) {
-    // check that each node is properly transformed
-    ASSERT_TRUE(newNodeMap.count(&node.get()) == 1);
-    ASSERT_EQ(2 * node.get().label, newNodeMap[&node.get()]->label);
-
-    // check that the tree structure is preserved by the transformation
-    auto childrenView = views::transform(
-        node.get().children(), [](const auto& node) { return &node; });
-    auto newChildrenView = views::transform(
-        newNodeMap[&node.get()]->children(),
-        [](const auto& node) { return &node; });
-
-    std::vector<const TestTree<int>*> childrenVector(
-        childrenView.begin(), childrenView.end());
-    std::vector<const TestTree<int>*> newChildrenVector(
-        newChildrenView.begin(), newChildrenView.end());
-    ASSERT_EQ(childrenVector.size(), newChildrenVector.size());
-    for (auto i = 0; i < newChildrenVector.size(); i++) {
-      ASSERT_TRUE(newNodeMap.count(childrenVector[i]) == 1);
-      ASSERT_EQ(newChildrenVector[i], newNodeMap[childrenVector[i]].get());
-    };
-  };
-};
diff --git a/velox/experimental/codegen/transform/utils/utils.h b/velox/experimental/codegen/transform/utils/utils.h
deleted file mode 100644
index 2bbb61a7cd084..0000000000000
--- a/velox/experimental/codegen/transform/utils/utils.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * This header define utility functions,classes and concept useful for the
- * transformtion framework. In general, it focuses on tree manipulation and
- * traversal.
- */
-#pragma once
-
-#if ENABLE_CONCEPTS
-#include <concepts> // @manual
-#endif
-#include <functional>
-#include <map>
-#include <memory>
-#include <optional>
-#include <vector>
-#include "velox/core/PlanNode.h"
-#include "velox/experimental/codegen/transform/utils/ranges_utils.h"
-
-namespace facebook {
-namespace velox {
-namespace transform {
-
-namespace utils {
-
-#if ENABLE_CONCEPTS
-
-/**
- * Basic tree concept
- * The only requirement here is to have an iterable range representing the
- * chidlren nodes
- * TODO: Introduce more refined of the tree concept : mutable tree
- * @tparam T
- */
-template <typename T>
-concept Tree = requires(const T& tree) {
-  // typename T::nodeType;
-  { children(tree) } -> std::ranges::range; // might need to be const here
-  std::is_same_v<
-      std::ranges::range_value_t<std::remove_cvref_t<decltype(children(tree))>>,
-      T>;
-};
-
-template <typename NodeType, typename NodeTransformer>
-concept isTansformer = requires(NodeType& node, NodeTransformer& tr) {
-  requires Tree<NodeType>;
-  // TODO: relax this constraint to allow more pointer type
-  {
-    tr(node, std::declval<std::vector<std::shared_ptr<NodeType>>>())
-    } -> same_as<std::shared_ptr<NodeType>>;
-};
-#endif
-
-/**
- * Range (begin/end) representing a topological traversal of a given tree.
- * This implementation is not lazy
- * TODO: Make sure that this class respects the range concept
- * TODO: Implement a lazy version
- * Implementation characteristics:
- * O(n) space
- * Constructor time O(n)
- * @tparam TreeType
- */
-template <typename TreeType>
-struct topologicalTraversal : public ranges::view_base {
-  std::vector<std::reference_wrapper<const TreeType>> nodeList;
-  const TreeType& tree;
-
-  explicit topologicalTraversal(const TreeType& tree_) : tree(tree_) {
-    // Compute a topological order of the tree nodes.
-    nodeList.push_back(tree);
-    for (size_t i = 0; i < nodeList.size(); ++i) {
-      for (auto const& child : children(nodeList[i].get())) {
-        nodeList.push_back(child);
-      }
-    };
-  }
-
-  auto begin() const {
-    return nodeList.crbegin();
-  }
-  auto end() const {
-    return nodeList.crend();
-  }
-
-  auto rbegin() const {
-    return nodeList.cbegin();
-  }
-  auto rend() const {
-    return nodeList.cend();
-  }
-};
-
-template <typename TreeType, typename Func>
-void dfsApply(const TreeType& tree, const Func& lambda) {
-  std::vector<std::reference_wrapper<const TreeType>> nodeList;
-  nodeList.push_back(tree);
-  while (!nodeList.empty()) {
-    auto ref = nodeList.back();
-    lambda(ref.get());
-    nodeList.pop_back();
-    for (auto const& child : children(ref.get())) {
-      nodeList.push_back(child);
-    };
-  };
-}
-
-/**
- * Perform an isomorphic transformation of a given tree, using a node to node
- * function.
- *
- * @tparam TreeType see Tree concept
- * @tparam NodeTransformer  (TODO: see NodeTransformer concept)
- * @param tree
- * @param transformer function
- * @return A new tree, and mapping between nodes in the old and new tree
- */
-template <typename TreeType, typename NodeTransformer>
-#if ENABLE_CONCEPTS
-requires isTansformer<TreeType, NodeTransformer>
-#endif
-auto isomorphicTreeTransform(
-    const TreeType& tree,
-    const NodeTransformer& transformer) {
-  // Note: Ideally we would rather use here std::reference_wrapper instead of
-  // const TreeType *; However the compare function on ref_wrapper are not
-  // appropriate
-  std::map<const TreeType*, std::shared_ptr<TreeType>> newNodes;
-
-  auto topoOrder = topologicalTraversal(tree);
-  for (const auto& currentNode : topoOrder) {
-    // First find the new nodes corresponding the child of the current node
-    auto newChildren = children(currentNode.get()) |
-        views::transform([&newNodes](const auto& child) {
-                         return newNodes[&child];
-                       });
-
-    auto newNode = transformer(currentNode.get(), newChildren);
-    newNodes[&currentNode.get()] = newNode;
-  }
-  return std::make_pair(newNodes[&topoOrder.rbegin()->get()], newNodes);
-}
-} // namespace utils
-
-} // namespace transform
-} // namespace velox
-}; // namespace facebook
-
-namespace ranges {
-template <typename Range>
-RANGES_INLINE_VAR constexpr bool enable_borrowed_range<
-    facebook::velox::transform::utils::topologicalTraversal<Range>> = true;
-
-};
diff --git a/velox/experimental/codegen/udf_manager/CMakeLists.txt b/velox/experimental/codegen/udf_manager/CMakeLists.txt
deleted file mode 100644
index 288964b45f38a..0000000000000
--- a/velox/experimental/codegen/udf_manager/CMakeLists.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_codegen_udf_manager UDFManager.cpp)
-
-# For some mysterious reason, adding ${FMT} or fmt is not working.  We need to
-# add velox_exception as a dependency to make fmt visible in this compilation
-# unit.
-target_link_libraries(velox_codegen_udf_manager velox_exception)
diff --git a/velox/experimental/codegen/udf_manager/ExpressionNullMode.h b/velox/experimental/codegen/udf_manager/ExpressionNullMode.h
deleted file mode 100644
index 6c0e142e1f427..0000000000000
--- a/velox/experimental/codegen/udf_manager/ExpressionNullMode.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-enum class ExpressionNullMode {
-  NullInNullOut, // null if any input is null, used for default null analysis
-  NullableInNullableOut, // 1. if any input is nullable then output is nullable
-                         // 2. it's not default null
-  NotNull, // expression never produce null
-  Custom // nullability propagation must overridden
-};
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/udf_manager/UDFManager.cpp b/velox/experimental/codegen/udf_manager/UDFManager.cpp
deleted file mode 100644
index cba06397b6692..0000000000000
--- a/velox/experimental/codegen/udf_manager/UDFManager.cpp
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/udf_manager/UDFManager.h"
-namespace facebook::velox {
-namespace codegen {
-
-void registerVeloxArithmeticUDFs(UDFManager& udfManager) {
-  const std::vector<std::string> arithmeticHeaders = {
-      "\"velox/functions/prestosql/CheckedArithmeticImpl.h\"",
-      "\"velox/functions/prestosql/ArithmeticImpl.h\""};
-
-  auto getDefaultArithmeticUDF = [&]() {
-    return UDFInformation()
-        .withHeaderFiles(arithmeticHeaders)
-        .withNullMode(ExpressionNullMode::NullInNullOut)
-        .withIsOptionalArguments(false)
-        .withIsOptionalOutput(false)
-        .withOutputForm(OutputForm::Return)
-        .withCodegenNullInNullOutChecks(true);
-  };
-
-  // Helper function to register arithmetic UDF.
-  auto registerUDF = [&](const std::unordered_set<std::string>& veloxNames,
-                         const std::string& calledFunctionName,
-                         const std::vector<velox::TypeKind>& argumentsTypes) {
-    udfManager.registerUDF(getDefaultArithmeticUDF()
-                               .withVeloxFunctionNames(veloxNames)
-                               .withCalledFunctionName(fmt::format(
-                                   "functions::{}", calledFunctionName))
-                               .withArgumentsLookupTypes(argumentsTypes));
-  };
-
-  // Matches registerBinaryIntegral in Velox.
-  auto registerBinaryIntegralUDF = [&](const std::unordered_set<std::string>&
-                                           veloxNames,
-                                       const std::string& calledFunctionName) {
-    registerUDF(
-        veloxNames, calledFunctionName, {TypeKind::BIGINT, TypeKind::BIGINT});
-
-    registerUDF(
-        veloxNames, calledFunctionName, {TypeKind::INTEGER, TypeKind::INTEGER});
-  };
-
-  // Matches registerUnaryIntegral in Velox.
-  auto registerUnaryIntegralUDF =
-      [&](const std::unordered_set<std::string>& veloxNames,
-          const std::string& calledFunctionName) {
-        registerUDF(veloxNames, calledFunctionName, {TypeKind::BIGINT});
-        registerUDF(veloxNames, calledFunctionName, {TypeKind::INTEGER});
-        registerUDF(veloxNames, calledFunctionName, {TypeKind::SMALLINT});
-        registerUDF(veloxNames, calledFunctionName, {TypeKind::TINYINT});
-      };
-
-  // Matches registerBinaryFloatingPoint in Velox.
-  auto registerBinaryFloatingPointUDF =
-      [&](const std::unordered_set<std::string>& veloxNames,
-          const std::string& calledFunctionName) {
-        registerUDF(
-            veloxNames, calledFunctionName, {TypeKind::REAL, TypeKind::REAL});
-        registerUDF(
-            veloxNames,
-            calledFunctionName,
-            {TypeKind::DOUBLE, TypeKind::DOUBLE});
-      };
-
-  // Matches registerUnaryFloatingPointUDF in Velox.
-  auto registerUnaryFloatingPointUDF =
-      [&](const std::unordered_set<std::string>& veloxNames,
-          const std::string& calledFunctionName) {
-        registerUDF(veloxNames, calledFunctionName, {TypeKind::REAL});
-        registerUDF(veloxNames, calledFunctionName, {TypeKind::DOUBLE});
-      };
-
-  // Matches registerUnaryNumeric in Velox.
-  auto registerUnaryNumeric =
-      [&](const std::unordered_set<std::string>& veloxNames,
-          const std::string& calledFunctionName) {
-        registerUnaryFloatingPointUDF(veloxNames, calledFunctionName);
-        registerUnaryIntegralUDF(veloxNames, calledFunctionName);
-      };
-
-  registerBinaryIntegralUDF({"plus"}, "checkedPlus");
-  registerBinaryFloatingPointUDF({"plus"}, "plus");
-
-  registerBinaryIntegralUDF({"minus"}, "checkedMinus");
-  registerBinaryFloatingPointUDF({"minus"}, "minus");
-
-  registerBinaryIntegralUDF({"multiply"}, "checkedMultiply");
-  registerBinaryFloatingPointUDF({"multiply"}, "multiply");
-
-  registerBinaryIntegralUDF({"divide"}, "checkedDivide");
-  registerBinaryFloatingPointUDF({"divide"}, "divide");
-
-  registerUnaryIntegralUDF({"negate"}, "checkedNegate");
-  registerUnaryFloatingPointUDF({"negate"}, "negate");
-
-  registerBinaryIntegralUDF({"modulus"}, "checkedModulus");
-
-  registerUnaryNumeric({"abs"}, "abs");
-  registerUnaryNumeric({"floor"}, "floor");
-  registerUnaryNumeric({"ceil", "ceiling"}, "ceil");
-
-  // Round function
-  UDFInformation roundUDF = getDefaultArithmeticUDF()
-                                .withVeloxFunctionNames({"round"})
-                                .withCalledFunctionName("functions::round");
-
-  udfManager.registerUDF(roundUDF.withArgumentsLookupTypes(
-      {TypeKind::INTEGER, TypeKind::INTEGER}));
-
-  udfManager.registerUDF(
-      roundUDF.withArgumentsLookupTypes({TypeKind::BIGINT, TypeKind::INTEGER}));
-
-  udfManager.registerUDF(roundUDF.withArgumentsLookupTypes(
-      {TypeKind::SMALLINT, TypeKind::INTEGER}));
-
-  udfManager.registerUDF(roundUDF.withArgumentsLookupTypes(
-      {TypeKind::TINYINT, TypeKind::INTEGER}));
-
-  udfManager.registerUDF(roundUDF.withArgumentsLookupTypes(
-      {TypeKind::TINYINT, TypeKind::INTEGER}));
-
-  udfManager.registerUDF(
-      roundUDF.withArgumentsLookupTypes({TypeKind::DOUBLE, TypeKind::INTEGER}));
-
-  udfManager.registerUDF(
-      roundUDF.withArgumentsLookupTypes({TypeKind::REAL, TypeKind::INTEGER}));
-
-  // Second argument is optional
-  udfManager.registerUDF(
-      roundUDF.withArgumentsLookupTypes({TypeKind::INTEGER}));
-
-  udfManager.registerUDF(roundUDF.withArgumentsLookupTypes({TypeKind::BIGINT}));
-
-  udfManager.registerUDF(
-      roundUDF.withArgumentsLookupTypes({TypeKind::SMALLINT}));
-
-  udfManager.registerUDF(
-      roundUDF.withArgumentsLookupTypes({TypeKind::TINYINT}));
-
-  udfManager.registerUDF(
-      roundUDF.withArgumentsLookupTypes({TypeKind::TINYINT}));
-
-  udfManager.registerUDF(roundUDF.withArgumentsLookupTypes({TypeKind::DOUBLE}));
-
-  udfManager.registerUDF(roundUDF.withArgumentsLookupTypes({TypeKind::REAL}));
-
-  // Register hash function
-  UDFInformation hashBaseUDF =
-      getDefaultArithmeticUDF()
-          .withHeaderFiles(
-              {"\"velox/experimental/codegen/functions/HashFunctionStub.h\""})
-          .withVeloxFunctionNames({"hash"})
-          .withCalledFunctionName("codegen::computeHashStub");
-
-  udfManager.registerUDF(
-      hashBaseUDF.withArgumentsLookupTypes({TypeKind::INTEGER}));
-  udfManager.registerUDF(
-      hashBaseUDF.withArgumentsLookupTypes({TypeKind::BIGINT}));
-  udfManager.registerUDF(
-      hashBaseUDF.withArgumentsLookupTypes({TypeKind::SMALLINT}));
-  udfManager.registerUDF(
-      hashBaseUDF.withArgumentsLookupTypes({TypeKind::TINYINT}));
-  udfManager.registerUDF(
-      hashBaseUDF.withArgumentsLookupTypes({TypeKind::DOUBLE}));
-  udfManager.registerUDF(
-      hashBaseUDF.withArgumentsLookupTypes({TypeKind::REAL}));
-  udfManager.registerUDF(
-      hashBaseUDF.withArgumentsLookupTypes({TypeKind::VARCHAR}));
-
-  // Between is added with arithmetic for now since its the only non-built in
-  // logical
-  UDFInformation betweenBaseUDF =
-      getDefaultArithmeticUDF()
-          .withHeaderFiles({"\"velox/functions_core/ComparisonsImpl.h\""})
-          .withVeloxFunctionNames({"between"})
-          .withCalledFunctionName("functions::between");
-
-  udfManager.registerUDF(betweenBaseUDF.withArgumentsLookupTypes(
-      {TypeKind::INTEGER, TypeKind::INTEGER, TypeKind::INTEGER}));
-  udfManager.registerUDF(betweenBaseUDF.withArgumentsLookupTypes(
-      {TypeKind::BIGINT, TypeKind::BIGINT, TypeKind::BIGINT}));
-  udfManager.registerUDF(betweenBaseUDF.withArgumentsLookupTypes(
-      {TypeKind::SMALLINT, TypeKind::SMALLINT, TypeKind::SMALLINT}));
-  udfManager.registerUDF(betweenBaseUDF.withArgumentsLookupTypes(
-      {TypeKind::TINYINT, TypeKind::TINYINT, TypeKind::TINYINT}));
-
-  udfManager.registerUDF(betweenBaseUDF.withArgumentsLookupTypes(
-      {TypeKind::DOUBLE, TypeKind::DOUBLE, TypeKind::DOUBLE}));
-  udfManager.registerUDF(betweenBaseUDF.withArgumentsLookupTypes(
-      {TypeKind::REAL, TypeKind::REAL, TypeKind::REAL}));
-
-  // Add rand udf
-  UDFInformation randUDF =
-      getDefaultArithmeticUDF()
-          .withCalledFunctionName(" folly::Random::randDouble01")
-          .withVeloxFunctionNames({"rand"})
-          .withHeaderFiles({"\"folly/Random.h\""});
-
-  udfManager.registerUDF(randUDF.withArgumentsLookupTypes({}));
-}
-
-UDFInformation getCastUDFBase() {
-  const std::vector<std::string> headers = {
-      "\"velox/experimental/codegen/functions/CastFunctionStub.h\""};
-
-  return UDFInformation()
-      .withHeaderFiles(headers)
-      .withNullMode(ExpressionNullMode::NullInNullOut)
-      .withIsOptionalArguments(false)
-      .withIsOptionalOutput(false)
-      .withOutputForm(OutputForm::Return)
-      .withCodegenNullInNullOutChecks(true);
-};
-
-UDFInformation getCastUDF(velox::TypeKind kind, bool castByTruncate) {
-  auto functionName = fmt::format(
-      "codegen::CodegenConversionStub<{toKind}, {truncate}>::cast",
-      fmt::arg("toKind", fmt::format("TypeKind::{}", mapTypeKindToName(kind))),
-      fmt::arg("truncate", castByTruncate ? "true" : "false"));
-
-  return getCastUDFBase().withCalledFunctionName(functionName);
-}
-
-void registerVeloxStringFunctions(UDFManager& udfManager) {
-  // Create a basic cast UDF missing velox name and the called name
-  auto getStringUDFBase = []() {
-    const std::vector<std::string> headers = {
-        "\"velox/functions/lib/string/StringImpl.h\""};
-
-    return UDFInformation()
-        .withHeaderFiles(headers)
-        .withNullMode(ExpressionNullMode::NullInNullOut)
-        .withIsOptionalArguments(false)
-        .withIsOptionalOutput(false)
-        .withOutputForm(OutputForm::InOut)
-        .withCodegenNullInNullOutChecks(true);
-  };
-
-  // Those will dynamically scan the encoding and do the fast path if needed
-  udfManager.registerUDF(
-      getStringUDFBase().withVeloxFunctionNames({"upper"}).withCalledFunctionName(
-          "functions::stringImpl::upper<functions::stringCore::StringEncodingMode::MOSTLY_ASCII>"));
-
-  udfManager.registerUDF(
-      getStringUDFBase().withVeloxFunctionNames({"lower"}).withCalledFunctionName(
-          "functions::stringImpl::lower<functions::stringCore::StringEncodingMode::MOSTLY_ASCII>"));
-
-  // This concat does not do the optimization at which the children are
-  // written directly in the output.
-  udfManager.registerUDF(
-      getStringUDFBase()
-          .withVeloxFunctionNames({"concat"})
-          .withCalledFunctionName("functions::stringImpl::concatStatic"));
-
-  // Not optimized for ASCII
-  udfManager.registerUDF(
-      getStringUDFBase()
-          .withOutputForm(OutputForm::Return)
-          .withArgumentsLookupTypes({TypeKind::VARCHAR})
-          .withVeloxFunctionNames({"length"})
-          .withCalledFunctionName(
-              "functions::stringImpl::length<functions::stringCore::StringEncodingMode::MOSTLY_ASCII>"));
-}
-
-void UDFManager::registerUDF(const UDFInformation& udfInformation) {
-  udfInformation.validate();
-  for (auto& name : udfInformation.getVeloxFunctionNames()) {
-    if (udfInformation.lookUpByName()) {
-      std::unique_lock lock(udfDictionaryNameOnlyMutex);
-      udfDictionaryNameOnly.emplace(name, udfInformation);
-    } else {
-      std::unique_lock lock(udfDictionaryWithArgumentsMutex);
-      udfDictionaryWithArguments.emplace(
-          std::make_pair(name, udfInformation.getArgumentsLookupTypes()),
-          udfInformation);
-    }
-  }
-}
-
-std::optional<UDFInformation> UDFManager::getUDFInformationTypedArgs(
-    const std::string& functionName,
-    const std::vector<velox::TypeKind>& argumentTypes) const {
-  std::shared_lock lock(udfDictionaryWithArgumentsMutex);
-
-  auto key = std::make_pair(functionName, argumentTypes);
-
-  auto udfIterator = udfDictionaryWithArguments.find(key);
-  return udfIterator == udfDictionaryWithArguments.end()
-      ? std::nullopt
-      : std::optional<UDFInformation>{udfIterator->second};
-}
-
-std::optional<UDFInformation> UDFManager::getUDFInformationUnTypedArgs(
-    const std::string& functionName) const {
-  std::shared_lock lock(udfDictionaryNameOnlyMutex);
-
-  auto udfIterator = udfDictionaryNameOnly.find(functionName);
-  return udfIterator == udfDictionaryNameOnly.end()
-      ? std::nullopt
-      : std::optional<UDFInformation>{udfIterator->second};
-}
-} // namespace codegen
-} // namespace facebook::velox
diff --git a/velox/experimental/codegen/udf_manager/UDFManager.h b/velox/experimental/codegen/udf_manager/UDFManager.h
deleted file mode 100644
index c2ff8c796048d..0000000000000
--- a/velox/experimental/codegen/udf_manager/UDFManager.h
+++ /dev/null
@@ -1,289 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/// This file define the UDFManager and some related classes. UDFManager is used
-/// to register UDFs and other related information that are needed for
-/// translating VELOX expression to Codegen UDFCallExpr, and also information
-/// needed for codegen to correctly call the functions.
-
-#pragma once
-#include <map>
-#include <optional>
-#include <shared_mutex>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-#include "velox/experimental/codegen/compiler_utils/LibraryDescriptor.h"
-#include "velox/experimental/codegen/udf_manager/ExpressionNullMode.h"
-#include "velox/type/Type.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-enum class OutputForm { Return, InOut };
-
-// Information for single UDF function.
-class UDFInformation {
- public:
-  UDFInformation() {}
-
-  // Make sure mandatory fields are set
-  void validate(bool veloxNamesMustBeSet = true) const {
-    if (veloxNamesMustBeSet && veloxFunctionNames_ == std::nullopt) {
-      throw std::invalid_argument("UDF veloxFunctionNames_ field not set");
-    }
-
-    if (calledFunctionName_ == std::nullopt) {
-      throw std::invalid_argument("UDF calledFunctionName_ field not set");
-    }
-
-    if (nullMode_ == std::nullopt) {
-      throw std::invalid_argument("UDF nullMode_ field not set");
-    }
-
-    if (isOptionalArguments_ == std::nullopt) {
-      throw std::invalid_argument("UDF isOptionalArguments_ field not set");
-    }
-
-    if (isOptionalOutput_ == std::nullopt) {
-      throw std::invalid_argument("UDF isOptionalOutput_ field not set");
-    }
-
-    if (outputForm_ == std::nullopt) {
-      throw std::invalid_argument("UDF outputForm_ field not set");
-    }
-
-    if (codegenNullInNullOutChecks_ == std::nullopt) {
-      throw std::invalid_argument(
-          "UDF codegenNullInNullOutChecks_ field not set");
-    }
-  }
-
-  UDFInformation& setVeloxFunctionNames(
-      const std::unordered_set<std::string>& veloxFunctionNames) {
-    veloxFunctionNames_ = veloxFunctionNames;
-    return *this;
-  }
-
-  std::unordered_set<std::string> getVeloxFunctionNames() const {
-    return veloxFunctionNames_.value();
-  }
-
-  UDFInformation& setCalledFunctionName(const std::string& calledFunctionName) {
-    calledFunctionName_ = calledFunctionName;
-    return *this;
-  }
-
-  std::string getCalledFunctionName() const {
-    return calledFunctionName_.value();
-  }
-
-  void setHeaderFiles(const std::vector<std::string>& headerFiles) {
-    headerFiles_ = headerFiles;
-  }
-
-  std::vector<std::string> getHeaderFiles() const {
-    return headerFiles_;
-  }
-
-  bool hasHeaderFiles() const {
-    return !headerFiles_.empty();
-  }
-
-  void setLibs(const std::vector<compiler_utils::LibraryDescriptor>& libs) {
-    libs_ = libs;
-  }
-
-  std::vector<compiler_utils::LibraryDescriptor> getLibs() const {
-    return libs_;
-  }
-
-  bool hasLibs() const {
-    return !libs_.empty();
-  }
-
-  void setNullMode(ExpressionNullMode expressionNullMode) {
-    nullMode_ = expressionNullMode;
-  }
-
-  ExpressionNullMode getNullMode() const {
-    return nullMode_.value();
-  }
-
-  void setOutputForm(OutputForm outputForm) {
-    outputForm_ = outputForm;
-  }
-
-  OutputForm getOutputForm() const {
-    return outputForm_.value();
-  }
-
-  bool isOptionalOutput() const {
-    return isOptionalOutput_.value();
-  }
-
-  bool isOptionalArguments() const {
-    return isOptionalArguments_.value();
-  }
-
-  void setIsOptionalOutput(bool isOptionalOutput) {
-    isOptionalOutput_ = isOptionalOutput;
-  }
-
-  void setIsOptionalArguments(bool isOptionalArguments) {
-    isOptionalArguments_ = isOptionalArguments;
-  }
-
-  void setCodegenNullInNullOutChecks(bool codegenNullInNullOutChecks) {
-    codegenNullInNullOutChecks_ = codegenNullInNullOutChecks;
-  }
-
-  bool codegenNullInNullOutChecks() const {
-    return codegenNullInNullOutChecks_.value();
-  }
-
-  bool lookUpByName() const {
-    return !argumentsLookupTypes_.has_value();
-  }
-
-  void setArgumentsLookupTypes(
-      const std::vector<velox::TypeKind>& argumentsTypes) {
-    argumentsLookupTypes_ = argumentsTypes;
-  }
-
-  std::vector<velox::TypeKind> getArgumentsLookupTypes() const {
-    return argumentsLookupTypes_.value();
-  }
-
-  UDFInformation withVeloxFunctionNames(
-      const std::unordered_set<std::string>& veloxFunctionNames) {
-    veloxFunctionNames_ = veloxFunctionNames;
-    return *this;
-  }
-
-  UDFInformation withCalledFunctionName(const std::string& calledFunctionName) {
-    calledFunctionName_ = calledFunctionName;
-    return *this;
-  }
-
-  UDFInformation withHeaderFiles(const std::vector<std::string>& headerFiles) {
-    headerFiles_ = headerFiles;
-    return *this;
-  }
-
-  UDFInformation withLibs(
-      const std::vector<compiler_utils::LibraryDescriptor>& libs) {
-    libs_ = libs;
-    return *this;
-  }
-
-  UDFInformation withNullMode(ExpressionNullMode expressionNullMode) {
-    nullMode_ = expressionNullMode;
-    return *this;
-  }
-
-  UDFInformation withOutputForm(OutputForm outputForm) {
-    outputForm_ = outputForm;
-    return *this;
-  }
-
-  UDFInformation withIsOptionalOutput(bool isOptionalOutput) {
-    isOptionalOutput_ = isOptionalOutput;
-    return *this;
-  }
-
-  UDFInformation withIsOptionalArguments(bool isOptionalArguments) {
-    isOptionalArguments_ = isOptionalArguments;
-    return *this;
-  }
-
-  UDFInformation withCodegenNullInNullOutChecks(
-      bool codegenNullInNullOutChecks) {
-    codegenNullInNullOutChecks_ = codegenNullInNullOutChecks;
-    return *this;
-  }
-
-  UDFInformation withArgumentsLookupTypes(
-      const std::vector<velox::TypeKind>& argumentsTypes) {
-    argumentsLookupTypes_ = argumentsTypes;
-    return *this;
-  }
-
- private:
-  std::optional<std::unordered_set<std::string>> veloxFunctionNames_;
-
-  std::optional<std::string> calledFunctionName_;
-
-  std::vector<std::string> headerFiles_;
-
-  std::vector<compiler_utils::LibraryDescriptor> libs_;
-
-  std::optional<ExpressionNullMode> nullMode_;
-
-  std::optional<bool> codegenNullInNullOutChecks_;
-
-  // If not set the function will be looked up by name
-  std::optional<std::vector<velox::TypeKind>> argumentsLookupTypes_;
-
-  std::optional<bool> isOptionalOutput_;
-
-  std::optional<bool> isOptionalArguments_;
-
-  std::optional<OutputForm> outputForm_;
-};
-
-// Manage registered UDFs. Thread safe.
-class UDFManager {
- public:
-  // Add entry to udfDictionary.
-  void registerUDF(const UDFInformation& udfInformation);
-
-  // Extract UDF information from a functionName and a list of arguments types.
-  std::optional<UDFInformation> getUDFInformationTypedArgs(
-      const std::string& functionName,
-      const std::vector<velox::TypeKind>& argumentTypes) const;
-
-  // Extract UDF information using a functionName only. Must have been
-  // registered with name only lookup.
-  std::optional<UDFInformation> getUDFInformationUnTypedArgs(
-      const std::string& functionName) const;
-
- private:
-  // Map (functionName, {argumentsTypes}) -> udf information.
-  using TypedLookupKey = std::pair<std::string, std::vector<velox::TypeKind>>;
-
-  std::map<TypedLookupKey, UDFInformation> udfDictionaryWithArguments;
-
-  // Map (functionName) -> udf information.
-  std::unordered_map<std::string, UDFInformation> udfDictionaryNameOnly;
-
-  // Mutex for reading/writing UDF dictionary
-  mutable std::shared_mutex udfDictionaryWithArgumentsMutex;
-  mutable std::shared_mutex udfDictionaryNameOnlyMutex;
-};
-
-void registerVeloxArithmeticUDFs(UDFManager& udfManager);
-
-void registerVeloxStringFunctions(UDFManager& udfManager);
-
-UDFInformation getCastUDFBase();
-UDFInformation getCastUDF(velox::TypeKind kind, bool castByTruncate);
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/utils/CMakeLists.txt b/velox/experimental/codegen/utils/CMakeLists.txt
deleted file mode 100644
index 32bbfd1d592cb..0000000000000
--- a/velox/experimental/codegen/utils/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_subdirectory(timer)
-add_subdirectory(resources)
diff --git a/velox/experimental/codegen/utils/resources/CMakeLists.txt b/velox/experimental/codegen/utils/resources/CMakeLists.txt
deleted file mode 100644
index 0353eb8754d77..0000000000000
--- a/velox/experimental/codegen/utils/resources/CMakeLists.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set(CODEGEN_LINK_PATH "$<TARGET_FILE:velox_all_link>")
-get_directory_property(DEFINED_VARIABLE VARIABLES)
-foreach(VR IN LISTS DEFINED_VARIABLE)
-  set(CMAKE_VARS "${CMAKE_VARS}\n${VR}=${${VR}}")
-endforeach()
-
-file(
-  GENERATE
-  OUTPUT ./cmake_var_file.txt
-  CONTENT "${CMAKE_VARS}")
-
-add_custom_command(
-  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/package.json"
-  DEPENDS generatePackage.py
-  COMMAND python3 "${CMAKE_CURRENT_SOURCE_DIR}/generatePackage.py" "--var-file"
-          "${CMAKE_CURRENT_BINARY_DIR}/cmake_var_file.txt")
-
-set(PACKAGE_JSON
-    "${CMAKE_CURRENT_BINARY_DIR}/package.json"
-    CACHE INTERNAL "package file")
-set(BASE_FOLDER
-    "${PROJECT_SOURCE_DIR}"
-    CACHE INTERNAL "package file")
-
-add_compile_definitions(PACKAGE_JSON="${PACKAGE_JSON}")
-add_compile_definitions(BASE_FOLDER="${BASE_FOLDER}")
-
-add_library(velox_codegen_utils_resource_path package.json ResourcePath.cpp)
diff --git a/velox/experimental/codegen/utils/resources/ResourcePath.cpp b/velox/experimental/codegen/utils/resources/ResourcePath.cpp
deleted file mode 100644
index 9d0f967c69b6c..0000000000000
--- a/velox/experimental/codegen/utils/resources/ResourcePath.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/experimental/codegen/utils/resources/ResourcePath.h"
-
-namespace facebook::velox::codegen {
-std::string ResourcePath::getResourcePath() {
-  return std::string(PACKAGE_JSON);
-}
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/utils/resources/ResourcePath.h b/velox/experimental/codegen/utils/resources/ResourcePath.h
deleted file mode 100644
index b8415bbaf4794..0000000000000
--- a/velox/experimental/codegen/utils/resources/ResourcePath.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-#include <string>
-
-namespace facebook::velox::codegen {
-struct ResourcePath {
-  static std::string getResourcePath();
-};
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/utils/resources/generatePackage.py b/velox/experimental/codegen/utils/resources/generatePackage.py
deleted file mode 100644
index 539b170ddcc72..0000000000000
--- a/velox/experimental/codegen/utils/resources/generatePackage.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import re
-import argparse
-
-parser = argparse.ArgumentParser(description="Builds a package descriptor for testing")
-parser.add_argument("--var-file", help="Cmake variable")
-
-
-def f4d_libraries(cmake_vars):
-    return f"""
-    {{
-        "includePath" : ["{cmake_vars['CMAKE_SOURCE_DIR']}"],
-        "additionalLinkerObject": []
-    }}
-    """
-
-
-def additional_libraries(cmake_vars):
-    # libraries with include path and binaries
-    library_names = ["PROTOBUF", "ZLIB", "GFLAGS", "FOLLY"]
-    library_includes = {
-        '"' + cmake_vars[f"{name}_INCLUDE_DIR"] + '"' for name in library_names
-    }
-
-    return f"""{{
-        "includePath" : [{" ,".join(library_includes)}]
-
-    }}"""
-
-
-def parse_cmake_vars(file_path):
-    reg = re.compile("(?P<name>.*)(:.*)?=(?P<value>.*)")
-    matches = [reg.match(line) for line in open(file_path).readlines()]
-    variables = {
-        match.group("name"): match.group("value") for match in matches if match
-    }
-    return variables
-
-
-if __name__ == "__main__":
-    args = parser.parse_args()
-    cmake_vars = parse_cmake_vars(args.var_file)
-    opt_level = "-O3"
-    json_string = f"""
-    {{"optimizationLevel": "{opt_level}",
-    "extraLinkOptions" : ["-Wl,-undefined,dynamic_lookup", "-Wl,-rpath", "." ],
-    "extraCompileOption": [
-        "-g",
-        "-v",
-        "-std=c++17",
-        "-mavx2",
-        "-mfma",
-        "-mavx",
-        "-mf16c",
-        "-march=native",
-        "-DUSE_VELOX_COMMON_BASE",
-        "-mllvm",
-        "-inline-threshold=5000",
-        "-DBOOST_ALL_NO_LIB",
-        "-DBOOST_CONTEXT_DYN_LINK",
-        "-DBOOST_REGEX_DYN_LINK",
-        "-fPIC",
-        {f'"-isysroot", "{cmake_vars["CMAKE_OSX_SYSROOT"]}"' if 'CMAKE_OSX_SYSROOT' in cmake_vars else ""},
-    ],
-    "extraLinkOptions" : [{f'"-isysroot", "{cmake_vars["CMAKE_OSX_SYSROOT"]}"' if 'CMAKE_OSX_SYSROOT' in cmake_vars else ""}],
-    "defaultLibraries": [{f4d_libraries(cmake_vars)}, {additional_libraries(cmake_vars)}],
-    "compilerPath": "{cmake_vars['CMAKE_CXX_COMPILER']}",
-    "linker": "{cmake_vars['CMAKE_LINKER']}",
-    "tempDirectory": "/tmp"
-    }}
-    """
-    with open("package.json", "w") as f:
-        f.write(json_string)
diff --git a/velox/experimental/codegen/utils/timer/CMakeLists.txt b/velox/experimental/codegen/utils/timer/CMakeLists.txt
deleted file mode 100644
index e094d25c54e27..0000000000000
--- a/velox/experimental/codegen/utils/timer/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_library(velox_codegen_utils_timer INTERFACE)
-target_link_libraries(velox_codegen_utils_timer INTERFACE fmt::fmt)
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
diff --git a/velox/experimental/codegen/utils/timer/NestedScopedTimer.h b/velox/experimental/codegen/utils/timer/NestedScopedTimer.h
deleted file mode 100644
index 348f1114f0db4..0000000000000
--- a/velox/experimental/codegen/utils/timer/NestedScopedTimer.h
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <fmt/format.h>
-#include <algorithm>
-#include <chrono>
-#include <map>
-#include <queue>
-#include <stack>
-#include <thread>
-#include <vector>
-#include "boost/accumulators/accumulators.hpp"
-#include "boost/accumulators/statistics.hpp"
-
-namespace facebook::velox::codegen {
-
-/// Represent a sequence of Start/End events from collected form Scoped Timers
-/// We split the recorded event as Start/End to be able to recover nesting
-/// structure offline \tparam Cl Time source Clock type, follow TrivialClock
-/// concept \tparam EI EventInfo stored for each events
-template <typename Cl, typename EI>
-struct EventSequence {
-  using Clock = Cl;
-  using EventInfo = EI;
-  static constexpr size_t defaultSize = 100;
-  EventSequence() {
-    startEvents.reserve(defaultSize);
-    endEvents.reserve(defaultSize);
-  }
-
-  explicit EventSequence(size_t reservedSize) {
-    startEvents.reserve(reservedSize);
-    endEvents.reserve(reservedSize);
-  }
-
-  struct Event {
-    EventInfo info;
-    typename Cl::time_point timePoint;
-    Event(const EventInfo& i, const typename Cl::time_point& t)
-        : info(i), timePoint(t) {}
-    Event() = default;
-  };
-
-  void addStartEvent(const EventInfo& info) {
-    startEvents.emplace_back(info, Clock::now());
-  }
-
-  void addEndEvent(const EventInfo& info) {
-    endEvents.emplace_back(info, Clock::now());
-  }
-
-  void clear() {
-    startEvents.clear();
-    endEvents.clear();
-  }
-
-  std::vector<Event> startEvents;
-  std::vector<Event> endEvents;
-  size_t pos;
-};
-
-template <typename Clock>
-using NamedEventSequence = EventSequence<Clock, const char*>;
-using NamedSteadyClockEventSequence =
-    NamedEventSequence<std::chrono::steady_clock>;
-
-/// Scoped Timer nested structure modeled as a tree
-/// \tparam Clock Time source
-template <typename Clock>
-struct TimerTree {
-  enum class EventType {
-    START,
-    END,
-  };
-
-  using EventVector = std::vector<
-      std::pair<EventType, typename NamedEventSequence<Clock>::Event>>;
-
-  typename NamedEventSequence<Clock>::EventInfo
-      info; // Timer information (eg name)
-
-  std::map<
-      typename NamedEventSequence<Clock>::EventInfo,
-      std::shared_ptr<TimerTree<Clock>>>
-      children;
-
-  std::vector<typename Clock::time_point> timePoints; // Start/End time events
-
-  // Absolute time statistics (ns)
-  double min_, max_, mean_, sum_, variance_;
-
-  // relative times (ns)
-  double timeRelativeToParentTimer_;
-  double timeRelativeToTotalTime_;
-
-  /// compute current timer statistics
-
-  void computeNodeStatistics() {
-    boost::accumulators::accumulator_set<
-        double,
-        boost::accumulators::stats<
-            boost::accumulators::tag::sum,
-            boost::accumulators::tag::min,
-            boost::accumulators::tag::max,
-            boost::accumulators::tag::mean,
-            boost::accumulators::tag::lazy_variance>>
-        accumulatorSet;
-
-    for (size_t i = 0; i + 1 < timePoints.size(); i += 2) {
-      auto durations = timePoints[i + 1] - timePoints[i];
-      accumulatorSet(static_cast<double>(durations.count()));
-    };
-
-    min_ = boost::accumulators::min(accumulatorSet);
-    max_ = boost::accumulators::max(accumulatorSet);
-    mean_ = boost::accumulators::mean(accumulatorSet);
-    sum_ = boost::accumulators::sum(accumulatorSet);
-    variance_ = boost::accumulators::variance(accumulatorSet);
-  }
-
-  static void computeStatistics(TimerTree<Clock> root) {
-    std::vector<TimerTree<Clock>*> nodes;
-    nodes.push_back(&root);
-    root.computeNodeStatistics();
-
-    for (size_t currentNode = 0; currentNode < nodes.size(); ++currentNode) {
-      for (auto& [name, child] : nodes[currentNode]->children) {
-        child->computeNodeStatistics();
-        child->timeRelativeToParentTimer_ =
-            (child->sum_ / nodes[currentNode]->sum_) * 100.00;
-        child->timeRelativeToTotalTime_ = (child->sum_ / root.sum_) * 100.00;
-        nodes.push_back(child.get());
-      }
-    }
-  }
-
-  /// Given an eventSequence object, merge startEvents and endEvents into a
-  /// single sorted event streams and tag the new events as start/end
-  /// startEvents = [T1,T3],endEvents = [T2,T4] -->
-  /// [{START,T1},{END,T2},{START,T3},{END,T4}] \param eventSequence \return
-  /// merged tagged event stream
-  static EventVector mergeEventVectors(
-      const NamedEventSequence<Clock>& eventSequence) {
-    EventVector startEvents;
-    EventVector endEvents;
-
-    std::transform(
-        eventSequence.startEvents.begin(),
-        eventSequence.startEvents.end(),
-        std::back_inserter(startEvents),
-        [](const auto& event) {
-          return std::make_pair(EventType::START, event);
-        });
-
-    std::transform(
-        eventSequence.endEvents.begin(),
-        eventSequence.endEvents.end(),
-        std::back_inserter(endEvents),
-        [](const auto& event) {
-          return std::make_pair(EventType::END, event);
-        });
-
-    EventVector mergedEvents;
-
-    std::merge(
-        startEvents.begin(),
-        startEvents.end(),
-        endEvents.begin(),
-        endEvents.end(),
-        std::back_inserter(mergedEvents),
-        [](const auto& left, const auto& right) {
-          return left.second.timePoint < right.second.timePoint;
-        });
-    return mergedEvents;
-  }
-
-  /// Build a new tree from an event Sequence, this is done by recovering the
-  /// nested structure of the orignal scoped timers
-  /// \param eventSequence
-  /// \return
-  static std::shared_ptr<TimerTree> fromEventSequence(
-      const NamedEventSequence<Clock>& eventSequence) {
-    auto mergedEvents = mergeEventVectors(eventSequence);
-
-    // Create a root timer to enclosing all created timer,
-    auto root = std::make_shared<TimerTree>();
-    root->info = "<ROOT>";
-    root->timePoints.push_back(mergedEvents.begin()->second.timePoint);
-    root->timePoints.push_back(mergedEvents.rbegin()->second.timePoint);
-
-    // Add the root timer as the first timer in the stack
-    std::stack<std::shared_ptr<TimerTree>> activeTimers;
-    activeTimers.push(root);
-
-    for (const auto& event : mergedEvents) {
-      // New timer starts
-      if (event.first == EventType::START) {
-        // Adds the new timer to the parent timer
-        auto [newTimerIterator, inserted] = activeTimers.top()->children.insert(
-            {event.second.info, std::make_shared<TimerTree>()});
-
-        // Set new timer infos
-        auto newTimer = newTimerIterator->second;
-        newTimer->info = event.second.info;
-        newTimer->timePoints.push_back(event.second.timePoint);
-
-        // new timer is now the inner most timer
-        activeTimers.push(newTimer);
-        continue;
-      };
-
-      // Timer Ends
-      if (event.first == EventType::END) {
-        auto currentTimer = activeTimers.top();
-        if (event.second.info != currentTimer->info) {
-          throw std::runtime_error(fmt::format(
-              "Improper timer nesting, closing timer {}, while timer {} is open",
-              event.second.info,
-              currentTimer->info));
-        };
-        currentTimer->timePoints.push_back(event.second.timePoint);
-        activeTimers.pop();
-      };
-    }
-    if (activeTimers.top() != root) {
-      throw std::runtime_error(
-          fmt::format("Timer {} was never closed", activeTimers.top()->info));
-    };
-
-    return root;
-  }
-
-  void print(
-      std::ostream& out,
-      const std::string& currentIdent,
-      const std::string& ident) {
-    out << currentIdent
-        << fmt::format(
-               "[{}] : count = {:d}, min = {:.0f}, max = {:.0f}, avg = {:.0f} , total (ns) = {:.0f} , % parent = {:.2f} , % total = {:.2f}\n",
-               this->info,
-               this->timePoints.size() / 2,
-               min_,
-               max_,
-               mean_,
-               sum_,
-               timeRelativeToParentTimer_,
-               timeRelativeToTotalTime_);
-
-    auto newIndent = currentIdent + ident;
-    for (const auto& [key, value] : this->children) {
-      value->print(out, newIndent, ident);
-    };
-  }
-};
-
-/// Scoped timer with a name
-/// When displayed, timer with the same name a considered equivalement and merge
-/// as one WARNING : name is not owned nor copied and expected to be live when
-/// the timer is displayed \tparam Clock
-template <typename Clock>
-struct NamedNestedScopedTimer {
-  using EventSequence = NamedEventSequence<Clock>;
-  NamedNestedScopedTimer(const char* name, EventSequence& eventSequence)
-      : eventSequence_(eventSequence), name_(name) {
-    eventSequence_.addStartEvent(name);
-  }
-  ~NamedNestedScopedTimer() {
-    eventSequence_.addEndEvent(name_);
-  }
-
-  static std::string printCounters(EventSequence& eventSequence) {
-    auto timerTree = computeTimerTreeStatistics(eventSequence);
-    return printTimerTreeStatistics(timerTree);
-  }
-
-  static std::shared_ptr<TimerTree<Clock>> computeTimerTreeStatistics(
-      EventSequence& eventSequence) {
-    auto timerTree = TimerTree<Clock>::fromEventSequence(eventSequence);
-    TimerTree<Clock>::computeStatistics(*timerTree);
-    return timerTree;
-  }
-
-  static std::string printTimerTreeStatistics(
-      std::shared_ptr<TimerTree<Clock>>& timerTree) {
-    std::stringstream stream;
-    timerTree->print(stream, "", "+");
-    return stream.str();
-  }
-
-  NamedEventSequence<Clock>& eventSequence_;
-  const char* name_;
-};
-using SteadyClockNamedScopedTimer =
-    NamedNestedScopedTimer<std::chrono::steady_clock>;
-
-using DefaultScopedTimer = SteadyClockNamedScopedTimer;
-using DefaultEventSequence = DefaultScopedTimer::EventSequence;
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/utils/timer/tests/CMakeLists.txt b/velox/experimental/codegen/utils/timer/tests/CMakeLists.txt
deleted file mode 100644
index 33de92937a77b..0000000000000
--- a/velox/experimental/codegen/utils/timer/tests/CMakeLists.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_executable(velox_experimental_codegen_utils_timer_test TimerTests.cpp
-                                                           ClockTests.cpp)
-
-target_link_libraries(
-  velox_experimental_codegen_utils_timer_test velox_codegen_utils_timer gtest
-  gtest_main velox_common_base)
-
-add_test(velox_experimental_codegen_utils_timer_test
-         velox_experimental_codegen_utils_timer_test)
diff --git a/velox/experimental/codegen/utils/timer/tests/ClockTests.cpp b/velox/experimental/codegen/utils/timer/tests/ClockTests.cpp
deleted file mode 100644
index e03d53cfea258..0000000000000
--- a/velox/experimental/codegen/utils/timer/tests/ClockTests.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include <xsimd/xsimd.hpp> // @manual
-#include <chrono>
-#include "boost/accumulators/accumulators.hpp"
-#include "boost/accumulators/statistics.hpp"
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-
-namespace facebook::velox::codegen {
-
-class ClockTest : public testing::Test {
- protected:
-  const size_t iteration = 100;
-};
-
-using namespace boost::accumulators;
-
-/// Compute basic statistics on a vector of time points
-/// \tparam Clock
-/// \param eventSequence
-/// \return
-template <typename Clock>
-auto timePointStats(
-    const std::vector<typename Clock::time_point>& timePoints,
-    size_t size) {
-  accumulator_set<
-      double,
-      stats<tag::min, tag::max, tag::mean, tag::lazy_variance>>
-      accumulatorSet;
-  for (size_t i = 0; i + 1 < size; i++) {
-    auto durations = timePoints[i + 1] - timePoints[i];
-    accumulatorSet(static_cast<double>(durations.count()));
-  }
-  return accumulatorSet;
-}
-
-using namespace boost::accumulators;
-template <typename Clock, bool warmCache, typename Action>
-void testClock(
-    const std::string& message,
-    const Action& action,
-    size_t iteration) {
-  std::vector<typename Clock::time_point> timePoints;
-  timePoints.reserve(iteration);
-
-  if constexpr (warmCache) {
-    for (size_t i = 0; i < iteration; i++) {
-      action(timePoints, i);
-    };
-    timePoints.clear();
-  }
-
-  for (size_t i = 0; i < iteration; i++) {
-    action(timePoints, i);
-  };
-
-  auto stats = timePointStats<Clock>(timePoints, iteration);
-
-  std::cout << fmt::format(
-      "{} : min = {}, max = {}, mean = {}, variance = {}\n",
-      message,
-      min(stats),
-      max(stats),
-      mean(stats),
-      variance(stats));
-}
-template <typename Clock>
-void printClockStatistics(const std::string& clockName, size_t iterations) {
-  testClock<Clock, true>(
-      fmt::format("{} push_back with hot cache", clockName),
-      [](auto& timePoints, size_t) -> void {
-        timePoints.push_back(Clock::now());
-      },
-      iterations);
-  testClock<Clock, false>(
-      fmt::format("{} push_back with cold cache", clockName),
-      [](auto& timePoints, size_t) -> void {
-        timePoints.push_back(Clock::now());
-      },
-      iterations);
-
-  testClock<Clock, true>(
-      fmt::format("{} [] with hot cache", clockName),
-      [](auto& timePoints, size_t i) -> void { timePoints[i] = Clock::now(); },
-      iterations);
-  testClock<Clock, false>(
-      fmt::format("{} [] with cold cache", clockName),
-      [](auto& timePoints, size_t i) -> void { timePoints[i] = Clock::now(); },
-      iterations);
-#if XSIMD_WITH_SSE2
-  testClock<Clock, true>(
-      fmt::format("{} non temporal with hot cache", clockName),
-      [](auto& timePoints, size_t i) -> void {
-        auto n = Clock::now();
-        _mm_stream_pi(
-            reinterpret_cast<__m64*>(&timePoints[i]),
-            *reinterpret_cast<__m64*>(&n));
-      },
-      iterations);
-  testClock<Clock, false>(
-      fmt::format("{} non temporal with cold cache", clockName),
-      [](auto& timePoints, size_t i) -> void {
-        auto n = Clock::now();
-        _mm_stream_pi(
-            reinterpret_cast<__m64*>(&timePoints[i]),
-            *reinterpret_cast<__m64*>(&n));
-      },
-      iterations);
-#endif
-}
-
-/// Compute basic statistics acros an event sequence
-/// \tparam Clock
-/// \param eventSequence
-/// \return
-template <typename Clock>
-auto timerEventStats(const NamedEventSequence<Clock>& eventSequence) {
-  accumulator_set<
-      double,
-      stats<tag::min, tag::max, tag::mean, tag::lazy_variance>>
-      accumulatorSet;
-  for (size_t i = 0; i < eventSequence.endEvents.size(); i++) {
-    auto durations = eventSequence.endEvents[i].timePoint -
-        eventSequence.startEvents[i].timePoint;
-    accumulatorSet(static_cast<double>(durations.count()));
-  }
-  return accumulatorSet;
-}
-
-/// For a given clock, this function returns some statistics on the how precise
-/// the ScopedTimer are
-/// \tparam Clock
-/// \tparam warmCache runtime the test twice to warm the cache
-/// \param iterations
-template <typename Clock, bool warmCache>
-void testNestedTimer(const std::string& message, size_t iterations) {
-  NamedEventSequence<Clock> eventSequence;
-
-  if constexpr (warmCache) {
-    for (size_t i = 0; i < iterations; i++) {
-      NamedNestedScopedTimer<Clock> timer1(
-          "NamedNestedScopeTimer", eventSequence);
-    };
-    eventSequence.startEvents.clear();
-    eventSequence.endEvents.clear();
-  }
-
-  for (size_t i = 0; i < iterations; i++) {
-    NamedNestedScopedTimer<Clock> timer1(
-        "NamedNestedScopeTimer", eventSequence);
-  };
-  auto stats = timerEventStats(eventSequence);
-  std::cout << fmt::format(
-      "{} : min = {},max = {}, mean = {}, variance = {}\n",
-      message,
-      min(stats),
-      max(stats),
-      mean(stats),
-      variance(stats));
-}
-
-TEST_F(ClockTest, clockPrecision) {
-  printClockStatistics<std::chrono::steady_clock>("steady_clock", iteration);
-  std::cout << "------" << std::endl;
-  printClockStatistics<std::chrono::high_resolution_clock>(
-      "high_resolution_clock", iteration);
-  ASSERT_TRUE(true);
-}
-
-TEST_F(ClockTest, nestTimerPrecision) {
-  testNestedTimer<std::chrono::steady_clock, true>(
-      "steady_clock hot cache", iteration);
-  testNestedTimer<std::chrono::steady_clock, false>(
-      "steady_clock cold cache", iteration);
-
-  testNestedTimer<std::chrono::high_resolution_clock, true>(
-      "high_resolution_clock hot cache", iteration);
-  testNestedTimer<std::chrono::high_resolution_clock, true>(
-      "high_resolution_clock cold cache", iteration);
-  ASSERT_TRUE(true);
-}
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/utils/timer/tests/TARGETS_disabled b/velox/experimental/codegen/utils/timer/tests/TARGETS_disabled
deleted file mode 100644
index a7373eb0b4502..0000000000000
--- a/velox/experimental/codegen/utils/timer/tests/TARGETS_disabled
+++ /dev/null
@@ -1,17 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
-
-cpp_unittest(
-    name = "velox_codegen_utils_timer_test",
-    srcs = [
-        "ClockTests.cpp",
-        "TimerTests.cpp",
-    ],
-    deps = [
-        "fbsource//third-party/xsimd:xsimd",  # @manual
-        "//velox/experimental/codegen/utils/timer:velox_codegen_utils_timer",
-    ],
-    external_deps = [
-        "glog",
-        ("boost", None, "boost_accumulators"),
-    ],
-)
diff --git a/velox/experimental/codegen/utils/timer/tests/TimerTests.cpp b/velox/experimental/codegen/utils/timer/tests/TimerTests.cpp
deleted file mode 100644
index b3b66d72088e7..0000000000000
--- a/velox/experimental/codegen/utils/timer/tests/TimerTests.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include <chrono>
-#include "velox/experimental/codegen/utils/timer/NestedScopedTimer.h"
-
-namespace facebook::velox::codegen {
-using namespace std::chrono_literals;
-
-class TimerTest : public testing::Test {};
-
-/// Testing clock with constant increments of 10 ns
-/// This make testing more predictable.
-struct TestClock {
-  static auto now() {
-    static size_t count = 0; // Assuming single threading here
-    count++;
-    return std::chrono::steady_clock::time_point::min() + count * 10ns;
-  }
-  using time_point = std::chrono::steady_clock::time_point;
-  using duration = std::chrono::steady_clock::duration;
-};
-
-using TestEventSequence = NamedEventSequence<TestClock>;
-using TestTimerTree = TimerTree<TestClock>;
-using TestNamedNestedScopedTimer = NamedNestedScopedTimer<TestClock>;
-
-TEST_F(TimerTest, improperNesting1) {
-  const char* name1 = "Counter A";
-  TestEventSequence eventSequence;
-  eventSequence.addEndEvent(name1);
-  EXPECT_THROW(
-      TestTimerTree::fromEventSequence(eventSequence), std::runtime_error);
-}
-
-TEST_F(TimerTest, improperNesting2) {
-  const char* name1 = "Counter A";
-  TestEventSequence eventSequence;
-  eventSequence.addStartEvent(name1);
-  EXPECT_THROW(
-      TestTimerTree::fromEventSequence(eventSequence), std::runtime_error);
-}
-
-TEST_F(TimerTest, EventSequence) {
-  TestEventSequence eventSequence;
-  {
-    TestNamedNestedScopedTimer timer1("A", eventSequence);
-    TestNamedNestedScopedTimer timer2("B", eventSequence);
-    TestNamedNestedScopedTimer timer3("C", eventSequence);
-    TestNamedNestedScopedTimer timer4("D", eventSequence);
-  }
-  ASSERT_EQ(eventSequence.startEvents.size(), 4);
-  ASSERT_EQ(eventSequence.endEvents.size(), 4);
-
-  ASSERT_EQ(eventSequence.startEvents[0].info, "A");
-  ASSERT_EQ(eventSequence.startEvents[1].info, "B");
-  ASSERT_EQ(eventSequence.startEvents[2].info, "C");
-  ASSERT_EQ(eventSequence.startEvents[3].info, "D");
-
-  ASSERT_EQ(eventSequence.endEvents[0].info, "D");
-  ASSERT_EQ(eventSequence.endEvents[1].info, "C");
-  ASSERT_EQ(eventSequence.endEvents[2].info, "B");
-  ASSERT_EQ(eventSequence.endEvents[3].info, "A");
-}
-
-TEST_F(TimerTest, nestedTimerCount) {
-  TestEventSequence eventSequence;
-
-  {
-    TestNamedNestedScopedTimer timer1("main", eventSequence);
-    for (size_t i = 0; i < 10; ++i) {
-      TestNamedNestedScopedTimer timer5("loop", eventSequence);
-
-      if (i % 3 == 0) {
-        TestNamedNestedScopedTimer timer2("if", eventSequence);
-      } else {
-        TestNamedNestedScopedTimer timer3("else1", eventSequence);
-        TestNamedNestedScopedTimer timer4("else2", eventSequence);
-      }
-    }
-  }
-  auto timerTree = TestTimerTree::fromEventSequence(eventSequence);
-  ASSERT_EQ(timerTree->children["main"]->timePoints.size(), 2);
-  ASSERT_EQ(
-      timerTree->children["main"]->children["loop"]->timePoints.size(), 20);
-  ASSERT_EQ(
-      timerTree->children["main"]
-          ->children["loop"]
-          ->children["else1"]
-          ->children["else2"]
-          ->timePoints.size(),
-      timerTree->children["main"]
-          ->children["loop"]
-          ->children["else1"]
-          ->timePoints.size());
-  ASSERT_EQ(
-      timerTree->children["main"]
-              ->children["loop"]
-              ->children["if"]
-              ->timePoints.size() +
-          timerTree->children["main"]
-              ->children["loop"]
-              ->children["else1"]
-              ->timePoints.size(),
-      timerTree->children["main"]->children["loop"]->timePoints.size());
-}
-
-TEST_F(TimerTest, nestedTimerPrint) {
-  TestEventSequence eventSequence;
-
-  {
-    TestNamedNestedScopedTimer timer1("main", eventSequence);
-    for (size_t i = 0; i < 10; ++i) {
-      TestNamedNestedScopedTimer timer5("loop", eventSequence);
-
-      if (i % 2 == 0) {
-        TestNamedNestedScopedTimer timer2("even", eventSequence);
-      } else {
-        TestNamedNestedScopedTimer timer3("odd1", eventSequence);
-        TestNamedNestedScopedTimer timer4("odd2", eventSequence);
-      }
-    }
-  }
-  auto timerTree = TestTimerTree::fromEventSequence(eventSequence);
-  TestTimerTree::computeStatistics(*timerTree);
-  const std::string result =
-      R"counter([<ROOT>] : count = 1, min = 0, max = 0, avg = 0 , total (ns) = 0 , % parent = 0.00 , % total = 0.00
-+[main] : count = 1, min = 510, max = 510, avg = 510 , total (ns) = 510 , % parent = 100.00 , % total = 100.00
-++[loop] : count = 10, min = 30, max = 50, avg = 40 , total (ns) = 400 , % parent = 78.43 , % total = 78.43
-+++[even] : count = 5, min = 10, max = 10, avg = 10 , total (ns) = 50 , % parent = 12.50 , % total = 9.80
-+++[odd1] : count = 5, min = 30, max = 30, avg = 30 , total (ns) = 150 , % parent = 37.50 , % total = 29.41
-++++[odd2] : count = 5, min = 10, max = 10, avg = 10 , total (ns) = 50 , % parent = 33.33 , % total = 9.80
-)counter";
-  std::stringstream output;
-  timerTree->print(output, "", "+");
-  ASSERT_EQ(result, output.str());
-}
-
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/vector_function/CMakeLists.txt b/velox/experimental/codegen/vector_function/CMakeLists.txt
deleted file mode 100644
index ca96b6d0f2aab..0000000000000
--- a/velox/experimental/codegen/vector_function/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
-add_library(velox_codegen_vector_function INTERFACE)
diff --git a/velox/experimental/codegen/vector_function/ConcatExpression-inl.h b/velox/experimental/codegen/vector_function/ConcatExpression-inl.h
deleted file mode 100644
index dba1f62fc27c9..0000000000000
--- a/velox/experimental/codegen/vector_function/ConcatExpression-inl.h
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#if ENABLE_CONCEPTS
-#include <concepts> // @manual
-#endif // concept
-
-#include <tuple>
-#include <utility>
-#include "velox/expression/Expr.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-/// Expected generated code format.
-/// struct  Generated1 {
-///  using veloxInputType  = std::tuple<DoubleType ,DoubleType>;
-///  using veloxOutputType = std::tuple<DoubleType>;
-///  using State = int;
-///  template<typename IN,typename OUT>
-///  void operator()(IN  && input,
-///                  OUT &&  output){
-///    std::get<0>(output) = std::get<0>(input) + std::get<1>(input);
-///  }
-//};
-
-template <typename TUPLE>
-struct refTuple {};
-template <typename... T>
-struct refTuple<std::tuple<T...>> {
-  using type = std::tuple<std::add_lvalue_reference_t<T>...>;
-};
-template <typename TUPLE>
-using refTuple_t = typename refTuple<TUPLE>::type;
-
-#if ENABLE_CONCEPTS
-template <typename GeneratedExpression>
-concept compiledExpression =
-    requires(GeneratedExpression& generatedExpression) {
-  typename veloxInputType = std::tuple<DoubleType, DoubleType>;
-  typename veloxOutputType = std::tuple<DoubleType>;
-  std::constructible_from<
-      GeneratedExpression,
-      const typename GeneratedExpression::State&>;
-  // TOOD: this should be templated function
-
-  requires(
-      typename GeneratedExpression::inputTupleType & input,
-      typename GeneratedExpression::outputTupleType & output) {
-    { generatedExpression(input, output) } -> std::same_as<void>;
-  };
-};
-#endif // concept
-
-/// Given a sequence of compiled expressions, this class represent the
-/// concatenation in order of those expressions.
-/// See test classes for use samples
-/// \tparam veloxInputType_ ImplType input (eg DoubleType)
-/// \tparam veloxOutputType_ ImplType input (eg DoubleType)
-/// \tparam T compiled expression classes. Each T has the shape of
-///         std::tuple<CompiledExprression,
-///                    std::index_sequence,
-///                    std::index_sequence>
-///        where the std::index_sequences represent the mapping between the
-///        input and output of T and the concatenation of all Ts
-
-template <
-    bool hasFilter_,
-    typename VeloxInputType_,
-    typename VeloxOutputType_,
-    typename... T> // T =
-                   // std::tuple<GeneratedExpression,std::index_sequence,std::index_sequence>
-#if ENABLE_CONCEPTS
-requires(compiledExpression<T>&&...) // All the type parameters
-                                     // are GeneratedExpression
-#endif
-    class ConcatExpression {
- public:
-  template <typename TYPE>
-  using GeneratedCode = std::tuple_element_t<0, TYPE>;
-
-  // InputMap<T> = std::index_sequence<a,b,c,d,...> where
-  // where columns a is mapped to the first input of T, b to the second etc...
-  template <typename TYPE>
-  using InputMap = std::tuple_element_t<1, TYPE>;
-
-  // OutputMap<T> = std::index_sequence<a,b,c,d,...> where T produces the
-  // output columns a,b,... of the final concatenation.
-  template <typename TYPE>
-  using OutputMap = std::tuple_element_t<2, TYPE>;
-
-  // Transforms arg packs into a std::tuple
-  using TemplateTupleHelper = std::tuple<T...>;
-
-  template <size_t index>
-  using GeneratedCodeAtIndex =
-      GeneratedCode<std::tuple_element_t<index, TemplateTupleHelper>>;
-
-  // InputMap of the  index'th expression being concatenated
-  template <size_t index>
-  using InputMapAtIndex =
-      InputMap<std::tuple_element_t<index, TemplateTupleHelper>>;
-
-  // OutputMap of the  index'th expression being concatenated
-  template <size_t index>
-  using OutputMapAtIndex =
-      OutputMap<std::tuple_element_t<index, TemplateTupleHelper>>;
-
-  // The state of the concatenation is simply the concatenation of states.
-  using State = std::tuple<typename GeneratedCode<T>::State...>;
-
-  using VeloxInputType = VeloxInputType_;
-  using VeloxOutputType = VeloxOutputType_;
-
-  static constexpr bool hasFilter = hasFilter_;
-
-  /// TODO: It's important that this function and helper be inline
-  template <typename InputTuple, typename OutputTuple>
-  inline bool operator()(InputTuple&& input, OutputTuple&& output) {
-    if constexpr (hasFilter) {
-      std::tuple<std::optional<bool>> filterOutput({});
-      this->helperFilter(input, filterOutput, std::index_sequence<0>{});
-      auto passed = std::get<0>(filterOutput);
-      if (!passed || !*passed) {
-        return false;
-      }
-      helperFromInd1(input, output, std::make_index_sequence<sizeof...(T)>{});
-      return true;
-    } else {
-      helper(input, output, std::make_index_sequence<sizeof...(T)>{});
-      return true;
-    }
-  }
-
- private:
-  void resetAllocators() {
-    resetAllocators_(std::make_index_sequence<sizeof...(T)>{});
-  }
-
-  template <typename InputTuple, typename OutputTuple, std::size_t... Indices>
-  inline void helper(
-      InputTuple&& input,
-      OutputTuple&& output,
-      [[maybe_unused]] const std::index_sequence<Indices...>& unused) {
-    (std::get<Indices>(expressions)(
-         helperGetMany(input, InputMapAtIndex<Indices>{}),
-         helperGetMany(output, OutputMapAtIndex<Indices>{})),
-     ...);
-  }
-
-  template <typename InputTuple, typename OutputTuple, std::size_t... Indices>
-  inline void helperFilter(
-      InputTuple&& input,
-      OutputTuple&& output,
-      [[maybe_unused]] const std::index_sequence<Indices...>& unused) {
-    (std::get<Indices>(expressions)(
-         helperGetMany(input, InputMapAtIndex<Indices>{}), output),
-     ...);
-  }
-
-  template <typename InputTuple, typename OutputTuple, std::size_t... Indices>
-  inline void helperFromInd1(
-      InputTuple&& input,
-      OutputTuple&& output,
-      [[maybe_unused]] const std::index_sequence<0, Indices...>& unused) {
-    this->helper(input, output, std::index_sequence<Indices...>{});
-  }
-
-  std::tuple<GeneratedCode<T>...> expressions;
-  template <size_t... Indices>
-  void resetAllocators_(const std::index_sequence<Indices...>&) {
-    (std::get<Indices>(expressions).state.allocator.reset(), ...);
-  }
-
-  /// Give a tuple T and an index_sequence return a new tuple with
-  /// the elements from T at index in the  index_sequnce.
-  /// eg (a,b,c,d,e), (2,4) -> (c,e)
-  /// \tparam TUPLE Input tuple type
-  /// \tparam Index Index of element to extracts
-  /// \param tuple
-  /// \param unused
-  /// \return new tuple
-  template <typename TupleType, size_t... Index>
-  inline auto helperGetMany(
-      TupleType&& tuple,
-      [[maybe_unused]] const std::index_sequence<Index...>& unused) {
-    return std::forward_as_tuple(
-        std::get<Index>(std::forward<TupleType>(tuple))...);
-  }
-};
-
-} // namespace codegen
-} // namespace velox
-}; // namespace facebook
diff --git a/velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h b/velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h
deleted file mode 100644
index 83085a96ce526..0000000000000
--- a/velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h
+++ /dev/null
@@ -1,447 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <iostream>
-#include <thread>
-#include <type_traits>
-#include <utility>
-#include "velox/experimental/codegen/vector_function/ConcatExpression-inl.h"
-#include "velox/experimental/codegen/vector_function/Perf.h"
-#include "velox/experimental/codegen/vector_function/VectorReader-inl.h"
-#include "velox/expression/VectorFunction.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-template <bool isDefaultNull, bool isDefaultNullStrict>
-struct InputReaderConfig {
-  static constexpr bool isWriter_ = false;
-  // when true, the reader will never read a nullvalue
-  static constexpr bool mayReadNull_ = !isDefaultNull && !isDefaultNullStrict;
-
-  // irrelevent for reader
-  static constexpr bool mayWriteNull_ = false;
-  static constexpr bool intializedWithNullSet_ = false;
-
-  constexpr static bool inputStringBuffersShared = false;
-  constexpr static bool constantStringBuffersShared = false;
-};
-
-template <bool isDefaultNull, bool isDefaultNullStrict>
-struct OutputReaderConfig {
-  static constexpr bool isWriter_ = true;
-  // true means set to null, false means not null
-  static constexpr bool intializedWithNullSet_ =
-      isDefaultNull || isDefaultNullStrict;
-  // when true, the reader will never reveive a null value to write
-  static constexpr bool mayWriteNull_ = !isDefaultNullStrict;
-  static constexpr bool mayReadNull_ = mayWriteNull_;
-
-  constexpr static bool inputStringBuffersShared = true;
-  constexpr static bool constantStringBuffersShared = false;
-};
-
-// #define DEBUG_CODEGEN
-// Debugging/printing functions
-namespace {
-template <typename ReferenceType>
-std::ostream& printReference(
-    std::ostream& out,
-    const ReferenceType& reference) {
-  auto value = reference.toOptionalValueType();
-
-  std::stringstream referenceStream;
-  if (!value.has_value()) {
-    referenceStream << "Null";
-  } else {
-    referenceStream << value.value();
-  }
-  out << fmt::format(
-      "ReferenceType [ rowIndex {}, vector address {}, value {} ]",
-      reference.rowIndex_,
-      static_cast<void*>(reference.reader_.vector_.get()),
-      referenceStream.str());
-  return out;
-}
-
-template <typename ValType>
-std::ostream& printValue(std::ostream& out, const ValType& value) {
-  std::stringstream referenceStream;
-  if (!value.has_value()) {
-    referenceStream << "Null";
-  } else {
-    referenceStream << value.value();
-  }
-  out << fmt::format("[ value {} ]", referenceStream.str());
-  return out;
-}
-
-template <typename... Types>
-void printTuple(const std::tuple<Types...>& tuple) {
-  auto printElement = [](/*auto && first,*/ auto&&... elements) {
-    (printValue(std::cerr, elements), ...);
-  };
-  std::apply(printElement, tuple);
-};
-
-// HelperFunction
-template <typename... Types>
-std::ostream& operator<<(std::ostream& out, const std::tuple<Types...>& tuple) {
-  auto printElement = [&out](auto&& first, auto&&... elements) {
-    out << std::forward<decltype(first)>(first);
-    ((out << ", " << std::forward<decltype(elements)>(elements)), ...);
-  };
-  std::apply(printElement, tuple);
-  return out;
-};
-} // namespace
-
-/// Base class for all generated function
-/// This add a new apply method to support multiple output;
-class GeneratedVectorFunctionBase
-    : public facebook::velox::exec::VectorFunction {
- public:
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Woverloaded-virtual"
-  // Multiple output apply method.
-  virtual size_t apply(
-      const facebook::velox::SelectivityVector& rows,
-      std::vector<facebook::velox::VectorPtr>& args,
-      const TypePtr& /* outputType */,
-      facebook::velox::exec::EvalCtx& context,
-      std::vector<facebook::velox::VectorPtr>& results) const = 0;
-#pragma clang diagnostic pop
-
-  void setRowType(const std::shared_ptr<const RowType>& rowType) {
-    rowType_ = rowType;
-  }
-
- protected:
-  std::shared_ptr<const RowType> rowType_;
-};
-
-// helper templates/functions
-namespace {
-template <typename Func, typename T, std::size_t... Indices>
-void applyLambdaToVector(
-    Func func,
-    std::vector<T>& args,
-    [[maybe_unused]] const std::index_sequence<Indices...>& unused) {
-  (func(args[Indices]), ...);
-}
-
-template <size_t... Indices>
-constexpr bool indexIn(const size_t i, const std::index_sequence<Indices...>&) {
-  return ((i == Indices) || ...);
-}
-} // namespace
-
-///
-/// \tparam GeneratedCode
-template <typename GeneratedCodeConfig>
-class GeneratedVectorFunction : public GeneratedVectorFunctionBase {
- public:
-  using GeneratedCode = typename GeneratedCodeConfig::GeneratedCodeClass;
-  using OutputTypes = typename GeneratedCode::VeloxOutputType;
-  using InputTypes = typename GeneratedCode::VeloxInputType;
-
-  // only useful when there's filter
-  using FilterInputIndices =
-      typename GeneratedCode::template InputMapAtIndex<0>;
-
-  GeneratedVectorFunction() : generatedExpression_() {}
-
- public:
-  virtual void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    VELOX_CHECK(result != nullptr);
-    VELOX_CHECK(rowType_ != nullptr);
-    VELOX_CHECK(result == nullptr or (result->as<RowVector>() != nullptr));
-
-    // all-constant expressions shouldn't be compiled
-    VELOX_CHECK(args.size() > 0);
-
-    BaseVector::ensureWritable(rows, rowType_, context.pool(), result);
-
-    // TODO: We should probably move this loop inside ensureWritable
-    for (size_t columnIndex = 0; columnIndex < rowType_->size();
-         ++columnIndex) {
-      BaseVector::ensureWritable(
-          rows,
-          rowType_->childAt(columnIndex),
-          context.pool(),
-          result->as<RowVector>()->childAt(columnIndex));
-    }
-
-    // Constuct nulls
-    for (auto& child : result->as<RowVector>()->children()) {
-      child->setCodegenOutput();
-      if constexpr (
-          (GeneratedCodeConfig::isDefaultNull ||
-           GeneratedCodeConfig::isDefaultNullStrict) &&
-          !GeneratedCode::hasFilter) {
-        // preset all with nulls, only if it's projection only
-        child->addNulls(nullptr, rows);
-      } else {
-        // preset all not nulls
-        child->mutableRawNulls();
-      }
-    }
-
-    result->setCodegenOutput();
-
-    VELOX_CHECK(result->as<RowVector>() != nullptr);
-
-    // Shared string input buffer
-    // TODO: write now we are sharing everything, this not ideal. We should do
-    // a static analysis reachability pass and acquire shared buffers
-    // accordingly to reduce memory lifetime.
-    for (auto& arg : args) {
-      if (arg->type()->kind() == TypeKind::VARCHAR) {
-        for (size_t columnIndex = 0; columnIndex < rowType_->size();
-             ++columnIndex) {
-          // Ensures that the results vectors are nullables.
-          if (result->as<RowVector>()->childAt(columnIndex)->type()->kind() ==
-              TypeKind::VARCHAR) {
-            result->as<RowVector>()
-                ->childAt(columnIndex)
-                ->template asFlatVector<StringView>()
-                ->acquireSharedStringBuffers(arg.get());
-          }
-        }
-      }
-    }
-
-    size_t resultSize;
-
-    if constexpr (
-        GeneratedCodeConfig::isDefaultNull ||
-        GeneratedCodeConfig::isDefaultNullStrict) {
-      // only proccess indices where all inputs are not nulls
-      auto rowsNotNull = rows;
-
-      auto deselectNull = [&](const VectorPtr& arg) {
-        if (arg->mayHaveNulls()) {
-          exec::LocalDecodedVector decodedVector(context, *arg, rowsNotNull);
-          if (auto* rawNulls = decodedVector->nulls()) {
-            rowsNotNull.deselectNulls(rawNulls, rows.begin(), rows.end());
-          }
-        }
-      };
-
-      if constexpr (GeneratedCode::hasFilter) {
-        /// when it's filter default null, we only deselect null bits on filter
-        /// attributes even if projection's also default null, because input
-        /// index and output index don't match now.
-        applyLambdaToVector(deselectNull, args, FilterInputIndices{});
-      } else {
-        for (const auto& arg : args) {
-          deselectNull(arg);
-        }
-      }
-
-      resultSize = apply(
-          rowsNotNull,
-          args,
-          outputType,
-          context,
-          result->as<RowVector>()->children());
-
-    } else {
-      resultSize = apply(
-          rows, args, outputType, context, result->as<RowVector>()->children());
-    }
-
-    // truncate result
-    if (resultSize != args[0]->size()) {
-      for (size_t columnIndex = 0; columnIndex < rowType_->size();
-           ++columnIndex) {
-        result->as<RowVector>()->childAt(columnIndex)->resize(resultSize);
-      }
-      result->resize(resultSize);
-    }
-  }
-
-  size_t apply(
-      const facebook::velox::SelectivityVector& rows,
-      std::vector<facebook::velox::VectorPtr>& args,
-      const TypePtr& /* outputType */,
-      facebook::velox::exec::EvalCtx& context,
-      std::vector<facebook::velox::VectorPtr>& results) const override {
-    VELOX_CHECK(rowType_ != nullptr);
-    VELOX_CHECK(results.size() == rowType_->size());
-
-    auto inReaders = createReaders(
-        args,
-        std::make_integer_sequence<
-            std::size_t,
-            std::tuple_size_v<InputTypes>>{});
-
-    auto outReaders = createWriters(
-        results,
-        std::make_integer_sequence<
-            std::size_t,
-            std::tuple_size_v<OutputTypes>>{});
-
-    size_t outIndex = 0;
-    auto computeRow =
-        [&inReaders, &outReaders, this, &outIndex](size_t rowIndex) {
-          // Input tuples
-          auto inputs = applyToTuple(
-              [rowIndex](auto&& reader) -> auto {
-                return (const typename std::remove_reference_t<
-                        decltype(reader)>::InputType)reader[rowIndex];
-              },
-              inReaders,
-              std::make_integer_sequence<
-                  std::size_t,
-                  std::tuple_size_v<InputTypes>>{});
-
-#ifdef DEBUG_CODEGEN
-          // Debugging code
-          std::cerr << "Input : ";
-          printTuple(inputs);
-          std::cerr << std::endl;
-#endif
-
-          // Output tuples
-          if constexpr (!GeneratedCode::hasFilter) {
-            // with filter, output index is computed and depends on how many
-            // passed the filter, without filter, it's just input index
-            outIndex = rowIndex;
-          }
-
-          auto outputs = applyToTuple(
-              [outIndex](auto&& reader) ->
-              typename std::remove_reference_t<decltype(reader)>::PointerType {
-                return reader[outIndex];
-              },
-              outReaders,
-              std::make_integer_sequence<
-                  std::size_t,
-                  std::tuple_size_v<OutputTypes>>{});
-
-          // Apply the generated function.
-          if constexpr (GeneratedCode::hasFilter) {
-            // with filter, return value indicates passed or not
-            if (generatedExpression_(inputs, outputs)) {
-              outIndex++;
-            }
-          } else {
-            generatedExpression_(inputs, outputs);
-          }
-
-#ifdef DEBUG_CODEGEN
-          // Debugging code
-          std::cerr << "Output : ";
-          printTuple(outputs);
-          std::cerr << std::endl;
-#endif
-          return true;
-        };
-
-    {
-      Perf perf;
-      rows.applyToSelected(computeRow);
-    }
-
-    // no filter, the return value is just original size
-    if constexpr (!GeneratedCode::hasFilter) {
-      outIndex = args[0]->size();
-    }
-
-    return outIndex;
-  }
-
-  // TODO: Missing implementation;
-  virtual bool isDeterministic() const override {
-    return true;
-  }
-
-  virtual bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
-  // Builds a new Instance
-  static std::shared_ptr<GeneratedVectorFunction<GeneratedCode>> newInstance(
-      const std::vector<TypePtr>& inputTypes,
-      const std::vector<TypePtr>& outputTypes) {
-    return std::make_shared<GeneratedVectorFunction<GeneratedCode>>(
-        inputTypes, outputTypes);
-  }
-
- private:
-  template <typename... SQLImplType>
-  auto toVectorType(const std::tuple<SQLImplType...>&) const {
-    return std::vector<TypePtr>{std::make_shared<SQLImplType>()...};
-  }
-
-  template <size_t... Indices>
-  auto createReaders(
-      std::vector<facebook::velox::VectorPtr>& args,
-      const std::index_sequence<Indices...>&) const {
-    if constexpr (
-        GeneratedCode::hasFilter && GeneratedCodeConfig::isDefaultNull) {
-      // Filter default null
-      return std::make_tuple(
-          VectorReader<
-              std::tuple_element_t<Indices, InputTypes>,
-              InputReaderConfig<indexIn(Indices, FilterInputIndices{}), false>>(
-              args[Indices])...);
-    } else {
-      return std::make_tuple(
-          VectorReader<
-              std::tuple_element_t<Indices, InputTypes>,
-              InputReaderConfig<
-                  GeneratedCodeConfig::isDefaultNull,
-                  GeneratedCodeConfig::isDefaultNullStrict>>(args[Indices])...);
-    }
-  }
-
-  template <size_t... Indices>
-  auto createWriters(
-      std::vector<facebook::velox::VectorPtr>& results,
-      const std::index_sequence<Indices...>&) const {
-    return std::make_tuple(VectorReader<
-                           std::tuple_element_t<Indices, OutputTypes>,
-                           OutputReaderConfig<
-                               GeneratedCodeConfig::isDefaultNull,
-                               GeneratedCodeConfig::isDefaultNullStrict>>(
-        results[Indices])...);
-  }
-  template <typename Func, typename Tuple, size_t... Index>
-  inline auto applyToTuple(
-      Func&& fun,
-      Tuple&& args,
-      [[maybe_unused]] const std::index_sequence<Index...>& indices =
-          std::index_sequence<Index...>{}) const {
-    /// TODO:  This might need to be improved in case func return ref types.
-    return std::make_tuple(fun(std::get<Index>(std::forward<Tuple>(args)))...);
-  }
-
-  mutable GeneratedCode generatedExpression_;
-};
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/vector_function/Perf.h b/velox/experimental/codegen/vector_function/Perf.h
deleted file mode 100644
index a6bcf1d4d1bb0..0000000000000
--- a/velox/experimental/codegen/vector_function/Perf.h
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <iostream>
-
-#if !defined(CODEGEN_PERF) || !defined(__linux__)
-namespace facebook::velox::codegen {
-class Perf {
- public:
-  Perf() {}
-  template <typename Seq>
-  explicit Perf(const Seq&) {}
-
-  template <typename PerfEvent>
-  [[maybe_unused]] void addEvent(PerfEvent) {}
-  void start() const {}
-  void stop() const {}
-  void reset() const {}
-  void report() const {}
-  void report(std::ostream&) const {}
-};
-} // namespace facebook::velox::codegen
-#else
-
-#include <linux/perf_event.h>
-#include <stdint.h>
-#include <sys/ioctl.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-#include <list>
-#include <vector>
-
-const inline std::string hw_events[] = {
-    "cpu cycles",
-    "instructions",
-    "cache references",
-    "cache misses",
-    "branch instructions",
-    "branch misses",
-    "bus cycles",
-    "stalled cycles frontend",
-    "stalled cycles backend",
-    "ref cpu cycles",
-};
-
-const inline std::string sw_events[] = {
-    "cpu clock",
-    "task clock",
-    "page faults",
-    "context switches",
-    "cpu migrations",
-    "page faults minor",
-    "page faults major",
-    "alignment faults",
-    "emulation faults",
-    "dummy",
-    "BPF output",
-};
-
-const inline std::string cache_events[] = {
-    "l1d",
-    "l1i",
-    "ll",
-    "dtlb",
-    "itlb",
-    "bpu",
-    "node",
-};
-
-const inline std::string cache_ops[] = {
-    "read",
-    "write",
-    "prefetch",
-};
-
-const inline std::string cache_results[] = {
-    "access",
-    "miss",
-};
-
-struct PerfEvent {
-  uint32_t type;
-  uint32_t config;
-};
-
-inline std::vector<PerfEvent> defaultEvents = {
-    //    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},
-    //    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},
-    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS},
-    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES},
-    //    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES},
-    //    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},
-    {PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK},
-    {PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK},
-};
-
-inline std::ostream& operator<<(std::ostream& os, const PerfEvent& e) {
-  switch (e.type) {
-    case PERF_TYPE_HARDWARE:
-      return os << hw_events[e.config];
-    case PERF_TYPE_SOFTWARE:
-      return os << sw_events[e.config];
-    case PERF_TYPE_HW_CACHE:
-      return os << cache_events[e.config & 0xff] << "_"
-                << cache_ops[(e.config >> 8) & 0xff] << "_"
-                << cache_results[e.config >> 16];
-    default:
-      return os << "Unknown event";
-  }
-}
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-class Perf {
- public:
-  Perf() : Perf(defaultEvents) {}
-  template <typename EventList>
-  explicit Perf(const EventList& eventList) : leader_(-1) {
-    for (const PerfEvent& e : eventList) {
-      addEvent(e);
-    }
-    reset();
-    start();
-  }
-
-  ~Perf() {
-    stop();
-    report();
-    for (auto& [fd, _] : events_) {
-      close(fd);
-    }
-  }
-
-  void addEvent(PerfEvent e) {
-    events_.emplace_back(-1, (perf_event_attr){});
-    auto& [fd, pe] = events_.back();
-    memset(&pe, 0, sizeof(pe));
-    pe.type = e.type;
-    pe.config = e.config;
-    pe.size = sizeof(pe);
-    pe.disabled = 1; // disabled at the beginning
-    pe.exclude_kernel = 1; // only user space event
-    pe.exclude_hv = 1; // exclude hypervisor event (if any)
-    pe.inherit = 1; // count child tasks (if any)
-    pe.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
-        PERF_FORMAT_TOTAL_TIME_RUNNING; // used if PMU is overcommited
-
-    fd = syscall(SYS_perf_event_open, &pe, 0, -1, leader_, 0);
-
-    if (fd == -1) {
-      std::cerr << "Unsupported event: " << e << std::endl;
-      events_.pop_back();
-      return;
-    }
-
-    if (leader_ == -1) {
-      leader_ = fd;
-    }
-  }
-
-  // do we need a removeEvent?
-
-  void start() const {
-    ioctl(leader_, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP);
-  }
-
-  void stop() const {
-    ioctl(leader_, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP);
-  }
-
-  void reset() const {
-    ioctl(leader_, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP);
-  }
-
-  void report(std::ostream& os = std::cerr) const {
-    ReadFormat result;
-    for (auto& [fd, e] : events_) {
-      read(fd, &result, sizeof(result));
-      uint64_t val = result.val;
-      if (result.timeEnabled != result.timeRunning) {
-        os << "WARNING: PMU overcommitted, the result below is only an"
-              " estimation and may not be sane depending on the hardware"
-           << std::endl;
-        val = result.val * (result.timeRunning / (double)result.timeEnabled);
-      }
-      os << (PerfEvent){e.type, (uint32_t)e.config} << ": " << val << std::endl;
-    }
-  }
-
- private:
-  struct __attribute__((packed)) ReadFormat {
-    uint64_t val; // value of event
-    uint64_t timeEnabled; // if PERF_FORMAT_TOTAL_TIME_ENABLED
-    uint64_t timeRunning; // if PERF_FORMAT_TOTAL_TIME_RUNNING
-  };
-  int leader_; // the fd to toggle on/off all events
-  std::list<std::pair<int, perf_event_attr>> events_;
-};
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
-
-#endif // !defined(CODEGEN_PERF) || !defined(__linux__)
diff --git a/velox/experimental/codegen/vector_function/StringTypes.h b/velox/experimental/codegen/vector_function/StringTypes.h
deleted file mode 100644
index 042c6bb0cb7f9..0000000000000
--- a/velox/experimental/codegen/vector_function/StringTypes.h
+++ /dev/null
@@ -1,296 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <optional>
-#include <string>
-#include <unordered_set>
-#include <variant>
-#include "velox/buffer/Buffer.h"
-#include "velox/common/base/Exceptions.h"
-#include "velox/type/StringView.h"
-#pragma once
-
-namespace facebook::velox {
-namespace codegen {
-
-struct TempBuffer {
-  std::unique_ptr<char*> data_ = nullptr;
-  size_t capacity_;
-  size_t currentValid_;
-
-  explicit TempBuffer(size_t capacity) {
-    data_ = std::make_unique<char*>(new char[capacity]);
-    capacity_ = capacity;
-    currentValid_ = 0;
-  }
-
-  ~TempBuffer() {
-    if (data_) {
-      delete[] * data_;
-    }
-  }
-
-  size_t available() const {
-    return capacity_ - currentValid_;
-  }
-};
-
-class TempsAllocator {
- public:
-  // TODO we can allocate on the pool
-  [[nodiscard]] char* allocate(std::size_t n) {
-    if (currentBuffer == -1 || buffers_[currentBuffer]->available() < n) {
-      currentBuffer++;
-      if (currentBuffer == buffers_.size()) {
-        buffers_.push_back(std::make_unique<TempBuffer>(allocationSize));
-      }
-    }
-    auto& buff = *buffers_[currentBuffer];
-    assert(buff.available() >= n);
-
-    buff.currentValid_ += n;
-    return *buff.data_ + buff.currentValid_;
-  }
-
-  void reset() {
-    for (auto& buff : buffers_) {
-      buff->currentValid_ = 0;
-    }
-    currentBuffer = 0;
-  }
-
- private:
-  // Manage lifetime of the allocated buffers
-  std::vector<std::unique_ptr<TempBuffer>> buffers_;
-
-  // Must be larger than max string size, 1G for now
-  static constexpr size_t allocationSize = 1000000000;
-
-  // Point to the current buffer used for allocation
-  int currentBuffer = -1;
-};
-
-// - All string types should be accessed using data() and size()
-// - String types that can be written to should also have resize(),
-// reserve().
-// - There are five different type classes to deal with for strings:
-
-// InputReference strings.
-// - Those are coming from a Velox input vector.
-// - Those are read-only.
-// - We will avoid copying those when assigned to temp or reader::pointerType.
-struct InputReferenceString : public std::reference_wrapper<const StringView> {
-  explicit InputReferenceString(
-      const std::reference_wrapper<const StringView>& string)
-      : std::reference_wrapper<const StringView>(string) {}
-};
-
-struct InputReferenceStringNullable
-    : public std::optional<InputReferenceString> {
-  void operator=(const std::optional<InputReferenceString>& other) {
-    std::optional<InputReferenceString>::operator=(other);
-  }
-};
-
-// ConstantStringNullable strings.
-// - Those are coming from a Velox input vector.
-// - Those are read-only.
-// - We will avoid copying those assigned to temp.
-struct ConstantString : public std::reference_wrapper<const StringView> {
-  explicit ConstantString(
-      const std::reference_wrapper<const StringView>& string)
-      : std::reference_wrapper<const StringView>(string) {}
-};
-
-struct ConstantStringNullable : public std::optional<ConstantString> {
-  void operator=(const std::optional<ConstantString>& other) {
-    std::optional<ConstantString>::operator=(other);
-  }
-};
-
-// Temp strings:
-// - Those do not reach output vector in the current codegen design.
-// - InputReference and ConstantStringNullable and other temp strings can be
-// assigned to those.
-// - We want to avoid copying ConstantStringNullable and InputReference to those
-// for most cases. except when explicitly requested (concat).
-// - Each temp string is written only once in the current codegen design (if
-// written using assignment).
-template <typename Allocator = TempsAllocator>
-struct TempString {
-  std::reference_wrapper<TempsAllocator> allocator_;
-
-  TempString(const TempString& other) = default;
-
-  explicit TempString(Allocator& allocator) : allocator_(allocator) {}
-
-  char* data_ = nullptr;
-
-  size_t size_ = 0;
-
-  /// Has the semantics as std::string, except that it does not fill the
-  /// space[size(), newSize] with 0 but rather leaves it as is
-  void resize(size_t newSize) {
-    if (newSize <= size_) {
-      // shrinking
-      size_ = newSize;
-      return;
-    }
-
-    // newSize > size
-    reserve(newSize);
-    size_ = newSize;
-  }
-
-  /// Reserve a sequential space for the string with at least size bytes.
-  /// should have the semantics as std::string
-  void reserve(size_t newCapacity) {
-    auto& buffer = data_;
-
-    if (buffer == nullptr) {
-      buffer = allocator_.get().allocate(newCapacity);
-      return;
-    }
-
-    // Need to allocate larger string
-    char* oldBuffer = buffer;
-    char* newBuffer = allocator_.get().allocate(newCapacity);
-    buffer = newBuffer;
-
-    // no need to copy old buffer
-    if (size_ == 0) {
-      return;
-    }
-
-    // TODO: avoid this copy when oldBuffer and newBuffer are sequential in
-    // memory
-    std::memcpy(newBuffer, oldBuffer, size_);
-    return;
-  }
-
-  size_t size() const {
-    return size_;
-  }
-
-  char* data() const {
-    return data_;
-  }
-
-  template <typename T>
-  typename std::enable_if_t<
-      std::is_same_v<T, InputReferenceString> ||
-          std::is_same_v<T, ConstantString>,
-      void>
-  operator=(const T& other_) {
-    auto& other = other_.get();
-    data_ = const_cast<char*>(other.data());
-    size_ = other.size();
-  }
-
-  template <typename T>
-  bool operator==(const T& rhs) const {
-    if (rhs.size() != size()) {
-      return false;
-    }
-
-    return memcmp(data(), rhs.data(), size()) == 0;
-  }
-
-  void operator=(const TempString<Allocator>& other) {
-    this->data_ = other.data();
-    this->size_ = other.size();
-    this->allocator_ = other.allocator_;
-  }
-  void finalize() {}
-};
-
-template <typename Allocator = TempsAllocator>
-struct TempStringNullable {
-  TempString<Allocator> tempString;
-
-  TempStringNullable(std::in_place_t, Allocator& allocator)
-      : tempString(allocator) {
-    isNull = false;
-  }
-
-  TempStringNullable(const TempStringNullable<Allocator>& other) = default;
-
-  explicit TempStringNullable(Allocator& allocator) : tempString(allocator) {}
-
-  bool isNull = true;
-
-  bool has_value() const {
-    return !isNull;
-  }
-
-  void operator=(const std::nullopt_t&) {
-    isNull = true;
-  }
-
-  void operator=(const TempStringNullable<Allocator>& rhs) {
-    isNull = rhs.isNull;
-    if (!isNull) {
-      tempString = rhs.tempString;
-    }
-  }
-  // Assigns temp to inputRef or to constant
-  template <typename T>
-  typename std::enable_if_t<
-      std::is_same_v<T, InputReferenceStringNullable> ||
-          std::is_same_v<T, ConstantStringNullable>,
-      void>
-  operator=(const T& other) {
-    if UNLIKELY (!other.has_value()) {
-      // since this is assigned only once we dont even need
-      isNull = true;
-      return;
-    }
-    isNull = false;
-    tempString = *other;
-  }
-
-  TempString<Allocator>& operator*() {
-    assert(!isNull);
-    return tempString;
-  }
-
-  const TempString<Allocator>& operator*() const {
-    assert(!isNull);
-    return tempString;
-  }
-};
-
-// After this line is under construction
-
-// TODO:
-// Special string that is used to for the results of concat.
-// this class can wrap any other writable string type . The wrapping changes the
-// semantics of the assignments to always append the rhs to the string held
-// inside T.
-// it also change the semantics of resize, reserve, data to the append version.
-// i.e: resize (x) = increase size by x.
-// more details once this is implemented. For now this optimization is disabled.
-template <typename T>
-struct ConcatOutputString {};
-
-// Substring in-place 0-copy when possible.
-// TODO:// coming have some thoughts
-
-} // namespace codegen
-} // namespace facebook::velox
diff --git a/velox/experimental/codegen/vector_function/VectorFunctionLoadUtils.h b/velox/experimental/codegen/vector_function/VectorFunctionLoadUtils.h
deleted file mode 100644
index 850a82ef70178..0000000000000
--- a/velox/experimental/codegen/vector_function/VectorFunctionLoadUtils.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/experimental/codegen/library_loader/FunctionTable.h"
-#include "velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h"
diff --git a/velox/experimental/codegen/vector_function/VectorReader-inl.h b/velox/experimental/codegen/vector_function/VectorReader-inl.h
deleted file mode 100644
index 671f330c9c46f..0000000000000
--- a/velox/experimental/codegen/vector_function/VectorReader-inl.h
+++ /dev/null
@@ -1,589 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/buffer/Buffer.h"
-#include "velox/common/base/Nulls.h"
-#include "velox/experimental/codegen/vector_function/StringTypes.h"
-#include "velox/type/Type.h"
-#include "velox/vector/FlatVector.h"
-
-namespace facebook {
-namespace velox {
-namespace codegen {
-
-// Expected members of the vector reader config.
-// struct Config {
-//   static constexpr bool isWriter_
-//   // when true, the reader will never read a nullvalue
-//   static constexpr bool mayReadNull_
-//
-//   static constexpr bool isWriter_
-//   // true means set to null, false means not null
-//   static constexpr bool intializedWithNullSet_
-//
-//   // when true, the reader will never receive a null value to write
-//   static constexpr bool mayWriteNull_
-//
-//
-//  String writer config
-//  constexpr static bool inputStringBuffersShared = false;
-//  constexpr static bool constantStringBuffersShared = false;
-// };
-
-// TODO: move readers to different directory
-/// Only support scalarType for now
-template <TypeKind SQLType>
-constexpr bool readableType = TypeTraits<SQLType>::isFixedWidth ||
-    TypeTraits<SQLType>::typeKind == TypeKind::VARCHAR;
-
-/// Reads from velox vector and produce native values.
-/// This class is meant to behave as much as possible as a std::countainer
-/// We introduce a ReferenceType<T> which approximate T &
-/// This Reader doesn't own the underlying vector.
-/// \tparam SQLType
-/// \tparam nullable true iff the underlying vector is nullable
-/// \tparam presetNullBits set all the nulls bits to bits::kNotNull if true
-/// \tpaarm assumeNullBitSet assume all nulls bits are set to bits::kNotNull if
-/// true
-template <
-    typename SQLType,
-    typename Config,
-    class T = typename std::enable_if_t<
-        readableType<SQLType::NativeType::typeKind>,
-        typename TypeTraits<SQLType::NativeType::typeKind>::NativeType>>
-struct VectorReader {
-  using NativeType = typename SQLType::NativeType::NativeType;
-
-  // The type used for codegen expression inputs
-  using ValueType = std::optional<NativeType>;
-  using InputType = ValueType;
-  explicit VectorReader(VectorPtr& vector) {
-    VELOX_CHECK_NOT_NULL(
-        std::dynamic_pointer_cast<FlatVector<NativeType>>(vector));
-    VELOX_CHECK_EQ(vector->typeKind(), SQLType::NativeType::typeKind);
-
-    auto flatVector = vector->asFlatVector<NativeType>();
-
-    if constexpr (Config::isWriter_) {
-      mutableRawNulls_ = flatVector->mutableRawNulls();
-      mutableRawValues_ = flatVector->mutableRawValues();
-    } else {
-      if constexpr (Config::mayReadNull_) {
-        // TODO when read only vector does not have nulls we dont need to
-        // allocate nulls
-        mutableRawNulls_ = flatVector->mutableRawNulls();
-      }
-      mutableRawValues_ = const_cast<NativeType*>(flatVector->rawValues());
-    }
-  }
-
-  uint64_t* mutableRawNulls_;
-  NativeType* mutableRawValues_;
-
-  struct PointerType {
-    size_t rowIndex_;
-    NativeType* mutableValues_;
-    uint64_t* mutableNulls_;
-
-    inline bool has_value() {
-      // FIXME: generated code should avoid calling on this on the writer and
-      // rather reads the on stack value
-      // static_assert(!Config::isWriter_);
-      if constexpr (!Config::mayReadNull_) {
-        return true;
-
-      } else {
-        // read nullability
-        return !bits::isBitNull(mutableNulls_, rowIndex_);
-      }
-    }
-
-    inline NativeType& operator*() {
-      return mutableValues_[rowIndex_];
-    }
-
-    inline const NativeType& operator*() const {
-      return mutableValues_[rowIndex_];
-    }
-
-    inline PointerType& operator=(const NativeType& other) {
-      static_assert(Config::isWriter_);
-
-      if constexpr (Config::intializedWithNullSet_) {
-        bits::setBit(mutableNulls_, rowIndex_, bits::kNotNull);
-      }
-
-      mutableValues_[rowIndex_] = other;
-      return *this;
-    }
-
-    inline PointerType& operator=(const ValueType& other) {
-      static_assert(Config::isWriter_);
-
-      if constexpr (!Config::mayWriteNull_) {
-        *this = *other;
-        return *this;
-      } else {
-        if (other.has_value()) {
-          *this = *other;
-        } else {
-          if constexpr (!Config::intializedWithNullSet_) {
-            bits::setBit(mutableNulls_, rowIndex_, bits::kNull);
-          }
-        }
-        return *this;
-      }
-    }
-
-    operator ValueType const() {
-      if (!this->has_value()) {
-        return {};
-      }
-      return {*(*this)};
-    }
-  };
-
-  inline PointerType operator[](size_t rowIndex) {
-    return {rowIndex, this->mutableRawValues_, this->mutableRawNulls_};
-  }
-};
-
-// Reader for flatVector<bool>
-// PointerType is the type that is consumed
-// by the expression for outputs.
-// Note: when rawValues is intitialized the initial value for all the values is
-// by default 0 and hence we on
-// TOOD : there is shared code acorss readers, see if we can in away combine it
-template <typename SQLType, typename Config>
-struct VectorReader<
-    SQLType,
-    Config,
-    std::
-        enable_if_t<SQLType::NativeType::typeKind == TypeKind::BOOLEAN, bool>> {
-  explicit VectorReader(VectorPtr& vector) {
-    VELOX_CHECK(vector->type()->kind() == TypeKind::BOOLEAN);
-    auto flatVector = vector->asFlatVector<bool>();
-    VELOX_CHECK_NOT_NULL(flatVector);
-
-    if constexpr (Config::isWriter_) {
-      mutableRawNulls_ = flatVector->mutableRawNulls();
-      mutableRawValues_ = flatVector->template mutableRawValues<uint64_t>();
-    } else {
-      // TODO when read only vector does not have nulls we dont need to allocate
-      // nulls
-      if constexpr (Config::mayReadNull_) {
-        mutableRawNulls_ = flatVector->mutableRawNulls();
-      }
-      mutableRawValues_ =
-          const_cast<uint64_t*>(flatVector->template rawValues<uint64_t>());
-    }
-  }
-
-  // The type used for codegen expression inputs
-  using ValueType = const std::optional<bool>;
-  using InputType = ValueType;
-  struct ReferenceType {
-    size_t rowIndex_;
-    uint64_t* mutableValues_;
-    uint64_t* mutableNulls_;
-
-    inline ReferenceType& operator=(const bool& other) {
-      static_assert(Config::isWriter_);
-
-      if constexpr (Config::intializedWithNullSet_) {
-        bits::setBit(mutableNulls_, rowIndex_, bits::kNotNull);
-      }
-
-      bits::setBit(mutableValues_, rowIndex_, other);
-      return *this;
-    }
-
-    operator bool() const {
-      return bits::isBitSet(mutableValues_, rowIndex_);
-    }
-  };
-
-  struct PointerType {
-    size_t rowIndex_;
-    uint64_t* mutableValues_;
-    uint64_t* mutableNulls_;
-
-    inline bool has_value() {
-      static_assert(!Config::isWriter_);
-      if constexpr (!Config::mayReadNull_) {
-        return true;
-      } else {
-        // read nullability
-        return !bits::isBitNull(mutableNulls_, rowIndex_);
-      }
-    }
-
-    inline ReferenceType operator*() {
-      return ReferenceType{rowIndex_, mutableValues_, mutableNulls_};
-    }
-
-    inline const ReferenceType operator*() const {
-      return ReferenceType{rowIndex_, mutableValues_, mutableNulls_};
-    }
-
-    inline PointerType& operator=(const bool& other) {
-      static_assert(Config::isWriter_);
-      if constexpr (Config::intializedWithNullSet_) {
-        bits::setBit(mutableNulls_, rowIndex_, bits::kNotNull);
-      }
-      bits::setBit(mutableValues_, rowIndex_, other);
-      return *this;
-    }
-
-    inline PointerType& operator=(const ValueType& other) {
-      static_assert(Config::isWriter_);
-
-      if constexpr (!Config::mayWriteNull_) {
-        *this = *other;
-        return *this;
-      } else {
-        if (other.has_value()) {
-          *this = *other;
-        } else {
-          if constexpr (!Config::intializedWithNullSet_) {
-            bits::setBit(mutableNulls_, rowIndex_, bits::kNull);
-          }
-        }
-        return *this;
-      }
-    }
-
-    operator ValueType const() {
-      if (!this->has_value()) {
-        return {};
-      }
-      return {*(*this)};
-    }
-  };
-
-  inline PointerType operator[](size_t rowIndex) {
-    return PointerType{
-        rowIndex, this->mutableRawValues_, this->mutableRawNulls_};
-  }
-
- private:
-  uint64_t* mutableRawNulls_;
-  uint64_t* mutableRawValues_;
-};
-
-//****************************************************************************
-
-// Reader for flatVector<StringView>
-// TODO: avoid copying constant string by allocating them on Velox buffer
-// TODO: specialize for default nulls
-template <typename SQLType, typename Config>
-struct VectorReader<
-    SQLType,
-    Config,
-    std::enable_if_t<
-        SQLType::NativeType::typeKind == TypeKind::VARCHAR,
-        StringView>> {
-  explicit VectorReader(VectorPtr& vector)
-      : vector_(vector->template asFlatVector<StringView>()) {
-    VELOX_CHECK(vector->type()->kind() == TypeKind::VARCHAR);
-    auto flatVector = vector->asFlatVector<StringView>();
-    VELOX_CHECK_NOT_NULL(flatVector);
-
-    if constexpr (Config::isWriter_) {
-      mutableRawNulls_ = flatVector->mutableRawNulls();
-      mutableRawValues_ = flatVector->template mutableRawValues<StringView>();
-    } else {
-      // TODO when read only vector does not have nulls we dont need to allocate
-      // nulls
-      if constexpr (Config::mayReadNull_) {
-        mutableRawNulls_ = flatVector->mutableRawNulls();
-      }
-      mutableRawValues_ =
-          const_cast<StringView*>(flatVector->template rawValues<StringView>());
-    }
-  }
-
-  // The type used for codegen expression inputs
-  using ValueType = std::optional<std::reference_wrapper<const StringView>>;
-  using InputType = codegen::InputReferenceStringNullable;
-
-  // This is used for the output types
-  struct StringWriter {
-   public:
-    StringWriter(
-        FlatVector<StringView>* vector,
-        vector_size_t rowIndex,
-        StringView* mutableValues)
-        : vector_(vector), rowIndex_(rowIndex), mutableValues_(mutableValues) {}
-
-    void operator=(const InputReferenceString& other_) {
-      static_assert(Config::isWriter_);
-
-      auto& other = other_.get();
-      if constexpr (Config::inputStringBuffersShared) {
-        mutableValues_[rowIndex_] = other_;
-      } else {
-        reserve(other.size());
-        if (other.size() != 0) {
-          std::memcpy(data(), other.data(), other.size());
-        }
-        resize(other.size());
-        finalize();
-      }
-    }
-
-    void operator=(const ConstantString& other_) {
-      static_assert(Config::isWriter_);
-
-      auto& other = other_.get();
-      if constexpr (Config::constantStringBuffersShared) {
-        mutableValues_[rowIndex_] = other_;
-      } else {
-        reserve(other.size());
-        if (other.size() != 0) {
-          std::memcpy(data(), other.data(), other.size());
-        }
-        resize(other.size());
-        finalize();
-      }
-    }
-
-    size_t size() const {
-      return size_;
-    }
-
-    size_t capacity() const {
-      return capacity_;
-    }
-
-    char* data() const {
-      return data_;
-    }
-
-    /// Reserve a space for the output string with size of at least newCapacity
-    void reserve(size_t newCapacity) {
-      if (newCapacity <= capacity()) {
-        return;
-      }
-
-      auto* newDataBuffer = vector_->getBufferWithSpace(newCapacity);
-
-      // If the new allocated space is on the same buffer no need to copy
-      // content or reassign start address
-      if (buffer_ == newDataBuffer) {
-        setCapacity(newCapacity);
-        return;
-      }
-
-      auto newStartAddress =
-          newDataBuffer->asMutable<char>() + newDataBuffer->size();
-
-      if (size() != 0) {
-        std::memcpy(newStartAddress, data(), size());
-      }
-
-      setCapacity(newCapacity);
-      setData(newStartAddress);
-      buffer_ = newDataBuffer;
-    }
-
-    /// Has the semantics as std::string, except that it does not fill the
-    /// space[size(), newSize] with 0 but rather leaves it as is
-    void resize(size_t newSize) {
-      if (newSize <= size_) {
-        // shrinking
-        size_ = newSize;
-        return;
-      }
-
-      // newSize > size
-      if (newSize <= capacity_) {
-        size_ = newSize;
-      } else {
-        reserve(newSize);
-        resize(newSize);
-      }
-    }
-
-    /// Not called by the UDF Implementation. Should be called at the end to
-    /// finalize the allocation and the string writing.
-    void finalize() {
-      VELOX_CHECK(size() == 0 || data());
-
-      if (buffer_) {
-        buffer_->setSize(buffer_->size() + size());
-      }
-      mutableValues_[rowIndex_] = StringView(data(), size());
-      return;
-    }
-
-    vector_size_t rowIndex() const {
-      return rowIndex_;
-    }
-
-    StringView* mutableValues() const {
-      return mutableValues_;
-    }
-
-   private:
-    void setData(char* address) {
-      data_ = address;
-    }
-
-    void setSize(size_t newSize) {
-      size_ = newSize;
-    }
-
-    void setCapacity(size_t newCapacity) {
-      capacity_ = newCapacity;
-    }
-
-    /// Address to the start of the string
-    char* data_ = nullptr;
-
-    /// Size of the string in bytes
-    size_t size_ = 0;
-
-    /// The capacity of the string in bytes
-    size_t capacity_ = 0;
-
-    /// The buffer that the output string uses for its allocation set during
-    /// reserve() call.
-    Buffer* buffer_ = nullptr;
-
-    FlatVector<StringView>* vector_;
-
-    int32_t rowIndex_;
-
-    StringView* mutableValues_;
-  };
-
-  struct PointerType {
-    uint64_t* mutableNulls_;
-    StringWriter proxy_;
-
-    inline bool has_value() {
-      if constexpr (Config::mayReadNull_) {
-        return !bits::isBitNull(mutableNulls_, proxy_.rowIndex());
-      } else {
-        return true;
-      }
-    }
-
-    operator codegen::InputReferenceStringNullable const() {
-      static_assert(!Config::isWriter_);
-
-      if (!this->has_value()) {
-        return {};
-      }
-
-      return codegen::InputReferenceStringNullable{
-          InputReferenceString{proxy_.mutableValues()[proxy_.rowIndex()]}};
-    }
-
-    inline PointerType& operator=(const InputReferenceStringNullable& other) {
-      static_assert(Config::isWriter_);
-      if constexpr (!Config::mayWriteNull_) {
-        if constexpr (Config::intializedWithNullSet_) {
-          bits::setBit(mutableNulls_, proxy_.rowIndex(), !bits::kNull);
-        }
-        proxy_ = *other;
-
-      } else {
-        // may have null
-        if (other.has_value()) {
-          if constexpr (Config::intializedWithNullSet_) {
-            bits::setBit(mutableNulls_, proxy_.rowIndex(), !bits::kNull);
-          }
-          proxy_ = *other;
-
-        } else {
-          if constexpr (!Config::intializedWithNullSet_) {
-            bits::setBit(mutableNulls_, proxy_.rowIndex(), bits::kNull);
-          }
-        }
-      }
-
-      return *this;
-    }
-
-    inline PointerType& operator=(const ConstantStringNullable& other) {
-      static_assert(Config::isWriter_);
-      if constexpr (!Config::mayWriteNull_) {
-        if constexpr (Config::intializedWithNullSet_) {
-          bits::setBit(mutableNulls_, proxy_.rowIndex(), bits::kNotNull);
-        }
-        proxy_ = *other;
-
-      } else {
-        // may have null
-        if (other.has_value()) {
-          if constexpr (Config::intializedWithNullSet_) {
-            bits::setBit(mutableNulls_, proxy_.rowIndex(), bits::kNotNull);
-          }
-          proxy_ = *other;
-
-        } else {
-          if constexpr (!Config::intializedWithNullSet_) {
-            bits::setBit(mutableNulls_, proxy_.rowIndex(), bits::kNull);
-          }
-        }
-      }
-
-      return *this;
-    }
-
-    inline PointerType& operator=(const std::nullopt_t&) {
-      static_assert(Config::isWriter_);
-
-      if constexpr (!Config::intializedWithNullSet_) {
-        bits::setBit(mutableNulls_, proxy_.rowIndex(), bits::kNull);
-      }
-      return *this;
-    }
-
-    inline StringWriter& operator*() {
-      static_assert(Config::isWriter_);
-      if constexpr (Config::intializedWithNullSet_) {
-        bits::setBit(mutableNulls_, proxy_.rowIndex(), bits::kNotNull);
-      }
-      return proxy_;
-    }
-
-    inline const StringWriter& operator*() const {
-      static_assert(Config::isWriter_);
-      if constexpr (Config::intializedWithNullSet_) {
-        bits::setBit(mutableNulls_, proxy_.rowIndex(), bits::kNotNull);
-      }
-      return proxy_;
-    }
-  };
-
-  inline PointerType operator[](size_t rowIndex) {
-    return PointerType{
-        mutableRawNulls_, StringWriter(vector_, rowIndex, mutableRawValues_)};
-  }
-
- private:
-  uint64_t* mutableRawNulls_;
-  StringView* mutableRawValues_;
-  FlatVector<StringView>* vector_;
-};
-
-} // namespace codegen
-} // namespace velox
-} // namespace facebook
diff --git a/velox/experimental/codegen/vector_function/tests/CMakeLists.txt b/velox/experimental/codegen/vector_function/tests/CMakeLists.txt
deleted file mode 100644
index 7f75bec3e314d..0000000000000
--- a/velox/experimental/codegen/vector_function/tests/CMakeLists.txt
+++ /dev/null
@@ -1,59 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-add_executable(
-  velox_codegen_vector_function_test CodegenVectorFunctionTest.cpp
-                                     TempStringTest.cpp VectorReaderTest.cpp)
-add_test(velox_codegen_vector_function_test velox_codegen_vector_function_test)
-
-target_link_libraries(
-  velox_codegen_vector_function_test
-  velox_codegen_ast
-  velox_codegen_external_process
-  velox_exec
-  velox_dwio_dwrf_reader
-  velox_dwio_dwrf_writer
-  velox_dwio_common
-  velox_aggregates
-  velox_functions_lib
-  velox_functions_prestosql
-  velox_hive_connector
-  velox_core
-  velox_type
-  velox_serialization
-  velox_exec_test_lib
-  velox_functions_json
-  velox_vector
-  velox_memory
-  velox_dwio_common_exception
-  velox_dwio_common_test_utils
-  velox_presto_serializer
-  velox_transform_utils
-  ${ANTLR4_RUNTIME}
-  Boost::atomic
-  Boost::context
-  Boost::date_time
-  Boost::filesystem
-  Boost::program_options
-  Boost::regex
-  Boost::thread
-  Boost::system
-  gflags::gflags
-  gtest
-  gtest_main
-  Folly::folly
-  gflags::gflags
-  glog::glog
-  fmt::fmt
-  dl)
diff --git a/velox/experimental/codegen/vector_function/tests/CodegenVectorFunctionTest.cpp b/velox/experimental/codegen/vector_function/tests/CodegenVectorFunctionTest.cpp
deleted file mode 100644
index 847740df4ecca..0000000000000
--- a/velox/experimental/codegen/vector_function/tests/CodegenVectorFunctionTest.cpp
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Random.h>
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include "velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h" // NOLINT (CLANGTIDY  ) facebook-hte-InlineHeader
-#include "velox/experimental/codegen/vector_function/StringTypes.h"
-
-namespace facebook::velox::codegen {
-
-struct GeneratedVectorFunctionConfigDouble {
-  struct Generated1 {
-    using VeloxInputType = std::tuple<DoubleType, DoubleType>;
-    using VeloxOutputType = std::tuple<DoubleType>;
-    struct State {
-      TempsAllocator allocator;
-    } state;
-
-    template <typename IN, typename OUT>
-    void operator()(IN&& input, OUT&& output) {
-      std::get<0>(std::forward<OUT>(output)) =
-          *std::get<0>(std::forward<IN>(input)) +
-          *std::get<1>(std::forward<IN>(input));
-    }
-  };
-
-  struct Generated2 {
-    using VeloxInputType = std::tuple<DoubleType, DoubleType>;
-    using VeloxOutputType = std::tuple<DoubleType>;
-    struct State {
-      TempsAllocator allocator;
-    } state;
-
-    template <typename IN, typename OUT>
-    void operator()(IN&& input, OUT&& output) {
-      std::get<0>(std::forward<OUT>(output)) =
-          *std::get<0>(std::forward<IN>(input)) -
-          *std::get<1>(std::forward<IN>(input));
-    }
-  };
-  using Type1 =
-      std::tuple<Generated1, std::index_sequence<0, 1>, std::index_sequence<0>>;
-  using Type2 =
-      std::tuple<Generated2, std::index_sequence<0, 1>, std::index_sequence<1>>;
-
-  using GeneratedCodeClass = ConcatExpression<
-      false,
-      std::tuple<DoubleType, DoubleType>,
-      std::tuple<DoubleType, DoubleType>,
-      Type1,
-      Type2>;
-
-  static constexpr bool isDefaultNull = false;
-  static constexpr bool isDefaultNullStrict = false;
-};
-
-TEST(TestConcat, BasicConcatRow) {
-  GeneratedVectorFunctionConfigDouble::GeneratedCodeClass concat;
-  auto args =
-      std::make_tuple<std::optional<double>, std::optional<double>>(3, 4);
-  auto output = std::tuple<std::optional<double>, std::optional<double>>();
-  concat(args, output);
-  EXPECT_EQ(std::get<0>(output), *std::get<0>(args) + *std::get<1>(args));
-  EXPECT_EQ(std::get<1>(output), *std::get<0>(args) - *std::get<1>(args));
-}
-
-TEST(TestConcat, EvalConcatFunction) {
-  const size_t rowLength = 1000;
-  SelectivityVector rows(rowLength);
-  rows.setAll();
-
-  auto inRowType =
-      ROW({"a", "b"},
-          {std::make_shared<DoubleType>(), std::make_shared<DoubleType>()});
-  auto outRowType =
-      ROW({"pl", "mi"},
-          {std::make_shared<DoubleType>(), std::make_shared<DoubleType>()});
-  auto pool = memory::addDefaultLeafMemoryPool();
-  auto inRowVector = BaseVector::create(inRowType, rowLength, pool.get());
-  auto outRowVector = BaseVector::create(outRowType, rowLength, pool.get());
-
-  VectorPtr& in1 = inRowVector->as<RowVector>()->childAt(0);
-  VectorPtr& in2 = inRowVector->as<RowVector>()->childAt(1);
-
-  in1->resize(rowLength);
-  in2->resize(rowLength);
-  in1->addNulls(nullptr, rows);
-  in2->addNulls(nullptr, rows);
-
-  std::vector<VectorPtr> in{in1, in2};
-  auto queryCtx = std::make_shared<core::QueryCtx>();
-  auto execCtx = std::make_unique<core::ExecCtx>(pool.get(), queryCtx.get());
-  exec::EvalCtx context(execCtx.get(), nullptr, inRowVector->as<RowVector>());
-  GeneratedVectorFunction<GeneratedVectorFunctionConfigDouble> vectorFunction;
-
-  vectorFunction.setRowType(outRowType);
-
-  // Initializing vector data;
-  rows.applyToSelected([&](size_t row) {
-    in1->asFlatVector<double>()->set(row, (double)row);
-    in2->asFlatVector<double>()->set(row, 1.5 * (double)row);
-  });
-
-  vectorFunction.apply(rows, in, nullptr, &context, &outRowVector);
-
-  VectorPtr& out1 = outRowVector->as<RowVector>()->childAt(0);
-  VectorPtr& out2 = outRowVector->as<RowVector>()->childAt(1);
-
-  EXPECT_TRUE(rows.testSelected([&](size_t row) -> ::testing::AssertionResult {
-    if (out1->isNullAt(row)) {
-      return ::testing::AssertionResult(false) << "out1 is null at row " << row;
-    };
-
-    if (out2->isNullAt(row)) {
-      return ::testing::AssertionResult(false) << "out2 is null at row " << row;
-    };
-
-    if (out1->asFlatVector<double>()->valueAt(row) !=
-        in1->asFlatVector<double>()->valueAt(row) +
-            in2->asFlatVector<double>()->valueAt(row)) {
-      return ::testing::AssertionResult(false) << "Wrong value at  " << row;
-    };
-    return ::testing::AssertionResult(true);
-  }));
-}
-
-struct GeneratedVectorFunctionConfigBool {
-  struct BoolExpressionAnd {
-    using VeloxInputType = std::tuple<BooleanType, BooleanType>;
-    using VeloxOutputType = std::tuple<BooleanType>;
-    struct State {
-      TempsAllocator allocator;
-    } state;
-
-    template <typename IN, typename OUT>
-    void operator()(IN&& input, OUT&& output) {
-      std::get<0>(std::forward<OUT>(output)) =
-          *std::get<0>(std::forward<IN>(input)) &&
-          *std::get<1>(std::forward<IN>(input));
-    }
-  };
-
-  struct BoolExpressionOr {
-    using VeloxInputType = std::tuple<BooleanType, BooleanType>;
-    using VeloxOutputType = std::tuple<BooleanType>;
-    struct State {
-      TempsAllocator allocator;
-    } state;
-
-    template <typename IN, typename OUT>
-    void operator()(IN&& input, OUT&& output) {
-      std::get<0>(std::forward<OUT>(output)) =
-          *std::get<0>(std::forward<IN>(input)) ||
-          *std::get<1>(std::forward<IN>(input));
-    }
-  };
-  using Type1 = std::tuple<
-      BoolExpressionAnd,
-      std::index_sequence<0, 1>,
-      std::index_sequence<0>>;
-
-  using Type2 = std::tuple<
-      BoolExpressionOr,
-      std::index_sequence<0, 1>,
-      std::index_sequence<1>>;
-
-  using GeneratedCodeClass = ConcatExpression<
-      false,
-      std::tuple<BooleanType, BooleanType>,
-      std::tuple<BooleanType, BooleanType>,
-      Type1,
-      Type2>;
-
-  static constexpr bool isDefaultNull = false;
-  static constexpr bool isDefaultNullStrict = false;
-};
-
-TEST(TestBooEvalVectorFunction, EvalBoolExpression) {
-  // TODO: Move those to test class
-  auto pool = memory::addDefaultLeafMemoryPool();
-  const size_t vectorSize = 1000;
-  auto queryCtx = std::make_shared<core::QueryCtx>();
-  auto execCtx = std::make_unique<core::ExecCtx>(pool.get(), queryCtx.get());
-
-  auto inRowType =
-      ROW({"a", "b"},
-          {std::make_shared<BooleanType>(), std::make_shared<BooleanType>()});
-  auto outRowType =
-      ROW({"and1", "and2"},
-          {std::make_shared<BooleanType>(), std::make_shared<BooleanType>()});
-
-  // Initializing input vectors
-  auto inRowVector = BaseVector::create(inRowType, vectorSize, pool.get());
-  auto outRowVector = BaseVector::create(outRowType, vectorSize, pool.get());
-
-  VectorPtr& inputVector1 = inRowVector->as<RowVector>()->childAt(0);
-  VectorPtr& inputVector2 = inRowVector->as<RowVector>()->childAt(1);
-
-  inputVector1->resize(vectorSize);
-  inputVector2->resize(vectorSize);
-
-  for (auto i = 0; i < vectorSize; i++) {
-    inputVector1->asFlatVector<bool>()->setNull(i, false);
-    inputVector2->asFlatVector<bool>()->setNull(i, false);
-
-    inputVector1->asFlatVector<bool>()->setNull(i, folly::Random::rand32() % 2);
-    inputVector2->asFlatVector<bool>()->setNull(i, folly::Random::rand32() % 2);
-
-    inputVector1->asFlatVector<bool>()->set(i, folly::Random::rand32() % 2);
-    inputVector2->asFlatVector<bool>()->set(i, folly::Random::rand32() % 2);
-  }
-
-  SelectivityVector rows(vectorSize);
-  rows.setAll();
-  rows.resize(vectorSize);
-
-  GeneratedVectorFunction<GeneratedVectorFunctionConfigBool> vectorFunction;
-  vectorFunction.setRowType(outRowType);
-
-  // Eval
-  exec::EvalCtx context(execCtx.get(), nullptr, inRowVector->as<RowVector>());
-  std::vector<VectorPtr> inputs{inputVector1, inputVector2};
-  vectorFunction.apply(rows, inputs, nullptr, &context, &outRowVector);
-
-  auto* out1 = outRowVector->as<RowVector>()->childAt(0)->asFlatVector<bool>();
-  auto* out2 = outRowVector->as<RowVector>()->childAt(1)->asFlatVector<bool>();
-
-  auto in1Flat = inputVector1->asFlatVector<bool>();
-  auto in2Flat = inputVector2->asFlatVector<bool>();
-
-  for (auto i = 0; i < vectorSize; i++) {
-    ASSERT_EQ(out1->valueAt(i), in1Flat->valueAt(i) && in2Flat->valueAt(i));
-    ASSERT_EQ(out2->valueAt(i), in1Flat->valueAt(i) || in2Flat->valueAt(i));
-  }
-}
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/vector_function/tests/TARGETS_disabled b/velox/experimental/codegen/vector_function/tests/TARGETS_disabled
deleted file mode 100644
index af68e35715560..0000000000000
--- a/velox/experimental/codegen/vector_function/tests/TARGETS_disabled
+++ /dev/null
@@ -1,61 +0,0 @@
-load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
-
-cpp_unittest(
-    name = "velox_codegen_vector_function_test",
-    srcs = [
-        "CodegenVectorFunctionTest.cpp",
-    ],
-    headers = [
-    ],
-    deps = [
-        "//folly:random",
-        "//velox/experimental/codegen/vector_function:velox_codegen_string_types",
-        "//velox/experimental/codegen/vector_function:velox_codegen_vector_function",
-    ],
-    external_deps = [
-        "glog",
-    ],
-)
-
-cpp_unittest(
-    name = "velox_codegen_temp_string_test",
-    srcs = [
-        "TempStringTest.cpp",
-    ],
-    headers = [
-    ],
-    deps = [
-        "//velox/experimental/codegen/vector_function:velox_codegen_string_types",
-    ],
-    external_deps = [
-        "glog",
-    ],
-)
-
-cpp_unittest(
-    name = "velox_codegen_vector_reader_test",
-    srcs = [
-        "VectorReaderTest.cpp",
-    ],
-    deps = [
-        "//folly:random",
-        "//velox/experimental/codegen/vector_function:velox_codegen_string_types",
-        "//velox/experimental/codegen/vector_function:velox_codegen_vector_function",
-    ],
-    external_deps = [
-        "glog",
-    ],
-)
-
-cpp_unittest(
-    name = "velox_codegen_perf_test",
-    srcs = [
-        "veloxCodegenPerfTest.cpp",
-    ],
-    headers = [
-    ],
-    preprocessor_flags = ["-DCODEGEN_PERF"],
-    deps = [
-        "//velox/experimental/codegen/vector_function:velox_codegen_vector_function",
-    ],
-)
diff --git a/velox/experimental/codegen/vector_function/tests/TempStringTest.cpp b/velox/experimental/codegen/vector_function/tests/TempStringTest.cpp
deleted file mode 100644
index 22c0a071bb00a..0000000000000
--- a/velox/experimental/codegen/vector_function/tests/TempStringTest.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include <iostream>
-#include "velox/experimental/codegen/vector_function/StringTypes.h"
-namespace facebook::velox::codegen {
-class TempAllocatorTest : public testing::Test {};
-
-TEST_F(TempAllocatorTest, construction) {
-  TempsAllocator allocator;
-  TempStringNullable string1(allocator);
-  ASSERT_EQ(string1.has_value(), false);
-
-  TempStringNullable string2(std::in_place, allocator);
-  ASSERT_EQ(string2.has_value(), true);
-  ASSERT_EQ((*string2).size(), 0);
-}
-
-TEST_F(TempAllocatorTest, Assignment) {
-  auto checkNull = [](auto& str) { ASSERT_EQ(str.has_value(), false); };
-  auto refString = StringView("test-string");
-  auto checkValue = [&](auto& str) {
-    ASSERT_EQ(str.has_value(), true);
-    ASSERT_EQ(
-        std::string((*str).data(), (*str).size()),
-        std::string(refString.data(), refString.size()));
-  };
-  TempsAllocator allocator;
-  TempStringNullable string1(allocator);
-  checkNull(string1);
-
-  // Assignments to input ref
-  string1 = InputReferenceStringNullable{InputReferenceString(refString)};
-  checkValue(string1);
-
-  string1 = InputReferenceStringNullable{};
-  checkNull(string1);
-
-  string1 = TempStringNullable(std::in_place, allocator);
-  *string1 = InputReferenceString(refString);
-  checkValue(string1);
-
-  string1 = std::nullopt;
-  checkNull(string1);
-
-  // Assignments to const ref
-  string1 = ConstantStringNullable{ConstantString(refString)};
-  checkValue(string1);
-
-  string1 = ConstantStringNullable{};
-  checkNull(string1);
-
-  string1 = TempStringNullable(std::in_place, allocator);
-  *string1 = ConstantString(refString);
-  checkValue(string1);
-
-  TempStringNullable string2(allocator);
-  string2 = string1;
-  checkValue(string2);
-
-  string1 = std::nullopt;
-  string2 = string1;
-  checkNull(string1);
-
-  // UDF proxy interface
-  string1 = TempStringNullable(std::in_place, allocator);
-  (*string1).reserve(refString.size());
-  (*string1).resize(refString.size());
-  std::memcpy((*string1).data(), refString.data(), refString.size());
-  checkValue(string1);
-}
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/vector_function/tests/VectorReaderTest.cpp b/velox/experimental/codegen/vector_function/tests/VectorReaderTest.cpp
deleted file mode 100644
index c6f6fc19de0cd..0000000000000
--- a/velox/experimental/codegen/vector_function/tests/VectorReaderTest.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Random.h>
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-#include "velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h" // NOLINT (CLANGTIDY  )
-#include "velox/experimental/codegen/vector_function/StringTypes.h"
-
-namespace facebook::velox::codegen {
-TEST(VectorReader, ReadDoublesVectors) {
-  const size_t vectorSize = 1000;
-  auto inRowType = ROW({"columnA", "columnB"}, {DOUBLE(), DOUBLE()});
-  auto outRowType = ROW({"expr1", "expr2"}, {DOUBLE(), DOUBLE()});
-
-  auto pool = memory::addDefaultLeafMemoryPool();
-  auto inRowVector = BaseVector::create(inRowType, vectorSize, pool.get());
-  auto outRowVector = BaseVector::create(outRowType, vectorSize, pool.get());
-
-  VectorPtr& in1 = inRowVector->as<RowVector>()->childAt(0);
-
-  SelectivityVector selectivityVector(vectorSize);
-  selectivityVector.setAll();
-  in1->resize(vectorSize);
-  in1->addNulls(nullptr, selectivityVector);
-  VectorReader<DoubleType, OutputReaderConfig<false, false>> writer(in1);
-  VectorReader<DoubleType, InputReaderConfig<false, false>> reader(in1);
-
-  for (size_t row = 0; row < vectorSize; row++) {
-    writer[row] = (double)row;
-  }
-
-  for (size_t row = 0; row < vectorSize; row++) {
-    ASSERT_DOUBLE_EQ((double)row, *reader[row]);
-  }
-
-  for (size_t row = 0; row < vectorSize; row++) {
-    ASSERT_DOUBLE_EQ(*reader[row], in1->asFlatVector<double>()->valueAt(row));
-  }
-}
-
-TEST(VectorReader, ReadBoolVectors) {
-  // TODO: Move those to test class
-  auto pool = memory::addDefaultLeafMemoryPool();
-  const size_t vectorSize = 1000;
-
-  auto inRowType = ROW({"columnA", "columnB"}, {BOOLEAN(), BOOLEAN()});
-  auto outRowType = ROW({"expr1", "expr2"}, {BOOLEAN(), BOOLEAN()});
-
-  auto inRowVector = BaseVector::create(inRowType, vectorSize, pool.get());
-  auto outRowVector = BaseVector::create(outRowType, vectorSize, pool.get());
-
-  VectorPtr& inputVector = inRowVector->as<RowVector>()->childAt(0);
-  inputVector->resize(vectorSize);
-  VectorReader<BooleanType, InputReaderConfig<false, false>> reader(
-      inputVector);
-  VectorReader<BooleanType, OutputReaderConfig<false, false>> writer(
-      inputVector);
-
-  for (size_t row = 0; row < vectorSize; row++) {
-    writer[row] = row % 2 == 0;
-  }
-
-  // Check that writing of values to the reader was success
-  for (size_t row = 0; row < vectorSize; row++) {
-    ASSERT_DOUBLE_EQ((row % 2 == 0), *reader[row]);
-    ASSERT_DOUBLE_EQ(
-        (row % 2 == 0), inputVector->asFlatVector<bool>()->valueAt(row));
-  }
-
-  // Write a null at even indices
-  for (size_t row = 0; row < vectorSize; row++) {
-    if (row % 2) {
-      writer[row] = std::nullopt;
-    }
-  }
-
-  for (size_t row = 0; row < vectorSize; row++) {
-    ASSERT_EQ(inputVector->asFlatVector<bool>()->isNullAt(row), row % 2);
-  }
-}
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/codegen/vector_function/tests/veloxCodegenPerfTest.cpp b/velox/experimental/codegen/vector_function/tests/veloxCodegenPerfTest.cpp
deleted file mode 100644
index 45b5552f02939..0000000000000
--- a/velox/experimental/codegen/vector_function/tests/veloxCodegenPerfTest.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-#include "velox/experimental/codegen/vector_function/Perf.h"
-
-using namespace ::testing;
-
-namespace facebook::velox::codegen {
-/*@mode/dev-sand
-branch instructions: 3012
-branch misses: 7
-cpu clock: 6862
-task clock: 4513
-@mode/opt
-branch instructions: 6
-branch misses: 2
-cpu clock: 4307
-task clock: 1956
-*/
-TEST(PerfTest, TestLoop) {
-  Perf p;
-  for (int i = 0; i < 1000; i++) {
-    /// do nothing, without optimization, each loop contains 3 branches
-    /// (according to godbolt.org with x86-clang++ 12.0.1), with optimization
-    /// this whole thing disappears
-  }
-}
-} // namespace facebook::velox::codegen
diff --git a/velox/experimental/gpu/tests/BlockingQueueTest.cu b/velox/experimental/gpu/tests/BlockingQueueTest.cu
index e15354f29aeef..e655180c35f25 100644
--- a/velox/experimental/gpu/tests/BlockingQueueTest.cu
+++ b/velox/experimental/gpu/tests/BlockingQueueTest.cu
@@ -198,7 +198,9 @@ __global__ void runGpu2Gpu(
     cuda::atomic<int64_t, cuda::thread_scope_device>& nextId,
     int capacity,
     int limit) {
-  __shared__ struct { int64_t message; } shared;
+  __shared__ struct {
+    int64_t message;
+  } shared;
   if (blockIdx.x == 0) {
     nextId = 0;
     for (int i = 0; i < capacity; ++i) {
@@ -281,7 +283,7 @@ void runKernelLaunches() {
 
 int main(int argc, char** argv) {
   using namespace facebook::velox::gpu;
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   checkDeviceProperties();
   runCpuGpuPingPong();
   printf("\n");
diff --git a/velox/experimental/gpu/tests/CMakeLists.txt b/velox/experimental/gpu/tests/CMakeLists.txt
index 8eaca86e7b959..d4a6a37f67761 100644
--- a/velox/experimental/gpu/tests/CMakeLists.txt
+++ b/velox/experimental/gpu/tests/CMakeLists.txt
@@ -13,6 +13,5 @@
 # limitations under the License.
 
 add_executable(velox_gpu_hash_table_test HashTableTest.cu)
-target_link_libraries(velox_gpu_hash_table_test Folly::folly gflags::gflags)
-set_target_properties(velox_gpu_hash_table_test PROPERTIES CUDA_ARCHITECTURES
-                                                           native)
+target_link_libraries(
+  velox_gpu_hash_table_test Folly::folly gflags::gflags)
diff --git a/velox/experimental/gpu/tests/DependencyWatchTest.cu b/velox/experimental/gpu/tests/DependencyWatchTest.cu
index f605436d55ce3..31fd8c5363329 100644
--- a/velox/experimental/gpu/tests/DependencyWatchTest.cu
+++ b/velox/experimental/gpu/tests/DependencyWatchTest.cu
@@ -97,7 +97,7 @@ void schedule(Node* nodes, int size, States* states) {
 
 int main(int argc, char** argv) {
   using namespace facebook::velox::gpu;
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   Node* nodes;
   CUDA_CHECK_FATAL(cudaMallocManaged(&nodes, FLAGS_node_count * sizeof(Node)));
   for (int i = 0; i < FLAGS_node_count; ++i) {
diff --git a/velox/experimental/gpu/tests/DoubleBufferProcessTest.cu b/velox/experimental/gpu/tests/DoubleBufferProcessTest.cu
index c1005c533108b..79070fb4ea188 100644
--- a/velox/experimental/gpu/tests/DoubleBufferProcessTest.cu
+++ b/velox/experimental/gpu/tests/DoubleBufferProcessTest.cu
@@ -197,7 +197,7 @@ void testCudaEvent(int deviceId) {
 
 int main(int argc, char** argv) {
   using namespace facebook::velox::gpu;
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   int deviceCount;
   CUDA_CHECK_FATAL(cudaGetDeviceCount(&deviceCount));
   printf("Device count: %d\n", deviceCount);
diff --git a/velox/experimental/gpu/tests/HashTableTest.cu b/velox/experimental/gpu/tests/HashTableTest.cu
index e45bb61d2b203..6de1378d93a6e 100644
--- a/velox/experimental/gpu/tests/HashTableTest.cu
+++ b/velox/experimental/gpu/tests/HashTableTest.cu
@@ -35,7 +35,7 @@ namespace {
 
 constexpr int kBlockSize = 256;
 
-__device__ uint32_t jenkinsRevMix32(uint32_t key) {
+[[maybe_unused]] __device__ uint32_t jenkinsRevMix32(uint32_t key) {
   key += (key << 12); // key *= (1 + (1 << 12))
   key ^= (key >> 22);
   key += (key << 4); // key *= (1 + (1 << 4))
@@ -298,7 +298,7 @@ __global__ void probe<true>(
       j = (j + sizeof(uint32_t)) & tableSizeMask;
       cmpMask = 0xffffffff;
     }
-  end:
+  end:;
   }
 }
 
@@ -627,7 +627,7 @@ __global__ void probePartitioned<true>(
       j = (j + sizeof(uint32_t)) & tableSizeMask;
       cmpMask = 0xffffffff;
     }
-  end:
+  end:;
   }
 }
 
@@ -745,7 +745,7 @@ void runPartitioned() {
 
 int main(int argc, char** argv) {
   using namespace facebook::velox::gpu;
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   assert(__builtin_popcount(FLAGS_table_size) == 1);
   assert(FLAGS_table_size % kBlockSize == 0);
   CUDA_CHECK_FATAL(cudaSetDevice(FLAGS_device));
diff --git a/velox/experimental/wave/CMakeLists.txt b/velox/experimental/wave/CMakeLists.txt
index 709bed6bdfccf..e8e4625201ceb 100644
--- a/velox/experimental/wave/CMakeLists.txt
+++ b/velox/experimental/wave/CMakeLists.txt
@@ -15,3 +15,4 @@
 add_subdirectory(common)
 add_subdirectory(exec)
 add_subdirectory(vector)
+add_subdirectory(dwio)
diff --git a/velox/experimental/wave/common/Bits.cuh b/velox/experimental/wave/common/Bits.cuh
new file mode 100644
index 0000000000000..50987167054c6
--- /dev/null
+++ b/velox/experimental/wave/common/Bits.cuh
@@ -0,0 +1,437 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <cub/warp/warp_scan.cuh>
+#include "velox/experimental/wave/common/Block.cuh"
+#include "velox/experimental/wave/common/CudaUtil.cuh"
+
+namespace facebook::velox::wave {
+
+template <typename T, typename U>
+inline void __device__ __host__ setBit(T* bits, U index, bool bit = true) {
+  constexpr int32_t kShift = sizeof(T) == 1 ? 3
+      : sizeof(T) == 2                      ? 4
+      : sizeof(T) == 4                      ? 5
+      : sizeof(T) == 8                      ? 6
+                                            : 0;
+  constexpr U kMask = (static_cast<U>(1) << kShift) - 1;
+  if (bit == true) {
+    bits[index >> kShift] |= static_cast<T>(1) << (index & kMask);
+  } else {
+    bits[index >> kShift] &= (static_cast<T>(1) << ~(index & kMask));
+  }
+}
+
+template <typename T, typename U>
+inline bool __device__ isBitSet(T* bits, U index) {
+  constexpr int32_t kShift = sizeof(T) == 1 ? 3
+      : sizeof(T) == 2                      ? 4
+      : sizeof(T) == 4                      ? 5
+      : sizeof(T) == 8                      ? 6
+                                            : 0;
+  constexpr U kMask = (static_cast<U>(1) << kShift) - 1;
+  return (bits[index >> kShift] & (static_cast<T>(1) << (index & kMask))) != 0;
+}
+
+// From libcudf
+inline __device__ uint32_t unalignedLoad32(void const* p) {
+  uint32_t ofs = 3 & reinterpret_cast<uintptr_t>(p);
+  auto const* p32 =
+      reinterpret_cast<uint32_t const*>(reinterpret_cast<uintptr_t>(p) - ofs);
+  uint32_t v = p32[0];
+  return (ofs) ? __funnelshift_r(v, p32[1], ofs * 8) : v;
+}
+
+/// From libcudf
+inline __device__ uint64_t unalignedLoad64(void const* p) {
+  uint32_t ofs = 3 & reinterpret_cast<uintptr_t>(p);
+  auto const* p32 =
+      reinterpret_cast<uint32_t const*>(reinterpret_cast<uintptr_t>(p) - ofs);
+  uint32_t v0 = p32[0];
+  uint32_t v1 = p32[1];
+  if (ofs) {
+    v0 = __funnelshift_r(v0, v1, ofs * 8);
+    v1 = __funnelshift_r(v1, p32[2], ofs * 8);
+  }
+  return (((uint64_t)v1) << 32) | v0;
+}
+
+// Loads uint32 at bit offset 'bits' from 'p' at 'width' bits.
+inline __device__ uint32_t
+loadBits32(void const* p, uint32_t bitIdx, int32_t width) {
+  uint32_t bytes = bitIdx / 8;
+  uint32_t bit = bitIdx & 7;
+  auto uptr = reinterpret_cast<uintptr_t>(p) + bytes;
+  uint32_t ofs = 3 & uptr;
+  bit += ofs * 8;
+  auto const* p32 = reinterpret_cast<uint32_t const*>(uptr - ofs);
+  uint32_t v = p32[0];
+  uint32_t mask = lowMask<uint32_t>(width);
+  if (bit + width <= 32) {
+    return (v >> (bit)) & mask;
+  }
+  return (__funnelshift_r(v, p32[1], bit)) & mask;
+}
+
+inline __device__ uint64_t
+loadBits64(void const* p, uint32_t bitIdx, uint32_t width) {
+  uint32_t bytes = bitIdx / 8;
+  uint32_t bit = bitIdx & 7;
+  auto uptr = reinterpret_cast<uintptr_t>(p) + bytes;
+  uint32_t ofs = (3 & uptr);
+  auto const* p32 = reinterpret_cast<uint32_t const*>(uptr - ofs);
+  bit += ofs * 8;
+  uint32_t v0 = p32[0];
+  uint32_t v1 = p32[1];
+  if (bit) {
+    v0 = __funnelshift_r(v0, v1, bit);
+    v1 = __funnelshift_r(v1, (width + bit > 64 ? p32[2] : 0), bit);
+  }
+  return (static_cast<uint64_t>(v1 & lowMask<uint32_t>(width - 32)) << 32) | v0;
+}
+
+/// Sets 'bits', 'begin' and 'end' so that 'bits' is aligned at 8.
+inline __device__ void alignBits(uint64_t* bits, int32_t& begin, int32_t& end) {
+  int32_t align = 7 & reinterpret_cast<uintptr_t>(bits);
+  if (align) {
+    bits = addBytes(bits, -align);
+    begin += align * 8;
+    end += align * 8;
+  }
+}
+
+inline __device__ void
+alignBits(const uint64_t* bits, int32_t& begin, int32_t& end) {
+  int32_t align = 7 & reinterpret_cast<uintptr_t>(bits);
+  if (align) {
+    bits = addBytes(bits, -align);
+    begin += align * 8;
+    end += align * 8;
+  }
+}
+
+/**
+ * Invokes a function for each batch of bits (partial or full words)
+ * in a given range.
+ *
+ * @param begin first bit to check (inclusive)
+ * @param end last bit to check (exclusive)
+ * @param partialWordFunc function to invoke for a partial word;
+ *  takes index of the word and mask
+ * @param fullWordFunc function to invoke for a full word;
+ *  takes index of the word
+ */
+template <typename PartialWordFunc, typename FullWordFunc>
+inline __device__ void forEachWord(
+    int32_t begin,
+    int32_t end,
+    PartialWordFunc partialWordFunc,
+    FullWordFunc fullWordFunc) {
+  if (begin >= end) {
+    return;
+  }
+  int32_t firstWord = roundUp(begin, 64);
+  int32_t lastWord = end & ~63L;
+  if (lastWord < firstWord) {
+    partialWordFunc(
+        lastWord / 64,
+        lowMask<uint64_t>(end - lastWord) &
+            highMask<uint64_t>(firstWord - begin));
+    return;
+  }
+  if (begin != firstWord) {
+    partialWordFunc(begin / 64, highMask<uint64_t>(firstWord - begin));
+  }
+  for (int32_t i = firstWord; i + 64 <= lastWord; i += 64) {
+    fullWordFunc(i / 64);
+  }
+  if (end != lastWord) {
+    partialWordFunc(lastWord / 64, lowMask<uint64_t>(end - lastWord));
+  }
+}
+
+///
+inline int32_t __device__
+countBits(const uint64_t* bits, int32_t begin, int32_t end) {
+  int32_t numBits = end - begin;
+  if (numBits == 0) {
+    return 0;
+  }
+  if (numBits <= 32) {
+    return __popc(loadBits32(bits, begin, numBits));
+  }
+  int32_t count = 0;
+  alignBits(bits, begin, end);
+  forEachWord(
+      begin,
+      end,
+      [&count, bits](int32_t idx, uint64_t mask) {
+        count += __popcll(bits[idx] & mask);
+      },
+      [&count, bits](int32_t idx) { count += __popcll(bits[idx]); });
+  return count;
+}
+
+inline int32_t __device__ __host__ scatterBitsDeviceSize(int32_t blockSize) {
+  // One int32 per warp + two int32_t.
+  return sizeof(int32_t) * (2 + (blockSize / 32));
+}
+
+namespace detail {
+__device__ inline uint32_t
+scatterInWord(uint32_t mask, const uint32_t* source, int32_t& sourceBit) {
+  auto result = mask;
+  auto sourceWord = source[sourceBit / 32];
+  int32_t sourceMask = 1 << (sourceBit & 31);
+  auto nextMask = mask;
+  while (nextMask) {
+    if ((sourceWord & sourceMask) == 0) {
+      auto lowBit = __ffs(nextMask) - 1;
+      result = result & ~(1 << lowBit);
+    }
+    ++sourceBit;
+    if ((sourceBit & 31) == 0) {
+      sourceWord = source[sourceBit / 32];
+      sourceMask = 1;
+    } else {
+      sourceMask = sourceMask << 1;
+    }
+    nextMask &= nextMask - 1;
+  }
+  return result;
+}
+
+inline __device__ int32_t* warpBase(int32_t* smem) {
+  constexpr int32_t kWarpThreads = 32;
+  return smem + (threadIdx.x / kWarpThreads);
+}
+
+inline __device__ auto* warpScanTemp(void* smem) {
+  // The temp storage is empty. Nothing is written. Return base of smem.
+  return reinterpret_cast<typename cub::WarpScan<uint32_t>::TempStorage*>(smem);
+}
+} // namespace detail
+
+/// Sets 'target' so that a 0 bit in 'mask' is 0 and a 1 bit in 'mask' is the
+/// nth bit in 'source', where nth is the number of set bits in 'mask' below th
+/// target bit. 'mask' and 'target' must be 8 byte aligned. 'source' needs no
+/// alignment but the partial int32-s at either end must be addressable.
+template <int32_t kWordsPerThread>
+__device__ void scatterBitsDevice(
+    int32_t numSource,
+    int32_t numTarget,
+    const char* source,
+    const uint64_t* targetMask,
+    char* target,
+    int32_t* smem) {
+  using Scan32 = cub::WarpScan<uint32_t>;
+  constexpr int32_t kWarpThreads = 32;
+  int32_t align = reinterpret_cast<uintptr_t>(source) & 3;
+  source -= align;
+  int32_t sourceBitBase = align * 8;
+  for (auto targetIdx = 0; targetIdx * 64 < numTarget;
+       targetIdx += blockDim.x * kWordsPerThread) {
+    int32_t firstTargetIdx = targetIdx + threadIdx.x * kWordsPerThread;
+    int32_t bitsForThread =
+        min(kWordsPerThread * 64, numTarget - firstTargetIdx * 64);
+    uint32_t count = 0;
+    for (auto bit = 0; bit < bitsForThread; bit += 64) {
+      if (bit + 64 <= bitsForThread) {
+        count += __popcll(targetMask[firstTargetIdx + (bit / 64)]);
+      } else {
+        auto mask = lowMask<uint64_t>(bitsForThread - bit);
+        count += __popcll(targetMask[firstTargetIdx + (bit / 64)] & mask);
+        break;
+      }
+    }
+    uint32_t threadFirstBit = 0;
+    Scan32(*detail::warpScanTemp(smem)).ExclusiveSum(count, threadFirstBit);
+    if ((threadIdx.x & (kWarpThreads - 1)) == kWarpThreads - 1) {
+      // Last thread in warp sets warpBase to warp bit count.
+      *detail::warpBase(smem) = threadFirstBit + count;
+    }
+
+    __syncthreads();
+    if (threadIdx.x < kWarpThreads) {
+      uint32_t start =
+          (threadIdx.x < blockDim.x / kWarpThreads) ? smem[threadIdx.x] : 0;
+      Scan32(*detail::warpScanTemp(smem)).ExclusiveSum(start, start);
+      if (threadIdx.x == (blockDim.x / kWarpThreads) - 1) {
+        // The last thread records total sum of bits in smem[blockDim.x / 32].
+        smem[blockDim.x / kWarpThreads] =
+            start + smem[(blockDim.x / kWarpThreads) - 1];
+      }
+      if (threadIdx.x < blockDim.x / kWarpThreads) {
+        smem[threadIdx.x] = start;
+      }
+    }
+    __syncthreads();
+    // Each thread knows its range in source and target.
+    int32_t sourceBit =
+        sourceBitBase + *detail::warpBase(smem) + threadFirstBit;
+    for (auto bit = 0; bit < bitsForThread; bit += 64) {
+      uint64_t maskWord;
+      if (bit + 64 <= bitsForThread) {
+        maskWord = targetMask[firstTargetIdx + (bit / 64)];
+      } else {
+        auto mask = lowMask<uint64_t>(bitsForThread - bit);
+        maskWord = targetMask[firstTargetIdx + (bit / 64)] & mask;
+      }
+      int2 result;
+      result.x = detail::scatterInWord(
+          static_cast<uint32_t>(maskWord),
+          reinterpret_cast<const uint32_t*>(source),
+          sourceBit);
+      result.y = detail::scatterInWord(
+          maskWord >> 32, reinterpret_cast<const uint32_t*>(source), sourceBit);
+      reinterpret_cast<int2*>(target)[firstTargetIdx + (bit / 64)] = result;
+    }
+    // All threads increment the count of consumed source bits from smem.
+    sourceBitBase += smem[blockDim.x / kWarpThreads];
+  }
+}
+
+/// True if rows[i...last-1] are all consecutive.
+inline __device__ bool isDense(const int32_t* rows, int32_t i, int32_t last) {
+  return rows[last - 1] - rows[i] == last - i - 1;
+}
+
+struct NonNullState {
+  /// Number of nulls below 'nonNullsBeloRow'.
+  int32_t nonNullsBelow;
+  /// First row not included in the count in 'nonNullsBelow'.
+  int32_t nonNullsBelowRow;
+  int32_t temp[256 / kWarpThreads];
+};
+
+/// Identifies threads that have a non-null value in a 256 thread
+/// block. Consecutive threads process consecutive values. If the thread falls
+/// on a null, -1 is returned, else the ordinal of the non-null corresponding to
+/// the thread. Must be called on all threads of the TB. 'nonNullOffset' is
+/// added to the returned index. 'nonNullOffset' is incremented by the number of
+/// non-null rows in this set of 256 rows if numRows == 256. This can be called
+/// on a loop where each iteration processes 256 consecutive rows and
+/// nonNullOffset c carries the offset between iterations.
+inline __device__ int32_t nonNullIndex256(
+    char* nulls,
+    int32_t bitOffset,
+    int32_t numRows,
+    NonNullState* state) {
+  if (threadIdx.x == 0) {
+    state->nonNullsBelow += countBits(
+        reinterpret_cast<uint64_t*>(nulls), state->nonNullsBelowRow, bitOffset);
+    state->nonNullsBelowRow = bitOffset;
+  }
+  __syncthreads();
+  int32_t group = threadIdx.x / 32;
+  uint32_t bits =
+      threadIdx.x < numRows ? loadBits32(nulls, bitOffset + group * 32, 32) : 0;
+  if (threadIdx.x == kWarpThreads * group) {
+    state->temp[group] = __popc(bits);
+  }
+  auto previousOffset = state->nonNullsBelow;
+  __syncthreads();
+  if (threadIdx.x < kWarpThreads) {
+    using Scan = cub::WarpScan<uint32_t, 8>;
+    uint32_t count = threadIdx.x < (blockDim.x / kWarpThreads)
+        ? state->temp[threadIdx.x]
+        : 0;
+    uint32_t start;
+    Scan(*reinterpret_cast<Scan::TempStorage*>(state->temp))
+        .ExclusiveSum(count, start);
+    if (threadIdx.x < blockDim.x / kWarpThreads) {
+      state->temp[threadIdx.x] = start;
+      if (threadIdx.x == (blockDim.x / kWarpThreads) - 1 && numRows == 256) {
+        state->nonNullsBelow += start + count;
+        state->nonNullsBelowRow = bitOffset + numRows;
+      }
+    }
+  }
+  __syncthreads();
+  if (bits & (1 << (threadIdx.x & 31))) {
+    return state->temp[group] + previousOffset +
+        __popc(bits & lowMask<uint32_t>(threadIdx.x & 31));
+  } else {
+    return -1;
+  }
+}
+
+/// Like nonNullIndex256 but takes an array of non-contiguous but
+/// ascending row numbers. 'nulls' must have enough valid bits to
+/// cover rows[numRows-1] bits. Each thread returns -1 if
+/// rows[threadIdx.x] falls on a null and the corresponding index in
+/// non-null rows otherwise. This can be called multiple times on
+/// consecutive groups of 256 row numbers. the non-null offset of the
+/// last row is carried in 'non-nulloffset'. 'rowOffset' is the offset
+/// of the first row of the batch of 256 in 'rows', so it has 0, 256,
+/// 512.. in consecutive calls. if 'rowOffset' is negative, -rowOffset
+/// gives the row to which '*nonNullOffset' refers, so the first
+/// non-'nonNullsBelow' is the non-nulls from -rowOffset to 'rows[0]'.
+inline __device__ int32_t nonNullIndex256Sparse(
+    char* nulls,
+    int32_t* rows,
+    int32_t numRows,
+    NonNullState* state) {
+  using Scan32 = cub::WarpScan<uint32_t>;
+  bool isNull = true;
+  uint32_t nonNullsBelow = 0;
+  if (threadIdx.x < numRows) {
+    isNull = !isBitSet(nulls, rows[threadIdx.x]);
+    nonNullsBelow = !isNull;
+    int32_t previousRow =
+        threadIdx.x == 0 ? state->nonNullsBelowRow : rows[threadIdx.x - 1] + 1;
+    nonNullsBelow += countBits(
+        reinterpret_cast<uint64_t*>(nulls), previousRow, rows[threadIdx.x]);
+  }
+  Scan32(*detail::warpScanTemp(state->temp))
+      .InclusiveSum(nonNullsBelow, nonNullsBelow);
+  int32_t previousOffset = state->nonNullsBelow;
+  if (detail::isLastInWarp()) {
+    // The last thread of the warp writes warp total.
+    state->temp[threadIdx.x / kWarpThreads] = nonNullsBelow;
+  }
+  __syncthreads();
+  if (threadIdx.x < kWarpThreads) {
+    int32_t start = 0;
+    if (threadIdx.x < blockDim.x / kWarpThreads) {
+      start = state->temp[threadIdx.x];
+    }
+    using Scan8 = cub::WarpScan<int32_t, 8>;
+    int32_t sum = 0;
+    Scan8(*reinterpret_cast<Scan8::TempStorage*>(state->temp))
+        .ExclusiveSum(start, sum);
+    if (threadIdx.x == (blockDim.x / kWarpThreads) - 1) {
+      // The last sum thread increments the running count of non-nulls
+      // by the block total.
+      state->nonNullsBelow += start + sum;
+      state->nonNullsBelowRow = rows[numRows - 1] + 1;
+    }
+    if (threadIdx.x < blockDim.x / kWarpThreads) {
+      state->temp[threadIdx.x] = sum;
+    }
+  }
+  __syncthreads();
+  if (isNull) {
+    return -1;
+  }
+  return state->temp[threadIdx.x / kWarpThreads] + previousOffset +
+      nonNullsBelow - 1;
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/Block.cuh b/velox/experimental/wave/common/Block.cuh
index 1ab27fcc265b9..55052681e546b 100644
--- a/velox/experimental/wave/common/Block.cuh
+++ b/velox/experimental/wave/common/Block.cuh
@@ -16,39 +16,98 @@
 
 #pragma once
 
+#include <cub/block/block_radix_sort.cuh>
 #include <cub/block/block_reduce.cuh>
 #include <cub/block/block_scan.cuh>
+#include <cub/block/block_store.cuh>
+#include "velox/experimental/wave/common/CudaUtil.cuh"
 
 /// Utilities for  booleans and indices and thread blocks.
 
 namespace facebook::velox::wave {
 
+/// Converts an array of flags to an array of indices of set flags. The first
+/// index is given by 'start'. The number of indices is returned in 'size', i.e.
+/// this is 1 + the index of the last set flag.
 template <
+    typename T,
     int32_t blockSize,
+    cub::BlockScanAlgorithm Algorithm = cub::BLOCK_SCAN_RAKING>
+inline int32_t __device__ __host__ boolToIndicesSharedSize() {
+  typedef cub::BlockScan<T, blockSize, Algorithm> BlockScanT;
+
+  return sizeof(typename BlockScanT::TempStorage);
+}
+
+/// Converts an array of flags to an array of indices of set flags. The first
+/// index is given by 'start'. The number of indices is returned in 'size', i.e.
+/// this is 1 + the index of the last set flag.
+template <
+    int32_t blockSize,
+    typename T,
     cub::BlockScanAlgorithm Algorithm = cub::BLOCK_SCAN_RAKING,
     typename Getter>
-__device__ inline void boolBlockToIndices(
-    Getter getter,
-    int32_t start,
-    int32_t* indices,
-    void* shmem,
-    int32_t& size) {
-  typedef cub::BlockScan<int, blockSize, Algorithm> BlockScanT;
+__device__ inline void
+boolBlockToIndices(Getter getter, T start, T* indices, void* shmem, T& size) {
+  typedef cub::BlockScan<T, blockSize, Algorithm> BlockScanT;
 
   auto* temp = reinterpret_cast<typename BlockScanT::TempStorage*>(shmem);
-  int data[1];
+  T data[1];
   uint8_t flag = getter();
   data[0] = flag;
   __syncthreads();
-  int aggregate;
+  T aggregate;
   BlockScanT(*temp).ExclusiveSum(data, data, aggregate);
-  __syncthreads();
   if (flag) {
     indices[data[0]] = threadIdx.x + start;
   }
   if (threadIdx.x == 0) {
     size = aggregate;
   }
+  __syncthreads();
+}
+
+inline int32_t __device__ __host__ bool256ToIndicesSize() {
+  return sizeof(typename cub::WarpScan<uint16_t>::TempStorage) +
+      33 * sizeof(uint16_t);
+}
+
+constexpr int32_t kWarpThreads = 1 << CUB_LOG_WARP_THREADS(0);
+
+/// Returns indices of set bits for 256 one byte flags. 'getter8' is
+/// invoked for 8 flags at a time, with the ordinal of the 8 byte
+/// flags word as argument, so that an index of 1 means flags
+/// 8..15. The indices start at 'start' and last index + 1 is
+/// returned in 'size'.
+template <typename T, typename Getter8>
+__device__ inline void
+bool256ToIndices(Getter8 getter8, T start, T* indices, T& size, char* smem) {
+  using Scan = cub::WarpScan<uint16_t>;
+  auto* smem16 = reinterpret_cast<uint16_t*>(smem);
+  int32_t group = threadIdx.x / 8;
+  uint64_t bits = getter8(group) & 0x0101010101010101;
+  if ((threadIdx.x & 7) == 0) {
+    smem16[group] = __popcll(bits);
+  }
+  __syncthreads();
+  if (threadIdx.x < 32) {
+    auto* temp = reinterpret_cast<typename Scan::TempStorage*>((smem + 72));
+    uint16_t data = smem16[threadIdx.x];
+    uint16_t result;
+    Scan(*temp).ExclusiveSum(data, result);
+    smem16[threadIdx.x] = result;
+    if (threadIdx.x == 31) {
+      size = data + result;
+    }
+  }
+  __syncthreads();
+  int32_t tidInGroup = threadIdx.x & 7;
+  if (bits & (1UL << (tidInGroup * 8))) {
+    int32_t base =
+        smem16[group] + __popcll(bits & lowMask<uint64_t>(tidInGroup * 8));
+    indices[base] = threadIdx.x + start;
+  }
+  __syncthreads();
 }
 
 template <int32_t blockSize, typename T, typename Getter>
@@ -65,4 +124,249 @@ __device__ inline void blockSum(Getter getter, void* shmem, T* result) {
   }
 }
 
+template <
+    int32_t kBlockSize,
+    int32_t kItemsPerThread,
+    typename Key,
+    typename Value>
+using RadixSort =
+    typename cub::BlockRadixSort<Key, kBlockSize, kItemsPerThread, Value>;
+
+template <
+    int32_t kBlockSize,
+    int32_t kItemsPerThread,
+    typename Key,
+    typename Value>
+inline int32_t __host__ __device__ blockSortSharedSize() {
+  return sizeof(
+      typename RadixSort<kBlockSize, kItemsPerThread, Key, Value>::TempStorage);
+}
+
+template <
+    int32_t kBlockSize,
+    int32_t kItemsPerThread,
+    typename Key,
+    typename Value,
+    typename KeyGetter,
+    typename ValueGetter>
+void __device__ blockSort(
+    KeyGetter keyGetter,
+    ValueGetter valueGetter,
+    Key* keyOut,
+    Value* valueOut,
+    char* smem) {
+  using Sort = cub::BlockRadixSort<Key, kBlockSize, kItemsPerThread, Value>;
+
+  // Per-thread tile items
+  Key keys[kItemsPerThread];
+  Value values[kItemsPerThread];
+
+  // Our current block's offset
+  int blockOffset = 0;
+
+  // Load items into a blocked arrangement
+  for (auto i = 0; i < kItemsPerThread; ++i) {
+    int32_t idx = blockOffset + i * kBlockSize + threadIdx.x;
+    values[i] = valueGetter(idx);
+    keys[i] = keyGetter(idx);
+  }
+
+  __syncthreads();
+  auto* temp_storage = reinterpret_cast<typename Sort::TempStorage*>(smem);
+
+  Sort(*temp_storage).SortBlockedToStriped(keys, values);
+
+  // Store output in striped fashion
+  cub::StoreDirectStriped<kBlockSize>(
+      threadIdx.x, valueOut + blockOffset, values);
+  cub::StoreDirectStriped<kBlockSize>(threadIdx.x, keyOut + blockOffset, keys);
+  __syncthreads();
+}
+
+template <int kBlockSize>
+int32_t partitionRowsSharedSize(int32_t numPartitions) {
+  using Scan = cub::BlockScan<int, kBlockSize>;
+  auto scanSize = sizeof(typename Scan::TempStorage) + sizeof(int32_t);
+  int32_t counterSize = sizeof(int32_t) * numPartitions;
+  if (counterSize <= scanSize) {
+    return scanSize;
+  }
+  static_assert(
+      sizeof(typename Scan::TempStorage) >= sizeof(int32_t) * kBlockSize);
+  return scanSize + counterSize; // - kBlockSize * sizeof(int32_t);
+}
+
+/// Partitions a sequence of indices into runs where the indices
+/// belonging to the same partition are contiguous. Indices from 0 to
+/// 'numKeys-1' are partitioned into 'partitionedRows', which must
+/// have space for 'numKeys' row numbers. The 0-based partition number
+/// for row 'i' is given by 'getter(i)'.  The row numbers for
+/// partition 0 start at 0. The row numbers for partition i start at
+/// 'partitionStarts[i-1]'. There must be at least the amount of
+/// shared memory given by partitionSharedSize(numPartitions).
+/// 'ranks' is a temporary array of 'numKeys' elements.
+template <int32_t kBlockSize, typename RowNumber, typename Getter>
+void __device__ partitionRows(
+    Getter getter,
+    uint32_t numKeys,
+    uint32_t numPartitions,
+    RowNumber* ranks,
+    RowNumber* partitionStarts,
+    RowNumber* partitionedRows) {
+  using Scan = cub::BlockScan<int32_t, kBlockSize>;
+  constexpr int32_t kWarpThreads = 1 << CUB_LOG_WARP_THREADS(0);
+  auto warp = threadIdx.x / kWarpThreads;
+  auto lane = cub::LaneId();
+  extern __shared__ __align__(16) char smem[];
+  auto* counters = reinterpret_cast<uint32_t*>(
+      numPartitions <= kBlockSize ? smem
+                                  : smem +
+              sizeof(typename Scan::
+                         TempStorage) /*- kBlockSize * sizeof(uint32_t)*/);
+  for (auto i = threadIdx.x; i < numPartitions; i += kBlockSize) {
+    counters[i] = 0;
+  }
+  __syncthreads();
+  for (auto start = 0; start < numKeys; start += kBlockSize) {
+    int32_t warpStart = start + warp * kWarpThreads;
+    if (start >= numKeys) {
+      break;
+    }
+    uint32_t laneMask = warpStart + kWarpThreads <= numKeys
+        ? 0xffffffff
+        : lowMask<uint32_t>(numKeys - warpStart);
+    if (warpStart + lane < numKeys) {
+      int32_t key = getter(warpStart + lane);
+      uint32_t mask = __match_any_sync(laneMask, key);
+      int32_t leader = (kWarpThreads - 1) - __clz(mask);
+      uint32_t cnt = __popc(mask & lowMask<uint32_t>(lane + 1));
+      uint32_t base;
+      if (lane == leader) {
+        base = atomicAdd(&counters[key], cnt);
+      }
+      base = __shfl_sync(laneMask, base, leader);
+      ranks[warpStart + lane] = base + cnt - 1;
+    }
+  }
+  // Prefix sum the counts. All counters must have their final value.
+  __syncthreads();
+  auto* temp = reinterpret_cast<typename Scan::TempStorage*>(smem);
+  int32_t* aggregate = reinterpret_cast<int32_t*>(smem);
+  for (auto start = 0; start < numPartitions; start += kBlockSize) {
+    int32_t localCount[1];
+    localCount[0] =
+        threadIdx.x + start < numPartitions ? counters[start + threadIdx.x] : 0;
+    if (threadIdx.x == 0 && start > 0) {
+      // The sum of the previous round is carried over as start of this.
+      localCount[0] += *aggregate;
+    }
+    Scan(*temp).InclusiveSum(localCount, localCount);
+    if (start + threadIdx.x < numPartitions) {
+      partitionStarts[start + threadIdx.x] = localCount[0];
+    }
+    if (threadIdx.x == kBlockSize - 1 && start + kBlockSize < numPartitions) {
+      *aggregate = localCount[0];
+    }
+    __syncthreads();
+  }
+  if (threadIdx.x == 0) {
+    if (partitionStarts[numPartitions - 1] != numKeys) {
+      *(long*)0 = 0;
+    }
+  }
+  // Write the row numbers of the inputs into the rankth position in each
+  // partition.
+  for (auto i = threadIdx.x; i < numKeys; i += kBlockSize) {
+    auto key = getter(i);
+    auto keyStart = key == 0 ? 0 : partitionStarts[key - 1];
+    partitionedRows[keyStart + ranks[i]] = i;
+  }
+  __syncthreads();
+}
+
+namespace detail {
+inline __device__ bool isLastInWarp() {
+  return (threadIdx.x & (kWarpThreads - 1)) == (kWarpThreads - 1);
+}
+} // namespace detail
+
+/// Returns the block wide exclusive sum (sum of 'input' for all
+/// lanes below threadIdx.x). If 'total' is non-nullptr, the block
+/// wide sum is returned in '*total'. 'temp' must have
+/// exclusiveSumTempSize() writable bytes aligned for T.
+template <typename T, int32_t kBlockSize>
+inline __device__ T exclusiveSum(T input, T* total, T* temp) {
+  constexpr int32_t kNumWarps = kBlockSize / kWarpThreads;
+  using Scan = cub::WarpScan<T>;
+  T sum;
+  Scan(*reinterpret_cast<typename Scan::TempStorage*>(temp))
+      .ExclusiveSum(input, sum);
+  if (kBlockSize == kWarpThreads) {
+    if (total) {
+      if (threadIdx.x == kWarpThreads - 1) {
+        *total = input + sum;
+      }
+      __syncthreads();
+    }
+    return sum;
+  }
+  if (detail::isLastInWarp()) {
+    temp[threadIdx.x / kWarpThreads] = input + sum;
+  }
+  __syncthreads();
+  using InnerScan = cub::WarpScan<T, kNumWarps>;
+  T warpSum = threadIdx.x < kNumWarps ? temp[threadIdx.x] : 0;
+  T blockSum;
+  InnerScan(*reinterpret_cast<typename InnerScan::TempStorage*>(temp))
+      .ExclusiveSum(warpSum, blockSum);
+  if (threadIdx.x < kNumWarps) {
+    temp[threadIdx.x] = blockSum;
+    if (total && threadIdx.x == kNumWarps - 1) {
+      *total = warpSum + blockSum;
+    }
+  }
+  __syncthreads();
+  return sum + temp[threadIdx.x / kWarpThreads];
+}
+
+/// Returns the block wide inclusive sum (sum of 'input' for all
+/// lanes below threadIdx.x). 'temp' must have
+/// exclusiveSumTempSize() writable bytes aligned for T. '*total' is set to the
+/// TB-wide total if 'total' is not nullptr.
+template <typename T, int32_t kBlockSize>
+inline __device__ T inclusiveSum(T input, T* total, T* temp) {
+  constexpr int32_t kNumWarps = kBlockSize / kWarpThreads;
+  using Scan = cub::WarpScan<T>;
+  T sum;
+  Scan(*reinterpret_cast<typename Scan::TempStorage*>(temp))
+      .InclusiveSum(input, sum);
+  if (kBlockSize <= kWarpThreads) {
+    if (total != nullptr) {
+      if (threadIdx.x == kBlockSize - 1) {
+        *total = sum;
+      }
+      __syncthreads();
+    }
+    return sum;
+  }
+  if (detail::isLastInWarp()) {
+    temp[threadIdx.x / kWarpThreads] = sum;
+  }
+  __syncthreads();
+  constexpr int32_t kInnerWidth = kNumWarps < 2 ? 2 : kNumWarps;
+  using InnerScan = cub::WarpScan<T, kInnerWidth>;
+  T warpSum = threadIdx.x < kInnerWidth ? temp[threadIdx.x] : 0;
+  T blockSum;
+  InnerScan(*reinterpret_cast<typename InnerScan::TempStorage*>(temp))
+      .ExclusiveSum(warpSum, blockSum);
+  if (threadIdx.x < kInnerWidth) {
+    temp[threadIdx.x] = blockSum;
+  }
+  if (total != nullptr && threadIdx.x == kInnerWidth - 1) {
+    *total = blockSum + warpSum;
+  }
+  __syncthreads();
+  return sum + temp[threadIdx.x / kWarpThreads];
+}
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/Buffer.cpp b/velox/experimental/wave/common/Buffer.cpp
index 53552a04d1535..3af8d128c039d 100644
--- a/velox/experimental/wave/common/Buffer.cpp
+++ b/velox/experimental/wave/common/Buffer.cpp
@@ -15,11 +15,43 @@
  */
 
 #include "velox/experimental/wave/common/Buffer.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/SuccinctPrinter.h"
+#include "velox/experimental/wave/common/Exception.h"
 #include "velox/experimental/wave/common/GpuArena.h"
 
+DECLARE_bool(wave_buffer_end_guard);
+
 namespace facebook::velox::wave {
 
+void Buffer::check() const {
+  if (!FLAGS_wave_buffer_end_guard) {
+    return;
+  }
+  if (*magicPtr() != kMagic) {
+    VELOX_FAIL("Buffer tail overrun: {}", toString());
+  }
+}
+
+void Buffer::setMagic() {
+  if (!FLAGS_wave_buffer_end_guard) {
+    return;
+  }
+  *magicPtr() = kMagic;
+}
+
+std::string Buffer::toString() const {
+  return fmt::format(
+      "<Buffer {} capacity={} ref={} pin={} dbg={}>",
+      ptr_,
+      capacity_,
+      referenceCount_,
+      pinCount_,
+      debugInfo_);
+}
+
 void Buffer::release() {
+  check();
   if (referenceCount_.fetch_sub(1) == 1) {
     arena_->free(this);
   }
diff --git a/velox/experimental/wave/common/Buffer.h b/velox/experimental/wave/common/Buffer.h
index a83e713dfb11b..0f0bddabac7b0 100644
--- a/velox/experimental/wave/common/Buffer.h
+++ b/velox/experimental/wave/common/Buffer.h
@@ -16,7 +16,9 @@
 
 #pragma once
 #include <boost/intrusive_ptr.hpp>
-#include "velox/common/base/Exceptions.h"
+#include <atomic>
+#include <cstdint>
+#include <string>
 
 namespace facebook::velox::wave {
 
@@ -31,6 +33,8 @@ class GpuArena;
 /// Buffer free list.
 class Buffer {
  public:
+  virtual ~Buffer() = default;
+
   template <typename T>
   T* as() {
     return reinterpret_cast<T*>(ptr_);
@@ -45,7 +49,7 @@ class Buffer {
   }
 
   void setSize(size_t newSize) {
-    VELOX_DCHECK_LE(newSize, capacity_);
+    assert(newSize <= capacity_);
     size_ = newSize;
   }
 
@@ -54,7 +58,7 @@ class Buffer {
   }
 
   bool unpin() {
-    VELOX_DCHECK_LT(0, pinCount_);
+    assert(0 < pinCount_);
     return --pinCount_ == 0;
   }
 
@@ -70,9 +74,31 @@ class Buffer {
     return referenceCount_;
   }
 
-  void release();
+  virtual void release();
+
+  const std::string& debugInfo() const {
+    return debugInfo_;
+  }
+
+  void setDebugInfo(std::string info) {
+    debugInfo_ = std::move(info);
+  }
+
+  /// Checks consistency of magic numbers. Throws on error.
+  void check() const;
+
+  std::string toString() const;
+
+ protected:
+  static constexpr int64_t kMagic = 0xe0be0be0be0be0b;
+
+  int64_t* magicPtr() const {
+    return reinterpret_cast<int64_t*>(
+        reinterpret_cast<char*>(ptr_) + capacity_);
+  }
+
+  void setMagic();
 
- private:
   // Number of WaveBufferPtrs referencing 'this'.
   std::atomic<int32_t> referenceCount_{0};
 
@@ -94,6 +120,7 @@ class Buffer {
   // The containeing arena.
   GpuArena* arena_{nullptr};
 
+  std::string debugInfo_;
   friend class GpuArena;
 };
 
@@ -107,4 +134,34 @@ static inline void intrusive_ptr_release(Buffer* buffer) {
   buffer->release();
 }
 
+template <typename Releaser>
+class WaveBufferView : public Buffer {
+ public:
+  static WaveBufferPtr create(uint8_t* data, size_t size, Releaser releaser) {
+    WaveBufferView<Releaser>* view = new WaveBufferView(data, size, releaser);
+    WaveBufferPtr result(view);
+    return result;
+  }
+
+  ~WaveBufferView() override = default;
+
+  void release() override {
+    if (referenceCount_.fetch_sub(1) == 1) {
+      // Destructs releaser, which should release the hold on the underlying
+      // buffer.
+      delete this;
+    }
+  }
+
+ private:
+  WaveBufferView(uint8_t* data, size_t size, Releaser releaser)
+      : Buffer(), releaser_(releaser) {
+    ptr_ = data;
+    size_ = size;
+    capacity_ = size;
+  }
+
+  Releaser const releaser_;
+};
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/CMakeLists.txt b/velox/experimental/wave/common/CMakeLists.txt
index 205d945331aea..db1f54f25568c 100644
--- a/velox/experimental/wave/common/CMakeLists.txt
+++ b/velox/experimental/wave/common/CMakeLists.txt
@@ -12,13 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_wave_common GpuArena.cpp Buffer.cpp Cuda.cu Exception.cpp
-                              Type.cpp)
+velox_add_library(
+  velox_wave_common
+  GpuArena.cpp
+  Buffer.cpp
+  Cuda.cu
+  Exception.cpp
+  Type.cpp
+  ResultStaging.cpp)
 
-set_target_properties(velox_wave_common PROPERTIES CUDA_ARCHITECTURES native)
-
-target_link_libraries(velox_wave_common velox_exception velox_common_base
-                      velox_type)
+velox_link_libraries(velox_wave_common velox_exception velox_common_base
+                     velox_type)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/experimental/wave/common/Cuda.cu b/velox/experimental/wave/common/Cuda.cu
index 48a1e68040298..b018c7283a74f 100644
--- a/velox/experimental/wave/common/Cuda.cu
+++ b/velox/experimental/wave/common/Cuda.cu
@@ -16,10 +16,13 @@
 
 #include <cuda_runtime.h>
 #include <fmt/format.h>
+#include <iostream>
 #include "velox/experimental/wave/common/Cuda.h"
 #include "velox/experimental/wave/common/CudaUtil.cuh"
 #include "velox/experimental/wave/common/Exception.h"
 
+#include <sstream>
+
 namespace facebook::velox::wave {
 
 void cudaCheck(cudaError_t err, const char* file, int line) {
@@ -30,6 +33,16 @@ void cudaCheck(cudaError_t err, const char* file, int line) {
       fmt::format("Cuda error: {}:{} {}", file, line, cudaGetErrorString(err)));
 }
 
+void cudaCheckFatal(cudaError_t err, const char* file, int line) {
+  if (err == cudaSuccess) {
+    return;
+  }
+  auto error =
+      fmt::format("Cuda error: {}:{} {}", file, line, cudaGetErrorString(err));
+  std::cerr << err << std::endl;
+  exit(1);
+}
+
 namespace {
 class CudaManagedAllocator : public GpuAllocator {
  public:
@@ -55,6 +68,9 @@ class CudaDeviceAllocator : public GpuAllocator {
   void free(void* ptr, size_t /*size*/) override {
     cudaFree(ptr);
   }
+  bool isDevice() const override {
+    return true;
+  }
 };
 
 class CudaHostAllocator : public GpuAllocator {
@@ -68,6 +84,10 @@ class CudaHostAllocator : public GpuAllocator {
   void free(void* ptr, size_t /*size*/) override {
     cudaFreeHost(ptr);
   };
+
+  bool isHost() const override {
+    return true;
+  }
 };
 
 } // namespace
@@ -114,6 +134,10 @@ void Stream::prefetch(Device* device, void* ptr, size_t size) {
       ptr, size, device ? device->deviceId : cudaCpuDeviceId, stream_->stream));
 }
 
+void Stream::memset(void* ptr, int32_t value, size_t size) {
+  CUDA_CHECK(cudaMemsetAsync(ptr, value, size, stream_->stream));
+}
+
 void Stream::hostToDeviceAsync(
     void* deviceAddress,
     const void* hostAddress,
@@ -124,6 +148,7 @@ void Stream::hostToDeviceAsync(
       size,
       cudaMemcpyHostToDevice,
       stream_->stream));
+  isTransfer_ = true;
 }
 
 void Stream::deviceToHostAsync(
@@ -170,8 +195,8 @@ struct EventImpl {
 
 Event::Event(bool withTime) : hasTiming_(withTime) {
   event_ = std::make_unique<EventImpl>();
-  CUDA_CHECK(
-      cudaEventCreate(&event_->event, withTime ? 0 : cudaEventDisableTiming));
+  CUDA_CHECK(cudaEventCreateWithFlags(
+      &event_->event, withTime ? 0 : cudaEventDisableTiming));
 }
 
 Event::~Event() {}
@@ -208,5 +233,67 @@ float Event::elapsedTime(const Event& start) const {
   CUDA_CHECK(cudaEventElapsedTime(&ms, start.event_->event, event_->event));
   return ms;
 }
+namespace {
+struct KernelEntry {
+  const char* name;
+  const void* func;
+};
+
+int32_t numKernelEntries = 0;
+KernelEntry kernelEntries[200];
+} // namespace
+
+bool registerKernel(const char* name, const void* func) {
+  kernelEntries[numKernelEntries].name = name;
+  kernelEntries[numKernelEntries].func = func;
+  ++numKernelEntries;
+  if (numKernelEntries >= sizeof(kernelEntries) / sizeof(kernelEntries[0])) {
+    LOG(ERROR) << "Reserve more space in kernelEntries";
+    exit(1);
+  }
+  return true;
+}
+
+KernelInfo kernelInfo(const void* func) {
+  cudaFuncAttributes attrs;
+  CUDA_CHECK_FATAL(cudaFuncGetAttributes(&attrs, func));
+  KernelInfo info;
+  info.numRegs = attrs.numRegs;
+  info.maxThreadsPerBlock = attrs.maxThreadsPerBlock;
+  info.sharedMemory = attrs.sharedSizeBytes;
+  int max;
+  cudaOccupancyMaxActiveBlocksPerMultiprocessor(&max, func, 256, 0);
+  info.maxOccupancy0 = max;
+  cudaOccupancyMaxActiveBlocksPerMultiprocessor(&max, func, 256, 256 * 32);
+  info.maxOccupancy32 = max;
+
+  return info;
+}
+
+std::string KernelInfo::toString() const {
+  std::stringstream out;
+  out << "NumRegs=" << numRegs << " maxThreadsPerBlock= " << maxThreadsPerBlock
+      << " sharedMemory=" << sharedMemory
+      << " occupancy 256,  0=" << maxOccupancy0
+      << " occupancy 256,32=" << maxOccupancy32;
+  return out.str();
+}
+
+KernelInfo getRegisteredKernelInfo(const char* name) {
+  for (auto i = 0; i < numKernelEntries; ++i) {
+    if (strcmp(name, kernelEntries[i].name) == 0) {
+      return kernelInfo(kernelEntries[i].func);
+    }
+  }
+  return KernelInfo();
+}
+
+void printKernels() {
+  for (auto i = 0; i < numKernelEntries; ++i) {
+    std::cout << kernelEntries[i].name << " - "
+              << getRegisteredKernelInfo(kernelEntries[i].name).toString()
+              << std::endl;
+  }
+}
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/Cuda.h b/velox/experimental/wave/common/Cuda.h
index b8e11806013d1..4735999a4dc4e 100644
--- a/velox/experimental/wave/common/Cuda.h
+++ b/velox/experimental/wave/common/Cuda.h
@@ -18,6 +18,8 @@
 
 #include <functional>
 #include <memory>
+#include <string>
+#include <unordered_map>
 /// Contains wrappers for common Cuda objects. Wave does not directly
 /// include Cuda headers because of interference with BitUtils.h and
 /// SimdUtils.h.
@@ -46,6 +48,9 @@ class Stream {
   /// Waits  until the stream is completed.
   void wait();
 
+  /// Enqueus a memset on 'device'.
+  void memset(void* address, int32_t value, size_t size);
+
   /// Enqueus a prefetch. Prefetches to host if 'device' is nullptr, otherwise
   /// to 'device'.
   void prefetch(Device* device, void* address, size_t size);
@@ -70,10 +75,16 @@ class Stream {
   void*& userData() {
     return userData_;
   }
+  bool getAndClearIsTransfer() {
+    auto flag = isTransfer_;
+    isTransfer_ = false;
+    return flag;
+  }
 
  protected:
   std::unique_ptr<StreamImpl> stream_;
   void* userData_{nullptr};
+  bool isTransfer_{false};
 
   friend class Event;
 };
@@ -87,7 +98,7 @@ class Event {
 
   ~Event();
 
-  ///  Recirds event on 'stream'. This must be called before other member
+  ///  Records event on 'stream'. This must be called before other member
   ///  functions.
   void record(Stream&);
 
@@ -126,6 +137,16 @@ class GpuAllocator {
   /// to allocate(). A Memory must be freed to the same allocator it came from.
   virtual void free(void* ptr, size_t bytes) = 0;
 
+  /// True if allocates host pinned memory.
+  virtual bool isHost() const {
+    return false;
+  }
+
+  /// True if allocates device side memory.
+  virtual bool isDevice() const {
+    return false;
+  }
+
   class Deleter;
 
   template <typename T>
@@ -183,4 +204,23 @@ GpuAllocator::UniquePtr<T[]> GpuAllocator::allocate(size_t n) {
   return UniquePtr<T[]>(ptr, Deleter(this, bytes));
 }
 
+/// Info on kernel occupancy limits.
+struct KernelInfo {
+  int32_t numRegs{0};
+  int32_t maxThreadsPerBlock;
+  int32_t sharedMemory{0};
+  int32_t maxOccupancy0{0};
+  int32_t maxOccupancy32{0};
+
+  std::string toString() const;
+};
+
+KernelInfo getRegisteredKernelInfo(const char* name);
+
+KernelInfo kernelInfo(const void* func);
+
+std::unordered_map<std::string, KernelInfo>& kernelRegistry();
+/// Prints summary of registered kernels.
+void printKernels();
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/CudaUtil.cuh b/velox/experimental/wave/common/CudaUtil.cuh
index 62c202ff23c3f..b16e32a72f334 100644
--- a/velox/experimental/wave/common/CudaUtil.cuh
+++ b/velox/experimental/wave/common/CudaUtil.cuh
@@ -25,13 +25,55 @@ namespace facebook::velox::wave {
 
 void cudaCheck(cudaError_t err, const char* file, int line);
 
+void cudaCheckFatal(cudaError_t err, const char* file, int line);
+
 #define CUDA_CHECK(e) ::facebook::velox::wave::cudaCheck(e, __FILE__, __LINE__)
 
+#ifndef CUDA_CHECK_FATAL
+#define CUDA_CHECK_FATAL(e) \
+  ::facebook::velox::wave::cudaCheckFatal(e, __FILE__, __LINE__)
+#endif
+
 template <typename T, typename U>
-constexpr inline T roundUp(T value, U factor) {
+__host__ __device__ constexpr inline T roundUp(T value, U factor) {
   return (value + (factor - 1)) / factor * factor;
 }
 
+template <typename T>
+constexpr T __device__ __host__ lowMask(int32_t bits) {
+  /****
+   * NVCC BUG: If the special case for all bits is not in, all modes except -G
+   * produce a 0 mask for 32 or 64 bits.
+   ****/
+  return bits == 8 * sizeof(T) ? ~static_cast<T>(0)
+                               : (static_cast<T>(1) << bits) - 1;
+}
+
+template <typename T>
+constexpr inline __device__ __host__ T highMask(int32_t bits) {
+  return lowMask<T>(bits) << ((sizeof(T) * 8) - bits);
+}
+
+template <typename T>
+inline T* __device__ __host__ addBytes(T* ptr, int bytes) {
+  return reinterpret_cast<T*>(reinterpret_cast<char*>(ptr) + bytes);
+}
+
+template <typename T>
+inline const T* __device__ __host__ addBytes(const T* ptr, int bytes) {
+  return reinterpret_cast<const T*>(reinterpret_cast<const char*>(ptr) + bytes);
+}
+
+template <typename T>
+inline T* __device__ __host__ addCast(void* ptr, int bytes) {
+  return reinterpret_cast<T*>(reinterpret_cast<char*>(ptr) + bytes);
+}
+
+template <typename T>
+inline const T* __device__ __host__ addCast(const void* ptr, int bytes) {
+  return reinterpret_cast<const T*>(reinterpret_cast<const char*>(ptr) + bytes);
+}
+
 __device__ __host__ inline int
 memcmp(const void* lhs, const void* rhs, size_t n) {
   auto* a = reinterpret_cast<const uint8_t*>(lhs);
@@ -44,7 +86,20 @@ memcmp(const void* lhs, const void* rhs, size_t n) {
   return 0;
 }
 
+inline uint32_t __device__ deviceScale32(uint32_t n, uint32_t scale) {
+  return (static_cast<uint64_t>(static_cast<uint32_t>(n)) * scale) >> 32;
+}
+
 struct StreamImpl {
   cudaStream_t stream;
 };
+
+bool registerKernel(const char* name, const void* func);
+
+#define REGISTER_KERNEL(name, func)                              \
+  namespace {                                                    \
+  static bool func##_reg =                                       \
+      registerKernel(name, reinterpret_cast<const void*>(func)); \
+  }
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/FreeSet.cuh b/velox/experimental/wave/common/FreeSet.cuh
new file mode 100644
index 0000000000000..c6e7f2bfc3cf1
--- /dev/null
+++ b/velox/experimental/wave/common/FreeSet.cuh
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace facebook::velox::wave {
+
+template <typename T, int32_t kSize>
+class FreeSet {
+ public:
+  static constexpr uint32_t kEmpty = ~0;
+  static constexpr int32_t kBitSizeMask = (kSize / 64) - 1;
+  static constexpr int32_t kSizeMask = kSize - 1;
+
+  void __device__ clear() {
+    for (auto i = threadIdx.x; i < kSize; i += blockDim.x) {
+      if (i < sizeof(bits_) / sizeof(bits_[0])) {
+        bits_[i] = 0;
+      }
+      items_[i] = kEmpty;
+    }
+  }
+
+  // Adds an item. Returns true if succeededs.
+  bool __device__ put(T item) {
+    if (full_) {
+      return false;
+    }
+    auto tid = threadIdx.x + blockDim.x * blockIdx.x;
+    auto bitIdx = tid & kBitSizeMask;
+    for (auto count = 0; count <= kBitSizeMask; ++count) {
+      auto word = ~bits_[bitIdx];
+      while (word) {
+        auto bit = __ffsll(word);
+        --bit;
+        if (kEmpty == atomicCAS(&items_[bitIdx * 64 + bit], kEmpty, item)) {
+          atomicOr(&bits_[bitIdx], 1UL << bit);
+          if (empty_) {
+            atomicExch(&empty_, 0);
+          }
+          return true;
+        }
+        word &= word - 1;
+      }
+      bitIdx = bitIdx + 1 & kBitSizeMask;
+    }
+    atomicExch(&full_, 1);
+    return false;
+  }
+
+  T __device__ get() {
+    if (empty_) {
+      return kEmpty;
+    }
+
+    auto tid = threadIdx.x + blockDim.x * blockIdx.x;
+    auto bitIdx = tid & kBitSizeMask;
+    for (auto count = 0; count <= kBitSizeMask; ++count) {
+      auto word = bits_[bitIdx];
+      while (word) {
+        auto bit = __ffsll(word);
+        --bit;
+        T item = atomicExch(&items_[bitIdx * 64 + bit], kEmpty);
+        if (item != kEmpty) {
+          atomicAnd(&bits_[bitIdx], ~(1UL << bit));
+          if (full_) {
+            atomicExch(&full_, 0);
+          }
+          return item;
+        }
+        word &= word - 1;
+      }
+      bitIdx = bitIdx + 1 & kBitSizeMask;
+    }
+    atomicExch(&empty_, true);
+    return kEmpty;
+  }
+
+  int32_t full_{0};
+  int32_t empty_{1};
+  unsigned long long bits_[kBitSizeMask + 1];
+  T items_[kSize];
+};
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/GpuArena.cpp b/velox/experimental/wave/common/GpuArena.cpp
index 2a41f8859e0d6..71bc8bdd7a4e5 100644
--- a/velox/experimental/wave/common/GpuArena.cpp
+++ b/velox/experimental/wave/common/GpuArena.cpp
@@ -21,10 +21,22 @@
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/experimental/wave/common/Exception.h"
 
+DEFINE_bool(
+    wave_buffer_end_guard,
+    false,
+    "Use buffer  end guard to detect overruns");
+
 namespace facebook::velox::wave {
 
 uint64_t GpuSlab::roundBytes(uint64_t bytes) {
-  return bits::nextPowerOfTwo(bytes);
+  if (FLAGS_wave_buffer_end_guard) {
+    bytes += sizeof(int64_t);
+  }
+  if (bytes > 32 << 10) {
+    return bits::roundUp(bytes, 32 << 10);
+  } else {
+    return bits::nextPowerOfTwo(std::max<int64_t>(16, bytes));
+  }
 }
 
 GpuSlab::GpuSlab(void* ptr, size_t capacityBytes, GpuAllocator* allocator)
@@ -272,20 +284,28 @@ std::string GpuSlab::toString() const {
 }
 
 GpuArena::Buffers::Buffers() {
-  memset(&buffers[0], 0, sizeof(buffers));
+  for (auto i = 0; i < sizeof(buffers) / sizeof(buffers[0]); ++i) {
+    new (&buffers[i]) Buffer();
+  }
 }
 
-GpuArena::GpuArena(uint64_t singleArenaCapacity, GpuAllocator* allocator)
-    : singleArenaCapacity_(singleArenaCapacity), allocator_(allocator) {
+GpuArena::GpuArena(
+    uint64_t singleArenaCapacity,
+    GpuAllocator* allocator,
+    uint64_t standbyCapacity)
+    : singleArenaCapacity_(singleArenaCapacity),
+      standbyCapacity_(standbyCapacity),
+      allocator_(allocator) {
   auto arena = std::make_shared<GpuSlab>(
       allocator_->allocate(singleArenaCapacity),
       singleArenaCapacity,
       allocator_);
+  capacity_ += arena->byteSize();
   arenas_.emplace(reinterpret_cast<uint64_t>(arena->address()), arena);
   currentArena_ = arena;
 }
 
-WaveBufferPtr GpuArena::getBuffer(void* ptr, size_t size) {
+WaveBufferPtr GpuArena::getBuffer(void* ptr, size_t capacity, size_t size) {
   auto result = firstFreeBuffer_;
   if (!result) {
     allBuffers_.push_back(std::make_unique<Buffers>());
@@ -297,43 +317,51 @@ WaveBufferPtr GpuArena::getBuffer(void* ptr, size_t size) {
     result = firstFreeBuffer_;
   }
   firstFreeBuffer_ = reinterpret_cast<Buffer*>(result->ptr_);
+  new (result) Buffer();
   result->arena_ = this;
   result->ptr_ = ptr;
   result->size_ = size;
-  result->capacity_ = size;
+  result->capacity_ = capacity;
+  result->setMagic();
   return result;
 }
 
 WaveBufferPtr GpuArena::allocateBytes(uint64_t bytes) {
-  bytes = GpuSlab::roundBytes(bytes);
+  auto roundedBytes = GpuSlab::roundBytes(bytes);
   std::lock_guard<std::mutex> l(mutex_);
-  auto* result = currentArena_->allocate(bytes);
+  totalAllocated_ += roundedBytes;
+  ++numAllocations_;
+  auto* result = currentArena_->allocate(roundedBytes);
   if (result != nullptr) {
-    return getBuffer(result, bytes);
+    return getBuffer(result, bytes, roundedBytes);
   }
   for (auto pair : arenas_) {
-    if (pair.second == currentArena_ || pair.second->freeBytes() < bytes) {
+    if (pair.second == currentArena_ ||
+        pair.second->freeBytes() < roundedBytes) {
       continue;
     }
     result = pair.second->allocate(bytes);
     if (result) {
       currentArena_ = pair.second;
-      return getBuffer(result, bytes);
+      return getBuffer(result, bytes, roundedBytes);
     }
   }
 
   // If first allocation fails we create a new GpuSlab for another attempt. If
   // it ever fails again then it means requested bytes is larger than a single
   // GpuSlab's capacity. No further attempts will happen.
+  auto arenaBytes = std::max<uint64_t>(singleArenaCapacity_, roundedBytes);
   auto newArena = std::make_shared<GpuSlab>(
-      allocator_->allocate(singleArenaCapacity_),
-      singleArenaCapacity_,
-      allocator_);
+      allocator_->allocate(arenaBytes), arenaBytes, allocator_);
   arenas_.emplace(reinterpret_cast<uint64_t>(newArena->address()), newArena);
+  capacity_ += newArena->byteSize();
+  if (capacity_ > maxCapacity_) {
+    maxCapacity_ = capacity_;
+  }
   currentArena_ = newArena;
   result = currentArena_->allocate(bytes);
   if (result) {
-    return getBuffer(result, bytes);
+    return getBuffer(result, bytes, roundedBytes);
   }
   VELOX_FAIL("Failed to allocate {} bytes of universal address space", bytes);
 }
@@ -353,7 +381,9 @@ void GpuArena::free(Buffer* buffer) {
         iter->first + singleArenaCapacity_, addressU64 + buffer->size_);
   }
   iter->second->free(buffer->ptr_, buffer->size_);
-  if (iter->second->empty() && iter->second != currentArena_) {
+  if (iter->second->empty() && iter->second != currentArena_ &&
+      capacity_ - iter->second->byteSize() >= standbyCapacity_) {
+    capacity_ -= iter->second->byteSize();
     arenas_.erase(iter);
   }
   buffer->ptr_ = firstFreeBuffer_;
@@ -362,4 +392,43 @@ void GpuArena::free(Buffer* buffer) {
   firstFreeBuffer_ = buffer;
 }
 
+ArenaStatus GpuArena::checkBuffers() {
+  ArenaStatus status;
+  std::lock_guard<std::mutex> l(mutex_);
+  std::vector<Buffer*> usedBuffers;
+  for (auto& buffers : allBuffers_) {
+    for (auto& buffer : buffers->buffers) {
+      if (buffer.referenceCount_) {
+        ++status.numBuffers;
+        status.capacity += buffer.capacity_;
+        status.allocatedBytes += buffer.size_;
+        buffer.check();
+        usedBuffers.push_back(&buffer);
+      }
+    }
+  }
+  std::sort(
+      usedBuffers.begin(),
+      usedBuffers.end(),
+      [](Buffer*& left, Buffer*& right) {
+        return (uintptr_t)left->ptr_ < (uintptr_t)right->ptr_;
+      });
+  for (auto i = 0; i < usedBuffers.size() - 1; ++i) {
+    void* end =
+        reinterpret_cast<char*>(usedBuffers[i]->ptr_) + usedBuffers[i]->size_;
+    if (end > usedBuffers[i + 1]->ptr_) {
+      VELOX_FAIL("Overlapping buffers in GpuArena");
+    }
+  }
+  return status;
+}
+
+std::string GpuArena::toString() const {
+  std::stringstream out;
+  for (auto& pair : arenas_) {
+    out << pair.second->toString() << std::endl;
+  }
+  return out.str();
+}
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/GpuArena.h b/velox/experimental/wave/common/GpuArena.h
index 32b802c662d09..9a7256947fcd6 100644
--- a/velox/experimental/wave/common/GpuArena.h
+++ b/velox/experimental/wave/common/GpuArena.h
@@ -42,7 +42,7 @@ class GpuSlab {
 
   // Returns an address for at least 'bytes' of memory inside this slab, nullptr
   // if there is no contiguous run of at least 'bytes'.
-  void* FOLLY_NULLABLE allocate(uint64_t bytes);
+  void* allocate(uint64_t bytes);
 
   /// Frees an area returned by allocate().
   void free(void* address, uint64_t bytes);
@@ -114,17 +114,31 @@ class GpuSlab {
   GpuAllocator* const allocator_;
 };
 
+struct ArenaStatus {
+  /// Number of allocated Buffers.
+  int32_t numBuffers{0};
+
+  /// Sum of capacity of allocated buffers.
+  int64_t capacity{};
+
+  /// Currently used bytes. Larger than capacity because of padding.
+  int64_t allocatedBytes{0};
+};
+
 /// A class that manages a set of GpuSlabs. It is able to adapt itself by
 /// growing the number of its managed GpuSlab's when extreme memory
 /// fragmentation happens.
 class GpuArena {
  public:
-  GpuArena(uint64_t singleArenaCapacity, GpuAllocator* allocator);
+  GpuArena(
+      uint64_t singleArenaCapacity,
+      GpuAllocator* allocator,
+      uint64_t standbyCapacity = 0);
 
   WaveBufferPtr allocateBytes(uint64_t bytes);
 
   template <typename T>
-  WaveBufferPtr allocate(int32_t items) {
+  WaveBufferPtr allocate(uint64_t items) {
     static_assert(std::is_trivially_destructible_v<T>);
     return allocateBytes(sizeof(T) * items);
   }
@@ -141,6 +155,37 @@ class GpuArena {
     return arenas_;
   }
 
+  uint64_t maxCapacity() const {
+    return maxCapacity_;
+  }
+
+  uint64_t totalAllocated() const {
+    return totalAllocated_;
+  }
+
+  uint64_t numAllocations() const {
+    return numAllocations_;
+  }
+
+  uint64_t retainedSize() const {
+    return capacity_;
+  }
+
+  void setSizes(uint64_t arenaSize, uint64_t standbyCapacity) {
+    singleArenaCapacity_ = arenaSize;
+    standbyCapacity_ = standbyCapacity;
+  }
+
+  bool isDevice() const {
+    return allocator_->isDevice();
+  }
+
+  /// Checks magic numbers and returns the sum of allocated capacity. Actual
+  /// sizes are padded to larger.
+  ArenaStatus checkBuffers();
+
+  std::string toString() const;
+
  private:
   // A preallocated array of Buffer handles for memory of 'this'.
   struct Buffers {
@@ -149,8 +194,9 @@ class GpuArena {
   };
 
   // Returns a new reference counting pointer to a new Buffer initialized to
-  // 'ptr' and 'size'.
-  WaveBufferPtr getBuffer(void* ptr, size_t size);
+  // 'ptr' and 'size'. 'size' is the size to fre, 'capacity' is the usable size
+  // excluding magic numbers and padding.
+  WaveBufferPtr getBuffer(void* ptr, size_t capacity, size_t size);
 
   // Serializes all activity in 'this'.
   std::mutex mutex_;
@@ -162,8 +208,14 @@ class GpuArena {
   // Head of Buffer free list.
   Buffer* firstFreeBuffer_{nullptr};
 
+  // Total capacity in all arenas.
+  uint64_t capacity_{0};
+
   // Capacity in bytes for a single GpuSlab managed by this.
-  const uint64_t singleArenaCapacity_;
+  uint64_t singleArenaCapacity_;
+
+  // Lower bound of capacity to keep around even if usage is below this.
+  uint64_t standbyCapacity_{0};
 
   GpuAllocator* const allocator_;
 
@@ -173,6 +225,10 @@ class GpuArena {
   // All allocations should come from this GpuSlab. When it is no longer able
   // to handle allocations it will be updated to a newly created GpuSlab.
   std::shared_ptr<GpuSlab> currentArena_;
+
+  uint64_t numAllocations_{0};
+  uint64_t totalAllocated_{0};
+  uint64_t maxCapacity_{0};
 };
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/Hash.h b/velox/experimental/wave/common/Hash.h
index ca3e51e95e265..c91f25407bdca 100644
--- a/velox/experimental/wave/common/Hash.h
+++ b/velox/experimental/wave/common/Hash.h
@@ -93,6 +93,17 @@ __device__ __host__ inline uint32_t twang32From64(uint64_t key) {
   return static_cast<uint32_t>(key);
 }
 
+__device__ inline uint64_t hashMix(const uint64_t upper, const uint64_t lower) {
+  // Murmur-inspired hashing.
+  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
+  uint64_t a = (lower ^ upper) * kMul;
+  a ^= (a >> 47);
+  uint64_t b = (upper ^ a) * kMul;
+  b ^= (b >> 47);
+  b *= kMul;
+  return b;
+}
+
 template <typename T>
 struct IntHasher32 {
   __device__ __host__ uint32_t operator()(T val) const {
diff --git a/velox/experimental/wave/common/HashTable.cuh b/velox/experimental/wave/common/HashTable.cuh
new file mode 100644
index 0000000000000..9ece4aa0cfbce
--- /dev/null
+++ b/velox/experimental/wave/common/HashTable.cuh
@@ -0,0 +1,368 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cuda/atomic>
+#include <cuda/semaphore>
+
+#include <cub/thread/thread_load.cuh>
+#include <cub/util_ptx.cuh>
+
+#include "velox/experimental/wave/common/CudaUtil.cuh"
+#include "velox/experimental/wave/common/FreeSet.cuh"
+#include "velox/experimental/wave/common/Hash.h"
+#include "velox/experimental/wave/common/HashTable.h"
+
+namespace facebook::velox::wave {
+
+#define GPF() *(long*)0 = 0
+
+template <typename T, typename U>
+inline __device__ cuda::atomic<T, cuda::thread_scope_device>* asDeviceAtomic(
+    U* ptr) {
+  return reinterpret_cast<cuda::atomic<T, cuda::thread_scope_device>*>(ptr);
+}
+
+template <typename T>
+inline bool __device__ atomicTryLock(T* lock) {
+  return 0 ==
+      asDeviceAtomic<int32_t>(lock)->exchange(1, cuda::memory_order_consume);
+}
+
+template <typename T>
+inline void __device__ atomicUnlock(T* lock) {
+  asDeviceAtomic<int32_t>(lock)->store(0, cuda::memory_order_release);
+}
+
+/// Allocator subclass that defines device member functions.
+struct RowAllocator : public HashPartitionAllocator {
+  template <typename T>
+  T* __device__ allocateRow() {
+    auto fromFree = getFromFree();
+    if (fromFree != kEmpty) {
+      ++numFromFree;
+      return reinterpret_cast<T*>(base + fromFree);
+    }
+    auto offset = atomicAdd(&rowOffset, rowSize);
+
+    if (offset + rowSize < cub::ThreadLoad<cub::LOAD_CG>(&stringOffset)) {
+      if (!inRange(base + offset)) {
+        GPF();
+      }
+      return reinterpret_cast<T*>(base + offset);
+    }
+    return nullptr;
+  }
+
+  uint32_t __device__ getFromFree() {
+    uint32_t item = reinterpret_cast<FreeSet<uint32_t, 1024>*>(freeSet)->get();
+    if (item != kEmpty) {
+      ++numFromFree;
+    }
+    return item;
+  }
+
+  void __device__ freeRow(void* row) {
+    if (!inRange(row)) {
+      GPF();
+    }
+    uint32_t offset = reinterpret_cast<uint64_t>(row) - base;
+    numFull += reinterpret_cast<FreeSet<uint32_t, 1024>*>(freeSet)->put(
+                   offset) == false;
+  }
+
+  template <typename T>
+  T* __device__ allocate(int32_t cnt) {
+    uint32_t size = sizeof(T) * cnt;
+    auto offset = atomicSub(&stringOffset, size);
+    if (offset - size > cub::ThreadLoad<cub::LOAD_CG>(&rowOffset)) {
+      if (!inRange(base + offset - size)) {
+        GPF();
+      }
+      return reinterpret_cast<T*>(base + offset - size);
+    }
+    return nullptr;
+  }
+
+  template <typename T>
+  bool __device__ inRange(T ptr) {
+    return reinterpret_cast<uint64_t>(ptr) >= base &&
+        reinterpret_cast<uint64_t>(ptr) < base + capacity;
+  }
+};
+
+inline uint8_t __device__ hashTag(uint64_t h) {
+  return 0x80 | (h >> 32);
+}
+
+struct GpuBucket : public GpuBucketMembers {
+  template <typename RowType>
+  inline RowType* __device__ load(int32_t idx) const {
+    uint64_t uptr = reinterpret_cast<const uint32_t*>(&data)[idx];
+    if (uptr == 0) {
+      return nullptr;
+    }
+    uptr |= static_cast<uint64_t>(data[idx + 8]) << 32;
+    return reinterpret_cast<RowType*>(uptr);
+  }
+
+  template <typename RowType>
+  inline RowType* __device__ loadConsume(int32_t idx) {
+    uint64_t uptr =
+        asDeviceAtomic<uint32_t>(&data)[idx].load(cuda::memory_order_consume);
+    if (uptr == 0) {
+      return nullptr;
+    }
+    uptr |= static_cast<uint64_t>(data[idx + 8]) << 32;
+    return reinterpret_cast<RowType*>(uptr);
+  }
+
+  template <typename RowType>
+  inline RowType* __device__ loadWithWait(int32_t idx) {
+    RowType* hit;
+    do {
+      // It could be somebody inserted the tag but did not fill in the
+      // pointer. The pointer is coming in a few clocks.
+      hit = loadConsume<RowType>(idx);
+    } while (!hit);
+    return hit;
+  }
+
+  inline void __device__ store(int32_t idx, void* ptr) {
+    auto uptr = reinterpret_cast<uint64_t>(ptr);
+    data[8 + idx] = uptr >> 32;
+    // The high part must be seen if the low part is seen.
+    asDeviceAtomic<uint32_t>(&data)[idx].store(
+        uptr, cuda::memory_order_release);
+  }
+
+  bool __device__ addNewTag(uint8_t tag, uint32_t oldTags, uint8_t tagShift) {
+    uint32_t newTags = oldTags | ((static_cast<uint32_t>(tag) << tagShift));
+    return (oldTags == atomicCAS(&tags, oldTags, newTags));
+  }
+};
+
+/// Shared memory state for an updating probe.
+struct ProbeShared {
+  int32_t* inputRetries;
+  int32_t* outputRetries;
+  uint32_t numKernelRetries;
+  uint32_t numHostRetries;
+  int32_t blockBase;
+  int32_t blockEnd;
+  int32_t numRounds;
+  int32_t toDo;
+  int32_t done;
+  int32_t numUpdated;
+  int32_t numTried;
+
+  /// Initializes a probe. Sets outputRetries and clears inputRetries and other
+  /// state.
+  void __device__ init(HashProbe* probe, int32_t base) {
+    inputRetries = nullptr;
+    outputRetries = probe->kernelRetries1;
+    numKernelRetries = 0;
+    numHostRetries = 0;
+    blockBase = base;
+    toDo = 0;
+    done = 0;
+    numRounds = 0;
+  }
+
+  // Resets retrry count and swaps input and output retries.
+  void __device__ nextRound(HashProbe* probe) {
+    numKernelRetries = 0;
+    if (!inputRetries) {
+      // This is after the initial round where there are no input retries.
+      inputRetries = outputRetries;
+      outputRetries = probe->kernelRetries2;
+    } else {
+      // swap input and output retries.
+      auto temp = outputRetries;
+      outputRetries = inputRetries;
+      inputRetries = temp;
+    }
+  }
+};
+
+class GpuHashTable : public GpuHashTableBase {
+ public:
+  static constexpr int32_t kExclusive = 1;
+
+  static int32_t updatingProbeSharedSize() {
+    return sizeof(ProbeShared);
+  }
+
+  template <typename RowType, typename Ops>
+  void __device__ readOnlyProbe(HashProbe* probe, Ops ops) {
+    int32_t blockBase = ops.blockBase(probe);
+    int32_t end = ops.numRowsInBlock(probe) + blockBase;
+    for (auto i = blockBase + threadIdx.x; i < end; i += blockDim.x) {
+      auto h = ops.hash(i, probe);
+      uint32_t tagWord = hashTag(h);
+      tagWord |= tagWord << 8;
+      tagWord = tagWord | tagWord << 16;
+      auto bucketIdx = h & sizeMask;
+      for (;;) {
+        GpuBucket* bucket = buckets + bucketIdx;
+        auto tags = bucket->tags;
+        auto hits = __vcmpeq4(tags, tagWord) & 0x01010101;
+        while (hits) {
+          auto hitIdx = (__ffs(hits) - 1) / 8;
+          auto* hit = bucket->load<RowType>(hitIdx);
+          if (ops.compare(this, hit, i, probe)) {
+            ops.hit(i, probe, hit);
+            goto done;
+          }
+          hits = hits & (hits - 1);
+        }
+        if (__vcmpeq4(tags, 0)) {
+          ops.miss(i, probe);
+          break;
+        }
+        bucketIdx = (bucketIdx + 1) & sizeMask;
+      }
+    done:;
+    }
+  }
+
+  template <typename RowType, typename Ops>
+  void __device__ updatingProbe(HashProbe* probe, Ops ops) {
+    extern __shared__ __align__(16) char smem[];
+    auto* sharedState = reinterpret_cast<ProbeShared*>(smem);
+    if (threadIdx.x == 0) {
+      sharedState->init(probe, ops.blockBase(probe));
+    }
+    __syncthreads();
+    auto lane = cub::LaneId();
+    constexpr int32_t kWarpThreads = 1 << CUB_LOG_WARP_THREADS(0);
+    auto warp = threadIdx.x / kWarpThreads;
+    int32_t end = ops.numRowsInBlock(probe) + sharedState->blockBase;
+    for (auto i = threadIdx.x + sharedState->blockBase; i < end;
+         i += blockDim.x) {
+      auto start = i & ~(kWarpThreads - 1);
+      uint32_t laneMask =
+          start + kWarpThreads <= end ? ~0 : lowMask<uint32_t>(end - start);
+      auto h = ops.hash(i, probe);
+      uint32_t tagWord = hashTag(h);
+      tagWord |= tagWord << 8;
+      tagWord = tagWord | tagWord << 16;
+      auto bucketIdx = h & sizeMask;
+      uint32_t misses = 0;
+      RowType* hit = nullptr;
+      RowType* toInsert = nullptr;
+      int32_t hitIdx;
+      GpuBucket* bucket;
+      uint32_t tags;
+      for (;;) {
+        bucket = buckets + bucketIdx;
+      reprobe:
+        tags = asDeviceAtomic<uint32_t>(&bucket->tags)
+                   ->load(cuda::memory_order_consume);
+        auto hits = __vcmpeq4(tags, tagWord) & 0x01010101;
+        while (hits) {
+          hitIdx = (__ffs(hits) - 1) / 8;
+          auto candidate = bucket->loadWithWait<RowType>(hitIdx);
+          if (ops.compare(this, candidate, i, probe)) {
+            if (toInsert) {
+              freeInsertable(toInsert, h);
+            }
+            hit = candidate;
+            break;
+          }
+          hits = hits & (hits - 1);
+        }
+        if (hit) {
+          break;
+        }
+        misses = __vcmpeq4(tags, 0);
+        if (misses) {
+          auto success = ops.insert(
+              this,
+              partitionIdx(h),
+              bucket,
+              misses,
+              tags,
+              tagWord,
+              i,
+              probe,
+              toInsert);
+          if (success == ProbeState::kRetry) {
+            goto reprobe;
+          }
+          if (success == ProbeState::kNeedSpace) {
+            addHostRetry(sharedState, i, probe);
+          }
+          hit = toInsert;
+          break;
+        }
+        bucketIdx = (bucketIdx + 1) & sizeMask;
+      }
+      // Every lane has a hit, or a nullptr if out of space.
+      uint32_t peers =
+          __match_any_sync(laneMask, reinterpret_cast<int64_t>(hit));
+      if (hit) {
+        int32_t leader = (kWarpThreads - 1) - __clz(peers);
+        RowType* writable = nullptr;
+        if (lane == leader) {
+          writable = ops.getExclusive(this, bucket, hit, hitIdx, warp);
+        }
+        auto toUpdate = peers;
+        ProbeState success = ProbeState::kDone;
+        while (toUpdate) {
+          auto peer = __ffs(toUpdate) - 1;
+          auto idxToUpdate = __shfl_sync(peers, i, peer);
+          if (lane == leader) {
+            if (success == ProbeState::kDone) {
+              success = ops.update(this, bucket, writable, idxToUpdate, probe);
+            }
+            if (success == ProbeState::kNeedSpace) {
+              addHostRetry(sharedState, idxToUpdate, probe);
+            }
+            if (success != ProbeState::kDone) {
+              printf("");
+            }
+          }
+          toUpdate &= toUpdate - 1;
+        }
+        if (lane == leader) {
+          ops.writeDone(writable);
+        }
+      } else {
+        printf("");
+      }
+    }
+  }
+
+  template <typename RowType>
+  void __device__ freeInsertable(RowType*& row, uint64_t h) {
+    allocators[partitionIdx(h)].freeRow(row);
+    row = nullptr;
+  }
+
+  int32_t __device__ partitionIdx(uint64_t h) const {
+    return (h & partitionMask) >> partitionShift;
+  }
+
+ private:
+  static void __device__
+  addHostRetry(ProbeShared* shared, int32_t i, HashProbe* probe) {
+    probe->hostRetries
+        [shared->blockBase + atomicAdd(&shared->numHostRetries, 1)] = i;
+  }
+};
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/HashTable.h b/velox/experimental/wave/common/HashTable.h
new file mode 100644
index 0000000000000..54dec795bb3d2
--- /dev/null
+++ b/velox/experimental/wave/common/HashTable.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+/// Structs for tagged GPU hash table. Can be inclued in both Velox .cpp and
+/// .cu.
+namespace facebook::velox::wave {
+
+/// A 32 byte tagged bucket with 4 tags, 4 flag bytes and 4 6-byte
+/// pointers. Fits in one 32 byte GPU cache sector.
+struct GpuBucketMembers {
+  uint32_t tags;
+  uint32_t flags;
+  uint16_t data[12];
+
+  template <typename T>
+  T* testingLoad(int32_t idx) {
+    auto uptr = static_cast<uint64_t>(data[8 + idx]) << 32;
+    uptr |= reinterpret_cast<uint32_t*>(data)[idx];
+    return reinterpret_cast<T*>(uptr);
+  }
+};
+
+template <typename T, int32_t kSize>
+class FreeSetBase {
+  int32_t full_{0};
+  int32_t empty_{1};
+  unsigned long long bits_[kSize / 64] = {};
+  T items_[kSize] = {};
+};
+
+/// A device arena for device side allocation.
+struct HashPartitionAllocator {
+  static constexpr uint32_t kEmpty = ~0;
+
+  HashPartitionAllocator(
+      char* data,
+      uint32_t size,
+      uint32_t rowSize,
+      void* freeSet)
+      : rowSize(rowSize),
+        base(reinterpret_cast<uint64_t>(data)),
+        capacity(size),
+        stringOffset(capacity),
+        freeSet(freeSet) {}
+
+  const int32_t rowSize{0};
+  const uint64_t base{0};
+  uint32_t rowOffset{0};
+  const uint32_t capacity{0};
+  uint32_t stringOffset{0};
+  void* freeSet{nullptr};
+  int32_t numFromFree{0};
+  int32_t numFull{0};
+};
+
+/// Implementation of HashPartitionAllocator, defined in .cuh.
+struct RowAllocator;
+
+enum class ProbeState : uint8_t { kDone, kMoreValues, kNeedSpace, kRetry };
+
+/// Operands for one TB of hash probe.
+struct HashProbe {
+  /// The number of input rows processed by each thread of a TB. The base index
+  /// for a block in the arrays in 'this' is 'numRowsPerThread * blockDim.x *
+  /// blockIdx.x'
+  int32_t numRowsPerThread{1};
+
+  /// Count of probe keys for each TB. Subscript is blockIdx.x.
+  int32_t* numRows;
+
+  /// Data for probe keys. To be interpreted by Ops of the probe, no
+  /// fixed format.
+  void* keys;
+
+  /// Hash numbers for probe keys.
+  uint64_t* hashes;
+
+  /// List of input rows to retry in kernel. Sized to one per row of
+  /// input. Used inside kernel, not meaningful after return. Sample
+  /// use case is another warp updating the same row.
+  int32_t* kernelRetries1;
+  int32_t* kernelRetries2;
+
+  /// List of input rows to retry after host updated state. Sized to
+  /// one per row of input. The reason for a host side retry is
+  /// needing more space. The host will decide to allocate/spill/error
+  /// out.
+  int32_t* hostRetries;
+
+  /// Count of valid items in 'hostRetries'. The subscript is blockIdx.x.
+  int32_t* numHostRetries;
+
+  /// Space in 'hits' and 'hitRows'. Should be a multiple of probe block width.
+  int32_t maxHits{0};
+
+  /// Row numbers for hits. Indices into 'hashes'.
+  int32_t* hitRows{nullptr};
+
+  // Optional payload rows hitting from a probe.
+  void** hits{nullptr};
+};
+
+struct GpuBucket;
+
+struct GpuHashTableBase {
+  /// Bucket array. Size is 'sizeMask + 1'.
+  GpuBucket* buckets{nullptr};
+
+  // Mask to extract index into 'buckets' from a hash number. a
+  // sizemask of 63 means 64 buckets, which is up to 256 entries.
+  uint32_t sizeMask;
+
+  // Translates a hash number to a partition number '(hash &
+  // partitionMask) >> partitionShift' is a partition number used as
+  // a physical partition of the table. Used as index into 'allocators'.
+  uint32_t partitionMask{0};
+  uint8_t partitionShift{0};
+
+  /// A RowAllocator for each partition.
+  RowAllocator* allocators;
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/ResultStaging.cpp b/velox/experimental/wave/common/ResultStaging.cpp
new file mode 100644
index 0000000000000..285e57fab435c
--- /dev/null
+++ b/velox/experimental/wave/common/ResultStaging.cpp
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/common/ResultStaging.h"
+#include "velox/common/base/BitUtil.h"
+#include "velox/experimental/wave/common/GpuArena.h"
+
+namespace facebook::velox::wave {
+
+BufferId ResultStaging::reserve(int32_t bytes) {
+  offsets_.push_back(fill_);
+  fill_ += bits::roundUp(bytes, 8);
+  return offsets_.size() - 1;
+}
+
+void ResultStaging::registerPointerInternal(
+    BufferId id,
+    void** pointer,
+    bool clear) {
+  VELOX_CHECK_LT(id, offsets_.size());
+  VELOX_CHECK_NOT_NULL(pointer);
+#if 0 // ndef NDEBUG
+  for (auto& pair : patch_) {
+    VELOX_CHECK(
+        pair.second != pointer, "Must not register the same pointer twice");
+  }
+#endif
+  if (clear) {
+    *pointer = nullptr;
+  }
+  patch_.push_back(std::make_pair(id, pointer));
+}
+
+void ResultStaging::makeDeviceBuffer(GpuArena& arena) {
+  if (fill_ == 0) {
+    return;
+  }
+  WaveBufferPtr buffer = arena.allocate<char>(fill_);
+  auto address = reinterpret_cast<int64_t>(buffer->as<char>());
+  // Patch all the registered pointers to point to buffer at offset offset_[id]
+  // + the offset already in the registered pointer.
+  for (auto& pair : patch_) {
+    int64_t* pointer = reinterpret_cast<int64_t*>(pair.second);
+    *pointer += address + offsets_[pair.first];
+  }
+  patch_.clear();
+  offsets_.clear();
+  fill_ = 0;
+  buffers_.push_back(std::move(buffer));
+}
+
+void ResultStaging::setReturnBuffer(GpuArena& arena, ResultBuffer& result) {
+  if (fill_ == 0) {
+    result.result = nullptr;
+    result.hostResult = nullptr;
+    return;
+  }
+  result.result = arena.allocate<char>(fill_);
+  auto address = reinterpret_cast<int64_t>(result.result->as<char>());
+  // Patch all the registered pointers to point to buffer at offset offset_[id]
+  // + the offset already in the registered pointer.
+  for (auto& pair : patch_) {
+    int64_t* pointer = reinterpret_cast<int64_t*>(pair.second);
+    *pointer += address + offsets_[pair.first];
+  }
+  patch_.clear();
+  offsets_.clear();
+  fill_ = 0;
+}
+
+GpuArena& getSmallTransferArena() {
+  static std::unique_ptr<GpuArena> arena = std::make_unique<GpuArena>(
+      10UL << 20, getHostAllocator(nullptr), 20UL << 20);
+  return *arena;
+}
+
+std::pair<char*, char*> LaunchParams::setup(size_t size) {
+  if (!arena.isDevice()) {
+    // Unified memory.
+    device = arena.allocate<char>(size);
+    return {device->as<char>(), device->as<char>()};
+  } else {
+    // Separate host and device side buffers.
+    device = arena.allocate<char>(size);
+    host = getSmallTransferArena().allocate<char>(size);
+    return {host->as<char>(), device->as<char>()};
+  }
+}
+
+void LaunchParams::transfer(Stream& stream) {
+  if (device) {
+    if (arena.isDevice()) {
+      stream.hostToDeviceAsync(
+          device->as<char>(), host->as<char>(), host->size());
+    } else {
+      stream.prefetch(getDevice(), device->as<char>(), device->size());
+    }
+  }
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/ResultStaging.h b/velox/experimental/wave/common/ResultStaging.h
new file mode 100644
index 0000000000000..35077071aae17
--- /dev/null
+++ b/velox/experimental/wave/common/ResultStaging.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <vector>
+
+#include "velox/experimental/wave/common/Buffer.h"
+#include "velox/experimental/wave/common/Cuda.h"
+
+namespace facebook::velox::wave {
+
+struct ResultBuffer {
+  void clear() {
+    result = nullptr;
+    hostResult = nullptr;
+  }
+
+  void transfer(Stream& stream) const {
+    if (result) {
+      if (!hostResult) {
+        stream.prefetch(nullptr, result->as<char>(), result->size());
+      } else {
+        stream.deviceToHostAsync(
+            hostResult->as<char>(), result->as<char>(), hostResult->size());
+      }
+    }
+  }
+
+  WaveBufferPtr result;
+  WaveBufferPtr hostResult;
+};
+
+using BufferId = int32_t;
+constexpr BufferId kNoBufferId = -1;
+
+class ResultStaging {
+ public:
+  /// Reserves 'bytes' bytes in result buffer to be brought to host after
+  /// the next kernel completes on device. The caller of the kernel calls
+  /// transfer().
+  BufferId reserve(int32_t bytes);
+
+  /// Registers '*pointer' to be patched to the buffer. The starting address of
+  /// the buffer is added to *pointer, so that if *pointer was 16, *pointer will
+  /// come to point to the 16th byte in the buffer. If 'clear' is true, *ptr is
+  /// set to nullptr first.
+  template <typename T>
+  void registerPointer(BufferId id, T pointer, bool clear) {
+    registerPointerInternal(
+        id,
+        reinterpret_cast<void**>(reinterpret_cast<uint64_t>(pointer)),
+        clear);
+  }
+
+  /// Creates a device side buffer for the reserved space and patches all the
+  /// registered pointers to offsets inside the device side buffer.  Retains
+  /// ownership of the device side buffer. Clears any reservations and
+  /// registrations so that new ones can be reserved and registered. This cycle
+  /// may repeat multiple times.  The device side buffers are freed on
+  /// destruction.
+  void makeDeviceBuffer(GpuArena& arena);
+
+  void setReturnBuffer(GpuArena& arena, ResultBuffer& result);
+
+ private:
+  void registerPointerInternal(BufferId id, void** pointer, bool clear);
+
+  // Offset of each result in either buffer.
+  std::vector<int32_t> offsets_;
+  // Patch addresses. The int64_t* is updated to point to the result buffer once
+  // it is allocated.
+  std::vector<std::pair<int32_t, void**>> patch_;
+  int32_t fill_{0};
+  WaveBufferPtr deviceBuffer_;
+  WaveBufferPtr hostBuffer_;
+  std::vector<WaveBufferPtr> buffers_;
+};
+
+/// Manages parameters of kernel launch. Provides pinned host buffer and a
+/// device side copy destination.
+struct LaunchParams {
+  LaunchParams(GpuArena& arena) : arena(arena) {}
+
+  /// Returns a host, device address pair of 'size' bytes.
+  std::pair<char*, char*> setup(size_t size);
+
+  void transfer(Stream& stream);
+
+  GpuArena& arena;
+  WaveBufferPtr host;
+  WaveBufferPtr device;
+};
+
+// Arena for decode and program launch param blocks. Lifetime of allocations is
+// a wave in WaveStream, typical size under 1MB, e.g. 1K blocks with 1K of
+// params.
+GpuArena& getSmallTransferArena();
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/BlockTest.cpp b/velox/experimental/wave/common/tests/BlockTest.cpp
index 6c6d8b20f2f43..3308e394ec641 100644
--- a/velox/experimental/wave/common/tests/BlockTest.cpp
+++ b/velox/experimental/wave/common/tests/BlockTest.cpp
@@ -24,9 +24,20 @@
 #include "velox/experimental/wave/common/GpuArena.h"
 #include "velox/experimental/wave/common/tests/BlockTest.h"
 
+#include <folly/Random.h>
+
 using namespace facebook::velox;
 using namespace facebook::velox::wave;
 
+constexpr int32_t kNumPartitionBlocks = 100;
+struct PartitionRun {
+  uint16_t* keys[kNumPartitionBlocks];
+  int32_t numRows[kNumPartitionBlocks];
+  int32_t* ranks[kNumPartitionBlocks];
+  int32_t* partitionStarts[kNumPartitionBlocks];
+  int32_t* partitionedRows[kNumPartitionBlocks];
+};
+
 class BlockTest : public testing::Test {
  protected:
   void SetUp() override {
@@ -39,6 +50,259 @@ class BlockTest : public testing::Test {
   void prefetch(Stream& stream, WaveBufferPtr buffer) {
     stream.prefetch(device_, buffer->as<char>(), buffer->capacity());
   }
+  void testBoolToIndices(bool use256) {
+    /// We make a set of 256 flags and corresponding 256 indices of true flags.
+    constexpr int32_t kNumBlocks = 20480;
+    constexpr int32_t kBlockSize = 256;
+    constexpr int32_t kNumFlags = kBlockSize * kNumBlocks;
+    auto flagsBuffer = arena_->allocate<uint8_t>(kNumFlags);
+    auto indicesBuffer = arena_->allocate<int32_t>(kNumFlags);
+    auto sizesBuffer = arena_->allocate<int32_t>(kNumBlocks);
+    BlockTestStream stream;
+
+    std::vector<int32_t> referenceIndices(kNumFlags);
+    std::vector<int32_t> referenceSizes(kNumBlocks);
+    uint8_t* flags = flagsBuffer->as<uint8_t>();
+    for (auto i = 0ul; i < kNumFlags; ++i) {
+      if ((i >> 8) % 17 == 0) {
+        flags[i] = 0;
+      } else if ((i >> 8) % 23 == 0) {
+        flags[i] = 1;
+      } else {
+        flags[i] = (i * 1121) % 73 > 50;
+      }
+    }
+    for (auto b = 0; b < kNumBlocks; ++b) {
+      auto start = b * kBlockSize;
+      int32_t counter = start;
+      for (auto i = 0; i < kBlockSize; ++i) {
+        if (flags[start + i]) {
+          referenceIndices[counter++] = start + i;
+        }
+      }
+      referenceSizes[b] = counter - start;
+    }
+
+    prefetch(stream, flagsBuffer);
+    prefetch(stream, indicesBuffer);
+    prefetch(stream, sizesBuffer);
+    stream.wait();
+    auto indicesPointers = arena_->allocate<void*>(kNumBlocks);
+    auto flagsPointers = arena_->allocate<void*>(kNumBlocks);
+    for (auto i = 0; i < kNumBlocks; ++i) {
+      flagsPointers->as<uint8_t*>()[i] = flags + (i * kBlockSize);
+      indicesPointers->as<int32_t*>()[i] =
+          indicesBuffer->as<int32_t>() + (i * kBlockSize);
+    }
+
+    prefetch(stream, flagsBuffer);
+    prefetch(stream, indicesBuffer);
+    prefetch(stream, sizesBuffer);
+    stream.wait();
+    auto startMicros = getCurrentTimeMicro();
+    if (use256) {
+      stream.testBool256ToIndices(
+          kNumBlocks,
+          flagsPointers->as<uint8_t*>(),
+          indicesPointers->as<int32_t*>(),
+          sizesBuffer->as<int32_t>());
+
+    } else {
+      stream.testBoolToIndices(
+          kNumBlocks,
+          flagsPointers->as<uint8_t*>(),
+          indicesPointers->as<int32_t*>(),
+          sizesBuffer->as<int32_t>());
+    }
+    stream.wait();
+    auto elapsed = getCurrentTimeMicro() - startMicros;
+    for (auto b = 0; b < kNumBlocks; ++b) {
+      auto* reference = referenceIndices.data() + b * kBlockSize;
+      auto* actual = indicesBuffer->as<int32_t>() + b * kBlockSize;
+      auto* referenceSizesData = referenceSizes.data();
+      auto* actualSizes = sizesBuffer->as<int32_t>();
+      ASSERT_EQ(
+          0, ::memcmp(reference, actual, referenceSizes[b] * sizeof(int32_t)));
+      ASSERT_EQ(referenceSizesData[b], actualSizes[b]);
+    }
+    std::cout << "Flags " << (use256 ? "256" : "") << " to indices: " << elapsed
+              << "us, " << kNumFlags / static_cast<float>(elapsed) << " Mrows/s"
+              << std::endl;
+
+    auto temp = arena_->allocate<char>(
+        BlockTestStream::boolToIndicesSize() * kNumBlocks);
+    prefetch(stream, temp);
+    prefetch(stream, flagsBuffer);
+    prefetch(stream, indicesBuffer);
+    prefetch(stream, sizesBuffer);
+    stream.wait();
+
+    startMicros = getCurrentTimeMicro();
+    if (use256) {
+      stream.testBool256ToIndicesNoShared(
+          kNumBlocks,
+          flagsPointers->as<uint8_t*>(),
+          indicesPointers->as<int32_t*>(),
+          sizesBuffer->as<int32_t>(),
+          temp->as<char>());
+    } else {
+      stream.testBoolToIndicesNoShared(
+          kNumBlocks,
+          flagsPointers->as<uint8_t*>(),
+          indicesPointers->as<int32_t*>(),
+          sizesBuffer->as<int32_t>(),
+          temp->as<char>());
+    }
+    stream.wait();
+    elapsed = getCurrentTimeMicro() - startMicros;
+    std::cout << "Flags " << (use256 ? "256" : "")
+              << " to indices: " << " to indices no smem: " << elapsed << "us, "
+              << kNumFlags / static_cast<float>(elapsed) << " Mrows/s"
+              << std::endl;
+  }
+
+  void makePartitionRun(
+      int32_t numRows,
+      int32_t numPartitions,
+      PartitionRun*& run,
+      WaveBufferPtr& buffer) {
+    auto rowsRounded = bits::roundUp(numRows, 8);
+    auto partitionsRounded = bits::roundUp(numPartitions, 8);
+    int64_t bytes = sizeof(PartitionRun) +
+        kNumPartitionBlocks *
+            (rowsRounded * sizeof(int32_t) * 4 +
+             partitionsRounded * sizeof(int32_t));
+    if (!buffer || buffer->capacity() < bytes) {
+      buffer = arena_->allocate<char>(bytes);
+    }
+    run = buffer->as<PartitionRun>();
+    auto chars = buffer->as<char>() + sizeof(PartitionRun);
+    for (auto block = 0; block < kNumPartitionBlocks; ++block) {
+      run->keys[block] = reinterpret_cast<uint16_t*>(chars);
+      run->numRows[block] = numRows;
+      chars += rowsRounded * sizeof(uint16_t);
+      run->partitionStarts[block] = reinterpret_cast<int32_t*>(chars);
+      chars += numPartitions * sizeof(int32_t);
+      run->ranks[block] = reinterpret_cast<int32_t*>(chars);
+      chars += sizeof(int32_t) * numRows;
+      run->partitionedRows[block] = reinterpret_cast<int32_t*>(chars);
+      chars += sizeof(int32_t) * numRows;
+      for (auto i = 0; i < numRows; ++i) {
+        run->keys[block][i] = (block + i * 2017) % numPartitions;
+      }
+    }
+    VELOX_CHECK_LE(chars - buffer->as<char>(), bytes);
+  }
+
+  void checkPartitionRun(const PartitionRun& run, int32_t numPartitions) {
+    // Check that every row is once in its proper partition.
+    for (auto block = 0; block < kNumPartitionBlocks; ++block) {
+      std::vector<bool> flags(run.numRows[block], false);
+      for (auto part = 0; part < numPartitions; ++part) {
+        for (auto i = (part == 0 ? 0 : run.partitionStarts[block][part - 1]);
+             i < run.partitionStarts[block][part];
+             ++i) {
+          auto row = run.partitionedRows[block][i];
+          EXPECT_LT(row, run.numRows[block]);
+          EXPECT_FALSE(flags[row]);
+          EXPECT_EQ(part, run.keys[block][row]);
+          flags[row] = true;
+        }
+      }
+      // Expect that all flags are set.
+      for (auto i = 0; i < run.numRows[block]; ++i) {
+        EXPECT_TRUE(flags[i]);
+      }
+    }
+  }
+
+  void scatterBitsTest(int32_t numBits, int32_t setPct, bool useSmem = false) {
+    auto numWords = bits::nwords(numBits);
+    auto maskBuffer = arena_->allocate<uint64_t>(numWords);
+    auto sourceBuffer = arena_->allocate<uint64_t>(numWords + 1);
+    auto resultBuffer = arena_->allocate<uint64_t>(numWords);
+    auto smemBuffer = arena_->allocate<uint32_t>(
+        BlockTestStream::scatterBitsSize(256) / sizeof(int32_t));
+    VELOX_CHECK_LE(1000, numBits);
+    memset(maskBuffer->as<char>(), 0, maskBuffer->capacity());
+    BlockTestStream stream;
+
+    auto maskData = maskBuffer->as<uint64_t>();
+    folly::Random::DefaultGenerator rng;
+    rng.seed(1);
+    for (auto bit = 0; bit < numBits; ++bit) {
+      if (folly::Random::rand32(rng) % 100 < setPct) {
+        bits::setBit(maskData, bit);
+      }
+    }
+    // Ranges of tens of set and unset bits.
+    bits::fillBits(maskData, numBits - 130, numBits - 2, true);
+    bits::fillBits(maskData, numBits - 601, numBits - 403, true);
+
+    // Range of mostly set bits, 1/50 is not set.
+    for (auto bit = numBits - 1000; bit > 400; --bit) {
+      if (folly::Random::rand32(rng) % 50) {
+        bits::setBit(maskData, bit);
+      }
+    }
+    // Alternating groups of 5 bits with 0-3 bis set.
+    for (auto i = 0; i < 305; i += 5) {
+      auto numSet = (i / 5) % 4;
+      for (auto j = 0; j < numSet; ++j) {
+        bits::setBit(maskData, i + j, true);
+      }
+    }
+
+    auto numInMask = bits::countBits(maskData, 0, numBits);
+    auto* source = sourceBuffer->as<uint64_t>();
+    uint64_t seed = 0x123456789abcdef0LL;
+    for (auto i = 0; i < numWords; ++i) {
+      source[i] = seed;
+      seed *= 0x5cdf;
+    }
+    std::vector<uint64_t> reference(numWords);
+    auto sourceAsChar = sourceBuffer->as<char>() + 1;
+    uint64_t cpuTime = 0;
+    {
+      MicrosecondTimer t(&cpuTime);
+      bits::scatterBits(
+          numInMask,
+          numBits,
+          sourceAsChar,
+          maskData,
+          reinterpret_cast<char*>(reference.data()));
+    }
+    prefetch(stream, maskBuffer);
+    prefetch(stream, resultBuffer);
+    prefetch(stream, smemBuffer);
+    prefetch(stream, sourceBuffer);
+    stream.wait();
+    uint64_t gpuTime = 0;
+    {
+      MicrosecondTimer t(&gpuTime);
+      stream.scatterBits(
+          numInMask,
+          numBits,
+          sourceAsChar,
+          maskData,
+          resultBuffer->as<char>(),
+          smemBuffer->as<int32_t>());
+      stream.wait();
+    }
+    auto resultAsChar = resultBuffer->as<char>();
+    for (int32_t i = 0; i < numBits; ++i) {
+      EXPECT_EQ(
+          bits::isBitSet(reference.data(), i), bits::isBitSet(resultAsChar, i));
+    }
+
+    std::cout << fmt::format(
+                     "scatterBits {} {}% set: cpu1t {} Mb/s gpu256t {} Mb/s",
+                     numBits,
+                     setPct,
+                     numBits / static_cast<float>(cpuTime),
+                     numBits / static_cast<float>(gpuTime))
+              << std::endl;
+  }
 
   Device* device_;
   GpuAllocator* allocator_;
@@ -46,70 +310,211 @@ class BlockTest : public testing::Test {
 };
 
 TEST_F(BlockTest, boolToIndices) {
-  /// We make a set of 256 flags and corresponding 256 indices of true flags.
-  constexpr int32_t kNumBlocks = 20480;
-  constexpr int32_t kBlockSize = 256;
-  constexpr int32_t kNumFlags = kBlockSize * kNumBlocks;
-  auto flagsBuffer = arena_->allocate<uint8_t>(kNumFlags);
-  auto indicesBuffer = arena_->allocate<int32_t>(kNumFlags);
-  auto sizesBuffer = arena_->allocate<int32_t>(kNumBlocks);
-  auto timesBuffer = arena_->allocate<int64_t>(kNumBlocks);
+  testBoolToIndices(false);
+  testBoolToIndices(true);
+}
+
+TEST_F(BlockTest, shortRadixSort) {
+  // We make a set of 8K uint16_t keys  and uint16_t values.
+  constexpr int32_t kNumBlocks = 1024;
+  constexpr int32_t kBlockSize = 1024;
+  constexpr int32_t kValuesPerThread = 8;
+  constexpr int32_t kValuesPerBlock = kBlockSize * kValuesPerThread;
+  constexpr int32_t kNumValues = kBlockSize * kNumBlocks * kValuesPerThread;
+  auto keysBuffer = arena_->allocate<uint16_t>(kNumValues);
+  auto valuesBuffer = arena_->allocate<int16_t>(kNumValues);
   BlockTestStream stream;
 
-  std::vector<int32_t> referenceIndices(kNumFlags);
-  std::vector<int32_t> referenceSizes(kNumBlocks);
-  uint8_t* flags = flagsBuffer->as<uint8_t>();
-  for (auto i = 0; i < kNumFlags; ++i) {
-    if ((i >> 8) % 17 == 0) {
-      flags[i] = 0;
-    } else if ((i >> 8) % 23 == 0) {
-      flags[i] = 1;
-    } else {
-      flags[i] = (i * 1121) % 73 > 50;
-    }
+  std::vector<uint16_t> referenceKeys(kNumValues);
+  std::vector<uint16_t> referenceValues(kNumValues);
+  uint16_t* keys = keysBuffer->as<uint16_t>();
+  uint16_t* values = valuesBuffer->as<uint16_t>();
+  for (auto i = 0; i < kNumValues; ++i) {
+    keys[i] = i * 2017;
+    values[i] = i;
   }
+
   for (auto b = 0; b < kNumBlocks; ++b) {
-    auto start = b * kBlockSize;
-    int32_t counter = start;
-    for (auto i = 0; i < kBlockSize; ++i) {
-      if (flags[start + i]) {
-        referenceIndices[counter++] = start + i;
-      }
+    auto start = b * kValuesPerBlock;
+    std::vector<uint16_t> indices(kValuesPerBlock);
+    std::iota(indices.begin(), indices.end(), 0);
+    std::sort(indices.begin(), indices.end(), [&](auto left, auto right) {
+      return keys[start + left] < keys[start + right];
+    });
+    for (auto i = 0; i < kValuesPerBlock; ++i) {
+      referenceValues[start + i] = values[start + indices[i]];
     }
-    referenceSizes[b] = counter - start;
   }
 
-  prefetch(stream, flagsBuffer);
-  prefetch(stream, indicesBuffer);
-  prefetch(stream, sizesBuffer);
+  prefetch(stream, valuesBuffer);
+  prefetch(stream, keysBuffer);
 
-  auto indicesPointers = arena_->allocate<void*>(kNumBlocks);
-  auto flagsPointers = arena_->allocate<void*>(kNumBlocks);
+  auto keysPointers = arena_->allocate<void*>(kNumBlocks);
+  auto valuesPointers = arena_->allocate<void*>(kNumBlocks);
   for (auto i = 0; i < kNumBlocks; ++i) {
-    flagsPointers->as<uint8_t*>()[i] = flags + (i * kBlockSize);
-    indicesPointers->as<int32_t*>()[i] =
-        indicesBuffer->as<int32_t>() + (i * kBlockSize);
+    keysPointers->as<uint16_t*>()[i] = keys + (i * kValuesPerBlock);
+    valuesPointers->as<uint16_t*>()[i] =
+        valuesBuffer->as<uint16_t>() + (i * kValuesPerBlock);
   }
-
+  auto keySegments = keysPointers->as<uint16_t*>();
+  auto valueSegments = valuesPointers->as<uint16_t*>();
+  prefetch(stream, keysPointers);
+  prefetch(stream, valuesPointers);
+  stream.wait();
   auto startMicros = getCurrentTimeMicro();
-  stream.testBoolToIndices(
-      kNumBlocks,
-      flagsPointers->as<uint8_t*>(),
-      indicesPointers->as<int32_t*>(),
-      sizesBuffer->as<int32_t>(),
-      timesBuffer->as<int64_t>());
+  stream.testSort16(kNumBlocks, keySegments, valueSegments);
   stream.wait();
   auto elapsed = getCurrentTimeMicro() - startMicros;
   for (auto b = 0; b < kNumBlocks; ++b) {
     ASSERT_EQ(
         0,
         ::memcmp(
-            referenceIndices.data() + b * kBlockSize,
-            indicesBuffer->as<int32_t>() + b * kBlockSize,
-            referenceSizes[b] * sizeof(int32_t)));
-    ASSERT_EQ(referenceSizes[b], sizesBuffer->as<int32_t>()[b]);
+            referenceValues.data() + b * kValuesPerBlock,
+            valueSegments[b],
+            kValuesPerBlock * sizeof(uint16_t)));
+  }
+  std::cout << "sort16: " << elapsed << "us, "
+            << kNumValues / static_cast<float>(elapsed) << " Mrows/s"
+            << std::endl;
+
+  // Reset the test values for second test.
+  for (auto i = 0; i < kNumValues; ++i) {
+    keys[i] = i * 2017;
+    values[i] = i;
   }
-  std::cout << "Flags to indices: " << elapsed << "us, "
-            << kNumFlags / static_cast<float>(elapsed) << " Mrows/s"
+  auto temp =
+      arena_->allocate<char>(kNumBlocks * BlockTestStream::sort16SharedSize());
+  prefetch(stream, temp);
+  prefetch(stream, valuesBuffer);
+  prefetch(stream, keysBuffer);
+  prefetch(stream, keysPointers);
+  prefetch(stream, valuesPointers);
+  stream.wait();
+  startMicros = getCurrentTimeMicro();
+  stream.testSort16NoShared(
+      kNumBlocks, keySegments, valueSegments, temp->as<char>());
+  stream.wait();
+  elapsed = getCurrentTimeMicro() - startMicros;
+  std::cout << "sort16 no shared: " << elapsed << "us, "
+            << kNumValues / static_cast<float>(elapsed) << " Mrows/s"
             << std::endl;
 }
+
+TEST_F(BlockTest, partition) {
+  // We make severl sets of keys and temp and result buffers. These
+  // are in unified memory. We run the partition for all and check the
+  // outcome on the host. We run at several different partition counts
+  // and batch sizes. All experiments are submitted as kNumPartitionBlocks
+  // concurrent thread blocks of 256 threads.
+  BlockTestStream stream;
+  std::vector<int32_t> partitionCounts = {1, 2, 32, 333, 1000, 8000};
+  std::vector<int32_t> runSizes = {100, 1000, 10000, 30000};
+  WaveBufferPtr buffer;
+  PartitionRun* run;
+  for (auto parts : partitionCounts) {
+    for (auto rows : runSizes) {
+      makePartitionRun(rows, parts, run, buffer);
+      prefetch(stream, buffer);
+      auto startMicros = getCurrentTimeMicro();
+      stream.partitionShorts(
+          kNumPartitionBlocks,
+          run->keys,
+          run->numRows,
+          parts,
+          run->ranks,
+          run->partitionStarts,
+          run->partitionedRows);
+      stream.wait();
+      auto time = getCurrentTimeMicro() - startMicros;
+      std::cout << fmt::format(
+                       "Partition {} batch={}  fanout={}  rate={} Mrows/s",
+                       kNumPartitionBlocks,
+                       rows,
+                       parts,
+                       kNumPartitionBlocks * static_cast<float>(rows) / time)
+                << std::endl;
+      checkPartitionRun(*run, parts);
+    }
+  }
+}
+
+TEST_F(BlockTest, scatterBits) {
+  scatterBitsTest(1999, 0);
+  scatterBitsTest(1999, 100);
+  scatterBitsTest(1999, 42);
+  scatterBitsTest(1999, 96);
+  scatterBitsTest(12345999, 0);
+  scatterBitsTest(12345999, 100);
+  scatterBitsTest(12345999, 42);
+  scatterBitsTest(12345999, 96);
+}
+
+TEST_F(BlockTest, nonNull) {
+  constexpr int32_t kNumRows = 4 << 20;
+  WaveBufferPtr nullsBuffer =
+      arena_->allocate<uint64_t>(bits::nwords(kNumRows));
+  WaveBufferPtr indicesBuffer = arena_->allocate<int32_t>(kNumRows);
+  WaveBufferPtr rowsBuffer = arena_->allocate<int32_t>(kNumRows);
+  WaveBufferPtr temp = arena_->allocate<int32_t>(1000);
+  auto nulls = nullsBuffer->as<uint64_t>();
+  const char* text =
+      "les loopiettes, les loopiettes, comme elles sont chouettes"
+      " parfois ci, parfois ca, parfois tu 'l sais pas";
+  auto len = strlen(text) - 8;
+  for (auto i = 0; i < kNumRows; i += 4096) {
+    // Every run of 4096 bits, i.e. 64 words has 16 nulls, 16 nonnulls and 32
+    // mostly nonn-nulls.
+    auto run = nulls + (i / 64);
+    memset(run, 0, 128);
+    memset(run + 16, 0xff, 128);
+    for (auto j = 32; j < 64; ++j) {
+      run[j] = bits::hashMix(
+                   1, *reinterpret_cast<const int64_t*>(text + (j % len))) |
+          bits::hashMix(
+                   0x1008, *reinterpret_cast<const int64_t*>(text + (i % len)));
+    }
+  }
+  // Add a single non-null before the first accessed row.
+  nulls[0] |= 1;
+  auto rows = rowsBuffer->as<int32_t>();
+  int32_t row = 2;
+  int32_t numRows = 0;
+  bool dense = true;
+  while (row < kNumRows) {
+    rows[numRows++] = row;
+
+    if (dense) {
+      ++row;
+    } else {
+      row += 1 + (numRows % 9) + (numRows % 111 == 0 ? 131 : 0);
+    }
+    if (numRows % 611 == 0) {
+      dense = !dense;
+    }
+  }
+
+  int32_t count = 0;
+  int32_t counted = 0;
+  auto nullsBelow = [&](int32_t i) {
+    count += bits::countBits(nulls, counted, i);
+    counted = i;
+    return i - count;
+  };
+
+  auto result = indicesBuffer->as<int32_t>();
+  auto rawTemp = temp->as<int32_t>();
+  BlockTestStream stream;
+  stream.nonNullIndex(
+      reinterpret_cast<char*>(nulls), rows, numRows, result, rawTemp);
+  stream.wait();
+  for (auto i = 0; i < numRows; ++i) {
+    if (result[i] == -1) {
+      ASSERT_FALSE(bits::isBitSet(nulls, rows[i]))
+          << "i=" << i << " rows[i]=" << rows[i];
+    } else {
+      ASSERT_EQ(result[i], rows[i] - nullsBelow(rows[i]))
+          << "i=" << i << " rows[i]=" << rows[i];
+      ;
+    }
+  }
+}
diff --git a/velox/experimental/wave/common/tests/BlockTest.cu b/velox/experimental/wave/common/tests/BlockTest.cu
index 830fa1358c0e8..0628ef9f11c39 100644
--- a/velox/experimental/wave/common/tests/BlockTest.cu
+++ b/velox/experimental/wave/common/tests/BlockTest.cu
@@ -1,51 +1,158 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/common/Bits.cuh"
 #include "velox/experimental/wave/common/Block.cuh"
 #include "velox/experimental/wave/common/CudaUtil.cuh"
+#include "velox/experimental/wave/common/HashTable.cuh"
 #include "velox/experimental/wave/common/tests/BlockTest.h"
+#include "velox/experimental/wave/common/tests/HashTestUtil.h"
+#include "velox/experimental/wave/common/tests/Updates.cuh"
 
 namespace facebook::velox::wave {
 
 using ScanAlgorithm = cub::BlockScan<int, 256, cub::BLOCK_SCAN_RAKING>;
 
-__global__ void boolToIndices(
+__global__ void
+boolToIndicesKernel(uint8_t** bools, int32_t** indices, int32_t* sizes) {
+  extern __shared__ char smem[];
+  int32_t idx = blockIdx.x;
+  // Start cycle timer
+  uint8_t* blockBools = bools[idx];
+  boolBlockToIndices<256>(
+      [&]() { return blockBools[threadIdx.x]; },
+      idx * 256,
+      indices[idx],
+      smem,
+      sizes[idx]);
+  __syncthreads();
+}
+
+void BlockTestStream::testBoolToIndices(
+    int32_t numBlocks,
+    uint8_t** flags,
+    int32_t** indices,
+    int32_t* sizes) {
+  CUDA_CHECK(cudaGetLastError());
+  auto tempBytes = sizeof(typename ScanAlgorithm::TempStorage);
+  boolToIndicesKernel<<<numBlocks, 256, tempBytes, stream_->stream>>>(
+      flags, indices, sizes);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+__global__ void boolToIndicesNoSharedKernel(
     uint8_t** bools,
     int32_t** indices,
     int32_t* sizes,
-    int64_t* times) {
-  extern __shared__ __align__(alignof(ScanAlgorithm::TempStorage)) char smem[];
+    void* temp) {
   int32_t idx = blockIdx.x;
-  // Start cycle timer
-  clock_t start = clock();
+
   uint8_t* blockBools = bools[idx];
+  char* smem = reinterpret_cast<char*>(temp) +
+      blockIdx.x * sizeof(typename ScanAlgorithm::TempStorage);
   boolBlockToIndices<256>(
       [&]() { return blockBools[threadIdx.x]; },
       idx * 256,
       indices[idx],
       smem,
       sizes[idx]);
-  clock_t stop = clock();
-  if (threadIdx.x == 0) {
-    times[idx] = (start > stop) ? start - stop : stop - start;
-  }
+  __syncthreads();
 }
 
-void BlockTestStream::testBoolToIndices(
+void BlockTestStream::testBoolToIndicesNoShared(
     int32_t numBlocks,
     uint8_t** flags,
     int32_t** indices,
     int32_t* sizes,
-    int64_t* times) {
-  auto tempBytes = sizeof(typename ScanAlgorithm::TempStorage);
-  boolToIndices<<<numBlocks, 256, tempBytes, stream_->stream>>>(
-      flags, indices, sizes, times);
+    void* temp) {
+  CUDA_CHECK(cudaGetLastError());
+  boolToIndicesNoSharedKernel<<<numBlocks, 256, 0, stream_->stream>>>(
+      flags, indices, sizes, temp);
   CUDA_CHECK(cudaGetLastError());
 }
 
+int32_t BlockTestStream::boolToIndicesSize() {
+  return sizeof(typename ScanAlgorithm::TempStorage);
+}
+
+__global__ void
+bool256ToIndicesKernel(uint8_t** bools, int32_t** indices, int32_t* sizes) {
+  extern __shared__ char smem[];
+  int32_t idx = blockIdx.x;
+  auto* bool64 = reinterpret_cast<uint64_t*>(bools[idx]);
+  bool256ToIndices(
+      [&](int32_t index8) { return bool64[index8]; },
+      idx * 256,
+      indices[idx],
+      sizes[idx],
+      smem);
+  __syncthreads();
+}
+
+void BlockTestStream::testBool256ToIndices(
+    int32_t numBlocks,
+    uint8_t** flags,
+    int32_t** indices,
+    int32_t* sizes) {
+  CUDA_CHECK(cudaGetLastError());
+  auto tempBytes = bool256ToIndicesSize();
+  bool256ToIndicesKernel<<<numBlocks, 256, tempBytes, stream_->stream>>>(
+      flags, indices, sizes);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+__global__ void bool256ToIndicesNoSharedKernel(
+    uint8_t** bools,
+    int32_t** indices,
+    int32_t* sizes,
+    void* temp) {
+  int32_t idx = blockIdx.x;
+  auto* bool64 = reinterpret_cast<uint64_t*>(bools[idx]);
+  char* smem = reinterpret_cast<char*>(temp) + blockIdx.x * 80;
+  bool256ToIndices(
+      [&](int32_t index8) { return bool64[index8]; },
+      idx * 256,
+      indices[idx],
+      sizes[idx],
+      smem);
+  __syncthreads();
+}
+
+void BlockTestStream::testBool256ToIndicesNoShared(
+    int32_t numBlocks,
+    uint8_t** flags,
+    int32_t** indices,
+    int32_t* sizes,
+    void* temp) {
+  CUDA_CHECK(cudaGetLastError());
+  bool256ToIndicesNoSharedKernel<<<numBlocks, 256, 0, stream_->stream>>>(
+      flags, indices, sizes, temp);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+int32_t BlockTestStream::bool256ToIndicesSize() {
+  return 80;
+}
+
 __global__ void sum64(int64_t* numbers, int64_t* results) {
-  extern __shared__ __align__(
-      alignof(cub::BlockReduce<int64_t, 256>::TempStorage)) char smem[];
+  extern __shared__ char smem[];
   int32_t idx = blockIdx.x;
   blockSum<256>(
       [&]() { return numbers[idx * 256 + threadIdx.x]; }, smem, results);
+  __syncthreads();
 }
 
 void BlockTestStream::testSum64(
@@ -57,4 +164,512 @@ void BlockTestStream::testSum64(
   CUDA_CHECK(cudaGetLastError());
 }
 
+/// Keys and values are n sections of 8K items. The items in each section get
+/// sorted on the key.
+void __global__ __launch_bounds__(1024)
+    testSort(uint16_t** keys, uint16_t** values) {
+  extern __shared__ __align__(16) char smem[];
+  auto keyBase = keys[blockIdx.x];
+  auto valueBase = values[blockIdx.x];
+  blockSort<256, 32>(
+      [&](auto i) { return keyBase[i]; },
+      [&](auto i) { return valueBase[i]; },
+      keys[blockIdx.x],
+      values[blockIdx.x],
+      smem);
+  __syncthreads();
+}
+
+void __global__ __launch_bounds__(1024)
+    testSortNoShared(uint16_t** keys, uint16_t** values, char* smem) {
+  auto keyBase = keys[blockIdx.x];
+  auto valueBase = values[blockIdx.x];
+  char* tbTemp = smem +
+      blockIdx.x *
+          sizeof(typename cub::BlockRadixSort<uint16_t, 256, 32, uint16_t>::
+                     TempStorage);
+
+  blockSort<256, 32>(
+      [&](auto i) { return keyBase[i]; },
+      [&](auto i) { return valueBase[i]; },
+      keys[blockIdx.x],
+      values[blockIdx.x],
+      tbTemp);
+  __syncthreads();
+}
+
+int32_t BlockTestStream::sort16SharedSize() {
+  return sizeof(
+      typename cub::BlockRadixSort<uint16_t, 256, 32, uint16_t>::TempStorage);
+}
+
+void BlockTestStream::testSort16(
+    int32_t numBlocks,
+    uint16_t** keys,
+    uint16_t** values) {
+  auto tempBytes = sizeof(
+      typename cub::BlockRadixSort<uint16_t, 256, 32, uint16_t>::TempStorage);
+
+  testSort<<<numBlocks, 256, tempBytes, stream_->stream>>>(keys, values);
+}
+
+void BlockTestStream::testSort16NoShared(
+    int32_t numBlocks,
+    uint16_t** keys,
+    uint16_t** values,
+    char* temp) {
+  testSortNoShared<<<numBlocks, 256, 0, stream_->stream>>>(keys, values, temp);
+}
+
+/// Calls partitionRows on each thread block of 256 threads. The parameters
+/// correspond to 'partitionRows'. Each is an array subscripted by blockIdx.x.
+void __global__ partitionShortsKernel(
+    uint16_t** keys,
+    int32_t* numKeys,
+    int32_t numPartitions,
+    int32_t** ranks,
+    int32_t** partitionStarts,
+    int32_t** partitionedRows) {
+  partitionRows<256>(
+      [&](auto i) { return keys[blockIdx.x][i]; },
+      numKeys[blockIdx.x],
+      numPartitions,
+      ranks[blockIdx.x],
+      partitionStarts[blockIdx.x],
+      partitionedRows[blockIdx.x]);
+  __syncthreads();
+}
+
+void BlockTestStream::partitionShorts(
+    int32_t numBlocks,
+    uint16_t** keys,
+    int32_t* numKeys,
+    int32_t numPartitions,
+    int32_t** ranks,
+    int32_t** partitionStarts,
+    int32_t** partitionedRows) {
+  constexpr int32_t kBlockSize = 256;
+  auto shared = partitionRowsSharedSize<kBlockSize>(numPartitions);
+  partitionShortsKernel<<<numBlocks, kBlockSize, shared, stream_->stream>>>(
+      keys, numKeys, numPartitions, ranks, partitionStarts, partitionedRows);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+/// A mock complex accumulator update function.
+ProbeState __device__ arrayAgg64Append(
+    ArrayAgg64* accumulator,
+    int64_t arg,
+    RowAllocator* allocator) {
+  auto* last = accumulator->last;
+  if (!last || accumulator->numInLast >= sizeof(last->data) / sizeof(int64_t)) {
+    auto* next = allocator->allocate<ArrayAgg64::Run>(1);
+    if (!next) {
+      return ProbeState::kNeedSpace;
+    }
+    next->next = nullptr;
+    if (accumulator->last) {
+      accumulator->last->next = next;
+      accumulator->last = next;
+    } else {
+      accumulator->first = accumulator->last = next;
+    }
+  }
+  accumulator->last->data[accumulator->numInLast++] = arg;
+  return ProbeState::kDone;
+}
+
+/// An mock Ops parameter class to do group by.
+class MockGroupByOps {
+ public:
+  int32_t __device__ blockBase(HashProbe* probe) {
+    return probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  }
+
+  int32_t __device__ numRowsInBlock(HashProbe* probe) {
+    return probe->numRows[blockIdx.x];
+  }
+
+  uint64_t __device__ hash(int32_t i, HashProbe* probe) {
+    auto key = reinterpret_cast<int64_t**>(probe->keys)[0];
+    return hashMix(1, key[i]);
+  }
+
+  bool __device__
+  compare(GpuHashTable* table, TestingRow* row, int32_t i, HashProbe* probe) {
+    return row->key == reinterpret_cast<int64_t**>(probe->keys)[0][i];
+  }
+
+  TestingRow* __device__
+  newRow(GpuHashTable* table, int32_t partition, int32_t i, HashProbe* probe) {
+    auto* allocator = &table->allocators[partition];
+    auto row = allocator->allocateRow<TestingRow>();
+    if (row) {
+      row->key = reinterpret_cast<int64_t**>(probe->keys)[0][i];
+      row->flags = 0;
+      row->count = 0;
+      new (&row->concatenation) ArrayAgg64();
+    }
+    return row;
+  }
+
+  ProbeState __device__ insert(
+      GpuHashTable* table,
+      int32_t partition,
+      GpuBucket* bucket,
+      uint32_t misses,
+      uint32_t oldTags,
+      uint32_t tagWord,
+      int32_t i,
+      HashProbe* probe,
+      TestingRow*& row) {
+    if (!row) {
+      row = newRow(table, partition, i, probe);
+      if (!row) {
+        return ProbeState::kNeedSpace;
+      }
+    }
+    auto missShift = __ffs(misses) - 1;
+    if (!bucket->addNewTag(tagWord, oldTags, missShift)) {
+      return ProbeState::kRetry;
+    }
+    bucket->store(missShift / 8, row);
+    return ProbeState::kDone;
+  }
+
+  TestingRow* __device__ getExclusive(
+      GpuHashTable* table,
+      GpuBucket* bucket,
+      TestingRow* row,
+      int32_t hitIdx,
+      int32_t warp) {
+    return row;
+    int32_t nanos = 1;
+    for (;;) {
+      if (atomicTryLock(&row->flags)) {
+        return row;
+      }
+      __nanosleep((nanos + threadIdx.x) & 31);
+      nanos += 3;
+    }
+  }
+
+  void __device__ writeDone(TestingRow* row) {
+    // atomicUnlock(&row->flags);
+  }
+
+  ProbeState __device__ update(
+      GpuHashTable* table,
+      GpuBucket* bucket,
+      TestingRow* row,
+      int32_t i,
+      HashProbe* probe) {
+    auto* keys = reinterpret_cast<int64_t**>(probe->keys);
+    atomicAdd((unsigned long long*)&row->count, (unsigned long long)keys[1][i]);
+    return ProbeState::kDone;
+    int64_t arg = keys[1][i];
+    int32_t part = table->partitionIdx(bucket - table->buckets);
+    auto* allocator = &table->allocators[part];
+    auto state = arrayAgg64Append(&row->concatenation, arg, allocator);
+    row->flags = 0;
+    __threadfence();
+    return state;
+  }
+};
+
+void __global__ __launch_bounds__(1024) hashTestKernel(
+    GpuHashTable* table,
+    HashProbe* probe,
+    BlockTestStream::HashCase mode) {
+  switch (mode) {
+    case BlockTestStream::HashCase::kGroup: {
+      table->updatingProbe<TestingRow>(probe, MockGroupByOps());
+      break;
+    }
+    case BlockTestStream::HashCase::kBuild:
+    case BlockTestStream::HashCase::kProbe:
+      *(long*)0 = 0; // Unimplemented.
+  }
+  __syncthreads();
+}
+
+void BlockTestStream::hashTest(
+    GpuHashTableBase* table,
+    HashRun& run,
+    HashCase mode) {
+  int32_t shared = 0;
+  if (mode == HashCase::kGroup) {
+    shared = GpuHashTable::updatingProbeSharedSize();
+  }
+  hashTestKernel<<<run.numBlocks, run.blockSize, shared, stream_->stream>>>(
+      reinterpret_cast<GpuHashTable*>(table), run.probe, mode);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void __global__ allocatorTestKernel(
+    int32_t numAlloc,
+    int32_t numFree,
+    int32_t numStr,
+    AllocatorTestResult* allResults) {
+  auto* result = allResults + threadIdx.x + blockIdx.x * blockDim.x;
+  for (;;) {
+    int32_t maxRows = sizeof(result->rows) / sizeof(result->rows[0]);
+    int32_t maxStrings = sizeof(result->strings) / sizeof(result->strings[0]);
+    for (auto count = 0; count < numAlloc; ++count) {
+      if (result->numRows >= maxRows) {
+        return;
+      }
+      auto newRow = result->allocator->allocateRow<int64_t>();
+      if (newRow == nullptr) {
+        return;
+      }
+      if (reinterpret_cast<uint64_t>(newRow) == result->allocator->base) {
+        printf("");
+      }
+
+      result->rows[result->numRows++] = newRow;
+    }
+    for (auto count = 0; count < numFree; ++count) {
+      if (result->numRows == 0) {
+        return;
+      }
+      auto* toFree = result->rows[--result->numRows];
+      if (reinterpret_cast<uint64_t>(toFree) == result->allocator->base) {
+        printf(""); // GPF();
+      }
+      if (!result->allocator->inRange(toFree)) {
+        GPF();
+      }
+      result->allocator->freeRow(toFree);
+    }
+    for (auto count = 0; count < numStr; ++count) {
+      if (result->numStrings >= maxStrings) {
+        return;
+      }
+      auto str = result->allocator->allocate<char>(11);
+      if (!str) {
+        return;
+      }
+      result->strings[result->numStrings++] = reinterpret_cast<int64_t*>(str);
+    }
+  }
+  __syncthreads();
+}
+
+void __global__ initAllocatorKernel(RowAllocator* allocator) {
+  if (threadIdx.x == 0) {
+    if (allocator->freeSet) {
+      reinterpret_cast<FreeSet<uint32_t, 1024>*>(allocator->freeSet)->clear();
+    }
+  }
+  __syncthreads();
+}
+
+//  static
+int32_t BlockTestStream::freeSetSize() {
+  return sizeof(FreeSet<uint32_t, 1024>);
+}
+
+void BlockTestStream::initAllocator(HashPartitionAllocator* allocator) {
+  initAllocatorKernel<<<1, 1, 0, stream_->stream>>>(
+      reinterpret_cast<RowAllocator*>(allocator));
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void BlockTestStream::rowAllocatorTest(
+    int32_t numBlocks,
+    int32_t numAlloc,
+    int32_t numFree,
+    int32_t numStr,
+    AllocatorTestResult* results) {
+  allocatorTestKernel<<<numBlocks, 64, 0, stream_->stream>>>(
+      numAlloc, numFree, numStr, results);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+#define UPDATE_CASE(name, func, smem)                                      \
+  void __global__ name##Kernel(TestingRow* rows, HashProbe* probe) {       \
+    func(rows, probe);                                                     \
+    __syncthreads();                                                       \
+  }                                                                        \
+                                                                           \
+  void BlockTestStream::name(TestingRow* rows, HashRun& run) {             \
+    name##Kernel<<<run.numBlocks, run.blockSize, smem, stream_->stream>>>( \
+        rows, run.probe);                                                  \
+    CUDA_CHECK(cudaGetLastError());                                        \
+  }
+
+UPDATE_CASE(updateSum1NoSync, testSumNoSync, 0);
+UPDATE_CASE(updateSum1Mtx, testSumMtx, 0);
+UPDATE_CASE(updateSum1MtxCoalesce, testSumMtxCoalesce, 0);
+UPDATE_CASE(updateSum1Atomic, testSumAtomic, 0);
+UPDATE_CASE(updateSum1AtomicCoalesceShfl, testSumAtomicCoalesceShfl, 0);
+UPDATE_CASE(
+    updateSum1AtomicCoalesceShmem,
+    testSumAtomicCoalesceShmem,
+    run.blockSize * sizeof(int64_t));
+UPDATE_CASE(updateSum1Exch, testSumExch, sizeof(ProbeShared));
+UPDATE_CASE(updateSum1Order, testSumOrder, 0);
+
+void __global__ __launch_bounds__(1024) update1PartitionKernel(
+    int32_t numRows,
+    int32_t numDistinct,
+    int32_t numParts,
+    int32_t blockStride,
+    HashProbe* probe,
+    int32_t* temp) {
+  auto blockStart = blockStride * blockIdx.x;
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  partitionRows<256, int32_t>(
+      [&](auto i) -> int32_t { return indices[i + blockStart] % numParts; },
+      blockIdx.x == blockDim.x - 1 ? numRows - blockStart : blockStride,
+      numParts,
+      temp + blockIdx.x * blockStride,
+      probe->hostRetries + blockStride * blockIdx.x,
+      probe->kernelRetries1 + blockStride * blockIdx.x);
+  __syncthreads();
+}
+
+void __global__ updateSum1PartKernel(
+    TestingRow* rows,
+    int32_t numParts,
+    HashProbe* probe,
+    int32_t numGroups,
+    int32_t groupStride) {
+  testSumPart(
+      rows,
+      numParts,
+      probe,
+      probe->kernelRetries1,
+      probe->hostRetries,
+      numGroups,
+      groupStride);
+  __syncthreads();
+}
+
+void BlockTestStream::updateSum1Part(TestingRow* rows, HashRun& run) {
+  auto numParts = std::min<int32_t>(run.numDistinct, 8192);
+  auto groupStride = run.numRows / 32;
+  auto numGroups = run.numRows / groupStride;
+  auto partSmem = partitionRowsSharedSize<256>(numParts);
+  // We use probe->kernelRetries1 as the indices array for partitions. We use
+  // probe->hostRetries as the array of partition starts. So, if we have 10
+  // partitions, then hostRetries[x..y] is the input rows for partition 1 if x
+  // is partitionStarts[0] and y is partitionStarts[1].
+  update1PartitionKernel<<<numGroups, 256, partSmem, stream_->stream>>>(
+      run.numRows,
+      run.numDistinct,
+      numParts,
+      groupStride,
+      run.probe,
+      run.partitionTemp);
+  CUDA_CHECK(cudaGetLastError());
+
+  int32_t blockSize = roundUp(std::min<int32_t>(256, numParts), 32);
+  int32_t numBlocks = numParts / blockSize;
+  // There will be one lane per partition. The last blocks may have empty lanes.
+  if (numBlocks * blockSize < numParts) {
+    ++numBlocks;
+  }
+  updateSum1PartKernel<<<numBlocks, blockSize, 0, stream_->stream>>>(
+      rows, numParts, run.probe, numGroups, groupStride);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+__global__ void scatterBitsKernel(
+    int32_t numSource,
+    int32_t numTarget,
+    const char* source,
+    const uint64_t* targetMask,
+    char* target,
+    int32_t* temp) {
+  if (!temp) {
+    extern __shared__ __align__(16) char smem[];
+    temp = reinterpret_cast<int32_t*>(smem);
+  }
+  scatterBitsDevice<4>(numSource, numTarget, source, targetMask, target, temp);
+  __syncthreads();
+}
+
+//    static
+int32_t BlockTestStream::scatterBitsSize(int32_t blockSize) {
+  return scatterBitsDeviceSize(blockSize);
+}
+
+void BlockTestStream::scatterBits(
+    int32_t numSource,
+    int32_t numTarget,
+    const char* source,
+    const uint64_t* targetMask,
+    char* target,
+    int32_t* temp) {
+  scatterBitsKernel<<<
+      1,
+      256,
+      temp ? 0 : scatterBitsDeviceSize(256),
+      stream_->stream>>>(
+      numSource, numTarget, source, targetMask, target, temp);
+}
+
+/// Struct for tracking state between calls to nonNullIndex256 and
+/// nonNullIndex256Sparse.
+struct NonNullIndexState {
+  // Number of non-nulls below 'row'. the null flag at 'row' is not included in
+  // the sum.
+  int32_t numNonNullBelow;
+  int32_t row;
+  // Scratch memory with one int32 per warp of 256 wide TB.
+  int32_t temp[256 / kWarpThreads];
+};
+
+void __global__ nonNullIndexKernel(
+    char* nulls,
+    int32_t* rows,
+    int32_t numRows,
+    int32_t* indices,
+    int32_t* temp) {
+  NonNullState* state = reinterpret_cast<NonNullState*>(temp);
+  if (threadIdx.x == 0) {
+    state->nonNullsBelow = 0;
+    state->nonNullsBelowRow = 0;
+  }
+  __syncthreads();
+  for (auto i = 0; i < numRows; i += blockDim.x) {
+    auto last = min(i + 256, numRows);
+    if (isDense(rows, i, last)) {
+      indices[i + threadIdx.x] =
+          nonNullIndex256(nulls, rows[i], last - i, state);
+    } else {
+      indices[i + threadIdx.x] =
+          nonNullIndex256Sparse(nulls, rows + i, last - i, state);
+    }
+  }
+  __syncthreads();
+}
+
+void BlockTestStream::nonNullIndex(
+    char* nulls,
+    int32_t* rows,
+    int32_t numRows,
+    int32_t* indices,
+    int32_t* temp) {
+  nonNullIndexKernel<<<1, 256, 0, stream_->stream>>>(
+      nulls, rows, numRows, indices, temp);
+}
+
+REGISTER_KERNEL("testSort", testSort);
+REGISTER_KERNEL("boolToIndices", boolToIndicesKernel);
+REGISTER_KERNEL("bool256ToIndices", bool256ToIndicesKernel);
+REGISTER_KERNEL("sum64", sum64);
+REGISTER_KERNEL("partitionShorts", partitionShortsKernel);
+REGISTER_KERNEL("hashTest", hashTestKernel);
+REGISTER_KERNEL("allocatorTest", allocatorTestKernel);
+REGISTER_KERNEL("sum1atm", updateSum1AtomicKernel);
+REGISTER_KERNEL("sum1atmCoaShfl", updateSum1AtomicCoalesceShflKernel);
+REGISTER_KERNEL("sum1atmCoaShmem", updateSum1AtomicCoalesceShmemKernel);
+REGISTER_KERNEL("sum1Exch", updateSum1ExchKernel);
+REGISTER_KERNEL("sum1Part", updateSum1PartKernel);
+REGISTER_KERNEL("partSum", update1PartitionKernel);
+REGISTER_KERNEL("scatterBits", scatterBitsKernel);
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/BlockTest.h b/velox/experimental/wave/common/tests/BlockTest.h
index bed782ff14ade..5218537141a3f 100644
--- a/velox/experimental/wave/common/tests/BlockTest.h
+++ b/velox/experimental/wave/common/tests/BlockTest.h
@@ -17,31 +17,164 @@
 #pragma once
 
 #include "velox/experimental/wave/common/Cuda.h"
+#include "velox/experimental/wave/common/HashTable.h"
+#include "velox/experimental/wave/common/tests/HashTestUtil.h"
 
-/// Sample header for testing Block.cuh
+/// Sample header for testing Wave Utilities.
 
 namespace facebook::velox::wave {
 
+constexpr uint32_t kPrime32 = 1815531889;
+
+/// A mock aggregate that concatenates numbers, like array_agg of bigint.
+struct ArrayAgg64 {
+  struct Run {
+    Run* next;
+    int64_t data[16];
+  };
+
+  Run* first{nullptr};
+  Run* last{nullptr};
+  // Fill of 'last->data', all other runs are full.
+  int8_t numInLast{0};
+};
+
+/// A mock hash table content row to test HashTable.
+struct TestingRow {
+  // Single ke part.
+  int64_t key;
+
+  // Count of updates. Sample aggregate
+  int64_t count{0};
+
+  // A mock concatenating aggregate. Use for testing control flow in
+  // running out of space in updating a group.
+  ArrayAgg64 concatenation;
+
+  // Next pointer in the case simulating a non-unique join table.
+  TestingRow* next{nullptr};
+
+  // flags for updating the row. E.g. probed flag, marker for exclusive write.
+  int32_t flags{0};
+};
+
+/// Result of allocator test kernel.
+struct AllocatorTestResult {
+  RowAllocator* allocator;
+  int32_t numRows;
+  int32_t numStrings;
+  int64_t* rows[200000];
+  int64_t* strings[200000];
+};
+
 class BlockTestStream : public Stream {
  public:
   /// In each block of 256 bools in bools[i], counts the number of
   /// true and writes the indices of true lanes into the corresponding
   /// indices[i]. Stors the number of true values to sizes[i].
   void testBoolToIndices(
+      int32_t numBlocks,
+      uint8_t** flags,
+      int32_t** indices,
+      int32_t* sizes);
+  void testBoolToIndicesNoShared(
+      int32_t numBlocks,
+      uint8_t** flags,
+      int32_t** indices,
+      int32_t* sizes,
+      void*);
+
+  // Returns the smem size for block size 256 of boolToIndices().
+  static int32_t boolToIndicesSize();
+
+  void testBool256ToIndices(
+      int32_t numBlocks,
+      uint8_t** flags,
+      int32_t** indices,
+      int32_t* sizes);
+
+  void testBool256ToIndicesNoShared(
       int32_t numBlocks,
       uint8_t** flags,
       int32_t** indices,
       int32_t* sizes,
-      int64_t* times);
+      void*);
+
+  // Returns the smem size for bool256ToIndices().
+  static int32_t bool256ToIndicesSize();
 
   // calculates the sum over blocks of 256 int64s and returns the result for
   // numbers[i * 256] ... numbers[(i + 1) * 256 - 1] inclusive  in results[i].
   void testSum64(int32_t numBlocks, int64_t* numbers, int64_t* results);
 
-  /// Sorts 'rows'[i] using ids[i] as keys and stores the sorted order in
-  /// 'result[i]'.
-  // void dedup(int32_t numBlocks, uint16_t** ids, uint16_t** rows, uint16_t**
-  // resultRows);
+  static int32_t sort16SharedSize();
+
+  void testSort16(int32_t numBlocks, uint16_t** keys, uint16_t** values);
+  void testSort16NoShared(
+      int32_t numBlocks,
+      uint16_t** keys,
+      uint16_t** values,
+      char* temp);
+
+  void partitionShorts(
+      int32_t numBlocks,
+      uint16_t** keys,
+      int32_t* numKeys,
+      int32_t numPartitions,
+      int32_t** ranks,
+      int32_t** partitionStarts,
+      int32_t** partitionedRows);
+
+  // Operation for hash table tests.
+  enum class HashCase { kGroup, kBuild, kProbe };
+
+  /// Does probe/groupby/build on 'table'. 'probe' contains the parameters and
+  /// temp storage. 'table' and 'probe' are expected to be resident on device.
+  /// 'numBlocks' gives how many TBs are run, the rows per TB are in 'probe'.
+  void hashTest(GpuHashTableBase* table, HashRun& probe, HashCase mode);
+
+  static int32_t freeSetSize();
+
+  void initAllocator(HashPartitionAllocator* allocator);
+
+  /// tests RowAllocator.
+  void rowAllocatorTest(
+      int32_t numBlocks,
+      int32_t numAlloc,
+      int32_t numFree,
+      int32_t numStr,
+      AllocatorTestResult* results);
+
+  void updateSum1Atomic(TestingRow* rows, HashRun& run);
+  void updateSum1Exch(TestingRow* rows, HashRun& run);
+  void updateSum1NoSync(TestingRow* rows, HashRun& run);
+  void updateSum1AtomicCoalesceShfl(TestingRow* rows, HashRun& run);
+  void updateSum1AtomicCoalesceShmem(TestingRow* rows, HashRun& run);
+  void updateSum1Part(TestingRow* rows, HashRun& run);
+  void updateSum1Mtx(TestingRow* rows, HashRun& run);
+  void updateSum1MtxCoalesce(TestingRow* rows, HashRun& run);
+  void updateSum1Order(TestingRow* rows, HashRun& run);
+
+  static int32_t scatterBitsSize(int32_t blockSize);
+
+  void scatterBits(
+      int32_t numSource,
+      int32_t numTarget,
+      const char* source,
+      const uint64_t* targetMask,
+      char* target,
+      int32_t* temp);
+
+  /// Tests nonNullIndex256 if 'rows' are all consecutive integers and
+  /// nonNullIndex256Sparse otherwise. If the row hits a null in 'nulls' the
+  /// result in indices is -1, therwise it is the index in non null values, i.e.
+  /// the original minus the count of null positions below it.
+  void nonNullIndex(
+      char* nulls,
+      int32_t* rows,
+      int32_t numRows,
+      int32_t* indices,
+      int32_t* temp);
 };
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/CMakeLists.txt b/velox/experimental/wave/common/tests/CMakeLists.txt
index 159261e72a802..8cb290f4baec9 100644
--- a/velox/experimental/wave/common/tests/CMakeLists.txt
+++ b/velox/experimental/wave/common/tests/CMakeLists.txt
@@ -12,11 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_wave_common_test GpuArenaTest.cpp CudaTest.cpp CudaTest.cu
-                                      BlockTest.cpp BlockTest.cu)
-
-set_target_properties(velox_wave_common_test PROPERTIES CUDA_ARCHITECTURES
-                                                        native)
+add_executable(
+  velox_wave_common_test
+  GpuArenaTest.cpp
+  CudaTest.cpp
+  CudaTest.cu
+  BlockTest.cpp
+  BlockTest.cu
+  HashTableTest.cpp
+  HashTestUtil.cpp)
 
 add_test(velox_wave_common_test velox_wave_common_test)
 
@@ -26,8 +30,8 @@ target_link_libraries(
   velox_memory
   velox_time
   velox_exception
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog
   Folly::folly)
diff --git a/velox/experimental/wave/common/tests/CpuTable.h b/velox/experimental/wave/common/tests/CpuTable.h
new file mode 100644
index 0000000000000..d960e11b61bdb
--- /dev/null
+++ b/velox/experimental/wave/common/tests/CpuTable.h
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+#include "velox/common/base/SimdUtil.h"
+
+namespace facebook::velox::wave {
+
+class CpuBucket {
+ public:
+#if XSIMD_WITH_SSE2
+  using TagVector = xsimd::batch<uint8_t, xsimd::sse2>;
+#elif XSIMD_WITH_NEON
+  using TagVector = xsimd::batch<uint8_t, xsimd::neon>;
+#endif
+
+  auto loadTags() {
+#if XSIMD_WITH_SSE2
+    return TagVector(_mm_loadu_si128(reinterpret_cast<__m128i const*>(tags_)));
+#elif XSIMD_WITH_NEON
+    return TagVector(vld1q_u8(tags_));
+#endif
+  }
+
+  void setTag(int32_t idx, uint8_t tag) {
+    tags_[idx] = tag;
+  }
+
+  static inline uint16_t matchTags(TagVector tags, uint8_t tag) {
+    auto flags = TagVector::broadcast(tag) == tags;
+    return simd::toBitMask(flags);
+  }
+
+  template <typename T>
+  T* load(int32_t idx) {
+    uint64_t data = *reinterpret_cast<uint64_t*>(&data_[idx * 6]);
+    return reinterpret_cast<T*>(data & 0xffffffffffff);
+  }
+
+  void store(uint32_t idx, void* row) {
+    auto uptr = reinterpret_cast<uint64_t>(row);
+    uint64_t data = *reinterpret_cast<uint64_t*>(&data_[idx * 6]);
+    *reinterpret_cast<uint64_t*>(&data_[idx * 6]) =
+        (data & 0xffff000000000000) | uptr;
+  }
+
+ private:
+  uint8_t tags_[16];
+  uint8_t data_[128 - 16];
+};
+
+struct CpuHashTable {
+  CpuHashTable() = default;
+
+  CpuHashTable(int32_t numSlots, int32_t rowBytes) {
+    auto numBuckets = bits::nextPowerOfTwo(numSlots) / 16;
+    assert(numBuckets > 0);
+    sizeMask = numBuckets - 1;
+    bucketSpace.resize(numBuckets * sizeof(CpuBucket) + 64);
+    buckets = reinterpret_cast<CpuBucket*>(
+        bits::roundUp(reinterpret_cast<uint64_t>(bucketSpace.data()), 64));
+    rows.resize(rowBytes);
+  }
+
+  std::string bucketSpace;
+
+  CpuBucket* buckets;
+
+  int32_t sizeMask;
+
+  // Preallocated space for rows. Do not resize.
+  std::string rows;
+
+  // Number of used bytes in 'rows'.
+  int32_t spaceUsed{0};
+
+  // Number of entries.
+  int32_t size{0};
+
+  template <typename T>
+  T* newRow() {
+    auto size = sizeof(T);
+    if (spaceUsed + size > rows.size()) {
+      return nullptr;
+    }
+    auto row = reinterpret_cast<T*>(rows.data() + spaceUsed);
+    spaceUsed += size;
+    return row;
+  }
+
+  template <typename RowType, typename Ops>
+  RowType* find(int64_t key, uint64_t h, Ops ops) const {
+    uint8_t tag = 0x80 | (h >> 32);
+    int32_t bucketIdx = h & sizeMask;
+    for (;;) {
+      auto tags = buckets[bucketIdx].loadTags();
+      auto hits = CpuBucket::matchTags(tags, tag);
+      while (hits) {
+        auto idx = bits::getAndClearLastSetBit(hits);
+        auto row = buckets[bucketIdx].load<RowType>(idx);
+        if (ops.compare1(this, row, key)) {
+          return row;
+        }
+      }
+      auto misses = CpuBucket::matchTags(tags, 0);
+      if (misses) {
+        return nullptr;
+      }
+      bucketIdx = (1 + bucketIdx) & sizeMask;
+    }
+  }
+
+  template <typename RowType, typename Ops>
+  void updatingProbe(int32_t numRows, HashProbe* probe, Ops ops) {
+    for (auto i = 0; i < numRows; ++i) {
+      auto h = probe->hashes[i];
+      uint8_t tag = 0x80 | (h >> 32);
+      auto bucketIdx = h & sizeMask;
+      for (;;) {
+        auto tags = buckets[bucketIdx].loadTags();
+        auto hits = CpuBucket::matchTags(tags, tag);
+        while (hits) {
+          auto idx = bits::getAndClearLastSetBit(hits);
+          auto row = buckets[bucketIdx].load<RowType>(idx);
+          if (ops.compare(this, row, i, probe)) {
+            ops.update(this, row, i, probe);
+            goto done;
+          }
+        }
+        auto misses = CpuBucket::matchTags(tags, 0);
+        if (misses) {
+          int32_t idx = bits::getAndClearLastSetBit(misses);
+          buckets[bucketIdx].setTag(idx, tag);
+          auto* newRow = ops.newRow(this, i, probe);
+          buckets[bucketIdx].store(idx, newRow);
+          ++size;
+          ops.update(this, newRow, i, probe);
+          break;
+        }
+        bucketIdx = (bucketIdx + 1) & sizeMask;
+      }
+    done:;
+    }
+  }
+
+  void check() {
+    for (auto i = 0; i <= sizeMask; ++i) {
+      for (auto j = 0; j < 16; j++) {
+        auto row = buckets[i].load<char>(j);
+        if (!row || (row >= rows.data() && row < rows.data() + rows.size())) {
+          continue;
+        }
+        VELOX_FAIL();
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/CudaTest.cpp b/velox/experimental/wave/common/tests/CudaTest.cpp
index 71922a4d8ca4a..9f924d962f8e7 100644
--- a/velox/experimental/wave/common/tests/CudaTest.cpp
+++ b/velox/experimental/wave/common/tests/CudaTest.cpp
@@ -32,9 +32,14 @@
 #include "velox/common/time/Timer.h"
 #include "velox/experimental/wave/common/GpuArena.h"
 #include "velox/experimental/wave/common/tests/BlockTest.h"
+#include "velox/experimental/wave/common/tests/CpuTable.h"
+#include "velox/experimental/wave/common/tests/HashTestUtil.h"
+#include "velox/experimental/wave/common/tests/Util.h"
 
 #include <iostream>
 
+DEFINE_bool(list_kernels, false, "Lists kernel occupancy and registers");
+
 DEFINE_int32(num_streams, 0, "Number of paralll streams");
 DEFINE_int32(op_size, 0, "Size of invoke kernel (ints read and written)");
 DEFINE_int32(
@@ -67,6 +72,15 @@ DEFINE_int64(
 DEFINE_string(mode, "all", "Mode for reduce test memory transfers.");
 
 DEFINE_bool(enable_bm, false, "Enable custom and long running tests");
+
+DEFINE_string(
+    roundtrip_ops,
+    "",
+    "Custom roundtrip composition, see comments in RoundtripThread");
+
+DEFINE_int32(gpu_repeats, 64, "Number of repeats for GPU round trips");
+DEFINE_int32(cpu_repeats, 32, "Number of repeats for CPU round trips");
+
 using namespace facebook::velox;
 using namespace facebook::velox::wave;
 
@@ -427,6 +441,565 @@ class ProcessDeviceCoalesced : public ProcessBatchBase {
   Semaphore syncSem_{0};
 };
 
+struct RoundtripStats {
+  // id of experiment.
+  int32_t id{0};
+  bool isCpu{false};
+  // Description of round trip.
+  std::string mode;
+  // Threads in experiment.
+  int32_t numThreads{0};
+  // Number of times a thread repeats the sequence given by 'mode'.
+  int64_t numOps{0};
+  // Number of additions in the ops
+  int64_t numAdds{0};
+
+  // Bytes transferred to device.
+  int64_t toDeviceBytes{0};
+
+  // Bytes copied to host.
+  int64_t toHostBytes{0};
+
+  int64_t startMicros{0};
+
+  int64_t endMicros{0};
+
+  // Wall time of experiment.
+  float micros{0};
+  void init(
+      int32_t _id,
+      bool _isCpu,
+      int32_t _numThreads,
+      std::string _mode,
+      int32_t repeats) {
+    id = _id;
+    isCpu = _isCpu;
+    numThreads = _numThreads;
+    mode = _mode;
+    numOps = repeats;
+  }
+
+  void add(RoundtripStats& other) {
+    startMicros = std::min(startMicros, other.startMicros);
+    endMicros = std::max(endMicros, other.endMicros);
+    toHostBytes += other.toHostBytes;
+    toDeviceBytes += other.toDeviceBytes;
+    numAdds += other.numAdds;
+  }
+
+  std::string toString() const {
+    return fmt::format(
+        "{}: rps={:.2f} gips={:.4f}  mode={} threads={} micros={} avgus={:.2f} toDev={:.2f} GB/s toHost={:.2f} GB/s",
+        id,
+        (numThreads * numOps) / (micros / 1000000.0),
+        numAdds / (micros * 1000.0),
+        mode,
+        numThreads,
+        micros,
+        micros / numOps,
+        toDeviceBytes / (micros * 1000.0),
+        toHostBytes / (micros * 1000.0));
+  }
+};
+
+// Checks a number for being prime. Returns 0 for prime and a factor for others.
+int64_t factor(int64_t n) {
+  int64_t end = sqrt(n);
+  for (int64_t f = 3; f < end; f += 2) {
+    if (n % f == 0) {
+      return f;
+    }
+  }
+  return 0;
+}
+
+/// Describes one thread of execution in round trip measurement. Each thread
+/// does a sequence of data transfers, kernel calls and synchronizations. The
+/// operations are described in a string of the form:
+///
+///  dnnn - Transfer nnn KB to device.
+/// hnnn - transfer nnn KB to host.
+/// annn,xxx - Increment nnn KB of ints in a kernel xxx times. Reads and writes
+/// nnn KB sequentially over up to 10K threads in 256 thread blocks rnnn,xxx -
+/// Increment nnn KB of int32 counters by a random increment fetched from a
+/// lookup table of nnn KB. This is done xxx times. Read and write sequential,
+/// read random in up to 10K lanes in blocks of 256. wnnn,xxx Same as 'a' but
+/// invokes the kernel wit a 8KB struct. Measures difference of sending a small
+/// parameter block as kernel parameter as opposed to pre-staging it on device
+/// with a small transfer. s - Synchronize the stream. e - Synchronize the
+/// stream with record event + wait event.
+class RoundtripThread {
+ public:
+  // Up to 64 MB of ints.
+  static constexpr int32_t kNumKB = 64 << 10;
+  static constexpr int32_t kNumInts = kNumKB * 256;
+
+  RoundtripThread(int32_t device, ArenaSet* arenas) : arenas_(arenas) {
+    device_ = getDevice(device);
+    setDevice(device_);
+    hostBuffer_ = arenas_->host->allocate<int32_t>(kNumInts);
+    deviceBuffer_ = arenas_->device->allocate<int32_t>(kNumInts);
+    lookupBuffer_ = arenas_->device->allocate<int32_t>(kNumInts);
+
+    stream_ = std::make_unique<TestStream>();
+    event_ = std::make_unique<Event>();
+    for (auto i = 0; i < kNumInts; ++i) {
+      hostBuffer_->as<int32_t>()[i] = i;
+    }
+    stream_->hostToDeviceAsync(
+        lookupBuffer_->as<int32_t>(),
+        hostBuffer_->as<int32_t>(),
+        kNumInts * sizeof(int32_t));
+    stream_->wait();
+    hostInts_ = std::make_unique<int32_t[]>(kNumInts);
+    hostLookup_ = std::make_unique<int32_t[]>(kNumInts);
+    memcpy(
+        hostLookup_.get(),
+        hostBuffer_->as<int32_t>(),
+        kNumInts * sizeof(int32_t));
+    serial_ = ++serialCounter_;
+  }
+
+  ~RoundtripThread() {
+    try {
+      stream_->wait();
+    } catch (const std::exception& e) {
+      LOG(ERROR) << "Error in sync on ~RoundtripThread(): " << e.what();
+    }
+  }
+
+  enum class OpCode {
+    kToDevice,
+    kToHost,
+    kAdd,
+    kAddShared,
+    kAddReg,
+    kAddFunc,
+    kAddBranch,
+    kAddFuncStore,
+    kAddSwitch,
+    kAddRandom,
+    kAddRandomEmptyWarps,
+    kAddRandomEmptyThreads,
+    kWideAdd,
+    kAdd4x64,
+    kEnd,
+    kSync,
+    kSyncEvent
+  };
+
+  struct Op {
+    OpCode opCode;
+    Add64Mode add64Mode;
+    int32_t param1{1};
+    int32_t param2{0};
+    int32_t param3{0};
+    int32_t param4{0};
+    int32_t param5{0};
+  };
+
+  void run(RoundtripStats& stats) {
+    stats.startMicros = getCurrentTimeMicro();
+    for (auto counter = 0; counter < stats.numOps; ++counter) {
+      int32_t position = 0;
+      bool done = false;
+      for (;;) {
+        auto op = nextOp(stats.mode, position);
+        switch (op.opCode) {
+          case OpCode::kEnd:
+            done = true;
+            break;
+          case OpCode::kToDevice:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              memcpy(
+                  hostInts_.get(),
+                  hostBuffer_->as<int32_t>(),
+                  op.param1 * 1024);
+            } else {
+              stream_->hostToDeviceAsync(
+                  deviceBuffer_->as<int32_t>(),
+                  hostBuffer_->as<int32_t>(),
+                  op.param1 * 1024);
+            }
+            stats.toDeviceBytes += op.param1 * 1024;
+            break;
+          case OpCode::kToHost:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              memcpy(
+                  hostBuffer_->as<int32_t>(),
+                  hostInts_.get(),
+                  op.param1 * 1024);
+            } else {
+              stream_->deviceToHostAsync(
+                  hostBuffer_->as<int32_t>(),
+                  deviceBuffer_->as<int32_t>(),
+                  op.param1 * 1024);
+            }
+            stats.toHostBytes += op.param1 * 1024;
+            break;
+          case OpCode::kAdd:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu(op.param1 * 256, op.param2);
+            } else {
+              stream_->addOne(
+                  deviceBuffer_->as<int32_t>(),
+                  op.param1 * 256,
+                  op.param2,
+                  op.param3);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+          case OpCode::kAddShared:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu(op.param1 * 256, op.param2);
+            } else {
+              stream_->addOneShared(
+                  deviceBuffer_->as<int32_t>(),
+                  op.param1 * 256,
+                  op.param2,
+                  op.param3);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+          case OpCode::kAddReg:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu(op.param1 * 256, op.param2);
+            } else {
+              stream_->addOneReg(
+                  deviceBuffer_->as<int32_t>(),
+                  op.param1 * 256,
+                  op.param2,
+                  op.param3);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+          case OpCode::kAddFunc:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu(op.param1 * 256, op.param2);
+            } else {
+              stream_->addOneFunc(
+                  deviceBuffer_->as<int32_t>(),
+                  op.param1 * 256,
+                  op.param2,
+                  op.param3);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+
+          case OpCode::kAddFuncStore:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu(op.param1 * 256, op.param2);
+            } else {
+              stream_->addOneFuncStore(
+                  deviceBuffer_->as<int32_t>(),
+                  op.param1 * 256,
+                  op.param2,
+                  op.param3);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+
+          case OpCode::kAddSwitch:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu(op.param1 * 256, op.param2);
+            } else {
+              stream_->addOneSwitch(
+                  deviceBuffer_->as<int32_t>(),
+                  op.param1 * 256,
+                  op.param2,
+                  op.param3);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+
+          case OpCode::kAddBranch:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu(op.param1 * 256, op.param2);
+            } else {
+              stream_->addOneBranch(
+                  deviceBuffer_->as<int32_t>(),
+                  op.param1 * 256,
+                  op.param2,
+                  op.param3);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+
+          case OpCode::kAdd4x64:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu64(op.param1 * 128, op.param2);
+            } else {
+              stream_->addOne4x64(
+                  deviceBuffer_->as<int64_t>(),
+                  op.param1 * 128,
+                  op.param2,
+                  op.param3,
+                  op.add64Mode);
+            }
+            stats.numAdds += op.param1 * op.param2 * 128;
+            break;
+
+          case OpCode::kWideAdd:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneCpu(op.param1 * 256, op.param2);
+            } else {
+              stream_->addOneWide(
+                  deviceBuffer_->as<int32_t>(), op.param1 * 256, op.param2);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+
+          case OpCode::kAddRandom:
+          case OpCode::kAddRandomEmptyWarps:
+          case OpCode::kAddRandomEmptyThreads:
+            VELOX_CHECK_LE(op.param1, kNumKB);
+            if (stats.isCpu) {
+              addOneRandomCpu(op.param1 * 256, op.param2, op.param4, op.param5);
+            } else {
+              stream_->addOneRandom(
+                  deviceBuffer_->as<int32_t>(),
+                  lookupBuffer_->as<int32_t>(),
+                  op.param1 * 256,
+                  op.param2,
+                  op.param3,
+                  op.param4,
+                  op.param5,
+                  op.opCode == OpCode::kAddRandomEmptyWarps,
+                  op.opCode == OpCode::kAddRandomEmptyThreads);
+            }
+            stats.numAdds += op.param1 * op.param2 * 256;
+            break;
+
+          case OpCode::kSync:
+            if (!stats.isCpu) {
+              stream_->wait();
+            }
+            break;
+          case OpCode::kSyncEvent:
+            if (!stats.isCpu) {
+              event_->record(*stream_);
+              event_->wait();
+            }
+            break;
+          default:
+            VELOX_FAIL("Bad test opcode {}", static_cast<int32_t>(op.opCode));
+        }
+        if (done) {
+          break;
+        }
+      }
+    }
+    stats.endMicros = getCurrentTimeMicro();
+  }
+
+  FOLLY_NOINLINE void addOneCpu(int32_t size, int32_t repeat) {
+    int32_t* ints = hostInts_.get();
+    for (auto counter = 0; counter < repeat; ++counter) {
+      for (auto i = 0; i < size; ++i) {
+        ++ints[i];
+      }
+    }
+  }
+
+  FOLLY_NOINLINE void addOneRandomCpu(
+      uint32_t size,
+      int32_t repeat,
+      int32_t numLocal,
+      int32_t localStride) {
+    int32_t* ints = hostInts_.get();
+    int32_t* lookup = hostLookup_.get();
+    for (uint32_t counter = 0; counter < repeat; ++counter) {
+      for (auto i = 0; i < size; ++i) {
+        auto rnd = scale32(i * (counter + 1) * kPrime32, size);
+        auto sum = lookup[rnd];
+        auto limit =
+            std::min<int32_t>(rnd + localStride * (1 + numLocal), size);
+        for (auto j = rnd + localStride; j < limit; j += localStride) {
+          sum += lookup[j];
+        }
+        ints[i] += sum;
+      }
+    }
+  }
+
+  FOLLY_NOINLINE void addOneCpu64(int32_t size, int32_t repeat) {
+    int64_t* ints = reinterpret_cast<int64_t*>(hostInts_.get());
+    for (auto counter = 0; counter < repeat; ++counter) {
+      for (auto i = 0; i < size; ++i) {
+        ++ints[i];
+      }
+    }
+  }
+
+  Op nextOp(const std::string& str, int32_t& position) {
+    Op op;
+    for (;;) {
+      if (position >= str.size()) {
+        op.opCode = OpCode::kEnd;
+        return op;
+      }
+      switch (str[position]) {
+        case ' ':
+          ++position;
+          break;
+        case 'd':
+          op.opCode = OpCode::kToDevice;
+          ++position;
+          op.param1 = parseInt(str, position, 1);
+          return op;
+        case 'h':
+          op.opCode = OpCode::kToHost;
+          ++position;
+          op.param1 = parseInt(str, position, 1);
+          return op;
+        case 'a':
+          op.opCode = OpCode::kAdd;
+          ++position;
+          if (str[position] == 's') {
+            op.opCode = OpCode::kAddShared;
+            ++position;
+          } else if (str[position] == 'r') {
+            op.opCode = OpCode::kAddReg;
+            ++position;
+          } else if (str[position] == 'f') {
+            op.opCode = OpCode::kAddFunc;
+            ++position;
+          } else if (str[position] == 'F') {
+            op.opCode = OpCode::kAddFuncStore;
+            ++position;
+          } else if (str[position] == 'b') {
+            op.opCode = OpCode::kAddBranch;
+            ++position;
+          } else if (str[position] == 'w') {
+            op.opCode = OpCode::kAddSwitch;
+            ++position;
+          }
+          op.param1 = parseInt(str, position, 1);
+          op.param2 = parseInt(str, position, 1);
+          op.param3 = parseInt(str, position, 10240);
+          return op;
+
+        case 'A':
+          op.opCode = OpCode::kAdd4x64;
+          op.add64Mode = Add64Mode::k4Seq;
+          ++position;
+          if (str[position] == 's') {
+            op.add64Mode = Add64Mode::k4SMemFunc;
+            ++position;
+          } else if (str[position] == 'r') {
+            op.add64Mode = Add64Mode::k4Reg;
+            ++position;
+          } else if (str[position] == 'o') {
+            op.add64Mode = Add64Mode::k1Add;
+            ++position;
+          } else if (str[position] == 'O') {
+            op.add64Mode = Add64Mode::k4Add;
+            ++position;
+          } else if (str[position] == 'c') {
+            op.add64Mode = Add64Mode::k4Coa;
+            ++position;
+          } else if (str[position] == 'f') {
+            op.add64Mode = Add64Mode::k4Func;
+            ++position;
+          } else if (str[position] == 'F') {
+            op.add64Mode = Add64Mode::k1Func;
+            ++position;
+          } else if (str[position] == 'b') {
+            op.add64Mode = Add64Mode::k4Branch;
+            ++position;
+          }
+          op.param1 = parseInt(str, position, 1);
+          op.param2 = parseInt(str, position, 1);
+          op.param3 = parseInt(str, position, 10240);
+          return op;
+
+        case 'w':
+          op.opCode = OpCode::kWideAdd;
+          ++position;
+          op.param1 = parseInt(str, position, 1);
+          op.param2 = parseInt(str, position, 1);
+          return op;
+
+        case 'r':
+          ++position;
+          if (str[position] == 'w') {
+            op.opCode = OpCode::kAddRandomEmptyWarps;
+            ++position;
+          } else if (str[position] == 't') {
+            op.opCode = OpCode::kAddRandomEmptyThreads;
+            ++position;
+          } else {
+            op.opCode = OpCode::kAddRandom;
+          }
+          // Size of data to update and lookup array (KB).
+          op.param1 = parseInt(str, position, 1);
+          // Number of repeats.
+          op.param2 = parseInt(str, position, 1);
+          // target number of  threads in kernel.
+          op.param3 = parseInt(str, position, 10240);
+          // Number of nearby memory accesses
+          op.param4 = parseInt(str, position, 0);
+          // Stride of nearby memory accesses
+          op.param5 = parseInt(str, position, 0);
+          return op;
+
+        case 's':
+          op.opCode = OpCode::kSync;
+          ++position;
+          return op;
+        case 'e':
+          op.opCode = OpCode::kSyncEvent;
+          ++position;
+          return op;
+        default:
+          VELOX_FAIL("No opcode {}", str[position]);
+      }
+    }
+  }
+
+  int32_t parseInt(const std::string& str, int32_t& position, int32_t deflt) {
+    int32_t result = 0;
+    if (position >= str.size()) {
+      return deflt;
+    }
+    if (str[position] == ',') {
+      ++position;
+    } else if (!isdigit(str[position])) {
+      return deflt;
+    }
+    for (;;) {
+      result = 10 * result + str[position++] - '0';
+      if (position == str.size() || !isdigit(str[position])) {
+        break;
+      }
+    }
+    return result;
+  }
+
+  ArenaSet* const arenas_;
+  Device* device_{nullptr};
+  WaveBufferPtr deviceBuffer_;
+  WaveBufferPtr hostBuffer_;
+  WaveBufferPtr lookupBuffer_;
+  std::unique_ptr<int32_t[]> hostLookup_;
+  std::unique_ptr<int32_t[]> hostInts_;
+  std::unique_ptr<TestStream> stream_;
+  std::unique_ptr<Event> event_;
+  int32_t serial_{0};
+  static inline std::atomic<int32_t> serialCounter_{0};
+};
+
 class CudaTest : public testing::Test {
  protected:
   static constexpr int64_t kArenaQuantum = 512 << 20;
@@ -439,7 +1012,7 @@ class CudaTest : public testing::Test {
     hostAllocator_ = getHostAllocator(device_);
   }
 
-  void setupMemory(int64_t capacity = 16UL << 30) {
+  void setupMemory(int64_t capacity = 24UL << 30) {
     static bool inited = false;
     if (!globalSyncExecutor) {
       globalSyncExecutor = std::make_unique<folly::CPUThreadPoolExecutor>(10);
@@ -450,13 +1023,10 @@ class CudaTest : public testing::Test {
     }
     inited = true;
     memory::MemoryManagerOptions options;
-    options.capacity = capacity;
-    memory::MmapAllocator::Options opts{(uint64_t)options.capacity};
-    mmapAllocator_ = std::make_shared<memory::MmapAllocator>(opts);
-    memory::MemoryAllocator::setDefaultInstance(mmapAllocator_.get());
-
-    options.allocator = mmapAllocator_.get();
-    manager_ = &memory::MemoryManager::getInstance(options);
+    options.useMmapAllocator = true;
+    options.allocatorCapacity = capacity;
+    memory::MemoryManager::initialize(options);
+    manager_ = memory::memoryManager();
   }
 
   void waitFinish() {
@@ -520,7 +1090,7 @@ class CudaTest : public testing::Test {
         waitEach(streams, events);
       }
       for (auto i = 0; i < numStreams; ++i) {
-        streams[i]->addOne(ints[i], opSize);
+        streams[i]->incOne(ints[i], opSize);
         if (counter == 0 || counter >= firstNotify) {
           streams[i]->addCallback([&]() {
             auto d = getCurrentTimeMicro() - start;
@@ -611,7 +1181,7 @@ class CudaTest : public testing::Test {
   void createData(int32_t numBatches, int32_t numColumns, int32_t numRows) {
     batches_.clear();
     if (!batchPool_) {
-      batchPool_ = memory::addDefaultLeafMemoryPool();
+      batchPool_ = memory::memoryManager()->addLeafPool();
     }
     int32_t sequence = 1;
     for (auto i = 0; i < numBatches; ++i) {
@@ -736,6 +1306,58 @@ class CudaTest : public testing::Test {
     return gbs;
   }
 
+  void roundtripTest(
+      const std::string& title,
+      const std::vector<std::string>& modeValues,
+      bool isCpu,
+      int numOps = 10000) {
+    auto arenas = getArenas();
+    std::vector<RoundtripStats> allStats;
+    std::vector<int32_t> numThreadsValues = {1, 2, 4, 8, 16, 32};
+    int32_t ordinal = 0;
+    for (auto numThreads : numThreadsValues) {
+      std::vector<RoundtripStats> runStats;
+      for (auto& mode : modeValues) {
+        std::vector<std::thread> threads;
+        std::vector<std::unique_ptr<RoundtripThread>> runs;
+        threads.reserve(numThreads);
+        runs.reserve(numThreads);
+        std::vector<RoundtripStats> threadStats;
+        threadStats.resize(numThreads);
+
+        for (int32_t i = 0; i < numThreads; ++i) {
+          threadStats[i].init(++ordinal, isCpu, numThreads, mode, numOps);
+          runs.push_back(std::make_unique<RoundtripThread>(0, arenas.get()));
+        }
+        for (int32_t i = 0; i < numThreads; ++i) {
+          threads.push_back(std::thread(
+              [i, &runs, &threadStats]() { runs[i]->run(threadStats[i]); }));
+        }
+        for (auto i = 0; i < numThreads; ++i) {
+          threads[i].join();
+          if (i == 0) {
+            allStats.push_back(threadStats[i]);
+          } else {
+            allStats.back().add(threadStats[i]);
+          }
+        }
+        allStats.back().micros =
+            allStats.back().endMicros - allStats.back().startMicros;
+      }
+    }
+    std::sort(
+        allStats.begin(),
+        allStats.end(),
+        [](const RoundtripStats& left, const RoundtripStats& right) {
+          return left.numAdds / left.micros > right.numAdds / right.micros;
+        });
+    std::cout << std::endl << title << std::endl;
+    for (auto& stats : allStats) {
+      std::cout << stats.toString() << std::endl;
+    }
+    releaseArenas(std::move(arenas));
+  }
+
   std::unique_ptr<ArenaSet> getArenas() {
     {
       std::lock_guard<std::mutex> l(mutex_);
@@ -788,7 +1410,7 @@ TEST_F(CudaTest, stream) {
   stream.prefetch(nullptr, ints, opSize * sizeof(int32_t));
   stream.wait();
   for (auto i = 0; i < opSize; ++i) {
-    ASSERT_EQ(ints[i], i + 1);
+    ASSERT_EQ(ints[i], i + (i & 31));
   }
   allocator_->free(ints, sizeof(int32_t) * opSize);
 }
@@ -842,7 +1464,7 @@ TEST_F(CudaTest, reduceMatrix) {
     return;
   }
 
-  std::vector<std::string> modes = {/*"unified", "device",*/ "devicecoalesced"};
+  std::vector<std::string> modes = {"unified", "device", "devicecoalesced"};
   std::vector<int32_t> batchMBValues = {30, 100};
   std::vector<int32_t> numThreadsValues = {1, 2, 3};
   std::vector<int32_t> workPerThreadValues = {2, 4};
@@ -899,12 +1521,147 @@ TEST_F(CudaTest, reduceMatrix) {
   waitFinish();
 }
 
+TEST_F(CudaTest, roundtripMatrix) {
+  if (!FLAGS_roundtrip_ops.empty()) {
+    std::vector<std::string> modes = {FLAGS_roundtrip_ops};
+    roundtripTest(
+        fmt::format("{} GPU, {} repeats", modes[0], FLAGS_gpu_repeats),
+        modes,
+        false,
+        FLAGS_gpu_repeats);
+    roundtripTest(
+        fmt::format("{} CPU, {} repeats", modes[0], FLAGS_cpu_repeats),
+        modes,
+        true,
+        FLAGS_cpu_repeats);
+    return;
+  }
+  if (!FLAGS_enable_bm) {
+    return;
+  }
+  std::vector<std::string> syncModeValues = {
+      "dahs",
+      "dahe",
+      "dsashs",
+      "deaehe",
+      "whs",
+      "d10w10h1sw10h1sw10h1s",
+      "d10a10h1sd1a10h1sd1a10h1s"};
+  roundtripTest("Sync GPU", syncModeValues, false, 10000);
+  roundtripTest("Sync CPU", syncModeValues, true, 10000);
+
+  std::vector<std::string> seqModeValues = {
+      "d10h10h10s",
+      "d100a100h100s",
+      "d1000a1000h1000s",
+      "d1000a1000,10h1000s",
+      "d1000a1000,10h1sd1a1000,5h1s",
+      "d100a100,10h1s",
+      "d1000a1000,30h1sd1a1000,30h1s",
+      "d1000a1000,150h1sd1a1000,150h1s",
+  };
+  roundtripTest("Seq GPU", seqModeValues, false, 32);
+  roundtripTest("Seq CPU", seqModeValues, true, 16);
+
+  std::vector<std::string> randomModeValues = {
+      "d100r100,10h1s",
+      "d100r100,10r100,10h1s",
+      "d100r100,10r100,100h1s",
+      "d100r100,1000h1s",
+      "d1000r1000,10h1s",
+      "d1000r1000,100h1s",
+      "d10000r10000,10h1s",
+      "d30000r30000,50h1s"};
+  roundtripTest("Random GPU", randomModeValues, false, 16);
+  roundtripTest("Random CPU", randomModeValues, true, 8);
+
+  std::vector<std::string> widthModeValues = {
+      "d100r100,10,256h1s",
+      "d100r100,10,1024",
+      "d100r100,10,8192",
+      "d30000r30000,5,256h1s",
+      "d30000r30000,5,256h1s",
+      "d30000r30000,5,512h1s",
+      "d30000r30000,5,2048h1s",
+      "d30000r30000,5,10240h1s",
+      "d30000rw30000,5,10240h1s",
+      "d30000rt30000,5,10240h1s"};
+  roundtripTest("Random GPU, width and conditional", widthModeValues, false, 8);
+}
+
+TEST_F(CudaTest, addRandom) {
+  constexpr int32_t kNumInts = 16 << 20;
+  auto arenas = getArenas();
+  auto stream = std::make_unique<TestStream>();
+  auto indices = arenas->unified->allocate<int32_t>(kNumInts);
+  auto sourceBuffer = arenas->unified->allocate<int32_t>(kNumInts);
+  auto rawIndices = indices->as<int32_t>();
+  for (auto i = 0; i < kNumInts; ++i) {
+    rawIndices[i] = i + 1;
+  }
+  stream->prefetch(getDevice(), rawIndices, indices->capacity());
+  auto ints1 = arenas->unified->allocate<int32_t>(kNumInts);
+  auto rawInts1 = ints1->as<int32_t>();
+  auto ints2 = arenas->unified->allocate<int32_t>(kNumInts);
+  auto rawInts2 = ints2->as<int32_t>();
+  auto ints3 = arenas->unified->allocate<int32_t>(kNumInts);
+  auto rawInts3 = ints3->as<int32_t>();
+  memset(rawInts1, 0, kNumInts * sizeof(int32_t));
+  memset(rawInts2, 0, kNumInts * sizeof(int32_t));
+  memset(rawInts3, 0, kNumInts * sizeof(int32_t));
+  stream->prefetch(getDevice(), rawInts1, ints1->capacity());
+  stream->prefetch(getDevice(), rawInts2, ints2->capacity());
+  stream->prefetch(getDevice(), rawInts3, ints3->capacity());
+  // Let prefetch finish.
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  // warm up.
+  stream->addOneRandom(rawInts1, rawIndices, kNumInts, 20, 10240);
+  stream->addOneRandom(rawInts2, rawIndices, kNumInts, 20, 10240, true);
+  stream->addOneRandom(rawInts3, rawIndices, kNumInts, 20, 10240, false, true);
+  stream->wait();
+
+  uint64_t time1 = 0;
+  uint64_t time2 = 0;
+  uint64_t time3 = 0;
+  for (auto count = 0; count < 20; ++count) {
+    {
+      MicrosecondTimer t(&time1);
+      stream->addOneRandom(rawInts1, rawIndices, kNumInts, 20, 10240);
+      stream->wait();
+    }
+    {
+      MicrosecondTimer t(&time2);
+      stream->addOneRandom(rawInts2, rawIndices, kNumInts, 20, 10240, true);
+      stream->wait();
+    }
+    {
+      MicrosecondTimer t(&time3);
+      stream->addOneRandom(
+          rawInts3, rawIndices, kNumInts, 20, 10240, false, true);
+      stream->wait();
+    }
+  }
+  std::cout << fmt::format(
+                   "All {}, half warps {} half threads {}", time1, time2, time3)
+            << std::endl;
+
+  stream->prefetch(nullptr, rawInts1, ints1->capacity());
+  stream->prefetch(nullptr, rawInts2, ints2->capacity());
+  stream->prefetch(nullptr, rawInts3, ints3->capacity());
+
+  EXPECT_EQ(0, memcmp(rawInts1, rawInts2, kNumInts * sizeof(int32_t)));
+  EXPECT_EQ(0, memcmp(rawInts1, rawInts3, kNumInts * sizeof(int32_t)));
+}
+
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   if (int device; cudaGetDevice(&device) != cudaSuccess) {
     LOG(WARNING) << "No CUDA detected, skipping all tests";
     return 0;
   }
+  if (FLAGS_list_kernels) {
+    printKernels();
+  }
   return RUN_ALL_TESTS();
 }
diff --git a/velox/experimental/wave/common/tests/CudaTest.cu b/velox/experimental/wave/common/tests/CudaTest.cu
index 31593a6750969..31f2b964800bd 100644
--- a/velox/experimental/wave/common/tests/CudaTest.cu
+++ b/velox/experimental/wave/common/tests/CudaTest.cu
@@ -14,30 +14,978 @@
  * limitations under the License.
  */
 
+#include <assert.h>
+#include "velox/experimental/wave/common/Block.cuh"
 #include "velox/experimental/wave/common/CudaUtil.cuh"
 #include "velox/experimental/wave/common/tests/CudaTest.h"
 
 namespace facebook::velox::wave {
+constexpr uint32_t kPrime32 = 1815531889;
 
-__global__ void addOneKernel(int32_t* numbers, int32_t size, int32_t stride) {
-  auto index = blockDim.x * blockIdx.x + threadIdx.x;
-  for (; index < size; index += stride) {
-    ++numbers[index];
+struct ResultPair {
+  int64_t n;
+  bool f;
+};
+
+typedef ResultPair (
+    *TestFunc)(int64_t data, int64_t data2, bool& flag, int32_t* ptr);
+
+__device__ TestFunc testFuncs[2];
+
+__device__ ResultPair
+testFunc(int64_t data, int64_t data2, bool& flag, int32_t* ptr) {
+  return {data + (data2 & 31), false};
+}
+
+void __global__ setupFuncs() {
+  testFuncs[0] = testFunc;
+  testFuncs[1] = testFunc;
+}
+
+__global__ void
+incOneKernel(int32_t* numbers, int32_t size, int32_t stride, int32_t repeats) {
+  for (auto counter = 0; counter < repeats; ++counter) {
+    for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+         index += stride) {
+      ++numbers[index];
+    }
+    __syncthreads();
+  }
+}
+
+__global__ void
+addOneKernel(int32_t* numbers, int32_t size, int32_t stride, int32_t repeats) {
+  for (auto counter = 0; counter < repeats; ++counter) {
+    for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+         index += stride) {
+      numbers[index] += index & 31;
+    }
+    __syncthreads();
+  }
+}
+
+__global__ void addOneSharedKernel(
+    int32_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  extern __shared__ __align__(16) char smem[];
+  int32_t* temp = reinterpret_cast<int32_t*>(smem);
+  for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+       index += stride) {
+    temp[threadIdx.x] = numbers[index];
+    for (auto counter = 0; counter < repeats; ++counter) {
+      temp[threadIdx.x] += (index + counter) & 31;
+    }
+    __syncthreads();
+    numbers[index] = temp[threadIdx.x];
+  }
+}
+
+__global__ void addOneRegKernel(
+    int32_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+       index += stride) {
+    auto temp = numbers[index];
+    for (auto counter = 0; counter < repeats; ++counter) {
+      temp += (index + counter) & 31;
+    }
+    __syncthreads();
+    numbers[index] = temp;
+  }
+}
+
+__global__ void addOneFuncKernel(
+    int32_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+       index += stride) {
+    int32_t* ptr = nullptr;
+    bool flag;
+    auto temp = numbers[index];
+    for (auto counter = 0; counter < repeats; ++counter) {
+      auto result = testFuncs[counter & 1](temp, counter, flag, ptr);
+      temp = result.n;
+    }
+    __syncthreads();
+    numbers[index] = temp;
+  }
+}
+
+#define TCASE(nn, m)                                 \
+  case nn:                                           \
+    temp = m + testFunc(temp, counter, flag, ptr).n; \
+    break;
+
+__global__ void addOneSwitchKernel(
+    int32_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+       index += stride) {
+    int32_t* ptr = nullptr;
+    bool flag;
+    auto temp = numbers[index];
+    for (auto counter = 0; counter < repeats; ++counter) {
+      switch (counter & 31) {
+        TCASE(0, 1);
+        TCASE(1, 82);
+        TCASE(2, 91);
+        TCASE(3, 181);
+        TCASE(4, 28);
+        TCASE(5, 36);
+        TCASE(6, 18);
+        TCASE(7, 13);
+        TCASE(8, 21);
+        TCASE(9, 32);
+        TCASE(10, 31);
+        TCASE(11, 191);
+        TCASE(12, 181);
+        TCASE(13, 151);
+        TCASE(14, 121);
+        TCASE(15, 111);
+        TCASE(16, 1);
+        TCASE(17, 82);
+        TCASE(18, 91);
+        TCASE(19, 181);
+        TCASE(20, 28);
+        TCASE(21, 36);
+        TCASE(22, 18);
+        TCASE(23, 13);
+        TCASE(24, 21);
+        TCASE(25, 32);
+        TCASE(26, 31);
+        TCASE(27, 191);
+        TCASE(28, 181);
+        TCASE(29, 151);
+        TCASE(30, 121);
+        TCASE(31, 111);
+      }
+    }
+    __syncthreads();
+    numbers[index] = temp;
+  }
+}
+
+#define BTCASE(nn, m)                              \
+  asm volatile("BLK" nn ":");                      \
+  temp = m + testFunc(temp, counter, flag, ptr).n; \
+  if (repeats < 1000000000)                        \
+    goto end;
+
+__global__ void addOneBranchKernel(
+    int32_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+       index += stride) {
+    int32_t* ptr = nullptr;
+    bool flag;
+    auto temp = numbers[index];
+
+#pragma unroll 1
+    for (auto counter = 0; counter < repeats; ++counter) {
+#if 0
+      if (repeats > 100000000) {
+      switch (repeats) {
+      case 100000001: asm volatile("bra BLK1;");
+      case 100000002: asm volatile("bra BLK2;");
+	break;
+      }
+    }
+#endif
+      uint32_t bits = counter & 31;
+      asm volatile(
+          "ts: .branchtargets BLK0, BLK1, BLK2, BLK3, BLK4, BLK5, BLK6, BLK7, BLK8, BLK9, BLK10, BLK11, BLK12, BLK13, BLK14, BLK15, BLK16, BLK17, BLK18, BLK19, BLK20, BLK21, BLK22, BLK23, BLK24, BLK25, BLK26, BLK27, BLK28, BLK29, BLK30, BLK31;");
+      asm volatile("brx.idx %0, ts;" ::"r"(bits));
+
+      BTCASE("0", 1);
+      BTCASE("1", 82);
+      BTCASE("2", 91);
+      BTCASE("3", 181);
+      BTCASE("4", 28);
+      BTCASE("5", 36);
+      BTCASE("6", 18);
+      BTCASE("7", 13);
+      BTCASE("8", 21);
+      BTCASE("9", 32);
+      BTCASE("10", 31);
+      BTCASE("11", 191);
+      BTCASE("12", 181);
+      BTCASE("13", 151);
+      BTCASE("14", 121);
+      BTCASE("15", 111);
+      BTCASE("16", 1);
+      BTCASE("17", 82);
+      BTCASE("18", 91);
+      BTCASE("19", 181);
+      BTCASE("20", 28);
+      BTCASE("21", 36);
+      BTCASE("22", 18);
+      BTCASE("23", 13);
+      BTCASE("24", 21);
+      BTCASE("25", 32);
+      BTCASE("26", 31);
+      BTCASE("27", 191);
+      BTCASE("28", 181);
+      BTCASE("29", 151);
+      BTCASE("30", 121);
+      BTCASE("31", 111);
+    end:;
+    }
+
+    __syncthreads();
+    numbers[index] = temp;
+  }
+}
+
+__global__ void addOneFuncStoreKernel(
+    int32_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  for (auto counter = 0; counter < repeats; ++counter) {
+    for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+         index += stride) {
+      int32_t* ptr = nullptr;
+      bool flag;
+      auto temp = numbers[index];
+      numbers[index] = testFuncs[counter & 1](temp, counter, flag, ptr).n;
+    }
+    __syncthreads();
   }
 }
 
-void TestStream::addOne(int32_t* numbers, int32_t size) {
-  constexpr int32_t kWidth = 10240;
+void TestStream::incOne(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width) {
   constexpr int32_t kBlockSize = 256;
   auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
   int32_t stride = size;
-  if (numBlocks > kWidth / kBlockSize) {
-    stride = kWidth;
-    numBlocks = kWidth / kBlockSize;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  incOneKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(
+      numbers, size, stride, repeats);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void TestStream::addOne(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width) {
+  constexpr int32_t kBlockSize = 256;
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
   }
   addOneKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(
-      numbers, size, stride);
+      numbers, size, stride, repeats);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void TestStream::addOneReg(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width) {
+  constexpr int32_t kBlockSize = 256;
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  addOneRegKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(
+      numbers, size, stride, repeats);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void TestStream::addOneFunc(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width) {
+  constexpr int32_t kBlockSize = 256;
+  setupFuncs<<<1, 1, 0, stream_->stream>>>();
+  CUDA_CHECK(cudaGetLastError());
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  addOneFuncKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(
+      numbers, size, stride, repeats);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void TestStream::addOneFuncStore(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width) {
+  constexpr int32_t kBlockSize = 256;
+  setupFuncs<<<1, 1, 0, stream_->stream>>>();
+  CUDA_CHECK(cudaGetLastError());
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  addOneFuncStoreKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(
+      numbers, size, stride, repeats);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void TestStream::addOneBranch(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width) {
+  constexpr int32_t kBlockSize = 256;
+  setupFuncs<<<1, 1, 0, stream_->stream>>>();
+  CUDA_CHECK(cudaGetLastError());
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  addOneBranchKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(
+      numbers, size, stride, repeats);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void TestStream::addOneSwitch(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width) {
+  constexpr int32_t kBlockSize = 256;
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  addOneSwitchKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(
+      numbers, size, stride, repeats);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+void TestStream::addOneShared(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width) {
+  constexpr int32_t kBlockSize = 256;
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  addOneSharedKernel<<<
+      numBlocks,
+      kBlockSize,
+      kBlockSize * sizeof(int32_t),
+      stream_->stream>>>(numbers, size, stride, repeats);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+__global__ void addOneWideKernel(WideParams params) {
+  auto numbers = params.numbers;
+  auto size = params.size;
+  auto repeat = params.repeat;
+  auto stride = params.stride;
+  for (auto counter = 0; counter < repeat; ++counter) {
+    for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+         index += stride) {
+      ++numbers[index];
+    }
+  }
+}
+
+void TestStream::addOneWide(
+    int32_t* numbers,
+    int32_t size,
+    int32_t repeat,
+    int32_t width) {
+  constexpr int32_t kBlockSize = 256;
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  WideParams params;
+  params.numbers = numbers;
+  params.size = size;
+  params.stride = stride;
+  params.repeat = repeat;
+  addOneWideKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(params);
+  CUDA_CHECK(cudaGetLastError());
+}
+
+__global__ void __launch_bounds__(1024) addOneRandomKernel(
+    int32_t* numbers,
+    const int32_t* lookup,
+    uint32_t size,
+    int32_t stride,
+    int32_t repeats,
+    int32_t numLocal,
+    int32_t localStride,
+    bool emptyWarps,
+    bool emptyThreads) {
+  for (uint32_t counter = 0; counter < repeats; ++counter) {
+    if (emptyWarps) {
+      if (((threadIdx.x / 32) & 1) == 0) {
+        for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+             index += stride) {
+          auto rnd = deviceScale32(index * (counter + 1) * kPrime32, size);
+          auto sum = lookup[rnd];
+          auto limit = min(rnd + localStride * (1 + numLocal), size);
+          for (auto j = rnd + localStride; j < limit; j += localStride) {
+            sum += lookup[j];
+          }
+          numbers[index] += sum;
+
+          rnd = deviceScale32((index + 32) * (counter + 1) * kPrime32, size);
+          sum = lookup[rnd];
+          limit = min(rnd + localStride * (1 + numLocal), size);
+          for (auto j = rnd + localStride; j < limit; j += localStride) {
+            sum += lookup[j];
+          }
+          numbers[index + 32] += sum;
+        }
+      }
+    } else if (emptyThreads) {
+      if ((threadIdx.x & 1) == 0) {
+        for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+             index += stride) {
+          auto rnd = deviceScale32(index * (counter + 1) * kPrime32, size);
+          auto sum = lookup[rnd];
+          auto limit = min(rnd + localStride * (1 + numLocal), size);
+          for (auto j = rnd + localStride; j < limit; j += localStride) {
+            sum += lookup[j];
+          }
+          numbers[index] += sum;
+
+          rnd = deviceScale32((index + 1) * (counter + 1) * kPrime32, size);
+          sum = lookup[rnd];
+          limit = min(rnd + localStride * (1 + numLocal), size);
+          for (auto j = rnd + localStride; j < limit; j += localStride) {
+            sum += lookup[j];
+          }
+          numbers[index + 1] += sum;
+        }
+      }
+    } else {
+      for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+           index += stride) {
+        auto rnd = deviceScale32(index * (counter + 1) * kPrime32, size);
+        auto sum = lookup[rnd];
+        auto limit = min(rnd + localStride * (1 + numLocal), size);
+        for (auto j = rnd + localStride; j < limit; j += localStride) {
+          sum += lookup[j];
+        }
+        numbers[index] += sum;
+      }
+    }
+    __syncthreads();
+  }
+  __syncthreads();
+}
+
+__global__ void __launch_bounds__(1024) addOneRandomPrefetchKernel(
+    int32_t* numbers,
+    const int32_t* lookup,
+    uint32_t size,
+    int32_t stride,
+    int32_t repeats,
+    int32_t numLocal,
+    int32_t localStride,
+    bool emptyWarps,
+    bool emptyThreads) {
+  for (uint32_t counter = 0; counter < repeats; ++counter) {
+    if (emptyWarps) {
+      if (((threadIdx.x / 32) & 1) == 0) {
+        for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+             index += stride) {
+          auto rnd = deviceScale32(index * (counter + 1) * kPrime32, size);
+          auto sum = lookup[rnd];
+          auto limit = min(rnd + localStride * (1 + numLocal), size);
+          for (auto j = rnd + localStride; j < limit; j += localStride) {
+            sum += lookup[j];
+          }
+          numbers[index] += sum;
+
+          rnd = deviceScale32((index + 32) * (counter + 1) * kPrime32, size);
+          sum = lookup[rnd];
+          limit = min(rnd + localStride * (1 + numLocal), size);
+          for (auto j = rnd + localStride; j < limit; j += localStride) {
+            sum += lookup[j];
+          }
+          numbers[index + 32] += sum;
+        }
+      }
+    } else if (emptyThreads) {
+      if ((threadIdx.x & 1) == 0) {
+        for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+             index += stride) {
+          auto rnd = deviceScale32(index * (counter + 1) * kPrime32, size);
+          auto sum = lookup[rnd];
+          auto limit = min(rnd + localStride * (1 + numLocal), size);
+          for (auto j = rnd + localStride; j < limit; j += localStride) {
+            sum += lookup[j];
+          }
+          numbers[index] += sum;
+
+          rnd = deviceScale32((index + 1) * (counter + 1) * kPrime32, size);
+          sum = lookup[rnd];
+          limit = min(rnd + localStride * (1 + numLocal), size);
+          for (auto j = rnd + localStride; j < limit; j += localStride) {
+            sum += lookup[j];
+          }
+          numbers[index + 1] += sum;
+        }
+      }
+    } else {
+      for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+           index += stride) {
+        auto rnd = deviceScale32(index * (counter + 1) * kPrime32, size);
+        auto sum = lookup[rnd];
+        auto limit = min(rnd + localStride * (1 + numLocal), size);
+        for (auto j = rnd + localStride; j < limit; j += localStride) {
+          sum += lookup[j];
+        }
+        numbers[index] += sum;
+      }
+    }
+    __syncthreads();
+  }
+  __syncthreads();
+}
+
+void TestStream::addOneRandom(
+    int32_t* numbers,
+    const int32_t* lookup,
+    int32_t size,
+    int32_t repeats,
+    int32_t width,
+    int32_t numLocal,
+    int32_t localStride,
+    bool emptyWarps,
+    bool emptyThreads) {
+  constexpr int32_t kBlockSize = 256;
+  auto numBlocks = roundUp(size, kBlockSize) / kBlockSize;
+  int32_t stride = size;
+  if (numBlocks > width / kBlockSize) {
+    stride = width;
+    numBlocks = width / kBlockSize;
+  }
+  addOneRandomKernel<<<numBlocks, kBlockSize, 0, stream_->stream>>>(
+      numbers,
+      lookup,
+      size,
+      stride,
+      repeats,
+      numLocal,
+      localStride,
+      emptyWarps,
+      emptyThreads);
   CUDA_CHECK(cudaGetLastError());
 }
 
+/// Memory width and stride
+__global__ void addOne64Kernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  for (auto counter = 0; counter < repeats; ++counter) {
+    for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+         index += stride) {
+      numbers[index] += index & 31;
+    }
+    __syncthreads();
+  }
+}
+
+__global__ void addOne4x64ConsecKernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  for (auto counter = 0; counter < repeats; ++counter) {
+    for (auto index = 4 * (blockDim.x * blockIdx.x + threadIdx.x); index < size;
+         index += stride) {
+      long2 l1 = *addCast<long2>(numbers, sizeof(int64_t) * index);
+      long2 l2 = *addCast<long2>(numbers, sizeof(int64_t) * (index + 2));
+      l1.x += index & 31;
+      l1.y += (index + 1) & 31;
+      l2.x += (index + 2) & 31;
+      l2.y += (index + 3) & 31;
+      *addCast<long2>(numbers, sizeof(int64_t) * index) = l1;
+      *addCast<long2>(numbers, sizeof(int64_t) * (index + 2)) = l2;
+    }
+    __syncthreads();
+  }
+}
+
+__global__ void addOne1x64Kernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  int32_t stride1 = stride / 4;
+  for (auto counter = 0; counter < repeats; ++counter) {
+    for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+         index += stride1) {
+      numbers[index] += 31 & index;
+    }
+    __syncthreads();
+  }
+}
+
+__global__ void addOne4Ox64Kernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  int32_t stride1 = stride / 4;
+  for (auto counter = 0; counter < repeats; ++counter) {
+    for (auto index = blockDim.x * blockIdx.x + threadIdx.x; index < size;
+         index += stride) {
+      numbers[index] += 31 & index;
+      numbers[index + stride1] += 31 & index;
+      numbers[index + stride1 * 2] += 31 & index;
+      numbers[index + stride1 * 3] += 31 & index;
+    }
+    __syncthreads();
+  }
+}
+
+__global__ void addOne4x64CoaKernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  int32_t halfStride = stride / 2;
+  for (auto counter = 0; counter < repeats; ++counter) {
+    for (auto index = 4 * (blockDim.x * blockIdx.x + threadIdx.x); index < size;
+         index += stride) {
+      long2 l1 = *addCast<long2>(numbers, sizeof(int64_t) * index);
+      long2 l2 =
+          *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride));
+      l1.x += index & 31;
+      l1.y += (index + 1) & 31;
+      l2.x += (index + halfStride) & 31;
+      l2.y += (index + halfStride + 1) & 31;
+      *addCast<long2>(numbers, sizeof(int64_t) * index) = l1;
+      *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride)) = l2;
+    }
+    __syncthreads();
+  }
+}
+
+struct Params1 {
+  int64_t n;
+  bool flag;
+};
+
+struct Params4 {
+  long2 l1;
+  long2 l2;
+  int32_t flags;
+};
+
+typedef Params4 (*TestFunc4)(Params4 params, int32_t index, long* args);
+
+__device__ Params4 testFunc4(Params4 params, int32_t index, long* args) {
+  params.l1.x += 32 & index;
+  params.l1.y = 31 & (index + 1);
+  params.l2.x += 31 & (index + 2);
+  params.l2.y += 31 & (index + 3);
+  return params;
+}
+
+__device__ TestFunc4 testFuncs4[2];
+
+typedef void (*TestFunc4SMem)(int64_t* params, int32_t index, int64_t* args);
+__device__ void testFunc4SMem(int64_t* smem, int32_t index, long* args) {
+  if ((index & 1) == 1) {
+    for (auto i = index; i < index + 4; ++i) {
+      i += smem[index];
+    }
+  }
+  long2 l1 = *addCast<long2>(smem, 0);
+  long2 l2 = *addCast<long2>(smem, 16);
+  l1.x += 32 & index;
+  l1.y = 31 & (index + 1);
+  l2.x += 31 & (index + 2);
+  l2.y += 31 & (index + 3);
+  *addCast<long2>(smem, 0) = l1;
+  *addCast<long2>(smem, 16) = l2;
+}
+
+__device__ TestFunc4SMem testFuncs4SMem[2];
+
+__global__ void setupFuncs4() {
+  testFuncs[0] = testFunc;
+  testFuncs[1] = testFunc;
+  testFuncs4[0] = testFunc4;
+  testFuncs4[1] = testFunc4;
+  testFuncs4SMem[0] = testFunc4SMem;
+  testFuncs4SMem[1] = testFunc4SMem;
+}
+
+__global__ void addOne4x64RegKernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  int32_t halfStride = stride / 2;
+  for (auto index = 4 * (blockDim.x * blockIdx.x + threadIdx.x); index < size;
+       index += stride) {
+    long2 l1 = *addCast<long2>(numbers, sizeof(int64_t) * index);
+    long2 l2 = *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride));
+
+    for (auto counter = 0; counter < repeats; ++counter) {
+      l1.x += index & 31;
+      l1.y += (index + 1) & 31;
+      l2.x += (index + halfStride) & 31;
+      l2.y += (index + halfStride + 1) & 31;
+    }
+    *addCast<long2>(numbers, sizeof(int64_t) * (index)) = l1;
+    *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride)) = l2;
+
+    __syncthreads();
+  }
+}
+
+#define BTCASE4(nn, m)                            \
+  asm volatile("BLK" nn ":");                     \
+  params = testFunc4(params, index + m, nullptr); \
+  if (repeats < 1000000000)                       \
+    goto end;
+
+void __global__ __launch_bounds__(1024) addOne4x64BranchKernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  int32_t halfStride = stride / 2;
+  for (auto index = 4 * (blockDim.x * blockIdx.x + threadIdx.x); index < size;
+       index += stride) {
+    Params4 params;
+    params.l1 = *addCast<long2>(numbers, sizeof(int64_t) * index);
+    params.l2 =
+        *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride));
+    for (auto counter = 0; counter < repeats; ++counter) {
+      asm volatile(
+          "ts: .branchtargets BLK0, BLK1, BLK2, BLK3, BLK4, BLK5, BLK6, BLK7, BLK8, BLK9, BLK10, BLK11, BLK12, BLK13, BLK14, BLK15, BLK16, BLK17, BLK18, BLK19, BLK20, BLK21, BLK22, BLK23, BLK24, BLK25, BLK26, BLK27, BLK28, BLK29, BLK30, BLK31;");
+      asm volatile("brx.idx %0, ts;" ::"r"(counter & 31));
+
+      BTCASE4("0", 1);
+      BTCASE4("1", 82);
+      BTCASE4("2", 91);
+      BTCASE4("3", 181);
+      BTCASE4("4", 28);
+      BTCASE4("5", 36);
+      BTCASE4("6", 18);
+      BTCASE4("7", 13);
+      BTCASE4("8", 21);
+      BTCASE4("9", 32);
+      BTCASE4("10", 31);
+      BTCASE4("11", 191);
+      BTCASE4("12", 181);
+      BTCASE4("13", 151);
+      BTCASE4("14", 121);
+      BTCASE4("15", 111);
+      BTCASE4("16", 1);
+      BTCASE4("17", 82);
+      BTCASE4("18", 91);
+      BTCASE4("19", 181);
+      BTCASE4("20", 28);
+      BTCASE4("21", 36);
+      BTCASE4("22", 18);
+      BTCASE4("23", 13);
+      BTCASE4("24", 21);
+      BTCASE4("25", 32);
+      BTCASE4("26", 31);
+      BTCASE4("27", 191);
+      BTCASE4("28", 181);
+      BTCASE4("29", 151);
+      BTCASE4("30", 121);
+      BTCASE4("31", 111);
+    end:;
+    }
+    *addCast<long2>(numbers, sizeof(int64_t) * (index)) = params.l1;
+    *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride)) =
+        params.l2;
+
+    __syncthreads();
+  }
+}
+
+__global__ void addOne4x64FuncKernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  int32_t halfStride = stride / 2;
+  for (auto index = 4 * (blockDim.x * blockIdx.x + threadIdx.x); index < size;
+       index += stride) {
+    Params4 params;
+    params.l1 = *addCast<long2>(numbers, sizeof(int64_t) * index);
+    params.l2 =
+        *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride));
+    for (auto counter = 0; counter < repeats; ++counter) {
+      params = testFuncs4[counter & 1](params, index, nullptr);
+    }
+    *addCast<long2>(numbers, sizeof(int64_t) * (index)) = params.l1;
+    *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride)) =
+        params.l2;
+
+    __syncthreads();
+  }
+}
+
+__global__ void addOne1x64FuncKernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  int32_t stride1 = stride / 4;
+  for (auto index = (blockDim.x * blockIdx.x + threadIdx.x); index < size;
+       index += stride1) {
+    ResultPair r;
+    r.n = numbers[index];
+    bool flag;
+    for (auto counter = 0; counter < repeats; ++counter) {
+      r = testFuncs[counter & 1](r.n, 0, flag, nullptr);
+    }
+    numbers[index] = r.n;
+    __syncthreads();
+  }
+}
+
+__global__ void addOne4x64SMemFuncKernel(
+    int64_t* numbers,
+    int32_t size,
+    int32_t stride,
+    int32_t repeats) {
+  int32_t halfStride = stride / 2;
+  extern __shared__ __align__(16) char smemBase[];
+
+  for (auto index = 4 * (blockDim.x * blockIdx.x + threadIdx.x); index < size;
+       index += stride) {
+    long2* smem = addCast<long2>(smemBase, threadIdx.x * 4 * sizeof(int64_t));
+    *smem = *addCast<long2>(numbers, sizeof(int64_t) * index);
+    smem[1] = *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride));
+    for (auto counter = 0; counter < repeats; ++counter) {
+      testFuncs4SMem[counter & 1](
+          reinterpret_cast<int64_t*>(smem), index, nullptr);
+    }
+    *addCast<long2>(numbers, sizeof(int64_t) * (index)) = smem[0];
+    *addCast<long2>(numbers, sizeof(int64_t) * (index + halfStride)) = smem[1];
+    __syncthreads();
+  }
+}
+
+void TestStream::addOne4x64(
+    int64_t* numbers,
+    int32_t size,
+    int32_t repeats,
+    int32_t width,
+    Add64Mode mode) {
+  constexpr int32_t kBlockSize = 256;
+  constexpr int32_t kNumPerThread = 4;
+  setupFuncs4<<<1, 1, 0, stream_->stream>>>();
+  CUDA_CHECK(cudaGetLastError());
+  int32_t numThreads = size / kNumPerThread;
+  auto numBlocks = roundUp(size / kNumPerThread, kBlockSize) / kBlockSize;
+  int32_t stride = numThreads;
+  if (numBlocks > (width / (kBlockSize * kNumPerThread))) {
+    stride = width * kNumPerThread;
+    numBlocks = width / kBlockSize;
+  }
+  int32_t smem = 0;
+  if (mode == Add64Mode::k4SMem || mode == Add64Mode::k4SMemFunc) {
+    smem = 5 * kBlockSize * sizeof(int64_t);
+  }
+  switch (mode) {
+    case Add64Mode::k4Seq:
+      addOne4x64ConsecKernel<<<numBlocks, kBlockSize, smem, stream_->stream>>>(
+          numbers, size, stride, repeats);
+      break;
+    case Add64Mode::k4Add:
+      addOne4Ox64Kernel<<<numBlocks, kBlockSize, smem, stream_->stream>>>(
+          numbers, size, stride, repeats);
+      break;
+
+    case Add64Mode::k4Coa:
+      addOne4x64CoaKernel<<<numBlocks, kBlockSize, smem, stream_->stream>>>(
+          numbers, size, stride, repeats);
+      break;
+    case Add64Mode::k4Reg:
+      addOne4x64RegKernel<<<numBlocks, kBlockSize, smem, stream_->stream>>>(
+          numbers, size, stride, repeats);
+      break;
+    case Add64Mode::k4Branch:
+      addOne4x64BranchKernel<<<numBlocks, kBlockSize, smem, stream_->stream>>>(
+          numbers, size, stride, repeats);
+      break;
+
+    case Add64Mode::k4Func:
+      addOne4x64FuncKernel<<<numBlocks, kBlockSize, smem, stream_->stream>>>(
+          numbers, size, stride, repeats);
+      break;
+    case Add64Mode::k1Func:
+      addOne1x64FuncKernel<<<numBlocks, kBlockSize, smem, stream_->stream>>>(
+          numbers, size, stride, repeats);
+      break;
+
+    case Add64Mode::k4SMemFunc:
+      addOne4x64SMemFuncKernel<<<
+          numBlocks,
+          kBlockSize,
+          smem,
+          stream_->stream>>>(numbers, size, stride, repeats);
+      break;
+    case Add64Mode::k1Add:
+      addOne1x64Kernel<<<numBlocks, kBlockSize, smem, stream_->stream>>>(
+          numbers, size, stride, repeats);
+      break;
+
+    default:
+      assert(false);
+  }
+  CUDA_CHECK(cudaGetLastError());
+}
+
+REGISTER_KERNEL("addOne", addOneKernel);
+REGISTER_KERNEL("addOneFunc", addOneFuncKernel);
+REGISTER_KERNEL("addOneWide", addOneWideKernel);
+REGISTER_KERNEL("addOneRandom", addOneRandomKernel);
+REGISTER_KERNEL("add4x64branch", addOne4x64BranchKernel);
+REGISTER_KERNEL("add4x64func", addOne4x64FuncKernel);
+REGISTER_KERNEL("add4x64smemfunc", addOne4x64SMemFuncKernel);
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/CudaTest.h b/velox/experimental/wave/common/tests/CudaTest.h
index 3356802ce4e53..0aef5b58e6232 100644
--- a/velox/experimental/wave/common/tests/CudaTest.h
+++ b/velox/experimental/wave/common/tests/CudaTest.h
@@ -22,10 +22,126 @@
 
 namespace facebook::velox::wave {
 
+struct WideParams {
+  int32_t size;
+  int32_t* numbers;
+  int32_t stride;
+  int32_t repeat;
+  char data[4000];
+  void* result;
+};
+
+enum class Add64Mode {
+  k1Add,
+  k4Add,
+  k4Seq,
+  k4Coa,
+  k4Reg,
+  k4SMem,
+  k4Branch,
+  k4Func,
+  k4SMemFunc,
+  k1Func
+};
+
 class TestStream : public Stream {
  public:
-  // Queues a kernel to add 1 to numbers[0...size - 1].
-  void addOne(int32_t* numbers, int size);
+  // Queues a kernel to add 1 to numbers[0...size - 1]. The kernel repeats
+  // 'repeat' times.
+  void
+  incOne(int32_t* numbers, int size, int32_t repeat = 1, int32_t width = 10240);
+
+  /// Like incOne but adds idx & 31 to numbers[idx].
+  void
+  addOne(int32_t* numbers, int size, int32_t repeat = 1, int32_t width = 10240);
+
+  void addOneWide(
+      int32_t* numbers,
+      int32_t size,
+      int32_t repeat = 1,
+      int32_t width = 10240);
+
+  /// Like addOne but uses shared memory for intermediates, with global
+  /// ead/write at start/end.
+  void addOneShared(
+      int32_t* numbers,
+      int32_t size,
+      int32_t repeat = 1,
+      int32_t width = 10240);
+
+  /// Like addOne but uses registers for intermediates.
+  void addOneReg(
+      int32_t* numbers,
+      int32_t size,
+      int32_t repeat = 1,
+      int32_t width = 10240);
+
+  /// Like addOneReg but does an indirect function call in the inner loop.
+  void addOneFunc(
+      int32_t* numbers,
+      int32_t size,
+      int32_t repeat = 1,
+      int32_t width = 10240);
+
+  void addOneFuncStore(
+      int32_t* numbers,
+      int32_t size,
+      int32_t repeat = 1,
+      int32_t width = 10240);
+
+  /// addOne with indirect jump.
+  void addOneBranch(
+      int32_t* numbers,
+      int32_t size,
+      int32_t repeat = 1,
+      int32_t width = 10240);
+
+  /// addOne with switch.
+  void addOneSwitch(
+      int32_t* numbers,
+      int32_t size,
+      int32_t repeat = 1,
+      int32_t width = 10240);
+
+  void addOne4x64(
+      int64_t* numbers,
+      int32_t size,
+      int32_t repeats,
+      int32_t width,
+      Add64Mode mode);
+
+  /// Increments each of 'numbers by a deterministic pseudorandom
+  /// increment from 'lookup'. If 'numLocal is non-0, also accesses
+  /// 'numLocal' adjacent positions in 'lookup' with a stride of
+  /// 'localStride'.  If 'emptyWarps' is true, odd warps do no work
+  /// but still sync with the other ones with __syncthreads().  If
+  /// 'emptyThreads' is true, odd lanes do no work and even lanes do
+  /// their work instead.
+  void addOneRandom(
+      int32_t* numbers,
+      const int32_t* lookup,
+      int size,
+      int32_t repeat = 1,
+      int32_t width = 10240,
+      int32_t numLocal = 0,
+      int32_t localStride = 0,
+      bool emptyWarps = false,
+      bool emptyLanes = false);
+
+  // Makes random lookup keys and increments, starting at 'startCount'
+  // columns[0] is keys. 'powerOfTwo' is the next power of two from
+  // 'keyRange'. If 'powerOfTwo' is 0 the key columns are set to
+  // zero. Otherwise the key column values are incremented by a a
+  // delta + index of column where delta for element 0 is startCount &
+  // (powerOfTwo - 1).
+  void makeInput(
+      int32_t numRows,
+      int32_t keyRange,
+      int32_t powerOfTwo,
+      int32_t startCount,
+      uint64_t* hash,
+      uint8_t numColumns,
+      int64_t** columns);
 };
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/GpuArenaTest.cpp b/velox/experimental/wave/common/tests/GpuArenaTest.cpp
index f451980020619..a3bca9a2080b4 100644
--- a/velox/experimental/wave/common/tests/GpuArenaTest.cpp
+++ b/velox/experimental/wave/common/tests/GpuArenaTest.cpp
@@ -155,3 +155,23 @@ TEST_F(GpuArenaTest, buffers) {
   buffers.clear();
   EXPECT_EQ(1, arena->slabs().size());
 }
+
+TEST_F(GpuArenaTest, views) {
+  auto arena = std::make_unique<GpuArena>(1 << 20, allocator_.get());
+  WaveBufferPtr buffer = arena->allocate<char>(1024);
+  EXPECT_EQ(1, buffer->refCount());
+  WaveBufferPtr view = WaveBufferView<WaveBufferPtr>::create(
+      buffer->as<uint8_t>() + 10, 10, buffer);
+  EXPECT_EQ(2, buffer->refCount());
+  EXPECT_EQ(1, view->refCount());
+  auto view2 = view;
+  EXPECT_EQ(2, buffer->refCount());
+  EXPECT_EQ(2, view->refCount());
+  auto raw = buffer.get();
+  buffer = nullptr;
+  EXPECT_EQ(1, raw->refCount());
+  view = nullptr;
+  view2 = nullptr;
+  // This is reference to freed but the header is still in the arena.
+  EXPECT_EQ(0, raw->refCount());
+}
diff --git a/velox/experimental/wave/common/tests/HashTableTest.cpp b/velox/experimental/wave/common/tests/HashTableTest.cpp
new file mode 100644
index 0000000000000..bae0fd4667dca
--- /dev/null
+++ b/velox/experimental/wave/common/tests/HashTableTest.cpp
@@ -0,0 +1,400 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/common/time/Timer.h"
+#include "velox/experimental/wave/common/Buffer.h"
+#include "velox/experimental/wave/common/GpuArena.h"
+#include "velox/experimental/wave/common/tests/BlockTest.h"
+#include "velox/experimental/wave/common/tests/CpuTable.h"
+#include "velox/experimental/wave/common/tests/HashTestUtil.h"
+
+#include <iostream>
+
+namespace facebook::velox::wave {
+
+class CpuMockGroupByOps {
+ public:
+  bool
+  compare(CpuHashTable* table, TestingRow* row, int32_t i, HashProbe* probe) {
+    return row->key == reinterpret_cast<int64_t**>(probe->keys)[0][i];
+  }
+
+  bool compare1(const CpuHashTable* table, TestingRow* row, int64_t key) {
+    return key == row->key;
+  }
+
+  TestingRow* newRow(CpuHashTable* table, int32_t i, HashProbe* probe) {
+    auto row = table->newRow<TestingRow>();
+    row->key = reinterpret_cast<int64_t**>(probe->keys)[0][i];
+    row->flags = 0;
+    row->count = 0;
+    new (&row->concatenation) ArrayAgg64();
+    return row;
+  }
+
+  void
+  update(CpuHashTable* table, TestingRow* row, int32_t i, HashProbe* probe) {
+    auto* keys = reinterpret_cast<int64_t**>(probe->keys);
+    row->count += keys[1][i];
+
+#if 0
+      int64_t arg = keys[1][i];
+      int32_t part = table->partitionIdx(bucket - table->buckets);
+      auto* allocator = &table->allocators[part];
+      auto state = arrayAgg64Append(&row->concatenation, arg, allocator);
+#endif
+  }
+};
+
+class HashTableTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    device_ = getDevice();
+    setDevice(device_);
+    allocator_ = getAllocator(device_);
+    arena_ = std::make_unique<GpuArena>(1 << 28, allocator_);
+    streams_.push_back(std::make_unique<BlockTestStream>());
+  }
+
+  void prefetch(Stream& stream, WaveBufferPtr buffer) {
+    stream.prefetch(device_, buffer->as<char>(), buffer->capacity());
+  }
+
+  // Tests different styles of updating a group by. Results are returned in
+  // 'run'.
+  void updateTestCase(int32_t numDistinct, int32_t numRows, HashRun& run) {
+    run.numRows = numRows;
+    run.numDistinct = numDistinct;
+    run.numColumns = 2;
+    run.numRowsPerThread = 32;
+
+    initializeHashTestInput(run, arena_.get());
+    fillHashTestInput(
+        run.numRows,
+        run.numDistinct,
+        bits::nextPowerOfTwo(run.numDistinct),
+        1,
+        run.numColumns,
+        reinterpret_cast<int64_t**>(run.probe->keys));
+    std::vector<TestingRow> reference(run.numDistinct);
+    for (auto i = 0; i < run.numDistinct; ++i) {
+      reference[i].key = i;
+    }
+    gpuRowsBuffer_ = arena_->allocate<TestingRow>(run.numDistinct);
+    TestingRow* gpuRows = gpuRowsBuffer_->as<TestingRow>();
+    memcpy(gpuRows, reference.data(), sizeof(TestingRow) * run.numDistinct);
+    prefetch(*streams_[0], gpuRowsBuffer_);
+    prefetch(*streams_[0], run.gpuData);
+    streams_[0]->wait();
+    updateCpu(reference.data(), run);
+    updateGpu(gpuRows, run, reference.data());
+    std::cout << run.toString() << std::endl;
+  }
+
+  void updateCpu(TestingRow* rows, HashRun& run) {
+    uint64_t micros = 0;
+    {
+      MicrosecondTimer t(&micros);
+      switch (run.testCase) {
+        case HashTestCase::kUpdateSum1: {
+          int64_t** keys = reinterpret_cast<int64_t**>(run.probe->keys);
+          int64_t* indices = keys[0];
+          int64_t* data = keys[1];
+          auto numRows = run.numRows;
+          for (auto i = 0; i < numRows; ++i) {
+            rows[indices[i]].count += data[i];
+          }
+          break;
+        }
+        default:
+          VELOX_FAIL("Unsupported test case");
+      }
+    }
+    run.addScore("cpu1t", micros);
+  }
+
+#define UPDATE_CASE(title, func, expectCorrect, nextFlags) \
+  {                                                        \
+    std::cout << title << std::endl;                       \
+    MicrosecondTimer t(&micros);                           \
+    streams_[0]->func(rows, run);                          \
+    streams_[0]->wait();                                   \
+  }                                                        \
+  run.addScore(title, micros);                             \
+  micros = 0;                                              \
+  compareAndReset(                                         \
+      reference, rows, run.numDistinct, title, expectCorrect, nextFlags);
+
+  void updateGpu(TestingRow* rows, HashRun& run, TestingRow* reference) {
+    uint64_t micros = 0;
+    switch (run.testCase) {
+      case HashTestCase::kUpdateSum1:
+        UPDATE_CASE("sum1Atm", updateSum1Atomic, true, 0);
+        UPDATE_CASE("sum1NoSync", updateSum1NoSync, false, 0);
+        UPDATE_CASE("sum1AtmCoaShfl", updateSum1AtomicCoalesceShfl, true, 1);
+        UPDATE_CASE("sum1AtmCoaShmem", updateSum1AtomicCoalesceShmem, true, 1);
+        UPDATE_CASE("sum1Mtx", updateSum1Mtx, true, 1);
+        UPDATE_CASE("sum1MtxCoa", updateSum1MtxCoalesce, true, 0);
+        UPDATE_CASE("sum1Part", updateSum1Part, true, 0);
+        // Commenting out Order and Exch functions as they are too slow.
+        // (for case when only 1 distinct element).
+
+        // UPDATE_CASE("sum1Order", updateSum1Order, true, 0);
+        // UPDATE_CASE("sum1Exch", updateSum1Exch, false, 0);
+
+        break;
+      default:
+        VELOX_FAIL("Unsupported test case");
+    }
+  }
+
+  void compareAndReset(
+      TestingRow* reference,
+      TestingRow* rows,
+      int32_t numRows,
+      const char* title,
+      bool expectCorrect,
+      int32_t initFlags = 0) {
+    int32_t numError = 0;
+    int64_t errorSigned = 0;
+    int64_t errorDelta = 0;
+    for (auto i = 0; i < numRows; ++i) {
+      if (rows[i].count == reference[i].count) {
+        continue;
+      }
+      if (numError == 0 && expectCorrect) {
+        std::cout << "In " << title << std::endl;
+        EXPECT_EQ(reference[i].count, rows[i].count) << " at " << i;
+      }
+      ++numError;
+      int64_t d = reference[i].count - rows[i].count;
+      errorSigned += d;
+      errorDelta += d < 0 ? -d : d;
+    }
+    if (numError) {
+      std::cout << fmt::format(
+                       "{}: numError={} errorDelta={} errorSigned={}",
+                       title,
+                       numError,
+                       errorDelta,
+                       errorSigned)
+                << std::endl;
+    }
+    for (auto i = 0; i < numRows; ++i) {
+      new (rows + i) TestingRow();
+      rows[i].key = i;
+      rows[i].flags = initFlags;
+    }
+    prefetch(*streams_[0], gpuRowsBuffer_);
+    streams_[0]->wait();
+  }
+
+  void groupTestCase(int32_t numDistinct, int32_t numRows, HashRun& run) {
+    run.numRows = numRows;
+    run.numDistinct = numDistinct;
+    if (!run.numSlots) {
+      run.numSlots = bits::nextPowerOfTwo(numDistinct);
+    }
+    run.numColumns = 2;
+    run.numRowsPerThread = 32;
+
+    initializeHashTestInput(run, arena_.get());
+    fillHashTestInput(
+        run.numRows,
+        run.numDistinct,
+        bits::nextPowerOfTwo(run.numDistinct),
+        1,
+        run.numColumns,
+        reinterpret_cast<int64_t**>(run.probe->keys));
+    CpuHashTable cpuTable(run.numSlots, sizeof(TestingRow) * run.numDistinct);
+    cpuGroupBy(cpuTable, run);
+    gpuGroupBy(cpuTable, run);
+    std::cout << run.toString() << std::endl;
+  }
+
+  void cpuGroupBy(CpuHashTable& table, HashRun& run) {
+    uint64_t time = 0;
+    {
+      MicrosecondTimer t(&time);
+      int64_t* key = reinterpret_cast<int64_t**>(run.probe->keys)[0];
+      auto* hashes = run.probe->hashes;
+      for (auto i = 0; i < run.numRows; ++i) {
+        hashes[i] = bits::hashMix(1, key[i]);
+      }
+      table.updatingProbe<TestingRow>(
+          run.numRows, run.probe, CpuMockGroupByOps());
+    }
+    run.addScore("cpu1T", time);
+  }
+
+  void gpuGroupBy(const CpuHashTable& reference, HashRun& run) {
+    WaveBufferPtr gpuTableBuffer;
+    GpuHashTableBase* gpuTable;
+    setupGpuTable(
+        run.numSlots,
+        run.numRows,
+        sizeof(TestingRow),
+        arena_.get(),
+        gpuTable,
+        gpuTableBuffer);
+    prefetch(*streams_[0], run.gpuData);
+    prefetch(*streams_[0], gpuTableBuffer);
+    streams_[0]->wait();
+    uint64_t micros = 0;
+    {
+      MicrosecondTimer t(&micros);
+      streams_[0]->hashTest(gpuTable, run, BlockTestStream::HashCase::kGroup);
+      streams_[0]->wait();
+    }
+    run.addScore("gpu", micros);
+    checkGroupBy(reference, gpuTable);
+  }
+
+  void checkGroupBy(const CpuHashTable& reference, GpuHashTableBase* table) {
+    int32_t numChecked = 0;
+    for (auto i = 0; i <= table->sizeMask; ++i) {
+      for (auto j = 0; j < 4; ++j) {
+        auto* row = reinterpret_cast<GpuBucketMembers*>(table->buckets)[i]
+                        .testingLoad<TestingRow>(j);
+        if (row == nullptr) {
+          continue;
+        }
+        ++numChecked;
+        auto referenceRow = reference.find<TestingRow>(
+            row->key, bits::hashMix(1, row->key), CpuMockGroupByOps());
+        ASSERT_TRUE(referenceRow != nullptr);
+        EXPECT_EQ(referenceRow->count, row->count);
+      }
+    }
+    EXPECT_EQ(reference.size, numChecked);
+  }
+
+  Device* device_;
+  GpuAllocator* allocator_;
+  std::unique_ptr<GpuArena> arena_;
+  std::vector<std::unique_ptr<BlockTestStream>> streams_;
+  WaveBufferPtr gpuRowsBuffer_;
+};
+
+TEST_F(HashTableTest, allocator) {
+  constexpr int32_t kNumThreads = 256;
+  constexpr int32_t kTotal = 1 << 22;
+  WaveBufferPtr data = arena_->allocate<char>(kTotal);
+  auto* allocator = data->as<HashPartitionAllocator>();
+  auto freeSetSize = BlockTestStream::freeSetSize();
+  new (allocator) HashPartitionAllocator(
+      data->as<char>() + sizeof(HashPartitionAllocator) + freeSetSize,
+      kTotal - sizeof(HashPartitionAllocator) - freeSetSize,
+      16,
+      allocator + 1);
+  memset(allocator->freeSet, 0, freeSetSize);
+  WaveBufferPtr allResults = arena_->allocate<AllocatorTestResult>(kNumThreads);
+  auto results = allResults->as<AllocatorTestResult>();
+  for (auto i = 0; i < kNumThreads; ++i) {
+    results[i].allocator = reinterpret_cast<RowAllocator*>(allocator);
+    results[i].numRows = 0;
+    results[i].numStrings = 0;
+  }
+  auto stream1 = std::make_unique<BlockTestStream>();
+  auto stream2 = std::make_unique<BlockTestStream>();
+  stream1->initAllocator(allocator);
+  stream1->wait();
+  stream1->rowAllocatorTest(2, 4, 3, 2, results);
+  stream2->rowAllocatorTest(2, 4, 3, 2, results + 128);
+
+  stream1->wait();
+  stream2->wait();
+  // Pointer to result idx, position in result;
+  std::unordered_map<int64_t*, int32_t> uniques;
+  for (auto resultIdx = 0; resultIdx < kNumThreads; ++resultIdx) {
+    auto* result = results + resultIdx;
+    for (auto i = 0; i < result->numRows; ++i) {
+      auto row = result->rows[i];
+      EXPECT_GE(reinterpret_cast<uint64_t>(row), allocator->base);
+      EXPECT_LT(
+          reinterpret_cast<uint64_t>(row),
+          allocator->base + allocator->capacity);
+      auto it = uniques.find(row);
+      EXPECT_TRUE(it == uniques.end()) << fmt::format(
+          "row {} is also at {} {}",
+          reinterpret_cast<uint64_t>(row),
+          it->second >> 24,
+          it->second & bits::lowMask(24));
+
+      uniques[row] = (resultIdx << 24) | i;
+    }
+    for (auto i = 0; i < result->numStrings; ++i) {
+      auto string = result->strings[i];
+      EXPECT_GE(reinterpret_cast<uint64_t>(string), allocator->base);
+      EXPECT_LT(
+          reinterpret_cast<uint64_t>(string),
+          allocator->base + allocator->capacity);
+      auto it = uniques.find(string);
+      EXPECT_TRUE(it == uniques.end()) << fmt::format(
+          "String {} is also at {} {}",
+          reinterpret_cast<uint64_t>(string),
+          it->second >> 24,
+          it->second & bits::lowMask(24));
+      uniques[string] = (resultIdx << 24) | i;
+    }
+  }
+}
+
+TEST_F(HashTableTest, update) {
+  {
+    HashRun run;
+    run.testCase = HashTestCase::kUpdateSum1;
+    updateTestCase(10000000, 2000000, run);
+  }
+  {
+    HashRun run;
+    run.testCase = HashTestCase::kUpdateSum1;
+    updateTestCase(100000, 2000000, run);
+  }
+  {
+    HashRun run;
+    run.testCase = HashTestCase::kUpdateSum1;
+    updateTestCase(1000, 2000000, run);
+  }
+  {
+    HashRun run;
+    run.testCase = HashTestCase::kUpdateSum1;
+    updateTestCase(10, 2000000, run);
+  }
+  {
+    HashRun run;
+    run.testCase = HashTestCase::kUpdateSum1;
+    updateTestCase(1, 2000000, run);
+  }
+}
+
+TEST_F(HashTableTest, groupBy) {
+  {
+    HashRun run;
+    run.testCase = HashTestCase::kGroupSum1;
+    run.numSlots = 2048;
+    groupTestCase(1000, 2000000, run);
+  }
+  {
+    HashRun run;
+    run.testCase = HashTestCase::kGroupSum1;
+    run.numSlots = 8 << 20;
+    groupTestCase(5000000, 50000000, run);
+  }
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/HashTestUtil.cpp b/velox/experimental/wave/common/tests/HashTestUtil.cpp
new file mode 100644
index 0000000000000..60bf3a6a60b29
--- /dev/null
+++ b/velox/experimental/wave/common/tests/HashTestUtil.cpp
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/common/tests/HashTestUtil.h"
+#include <fmt/format.h>
+#include "velox/common/base/BitUtil.h"
+#include "velox/experimental/wave/common/Buffer.h"
+#include "velox/experimental/wave/common/GpuArena.h"
+#include "velox/experimental/wave/common/HashTable.h"
+
+namespace facebook::velox::wave {
+
+constexpr uint32_t kPrime32 = 1815531889;
+inline uint32_t scale32(uint32_t n, uint32_t scale) {
+  return (static_cast<uint64_t>(static_cast<uint32_t>(n)) * scale) >> 32;
+}
+
+// Returns the byte size for a GpuProbe with numRows as first, rounded row count
+// as second.
+std::pair<int64_t, int32_t> probeSize(HashRun& run) {
+  int32_t roundedRows =
+      bits::roundUp(run.numRows, run.blockSize * run.numRowsPerThread);
+  return {
+      sizeof(HashProbe) +
+          // Column data and hash number array.
+          (1 + run.numColumns) * roundedRows * sizeof(int64_t)
+          // Pointers to column starts
+          + sizeof(int64_t*) * run.numColumns
+          // retry lists
+          + 3 * sizeof(int32_t) * roundedRows +
+          // numRows for each block.
+          sizeof(int32_t) * roundedRows /
+              (run.blockSize * run.numRowsPerThread) +
+          // Temp space for partitioning.
+          roundedRows * sizeof(int32_t) +
+          // alignment padding
+          256,
+      roundedRows};
+}
+
+void fillHashTestInput(
+    int32_t numRows,
+    int32_t keyRange,
+    int32_t powerOfTwo,
+    int64_t counter,
+    uint8_t numColumns,
+    int64_t** columns,
+    int32_t numHot,
+    int32_t hotPct) {
+  int32_t delta = counter & (powerOfTwo - 1);
+  for (auto i = 0; i < numRows; ++i) {
+    auto previous = columns[0][i];
+    auto seed = (previous + delta + i) * kPrime32;
+    if (hotPct && scale32(seed >> 32, 100) <= hotPct) {
+      int32_t nth = scale32(seed, numHot);
+      nth = std::min<int64_t>(
+          keyRange - 1, nth * (static_cast<float>(keyRange) / nth));
+      columns[0][i] = nth;
+    } else {
+      columns[0][i] = scale32(seed, keyRange);
+    }
+  }
+  counter += numRows;
+  for (auto c = 1; c < numColumns; ++c) {
+    for (auto r = 0; r < numRows; ++r) {
+      columns[c][r] = 1; // c + (r & 7);
+    }
+  }
+}
+
+void initializeHashTestInput(HashRun& run, GpuArena* arena) {
+  auto [bytes, roundedRows] = probeSize(run);
+  if (!arena) {
+    run.isCpu = true;
+    run.cpuData = std::make_unique<char[]>(bytes);
+    run.input = run.cpuData.get();
+  } else {
+    run.isCpu = false;
+    run.gpuData = arena->allocate<char>(bytes);
+    run.input = run.gpuData->as<char>();
+  }
+  auto data = run.input;
+  auto dataBegin = data;
+  HashProbe* probe = new (data) HashProbe();
+  run.probe = probe;
+  data += sizeof(HashProbe);
+  probe->numRows = reinterpret_cast<int32_t*>(data);
+  data += bits::roundUp(
+      sizeof(int32_t) * roundedRows / (run.numRowsPerThread * run.blockSize),
+      8);
+  if (!arena) {
+    probe->numRows[0] = run.numRows;
+  } else {
+    run.numBlocks = roundedRows / (run.blockSize * run.numRowsPerThread);
+    for (auto i = 0; i < run.numBlocks; ++i) {
+      if (i == run.numBlocks - 1) {
+        probe->numRows[i] =
+            run.numRows - (i * run.blockSize * run.numRowsPerThread);
+        break;
+      }
+      probe->numRows[i] = run.blockSize * run.numRowsPerThread;
+      ;
+    }
+  }
+  probe->numRowsPerThread = run.numRowsPerThread;
+  probe->hashes = reinterpret_cast<uint64_t*>(data);
+  data += sizeof(uint64_t) * roundedRows;
+  probe->keys = data;
+  data += sizeof(void*) * run.numColumns;
+  probe->kernelRetries1 = reinterpret_cast<int32_t*>(data);
+  data += sizeof(int32_t) * roundedRows;
+  probe->kernelRetries2 = reinterpret_cast<int32_t*>(data);
+  data += sizeof(int32_t) * roundedRows;
+  probe->hostRetries = reinterpret_cast<int32_t*>(data);
+  data += sizeof(int32_t) * roundedRows;
+  for (auto i = 0; i < run.numColumns; ++i) {
+    reinterpret_cast<int64_t**>(probe->keys)[i] =
+        reinterpret_cast<int64_t*>(data);
+    data += sizeof(int64_t) * roundedRows;
+  }
+  run.partitionTemp = reinterpret_cast<int32_t*>(data);
+  data += bits::roundUp(sizeof(int32_t) * roundedRows, 8);
+  VELOX_CHECK_LE(data - dataBegin, bytes);
+}
+
+void setupGpuTable(
+    int32_t numSlots,
+    int32_t maxRows,
+    int64_t rowSize,
+    GpuArena* arena,
+    GpuHashTableBase*& table,
+    WaveBufferPtr& buffer) {
+  using FreeSetType = FreeSetBase<void*, 1024>;
+  // GPU cache lines are 128 bytes divided in 4 separately loadable 32 byte
+  // sectors.
+  constexpr int32_t kAlignment = 128;
+  int32_t numBuckets = bits::nextPowerOfTwo(numSlots / 4);
+  int64_t bytes = sizeof(GpuHashTableBase) + sizeof(HashPartitionAllocator) +
+      sizeof(FreeSetType) + sizeof(GpuBucketMembers) * numBuckets +
+      maxRows * rowSize;
+  buffer = arena->allocate<char>(bytes + kAlignment);
+  table = buffer->as<GpuHashTableBase>();
+  new (table) GpuHashTableBase();
+  table->sizeMask = numBuckets - 1;
+  char* data = reinterpret_cast<char*>(table + 1);
+  table->allocators = reinterpret_cast<RowAllocator*>(data);
+  auto allocatorBase =
+      reinterpret_cast<HashPartitionAllocator*>(table->allocators);
+  data += sizeof(HashPartitionAllocator);
+  auto freeSet = reinterpret_cast<FreeSetType*>(data);
+  new (freeSet) FreeSetType();
+  data += sizeof(FreeSetType);
+  // The buckets start at aligned address.
+  data = reinterpret_cast<char*>(
+      bits::roundUp(reinterpret_cast<uint64_t>(data), kAlignment));
+  table->buckets = reinterpret_cast<GpuBucket*>(data);
+  data += sizeof(GpuBucketMembers) * numBuckets;
+  auto allocator = reinterpret_cast<HashPartitionAllocator*>(table->allocators);
+  new (allocator)
+      HashPartitionAllocator(data, maxRows * rowSize, rowSize, freeSet);
+  table->partitionMask = 0;
+  table->partitionShift = 0;
+  memset(table->buckets, 0, sizeof(GpuBucketMembers) * (table->sizeMask + 1));
+}
+
+std::string HashRun::toString() const {
+  std::stringstream out;
+  std::string opLabel = testCase == HashTestCase::kUpdateSum1 ? "update sum1"
+      : testCase == HashTestCase::kGroupSum1                  ? "groupSum1"
+                                             : "update array_agg1";
+  out << "===" << label << ":" << opLabel << " distinct=" << numDistinct
+      << " rows=" << numRows << " (" << numBlocks << "x" << blockSize << "x"
+      << numRowsPerThread << ") ";
+  if (hotPct) {
+    out << " skew " << hotPct << "% in " << numHot << " ";
+  }
+  auto sorted = scores;
+  std::sort(sorted.begin(), sorted.end(), [](auto& left, auto& right) {
+    return left.second < right.second;
+  });
+  float gb =
+      numRows * sizeof(int64_t) * numColumns / static_cast<float>(1 << 30);
+  for (auto& score : sorted) {
+    out << std::endl
+        << "  * "
+        << fmt::format(
+               " {}={:.2f} rps {:.2f} GB/s {} us {:.2f}x",
+               score.first,
+               numRows / (score.second / 1e6),
+               gb / (score.second / 1e6),
+               score.second,
+               score.second / sorted[0].second);
+  }
+  return out.str();
+}
+
+void HashRun::addScore(const char* label, uint64_t micros) {
+  scores.push_back(std::make_pair<std::string, float>(label, micros));
+}
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/HashTestUtil.h b/velox/experimental/wave/common/tests/HashTestUtil.h
new file mode 100644
index 0000000000000..ddebee017f41d
--- /dev/null
+++ b/velox/experimental/wave/common/tests/HashTestUtil.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include "velox/experimental/wave/common/Buffer.h"
+#include "velox/experimental/wave/common/HashTable.h"
+
+namespace facebook::velox::wave {
+
+/// Identifies operation being tested. A collection of representative hash table
+/// ops like aggregates probes and builds with different functions and layouts.
+enum class HashTestCase {
+  // bigint sum.  Update only, no hash table.
+  kUpdateSum1,
+  // group by with bigint sum.
+  kGroupSum1,
+  // array_agg of bigint. Update only, no hash table.
+  kUpdateArrayAgg1
+};
+
+/// Describes a hashtable benchmark case.
+struct HashRun {
+  // Label of test case. Describes what is done. The labels for different
+  // implementations come from 'scores'.
+  std::string label;
+  // the operation being measured.
+  HashTestCase testCase;
+  // CPU/GPU measurement.
+  bool isCpu;
+
+  // Number of slots in table.
+  int32_t numSlots{0};
+
+  // Number of probe rows.
+  int32_t numRows;
+
+  // Number of distinct keys.
+  int32_t numDistinct;
+
+  // Number of distinct hot keys.
+  int32_t numHot{0};
+
+  // Percentage of hot keys over total keys. e.g. with 1000 distinct and 10 hot
+  // and hotPct of 50, every second key will be one of 10 and the rest are
+  // evenly spread over the 1000.
+  int32_t hotPct{0};
+
+  // Number of keys processed by each thread of each block.
+  int32_t numRowsPerThread;
+
+  int32_t blockSize{256};
+
+  // Number of blocks of 'blockSize' threads.
+  int32_t numBlocks;
+
+  // Number of columns. Key is column 0.
+  uint8_t numColumns{1};
+
+  // Number of independent hash tables.
+  int32_t numTables{1};
+
+  // Result, labeled by implementation alternative.
+  std::vector<std::pair<std::string, float>> scores;
+
+  std::unique_ptr<char[]> cpuData;
+  WaveBufferPtr gpuData;
+
+  // Input data, either cpuData or gpuData.
+  char* input;
+
+  // Initialized probe params, contained in 'input'.
+  HashProbe* probe;
+  // One int per row, use for partitioning intermediates. Uninitialized.
+  int32_t* partitionTemp;
+
+  int32_t* partitionArgs;
+  std::string toString() const;
+  void addScore(const char* label, uint64_t micros);
+  void clearScore() {
+    scores.clear();
+  }
+};
+
+void fillHashTestInput(
+    int32_t numRows,
+    int32_t keyRange,
+    int32_t powerOfTwo,
+    int64_t counter,
+    uint8_t numColumns,
+    int64_t** columns,
+    int32_t numHot = 0,
+    int32_t hotPct = 0);
+
+void initializeHashTestInput(HashRun& run, GpuArena* arena);
+
+void setupGpuTable(
+    int32_t numSlots,
+    int32_t maxRows,
+    int64_t rowSize,
+    GpuArena* arena,
+    GpuHashTableBase*& table,
+    WaveBufferPtr& buffer);
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/Updates.cuh b/velox/experimental/wave/common/tests/Updates.cuh
new file mode 100644
index 0000000000000..fd0aa491e2913
--- /dev/null
+++ b/velox/experimental/wave/common/tests/Updates.cuh
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/wave/common/HashTable.cuh"
+#include "velox/experimental/wave/common/tests/BlockTest.h"
+
+namespace facebook::velox::wave {
+
+using Mutex = cuda::binary_semaphore<cuda::thread_scope_device>;
+
+inline void __device__ testingLock(int32_t* mtx) {
+  reinterpret_cast<Mutex*>(mtx)->acquire();
+}
+
+inline void __device__ testingUnlock(int32_t* mtx) {
+  reinterpret_cast<Mutex*>(mtx)->release();
+}
+
+void __device__ testSumNoSync(TestingRow* rows, HashProbe* probe) {
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+  int32_t base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  int32_t end = base + probe->numRows[blockIdx.x];
+
+  for (auto i = base + threadIdx.x; i < end; i += blockDim.x) {
+    auto* row = &rows[indices[i]];
+    row->count += deltas[i];
+  }
+}
+
+void __device__ testSumPart(
+    TestingRow* rows,
+    int32_t numParts,
+    HashProbe* probe,
+    int32_t* part,
+    int32_t* partEnd,
+    int32_t numGroups,
+    int32_t groupStride) {
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+  for (auto groupIdx = 0; groupIdx < numGroups; ++groupIdx) {
+    auto groupStart = groupIdx * groupStride;
+    int32_t linear = threadIdx.x + blockIdx.x * blockDim.x;
+    if (linear > numParts) {
+      break;
+    }
+    int32_t begin = linear == 0 ? groupStart
+                                : groupStart + partEnd[groupStart + linear - 1];
+    int32_t end = groupStart + partEnd[groupStart + linear];
+
+    for (auto i = begin; i < end; ++i) {
+      auto index = groupStart + part[i];
+      auto* row = &rows[indices[index]];
+      row->count += deltas[index];
+    }
+  }
+  __syncthreads();
+}
+
+void __device__ testSumMtx(TestingRow* rows, HashProbe* probe) {
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+  int32_t base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  int32_t end = base + probe->numRows[blockIdx.x];
+
+  for (auto i = base + threadIdx.x; i < end; i += blockDim.x) {
+    auto* row = &rows[indices[i]];
+    testingLock(&row->flags);
+    row->count += deltas[i];
+    testingUnlock(&row->flags);
+  }
+}
+
+void __device__ testSumAtomic(TestingRow* rows, HashProbe* probe) {
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+  int32_t base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  int32_t end = base + probe->numRows[blockIdx.x];
+
+  for (auto i = base + threadIdx.x; i < end; i += blockDim.x) {
+    auto* row = &rows[indices[i]];
+    atomicAdd((unsigned long long*)&row->count, (unsigned long long)deltas[i]);
+  }
+}
+
+void __device__ testSumAtomicCoalesceShmem(TestingRow* rows, HashProbe* probe) {
+  constexpr int32_t kWarpThreads = 32;
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+  int32_t base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  int32_t lane = cub::LaneId();
+  int32_t end = base + probe->numRows[blockIdx.x];
+  extern __shared__ char smem[];
+
+  int64_t* totals = (int64_t*)smem;
+
+  for (auto count = base; count < end; count += blockDim.x) {
+    auto i = threadIdx.x + count;
+
+    if (i < end) {
+      totals[threadIdx.x] = 0;
+      __syncwarp();
+      uint32_t laneMask = count + kWarpThreads <= end
+          ? 0xffffffff
+          : lowMask<uint32_t>(end - count);
+      auto index = indices[i];
+      auto delta = deltas[i];
+      uint32_t allPeers = __match_any_sync(laneMask, index);
+      int32_t leader = __ffs(allPeers) - 1;
+      atomicAdd(
+          (unsigned long long*)&totals
+              [(threadIdx.x & (~(kWarpThreads - 1))) | leader],
+          (unsigned long long)delta);
+      __syncwarp();
+      if (lane == leader) {
+        auto* row = &rows[index];
+        atomicAdd(
+            (unsigned long long*)&row->count,
+            (unsigned long long)totals[threadIdx.x]);
+      }
+    }
+  }
+}
+
+void __device__ testSumAtomicCoalesceShfl(TestingRow* rows, HashProbe* probe) {
+  constexpr int32_t kWarpThreads = 32;
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+  int32_t base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  int32_t lane = cub::LaneId();
+  int32_t end = base + probe->numRows[blockIdx.x];
+
+  for (auto count = base; count < end; count += blockDim.x) {
+    auto i = threadIdx.x + count;
+
+    if (i < end) {
+      uint32_t laneMask = count + kWarpThreads <= end
+          ? 0xffffffff
+          : lowMask<uint32_t>(end - count);
+      auto index = indices[i];
+      auto delta = deltas[i];
+      uint32_t allPeers = __match_any_sync(laneMask, index);
+      int32_t leader = __ffs(allPeers) - 1;
+      auto peers = allPeers;
+      int64_t total = 0;
+      auto currentPeer = leader;
+      for (;;) {
+        total += __shfl_sync(allPeers, delta, currentPeer);
+        peers &= peers - 1;
+        if (peers == 0) {
+          break;
+        }
+        currentPeer = __ffs(peers) - 1;
+      }
+      if (lane == leader) {
+        auto* row = &rows[index];
+        atomicAdd((unsigned long long*)&row->count, (unsigned long long)total);
+      }
+    }
+  }
+}
+
+void __device__ testSumExch(TestingRow* rows, HashProbe* probe) {
+  int32_t base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  int32_t end = base + probe->numRows[blockIdx.x];
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+
+  extern __shared__ __align__(16) char smem[];
+  ProbeShared* shared = reinterpret_cast<ProbeShared*>(smem);
+  if (threadIdx.x == 0) {
+    shared->init(probe, base);
+    shared->blockEnd = end;
+    shared->toDo = probe->numRows[blockIdx.x];
+    shared->numRounds = 0;
+    shared->numUpdated = 0;
+    shared->numTried = 0;
+  }
+  __syncthreads();
+  for (;;) {
+    if (shared->blockEnd <= shared->blockBase) {
+      GPF();
+    }
+    int32_t counter;
+    for (counter = base; counter < shared->blockEnd; counter += blockDim.x) {
+      auto i = counter + threadIdx.x;
+      if (i < shared->blockEnd) {
+        atomicAdd(&shared->numTried, 1);
+        if (shared->inputRetries) {
+          i = shared->inputRetries[i];
+        }
+        auto* row = &rows[indices[i]];
+        if (0 ==
+            asDeviceAtomic<int32_t>(&row->flags)
+                ->exchange(1, cuda::memory_order_consume)) {
+          atomicAdd(
+              (unsigned long long*)&row->count, (unsigned long long)deltas[i]);
+          atomicAdd(&shared->numUpdated, 1);
+          asDeviceAtomic<int32_t>(&row->flags)
+              ->store(0, cuda::memory_order_release);
+        } else {
+          shared
+              ->outputRetries[base + atomicAdd(&shared->numKernelRetries, 1)] =
+              i;
+        }
+      } else {
+        atomicAdd(&shared->numTried, 1 << 16);
+      }
+      // __syncthreads();
+    }
+    __syncthreads();
+    if (shared->numKernelRetries == 0) {
+      if ((shared->numTried & 0xffff) != shared->blockEnd - shared->blockBase) {
+        GPF();
+      }
+      if (shared->done + (shared->blockEnd - shared->blockBase) !=
+          shared->toDo) {
+        GPF();
+      }
+      // printf("%d %d //%d\n", base, end, counter);
+      return;
+    }
+
+    if (threadIdx.x == 0) {
+      shared->done +=
+          (shared->blockEnd - shared->blockBase) - shared->numKernelRetries;
+      ++shared->numRounds;
+      shared->numTried = 0;
+      shared->blockEnd = base + shared->numKernelRetries;
+      shared->nextRound(probe);
+    }
+    __syncthreads();
+  }
+}
+void __device__ testSumMtxCoalesce(TestingRow* rows, HashProbe* probe) {
+  constexpr int32_t kWarpThreads = 32;
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+  int32_t base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  int32_t lane = cub::LaneId();
+  int32_t end = base + probe->numRows[blockIdx.x];
+
+  for (auto count = base; count < end; count += blockDim.x) {
+    auto i = threadIdx.x + count;
+
+    if (i < end) {
+      uint32_t laneMask = count + kWarpThreads <= end
+          ? 0xffffffff
+          : lowMask<uint32_t>(end - count);
+      auto index = indices[i];
+      auto delta = deltas[i];
+      uint32_t allPeers = __match_any_sync(laneMask, index);
+      int32_t leader = __ffs(allPeers) - 1;
+      auto peers = allPeers;
+      int64_t total = 0;
+      auto currentPeer = leader;
+      for (;;) {
+        total += __shfl_sync(allPeers, delta, currentPeer);
+        peers &= peers - 1;
+        if (peers == 0) {
+          break;
+        }
+        currentPeer = __ffs(peers) - 1;
+      }
+      if (lane == leader) {
+        auto* row = &rows[index];
+        testingLock(&row->flags);
+        row->count += total;
+        testingUnlock(&row->flags);
+      }
+    }
+  }
+}
+
+void __device__ testSumOrder(TestingRow* rows, HashProbe* probe) {
+  auto keys = reinterpret_cast<int64_t**>(probe->keys);
+  auto indices = keys[0];
+  auto deltas = keys[1];
+  int32_t base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
+  int32_t end = base + probe->numRows[blockIdx.x];
+
+  for (auto i = base + threadIdx.x; i < end; i += blockDim.x) {
+    auto* row = &rows[indices[i]];
+    int32_t waitNano = 1;
+    auto d = deltas[i];
+    for (;;) {
+      if (0 ==
+          asDeviceAtomic<int32_t>(&row->flags)
+              ->exchange(1, cuda::memory_order_consume)) {
+        row->count += d;
+        asDeviceAtomic<int32_t>(&row->flags)
+            ->store(0, cuda::memory_order_release);
+        break;
+      } else {
+        __nanosleep(waitNano);
+        waitNano += threadIdx.x & 31;
+      }
+    }
+  }
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/Util.h b/velox/experimental/wave/common/tests/Util.h
new file mode 100644
index 0000000000000..5b39a26587378
--- /dev/null
+++ b/velox/experimental/wave/common/tests/Util.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace facebook::velox::wave {
+
+inline uint32_t scale32(uint32_t n, uint32_t scale) {
+  return (static_cast<uint64_t>(static_cast<uint32_t>(n)) * scale) >> 32;
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/CMakeLists.txt b/velox/experimental/wave/dwio/CMakeLists.txt
new file mode 100644
index 0000000000000..f43052462fdce
--- /dev/null
+++ b/velox/experimental/wave/dwio/CMakeLists.txt
@@ -0,0 +1,24 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_subdirectory(decode)
+
+velox_add_library(
+  velox_wave_dwio
+  ColumnReader.cpp
+  FormatData.cpp
+  ReadStream.cpp
+  StructColumnReader.cpp)
+
+velox_link_libraries(velox_wave_dwio Folly::folly fmt::fmt xsimd)
diff --git a/velox/experimental/wave/dwio/ColumnReader.cpp b/velox/experimental/wave/dwio/ColumnReader.cpp
new file mode 100644
index 0000000000000..5a498dc97175f
--- /dev/null
+++ b/velox/experimental/wave/dwio/ColumnReader.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+
+namespace facebook::velox::wave {
+
+void ColumnReader::makeOp(
+    ReadStream* readStream,
+    ColumnAction action,
+    ColumnOp& op) {
+  VELOX_CHECK(action == ColumnAction::kValues, "Only values supported");
+  op.action = action;
+  op.reader = this;
+  op.waveVector = readStream->operandVector(operand_->id, requestedType_);
+};
+
+bool ColumnReader::hasNonNullFilter() const {
+  return scanSpec_->filter() && !scanSpec_->filter()->testNull();
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/ColumnReader.h b/velox/experimental/wave/dwio/ColumnReader.h
new file mode 100644
index 0000000000000..813c274cd3d6d
--- /dev/null
+++ b/velox/experimental/wave/dwio/ColumnReader.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/io/IoStatistics.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/experimental/wave/dwio/FormatData.h"
+#include "velox/experimental/wave/exec/Wave.h"
+
+namespace facebook::velox::wave {
+
+class ReadStream;
+class StructColumnReader;
+
+/// dwio::SelectiveColumnReader for Wave
+class ColumnReader {
+ public:
+  ColumnReader(
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
+      AbstractOperand* operand,
+      FormatParams& params,
+      velox::common::ScanSpec& scanSpec)
+      : requestedType_(requestedType),
+        fileType_(fileType),
+        operand_(operand),
+        formatData_(params.toFormatData(
+            fileType_,
+            scanSpec,
+            operand ? operand->id : kNoOperand)),
+        scanSpec_(&scanSpec) {}
+
+  virtual ~ColumnReader() = default;
+
+  const common::ScanSpec& scanSpec() const {
+    return *scanSpec_;
+  }
+
+  const std::vector<ColumnReader*>& children() const {
+    return children_;
+  }
+
+  bool hasNonNullFilter() const;
+
+  int32_t totalRows() const {
+    return formatData_->totalRows();
+  }
+
+  AbstractOperand* operand() const {
+    return operand_;
+  }
+
+  /// Initializes 'op' for the column of 'this'. The op is made once and used
+  /// for possibly multiple row ranges later.
+  virtual void
+  makeOp(ReadStream* readStream, ColumnAction action, ColumnOp& op);
+
+  FormatData* formatData() const {
+    return formatData_.get();
+  }
+
+  std::vector<std::unique_ptr<SplitStaging>>& splitStaging() {
+    return staging_;
+  }
+
+  /// Records an event after the first griddize. many decodes may proceed for
+  /// different rows on different streams after the griddize.
+  void recordGriddize(Stream& stream) {
+    VELOX_CHECK_NULL(griddizeEvent_);
+    griddizeEvent_ = std::make_unique<Event>();
+    griddizeEvent_->record(stream);
+  }
+
+  Event* griddizeEvent() const {
+    return griddizeEvent_.get();
+  }
+
+ protected:
+  TypePtr requestedType_;
+  std::shared_ptr<const dwio::common::TypeWithId> fileType_;
+  AbstractOperand* const operand_;
+  std::unique_ptr<FormatData> formatData_;
+  // Specification of filters, value extraction, pruning etc. The
+  // spec is assigned at construction and the contents may change at
+  // run time based on adaptation. Owned by caller.
+  velox::common::ScanSpec* scanSpec_;
+
+  std::vector<ColumnReader*> children_;
+
+  // Staging of encoded data on device. Only set in the top struct reader.
+  std::vector<std::unique_ptr<SplitStaging>> staging_;
+
+  // Event realized after griddize completes. Non-first ReadStream launches must
+  // wait for this.
+  std::unique_ptr<Event> griddizeEvent_;
+};
+
+class ReadStream : public Executable {
+ public:
+  ReadStream(
+      StructColumnReader* columnReader,
+      WaveStream& waveStream,
+      velox::io::IoStatistics* ioStats,
+      FileInfo& fileInfo,
+      const OperandSet* firstColumns = nullptr);
+
+  void setNullable(const AbstractOperand& op, bool nullable) {
+    waveStream->setNullable(op, nullable);
+  }
+
+  /// Runs a sequence of kernel invocations until all eagerly produced
+  /// columns have their last kernel in flight.  Transfers ownership
+  /// of 'readStream' to its WaveStream. 'row' is the start relative
+  /// to split start. 'rows' are offsets relative to 'row'.
+  static void
+  launch(std::unique_ptr<ReadStream> readStream, int32_t row, RowSet rows);
+
+  DecodePrograms& programs() {
+    return programs_;
+  }
+
+  // Prepares the next kernel launch in 'programs_'. Returns true if
+  // all non-lazy activity will be complete after the program kernel
+  // completes. Sets needSync if the next step(s) depend on the stream
+  // being synced first, i.e. a device to host transfer must have
+  // completed so that the next step can decide based on data received
+  // from device.
+  bool makePrograms(bool& needSync);
+
+  bool filtersDone() const {
+    return filtersDone_;
+  }
+
+  StructColumnReader* reader() const {
+    return reader_;
+  }
+
+ private:
+  // Computes starting points for multiple TBs per column if more rows are
+  // needed than is good per TB.
+  void makeGrid(Stream* stream);
+
+  // Sets consistent blockStatus and temp across 'programs_'. If 'stream is
+  // given, prefetches BlockStatus on device on 'stream'.
+  void setBlockStatusAndTemp(Stream* stream = nullptr);
+
+  /// Makes column dependencies.
+  void makeOps();
+  // Sets the ops to 'offset_' and 'rows_'. Call before each batch.
+  void prepareRead();
+  void makeControl();
+
+  // Enqueues waits on stream for the transfers the 'currentStaging_'
+  // depends on. Fist batch on stripe enqueues transfer, next batches
+  // are enqueued on a different stream but still depend on the first
+  // transfers completing on the first stream.
+  void syncStaging(Stream& stream);
+
+  io::IoStatistics* const ioStats_;
+
+  // Makes steps to align values from non-last filters to the selection of the
+  // last filter.
+  void makeCompact(bool isSerial);
+
+  void prefetchStatus(Stream* stream);
+
+  // True if non-filter columns will be done sequentially in the
+  // filters kernel. This will never loose if there is an always read
+  // single column. This may loose if it were better to take the
+  // launch cost but run all non-filter columns in their own TBs.
+  bool decodenonFiltersInFiltersKernel();
+
+  StructColumnReader* reader_;
+  std::vector<AbstractOperand*> abstractOperands_;
+
+  // Offset in top level rows from start of split.
+  int32_t row_;
+
+  // Row numbers to read relative to 'row_'.
+  RowSet rows_;
+
+  // Non-filter columns.
+  std::vector<ColumnOp> ops_;
+
+  // Filter columns in filter order.
+  std::vector<ColumnOp> filters_;
+
+  // Count of KBlockSize blocks in max top level rows.
+  int32_t numBlocks_{0};
+
+  // Pointer to staging owned by reader tree root. Not owned here because
+  // lifetime is the split, not the batch.
+  SplitStaging* currentStaging_;
+
+  // Data to be copied from device, e.g. filter selectivities.
+  ResultStaging resultStaging_;
+
+  // Intermediate data to stay on device, e.g. selected rows.
+  ResultStaging deviceStaging_;
+  // Owning references to decode programs. Must be live for duration of kernels.
+  std::vector<LaunchParams> commands_;
+  // Reusable control block for launching decode kernels.
+  DecodePrograms programs_;
+  // If no filters, the starting RowSet directly initializes the BlockStatus'es
+  // at the end of the ReadStream.
+  bool hasFilters_{false};
+  bool filtersDone_{false};
+  //  Sequence number of kernel launch.
+  int32_t nthWave_{0};
+
+  // Leading bytes in control_->deviceData used for BlockStatus. Cleared on
+  // device. The bytes after that are set on host and then prefetched to device.
+  int32_t statusBytes_{0};
+  int32_t gridStatusBytes_{0};
+  LaunchControl* control_{nullptr};
+
+  // Set to true when after first griddize() and akeOps().
+  bool inited_{false};
+  FileInfo fileInfo_;
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/FormatData.cpp b/velox/experimental/wave/dwio/FormatData.cpp
new file mode 100644
index 0000000000000..feb847aa6f7d5
--- /dev/null
+++ b/velox/experimental/wave/dwio/FormatData.cpp
@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/dwio/FormatData.h"
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/exec/Wave.h"
+
+DECLARE_int32(wave_reader_rows_per_tb);
+
+DEFINE_int32(
+    staging_bytes_per_thread,
+    300000,
+    "Make a parallel memcpy shard per this many bytes");
+
+namespace facebook::velox::wave {
+
+BufferId SplitStaging::add(Staging& staging) {
+  VELOX_CHECK_NULL(deviceBuffer_);
+  staging_.push_back(staging);
+  offsets_.push_back(fill_);
+  fill_ += bits::roundUp(staging.size, 8);
+  return offsets_.size() - 1;
+}
+
+void SplitStaging::registerPointerInternal(
+    BufferId id,
+    void** ptr,
+    bool clear) {
+  VELOX_CHECK_NOT_NULL(ptr);
+  VELOX_CHECK_NULL(deviceBuffer_);
+  if (clear) {
+    *ptr = nullptr;
+  }
+#if 0 // ndef NDEBUG
+  for (auto& pair : patch_) {
+    VELOX_CHECK(pair.second != ptr, "Must not register the same pointer twice");
+  }
+#endif
+  patch_.push_back(std::make_pair(id, ptr));
+}
+
+void SplitStaging::copyColumns(
+    int32_t begin,
+    int32_t end,
+    char* destination,
+    bool release) {
+  for (auto i = begin; i < end; ++i) {
+    memcpy(destination, staging_[i].hostData, staging_[i].size);
+    destination += staging_[i].size;
+  }
+  if (release) {
+    sem_.release();
+  }
+}
+
+// Shared pool of 1-2GB of pinned host memory for staging. May
+// transiently exceed 2GB but settles to 2GB after the peak.
+GpuArena& getTransferArena() {
+  static std::unique_ptr<GpuArena> arena = std::make_unique<GpuArena>(
+      1UL << 30, getHostAllocator(nullptr), 2UL << 30);
+  return *arena;
+}
+
+// Starts the transfers registered with add(). 'stream' is set to a stream
+// where operations depending on the transfer may be queued.
+void SplitStaging::transfer(
+    WaveStream& waveStream,
+    Stream& stream,
+    bool recordEvent,
+    std::function<void(WaveStream&, Stream&)> asyncTail) {
+  if (fill_ == 0 || deviceBuffer_ != nullptr) {
+    if (recordEvent && !event_) {
+      event_ = std::make_unique<Event>();
+      event_->record(stream);
+    }
+    if (asyncTail) {
+      asyncTail(waveStream, stream);
+    }
+    return;
+  }
+  WaveTime startTime = WaveTime::now();
+  deviceBuffer_ = waveStream.deviceArena().allocate<char>(fill_);
+  hostBuffer_ = getTransferArena().allocate<char>(fill_);
+  auto transferBuffer = hostBuffer_->as<char>();
+  int firstToCopy = 0;
+  int32_t numCopies = staging_.size();
+  int64_t copySize = 0;
+  auto targetCopySize = FLAGS_staging_bytes_per_thread;
+  int32_t numThreads = 0;
+  if (fill_ > 2000000) {
+    for (auto i = 0; i < staging_.size(); ++i) {
+      auto columnSize = staging_[i].size;
+      copySize += columnSize;
+      if (copySize >= targetCopySize && i < staging_.size() - 1) {
+        ++numThreads;
+        WaveStream::copyExecutor()->add(
+            [i, firstToCopy, transferBuffer, this]() {
+              copyColumns(firstToCopy, i + 1, transferBuffer, true);
+            });
+        transferBuffer += copySize;
+        copySize = 0;
+        firstToCopy = i + 1;
+      }
+    }
+  }
+  auto deviceData = deviceBuffer_->as<char>();
+  for (auto& pair : patch_) {
+    *reinterpret_cast<int64_t*>(pair.second) +=
+        reinterpret_cast<int64_t>(deviceData) + offsets_[pair.first];
+  }
+  if (asyncTail) {
+    WaveStream::syncExecutor()->add([firstToCopy,
+                                     numThreads,
+                                     transferBuffer,
+                                     asyncTail,
+                                     &waveStream,
+                                     &stream,
+                                     recordEvent,
+                                     startTime,
+                                     this]() {
+      copyColumns(firstToCopy, staging_.size(), transferBuffer, false);
+      for (auto i = 0; i < numThreads; ++i) {
+        sem_.acquire();
+      }
+      stream.hostToDeviceAsync(
+          deviceBuffer_->as<char>(), hostBuffer_->as<char>(), fill_);
+      waveStream.stats().stagingTime += WaveTime::now() - startTime;
+      if (recordEvent) {
+        event_ = std::make_unique<Event>();
+        event_->record(stream);
+      }
+      fill_ = 0;
+      patch_.clear();
+      offsets_.clear();
+      asyncTail(waveStream, stream);
+    });
+  } else {
+    copyColumns(firstToCopy, staging_.size(), transferBuffer, false);
+    for (auto i = 0; i < numThreads; ++i) {
+      sem_.acquire();
+    }
+    stream.hostToDeviceAsync(
+        deviceBuffer_->as<char>(), hostBuffer_->as<char>(), fill_);
+    waveStream.stats().stagingTime += WaveTime::now() - startTime;
+    if (recordEvent) {
+      event_ = std::make_unique<Event>();
+      event_->record(stream);
+    }
+    fill_ = 0;
+    patch_.clear();
+    offsets_.clear();
+  }
+}
+
+namespace {
+void setFilter(GpuDecode* step, ColumnReader* reader, Stream* stream) {
+  auto* veloxFilter = reader->scanSpec().filter();
+  if (!veloxFilter) {
+    step->filterKind = WaveFilterKind::kAlwaysTrue;
+    return;
+  }
+  switch (veloxFilter->kind()) {
+    case common::FilterKind::kBigintRange: {
+      step->filterKind = WaveFilterKind::kBigintRange;
+      step->nullsAllowed = veloxFilter->testNull();
+      step->filter._.int64Range[0] =
+          reinterpret_cast<common::BigintRange*>(veloxFilter)->lower();
+      step->filter._.int64Range[1] =
+          reinterpret_cast<common::BigintRange*>(veloxFilter)->upper();
+      break;
+    }
+
+    default:
+      VELOX_UNSUPPORTED(
+          "Unsupported filter kind", static_cast<int32_t>(veloxFilter->kind()));
+  }
+}
+} // namespace
+
+std::unique_ptr<GpuDecode> FormatData::makeStep(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ResultStaging& deviceStaging,
+    SplitStaging& splitStaging,
+    ReadStream& stream,
+    WaveTypeKind columnKind,
+    int32_t blockIdx) {
+  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
+  auto maxRowsPerThread = (rowsPerBlock / kBlockSize);
+  int32_t numBlocks =
+      bits::roundUp(op.rows.size(), rowsPerBlock) / rowsPerBlock;
+
+  auto rowsInBlock = std::min<int32_t>(
+      rowsPerBlock, op.rows.size() - (blockIdx * rowsPerBlock));
+
+  auto step = std::make_unique<GpuDecode>();
+  bool hasNulls = false;
+  if (nullsBufferId_ != kNoBufferId) {
+    hasNulls = true;
+    if (grid_.nulls) {
+      step->nonNullBases = grid_.numNonNull;
+      step->nulls = grid_.nulls;
+    } else {
+      // The nulls transfer is staged but no pointer yet. Happens when the nulls
+      // decoding is in the same kernel as decode, i.e. single TB per column.
+      splitStaging.registerPointer(nullsBufferId_, &step->nulls, true);
+      step->nonNullBases = nullptr;
+    }
+  }
+  step->numRowsPerThread = bits::roundUp(rowsInBlock, kBlockSize) / kBlockSize;
+  step->gridNumRowsPerThread = maxRowsPerThread;
+  setFilter(step.get(), op.reader, nullptr);
+  bool dense = previousFilter == nullptr &&
+      simd::isDense(op.rows.data(), op.rows.size());
+  step->nullMode = hasNulls
+      ? (dense ? NullMode::kDenseNullable : NullMode::kSparseNullable)
+      : (dense ? NullMode::kDenseNonNull : NullMode::kSparseNonNull);
+  step->nthBlock = blockIdx;
+  if (step->filterKind != WaveFilterKind::kAlwaysTrue && op.waveVector) {
+    /// Filtres get to record an extra copy of their passing rows if they make
+    /// values.
+    if (blockIdx == 0) {
+      op.extraRowCountId = deviceStaging.reserve(
+          numBlocks * step->numRowsPerThread * sizeof(int32_t));
+      deviceStaging.registerPointer(
+          op.extraRowCountId, &step->filterRowCount, true);
+      deviceStaging.registerPointer(
+          op.extraRowCountId, &op.extraRowCount, true);
+    } else {
+      step->filterRowCount = reinterpret_cast<int32_t*>(
+          blockIdx * sizeof(int32_t) * maxRowsPerThread);
+      deviceStaging.registerPointer(
+          op.extraRowCountId, &step->filterRowCount, false);
+    }
+  }
+  step->dataType = columnKind;
+  auto kindSize = waveTypeKindSize(columnKind);
+  step->step =
+      kindSize == 4 ? DecodeStep::kSelective32 : DecodeStep::kSelective64;
+  if (previousFilter) {
+    step->maxRow = GpuDecode::kFilterHits;
+  } else {
+    step->maxRow = currentRow_ + (blockIdx * rowsPerBlock) + rowsInBlock;
+  }
+  step->baseRow = currentRow_ + rowsPerBlock * blockIdx;
+
+  if (op.waveVector) {
+    if (blockIdx == 0) {
+      VELOX_CHECK_GE(op.waveVector->size(), op.rows.size());
+    }
+    step->result =
+        op.waveVector->values<char>() + kindSize * blockIdx * rowsPerBlock;
+    step->resultNulls = op.waveVector->nulls()
+        ? op.waveVector->nulls() + blockIdx * rowsPerBlock
+        : nullptr;
+
+    if (previousFilter) {
+      if (previousFilter->deviceResult) {
+        // This is when the previous filter is in the previous kernel and its
+        // device side result is allocated.
+        step->rows = previousFilter->deviceResult + blockIdx * rowsPerBlock;
+      } else {
+        step->rows = reinterpret_cast<int32_t*>(
+            blockIdx * rowsPerBlock * sizeof(int32_t));
+        deviceStaging.registerPointer(
+            previousFilter->deviceResultId, &step->rows, false);
+      }
+    }
+    if (op.reader->scanSpec().filter()) {
+      if (blockIdx == 0) {
+        op.deviceResultId =
+            deviceStaging.reserve(op.rows.size() * sizeof(int32_t));
+        deviceStaging.registerPointer(
+            op.deviceResultId, &step->resultRows, true);
+        deviceStaging.registerPointer(
+            op.deviceResultId, &op.deviceResult, true);
+      } else {
+        step->resultRows = reinterpret_cast<int32_t*>(
+            blockIdx * rowsPerBlock * sizeof(int32_t));
+        deviceStaging.registerPointer(
+            op.deviceResultId, &step->resultRows, false);
+      }
+    }
+  }
+  return step;
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/FormatData.h b/velox/experimental/wave/dwio/FormatData.h
new file mode 100644
index 0000000000000..c5b316865c7ef
--- /dev/null
+++ b/velox/experimental/wave/dwio/FormatData.h
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Range.h>
+#include "velox/common/base/Semaphore.h"
+#include "velox/common/caching/AsyncDataCache.h"
+#include "velox/common/file/Region.h"
+#include "velox/dwio/common/ScanSpec.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/experimental/wave/dwio/decode/DecodeStep.h"
+#include "velox/experimental/wave/exec/OperandSet.h"
+#include "velox/experimental/wave/vector/WaveVector.h"
+
+namespace facebook::velox::wave {
+
+class ReadStream;
+class WaveStream;
+
+/// Use generic bit set to track depemdemce pon staging.
+using StagingSet = OperandSet;
+
+// Describes how a column is staged on GPU, for example, copy from host RAM,
+// direct read, already on device etc.
+struct Staging {
+  Staging(const void* hostData, int32_t size, const common::Region& region)
+      : hostData(hostData),
+        size(hostData ? size : region.length),
+        fileOffset(region.offset) {}
+
+  // Pointer to data in pageable host memory, if applicable.
+  const void* hostData{nullptr};
+
+  //  Size in bytes.
+  size_t size;
+
+  /// If 'hostData' is nullptr, this is the start offset for 'size'
+  /// bytes in 'fileInfo_' of containing SplitStaging.
+  int64_t fileOffset{0};
+};
+
+struct FileInfo {
+  ReadFile* file{nullptr};
+  StringIdLease* fileId{nullptr};
+  cache::AsyncDataCache* cache{nullptr};
+};
+
+/// Describes how columns to be read together are staged on device. This is
+/// anything from a set of host to device copies, GPU direct IO, or no-op if
+/// data already on device.
+class SplitStaging {
+ public:
+  /// id indicating no dependence on other staging.
+  static constexpr int32_t kNoStaging = ~0;
+
+  SplitStaging(FileInfo& fileInfo, int32_t id) : id_(id), fileInfo_(fileInfo) {}
+
+  /// Adds a transfer described by 'staging'. Returns an id of the
+  /// device side buffer. The id will be mapped to an actual buffer
+  /// when the transfers are queud. At this time, pointers that
+  /// are registered to the id are patched to the actual device side
+  /// address.
+  BufferId add(Staging& staging);
+
+  /// Registers '*ptr' to be patched to the device side address of the transfer
+  /// identified by 'id'. The *ptr is an offset into the buffer identified by
+  /// id, so that the actual start of the area is added to the offset at *ptr.
+  /// If 'clear' is true, *ptr is set to nullptr first. This may not be called
+  /// after transfer().
+  template <typename T>
+  void registerPointer(BufferId id, T pointer, bool clear) {
+    registerPointerInternal(
+        id,
+        reinterpret_cast<void**>(reinterpret_cast<uint64_t>(pointer)),
+        clear);
+  }
+
+  int64_t bytesToDevice() const {
+    return fill_;
+  }
+  // Starts the transfers registered with add( on 'stream'). Does
+  // nothing after first call or if no pointers are registered. If
+  // 'recordEvent' is true, records an event that is completed after
+  // the transfer arrives. Use event() to access the event. If
+  // 'asyncTail' is non-nullptr, it is called after the data transfer
+  // is enqueued. The call is on an executor and transfer() returns as
+  // soon as the work is enqueud. If asyncTail is not given,
+  // transfer() returns after the transfer is enqueued on
+  // 'stream'. event() is not set until the transfer is enqueued.
+  void transfer(
+      WaveStream& waveStream,
+      Stream& stream,
+      bool recordEvent = false,
+      std::function<void(WaveStream&, Stream&)> asyncTail = nullptr);
+
+  Event* event() const {
+    return event_.get();
+  }
+
+  int32_t id() const {
+    return id_;
+  }
+
+  void addDependency(int32_t id) {
+    dependsOn_.add(id);
+  }
+
+  const StagingSet& dependsOn() {
+    return dependsOn_;
+  }
+
+ private:
+  void registerPointerInternal(BufferId id, void** ptr, bool clear);
+
+  void copyColumns(int32_t begin, int32_t end, char* destination, bool release);
+
+  const int32_t id_;
+
+  // Pinned host memory for transfer to device. May be nullptr if using unified
+  // memory.
+  WaveBufferPtr hostBuffer_;
+
+  // Device accessible memory (device or unified) with the data to read.
+  WaveBufferPtr deviceBuffer_;
+
+  std::vector<Staging> staging_;
+  // Offsets into device buffer for each id returned by add().
+  std::vector<int64_t> offsets_;
+
+  // List of pointers to patch to places inside deviceBuffer once this is
+  // allocated.
+  std::vector<std::pair<int32_t, void**>> patch_;
+
+  // Total device side space reserved so farr.
+  int64_t fill_{0};
+
+  // Optional event recorded after end of transfer. Use to sync dependent
+  // kernels on other streams.
+  std::unique_ptr<Event> event_;
+
+  // Synchronizes arrival of multithreaded memcpy
+  Semaphore sem_{0};
+
+  FileInfo& fileInfo_;
+
+  // Set of other SplitStaging ids of which 'this' is a
+  // duplicate. These need to be complete efore dependents of 'this'
+  // can run. A staging can both have transfers and dependencies.
+  StagingSet dependsOn_;
+};
+
+using RowSet = folly::Range<const int32_t*>;
+class ColumnReader;
+
+/// Information that allows a column to be read in parallel independent thread
+/// blocks. This represents an array of starting points inside the encoded
+/// column.
+struct ColumnGridInfo {
+  /// Number of independently schedulable blocks.
+  int32_t numBlocks;
+
+  ///
+  BlockStatus* status{nullptr};
+
+  /// Device readable nulls as a flat bitmap. 1 is non-null. nullptr means
+  /// non-null.
+  char* nulls{nullptr};
+
+  /// Device side array of non-null counts. Decoding for values for the ith
+  /// block starts at index 'nonNullCount[i - 1]' in encoded values. nullptr if
+  /// non nulls.
+  int32_t* numNonNull{nullptr};
+};
+
+// Specifies an action on a column. A column is not indivisible. It
+// has parts and another column's decode may depend on one part of
+// another column but not another., e.g. a child of a nullable struct
+// needs the nulls of the struct but no other parts to decode.
+enum class ColumnAction { kNulls = 1, kLengths = 2, kFilter = 4, kValues = 8 };
+
+/// A generic description of a decode step. The actual steps are
+/// provided by FormatData specializations but this captures
+/// dependences, e.g. filters before non-filters, nulls and lengths
+/// of repeated containers before decoding the values. A dependency
+/// can be device side only or may need host decision. Items that
+/// depend device side can be made into consecutive decode ops in
+/// one kernel launch or can be in consecutively queued
+/// kernels. dependences which need host require the prerequisite
+/// kernel to ship data to host, which will sync on the stream and
+/// only then may schedule the dependents in another kernel.
+struct ColumnOp {
+  static constexpr int32_t kNoPrerequisite = -1;
+  static constexpr int32_t kNoOperand = -1;
+
+  // Is the op completed after this? If so, any dependent action can be
+  // queued as soon as this is set.
+  bool isFinal{false};
+  // True if needs a result on the host before proceeding.
+  bool needsResult{false};
+  OperandId producesOperand{kNoOperand};
+  // Index of another op in column ops array in ReadStream.
+  int32_t prerequisite{kNoPrerequisite};
+  ColumnAction action;
+  // Non-owning view on rows to read.
+  RowSet rows;
+  ColumnReader* reader{nullptr};
+  // Vector completed by arrival of this. nullptr if no vector.
+  WaveVector* waveVector{nullptr};
+
+  // Host side result size. 0 for unconditional decoding. Can be buffer size for
+  // passing rows, length/offset array etc.
+  int32_t resultSize{0};
+
+  // Device side non-vector result, like set of passing rows, array of
+  // lengths/starts etc.
+  int32_t* deviceResult{nullptr};
+
+  // Id of 'deviceResult' from resultStaging. A subsequent op must refer to the
+  // result of the previous one before the former is allocated.
+  BufferId deviceResultId{kNoBufferId};
+
+  // Id of extra filter passing row count. Needed for aligning values from
+  // non-last filtered columns to final.
+  int32_t* extraRowCount{nullptr};
+
+  BufferId extraRowCountId{kNoBufferId};
+
+  int32_t* hostResult{nullptr};
+};
+
+/// Operations on leaf columns. This is specialized for each file format.
+class FormatData {
+ public:
+  virtual ~FormatData() = default;
+
+  virtual int32_t totalRows() const = 0;
+
+  virtual bool hasNulls() const = 0;
+
+  /// Enqueues read of 'numRows' worth of null flags.  Returns the id of the
+  /// result area allocated from 'deviceStaging'.
+  virtual BufferId readNulls(
+      int32_t numRows,
+      ResultStaging& deviceStaging,
+      SplitStaging& stageing,
+      DecodePrograms& programs) {
+    VELOX_NYI();
+  }
+
+  /// Sets how many TBs will be scheduled at a time for this column.
+  void setBlocks(int32_t numBlocks) {
+    VELOX_NYI();
+  }
+
+  /// Returns estimate of sequential instructions needed to decode one value.
+  /// Used to decide how many TBs to use for each column.
+  virtual float cost(const ColumnOp& op) {
+    return 10;
+  }
+
+  /// Prepares a new batch of reads. The batch starts at 'startRiw', which is a
+  /// row number in terms of the column of 'this'. The row number for a nested
+  /// column is in terms of the column, not in terms of top level rows.
+  virtual void newBatch(int32_t startRow) = 0;
+
+  /// Schedules operations for preparing the encoded data to be
+  /// consumed in 'numBlocks' parallel blocks of 'blockSize' rows. For
+  /// example, for a column of 11M nullable varints, this with 1024
+  /// blocksize and 2048 blocks, this would count 2M bits and write a
+  /// prefix sum every 1K bits, so that we know the corresponding
+  /// position in the varints for non-nulls. Then for the varints, we
+  /// write the starting offset every 1K nulls, e.g, supposing 2 bytes
+  /// per varint and 800 non-nulls for every 1K bits, we get 0, 1600,
+  /// 3600, ... as starts for the varints. The FormatData stores the
+  /// intermediates. This is a no-op for encodings that are random
+  /// access capable, e.g. non-null bit packings. this is a also a
+  /// no-op if there are less than 'blockSize' rows left.
+  virtual void griddize(
+      int32_t blockSize,
+      int32_t numBlocks,
+      ResultStaging& deviceStaging,
+      ResultStaging& resultStaging,
+      SplitStaging& staging,
+      DecodePrograms& program,
+      ReadStream& stream) = 0;
+
+  /// Adds the next read of the column. If the column is a filter depending on
+  /// another filter, the previous filter is given on the first call. Updates
+  /// status of 'op'.
+  virtual void startOp(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ResultStaging& deviceStaging,
+      ResultStaging& resultStaging,
+      SplitStaging& staging,
+      DecodePrograms& program,
+      ReadStream& stream) = 0;
+
+ protected:
+  std::unique_ptr<GpuDecode> makeStep(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ResultStaging& deviceStaging,
+      SplitStaging& splitStaging,
+      ReadStream& stream,
+      WaveTypeKind columnKind,
+      int32_t blockIdx);
+
+  // Staging id for nulls.
+  int32_t nullsStagingId_{SplitStaging::kNoStaging};
+  // Id for nulls buffer. The nulls buffer has no address at time of scheduling
+  // if nulls decode is in the same kernel as decoding.
+  BufferId nullsBufferId_{kNoBufferId};
+  // id of last splitStaging 'this' depends on.
+  int32_t lastStagingId_{SplitStaging::kNoStaging};
+
+  // First unaccessed row number relative to start of 'this'.
+  int32_t currentRow_{0};
+
+  ColumnGridInfo grid_;
+  bool griddized_{false};
+};
+
+class FormatParams {
+ public:
+  explicit FormatParams(
+      memory::MemoryPool& pool,
+      dwio::common::ColumnReaderStatistics& stats)
+      : pool_(pool), stats_(stats) {}
+
+  virtual ~FormatParams() = default;
+
+  /// Makes format-specific structures for the column given by  'type'.
+  /// 'scanSpec' is given as extra context.
+  virtual std::unique_ptr<FormatData> toFormatData(
+      const std::shared_ptr<const dwio::common::TypeWithId>& type,
+      const velox::common::ScanSpec& scanSpec,
+      OperandId operand) = 0;
+
+  memory::MemoryPool& pool() {
+    return pool_;
+  }
+
+  dwio::common::ColumnReaderStatistics& runtimeStatistics() {
+    return stats_;
+  }
+
+ private:
+  memory::MemoryPool& pool_;
+  dwio::common::ColumnReaderStatistics& stats_;
+  int32_t currentRow_{0};
+};
+
+}; // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/ReadStream.cpp b/velox/experimental/wave/dwio/ReadStream.cpp
new file mode 100644
index 0000000000000..af8f52ac3c6bd
--- /dev/null
+++ b/velox/experimental/wave/dwio/ReadStream.cpp
@@ -0,0 +1,474 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/process/TraceContext.h"
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/dwio/StructColumnReader.h"
+
+DEFINE_int32(
+    wave_reader_rows_per_tb,
+    1024,
+    "Number of items per thread block in Wave reader");
+
+DEFINE_int32(
+    wave_max_reader_batch_rows,
+    80 * 1024,
+    "Max batch for Wave table scan");
+
+namespace facebook::velox::wave {
+
+void allOperands(
+    const ColumnReader* reader,
+    OperandSet& operands,
+    std::vector<AbstractOperand*>* abstractOperands) {
+  auto op = reader->operand();
+  if (op != nullptr) {
+    operands.add(op->id);
+    if (abstractOperands) {
+      abstractOperands->push_back(op);
+    }
+  }
+
+  for (auto& child : reader->children()) {
+    allOperands(child, operands, abstractOperands);
+  }
+}
+
+ReadStream::ReadStream(
+    StructColumnReader* columnReader,
+    WaveStream& _waveStream,
+    io::IoStatistics* ioStats,
+    FileInfo& fileInfo,
+    const OperandSet* firstColumns)
+    : Executable(), ioStats_(ioStats), fileInfo_(fileInfo) {
+  VELOX_CHECK_EQ(
+      0,
+      FLAGS_wave_reader_rows_per_tb & 1023,
+      "wave_reader_rows_per_tb must be a multiple of 1K");
+  waveStream = &_waveStream;
+  allOperands(columnReader, outputOperands, &abstractOperands_);
+  output.resize(outputOperands.size());
+  reader_ = columnReader;
+  reader_->splitStaging().push_back(
+      std::make_unique<SplitStaging>(fileInfo_, 0));
+  currentStaging_ = reader_->splitStaging().back().get();
+}
+
+void ReadStream::setBlockStatusAndTemp(Stream* stream) {
+  auto* status = control_->deviceData->as<BlockStatus>();
+  prefetchStatus(stream);
+  auto maxRowsPerThread = FLAGS_wave_reader_rows_per_tb / kBlockSize;
+  auto tempSize = programs_.programs[0][0]->tempSize();
+  auto size = programs_.programs.size() * tempSize;
+  auto id = deviceStaging_.reserve(size);
+  for (auto blockIdx = 0; blockIdx < programs_.programs.size(); ++blockIdx) {
+    auto& program = programs_.programs[blockIdx];
+    for (auto& op : program) {
+      op->temp = reinterpret_cast<int32_t*>(blockIdx * tempSize);
+      deviceStaging_.registerPointer(id, &op->temp, false);
+      op->blockStatus = status + maxRowsPerThread * op->nthBlock;
+    }
+  }
+}
+
+void ReadStream::prefetchStatus(Stream* stream) {
+  if (!stream) {
+    return;
+  }
+  char* data = control_->deviceData->as<char>();
+  auto size = control_->deviceData->size() - (statusBytes_ + gridStatusBytes_);
+  stream->prefetch(getDevice(), data + statusBytes_ + gridStatusBytes_, size);
+}
+
+namespace {
+void maybeRecordTransferTime(Stream& stream, WaveStream& waveStream) {
+  if (stream.getAndClearIsTransfer() && FLAGS_wave_transfer_timing) {
+    WaveTimer t(waveStream.mutableStats().transferWaitTime);
+    stream.wait();
+  }
+}
+} // namespace
+
+void ReadStream::makeGrid(Stream* stream) {
+  programs_.clear();
+  auto total = reader_->formatData()->totalRows();
+  auto blockSize = FLAGS_wave_reader_rows_per_tb;
+  auto numBlocks = bits::roundUp(total, blockSize) / blockSize;
+  auto& children = reader_->children();
+  for (auto i = 0; i < children.size(); ++i) {
+    auto* child = reader_->children()[i];
+    // TODO:  Must  propagate the incoming nulls from outer to inner structs.
+    // griddize must decode nulls if present.
+    child->formatData()->griddize(
+        blockSize,
+        numBlocks,
+        deviceStaging_,
+        resultStaging_,
+        *currentStaging_,
+        programs_,
+        *this);
+  }
+  if (!programs_.programs.empty()) {
+    WaveStats& stats = waveStream->stats();
+    auto bytes = currentStaging_->bytesToDevice();
+    ioStats_->incRawBytesRead(bytes);
+    stats.bytesToDevice += bytes;
+    ++stats.numKernels;
+    stats.numPrograms += programs_.programs.size();
+    stats.numThreads +=
+        programs_.programs.size() * std::min<int32_t>(rows_.size(), kBlockSize);
+    setBlockStatusAndTemp();
+    deviceStaging_.makeDeviceBuffer(waveStream->arena());
+    currentStaging_->transfer(*waveStream, *stream, true);
+    LaunchParams params(waveStream->deviceArena());
+    WaveBufferPtr extra;
+    {
+      maybeRecordTransferTime(*stream, *waveStream);
+      PrintTime l("grid");
+      launchDecode(programs_, params, stream);
+    }
+    reader_->recordGriddize(*stream);
+    if (params.device) {
+      commands_.push_back(std::move(params));
+    }
+    auto nth = reader_->splitStaging().size();
+    reader_->splitStaging().push_back(
+        std::make_unique<SplitStaging>(fileInfo_, nth));
+    currentStaging_ = reader_->splitStaging().back().get();
+  }
+}
+
+void ReadStream::makeCompact(bool isSerial) {
+  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
+  auto maxRowsPerThread = FLAGS_wave_reader_rows_per_tb / kBlockSize;
+  for (int32_t i = 0; i < static_cast<int32_t>(filters_.size()) - 1; ++i) {
+    if (filters_[i].waveVector) {
+      int32_t numTBs =
+          bits::roundUp(numBlocks_, maxRowsPerThread) / maxRowsPerThread;
+      for (auto blockIdx = 0; blockIdx < numTBs; ++blockIdx) {
+        auto step = std::make_unique<GpuDecode>();
+        step->step = DecodeStep::kCompact64;
+        step->nthBlock = blockIdx;
+        step->numRowsPerThread = blockIdx == numTBs - 1
+            ? numBlocks_ - (numTBs - 1) * maxRowsPerThread
+            : maxRowsPerThread;
+        step->gridNumRowsPerThread = maxRowsPerThread;
+        if (filters_.back().deviceResult) {
+          step->data.compact.finalRows =
+              filters_.back().deviceResult + blockIdx * rowsPerBlock;
+          step->data.compact.sourceNumRows =
+              filters_[i].extraRowCount + blockIdx * maxRowsPerThread;
+        } else {
+          step->data.compact.finalRows = reinterpret_cast<int32_t*>(
+              blockIdx * rowsPerBlock * sizeof(int32_t));
+          deviceStaging_.registerPointer(
+              filters_.back().deviceResultId,
+              &step->data.compact.finalRows,
+              false);
+          step->data.compact.sourceNumRows = reinterpret_cast<int32_t*>(
+              blockIdx * maxRowsPerThread * sizeof(int32_t));
+          deviceStaging_.registerPointer(
+              filters_[i].extraRowCountId,
+              &step->data.compact.sourceNumRows,
+              false);
+        }
+        if (filters_[i].deviceResult) {
+          step->data.compact.sourceRows =
+              filters_[i].deviceResult + blockIdx * rowsPerBlock;
+        } else {
+          step->data.compact.sourceRows =
+              reinterpret_cast<int32_t*>(blockIdx * rowsPerBlock);
+          deviceStaging_.registerPointer(
+              filters_[i].deviceResultId,
+              &step->data.compact.sourceRows,
+              false);
+        }
+        auto& vector = filters_[i].waveVector;
+        step->dataType = static_cast<WaveTypeKind>(vector->type()->kind());
+        step->data.compact.source = vector->values<char>() +
+            waveTypeKindSize(step->dataType) * blockIdx * rowsPerBlock;
+        if (vector->nulls()) {
+          step->data.compact.sourceNull =
+              vector->nulls() + blockIdx * rowsPerBlock;
+        }
+        if (isSerial) {
+          programs_.programs[blockIdx].push_back(std::move(step));
+        } else {
+          programs_.programs.emplace_back();
+          programs_.programs.back().push_back(std::move(step));
+        }
+      }
+    }
+  }
+}
+
+void ReadStream::makeOps() {
+  auto& children = reader_->children();
+  for (auto i = 0; i < children.size(); ++i) {
+    auto* child = reader_->children()[i];
+    if (child->scanSpec().filter()) {
+      hasFilters_ = true;
+      filters_.emplace_back();
+      bool filterOnly = !child->scanSpec().keepValues();
+      child->makeOp(
+          this,
+          filterOnly ? ColumnAction::kFilter : ColumnAction::kValues,
+          filters_.back());
+    }
+  }
+  for (auto i = 0; i < children.size(); ++i) {
+    auto* child = reader_->children()[i];
+    if (child->scanSpec().filter()) {
+      continue;
+    }
+    ops_.emplace_back();
+    auto& op = ops_.back();
+    child->makeOp(this, ColumnAction::kValues, op);
+  }
+}
+
+bool ReadStream::decodenonFiltersInFiltersKernel() {
+  return ops_.size() == 1;
+}
+
+void ReadStream::prepareRead() {
+  filtersDone_ = false;
+  for (auto& op : filters_) {
+    op.reader->formatData()->newBatch(row_);
+    op.isFinal = false;
+    op.rows = rows_;
+  }
+  for (auto& op : ops_) {
+    op.reader->formatData()->newBatch(row_);
+    op.isFinal = false;
+    op.rows = rows_;
+  }
+}
+
+bool ReadStream::makePrograms(bool& needSync) {
+  bool allDone = true;
+  needSync = false;
+  programs_.clear();
+  ColumnOp* previousFilter = nullptr;
+  if (!filtersDone_ && !filters_.empty()) {
+    // Filters are done consecutively, each TB does all the filters for its
+    // range.
+    for (auto& filter : filters_) {
+      filter.reader->formatData()->startOp(
+          filter,
+          previousFilter,
+          deviceStaging_,
+          resultStaging_,
+          *currentStaging_,
+          programs_,
+          *this);
+      previousFilter = &filter;
+    }
+    if (!decodenonFiltersInFiltersKernel()) {
+      filtersDone_ = true;
+      return false;
+    }
+  }
+  makeCompact(!filtersDone_);
+  previousFilter = filters_.empty() ? nullptr : &filters_.back();
+  for (auto i = 0; i < ops_.size(); ++i) {
+    auto& op = ops_[i];
+    if (op.isFinal) {
+      continue;
+    }
+    if (op.prerequisite == ColumnOp::kNoPrerequisite ||
+        ops_[op.prerequisite].isFinal) {
+      op.reader->formatData()->startOp(
+          op,
+          previousFilter,
+          deviceStaging_,
+          resultStaging_,
+          *currentStaging_,
+          programs_,
+          *this);
+      if (!op.isFinal) {
+        allDone = false;
+      }
+      if (op.needsResult) {
+        needSync = true;
+      }
+    } else {
+      allDone = false;
+    }
+  }
+  filtersDone_ = true;
+  if ((filters_.empty() || gridStatusBytes_ > 0) && allDone) {
+    auto setCount = std::make_unique<GpuDecode>();
+    setCount->step = DecodeStep::kRowCountNoFilter;
+    setCount->data.rowCountNoFilter.numRows = rows_.size();
+    setCount->data.rowCountNoFilter.status =
+        control_->deviceData->as<BlockStatus>();
+    setCount->data.rowCountNoFilter.gridStatusSize = gridStatusBytes_;
+    setCount->data.rowCountNoFilter.gridOnly = !filters_.empty();
+
+    programs_.programs.emplace_back();
+    programs_.programs.back().push_back(std::move(setCount));
+  }
+  ++nthWave_;
+  resultStaging_.setReturnBuffer(waveStream->arena(), programs_.result);
+  return allDone;
+}
+
+void ReadStream::syncStaging(Stream& stream) {
+  auto& set = currentStaging_->dependsOn();
+  if (set.empty()) {
+    return;
+  }
+  set.forEach([&](int32_t id) {
+    auto dep = reader_->splitStaging()[id].get();
+    auto event = dep->event();
+    VELOX_CHECK(event);
+    event->wait(stream);
+  });
+}
+
+void ReadStream::launch(
+    std::unique_ptr<ReadStream> readStream,
+    int32_t row,
+    RowSet rows) {
+  using UniqueExe = std::unique_ptr<Executable>;
+  readStream->row_ = row;
+  readStream->rows_ = rows;
+
+  // The function of control here is to have a status and row count for each
+  // kBlockSize top level rows of output and to have Operand structs for the
+  // produced column.
+  readStream->makeControl();
+  auto numRows = readStream->rows_.size();
+  auto waveStream = readStream->waveStream;
+  WaveStats& stats = waveStream->stats();
+  bool firstLaunch = true;
+  waveStream->installExecutables(
+      folly::Range<UniqueExe*>(reinterpret_cast<UniqueExe*>(&readStream), 1),
+      [&](Stream* stream, folly::Range<Executable**> exes) {
+        auto* readStream = reinterpret_cast<ReadStream*>(exes[0]);
+        bool needSync = false;
+        bool griddizedHere = false;
+        if (!readStream->inited_) {
+          readStream->makeGrid(stream);
+          griddizedHere = true;
+          readStream->makeOps();
+          readStream->inited_ = true;
+        }
+        readStream->prepareRead();
+        for (;;) {
+          bool done = readStream->makePrograms(needSync);
+          auto bytes = readStream->currentStaging_->bytesToDevice();
+          readStream->ioStats_->incRawBytesRead(bytes);
+          stats.bytesToDevice += bytes;
+          ++stats.numKernels;
+          stats.numPrograms += readStream->programs_.programs.size();
+          stats.numThreads += readStream->programs_.programs.size() *
+              std::min<int32_t>(readStream->rows_.size(), kBlockSize);
+          readStream->currentStaging_->transfer(*waveStream, *stream, true);
+          if (done) {
+            break;
+          }
+          readStream->setBlockStatusAndTemp(stream);
+          readStream->deviceStaging_.makeDeviceBuffer(waveStream->arena());
+          WaveBufferPtr extra;
+          if (!griddizedHere && firstLaunch) {
+            // If the same split is read on multiple streams for
+            // different row ranges, the non-first will have to sync
+            // on the griddize of the first.
+            if (auto* event = readStream->reader_->griddizeEvent()) {
+              event->wait(*stream);
+            }
+          }
+          firstLaunch = false;
+          readStream->syncStaging(*stream);
+          LaunchParams params(waveStream->deviceArena());
+          {
+            maybeRecordTransferTime(*stream, *readStream->waveStream);
+            PrintTime l("decode");
+            launchDecode(readStream->programs(), params, stream);
+          }
+          if (params.device) {
+            readStream->commands_.push_back(std::move(params));
+          }
+          auto nth = readStream->reader_->splitStaging().size();
+          readStream->reader_->splitStaging().push_back(
+              std::make_unique<SplitStaging>(readStream->fileInfo_, nth));
+          readStream->currentStaging_ =
+              readStream->reader_->splitStaging().back().get();
+          if (needSync) {
+            waveStream->setState(WaveStream::State::kWait);
+            stream->wait();
+            readStream->waveStream->setState(WaveStream::State::kHost);
+          } else {
+            readStream->waveStream->setState(WaveStream::State::kParallel);
+          }
+        }
+
+        readStream->setBlockStatusAndTemp(stream);
+        readStream->deviceStaging_.makeDeviceBuffer(waveStream->arena());
+        LaunchParams params(readStream->waveStream->deviceArena());
+        readStream->syncStaging(*stream);
+        {
+          maybeRecordTransferTime(*stream, *readStream->waveStream);
+          PrintTime l("decode-f");
+          launchDecode(readStream->programs(), params, stream);
+        }
+        if (params.device) {
+          readStream->commands_.push_back(std::move(params));
+        }
+        readStream->waveStream->setState(WaveStream::State::kParallel);
+        readStream->waveStream->markLaunch(*stream, *readStream);
+      });
+}
+
+void ReadStream::makeControl() {
+  auto numRows = rows_.size();
+  numBlocks_ = bits::roundUp(numRows, kBlockSize) / kBlockSize;
+  waveStream->setNumRows(numRows);
+  WaveStream::ExeLaunchInfo info;
+  waveStream->exeLaunchInfo(*this, numBlocks_, info);
+  auto instructionStatus = waveStream->instructionStatus();
+  int32_t instructionBytes =
+      instructionStatusSize(instructionStatus, numBlocks_);
+  statusBytes_ = bits::roundUp(sizeof(BlockStatus) * numBlocks_, 8);
+  auto deviceBytes = statusBytes_ + instructionBytes + info.totalBytes;
+  auto control = std::make_unique<LaunchControl>(0, numRows);
+  control->deviceData = waveStream->arena().allocate<char>(deviceBytes);
+  // The operand section must be cleared before written on host. The statuses
+  // are cleared on device.
+  memset(
+      control->deviceData->as<char>() + statusBytes_ + instructionBytes,
+      0,
+      info.totalBytes);
+  control->params.status = control->deviceData->as<BlockStatus>();
+  for (auto& reader : reader_->children()) {
+    if (!reader->formatData()->hasNulls() || reader->hasNonNullFilter()) {
+      auto* operand = reader->operand();
+      if (operand) {
+        waveStream->operandNullable()[operand->id] = false;
+      }
+    }
+  }
+  operands = waveStream->fillOperands(
+      *this,
+      control->deviceData->as<char>() + statusBytes_ + instructionBytes,
+      info)[0];
+  control_ = control.get();
+  waveStream->setLaunchControl(0, 0, std::move(control));
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/StructColumnReader.cpp b/velox/experimental/wave/dwio/StructColumnReader.cpp
new file mode 100644
index 0000000000000..ec20a5159ec57
--- /dev/null
+++ b/velox/experimental/wave/dwio/StructColumnReader.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/dwio/StructColumnReader.h"
+
+namespace facebook ::velox::wave {
+
+bool StructColumnReader::isChildConstant(
+    const velox::common::ScanSpec& childSpec) const {
+  // Returns true if the child has a constant set in the ScanSpec, or if the
+  // file doesn't have this child (in which case it will be treated as null).
+  return childSpec.isConstant() ||
+      // The below check is trying to determine if this is a missing field in a
+      // struct that should be constant null.
+      (!isRoot_ && // If we're in the root struct channel is meaningless in this
+                   // context and it will be a null constant anyway if it's
+                   // missing.
+       childSpec.channel() !=
+           velox::common::ScanSpec::kNoChannel && // This can happen if there's
+                                                  // a filter on a subfield of a
+                                                  // row type that doesn't exist
+                                                  // in the output.
+       fileType_->type()->kind() !=
+           TypeKind::MAP && // If this is the case it means this is a flat map,
+                            // so it can't have "missing" fields.
+       childSpec.channel() >= fileType_->size());
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/StructColumnReader.h b/velox/experimental/wave/dwio/StructColumnReader.h
new file mode 100644
index 0000000000000..15895ac8b3135
--- /dev/null
+++ b/velox/experimental/wave/dwio/StructColumnReader.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+
+namespace facebook ::velox::wave {
+
+class StructColumnReader : public ColumnReader {
+ public:
+  StructColumnReader(
+      const TypePtr& requestedType,
+      std::shared_ptr<const dwio::common::TypeWithId> fileType,
+      AbstractOperand* operand,
+      FormatParams& params,
+      velox::common::ScanSpec& scanSpec,
+      bool isRoot)
+      : ColumnReader(requestedType, fileType, operand, params, scanSpec),
+        isRoot_(isRoot) {}
+
+  bool isChildConstant(const velox::common::ScanSpec& childSpec) const;
+
+ protected:
+  void addChild(std::unique_ptr<ColumnReader> child) {
+    children_.push_back(child.get());
+    childrenOwned_.push_back(std::move(child));
+  }
+
+  const bool isRoot_;
+  std::vector<std::unique_ptr<ColumnReader>> childrenOwned_;
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/decode/CMakeLists.txt b/velox/experimental/wave/dwio/decode/CMakeLists.txt
new file mode 100644
index 0000000000000..790995c47a3c6
--- /dev/null
+++ b/velox/experimental/wave/dwio/decode/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_subdirectory(tests)
+
+velox_add_library(velox_wave_decode GpuDecoder.cu)
+
+velox_link_libraries(velox_wave_decode velox_wave_common)
diff --git a/velox/experimental/wave/dwio/decode/DecodeStep.h b/velox/experimental/wave/dwio/decode/DecodeStep.h
new file mode 100644
index 0000000000000..9ae0e73312d8b
--- /dev/null
+++ b/velox/experimental/wave/dwio/decode/DecodeStep.h
@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/wave/common/Buffer.h"
+#include "velox/experimental/wave/common/GpuArena.h"
+#include "velox/experimental/wave/common/ResultStaging.h"
+#include "velox/experimental/wave/vector/Operand.h"
+
+namespace facebook::velox::wave {
+
+enum class NullMode : uint8_t {
+  kDenseNonNull,
+  kSparseNonNull,
+  kDenseNullable,
+  kSparseNullable
+};
+
+enum class WaveFilterKind : uint8_t {
+  kAlwaysTrue,
+  kNotNull,
+  kNull,
+  kBigintRange,
+  kDoubleRange,
+  kFloatRange,
+  kBigintValues
+};
+
+struct alignas(16) WaveFilterBase {
+  union {
+    int64_t int64Range[2];
+    float floatRange[2];
+    double doubleRange[2];
+    struct {
+      int32_t size;
+      void* table;
+    } values;
+  } _;
+  // flags for float/double range.
+  bool lowerUnbounded;
+  bool upperUnbounded;
+  bool lowerExclusive;
+  bool upperExclusive;
+};
+
+/// Instructions for GPU decode.  This can be decoding,
+/// or pre/post processing other than decoding.
+enum class DecodeStep {
+  kSelective32,
+  kCompact64,
+  kSelective64,
+  kConstant32,
+  kConstant64,
+  kConstantChar,
+  kConstantBool,
+  kConstantBytes,
+  kTrivial,
+  kTrivialNoOp,
+  kMainlyConstant,
+  kBitpack32,
+  kBitpack64,
+  kRleTotalLength,
+  kRleBool,
+  kRle,
+  kDictionary,
+  kDictionaryOnBitpack,
+  kVarint,
+  kNullable,
+  kSentinel,
+  kSparseBool,
+  kMakeScatterIndices,
+  kScatter32,
+  kScatter64,
+  kLengthToOffset,
+  kMissing,
+  kStruct,
+  kArray,
+  kMap,
+  kFlatMap,
+  kFlatMapNode,
+  kRowCountNoFilter,
+  kCountBits,
+  kUnsupported,
+};
+
+class ColumnReader;
+
+/// Describes a decoding loop's input and result disposition.
+struct alignas(16) GpuDecode {
+  /// Constant in 'numRows' to signify the number comes from 'blockstatus'.
+  static constexpr int32_t kFilterHits = -1;
+
+  // The operation to perform. Decides which branch of the union to use.
+  DecodeStep step;
+  DecodeStep encoding;
+
+  WaveTypeKind dataType;
+
+  /// If false, implies a not null filter. If there is a filter, specifies
+  /// whether nulls pass.
+  bool nullsAllowed{true};
+
+  WaveFilterKind filterKind{WaveFilterKind::kAlwaysTrue};
+
+  NullMode nullMode;
+
+  /// Number of chunks (e.g. Parquet pages). If > 1, different rows row ranges
+  /// have different encodings. The first chunk's encoding is in 'data'. The
+  /// next chunk's encoding is in the next GpuDecode's 'data'. Each chunk has
+  /// its own 'nulls'. The input row numbers and output data/row numbers are
+  /// given by the first GpuDecode.
+  uint8_t numChunks{1};
+
+  // Ordinal number of TB in TBs working on the same column. Each TB does a
+  // multiple of TB width rows. The TBs for different ranges of rows are
+  // launched in the same grid but are independent. The ordinal for non-first
+  // TBs gets the base index for values.
+  uint16_t nthBlock{0};
+  /// Number of rows to process per thread of this block. This is equal across
+  /// the grid, except for last block.
+  uint16_t numRowsPerThread{1};
+
+  /// Number of rows per thread in the grid, same for all blocks including the
+  /// last one.
+  uint16_t gridNumRowsPerThread{1};
+
+  /// Number of rows to decode. if kFilterHits, the previous GpuDecode gives
+  /// this number in BlockStatus. If 'rows' is set, this is the number of valid
+  /// elements in 'rows'. If 'rows' is not set, the start is ''baseRow'
+  int32_t maxRow{0};
+
+  // If rows are densely decoded, this is the first row in terms of nullable
+  // rows to decode in this TB.
+  int32_t baseRow{0};
+
+  /// Row count from filter. If a filter precedes this, the row count
+  /// is read from this and 'rows' is set to the result row
+  /// numbers. If this is a filter, the row count is written to
+  /// 'blockStatus' and the row numbers are written to
+  /// 'resultRows'. There is one BlockStatus for each kBlockSize rows
+  /// in the grid. One TB covers 'numRowsPerThread' consecutive
+  /// BlockStatuses. Because the previous filter for the range of rows
+  /// is in the same TB read and write of row count is ordered by
+  /// syncthreads at the end of each filter. The subscript is
+  /// 'nthBlock * numRowsPerThread + <nth loop>'.
+  BlockStatus* blockStatus{nullptr};
+
+  /// Extra copy of result row count for each of kBlockSize rows if
+  /// this is a filter. This is needed for non-last filters that
+  /// extract values. The values have to be aligned after the final
+  /// filtering result is known. This is no longer available in
+  /// blockStatus.
+  int32_t* filterRowCount{nullptr};
+
+  // If multiple TBs on the same column and there are nulls, this is the start
+  // offset of the TB's range of rows in non-null values. nullptr if no nulls.
+  int32_t* nonNullBases{nullptr};
+
+  /// If there are multiple chunks, this is an array of starts of non-first
+  /// chunks.
+  int32_t* chunkBounds{nullptr};
+
+  /// If results will be scattered because of nulls, this is the bitmap with a 0
+  /// for null. Subscripted with row number in encoding unit.
+  char* nulls{nullptr};
+
+  // If rows are sparsely decoded, this is the array of row numbers to extract.
+  // The numbers are in terms of nullable rows.
+  int32_t* rows{nullptr};
+
+  // Data for pushed down filter. Interpretation depends on 'filterKind'.
+  WaveFilterBase filter;
+
+  // Temp storage. Requires 2 + (kBlockSize / kWarpThreads) ints for each TB.
+  int32_t* temp;
+
+  /// Row numbers that pass 'filter'. nullptr if no filter.
+  int32_t* resultRows{nullptr};
+
+  /// Result nulls.
+  uint8_t* resultNulls{nullptr};
+
+  /// Result array. nullptr if filter only.
+  void* result{nullptr};
+
+  struct Trivial {
+    // Type of the input and result data.
+    WaveTypeKind dataType;
+    // Input data.
+    const void* input;
+    // Begin position for input, scatter and result.
+    int begin;
+    // End position (exclusive) for input, scatter and result.
+    int end;
+    // If not null, contains the output position relative to result pointer.
+    const int32_t* scatter;
+    // Starting address of the result.
+    void* result;
+  };
+
+  struct MainlyConstant {
+    // Type of the values and result.
+    WaveTypeKind dataType;
+    // Number of total values that should be written to result.
+    int count;
+    // Common value that is repeated.
+    const void* commonValue;
+    // Sparse values that will be picked up when isCommon is false.
+    const void* otherValues;
+    // Bitmask indicating whether a values is common or not.
+    const uint8_t* isCommon;
+    // Temporary storage to keep non-common value indices.  Should be
+    // preallocated to at least count large.
+    int32_t* otherIndices;
+    // Starting address of the result.
+    void* result;
+    // If non-null, the count of non-common elements will be written to this
+    // address.
+    int32_t* otherCount;
+  };
+
+  struct DictionaryOnBitpack {
+    // Type of the alphabet and result.
+    WaveTypeKind dataType;
+    // Dictionary alphabet.
+    const void* alphabet;
+    // Indices into the alphabet.
+    const uint64_t* indices;
+    // Begin position for indices, scatter and result.
+    int begin;
+    // End position (exclusive) for indices, scatter and result.
+    int end;
+    // Bit width of each index.
+    int bitWidth;
+    // If not null, contains the output position relative to result pointer.
+    const int32_t* scatter;
+    // All indices should be offseted by this baseline.
+    int64_t baseline;
+    // Starting address of the result.
+    void* result;
+  };
+
+  struct Varint {
+    // Address of the input data.
+    const char* input;
+    // Byte size of the input data.
+    int size;
+    // Temporary storage to keep whether each byte is a terminal for a number.
+    // Should be allocated at least "size" large.
+    bool* ends;
+    // Temporary storage to keep the location of end position of each number.
+    // Should be allocated at least "size" large.
+    int32_t* endPos;
+    // Type of the result number.
+    WaveTypeKind resultType;
+    // Starting address of the result.
+    void* result;
+    // Count of the numbers in the result.
+    int resultSize;
+  };
+
+  struct SparseBool {
+    // Number of bits in the result.
+    int totalCount;
+    // Sparse value; common value is the opposite of this.
+    bool sparseValue;
+    // Bit indices where sparse value should be stored.
+    const int32_t* sparseIndices;
+    // Number of sparse values.
+    int sparseCount;
+    // Temporary storage to keep bool representation of bits.  Should be at
+    // least totalCount large.
+    bool* bools;
+    // Address of the result bits.  We do not support unaligned result because
+    // different blocks could access the same byte and cause racing condition.
+    uint8_t* result;
+  };
+
+  struct RleTotalLength {
+    // Input data to be summed.
+    const int32_t* input;
+    // Number of input data.
+    int count;
+    // The sum of input data.
+    int64_t* result;
+  };
+
+  struct Rle {
+    // Type of values and result.
+    WaveTypeKind valueType;
+    // Values that will be repeated.
+    const void* values;
+    // Length of each value.
+    const int32_t* lengths;
+    // Number of values and lengths.
+    int count;
+    // Starting address of the result.
+    const void* result;
+  };
+
+  struct MakeScatterIndices {
+    // Input bits.
+    const uint8_t* bits;
+    // Whether set or unset bits should be found in the input.
+    bool findSetBits;
+    // Begin bit position of the input.
+    int begin;
+    // End bit position (exclusive) of the input.
+    int end;
+    // Address of the result indices.
+    int32_t* indices;
+    // If non-null, store the number of indices being written.
+    int32_t* indicesCount;
+  };
+
+  struct RowCountNoFilter {
+    int32_t numRows;
+    BlockStatus* status;
+    int32_t gridStatusSize;
+    bool gridOnly;
+  };
+
+  struct CountBits {
+    const uint8_t* bits;
+    // Number of bits. A count is produced for each run of 'resultStride' bits
+    // fully included in 'numBits'. If numBits is 600 and resultStride is 256
+    // then result[0] is the count of ones in the first 256, then result[1] is
+    // the count of ones in the first 512 and result[2] is unset.
+    int32_t numBits;
+    // 256/512/1024/2048.
+    int32_t resultStride;
+    // One int per warp (blockDim.x/32).
+  };
+
+  struct CompactValues {
+    // Selected row numbers from the source filtered column.
+    int32_t* sourceRows;
+    // Row count for each kBlockSize rows of the source.
+    int32_t* sourceNumRows;
+    /// The rows selected by the last filter. blockStatus has the count.
+    int32_t* finalRows;
+    /// The results produced by the first filtered column.
+    void* source;
+    /// Null flags. nullptr if not nullable.
+    uint8_t* sourceNull;
+  };
+
+  union {
+    Trivial trivial;
+    MainlyConstant mainlyConstant;
+    DictionaryOnBitpack dictionaryOnBitpack;
+    Varint varint;
+    SparseBool sparseBool;
+    RleTotalLength rleTotalLength;
+    Rle rle;
+    MakeScatterIndices makeScatterIndices;
+    RowCountNoFilter rowCountNoFilter;
+    CountBits countBits;
+    CompactValues compact;
+  } data;
+
+  /// Returns the amount of int aligned global memory per TB needed in 'temp'
+  /// for standard size TB.
+  int32_t tempSize() const;
+
+  /// Returns the amount of shared memory for standard size thread block for
+  /// 'step'.
+  int32_t sharedMemorySize() const;
+
+  /// Sets the pushed down filter from ScanSpec of 'reader'. Uses 'stream' to
+  /// setup device-side data like hash tables.
+  void setFilter(ColumnReader* reader, Stream* stream);
+};
+
+struct DecodePrograms {
+  void clear() {
+    programs.clear();
+    result.clear();
+  }
+
+  // Set of decode programs submitted as a unit. Each vector<DecodeStep> is run
+  // on its own thread block. The consecutive DecodeSteps in the same program
+  // are consecutive and the next one can depend on a previous one.
+  std::vector<std::vector<std::unique_ptr<GpuDecode>>> programs;
+
+  /// Unified or device memory   buffer where steps in 'programs' write results
+  /// for the host. Decode results stay on device, only control information like
+  /// filter result counts or length sums come to the host via this buffer. If
+  /// nullptr, no data transfer is scheduled. 'result' should be nullptr if all
+  /// steps are unconditional, like simple decoding.
+  ResultBuffer result;
+};
+
+void launchDecode(
+    const DecodePrograms& programs,
+    LaunchParams& params,
+    Stream* stream);
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/decode/GpuDecoder-inl.cuh b/velox/experimental/wave/dwio/decode/GpuDecoder-inl.cuh
new file mode 100644
index 0000000000000..492a66ee34455
--- /dev/null
+++ b/velox/experimental/wave/dwio/decode/GpuDecoder-inl.cuh
@@ -0,0 +1,1171 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cub/cub.cuh> // @manual
+#include "velox/experimental/wave/common/Bits.cuh"
+
+namespace facebook::velox::wave {
+
+namespace detail {
+template <typename T>
+__device__ void decodeTrivial(GpuDecode::Trivial& op) {
+  auto address = reinterpret_cast<uint64_t>(op.input);
+  constexpr uint64_t kMask = sizeof(T) - 1;
+  int32_t lowShift = (address & kMask) * 8;
+  int32_t highShift = sizeof(T) * 8 - lowShift;
+  auto source = reinterpret_cast<T*>(address & ~kMask);
+  int32_t end = op.end;
+  T* result = reinterpret_cast<T*>(op.result);
+  auto scatter = op.scatter;
+  if (scatter) {
+    for (auto i = op.begin + threadIdx.x; i < end; i += blockDim.x) {
+      result[scatter[i]] =
+          (source[i] >> lowShift) | (source[i + 1] << highShift);
+    }
+  } else {
+    for (auto i = op.begin + threadIdx.x; i < end; i += blockDim.x) {
+      result[i] = (source[i] >> lowShift) | (source[i + 1] << highShift);
+    }
+  }
+}
+
+__device__ inline void decodeTrivial(GpuDecode& plan) {
+  auto& op = plan.data.trivial;
+  switch (op.dataType) {
+    case WaveTypeKind::TINYINT:
+      decodeTrivial<uint8_t>(op);
+      break;
+    case WaveTypeKind::SMALLINT:
+      decodeTrivial<uint16_t>(op);
+      break;
+    case WaveTypeKind::INTEGER:
+    case WaveTypeKind::REAL:
+      decodeTrivial<uint32_t>(op);
+      break;
+    case WaveTypeKind::BIGINT:
+    case WaveTypeKind::DOUBLE:
+      decodeTrivial<uint64_t>(op);
+      break;
+    default:
+      if (threadIdx.x == 0) {
+        printf("ERROR: Unsupported data type for Trivial\n");
+      }
+  }
+}
+
+enum class ResultOp { kDict, kBaseline, kDictScatter, kBaselineScatter };
+
+template <typename T, ResultOp op>
+__device__ void storeResult(
+    int32_t i,
+    uint64_t bitfield,
+    T baseline,
+    const T* dict,
+    const int32_t* scatter,
+    T* result) {
+  if constexpr (op == ResultOp::kBaseline) {
+    result[i] = bitfield + baseline;
+  } else if constexpr (op == ResultOp::kBaselineScatter) {
+    result[scatter[i]] = bitfield + baseline;
+  } else if constexpr (op == ResultOp::kDict) {
+    result[i] = dict[bitfield + baseline];
+  } else if constexpr (op == ResultOp::kDictScatter) {
+    result[scatter[i]] = dict[bitfield + baseline];
+  }
+}
+
+#if 1
+template <typename T, ResultOp resultOp>
+__device__ void decodeDictionaryOnBitpack(GpuDecode::DictionaryOnBitpack& op) {
+  int32_t i = op.begin + threadIdx.x;
+  auto end = op.end;
+  auto address = reinterpret_cast<uint64_t>(op.indices);
+  int32_t alignOffset = (address & 7) * 8;
+  address &= ~7UL;
+  auto words = reinterpret_cast<uint64_t*>(address);
+  const T* dict = reinterpret_cast<const T*>(op.alphabet);
+  auto scatter = op.scatter;
+  auto baseline = op.baseline;
+  auto bitWidth = op.bitWidth;
+  uint64_t mask = (1LU << bitWidth) - 1;
+  auto result = reinterpret_cast<T*>(op.result);
+  for (; i < end; i += blockDim.x) {
+    int32_t bitIndex = i * bitWidth + alignOffset;
+    int32_t wordIndex = bitIndex >> 6;
+    int32_t bit = bitIndex & 63;
+    uint64_t word = words[wordIndex];
+    uint64_t index = word >> bit;
+    if (bitWidth + bit > 64) {
+      uint64_t nextWord = words[wordIndex + 1];
+      index |= nextWord << (64 - bit);
+    }
+    index &= mask;
+    storeResult<T, resultOp>(i, index, baseline, dict, scatter, result);
+  }
+}
+#elif 0
+
+template <typename T, ResultOp resultOp>
+__device__ void decodeDictionaryOnBitpack(GpuDecode::DictionaryOnBitpack& op) {
+  int32_t i = op.begin + threadIdx.x;
+  __shared__ int32_t end;
+  __shared__ uint64_t address;
+  __shared__ int32_t alignOffset;
+  __shared__ uint64_t* words;
+  __shared__ const T* dict;
+  __shared__ const int32_t* scatter;
+  __shared__ int64_t baseline;
+  __shared__ uint8_t bitWidth;
+  __shared__ uint64_t mask;
+  __shared__ T* result;
+
+  if (threadIdx.x == 0) {
+    end = op.end;
+    address = reinterpret_cast<uint64_t>(op.indices);
+    alignOffset = (address & 7) * 8;
+    address &= ~7UL;
+    words = reinterpret_cast<uint64_t*>(address);
+    dict = reinterpret_cast<const T*>(op.alphabet);
+    scatter = op.scatter;
+    baseline = op.baseline;
+    bitWidth = op.bitWidth;
+    mask = (1LU << bitWidth) - 1;
+    result = reinterpret_cast<T*>(op.result);
+  }
+  __syncthreads();
+  for (; i < end; i += blockDim.x) {
+    int32_t bitIndex = i * bitWidth + alignOffset;
+    int32_t wordIndex = bitIndex >> 6;
+    int32_t bit = bitIndex & 63;
+    uint64_t word = words[wordIndex];
+    uint64_t index = word >> bit;
+    if (bitWidth + bit > 64) {
+      uint64_t nextWord = words[wordIndex + 1];
+      index |= nextWord << (64 - bit);
+    }
+    index &= mask;
+    storeResult<T, resultOp>(i, index, baseline, dict, scatter, result);
+  }
+}
+#elif 0
+
+template <typename T, ResultOp resultOp>
+__device__ void decodeDictionaryOnBitpack(GpuDecode::DictionaryOnBitpack& op) {
+  int32_t i = op.begin + threadIdx.x;
+  auto address = reinterpret_cast<uint64_t>(op.indices);
+  int32_t alignOffset = (address & 7) * 8;
+  address &= ~7UL;
+  auto words = reinterpret_cast<uint64_t*>(address);
+  const T* dict = reinterpret_cast<const T*>(op.alphabet);
+  auto scatter = op.scatter;
+  auto baseline = op.baseline;
+  auto bitWidth = op.bitWidth;
+  uint64_t mask = (1LU << bitWidth) - 1;
+  for (; i < op.end; i += blockDim.x) {
+    int32_t bitIndex = i * op.bitWidth + alignOffset;
+    int32_t wordIndex = bitIndex >> 6;
+    int32_t bit = bitIndex & 63;
+    uint64_t word = words[wordIndex];
+    uint64_t index = word >> bit;
+    if (bitWidth + bit > 64) {
+      uint64_t nextWord = words[wordIndex + 1];
+      index |= nextWord << (64 - bit);
+    }
+    index &= mask;
+    storeResult<T, resultOp>(
+        i, index, baseline, dict, scatter, reinterpret_cast<T*>(op.result));
+  }
+}
+#elif 0
+template <typename T, ResultOp resultOp>
+__device__ void decodeDictionaryOnBitpack(GpuDecode::DictionaryOnBitpack& op) {
+  int32_t i = op.begin + threadIdx.x;
+  auto scatter = op.scatter;
+  auto baseline = op.baseline;
+  for (; i < op.end; i += blockDim.x) {
+    uint64_t index;
+    if (op.bitWidth <= 32) {
+      index = loadBits32(op.indices, i * op.bitWidth, op.bitWidth);
+    } else {
+      index = loadBits64(op.indices, i * op.bitWidth, op.bitWidth);
+    }
+    storeResult<T, resultOp>(
+        i,
+        index,
+        baseline,
+        reinterpret_cast<const T*>(op.alphabet),
+        scatter,
+        reinterpret_cast<T*>(op.result));
+  }
+}
+#endif
+
+template <typename T>
+__device__ void decodeDictionaryOnBitpack(GpuDecode::DictionaryOnBitpack& op) {
+  if (!op.scatter) {
+    if (op.alphabet) {
+      decodeDictionaryOnBitpack<T, ResultOp::kDict>(op);
+    } else {
+      decodeDictionaryOnBitpack<T, ResultOp::kBaseline>(op);
+    }
+  } else {
+    if (op.alphabet) {
+      decodeDictionaryOnBitpack<T, ResultOp::kDictScatter>(op);
+    } else {
+      decodeDictionaryOnBitpack<T, ResultOp::kBaselineScatter>(op);
+    }
+  }
+}
+
+__device__ inline void decodeDictionaryOnBitpack(GpuDecode& plan) {
+  auto& op = plan.data.dictionaryOnBitpack;
+  switch (op.dataType) {
+    case WaveTypeKind::TINYINT:
+      decodeDictionaryOnBitpack<int8_t>(op);
+      break;
+    case WaveTypeKind::SMALLINT:
+      decodeDictionaryOnBitpack<int16_t>(op);
+      break;
+    case WaveTypeKind::INTEGER:
+      decodeDictionaryOnBitpack<int32_t>(op);
+      break;
+    case WaveTypeKind::BIGINT:
+      decodeDictionaryOnBitpack<int64_t>(op);
+      break;
+    default:
+      if (threadIdx.x == 0) {
+        assert(false);
+        printf("ERROR: Unsupported data type for DictionaryOnBitpack\n");
+      }
+  }
+}
+
+template <int32_t kBlockSize, typename T>
+__device__ int scatterIndices(
+    const T* values,
+    T value,
+    int32_t begin,
+    int32_t end,
+    int32_t* indices) {
+  typedef cub::BlockScan<int32_t, kBlockSize> BlockScan;
+  extern __shared__ char smem[];
+  auto* scanStorage = reinterpret_cast<typename BlockScan::TempStorage*>(smem);
+  int numMatch;
+  bool match;
+  int32_t k = 0;
+  for (auto j = begin; j < end; j += kBlockSize) {
+    auto jt = j + threadIdx.x;
+    numMatch = match = (jt < end && values[jt] == value);
+    int subtotal;
+    BlockScan(*scanStorage).ExclusiveSum(numMatch, numMatch, subtotal);
+    __syncthreads();
+    if (match) {
+      indices[k + numMatch] = jt - begin;
+    }
+    k += subtotal;
+  }
+  return k;
+}
+
+template <int kBlockSize>
+__device__ int scatterIndices(
+    const uint8_t* bits,
+    bool value,
+    int32_t begin,
+    int32_t end,
+    int32_t* indices) {
+  typedef cub::BlockScan<int32_t, kBlockSize> BlockScan;
+  extern __shared__ char smem[];
+  auto* scanStorage = reinterpret_cast<typename BlockScan::TempStorage*>(smem);
+  constexpr int kPerThread = 8;
+  int numMatch[kPerThread];
+  bool match[kPerThread];
+  int32_t k = 0;
+  constexpr auto kBitsPerBlock = kBlockSize * kPerThread;
+  for (auto j = begin; j < end; j += kBitsPerBlock) {
+    auto jt = j + threadIdx.x * kPerThread;
+    for (auto i = 0; i < kPerThread; ++i) {
+      numMatch[i] = match[i] = jt + i < end && isSet(bits, jt + i) == value;
+    }
+    int subtotal;
+    BlockScan(*scanStorage).ExclusiveSum(numMatch, numMatch, subtotal);
+    __syncthreads();
+    for (auto i = 0; i < kPerThread; ++i) {
+      if (match[i]) {
+        indices[k + numMatch[i]] = jt + i - begin;
+      }
+    }
+    k += subtotal;
+  }
+  return k;
+}
+
+__device__ inline void
+bitpackBools(const bool* input, int count, uint8_t* out) {
+  int nbytes = count / 8;
+  for (auto i = threadIdx.x; i < nbytes; i += blockDim.x) {
+    uint8_t value = 0;
+    for (int j = 0; j < 8; ++j) {
+      value |= input[8 * i + j] << j;
+    }
+    out[i] = value;
+  }
+  if (threadIdx.x == 0 && count % 8 != 0) {
+    auto extra = count % 8;
+    for (int j = count - extra; j < count; ++j) {
+      setBit(out, j, input[j]);
+    }
+  }
+}
+
+__device__ inline void decodeSparseBool(GpuDecode::SparseBool& op) {
+  for (int i = threadIdx.x; i < op.totalCount; i += blockDim.x) {
+    op.bools[i] = !op.sparseValue;
+  }
+  __syncthreads();
+  for (int i = threadIdx.x; i < op.sparseCount; i += blockDim.x) {
+    op.bools[op.sparseIndices[i]] = op.sparseValue;
+  }
+  __syncthreads();
+  bitpackBools(op.bools, op.totalCount, op.result);
+}
+
+__device__ inline uint32_t readVarint32(const char** pos) {
+  uint32_t value = (**pos) & 127;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= (**pos & 127) << 7;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= (**pos & 127) << 14;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= (**pos & 127) << 21;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= (*((*pos)++) & 127) << 28;
+  return value;
+}
+
+__device__ inline uint64_t readVarint64(const char** pos) {
+  uint64_t value = (**pos) & 127;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= (**pos & 127) << 7;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= (**pos & 127) << 14;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= (**pos & 127) << 21;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= static_cast<uint64_t>(**pos & 127) << 28;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= static_cast<uint64_t>(**pos & 127) << 35;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= static_cast<uint64_t>(**pos & 127) << 42;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= static_cast<uint64_t>(**pos & 127) << 49;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= static_cast<uint64_t>(**pos & 127) << 56;
+  if (!(*((*pos)++) & 128)) {
+    return value;
+  }
+  value |= static_cast<uint64_t>(*((*pos)++) & 127) << 63;
+  return value;
+}
+
+template <int kBlockSize, typename T>
+__device__ int decodeVarint(
+    const char* input,
+    int size,
+    bool* ends,
+    int32_t* endPos,
+    T* output) {
+  for (auto i = threadIdx.x; i < size; i += blockDim.x) {
+    ends[i] = ~input[i] & 0x80;
+  }
+  auto numOut = scatterIndices<kBlockSize>(ends, true, 0, size, endPos);
+  for (auto i = threadIdx.x; i < numOut; i += blockDim.x) {
+    auto* pos = input + (i == 0 ? 0 : (endPos[i - 1] + 1));
+    if constexpr (sizeof(T) == 4) {
+      output[i] = readVarint32(&pos);
+    } else {
+      static_assert(sizeof(T) == 8);
+      output[i] = readVarint64(&pos);
+    }
+  }
+  return numOut;
+}
+
+template <int kBlockSize>
+__device__ void decodeVarint(GpuDecode& plan) {
+  auto& op = plan.data.varint;
+  int resultSize;
+  switch (op.resultType) {
+    case WaveTypeKind::INTEGER:
+      resultSize = decodeVarint<kBlockSize, uint32_t>(
+          op.input, op.size, op.ends, op.endPos, (uint32_t*)op.result);
+      break;
+    case WaveTypeKind::BIGINT:
+      resultSize = decodeVarint<kBlockSize, uint64_t>(
+          op.input, op.size, op.ends, op.endPos, (uint64_t*)op.result);
+      break;
+    default:
+      if (threadIdx.x == 0) {
+        printf("ERROR: Unsupported result type for varint decoder\n");
+        assert(false);
+      }
+  }
+  if (threadIdx.x == 0) {
+    op.resultSize = resultSize;
+  }
+}
+
+template <int kBlockSize, typename T>
+__device__ void decodeMainlyConstant(GpuDecode::MainlyConstant& op) {
+  auto otherCount = scatterIndices<kBlockSize>(
+      op.isCommon, false, 0, op.count, op.otherIndices);
+  auto commonValue = *(const T*)op.commonValue;
+  auto* otherValues = (const T*)op.otherValues;
+  auto* result = (T*)op.result;
+  for (int i = threadIdx.x; i < op.count; i += blockDim.x) {
+    result[i] = commonValue;
+  }
+  __syncthreads();
+  for (int i = threadIdx.x; i < otherCount; i += blockDim.x) {
+    result[op.otherIndices[i]] = otherValues[i];
+  }
+  if (threadIdx.x == 0 && op.otherCount) {
+    *op.otherCount = otherCount;
+  }
+}
+
+template <int kBlockSize>
+__device__ void decodeMainlyConstant(GpuDecode& plan) {
+  auto& op = plan.data.mainlyConstant;
+  switch (op.dataType) {
+    case WaveTypeKind::TINYINT:
+      decodeMainlyConstant<kBlockSize, uint8_t>(op);
+      break;
+    case WaveTypeKind::SMALLINT:
+      decodeMainlyConstant<kBlockSize, uint16_t>(op);
+      break;
+    case WaveTypeKind::INTEGER:
+    case WaveTypeKind::REAL:
+      decodeMainlyConstant<kBlockSize, uint32_t>(op);
+      break;
+    case WaveTypeKind::BIGINT:
+    case WaveTypeKind::DOUBLE:
+      decodeMainlyConstant<kBlockSize, uint64_t>(op);
+      break;
+    default:
+      if (threadIdx.x == 0) {
+        printf("ERROR: Unsupported data type for MainlyConstant\n");
+        assert(false);
+      }
+  }
+}
+
+template <int kBlockSize, typename T, typename U>
+__device__ T sum(const U* values, int size) {
+  using Reduce = cub::BlockReduce<T, kBlockSize>;
+  extern __shared__ char smem[];
+  auto* reduceStorage = reinterpret_cast<typename Reduce::TempStorage*>(smem);
+  T total = 0;
+  for (int i = 0; i < size; i += kBlockSize) {
+    auto numValid = min(size - i, kBlockSize);
+    T value;
+    if (threadIdx.x < numValid) {
+      value = values[i + threadIdx.x];
+    }
+    total += Reduce(*reduceStorage).Sum(value, numValid);
+    __syncthreads();
+  }
+  return total;
+}
+
+template <int kBlockSize>
+__device__ void rleTotalLength(GpuDecode::RleTotalLength& op) {
+  auto result = sum<kBlockSize, int64_t>(op.input, op.count);
+  if (threadIdx.x == 0) {
+    *op.result = result;
+  }
+}
+
+template <typename T>
+__device__ int upperBound(const T* data, int size, T target) {
+  int lo = 0, hi = size;
+  while (lo < hi) {
+    int i = (lo + hi) / 2;
+    if (data[i] <= target) {
+      lo = i + 1;
+    } else {
+      hi = i;
+    }
+  }
+  return lo;
+}
+
+template <int kBlockSize, typename T>
+__device__ void decodeRle(GpuDecode::Rle& op) {
+  using BlockScan = cub::BlockScan<int32_t, kBlockSize>;
+  extern __shared__ char smem[];
+  auto* scanStorage = reinterpret_cast<typename BlockScan::TempStorage*>(smem);
+
+  static_assert(sizeof(*scanStorage) >= sizeof(int32_t) * kBlockSize);
+  auto* offsets = (int32_t*)scanStorage;
+  auto* values = (const T*)op.values;
+  auto* result = (T*)op.result;
+  int total = 0;
+  for (int i = 0; i < op.count; i += blockDim.x) {
+    auto ti = threadIdx.x + i;
+    auto len = ti < op.count ? op.lengths[ti] : 0;
+    int32_t offset, subtotal;
+    __syncthreads();
+    BlockScan(*scanStorage).InclusiveSum(len, offset, subtotal);
+    __syncthreads();
+    offsets[threadIdx.x] = offset;
+    __syncthreads();
+    for (int j = threadIdx.x; j < subtotal; j += blockDim.x) {
+      result[total + j] = values[i + upperBound(offsets, blockDim.x, j)];
+    }
+    total += subtotal;
+  }
+}
+
+template <int kBlockSize>
+__device__ void decodeRle(GpuDecode& plan) {
+  auto& op = plan.data.rle;
+  switch (op.valueType) {
+    case WaveTypeKind::TINYINT:
+      decodeRle<kBlockSize, uint8_t>(op);
+      break;
+    case WaveTypeKind::SMALLINT:
+      decodeRle<kBlockSize, uint16_t>(op);
+      break;
+    case WaveTypeKind::INTEGER:
+    case WaveTypeKind::REAL:
+      decodeRle<kBlockSize, uint32_t>(op);
+      break;
+    case WaveTypeKind::BIGINT:
+    case WaveTypeKind::DOUBLE:
+      decodeRle<kBlockSize, uint64_t>(op);
+      break;
+    default:
+      if (threadIdx.x == 0) {
+        printf("ERROR: Unsupported value type for Rle\n");
+        assert(false);
+      }
+  }
+}
+
+template <int kBlockSize>
+__device__ void makeScatterIndices(GpuDecode::MakeScatterIndices& op) {
+  auto indicesCount = scatterIndices<kBlockSize>(
+      op.bits, op.findSetBits, op.begin, op.end, op.indices);
+  if (threadIdx.x == 0 && op.indicesCount) {
+    *op.indicesCount = indicesCount;
+  }
+}
+
+template <typename T, DecodeStep kEncoding>
+inline __device__ T randomAccessDecode(const GpuDecode* op, int32_t idx) {
+  switch (kEncoding) {
+    case DecodeStep::kDictionaryOnBitpack: {
+      const auto& d = op->data.dictionaryOnBitpack;
+      auto width = d.bitWidth;
+      if (sizeof(T) == 4 || width <= 32) {
+        return loadBits32(d.indices, idx * width, width) + d.baseline;
+      } else {
+        return loadBits64(d.indices, idx * width, width) + d.baseline;
+      }
+    }
+  }
+}
+
+template <typename T, WaveFilterKind kFilterKind, bool kFixedFilter = true>
+__device__ bool testFilter(const GpuDecode* op, T data) {
+  switch (kFixedFilter ? kFilterKind : op->filterKind) {
+    case WaveFilterKind::kBigintRange: {
+      long2 bounds = *reinterpret_cast<const long2*>(&op->filter);
+      return data >= bounds.x && data <= bounds.y;
+    }
+    default:
+      return true;
+  }
+}
+
+template <
+    typename T,
+    int32_t kBlockSize,
+    bool kHasFilter,
+    bool kHasResult,
+    bool kHasNulls>
+__device__ void makeResult(
+    const GpuDecode* op,
+    T data,
+    int32_t row,
+    bool filterPass,
+    int32_t nthLoop,
+    uint8_t nullFlag,
+    int32_t* temp) {
+  auto base = nthLoop * kBlockSize;
+  if (kHasFilter) {
+    int32_t resultIdx = exclusiveSum<int16_t, kBlockSize>(
+        static_cast<int16_t>(filterPass),
+        nullptr,
+        reinterpret_cast<int16_t*>(temp));
+    if (threadIdx.x == kBlockSize - 1) {
+      op->blockStatus[nthLoop].numRows = resultIdx + filterPass;
+      if (op->filterRowCount) {
+        op->filterRowCount[nthLoop] = resultIdx + filterPass;
+      }
+    }
+    if (filterPass) {
+      resultIdx += base;
+      op->resultRows[resultIdx] = row;
+      if (kHasResult) {
+        reinterpret_cast<T*>(op->result)[resultIdx] = data;
+        if (kHasNulls && op->resultNulls) {
+          op->resultNulls[resultIdx] = nullFlag;
+        }
+      }
+    }
+  } else {
+    if (!filterPass) {
+      // In the no filter case, filterPass is false for lanes that are after the
+      // last row.
+      return;
+    }
+    auto resultIdx = base + threadIdx.x;
+    reinterpret_cast<T*>(op->result)[resultIdx] = data;
+    if (kHasNulls && op->resultNulls) {
+      op->resultNulls[resultIdx] = nullFlag;
+    }
+  }
+}
+
+template <
+    typename T,
+    int32_t kBlockSize,
+    DecodeStep kEncoding,
+    WaveFilterKind kFilterKind,
+    bool kHasResult>
+__device__ void decodeSelective(GpuDecode* op) {
+  int32_t nthLoop = 0;
+  switch (op->nullMode) {
+    case NullMode::kDenseNonNull: {
+      if (kFilterKind == WaveFilterKind::kAlwaysTrue) {
+        //  No-filter case with everything inlined.
+        auto base = op->baseRow;
+        auto i = threadIdx.x;
+        auto& d = op->data.dictionaryOnBitpack;
+        auto end = op->maxRow - op->baseRow;
+        auto address = reinterpret_cast<uint64_t>(d.indices);
+        int32_t alignOffset = (address & 7) * 8;
+        address &= ~7UL;
+        auto words = reinterpret_cast<uint64_t*>(address);
+        auto baseline = d.baseline;
+        auto bitWidth = d.bitWidth;
+        uint64_t mask = (1LU << bitWidth) - 1;
+        auto* result = reinterpret_cast<T*>(op->result);
+        for (; i < end; i += blockDim.x) {
+          int32_t bitIndex = (i + base) * bitWidth + alignOffset;
+          int32_t wordIndex = bitIndex >> 6;
+          if (threadIdx.x < 3) {
+            asm volatile("prefetch.global.L1 [%0];" ::"l"(
+                &words[wordIndex + 48 + threadIdx.x * 4]));
+          }
+          int32_t bit = bitIndex & 63;
+          uint64_t word = words[wordIndex];
+          uint64_t index = word >> bit;
+          if (bitWidth + bit > 64) {
+            uint64_t nextWord = words[wordIndex + 1];
+            index |= nextWord << (64 - bit);
+          }
+          index &= mask;
+          result[i] = index + baseline;
+        }
+      } else {
+        do {
+          int32_t row = threadIdx.x + op->baseRow + nthLoop * kBlockSize;
+          bool filterPass = false;
+          T data{};
+          if (row < op->maxRow) {
+            data = randomAccessDecode<T, kEncoding>(op, row);
+            filterPass = testFilter<T, kFilterKind, true>(op, data);
+          }
+          makeResult<
+              T,
+              kBlockSize,
+              kFilterKind != WaveFilterKind::kAlwaysTrue,
+              kHasResult,
+              false>(op, data, row, filterPass, nthLoop, kNotNull, op->temp);
+        } while (++nthLoop < op->numRowsPerThread);
+      }
+      break;
+    }
+    case NullMode::kSparseNonNull:
+      do {
+        int32_t numRows = op->blockStatus[nthLoop].numRows;
+        bool filterPass = false;
+        T data{};
+        int32_t row = 0;
+        if (threadIdx.x < numRows) {
+          row = op->rows[threadIdx.x + nthLoop * kBlockSize];
+          data = randomAccessDecode<T, kEncoding>(op, row);
+          filterPass = testFilter<T, kFilterKind, true>(op, data);
+        }
+        makeResult<
+            T,
+            kBlockSize,
+            kFilterKind != WaveFilterKind::kAlwaysTrue,
+            kHasResult,
+            false>(op, data, row, filterPass, nthLoop, kNotNull, op->temp);
+      } while (++nthLoop < op->numRowsPerThread);
+      break;
+    case NullMode::kDenseNullable: {
+      int32_t maxRow = op->maxRow;
+      int32_t dataIdx = 0;
+      auto* state = reinterpret_cast<NonNullState*>(op->temp);
+      if (threadIdx.x == 0) {
+        state->nonNullsBelow = op->nthBlock == 0
+            ? 0
+            : op->nonNullBases
+                  [op->nthBlock *
+                       (op->gridNumRowsPerThread / (1024 / kBlockSize)) -
+                   1];
+        state->nonNullsBelowRow =
+            op->gridNumRowsPerThread * op->nthBlock * kBlockSize;
+      }
+      __syncthreads();
+      do {
+        int32_t base = op->baseRow + nthLoop * kBlockSize;
+        bool filterPass = false;
+        int32_t dataIdx;
+        T data{};
+        if (base < maxRow) {
+          dataIdx = nonNullIndex256(
+              op->nulls, base, min(kBlockSize, maxRow - base), state);
+          filterPass = base + threadIdx.x < maxRow;
+          if (filterPass) {
+            if (dataIdx == -1) {
+              if (!op->nullsAllowed) {
+                filterPass = false;
+              }
+            } else {
+              data = randomAccessDecode<T, kEncoding>(op, dataIdx);
+              filterPass = testFilter<T, kFilterKind, true>(op, data);
+            }
+          }
+        }
+        makeResult<
+            T,
+            kBlockSize,
+            kFilterKind != WaveFilterKind::kAlwaysTrue,
+            kHasResult,
+            true>(
+            op,
+            data,
+            base + threadIdx.x,
+            filterPass,
+            nthLoop,
+            dataIdx == -1 ? kNull : kNotNull,
+            state->temp);
+      } while (++nthLoop < op->numRowsPerThread);
+      break;
+    }
+    case NullMode::kSparseNullable: {
+      auto state = reinterpret_cast<NonNullState*>(op->temp);
+      if (threadIdx.x == 0) {
+        state->nonNullsBelow = op->nthBlock == 0
+            ? 0
+            : op->nonNullBases
+                  [op->nthBlock *
+                       (op->gridNumRowsPerThread / (1024 / kBlockSize)) -
+                   1];
+        state->nonNullsBelowRow =
+            op->gridNumRowsPerThread * op->nthBlock * kBlockSize;
+      }
+      __syncthreads();
+      do {
+        int32_t base = kBlockSize * nthLoop;
+        int32_t numRows = op->blockStatus[nthLoop].numRows;
+        if (numRows == 0) {
+        } else {
+          bool filterPass = true;
+          T data{};
+          int32_t dataIdx =
+              nonNullIndex256Sparse(op->nulls, op->rows + base, numRows, state);
+          filterPass = threadIdx.x < numRows;
+          if (filterPass) {
+            if (dataIdx == -1) {
+              if (!op->nullsAllowed) {
+                filterPass = false;
+              }
+            } else {
+              data = randomAccessDecode<T, kEncoding>(op, dataIdx);
+              filterPass =
+                  testFilter<T, WaveFilterKind::kAlwaysTrue, false>(op, data);
+            }
+          }
+          makeResult<
+              T,
+              kBlockSize,
+              kFilterKind != WaveFilterKind::kAlwaysTrue,
+              kHasResult,
+              true>(
+              op,
+              data,
+              op->rows[base + threadIdx.x],
+              filterPass,
+              nthLoop,
+              dataIdx == -1 ? kNull : kNotNull,
+              state->temp);
+        }
+      } while (++nthLoop < op->numRowsPerThread);
+      break;
+    }
+  }
+  __syncthreads();
+}
+
+// Returns the position of 'target' in 'data' to 'data + size'. Not finding the
+// value is an error and the values are expected to be unique.
+inline __device__ int
+findRow(const int32_t* rows, int32_t size, int32_t row, GpuDecode* op) {
+  int lo = 0, hi = size;
+  while (lo < hi) {
+    int i = (lo + hi) / 2;
+    if (rows[i] == row) {
+      return i;
+    }
+    if (rows[i] < row) {
+      lo = i + 1;
+    } else {
+      hi = i;
+    }
+  }
+  printf("Expecting to find  row %d in findRow() size %d %p\n", row, size, op);
+  assert(false);
+}
+
+template <typename T, int32_t kBlockSize>
+__device__ void compactValues(GpuDecode* op) {
+  auto& compact = op->data.compact;
+  int32_t nthLoop = 0;
+  do {
+    auto numRows = op->blockStatus[nthLoop].numRows;
+    T sourceValue;
+    uint8_t sourceNull;
+    int32_t base;
+    if (threadIdx.x < numRows) {
+      base = nthLoop * kBlockSize;
+      auto row = compact.finalRows[base + threadIdx.x];
+      auto numSource = compact.sourceNumRows[nthLoop];
+      auto sourceRow = findRow(compact.sourceRows + base, numSource, row, op);
+      sourceValue =
+          reinterpret_cast<const T*>(compact.source)[base + sourceRow];
+      if (compact.sourceNull) {
+        sourceNull = compact.sourceNull[base + sourceRow];
+      }
+    }
+    __syncthreads();
+    if (threadIdx.x < numRows) {
+      reinterpret_cast<T*>(compact.source)[base + threadIdx.x] = sourceValue;
+      if (compact.sourceNull) {
+        compact.sourceNull[base + threadIdx.x] = sourceNull;
+      }
+    }
+  } while (++nthLoop < op->numRowsPerThread);
+}
+
+template <int kBlockSize>
+__device__ void setRowCountNoFilter(GpuDecode::RowCountNoFilter& op) {
+  auto numRows = op.numRows;
+  auto* status = op.status;
+  auto numBlocks = roundUp(numRows, kBlockSize) / kBlockSize;
+  if (op.gridStatusSize > 0) {
+    auto grid = roundUp(
+        reinterpret_cast<uintptr_t>(status) + numBlocks * sizeof(BlockStatus),
+        8);
+    int64_t* statusEnd = reinterpret_cast<int64_t*>(grid + op.gridStatusSize);
+    auto ptr = reinterpret_cast<int64_t*>(grid) + threadIdx.x;
+    for (; ptr < statusEnd; ptr += kBlockSize) {
+      *ptr = 0;
+    }
+    if (op.gridOnly) {
+      return;
+    }
+  }
+  for (auto base = 0; base < numBlocks; base += kBlockSize) {
+    auto idx = threadIdx.x + base;
+    if (idx < numBlocks) {
+      // Every thread writes a row count for kBlockSize rows.  all row
+      // counts except the last are kBlockSize. The next kernel sets
+      // lane status to active for rows below rowCount and to inactive
+      // for others.
+      status[idx].numRows =
+          idx < numBlocks - 1 ? kBlockSize : numRows - idx * kBlockSize;
+    }
+  }
+}
+
+template <int32_t kBlockSize, int32_t kWidth>
+inline __device__ void reduceCase(
+    int32_t cnt,
+    int32_t nthLoop,
+    int32_t numResults,
+    int32_t* results,
+    int32_t* temp) {
+  static_assert(kWidth == 4 || kWidth == 8 || kWidth == 16 || kWidth == 32);
+  using Reduce = cub::WarpReduce<int32_t, kWidth>;
+  auto sum =
+      Reduce(*reinterpret_cast<typename Reduce::TempStorage*>(temp)).Sum(cnt);
+  constexpr int32_t kResultsPerLoop = kBlockSize / kWidth;
+
+  if ((threadIdx.x & (kWidth - 1)) == 0) {
+    temp[threadIdx.x / kWidth] = sum;
+  }
+  __syncthreads();
+  // Add up the temps.
+  sum = threadIdx.x < kResultsPerLoop ? temp[threadIdx.x] : 0;
+  if (threadIdx.x == 0 && nthLoop > 0) {
+    sum += results[nthLoop * kResultsPerLoop - 1];
+  }
+  auto result = inclusiveSum<int32_t, kBlockSize / kWidth>(
+      threadIdx.x < kResultsPerLoop ? sum : 0, nullptr, temp);
+  auto resultIdx = threadIdx.x + nthLoop * kResultsPerLoop;
+  if (resultIdx < numResults) {
+    results[resultIdx] = result;
+  }
+}
+
+template <int kBlockSize>
+__device__ void countBits(GpuDecode& step) {
+  auto& op = step.data.countBits;
+  auto numBits = op.numBits;
+  bool aligned = (reinterpret_cast<uintptr_t>(op.bits) & 7) == 0;
+  int32_t numWords = roundUp(op.numBits, 64) / 64;
+  int32_t numResults = (numBits - 1) / op.resultStride;
+  auto* bits = reinterpret_cast<const uint64_t*>(op.bits);
+  for (auto i = 0; i < numBits; i += 64 * kBlockSize) {
+    int32_t idx = threadIdx.x + (i / 64);
+    int32_t cnt = 0;
+    if (idx < numWords) {
+      if (aligned) {
+        cnt = __popcll(bits[idx]);
+      } else {
+        cnt = __popcll(unalignedLoad64(bits + idx));
+      }
+    }
+    switch (op.resultStride) {
+      case 256:
+        reduceCase<kBlockSize, 4>(
+            cnt,
+            i / (64 * kBlockSize),
+            numResults,
+            reinterpret_cast<int32_t*>(step.result),
+            step.temp);
+        break;
+      case 512:
+        reduceCase<kBlockSize, 8>(
+            cnt,
+            i / (64 * kBlockSize),
+            numResults,
+            reinterpret_cast<int32_t*>(step.result),
+            step.temp);
+        break;
+      case 1024:
+        reduceCase<kBlockSize, 16>(
+            cnt,
+            i / (64 * kBlockSize),
+            numResults,
+            reinterpret_cast<int32_t*>(step.result),
+            step.temp);
+        break;
+      case 2048:
+        reduceCase<kBlockSize, 32>(
+            cnt,
+            i / (64 * kBlockSize),
+            numResults,
+            reinterpret_cast<int32_t*>(step.result),
+            step.temp);
+        break;
+    }
+  }
+}
+
+template <typename T, int32_t kBlockSize, DecodeStep kEncoding>
+__device__ void selectiveFilter(GpuDecode* op) {
+  switch (op->filterKind) {
+    case WaveFilterKind::kAlwaysTrue:
+      decodeSelective<
+          T,
+          kBlockSize,
+          kEncoding,
+          WaveFilterKind::kAlwaysTrue,
+          true>(op);
+      break;
+    case WaveFilterKind::kBigintRange:
+      decodeSelective<
+          T,
+          kBlockSize,
+          kEncoding,
+          WaveFilterKind::kBigintRange,
+          true>(op);
+      break;
+    default:
+      assert(false);
+  }
+}
+
+template <typename T, int32_t kBlockSize>
+__device__ void selectiveSwitch(GpuDecode* op) {
+  if (op->encoding == DecodeStep::kDictionaryOnBitpack) {
+    selectiveFilter<T, kBlockSize, DecodeStep::kDictionaryOnBitpack>(op);
+  } else {
+    assert(false);
+  }
+}
+
+template <int32_t kBlockSize>
+__device__ void decodeSwitch(GpuDecode& op) {
+  switch (op.step) {
+    case DecodeStep::kSelective32:
+      selectiveSwitch<int32_t, kBlockSize>(&op);
+      break;
+    case DecodeStep::kSelective64:
+      selectiveSwitch<int64_t, kBlockSize>(&op);
+      break;
+    case DecodeStep::kCompact64:
+      detail::compactValues<int64_t, kBlockSize>(&op);
+      break;
+    case DecodeStep::kCountBits:
+      countBits<kBlockSize>(op);
+      break;
+    case DecodeStep::kTrivial:
+      detail::decodeTrivial(op);
+      break;
+    case DecodeStep::kDictionaryOnBitpack:
+      detail::decodeDictionaryOnBitpack(op);
+      break;
+    case DecodeStep::kSparseBool:
+      detail::decodeSparseBool(op.data.sparseBool);
+      break;
+    case DecodeStep::kMainlyConstant:
+      detail::decodeMainlyConstant<kBlockSize>(op);
+      break;
+    case DecodeStep::kVarint:
+      detail::decodeVarint<kBlockSize>(op);
+      break;
+    case DecodeStep::kRleTotalLength:
+      detail::rleTotalLength<kBlockSize>(op.data.rleTotalLength);
+      break;
+    case DecodeStep::kRle:
+      detail::decodeRle<kBlockSize>(op);
+      break;
+    case DecodeStep::kMakeScatterIndices:
+      detail::makeScatterIndices<kBlockSize>(op.data.makeScatterIndices);
+      break;
+    case DecodeStep::kRowCountNoFilter:
+      detail::setRowCountNoFilter<kBlockSize>(op.data.rowCountNoFilter);
+      break;
+    default:
+      if (threadIdx.x == 0) {
+        printf(
+            "ERROR: Unsupported DecodeStep %d\n",
+            static_cast<int32_t>(op.step));
+      }
+  }
+}
+
+template <int kBlockSize>
+__global__ void decodeGlobal(GpuDecode* plan) {
+  detail::decodeSwitch<kBlockSize>(plan[blockIdx.x]);
+  __syncthreads();
+}
+
+template <int32_t kBlockSize>
+int32_t sharedMemorySizeForDecode(DecodeStep step) {
+  using Reduce32 = cub::BlockReduce<int32_t, kBlockSize>;
+  using BlockScan32 = cub::BlockScan<int32_t, kBlockSize>;
+  switch (step) {
+    case DecodeStep::kSelective32:
+    case DecodeStep::kSelective64:
+    case DecodeStep::kCompact64:
+    case DecodeStep::kTrivial:
+    case DecodeStep::kDictionaryOnBitpack:
+    case DecodeStep::kCountBits:
+    case DecodeStep::kSparseBool:
+    case DecodeStep::kRowCountNoFilter:
+      return 0;
+      break;
+
+    case DecodeStep::kRleTotalLength:
+      return sizeof(typename Reduce32::TempStorage);
+    case DecodeStep::kMainlyConstant:
+    case DecodeStep::kRleBool:
+    case DecodeStep::kRle:
+    case DecodeStep::kVarint:
+    case DecodeStep::kMakeScatterIndices:
+    case DecodeStep::kLengthToOffset:
+      return sizeof(typename BlockScan32::TempStorage);
+    default:
+      assert(false); // Undefined.
+      return 0;
+  }
+}
+
+} // namespace detail
+
+template <int kBlockSize>
+void decodeGlobal(GpuDecode* plan, int numBlocks, cudaStream_t stream) {
+  int32_t sharedSize = 0;
+  for (auto i = 0; i < numBlocks; ++i) {
+    sharedSize = std::max(
+        sharedSize,
+        detail::sharedMemorySizeForDecode<kBlockSize>(plan[i].step));
+  }
+  if (sharedSize > 0) {
+    sharedSize += 15; // allow align at 16.
+  }
+
+  detail::decodeGlobal<kBlockSize>
+      <<<numBlocks, kBlockSize, sharedSize, stream>>>(plan);
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/decode/GpuDecoder.cu b/velox/experimental/wave/dwio/decode/GpuDecoder.cu
new file mode 100644
index 0000000000000..7d54fcf59cd11
--- /dev/null
+++ b/velox/experimental/wave/dwio/decode/GpuDecoder.cu
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/common/Buffer.h"
+#include "velox/experimental/wave/common/Cuda.h"
+#include "velox/experimental/wave/common/CudaUtil.cuh"
+#include "velox/experimental/wave/common/GpuArena.h"
+#include "velox/experimental/wave/dwio/decode/GpuDecoder.cuh"
+
+namespace facebook::velox::wave {
+
+int32_t GpuDecode::tempSize() const {
+  // 1 int32 per lane as an upper limit.
+  return std::max<int32_t>(kBlockSize * sizeof(int32_t), sizeof(NonNullState));
+}
+
+int32_t GpuDecode::sharedMemorySize() const {
+  return detail::sharedMemorySizeForDecode<kBlockSize>(step);
+}
+
+/// Describes multiple sequences of decode ops. Each TB executes a sequence of
+/// decode steps. The data area starts with a range of instruction numbers for
+/// each thread block. The first TB runs from 0 to ends[0]. The nth runs from
+/// ends[nth-1] to ends[nth]. After gridDim.x ends, we round to an 8 aligned
+/// offset and have an array of GpuDecodes.]
+struct alignas(16) GpuDecodeParams {
+  // If need to represent more than this many ops, use a dynamically allocated
+  // external array in 'external'.
+  static constexpr int32_t kMaxInlineOps = 19;
+
+  // Pointer to standalone description of work. If nullptr, the description of
+  // work fits inline in 'this'.
+  GpuDecodeParams* external{nullptr};
+  void* padding;
+  // The end of each decode program. The first starts at 0. The end is
+  // ends[blockIdx.x].
+  int32_t ends
+      [kMaxInlineOps * (sizeof(GpuDecode) + sizeof(int32_t)) /
+       sizeof(int32_t)] = {};
+};
+
+void __global__ __launch_bounds__(1024)
+    decodeKernel(GpuDecodeParams inlineParams) {
+  __shared__ GpuDecodeParams* params;
+  __shared__ int32_t programStart;
+  __shared__ int32_t programEnd;
+  __shared__ GpuDecode* ops;
+  if (threadIdx.x == 0) {
+    params = inlineParams.external ? inlineParams.external : &inlineParams;
+    programStart = blockIdx.x == 0 ? 0 : params->ends[blockIdx.x - 1];
+    programEnd = params->ends[blockIdx.x];
+    ops =
+        reinterpret_cast<GpuDecode*>(&params->ends[0] + roundUp(gridDim.x, 4));
+  }
+  __syncthreads();
+  for (auto i = programStart; i < programEnd; ++i) {
+    detail::decodeSwitch<kBlockSize>(ops[i]);
+  }
+  __syncthreads();
+}
+
+void launchDecode(
+    const DecodePrograms& programs,
+    LaunchParams& launchParams,
+    Stream* stream) {
+  int32_t numBlocks = programs.programs.size();
+  int32_t numOps = 0;
+  bool allSingle = true;
+  int32_t shared = 0;
+  for (auto& program : programs.programs) {
+    int numSteps = program.size();
+    ;
+    if (numSteps != 1) {
+      allSingle = false;
+    }
+    numOps += numSteps;
+    for (auto& step : program) {
+      shared = std::max(
+          shared, detail::sharedMemorySizeForDecode<kBlockSize>(step->step));
+    }
+  }
+  if (shared > 0) {
+    shared += 15; // allow align at 16.
+  }
+  GpuDecodeParams localParams;
+  GpuDecodeParams* params = &localParams;
+  char* host = nullptr;
+  char* device = nullptr;
+  if (numOps > GpuDecodeParams::kMaxInlineOps || allSingle) {
+    auto pair = launchParams.setup(
+        (numOps + 1) * (sizeof(GpuDecode) + sizeof(int32_t)) + 16);
+    host = pair.first;
+    device = pair.second;
+    uintptr_t aligned = roundUp(reinterpret_cast<uintptr_t>(host), 16);
+    params = reinterpret_cast<GpuDecodeParams*>(aligned);
+  }
+  int32_t end = programs.programs[0].size();
+  GpuDecode* decodes =
+      reinterpret_cast<GpuDecode*>(&params->ends[0] + roundUp(numBlocks, 4));
+  uintptr_t decodeOffset = reinterpret_cast<char*>(decodes) - host;
+  int32_t fill = 0;
+  for (auto i = 0; i < programs.programs.size(); ++i) {
+    params->ends[i] =
+        (i == 0 ? 0 : params->ends[i - 1]) + programs.programs[i].size();
+    for (auto& op : programs.programs[i]) {
+      decodes[fill++] = *op;
+    }
+  }
+  if (allSingle) {
+    launchParams.transfer(*stream);
+    detail::decodeGlobal<kBlockSize>
+        <<<numBlocks, kBlockSize, shared, stream->stream()->stream>>>(
+            reinterpret_cast<GpuDecode*>(device + decodeOffset));
+    CUDA_CHECK(cudaGetLastError());
+    programs.result.transfer(*stream);
+    return;
+  }
+  if (launchParams.device) {
+    localParams.external = reinterpret_cast<GpuDecodeParams*>(device);
+    launchParams.transfer(*stream);
+  }
+
+  decodeKernel<<<numBlocks, kBlockSize, shared, stream->stream()->stream>>>(
+      localParams);
+  CUDA_CHECK(cudaGetLastError());
+  programs.result.transfer(*stream);
+}
+
+REGISTER_KERNEL("decode", decodeKernel);
+namespace {
+static bool decSingles_reg = registerKernel(
+    "decodeSingle",
+    reinterpret_cast<const void*>(detail::decodeGlobal<kBlockSize>));
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/decode/GpuDecoder.cuh b/velox/experimental/wave/dwio/decode/GpuDecoder.cuh
new file mode 100644
index 0000000000000..7ed68d9404163
--- /dev/null
+++ b/velox/experimental/wave/dwio/decode/GpuDecoder.cuh
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cuda_runtime.h>
+#include "velox/experimental/wave/common/CudaUtil.cuh"
+#include "velox/experimental/wave/dwio/decode/DecodeStep.h"
+
+namespace facebook::velox::wave {
+
+/// Returns the amount of shared memory per thread block for 'op'
+int32_t sharedMemorySize(GpuDecode& op);
+
+/// Decode plans passed, one thread block will be running on each plan.
+__device__ void decodeNoSharedMemory(GpuDecode* plan);
+
+/// Decode plans passed, this version requires shared memory thus the
+/// concurrency level will be lower.
+template <int kBlockSize>
+__device__ void decodeWithSharedMemory(GpuDecode* plan);
+
+/// Decode plans, initiated from host code.
+template <int kBlockSize>
+void decodeGlobal(GpuDecode* plan, int numBlocks, cudaStream_t stream = 0);
+
+__host__ __device__ inline bool isSet(const uint8_t* bits, int32_t idx) {
+  return bits[idx / 8] & (1 << (idx & 7));
+}
+
+__host__ __device__ inline void setBit(uint8_t* bits, uint32_t idx) {
+  bits[idx / 8] |= (1 << (idx % 8));
+}
+
+__host__ __device__ inline void clearBit(uint8_t* bits, uint32_t idx) {
+  static constexpr uint8_t kZeroBitmasks[] = {
+      static_cast<uint8_t>(~(1 << 0)),
+      static_cast<uint8_t>(~(1 << 1)),
+      static_cast<uint8_t>(~(1 << 2)),
+      static_cast<uint8_t>(~(1 << 3)),
+      static_cast<uint8_t>(~(1 << 4)),
+      static_cast<uint8_t>(~(1 << 5)),
+      static_cast<uint8_t>(~(1 << 6)),
+      static_cast<uint8_t>(~(1 << 7)),
+  };
+  bits[idx / 8] &= kZeroBitmasks[idx % 8];
+}
+
+__host__ __device__ inline void
+setBit(uint8_t* bits, uint32_t idx, bool value) {
+  value ? setBit(bits, idx) : clearBit(bits, idx);
+}
+
+} // namespace facebook::velox::wave
+
+#include "velox/experimental/wave/dwio/decode/GpuDecoder-inl.cuh"
diff --git a/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt b/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..6adeeb6268aad
--- /dev/null
+++ b/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt
@@ -0,0 +1,30 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_wave_decode_test GpuDecoderTest.cu)
+
+add_test(velox_wave_decode_test velox_wave_decode_test)
+
+target_link_libraries(
+  velox_wave_decode_test
+  velox_wave_decode
+  velox_wave_common
+  velox_memory
+  velox_time
+  velox_exception
+  GTest::gtest
+  GTest::gtest_main
+  gflags::gflags
+  glog::glog
+  Folly::folly)
diff --git a/velox/experimental/wave/dwio/decode/tests/GpuDecoderTest.cu b/velox/experimental/wave/dwio/decode/tests/GpuDecoderTest.cu
new file mode 100644
index 0000000000000..940f3f638d90e
--- /dev/null
+++ b/velox/experimental/wave/dwio/decode/tests/GpuDecoderTest.cu
@@ -0,0 +1,763 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <fmt/format.h>
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include "velox/experimental/gpu/Common.h"
+#include "velox/experimental/wave/dwio/decode/GpuDecoder.cuh"
+
+DEFINE_int32(device_id, 0, "");
+DEFINE_bool(benchmark, false, "");
+DEFINE_bool(print_kernels, false, "Print register and smem usage");
+DEFINE_bool(use_selective, false, "Use selective path for test");
+
+namespace facebook::velox::wave {
+namespace {
+
+using namespace facebook::velox;
+
+// define to use the flexible call path wiht multiple ops per TB
+#define USE_PROGRAM_API
+#define USE_SEL_BITPACK true
+
+// Returns the number of bytes the "values" will occupy after varint encoding.
+uint64_t bulkVarintSize(const uint64_t* values, int count) {
+  constexpr uint8_t kLookupSizeTable64[64] = {
+      10, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7,
+      6,  6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 3,
+      3,  3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1};
+  uint64_t size = 0;
+  for (int i = 0; i < count; ++i) {
+    size += kLookupSizeTable64[__builtin_clzll(values[i] | 1ULL)];
+  }
+  return size;
+}
+
+template <typename T>
+void writeVarint(T val, char** pos) noexcept {
+  while (val >= 128) {
+    *((*pos)++) = 0x80 | (val & 0x7f);
+    val >>= 7;
+  }
+  *((*pos)++) = val;
+}
+
+template <typename T>
+gpu::CudaPtr<T[]> allocate(int n) {
+  T* ptr;
+  CUDA_CHECK_FATAL(cudaMallocManaged(&ptr, n * sizeof(T)));
+  return gpu::CudaPtr<T[]>(ptr);
+}
+
+template <typename T>
+void fillRandom(T* values, int32_t numValues) {
+  uint64_t seed = 0xafbe1647deba879LU;
+  for (auto i = 0; i < numValues; ++i) {
+    values[i] = seed;
+    seed = (seed * 0x5def1) ^ (seed >> 21);
+  }
+}
+
+// Generate random bits with probability "p" being true and "1 - p" being false.
+void fillRandomBits(uint8_t* bits, double p, int numValues) {
+  for (int i = 0; i < numValues; ++i) {
+    setBit(bits, i, (double)rand() / RAND_MAX < p);
+  }
+}
+
+template <typename T>
+inline T* addBytes(T* ptr, int bytes) {
+  return reinterpret_cast<T*>(reinterpret_cast<char*>(ptr) + bytes);
+}
+
+template <typename T>
+inline const T* addBytes(const T* ptr, int bytes) {
+  return reinterpret_cast<const T*>(reinterpret_cast<const char*>(ptr) + bytes);
+}
+
+void prefetchToDevice(void* ptr, size_t size) {
+  CUDA_CHECK_FATAL(cudaMemPrefetchAsync(ptr, size, FLAGS_device_id, nullptr));
+}
+
+template <typename T>
+void makeBitpackDict(
+    int32_t bitWidth,
+    int32_t numValues,
+    gpu::CudaPtr<char[]>& cudaPtr,
+    T*& dict,
+    uint64_t*& bits,
+    T*& result,
+    int32_t** scatter,
+    bool bitsOnly,
+    BlockStatus*& blockStatus,
+    int32_t numBlocks,
+    int32_t blockSize) {
+  int64_t dictBytes = bitsOnly ? 0 : sizeof(T) << bitWidth;
+  int64_t bitBytes = (roundUp(numValues * bitWidth, 128) / 8) + 16;
+  int64_t resultBytes = numValues * sizeof(T);
+  int scatterBytes =
+      scatter ? roundUp(numValues * sizeof(int32_t), sizeof(T)) : 0;
+  int32_t statusBytes = sizeof(BlockStatus) * numBlocks;
+  if (scatterBytes) {
+    resultBytes += resultBytes / 2;
+  }
+  cudaPtr = allocate<char>(
+      dictBytes + bitBytes + scatterBytes + resultBytes + statusBytes);
+  T* memory = (T*)cudaPtr.get();
+
+  dict = bitsOnly ? nullptr : memory;
+
+  static int sequence = 1;
+  ++sequence;
+  for (auto i = 0; i < dictBytes / sizeof(T); ++i) {
+    dict[i] = (10 + sequence) * i;
+  }
+
+  // The bit packed data does not start at a word boundary.
+  bits = addBytes(reinterpret_cast<uint64_t*>(memory), dictBytes + 1);
+  fillRandom(bits, bitBytes / 8);
+
+  if (scatterBytes) {
+    // Make a scatter vector that makes gaps in the result sequence.
+    *scatter =
+        addBytes(reinterpret_cast<int32_t*>(memory), dictBytes + bitBytes);
+    for (auto i = 0; i < numValues; ++i) {
+      (*scatter)[i] = i + i / 4;
+    }
+  }
+  result = addBytes(
+      reinterpret_cast<T*>(memory), dictBytes + bitBytes + scatterBytes);
+  blockStatus =
+      reinterpret_cast<BlockStatus*>(addBytes(result, numValues * sizeof(T)));
+  for (auto i = 0; i < numBlocks; ++i) {
+    blockStatus[i].numRows =
+        i < numBlocks - 1 ? blockSize : numValues - (i * blockSize);
+  }
+  prefetchToDevice(
+      memory, dictBytes + bitBytes + scatterBytes + resultBytes + statusBytes);
+}
+
+class GpuDecoderTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    if (int device; cudaGetDevice(&device) != cudaSuccess) {
+      GTEST_SKIP() << "No CUDA detected, skipping all tests";
+    }
+    arena_ = std::make_unique<GpuArena>(100000000, getAllocator(getDevice()));
+    CUDA_CHECK_FATAL(cudaEventCreate(&startEvent_));
+    CUDA_CHECK_FATAL(cudaEventCreate(&stopEvent_));
+  }
+
+  void TearDown() override {
+    CUDA_CHECK_FATAL(cudaEventDestroy(startEvent_));
+    CUDA_CHECK_FATAL(cudaEventDestroy(stopEvent_));
+  }
+
+  void testCase(
+      const std::string& label,
+      std::function<void()> func,
+      int64_t bytes,
+      int32_t numReps) {
+    func();
+    CUDA_CHECK_FATAL(cudaGetLastError());
+    if (!FLAGS_benchmark) {
+      CUDA_CHECK_FATAL(cudaDeviceSynchronize());
+      return;
+    }
+    CUDA_CHECK_FATAL(cudaEventRecord(startEvent_, 0));
+    for (auto count = 0; count < numReps; ++count) {
+      func();
+    }
+    CUDA_CHECK_FATAL(cudaEventRecord(stopEvent_, 0));
+    CUDA_CHECK_FATAL(cudaEventSynchronize(stopEvent_));
+    float ms;
+    CUDA_CHECK_FATAL(cudaEventElapsedTime(&ms, startEvent_, stopEvent_));
+    printf(
+        "%s %.2f (%d at %.2f us each)\n",
+        label.c_str(),
+        bytes * numReps * 1e-6 / ms,
+        numReps,
+        ms * 1000 / numReps);
+  }
+
+  template <typename T, int32_t kBlockSize>
+  void testCopyPlan(int64_t numValues, int numBlocks, bool useScatter) {
+    auto source = allocate<T>(numValues);
+    auto result = allocate<T>(numValues * 4 / 3);
+    gpu::CudaPtr<int32_t[]> scatter;
+    if (useScatter) {
+      scatter = allocate<int32_t>(numValues);
+      for (auto i = 0; i < numValues; ++i) {
+        scatter[i] = i * 5 / 4;
+      }
+    }
+    fillRandom(source.get(), numValues);
+    result[numValues] = 0xdeadbeef;
+    int valuesPerOp = roundUp(numValues / numBlocks, kBlockSize);
+    int numOps = roundUp(numValues, valuesPerOp) / valuesPerOp;
+    auto ops = allocate<GpuDecode>(numOps);
+    for (auto i = 0; i < numOps; ++i) {
+      int32_t begin = i * valuesPerOp;
+      ops[i].step = DecodeStep::kTrivial;
+      auto& op = ops[i].data.trivial;
+      op.dataType = WaveTypeTrait<T>::typeKind;
+      op.begin = begin;
+      op.end = std::min<int32_t>(numValues, (i + 1) * valuesPerOp);
+      op.result = result.get();
+      op.input = source.get();
+      op.scatter = scatter.get();
+    }
+    testCase(
+        fmt::format(
+            "copy plan {} numValues={} useScatter={}",
+            sizeof(T) * 8,
+            numValues,
+            useScatter),
+        [&] { decodeGlobal<kBlockSize>(ops.get(), numOps); },
+        numValues * sizeof(T),
+        10);
+    if (!scatter) {
+      EXPECT_EQ(0xdeadbeef, result[numValues]);
+    }
+    for (auto i = 0; i < numValues; ++i) {
+      ASSERT_EQ(source[i], result[scatter ? scatter[i] : i]);
+    }
+  }
+
+  template <typename T, int kBlockSize>
+  void dictTestPlan(
+      int32_t bitWidth,
+      int64_t numValues,
+      int numBlocks,
+      bool useScatter,
+      bool bitsOnly = false,
+      bool useSelective = false) {
+    gpu::CudaPtr<char[]> ptr;
+    T* dict;
+    uint64_t* bits;
+    T* result;
+    int32_t* scatter = nullptr;
+    BlockStatus* blockStatus;
+    makeBitpackDict(
+        bitWidth,
+        numValues,
+        ptr,
+        dict,
+        bits,
+        result,
+        useScatter ? &scatter : nullptr,
+        bitsOnly,
+        blockStatus,
+        roundUp(numValues, kBlockSize) / kBlockSize,
+        kBlockSize);
+    result[numValues] = 0xdeadbeef;
+    int valuesPerOp = roundUp(numValues / numBlocks, kBlockSize);
+    int numOps = roundUp(numValues, valuesPerOp) / valuesPerOp;
+    auto valuesPerThread = valuesPerOp / kBlockSize;
+    auto ops = allocate<GpuDecode>(numOps);
+    for (auto i = 0; i < numOps; ++i) {
+      int32_t begin = i * valuesPerOp;
+      ops[i].step = useSelective ? (sizeof(T) == 8 ? DecodeStep::kSelective64
+                                                   : DecodeStep::kSelective32)
+                                 : DecodeStep::kDictionaryOnBitpack;
+      ops[i].encoding = DecodeStep::kDictionaryOnBitpack;
+      ops[i].dataType = WaveTypeTrait<T>::typeKind;
+      ops[i].nullMode = NullMode::kDenseNonNull;
+      ops[i].nthBlock = i;
+      ops[i].numRowsPerThread = i == numOps - 1
+          ? roundUp(numValues - (valuesPerOp * i), kBlockSize) / kBlockSize
+          : valuesPerThread;
+      ops[i].baseRow = i * valuesPerOp;
+      ops[i].maxRow = std::min<int32_t>((i + 1) * valuesPerOp, numValues);
+      ops[i].result = reinterpret_cast<T*>(result) + i * valuesPerOp;
+
+      ops[i].blockStatus = blockStatus + (i * valuesPerThread);
+      auto& op = ops[i].data.dictionaryOnBitpack;
+      op.begin = begin;
+      op.end = std::min<int>(numValues, (i + 1) * valuesPerOp);
+      op.result = result;
+      op.bitWidth = bitWidth;
+      op.indices = bits;
+      op.alphabet = dict;
+      op.scatter = scatter;
+      op.baseline = 0;
+      op.dataType = WaveTypeTrait<T>::typeKind;
+    }
+    testCase(
+        fmt::format(
+            "bitpack dictplan {} -> {} numValues={} useScatter={}",
+            bitWidth,
+            sizeof(T) * 8,
+            numValues,
+            useScatter),
+        [&] {
+#ifdef USE_PROGRAM_API
+          callViaPrograms(ops.get(), numOps);
+#else
+          decodeGlobal<kBlockSize>(ops.get(), numOps);
+#endif
+        },
+        numValues * sizeof(T),
+        10);
+    if (!scatter) {
+      EXPECT_EQ(0xdeadbeef, result[numValues]);
+    }
+    auto mask = (1uL << bitWidth) - 1;
+    for (auto i = 0; i < numValues; ++i) {
+      int32_t bit = i * bitWidth;
+      uint64_t word = *addBytes(bits, bit / 8);
+      uint64_t index = (word >> (bit & 7)) & mask;
+      T expected = bitsOnly ? index : dict[index];
+      ASSERT_EQ(result[scatter ? scatter[i] : i], expected) << i;
+    }
+  }
+
+  template <int kBlockSize>
+  void testSparseBool(int numValues, int numBlocks) {
+    auto expected = allocate<uint8_t>((numValues + 7) / 8);
+    fillRandomBits(expected.get(), 0.99, numValues);
+    auto indices = allocate<int32_t>(numValues);
+    int indicesCount = 0;
+    for (int i = 0; i < numValues; ++i) {
+      if (!isSet(expected.get(), i)) {
+        indices[indicesCount++] = i;
+      }
+    }
+    auto bools = allocate<bool>(numValues * numBlocks);
+    auto resultSize = (numValues + 7) / 8;
+    auto result = allocate<uint8_t>(resultSize * numBlocks);
+    auto ops = allocate<GpuDecode>(numBlocks);
+    for (int i = 0; i < numBlocks; ++i) {
+      ops[i].step = DecodeStep::kSparseBool;
+      auto& op = ops[i].data.sparseBool;
+      op.totalCount = numValues;
+      op.sparseValue = false;
+      op.sparseIndices = indices.get();
+      op.sparseCount = indicesCount;
+      op.bools = bools.get() + i * numValues;
+      op.result = result.get() + i * resultSize;
+    }
+    testCase(
+        "",
+        [&] { decodeGlobal<kBlockSize>(ops.get(), numBlocks); },
+        resultSize * numBlocks,
+        3);
+    for (int j = 0; j < numBlocks; ++j) {
+      auto* actual = ops[j].data.sparseBool.result;
+      for (int i = 0; i < numValues; ++i) {
+        ASSERT_EQ(isSet(actual, i), isSet(expected.get(), i)) << i;
+      }
+    }
+  }
+
+  template <int kBlockSize>
+  void testVarint(int numValues, int numBlocks) {
+    std::vector<uint64_t> expected(numValues);
+    fillRandom(expected.data(), numValues);
+    for (int i = 0; i < numValues; ++i) {
+      if (i % 100 != 0) {
+        expected[i] %= 128;
+      }
+    }
+    auto inputSize = bulkVarintSize(expected.data(), numValues);
+    auto input = allocate<char>(inputSize);
+    auto* rawInput = input.get();
+    for (int i = 0; i < numValues; ++i) {
+      writeVarint(expected[i], &rawInput);
+    }
+    auto ends = allocate<bool>(inputSize * numBlocks);
+    auto endPos = allocate<int32_t>(inputSize * numBlocks);
+    auto result = allocate<uint64_t>(inputSize * numBlocks);
+    auto ops = allocate<GpuDecode>(numBlocks);
+    for (int i = 0; i < numBlocks; ++i) {
+      ops[i].step = DecodeStep::kVarint;
+      auto& op = ops[i].data.varint;
+      op.input = input.get();
+      op.size = inputSize;
+      op.ends = ends.get() + i * inputSize;
+      op.endPos = endPos.get() + i * inputSize;
+      op.resultType = WaveTypeKind::BIGINT;
+      op.result = result.get() + i * inputSize;
+    }
+    testCase(
+        "",
+        [&] { decodeGlobal<kBlockSize>(ops.get(), numBlocks); },
+        numValues * sizeof(uint64_t) * numBlocks,
+        3);
+    for (int j = 0; j < numBlocks; ++j) {
+      auto& op = ops[j].data.varint;
+      ASSERT_EQ(op.resultSize, numValues);
+      for (int i = 0; i < numValues; ++i) {
+        ASSERT_EQ(reinterpret_cast<const uint64_t*>(op.result)[i], expected[i]);
+      }
+    }
+  }
+
+  template <typename T, int kBlockSize>
+  void testMainlyConstant(int numValues, int numBlocks) {
+    auto isCommon = allocate<uint8_t>((numValues + 7) / 8);
+    fillRandomBits(isCommon.get(), 0.99, numValues);
+    auto values = allocate<T>(numValues + 1);
+    fillRandom(values.get(), numValues + 1);
+    auto otherIndices = allocate<int32_t>(numValues * numBlocks);
+    auto result = allocate<T>(numValues * numBlocks);
+    auto otherCounts = allocate<int32_t>(numBlocks);
+    auto ops = allocate<GpuDecode>(numBlocks);
+    for (int i = 0; i < numBlocks; ++i) {
+      ops[i].step = DecodeStep::kMainlyConstant;
+      auto& op = ops[i].data.mainlyConstant;
+      op.dataType = WaveTypeTrait<T>::typeKind;
+      op.count = numValues;
+      op.commonValue = &values[numValues];
+      op.otherValues = values.get();
+      op.isCommon = isCommon.get();
+      op.otherIndices = otherIndices.get() + i * numValues;
+      op.result = result.get() + i * numValues;
+      op.otherCount = otherCounts.get() + i;
+    }
+    testCase(
+        "",
+        [&] { decodeGlobal<kBlockSize>(ops.get(), numBlocks); },
+        numValues * numBlocks * sizeof(T),
+        3);
+    for (int k = 0; k < numBlocks; ++k) {
+      auto& op = ops[k].data.mainlyConstant;
+      auto* result = (const T*)op.result;
+      int j = 0;
+      for (int i = 0; i < numValues; ++i) {
+        if (isSet(isCommon.get(), i)) {
+          ASSERT_EQ(result[i], values[numValues]);
+        } else {
+          ASSERT_EQ(result[i], values[j++]);
+        }
+      }
+      ASSERT_EQ(*op.otherCount, j);
+    }
+  }
+
+  template <int kBlockSize>
+  void testRleTotalLength(int numValues, int numBlocks) {
+    auto values = allocate<int32_t>(numValues);
+    fillRandom(values.get(), numValues);
+    int valuesPerOp = (numValues + numBlocks - 1) / numBlocks;
+    auto ops = allocate<GpuDecode>(numBlocks);
+    auto lengths = allocate<int64_t>(numBlocks);
+    for (auto i = 0; i < numBlocks; ++i) {
+      ops[i].step = DecodeStep::kRleTotalLength;
+      auto& op = ops[i].data.rleTotalLength;
+      op.input = values.get() + i * valuesPerOp;
+      op.count = std::min(valuesPerOp, numValues - i * valuesPerOp);
+      op.result = &lengths[i];
+    }
+    testCase(
+        "",
+        [&] { decodeGlobal<kBlockSize>(ops.get(), numBlocks); },
+        numValues * sizeof(int32_t),
+        5);
+    for (int i = 0; i < numBlocks; ++i) {
+      auto& op = ops[i].data.rleTotalLength;
+      int64_t expected = 0;
+      for (int j = 0; j < op.count; ++j) {
+        expected += op.input[j];
+      }
+      ASSERT_EQ(*op.result, expected);
+    }
+  }
+
+  template <typename T, int kBlockSize>
+  void testRle(int numValues, int numBlocks) {
+    auto values = allocate<T>(numValues);
+    auto lengths = allocate<int32_t>(numValues);
+    int totalLength = 0;
+    fillRandom(values.get(), numValues);
+    fillRandom(lengths.get(), numValues);
+    for (int i = 0; i < numValues; ++i) {
+      int limit = i % 1000 == 0 ? 1000 : 10;
+      lengths[i] = (uint32_t)lengths[i] % limit;
+      totalLength += lengths[i];
+    }
+    auto ops = allocate<GpuDecode>(numBlocks);
+    auto results = allocate<int64_t>(numBlocks);
+    int valuesPerOp = (numValues + numBlocks - 1) / numBlocks;
+    for (int i = 0; i < numBlocks; ++i) {
+      ops[i].step = DecodeStep::kRleTotalLength;
+      auto& op = ops[i].data.rleTotalLength;
+      op.input = lengths.get() + i * valuesPerOp;
+      op.count = std::min(valuesPerOp, numValues - i * valuesPerOp);
+      op.result = &results[i];
+    }
+    decodeGlobal<kBlockSize>(ops.get(), numBlocks);
+    CUDA_CHECK_FATAL(cudaGetLastError());
+    CUDA_CHECK_FATAL(cudaDeviceSynchronize());
+    auto result = allocate<T>(totalLength);
+    int lengthSofar = 0;
+    for (int i = 0; i < numBlocks; ++i) {
+      int subtotal = *ops[i].data.rleTotalLength.result;
+      ops[i].step = DecodeStep::kRle;
+      auto& op = ops[i].data.rle;
+      op.valueType = WaveTypeTrait<T>::typeKind;
+      op.values = values.get() + i * valuesPerOp;
+      op.lengths = lengths.get() + i * valuesPerOp;
+      op.count = std::min(valuesPerOp, numValues - i * valuesPerOp);
+      op.result = result.get() + lengthSofar;
+      lengthSofar += subtotal;
+    }
+    testCase(
+        "",
+        [&] { decodeGlobal<kBlockSize>(ops.get(), numBlocks); },
+        totalLength * sizeof(T),
+        3);
+    for (int i = 0; i < numBlocks; ++i) {
+    }
+    for (int i = 0, j = 0; i < numValues; ++i) {
+      for (int k = 0; k < lengths[i]; ++k) {
+        ASSERT_EQ(result[j++], values[i]);
+      }
+    }
+  }
+
+  template <int kBlockSize>
+  void testMakeScatterIndices(int numValues, int numBlocks) {
+    auto bits = allocate<uint8_t>((numValues * numBlocks + 7) / 8);
+    fillRandomBits(bits.get(), 0.5, numValues * numBlocks);
+    auto indices = allocate<int32_t>(numValues * numBlocks);
+    auto indicesCounts = allocate<int32_t>(numBlocks);
+    auto ops = allocate<GpuDecode>(numBlocks);
+    for (int i = 0; i < numBlocks; ++i) {
+      ops[i].step = DecodeStep::kMakeScatterIndices;
+      auto& op = ops[i].data.makeScatterIndices;
+      op.bits = bits.get();
+      op.findSetBits = true;
+      op.begin = i * numValues;
+      op.end = op.begin + numValues;
+      op.indices = indices.get() + i * numValues;
+      op.indicesCount = indicesCounts.get() + i;
+    }
+    testCase(
+        "",
+        [&] { decodeGlobal<kBlockSize>(ops.get(), numBlocks); },
+        numValues * numBlocks * sizeof(int32_t),
+        3);
+    for (int i = 0; i < numBlocks; ++i) {
+      auto& op = ops[i].data.makeScatterIndices;
+      int k = 0;
+      for (int j = 0; j < numValues; ++j) {
+        if (isSet(bits.get(), j + i * numValues)) {
+          ASSERT_LT(k, *op.indicesCount);
+          ASSERT_EQ(op.indices[k++], j);
+        }
+      }
+      ASSERT_EQ(k, *op.indicesCount);
+    }
+  }
+
+  void callViaPrograms(GpuDecode* ops, int32_t numOps) {
+    auto stream = std::make_unique<Stream>();
+    LaunchParams params(*arena_);
+    DecodePrograms programs;
+    for (int i = 0; i < numOps; ++i) {
+      programs.programs.emplace_back();
+      programs.programs.back().push_back(std::make_unique<GpuDecode>());
+      auto opPtr = programs.programs.back().front().get();
+      *opPtr = ops[i];
+    }
+    launchDecode(programs, params, stream.get());
+    stream->wait();
+  }
+
+  void testMakeScatterIndicesStream(int numValues, int numBlocks) {
+    auto bits = allocate<uint8_t>((numValues * numBlocks + 7) / 8);
+    fillRandomBits(bits.get(), 0.5, numValues * numBlocks);
+    auto indices = allocate<int32_t>(numValues * numBlocks);
+    auto indicesCounts = allocate<int32_t>(numBlocks);
+    DecodePrograms programs;
+    for (int i = 0; i < numBlocks; ++i) {
+      programs.programs.emplace_back();
+      programs.programs.back().push_back(std::make_unique<GpuDecode>());
+      auto opPtr = programs.programs.back().front().get();
+      opPtr->step = DecodeStep::kMakeScatterIndices;
+      auto& op = opPtr->data.makeScatterIndices;
+      op.bits = bits.get();
+      op.findSetBits = true;
+      op.begin = i * numValues;
+      op.end = op.begin + numValues;
+      op.indices = indices.get() + i * numValues;
+      op.indicesCount = indicesCounts.get() + i;
+    }
+    auto stream = std::make_unique<Stream>();
+    LaunchParams params(*arena_);
+    launchDecode(programs, params, stream.get());
+    stream->wait();
+    for (int i = 0; i < numBlocks; ++i) {
+      auto& op = programs.programs[i].front()->data.makeScatterIndices;
+      int k = 0;
+      for (int j = 0; j < numValues; ++j) {
+        if (isSet(bits.get(), j + i * numValues)) {
+          ASSERT_LT(k, *op.indicesCount);
+          ASSERT_EQ(op.indices[k++], j);
+        }
+      }
+      ASSERT_EQ(k, *op.indicesCount);
+    }
+  }
+
+  void testCountBits(int32_t numWords, int32_t stride) {
+    auto bits = allocate<uint8_t>(numWords * 8);
+    fillRandomBits(bits.get(), 0.5, numWords * 64);
+    auto result = allocate<int32_t>(numWords * 64 / stride);
+    // One int per warp.
+    auto temp = allocate<int32_t>(8);
+    DecodePrograms programs;
+    programs.programs.emplace_back();
+    programs.programs.back().push_back(std::make_unique<GpuDecode>());
+    auto opPtr = programs.programs.back().front().get();
+    opPtr->step = DecodeStep::kCountBits;
+    auto& op = opPtr->data.countBits;
+    opPtr->temp = temp.get();
+    op.bits = bits.get();
+    op.numBits = numWords * 64;
+    op.resultStride = stride;
+    opPtr->result = result.get();
+    auto stream = std::make_unique<Stream>();
+    LaunchParams params(*arena_);
+    launchDecode(programs, params, stream.get());
+    stream->wait();
+    auto numResults = ((numWords * 64) - 1) / stride;
+    auto* rawResult = result.get();
+    int32_t count = 0;
+    for (auto i = 0; i < numResults; ++i) {
+      for (auto j = 0; j < stride / 64; j++) {
+        count += __builtin_popcountl(
+            reinterpret_cast<const uint64_t*>(op.bits)[i * (stride / 64) + j]);
+      }
+      EXPECT_EQ(count, rawResult[i]);
+    }
+  }
+
+ private:
+  std::unique_ptr<GpuArena> arena_;
+
+  cudaEvent_t startEvent_;
+  cudaEvent_t stopEvent_;
+};
+
+TEST_F(GpuDecoderTest, trivial) {
+  testCopyPlan<uint64_t, 128>(40'000'003, 1024, false);
+  testCopyPlan<uint64_t, 128>(40'000'003, 1024, true);
+}
+
+TEST_F(GpuDecoderTest, dictionaryOnBitpack) {
+  dictTestPlan<int32_t, 256>(11, 4'000'037, 1024, false);
+  dictTestPlan<int64_t, 256>(11, 4'000'037, 1024, false);
+  dictTestPlan<int32_t, 256>(11, 40'000'003, 1024, false);
+  dictTestPlan<int64_t, 256>(11, 40'000'003, 1024, false);
+  dictTestPlan<int64_t, 256>(11, 40'000'003, 1024, true);
+}
+
+TEST_F(GpuDecoderTest, bitpack) {
+  bool useSelective = FLAGS_use_selective;
+  dictTestPlan<int32_t, 256>(27, 4000001, 1024, false, true, useSelective);
+  dictTestPlan<int64_t, 256>(28, 4'000'037, 1024, false, true, useSelective);
+  dictTestPlan<int32_t, 256>(26, 40'000'003, 1024, false, true, useSelective);
+  dictTestPlan<int64_t, 256>(30, 40'000'003, 1024, false, true, useSelective);
+  dictTestPlan<int64_t, 256>(47, 40'000'003, 1024, false, true, useSelective);
+  dictTestPlan<int64_t, 256>(22, 40'000'003, 1024, true, true, false);
+}
+
+TEST_F(GpuDecoderTest, sparseBool) {
+  testSparseBool<256>(40013, 1024);
+}
+
+TEST_F(GpuDecoderTest, varint) {
+  testVarint<256>(4001, 1024);
+}
+
+TEST_F(GpuDecoderTest, mainlyConstant) {
+  testMainlyConstant<int64_t, 256>(40013, 1024);
+}
+
+TEST_F(GpuDecoderTest, rleTotalLength) {
+  testRleTotalLength<256>(40'000'003, 1024);
+}
+
+TEST_F(GpuDecoderTest, rle) {
+  testRle<int64_t, 256>(40'000'003, 1024);
+}
+
+TEST_F(GpuDecoderTest, makeScatterIndices) {
+  testMakeScatterIndices<256>(40013, 1024);
+}
+
+TEST_F(GpuDecoderTest, countBits) {
+  testCountBits(10000, 256);
+  testCountBits(20000, 512);
+  testCountBits(30000, 1024);
+  testCountBits(100000, 2048);
+}
+
+TEST_F(GpuDecoderTest, streamApi) {
+  //  One call with few blocks, another with many, to cover inlined and out of
+  //  line params.
+  testMakeScatterIndicesStream(100, 20);
+  testMakeScatterIndicesStream(999, 999);
+}
+} // namespace
+} // namespace facebook::velox::wave
+
+void printFuncAttrs(
+    const std::string& heading,
+    const cudaFuncAttributes& attrs) {
+  std::cout << heading << " sharedSizeBytes=" << attrs.sharedSizeBytes
+            << " constSizeBytes" << attrs.constSizeBytes
+            << " localSizeBytes =" << attrs.localSizeBytes
+            << "maxThreadsPerBlock=" << attrs.maxThreadsPerBlock
+            << " numRegs=" << attrs.numRegs
+            << " maxDynamicSharedSizeBytes=" << attrs.maxDynamicSharedSizeBytes
+            << std::endl;
+}
+using namespace facebook::velox::wave;
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::Init init{&argc, &argv};
+
+  if (int device; cudaGetDevice(&device) != cudaSuccess) {
+    std::cerr << "No CUDA detected, skipping all tests" << std::endl;
+    return 0;
+  }
+
+  cudaDeviceProp prop;
+  CUDA_CHECK_FATAL(cudaGetDeviceProperties(&prop, FLAGS_device_id));
+  printf("Running on device: %s\n", prop.name);
+  CUDA_CHECK_FATAL(cudaSetDevice(FLAGS_device_id));
+  if (FLAGS_print_kernels) {
+    cudaFuncAttributes attrs;
+    CUDA_CHECK_FATAL(cudaFuncGetAttributes(&attrs, detail::decodeGlobal<128>));
+    printFuncAttrs("decode blocksize 128", attrs);
+    CUDA_CHECK_FATAL(cudaFuncGetAttributes(&attrs, detail::decodeGlobal<256>));
+    printFuncAttrs("decode blocksize 256", attrs);
+    CUDA_CHECK_FATAL(cudaFuncGetAttributes(&attrs, detail::decodeGlobal<512>));
+    printFuncAttrs("decode blocksize 512", attrs);
+    CUDA_CHECK_FATAL(cudaFuncGetAttributes(&attrs, detail::decodeGlobal<1024>));
+    printFuncAttrs("decode blocksize 1024", attrs);
+    printFuncAttrs("decode2", attrs);
+
+    printKernels();
+  }
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/experimental/wave/exec/Aggregate.cuh b/velox/experimental/wave/exec/Aggregate.cuh
new file mode 100644
index 0000000000000..835e9ea7e5cc4
--- /dev/null
+++ b/velox/experimental/wave/exec/Aggregate.cuh
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/ExprKernel.h"
+
+#include <gflags/gflags.h>
+#include "velox/experimental/wave/common/Block.cuh"
+#include "velox/experimental/wave/common/CudaUtil.cuh"
+#include "velox/experimental/wave/exec/WaveCore.cuh"
+
+namespace facebook::velox::wave {
+
+inline __device__ void clearReturnState(
+    const IAggregate& agg,
+    WaveShared* shared) {
+  auto* lanes = laneStatus<uint8_t>(shared, agg.status, 0);
+  lanes[threadIdx.x] = 0;
+}
+
+__device__ __forceinline__ void aggregateKernel(
+    const IAggregate& agg,
+    WaveShared* shared,
+    ErrorCode& laneStatus) {
+  auto state =
+      reinterpret_cast<DeviceAggregation*>(shared->states[agg.stateIndex]);
+  char* row = state->singleRow;
+  for (auto i = 0; i < agg.numAggregates; ++i) {
+    auto& acc = agg.aggregates[i];
+    int64_t value = 0;
+    if (laneStatus == ErrorCode::kOk) {
+      operandOrNull(
+          shared->operands, acc.arg1, shared->blockBase, &shared->data, value);
+    }
+    using Reduce = cub::WarpReduce<int64_t>;
+    auto sum =
+        Reduce(*reinterpret_cast<Reduce::TempStorage*>(shared)).Sum(value);
+    if ((threadIdx.x & (kWarpThreads - 1)) == 0) {
+      auto* data = addCast<unsigned long long>(row, acc.accumulatorOffset);
+      atomicAdd(data, static_cast<unsigned long long>(sum));
+    }
+  }
+}
+
+__device__ __forceinline__ void readAggregateKernel(
+    const IAggregate& agg,
+    WaveShared* shared) {
+  if (shared->blockBase > 0) {
+    if (threadIdx.x == 0) {
+      shared->status->numRows = 0;
+    }
+    __syncthreads();
+    return;
+  }
+  if (threadIdx.x == 0) {
+    auto state =
+        reinterpret_cast<DeviceAggregation*>(shared->states[agg.stateIndex]);
+    char* row = state->singleRow;
+    shared->status->numRows = 1;
+    for (auto i = 0; i < agg.numAggregates; ++i) {
+      auto& acc = agg.aggregates[i];
+      flatResult<int64_t>(
+          shared->operands, acc.result, shared->blockBase, &shared->data) =
+          *addCast<int64_t>(row, acc.accumulatorOffset);
+    }
+  }
+  __syncthreads();
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/AggregateFunction.h b/velox/experimental/wave/exec/AggregateFunction.h
index 1d346a885f16a..e73e30be956f5 100644
--- a/velox/experimental/wave/exec/AggregateFunction.h
+++ b/velox/experimental/wave/exec/AggregateFunction.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include "velox/experimental/wave/exec/ErrorCode.h"
 #include "velox/experimental/wave/vector/Operand.h"
 
 namespace facebook::velox::wave::aggregation {
diff --git a/velox/experimental/wave/exec/Aggregation.cpp b/velox/experimental/wave/exec/Aggregation.cpp
index 57d009592c4c8..de2839a1d05ba 100644
--- a/velox/experimental/wave/exec/Aggregation.cpp
+++ b/velox/experimental/wave/exec/Aggregation.cpp
@@ -20,19 +20,19 @@
 #include "velox/experimental/wave/exec/ToWave.h"
 #include "velox/experimental/wave/exec/Vectors.h"
 
-#define KEY_TYPE_DISPATCH(_func, _kindExpr, ...) \
-  [&]() {                                        \
-    auto _kind = (_kindExpr);                    \
-    switch (_kind) {                             \
-      case PhysicalType::kInt32:                 \
-        return _func<int32_t>(__VA_ARGS__);      \
-      case PhysicalType::kInt64:                 \
-        return _func<int64_t>(__VA_ARGS__);      \
-      case PhysicalType::kString:                \
-        return _func<StringView>(__VA_ARGS__);   \
-      default:                                   \
-        VELOX_UNSUPPORTED("{}", _kind);          \
-    };                                           \
+#define KEY_TYPE_DISPATCH(_func, _kindExpr, ...)              \
+  [&]() {                                                     \
+    auto _kind = (_kindExpr);                                 \
+    switch (_kind) {                                          \
+      case PhysicalType::kInt32:                              \
+        return _func<int32_t>(__VA_ARGS__);                   \
+      case PhysicalType::kInt64:                              \
+        return _func<int64_t>(__VA_ARGS__);                   \
+      case PhysicalType::kString:                             \
+        return _func<StringView>(__VA_ARGS__);                \
+      default:                                                \
+        VELOX_UNSUPPORTED("{}", static_cast<int32_t>(_kind)); \
+    };                                                        \
   }()
 
 namespace facebook::velox::wave {
@@ -80,10 +80,10 @@ Aggregation::Aggregation(
     const core::AggregationNode& node,
     const std::shared_ptr<aggregation::AggregateFunctionRegistry>&
         functionRegistry)
-    : WaveOperator(state, node.outputType()),
+    : WaveOperator(state, node.outputType(), node.id()),
       arena_(&state.arena()),
       functionRegistry_(functionRegistry) {
-  VELOX_CHECK_EQ(node.step(), core::AggregationNode::Step::kSingle);
+  VELOX_CHECK(node.step() == core::AggregationNode::Step::kSingle);
   VELOX_CHECK(node.preGroupedKeys().empty());
   auto& inputType = node.sources()[0]->outputType();
   container_ = arena_->allocate<aggregation::GroupsContainer>(
@@ -279,15 +279,15 @@ void Aggregation::flush(bool noMoreInput) {
   flushDone_.record(*flushStream_);
 }
 
-int32_t Aggregation::canAdvance() {
+AdvanceResult Aggregation::canAdvance(WaveStream& stream) {
   if (!noMoreInput_ || finished_) {
-    return 0;
+    return {};
   }
   while (!inputs_.empty()) {
     waitFlushDone();
     flush(true);
   }
-  return container_->actualNumGroups;
+  return {.numRows = container_->actualNumGroups};
 }
 
 void Aggregation::schedule(WaveStream& waveStream, int32_t maxRows) {
@@ -299,12 +299,21 @@ void Aggregation::schedule(WaveStream& waveStream, int32_t maxRows) {
       numColumns, exec->deviceData.emplace_back());
   auto* instructions = arena_->allocate<aggregation::Instruction>(
       numColumns, exec->deviceData.emplace_back());
+  auto numBlocks = bits::roundUp(maxRows, kBlockSize) / kBlockSize;
+  auto* rowStatus =
+      arena_->allocate<BlockStatus>(numBlocks, exec->deviceData.emplace_back());
+  bzero(rowStatus, numBlocks * sizeof(BlockStatus));
+  for (auto i = 0; i < numBlocks; ++i) {
+    rowStatus[i].numRows =
+        i == numBlocks - 1 ? maxRows - kBlockSize * i : kBlockSize;
+  }
   auto* status = arena_->allocate<BlockStatus>(
       numColumns, exec->deviceData.emplace_back());
   bzero(status, numColumns * sizeof(BlockStatus));
   exec->operands =
       arena_->allocate<Operand>(numColumns, exec->deviceData.emplace_back());
   exec->outputOperands = outputIds_;
+  exec->firstOutputOperandIdx = 0;
   for (int i = 0; i < numColumns; ++i) {
     auto column = WaveVector::create(outputType_->childAt(i), *arena_);
     column->resize(maxRows, false);
@@ -333,6 +342,9 @@ void Aggregation::schedule(WaveStream& waveStream, int32_t maxRows) {
         int sharedSize = std::max(
             aggregation::ExtractKeys::sharedSize(),
             aggregation::ExtractValues::sharedSize());
+        auto control = std::make_unique<LaunchControl>(id_, maxRows);
+        control->params.status = rowStatus;
+        waveStream.addLaunchControl(id_, std::move(control));
         aggregation::call(
             *stream, numColumns, programs, nullptr, status, sharedSize);
         waveStream.markLaunch(*stream, *exes[0]);
@@ -342,8 +354,4 @@ void Aggregation::schedule(WaveStream& waveStream, int32_t maxRows) {
           << stats_.ingestedRowCount / stats_.gpuTimeMs * 1000 << " rows/s";
 }
 
-vector_size_t Aggregation::outputSize(WaveStream&) const {
-  return container_->actualNumGroups;
-}
-
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/Aggregation.h b/velox/experimental/wave/exec/Aggregation.h
index bd208d7e745bc..e16b3c0b7ce32 100644
--- a/velox/experimental/wave/exec/Aggregation.h
+++ b/velox/experimental/wave/exec/Aggregation.h
@@ -43,7 +43,7 @@ class Aggregation : public WaveOperator {
 
   void flush(bool noMoreInput) override;
 
-  int32_t canAdvance() override;
+  AdvanceResult canAdvance(WaveStream& stream) override;
 
   void schedule(WaveStream& stream, int32_t maxRows) override;
 
@@ -51,8 +51,6 @@ class Aggregation : public WaveOperator {
     return finished_;
   }
 
-  vector_size_t outputSize(WaveStream&) const override;
-
   std::string toString() const override {
     return "Aggregation";
   }
diff --git a/velox/experimental/wave/exec/AggregationInstructions.cu b/velox/experimental/wave/exec/AggregationInstructions.cu
index ac2a341d8f8bb..1827dcb717e44 100644
--- a/velox/experimental/wave/exec/AggregationInstructions.cu
+++ b/velox/experimental/wave/exec/AggregationInstructions.cu
@@ -91,7 +91,7 @@ normalize(BlockInfo* block, void* idMap, Operand* key, int32_t& result) {
   auto* typedIdMap = reinterpret_cast<IdMap<T>*>(idMap);
   auto id = typedIdMap->makeId(value<T>(key, block->base, block->shared));
   if (id == -1) {
-    return ErrorCode::kInsuffcientMemory;
+    return ErrorCode::kInsufficientMemory;
   }
   assert(typedIdMap->cardinality() <= kNormalizationRadix);
   result = kNormalizationRadix * result + id - 1;
diff --git a/velox/experimental/wave/exec/CMakeLists.txt b/velox/experimental/wave/exec/CMakeLists.txt
index a346b917a4a00..024efe9f8f974 100644
--- a/velox/experimental/wave/exec/CMakeLists.txt
+++ b/velox/experimental/wave/exec/CMakeLists.txt
@@ -12,24 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(velox_wave_stream OperandSet.cpp Wave.cpp)
+
+velox_link_libraries(velox_wave_stream Folly::folly fmt::fmt xsimd)
+
+velox_add_library(
   velox_wave_exec
   Aggregation.cpp
   AggregationInstructions.cu
   ExprKernel.cu
-  OperandSet.cpp
+  ExprKernel2.cu
+  ExprKernel3.cu
+  Instruction.cpp
   ToWave.cpp
   WaveOperator.cpp
   Vectors.cpp
   Values.cpp
   WaveDriver.cpp
-  Wave.cpp
-  Project.cpp)
+  Project.cpp
+  TableScan.cpp
+  WaveHiveDataSource.cpp
+  WaveSplitReader.cpp)
 
-set_target_properties(velox_wave_exec PROPERTIES CUDA_ARCHITECTURES native)
-
-target_link_libraries(velox_wave_exec velox_wave_vector velox_wave_common
-                      velox_exception velox_common_base velox_exec)
+velox_link_libraries(
+  velox_wave_exec
+  velox_wave_vector
+  velox_wave_common
+  velox_wave_stream
+  velox_exception
+  velox_common_base
+  velox_exec)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/experimental/wave/exec/ErrorCode.h b/velox/experimental/wave/exec/ErrorCode.h
index 3818c4d6fb925..d24d04713db62 100644
--- a/velox/experimental/wave/exec/ErrorCode.h
+++ b/velox/experimental/wave/exec/ErrorCode.h
@@ -18,23 +18,4 @@
 
 #include "velox/experimental/wave/vector/Operand.h"
 
-namespace facebook::velox::wave {
-
-///
-enum class ErrorCode : uint8_t {
-  // All operations completed.
-  kOk = 0,
-
-  // Catchall for runtime errors.
-  kError,
-
-  kInsuffcientMemory,
-};
-
-/// Contains a count of active lanes and a per lane error code.
-struct BlockStatus {
-  int32_t numRows{0};
-  ErrorCode errors[kBlockSize];
-};
-
-} // namespace facebook::velox::wave
+namespace facebook::velox::wave {} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/ExprKernel.cu b/velox/experimental/wave/exec/ExprKernel.cu
index 825b652179173..c97bc07a3d38c 100644
--- a/velox/experimental/wave/exec/ExprKernel.cu
+++ b/velox/experimental/wave/exec/ExprKernel.cu
@@ -16,134 +16,189 @@
 
 #include "velox/experimental/wave/exec/ExprKernel.h"
 
+#include <gflags/gflags.h>
 #include "velox/experimental/wave/common/Block.cuh"
 #include "velox/experimental/wave/common/CudaUtil.cuh"
+#include "velox/experimental/wave/exec/Aggregate.cuh"
 #include "velox/experimental/wave/exec/WaveCore.cuh"
 
-namespace facebook::velox::wave {
-
-template <typename T>
-__device__ inline T opFunc_kPlus(T left, T right) {
-  return left + right;
-}
-
-template <typename T, typename OpFunc>
-__device__ inline void binaryOpKernel(
-    OpFunc func,
-    IBinary& op,
-    Operand** operands,
-    int32_t blockBase,
-    char* shared,
-    BlockStatus* status) {
-  if (threadIdx.x >= status->numRows) {
-    return;
-  }
-  flatResult<T>(operands, op.result, blockBase, shared) = func(
-      getOperand<T>(operands, op.left, blockBase, shared),
-      getOperand<T>(operands, op.right, blockBase, shared));
-}
-
-__device__ void filterKernel(
-    const IFilter& filter,
-    Operand** operands,
-    int32_t blockBase,
-    char* shared,
-    int32_t& numRows) {
-  auto* flags = operands[filter.flags];
-  auto* indices = operands[filter.indices];
-  if (flags->nulls) {
-    boolBlockToIndices<kBlockSize>(
-        [&]() -> uint8_t {
-          return threadIdx.x >= numRows
-              ? 0
-              : flatValue<uint8_t>(flags->base, blockBase) &
-                  flatValue<uint8_t>(flags->nulls, blockBase);
-        },
-        blockBase,
-        reinterpret_cast<int32_t*>(indices->base) + blockBase,
-        shared,
-        numRows);
-  } else {
-    boolBlockToIndices<kBlockSize>(
-        [&]() -> uint8_t {
-          return threadIdx.x >= numRows
-              ? 0
-              : flatValue<uint8_t>(flags->base, blockBase);
-        },
-        blockBase,
-        reinterpret_cast<int32_t*>(indices->base) + blockBase,
-        shared,
-        numRows);
-  }
-}
+DEFINE_bool(kernel_gdb, false, "Run kernels sequentially for debugging");
 
-__device__ void wrapKernel(
-    IWrap& wrap,
-    Operand** operands,
-    int32_t blockBase,
-    int32_t& numRows) {}
+namespace facebook::velox::wave {
 
-#define BINARY_TYPES(opCode, OP)                             \
-  case OP_MIX(opCode, ScalarType::kInt64):                   \
-    binaryOpKernel<int64_t>(                                 \
+#define BINARY_TYPES(opCode, TP, OP)                         \
+  case opCode:                                               \
+    binaryOpKernel<TP>(                                      \
         [](auto left, auto right) { return left OP right; }, \
         instruction->_.binary,                               \
         operands,                                            \
         blockBase,                                           \
-        shared,                                              \
-        status);                                             \
+        &shared->data,                                       \
+        laneStatus);                                         \
     break;
 
-__global__ void waveBaseKernel(
-    int32_t* baseIndices,
-    int32_t* programIndices,
-    ThreadBlockProgram** programs,
-    Operand*** programOperands,
-    BlockStatus* blockStatusArray) {
-  using ScanAlgorithm = cub::BlockScan<int, 256, cub::BLOCK_SCAN_RAKING>;
-  extern __shared__ __align__(
-      alignof(typename ScanAlgorithm::TempStorage)) char shared[];
-  int programIndex = programIndices[blockIdx.x];
-  auto* program = programs[programIndex];
-  auto* operands = programOperands[programIndex];
-  auto* status = &blockStatusArray[blockIdx.x - baseIndices[blockIdx.x]];
-  int32_t blockBase = (blockIdx.x - baseIndices[blockIdx.x]) * blockDim.x;
-  for (auto i = 0; i < program->numInstructions; ++i) {
-    auto instruction = program->instructions[i];
+__global__ void oneAggregate(KernelParams params, int32_t pc, int32_t base) {
+  PROGRAM_PREAMBLE(base);
+  aggregateKernel(instruction[pc]._.aggregate, shared, laneStatus);
+  PROGRAM_EPILOGUE();
+}
+
+__global__ void oneReadAggregate(KernelParams params, int32_t pc, int32_t base);
+
+__global__ void onePlusBigint(KernelParams params, int32_t pc, int32_t base);
+template <typename T>
+__global__ void oneLt(KernelParams params, int32_t pc, int32_t base) {
+  PROGRAM_PREAMBLE(base);
+  binaryOpKernel<T>(
+      [](auto left, auto right) { return left < right; },
+      instruction[pc]._.binary,
+      operands,
+      blockBase,
+      &shared->data,
+      laneStatus);
+  PROGRAM_EPILOGUE();
+}
+
+__global__ void oneFilter(KernelParams params, int32_t pc, int32_t base);
+
+__global__ void waveBaseKernel(KernelParams params) {
+  PROGRAM_PREAMBLE(0);
+  for (;;) {
     switch (instruction->opCode) {
+      case OpCode::kReturn:
+        PROGRAM_EPILOGUE();
+        return;
+
       case OpCode::kFilter:
         filterKernel(
-            instruction->_.filter,
-            operands,
-            blockBase,
-            shared,
-            status->numRows);
+            instruction->_.filter, operands, blockBase, shared, laneStatus);
         break;
 
       case OpCode::kWrap:
-        wrapKernel(instruction->_.wrap, operands, blockBase, status->numRows);
+        wrapKernel(
+            instruction->_.wrap,
+            operands,
+            blockBase,
+            shared->numRows,
+            &shared->data);
         break;
+      case OpCode::kAggregate:
+        aggregateKernel(instruction->_.aggregate, shared, laneStatus);
+        break;
+      case OpCode::kReadAggregate:
+        readAggregateKernel(instruction->_.aggregate, shared);
+        break;
+        BINARY_TYPES(OpCode::kPlus_BIGINT, int64_t, +);
+        BINARY_TYPES(OpCode::kLT_BIGINT, int64_t, <);
+    }
+    ++instruction;
+  }
+}
+
+int32_t instructionSharedMemory(const Instruction& instruction) {
+  switch (instruction.opCode) {
+    case OpCode::kFilter:
+      return sizeof(WaveShared) +
+          (2 + (kBlockSize / kWarpThreads)) * sizeof(int32_t);
+    default:
+      return sizeof(WaveShared);
+  }
+}
+
+#define CALL_ONE(k, params, pc, base) \
+  k<<<blocksPerExe,                   \
+      kBlockSize,                     \
+      sharedSize,                     \
+      alias ? alias->stream()->stream : stream()->stream>>>(params, pc, base);
 
-        BINARY_TYPES(OpCode::kPlus, +);
+void WaveKernelStream::callOne(
+    Stream* alias,
+    int32_t numBlocks,
+    int32_t sharedSize,
+    KernelParams& params) {
+  int32_t blocksPerExe = 0;
+  auto first = params.programIdx[0];
+  for (; blocksPerExe < numBlocks; ++blocksPerExe) {
+    if (params.programIdx[blocksPerExe] != first) {
+      break;
+    }
+  }
+  std::vector<std::vector<OpCode>> programs;
+  for (auto i = 0; i < numBlocks; i += blocksPerExe) {
+    auto programIdx = programs.size();
+    programs.emplace_back();
+    auto* instructions = params.programs[programIdx]->instructions;
+    for (auto pc = 0; instructions[pc].opCode != OpCode::kReturn; ++pc) {
+      programs.back().push_back(instructions[pc].opCode);
+    }
+  }
+  auto initialStartPC = params.startPC;
+  for (auto programIdx = 0; programIdx < programs.size(); ++programIdx) {
+    auto& program = programs[programIdx];
+    int32_t base = programIdx * blocksPerExe;
+    params.startPC = initialStartPC;
+    int32_t start = 0;
+    if (params.startPC) {
+      start = params.startPC[programIdx];
     }
+    for (auto pc = start; pc < program.size(); ++pc) {
+      assert(params.programs[0]->instructions != nullptr);
+      switch (program[pc]) {
+        case OpCode::kFilter:
+          CALL_ONE(oneFilter, params, pc, base)
+          ++pc;
+          break;
+        case OpCode::kAggregate:
+          CALL_ONE(oneAggregate, params, pc, base)
+          break;
+        case OpCode::kReadAggregate:
+          CALL_ONE(oneReadAggregate, params, pc, base)
+          break;
+        case OpCode::kPlus_BIGINT:
+          CALL_ONE(onePlusBigint, params, pc, base);
+          break;
+        case OpCode::kLT_BIGINT:
+          CALL_ONE(oneLt<int64_t>, params, pc, base);
+          break;
+        default:
+          assert(false);
+      }
+    }
+    params.startPC = nullptr;
   }
 }
 
 void WaveKernelStream::call(
     Stream* alias,
     int32_t numBlocks,
-    int32_t* bases,
-    int32_t* programIdx,
-    ThreadBlockProgram** programs,
-    Operand*** operands,
-    BlockStatus* status,
-    int32_t sharedSize) {
+    int32_t sharedSize,
+    KernelParams& params) {
+  if (FLAGS_kernel_gdb) {
+    callOne(alias, numBlocks, sharedSize, params);
+    (alias ? alias : this)->wait();
+    return;
+  }
+
   waveBaseKernel<<<
       numBlocks,
       kBlockSize,
       sharedSize,
-      alias ? alias->stream()->stream : stream()->stream>>>(
-      bases, programIdx, programs, operands, status);
+      alias ? alias->stream()->stream : stream()->stream>>>(params);
+}
+
+REGISTER_KERNEL("expr", waveBaseKernel);
+
+void __global__ setupAggregationKernel(AggregationControl op) {
+  //    assert(op.maxTableEntries == 0);
+  auto* data = new (op.head) DeviceAggregation();
+  data->rowSize = op.rowSize;
+  data->singleRow = reinterpret_cast<char*>(data + 1);
+  memset(data->singleRow, 0, op.rowSize);
+}
+
+void WaveKernelStream::setupAggregation(AggregationControl& op) {
+  setupAggregationKernel<<<1, 1, 0, stream_->stream>>>(op);
+  wait();
 }
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/ExprKernel.h b/velox/experimental/wave/exec/ExprKernel.h
index ec4a2b2747669..a380a904f6d2b 100644
--- a/velox/experimental/wave/exec/ExprKernel.h
+++ b/velox/experimental/wave/exec/ExprKernel.h
@@ -18,6 +18,7 @@
 
 #include <cstdint>
 #include "velox/experimental/wave/common/Cuda.h"
+#include "velox/experimental/wave/common/HashTable.h"
 #include "velox/experimental/wave/exec/ErrorCode.h"
 #include "velox/experimental/wave/vector/Operand.h"
 
@@ -29,16 +30,6 @@
 /// be allocated dynamically at kernel invocation.
 namespace facebook::velox::wave {
 
-/// Mixed with opcode to switch between instantiations of instructions for
-/// different types.
-enum class ScalarType {
-  kInt32,
-  kInt64,
-  kReal,
-  kDouble,
-  kString,
-};
-
 /// Opcodes for common instruction set. First all instructions that
 /// do not have operand type variants, then all the ones that
 /// do. For type templated instructions, the case label is opcode *
@@ -47,23 +38,18 @@ enum class OpCode {
   // First all OpCodes that have no operand type specialization.
   kFilter = 0,
   kWrap,
+  kLiteral,
+  kNegate,
+  kAggregate,
+  kReadAggregate,
+  kReturn,
 
   // From here, only OpCodes that have variants for scalar types.
-  kPlus,
-  kMinus,
-  kTimes,
-  kDivide,
-  kEquals,
-  kLT,
-  kLTE,
-  kGT,
-  kGTE,
-  kNE,
-
+  kPlus_BIGINT,
+  kLT_BIGINT
 };
 
-#define OP_MIX(op, t) \
-  static_cast<OpCode>(static_cast<int32_t>(t) + 8 * static_cast<int32_t>(op))
+constexpr int32_t kLastScalarKind = static_cast<int32_t>(WaveTypeKind::HUGEINT);
 
 struct IBinary {
   OperandIndex left;
@@ -71,9 +57,6 @@ struct IBinary {
   OperandIndex result;
   // If set, apply operation to lanes where there is a non-zero byte in this.
   OperandIndex predicate{kEmpty};
-  // If true, inverts the meaning of 'predicate', so that the operation is
-  // perfformed on lanes with a zero byte bit. Xored with predicate[idx].
-  uint8_t invert{0};
 };
 
 struct IFilter {
@@ -84,31 +67,87 @@ struct IFilter {
 struct IWrap {
   // The indices to wrap on top of 'columns'.
   OperandIndex indices;
-
-  // Number of items in 'columns', 'targetColumns', 'nuwIndices',
-  // 'mayShareIndices'.
   int32_t numColumns;
 
   // The columns to wrap.
   OperandIndex* columns;
-  // The post wrap columns. If the original is not wrapped, these
-  // have the base of original and indices to wrap and posssibly new
-  // nulls from 'newNulls'. If the original is wrapped and
-  // newIndices[i] is non-nullptr, the combined indices from the
-  // existing wrap and 'indices are stored in
-  // 'newIndices'. 'newIndices[i]' is the indices of
-  // targetColumn[i]. If 'newIndices[i]' is nullptr, the new indices
-  // overwrite the indices in 'column[i]' and the indices are
-  // referenced from targetColunns[i]'.
-  OperandIndex* targetColumns;
-
-  OperandIndex* newIndices;
-
-  // If mayShareIndices[i]' is an index of a previous entry in 'columns' and
-  // columns[mayshareIndices[i]] shares indices of columns[i], then
-  // targetColumns[i] has indices of targetColumn[mayShareIndices[i]]. If the
-  // wrappings were not the same, indices are obtained from newIndices[i].
-  int32_t* mayShareIndices;
+};
+
+struct ILiteral {
+  OperandIndex literal;
+  OperandIndex result;
+  OperandIndex predicate;
+};
+
+struct INegate {
+  OperandIndex value;
+  OperandIndex result;
+  OperandIndex predicate;
+};
+struct IReturn {};
+
+enum class AggregateOp : uint8_t { kSum };
+
+/// Device-side state for group by
+struct DeviceAggregation {
+  /// hash table, nullptr if no grouping keys.
+  GpuHashTableBase* table{nullptr};
+
+  // Byte size of a rowm rounded to next 8.
+  int32_t rowSize = 0;
+
+  /// Allocator for variable llength accumulators, if not provided by 'table'.
+  RowAllocator* allocator{nullptr};
+
+  char* singleRow{nullptr};
+};
+
+/// Parameters for creating/updating a group by.
+struct AggregationControl {
+  /// Pointer to uninitialized first buffer in the case of initializing and to
+  /// the previous head in the case of rehashing. Must always be set.
+  void* head;
+  /// Size of block starting at 'head'. Must be set on first setup.
+  int64_t headSize{0};
+  /// For a rehashing request, space for a new head and a new HashTable.
+  void* newHead{nullptr};
+  int64_t newHeadSize{0};
+  /// Size of single row allocation. Required on first init.
+  int32_t rowSize{0};
+  //// Number of slots in HashTable, must be a powr of two. 0 means no hash
+  /// table (aggregation without grouping keys).
+  int32_t maxTableEntries{0};
+  /// Number of allocators for the hash table, if any. Must be a powr of two.
+  int32_t numPartitions{1};
+  /// Uninitialized space to be added to the allocators of an existing
+  /// HashTable.
+  char* extraSpace{nullptr};
+  /// Usable bytes starting at extraSpace.
+  int64_t extraSpaceSize{0};
+};
+
+struct IUpdateAgg {
+  AggregateOp op;
+  // Offset of null indicator byte on accumulator row.
+  int32_t nullOffset;
+  // Offset of accumulator on accumulator row. Aligned at 8.
+  int32_t accumulatorOffset;
+  OperandIndex arg1{kEmpty};
+  OperandIndex arg2{kEmpty};
+  OperandIndex result{kEmpty};
+};
+
+struct IAggregate {
+  uint16_t numKeys;
+  uint16_t numAggregates;
+  // Serial is used in BlockStatus to identify 'this' for continue.
+  uint8_t serial;
+  /// Index of the state in operator states.
+  uint8_t stateIndex;
+  /// Position of status return block in operator status returned to host.
+  InstructionStatus status;
+  //  'numAggre gates' Updates followed by key 'numKeys' key operand indices.
+  IUpdateAgg* aggregates;
 };
 
 struct Instruction {
@@ -117,6 +156,9 @@ struct Instruction {
     IBinary binary;
     IFilter filter;
     IWrap wrap;
+    ILiteral literal;
+    INegate negate;
+    IAggregate aggregate;
   } _;
 };
 
@@ -125,10 +167,59 @@ struct ThreadBlockProgram {
   // across the ThreadBlockPrograms.
   int32_t sharedMemorySize{0};
   int32_t numInstructions;
+  // Array of instructions. Ends in a kReturn.
+  Instruction* instructions;
+};
 
-  Instruction** instructions;
+/// Thread block wide status in Wave kernels
+struct WaveShared {
+  /// per lane status and row count.
+  BlockStatus* status;
+  Operand** operands;
+  void** states;
+  /// If true, all threads in block return before starting next instruction.
+  bool stop;
+  int32_t blockBase;
+  int32_t numRows;
+  // Scratch data area. Size depends on shared memory size for instructions.
+  // Align 8.
+  int64_t data;
 };
 
+/// Parameters for a Wave kernel. All pointers are device side readable.
+struct KernelParams {
+  /// The first thread block with the program. Subscript is blockIdx.x.
+  int32_t* blockBase{nullptr};
+  // The ordinal of the program. All blocks with the same program have the same
+  // number here. Subscript is blockIdx.x.
+  int32_t* programIdx{nullptr};
+
+  // The TB program for each exe. The subscript is programIdx[blockIdx.x].
+  ThreadBlockProgram** programs{nullptr};
+
+  /// The instruction where to start the execution. If nullptr,
+  /// 0. Otherwise subscript is programIdx. The active lanes are given
+  /// in 'blockStatus'. Used when restarting program at a specific
+  /// instruction, e.g. after allocating new memory on host. nullptr means first
+  /// launch, starting at 0.
+  int32_t* startPC{nullptr};
+
+  // For each exe, the start of the array of Operand*. Instructions reference
+  // operands via offset in this array. The subscript is
+  // programIndx[blockIdx.x].
+  Operand*** operands{nullptr};
+
+  // the status return block for each TB. The subscript is blockIdx.x -
+  // (blockBase[blockIdx.x] / kBlockSize). Shared between all programs.
+  BlockStatus* status{nullptr};
+  // Address of global states like hash tables. Subscript is 'programIdx' and
+  // next subscript is state id in the instruction.
+  void*** operatorStates;
+};
+
+/// Returns the shared memory size for instruction for kBlockSize.
+int32_t instructionSharedMemory(const Instruction& instruction);
+
 /// A stream for invoking ExprKernel.
 class WaveKernelStream : public Stream {
  public:
@@ -142,12 +233,20 @@ class WaveKernelStream : public Stream {
   void call(
       Stream* alias,
       int32_t numBlocks,
-      int32_t* blockBase,
-      int32_t* programIndices,
-      ThreadBlockProgram** programs,
-      Operand*** operands,
-      BlockStatus* status,
-      int32_t sharedSize);
+      int32_t sharedSize,
+      KernelParams& params);
+
+  /// Sets up or updates an aggregation.
+  void setupAggregation(AggregationControl& op);
+
+ private:
+  // Debug implementation of call() where each instruction is a separate kernel
+  // launch.
+  void callOne(
+      Stream* alias,
+      int32_t numBlocks,
+      int32_t sharedSize,
+      KernelParams& params);
 };
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/ExprKernel2.cu b/velox/experimental/wave/exec/ExprKernel2.cu
new file mode 100644
index 0000000000000..ca482f05aae38
--- /dev/null
+++ b/velox/experimental/wave/exec/ExprKernel2.cu
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/ExprKernel.h"
+
+#include <gflags/gflags.h>
+#include "velox/experimental/wave/common/Block.cuh"
+#include "velox/experimental/wave/common/CudaUtil.cuh"
+#include "velox/experimental/wave/exec/Aggregate.cuh"
+#include "velox/experimental/wave/exec/WaveCore.cuh"
+
+DECLARE_bool(kernel_gdb);
+
+namespace facebook::velox::wave {
+
+__global__ void
+oneReadAggregate(KernelParams params, int32_t pc, int32_t base) {
+  PROGRAM_PREAMBLE(base);
+  readAggregateKernel(instruction[pc]._.aggregate, shared);
+  PROGRAM_EPILOGUE();
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/ExprKernel3.cu b/velox/experimental/wave/exec/ExprKernel3.cu
new file mode 100644
index 0000000000000..56ad179c0b8c9
--- /dev/null
+++ b/velox/experimental/wave/exec/ExprKernel3.cu
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/ExprKernel.h"
+
+#include <gflags/gflags.h>
+#include "velox/experimental/wave/common/Block.cuh"
+#include "velox/experimental/wave/common/CudaUtil.cuh"
+#include "velox/experimental/wave/exec/Aggregate.cuh"
+#include "velox/experimental/wave/exec/WaveCore.cuh"
+
+DECLARE_bool(kernel_gdb);
+
+namespace facebook::velox::wave {
+
+__global__ void oneFilter(KernelParams params, int32_t pc, int32_t base) {
+  PROGRAM_PREAMBLE(base);
+  filterKernel(
+      instruction[pc]._.filter, operands, blockBase, shared, laneStatus);
+  wrapKernel(
+      instruction[pc + 1]._.wrap,
+      operands,
+      blockBase,
+      shared->numRows,
+      &shared->data);
+  PROGRAM_EPILOGUE();
+}
+
+__global__ void onePlusBigint(KernelParams params, int32_t pc, int32_t base) {
+  PROGRAM_PREAMBLE(base);
+  binaryOpKernel<int64_t>(
+      [](auto left, auto right) { return left + right; },
+      instruction[pc]._.binary,
+      operands,
+      blockBase,
+      &shared->data,
+      laneStatus);
+  PROGRAM_EPILOGUE();
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/Filter.h b/velox/experimental/wave/exec/Filter.h
deleted file mode 100644
index a78502306f07e..0000000000000
--- a/velox/experimental/wave/exec/Filter.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/experimental/wave/exec/WaveOperator.h"
-
-namespace facebook::velox::wave {
-
-class Filter : public WaveOperator {
- public:
-  Filter(RowTypePtr inputType, exec::ExprSet exprSet);
-
-  bool isStreaming() const override {
-    return true;
-  }
-
- private:
-  std::vector<Subfield> input_;
-};
-
-} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/Instruction.cpp b/velox/experimental/wave/exec/Instruction.cpp
new file mode 100644
index 0000000000000..6f8847907c57c
--- /dev/null
+++ b/velox/experimental/wave/exec/Instruction.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/Wave.h"
+
+namespace facebook::velox::wave {
+
+std::string rowTypeString(const Type& type) {
+  return "";
+}
+
+void AbstractAggregation::reserveState(InstructionStatus& reservedState) {
+  instructionStatus = reservedState;
+  // A group by produces 8 bytes of grid level state and uses the main main
+  // BlockStatus for lane status.
+  reservedState.gridState += 8;
+}
+
+AdvanceResult AbstractAggregation::canAdvance(
+    WaveStream& stream,
+    LaunchControl* control,
+    OperatorState* state,
+    int32_t programIdx) const {
+  return {};
+}
+
+AdvanceResult AbstractReadAggregation::canAdvance(
+    WaveStream& stream,
+    LaunchControl* control,
+    OperatorState* state,
+    int32_t programIdx) const {
+  auto* aggState = reinterpret_cast<AggregateOperatorState*>(state);
+  if (aggState->isNew) {
+    aggState->isNew = false;
+    return {.numRows = 1};
+  }
+  return {};
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/Instruction.h b/velox/experimental/wave/exec/Instruction.h
index 18616132133c6..6d935b090533d 100644
--- a/velox/experimental/wave/exec/Instruction.h
+++ b/velox/experimental/wave/exec/Instruction.h
@@ -16,6 +16,9 @@
 
 #pragma once
 
+#include "velox/exec/Driver.h"
+#include "velox/exec/Operator.h"
+#include "velox/experimental/wave/common/ResultStaging.h"
 #include "velox/experimental/wave/exec/ExprKernel.h"
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
@@ -24,7 +27,17 @@ namespace facebook::velox::wave {
 /// Abstract representation of Wave instructions. These translate to a device
 /// side ThreadBlockProgram right before execution.
 
+template <typename T, typename U>
+T addBytes(U* p, int32_t bytes) {
+  return reinterpret_cast<T>(reinterpret_cast<uintptr_t>(p) + bytes);
+}
+
+/// Represents an input/output of an instruction or WaveOperator on host. The
+/// device-side Operator is made at launch time based on this.
 struct AbstractOperand {
+  static constexpr int32_t kNoConstant = ~0;
+  static constexpr int32_t kNoWrap = ~0;
+
   AbstractOperand(int32_t id, const TypePtr& type, std::string label)
       : id(id), type(type), label(label) {}
 
@@ -39,42 +52,182 @@ struct AbstractOperand {
   // Label for debugging, e.g. column name or Expr::toString output.
   std::string label;
 
+  // The Operand of this is nullable if the Operand at some nullableIf_ is
+  // nullable.
+  std::vector<OperandId> nullableIf;
+
   // Vector with constant value, else nullptr.
   VectorPtr constant;
 
   // True if bits in nulls or boolean values are as a bit field. Need widening
   // to byte on device.
   bool flagsAsBits{false};
+
+  // Offset of the literal from the block of literals after the instructions.
+  // The base array in Operand will be set to 'constantOffset + end of last
+  // instruction'.
+  int32_t literalOffset{kNoConstant};
+  // true if null literal.
+  bool literalNull{false};
+
+  // True if the data needs no null flags. Applies to some intermediates like
+  // selected rows or flags or values of compile-time known non-nulls.
+  bool notNull{false};
+
+  // True if nullability depends on the run-time nullability of Operands this
+  // depends on. These are in 'nullableIf'.
+  bool conditionalNonNull{false};
+
+  // if true, nullability is set in WaveStream at the time of launching. Given
+  // by e.g. file metadata but not set at plan time.
+  bool sourceNullable{false};
+
+  // Ordinal of the wrap instruction that first wraps this. All operands wrapped
+  // by the same wrap share 'Operand.indices'. All Operands that are wrapped at
+  // some point get indices when first created. When they get wrapped, there is
+  // one wrap for all Operands with the same 'wrappedAt'
+  int32_t wrappedAt{kNoWrap};
+
+  std::string toString() const;
+};
+
+struct AdvanceResult {
+  bool empty() const {
+    return numRows == 0 && !isRetry;
+  }
+
+  ///  Max number of result rows.
+  int32_t numRows{0};
+
+  /// The sequence number of kernel launch that needs continue.
+  int32_t nthLaunch{0};
+
+  /// The ordinal of the program in the launch.
+  int32_t programIdx{0};
+
+  /// The instruction where to pick up. If not 0, must have 'isRetry' true.
+  int32_t instructionIdx{0};
+
+  /// True if continuing execution of a partially executed instruction. false if
+  /// getting a new batch from a source. If true, the kernel launch must specify
+  /// continuable lanes in BlockStatus.
+  bool isRetry{false};
 };
 
+class WaveStream;
+struct OperatorState;
+struct LaunchControl;
+
 struct AbstractInstruction {
   AbstractInstruction(OpCode opCode) : opCode(opCode) {}
 
+  virtual ~AbstractInstruction() = default;
+
   template <typename T>
   T& as() {
     return *reinterpret_cast<T*>(this);
   }
 
+  /// Checks blocking for external reasons for a source instruction in a source
+  /// executable. Applies to e.g. exchange.
+  virtual exec::BlockingReason isBlocked(
+      WaveStream& stream,
+      OperatorState* state,
+      ContinueFuture* future) const {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  /// Prepares the source instruction of a Program that begins with a
+  /// source instruction, like reading an aggregation or an
+  /// exchange. 'state' is a handle to the state on device. The
+  /// Executable is found in 'stream'. The 'this' contains no state
+  /// and is only used to dispatch on the operator.
+  virtual AdvanceResult canAdvance(
+      WaveStream& stream,
+      LaunchControl* control,
+      OperatorState* state,
+      int32_t programIdx) const {
+    return {};
+  }
+
+  virtual bool isSink() const {
+    return false;
+  }
+
+  virtual std::optional<int32_t> stateId() const {
+    return std::nullopt;
+  }
+
+  /// True if assigns 'op'.
+  virtual bool isOutput(const AbstractOperand* op) const {
+    return false;
+  }
+
+  virtual bool isContinuable(WaveStream& stream) const {
+    return false;
+  }
+
+  virtual void reserveState(InstructionStatus& state) {}
+
+  /// Returns the InstructionStatus if any. Used for patching the grid
+  /// size after all statuses in the operator pipeline are known.
+  virtual InstructionStatus* mutableInstructionStatus() {
+    return nullptr;
+  }
+
   OpCode opCode;
+
+  virtual std::string toString() const {
+    return fmt::format("OpCode {}", static_cast<int32_t>(opCode));
+  }
+};
+
+struct AbstractReturn : public AbstractInstruction {
+  AbstractReturn() : AbstractInstruction(OpCode::kReturn) {}
 };
 
 struct AbstractFilter : public AbstractInstruction {
+  AbstractFilter(AbstractOperand* flags, AbstractOperand* indices)
+      : AbstractInstruction(OpCode::kFilter), flags(flags), indices(indices) {}
+
   AbstractOperand* flags;
   AbstractOperand* indices;
+
+  std::string toString() const override;
 };
 
 struct AbstractWrap : public AbstractInstruction {
-  AbstractOperand indices;
+  AbstractWrap(AbstractOperand* indices, int32_t id)
+      : AbstractInstruction(OpCode::kWrap), indices(indices), id(id) {}
+  AbstractOperand* indices;
   std::vector<AbstractOperand*> source;
   std::vector<AbstractOperand*> target;
 
+  const int32_t id;
+  // Offset of array of affected operand indices in the literals section of the
+  // TB program. Filled in by first pass of making the TB program.
+  int32_t literalOffset{-1};
+
   void addWrap(AbstractOperand* sourceOp, AbstractOperand* targetOp = nullptr) {
-    if (std::find(source.begin(), source.end(), sourceOp) != source.end()) {
-      return;
+    int newWrap = AbstractOperand::kNoWrap;
+    if (targetOp) {
+      targetOp->wrappedAt = id;
+    } else if (sourceOp->wrappedAt == AbstractOperand::kNoWrap) {
+      sourceOp->wrappedAt = id;
+    }
+
+    for (auto i = 0; i < source.size(); ++i) {
+      // If the operand has the same wrap as another one here, do nothing.
+      if (source[i]->wrappedAt == sourceOp->wrappedAt ||
+          (targetOp && target[i]->wrappedAt == targetOp->wrappedAt)) {
+        return;
+      }
     }
     source.push_back(sourceOp);
     target.push_back(targetOp ? targetOp : sourceOp);
   }
+
+  std::string toString() const override;
 };
 
 struct AbstractBinary : public AbstractInstruction {
@@ -82,14 +235,188 @@ struct AbstractBinary : public AbstractInstruction {
       OpCode opCode,
       AbstractOperand* left,
       AbstractOperand* right,
-      AbstractOperand* result)
-      : AbstractInstruction(opCode), left(left), right(right), result(result) {}
+      AbstractOperand* result,
+      AbstractOperand* predicate = nullptr)
+      : AbstractInstruction(opCode),
+        left(left),
+        right(right),
+        result(result),
+        predicate(predicate) {}
 
   AbstractOperand* left;
   AbstractOperand* right;
   AbstractOperand* result;
-  AbstractOperand* predicate{nullptr};
-  bool invert{false};
+  AbstractOperand* predicate;
+
+  bool isOutput(const AbstractOperand* op) const override {
+    return op == result;
+  }
+
+  std::string toString() const override;
+};
+
+struct AbstractLiteral : public AbstractInstruction {
+  AbstractLiteral(
+      const VectorPtr& constant,
+      AbstractOperand* result,
+      AbstractOperand* predicate)
+      : AbstractInstruction(OpCode::kLiteral),
+        constant(constant),
+        result(result),
+        predicate(predicate) {}
+  VectorPtr constant;
+  AbstractOperand* result;
+  AbstractOperand* predicate;
+};
+
+struct AbstractUnary : public AbstractInstruction {
+  AbstractUnary(
+      OpCode opcode,
+      AbstractOperand* input,
+      AbstractOperand* result,
+      AbstractOperand* predicate = nullptr)
+      : AbstractInstruction(opcode),
+        input(input),
+        result(result),
+        predicate(predicate) {}
+  AbstractOperand* input;
+  AbstractOperand* result;
+  AbstractOperand* predicate;
+};
+
+enum class StateKind : uint8_t { kGroupBy };
+
+/// Represents a shared state operated on by instructions. For example, a
+/// join/group by table, destination buffers for repartition etc. Device side
+/// memory owned by a group of WaveBufferPtrs in the Program or WaveStream.
+struct AbstractState {
+  AbstractState(
+      int32_t id,
+      StateKind kind,
+      const std::string& idString,
+      const std::string& label)
+      : id(id), kind(kind), idString(idString), label(label) {}
+
+  /// serial numbr.
+  int32_t id;
+
+  StateKind kind;
+
+  /// PlanNodeId for joins/aggregates, other velox::Task scoped id.
+  std::string idString;
+
+  /// Comment
+  std::string label;
+
+  /// True if there is one item per WaveDriver, If false, there is one item per
+  /// WaveStream.
+  bool isGlobal;
 };
 
+struct AbstractOperator : public AbstractInstruction {
+  AbstractOperator(
+      OpCode opCode,
+      int32_t serial,
+      AbstractState* state,
+      RowTypePtr outputType)
+      : AbstractInstruction(opCode),
+        serial(serial),
+        state(state),
+        outputType(outputType) {}
+
+  std::optional<int32_t> stateId() const override {
+    if (!state) {
+      return std::nullopt;
+    }
+    return state->id;
+  }
+
+  // Identifies the bit in 'continuable' to indicate need for post-return
+  // action.
+  int32_t serial;
+
+  // Handle on device side state, e.g. aggregate hash table or repartitioning
+  // output buffers.
+  AbstractState* state;
+  RowTypePtr outputType;
+};
+
+struct AbstractAggInstruction {
+  AggregateOp op;
+  // Offset of null indicator byte on accumulator row.
+  int32_t nullOffset;
+  // Offset of accumulator on accumulator row. Aligned at 8.
+  int32_t accumulatorOffset;
+  std::vector<AbstractOperand*> args;
+  AbstractOperand* result;
+};
+
+struct AbstractAggregation : public AbstractOperator {
+  AbstractAggregation(
+      int32_t serial,
+      std::vector<AbstractOperand*> keys,
+      std::vector<AbstractAggInstruction> aggregates,
+      AbstractState* state,
+      RowTypePtr outputType)
+      : AbstractOperator(OpCode::kAggregate, serial, state, outputType),
+        keys(std::move(keys)),
+        aggregates(std::move(aggregates)) {}
+
+  int32_t rowSize() {
+    return aggregates.back().accumulatorOffset + sizeof(int64_t);
+  }
+
+  bool isSink() const override {
+    return true;
+  }
+
+  void reserveState(InstructionStatus& state) override;
+
+  InstructionStatus* mutableInstructionStatus() override {
+    return &instructionStatus;
+  }
+
+  AdvanceResult canAdvance(
+      WaveStream& stream,
+      LaunchControl* control,
+      OperatorState* state,
+      int32_t programIdx) const override;
+
+  InstructionStatus instructionStatus;
+
+  bool intermediateInput{false};
+  bool intermediateOutput{false};
+  std::vector<AbstractOperand*> keys;
+  std::vector<AbstractAggInstruction> aggregates;
+  int32_t stateId;
+  int32_t literalOffset;
+
+  int32_t literalBytes{0};
+  // The data area of the physical instruction. Copied by the reading
+  // istruction.
+  IUpdateAgg* literal{nullptr};
+};
+
+struct AbstractReadAggregation : public AbstractOperator {
+  AbstractReadAggregation(int32_t serial, AbstractAggregation* aggregation)
+      : AbstractOperator(
+            OpCode::kReadAggregate,
+            serial,
+            aggregation->state,
+            aggregation->outputType),
+        aggregation(aggregation) {}
+
+  AdvanceResult canAdvance(
+      WaveStream& stream,
+      LaunchControl* control,
+      OperatorState* state,
+      int32_t programIdx) const override;
+
+  AbstractAggregation* aggregation;
+  int32_t literalOffset{0};
+};
+
+/// Serializes 'row' to characters interpretable on device.
+std::string rowTypeString(const RowTypePtr& row);
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/OperandSet.h b/velox/experimental/wave/exec/OperandSet.h
index bac57e7def117..d9262a8eb416d 100644
--- a/velox/experimental/wave/exec/OperandSet.h
+++ b/velox/experimental/wave/exec/OperandSet.h
@@ -18,9 +18,9 @@
 
 #include <vector>
 #include "velox/common/base/BitUtil.h"
+#include "velox/experimental/wave/vector/Operand.h"
 
 namespace facebook::velox::wave {
-using OperandId = int32_t;
 
 /// Set of OperandId . Uses the id() as an index into a bitmap.
 class OperandSet {
diff --git a/velox/experimental/wave/exec/Project.cpp b/velox/experimental/wave/exec/Project.cpp
index c9cbd8edfb4e8..c40fcf6e18e58 100644
--- a/velox/experimental/wave/exec/Project.cpp
+++ b/velox/experimental/wave/exec/Project.cpp
@@ -15,37 +15,124 @@
  */
 
 #include "velox/experimental/wave/exec/Project.h"
+#include "velox/common/process/TraceContext.h"
 #include "velox/experimental/wave/exec/ToWave.h"
 #include "velox/experimental/wave/exec/Wave.h"
 #include "velox/experimental/wave/exec/WaveDriver.h"
 
 namespace facebook::velox::wave {
 
+AbstractWrap* Project::findWrap() const {
+  return filterWrap_;
+}
+
+AdvanceResult Project::canAdvance(WaveStream& stream) {
+  auto& controls = stream.launchControls(id_);
+  if (controls.empty()) {
+    /// No previous execution on the stream. If the first program starts with a
+    /// source we can continue that.
+    if (!isSource()) {
+      return {};
+    }
+    auto* program = levels_[0][0].get();
+    auto advance = program->canAdvance(stream, nullptr, 0);
+    if (!advance.empty()) {
+      advance.programIdx = 0;
+    }
+    return advance;
+  }
+  for (int32_t i = levels_.size() - 1; i >= 0; --i) {
+    auto& level = levels_[i];
+    AdvanceResult first;
+    VELOX_CHECK_EQ(controls[i]->programInfo.size(), level.size());
+    for (auto j = 0; j < level.size(); ++j) {
+      auto* program = level[i].get();
+      auto advance = program->canAdvance(stream, controls[i].get(), j);
+      if (!advance.empty()) {
+        if (first.empty()) {
+          first = advance;
+        }
+        controls[i]->programInfo[j].advance = advance;
+      } else {
+        controls[i]->programInfo[j].advance = {};
+      }
+      if (!first.empty()) {
+        return first;
+      }
+    }
+  }
+
+  return {};
+}
+
+namespace {
+bool anyContinuable(LaunchControl& control) {
+  for (auto& info : control.programInfo) {
+    if (!info.advance.empty()) {
+      return true;
+    }
+  }
+  return false;
+}
+} // namespace
+
 void Project::schedule(WaveStream& stream, int32_t maxRows) {
-  for (auto& level : levels_) {
+  int32_t firstLevel = 0;
+  auto& controls = stream.launchControls(id_);
+  bool isContinue = false;
+  // firstLevel is 0 if no previous activity, otherwise it is the last level
+  // with continuable activity. If continuable activity,'isContinue' is true.
+  if (!controls.empty()) {
+    for (int32_t i = levels_.size() - 1; i >= 0; --i) {
+      if (anyContinuable(*controls[i])) {
+        firstLevel = i;
+        isContinue = true;
+        break;
+      }
+    }
+  }
+  for (auto levelIdx = firstLevel; levelIdx < levels_.size(); ++levelIdx) {
+    auto& level = levels_[levelIdx];
     std::vector<std::unique_ptr<Executable>> exes(level.size());
     for (auto i = 0; i < level.size(); ++i) {
       auto& program = level[i];
-      exes[i] = program->getExecutable(maxRows, driver_->operands());
+      exes[i] = stream.recycleExecutable(program.get(), maxRows);
+      if (!exes[i]) {
+        exes[i] = program->getExecutable(maxRows, driver_->operands());
+      }
     }
     auto blocksPerExe = bits::roundUp(maxRows, kBlockSize) / kBlockSize;
     auto* data = exes.data();
     auto range = folly::Range(data, data + exes.size());
     stream.installExecutables(
         range, [&](Stream* out, folly::Range<Executable**> exes) {
-          auto inputControl = driver_->inputControl(stream, id_);
+          LaunchControl* inputControl = nullptr;
+          if (!isContinue && !isSource()) {
+            inputControl = driver_->inputControl(stream, id_);
+          }
           auto control = stream.prepareProgramLaunch(
-              id_, maxRows, exes, blocksPerExe, false, out);
-          reinterpret_cast<WaveKernelStream*>(out)->call(
-              out,
-              exes.size() * blocksPerExe,
-              control->blockBase,
-              control->programIdx,
-              control->programs,
-              control->operands,
-              inputControl->status,
-              control->sharedMemorySize);
+              id_,
+              levelIdx,
+              isContinue ? -1 : maxRows,
+              exes,
+              blocksPerExe,
+              inputControl,
+              out);
+          out->prefetch(
+              getDevice(),
+              control->deviceData->as<char>(),
+              control->deviceData->size());
+          stream.setState(WaveStream::State::kParallel);
+          {
+            PrintTime c("expr");
+            reinterpret_cast<WaveKernelStream*>(out)->call(
+                out,
+                exes.size() * blocksPerExe,
+                control->sharedMemorySize,
+                control->params);
+          }
         });
+    isContinue = false;
   }
 }
 
@@ -53,17 +140,13 @@ void Project::finalize(CompileState& state) {
   for (auto& level : levels_) {
     for (auto& program : level) {
       program->prepareForDevice(state.arena());
-      for (auto& pair : program->localAndOutput()) {
-        computedSet_.add(pair.first->id);
+      for (auto& pair : program->output()) {
+        if (true /*isProjected(id)*/) {
+          computedSet_.add(pair.first->id);
+        }
       }
     }
   }
 }
 
-vector_size_t Project::outputSize(WaveStream& stream) const {
-  auto& control = stream.launchControls(id_);
-  VELOX_CHECK(!control.empty());
-  return control[0]->inputRows;
-}
-
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/Project.h b/velox/experimental/wave/exec/Project.h
index cc08045084807..60fb58af428cf 100644
--- a/velox/experimental/wave/exec/Project.h
+++ b/velox/experimental/wave/exec/Project.h
@@ -23,22 +23,47 @@ class Project : public WaveOperator {
   Project(
       CompileState& state,
       RowTypePtr outputType,
-      std::vector<AbstractOperand*> operands,
-      std::vector<std::vector<ProgramPtr>> levels)
-      : WaveOperator(state, outputType), levels_(std::move(levels)) {}
+      std::vector<std::vector<ProgramPtr>> levels,
+      AbstractWrap* filterWrap = nullptr)
+      : WaveOperator(state, outputType, ""),
+        levels_(std::move(levels)),
+        filterWrap_(filterWrap) {}
+
+  AbstractWrap* findWrap() const override;
 
   bool isStreaming() const override {
+    if (!levels_.empty() && levels_[0].size() == 1 &&
+        levels_[0][0]->isSource()) {
+      return false;
+    }
     return true;
   }
 
-  void schedule(WaveStream& stream, int32_t maxRows = 0) override;
+  bool isSource() const override {
+    return !isStreaming();
+  }
+
+  /// True if the last  level is a sink like aggregation or partitioned output
+  /// or hash build. No output operands but the output will be consumed in
+  /// another pipeline.
+  bool isSink() const override {
+    if (levels_.empty()) {
+      // Can be temporarily empty if all instructions are fused into previous
+      // and this is only to designate a wrap.
+      return false;
+    }
+    auto& last = levels_.back();
+    return last.size() == 1 && last[0]->isSink();
+  }
+
+  AdvanceResult canAdvance(WaveStream& Stream) override;
 
-  vector_size_t outputSize(WaveStream& stream) const override;
+  void schedule(WaveStream& stream, int32_t maxRows = 0) override;
 
   void finalize(CompileState& state) override;
 
   std::string toString() const override {
-    return "Project";
+    return fmt::format("Project {}", WaveOperator::toString());
   }
 
   const OperandSet& syncSet() const override {
@@ -46,8 +71,14 @@ class Project : public WaveOperator {
   }
 
  private:
+  struct ContinueLocation {
+    int32_t programIdx;
+    int32_t instructionIdx;
+  };
+
   std::vector<std::vector<ProgramPtr>> levels_;
   OperandSet computedSet_;
+  AbstractWrap* filterWrap_{nullptr};
 };
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/TableScan.cpp b/velox/experimental/wave/exec/TableScan.cpp
new file mode 100644
index 0000000000000..f2c5189494749
--- /dev/null
+++ b/velox/experimental/wave/exec/TableScan.cpp
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/TableScan.h"
+#include "velox/common/time/Timer.h"
+#include "velox/exec/Task.h"
+#include "velox/experimental/wave/exec/WaveDriver.h"
+#include "velox/experimental/wave/exec/WaveSplitReader.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::wave {
+
+std::atomic<uint64_t> TableScan::ioWaitNanos_;
+
+using exec::BlockingReason;
+
+BlockingReason TableScan::isBlocked(ContinueFuture* future) {
+  if (!dataSource_ || needNewSplit_) {
+    nextSplit(future);
+    isNewSplit_ = true;
+  }
+  if (blockingFuture_.valid()) {
+    *future = std::move(blockingFuture_);
+    return blockingReason_;
+  }
+  return BlockingReason::kNotBlocked;
+}
+
+AdvanceResult TableScan::canAdvance(WaveStream& stream) {
+  if (!dataSource_ || needNewSplit_) {
+    return {};
+  }
+  if (isNewSplit_) {
+    isNewSplit_ = false;
+    return {.numRows = waveDataSource_->canAdvance(stream)};
+  }
+  return {.numRows = nextAvailableRows_};
+}
+
+void TableScan::schedule(WaveStream& stream, int32_t maxRows) {
+  waveDataSource_->schedule(stream, maxRows);
+  nextAvailableRows_ = waveDataSource_->canAdvance(stream);
+  if (nextAvailableRows_ == 0) {
+    updateStats(
+        waveDataSource_->splitReader()->runtimeStats(),
+        waveDataSource_->splitReader().get());
+    needNewSplit_ = true;
+  }
+}
+
+void TableScan::updateStats(
+    std::unordered_map<std::string, RuntimeCounter> connectorStats,
+    WaveSplitReader* splitReader) {
+  auto lockedStats = stats().wlock();
+  if (splitReader) {
+    lockedStats->rawInputPositions = splitReader->getCompletedRows();
+    lockedStats->rawInputBytes = splitReader->getCompletedBytes();
+  }
+  for (const auto& [name, counter] : connectorStats) {
+    if (name == "ioWaitNanos") {
+      ioWaitNanos_ += counter.value - lastIoWaitNanos_;
+      lastIoWaitNanos_ = counter.value;
+    }
+    if (UNLIKELY(lockedStats->runtimeStats.count(name) == 0)) {
+      lockedStats->runtimeStats.insert(
+          std::make_pair(name, RuntimeMetric(counter.unit)));
+    } else {
+      VELOX_CHECK_EQ(lockedStats->runtimeStats.at(name).unit, counter.unit);
+    }
+    lockedStats->runtimeStats.at(name).addValue(counter.value);
+  }
+}
+
+BlockingReason TableScan::nextSplit(ContinueFuture* future) {
+  exec::Split split;
+  blockingReason_ = driverCtx_->task->getSplitOrFuture(
+      driverCtx_->splitGroupId,
+      planNodeId_,
+      split,
+      blockingFuture_,
+      maxPreloadedSplits_,
+      splitPreloader_);
+  if (blockingReason_ != BlockingReason::kNotBlocked) {
+    return blockingReason_;
+  }
+
+  if (!split.hasConnectorSplit()) {
+    noMoreSplits_ = true;
+    if (dataSource_) {
+      updateStats(dataSource_->runtimeStats());
+    }
+    return BlockingReason::kNotBlocked;
+  }
+
+  const auto& connectorSplit = split.connectorSplit;
+  needNewSplit_ = false;
+
+  VELOX_CHECK_EQ(
+      connector_->connectorId(),
+      connectorSplit->connectorId,
+      "Got splits with different connector IDs");
+
+  WithSubfieldMap subfields(driver_->subfields());
+  if (!dataSource_) {
+    connectorQueryCtx_ = driver_->operatorCtx()->createConnectorQueryCtx(
+        connectorSplit->connectorId, planNodeId_, connectorPool_);
+    dataSource_ = connector_->createDataSource(
+        outputType_, tableHandle_, columnHandles_, connectorQueryCtx_.get());
+    waveDataSource_ = dataSource_->toWaveDataSource();
+    waveDataSource_->setOutputOperands(defines_);
+    waveDataSource_->addSplit(connectorSplit);
+  } else {
+    if (connectorSplit->dataSource) {
+      ++numPreloadedSplits_;
+      // The AsyncSource returns a unique_ptr to a shared_ptr. The
+      // unique_ptr will be nullptr if there was a cancellation.
+      numReadyPreloadedSplits_ += connectorSplit->dataSource->hasValue();
+      auto preparedDataSource = connectorSplit->dataSource->move();
+      driver_->stats().wlock()->getOutputTiming.add(
+          connectorSplit->dataSource->prepareTiming());
+      if (!preparedDataSource) {
+        // There must be a cancellation.
+        VELOX_CHECK(driver_->operatorCtx()->task()->isCancelled());
+        return BlockingReason::kNotBlocked;
+      }
+      auto preparedWaveSource = preparedDataSource->toWaveDataSource();
+      waveDataSource_->setFromDataSource(std::move(preparedWaveSource));
+    } else {
+      waveDataSource_->addSplit(connectorSplit);
+    }
+  }
+  ++stats().wlock()->numSplits;
+
+  for (const auto& entry : pendingDynamicFilters_) {
+    waveDataSource_->addDynamicFilter(entry.first, entry.second);
+  }
+  pendingDynamicFilters_.clear();
+  return BlockingReason::kNotBlocked;
+}
+
+void TableScan::preload(std::shared_ptr<connector::ConnectorSplit> split) {
+  // The AsyncSource returns a unique_ptr to the shared_ptr of the
+  // DataSource. The callback may outlive the Task, hence it captures
+  // a shared_ptr to it. This is required to keep memory pools live
+  // for the duration. The callback checks for task cancellation to
+  // avoid needless work.
+  split->dataSource = std::make_unique<AsyncSource<connector::DataSource>>(
+      [type = outputType_,
+       source = waveDataSource_,
+       table = tableHandle_,
+       columns = columnHandles_,
+       connector = connector_,
+       defines = defines_,
+       this,
+       ctx = driver_->operatorCtx()->createConnectorQueryCtx(
+           split->connectorId, planNodeId_, connectorPool_),
+       task = driver_->operatorCtx()->task(),
+       split]() -> std::unique_ptr<connector::DataSource> {
+        if (task->isCancelled()) {
+          return nullptr;
+        }
+        auto debugString =
+            fmt::format("Split {} Task {}", split->toString(), task->taskId());
+        ExceptionContextSetter exceptionContext(
+            {[](VeloxException::Type /*exceptionType*/, auto* debugString) {
+               return *static_cast<std::string*>(debugString);
+             },
+             &debugString});
+
+        auto ptr = connector->createDataSource(type, table, columns, ctx.get());
+        if (task->isCancelled()) {
+          return nullptr;
+        }
+        WithSubfieldMap subfields(driver_->subfields());
+        auto waveSource = ptr->toWaveDataSource();
+        waveSource->setOutputOperands(defines);
+        waveSource->addSplit(split);
+        return ptr;
+      });
+}
+
+void TableScan::checkPreload() {
+  auto executor = connector_->executor();
+  if (maxPreloadedSplits_ == 0 || !executor ||
+      !connector_->supportsSplitPreload()) {
+    return;
+  }
+  if (dataSource_->allPrefetchIssued()) {
+    maxPreloadedSplits_ = driverCtx_->task->numDrivers(driverCtx_->driver) *
+        maxSplitPreloadPerDriver_;
+    if (!splitPreloader_) {
+      splitPreloader_ =
+          [executor, this](std::shared_ptr<connector::ConnectorSplit> split) {
+            preload(split);
+
+            executor->add(
+                [taskHolder = driver_->operatorCtx()->task(), split]() mutable {
+                  split->dataSource->prepare();
+                  split.reset();
+                });
+          };
+    }
+  }
+}
+
+bool TableScan::isFinished() const {
+  return noMoreSplits_;
+}
+
+void TableScan::addDynamicFilter(
+    const core::PlanNodeId& producer,
+    column_index_t outputChannel,
+    const std::shared_ptr<common::Filter>& filter) {
+  if (dataSource_) {
+    dataSource_->addDynamicFilter(outputChannel, filter);
+  } else {
+    pendingDynamicFilters_.emplace(outputChannel, filter);
+  }
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/TableScan.h b/velox/experimental/wave/exec/TableScan.h
new file mode 100644
index 0000000000000..7c12321ffbf1e
--- /dev/null
+++ b/velox/experimental/wave/exec/TableScan.h
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/experimental/wave/exec/WaveOperator.h"
+
+#include "velox/common/time/Timer.h"
+#include "velox/exec/Task.h"
+#include "velox/experimental/wave/exec/ToWave.h"
+#include "velox/experimental/wave/exec/WaveDataSource.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::wave {
+
+class TableScan : public WaveSourceOperator {
+ public:
+  TableScan(
+      CompileState& state,
+      int32_t operatorId,
+      const core::TableScanNode& tableScanNode)
+      : WaveSourceOperator(
+            state,
+            tableScanNode.outputType(),
+            tableScanNode.id()),
+        tableHandle_(tableScanNode.tableHandle()),
+        columnHandles_(tableScanNode.assignments()),
+        driverCtx_(state.driver().driverCtx()),
+        connectorPool_(driverCtx_->task->addConnectorPoolLocked(
+            planNodeId_,
+            driverCtx_->pipelineId,
+            driverCtx_->driverId,
+            "",
+            tableHandle_->connectorId())),
+        readBatchSize_(driverCtx_->task->queryCtx()
+                           ->queryConfig()
+                           .preferredOutputBatchRows()) {
+    connector_ = connector::getConnector(tableHandle_->connectorId());
+  }
+
+  AdvanceResult canAdvance(WaveStream& stream) override;
+
+  void schedule(WaveStream& stream, int32_t maxRows = 0) override;
+
+  bool isStreaming() const override {
+    return true;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* future) override;
+
+  bool isFinished() const override;
+
+  bool canAddDynamicFilter() const override {
+    return true;
+  }
+
+  void addDynamicFilter(
+      const core::PlanNodeId& producer,
+      column_index_t outputChannel,
+      const std::shared_ptr<common::Filter>& filter) override;
+
+  static uint64_t ioWaitNanos() {
+    return ioWaitNanos_;
+  }
+
+  std::string toString() const override {
+    return "TableScan";
+  }
+
+ private:
+  exec::BlockingReason nextSplit(ContinueFuture* future);
+
+  // Sets 'maxPreloadSplits' and 'splitPreloader' if prefetching
+  // splits is appropriate. The preloader will be applied to the
+  // 'first 'maxPreloadSplits' of the Tasks's split queue for 'this'
+  // when getting splits.
+  void checkPreload();
+
+  // Sets 'split->dataSource' to be a Asyncsource that makes a
+  // DataSource to read 'split'. This source will be prepared in the
+  // background on the executor of the connector. If the DataSource is
+  // needed before prepare is done, it will be made when needed.
+  void preload(std::shared_ptr<connector::ConnectorSplit> split);
+
+  // Adds 'stats' to operator stats of the containing WaveDriver. Some
+  // stats come from DataSource, others from SplitReader. If
+  // 'splitReader' is given, the completed rows/bytes from
+  // 'splitReader' are added. These do not come in the runtimeStats()
+  // map.
+  void updateStats(
+      std::unordered_map<std::string, RuntimeCounter> stats,
+      WaveSplitReader* splitReader = nullptr);
+
+  // Process-wide IO wait time.
+  static std::atomic<uint64_t> ioWaitNanos_;
+
+  const std::shared_ptr<connector::ConnectorTableHandle> tableHandle_;
+  const std::
+      unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+          columnHandles_;
+  exec::DriverCtx* const driverCtx_;
+  memory::MemoryPool* const connectorPool_;
+  ContinueFuture blockingFuture_{ContinueFuture::makeEmpty()};
+  exec::BlockingReason blockingReason_;
+  int64_t currentSplitWeight_{0};
+  bool needNewSplit_ = true;
+  std::shared_ptr<connector::Connector> connector_;
+  std::shared_ptr<connector::ConnectorQueryCtx> connectorQueryCtx_;
+  bool noMoreSplits_ = false;
+  // Dynamic filters to add to the data source when it gets created.
+  std::unordered_map<column_index_t, std::shared_ptr<common::Filter>>
+      pendingDynamicFilters_;
+
+  std::shared_ptr<connector::DataSource> dataSource_;
+
+  std::shared_ptr<WaveDataSource> waveDataSource_;
+
+  int32_t maxPreloadedSplits_{0};
+
+  const int32_t maxSplitPreloadPerDriver_{0};
+
+  // Callback passed to getSplitOrFuture() for triggering async
+  // preload. The callback's lifetime is the lifetime of 'this'. This
+  // callback can schedule preloads on an executor. These preloads may
+  // outlive the Task and therefore need to capture a shared_ptr to
+  // it.
+  std::function<void(const std::shared_ptr<connector::ConnectorSplit>&)>
+      splitPreloader_{nullptr};
+
+  // Count of splits that started background preload.
+  int32_t numPreloadedSplits_{0};
+
+  // Count of splits that finished preloading before being read.
+  int32_t numReadyPreloadedSplits_{0};
+
+  vector_size_t readBatchSize_;
+  vector_size_t maxReadBatchSize_;
+
+  // Exits getOutput() method after this many milliseconds.
+  // Zero means 'no limit'.
+  size_t getOutputTimeLimitMs_{0};
+
+  double maxFilteringRatio_{0};
+
+  // String shown in ExceptionContext inside DataSource and LazyVector loading.
+  std::string debugString_;
+
+  // The last value of the IO wait time of 'this' that has been added to the
+  // global static 'ioWaitNanos_'.
+  uint64_t lastIoWaitNanos_{0};
+
+  // The value returned by canAdvance() of the WaveDataSource after last
+  // schedule().
+  int32_t nextAvailableRows_{0};
+
+  // True if canAdvance() should do waveDataSource_->canAdvance() instead of
+  // returning 'nextAvailableRows_'.
+  bool isNewSplit_{false};
+};
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/ToWave.cpp b/velox/experimental/wave/exec/ToWave.cpp
index ddccfb3b58683..809980bb96964 100644
--- a/velox/experimental/wave/exec/ToWave.cpp
+++ b/velox/experimental/wave/exec/ToWave.cpp
@@ -18,6 +18,7 @@
 #include "velox/exec/FilterProject.h"
 #include "velox/experimental/wave/exec/Aggregation.h"
 #include "velox/experimental/wave/exec/Project.h"
+#include "velox/experimental/wave/exec/TableScan.h"
 #include "velox/experimental/wave/exec/Values.h"
 #include "velox/experimental/wave/exec/WaveDriver.h"
 #include "velox/expression/ConstantExpr.h"
@@ -61,6 +62,22 @@ Value CompileState::toValue(const Expr& expr) {
   return Value(&expr);
 }
 
+Value CompileState::toValue(const core::FieldAccessTypedExpr& field) {
+  auto it = fieldToExpr_.find(field.name());
+  exec::Expr* expr;
+  if (it != fieldToExpr_.end()) {
+    expr = it->second.get();
+  } else {
+    auto name = field.name();
+    static std::vector<exec::ExprPtr> empty;
+    exec::ExprPtr newExpr =
+        std::make_shared<exec::FieldReference>(field.type(), empty, name);
+    expr = newExpr.get();
+    fieldToExpr_[name] = std::move(newExpr);
+  }
+  return toValue(*expr);
+}
+
 AbstractOperand* CompileState::newOperand(AbstractOperand& other) {
   auto newOp = std::make_unique<AbstractOperand>(other, operandCounter_++);
   operands_.push_back(std::move(newOp));
@@ -71,21 +88,32 @@ AbstractOperand* CompileState::newOperand(
     const TypePtr& type,
     const std::string& label) {
   operands_.push_back(
-      std::make_unique<AbstractOperand>(operandCounter_++, type, ""));
+      std::make_unique<AbstractOperand>(operandCounter_++, type, label));
   auto op = operands_.back().get();
   return op;
 }
 
-AbstractOperand* CompileState::addIdentityProjections(Value value) {
+AbstractState* CompileState::newState(
+    StateKind kind,
+    const std::string& idString,
+    const std::string& label) {
+  operatorStates_.push_back(
+      std::make_unique<AbstractState>(stateCounter_++, kind, idString, label));
+  auto state = operatorStates_.back().get();
+  return state;
+}
+
+AbstractOperand* CompileState::addIdentityProjections(AbstractOperand* source) {
   AbstractOperand* result = nullptr;
-  for (auto i = 0; i < operators_.size(); ++i) {
-    if (auto operand = operators_[i]->defines(value)) {
-      result = operand;
-      continue;
-    }
-    if (!result) {
-      continue;
-    }
+
+  int32_t latest = 0;
+  auto it = operandOperatorIndex_.find(source);
+  VELOX_CHECK(
+      it != operandOperatorIndex_.end(),
+      "The operand being projected through must b defined first");
+  latest = it->second;
+  result = source;
+  for (auto i = latest; i < operators_.size(); ++i) {
     if (auto wrap = operators_[i]->findWrap()) {
       if (operators_[i]->isExpanding()) {
         auto newResult = newOperand(*result);
@@ -101,16 +129,18 @@ AbstractOperand* CompileState::addIdentityProjections(Value value) {
 
 AbstractOperand* CompileState::findCurrentValue(Value value) {
   auto it = projectedTo_.find(value);
+  AbstractOperand* source;
   if (it == projectedTo_.end()) {
     auto originIt = definedBy_.find(value);
     if (originIt == definedBy_.end()) {
       return nullptr;
     }
+    source = originIt->second;
     // The operand is defined earlier, so must get translated through
     // cardinality changes. Or if it is not defined earlier, it is defined in
     // the WaveOperator being constructed, in which case,i.e. the operand in
     // 'definedBy_'.
-    auto projected = addIdentityProjections(value);
+    auto projected = addIdentityProjections(source);
     return projected ? projected : originIt->second;
   }
   return it->second;
@@ -118,8 +148,16 @@ AbstractOperand* CompileState::findCurrentValue(Value value) {
 
 std::optional<OpCode> binaryOpCode(const Expr& expr) {
   auto& name = expr.name();
+  // Only BIGINT + and <.
+  if (expr.inputs().size() != 2 ||
+      expr.inputs()[0]->type()->kind() != TypeKind::BIGINT) {
+    return std::nullopt;
+  }
   if (name == "plus") {
-    return OpCode::kPlus;
+    return OpCode::kPlus_BIGINT;
+  }
+  if (name == "lt") {
+    return OpCode::kLT_BIGINT;
   }
   return std::nullopt;
 }
@@ -130,6 +168,17 @@ Program* CompileState::newProgram() {
   return program.get();
 }
 
+Program* CompileState::programOf(AbstractOperand* op, bool create) {
+  auto it = definedIn_.find(op);
+  if (it == definedIn_.end()) {
+    if (!create) {
+      return nullptr;
+    }
+    return newProgram();
+  }
+  return it->second;
+}
+
 void CompileState::addInstruction(
     std::unique_ptr<AbstractInstruction> instruction,
     AbstractOperand* result,
@@ -164,6 +213,45 @@ void CompileState::addInstruction(
   definedIn_[result] = program;
 }
 
+bool maybeNotNull(const AbstractOperand* op) {
+  if (!op) {
+    return true;
+  }
+  if (op->constant) {
+    return !op->constant->isNullAt(0);
+  }
+  return op->conditionalNonNull || op->notNull || op->sourceNullable;
+}
+
+void CompileState::addNullableIf(
+    const AbstractOperand* op,
+    std::vector<OperandId>& nullableIf) {
+  if (op->constant || op->notNull) {
+    return;
+  }
+  if (std::find(nullableIf.begin(), nullableIf.end(), op->id) ==
+      nullableIf.end()) {
+    if (op->sourceNullable) {
+      nullableIf.push_back(op->id);
+    } else if (op->conditionalNonNull) {
+      for (auto& i : op->nullableIf) {
+        if (std::find(nullableIf.begin(), nullableIf.end(), i) ==
+            nullableIf.end()) {
+          nullableIf.push_back(i);
+        }
+      }
+    }
+  }
+}
+
+void CompileState::setConditionalNullable(AbstractBinary& binary) {
+  if (maybeNotNull(binary.left) && maybeNotNull(binary.right)) {
+    binary.result->conditionalNonNull = true;
+    addNullableIf(binary.left, binary.result->nullableIf);
+    addNullableIf(binary.right, binary.result->nullableIf);
+  }
+}
+
 AbstractOperand* CompileState::addExpr(const Expr& expr) {
   auto value = toValue(expr);
   auto current = findCurrentValue(value);
@@ -174,9 +262,23 @@ AbstractOperand* CompileState::addExpr(const Expr& expr) {
   if (auto* field = dynamic_cast<const exec::FieldReference*>(&expr)) {
     VELOX_FAIL("Should have been defined");
   } else if (auto* constant = dynamic_cast<const exec::ConstantExpr*>(&expr)) {
-    VELOX_UNSUPPORTED("No constants");
+    if (predicate_) {
+      auto result = newOperand(constant->type(), constant->toString());
+      currentProgram_->add(std::make_unique<AbstractLiteral>(
+          constant->value(), result, predicate_));
+      return result;
+    } else {
+      auto op = newOperand(constant->value()->type(), constant->toString());
+      op->constant = constant->value();
+      if (constant->value()->isNullAt(0)) {
+        op->literalNull = true;
+      } else {
+        op->notNull = true;
+      }
+      return op;
+    }
   } else if (dynamic_cast<const exec::SpecialForm*>(&expr)) {
-    VELOX_UNSUPPORTED("No special forms");
+    VELOX_UNSUPPORTED("No special forms: {}", expr.toString(1));
   }
   auto opCode = binaryOpCode(expr);
   if (!opCode.has_value()) {
@@ -187,6 +289,8 @@ AbstractOperand* CompileState::addExpr(const Expr& expr) {
   auto rightOp = addExpr(*expr.inputs()[1]);
   auto instruction =
       std::make_unique<AbstractBinary>(opCode.value(), leftOp, rightOp, result);
+  setConditionalNullable(*instruction);
+
   auto leftProgram = definedIn_[leftOp];
   auto rightProgram = definedIn_[rightOp];
   std::vector<Program*> sources;
@@ -208,6 +312,7 @@ std::vector<AbstractOperand*> CompileState::addExprSet(
   std::vector<AbstractOperand*> result;
   for (auto i = begin; i < end; ++i) {
     result.push_back(addExpr(*exprs[i]));
+    programOf(result.back())->addLabel(exprs[i]->toString(true));
   }
   return result;
 }
@@ -216,7 +321,7 @@ std::vector<std::vector<ProgramPtr>> CompileState::makeLevels(
     int32_t startIndex) {
   std::vector<std::vector<ProgramPtr>> levels;
   folly::F14FastSet<Program*> toAdd;
-  for (auto i = 0; i < allPrograms_.size(); ++i) {
+  for (auto i = startIndex; i < allPrograms_.size(); ++i) {
     toAdd.insert(allPrograms_[i].get());
   }
   while (!toAdd.empty()) {
@@ -253,23 +358,60 @@ int32_t findOutputChannel(
   VELOX_FAIL("Expr without output channel");
 }
 
+void CompileState::addFilter(const Expr& expr, const RowTypePtr& outputType) {
+  int32_t numPrograms = allPrograms_.size();
+  auto condition = addExpr(expr);
+  auto indices = newOperand(INTEGER(), "indices");
+  indices->notNull = true;
+  auto program = programOf(condition);
+  program->addLabel(expr.toString(true));
+  program->markOutput(indices->id);
+  program->add(std::make_unique<AbstractFilter>(condition, indices));
+  auto wrapUnique = std::make_unique<AbstractWrap>(indices, wrapCounter_++);
+  auto wrap = wrapUnique.get();
+  program->add(std::move(wrapUnique));
+  auto levels = makeLevels(numPrograms);
+  operators_.push_back(
+      std::make_unique<Project>(*this, outputType, levels, wrap));
+}
+
 void CompileState::addFilterProject(
     exec::Operator* op,
-    RowTypePtr outputType,
+    RowTypePtr& outputType,
     int32_t& nodeIndex) {
   auto filterProject = reinterpret_cast<exec::FilterProject*>(op);
+  outputType = driverFactory_.planNodes[nodeIndex]->outputType();
   auto data = filterProject->exprsAndProjection();
-  VELOX_CHECK(!data.hasFilter);
+  auto& identityProjections = filterProject->identityProjections();
+  int32_t firstProjection = 0;
+  if (data.hasFilter) {
+    addFilter(*data.exprs->exprs()[0], outputType);
+    firstProjection = 1;
+    ++nodeIndex;
+    outputType = driverFactory_.planNodes[nodeIndex]->outputType();
+  }
   int32_t numPrograms = allPrograms_.size();
-  auto operands = addExprSet(*data.exprs, 0, data.exprs->exprs().size());
+  auto operands =
+      addExprSet(*data.exprs, firstProjection, data.exprs->exprs().size());
+  std::vector<std::pair<Value, AbstractOperand*>> pairs;
   for (auto i = 0; i < operands.size(); ++i) {
-    int32_t channel = findOutputChannel(*data.resultProjections, i);
+    int32_t channel =
+        findOutputChannel(*data.resultProjections, i + firstProjection);
     auto subfield = toSubfield(outputType->nameOf(channel));
-    definedBy_[Value(subfield)] = operands[i];
+    auto program = programOf(operands[i], false);
+    if (program) {
+      program->markOutput(operands[i]->id);
+      definedIn_[operands[i]] = program;
+    }
+    Value value(subfield);
+    definedBy_[value] = operands[i];
+    pairs.push_back(std::make_pair(value, operands[i]));
   }
   auto levels = makeLevels(numPrograms);
-  operators_.push_back(
-      std::make_unique<Project>(*this, outputType, operands, levels));
+  operators_.push_back(std::make_unique<Project>(*this, outputType, levels));
+  for (auto& [value, operand] : pairs) {
+    operators_.back()->defined(value, operand);
+  }
 }
 
 bool CompileState::reserveMemory() {
@@ -295,6 +437,126 @@ CompileState::aggregateFunctionRegistry() {
   return aggregateFunctionRegistry_;
 }
 
+void CompileState::setAggregateFromPlan(
+    const core::AggregationNode::Aggregate& planAggregate,
+    AbstractAggInstruction& agg) {
+  agg.op = AggregateOp::kSum;
+}
+
+void CompileState::makeAggregateLayout(AbstractAggregation& aggregate) {
+  // First key nulls, then key wirds. Then accumulator nulls, then accumulators.
+  int32_t numKeys = aggregate.keys.size();
+  int32_t startOffset = bits::roundUp(numKeys, 8) + 8 * numKeys;
+  int32_t accNullOffset = startOffset;
+  auto numAggs = aggregate.aggregates.size();
+  int32_t accOffset = accNullOffset + bits::roundUp(numAggs, 8);
+  for (auto i = 0; i < numAggs; ++i) {
+    auto& agg = aggregate.aggregates[i];
+    agg.nullOffset = accNullOffset + i;
+    agg.accumulatorOffset = accOffset + i * sizeof(int64_t);
+  }
+}
+
+void CompileState::makeAggregateAccumulate(const core::AggregationNode* node) {
+  auto* state = newState(StateKind::kGroupBy, node->id(), "");
+  std::vector<AbstractOperand*> keys;
+  folly::F14FastSet<AbstractOperand*> uniqueArgs;
+  folly::F14FastSet<Program*> programs;
+  std::vector<AbstractOperand*> allArgs;
+  std::vector<AbstractAggInstruction> aggregates;
+  int numPrograms = allPrograms_.size();
+  for (auto& key : node->groupingKeys()) {
+    auto arg = findCurrentValue(key);
+    allArgs.push_back(arg);
+    keys.push_back(arg);
+    if (auto source = definedIn_[arg]) {
+      programs.insert(source);
+    }
+  }
+  auto numKeys = node->groupingKeys().size();
+  for (auto& planAggregate : node->aggregates()) {
+    aggregates.emplace_back();
+    std::vector<PhysicalType> argTypes;
+    auto& aggregate = aggregates.back();
+    setAggregateFromPlan(planAggregate, aggregate);
+    auto i = numKeys + aggregates.size() - 1;
+    aggregate.result = newOperand(
+        node->outputType()->childAt(i), node->outputType()->nameOf(i));
+    auto subfield = toSubfield(node->outputType()->nameOf(i));
+    definedBy_[Value(subfield)] = aggregate.result;
+    for (auto& arg : planAggregate.call->inputs()) {
+      argTypes.push_back(fromCpuType(*arg->type()));
+      auto field =
+          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(arg);
+      auto op = findCurrentValue(field);
+      aggregate.args.push_back(op);
+      bool isNew = uniqueArgs.insert(op).second;
+      if (isNew) {
+        allArgs.push_back(op);
+        if (auto source = definedIn_[op]) {
+          programs.insert(source);
+        }
+      }
+    }
+#if 0
+    auto func =
+        functionRegistry_->getFunction(aggregate.call->name(), argTypes);
+    VELOX_CHECK_NOT_NULL(func);
+#endif
+  }
+  auto instruction = std::make_unique<AbstractAggregation>(
+      nthContinuable_++,
+      std::move(keys),
+      std::move(aggregates),
+      state,
+      node->outputType());
+  makeAggregateLayout(*instruction);
+  std::vector<Program*> sourceList;
+  if (programs.empty()) {
+    sourceList.push_back(newProgram());
+  } else if (programs.size() == 1) {
+    sourceList.push_back(*programs.begin());
+  } else {
+    for (auto& s : programs) {
+      sourceList.push_back(s);
+    }
+  }
+  instruction->reserveState(instructionStatus_);
+  allStatuses_.push_back(instruction->mutableInstructionStatus());
+  auto aggInstruction = instruction.get();
+  addInstruction(std::move(instruction), nullptr, sourceList);
+  if (allPrograms_.size() > numPrograms) {
+    makeProject(numPrograms, node->outputType());
+  }
+  numPrograms = allPrograms_.size();
+  auto reader = newProgram();
+  reader->add(std::make_unique<AbstractReadAggregation>(
+      nthContinuable_++, aggInstruction));
+
+  makeProject(numPrograms, node->outputType());
+  auto project = reinterpret_cast<Project*>(operators_.back().get());
+  for (auto i = 0; i < node->groupingKeys().size(); ++i) {
+    std::string name = aggInstruction->keys[i]->label;
+    operators_.back()->defined(
+        Value(toSubfield(name)), aggInstruction->keys[i]);
+    definedIn_[aggInstruction->keys[i]] = reader;
+  }
+  for (auto i = 0; i < aggInstruction->aggregates.size(); ++i) {
+    std::string name = aggInstruction->aggregates[i].result->label;
+    operators_.back()->defined(
+        Value(toSubfield(name)), aggInstruction->aggregates[i].result);
+    definedIn_[aggInstruction->aggregates[i].result] = reader;
+    // project->definesSubfield(*this,
+    // aggInstruction->aggregates[i].result->type, name, false);
+  }
+}
+
+void CompileState::makeProject(int firstProgram, RowTypePtr outputType) {
+  auto levels = makeLevels(firstProgram);
+  operators_.push_back(
+      std::make_unique<Project>(*this, outputType, std::move(levels)));
+}
+
 bool CompileState::addOperator(
     exec::Operator* op,
     int32_t& nodeIndex,
@@ -313,8 +575,6 @@ bool CompileState::addOperator(
     if (!reserveMemory()) {
       return false;
     }
-
-    outputType = driverFactory_.planNodes[nodeIndex]->outputType();
     addFilterProject(op, outputType, nodeIndex);
   } else if (name == "Aggregation") {
     if (!reserveMemory()) {
@@ -323,9 +583,23 @@ bool CompileState::addOperator(
     auto* node = dynamic_cast<const core::AggregationNode*>(
         driverFactory_.planNodes[nodeIndex].get());
     VELOX_CHECK_NOT_NULL(node);
+    makeAggregateAccumulate(node);
+#if 0
     operators_.push_back(std::make_unique<Aggregation>(
         *this, *node, aggregateFunctionRegistry()));
+#endif
     outputType = node->outputType();
+  } else if (name == "TableScan") {
+    if (!reserveMemory()) {
+      return false;
+    }
+    auto scan = reinterpret_cast<const core::TableScanNode*>(
+        driverFactory_.planNodes[nodeIndex].get());
+    outputType = driverFactory_.planNodes[nodeIndex]->outputType();
+
+    operators_.push_back(
+        std::make_unique<TableScan>(*this, operators_.size(), *scan));
+    outputType = scan->outputType();
   } else {
     return false;
   }
@@ -334,9 +608,11 @@ bool CompileState::addOperator(
 
 bool isProjectedThrough(
     const std::vector<exec::IdentityProjection>& projectedThrough,
-    int32_t i) {
+    int32_t i,
+    int32_t& inputChannel) {
   for (auto& projection : projectedThrough) {
     if (projection.outputChannel == i) {
+      inputChannel = projection.inputChannel;
       return true;
     }
   }
@@ -354,32 +630,79 @@ bool CompileState::compile() {
   // Make sure operator states are initialized.  We will need to inspect some of
   // them during the transformation.
   driver_.initializeOperators();
+  RowTypePtr inputType;
   for (; operatorIndex < operators.size(); ++operatorIndex) {
+    int32_t previousNumOperators = operators_.size();
+    auto& identity = operators[operatorIndex]->identityProjections();
+    // The columns that are projected through are renamed. They may also get an
+    // indirection after the new operator is placed.
+    std::vector<std::pair<AbstractOperand*, int32_t>> identityProjected;
+    for (auto& projection : identity) {
+      identityProjected.push_back(std::make_pair(
+          findCurrentValue(
+              Value(toSubfield(inputType->nameOf(projection.inputChannel)))),
+          projection.outputChannel));
+    }
     if (!addOperator(operators[operatorIndex], nodeIndex, outputType)) {
       break;
     }
     ++nodeIndex;
-    auto& identity = operators[operatorIndex]->identityProjections();
-    for (auto i = 0; i < outputType->size(); ++i) {
-      Value value = Value(toSubfield(outputType->nameOf(i)));
-      if (isProjectedThrough(identity, i)) {
+    for (auto newIndex = previousNumOperators; newIndex < operators_.size();
+         ++newIndex) {
+      if (operators_[newIndex]->isSink()) {
+        // No output operands.
         continue;
       }
-      auto operand = operators_.back()->defines(value);
-      definedBy_[value] = operand;
+      for (auto i = 0; i < outputType->size(); ++i) {
+        auto& name = outputType->nameOf(i);
+        Value value = Value(toSubfield(name));
+        int32_t inputChannel;
+        if (isProjectedThrough(identity, i, inputChannel)) {
+          continue;
+        }
+        auto operand = operators_[newIndex]->defines(value);
+        if (!operand &&
+            (operators_[newIndex]->isSource() ||
+             !operators_[newIndex]->isStreaming())) {
+          operand = operators_[newIndex]->definesSubfield(
+              *this, outputType->childAt(i), name, newIndex == 0);
+        }
+        if (operand) {
+          operators_[newIndex]->addOutputId(operand->id);
+          definedBy_[value] = operand;
+          operandOperatorIndex_[operand] = operators_.size() - 1;
+        }
+      }
     }
+    for (auto& [op, channel] : identityProjected) {
+      Value value(toSubfield(outputType->nameOf(channel)));
+      auto newOp = addIdentityProjections(op);
+      projectedTo_[value] = newOp;
+    }
+    inputType = outputType;
   }
   if (operators_.empty()) {
     return false;
   }
-  for (auto& op : operators_) {
-    op->finalize(*this);
-  }
   std::vector<OperandId> resultOrder;
   for (auto i = 0; i < outputType->size(); ++i) {
     auto operand = findCurrentValue(Value(toSubfield(outputType->nameOf(i))));
+    auto source = programOf(operand, false);
+    // Operands produced by programs, when projected out of Wave, must
+    // be marked as output of their respective programs. Some
+    // operands, e.g. table scan results are not from programs.
+    if (source) {
+      source->markOutput(operand->id);
+    }
     resultOrder.push_back(operand->id);
   }
+  for (auto& op : operators_) {
+    op->finalize(*this);
+  }
+  instructionStatus_.gridStateSize = instructionStatus_.gridState;
+  for (auto* status : allStatuses_) {
+    status->gridStateSize = instructionStatus_.gridState;
+  }
   auto waveOpUnique = std::make_unique<WaveDriver>(
       driver_.driverCtx(),
       outputType,
@@ -389,7 +712,9 @@ bool CompileState::compile() {
       std::move(operators_),
       std::move(resultOrder),
       std::move(subfields_),
-      std::move(operands_));
+      std::move(operands_),
+      std::move(operatorStates_),
+      instructionStatus_);
   auto waveOp = waveOpUnique.get();
   waveOp->initialize();
   std::vector<std::unique_ptr<exec::Operator>> added;
diff --git a/velox/experimental/wave/exec/ToWave.h b/velox/experimental/wave/exec/ToWave.h
index 87c9de602616a..816620fa5e1d7 100644
--- a/velox/experimental/wave/exec/ToWave.h
+++ b/velox/experimental/wave/exec/ToWave.h
@@ -31,6 +31,10 @@ class CompileState {
   CompileState(const exec::DriverFactory& driverFactory, exec::Driver& driver)
       : driverFactory_(driverFactory), driver_(driver) {}
 
+  exec::Driver& driver() {
+    return driver_;
+  }
+
   // Replaces sequences of Operators in the Driver given at construction with
   // Wave equivalents. Returns true if the Driver was changed.
   bool compile();
@@ -49,8 +53,17 @@ class CompileState {
 
   Value toValue(const exec::Expr& expr);
 
-  AbstractOperand* addIdentityProjections(Value value);
+  Value toValue(const core::FieldAccessTypedExpr& field);
+
+  AbstractOperand* addIdentityProjections(AbstractOperand* source);
   AbstractOperand* findCurrentValue(Value value);
+
+  AbstractOperand* findCurrentValue(
+      const std::shared_ptr<const core::FieldAccessTypedExpr>& field) {
+    Value value = toValue(*field);
+    return findCurrentValue(value);
+  }
+
   AbstractOperand* addExpr(const exec::Expr& expr);
 
   void addInstruction(
@@ -78,11 +91,30 @@ class CompileState {
   bool
   addOperator(exec::Operator* op, int32_t& nodeIndex, RowTypePtr& outputType);
 
+  void addFilter(const exec::Expr& expr, const RowTypePtr& outputType);
+
+  AbstractState* newState(
+      StateKind kind,
+      const std::string& idString,
+      const std::string& label);
+
   void addFilterProject(
       exec::Operator* op,
-      RowTypePtr outputType,
+      RowTypePtr& outputType,
       int32_t& nodeIndex);
 
+  /// Adds a projection operator containing programs starting at 'firstProgram'
+  /// for the rest of 'allPrograms_'..
+  void makeProject(int32_t firstProgram, RowTypePtr outputType);
+
+  void makeAggregateLayout(AbstractAggregation& aggregate);
+
+  void setAggregateFromPlan(
+      const core::AggregationNode::Aggregate& planAggregate,
+      AbstractAggInstruction& agg);
+
+  void makeAggregateAccumulate(const core::AggregationNode* node);
+
   bool reserveMemory();
 
   // Adds 'instruction' to the suitable program and records the result
@@ -97,17 +129,27 @@ class CompileState {
       const AbstractOperand* result,
       const std::vector<Program*>& inputs);
 
+  void setConditionalNullable(AbstractBinary& binary);
+
+  // Adds 'op->id' to 'nullableIf' if not already there.
+  void addNullableIf(
+      const AbstractOperand* op,
+      std::vector<OperandId>& nullableIf);
+
+  Program* programOf(AbstractOperand* op, bool create = true);
+
   const std::shared_ptr<aggregation::AggregateFunctionRegistry>&
   aggregateFunctionRegistry();
 
   std::unique_ptr<GpuArena> arena_;
   // The operator and output operand where the Value is first defined.
-  folly::F14FastMap<Value, AbstractOperand*, ValueHasher, ValueComparer>
-      definedBy_;
+  DefinesMap definedBy_;
 
   // The Operand where Value is available after all projections placed to date.
-  folly::F14FastMap<Value, AbstractOperand*, ValueHasher, ValueComparer>
-      projectedTo_;
+  DefinesMap projectedTo_;
+
+  // Index of WaveOperator producing the operand.
+  folly::F14FastMap<AbstractOperand*, int32_t> operandOperatorIndex_;
 
   folly::F14FastMap<AbstractOperand*, Program*> definedIn_;
 
@@ -117,8 +159,11 @@ class CompileState {
 
   std::vector<ProgramPtr> allPrograms_;
 
+  std::vector<std::vector<ProgramPtr>> pendingLevels_;
+
   // All AbstractOperands. Handed off to WaveDriver after plan conversion.
   std::vector<std::unique_ptr<AbstractOperand>> operands_;
+  std::vector<std::unique_ptr<AbstractState>> operatorStates_;
 
   // The Wave operators generated so far.
   std::vector<std::unique_ptr<WaveOperator>> operators_;
@@ -126,11 +171,23 @@ class CompileState {
   // The program being generated.
   std::shared_ptr<Program> currentProgram_;
 
+  // Boolean to select the instruction. Set for conditionl sections.
+  AbstractOperand* predicate_{nullptr};
+
   // Sequence number for operands.
   int32_t operandCounter_{0};
+  int32_t wrapCounter_{0};
+  int32_t stateCounter_{0};
+  InstructionStatus instructionStatus_;
+
+  // All InstructionStatus records in instructions that have them. Used for
+  // patching the final grid size when this is known.
+  std::vector<InstructionStatus*> allStatuses_;
 
+  int32_t nthContinuable_{0};
   std::shared_ptr<aggregation::AggregateFunctionRegistry>
       aggregateFunctionRegistry_;
+  folly::F14FastMap<std::string, std::shared_ptr<exec::Expr>> fieldToExpr_;
 };
 
 /// Registers adapter to add Wave operators to Drivers.
diff --git a/velox/experimental/wave/exec/Values.cpp b/velox/experimental/wave/exec/Values.cpp
index 98ef5938b7dfe..316f483ceee5e 100644
--- a/velox/experimental/wave/exec/Values.cpp
+++ b/velox/experimental/wave/exec/Values.cpp
@@ -21,18 +21,18 @@
 namespace facebook::velox::wave {
 
 Values::Values(CompileState& state, const core::ValuesNode& values)
-    : WaveOperator(state, values.outputType()),
+    : WaveSourceOperator(state, values.outputType(), values.id()),
       values_(values.values()),
       roundsLeft_(values.repeatTimes()) {}
 
-int32_t Values::canAdvance() {
+AdvanceResult Values::canAdvance(WaveStream& stream) {
   if (current_ < values_.size()) {
-    return values_[current_]->size();
+    return {.numRows = values_[current_]->size()};
   }
   if (roundsLeft_ > 1) {
-    return values_[0]->size();
+    return {.numRows = values_[0]->size()};
   }
-  return 0;
+  return {};
 }
 
 void Values::schedule(WaveStream& stream, int32_t maxRows) {
@@ -52,10 +52,16 @@ void Values::schedule(WaveStream& stream, int32_t maxRows) {
   for (auto i = 0; i < subfields_.size(); ++i) {
     sources.push_back(data->childAt(i).get());
   }
+  int32_t counter = 0;
+  outputIds_.forEach([&](auto id) {
+    stream.setNullable(*stream.operandAt(id), sources[counter]->mayHaveNulls());
+    ++counter;
+  });
   folly::Range<Executable**> empty(nullptr, nullptr);
   auto numBlocks = bits::roundUp(data->size(), kBlockSize) / kBlockSize;
+  stream.setNumRows(data->size());
   stream.prepareProgramLaunch(
-      id_, data->size(), empty, numBlocks, true, nullptr);
+      id_, 0, data->size(), empty, numBlocks, nullptr, nullptr);
   vectorsToDevice(
       folly::Range(sources.data(), sources.size()), outputIds_, stream);
 }
diff --git a/velox/experimental/wave/exec/Values.h b/velox/experimental/wave/exec/Values.h
index b7c80229d89b6..5702b022d0a52 100644
--- a/velox/experimental/wave/exec/Values.h
+++ b/velox/experimental/wave/exec/Values.h
@@ -20,11 +20,11 @@
 
 namespace facebook::velox::wave {
 
-class Values : public WaveOperator {
+class Values : public WaveSourceOperator {
  public:
   Values(CompileState& state, const core::ValuesNode& values);
 
-  int32_t canAdvance() override;
+  AdvanceResult canAdvance(WaveStream& stream) override;
 
   bool isStreaming() const override {
     return true;
@@ -36,12 +36,6 @@ class Values : public WaveOperator {
     return roundsLeft_ == (current_ == values_.size());
   }
 
-  vector_size_t outputSize(WaveStream& stream) const override {
-    // Must not be called before schedule().
-    VELOX_CHECK_LT(0, current_);
-    return values_[current_ - 1]->size();
-  }
-
   std::string toString() const override;
 
  private:
diff --git a/velox/experimental/wave/exec/Vectors.cpp b/velox/experimental/wave/exec/Vectors.cpp
index 1a279055d8110..919c59b03f949 100644
--- a/velox/experimental/wave/exec/Vectors.cpp
+++ b/velox/experimental/wave/exec/Vectors.cpp
@@ -74,7 +74,7 @@ void transferVector(
     std::vector<WaveVectorPtr>& waveVectors,
     std::vector<Operand>& operands,
     GpuArena& arena,
-    int64_t totalBytes) {
+    int64_t& totalBytes) {
   if (waveVectors.size() <= index) {
     waveVectors.resize(index + 1);
   }
@@ -119,18 +119,8 @@ void vectorsToDevice(
     transferVector(
         source[i], i, transfers, waveVectors, operandVector, arena, bytes);
   }
-  auto operands = arena.allocate<Operand>(operandVector.size());
-  memcpy(
-      operands->as<Operand>(),
-      operandVector.data(),
-      operandVector.size() * sizeof(Operand));
-  operandVector.clear();
   Executable::startTransfer(
-      ids,
-      std::move(operands),
-      std::move(waveVectors),
-      std::move(transfers),
-      stream);
+      ids, std::move(waveVectors), std::move(transfers), stream);
 }
 
 // Patches the position 'ofet' in 'code' to be a new uninitialized device
diff --git a/velox/experimental/wave/exec/Wave.cpp b/velox/experimental/wave/exec/Wave.cpp
index 42a409eec05f6..254fc3f358b00 100644
--- a/velox/experimental/wave/exec/Wave.cpp
+++ b/velox/experimental/wave/exec/Wave.cpp
@@ -15,18 +15,150 @@
  */
 
 #include "velox/experimental/wave/exec/Wave.h"
+#include <iostream>
 #include "velox/experimental/wave/exec/Vectors.h"
 
+DEFINE_bool(wave_timing, true, "Enable Wave perf timers");
+DEFINE_bool(
+    wave_print_time,
+    false,
+    "Enables printing times inside PrinTime guard.");
+
+DEFINE_bool(
+    wave_transfer_timing,
+    false,
+    "Enables measuring host to device transfer latency separet "
+    "from wait time for compute");
+
 namespace facebook::velox::wave {
 
+PrintTime::PrintTime(const char* title)
+    : title_(title),
+      start_(FLAGS_wave_print_time ? getCurrentTimeMicro() : 0) {}
+
+PrintTime::~PrintTime() {
+  if (FLAGS_wave_print_time) {
+    std::cout << title_ << "=" << getCurrentTimeMicro() - start_ << std::endl;
+  }
+}
+
+std::string WaveTime::toString() const {
+  if (micros < 20) {
+    return fmt::format("{} ({} clocks)", succinctNanos(micros * 1000), clocks);
+  }
+  return succinctNanos(micros * 1000);
+}
+
+void WaveStats::add(const WaveStats& other) {
+  numWaves += other.numWaves;
+  numKernels += other.numKernels;
+  numThreadBlocks += other.numThreadBlocks;
+  numPrograms += other.numPrograms;
+  numThreads += other.numThreads;
+  numSync += other.numSync;
+  bytesToDevice += other.bytesToDevice;
+  bytesToHost += other.bytesToHost;
+  hostOnlyTime += other.hostOnlyTime;
+  hostParallelTime += other.hostParallelTime;
+  waitTime += other.waitTime;
+  transferWaitTime += other.transferWaitTime;
+  stagingTime += other.stagingTime;
+}
+
+void WaveStats::clear() {
+  new (this) WaveStats();
+}
+
+const SubfieldMap*& threadSubfieldMap() {
+  thread_local const SubfieldMap* subfields;
+  return subfields;
+}
+
+std::string definesToString(const DefinesMap* map) {
+  std::stringstream out;
+  for (const auto& [value, id] : *map) {
+    out
+        << (value.subfield ? value.subfield->toString()
+                           : value.expr->toString(1));
+    out << " = " << id->id << " (" << id->type->toString() << ")" << std::endl;
+  }
+  return out.str();
+}
+
+AbstractOperand* pathToOperand(
+    const DefinesMap& map,
+    std::vector<std::unique_ptr<common::Subfield::PathElement>>& path) {
+  if (path.empty()) {
+    return nullptr;
+  }
+  common::Subfield field(std::move(path));
+  const auto subfieldMap = threadSubfieldMap();
+  auto it = threadSubfieldMap()->find(field.toString());
+  if (it == subfieldMap->end()) {
+    return nullptr;
+  }
+  Value value(it->second.get());
+  auto valueIt = map.find(value);
+  path = std::move(field.path());
+  if (valueIt == map.end()) {
+    return nullptr;
+  }
+  return valueIt->second;
+}
+
+WaveVector* Executable::operandVector(OperandId id) {
+  WaveVectorPtr* ptr = nullptr;
+  if (outputOperands.contains(id)) {
+    auto ordinal = outputOperands.ordinal(id);
+    ptr = &output[ordinal];
+  }
+  if (localOperands.contains(id)) {
+    auto ordinal = localOperands.ordinal(id);
+    ptr = &intermediates[ordinal];
+  }
+  if (*ptr) {
+    return ptr->get();
+  }
+  return nullptr;
+}
+
+WaveVector* Executable::operandVector(OperandId id, const TypePtr& type) {
+  WaveVectorPtr* ptr = nullptr;
+  if (outputOperands.contains(id)) {
+    auto ordinal = outputOperands.ordinal(id);
+    ptr = &output[ordinal];
+  } else if (localOperands.contains(id)) {
+    auto ordinal = localOperands.ordinal(id);
+    ptr = &intermediates[ordinal];
+  } else {
+    VELOX_FAIL("No local/output operand found");
+  }
+  if (*ptr) {
+    return ptr->get();
+  }
+  *ptr = WaveVector::create(type, waveStream->arena());
+  return ptr->get();
+}
+
 WaveStream::~WaveStream() {
-  // TODO: wait for device side work to finish before freeing associated memory
-  // owned by exes and buffers in 'this'.
+  if (!hasError_) {
+    VELOX_CHECK(
+        state_ == State::kHost || state_ == State::kNotRunning,
+        "Bad state at ~WaveStream: {}",
+        static_cast<int32_t>(state_));
+  }
+  for (auto& stream : streams_) {
+    stream->wait();
+  }
   for (auto& exe : executables_) {
     if (exe->releaser) {
       exe->releaser(exe);
     }
   }
+  releaseStreamsAndEvents();
+}
+
+void WaveStream::releaseStreamsAndEvents() {
   for (auto& stream : streams_) {
     releaseStream(std::move(stream));
   }
@@ -34,12 +166,65 @@ WaveStream::~WaveStream() {
     std::unique_ptr<Event> temp(event);
     releaseEvent(std::move(temp));
   }
+  allEvents_.clear();
+  streams_.clear();
+  lastEvent_.clear();
+  hostReturnEvent_ = nullptr;
+  // Conditional nullability will be set by the source.
+  std::fill(operandNullable_.begin(), operandNullable_.end(), true);
+}
+
+void WaveStream::setState(WaveStream::State state) {
+  if (state == state_) {
+    return;
+  }
+  WaveTime nowTime = WaveTime::now();
+  switch (state_) {
+    case State::kNotRunning:
+      break;
+    case State::kHost:
+      stats_.hostOnlyTime += nowTime - start_;
+      break;
+    case State::kParallel:
+      stats_.hostParallelTime += nowTime - start_;
+      break;
+    case State::kWait:
+      stats_.waitTime += nowTime - start_;
+      break;
+  }
+  start_ = nowTime;
+  state_ = state;
+  if (state_ == State::kWait) {
+    ++stats_.numSync;
+  }
 }
 
 std::mutex WaveStream::reserveMutex_;
 std::vector<std::unique_ptr<Stream>> WaveStream::streamsForReuse_;
 std::vector<std::unique_ptr<Event>> WaveStream::eventsForReuse_;
 bool WaveStream::exitInited_{false};
+std::unique_ptr<folly::CPUThreadPoolExecutor> WaveStream::copyExecutor_;
+std::unique_ptr<folly::CPUThreadPoolExecutor> WaveStream::syncExecutor_;
+
+folly::CPUThreadPoolExecutor* WaveStream::copyExecutor() {
+  return getExecutor(copyExecutor_);
+}
+
+folly::CPUThreadPoolExecutor* WaveStream::syncExecutor() {
+  return getExecutor(syncExecutor_);
+}
+
+folly::CPUThreadPoolExecutor* WaveStream::getExecutor(
+    std::unique_ptr<folly::CPUThreadPoolExecutor>& ptr) {
+  if (ptr) {
+    return ptr.get();
+  }
+  std::lock_guard<std::mutex> l(reserveMutex_);
+  if (!ptr) {
+    ptr = std::make_unique<folly::CPUThreadPoolExecutor>(32);
+  }
+  return ptr.get();
+}
 
 Stream* WaveStream::newStream() {
   auto stream = streamFromReserve();
@@ -104,6 +289,62 @@ void WaveStream::releaseEvent(std::unique_ptr<Event>&& event) {
   eventsForReuse_.push_back(std::move(event));
 }
 
+OperatorState* WaveStream::operatorState(int32_t id) {
+  auto it = taskStateMap_->states.find(id);
+  if (it != taskStateMap_->states.end()) {
+    return it->second.get();
+  }
+  return nullptr;
+}
+
+OperatorState* WaveStream::newState(ProgramState& init) {
+  auto stateShared = init.create(*this);
+  taskStateMap_->states[init.stateId] = stateShared;
+  return stateShared.get();
+}
+
+void WaveStream::markHostOutputOperand(const AbstractOperand& op) {
+  hostOutputOperands_.add(op.id);
+  auto nullable = isNullable(op);
+  auto alignment = WaveVector::alignment(op.type);
+  hostReturnSize_ = bits::roundUp(hostReturnSize_, alignment);
+  hostReturnSize_ += WaveVector::backingSize(op.type, numRows_, nullable);
+}
+
+void WaveStream::setReturnData(bool needStatus) {
+  if (!needStatus && hostReturnSize_ == 0) {
+    return;
+  }
+}
+
+void WaveStream::resultToHost() {
+  if (!hostReturnEvent_) {
+    hostReturnEvent_ = newEvent();
+  }
+  auto numBlocks = bits::roundUp(numRows_, kBlockSize) / kBlockSize;
+  int32_t statusBytes = bits::roundUp(sizeof(BlockStatus) * numBlocks, 8) +
+      instructionStatusSize(instructionStatus_, numBlocks);
+  if (!hostBlockStatus_ || hostBlockStatus_->size() < statusBytes) {
+    hostBlockStatus_ = getSmallTransferArena().allocate<char>(statusBytes);
+  }
+  Stream* transferStream = streams_[0].get();
+  if (streams_.size() > 1) {
+    // If many events, queue up the transfer on the first after
+    for (auto i = 1; i < streams_.size(); ++i) {
+      lastEvent_[i]->wait(*transferStream);
+    }
+  }
+  if (hostReturnDataUsed_ > 0) {
+    transferStream->deviceToHostAsync(
+        hostReturnData_->as<char>(),
+        deviceReturnData_->as<char>(),
+        hostReturnDataUsed_);
+  }
+  transferStream->deviceToHostAsync(
+      hostBlockStatus_->as<char>(), deviceBlockStatus_, statusBytes);
+  hostReturnEvent_->record(*transferStream);
+}
+
 namespace {
 // Copies from pageable host to unified address. Multithreaded memcpy is
 // probably best.
@@ -117,17 +358,20 @@ void copyData(std::vector<Transfer>& transfers) {
 
 void Executable::startTransfer(
     OperandSet outputOperands,
-    WaveBufferPtr&& operands,
     std::vector<WaveVectorPtr>&& outputVectors,
     std::vector<Transfer>&& transfers,
     WaveStream& waveStream) {
   auto exe = std::make_unique<Executable>();
+  auto numBlocks = bits::roundUp(waveStream.numRows(), kBlockSize) / kBlockSize;
+  exe->waveStream = &waveStream;
   exe->outputOperands = outputOperands;
+  WaveStream::ExeLaunchInfo info;
+  waveStream.exeLaunchInfo(*exe, numBlocks, info);
   exe->output = std::move(outputVectors);
   exe->transfers = std::move(transfers);
-  exe->deviceData.push_back(operands);
-  exe->operands = operands->as<Operand>();
-  exe->outputOperands = outputOperands;
+  exe->deviceData.push_back(waveStream.arena().allocate<char>(info.totalBytes));
+  auto start = exe->deviceData[0]->as<char>();
+  exe->operands = waveStream.fillOperands(*exe, start, info)[0];
   copyData(exe->transfers);
   auto* device = waveStream.device();
   waveStream.installExecutables(
@@ -135,11 +379,26 @@ void Executable::startTransfer(
       [&](Stream* stream, folly::Range<Executable**> executables) {
         for (auto& transfer : executables[0]->transfers) {
           stream->prefetch(device, transfer.to, transfer.size);
+          waveStream.stats().bytesToDevice += transfer.size;
         }
         waveStream.markLaunch(*stream, *executables[0]);
       });
 }
 
+std::unique_ptr<Executable> WaveStream::recycleExecutable(
+    Program* program,
+    int32_t numRows) {
+  for (auto i = 0; i < executables_.size(); ++i) {
+    if (executables_[i]->programShared.get() == program) {
+      auto result = std::move(executables_[i]);
+      result->stream = nullptr;
+      executables_.erase(executables_.begin() + i);
+      return result;
+    }
+  }
+  return nullptr;
+}
+
 void WaveStream::installExecutables(
     folly::Range<std::unique_ptr<Executable>*> executables,
     std::function<void(Stream*, folly::Range<Executable**>)> launch) {
@@ -152,6 +411,7 @@ void WaveStream::installExecutables(
   for (auto& exeUnique : executables) {
     executables_.push_back(std::move(exeUnique));
     auto exe = executables_.back().get();
+    exe->waveStream = this;
     VELOX_CHECK(exe->stream == nullptr);
     OperandSet streamSet;
     exe->inputOperands.forEach([&](int32_t id) {
@@ -166,22 +426,44 @@ void WaveStream::installExecutables(
     });
     dependences[streamSet].push_back(exe);
     exe->outputOperands.forEach([&](int32_t id) {
-      VELOX_CHECK_EQ(0, operandToExecutable_.count(id));
+      // The stream may have the same or different exe in place from a previous
+      // launch.
       operandToExecutable_[id] = exe;
     });
   }
 
   // exes with no dependences go on a new stream. Streams with dependent compute
-  // get an event. The dependent computes ggo on new streams that first wait for
+  // get an event. The dependent computes go on new streams that first wait for
   // the events.
   folly::F14FastMap<int32_t, Event*> streamEvents;
   for (auto& [ids, exeVector] : dependences) {
     folly::Range<Executable**> exes(exeVector.data(), exeVector.size());
     std::vector<Stream*> required;
     ids.forEach([&](int32_t id) { required.push_back(streams_[id].get()); });
+    if (required.size() == 1) {
+      launch(required[0], exes);
+      continue;
+    }
     if (required.empty()) {
-      auto stream = newStream();
+      Stream* stream = nullptr;
+      Event* event = nullptr;
+      for (auto i = 0; i < streams_.size(); ++i) {
+        if (Stream* candidate = streams_[i].get()) {
+          VELOX_CHECK_GT(lastEvent_.size(), i);
+          if (!lastEvent_[i] || lastEvent_[i]->query()) {
+            stream = candidate;
+            event = lastEvent_[i];
+            break;
+          }
+        }
+      }
+      if (!stream) {
+        stream = newStream();
+      }
       launch(stream, exes);
+      if (event) {
+        event->record(*stream);
+      }
     } else {
       for (auto* req : required) {
         auto id = reinterpret_cast<uintptr_t>(req->userData());
@@ -204,9 +486,16 @@ bool WaveStream::isArrived(
     int32_t sleepMicro,
     int32_t timeoutMicro) {
   OperandSet waitSet;
+  if (hostReturnEvent_) {
+    bool done = hostReturnEvent_->query();
+    if (done) {
+      releaseStreamsAndEvents();
+    }
+    return done;
+  }
   ids.forEach([&](int32_t id) {
     auto exe = operandToExecutable_[id];
-    VELOX_CHECK_NOT_NULL(exe);
+    VELOX_CHECK_NOT_NULL(exe, "No exe produces operand {} in stream", id);
     if (!exe->stream) {
       return;
     }
@@ -221,6 +510,7 @@ bool WaveStream::isArrived(
     waitSet.add(streamId);
   });
   if (waitSet.empty()) {
+    releaseStreamsAndEvents();
     return true;
   }
   if (sleepMicro == -1) {
@@ -236,6 +526,7 @@ bool WaveStream::isArrived(
       }
     });
     if (ready) {
+      releaseStreamsAndEvents();
       return true;
     }
     std::this_thread::sleep_for(std::chrono::microseconds(sleepMicro));
@@ -244,202 +535,706 @@ bool WaveStream::isArrived(
   return false;
 }
 
-template <typename T, typename U>
-T addBytes(U* p, int32_t bytes) {
-  return reinterpret_cast<T>(reinterpret_cast<uintptr_t>(p) + bytes);
+void WaveStream::ensureVector(
+    const AbstractOperand& op,
+    WaveVectorPtr& vector,
+    int32_t numRows) {
+  if (!vector) {
+    vector = std::make_unique<WaveVector>(op.type, arena());
+  }
+  bool nullable = isNullable(op);
+  if (false /*hostOutputOperands_.contains(op.id)*/) {
+    VELOX_NYI();
+  } else {
+    vector->resize(numRows < 0 ? numRows_ : numRows, nullable);
+  }
+}
+
+bool WaveStream::isNullable(const AbstractOperand& op) const {
+  bool notNull = op.notNull;
+  if (!notNull) {
+    if (op.sourceNullable) {
+      notNull = !operandNullable_[op.id];
+    } else {
+      notNull = true;
+      for (auto i : op.nullableIf) {
+        if (operandNullable_[i]) {
+          notNull = false;
+          break;
+        }
+      }
+    }
+  }
+  return !notNull;
+}
+
+void WaveStream::exeLaunchInfo(
+    Executable& exe,
+    int32_t numBlocks,
+    ExeLaunchInfo& info) {
+  // The exe has an Operand* for each input/local/output/literal
+  // op. It has an Operand for each local/output/literal op. It has
+  // an array of numBlock int32_t*'s for every distinct wrapAt in
+  // its local/output operands where the wrapAt does not occur in
+  // any of the input Operands.
+  info.numBlocks = numBlocks;
+  info.numInput = exe.inputOperands.size();
+  exe.inputOperands.forEach([&](auto id) {
+    auto op = operandAt(id);
+    auto* inputExe = operandExecutable(op->id);
+    if (op->wrappedAt != AbstractOperand::kNoWrap) {
+      auto* indices = inputExe->wraps[op->wrappedAt];
+      VELOX_CHECK_NOT_NULL(indices);
+      info.inputWrap[op->wrappedAt] = indices;
+    }
+  });
+
+  exe.localOperands.forEach([&](auto id) {
+    auto op = operandAt(id);
+    if (op->wrappedAt != AbstractOperand::kNoWrap) {
+      if (info.inputWrap.find(id) == info.inputWrap.end()) {
+        if (info.localWrap.find(op->wrappedAt) == info.localWrap.end()) {
+          info.localWrap[op->wrappedAt] = reinterpret_cast<int32_t**>(
+              info.localWrap.size() * numBlocks * sizeof(void*));
+        }
+      }
+    }
+  });
+  exe.outputOperands.forEach([&](auto id) {
+    auto op = operandAt(id);
+    if (op->wrappedAt != AbstractOperand::kNoWrap) {
+      if (info.inputWrap.find(id) == info.inputWrap.end()) {
+        if (info.localWrap.find(op->wrappedAt) == info.localWrap.end()) {
+          info.localWrap[op->wrappedAt] = reinterpret_cast<int32_t**>(
+              info.localWrap.size() * numBlocks * sizeof(void*));
+        }
+      }
+    }
+  });
+  auto numLiteral = exe.literals ? exe.literals->size() : 0;
+  info.numLocalOps =
+      exe.localOperands.size() + exe.outputOperands.size() + numLiteral;
+  info.totalBytes =
+      // Pointer to Operand for input and local Operands.
+      sizeof(void*) * (info.numLocalOps + exe.inputOperands.size()) +
+      // Flat array of Operand for all but input.
+      sizeof(Operand) * info.numLocalOps +
+      // Space for the 'indices' for each distinct wrappedAt.
+      (info.localWrap.size() * numBlocks * sizeof(void*));
+  if (exe.programShared) {
+    exe.programShared->getOperatorStates(*this, info.operatorStates);
+  }
+}
+
+Operand**
+WaveStream::fillOperands(Executable& exe, char* start, ExeLaunchInfo& info) {
+  Operand** operandPtrBegin = addBytes<Operand**>(start, 0);
+  exe.inputOperands.forEach([&](int32_t id) {
+    auto* inputExe = operandToExecutable_[id];
+    int32_t ordinal = inputExe->outputOperands.ordinal(id);
+    *operandPtrBegin =
+        &inputExe->operands[inputExe->firstOutputOperandIdx + ordinal];
+    ++operandPtrBegin;
+  });
+  Operand* operandBegin = addBytes<Operand*>(
+      start, (info.numInput + info.numLocalOps) * sizeof(void*));
+  VELOX_CHECK_EQ(0, reinterpret_cast<uintptr_t>(operandBegin) & 7);
+  int32_t* indicesBegin =
+      addBytes<int32_t*>(operandBegin, info.numLocalOps * sizeof(Operand));
+  for (auto& [id, ptr] : info.localWrap) {
+    info.localWrap[id] =
+        addBytes<int32_t**>(indicesBegin, reinterpret_cast<int64_t>(ptr));
+  }
+  exe.wraps = std::move(info.localWrap);
+  for (auto& [id, ptr] : info.inputWrap) {
+    exe.wraps[id] = ptr;
+  }
+  exe.intermediates.resize(exe.localOperands.size());
+  int32_t fill = 0;
+  exe.localOperands.forEach([&](auto id) {
+    auto op = operandAt(id);
+    ensureVector(*op, exe.intermediates[fill]);
+    auto vec = exe.intermediates[fill].get();
+    ++fill;
+    vec->toOperand(operandBegin);
+    if (op->wrappedAt != AbstractOperand::kNoWrap) {
+      operandBegin->indices = exe.wraps[op->wrappedAt];
+      VELOX_CHECK_NOT_NULL(operandBegin->indices);
+    }
+    *operandPtrBegin = operandBegin;
+    ++operandPtrBegin;
+    ++operandBegin;
+  });
+  exe.firstOutputOperandIdx = exe.intermediates.size();
+  exe.output.resize(exe.outputOperands.size());
+  fill = 0;
+  exe.outputOperands.forEach([&](auto id) {
+    auto op = operandAt(id);
+    ensureVector(*op, exe.output[fill]);
+    auto vec = exe.output[fill].get();
+    ++fill;
+    vec->toOperand(operandBegin);
+    if (op->wrappedAt != AbstractOperand::kNoWrap) {
+      operandBegin->indices = exe.wraps[op->wrappedAt];
+      VELOX_CHECK_NOT_NULL(operandBegin->indices);
+    }
+    *operandPtrBegin = operandBegin;
+    ++operandPtrBegin;
+    ++operandBegin;
+  });
+
+  auto numConstants = exe.literals ? exe.literals->size() : 0;
+  if (numConstants) {
+    memcpy(operandBegin, exe.literals->data(), numConstants * sizeof(Operand));
+    for (auto i = 0; i < numConstants; ++i) {
+      *operandPtrBegin = operandBegin;
+      ++operandPtrBegin;
+      ++operandBegin;
+    }
+  }
+
+  return addBytes<Operand**>(start, 0);
+}
+
+void WaveStream::setLaunchControl(
+    int32_t key,
+    int32_t nth,
+    std::unique_ptr<LaunchControl> control) {
+  if (key == 0 && nth == 0) {
+    deviceBlockStatus_ = control->params.status;
+  }
+  auto& controls = launchControl_[key];
+  if (controls.size() <= nth) {
+    controls.resize(nth + 1);
+  }
+  controls[nth] = std::move(control);
 }
 
 LaunchControl* WaveStream::prepareProgramLaunch(
     int32_t key,
+    int32_t nthLaunch,
     int32_t inputRows,
     folly::Range<Executable**> exes,
     int32_t blocksPerExe,
-    bool initStatus,
+    const LaunchControl* inputControl,
     Stream* stream) {
   static_assert(Operand::kPointersInOperand * sizeof(void*) == sizeof(Operand));
-  int32_t shared = 0;
+  auto& controlVector = launchControl_[key];
+  LaunchControl* controlPtr;
+  if (controlVector.size() > nthLaunch) {
+    controlPtr = controlVector[nthLaunch].get();
+  } else {
+    controlVector.resize(nthLaunch + 1);
+    controlVector[nthLaunch] = std::make_unique<LaunchControl>(key, inputRows);
+    controlPtr = controlVector[nthLaunch].get();
+  }
+  bool isContinue = false;
+  auto& control = *controlPtr;
+  if (control.programInfo.empty()) {
+    control.programInfo.resize(exes.size());
+  } else {
+    VELOX_CHECK_EQ(exes.size(), control.programInfo.size());
+    for (auto& info : control.programInfo) {
+      if (info.advance.isRetry) {
+        isContinue = true;
+        break;
+      }
+    }
+  }
+  if (isContinue) {
+    VELOX_CHECK_EQ(-1, inputRows);
+  } else {
+    VELOX_CHECK_LT(0, inputRows);
+    numRows_ = inputRows;
+  }
 
-  //  First calculate total size.
   // 2 int arrays: blockBase, programIdx.
-  int32_t numBlocks = std::min<int32_t>(1, exes.size()) * blocksPerExe;
+  int32_t numBlocks = std::max<int32_t>(1, exes.size()) * blocksPerExe;
   int32_t size = 2 * numBlocks * sizeof(int32_t);
+  std::vector<ExeLaunchInfo> info(exes.size());
   auto exeOffset = size;
-  // 2 pointers per exe: TB program and start of its param array.
-  size += exes.size() * sizeof(void*) * 2;
+  // 2 pointers per exe: TB program and start of its param array and 1 int for
+  // start PC. Round to 3 for alignment.
+  size += exes.size() * sizeof(void*) * 3;
   auto operandOffset = size;
-  // Exe dependent sizes for parameters.
-  int32_t numTotalOps = 0;
-  for (auto& exe : exes) {
-    markLaunch(*stream, *exe);
-    shared = std::max(shared, exe->programShared->sharedMemorySize());
-    int32_t numIn = exe->inputOperands.size();
-    int numOps = numIn + exe->intermediates.size() + exe->outputOperands.size();
-    numTotalOps += numOps;
-    size += numOps * sizeof(void*) + (numOps - numIn) * sizeof(Operand);
+  // Exe dependent sizes for operands.
+  int32_t operandBytes = 0;
+  int32_t operatorStateBytes = 0;
+  int32_t shared = 0;
+  for (auto i = 0; i < exes.size(); ++i) {
+    exeLaunchInfo(*exes[i], numBlocks, info[i]);
+    operandBytes += info[i].totalBytes;
+    markLaunch(*stream, *exes[i]);
+    shared = std::max(shared, exes[i]->programShared->sharedMemorySize());
+    operatorStateBytes += info[i].operatorStates.size() * sizeof(void*);
   }
+  size += operandBytes;
   int32_t statusOffset = 0;
-  if (initStatus) {
+  if (!inputControl) {
     statusOffset = size;
     //  Pointer to return block for each tB.
-    size += blocksPerExe * sizeof(BlockStatus);
+    size += bits::roundUp(blocksPerExe * sizeof(BlockStatus), 8);
+    size += bits::roundUp(
+        instructionStatus_.gridStateSize +
+            instructionStatus_.blockState * numBlocks,
+        8);
   }
+  // 1 pointer per exe and an exe-dependent data area.
+  int32_t operatorStateOffset = size;
+  size += exes.size() * sizeof(void*) + operatorStateBytes;
   auto buffer = arena_.allocate<char>(size);
+  if (stream) {
+    stream->prefetch(nullptr, buffer->as<char>(), buffer->size());
+  }
+  // Zero initialization is expected, for example for operands and arrays in
+  // Operand::indices.
+  memset(buffer->as<char>(), 0, size);
 
-  auto controlUnique = std::make_unique<LaunchControl>();
-  auto& control = *controlUnique;
-
-  control.key = key;
-  control.inputRows = inputRows;
   control.sharedMemorySize = shared;
   // Now we fill in the various arrays and put their start addresses in
   // 'control'.
   auto start = buffer->as<int32_t>();
-  control.blockBase = start;
-  control.programIdx = start + numBlocks;
-  control.programs = addBytes<ThreadBlockProgram**>(
-      control.programIdx, numBlocks * sizeof(int32_t));
-  control.operands =
-      addBytes<Operand***>(control.programs, exes.size() * sizeof(void*));
-  int32_t fill = 0;
-  Operand** operandPtrBegin = addBytes<Operand**>(start, operandOffset);
-  Operand* operandArrayBegin =
-      addBytes<Operand*>(operandPtrBegin, numTotalOps * sizeof(void*));
-  if (initStatus) {
+  control.params.blockBase = start;
+  control.params.programIdx = start + numBlocks;
+  control.params.programs = addBytes<ThreadBlockProgram**>(
+      control.params.programIdx, numBlocks * sizeof(int32_t));
+  control.params.operands = addBytes<Operand***>(
+      control.params.programs, exes.size() * sizeof(void*));
+  control.params.startPC = isContinue
+      ? addBytes<int32_t*>(control.params.operands, exes.size() * sizeof(void*))
+      : nullptr;
+
+  if (!inputControl) {
     // If the launch produces new statuses (as opposed to updating status of a
     // previous launch), there is an array with a status for each TB. If there
     // are multiple exes, they all share the same error codes. A launch can have
     // a single cardinality change, which will update the row counts in each TB.
     // Writing errors is not serialized but each lane with at least one error
     // will show one error.
-    control.status = addBytes<BlockStatus*>(start, statusOffset);
-    memset(control.status, 0, blocksPerExe * sizeof(BlockStatus));
+    control.params.status = addBytes<BlockStatus*>(start, statusOffset);
+    // Memory is already set to all 0.
     for (auto i = 0; i < blocksPerExe; ++i) {
-      auto status = &control.status[i];
+      auto status = &control.params.status[i];
+      deviceBlockStatus_ = status;
       status->numRows =
           i == blocksPerExe - 1 ? inputRows % kBlockSize : kBlockSize;
     }
   } else {
-    control.status = nullptr;
-  }
-  for (auto exeIdx = 0; exeIdx < exes.size(); ++exeIdx) {
-    auto exe = exes[exeIdx];
-    int32_t numIn = exe->inputOperands.size();
-    int32_t numLocal = exe->intermediates.size() + exe->outputOperands.size();
-    control.programs[exeIdx] = exe->program;
-    control.operands[exeIdx] = operandPtrBegin;
-    // We get the actual input operands for the exe from the exes this depends
-    // on
-    exe->inputOperands.forEach([&](int32_t id) {
-      auto* inputExe = operandToExecutable_[id];
-      int32_t ordinal = inputExe->outputOperands.ordinal(id);
-      *operandPtrBegin = &inputExe->operands[ordinal];
-      ++operandPtrBegin;
-    });
-    // We install the intermediates and outputs from the WaveVectors in the exe.
-    exe->operands = operandArrayBegin;
-    for (auto& vec : exe->intermediates) {
-      *operandPtrBegin = operandArrayBegin;
-      vec->toOperand(operandArrayBegin);
-      ++operandPtrBegin;
-      ++operandArrayBegin;
-    }
-    for (auto& vec : exe->output) {
-      *operandPtrBegin = operandArrayBegin;
-      vec->toOperand(operandArrayBegin);
-      ++operandPtrBegin;
-      ++operandArrayBegin;
+    control.params.status = inputControl->params.status;
+  }
+  char* operandStart = addBytes<char*>(start, operandOffset);
+  VELOX_CHECK_EQ(0, reinterpret_cast<uintptr_t>(operandStart) & 7);
+  int32_t fill = 0;
+  for (auto i = 0; i < exes.size(); ++i) {
+    control.params.programs[i] = exes[i]->program;
+    if (isContinue) {
+      control.params.startPC[i] = control.programInfo[i].advance.instructionIdx;
     }
+    auto operandPtrs = fillOperands(*exes[i], operandStart, info[i]);
+    control.params.operands[i] = operandPtrs;
+    // The operands defined by the exe start after the input operands and are
+    // all consecutive.
+    exes[i]->operands = operandPtrs[exes[i]->inputOperands.size()];
+    operandStart += info[i].totalBytes;
     for (auto tbIdx = 0; tbIdx < blocksPerExe; ++tbIdx) {
-      control.blockBase[fill] = exeIdx * blocksPerExe;
-      control.programIdx[fill] = exeIdx;
+      control.params.blockBase[fill] = i * blocksPerExe;
+      control.params.programIdx[fill] = i;
+      ++fill;
     }
   }
+
+  // Fill in operator states, e.g. hash tables.
+  void** operatorStatePtrs = addBytes<void**>(start, operatorStateOffset);
+  control.params.operatorStates = reinterpret_cast<void***>(operatorStatePtrs);
+  auto stateFill = operatorStatePtrs + info.size();
+  for (auto i = 0; i < info.size(); ++i) {
+    operatorStatePtrs[i] = stateFill;
+    auto& ptrs = info[i].operatorStates;
+    for (auto j = 0; j < ptrs.size(); ++j) {
+      *stateFill = ptrs[j];
+      ++stateFill;
+    }
+  }
+  if (!exes.empty()) {
+    ++stats_.numKernels;
+  }
+
+  stats_.numPrograms += exes.size();
+  stats_.numThreadBlocks += blocksPerExe * exes.size();
+  stats_.numThreads += numRows_ * exes.size();
+
   control.deviceData = std::move(buffer);
-  launchControl_[key].push_back(std::move(controlUnique));
   return &control;
 }
 
-ScalarType typeKindCode(TypeKind kind) {
-  switch (kind) {
-    case TypeKind::BIGINT:
-      return ScalarType::kInt64;
-    default:
-      VELOX_UNSUPPORTED("Bad TypeKind {}", kind);
+int32_t WaveStream::getOutput(
+    int32_t operatorId,
+    memory::MemoryPool& pool,
+    folly::Range<const OperandId*> operands,
+    VectorPtr* vectors) {
+  auto it = launchControl_.find(operatorId);
+  VELOX_CHECK(it != launchControl_.end());
+  auto* control = it->second[0].get();
+  auto* status = control->params.status;
+  auto numBlocks = bits::roundUp(numRows_, kBlockSize) / kBlockSize;
+  if (operands.empty()) {
+    return statusNumRows(status, numBlocks);
+  }
+  for (auto i = 0; i < operands.size(); ++i) {
+    auto id = operands[i];
+    auto exe = operandExecutable(id);
+    VELOX_CHECK_NOT_NULL(exe);
+    auto ordinal = exe->outputOperands.ordinal(id);
+    auto waveVectorPtr = &exe->output[ordinal];
+    if (!waveVectorPtr->get()) {
+      exe->ensureLazyArrived(operands);
+      VELOX_CHECK_NOT_NULL(
+          waveVectorPtr->get(), "Lazy load should have filled in the result");
+    }
+    vectors[i] = waveVectorPtr->get()->toVelox(
+        &pool,
+        numBlocks,
+        status,
+        &exe->operands[exe->firstOutputOperandIdx + ordinal]);
+  }
+  return vectors[0]->size();
+}
+
+void WaveStream::makeAggregate(
+    AbstractAggregation& inst,
+    AggregateOperatorState& state) {
+  VELOX_CHECK(inst.keys.empty());
+  int32_t size = inst.rowSize();
+  auto stream = streamFromReserve();
+  auto buffer = arena_.allocate<char>(size + sizeof(DeviceAggregation));
+  state.buffers.push_back(buffer);
+  AggregationControl control;
+  control.head = buffer->as<char>();
+  control.headSize = buffer->size();
+  control.rowSize = size;
+  reinterpret_cast<WaveKernelStream*>(stream.get())->setupAggregation(control);
+  releaseStream(std::move(stream));
+}
+
+std::string WaveStream::toString() const {
+  std::stringstream out;
+  out << "{WaveStream ";
+  for (auto& exe : executables_) {
+    out << exe->toString() << std::endl;
+  }
+  out << "}";
+  if (hostReturnEvent_) {
+    out << fmt::format("hostReturnEvent={}", hostReturnEvent_->query())
+        << std::endl;
+  }
+  for (auto i = 0; i < streams_.size(); ++i) {
+    out << fmt::format(
+        "stream {} {}, ",
+        streams_[i]->userData(),
+        lastEvent_[i] ? fmt::format("event={}", lastEvent_[i]->query())
+                      : fmt::format("no event"));
+  }
+  return out.str();
+}
+
+WaveTypeKind typeKindCode(TypeKind kind) {
+  return static_cast<WaveTypeKind>(kind);
+}
+
+void Program::getOperatorStates(WaveStream& stream, std::vector<void*>& ptrs) {
+  ptrs.resize(operatorStates_.size());
+  for (auto i = 0; i < operatorStates_.size(); ++i) {
+    auto& operatorState = *operatorStates_[i];
+    auto* state = stream.operatorState(operatorState.stateId);
+    if (!state) {
+      VELOX_CHECK_NOT_NULL(operatorState.create);
+      state = stream.newState(operatorState);
+    }
+    ptrs[i] = state->buffers[0]->as<char>();
   }
 }
 
+bool Program::isSink() const {
+  int32_t size = instructions_.size();
+  if (instructions_[size - 1]->opCode == OpCode::kReturn) {
+    VELOX_CHECK_GE(size, 2);
+    return instructions_[size - 2]->isSink();
+  }
+  return instructions_[size - 1]->isSink();
+}
+
+AdvanceResult Program::canAdvance(
+    WaveStream& stream,
+    LaunchControl* control,
+    int32_t programIdx) {
+  for (int32_t i = instructions_.size() - 1; i >= 0; --i) {
+    auto* instruction = instructions_[i].get();
+    OperatorState* state = nullptr;
+    auto stateId = instruction->stateId();
+    if (stateId.has_value()) {
+      state = stream.operatorState(stateId.value());
+    }
+    auto result = instruction->canAdvance(stream, control, state, programIdx);
+    if (!result.empty()) {
+      return result;
+    }
+  }
+  return {};
+}
+
+#define IN_HEAD(abstract, physical, _op)             \
+  auto* abstractInst = &instruction->as<abstract>(); \
+  space->opCode = _op;                               \
+  auto physicalInst = new (&space->_) physical();
+
+#define IN_OPERAND(member) \
+  physicalInst->member = operandIndex(abstractInst->member)
+
 void Program::prepareForDevice(GpuArena& arena) {
-  int32_t codeSize = 0;
-  int32_t sharedMemorySize = 0;
+  VELOX_CHECK(!instructions_.empty());
+  if (instructions_.back()->opCode != OpCode::kReturn) {
+    instructions_.push_back(std::make_unique<AbstractReturn>());
+  }
+  int32_t codeSize = sizeof(Instruction) * instructions_.size();
   for (auto& instruction : instructions_)
     switch (instruction->opCode) {
-      case OpCode::kPlus: {
+      case OpCode::kFilter: {
+        auto& filter = instruction->as<AbstractFilter>();
+        markInput(filter.flags);
+        markResult(filter.indices);
+
+        break;
+      }
+      case OpCode::kWrap: {
+        auto& wrap = instruction->as<AbstractWrap>();
+        markInput(wrap.indices);
+        std::vector<OperandIndex> indices(wrap.target.size());
+        wrap.literalOffset = addLiteral(indices.data(), indices.size());
+        for (auto i = 0; i < wrap.target.size(); ++i) {
+          auto target = wrap.target[i];
+          markInput(wrap.source[i]);
+          if (target != wrap.source[i]) {
+            markResult(target);
+          }
+        }
+        break;
+      }
+      case OpCode::kPlus_BIGINT:
+      case OpCode::kLT_BIGINT: {
         auto& bin = instruction->as<AbstractBinary>();
         markInput(bin.left);
         markInput(bin.right);
         markResult(bin.result);
         markInput(bin.predicate);
-        codeSize += sizeof(Instruction);
+        break;
+      }
+      case OpCode::kNegate: {
+        auto& un = instruction->as<AbstractUnary>();
+        markInput(un.input);
+        markResult(un.result);
+        markInput(un.predicate);
+        break;
+      }
+      case OpCode::kReturn:
+        break;
+      case OpCode::kAggregate: {
+        auto& agg = instruction->as<AbstractAggregation>();
+        for (auto& key : agg.keys) {
+          markInput(key);
+        }
+        // The literal area has first IUpdateAggs and then Operandindex's for
+        // the keys.
+        int32_t extra =
+            bits::roundUp(
+                agg.keys.size() * sizeof(OperandIndex), sizeof(IUpdateAgg)) /
+            sizeof(IUpdateAgg);
+        std::vector<IUpdateAgg> temp(agg.aggregates.size() + extra);
+        agg.literalOffset = addLiteral(temp.data(), temp.size());
+        agg.literalBytes = temp.size() * sizeof(IUpdateAgg);
+        for (auto& op : agg.aggregates) {
+          for (auto& arg : op.args) {
+            markInput(arg);
+          }
+        }
+        break;
+      }
+      case OpCode::kReadAggregate: {
+        auto& read = instruction->as<AbstractReadAggregation>();
+        auto& agg = *read.aggregation;
+        for (auto& key : agg.keys) {
+          markResult(key);
+        }
+        // The literal area is like in the aggregation.
+        int32_t extra = agg.literalBytes;
+        std::vector<IUpdateAgg> temp(extra / sizeof(IUpdateAgg));
+        read.literalOffset = addLiteral(temp.data(), temp.size());
+        for (auto& key : agg.keys) {
+          markResult(key);
+        }
+        for (auto& op : agg.aggregates) {
+          markResult(op.result);
+        }
         break;
       }
       default:
-        VELOX_UNSUPPORTED("OpCode {}", instruction->opCode);
+        VELOX_UNSUPPORTED(
+            "OpCode {}", static_cast<int32_t>(instruction->opCode));
     }
   sortSlots();
   arena_ = &arena;
   deviceData_ = arena.allocate<char>(
-      codeSize + instructions_.size() * sizeof(void*) +
-      sizeof(ThreadBlockProgram));
+      codeSize + literalArea_.size() + sizeof(ThreadBlockProgram));
+  uintptr_t end = reinterpret_cast<uintptr_t>(
+      deviceData_->as<char>() + deviceData_->size());
   program_ = deviceData_->as<ThreadBlockProgram>();
-  auto instructionArray = addBytes<Instruction**>(program_, sizeof(*program_));
-  program_->sharedMemorySize = sharedMemorySize;
+  auto instructionArray = addBytes<Instruction*>(program_, sizeof(*program_));
   program_->numInstructions = instructions_.size();
   program_->instructions = instructionArray;
-  Instruction* space = addBytes<Instruction*>(
-      instructionArray, instructions_.size() * sizeof(void*));
+  Instruction* space = instructionArray;
+  deviceLiterals_ = reinterpret_cast<char*>(space) +
+      sizeof(Instruction) * instructions_.size();
+  VELOX_CHECK_LE(
+      reinterpret_cast<uintptr_t>(deviceLiterals_) + literalArea_.size(), end);
+  memcpy(deviceLiterals_, literalArea_.data(), literalArea_.size());
+
   for (auto& instruction : instructions_) {
-    *instructionArray = space;
-    ++instructionArray;
     switch (instruction->opCode) {
-      case OpCode::kPlus: {
-        auto& bin = instruction->as<AbstractBinary>();
-        auto typeCode = typeKindCode(bin.left->type->kind());
-        // Comstructed on host, no vtable.
-        space->opCode = OP_MIX(instruction->opCode, typeCode);
-        new (&space->_.binary) IBinary();
-        space->_.binary.left = operandIndex(bin.left);
-        space->_.binary.right = operandIndex(bin.right);
-        space->_.binary.result = operandIndex(bin.result);
-        ++space;
+      case OpCode::kPlus_BIGINT:
+      case OpCode::kLT_BIGINT: {
+        IN_HEAD(AbstractBinary, IBinary, instruction->opCode)
+
+        IN_OPERAND(left);
+        IN_OPERAND(right);
+        IN_OPERAND(result);
+        IN_OPERAND(predicate);
+        break;
+      }
+      case OpCode::kFilter: {
+        IN_HEAD(AbstractFilter, IFilter, OpCode::kFilter);
+        IN_OPERAND(flags);
+        IN_OPERAND(indices);
+        break;
+      }
+      case OpCode::kWrap: {
+        IN_HEAD(AbstractWrap, IWrap, OpCode::kWrap);
+        IN_OPERAND(indices);
+        physicalInst->numColumns = abstractInst->source.size();
+        physicalInst->columns = reinterpret_cast<OperandIndex*>(
+            deviceLiterals_ + abstractInst->literalOffset);
+        for (auto i = 0; i < abstractInst->source.size(); ++i) {
+          physicalInst->columns[i] = operandIndex(abstractInst->source[i]);
+        }
+        break;
+      }
+      case OpCode::kAggregate: {
+        IN_HEAD(AbstractAggregation, IAggregate, OpCode::kAggregate);
+
+        physicalInst->numKeys = abstractInst->keys.size();
+        physicalInst->numAggregates = abstractInst->aggregates.size();
+        physicalInst->stateIndex = operatorStates_.size();
+        auto programState = std::make_unique<ProgramState>();
+        programState->stateId = abstractInst->state->id;
+        programState->isGlobal = true;
+        programState->create =
+            [inst = abstractInst](
+                WaveStream& stream) -> std::shared_ptr<OperatorState> {
+          auto newState = std::make_shared<AggregateOperatorState>();
+          newState->instruction = inst;
+          stream.makeAggregate(*inst, *newState);
+          return newState;
+        };
+        operatorStates_.push_back(std::move(programState));
+        physicalInst->status = abstractInst->instructionStatus;
+        physicalInst->aggregates = reinterpret_cast<IUpdateAgg*>(
+            deviceLiterals_ + abstractInst->literalOffset);
+        // the literal is copied when making the reader for aggregates.
+        abstractInst->literal = physicalInst->aggregates;
+        OperandIndex* keys = reinterpret_cast<OperandIndex*>(
+            physicalInst->aggregates + physicalInst->numAggregates);
+        for (auto i = 0; i < abstractInst->keys.size(); ++i) {
+          keys[i] = operandIndex(abstractInst->keys[i]);
+        }
+        for (auto i = 0; i < abstractInst->aggregates.size(); ++i) {
+          auto physicalAgg = physicalInst->aggregates + i;
+          auto& abstractAgg = abstractInst->aggregates[i];
+          physicalAgg->op = abstractAgg.op;
+          physicalAgg->nullOffset = abstractAgg.nullOffset;
+          physicalAgg->accumulatorOffset = abstractAgg.accumulatorOffset;
+          if (abstractAgg.args.size() > 0) {
+            physicalAgg->arg1 = operandIndex(abstractAgg.args[0]);
+          }
+          if (abstractAgg.args.size() > 1) {
+            physicalAgg->arg2 = operandIndex(abstractAgg.args[1]);
+          }
+        }
+        break;
+      }
+      case OpCode::kReadAggregate: {
+        IN_HEAD(AbstractReadAggregation, IAggregate, OpCode::kReadAggregate);
+        auto& agg = *abstractInst->aggregation;
+        physicalInst->numKeys = agg.keys.size();
+        physicalInst->numAggregates = agg.aggregates.size();
+        physicalInst->aggregates = reinterpret_cast<IUpdateAgg*>(
+            deviceLiterals_ + abstractInst->literalOffset);
+        auto programState = std::make_unique<ProgramState>();
+        programState->stateId = agg.state->id;
+        programState->isGlobal = true;
+        physicalInst->serial = agg.serial;
+        physicalInst->stateIndex = operatorStates_.size();
+        operatorStates_.push_back(std::move(programState));
+        memcpy(physicalInst->aggregates, agg.literal, agg.literalBytes);
+        auto numKeys = agg.keys.size();
+        auto* keys = reinterpret_cast<OperandIndex*>(
+            &physicalInst->aggregates[physicalInst->numAggregates]);
+        for (auto i = 0; i < numKeys; ++i) {
+          keys[i] = operandIndex(agg.keys[i]);
+        }
+        for (auto i = 0; i < agg.aggregates.size(); ++i) {
+          physicalInst->aggregates[i].result =
+              operandIndex(agg.aggregates[i].result);
+        }
+        break;
+      }
+      case OpCode::kReturn: {
+        IN_HEAD(AbstractReturn, IReturn, OpCode::kReturn);
         break;
       }
       default:
         VELOX_UNSUPPORTED("Bad OpCode");
     }
+    sharedMemorySize_ =
+        std::max(sharedMemorySize_, instructionSharedMemory(*space));
+    ++space;
+    VELOX_CHECK_LE(
+        reinterpret_cast<uintptr_t>(space),
+        reinterpret_cast<uintptr_t>(deviceLiterals_));
+  }
+  program_->sharedMemorySize = sharedMemorySize_;
+  literalOperands_.resize(literal_.size());
+  for (auto& [op, index] : literal_) {
+    literalToOperand(op, literalOperands_[index - firstLiteralIdx_]);
   }
 }
 
-void Program::sortSlots() {
-  // Assigns offsets to input and local/output slots so that all
-  // input is first and output next and within input and output, the
-  // slots are ordered with lower operand id first. So, if inputs
-  // are slots 88 and 22 and outputs are 77 and 33, then the
-  // complete order is 22, 88, 33, 77.
-  std::vector<AbstractOperand*> ids;
-  for (auto& pair : input_) {
-    ids.push_back(pair.first);
-  }
-  std::sort(
-      ids.begin(),
-      ids.end(),
-      [](AbstractOperand*& left, AbstractOperand*& right) {
-        return left->id < right->id;
-      });
-  for (auto i = 0; i < ids.size(); ++i) {
-    input_[ids[i]] = i;
+void Program::literalToOperand(AbstractOperand* abstractOp, Operand& op) {
+  op.indexMask = 0;
+  op.indices = nullptr;
+  if (abstractOp->literalNull) {
+    op.nulls =
+        reinterpret_cast<uint8_t*>(deviceLiterals_ + abstractOp->literalOffset);
+  } else {
+    op.base = deviceLiterals_ + abstractOp->literalOffset;
   }
-  ids.clear();
-  for (auto& pair : local_) {
+}
+
+namespace {
+// Sorts 'map' by id. Inserts back into map with second as ordinal number
+// starting at 'startAt'. Returns 1 + the highest assigned number.
+int32_t sortAndRenumber(
+    int32_t startAt,
+    folly::F14FastMap<AbstractOperand*, int32_t>& map) {
+  std::vector<AbstractOperand*> ids;
+  for (auto& pair : map) {
     ids.push_back(pair.first);
   }
   std::sort(
@@ -449,32 +1244,114 @@ void Program::sortSlots() {
         return left->id < right->id;
       });
   for (auto i = 0; i < ids.size(); ++i) {
-    local_[ids[i]] = i + input_.size();
+    map[ids[i]] = i + startAt;
   }
+  return startAt + ids.size();
+}
+} // namespace
+
+void Program::sortSlots() {
+  // Assigns offsets to input and local/output slots so that all
+  // input is first and output next and within input and output, the
+  // slots are ordered with lower operand id first. So, if inputs
+  // are slots 88 and 22 and outputs are 77 and 33, then the
+  // complete order is 22, 88, 33, 77. Constants are sorted after everything
+  // else.
+
+  auto start = sortAndRenumber(0, input_);
+  start = sortAndRenumber(start, local_);
+  start = sortAndRenumber(start, output_);
+  firstLiteralIdx_ = start;
+  sortAndRenumber(start, literal_);
 }
 
 OperandIndex Program::operandIndex(AbstractOperand* op) const {
+  if (!op) {
+    return kEmpty;
+  }
   auto it = input_.find(op);
   if (it != input_.end()) {
     return it->second;
   }
   it = local_.find(op);
-  if (it == local_.end()) {
-    VELOX_FAIL("Bad operand, offset not known");
+  if (it != local_.end()) {
+    return it->second;
+  }
+  it = output_.find(op);
+  if (it != local_.end()) {
+    return it->second;
+  }
+
+  it = literal_.find(op);
+  if (it != literal_.end()) {
+    return it->second;
+  }
+  VELOX_FAIL("Operand not found");
+}
+
+template <typename T>
+int32_t Program::addLiteral(T* value, int32_t count) {
+  nextLiteral_ = bits::roundUp(nextLiteral_, sizeof(T));
+  auto start = nextLiteral_;
+  nextLiteral_ += sizeof(T) * count;
+  literalArea_.resize(nextLiteral_);
+  memcpy(literalArea_.data() + start, value, sizeof(T) * count);
+  return start;
+}
+
+template <TypeKind kind>
+int32_t Program::addLiteralTyped(AbstractOperand* op) {
+  if (op->literalOffset != AbstractOperand::kNoConstant) {
+    return op->literalOffset;
+  }
+  using T = typename TypeTraits<kind>::NativeType;
+  if (op->constant->isNullAt(0)) {
+    op->literalNull = true;
+    char zero = 0;
+    return op->literalOffset = addLiteral<char>(&zero, 1);
   }
-  return it->second;
+  T value = op->constant->as<SimpleVector<T>>()->valueAt(0);
+  if constexpr (std::is_same_v<T, StringView>) {
+    int64_t inlined = 0;
+    StringView* stringView = reinterpret_cast<StringView*>(&value);
+    if (stringView->size() <= 6) {
+      int64_t inlined = static_cast<int64_t>(stringView->size()) << 48;
+      memcpy(
+          reinterpret_cast<char*>(&inlined) + 2,
+          stringView->data(),
+          stringView->size());
+      op->literalOffset = addLiteral(&inlined, 1);
+    } else {
+      int64_t zero = 0;
+      op->literalOffset = addLiteral(&zero, 1);
+      addLiteral(stringView->data(), stringView->size());
+    }
+  } else {
+    op->literalOffset = addLiteral(&value, 1);
+  }
+  return op->literalOffset;
 }
 
 void Program::markInput(AbstractOperand* op) {
   if (!op) {
     return;
   }
-  if (!local_.count(op)) {
+  if (op->constant) {
+    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        addLiteralTyped, op->constant->type()->kind(), op);
+    literal_[op] = literal_.size();
+    return;
+  }
+  if (!local_.count(op) && !output_.count(op)) {
     input_[op] = input_.size();
   }
 }
 
 void Program::markResult(AbstractOperand* op) {
+  if (outputIds_.contains(op->id)) {
+    output_[op] = outputIds_.ordinal(op->id);
+    return;
+  }
   if (!local_.count(op)) {
     local_[op] = local_.size();
   }
@@ -499,22 +1376,88 @@ std::unique_ptr<Executable> Program::getExecutable(
       exe->inputOperands.add(pair.first->id);
     }
     for (auto& pair : local_) {
+      exe->localOperands.add(pair.first->id);
+    }
+    for (auto& pair : output_) {
       exe->outputOperands.add(pair.first->id);
     }
-    exe->output.resize(local_.size());
+
+    exe->literals = &literalOperands_;
     exe->releaser = [](std::unique_ptr<Executable>& ptr) {
       auto program = ptr->programShared.get();
       ptr->reuse();
       program->releaseExe(std::move(ptr));
     };
+  }
+  return exe;
+}
 
-  } // We have an exe, whether new or reused. Check the vectors.
-  int32_t nth = 0;
-  exe->outputOperands.forEach([&](int32_t id) {
-    ensureWaveVector(
-        exe->output[nth], operands[id]->type, maxRows, true, *arena_);
-    ++nth;
+std::string AbstractOperand::toString() const {
+  if (constant) {
+    return fmt::format(
+        "<literal {} {}>", constant->toString(0), type->toString());
+  }
+  const char* nulls = notNull ? "NN"
+      : conditionalNonNull    ? "CN"
+      : sourceNullable        ? "SN"
+                              : "?";
+  return fmt::format("<{} {}: {} {}>", id, label, nulls, type->toString());
+}
+
+std::string Executable::toString() const {
+  std::stringstream out;
+  out << "{Exe "
+      << (stream ? fmt::format("stream {}", stream->userData())
+                 : fmt::format(" no stream "))
+      << " produces ";
+  bool first = true;
+  outputOperands.forEach([&](auto id) {
+    if (!first) {
+      out << ", ";
+    };
+    first = false;
+    out << waveStream->operandAt(id)->toString();
   });
-  return exe;
+  if (programShared) {
+    out << std::endl;
+    out << "program " << programShared->toString();
+  }
+  return out.str();
+}
+
+std::string Program::toString() const {
+  std::stringstream out;
+  out << "{ program" << std::endl;
+  for (auto& instruction : instructions_) {
+    out << instruction->toString() << std::endl;
+  }
+  out << "}" << std::endl;
+  return out.str();
+}
+
+std::string AbstractFilter::toString() const {
+  return fmt::format("filter {} -> {}", flags->toString(), indices->toString());
+  ;
 }
+
+std::string AbstractWrap::toString() const {
+  std::stringstream out;
+  out << "wrap indices=" << indices->toString() << " {";
+  for (auto& op : source) {
+    out << op->toString() << " ";
+  }
+  out << "}";
+  return out.str();
+}
+
+std::string AbstractBinary::toString() const {
+  return fmt::format(
+      "{} = {} {} {} {}",
+      result->toString(),
+      left->toString(),
+      static_cast<int32_t>(opCode),
+      right->toString(),
+      predicate ? fmt::format(" if {}", predicate->toString()) : "");
+}
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/Wave.h b/velox/experimental/wave/exec/Wave.h
index 5d78cb82242d3..85aaafa562535 100644
--- a/velox/experimental/wave/exec/Wave.h
+++ b/velox/experimental/wave/exec/Wave.h
@@ -26,8 +26,115 @@
 #include "velox/experimental/wave/exec/ExprKernel.h"
 #include "velox/experimental/wave/vector/WaveVector.h"
 
+#include <folly/executors/CPUThreadPoolExecutor.h>
+
+DECLARE_bool(wave_timing);
+DECLARE_bool(wave_transfer_timing);
+
 namespace facebook::velox::wave {
 
+/// Scoped guard, prints the time spent inside if
+class PrintTime {
+ public:
+  PrintTime(const char* title);
+  ~PrintTime();
+
+ private:
+  const char* title_;
+  uint64_t start_;
+};
+
+/// A host side time point for measuring wait and launch prepare latency. Counts
+/// both wall microseconds and clocks.
+struct WaveTime {
+  size_t micros{0};
+  uint64_t clocks{0};
+
+  static uint64_t getMicro() {
+    return FLAGS_wave_timing ? getCurrentTimeMicro() : 0;
+  }
+
+  static WaveTime now() {
+    if (!FLAGS_wave_timing) {
+      return {0, 0};
+    }
+    return {getCurrentTimeMicro(), folly::hardware_timestamp()};
+  }
+
+  WaveTime operator-(const WaveTime right) const {
+    return {micros - right.micros, clocks - right.clocks};
+  }
+
+  WaveTime operator+(const WaveTime right) const {
+    return {right.micros + micros, right.clocks + clocks};
+  }
+  void operator+=(const WaveTime& other) {
+    micros += other.micros;
+    clocks += other.clocks;
+  }
+  std::string toString() const;
+};
+
+class WaveTimer {
+ public:
+  WaveTimer(WaveTime& accumulator)
+      : accumulator_(accumulator), start_(WaveTime::now()) {}
+  ~WaveTimer() {
+    accumulator_ = accumulator_ + (WaveTime::now() - start_);
+  }
+
+ private:
+  WaveTime& accumulator_;
+  WaveTime start_;
+};
+
+struct WaveStats {
+  /// Count of WaveStreams.
+  int64_t numWaves{0};
+
+  // Count of kernel launches.
+  int64_t numKernels{0};
+
+  // Count of thread blocks in all kernel launches.
+  int64_t numThreadBlocks{0};
+
+  /// Number of programs. One launch typically has several programs, roughly one
+  /// per output column.
+  int64_t numPrograms{0};
+
+  /// Number of starting lanes in kernel launches. This is not exactly thread
+  /// blocks because the last block per program is not full.
+  int64_t numThreads{0};
+
+  /// Data transfer from host to device.
+  int64_t bytesToDevice{0};
+
+  int64_t bytesToHost{0};
+
+  /// Number of times the host syncs with device.
+  int64_t numSync{0};
+
+  /// Time a host thread runs without activity on device, e.g. after a sync or
+  /// before first launch.
+  WaveTime hostOnlyTime;
+  /// Time a host thread runs after kernel launch preparing the next kernel.
+  WaveTime hostParallelTime;
+  /// Time a host thread waits for device.
+  WaveTime waitTime;
+
+  /// Time a host thread is synchronously staging data to device. This is either
+  /// the wall time of multithreaded memcpy to pinned host or the wall time of
+  /// multithreaded GPU Direct NVME read. This does not include the time of
+  /// hostToDeviceAsync.
+  WaveTime stagingTime;
+
+  /// Optionally measured host to device transfer latency.
+  WaveTime transferWaitTime;
+
+  void clear();
+  void add(const WaveStats& other);
+};
+
 // A value a kernel can depend on. Either a dedupped exec::Expr or a dedupped
 // subfield. Subfield between operators, Expr inside  an Expr.
 struct Value {
@@ -38,6 +145,7 @@ struct Value {
   ~Value() = default;
 
   bool operator==(const Value& other) const {
+    // Both exprs and subfields are deduplicated.
     return expr == other.expr && subfield == other.subfield;
   }
 
@@ -47,6 +155,7 @@ struct Value {
 
 struct ValueHasher {
   size_t operator()(const Value& value) const {
+    // Hash the addresses because both exprs and subfields are deduplicated.
     return folly::hasher<uint64_t>()(
                reinterpret_cast<uintptr_t>(value.subfield)) ^
         folly::hasher<uint64_t>()(reinterpret_cast<uintptr_t>(value.expr));
@@ -59,6 +168,35 @@ struct ValueComparer {
   }
 };
 
+using SubfieldMap =
+    folly::F14FastMap<std::string, std::unique_ptr<common::Subfield>>;
+
+using DefinesMap =
+    folly::F14FastMap<Value, AbstractOperand*, ValueHasher, ValueComparer>;
+
+/// Translates a set of path steps to an OperandId or kNoOperand if
+/// none found. The path is not const because it is temporarily
+/// moved into a Subfield. Not thread safe for 'path'.
+AbstractOperand* pathToOperand(
+    const DefinesMap& map,
+    std::vector<std::unique_ptr<common::Subfield::PathElement>>& path);
+
+const SubfieldMap*& threadSubfieldMap();
+
+class WithSubfieldMap {
+ public:
+  WithSubfieldMap(const SubfieldMap* map) {
+    previous_ = threadSubfieldMap();
+    threadSubfieldMap() = map;
+  }
+  ~WithSubfieldMap() {
+    threadSubfieldMap() = previous_;
+  }
+
+ private:
+  const SubfieldMap* previous_;
+};
+
 struct Transfer {
   Transfer(const void* from, void* to, size_t size)
       : from(from), to(to), size(size) {}
@@ -69,15 +207,68 @@ struct Transfer {
   size_t size;
 };
 
+std::string definesToString(const DefinesMap* map);
+
 class WaveStream;
 class Program;
 
+/// Represents a device side operator state, like a join/group by hash table or
+/// repartition output. Can be scoped to a WaveStream or to a Program.
+struct OperatorState {
+  /// Marks that 'stream' will enqueue a program touching 'this'. Blocks until
+  /// 'this' is available. Throws an error if 'this' has entered an error state,
+  /// e.g. out of memory.
+  void enter(WaveStream* stream);
+
+  /// Marks that 'stream' has completed a program touching 'this'.
+  void leave(WaveStream* stream);
+
+  /// Acquires a process-wide exclusive hold on 'this' This is done
+  /// e.g. to rehash a hash table. 'stream' must have called enter()
+  /// on 'this' previously. If successful returns true after waiting
+  /// for the caller to be the only stream holding this. Returns false
+  /// If another stream called this before, returns false after
+  /// waiting for the exclusive owner to finish. If 'this' is in an
+  /// error state, throws the error. In any return except true, the
+  /// caller is not an owner of 'this'. After completing the activity,
+  /// the caller must call leave() when done.
+  bool enterExclusive(WaveStream* stream);
+
+  /// Sets an error. Any thread calling enter() or enterExclusive() will throw
+  /// the error. The caller must have successfully called enterExclusive()
+  /// first.
+  void setError(WaveStream* stream, std::exception_ptr error);
+
+  int32_t id;
+  /// Owns the device side data. Starting address of first is passed to the
+  /// kernel. Layout depends on operator.
+  std::vector<WaveBufferPtr> buffers;
+
+  std::mutex mutex_;
+  // Count of streams with programs touching this enqueued.
+  int32_t numStreams_{0};
+  // The stream with exclusive access via enterExclusive().
+  WaveStream* owner{nullptr};
+};
+
+struct AggregateOperatorState : public OperatorState {
+  AbstractAggregation* instruction;
+  // True after first created.
+  bool isNew{true};
+};
+
+struct OperatorStateMap {
+  folly::F14FastMap<int32_t, std::shared_ptr<OperatorState>> states;
+};
+
 /// Represents a kernel or data transfer. Many executables can be in one kernel
 /// launch on different thread blocks. Owns the output and intermediate memory
 /// for the thread block program or data transfer this represents. Has a
-/// WaveStream level unique id for each output column. be nulllptr if this
+/// WaveStream level unique id for each output column. May be nulllptr if this
 /// represents data movement only.
 struct Executable {
+  virtual ~Executable() = default;
+
   std::unique_ptr<Executable>
   create(std::shared_ptr<Program> program, int32_t numRows, GpuArena& arena);
 
@@ -85,19 +276,37 @@ struct Executable {
   /// addTransfer().
   static void startTransfer(
       OperandSet outputOperands,
-      WaveBufferPtr&& operands,
       std::vector<WaveVectorPtr>&& outputVectors,
       std::vector<Transfer>&& transfers,
       WaveStream& stream);
 
+  virtual void ensureLazyArrived(folly::Range<const OperandId*> operands) {
+    VELOX_UNREACHABLE(
+        "A table scan executable is expected to override this "
+        "or always produce all columns");
+  }
+
+  /// Returns the vector for 'id' or nullptr if does not exist.
+  WaveVector* operandVector(OperandId id);
+
+  /// Returns the vector for 'id' and creates an empty vector of 'type' if one
+  /// does not exist. The caller will resize.
+  WaveVector* operandVector(OperandId id, const TypePtr& type);
+
   // Clear state to prepare for reuse.
   void reuse() {
     operands = nullptr;
     stream = nullptr;
+    wraps.clear();
   }
 
+  virtual std::string toString() const;
+
+  // The containing WaveStream.
+  WaveStream* waveStream{nullptr};
+
   // The Program this is an invocationn of. nullptr if 'this' represents a data
-  // transfer.
+  // transfer or column read.
   std::shared_ptr<Program> programShared;
 
   ThreadBlockProgram* program{nullptr};
@@ -114,18 +323,29 @@ struct Executable {
   // Operand ids for outputs.
   OperandSet outputOperands;
 
-  // Unified memory Operand structs for intermediates/outputs. These
+  // Unified memory Operand structs for intermediates/outputs/literals. These
   // are a contiguous array of Operand in LaunchControl of 'this'
   Operand* operands;
 
+  // Index of first output operand in 'operands'.
+  int32_t firstOutputOperandIdx{-1};
+
+  // Map from wrapAt in AbstractOperand to device side 'indices' with one
+  // int32_t* per thread block.
+  folly::F14FastMap<int32_t, int32_t**> wraps;
+
+  // Host side array of literals. These refer to literal data in device side
+  // ThreadBlockProgram. These are copied at the end of 'operands' at launch.
+  const std::vector<Operand>* literals;
+
   // Backing memory for intermediate Operands. Free when 'this' arrives. If
   // scheduling follow up work that is synchronized with arrival of 'this', the
   // intermediates can be moved to the dependent executable at time of
   // scheduling.
   std::vector<WaveVectorPtr> intermediates;
 
-  // Backing device memory   for 'output' Can be moved to intermediates or
-  // output of a dependent executables.
+  // Backing device memory   for 'output'. These are accessed by dependent
+  // executables and must not be written to until out of scope.
   std::vector<WaveVectorPtr> output;
 
   // If this represents data transfer, the ranges to transfer.
@@ -143,12 +363,77 @@ struct Executable {
   std::function<void(std::unique_ptr<Executable>&)> releaser;
 };
 
+/// Describes the OperatorStates touched by a Program.
+struct ProgramState {
+  // Task-wide id.
+  int32_t stateId;
+  // Function for creating a state. nullptr if the state must exist before
+  // creating an executable.
+  std::function<std::shared_ptr<OperatorState>(WaveStream& stream)> create;
+
+  /// The instruction using the state. This is where to continue if
+  /// the return indicates the instruction is not fully processed.
+  int32_t instructionIdx;
+
+  // True if the state is shared across all streams, e.g. hash join build side.
+  bool isGlobal{true};
+  ///
+
+  /// If non-0, size of device memory scratch area per TB.
+  int32_t tempBytesPerTB{0};
+
+  /// If non-0, size of status to return to host for each TB. The device side
+  /// address goes via and the host side address goes to the LaunchControl.
+  int32_t returnBytesPerTB{0};
+};
+
+/// Describes a point to pick up execution of a partially executed program.
+struct ContinuePoint {
+  ContinuePoint() = default;
+  ContinuePoint(int32_t instruction, int32_t rows)
+      : instructionIdx(instruction), sourceRows(rows) {}
+
+  bool empty() const {
+    return laneMask.empty() && sourceRows == 0;
+  }
+
+  /// The index of the instruction where to pick up execution. Must be set if
+  /// !this->empty().
+  int32_t instructionIdx{-1};
+
+  /// If non-zero, the continue makes up to 'sourceRows' new values.
+  int32_t sourceRows{0};
+  /// If non-empty, 'sourceRows' must be 0 and  laneMask gives the lanes in
+  /// the previous invocation that need to be continued.
+  std::vector<uint64_t> laneMask;
+};
+
+/// State of one Program in LaunchControl.
+struct ProgramLaunch {
+  Program* program{nullptr};
+  bool isStaged{false};
+  /// Device side buffer for status returning instructions.
+  std::vector<void*> returnBuffers;
+  /// Host side address 1:1 to 'returnBuffers'.
+  std::vector<void*> hostReturnBuffers;
+  /// Device side temp status for instructions.
+  std::vector<void*> deviceBuffers;
+
+  /// Where to continue if previous execution was incomplete.
+  AdvanceResult advance;
+};
+
 class Program : public std::enable_shared_from_this<Program> {
  public:
   void add(std::unique_ptr<AbstractInstruction> instruction) {
     instructions_.push_back(std::move(instruction));
   }
 
+  /// Specifies that Operand with 'id' is used by a dependent operation.
+  void markOutput(OperandId id) {
+    outputIds_.add(id);
+  }
+
   const std::vector<Program*>& dependsOn() const {
     return dependsOn_;
   }
@@ -161,8 +446,8 @@ class Program : public std::enable_shared_from_this<Program> {
     dependsOn_.push_back(source);
   }
 
-  // Initializes executableImage and relocation information and places for
-  // parameters.
+  // Initializes executableImage and relocation information and places
+  // the result on device.
   void prepareForDevice(GpuArena& arena);
 
   std::unique_ptr<Executable> getExecutable(
@@ -193,21 +478,68 @@ class Program : public std::enable_shared_from_this<Program> {
     return sharedMemorySize_;
   }
 
-  const folly::F14FastMap<AbstractOperand*, int32_t>& localAndOutput() const {
-    return local_;
+  const folly::F14FastMap<AbstractOperand*, int32_t>& output() const {
+    return output_;
   }
 
+  const std::string& label() const {
+    return label_;
+  }
+
+  void addLabel(const std::string& label) {
+    label_ = label_ + " " + label;
+  }
+
+  /// Fills 'ptrs' with device side global/stream states. Creates the states if
+  /// necessary.
+  void getOperatorStates(WaveStream& stream, std::vector<void*>& ptrs);
+
+  /// True if begins with a source instruction, like reading and aggregate
+  /// result or exchange.
+  bool isSource() {
+    return !instructions_.empty() &&
+        instructions_.front()->opCode == OpCode::kReadAggregate;
+  }
+
+  /// If partially executed instructions in the call of 'control',
+  /// returns the point where to pick up. If fully executed or not
+  /// started, returns the number of rows to obtain from the
+  /// source. If no source and no partial execution or source at end
+  /// returns empty. If picking up from a partially executed
+  /// instruction, sets the lanes to continue in the status of
+  /// 'control'.
+  AdvanceResult
+  canAdvance(WaveStream& stream, LaunchControl* control, int32_t programIdx);
+
+  /// True if last non-return instruction is a sink, e.g. build, repartition. No
+  /// output vectors,, synced on 'hostReturnEvent_'.
+  bool isSink() const;
+
+  void registerStatus(WaveStream& stream);
+
+  std::string toString() const;
+
  private:
+  template <TypeKind kind>
+  int32_t addLiteralTyped(AbstractOperand* op);
+  /// Returns a starting offset to a constant with 'count' elements of T,
+  /// initialized from 'value[]' The values are copied to device side
+  /// ThreadBlockProgram.
+  template <typename T>
+  int32_t addLiteral(T* value, int32_t count);
+
+  void literalToOperand(AbstractOperand* abstractOp, Operand& op);
+
   GpuArena* arena_{nullptr};
   std::vector<Program*> dependsOn_;
-  folly::F14FastMap<Value, AbstractOperand*, ValueHasher, ValueComparer>
-      produces_;
+  DefinesMap produces_;
   std::vector<std::unique_ptr<AbstractInstruction>> instructions_;
   bool isMutable_{true};
 
   // Adds 'op' to 'input' if it is not produced by one in 'local'
   void markInput(AbstractOperand* op);
-  // Adds 'op' to 'local_'
+
+  // Adds 'op' to 'local_' or 'output_'.
   void markResult(AbstractOperand* op);
   void sortSlots();
 
@@ -216,8 +548,28 @@ class Program : public std::enable_shared_from_this<Program> {
   // Input Operand  to offset in operands array.
   folly::F14FastMap<AbstractOperand*, int32_t> input_;
 
-  // Local/output Operand offset in operands array.
+  /// Set of OperandIds for outputs. These must come after intermediates in
+  /// Operands array.
+  OperandSet outputIds_;
+
+  // Local Operand offset in operands array.
   folly::F14FastMap<AbstractOperand*, int32_t> local_;
+  // Output Operand offset in operands array.
+  folly::F14FastMap<AbstractOperand*, int32_t> output_;
+
+  // OperandIdx for first literal operand.
+  int32_t firstLiteralIdx_{-1};
+
+  // Constant Operand  to offset in operands array.
+  folly::F14FastMap<AbstractOperand*, int32_t> literal_;
+
+  // Offset of first unused constant area byte from start of constant area.
+  int32_t nextLiteral_{0};
+
+  // Binary data for constants to be embedded in ThreadBlockProgram. Must be
+  // relocatable, i.e. does not contain non-relative pointers within the
+  // constant area.
+  std::string literalArea_;
 
   // Owns device side 'threadBlockProgram_'
   WaveBufferPtr deviceData_;
@@ -226,6 +578,15 @@ class Program : public std::enable_shared_from_this<Program> {
   ThreadBlockProgram* program_;
 
   int32_t sharedMemorySize_{0};
+
+  // Host side image of device side Operands that reference 'constantArea_'.
+  // These are copied at the end of the operand block created at kernel launch.
+  std::vector<Operand> literalOperands_;
+
+  std::string label_;
+
+  // Start of device side constant area.
+  char* deviceLiterals_{nullptr};
   // Serializes 'prepared_'. Access on WaveStrea, is single threaded but sharing
   // Programs across WaveDrivers makes sense, so make the preallocated resource
   // thread safe.
@@ -233,16 +594,53 @@ class Program : public std::enable_shared_from_this<Program> {
 
   // a pool of ready to run executables.
   std::vector<std::unique_ptr<Executable>> prepared_;
+
+  // Globals accessed by id from instructions.
+  std::vector<std::unique_ptr<ProgramState>> operatorStates_;
 };
 
+inline int32_t instructionStatusSize(
+    InstructionStatus& status,
+    int32_t numBlocks) {
+  return bits::roundUp(
+      static_cast<uint32_t>(status.gridStateSize) +
+          numBlocks * static_cast<uint32_t>(status.blockState),
+      8);
+}
+
 using ProgramPtr = std::shared_ptr<Program>;
 
+class WaveSplitReader;
 struct LaunchControl;
 
 /// Represents consecutive data dependent kernel launches.
 class WaveStream {
  public:
-  WaveStream(GpuArena& arena) : arena_(arena) {}
+  /// Describes what 'this' is doing for purposes of stats collection.
+  enum class State {
+    // Not runnable, e.g. another WaveStream is being processed by WaveDriver.
+    kNotRunning,
+    // Running on host only, e.g. preparing for first kernel launch.
+    kHost,
+    // Running on host with device side work submitted.
+    kParallel,
+    // Waiting on host thread for device results.
+    kWait
+  };
+
+  WaveStream(
+      GpuArena& arena,
+      GpuArena& deviceArena,
+      const std::vector<std::unique_ptr<AbstractOperand>>* operands,
+      OperatorStateMap* stateMap,
+      InstructionStatus state)
+      : arena_(arena),
+        deviceArena_(deviceArena),
+        operands_(operands),
+        taskStateMap_(stateMap),
+        instructionStatus_(state) {
+    operandNullable_.resize(operands_->size(), true);
+  }
 
   ~WaveStream();
 
@@ -257,6 +655,56 @@ class WaveStream {
     return arena_;
   }
 
+  GpuArena& deviceArena() {
+    return deviceArena_;
+  }
+
+  /// Sets nullability of a source column. This is runtime, since may depend on
+  /// the actual presence of nulls in the source, e.g. file. Nullability
+  /// defaults to nullable.
+  void setNullable(const AbstractOperand& op, bool nullable) {
+    operandNullable_[op.id] = nullable;
+  }
+
+  int32_t numRows() const {
+    return numRows_;
+  }
+
+  // Sets the size of top-level vectors to be prepared for the next launch.
+  void setNumRows(int32_t numRows) {
+    numRows_ = numRows;
+  }
+
+  /// Sets 'vector' to ' a WaveVector of suitable type, size and
+  /// nullability. May reuse 'vector' if not nullptr. The size comes
+  /// from setNumRows() if not given as parameter.
+  void ensureVector(
+      const AbstractOperand& operand,
+      WaveVectorPtr& vector,
+      int32_t numRows = -1);
+
+  /// Marks 'op' as being later copied to host.  Allocates these together.
+  void markHostOutputOperand(const AbstractOperand& op);
+
+  /// Finalizes return state. setNumRows and markHostOutputOperand may not be
+  /// called after this. If 'needStatus' is false and no columns are marked for
+  /// host return there is no need for any data transfer at the end of the
+  /// stream.
+  void setReturnData(bool needStatus);
+
+  /// Enqueus copy of device side results to host.
+  void resultToHost();
+
+  /// Updates 'vectors' to reference the data in 'operands'. 'id' is the id of
+  /// the last WaveOperator. It identifies the LaunchControl with the final
+  /// BlockStatus with errors and cardinalities. Returns the number of rows
+  /// after possible selection.
+  int32_t getOutput(
+      int32_t operatorId,
+      memory::MemoryPool& pool,
+      folly::Range<const OperandId*> operands,
+      VectorPtr* vectors);
+
   Executable* operandExecutable(OperandId id) {
     auto it = operandToExecutable_.find(id);
     if (it == operandToExecutable_.end()) {
@@ -287,6 +735,10 @@ class WaveStream {
     executable.stream = &stream;
   }
 
+  std::vector<bool>& operandNullable() {
+    return operandNullable_;
+  }
+
   // Retuns true if all executables needed to cover 'ids' have arrived. if
   // 'sleepMicro' is default, returns immediately if not arrived. Otherwise
   // sleeps 'leepMicros' and rechecks until complete or until 'timeoutMicro' us
@@ -299,6 +751,7 @@ class WaveStream {
   Device* device() const {
     return getDevice();
   }
+
   /// Returns a new stream, assigns it an id and keeps it owned by 'this'. The
   /// Stream will be returned to the static pool of streams on destruction of
   /// 'this'.
@@ -318,17 +771,20 @@ class WaveStream {
   /// row counts. The LaunchControl is in host memory, the arrays
   /// referenced from it are in unified memory, owned by
   /// LaunchControl. 'key' identifies the issuing
-  /// WaveOperator. 'inputRows' is the logical number of input rows,
-  /// not all TBs are necessarily full. 'exes' are the programs
-  /// launched together, e.g. different exprs on different
-  /// columns. 'blocks{PerExe' is the number of TBs running each exe. 'stream'
-  /// enqueus the data transfer.
+  /// WaveOperator. 'nthLaunch' is the serial number of the kernel
+  /// within the operator. Multiple launches can have the same serial
+  /// for continuing partially executed operations. 'inputRows' is the
+  /// logical number of input rows, not all TBs are necessarily
+  /// full. 'exes' are the programs launched together, e.g. different
+  /// exprs on different columns. 'blocks{PerExe' is the number of TBs
+  /// running each exe. 'stream' enqueus the data transfer.
   LaunchControl* prepareProgramLaunch(
       int32_t key,
+      int32_t nthlaunch,
       int32_t inputRows,
       folly::Range<Executable**> exes,
       int32_t blocksPerExe,
-      bool initstatus,
+      const LaunchControl* inputStatus,
       Stream* stream);
 
   const std::vector<std::unique_ptr<LaunchControl>>& launchControls(
@@ -336,9 +792,117 @@ class WaveStream {
     return launchControl_[key];
   }
 
+  void addLaunchControl(int32_t key, std::unique_ptr<LaunchControl> control) {
+    launchControl_[key].push_back(std::move(control));
+  }
+
+  void setLaunchControl(
+      int32_t key,
+      int32_t nth,
+      std::unique_ptr<LaunchControl> control);
+
+  const AbstractOperand* operandAt(int32_t id) {
+    VELOX_CHECK_LT(id, operands_->size());
+    return (*operands_)[id].get();
+  }
+
+  // Describes an exe in a multi-program launch.
+  struct ExeLaunchInfo {
+    int32_t numBlocks;
+    int32_t numInput{0};
+    int32_t numLocalOps{0};
+    int32_t numLocalWrap{0};
+    int32_t totalBytes{0};
+    folly::F14FastMap<int32_t, int32_t**> inputWrap;
+    folly::F14FastMap<int32_t, int32_t**> localWrap;
+    std::vector<void*> operatorStates;
+  };
+
+  void
+  exeLaunchInfo(Executable& exe, int32_t blocksPerExe, ExeLaunchInfo& info);
+
+  Operand** fillOperands(Executable& exe, char* start, ExeLaunchInfo& info);
+
+  State state() const {
+    return state_;
+  }
+
+  /// Sets the state for stats collection.
+  void setState(WaveStream::State state);
+
+  const WaveStats& stats() const {
+    return stats_;
+  }
+
+  WaveStats& mutableStats() {
+    return stats_;
+  }
+
+  WaveStats& stats() {
+    return stats_;
+  }
+
+  void setSplitReader(const std::shared_ptr<WaveSplitReader>& reader) {
+    splitReader_ = reader;
+  }
+
+  void clearLaunch(int32_t id) {
+    launchControl_[id].clear();
+  }
+
+  OperatorState* operatorState(int32_t id);
+
+  OperatorState* newState(ProgramState& init);
+
+  /// Initializes 'state' to the device side state for 'inst'. Returns after
+  /// 'state' is ready to use on device.
+  void makeAggregate(AbstractAggregation& inst, AggregateOperatorState& state);
+
+  std::unique_ptr<Executable> recycleExecutable(
+      Program* program,
+      int32_t numRows);
+
+  /// True if ends with a resettable sink like partial aggregation and the sink
+  /// is full.
+  bool isSinkFull() const {
+    return false;
+  }
+
+  /// Clears the state in final sink, e.g. partial agregation. The
+  /// stream can be continuable at this point and the new sink state
+  /// will get the data not produced so far.
+  void resetSink() {}
+
+  // Releases and clears streams and events. Done at destruction or
+  // before reuse. All device side activity is expected to be
+  // complete. Resets conditional nullability info.
+  void releaseStreamsAndEvents();
+
+  void setError() {
+    hasError_ = true;
+  }
+
+  static folly::CPUThreadPoolExecutor* copyExecutor();
+  static folly::CPUThreadPoolExecutor* syncExecutor();
+
+  std::string toString() const;
+
+  /// Reads the BlockStatus from device and marks programs that need to be
+  /// continued.
+  bool interpretArrival();
+
+  const InstructionStatus& instructionStatus() const {
+    return instructionStatus_;
+  }
+
  private:
+  // true if 'op' is nullable in the context of 'this'.
+  bool isNullable(const AbstractOperand& op) const;
+
   Event* newEvent();
 
+  LaunchControl* lastControl() const;
+
   static std::unique_ptr<Event> eventFromReserve();
   static void releaseEvent(std::unique_ptr<Event>&& event);
 
@@ -347,19 +911,50 @@ class WaveStream {
   static std::vector<std::unique_ptr<Event>> eventsForReuse_;
   static std::vector<std::unique_ptr<Stream>> streamsForReuse_;
   static bool exitInited_;
+  static std::unique_ptr<folly::CPUThreadPoolExecutor> copyExecutor_;
+  static std::unique_ptr<folly::CPUThreadPoolExecutor> syncExecutor_;
 
   static void clearReusable();
 
+  static folly::CPUThreadPoolExecutor* getExecutor(
+      std::unique_ptr<folly::CPUThreadPoolExecutor>& ptr);
+
+  // Unified memory.
   GpuArena& arena_;
+
+  // Device memory.
+  GpuArena& deviceArena_;
+
+  const std::vector<std::unique_ptr<AbstractOperand>>* const operands_;
+  // True at '[i]' if in this stream 'operands_[i]' should have null flags.
+  std::vector<bool> operandNullable_;
+
+  // Task-wide states like join hash tables.
+  OperatorStateMap* taskStateMap_;
+
+  // Stream level states like small partial aggregates.
+  OperatorStateMap streamStateMap_;
+
+  // Space reserved for per-instruction return state above BlockStatus array.
+  InstructionStatus instructionStatus_;
+
+  // Number of rows to allocate for top level vectors for the next kernel
+  // launch.
+  int32_t numRows_{0};
+
   folly::F14FastMap<OperandId, Executable*> operandToExecutable_;
   std::vector<std::unique_ptr<Executable>> executables_;
 
   // Currently active streams, each at the position given by its
   // stream->userData().
   std::vector<std::unique_ptr<Stream>> streams_;
+
   // The most recent event recorded on the pairwise corresponding element of
   // 'streams_'.
   std::vector<Event*> lastEvent_;
+  // If status return copy has been initiated, then this is the event to sync
+  // with before accessing the 'hostReturnData_'
+  Event* hostReturnEvent_{nullptr};
 
   // all events recorded on any stream. Events, once seen realized, are moved
   // back to reserve from here.
@@ -371,6 +966,43 @@ class WaveStream {
       launchControl_;
 
   folly::F14FastMap<int32_t, WaveBufferPtr> extraData_;
+
+  // ids of operands that need their memory to be in the host return area.
+  OperandSet hostOutputOperands_;
+
+  // Offset of the operand in 'hostReturnData_' and 'deviceReturnData_'.
+  folly::F14FastMap<OperandId, int64_t> hostReturnOffset_;
+
+  // Size of data returned at end of stream.
+  int64_t hostReturnSize_{0};
+
+  int64_t hostReturnDataUsed_{0};
+
+  // Device side data for all returnable data, like BlockStatus and Vector
+  // bodies to be copied to host.
+  WaveBufferPtr deviceReturnData_;
+
+  // Host pinned memory to which 'deviceReturnData' is copied.
+  WaveBufferPtr hostReturnData_;
+
+  // Device/unified pointer to BlockStatus and memory for areas for
+  // instructionStatus_. Allocated before first launch and copied to
+  // 'hostBlockStatus_' after last kernel in pipeline.
+  BlockStatus* deviceBlockStatus_{nullptr};
+
+  // Host side copy of BlockStatus.
+  WaveBufferPtr hostBlockStatus_;
+
+  // Time when host side activity last started on 'this'.
+  WaveTime start_;
+
+  State state_{State::kNotRunning};
+
+  bool hasError_{false};
+
+  WaveStats stats_;
+
+  std::shared_ptr<WaveSplitReader> splitReader_;
 };
 
 /// Describes all the control data for launching a kernel executing
@@ -386,29 +1018,34 @@ class WaveStream {
 //// WaveVectors in each exe. Array of TB return status blocks, one
 //// per TB.
 struct LaunchControl {
-  int32_t key;
+  LaunchControl(int32_t _key, int32_t _inputRows)
+      : key(_key), inputRows(_inputRows) {}
 
-  int32_t inputRows;
+  // Id of the initiating operator.
+  const int32_t key;
 
-  /// The first thread block with the program.
-  int32_t* blockBase;
-  // The ordinal of the program. All blocks with the same program have the same
-  // number here.
-  int32_t* programIdx;
+  // Number of rows the programs get as input. Initializes the BlockStatus'es on
+  // device in prepareProgamLaunch().
+  const int32_t inputRows;
 
-  // The TB program for each exe.
-  ThreadBlockProgram** programs;
+  KernelParams params;
 
-  // For each exe, the start of the array of Operand*. Instructions reference
-  // operands via offset in this array.//
-  Operand*** operands;
-
-  // the status return block for each TB.
-  BlockStatus* status;
   int32_t sharedMemorySize{0};
 
   // Storage for all the above in a contiguous unified memory piece.
   WaveBufferPtr deviceData;
+
+  /// Staging for device side temp storage.
+  ResultStaging tempStaging;
+
+  /// Staging for device data to be copied to host.
+  ResultStaging returnStaging;
+
+  /// Staging for host side buffers that receive the data from 'returnStaging'.
+  ResultStaging hostReturnStaging;
+
+  /// Continue info for each Program in the launch.
+  std::vector<ProgramLaunch> programInfo;
 };
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveCore.cuh b/velox/experimental/wave/exec/WaveCore.cuh
index 058b89bb18627..af5534c853e98 100644
--- a/velox/experimental/wave/exec/WaveCore.cuh
+++ b/velox/experimental/wave/exec/WaveCore.cuh
@@ -16,19 +16,80 @@
 
 #pragma once
 
+#include <assert.h>
 #include <cuda_runtime.h> // @manual
 
+#include "velox/experimental/wave/common/Block.cuh"
+#include "velox/experimental/wave/exec/ExprKernel.h"
 #include "velox/experimental/wave/vector/Operand.h"
 
 namespace facebook::velox::wave {
 
+template <typename T>
+inline T* __device__
+gridStatus(const WaveShared* shared, const InstructionStatus& status) {
+  int32_t numBlocks = roundUp(shared->numRows, kBlockSize) / kBlockSize;
+  return reinterpret_cast<T*>(
+      roundUp(
+          reinterpret_cast<uintptr_t>(shared->status) +
+              numBlocks * sizeof(BlockStatus),
+          8) +
+      status.gridState);
+}
+
+template <typename T>
+inline T* __device__ laneStatus(
+    const WaveShared* shared,
+    const InstructionStatus& status,
+    int32_t nthBlock) {
+  int32_t numBlocks = roundUp(shared->numRows, kBlockSize) / kBlockSize;
+  return reinterpret_cast<T*>(
+      roundUp(
+          reinterpret_cast<uintptr_t>(shared->status) +
+              numBlocks * sizeof(BlockStatus),
+          8) +
+      status.gridStateSize + status.blockState * numBlocks);
+}
+
+inline bool __device__ laneActive(ErrorCode code) {
+  return static_cast<uint8_t>(code) <=
+      static_cast<uint8_t>(ErrorCode::kContinue);
+}
+
 template <typename T>
 __device__ inline T& flatValue(void* base, int32_t blockBase) {
   return reinterpret_cast<T*>(base)[blockBase + threadIdx.x];
 }
 
-__device__ inline bool isNull(Operand* op, int32_t blockBase) {
-  return op->nulls == nullptr || !op->nulls[blockBase + threadIdx.x];
+/// Returns true if operand is non null. Sets 'value' to the value of the
+/// operand.
+template <typename T>
+__device__ __forceinline__ bool operandOrNull(
+    Operand** operands,
+    OperandIndex opIdx,
+    int32_t blockBase,
+    void* shared,
+    T& value) {
+  if (opIdx > kMinSharedMemIndex) {
+    assert(false);
+  }
+  auto op = operands[opIdx];
+  int32_t index = threadIdx.x;
+  if (auto indicesInOp = op->indices) {
+    auto indices = indicesInOp[blockBase / kBlockSize];
+    if (indices) {
+      index = indices[index];
+    } else {
+      index += blockBase;
+    }
+  } else {
+    index = (index + blockBase) & op->indexMask;
+  }
+  if (op->nulls && op->nulls[index] == kNull) {
+    return false;
+  }
+  value = reinterpret_cast<const T*>(op->base)[index];
+  return true;
 }
 
 template <typename T>
@@ -36,10 +97,9 @@ __device__ inline T getOperand(
     Operand** operands,
     OperandIndex opIdx,
     int32_t blockBase,
-    char* shared) {
+    void* shared) {
   if (opIdx > kMinSharedMemIndex) {
-    return reinterpret_cast<T*>(
-        shared + opIdx - kMinSharedMemIndex)[blockIdx.x];
+    assert(false);
   }
   auto op = operands[opIdx];
   int32_t index = (threadIdx.x + blockBase) & op->indexMask;
@@ -68,15 +128,28 @@ __device__ inline T value(Operand* op, int index) {
   return reinterpret_cast<const T*>(op->base)[index];
 }
 
+/// Sets the lane's result to null for opIdx.
+__device__ inline void resultNull(
+    Operand** operands,
+    OperandIndex opIdx,
+    int32_t blockBase,
+    void* shared) {
+  if (opIdx >= kMinSharedMemIndex) {
+    assert(false);
+  } else {
+    auto* op = operands[opIdx];
+    op->nulls[blockBase + threadIdx.x] = kNull;
+  }
+}
+
 template <typename T>
 __device__ inline T& flatResult(
     Operand** operands,
     OperandIndex opIdx,
     int32_t blockBase,
-    char* shared) {
+    void* shared) {
   if (opIdx >= kMinSharedMemIndex) {
-    return reinterpret_cast<T*>(
-        shared + opIdx - kMinSharedMemIndex)[threadIdx.x];
+    assert(false);
   }
   auto* op = operands[opIdx];
   if (op->nulls) {
@@ -90,4 +163,167 @@ __device__ inline T& flatResult(Operand* op, int32_t blockBase) {
   return flatResult<T>(&op, 0, blockBase, nullptr);
 }
 
+#define PROGRAM_PREAMBLE(blockOffset)                                          \
+  extern __shared__ char sharedChar[];                                         \
+  WaveShared* shared = reinterpret_cast<WaveShared*>(sharedChar);              \
+  int programIndex = params.programIdx[blockIdx.x + blockOffset];              \
+  auto* program = params.programs[programIndex];                               \
+  if (threadIdx.x == 0) {                                                      \
+    shared->operands = params.operands[programIndex];                          \
+    shared->status = &params.status                                            \
+                          [blockIdx.x + blockOffset -                          \
+                           params.blockBase[blockIdx.x + blockOffset]];        \
+    shared->numRows = shared->status->numRows;                                 \
+    shared->blockBase = (blockIdx.x + blockOffset -                            \
+                         params.blockBase[blockIdx.x + blockOffset]) *         \
+        blockDim.x;                                                            \
+    shared->states = params.operatorStates[programIndex];                      \
+    shared->stop = false;                                                      \
+  }                                                                            \
+  __syncthreads();                                                             \
+  auto blockBase = shared->blockBase;                                          \
+  auto operands = shared->operands;                                            \
+  ErrorCode laneStatus;                                                        \
+  Instruction* instruction;                                                    \
+  if (params.startPC == nullptr) {                                             \
+    instruction = program->instructions;                                       \
+    laneStatus =                                                               \
+        threadIdx.x < shared->numRows ? ErrorCode::kOk : ErrorCode::kInactive; \
+  } else {                                                                     \
+    instruction = program->instructions + params.startPC[programIndex];        \
+    laneStatus = shared->status->errors[threadIdx.x];                          \
+  }
+
+#define PROGRAM_EPILOGUE()                          \
+  if (threadIdx.x == 0) {                           \
+    shared->status->numRows = shared->numRows;      \
+  }                                                 \
+  shared->status->errors[threadIdx.x] = laneStatus; \
+  __syncthreads();
+
+__device__ __forceinline__ void filterKernel(
+    const IFilter& filter,
+    Operand** operands,
+    int32_t blockBase,
+    WaveShared* shared,
+    ErrorCode& laneStatus) {
+  bool isPassed = laneActive(laneStatus);
+  if (isPassed) {
+    if (!operandOrNull(
+            operands, filter.flags, blockBase, &shared->data, isPassed)) {
+      isPassed = false;
+    }
+  }
+  uint32_t bits = __ballot_sync(0xffffffff, isPassed);
+  if ((threadIdx.x & (kWarpThreads - 1)) == 0) {
+    reinterpret_cast<int32_t*>(&shared->data)[threadIdx.x / kWarpThreads] =
+        __popc(bits);
+  }
+  __syncthreads();
+  if (threadIdx.x < kWarpThreads) {
+    constexpr int32_t kNumWarps = kBlockSize / kWarpThreads;
+    int32_t cnt = threadIdx.x < kNumWarps
+        ? reinterpret_cast<int32_t*>(&shared->data)[threadIdx.x]
+        : 0;
+    int32_t sum;
+    using Scan = cub::WarpScan<int32_t, kBlockSize / kWarpThreads>;
+    Scan(*reinterpret_cast<Scan::TempStorage*>(shared)).ExclusiveSum(cnt, sum);
+    if (threadIdx.x < kNumWarps) {
+      if (threadIdx.x == kNumWarps - 1) {
+        shared->numRows = cnt + sum;
+      }
+      reinterpret_cast<int32_t*>(&shared->data)[threadIdx.x] = sum;
+    }
+  }
+  __syncthreads();
+  if (bits & (1 << (threadIdx.x & (kWarpThreads - 1)))) {
+    auto* indices = reinterpret_cast<int32_t*>(operands[filter.indices]->base);
+    auto start = blockBase +
+        reinterpret_cast<int32_t*>(&shared->data)[threadIdx.x / kWarpThreads];
+    auto bit = start +
+        __popc(bits & lowMask<uint32_t>(threadIdx.x & (kWarpThreads - 1)));
+    indices[bit] = blockBase + threadIdx.x;
+  }
+  laneStatus =
+      threadIdx.x < shared->numRows ? ErrorCode::kOk : ErrorCode::kInactive;
+  __syncthreads();
+}
+
+__device__ void __forceinline__ wrapKernel(
+    const IWrap& wrap,
+    Operand** operands,
+    int32_t blockBase,
+    int32_t numRows,
+    void* shared) {
+  Operand* op = operands[wrap.indices];
+  auto* filterIndices = reinterpret_cast<int32_t*>(op->base);
+  if (filterIndices[blockBase + numRows - 1] == numRows + blockBase - 1) {
+    // There is no cardinality change.
+    return;
+  }
+
+  struct WrapState {
+    int32_t* indices;
+  };
+
+  auto* state = reinterpret_cast<WrapState*>(shared);
+  bool rowActive = threadIdx.x < numRows;
+  for (auto column = 0; column < wrap.numColumns; ++column) {
+    if (threadIdx.x == 0) {
+      auto opIndex = wrap.columns[column];
+      auto* op = operands[opIndex];
+      int32_t** opIndices = &op->indices[blockBase / kBlockSize];
+      if (!*opIndices) {
+        *opIndices = filterIndices + blockBase;
+        state->indices = nullptr;
+      } else {
+        state->indices = *opIndices;
+      }
+    }
+    __syncthreads();
+    // Every thread sees the decision on thred 0 above.
+    if (!state->indices) {
+      continue;
+    }
+    int32_t newIndex;
+    if (rowActive) {
+      newIndex =
+          state->indices[filterIndices[blockBase + threadIdx.x] - blockBase];
+    }
+    // All threads hit this.
+    __syncthreads();
+    if (rowActive) {
+      state->indices[threadIdx.x] = newIndex;
+    }
+  }
+  __syncthreads();
+}
+
+template <typename T>
+__device__ inline T opFunc_kPlus(T left, T right) {
+  return left + right;
+}
+
+template <typename T, typename OpFunc>
+__device__ __forceinline__ void binaryOpKernel(
+    OpFunc func,
+    IBinary& instr,
+    Operand** operands,
+    int32_t blockBase,
+    void* shared,
+    ErrorCode& laneStatus) {
+  if (!laneActive(laneStatus)) {
+    return;
+  }
+  T left;
+  T right;
+  if (operandOrNull(operands, instr.left, blockBase, shared, left) &&
+      operandOrNull(operands, instr.right, blockBase, shared, right)) {
+    flatResult<decltype(func(left, right))>(
+        operands, instr.result, blockBase, shared) = func(left, right);
+  } else {
+    resultNull(operands, instr.result, blockBase, shared);
+  }
+}
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveDataSource.h b/velox/experimental/wave/exec/WaveDataSource.h
new file mode 100644
index 0000000000000..caf7c28f25043
--- /dev/null
+++ b/velox/experimental/wave/exec/WaveDataSource.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/time/Timer.h"
+#include "velox/connectors/Connector.h"
+#include "velox/exec/Task.h"
+#include "velox/experimental/wave/exec/WaveOperator.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::wave {
+
+class WaveSplitReader;
+
+/// A delegate produced by a regular Velox connector::DataSource for reading its
+/// particular file format on GPU. Same methods, except that Wave schedule() and
+/// related are exposed instead of an iterator model.
+class WaveDataSource : public std::enable_shared_from_this<WaveDataSource> {
+ public:
+  virtual ~WaveDataSource() = default;
+
+  /// Sets the operand ids of the subfields that are projected out.
+  void setOutputOperands(const DefinesMap& defines) {
+    defines_ = &defines;
+  }
+
+  virtual void addDynamicFilter(
+      column_index_t outputChannel,
+      const std::shared_ptr<common::Filter>& filter) = 0;
+
+  virtual void addSplit(std::shared_ptr<connector::ConnectorSplit> split) = 0;
+
+  virtual int32_t canAdvance(WaveStream& stream) = 0;
+
+  virtual void schedule(WaveStream& stream, int32_t maxRows = 0) = 0;
+
+  virtual bool isFinished() = 0;
+
+  virtual std::shared_ptr<WaveSplitReader> splitReader() = 0;
+
+  virtual uint64_t getCompletedBytes() = 0;
+
+  virtual uint64_t getCompletedRows() = 0;
+
+  virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() = 0;
+
+  virtual void setFromDataSource(std::shared_ptr<WaveDataSource> source) {
+    VELOX_UNSUPPORTED();
+  }
+
+ protected:
+  const DefinesMap* defines_{nullptr};
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveDriver.cpp b/velox/experimental/wave/exec/WaveDriver.cpp
index 24267e5c6be4d..f1e2f894853de 100644
--- a/velox/experimental/wave/exec/WaveDriver.cpp
+++ b/velox/experimental/wave/exec/WaveDriver.cpp
@@ -15,9 +15,18 @@
  */
 
 #include "velox/experimental/wave/exec/WaveDriver.h"
+#include <iostream>
+#include "velox/common/process/TraceContext.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/exec/Task.h"
 #include "velox/experimental/wave/exec/Instruction.h"
 #include "velox/experimental/wave/exec/WaveOperator.h"
 
+DEFINE_int32(
+    max_streams_per_driver,
+    4,
+    "Number of parallel Cuda streams per CPU thread");
+
 namespace facebook::velox::wave {
 
 WaveDriver::WaveDriver(
@@ -29,7 +38,9 @@ WaveDriver::WaveDriver(
     std::vector<std::unique_ptr<WaveOperator>> waveOperators,
     std::vector<OperandId> resultOrder,
     SubfieldMap subfields,
-    std::vector<std::unique_ptr<AbstractOperand>> operands)
+    std::vector<std::unique_ptr<AbstractOperand>> operands,
+    std::vector<std::unique_ptr<AbstractState>> states,
+    InstructionStatus instructionStatus)
     : exec::SourceOperator(
           driverCtx,
           outputType,
@@ -39,8 +50,13 @@ WaveDriver::WaveDriver(
       arena_(std::move(arena)),
       resultOrder_(std::move(resultOrder)),
       subfields_(std::move(subfields)),
-      operands_(std::move(operands)) {
+      operands_(std::move(operands)),
+      states_(std::move(states)),
+      instructionStatus_(instructionStatus) {
   VELOX_CHECK(!waveOperators.empty());
+  auto returnBatchSize = 10000 * outputType_->size() * 10;
+  deviceArena_ = std::make_unique<GpuArena>(
+      100000000, getDeviceAllocator(getDevice()), 400000000);
   pipelines_.emplace_back();
   for (auto& op : waveOperators) {
     op->setDriver(this);
@@ -49,77 +65,260 @@ WaveDriver::WaveDriver(
     }
     pipelines_.back().operators.push_back(std::move(op));
   }
+  pipelines_.back().needStatus = true;
+  // True unless ends with repartitioning.
+  pipelines_.back().makesHostResult = true;
+  pipelines_.front().canAdvance = true;
+}
+
+bool WaveDriver::shouldYield(
+    exec::StopReason taskStopReason,
+    size_t startTimeMs) const {
+  // Checks task-level yield signal, driver-level yield signal and table scan
+  // output processing time limit.
+  return taskStopReason == exec::StopReason::kYield ||
+      operatorCtx()->driverCtx()->driver->shouldYield() ||
+      ((getOutputTimeLimitMs_ != 0) &&
+       (getCurrentTimeMs() - startTimeMs) >= getOutputTimeLimitMs_);
 }
 
 RowVectorPtr WaveDriver::getOutput() {
-  VLOG(1) << "Getting output";
-  for (;;) {
-    startMore();
-    bool running = false;
-    for (int i = pipelines_.size() - 1; i >= 0; --i) {
-      if (pipelines_[i].streams.empty()) {
+  if (finished_) {
+    return nullptr;
+  }
+  startTimeMs_ = getCurrentTimeMs();
+  int32_t last = pipelines_.size() - 1;
+  try {
+    for (int32_t i = last; i >= 0; --i) {
+      if (!pipelines_[i].canAdvance) {
         continue;
       }
-      auto& op = *pipelines_[i].operators.back();
-      auto& lastSet = op.syncSet();
-      auto& streams = pipelines_[i].streams;
-      for (auto it = streams.begin(); it != streams.end();) {
-        auto& stream = *it;
-        if (!stream->isArrived(lastSet)) {
-          ++it;
-          continue;
-        }
-        RowVectorPtr result;
-        if (i + 1 < pipelines_.size()) {
-          auto waveResult = makeWaveResult(op.outputType(), *stream, lastSet);
-          VLOG(1) << "Enqueue " << waveResult->size() << " rows to pipeline "
-                  << i + 1;
-          pipelines_[i + 1].operators[0]->enqueue(std::move(waveResult));
-        } else {
-          result = makeResult(*stream, lastSet);
-          VLOG(1) << "Final output size: " << result->size();
-        }
-        if (streamAtEnd(*stream)) {
-          it = streams.erase(it);
-        } else {
-          ++it;
-        }
-        if (result) {
-          VLOG(1) << "Got output";
-          return result;
-        }
+      auto status = advance(i);
+      switch (status) {
+        case Advance::kBlocked:
+          updateStats();
+          return nullptr;
+        case Advance::kResult:
+          if (i == last) {
+            if (pipelines_[i].makesHostResult) {
+              return result_;
+            } else {
+              break;
+            }
+          }
+          pipelines_[i + 1].canAdvance = true;
+          i += 2;
+          break;
+        case Advance::kFinished:
+          pipelines_[i].canAdvance = false;
+          if (i == 0 || pipelines_[i].noMoreInput) {
+            flush(i);
+            if (i < last) {
+              pipelines_[i + 1].noMoreInput = true;
+              pipelines_[i + 1].canAdvance = true;
+              i += 2;
+              break;
+            } else {
+              // Last finished.
+              finished_ = true;
+              updateStats();
+              return nullptr;
+            }
+          }
+          break;
+      }
+    }
+  } catch (const std::exception& e) {
+    updateStats();
+    setError();
+    throw;
+  }
+  finished_ = true;
+  updateStats();
+  return nullptr;
+}
+
+void WaveDriver::flush(int32_t pipelineIdx) {
+  //
+  ;
+}
+
+namespace {
+void moveTo(
+    std::vector<std::unique_ptr<WaveStream>>& from,
+    int32_t i,
+    std::vector<std::unique_ptr<WaveStream>>& to,
+    bool toRun = false) {
+  if (!toRun) {
+    VELOX_CHECK(from[i]->state() != WaveStream::State::kParallel);
+  }
+  to.push_back(std::move(from[i]));
+  from.erase(from.begin() + i);
+}
+} // namespace
+
+exec::BlockingReason WaveDriver::processArrived(Pipeline& pipeline) {
+  for (auto streamIdx = 0; streamIdx < pipeline.arrived.size(); ++streamIdx) {
+    bool continued = false;
+    for (int32_t i = pipeline.operators.size() - 1; i >= 0; --i) {
+      auto reason = pipeline.operators[i]->isBlocked(&blockingFuture_);
+      if (reason != exec::BlockingReason::kNotBlocked) {
+        return reason;
       }
-      if (i + 1 < pipelines_.size()) {
-        pipelines_[i + 1].operators[0]->flush(
-            streams.empty() && pipelines_[i].operators[0]->isFinished());
+      auto advance =
+          pipeline.operators[i]->canAdvance(*pipeline.arrived[streamIdx]);
+      if (!advance.empty()) {
+        runOperators(
+            pipeline, *pipeline.arrived[streamIdx], i, advance.numRows);
+        moveTo(pipeline.arrived, i, pipeline.running, true);
+        continued = true;
+        break;
       }
-      running = true;
     }
-    if (!running) {
-      VLOG(1) << "No more output";
-      finished_ = true;
-      return nullptr;
+
+    if (continued) {
+      --streamIdx;
+    } else {
+      /// Not blocked and not continuable, so must be at end.
+      moveTo(pipeline.arrived, streamIdx, pipeline.finished);
+      --streamIdx;
     }
   }
+  return exec::BlockingReason::kNotBlocked;
 }
 
-bool WaveDriver::streamAtEnd(WaveStream& stream) {
-  return true;
+void WaveDriver::runOperators(
+    Pipeline& pipeline,
+    WaveStream& stream,
+    int32_t from,
+    int32_t numRows) {
+  // The stream is in 'host' state for any host to device data
+  // transfer, then in parallel state after first kernel launch.
+  ++stream.stats().numWaves;
+  stream.setState(WaveStream::State::kHost);
+  for (auto i = from; i < pipeline.operators.size(); ++i) {
+    pipeline.operators[i]->schedule(stream, numRows);
+  }
+  stream.resultToHost();
 }
 
-WaveVectorPtr WaveDriver::makeWaveResult(
-    const TypePtr& rowType,
-    WaveStream& stream,
-    const OperandSet& lastSet) {
-  std::vector<WaveVectorPtr> children(rowType->size());
-  int32_t nthChild = 0;
-  lastSet.forEach([&](int32_t id) {
-    auto exe = stream.operandExecutable(id);
-    VELOX_CHECK_NOT_NULL(exe);
-    auto ordinal = exe->outputOperands.ordinal(id);
-    children[nthChild++] = std::move(exe->output[ordinal]);
-  });
-  return std::make_unique<WaveVector>(rowType, *arena_, std::move(children));
+// Global counter for busy wait iterations.
+tsan_atomic<int64_t> totalWaitLoops;
+
+void WaveDriver::waitForArrival(Pipeline& pipeline) {
+  auto set = pipeline.operators.back()->syncSet();
+  int64_t waitLoops = 0;
+  WaveTimer timer(waveStats_.waitTime);
+  while (!pipeline.running.empty()) {
+    for (auto i = 0; i < pipeline.running.size(); ++i) {
+      auto waitUs = pipeline.running.size() == 1 ? 0 : 10;
+      if (pipeline.running[i]->isArrived(set, waitUs, 0)) {
+        incStats((pipeline.running[i]->stats()));
+        pipeline.running[i]->setState(WaveStream::State::kNotRunning);
+        moveTo(pipeline.running, i, pipeline.arrived);
+      }
+      ++waitLoops;
+    }
+  }
+  totalWaitLoops += waitLoops;
+}
+
+namespace {
+bool shouldStop(exec::StopReason taskStopReason) {
+  return taskStopReason != exec::StopReason::kNone &&
+      taskStopReason != exec::StopReason::kYield;
+}
+} // namespace
+
+Advance WaveDriver::advance(int pipelineIdx) {
+  auto& pipeline = pipelines_[pipelineIdx];
+  int64_t waitLoops = 0;
+  // Set to true when any stream is seen not ready, false when any stream is
+  // seen ready.
+  bool isWaiting = false;
+  // Time when a stream was first seen not ready.
+  int64_t waitingSince = 0;
+  // Total wait time. Incremented when isWaiting is set to false from true.
+  int64_t waitUs = 0;
+  for (;;) {
+    const exec::StopReason taskStopReason =
+        operatorCtx()->driverCtx()->task->shouldStop();
+    if (shouldStop(taskStopReason) ||
+        shouldYield(taskStopReason, startTimeMs_)) {
+      blockingReason_ = exec::BlockingReason::kYield;
+      blockingFuture_ = ContinueFuture{folly::Unit{}};
+      // A point for test code injection.
+      common::testutil::TestValue::adjust(
+          "facebook::velox::wave::WaveDriver::getOutput::yield", this);
+      totalWaitLoops += waitLoops;
+      waveStats_.waitTime.micros += waitUs;
+
+      return Advance::kBlocked;
+    }
+
+    if (pipeline.sinkFull) {
+      pipeline.sinkFull = false;
+      for (auto i = 0; i < pipeline.arrived.size(); ++i) {
+        pipeline.arrived[i]->resetSink();
+      }
+    }
+    blockingReason_ = processArrived(pipeline);
+    if (blockingReason_ != exec::BlockingReason::kNotBlocked) {
+      totalWaitLoops += waitLoops;
+      return Advance::kBlocked;
+    }
+    if (pipeline.running.empty() && pipeline.arrived.empty() &&
+        !pipeline.finished.empty()) {
+      totalWaitLoops += waitLoops;
+      return Advance::kFinished;
+    }
+    auto& op = *pipeline.operators.back();
+    auto& lastSet = op.syncSet();
+    for (auto i = 0; i < pipeline.running.size(); ++i) {
+      bool isArrived;
+      int64_t start = WaveTime::getMicro();
+      isArrived = pipeline.running[i]->isArrived(lastSet);
+      waveStats_.waitTime.micros += WaveTime::getMicro() - start;
+      if (isArrived) {
+        auto arrived = pipeline.running[i].get();
+        arrived->setState(WaveStream::State::kNotRunning);
+        incStats(arrived->stats());
+        if (isWaiting) {
+          waitUs += WaveTime::getMicro() - waitingSince;
+          isWaiting = false;
+        }
+        moveTo(pipeline.running, i, pipeline.arrived);
+        if (pipeline.makesHostResult) {
+          result_ = makeResult(*arrived, lastSet);
+          if (result_ && result_->size() != 0) {
+            totalWaitLoops += waitLoops;
+            waveStats_.waitTime.micros += waitUs;
+            return Advance::kResult;
+          }
+          --i;
+        } else if (arrived->isSinkFull()) {
+          pipeline.sinkFull = true;
+          waitForArrival(pipeline);
+          totalWaitLoops += waitLoops;
+          waveStats_.waitTime.micros += waitUs;
+          return Advance::kResult;
+        }
+      } else if (!isWaiting) {
+        waitingSince = WaveTime::getMicro();
+        isWaiting = true;
+      } else {
+        ++waitLoops;
+      }
+    }
+    if (pipeline.finished.empty() &&
+        pipeline.running.size() + pipeline.arrived.size() <
+            FLAGS_max_streams_per_driver) {
+      auto stream = std::make_unique<WaveStream>(
+          *arena_, *deviceArena_, &operands(), &stateMap_, instructionStatus_);
+      stream->setState(WaveStream::State::kHost);
+      pipeline.arrived.push_back(std::move(stream));
+    }
+  }
 }
 
 RowVectorPtr WaveDriver::makeResult(
@@ -127,44 +326,20 @@ RowVectorPtr WaveDriver::makeResult(
     const OperandSet& lastSet) {
   auto& last = *pipelines_.back().operators.back();
   auto& rowType = last.outputType();
+  auto operatorId = last.operatorId();
   std::vector<VectorPtr> children(rowType->size());
+  int32_t numRows = stream.getOutput(
+      operatorId, *operatorCtx_->pool(), resultOrder_, children.data());
   auto result = std::make_shared<RowVector>(
       operatorCtx_->pool(),
       rowType,
       BufferPtr(nullptr),
-      last.outputSize(stream),
+      numRows,
       std::move(children));
-  int32_t nthChild = 0;
-  for (auto id : resultOrder_) {
-    auto exe = stream.operandExecutable(id);
-    VELOX_CHECK_NOT_NULL(exe);
-    auto ordinal = exe->outputOperands.ordinal(id);
-    auto waveVector = std::move(exe->output[ordinal]);
-    result->childAt(nthChild++) = waveVector->toVelox(operatorCtx_->pool());
-  };
-  return result;
-}
-
-void WaveDriver::startMore() {
-  for (int i = 0; i < pipelines_.size(); ++i) {
-    auto& ops = pipelines_[i].operators;
-    if (auto rows = ops[0]->canAdvance()) {
-      VLOG(1) << "Advance " << rows << " rows in pipeline " << i;
-      auto stream = std::make_unique<WaveStream>(*arena_);
-      for (auto& op : ops) {
-        op->schedule(*stream, rows);
-      }
-      if (i == pipelines_.size() - 1) {
-        prefetchReturn(*stream);
-      }
-      pipelines_[i].streams.push_back(std::move(stream));
-      break;
-    }
+  if (!numRows) {
+    return nullptr;
   }
-}
-
-void WaveDriver::prefetchReturn(WaveStream& stream) {
-  // Schedule return buffers from last op to be on host side.
+  return result;
 }
 
 LaunchControl* WaveDriver::inputControl(
@@ -198,4 +373,58 @@ std::string WaveDriver::toString() const {
   return out.str();
 }
 
+void WaveDriver::setError() {
+  for (auto& pipeline : pipelines_) {
+    for (auto& stream : pipeline.running) {
+      stream->setError();
+    }
+  }
+}
+
+void WaveDriver::updateStats() {
+  auto lockedStats = stats_.wlock();
+  lockedStats->addRuntimeStat(
+      "wave.numWaves", RuntimeCounter(waveStats_.numWaves));
+  lockedStats->addRuntimeStat(
+      "wave.numKernels", RuntimeCounter(waveStats_.numKernels));
+  lockedStats->addRuntimeStat(
+      "wave.numThreadBlocks", RuntimeCounter(waveStats_.numThreadBlocks));
+  lockedStats->addRuntimeStat(
+      "wave.numThreads", RuntimeCounter(waveStats_.numThreads));
+  lockedStats->addRuntimeStat(
+      "wave.numPrograms", RuntimeCounter(waveStats_.numPrograms));
+  lockedStats->addRuntimeStat(
+      "wave.numSync", RuntimeCounter(waveStats_.numSync));
+  lockedStats->addRuntimeStat(
+      "wave.bytesToDevice",
+      RuntimeCounter(waveStats_.bytesToDevice, RuntimeCounter::Unit::kBytes));
+  lockedStats->addRuntimeStat(
+      "wave.bytesToHost",
+      RuntimeCounter(waveStats_.bytesToHost, RuntimeCounter::Unit::kBytes));
+  lockedStats->addRuntimeStat(
+      "wave.hostOnlyNanos",
+      RuntimeCounter(
+          waveStats_.hostOnlyTime.micros * 1000, RuntimeCounter::Unit::kNanos));
+  lockedStats->addRuntimeStat(
+      "wave.hostParallelNanos",
+      RuntimeCounter(
+          waveStats_.hostParallelTime.micros * 1000,
+          RuntimeCounter::Unit::kNanos));
+  lockedStats->addRuntimeStat(
+      "wave.waitNanos",
+      RuntimeCounter(
+          waveStats_.waitTime.micros * 1000, RuntimeCounter::Unit::kNanos));
+  lockedStats->addRuntimeStat(
+      "wave.stagingNanos",
+      RuntimeCounter(
+          waveStats_.stagingTime.micros * 1000, RuntimeCounter::Unit::kNanos));
+  if (FLAGS_wave_transfer_timing) {
+    lockedStats->addRuntimeStat(
+        "wave.transferWaitNanos",
+        RuntimeCounter(
+            waveStats_.transferWaitTime.micros * 1000,
+            RuntimeCounter::Unit::kNanos));
+  }
+}
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveDriver.h b/velox/experimental/wave/exec/WaveDriver.h
index c5c4359b891d7..f126cee2f369b 100644
--- a/velox/experimental/wave/exec/WaveDriver.h
+++ b/velox/experimental/wave/exec/WaveDriver.h
@@ -16,13 +16,12 @@
 
 #pragma once
 
+#include "velox/exec/Driver.h"
 #include "velox/exec/Operator.h"
 #include "velox/experimental/wave/exec/WaveOperator.h"
 
 namespace facebook::velox::wave {
-
-using SubfieldMap =
-    folly::F14FastMap<std::string, std::unique_ptr<common::Subfield>>;
+enum class Advance { kBlocked, kResult, kFinished };
 
 class WaveDriver : public exec::SourceOperator {
  public:
@@ -35,7 +34,9 @@ class WaveDriver : public exec::SourceOperator {
       std::vector<std::unique_ptr<WaveOperator>> waveOperators,
       std::vector<OperandId> resultOrder_,
       SubfieldMap subfields,
-      std::vector<std::unique_ptr<AbstractOperand>> operands);
+      std::vector<std::unique_ptr<AbstractOperand>> operands,
+      std::vector<std::unique_ptr<AbstractState>> states,
+      InstructionStatus instructionStatus);
 
   RowVectorPtr getOutput() override;
 
@@ -63,51 +64,111 @@ class WaveDriver : public exec::SourceOperator {
     return operands_;
   }
 
+  const SubfieldMap* subfields() {
+    return &subfields_;
+  }
+
   /// Returns the control block with thread block level sizes and statuses for
-  /// input of  operator with id 'operator'. This is te control for the source
+  /// input of  operator with id 'operator'. This is the control for the source
   /// or previous cardinality change.
   LaunchControl* inputControl(WaveStream& stream, int32_t operatorId);
 
   std::string toString() const override;
 
+  void addDynamicFilter(
+      const core::PlanNodeId& producer,
+      column_index_t outputChannel,
+      const std::shared_ptr<common::Filter>& filter) override {
+    pipelines_[0].operators[0]->addDynamicFilter(
+        producer, outputChannel, filter);
+  }
+
+  exec::OperatorCtx* operatorCtx() const {
+    return operatorCtx_.get();
+  }
+
  private:
+  struct Pipeline {
+    // Wave operators replacing 'cpuOperators_' on GPU path.
+    std::vector<std::unique_ptr<WaveOperator>> operators;
+
+    // The set of currently pending kernel DAGs for this Pipeline.  If the
+    // source operator can produce multiple consecutive batches before the batch
+    // is executed to completion, multiple such batches can be on device
+    // independently of each other. Limited by max_streams_per_driver.
+    std::vector<std::unique_ptr<WaveStream>> running;
+
+    std::vector<std::unique_ptr<WaveStream>> arrived;
+
+    std::vector<std::unique_ptr<WaveStream>> continuable;
+
+    std::vector<std::unique_ptr<WaveStream>> blocked;
+
+    /// Streams ready to recycle. A stream's device side resources are usually
+    /// reusable for a new batch from the source operator.
+    std::vector<std::unique_ptr<WaveStream>> finished;
+
+    /// True if status copy to host is needed after the last kernel. True if
+    /// returns vectors to host or if can produce multiple batches of output for
+    /// one input.
+    bool needStatus{false};
+    bool sinkFull{false};
+
+    /// True if produces Batches in RowVectors.
+    bool makesHostResult{false};
+    bool canAdvance{false};
+    bool noMoreInput{false};
+  };
+
   // True if all output from 'stream' is fetched.
   bool streamAtEnd(WaveStream& stream);
 
   // Makes a RowVector from the result buffers of the last stage of executables
   // in 'stream'.
   RowVectorPtr makeResult(WaveStream& stream, const OperandSet& outputIds);
+  Advance advance(int pipelineIdx);
+  exec::BlockingReason processArrived(Pipeline& pipeline);
+
+  // Waits for all streams of 'pipeline' to arrive. used for sink
+  // full, where we need a barrier between updating and processing the
+  // sink, like repartitioning or aggregation.
+  void waitForArrival(Pipeline& pipeline);
 
-  WaveVectorPtr makeWaveResult(
-      const TypePtr& rowType,
+  // Runs or continues operators starting at 'from'.
+  void runOperators(
+      Pipeline& pipeline,
       WaveStream& stream,
-      const OperandSet& lastSet);
+      int32_t from,
+      int32_t numRows);
+
+  // Finishes any pending activity, so that the final result at the
+  // end is ready to consume by another pipeline. This is called once,
+  // after there is guaranteed no more input.
+  void flush(int32_t pipelineIdx);
+
+  // Copies from 'waveStats_' to runtimeStates consumed by
+  // exec::Driver.
+  void updateStats();
 
-  // Starts another WaveStream if the source operator indicates it has more data
-  // and there is space in the arena.
-  void startMore();
+  bool shouldYield(exec::StopReason taskStopReason, size_t startTimeMs) const;
 
-  // Enqueus a prefetch from device to host for the buffers of output vectors.
-  void prefetchReturn(WaveStream& stream);
+  // Sets the WaveStreams to error state.
+  void setError();
 
   std::unique_ptr<GpuArena> arena_;
+  std::unique_ptr<GpuArena> deviceArena_;
 
   ContinueFuture blockingFuture_{ContinueFuture::makeEmpty()};
   exec::BlockingReason blockingReason_;
 
+  size_t startTimeMs_;
+  size_t getOutputTimeLimitMs_{0};
   bool finished_{false};
 
-  struct Pipeline {
-    // Wave operators replacing 'cpuOperators_' on GPU path.
-    std::vector<std::unique_ptr<WaveOperator>> operators;
-
-    // The set of currently pending kernel DAGs for this Pipeline.  If the
-    // source operator can produce multiple consecutive batches before the batch
-    // is executed to completion, multiple such batches can be on device
-    // independently of each other.  This is bounded by device memory and the
-    // speed at which the source can produce new batches.
-    std::list<std::unique_ptr<WaveStream>> streams;
-  };
+  void incStats(WaveStats& stats) {
+    waveStats_.add(stats);
+    stats.clear();
+  }
 
   std::vector<Pipeline> pipelines_;
 
@@ -121,6 +182,19 @@ class WaveDriver : public exec::SourceOperator {
   SubfieldMap subfields_;
   // Operands handed over by compilation.
   std::vector<std::unique_ptr<AbstractOperand>> operands_;
+
+  std::vector<std::unique_ptr<AbstractState>> states_;
+
+  WaveStats waveStats_;
+
+  // States shared between WaveStreams and WaveDrivers, for example join/group
+  // by tables.
+  OperatorStateMap stateMap_;
+
+  // Space reserved in BlockStatus array for instruction level return state.
+  InstructionStatus instructionStatus_;
+
+  RowVectorPtr result_;
 };
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveHiveDataSource.cpp b/velox/experimental/wave/exec/WaveHiveDataSource.cpp
new file mode 100644
index 0000000000000..7540518718a1c
--- /dev/null
+++ b/velox/experimental/wave/exec/WaveHiveDataSource.cpp
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/WaveHiveDataSource.h"
+
+namespace facebook::velox::wave {
+
+using namespace connector::hive;
+
+WaveHiveDataSource::WaveHiveDataSource(
+    const std::shared_ptr<HiveTableHandle>& hiveTableHandle,
+    const std::shared_ptr<common::ScanSpec>& scanSpec,
+    const RowTypePtr& readerOutputType,
+    std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
+        partitionKeys,
+    FileHandleFactory* fileHandleFactory,
+    folly::Executor* executor,
+    const connector::ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<HiveConfig>& hiveConfig,
+    const std::shared_ptr<io::IoStatistics>& ioStats,
+    const exec::ExprSet* remainingFilter,
+    std::shared_ptr<common::MetadataFilter> metadataFilter) {
+  params_.hiveTableHandle = hiveTableHandle;
+  params_.scanSpec = scanSpec;
+  params_.readerOutputType = readerOutputType;
+  params_.partitionKeys = partitionKeys;
+  params_.fileHandleFactory = fileHandleFactory;
+  params_.executor = executor;
+  params_.connectorQueryCtx = connectorQueryCtx;
+  params_.hiveConfig = hiveConfig;
+  params_.ioStats = ioStats;
+  remainingFilter_ = remainingFilter ? remainingFilter->exprs().at(0) : nullptr;
+  metadataFilter_ = metadataFilter;
+}
+
+void WaveHiveDataSource::addDynamicFilter(
+    column_index_t outputChannel,
+    const std::shared_ptr<common::Filter>& filter) {
+  VELOX_NYI();
+}
+
+void WaveHiveDataSource::setFromDataSource(
+    std::shared_ptr<WaveDataSource> sourceShared) {
+  auto source = dynamic_cast<WaveHiveDataSource*>(sourceShared.get());
+  VELOX_CHECK(source, "Bad DataSource type");
+
+  split_ = std::move(source->split_);
+  if (source->splitReader_ && source->splitReader_->emptySplit()) {
+    runtimeStats_.skippedSplits += source->runtimeStats_.skippedSplits;
+    runtimeStats_.skippedSplitBytes += source->runtimeStats_.skippedSplitBytes;
+    return;
+  }
+  source->params_.scanSpec->moveAdaptationFrom(*params_.scanSpec);
+  params_.scanSpec = std::move(source->params_.scanSpec);
+  splitReader_ = std::move(source->splitReader_);
+  // New io will be accounted on the stats of 'source'. Add the existing
+  // balance to that.
+  source->params_.ioStats->merge(*params_.ioStats);
+  params_.ioStats = std::move(source->params_.ioStats);
+}
+
+void WaveHiveDataSource::addSplit(
+    std::shared_ptr<connector::ConnectorSplit> split) {
+  VELOX_CHECK(
+      split_ == nullptr,
+      "Previous split has not been processed yet. Call next to process the split.");
+  split_ = std::dynamic_pointer_cast<HiveConnectorSplit>(split);
+  VELOX_CHECK(split_, "Wrong type of split");
+
+  VLOG(1) << "Adding split " << split_->toString();
+
+  if (splitReader_) {
+    splitReader_.reset();
+  }
+
+  splitReader_ = WaveSplitReader::create(split, params_, defines_);
+
+  // Split reader subclasses may need to use the reader options in prepareSplit
+  // so we initialize it beforehand.
+  splitReader_->configureReaderOptions();
+  splitReader_->prepareSplit(metadataFilter_, runtimeStats_);
+}
+
+int32_t WaveHiveDataSource::canAdvance(WaveStream& stream) {
+  if (!splitReader_) {
+    return 0;
+  }
+  auto numRows = splitReader_->canAdvance(stream);
+  if (numRows == 0) {
+    split_ = nullptr;
+  }
+  return numRows;
+}
+
+void WaveHiveDataSource::schedule(WaveStream& stream, int32_t maxRows) {
+  splitReader_->schedule(stream, maxRows);
+  // The stream must hold the reader tree. 'this' can initiate many
+  // concurrently running streams over potentially multiple splits.
+  stream.setSplitReader(splitReader_);
+}
+
+bool WaveHiveDataSource::isFinished() {
+  if (!splitReader_) {
+    return false;
+  }
+  if (splitReader_->isFinished()) {
+    auto stats = splitReader_->runtimeStats();
+    for (const auto& [name, counter] : stats) {
+      auto it = splitReaderStats_.find(name);
+      if (it == splitReaderStats_.end()) {
+        splitReaderStats_.insert(std::make_pair(name, counter));
+      } else {
+        splitReaderStats_.insert(std::make_pair(
+            name, RuntimeCounter(it->second.value, counter.unit)));
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+uint64_t WaveHiveDataSource::getCompletedBytes() {
+  return 0;
+}
+
+uint64_t WaveHiveDataSource::getCompletedRows() {
+  return completedRows_;
+}
+
+std::unordered_map<std::string, RuntimeCounter>
+WaveHiveDataSource::runtimeStats() {
+  auto map = runtimeStats_.toMap();
+  for (const auto& [name, counter] : splitReaderStats_) {
+    map.insert(std::make_pair(name, counter));
+  }
+  return map;
+}
+
+// static
+void WaveHiveDataSource::registerConnector() {
+  static bool registered = false;
+  if (registered) {
+    return;
+  }
+  registered = true;
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>());
+
+  // Create hive connector with config...
+  auto hiveConnector =
+      connector::getConnectorFactory(
+          connector::hive::HiveConnectorFactory::kHiveConnectorName)
+          ->newConnector("wavemock", config, nullptr);
+  connector::registerConnector(hiveConnector);
+  connector::hive::HiveDataSource::registerWaveDelegateHook(
+      [](const std::shared_ptr<HiveTableHandle>& hiveTableHandle,
+         const std::shared_ptr<common::ScanSpec>& scanSpec,
+         const RowTypePtr& readerOutputType,
+         std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
+             partitionKeys,
+         FileHandleFactory* fileHandleFactory,
+         folly::Executor* executor,
+         const connector::ConnectorQueryCtx* connectorQueryCtx,
+         const std::shared_ptr<HiveConfig>& hiveConfig,
+         const std::shared_ptr<io::IoStatistics>& ioStats,
+         const exec::ExprSet* remainingFilter,
+         std::shared_ptr<common::MetadataFilter> metadataFilter) {
+        return std::make_shared<WaveHiveDataSource>(
+            hiveTableHandle,
+            scanSpec,
+            readerOutputType,
+
+            partitionKeys,
+            fileHandleFactory,
+            executor,
+            connectorQueryCtx,
+            hiveConfig,
+            ioStats,
+            remainingFilter,
+            metadataFilter);
+      });
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveHiveDataSource.h b/velox/experimental/wave/exec/WaveHiveDataSource.h
new file mode 100644
index 0000000000000..7e1336ab4f571
--- /dev/null
+++ b/velox/experimental/wave/exec/WaveHiveDataSource.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include "velox/connectors/hive/HiveDataSource.h"
+#include "velox/experimental/wave/exec/WaveDataSource.h"
+#include "velox/experimental/wave/exec/WaveSplitReader.h"
+
+namespace facebook::velox::wave {
+
+class WaveHiveDataSource : public WaveDataSource {
+ public:
+  WaveHiveDataSource(
+      const std::shared_ptr<connector::hive::HiveTableHandle>& hiveTableHandle,
+      const std::shared_ptr<common::ScanSpec>& scanSpec,
+      const RowTypePtr& readerOutputType,
+      std::unordered_map<
+          std::string,
+          std::shared_ptr<connector::hive::HiveColumnHandle>>* partitionKeys,
+      FileHandleFactory* fileHandleFactory,
+      folly::Executor* executor,
+      const connector::ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<connector::hive::HiveConfig>& hiveConfig,
+      const std::shared_ptr<io::IoStatistics>& ioStats,
+      const exec::ExprSet* remainingFilter,
+      std::shared_ptr<common::MetadataFilter> metadataFilter);
+
+  void addDynamicFilter(
+      column_index_t outputChannel,
+      const std::shared_ptr<common::Filter>& filter) override;
+
+  void addSplit(std::shared_ptr<connector::ConnectorSplit> split) override;
+
+  void setFromDataSource(std::shared_ptr<WaveDataSource> dataSource) override;
+
+  int32_t canAdvance(WaveStream& stream) override;
+
+  void schedule(WaveStream& stream, int32_t maxRows) override;
+
+  bool isFinished() override;
+
+  std::shared_ptr<WaveSplitReader> splitReader() override {
+    return splitReader_;
+  }
+
+  uint64_t getCompletedBytes() override;
+
+  uint64_t getCompletedRows() override;
+
+  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override;
+
+  static void registerConnector();
+
+ private:
+  SplitReaderParams params_;
+  std::shared_ptr<connector::ConnectorSplit> split_;
+  std::shared_ptr<WaveSplitReader> splitReader_;
+  std::shared_ptr<exec::Expr> remainingFilter_;
+  dwio::common::RuntimeStatistics runtimeStats_;
+  std::shared_ptr<common::MetadataFilter> metadataFilter_;
+  int64_t completedRows_{0};
+  int64_t completedBytes_{0};
+  std::unordered_map<std::string, RuntimeCounter> splitReaderStats_;
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveOperator.cpp b/velox/experimental/wave/exec/WaveOperator.cpp
index e72626085c3a3..3ed89becfe652 100644
--- a/velox/experimental/wave/exec/WaveOperator.cpp
+++ b/velox/experimental/wave/exec/WaveOperator.cpp
@@ -16,40 +16,59 @@
 
 #include "velox/experimental/wave/exec/WaveOperator.h"
 #include "velox/experimental/wave/exec/ToWave.h"
+#include "velox/experimental/wave/exec/WaveDriver.h"
 
 namespace facebook::velox::wave {
 
-WaveOperator::WaveOperator(CompileState& state, const RowTypePtr& type)
-    : id_(state.numOperators()), outputType_(type) {
-  definesSubfields(state, outputType_);
-}
+WaveOperator::WaveOperator(
+    CompileState& state,
+    const RowTypePtr& type,
+    const std::string& planNodeId)
+    : id_(state.numOperators()), planNodeId_(planNodeId), outputType_(type) {}
 
-void WaveOperator::definesSubfields(
+AbstractOperand* WaveOperator::definesSubfield(
     CompileState& state,
     const TypePtr& type,
-    const std::string& parentPath) {
+    const std::string& parentPath,
+    bool sourceNullable) {
   switch (type->kind()) {
     case TypeKind::ROW: {
       auto& row = type->as<TypeKind::ROW>();
       for (auto i = 0; i < type->size(); ++i) {
         auto& child = row.childAt(i);
         auto name = row.nameOf(i);
-        auto field = state.toSubfield(name);
-        subfields_.push_back(field);
-        types_.push_back(child);
-        auto operand = state.findCurrentValue(Value(field));
-        if (!operand) {
-          operand = state.newOperand(child, name);
-        }
-        outputIds_.add(operand->id);
-        defines_[Value(field)] = operand;
+        std::string childPath = fmt::format("{}.{}", parentPath, name);
+        definesSubfield(state, child, childPath, sourceNullable);
       }
     }
+      [[fallthrough]];
       // TODO:Add cases for nested types.
     default: {
-      return;
+      auto field = state.toSubfield(parentPath);
+      subfields_.push_back(field);
+      types_.push_back(type);
+      auto operand = state.findCurrentValue(Value(field));
+      if (!operand) {
+        operand = state.newOperand(type, parentPath);
+      }
+      if (sourceNullable && !operand->notNull && !operand->conditionalNonNull) {
+        operand->sourceNullable = true;
+      }
+      defines_[Value(field)] = operand;
+
+      return operand;
     }
   }
 }
 
+folly::Synchronized<exec::OperatorStats>& WaveOperator::stats() {
+  return driver_->stats();
+}
+
+std::string WaveOperator::toString() const {
+  std::stringstream out;
+  out << "Id: " << id_ << " produces " << outputIds_.toString() << std::endl;
+  return out.str();
+}
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveOperator.h b/velox/experimental/wave/exec/WaveOperator.h
index c57dc20ff6650..abf380fd8ebff 100644
--- a/velox/experimental/wave/exec/WaveOperator.h
+++ b/velox/experimental/wave/exec/WaveOperator.h
@@ -16,8 +16,10 @@
 
 #pragma once
 
+#include "velox/exec/Driver.h"
 #include "velox/experimental/wave/exec/Wave.h"
 #include "velox/experimental/wave/vector/WaveVector.h"
+#include "velox/type/Filter.h"
 
 namespace facebook::velox::wave {
 
@@ -26,10 +28,17 @@ class WaveDriver;
 
 class WaveOperator {
  public:
-  WaveOperator(CompileState& state, const RowTypePtr& outputType);
+  WaveOperator(
+      CompileState& state,
+      const RowTypePtr& outputType,
+      const std::string& planNodeId);
 
   virtual ~WaveOperator() = default;
 
+  virtual exec::BlockingReason isBlocked(ContinueFuture* future) {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
   const RowTypePtr& outputType() const {
     return outputType_;
   }
@@ -44,6 +53,10 @@ class WaveOperator {
     return isExpanding_;
   }
 
+  virtual bool isSource() const {
+    return false;
+  }
+
   virtual bool isStreaming() const = 0;
 
   virtual void enqueue(WaveVectorPtr) {
@@ -65,8 +78,8 @@ class WaveOperator {
   /// Returns how many rows of output are available from 'this'. Source
   /// operators and cardinality increasing operators must return a correct
   /// answer if they are ready to produce data. Others should return 0.
-  virtual int32_t canAdvance() {
-    return 0;
+  virtual AdvanceResult canAdvance(WaveStream& stream) {
+    return {.numRows = 0};
   }
 
   /// Adds processing for 'this' to 'stream'. If 'maxRows' is given,
@@ -84,12 +97,17 @@ class WaveOperator {
     VELOX_FAIL("Override for source or blocking operator");
   }
 
-  virtual std::string toString() const = 0;
+  virtual bool isSink() const {
+    return false;
+  }
+
+  virtual std::string toString() const;
 
-  void definesSubfields(
+  AbstractOperand* definesSubfield(
       CompileState& state,
       const TypePtr& type,
-      const std::string& parentPath = "");
+      const std::string& parentPath = "",
+      bool sourceNullable = false);
 
   /// Returns the operand if this is defined by 'this'.
   AbstractOperand* defines(Value value) {
@@ -100,27 +118,29 @@ class WaveOperator {
     return it->second;
   }
 
+  /// Marks 'operand' as defined here.
+  void defined(Value value, AbstractOperand* op) {
+    defines_[value] = op;
+  }
+
   void setDriver(WaveDriver* driver) {
     driver_ = driver;
   }
 
-  // Returns the number of non-filtered out result rows in the invocation inside
-  // 'stream'. 'this' must have had schedule() called with the same stream and
-  // the stream must have arrived. The actual result rows may be non-contiguous
-  // in the result vectors and may need indirection to access, as seen in output
-  // operands of the corresponding executables.
-  virtual vector_size_t outputSize(WaveStream& stream) const = 0;
-
   const OperandSet& outputIds() const {
     return outputIds_;
   }
 
+  void addOutputId(OperandId id) {
+    outputIds_.add(id);
+  }
+
   // The set of output operands that must have arrived for there to be a result.
   virtual const OperandSet& syncSet() const {
     return outputIds_;
   }
 
-  /// Called once on each Operator, fiest to last, after no more
+  /// Called once on each Operator, first to last, after no more
   /// Operators will be added to the WaveDriver plan. Can be used for
   /// e.g. making executable images of Programs since their content
   /// and dependences will no longer change.
@@ -130,8 +150,21 @@ class WaveOperator {
     return id_;
   }
 
+  virtual bool canAddDynamicFilter() const {
+    return false;
+  }
+
+  virtual void addDynamicFilter(
+      const core::PlanNodeId& /*producer*/,
+      column_index_t /*outputChannel*/,
+      const std::shared_ptr<common::Filter>& /*filter*/) {
+    VELOX_UNSUPPORTED();
+  }
+
  protected:
-  // Sequence number in WaveOperator sequence inside WaveDriver. IUsed to label
+  folly::Synchronized<exec::OperatorStats>& stats();
+
+  // Sequence number in WaveOperator sequence inside WaveDriver. Used to label
   // states of different oprators in WaveStream.
   int32_t id_;
 
@@ -146,6 +179,9 @@ class WaveOperator {
   // Pairwise type for each subfield.
   std::vector<TypePtr> types_;
 
+  // Id in original plan. Use for getting splits.
+  std::string planNodeId_;
+
   // the execution time set of OperandIds.
   OperandSet outputIds_;
 
@@ -156,12 +192,10 @@ class WaveOperator {
   RowTypePtr outputType_;
 
   // The operands that are first defined here.
-  folly::F14FastMap<Value, AbstractOperand*, ValueHasher, ValueComparer>
-      defines_;
+  DefinesMap defines_;
 
   // The operand for values that are projected through 'this'.
-  folly::F14FastMap<Value, AbstractOperand*, ValueHasher, ValueComparer>
-      projects_;
+  DefinesMap projects_;
 
   std::vector<std::shared_ptr<Program>> programs_;
 
@@ -177,4 +211,16 @@ class WaveOperator {
   std::vector<WaveBufferPtr> executableMemory_;
 };
 
+class WaveSourceOperator : public WaveOperator {
+ public:
+  WaveSourceOperator(
+      CompileState& state,
+      const RowTypePtr& outputType,
+      const std::string& planNodeId)
+      : WaveOperator(state, outputType, planNodeId) {}
+  bool isSource() const override {
+    return true;
+  }
+};
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveSplitReader.cpp b/velox/experimental/wave/exec/WaveSplitReader.cpp
new file mode 100644
index 0000000000000..330027b49fb04
--- /dev/null
+++ b/velox/experimental/wave/exec/WaveSplitReader.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/WaveSplitReader.h"
+
+namespace facebook::velox::wave {
+std::shared_ptr<WaveSplitReader> WaveSplitReader::create(
+    const std::shared_ptr<velox::connector::ConnectorSplit>& split,
+    const SplitReaderParams& params,
+    const DefinesMap* defines) {
+  for (auto& factory : factories_) {
+    auto result = factory->create(split, params, defines);
+    if (result) {
+      return result;
+    }
+  }
+  VELOX_FAIL("No WaveSplitReader for  {}", split->toString());
+}
+
+std::vector<std::unique_ptr<WaveSplitReaderFactory>>
+    WaveSplitReader::factories_;
+
+// static
+void WaveSplitReader::registerFactory(
+    std::unique_ptr<WaveSplitReaderFactory> factory) {
+  factories_.push_back(std::move(factory));
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/WaveSplitReader.h b/velox/experimental/wave/exec/WaveSplitReader.h
new file mode 100644
index 0000000000000..3bd4e6a7cc542
--- /dev/null
+++ b/velox/experimental/wave/exec/WaveSplitReader.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/time/Timer.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/common/ScanSpec.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/exec/Task.h"
+#include "velox/experimental/wave/exec/WaveOperator.h"
+
+namespace facebook::velox::wave {
+
+/// Parameters for a Wave Hive SplitReaderFactory.
+struct SplitReaderParams {
+  std ::shared_ptr<connector::hive::HiveTableHandle> hiveTableHandle;
+  std::shared_ptr<common::ScanSpec> scanSpec;
+  RowTypePtr readerOutputType;
+  std::unordered_map<
+      std::string,
+      std::shared_ptr<connector::hive::HiveColumnHandle>>* partitionKeys;
+  FileHandleFactory* fileHandleFactory;
+  folly::Executor* executor;
+  const connector::ConnectorQueryCtx* connectorQueryCtx;
+  std::shared_ptr<connector::hive::HiveConfig> hiveConfig;
+  std::shared_ptr<io::IoStatistics> ioStats;
+};
+
+class WaveSplitReaderFactory;
+
+class WaveSplitReader {
+ public:
+  virtual ~WaveSplitReader() = default;
+
+  static std::shared_ptr<WaveSplitReader> create(
+      const std::shared_ptr<velox::connector::ConnectorSplit>& split,
+      const SplitReaderParams& params,
+      const DefinesMap* defines);
+
+  virtual bool emptySplit() = 0;
+
+  virtual int32_t canAdvance(WaveStream& stream) = 0;
+
+  virtual void schedule(WaveStream& stream, int32_t maxRows) = 0;
+
+  virtual bool isFinished() const = 0;
+
+  virtual uint64_t getCompletedBytes() = 0;
+
+  virtual uint64_t getCompletedRows() = 0;
+
+  virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() = 0;
+
+  virtual void configureReaderOptions() {}
+  virtual void prepareSplit(
+      std::shared_ptr<common::MetadataFilter> metadataFilter,
+      dwio::common::RuntimeStatistics& runtimeStats) {}
+
+  static void registerFactory(std::unique_ptr<WaveSplitReaderFactory> factory);
+
+  static std::vector<std::unique_ptr<WaveSplitReaderFactory>> factories_;
+};
+
+class WaveSplitReaderFactory {
+ public:
+  virtual ~WaveSplitReaderFactory() = default;
+
+  /// Returns a new split reader corresponding to 'split' if 'this' recognizes
+  /// the split, otherwise returns nullptr.
+  virtual std::shared_ptr<WaveSplitReader> create(
+      const std::shared_ptr<connector::ConnectorSplit>& split,
+      const SplitReaderParams& params,
+      const DefinesMap* defines) = 0;
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/tests/AggregationTest.cpp b/velox/experimental/wave/exec/tests/AggregationTest.cpp
index 499cc36bad55a..847e8c11d6306 100644
--- a/velox/experimental/wave/exec/tests/AggregationTest.cpp
+++ b/velox/experimental/wave/exec/tests/AggregationTest.cpp
@@ -49,13 +49,17 @@ class AggregationTest : public OperatorTestBase {
   }
 
   void SetUp() override {
+    GTEST_SKIP() << "Skipped until aggregation remodeling is complete";
+    OperatorTestBase::SetUp();
     if (int device; cudaGetDevice(&device) != cudaSuccess) {
       GTEST_SKIP() << "No CUDA detected, skipping all tests";
     }
   }
+
+  void TearDown() override {}
 };
 
-TEST_F(AggregationTest, singleKeySingleAggregate) {
+TEST_F(AggregationTest, DISABLED_singleKeySingleAggregate) {
   constexpr int kSize = 10;
   auto vector = makeRowVector({
       makeFlatVector<int64_t>(kSize, [](int i) { return i % 3; }),
@@ -72,7 +76,7 @@ TEST_F(AggregationTest, singleKeySingleAggregate) {
   AssertQueryBuilder(plan).assertResults(expected);
 }
 
-TEST_F(AggregationTest, singleKeyMultiAggregate) {
+TEST_F(AggregationTest, DISABLED_singleKeyMultiAggregate) {
   constexpr int kSize = 10;
   auto vector = makeRowVector({
       makeFlatVector<int64_t>(kSize, [](int i) { return i % 3; }),
@@ -92,7 +96,7 @@ TEST_F(AggregationTest, singleKeyMultiAggregate) {
   AssertQueryBuilder(plan).assertResults(expected);
 }
 
-TEST_F(AggregationTest, multiKeySingleAggregate) {
+TEST_F(AggregationTest, DISABLED_multiKeySingleAggregate) {
   constexpr int kSize = 10;
   // 0 1 0 1 0 1 0 1 0 1
   // 0 1 2 0 1 2 0 1 2 0
@@ -114,7 +118,7 @@ TEST_F(AggregationTest, multiKeySingleAggregate) {
   AssertQueryBuilder(plan).assertResults(expected);
 }
 
-TEST_F(AggregationTest, tpchQ1) {
+TEST_F(AggregationTest, DISABLED_tpchQ1) {
   // TODO: Use StringView instead of int64_t for keys.
   struct {
     std::uniform_int_distribution<> returnflag{0, 2};
@@ -227,9 +231,3 @@ TEST_F(AggregationTest, tpchQ1) {
 
 } // namespace
 } // namespace facebook::velox::wave
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-  folly::Init follyInit(&argc, &argv);
-  return RUN_ALL_TESTS();
-}
diff --git a/velox/experimental/wave/exec/tests/CMakeLists.txt b/velox/experimental/wave/exec/tests/CMakeLists.txt
index 74feddf6cf066..ae58682051025 100644
--- a/velox/experimental/wave/exec/tests/CMakeLists.txt
+++ b/velox/experimental/wave/exec/tests/CMakeLists.txt
@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_wave_exec_test FilterProjectTest.cpp Main.cpp)
+add_subdirectory(utils)
 
-set_target_properties(velox_wave_exec_test PROPERTIES CUDA_ARCHITECTURES native)
-
-add_test(velox_wave_exec_test velox_wave_exec_test)
+add_executable(velox_wave_exec_test FilterProjectTest.cpp TableScanTest.cpp
+                                    AggregationTest.cpp Main.cpp)
 
 target_link_libraries(
   velox_wave_exec_test
   velox_wave_exec
+  velox_wave_mock_reader
   velox_aggregates
   velox_dwio_common
   velox_dwio_common_exception
@@ -56,3 +56,51 @@ target_link_libraries(
   glog::glog
   fmt::fmt
   ${FILESYSTEM})
+
+add_test(velox_wave_exec_test velox_wave_exec_test)
+
+if(${VELOX_ENABLE_BENCHMARKS})
+  add_executable(velox_wave_benchmark WaveBenchmark.cpp)
+
+  target_link_libraries(
+    velox_wave_benchmark
+    velox_query_benchmark
+    velox_wave_exec
+    velox_wave_mock_reader
+    velox_aggregates
+    velox_dwio_common
+    velox_dwio_common_exception
+    velox_dwio_common_test_utils
+    velox_dwio_parquet_reader
+    velox_dwio_parquet_writer
+    velox_exec
+    velox_exec_test_lib
+    velox_functions_json
+    velox_functions_lib
+    velox_functions_prestosql
+    velox_functions_test_lib
+    velox_hive_connector
+    velox_memory
+    velox_serialization
+    velox_test_util
+    velox_type
+    velox_vector
+    velox_vector_fuzzer
+    Boost::atomic
+    Boost::context
+    Boost::date_time
+    Boost::filesystem
+    Boost::program_options
+    Boost::regex
+    Boost::thread
+    Boost::system
+    gtest
+    gtest_main
+    gmock
+    ${FOLLY_BENCHMARK}
+    Folly::folly
+    gflags::gflags
+    glog::glog
+    fmt::fmt
+    ${FILESYSTEM})
+endif()
diff --git a/velox/experimental/wave/exec/tests/FilterProjectTest.cpp b/velox/experimental/wave/exec/tests/FilterProjectTest.cpp
index 3b7fdb3a94ce9..80db5896c5b17 100644
--- a/velox/experimental/wave/exec/tests/FilterProjectTest.cpp
+++ b/velox/experimental/wave/exec/tests/FilterProjectTest.cpp
@@ -30,6 +30,7 @@ using facebook::velox::test::BatchMaker;
 class FilterProjectTest : public OperatorTestBase {
  protected:
   void SetUp() override {
+    OperatorTestBase::SetUp();
     if (int device; cudaGetDevice(&device) != cudaSuccess) {
       GTEST_SKIP() << "No CUDA detected, skipping all tests";
     }
@@ -67,6 +68,26 @@ class FilterProjectTest : public OperatorTestBase {
     auto task = assertQuery(plan, "SELECT c0, c1, c0 + c1 FROM tmp");
   }
 
+  std::shared_ptr<Task> assertFilterProject(
+      const std::string& filter,
+      const std::vector<std::string>& projections,
+      const std::vector<RowVectorPtr>& vectors) {
+    auto plan = PlanBuilder()
+                    .values(vectors)
+                    .filter(filter)
+                    .project(projections)
+                    .planNode();
+    std::stringstream sql;
+    sql << "SELECT ";
+    for (auto i = 0; i < projections.size(); ++i) {
+      sql << " " << projections[i] << (i == projections.size() - 1 ? "" : ",");
+    }
+    sql << " FROM tmp WHERE " << filter;
+
+    auto task = assertQuery(plan, sql.str());
+    return task;
+  }
+
   std::shared_ptr<const RowType> rowType_{
       ROW({"c0", "c1", "c2", "c3"},
           {BIGINT(), BIGINT(), SMALLINT(), DOUBLE()})};
@@ -96,3 +117,19 @@ TEST_F(FilterProjectTest, project) {
 
   assertProject(vectors);
 }
+
+TEST_F(FilterProjectTest, filterProject) {
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 1; ++i) {
+    auto vector = std::dynamic_pointer_cast<RowVector>(
+        BatchMaker::createBatch(rowType_, 100, *pool_));
+    makeNotNull(vector, 1000000000);
+    vectors.push_back(vector);
+  }
+  createDuckDbTable(vectors);
+
+  assertFilterProject(
+      "c0 < 400000000",
+      std::vector<std::string>{"c0", "c1", "c1 + c0 as s", "c2", "c3"},
+      vectors);
+}
diff --git a/velox/experimental/wave/exec/tests/Main.cpp b/velox/experimental/wave/exec/tests/Main.cpp
index 970f35d8180a4..a54054a9a2667 100644
--- a/velox/experimental/wave/exec/tests/Main.cpp
+++ b/velox/experimental/wave/exec/tests/Main.cpp
@@ -17,13 +17,20 @@
 
 #include <folly/Unit.h>
 #include <folly/init/Init.h>
+#include <gflags/gflags.h>
 #include <gtest/gtest.h>
+#include "velox/experimental/wave/common/Cuda.h"
+
+DEFINE_bool(list_kernels, false, "Print register use of kernels");
 
 // This main is needed for some tests on linux.
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   // Signal handler required for ThreadDebugInfoTest
   facebook::velox::process::addDefaultFatalSignalHandler();
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
+  if (FLAGS_list_kernels) {
+    facebook::velox::wave::printKernels();
+  }
   return RUN_ALL_TESTS();
 }
diff --git a/velox/experimental/wave/exec/tests/TableScanTest.cpp b/velox/experimental/wave/exec/tests/TableScanTest.cpp
new file mode 100644
index 0000000000000..bbf092f67ad0d
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/TableScanTest.cpp
@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <cuda_runtime.h> // @manual
+#include "velox/common/base/tests/GTestUtils.h"
+
+#include "velox/exec/ExchangeSource.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/LocalExchangeSource.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/experimental/wave/exec/ToWave.h"
+#include "velox/experimental/wave/exec/WaveHiveDataSource.h"
+#include "velox/experimental/wave/exec/tests/utils/FileFormat.h"
+#include "velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DECLARE_int32(wave_max_reader_batch_rows);
+DECLARE_int32(max_streams_per_driver);
+DECLARE_int32(wave_reader_rows_per_tb);
+
+using namespace facebook::velox;
+using namespace facebook::velox::core;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+struct WaveScanTestParam {
+  int32_t numStreams{1};
+  int32_t batchSize{20000};
+  int32_t rowsPerTB{1024};
+};
+
+std::vector<WaveScanTestParam> waveScanTestParams() {
+  return {
+      WaveScanTestParam{},
+      WaveScanTestParam{.numStreams = 4, .rowsPerTB = 4096},
+      WaveScanTestParam{.numStreams = 4, .batchSize = 1111},
+      WaveScanTestParam{.numStreams = 9, .batchSize = 16500},
+      WaveScanTestParam{
+          .numStreams = 2, .batchSize = 20000, .rowsPerTB = 20480}};
+}
+
+class TableScanTest : public virtual HiveConnectorTestBase,
+                      public testing::WithParamInterface<WaveScanTestParam> {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    if (int device; cudaGetDevice(&device) != cudaSuccess) {
+      GTEST_SKIP() << "No CUDA detected, skipping all tests";
+    }
+    wave::registerWave();
+    wave::WaveHiveDataSource::registerConnector();
+    wave::test::WaveTestSplitReader::registerTestSplitReader();
+    exec::ExchangeSource::factories().clear();
+    exec::ExchangeSource::registerFactory(createLocalExchangeSource);
+    fuzzer_ = std::make_unique<VectorFuzzer>(options_, pool_.get());
+    auto param = GetParam();
+    FLAGS_max_streams_per_driver = param.numStreams;
+    FLAGS_wave_max_reader_batch_rows = param.batchSize;
+    FLAGS_wave_reader_rows_per_tb = param.rowsPerTB;
+  }
+
+  static void SetUpTestCase() {
+    OperatorTestBase::SetUpTestCase();
+  }
+
+  void TearDown() override {
+    vectors_.clear();
+    wave::test::Table::dropAll();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  auto makeData(
+      const RowTypePtr& type,
+      int32_t numVectors,
+      int32_t vectorSize,
+      bool notNull = true,
+      std::function<void(RowVectorPtr)> custom = nullptr) {
+    vectors_ = makeVectors(type, numVectors, vectorSize, notNull ? 0 : 0.1);
+    int32_t cnt = 0;
+    for (auto& vector : vectors_) {
+      if (custom) {
+        custom(vector);
+      } else {
+        makeRange(vector, 1000000000, notNull);
+      }
+      auto rn = vector->childAt(type->size() - 1)->as<FlatVector<int64_t>>();
+      for (auto i = 0; i < rn->size(); ++i) {
+        rn->set(i, cnt++);
+      }
+    }
+    auto splits = makeTable("test", vectors_);
+    createDuckDbTable(vectors_);
+    if (dumpData_) {
+      toFile();
+    }
+    return splits;
+  }
+
+  std::vector<RowVectorPtr> makeVectors(
+      const RowTypePtr& rowType,
+      int32_t numVectors,
+      int32_t rowsPerVector,
+      float nullRatio = 0) {
+    std::vector<RowVectorPtr> vectors;
+    options_.vectorSize = rowsPerVector;
+    options_.nullRatio = nullRatio;
+    fuzzer_->setOptions(options_);
+
+    for (int32_t i = 0; i < numVectors; ++i) {
+      auto vector = fuzzer_->fuzzInputFlatRow(rowType);
+      vectors.push_back(vector);
+    }
+    return vectors;
+  }
+
+  void makeRange(
+      RowVectorPtr row,
+      int64_t mod = std::numeric_limits<int64_t>::max(),
+      bool notNull = true,
+      int32_t begin = -1,
+      int32_t end = -1) {
+    if (begin == -1) {
+      begin = 0;
+    }
+    if (end == -1) {
+      end = row->type()->size();
+    }
+    for (auto i = begin; i < end; ++i) {
+      auto child = row->childAt(i);
+      if (auto ints = child->as<FlatVector<int64_t>>()) {
+        for (auto i = 0; i < child->size(); ++i) {
+          if (!notNull && ints->isNullAt(i)) {
+            continue;
+          }
+          ints->set(i, ints->valueAt(i) % mod);
+        }
+      }
+      if (notNull) {
+        child->clearNulls(0, row->size());
+      }
+    }
+  }
+
+  wave::test::SplitVector makeTable(
+      const std::string& name,
+      std::vector<RowVectorPtr>& rows) {
+    wave::test::Table::dropTable(name);
+    return wave::test::Table::defineTable(name, rows)->splits();
+  }
+
+  std::shared_ptr<Task> assertQuery(
+      const PlanNodePtr& plan,
+      const wave::test::SplitVector& splits,
+      const std::string& duckDbSql) {
+    return OperatorTestBase::assertQuery(plan, splits, duckDbSql);
+  }
+
+  std::shared_ptr<Task> assertQuery(
+      const PlanNodePtr& plan,
+      const wave::test::SplitVector& splits,
+      const std::string& duckDbSql,
+      const int32_t numPrefetchSplit) {
+    return AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .config(
+            core::QueryConfig::kMaxSplitPreloadPerDriver,
+            std::to_string(numPrefetchSplit))
+        .splits(splits)
+        .assertResults(duckDbSql);
+  }
+
+  core::PlanNodePtr tableScanNode(const RowTypePtr& outputType) {
+    return PlanBuilder(pool_.get()).tableScan(outputType).planNode();
+  }
+
+  static PlanNodeStats getTableScanStats(const std::shared_ptr<Task>& task) {
+    auto planStats = toPlanStats(task->taskStats());
+    return std::move(planStats.at("0"));
+  }
+
+  static std::unordered_map<std::string, RuntimeMetric>
+  getTableScanRuntimeStats(const std::shared_ptr<Task>& task) {
+    return task->taskStats().pipelineStats[0].operatorStats[0].runtimeStats;
+  }
+
+  static int64_t getSkippedStridesStat(const std::shared_ptr<Task>& task) {
+    return getTableScanRuntimeStats(task)["skippedStrides"].sum;
+  }
+
+  static int64_t getSkippedSplitsStat(const std::shared_ptr<Task>& task) {
+    return getTableScanRuntimeStats(task)["skippedSplits"].sum;
+  }
+
+  static void waitForFinishedDrivers(
+      const std::shared_ptr<Task>& task,
+      uint32_t n) {
+    // Limit wait to 10 seconds.
+    size_t iteration{0};
+    while (task->numFinishedDrivers() < n and iteration < 100) {
+      /* sleep override */
+      usleep(100'000); // 0.1 second.
+      ++iteration;
+    }
+    ASSERT_EQ(n, task->numFinishedDrivers());
+  }
+
+  FOLLY_NOINLINE void toFile() {
+    std::ofstream out("/tmp/file.txt");
+    int32_t row = 0;
+    for (auto i = 0; i < vectors_.size(); ++i) {
+      out << "\n\n*** " << row;
+      out << vectors_[i]->toString(0, vectors_[i]->size(), "\n", true);
+    }
+    out.close();
+  }
+
+  VectorFuzzer::Options options_;
+  std::unique_ptr<VectorFuzzer> fuzzer_;
+  int32_t numBatches_ = 3;
+  int32_t batchSize_ = 20'000;
+  std::vector<RowVectorPtr> vectors_;
+  bool dumpData_{false};
+};
+
+TEST_P(TableScanTest, basic) {
+  auto type = ROW({"c0"}, {BIGINT()});
+  auto splits = makeData(type, numBatches_, batchSize_);
+
+  auto plan = tableScanNode(type);
+  auto task = assertQuery(plan, splits, "SELECT * FROM tmp");
+
+  auto planStats = toPlanStats(task->taskStats());
+  auto scanNodeId = plan->id();
+  auto it = planStats.find(scanNodeId);
+  ASSERT_TRUE(it != planStats.end());
+}
+
+TEST_P(TableScanTest, filter) {
+  auto type =
+      ROW({"c0", "c1", "c2", "c3"}, {BIGINT(), BIGINT(), BIGINT(), BIGINT()});
+  auto splits = makeData(type, numBatches_, batchSize_);
+
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(type)
+                  .filter("c0 < 500000000")
+                  .project({"c0", "c1 + 100000000 as c1", "c2", "c3"})
+                  .filter("c1 < 500000000")
+                  .project({"c0", "c1", "c2 + 1", "c3", "c3 + 2"})
+                  .planNode();
+  auto task = assertQuery(
+      plan,
+      splits,
+      "SELECT c0, c1 + 100000000, c2 + 1, c3, c3 + 2 FROM tmp where c0 < 500000000 and c1 + 100000000 < 500000000");
+}
+
+TEST_P(TableScanTest, filterNull) {
+  auto type =
+      ROW({"c0", "c1", "c2", "c3"}, {BIGINT(), BIGINT(), BIGINT(), BIGINT()});
+  auto splits = makeData(type, numBatches_, batchSize_, false);
+
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(type)
+                  .filter("c0 < 500000000")
+                  .project({"c0", "c1 + 100000000 as c1", "c2", "c3"})
+                  .filter("c1 < 500000000")
+                  .project({"c0", "c1", "c2 + 1", "c3", "c3 + 2"})
+                  .planNode();
+  auto task = assertQuery(
+      plan,
+      splits,
+      "SELECT c0, c1 + 100000000, c2 + 1, c3, c3 + 2 FROM tmp where c0 < 500000000 and c1 + 100000000 < 500000000");
+}
+
+TEST_P(TableScanTest, filterInScan) {
+  auto type =
+      ROW({"c0", "c1", "c2", "c3"}, {BIGINT(), BIGINT(), BIGINT(), BIGINT()});
+  auto splits = makeData(type, numBatches_, batchSize_);
+
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(type, {"c0 < 500000000", "c1 < 400000000"})
+                  .project({"c0", "c1 + 100000000 as c1", "c2", "c3"})
+                  .project({"c0", "c1", "c2 + 1", "c3", "c3 + 2"})
+                  .planNode();
+  auto task = assertQuery(
+      plan,
+      splits,
+      "SELECT c0, c1 + 100000000, c2 + 1, c3, c3 + 2 FROM tmp where c0 < 500000000 and c1 + 100000000 < 500000000");
+}
+
+TEST_P(TableScanTest, filterInScanNull) {
+  auto type =
+      ROW({"c0", "c1", "c2", "c3", "rn"},
+          {BIGINT(), BIGINT(), BIGINT(), BIGINT(), BIGINT()});
+  auto splits = makeData(type, numBatches_, batchSize_, false);
+
+  auto plan =
+      PlanBuilder(pool_.get())
+          .tableScan(type, {"c0 < 500000000", "c1 < 400000000"})
+          .project(
+              {"c0",
+               "c1",
+               "c1 + 100000000 as c1f",
+               "c2 as c2p",
+               "c3 as c3p",
+               "rn"})
+          .project({"c0", "c1", "c1f", "c2p + 1", "c3p", "c3p + 2", "rn"})
+          .planNode();
+  auto task = assertQuery(
+      plan,
+      splits,
+      "SELECT c0, c1, c1 + 100000000, c2 + 1, c3, c3 + 2, rn FROM tmp where c0 < 500000000 and c1 + 100000000 < 500000000");
+}
+
+TEST_P(TableScanTest, scanAgg) {
+  auto type =
+      ROW({"c0", "c1", "c2", "c3", "rn"},
+          {BIGINT(), BIGINT(), BIGINT(), BIGINT(), BIGINT()});
+  auto splits = makeData(type, numBatches_, batchSize_);
+
+  auto plan =
+      PlanBuilder(pool_.get())
+          .tableScan(type, {"c0 < 950000000"})
+          .project(
+              {"c0",
+               "c1 + 1 as c1",
+               "c2 + 2 as c2",
+               "c3 + c2 as c3",
+               "rn + 1 as rn"})
+          .singleAggregation(
+              {}, {"sum(c0)", "sum(c1)", "sum(c2)", "sum(c3)", "sum(rn)"})
+          .planNode();
+  auto task = assertQuery(
+      plan,
+      splits,
+      "SELECT sum(c0), sum(c1 + 1), sum(c2 + 2), sum(c3 + c2), sum(rn + 1) FROM tmp where c0 < 950000000");
+}
+
+TEST_P(TableScanTest, scanGroupBy) {
+  GTEST_SKIP();
+  auto type =
+      ROW({"c0", "c1", "c2", "c3", "rn"},
+          {BIGINT(), BIGINT(), BIGINT(), BIGINT(), BIGINT()});
+  auto splits =
+      makeData(type, numBatches_, batchSize_, true, [&](RowVectorPtr row) {
+        makeRange(row, 1000000000, true, 1, -1);
+      });
+
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(type, {"c1 < 950000000"})
+                  .project(
+                      {"c0",
+                       "c1 + 1 as c1",
+                       "c2 + 2 as c2",
+                       "c3 + c2 as c3",
+                       "rn + 1 as rn"})
+                  .singleAggregation(
+                      {"c0"}, {"sum(c1)", "sum(c2)", "sum(c3)", "sum(rn)"})
+                  .planNode();
+  auto task = assertQuery(
+      plan,
+      splits,
+      "SELECT c0, sum(c1 + 1), sum(c2 + 2), sum(c3 + c2), sum(rn + 1) FROM tmp where c0 < 950000000 group by c0");
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TableScanTests,
+    TableScanTest,
+    testing::ValuesIn(waveScanTestParams()));
diff --git a/velox/experimental/wave/exec/tests/WaveBenchmark.cpp b/velox/experimental/wave/exec/tests/WaveBenchmark.cpp
new file mode 100644
index 0000000000000..d748c35bcffe9
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/WaveBenchmark.cpp
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/benchmarks/QueryBenchmarkBase.h"
+#include "velox/common/process/TraceContext.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/dwio/dwrf/writer/WriterContext.h"
+#include "velox/experimental/wave/exec/ToWave.h"
+#include "velox/experimental/wave/exec/WaveHiveDataSource.h"
+#include "velox/experimental/wave/exec/tests/utils/FileFormat.h"
+#include "velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::dwio::common;
+
+DEFINE_string(
+    data_path,
+    "",
+    "Root path of test data. Data layout must follow Hive-style partitioning. "
+    "If the content are directories, they contain the data files for "
+    "each table. If they are files, they contain a file system path for each "
+    "data file, one per line. This allows running against cloud storage or "
+    "HDFS");
+
+DEFINE_bool(
+    generate,
+    true,
+    "Generate input data. If false, data_path must "
+    "contain a directory with a subdirectory per table.");
+
+DEFINE_bool(preload, false, "Preload Wave data into RAM before starting query");
+
+DEFINE_bool(wave, true, "Run benchmark with Wave");
+
+DEFINE_int32(num_columns, 10, "Number of columns in test table");
+
+DEFINE_int64(filter_pass_pct, 100, "Passing % for one filter");
+
+DEFINE_int32(null_pct, 0, "Pct of null values in columns");
+
+DEFINE_int32(num_column_filters, 0, "Number of columns wit a filter");
+
+DEFINE_int32(num_expr_filters, 0, "Number of columns  with a filter expr");
+
+DEFINE_int32(
+    num_arithmetic,
+    0,
+    "Number of arithmetic ops per column after filters");
+
+DEFINE_int32(rows_per_stripe, 200000, "Rows in a stripe");
+
+DEFINE_int64(num_rows, 1000000000, "Rows in test table");
+
+DEFINE_int32(
+    run_query_verbose,
+    -1,
+    "Run a given query and print execution statistics");
+
+class WaveBenchmark : public QueryBenchmarkBase {
+ public:
+  ~WaveBenchmark() {
+    wave::test::Table::dropAll();
+  }
+
+  void initialize() override {
+    QueryBenchmarkBase::initialize();
+    if (FLAGS_wave) {
+      wave::registerWave();
+      wave::WaveHiveDataSource::registerConnector();
+      wave::test::WaveTestSplitReader::registerTestSplitReader();
+    }
+    rootPool_ = memory::memoryManager()->addRootPool("WaveBenchmark");
+    leafPool_ = rootPool_->addLeafChild("WaveBenchmark");
+  }
+
+  void makeData(
+      const RowTypePtr& type,
+      int32_t numVectors,
+      int32_t vectorSize,
+      float nullPct = 0) {
+    auto vectors = makeVectors(type, numVectors, vectorSize, nullPct / 100);
+    int32_t cnt = 0;
+    for (auto& vector : vectors) {
+      makeRange(vector, 1000000000, nullPct == 0);
+      auto rn = vector->childAt(type->size() - 1)->as<FlatVector<int64_t>>();
+      for (auto i = 0; i < rn->size(); ++i) {
+        rn->set(i, cnt++);
+      }
+    }
+    if (FLAGS_wave) {
+      makeTable(FLAGS_data_path + "/test.wave", vectors);
+      if (FLAGS_generate) {
+        auto table =
+            wave::test::Table::getTable(FLAGS_data_path + "/test.wave");
+        table->toFile(FLAGS_data_path + "/test.wave");
+      }
+    } else {
+      std::string temp = FLAGS_data_path + "/data." + FLAGS_data_format;
+      auto config = std::make_shared<dwrf::Config>();
+      config->set(dwrf::Config::COMPRESSION, common::CompressionKind_NONE);
+      config->set(
+          dwrf::Config::STRIPE_SIZE,
+          static_cast<uint64_t>(FLAGS_rows_per_stripe * FLAGS_num_columns * 4));
+      writeToFile(temp, vectors, config, vectors.front()->type());
+    }
+  }
+
+  std::vector<RowVectorPtr> makeVectors(
+      const RowTypePtr& rowType,
+      int32_t numVectors,
+      int32_t rowsPerVector,
+      float nullRatio = 0) {
+    std::vector<RowVectorPtr> vectors;
+    options_.vectorSize = rowsPerVector;
+    options_.nullRatio = nullRatio;
+    fuzzer_ = std::make_unique<VectorFuzzer>(options_, leafPool_.get());
+    for (int32_t i = 0; i < numVectors; ++i) {
+      auto vector = fuzzer_->fuzzInputFlatRow(rowType);
+      vectors.push_back(vector);
+    }
+    return vectors;
+  }
+
+  void makeRange(
+      RowVectorPtr row,
+      int64_t mod = std::numeric_limits<int64_t>::max(),
+      bool notNull = true) {
+    for (auto i = 0; i < row->type()->size(); ++i) {
+      auto child = row->childAt(i);
+      if (auto ints = child->as<FlatVector<int64_t>>()) {
+        for (auto i = 0; i < child->size(); ++i) {
+          if (!notNull && ints->isNullAt(i)) {
+            continue;
+          }
+          ints->set(i, ints->valueAt(i) % mod);
+        }
+      }
+      if (notNull) {
+        child->clearNulls(0, row->size());
+      }
+    }
+  }
+
+  wave::test::SplitVector makeTable(
+      const std::string& name,
+      std::vector<RowVectorPtr>& rows) {
+    wave::test::Table::dropTable(name);
+    return wave::test::Table::defineTable(name, rows)->splits();
+  }
+
+  void writeToFile(
+      const std::string& filePath,
+      const std::vector<RowVectorPtr>& vectors,
+      std::shared_ptr<dwrf::Config> config,
+      const TypePtr& schema) {
+    dwrf::WriterOptions options;
+    options.config = config;
+    options.schema = schema;
+    auto localWriteFile =
+        std::make_unique<LocalWriteFile>(filePath, true, false);
+    auto sink = std::make_unique<dwio::common::WriteFileSink>(
+        std::move(localWriteFile), filePath);
+    auto childPool =
+        rootPool_->addAggregateChild("HiveConnectorTestBase.Writer");
+    options.memoryPool = childPool.get();
+    facebook::velox::dwrf::Writer writer{std::move(sink), options};
+    for (size_t i = 0; i < vectors.size(); ++i) {
+      writer.write(vectors[i]);
+    }
+    writer.close();
+  }
+
+  exec::test::TpchPlan getQueryPlan(int32_t query) {
+    switch (query) {
+      case 1: {
+        if (!type_) {
+          type_ = makeType();
+        }
+
+        exec::test::TpchPlan plan;
+        if (FLAGS_wave) {
+          plan.dataFiles["0"] = {FLAGS_data_path + "/test.wave"};
+        } else {
+          plan.dataFiles["0"] = {FLAGS_data_path + "/data.dwrf"};
+          plan.dataFileFormat = toFileFormat(FLAGS_data_format);
+        }
+        int64_t bound = (1'000'000'000LL * FLAGS_filter_pass_pct) / 100;
+        std::vector<std::string> scanFilters;
+        for (auto i = 0; i < FLAGS_num_column_filters; ++i) {
+          scanFilters.push_back(fmt::format("c{} < {}", i, bound));
+        }
+        auto builder =
+            PlanBuilder(leafPool_.get()).tableScan(type_, scanFilters);
+
+        for (auto i = 0; i < FLAGS_num_expr_filters; ++i) {
+          builder = builder.filter(
+              fmt::format("c{} < {}", FLAGS_num_column_filters + i, bound));
+        }
+
+        std::vector<std::string> aggInputs;
+        if (FLAGS_num_arithmetic > 0) {
+          std::vector<std::string> projects;
+          for (auto c = 0; c < type_->size(); ++c) {
+            std::string expr = fmt::format("c{} ", c);
+            for (auto i = 0; i < FLAGS_num_arithmetic; ++i) {
+              expr += fmt::format(" + c{}", c);
+            }
+            expr += fmt::format(" as f{}", c);
+            projects.push_back(std::move(expr));
+            aggInputs.push_back(fmt::format("f{}", c));
+          }
+          builder = builder.project(std::move(projects));
+        } else {
+          for (auto i = 0; i < type_->size(); ++i) {
+            aggInputs.push_back(fmt::format("c{}", i));
+          }
+        }
+        std::vector<std::string> aggs;
+        for (auto i = 0; i < aggInputs.size(); ++i) {
+          aggs.push_back(fmt::format("sum({})", aggInputs[i]));
+        }
+
+        plan.plan = builder.singleAggregation({}, aggs).planNode();
+
+        plan.dataFileFormat =
+            FLAGS_wave ? FileFormat::UNKNOWN : FileFormat::DWRF;
+        return plan;
+      }
+      default:
+        VELOX_FAIL("Bad query number");
+    }
+  }
+
+  void prepareQuery(int32_t query) {
+    switch (query) {
+      case 1: {
+        type_ = makeType();
+        auto numVectors =
+            std::max<int64_t>(1, FLAGS_num_rows / FLAGS_rows_per_stripe);
+        if (FLAGS_generate) {
+          makeData(
+              type_, numVectors, FLAGS_num_rows / numVectors, FLAGS_null_pct);
+        } else {
+          loadData();
+        }
+        break;
+      }
+      default:
+        VELOX_FAIL("Bad query number");
+    }
+  }
+
+  void loadData() {
+    if (FLAGS_wave) {
+      auto table =
+          wave::test::Table::getTable(FLAGS_data_path + "/test.wave", true);
+      table->fromFile(FLAGS_data_path + "/test.wave");
+      if (FLAGS_preload) {
+        table->loadData(leafPool_);
+      }
+    }
+  }
+
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> listSplits(
+      const std::string& path,
+      int32_t numSplitsPerFile,
+      const TpchPlan& plan) override {
+    if (plan.dataFileFormat == FileFormat::UNKNOWN) {
+      auto table = wave::test::Table::getTable(path);
+      return table->splits();
+    }
+    return QueryBenchmarkBase::listSplits(path, numSplitsPerFile, plan);
+  }
+
+  void runMain(std::ostream& out, RunStats& runStats) override {
+    if (FLAGS_run_query_verbose == -1) {
+      folly::runBenchmarks();
+    } else {
+      const auto queryPlan = getQueryPlan(FLAGS_run_query_verbose);
+      auto [cursor, actualResults] = run(queryPlan);
+      if (!cursor) {
+        LOG(ERROR) << "Query terminated with error. Exiting";
+        exit(1);
+      }
+      auto task = cursor->task();
+      ensureTaskCompletion(task.get());
+      if (FLAGS_include_results) {
+        printResults(actualResults, out);
+        out << std::endl;
+      }
+      const auto stats = task->taskStats();
+      int64_t rawInputBytes = 0;
+      for (auto& pipeline : stats.pipelineStats) {
+        auto& first = pipeline.operatorStats[0];
+        if (first.operatorType == "TableScan" || first.operatorType == "Wave") {
+          rawInputBytes += first.rawInputBytes;
+        }
+      }
+      runStats.rawInputBytes = rawInputBytes;
+      out << fmt::format(
+                 "Execution time: {}",
+                 succinctMillis(
+                     stats.executionEndTimeMs - stats.executionStartTimeMs))
+          << std::endl;
+      out << fmt::format(
+                 "Splits total: {}, finished: {}",
+                 stats.numTotalSplits,
+                 stats.numFinishedSplits)
+          << std::endl;
+      out << printPlanWithStats(
+                 *queryPlan.plan, stats, FLAGS_include_custom_stats)
+          << std::endl;
+    }
+  }
+
+  RowTypePtr makeType() {
+    std::vector<std::string> names;
+    std::vector<TypePtr> types;
+    for (auto i = 0; i < FLAGS_num_columns; ++i) {
+      names.push_back(fmt::format("c{}", i));
+      types.push_back(BIGINT());
+    }
+    return ROW(std::move(names), std::move(types));
+  }
+
+  std::shared_ptr<memory::MemoryPool> rootPool_;
+  std::shared_ptr<memory::MemoryPool> leafPool_;
+  RowTypePtr type_;
+  VectorFuzzer::Options options_;
+  std::unique_ptr<VectorFuzzer> fuzzer_;
+};
+
+void waveBenchmarkMain() {
+  auto benchmark = std::make_unique<WaveBenchmark>();
+  benchmark->initialize();
+  if (FLAGS_run_query_verbose != -1) {
+    benchmark->prepareQuery(FLAGS_run_query_verbose);
+  }
+  if (FLAGS_test_flags_file.empty()) {
+    RunStats stats;
+    benchmark->runOne(std::cout, stats);
+    std::cout << stats.toString(false);
+  } else {
+    benchmark->runAllCombinations();
+  }
+  benchmark->shutdown();
+}
+
+int main(int argc, char** argv) {
+  std::string kUsage(
+      "This program benchmarks Wave. Run 'velox_wave_benchmark -helpon=WaveBenchmark' for available options.\n");
+  gflags::SetUsageMessage(kUsage);
+  folly::Init init{&argc, &argv, false};
+  facebook::velox::wave::printKernels();
+  waveBenchmarkMain();
+  return 0;
+}
diff --git a/velox/experimental/wave/exec/tests/utils/CMakeLists.txt b/velox/experimental/wave/exec/tests/utils/CMakeLists.txt
new file mode 100644
index 0000000000000..e977acd4506ea
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/utils/CMakeLists.txt
@@ -0,0 +1,29 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_wave_mock_file FileFormat.cpp)
+target_link_libraries(
+  velox_wave_mock_file velox_exception velox_common_base velox_vector)
+
+add_library(velox_wave_mock_reader WaveTestSplitReader.cpp TestFormatReader.cpp)
+
+target_link_libraries(
+  velox_wave_mock_reader
+  velox_wave_exec
+  velox_wave_mock_file
+  velox_wave_dwio
+  velox_wave_decode
+  velox_exception
+  velox_common_base
+  velox_vector)
diff --git a/velox/experimental/wave/exec/tests/utils/FileFormat.cpp b/velox/experimental/wave/exec/tests/utils/FileFormat.cpp
new file mode 100644
index 0000000000000..cd7c2a929c90a
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/utils/FileFormat.cpp
@@ -0,0 +1,669 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/tests/utils/FileFormat.h"
+#include <iostream>
+#include "velox/common/config/Config.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/vector/VectorSaver.h"
+
+namespace facebook::velox::wave::test {
+
+const Column* Stripe::findColumn(const dwio::common::TypeWithId& child) const {
+  for (auto i = 0; i < typeWithId->size(); ++i) {
+    if (typeWithId->childAt(i)->id() == child.id()) {
+      return columns[i].get();
+    }
+  }
+  VELOX_FAIL("No such column {}", child.id());
+}
+
+std::mutex Table::mutex_;
+std::unordered_map<std::string, std::unique_ptr<Table>> Table::allTables_;
+std::unordered_map<std::string, Stripe*> Table::allStripes_;
+
+int32_t bitWidth(uint64_t max) {
+  return 64 - __builtin_clzll(max);
+}
+
+template <typename T>
+T subtractMin(T value, T min) {
+  return value - min;
+}
+
+template <>
+StringView subtractMin(StringView value, StringView /*min*/) {
+  return value;
+}
+
+template <>
+Timestamp subtractMin(Timestamp value, Timestamp /*min*/) {
+  return value;
+}
+
+template <>
+double subtractMin(double value, double /*min*/) {
+  return value;
+}
+
+template <>
+float subtractMin(float value, float /*min*/) {
+  return value;
+}
+
+template <typename T>
+int64_t baseValue(T value) {
+  return static_cast<int64_t>(value);
+}
+
+template <>
+int64_t baseValue(StringView value) {
+  return 0;
+}
+
+template <>
+int64_t baseValue(Timestamp value) {
+  return 0;
+}
+
+template <>
+int64_t baseValue(double value) {
+  return 0;
+}
+template <>
+int64_t baseValue(float value) {
+  return 0;
+}
+
+template <typename T>
+int32_t rangeBitWidth(T max, T min) {
+  auto bits = bitWidth(baseValue(subtractMin(max, min)));
+  return bits ? bits : sizeof(T) * 8;
+}
+
+template <typename T>
+BufferPtr
+encodeInts(const std::vector<T>& ints, T min, T max, memory::MemoryPool* pool) {
+  int32_t width = rangeBitWidth(max, min);
+  int32_t size = bits::roundUp(ints.size() * width, 128) / 8;
+  auto buffer = AlignedBuffer::allocate<char>(size, pool);
+  auto destination = buffer->asMutable<uint64_t>();
+  for (auto i = 0; i < ints.size(); ++i) {
+    T sourceValue = subtractMin(ints[i], min);
+    bits::copyBits(
+        reinterpret_cast<uint64_t*>(&sourceValue),
+        0,
+        destination,
+        i * width,
+        width);
+  }
+  return buffer;
+}
+
+template <TypeKind kind>
+std::unique_ptr<EncoderBase> makeTypedEncoder(
+    memory::MemoryPool& pool,
+    const TypePtr& type) {
+  using T = typename TypeTraits<kind>::NativeType;
+  return std::make_unique<Encoder<T>>(&pool, type);
+}
+
+std::unique_ptr<EncoderBase> makeEncoder(
+    memory::MemoryPool& pool,
+    const TypePtr& type) {
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      makeTypedEncoder, type->kind(), pool, type);
+}
+
+template <typename T>
+int64_t Encoder<T>::flatSize() {
+  return count_ * rangeBitWidth(max_, min_) / 8;
+}
+
+template <>
+int64_t Encoder<StringView>::flatSize() {
+  return totalStringBytes_ + (count_ * bitWidth(maxLength_) / 8);
+}
+
+template <>
+int64_t Encoder<Timestamp>::flatSize() {
+  return direct_.size() * sizeof(Timestamp);
+}
+
+template <>
+int64_t Encoder<double>::flatSize() {
+  return direct_.size() * sizeof(double);
+}
+
+template <>
+int64_t Encoder<float>::flatSize() {
+  return direct_.size() * sizeof(float);
+}
+
+template <typename T>
+int64_t Encoder<T>::dictSize() {
+  return (rangeBitWidth(max_, min_) * distincts_.size() / 8) +
+      (bitWidth(distincts_.size() - 1) * count_ / 8);
+}
+
+template <>
+int64_t Encoder<StringView>::dictSize() {
+  return (count_ * bitWidth(distincts_.size() - 1) / 8) + dictBytes_;
+}
+
+struct StringWithId {
+  StringView string;
+  int32_t id;
+};
+
+void printSums(uint64_t* bits, int32_t numBits) {
+  std::cout << "***Flags\n";
+  int32_t cnt = 0;
+  for (auto i = 0; i < bits::nwords(numBits) - 16; i += 16) {
+    cnt += bits::countBits(bits, i * 64, (i + 16) * 64);
+    std::cout << fmt::format("{}: {}\n", (i + 16) * 64, cnt);
+  }
+}
+
+std::unique_ptr<Column>
+encodeBits(uint64_t* bits, int32_t numBits, memory::MemoryPool* pool) {
+  auto column = std::make_unique<Column>();
+  column->encoding = kFlat;
+  column->kind = TypeKind::BOOLEAN;
+  column->numValues = numBits;
+  column->values = AlignedBuffer::allocate<bool>(numBits, pool);
+  memcpy(column->values->asMutable<char>(), bits, bits::nbytes(numBits));
+  column->bitWidth = 1;
+  // printSums(bits, numBits);
+  return column;
+}
+
+template <typename T>
+std::unique_ptr<Column>
+directInts(std::vector<T>& ints, T min, T max, memory::MemoryPool* pool) {
+  auto column = std::make_unique<Column>();
+  column->values = encodeInts(ints, min, max, pool);
+  column->numValues = ints.size();
+  return column;
+}
+
+template <typename T>
+std::unique_ptr<Column> Encoder<T>::toColumn() {
+  auto column = std::make_unique<Column>();
+  column->kind = kind_;
+  if (!nulls_.empty()) {
+    column->nulls = encodeBits(nulls_.data(), count_, pool_);
+  }
+  if (distincts_.size() <= 1) {
+    VELOX_NYI("constant not supported");
+  }
+  if (!abandonDict_ && dictSize() < flatSize()) {
+    if (kind_ == TypeKind::VARCHAR) {
+      column->encoding = kDict;
+      column->values = encodeInts(
+          indices_, 0, static_cast<int32_t>(distincts_.size() - 1), pool_);
+      column->bitWidth = bitWidth(distincts_.size() - 1);
+      column->alphabet = dictStrings_.toColumn();
+      return column;
+    } else {
+      column->alphabet = directInts(dictInts_, min_, max_, pool_);
+    }
+  }
+  column->values = encodeInts(direct_, min_, max_, pool_);
+  column->numValues = count_;
+  column->bitWidth = rangeBitWidth(max_, min_);
+  column->baseline = baseValue(min_);
+  return column;
+}
+
+template <typename T>
+void Encoder<T>::add(T data) {
+  if (direct_.empty()) {
+    min_ = data;
+    max_ = data;
+  } else {
+    if (data > max_) {
+      max_ = data;
+    } else if (data < min_) {
+      min_ = data;
+    }
+  }
+  ++count_;
+  ++nonNullCount_;
+  direct_.push_back(data);
+  if (abandonDict_) {
+    return;
+  }
+  auto it = distincts_.find(data);
+  if (it != distincts_.end()) {
+    indices_.push_back(it->second);
+    return;
+  }
+  auto id = distincts_.size();
+  distincts_[data] = id;
+  dictInts_.push_back(data);
+  indices_.push_back(id);
+}
+
+StringView StringSet::add(StringView data) {
+  int32_t stringSize = data.size();
+  totalSize_ += stringSize;
+  if (stringSize > maxLength_) {
+    maxLength_ = stringSize;
+  }
+  if (buffers_.empty() ||
+      buffers_.back()->size() + stringSize > buffers_.back()->capacity()) {
+    buffers_.push_back(AlignedBuffer::allocate<char>(1 << 20, pool_));
+    buffers_.back()->setSize(0);
+  }
+  lengths_.push_back(stringSize);
+  auto& buffer = buffers_.back();
+  auto size = buffer->size();
+  memcpy(buffer->asMutable<char>() + size, data.data(), data.size());
+  buffer->setSize(size + data.size());
+  return StringView(buffer->as<char>() + size, data.size());
+};
+
+std::unique_ptr<Column> StringSet::toColumn() {
+  auto buffer = AlignedBuffer::allocate<char>(totalSize_, pool_);
+  for (auto& piece : buffers_) {
+    memcpy(buffer->asMutable<char>(), piece->as<char>(), piece->size());
+  }
+  auto column = std::make_unique<Column>();
+  column->kind = TypeKind::VARCHAR;
+  column->encoding = kFlat;
+  column->values = buffer;
+  column->lengths = directInts(lengths_, 0, maxLength_, pool_);
+  column->bitWidth = bitWidth(maxLength_);
+  return column;
+}
+
+template <>
+void Encoder<StringView>::add(StringView data) {
+  ++count_;
+  ++nonNullCount_;
+  auto size = data.size();
+  totalStringBytes_ += size;
+  if (size > maxLength_) {
+    maxLength_ = size;
+  }
+
+  if (abandonDict_) {
+    allStrings_.add(data);
+    return;
+  }
+  auto it = distincts_.find(data);
+  if (it != distincts_.end()) {
+    indices_.push_back(it->second);
+    return;
+  }
+  dictBytes_ += data.size();
+  auto copy = dictStrings_.add(data);
+  auto id = distincts_.size();
+  distincts_[copy] = id;
+  indices_.push_back(id);
+}
+
+template <typename T>
+void Encoder<T>::addNull() {
+  ++count_;
+  auto n = bits::nwords(count_);
+  if (nulls_.size() < n) {
+    nulls_.resize(n, bits::kNotNull64);
+  }
+  bits::setBit(nulls_.data(), count_ - 1, bits::kNull);
+}
+
+template <typename T>
+void Encoder<T>::append(const VectorPtr& data) {
+  auto size = data->size();
+  SelectivityVector allRows(size);
+  DecodedVector decoded(*data, allRows, true);
+  for (auto i = 0; i < size; ++i) {
+    if (decoded.isNullAt(i)) {
+      addNull();
+    } else {
+      add(decoded.valueAt<T>(i));
+    }
+  }
+}
+
+void Writer::append(RowVectorPtr data) {
+  type_ = data->type();
+  if (encoders_.empty()) {
+    for (auto i = 0; i < data->type()->size(); ++i) {
+      encoders_.push_back(
+          makeEncoder(*pool_, data->type()->as<TypeKind::ROW>().childAt(i)));
+    }
+  }
+  VELOX_CHECK_EQ(encoders_.size(), data->type()->size());
+  for (auto i = 0; i < encoders_.size(); ++i) {
+    encoders_[i]->append(data->childAt(i));
+  }
+  rowsInStripe_ += data->size();
+  if (rowsInStripe_ >= stripeSize_) {
+    finishStripe();
+  }
+}
+
+void Writer::finishStripe() {
+  if (encoders_.empty()) {
+    return;
+  }
+  std::vector<std::unique_ptr<Column>> columns;
+  for (auto& encoder : encoders_) {
+    columns.push_back(encoder->toColumn());
+  }
+  int32_t numRows = columns[0]->numValues;
+  stripes_.push_back(std::make_unique<Stripe>(
+      std::move(columns), dwio::common::TypeWithId::create(type_), numRows));
+  encoders_.clear();
+  rowsInStripe_ = 0;
+}
+
+Table* Writer::finalize(std::string tableName) {
+  finishStripe();
+  auto table = Table::getTable(tableName, true);
+  table->addStripes(std::move(stripes_), pool_);
+  return table;
+}
+
+template <typename T>
+void writeNumber(std::ostream& stream, const T& n) {
+  stream.write(reinterpret_cast<const char*>(&n), sizeof(T));
+}
+
+void Column::load(
+    std::unique_ptr<ReadFile>& file,
+    const std::string& path,
+    memory::MemoryPool* pool) {
+  VELOX_CHECK(region.length > 0 || nulls || !children.empty());
+  if (nulls) {
+    nulls->load(file, path, pool);
+  }
+  if (alphabet) {
+    alphabet->load(file, path, pool);
+  }
+  if (region.length > 0) {
+    values = AlignedBuffer::allocate<char>(region.length, pool);
+    if (!file) {
+      auto fileSystem = filesystems::getFileSystem(path, nullptr);
+      file = fileSystem->openFileForRead(path);
+    }
+    file->pread(region.offset, region.length, values->asMutable<char>());
+  }
+  for (auto& child : children) {
+    child->load(file, path, pool);
+  }
+}
+
+template <typename T>
+void readNumber(std::istream& stream, T& n) {
+  stream.read(reinterpret_cast<char*>(&n), sizeof(n));
+}
+
+template <typename T>
+void appendNumber(WriteFile& file, T n) {
+  file.append(std::string_view(reinterpret_cast<const char*>(&n), sizeof(n)));
+}
+
+void writeColumn(Column& column, WriteFile& file, std::stringstream& footer) {
+  writeNumber(footer, column.encoding);
+  writeNumber(footer, column.kind);
+  if (column.nulls) {
+    writeColumn(*column.nulls, file, footer);
+  } else {
+    writeNumber(footer, Encoding::kNone);
+  }
+  writeNumber(footer, column.numValues);
+  if (Encoding::kStruct == column.encoding) {
+    VELOX_NYI();
+    return;
+  }
+  if (Encoding::kDict == column.encoding) {
+    writeColumn(*column.alphabet, file, footer);
+  }
+  writeNumber(footer, column.bitWidth);
+  writeNumber(footer, column.baseline);
+  int64_t offset = file.size();
+  writeNumber(footer, offset);
+  int64_t size = column.values->size();
+  writeNumber(footer, size);
+  file.append(std::string_view(column.values->as<char>(), size));
+}
+
+void writeColumns(
+    std::vector<std::unique_ptr<Column>>& columns,
+    Column* nulls,
+    WriteFile& file,
+    std::stringstream& footer) {
+  writeNumber(footer, Encoding::kStruct);
+  writeNumber(footer, TypeKind::ROW);
+  if (nulls) {
+    writeColumn(*nulls, file, footer);
+  } else {
+    writeNumber(footer, Encoding::kNone);
+  }
+  writeNumber(footer, columns[0]->numValues);
+  int32_t numColumns = columns.size();
+  writeNumber(footer, numColumns);
+  std::vector<std::string> columnFooters;
+  int32_t columnStart = 0;
+  for (auto columnIdx = 0; columnIdx < columns.size(); ++columnIdx) {
+    std::stringstream columnFooter;
+    writeColumn(*columns[columnIdx], file, columnFooter);
+    auto footerString = columnFooter.str();
+    writeNumber(footer, columnStart);
+    columnStart += footerString.size();
+    columnFooters.push_back(std::move(footerString));
+  }
+  for (auto columnFooter : columnFooters) {
+    footer.write(columnFooter.data(), columnFooter.size());
+  }
+}
+
+std::vector<std::unique_ptr<Column>> readColumns(std::stringstream& in);
+
+std::unique_ptr<Column> readColumn(std::stringstream& in) {
+  Encoding encoding;
+  readNumber(in, encoding);
+  if (encoding == Encoding::kNone) {
+    return nullptr;
+  }
+  auto column = std::make_unique<Column>();
+  column->encoding = encoding;
+  readNumber(in, column->kind);
+  column->nulls = readColumn(in);
+  readNumber(in, column->numValues);
+  if (encoding == Encoding::kStruct) {
+    column->children = readColumns(in);
+    return column;
+  }
+  if (encoding == Encoding::kDict) {
+    column->alphabet = readColumn(in);
+  }
+  readNumber(in, column->bitWidth);
+  readNumber(in, column->baseline);
+  readNumber(in, column->region.offset);
+  readNumber(in, column->region.length);
+  return column;
+}
+
+std::vector<std::unique_ptr<Column>> readColumns(std::stringstream& in) {
+  int32_t numColumns;
+  readNumber(in, numColumns);
+  std::vector<int32_t> starts(numColumns);
+  in.read(reinterpret_cast<char*>(starts.data()), numColumns * sizeof(int32_t));
+  std::vector<std::unique_ptr<Column>> children(numColumns);
+  for (auto i = 0; i < numColumns; ++i) {
+    children[i] = readColumn(in);
+  }
+  return children;
+}
+
+void Table::toFile(const std::string& path) {
+  std::vector<std::string> stripeFooters;
+  std::vector<int64_t> stripeStart;
+  auto type = stripes_.front()->typeWithId->type();
+  auto fileSystem = filesystems::getFileSystem(path, nullptr);
+  try {
+    fileSystem->remove(path);
+  } catch (const std::exception& e) {
+  }
+  auto file = fileSystem->openFileForWrite(path);
+  std::vector<std::string> footers;
+  for (auto stripeIdx = 0; stripeIdx < stripes_.size(); ++stripeIdx) {
+    auto stripe = stripes_[stripeIdx].get();
+    stripeStart.push_back(file->size());
+    std::stringstream footer;
+    writeColumns(stripe->columns, nullptr, *file, footer);
+    footers.push_back(footer.str());
+  }
+  int64_t footerStart = file->size();
+  std::vector<int64_t> footerStarts;
+  for (auto& footer : footers) {
+    footerStarts.push_back(file->size());
+    file->append(std::string_view(footer.data(), footer.size()));
+  }
+  int64_t typeStart = file->size();
+  std::stringstream typeStream;
+  saveType(type, typeStream);
+  auto typeString = typeStream.str();
+  file->append(std::string_view(typeString.data(), typeString.size()));
+  int64_t offsetStart = file->size();
+  for (auto i = 0; i < stripeStart.size(); ++i) {
+    appendNumber(*file, stripeStart[i]);
+    appendNumber(*file, footerStarts[i]);
+  }
+  int32_t numStripes = stripes_.size();
+  appendNumber(*file, numStripes);
+  appendNumber(*file, offsetStart);
+  appendNumber(*file, typeStart);
+  appendNumber(*file, footerStart);
+  file->close();
+}
+
+void Table::fromFile(
+    const std::string& path,
+    int64_t splitStart,
+    int64_t splitSize) {
+  auto fileSystem = filesystems::getFileSystem(path, nullptr);
+  auto file = fileSystem->openFileForRead(path);
+  int64_t size = file->size();
+  std::string tail;
+  tail.resize(std::min<int64_t>(size, 100000));
+  file->pread(size - tail.size(), tail.size(), tail.data());
+  char* end = tail.data() + tail.size();
+  auto numStripes = *reinterpret_cast<int32_t*>(end - 28);
+  auto offsetStart = size - *reinterpret_cast<int64_t*>(end - 24);
+  auto typeStart = size - *reinterpret_cast<int64_t*>(end - 16);
+  auto footerStart = size - *reinterpret_cast<int64_t*>(end - 8);
+  int64_t tailSize = footerStart;
+  if (tailSize > tail.size()) {
+    std::string moreTail;
+    moreTail.resize(tailSize - tail.size());
+    file->pread(size - footerStart, moreTail.size(), moreTail.data());
+    moreTail += tail;
+    tail = std::move(moreTail);
+  }
+  // Read the type.
+  std::stringstream typeStream(tail);
+  typeStream.seekg(tail.size() - typeStart);
+  auto type = restoreType(typeStream);
+  auto typeWithIdUnique = dwio::common::TypeWithId::create(
+      std::static_pointer_cast<const RowType>(type));
+  std::shared_ptr<const dwio::common::TypeWithId> typeWithId(
+      typeWithIdUnique.release());
+  // Loop over offsets and make stripes for the ones in range.
+  auto offset = tail.size() - offsetStart;
+  std::vector<std::unique_ptr<Stripe>> stripes;
+  for (auto i = 0; i < numStripes; ++i) {
+    auto dataStart = *reinterpret_cast<int64_t*>(tail.data() + offset + i * 16);
+    if (dataStart >= splitStart && dataStart < splitStart + splitSize) {
+      auto footerStart =
+          size - *reinterpret_cast<int64_t*>(tail.data() + offset + 8 + i * 16);
+      auto footerOff = tail.size() - footerStart;
+      std::stringstream footerStream(tail);
+      // skip 3 first,i.e. kStruct, TypeKind::ROW, kNone.
+      footerStream.seekg(footerOff + 3);
+      int32_t numRows;
+      readNumber(footerStream, numRows);
+      auto columns = readColumns(footerStream);
+      stripes.push_back(std::make_unique<Stripe>(
+          std::move(columns), typeWithId, numRows, path));
+    }
+  }
+  addStripes(std::move(stripes), nullptr);
+}
+
+void Table::addStripes(
+    std::vector<std::unique_ptr<Stripe>>&& stripes,
+    std::shared_ptr<memory::MemoryPool> pool) {
+  std::lock_guard<std::mutex> l(mutex_);
+  for (auto& s : stripes) {
+    s->name = fmt::format("wavemock://{}/{}", name_, stripes_.size());
+    allStripes_[s->name] = s.get();
+    stripes_.push_back(std::move(s));
+  }
+  if (pool) {
+    pools_.push_back(pool);
+  }
+}
+
+void Table::loadData(std::shared_ptr<memory::MemoryPool> pool) {
+  std::unique_ptr<ReadFile> file;
+  VELOX_CHECK(pools_.empty());
+  for (auto& stripe : stripes_) {
+    for (auto& column : stripe->columns) {
+      column->load(file, stripe->path, pool.get());
+    }
+  }
+  pools_.push_back(pool);
+}
+
+// static
+const Table* Table::defineTable(
+    const std::string& name,
+    const std::vector<RowVectorPtr>& data) {
+  dropTable(name);
+  Writer writer(data[0]->size());
+  for (auto& vector : data) {
+    writer.append(vector);
+  }
+  return writer.finalize(name);
+}
+
+//  static
+void Table::dropTable(const std::string& name) {
+  std::lock_guard<std::mutex> l(mutex_);
+  auto it = allTables_.find(name);
+  if (it == allTables_.end()) {
+    return;
+  }
+  auto& table = it->second;
+  for (auto& stripe : table->stripes_) {
+    allStripes_.erase(stripe->name);
+  }
+  allTables_.erase(it);
+}
+// static
+void Table::dropAll() {
+  std::lock_guard<std::mutex> l(mutex_);
+  allStripes_.clear();
+  allTables_.clear();
+}
+
+} // namespace facebook::velox::wave::test
diff --git a/velox/experimental/wave/exec/tests/utils/FileFormat.h b/velox/experimental/wave/exec/tests/utils/FileFormat.h
new file mode 100644
index 0000000000000..58e837d6beec8
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/utils/FileFormat.h
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/file/Region.h"
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/type/StringView.h"
+#include "velox/vector/ComplexVector.h"
+
+/// Sample set of composable encodings. Bit packing, direct and dictionary.
+namespace facebook::velox::wave::test {
+
+class Table;
+
+enum Encoding : uint8_t { kFlat, kDict, kStruct, kNone };
+
+struct Column {
+  void load(
+      std::unique_ptr<ReadFile>& file,
+      const std::string& path,
+      memory::MemoryPool* pool);
+
+  Encoding encoding;
+  TypeKind kind;
+  // Number of encoded values including nulls.
+  int32_t numValues{0};
+
+  // Distinct values in kDict.
+  std::shared_ptr<Column> alphabet;
+
+  // Encoded lengths for strings in 'data' if type is varchar and encoding is
+  // kFlat.
+  std::unique_ptr<Column> lengths;
+
+  // Width of bit packed encoding.
+  int8_t bitWidth;
+
+  BufferPtr values;
+
+  /// Frame of reference base for kFlat.
+  int64_t baseline{0};
+
+  /// Encoded column with 'numValues' null bits, nullptr if no nulls. If set,
+  /// 'values' has an entry for each non-null.
+  std::unique_ptr<Column> nulls;
+
+  /// Location of raw data in the backing file, or 0,0 if no backing file.
+  common::Region region;
+
+  std::vector<std::unique_ptr<Column>> children;
+};
+
+struct Stripe {
+  Stripe(
+      std::vector<std::unique_ptr<Column>>&& in,
+      const std::shared_ptr<const dwio::common::TypeWithId>& type,
+      int32_t numRows,
+      std::string path = "")
+      : typeWithId(type),
+        numRows(numRows),
+        columns(std::move(in)),
+        path(std::move(path)) {}
+
+  const Column* findColumn(const dwio::common::TypeWithId& child) const;
+
+  bool isLoaded() const {
+    for (auto i = 0; i < columns.size(); ++i) {
+      if (!columns[i]->values) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // Unique name assigned when associating with a Table.
+  std::string name;
+
+  std::shared_ptr<const dwio::common::TypeWithId> typeWithId;
+
+  /// Number of rows. Needed for counting if no columns.
+  int32_t numRows{0};
+
+  // Top level columns.
+  std::vector<std::unique_ptr<Column>> columns;
+
+  /// Path of file referenced by Region in Columns.
+  std::string path;
+};
+
+class StringSet {
+ public:
+  StringSet(memory::MemoryPool* pool) : pool_(pool) {}
+
+  StringView add(StringView data);
+  std::unique_ptr<Column> toColumn();
+
+ private:
+  int64_t totalSize_{0};
+  int32_t maxLength_{0};
+  std::vector<int32_t> lengths_;
+  std::vector<BufferPtr> buffers_;
+  memory::MemoryPool* pool_;
+};
+
+class EncoderBase {
+ public:
+  virtual ~EncoderBase() = default;
+
+  virtual void append(const VectorPtr& data) = 0;
+
+  virtual std::unique_ptr<Column> toColumn() = 0;
+};
+
+template <typename T>
+class Encoder : public EncoderBase {
+ public:
+  Encoder(memory::MemoryPool* pool, const TypePtr& type)
+      : pool_(pool),
+        kind_(type->kind()),
+        dictStrings_(pool),
+        allStrings_(pool) {}
+
+  // Adds data.
+  void append(const VectorPtr& data) override;
+
+  // Retrieves the data added so far as an encoded column.
+  std::unique_ptr<Column> toColumn() override;
+
+ private:
+  void appendTyped(VectorPtr data);
+
+  void add(T data);
+
+  void addNull();
+
+  int64_t flatSize();
+  int64_t dictSize();
+
+  memory::MemoryPool* pool_;
+  TypeKind kind_;
+  int32_t count_{0};
+  int32_t nonNullCount_{0};
+  // Distincts for either int64_t or double.
+  folly::F14FastMap<T, int32_t> distincts_;
+  // Values as indices into dicts.
+  std::vector<int32_t> indices_;
+
+  std::vector<T> dictInts_;
+  // The fixed width values as direct.
+  std::vector<T> direct_;
+  // True if too many distinct values for dict.
+  bool abandonDict_{false};
+  T max_{};
+  T min_{};
+  // longest string, if string type.
+  int32_t maxLength_{0};
+  // Total bytes in distinct strings.
+  int64_t dictBytes_{0};
+  // Total string bytes without dict.
+  int32_t totalStringBytes_{0};
+
+  StringSet dictStrings_;
+  StringSet allStrings_;
+  // If nulls occur, has a 1 bit for each non-null. Empty if no nulls.
+  std::vector<uint64_t> nulls_;
+};
+
+template <>
+void Encoder<StringView>::add(StringView data);
+
+template <>
+int64_t Encoder<StringView>::dictSize();
+
+template <>
+int64_t Encoder<StringView>::flatSize();
+
+template <>
+int64_t Encoder<Timestamp>::flatSize();
+template <>
+int64_t Encoder<double>::flatSize();
+template <>
+int64_t Encoder<float>::flatSize();
+
+class Writer {
+ public:
+  Writer(int32_t stripeSize)
+      : stripeSize_(stripeSize),
+        pool_(memory::MemoryManager::getInstance()->addLeafPool()) {}
+
+  /// Appends a batch of data.
+  void append(RowVectorPtr data);
+
+  // Finishes encoding data, makes the table ready to read.
+  Table* finalize(std::string tableName);
+
+ private:
+  TypePtr type_;
+  void finishStripe();
+  const int32_t stripeSize_;
+  int32_t rowsInStripe_{0};
+  std::vector<std::unique_ptr<Stripe>> stripes_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::vector<std::unique_ptr<EncoderBase>> encoders_;
+};
+
+using SplitVector = std::vector<std::shared_ptr<connector::ConnectorSplit>>;
+
+class Table {
+ public:
+  Table(const std::string name) : name_(name) {}
+
+  static const Table* defineTable(
+      const std::string& name,
+      const std::vector<RowVectorPtr>& data);
+
+  static Table* getTable(const std::string& name, bool makeNew = false) {
+    std::lock_guard<std::mutex> l(mutex_);
+    auto it = allTables_.find(name);
+    if (it == allTables_.end()) {
+      if (makeNew) {
+        auto table = std::make_unique<Table>(name);
+        auto ptr = table.get();
+        allTables_[name] = std::move(table);
+        return ptr;
+      }
+      return nullptr;
+    }
+    return it->second.get();
+  }
+
+  void toFile(const std::string& path);
+
+  /// Initializes from 'path' for stripes whose start falls between 'start' and
+  /// 'start + size'.
+  void fromFile(
+      const std::string& path,
+      int64_t start = 0,
+      int64_t size = std::numeric_limits<int64_t>::max());
+
+  /// Reads the encoded data for all columns in column->buffer, allocating from
+  /// 'pool'.
+  void loadData(std::shared_ptr<memory::MemoryPool> pool);
+
+  static void dropTable(const std::string& name);
+
+  static Stripe* getStripe(const std::string& path) {
+    std::lock_guard<std::mutex> l(mutex_);
+    auto it = allStripes_.find(path);
+    VELOX_CHECK(it != allStripes_.end());
+    return it->second;
+  }
+
+  void addStripes(
+      std::vector<std::unique_ptr<Stripe>>&& stripes,
+      std::shared_ptr<memory::MemoryPool> pool);
+
+  int32_t numStripes() const {
+    return stripes_.size();
+  }
+
+  Stripe* stripeAt(int32_t index) {
+    std::lock_guard<std::mutex> l(mutex_);
+    if (index >= stripes_.size()) {
+      return nullptr;
+    }
+    return stripes_[index].get();
+  }
+
+  SplitVector splits() const {
+    SplitVector result;
+    std::lock_guard<std::mutex> l(mutex_);
+    for (auto& stripe : stripes_) {
+      result.push_back(std::make_shared<connector::hive::HiveConnectorSplit>(
+          "test-hive", stripe->name, dwio::common::FileFormat::UNKNOWN));
+    }
+    return result;
+  }
+
+  /// Drops all tables and stripes. Do this at end of test for cleanup.
+  static void dropAll();
+
+ private:
+  static std::mutex mutex_;
+  static std::unordered_map<std::string, std::unique_ptr<Table>> allTables_;
+  static std::unordered_map<std::string, Stripe*> allStripes_;
+  std::vector<std::shared_ptr<memory::MemoryPool>> pools_;
+  std::string name_;
+  std::vector<std::unique_ptr<Stripe>> stripes_;
+};
+
+} // namespace facebook::velox::wave::test
diff --git a/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp b/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp
new file mode 100644
index 0000000000000..c9bfed307e4f4
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/tests/utils/TestFormatReader.h"
+#include "velox/experimental/wave/dwio/StructColumnReader.h"
+
+DECLARE_int32(wave_reader_rows_per_tb);
+
+namespace facebook::velox::wave::test {
+
+using common::Subfield;
+
+std::unique_ptr<FormatData> TestFormatParams::toFormatData(
+    const std::shared_ptr<const dwio::common::TypeWithId>& type,
+    const velox::common::ScanSpec& scanSpec,
+    OperandId operand) {
+  auto* column = type->id() == 0 ? nullptr : stripe_->findColumn(*type);
+  return std::make_unique<TestFormatData>(
+      operand, stripe_->columns[0]->numValues, column);
+}
+
+BufferId TestFormatData::stageNulls(
+    ResultStaging& deviceStaging,
+    SplitStaging& splitStaging) {
+  if (!column_->nulls) {
+    nullsStaged_ = true;
+    return kNotRegistered;
+  }
+
+  if (nullsStaged_) {
+    splitStaging.addDependency(nullsStagingId_);
+    return kNotRegistered;
+  }
+  nullsStaged_ = true;
+  auto* nulls = column_->nulls.get();
+  Staging staging(
+      nulls->values->as<char>(),
+      bits::nwords(column_->numValues) * sizeof(uint64_t),
+      column_->region);
+  nullsBufferId_ = splitStaging.add(staging);
+  nullsStagingId_ = splitStaging.id();
+  splitStaging.registerPointer(nullsBufferId_, &grid_.nulls, true);
+  return nullsBufferId_;
+}
+
+void TestFormatData::griddize(
+    int32_t blockSize,
+    int32_t numBlocks,
+    ResultStaging& deviceStaging,
+    ResultStaging& resultStaging,
+    SplitStaging& staging,
+    DecodePrograms& programs,
+    ReadStream& stream) {
+  constexpr int32_t kCountStride = 1024;
+  if (griddized_) {
+    return;
+  }
+  griddized_ = true;
+  if (!column_->nulls) {
+    return;
+  }
+  // If the whole stripe is covered by a single TB, there is no need for a
+  // separate griddize kernel.
+  if (blockSize >= column_->numValues) {
+    return;
+  }
+  auto id = stageNulls(deviceStaging, staging);
+
+  auto count = std::make_unique<GpuDecode>();
+  staging.registerPointer(id, &count->data.countBits.bits, true);
+  auto numStrides =
+      bits::roundUp(column_->numValues, kCountStride) / kCountStride;
+  auto resultId = deviceStaging.reserve(sizeof(int32_t) * numStrides);
+  deviceStaging.registerPointer(resultId, &count->result, true);
+  deviceStaging.registerPointer(resultId, &grid_.numNonNull, true);
+  count->step = DecodeStep::kCountBits;
+  count->data.countBits.numBits = column_->numValues;
+  count->data.countBits.resultStride = kCountStride;
+  programs.programs.emplace_back();
+  programs.programs.back().push_back(std::move(count));
+}
+
+void TestFormatData::startOp(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ResultStaging& deviceStaging,
+    ResultStaging& resultStaging,
+    SplitStaging& splitStaging,
+    DecodePrograms& program,
+    ReadStream& stream) {
+  VELOX_CHECK_NOT_NULL(column_);
+  BufferId id = kNoBufferId;
+  // If nulls were not staged on device in griddize() they will be moved now for
+  // the single TB.
+  stageNulls(deviceStaging, splitStaging);
+  if (!staged_) {
+    staged_ = true;
+    Staging staging(
+        column_->values->as<char>(), column_->values->size(), column_->region);
+    id = splitStaging.add(staging);
+    lastStagingId_ = splitStaging.id();
+  } else {
+    splitStaging.addDependency(lastStagingId_);
+  }
+  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
+  int32_t numBlocks =
+      bits::roundUp(op.rows.size(), rowsPerBlock) / rowsPerBlock;
+  if (numBlocks > 1) {
+    VELOX_CHECK(griddized_);
+  }
+  VELOX_CHECK_LT(numBlocks, 256 * 256, "Overflow 16 bit block number");
+  for (auto blockIdx = 0; blockIdx < numBlocks; ++blockIdx) {
+    auto rowsInBlock = std::min<int32_t>(
+        rowsPerBlock, op.rows.size() - (blockIdx * rowsPerBlock));
+    auto columnKind = static_cast<WaveTypeKind>(column_->kind);
+
+    auto step = makeStep(
+        op,
+        previousFilter,
+        deviceStaging,
+        splitStaging,
+        stream,
+        columnKind,
+        blockIdx);
+    if (column_->encoding == Encoding::kFlat) {
+      if (column_->baseline == 0 &&
+          (column_->bitWidth == 32 || column_->bitWidth == 64)) {
+        step->encoding = DecodeStep::kTrivial;
+        step->data.trivial.dataType = columnKind;
+        step->data.trivial.input = 0;
+        step->data.trivial.begin = currentRow_;
+        step->data.trivial.end = currentRow_ + rowsInBlock;
+        step->data.trivial.input = nullptr;
+        if (id != kNoBufferId) {
+          splitStaging.registerPointer(id, &step->data.trivial.input, true);
+          if (blockIdx == 0) {
+            splitStaging.registerPointer(id, &deviceBuffer_, true);
+          }
+        } else {
+          step->data.trivial.input = deviceBuffer_;
+        }
+        step->data.trivial.result = op.waveVector->values<char>();
+      } else {
+        step->encoding = DecodeStep::kDictionaryOnBitpack;
+        // Just bit pack, no dictionary.
+        step->data.dictionaryOnBitpack.alphabet = nullptr;
+        step->data.dictionaryOnBitpack.baseline = column_->baseline;
+        step->data.dictionaryOnBitpack.bitWidth = column_->bitWidth;
+        step->data.dictionaryOnBitpack.indices = nullptr;
+        step->data.dictionaryOnBitpack.begin = currentRow_;
+        if (id != kNoBufferId) {
+          splitStaging.registerPointer(
+              id, &step->data.dictionaryOnBitpack.indices, true);
+          if (blockIdx == 0) {
+            splitStaging.registerPointer(id, &deviceBuffer_, true);
+          }
+        } else {
+          step->data.dictionaryOnBitpack.indices =
+              reinterpret_cast<uint64_t*>(deviceBuffer_);
+        }
+      }
+    } else {
+      VELOX_NYI("Non flat test encoding");
+    }
+    op.isFinal = true;
+    std::vector<std::unique_ptr<GpuDecode>>* steps;
+
+    // Programs are parallel after filters
+    if (stream.filtersDone() || !previousFilter) {
+      program.programs.emplace_back();
+      steps = &program.programs.back();
+    } else {
+      steps = &program.programs[blockIdx];
+    }
+    steps->push_back(std::move(step));
+  }
+}
+
+class TestStructColumnReader : public StructColumnReader {
+ public:
+  TestStructColumnReader(
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      TestFormatParams& params,
+      common::ScanSpec& scanSpec,
+      std::vector<std::unique_ptr<Subfield::PathElement>>& path,
+      const DefinesMap& defines,
+      bool isRoot)
+      : StructColumnReader(
+            requestedType,
+            fileType,
+            pathToOperand(defines, path),
+            params,
+            scanSpec,
+            isRoot) {
+    // A reader tree may be constructed while the ScanSpec is being used
+    // for another read. This happens when the next stripe is being
+    // prepared while the previous one is reading.
+    auto& childSpecs = scanSpec.stableChildren();
+    for (auto i = 0; i < childSpecs.size(); ++i) {
+      auto childSpec = childSpecs[i];
+      if (isChildConstant(*childSpec)) {
+        VELOX_NYI();
+        continue;
+      }
+      auto childFileType = fileType_->childByName(childSpec->fieldName());
+      auto childRequestedType = requestedType_->as<TypeKind::ROW>().findChild(
+          folly::StringPiece(childSpec->fieldName()));
+      auto childParams = TestFormatParams(
+          params.pool(), params.runtimeStatistics(), params.stripe());
+
+      path.push_back(std::make_unique<common::Subfield::NestedField>(
+          childSpec->fieldName()));
+      addChild(TestFormatReader::build(
+          childRequestedType,
+          childFileType,
+          params,
+          *childSpec,
+          path,
+          defines));
+      path.pop_back();
+      childSpec->setSubscript(children_.size() - 1);
+    }
+  }
+};
+
+std::unique_ptr<ColumnReader> buildIntegerReader(
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+    TestFormatParams& params,
+    common::ScanSpec& scanSpec,
+    std::vector<std::unique_ptr<Subfield::PathElement>>& path,
+    const DefinesMap& defines) {
+  return std::make_unique<ColumnReader>(
+      requestedType, fileType, pathToOperand(defines, path), params, scanSpec);
+}
+
+// static
+std::unique_ptr<ColumnReader> TestFormatReader::build(
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+    TestFormatParams& params,
+    common::ScanSpec& scanSpec,
+    std::vector<std::unique_ptr<Subfield::PathElement>>& path,
+    const DefinesMap& defines,
+    bool isRoot) {
+  switch (fileType->type()->kind()) {
+    case TypeKind::INTEGER:
+    case TypeKind::BIGINT:
+      return buildIntegerReader(
+          requestedType, fileType, params, scanSpec, path, defines);
+
+    case TypeKind::ROW:
+      return std::make_unique<TestStructColumnReader>(
+          requestedType, fileType, params, scanSpec, path, defines, isRoot);
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
+} // namespace facebook::velox::wave::test
diff --git a/velox/experimental/wave/exec/tests/utils/TestFormatReader.h b/velox/experimental/wave/exec/tests/utils/TestFormatReader.h
new file mode 100644
index 0000000000000..55332c02b4c00
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/utils/TestFormatReader.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/exec/tests/utils/FileFormat.h"
+#include "velox/type/Subfield.h"
+
+namespace facebook::velox::wave::test {
+
+class TestFormatData : public wave::FormatData {
+ public:
+  static constexpr int32_t kNotRegistered = -1;
+
+  TestFormatData(
+      OperandId operand,
+      int32_t totalRows,
+      const test::Column* column)
+      : operand_(operand), totalRows_(totalRows), column_(column) {}
+
+  bool hasNulls() const override {
+    return column_->nulls != nullptr;
+  }
+
+  int32_t totalRows() const override {
+    return totalRows_;
+  }
+
+  void newBatch(int32_t startRow) override {
+    currentRow_ = startRow;
+    queued_ = false;
+  }
+
+  void griddize(
+      int32_t blockSize,
+      int32_t numBlocks,
+      ResultStaging& deviceStaging,
+      ResultStaging& resultStaging,
+      SplitStaging& staging,
+      DecodePrograms& programs,
+      ReadStream& stream) override;
+
+  void startOp(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ResultStaging& deviceStaging,
+      ResultStaging& resultStaging,
+      SplitStaging& staging,
+      DecodePrograms& program,
+      ReadStream& stream) override;
+
+ private:
+  // Stages movement of nulls to device if any. Returns the id of the buffer or
+  // kNotRegisterd.
+  int32_t stageNulls(ResultStaging& deviceStaging, SplitStaging& splitStaging);
+
+  const OperandId operand_;
+
+  int32_t totalRows_{0};
+
+  const test::Column* column_;
+  bool staged_{false};
+  bool nullsStaged_{false};
+  bool queued_{false};
+  int32_t numStaged_{0};
+  // The device side data area start, set after the staged transfer is done.
+  void* deviceBuffer_{nullptr};
+};
+
+class TestFormatParams : public wave::FormatParams {
+ public:
+  TestFormatParams(
+      memory::MemoryPool& pool,
+      dwio::common::ColumnReaderStatistics& stats,
+      const test::Stripe* stripe)
+      : FormatParams(pool, stats), stripe_(stripe) {}
+
+  std::unique_ptr<FormatData> toFormatData(
+      const std::shared_ptr<const dwio::common::TypeWithId>& type,
+      const velox::common::ScanSpec& scanSpec,
+      OperandId operand) override;
+
+  const Stripe* stripe() const {
+    return stripe_;
+  }
+
+ private:
+  const test::Stripe* stripe_;
+};
+
+class TestFormatReader {
+ public:
+  static std::unique_ptr<ColumnReader> build(
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      TestFormatParams& params,
+      common::ScanSpec& scanSpec,
+      std::vector<std::unique_ptr<common::Subfield::PathElement>>& path,
+      const DefinesMap& defines,
+      bool isRoot = false);
+};
+
+} // namespace facebook::velox::wave::test
diff --git a/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp
new file mode 100644
index 0000000000000..bdbaab479d75f
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h"
+#include "velox/experimental/wave/exec/tests/utils/TestFormatReader.h"
+
+DECLARE_int32(wave_max_reader_batch_rows);
+
+namespace facebook::velox::wave::test {
+
+using common::Subfield;
+
+WaveTestSplitReader::WaveTestSplitReader(
+    const std::shared_ptr<connector::ConnectorSplit>& split,
+    const SplitReaderParams& params,
+    const DefinesMap* defines) {
+  params_ = params;
+  auto hiveSplit =
+      dynamic_cast<connector::hive::HiveConnectorSplit*>(split.get());
+  VELOX_CHECK_NOT_NULL(hiveSplit);
+
+  stripe_ = test::Table::getStripe(hiveSplit->filePath);
+  if (!stripe_->isLoaded()) {
+    try {
+      fileHandle_ = params_.fileHandleFactory->generate(
+          stripe_->path,
+          hiveSplit->properties.has_value() ? &*hiveSplit->properties
+                                            : nullptr);
+      VELOX_CHECK_NOT_NULL(fileHandle_.get());
+    } catch (const VeloxRuntimeError& e) {
+      if (e.errorCode() == error_code::kFileNotFound &&
+          params_.hiveConfig->ignoreMissingFiles(
+              params_.connectorQueryCtx->sessionProperties())) {
+        emptySplit_ = true;
+        return;
+      }
+      throw;
+    }
+  }
+  VELOX_CHECK_NOT_NULL(stripe_);
+  TestFormatParams formatParams(
+      *params.connectorQueryCtx->memoryPool(), readerStats_, stripe_);
+  std::vector<std::unique_ptr<Subfield::PathElement>> empty;
+  columnReader_ = TestFormatReader::build(
+      params.readerOutputType,
+      stripe_->typeWithId,
+      formatParams,
+      *params.scanSpec,
+      empty,
+      *defines,
+      true);
+  if (fileHandle_.get()) {
+    fileInfo_.file = fileHandle_->file.get();
+    fileInfo_.fileId = &fileHandle_->uuid;
+    fileInfo_.cache = params_.connectorQueryCtx->cache();
+  }
+}
+
+int32_t WaveTestSplitReader::canAdvance(WaveStream& stream) {
+  if (!stripe_) {
+    return 0;
+  }
+  return std::min<int32_t>(FLAGS_wave_max_reader_batch_rows, available());
+}
+
+void WaveTestSplitReader::schedule(WaveStream& waveStream, int32_t maxRows) {
+  auto numRows = std::min<int32_t>(maxRows, available());
+  scheduledRows_ = numRows;
+  auto rowSet = folly::Range<const int32_t*>(iota(numRows, rows_), numRows);
+  std::unique_ptr<ReadStream> exe(reinterpret_cast<ReadStream*>(
+      waveStream.recycleExecutable(nullptr, 0).release()));
+  if (exe) {
+    VELOX_DCHECK_NOT_NULL(
+        dynamic_cast<ReadStream*>(reinterpret_cast<Executable*>(exe.get())));
+    if (reinterpret_cast<ColumnReader*>(exe->reader()) != columnReader_.get()) {
+      // The previous read exe on the WaveStream is a different split. Make new.
+      exe.reset();
+    }
+  }
+  if (!exe) {
+    exe = std::make_unique<ReadStream>(
+        reinterpret_cast<StructColumnReader*>(columnReader_.get()),
+        waveStream,
+        params_.ioStats.get(),
+        fileInfo_);
+  }
+  ReadStream::launch(std::move(exe), nextRow_, rowSet);
+  nextRow_ += scheduledRows_;
+}
+
+vector_size_t WaveTestSplitReader::outputSize(WaveStream& stream) const {
+  return scheduledRows_;
+}
+
+bool WaveTestSplitReader::isFinished() const {
+  return nextRow_ >= available();
+}
+
+namespace {
+class WaveTestSplitReaderFactory : public WaveSplitReaderFactory {
+ public:
+  std::shared_ptr<WaveSplitReader> create(
+      const std::shared_ptr<connector::ConnectorSplit>& split,
+      const SplitReaderParams& params,
+      const DefinesMap* defines) override {
+    auto hiveSplit =
+        dynamic_cast<connector::hive::HiveConnectorSplit*>(split.get());
+    if (!hiveSplit) {
+      return nullptr;
+    }
+    if (hiveSplit->filePath.size() > 11 &&
+        memcmp(hiveSplit->filePath.data(), "wavemock://", 11) == 0) {
+      return std::make_shared<WaveTestSplitReader>(split, params, defines);
+    }
+    return nullptr;
+  }
+};
+} // namespace
+
+//  static
+void WaveTestSplitReader::registerTestSplitReader() {
+  WaveSplitReader::registerFactory(
+      std::make_unique<WaveTestSplitReaderFactory>());
+}
+
+} // namespace facebook::velox::wave::test
diff --git a/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h
new file mode 100644
index 0000000000000..320c8a08784e6
--- /dev/null
+++ b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/exec/WaveSplitReader.h"
+#include "velox/experimental/wave/exec/tests/utils/FileFormat.h"
+
+namespace facebook::velox::wave::test {
+
+/// A WaveSplitReader that decodes mock Wave tables.
+class WaveTestSplitReader : public WaveSplitReader {
+ public:
+  WaveTestSplitReader(
+      const std::shared_ptr<connector::ConnectorSplit>& split,
+      const SplitReaderParams& params,
+      const DefinesMap* defines);
+
+  bool emptySplit() override {
+    return !stripe_ || stripe_->columns[0]->numValues == 0 || emptySplit_;
+  }
+
+  int32_t canAdvance(WaveStream& stream) override;
+
+  void schedule(WaveStream& stream, int32_t maxRows = 0) override;
+
+  vector_size_t outputSize(WaveStream& stream) const;
+
+  bool isFinished() const override;
+
+  uint64_t getCompletedBytes() override {
+    return params_.ioStats->rawBytesRead();
+  }
+
+  uint64_t getCompletedRows() override {
+    return nextRow_;
+  }
+
+  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+    return {};
+  }
+
+  static void registerTestSplitReader();
+
+ private:
+  int32_t available() const {
+    return stripe_->columns[0]->numValues - nextRow_;
+  }
+
+  std::shared_ptr<connector::ConnectorSplit> split_;
+  SplitReaderParams params_;
+  FileHandleCachedPtr fileHandleCachePtr;
+  cache::AsyncDataCache* cache_{nullptr};
+  test::Stripe* stripe_{nullptr};
+  std::unique_ptr<ColumnReader> columnReader_;
+  // First unscheduled row.
+  int32_t nextRow_{0};
+  int32_t scheduledRows_{0};
+  dwio::common::ColumnReaderStatistics readerStats_;
+  raw_vector<int32_t> rows_;
+  FileHandleCachedPtr fileHandle_;
+  FileInfo fileInfo_;
+  bool emptySplit_{false};
+};
+
+} // namespace facebook::velox::wave::test
diff --git a/velox/experimental/wave/vector/CMakeLists.txt b/velox/experimental/wave/vector/CMakeLists.txt
index 4f04b01abe16c..7e30824867896 100644
--- a/velox/experimental/wave/vector/CMakeLists.txt
+++ b/velox/experimental/wave/vector/CMakeLists.txt
@@ -12,5 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_wave_vector WaveVector.cpp)
-target_link_libraries(velox_wave_vector velox_vector velox_common_base)
+velox_add_library(velox_wave_vector WaveVector.cpp)
+velox_link_libraries(velox_wave_vector velox_vector velox_common_base)
diff --git a/velox/experimental/wave/vector/Operand.h b/velox/experimental/wave/vector/Operand.h
index 5ba78813086f5..0baa192d3b860 100644
--- a/velox/experimental/wave/vector/Operand.h
+++ b/velox/experimental/wave/vector/Operand.h
@@ -23,6 +23,55 @@
 /// side files.
 namespace facebook::velox::wave {
 
+/// Copy of TypeKind in velox/type/Type.h. Type.h is incompatible with Cuda
+/// headers, therefore duplicated here.
+enum class WaveTypeKind : int8_t {
+
+  BOOLEAN = 0,
+  TINYINT = 1,
+  SMALLINT = 2,
+  INTEGER = 3,
+  BIGINT = 4,
+  REAL = 5,
+  DOUBLE = 6,
+  VARCHAR = 7,
+  VARBINARY = 8,
+  TIMESTAMP = 9,
+  HUGEINT = 10,
+  // Enum values for ComplexTypes start after 30 to leave
+  // some values space to accommodate adding new scalar/native
+  // types above.
+  ARRAY = 30,
+  MAP = 31,
+  ROW = 32,
+  UNKNOWN = 33,
+  FUNCTION = 34,
+  OPAQUE = 35,
+  INVALID = 36
+};
+
+template <typename T>
+struct WaveTypeTrait {};
+
+template <>
+struct WaveTypeTrait<int32_t> {
+  static constexpr WaveTypeKind typeKind = WaveTypeKind::INTEGER;
+};
+
+template <>
+struct WaveTypeTrait<uint32_t> {
+  static constexpr WaveTypeKind typeKind = WaveTypeKind::INTEGER;
+};
+
+template <>
+struct WaveTypeTrait<int64_t> {
+  static constexpr WaveTypeKind typeKind = WaveTypeKind::BIGINT;
+};
+template <>
+struct WaveTypeTrait<uint64_t> {
+  static constexpr WaveTypeKind typeKind = WaveTypeKind::BIGINT;
+};
+
 // Normal thread block size for Wave kernels
 constexpr int32_t kBlockSize = 256;
 using OperandId = int32_t;
@@ -32,10 +81,18 @@ constexpr OperandId kNoOperand = ~0;
 using OperandIndex = uint16_t;
 constexpr OperandIndex kEmpty = ~0;
 
-// operand indices above this are offsets into TB shared memory arrays. The
-// value to use is the item at blockIx.x.
+// operand indices above this are offsets into TB shared memory arrays.
 constexpr OperandIndex kMinSharedMemIndex = 0x8000;
 
+// Number of nullable locals in shared memory. Each has kBlockSize null bytes at
+// the start of the TB shared memory. 0 means no nulls. 1 means first kBlockSize
+// bytes are nulls, 2 means second kBlockSize  bytes are null flags etc.
+constexpr uint16_t kSharedNullMask = 3;
+
+/// Start of the parameter array in the TB shared memory. 13 bits. Shift 1 left
+/// to get offset.
+constexpr uint16_t kSharedOperandMask = 0x7ffc;
+
 /// Describes an operand for a Wave kernel instruction. The same
 /// insttruction is interpreted by multiple thread blocks in the
 /// kernel invocation. When accessing an operand, we have the base
@@ -59,15 +116,62 @@ struct Operand {
   // Array of flat base values. Cast to pod type or StringView.
   void* base;
 
+  // Array of null indicators. No nulls if nullptr.  A 1 means not-null, for
+  // consistency with Velox.
+  uint8_t* nulls;
+
   // If non-nullptr, provides index into 'base. Subscripted with the
   // blockIdx - idx of first bllock wit this instruction
   // stream. Different thread blocks may or may not have indices for
   // a given operand.
   int32_t** indices;
+};
 
-  // Array of null indicators. No nulls if nullptr.  A 1 means not-null, for
-  // consistency with Velox.
-  uint8_t* nulls;
+/// Per-lane error code.
+enum class ErrorCode : uint8_t {
+  // All operations completed.
+  kOk = 0,
+
+  // Set on entry when continuing, e.g. produce more data from hash probe.
+  kContinue,
+
+  // all codes from here onwards mean the lane is off
+  // Catchall for runtime errors.
+  kError,
+
+  kInsufficientMemory,
+
+  kInactive,
+
+};
+
+/// Thread block status with count of active lanes and a per lane
+/// error code and continue points for operators that can produce more
+/// data.
+struct BlockStatus {
+  int32_t numRows{0};
+  ErrorCode errors[kBlockSize];
 };
 
+/// Describes the location of an instruction's return state in the
+/// BlockStatus area. The return states are allocated right above
+/// the BlockStatus array. First are grid level statuses for instructions that
+/// return a status. After this are block level statuses.
+
+struct InstructionStatus {
+  // Offset of containing instruction's grid state from the end of BlockStatus
+  // array.
+  uint16_t gridState{0};
+  // Total size of gridStates. Block level states start after the last grid
+  // state.
+  uint16_t gridStateSize{0};
+  // Start of per-block status. gridStateSize + gridDim.x * blocksPerThread *
+  // blockState' is the  offset of the first per block status from the end of
+  // BlockStatus array.
+  uint16_t blockState{0};
+};
+
+/// Returns the number of active rows in 'status' for 'numBlocks'.
+int32_t statusNumRows(const BlockStatus* status, int32_t numBlocks);
+
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/vector/WaveVector.cpp b/velox/experimental/wave/vector/WaveVector.cpp
index 544cfa536cd34..f9db77949df8d 100644
--- a/velox/experimental/wave/vector/WaveVector.cpp
+++ b/velox/experimental/wave/vector/WaveVector.cpp
@@ -18,13 +18,33 @@
 #include "velox/common/base/SimdUtil.h"
 #include "velox/experimental/wave/common/StringView.h"
 #include "velox/vector/FlatVector.h"
+#include "velox/vector/VectorTypeUtils.h"
 
 namespace facebook::velox::wave {
 
+template <TypeKind Kind>
+static int32_t kindSize() {
+  return sizeof(typename KindToFlatVector<Kind>::WrapperType);
+}
+
+int32_t waveTypeKindSize(WaveTypeKind waveKind) {
+  TypeKind kind = static_cast<TypeKind>(waveKind);
+  if (kind == TypeKind::VARCHAR || kind == TypeKind::VARBINARY) {
+    // Wave StringView is 8, not 16 bytes.
+    return sizeof(StringView);
+  }
+  if (kind == TypeKind::UNKNOWN) {
+    return sizeof(UnknownValue);
+  }
+
+  return VELOX_DYNAMIC_TYPE_DISPATCH(kindSize, kind);
+}
+
 WaveVector::WaveVector(
     const TypePtr& type,
     GpuArena& arena,
-    std::vector<std::unique_ptr<WaveVector>> children)
+    std::vector<std::unique_ptr<WaveVector>> children,
+    bool notNull)
     : type_(type),
       kind_(type_->kind()),
       arena_(&arena),
@@ -47,31 +67,33 @@ WaveVector::WaveVector(
   }
 }
 
-void WaveVector::resize(vector_size_t size, bool nullable) {
-  if (size > size_) {
-    int64_t bytes;
-    if (type_->kind() == TypeKind::VARCHAR) {
-      bytes = sizeof(StringView) * size;
-    } else {
-      bytes = type_->cppSizeInBytes() * size;
-    }
-    if (!values_ || bytes > values_->capacity()) {
-      values_ = arena_->allocateBytes(bytes);
-    }
-    if (nullable) {
-      if (!nulls_ || nulls_->capacity() < size) {
-        nulls_ = arena_->allocateBytes(size);
-      }
+void WaveVector::resize(
+    vector_size_t size,
+    bool nullable,
+    WaveBufferPtr* backing,
+    int64_t* backingOffset) {
+  auto capacity = values_ ? values_->capacity() : 0;
+  size_ = size;
+  int32_t bytesNeeded = backingSize(type_, size, nullable);
+  if (bytesNeeded > capacity) {
+    if (backing) {
+      values_ = WaveBufferView<WaveBufferPtr>::create(
+          (*backing)->as<uint8_t>() + *backingOffset, bytesNeeded, *backing);
+      *backingOffset += bytesNeeded;
     } else {
-      nulls_.reset();
+      values_ = arena_->allocateBytes(bytesNeeded);
     }
-    size_ = size;
+  }
+  if (nullable) {
+    nulls_ = values_->as<uint8_t>() + bytesNeeded - size;
+  } else {
+    nulls_ = nullptr;
   }
 }
 
 void WaveVector::toOperand(Operand* operand) const {
   operand->size = size_;
-  operand->nulls = nulls_ ? nulls_->as<uint8_t>() : nullptr;
+  operand->nulls = nulls_;
   if (encoding_ == VectorEncoding::Simple::CONSTANT) {
     operand->indexMask = 0;
     operand->base = values_->as<uint64_t>();
@@ -91,31 +113,38 @@ void toBits(uint64_t* words, int32_t numBytes) {
   auto data = reinterpret_cast<uint8_t*>(words);
   auto zero = xsimd::broadcast<uint8_t>(0);
   for (auto i = 0; i < numBytes; i += xsimd::batch<uint8_t>::size) {
-    auto flags = xsimd::batch<uint8_t>::load_unaligned(data) != zero;
+    auto flags = xsimd::batch<uint8_t>::load_unaligned(data + i) != zero;
     uint32_t bits = simd::toBitMask(flags);
     reinterpret_cast<uint32_t*>(words)[i / sizeof(flags)] = bits;
   }
 }
 
+namespace {
+class NoReleaser {
+ public:
+  void addRef() const {};
+  void release() const {};
+};
+
 template <TypeKind kind>
 static VectorPtr toVeloxTyped(
     vector_size_t size,
     velox::memory::MemoryPool* pool,
     const TypePtr& type,
     const WaveBufferPtr& values,
-    const WaveBufferPtr& nulls) {
+    const uint8_t* nulls) {
   using T = typename TypeTraits<kind>::NativeType;
 
   BufferPtr nullsView;
   if (nulls) {
-    nullsView = WaveBufferView::create(nulls);
+    nullsView = BufferView<NoReleaser>::create(nulls, size, NoReleaser());
     toBits(
         const_cast<uint64_t*>(nullsView->as<uint64_t>()),
         nullsView->capacity());
   }
   BufferPtr valuesView;
   if (values) {
-    valuesView = WaveBufferView::create(values);
+    valuesView = VeloxWaveBufferView::create(values);
   }
 
   return std::make_shared<FlatVector<T>>(
@@ -127,9 +156,102 @@ static VectorPtr toVeloxTyped(
       std::vector<BufferPtr>());
 }
 
-VectorPtr WaveVector::toVelox(memory::MemoryPool* pool) {
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-      toVeloxTyped, type_->kind(), size_, pool, type_, values_, nulls_);
+bool isDenselyFilled(const BlockStatus* status, int32_t numBlocks) {
+  for (int32_t i = 0; i < numBlocks - 1; ++i) {
+    if (status[i].numRows != kBlockSize) {
+      return false;
+    }
+  }
+  return true;
+}
+} // namespace
+
+int32_t statusNumRows(const BlockStatus* status, int32_t numBlocks) {
+  int32_t numRows = 0;
+  for (auto i = 0; i < numBlocks; ++i) {
+    numRows += status[i].numRows;
+  }
+  return numRows;
+}
+
+// static
+int32_t WaveVector::alignment(const TypePtr& type) {
+  switch (type->kind()) {
+    case TypeKind::VARCHAR:
+    case TypeKind::VARBINARY:
+      return sizeof(void*);
+    default:
+      return type->cppSizeInBytes();
+  }
+}
+
+//    static
+int64_t
+WaveVector::backingSize(const TypePtr& type, int32_t size, bool nullable) {
+  int64_t bytes;
+  if (type->kind() == TypeKind::VARCHAR) {
+    bytes = sizeof(StringView) * size;
+  } else {
+    bytes = type->cppSizeInBytes() * size;
+  }
+  return bits::roundUp(bytes, sizeof(void*)) + (nullable ? size : 0);
+}
+
+VectorPtr WaveVector::toVelox(
+    memory::MemoryPool* pool,
+    int32_t numBlocks,
+    const BlockStatus* status,
+    const Operand* operand) {
+  auto operandIndices = operand->indices;
+  // If there is a wrap, any row can be referenced, so the vector is
+  // with size_ of WaveVector. If there is no wrap, it is mapped to
+  // the end of the last BlockStatus. If the blocks are densely filled
+  // we have the vector at right size with no wrap on top.
+  int32_t filledSize = operandIndices
+      ? size_
+      : (kBlockSize * (numBlocks - 1)) + status[numBlocks - 1].numRows;
+  auto base = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+      toVeloxTyped, type_->kind(), filledSize, pool, type_, values_, nulls_);
+  if (!status || !operand) {
+    return base;
+  }
+
+  // Translate the BlockStatus and indices in Operand to a host side dictionary
+  // wrap.
+  int maxRow = std::min<int32_t>(filledSize, numBlocks * kBlockSize);
+  numBlocks = bits::roundUp(maxRow, kBlockSize) / kBlockSize;
+  int numActive = statusNumRows(status, numBlocks);
+  if (!operandIndices) {
+    // Vector sizes are >= active in status because they are allocated before
+    // the row count in status becomes known.
+    VELOX_CHECK_LE(
+        numActive,
+        size_,
+        "If there is no indirection in Operand, vector size must be >= BlockStatus");
+    // If all blocks except last are full we return base without wrap.
+    if (isDenselyFilled(status, numBlocks)) {
+      return base;
+    }
+  }
+  auto indices = AlignedBuffer::allocate<vector_size_t>(numActive, pool);
+  auto rawIndices = indices->asMutable<vector_size_t>();
+  int32_t fill = 0;
+  for (auto block = 0; block < numBlocks; ++block) {
+    auto blockIndices = operandIndices ? operandIndices[block] : nullptr;
+    if (!blockIndices) {
+      for (auto i = 0; i < status[block].numRows; ++i) {
+        rawIndices[fill++] = block * kBlockSize + i;
+      }
+    } else {
+      memcpy(
+          rawIndices + fill,
+          blockIndices,
+          status[block].numRows * sizeof(int32_t));
+      fill += status[block].numRows;
+    }
+  }
+  return BaseVector::wrapInDictionary(
+      BufferPtr(nullptr), indices, numActive, base);
 }
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/vector/WaveVector.h b/velox/experimental/wave/vector/WaveVector.h
index d128bbd3c46af..3da651bacf029 100644
--- a/velox/experimental/wave/vector/WaveVector.h
+++ b/velox/experimental/wave/vector/WaveVector.h
@@ -38,6 +38,8 @@ class Loader {
   bool loadTail_{false};
 };
 
+int32_t waveTypeKindSize(WaveTypeKind kind);
+
 /// Represents a vector of device side intermediate results. Vector is
 /// a host side only structure, the WaveBufferPtrs own the device
 /// memory. Unlike Velox vectors, these are statically owned by Wave
@@ -53,13 +55,14 @@ class WaveVector {
   }
 
   // Constructs a vector. Resize can be used to create buffers for a given size.
-  WaveVector(const TypePtr& type, GpuArena& arena)
-      : type_(type), kind_(type_->kind()), arena_(&arena) {}
+  WaveVector(const TypePtr& type, GpuArena& arena, bool notNull = false)
+      : type_(type), kind_(type_->kind()), arena_(&arena), notNull_(notNull) {}
 
   WaveVector(
       const TypePtr& type,
       GpuArena& arena,
-      std::vector<std::unique_ptr<WaveVector>> children);
+      std::vector<std::unique_ptr<WaveVector>> children,
+      bool notNull = false);
 
   const TypePtr& type() const {
     return type_;
@@ -69,15 +72,28 @@ class WaveVector {
     return size_;
   }
 
-  void resize(vector_size_t sie, bool nullable = true);
+  /// Sets the size to 'size'. Allocates the backing memory from
+  /// 'arena_'. If 'backing' is non-nullptr, uses '*backing' for
+  /// backing store, starting at offset *backingOffset'. Returns the
+  /// offset of the first unused byte in '*backingOffset'. Leaves
+  /// contents uninitialized in all cases.
+  void resize(
+      vector_size_t size,
+      bool nullable = true,
+      WaveBufferPtr* backing = nullptr,
+      int64_t* backingOffset = nullptr);
+
+  /// Returns the needed alignment for backing memory.
+  static int32_t alignment(const TypePtr& type);
+
+  /// Returns the size in bytes for 'size' elements of 'type', including nulls
+  /// if 'nullable' is true. Does not include string buffers.
+  static int64_t backingSize(const TypePtr& type, int32_t size, bool nullable);
 
   bool mayHaveNulls() const {
     return nulls_ != nullptr;
   }
 
-  // Makes sure there is space for nulls. Initial value is undefined.
-  void ensureNulls();
-
   // Frees all allocated buffers. resize() can be used to populate the buffers
   // with a selected size.
   void clear();
@@ -95,15 +111,19 @@ class WaveVector {
   }
 
   uint8_t* nulls() {
-    if (nulls_) {
-      return nulls_->as<uint8_t>();
-    }
-    return nullptr;
+    return nulls_;
   }
 
   /// Returns a Velox vector giving a view on device side data. The device
-  /// buffers stay live while referenced by Velox.
-  VectorPtr toVelox(memory::MemoryPool* pool);
+  /// buffers stay live while referenced by Velox. If there is a selection,
+  /// numBlocks is the number of kBlockSize blocks the vector was allocated for,
+  /// BlockStatus gives the row counts per block and Operand gives the
+  /// dictionary indices representing the selection.
+  VectorPtr toVelox(
+      memory::MemoryPool* pool,
+      int32_t numBlocks = -1,
+      const BlockStatus* status = nullptr,
+      const Operand* operand = nullptr);
 
   /// Sets 'operand' to point to the buffers of 'this'.
   void toOperand(Operand* operand) const;
@@ -126,31 +146,24 @@ class WaveVector {
 
   vector_size_t size_{0};
 
-  // Values array, cast to pod type or StringView
+  // Values array, cast to pod type or StringView. If there are nulls, the null
+  // flags are in this buffer after the values, starting at 'null_'
   WaveBufferPtr values_;
 
-  // Nulls buffer, nullptr if no nulls.
-  WaveBufferPtr nulls_;
+  // Nulls, points to the tail of 'values'. nullptr if no nulls.
+  uint8_t* nulls_{nullptr};
 
   // If dictionary or if wrapped in a selection, vector of indices into
   // 'values'.
   WaveBufferPtr indices_;
 
-  // Thread block level sizes. For each kBlockSize values, contains
-  // one int16_t that indicates how many of 'values' or 'indices' have
-  // a value.
-  WaveBufferPtr blockSizes_;
-  // Thread block level pointers inside 'indices_'. the ith entry is nullptr
-  // if the ith thread block has no row number mapping (all rows pass or none
-  // pass).
-  WaveBufferPtr blockIndices_;
-
   // Lengths and offsets for array/map elements.
   WaveBufferPtr lengths_;
   WaveBufferPtr offsets_;
 
   // Members of a array/map/struct vector.
   std::vector<std::unique_ptr<WaveVector>> children_;
+  bool notNull_{false};
 };
 
 using WaveVectorPtr = std::unique_ptr<WaveVector>;
@@ -170,11 +183,17 @@ struct WaveReleaser {
 };
 
 // A BufferView for velox::BaseVector for a view on unified memory.
-class WaveBufferView : public BufferView<WaveReleaser> {
+class VeloxWaveBufferView : public BufferView<WaveReleaser> {
  public:
-  static BufferPtr create(WaveBufferPtr buffer) {
+  /// Takes an additional reference to buffer. 'offset' and 'size'
+  /// allow sharing one allocation for many views. This is done when many
+  /// vectors have to be moved as a unit between device and host.
+  static BufferPtr
+  create(WaveBufferPtr buffer, int64_t offset = 0, int32_t size = -1) {
     return BufferView<WaveReleaser>::create(
-        buffer->as<uint8_t>(), buffer->capacity(), WaveReleaser(buffer));
+        buffer->as<uint8_t>() + offset,
+        size == -1 ? buffer->capacity() - offset : size,
+        WaveReleaser(buffer));
   }
 };
 
diff --git a/velox/experimental/wave/vector/tests/CMakeLists.txt b/velox/experimental/wave/vector/tests/CMakeLists.txt
index 2d4201c4c4cc2..1b12f8ad56ba1 100644
--- a/velox/experimental/wave/vector/tests/CMakeLists.txt
+++ b/velox/experimental/wave/vector/tests/CMakeLists.txt
@@ -14,9 +14,6 @@
 
 add_executable(velox_wave_vector_test VectorTest.cpp)
 
-set_target_properties(velox_wave_vector_test PROPERTIES CUDA_ARCHITECTURES
-                                                        native)
-
 add_test(veloxwave__vector_test velox_wave_vector_test)
 
 target_link_libraries(
@@ -32,9 +29,9 @@ target_link_libraries(
   Boost::regex
   Boost::thread
   Boost::system
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   Folly::folly
   gflags::gflags
   glog::glog
diff --git a/velox/expression/BooleanMix.cpp b/velox/expression/BooleanMix.cpp
index 1c7dfa2efacdd..e4c69b0736f2c 100644
--- a/velox/expression/BooleanMix.cpp
+++ b/velox/expression/BooleanMix.cpp
@@ -104,16 +104,12 @@ BooleanMix getFlatBool(
       memset(valuesToSet, 0, bits::nbytes(size));
       DecodedVector decoded(*vector, activeRows);
       auto values = decoded.data<uint64_t>();
-      auto nulls = decoded.nulls();
+      auto nulls = decoded.nulls(&activeRows);
       auto indices = decoded.indices();
       activeRows.applyToSelected([&](int32_t i) {
         auto index = indices[i];
         bool isNull = nulls && bits::isBitNull(nulls, i);
-        if (mergeNullsToValues && nulls) {
-          if (!isNull && bits::isBitSet(values, index)) {
-            bits::setBit(valuesToSet, i);
-          }
-        } else if (!isNull && bits::isBitSet(values, index)) {
+        if (!isNull && bits::isBitSet(values, index)) {
           bits::setBit(valuesToSet, i);
         }
         if (nullsToSet && isNull) {
diff --git a/velox/expression/CMakeLists.txt b/velox/expression/CMakeLists.txt
index 10c850bf66a1d..e1229b67c0143 100644
--- a/velox/expression/CMakeLists.txt
+++ b/velox/expression/CMakeLists.txt
@@ -12,17 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
-  velox_expression_functions FunctionSignature.cpp SignatureBinder.cpp
-                             ReverseSignatureBinder.cpp)
+velox_add_library(velox_type_signature OBJECT TypeSignature.cpp)
 
-target_link_libraries(velox_expression_functions velox_common_base
-                      velox_type_calculation)
+velox_link_libraries(velox_type_signature velox_common_base)
 
-add_library(
+velox_add_library(velox_expression_functions FunctionSignature.cpp
+                  SignatureBinder.cpp ReverseSignatureBinder.cpp)
+
+velox_link_libraries(
+  velox_expression_functions
+  velox_common_base
+  velox_type_calculation
+  velox_type_signature
+  velox_signature_parser)
+
+velox_add_library(
   velox_expression
   BooleanMix.cpp
   CastExpr.cpp
+  CastHooks.cpp
   CoalesceExpr.cpp
   ConjunctExpr.cpp
   ConstantExpr.cpp
@@ -32,23 +40,33 @@ add_library(
   ExprToSubfieldFilter.cpp
   FieldReference.cpp
   FunctionCallToSpecialForm.cpp
+  GenericWriter.cpp
   LambdaExpr.cpp
-  VectorFunction.cpp
+  PeeledEncoding.cpp
+  PrestoCastHooks.cpp
   RegisterSpecialForm.cpp
   RowConstructor.cpp
   SimpleFunctionRegistry.cpp
   SpecialFormRegistry.cpp
   SwitchExpr.cpp
   TryExpr.cpp
-  GenericWriter.cpp
-  PeeledEncoding.cpp)
+  VectorFunction.cpp)
 
-target_link_libraries(
-  velox_expression velox_core velox_vector velox_common_base
-  velox_expression_functions velox_functions_util)
+velox_link_libraries(
+  velox_expression
+  velox_core
+  velox_vector
+  velox_common_base
+  velox_expression_functions
+  velox_functions_util
+  velox_type_tz
+  double-conversion::double-conversion
+  Folly::folly)
 
 add_subdirectory(type_calculation)
+add_subdirectory(signature_parser)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
+  add_subdirectory(fuzzer)
 endif()
diff --git a/velox/expression/CastExpr-inl.h b/velox/expression/CastExpr-inl.h
index 8dbefa8642927..e767c5277cff1 100644
--- a/velox/expression/CastExpr-inl.h
+++ b/velox/expression/CastExpr-inl.h
@@ -15,8 +15,7 @@
  */
 #pragma once
 
-#include <charconv>
-
+#include "velox/common/base/CountBits.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/CoreTypeSystem.h"
 #include "velox/expression/StringWriter.h"
@@ -49,111 +48,153 @@ inline std::exception_ptr makeBadCastException(
       std::current_exception(),
       makeErrorMessage(input, row, resultType, errorDetails),
       false));
+}
+
+} // namespace
+
+namespace detail {
+
+/// Represent the varchar fragment.
+///
+/// For example:
+/// | value | wholeDigits | fractionalDigits | exponent | sign |
+/// | 9999999999.99 | 9999999999 | 99 | nullopt | 1 |
+/// | 15 | 15 |  | nullopt | 1 |
+/// | 1.5 | 1 | 5 | nullopt | 1 |
+/// | -1.5 | 1 | 5 | nullopt | -1 |
+/// | 31.523e-2 | 31 | 523 | -2 | 1 |
+struct DecimalComponents {
+  std::string_view wholeDigits;
+  std::string_view fractionalDigits;
+  std::optional<int32_t> exponent = std::nullopt;
+  int8_t sign = 1;
 };
 
-// Copied from format.h of fmt.
-inline int countDigits(uint128_t n) {
-  int count = 1;
-  for (;;) {
-    if (n < 10) {
-      return count;
-    }
-    if (n < 100) {
-      return count + 1;
-    }
-    if (n < 1000) {
-      return count + 2;
-    }
-    if (n < 10000) {
-      return count + 3;
-    }
-    n /= 10000u;
-    count += 4;
+// Extract a string view of continuous digits.
+std::string_view extractDigits(const char* s, size_t start, size_t size);
+
+/// Parse decimal components, including whole digits, fractional digits,
+/// exponent and sign, from input chars. Returns error status if input chars
+/// do not represent a valid value.
+Status
+parseDecimalComponents(const char* s, size_t size, DecimalComponents& out);
+
+/// Parse huge int from decimal components. The fractional part is scaled up by
+/// required power of 10, and added with the whole part. Returns error status if
+/// overflows.
+Status parseHugeInt(const DecimalComponents& decimalComponents, int128_t& out);
+
+/// Converts string view to decimal value of given precision and scale.
+/// Derives from Arrow function DecimalFromString. Arrow implementation:
+/// https://github.com/apache/arrow/blob/main/cpp/src/arrow/util/decimal.cc#L637.
+///
+/// Firstly, it parses the varchar to DecimalComponents which contains the
+/// message that can represent a decimal value. Secondly, processes the exponent
+/// to get the scale. Thirdly, compute the rescaled value. Returns status for
+/// the outcome of computing.
+template <typename T>
+Status toDecimalValue(
+    const StringView s,
+    int toPrecision,
+    int toScale,
+    T& decimalValue) {
+  DecimalComponents decimalComponents;
+  if (auto status =
+          parseDecimalComponents(s.data(), s.size(), decimalComponents);
+      !status.ok()) {
+    return Status::UserError("Value is not a number. " + status.message());
   }
-}
 
-/// @brief Convert the unscaled value of a decimal to varchar and write to raw
-/// string buffer from start position.
-/// @tparam T The type of input value.
-/// @param unscaledValue The input unscaled value.
-/// @param scale The scale of decimal.
-/// @param maxVarcharSize The estimated max size of a varchar.
-/// @param startPosition The start position to write from.
-/// @return A string view.
-template <typename T>
-StringView convertToStringView(
-    T unscaledValue,
-    int32_t scale,
-    int32_t maxVarcharSize,
-    char* const startPosition) {
-  char* writePosition = startPosition;
-  if (unscaledValue == 0) {
-    *writePosition++ = '0';
-  } else {
-    if (unscaledValue < 0) {
-      *writePosition++ = '-';
-      unscaledValue = -unscaledValue;
+  // Count number of significant digits (without leading zeros).
+  const size_t firstNonZero =
+      decimalComponents.wholeDigits.find_first_not_of('0');
+  size_t significantDigits = decimalComponents.fractionalDigits.size();
+  if (firstNonZero != std::string::npos) {
+    significantDigits += decimalComponents.wholeDigits.size() - firstNonZero;
+  }
+  int32_t parsedPrecision = static_cast<int32_t>(significantDigits);
+
+  int32_t parsedScale = 0;
+  bool roundUp = false;
+  const int32_t fractionSize = decimalComponents.fractionalDigits.size();
+  if (!decimalComponents.exponent.has_value()) {
+    if (fractionSize > toScale) {
+      if (decimalComponents.fractionalDigits[toScale] >= '5') {
+        roundUp = true;
+      }
+      parsedScale = toScale;
+      decimalComponents.fractionalDigits =
+          std::string_view(decimalComponents.fractionalDigits.data(), toScale);
+    } else {
+      parsedScale = fractionSize;
     }
-    auto [position, errorCode] = std::to_chars(
-        writePosition,
-        writePosition + maxVarcharSize,
-        unscaledValue / DecimalUtil::kPowersOfTen[scale]);
-    VELOX_DCHECK_EQ(
-        errorCode,
-        std::errc(),
-        "Failed to cast decimal to varchar: {}",
-        std::make_error_code(errorCode).message());
-    writePosition = position;
-
-    if (scale > 0) {
-      *writePosition++ = '.';
-      uint128_t fraction = unscaledValue % DecimalUtil::kPowersOfTen[scale];
-      // Append leading zeros.
-      int numLeadingZeros = std::max(scale - countDigits(fraction), 0);
-      std::memset(writePosition, '0', numLeadingZeros);
-      writePosition += numLeadingZeros;
-      // Append remaining fraction digits.
-      auto [position, errorCode] = std::to_chars(
-          writePosition, writePosition + maxVarcharSize, fraction);
-      VELOX_DCHECK_EQ(
-          errorCode,
-          std::errc(),
-          "Failed to cast decimal to varchar: {}",
-          std::make_error_code(errorCode).message());
-      writePosition = position;
+  } else {
+    const auto exponent = decimalComponents.exponent.value();
+    parsedScale = -exponent + fractionSize;
+    // Truncate the fractionalDigits.
+    if (parsedScale > toScale) {
+      if (-exponent >= toScale) {
+        // The fractional digits could be dropped.
+        if (fractionSize > 0 && decimalComponents.fractionalDigits[0] >= '5') {
+          roundUp = true;
+        }
+        decimalComponents.fractionalDigits = "";
+        parsedScale -= fractionSize;
+      } else {
+        const auto reduceDigits = exponent + toScale;
+        if (fractionSize > reduceDigits &&
+            decimalComponents.fractionalDigits[reduceDigits] >= '5') {
+          roundUp = true;
+        }
+        decimalComponents.fractionalDigits = std::string_view(
+            decimalComponents.fractionalDigits.data(),
+            std::min(reduceDigits, fractionSize));
+        parsedScale -= fractionSize - decimalComponents.fractionalDigits.size();
+      }
     }
   }
-  return StringView(startPosition, writePosition - startPosition);
-}
 
-} // namespace
+  int128_t out = 0;
+  if (auto status = parseHugeInt(decimalComponents, out); !status.ok()) {
+    return status;
+  }
 
-template <bool adjustForTimeZone>
-void CastExpr::castTimestampToDate(
-    const SelectivityVector& rows,
-    const BaseVector& input,
-    exec::EvalCtx& context,
-    VectorPtr& result,
-    const date::time_zone* timeZone) {
-  auto* resultFlatVector = result->as<FlatVector<int32_t>>();
-  static const int32_t kSecsPerDay{86'400};
-  auto inputVector = input.as<SimpleVector<Timestamp>>();
-  applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
-    auto input = inputVector->valueAt(row);
-    if constexpr (adjustForTimeZone) {
-      input.toTimezone(*timeZone);
+  if (roundUp) {
+    bool overflow = __builtin_add_overflow(out, 1, &out);
+    if (UNLIKELY(overflow)) {
+      return Status::UserError("Value too large.");
     }
-    auto seconds = input.getSeconds();
-    if (seconds >= 0 || seconds % kSecsPerDay == 0) {
-      resultFlatVector->set(row, seconds / kSecsPerDay);
-    } else {
-      // For division with negatives, minus 1 to compensate the discarded
-      // fractional part. e.g. -1/86'400 yields 0, yet it should be
-      // considered as -1 day.
-      resultFlatVector->set(row, seconds / kSecsPerDay - 1);
+  }
+  out *= decimalComponents.sign;
+
+  if (parsedScale < 0) {
+    /// Force the scale to be zero, to avoid negative scales (due to
+    /// compatibility issues with external systems such as databases).
+    if (-parsedScale + toScale > LongDecimalType::kMaxPrecision) {
+      return Status::UserError("Value too large.");
     }
-  });
+
+    bool overflow = __builtin_mul_overflow(
+        out, DecimalUtil::kPowersOfTen[-parsedScale + toScale], &out);
+    if (UNLIKELY(overflow)) {
+      return Status::UserError("Value too large.");
+    }
+    parsedPrecision -= parsedScale;
+    parsedScale = toScale;
+  }
+  const auto status = DecimalUtil::rescaleWithRoundUp<int128_t, T>(
+      out,
+      std::min((uint8_t)parsedPrecision, LongDecimalType::kMaxPrecision),
+      parsedScale,
+      toPrecision,
+      toScale,
+      decimalValue);
+  if (!status.ok()) {
+    return Status::UserError("Value too large.");
+  }
+  return status;
 }
+} // namespace detail
 
 template <typename Func>
 void CastExpr::applyToSelectedNoThrowLocal(
@@ -165,7 +206,12 @@ void CastExpr::applyToSelectedNoThrowLocal(
     rows.template applyToSelected([&](auto row) INLINE_LAMBDA {
       try {
         func(row);
-      } catch (...) {
+      } catch (const VeloxException& e) {
+        if (!e.isUserError()) {
+          throw;
+        }
+        result->setNull(row, true);
+      } catch (const std::exception&) {
         result->setNull(row, true);
       }
     });
@@ -179,7 +225,7 @@ void CastExpr::applyToSelectedNoThrowLocal(
         }
         // Avoid double throwing.
         context.setVeloxExceptionError(row, std::current_exception());
-      } catch (const std::exception& e) {
+      } catch (const std::exception&) {
         context.setError(row, std::current_exception());
       }
     });
@@ -189,46 +235,116 @@ void CastExpr::applyToSelectedNoThrowLocal(
 /// The per-row level Kernel
 /// @tparam ToKind The cast target type
 /// @tparam FromKind The expression type
+/// @tparam TPolicy The policy used by the cast
 /// @param row The index of the current row
 /// @param input The input vector (of type FromKind)
 /// @param result The output vector (of type ToKind)
-template <TypeKind ToKind, TypeKind FromKind, bool Truncate>
+template <TypeKind ToKind, TypeKind FromKind, typename TPolicy>
 void CastExpr::applyCastKernel(
     vector_size_t row,
     EvalCtx& context,
     const SimpleVector<typename TypeTraits<FromKind>::NativeType>* input,
     FlatVector<typename TypeTraits<ToKind>::NativeType>* result) {
-  auto inputRowValue = input->valueAt(row);
+  bool wrapException = true;
+  auto setError = [&](const std::string& details) INLINE_LAMBDA {
+    if (setNullInResultAtError()) {
+      result->setNull(row, true);
+    } else {
+      wrapException = false;
+      if (context.captureErrorDetails()) {
+        const auto errorDetails =
+            makeErrorMessage(*input, row, result->type(), details);
+        context.setStatus(row, Status::UserError("{}", errorDetails));
+      } else {
+        context.setStatus(row, Status::UserError());
+      }
+    }
+  };
 
-  // Optimize empty input strings casting by avoiding throwing exceptions.
-  if constexpr (
-      FromKind == TypeKind::VARCHAR || FromKind == TypeKind::VARBINARY) {
+  // If castResult has an error, set the error in context. Otherwise, set the
+  // value in castResult directly to result. This lambda should be called only
+  // when ToKind is primitive and is not VARCHAR or VARBINARY.
+  auto setResultOrError = [&](const auto& castResult, vector_size_t row)
+                              INLINE_LAMBDA {
+                                if (castResult.hasError()) {
+                                  setError(castResult.error().message());
+                                } else {
+                                  result->set(row, castResult.value());
+                                }
+                              };
+
+  try {
+    auto inputRowValue = input->valueAt(row);
+
+    // Optimize empty input strings casting by avoiding throwing exceptions.
     if constexpr (
-        TypeTraits<ToKind>::isPrimitiveType &&
-        TypeTraits<ToKind>::isFixedWidth) {
-      if (inputRowValue.size() == 0) {
-        if (setNullInResultAtError()) {
-          result->setNull(row, true);
-        } else {
-          context.setVeloxExceptionError(
-              row,
-              makeBadCastException(
-                  result->type(), *input, row, "Empty string"));
+        FromKind == TypeKind::VARCHAR || FromKind == TypeKind::VARBINARY) {
+      if constexpr (
+          TypeTraits<ToKind>::isPrimitiveType &&
+          TypeTraits<ToKind>::isFixedWidth) {
+        inputRowValue = hooks_->removeWhiteSpaces(inputRowValue);
+        if (inputRowValue.size() == 0) {
+          setError("Empty string");
+          return;
         }
+      }
+      if constexpr (ToKind == TypeKind::TIMESTAMP) {
+        const auto castResult = hooks_->castStringToTimestamp(inputRowValue);
+        setResultOrError(castResult, row);
+        return;
+      }
+      if constexpr (ToKind == TypeKind::REAL) {
+        const auto castResult = hooks_->castStringToReal(inputRowValue);
+        setResultOrError(castResult, row);
         return;
       }
+      if constexpr (ToKind == TypeKind::DOUBLE) {
+        const auto castResult = hooks_->castStringToDouble(inputRowValue);
+        setResultOrError(castResult, row);
+        return;
+      }
+
+      if constexpr (
+          ToKind == TypeKind::TINYINT || ToKind == TypeKind::SMALLINT ||
+          ToKind == TypeKind::INTEGER || ToKind == TypeKind::BIGINT ||
+          ToKind == TypeKind::HUGEINT) {
+        if constexpr (TPolicy::throwOnUnicode) {
+          // This is a special case where we intentionally throw
+          // VeloxRuntimeError to avoid it being suppressed by TRY().
+          VELOX_CHECK_UNSUPPORTED_INPUT_UNCATCHABLE(
+              functions::stringCore::isAscii(
+                  inputRowValue.data(), inputRowValue.size()),
+              "Unicode characters are not supported for conversion to integer types");
+        }
+      }
+    }
+
+    const auto castResult =
+        util::Converter<ToKind, void, TPolicy>::tryCast(inputRowValue);
+    if (castResult.hasError()) {
+      setError(castResult.error().message());
+      return;
     }
-  }
 
-  auto output = util::Converter<ToKind, void, Truncate>::cast(inputRowValue);
+    const auto output = castResult.value();
 
-  if constexpr (ToKind == TypeKind::VARCHAR || ToKind == TypeKind::VARBINARY) {
-    // Write the result output to the output vector
-    auto writer = exec::StringWriter<>(result, row);
-    writer.copy_from(output);
-    writer.finalize();
-  } else {
-    result->set(row, output);
+    if constexpr (
+        ToKind == TypeKind::VARCHAR || ToKind == TypeKind::VARBINARY) {
+      // Write the result output to the output vector
+      auto writer = exec::StringWriter<>(result, row);
+      writer.copy_from(output);
+      writer.finalize();
+    } else {
+      result->set(row, output);
+    }
+
+  } catch (const VeloxException& ue) {
+    if (!ue.isUserError() || !wrapException) {
+      throw;
+    }
+    setError(ue.message());
+  } catch (const std::exception& e) {
+    setError(e.what());
   }
 }
 
@@ -248,16 +364,25 @@ void CastExpr::applyDecimalCastKernel(
 
   applyToSelectedNoThrowLocal(
       context, rows, castResult, [&](vector_size_t row) {
-        auto rescaledValue = DecimalUtil::rescaleWithRoundUp<TInput, TOutput>(
+        TOutput rescaledValue;
+        const auto status = DecimalUtil::rescaleWithRoundUp<TInput, TOutput>(
             sourceVector->valueAt(row),
             fromPrecisionScale.first,
             fromPrecisionScale.second,
             toPrecisionScale.first,
-            toPrecisionScale.second);
-        if (rescaledValue.has_value()) {
-          castResultRawBuffer[row] = rescaledValue.value();
+            toPrecisionScale.second,
+            rescaledValue);
+        if (status.ok()) {
+          castResultRawBuffer[row] = rescaledValue;
         } else {
-          castResult->setNull(row, true);
+          if (setNullInResultAtError()) {
+            castResult->setNull(row, true);
+          } else {
+            context.setVeloxExceptionError(
+                row,
+                std::make_exception_ptr(VeloxUserError(
+                    std::current_exception(), status.message(), false)));
+          }
         }
       });
 }
@@ -287,6 +412,69 @@ void CastExpr::applyIntToDecimalCastKernel(
       });
 }
 
+template <typename TInput, typename TOutput>
+void CastExpr::applyFloatingPointToDecimalCastKernel(
+    const SelectivityVector& rows,
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const TypePtr& toType,
+    VectorPtr& result) {
+  const auto floatingInput = input.as<SimpleVector<TInput>>();
+  auto rawResults =
+      result->asUnchecked<FlatVector<TOutput>>()->mutableRawValues();
+  const auto toPrecisionScale = getDecimalPrecisionScale(*toType);
+
+  applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
+    TOutput output;
+    const auto status = DecimalUtil::rescaleFloatingPoint<TInput, TOutput>(
+        floatingInput->valueAt(row),
+        toPrecisionScale.first,
+        toPrecisionScale.second,
+        output);
+    if (status.ok()) {
+      rawResults[row] = output;
+    } else {
+      if (setNullInResultAtError()) {
+        result->setNull(row, true);
+      } else {
+        context.setVeloxExceptionError(
+            row, makeBadCastException(toType, input, row, status.message()));
+      }
+    }
+  });
+}
+
+template <typename T>
+void CastExpr::applyVarcharToDecimalCastKernel(
+    const SelectivityVector& rows,
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const TypePtr& toType,
+    VectorPtr& result) {
+  auto sourceVector = input.as<SimpleVector<StringView>>();
+  auto rawBuffer = result->asUnchecked<FlatVector<T>>()->mutableRawValues();
+  const auto toPrecisionScale = getDecimalPrecisionScale(*toType);
+
+  rows.applyToSelected([&](auto row) {
+    T decimalValue;
+    const auto status = detail::toDecimalValue<T>(
+        hooks_->removeWhiteSpaces(sourceVector->valueAt(row)),
+        toPrecisionScale.first,
+        toPrecisionScale.second,
+        decimalValue);
+    if (status.ok()) {
+      rawBuffer[row] = decimalValue;
+    } else {
+      if (setNullInResultAtError()) {
+        result->setNull(row, true);
+      } else {
+        context.setVeloxExceptionError(
+            row, makeBadCastException(toType, input, row, status.message()));
+      }
+    }
+  });
+}
+
 template <typename FromNativeType, TypeKind ToKind>
 VectorPtr CastExpr::applyDecimalToFloatCast(
     const SelectivityVector& rows,
@@ -304,8 +492,11 @@ VectorPtr CastExpr::applyDecimalToFloatCast(
   const auto simpleInput = input.as<SimpleVector<FromNativeType>>();
   const auto scaleFactor = DecimalUtil::kPowersOfTen[precisionScale.second];
   applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
-    auto output =
-        util::Converter<ToKind, void, false>::cast(simpleInput->valueAt(row));
+    const auto output =
+        util::Converter<ToKind>::tryCast(simpleInput->valueAt(row))
+            .thenOrThrow(folly::identity, [&](const Status& status) {
+              VELOX_USER_FAIL("{}", status.message());
+            });
     resultBuffer[row] = output / scaleFactor;
   });
   return result;
@@ -327,37 +518,39 @@ VectorPtr CastExpr::applyDecimalToIntegralCast(
   const auto precisionScale = getDecimalPrecisionScale(*fromType);
   const auto simpleInput = input.as<SimpleVector<FromNativeType>>();
   const auto scaleFactor = DecimalUtil::kPowersOfTen[precisionScale.second];
-  const auto castToIntByTruncate =
-      context.execCtx()->queryCtx()->queryConfig().isCastToIntByTruncate();
-  applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
-    auto value = simpleInput->valueAt(row);
-    auto integralPart = value / scaleFactor;
-    if (!castToIntByTruncate) {
+  if (hooks_->truncate()) {
+    applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
+      resultBuffer[row] =
+          static_cast<To>(simpleInput->valueAt(row) / scaleFactor);
+    });
+  } else {
+    applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
+      auto value = simpleInput->valueAt(row);
+      auto integralPart = value / scaleFactor;
       auto fractionPart = value % scaleFactor;
       auto sign = value >= 0 ? 1 : -1;
       bool needsRoundUp =
           (scaleFactor != 1) && (sign * fractionPart >= (scaleFactor >> 1));
       integralPart += needsRoundUp ? sign : 0;
-    }
-
-    if (integralPart > std::numeric_limits<To>::max() ||
-        integralPart < std::numeric_limits<To>::min()) {
-      if (setNullInResultAtError()) {
-        result->setNull(row, true);
-      } else {
-        context.setVeloxExceptionError(
-            row,
-            makeBadCastException(
-                result->type(),
-                input,
-                row,
-                makeErrorMessage(input, row, toType) + "Out of bounds."));
+      if (integralPart > std::numeric_limits<To>::max() ||
+          integralPart < std::numeric_limits<To>::min()) {
+        if (setNullInResultAtError()) {
+          result->setNull(row, true);
+        } else {
+          context.setVeloxExceptionError(
+              row,
+              makeBadCastException(
+                  result->type(),
+                  input,
+                  row,
+                  makeErrorMessage(input, row, toType) + "Out of bounds."));
+        }
+        return;
       }
-      return;
-    }
 
-    resultBuffer[row] = static_cast<To>(integralPart);
-  });
+      resultBuffer[row] = static_cast<To>(integralPart);
+    });
+  }
   return result;
 }
 
@@ -391,28 +584,14 @@ VectorPtr CastExpr::applyDecimalToVarcharCast(
   const auto simpleInput = input.as<SimpleVector<FromNativeType>>();
   int precision = getDecimalPrecisionScale(*fromType).first;
   int scale = getDecimalPrecisionScale(*fromType).second;
-  // A varchar's size is estimated with unscaled value digits, dot, leading
-  // zero, and possible minus sign.
-  int32_t rowSize = precision + 1;
-  if (scale > 0) {
-    ++rowSize; // A dot.
-  }
-  if (precision == scale) {
-    ++rowSize; // Leading zero.
-  }
-
+  auto rowSize = DecimalUtil::maxStringViewSize(precision, scale);
   auto flatResult = result->asFlatVector<StringView>();
   if (StringView::isInline(rowSize)) {
     char inlined[StringView::kInlineSize];
     applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
-      if (simpleInput->isNullAt(row)) {
-        result->setNull(row, true);
-      } else {
-        flatResult->setNoCopy(
-            row,
-            convertToStringView<FromNativeType>(
-                simpleInput->valueAt(row), scale, rowSize, inlined));
-      }
+      auto actualSize = DecimalUtil::castToString<FromNativeType>(
+          simpleInput->valueAt(row), scale, rowSize, inlined);
+      flatResult->setNoCopy(row, StringView(inlined, actualSize));
     });
     return result;
   }
@@ -422,17 +601,13 @@ VectorPtr CastExpr::applyDecimalToVarcharCast(
   char* rawBuffer = buffer->asMutable<char>() + buffer->size();
 
   applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
-    if (simpleInput->isNullAt(row)) {
-      result->setNull(row, true);
-    } else {
-      auto stringView = convertToStringView<FromNativeType>(
-          simpleInput->valueAt(row), scale, rowSize, rawBuffer);
-      flatResult->setNoCopy(row, stringView);
-      if (!stringView.isInline()) {
-        // If string view is inline, correponding bytes on the raw string buffer
-        // are not needed.
-        rawBuffer += stringView.size();
-      }
+    auto actualSize = DecimalUtil::castToString<FromNativeType>(
+        simpleInput->valueAt(row), scale, rowSize, rawBuffer);
+    flatResult->setNoCopy(row, StringView(rawBuffer, actualSize));
+    if (!StringView::isInline(actualSize)) {
+      // If string view is inline, corresponding bytes on the raw string buffer
+      // are not needed.
+      rawBuffer += actualSize;
     }
   });
   // Update the exact buffer size.
@@ -487,67 +662,28 @@ void CastExpr::applyCastPrimitives(
   auto* resultFlatVector = result->as<FlatVector<To>>();
   auto* inputSimpleVector = input.as<SimpleVector<From>>();
 
-  const auto& queryConfig = context.execCtx()->queryCtx()->queryConfig();
-  auto& resultType = resultFlatVector->type();
-
-  auto setError = [&](vector_size_t row, const std::string& details) {
-    if (setNullInResultAtError()) {
-      result->setNull(row, true);
-    } else {
-      context.setVeloxExceptionError(
-          row, makeBadCastException(resultType, input, row, details));
-    }
-  };
-
-  if (!queryConfig.isCastToIntByTruncate()) {
-    applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
-      try {
-        applyCastKernel<ToKind, FromKind, false /*truncate*/>(
+  switch (hooks_->getPolicy()) {
+    case LegacyCastPolicy:
+      applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
+        applyCastKernel<ToKind, FromKind, util::LegacyCastPolicy>(
             row, context, inputSimpleVector, resultFlatVector);
-
-      } catch (const VeloxException& ue) {
-        if (!ue.isUserError()) {
-          throw;
-        }
-        setError(row, ue.message());
-      } catch (const std::exception& e) {
-        setError(row, e.what());
-      }
-    });
-
-  } else {
-    applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
-      try {
-        applyCastKernel<ToKind, FromKind, true /*truncate*/>(
+      });
+      break;
+    case PrestoCastPolicy:
+      applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
+        applyCastKernel<ToKind, FromKind, util::PrestoCastPolicy>(
             row, context, inputSimpleVector, resultFlatVector);
-      } catch (const VeloxException& ue) {
-        if (!ue.isUserError()) {
-          throw;
-        }
-        setError(row, ue.message());
-      } catch (const std::exception& e) {
-        setError(row, e.what());
-      }
-    });
-  }
+      });
+      break;
+    case SparkCastPolicy:
+      applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
+        applyCastKernel<ToKind, FromKind, util::SparkCastPolicy>(
+            row, context, inputSimpleVector, resultFlatVector);
+      });
+      break;
 
-  // If we're converting to a TIMESTAMP, check if we need to adjust the
-  // current GMT timezone to the user provided session timezone.
-  if constexpr (ToKind == TypeKind::TIMESTAMP) {
-    // If user explicitly asked us to adjust the timezone.
-    if (queryConfig.adjustTimestampToTimezone()) {
-      auto sessionTzName = queryConfig.sessionTimezone();
-      if (!sessionTzName.empty()) {
-        // locate_zone throws runtime_error if the timezone couldn't be found
-        // (so we're safe to dereference the pointer).
-        auto* timeZone = date::locate_zone(sessionTzName);
-        auto rawTimestamps = resultFlatVector->mutableRawValues();
-
-        applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
-          rawTimestamps[row].toGMT(*timeZone);
-        });
-      }
-    }
+    default:
+      VELOX_NYI("Policy {} not yet implemented.", hooks_->getPolicy());
   }
 }
 
diff --git a/velox/expression/CastExpr.cpp b/velox/expression/CastExpr.cpp
index 57977869d88b6..0da3b7b45e985 100644
--- a/velox/expression/CastExpr.cpp
+++ b/velox/expression/CastExpr.cpp
@@ -22,16 +22,142 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/CoreTypeSystem.h"
 #include "velox/expression/PeeledEncoding.h"
+#include "velox/expression/PrestoCastHooks.h"
 #include "velox/expression/ScopedVarSetter.h"
-#include "velox/external/date/tz.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
 #include "velox/type/Type.h"
+#include "velox/type/tz/TimeZoneMap.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/FunctionVector.h"
 #include "velox/vector/SelectivityVector.h"
 
 namespace facebook::velox::exec {
 
+std::string_view
+detail::extractDigits(const char* s, size_t start, size_t size) {
+  size_t pos = start;
+  for (; pos < size; ++pos) {
+    if (!std::isdigit(s[pos])) {
+      break;
+    }
+  }
+  return std::string_view(s + start, pos - start);
+}
+
+Status detail::parseDecimalComponents(
+    const char* s,
+    size_t size,
+    detail::DecimalComponents& out) {
+  if (size == 0) {
+    return Status::UserError("Input is empty.");
+  }
+
+  size_t pos = 0;
+
+  // Sign of the number.
+  if (s[pos] == '-') {
+    out.sign = -1;
+    ++pos;
+  } else if (s[pos] == '+') {
+    out.sign = 1;
+    ++pos;
+  }
+
+  // Extract the whole digits.
+  out.wholeDigits = detail::extractDigits(s, pos, size);
+  pos += out.wholeDigits.size();
+  if (pos == size) {
+    return out.wholeDigits.empty()
+        ? Status::UserError("Extracted digits are empty.")
+        : Status::OK();
+  }
+
+  // Optional dot (if given in fractional form).
+  if (s[pos] == '.') {
+    // Extract the fractional digits.
+    ++pos;
+    out.fractionalDigits = detail::extractDigits(s, pos, size);
+    pos += out.fractionalDigits.size();
+  }
+
+  if (out.wholeDigits.empty() && out.fractionalDigits.empty()) {
+    return Status::UserError("Extracted digits are empty.");
+  }
+  if (pos == size) {
+    return Status::OK();
+  }
+  // Optional exponent.
+  if (s[pos] == 'e' || s[pos] == 'E') {
+    ++pos;
+    bool withSign = pos < size && (s[pos] == '+' || s[pos] == '-');
+    if (withSign && pos == size - 1) {
+      return Status::UserError("The exponent part only contains sign.");
+    }
+    // Make sure all chars after sign are digits, as as folly::tryTo allows
+    // leading and trailing whitespaces.
+    for (auto i = (size_t)withSign; i < size - pos; ++i) {
+      if (!std::isdigit(s[pos + i])) {
+        return Status::UserError(
+            "Non-digit character '{}' is not allowed in the exponent part.",
+            s[pos + i]);
+      }
+    }
+    out.exponent = folly::to<int32_t>(folly::StringPiece(s + pos, size - pos));
+    return Status::OK();
+  }
+  return pos == size
+      ? Status::OK()
+      : Status::UserError(
+            "Chars '{}' are invalid.", std::string(s + pos, size - pos));
+}
+
+Status detail::parseHugeInt(
+    const DecimalComponents& decimalComponents,
+    int128_t& out) {
+  // Parse the whole digits.
+  if (decimalComponents.wholeDigits.size() > 0) {
+    const auto tryValue = folly::tryTo<int128_t>(folly::StringPiece(
+        decimalComponents.wholeDigits.data(),
+        decimalComponents.wholeDigits.size()));
+    if (tryValue.hasError()) {
+      return Status::UserError("Value too large.");
+    }
+    out = tryValue.value();
+  }
+
+  // Parse the fractional digits.
+  if (decimalComponents.fractionalDigits.size() > 0) {
+    const auto length = decimalComponents.fractionalDigits.size();
+    bool overflow =
+        __builtin_mul_overflow(out, DecimalUtil::kPowersOfTen[length], &out);
+    if (overflow) {
+      return Status::UserError("Value too large.");
+    }
+    const auto tryValue = folly::tryTo<int128_t>(
+        folly::StringPiece(decimalComponents.fractionalDigits.data(), length));
+    if (tryValue.hasError()) {
+      return Status::UserError("Value too large.");
+    }
+    overflow = __builtin_add_overflow(out, tryValue.value(), &out);
+    VELOX_DCHECK(!overflow);
+  }
+  return Status::OK();
+}
+
+namespace {
+
+const tz::TimeZone* getTimeZoneFromConfig(const core::QueryConfig& config) {
+  if (config.adjustTimestampToTimezone()) {
+    const auto sessionTzName = config.sessionTimezone();
+    if (!sessionTzName.empty()) {
+      return tz::locateZone(sessionTzName);
+    }
+  }
+  return nullptr;
+}
+
+} // namespace
+
 VectorPtr CastExpr::castFromDate(
     const SelectivityVector& rows,
     const BaseVector& input,
@@ -47,10 +173,11 @@ VectorPtr CastExpr::castFromDate(
       auto* resultFlatVector = castResult->as<FlatVector<StringView>>();
       applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
         try {
+          // TODO Optimize to avoid creating an intermediate string.
           auto output = DATE()->toString(inputFlatVector->valueAt(row));
           auto writer = exec::StringWriter<>(resultFlatVector, row);
           writer.resize(output.size());
-          std::memcpy(writer.data(), output.data(), output.size());
+          ::memcpy(writer.data(), output.data(), output.size());
           writer.finalize();
         } catch (const VeloxException& ue) {
           if (!ue.isUserError()) {
@@ -67,12 +194,8 @@ VectorPtr CastExpr::castFromDate(
     }
     case TypeKind::TIMESTAMP: {
       static const int64_t kMillisPerDay{86'400'000};
-      const auto& queryConfig = context.execCtx()->queryCtx()->queryConfig();
-      const auto sessionTzName = queryConfig.sessionTimezone();
       const auto* timeZone =
-          (queryConfig.adjustTimestampToTimezone() && !sessionTzName.empty())
-          ? date::locate_zone(sessionTzName)
-          : nullptr;
+          getTimeZoneFromConfig(context.execCtx()->queryCtx()->queryConfig());
       auto* resultFlatVector = castResult->as<FlatVector<Timestamp>>();
       applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
         auto timestamp = Timestamp::fromMillis(
@@ -103,14 +226,34 @@ VectorPtr CastExpr::castToDate(
   switch (fromType->kind()) {
     case TypeKind::VARCHAR: {
       auto* inputVector = input.as<SimpleVector<StringView>>();
-      const auto& queryConfig = context.execCtx()->queryCtx()->queryConfig();
-      auto isIso8601 = queryConfig.isIso8601();
       applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        bool wrapException = true;
         try {
-          auto inputString = inputVector->valueAt(row);
-          resultFlatVector->set(
-              row, util::castFromDateString(inputString, isIso8601));
+          const auto result =
+              hooks_->castStringToDate(inputVector->valueAt(row));
+          if (result.hasError()) {
+            wrapException = false;
+            if (setNullInResultAtError()) {
+              resultFlatVector->setNull(row, true);
+            } else {
+              if (context.captureErrorDetails()) {
+                context.setStatus(
+                    row,
+                    Status::UserError(
+                        "{} {}",
+                        makeErrorMessage(input, row, DATE()),
+                        result.error().message()));
+              } else {
+                context.setStatus(row, Status::UserError());
+              }
+            }
+          } else {
+            resultFlatVector->set(row, result.value());
+          }
         } catch (const VeloxUserError& ue) {
+          if (!wrapException) {
+            throw;
+          }
           VELOX_USER_FAIL(
               makeErrorMessage(input, row, DATE()) + " " + ue.message());
         } catch (const std::exception& e) {
@@ -122,14 +265,13 @@ VectorPtr CastExpr::castToDate(
       return castResult;
     }
     case TypeKind::TIMESTAMP: {
-      const auto& queryConfig = context.execCtx()->queryCtx()->queryConfig();
-      auto sessionTzName = queryConfig.sessionTimezone();
-      if (queryConfig.adjustTimestampToTimezone() && !sessionTzName.empty()) {
-        auto* timeZone = date::locate_zone(sessionTzName);
-        castTimestampToDate<true>(rows, input, context, castResult, timeZone);
-      } else {
-        castTimestampToDate<false>(rows, input, context, castResult);
-      }
+      auto* inputVector = input.as<SimpleVector<Timestamp>>();
+      const auto* timeZone =
+          getTimeZoneFromConfig(context.execCtx()->queryCtx()->queryConfig());
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        const auto days = util::toDate(inputVector->valueAt(row), timeZone);
+        resultFlatVector->set(row, days);
+      });
       return castResult;
     }
     default:
@@ -138,6 +280,49 @@ VectorPtr CastExpr::castToDate(
   }
 }
 
+VectorPtr CastExpr::castFromIntervalDayTime(
+    const SelectivityVector& rows,
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const TypePtr& toType) {
+  VectorPtr castResult;
+  context.ensureWritable(rows, toType, castResult);
+  (*castResult).clearNulls(rows);
+
+  auto* inputFlatVector = input.as<SimpleVector<int64_t>>();
+  switch (toType->kind()) {
+    case TypeKind::VARCHAR: {
+      auto* resultFlatVector = castResult->as<FlatVector<StringView>>();
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        try {
+          // TODO Optimize to avoid creating an intermediate string.
+          auto output =
+              INTERVAL_DAY_TIME()->valueToString(inputFlatVector->valueAt(row));
+          auto writer = exec::StringWriter<>(resultFlatVector, row);
+          writer.resize(output.size());
+          ::memcpy(writer.data(), output.data(), output.size());
+          writer.finalize();
+        } catch (const VeloxException& ue) {
+          if (!ue.isUserError()) {
+            throw;
+          }
+          VELOX_USER_FAIL(
+              makeErrorMessage(input, row, toType) + " " + ue.message());
+        } catch (const std::exception& e) {
+          VELOX_USER_FAIL(
+              makeErrorMessage(input, row, toType) + " " + e.what());
+        }
+      });
+      return castResult;
+    }
+    default:
+      VELOX_UNSUPPORTED(
+          "Cast from {} to {} is not supported",
+          INTERVAL_DAY_TIME()->toString(),
+          toType->toString());
+  }
+}
+
 namespace {
 void propagateErrorsOrSetNulls(
     bool setNullInResultAtError,
@@ -145,7 +330,7 @@ void propagateErrorsOrSetNulls(
     const SelectivityVector& nestedRows,
     const BufferPtr& elementToTopLevelRows,
     VectorPtr& result,
-    ErrorVectorPtr& oldErrors) {
+    EvalErrorsPtr& oldErrors) {
   if (context.errors()) {
     if (setNullInResultAtError) {
       // Errors in context.errors() should be translated to nulls in the top
@@ -192,7 +377,7 @@ VectorPtr CastExpr::applyMap(
         mapKeys->size(), rows, input, context.pool());
   }
 
-  ErrorVectorPtr oldErrors;
+  EvalErrorsPtr oldErrors;
   context.swapErrors(oldErrors);
 
   // Cast keys
@@ -287,7 +472,7 @@ VectorPtr CastExpr::applyArray(
   auto elementToTopLevelRows = functions::getElementToTopLevelRows(
       arrayElements->size(), rows, input, context.pool());
 
-  ErrorVectorPtr oldErrors;
+  EvalErrorsPtr oldErrors;
   context.swapErrors(oldErrors);
 
   VectorPtr newElements;
@@ -357,7 +542,7 @@ VectorPtr CastExpr::applyRow(
   std::vector<VectorPtr> newChildren;
   newChildren.reserve(numOutputChildren);
 
-  ErrorVectorPtr oldErrors;
+  EvalErrorsPtr oldErrors;
   if (setNullInResultAtError()) {
     // We need to isolate errors that happen during the cast from previous
     // errors since those translate to nulls, unlike exisiting errors.
@@ -394,7 +579,7 @@ VectorPtr CastExpr::applyRow(
     if (matchNotFound) {
       // Create a vector for null for this child
       context.ensureWritable(rows, toChildType, outputChild);
-      outputChild->addNulls(nullptr, rows);
+      outputChild->addNulls(rows);
     } else {
       const auto& inputChild = input->children()[fromChildrenIndex];
       if (toChildType == inputChild->type()) {
@@ -426,7 +611,7 @@ VectorPtr CastExpr::applyRow(
     // Set errors as nulls.
     if (auto errors = context.errors()) {
       rows.applyToSelected([&](auto row) {
-        if (errors->isIndexInRange(row) && !errors->isNullAt(row)) {
+        if (errors->hasErrorAt(row)) {
           result->setNull(row, true);
         }
       });
@@ -451,6 +636,10 @@ VectorPtr CastExpr::applyDecimal(
 
   // toType is a decimal
   switch (fromType->kind()) {
+    case TypeKind::BOOLEAN:
+      applyIntToDecimalCastKernel<bool, toDecimalType>(
+          rows, input, context, toType, castResult);
+      break;
     case TypeKind::TINYINT:
       applyIntToDecimalCastKernel<int8_t, toDecimalType>(
           rows, input, context, toType, castResult);
@@ -463,6 +652,14 @@ VectorPtr CastExpr::applyDecimal(
       applyIntToDecimalCastKernel<int32_t, toDecimalType>(
           rows, input, context, toType, castResult);
       break;
+    case TypeKind::REAL:
+      applyFloatingPointToDecimalCastKernel<float, toDecimalType>(
+          rows, input, context, toType, castResult);
+      break;
+    case TypeKind::DOUBLE:
+      applyFloatingPointToDecimalCastKernel<double, toDecimalType>(
+          rows, input, context, toType, castResult);
+      break;
     case TypeKind::BIGINT: {
       if (fromType->isShortDecimal()) {
         applyDecimalCastKernel<int64_t, toDecimalType>(
@@ -481,6 +678,10 @@ VectorPtr CastExpr::applyDecimal(
       }
       [[fallthrough]];
     }
+    case TypeKind::VARCHAR:
+      applyVarcharToDecimalCastKernel<toDecimalType>(
+          rows, input, context, toType, castResult);
+      break;
     default:
       VELOX_UNSUPPORTED(
           "Cast from {} to {} is not supported",
@@ -497,18 +698,29 @@ void CastExpr::applyPeeled(
     const TypePtr& fromType,
     const TypePtr& toType,
     VectorPtr& result) {
-  if (castFromOperator_ || castToOperator_) {
-    VELOX_CHECK_NE(
-        fromType,
-        toType,
+  auto castFromOperator = getCastOperator(fromType);
+  if (castFromOperator && !castFromOperator->isSupportedToType(toType)) {
+    VELOX_USER_FAIL(
+        "Cannot cast {} to {}.", fromType->toString(), toType->toString());
+  }
+
+  auto castToOperator = getCastOperator(toType);
+  if (castToOperator && !castToOperator->isSupportedFromType(fromType)) {
+    VELOX_USER_FAIL(
+        "Cannot cast {} to {}.", fromType->toString(), toType->toString());
+  }
+
+  if (castFromOperator || castToOperator) {
+    VELOX_USER_CHECK(
+        *fromType != *toType,
         "Attempting to cast from {} to itself.",
         fromType->toString());
 
     auto applyCustomCast = [&]() {
-      if (castToOperator_) {
-        castToOperator_->castTo(input, context, rows, toType, result);
+      if (castToOperator) {
+        castToOperator->castTo(input, context, rows, toType, result, hooks_);
       } else {
-        castFromOperator_->castFrom(input, context, rows, toType, result);
+        castFromOperator->castFrom(input, context, rows, toType, result);
       }
     };
 
@@ -516,7 +728,7 @@ void CastExpr::applyPeeled(
       // This can be optimized by passing setNullInResultAtError() to castTo and
       // castFrom operations.
 
-      ErrorVectorPtr oldErrors;
+      EvalErrorsPtr oldErrors;
       context.swapErrors(oldErrors);
 
       applyCustomCast();
@@ -526,7 +738,7 @@ void CastExpr::applyPeeled(
         auto rawNulls = result->mutableRawNulls();
 
         rows.applyToSelected([&](auto row) {
-          if (errors->isIndexInRange(row) && !errors->isNullAt(row)) {
+          if (errors->hasErrorAt(row)) {
             bits::setNull(rawNulls, row, true);
           }
         });
@@ -537,11 +749,17 @@ void CastExpr::applyPeeled(
     } else {
       applyCustomCast();
     }
-
   } else if (fromType->isDate()) {
     result = castFromDate(rows, input, context, toType);
   } else if (toType->isDate()) {
     result = castToDate(rows, input, context, fromType);
+  } else if (fromType->isIntervalDayTime()) {
+    result = castFromIntervalDayTime(rows, input, context, toType);
+  } else if (toType->isIntervalDayTime()) {
+    VELOX_UNSUPPORTED(
+        "Cast from {} to {} is not supported",
+        fromType->toString(),
+        toType->toString());
   } else if (toType->isShortDecimal()) {
     result = applyDecimal<int64_t>(rows, input, context, fromType, toType);
   } else if (toType->isLongDecimal()) {
@@ -567,6 +785,31 @@ void CastExpr::applyPeeled(
             fromType,
             toType);
     }
+  } else if (
+      fromType->kind() == TypeKind::TIMESTAMP &&
+      (toType->kind() == TypeKind::VARCHAR ||
+       toType->kind() == TypeKind::VARBINARY)) {
+    result = applyTimestampToVarcharCast(toType, rows, context, input);
+  } else if (toType->kind() == TypeKind::VARBINARY) {
+    switch (fromType->kind()) {
+      case TypeKind::TINYINT:
+        result = applyIntToBinaryCast<int8_t>(rows, context, input);
+        break;
+      case TypeKind::SMALLINT:
+        result = applyIntToBinaryCast<int16_t>(rows, context, input);
+        break;
+      case TypeKind::INTEGER:
+        result = applyIntToBinaryCast<int32_t>(rows, context, input);
+        break;
+      case TypeKind::BIGINT:
+        result = applyIntToBinaryCast<int64_t>(rows, context, input);
+        break;
+      default:
+        // Handle primitive type conversions.
+        applyCastPrimitivesDispatch<TypeKind::VARBINARY>(
+            fromType, toType, rows, context, input, result);
+        break;
+    }
   } else {
     switch (toType->kind()) {
       case TypeKind::MAP:
@@ -609,6 +852,72 @@ void CastExpr::applyPeeled(
   }
 }
 
+VectorPtr CastExpr::applyTimestampToVarcharCast(
+    const TypePtr& toType,
+    const SelectivityVector& rows,
+    exec::EvalCtx& context,
+    const BaseVector& input) {
+  VectorPtr result;
+  context.ensureWritable(rows, toType, result);
+  (*result).clearNulls(rows);
+  auto flatResult = result->asFlatVector<StringView>();
+  const auto simpleInput = input.as<SimpleVector<Timestamp>>();
+
+  const auto& options = hooks_->timestampToStringOptions();
+  const uint32_t rowSize = getMaxStringLength(options);
+
+  Buffer* buffer = flatResult->getBufferWithSpace(
+      rows.countSelected() * rowSize, true /*exactSize*/);
+  char* rawBuffer = buffer->asMutable<char>() + buffer->size();
+
+  applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
+    // Adjust input timestamp according the session timezone.
+    Timestamp inputValue(simpleInput->valueAt(row));
+    if (options.timeZone) {
+      inputValue.toTimezone(*(options.timeZone));
+    }
+    const auto stringView =
+        Timestamp::tsToStringView(inputValue, options, rawBuffer);
+    flatResult->setNoCopy(row, stringView);
+    // The result of both Presto and Spark contains more than 12 digits even
+    // when 'zeroPaddingYear' is disabled.
+    VELOX_DCHECK(!stringView.isInline());
+    rawBuffer += stringView.size();
+  });
+
+  // Update the exact buffer size.
+  buffer->setSize(rawBuffer - buffer->asMutable<char>());
+  return result;
+}
+
+template <typename TInput>
+VectorPtr CastExpr::applyIntToBinaryCast(
+    const SelectivityVector& rows,
+    exec::EvalCtx& context,
+    const BaseVector& input) {
+  auto result = BaseVector::create(VARBINARY(), rows.end(), context.pool());
+  const auto flatResult = result->asFlatVector<StringView>();
+  const auto simpleInput = input.as<SimpleVector<TInput>>();
+
+  // The created string view is always inlined for int types.
+  char inlined[sizeof(TInput)];
+  applyToSelectedNoThrowLocal(context, rows, result, [&](vector_size_t row) {
+    TInput input = simpleInput->valueAt(row);
+    if constexpr (std::is_same_v<TInput, int8_t>) {
+      inlined[0] = static_cast<char>(input & 0xFF);
+    } else {
+      for (int i = sizeof(TInput) - 1; i >= 0; --i) {
+        inlined[i] = static_cast<char>(input & 0xFF);
+        input >>= 8;
+      }
+    }
+    const auto stringView = StringView(inlined, sizeof(TInput));
+    flatResult->setNoCopy(row, stringView);
+  });
+
+  return result;
+}
+
 void CastExpr::apply(
     const SelectivityVector& rows,
     const VectorPtr& input,
@@ -616,54 +925,64 @@ void CastExpr::apply(
     const TypePtr& fromType,
     const TypePtr& toType,
     VectorPtr& result) {
-  LocalDecodedVector decoded(context, *input, rows);
-  auto* rawNulls = decoded->nulls();
+  LocalSelectivityVector remainingRows(context, rows);
+
+  context.deselectErrors(*remainingRows);
+
+  LocalDecodedVector decoded(context, *input, *remainingRows);
+  auto* rawNulls = decoded->nulls(remainingRows.get());
 
-  LocalSelectivityVector nonNullRows(*context.execCtx(), rows.end());
-  *nonNullRows = rows;
   if (rawNulls) {
-    nonNullRows->deselectNulls(rawNulls, rows.begin(), rows.end());
+    remainingRows->deselectNulls(
+        rawNulls, remainingRows->begin(), remainingRows->end());
   }
 
   VectorPtr localResult;
-  if (!nonNullRows->hasSelections()) {
+  if (!remainingRows->hasSelections()) {
     localResult =
         BaseVector::createNullConstant(toType, rows.end(), context.pool());
   } else if (decoded->isIdentityMapping()) {
     applyPeeled(
-        *nonNullRows, *decoded->base(), context, fromType, toType, localResult);
+        *remainingRows,
+        *decoded->base(),
+        context,
+        fromType,
+        toType,
+        localResult);
   } else {
-    ScopedContextSaver saver;
-    LocalSelectivityVector newRowsHolder(*context.execCtx());
-
-    LocalDecodedVector localDecoded(context);
-    std::vector<VectorPtr> peeledVectors;
-    auto peeledEncoding = PeeledEncoding::peel(
-        {input}, *nonNullRows, localDecoded, true, peeledVectors);
-    VELOX_CHECK_EQ(peeledVectors.size(), 1);
-    if (peeledVectors[0]->isLazy()) {
-      peeledVectors[0] =
-          peeledVectors[0]->as<LazyVector>()->loadedVectorShared();
-    }
-    auto newRows =
-        peeledEncoding->translateToInnerRows(*nonNullRows, newRowsHolder);
-    // Save context and set the peel.
-    context.saveAndReset(saver, *nonNullRows);
-    context.setPeeledEncoding(peeledEncoding);
-    applyPeeled(
-        *newRows, *peeledVectors[0], context, fromType, toType, localResult);
-
-    localResult = context.getPeeledEncoding()->wrap(
-        toType, context.pool(), localResult, *nonNullRows);
+    withContextSaver([&](ContextSaver& saver) {
+      LocalSelectivityVector newRowsHolder(*context.execCtx());
+
+      LocalDecodedVector localDecoded(context);
+      std::vector<VectorPtr> peeledVectors;
+      auto peeledEncoding = PeeledEncoding::peel(
+          {input}, *remainingRows, localDecoded, true, peeledVectors);
+      VELOX_CHECK_EQ(peeledVectors.size(), 1);
+      if (peeledVectors[0]->isLazy()) {
+        peeledVectors[0] =
+            peeledVectors[0]->as<LazyVector>()->loadedVectorShared();
+      }
+      auto newRows =
+          peeledEncoding->translateToInnerRows(*remainingRows, newRowsHolder);
+      // Save context and set the peel.
+      context.saveAndReset(saver, *remainingRows);
+      context.setPeeledEncoding(peeledEncoding);
+      applyPeeled(
+          *newRows, *peeledVectors[0], context, fromType, toType, localResult);
+
+      localResult = context.getPeeledEncoding()->wrap(
+          toType, context.pool(), localResult, *remainingRows);
+    });
   }
-  context.moveOrCopyResult(localResult, *nonNullRows, result);
+  context.moveOrCopyResult(localResult, *remainingRows, result);
   context.releaseVector(localResult);
 
-  // If there are nulls in input, add nulls to the result at the same rows.
+  // If there are nulls or rows that encountered errors in the input, add nulls
+  // to the result at the same rows.
   VELOX_CHECK_NOT_NULL(result);
-  if (rawNulls) {
+  if (rawNulls || context.errors()) {
     EvalCtx::addNulls(
-        rows, nonNullRows->asRange().bits(), context, toType, result);
+        rows, remainingRows->asRange().bits(), context, toType, result);
   }
 }
 
@@ -679,6 +998,11 @@ void CastExpr::evalSpecialForm(
   inTopLevel = true;
   if (nullOnFailure()) {
     ScopedVarSetter holder{context.mutableThrowOnError(), false};
+    ScopedVarSetter captureErrorDetails(
+        context.mutableCaptureErrorDetails(), false);
+
+    ScopedThreadSkipErrorDetails skipErrorDetails(true);
+
     apply(rows, input, context, fromType, toType, result);
   } else {
     apply(rows, input, context, fromType, toType, result);
@@ -709,6 +1033,23 @@ std::string CastExpr::toSql(std::vector<VectorPtr>* complexConstants) const {
   return out.str();
 }
 
+CastOperatorPtr CastExpr::getCastOperator(const TypePtr& type) {
+  const auto* key = type->name();
+
+  auto it = castOperators_.find(key);
+  if (it != castOperators_.end()) {
+    return it->second;
+  }
+
+  auto castOperator = getCustomTypeCastOperator(key);
+  if (castOperator == nullptr) {
+    return nullptr;
+  }
+
+  castOperators_.emplace(key, castOperator);
+  return castOperator;
+}
+
 TypePtr CastCallToSpecialForm::resolveType(
     const std::vector<TypePtr>& /* argTypes */) {
   VELOX_FAIL("CAST expressions do not support type resolution.");
@@ -718,14 +1059,26 @@ ExprPtr CastCallToSpecialForm::constructSpecialForm(
     const TypePtr& type,
     std::vector<ExprPtr>&& compiledChildren,
     bool trackCpuUsage,
-    const core::QueryConfig& /*config*/) {
+    const core::QueryConfig& config) {
   VELOX_CHECK_EQ(
       compiledChildren.size(),
       1,
-      "CAST statements expect exactly 1 argument, received {}",
+      "CAST statements expect exactly 1 argument, received {}.",
       compiledChildren.size());
+  const auto inputKind = compiledChildren[0]->type()->kind();
+  if (type->kind() == TypeKind::VARBINARY &&
+      (inputKind == TypeKind::TINYINT || inputKind == TypeKind::SMALLINT ||
+       inputKind == TypeKind::INTEGER || inputKind == TypeKind::BIGINT)) {
+    VELOX_UNSUPPORTED(
+        "Cannot cast {} to VARBINARY.",
+        compiledChildren[0]->type()->toString());
+  }
   return std::make_shared<CastExpr>(
-      type, std::move(compiledChildren[0]), trackCpuUsage, false);
+      type,
+      std::move(compiledChildren[0]),
+      trackCpuUsage,
+      false,
+      std::make_shared<PrestoCastHooks>(config));
 }
 
 TypePtr TryCastCallToSpecialForm::resolveType(
@@ -737,13 +1090,17 @@ ExprPtr TryCastCallToSpecialForm::constructSpecialForm(
     const TypePtr& type,
     std::vector<ExprPtr>&& compiledChildren,
     bool trackCpuUsage,
-    const core::QueryConfig& /*config*/) {
+    const core::QueryConfig& config) {
   VELOX_CHECK_EQ(
       compiledChildren.size(),
       1,
-      "TRY CAST statements expect exactly 1 argument, received {}",
+      "TRY CAST statements expect exactly 1 argument, received {}.",
       compiledChildren.size());
   return std::make_shared<CastExpr>(
-      type, std::move(compiledChildren[0]), trackCpuUsage, true);
+      type,
+      std::move(compiledChildren[0]),
+      trackCpuUsage,
+      true,
+      std::make_shared<PrestoCastHooks>(config));
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/CastExpr.h b/velox/expression/CastExpr.h
index 986a1c09534a2..01bcc053a56e3 100644
--- a/velox/expression/CastExpr.h
+++ b/velox/expression/CastExpr.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/expression/CastHooks.h"
 #include "velox/expression/FunctionCallToSpecialForm.h"
 #include "velox/expression/SpecialForm.h"
 
@@ -51,6 +52,16 @@ class CastOperator {
       const TypePtr& resultType,
       VectorPtr& result) const = 0;
 
+  virtual void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result,
+      const std::shared_ptr<CastHooks>& /* hooks */) const {
+    castTo(input, context, rows, resultType, result);
+  }
+
   /// Casts a vector of the custom type to another type. This function should
   /// not throw when processing input rows, but report errors via
   /// context.setError().
@@ -72,27 +83,20 @@ class CastExpr : public SpecialForm {
   /// @param type The target type of the cast expression
   /// @param expr The expression to cast
   /// @param trackCpuUsage Whether to track CPU usage
-  CastExpr(TypePtr type, ExprPtr&& expr, bool trackCpuUsage, bool nullOnFailure)
+  CastExpr(
+      TypePtr type,
+      ExprPtr&& expr,
+      bool trackCpuUsage,
+      bool nullOnFailure,
+      std::shared_ptr<CastHooks> hooks)
       : SpecialForm(
             type,
             std::vector<ExprPtr>({expr}),
             nullOnFailure ? kTryCast.data() : kCast.data(),
             false /* supportsFlatNoNullsFastPath */,
             trackCpuUsage),
-        nullOnFailure_(nullOnFailure) {
-    auto fromType = inputs_[0]->type();
-    castFromOperator_ = getCustomTypeCastOperator(fromType->toString());
-    if (castFromOperator_ && !castFromOperator_->isSupportedToType(type)) {
-      VELOX_FAIL(
-          "Cannot cast {} to {}.", fromType->toString(), type->toString());
-    }
-
-    castToOperator_ = getCustomTypeCastOperator(type->toString());
-    if (castToOperator_ && !castToOperator_->isSupportedFromType(fromType)) {
-      VELOX_FAIL(
-          "Cannot cast {} to {}.", fromType->toString(), type->toString());
-    }
-  }
+        nullOnFailure_(nullOnFailure),
+        hooks_(std::move(hooks)) {}
 
   void evalSpecialForm(
       const SelectivityVector& rows,
@@ -172,10 +176,11 @@ class CastExpr : public SpecialForm {
   /// The per-row level Kernel
   /// @tparam ToKind The cast target type
   /// @tparam FromKind The expression type
+  /// @tparam TPolicy The policy used by the cast
   /// @param row The index of the current row
   /// @param input The input vector (of type FromKind)
   /// @param result The output vector (of type ToKind)
-  template <TypeKind ToKind, TypeKind FromKind, bool Truncate>
+  template <TypeKind ToKind, TypeKind FromKind, typename TPolicy>
   void applyCastKernel(
       vector_size_t row,
       EvalCtx& context,
@@ -194,6 +199,12 @@ class CastExpr : public SpecialForm {
       exec::EvalCtx& context,
       const TypePtr& fromType);
 
+  VectorPtr castFromIntervalDayTime(
+      const SelectivityVector& rows,
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const TypePtr& toType);
+
   template <typename TInput, typename TOutput>
   void applyDecimalCastKernel(
       const SelectivityVector& rows,
@@ -211,6 +222,28 @@ class CastExpr : public SpecialForm {
       const TypePtr& toType,
       VectorPtr& castResult);
 
+  template <typename TInput>
+  VectorPtr applyIntToBinaryCast(
+      const SelectivityVector& rows,
+      exec::EvalCtx& context,
+      const BaseVector& input);
+
+  template <typename TInput, typename TOutput>
+  void applyFloatingPointToDecimalCastKernel(
+      const SelectivityVector& rows,
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const TypePtr& toType,
+      VectorPtr& castResult);
+
+  template <typename T>
+  void applyVarcharToDecimalCastKernel(
+      const SelectivityVector& rows,
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const TypePtr& toType,
+      VectorPtr& castResult);
+
   template <typename FromNativeType, TypeKind ToKind>
   VectorPtr applyDecimalToFloatCast(
       const SelectivityVector& rows,
@@ -264,13 +297,11 @@ class CastExpr : public SpecialForm {
       const BaseVector& input,
       VectorPtr& result);
 
-  template <bool adjustForTimeZone>
-  void castTimestampToDate(
+  VectorPtr applyTimestampToVarcharCast(
+      const TypePtr& toType,
       const SelectivityVector& rows,
-      const BaseVector& input,
       exec::EvalCtx& context,
-      VectorPtr& result,
-      const date::time_zone* timeZone = nullptr);
+      const BaseVector& input);
 
   bool nullOnFailure() const {
     return nullOnFailure_;
@@ -280,15 +311,13 @@ class CastExpr : public SpecialForm {
     return nullOnFailure() && inTopLevel;
   }
 
-  // Custom cast operator for the from-type. Nullptr if the type is native or
-  // doesn't support cast-from.
-  CastOperatorPtr castFromOperator_;
+  CastOperatorPtr getCastOperator(const TypePtr& type);
 
-  // Custom cast operator for the to-type. Nullptr if the type is native or
-  // doesn't support cast-to.
-  CastOperatorPtr castToOperator_;
+  // Custom cast operators for to and from top-level as well as nested types.
+  folly::F14FastMap<std::string, CastOperatorPtr> castOperators_;
 
   bool nullOnFailure_;
+  std::shared_ptr<CastHooks> hooks_;
 
   bool inTopLevel = false;
 };
diff --git a/velox/expression/CastHooks.cpp b/velox/expression/CastHooks.cpp
new file mode 100644
index 0000000000000..b600ba4c71a93
--- /dev/null
+++ b/velox/expression/CastHooks.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "CastHooks.h"
+
+namespace facebook::velox::exec {
+
+fmt::underlying_t<PolicyType> format_as(PolicyType f) {
+  return fmt::underlying(f);
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/CastHooks.h b/velox/expression/CastHooks.h
new file mode 100644
index 0000000000000..dfd88ce55f475
--- /dev/null
+++ b/velox/expression/CastHooks.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/StringWriter.h"
+#include "velox/type/Timestamp.h"
+
+namespace facebook::velox::exec {
+
+enum PolicyType { LegacyCastPolicy = 1, PrestoCastPolicy, SparkCastPolicy };
+
+fmt::underlying_t<PolicyType> format_as(PolicyType f);
+
+/// This class provides cast hooks to allow different behaviors of CastExpr and
+/// SparkCastExpr. The main purpose is to create customized cast implementation
+/// by taking full usage of existing cast expression.
+class CastHooks {
+ public:
+  virtual ~CastHooks() = default;
+
+  virtual Expected<Timestamp> castStringToTimestamp(
+      const StringView& view) const = 0;
+
+  virtual Expected<int32_t> castStringToDate(
+      const StringView& dateString) const = 0;
+
+  // 'data' is guaranteed to be non-empty and has been processed by
+  // removeWhiteSpaces.
+  virtual Expected<float> castStringToReal(const StringView& data) const = 0;
+
+  // 'data' is guaranteed to be non-empty and has been processed by
+  // removeWhiteSpaces.
+  virtual Expected<double> castStringToDouble(const StringView& data) const = 0;
+
+  // Trims all leading and trailing UTF8 whitespaces.
+  virtual StringView removeWhiteSpaces(const StringView& view) const = 0;
+
+  // Returns the options to cast from timestamp to string.
+  virtual const TimestampToStringOptions& timestampToStringOptions() const = 0;
+
+  // Returns whether to cast to int by truncate.
+  virtual bool truncate() const = 0;
+
+  virtual PolicyType getPolicy() const = 0;
+};
+} // namespace facebook::velox::exec
diff --git a/velox/expression/CastTypeChecker.h b/velox/expression/CastTypeChecker.h
new file mode 100644
index 0000000000000..9186eb8c57a6a
--- /dev/null
+++ b/velox/expression/CastTypeChecker.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/type/CppToType.h"
+#include "velox/type/SimpleFunctionApi.h"
+
+namespace facebook::velox {
+
+// Recursively check that T and vectorType associate to the same TypeKind.
+template <typename T>
+struct CastTypeChecker {
+  static_assert(
+      CppToType<T>::maxSubTypes == 0,
+      "Complex types should be checked separately.");
+
+  static bool check(const TypePtr& vectorType) {
+    return CppToType<T>::typeKind == vectorType->kind();
+  }
+};
+
+template <>
+struct CastTypeChecker<DynamicRow> {
+  static bool check(const TypePtr& vectorType) {
+    return TypeKind::ROW == vectorType->kind();
+  }
+};
+
+template <typename T>
+struct CastTypeChecker<Generic<T>> {
+  static bool check(const TypePtr&) {
+    return true;
+  }
+};
+
+template <typename T>
+struct CastTypeChecker<Array<T>> {
+  static bool check(const TypePtr& vectorType) {
+    return TypeKind::ARRAY == vectorType->kind() &&
+        CastTypeChecker<T>::check(vectorType->childAt(0));
+  }
+};
+
+template <typename K, typename V>
+struct CastTypeChecker<Map<K, V>> {
+  static bool check(const TypePtr& vectorType) {
+    return TypeKind::MAP == vectorType->kind() &&
+        CastTypeChecker<K>::check(vectorType->childAt(0)) &&
+        CastTypeChecker<V>::check(vectorType->childAt(1));
+  }
+};
+
+template <typename... T>
+struct CastTypeChecker<Row<T...>> {
+  static bool check(const TypePtr& vectorType) {
+    int index = 0;
+    return TypeKind::ROW == vectorType->kind() &&
+        (CastTypeChecker<T>::check(vectorType->childAt(index++)) && ... &&
+         true);
+  }
+};
+
+} // namespace facebook::velox
diff --git a/velox/expression/CoalesceExpr.cpp b/velox/expression/CoalesceExpr.cpp
index 0fd67f4a1178b..cc7e7f18164cc 100644
--- a/velox/expression/CoalesceExpr.cpp
+++ b/velox/expression/CoalesceExpr.cpp
@@ -71,7 +71,7 @@ void CoalesceExpr::evalSpecialForm(
     }
 
     decodedVector.get()->decode(*result, *activeRows);
-    const uint64_t* rawNulls = decodedVector->nulls();
+    const uint64_t* rawNulls = decodedVector->nulls(activeRows);
     if (!rawNulls) {
       // No nulls left.
       return;
diff --git a/velox/expression/ComplexViewTypes.h b/velox/expression/ComplexViewTypes.h
index 8b0799e14a518..74709c5780420 100644
--- a/velox/expression/ComplexViewTypes.h
+++ b/velox/expression/ComplexViewTypes.h
@@ -23,6 +23,7 @@
 #include "velox/common/base/CompareFlags.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/CoreTypeSystem.h"
+#include "velox/expression/CastTypeChecker.h"
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/DecodedVector.h"
@@ -238,9 +239,7 @@ class SkipNullsIterator {
   using reference = value_type;
 
  public:
-  SkipNullsIterator<BaseIterator>(
-      const BaseIterator& begin,
-      const BaseIterator& end)
+  SkipNullsIterator(const BaseIterator& begin, const BaseIterator& end)
       : iter_(begin), end_(end) {}
 
   // Given an element, return an iterator to the first not-null element starting
@@ -673,14 +672,22 @@ class ArrayView {
         "efficient to use the standard iterator interface.");
   }
 
-  const BaseVector* elementsVector() const {
+  const BaseVector* elementsVectorBase() const {
     return reader_->baseVector();
   }
 
+  bool isFlatElements() const {
+    return reader_->decoded_.isIdentityMapping();
+  }
+
   vector_size_t offset() const {
     return offset_;
   }
 
+  TypeKind elementKind() const {
+    return elementsVectorBase()->typeKind();
+  }
+
  private:
   const reader_t* reader_;
   vector_size_t offset_;
@@ -1004,8 +1011,8 @@ struct HasGeneric {
   }
 };
 
-template <typename T>
-struct HasGeneric<Generic<T>> {
+template <typename T, bool comparable, bool orderable>
+struct HasGeneric<Generic<T, comparable, orderable>> {
   static constexpr bool value() {
     return true;
   }
@@ -1109,6 +1116,10 @@ class GenericView {
     return decoded_.base()->type();
   }
 
+  std::string toString() const {
+    return decoded_.toString(index_);
+  }
+
   // If conversion is invalid, behavior is undefined. However, debug time
   // checks will throw an exception.
   template <typename ToType>
@@ -1119,11 +1130,18 @@ class GenericView {
             "castTo type is not compatible with type of vector, vector type is {}",
             type()->toString()));
 
-    // TODO: We can distinguish if this is a null-free or not null-free
-    // generic. And based on that determine if we want to call operator[] or
-    // readNullFree. For now we always return nullable.
-    return ensureReader<ToType>()->operator[](
-        index_); // We pass the non-decoded index.
+    // If its a primitive type, then the casted reader always exists at
+    // castReaders_[0], and is set in Vector readers.
+    if constexpr (SimpleTypeTrait<ToType>::isPrimitiveType) {
+      return reinterpret_cast<VectorReader<ToType>*>(castReaders_[0].get())
+          ->operator[](index_);
+    } else {
+      // TODO: We can distinguish if this is a null-free or not null-free
+      // generic. And based on that determine if we want to call operator[] or
+      // readNullFree. For now we always return nullable.
+      return ensureReader<ToType>()->operator[](
+          index_); // We pass the non-decoded index.
+    }
   }
 
   template <typename ToType>
@@ -1136,7 +1154,6 @@ class GenericView {
         index_); // We pass the non-decoded index.
   }
 
- private:
   template <typename B>
   VectorReader<B>* ensureReader() const {
     static_assert(
@@ -1147,7 +1164,6 @@ class GenericView {
     // the user is always casting to the same type.
     // Types are divided into three sets, for 1, and 2 we do not do the check,
     // since no two types can ever refer to the same vector.
-
     if constexpr (!HasGeneric<B>::value()) {
       // Two types with no generic can never represent same vector.
       return ensureReaderImpl<B, 0>();
@@ -1174,6 +1190,7 @@ class GenericView {
     }
   }
 
+ private:
   template <typename B, size_t I>
   VectorReader<B>* ensureReaderImpl() const {
     auto* reader = static_cast<VectorReader<B>*>(castReaders_[I].get());
diff --git a/velox/expression/ComplexWriterTypes.h b/velox/expression/ComplexWriterTypes.h
index ae07941e155a2..1874d8c014b36 100644
--- a/velox/expression/ComplexWriterTypes.h
+++ b/velox/expression/ComplexWriterTypes.h
@@ -17,6 +17,7 @@
 #pragma once
 #include <folly/Likely.h>
 #include <cinttypes>
+#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <optional>
@@ -29,6 +30,7 @@
 #include "velox/core/CoreTypeSystem.h"
 #include "velox/core/Metaprogramming.h"
 #include "velox/expression/ComplexViewTypes.h"
+#include "velox/expression/KindToSimpleType.h"
 #include "velox/expression/UdfTypeResolver.h"
 #include "velox/type/Type.h"
 #include "velox/vector/TypeAliases.h"
@@ -48,6 +50,8 @@ class VectorWriterBase {
   virtual void commit(bool isSet) = 0;
   virtual void ensureSize(size_t size) = 0;
   virtual void finish() {}
+  // Implementations that write variable length data or complex types should
+  // override this to reset their state and that of their children.
   virtual void finalizeNull() {}
   virtual ~VectorWriterBase() {}
   vector_size_t offset_ = 0;
@@ -90,9 +94,8 @@ struct PrimitiveWriter {
 };
 
 template <typename V>
-bool constexpr provide_std_interface =
-    SimpleTypeTrait<V>::isPrimitiveType && !std::is_same_v<Varchar, V> &&
-    !std::is_same_v<Varbinary, V> && !std::is_same_v<Any, V>;
+bool constexpr provide_std_interface = SimpleTypeTrait<V>::isPrimitiveType &&
+    !std::is_same_v<Varchar, V> && !std::is_same_v<Varbinary, V>;
 
 // bool is an exception, it requires commit but also provides std::interface.
 template <typename V>
@@ -106,6 +109,9 @@ class ArrayWriter {
   using child_writer_t = VectorWriter<V, void>;
   using element_t = typename child_writer_t::exec_out_t;
 
+  static constexpr bool hasStringValue =
+      std::is_same_v<V, Varchar> || std::is_same_v<V, Varbinary>;
+
  public:
   // Note: size is with respect to the current size of this array being written.
   void reserve(vector_size_t size) {
@@ -124,7 +130,7 @@ class ArrayWriter {
 
     if constexpr (!requires_commit<V>) {
       VELOX_DCHECK(provide_std_interface<V>);
-      elementsVector_->setNull(index, false);
+      elementsVector()->setNull(index, false);
       return childWriter_->data_[index];
     } else {
       needCommit_ = true;
@@ -133,11 +139,47 @@ class ArrayWriter {
     }
   }
 
+  void push_back(const OptionalAccessor<V>& item) {
+    if (!item.has_value()) {
+      add_null();
+    } else {
+      if constexpr (provide_std_interface<V>) {
+        push_back(item.value());
+      } else {
+        add_item().copy_from(item.value());
+      }
+    }
+  }
+
+  void push_back(const std::optional<GenericView>& inputView) {
+    if (inputView.has_value()) {
+      push_back(*inputView);
+    } else {
+      add_null();
+    }
+  }
+
+  void push_back(const GenericView& item) {
+    add_item().copy_from(item);
+  }
+
+  void push_back(const StringView& item) {
+    add_item().copy_from(item);
+  }
+
+  void push_back(const std::optional<StringView>& item) {
+    if (item.has_value()) {
+      push_back(*item);
+    } else {
+      add_null();
+    }
+  }
+
   // Add a new null item to the array.
   void add_null() {
     resize(length_ + 1);
     auto index = valuesOffset_ + length_ - 1;
-    elementsVector_->setNull(index, true);
+    elementsVector()->setNull(index, true);
     // Note: no need to commit the null item.
   }
 
@@ -196,13 +238,13 @@ class ArrayWriter {
   typename std::enable_if_t<provide_std_interface<T>, PrimitiveWriter<T>>
   operator[](vector_size_t index) {
     VELOX_DCHECK_LT(index, length_, "out of bound access");
-    return PrimitiveWriter<V>{elementsVector_, valuesOffset_ + index};
+    return PrimitiveWriter<V>{elementsVector(), valuesOffset_ + index};
   }
 
   template <typename T = V>
   typename std::enable_if_t<provide_std_interface<T>, PrimitiveWriter<T>>
   back() {
-    return PrimitiveWriter<V>{elementsVector_, valuesOffset_ + length_ - 1};
+    return PrimitiveWriter<V>{elementsVector(), valuesOffset_ + length_ - 1};
   }
 
   // Any vector type with std-like optional-free interface.
@@ -214,14 +256,33 @@ class ArrayWriter {
 
   // Don't mutate elementVecotr_ through this API unless you know what you're
   // doing.
+  // This function returns the base of elements vector and the elements vector
+  // itself.
   typename child_writer_t::vector_t* elementsVector() {
-    return elementsVector_;
+    return decodedElementsVectorBase_;
   }
 
   vector_size_t valuesOffset() const {
     return valuesOffset_;
   }
 
+  // Copy from nullable ArrayView.
+  void add_items(
+      const typename VectorExec::template resolver<Array<V>>::in_type&
+          arrayView) {
+    if constexpr (isGenericType<V>::value) {
+      addItemsGeneric(arrayView);
+    } else if constexpr (hasStringValue) {
+      addItemsStringFastPath<SimpleTypeTrait<V>::typeKind>(arrayView);
+    } else if constexpr (std::is_same_v<V, bool>) {
+      addItemsBoolFastPath(arrayView);
+    } else if constexpr (provide_std_interface<V>) {
+      addItemsPrimitiveFastPath<V>(arrayView);
+    } else {
+      addItemsGeneralSlowPath(arrayView);
+    }
+  }
+
   // Any vector type with std-like optional-free interface.
   template <typename VectorType>
   void add_items(const VectorType& data) {
@@ -247,38 +308,219 @@ class ArrayWriter {
     }
   }
 
-  // Copy from nullable ArrayView.
-  void add_items(
-      const typename VectorExec::template resolver<Array<V>>::in_type&
-          arrayView) {
-    if constexpr (provide_std_interface<V>) {
-      // TODO: accelerate this with memcpy.
-      auto start = length_;
-      resize(length_ + arrayView.size());
-      for (auto i = 0; i < arrayView.size(); i++) {
-        if (arrayView[i].has_value()) {
-          this->operator[](i + start) = arrayView[i].value();
+ private:
+  template <TypeKind kind, typename VectorType>
+  void addItemsGenericPrimitive(const VectorType& data) {
+    if constexpr (kind == TypeKind::BOOLEAN) {
+      addItemsBoolFastPath(data);
+    } else if constexpr (
+        kind == TypeKind::VARCHAR || kind == TypeKind::VARBINARY) {
+      addItemsStringFastPath<kind>(data);
+    } else if constexpr (TypeTraits<kind>::isPrimitiveType) {
+      addItemsPrimitiveFastPath<typename KindToSimpleType<kind>::type>(data);
+    } else {
+      VELOX_UNREACHABLE("non primitives handled in addItemsGeneric");
+    }
+  }
+
+  template <typename ElementSimpleType, typename Input>
+  void addItemsPrimitiveFastPath(const Input& sourceArray) {
+    VELOX_DCHECK_NE(sourceArray.elementKind(), TypeKind::BOOLEAN);
+    VELOX_DCHECK_NE(sourceArray.elementKind(), TypeKind::VARBINARY);
+    VELOX_DCHECK_NE(sourceArray.elementKind(), TypeKind::VARCHAR);
+
+    auto start = length_ + valuesOffset_;
+    resize(length_ + sourceArray.size());
+    auto* flatOutput =
+        elementsVector()
+            ->template asUnchecked<FlatVector<
+                typename VectorExec::resolver<ElementSimpleType>::in_type>>();
+    auto* rawValues = flatOutput->mutableRawValues();
+    flatOutput->clearNulls(start, start + sourceArray.size());
+
+    // Flat input fast path.
+    if (sourceArray.isFlatElements()) {
+      auto* flatInput =
+          sourceArray.elementsVectorBase()
+              ->template asUnchecked<FlatVector<
+                  typename VectorExec::resolver<ElementSimpleType>::in_type>>();
+      auto* inputData = flatInput->rawValues();
+      auto inputOffset = sourceArray.offset();
+      if (!sourceArray.mayHaveNulls()) {
+        std::memcpy(
+            &rawValues[start],
+            &inputData[inputOffset],
+            sourceArray.size() *
+                sizeof(
+                    typename VectorExec::resolver<ElementSimpleType>::in_type));
+
+      } else {
+        for (int i = 0; i < sourceArray.size(); i++) {
+          if (!flatInput->isNullAt(i + inputOffset)) {
+            rawValues[i + start] = inputData[i + inputOffset];
+          } else {
+            flatOutput->setNull(i + start, true);
+          }
+        }
+      }
+      return;
+    }
+
+    // All input encodings, no nulls.
+    int i = 0;
+    if (!sourceArray.mayHaveNulls()) {
+      for (auto item : sourceArray) {
+        if constexpr (isGenericType<V>::value) {
+          rawValues[i + start] = item->template castTo<ElementSimpleType>();
         } else {
-          this->operator[](i + start) = std::nullopt;
+          rawValues[i + start] = item.value();
         }
+        i++;
       }
-    } else {
-      for (const auto& item : arrayView) {
-        if (item.has_value()) {
-          auto& writer = add_item();
-          writer.copy_from(item.value());
+      return;
+    }
+
+    // All input encodings, with nulls.
+    for (auto item : sourceArray) {
+      if (item.has_value()) {
+        if constexpr (isGenericType<V>::value) {
+          rawValues[i + start] = item->template castTo<ElementSimpleType>();
         } else {
-          add_null();
+          rawValues[i + start] = item.value();
         }
+      } else {
+        flatOutput->setNull(i + start, true);
       }
+      i++;
+    }
+  }
+
+  template <TypeKind kind, typename Input>
+  void addItemsStringFastPath(const Input& sourceArray) {
+    auto* vector = sourceArray.elementsVectorBase();
+    auto* flatOutput =
+        this->elementsVector()->template asUnchecked<FlatVector<StringView>>();
+    bool found = false;
+    // Caching at this layer is much faster.
+    for (auto* item : vectorsWithAcquiredBuffers_) {
+      if (item == vector) {
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
+      vectorsWithAcquiredBuffers_.push_back(vector);
+      flatOutput->acquireSharedStringBuffers(vector);
+    }
+    auto start = length_ + valuesOffset_;
+    resize(length_ + sourceArray.size());
+    flatOutput->clearNulls(start, start + sourceArray.size());
+
+    auto* outputData = flatOutput->mutableRawValues();
+
+    // Flat fast path.
+    if (sourceArray.isFlatElements()) {
+      auto* flatInput = sourceArray.elementsVectorBase()
+                            ->template asUnchecked<FlatVector<StringView>>();
+      auto* inputData = flatInput->rawValues();
+      auto inputOffset = sourceArray.offset();
+      if (!sourceArray.mayHaveNulls()) {
+        std::memcpy(
+            &outputData[start],
+            &inputData[inputOffset],
+            sourceArray.size() * sizeof(StringView));
+
+      } else {
+        for (int i = 0; i < sourceArray.size(); i++) {
+          if (!flatInput->isNullAt(i + inputOffset)) {
+            outputData[i + start] = inputData[i + inputOffset];
+          } else {
+            flatOutput->setNull(i + start, true);
+          }
+        }
+      }
+      return;
+    }
+
+    // Null free fast path with all input encodings.
+    if (!sourceArray.mayHaveNulls()) {
+      for (const auto& element : sourceArray) {
+        if constexpr (isGenericType<V>::value) {
+          outputData[start] =
+              element->template castTo<typename KindToSimpleType<kind>::type>();
+        } else {
+          outputData[start] = element.value();
+        }
+        start++;
+      }
+      return;
+    }
+
+    for (const auto& element : sourceArray) {
+      if (element.has_value()) {
+        if constexpr (isGenericType<V>::value) {
+          outputData[start] =
+              element->template castTo<typename KindToSimpleType<kind>::type>();
+        } else {
+          outputData[start] = element.value();
+        }
+      } else {
+        flatOutput->setNull(start, true);
+      }
+      start++;
+    }
+  }
+
+  template <typename Input>
+  void addItemsBoolFastPath(const Input& sourceArray) {
+    auto* flatOutput =
+        this->elementsVector()->template asUnchecked<FlatVector<bool>>();
+
+    auto start = length_ + valuesOffset_;
+    resize(length_ + sourceArray.size());
+    for (const auto& element : sourceArray) {
+      if (element.has_value()) {
+        if constexpr (isGenericType<V>::value) {
+          flatOutput->set(start, element->template castTo<bool>());
+        } else {
+          flatOutput->set(start, element.value());
+        }
+      } else {
+        flatOutput->setNull(start, true);
+      }
+      start++;
+    }
+  }
+
+  template <typename Input>
+  void addItemsGeneralSlowPath(const Input& sourceArray) {
+    reserve(size() + sourceArray.size());
+    for (const auto& item : sourceArray) {
+      if (item.has_value()) {
+        auto& writer = add_item();
+        writer.copy_from(item.value());
+      } else {
+        add_null();
+      }
+    }
+  }
+
+  template <typename VectorType>
+  void addItemsGeneric(const VectorType& arrayView) {
+    if (elementIsPrimitive) {
+      auto kind = arrayView.elementKind();
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+          addItemsGenericPrimitive, kind, arrayView);
+    } else {
+      addItemsGeneralSlowPath(arrayView);
     }
   }
 
- private:
   // Make sure user do not use those.
-  ArrayWriter<V>() = default;
-  ArrayWriter<V>(const ArrayWriter<V>&) = default;
-  ArrayWriter<V>& operator=(const ArrayWriter<V>&) = default;
+  ArrayWriter() = default;
+  ArrayWriter(const ArrayWriter<V>&) = default;
+  ArrayWriter& operator=(const ArrayWriter<V>&) = default;
 
   void commitMostRecentChildItem() {
     if constexpr (requires_commit<V>) {
@@ -291,13 +533,15 @@ class ArrayWriter {
 
   void initialize(VectorWriter<Array<V>, void>* writer) {
     childWriter_ = &writer->childWriter_;
-    elementsVector_ = &childWriter_->vector();
-    valuesOffset_ = elementsVector_->size();
+    decodedElementsVectorBase_ = &childWriter_->vector();
+    valuesOffset_ = elementsVector()->size();
     childWriter_->ensureSize(1);
-    elementsVectorCapacity_ = elementsVector_->size();
+    elementsVectorCapacity_ = elementsVector()->size();
+    elementIsPrimitive = elementsVector()->type()->isPrimitiveType();
   }
 
-  typename child_writer_t::vector_t* elementsVector_ = nullptr;
+  // The base of the decoded elements vectors.
+  typename child_writer_t::vector_t* decodedElementsVectorBase_ = nullptr;
 
   // Pointer to child vector writer.
   child_writer_t* childWriter_ = nullptr;
@@ -315,6 +559,13 @@ class ArrayWriter {
   // Tracks the capacity of elements vector.
   vector_size_t elementsVectorCapacity_ = 0;
 
+  typename std::conditional<
+      hasStringValue || isGenericType<V>::value,
+      std::vector<const BaseVector*>,
+      std::byte>::type vectorsWithAcquiredBuffers_;
+
+  bool elementIsPrimitive;
+
   template <typename A, typename B>
   friend struct VectorWriter;
 
@@ -466,11 +717,11 @@ class MapWriter {
 
  private:
   // Make sure user do not use those.
-  MapWriter<K, V>() = default;
+  MapWriter() = default;
 
-  MapWriter<K, V>(const MapWriter<K, V>&) = default;
+  MapWriter(const MapWriter<K, V>&) = default;
 
-  MapWriter<K, V>& operator=(const MapWriter<K, V>&) = default;
+  MapWriter& operator=(const MapWriter<K, V>&) = default;
 
   vector_size_t indexOfLast() {
     return innerOffset_ + length_ - 1;
@@ -516,7 +767,7 @@ class MapWriter {
     keysVector_ = &keysWriter_->vector();
     valuesVector_ = &valuesWriter_->vector();
 
-    innerOffset_ = std::max(keysVector_->size(), valuesVector_->size());
+    innerOffset_ = std::min(keysVector_->size(), valuesVector_->size());
 
     // Keys can never be null.
     keysVector_->resetNulls();
@@ -524,10 +775,7 @@ class MapWriter {
     keysWriter_->ensureSize(1);
     valuesWriter_->ensureSize(1);
 
-    VELOX_DCHECK(
-        keysVector_->size() == valuesVector_->size(),
-        "expect map keys and value vector sized to be synchronized");
-    capacity_ = keysVector_->size();
+    capacity_ = std::min(keysVector_->size(), valuesVector_->size());
   }
 
   key_element_t& lastKeyWriter() {
@@ -732,9 +980,7 @@ class RowWriter {
     (
         [&]() {
           using current_t = std::tuple_element_t<Is, children_types>;
-          if constexpr (
-              !provide_std_interface<current_t> &&
-              !isOpaqueType<current_t>::value) {
+          if constexpr (!provide_std_interface<current_t>) {
             if (UNLIKELY(std::get<Is>(needCommit_))) {
               std::get<Is>(childrenWriters_).finalizeNull();
               std::get<Is>(needCommit_) = false;
@@ -802,6 +1048,10 @@ class GenericWriter {
 
   template <typename ToType>
   typename VectorWriter<ToType, void>::exec_out_t& castTo() {
+    static_assert(
+        !isGenericType<ToType>::value,
+        "Cast to generic is useless and recursive");
+
     VELOX_USER_DCHECK(
         CastTypeChecker<ToType>::check(type()),
         "castTo type is not compatible with type of vector, vector type is {}, casted to type is {}",
@@ -810,7 +1060,32 @@ class GenericWriter {
             ? "DynamicRow"
             : CppToType<ToType>::create()->toString());
 
-    return castToImpl<ToType>();
+    if constexpr (SimpleTypeTrait<ToType>::isPrimitiveType) {
+      // This is an optimization for when the type of the vector is a
+      // primitive type, in that case there is only one possible option for
+      // ToType, we make sure during the construction of the VectorWriter
+      // that castWriter_ and castType_ are properly initialized.
+
+      // Note that unlike tryCastTo, castTo assumes that the user is casting
+      // to the correct type. And since there is only valid type in the case
+      // of primitive this is safe.
+
+      // We make sure that the writer is initialized in the initialize call
+      // in the vector writer.
+
+      auto& writer =
+          *reinterpret_cast<VectorWriter<ToType, void>*>(castWriter_.get());
+
+      if constexpr (
+          std::is_fundamental_v<ToType> && !std::is_same_v<ToType, bool>) {
+        return writer.data_[index_];
+      } else {
+        writer.setOffset(index_);
+        return writer.current();
+      }
+    } else {
+      return castToImpl<ToType>();
+    }
   }
 
   template <typename ToType>
@@ -855,8 +1130,9 @@ class GenericWriter {
   VectorWriter<B, void>* retrieveCastedWriter() {
     DCHECK(castType_);
     DCHECK(castWriter_);
+    // TODO: optimize this check using disjoint sets of types (see
+    // GenericView).
 
-    // TODO: optimize this check using disjoint sets of types (see GenericView).
     return dynamic_cast<VectorWriter<B, void>*>(castWriter_.get());
   }
 
@@ -883,8 +1159,10 @@ class GenericWriter {
   }
 
   BaseVector* vector_;
+
   std::shared_ptr<VectorWriterBase>& castWriter_;
   TypePtr& castType_;
+
   vector_size_t& index_;
 
   template <typename A, typename B>
diff --git a/velox/expression/ConjunctExpr.cpp b/velox/expression/ConjunctExpr.cpp
index 6b17f8c0dee64..90d49c5800f71 100644
--- a/velox/expression/ConjunctExpr.cpp
+++ b/velox/expression/ConjunctExpr.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/expression/ConjunctExpr.h"
 #include "velox/expression/BooleanMix.h"
+#include "velox/expression/FieldReference.h"
 #include "velox/expression/ScopedVarSetter.h"
 
 namespace facebook::velox::exec {
@@ -25,14 +26,16 @@ uint64_t* rowsWithError(
     const SelectivityVector& rows,
     const SelectivityVector& activeRows,
     EvalCtx& context,
-    ErrorVectorPtr& previousErrors,
+    EvalErrorsPtr& previousErrors,
     LocalSelectivityVector& errorRowsHolder) {
-  auto errors = context.errors();
-  if (!errors) {
+  const auto* errorsPtr = context.errorsPtr();
+  if (!errorsPtr || !*errorsPtr) {
     // No new errors. Put the old errors back.
     context.swapErrors(previousErrors);
     return nullptr;
   }
+
+  const auto& errors = *errorsPtr;
   uint64_t* errorMask = nullptr;
   SelectivityVector* errorRows = errorRowsHolder.get();
   if (!errorRows) {
@@ -45,18 +48,14 @@ uint64_t* rowsWithError(
   bits::andBits(
       errorMask,
       activeRows.asRange().bits(),
-      errors->rawNulls(),
+      errors->errorFlags(),
       rows.begin(),
       std::min(errors->size(), rows.end()));
   if (previousErrors) {
     // Add the new errors to the previous ones and free the new errors.
     bits::forEachSetBit(
-        errors->rawNulls(), rows.begin(), errors->size(), [&](int32_t row) {
-          context.addError(
-              row,
-              *std::static_pointer_cast<std::exception_ptr>(
-                  errors->valueAt(row)),
-              previousErrors);
+        errors->errorFlags(), rows.begin(), errors->size(), [&](int32_t row) {
+          context.addError(row, errors, previousErrors);
         });
     context.swapErrors(previousErrors);
     previousErrors = nullptr;
@@ -78,16 +77,14 @@ void finalizeErrors(
   auto size =
       std::min(std::min(rows.size(), activeRows.size()), errors->size());
   for (auto i = 0; i < size; ++i) {
-    if (errors->isNullAt(i)) {
+    if (!errors->hasErrorAt(i)) {
       continue;
     }
     if (rows.isValid(i) && !activeRows.isValid(i)) {
-      errors->setNull(i, true);
+      errors->clearError(i);
     }
-    if (throwOnError && !errors->isNullAt(i)) {
-      auto exceptionPtr =
-          std::static_pointer_cast<std::exception_ptr>(errors->valueAt(i));
-      std::rethrow_exception(*exceptionPtr);
+    if (throwOnError) {
+      errors->throwIfErrorAt(i);
     }
   }
 }
@@ -129,12 +126,20 @@ void ConjunctExpr::evalSpecialForm(
   for (int32_t i = 0; i < inputs_.size(); ++i) {
     VectorPtr inputResult;
     VectorRecycler inputResultRecycler(inputResult, context.vectorPool());
-    ErrorVectorPtr errors;
+    EvalErrorsPtr errors;
     if (handleErrors) {
       context.swapErrors(errors);
     }
 
     SelectivityTimer timer(selectivity_[inputOrder_[i]], numActive);
+    if (evaluatesArgumentsOnNonIncreasingSelection()) {
+      // Exclude loading rows that we know for sure will have a false result.
+      for (auto* field : inputs_[inputOrder_[i]]->distinctFields()) {
+        if (multiplyReferencedFields_.count(field) > 0) {
+          context.ensureFieldLoaded(field->index(context), *activeRows);
+        }
+      }
+    }
     inputs_[inputOrder_[i]]->eval(*activeRows, context, inputResult);
     if (context.errors()) {
       handleErrors = true;
@@ -193,6 +198,59 @@ void ConjunctExpr::maybeReorderInputs() {
   }
 }
 
+namespace {
+// helper functions for conjuncts operating on values, nulls and active rows a
+// word at a time.
+inline void setFalseForOne(uint64_t active, uint64_t source, uint64_t& target) {
+  target &= ~active | ~source;
+}
+
+inline void setTrueForOne(uint64_t active, uint64_t source, uint64_t& target) {
+  target |= active & source;
+}
+
+inline void
+setPresentForOne(uint64_t active, uint64_t source, uint64_t& target) {
+  target |= active & source;
+}
+
+inline void
+setNonPresentForOne(uint64_t active, uint64_t source, uint64_t& target) {
+  target &= ~active | ~source;
+}
+
+inline void updateAnd(
+    uint64_t& resultValue,
+    uint64_t& resultPresent,
+    uint64_t& active,
+    uint64_t testValue,
+    uint64_t testPresent) {
+  auto testFalse = ~testValue & testPresent;
+  setFalseForOne(active, testFalse, resultValue);
+  setPresentForOne(active, testFalse, resultPresent);
+  auto resultTrue = resultValue & resultPresent;
+  setNonPresentForOne(
+      active, resultPresent & resultTrue & ~testPresent, resultPresent);
+  active &= ~testFalse;
+}
+
+inline void updateOr(
+    uint64_t& resultValue,
+    uint64_t& resultPresent,
+    uint64_t& active,
+    uint64_t testValue,
+    uint64_t testPresent) {
+  auto testTrue = testValue & testPresent;
+  setTrueForOne(active, testTrue, resultValue);
+  setPresentForOne(active, testTrue, resultPresent);
+  auto resultFalse = ~resultValue & resultPresent;
+  setNonPresentForOne(
+      active, resultPresent & resultFalse & ~testPresent, resultPresent);
+  active &= ~testTrue;
+}
+
+} // namespace
+
 void ConjunctExpr::updateResult(
     BaseVector* inputResult,
     EvalCtx& context,
@@ -211,7 +269,7 @@ void ConjunctExpr::updateResult(
       &values,
       &nulls)) {
     case BooleanMix::kAllNull:
-      result->addNulls(nullptr, *activeRows);
+      result->addNulls(*activeRows);
       return;
     case BooleanMix::kAllFalse:
       if (isAnd_) {
@@ -246,24 +304,77 @@ void ConjunctExpr::updateResult(
       }
       return;
     default: {
-      bits::forEachSetBit(
-          activeRows->asRange().bits(),
-          activeRows->begin(),
-          activeRows->end(),
-          [&](int32_t row) {
-            if (nulls && bits::isBitNull(nulls, row)) {
-              result->setNull(row, true);
-            } else {
-              bool isTrue = bits::isBitSet(values, row);
-              if (isAnd_ && !isTrue) {
-                result->set(row, false);
-                activeRows->setValid(row, false);
-              } else if (!isAnd_ && isTrue) {
-                result->set(row, true);
-                activeRows->setValid(row, false);
+      uint64_t* resultValues = result->mutableRawValues<uint64_t>();
+      uint64_t* resultNulls = nullptr;
+      if (nulls || result->mayHaveNulls()) {
+        resultNulls = result->mutableRawNulls();
+      }
+      auto* activeBits = activeRows->asMutableRange().bits();
+      if (isAnd_) {
+        bits::forEachWord(
+            activeRows->begin(),
+            activeRows->end(),
+            [&](int32_t index, uint64_t mask) {
+              uint64_t nullWord =
+                  resultNulls ? resultNulls[index] : bits::kNotNull64;
+              uint64_t activeWord = activeBits[index] & mask;
+              updateAnd(
+                  resultValues[index],
+                  nullWord,
+                  activeWord,
+                  values[index],
+                  nulls ? nulls[index] : bits::kNotNull64);
+              if (resultNulls) {
+                resultNulls[index] = nullWord;
               }
-            }
-          });
+              activeBits[index] &= ~mask | activeWord;
+            },
+            [&](int32_t index) {
+              uint64_t nullWord =
+                  resultNulls ? resultNulls[index] : bits::kNotNull64;
+              updateAnd(
+                  resultValues[index],
+                  nullWord,
+                  activeBits[index],
+                  values[index],
+                  nulls ? nulls[index] : bits::kNotNull64);
+              if (resultNulls) {
+                resultNulls[index] = nullWord;
+              }
+            });
+      } else {
+        bits::forEachWord(
+            activeRows->begin(),
+            activeRows->end(),
+            [&](int32_t index, uint64_t mask) {
+              uint64_t nullWord =
+                  resultNulls ? resultNulls[index] : bits::kNotNull64;
+              uint64_t activeWord = activeBits[index] & mask;
+              updateOr(
+                  resultValues[index],
+                  nullWord,
+                  activeWord,
+                  values[index],
+                  nulls ? nulls[index] : bits::kNotNull64);
+              if (resultNulls) {
+                resultNulls[index] = nullWord;
+              }
+              activeBits[index] &= ~mask | activeWord;
+            },
+            [&](int32_t index) {
+              uint64_t nullWord =
+                  resultNulls ? resultNulls[index] : bits::kNotNull64;
+              updateOr(
+                  resultValues[index],
+                  nullWord,
+                  activeBits[index],
+                  values[index],
+                  nulls ? nulls[index] : bits::kNotNull64);
+              if (resultNulls) {
+                resultNulls[index] = nullWord;
+              }
+            });
+      }
       activeRows->updateBounds();
     }
   }
@@ -274,8 +385,8 @@ std::string ConjunctExpr::toSql(
   std::stringstream out;
   out << "(" << inputs_[0]->toSql(complexConstants) << ")";
   for (auto i = 1; i < inputs_.size(); ++i) {
-    out << " " << name_ << " "
-        << "(" << inputs_[i]->toSql(complexConstants) << ")";
+    out << " " << name_ << " " << "(" << inputs_[i]->toSql(complexConstants)
+        << ")";
   }
   return out.str();
 }
diff --git a/velox/expression/ConjunctExpr.h b/velox/expression/ConjunctExpr.h
index 4da0dcbf101ca..5fb6426632fca 100644
--- a/velox/expression/ConjunctExpr.h
+++ b/velox/expression/ConjunctExpr.h
@@ -82,6 +82,10 @@ class ConjunctExpr : public SpecialForm {
       FlatVector<bool>* result,
       SelectivityVector* activeRows);
 
+  bool evaluatesArgumentsOnNonIncreasingSelection() const override {
+    return isAnd_;
+  }
+
   // true if conjunction (and), false if disjunction (or).
   const bool isAnd_;
 
diff --git a/velox/expression/ConstantExpr.cpp b/velox/expression/ConstantExpr.cpp
index be2abcd894654..f0b618c2e1f9d 100644
--- a/velox/expression/ConstantExpr.cpp
+++ b/velox/expression/ConstantExpr.cpp
@@ -118,7 +118,7 @@ std::string toSqlType(const TypePtr& type) {
         if (i > 0) {
           out << ", ";
         }
-        out << type->asRow().nameOf(i) << " " << type->childAt(i)->toString();
+        out << type->asRow().nameOf(i) << " " << toSqlType(type->childAt(i));
       }
       out << ")";
       return out.str();
@@ -160,14 +160,35 @@ void appendSqlLiteral(
       break;
     }
     case TypeKind::TINYINT:
+      [[fallthrough]];
     case TypeKind::SMALLINT:
-    case TypeKind::BIGINT:
-    case TypeKind::TIMESTAMP:
+      [[fallthrough]];
+    case TypeKind::BIGINT: {
+      if (vector.type()->isIntervalDayTime()) {
+        auto* intervalVector =
+            vector.wrappedVector()->as<SimpleVector<int64_t>>();
+        out << "INTERVAL " << intervalVector->valueAt(vector.wrappedIndex(row))
+            << " MILLISECOND";
+        break;
+      }
+      [[fallthrough]];
+    }
+    case TypeKind::HUGEINT:
+      [[fallthrough]];
     case TypeKind::REAL:
+      [[fallthrough]];
     case TypeKind::DOUBLE:
       out << "'" << vector.wrappedVector()->toString(vector.wrappedIndex(row))
           << "'::" << vector.type()->toString();
       break;
+    case TypeKind::TIMESTAMP: {
+      TimestampToStringOptions options;
+      options.dateTimeSeparator = ' ';
+      const auto ts =
+          vector.wrappedVector()->as<SimpleVector<Timestamp>>()->valueAt(row);
+      out << "'" << ts.toString(options) << "'::" << vector.type()->toString();
+      break;
+    }
     case TypeKind::VARCHAR:
       appendSqlString(
           vector.wrappedVector()->toString(vector.wrappedIndex(row)), out);
@@ -216,7 +237,9 @@ void appendSqlLiteral(
 }
 
 bool canBeExpressedInSQL(const TypePtr& type) {
-  return type->isPrimitiveType() && type != VARBINARY();
+  // Logical types cannot be expressed in SQL.
+  const bool isLogicalType = type->name() != type->kindName();
+  return type->isPrimitiveType() && type != VARBINARY() && !isLogicalType;
 }
 
 } // namespace
@@ -224,6 +247,15 @@ bool canBeExpressedInSQL(const TypePtr& type) {
 std::string ConstantExpr::toSql(
     std::vector<VectorPtr>* complexConstants) const {
   VELOX_CHECK_NOT_NULL(sharedConstantValue_);
+
+  // TODO canBeExpressedInSQL is misleading. ARRAY(INTEGER()) can be expressed
+  // in SQL, but canBeExpressedInSQL returns false for that type. we need to
+  // distinguish between types that cannot be expressed in SQL at all
+  // (VARBINARY, logic types like JSON) and types that can be expressed in
+  // SQL, but they can be large and therefore we want to provider an option to
+  // represent then using 'complex constants'. If a type cannot be expressed
+  // in SQL, we should assert that complexConstants is not null.
+
   std::ostringstream out;
   if (complexConstants && !canBeExpressedInSQL(sharedConstantValue_->type())) {
     int idx = complexConstants->size();
diff --git a/velox/expression/DecodedArgs.h b/velox/expression/DecodedArgs.h
index e56a9555da725..cfe791293eefb 100644
--- a/velox/expression/DecodedArgs.h
+++ b/velox/expression/DecodedArgs.h
@@ -41,7 +41,7 @@ class DecodedArgs {
     }
   }
 
-  DecodedVector* FOLLY_NONNULL at(int i) const {
+  DecodedVector* at(int i) const {
     return const_cast<exec::LocalDecodedVector*>(&holders_[i])->get();
   }
 
diff --git a/velox/expression/EvalCtx.cpp b/velox/expression/EvalCtx.cpp
index 08dafcc02afc1..ae87fb28063f6 100644
--- a/velox/expression/EvalCtx.cpp
+++ b/velox/expression/EvalCtx.cpp
@@ -16,23 +16,17 @@
 
 #include "velox/expression/EvalCtx.h"
 #include <exception>
-#include "velox/common/base/RawVector.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/PeeledEncoding.h"
 
-namespace facebook::velox::exec {
+using facebook::velox::common::testutil::TestValue;
 
-ScopedContextSaver::~ScopedContextSaver() {
-  if (context) {
-    context->restore(*this);
-  }
-}
+namespace facebook::velox::exec {
 
 EvalCtx::EvalCtx(core::ExecCtx* execCtx, ExprSet* exprSet, const RowVector* row)
-    : execCtx_(execCtx),
-      exprSet_(exprSet),
-      row_(row),
-      cacheEnabled_(execCtx->exprEvalCacheEnabled()) {
+    : execCtx_(execCtx), exprSet_(exprSet), row_(row) {
   // TODO Change the API to replace raw pointers with non-const references.
   // Sanity check inputs to prevent crashes.
   VELOX_CHECK_NOT_NULL(execCtx);
@@ -50,16 +44,11 @@ EvalCtx::EvalCtx(core::ExecCtx* execCtx, ExprSet* exprSet, const RowVector* row)
 }
 
 EvalCtx::EvalCtx(core::ExecCtx* execCtx)
-    : execCtx_(execCtx),
-      exprSet_(nullptr),
-      row_(nullptr),
-      cacheEnabled_(execCtx->exprEvalCacheEnabled()) {
+    : execCtx_(execCtx), exprSet_(nullptr), row_(nullptr) {
   VELOX_CHECK_NOT_NULL(execCtx);
 }
 
-void EvalCtx::saveAndReset(
-    ScopedContextSaver& saver,
-    const SelectivityVector& rows) {
+void EvalCtx::saveAndReset(ContextSaver& saver, const SelectivityVector& rows) {
   if (saver.context) {
     return;
   }
@@ -76,80 +65,81 @@ void EvalCtx::saveAndReset(
   }
 }
 
-void EvalCtx::ensureErrorsVectorSize(ErrorVectorPtr& vector, vector_size_t size)
+void EvalCtx::ensureErrorsVectorSize(EvalErrorsPtr& vector, vector_size_t size)
     const {
-  auto oldSize = vector ? vector->size() : 0;
   if (!vector) {
-    vector = std::make_shared<ErrorVector>(
-        pool(),
-        OpaqueType::create<void>(),
-        AlignedBuffer::allocate<bool>(size, pool(), true) /*nulls*/,
-        size /*length*/,
-        AlignedBuffer::allocate<ErrorVector::value_type>(
-            size, pool(), ErrorVector::value_type()),
-        std::vector<BufferPtr>(0),
-        SimpleVectorStats<std::shared_ptr<void>>{},
-        1 /*distinctValueCount*/,
-        size /*nullCount*/,
-        false /*isSorted*/,
-        size /*representedBytes*/);
-  } else if (vector->size() < size) {
-    vector->resize(size, false);
-  }
-  // Set all new positions to null, including the one to be set.
-  for (auto i = oldSize; i < size; ++i) {
-    vector->setNull(i, true);
+    vector = std::make_shared<EvalErrors>(pool(), size);
+  } else {
+    vector->ensureCapacity(size);
   }
 }
 
+void EvalCtx::addError(vector_size_t index, EvalErrorsPtr& errorsPtr) const {
+  ensureErrorsVectorSize(errorsPtr, index + 1);
+  errorsPtr->setError(index);
+}
+
 void EvalCtx::addError(
     vector_size_t index,
     const std::exception_ptr& exceptionPtr,
-    ErrorVectorPtr& errorsPtr) const {
+    EvalErrorsPtr& errorsPtr) const {
   ensureErrorsVectorSize(errorsPtr, index + 1);
-  if (errorsPtr->isNullAt(index)) {
-    errorsPtr->setNull(index, false);
-    errorsPtr->set(index, std::make_shared<std::exception_ptr>(exceptionPtr));
-  }
+  errorsPtr->setError(index, exceptionPtr);
 }
 
 void EvalCtx::addErrors(
     const SelectivityVector& rows,
-    const ErrorVectorPtr& fromErrors,
-    ErrorVectorPtr& toErrors) const {
+    const EvalErrorsPtr& fromErrors,
+    EvalErrorsPtr& toErrors) const {
   if (!fromErrors) {
     return;
   }
 
   ensureErrorsVectorSize(toErrors, fromErrors->size());
-  rows.testSelected([&](auto row) {
-    if (!fromErrors->isIndexInRange(row)) {
-      return false;
-    }
-    if (!fromErrors->isNullAt(row) && toErrors->isNullAt(row)) {
-      toErrors->set(
-          row,
-          std::static_pointer_cast<std::exception_ptr>(
-              fromErrors->valueAt(row)));
-    }
-    return true;
-  });
+  toErrors->copyErrors(rows, *fromErrors);
+}
+
+void EvalCtx::addError(
+    vector_size_t row,
+    const EvalErrorsPtr& fromErrors,
+    EvalErrorsPtr& toErrors) const {
+  if (fromErrors != nullptr) {
+    copyError(*fromErrors, row, toErrors, row);
+  }
+}
+
+void EvalCtx::copyError(
+    const EvalErrors& from,
+    vector_size_t fromIndex,
+    EvalErrorsPtr& to,
+    vector_size_t toIndex) const {
+  const auto fromSize = from.size();
+  if (from.hasErrorAt(fromIndex)) {
+    ensureErrorsVectorSize(to, toIndex + 1);
+    to->copyError(from, fromIndex, toIndex);
+  }
+}
+
+void EvalCtx::deselectErrors(SelectivityVector& rows) const {
+  if (!errors_) {
+    return;
+  }
+  // A non-null in errors resets the row. AND with the errors null mask.
+  rows.deselectNonNulls(
+      errors_->errorFlags(),
+      rows.begin(),
+      std::min(errors_->size(), rows.end()));
 }
 
-void EvalCtx::restore(ScopedContextSaver& saver) {
+void EvalCtx::restore(ContextSaver& saver) {
+  TestValue::adjust("facebook::velox::exec::EvalCtx::restore", this);
+
   peeledFields_ = std::move(saver.peeled);
   nullsPruned_ = saver.nullsPruned;
   if (errors_) {
-    int32_t errorSize = errors_->size();
     peeledEncoding_->applyToNonNullInnerRows(
         *saver.rows, [&](auto outerRow, auto innerRow) {
-          if (innerRow < errorSize && !errors_->isNullAt(innerRow)) {
-            addError(
-                outerRow,
-                *std::static_pointer_cast<std::exception_ptr>(
-                    errors_->valueAt(innerRow)),
-                saver.errors);
-          }
+          copyError(*errors_, innerRow, saver.errors, outerRow);
         });
   }
   errors_ = std::move(saver.errors);
@@ -161,8 +151,38 @@ namespace {
 auto throwError(const std::exception_ptr& exceptionPtr) {
   std::rethrow_exception(toVeloxException(exceptionPtr));
 }
+
+std::exception_ptr toVeloxUserError(const std::string& message) {
+  return std::make_exception_ptr(VeloxUserError(
+      __FILE__,
+      __LINE__,
+      __FUNCTION__,
+      "",
+      message,
+      error_source::kErrorSourceUser,
+      error_code::kInvalidArgument,
+      false /*retriable*/));
+}
+
 } // namespace
 
+void EvalCtx::setStatus(vector_size_t index, const Status& status) {
+  VELOX_CHECK(!status.ok(), "Status must be an error");
+
+  if (status.isUserError()) {
+    if (throwOnError_) {
+      VELOX_USER_FAIL(status.message());
+    }
+    if (captureErrorDetails_) {
+      addError(index, toVeloxUserError(status.message()), errors_);
+    } else {
+      addError(index, errors_);
+    }
+  } else {
+    VELOX_FAIL(status.message());
+  }
+}
+
 void EvalCtx::setError(
     vector_size_t index,
     const std::exception_ptr& exceptionPtr) {
@@ -170,11 +190,13 @@ void EvalCtx::setError(
     throwError(exceptionPtr);
   }
 
-  addError(index, toVeloxException(exceptionPtr), errors_);
+  if (captureErrorDetails_) {
+    addError(index, toVeloxException(exceptionPtr), errors_);
+  } else {
+    addError(index, errors_);
+  }
 }
 
-// This should be used onlly when exceptionPtr is guranteed to be a
-// VeloxException.
 void EvalCtx::setVeloxExceptionError(
     vector_size_t index,
     const std::exception_ptr& exceptionPtr) {
@@ -182,7 +204,11 @@ void EvalCtx::setVeloxExceptionError(
     std::rethrow_exception(exceptionPtr);
   }
 
-  addError(index, exceptionPtr, errors_);
+  if (captureErrorDetails_) {
+    addError(index, exceptionPtr, errors_);
+  } else {
+    addError(index, errors_);
+  }
 }
 
 void EvalCtx::setErrors(
@@ -192,15 +218,19 @@ void EvalCtx::setErrors(
     throwError(exceptionPtr);
   }
 
-  auto veloxException = toVeloxException(exceptionPtr);
-  rows.applyToSelected(
-      [&](auto row) { addError(row, veloxException, errors_); });
+  if (captureErrorDetails_) {
+    auto veloxException = toVeloxException(exceptionPtr);
+    rows.applyToSelected(
+        [&](auto row) { addError(row, veloxException, errors_); });
+  } else {
+    rows.applyToSelected([&](auto row) { addError(row, errors_); });
+  }
 }
 
 void EvalCtx::addElementErrorsToTopLevel(
     const SelectivityVector& elementRows,
     const BufferPtr& elementToTopLevelRows,
-    ErrorVectorPtr& topLevelErrors) {
+    EvalErrorsPtr& topLevelErrors) {
   if (!errors_) {
     return;
   }
@@ -208,12 +238,7 @@ void EvalCtx::addElementErrorsToTopLevel(
   const auto* rawElementToTopLevelRows =
       elementToTopLevelRows->as<vector_size_t>();
   elementRows.applyToSelected([&](auto row) {
-    if (errors_->isIndexInRange(row) && !errors_->isNullAt(row)) {
-      addError(
-          rawElementToTopLevelRows[row],
-          *std::static_pointer_cast<std::exception_ptr>(errors_->valueAt(row)),
-          topLevelErrors);
-    }
+    copyError(*errors_, row, topLevelErrors, rawElementToTopLevelRows[row]);
   });
 }
 
@@ -230,12 +255,28 @@ void EvalCtx::convertElementErrorsToTopLevelNulls(
   const auto* rawElementToTopLevelRows =
       elementToTopLevelRows->as<vector_size_t>();
   elementRows.applyToSelected([&](auto row) {
-    if (errors_->isIndexInRange(row) && !errors_->isNullAt(row)) {
+    if (errors_->hasErrorAt(row)) {
       bits::setNull(rawNulls, rawElementToTopLevelRows[row], true);
     }
   });
 }
 
+void EvalCtx::moveAppendErrors(EvalErrorsPtr& other) {
+  if (!errors_) {
+    return;
+  }
+
+  if (!other) {
+    std::swap(errors_, other);
+    return;
+  }
+
+  ensureErrorsVectorSize(other, errors_->size());
+  other->copyErrors(*errors_);
+
+  errors_.reset();
+}
+
 const VectorPtr& EvalCtx::getField(int32_t index) const {
   const VectorPtr* field;
   if (!peeledFields_.empty()) {
@@ -279,6 +320,46 @@ VectorPtr EvalCtx::ensureFieldLoaded(
   return field;
 }
 
+// Utility function used to extend the size of a complex Vector by wrapping it
+// in a dictionary with identity mapping for existing rows.
+// Note: If targetSize < the current size of the vector, then the result will
+// have the same size as the input vector.
+VectorPtr extendSizeByWrappingInDictionary(
+    VectorPtr& vector,
+    vector_size_t targetSize,
+    EvalCtx& context) {
+  auto currentSize = vector->size();
+  targetSize = std::max(targetSize, currentSize);
+  VELOX_DCHECK(
+      !vector->type()->isPrimitiveType(), "Only used for complex types.");
+  BufferPtr indices = allocateIndices(targetSize, context.pool());
+  auto rawIndices = indices->asMutable<vector_size_t>();
+  // Only fill in indices for existing rows in the vector.
+  std::iota(rawIndices, rawIndices + currentSize, 0);
+  // A nulls buffer is required otherwise wrapInDictionary() can return a
+  // constant. Moreover, nulls will eventually be added, so it's not wasteful.
+  auto nulls = allocateNulls(targetSize, context.pool());
+  return BaseVector::wrapInDictionary(
+      std::move(nulls), std::move(indices), targetSize, std::move(vector));
+}
+
+// Utility function used to resize a primitive type vector while ensuring that
+// the result has all unique and writable buffers.
+void resizePrimitiveTypeVectors(
+    VectorPtr& vector,
+    vector_size_t targetSize,
+    EvalCtx& context) {
+  VELOX_DCHECK(
+      vector->type()->isPrimitiveType(), "Only used for primitive types.");
+  auto currentSize = vector->size();
+  LocalSelectivityVector extraRows(context, targetSize);
+  extraRows->setValidRange(0, currentSize, false);
+  extraRows->setValidRange(currentSize, targetSize, true);
+  extraRows->updateBounds();
+  BaseVector::ensureWritable(
+      *extraRows, vector->type(), context.pool(), vector);
+}
+
 // static
 void EvalCtx::addNulls(
     const SelectivityVector& rows,
@@ -306,21 +387,35 @@ void EvalCtx::addNulls(
     return;
   }
 
+  auto currentSize = result->size();
+  auto targetSize = rows.end();
   if (!result.unique() || !result->isNullsWritable()) {
-    BaseVector::ensureWritable(
-        SelectivityVector::empty(), type, context.pool(), result);
-  }
-
-  if (result->size() < rows.end()) {
-    BaseVector::ensureWritable(
-        SelectivityVector::empty(), type, context.pool(), result);
-    if (result->encoding() == VectorEncoding::Simple::ROW) {
-      // Avoid calling resize on all children by adding top level nulls only.
-      // We know from the check above that result is unique and isNullsWritable.
-      result->asUnchecked<RowVector>()->appendNulls(
-          rows.end() - result->size());
+    if (result->type()->isPrimitiveType()) {
+      if (currentSize < targetSize) {
+        resizePrimitiveTypeVectors(result, targetSize, context);
+      } else {
+        BaseVector::ensureWritable(
+            SelectivityVector::empty(), type, context.pool(), result);
+      }
     } else {
-      result->resize(rows.end());
+      result = extendSizeByWrappingInDictionary(result, targetSize, context);
+    }
+  } else if (currentSize < targetSize) {
+    VELOX_DCHECK(
+        !result->isConstantEncoding(),
+        "Should have been handled in code-path for !isNullsWritable()");
+    if (VectorEncoding::isDictionary(result->encoding())) {
+      // We can just resize the dictionary layer in-place. It also ensures
+      // indices buffer is unique after resize.
+      result->resize(targetSize);
+    } else {
+      if (result->type()->isPrimitiveType()) {
+        // A flat vector can still have a shared values_ buffer so we ensure all
+        // its buffers are unique while resizing.
+        resizePrimitiveTypeVectors(result, targetSize, context);
+      } else {
+        result = extendSizeByWrappingInDictionary(result, targetSize, context);
+      }
     }
   }
 
diff --git a/velox/expression/EvalCtx.h b/velox/expression/EvalCtx.h
index 01efb77e337e6..22fb13e478b6a 100644
--- a/velox/expression/EvalCtx.h
+++ b/velox/expression/EvalCtx.h
@@ -16,7 +16,9 @@
 
 #pragma once
 
+#include <exception>
 #include <functional>
+#include <memory>
 
 #include "velox/common/base/Portability.h"
 #include "velox/core/QueryCtx.h"
@@ -29,22 +31,200 @@ class Expr;
 class ExprSet;
 class LocalDecodedVector;
 class LocalSelectivityVector;
-struct ScopedContextSaver;
+struct ContextSaver;
 class PeeledEncoding;
 
+/// Tracks per-row errors that occurred during expression evaluation.
+/// Used when EvalCtx::throwOnError() is false.
+class EvalErrors {
+ public:
+  EvalErrors(memory::MemoryPool* pool, vector_size_t size)
+      : pool_{pool}, size_{size} {
+    VELOX_CHECK_NOT_NULL(pool);
+    VELOX_CHECK_GT(size, 0);
+    errorFlags_ = AlignedBuffer::allocate<bool>(size, pool, false);
+    rawErrorFlags_ = errorFlags_->asMutable<uint64_t>();
+  }
+
+  vector_size_t size() const {
+    return size_;
+  }
+
+  /// Similar to std::vector::reserve. Allocates internal buffers to fit at
+  /// least 'size' rows. No-op if 'size()' is already at or exceeding requested.
+  void ensureCapacity(vector_size_t size) {
+    if (size_ >= size) {
+      return;
+    }
+
+    AlignedBuffer::reallocate<bool>(&errorFlags_, size, false);
+    rawErrorFlags_ = errorFlags_->asMutable<uint64_t>();
+    if (exceptions_ != nullptr) {
+      AlignedBuffer::reallocate<TError>(&exceptions_, size, TError());
+    }
+
+    size_ = size;
+  }
+
+  /// Returns true if at least one row has an error.
+  bool hasError() const {
+    const auto firstErrorRow = bits::findFirstBit(rawErrorFlags_, 0, size_);
+    return firstErrorRow >= 0;
+  }
+
+  /// Returns true if 'index' has an error.
+  bool hasErrorAt(vector_size_t index) const {
+    return index < size_ && bits::isBitSet(rawErrorFlags_, index);
+  }
+
+  /// Throws if 'index' has an error. The caller must ensure that error details
+  /// are available.
+  void throwIfErrorAt(vector_size_t index) const {
+    auto error = errorAt(index);
+    if (error.has_value()) {
+      VELOX_CHECK_NOT_NULL(error.value());
+      std::rethrow_exception(*error.value());
+    }
+  }
+
+  /// Finds first row in 'rows' that has an error and throws that error. The
+  /// caller must ensure that error details are available.
+  void throwFirstError(const SelectivityVector& rows) const {
+    rows.testSelected([&](vector_size_t row) {
+      if (row < size_) {
+        throwIfErrorAt(row);
+        return true;
+      }
+      return false;
+    });
+  }
+
+  /// Returns std::nullopt if 'index' doesn't have an error.
+  /// Returns nullptr if 'index' has an error, but error details are not
+  /// available. Returns std::exception_ptr if 'index' has an error and error
+  /// details are available.
+  std::optional<std::shared_ptr<std::exception_ptr>> errorAt(
+      vector_size_t index) const {
+    if (!hasErrorAt(index)) {
+      return std::nullopt;
+    }
+
+    if (exceptions_ == nullptr) {
+      return {nullptr};
+    }
+
+    return exceptions_->as<TError>()[index];
+  }
+
+  /// Bitmask with bits set for rows with errors. Only first 'size()' bits are
+  /// valid.
+  const uint64_t* errorFlags() const {
+    return rawErrorFlags_;
+  }
+
+  /// Returns the number of rows with errors.
+  vector_size_t countErrors() const {
+    return bits::countBits(rawErrorFlags_, 0, size_);
+  }
+
+  /// Marks 'index' as having an error. Doesn't specify error details.
+  void setError(vector_size_t index) {
+    ensureCapacity(index + 1);
+    bits::setBit(rawErrorFlags_, index);
+  }
+
+  /// Clears error at 'index'.
+  void clearError(vector_size_t index) {
+    if (index < size_) {
+      bits::clearBit(rawErrorFlags_, index);
+    }
+  }
+
+  /// Marks 'index' as having an error and sets the exception_ptr. No-op if
+  /// 'index' is already marked as having an error.
+  void setError(vector_size_t index, const std::exception_ptr& exceptionPtr) {
+    ensureCapacity(index + 1);
+    if (!bits::isBitSet(rawErrorFlags_, index)) {
+      bits::setBit(rawErrorFlags_, index);
+
+      if (exceptions_ == nullptr) {
+        exceptions_ = AlignedBuffer::allocate<TError>(size_, pool_, TError());
+      }
+      exceptions_->asMutable<TError>()[index] =
+          std::make_shared<std::exception_ptr>(exceptionPtr);
+    }
+  }
+
+  /// Copies an error from 'from' at index 'fromIndex' to this at index
+  /// 'toIndex'. No-op if 'from' at index 'fromIndex' doesn't have an error or
+  /// this already has an error at 'toIndex'.
+  void copyError(
+      const EvalErrors& from,
+      vector_size_t fromIndex,
+      vector_size_t toIndex) {
+    if (from.hasErrorAt(fromIndex)) {
+      ensureCapacity(toIndex + 1);
+      if (!bits::isBitSet(rawErrorFlags_, toIndex)) {
+        bits::setBit(rawErrorFlags_, toIndex);
+
+        if (from.exceptions_ != nullptr) {
+          if (exceptions_ == nullptr) {
+            exceptions_ =
+                AlignedBuffer::allocate<TError>(size_, pool_, TError());
+          }
+
+          exceptions_->asMutable<TError>()[toIndex] =
+              from.exceptions_->as<TError>()[fromIndex];
+        }
+      }
+    }
+  }
+
+  /// Copies errors from 'from' at 'rows' to corresponding rows in this. Doesn't
+  /// overwrite existing errors.
+  void copyErrors(const SelectivityVector& rows, const EvalErrors& from) {
+    const auto fromSize = from.size();
+    ensureCapacity(std::min(fromSize, rows.end()));
+    rows.testSelected([&](auto row) {
+      if (row < fromSize) {
+        copyError(from, row, row);
+        return true;
+      }
+      return false;
+    });
+  }
+
+  /// Copies all errors from 'from' to corresponding rows in this. Doesn't
+  /// overwrite existing errors.
+  void copyErrors(const EvalErrors& from) {
+    ensureCapacity(from.size());
+    bits::forEachSetBit(from.errorFlags(), 0, from.size(), [&](auto row) {
+      copyError(from, row, row);
+    });
+  }
+
+ private:
+  using TError = std::shared_ptr<std::exception_ptr>;
+
+  memory::MemoryPool* pool_;
+  vector_size_t size_;
+  BufferPtr errorFlags_;
+  uint64_t* rawErrorFlags_;
+  BufferPtr exceptions_{nullptr};
+};
+
+using EvalErrorsPtr = std::shared_ptr<EvalErrors>;
+
 // Context for holding the base row vector, error state and various
 // flags for Expr interpreter.
 class EvalCtx {
  public:
-  EvalCtx(
-      core::ExecCtx* FOLLY_NONNULL execCtx,
-      ExprSet* FOLLY_NULLABLE exprSet,
-      const RowVector* FOLLY_NULLABLE row);
+  EvalCtx(core::ExecCtx* execCtx, ExprSet* exprSet, const RowVector* row);
 
   /// For testing only.
-  explicit EvalCtx(core::ExecCtx* FOLLY_NONNULL execCtx);
+  explicit EvalCtx(core::ExecCtx* execCtx);
 
-  const RowVector* FOLLY_NONNULL row() const {
+  const RowVector* row() const {
     return row_;
   }
 
@@ -54,7 +234,7 @@ class EvalCtx {
     return inputFlatNoNulls_;
   }
 
-  memory::MemoryPool* FOLLY_NONNULL pool() const {
+  memory::MemoryPool* pool() const {
     return execCtx_->pool();
   }
 
@@ -77,14 +257,19 @@ class EvalCtx {
   }
 
   /// Used by peelEncodings.
-  void saveAndReset(ScopedContextSaver& saver, const SelectivityVector& rows);
+  void saveAndReset(ContextSaver& saver, const SelectivityVector& rows);
 
-  void restore(ScopedContextSaver& saver);
+  void restore(ContextSaver& saver);
 
+  // @param status Must indicate an error. Cannot be "ok".
+  void setStatus(vector_size_t index, const Status& status);
+
+  // If exceptionPtr is known to be a VeloxException use setVeloxExceptionError
+  // instead.
   void setError(vector_size_t index, const std::exception_ptr& exceptionPtr);
 
-  // Similar to setError but more performant, should be used when the user knows
-  // for sure that exception_ptr is a velox exception.
+  // Similar to setError but more performant. Should be used when the caller
+  // knows for sure that exception_ptr is a VeloxException.
   void setVeloxExceptionError(
       vector_size_t index,
       const std::exception_ptr& exceptionPtr);
@@ -93,11 +278,20 @@ class EvalCtx {
       const SelectivityVector& rows,
       const std::exception_ptr& exceptionPtr);
 
-  /// Invokes a function on each selected row. Records per-row exceptions by
-  /// calling 'setError'. The function must take a single "row" argument of type
-  /// vector_size_t and return void.
   template <typename Callable>
   void applyToSelectedNoThrow(const SelectivityVector& rows, Callable func) {
+    applyToSelectedNoThrow(rows, func, [](auto /* row */) INLINE_LAMBDA {});
+  }
+
+  /// Invokes a function on each selected row. Records per-row exceptions by
+  /// calling 'setError'. The function onErrorFunc is called before 'setError'
+  /// when exceptions are thrown. The functions Callable and OnError must take a
+  /// single "row" argument of type vector_size_t and return void.
+  template <typename Callable, typename OnError>
+  void applyToSelectedNoThrow(
+      const SelectivityVector& rows,
+      Callable func,
+      OnError onErrorFunc) {
     rows.template applyToSelected([&](auto row) INLINE_LAMBDA {
       try {
         func(row);
@@ -105,9 +299,13 @@ class EvalCtx {
         if (!e.isUserError()) {
           throw;
         }
+
+        onErrorFunc(row);
+
         // Avoid double throwing.
         setVeloxExceptionError(row, std::current_exception());
-      } catch (const std::exception& e) {
+      } catch (const std::exception&) {
+        onErrorFunc(row);
         setError(row, std::current_exception());
       }
     });
@@ -119,7 +317,7 @@ class EvalCtx {
   void addError(
       vector_size_t index,
       const std::exception_ptr& exceptionPtr,
-      ErrorVectorPtr& errorsPtr) const;
+      EvalErrorsPtr& errorsPtr) const;
 
   /// Copy std::exception_ptr in fromErrors at rows to the corresponding rows in
   /// toErrors. If there are existing exceptions in toErrors, these exceptions
@@ -127,82 +325,87 @@ class EvalCtx {
   /// ignored.
   void addErrors(
       const SelectivityVector& rows,
-      const ErrorVectorPtr& fromErrors,
-      ErrorVectorPtr& toErrors) const;
+      const EvalErrorsPtr& fromErrors,
+      EvalErrorsPtr& toErrors) const;
+
+  /// Like above, but for a single row.
+  void addError(
+      vector_size_t row,
+      const EvalErrorsPtr& fromErrors,
+      EvalErrorsPtr& toErrors) const;
 
   // Given a mapping from element rows to top-level rows, add element-level
   // errors in errors_ to topLevelErrors.
   void addElementErrorsToTopLevel(
       const SelectivityVector& elementRows,
       const BufferPtr& elementToTopLevelRows,
-      ErrorVectorPtr& topLevelErrors);
+      EvalErrorsPtr& topLevelErrors);
 
   // Given a mapping from element rows to top-level rows, set errors in
-  // in the elements as nulls int the top level row.
+  // the elements as nulls in the top level row.
   void convertElementErrorsToTopLevelNulls(
       const SelectivityVector& elementRows,
       const BufferPtr& elementToTopLevelRows,
       VectorPtr& result);
 
-  void deselectErrors(SelectivityVector& rows) const {
-    if (!errors_) {
-      return;
-    }
-    // A non-null in errors resets the row. AND with the errors null mask.
-    rows.deselectNonNulls(
-        errors_->rawNulls(),
-        rows.begin(),
-        std::min(errors_->size(), rows.end()));
-  }
+  void deselectErrors(SelectivityVector& rows) const;
 
-  // Returns the vector of errors or nullptr if no errors. This is
-  // intentionally a raw pointer to signify that the caller may not
-  // retain references to this.
-  ErrorVector* FOLLY_NULLABLE errors() const {
+  /// Returns the vector of errors or nullptr if no errors. This is
+  /// intentionally a raw pointer to signify that the caller may not
+  /// retain references to this.
+  ///
+  /// When 'captureErrorDetails' is false, only null flags are being set, the
+  /// values are null std::shared_ptr and should not be used.
+  EvalErrors* errors() const {
     return errors_.get();
   }
 
-  ErrorVectorPtr* FOLLY_NONNULL errorsPtr() {
+  EvalErrorsPtr* errorsPtr() {
     return &errors_;
   }
 
-  void swapErrors(ErrorVectorPtr& other) {
+  /// Make sure the error vector is addressable up to index `size`-1. Initialize
+  /// all
+  /// new elements to null.
+  void ensureErrorsVectorSize(vector_size_t size) {
+    ensureErrorsVectorSize(errors_, size);
+  }
+
+  void swapErrors(EvalErrorsPtr& other) {
     std::swap(errors_, other);
   }
 
   /// Adds errors in 'this' to 'other'. Clears errors from 'this'.
-  void moveAppendErrors(ErrorVectorPtr& other) {
-    if (!errors_) {
-      return;
-    }
-
-    if (!other) {
-      std::swap(errors_, other);
-      return;
-    }
-
-    ensureErrorsVectorSize(other, errors_->size());
-    bits::forEachBit(
-        errors_->rawNulls(), 0, errors_->size(), bits::kNotNull, [&](auto row) {
-          other->set(row, errors_->valueAt(row));
-        });
-
-    errors_.reset();
-  }
+  void moveAppendErrors(EvalErrorsPtr& other);
 
+  /// Boolean indicating whether exceptions that occur during expression
+  /// evaluation should be thrown directly or saved for later processing.
   bool throwOnError() const {
     return throwOnError_;
   }
 
-  bool* FOLLY_NONNULL mutableThrowOnError() {
+  bool* mutableThrowOnError() {
     return &throwOnError_;
   }
 
+  /// Boolean indicating whether to capture details when storing exceptions for
+  /// later processing (throwOnError_ == true).
+  ///
+  /// Conjunct expressions (AND, OR) require capturing error details, while TRY
+  /// and TRY_CAST expressions do not.
+  bool captureErrorDetails() const {
+    return captureErrorDetails_;
+  }
+
+  bool* mutableCaptureErrorDetails() {
+    return &captureErrorDetails_;
+  }
+
   bool nullsPruned() const {
     return nullsPruned_;
   }
 
-  bool* FOLLY_NONNULL mutableNullsPruned() {
+  bool* mutableNullsPruned() {
     return &nullsPruned_;
   }
 
@@ -218,7 +421,7 @@ class EvalCtx {
   // current SelectivityVector. For example, true for top level
   // projections or conjuncts of a top level AND. False for then and
   // else of an IF.
-  bool* FOLLY_NONNULL mutableIsFinalSelection() {
+  bool* mutableIsFinalSelection() {
     return &isFinalSelection_;
   }
 
@@ -227,15 +430,15 @@ class EvalCtx {
     return &finalSelection_;
   }
 
-  const SelectivityVector* FOLLY_NULLABLE finalSelection() const {
+  const SelectivityVector* finalSelection() const {
     return finalSelection_;
   }
 
-  core::ExecCtx* FOLLY_NONNULL execCtx() const {
+  core::ExecCtx* execCtx() const {
     return execCtx_;
   }
 
-  ExprSet* FOLLY_NULLABLE exprSet() const {
+  ExprSet* exprSet() const {
     return exprSet_;
   }
 
@@ -277,7 +480,7 @@ class EvalCtx {
   /// appropriate.
   static void addNulls(
       const SelectivityVector& rows,
-      const uint64_t* FOLLY_NULLABLE rawNulls,
+      const uint64_t* rawNulls,
       EvalCtx& context,
       const TypePtr& type,
       VectorPtr& result);
@@ -312,24 +515,58 @@ class EvalCtx {
         rows, type, execCtx_->pool(), result, execCtx_->vectorPool());
   }
 
-  /// Make sure the vector is addressable up to index `size`-1. Initialize all
-  /// new elements to null.
-  void ensureErrorsVectorSize(ErrorVectorPtr& vector, vector_size_t size) const;
   PeeledEncoding* getPeeledEncoding() {
     return peeledEncoding_.get();
   }
 
-  /// Returns true if caching in expression evaluation is enabled, such as
-  /// Expr::evalWithMemo.
-  bool cacheEnabled() const {
-    return cacheEnabled_;
+  /// Returns true if dictionary memoization optimization is enabled, which
+  /// allows the reuse of results between consecutive input batches if they are
+  /// dictionary encoded and have the same alphabet(undelying flat vector).
+  bool dictionaryMemoizationEnabled() const {
+    return execCtx_->optimizationParams().dictionaryMemoizationEnabled;
+  }
+
+  /// Returns the maximum number of distinct inputs to cache results for in a
+  /// given shared subexpression.
+  uint32_t maxSharedSubexprResultsCached() const {
+    return execCtx_->optimizationParams().maxSharedSubexprResultsCached;
+  }
+
+  /// Returns true if peeling is enabled.
+  bool peelingEnabled() const {
+    return execCtx_->optimizationParams().peelingEnabled;
+  }
+
+  /// Returns true if shared subexpression reuse is enabled.
+  bool sharedSubExpressionReuseEnabled() const {
+    return execCtx_->optimizationParams().sharedSubExpressionReuseEnabled;
+  }
+
+  /// Returns true if loading lazy inputs are deferred till they need to be
+  /// accessed.
+  bool deferredLazyLoadingEnabled() const {
+    return execCtx_->optimizationParams().deferredLazyLoadingEnabled;
   }
 
  private:
-  core::ExecCtx* const FOLLY_NONNULL execCtx_;
-  ExprSet* FOLLY_NULLABLE const exprSet_;
-  const RowVector* FOLLY_NULLABLE row_;
-  const bool cacheEnabled_;
+  void ensureErrorsVectorSize(EvalErrorsPtr& errors, vector_size_t size) const;
+
+  // Updates 'errorPtr' to clear null at 'index' to indicate an error has
+  // occured without specifying error details.
+  void addError(vector_size_t index, EvalErrorsPtr& errorsPtr) const;
+
+  // Copy error from 'from' at index 'fromIndex' to 'to' at index 'toIndex'.
+  // No-op if 'from' doesn't have an error at 'fromIndex' or if 'to' already has
+  // an error at 'toIndex'.
+  void copyError(
+      const EvalErrors& from,
+      vector_size_t fromIndex,
+      EvalErrorsPtr& to,
+      vector_size_t toIndex) const;
+
+  core::ExecCtx* const execCtx_;
+  ExprSet* const exprSet_;
+  const RowVector* row_;
   bool inputFlatNoNulls_;
 
   // Corresponds 1:1 to children of 'row_'. Set to an inner vector
@@ -346,36 +583,47 @@ class EvalCtx {
   bool nullsPruned_{false};
   bool throwOnError_{true};
 
+  bool captureErrorDetails_{true};
+
   // True if the current set of rows will not grow, e.g. not under and IF or OR.
   bool isFinalSelection_{true};
 
   // If isFinalSelection_ is false, the set of rows for the upper-most IF or
   // OR. Used to determine the set of rows for loading lazy vectors.
-  const SelectivityVector* FOLLY_NULLABLE finalSelection_;
+  const SelectivityVector* finalSelection_;
 
-  // Stores exception found during expression evaluation. Exceptions are stored
-  // in a opaque flat vector, which will translate to a
-  // std::shared_ptr<std::exception_ptr>.
-  ErrorVectorPtr errors_;
+  // Stores exceptions encountered during expression evaluation.
+  // If 'captureErrorDetails()' is false, stores flags indicating which rows had
+  // errors without storing actual exceptions.
+  EvalErrorsPtr errors_;
 };
 
-/// Utility wrapper struct that is used to temporarily reset the value of the an
-/// ExprCtx till it goes out of scope. EvalCtx::saveAndReset() is used to
-/// achieve that. The old context can also be explicitly restored using
-/// EvalCtx::restore().
-struct ScopedContextSaver {
-  ~ScopedContextSaver();
+/// Utility wrapper struct that is used to temporarily reset the value of the
+/// EvalCtx. EvalCtx::saveAndReset() is used to achieve that. Use
+/// withContextSaver to ensure the original context is restored on a scucessful
+/// run or call EvalContext::restore to do it manually.
+struct ContextSaver {
   // The context to restore. nullptr if nothing to restore.
-  EvalCtx* FOLLY_NULLABLE context = nullptr;
+  EvalCtx* context = nullptr;
   std::vector<VectorPtr> peeled;
   std::shared_ptr<PeeledEncoding> peeledEncoding;
   bool nullsPruned = false;
   // The selection of the context being saved.
-  const SelectivityVector* FOLLY_NONNULL rows;
-  const SelectivityVector* FOLLY_NULLABLE finalSelection;
-  ErrorVectorPtr errors;
+  const SelectivityVector* rows;
+  const SelectivityVector* finalSelection;
+  EvalErrorsPtr errors;
 };
 
+/// Restores the context when the body executes successfully.
+template <typename F>
+void withContextSaver(F&& f) {
+  ContextSaver saver;
+  f(saver);
+  if (saver.context) {
+    saver.context->restore(saver);
+  }
+}
+
 /// Produces a SelectivityVector with a single row selected using a pool of
 /// SelectivityVectors managed by the EvalCtx::execCtx().
 class LocalSingleRow {
@@ -421,28 +669,24 @@ class LocalSelectivityVector {
       : context_(*context.execCtx()),
         vector_(context_.getSelectivityVector(size)) {}
 
-  explicit LocalSelectivityVector(
-      EvalCtx* FOLLY_NONNULL context,
-      vector_size_t size)
+  explicit LocalSelectivityVector(EvalCtx* context, vector_size_t size)
       : LocalSelectivityVector(*context, size) {}
 
   explicit LocalSelectivityVector(core::ExecCtx& context)
       : context_(context), vector_(nullptr) {}
-  explicit LocalSelectivityVector(core::ExecCtx* FOLLY_NONNULL context)
+  explicit LocalSelectivityVector(core::ExecCtx* context)
       : context_(*context), vector_(nullptr) {}
 
   explicit LocalSelectivityVector(EvalCtx& context)
       : context_(*context.execCtx()), vector_(nullptr) {}
 
-  explicit LocalSelectivityVector(EvalCtx* FOLLY_NONNULL context)
+  explicit LocalSelectivityVector(EvalCtx* context)
       : LocalSelectivityVector(*context) {}
 
   LocalSelectivityVector(core::ExecCtx& context, vector_size_t size)
       : context_(context), vector_(context_.getSelectivityVector(size)) {}
 
-  LocalSelectivityVector(
-      core::ExecCtx* FOLLY_NONNULL context,
-      vector_size_t size)
+  LocalSelectivityVector(core::ExecCtx* context, vector_size_t size)
       : LocalSelectivityVector(*context, size) {}
 
   // Grab an instance of a SelectivityVector from the pool and initialize it to
@@ -469,11 +713,11 @@ class LocalSelectivityVector {
     return *vector_;
   }
 
-  SelectivityVector* FOLLY_NULLABLE get() {
+  SelectivityVector* get() {
     return vector_.get();
   }
 
-  SelectivityVector* FOLLY_NONNULL get(vector_size_t size) {
+  SelectivityVector* get(vector_size_t size) {
     if (!vector_) {
       vector_ = context_.getSelectivityVector(size);
     }
@@ -481,7 +725,7 @@ class LocalSelectivityVector {
   }
 
   // Returns a recycled SelectivityVector with 'size' bits set to 'value'.
-  SelectivityVector* FOLLY_NONNULL get(vector_size_t size, bool value) {
+  SelectivityVector* get(vector_size_t size, bool value) {
     if (!vector_) {
       vector_ = context_.getSelectivityVector();
     }
@@ -490,7 +734,7 @@ class LocalSelectivityVector {
   }
 
   // Returns a recycled SelectivityVector initialized from 'other'.
-  SelectivityVector* FOLLY_NONNULL get(const SelectivityVector& other) {
+  SelectivityVector* get(const SelectivityVector& other) {
     if (!vector_) {
       vector_ = context_.getSelectivityVector();
     }
@@ -508,12 +752,12 @@ class LocalSelectivityVector {
     return *vector_;
   }
 
-  SelectivityVector* FOLLY_NULLABLE operator->() {
+  SelectivityVector* operator->() {
     VELOX_DCHECK_NOT_NULL(vector_, "get(size) must be called.");
     return vector_.get();
   }
 
-  const SelectivityVector* FOLLY_NONNULL operator->() const {
+  const SelectivityVector* operator->() const {
     VELOX_DCHECK_NOT_NULL(vector_, "get(size) must be called.");
     return vector_.get();
   }
@@ -530,7 +774,7 @@ class LocalDecodedVector {
   explicit LocalDecodedVector(EvalCtx& context)
       : context_(*context.execCtx()) {}
 
-  explicit LocalDecodedVector(EvalCtx* FOLLY_NONNULL context)
+  explicit LocalDecodedVector(EvalCtx* context)
       : LocalDecodedVector(*context) {}
 
   LocalDecodedVector(
@@ -556,7 +800,7 @@ class LocalDecodedVector {
     }
   }
 
-  DecodedVector* FOLLY_NONNULL get() {
+  DecodedVector* get() {
     if (!vector_) {
       vector_ = context_.get().getDecodedVector();
     }
@@ -574,12 +818,12 @@ class LocalDecodedVector {
     return *vector_;
   }
 
-  DecodedVector* FOLLY_NONNULL operator->() {
+  DecodedVector* operator->() {
     VELOX_DCHECK_NOT_NULL(vector_, "get() must be called.");
     return vector_.get();
   }
 
-  const DecodedVector* FOLLY_NONNULL operator->() const {
+  const DecodedVector* operator->() const {
     VELOX_DCHECK_NOT_NULL(vector_, "get() must be called.");
     return vector_.get();
   }
@@ -598,14 +842,14 @@ class ScopedFinalSelectionSetter {
  public:
   ScopedFinalSelectionSetter(
       EvalCtx& evalCtx,
-      const SelectivityVector* FOLLY_NULLABLE finalSelection,
+      const SelectivityVector* finalSelection,
       bool checkCondition = true,
       bool override = false);
   ~ScopedFinalSelectionSetter();
 
  private:
   EvalCtx& evalCtx_;
-  const SelectivityVector* FOLLY_NULLABLE oldFinalSelection_;
+  const SelectivityVector* oldFinalSelection_;
   bool oldIsFinalSelection_;
 };
 
diff --git a/velox/expression/Expr.cpp b/velox/expression/Expr.cpp
index 6f5ee3b51db52..ee06286dfa4ff 100644
--- a/velox/expression/Expr.cpp
+++ b/velox/expression/Expr.cpp
@@ -99,19 +99,6 @@ bool isMember(
   return std::find(fields.begin(), fields.end(), &field) != fields.end();
 }
 
-void mergeFields(
-    std::vector<FieldReference*>& distinctFields,
-    std::unordered_set<FieldReference*>& multiplyReferencedFields,
-    const std::vector<FieldReference*>& moreFields) {
-  for (auto* newField : moreFields) {
-    if (isMember(distinctFields, *newField)) {
-      multiplyReferencedFields.insert(newField);
-    } else {
-      distinctFields.emplace_back(newField);
-    }
-  }
-}
-
 // Returns true if input expression or any sub-expression is an IF, AND or OR.
 bool hasConditionals(Expr* expr) {
   if (expr->isConditional()) {
@@ -141,12 +128,14 @@ Expr::Expr(
     TypePtr type,
     std::vector<std::shared_ptr<Expr>>&& inputs,
     std::shared_ptr<VectorFunction> vectorFunction,
+    VectorFunctionMetadata metadata,
     std::string name,
     bool trackCpuUsage)
     : type_(std::move(type)),
       inputs_(std::move(inputs)),
       name_(std::move(name)),
       vectorFunction_(std::move(vectorFunction)),
+      vectorFunctionMetadata_{std::move(metadata)},
       specialForm_{false},
       supportsFlatNoNullsFastPath_{
           vectorFunction_->supportsFlatNoNullsFastPath() &&
@@ -156,7 +145,7 @@ Expr::Expr(
   constantInputs_.reserve(inputs_.size());
   inputIsConstant_.reserve(inputs_.size());
   for (auto& expr : inputs_) {
-    if (auto constantExpr = std::dynamic_pointer_cast<ConstantExpr>(expr)) {
+    if (auto constantExpr = expr->as<ConstantExpr>()) {
       constantInputs_.emplace_back(constantExpr->value());
       inputIsConstant_.push_back(true);
     } else {
@@ -205,7 +194,7 @@ bool Expr::allSupportFlatNoNullsFastPath(
 
 void Expr::clearMetaData() {
   metaDataComputed_ = false;
-  for (auto child : inputs_) {
+  for (auto& child : inputs_) {
     child->clearMetaData();
   }
   propagatesNulls_ = false;
@@ -216,6 +205,26 @@ void Expr::clearMetaData() {
   sameAsParentDistinctFields_ = false;
 }
 
+void Expr::mergeFields(
+    std::vector<FieldReference*>& distinctFields,
+    std::unordered_set<FieldReference*>& multiplyReferencedFields,
+    const std::vector<FieldReference*>& moreFields) {
+  for (auto* newField : moreFields) {
+    if (isMember(distinctFields, *newField)) {
+      multiplyReferencedFields.insert(newField);
+    } else {
+      distinctFields.emplace_back(newField);
+    }
+  }
+}
+
+void Expr::computeDistinctFields() {
+  for (auto& input : inputs_) {
+    mergeFields(
+        distinctFields_, multiplyReferencedFields_, input->distinctFields_);
+  }
+}
+
 void Expr::computeMetadata() {
   if (metaDataComputed_) {
     return;
@@ -230,7 +239,7 @@ void Expr::computeMetadata() {
   // An expression is deterministic if it is a deterministic function call or a
   // special form, and all its inputs are also deterministic.
   if (vectorFunction_) {
-    deterministic_ = vectorFunction_->isDeterministic();
+    deterministic_ = vectorFunctionMetadata_.deterministic;
   } else {
     VELOX_CHECK(isSpecialForm());
     deterministic_ = true;
@@ -241,15 +250,7 @@ void Expr::computeMetadata() {
   }
 
   // (2) Compute distinctFields_ and multiplyReferencedFields_.
-  for (auto& input : inputs_) {
-    mergeFields(
-        distinctFields_, multiplyReferencedFields_, input->distinctFields_);
-  }
-
-  if (is<FieldReference>() && inputs_.empty()) {
-    distinctFields_.resize(1);
-    distinctFields_[0] = this->as<FieldReference>();
-  }
+  computeDistinctFields();
 
   // (3) Compute propagatesNulls_.
   // propagatesNulls_ is true iff a null in any of the columns this
@@ -258,7 +259,7 @@ void Expr::computeMetadata() {
       !is<CastExpr>()) {
     as<SpecialForm>()->computePropagatesNulls();
   } else {
-    if (vectorFunction_ && !vectorFunction_->isDefaultNullBehavior()) {
+    if (vectorFunction_ && !vectorFunctionMetadata_.defaultNullBehavior) {
       propagatesNulls_ = false;
     } else {
       // Logic for handling default-null vector functions.
@@ -298,28 +299,12 @@ void Expr::computeMetadata() {
   }
 
   // (5) Compute hasConditionals_.
-  hasConditionals_ = hasConditionals(this);
+  hasConditionals_ = exec::hasConditionals(this);
 
   metaDataComputed_ = true;
 }
 
 namespace {
-void rethrowFirstError(
-    const SelectivityVector& rows,
-    const ErrorVectorPtr& errors) {
-  auto errorSize = errors->size();
-  rows.testSelected([&](vector_size_t row) {
-    if (row >= errorSize) {
-      return false;
-    }
-    if (!errors->isNullAt(row)) {
-      auto exceptionPtr =
-          std::static_pointer_cast<std::exception_ptr>(errors->valueAt(row));
-      std::rethrow_exception(*exceptionPtr);
-    }
-    return true;
-  });
-}
 
 // Sets errors in 'context' to be the union of 'argumentErrors' for 'rows' and
 // 'errors'. If 'context' throws on first error and 'argumentErrors'
@@ -330,12 +315,12 @@ void rethrowFirstError(
 // caller.
 void mergeOrThrowArgumentErrors(
     const SelectivityVector& rows,
-    ErrorVectorPtr& originalErrors,
-    ErrorVectorPtr& argumentErrors,
+    EvalErrorsPtr& originalErrors,
+    EvalErrorsPtr& argumentErrors,
     EvalCtx& context) {
   if (argumentErrors) {
     if (context.throwOnError()) {
-      rethrowFirstError(rows, argumentErrors);
+      argumentErrors->throwFirstError(rows);
     }
     context.addErrors(rows, argumentErrors, originalErrors);
   }
@@ -374,8 +359,8 @@ bool Expr::evalArgsDefaultNulls(
     EvalArg evalArg,
     EvalCtx& context,
     VectorPtr& result) {
-  ErrorVectorPtr argumentErrors;
-  ErrorVectorPtr originalErrors;
+  EvalErrorsPtr argumentErrors;
+  EvalErrorsPtr originalErrors;
   LocalDecodedVector decoded(context);
   // Store pre-existing errors locally and clear them from
   // 'context'. We distinguish between argument errors and
@@ -395,19 +380,19 @@ bool Expr::evalArgsDefaultNulls(
       auto& arg = inputValues_[i];
       if (arg->mayHaveNulls()) {
         decoded.get()->decode(*arg, rows.rows());
-        flatNulls = decoded.get()->nulls();
+        flatNulls = decoded.get()->nulls(&rows.rows());
       }
       // A null with no error deselects the row.
       // An error adds itself to argument errors.
       if (context.errors()) {
         // There are new errors.
-        context.ensureErrorsVectorSize(*context.errorsPtr(), rows.rows().end());
+        context.ensureErrorsVectorSize(rows.rows().end());
         auto newErrors = context.errors();
         assert(newErrors); // lint
         if (flatNulls) {
           // There are both nulls and errors. Only a null with no error removes
           // a row.
-          auto errorNulls = newErrors->rawNulls();
+          auto errorNulls = newErrors->errorFlags();
           auto rowBits = rows.mutableRows().asMutableRange().bits();
           auto nwords = bits::nwords(rows.rows().end());
           for (auto j = 0; j < nwords; ++j) {
@@ -485,7 +470,10 @@ void Expr::evalSimplified(
   if (remainingRows->hasSelections()) {
     evalSimplifiedImpl(*remainingRows, context, result);
   }
-  addNulls(rows, remainingRows->asRange().bits(), context, result);
+
+  if (!type()->isFunction()) {
+    addNulls(rows, remainingRows->asRange().bits(), context, result);
+  }
 }
 
 void Expr::releaseInputValues(EvalCtx& evalCtx) {
@@ -504,7 +492,7 @@ void Expr::evalSimplifiedImpl(
   }
 
   MutableRemainingRows remainingRows(rows, context);
-  const bool defaultNulls = vectorFunction_->isDefaultNullBehavior();
+  const bool defaultNulls = vectorFunctionMetadata_.defaultNullBehavior;
   auto evalArg = [&](int32_t i) {
     auto& inputValue = inputValues_[i];
     inputs_[i]->evalSimplified(remainingRows.rows(), context, inputValue);
@@ -513,7 +501,8 @@ void Expr::evalSimplifiedImpl(
         inputValue->encoding() == VectorEncoding::Simple::FLAT ||
         inputValue->encoding() == VectorEncoding::Simple::ARRAY ||
         inputValue->encoding() == VectorEncoding::Simple::MAP ||
-        inputValue->encoding() == VectorEncoding::Simple::ROW);
+        inputValue->encoding() == VectorEncoding::Simple::ROW ||
+        inputValue->encoding() == VectorEncoding::Simple::FUNCTION);
   };
 
   if (defaultNulls) {
@@ -530,7 +519,7 @@ void Expr::evalSimplifiedImpl(
   try {
     vectorFunction_->apply(
         remainingRows.rows(), inputValues_, type(), context, result);
-  } catch (const VeloxException& ve) {
+  } catch (const VeloxException&) {
     throw;
   } catch (const std::exception& e) {
     VELOX_USER_FAIL(e.what());
@@ -549,14 +538,14 @@ namespace {
 class ExprExceptionContext {
  public:
   ExprExceptionContext(
-      const Expr* FOLLY_NONNULL expr,
-      const RowVector* FOLLY_NONNULL vector,
-      const ExprSet* FOLLY_NULLABLE parentExprSet)
+      const Expr* expr,
+      const RowVector* vector,
+      const ExprSet* parentExprSet)
       : expr_(expr), vector_(vector), parentExprSet_(parentExprSet) {}
 
   /// Persist data and sql on disk. Data will be persisted in $basePath/vector
   /// and sql will be persisted in $basePath/sql
-  void persistDataAndSql(const char* FOLLY_NONNULL basePath) {
+  void persistDataAndSql(const char* basePath) {
     // Exception already persisted or failed to persist. We don't persist again
     // in this situation.
     if (!dataPath_.empty()) {
@@ -617,11 +606,11 @@ class ExprExceptionContext {
     }
   }
 
-  const Expr* FOLLY_NONNULL expr() const {
+  const Expr* expr() const {
     return expr_;
   }
 
-  const RowVector* FOLLY_NONNULL vector() const {
+  const RowVector* vector() const {
     return vector_;
   }
 
@@ -639,15 +628,15 @@ class ExprExceptionContext {
 
  private:
   /// The expression.
-  const Expr* FOLLY_NONNULL expr_;
+  const Expr* expr_;
 
   /// The input vector, i.e. EvalCtx::row(). In some cases, input columns are
   /// re-used for results. Hence, 'vector' may no longer contain input data at
   /// the time of exception.
-  const RowVector* FOLLY_NONNULL vector_;
+  const RowVector* vector_;
 
   // The parent ExprSet that is executing this expression.
-  const ExprSet* FOLLY_NULLABLE parentExprSet_;
+  const ExprSet* parentExprSet_;
 
   /// Path of the file storing the serialized 'vector'. Used to avoid
   /// serializing vector repeatedly in cases when multiple rows generate
@@ -691,14 +680,15 @@ std::string onTopLevelException(VeloxException::Type exceptionType, void* arg) {
     basePath = FLAGS_velox_save_input_on_expression_system_failure_path.c_str();
   }
   if (strlen(basePath) == 0) {
-    return context->expr()->toString();
+    return fmt::format("Top-level Expression: {}", context->expr()->toString());
   }
 
   // Save input vector to a file.
   context->persistDataAndSql(basePath);
 
   return fmt::format(
-      "{}. Input data: {}. SQL expression: {}. All SQL expressions: {}.",
+      "Top-level Expression: {}. Input data: {}. SQL expression: {}."
+      " All SQL expressions: {}. ",
       context->expr()->toString(),
       context->dataPath(),
       context->sqlPath(),
@@ -718,7 +708,7 @@ void Expr::evalFlatNoNulls(
     EvalCtx& context,
     VectorPtr& result,
     const ExprSet* parentExprSet) {
-  if (shouldEvaluateSharedSubexp()) {
+  if (shouldEvaluateSharedSubexp(context)) {
     evaluateSharedSubexpr(
         rows,
         context,
@@ -740,8 +730,9 @@ void Expr::evalFlatNoNullsImpl(
     const ExprSet* parentExprSet) {
   ExprExceptionContext exprExceptionContext{this, context.row(), parentExprSet};
   ExceptionContextSetter exceptionContext(
-      {parentExprSet ? onTopLevelException : onException,
-       parentExprSet ? (void*)&exprExceptionContext : this});
+      {.messageFunc = parentExprSet ? onTopLevelException : onException,
+       .arg = parentExprSet ? (void*)&exprExceptionContext : this,
+       .isEssential = parentExprSet != nullptr});
 
   if (!rows.hasSelections()) {
     checkOrSetEmptyResult(type(), context.pool(), result);
@@ -793,8 +784,9 @@ void Expr::eval(
   // exception.
   ExprExceptionContext exprExceptionContext{this, context.row(), parentExprSet};
   ExceptionContextSetter exceptionContext(
-      {parentExprSet ? onTopLevelException : onException,
-       parentExprSet ? (void*)&exprExceptionContext : this});
+      {.messageFunc = parentExprSet ? onTopLevelException : onException,
+       .arg = parentExprSet ? (void*)&exprExceptionContext : this,
+       .isEssential = parentExprSet != nullptr});
 
   if (!rows.hasSelections()) {
     checkOrSetEmptyResult(type(), context.pool(), result);
@@ -827,14 +819,18 @@ void Expr::eval(
   //
   // TODO: Re-work the logic of deciding when to load which field.
   if (!hasConditionals_ || distinctFields_.size() == 1 ||
-      shouldEvaluateSharedSubexp()) {
+      shouldEvaluateSharedSubexp(context) ||
+      !context.deferredLazyLoadingEnabled()) {
     // Load lazy vectors if any.
     for (auto* field : distinctFields_) {
       context.ensureFieldLoaded(field->index(context), rows);
     }
-  } else if (!propagatesNulls_) {
-    // Load multiply-referenced fields at common parent expr with "rows".
-    // Delay loading fields that are not in multiplyReferencedFields_.
+  } else if (
+      !propagatesNulls_ && !evaluatesArgumentsOnNonIncreasingSelection()) {
+    // Load multiply-referenced fields at common parent expr with "rows".  Delay
+    // loading fields that are not in multiplyReferencedFields_.  In case
+    // evaluatesArgumentsOnNonIncreasingSelection() is true, this is delayed
+    // until we process the inputs of ConjunctExpr.
     for (const auto& field : multiplyReferencedFields_) {
       context.ensureFieldLoaded(field->index(context), rows);
     }
@@ -857,14 +853,47 @@ void Expr::evaluateSharedSubexpr(
     VectorPtr& result,
     TEval eval) {
   // Captures the inputs referenced by distinctFields_.
-  std::vector<const BaseVector*> expressionInputFields;
+  InputForSharedResults expressionInputFields;
   for (auto* field : distinctFields_) {
-    expressionInputFields.push_back(
-        context.getField(field->index(context)).get());
+    expressionInputFields.addInput(context.getField(field->index(context)));
+  }
+
+  // Find the cached results for the same inputs, or create an entry if one
+  // doesn't exist.
+  auto sharedSubexprResultsIter =
+      sharedSubexprResults_.find(expressionInputFields);
+
+  // If any of the input vector is freed/expired, remove the entry from the
+  // results cache.
+  if (sharedSubexprResultsIter != sharedSubexprResults_.end() &&
+      sharedSubexprResultsIter->first.isExpired()) {
+    sharedSubexprResults_.erase(sharedSubexprResultsIter);
+    VELOX_DCHECK(
+        sharedSubexprResults_.find(expressionInputFields) ==
+        sharedSubexprResults_.end());
+    sharedSubexprResultsIter = sharedSubexprResults_.end();
+  }
+
+  if (sharedSubexprResultsIter == sharedSubexprResults_.end()) {
+    auto maxSharedSubexprResultsCached =
+        context.maxSharedSubexprResultsCached();
+    if (sharedSubexprResults_.size() < maxSharedSubexprResultsCached) {
+      // If we have room left in the cache, add it.
+      sharedSubexprResultsIter =
+          sharedSubexprResults_
+              .insert(
+                  std::pair(std::move(expressionInputFields), SharedResults()))
+              .first;
+    } else {
+      // Otherwise, simply evaluate it and return without caching the results.
+      eval(rows, context, result);
+
+      return;
+    }
   }
 
   auto& [sharedSubexprRows, sharedSubexprValues] =
-      sharedSubexprResults_[expressionInputFields];
+      sharedSubexprResultsIter->second;
 
   if (sharedSubexprValues == nullptr) {
     eval(rows, context, result);
@@ -923,7 +952,16 @@ void Expr::evaluateSharedSubexpr(
   context.deselectErrors(*missingRows);
 
   sharedSubexprRows->select(*missingRows);
-  context.moveOrCopyResult(sharedSubexprValues, rows, result);
+
+  if (context.errors()) {
+    LocalSelectivityVector rowsWithoutErrorsHolder(context, rows);
+    auto* rowsWithoutErrors = rowsWithoutErrorsHolder.get();
+    context.deselectErrors(*rowsWithoutErrors);
+
+    context.moveOrCopyResult(sharedSubexprValues, *rowsWithoutErrors, result);
+  } else {
+    context.moveOrCopyResult(sharedSubexprValues, rows, result);
+  }
 }
 
 SelectivityVector* singleRow(
@@ -937,7 +975,7 @@ SelectivityVector* singleRow(
 
 Expr::PeelEncodingsResult Expr::peelEncodings(
     EvalCtx& context,
-    ScopedContextSaver& saver,
+    ContextSaver& saver,
     const SelectivityVector& rows,
     LocalDecodedVector& localDecoded,
     LocalSelectivityVector& newRowsHolder,
@@ -1000,7 +1038,7 @@ Expr::PeelEncodingsResult Expr::peelEncodings(
 
   // If the expression depends on one dictionary, results are cacheable.
   bool mayCache = false;
-  if (context.cacheEnabled()) {
+  if (context.dictionaryMemoizationEnabled()) {
     mayCache = distinctFields_.size() == 1 &&
         VectorEncoding::isDictionary(context.wrapEncoding()) &&
         !peeledVectors[0]->memoDisabled();
@@ -1015,7 +1053,8 @@ void Expr::evalEncodings(
     const SelectivityVector& rows,
     EvalCtx& context,
     VectorPtr& result) {
-  if (deterministic_ && !skipFieldDependentOptimizations()) {
+  if (deterministic_ && !skipFieldDependentOptimizations() &&
+      context.peelingEnabled()) {
     bool hasFlat = false;
     for (auto* field : distinctFields_) {
       if (isFlat(*context.getField(field->index(context)))) {
@@ -1027,8 +1066,8 @@ void Expr::evalEncodings(
     if (!hasFlat) {
       VectorPtr wrappedResult;
       // Attempt peeling and bound the scope of the context used for it.
-      {
-        ScopedContextSaver saveContext;
+
+      withContextSaver([&](ContextSaver& saveContext) {
         LocalSelectivityVector newRowsHolder(context);
         LocalSelectivityVector finalRowsHolder(context);
         LocalDecodedVector decodedHolder(context);
@@ -1042,9 +1081,9 @@ void Expr::evalEncodings(
         auto* newRows = peelEncodingsResult.newRows;
         if (newRows) {
           VectorPtr peeledResult;
-          // peelEncodings() can potentially produce an empty selectivity vector
-          // if all selected values we are waiting for are nulls. So, here we
-          // check for such a case.
+          // peelEncodings() can potentially produce an empty selectivity
+          // vector if all selected values we are waiting for are nulls. So,
+          // here we check for such a case.
           if (newRows->hasSelections()) {
             if (peelEncodingsResult.mayCache) {
               evalWithMemo(*newRows, context, peeledResult);
@@ -1055,7 +1094,8 @@ void Expr::evalEncodings(
           wrappedResult = context.getPeeledEncoding()->wrap(
               this->type(), context.pool(), peeledResult, rows);
         }
-      }
+      });
+
       if (wrappedResult != nullptr) {
         context.moveOrCopyResult(wrappedResult, rows, result);
         return;
@@ -1080,7 +1120,7 @@ bool Expr::removeSureNulls(
 
     if (values->mayHaveNulls()) {
       LocalDecodedVector decoded(context, *values, rows);
-      if (auto* rawNulls = decoded->nulls()) {
+      if (auto* rawNulls = decoded->nulls(&rows)) {
         if (!result) {
           result = nullHolder.get(rows);
         }
@@ -1091,16 +1131,16 @@ bool Expr::removeSureNulls(
   }
   if (result) {
     result->updateBounds();
-    return true;
+    return result->countSelected() != rows.countSelected();
   }
   return false;
 }
 
 void Expr::addNulls(
     const SelectivityVector& rows,
-    const uint64_t* FOLLY_NULLABLE rawNulls,
+    const uint64_t* rawNulls,
     EvalCtx& context,
-    VectorPtr& result) {
+    VectorPtr& result) const {
   EvalCtx::addNulls(rows, rawNulls, context, type(), result);
 }
 
@@ -1143,81 +1183,96 @@ void Expr::evalWithNulls(
   evalAll(rows, context, result);
 }
 
+// Optimization that attempts to cache results for inputs that are dictionary
+// encoded and use the same base vector between subsequent input batches. Since
+// this hold onto a reference to the base vector and the cached results, it can
+// be memory intensive. Therefore in order to reduce this consumption and ensure
+// it is only employed for cases where it can be useful, it only starts caching
+// result after it encounters the same base at least twice.
 void Expr::evalWithMemo(
     const SelectivityVector& rows,
     EvalCtx& context,
     VectorPtr& result) {
   VectorPtr base;
   distinctFields_[0]->evalSpecialForm(rows, context, base);
-  ++numCachableInput_;
-  if (baseDictionary_ == base) {
-    ++numCacheableRepeats_;
-    if (cachedDictionaryIndices_) {
-      LocalSelectivityVector cachedHolder(context, rows);
-      auto cached = cachedHolder.get();
-      VELOX_DCHECK(cached != nullptr);
-      cached->intersect(*cachedDictionaryIndices_);
-      if (cached->hasSelections()) {
-        context.ensureWritable(rows, type(), result);
-        result->copy(dictionaryCache_.get(), *cached, nullptr);
-      }
-    }
-    LocalSelectivityVector uncachedHolder(context, rows);
-    auto uncached = uncachedHolder.get();
-    VELOX_DCHECK(uncached != nullptr);
-    if (cachedDictionaryIndices_) {
-      uncached->deselect(*cachedDictionaryIndices_);
-    }
-    if (uncached->hasSelections()) {
-      // Fix finalSelection at "rows" if uncached rows is a strict subset to
-      // avoid losing values not in uncached rows that were copied earlier into
-      // "result" from the cached rows.
-      ScopedFinalSelectionSetter scopedFinalSelectionSetter(
-          context, &rows, uncached->countSelected() < rows.countSelected());
-
-      evalWithNulls(*uncached, context, result);
-      context.deselectErrors(*uncached);
-      context.exprSet()->addToMemo(this);
-      auto newCacheSize = uncached->end();
-
-      // dictionaryCache_ is valid only for cachedDictionaryIndices_. Hence, a
-      // safe call to BaseVector::ensureWritable must include all the rows not
-      // covered by cachedDictionaryIndices_. If BaseVector::ensureWritable is
-      // called only for a subset of rows not covered by
-      // cachedDictionaryIndices_, it will attempt to copy rows that are not
-      // valid leading to a crash.
-      LocalSelectivityVector allUncached(context, dictionaryCache_->size());
-      allUncached.get()->setAll();
-      allUncached.get()->deselect(*cachedDictionaryIndices_);
-      context.ensureWritable(*allUncached.get(), type(), dictionaryCache_);
-
-      if (cachedDictionaryIndices_->size() < newCacheSize) {
-        cachedDictionaryIndices_->resize(newCacheSize, false);
-      }
 
-      cachedDictionaryIndices_->select(*uncached);
+  if (base.get() != baseOfDictionaryRawPtr_ ||
+      baseOfDictionaryWeakPtr_.expired()) {
+    baseOfDictionaryRepeats_ = 0;
+    baseOfDictionaryWeakPtr_ = base;
+    baseOfDictionaryRawPtr_ = base.get();
+    context.releaseVector(baseOfDictionary_);
+    context.releaseVector(dictionaryCache_);
+    evalWithNulls(rows, context, result);
+    return;
+  }
+  ++baseOfDictionaryRepeats_;
 
-      // Resize the dictionaryCache_ to accommodate all the necessary rows.
-      if (dictionaryCache_->size() < uncached->end()) {
-        dictionaryCache_->resize(uncached->end());
-      }
-      dictionaryCache_->copy(result.get(), *uncached, nullptr);
+  if (baseOfDictionaryRepeats_ == 1) {
+    evalWithNulls(rows, context, result);
+    baseOfDictionary_ = base;
+    dictionaryCache_ = result;
+    if (!cachedDictionaryIndices_) {
+      cachedDictionaryIndices_ =
+          context.execCtx()->getSelectivityVector(rows.end());
     }
-    context.releaseVector(base);
+    *cachedDictionaryIndices_ = rows;
+    context.deselectErrors(*cachedDictionaryIndices_);
     return;
   }
-  context.releaseVector(baseDictionary_);
-  baseDictionary_ = base;
-  evalWithNulls(rows, context, result);
 
-  context.releaseVector(dictionaryCache_);
-  dictionaryCache_ = result;
-  if (!cachedDictionaryIndices_) {
-    cachedDictionaryIndices_ =
-        context.execCtx()->getSelectivityVector(rows.end());
+  if (cachedDictionaryIndices_) {
+    LocalSelectivityVector cachedHolder(context, rows);
+    auto cached = cachedHolder.get();
+    VELOX_DCHECK(cached != nullptr);
+    cached->intersect(*cachedDictionaryIndices_);
+    if (cached->hasSelections()) {
+      context.ensureWritable(rows, type(), result);
+      result->copy(dictionaryCache_.get(), *cached, nullptr);
+    }
+  }
+  LocalSelectivityVector uncachedHolder(context, rows);
+  auto uncached = uncachedHolder.get();
+  VELOX_DCHECK(uncached != nullptr);
+  if (cachedDictionaryIndices_) {
+    uncached->deselect(*cachedDictionaryIndices_);
+  }
+  if (uncached->hasSelections()) {
+    // Fix finalSelection at "rows" if uncached rows is a strict subset to
+    // avoid losing values not in uncached rows that were copied earlier into
+    // "result" from the cached rows.
+    ScopedFinalSelectionSetter scopedFinalSelectionSetter(
+        context, &rows, uncached->countSelected() < rows.countSelected());
+
+    evalWithNulls(*uncached, context, result);
+    context.deselectErrors(*uncached);
+    context.exprSet()->addToMemo(this);
+    auto newCacheSize = uncached->end();
+
+    // dictionaryCache_ is valid only for cachedDictionaryIndices_. Hence, a
+    // safe call to BaseVector::ensureWritable must include all the rows not
+    // covered by cachedDictionaryIndices_. If BaseVector::ensureWritable is
+    // called only for a subset of rows not covered by
+    // cachedDictionaryIndices_, it will attempt to copy rows that are not
+    // valid leading to a crash.
+    LocalSelectivityVector allUncached(context, dictionaryCache_->size());
+    allUncached.get()->setAll();
+    allUncached.get()->deselect(*cachedDictionaryIndices_);
+    context.ensureWritable(*allUncached.get(), type(), dictionaryCache_);
+
+    if (cachedDictionaryIndices_->size() < newCacheSize) {
+      cachedDictionaryIndices_->resize(newCacheSize, false);
+    }
+
+    cachedDictionaryIndices_->select(*uncached);
+
+    // Resize the dictionaryCache_ to accommodate all the necessary rows.
+    if (dictionaryCache_->size() < uncached->end()) {
+      dictionaryCache_->resize(uncached->end());
+    }
+    dictionaryCache_->copy(result.get(), *uncached, nullptr);
   }
-  *cachedDictionaryIndices_ = rows;
-  context.deselectErrors(*cachedDictionaryIndices_);
+  context.releaseVector(base);
 }
 
 void Expr::setAllNulls(
@@ -1259,6 +1314,8 @@ void computeIsAsciiForInputs(
         inputValues[index]->type()->kind() == TypeKind::VARCHAR) {
       auto* vector =
           inputValues[index]->template as<SimpleVector<StringView>>();
+
+      VELOX_CHECK(vector, inputValues[index]->toString());
       vector->computeAndSetIsAscii(rows);
     }
   }
@@ -1324,7 +1381,7 @@ void Expr::evalAll(
     return;
   }
 
-  if (shouldEvaluateSharedSubexp()) {
+  if (shouldEvaluateSharedSubexp(context)) {
     evaluateSharedSubexpr(
         rows,
         context,
@@ -1338,7 +1395,7 @@ void Expr::evalAll(
 }
 
 bool Expr::throwArgumentErrors(const EvalCtx& context) const {
-  bool defaultNulls = vectorFunction_->isDefaultNullBehavior();
+  bool defaultNulls = vectorFunctionMetadata_.defaultNullBehavior;
   return context.throwOnError() &&
       (!defaultNulls ||
        (supportsFlatNoNullsFastPath() && context.inputFlatNoNulls()));
@@ -1355,7 +1412,7 @@ void Expr::evalAllImpl(
     return;
   }
   bool tryPeelArgs = deterministic_ ? true : false;
-  bool defaultNulls = vectorFunction_->isDefaultNullBehavior();
+  bool defaultNulls = vectorFunctionMetadata_.defaultNullBehavior;
 
   // Tracks what subset of rows shall un-evaluated inputs and current expression
   // evaluates. Initially points to rows.
@@ -1393,39 +1450,35 @@ void Expr::evalAllImpl(
 
   // Write non-selected rows in remainingRows as nulls in the result if some
   // rows have been skipped.
-  if (remainingRows.mayHaveChanged()) {
+  if (remainingRows.hasChanged()) {
     addNulls(rows, remainingRows.rows().asRange().bits(), context, result);
   }
   releaseInputValues(context);
 }
 
-namespace {
-void setPeeledArg(
-    VectorPtr arg,
-    int32_t index,
-    int32_t numArgs,
-    std::vector<VectorPtr>& peeledArgs) {
-  if (peeledArgs.empty()) {
-    peeledArgs.resize(numArgs);
-  }
-  peeledArgs[index] = arg;
-}
-} // namespace
-
 bool Expr::applyFunctionWithPeeling(
     const SelectivityVector& applyRows,
     EvalCtx& context,
     VectorPtr& result) {
   LocalDecodedVector localDecoded(context);
   LocalSelectivityVector newRowsHolder(context);
-  ScopedContextSaver saver;
+  if (!context.peelingEnabled()) {
+    if (inputValues_.size() == 1) {
+      // If we have a single input, velox needs to ensure that the
+      // vectorFunction would receive a flat input.
+      BaseVector::flattenVector(inputValues_[0]);
+      applyFunction(applyRows, context, result);
+      return true;
+    }
+    return false;
+  }
   // Attempt peeling.
   std::vector<VectorPtr> peeledVectors;
   auto peeledEncoding = PeeledEncoding::peel(
       inputValues_,
       applyRows,
       localDecoded,
-      vectorFunction_->isDefaultNullBehavior(),
+      vectorFunctionMetadata_.defaultNullBehavior,
       peeledVectors);
   if (!peeledEncoding) {
     return false;
@@ -1439,21 +1492,23 @@ bool Expr::applyFunctionWithPeeling(
   // pre-existing rows need to be preserved.
   auto newRows = peeledEncoding->translateToInnerRows(applyRows, newRowsHolder);
 
-  // Save context and set the peel.
-  context.saveAndReset(saver, applyRows);
-  context.setPeeledEncoding(peeledEncoding);
-
-  // Apply the function.
-  VectorPtr peeledResult;
-  applyFunction(*newRows, context, peeledResult);
-  VectorPtr wrappedResult = context.getPeeledEncoding()->wrap(
-      this->type(), context.pool(), peeledResult, applyRows);
-  context.moveOrCopyResult(wrappedResult, applyRows, result);
-
-  // Recycle peeledResult if it's not owned by the result vector. Examples of
-  // when this can happen is when the result is a primitive constant vector, or
-  // when moveOrCopyResult copies wrappedResult content.
-  context.releaseVector(peeledResult);
+  withContextSaver([&](ContextSaver& saver) {
+    // Save context and set the peel.
+    context.saveAndReset(saver, applyRows);
+    context.setPeeledEncoding(peeledEncoding);
+
+    // Apply the function.
+    VectorPtr peeledResult;
+    applyFunction(*newRows, context, peeledResult);
+    VectorPtr wrappedResult = context.getPeeledEncoding()->wrap(
+        this->type(), context.pool(), peeledResult, applyRows);
+    context.moveOrCopyResult(wrappedResult, applyRows, result);
+
+    // Recycle peeledResult if it's not owned by the result vector. Examples of
+    // when this can happen is when the result is a primitive constant vector,
+    // or when moveOrCopyResult copies wrappedResult content.
+    context.releaseVector(peeledResult);
+  });
 
   return true;
 }
@@ -1473,7 +1528,7 @@ void Expr::applyFunction(
 
   try {
     vectorFunction_->apply(rows, inputValues_, type(), context, result);
-  } catch (const VeloxException& ve) {
+  } catch (const VeloxException&) {
     throw;
   } catch (const std::exception& e) {
     VELOX_USER_FAIL(e.what());
@@ -1490,7 +1545,7 @@ void Expr::applyFunction(
         // should only apply when the UDF is buggy (hopefully rarely).
         VELOX_USER_FAIL(
             "Function neither returned results nor threw exception.");
-      } catch (const std::exception& e) {
+      } catch (const std::exception&) {
         context.setErrors(remainingRows.rows(), std::current_exception());
       }
     }
@@ -1606,7 +1661,7 @@ bool Expr::isConstant() const {
     return false;
   }
   for (auto& input : inputs_) {
-    if (!dynamic_cast<ConstantExpr*>(input.get())) {
+    if (!input->is<ConstantExpr>()) {
       return false;
     }
   }
@@ -1709,7 +1764,7 @@ ExprSet::ExprSet(
   exprs_ = compileExpressions(sources, execCtx, this, enableConstantFolding);
   std::vector<FieldReference*> allDistinctFields;
   for (auto& expr : exprs_) {
-    mergeFields(
+    Expr::mergeFields(
         distinctFields_, multiplyReferencedFields_, expr->distinctFields());
   }
 }
@@ -1758,15 +1813,19 @@ ExprSet::~ExprSet() {
       auto exprStats = stats();
 
       std::vector<std::string> sqls;
+      std::vector<VectorPtr> complexConstants;
       for (const auto& expr : exprs()) {
         try {
-          sqls.emplace_back(expr->toSql());
+          sqls.emplace_back(expr->toSql(&complexConstants));
         } catch (const std::exception& e) {
           LOG_EVERY_N(WARNING, 100) << "Failed to generate SQL: " << e.what();
           sqls.emplace_back("<failed to generate>");
         }
       }
 
+      // TODO Enhance listener API to allow passing 'complexConstants' in
+      // addition to SQL.
+
       auto uuid = makeUuid();
       for (const auto& listener : listeners) {
         listener->onCompletion(
diff --git a/velox/expression/Expr.h b/velox/expression/Expr.h
index 90db16dbf1876..ade47d61f8b00 100644
--- a/velox/expression/Expr.h
+++ b/velox/expression/Expr.h
@@ -119,13 +119,12 @@ class MutableRemainingRows {
     return mutableRows_->hasSelections();
   }
 
-  /// @return true if current set of rows might be different from the original
+  /// @return true if current set of rows is different from the original
   /// set of rows, which may happen if deselectNull() or deselectErrors() were
-  /// called. May return 'true' even if current set of rows is the same as
-  /// original set. Returns 'false' only if current set of rows is for sure the
-  /// same as original.
-  bool mayHaveChanged() const {
-    return mutableRows_ != nullptr && !mutableRows_->isAllSelected();
+  /// called.
+  bool hasChanged() const {
+    return mutableRows_ != nullptr &&
+        mutableRows_->countSelected() != originalRows_->countSelected();
   }
 
  private:
@@ -167,6 +166,7 @@ class Expr {
       TypePtr type,
       std::vector<std::shared_ptr<Expr>>&& inputs,
       std::shared_ptr<VectorFunction> vectorFunction,
+      VectorFunctionMetadata metadata,
       std::string name,
       bool trackCpuUsage);
 
@@ -182,7 +182,7 @@ class Expr {
       const SelectivityVector& rows,
       EvalCtx& context,
       VectorPtr& result,
-      const ExprSet* FOLLY_NULLABLE parentExprSet = nullptr);
+      const ExprSet* parentExprSet = nullptr);
 
   /// Evaluates the expression using fast path that assumes all inputs and
   /// intermediate results are flat or constant and have no nulls.
@@ -201,13 +201,13 @@ class Expr {
       const SelectivityVector& rows,
       EvalCtx& context,
       VectorPtr& result,
-      const ExprSet* FOLLY_NULLABLE parentExprSet = nullptr);
+      const ExprSet* parentExprSet = nullptr);
 
   void evalFlatNoNullsImpl(
       const SelectivityVector& rows,
       EvalCtx& context,
       VectorPtr& result,
-      const ExprSet* FOLLY_NULLABLE parentExprSet);
+      const ExprSet* parentExprSet);
 
   // Simplified path for expression evaluation (flattens all vectors).
   void evalSimplified(
@@ -239,12 +239,22 @@ class Expr {
   // sameAsParentDistinctFields_.
   void computeMetadata();
 
+  // Utility function to add fields to both distinct and multiply referenced
+  // fields.
+  static void mergeFields(
+      std::vector<FieldReference*>& distinctFields,
+      std::unordered_set<FieldReference*>& multiplyReferencedFields,
+      const std::vector<FieldReference*>& fieldsToAdd);
+
   virtual void reset() {
     sharedSubexprResults_.clear();
   }
 
   void clearMemo() {
-    baseDictionary_ = nullptr;
+    baseOfDictionaryRepeats_ = 0;
+    baseOfDictionary_.reset();
+    baseOfDictionaryWeakPtr_.reset();
+    baseOfDictionaryRawPtr_ = nullptr;
     dictionaryCache_ = nullptr;
     cachedDictionaryIndices_ = nullptr;
   }
@@ -269,6 +279,10 @@ class Expr {
     return false;
   }
 
+  bool hasConditionals() const {
+    return hasConditionals_;
+  }
+
   bool isDeterministic() const {
     return deterministic_;
   }
@@ -287,6 +301,16 @@ class Expr {
     isMultiplyReferenced_ = true;
   }
 
+  /// True if this is a special form where the next argument will always be
+  /// evaluated on a subset of the rows for which the previous one was
+  /// evaluated.  This is true of AND and no other at this time.  This implies
+  /// that lazies can be loaded on first use and not before starting evaluating
+  /// the form.  This is so because a subsequent use will never access rows that
+  /// were not in scope for the previous one.
+  virtual bool evaluatesArgumentsOnNonIncreasingSelection() const {
+    return false;
+  }
+
   std::vector<common::Subfield> extractSubfields() const;
 
   virtual void extractSubfieldsImpl(
@@ -343,7 +367,7 @@ class Expr {
   /// expressable as sql. If not given, they will be converted to
   /// SQL-expressable simple constants.
   virtual std::string toSql(
-      std::vector<VectorPtr>* FOLLY_NULLABLE complexConstants = nullptr) const;
+      std::vector<VectorPtr>* complexConstants = nullptr) const;
 
   const ExprStats& stats() const {
     return stats_;
@@ -351,14 +375,18 @@ class Expr {
 
   void addNulls(
       const SelectivityVector& rows,
-      const uint64_t* FOLLY_NULLABLE rawNulls,
+      const uint64_t* rawNulls,
       EvalCtx& context,
-      VectorPtr& result);
+      VectorPtr& result) const;
 
-  auto& vectorFunction() const {
+  const std::shared_ptr<VectorFunction>& vectorFunction() const {
     return vectorFunction_;
   }
 
+  const VectorFunctionMetadata& vectorFunctionMetadata() const {
+    return vectorFunctionMetadata_;
+  }
+
   auto& inputValues() {
     return inputValues_;
   }
@@ -387,8 +415,8 @@ class Expr {
 
  private:
   struct PeelEncodingsResult {
-    SelectivityVector* FOLLY_NULLABLE newRows;
-    SelectivityVector* FOLLY_NULLABLE newFinalSelection;
+    SelectivityVector* newRows;
+    SelectivityVector* newFinalSelection;
     bool mayCache;
 
     static PeelEncodingsResult empty() {
@@ -398,7 +426,7 @@ class Expr {
 
   PeelEncodingsResult peelEncodings(
       EvalCtx& context,
-      ScopedContextSaver& saver,
+      ContextSaver& saver,
       const SelectivityVector& rows,
       LocalDecodedVector& localDecoded,
       LocalSelectivityVector& newRowsHolder,
@@ -458,8 +486,9 @@ class Expr {
   /// Evaluation of such expression is optimized by memoizing and reusing
   /// the results of prior evaluations. That logic is implemented in
   /// 'evaluateSharedSubexpr'.
-  bool shouldEvaluateSharedSubexp() const {
-    return deterministic_ && isMultiplyReferenced_ && !inputs_.empty();
+  bool shouldEvaluateSharedSubexp(EvalCtx& context) const {
+    return deterministic_ && isMultiplyReferenced_ && !inputs_.empty() &&
+        context.sharedSubExpressionReuseEnabled();
   }
 
   /// Evaluate common sub-expression. Check if sharedSubexprValues_ already has
@@ -491,7 +520,7 @@ class Expr {
 
   void appendInputsSql(
       std::stringstream& stream,
-      std::vector<VectorPtr>* FOLLY_NULLABLE complexConstants) const;
+      std::vector<VectorPtr>* complexConstants) const;
 
   /// Release 'inputValues_' back to vector pool in 'evalCtx' so they can be
   /// reused.
@@ -537,10 +566,16 @@ class Expr {
                           : nullptr;
   }
 
+  // Should be called only after computeMetadata() has been called on 'inputs_'.
+  // Computes distinctFields for this expression. Also updates any multiply
+  // referenced fields.
+  virtual void computeDistinctFields();
+
   const TypePtr type_;
   const std::vector<std::shared_ptr<Expr>> inputs_;
   const std::string name_;
   const std::shared_ptr<VectorFunction> vectorFunction_;
+  const VectorFunctionMetadata vectorFunctionMetadata_;
   const bool specialForm_;
   const bool supportsFlatNoNullsFastPath_;
   const bool trackCpuUsage_;
@@ -574,6 +609,37 @@ class Expr {
 
   std::vector<VectorPtr> inputValues_;
 
+  /// Represents a set of inputs referenced by 'distinctFields_' that are
+  /// captured when the 'evaluateSharedSubexpr()' method is called on a shared
+  /// sub-expression. The purpose of this class is to ensure that cached
+  /// results are re-used for the correct set of live input vectors.
+  class InputForSharedResults {
+   public:
+    void addInput(const std::shared_ptr<BaseVector>& input) {
+      inputVectors_.push_back(input.get());
+      inputWeakVectors_.push_back(input);
+    }
+
+    bool operator<(const InputForSharedResults& other) const {
+      return inputVectors_ < other.inputVectors_;
+    }
+
+    bool isExpired() const {
+      for (const auto& input : inputWeakVectors_) {
+        if (input.expired()) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+   private:
+    // Used as a key in a map that keeps track of cached results.
+    std::vector<const BaseVector*> inputVectors_;
+    // Used to check if inputs have expired.
+    std::vector<std::weak_ptr<BaseVector>> inputWeakVectors_;
+  };
+
   struct SharedResults {
     // The rows for which 'sharedSubexprValues_' has a value.
     std::unique_ptr<SelectivityVector> sharedSubexprRows_ = nullptr;
@@ -583,24 +649,31 @@ class Expr {
 
   // Maps the inputs referenced by distinctFields_ captuered when
   // evaluateSharedSubexpr() is called to the cached shared results.
-  std::map<std::vector<const BaseVector*>, SharedResults> sharedSubexprResults_;
+  std::map<InputForSharedResults, SharedResults> sharedSubexprResults_;
+
+  // Pointers to the last base vector of cachable dictionary input. Used to
+  // check if the current input's base vector is the same as the last. If it's
+  // the same, then results can be cached.
+  std::weak_ptr<BaseVector> baseOfDictionaryWeakPtr_;
+  BaseVector* baseOfDictionaryRawPtr_ = nullptr;
+
+  // This is a strong reference to the base vector and is only set if
+  // `baseOfDictionaryRepeats_` > 1. This is to ensure that the vector held is
+  // not modified and re-used in-place.
+  VectorPtr baseOfDictionary_;
 
-  VectorPtr baseDictionary_;
+  // Number of times currently held cacheable vector is seen for a non-first
+  // time. Is reset everytime 'baseOfDictionaryRawPtr_' is different from the
+  // current input's base.
+  int baseOfDictionaryRepeats_ = 0;
 
   // Values computed for the base dictionary, 1:1 to the positions in
-  // 'baseDictionary_'.
+  // 'baseOfDictionaryRawPtr_'.
   VectorPtr dictionaryCache_;
 
   // The indices that are valid in 'dictionaryCache_'.
   std::unique_ptr<SelectivityVector> cachedDictionaryIndices_;
 
-  // Count of executions where this is wrapped in a dictionary so that
-  // results could be cached.
-  int32_t numCachableInput_{0};
-
-  // Count of times the cacheable vector is seen for a non-first time.
-  int32_t numCacheableRepeats_{0};
-
   /// Runtime statistics. CPU time, wall time and number of processed rows.
   ExprStats stats_;
 
@@ -633,7 +706,7 @@ class ExprSet {
  public:
   explicit ExprSet(
       const std::vector<core::TypedExprPtr>& source,
-      core::ExecCtx* FOLLY_NONNULL execCtx,
+      core::ExecCtx* execCtx,
       bool enableConstantFolding = true);
 
   virtual ~ExprSet();
@@ -657,7 +730,7 @@ class ExprSet {
 
   void clear();
 
-  core::ExecCtx* FOLLY_NULLABLE execCtx() const {
+  core::ExecCtx* execCtx() const {
     return execCtx_;
   }
 
@@ -684,7 +757,7 @@ class ExprSet {
   }
 
   // Flags an expression that remembers the results for a dictionary.
-  void addToMemo(Expr* FOLLY_NONNULL expr) {
+  void addToMemo(Expr* expr) {
     memoizingExprs_.insert(expr);
   }
 
@@ -717,14 +790,14 @@ class ExprSet {
 
   // Exprs which retain memoized state, e.g. from running over dictionaries.
   std::unordered_set<Expr*> memoizingExprs_;
-  core::ExecCtx* FOLLY_NONNULL const execCtx_;
+  core::ExecCtx* const execCtx_;
 };
 
 class ExprSetSimplified : public ExprSet {
  public:
   ExprSetSimplified(
       const std::vector<core::TypedExprPtr>& source,
-      core::ExecCtx* FOLLY_NONNULL execCtx)
+      core::ExecCtx* execCtx)
       : ExprSet(source, execCtx, /*enableConstantFolding*/ false) {}
 
   virtual ~ExprSetSimplified() override {}
@@ -750,7 +823,7 @@ class ExprSetSimplified : public ExprSet {
 // account and instantiates the correct ExprSet class.
 std::unique_ptr<ExprSet> makeExprSetFromFlag(
     std::vector<core::TypedExprPtr>&& source,
-    core::ExecCtx* FOLLY_NONNULL execCtx);
+    core::ExecCtx* execCtx);
 
 /// Returns a string representation of the expression trees annotated with
 /// runtime statistics. Expected to be called after calling ExprSet::eval one or
@@ -782,14 +855,10 @@ class ExprSetListener {
       const ExprSetCompletionEvent& event) = 0;
 
   /// Called when a batch of rows encounters errors processing one or more
-  /// rows in a try expression to provide information about these errors. This
-  /// function must neither change rows nor errors.
-  /// @param rows Rows where errors exist.
-  /// @param errors Error vector produced inside the try expression.
-  virtual void onError(
-      const SelectivityVector& rows,
-      const ErrorVector& errors,
-      const std::string& queryId) = 0;
+  /// rows in a try expression to provide information about these errors.
+  /// @param numRows Number of rows with errors.
+  /// @param queryId Query ID.
+  virtual void onError(vector_size_t numRows, const std::string& queryId) = 0;
 };
 
 /// Return the ExprSetListeners having been registered.
diff --git a/velox/expression/ExprCompiler.cpp b/velox/expression/ExprCompiler.cpp
index 27ea1c9154e44..aa9eae5451feb 100644
--- a/velox/expression/ExprCompiler.cpp
+++ b/velox/expression/ExprCompiler.cpp
@@ -188,9 +188,9 @@ std::vector<ExprPtr> compileInputs(
       if (flattenIf.has_value()) {
         std::vector<TypedExprPtr> flat;
         flattenInput(input, flattenIf.value(), flat);
-        for (auto& input : flat) {
+        for (auto& input_2 : flat) {
           compiledInputs.push_back(compileExpression(
-              input,
+              input_2,
               scope,
               config,
               pool,
@@ -393,22 +393,22 @@ ExprPtr compileRewrittenExpression(
         trackCpuUsage);
   } else if (auto cast = dynamic_cast<const core::CastTypedExpr*>(expr.get())) {
     VELOX_CHECK(!compiledInputs.empty());
-    auto castExpr = std::make_shared<CastExpr>(
-        resultType,
-        std::move(compiledInputs[0]),
-        trackCpuUsage,
-        cast->nullOnFailure());
-    result = castExpr;
+    if (FOLLY_UNLIKELY(*resultType == *compiledInputs[0]->type())) {
+      result = compiledInputs[0];
+    } else {
+      result = getSpecialForm(
+          config,
+          cast->nullOnFailure() ? "try_cast" : "cast",
+          resultType,
+          std::move(compiledInputs),
+          trackCpuUsage);
+    }
   } else if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
-    if (auto specialForm = getSpecialForm(
-            config,
-            call->name(),
-            resultType,
-            std::move(compiledInputs),
-            trackCpuUsage)) {
-      result = specialForm;
+    if (auto specialForm = specialFormRegistry().getSpecialForm(call->name())) {
+      result = specialForm->constructSpecialForm(
+          resultType, std::move(compiledInputs), trackCpuUsage, config);
     } else if (
-        auto func = getVectorFunction(
+        auto functionWithMetadata = getVectorFunctionWithMetadata(
             call->name(),
             inputTypes,
             getConstantInputs(compiledInputs),
@@ -416,7 +416,8 @@ ExprPtr compileRewrittenExpression(
       result = std::make_shared<Expr>(
           resultType,
           std::move(compiledInputs),
-          func,
+          functionWithMetadata->first,
+          functionWithMetadata->second,
           call->name(),
           trackCpuUsage);
     } else if (
@@ -430,12 +431,14 @@ ExprPtr compileRewrittenExpression(
           simpleFunctionEntry->type(),
           resultType,
           folly::join(", ", inputTypes));
+
       auto func = simpleFunctionEntry->createFunction()->createVectorFunction(
-          getConstantInputs(compiledInputs), config);
+          inputTypes, getConstantInputs(compiledInputs), config);
       result = std::make_shared<Expr>(
           resultType,
           std::move(compiledInputs),
           std::move(func),
+          simpleFunctionEntry->metadata(),
           call->name(),
           trackCpuUsage);
     } else {
diff --git a/velox/expression/ExprToSubfieldFilter.cpp b/velox/expression/ExprToSubfieldFilter.cpp
index b859ccff1e7b2..f876c5de3fa84 100644
--- a/velox/expression/ExprToSubfieldFilter.cpp
+++ b/velox/expression/ExprToSubfieldFilter.cpp
@@ -67,11 +67,11 @@ bool toSubfield(const core::ITypedExpr* field, common::Subfield& subfield) {
       const auto& name = dereference->name();
       // When the field name is empty string, it typically means that the field
       // name was not set in the parent type.
-      if (name == "") {
+      if (name.empty()) {
         return false;
       }
       path.push_back(std::make_unique<common::Subfield::NestedField>(name));
-    } else if (!dynamic_cast<const core::InputTypedExpr*>(current)) {
+    } else if (dynamic_cast<const core::InputTypedExpr*>(current) == nullptr) {
       return false;
     } else {
       break;
@@ -84,7 +84,7 @@ bool toSubfield(const core::ITypedExpr* field, common::Subfield& subfield) {
       return false;
     }
     current = current->inputs()[0].get();
-    if (!current) {
+    if (current == nullptr) {
       return false;
     }
   }
@@ -336,8 +336,7 @@ std::unique_ptr<common::Filter> makeNotEqualFilter(
     std::vector<std::unique_ptr<common::Filter>> filters;
     filters.emplace_back(std::move(lessThanFilter));
     filters.emplace_back(std::move(greaterThanFilter));
-    return std::make_unique<common::MultiRange>(
-        std::move(filters), false, false);
+    return std::make_unique<common::MultiRange>(std::move(filters), false);
   }
 }
 
diff --git a/velox/expression/ExprToSubfieldFilter.h b/velox/expression/ExprToSubfieldFilter.h
index 193e3413ea25a..f87d28e2530bc 100644
--- a/velox/expression/ExprToSubfieldFilter.h
+++ b/velox/expression/ExprToSubfieldFilter.h
@@ -320,16 +320,12 @@ inline std::unique_ptr<common::IsNotNull> isNotNull() {
 }
 
 template <typename T>
-std::unique_ptr<common::MultiRange> orFilter(
-    std::unique_ptr<T> a,
-    std::unique_ptr<T> b,
-    bool nullAllowed = false,
-    bool nanAllowed = false) {
+std::unique_ptr<common::MultiRange>
+orFilter(std::unique_ptr<T> a, std::unique_ptr<T> b, bool nullAllowed = false) {
   std::vector<std::unique_ptr<common::Filter>> filters;
   filters.emplace_back(std::move(a));
   filters.emplace_back(std::move(b));
-  return std::make_unique<common::MultiRange>(
-      std::move(filters), nullAllowed, nanAllowed);
+  return std::make_unique<common::MultiRange>(std::move(filters), nullAllowed);
 }
 
 inline std::unique_ptr<common::HugeintRange> lessThanHugeint(
diff --git a/velox/expression/FieldReference.cpp b/velox/expression/FieldReference.cpp
index e2e169d862009..f68678a2e50ea 100644
--- a/velox/expression/FieldReference.cpp
+++ b/velox/expression/FieldReference.cpp
@@ -20,29 +20,14 @@
 
 namespace facebook::velox::exec {
 
-// Fast path to avoid copying result.  An alternative way to do this is to
-// ensure that children has null if parent has nulls on corresponding rows,
-// whenever the RowVector is constructed or mutated (eager propagation of
-// nulls).  The current lazy propagation might still be better (more efficient)
-// when adding extra nulls.
-bool FieldReference::addNullsFast(
-    const SelectivityVector& rows,
-    EvalCtx& context,
-    VectorPtr& result,
-    const RowVector* row) {
-  if (result) {
-    return false;
-  }
-  auto& child =
-      inputs_.empty() ? context.getField(index_) : row->childAt(index_);
-  if (row->mayHaveNulls()) {
-    if (!child.unique()) {
-      return false;
-    }
-    addNulls(rows, row->rawNulls(), context, const_cast<VectorPtr&>(child));
+void FieldReference::computeDistinctFields() {
+  SpecialForm::computeDistinctFields();
+  if (inputs_.empty()) {
+    mergeFields(
+        distinctFields_,
+        multiplyReferencedFields_,
+        {this->as<FieldReference>()});
   }
-  result = child;
-  return true;
 }
 
 void FieldReference::apply(
@@ -61,25 +46,14 @@ void FieldReference::apply(
   } else {
     inputs_[0]->eval(rows, context, input);
 
-    if (auto rowTry = input->as<RowVector>()) {
-      // Make sure output is not copied
-      if (rowTry->isCodegenOutput()) {
-        auto rowType = dynamic_cast<const RowType*>(rowTry->type().get());
-        index_ = rowType->getChildIdx(field_);
-        result = std::move(rowTry->childAt(index_));
-        VELOX_CHECK(result.unique());
-        return;
-      }
-    }
-
     decoded.decode(*input, rows);
     if (decoded.mayHaveNulls()) {
       nonNullRowsHolder.get(rows);
       nonNullRowsHolder->deselectNulls(
-          decoded.nulls(), rows.begin(), rows.end());
+          decoded.nulls(&rows), rows.begin(), rows.end());
       nonNullRows = nonNullRowsHolder.get();
       if (!nonNullRows->hasSelections()) {
-        addNulls(rows, decoded.nulls(), context, result);
+        addNulls(rows, decoded.nulls(&rows), context, result);
         return;
       }
     }
@@ -106,9 +80,6 @@ void FieldReference::apply(
     VELOX_CHECK(rowType);
     index_ = rowType->getChildIdx(field_);
   }
-  if (!useDecode && addNullsFast(rows, context, result, row)) {
-    return;
-  }
   VectorPtr child =
       inputs_.empty() ? context.getField(index_) : row->childAt(index_);
   if (child->encoding() == VectorEncoding::Simple::LAZY) {
@@ -134,7 +105,7 @@ void FieldReference::apply(
 
   // Check for nulls in the input struct. Propagate these nulls to 'result'.
   if (!inputs_.empty() && decoded.mayHaveNulls()) {
-    addNulls(rows, decoded.nulls(), context, result);
+    addNulls(rows, decoded.nulls(&rows), context, result);
   }
 }
 
diff --git a/velox/expression/FieldReference.h b/velox/expression/FieldReference.h
index 5d86afa93cc38..ed1b12bc2c15d 100644
--- a/velox/expression/FieldReference.h
+++ b/velox/expression/FieldReference.h
@@ -79,16 +79,13 @@ class FieldReference : public SpecialForm {
   std::string toSql(
       std::vector<VectorPtr>* complexConstants = nullptr) const override;
 
+ protected:
+  void computeDistinctFields() override;
+
  private:
   void
   apply(const SelectivityVector& rows, EvalCtx& context, VectorPtr& result);
 
-  bool addNullsFast(
-      const SelectivityVector& rows,
-      EvalCtx& context,
-      VectorPtr& result,
-      const RowVector* row);
-
   const std::string field_;
   int32_t index_ = -1;
 };
diff --git a/velox/expression/FunctionMetadata.h b/velox/expression/FunctionMetadata.h
new file mode 100644
index 0000000000000..bc354110b9557
--- /dev/null
+++ b/velox/expression/FunctionMetadata.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+namespace facebook::velox::exec {
+
+struct VectorFunctionMetadata {
+  /// Boolean indicating whether this function supports flattening, i.e.
+  /// converting a set of nested calls into a single call.
+  ///
+  ///     f(a, f(b, f(c, d))) => f(a, b, c, d).
+  ///
+  /// For example, concat(string,...), concat(array,...), map_concat(map,...)
+  /// Presto functions support flattening. Similarly, built-in special format
+  /// AND and OR also support flattening.
+  ///
+  /// A function that supports flattening must have a signature with variadic
+  /// arguments of the same type. The result type must be the same as input
+  /// type.
+  bool supportsFlattening{false};
+
+  /// True if the function is deterministic, e.g given same inputs always
+  /// returns same result.
+  bool deterministic{true};
+
+  /// True if null in any argument always produces null result.
+  /// In this case, 'rows' in VectorFunction::apply will point only to positions
+  /// for which all arguments are not null.
+  bool defaultNullBehavior{true};
+};
+
+class VectorFunctionMetadataBuilder {
+ public:
+  VectorFunctionMetadataBuilder& supportsFlattening(bool supportsFlattening) {
+    metadata_.supportsFlattening = supportsFlattening;
+    return *this;
+  }
+
+  VectorFunctionMetadataBuilder& deterministic(bool deterministic) {
+    metadata_.deterministic = deterministic;
+    return *this;
+  }
+
+  VectorFunctionMetadataBuilder& defaultNullBehavior(bool defaultNullBehavior) {
+    metadata_.defaultNullBehavior = defaultNullBehavior;
+    return *this;
+  }
+
+  const VectorFunctionMetadata& build() const {
+    return metadata_;
+  }
+
+ private:
+  VectorFunctionMetadata metadata_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/FunctionSignature.cpp b/velox/expression/FunctionSignature.cpp
index d061002bd2518..a1460f1355a94 100644
--- a/velox/expression/FunctionSignature.cpp
+++ b/velox/expression/FunctionSignature.cpp
@@ -51,21 +51,6 @@ const std::vector<std::string> primitiveTypeNames() {
   return kPrimitiveTypeNames;
 }
 
-void toAppend(
-    const facebook::velox::exec::TypeSignature& signature,
-    std::string* result) {
-  result->append(signature.toString());
-}
-
-std::string TypeSignature::toString() const {
-  std::ostringstream out;
-  out << baseName_;
-  if (!parameters_.empty()) {
-    out << "(" << folly::join(",", parameters_) << ")";
-  }
-  return out.str();
-}
-
 std::string FunctionSignature::argumentsToString() const {
   std::vector<std::string> arguments;
   auto size = argumentTypes_.size();
@@ -107,38 +92,6 @@ size_t findNextComma(const std::string& str, size_t start) {
   return std::string::npos;
 }
 
-TypeSignature parseTypeSignature(const std::string& signature) {
-  auto parenPos = signature.find('(');
-  if (parenPos == std::string::npos) {
-    return TypeSignature(signature, {});
-  }
-
-  auto baseName = signature.substr(0, parenPos);
-  std::vector<TypeSignature> nestedTypes;
-
-  auto endParenPos = signature.rfind(')');
-  VELOX_CHECK(
-      endParenPos != std::string::npos,
-      "Couldn't find the closing parenthesis.");
-
-  auto prevPos = parenPos + 1;
-  auto commaPos = findNextComma(signature, prevPos);
-  while (commaPos != std::string::npos) {
-    auto token = signature.substr(prevPos, commaPos - prevPos);
-    boost::algorithm::trim(token);
-    nestedTypes.emplace_back(parseTypeSignature(token));
-
-    prevPos = commaPos + 1;
-    commaPos = findNextComma(signature, prevPos);
-  }
-
-  auto token = signature.substr(prevPos, endParenPos - prevPos);
-  boost::algorithm::trim(token);
-  nestedTypes.emplace_back(parseTypeSignature(token));
-
-  return TypeSignature(baseName, std::move(nestedTypes));
-}
-
 namespace {
 /// Returns true only if 'str' contains digits.
 bool isPositiveInteger(const std::string& str) {
@@ -161,14 +114,14 @@ void validateBaseTypeAndCollectTypeParams(
           !isReturnType, "Type 'Any' cannot appear in return type");
 
       VELOX_USER_CHECK(
-          arg.parameters().empty(), "Type 'Any' cannot have parameters")
+          arg.parameters().empty(), "Type 'Any' cannot have parameters");
       return;
     }
 
     if (!isPositiveInteger(typeName) &&
         !tryMapNameToTypeKind(typeName).has_value() &&
         !isDecimalName(typeName) && !isDateName(typeName)) {
-      VELOX_USER_CHECK(hasType(typeName), "Type doesn't exist: {}", typeName);
+      VELOX_USER_CHECK(hasType(typeName), "Type doesn't exist: '{}'", typeName);
     }
 
     // Ensure all params are similarly supported.
@@ -182,8 +135,8 @@ void validateBaseTypeAndCollectTypeParams(
     // it doesn't have parameters, e.g M[T].
     VELOX_USER_CHECK(
         arg.parameters().empty(),
-        "Named type cannot have parameters : {}",
-        arg.toString())
+        "Named type cannot have parameters: '{}'",
+        arg.toString());
     collectedTypeVariables.insert(arg.baseName());
   }
 }
@@ -192,8 +145,13 @@ void validate(
     const std::unordered_map<std::string, SignatureVariable>& variables,
     const TypeSignature& returnType,
     const std::vector<TypeSignature>& argumentTypes,
-    const std::vector<bool>& constantArguments) {
+    const std::vector<bool>& constantArguments,
+    const std::vector<TypeSignature>& additionalTypes = {}) {
   std::unordered_set<std::string> usedVariables;
+  // Validate the additional types, and collect the used variables.
+  for (const auto& type : additionalTypes) {
+    validateBaseTypeAndCollectTypeParams(variables, type, usedVariables, false);
+  }
   // Validate the argument types.
   for (const auto& arg : argumentTypes) {
     // Is base type a type parameter or a built in type ?
@@ -262,6 +220,26 @@ FunctionSignature::FunctionSignature(
   validate(variables_, returnType_, argumentTypes_, constantArguments_);
 }
 
+FunctionSignature::FunctionSignature(
+    std::unordered_map<std::string, SignatureVariable> variables,
+    facebook::velox::exec::TypeSignature returnType,
+    std::vector<TypeSignature> argumentTypes,
+    std::vector<bool> constantArguments,
+    bool variableArity,
+    const std::vector<TypeSignature>& additionalTypes)
+    : variables_{std::move(variables)},
+      returnType_{std::move(returnType)},
+      argumentTypes_{std::move(argumentTypes)},
+      constantArguments_{std::move(constantArguments)},
+      variableArity_{variableArity} {
+  validate(
+      variables_,
+      returnType_,
+      argumentTypes_,
+      constantArguments_,
+      additionalTypes);
+}
+
 std::string AggregateFunctionSignature::toString() const {
   std::ostringstream out;
   out << "(" << argumentsToString() << ") -> " << intermediateType_.toString()
diff --git a/velox/expression/FunctionSignature.h b/velox/expression/FunctionSignature.h
index f943d8eaf7d3c..1ea46c2625992 100644
--- a/velox/expression/FunctionSignature.h
+++ b/velox/expression/FunctionSignature.h
@@ -23,6 +23,8 @@
 #include <vector>
 
 #include "velox/common/base/Exceptions.h"
+#include "velox/expression/TypeSignature.h"
+#include "velox/expression/signature_parser/SignatureParser.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::exec {
@@ -34,6 +36,14 @@ const std::vector<std::string> primitiveTypeNames();
 
 enum class ParameterType : int8_t { kTypeParameter, kIntegerParameter };
 
+/// Canonical names for functions that have special treatments in pushdowns.
+enum class FunctionCanonicalName {
+  kUnknown,
+  kLt,
+  kNot,
+  kRand,
+};
+
 /// SignatureVariable holds both, type parameters (e.g. K or V in map(K,
 /// V)), and integer parameters with optional constraints (e.g. "r_precision =
 /// a_precision + b_precision" in decimals).
@@ -97,32 +107,6 @@ class SignatureVariable {
   bool comparableTypesOnly_ = false;
 };
 
-// Base type (e.g. map) and optional parameters (e.g. K, V).
-// All parameters must be of the same ParameterType.
-class TypeSignature {
- public:
-  TypeSignature(std::string baseName, std::vector<TypeSignature> parameters)
-      : baseName_{std::move(baseName)}, parameters_{std::move(parameters)} {}
-
-  const std::string& baseName() const {
-    return baseName_;
-  }
-
-  const std::vector<TypeSignature>& parameters() const {
-    return parameters_;
-  }
-
-  std::string toString() const;
-
-  bool operator==(const TypeSignature& rhs) const {
-    return baseName_ == rhs.baseName_ && parameters_ == rhs.parameters_;
-  }
-
- private:
-  const std::string baseName_;
-  const std::vector<TypeSignature> parameters_;
-};
-
 class FunctionSignature {
  public:
   /// @param variables_ Generic type names used in return type
@@ -159,6 +143,11 @@ class FunctionSignature {
     return constantArguments_;
   }
 
+  bool hasConstantArgument() const {
+    return std::any_of(
+        constantArguments_.begin(), constantArguments_.end(), folly::identity);
+  }
+
   bool variableArity() const {
     return variableArity_;
   }
@@ -179,6 +168,22 @@ class FunctionSignature {
   }
 
  protected:
+  /// @param additionalTypes A list of additional types introduced by subclass.
+  /// Since FunctionSignature will validate that the number of used variables
+  /// and the size of variables_ must be equal. If the subclass introduces new
+  /// types, such as intermediateType in AggregateFunctionSignature, and these
+  /// types uses signature variables, it needs to pass the additional types to
+  /// the constructor of FunctionSignature for validation, to ensure that the
+  /// variables used by the subclass will also be counted in the validation of
+  /// FunctionSignature.
+  FunctionSignature(
+      std::unordered_map<std::string, SignatureVariable> variables,
+      TypeSignature returnType,
+      std::vector<TypeSignature> argumentTypes,
+      std::vector<bool> constantArguments,
+      bool variableArity,
+      const std::vector<TypeSignature>& additionalTypes);
+
   // Return a string of the list of argument types.
   std::string argumentsToString() const;
 
@@ -206,7 +211,8 @@ class AggregateFunctionSignature : public FunctionSignature {
             std::move(returnType),
             std::move(argumentTypes),
             std::move(constantArguments),
-            variableArity),
+            variableArity,
+            {intermediateType}),
         intermediateType_{std::move(intermediateType)} {}
 
   const TypeSignature& intermediateType() const {
@@ -237,18 +243,8 @@ inline void addVariable(
 
 } // namespace
 
-/// Parses a string into TypeSignature. The format of the string is type name,
-/// optionally followed by type parameters enclosed in parenthesis.
-/// Examples:
-///     - bigint
-///     - double
-///     - array(T)
-///     - map(K,V)
-///     - row(bigint,array(tinyint),T)
-///     - function(S,T,R)
-TypeSignature parseTypeSignature(const std::string& signature);
-
 /// Convenience class for creating FunctionSignature instances.
+///
 /// Example of usage:
 ///     - signature of "concat" function: varchar... -> varchar
 ///
@@ -274,6 +270,11 @@ class FunctionSignatureBuilder {
     return *this;
   }
 
+  FunctionSignatureBuilder& variable(const SignatureVariable& variable) {
+    addVariable(variables_, variable);
+    return *this;
+  }
+
   FunctionSignatureBuilder& knownTypeVariable(const std::string& name);
 
   /// Orderable implies comparable, this method would enable
@@ -313,6 +314,24 @@ class FunctionSignatureBuilder {
     return *this;
   }
 
+  /// Variable arity arguments can appear only at the end of the argument list
+  /// and can appear zero or more times.
+  FunctionSignatureBuilder& variableArity(const std::string& type) {
+    argumentTypes_.emplace_back(parseTypeSignature(type));
+    constantArguments_.push_back(false);
+    variableArity_ = true;
+    return *this;
+  }
+
+  /// Variable arity arguments can appear only at the end of the argument list
+  /// and can appear zero or more times.
+  FunctionSignatureBuilder& constantVariableArity(const std::string& type) {
+    argumentTypes_.emplace_back(parseTypeSignature(type));
+    constantArguments_.push_back(true);
+    variableArity_ = true;
+    return *this;
+  }
+
   FunctionSignaturePtr build();
 
  private:
@@ -390,6 +409,25 @@ class AggregateFunctionSignatureBuilder {
     return *this;
   }
 
+  /// Variable arity arguments can appear only at the end of the argument list
+  /// and can appear zero or more times.
+  AggregateFunctionSignatureBuilder& variableArity(const std::string& type) {
+    argumentTypes_.emplace_back(parseTypeSignature(type));
+    constantArguments_.push_back(false);
+    variableArity_ = true;
+    return *this;
+  }
+
+  /// Variable arity arguments can appear only at the end of the argument list
+  /// and can appear zero or more times.
+  AggregateFunctionSignatureBuilder& constantVariableArity(
+      const std::string& type) {
+    argumentTypes_.emplace_back(parseTypeSignature(type));
+    constantArguments_.push_back(true);
+    variableArity_ = true;
+    return *this;
+  }
+
   std::shared_ptr<AggregateFunctionSignature> build();
 
  private:
diff --git a/velox/expression/GenericWriter.cpp b/velox/expression/GenericWriter.cpp
index 2bb8764bcfcf8..2e24474ee9c09 100644
--- a/velox/expression/GenericWriter.cpp
+++ b/velox/expression/GenericWriter.cpp
@@ -31,21 +31,6 @@ bool constexpr fastPathSupportedStatic() {
   return TypeTraits<kind>::isPrimitiveType && kind != TypeKind::UNKNOWN;
 }
 
-template <TypeKind kind>
-struct KindToSimpleType {
-  using type = typename TypeTraits<kind>::NativeType;
-};
-
-template <>
-struct KindToSimpleType<TypeKind::VARCHAR> {
-  using type = Varchar;
-};
-
-template <>
-struct KindToSimpleType<TypeKind::VARBINARY> {
-  using type = Varbinary;
-};
-
 // Base case for primitives.
 template <TypeKind T>
 void copy_from_internal(GenericWriter& out, const GenericView& in) {
diff --git a/velox/expression/KindToSimpleType.h b/velox/expression/KindToSimpleType.h
new file mode 100644
index 0000000000000..77f4ce27e604c
--- /dev/null
+++ b/velox/expression/KindToSimpleType.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/type/CppToType.h"
+#include "velox/type/SimpleFunctionApi.h"
+
+namespace facebook::velox {
+
+template <TypeKind kind>
+struct KindToSimpleType {
+  using type = typename TypeTraits<kind>::NativeType;
+};
+
+template <>
+struct KindToSimpleType<TypeKind::VARCHAR> {
+  using type = Varchar;
+};
+
+template <>
+struct KindToSimpleType<TypeKind::VARBINARY> {
+  using type = Varbinary;
+};
+
+} // namespace facebook::velox
diff --git a/velox/expression/LambdaExpr.cpp b/velox/expression/LambdaExpr.cpp
index 0aef0aaf1d08a..8e3f58f987e9a 100644
--- a/velox/expression/LambdaExpr.cpp
+++ b/velox/expression/LambdaExpr.cpp
@@ -32,10 +32,12 @@ class ExprCallable : public Callable {
   ExprCallable(
       RowTypePtr signature,
       RowVectorPtr capture,
-      std::shared_ptr<Expr> body)
+      std::shared_ptr<Expr> body,
+      std::vector<std::shared_ptr<Expr>> sharedExprsToReset)
       : signature_(std::move(signature)),
         capture_(std::move(capture)),
-        body_(std::move(body)) {}
+        body_(std::move(body)),
+        sharedExprsToReset_(std::move(sharedExprsToReset)) {}
 
   bool hasCapture() const override {
     return capture_->childrenSize() > signature_->size();
@@ -53,6 +55,7 @@ class ExprCallable : public Callable {
     EvalCtx lambdaCtx = createLambdaCtx(context, row, validRowsInReusedResult);
     ScopedVarSetter throwOnError(
         lambdaCtx.mutableThrowOnError(), context->throwOnError());
+    resetSharedExprs();
     body_->eval(rows, lambdaCtx, *result);
     transformErrorVector(lambdaCtx, context, rows, elementToTopLevelRows);
   }
@@ -63,16 +66,23 @@ class ExprCallable : public Callable {
       const BufferPtr& wrapCapture,
       EvalCtx* context,
       const std::vector<VectorPtr>& args,
-      ErrorVectorPtr& elementErrors,
+      EvalErrorsPtr& elementErrors,
       VectorPtr* result) override {
     auto row = createRowVector(context, wrapCapture, args, rows.end());
     EvalCtx lambdaCtx = createLambdaCtx(context, row, validRowsInReusedResult);
     ScopedVarSetter throwOnError(lambdaCtx.mutableThrowOnError(), false);
+    resetSharedExprs();
     body_->eval(rows, lambdaCtx, *result);
     lambdaCtx.swapErrors(elementErrors);
   }
 
  private:
+  void resetSharedExprs() {
+    for (auto& expr : sharedExprsToReset_) {
+      expr->reset();
+    }
+  }
+
   EvalCtx createLambdaCtx(
       EvalCtx* context,
       std::shared_ptr<RowVector>& row,
@@ -105,6 +115,7 @@ class ExprCallable : public Callable {
       const BufferPtr& wrapCapture,
       const std::vector<VectorPtr>& args,
       vector_size_t size) {
+    VELOX_CHECK_EQ(signature_->size(), args.size());
     std::vector<VectorPtr> allVectors = args;
     for (auto index = args.size(); index < capture_->childrenSize(); ++index) {
       auto values = capture_->childAt(index);
@@ -128,10 +139,56 @@ class ExprCallable : public Callable {
   RowTypePtr signature_;
   RowVectorPtr capture_;
   std::shared_ptr<Expr> body_;
+  // List of Shared Exprs that are decendants of 'body_' for which reset() needs
+  // to be called before calling `body_->eval()`.
+  std::vector<std::shared_ptr<Expr>> sharedExprsToReset_;
 };
 
+void extractSharedExpressions(
+    const ExprPtr& expr,
+    std::unordered_set<ExprPtr>& shared) {
+  for (const auto& input : expr->inputs()) {
+    if (input->isMultiplyReferenced()) {
+      shared.insert(input);
+      continue;
+    }
+    extractSharedExpressions(input, shared);
+  }
+}
+
 } // namespace
 
+LambdaExpr::LambdaExpr(
+    TypePtr type,
+    RowTypePtr&& signature,
+    std::vector<std::shared_ptr<FieldReference>>&& capture,
+    std::shared_ptr<Expr>&& body,
+    bool trackCpuUsage)
+    : SpecialForm(
+          std::move(type),
+          std::vector<std::shared_ptr<Expr>>(),
+          "lambda",
+          false /* supportsFlatNoNullsFastPath */,
+          trackCpuUsage),
+      signature_(std::move(signature)),
+      body_(std::move(body)),
+      capture_(std::move(capture)) {
+  std::unordered_set<ExprPtr> shared;
+  extractSharedExpressions(body_, shared);
+  for (auto& expr : shared) {
+    sharedExprsToReset_.push_back(expr);
+  }
+}
+
+void LambdaExpr::computeDistinctFields() {
+  SpecialForm::computeDistinctFields();
+  std::vector<FieldReference*> capturedFields;
+  for (auto& field : capture_) {
+    capturedFields.push_back(field.get());
+  }
+  mergeFields(distinctFields_, multiplyReferencedFields_, capturedFields);
+}
+
 std::string LambdaExpr::toString(bool recursive) const {
   if (!recursive) {
     return name_;
@@ -195,7 +252,8 @@ void LambdaExpr::evalSpecialForm(
       rows.end(),
       values,
       0);
-  auto callable = std::make_shared<ExprCallable>(signature_, capture, body_);
+  auto callable = std::make_shared<ExprCallable>(
+      signature_, capture, body_, sharedExprsToReset_);
   std::shared_ptr<FunctionVector> functions;
   if (!result) {
     functions = std::make_shared<FunctionVector>(context.pool(), type_);
diff --git a/velox/expression/LambdaExpr.h b/velox/expression/LambdaExpr.h
index eb82481af0aba..bba0dc0e85f50 100644
--- a/velox/expression/LambdaExpr.h
+++ b/velox/expression/LambdaExpr.h
@@ -33,20 +33,7 @@ class LambdaExpr : public SpecialForm {
       RowTypePtr&& signature,
       std::vector<std::shared_ptr<FieldReference>>&& capture,
       std::shared_ptr<Expr>&& body,
-      bool trackCpuUsage)
-      : SpecialForm(
-            std::move(type),
-            std::vector<std::shared_ptr<Expr>>(),
-            "lambda",
-            false /* supportsFlatNoNullsFastPath */,
-            trackCpuUsage),
-        signature_(std::move(signature)),
-        body_(std::move(body)),
-        capture_(std::move(capture)) {
-    for (auto& field : capture_) {
-      distinctFields_.push_back(field.get());
-    }
-  }
+      bool trackCpuUsage);
 
   bool isConstant() const override {
     return false;
@@ -62,6 +49,9 @@ class LambdaExpr : public SpecialForm {
       EvalCtx& context,
       VectorPtr& result) override;
 
+ protected:
+  void computeDistinctFields() override;
+
  private:
   /// Used to initialize captureChannels_ and typeWithCapture_ on first use.
   void makeTypeWithCapture(EvalCtx& context);
@@ -81,6 +71,12 @@ class LambdaExpr : public SpecialForm {
   /// array/map.
   ExprPtr body_;
 
+  // List of Shared Exprs that are decendants of 'body_' for which reset() needs
+  // to be called before calling `body_->eval()`.This is because every
+  // invocation of `body_->eval()` should treat its inputs like a fresh batch
+  // similar to how we operate in `ExprSet::eval()`.
+  std::vector<ExprPtr> sharedExprsToReset_;
+
   /// List of field references to columns in the input row vector.
   std::vector<std::shared_ptr<FieldReference>> capture_;
 
diff --git a/velox/expression/Main.cpp b/velox/expression/Main.cpp
new file mode 100644
index 0000000000000..3b55575663ed0
--- /dev/null
+++ b/velox/expression/Main.cpp
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::Init init(&argc, &argv, false);
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/expression/PeeledEncoding.cpp b/velox/expression/PeeledEncoding.cpp
index c274db0fa5619..124a3737a343c 100644
--- a/velox/expression/PeeledEncoding.cpp
+++ b/velox/expression/PeeledEncoding.cpp
@@ -20,10 +20,10 @@
 
 namespace facebook::velox::exec {
 
-std::shared_ptr<PeeledEncoding> PeeledEncoding::peel(
+/*static*/ std::shared_ptr<PeeledEncoding> PeeledEncoding::peel(
     const std::vector<VectorPtr>& vectorsToPeel,
     const SelectivityVector& rows,
-    LocalDecodedVector& decodedVector,
+    DecodedVector& decodedVector,
     bool canPeelsHaveNulls,
     std::vector<VectorPtr>& peeledVectors) {
   std::shared_ptr<PeeledEncoding> peeledEncoding(new PeeledEncoding());
@@ -38,6 +38,20 @@ std::shared_ptr<PeeledEncoding> PeeledEncoding::peel(
   return nullptr;
 }
 
+/*static*/ std::shared_ptr<PeeledEncoding> PeeledEncoding::peel(
+    const std::vector<VectorPtr>& vectorsToPeel,
+    const SelectivityVector& rows,
+    LocalDecodedVector& decodedVector,
+    bool canPeelsHaveNulls,
+    std::vector<VectorPtr>& peeledVectors) {
+  return peel(
+      vectorsToPeel,
+      rows,
+      *decodedVector.get(),
+      canPeelsHaveNulls,
+      peeledVectors);
+}
+
 SelectivityVector* PeeledEncoding::translateToInnerRows(
     const SelectivityVector& outerRows,
     LocalSelectivityVector& innerRowsHolder) const {
@@ -98,7 +112,7 @@ void PeeledEncoding::setDictionaryWrapping(
 bool PeeledEncoding::peelInternal(
     const std::vector<VectorPtr>& vectorsToPeel,
     const SelectivityVector& rows,
-    LocalDecodedVector& decodedVector,
+    DecodedVector& decodedVector,
     bool canPeelsHaveNulls,
     std::vector<VectorPtr>& peeledVectors) {
   auto numFields = vectorsToPeel.size();
@@ -189,7 +203,6 @@ bool PeeledEncoding::peelInternal(
       constantWrapIndex_ = rows.begin();
     }
   } else {
-    auto decoded = decodedVector.get();
     auto firstWrapper = vectorsToPeel[firstPeeled];
     // Check if constant encoding can be peeled off too if the input is of the
     // form Dictionary(Constant(complex)).
@@ -199,17 +212,17 @@ bool PeeledEncoding::peelInternal(
       numLevels++; // include the constant layer while decoding.
       peeledVectors.back() = peeledVectors.back()->valueVector();
     }
-    decoded->makeIndices(*firstWrapper, rows, numLevels);
-    if (decoded->isConstantMapping()) {
+    decodedVector.makeIndices(*firstWrapper, rows, numLevels);
+    if (decodedVector.isConstantMapping()) {
       // This can only happen if the attempt to peel a constant encoding layer
       // exposed a null complex constant as the base.
       VELOX_CHECK(peeledVectors.size() == 1);
-      auto innerIdx = decoded->index(rows.begin());
+      auto innerIdx = decodedVector.index(rows.begin());
       VELOX_CHECK(peeledVectors.back()->isNullAt(innerIdx));
       wrapEncoding_ = VectorEncoding::Simple::CONSTANT;
       constantWrapIndex_ = innerIdx;
     } else {
-      setDictionaryWrapping(*decoded, rows, *firstWrapper);
+      setDictionaryWrapping(decodedVector, rows, *firstWrapper);
       // Make sure all the constant vectors have at least the same length as the
       // base vector after peeling. This will make sure any translated rows
       // point to valid rows in the constant vector.
diff --git a/velox/expression/PeeledEncoding.h b/velox/expression/PeeledEncoding.h
index 99cd35ac16ae3..6d8588d466e71 100644
--- a/velox/expression/PeeledEncoding.h
+++ b/velox/expression/PeeledEncoding.h
@@ -32,6 +32,11 @@ class LocalSelectivityVector;
 /// translate top level rows into inner rows and wrap a vector (typically
 /// generated as a result of applying an expression on the peeled vectors).
 ///
+/// When the base vector size is larger than 8 times of the selected rows, we do
+/// not save the dictionary wrapping.  Instead, we store a flattened version of
+/// the selected rows and return them when needed.  The wrapping in this case is
+/// kept as FLAT, and the inner/outer rows translation will be identical.
+///
 /// Typical usage pattern for peeling includes:
 /// (See Expr::applyFunctionWithPeeling() for example usage)
 /// 1. peeling a set of input vectors
@@ -110,6 +115,13 @@ class PeeledEncoding {
   /// peels). Returns a nullptr if peeling was unsuccessful, otherwise returns a
   /// valid PeeledEncoding object and populates 'peeledVectors' with the peeled
   /// vectors.
+  static std::shared_ptr<PeeledEncoding> peel(
+      const std::vector<VectorPtr>& vectorsToPeel,
+      const SelectivityVector& rows,
+      DecodedVector& decodedVector,
+      bool canPeelsHaveNulls,
+      std::vector<VectorPtr>& peeledVectors);
+
   static std::shared_ptr<PeeledEncoding> peel(
       const std::vector<VectorPtr>& vectorsToPeel,
       const SelectivityVector& rows,
@@ -144,7 +156,7 @@ class PeeledEncoding {
   /// selectivity vector.
   VectorPtr wrap(
       const TypePtr& outputType,
-      velox::memory::MemoryPool* FOLLY_NONNULL pool,
+      velox::memory::MemoryPool* pool,
       VectorPtr peeledResult,
       const SelectivityVector& rows) const;
 
@@ -164,7 +176,7 @@ class PeeledEncoding {
       vector_size_t innerRow = indices ? indices[outerRow] : constantWrapIndex_;
       func(outerRow, innerRow);
     });
-  };
+  }
 
  private:
   PeeledEncoding() = default;
@@ -174,7 +186,7 @@ class PeeledEncoding {
   bool peelInternal(
       const std::vector<VectorPtr>& vectorsToPeel,
       const SelectivityVector& rows,
-      LocalDecodedVector& decodedVector,
+      DecodedVector& decodedVector,
       bool canPeelsHaveNulls,
       std::vector<VectorPtr>& peeledVectors);
 
diff --git a/velox/expression/PrestoCastHooks.cpp b/velox/expression/PrestoCastHooks.cpp
new file mode 100644
index 0000000000000..4876ef31aa3c7
--- /dev/null
+++ b/velox/expression/PrestoCastHooks.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cmath>
+
+#include <double-conversion/double-conversion.h>
+#include <folly/Expected.h>
+
+#include "velox/expression/PrestoCastHooks.h"
+#include "velox/functions/lib/string/StringImpl.h"
+#include "velox/type/TimestampConversion.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox::exec {
+
+PrestoCastHooks::PrestoCastHooks(const core::QueryConfig& config)
+    : CastHooks(), legacyCast_(config.isLegacyCast()) {
+  if (!legacyCast_) {
+    options_.zeroPaddingYear = true;
+    options_.dateTimeSeparator = ' ';
+    const auto sessionTzName = config.sessionTimezone();
+    if (config.adjustTimestampToTimezone() && !sessionTzName.empty()) {
+      options_.timeZone = tz::locateZone(sessionTzName);
+    }
+  }
+}
+
+Expected<Timestamp> PrestoCastHooks::castStringToTimestamp(
+    const StringView& view) const {
+  const auto conversionResult = util::fromTimestampWithTimezoneString(
+      view.data(),
+      view.size(),
+      legacyCast_ ? util::TimestampParseMode::kLegacyCast
+                  : util::TimestampParseMode::kPrestoCast);
+  if (conversionResult.hasError()) {
+    return folly::makeUnexpected(conversionResult.error());
+  }
+
+  auto result = conversionResult.value();
+
+  // If the parsed string has timezone information, convert the timestamp at
+  // GMT at that time. For example, "1970-01-01 00:00:00 -00:01" is 60 seconds
+  // at GMT.
+  if (result.second != nullptr) {
+    result.first.toGMT(*result.second);
+
+  }
+  // If no timezone information is available in the input string, check if we
+  // should understand it as being at the session timezone, and if so, convert
+  // to GMT.
+  else if (options_.timeZone != nullptr) {
+    result.first.toGMT(*options_.timeZone);
+  }
+  return result.first;
+}
+
+Expected<int32_t> PrestoCastHooks::castStringToDate(
+    const StringView& dateString) const {
+  // Cast from string to date allows only complete ISO 8601 formatted strings:
+  // [+-](YYYY-MM-DD).
+  return util::fromDateString(dateString, util::ParseMode::kPrestoCast);
+}
+
+namespace {
+
+using double_conversion::StringToDoubleConverter;
+
+template <typename T>
+Expected<T> doCastToFloatingPoint(const StringView& data) {
+  static const T kNan = std::numeric_limits<T>::quiet_NaN();
+  static StringToDoubleConverter stringToDoubleConverter{
+      StringToDoubleConverter::ALLOW_TRAILING_SPACES,
+      /*empty_string_value*/ kNan,
+      /*junk_string_value*/ kNan,
+      "Infinity",
+      "NaN"};
+  int processedCharactersCount;
+  T result;
+  auto* begin = std::find_if_not(data.begin(), data.end(), [](char c) {
+    return functions::stringImpl::isAsciiWhiteSpace(c);
+  });
+  auto length = data.end() - begin;
+  if (length == 0) {
+    // 'data' only contains white spaces.
+    return folly::makeUnexpected(Status::UserError());
+  }
+  if constexpr (std::is_same_v<T, float>) {
+    result = stringToDoubleConverter.StringToFloat(
+        begin, length, &processedCharactersCount);
+  } else if constexpr (std::is_same_v<T, double>) {
+    result = stringToDoubleConverter.StringToDouble(
+        begin, length, &processedCharactersCount);
+  }
+  // Since we already removed leading space, if processedCharactersCount == 0,
+  // it means the remaining string is either empty or a junk string. So return a
+  // user error in this case.
+  if UNLIKELY (processedCharactersCount == 0) {
+    return folly::makeUnexpected(Status::UserError());
+  }
+  return result;
+}
+
+} // namespace
+
+Expected<float> PrestoCastHooks::castStringToReal(
+    const StringView& data) const {
+  return doCastToFloatingPoint<float>(data);
+}
+
+Expected<double> PrestoCastHooks::castStringToDouble(
+    const StringView& data) const {
+  return doCastToFloatingPoint<double>(data);
+}
+
+StringView PrestoCastHooks::removeWhiteSpaces(const StringView& view) const {
+  return view;
+}
+
+const TimestampToStringOptions& PrestoCastHooks::timestampToStringOptions()
+    const {
+  return options_;
+}
+
+PolicyType PrestoCastHooks::getPolicy() const {
+  return legacyCast_ ? PolicyType::LegacyCastPolicy
+                     : PolicyType::PrestoCastPolicy;
+}
+} // namespace facebook::velox::exec
diff --git a/velox/expression/PrestoCastHooks.h b/velox/expression/PrestoCastHooks.h
new file mode 100644
index 0000000000000..af129557a955c
--- /dev/null
+++ b/velox/expression/PrestoCastHooks.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/CastHooks.h"
+#include "velox/expression/EvalCtx.h"
+
+namespace facebook::velox::exec {
+
+// This class provides cast hooks following Presto semantics.
+class PrestoCastHooks : public CastHooks {
+ public:
+  explicit PrestoCastHooks(const core::QueryConfig& config);
+
+  // Uses the default implementation of 'castFromDateString'.
+  Expected<Timestamp> castStringToTimestamp(
+      const StringView& view) const override;
+
+  // Uses standard cast mode to cast from string to date.
+  Expected<int32_t> castStringToDate(
+      const StringView& dateString) const override;
+
+  // Allows casting 'NaN', 'Infinity', and '-Infinity' to real, but not 'Inf' or
+  // these strings with different letter cases.
+  Expected<float> castStringToReal(const StringView& data) const override;
+
+  // Allows casting 'NaN', 'Infinity', and '-Infinity' to double, but not 'Inf'
+  // or these strings with different letter cases.
+  Expected<double> castStringToDouble(const StringView& data) const override;
+
+  // Returns the input as is.
+  StringView removeWhiteSpaces(const StringView& view) const override;
+
+  // Returns cast options following 'isLegacyCast' and session timezone.
+  const TimestampToStringOptions& timestampToStringOptions() const override;
+
+  bool truncate() const override {
+    return false;
+  }
+
+  PolicyType getPolicy() const override;
+
+ private:
+  const bool legacyCast_;
+  TimestampToStringOptions options_ = {
+      .precision = TimestampToStringOptions::Precision::kMilliseconds};
+};
+} // namespace facebook::velox::exec
diff --git a/velox/expression/RegisterSpecialForm.h b/velox/expression/RegisterSpecialForm.h
index a166b0963fc92..bd71ac53b83a2 100644
--- a/velox/expression/RegisterSpecialForm.h
+++ b/velox/expression/RegisterSpecialForm.h
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) Facebook, Inc. and its affiliates.
  *
diff --git a/velox/expression/ReverseSignatureBinder.cpp b/velox/expression/ReverseSignatureBinder.cpp
index b21715fef36d3..274d2a06480f4 100644
--- a/velox/expression/ReverseSignatureBinder.cpp
+++ b/velox/expression/ReverseSignatureBinder.cpp
@@ -18,28 +18,10 @@
 
 namespace facebook::velox::exec {
 
-bool ReverseSignatureBinder::hasConstrainedIntegerVariable(
-    const TypeSignature& type) const {
-  if (type.parameters().empty()) {
-    auto it = variables().find(type.baseName());
-    return it != variables().end() && it->second.isIntegerParameter() &&
-        it->second.constraint() != "";
-  }
-
-  const auto& parameters = type.parameters();
-  for (const auto& parameter : parameters) {
-    if (hasConstrainedIntegerVariable(parameter)) {
-      return true;
-    }
-  }
-  return false;
-}
-
 bool ReverseSignatureBinder::tryBind() {
-  if (hasConstrainedIntegerVariable(signature_.returnType())) {
-    return false;
-  }
-  return SignatureBinderBase::tryBind(signature_.returnType(), returnType_);
+  tryBindSucceeded_ =
+      SignatureBinderBase::tryBind(signature_.returnType(), returnType_);
+  return tryBindSucceeded_;
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/expression/ReverseSignatureBinder.h b/velox/expression/ReverseSignatureBinder.h
index 02b92d217cf41..3da800a5edbb6 100644
--- a/velox/expression/ReverseSignatureBinder.h
+++ b/velox/expression/ReverseSignatureBinder.h
@@ -40,15 +40,24 @@ class ReverseSignatureBinder : private SignatureBinderBase {
   /// tryBind() and only if tryBind() returns true. If a type variable is not
   /// determined by tryBind(), it maps to a nullptr.
   const std::unordered_map<std::string, TypePtr>& bindings() const {
+    VELOX_CHECK(
+        tryBindSucceeded_, "tryBind() must be called first and succeed");
     return typeVariablesBindings_;
   }
 
- private:
-  /// Return whether there is a constraint on an integer variable in type
-  /// signature.
-  bool hasConstrainedIntegerVariable(const TypeSignature& type) const;
+  /// Return the integer bindings produced by 'tryBind'. This function should be
+  /// called after 'tryBind' and only if 'tryBind' returns true.
+  const std::unordered_map<std::string, int>& integerBindings() const {
+    VELOX_CHECK(
+        tryBindSucceeded_, "tryBind() must be called first and succeed");
+    return integerVariablesBindings_;
+  }
 
+ private:
   const TypePtr returnType_;
+
+  // True if 'tryBind' has been called and succeeded. False otherwise.
+  bool tryBindSucceeded_{false};
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/expression/RowConstructor.cpp b/velox/expression/RowConstructor.cpp
index 9310c24bf8c23..59f3f2b427096 100644
--- a/velox/expression/RowConstructor.cpp
+++ b/velox/expression/RowConstructor.cpp
@@ -32,35 +32,30 @@ TypePtr RowConstructorCallToSpecialForm::resolveType(
 }
 
 ExprPtr RowConstructorCallToSpecialForm::constructSpecialForm(
-    const std::string& name,
     const TypePtr& type,
     std::vector<ExprPtr>&& compiledChildren,
     bool trackCpuUsage,
     const core::QueryConfig& config) {
-  auto rowConstructorVectorFunction =
-      vectorFunctionFactories().withRLock([&config, &name](auto& functionMap) {
-        auto functionIterator = functionMap.find(name);
-        return functionIterator->second.factory(name, {}, config);
+  auto [function, metadata] = vectorFunctionFactories().withRLock(
+      [&config](auto& functionMap) -> std::pair<
+                                       std::shared_ptr<VectorFunction>,
+                                       VectorFunctionMetadata> {
+        auto functionIterator = functionMap.find(kRowConstructor);
+        if (functionIterator != functionMap.end()) {
+          return {
+              functionIterator->second.factory(kRowConstructor, {}, config),
+              functionIterator->second.metadata};
+        } else {
+          VELOX_FAIL("Function {} is not registered.", kRowConstructor);
+        }
       });
 
   return std::make_shared<Expr>(
       type,
       std::move(compiledChildren),
-      rowConstructorVectorFunction,
-      name,
-      trackCpuUsage);
-}
-
-ExprPtr RowConstructorCallToSpecialForm::constructSpecialForm(
-    const TypePtr& type,
-    std::vector<ExprPtr>&& compiledChildren,
-    bool trackCpuUsage,
-    const core::QueryConfig& config) {
-  return constructSpecialForm(
+      function,
+      metadata,
       kRowConstructor,
-      type,
-      std::move(compiledChildren),
-      trackCpuUsage,
-      config);
+      trackCpuUsage);
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/RowConstructor.h b/velox/expression/RowConstructor.h
index c2deb9a86cf07..9e29208536cc4 100644
--- a/velox/expression/RowConstructor.h
+++ b/velox/expression/RowConstructor.h
@@ -30,13 +30,5 @@ class RowConstructorCallToSpecialForm : public FunctionCallToSpecialForm {
       const core::QueryConfig& config) override;
 
   static constexpr const char* kRowConstructor = "row_constructor";
-
- protected:
-  ExprPtr constructSpecialForm(
-      const std::string& name,
-      const TypePtr& type,
-      std::vector<ExprPtr>&& compiledChildren,
-      bool trackCpuUsage,
-      const core::QueryConfig& config);
 };
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SignatureBinder.cpp b/velox/expression/SignatureBinder.cpp
index 965841270dc5b..d1621a0976858 100644
--- a/velox/expression/SignatureBinder.cpp
+++ b/velox/expression/SignatureBinder.cpp
@@ -74,10 +74,26 @@ std::optional<int64_t> tryResolveLongLiteral(
   VELOX_CHECK(
       integerVariablesBindings.count(variable),
       "Variable {} calculation failed.",
-      variable)
+      variable);
   return integerVariablesBindings.at(variable);
 }
 
+// If the parameter is a named field from a row, ensure the names are
+// compatible. For example:
+//
+// > row(bigint) - binds any row with bigint as field.
+// > row(foo bigint) - only binds rows where bigint field is named foo.
+bool checkNamedRowField(
+    const TypeSignature& signature,
+    const TypePtr& actualType,
+    size_t idx) {
+  if (signature.rowFieldName().has_value() &&
+      (*signature.rowFieldName() != asRowType(actualType)->nameOf(idx))) {
+    return false;
+  }
+  return true;
+}
+
 } // namespace
 
 bool SignatureBinder::tryBind() {
@@ -122,6 +138,9 @@ bool SignatureBinder::tryBind() {
 bool SignatureBinderBase::checkOrSetIntegerParameter(
     const std::string& parameterName,
     int value) {
+  if (isPositiveInteger(parameterName)) {
+    return atoi(parameterName.c_str()) == value;
+  }
   if (!variables().count(parameterName)) {
     // Return false if the parameter is not found in the signature.
     return false;
@@ -191,6 +210,7 @@ bool SignatureBinderBase::tryBind(
   if (params.size() != actualType->parameters().size()) {
     return false;
   }
+
   for (auto i = 0; i < params.size(); i++) {
     const auto& actualParameter = actualType->parameters()[i];
     switch (actualParameter.kind) {
@@ -201,6 +221,10 @@ bool SignatureBinderBase::tryBind(
         }
         break;
       case TypeParameterKind::kType:
+        if (!checkNamedRowField(params[i], actualType, i)) {
+          return false;
+        }
+
         if (!tryBind(params[i], actualParameter.type)) {
           return false;
         }
diff --git a/velox/expression/SimpleFunctionAdapter.h b/velox/expression/SimpleFunctionAdapter.h
index 6a59a73b15218..4aed80c3adefc 100644
--- a/velox/expression/SimpleFunctionAdapter.h
+++ b/velox/expression/SimpleFunctionAdapter.h
@@ -16,11 +16,13 @@
 
 #pragma once
 
+#include <exception>
 #include <memory>
 #include <optional>
 #include <type_traits>
 
 #include "velox/common/base/Portability.h"
+#include "velox/common/base/Status.h"
 #include "velox/expression/ComplexWriterTypes.h"
 #include "velox/expression/DecodedArgs.h"
 #include "velox/expression/Expr.h"
@@ -85,12 +87,27 @@ class SimpleFunctionAdapter : public VectorFunction {
   // boolean.
   template <int32_t POSITION>
   static constexpr bool isArgFlatConstantFastPathEligible =
-      SimpleTypeTrait<arg_at<POSITION>>::isPrimitiveType&&
-          SimpleTypeTrait<arg_at<POSITION>>::typeKind != TypeKind::BOOLEAN;
+      SimpleTypeTrait<arg_at<POSITION>>::isPrimitiveType &&
+      SimpleTypeTrait<arg_at<POSITION>>::typeKind != TypeKind::BOOLEAN;
 
   constexpr int32_t reuseStringsFromArgValue() const {
     return udf_reuse_strings_from_arg<typename FUNC::udf_struct_t>();
   }
+  template <size_t... Is>
+  bool allArgsPrimitiveImpl(std::index_sequence<Is...>) const {
+    return ([&]() {
+      if constexpr (isVariadicType<arg_at<Is>>::value) {
+        return SimpleTypeTrait<
+            typename arg_at<Is>::underlying_type>::isPrimitiveType;
+      } else {
+        return SimpleTypeTrait<arg_at<Is>>::isPrimitiveType;
+      }
+    }() && ...);
+  }
+
+  bool allArgsPrimitive() const {
+    return allArgsPrimitiveImpl(std::make_index_sequence<FUNC::num_args>());
+  }
 
   // Check if all arguments that satisfy
   // isArgFlatConstantFastPathEligible<Is> and not part of variadic pack have
@@ -180,6 +197,16 @@ class SimpleFunctionAdapter : public VectorFunction {
       context.template applyToSelectedNoThrow<Callable>(*rows, func);
     }
 
+    template <typename Callable, typename OnError>
+    void applyToSelectedNoThrow(Callable func, OnError onErrorFunc) {
+      context.template applyToSelectedNoThrow<Callable>(
+          *rows, func, onErrorFunc);
+    }
+
+    void setError(vector_size_t row, Status status) {
+      context.setStatus(row, status);
+    }
+
     const SelectivityVector* rows;
     result_vector_t* result;
     VectorWriter<typename FUNC::return_type> resultWriter;
@@ -190,11 +217,12 @@ class SimpleFunctionAdapter : public VectorFunction {
 
   template <int32_t POSITION, typename... Values>
   void unpackInitialize(
+      const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
       const std::vector<VectorPtr>& packed,
       const Values*... values) const {
     if constexpr (POSITION == FUNC::num_args) {
-      return (*fn_).initialize(config, values...);
+      return (*fn_).initialize(inputTypes, config, values...);
     } else {
       if (packed.at(POSITION) != nullptr) {
         SelectivityVector rows(1);
@@ -202,35 +230,40 @@ class SimpleFunctionAdapter : public VectorFunction {
         auto oneReader = VectorReader<arg_at<POSITION>>(&decodedVector);
         auto oneValue = oneReader[0];
 
-        unpackInitialize<POSITION + 1>(config, packed, values..., &oneValue);
+        unpackInitialize<POSITION + 1>(
+            inputTypes, config, packed, values..., &oneValue);
       } else {
         using temp_type = exec_arg_at<POSITION>;
         unpackInitialize<POSITION + 1>(
-            config, packed, values..., (const temp_type*)nullptr);
+            inputTypes, config, packed, values..., (const temp_type*)nullptr);
       }
     }
   }
 
  public:
-  explicit SimpleFunctionAdapter(
+  SimpleFunctionAdapter(
+      const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
       const std::vector<VectorPtr>& constantInputs)
       : fn_{std::make_unique<FUNC>()} {
     if constexpr (FUNC::udf_has_initialize) {
       try {
-        unpackInitialize<0>(config, constantInputs);
+        unpackInitialize<0>(inputTypes, config, constantInputs);
       } catch (const VeloxRuntimeError&) {
         throw;
-      } catch (const std::exception& e) {
+      } catch (const std::exception&) {
         initializeException_ = std::current_exception();
       }
     }
   }
 
+  explicit SimpleFunctionAdapter() {}
+
   template <
       int32_t POSITION,
-      typename std::enable_if_t<POSITION<FUNC::num_args, int32_t> = 0>
-          VectorPtr* findReusableArg(std::vector<VectorPtr>& args) const {
+      typename std::enable_if_t<
+          POSITION<FUNC::num_args, int32_t> = 0> VectorPtr*
+          findReusableArg(std::vector<VectorPtr>& args) const {
     if constexpr (isVariadicType<arg_at<POSITION>>::value) {
       if constexpr (
           SimpleTypeTrait<
@@ -293,8 +326,10 @@ class SimpleFunctionAdapter : public VectorFunction {
         return_type_traits::isFixedWidth) {
       if (!reusableResult->get()) {
         if (auto* arg = findReusableArg<0>(args)) {
-          reusableResult = arg;
-          isResultReused = true;
+          if ((*arg)->type()->equivalent(*outputType)) {
+            reusableResult = arg;
+            isResultReused = true;
+          }
         }
       }
     }
@@ -395,16 +430,23 @@ class SimpleFunctionAdapter : public VectorFunction {
     }
   }
 
-  bool isDeterministic() const override {
-    return fn_->isDeterministic();
-  }
-
-  bool isDefaultNullBehavior() const override {
-    return fn_->is_default_null_behavior;
+  FunctionCanonicalName getCanonicalName() const final {
+    return fn_->getCanonicalName();
   }
 
   bool supportsFlatNoNullsFastPath() const override {
-    return !FUNC::can_produce_null_output;
+    if (FUNC::can_produce_null_output) {
+      return false;
+    }
+
+    if (FUNC::is_default_contains_nulls_behavior) {
+      // If the function has is_default_contains_nulls_behavior it returns
+      // null if data contain null even if the return type of callNullFree is
+      // void.
+      return allArgsPrimitive();
+    } else {
+      return true;
+    }
   }
 
   bool ensureStringEncodingSetAtAllInputs() const override {
@@ -588,7 +630,11 @@ class SimpleFunctionAdapter : public VectorFunction {
               // Result is NULL because the input contains NULL.
               notNull = false;
             } else {
-              notNull = doApplyNullFree<0>(row, out, readers...);
+              auto status = doApplyNullFree<0>(row, out, notNull, readers...);
+              if UNLIKELY (!status.ok()) {
+                applyContext.setError(row, status);
+                return;
+              }
             }
 
             writeResult(row, notNull, out);
@@ -596,7 +642,12 @@ class SimpleFunctionAdapter : public VectorFunction {
         } else {
           applyContext.applyToSelectedNoThrow([&](auto row) INLINE_LAMBDA {
             typename return_type_traits::NativeType out{};
-            bool notNull = doApplyNullFree<0>(row, out, readers...);
+            bool notNull;
+            auto status = doApplyNullFree<0>(row, out, notNull, readers...);
+            if UNLIKELY (!status.ok()) {
+              applyContext.setError(row, status);
+              return;
+            }
 
             writeResult(row, notNull, out);
           });
@@ -606,7 +657,13 @@ class SimpleFunctionAdapter : public VectorFunction {
           if (applyContext.allAscii) {
             applyContext.applyToSelectedNoThrow([&](auto row) INLINE_LAMBDA {
               typename return_type_traits::NativeType out{};
-              bool notNull = doApplyAsciiNotNull<0>(row, out, readers...);
+              bool notNull;
+              auto status =
+                  doApplyAsciiNotNull<0>(row, out, notNull, readers...);
+              if UNLIKELY (!status.ok()) {
+                applyContext.setError(row, status);
+                return;
+              }
               writeResult(row, notNull, out);
             });
             return;
@@ -618,13 +675,23 @@ class SimpleFunctionAdapter : public VectorFunction {
           // optimization (eliminating the temp) is easier to do by the
           // compiler (assuming the function call is inlined).
           typename return_type_traits::NativeType out{};
-          bool notNull = doApplyNotNull<0>(row, out, readers...);
+          bool notNull;
+          auto status = doApplyNotNull<0>(row, out, notNull, readers...);
+          if UNLIKELY (!status.ok()) {
+            applyContext.setError(row, status);
+            return;
+          }
           writeResult(row, notNull, out);
         });
       } else {
         applyContext.applyToSelectedNoThrow([&](auto row) INLINE_LAMBDA {
           typename return_type_traits::NativeType out{};
-          bool notNull = doApply<0>(row, out, readers...);
+          bool notNull;
+          auto status = doApply<0>(row, out, notNull, readers...);
+          if UNLIKELY (!status.ok()) {
+            applyContext.setError(row, status);
+            return;
+          }
           writeResult(row, notNull, out);
         });
       }
@@ -634,63 +701,69 @@ class SimpleFunctionAdapter : public VectorFunction {
         // once per batch instead of once per row shows a significant
         // performance improvement when there are no nulls.
         if (applyContext.mayHaveNullsRecursive) {
-          applyUdf(applyContext, [&](auto& out, auto row) INLINE_LAMBDA {
-            auto containsNull = (readers.containsNull(row) || ...);
-            if (containsNull) {
-              // Result is NULL because the input contains NULL.
-              return false;
-            }
-
-            return doApplyNullFree<0>(row, out, readers...);
-          });
+          applyUdf(
+              applyContext,
+              [&](auto& out, auto& notNull, auto row) INLINE_LAMBDA {
+                auto containsNull = (readers.containsNull(row) || ...);
+                if (containsNull) {
+                  // Result is NULL because the input contains NULL.
+                  notNull = false;
+                  return Status::OK();
+                }
+
+                return doApplyNullFree<0>(row, out, notNull, readers...);
+              });
         } else {
-          applyUdf(applyContext, [&](auto& out, auto row) INLINE_LAMBDA {
-            return doApplyNullFree<0>(row, out, readers...);
-          });
+          applyUdf(
+              applyContext,
+              [&](auto& out, auto& notNull, auto row) INLINE_LAMBDA {
+                return doApplyNullFree<0>(row, out, notNull, readers...);
+              });
         }
       } else if (allNotNull) {
         if constexpr (FUNC::has_ascii) {
           if (applyContext.allAscii) {
-            applyUdf(applyContext, [&](auto& out, auto row) INLINE_LAMBDA {
-              return doApplyAsciiNotNull<0>(row, out, readers...);
-            });
+            applyUdf(
+                applyContext,
+                [&](auto& out, auto& notNull, auto row) INLINE_LAMBDA {
+                  return doApplyAsciiNotNull<0>(row, out, notNull, readers...);
+                });
             return;
           }
         }
-        applyUdf(applyContext, [&](auto& out, auto row) INLINE_LAMBDA {
-          return doApplyNotNull<0>(row, out, readers...);
-        });
+        applyUdf(
+            applyContext,
+            [&](auto& out, auto& notNull, auto row) INLINE_LAMBDA {
+              return doApplyNotNull<0>(row, out, notNull, readers...);
+            });
       } else {
-        applyUdf(applyContext, [&](auto& out, auto row) INLINE_LAMBDA {
-          return doApply<0>(row, out, readers...);
-        });
+        applyUdf(
+            applyContext,
+            [&](auto& out, auto& notNull, auto row) INLINE_LAMBDA {
+              return doApply<0>(row, out, notNull, readers...);
+            });
       }
     }
   }
 
   template <typename Func>
   void applyUdf(ApplyContext& applyContext, Func func) const {
-    if constexpr (IsArrayWriter<T>::value || IsMapWriter<T>::value) {
-      // An optimization for arrayProxy and mapWriter that force the
-      // localization of the writer.
-      auto& currentWriter = applyContext.resultWriter.writer_;
-
-      applyContext.applyToSelectedNoThrow([&](auto row) INLINE_LAMBDA {
-        applyContext.resultWriter.setOffset(row);
-        // Force local copy of proxy.
-        auto localWriter = currentWriter;
-        auto notNull = func(localWriter, row);
-        currentWriter = localWriter;
-        applyContext.resultWriter.commit(notNull);
-      });
-      applyContext.resultWriter.finish();
-    } else {
-      applyContext.applyToSelectedNoThrow([&](auto row) INLINE_LAMBDA {
-        applyContext.resultWriter.setOffset(row);
-        applyContext.resultWriter.commit(
-            func(applyContext.resultWriter.current(), row));
-      });
-    }
+    applyContext.applyToSelectedNoThrow(
+        [&](auto row) INLINE_LAMBDA {
+          applyContext.resultWriter.setOffset(row);
+          bool notNull;
+          auto status = func(applyContext.resultWriter.current(), notNull, row);
+          if UNLIKELY (!status.ok()) {
+            applyContext.setError(row, status);
+            applyContext.resultWriter.commitNull();
+          } else {
+            applyContext.resultWriter.commit(notNull);
+          }
+        },
+        [&](auto /* row */)
+            INLINE_LAMBDA { applyContext.resultWriter.commitNull(); });
+
+    applyContext.resultWriter.finish();
   }
 
   // == NULLABLE VARIANTS ==
@@ -704,10 +777,11 @@ class SimpleFunctionAdapter : public VectorFunction {
       typename... Values,
       std::enable_if_t<
           POSITION<FUNC::num_args && FUNC::is_default_null_behavior, int32_t> =
-              0> FOLLY_ALWAYS_INLINE bool
+              0> FOLLY_ALWAYS_INLINE Status
           doApply(
               size_t idx,
               T& target,
+              bool& notNull,
               R0& currentReader,
               const Values&... extra) const {
     if (LIKELY(currentReader.isSet(idx))) {
@@ -715,9 +789,10 @@ class SimpleFunctionAdapter : public VectorFunction {
       decltype(currentReader[idx]) v0 = currentReader[idx];
 
       // recurse through the readers to build the arg list at compile time.
-      return doApply<POSITION + 1>(idx, target, extra..., v0);
+      return doApply<POSITION + 1>(idx, target, notNull, extra..., v0);
     } else {
-      return false;
+      notNull = false;
+      return Status::OK();
     }
   }
 
@@ -728,10 +803,11 @@ class SimpleFunctionAdapter : public VectorFunction {
       typename... Values,
       std::enable_if_t<
           POSITION<FUNC::num_args && !FUNC::is_default_null_behavior, int32_t> =
-              0> FOLLY_ALWAYS_INLINE bool
+              0> FOLLY_ALWAYS_INLINE Status
           doApply(
               size_t idx,
               T& target,
+              bool& notNull,
               R0& currentReader,
               const Values&... extra) const {
     // Recurse through all the arguments to build the arg list at compile
@@ -740,16 +816,17 @@ class SimpleFunctionAdapter : public VectorFunction {
       return doApply<POSITION + 1>(
           idx,
           target,
+          notNull,
           extra...,
           (currentReader.isSet(idx) ? &currentReader[idx] : nullptr));
     } else {
       using temp_type = std::remove_reference_t<decltype(currentReader[idx])>;
       if (currentReader.isSet(idx)) {
         temp_type temp = currentReader[idx];
-        return doApply<POSITION + 1>(idx, target, extra..., &temp);
+        return doApply<POSITION + 1>(idx, target, notNull, extra..., &temp);
       } else {
         return doApply<POSITION + 1>(
-            idx, target, extra..., (const temp_type*)nullptr);
+            idx, target, notNull, extra..., (const temp_type*)nullptr);
       }
     }
   }
@@ -761,9 +838,12 @@ class SimpleFunctionAdapter : public VectorFunction {
       std::enable_if_t<
           POSITION == FUNC::num_args && FUNC::is_default_null_behavior,
           int32_t> = 0>
-  FOLLY_ALWAYS_INLINE bool
-  doApply(size_t /*idx*/, T& target, const Values&... values) const {
-    return (*fn_).call(target, values...);
+  FOLLY_ALWAYS_INLINE Status doApply(
+      size_t /*idx*/,
+      T& target,
+      bool& notNull,
+      const Values&... values) const {
+    return (*fn_).call(target, notNull, values...);
   }
 
   // For NOT default null behavior, terminate with UDFHolder::callNullable.
@@ -773,9 +853,12 @@ class SimpleFunctionAdapter : public VectorFunction {
       std::enable_if_t<
           POSITION == FUNC::num_args && !FUNC::is_default_null_behavior,
           int32_t> = 0>
-  FOLLY_ALWAYS_INLINE bool
-  doApply(size_t /*idx*/, T& target, const Values*... values) const {
-    return (*fn_).callNullable(target, values...);
+  FOLLY_ALWAYS_INLINE Status doApply(
+      size_t /*idx*/,
+      T& target,
+      bool& notNull,
+      const Values*... values) const {
+    return (*fn_).callNullable(target, notNull, values...);
   }
 
   // == NOT-NULL VARIANT ==
@@ -792,13 +875,14 @@ class SimpleFunctionAdapter : public VectorFunction {
       typename R0,
       typename... TStuff,
       std::enable_if_t<POSITION != FUNC::num_args, int32_t> = 0>
-  FOLLY_ALWAYS_INLINE bool doApplyNotNull(
+  FOLLY_ALWAYS_INLINE Status doApplyNotNull(
       size_t idx,
       T& target,
+      bool& notNull,
       R0& currentReader,
       const TStuff&... extra) const {
     decltype(currentReader[idx]) v0 = currentReader[idx];
-    return doApplyNotNull<POSITION + 1>(idx, target, extra..., v0);
+    return doApplyNotNull<POSITION + 1>(idx, target, notNull, extra..., v0);
   }
 
   // For default null behavior, Terminate by with UDFHolder::call.
@@ -806,9 +890,12 @@ class SimpleFunctionAdapter : public VectorFunction {
       size_t POSITION,
       typename... Values,
       std::enable_if_t<POSITION == FUNC::num_args, int32_t> = 0>
-  FOLLY_ALWAYS_INLINE bool
-  doApplyNotNull(size_t /*idx*/, T& target, const Values&... values) const {
-    return (*fn_).call(target, values...);
+  FOLLY_ALWAYS_INLINE Status doApplyNotNull(
+      size_t /*idx*/,
+      T& target,
+      bool& notNull,
+      const Values&... values) const {
+    return (*fn_).call(target, notNull, values...);
   }
 
   template <
@@ -816,24 +903,27 @@ class SimpleFunctionAdapter : public VectorFunction {
       typename R0,
       typename... TStuff,
       std::enable_if_t<POSITION != FUNC::num_args, int32_t> = 0>
-  FOLLY_ALWAYS_INLINE bool doApplyAsciiNotNull(
+  FOLLY_ALWAYS_INLINE Status doApplyAsciiNotNull(
       size_t idx,
       T& target,
+      bool& notNull,
       R0& currentReader,
       const TStuff&... extra) const {
     decltype(currentReader[idx]) v0 = currentReader[idx];
-    return doApplyAsciiNotNull<POSITION + 1>(idx, target, extra..., v0);
+    return doApplyAsciiNotNull<POSITION + 1>(
+        idx, target, notNull, extra..., v0);
   }
 
   template <
       size_t POSITION,
       typename... Values,
       std::enable_if_t<POSITION == FUNC::num_args, int32_t> = 0>
-  FOLLY_ALWAYS_INLINE bool doApplyAsciiNotNull(
+  FOLLY_ALWAYS_INLINE Status doApplyAsciiNotNull(
       size_t /*idx*/,
       T& target,
+      bool& notNull,
       const Values&... values) const {
-    return (*fn_).callAscii(target, values...);
+    return (*fn_).callAscii(target, notNull, values...);
   }
 
   template <
@@ -841,22 +931,26 @@ class SimpleFunctionAdapter : public VectorFunction {
       typename R0,
       typename... TStuff,
       std::enable_if_t<POSITION != FUNC::num_args, int32_t> = 0>
-  FOLLY_ALWAYS_INLINE bool doApplyNullFree(
+  FOLLY_ALWAYS_INLINE Status doApplyNullFree(
       size_t idx,
       T& target,
+      bool& notNull,
       R0& currentReader,
       const TStuff&... extra) const {
     auto v0 = currentReader.readNullFree(idx);
-    return doApplyNullFree<POSITION + 1>(idx, target, extra..., v0);
+    return doApplyNullFree<POSITION + 1>(idx, target, notNull, extra..., v0);
   }
 
   template <
       size_t POSITION,
       typename... Values,
       std::enable_if_t<POSITION == FUNC::num_args, int32_t> = 0>
-  FOLLY_ALWAYS_INLINE bool
-  doApplyNullFree(size_t /*idx*/, T& target, const Values&... values) const {
-    return (*fn_).callNullFree(target, values...);
+  FOLLY_ALWAYS_INLINE Status doApplyNullFree(
+      size_t /*idx*/,
+      T& target,
+      bool& notNull,
+      const Values&... values) const {
+    return (*fn_).callNullFree(target, notNull, values...);
   }
 };
 
@@ -868,11 +962,15 @@ class SimpleFunctionAdapterFactoryImpl : public SimpleFunctionAdapterFactory {
 
   explicit SimpleFunctionAdapterFactoryImpl() {}
 
+  static constexpr bool is_default_null_behavior =
+      UDFHolder::is_default_null_behavior;
+
   std::unique_ptr<VectorFunction> createVectorFunction(
+      const std::vector<TypePtr>& inputTypes,
       const std::vector<VectorPtr>& constantInputs,
       const core::QueryConfig& config) const override {
     return std::make_unique<SimpleFunctionAdapter<UDFHolder>>(
-        config, constantInputs);
+        inputTypes, config, constantInputs);
   }
 };
 
diff --git a/velox/expression/SimpleFunctionRegistry.cpp b/velox/expression/SimpleFunctionRegistry.cpp
index 36c6849f48b40..34d7467932865 100644
--- a/velox/expression/SimpleFunctionRegistry.cpp
+++ b/velox/expression/SimpleFunctionRegistry.cpp
@@ -33,21 +33,44 @@ SimpleFunctionRegistry& mutableSimpleFunctions() {
   return simpleFunctionsInternal();
 }
 
-void SimpleFunctionRegistry::registerFunctionInternal(
+bool SimpleFunctionRegistry::registerFunctionInternal(
     const std::string& name,
     const std::shared_ptr<const Metadata>& metadata,
-    const FunctionFactory& factory) {
+    const FunctionFactory& factory,
+    bool overwrite) {
   const auto sanitizedName = sanitizeName(name);
-  registeredFunctions_.withWLock([&](auto& map) {
+  return registeredFunctions_.withWLock([&](auto& map) {
     SignatureMap& signatureMap = map[sanitizedName];
-    signatureMap[*metadata->signature()] =
-        std::make_unique<const FunctionEntry>(metadata, factory);
+    auto& functions = signatureMap[*metadata->signature()];
+
+    for (auto it = functions.begin(); it != functions.end(); ++it) {
+      const auto& otherMetadata = (*it)->getMetadata();
+
+      if (metadata->physicalSignatureEquals(otherMetadata)) {
+        if (!overwrite) {
+          return false;
+        }
+        functions.erase(it);
+        break;
+      }
+
+      // Make sure default-null-behavior and deterministic properties are the
+      // same for all implementations of a given logical signature.
+      VELOX_USER_CHECK_EQ(
+          metadata->defaultNullBehavior(), otherMetadata.defaultNullBehavior());
+      VELOX_USER_CHECK_EQ(
+          metadata->isDeterministic(), otherMetadata.isDeterministic());
+    }
+
+    functions.emplace_back(
+        std::make_unique<const FunctionEntry>(metadata, factory));
+    return true;
   });
 }
 
 namespace {
-// This function is not thread safe should be called only from within a
-// syncrhronized read region of registeredFunctions_.
+// This function is not thread safe. It should be called only from within a
+// synchronized read region of registeredFunctions_.
 const SignatureMap* getSignatureMap(
     const std::string& name,
     const FunctionMap& registeredFunctions) {
@@ -72,6 +95,55 @@ SimpleFunctionRegistry::getFunctionSignatures(const std::string& name) const {
   return signatures;
 }
 
+std::vector<std::pair<VectorFunctionMetadata, const FunctionSignature*>>
+SimpleFunctionRegistry::getFunctionSignaturesAndMetadata(
+    const std::string& name) const {
+  std::vector<std::pair<VectorFunctionMetadata, const FunctionSignature*>>
+      result;
+  registeredFunctions_.withRLock([&](const auto& map) {
+    if (const auto* signatureMap = getSignatureMap(name, map)) {
+      result.reserve(signatureMap->size());
+      for (const auto& [signature, functions] : *signatureMap) {
+        VectorFunctionMetadata metadata{
+            false,
+            functions[0]->getMetadata().isDeterministic(),
+            functions[0]->getMetadata().defaultNullBehavior()};
+        result.emplace_back(
+            std::pair<VectorFunctionMetadata, const FunctionSignature*>{
+                metadata, &signature});
+      }
+    }
+  });
+  return result;
+}
+
+namespace {
+
+// Same as Type::kindEquals, but matches UNKNOWN in 'physicalType' to any type.
+bool physicalTypeMatches(const TypePtr& type, const TypePtr& physicalType) {
+  if (physicalType->isUnKnown()) {
+    return true;
+  }
+
+  if (type->kind() != physicalType->kind()) {
+    return false;
+  }
+
+  if (type->size() != physicalType->size()) {
+    return false;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (!physicalTypeMatches(type->childAt(i), physicalType->childAt(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+} // namespace
+
 std::optional<SimpleFunctionRegistry::ResolvedSimpleFunction>
 SimpleFunctionRegistry::resolveFunction(
     const std::string& name,
@@ -83,12 +155,37 @@ SimpleFunctionRegistry::resolveFunction(
       for (const auto& [candidateSignature, functionEntry] : *signatureMap) {
         SignatureBinder binder(candidateSignature, argTypes);
         if (binder.tryBind()) {
-          auto* currentCandidate = functionEntry.get();
-          if (!selectedCandidate ||
-              currentCandidate->getMetadata().priority() <
-                  selectedCandidate->getMetadata().priority()) {
-            selectedCandidate = currentCandidate;
-            selectedCandidateType = binder.tryResolveReturnType();
+          for (const auto& currentCandidate : functionEntry) {
+            const auto& m = currentCandidate->getMetadata();
+
+            // For variadic signatures, number of arguments in function call may
+            // be one less than number of arguments in the signature.
+            const auto numArgsToMatch =
+                std::min(argTypes.size(), m.argPhysicalTypes().size());
+
+            bool match = true;
+            for (auto i = 0; i < numArgsToMatch; ++i) {
+              if (!physicalTypeMatches(argTypes[i], m.argPhysicalTypes()[i])) {
+                match = false;
+                break;
+              }
+            }
+
+            if (!match) {
+              continue;
+            }
+
+            if (!selectedCandidate ||
+                currentCandidate->getMetadata().priority() <
+                    selectedCandidate->getMetadata().priority()) {
+              auto resultType = binder.tryResolveReturnType();
+              VELOX_CHECK_NOT_NULL(resultType);
+
+              if (physicalTypeMatches(resultType, m.resultPhysicalType())) {
+                selectedCandidate = currentCandidate.get();
+                selectedCandidateType = resultType;
+              }
+            }
           }
         }
       }
diff --git a/velox/expression/SimpleFunctionRegistry.h b/velox/expression/SimpleFunctionRegistry.h
index 2d1e1a431c831..2948f6af0c0b9 100644
--- a/velox/expression/SimpleFunctionRegistry.h
+++ b/velox/expression/SimpleFunctionRegistry.h
@@ -24,8 +24,11 @@
 namespace facebook::velox::exec {
 
 template <typename T>
-const std::shared_ptr<const T>& singletonUdfMetadata() {
-  static auto instance = std::make_shared<const T>();
+const std::shared_ptr<const T>& singletonUdfMetadata(
+    bool defaultNullBehavior,
+    const std::vector<exec::SignatureVariable>& constraints = {}) {
+  static auto instance =
+      std::make_shared<const T>(defaultNullBehavior, constraints);
   return instance;
 }
 
@@ -52,23 +55,39 @@ struct FunctionEntry {
   const FunctionFactory factory_;
 };
 
-using SignatureMap =
-    std::unordered_map<FunctionSignature, std::unique_ptr<const FunctionEntry>>;
+using SignatureMap = std::unordered_map<
+    FunctionSignature,
+    std::vector<std::unique_ptr<const FunctionEntry>>>;
 using FunctionMap = std::unordered_map<std::string, SignatureMap>;
 
 class SimpleFunctionRegistry {
  public:
+  /// Register a UDF with the given aliases and constraints. If an alias already
+  /// exists and 'overwrite' is true, the existing entry in the function
+  /// registry is overwritten by the current UDF. If an alias already exists and
+  /// 'overwrite' is false, the current UDF is not registered with this alias.
+  /// This method returns true if all 'aliases' are registered successfully. It
+  /// returns false if any alias in 'aliases' already exists in the registry and
+  /// is not overwritten.
   template <typename UDF>
-  void registerFunction(const std::vector<std::string>& aliases = {}) {
-    const auto& metadata = singletonUdfMetadata<typename UDF::Metadata>();
-    const auto factory = [metadata]() { return CreateUdf<UDF>(); };
+  bool registerFunction(
+      const std::vector<std::string>& aliases,
+      const std::vector<exec::SignatureVariable>& constraints,
+      bool overwrite) {
+    const auto& metadata = singletonUdfMetadata<typename UDF::Metadata>(
+        UDF::is_default_null_behavior, constraints);
+    const auto factory = []() { return CreateUdf<UDF>(); };
 
     if (aliases.empty()) {
-      registerFunctionInternal(metadata->getName(), metadata, factory);
+      return registerFunctionInternal(
+          metadata->getName(), metadata, factory, overwrite);
     } else {
+      bool registered = true;
       for (const auto& name : aliases) {
-        registerFunctionInternal(name, metadata, factory);
+        registered &=
+            registerFunctionInternal(name, metadata, factory, overwrite);
       }
+      return registered;
     }
   }
 
@@ -91,6 +110,9 @@ class SimpleFunctionRegistry {
   std::vector<const FunctionSignature*> getFunctionSignatures(
       const std::string& name) const;
 
+  std::vector<std::pair<VectorFunctionMetadata, const FunctionSignature*>>
+  getFunctionSignaturesAndMetadata(const std::string& name) const;
+
   class ResolvedSimpleFunction {
    public:
     ResolvedSimpleFunction(
@@ -102,17 +124,24 @@ class SimpleFunctionRegistry {
       return functionEntry_.createFunction();
     }
 
-    TypePtr& type() {
+    const TypePtr& type() const {
       return type_;
     }
 
-    const Metadata& getMetadata() const {
-      return functionEntry_.getMetadata();
+    std::string helpMessage(const std::string& name) const {
+      return functionEntry_.getMetadata().helpMessage(name);
+    }
+
+    VectorFunctionMetadata metadata() const {
+      return VectorFunctionMetadata{
+          false,
+          functionEntry_.getMetadata().isDeterministic(),
+          functionEntry_.getMetadata().defaultNullBehavior()};
     }
 
    private:
     const FunctionEntry& functionEntry_;
-    TypePtr type_;
+    const TypePtr type_;
   };
 
   std::optional<ResolvedSimpleFunction> resolveFunction(
@@ -125,10 +154,17 @@ class SimpleFunctionRegistry {
     return std::make_unique<T>();
   }
 
-  void registerFunctionInternal(
+  /// Registers a function with the given name and metadata. If an entry with
+  /// the name already exists and 'overwrite' is true, the existing entry is
+  /// overwritten. If an entry with the name already exists and 'overwrite' is
+  /// false, the function reigstry remain unchanged. This method returns true if
+  /// the function is successfully registered. It returns false if the function
+  /// registry remains unchanged.
+  bool registerFunctionInternal(
       const std::string& name,
       const std::shared_ptr<const Metadata>& metadata,
-      const FunctionFactory& factory);
+      const FunctionFactory& factory,
+      bool overwrite);
 
   folly::Synchronized<FunctionMap> registeredFunctions_;
 };
@@ -137,11 +173,21 @@ const SimpleFunctionRegistry& simpleFunctions();
 
 SimpleFunctionRegistry& mutableSimpleFunctions();
 
-// This function should be called once and alone.
+/// This function should be called once and alone.
+/// @param names Aliases for the function.
+/// @param constraints Additional constraints for variables used in function
+/// signature. Primarily used to specify rules for calculating precision and
+/// scale for decimal result types.
+/// @param overwrite If true, overwrites existing entries in the function
+/// registry with the same names.
 template <typename UDFHolder>
-void registerSimpleFunction(const std::vector<std::string>& names) {
-  mutableSimpleFunctions()
-      .registerFunction<SimpleFunctionAdapterFactoryImpl<UDFHolder>>(names);
+bool registerSimpleFunction(
+    const std::vector<std::string>& names,
+    const std::vector<exec::SignatureVariable>& constraints,
+    bool overwrite) {
+  return mutableSimpleFunctions()
+      .registerFunction<SimpleFunctionAdapterFactoryImpl<UDFHolder>>(
+          names, constraints, overwrite);
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SpecialFormRegistry.cpp b/velox/expression/SpecialFormRegistry.cpp
index 616378ce41521..3957981905b35 100644
--- a/velox/expression/SpecialFormRegistry.cpp
+++ b/velox/expression/SpecialFormRegistry.cpp
@@ -29,8 +29,10 @@ SpecialFormRegistry& specialFormRegistryInternal() {
 void SpecialFormRegistry::registerFunctionCallToSpecialForm(
     const std::string& name,
     std::unique_ptr<FunctionCallToSpecialForm> functionCallToSpecialForm) {
-  registry_.withWLock(
-      [&](auto& map) { map[name] = std::move(functionCallToSpecialForm); });
+  const auto sanitizedName = sanitizeName(name);
+  registry_.withWLock([&](auto& map) {
+    map[sanitizedName] = std::move(functionCallToSpecialForm);
+  });
 }
 
 void SpecialFormRegistry::unregisterAllFunctionCallToSpecialForm() {
@@ -39,9 +41,10 @@ void SpecialFormRegistry::unregisterAllFunctionCallToSpecialForm() {
 
 FunctionCallToSpecialForm* FOLLY_NULLABLE
 SpecialFormRegistry::getSpecialForm(const std::string& name) const {
+  const auto sanitizedName = sanitizeName(name);
   FunctionCallToSpecialForm* specialForm = nullptr;
   registry_.withRLock([&](const auto& map) {
-    auto it = map.find(name);
+    auto it = map.find(sanitizedName);
     if (it != map.end()) {
       specialForm = it->second.get();
     }
diff --git a/velox/expression/SwitchExpr.cpp b/velox/expression/SwitchExpr.cpp
index 5f6d493ad9a4c..3ef508a6c8bb8 100644
--- a/velox/expression/SwitchExpr.cpp
+++ b/velox/expression/SwitchExpr.cpp
@@ -77,9 +77,9 @@ void SwitchExpr::evalSpecialForm(
       const auto& vector = context.getField(field->index(context));
       if (vector->mayHaveNulls()) {
         LocalDecodedVector decoded(context, *vector, remaining);
-        addNulls(remaining, decoded->nulls(), context, localResult);
+        addNulls(remaining, decoded->nulls(&remaining), context, localResult);
         remaining.deselectNulls(
-            decoded->nulls(), remaining.begin(), remaining.end());
+            decoded->nulls(&remaining), remaining.begin(), remaining.end());
       }
     }
   }
diff --git a/velox/expression/TryExpr.cpp b/velox/expression/TryExpr.cpp
index 41db0ed1119a2..d8069e1abe1d5 100644
--- a/velox/expression/TryExpr.cpp
+++ b/velox/expression/TryExpr.cpp
@@ -23,6 +23,11 @@ void TryExpr::evalSpecialForm(
     EvalCtx& context,
     VectorPtr& result) {
   ScopedVarSetter throwOnError(context.mutableThrowOnError(), false);
+  ScopedVarSetter captureErrorDetails(
+      context.mutableCaptureErrorDetails(), false);
+
+  ScopedThreadSkipErrorDetails skipErrorDetails(true);
+
   // It's possible with nested TRY expressions that some rows already threw
   // exceptions in earlier expressions that haven't been handled yet. To avoid
   // incorrectly handling them here, store those errors and temporarily reset
@@ -31,7 +36,12 @@ void TryExpr::evalSpecialForm(
   // This also prevents this TRY expression from leaking exceptions to the
   // parent TRY expression, so the parent won't incorrectly null out rows that
   // threw exceptions which this expression already handled.
-  ScopedVarSetter<ErrorVectorPtr> errorsSetter(context.errorsPtr(), nullptr);
+  ScopedVarSetter<EvalErrorsPtr> errorsSetter(context.errorsPtr(), nullptr);
+
+  // Allocate error vector to avoid repeated re-allocations for every failed
+  // row.
+  context.ensureErrorsVectorSize(rows.end());
+
   inputs_[0]->eval(rows, context, result);
 
   nullOutErrors(rows, context, result);
@@ -42,6 +52,11 @@ void TryExpr::evalSpecialFormSimplified(
     EvalCtx& context,
     VectorPtr& result) {
   ScopedVarSetter throwOnError(context.mutableThrowOnError(), false);
+  ScopedVarSetter captureErrorDetails(
+      context.mutableCaptureErrorDetails(), false);
+
+  ScopedThreadSkipErrorDetails skipErrorDetails(true);
+
   // It's possible with nested TRY expressions that some rows already threw
   // exceptions in earlier expressions that haven't been handled yet. To avoid
   // incorrectly handling them here, store those errors and temporarily reset
@@ -50,7 +65,8 @@ void TryExpr::evalSpecialFormSimplified(
   // This also prevents this TRY expression from leaking exceptions to the
   // parent TRY expression, so the parent won't incorrectly null out rows that
   // threw exceptions which this expression already handled.
-  ScopedVarSetter<ErrorVectorPtr> errorsSetter(context.errorsPtr(), nullptr);
+  ScopedVarSetter<EvalErrorsPtr> errorsSetter(context.errorsPtr(), nullptr);
+
   inputs_[0]->evalSimplified(rows, context, result);
 
   nullOutErrors(rows, context, result);
@@ -63,27 +79,24 @@ namespace {
 void applyListenersOnError(
     const SelectivityVector& rows,
     const EvalCtx& context) {
-  auto errors = context.errors();
+  const auto* errors = context.errors();
   VELOX_CHECK_NOT_NULL(errors);
 
-  exec::LocalSelectivityVector errorRows(context.execCtx(), errors->size());
-  errorRows->clearAll();
+  vector_size_t numErrors = 0;
   rows.applyToSelected([&](auto row) {
-    if (row < errors->size() && !errors->isNullAt(row)) {
-      errorRows->setValid(row, true);
+    if (errors->hasErrorAt(row)) {
+      ++numErrors;
     }
   });
-  errorRows->updateBounds();
 
-  if (!errorRows->hasSelections()) {
+  if (numErrors == 0) {
     return;
   }
 
   exprSetListeners().withRLock([&](auto& listeners) {
     if (!listeners.empty()) {
       for (auto& listener : listeners) {
-        listener->onError(
-            *errorRows, *errors, context.execCtx()->queryCtx()->queryId());
+        listener->onError(numErrors, context.execCtx()->queryCtx()->queryId());
       }
     }
   });
@@ -93,62 +106,63 @@ void applyListenersOnError(
 void TryExpr::nullOutErrors(
     const SelectivityVector& rows,
     EvalCtx& context,
-    VectorPtr& result) {
-  auto errors = context.errors();
-  if (errors) {
-    applyListenersOnError(rows, context);
-
-    if (result->encoding() == VectorEncoding::Simple::CONSTANT) {
-      // Since it's constant, if any row is NULL they're all NULL, so check row
-      // 0 arbitrarily.
-      if (result->isNullAt(0)) {
-        // The result is already a NULL constant, so this is a no-op.
-        return;
-      }
+    VectorPtr& result) const {
+  const auto* errors = context.errors();
+  if (!errors) {
+    return;
+  }
 
-      if (errors->isConstantEncoding()) {
-        // Set the result to be a NULL constant.
-        result = BaseVector::createNullConstant(
-            result->type(), result->size(), context.pool());
-      } else {
-        auto size = result->size();
-        VELOX_DCHECK_GE(size, rows.end());
-
-        auto nulls = allocateNulls(size, context.pool());
-        auto rawNulls = nulls->asMutable<uint64_t>();
-        rows.applyToSelected([&](auto row) {
-          if (row < errors->size() && !errors->isNullAt(row)) {
-            bits::setNull(rawNulls, row, true);
-          }
-        });
-        // Wrap in dictionary indices all pointing to index 0.
-        auto indices = allocateIndices(size, context.pool());
-        result = BaseVector::wrapInDictionary(nulls, indices, size, result);
+  if (!errors->hasError()) {
+    return;
+  }
+
+  applyListenersOnError(rows, context);
+
+  if (result->isConstantEncoding()) {
+    // Since it's constant, if any row is NULL they're all NULL, so check row
+    // 0 arbitrarily.
+    if (result->isNullAt(0)) {
+      // The result is already a NULL constant, so this is a no-op.
+      return;
+    }
+
+    auto size = result->size();
+    VELOX_DCHECK_GE(size, rows.end());
+
+    auto nulls = allocateNulls(size, context.pool());
+    auto rawNulls = nulls->asMutable<uint64_t>();
+    rows.applyToSelected([&](auto row) {
+      if (errors->hasErrorAt(row)) {
+        bits::setNull(rawNulls, row, true);
       }
-    } else {
-      if (result.unique() && result->isNullsWritable()) {
-        rows.applyToSelected([&](auto row) {
-          if (row < errors->size() && !errors->isNullAt(row)) {
-            result->setNull(row, true);
-          }
-        });
-      } else {
-        auto nulls = allocateNulls(rows.end(), context.pool());
-        auto* rawNulls = nulls->asMutable<uint64_t>();
-        auto indices = allocateIndices(rows.end(), context.pool());
-        auto* rawIndices = indices->asMutable<vector_size_t>();
-
-        rows.applyToSelected([&](auto row) {
-          rawIndices[row] = row;
-          if (row < errors->size() && !errors->isNullAt(row)) {
-            bits::setNull(rawNulls, row, true);
-          }
-        });
-
-        result =
-            BaseVector::wrapInDictionary(nulls, indices, rows.end(), result);
+    });
+
+    // Wrap in dictionary indices all pointing to index 0.
+    auto indices = allocateIndices(size, context.pool());
+    result = BaseVector::wrapInDictionary(nulls, indices, size, result);
+  } else if (
+      result.unique() && result->isNullsWritable() &&
+      result->size() >= rows.end()) {
+    auto* rawNulls = result->mutableRawNulls();
+    rows.applyToSelected([&](auto row) {
+      if (errors->hasErrorAt(row)) {
+        bits::setNull(rawNulls, row, true);
       }
-    }
+    });
+  } else {
+    auto nulls = allocateNulls(rows.end(), context.pool());
+    auto* rawNulls = nulls->asMutable<uint64_t>();
+    auto indices = allocateIndices(rows.end(), context.pool());
+    auto* rawIndices = indices->asMutable<vector_size_t>();
+
+    rows.applyToSelected([&](auto row) {
+      rawIndices[row] = row;
+      if (errors->hasErrorAt(row)) {
+        bits::setNull(rawNulls, row, true);
+      }
+    });
+
+    result = BaseVector::wrapInDictionary(nulls, indices, rows.end(), result);
   }
 }
 
diff --git a/velox/expression/TryExpr.h b/velox/expression/TryExpr.h
index c8065d58ca8d6..9dc80e40f5dae 100644
--- a/velox/expression/TryExpr.h
+++ b/velox/expression/TryExpr.h
@@ -44,7 +44,7 @@ class TryExpr : public SpecialForm {
   void nullOutErrors(
       const SelectivityVector& rows,
       EvalCtx& context,
-      VectorPtr& result);
+      VectorPtr& result) const;
 
  private:
   // This is safe to call only after all metadata is computed for input
diff --git a/velox/expression/TypeSignature.cpp b/velox/expression/TypeSignature.cpp
new file mode 100644
index 0000000000000..b04bb0ae00796
--- /dev/null
+++ b/velox/expression/TypeSignature.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/TypeSignature.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::exec {
+void toAppend(
+    const facebook::velox::exec::TypeSignature& signature,
+    std::string* result) {
+  result->append(signature.toString());
+}
+
+std::string TypeSignature::toString() const {
+  std::ostringstream out;
+  if (rowFieldName_.has_value()) {
+    out << *rowFieldName_ << " ";
+  }
+  out << baseName_;
+  if (!parameters_.empty()) {
+    out << "(" << folly::join(",", parameters_) << ")";
+  }
+  return out.str();
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/TypeSignature.h b/velox/expression/TypeSignature.h
new file mode 100644
index 0000000000000..3dc2144fd3686
--- /dev/null
+++ b/velox/expression/TypeSignature.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace facebook::velox::exec {
+
+// Base type (e.g. map) and optional parameters (e.g. K, V).
+class TypeSignature {
+ public:
+  /// @param baseName The base name of the type. Could describe a concrete type
+  /// name (e.g. map, bigint, double), or a variable (e.g. K, V).
+  /// @param parameters The optional parameters for the type. For example, the
+  /// signature "map(K, V)" would have two parameters, "K", and "V". All
+  /// parameters must be of the same ParameterType.
+  /// @param rowFieldName if this type signature is a field of another parent
+  /// row type, it can optionally have a name. E.g. `row(id bigint)` would have
+  /// "id" set as rowFieldName in the "bigint" parameter.
+  TypeSignature(
+      std::string baseName,
+      std::vector<TypeSignature> parameters,
+      std::optional<std::string> rowFieldName = std::nullopt)
+      : baseName_{std::move(baseName)},
+        parameters_{std::move(parameters)},
+        rowFieldName_(rowFieldName) {}
+
+  const std::string& baseName() const {
+    return baseName_;
+  }
+
+  const std::vector<TypeSignature>& parameters() const {
+    return parameters_;
+  }
+
+  const std::optional<std::string>& rowFieldName() const {
+    return rowFieldName_;
+  }
+
+  std::string toString() const;
+
+  bool operator==(const TypeSignature& rhs) const {
+    return baseName_ == rhs.baseName_ && parameters_ == rhs.parameters_ &&
+        rowFieldName_ == rhs.rowFieldName_;
+  }
+
+ private:
+  const std::string baseName_;
+  const std::vector<TypeSignature> parameters_;
+
+  // If this object is a field of another parent row type, it can optionally
+  // have a name, e.g, `row(id bigint)`
+  std::optional<std::string> rowFieldName_;
+};
+
+using TypeSignaturePtr = std::shared_ptr<TypeSignature>;
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/UdfTypeResolver.h b/velox/expression/UdfTypeResolver.h
index c0bc900396639..e5be108de25ec 100644
--- a/velox/expression/UdfTypeResolver.h
+++ b/velox/expression/UdfTypeResolver.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/type/CppToType.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::exec {
@@ -101,6 +102,20 @@ struct resolver<Array<V>> {
   using out_type = ArrayWriter<V>;
 };
 
+template <typename P, typename S>
+struct resolver<ShortDecimal<P, S>> {
+  using in_type = int64_t;
+  using null_free_in_type = in_type;
+  using out_type = int64_t;
+};
+
+template <typename P, typename S>
+struct resolver<LongDecimal<P, S>> {
+  using in_type = int128_t;
+  using null_free_in_type = in_type;
+  using out_type = int128_t;
+};
+
 template <>
 struct resolver<Varchar> {
   using in_type = StringView;
@@ -129,6 +144,13 @@ struct resolver<IntervalDayTime> {
   using out_type = int64_t;
 };
 
+template <>
+struct resolver<IntervalYearMonth> {
+  using in_type = int32_t;
+  using null_free_in_type = in_type;
+  using out_type = int32_t;
+};
+
 template <typename T>
 struct resolver<std::shared_ptr<T>> {
   using in_type = std::shared_ptr<T>;
@@ -143,8 +165,8 @@ struct resolver<Variadic<T>> {
   // Variadic cannot be used as an out_type
 };
 
-template <typename T>
-struct resolver<Generic<T>> {
+template <typename T, bool comparable, bool orderable>
+struct resolver<Generic<T, comparable, orderable>> {
   using in_type = GenericView;
   using null_free_in_type = in_type;
   using out_type = GenericWriter;
diff --git a/velox/expression/VectorFunction.cpp b/velox/expression/VectorFunction.cpp
index 4ff6f360298ba..44e70cd44977b 100644
--- a/velox/expression/VectorFunction.cpp
+++ b/velox/expression/VectorFunction.cpp
@@ -21,71 +21,133 @@
 
 namespace facebook::velox::exec {
 
+namespace {
+template <typename TResult, typename TFunc>
+std::optional<TResult> applyToVectorFunctionEntry(
+    const std::string& name,
+    TFunc applyFunc) {
+  auto sanitizedName = sanitizeName(name);
+
+  return vectorFunctionFactories().withRLock(
+      [&](auto& functions) -> std::optional<TResult> {
+        auto it = functions.find(sanitizedName);
+        if (it == functions.end()) {
+          return std::nullopt;
+        }
+        return applyFunc(sanitizedName, it->second);
+      });
+}
+
+// Zip `inputTypes` and `constantInputs` vectors into a single
+// vector of `VectorFunctionArg`.
+std::vector<VectorFunctionArg> toVectorFunctionArgs(
+    const std::vector<TypePtr>& inputTypes,
+    const std::vector<VectorPtr>& constantInputs) {
+  std::vector<VectorFunctionArg> args;
+  args.reserve(inputTypes.size());
+
+  for (vector_size_t i = 0; i < inputTypes.size(); ++i) {
+    args.push_back({
+        inputTypes[i],
+        constantInputs.size() > i ? constantInputs[i] : nullptr,
+    });
+  }
+
+  return args;
+}
+} // namespace
+
 VectorFunctionMap& vectorFunctionFactories() {
   static VectorFunctionMap factories;
   return factories;
 }
 
-std::optional<std::vector<FunctionSignaturePtr>> getVectorFunctionSignatures(
+std::optional<VectorFunctionMetadata> getVectorFunctionMetadata(
     const std::string& name) {
-  auto sanitizedName = sanitizeName(name);
+  return applyToVectorFunctionEntry<VectorFunctionMetadata>(
+      name,
+      [&](const auto& /*name*/, const auto& entry) { return entry.metadata; });
+}
 
-  return vectorFunctionFactories()
-      .withRLock([&sanitizedName](auto& functions) -> auto {
-        auto it = functions.find(sanitizedName);
-        return it == functions.end() ? std::nullopt
-                                     : std::optional(it->second.signatures);
+std::optional<std::vector<FunctionSignaturePtr>> getVectorFunctionSignatures(
+    const std::string& name) {
+  return applyToVectorFunctionEntry<std::vector<FunctionSignaturePtr>>(
+      name, [&](const auto& /*name*/, const auto& entry) {
+        return entry.signatures;
       });
 }
 
-std::shared_ptr<const Type> resolveVectorFunction(
+TypePtr resolveVectorFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
-  if (auto vectorFunctionSignatures =
-          exec::getVectorFunctionSignatures(functionName)) {
-    for (const auto& signature : vectorFunctionSignatures.value()) {
-      exec::SignatureBinder binder(*signature, argTypes);
-      if (binder.tryBind()) {
-        return binder.tryResolveReturnType();
-      }
-    }
+  if (auto outputTypeWithMetadata =
+          resolveVectorFunctionWithMetadata(functionName, argTypes)) {
+    return outputTypeWithMetadata->first;
   }
 
   return nullptr;
 }
 
+std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadata(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes) {
+  return applyToVectorFunctionEntry<std::pair<TypePtr, VectorFunctionMetadata>>(
+      functionName,
+      [&](const auto& /*name*/, const auto& entry)
+          -> std::optional<std::pair<TypePtr, VectorFunctionMetadata>> {
+        for (const auto& signature : entry.signatures) {
+          exec::SignatureBinder binder(*signature, argTypes);
+          if (binder.tryBind()) {
+            return {{binder.tryResolveReturnType(), entry.metadata}};
+          }
+        }
+        return std::nullopt;
+      });
+}
+
 std::shared_ptr<VectorFunction> getVectorFunction(
     const std::string& name,
     const std::vector<TypePtr>& inputTypes,
     const std::vector<VectorPtr>& constantInputs,
     const core::QueryConfig& config) {
-  auto sanitizedName = sanitizeName(name);
+  auto functionWithMetadata =
+      getVectorFunctionWithMetadata(name, inputTypes, constantInputs, config);
+  if (!functionWithMetadata.has_value()) {
+    return nullptr;
+  }
+  return functionWithMetadata->first;
+}
 
+std::optional<
+    std::pair<std::shared_ptr<VectorFunction>, VectorFunctionMetadata>>
+getVectorFunctionWithMetadata(
+    const std::string& name,
+    const std::vector<TypePtr>& inputTypes,
+    const std::vector<VectorPtr>& constantInputs,
+    const core::QueryConfig& config) {
   if (!constantInputs.empty()) {
     VELOX_CHECK_EQ(inputTypes.size(), constantInputs.size());
   }
 
-  // Zip `inputTypes` and `constantInputs` vectors into a single vector of
-  // `VectorFunctionArg`.
-  std::vector<VectorFunctionArg> inputArgs;
-  inputArgs.reserve(inputTypes.size());
-
-  for (vector_size_t i = 0; i < inputTypes.size(); ++i) {
-    inputArgs.push_back({
-        inputTypes[i],
-        constantInputs.size() > i ? constantInputs[i] : nullptr,
-    });
-  }
-
-  return vectorFunctionFactories().withRLock(
-      [&sanitizedName, &inputArgs, &config, &inputTypes](
-          auto& functionMap) -> std::shared_ptr<VectorFunction> {
-        if (resolveVectorFunction(sanitizedName, inputTypes)) {
-          auto functionIterator = functionMap.find(sanitizedName);
-          return functionIterator->second.factory(
-              sanitizedName, inputArgs, config);
+  return applyToVectorFunctionEntry<
+      std::pair<std::shared_ptr<VectorFunction>, VectorFunctionMetadata>>(
+      name,
+      [&](const auto& sanitizedName, const auto& entry)
+          -> std::optional<std::pair<
+              std::shared_ptr<VectorFunction>,
+              VectorFunctionMetadata>> {
+        for (const auto& signature : entry.signatures) {
+          exec::SignatureBinder binder(*signature, inputTypes);
+          if (binder.tryBind()) {
+            auto inputArgs = toVectorFunctionArgs(inputTypes, constantInputs);
+
+            return {
+                {entry.factory(sanitizedName, inputArgs, config),
+                 entry.metadata}};
+          }
         }
-        return nullptr;
+        return std::nullopt;
       });
 }
 
diff --git a/velox/expression/VectorFunction.h b/velox/expression/VectorFunction.h
index 5f30c3cb60cdf..6343955e0dbca 100644
--- a/velox/expression/VectorFunction.h
+++ b/velox/expression/VectorFunction.h
@@ -19,6 +19,7 @@
 #include <vector>
 #include "velox/core/Expressions.h"
 #include "velox/expression/EvalCtx.h"
+#include "velox/expression/FunctionMetadata.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/vector/SelectivityVector.h"
 #include "velox/vector/SimpleVector.h"
@@ -44,7 +45,7 @@ class VectorFunction {
   /// vector as flat or constant, but not dictionary encoded.
   ///
   /// Single-argument functions that specify null-in-null-out behavior, e.g.
-  /// isDefaultNullBehavior returns true, will never see a null row in 'rows'.
+  /// defaultNullBehavior is true, will never see a null row in 'rows'.
   /// Hence, they can safely assume that args[0] vector is flat or constant and
   /// has no nulls in specified positions.
   ///
@@ -82,17 +83,6 @@ class VectorFunction {
       EvalCtx& context,
       VectorPtr& result) const = 0;
 
-  virtual bool isDeterministic() const {
-    return true;
-  }
-
-  // Returns true if null in any argument always produces null result.
-  // In this case, "rows" in "apply" will point only to positions for
-  // which all arguments are not null.
-  virtual bool isDefaultNullBehavior() const {
-    return true;
-  }
-
   /// Returns true if (1) supports evaluation on all constant inputs of size >
   /// 1; (2) returns flat or constant result when inputs are all flat, all
   /// constant or a mix of flat and constant; (3) guarantees that if all inputs
@@ -127,6 +117,10 @@ class VectorFunction {
       const {
     return std::nullopt;
   }
+
+  virtual FunctionCanonicalName getCanonicalName() const {
+    return FunctionCanonicalName::kUnknown;
+  }
 };
 
 /// Vector function that generates the specified error for every row. Use this
@@ -162,7 +156,7 @@ class ApplyNeverCalled final : public VectorFunction {
       const TypePtr&,
       EvalCtx&,
       VectorPtr&) const final {
-    VELOX_UNREACHABLE("Not expected to be called.")
+    VELOX_UNREACHABLE("Not expected to be called.");
   }
 };
 
@@ -170,11 +164,17 @@ class ApplyNeverCalled final : public VectorFunction {
 class SimpleFunctionAdapterFactory {
  public:
   virtual std::unique_ptr<VectorFunction> createVectorFunction(
+      const std::vector<TypePtr>& inputTypes,
       const std::vector<VectorPtr>& constantInputs,
       const core::QueryConfig& config) const = 0;
   virtual ~SimpleFunctionAdapterFactory() = default;
 };
 
+/// Returns the function metadata with the specified name. Returns std::nullopt
+/// if there is no function with the specified name.
+std::optional<VectorFunctionMetadata> getVectorFunctionMetadata(
+    const std::string& name);
+
 /// Returns a list of signatures supported by VectorFunction with the specified
 /// name. Returns std::nullopt if there is no function with the specified name.
 std::optional<std::vector<FunctionSignaturePtr>> getVectorFunctionSignatures(
@@ -183,7 +183,12 @@ std::optional<std::vector<FunctionSignaturePtr>> getVectorFunctionSignatures(
 /// Given name of vector function and argument types, returns
 /// the return type if function exists and have a signature that binds to the
 /// input types otherwise returns nullptr.
-std::shared_ptr<const Type> resolveVectorFunction(
+TypePtr resolveVectorFunction(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes);
+
+std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadata(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
@@ -199,23 +204,13 @@ std::shared_ptr<VectorFunction> getVectorFunction(
     const std::vector<VectorPtr>& constantInputs,
     const core::QueryConfig& config);
 
-struct VectorFunctionMetadata {
-  /// Boolean indicating whether this function supports flattening, i.e.
-  /// converting a set of nested calls into a single call.
-  ///
-  ///     f(a, f(b, f(c, d))) => f(a, b, c, d).
-  ///
-  /// For example, concat(string,...), concat(array,...), map_concat(map,...)
-  /// Presto functions support flattening. Similarly, built-in special format
-  /// AND and OR also support flattening.
-  ///
-  /// A function that supports flattening must have a signature with variadic
-  /// arguments of the same type. The result type must be the same as input
-  /// type.
-  bool supportsFlattening{false};
-
-  // TODO Add is-deterministic flag.
-};
+std::optional<
+    std::pair<std::shared_ptr<VectorFunction>, VectorFunctionMetadata>>
+getVectorFunctionWithMetadata(
+    const std::string& name,
+    const std::vector<TypePtr>& inputTypes,
+    const std::vector<VectorPtr>& constantInputs,
+    const core::QueryConfig& config);
 
 /// Registers stateless VectorFunction. The same instance will be used for all
 /// expressions.
diff --git a/velox/expression/VectorReaders.h b/velox/expression/VectorReaders.h
index 8a6609a458a51..26c6046da7a5d 100644
--- a/velox/expression/VectorReaders.h
+++ b/velox/expression/VectorReaders.h
@@ -28,6 +28,7 @@
 
 #include "velox/expression/ComplexViewTypes.h"
 #include "velox/expression/DecodedArgs.h"
+#include "velox/expression/KindToSimpleType.h"
 #include "velox/expression/UdfTypeResolver.h"
 #include "velox/expression/VariadicView.h"
 #include "velox/type/StringView.h"
@@ -632,16 +633,31 @@ struct VectorReader<Variadic<T>> {
   std::vector<std::unique_ptr<VectorReader<T>>> childReaders_;
 };
 
-template <typename T>
-struct VectorReader<Generic<T>> {
+template <typename T, bool comparable, bool orderable>
+struct VectorReader<Generic<T, comparable, orderable>> {
   using exec_in_t = GenericView;
   using exec_null_free_in_t = exec_in_t;
 
-  explicit VectorReader(const DecodedVector* decoded) : decoded_(*decoded) {}
+  template <TypeKind kind>
+  void ensureCastedReader() {
+    if constexpr (TypeTraits<kind>::isPrimitiveType) {
+      this->operator[](0)
+          .template ensureReader<typename KindToSimpleType<kind>::type>();
+    }
+  }
 
-  explicit VectorReader(const VectorReader<Generic<T>>&) = delete;
+  explicit VectorReader(const DecodedVector* decoded) : decoded_(*decoded) {
+    if (decoded->size() && decoded->base()->type()->isPrimitiveType()) {
+      TypeKind kind = decoded->base()->typeKind();
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(ensureCastedReader, kind);
+    }
+  }
+
+  explicit VectorReader(
+      const VectorReader<Generic<T, comparable, orderable>>&) = delete;
 
-  VectorReader<Generic<T>>& operator=(const VectorReader<Generic<T>>&) = delete;
+  VectorReader<Generic<T, comparable, orderable>>& operator=(
+      const VectorReader<Generic<T, comparable, orderable>>&) = delete;
 
   bool isSet(vector_size_t offset) const {
     return !decoded_.isNullAt(offset);
diff --git a/velox/expression/VectorWriters.h b/velox/expression/VectorWriters.h
index a64d6dea0dbb4..fef8e6977b630 100644
--- a/velox/expression/VectorWriters.h
+++ b/velox/expression/VectorWriters.h
@@ -103,7 +103,7 @@ struct VectorWriter<Array<V>> : public VectorWriterBase {
 
   // This should be called once all rows are processed.
   void finish() override {
-    writer_.elementsVector_->resize(writer_.valuesOffset_);
+    writer_.elementsVector()->resize(writer_.valuesOffset_);
     arrayVector_ = nullptr;
     childWriter_.finish();
   }
@@ -277,8 +277,10 @@ struct VectorWriter<Row<T...>> : public VectorWriterBase {
 
   void ensureSize(size_t size) override {
     if (size > rowVector_->size()) {
+      // Note order is important here, we resize children first to ensure
+      // data_ is cached and are not reset when rowVector resizes them.
+      resizeVectorWriters<0>(size);
       rowVector_->resize(size, /*setNotNull*/ false);
-      resizeVectorWriters<0>(rowVector_->size());
     }
   }
 
@@ -371,16 +373,21 @@ struct VectorWriter<
 
   void commitNull() {
     proxy_.vector_->setNull(proxy_.offset_, true);
+    finalizeNull();
+  }
+
+  void finalizeNull() override {
+    proxy_.prepareForReuse(false);
   }
 
   void commit(bool isSet) override {
     // this code path is called when the slice is top-level
     if (isSet) {
       proxy_.finalize();
+      proxy_.prepareForReuse(true);
     } else {
       commitNull();
     }
-    proxy_.prepareForReuse(isSet);
   }
 
   void setOffset(vector_size_t offset) override {
@@ -487,12 +494,13 @@ struct VectorWriter<std::shared_ptr<T>> : public VectorWriterBase {
   vector_t* vector_;
 };
 
-template <typename T>
-struct VectorWriter<Generic<T>> : public VectorWriterBase {
+template <typename T, bool comparable, bool orderable>
+struct VectorWriter<Generic<T, comparable, orderable>>
+    : public VectorWriterBase {
   using exec_out_t = GenericWriter;
   using vector_t = BaseVector;
 
-  VectorWriter<Generic<T>>() : writer_{castWriter_, castType_, offset_} {}
+  VectorWriter() : writer_{castWriter_, castType_, offset_} {}
 
   void setOffset(vector_size_t offset) override {
     offset_ = offset;
@@ -522,9 +530,20 @@ struct VectorWriter<Generic<T>> : public VectorWriterBase {
     }
   }
 
+  template <TypeKind kind>
+  void ensureCastedWriter() {
+    if constexpr (TypeTraits<kind>::isPrimitiveType) {
+      writer_.ensureWriter<typename KindToSimpleType<kind>::type>();
+    }
+  }
+
   void init(vector_t& vector) {
     vector_ = &vector;
     writer_.initialize(vector_);
+    if (vector.type()->isPrimitiveType()) {
+      TypeKind kind = vector.typeKind();
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(ensureCastedWriter, kind);
+    }
   }
 
   void ensureSize(size_t size) override {
@@ -706,10 +725,10 @@ struct VectorWriter<DynamicRow, void> : public VectorWriterBase {
 
   void ensureSize(size_t size) override {
     if (size > rowVector_->size()) {
-      rowVector_->resize(size, /*setNotNull*/ false);
       for (int i = 0; i < writer_.childrenCount_; ++i) {
         writer_.childrenWriters_[i]->ensureSize(size);
       }
+      rowVector_->resize(size, /*setNotNull*/ false);
     }
   }
 
diff --git a/velox/expression/benchmarks/CMakeLists.txt b/velox/expression/benchmarks/CMakeLists.txt
index 2f7e8b020fe13..bad77a8a59912 100644
--- a/velox/expression/benchmarks/CMakeLists.txt
+++ b/velox/expression/benchmarks/CMakeLists.txt
@@ -13,29 +13,33 @@
 # limitations under the License.
 
 set(BENCHMARK_DEPENDENCIES
-    velox_functions_test_lib velox_exec velox_exec_test_lib gflags::gflags
-    Folly::folly ${FOLLY_BENCHMARK})
+    velox_functions_test_lib
+    velox_exec
+    velox_exec_test_lib
+    gflags::gflags
+    Folly::folly
+    ${FOLLY_BENCHMARK})
 
 add_executable(velox_benchmark_call_null_free_no_nulls
                CallNullFreeBenchmark.cpp)
-target_link_libraries(velox_benchmark_call_null_free_no_nulls
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_benchmark_call_null_free_no_nulls ${BENCHMARK_DEPENDENCIES})
 target_compile_definitions(
   velox_benchmark_call_null_free_no_nulls PUBLIC WITH_NULL_ARRAYS=false
                                                  WITH_NULL_ELEMENTS=false)
 
 add_executable(velox_benchmark_call_null_free_null_arrays
                CallNullFreeBenchmark.cpp)
-target_link_libraries(velox_benchmark_call_null_free_null_arrays
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_benchmark_call_null_free_null_arrays ${BENCHMARK_DEPENDENCIES})
 target_compile_definitions(
   velox_benchmark_call_null_free_null_arrays PUBLIC WITH_NULL_ARRAYS=true
                                                     WITH_NULL_ELEMENTS=false)
 
 add_executable(velox_benchmark_call_null_free_null_elements
                CallNullFreeBenchmark.cpp)
-target_link_libraries(velox_benchmark_call_null_free_null_elements
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_benchmark_call_null_free_null_elements ${BENCHMARK_DEPENDENCIES})
 target_compile_definitions(
   velox_benchmark_call_null_free_null_elements PUBLIC WITH_NULL_ARRAYS=false
                                                       WITH_NULL_ELEMENTS=true)
@@ -50,4 +54,5 @@ target_compile_definitions(
   PUBLIC WITH_NULL_ARRAYS=true WITH_NULL_ELEMENTS=true)
 
 add_executable(velox_benchmark_variadic VariadicBenchmark.cpp)
-target_link_libraries(velox_benchmark_variadic ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_benchmark_variadic ${BENCHMARK_DEPENDENCIES})
diff --git a/velox/expression/benchmarks/CallNullFreeBenchmark.cpp b/velox/expression/benchmarks/CallNullFreeBenchmark.cpp
index 43ca628703081..a1498b87806a7 100644
--- a/velox/expression/benchmarks/CallNullFreeBenchmark.cpp
+++ b/velox/expression/benchmarks/CallNullFreeBenchmark.cpp
@@ -312,7 +312,7 @@ BENCHMARK_MULTI(simpleMinIntegerNullFreeFastPath) {
 } // namespace facebook::velox::functions
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   facebook::velox::functions::CallNullFreeBenchmark benchmark;
   benchmark.test();
   folly::runBenchmarks();
diff --git a/velox/expression/benchmarks/CastBenchmark.cpp b/velox/expression/benchmarks/CastBenchmark.cpp
deleted file mode 100644
index 895e74aa23b36..0000000000000
--- a/velox/expression/benchmarks/CastBenchmark.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/Benchmark.h>
-#include <folly/init/Init.h>
-
-#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-
-using namespace facebook::velox;
-
-namespace {
-class CastBenchmark : public functions::test::FunctionBenchmarkBase {
- public:
-  CastBenchmark() : FunctionBenchmarkBase() {}
-
-  size_t doRun(const TypePtr& inputType, const TypePtr& outputType) {
-    folly::BenchmarkSuspender suspender;
-    std::string colName = "c0";
-    std::vector<facebook::velox::core::TypedExprPtr> inputs{
-        std::make_shared<facebook::velox::core::FieldAccessTypedExpr>(
-            inputType, colName)};
-    std::vector<facebook::velox::core::TypedExprPtr> expr{
-        std::make_shared<facebook::velox::core::CastTypedExpr>(
-            outputType, inputs, false)};
-    exec::ExprSet exprSet(expr, &execCtx_);
-
-    facebook::velox::VectorFuzzer fuzzer({}, pool());
-    // With encodings, evalMemo can get invoked which does a copy and adds a lot
-    // of overhead.
-    auto input = fuzzer.fuzzFlatNotNull(inputType);
-    auto rowVector = vectorMaker_.rowVector({colName}, {input});
-    suspender.dismiss();
-
-    size_t cnt = 0;
-    for (auto i = 0; i < 100; i++) {
-      auto result = evaluate(exprSet, rowVector);
-      cnt += result->size();
-
-      // For complex types with lots of children, clearing the result can
-      // actually consume a lot of resources skewing the result.
-      suspender.rehire();
-      result.reset();
-      suspender.dismiss();
-    }
-
-    return cnt;
-  }
-};
-
-BENCHMARK_MULTI(scalar) {
-  folly::BenchmarkSuspender suspender;
-  CastBenchmark benchmark;
-  suspender.dismiss();
-
-  return benchmark.doRun(INTEGER(), BIGINT());
-}
-
-BENCHMARK_MULTI(renameSmallStruct) {
-  folly::BenchmarkSuspender suspender;
-  CastBenchmark benchmark;
-  std::vector<std::string> oldNames;
-  std::vector<std::string> newNames;
-  std::vector<TypePtr> oldTypes;
-  std::vector<TypePtr> newTypes;
-  for (int i = 0; i < 3; i++) {
-    oldNames.push_back("");
-    newNames.push_back(fmt::format("col{}", i));
-    oldTypes.push_back(INTEGER());
-  }
-  newTypes = oldTypes;
-  suspender.dismiss();
-
-  return benchmark.doRun(
-      ROW(std::move(oldNames), std::move(oldTypes)),
-      ROW(std::move(newNames), std::move(newTypes)));
-}
-
-BENCHMARK_MULTI(renameLargeStruct) {
-  folly::BenchmarkSuspender suspender;
-  CastBenchmark benchmark;
-  std::vector<std::string> oldNames;
-  std::vector<std::string> newNames;
-  std::vector<TypePtr> oldTypes;
-  std::vector<TypePtr> newTypes;
-  for (int i = 0; i < 1000; i++) {
-    oldNames.push_back("");
-    newNames.push_back(fmt::format("col{}", i));
-    oldTypes.push_back(INTEGER());
-  }
-  newTypes = oldTypes;
-  suspender.dismiss();
-
-  return benchmark.doRun(
-      ROW(std::move(oldNames), std::move(oldTypes)),
-      ROW(std::move(newNames), std::move(newTypes)));
-}
-
-BENCHMARK_MULTI(smallStructNested) {
-  folly::BenchmarkSuspender suspender;
-  CastBenchmark benchmark;
-  std::vector<std::string> oldNames;
-  std::vector<std::string> newNames;
-  std::vector<TypePtr> oldTypes;
-  std::vector<TypePtr> newTypes;
-  for (int i = 0; i < 3; i++) {
-    oldNames.push_back("");
-    newNames.push_back(fmt::format("col{}", i));
-    oldTypes.push_back(INTEGER());
-    newTypes.push_back(BIGINT());
-  }
-  suspender.dismiss();
-
-  return benchmark.doRun(
-      ROW(std::move(oldNames), std::move(oldTypes)),
-      ROW(std::move(newNames), std::move(newTypes)));
-}
-
-BENCHMARK_MULTI(largeStructNested) {
-  folly::BenchmarkSuspender suspender;
-  CastBenchmark benchmark;
-  std::vector<std::string> oldNames;
-  std::vector<std::string> newNames;
-  std::vector<TypePtr> oldTypes;
-  std::vector<TypePtr> newTypes;
-  for (int i = 0; i < 1000; i++) {
-    oldNames.push_back("");
-    newNames.push_back(fmt::format("col{}", i));
-    oldTypes.push_back(INTEGER());
-    newTypes.push_back(BIGINT());
-  }
-  suspender.dismiss();
-
-  return benchmark.doRun(
-      ROW(std::move(oldNames), std::move(oldTypes)),
-      ROW(std::move(newNames), std::move(newTypes)));
-}
-} // namespace
-
-int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
-
-  folly::runBenchmarks();
-  return 0;
-}
diff --git a/velox/expression/benchmarks/TryBenchmark.cpp b/velox/expression/benchmarks/TryBenchmark.cpp
index 61e6fed47542a..8a947d78520ad 100644
--- a/velox/expression/benchmarks/TryBenchmark.cpp
+++ b/velox/expression/benchmarks/TryBenchmark.cpp
@@ -185,7 +185,7 @@ BENCHMARK_MULTI(divideAllExceptions) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/expression/benchmarks/VariadicBenchmark.cpp b/velox/expression/benchmarks/VariadicBenchmark.cpp
index 1bc058848a9e8..457dbd69efd8c 100644
--- a/velox/expression/benchmarks/VariadicBenchmark.cpp
+++ b/velox/expression/benchmarks/VariadicBenchmark.cpp
@@ -194,7 +194,7 @@ BENCHMARK_MULTI(simpleVariadicLotsOfArgs) {
 } // namespace facebook::velox::functions
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   facebook::velox::functions::VariadicBenchmark benchmark;
   benchmark.test();
   folly::runBenchmarks();
diff --git a/velox/expression/fuzzer/ArgGenerator.h b/velox/expression/fuzzer/ArgGenerator.h
new file mode 100644
index 0000000000000..4c015f7a38c79
--- /dev/null
+++ b/velox/expression/fuzzer/ArgGenerator.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/FunctionSignature.h"
+#include "velox/vector/fuzzer/Utils.h"
+
+namespace facebook::velox::fuzzer {
+
+/// Generates random, but valid input types for a specified function signature
+/// with the return type.
+class ArgGenerator {
+ public:
+  virtual ~ArgGenerator() = default;
+
+  /// Given a signature and a concrete return type returns randomly selected
+  /// valid input types. Returns empty vector if no input types can produce the
+  /// specified result type.
+  virtual std::vector<TypePtr> generateArgs(
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      FuzzerGenerator& rng) = 0;
+};
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ArgumentTypeFuzzer.cpp b/velox/expression/fuzzer/ArgumentTypeFuzzer.cpp
new file mode 100644
index 0000000000000..9ddfdee3b8040
--- /dev/null
+++ b/velox/expression/fuzzer/ArgumentTypeFuzzer.cpp
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/fuzzer/ArgumentTypeFuzzer.h"
+
+#include <boost/algorithm/string.hpp>
+#include <boost/random/uniform_int_distribution.hpp>
+
+#include "velox/expression/ReverseSignatureBinder.h"
+#include "velox/expression/SignatureBinder.h"
+#include "velox/type/Type.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::fuzzer {
+
+std::string typeToBaseName(const TypePtr& type) {
+  if (type->isDecimal()) {
+    return "decimal";
+  }
+  return boost::algorithm::to_lower_copy(std::string{type->kindName()});
+}
+
+std::optional<TypeKind> baseNameToTypeKind(const std::string& typeName) {
+  auto kindName = boost::algorithm::to_upper_copy(typeName);
+  return tryMapNameToTypeKind(kindName);
+}
+
+namespace {
+
+bool isDecimalBaseName(const std::string& typeName) {
+  auto normalized = boost::algorithm::to_lower_copy(typeName);
+
+  return normalized == "decimal";
+}
+
+/// Returns true only if 'str' contains digits.
+bool isPositiveInteger(const std::string& str) {
+  return !str.empty() &&
+      std::find_if(str.begin(), str.end(), [](unsigned char c) {
+        return !std::isdigit(c);
+      }) == str.end();
+}
+
+} // namespace
+
+void ArgumentTypeFuzzer::determineUnboundedIntegerVariables(
+    const exec::TypeSignature& type) {
+  std::vector<exec::TypeSignature> decimalTypes;
+  findDecimalTypes(type, decimalTypes);
+  if (decimalTypes.empty()) {
+    return;
+  }
+  for (const auto& decimalType : decimalTypes) {
+    auto [p, s] = tryBindFixedPrecisionScale(decimalType);
+
+    if (p.has_value() && s.has_value()) {
+      return;
+    }
+
+    const auto& precision = decimalType.parameters()[0].baseName();
+    const auto& scale = decimalType.parameters()[1].baseName();
+
+    if (s.has_value()) {
+      p = std::max<int>(ShortDecimalType::kMinPrecision, s.value());
+      if (p < LongDecimalType::kMaxPrecision) {
+        p = p.value() + rand32(0, LongDecimalType::kMaxPrecision - p.value());
+      }
+
+      integerBindings_[precision] = p.value();
+      return;
+    }
+
+    if (p.has_value()) {
+      s = rand32(0, p.value());
+      integerBindings_[scale] = s.value();
+      return;
+    }
+
+    p = rand32(1, LongDecimalType::kMaxPrecision);
+    s = rand32(0, p.value());
+
+    integerBindings_[precision] = p.value();
+    integerBindings_[scale] = s.value();
+  }
+}
+
+void ArgumentTypeFuzzer::determineUnboundedTypeVariables() {
+  for (auto& [variableName, variableInfo] : variables()) {
+    if (!variableInfo.isTypeParameter()) {
+      continue;
+    }
+
+    if (bindings_[variableName] != nullptr) {
+      continue;
+    }
+
+    // Random randomType() never generates unknown here.
+    // TODO: we should extend randomType types and exclude unknown based
+    // on variableInfo.
+    if (variableInfo.orderableTypesOnly()) {
+      bindings_[variableName] = randOrderableType();
+    } else {
+      bindings_[variableName] = randType();
+    }
+  }
+}
+
+TypePtr ArgumentTypeFuzzer::randType() {
+  return velox::randType(rng_, 2);
+}
+
+TypePtr ArgumentTypeFuzzer::randOrderableType() {
+  return velox::randOrderableType(rng_, 2);
+}
+
+bool ArgumentTypeFuzzer::fuzzArgumentTypes(uint32_t maxVariadicArgs) {
+  if (returnType_ == nullptr) {
+    for (const auto& [name, _] : signature_.variables()) {
+      bindings_.insert({name, nullptr});
+    }
+  } else {
+    exec::ReverseSignatureBinder binder{signature_, returnType_};
+    if (!binder.tryBind()) {
+      return false;
+    }
+
+    auto types = signature_.argumentTypes();
+    types.emplace_back(signature_.returnType());
+    for (const auto& type : types) {
+      std::vector<exec::TypeSignature> decimalTypes;
+      findDecimalTypes(type, decimalTypes);
+      if (decimalTypes.empty()) {
+        continue;
+      }
+
+      // Verify if the precision and scale variables of argument types and
+      // return type can be bound to constant values. If not and extra
+      // constraint is provided, argument types cannot be generated without
+      // following these constraints.
+      for (const auto& decimalType : decimalTypes) {
+        const auto [p, s] = tryBindFixedPrecisionScale(decimalType);
+
+        const auto& precision = decimalType.parameters()[0].baseName();
+        const auto& scale = decimalType.parameters()[1].baseName();
+
+        const auto hasConstraint = [&](const std::string& name) {
+          return !variables().at(name).constraint().empty();
+        };
+
+        if ((!p.has_value() && hasConstraint(precision)) ||
+            (!s.has_value() && hasConstraint(scale))) {
+          return false;
+        }
+      }
+    }
+
+    bindings_ = binder.bindings();
+    integerBindings_ = binder.integerBindings();
+  }
+
+  const auto& formalArgs = signature_.argumentTypes();
+  auto formalArgsCnt = formalArgs.size();
+
+  determineUnboundedTypeVariables();
+  for (const auto& argType : formalArgs) {
+    determineUnboundedIntegerVariables(argType);
+  }
+  for (auto i = 0; i < formalArgsCnt; i++) {
+    TypePtr actualArg;
+    if (formalArgs[i].baseName() == "any") {
+      actualArg = randType();
+    } else {
+      actualArg = exec::SignatureBinder::tryResolveType(
+          formalArgs[i], variables(), bindings_, integerBindings_);
+      VELOX_CHECK(actualArg != nullptr);
+    }
+    argumentTypes_.push_back(actualArg);
+  }
+
+  // Generate random repeats of the last argument type if the signature is
+  // variadic.
+  if (signature_.variableArity()) {
+    auto repeat = boost::random::uniform_int_distribution<uint32_t>(
+        0, maxVariadicArgs)(rng_);
+    auto last = argumentTypes_[formalArgsCnt - 1];
+    for (int i = 0; i < repeat; ++i) {
+      argumentTypes_.push_back(last);
+    }
+  }
+
+  return true;
+}
+
+TypePtr ArgumentTypeFuzzer::fuzzReturnType() {
+  VELOX_CHECK_EQ(
+      returnType_,
+      nullptr,
+      "Only fuzzing uninitialized return type is allowed.");
+
+  determineUnboundedTypeVariables();
+  determineUnboundedIntegerVariables(signature_.returnType());
+
+  const auto& returnType = signature_.returnType();
+
+  if (returnType.baseName() == "any") {
+    returnType_ = randType();
+  } else {
+    returnType_ = exec::SignatureBinder::tryResolveType(
+        returnType, variables(), bindings_, integerBindings_);
+  }
+
+  VELOX_CHECK_NOT_NULL(returnType_);
+  return returnType_;
+}
+
+int32_t ArgumentTypeFuzzer::rand32(int32_t min, int32_t max) {
+  return boost::random::uniform_int_distribution<uint32_t>(min, max)(rng_);
+}
+
+std::optional<int> ArgumentTypeFuzzer::tryFixedBinding(
+    const std::string& name) {
+  auto it = variables().find(name);
+  if (it == variables().end()) {
+    VELOX_CHECK(
+        isPositiveInteger(name),
+        "Precision and scale of a decimal type must refer to a variable "
+        "or specify a positive integer constant: {}",
+        name);
+    return std::stoi(name);
+  }
+
+  if (integerBindings_.count(name) > 0) {
+    return integerBindings_[name];
+  }
+
+  if (isPositiveInteger(it->second.constraint())) {
+    const auto value = std::stoi(it->second.constraint());
+    integerBindings_[name] = value;
+    return value;
+  }
+
+  return std::nullopt;
+}
+
+std::pair<std::optional<int>, std::optional<int>>
+ArgumentTypeFuzzer::tryBindFixedPrecisionScale(
+    const exec::TypeSignature& type) {
+  VELOX_CHECK(isDecimalBaseName(type.baseName()));
+  VELOX_CHECK_EQ(2, type.parameters().size());
+
+  const auto& precisionName = type.parameters()[0].baseName();
+  const auto& scaleName = type.parameters()[1].baseName();
+
+  std::optional<int> p = tryFixedBinding(precisionName);
+  std::optional<int> s = tryFixedBinding(scaleName);
+  return {p, s};
+}
+
+void ArgumentTypeFuzzer::findDecimalTypes(
+    const exec::TypeSignature& type,
+    std::vector<exec::TypeSignature>& decimalTypes) const {
+  if (isDecimalBaseName(type.baseName())) {
+    decimalTypes.push_back(type);
+  }
+  for (const auto& param : type.parameters()) {
+    findDecimalTypes(param, decimalTypes);
+  }
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ArgumentTypeFuzzer.h b/velox/expression/fuzzer/ArgumentTypeFuzzer.h
new file mode 100644
index 0000000000000..08c3375df9f8d
--- /dev/null
+++ b/velox/expression/fuzzer/ArgumentTypeFuzzer.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <random>
+#include <unordered_map>
+
+#include "velox/expression/FunctionSignature.h"
+#include "velox/expression/SignatureBinder.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::fuzzer {
+
+/// For function signatures using type variables, generates a list of
+/// arguments types. Optionally, allows to specify a desired return type. If
+/// specified, the return type acts as a constraint on the possible set of
+/// argument types. If no return type is specified, it also allows generate a
+/// random type that can bind to the function's return type.
+class ArgumentTypeFuzzer {
+ public:
+  ArgumentTypeFuzzer(
+      const exec::FunctionSignature& signature,
+      std::mt19937& rng)
+      : ArgumentTypeFuzzer(signature, nullptr, rng) {}
+
+  ArgumentTypeFuzzer(
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      std::mt19937& rng)
+      : signature_{signature}, returnType_{returnType}, rng_{rng} {}
+
+  /// Generate random argument types. If the desired returnType has been
+  /// specified, checks that it can be bound to the return type of signature_.
+  /// Return true if the generation succeeds, false otherwise. If signature_ has
+  /// variable arity, repeat the last argument at most maxVariadicArgs times.
+  bool fuzzArgumentTypes(uint32_t maxVariadicArgs);
+
+  /// Return the generated list of argument types. This function should be
+  /// called after fuzzArgumentTypes() is called and returns true.
+  const std::vector<TypePtr>& argumentTypes() const {
+    return argumentTypes_;
+  }
+
+  /// Return a random type that can bind to the function signature's return
+  /// type and set returnType_ to this type. This function can only be called
+  /// when returnType_ is uninitialized.
+  TypePtr fuzzReturnType();
+
+ private:
+  /// Return the variables in the signature.
+  auto& variables() const {
+    return signature_.variables();
+  }
+
+  // Returns random integer between min and max inclusive.
+  int32_t rand32(int32_t min, int32_t max);
+
+  // Bind each type variable that is not determined by the return type to a
+  // randomly generated type.
+  void determineUnboundedTypeVariables();
+
+  // Bind integer variables used in specified decimal(p,s) type signature to
+  // randomly generated values if not already bound.
+  // Noop if 'type' is not a decimal type signature.
+  void determineUnboundedIntegerVariables(const exec::TypeSignature& type);
+
+  TypePtr randType();
+
+  /// Generates an orderable random type, including structs, and arrays.
+  TypePtr randOrderableType();
+
+  // Bind 'name' variable, if not already bound, using 'constant' constraint
+  // ('name'='123'). Return bound value if 'name' is already bound or was
+  // successfully bound to a constant value. Return std::nullopt otherwise.
+  std::optional<int> tryFixedBinding(const std::string& name);
+
+  // Bind the precision and scale variables in a decimal type signature to
+  // constant values. Return std::nullopt if the variable cannot be bound to a
+  // constant value.
+  std::pair<std::optional<int>, std::optional<int>> tryBindFixedPrecisionScale(
+      const exec::TypeSignature& type);
+
+  // Find all the nested decimal type signatures recursively.
+  void findDecimalTypes(
+      const exec::TypeSignature& type,
+      std::vector<exec::TypeSignature>& decimalTypes) const;
+
+  const exec::FunctionSignature& signature_;
+
+  TypePtr returnType_;
+
+  std::vector<TypePtr> argumentTypes_;
+
+  /// Bindings between type variables and their actual types.
+  std::unordered_map<std::string, TypePtr> bindings_;
+
+  std::unordered_map<std::string, int> integerBindings_;
+
+  /// RNG to generate random types for unbounded type variables when necessary.
+  std::mt19937& rng_;
+};
+
+/// Return the kind name of type in lower case. This is expected to match the
+/// TypeSignature::baseName_ corresponding to type.
+std::string typeToBaseName(const TypePtr& type);
+
+/// Return the TypeKind that corresponds to typeName.
+std::optional<TypeKind> baseNameToTypeKind(const std::string& typeName);
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/CMakeLists.txt b/velox/expression/fuzzer/CMakeLists.txt
new file mode 100644
index 0000000000000..4e9576db5f23e
--- /dev/null
+++ b/velox/expression/fuzzer/CMakeLists.txt
@@ -0,0 +1,59 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_expression_test_utility ArgumentTypeFuzzer.cpp
+                                          FuzzerToolkit.cpp)
+
+target_link_libraries(
+  velox_expression_test_utility velox_type velox_expression_functions
+  GTest::gtest)
+
+add_library(
+  velox_expression_fuzzer
+  ArgumentTypeFuzzer.cpp
+  DecimalArgGeneratorBase.cpp
+  ExpressionFuzzer.cpp
+  FuzzerRunner.cpp
+  ExpressionFuzzerVerifier.cpp)
+
+target_link_libraries(
+  velox_expression_fuzzer
+  velox_expression_verifier
+  velox_type
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  velox_function_registry
+  velox_expression_test_utility)
+
+add_executable(velox_expression_fuzzer_test ExpressionFuzzerTest.cpp)
+
+target_link_libraries(
+  velox_expression_fuzzer_test
+  velox_expression_fuzzer
+  velox_functions_prestosql
+  GTest::gtest
+  GTest::gtest_main)
+
+add_executable(spark_expression_fuzzer_test SparkExpressionFuzzerTest.cpp)
+
+target_link_libraries(
+  spark_expression_fuzzer_test
+  velox_expression_fuzzer
+  velox_functions_spark
+  GTest::gtest
+  GTest::gtest_main)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/expression/fuzzer/DecimalArgGeneratorBase.cpp b/velox/expression/fuzzer/DecimalArgGeneratorBase.cpp
new file mode 100644
index 0000000000000..1b65b67658c56
--- /dev/null
+++ b/velox/expression/fuzzer/DecimalArgGeneratorBase.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include <boost/random/uniform_int_distribution.hpp>
+
+namespace facebook::velox::fuzzer {
+namespace {
+
+// Returns all the possible decimal types.
+const std::vector<TypePtr>& getAllTypes() {
+  const auto generateAllTypes = []() {
+    std::vector<TypePtr> allTypes;
+    for (auto p = 1; p <= 38; ++p) {
+      for (auto s = 0; s <= p; ++s) {
+        allTypes.push_back(DECIMAL(p, s));
+      }
+    }
+    return allTypes;
+  };
+
+  static const std::vector<TypePtr> allTypes = generateAllTypes();
+  return allTypes;
+}
+
+uint32_t rand32(uint32_t max, FuzzerGenerator& rng) {
+  return boost::random::uniform_int_distribution<uint32_t>()(rng) % max;
+}
+} // namespace
+
+std::vector<TypePtr> DecimalArgGeneratorBase::generateArgs(
+    const exec::FunctionSignature& /*signature*/,
+    const TypePtr& returnType,
+    FuzzerGenerator& rng) {
+  auto inputs = findInputs(returnType, rng);
+  for (const auto& input : inputs) {
+    if (input == nullptr) {
+      return {};
+    }
+  }
+  return inputs;
+}
+
+void DecimalArgGeneratorBase::initialize(uint32_t numArgs) {
+  switch (numArgs) {
+    case 1: {
+      for (const auto& t : getAllTypes()) {
+        auto [p, s] = getDecimalPrecisionScale(*t);
+        if (auto returnType = toReturnType(p, s)) {
+          inputs_[returnType.value()].push_back({t});
+        }
+      }
+      break;
+    }
+    case 2: {
+      for (const auto& a : getAllTypes()) {
+        for (const auto& b : getAllTypes()) {
+          auto [p1, s1] = getDecimalPrecisionScale(*a);
+          auto [p2, s2] = getDecimalPrecisionScale(*b);
+
+          if (auto returnType = toReturnType(p1, s1, p2, s2)) {
+            inputs_[returnType.value()].push_back({a, b});
+          }
+        }
+      }
+      break;
+    }
+    default:
+      VELOX_NYI(
+          "Initialization with {} argument types is not supported.", numArgs);
+  }
+}
+
+std::vector<TypePtr> DecimalArgGeneratorBase::findInputs(
+    const TypePtr& returnType,
+    FuzzerGenerator& rng) const {
+  const auto [p, s] = getDecimalPrecisionScale(*returnType);
+  const auto it = inputs_.find({p, s});
+  if (it == inputs_.end()) {
+    VLOG(1) << "Cannot find input types for " << returnType->toString();
+    return {};
+  }
+
+  const auto index = rand32(it->second.size(), rng);
+  return it->second[index];
+}
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/DecimalArgGeneratorBase.h b/velox/expression/fuzzer/DecimalArgGeneratorBase.h
new file mode 100644
index 0000000000000..c27db1b8d264f
--- /dev/null
+++ b/velox/expression/fuzzer/DecimalArgGeneratorBase.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/ArgGenerator.h"
+
+namespace facebook::velox::fuzzer {
+
+/// An argument type generator for decimal function. A map keyed on the pair of
+/// precision and scale could be initialized with all possible input types.
+/// Argument types are generated by looking up the map with the precision and
+/// scale of return type, and randomly selecting valid input types. Derived
+/// classes should call 'initialize' from the constructor and specify the number
+/// of decimal arguments. They should also implement toReturnType with matching
+/// number of pairs of precision and scale.
+class DecimalArgGeneratorBase : public ArgGenerator {
+ public:
+  std::vector<TypePtr> generateArgs(
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      FuzzerGenerator& rng) override;
+
+ protected:
+  // Computes result type for all possible pairs of decimal input types. Stores
+  // the results in 'inputs_' map keyed by the precision and scale of return
+  // type.
+  // @param numArgs the number of decimal argument types. It only supports
+  // initialization with one or two argument types.
+  virtual void initialize(uint32_t numArgs);
+
+  // Given precisions and scales of the inputs, returns precision and scale of
+  // the result. Returns std::nullopt if a valid return type cannot be generated
+  // with inputs. Used when the return type is generated with one pair of input
+  // precision and scale.
+  virtual std::optional<std::pair<int, int>> toReturnType(int p, int s) {
+    VELOX_UNREACHABLE();
+  }
+
+  // Used when the return type is generated with two pairs of input precision
+  // and scale.
+  virtual std::optional<std::pair<int, int>>
+  toReturnType(int p1, int s1, int p2, int s2) {
+    VELOX_UNREACHABLE();
+  }
+
+ private:
+  // Returns randomly selected pair of input types that produce the specified
+  // result type.
+  std::vector<TypePtr> findInputs(
+      const TypePtr& returnType,
+      FuzzerGenerator& rng) const;
+
+  // Maps from the precision and scale of return type to corresponding input
+  // types.
+  std::unordered_map<std::pair<int, int>, std::vector<std::vector<TypePtr>>>
+      inputs_;
+};
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ExpressionFuzzer.cpp b/velox/expression/fuzzer/ExpressionFuzzer.cpp
new file mode 100644
index 0000000000000..8eae0d3b8e8f6
--- /dev/null
+++ b/velox/expression/fuzzer/ExpressionFuzzer.cpp
@@ -0,0 +1,1406 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <boost/algorithm/string.hpp>
+#include <boost/random/uniform_int_distribution.hpp>
+#include <folly/ScopeGuard.h>
+#include <glog/logging.h>
+#include <exception>
+#include <unordered_set>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/expression/ReverseSignatureBinder.h"
+#include "velox/expression/SimpleFunctionRegistry.h"
+#include "velox/expression/fuzzer/ArgumentTypeFuzzer.h"
+#include "velox/expression/fuzzer/ExpressionFuzzer.h"
+
+namespace facebook::velox::fuzzer {
+
+namespace {
+using exec::SignatureBinder;
+using exec::SignatureBinderBase;
+
+class FullSignatureBinder : public SignatureBinderBase {
+ public:
+  FullSignatureBinder(
+      const exec::FunctionSignature& signature,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& returnType)
+      : SignatureBinderBase(signature) {
+    if (signature_.argumentTypes().size() != argTypes.size()) {
+      return;
+    }
+
+    for (auto i = 0; i < argTypes.size(); ++i) {
+      if (!SignatureBinderBase::tryBind(
+              signature_.argumentTypes()[i], argTypes[i])) {
+        return;
+      }
+    }
+
+    if (!SignatureBinderBase::tryBind(signature_.returnType(), returnType)) {
+      return;
+    }
+
+    bound_ = true;
+  }
+
+  // Returns true if argument types and return type specified in the constructor
+  // match specified signature.
+  bool tryBind() {
+    return bound_;
+  }
+
+ private:
+  bool bound_{false};
+};
+
+static const std::vector<std::string> kIntegralTypes{
+    "tinyint",
+    "smallint",
+    "integer",
+    "bigint",
+    "boolean"};
+
+static const std::vector<std::string> kFloatingPointTypes{"real", "double"};
+
+facebook::velox::exec::FunctionSignaturePtr makeCastSignature(
+    const std::string& fromType,
+    const std::string& toType) {
+  return facebook::velox::exec::FunctionSignatureBuilder()
+      .argumentType(fromType)
+      .returnType(toType)
+      .build();
+}
+
+void addCastFromIntegralSignatures(
+    const std::string& toType,
+    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
+  for (const auto& fromType : kIntegralTypes) {
+    signatures.push_back(makeCastSignature(fromType, toType));
+  }
+}
+
+void addCastFromFloatingPointSignatures(
+    const std::string& toType,
+    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
+  for (const auto& fromType : kFloatingPointTypes) {
+    signatures.push_back(makeCastSignature(fromType, toType));
+  }
+}
+
+void addCastFromVarcharSignature(
+    const std::string& toType,
+    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
+  signatures.push_back(makeCastSignature("varchar", toType));
+}
+
+void addCastFromTimestampSignature(
+    const std::string& toType,
+    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
+  signatures.push_back(makeCastSignature("timestamp", toType));
+}
+
+void addCastFromDateSignature(
+    const std::string& toType,
+    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
+  signatures.push_back(makeCastSignature("date", toType));
+}
+
+std::vector<facebook::velox::exec::FunctionSignaturePtr>
+getSignaturesForCast() {
+  std::vector<facebook::velox::exec::FunctionSignaturePtr> signatures;
+
+  // To integral types.
+  for (const auto& toType : kIntegralTypes) {
+    addCastFromIntegralSignatures(toType, signatures);
+    addCastFromFloatingPointSignatures(toType, signatures);
+    addCastFromVarcharSignature(toType, signatures);
+  }
+
+  // To floating-point types.
+  for (const auto& toType : kFloatingPointTypes) {
+    addCastFromIntegralSignatures(toType, signatures);
+    addCastFromFloatingPointSignatures(toType, signatures);
+    addCastFromVarcharSignature(toType, signatures);
+  }
+
+  // To varchar type.
+  addCastFromIntegralSignatures("varchar", signatures);
+  addCastFromFloatingPointSignatures("varchar", signatures);
+  addCastFromVarcharSignature("varchar", signatures);
+  addCastFromDateSignature("varchar", signatures);
+  addCastFromTimestampSignature("varchar", signatures);
+
+  // To timestamp type.
+  addCastFromVarcharSignature("timestamp", signatures);
+  addCastFromDateSignature("timestamp", signatures);
+
+  // To date type.
+  addCastFromVarcharSignature("date", signatures);
+  addCastFromTimestampSignature("date", signatures);
+
+  // For each supported translation pair T --> U, add signatures of array(T) -->
+  // array(U), map(varchar, T) --> map(varchar, U), row(T) --> row(U).
+  auto size = signatures.size();
+  for (auto i = 0; i < size; ++i) {
+    auto from = signatures[i]->argumentTypes()[0].baseName();
+    auto to = signatures[i]->returnType().baseName();
+
+    signatures.push_back(makeCastSignature(
+        fmt::format("array({})", from), fmt::format("array({})", to)));
+
+    signatures.push_back(makeCastSignature(
+        fmt::format("map(varchar, {})", from),
+        fmt::format("map(varchar, {})", to)));
+
+    signatures.push_back(makeCastSignature(
+        fmt::format("row({})", from), fmt::format("row({})", to)));
+  }
+  return signatures;
+}
+
+static const std::unordered_map<
+    std::string,
+    std::vector<facebook::velox::exec::FunctionSignaturePtr>>
+    kSpecialForms = {
+        {"and",
+         std::vector<facebook::velox::exec::FunctionSignaturePtr>{
+             // Signature: and (condition,...) -> output:
+             // boolean, boolean,.. -> boolean
+             facebook::velox::exec::FunctionSignatureBuilder()
+                 .argumentType("boolean")
+                 .variableArity("boolean")
+                 .returnType("boolean")
+                 .build()}},
+        {"or",
+         std::vector<facebook::velox::exec::FunctionSignaturePtr>{
+             // Signature: or (condition,...) -> output:
+             // boolean, boolean,.. -> boolean
+             facebook::velox::exec::FunctionSignatureBuilder()
+                 .argumentType("boolean")
+                 .variableArity("boolean")
+                 .returnType("boolean")
+                 .build()}},
+        {"coalesce",
+         std::vector<facebook::velox::exec::FunctionSignaturePtr>{
+             // Signature: coalesce (input,...) -> output:
+             // T, T,.. -> T
+             facebook::velox::exec::FunctionSignatureBuilder()
+                 .typeVariable("T")
+                 .argumentType("T")
+                 .variableArity("T")
+                 .returnType("T")
+                 .build()}},
+        {
+            "if",
+            std::vector<facebook::velox::exec::FunctionSignaturePtr>{
+                // Signature: if (condition, then) -> output:
+                // boolean, T -> T
+                facebook::velox::exec::FunctionSignatureBuilder()
+                    .typeVariable("T")
+                    .argumentType("boolean")
+                    .argumentType("T")
+                    .returnType("T")
+                    .build(),
+                // Signature: if (condition, then, else) -> output:
+                // boolean, T, T -> T
+                facebook::velox::exec::FunctionSignatureBuilder()
+                    .typeVariable("T")
+                    .argumentType("boolean")
+                    .argumentType("T")
+                    .argumentType("T")
+                    .returnType("T")
+                    .build()},
+        },
+        {
+            "switch",
+            std::vector<facebook::velox::exec::FunctionSignaturePtr>{
+                // Signature: Switch (condition, then) -> output:
+                // boolean, T -> T
+                // This is only used to bind to a randomly selected type for the
+                // output, then while generating arguments, an override is used
+                // to generate inputs that can create variation of multiple
+                // cases and may or may not include a final else clause.
+                facebook::velox::exec::FunctionSignatureBuilder()
+                    .typeVariable("T")
+                    .argumentType("boolean")
+                    .argumentType("T")
+                    .returnType("T")
+                    .build()},
+        },
+        {
+            "cast",
+            /// TODO: Add supported Cast signatures to CastTypedExpr and expose
+            /// them to fuzzer instead of hard-coding signatures here.
+            getSignaturesForCast(),
+        },
+};
+
+static std::unordered_set<std::string> splitNames(const std::string& names) {
+  // Parse, lower case and trim it.
+  std::vector<folly::StringPiece> nameList;
+  folly::split(',', names, nameList);
+  std::unordered_set<std::string> nameSet;
+
+  for (const auto& it : nameList) {
+    auto str = folly::trimWhitespace(it).toString();
+    folly::toLowerAscii(str);
+    nameSet.insert(str);
+  }
+  return nameSet;
+}
+
+static std::pair<std::string, std::string> splitSignature(
+    const std::string& signature) {
+  const auto parenPos = signature.find("(");
+
+  if (parenPos != std::string::npos) {
+    return {signature.substr(0, parenPos), signature.substr(parenPos)};
+  }
+
+  return {signature, ""};
+}
+
+// Returns if `functionName` is deterministic. Returns true if the function was
+// not found or determinism cannot be established.
+bool isDeterministic(const std::string& functionName) {
+  // We know that the 'cast', 'and', and 'or' special forms are deterministic.
+  // Hard-code them here because they are not real functions and hence cannot
+  // be resolved by the code below.
+  if (functionName == "and" || functionName == "or" ||
+      functionName == "coalesce" || functionName == "if" ||
+      functionName == "switch" || functionName == "cast") {
+    return true;
+  }
+
+  const auto determinism = velox::isDeterministic(functionName);
+  if (!determinism.has_value()) {
+    // functionName must be a special form.
+    LOG(WARNING) << "Unable to determine if '" << functionName
+                 << "' is deterministic or not. Assuming it is.";
+    return true;
+  }
+  return determinism.value();
+}
+
+// Parse the comma separated list of function names, and use it to filter the
+// input signatures.
+static void filterSignatures(
+    facebook::velox::FunctionSignatureMap& input,
+    const std::string& onlyFunctions,
+    const std::unordered_set<std::string>& skipFunctions) {
+  if (!onlyFunctions.empty()) {
+    // Parse, lower case and trim it.
+    auto nameSet = splitNames(onlyFunctions);
+
+    // Use the generated set to filter the input signatures.
+    for (auto it = input.begin(); it != input.end();) {
+      if (!nameSet.count(it->first)) {
+        it = input.erase(it);
+      } else
+        it++;
+    }
+  }
+
+  for (auto skip : skipFunctions) {
+    // 'skip' can be function name or signature.
+    const auto [skipName, skipSignature] = splitSignature(skip);
+
+    if (skipSignature.empty()) {
+      input.erase(skipName);
+    } else {
+      auto it = input.find(skipName);
+      if (it != input.end()) {
+        // Compiler refuses to reference 'skipSignature' from the lambda as
+        // is.
+        const auto& signatureToRemove = skipSignature;
+
+        auto removeIt = std::find_if(
+            it->second.begin(), it->second.end(), [&](const auto& signature) {
+              return signature->toString() == signatureToRemove;
+            });
+        VELOX_CHECK(
+            removeIt != it->second.end(), "Skip signature not found: {}", skip);
+        it->second.erase(removeIt);
+      }
+    }
+  }
+
+  for (auto it = input.begin(); it != input.end();) {
+    if (!isDeterministic(it->first)) {
+      LOG(WARNING) << "Skipping non-deterministic function: " << it->first;
+      it = input.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+static void appendSpecialForms(
+    facebook::velox::FunctionSignatureMap& signatureMap,
+    const std::string& specialForms) {
+  auto specialFormNames = splitNames(specialForms);
+  for (const auto& [name, signatures] : kSpecialForms) {
+    if (specialFormNames.count(name) == 0) {
+      LOG(INFO) << "Skipping special form: " << name;
+      continue;
+    }
+    std::vector<const facebook::velox::exec::FunctionSignature*> rawSignatures;
+    for (const auto& signature : signatures) {
+      rawSignatures.push_back(signature.get());
+    }
+    signatureMap.insert({name, std::move(rawSignatures)});
+  }
+}
+
+std::optional<CallableSignature> processConcreteSignature(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    const exec::FunctionSignature& signature,
+    bool enableComplexTypes) {
+  VELOX_CHECK(
+      signature.variables().empty(),
+      "Only concrete signatures are processed here.");
+
+  CallableSignature callable{
+      .name = functionName,
+      .args = argTypes,
+      .variableArity = signature.variableArity(),
+      .returnType =
+          SignatureBinder::tryResolveType(signature.returnType(), {}, {}),
+      .constantArgs = signature.constantArguments()};
+  VELOX_CHECK_NOT_NULL(callable.returnType);
+
+  bool onlyPrimitiveTypes = callable.returnType->isPrimitiveType();
+
+  for (const auto& arg : argTypes) {
+    onlyPrimitiveTypes = onlyPrimitiveTypes && arg->isPrimitiveType();
+  }
+
+  if (!(onlyPrimitiveTypes || enableComplexTypes)) {
+    LOG(WARNING) << "Skipping '" << callable.toString()
+                 << "' because it contains non-primitive types.";
+
+    return std::nullopt;
+  }
+  return callable;
+}
+
+// Determine whether type is or contains typeName. typeName should be in lower
+// case.
+bool containTypeName(
+    const exec::TypeSignature& type,
+    const std::string& typeName) {
+  auto sanitizedTypeName = exec::sanitizeName(type.baseName());
+  if (sanitizedTypeName == typeName) {
+    return true;
+  }
+  for (const auto& parameter : type.parameters()) {
+    if (containTypeName(parameter, typeName)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Determine whether the signature has an argument or return type that
+// contains typeName. typeName should be in lower case.
+bool useTypeName(
+    const exec::FunctionSignature& signature,
+    const std::string& typeName) {
+  if (containTypeName(signature.returnType(), typeName)) {
+    return true;
+  }
+  for (const auto& argument : signature.argumentTypes()) {
+    if (containTypeName(argument, typeName)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool isSupportedSignature(
+    const exec::FunctionSignature& signature,
+    bool enableComplexType,
+    bool enableDecimalType) {
+  // When enableComplexType is disabled, not supporting complex functions.
+  const bool useComplexType = useTypeName(signature, "array") ||
+      useTypeName(signature, "map") || useTypeName(signature, "row");
+  // When enableDecimalType is disabled, not supporting decimal functions. Not
+  // supporting functions using custom types, timestamp with time zone types and
+  // interval day to second types.
+  return !(
+      useTypeName(signature, "opaque") ||
+      useTypeName(signature, "timestamp with time zone") ||
+      useTypeName(signature, "interval day to second") ||
+      (!enableDecimalType && useTypeName(signature, "decimal")) ||
+      (!enableComplexType && useComplexType) ||
+      (enableComplexType && useTypeName(signature, "unknown")));
+}
+
+/// Returns row numbers for non-null rows among all children in'data' or null
+/// if all rows are null.
+BufferPtr extractNonNullIndices(const RowVectorPtr& data) {
+  DecodedVector decoded;
+  SelectivityVector nonNullRows(data->size());
+
+  for (auto& child : data->children()) {
+    decoded.decode(*child);
+    auto* rawNulls = decoded.nulls(nullptr);
+    if (rawNulls) {
+      nonNullRows.deselectNulls(rawNulls, 0, data->size());
+    }
+    if (!nonNullRows.hasSelections()) {
+      return nullptr;
+    }
+  }
+
+  BufferPtr indices = allocateIndices(nonNullRows.end(), data->pool());
+  auto rawIndices = indices->asMutable<vector_size_t>();
+  vector_size_t cnt = 0;
+  nonNullRows.applyToSelected(
+      [&](vector_size_t row) { rawIndices[cnt++] = row; });
+  VELOX_CHECK_GT(cnt, 0);
+  indices->setSize(cnt * sizeof(vector_size_t));
+  return indices;
+}
+
+/// Wraps child vectors of the specified 'rowVector' in dictionary using
+/// specified 'indices'. Returns new RowVector created from the wrapped
+/// vectors.
+RowVectorPtr wrapChildren(
+    const BufferPtr& indices,
+    const RowVectorPtr& rowVector) {
+  auto size = indices->size() / sizeof(vector_size_t);
+
+  std::vector<VectorPtr> newInputs;
+  for (const auto& child : rowVector->children()) {
+    newInputs.push_back(
+        BaseVector::wrapInDictionary(nullptr, indices, size, child));
+  }
+
+  return std::make_shared<RowVector>(
+      rowVector->pool(), rowVector->type(), nullptr, size, newInputs);
+}
+
+// Return the level of nestin of `type`. Return 0 if `type` is primitive.
+uint32_t levelOfNesting(const TypePtr& type) {
+  if (type->isPrimitiveType()) {
+    return 0;
+  }
+  switch (type->kind()) {
+    case TypeKind::ARRAY:
+      return 1 + levelOfNesting(type->asArray().elementType());
+    case TypeKind::MAP:
+      return 1 +
+          std::max(
+                 levelOfNesting(type->asMap().keyType()),
+                 levelOfNesting(type->asMap().valueType()));
+    case TypeKind::ROW: {
+      auto children = type->asRow().children();
+      VELOX_CHECK(!children.empty());
+      uint32_t maxChildNesting = 0;
+      for (const auto& child : children) {
+        maxChildNesting = std::max(maxChildNesting, levelOfNesting(child));
+      }
+      return 1 + maxChildNesting;
+    }
+    default:
+      VELOX_UNREACHABLE("Not a supported type.");
+  }
+}
+
+} // namespace
+
+ExpressionFuzzer::ExpressionFuzzer(
+    FunctionSignatureMap signatureMap,
+    size_t initialSeed,
+    const std::shared_ptr<VectorFuzzer>& vectorFuzzer,
+    const std::optional<ExpressionFuzzer::Options>& options,
+    const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
+        argGenerators)
+    : options_(options.value_or(Options())),
+      vectorFuzzer_(vectorFuzzer),
+      state{rng_, std::max(1, options_.maxLevelOfNesting)},
+      argGenerators_(argGenerators) {
+  VELOX_CHECK(vectorFuzzer, "Vector fuzzer must be provided");
+  seed(initialSeed);
+
+  appendSpecialForms(signatureMap, options_.specialForms);
+  filterSignatures(
+      signatureMap, options_.useOnlyFunctions, options_.skipFunctions);
+
+  size_t totalFunctions = 0;
+  size_t totalFunctionSignatures = 0;
+  size_t supportedFunctionSignatures = 0;
+  // A local random number generator to be used just in ExpressionFuzzer
+  // constructor. We do not use rng_ in this function because code in this
+  // function may change rng_ and cause it to mismatch with the seed printed in
+  // the log.
+  FuzzerGenerator localRng{
+      static_cast<FuzzerGenerator::result_type>(initialSeed)};
+  // Process each available signature for every function.
+  for (const auto& function : signatureMap) {
+    ++totalFunctions;
+    bool atLeastOneSupported = false;
+    for (const auto& signature : function.second) {
+      ++totalFunctionSignatures;
+
+      if (!isSupportedSignature(
+              *signature,
+              options_.enableComplexTypes,
+              options_.enableDecimalType)) {
+        continue;
+      }
+      if (!(signature->variables().empty() || options_.enableComplexTypes ||
+            options_.enableDecimalType)) {
+        LOG(WARNING) << "Skipping unsupported signature: " << function.first
+                     << signature->toString();
+        continue;
+      }
+      if (signature->variableArity() && !options_.enableVariadicSignatures) {
+        LOG(WARNING) << "Skipping variadic function signature: "
+                     << function.first << signature->toString();
+        continue;
+      }
+
+      if (!signature->variables().empty()) {
+        std::unordered_set<std::string> typeVariables;
+        for (const auto& [name, _] : signature->variables()) {
+          typeVariables.insert(name);
+        }
+        atLeastOneSupported = true;
+        ++supportedFunctionSignatures;
+        signatureTemplates_.emplace_back(SignatureTemplate{
+            function.first, signature, std::move(typeVariables)});
+      } else {
+        // Determine a list of concrete argument types that can bind to the
+        // signature. For non-parameterized signatures, these argument types
+        // will be used to create a callable signature.
+        std::vector<TypePtr> argTypes;
+        bool supportedSignature = true;
+        for (const auto& arg : signature->argumentTypes()) {
+          auto resolvedType = SignatureBinder::tryResolveType(arg, {}, {});
+          if (!resolvedType) {
+            supportedSignature = false;
+            continue;
+          }
+          argTypes.push_back(resolvedType);
+        }
+
+        if (!supportedSignature) {
+          LOG(WARNING) << "Skipping unsupported signature with generic: "
+                       << function.first << signature->toString();
+          continue;
+        }
+        if (auto callableFunction = processConcreteSignature(
+                function.first,
+                argTypes,
+                *signature,
+                options_.enableComplexTypes)) {
+          atLeastOneSupported = true;
+          ++supportedFunctionSignatures;
+          signatures_.emplace_back(*callableFunction);
+        }
+      }
+    }
+
+    if (atLeastOneSupported) {
+      supportedFunctions_.push_back(function.first);
+    }
+  }
+
+  auto unsupportedFunctions = totalFunctions - supportedFunctions_.size();
+  auto unsupportedFunctionSignatures =
+      totalFunctionSignatures - supportedFunctionSignatures;
+  LOG(INFO) << fmt::format(
+      "Total candidate functions: {} ({} signatures)",
+      totalFunctions,
+      totalFunctionSignatures);
+  LOG(INFO) << fmt::format(
+      "Functions with at least one supported signature: {} ({:.2f}%)",
+      supportedFunctions_.size(),
+      (double)supportedFunctions_.size() / totalFunctions * 100);
+  LOG(INFO) << fmt::format(
+      "Functions with no supported signature: {} ({:.2f}%)",
+      unsupportedFunctions,
+      (double)unsupportedFunctions / totalFunctions * 100);
+  LOG(INFO) << fmt::format(
+      "Supported function signatures: {} ({:.2f}%)",
+      supportedFunctionSignatures,
+      (double)supportedFunctionSignatures / totalFunctionSignatures * 100);
+  LOG(INFO) << fmt::format(
+      "Unsupported function signatures: {} ({:.2f}%)",
+      unsupportedFunctionSignatures,
+      (double)unsupportedFunctionSignatures / totalFunctionSignatures * 100);
+
+  getTicketsForFunctions();
+
+  // We sort the available signatures before inserting them into
+  // typeToExpressionList_ and expressionToSignature_. The purpose of this step
+  // is to ensure the vector of function signatures associated with each key in
+  // signaturesMap_ has a deterministic order, so that we can deterministically
+  // generate expressions across platforms. We just do this once and the vector
+  // is small, so it doesn't need to be very efficient.
+  sortCallableSignatures(signatures_);
+
+  for (const auto& it : signatures_) {
+    auto returnType = typeToBaseName(it.returnType);
+    if (typeToExpressionList_[returnType].empty() ||
+        typeToExpressionList_[returnType].back() != it.name) {
+      // Ensure entries for a function name are added only once. This
+      // gives all others a fair chance to be selected. Since signatures
+      // are sorted on the function name this check will always work.
+      // Add multiple entries to increase likelihood of its selection.
+      addToTypeToExpressionListByTicketTimes(returnType, it.name);
+    }
+    expressionToSignature_[it.name][returnType].push_back(&it);
+  }
+
+  // Similarly, sort all template signatures.
+  sortSignatureTemplates(signatureTemplates_);
+
+  for (const auto& it : signatureTemplates_) {
+    const auto returnType =
+        exec::sanitizeName(it.signature->returnType().baseName());
+    const auto* returnTypeKey = &returnType;
+
+    if (it.typeVariables.find(returnType) != it.typeVariables.end()) {
+      // Return type is a template variable.
+      returnTypeKey = &kTypeParameterName;
+    }
+    if (typeToExpressionList_[*returnTypeKey].empty() ||
+        typeToExpressionList_[*returnTypeKey].back() != it.name) {
+      addToTypeToExpressionListByTicketTimes(*returnTypeKey, it.name);
+    }
+    expressionToTemplatedSignature_[it.name][*returnTypeKey].push_back(&it);
+  }
+
+  if (options_.enableDereference) {
+    addToTypeToExpressionListByTicketTimes("row", "row_constructor");
+    addToTypeToExpressionListByTicketTimes(kTypeParameterName, "dereference");
+  }
+
+  // Register function override (for cases where we want to restrict the types
+  // or parameters we pass to functions).
+  registerFuncOverride(&ExpressionFuzzer::generateSwitchArgs, "switch");
+}
+
+void ExpressionFuzzer::getTicketsForFunctions() {
+  if (options_.functionTickets.empty()) {
+    return;
+  }
+  std::vector<std::string> results;
+  boost::algorithm::split(
+      results, options_.functionTickets, boost::is_any_of(","));
+
+  for (auto& entry : results) {
+    std::vector<std::string> separated;
+    boost::algorithm::split(separated, entry, boost::is_any_of("="));
+    if (separated.size() != 2) {
+      LOG(FATAL)
+          << "Invalid format. Expected a function name and its number of "
+             "tickets separated by '=', instead found: "
+          << entry;
+    }
+    int tickets = 0;
+    try {
+      tickets = stoi(separated[1]);
+    } catch (std::exception& e) {
+      LOG(FATAL)
+          << "Invalid number of tickets. Expected a function name and its "
+             "number of tickets separated by '=', instead found: "
+          << entry << " Error encountered: " << e.what();
+    }
+
+    if (tickets < 1) {
+      LOG(FATAL)
+          << "Number of tickets should be a positive integer. Expected a "
+             "function name and its number of tickets separated by '=',"
+             " instead found: "
+          << entry;
+    }
+    functionsToTickets_.insert({separated[0], tickets});
+  }
+}
+
+int ExpressionFuzzer::getTickets(const std::string& funcName) {
+  auto itr = functionsToTickets_.find(funcName);
+  int tickets = 1;
+  if (itr != functionsToTickets_.end()) {
+    tickets = itr->second;
+  }
+  return tickets;
+}
+
+void ExpressionFuzzer::addToTypeToExpressionListByTicketTimes(
+    const std::string& type,
+    const std::string& funcName) {
+  int tickets = getTickets(funcName);
+  for (int i = 0; i < tickets; i++) {
+    typeToExpressionList_[exec::sanitizeName(type)].push_back(funcName);
+  }
+}
+
+template <typename TFunc>
+void ExpressionFuzzer::registerFuncOverride(
+    TFunc func,
+    const std::string& name) {
+  funcArgOverrides_[name] = std::bind(func, this, std::placeholders::_1);
+}
+
+void ExpressionFuzzer::seed(size_t seed) {
+  rng_.seed(seed);
+  vectorFuzzer_->reSeed(seed);
+}
+
+int32_t ExpressionFuzzer::rand32(int32_t min, int32_t max) {
+  return boost::random::uniform_int_distribution<uint32_t>(min, max)(rng_);
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateArgConstant(const TypePtr& arg) {
+  if (vectorFuzzer_->coinToss(options_.nullRatio)) {
+    return std::make_shared<core::ConstantTypedExpr>(
+        arg, variant::null(arg->kind()));
+  }
+  return std::make_shared<core::ConstantTypedExpr>(
+      vectorFuzzer_->fuzzConstant(arg, 1));
+}
+
+// Either generates a new column of the required type or if already generated
+// columns of the same type exist then there is a 30% chance that it will
+// re-use one of them.
+core::TypedExprPtr ExpressionFuzzer::generateArgColumn(const TypePtr& arg) {
+  auto& listOfCandidateCols = state.typeToColumnNames_[arg->toString()];
+  bool reuseColumn = options_.enableColumnReuse &&
+      !listOfCandidateCols.empty() && vectorFuzzer_->coinToss(0.3);
+
+  if (!reuseColumn && options_.maxInputsThreshold.has_value() &&
+      state.inputRowTypes_.size() >= options_.maxInputsThreshold.value()) {
+    reuseColumn = !listOfCandidateCols.empty();
+  }
+
+  if (!reuseColumn) {
+    state.inputRowTypes_.emplace_back(arg);
+    state.inputRowNames_.emplace_back(
+        fmt::format("c{}", state.inputRowTypes_.size() - 1));
+    listOfCandidateCols.push_back(state.inputRowNames_.back());
+    return std::make_shared<core::FieldAccessTypedExpr>(
+        arg, state.inputRowNames_.back());
+  }
+  size_t chosenColIndex = rand32(0, listOfCandidateCols.size() - 1);
+  return std::make_shared<core::FieldAccessTypedExpr>(
+      arg, listOfCandidateCols[chosenColIndex]);
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateArg(const TypePtr& arg) {
+  size_t argClass = rand32(0, 3);
+
+  // Toss a coin and choose between a constant, a column reference, or another
+  // expression (function).
+  //
+  // TODO: Add more expression types:
+  // - Conjunctions
+  // - IF/ELSE/SWITCH
+  // - Lambdas
+  // - Try
+  if (argClass >= kArgExpression) {
+    if (state.remainingLevelOfNesting_ > 0) {
+      return generateExpression(arg);
+    }
+    argClass = rand32(0, 1);
+  }
+
+  if (argClass == kArgConstant) {
+    return generateArgConstant(arg);
+  }
+  // argClass == kArgColumn
+  return generateArgColumn(arg);
+}
+
+std::vector<core::TypedExprPtr> ExpressionFuzzer::generateArgs(
+    const std::vector<TypePtr>& argTypes,
+    const std::vector<bool>& constantArgs,
+    uint32_t numVarArgs) {
+  std::vector<core::TypedExprPtr> inputExpressions;
+  inputExpressions.reserve(argTypes.size() + numVarArgs);
+
+  for (auto i = 0; i < argTypes.size(); ++i) {
+    inputExpressions.emplace_back(
+        generateArg(argTypes.at(i), constantArgs.at(i)));
+  }
+  // Append varargs to the argument list.
+  for (int i = 0; i < numVarArgs; i++) {
+    inputExpressions.emplace_back(
+        generateArg(argTypes.back(), constantArgs.back()));
+  }
+  return inputExpressions;
+}
+
+std::vector<core::TypedExprPtr> ExpressionFuzzer::generateArgs(
+    const CallableSignature& input) {
+  auto numVarArgs =
+      !input.variableArity ? 0 : rand32(0, options_.maxNumVarArgs);
+  return generateArgs(input.args, input.constantArgs, numVarArgs);
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateArgFunction(const TypePtr& arg) {
+  const auto& functionType = arg->asFunction();
+
+  std::vector<TypePtr> args;
+  std::vector<std::string> names;
+  std::vector<core::TypedExprPtr> inputs;
+  args.reserve(arg->size() - 1);
+  names.reserve(arg->size() - 1);
+  inputs.reserve(arg->size() - 1);
+
+  for (auto i = 0; i < arg->size() - 1; ++i) {
+    args.push_back(arg->childAt(i));
+    names.push_back(fmt::format("__a{}", i));
+    inputs.push_back(std::make_shared<core::FieldAccessTypedExpr>(
+        args.back(), names.back()));
+  }
+
+  const auto& returnType = functionType.children().back();
+
+  const auto baseType = typeToBaseName(returnType);
+  const auto& baseList = typeToExpressionList_[baseType];
+  const auto& templateList = typeToExpressionList_[kTypeParameterName];
+
+  std::vector<std::string> eligible;
+  for (const auto& functionName : baseList) {
+    if (auto* signature =
+            findConcreteSignature(args, returnType, functionName)) {
+      eligible.push_back(functionName);
+    } else if (
+        auto* signatureTemplate =
+            findSignatureTemplate(args, returnType, baseType, functionName)) {
+      eligible.push_back(functionName);
+    }
+  }
+
+  for (const auto& functionName : templateList) {
+    if (auto* signatureTemplate =
+            findSignatureTemplate(args, returnType, baseType, functionName)) {
+      eligible.push_back(functionName);
+    }
+  }
+
+  if (eligible.empty()) {
+    return std::make_shared<core::LambdaTypedExpr>(
+        ROW(std::move(names), std::move(args)),
+        generateArgConstant(returnType));
+  }
+
+  const auto idx = rand32(0, eligible.size() - 1);
+  const auto name = eligible[idx];
+
+  return std::make_shared<core::LambdaTypedExpr>(
+      ROW(std::move(names), std::move(args)),
+      std::make_shared<core::CallTypedExpr>(returnType, inputs, name));
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateArg(
+    const TypePtr& arg,
+    bool isConstant) {
+  if (arg->isFunction()) {
+    return generateArgFunction(arg);
+  }
+
+  if (isConstant) {
+    return generateArgConstant(arg);
+  } else {
+    return generateArg(arg);
+  }
+}
+
+std::vector<core::TypedExprPtr> ExpressionFuzzer::generateSwitchArgs(
+    const CallableSignature& input) {
+  VELOX_CHECK_EQ(
+      input.args.size(),
+      2,
+      "Only two inputs are expected from the template signature.");
+  size_t cases = rand32(1, 5);
+  bool useFinalElse = vectorFuzzer_->coinToss(0.5);
+
+  auto conditionClauseType = input.args[0];
+  auto thenClauseType = input.args[1];
+  std::vector<core::TypedExprPtr> inputExpressions;
+  for (int case_idx = 0; case_idx < cases; case_idx++) {
+    inputExpressions.push_back(generateArg(conditionClauseType));
+    inputExpressions.push_back(generateArg(thenClauseType));
+  }
+  if (useFinalElse) {
+    inputExpressions.push_back(generateArg(thenClauseType));
+  }
+  return inputExpressions;
+}
+
+ExpressionFuzzer::FuzzedExpressionData ExpressionFuzzer::fuzzExpressions(
+    const RowTypePtr& outType) {
+  state.reset();
+  VELOX_CHECK_EQ(
+      state.remainingLevelOfNesting_, std::max(1, options_.maxLevelOfNesting));
+
+  std::vector<core::TypedExprPtr> expressions;
+  for (int i = 0; i < outType->size(); i++) {
+    expressions.push_back(generateExpression(outType->childAt(i)));
+  }
+  return {
+      std::move(expressions),
+      ROW(std::move(state.inputRowNames_), std::move(state.inputRowTypes_)),
+      std::move(state.expressionStats_)};
+}
+
+ExpressionFuzzer::FuzzedExpressionData ExpressionFuzzer::fuzzExpressions(
+    size_t numberOfExpressions) {
+  return fuzzExpressions(fuzzRowReturnType(numberOfExpressions));
+}
+
+ExpressionFuzzer::FuzzedExpressionData ExpressionFuzzer::fuzzExpression() {
+  return fuzzExpressions(1);
+}
+
+// Either generates a new expression of the required return type or if already
+// generated expressions of the same return type exist then there is a 30%
+// chance that it will re-use one of them.
+core::TypedExprPtr ExpressionFuzzer::generateExpression(
+    const TypePtr& returnType) {
+  VELOX_CHECK_GT(state.remainingLevelOfNesting_, 0);
+  --state.remainingLevelOfNesting_;
+  auto guard = folly::makeGuard([&] { ++state.remainingLevelOfNesting_; });
+
+  core::TypedExprPtr expression;
+  bool reuseExpression =
+      options_.enableExpressionReuse && vectorFuzzer_->coinToss(0.3);
+  if (reuseExpression) {
+    expression = state.expressionBank_.getRandomExpression(
+        returnType, state.remainingLevelOfNesting_ + 1);
+    if (expression) {
+      return expression;
+    }
+  }
+  auto baseType = typeToBaseName(returnType);
+  VELOX_CHECK_NE(
+      baseType, "T", "returnType should have all concrete types defined");
+  // Randomly pick among all functions that support this return type. Also,
+  // consider all functions that have return type "T" as they can
+  // support any concrete return type.
+  auto& baseList = typeToExpressionList_[baseType];
+  auto& templateList = typeToExpressionList_[kTypeParameterName];
+  uint32_t numEligible = baseList.size() + templateList.size();
+
+  if (numEligible > 0) {
+    size_t chosenExprIndex = rand32(0, numEligible - 1);
+    std::string chosenFunctionName;
+    if (chosenExprIndex < baseList.size()) {
+      chosenFunctionName = baseList[chosenExprIndex];
+    } else {
+      chosenExprIndex -= baseList.size();
+      chosenFunctionName = templateList[chosenExprIndex];
+    }
+
+    if (chosenFunctionName == "cast") {
+      expression = generateCastExpression(returnType);
+    } else if (chosenFunctionName == "row_constructor") {
+      // Avoid generating deeply nested types that is rarely used in practice.
+      if (levelOfNesting(returnType) < 3) {
+        expression = generateRowConstructorExpression(returnType);
+      }
+    } else if (chosenFunctionName == "dereference") {
+      expression = generateDereferenceExpression(returnType);
+    } else {
+      expression = generateExpressionFromConcreteSignatures(
+          returnType, chosenFunctionName);
+      if (!expression &&
+          (options_.enableComplexTypes || options_.enableDecimalType)) {
+        expression = generateExpressionFromSignatureTemplate(
+            returnType, chosenFunctionName);
+      }
+    }
+  }
+  if (!expression) {
+    VLOG(1) << "Couldn't find a proper function to return '"
+            << returnType->toString() << "'. Returning a constant instead.";
+    return generateArgConstant(returnType);
+  }
+  state.expressionBank_.insert(expression);
+  return expression;
+}
+
+std::vector<core::TypedExprPtr> ExpressionFuzzer::getArgsForCallable(
+    const CallableSignature& callable) {
+  auto funcIt = funcArgOverrides_.find(callable.name);
+  if (funcIt == funcArgOverrides_.end()) {
+    return generateArgs(callable);
+  }
+  return funcIt->second(callable);
+}
+
+core::TypedExprPtr ExpressionFuzzer::getCallExprFromCallable(
+    const CallableSignature& callable,
+    const TypePtr& type) {
+  auto args = getArgsForCallable(callable);
+  // Generate a CallTypedExpr with type because callable.returnType may not have
+  // the required field names.
+  return std::make_shared<core::CallTypedExpr>(type, args, callable.name);
+}
+
+const CallableSignature* ExpressionFuzzer::chooseRandomConcreteSignature(
+    const TypePtr& returnType,
+    const std::string& functionName) {
+  if (expressionToSignature_.find(functionName) ==
+      expressionToSignature_.end()) {
+    return nullptr;
+  }
+  auto baseType = typeToBaseName(returnType);
+  auto itr = expressionToSignature_[functionName].find(baseType);
+  if (itr == expressionToSignature_[functionName].end()) {
+    return nullptr;
+  }
+  // Only function signatures whose return type equals to returnType are
+  // eligible. There may be ineligible signatures in signaturesMap_ because
+  // the map keys only differentiate top-level type kinds.
+  std::vector<const CallableSignature*> eligible;
+  for (auto signature : itr->second) {
+    if (signature->returnType->equivalent(*returnType)) {
+      eligible.push_back(signature);
+    }
+  }
+  if (eligible.empty()) {
+    return nullptr;
+  }
+
+  // Randomly pick a function that can return `returnType`.
+  size_t idx = rand32(0, eligible.size() - 1);
+  return eligible[idx];
+}
+
+const CallableSignature* ExpressionFuzzer::findConcreteSignature(
+    const std::vector<TypePtr>& argTypes,
+    const TypePtr& returnType,
+    const std::string& functionName) {
+  if (expressionToSignature_.find(functionName) ==
+      expressionToSignature_.end()) {
+    return nullptr;
+  }
+  auto baseType = typeToBaseName(returnType);
+  auto it = expressionToSignature_[functionName].find(baseType);
+  if (it == expressionToSignature_[functionName].end()) {
+    return nullptr;
+  }
+
+  for (auto signature : it->second) {
+    if (!signature->returnType->equivalent(*returnType)) {
+      continue;
+    }
+
+    if (signature->args.size() != argTypes.size()) {
+      continue;
+    }
+
+    bool argTypesMatch = true;
+    for (auto i = 0; i < argTypes.size(); ++i) {
+      if (signature->constantArgs[i] ||
+          !signature->args[i]->equivalent(*argTypes[i])) {
+        argTypesMatch = false;
+        break;
+      }
+    }
+
+    if (argTypesMatch) {
+      return signature;
+    }
+  }
+
+  return nullptr;
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateExpressionFromConcreteSignatures(
+    const TypePtr& returnType,
+    const std::string& functionName) {
+  const auto* chosen = chooseRandomConcreteSignature(returnType, functionName);
+  if (!chosen) {
+    return nullptr;
+  }
+
+  markSelected(chosen->name);
+  return getCallExprFromCallable(*chosen, returnType);
+}
+
+const SignatureTemplate* ExpressionFuzzer::chooseRandomSignatureTemplate(
+    const TypePtr& returnType,
+    const std::string& typeName,
+    const std::string& functionName) {
+  std::vector<const SignatureTemplate*> eligible;
+  if (expressionToTemplatedSignature_.find(functionName) ==
+      expressionToTemplatedSignature_.end()) {
+    return nullptr;
+  }
+  auto it = expressionToTemplatedSignature_[functionName].find(typeName);
+  if (it == expressionToTemplatedSignature_[functionName].end()) {
+    return nullptr;
+  }
+  // Only function signatures whose return type can match returnType are
+  // eligible. There may be ineligible signatures in signaturesMap_ because
+  // the map keys only differentiate the top-level type names.
+  auto& signatureTemplates = it->second;
+  for (auto signatureTemplate : signatureTemplates) {
+    exec::ReverseSignatureBinder binder{
+        *signatureTemplate->signature, returnType};
+    if (binder.tryBind()) {
+      eligible.push_back(signatureTemplate);
+    }
+  }
+  if (eligible.empty()) {
+    return nullptr;
+  }
+
+  auto idx = rand32(0, eligible.size() - 1);
+  return eligible[idx];
+}
+
+const SignatureTemplate* ExpressionFuzzer::findSignatureTemplate(
+    const std::vector<TypePtr>& argTypes,
+    const TypePtr& returnType,
+    const std::string& typeName,
+    const std::string& functionName) {
+  std::vector<const SignatureTemplate*> eligible;
+  if (expressionToTemplatedSignature_.find(functionName) ==
+      expressionToTemplatedSignature_.end()) {
+    return nullptr;
+  }
+  auto it = expressionToTemplatedSignature_[functionName].find(typeName);
+  if (it == expressionToTemplatedSignature_[functionName].end()) {
+    return nullptr;
+  }
+
+  for (auto signatureTemplate : it->second) {
+    // Skip signatures with constant arguments.
+    if (signatureTemplate->signature->hasConstantArgument()) {
+      continue;
+    }
+
+    FullSignatureBinder binder{
+        *signatureTemplate->signature, argTypes, returnType};
+    if (binder.tryBind()) {
+      return signatureTemplate;
+    }
+  }
+
+  return nullptr;
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateExpressionFromSignatureTemplate(
+    const TypePtr& returnType,
+    const std::string& functionName) {
+  auto typeName = typeToBaseName(returnType);
+
+  auto* chosen =
+      chooseRandomSignatureTemplate(returnType, typeName, functionName);
+  if (!chosen) {
+    chosen = chooseRandomSignatureTemplate(
+        returnType, kTypeParameterName, functionName);
+    if (!chosen) {
+      return nullptr;
+    }
+  }
+
+  auto chosenSignature = *chosen->signature;
+  ArgumentTypeFuzzer fuzzer{chosenSignature, returnType, rng_};
+
+  std::vector<TypePtr> argumentTypes;
+  if (fuzzer.fuzzArgumentTypes(options_.maxNumVarArgs)) {
+    // Use the argument fuzzer to generate argument types.
+    argumentTypes = fuzzer.argumentTypes();
+  } else {
+    auto it = argGenerators_.find(functionName);
+    // Since the argument type fuzzer cannot produce argument types, argument
+    // generators should be provided.
+    VELOX_CHECK(
+        it != argGenerators_.end(),
+        "Cannot generate argument types for {} with return type {}.",
+        functionName,
+        returnType->toString());
+    argumentTypes = it->second->generateArgs(chosenSignature, returnType, rng_);
+    if (argumentTypes.empty()) {
+      return nullptr;
+    }
+  }
+
+  auto constantArguments = chosenSignature.constantArguments();
+
+  // ArgumentFuzzer may generate duplicate arguments if the signature's
+  // variableArity is true, so we need to pad duplicate constant flags.
+  if (!constantArguments.empty()) {
+    auto repeat = argumentTypes.size() - constantArguments.size();
+    auto lastConstant = constantArguments.back();
+    for (int i = 0; i < repeat; ++i) {
+      constantArguments.push_back(lastConstant);
+    }
+  }
+
+  CallableSignature callable{
+      .name = chosen->name,
+      .args = argumentTypes,
+      .variableArity = false,
+      .returnType = returnType,
+      .constantArgs = constantArguments};
+
+  markSelected(chosen->name);
+  return getCallExprFromCallable(callable, returnType);
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateCastExpression(
+    const TypePtr& returnType) {
+  const auto* callable = chooseRandomConcreteSignature(returnType, "cast");
+  if (!callable) {
+    return nullptr;
+  }
+
+  auto args = getArgsForCallable(*callable);
+  markSelected("cast");
+
+  // Generate try_cast expression with 50% chance.
+  bool nullOnFailure = vectorFuzzer_->coinToss(0.5);
+  return std::make_shared<core::CastTypedExpr>(returnType, args, nullOnFailure);
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateRowConstructorExpression(
+    const TypePtr& returnType) {
+  VELOX_CHECK(returnType->isRow());
+  auto argTypes = asRowType(returnType)->children();
+  std::vector<bool> constantArgs(argTypes.size(), false);
+
+  auto inputExpressions = generateArgs(argTypes, constantArgs);
+  return std::make_shared<core::ConcatTypedExpr>(
+      asRowType(returnType)->names(), inputExpressions);
+}
+
+TypePtr ExpressionFuzzer::generateRandomRowTypeWithReferencedField(
+    uint32_t numFields,
+    uint32_t referencedIndex,
+    const TypePtr& referencedType) {
+  std::vector<TypePtr> fieldTypes(numFields);
+  std::vector<std::string> fieldNames(numFields);
+  for (auto i = 0; i < numFields; ++i) {
+    if (i == referencedIndex) {
+      fieldTypes[i] = referencedType;
+    } else {
+      fieldTypes[i] = vectorFuzzer_->randType();
+    }
+    fieldNames[i] = fmt::format("row_field{}", i);
+  }
+  return ROW(std::move(fieldNames), std::move(fieldTypes));
+}
+
+core::TypedExprPtr ExpressionFuzzer::generateDereferenceExpression(
+    const TypePtr& returnType) {
+  auto numFields = rand32(1, 3);
+  auto referencedIndex = rand32(0, numFields - 1);
+  auto argType = generateRandomRowTypeWithReferencedField(
+      numFields, referencedIndex, returnType);
+
+  auto inputExpressions = generateArgs({argType}, {false});
+  return std::make_shared<core::FieldAccessTypedExpr>(
+      returnType,
+      inputExpressions[0],
+      fmt::format("row_field{}", referencedIndex));
+}
+void ExpressionFuzzer::ExprBank::insert(const core::TypedExprPtr& expression) {
+  auto typeString = expression->type()->toString();
+  if (typeToExprsByLevel_.find(typeString) == typeToExprsByLevel_.end()) {
+    typeToExprsByLevel_.insert(
+        {typeString, ExprsIndexedByLevel(maxLevelOfNesting_ + 1)});
+  }
+  auto& expressionsByLevel = typeToExprsByLevel_[typeString];
+  int nestingLevel = getNestedLevel(expression);
+  VELOX_CHECK_LE(nestingLevel, maxLevelOfNesting_);
+  expressionsByLevel[nestingLevel].push_back(expression);
+}
+
+core::TypedExprPtr ExpressionFuzzer::ExprBank::getRandomExpression(
+    const facebook::velox::TypePtr& returnType,
+    int uptoLevelOfNesting) {
+  VELOX_CHECK_LE(uptoLevelOfNesting, maxLevelOfNesting_);
+  auto typeString = returnType->toString();
+  if (typeToExprsByLevel_.find(typeString) == typeToExprsByLevel_.end()) {
+    return nullptr;
+  }
+  auto& expressionsByLevel = typeToExprsByLevel_[typeString];
+  int totalToConsider = 0;
+  for (int i = 0; i <= uptoLevelOfNesting; i++) {
+    totalToConsider += expressionsByLevel[i].size();
+  }
+  if (totalToConsider > 0) {
+    int choice = boost::random::uniform_int_distribution<uint32_t>(
+        0, totalToConsider - 1)(rng_);
+    for (int i = 0; i <= uptoLevelOfNesting; i++) {
+      if (choice >= expressionsByLevel[i].size()) {
+        choice -= expressionsByLevel[i].size();
+        continue;
+      }
+      return expressionsByLevel[i][choice];
+    }
+    VELOX_CHECK(false, "Should have found an expression.");
+  }
+  return nullptr;
+}
+
+TypePtr ExpressionFuzzer::fuzzReturnType() {
+  auto chooseFromConcreteSignatures = rand32(0, 1);
+
+  chooseFromConcreteSignatures =
+      (chooseFromConcreteSignatures && !signatures_.empty()) ||
+      (!chooseFromConcreteSignatures && signatureTemplates_.empty());
+  TypePtr rootType;
+  if (signatures_.empty() && signatureTemplates_.empty() &&
+      options_.enableDereference) {
+    // Dereference does not have signatures in either list. So even if these
+    // signature lists are both empty, we can still generate a random return
+    // type for dereference.
+    rootType = vectorFuzzer_->randType();
+  } else if (chooseFromConcreteSignatures) {
+    // Pick a random signature to choose the root return type.
+    VELOX_CHECK(!signatures_.empty(), "No function signature available.");
+    size_t idx = rand32(0, signatures_.size() - 1);
+    rootType = signatures_[idx].returnType;
+  } else {
+    // Pick a random concrete return type that can bind to the return type of
+    // a chosen signature.
+    VELOX_CHECK(
+        !signatureTemplates_.empty(), "No function signature available.");
+    size_t idx = rand32(0, signatureTemplates_.size() - 1);
+    ArgumentTypeFuzzer typeFuzzer{*signatureTemplates_[idx].signature, rng_};
+    rootType = typeFuzzer.fuzzReturnType();
+  }
+  return rootType;
+}
+
+RowTypePtr ExpressionFuzzer::fuzzRowReturnType(size_t size, char prefix) {
+  std::vector<TypePtr> children;
+  std::vector<std::string> names;
+  for (int i = 0; i < size; i++) {
+    children.push_back(fuzzReturnType());
+    names.push_back(fmt::format("{}{}", prefix, i));
+  }
+  return ROW(std::move(names), std::move(children));
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ExpressionFuzzer.h b/velox/expression/fuzzer/ExpressionFuzzer.h
new file mode 100644
index 0000000000000..a703ddb7eef91
--- /dev/null
+++ b/velox/expression/fuzzer/ExpressionFuzzer.h
@@ -0,0 +1,431 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/core/ITypedExpr.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/expression/tests/ExpressionVerifier.h"
+#include "velox/functions/FunctionRegistry.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+namespace facebook::velox::fuzzer {
+
+// A tool that can be used to generate random expressions.
+class ExpressionFuzzer {
+ public:
+  struct Options {
+    // The maximum number of variadic arguments fuzzer will generate for
+    // functions that accept variadic arguments. Fuzzer will generate up to
+    // max_num_varargs arguments for the variadic list in addition to the
+    // required arguments by the function.
+    int32_t maxNumVarArgs = 5;
+
+    // Enable testing of function signatures with variadic arguments.
+    bool enableVariadicSignatures = false;
+
+    // Allow fuzzer to generate random expressions with dereference and
+    // row_constructor functions.
+    bool enableDereference = false;
+
+    // Enable testing of function signatures with complex argument or return
+    // types.
+    bool enableComplexTypes = false;
+
+    // Enable testing of function signatures with decimal argument or return
+    // types.
+    bool enableDecimalType = false;
+
+    // Enable generation of expressions where one input column can be used by
+    // multiple subexpressions.
+    bool enableColumnReuse = false;
+
+    // Enable generation of expressions that re-uses already generated
+    // subexpressions.
+    bool enableExpressionReuse = false;
+
+    int32_t maxLevelOfNesting = 10;
+
+    //  Comma separated list of function names and their tickets in the format
+    //  <function_name>=<tickets>. Every ticket represents an opportunity for a
+    //  function to be chosen from a pool of candidates. By default, every
+    //  function has one ticket, and the likelihood of a function being picked
+    //  an be increased by allotting it more tickets. Note that in practice,
+    //  increasing the number of tickets does not proportionally increase the
+    //  likelihood of selection, as the selection process involves filtering the
+    //  pool of candidates by a required return type so not all functions may
+    //  compete against the same number of functions at every instance. Number
+    //  of tickets must be a positive integer. Example: eq=3,floor=5
+    std::string functionTickets = "";
+
+    // Chance of adding a null constant to the plan, or null value in a vector
+    // (expressed as double from 0 to 1).
+    double nullRatio = 0.1;
+
+    // If specified, Fuzzer will only choose functions from this comma separated
+    // list of function names (e.g: --only \"split\" or --only
+    // \"substr,ltrim\")."
+    std::string useOnlyFunctions = "";
+
+    // Comma-separated list of special forms to use in generated expression.
+    // Supported special forms: and, or, coalesce, if, switch, cast.")
+    std::string specialForms = "and,or,cast,coalesce,if,switch";
+
+    // This list can include a mix of function names and function signatures.
+    // Use function name to exclude all signatures of a given function from
+    // testing. Use function signature to exclude only a specific signature.
+    // ex skipFunctions{
+    //   "width_bucket",
+    //   "array_sort(array(T),constant function(T,T,bigint)) -> array(T)"}
+    std::unordered_set<std::string> skipFunctions;
+
+    // When set, when the input size of the generated expressions reaches
+    // maxInputsThreshold, fuzzing input columns will reuse one of the existing
+    // columns if any is already generated with the same type.
+    // This can be used to control the size of the input of the fuzzer
+    // expression.
+    std::optional<int32_t> maxInputsThreshold = std::nullopt;
+  };
+
+  ExpressionFuzzer(
+      FunctionSignatureMap signatureMap,
+      size_t initialSeed,
+      const std::shared_ptr<VectorFuzzer>& vectorFuzzer,
+      const std::optional<ExpressionFuzzer::Options>& options = std::nullopt,
+      const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
+          argGenerators = {});
+
+  template <typename TFunc>
+  void registerFuncOverride(TFunc func, const std::string& name);
+
+  struct FuzzedExpressionData {
+    // A list of generated expressions.
+    std::vector<core::TypedExprPtr> expressions;
+
+    // The input vector type that is expected by the generated expressions.
+    RowTypePtr inputType;
+
+    // Count how many times each expression has been selected in expressions.
+    std::unordered_map<std::string, size_t> selectionStats;
+  };
+
+  /// Fuzz a set of expressions.
+  FuzzedExpressionData fuzzExpressions(size_t expressionCount);
+
+  /// Fuzz a set of expressions given a output row type.
+  FuzzedExpressionData fuzzExpressions(const RowTypePtr& outType);
+
+  // Fuzz a single expression and return it along with the input row type.
+  FuzzedExpressionData fuzzExpression();
+
+  /// Used to enable re-use of sub-expressions by exposing an API that allows
+  /// for randomly picking an expression that has a specific return type and a
+  /// nesting level less than or equal to a specified limit. It ensures that
+  /// all expressions that are valid candidates have an equal probability of
+  /// selection.
+  class ExprBank {
+   public:
+    ExprBank(FuzzerGenerator& rng, int maxLevelOfNesting)
+        : rng_(rng), maxLevelOfNesting_(maxLevelOfNesting) {}
+
+    /// Adds an expression to the bank.
+    void insert(const core::TypedExprPtr& expression);
+
+    /// Returns a randomly selected expression of the requested 'returnType'
+    /// which is guaranteed to have a nesting level less than or equal to
+    /// 'uptoLevelOfNesting'. Returns a nullptr if no such function can be
+    /// found.
+    core::TypedExprPtr getRandomExpression(
+        const TypePtr& returnType,
+        int uptoLevelOfNesting);
+
+    /// Removes all the expressions from the bank. Should be called after
+    /// every fuzzer iteration.
+    void reset() {
+      typeToExprsByLevel_.clear();
+    }
+
+   private:
+    int getNestedLevel(const core::TypedExprPtr& expression) {
+      int level = 0;
+      for (auto& input : expression->inputs()) {
+        level = std::max(level, getNestedLevel(input) + 1);
+      }
+      return level;
+    }
+
+    /// Reference to the random generator of the expression fuzzer.
+    FuzzerGenerator& rng_;
+
+    /// Only expression having less than or equal to this level of nesting
+    /// will be generated.
+    int maxLevelOfNesting_;
+
+    /// Represents a vector where each index contains a list of expressions
+    /// such that the depth of each expression tree is equal to that index.
+    using ExprsIndexedByLevel = std::vector<std::vector<core::TypedExprPtr>>;
+
+    /// Maps a 'Type' serialized as a string to an object of type
+    /// ExprsIndexedByLevel
+    std::unordered_map<std::string, ExprsIndexedByLevel> typeToExprsByLevel_;
+  };
+
+  void seed(size_t seed);
+
+  const std::vector<std::string>& supportedFunctions() const {
+    return supportedFunctions_;
+  }
+
+  // Generate a random return type.
+  TypePtr fuzzReturnType();
+
+  RowTypePtr fuzzRowReturnType(size_t size, char prefix = 'p');
+
+ private:
+  // Either generates a new expression of the required return type or if
+  // already generated expressions of the same return type exist then there is
+  // a 30% chance that it will re-use one of them.
+  core::TypedExprPtr generateExpression(const TypePtr& type);
+
+  enum ArgumentKind { kArgConstant = 0, kArgColumn = 1, kArgExpression = 2 };
+
+  // Parse options.functionTickets into a map that maps function name to its
+  // number of tickets.
+  void getTicketsForFunctions();
+
+  // Get tickets for one function assigned by the options.functionTickets
+  // option. This function should be called after getTicketsForFunctions().
+  int getTickets(const std::string& funcName);
+
+  // Add `funcName` that returns `type` to typeToExpressionList_.
+  void addToTypeToExpressionListByTicketTimes(
+      const std::string& type,
+      const std::string& funcName);
+
+  void appendConjunctSignatures();
+
+  core::TypedExprPtr generateArgConstant(const TypePtr& arg);
+
+  core::TypedExprPtr generateArgColumn(const TypePtr& arg);
+
+  core::TypedExprPtr generateArg(const TypePtr& arg);
+
+  // Given lambda argument type, generate matching LambdaTypedExpr.
+  //
+  // The 'arg' specifies inputs types and result type for the lambda. This
+  // method finds all matching signatures and signature templates, picks one
+  // randomly and generates LambdaTypedExpr. If no matching signatures or
+  // signature templates found, this method returns LambdaTypedExpr that
+  // represents a constant lambda, i.e lambda that returns the same value for
+  // all input. The constant value is generated using 'generateArgConstant'.
+  core::TypedExprPtr generateArgFunction(const TypePtr& arg);
+
+  std::vector<core::TypedExprPtr> generateArgs(const CallableSignature& input);
+
+  std::vector<core::TypedExprPtr> generateArgs(
+      const std::vector<TypePtr>& argTypes,
+      const std::vector<bool>& constantArgs,
+      uint32_t numVarArgs = 0);
+
+  core::TypedExprPtr generateArg(const TypePtr& arg, bool isConstant);
+
+  // Return a vector of expressions for each argument of callable in order.
+  std::vector<core::TypedExprPtr> getArgsForCallable(
+      const CallableSignature& callable);
+
+  /// Specialization for the "switch" function. Takes in a signature that is
+  /// of the form Switch (condition, then): boolean, T -> T where the type
+  /// variable is bounded to a randomly selected type. It randomly decides the
+  /// number of cases (upto a max of 5) to generate and whether to include the
+  /// else clause. Finally, uses the type specified in the signature to
+  /// generate inputs with that return type.
+  std::vector<core::TypedExprPtr> generateSwitchArgs(
+      const CallableSignature& input);
+
+  core::TypedExprPtr getCallExprFromCallable(
+      const CallableSignature& callable,
+      const TypePtr& type);
+
+  /// Return a random signature mapped to functionName in
+  /// expressionToSignature_ whose return type can match returnType. Return
+  /// nullptr if no such signature template exists.
+  const CallableSignature* chooseRandomConcreteSignature(
+      const TypePtr& returnType,
+      const std::string& functionName);
+
+  /// Returns a signature with matching input types and return type. Returns
+  /// nullptr if matching signature doesn't exist.
+  const CallableSignature* findConcreteSignature(
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& returnType,
+      const std::string& functionName);
+
+  /// Generate an expression by randomly selecting a concrete function
+  /// signature that returns 'returnType' among all signatures that the
+  /// function named 'functionName' supports.
+  core::TypedExprPtr generateExpressionFromConcreteSignatures(
+      const TypePtr& returnType,
+      const std::string& functionName);
+
+  /// Return a random signature template mapped to typeName and functionName
+  /// in expressionToTemplatedSignature_ whose return type can match
+  /// returnType. Return nullptr if no such signature template exists.
+  const SignatureTemplate* chooseRandomSignatureTemplate(
+      const TypePtr& returnType,
+      const std::string& typeName,
+      const std::string& functionName);
+
+  /// Returns a signature template with matching input types and return type.
+  /// Returns nullptr if matching signature template doesn't exist.
+  const SignatureTemplate* findSignatureTemplate(
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& returnType,
+      const std::string& typeName,
+      const std::string& functionName);
+
+  /// Generate an expression by randomly selecting a function signature
+  /// template that returns 'returnType' among all signature templates that
+  /// the function named 'functionName' supports.
+  core::TypedExprPtr generateExpressionFromSignatureTemplate(
+      const TypePtr& returnType,
+      const std::string& functionName);
+
+  /// Generate a cast expression that returns the specified type. Return a
+  /// nullptr if casting to the specified type is not supported. The supported
+  /// types include primitive types, array, map, and row types right now.
+  core::TypedExprPtr generateCastExpression(const TypePtr& returnType);
+
+  // Generate an expression of the row_constructor special form that returns
+  // `returnType`. `returnType` must be a RowType.
+  core::TypedExprPtr generateRowConstructorExpression(
+      const TypePtr& returnType);
+
+  // Generate a random row type with `referencedType` be its field at
+  // `referencedIndex`.
+  TypePtr generateRandomRowTypeWithReferencedField(
+      uint32_t numFields,
+      uint32_t referencedIndex,
+      const TypePtr& referencedType);
+
+  // Generate an expression of the dereference special form that returns
+  // `returnType`.
+  core::TypedExprPtr generateDereferenceExpression(const TypePtr& returnType);
+
+  /// Should be called whenever a function is selected by the fuzzer.
+  void markSelected(const std::string& funcName) {
+    state.expressionStats_[funcName]++;
+  }
+
+  // Returns random integer between min and max inclusive.
+  int32_t rand32(int32_t min, int32_t max);
+
+  static const inline std::string kTypeParameterName = "T";
+
+  const Options options_;
+
+  std::vector<CallableSignature> signatures_;
+  std::vector<SignatureTemplate> signatureTemplates_;
+
+  /// Maps the base name of a return type signature to the function names that
+  /// support that return type. Base name could be "T" if the return type is a
+  /// type variable.
+  std::unordered_map<std::string, std::vector<std::string>>
+      typeToExpressionList_;
+
+  /// Maps the base name of a *concrete* return type signature to the function
+  /// names that support that return type. Those names then each further map
+  /// to a list of CallableSignature objects that they support. Base name
+  /// could be "T" if the return type is a type variable.
+  std::unordered_map<
+      std::string,
+      std::unordered_map<std::string, std::vector<const CallableSignature*>>>
+      expressionToSignature_;
+
+  /// Maps the base name of a *templated* return type signature to the
+  /// function names that support that return type. Those names then each
+  /// further map to a list of SignatureTemplate objects that they support.
+  /// Base name could be "T" if the return type is a type variable.
+  std::unordered_map<
+      std::string,
+      std::unordered_map<std::string, std::vector<const SignatureTemplate*>>>
+      expressionToTemplatedSignature_;
+
+  // A map that maps function name to its number of tickets parsed from the
+  // --assign_function_tickets startup flag .
+  std::unordered_map<std::string, int> functionsToTickets_;
+
+  /// We allow the arg generation routine to be specialized for particular
+  /// functions. This map stores the mapping between function name and the
+  /// overridden method.
+  using ArgsOverrideFunc = std::function<std::vector<core::TypedExprPtr>(
+      const CallableSignature& input)>;
+
+  std::unordered_map<std::string, ArgsOverrideFunc> funcArgOverrides_;
+
+  std::shared_ptr<VectorFuzzer> vectorFuzzer_;
+
+  FuzzerGenerator rng_;
+
+  std::vector<std::string> supportedFunctions_;
+
+  struct State {
+    void reset() {
+      inputRowTypes_.clear();
+      inputRowNames_.clear();
+      typeToColumnNames_.clear();
+      expressionBank_.reset();
+      expressionStats_.clear();
+    }
+
+    State(FuzzerGenerator& rng, int maxLevelOfNesting)
+        : expressionBank_(rng, maxLevelOfNesting),
+          remainingLevelOfNesting_(maxLevelOfNesting) {}
+
+    /// Used to track all generated expressions within a single iteration and
+    /// support expression re-use.
+    ExprBank expressionBank_;
+
+    /// Contains the types and names of the input vector that the generated
+    /// expressions consume.
+    std::vector<TypePtr> inputRowTypes_;
+    std::vector<std::string> inputRowNames_;
+
+    // Count how many times each function has been selected.
+    std::unordered_map<std::string, size_t> expressionStats_;
+
+    /// Maps a 'Type' serialized as a string to the column names that have
+    /// already been generated. Used to easily look up columns that can be
+    /// re-used when a specific type is required as input to a callable.
+    std::unordered_map<std::string, std::vector<std::string>>
+        typeToColumnNames_;
+
+    /// The remaining levels of expression nesting. It's initialized by
+    /// FLAGS_max_level_of_nesting and updated in generateExpression(). When
+    /// its value decreases to 0, we don't generate subexpressions anymore.
+    int32_t remainingLevelOfNesting_;
+
+  } state;
+  friend class ExpressionFuzzerUnitTest;
+
+  // Maps from function name to a specific generator of argument types.
+  std::unordered_map<std::string, std::shared_ptr<ArgGenerator>> argGenerators_;
+};
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ExpressionFuzzerTest.cpp b/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
new file mode 100644
index 0000000000000..86addf774df25
--- /dev/null
+++ b/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <unordered_set>
+
+#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/expression/fuzzer/FuzzerRunner.h"
+#include "velox/functions/prestosql/fuzzer/DivideArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/ModulusArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/TruncateArgGenerator.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+using namespace facebook::velox::exec::test;
+using facebook::velox::fuzzer::ArgGenerator;
+using facebook::velox::fuzzer::FuzzerRunner;
+
+int main(int argc, char** argv) {
+  facebook::velox::functions::prestosql::registerAllScalarFunctions();
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+
+  // TODO: List of the functions that at some point crash or fail and need to
+  // be fixed before we can enable.
+  // This list can include a mix of function names and function signatures.
+  // Use function name to exclude all signatures of a given function from
+  // testing. Use function signature to exclude only a specific signature.
+  std::unordered_set<std::string> skipFunctions = {
+      // Fuzzer and the underlying engine are confused about cardinality(HLL)
+      // (since HLL is a user defined type), and end up trying to use
+      // cardinality passing a VARBINARY (since HLL's implementation uses an
+      // alias to VARBINARY).
+      "cardinality",
+      "element_at",
+      "width_bucket",
+      // Fuzzer cannot generate valid 'comparator' lambda.
+      "array_sort(array(T),constant function(T,T,bigint)) -> array(T)",
+      "split_to_map(varchar,varchar,varchar,function(varchar,varchar,varchar,varchar)) -> map(varchar,varchar)",
+      // https://github.com/facebookincubator/velox/issues/8919
+      "plus(date,interval year to month) -> date",
+      "minus(date,interval year to month) -> date",
+      "plus(timestamp,interval year to month) -> timestamp",
+      "plus(interval year to month,timestamp) -> timestamp",
+      "minus(timestamp,interval year to month) -> timestamp",
+      // https://github.com/facebookincubator/velox/issues/8438#issuecomment-1907234044
+      "regexp_extract",
+      "regexp_extract_all",
+      "regexp_like",
+      "regexp_replace",
+      "regexp_split",
+      // date_format and format_datetime throw VeloxRuntimeError when input
+      // timestamp is out of the supported range.
+      "date_format",
+      "format_datetime",
+      // from_unixtime can generate timestamps out of the supported range that
+      // make other functions throw VeloxRuntimeErrors.
+      "from_unixtime",
+  };
+  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+
+  std::unordered_map<std::string, std::shared_ptr<ArgGenerator>> argGenerators =
+      {{"plus", std::make_shared<PlusMinusArgGenerator>()},
+       {"minus", std::make_shared<PlusMinusArgGenerator>()},
+       {"multiply", std::make_shared<MultiplyArgGenerator>()},
+       {"divide", std::make_shared<DivideArgGenerator>()},
+       {"floor", std::make_shared<FloorAndRoundArgGenerator>()},
+       {"round", std::make_shared<FloorAndRoundArgGenerator>()},
+       {"mod", std::make_shared<ModulusArgGenerator>()},
+       {"truncate", std::make_shared<TruncateArgGenerator>()}};
+
+  FuzzerRunner::runFromGtest(initialSeed, skipFunctions, {{}}, argGenerators);
+}
diff --git a/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp b/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
new file mode 100644
index 0000000000000..1da7133eca7f6
--- /dev/null
+++ b/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/fuzzer/ExpressionFuzzerVerifier.h"
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include <glog/logging.h>
+#include <exception>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/expression/ReverseSignatureBinder.h"
+#include "velox/expression/fuzzer/ExpressionFuzzer.h"
+
+namespace facebook::velox::fuzzer {
+
+namespace {
+
+using exec::SignatureBinder;
+
+/// Returns row numbers for non-null rows among all children in'data' or null
+/// if all rows are null.
+BufferPtr extractNonNullIndices(const RowVectorPtr& data) {
+  DecodedVector decoded;
+  SelectivityVector nonNullRows(data->size());
+
+  for (auto& child : data->children()) {
+    decoded.decode(*child);
+    auto* rawNulls = decoded.nulls(nullptr);
+    if (rawNulls) {
+      nonNullRows.deselectNulls(rawNulls, 0, data->size());
+    }
+    if (!nonNullRows.hasSelections()) {
+      return nullptr;
+    }
+  }
+
+  BufferPtr indices = allocateIndices(nonNullRows.end(), data->pool());
+  auto rawIndices = indices->asMutable<vector_size_t>();
+  vector_size_t cnt = 0;
+  nonNullRows.applyToSelected(
+      [&](vector_size_t row) { rawIndices[cnt++] = row; });
+  VELOX_CHECK_GT(cnt, 0);
+  indices->setSize(cnt * sizeof(vector_size_t));
+  return indices;
+}
+
+/// Wraps child vectors of the specified 'rowVector' in dictionary using
+/// specified 'indices'. Returns new RowVector created from the wrapped vectors.
+RowVectorPtr wrapChildren(
+    const BufferPtr& indices,
+    const RowVectorPtr& rowVector) {
+  auto size = indices->size() / sizeof(vector_size_t);
+
+  std::vector<VectorPtr> newInputs;
+  for (const auto& child : rowVector->children()) {
+    newInputs.push_back(
+        BaseVector::wrapInDictionary(nullptr, indices, size, child));
+  }
+
+  return std::make_shared<RowVector>(
+      rowVector->pool(), rowVector->type(), nullptr, size, newInputs);
+}
+} // namespace
+
+ExpressionFuzzerVerifier::ExpressionFuzzerVerifier(
+    const FunctionSignatureMap& signatureMap,
+    size_t initialSeed,
+    const ExpressionFuzzerVerifier::Options& options,
+    const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
+        argGenerators)
+    : options_(options),
+      queryCtx_(core::QueryCtx::create(
+          nullptr,
+          core::QueryConfig(options.queryConfigs))),
+      execCtx_({pool_.get(), queryCtx_.get()}),
+      verifier_(
+          &execCtx_,
+          {options_.disableConstantFolding,
+           options_.reproPersistPath,
+           options_.persistAndRunOnce}),
+      vectorFuzzer_(std::make_shared<VectorFuzzer>(
+          options_.vectorFuzzerOptions,
+          execCtx_.pool())),
+      expressionFuzzer_(
+          signatureMap,
+          initialSeed,
+          vectorFuzzer_,
+          options.expressionFuzzerOptions,
+          argGenerators) {
+  seed(initialSeed);
+
+  // Init stats and register listener.
+  for (auto& name : expressionFuzzer_.supportedFunctions()) {
+    exprNameToStats_.insert({name, ExprUsageStats()});
+  }
+  statListener_ = std::make_shared<ExprStatsListener>(exprNameToStats_);
+  if (!exec::registerExprSetListener(statListener_)) {
+    LOG(WARNING) << "Listener should only be registered once.";
+  }
+}
+
+std::vector<int> ExpressionFuzzerVerifier::generateLazyColumnIds(
+    const RowVectorPtr& rowVector,
+    VectorFuzzer& vectorFuzzer) {
+  std::vector<int> columnsToWrapInLazy;
+  if (options_.lazyVectorGenerationRatio > 0) {
+    for (int idx = 0; idx < rowVector->childrenSize(); idx++) {
+      VELOX_CHECK_NOT_NULL(rowVector->childAt(idx));
+      if (vectorFuzzer.coinToss(options_.lazyVectorGenerationRatio)) {
+        columnsToWrapInLazy.push_back(
+            vectorFuzzer.coinToss(0.8) ? idx : -1 * idx);
+      }
+    }
+  }
+  return columnsToWrapInLazy;
+}
+
+void ExpressionFuzzerVerifier::reSeed() {
+  seed(rng_());
+}
+
+void ExpressionFuzzerVerifier::seed(size_t seed) {
+  currentSeed_ = seed;
+  expressionFuzzer_.seed(currentSeed_);
+  vectorFuzzer_->reSeed(currentSeed_);
+  rng_.seed(currentSeed_);
+}
+
+template <typename T>
+bool ExpressionFuzzerVerifier::isDone(size_t i, T startTime) const {
+  if (options_.durationSeconds > 0) {
+    std::chrono::duration<double> elapsed =
+        std::chrono::system_clock::now() - startTime;
+    return elapsed.count() >= options_.durationSeconds;
+  }
+  return i >= options_.steps;
+}
+
+void ExpressionFuzzerVerifier::logStats() {
+  std::vector<std::pair<std::string, ExprUsageStats>> entries;
+  uint64_t totalSelections = 0;
+  for (auto& elem : exprNameToStats_) {
+    totalSelections += elem.second.numTimesSelected;
+    entries.push_back(elem);
+  }
+
+  // sort by numProcessedRows
+  std::sort(entries.begin(), entries.end(), [](auto& left, auto& right) {
+    return left.second.numProcessedRows > right.second.numProcessedRows;
+  });
+  int maxEntriesLimit = std::min<size_t>(10, entries.size());
+  LOG(INFO) << "==============================> Top " << maxEntriesLimit
+            << " by number of rows processed";
+  LOG(INFO)
+      << "Format: functionName numTimesSelected proportionOfTimesSelected "
+         "numProcessedRows";
+  for (int i = 0; i < maxEntriesLimit; i++) {
+    LOG(INFO) << entries[i].first << " " << entries[i].second.numTimesSelected
+              << " " << std::fixed << std::setprecision(2)
+              << (entries[i].second.numTimesSelected * 100.00) / totalSelections
+              << "% " << entries[i].second.numProcessedRows;
+  }
+
+  LOG(INFO) << "==============================> Bottom " << maxEntriesLimit
+            << " by number of rows processed";
+  LOG(INFO)
+      << "Format: functionName numTimesSelected proportionOfTimesSelected "
+         "numProcessedRows";
+  for (int i = 0; i < maxEntriesLimit; i++) {
+    int idx = entries.size() - 1 - i;
+    LOG(INFO) << entries[idx].first << " "
+              << entries[idx].second.numTimesSelected << " " << std::fixed
+              << std::setprecision(2)
+              << (entries[idx].second.numTimesSelected * 100.00) /
+            totalSelections
+              << "% " << entries[idx].second.numProcessedRows;
+  }
+
+  // sort by numTimesSelected
+  std::sort(entries.begin(), entries.end(), [](auto& left, auto& right) {
+    return left.second.numTimesSelected > right.second.numTimesSelected;
+  });
+
+  LOG(INFO) << "==============================> All stats sorted by number "
+               "of times the function was chosen";
+  LOG(INFO)
+      << "Format: functionName numTimesSelected proportionOfTimesSelected "
+         "numProcessedRows";
+  for (auto& elem : entries) {
+    LOG(INFO) << elem.first << " " << elem.second.numTimesSelected << " "
+              << std::fixed << std::setprecision(2)
+              << (elem.second.numTimesSelected * 100.00) / totalSelections
+              << "% " << elem.second.numProcessedRows;
+  }
+}
+
+// Generates a row vector with child vectors corresponding to the same type as
+// the return type of the expression trees in 'plans'. These are used as
+// pre-allocated result vectors to be passed during expression evaluation.
+RowVectorPtr ExpressionFuzzerVerifier::generateResultVectors(
+    std::vector<core::TypedExprPtr>& plans) {
+  std::vector<VectorPtr> results;
+  std::vector<std::shared_ptr<const Type>> resultTypes;
+  size_t vectorSize = vectorFuzzer_->getOptions().vectorSize;
+  for (auto& plan : plans) {
+    results.push_back(
+        vectorFuzzer_->coinToss(0.5) ? vectorFuzzer_->fuzzFlat(plan->type())
+                                     : nullptr);
+    resultTypes.push_back(plan->type());
+  }
+  auto rowType = ROW(std::move(resultTypes));
+  return std::make_shared<RowVector>(
+      execCtx_.pool(), rowType, BufferPtr(nullptr), vectorSize, results);
+}
+
+void ExpressionFuzzerVerifier::retryWithTry(
+    std::vector<core::TypedExprPtr> plans,
+    const RowVectorPtr& rowVector,
+    const VectorPtr& resultVector,
+    const std::vector<int>& columnsToWrapInLazy) {
+  // Wrap each expression tree with 'try'.
+  std::vector<core::TypedExprPtr> tryPlans;
+  for (auto& plan : plans) {
+    tryPlans.push_back(std::make_shared<core::CallTypedExpr>(
+        plan->type(), std::vector<core::TypedExprPtr>{plan}, "try"));
+  }
+
+  ResultOrError tryResult;
+
+  // The function throws if anything goes wrong except
+  // UNSUPPORTED_INPUT_UNCATCHABLE errors.
+  try {
+    tryResult = verifier_.verify(
+        tryPlans,
+        rowVector,
+        resultVector ? BaseVector::copy(*resultVector) : nullptr,
+        false, // canThrow
+        columnsToWrapInLazy);
+  } catch (const std::exception&) {
+    if (options_.findMinimalSubexpression) {
+      test::computeMinimumSubExpression(
+          {&execCtx_, {false, ""}},
+          *vectorFuzzer_,
+          plans,
+          rowVector,
+          columnsToWrapInLazy);
+    }
+    throw;
+  }
+  if (tryResult.unsupportedInputUncatchableError) {
+    LOG(INFO)
+        << "Retry with try fails to find minimal subexpression due to UNSUPPORTED_INPUT_UNCATCHABLE error.";
+    return;
+  }
+
+  // Re-evaluate the original expression on rows that didn't produce an
+  // error (i.e. returned non-NULL results when evaluated with TRY).
+  BufferPtr noErrorIndices = extractNonNullIndices(tryResult.result);
+
+  if (noErrorIndices != nullptr) {
+    auto noErrorRowVector = wrapChildren(noErrorIndices, rowVector);
+
+    LOG(INFO) << "Retrying original expression on " << noErrorRowVector->size()
+              << " rows without errors";
+
+    try {
+      verifier_.verify(
+          plans,
+          noErrorRowVector,
+          resultVector ? BaseVector::copy(*resultVector)
+                             ->slice(0, noErrorRowVector->size())
+                       : nullptr,
+          false, // canThrow
+          columnsToWrapInLazy);
+    } catch (const std::exception&) {
+      if (options_.findMinimalSubexpression) {
+        test::computeMinimumSubExpression(
+            {&execCtx_, {false, ""}},
+            *vectorFuzzer_,
+            plans,
+            noErrorRowVector,
+            columnsToWrapInLazy);
+      }
+      throw;
+    }
+  }
+}
+
+void ExpressionFuzzerVerifier::go() {
+  VELOX_CHECK(
+      options_.steps > 0 || options_.durationSeconds > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+  VELOX_CHECK_GT(
+      options_.maxExpressionTreesPerStep,
+      0,
+      "--max_expression_trees_per_step needs to be greater than zero.");
+
+  auto startTime = std::chrono::system_clock::now();
+  size_t i = 0;
+  size_t numFailed = 0;
+
+  while (!isDone(i, startTime)) {
+    LOG(INFO) << "==============================> Started iteration " << i
+              << " (seed: " << currentSeed_ << ")";
+
+    // Generate multiple expression trees and input data vectors. They can
+    // re-use columns and share sub-expressions if the appropriate flag is set.
+    int numExpressionTrees = boost::random::uniform_int_distribution<int>(
+        1, options_.maxExpressionTreesPerStep)(rng_);
+    auto [expressions, inputType, selectionStats] =
+        expressionFuzzer_.fuzzExpressions(numExpressionTrees);
+
+    for (auto& [funcName, count] : selectionStats) {
+      exprNameToStats_[funcName].numTimesSelected += count;
+    }
+
+    std::vector<core::TypedExprPtr> plans = std::move(expressions);
+
+    auto rowVector = vectorFuzzer_->fuzzInputRow(inputType);
+
+    auto columnsToWrapInLazy = generateLazyColumnIds(rowVector, *vectorFuzzer_);
+
+    auto resultVectors = generateResultVectors(plans);
+    ResultOrError result;
+
+    try {
+      result = verifier_.verify(
+          plans,
+          rowVector,
+          resultVectors ? BaseVector::copy(*resultVectors) : nullptr,
+          true, // canThrow
+          columnsToWrapInLazy);
+    } catch (const std::exception&) {
+      if (options_.findMinimalSubexpression) {
+        test::computeMinimumSubExpression(
+            {&execCtx_, {false, ""}},
+            *vectorFuzzer_,
+            plans,
+            rowVector,
+            columnsToWrapInLazy);
+      }
+      throw;
+    }
+
+    if (result.exceptionPtr) {
+      ++numFailed;
+    }
+
+    // If both paths threw compatible exceptions, we add a try() function to
+    // the expression's root and execute it again. This time the expression
+    // cannot throw. Expressions that throw UNSUPPORTED_INPUT_UNCATCHABLE errors
+    // are not supported.
+    if (result.exceptionPtr && options_.retryWithTry &&
+        !result.unsupportedInputUncatchableError) {
+      LOG(INFO)
+          << "Both paths failed with compatible exceptions. Retrying expression using try().";
+      retryWithTry(plans, rowVector, resultVectors, columnsToWrapInLazy);
+    }
+
+    LOG(INFO) << "==============================> Done with iteration " << i;
+    reSeed();
+    ++i;
+  }
+  logStats();
+
+  LOG(ERROR) << "Total iterations: " << i;
+  LOG(ERROR) << "Total failed: " << numFailed;
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ExpressionFuzzerVerifier.h b/velox/expression/fuzzer/ExpressionFuzzerVerifier.h
new file mode 100644
index 0000000000000..be00ddca9bf12
--- /dev/null
+++ b/velox/expression/fuzzer/ExpressionFuzzerVerifier.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/core/ITypedExpr.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/fuzzer/ExpressionFuzzer.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/expression/tests/ExpressionVerifier.h"
+#include "velox/functions/FunctionRegistry.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+DECLARE_int32(velox_fuzzer_max_level_of_nesting);
+
+namespace facebook::velox::fuzzer {
+
+// A tool that utilizes ExpressionFuzzer, VectorFuzzer and ExpressionVerfier to
+// generate random expressions and verify the correctness of the results. It
+// works by:
+///
+///  1. Taking an initial set of available function signatures.
+///  2. Generating a random expression tree based on the available function
+///     signatures.
+///  3. Generating a random set of input data (vector), with a variety of
+///     encodings and data layouts.
+///  4. Executing the expression using the common and simplified eval paths, and
+///     asserting results are the exact same.
+///  5. Rinse and repeat.
+///
+
+class ExpressionFuzzerVerifier {
+ public:
+  struct Options;
+
+  ExpressionFuzzerVerifier(
+      const FunctionSignatureMap& signatureMap,
+      size_t initialSeed,
+      const Options& options,
+      const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
+          argGenerators);
+
+  // This function starts the test that is performed by the
+  // ExpressionFuzzerVerifier which is generating random expressions and
+  // verifying them.
+  void go();
+
+  struct Options {
+    // Number of expressions to generate and execute.
+    int32_t steps = 10;
+
+    // For how long it should run (in seconds). If zero it executes exactly
+    // --steps iterations and exits.
+    int32_t durationSeconds = 0;
+
+    // The number of elements on each generated vector.
+    int32_t batchSize = 100;
+
+    // Retry failed expressions by wrapping it using a try() statement.
+    bool retryWithTry = false;
+
+    // Automatically seeks minimum failed subexpression on result mismatch
+    bool findMinimalSubexpression = false;
+
+    // Disable constant folding in the common evaluation path.
+    bool disableConstantFolding = false;
+
+    // Directory path for persistence of data and SQL when fuzzer fails for
+    // future reproduction. Empty string disables this feature.
+    std::string reproPersistPath = "";
+
+    // Persist repro info before evaluation and only run one iteration.
+    // This is to rerun with the seed number and persist repro info upon a
+    // crash failure. Only effective if repro_persist_path is set.
+    bool persistAndRunOnce = false;
+
+    // Specifies the probability with which columns in the input row vector will
+    // be selected to be wrapped in lazy encoding (expressed as double from 0 to
+    // 1).
+    double lazyVectorGenerationRatio = 0.0;
+
+    // This sets an upper limit on the number of expression trees to generate
+    // per step. These trees would be executed in the same ExprSet and can
+    // re-use already generated columns and subexpressions (if re-use is
+    // enabled).
+    int32_t maxExpressionTreesPerStep = 1;
+
+    VectorFuzzer::Options vectorFuzzerOptions;
+
+    ExpressionFuzzer::Options expressionFuzzerOptions;
+
+    std::unordered_map<std::string, std::string> queryConfigs;
+  };
+
+ private:
+  struct ExprUsageStats {
+    // Num of times the expression was randomly selected.
+    int numTimesSelected = 0;
+    // Num of rows processed by the expression.
+    int numProcessedRows = 0;
+  };
+
+  void seed(size_t seed);
+
+  void reSeed();
+
+  // A utility class used to keep track of stats relevant to the fuzzer.
+  class ExprStatsListener : public exec::ExprSetListener {
+   public:
+    explicit ExprStatsListener(
+        std::unordered_map<std::string, ExprUsageStats>& exprNameToStats)
+        : exprNameToStats_(exprNameToStats) {}
+
+    void onCompletion(
+        const std::string& /*uuid*/,
+        const exec::ExprSetCompletionEvent& event) override {
+      for (auto& [funcName, stats] : event.stats) {
+        auto itr = exprNameToStats_.find(funcName);
+        if (itr == exprNameToStats_.end()) {
+          // Skip expressions like FieldReference and ConstantExpr
+          continue;
+        }
+        itr->second.numProcessedRows += stats.numProcessedRows;
+      }
+    }
+
+    // A no-op since we cannot tie errors directly to functions where they
+    // occurred.
+    void onError(vector_size_t /*numRows*/, const std::string& /*queryId*/)
+        override {}
+
+   private:
+    std::unordered_map<std::string, ExprUsageStats>& exprNameToStats_;
+  };
+
+  /// Randomize initial result vector data to test for correct null and data
+  /// setting in functions.
+  RowVectorPtr generateResultVectors(std::vector<core::TypedExprPtr>& plans);
+
+  /// Executes two steps:
+  /// #1. Retries executing the expression in `plan` by wrapping it in a `try()`
+  ///     clause and expecting it not to throw an exception.
+  /// #2. Re-execute the expression only on rows that produced non-NULL values
+  ///     in the previous step.
+  ///
+  /// Throws in case any of these steps fail.
+  void retryWithTry(
+      std::vector<core::TypedExprPtr> plans,
+      const RowVectorPtr& rowVector,
+      const VectorPtr& resultVectors,
+      const std::vector<int>& columnsToWrapInLazy);
+
+  /// If --duration_sec > 0, check if we expired the time budget. Otherwise,
+  /// check if we expired the number of iterations (--steps).
+  template <typename T>
+  bool isDone(size_t i, T startTime) const;
+
+  /// Called at the end of a successful fuzzer run. It logs the top and bottom
+  /// 10 functions based on the num of rows processed by them. Also logs a full
+  /// list of all functions sorted in descending order by the num of times they
+  /// were selected by the fuzzer. Every logged function contains the
+  /// information in the following format which can be easily exported to a
+  /// spreadsheet for further analysis: functionName numTimesSelected
+  /// proportionOfTimesSelected numProcessedRows.
+  void logStats();
+
+  // Randomly pick columns from the input row vector to wrap in lazy.
+  // Negative column indices represent lazy vectors that have been preloaded
+  // before feeding them to the evaluator. This list is sorted on the absolute
+  // value of the entries.
+  std::vector<int> generateLazyColumnIds(
+      const RowVectorPtr& rowVector,
+      VectorFuzzer& vectorFuzzer);
+
+  const Options options_;
+
+  FuzzerGenerator rng_;
+
+  size_t currentSeed_{0};
+
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::deprecatedAddDefaultLeafMemoryPool()};
+
+  core::ExecCtx execCtx_;
+
+  test::ExpressionVerifier verifier_;
+
+  std::shared_ptr<VectorFuzzer> vectorFuzzer_;
+
+  std::shared_ptr<ExprStatsListener> statListener_;
+
+  std::unordered_map<std::string, ExprUsageStats> exprNameToStats_;
+
+  /// The expression fuzzer that is used to fuzz the expression in the test.
+  ExpressionFuzzer expressionFuzzer_;
+};
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/FuzzerRunner.cpp b/velox/expression/fuzzer/FuzzerRunner.cpp
new file mode 100644
index 0000000000000..97ef1fc7bd670
--- /dev/null
+++ b/velox/expression/fuzzer/FuzzerRunner.cpp
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/fuzzer/FuzzerRunner.h"
+#include "velox/expression/fuzzer/ExpressionFuzzer.h"
+
+DEFINE_int32(steps, 10, "Number of expressions to generate and execute.");
+
+DEFINE_int32(
+    duration_sec,
+    0,
+    "For how long it should run (in seconds). If zero, "
+    "it executes exactly --steps iterations and exits.");
+
+DEFINE_int32(
+    batch_size,
+    100,
+    "The number of elements on each generated vector.");
+
+DEFINE_bool(
+    retry_with_try,
+    false,
+    "Retry failed expressions by wrapping it using a try() statement.");
+
+DEFINE_bool(
+    find_minimal_subexpression,
+    false,
+    "Automatically seeks minimum failed subexpression on result mismatch");
+
+DEFINE_bool(
+    disable_constant_folding,
+    false,
+    "Disable constant-folding in the common evaluation path.");
+
+DEFINE_string(
+    repro_persist_path,
+    "",
+    "Directory path for persistence of data and SQL when fuzzer fails for "
+    "future reproduction. Empty string disables this feature.");
+
+DEFINE_bool(
+    persist_and_run_once,
+    false,
+    "Persist repro info before evaluation and only run one iteration. "
+    "This is to rerun with the seed number and persist repro info upon a "
+    "crash failure. Only effective if repro_persist_path is set.");
+
+DEFINE_double(
+    lazy_vector_generation_ratio,
+    0.0,
+    "Specifies the probability with which columns in the input row "
+    "vector will be selected to be wrapped in lazy encoding "
+    "(expressed as double from 0 to 1).");
+
+DEFINE_int32(
+    max_expression_trees_per_step,
+    1,
+    "This sets an upper limit on the number of expression trees to generate "
+    "per step. These trees would be executed in the same ExprSet and can "
+    "re-use already generated columns and subexpressions (if re-use is "
+    "enabled).");
+
+// The flags bellow are used to initialize ExpressionFuzzer::options.
+DEFINE_string(
+    only,
+    "",
+    "If specified, Fuzzer will only choose functions from "
+    "this comma separated list of function names "
+    "(e.g: --only \"split\" or --only \"substr,ltrim\").");
+
+DEFINE_string(
+    special_forms,
+    "and,or,cast,coalesce,if,switch",
+    "Comma-separated list of special forms to use in generated expression. "
+    "Supported special forms: and, or, coalesce, if, switch, cast.");
+
+DEFINE_int32(
+    velox_fuzzer_max_level_of_nesting,
+    10,
+    "Max levels of expression nesting. The default value is 10 and minimum is 1.");
+
+DEFINE_int32(
+    max_num_varargs,
+    5,
+    "The maximum number of variadic arguments fuzzer will generate for "
+    "functions that accept variadic arguments. Fuzzer will generate up to "
+    "max_num_varargs arguments for the variadic list in addition to the "
+    "required arguments by the function.");
+
+DEFINE_double(
+    null_ratio,
+    0.1,
+    "Chance of adding a null constant to the plan, or null value in a vector "
+    "(expressed as double from 0 to 1).");
+
+DEFINE_bool(
+    enable_variadic_signatures,
+    false,
+    "Enable testing of function signatures with variadic arguments.");
+
+DEFINE_bool(
+    enable_dereference,
+    false,
+    "Allow fuzzer to generate random expressions with dereference and row_constructor functions.");
+
+DEFINE_bool(
+    velox_fuzzer_enable_complex_types,
+    false,
+    "Enable testing of function signatures with complex argument or return types.");
+
+DEFINE_bool(
+    velox_fuzzer_enable_decimal_type,
+    false,
+    "Enable testing of function signatures with decimal argument or return types.");
+
+DEFINE_bool(
+    velox_fuzzer_enable_column_reuse,
+    false,
+    "Enable generation of expressions where one input column can be "
+    "used by multiple subexpressions");
+
+DEFINE_bool(
+    velox_fuzzer_enable_expression_reuse,
+    false,
+    "Enable generation of expressions that re-uses already generated "
+    "subexpressions.");
+
+DEFINE_string(
+    assign_function_tickets,
+    "",
+    "Comma separated list of function names and their tickets in the format "
+    "<function_name>=<tickets>. Every ticket represents an opportunity for "
+    "a function to be chosen from a pool of candidates. By default, "
+    "every function has one ticket, and the likelihood of a function "
+    "being picked can be increased by allotting it more tickets. Note "
+    "that in practice, increasing the number of tickets does not "
+    "proportionally increase the likelihood of selection, as the selection "
+    "process involves filtering the pool of candidates by a required "
+    "return type so not all functions may compete against the same number "
+    "of functions at every instance. Number of tickets must be a positive "
+    "integer. Example: eq=3,floor=5");
+
+namespace facebook::velox::fuzzer {
+
+namespace {
+VectorFuzzer::Options getVectorFuzzerOptions() {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = FLAGS_batch_size;
+  opts.stringVariableLength = true;
+  opts.stringLength = 100;
+  opts.nullRatio = FLAGS_null_ratio;
+  return opts;
+}
+
+ExpressionFuzzer::Options getExpressionFuzzerOptions(
+    const std::unordered_set<std::string>& skipFunctions) {
+  ExpressionFuzzer::Options opts;
+  opts.maxLevelOfNesting = FLAGS_velox_fuzzer_max_level_of_nesting;
+  opts.maxNumVarArgs = FLAGS_max_num_varargs;
+  opts.enableVariadicSignatures = FLAGS_enable_variadic_signatures;
+  opts.enableDereference = FLAGS_enable_dereference;
+  opts.enableComplexTypes = FLAGS_velox_fuzzer_enable_complex_types;
+  opts.enableDecimalType = FLAGS_velox_fuzzer_enable_decimal_type;
+  opts.enableColumnReuse = FLAGS_velox_fuzzer_enable_column_reuse;
+  opts.enableExpressionReuse = FLAGS_velox_fuzzer_enable_expression_reuse;
+  opts.functionTickets = FLAGS_assign_function_tickets;
+  opts.nullRatio = FLAGS_null_ratio;
+  opts.specialForms = FLAGS_special_forms;
+  opts.useOnlyFunctions = FLAGS_only;
+  opts.skipFunctions = skipFunctions;
+  return opts;
+}
+
+ExpressionFuzzerVerifier::Options getExpressionFuzzerVerifierOptions(
+    const std::unordered_set<std::string>& skipFunctions,
+    const std::unordered_map<std::string, std::string>& queryConfigs) {
+  ExpressionFuzzerVerifier::Options opts;
+  opts.steps = FLAGS_steps;
+  opts.durationSeconds = FLAGS_duration_sec;
+  opts.batchSize = FLAGS_batch_size;
+  opts.retryWithTry = FLAGS_retry_with_try;
+  opts.findMinimalSubexpression = FLAGS_find_minimal_subexpression;
+  opts.disableConstantFolding = FLAGS_disable_constant_folding;
+  opts.reproPersistPath = FLAGS_repro_persist_path;
+  opts.persistAndRunOnce = FLAGS_persist_and_run_once;
+  opts.lazyVectorGenerationRatio = FLAGS_lazy_vector_generation_ratio;
+  opts.maxExpressionTreesPerStep = FLAGS_max_expression_trees_per_step;
+  opts.vectorFuzzerOptions = getVectorFuzzerOptions();
+  opts.expressionFuzzerOptions = getExpressionFuzzerOptions(skipFunctions);
+  opts.queryConfigs = queryConfigs;
+  return opts;
+}
+
+} // namespace
+
+// static
+int FuzzerRunner::run(
+    size_t seed,
+    const std::unordered_set<std::string>& skipFunctions,
+    const std::unordered_map<std::string, std::string>& queryConfigs,
+    const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
+        argGenerators) {
+  runFromGtest(seed, skipFunctions, queryConfigs, argGenerators);
+  return RUN_ALL_TESTS();
+}
+
+// static
+void FuzzerRunner::runFromGtest(
+    size_t seed,
+    const std::unordered_set<std::string>& skipFunctions,
+    const std::unordered_map<std::string, std::string>& queryConfigs,
+    const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
+        argGenerators) {
+  memory::MemoryManager::testingSetInstance({});
+  auto signatures = facebook::velox::getFunctionSignatures();
+  ExpressionFuzzerVerifier(
+      signatures,
+      seed,
+      getExpressionFuzzerVerifierOptions(skipFunctions, queryConfigs),
+      argGenerators)
+      .go();
+}
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/FuzzerRunner.h b/velox/expression/fuzzer/FuzzerRunner.h
new file mode 100644
index 0000000000000..c7c5cda54c650
--- /dev/null
+++ b/velox/expression/fuzzer/FuzzerRunner.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/String.h>
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "velox/expression/fuzzer/ExpressionFuzzerVerifier.h"
+#include "velox/functions/FunctionRegistry.h"
+
+namespace facebook::velox::fuzzer {
+
+/// FuzzerRunner leverages ExpressionFuzzerVerifier to create a gtest unit test.
+class FuzzerRunner {
+ public:
+  static int run(
+      size_t seed,
+      const std::unordered_set<std::string>& skipFunctions,
+      const std::unordered_map<std::string, std::string>& queryConfigs,
+      const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
+          argGenerators);
+
+  static void runFromGtest(
+      size_t seed,
+      const std::unordered_set<std::string>& skipFunctions,
+      const std::unordered_map<std::string, std::string>& queryConfigs,
+      const std::unordered_map<std::string, std::shared_ptr<ArgGenerator>>&
+          argGenerators);
+};
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/tests/FuzzerToolkit.cpp b/velox/expression/fuzzer/FuzzerToolkit.cpp
similarity index 75%
rename from velox/expression/tests/FuzzerToolkit.cpp
rename to velox/expression/fuzzer/FuzzerToolkit.cpp
index fdedaf9b71e08..292f4619bb661 100644
--- a/velox/expression/tests/FuzzerToolkit.cpp
+++ b/velox/expression/fuzzer/FuzzerToolkit.cpp
@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/tests/FuzzerToolkit.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
 
-namespace facebook::velox::test {
+namespace facebook::velox::fuzzer {
 
 std::string CallableSignature::toString() const {
   std::string buf = name;
@@ -103,4 +103,38 @@ void compareExceptions(
   LOG(INFO) << "Exceptions match.";
 }
 
-} // namespace facebook::velox::test
+void compareVectors(
+    const VectorPtr& left,
+    const VectorPtr& right,
+    const std::string& leftName,
+    const std::string& rightName,
+    const std::optional<SelectivityVector>& rowsInput) {
+  // Print vector contents if in verbose mode.
+  VLOG(1) << "Comparing vectors " << leftName << " vs " << rightName;
+
+  if (!rowsInput.has_value()) {
+    VELOX_CHECK_EQ(left->size(), right->size(), "Vectors must be equal size.");
+  }
+
+  const auto& rows =
+      rowsInput.has_value() ? *rowsInput : SelectivityVector(left->size());
+
+  rows.applyToSelected([&](vector_size_t row) {
+    VLOG(1) << fmt::format(
+        "At {} [ {} vs {} ]", row, left->toString(row), right->toString(row));
+  });
+  VLOG(1) << "===================";
+
+  rows.applyToSelected([&](vector_size_t row) {
+    VELOX_CHECK(
+        left->equalValueAt(right.get(), row, row),
+        "Different values at idx '{}': '{}' vs. '{}'",
+        row,
+        left->toString(row),
+        right->toString(row));
+  });
+
+  LOG(INFO) << "Two vectors match.";
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/FuzzerToolkit.h b/velox/expression/fuzzer/FuzzerToolkit.h
new file mode 100644
index 0000000000000..6eb0a17f9909b
--- /dev/null
+++ b/velox/expression/fuzzer/FuzzerToolkit.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/FunctionSignature.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::fuzzer {
+
+// Represents one available function signature.
+struct CallableSignature {
+  // Function name.
+  std::string name;
+
+  // Input arguments and return type.
+  std::vector<TypePtr> args;
+  bool variableArity{false};
+  TypePtr returnType;
+
+  // Boolean flags identifying constant arguments.
+  std::vector<bool> constantArgs;
+
+  // Convenience print function.
+  std::string toString() const;
+};
+
+struct SignatureTemplate {
+  std::string name;
+  const exec::FunctionSignature* signature;
+  std::unordered_set<std::string> typeVariables;
+};
+
+struct ResultOrError {
+  RowVectorPtr result;
+  std::exception_ptr exceptionPtr;
+  /// Whether the exception is UNSUPPORTED_INPUT_UNCATCHABLE error. This flag
+  /// should only be set to true when exceptionPtr is not a nullptr.
+  bool unsupportedInputUncatchableError{false};
+};
+
+/// Sort callable function signatures.
+void sortCallableSignatures(std::vector<CallableSignature>& signatures);
+
+/// Sort function signature templates.
+void sortSignatureTemplates(std::vector<SignatureTemplate>& signatures);
+
+void compareExceptions(
+    std::exception_ptr exceptionPtr,
+    std::exception_ptr otherExceptionPr);
+
+/// Parse the comma separated list of function names, and use it to filter the
+/// input signatures. Return a signature map that (1) only include functions
+/// appearing in onlyFunctions if onlyFunctions is non-empty, and (2) not
+/// include any functions appearing in skipFunctions if skipFunctions is
+/// non-empty.
+/// @tparam SignatureMapType can be AggregateFunctionSignatureMap or
+/// WindowFunctionMap.
+template <typename SignatureMapType>
+SignatureMapType filterSignatures(
+    const SignatureMapType& input,
+    const std::string& onlyFunctions,
+    const std::unordered_set<std::string>& skipFunctions) {
+  if (onlyFunctions.empty() && skipFunctions.empty()) {
+    return input;
+  }
+
+  SignatureMapType output;
+  if (!onlyFunctions.empty()) {
+    // Parse, lower case and trim it.
+    std::vector<folly::StringPiece> nameList;
+    folly::split(',', onlyFunctions, nameList);
+    std::unordered_set<std::string> nameSet;
+    for (const auto& it : nameList) {
+      auto str = folly::trimWhitespace(it).toString();
+      folly::toLowerAscii(str);
+      nameSet.insert(str);
+    }
+
+    for (const auto& it : input) {
+      if (nameSet.count(it.first) > 0) {
+        output.insert(it);
+      }
+    }
+  } else {
+    output = input;
+  }
+
+  for (auto s : skipFunctions) {
+    auto str = s;
+    folly::toLowerAscii(str);
+    output.erase(str);
+  }
+  return output;
+}
+// Compare two vectors for selected rows and throw on mismatch.
+// If rows not provided, left and right are checked to have the same size, and
+// all rows are compared.
+void compareVectors(
+    const VectorPtr& left,
+    const VectorPtr& right,
+    const std::string& leftName = "left",
+    const std::string& rightName = "right",
+    const std::optional<SelectivityVector>& rows = std::nullopt);
+} // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp b/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp
new file mode 100644
index 0000000000000..18a5453b1760b
--- /dev/null
+++ b/velox/expression/fuzzer/SparkExpressionFuzzerTest.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/String.h>
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "velox/expression/fuzzer/FuzzerRunner.h"
+#include "velox/functions/sparksql/Register.h"
+#include "velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/DivideArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h"
+
+using namespace facebook::velox::functions::sparksql::fuzzer;
+using facebook::velox::fuzzer::ArgGenerator;
+
+DEFINE_int64(
+    seed,
+    123456,
+    "Initial seed for random number generator "
+    "(use it to reproduce previous results).");
+
+using facebook::velox::fuzzer::FuzzerRunner;
+
+int main(int argc, char** argv) {
+  facebook::velox::functions::sparksql::registerFunctions("");
+
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+
+  // The following list are the Spark UDFs that hit issues
+  // For rlike you need the following combo in the only list:
+  // rlike, md5 and upper
+  std::unordered_set<std::string> skipFunctions = {
+      "regexp_extract",
+      // https://github.com/facebookincubator/velox/issues/8438
+      "regexp_replace",
+      "rlike",
+      "chr",
+      "replace",
+      "might_contain",
+      "unix_timestamp",
+      // from_unixtime throws VeloxRuntimeError when the timestamp is out of the
+      // supported range.
+      "from_unixtime",
+      // timestamp_millis(bigint) can generate timestamps out of the supported
+      // range that make other functions throw VeloxRuntimeErrors.
+      "timestamp_millis(bigint) -> timestamp",
+  };
+
+  // Required by spark_partition_id function.
+  std::unordered_map<std::string, std::string> queryConfigs = {
+      {facebook::velox::core::QueryConfig::kSparkPartitionId, "123"},
+      {facebook::velox::core::QueryConfig::kSessionTimezone,
+       "America/Los_Angeles"}};
+
+  std::unordered_map<std::string, std::shared_ptr<ArgGenerator>> argGenerators =
+      {{"add", std::make_shared<AddSubtractArgGenerator>()},
+       {"subtract", std::make_shared<AddSubtractArgGenerator>()},
+       {"multiply", std::make_shared<MultiplyArgGenerator>()},
+       {"divide", std::make_shared<DivideArgGenerator>()},
+       {"unscaled_value", std::make_shared<UnscaledValueArgGenerator>()},
+       {"make_timestamp", std::make_shared<MakeTimestampArgGenerator>()}};
+
+  return FuzzerRunner::run(
+      FLAGS_seed, skipFunctions, queryConfigs, argGenerators);
+}
diff --git a/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.cpp b/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.cpp
new file mode 100644
index 0000000000000..7dd10d3adf33b
--- /dev/null
+++ b/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h"
+#include <gtest/gtest.h>
+#include "velox/expression/SignatureBinder.h"
+
+namespace facebook::velox::fuzzer::test {
+
+void assertReturnType(
+    const std::shared_ptr<ArgGenerator>& generator,
+    const exec::FunctionSignature& signature,
+    const TypePtr& returnType) {
+  std::mt19937 seed{0};
+  const auto argTypes = generator->generateArgs(signature, returnType, seed);
+
+  // Resolve return type from argument types for the given signature.
+  exec::SignatureBinder binder(signature, argTypes);
+  VELOX_CHECK(
+      binder.tryBind(),
+      "Failed to resolve {} from argument types.",
+      returnType->toString());
+  const auto actualType = binder.tryResolveReturnType();
+  EXPECT_TRUE(returnType->equivalent(*actualType))
+      << "Expected type: " << returnType->toString()
+      << ", actual type: " << actualType->toString();
+}
+
+void assertEmptyArgs(
+    std::shared_ptr<ArgGenerator> generator,
+    const exec::FunctionSignature& signature,
+    const TypePtr& returnType) {
+  std::mt19937 seed{0};
+  const auto argTypes = generator->generateArgs(signature, returnType, seed);
+  EXPECT_TRUE(argTypes.empty());
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h b/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h
new file mode 100644
index 0000000000000..95b8c4d5ab5f4
--- /dev/null
+++ b/velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/functions/FunctionRegistry.h"
+
+namespace facebook::velox::fuzzer::test {
+
+/// Assert the equivalence between the given return type and the actual type
+/// resolved from generated argument types.
+void assertReturnType(
+    const std::shared_ptr<ArgGenerator>& generator,
+    const exec::FunctionSignature& signature,
+    const TypePtr& returnType);
+
+// Assert that no argument types can be generated for the given return type.
+void assertEmptyArgs(
+    std::shared_ptr<ArgGenerator> generator,
+    const exec::FunctionSignature& signature,
+    const TypePtr& returnType);
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp b/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp
new file mode 100644
index 0000000000000..ca4ee13b64d5e
--- /dev/null
+++ b/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp
@@ -0,0 +1,707 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/fuzzer/ArgumentTypeFuzzer.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/expression/SignatureBinder.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::fuzzer::test {
+
+namespace {
+const uint32_t kMaxVariadicArgs = 5;
+} // namespace
+
+class ArgumentTypeFuzzerTest : public testing::Test {
+ protected:
+  void testFuzzingSuccess(
+      const std::shared_ptr<exec::FunctionSignature>& signature,
+      const TypePtr& returnType,
+      const std::vector<TypePtr>& expectedArgumentTypes) {
+    std::mt19937 seed{0};
+    ArgumentTypeFuzzer fuzzer{*signature, returnType, seed};
+    ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+
+    auto& argumentTypes = fuzzer.argumentTypes();
+    ASSERT_LE(expectedArgumentTypes.size(), argumentTypes.size());
+
+    auto& argumentSignatures = signature->argumentTypes();
+    int i;
+    for (i = 0; i < expectedArgumentTypes.size(); ++i) {
+      ASSERT_TRUE(expectedArgumentTypes[i]->equivalent(*argumentTypes[i]))
+          << "at " << i
+          << ": Expected: " << expectedArgumentTypes[i]->toString()
+          << ". Got: " << argumentTypes[i]->toString();
+    }
+
+    if (i < argumentTypes.size()) {
+      ASSERT_TRUE(signature->variableArity());
+      ASSERT_LE(
+          argumentTypes.size() - argumentSignatures.size(), kMaxVariadicArgs);
+      for (int j = i; j < argumentTypes.size(); ++j) {
+        ASSERT_TRUE(argumentTypes[j]->equivalent(*argumentTypes[i - 1]));
+      }
+    }
+  }
+
+  void testFuzzingFailure(
+      const std::shared_ptr<exec::FunctionSignature>& signature,
+      const TypePtr& returnType) {
+    std::mt19937 seed{0};
+    ArgumentTypeFuzzer fuzzer{*signature, returnType, seed};
+    ASSERT_FALSE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+  }
+};
+
+TEST_F(ArgumentTypeFuzzerTest, concreteSignature) {
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("bigint")
+                         .argumentType("varchar")
+                         .argumentType("array(boolean)")
+                         .build();
+
+    testFuzzingSuccess(signature, BIGINT(), {VARCHAR(), ARRAY(BOOLEAN())});
+    testFuzzingFailure(signature, SMALLINT());
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("array(array(double))")
+                         .argumentType("array(bigint)")
+                         .argumentType("double")
+                         .build();
+
+    testFuzzingSuccess(
+        signature, ARRAY(ARRAY(DOUBLE())), {ARRAY(BIGINT()), DOUBLE()});
+    testFuzzingFailure(signature, ARRAY(ARRAY(REAL())));
+    testFuzzingFailure(signature, ARRAY(DOUBLE()));
+  }
+}
+
+TEST_F(ArgumentTypeFuzzerTest, signatureTemplate) {
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("T")
+                         .argumentType("T")
+                         .argumentType("array(T)")
+                         .build();
+
+    testFuzzingSuccess(signature, BIGINT(), {BIGINT(), ARRAY(BIGINT())});
+    testFuzzingSuccess(
+        signature, ARRAY(DOUBLE()), {ARRAY(DOUBLE()), ARRAY(ARRAY(DOUBLE()))});
+    testFuzzingSuccess(
+        signature, ROW({DOUBLE()}), {ROW({DOUBLE()}), ARRAY(ROW({DOUBLE()}))});
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("array(T)")
+                         .argumentType("T")
+                         .argumentType("bigint")
+                         .build();
+
+    testFuzzingSuccess(
+        signature, ARRAY(ARRAY(DOUBLE())), {ARRAY(DOUBLE()), BIGINT()});
+    testFuzzingSuccess(signature, ARRAY(VARCHAR()), {VARCHAR(), BIGINT()});
+    testFuzzingFailure(signature, BIGINT());
+    testFuzzingFailure(signature, MAP(VARCHAR(), BIGINT()));
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .knownTypeVariable("K")
+                         .typeVariable("V")
+                         .returnType("K")
+                         .argumentType("array(K)")
+                         .argumentType("array(V)")
+                         .build();
+
+    auto verifyArgumentTypes = [&](const TypePtr& returnType,
+                                   const TypePtr& firstArg) {
+      std::mt19937 seed{0};
+      ArgumentTypeFuzzer fuzzer{*signature, returnType, seed};
+      ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+
+      auto& argumentTypes = fuzzer.argumentTypes();
+      ASSERT_TRUE(argumentTypes[0]->equivalent(*firstArg));
+      // Only check the top-level type because the child type is randomly
+      // generated.
+      ASSERT_TRUE(argumentTypes[1]->isArray());
+    };
+
+    verifyArgumentTypes(DECIMAL(10, 5), ARRAY(DECIMAL(10, 5)));
+    verifyArgumentTypes(ARRAY(DOUBLE()), ARRAY(ARRAY(DOUBLE())));
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .knownTypeVariable("K")
+                         .typeVariable("V")
+                         .returnType("bigint")
+                         .argumentType("array(K)")
+                         .argumentType("array(V)")
+                         .build();
+
+    {
+      std::mt19937 seed{0};
+      ArgumentTypeFuzzer fuzzer{*signature, BIGINT(), seed};
+      ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+
+      auto& argumentTypes = fuzzer.argumentTypes();
+      // Only check the top-level type because the children types are randomly
+      // generated.
+      ASSERT_TRUE(argumentTypes[0]->isArray());
+      ASSERT_TRUE(argumentTypes[1]->isArray());
+    }
+
+    testFuzzingFailure(signature, DOUBLE());
+  }
+}
+
+TEST_F(ArgumentTypeFuzzerTest, variableArity) {
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("X")
+                         .returnType("X")
+                         .argumentType("X")
+                         .variableArity("bigint")
+                         .build();
+
+    testFuzzingSuccess(signature, VARCHAR(), {VARCHAR(), BIGINT()});
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .knownTypeVariable("K")
+                         .returnType("bigint")
+                         .variableArity("K")
+                         .build();
+    std::mt19937 seed{0};
+    ArgumentTypeFuzzer fuzzer{*signature, BIGINT(), seed};
+    ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+
+    auto& argumentTypes = fuzzer.argumentTypes();
+    auto& firstArg = argumentTypes[0];
+    for (const auto& argument : argumentTypes) {
+      ASSERT_TRUE(argument->equivalent(*firstArg));
+    }
+  }
+}
+
+TEST_F(ArgumentTypeFuzzerTest, any) {
+  auto signature = exec::FunctionSignatureBuilder()
+                       .returnType("bigint")
+                       .argumentType("any")
+                       .build();
+  std::mt19937 seed{0};
+  ArgumentTypeFuzzer fuzzer{*signature, BIGINT(), seed};
+  ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+
+  auto& argumentTypes = fuzzer.argumentTypes();
+  ASSERT_EQ(argumentTypes.size(), 1);
+  ASSERT_TRUE(argumentTypes[0] != nullptr);
+}
+
+TEST_F(ArgumentTypeFuzzerTest, unsupported) {
+  // Constraints on the return type is not supported.
+  auto signature =
+      exec::FunctionSignatureBuilder()
+          .integerVariable("a_scale")
+          .integerVariable("b_scale")
+          .integerVariable("a_precision")
+          .integerVariable("b_precision")
+          .integerVariable(
+              "r_precision",
+              "min(38, max(a_precision - a_scale, b_precision - b_scale) + max(a_scale, b_scale) + 1)")
+          .integerVariable("r_scale", "max(a_scale, b_scale)")
+          .returnType("row(array(decimal(r_precision, r_scale)))")
+          .argumentType("decimal(a_precision, a_scale)")
+          .argumentType("decimal(b_precision, b_scale)")
+          .build();
+
+  testFuzzingFailure(signature, ROW({ARRAY(DECIMAL(13, 6))}));
+
+  // Constraints on the argument types are not supported.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("a_scale")
+                  .integerVariable("b_scale")
+                  .integerVariable("a_precision", "a_scale + 1")
+                  .integerVariable("b_precision")
+                  .integerVariable("r_precision")
+                  .integerVariable("r_scale")
+                  .returnType("decimal(r_precision, r_scale)")
+                  .argumentType("decimal(a_precision, a_scale)")
+                  .argumentType("decimal(b_precision, b_scale)")
+                  .build();
+
+  testFuzzingFailure(signature, DECIMAL(13, 6));
+}
+
+TEST_F(ArgumentTypeFuzzerTest, lambda) {
+  // array(T), function(T, boolean) -> array(T)
+  auto signature = exec::FunctionSignatureBuilder()
+                       .typeVariable("T")
+                       .returnType("array(T)")
+                       .argumentType("array(T)")
+                       .argumentType("function(T,boolean)")
+                       .build();
+
+  testFuzzingSuccess(
+      signature,
+      ARRAY(BIGINT()),
+      {ARRAY(BIGINT()), FUNCTION(std::vector<TypePtr>{BIGINT()}, BOOLEAN())});
+
+  // array(T), function(T, U) -> array(U)
+  signature = exec::FunctionSignatureBuilder()
+                  .typeVariable("T")
+                  .typeVariable("U")
+                  .returnType("array(U)")
+                  .argumentType("array(T)")
+                  .argumentType("function(T,U)")
+                  .build();
+
+  {
+    std::mt19937 seed{0};
+    ArgumentTypeFuzzer fuzzer{*signature, ARRAY(VARCHAR()), seed};
+    ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+
+    const auto& argumentTypes = fuzzer.argumentTypes();
+    ASSERT_TRUE(argumentTypes[0]->isArray());
+
+    // T is chosen randomly.
+    auto randomType = argumentTypes[0]->asArray().elementType();
+    ASSERT_EQ(*argumentTypes[1], *FUNCTION({randomType}, VARCHAR()));
+  }
+
+  // map(K, V1), function(K, V1, V2) -> map(K, V2)
+  signature = exec::FunctionSignatureBuilder()
+                  .knownTypeVariable("K")
+                  .typeVariable("V1")
+                  .typeVariable("V2")
+                  .returnType("map(K,V2)")
+                  .argumentType("map(K,V1)")
+                  .argumentType("function(K,V1,V2)")
+                  .build();
+
+  {
+    std::mt19937 seed{0};
+    ArgumentTypeFuzzer fuzzer{*signature, MAP(BIGINT(), VARCHAR()), seed};
+    ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+
+    const auto& argumentTypes = fuzzer.argumentTypes();
+    ASSERT_TRUE(argumentTypes[0]->isMap());
+    ASSERT_TRUE(argumentTypes[0]->asMap().keyType()->isBigint());
+
+    // V1 is chosen randomly.
+    auto randomType = argumentTypes[0]->asMap().valueType();
+    ASSERT_EQ(*argumentTypes[1], *FUNCTION({BIGINT(), randomType}, VARCHAR()));
+  }
+}
+
+TEST_F(ArgumentTypeFuzzerTest, unconstrainedSignatureTemplate) {
+  auto signature = exec::FunctionSignatureBuilder()
+                       .knownTypeVariable("K")
+                       .typeVariable("V")
+                       .returnType("V")
+                       .argumentType("map(K,V)")
+                       .argumentType("K")
+                       .build();
+
+  std::mt19937 seed{0};
+  ArgumentTypeFuzzer fuzzer{*signature, MAP(BIGINT(), VARCHAR()), seed};
+  ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
+
+  const auto& argumentTypes = fuzzer.argumentTypes();
+  ASSERT_EQ(2, argumentTypes.size());
+  ASSERT_TRUE(argumentTypes[0] != nullptr);
+  ASSERT_TRUE(argumentTypes[1] != nullptr);
+
+  ASSERT_EQ(argumentTypes[0]->kind(), TypeKind::MAP);
+
+  ASSERT_EQ(argumentTypes[0]->childAt(0), argumentTypes[1]);
+}
+
+TEST_F(ArgumentTypeFuzzerTest, orderableConstraint) {
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .orderableTypeVariable("T")
+                         .returnType("bigint")
+                         .argumentType("T")
+                         .build();
+
+    for (size_t i = 0; i < 100; ++i) {
+      std::mt19937 rng(i);
+      ArgumentTypeFuzzer fuzzer{*signature, nullptr, rng};
+      fuzzer.fuzzArgumentTypes(kMaxVariadicArgs);
+      ASSERT_TRUE(fuzzer.argumentTypes()[0]->isOrderable())
+          << fuzzer.argumentTypes()[0]->toString();
+    }
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .orderableTypeVariable("T")
+                         .returnType("T")
+                         .argumentType("T")
+                         .build();
+    testFuzzingFailure(signature, MAP(VARCHAR(), BIGINT()));
+    testFuzzingFailure(signature, ARRAY(MAP(VARCHAR(), BIGINT())));
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .orderableTypeVariable("T")
+                         .returnType("array(T)")
+                         .argumentType("array(T)")
+                         .build();
+
+    testFuzzingSuccess(signature, ARRAY(DOUBLE()), {ARRAY(DOUBLE())});
+    testFuzzingSuccess(
+        signature, ARRAY(ROW({DOUBLE()})), {ARRAY(ROW({DOUBLE()}))});
+    testFuzzingFailure(signature, MAP(VARCHAR(), BIGINT()));
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .orderableTypeVariable("U")
+                         .returnType("row(T, U)")
+                         .argumentType("T")
+                         .argumentType("row(T,U)")
+                         .build();
+
+    testFuzzingSuccess(
+        signature,
+        ROW({MAP(BIGINT(), BIGINT()), BIGINT()}),
+        {MAP(BIGINT(), BIGINT()), ROW({MAP(BIGINT(), BIGINT()), BIGINT()})});
+
+    testFuzzingFailure(signature, ROW({BIGINT(), MAP(VARCHAR(), BIGINT())}));
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .orderableTypeVariable("U")
+                         .returnType("row(T,U)")
+                         .argumentType("T")
+                         .argumentType("function(T,U)")
+                         .build();
+
+    testFuzzingSuccess(
+        signature,
+        ROW({MAP(BIGINT(), BIGINT()), BIGINT()}),
+        {MAP(BIGINT(), BIGINT()),
+         std::make_shared<FunctionType>(
+             std::vector<TypePtr>{MAP(BIGINT(), BIGINT())}, BIGINT())});
+
+    testFuzzingFailure(signature, ROW({BIGINT(), MAP(VARCHAR(), BIGINT())}));
+  }
+}
+
+TEST_F(ArgumentTypeFuzzerTest, fuzzDecimalArgumentTypes) {
+  auto fuzzArgumentTypes = [](const exec::FunctionSignature& signature,
+                              const TypePtr& returnType) {
+    std::mt19937 seed{0};
+    ArgumentTypeFuzzer fuzzer{signature, returnType, seed};
+    bool ok = fuzzer.fuzzArgumentTypes(kMaxVariadicArgs);
+    VELOX_CHECK(
+        ok,
+        "Signature: {}, Return type: {}",
+        signature.toString(),
+        returnType->toString());
+    return fuzzer.argumentTypes();
+  };
+
+  // Argument type must match return type.
+  auto signature = exec::FunctionSignatureBuilder()
+                       .integerVariable("p")
+                       .integerVariable("s")
+                       .returnType("decimal(p,s)")
+                       .argumentType("decimal(p,s)")
+                       .build();
+
+  auto argTypes = fuzzArgumentTypes(*signature, DECIMAL(10, 7));
+  ASSERT_EQ(1, argTypes.size());
+  EXPECT_EQ(DECIMAL(10, 7)->toString(), argTypes[0]->toString());
+
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s")
+                  .returnType("decimal(p,s)")
+                  .argumentType("decimal(p,s)")
+                  .variableArity("decimal(p,s)")
+                  .build();
+  argTypes = fuzzArgumentTypes(*signature, DECIMAL(10, 7));
+  ASSERT_LE(1, argTypes.size());
+  for (const auto& argType : argTypes) {
+    EXPECT_EQ(DECIMAL(10, 7)->toString(), argType->toString());
+  }
+
+  // Argument type can be any decimal.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s")
+                  .returnType("boolean")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  argTypes = fuzzArgumentTypes(*signature, BOOLEAN());
+  ASSERT_EQ(1, argTypes.size());
+  EXPECT_TRUE(argTypes[0]->isDecimal());
+
+  // Argument type can be any decimal with scale 30.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .returnType("boolean")
+                  .argumentType("decimal(p,30)")
+                  .build();
+
+  argTypes = fuzzArgumentTypes(*signature, BOOLEAN());
+  ASSERT_EQ(1, argTypes.size());
+  EXPECT_TRUE(argTypes[0]->isDecimal());
+  EXPECT_EQ(30, getDecimalPrecisionScale(*argTypes[0]).second);
+
+  // Another way to specify fixed scale.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s", "3")
+                  .returnType("boolean")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  argTypes = fuzzArgumentTypes(*signature, BOOLEAN());
+  ASSERT_EQ(1, argTypes.size());
+  EXPECT_TRUE(argTypes[0]->isDecimal());
+  EXPECT_EQ(3, getDecimalPrecisionScale(*argTypes[0]).second);
+
+  // Argument type can be any decimal with precision 3.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("s")
+                  .returnType("boolean")
+                  .argumentType("decimal(3,s)")
+                  .build();
+
+  argTypes = fuzzArgumentTypes(*signature, BOOLEAN());
+  ASSERT_EQ(1, argTypes.size());
+  EXPECT_TRUE(argTypes[0]->isDecimal());
+  EXPECT_EQ(3, getDecimalPrecisionScale(*argTypes[0]).first);
+
+  // Another way to specify fixed precision.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p", "30")
+                  .integerVariable("s")
+                  .returnType("boolean")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  argTypes = fuzzArgumentTypes(*signature, BOOLEAN());
+  ASSERT_EQ(1, argTypes.size());
+  EXPECT_TRUE(argTypes[0]->isDecimal());
+  EXPECT_EQ(30, getDecimalPrecisionScale(*argTypes[0]).first);
+
+  // Multiple arguments. All must be the same as return type.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s")
+                  .returnType("decimal(p,s)")
+                  .argumentType("decimal(p,s)")
+                  .argumentType("decimal(p,s)")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  argTypes = fuzzArgumentTypes(*signature, DECIMAL(10, 7));
+  ASSERT_EQ(3, argTypes.size());
+  EXPECT_EQ(DECIMAL(10, 7)->toString(), argTypes[0]->toString());
+  EXPECT_EQ(DECIMAL(10, 7)->toString(), argTypes[1]->toString());
+  EXPECT_EQ(DECIMAL(10, 7)->toString(), argTypes[2]->toString());
+
+  // Multiple arguments. Some have fixed precision, scale or both.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s")
+                  .returnType("decimal(p,s)")
+                  .argumentType("decimal(p,s)")
+                  .argumentType("decimal(p,10)")
+                  .argumentType("decimal(12,s)")
+                  .argumentType("decimal(2,1)")
+                  .build();
+
+  argTypes = fuzzArgumentTypes(*signature, DECIMAL(10, 7));
+  ASSERT_EQ(4, argTypes.size());
+  EXPECT_EQ(DECIMAL(10, 7)->toString(), argTypes[0]->toString());
+  EXPECT_EQ(DECIMAL(10, 10)->toString(), argTypes[1]->toString());
+  EXPECT_EQ(DECIMAL(12, 7)->toString(), argTypes[2]->toString());
+  EXPECT_EQ(DECIMAL(2, 1)->toString(), argTypes[3]->toString());
+
+  // Multiple pairs of precision and scale variables.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p1")
+                  .integerVariable("s1")
+                  .integerVariable("p2")
+                  .integerVariable("s2")
+                  .returnType("bigint")
+                  .argumentType("decimal(p1,s1)")
+                  .argumentType("decimal(p2,s2)")
+                  .argumentType("decimal(p1,s1)")
+                  .argumentType("decimal(p2,s2)")
+                  .build();
+  argTypes = fuzzArgumentTypes(*signature, BIGINT());
+  ASSERT_EQ(4, argTypes.size());
+  EXPECT_TRUE(argTypes[0]->isDecimal());
+  EXPECT_TRUE(argTypes[1]->isDecimal());
+  EXPECT_EQ(argTypes[0]->toString(), argTypes[2]->toString());
+  EXPECT_EQ(argTypes[1]->toString(), argTypes[3]->toString());
+
+  // Decimal argument types are nested in complex types.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("a_scale")
+                  .integerVariable("b_scale")
+                  .integerVariable("a_precision")
+                  .integerVariable("b_precision")
+                  .integerVariable("r_precision")
+                  .integerVariable("r_scale")
+                  .returnType("decimal(r_precision, r_scale)")
+                  .argumentType("row(array(decimal(a_precision, a_scale)))")
+                  .argumentType("row(array(decimal(b_precision, b_scale)))")
+                  .build();
+  argTypes = fuzzArgumentTypes(*signature, DECIMAL(10, 7));
+  ASSERT_EQ(2, argTypes.size());
+  EXPECT_TRUE(argTypes[0]->isRow());
+  EXPECT_TRUE(argTypes[0]->asRow().childAt(0)->isArray());
+  EXPECT_TRUE(
+      argTypes[0]->asRow().childAt(0)->asArray().elementType()->isDecimal());
+  EXPECT_TRUE(argTypes[1]->isRow());
+  EXPECT_TRUE(argTypes[1]->asRow().childAt(0)->isArray());
+  EXPECT_TRUE(
+      argTypes[1]->asRow().childAt(0)->asArray().elementType()->isDecimal());
+}
+
+TEST_F(ArgumentTypeFuzzerTest, fuzzDecimalReturnType) {
+  auto fuzzReturnType = [](const exec::FunctionSignature& signature) {
+    std::mt19937 seed{0};
+    ArgumentTypeFuzzer fuzzer{signature, seed};
+    return fuzzer.fuzzReturnType();
+  };
+
+  // Return type can be any decimal.
+  auto signature = exec::FunctionSignatureBuilder()
+                       .integerVariable("p")
+                       .integerVariable("s")
+                       .returnType("decimal(p,s)")
+                       .argumentType("decimal(p,s)")
+                       .build();
+
+  auto returnType = fuzzReturnType(*signature);
+  EXPECT_TRUE(returnType->isDecimal());
+
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s")
+                  .returnType("decimal(p,s)")
+                  .argumentType("decimal(p,s)")
+                  .variableArity("decimal(p,s)")
+                  .build();
+
+  returnType = fuzzReturnType(*signature);
+  EXPECT_TRUE(returnType->isDecimal());
+
+  // Return type can be any decimal with scale 3.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s")
+                  .returnType("decimal(p,3)")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  returnType = fuzzReturnType(*signature);
+  EXPECT_TRUE(returnType->isDecimal());
+  EXPECT_EQ(3, getDecimalPrecisionScale(*returnType).second);
+
+  // Another way to specify that scale must be 3.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s", "3")
+                  .returnType("decimal(p,s)")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  returnType = fuzzReturnType(*signature);
+  EXPECT_TRUE(returnType->isDecimal());
+  EXPECT_EQ(3, getDecimalPrecisionScale(*returnType).second);
+
+  // Return type can be any decimal with precision 22.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s")
+                  .returnType("decimal(22,s)")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  returnType = fuzzReturnType(*signature);
+  EXPECT_TRUE(returnType->isDecimal());
+  EXPECT_EQ(22, getDecimalPrecisionScale(*returnType).first);
+
+  // Another way to specify that precision must be 22.
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p", "22")
+                  .integerVariable("s")
+                  .returnType("decimal(p,s)")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  returnType = fuzzReturnType(*signature);
+  EXPECT_TRUE(returnType->isDecimal());
+  EXPECT_EQ(22, getDecimalPrecisionScale(*returnType).first);
+
+  // Return type can only be DECIMAL(10, 7).
+  signature = exec::FunctionSignatureBuilder()
+                  .integerVariable("p")
+                  .integerVariable("s")
+                  .returnType("decimal(10,7)")
+                  .argumentType("decimal(p,s)")
+                  .build();
+
+  returnType = fuzzReturnType(*signature);
+  EXPECT_EQ(DECIMAL(10, 7)->toString(), returnType->toString());
+
+  // Decimal return type is nested in complex types.
+  signature =
+      exec::FunctionSignatureBuilder()
+          .integerVariable("a_scale")
+          .integerVariable("b_scale")
+          .integerVariable("a_precision")
+          .integerVariable("b_precision")
+          .returnType(
+              "row(array(decimal(a_precision, a_scale)), array(decimal(b_precision, b_scale)))")
+          .argumentType("decimal(a_precision, a_scale)")
+          .argumentType("decimal(b_precision, b_scale)")
+          .build();
+  returnType = fuzzReturnType(*signature);
+  EXPECT_TRUE(returnType->isRow());
+  EXPECT_TRUE(returnType->asRow().childAt(0)->isArray());
+  EXPECT_TRUE(returnType->asRow().childAt(1)->isArray());
+  EXPECT_TRUE(
+      returnType->asRow().childAt(0)->asArray().elementType()->isDecimal());
+  EXPECT_TRUE(
+      returnType->asRow().childAt(1)->asArray().elementType()->isDecimal());
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/expression/fuzzer/tests/CMakeLists.txt b/velox/expression/fuzzer/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..c87b21e173f53
--- /dev/null
+++ b/velox/expression/fuzzer/tests/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_expression_fuzzer_test_utility ArgGeneratorTestUtils.cpp)
+target_link_libraries(
+  velox_expression_fuzzer_test_utility velox_expression_functions
+  velox_function_registry GTest::gtest)
+
+add_executable(
+  velox_expression_fuzzer_unit_test
+  ArgumentTypeFuzzerTest.cpp DecimalArgGeneratorTest.cpp
+  ExpressionFuzzerUnitTest.cpp)
+
+target_link_libraries(
+  velox_expression_fuzzer_unit_test
+  velox_expression_fuzzer
+  velox_functions_prestosql
+  velox_core
+  velox_expression
+  velox_expression_fuzzer_test_utility
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/expression/fuzzer/tests/DecimalArgGeneratorTest.cpp b/velox/expression/fuzzer/tests/DecimalArgGeneratorTest.cpp
new file mode 100644
index 0000000000000..3c77253f56dc2
--- /dev/null
+++ b/velox/expression/fuzzer/tests/DecimalArgGeneratorTest.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h"
+
+namespace facebook::velox::fuzzer::test {
+
+class DecimalArgGeneratorTest : public testing::Test {
+ protected:
+  class UnaryArgGenerator : public DecimalArgGeneratorBase {
+   public:
+    UnaryArgGenerator() {
+      initialize(1);
+    }
+
+   protected:
+    std::optional<std::pair<int, int>> toReturnType(int p, int s) override {
+      auto precision = std::min(38, p + s + 1);
+      auto scale = std::min(s + 1, 18);
+      return {{precision, scale}};
+    }
+  };
+
+  class BinaryArgGenerator : public DecimalArgGeneratorBase {
+   public:
+    BinaryArgGenerator() {
+      initialize(2);
+    }
+
+   protected:
+    std::optional<std::pair<int, int>>
+    toReturnType(int p1, int s1, int p2, int s2) override {
+      auto s = std::max(s1, s2);
+      auto p = std::min(38, std::max(p1 - s1, p2 - s2) + std::max(s1, s2) + 1);
+      return {{p, s}};
+    }
+  };
+};
+
+TEST_F(DecimalArgGeneratorTest, unary) {
+  auto signature =
+      exec::FunctionSignatureBuilder()
+          .integerVariable("scale")
+          .integerVariable("precision")
+          .integerVariable("r_precision", "min(38, precision + scale + 1)")
+          .integerVariable("r_scale", "min(scale + 1, 18)")
+          .returnType("decimal(r_precision, r_scale)")
+          .argumentType("decimal(precision, scale)")
+          .build();
+
+  const auto generator = std::make_shared<UnaryArgGenerator>();
+  for (auto returnType : {DECIMAL(10, 2), DECIMAL(38, 18)}) {
+    assertReturnType(generator, *signature, returnType);
+  }
+  assertEmptyArgs(generator, *signature, DECIMAL(38, 20));
+}
+
+TEST_F(DecimalArgGeneratorTest, binary) {
+  auto signature =
+      exec::FunctionSignatureBuilder()
+          .integerVariable("a_scale")
+          .integerVariable("b_scale")
+          .integerVariable("a_precision")
+          .integerVariable("b_precision")
+          .integerVariable(
+              "r_precision",
+              "min(38, max(a_precision - a_scale, b_precision - b_scale) + max(a_scale, b_scale) + 1)")
+          .integerVariable("r_scale", "max(a_scale, b_scale)")
+          .returnType("decimal(r_precision, r_scale)")
+          .argumentType("decimal(a_precision, a_scale)")
+          .argumentType("decimal(b_precision, b_scale)")
+          .build();
+
+  const auto generator = std::make_shared<BinaryArgGenerator>();
+  for (auto returnType :
+       {DECIMAL(10, 2), DECIMAL(38, 20), DECIMAL(38, 38), DECIMAL(38, 0)}) {
+    assertReturnType(generator, *signature, returnType);
+  }
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/expression/tests/ExpressionFuzzerUnitTest.cpp b/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
similarity index 77%
rename from velox/expression/tests/ExpressionFuzzerUnitTest.cpp
rename to velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
index 26dd27f65ffe3..2a00931336876 100644
--- a/velox/expression/tests/ExpressionFuzzerUnitTest.cpp
+++ b/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
@@ -16,12 +16,16 @@
 
 #include <gtest/gtest.h>
 
-#include "velox/expression/tests/ExpressionFuzzer.h"
+#include "velox/expression/fuzzer/ExpressionFuzzer.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 
-namespace facebook::velox::test {
+namespace facebook::velox::fuzzer::test {
 class ExpressionFuzzerUnitTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   uint32_t countLevelOfNesting(core::TypedExprPtr expression) {
     if (expression->inputs().empty()) {
       return 0;
@@ -50,18 +54,34 @@ class ExpressionFuzzerUnitTest : public testing::Test {
     auto index = folly::Random::rand32(kSupportedTypes.size(), seed);
     return kSupportedTypes[index];
   }
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
+
+  std::shared_ptr<VectorFuzzer> vectorfuzzer{
+      std::make_shared<VectorFuzzer>(VectorFuzzer::Options{}, pool.get())};
 };
 
+namespace {
+auto makeOptionsWithMaxLevelNesting(int32_t value) {
+  ExpressionFuzzer::Options options;
+  options.maxLevelOfNesting = value;
+  return options;
+}
+} // namespace
 TEST_F(ExpressionFuzzerUnitTest, restrictedLevelOfNesting) {
   velox::functions::prestosql::registerAllScalarFunctions();
   std::mt19937 seed{0};
 
   auto testLevelOfNesting = [&](int32_t maxLevelOfNesting) {
     ExpressionFuzzer fuzzer{
-        velox::getFunctionSignatures(), 0, maxLevelOfNesting};
+        velox::getFunctionSignatures(),
+        0,
+        vectorfuzzer,
+        makeOptionsWithMaxLevelNesting(maxLevelOfNesting),
+    };
 
     for (int i = 0; i < 5000; ++i) {
-      auto expression = fuzzer.generateExpression(randomType(seed));
+      auto expression = fuzzer.fuzzExpression().expressions[0];
       EXPECT_LE(countLevelOfNesting(expression), std::max(1, maxLevelOfNesting))
           << fmt::format(
                  "Expression {} exceeds max level of nesting {} (original {})",
@@ -92,10 +112,14 @@ TEST_F(ExpressionFuzzerUnitTest, reproduceExpressionWithSeed) {
   auto generateExpressions = [&]() {
     std::vector<std::string> firstGeneration;
     std::mt19937 seed{7654321};
-    ExpressionFuzzer fuzzer{velox::getFunctionSignatures(), 1234567, 5};
+    ExpressionFuzzer fuzzer{
+        velox::getFunctionSignatures(),
+        1234567,
+        vectorfuzzer,
+        makeOptionsWithMaxLevelNesting(5)};
     for (auto i = 0; i < 10; ++i) {
       firstGeneration.push_back(
-          fuzzer.generateExpression(randomType(seed))->toString());
+          fuzzer.fuzzExpression().expressions[0]->toString());
     }
     return firstGeneration;
   };
@@ -115,10 +139,13 @@ TEST_F(ExpressionFuzzerUnitTest, exprBank) {
   int32_t maxLevelOfNesting = 10;
   {
     ExpressionFuzzer fuzzer{
-        velox::getFunctionSignatures(), 0, maxLevelOfNesting};
+        velox::getFunctionSignatures(),
+        0,
+        vectorfuzzer,
+        makeOptionsWithMaxLevelNesting(maxLevelOfNesting)};
     ExpressionFuzzer::ExprBank exprBank(seed, maxLevelOfNesting);
     for (int i = 0; i < 5000; ++i) {
-      auto expression = fuzzer.generateExpression(randomType(seed));
+      auto expression = fuzzer.fuzzExpression().expressions[0];
       // Verify that if there is a single expression then it is returned
       // successfully.
       exprBank.insert(expression);
@@ -140,10 +167,13 @@ TEST_F(ExpressionFuzzerUnitTest, exprBank) {
     // Verify that randomly selected expressions do not exceed the requested max
     // nesting level.
     ExpressionFuzzer fuzzer{
-        velox::getFunctionSignatures(), 0, maxLevelOfNesting};
+        velox::getFunctionSignatures(),
+        0,
+        vectorfuzzer,
+        makeOptionsWithMaxLevelNesting(maxLevelOfNesting)};
     ExpressionFuzzer::ExprBank exprBank(seed, maxLevelOfNesting);
     for (int i = 0; i < 1000; ++i) {
-      auto expression = fuzzer.generateExpression(randomType(seed));
+      auto expression = fuzzer.fuzzExpression().expressions[0];
       exprBank.insert(expression);
     }
 
@@ -169,4 +199,4 @@ TEST_F(ExpressionFuzzerUnitTest, exprBank) {
   }
 }
 
-} // namespace facebook::velox::test
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/expression/signature_parser/CMakeLists.txt b/velox/expression/signature_parser/CMakeLists.txt
new file mode 100644
index 0000000000000..0627986c98790
--- /dev/null
+++ b/velox/expression/signature_parser/CMakeLists.txt
@@ -0,0 +1,42 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
+
+bison_target(
+  SignatureParser SignatureParser.yy
+  ${CMAKE_CURRENT_BINARY_DIR}/SignatureParser.yy.cc
+  DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/SignatureParser.yy.h
+  COMPILE_FLAGS "-Werror -Wno-deprecated")
+
+flex_target(
+  SignatureParserScanner SignatureParser.ll
+  ${CMAKE_CURRENT_BINARY_DIR}/Scanner.cpp COMPILE_FLAGS "-Cf --prefix=veloxsp")
+
+add_flex_bison_dependency(SignatureParserScanner SignatureParser)
+
+if(VELOX_MONO_LIBRARY)
+  add_custom_target(
+    velox_signature_gen_src DEPENDS ${BISON_SignatureParser_OUTPUTS}
+                                    ${FLEX_SignatureParserScanner_OUTPUTS})
+  add_dependencies(velox velox_signature_gen_src)
+endif()
+
+include_directories(${PROJECT_BINARY_DIR})
+include_directories(${FLEX_INCLUDE_DIRS})
+velox_add_library(velox_signature_parser ${BISON_SignatureParser_OUTPUTS}
+                  ${FLEX_SignatureParserScanner_OUTPUTS} ParseUtil.cpp)
+velox_link_libraries(velox_signature_parser velox_common_base velox_type)
diff --git a/velox/expression/signature_parser/ParseUtil.cpp b/velox/expression/signature_parser/ParseUtil.cpp
new file mode 100644
index 0000000000000..768e10458e490
--- /dev/null
+++ b/velox/expression/signature_parser/ParseUtil.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/signature_parser/ParseUtil.h"
+#include <string>
+#include "velox/type/Type.h"
+
+namespace facebook::velox::exec {
+
+TypeSignaturePtr inferTypeWithSpaces(
+    const std::vector<std::string>& words,
+    bool canHaveFieldName) {
+  VELOX_CHECK_GE(words.size(), 2);
+  const auto& fieldName = words[0];
+  const auto allWords = folly::join(" ", words);
+  if (hasType(allWords) || !canHaveFieldName) {
+    return std::make_shared<exec::TypeSignature>(
+        exec::TypeSignature(allWords, {}));
+  }
+  return std::make_shared<exec::TypeSignature>(exec::TypeSignature(
+      allWords.data() + fieldName.size() + 1, {}, fieldName));
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/signature_parser/ParseUtil.h b/velox/expression/signature_parser/ParseUtil.h
new file mode 100644
index 0000000000000..7a66e6419ad5e
--- /dev/null
+++ b/velox/expression/signature_parser/ParseUtil.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include "velox/expression/TypeSignature.h"
+
+namespace facebook::velox::exec {
+
+/// Convert words with spaces to a Velox Type Signature.
+/// First check if all the words are a Velox type.
+/// If cannotHaveFieldName = false, check if the first word is a field name and
+/// the remaining words are a Velox type.
+TypeSignaturePtr inferTypeWithSpaces(
+    const std::vector<std::string>& words,
+    bool canHaveFieldName = false);
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/signature_parser/Scanner.h b/velox/expression/signature_parser/Scanner.h
new file mode 100644
index 0000000000000..9733cf079c3e1
--- /dev/null
+++ b/velox/expression/signature_parser/Scanner.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cmath>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/expression/TypeSignature.h"
+
+namespace facebook::velox::exec {
+
+class Scanner : public yyFlexLexer {
+ public:
+  Scanner(
+      std::istream& arg_yyin,
+      std::ostream& arg_yyout,
+      TypeSignaturePtr& outputType,
+      const std::string_view input)
+      : yyFlexLexer(&arg_yyin, &arg_yyout),
+        outputType_(outputType),
+        input_(input) {}
+  int lex(Parser::semantic_type* yylval);
+
+  void setTypeSignature(TypeSignaturePtr type) {
+    outputType_ = std::move(type);
+  }
+
+  // Store input to print it as part of the error message.
+  std::string_view input() {
+    return input_;
+  }
+
+ private:
+  TypeSignaturePtr& outputType_;
+  const std::string_view input_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/signature_parser/SignatureParser.h b/velox/expression/signature_parser/SignatureParser.h
new file mode 100644
index 0000000000000..8b316f6bb042c
--- /dev/null
+++ b/velox/expression/signature_parser/SignatureParser.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include "velox/expression/TypeSignature.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::exec {
+
+/// Parses a string into TypeSignature. The format of the string is type name,
+/// optionally followed by type parameters enclosed in parenthesis.
+///
+/// Examples:
+///     - bigint
+///     - double
+///     - array(T)
+///     - map(K,V)
+///     - row(named bigint,array(tinyint),T)
+///     - function(S,T,R)
+///
+/// Row fields are allowed to be named or anonymous, e.g. "row(foo bigint)" or
+/// "row(bigint)"
+TypeSignature parseTypeSignature(const std::string& signature);
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/signature_parser/SignatureParser.ll b/velox/expression/signature_parser/SignatureParser.ll
new file mode 100644
index 0000000000000..d110631228654
--- /dev/null
+++ b/velox/expression/signature_parser/SignatureParser.ll
@@ -0,0 +1,73 @@
+%{
+#include <vector>
+#include <memory>
+
+#include "velox/expression/signature_parser/SignatureParser.yy.h"  // @manual
+#include "velox/expression/signature_parser/Scanner.h"
+#define YY_DECL int facebook::velox::exec::Scanner::lex(facebook::velox::exec::Parser::semantic_type *yylval)
+%}
+
+%option c++ noyywrap noyylineno nodefault caseless
+
+A   [A|a]
+B   [B|b]
+C   [C|c]
+D   [D|d]
+E   [E|e]
+F   [F|f]
+G   [G|g]
+H   [H|h]
+I   [I|i]
+J   [J|j]
+K   [K|k]
+L   [L|l]
+M   [M|m]
+O   [O|o]
+P   [P|p]
+R   [R|r]
+S   [S|s]
+T   [T|t]
+U   [U|u]
+W   [W|w]
+X   [X|x]
+Y   [Y|y]
+Z   [Z|z]
+
+WORD              ([[:alnum:]_]*)
+QUOTED_ID         (['"'][[:alnum:][:space:]_]*['"'])
+ROW               (ROW|STRUCT)
+
+%%
+
+"("                return Parser::token::LPAREN;
+")"                return Parser::token::RPAREN;
+","                return Parser::token::COMMA;
+(ARRAY)            return Parser::token::ARRAY;
+(MAP)              return Parser::token::MAP;
+(FUNCTION)         return Parser::token::FUNCTION;
+(DECIMAL)          yylval->build<std::string>(YYText()); return Parser::token::DECIMAL;
+{ROW}              return Parser::token::ROW;
+{WORD}             yylval->build<std::string>(YYText()); return Parser::token::WORD;
+{QUOTED_ID}        yylval->build<std::string>(YYText()); return Parser::token::QUOTED_ID;
+<<EOF>>            return Parser::token::YYEOF;
+.               /* no action on unmatched input */
+
+%%
+
+int yyFlexLexer::yylex() {
+    throw std::runtime_error("Bad call to yyFlexLexer::yylex()");
+}
+
+#include "velox/expression/signature_parser/SignatureParser.h"
+
+facebook::velox::exec::TypeSignature facebook::velox::exec::parseTypeSignature(
+    const std::string& signatureText) {
+  std::istringstream is(signatureText);
+  std::ostringstream os;
+  facebook::velox::exec::TypeSignaturePtr signature;
+  facebook::velox::exec::Scanner scanner{is, os, signature, signatureText};
+  facebook::velox::exec::Parser parser{&scanner};
+  parser.parse();
+  VELOX_CHECK(signature, "Failed to parse signature [{}]", signatureText);
+  return std::move(*signature);
+}
diff --git a/velox/expression/signature_parser/SignatureParser.yy b/velox/expression/signature_parser/SignatureParser.yy
new file mode 100644
index 0000000000000..999509f09a06d
--- /dev/null
+++ b/velox/expression/signature_parser/SignatureParser.yy
@@ -0,0 +1,98 @@
+%{
+#include <FlexLexer.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/expression/TypeSignature.h"
+#include "velox/expression/signature_parser/ParseUtil.h"
+%}
+%require "3.0.4"
+%language "C++"
+
+%define parser_class_name {Parser}
+%define api.namespace {facebook::velox::exec}
+%define api.value.type variant
+%parse-param {Scanner* scanner}
+%define parse.error verbose
+
+%code requires
+{
+    namespace facebook::velox::exec {
+        class Scanner;
+        class TypeSignature;
+    } // namespace facebook::velox::exec
+} // %code requires
+
+%code
+{
+    #include <velox/expression/signature_parser/Scanner.h>
+    #define yylex(x) scanner->lex(x)
+}
+
+%token               LPAREN RPAREN COMMA ARRAY MAP ROW FUNCTION
+%token <std::string> WORD VARIABLE QUOTED_ID DECIMAL
+%token YYEOF         0
+
+%nterm <std::shared_ptr<exec::TypeSignature>> special_type function_type decimal_type row_type array_type map_type
+%nterm <std::shared_ptr<exec::TypeSignature>> type named_type
+%nterm <std::vector<exec::TypeSignature>> type_list type_list_opt_names
+%nterm <std::vector<std::string>> type_with_spaces
+
+%%
+
+type_spec : type                 { scanner->setTypeSignature($1); }
+          | type_with_spaces     { scanner->setTypeSignature(inferTypeWithSpaces($1)); }
+          | error                { yyerrok; }
+          ;
+
+type : special_type   { $$ = $1; }
+     | WORD           { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature($1, {})); }
+     ;
+
+special_type : array_type                  { $$ = $1; }
+             | map_type                    { $$ = $1; }
+             | row_type                    { $$ = $1; }
+             | function_type               { $$ = $1; }
+             | decimal_type                { $$ = $1; }
+             ;
+
+named_type : QUOTED_ID type          { $1.erase(0, 1); $1.pop_back(); $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature($2->baseName(), $2->parameters(), $1)); }  // Remove the quotes.
+           | WORD special_type       { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature($2->baseName(), $2->parameters(), $1)); }
+           | type_with_spaces        { $$ = inferTypeWithSpaces($1, true); }
+           ;
+
+type_with_spaces : type_with_spaces WORD { $1.push_back($2); $$ = std::move($1); }
+                 | WORD WORD             { $$.push_back($1); $$.push_back($2); }
+                 ;
+
+decimal_type : DECIMAL LPAREN WORD COMMA WORD RPAREN { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature($1, { exec::TypeSignature($3, {}), exec::TypeSignature($5, {}) })); }
+             ;
+
+type_list : type                   { $$.push_back(*($1)); }
+          | type_list COMMA type   { $1.push_back(*($3)); $$ = std::move($1); }
+          ;
+
+type_list_opt_names : named_type                           { $$.push_back(*($1)); }
+                    | type_list_opt_names COMMA named_type { $1.push_back(*($3)); $$ = std::move($1); }
+                    | type                                 { $$.push_back(*($1)); }
+                    | type_list_opt_names COMMA type       { $1.push_back(*($3)); $$ = std::move($1); }
+                    ;
+
+row_type : ROW LPAREN type_list_opt_names RPAREN  { $$ = std::make_shared<exec::TypeSignature>("row", $3); }
+         ;
+
+array_type : ARRAY LPAREN type RPAREN             { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("array", { *($3) })); }
+           | ARRAY LPAREN type_with_spaces RPAREN { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("array", { *inferTypeWithSpaces($3) })); }
+           ;
+
+map_type : MAP LPAREN type COMMA type RPAREN                         { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("map", {*($3), *($5)})); }
+         | MAP LPAREN type COMMA type_with_spaces RPAREN             { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("map", {*($3), *inferTypeWithSpaces($5)})); }
+         | MAP LPAREN type_with_spaces COMMA type RPAREN             { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("map", {*inferTypeWithSpaces($3), *($5)})); }
+         | MAP LPAREN type_with_spaces COMMA type_with_spaces RPAREN { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("map", {*inferTypeWithSpaces($3), *inferTypeWithSpaces($5)})); }
+         ;
+
+function_type : FUNCTION LPAREN type_list RPAREN { $$ = std::make_shared<exec::TypeSignature>(exec::TypeSignature("function", {$3})); }
+
+%%
+
+void facebook::velox::exec::Parser::error(const std::string& msg) {
+    VELOX_FAIL("Failed to parse type signature [{}]: {}", scanner->input(), msg);
+}
diff --git a/velox/expression/signature_parser/tests/CMakeLists.txt b/velox/expression/signature_parser/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..7d02765ee26b8
--- /dev/null
+++ b/velox/expression/signature_parser/tests/CMakeLists.txt
@@ -0,0 +1,25 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_signature_parser_test ParseTypeSignatureTest.cpp)
+
+add_test(NAME velox_signature_parser_test COMMAND velox_signature_parser_test)
+
+target_link_libraries(
+  velox_signature_parser_test
+  velox_signature_parser
+  velox_type_signature
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock)
diff --git a/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp b/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp
new file mode 100644
index 0000000000000..2f4c3c105c46a
--- /dev/null
+++ b/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include "velox/expression/signature_parser/SignatureParser.h"
+
+using namespace facebook::velox::exec;
+
+namespace facebook::velox {
+namespace {
+
+std::string roundTrip(const std::string& typeSignature) {
+  return parseTypeSignature(typeSignature).toString();
+}
+
+void testScalarType(const std::string& typeSignature) {
+  auto signature = parseTypeSignature(typeSignature);
+  ASSERT_EQ(signature.baseName(), typeSignature);
+  ASSERT_EQ(signature.parameters().size(), 0);
+}
+
+class CustomType : public VarcharType {
+ public:
+  CustomType() = default;
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+};
+
+static const TypePtr& JSON() {
+  static const TypePtr instance{std::make_shared<CustomType>()};
+  return instance;
+}
+
+static const TypePtr& TIMESTAMP_WITH_TIME_ZONE() {
+  static const TypePtr instance{std::make_shared<CustomType>()};
+  return instance;
+}
+
+class TypeFactories : public CustomTypeFactories {
+ public:
+  TypeFactories(const TypePtr& type) : type_(type) {}
+
+  TypePtr getType() const override {
+    return type_;
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+ private:
+  TypePtr type_;
+};
+
+class ParseTypeSignatureTest : public ::testing::Test {
+ private:
+  void SetUp() override {
+    // Register custom types with and without spaces.
+    registerCustomType("json", std::make_unique<const TypeFactories>(JSON()));
+    registerCustomType(
+        "timestamp with time zone",
+        std::make_unique<const TypeFactories>(TIMESTAMP_WITH_TIME_ZONE()));
+  }
+};
+
+TEST_F(ParseTypeSignatureTest, scalar) {
+  testScalarType("tinyint");
+  testScalarType("smallint");
+  testScalarType("integer");
+  testScalarType("bigint");
+  testScalarType("real");
+  testScalarType("double");
+  testScalarType("timestamp");
+}
+
+TEST_F(ParseTypeSignatureTest, decimal) {
+  {
+    auto signature = parseTypeSignature("DECIMAL(a_precision, a_scale)");
+    ASSERT_EQ(signature.baseName(), "DECIMAL");
+    ASSERT_EQ(signature.parameters().size(), 2);
+
+    auto param1 = signature.parameters()[0];
+    ASSERT_EQ(param1.baseName(), "a_precision");
+    ASSERT_EQ(param1.parameters().size(), 0);
+
+    auto param2 = signature.parameters()[1];
+    ASSERT_EQ(param2.baseName(), "a_scale");
+    ASSERT_EQ(param2.parameters().size(), 0);
+  }
+  {
+    auto signature = parseTypeSignature("decimal(38, a_scale)");
+    ASSERT_EQ(signature.baseName(), "decimal");
+    auto param1 = signature.parameters()[0];
+    ASSERT_EQ(param1.baseName(), "38");
+    ASSERT_EQ(param1.parameters().size(), 0);
+
+    auto param2 = signature.parameters()[1];
+    ASSERT_EQ(param2.baseName(), "a_scale");
+    ASSERT_EQ(param2.parameters().size(), 0);
+  }
+}
+
+TEST_F(ParseTypeSignatureTest, array) {
+  {
+    auto signature = parseTypeSignature("array(bigint)");
+    ASSERT_EQ(signature.baseName(), "array");
+    ASSERT_EQ(signature.parameters().size(), 1);
+
+    auto param = signature.parameters()[0];
+    ASSERT_EQ(param.baseName(), "bigint");
+    ASSERT_EQ(param.parameters().size(), 0);
+  }
+  {
+    auto signature = parseTypeSignature("array(timestamp with time zone)");
+    ASSERT_EQ(signature.baseName(), "array");
+    ASSERT_EQ(signature.parameters().size(), 1);
+
+    auto param = signature.parameters()[0];
+    ASSERT_EQ(param.baseName(), "timestamp with time zone");
+    ASSERT_EQ(param.parameters().size(), 0);
+  }
+  {
+    auto signature = parseTypeSignature(
+        "array(row(timestamp timestamp with time zone, decimal(a_scale, 14)))");
+    ASSERT_EQ(signature.baseName(), "array");
+    ASSERT_EQ(signature.parameters().size(), 1);
+
+    auto param = signature.parameters()[0];
+    ASSERT_EQ(param.baseName(), "row");
+    ASSERT_EQ(param.parameters().size(), 2);
+
+    auto field1 = param.parameters()[0];
+    ASSERT_EQ(field1.baseName(), "timestamp with time zone");
+    ASSERT_EQ(field1.rowFieldName(), "timestamp");
+    ASSERT_EQ(field1.parameters().size(), 0);
+
+    auto field2 = param.parameters()[1];
+    ASSERT_EQ(field2.baseName(), "decimal");
+    ASSERT_EQ(field2.parameters().size(), 2);
+
+    auto decimalarg1 = field2.parameters()[0];
+    ASSERT_EQ(decimalarg1.baseName(), "a_scale");
+    ASSERT_EQ(decimalarg1.parameters().size(), 0);
+
+    auto decimalarg2 = field2.parameters()[1];
+    ASSERT_EQ(decimalarg2.baseName(), "14");
+    ASSERT_EQ(decimalarg2.parameters().size(), 0);
+  }
+}
+
+TEST_F(ParseTypeSignatureTest, map) {
+  auto signature = parseTypeSignature("map(interval day to second, double)");
+  ASSERT_EQ(signature.baseName(), "map");
+  ASSERT_EQ(signature.parameters().size(), 2);
+
+  auto key = signature.parameters()[0];
+  ASSERT_EQ(key.baseName(), "interval day to second");
+  ASSERT_EQ(key.parameters().size(), 0);
+
+  auto value = signature.parameters()[1];
+  ASSERT_EQ(value.baseName(), "double");
+  ASSERT_EQ(value.parameters().size(), 0);
+}
+
+TEST_F(ParseTypeSignatureTest, row) {
+  {
+    auto signature = parseTypeSignature("row(v)");
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 1);
+  }
+
+  // test quoted row fields.
+  {
+    auto signature = parseTypeSignature("row(\"12col0\" v, l)");
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 2);
+    ASSERT_FALSE(signature.rowFieldName().has_value());
+    auto field1 = signature.parameters()[0];
+    ASSERT_EQ(field1.baseName(), "v");
+    ASSERT_EQ(field1.rowFieldName(), "12col0");
+    ASSERT_EQ(field1.parameters().size(), 0);
+
+    auto field2 = signature.parameters()[1];
+    ASSERT_EQ(field2.baseName(), "l");
+    ASSERT_EQ(field2.parameters().size(), 0);
+  }
+
+  {
+    auto signature = parseTypeSignature(
+        "row(\"field 0\" array(json), \"field 1\" row(bla varchar))");
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 2);
+    ASSERT_FALSE(signature.rowFieldName().has_value());
+    auto field0 = signature.parameters()[0];
+    ASSERT_EQ(field0.baseName(), "array");
+    ASSERT_EQ(field0.rowFieldName(), "field 0");
+    ASSERT_EQ(field0.parameters().size(), 1);
+    auto arrayElement = field0.parameters()[0];
+    ASSERT_EQ(arrayElement.baseName(), "json");
+
+    auto field1 = signature.parameters()[1];
+    ASSERT_EQ(field1.baseName(), "row");
+    ASSERT_EQ(field1.rowFieldName(), "field 1");
+    ASSERT_EQ(field1.parameters().size(), 1);
+
+    auto rowfield = field1.parameters()[0];
+    ASSERT_EQ(rowfield.baseName(), "varchar");
+    ASSERT_EQ(rowfield.rowFieldName(), "bla");
+    ASSERT_EQ(rowfield.parameters().size(), 0);
+  }
+}
+
+TEST_F(ParseTypeSignatureTest, roundTrip) {
+  ASSERT_EQ(roundTrip("bigint"), "bigint");
+
+  ASSERT_EQ(roundTrip("array(T)"), "array(T)");
+  ASSERT_EQ(roundTrip("array(array(T))"), "array(array(T))");
+  ASSERT_EQ(roundTrip("array(row(K,V))"), "array(row(K,V))");
+
+  ASSERT_EQ(roundTrip("map(K,V)"), "map(K,V)");
+
+  ASSERT_EQ(roundTrip("function(S,R)"), "function(S,R)");
+
+  // Test a complex type as the second field in a row
+  ASSERT_EQ(
+      roundTrip("row(map(K,V),map(bigint,array(double)))"),
+      "row(map(K,V),map(bigint,array(double)))");
+}
+
+TEST_F(ParseTypeSignatureTest, invalidSignatures) {
+  EXPECT_THROW(parseTypeSignature("array(varchar"), VeloxRuntimeError);
+  EXPECT_THROW(parseTypeSignature("array(array(T)"), VeloxRuntimeError);
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/expression/tests/ArgumentTypeFuzzer.cpp b/velox/expression/tests/ArgumentTypeFuzzer.cpp
deleted file mode 100644
index f887079cc2d37..0000000000000
--- a/velox/expression/tests/ArgumentTypeFuzzer.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/expression/tests/ArgumentTypeFuzzer.h"
-
-#include <boost/algorithm/string.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-
-#include "velox/expression/ReverseSignatureBinder.h"
-#include "velox/expression/SignatureBinder.h"
-#include "velox/type/Type.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-
-namespace facebook::velox::test {
-
-std::string typeToBaseName(const TypePtr& type) {
-  return boost::algorithm::to_lower_copy(std::string{type->kindName()});
-}
-
-std::optional<TypeKind> baseNameToTypeKind(const std::string& typeName) {
-  auto kindName = boost::algorithm::to_upper_copy(typeName);
-  return tryMapNameToTypeKind(kindName);
-}
-
-void ArgumentTypeFuzzer::determineUnboundedTypeVariables() {
-  for (auto& [variableName, variableInfo] : variables()) {
-    if (!variableInfo.isTypeParameter()) {
-      continue;
-    }
-
-    if (bindings_[variableName] != nullptr) {
-      continue;
-    }
-
-    // Random randomType() never generates unknown here.
-    // TODO: we should extend randomType types and exclude unknown based
-    // on variableInfo.
-    if (variableInfo.orderableTypesOnly()) {
-      bindings_[variableName] = randOrderableType();
-    } else {
-      bindings_[variableName] = randType();
-    }
-  }
-}
-
-TypePtr ArgumentTypeFuzzer::randType() {
-  return velox::randType(rng_, 2);
-}
-
-TypePtr ArgumentTypeFuzzer::randOrderableType() {
-  return velox::randOrderableType(rng_, 2);
-}
-
-bool ArgumentTypeFuzzer::fuzzArgumentTypes(uint32_t maxVariadicArgs) {
-  const auto& formalArgs = signature_.argumentTypes();
-  auto formalArgsCnt = formalArgs.size();
-
-  if (returnType_) {
-    exec::ReverseSignatureBinder binder{signature_, returnType_};
-    if (!binder.tryBind()) {
-      return false;
-    }
-    bindings_ = binder.bindings();
-  } else {
-    for (const auto& [name, _] : signature_.variables()) {
-      bindings_.insert({name, nullptr});
-    }
-  }
-
-  determineUnboundedTypeVariables();
-  for (auto i = 0; i < formalArgsCnt; i++) {
-    TypePtr actualArg;
-    if (formalArgs[i].baseName() == "any") {
-      actualArg = randType();
-    } else {
-      actualArg = exec::SignatureBinder::tryResolveType(
-          formalArgs[i], variables(), bindings_);
-      VELOX_CHECK(actualArg != nullptr);
-    }
-    argumentTypes_.push_back(actualArg);
-  }
-
-  // Generate random repeats of the last argument type if the signature is
-  // variadic.
-  if (signature_.variableArity()) {
-    auto repeat = boost::random::uniform_int_distribution<uint32_t>(
-        0, maxVariadicArgs)(rng_);
-    auto last = argumentTypes_[formalArgsCnt - 1];
-    for (int i = 0; i < repeat; ++i) {
-      argumentTypes_.push_back(last);
-    }
-  }
-
-  return true;
-}
-
-TypePtr ArgumentTypeFuzzer::fuzzReturnType() {
-  VELOX_CHECK_EQ(
-      returnType_,
-      nullptr,
-      "Only fuzzing uninitialized return type is allowed.");
-
-  determineUnboundedTypeVariables();
-  if (signature_.returnType().baseName() == "any") {
-    returnType_ = randType();
-    return returnType_;
-  } else {
-    returnType_ = exec::SignatureBinder::tryResolveType(
-        signature_.returnType(), variables(), bindings_);
-    VELOX_CHECK_NE(returnType_, nullptr);
-    return returnType_;
-  }
-}
-
-} // namespace facebook::velox::test
diff --git a/velox/expression/tests/ArgumentTypeFuzzer.h b/velox/expression/tests/ArgumentTypeFuzzer.h
deleted file mode 100644
index 540a353221bfd..0000000000000
--- a/velox/expression/tests/ArgumentTypeFuzzer.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <random>
-#include <unordered_map>
-
-#include "velox/expression/FunctionSignature.h"
-#include "velox/expression/SignatureBinder.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::test {
-
-/// For function signatures using type variables, generates a list of
-/// arguments types. Optionally, allows to specify a desired return type. If
-/// specified, the return type acts as a constraint on the possible set of
-/// argument types. If no return type is specified, it also allows generate a
-/// random type that can bind to the function's return type.
-class ArgumentTypeFuzzer {
- public:
-  ArgumentTypeFuzzer(
-      const exec::FunctionSignature& signature,
-      std::mt19937& rng)
-      : ArgumentTypeFuzzer(signature, nullptr, rng) {}
-
-  ArgumentTypeFuzzer(
-      const exec::FunctionSignature& signature,
-      const TypePtr& returnType,
-      std::mt19937& rng)
-      : signature_{signature}, returnType_{returnType}, rng_{rng} {}
-
-  /// Generate random argument types. If the desired returnType has been
-  /// specified, checks that it can be bound to the return type of signature_.
-  /// Return true if the generation succeeds, false otherwise. If signature_ has
-  /// variable arity, repeat the last argument at most maxVariadicArgs times.
-  bool fuzzArgumentTypes(uint32_t maxVariadicArgs);
-
-  /// Return the generated list of argument types. This function should be
-  /// called after fuzzArgumentTypes() is called and returns true.
-  const std::vector<TypePtr>& argumentTypes() const {
-    return argumentTypes_;
-  }
-
-  /// Return a random type that can bind to the function signature's return
-  /// type and set returnType_ to this type. This function can only be called
-  /// when returnType_ is uninitialized.
-  TypePtr fuzzReturnType();
-
- private:
-  /// Return the variables in the signature.
-  auto& variables() const {
-    return signature_.variables();
-  }
-
-  /// Bind each type variable that is not determined by the return type to a
-  /// randomly generated type.
-  void determineUnboundedTypeVariables();
-
-  TypePtr randType();
-
-  /// Generates an orderable random type, including structs, and arrays.
-  TypePtr randOrderableType();
-
-  const exec::FunctionSignature& signature_;
-
-  TypePtr returnType_;
-
-  std::vector<TypePtr> argumentTypes_;
-
-  /// Bindings between type variables and their actual types.
-  std::unordered_map<std::string, TypePtr> bindings_;
-
-  /// RNG to generate random types for unbounded type variables when necessary.
-  std::mt19937& rng_;
-};
-
-/// Return the kind name of type in lower case. This is expected to match the
-/// TypeSignature::baseName_ corresponding to type.
-std::string typeToBaseName(const TypePtr& type);
-
-/// Return the TypeKind that corresponds to typeName.
-std::optional<TypeKind> baseNameToTypeKind(const std::string& typeName);
-
-} // namespace facebook::velox::test
diff --git a/velox/expression/tests/ArgumentTypeFuzzerTest.cpp b/velox/expression/tests/ArgumentTypeFuzzerTest.cpp
deleted file mode 100644
index a5b0b49af26d9..0000000000000
--- a/velox/expression/tests/ArgumentTypeFuzzerTest.cpp
+++ /dev/null
@@ -1,406 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/expression/tests/ArgumentTypeFuzzer.h"
-
-#include <gtest/gtest.h>
-
-#include "velox/expression/SignatureBinder.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::test {
-
-namespace {
-const uint32_t kMaxVariadicArgs = 5;
-} // namespace
-
-class ArgumentTypeFuzzerTest : public testing::Test {
- protected:
-  void testFuzzingSuccess(
-      const std::shared_ptr<exec::FunctionSignature>& signature,
-      const TypePtr& returnType,
-      const std::vector<TypePtr>& expectedArgumentTypes) {
-    std::mt19937 seed{0};
-    ArgumentTypeFuzzer fuzzer{*signature, returnType, seed};
-    ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-
-    auto& argumentTypes = fuzzer.argumentTypes();
-    ASSERT_LE(expectedArgumentTypes.size(), argumentTypes.size());
-
-    auto& argumentSignatures = signature->argumentTypes();
-    int i;
-    for (i = 0; i < expectedArgumentTypes.size(); ++i) {
-      ASSERT_TRUE(expectedArgumentTypes[i]->equivalent(*argumentTypes[i]))
-          << "at " << i
-          << ": Expected: " << expectedArgumentTypes[i]->toString()
-          << ". Got: " << argumentTypes[i]->toString();
-    }
-
-    if (i < argumentTypes.size()) {
-      ASSERT_TRUE(signature->variableArity());
-      ASSERT_LE(
-          argumentTypes.size() - argumentSignatures.size(), kMaxVariadicArgs);
-      for (int j = i; j < argumentTypes.size(); ++j) {
-        ASSERT_TRUE(argumentTypes[j]->equivalent(*argumentTypes[i - 1]));
-      }
-    }
-  }
-
-  void testFuzzingFailure(
-      const std::shared_ptr<exec::FunctionSignature>& signature,
-      const TypePtr& returnType) {
-    std::mt19937 seed{0};
-    ArgumentTypeFuzzer fuzzer{*signature, returnType, seed};
-    ASSERT_FALSE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-  }
-};
-
-TEST_F(ArgumentTypeFuzzerTest, concreteSignature) {
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .returnType("bigint")
-                         .argumentType("varchar")
-                         .argumentType("array(boolean)")
-                         .build();
-
-    testFuzzingSuccess(signature, BIGINT(), {VARCHAR(), ARRAY(BOOLEAN())});
-    testFuzzingFailure(signature, SMALLINT());
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .returnType("array(array(double))")
-                         .argumentType("array(bigint)")
-                         .argumentType("double")
-                         .build();
-
-    testFuzzingSuccess(
-        signature, ARRAY(ARRAY(DOUBLE())), {ARRAY(BIGINT()), DOUBLE()});
-    testFuzzingFailure(signature, ARRAY(ARRAY(REAL())));
-    testFuzzingFailure(signature, ARRAY(DOUBLE()));
-  }
-}
-
-TEST_F(ArgumentTypeFuzzerTest, signatureTemplate) {
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .typeVariable("T")
-                         .returnType("T")
-                         .argumentType("T")
-                         .argumentType("array(T)")
-                         .build();
-
-    testFuzzingSuccess(signature, BIGINT(), {BIGINT(), ARRAY(BIGINT())});
-    testFuzzingSuccess(
-        signature, ARRAY(DOUBLE()), {ARRAY(DOUBLE()), ARRAY(ARRAY(DOUBLE()))});
-    testFuzzingSuccess(
-        signature, ROW({DOUBLE()}), {ROW({DOUBLE()}), ARRAY(ROW({DOUBLE()}))});
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .typeVariable("T")
-                         .returnType("array(T)")
-                         .argumentType("T")
-                         .argumentType("bigint")
-                         .build();
-
-    testFuzzingSuccess(
-        signature, ARRAY(ARRAY(DOUBLE())), {ARRAY(DOUBLE()), BIGINT()});
-    testFuzzingSuccess(signature, ARRAY(VARCHAR()), {VARCHAR(), BIGINT()});
-    testFuzzingFailure(signature, BIGINT());
-    testFuzzingFailure(signature, MAP(VARCHAR(), BIGINT()));
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .knownTypeVariable("K")
-                         .typeVariable("V")
-                         .returnType("K")
-                         .argumentType("array(K)")
-                         .argumentType("array(V)")
-                         .build();
-
-    auto verifyArgumentTypes = [&](const TypePtr& returnType,
-                                   const TypePtr& firstArg) {
-      std::mt19937 seed{0};
-      ArgumentTypeFuzzer fuzzer{*signature, returnType, seed};
-      ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-
-      auto& argumentTypes = fuzzer.argumentTypes();
-      ASSERT_TRUE(argumentTypes[0]->equivalent(*firstArg));
-      // Only check the top-level type because the child type is randomly
-      // generated.
-      ASSERT_TRUE(argumentTypes[1]->isArray());
-    };
-
-    verifyArgumentTypes(DECIMAL(10, 5), ARRAY(DECIMAL(10, 5)));
-    verifyArgumentTypes(ARRAY(DOUBLE()), ARRAY(ARRAY(DOUBLE())));
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .knownTypeVariable("K")
-                         .typeVariable("V")
-                         .returnType("bigint")
-                         .argumentType("array(K)")
-                         .argumentType("array(V)")
-                         .build();
-
-    {
-      std::mt19937 seed{0};
-      ArgumentTypeFuzzer fuzzer{*signature, BIGINT(), seed};
-      ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-
-      auto& argumentTypes = fuzzer.argumentTypes();
-      // Only check the top-level type because the children types are randomly
-      // generated.
-      ASSERT_TRUE(argumentTypes[0]->isArray());
-      ASSERT_TRUE(argumentTypes[1]->isArray());
-    }
-
-    testFuzzingFailure(signature, DOUBLE());
-  }
-}
-
-TEST_F(ArgumentTypeFuzzerTest, variableArity) {
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .typeVariable("X")
-                         .returnType("X")
-                         .argumentType("X")
-                         .argumentType("bigint")
-                         .variableArity()
-                         .build();
-
-    testFuzzingSuccess(signature, VARCHAR(), {VARCHAR(), BIGINT()});
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .knownTypeVariable("K")
-                         .returnType("bigint")
-                         .argumentType("K")
-                         .variableArity()
-                         .build();
-    std::mt19937 seed{0};
-    ArgumentTypeFuzzer fuzzer{*signature, BIGINT(), seed};
-    ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-
-    auto& argumentTypes = fuzzer.argumentTypes();
-    auto& firstArg = argumentTypes[0];
-    for (const auto& argument : argumentTypes) {
-      ASSERT_TRUE(argument->equivalent(*firstArg));
-    }
-  }
-}
-
-TEST_F(ArgumentTypeFuzzerTest, any) {
-  auto signature = exec::FunctionSignatureBuilder()
-                       .returnType("bigint")
-                       .argumentType("any")
-                       .build();
-  std::mt19937 seed{0};
-  ArgumentTypeFuzzer fuzzer{*signature, BIGINT(), seed};
-  ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-
-  auto& argumentTypes = fuzzer.argumentTypes();
-  ASSERT_EQ(argumentTypes.size(), 1);
-  ASSERT_TRUE(argumentTypes[0] != nullptr);
-}
-
-TEST_F(ArgumentTypeFuzzerTest, unsupported) {
-  // Constraints on the return type is not supported.
-  auto signature =
-      exec::FunctionSignatureBuilder()
-          .integerVariable("a_scale")
-          .integerVariable("b_scale")
-          .integerVariable("a_precision")
-          .integerVariable("b_precision")
-          .integerVariable(
-              "r_precision",
-              "min(38, max(a_precision - a_scale, b_precision - b_scale) + max(a_scale, b_scale) + 1)")
-          .integerVariable("r_scale", "max(a_scale, b_scale)")
-          .returnType("row(array(decimal(r_precision, r_scale)))")
-          .argumentType("decimal(a_precision, a_scale)")
-          .argumentType("decimal(b_precision, b_scale)")
-          .build();
-
-  testFuzzingFailure(signature, DECIMAL(13, 6));
-}
-
-TEST_F(ArgumentTypeFuzzerTest, lambda) {
-  // array(T), function(T, boolean) -> array(T)
-  auto signature = exec::FunctionSignatureBuilder()
-                       .typeVariable("T")
-                       .returnType("array(T)")
-                       .argumentType("array(T)")
-                       .argumentType("function(T,boolean)")
-                       .build();
-
-  testFuzzingSuccess(
-      signature,
-      ARRAY(BIGINT()),
-      {ARRAY(BIGINT()), FUNCTION(std::vector<TypePtr>{BIGINT()}, BOOLEAN())});
-
-  // array(T), function(T, U) -> array(U)
-  signature = exec::FunctionSignatureBuilder()
-                  .typeVariable("T")
-                  .typeVariable("U")
-                  .returnType("array(U)")
-                  .argumentType("array(T)")
-                  .argumentType("function(T,U)")
-                  .build();
-
-  {
-    std::mt19937 seed{0};
-    ArgumentTypeFuzzer fuzzer{*signature, ARRAY(VARCHAR()), seed};
-    ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-
-    const auto& argumentTypes = fuzzer.argumentTypes();
-    ASSERT_TRUE(argumentTypes[0]->isArray());
-
-    // T is chosen randomly.
-    auto randomType = argumentTypes[0]->asArray().elementType();
-    ASSERT_EQ(*argumentTypes[1], *FUNCTION({randomType}, VARCHAR()));
-  }
-
-  // map(K, V1), function(K, V1, V2) -> map(K, V2)
-  signature = exec::FunctionSignatureBuilder()
-                  .knownTypeVariable("K")
-                  .typeVariable("V1")
-                  .typeVariable("V2")
-                  .returnType("map(K,V2)")
-                  .argumentType("map(K,V1)")
-                  .argumentType("function(K,V1,V2)")
-                  .build();
-
-  {
-    std::mt19937 seed{0};
-    ArgumentTypeFuzzer fuzzer{*signature, MAP(BIGINT(), VARCHAR()), seed};
-    ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-
-    const auto& argumentTypes = fuzzer.argumentTypes();
-    ASSERT_TRUE(argumentTypes[0]->isMap());
-    ASSERT_TRUE(argumentTypes[0]->asMap().keyType()->isBigint());
-
-    // V1 is chosen randomly.
-    auto randomType = argumentTypes[0]->asMap().valueType();
-    ASSERT_EQ(*argumentTypes[1], *FUNCTION({BIGINT(), randomType}, VARCHAR()));
-  }
-}
-
-TEST_F(ArgumentTypeFuzzerTest, unconstrainedSignatureTemplate) {
-  auto signature = exec::FunctionSignatureBuilder()
-                       .knownTypeVariable("K")
-                       .typeVariable("V")
-                       .returnType("V")
-                       .argumentType("map(K,V)")
-                       .argumentType("K")
-                       .build();
-
-  std::mt19937 seed{0};
-  ArgumentTypeFuzzer fuzzer{*signature, MAP(BIGINT(), VARCHAR()), seed};
-  ASSERT_TRUE(fuzzer.fuzzArgumentTypes(kMaxVariadicArgs));
-
-  const auto& argumentTypes = fuzzer.argumentTypes();
-  ASSERT_EQ(2, argumentTypes.size());
-  ASSERT_TRUE(argumentTypes[0] != nullptr);
-  ASSERT_TRUE(argumentTypes[1] != nullptr);
-
-  ASSERT_EQ(argumentTypes[0]->kind(), TypeKind::MAP);
-
-  ASSERT_EQ(argumentTypes[0]->childAt(0), argumentTypes[1]);
-}
-
-TEST_F(ArgumentTypeFuzzerTest, orderableConstraint) {
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .orderableTypeVariable("T")
-                         .returnType("bigint")
-                         .argumentType("T")
-                         .build();
-
-    for (size_t i = 0; i < 100; ++i) {
-      std::mt19937 rng(i);
-      ArgumentTypeFuzzer fuzzer{*signature, nullptr, rng};
-      fuzzer.fuzzArgumentTypes(kMaxVariadicArgs);
-      ASSERT_TRUE(fuzzer.argumentTypes()[0]->isOrderable())
-          << fuzzer.argumentTypes()[0]->toString();
-    }
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .orderableTypeVariable("T")
-                         .returnType("T")
-                         .argumentType("T")
-                         .build();
-    testFuzzingFailure(signature, MAP(VARCHAR(), BIGINT()));
-    testFuzzingFailure(signature, ARRAY(MAP(VARCHAR(), BIGINT())));
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .orderableTypeVariable("T")
-                         .returnType("array(T)")
-                         .argumentType("array(T)")
-                         .build();
-
-    testFuzzingSuccess(signature, ARRAY(DOUBLE()), {ARRAY(DOUBLE())});
-    testFuzzingSuccess(
-        signature, ARRAY(ROW({DOUBLE()})), {ARRAY(ROW({DOUBLE()}))});
-    testFuzzingFailure(signature, MAP(VARCHAR(), BIGINT()));
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .typeVariable("T")
-                         .orderableTypeVariable("U")
-                         .returnType("row(T, U)")
-                         .argumentType("T")
-                         .argumentType("row(T,U)")
-                         .build();
-
-    testFuzzingSuccess(
-        signature,
-        ROW({MAP(BIGINT(), BIGINT()), BIGINT()}),
-        {MAP(BIGINT(), BIGINT()), ROW({MAP(BIGINT(), BIGINT()), BIGINT()})});
-
-    testFuzzingFailure(signature, ROW({BIGINT(), MAP(VARCHAR(), BIGINT())}));
-  }
-
-  {
-    auto signature = exec::FunctionSignatureBuilder()
-                         .typeVariable("T")
-                         .orderableTypeVariable("U")
-                         .returnType("row(T,U)")
-                         .argumentType("T")
-                         .argumentType("function(T,U)")
-                         .build();
-
-    testFuzzingSuccess(
-        signature,
-        ROW({MAP(BIGINT(), BIGINT()), BIGINT()}),
-        {MAP(BIGINT(), BIGINT()),
-         std::make_shared<FunctionType>(
-             std::vector<TypePtr>{MAP(BIGINT(), BIGINT())}, BIGINT())});
-
-    testFuzzingFailure(signature, ROW({BIGINT(), MAP(VARCHAR(), BIGINT())}));
-  }
-}
-
-} // namespace facebook::velox::test
diff --git a/velox/expression/tests/ArrayViewTest.cpp b/velox/expression/tests/ArrayViewTest.cpp
index 37d2529ccba98..27e6e9781d946 100644
--- a/velox/expression/tests/ArrayViewTest.cpp
+++ b/velox/expression/tests/ArrayViewTest.cpp
@@ -575,6 +575,7 @@ TEST_F(NullableArrayViewTest, materializeArrayOfCustomTypes) {
           MaterializeType<Array<UDTTypeRegistrar::SimpleType>>::nullable_t,
           std::vector<std::optional<UDT>>>);
   UDTTypeRegistrar::registerType();
+  auto guard = folly::makeGuard([&] { UDTTypeRegistrar::unregisterType(); });
   registerFunction<MakeUDTFunc, UDTTypeRegistrar::SimpleType>({"make_udt"});
 
   auto result = evaluate(
@@ -597,6 +598,7 @@ TEST_F(NullFreeArrayViewTest, materializeArrayOfCustomTypes) {
           MaterializeType<Array<UDTTypeRegistrar::SimpleType>>::null_free_t,
           std::vector<UDT>>);
   UDTTypeRegistrar::registerType();
+  auto guard = folly::makeGuard([&] { UDTTypeRegistrar::unregisterType(); });
   registerFunction<MakeUDTFunc, UDTTypeRegistrar::SimpleType>({"make_udt"});
 
   auto result = evaluate(
diff --git a/velox/expression/tests/ArrayWriterTest.cpp b/velox/expression/tests/ArrayWriterTest.cpp
index 28ba55debf260..7398a9d6da536 100644
--- a/velox/expression/tests/ArrayWriterTest.cpp
+++ b/velox/expression/tests/ArrayWriterTest.cpp
@@ -316,12 +316,16 @@ TEST_F(ArrayWriterTest, testVarChar) {
         stringWriter,
         "test a long string, a bit longer than that, longer, and longer");
   }
+
+  arrayWriter.push_back("new_feature"_sv);
+
   vectorWriter.commit();
   auto expected = std::vector<std::vector<std::optional<StringView>>>{
       {"hi"_sv,
        std::nullopt,
        "welcome"_sv,
-       "test a long string, a bit longer than that, longer, and longer"_sv}};
+       "test a long string, a bit longer than that, longer, and longer"_sv,
+       "new_feature"_sv}};
   assertEqualVectors(result, makeNullableArrayVector(expected));
 }
 
@@ -769,6 +773,50 @@ TEST_F(ArrayWriterTest, addItems) {
   }
 }
 
+TEST_F(ArrayWriterTest, addItemsString) {
+  std::string string1 =
+      "*************************************not-inlined-string*********************************************1";
+  std::string string2 =
+      "*************************************not-inlined-string*********************************************2";
+
+  auto inputVector = makeArrayVector<std::string>(
+      {{string1, string2}, {string1, string1}, {string2, string2}});
+  DecodedVector decoded;
+  decoded.decode(*inputVector, 1);
+  exec::VectorReader<Array<Varchar>> inputReader(&decoded);
+
+  auto result = prepareResult(CppToType<Array<Varchar>>::create());
+  exec::VectorWriter<Array<Varchar>> writer;
+  writer.init(*result->as<ArrayVector>());
+  writer.setOffset(0);
+  auto& arrayWriter = writer.current();
+
+  arrayWriter.add_items(inputReader[0]);
+  arrayWriter.add_items(inputReader[1]);
+  arrayWriter.add_items(inputReader[2]);
+  arrayWriter.add_items(inputReader[0]);
+  writer.commit();
+  writer.finish();
+
+  auto expected = makeArrayVector<std::string>(
+      {{string1,
+        string2,
+        string1,
+        string1,
+        string2,
+        string2,
+        string1,
+        string2}});
+  assertEqualVectors(result, expected);
+
+  // Make sure that buffers are reused.
+  auto flatOutElements =
+      result->as<ArrayVector>()->elements()->asFlatVector<StringView>();
+  auto flatInElements =
+      inputVector->as<ArrayVector>()->elements()->asFlatVector<StringView>();
+  ASSERT_EQ(flatOutElements->stringBuffers(), flatInElements->stringBuffers());
+}
+
 // Make sure nested vectors are resized to actual size after writing.
 TEST_F(ArrayWriterTest, finishPostSize) {
   using out_t = Array<Array<int32_t>>;
@@ -809,7 +857,6 @@ TEST_F(ArrayWriterTest, nestedArrayWriteThenCommitNull) {
     auto& nestedArray = current.add_item();
     nestedArray.push_back(1);
     nestedArray.push_back(2);
-
     writer.commitNull();
   }
 
@@ -926,6 +973,7 @@ using UDT2TypeRegistrar = OpaqueCustomTypeRegister<UDT2, kName>;
 
 TEST_F(ArrayWriterTest, copyFromArrayOfOpaqueUDT) {
   UDT2TypeRegistrar::registerType();
+  auto guard = folly::makeGuard([&] { UDT2TypeRegistrar::unregisterType(); });
 
   using out_t = Array<UDT2TypeRegistrar::SimpleType>;
 
@@ -973,6 +1021,7 @@ struct CopyFromArrayOfUDTFunc {
 
 TEST_F(ArrayWriterTest, copyFromNestedArrayOfOpaqueUDT) {
   UDT2TypeRegistrar::registerType();
+  auto guard = folly::makeGuard([&] { UDT2TypeRegistrar::unregisterType(); });
   registerFunction<CopyFromArrayOfUDTFunc, copy_from_udt_t>(
       {"copy_udt2_array"});
 
@@ -1014,5 +1063,43 @@ TEST_F(ArrayWriterTest, copyFromNestedArrayOfOpaqueUDT) {
   }
 }
 
+// Throws an error if n is even, otherwise creates a 3x3 array filled with n.
+template <typename T>
+struct ThrowsErrorsFunc {
+  template <typename TOut>
+  void call(TOut& out, const int64_t& n) {
+    for (auto i = 0; i < 3; i++) {
+      auto& innerArray = out.add_item();
+      for (auto j = 0; j < 3; j++) {
+        // If commit isn't called as part of error handling, the first inner
+        // array in odd number rows will pick up the elements from the last
+        // inner array of the previous row.
+        innerArray.push_back(n);
+      }
+    }
+
+    VELOX_USER_CHECK_EQ(n % 2, 1);
+  }
+};
+
+TEST_F(ArrayWriterTest, errorHandlingE2E) {
+  registerFunction<ThrowsErrorsFunc, Array<Array<int64_t>>, int64_t>(
+      {"throws_errors"});
+
+  auto result = evaluate(
+      "try(throws_errors(c0))",
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6})}));
+
+  assertEqualVectors(
+      result,
+      makeNestedArrayVectorFromJson<int64_t>(
+          {"[[1, 1, 1], [1, 1, 1], [1, 1, 1]]",
+           "null",
+           "[[3, 3, 3], [3, 3, 3], [3, 3, 3]]",
+           "null",
+           "[[5, 5, 5], [5, 5, 5], [5, 5, 5]]",
+           "null"}));
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/expression/tests/CMakeLists.txt b/velox/expression/tests/CMakeLists.txt
index 7d2c68de03d4a..6692adf6d242a 100644
--- a/velox/expression/tests/CMakeLists.txt
+++ b/velox/expression/tests/CMakeLists.txt
@@ -12,48 +12,42 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_expression_test_utility ArgumentTypeFuzzer.cpp
-                                          FuzzerToolkit.cpp)
-
-target_link_libraries(velox_expression_test_utility velox_type
-                      velox_expression_functions gtest)
-
 add_executable(
   velox_expression_test
-  ArgumentTypeFuzzerTest.cpp
+  ArrayViewTest.cpp
+  ArrayWriterTest.cpp
+  CastExprTest.cpp
+  CoalesceTest.cpp
+  ConjunctTest.cpp
+  ConstantFlatVectorReaderTest.cpp
   CustomTypeTest.cpp
+  ExprCompilerTest.cpp
   ExprEncodingsTest.cpp
+  ExprStatsTest.cpp
   ExprTest.cpp
   ExprToSubfieldFilterTest.cpp
-  ExprCompilerTest.cpp
   EvalCtxTest.cpp
-  ExprStatsTest.cpp
-  CastExprTest.cpp
-  CoalesceTest.cpp
-  ConstantFlatVectorReaderTest.cpp
+  EvalErrorsTest.cpp
+  EvalSimplifiedTest.cpp
+  FunctionCallToSpecialFormTest.cpp
+  GenericViewTest.cpp
+  GenericWriterTest.cpp
+  Main.cpp
+  MapViewTest.cpp
   MapWriterTest.cpp
-  ArrayWriterTest.cpp
+  PeeledEncodingTest.cpp
   ReverseSignatureBinderTest.cpp
+  RowViewTest.cpp
   RowWriterTest.cpp
-  EvalSimplifiedTest.cpp
-  FunctionCallToSpecialFormTest.cpp
   SignatureBinderTest.cpp
-  SimpleFunctionTest.cpp
-  SimpleFunctionInitTest.cpp
   SimpleFunctionCallNullFreeTest.cpp
+  SimpleFunctionInitTest.cpp
   SimpleFunctionPresetNullsTest.cpp
-  ArrayViewTest.cpp
-  StringWriterTest.cpp
-  ArrayWriterTest.cpp
+  SimpleFunctionTest.cpp
   StringWriterTest.cpp
-  MapViewTest.cpp
-  RowViewTest.cpp
-  GenericViewTest.cpp
   TryExprTest.cpp
   VariadicViewTest.cpp
-  VectorReaderTest.cpp
-  GenericWriterTest.cpp
-  PeeledEncodingTest.cpp)
+  VectorReaderTest.cpp)
 
 add_test(
   NAME velox_expression_test
@@ -77,9 +71,9 @@ target_link_libraries(
   velox_presto_serializer
   velox_vector_test_lib
   velox_vector_fuzzer
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   Folly::folly
   gflags::gflags
   glog::glog
@@ -88,39 +82,29 @@ target_link_libraries(
 add_library(velox_expression_verifier ExpressionVerifier.cpp)
 
 target_link_libraries(
-  velox_expression_verifier velox_vector_test_lib velox_vector_fuzzer
-  velox_type velox_expression_test_utility)
-
-add_library(velox_expression_fuzzer ExpressionFuzzer.cpp FuzzerRunner.cpp)
-
-target_link_libraries(
-  velox_expression_fuzzer
   velox_expression_verifier
-  velox_type
-  velox_vector_fuzzer
   velox_vector_test_lib
-  velox_function_registry
+  velox_vector_fuzzer
+  velox_type
   velox_expression_test_utility)
 
-add_executable(velox_expression_fuzzer_unit_test ExpressionFuzzerUnitTest.cpp)
-
+add_library(velox_expression_runner ExpressionRunner.cpp)
 target_link_libraries(
-  velox_expression_fuzzer_unit_test
-  velox_expression_fuzzer
+  velox_expression_runner
+  velox_expression_verifier
   velox_functions_prestosql
-  velox_core
-  velox_expression
-  gtest
-  gtest_main)
-
-add_library(velox_expression_runner ExpressionRunner.cpp)
-target_link_libraries(velox_expression_runner velox_expression_verifier
-                      velox_functions_prestosql velox_parse_parser gtest)
+  velox_functions_spark
+  velox_parse_parser
+  GTest::gtest)
 
 add_executable(velox_expression_runner_test ExpressionRunnerTest.cpp)
 target_link_libraries(
-  velox_expression_runner_test velox_expression_runner velox_exec_test_lib
-  velox_function_registry gtest gtest_main)
+  velox_expression_runner_test
+  velox_expression_runner
+  velox_exec_test_lib
+  velox_function_registry
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(velox_expression_verifier_unit_test
                ExpressionVerifierUnitTest.cpp)
@@ -134,8 +118,8 @@ target_link_libraries(
   velox_parse_utils
   velox_type
   velox_vector_test_lib
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
 
 add_executable(velox_expression_runner_unit_test ExpressionRunnerUnitTest.cpp)
 target_link_libraries(
@@ -149,15 +133,5 @@ target_link_libraries(
   velox_temp_path
   velox_exec_test_lib
   velox_vector_test_lib
-  gtest
-  gtest_main)
-
-add_executable(velox_expression_fuzzer_test ExpressionFuzzerTest.cpp)
-
-target_link_libraries(velox_expression_fuzzer_test velox_expression_fuzzer
-                      velox_functions_prestosql gtest gtest_main)
-
-add_executable(spark_expression_fuzzer_test SparkExpressionFuzzerTest.cpp)
-
-target_link_libraries(spark_expression_fuzzer_test velox_expression_fuzzer
-                      velox_functions_spark gtest gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/expression/tests/CastExprTest.cpp b/velox/expression/tests/CastExprTest.cpp
index 56d3d77ee888c..67317cc1758e6 100644
--- a/velox/expression/tests/CastExprTest.cpp
+++ b/velox/expression/tests/CastExprTest.cpp
@@ -20,6 +20,8 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/tests/CastBaseTest.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/Type.h"
@@ -29,52 +31,25 @@
 using namespace facebook::velox;
 namespace facebook::velox::test {
 namespace {
-
-constexpr float kInf = std::numeric_limits<float>::infinity();
-constexpr float kNan = std::numeric_limits<float>::quiet_NaN();
-
-namespace {
-auto createCopy(const VectorPtr& input) {
-  VectorPtr result;
-  SelectivityVector rows(input->size());
-  BaseVector::ensureWritable(rows, input->type(), input->pool(), result);
-  result->copy(input.get(), rows, nullptr);
-  return result;
-}
-} // namespace
+template <typename TExecParams>
+struct ErrorOnOddFunctionElseUnknown {
+  VELOX_DEFINE_FUNCTION_TYPES(TExecParams);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<UnknownValue> /*out*/,
+      const int32_t input) {
+    // Function will always throw an error on odd input.
+    if (input % 2 != 0) {
+      VELOX_USER_FAIL("ErrorOnOddElseUnknown Function: {}", input);
+    }
+  }
+};
 
 class CastExprTest : public functions::test::CastBaseTest {
  protected:
   CastExprTest() {
-    exec::registerVectorFunction(
-        "testing_dictionary",
-        TestingDictionaryFunction::signatures(),
-        std::make_unique<TestingDictionaryFunction>());
-  }
-
-  void setCastIntByTruncate(bool value) {
-    queryCtx_->testingOverrideConfigUnsafe({
-        {core::QueryConfig::kCastToIntByTruncate, std::to_string(value)},
-    });
-  }
-
-  void setCastMatchStructByName(bool value) {
-    queryCtx_->testingOverrideConfigUnsafe({
-        {core::QueryConfig::kCastMatchStructByName, std::to_string(value)},
-    });
-  }
-
-  void setTimezone(const std::string& value) {
-    queryCtx_->testingOverrideConfigUnsafe({
-        {core::QueryConfig::kSessionTimezone, value},
-        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
-    });
-  }
-
-  void setCastStringToDateIsIso8601(bool value) {
-    queryCtx_->testingOverrideConfigUnsafe({
-        {core::QueryConfig::kCastStringToDateIsIso8601, std::to_string(value)},
-    });
+    registerFunction<ErrorOnOddFunctionElseUnknown, UnknownValue, int32_t>(
+        {"error_on_odd_else_unknown"});
   }
 
   std::shared_ptr<core::ConstantTypedExpr> makeConstantNullExpr(TypeKind kind) {
@@ -82,128 +57,6 @@ class CastExprTest : public functions::test::CastBaseTest {
         createType(kind, {}), variant(kind));
   }
 
-  std::shared_ptr<core::CastTypedExpr> makeCastExpr(
-      const core::TypedExprPtr& input,
-      const TypePtr& toType,
-      bool nullOnFailure) {
-    std::vector<core::TypedExprPtr> inputs = {input};
-    return std::make_shared<core::CastTypedExpr>(toType, inputs, nullOnFailure);
-  }
-
-  void testComplexCast(
-      const std::string& fromExpression,
-      const VectorPtr& data,
-      const VectorPtr& expected,
-      bool nullOnFailure = false) {
-    auto rowVector = makeRowVector({data});
-    auto rowType = asRowType(rowVector->type());
-    auto castExpr = makeCastExpr(
-        makeTypedExpr(fromExpression, rowType),
-        expected->type(),
-        nullOnFailure);
-    exec::ExprSet exprSet({castExpr}, &execCtx_);
-    auto copy = createCopy(data);
-    const auto size = data->size();
-    SelectivityVector rows(size);
-    std::vector<VectorPtr> result(1);
-    {
-      exec::EvalCtx evalCtx(&execCtx_, &exprSet, rowVector.get());
-      exprSet.eval(rows, evalCtx, result);
-
-      assertEqualVectors(expected, result[0]);
-
-      // Make sure the input vector does not change.
-      assertEqualVectors(data, copy);
-    }
-
-    // Test constant input.
-    {
-      // Use last element for constant.
-      const auto index = size - 1;
-      auto constantData = BaseVector::wrapInConstant(size, index, data);
-      auto constantRow = makeRowVector({constantData});
-      auto localCopy = createCopy(constantRow);
-      exec::EvalCtx evalCtx(&execCtx_, &exprSet, constantRow.get());
-      exprSet.eval(rows, evalCtx, result);
-
-      // Make sure the input vector does not change.
-      assertEqualVectors(constantRow, localCopy);
-      assertEqualVectors(data, copy);
-
-      assertEqualVectors(
-          BaseVector::wrapInConstant(size, index, expected), result[0]);
-    }
-
-    // Test dictionary input. It is not sufficient to wrap input in a dictionary
-    // as it will be peeled off before calling "cast". Apply
-    // testing_dictionary function to input to ensure that "cast" receives
-    // dictionary input.
-    {
-      auto dictionaryCastExpr = makeCastExpr(
-          makeTypedExpr(
-              fmt::format("testing_dictionary({})", fromExpression), rowType),
-          expected->type(),
-          nullOnFailure);
-      exec::ExprSet dictionaryExprSet({dictionaryCastExpr}, &execCtx_);
-      exec::EvalCtx evalCtx(&execCtx_, &dictionaryExprSet, rowVector.get());
-      dictionaryExprSet.eval(rows, evalCtx, result);
-
-      // Make sure the input vector does not change.
-      assertEqualVectors(data, copy);
-
-      auto indices = functions::test::makeIndicesInReverse(size, pool());
-      assertEqualVectors(wrapInDictionary(indices, size, expected), result[0]);
-    }
-  }
-
-  /**
-   * @tparam From Source type for cast
-   * @tparam To Destination type for cast
-   * @param typeString Cast type in string
-   * @param input Input vector of type From
-   * @param expectedResult Expected output vector of type To
-   * @param inputNulls Input null indexes
-   * @param expectedNulls Expected output null indexes
-   */
-  template <typename TFrom, typename TTo>
-  void testCast(
-      const std::string& typeString,
-      std::vector<std::optional<TFrom>> input,
-      std::vector<std::optional<TTo>> expectedResult,
-      bool expectFailure = false,
-      bool tryCast = false,
-      const TypePtr& fromType = CppToType<TFrom>::create(),
-      const TypePtr& toType = CppToType<TTo>::create()) {
-    std::vector<TFrom> rawInput(input.size());
-    for (auto index = 0; index < input.size(); index++) {
-      if (input[index].has_value()) {
-        rawInput[index] = input[index].value();
-      }
-    }
-    // Create input vector using values and nulls
-    auto inputVector = makeFlatVector(rawInput, fromType);
-
-    for (auto index = 0; index < input.size(); index++) {
-      if (!input[index].has_value()) {
-        inputVector->setNull(index, true);
-      }
-    }
-    auto rowVector = makeRowVector({inputVector});
-    std::string castFunction = tryCast ? "try_cast" : "cast";
-    if (expectFailure) {
-      EXPECT_THROW(
-          evaluate(
-              fmt::format("{}(c0 as {})", castFunction, typeString), rowVector),
-          VeloxUserError);
-      return;
-    }
-    // run try cast and get the result vector
-    auto result =
-        evaluate(castFunction + "(c0 as " + typeString + ")", rowVector);
-    auto expected = makeNullableFlatVector<TTo>(expectedResult, toType);
-    assertEqualVectors(expected, result);
-  }
-
   template <typename T>
   void testDecimalToFloatCasts() {
     // short to short, scale up.
@@ -217,8 +70,7 @@ class CastExprTest : public functions::test::CastBaseTest {
          DecimalUtil::kShortDecimalMax,
          std::nullopt},
         DECIMAL(18, 18));
-    testComplexCast(
-        "c0",
+    testCast(
         shortFlat,
         makeNullableFlatVector<T>(
             {-1,
@@ -241,8 +93,7 @@ class CastExprTest : public functions::test::CastBaseTest {
          HugeInt::build(0xffff, 0xffffffffffffffff),
          std::nullopt},
         DECIMAL(38, 5));
-    testComplexCast(
-        "c0",
+    testCast(
         longFlat,
         makeNullableFlatVector<T>(
             {-1e33, 0, 1e33, 1.2089258196146293E19, std::nullopt}));
@@ -258,8 +109,7 @@ class CastExprTest : public functions::test::CastBaseTest {
         static_cast<int64_t>(std::numeric_limits<int32_t>::max()) + 1;
 
     VELOX_ASSERT_THROW(
-        testComplexCast(
-            "c0",
+        testCast(
             makeFlatVector<int64_t>({0, tooSmall}, DECIMAL(10, 0)),
             makeFlatVector<NativeType>(0, 0)),
         fmt::format(
@@ -267,8 +117,7 @@ class CastExprTest : public functions::test::CastBaseTest {
             TypeTraits<KIND>::name));
 
     VELOX_ASSERT_THROW(
-        testComplexCast(
-            "c0",
+        testCast(
             makeFlatVector<int128_t>({0, tooSmall}, DECIMAL(19, 0)),
             makeFlatVector<NativeType>(0, 0)),
         fmt::format(
@@ -276,8 +125,7 @@ class CastExprTest : public functions::test::CastBaseTest {
             TypeTraits<KIND>::name));
 
     VELOX_ASSERT_THROW(
-        testComplexCast(
-            "c0",
+        testCast(
             makeFlatVector<int64_t>({0, tooBig}, DECIMAL(10, 0)),
             makeFlatVector<NativeType>(0, 0)),
         fmt::format(
@@ -285,8 +133,7 @@ class CastExprTest : public functions::test::CastBaseTest {
             TypeTraits<KIND>::name));
 
     VELOX_ASSERT_THROW(
-        testComplexCast(
-            "c0",
+        testCast(
             makeFlatVector<int128_t>({0, tooBig}, DECIMAL(19, 0)),
             makeFlatVector<NativeType>(0, 0)),
         fmt::format(
@@ -303,16 +150,14 @@ class CastExprTest : public functions::test::CastBaseTest {
     const auto tooBig =
         static_cast<int64_t>(std::numeric_limits<int32_t>::max()) + 1;
 
-    testComplexCast(
-        "c0",
+    testCast(
         makeNullableFlatVector<int64_t>(
             {0, tooSmall, 0, tooBig, 0, std::nullopt, 0}, DECIMAL(10, 0)),
         makeNullableFlatVector<NativeType>(
             {0, std::nullopt, 0, std::nullopt, 0, std::nullopt, 0}),
         true);
 
-    testComplexCast(
-        "c0",
+    testCast(
         makeNullableFlatVector<int128_t>(
             {0, tooSmall, 0, tooBig, 0, std::nullopt, 0}, DECIMAL(19, 0)),
         makeNullableFlatVector<NativeType>(
@@ -322,7 +167,6 @@ class CastExprTest : public functions::test::CastBaseTest {
 
   template <typename T>
   void testDecimalToIntegralCasts() {
-    setCastIntByTruncate(false);
     auto shortFlat = makeNullableFlatVector<int64_t>(
         {-300,
          -260,
@@ -337,8 +181,7 @@ class CastExprTest : public functions::test::CastBaseTest {
          7200,
          std::nullopt},
         DECIMAL(6, 2));
-    testComplexCast(
-        "c0",
+    testCast(
         shortFlat,
         makeNullableFlatVector<T>(
             {-3,
@@ -367,8 +210,7 @@ class CastExprTest : public functions::test::CastBaseTest {
          720'000'000'000,
          std::nullopt},
         DECIMAL(20, 10));
-    testComplexCast(
-        "c0",
+    testCast(
         longFlat,
         makeNullableFlatVector<T>(
             {-3,
@@ -383,56 +225,19 @@ class CastExprTest : public functions::test::CastBaseTest {
              69,
              72,
              std::nullopt}));
-
-    setCastIntByTruncate(true);
-    testComplexCast(
-        "c0",
-        shortFlat,
-        makeNullableFlatVector<T>(
-            {-3,
-             -2 /*-2.6 truncated to -2*/,
-             -2 /*-2.3 truncated to -2*/,
-             -2,
-             -1,
-             0,
-             55,
-             57 /*57.49 truncated to 57*/,
-             57 /*57.55 truncated to 57*/,
-             69,
-             72,
-             std::nullopt}));
-
-    testComplexCast(
-        "c0",
-        longFlat,
-        makeNullableFlatVector<T>(
-            {-3,
-             -2 /*-2.55 truncated to -2*/,
-             -2 /*-2.45 truncated to -2*/,
-             -2,
-             -1,
-             0,
-             55,
-             55 /* 55.49 truncated to 55*/,
-             55 /* 55.99 truncated to 55*/,
-             69,
-             72,
-             std::nullopt}));
   }
 
   template <typename T>
   void testIntToDecimalCasts() {
     // integer to short decimal
     auto input = makeFlatVector<T>({-3, -2, -1, 0, 55, 69, 72});
-    testComplexCast(
-        "c0",
+    testCast(
         input,
         makeFlatVector<int64_t>(
             {-300, -200, -100, 0, 5'500, 6'900, 7'200}, DECIMAL(6, 2)));
 
     // integer to long decimal
-    testComplexCast(
-        "c0",
+    testCast(
         input,
         makeFlatVector<int128_t>(
             {-30'000'000'000,
@@ -447,8 +252,7 @@ class CastExprTest : public functions::test::CastBaseTest {
     // Expected failures: allowed # of integers (precision - scale) in the
     // target
     VELOX_ASSERT_THROW(
-        testComplexCast(
-            "c0",
+        testCast(
             makeFlatVector<T>(std::vector<T>{std::numeric_limits<T>::min()}),
             makeFlatVector(std::vector<int64_t>{0}, DECIMAL(3, 1))),
         fmt::format(
@@ -456,20 +260,22 @@ class CastExprTest : public functions::test::CastBaseTest {
             CppToType<T>::name,
             std::to_string(std::numeric_limits<T>::min())));
     VELOX_ASSERT_THROW(
-        testComplexCast(
-            "c0",
+        testCast(
             makeFlatVector<T>(std::vector<T>{-100}),
             makeFlatVector(std::vector<int64_t>{0}, DECIMAL(17, 16))),
         fmt::format(
             "Cannot cast {} '-100' to DECIMAL(17, 16)", CppToType<T>::name));
     VELOX_ASSERT_THROW(
-        testComplexCast(
-            "c0",
+        testCast(
             makeFlatVector<T>(std::vector<T>{100}),
             makeFlatVector(std::vector<int64_t>{0}, DECIMAL(17, 16))),
         fmt::format(
             "Cannot cast {} '100' to DECIMAL(17, 16)", CppToType<T>::name));
   }
+
+  std::string zeros(uint32_t numZeros) {
+    return std::string(numZeros, '0');
+  }
 };
 
 TEST_F(CastExprTest, basics) {
@@ -500,6 +306,28 @@ TEST_F(CastExprTest, basics) {
       {1.888, 2.5, 3.6, 100.44, -100.101, 1.0, -2.0},
       {1.888, 2.5, 3.6, 100.44, -100.101, 1.0, -2.0});
   testCast<bool, std::string>("string", {true, false}, {"true", "false"});
+  testCast<float, bool>(
+      "boolean",
+      {0.0,
+       1.0,
+       1.1,
+       -1.1,
+       0.5,
+       -0.5,
+       std::numeric_limits<float>::quiet_NaN(),
+       std::numeric_limits<float>::infinity(),
+       0.0000000000001},
+      {false, true, true, true, true, true, true, true, true});
+  testCast<std::string, float>(
+      "float",
+      {"1.888", "1.", "1", "1.7E308", "Infinity", "-Infinity", "NaN"},
+      {1.888,
+       1.0,
+       1.0,
+       std::numeric_limits<float>::infinity(),
+       std::numeric_limits<float>::infinity(),
+       -std::numeric_limits<float>::infinity(),
+       std::numeric_limits<float>::quiet_NaN()});
 
   gflags::FlagSaver flagSaver;
   FLAGS_experimental_enable_legacy_cast = true;
@@ -509,30 +337,296 @@ TEST_F(CastExprTest, basics) {
       {"1.888", "2.5", "3.6", "100.44", "-100.101", "1", "-2"});
 }
 
+TEST_F(CastExprTest, fromUnknownType) {
+  testCast<UnknownValue, int8_t>(
+      "tinyint", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, int16_t>(
+      "smallint", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, int32_t>(
+      "int", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, int64_t>(
+      "bigint", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, float>(
+      "float", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, double>(
+      "double", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, std::string>(
+      "string", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, bool>(
+      "boolean", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, Timestamp>(
+      "timestamp", {std::nullopt, std::nullopt}, {std::nullopt, std::nullopt});
+  testCast<UnknownValue, int32_t>(
+      "date",
+      {std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt},
+      UNKNOWN(),
+      DATE());
+}
+
+TEST_F(CastExprTest, realAndDoubleToString) {
+  setLegacyCast(false);
+  testCast<double, std::string>(
+      "string",
+      {
+          12345678901234567000.0,
+          123456789.01234567,
+          10'000'000.0,
+          12345.0,
+          0.001,
+          0.00012,
+          0.0,
+          -0.0,
+          -0.00012,
+          -0.001,
+          -12345.0,
+          -10'000'000.0,
+          -123456789.01234567,
+          -12345678901234567000.0,
+          std::numeric_limits<double>::infinity(),
+          -std::numeric_limits<double>::infinity(),
+          std::numeric_limits<double>::quiet_NaN(),
+          -std::numeric_limits<double>::quiet_NaN(),
+      },
+      {
+          "1.2345678901234567E19",
+          "1.2345678901234567E8",
+          "1.0E7",
+          "12345.0",
+          "0.001",
+          "1.2E-4",
+          "0.0",
+          "-0.0",
+          "-1.2E-4",
+          "-0.001",
+          "-12345.0",
+          "-1.0E7",
+          "-1.2345678901234567E8",
+          "-1.2345678901234567E19",
+          "Infinity",
+          "-Infinity",
+          "NaN",
+          "NaN",
+      });
+  testCast<float, std::string>(
+      "string",
+      {
+          12345678000000000000.0,
+          123456780.0,
+          10'000'000.0,
+          12345.0,
+          0.001,
+          0.00012,
+          0.0,
+          -0.0,
+          -0.00012,
+          -0.001,
+          -12345.0,
+          -10'000'000.0,
+          -123456780.0,
+          -12345678000000000000.0,
+          std::numeric_limits<float>::infinity(),
+          -std::numeric_limits<float>::infinity(),
+          std::numeric_limits<float>::quiet_NaN(),
+          -std::numeric_limits<float>::quiet_NaN(),
+      },
+      {
+          "1.2345678E19",
+          "1.2345678E8",
+          "1.0E7",
+          "12345.0",
+          "0.001",
+          "1.2E-4",
+          "0.0",
+          "-0.0",
+          "-1.2E-4",
+          "-0.001",
+          "-12345.0",
+          "-1.0E7",
+          "-1.2345678E8",
+          "-1.2345678E19",
+          "Infinity",
+          "-Infinity",
+          "NaN",
+          "NaN",
+      });
+
+  setLegacyCast(true);
+  testCast<double, std::string>(
+      "string",
+      {
+          12345678901234567000.0,
+          123456789.01234567,
+          10'000'000.0,
+          12345.0,
+          0.001,
+          0.00012,
+          0.0,
+          -0.0,
+          -0.00012,
+          -0.001,
+          -12345.0,
+          -10'000'000.0,
+          -123456789.01234567,
+          -12345678901234567000.0,
+          std::numeric_limits<double>::infinity(),
+          -std::numeric_limits<double>::infinity(),
+          std::numeric_limits<double>::quiet_NaN(),
+          -std::numeric_limits<double>::quiet_NaN(),
+      },
+      {
+          "12345678901234567000.0",
+          "123456789.01234567",
+          "10000000.0",
+          "12345.0",
+          "0.001",
+          "0.00012",
+          "0.0",
+          "-0.0",
+          "-0.00012",
+          "-0.001",
+          "-12345.0",
+          "-10000000.0",
+          "-123456789.01234567",
+          "-12345678901234567000.0",
+          "Infinity",
+          "-Infinity",
+          "NaN",
+          "NaN",
+      });
+  testCast<float, std::string>(
+      "string",
+      {
+          12345678000000000000.0,
+          123456780.0,
+          10'000'000.0,
+          12345.0,
+          0.001,
+          0.00012,
+          0.0,
+          -0.0,
+          -0.00012,
+          -0.001,
+          -12345.0,
+          -10'000'000.0,
+          -123456780.0,
+          -12345678000000000000.0,
+          std::numeric_limits<float>::infinity(),
+          -std::numeric_limits<float>::infinity(),
+          std::numeric_limits<float>::quiet_NaN(),
+          -std::numeric_limits<float>::quiet_NaN(),
+      },
+      {
+          "12345678295994466000.0",
+          "123456784.0",
+          "10000000.0",
+          "12345.0",
+          "0.0010000000474974513",
+          "0.00011999999696854502",
+          "0.0",
+          "-0.0",
+          "-0.00011999999696854502",
+          "-0.0010000000474974513",
+          "-12345.0",
+          "-10000000.0",
+          "-123456784.0",
+          "-12345678295994466000.0",
+          "Infinity",
+          "-Infinity",
+          "NaN",
+          "NaN",
+      });
+}
+
 TEST_F(CastExprTest, stringToTimestamp) {
   std::vector<std::optional<std::string>> input{
       "1970-01-01",
+      "1970-01-01 00:00 America/Sao_Paulo",
       "2000-01-01",
       "1970-01-01 00:00:00",
       "2000-01-01 12:21:56",
       "1970-01-01 00:00:00-02:00",
+      "1970-01-01 00:00:00 +02",
+      "1970-01-01 00:00:00 -0101",
       std::nullopt,
   };
   std::vector<std::optional<Timestamp>> expected{
       Timestamp(0, 0),
+      Timestamp(10800, 0),
       Timestamp(946684800, 0),
       Timestamp(0, 0),
       Timestamp(946729316, 0),
       Timestamp(7200, 0),
+      Timestamp(-7200, 0),
+      Timestamp(3660, 0),
       std::nullopt,
   };
   testCast<std::string, Timestamp>("timestamp", input, expected);
 
-  setCastIntByTruncate(true);
+  // Try with a different session timezone.
+  setTimezone("America/Los_Angeles");
+  input = {
+      "1970-01-01 00:00",
+      "1970-01-01 00:00 +00:00",
+      "1970-01-01 00:00 +01:00",
+      "1970-01-01 00:00 America/Sao_Paulo",
+      "2000-01-01 12:21:56Z",
+  };
+  expected = {
+      Timestamp(28800, 0),
+      Timestamp(0, 0),
+      Timestamp(-3600, 0),
+      Timestamp(10800, 0),
+      Timestamp(946729316, 0),
+  };
+  testCast<std::string, Timestamp>("timestamp", input, expected);
+
+  // Test invalid inputs.
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<Timestamp, std::string>(
+          "cast(c0 as timestamp)", "1970-01-01T00:00")),
+      "Cannot cast VARCHAR '1970-01-01T00:00' to TIMESTAMP. Unable to parse timestamp value");
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<Timestamp, std::string>(
+          "cast(c0 as timestamp)", "201915-04-23 11:46:00.000")),
+      "Timepoint is outside of supported year range");
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<Timestamp, std::string>(
+          "try_cast(c0 as timestamp)", "201915-04-23 11:46:00.000")),
+      "Timepoint is outside of supported year range");
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<Timestamp, std::string>(
+          "cast(c0 as timestamp)", "2045-12-31 18:00:00")),
+      "Unable to convert timezone 'America/Los_Angeles' past 2037-11-01 09:00:00");
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<Timestamp, std::string>(
+          "try_cast(c0 as timestamp)", "2045-12-31 18:00:00")),
+      "Unable to convert timezone 'America/Los_Angeles' past 2037-11-01 09:00:00");
+
+  setLegacyCast(true);
+  input = {
+      "1970-01-01",
+      "1970-01-01T00:00 America/Sao_Paulo",
+      "2000-01-01",
+      "1970-01-01T00:00:00",
+      "2000-01-01 12:21:56",
+      "1970-01-01T00:00:00-02:00",
+      std::nullopt,
+  };
+  expected = {
+      Timestamp(0, 0),
+      Timestamp(10800, 0),
+      Timestamp(946684800, 0),
+      Timestamp(0, 0),
+      Timestamp(946729316, 0),
+      Timestamp(7200, 0),
+      std::nullopt,
+  };
   testCast<std::string, Timestamp>("timestamp", input, expected);
 }
 
 TEST_F(CastExprTest, timestampToString) {
+  setLegacyCast(false);
   testCast<Timestamp, std::string>(
       "string",
       {
@@ -546,21 +640,84 @@ TEST_F(CastExprTest, timestampToString) {
           Timestamp(946729316, 123),
           Timestamp(946729316, 129900000),
           Timestamp(7266, 0),
+          Timestamp(-50049331200, 0),
+          Timestamp(253405036800, 0),
+          Timestamp(-62480037600, 0),
+          std::nullopt,
+      },
+      {
+          "1940-01-02 00:00:00.000",
+          "1969-12-31 21:58:54.000",
+          "1970-01-01 00:00:00.000",
+          "2000-01-01 00:00:00.000",
+          "2269-12-29 00:00:00.000",
+          "4969-12-04 00:00:00.000",
+          "2000-01-01 12:21:56.000",
+          "2000-01-01 12:21:56.000",
+          "2000-01-01 12:21:56.129",
+          "1970-01-01 02:01:06.000",
+          "0384-01-01 08:00:00.000",
+          "10000-02-01 16:00:00.000",
+          "-0010-02-01 10:00:00.000",
+          std::nullopt,
+      });
+
+  setLegacyCast(true);
+  testCast<Timestamp, std::string>(
+      "string",
+      {
+          Timestamp(0, 0),
+          Timestamp(946729316, 123),
+          Timestamp(-50049331200, 0),
+          Timestamp(253405036800, 0),
+          Timestamp(-62480037600, 0),
           std::nullopt,
       },
       {
-          "1940-01-02T00:00:00.000",
-          "1969-12-31T21:58:54.000",
           "1970-01-01T00:00:00.000",
-          "2000-01-01T00:00:00.000",
-          "2269-12-29T00:00:00.000",
-          "4969-12-04T00:00:00.000",
-          "2000-01-01T12:21:56.000",
           "2000-01-01T12:21:56.000",
-          "2000-01-01T12:21:56.129",
-          "1970-01-01T02:01:06.000",
+          "384-01-01T08:00:00.000",
+          "10000-02-01T16:00:00.000",
+          "-10-02-01T10:00:00.000",
+          std::nullopt,
+      });
+
+  setLegacyCast(false);
+  setTimezone("America/Los_Angeles");
+  testCast<Timestamp, std::string>(
+      "string",
+      {
+          Timestamp(0, 0),
+          Timestamp(946729316, 123),
+          Timestamp(-50049331622, 0),
+          Timestamp(-62480038022, 0),
+          std::nullopt,
+      },
+      {
+          "1969-12-31 16:00:00.000",
+          "2000-01-01 04:21:56.000",
+          "0384-01-01 00:00:00.000",
+          "-0010-02-01 02:00:00.000",
           std::nullopt,
       });
+
+  // Ensure external/date throws since it doesn't know how to convert large
+  // timestamps.
+  auto mustThrow = [&]() {
+    return testCast<Timestamp, std::string>(
+        "string", {Timestamp(253405036800, 0)}, {"10000-02-01 08:00:00.000"});
+  };
+  VELOX_ASSERT_THROW(
+      mustThrow(), "Unable to convert timezone 'America/Los_Angeles' past");
+
+  // try_cast should also throw since it's runtime error.
+  auto tryCastMustThrow = [&]() {
+    return testTryCast<Timestamp, std::string>(
+        "string", {Timestamp(253405036800, 0)}, {"10000-02-01 08:00:00.000"});
+  };
+  VELOX_ASSERT_THROW(
+      tryCastMustThrow(),
+      "Unable to convert timezone 'America/Los_Angeles' past");
 }
 
 TEST_F(CastExprTest, dateToTimestamp) {
@@ -578,14 +735,11 @@ TEST_F(CastExprTest, dateToTimestamp) {
           Timestamp(1257724800, 0),
           std::nullopt,
       },
-      false,
-      false,
       DATE(),
       TIMESTAMP());
 }
 
 TEST_F(CastExprTest, timestampToDate) {
-  setTimezone("");
   std::vector<std::optional<Timestamp>> inputTimestamps = {
       Timestamp(0, 0),
       Timestamp(946684800, 0),
@@ -602,8 +756,6 @@ TEST_F(CastExprTest, timestampToDate) {
           14557,
           std::nullopt,
       },
-      false,
-      false,
       TIMESTAMP(),
       DATE());
 
@@ -617,26 +769,54 @@ TEST_F(CastExprTest, timestampToDate) {
           14556,
           std::nullopt,
       },
-      false,
-      false,
       TIMESTAMP(),
       DATE());
-}
 
-TEST_F(CastExprTest, timestampInvalid) {
-  testCast<int8_t, Timestamp>("timestamp", {12}, {Timestamp(0, 0)}, true);
-  testCast<int16_t, Timestamp>("timestamp", {1234}, {Timestamp(0, 0)}, true);
-  testCast<int32_t, Timestamp>("timestamp", {1234}, {Timestamp(0, 0)}, true);
-  testCast<int64_t, Timestamp>("timestamp", {1234}, {Timestamp(0, 0)}, true);
+  // Ensure external/date throws since it doesn't know how to convert large
+  // timestamps.
+  auto mustThrow = [&]() {
+    return testCast<Timestamp, int32_t>(
+        "date", {Timestamp(253405036800, 0)}, {0});
+  };
+  VELOX_ASSERT_THROW(
+      mustThrow(), "Unable to convert timezone 'America/Los_Angeles' past");
 
-  testCast<float, Timestamp>("timestamp", {12.99}, {Timestamp(0, 0)}, true);
-  testCast<double, Timestamp>("timestamp", {12.99}, {Timestamp(0, 0)}, true);
+  // try_cast should also throw since it's runtime error.
+  auto tryCastMustThrow = [&]() {
+    return testTryCast<Timestamp, int32_t>(
+        "date", {Timestamp(253405036800, 0)}, {0});
+  };
+  VELOX_ASSERT_THROW(
+      tryCastMustThrow(),
+      "Unable to convert timezone 'America/Los_Angeles' past");
+}
 
-  testCast<std::string, Timestamp>(
-      "timestamp", {"2012-Oct-01"}, {Timestamp(0, 0)}, true);
+TEST_F(CastExprTest, timestampInvalid) {
+  testInvalidCast<int8_t>(
+      "timestamp", {12}, "Conversion to Timestamp is not supported");
+  testInvalidCast<int16_t>(
+      "timestamp", {1234}, "Conversion to Timestamp is not supported");
+  testInvalidCast<int32_t>(
+      "timestamp", {1234}, "Conversion to Timestamp is not supported");
+  testInvalidCast<int64_t>(
+      "timestamp", {1234}, "Conversion to Timestamp is not supported");
+
+  testInvalidCast<float>(
+      "timestamp", {12.99}, "Conversion to Timestamp is not supported");
+  testInvalidCast<double>(
+      "timestamp", {12.99}, "Conversion to Timestamp is not supported");
+
+  testInvalidCast<std::string>(
+      "timestamp",
+      {"2012-Oct-01"},
+      "Unable to parse timestamp value: \"2012-Oct-01\"");
 }
 
 TEST_F(CastExprTest, timestampAdjustToTimezone) {
+  // Empty timezone is assumed to be GMT.
+  testCast<std::string, Timestamp>(
+      "timestamp", {"1970-01-01"}, {Timestamp(0, 0)});
+
   setTimezone("America/Los_Angeles");
 
   // Expect unix epochs to be converted to LA timezone (8h offset).
@@ -656,378 +836,319 @@ TEST_F(CastExprTest, timestampAdjustToTimezone) {
           Timestamp(946713600, 0),
           Timestamp(0, 0),
           Timestamp(946758116, 0),
-          Timestamp(-21600, 0),
+          Timestamp(-50400, 0),
           std::nullopt,
           Timestamp(957164400, 0),
       });
-
-  // Empty timezone is assumed to be GMT.
-  setTimezone("");
-  testCast<std::string, Timestamp>(
-      "timestamp", {"1970-01-01"}, {Timestamp(0, 0)});
-}
-
-TEST_F(CastExprTest, timestampAdjustToTimezoneInvalid) {
-  auto testFunc = [&]() {
-    testCast<std::string, Timestamp>(
-        "timestamp", {"1970-01-01"}, {Timestamp(1, 0)});
-  };
-
-  setTimezone("bla");
-  EXPECT_THROW(testFunc(), std::runtime_error);
 }
 
 TEST_F(CastExprTest, date) {
-  for (bool isIso8601 : {true, false}) {
-    setCastStringToDateIsIso8601(isIso8601);
-    testCast<std::string, int32_t>(
-        "date",
-        {"1970-01-01",
-         "2020-01-01",
-         "2135-11-09",
-         "1969-12-27",
-         "1812-04-15",
-         "1920-01-02",
-         "12345-12-18",
-         "1970-1-2",
-         "1970-01-2",
-         "1970-1-02",
-         "+1970-01-02",
-         "-1-1-1",
-         " 1970-01-01",
-         std::nullopt},
-        {0,
-         18262,
-         60577,
-         -5,
-         -57604,
-         -18262,
-         3789742,
-         1,
-         1,
-         1,
-         1,
-         -719893,
-         0,
-         std::nullopt},
-        false,
-        false,
-        VARCHAR(),
-        DATE());
-  }
-
-  setCastStringToDateIsIso8601(false);
   testCast<std::string, int32_t>(
       "date",
-      {"12345",
-       "2015",
-       "2015-03",
-       "2015-03-18T",
-       "2015-03-18T123123",
-       "2015-03-18 123142",
-       "2015-03-18 (BC)"},
-      {3789391, 16436, 16495, 16512, 16512, 16512, 16512},
-      false,
-      false,
+      {"1970-01-01",
+       " 2020-01-01",
+       "2135-11-09  ",
+       "   1969-12-27 ",
+       "1812-04-15",
+       "1920-01-02",
+       "12345-12-18",
+       "1970-1-2",
+       "1970-01-2",
+       "1970-1-02",
+       "+1970-01-02",
+       "-1-1-1",
+       " 1970-01-01",
+       std::nullopt},
+      {0,
+       18262,
+       60577,
+       -5,
+       -57604,
+       -18262,
+       3789742,
+       1,
+       1,
+       1,
+       1,
+       -719893,
+       0,
+       std::nullopt},
       VARCHAR(),
       DATE());
 }
 
 TEST_F(CastExprTest, invalidDate) {
-  for (bool isIso8601 : {true, false}) {
-    setCastStringToDateIsIso8601(isIso8601);
-
-    testCast<int8_t, int32_t>(
-        "date", {12}, {0}, true, false, TINYINT(), DATE());
-    testCast<int16_t, int32_t>(
-        "date", {1234}, {0}, true, false, SMALLINT(), DATE());
-    testCast<int32_t, int32_t>(
-        "date", {1234}, {0}, true, false, INTEGER(), DATE());
-    testCast<int64_t, int32_t>(
-        "date", {1234}, {0}, true, false, BIGINT(), DATE());
-
-    testCast<float, int32_t>("date", {12.99}, {0}, true, false, REAL(), DATE());
-    testCast<double, int32_t>(
-        "date", {12.99}, {0}, true, false, DOUBLE(), DATE());
-
-    // Parsing ill-formated dates.
-    testCast<std::string, int32_t>(
-        "date", {"2012-Oct-23"}, {0}, true, false, VARCHAR(), DATE());
-    testCast<std::string, int32_t>(
-        "date", {"2015-03-18X"}, {0}, true, false, VARCHAR(), DATE());
-    testCast<std::string, int32_t>(
-        "date", {"2015/03/18"}, {0}, true, false, VARCHAR(), DATE());
-    testCast<std::string, int32_t>(
-        "date", {"2015.03.18"}, {0}, true, false, VARCHAR(), DATE());
-    testCast<std::string, int32_t>(
-        "date", {"20150318"}, {0}, true, false, VARCHAR(), DATE());
-    testCast<std::string, int32_t>(
-        "date", {"2015-031-8"}, {0}, true, false, VARCHAR(), DATE());
-  }
-
-  setCastStringToDateIsIso8601(true);
-  testCast<std::string, int32_t>(
-      "date", {"12345"}, {0}, true, false, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015-03"}, {0}, true, false, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015-03-18 123412"}, {0}, true, false, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015-03-18T"}, {0}, true, false, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015-03-18T123412"}, {0}, true, false, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"2015-03-18 (BC)"}, {0}, true, false, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {"1970-01-01 "}, {0}, true, false, VARCHAR(), DATE());
-  testCast<std::string, int32_t>(
-      "date", {" 1970-01-01 "}, {0}, true, false, VARCHAR(), DATE());
+  testInvalidCast<int8_t>(
+      "date", {12}, "Cast from TINYINT to DATE is not supported", TINYINT());
+  testInvalidCast<int16_t>(
+      "date",
+      {1234},
+      "Cast from SMALLINT to DATE is not supported",
+      SMALLINT());
+  testInvalidCast<int32_t>(
+      "date", {1234}, "Cast from INTEGER to DATE is not supported", INTEGER());
+  testInvalidCast<int64_t>(
+      "date", {1234}, "Cast from BIGINT to DATE is not supported", BIGINT());
+
+  testInvalidCast<float>(
+      "date", {12.99}, "Cast from REAL to DATE is not supported", REAL());
+  testInvalidCast<double>(
+      "date", {12.99}, "Cast from DOUBLE to DATE is not supported", DOUBLE());
+
+  // Parsing ill-formated dates.
+  testInvalidCast<std::string>(
+      "date",
+      {"2012-Oct-23"},
+      "Unable to parse date value: \"2012-Oct-23\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-03-18X"},
+      "Unable to parse date value: \"2015-03-18X\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015/03/18"},
+      "Unable to parse date value: \"2015/03/18\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015.03.18"},
+      "Unable to parse date value: \"2015.03.18\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"20150318"},
+      "Unable to parse date value: \"20150318\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-031-8"},
+      "Unable to parse date value: \"2015-031-8\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date", {"12345"}, "Unable to parse date value: \"12345\"", VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-03"},
+      "Unable to parse date value: \"2015-03\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-03-18 123412"},
+      "Unable to parse date value: \"2015-03-18 123412\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-03-18T"},
+      "Unable to parse date value: \"2015-03-18T\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-03-18T123412"},
+      "Unable to parse date value: \"2015-03-18T123412\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-03-18 (BC)"},
+      "Unable to parse date value: \"2015-03-18 (BC)\"",
+      VARCHAR());
 }
 
 TEST_F(CastExprTest, primitiveInvalidCornerCases) {
-  setCastIntByTruncate(false);
   // To integer.
   {
     // Overflow.
-    testCast<int32_t, int8_t>("tinyint", {1234567}, {0}, true);
-    testCast<int32_t, int8_t>("tinyint", {-1234567}, {0}, true);
-    testCast<double, int8_t>("tinyint", {12345.67}, {0}, true);
-    testCast<double, int8_t>("tinyint", {-12345.67}, {0}, true);
-    testCast<double, int8_t>("tinyint", {127.8}, {128}, true);
-    testCast<float, int32_t>("integer", {kInf}, {0}, true);
-    testCast<float, int64_t>("bigint", {kInf}, {0}, true);
+    testInvalidCast<int32_t>(
+        "tinyint", {1234567}, "Overflow during arithmetic conversion");
+    testInvalidCast<int32_t>(
+        "tinyint",
+        {-1234567},
+        "Negative overflow during arithmetic conversion");
+    testInvalidCast<double>(
+        "tinyint",
+        {12345.67},
+        "Loss of precision during arithmetic conversion");
+    testInvalidCast<double>(
+        "tinyint",
+        {-12345.67},
+        "Loss of precision during arithmetic conversion");
+    testInvalidCast<double>(
+        "tinyint", {127.8}, "Loss of precision during arithmetic conversion");
+    testInvalidCast<float>(
+        "integer", {kInf}, "Loss of precision during arithmetic conversion");
+    testInvalidCast<float>(
+        "bigint", {kInf}, "Loss of precision during arithmetic conversion");
     // Presto throws on cast(nan() as bigint), but we let it return 0 to be
     // consistent with other cases.
-    testCast<float, int64_t>("bigint", {kNan}, {0}, true);
-    testCast<float, int32_t>("integer", {kNan}, {0}, true);
-    testCast<float, int16_t>("smallint", {kNan}, {0}, true);
-    testCast<float, int8_t>("tinyint", {kNan}, {0}, true);
+    testInvalidCast<float>(
+        "bigint", {kNan}, "Cannot cast NaN to an integral value");
+    testInvalidCast<float>(
+        "integer", {kNan}, "Cannot cast NaN to an integral value");
+    testInvalidCast<float>(
+        "smallint", {kNan}, "Cannot cast NaN to an integral value");
+    testInvalidCast<float>(
+        "tinyint", {kNan}, "Cannot cast NaN to an integral value");
 
     // Invalid strings.
-    testCast<std::string, int8_t>("tinyint", {"1234567"}, {0}, true);
-    testCast<std::string, int8_t>("tinyint", {"1.2"}, {0}, true);
-    testCast<std::string, int8_t>("tinyint", {"1.23444"}, {0}, true);
-    testCast<std::string, int8_t>("tinyint", {".2355"}, {0}, true);
-    testCast<std::string, int8_t>("tinyint", {"1a"}, {0}, true);
-    testCast<std::string, int8_t>("tinyint", {""}, {0}, true);
-    testCast<std::string, int32_t>("integer", {"1'234'567"}, {0}, true);
-    testCast<std::string, int32_t>("integer", {"1,234,567"}, {0}, true);
-    testCast<std::string, int64_t>("bigint", {"infinity"}, {0}, true);
-    testCast<std::string, int64_t>("bigint", {"nan"}, {0}, true);
+    testInvalidCast<std::string>(
+        "tinyint", {"1234567"}, "Overflow during conversion");
+    testInvalidCast<std::string>(
+        "tinyint",
+        {"1.2"},
+        "Non-whitespace character found after end of conversion");
+    testInvalidCast<std::string>(
+        "tinyint",
+        {"1.23444"},
+        "Non-whitespace character found after end of conversion");
+    testInvalidCast<std::string>(
+        "tinyint", {".2355"}, "Invalid leading character");
+    testInvalidCast<std::string>(
+        "tinyint",
+        {"1a"},
+        "Non-whitespace character found after end of conversion");
+    testInvalidCast<std::string>("tinyint", {""}, "Empty string");
+    testInvalidCast<std::string>(
+        "integer",
+        {"1'234'567"},
+        "Non-whitespace character found after end of conversion");
+    testInvalidCast<std::string>(
+        "integer",
+        {"1,234,567"},
+        "Non-whitespace character found after end of conversion");
+    testInvalidCast<std::string>(
+        "bigint", {"infinity"}, "Invalid leading character");
+    testInvalidCast<std::string>(
+        "bigint", {"nan"}, "Invalid leading character");
+    testInvalidCast<std::string>(
+        "bigint",
+        {"٣"},
+        "Unicode characters are not supported for conversion to integer types",
+        VARCHAR(),
+        true);
   }
 
   // To floating-point.
   {
     // TODO: Presto returns Infinity in this case.
-    testCast<double, float>("real", {1.7E308}, {0}, true);
-
-    // Invalid strings.
-    testCast<std::string, float>("real", {"1.2a"}, {0}, true);
-    testCast<std::string, float>("real", {"1.2.3"}, {0}, true);
-  }
+    testInvalidCast<double>(
+        "real", {1.7E308}, "Overflow during arithmetic conversion");
 
-  // To boolean.
-  {
-    testCast<std::string, bool>("boolean", {"1.7E308"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"nan"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"infinity"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"12"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"-1"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"tr"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"tru"}, {0}, true);
-  }
-
-  setCastIntByTruncate(true);
-  // To integer.
-  {
-    // Invalid strings.
-    testCast<std::string, int8_t>("tinyint", {"1234567"}, {0}, true);
-    testCast<std::string, int8_t>("tinyint", {"1a"}, {0}, true);
-    testCast<std::string, int8_t>("tinyint", {""}, {0}, true);
-    testCast<std::string, int32_t>("integer", {"1'234'567"}, {0}, true);
-    testCast<std::string, int32_t>("integer", {"1,234,567"}, {0}, true);
-    testCast<std::string, int64_t>("bigint", {"infinity"}, {0}, true);
-    testCast<std::string, int64_t>("bigint", {"nan"}, {0}, true);
-    testCast<std::string, int8_t>("tinyint", {"+1"}, {0}, true);
-  }
-
-  // To floating-point.
-  {
     // Invalid strings.
-    testCast<std::string, float>("real", {"1.2a"}, {0}, true);
-    testCast<std::string, float>("real", {"1.2.3"}, {0}, true);
+    testInvalidCast<std::string>(
+        "real", {"1.2a"}, "Cannot cast VARCHAR '1.2a' to REAL");
+    testInvalidCast<std::string>(
+        "real", {"1.2.3"}, "Cannot cast VARCHAR '1.2.3' to REAL");
+    testInvalidCast<std::string>(
+        "real", {"nAn"}, "Cannot cast VARCHAR 'nAn' to REAL");
+    testInvalidCast<std::string>(
+        "real", {" nAn "}, "Cannot cast VARCHAR ' nAn ' to REAL");
+    testInvalidCast<std::string>(
+        "double", {"nAn"}, "Cannot cast VARCHAR 'nAn' to DOUBLE");
+    testInvalidCast<std::string>(
+        "real", {"iNfinitY"}, "Cannot cast VARCHAR 'iNfinitY' to REAL");
+    testInvalidCast<std::string>(
+        "double", {"iNfinitY"}, "Cannot cast VARCHAR 'iNfinitY' to DOUBLE");
+    testInvalidCast<std::string>(
+        "double", {" iNfinitY "}, "Cannot cast VARCHAR ' iNfinitY ' to DOUBLE");
+    testInvalidCast<std::string>(
+        "double", {""}, "Cannot cast VARCHAR '' to DOUBLE");
+    testInvalidCast<std::string>(
+        "double", {"   "}, "Cannot cast VARCHAR '   ' to DOUBLE");
+    testInvalidCast<std::string>(
+        "real", {"NaN  ."}, "Cannot cast VARCHAR 'NaN  .' to REAL");
+    testInvalidCast<std::string>(
+        "real", {"- NaN"}, "Cannot cast VARCHAR '- NaN' to REAL");
   }
 
   // To boolean.
   {
-    testCast<std::string, bool>("boolean", {"1.7E308"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"nan"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"infinity"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"12"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"-1"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"tr"}, {0}, true);
-    testCast<std::string, bool>("boolean", {"tru"}, {0}, true);
+    testInvalidCast<std::string>(
+        "boolean", {"1.7E308"}, "Cannot cast VARCHAR '1.7E308' to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"nan"}, "Cannot cast VARCHAR 'nan' to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"infinity"}, "Cannot cast VARCHAR 'infinity' to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"12"}, "Cannot cast VARCHAR '12' to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"-1"}, "Cannot cast VARCHAR '-1' to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"tr"}, "Cannot cast VARCHAR 'tr' to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"tru"}, "Cannot cast VARCHAR 'tru' to BOOLEAN");
   }
 }
 
 TEST_F(CastExprTest, primitiveValidCornerCases) {
-  setCastIntByTruncate(false);
   // To integer.
   {
-    testCast<double, int8_t>("tinyint", {127.1}, {127}, false);
-    testCast<double, int64_t>("bigint", {12345.12}, {12345}, false);
-    testCast<double, int64_t>("bigint", {12345.67}, {12346}, false);
-    testCast<std::string, int8_t>("tinyint", {"+1"}, {1}, false);
+    testCast<double, int8_t>("tinyint", {127.1}, {127});
+    testCast<double, int64_t>("bigint", {12345.12}, {12345});
+    testCast<double, int64_t>("bigint", {12345.67}, {12346});
+    testCast<std::string, int8_t>("tinyint", {"+1"}, {1});
   }
 
   // To floating-point.
   {
-    testCast<std::string, float>("real", {"1.7E308"}, {kInf}, false);
-    testCast<std::string, float>("real", {"1."}, {1.0}, false);
-    testCast<std::string, float>("real", {"1"}, {1}, false);
-    // When casting from "Infinity" and "NaN", Presto is case sensitive. But we
-    // let them be case insensitive to be consistent with other conversions.
-    testCast<std::string, float>("real", {"infinity"}, {kInf}, false);
-    testCast<std::string, float>("real", {"-infinity"}, {-kInf}, false);
-    testCast<std::string, float>("real", {"InfiNiTy"}, {kInf}, false);
-    testCast<std::string, float>("real", {"-InfiNiTy"}, {-kInf}, false);
-    testCast<std::string, float>("real", {"nan"}, {kNan}, false);
-    testCast<std::string, float>("real", {"nAn"}, {kNan}, false);
+    testCast<std::string, float>("real", {"1.7E308"}, {kInf});
+    testCast<std::string, float>("real", {"1."}, {1.0});
+    testCast<std::string, float>("real", {"1"}, {1});
+    testCast<std::string, float>("real", {"  1  "}, {1});
+    testCast<std::string, float>("real", {"-Infinity"}, {-kInf});
+    testCast<std::string, float>("real", {"+Infinity"}, {kInf});
+    testCast<std::string, float>("real", {" Infinity "}, {kInf});
+    testCast<std::string, float>("real", {"  NaN  "}, {kNan});
+    testCast<std::string, float>("real", {"  -NaN  "}, {kNan});
+    testCast<std::string, float>("real", {"  +NaN  "}, {kNan});
   }
 
   // To boolean.
   {
-    testCast<int8_t, bool>("boolean", {1}, {true}, false);
-    testCast<int8_t, bool>("boolean", {0}, {false}, false);
-    testCast<int8_t, bool>("boolean", {12}, {true}, false);
-    testCast<int8_t, bool>("boolean", {-1}, {true}, false);
-    testCast<double, bool>("boolean", {1.0}, {true}, false);
-    testCast<double, bool>("boolean", {1.1}, {true}, false);
-    testCast<double, bool>("boolean", {0.1}, {true}, false);
-    testCast<double, bool>("boolean", {-0.1}, {true}, false);
-    testCast<double, bool>("boolean", {-1.0}, {true}, false);
-    testCast<float, bool>("boolean", {kNan}, {true}, false);
-    testCast<float, bool>("boolean", {kInf}, {true}, false);
-    testCast<double, bool>("boolean", {0.0000000000001}, {true}, false);
-
-    testCast<std::string, bool>("boolean", {"1"}, {true}, false);
-    testCast<std::string, bool>("boolean", {"0"}, {false}, false);
-    testCast<std::string, bool>("boolean", {"t"}, {true}, false);
-    testCast<std::string, bool>("boolean", {"true"}, {true}, false);
+    testCast<int8_t, bool>("boolean", {1}, {true});
+    testCast<int8_t, bool>("boolean", {0}, {false});
+    testCast<int8_t, bool>("boolean", {12}, {true});
+    testCast<int8_t, bool>("boolean", {-1}, {true});
+    testCast<double, bool>("boolean", {1.0}, {true});
+    testCast<double, bool>("boolean", {1.1}, {true});
+    testCast<double, bool>("boolean", {0.1}, {true});
+    testCast<double, bool>("boolean", {-0.1}, {true});
+    testCast<double, bool>("boolean", {-1.0}, {true});
+    testCast<float, bool>("boolean", {kNan}, {true});
+    testCast<float, bool>("boolean", {kInf}, {true});
+    testCast<double, bool>("boolean", {0.0000000000001}, {true});
+
+    testCast<std::string, bool>("boolean", {"1"}, {true});
+    testCast<std::string, bool>("boolean", {"0"}, {false});
+    testCast<std::string, bool>("boolean", {"t"}, {true});
+    testCast<std::string, bool>("boolean", {"true"}, {true});
+    testCast<std::string, bool>("boolean", {"false"}, {false});
+    testCast<std::string, bool>("boolean", {"f"}, {false});
+
+    testInvalidCast<std::string>(
+        "boolean", {"NO"}, "Cannot cast NO to BOOLEAN");
+
+    testInvalidCast<std::string>(
+        "boolean", {"off"}, "Cannot cast off to BOOLEAN");
   }
 
   // To string.
   {
-    testCast<float, std::string>("varchar", {kInf}, {"Infinity"}, false);
-    testCast<float, std::string>("varchar", {kNan}, {"NaN"}, false);
-  }
-
-  setCastIntByTruncate(true);
-  // To integer.
-  {
-    // Valid strings.
-    testCast<std::string, int8_t>("tinyint", {"1.2"}, {1}, false);
-    testCast<std::string, int8_t>("tinyint", {"1.23444"}, {1}, false);
-    testCast<std::string, int8_t>("tinyint", {".2355"}, {0}, false);
-    testCast<std::string, int8_t>("tinyint", {"-1.8"}, {-1}, false);
-    testCast<std::string, int8_t>("tinyint", {"1."}, {1}, false);
-    testCast<std::string, int8_t>("tinyint", {"-1."}, {-1}, false);
-    testCast<std::string, int8_t>("tinyint", {"0."}, {0}, false);
-    testCast<std::string, int8_t>("tinyint", {"."}, {0}, false);
-    testCast<std::string, int8_t>("tinyint", {"-."}, {0}, false);
-
-    testCast<int32_t, int8_t>("tinyint", {1234567}, {-121}, false);
-    testCast<int32_t, int8_t>("tinyint", {-1234567}, {121}, false);
-    testCast<double, int8_t>("tinyint", {12345.67}, {57}, false);
-    testCast<double, int8_t>("tinyint", {-12345.67}, {-57}, false);
-    testCast<double, int8_t>("tinyint", {127.1}, {127}, false);
-    testCast<float, int64_t>("bigint", {kInf}, {9223372036854775807}, false);
-    testCast<float, int64_t>("bigint", {kNan}, {0}, false);
-    testCast<float, int32_t>("integer", {kNan}, {0}, false);
-    testCast<float, int16_t>("smallint", {kNan}, {0}, false);
-    testCast<float, int8_t>("tinyint", {kNan}, {0}, false);
-
-    testCast<double, int64_t>("bigint", {12345.12}, {12345}, false);
-    testCast<double, int64_t>("bigint", {12345.67}, {12345}, false);
-  }
-
-  // To floating-point.
-  {
-    testCast<double, float>("real", {1.7E308}, {kInf}, false);
-
-    testCast<std::string, float>("real", {"1.7E308"}, {kInf}, false);
-    testCast<std::string, float>("real", {"1."}, {1.0}, false);
-    testCast<std::string, float>("real", {"1"}, {1}, false);
-    testCast<std::string, float>("real", {"infinity"}, {kInf}, false);
-    testCast<std::string, float>("real", {"-infinity"}, {-kInf}, false);
-    testCast<std::string, float>("real", {"nan"}, {kNan}, false);
-    testCast<std::string, float>("real", {"InfiNiTy"}, {kInf}, false);
-    testCast<std::string, float>("real", {"-InfiNiTy"}, {-kInf}, false);
-    testCast<std::string, float>("real", {"nAn"}, {kNan}, false);
-  }
-
-  // To boolean.
-  {
-    testCast<int8_t, bool>("boolean", {1}, {true}, false);
-    testCast<int8_t, bool>("boolean", {0}, {false}, false);
-    testCast<int8_t, bool>("boolean", {12}, {true}, false);
-    testCast<int8_t, bool>("boolean", {-1}, {true}, false);
-    testCast<double, bool>("boolean", {1.0}, {true}, false);
-    testCast<double, bool>("boolean", {1.1}, {true}, false);
-    testCast<double, bool>("boolean", {0.1}, {true}, false);
-    testCast<double, bool>("boolean", {-0.1}, {true}, false);
-    testCast<double, bool>("boolean", {-1.0}, {true}, false);
-    testCast<float, bool>("boolean", {kNan}, {false}, false);
-    testCast<float, bool>("boolean", {kInf}, {true}, false);
-    testCast<double, bool>("boolean", {0.0000000000001}, {true}, false);
-
-    testCast<std::string, bool>("boolean", {"1"}, {true}, false);
-    testCast<std::string, bool>("boolean", {"0"}, {false}, false);
-    testCast<std::string, bool>("boolean", {"t"}, {true}, false);
-    testCast<std::string, bool>("boolean", {"true"}, {true}, false);
-  }
-
-  // To string.
-  {
-    testCast<float, std::string>("varchar", {kInf}, {"Infinity"}, false);
-    testCast<float, std::string>("varchar", {kNan}, {"NaN"}, false);
+    testCast<float, std::string>("varchar", {kInf}, {"Infinity"});
+    testCast<float, std::string>("varchar", {kNan}, {"NaN"});
   }
 }
 
 TEST_F(CastExprTest, truncateVsRound) {
-  // Testing truncate vs round cast from double to int.
-  setCastIntByTruncate(true);
-  testCast<double, int>(
-      "int", {1.888, 2.5, 3.6, 100.44, -100.101}, {1, 2, 3, 100, -100});
-  testCast<double, int8_t>(
-      "tinyint",
-      {1,
-       256,
-       257,
-       2147483646,
-       2147483647,
-       2147483648,
-       -2147483646,
-       -2147483647,
-       -2147483648,
-       -2147483649},
-      {1, 0, 1, -2, -1, -1, 2, 1, 0, 0});
-
-  setCastIntByTruncate(false);
+  // Testing round cast from double to int.
   testCast<double, int>(
       "int", {1.888, 2.5, 3.6, 100.44, -100.101}, {2, 3, 4, 100, -100});
-
   testCast<int8_t, int32_t>("int", {111, 2, 3, 10, -10}, {111, 2, 3, 10, -10});
-
-  setCastIntByTruncate(true);
-  testCast<int32_t, int8_t>(
-      "tinyint", {1111111, 2, 3, 1000, -100101}, {71, 2, 3, -24, -5});
-
-  setCastIntByTruncate(false);
-  EXPECT_THROW(
-      (testCast<int32_t, int8_t>(
-          "tinyint", {1111111, 2, 3, 1000, -100101}, {71, 2, 3, -24, -5})),
-      VeloxUserError);
+  testCast<int32_t, int8_t>("tinyint", {2, 3}, {2, 3});
+  testInvalidCast<int32_t>(
+      "tinyint",
+      {1111111, 1000, -100101},
+      "Cannot cast INTEGER '1111111' to TINYINT. Overflow during arithmetic conversion:");
 }
 
 TEST_F(CastExprTest, nullInputs) {
@@ -1048,69 +1169,22 @@ TEST_F(CastExprTest, nullInputs) {
 
 TEST_F(CastExprTest, errorHandling) {
   // Making sure error cases lead to null outputs
-  testCast<std::string, int8_t>(
+  testTryCast<std::string, int8_t>(
       "tinyint",
       {"1abc", "2", "3", "100", std::nullopt},
-      {std::nullopt, 2, 3, 100, std::nullopt},
-      false,
-      true);
-
-  setCastIntByTruncate(true);
-  testCast<std::string, int8_t>(
-      "tinyint",
-      {"-",
-       "-0",
-       " @w 123",
-       "123 ",
-       "  122",
-       "",
-       "-12-3",
-       "1234",
-       "-129",
-       "1.1.1",
-       "1..",
-       "1.abc",
-       "..",
-       "-..",
-       "125.5",
-       "127",
-       "-128"},
-      {std::nullopt,
-       0,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       std::nullopt,
-       125,
-       127,
-       -128},
-      false,
-      true);
-
-  testCast<double, int>(
-      "integer",
-      {1e12, 2.5, 3.6, 100.44, -100.101},
-      {std::numeric_limits<int32_t>::max(), 2, 3, 100, -100},
-      false,
-      true);
-
-  setCastIntByTruncate(false);
+      {std::nullopt, 2, 3, 100, std::nullopt});
   testCast<double, int>(
       "int", {1.888, 2.5, 3.6, 100.44, -100.101}, {2, 3, 4, 100, -100});
 
-  testCast<std::string, int8_t>(
-      "tinyint", {"1abc", "2", "3", "100", "-100"}, {1, 2, 3, 100, -100}, true);
+  testInvalidCast<std::string>(
+      "tinyint",
+      {"1abc", "2", "3", "100", "-100"},
+      "Non-whitespace character found after end of conversion");
 
-  testCast<std::string, int8_t>(
-      "tinyint", {"1", "2", "3", "100", "-100.5"}, {1, 2, 3, 100, -100}, true);
+  testInvalidCast<std::string>(
+      "tinyint",
+      {"1", "2", "3", "100", "-100.5"},
+      "Non-whitespace character found after end of conversion");
 }
 
 constexpr vector_size_t kVectorSize = 1'000;
@@ -1128,7 +1202,7 @@ TEST_F(CastExprTest, mapCast) {
     auto expectedMap = makeMapVector<int32_t, double>(
         kVectorSize, sizeAt, keyAt, valueAt, nullEvery(3));
 
-    testComplexCast("c0", inputMap, expectedMap);
+    testCast(inputMap, expectedMap);
   }
 
   // Cast map<bigint, bigint> -> map<bigint, varchar>.
@@ -1140,7 +1214,7 @@ TEST_F(CastExprTest, mapCast) {
     auto expectedMap = makeMapVector<int64_t, StringView>(
         kVectorSize, sizeAt, keyAt, valueAtString, nullEvery(3));
 
-    testComplexCast("c0", inputMap, expectedMap);
+    testCast(inputMap, expectedMap);
   }
 
   // Cast map<bigint, bigint> -> map<varchar, bigint>.
@@ -1152,7 +1226,7 @@ TEST_F(CastExprTest, mapCast) {
     auto expectedMap = makeMapVector<StringView, int64_t>(
         kVectorSize, sizeAt, keyAtString, valueAt, nullEvery(3));
 
-    testComplexCast("c0", inputMap, expectedMap);
+    testCast(inputMap, expectedMap);
   }
 
   // null values
@@ -1163,14 +1237,13 @@ TEST_F(CastExprTest, mapCast) {
     auto expectedMap = makeMapVector<int32_t, double>(
         kVectorSize, sizeAt, keyAt, valueAt, nullEvery(3), nullEvery(7));
 
-    testComplexCast("c0", inputWithNullValues, expectedMap);
+    testCast(inputWithNullValues, expectedMap);
   }
 
   // Nulls in result keys are not allowed.
   {
     VELOX_ASSERT_THROW(
-        testComplexCast(
-            "c0",
+        testCast(
             inputMap,
             makeMapVector<Timestamp, int64_t>(
                 kVectorSize,
@@ -1182,8 +1255,7 @@ TEST_F(CastExprTest, mapCast) {
             false),
         "Cannot cast BIGINT '0' to TIMESTAMP. Conversion to Timestamp is not supported");
 
-    testComplexCast(
-        "c0",
+    testCast(
         inputMap,
         makeMapVector<Timestamp, int64_t>(
             kVectorSize,
@@ -1207,7 +1279,8 @@ TEST_F(CastExprTest, mapCast) {
 
     SelectivityVector rows(5);
     rows.setValid(2, false);
-    mapVector->setOffsetAndSize(2, 100, 100);
+    mapVector->setOffsetAndSize(2, 100, 1);
+    mapVector->setOffsetAndSize(51, 2, 1);
     std::vector<VectorPtr> results(1);
 
     auto rowVector = makeRowVector({mapVector});
@@ -1272,7 +1345,7 @@ TEST_F(CastExprTest, arrayCast) {
   {
     auto expected =
         makeArrayVector<int64_t>(kVectorSize, sizeAt, valueAt, nullEvery(3));
-    testComplexCast("c0", arrayVector, expected);
+    testCast(arrayVector, expected);
   }
 
   // Cast array<double> -> array<varchar>.
@@ -1284,7 +1357,7 @@ TEST_F(CastExprTest, arrayCast) {
     };
     auto expected = makeArrayVector<StringView>(
         kVectorSize, sizeAt, valueAtString, nullEvery(3));
-    testComplexCast("c0", arrayVector, expected);
+    testCast(arrayVector, expected);
   }
 
   // Make sure that the output of array cast has valid(copyable) data even for
@@ -1297,7 +1370,8 @@ TEST_F(CastExprTest, arrayCast) {
 
     SelectivityVector rows(5);
     rows.setValid(2, false);
-    arrayVector->setOffsetAndSize(2, 100, 10);
+    arrayVector->setOffsetAndSize(2, 100, 5);
+    arrayVector->setOffsetAndSize(20, 10, 5);
     std::vector<VectorPtr> results(1);
 
     auto rowVector = makeRowVector({arrayVector});
@@ -1348,7 +1422,7 @@ TEST_F(CastExprTest, arrayCast) {
         {{{{std::nullopt, 4}}}}, // row1
 
     });
-    testComplexCast("c0", data, expected, true);
+    testCast(data, expected, true);
   }
 }
 
@@ -1372,7 +1446,7 @@ TEST_F(CastExprTest, rowCast) {
   {
     auto expectedRowVector = makeRowVector(
         {doubleVectorNullEvery11, intVectorNullEvery3}, nullEvery(5));
-    testComplexCast("c0", rowVector, expectedRowVector);
+    testCast(rowVector, expectedRowVector);
   }
   // Position-based cast: ROW(c0: bigint, c1: double) -> ROW(a: double, b:
   // bigint)
@@ -1381,13 +1455,13 @@ TEST_F(CastExprTest, rowCast) {
         {"a", "b"},
         {doubleVectorNullEvery11, intVectorNullEvery3},
         nullEvery(5));
-    testComplexCast("c0", rowVector, expectedRowVector);
+    testCast(rowVector, expectedRowVector);
   }
   // Position-based cast: ROW(c0: bigint, c1: double) -> ROW(c0: double)
   {
     auto expectedRowVector =
         makeRowVector({doubleVectorNullEvery11}, nullEvery(5));
-    testComplexCast("c0", rowVector, expectedRowVector);
+    testCast(rowVector, expectedRowVector);
   }
 
   // Name-based cast: ROW(c0: bigint, c1: double) -> ROW(c0: double) dropping
@@ -1398,7 +1472,7 @@ TEST_F(CastExprTest, rowCast) {
         kVectorSize, valueAtInt, [](vector_size_t /* row */) { return true; });
     auto expectedRowVector = makeRowVector(
         {"c0", "b"}, {doubleVectorNullEvery11, intVectorNullAll}, nullEvery(5));
-    testComplexCast("c0", rowVector, expectedRowVector);
+    testCast(rowVector, expectedRowVector);
   }
 
   // Error handling.
@@ -1411,7 +1485,7 @@ TEST_F(CastExprTest, rowCast) {
         {makeFlatVector<int32_t>({1, 2}), makeFlatVector<int32_t>({2, 3})});
     expected->setNull(1, true);
 
-    testComplexCast("c0", data, expected, true);
+    testCast(data, expected, true);
   }
 
   {
@@ -1438,9 +1512,9 @@ TEST_F(CastExprTest, rowCast) {
     expected3->setNull(0, true);
     expected3->setNull(1, true);
 
-    testComplexCast("c0", data, expected1, true);
-    testComplexCast("c0", data, expected2, true);
-    testComplexCast("c0", data, expected3, true);
+    testCast(data, expected1, true);
+    testCast(data, expected2, true);
+    testCast(data, expected3, true);
   }
 
   // Null handling for nested structs.
@@ -1450,7 +1524,7 @@ TEST_F(CastExprTest, rowCast) {
     auto expected =
         makeRowVector({makeRowVector({makeFlatVector<int32_t>({1, 0})})});
     expected->setNull(1, true);
-    testComplexCast("c0", data, expected, true);
+    testCast(data, expected, true);
   }
 }
 
@@ -1476,10 +1550,10 @@ TEST_F(CastExprTest, testNullOnFailure) {
       {1, 2, std::nullopt, std::nullopt, std::nullopt});
 
   // nullOnFailure is true, so we should return null instead of throwing.
-  testComplexCast("c0", input, expected, true);
+  testCast(input, expected, true);
 
   // nullOnFailure is false, so we should throw.
-  EXPECT_THROW(testComplexCast("c0", input, expected, false), VeloxUserError);
+  EXPECT_THROW(testCast(input, expected, false), VeloxUserError);
 }
 
 TEST_F(CastExprTest, toString) {
@@ -1519,23 +1593,28 @@ TEST_F(CastExprTest, decimalToFloat) {
 TEST_F(CastExprTest, decimalToBool) {
   auto shortFlat = makeNullableFlatVector<int64_t>(
       {DecimalUtil::kShortDecimalMin, 0, std::nullopt}, DECIMAL(18, 18));
-  testComplexCast(
-      "c0", shortFlat, makeNullableFlatVector<bool>({1, 0, std::nullopt}));
+  testCast(shortFlat, makeNullableFlatVector<bool>({1, 0, std::nullopt}));
 
   auto longFlat = makeNullableFlatVector<int128_t>(
       {DecimalUtil::kLongDecimalMin, 0, std::nullopt}, DECIMAL(38, 5));
-  testComplexCast(
-      "c0", longFlat, makeNullableFlatVector<bool>({1, 0, std::nullopt}));
+  testCast(longFlat, makeNullableFlatVector<bool>({1, 0, std::nullopt}));
 }
 
 TEST_F(CastExprTest, decimalToVarchar) {
   auto flatForInline = makeNullableFlatVector<int64_t>(
       {123456789, -333333333, 0, 5, -9, std::nullopt}, DECIMAL(9, 2));
-  testComplexCast(
-      "c0",
+  testCast(
       flatForInline,
       makeNullableFlatVector<StringView>(
-          {"1234567.89", "-3333333.33", "0", "0.05", "-0.09", std::nullopt}));
+          {"1234567.89",
+           "-3333333.33",
+           "0.00",
+           "0.05",
+           "-0.09",
+           std::nullopt}));
+
+  auto shortFlatForZero = makeNullableFlatVector<int64_t>({0}, DECIMAL(6, 0));
+  testCast(shortFlatForZero, makeNullableFlatVector<StringView>({"0"}));
 
   auto shortFlat = makeNullableFlatVector<int64_t>(
       {DecimalUtil::kShortDecimalMin,
@@ -1545,13 +1624,12 @@ TEST_F(CastExprTest, decimalToVarchar) {
        DecimalUtil::kShortDecimalMax,
        std::nullopt},
       DECIMAL(18, 18));
-  testComplexCast(
-      "c0",
+  testCast(
       shortFlat,
       makeNullableFlatVector<StringView>(
           {"-0.999999999999999999",
            "-0.000000000000000003",
-           "0",
+           "0.000000000000000000",
            "0.000000000000000055",
            "0.999999999999999999",
            std::nullopt}));
@@ -1564,66 +1642,59 @@ TEST_F(CastExprTest, decimalToVarchar) {
        HugeInt::build(0xffff, 0xffffffffffffffff),
        std::nullopt},
       DECIMAL(38, 5));
-  testComplexCast(
-      "c0",
+  testCast(
       longFlat,
       makeNullableFlatVector<StringView>(
           {"-999999999999999999999999999999999.99999",
-           "0",
+           "0.00000",
            "999999999999999999999999999999999.99999",
            "-0.00001",
            "12089258196146291747.06175",
            std::nullopt}));
+
+  auto longFlatForZero = makeNullableFlatVector<int128_t>({0}, DECIMAL(25, 0));
+  testCast(longFlatForZero, makeNullableFlatVector<StringView>({"0"}));
 }
 
 TEST_F(CastExprTest, decimalToDecimal) {
   // short to short, scale up.
   auto shortFlat =
       makeFlatVector<int64_t>({-3, -2, -1, 0, 55, 69, 72}, DECIMAL(2, 2));
-  testComplexCast(
-      "c0",
+  testCast(
       shortFlat,
       makeFlatVector<int64_t>(
           {-300, -200, -100, 0, 5'500, 6'900, 7'200}, DECIMAL(4, 4)));
 
   // short to short, scale down.
-  testComplexCast(
-      "c0",
-      shortFlat,
-      makeFlatVector<int64_t>({0, 0, 0, 0, 6, 7, 7}, DECIMAL(4, 1)));
+  testCast(
+      shortFlat, makeFlatVector<int64_t>({0, 0, 0, 0, 6, 7, 7}, DECIMAL(4, 1)));
 
   // long to short, scale up.
   auto longFlat =
       makeFlatVector<int128_t>({-201, -109, 0, 105, 208}, DECIMAL(20, 2));
-  testComplexCast(
-      "c0",
+  testCast(
       longFlat,
       makeFlatVector<int64_t>(
           {-201'000, -109'000, 0, 105'000, 208'000}, DECIMAL(10, 5)));
 
   // long to short, scale down.
-  testComplexCast(
-      "c0",
-      longFlat,
-      makeFlatVector<int64_t>({-20, -11, 0, 11, 21}, DECIMAL(10, 1)));
+  testCast(
+      longFlat, makeFlatVector<int64_t>({-20, -11, 0, 11, 21}, DECIMAL(10, 1)));
 
   // long to long, scale up.
-  testComplexCast(
-      "c0",
+  testCast(
       longFlat,
       makeFlatVector<int128_t>(
           {-20'100'000'000, -10'900'000'000, 0, 10'500'000'000, 20'800'000'000},
           DECIMAL(20, 10)));
 
   // long to long, scale down.
-  testComplexCast(
-      "c0",
+  testCast(
       longFlat,
       makeFlatVector<int128_t>({-20, -11, 0, 11, 21}, DECIMAL(20, 1)));
 
   // short to long, scale up.
-  testComplexCast(
-      "c0",
+  testCast(
       shortFlat,
       makeFlatVector<int128_t>(
           {-3'000'000'000,
@@ -1636,8 +1707,7 @@ TEST_F(CastExprTest, decimalToDecimal) {
           DECIMAL(20, 11)));
 
   // short to long, scale down.
-  testComplexCast(
-      "c0",
+  testCast(
       makeFlatVector<int64_t>({-20'500, -190, 12'345, 19'999}, DECIMAL(6, 4)),
       makeFlatVector<int128_t>({-21, 0, 12, 20}, DECIMAL(20, 1)));
 
@@ -1649,15 +1719,14 @@ TEST_F(CastExprTest, decimalToDecimal) {
 
   // Throws exception if CAST fails.
   VELOX_ASSERT_THROW(
-      testComplexCast("c0", longFlat, expectedShort),
+      testCast(longFlat, expectedShort),
       "Cannot cast DECIMAL '-1000.000' to DECIMAL(6, 4)");
 
   // nullOnFailure is true.
-  testComplexCast("c0", longFlat, expectedShort, true);
+  testCast(longFlat, expectedShort, true);
 
   // long to short, big numbers.
-  testComplexCast(
-      "c0",
+  testCast(
       makeNullableFlatVector<int128_t>(
           {HugeInt::build(-2, 200),
            HugeInt::build(-1, 300),
@@ -1678,21 +1747,30 @@ TEST_F(CastExprTest, decimalToDecimal) {
 
   // Overflow case.
   VELOX_ASSERT_THROW(
-      testComplexCast(
-          "c0",
+      testCast(
           makeNullableFlatVector<int128_t>(
               {DecimalUtil::kLongDecimalMax}, DECIMAL(38, 0)),
           makeNullableFlatVector<int128_t>({0}, DECIMAL(38, 1))),
       "Cannot cast DECIMAL '99999999999999999999999999999999999999' to DECIMAL(38, 1)");
   VELOX_ASSERT_THROW(
-      testComplexCast(
-          "c0",
+      testCast(
           makeNullableFlatVector<int128_t>(
               {DecimalUtil::kLongDecimalMin}, DECIMAL(38, 0)),
           makeNullableFlatVector<int128_t>({0}, DECIMAL(38, 1))),
       "Cannot cast DECIMAL '-99999999999999999999999999999999999999' to DECIMAL(38, 1)");
 }
 
+TEST_F(CastExprTest, integerToBinary) {
+  testInvalidCast<int8_t>(
+      "varbinary", {12}, "Cannot cast TINYINT to VARBINARY.");
+  testInvalidCast<int16_t>(
+      "varbinary", {12}, "Cannot cast SMALLINT to VARBINARY.");
+  testInvalidCast<int32_t>(
+      "varbinary", {12}, "Cannot cast INTEGER to VARBINARY.");
+  testInvalidCast<int64_t>(
+      "varbinary", {12}, "Cannot cast BIGINT to VARBINARY.");
+}
+
 TEST_F(CastExprTest, integerToDecimal) {
   testIntToDecimalCasts<int8_t>();
   testIntToDecimalCasts<int16_t>();
@@ -1700,6 +1778,275 @@ TEST_F(CastExprTest, integerToDecimal) {
   testIntToDecimalCasts<int64_t>();
 }
 
+TEST_F(CastExprTest, boolToDecimal) {
+  // Bool to short decimal.
+  auto input =
+      makeFlatVector<bool>({true, false, false, true, true, true, false});
+  testCast(
+      input,
+      makeFlatVector<int64_t>({100, 0, 0, 100, 100, 100, 0}, DECIMAL(6, 2)));
+
+  // Bool to long decimal.
+  testCast(
+      input,
+      makeFlatVector<int128_t>(
+          {10'000'000'000,
+           0,
+           0,
+           10'000'000'000,
+           10'000'000'000,
+           10'000'000'000,
+           0},
+          DECIMAL(20, 10)));
+}
+
+TEST_F(CastExprTest, varcharToDecimal) {
+  testCast(
+      makeFlatVector<StringView>(
+          {"9999999999.99",
+           "15",
+           "1.5",
+           "-1.5",
+           "1.556",
+           "1.554",
+           ("1.556" + std::string(32, '1')).data(),
+           ("1.556" + std::string(32, '9')).data(),
+           "0000.123",
+           ".12300000000",
+           "+09",
+           "9.",
+           ".9",
+           "3E2",
+           "-3E+2",
+           "3E+2",
+           "3E+00002",
+           "3E-2",
+           "3e+2",
+           "3e-2",
+           "3.5E-2",
+           "3.4E-2",
+           "3.5E+2",
+           "3.4E+2",
+           "31.423e+2",
+           "31.423e-2",
+           "31.523e-2",
+           "-3E-00000"}),
+      makeFlatVector<int64_t>(
+          {999'999'999'999,
+           1500,
+           150,
+           -150,
+           156,
+           155,
+           156,
+           156,
+           12,
+           12,
+           900,
+           900,
+           90,
+           30000,
+           -30000,
+           30000,
+           30000,
+           3,
+           30000,
+           3,
+           4,
+           3,
+           35000,
+           34000,
+           314230,
+           31,
+           32,
+           -300},
+          DECIMAL(12, 2)));
+
+  // Truncates the fractional digits with exponent.
+  testCast(
+      makeFlatVector<StringView>(
+          {"112345612.23e-6",
+           "112345662.23e-6",
+           "1.23e-6",
+           "1.23e-3",
+           "1.26e-3",
+           "1.23456781e3",
+           "1.23456789e3",
+           "1.23456789123451789123456789e9",
+           "1.23456789123456789123456789e9"}),
+      makeFlatVector<int128_t>(
+          {1123456,
+           1123457,
+           0,
+           12,
+           13,
+           12345678,
+           12345679,
+           12345678912345,
+           12345678912346},
+          DECIMAL(20, 4)));
+
+  const auto minDecimalStr = '-' + std::string(36, '9') + '.' + "99";
+  const auto maxDecimalStr = std::string(36, '9') + '.' + "99";
+  testCast(
+      makeFlatVector<StringView>(
+          {StringView(minDecimalStr),
+           StringView(maxDecimalStr),
+           "123456789012345678901234.567"}),
+      makeFlatVector<int128_t>(
+          {
+              DecimalUtil::kLongDecimalMin,
+              DecimalUtil::kLongDecimalMax,
+              HugeInt::build(
+                  669260, 10962463713375599297U), // 12345678901234567890123457
+          },
+          DECIMAL(38, 2)));
+
+  const std::string fractionLarge = "1.9" + std::string(67, '9');
+  const std::string fractionLargeExp = "1.9" + std::string(67, '9') + "e2";
+  const std::string fractionLargeNegExp =
+      "1000.9" + std::string(67, '9') + "e-2";
+  testCast(
+      makeFlatVector<StringView>(
+          {StringView(('-' + std::string(38, '9')).data()),
+           StringView(std::string(38, '9').data()),
+           StringView(fractionLarge),
+           StringView(fractionLargeExp),
+           StringView(fractionLargeNegExp)}),
+      makeFlatVector<int128_t>(
+          {DecimalUtil::kLongDecimalMin,
+           DecimalUtil::kLongDecimalMax,
+           2,
+           200,
+           10},
+          DECIMAL(38, 0)));
+
+  const std::string fractionRoundDown = "0." + std::string(38, '9') + "2";
+  const std::string fractionRoundDownExp =
+      "99." + std::string(36, '9') + "2e-2";
+  testCast(
+      makeFlatVector<StringView>(
+          {StringView(fractionRoundDown), StringView(fractionRoundDownExp)}),
+      makeConstant<int128_t>(DecimalUtil::kLongDecimalMax, 2, DECIMAL(38, 38)));
+
+  // Overflows when parsing whole digits.
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {std::string(280, '9')},
+      fmt::format(
+          "Cannot cast VARCHAR '{}' to DECIMAL(38, 0). Value too large.",
+          std::string(280, '9')));
+
+  // Overflows when parsing fractional digits.
+  const std::string fractionOverflow = std::string(36, '9') + '.' + "23456";
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 10),
+      {fractionOverflow},
+      fmt::format(
+          "Cannot cast VARCHAR '{}' to DECIMAL(38, 10). Value too large.",
+          fractionOverflow));
+
+  const std::string fractionRoundUp = "0." + std::string(38, '9') + "6";
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 38),
+      {fractionRoundUp},
+      fmt::format(
+          "Cannot cast VARCHAR '{}' to DECIMAL(38, 38). Value too large.",
+          fractionRoundUp));
+
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {"0.0444a"},
+      "Cannot cast VARCHAR '0.0444a' to DECIMAL(38, 0). Value is not a number. Chars 'a' are invalid.");
+
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {""},
+      "Cannot cast VARCHAR '' to DECIMAL(38, 0). Value is not a number. Input is empty.");
+
+  // Exponent > LongDecimalType::kMaxPrecision.
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {"1.23e67"},
+      "Cannot cast VARCHAR '1.23e67' to DECIMAL(38, 0). Value too large.");
+
+  // Forcing the scale to be zero overflows.
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {"20908.23e35"},
+      "Cannot cast VARCHAR '20908.23e35' to DECIMAL(38, 0). Value too large.");
+
+  // Rescale overflows.
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 38),
+      {"111111111111111111.23"},
+      "Cannot cast VARCHAR '111111111111111111.23' to DECIMAL(38, 38). Value too large.");
+
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {"23e-5d"},
+      "Cannot cast VARCHAR '23e-5d' to DECIMAL(38, 0). Value is not a number. Non-digit character 'd' is not allowed in the exponent part.");
+
+  // Whitespaces.
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {"1. 23"},
+      "Cannot cast VARCHAR '1. 23' to DECIMAL(38, 0). Value is not a number. Chars ' 23' are invalid.");
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(12, 2),
+      {"-3E+ 2"},
+      "Cannot cast VARCHAR '-3E+ 2' to DECIMAL(12, 2). Value is not a number. Non-digit character ' ' is not allowed in the exponent part.");
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {"1.23 "},
+      "Cannot cast VARCHAR '1.23 ' to DECIMAL(38, 0). Value is not a number. Chars ' ' are invalid.");
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(12, 2),
+      {"-3E+2 "},
+      "Cannot cast VARCHAR '-3E+2 ' to DECIMAL(12, 2). Value is not a number. Non-digit character ' ' is not allowed in the exponent part.");
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(38, 0),
+      {" 1.23"},
+      "Cannot cast VARCHAR ' 1.23' to DECIMAL(38, 0). Value is not a number. Extracted digits are empty.");
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(12, 2),
+      {" -3E+2"},
+      "Cannot cast VARCHAR ' -3E+2' to DECIMAL(12, 2). Value is not a number. Extracted digits are empty.");
+
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(12, 2),
+      {"-3E+2.1"},
+      "Cannot cast VARCHAR '-3E+2.1' to DECIMAL(12, 2). Value is not a number. Non-digit character '.' is not allowed in the exponent part.");
+
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(12, 2),
+      {"-3E+"},
+      "Cannot cast VARCHAR '-3E+' to DECIMAL(12, 2). Value is not a number. The exponent part only contains sign.");
+
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(12, 2),
+      {"-3E-"},
+      "Cannot cast VARCHAR '-3E-' to DECIMAL(12, 2). Value is not a number. The exponent part only contains sign.");
+}
+
 TEST_F(CastExprTest, castInTry) {
   // Test try(cast(array(varchar) as array(bigint))) whose input vector is
   // wrapped in dictinary encoding. The row of ["2a"] should trigger an error
@@ -1748,6 +2095,236 @@ TEST_F(CastExprTest, castInTry) {
       ARRAY(ARRAY(VARCHAR())), ARRAY(ARRAY(BIGINT())), nested, nestedExpected);
 }
 
+TEST_F(CastExprTest, doubleToDecimal) {
+  // Double to short decimal.
+  const auto input = makeFlatVector<double>(
+      {-3333.03,
+       -2222.02,
+       -1.0,
+       0.00,
+       100,
+       99999.99,
+       10.03,
+       10.05,
+       9.95,
+       -2.123456789});
+  testCast(
+      input,
+      makeFlatVector<int64_t>(
+          {-33'330'300,
+           -22'220'200,
+           -10'000,
+           0,
+           1'000'000,
+           999'999'900,
+           100'300,
+           100'500,
+           99'500,
+           -21'235},
+          DECIMAL(10, 4)));
+
+  // Double to long decimal.
+  testCast(
+      input,
+      makeFlatVector<int128_t>(
+          {
+              HugeInt::parse("-333303" + zeros(16)),
+              HugeInt::parse("-222202" + zeros(16)),
+              -1'000'000'000'000'000'000,
+              0,
+              HugeInt::parse("100" + zeros(18)),
+              HugeInt::parse("9999999" + zeros(16)),
+              HugeInt::parse("1003" + zeros(16)),
+              HugeInt::parse("1005" + zeros(16)),
+              HugeInt::parse("995" + zeros(16)),
+              HugeInt::parse("-2123456789" + zeros(9)),
+          },
+          DECIMAL(38, 18)));
+  testCast(
+      input,
+      makeFlatVector<int128_t>(
+          {-33'330, -22'220, -10, 0, 1'000, 1'000'000, 100, 101, 100, -21},
+          DECIMAL(20, 1)));
+  testCast(
+      makeNullableFlatVector<double>(
+          {0.13456789,
+           0.00000015,
+           0.000000000000001,
+           0.999999999999999,
+           0.123456789123123,
+           std::nullopt}),
+      makeNullableFlatVector<int128_t>(
+          {134'567'890'000'000'000,
+           150'000'000'000,
+           1'000,
+           999'999'999'999'999'000,
+           123'456'789'123'123'000,
+           std::nullopt},
+          DECIMAL(38, 18)));
+
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(10, 2),
+      {9999999999999999999999.99},
+      "Cannot cast DOUBLE '1E22' to DECIMAL(10, 2). Result overflows.");
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(10, 2),
+      {static_cast<double>(
+          static_cast<int128_t>(std::numeric_limits<int64_t>::max()) + 1)},
+      "Cannot cast DOUBLE '9223372036854776000' to DECIMAL(10, 2). Result overflows.");
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(10, 2),
+      {static_cast<double>(
+          static_cast<int128_t>(std::numeric_limits<int64_t>::min()) - 1)},
+      "Cannot cast DOUBLE '-9223372036854776000' to DECIMAL(10, 2). Result overflows.");
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(20, 2),
+      {static_cast<double>(DecimalUtil::kLongDecimalMax)},
+      "Cannot cast DOUBLE '1E38' to DECIMAL(20, 2). Result overflows.");
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(20, 2),
+      {static_cast<double>(DecimalUtil::kLongDecimalMin)},
+      "Cannot cast DOUBLE '-1E38' to DECIMAL(20, 2). Result overflows.");
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(38, 2),
+      {std::numeric_limits<double>::max()},
+      "Cannot cast DOUBLE '1.7976931348623157E308' to DECIMAL(38, 2). Result overflows.");
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(38, 2),
+      {std::numeric_limits<double>::lowest()},
+      "Cannot cast DOUBLE '-1.7976931348623157E308' to DECIMAL(38, 2). Result overflows.");
+  testCast(
+      makeConstant<double>(std::numeric_limits<double>::min(), 1),
+      makeConstant<int128_t>(0, 1, DECIMAL(38, 2)));
+
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(38, 2),
+      {INFINITY},
+      "Cannot cast DOUBLE 'Infinity' to DECIMAL(38, 2). The input value should be finite.");
+  testThrow<double>(
+      DOUBLE(),
+      DECIMAL(38, 2),
+      {NAN},
+      "Cannot cast DOUBLE 'NaN' to DECIMAL(38, 2). The input value should be finite.");
+}
+
+TEST_F(CastExprTest, realToDecimal) {
+  // Real to short decimal.
+  const auto input = makeFlatVector<float>(
+      {-3333.03,
+       -2222.02,
+       -1.0,
+       0.00,
+       100,
+       99999.9,
+       10.03,
+       10.05,
+       9.95,
+       -2.12345});
+  testCast(
+      input,
+      makeFlatVector<int64_t>(
+          {-33'330'300,
+           -22'220'200,
+           -10'000,
+           0,
+           1'000'000,
+           999'999'000,
+           100'300,
+           100'500,
+           99'500,
+           -212'35},
+          DECIMAL(10, 4)));
+
+  // Real to long decimal.
+  testCast(
+      input,
+      makeFlatVector<int128_t>(
+          {HugeInt::parse("-333303" + zeros(16)),
+           HugeInt::parse("-222202" + zeros(16)),
+           -1'000'000'000'000'000'000,
+           0,
+           HugeInt::parse("100" + zeros(18)),
+           HugeInt::parse("999999" + zeros(17)),
+           HugeInt::parse("1003" + zeros(16)),
+           HugeInt::parse("1005" + zeros(16)),
+           HugeInt::parse("995" + zeros(16)),
+           -2'123'450'000'000'000'000},
+          DECIMAL(38, 18)));
+  testCast(
+      input,
+      makeFlatVector<int128_t>(
+          {-33'330, -22'220, -10, 0, 1'000, 999'999, 100, 101, 100, -21},
+          DECIMAL(20, 1)));
+  testCast(
+      makeNullableFlatVector<float>(
+          {0.134567, 0.000015, 0.000001, 0.999999, 0.123456, std::nullopt}),
+      makeNullableFlatVector<int128_t>(
+          {134'567'000'000'000'000,
+           15'000'000'000'000,
+           1'000'000'000'000,
+           999'999'000'000'000'000,
+           123'456'000'000'000'000,
+           std::nullopt},
+          DECIMAL(38, 18)));
+
+  testThrow<float>(
+      REAL(), DECIMAL(10, 2), {9999999999999999999999.99}, "Result overflows.");
+  testThrow<float>(
+      REAL(),
+      DECIMAL(10, 2),
+      {static_cast<float>(
+          static_cast<int128_t>(std::numeric_limits<int64_t>::max()) + 1)},
+      "Cannot cast REAL '9223372036854776000' to DECIMAL(10, 2). Result overflows.");
+  testThrow<float>(
+      REAL(),
+      DECIMAL(10, 2),
+      {static_cast<float>(
+          static_cast<int128_t>(std::numeric_limits<int64_t>::min()) - 1)},
+      "Cannot cast REAL '-9223372036854776000' to DECIMAL(10, 2). Result overflows.");
+  testThrow<float>(
+      REAL(),
+      DECIMAL(20, 2),
+      {static_cast<float>(DecimalUtil::kLongDecimalMax)},
+      "Cannot cast REAL '9.999999680285692E37' to DECIMAL(20, 2). Result overflows.");
+  testThrow<float>(
+      REAL(),
+      DECIMAL(20, 2),
+      {static_cast<float>(DecimalUtil::kLongDecimalMin)},
+      "Cannot cast REAL '-9.999999680285692E37' to DECIMAL(20, 2). Result overflows.");
+  testThrow<float>(
+      REAL(),
+      DECIMAL(38, 2),
+      {std::numeric_limits<float>::max()},
+      "Cannot cast REAL '3.4028234663852886E38' to DECIMAL(38, 2). Result overflows.");
+  testThrow<float>(
+      REAL(),
+      DECIMAL(38, 2),
+      {std::numeric_limits<float>::lowest()},
+      "Cannot cast REAL '-3.4028234663852886E38' to DECIMAL(38, 2). Result overflows.");
+  testCast(
+      makeConstant<float>(std::numeric_limits<float>::min(), 1),
+      makeConstant<int128_t>(0, 1, DECIMAL(38, 2)));
+
+  testThrow<float>(
+      REAL(),
+      DECIMAL(38, 2),
+      {INFINITY},
+      "Cannot cast REAL 'Infinity' to DECIMAL(38, 2). The input value should be finite.");
+  testThrow<float>(
+      REAL(),
+      DECIMAL(38, 2),
+      {NAN},
+      "Cannot cast REAL 'NaN' to DECIMAL(38, 2). The input value should be finite.");
+}
+
 TEST_F(CastExprTest, primitiveNullConstant) {
   // Evaluate cast(NULL::double as bigint).
   auto cast =
@@ -1880,10 +2457,6 @@ class TestingDictionaryToFewerRowsFunction : public exec::VectorFunction {
  public:
   TestingDictionaryToFewerRowsFunction() {}
 
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -1891,8 +2464,8 @@ class TestingDictionaryToFewerRowsFunction : public exec::VectorFunction {
       exec::EvalCtx& context,
       VectorPtr& result) const override {
     const auto size = rows.size();
-    auto indices = makeIndices(
-        size, [](auto /*row*/) { return 0; }, context.pool());
+    auto indices =
+        makeIndices(size, [](auto /*row*/) { return 0; }, context.pool());
 
     result = BaseVector::wrapInDictionary(nullptr, indices, size, args[0]);
   }
@@ -1926,7 +2499,8 @@ TEST_F(CastExprTest, dictionaryEncodedNestedInput) {
   exec::registerVectorFunction(
       "add_dict",
       TestingDictionaryToFewerRowsFunction::signatures(),
-      std::make_unique<TestingDictionaryToFewerRowsFunction>());
+      std::make_unique<TestingDictionaryToFewerRowsFunction>(),
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
 
   auto elements = makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6});
   auto elementsInDict = BaseVector::wrapInDictionary(
@@ -2040,5 +2614,87 @@ TEST_F(CastExprTest, lazyInput) {
 
   evaluate("cast(switch(gt(c0, c1), c1, c0) as double)", data);
 }
+
+TEST_F(CastExprTest, identicalTypes) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(10, folly::identity),
+  });
+  auto result = evaluate("cast(c0 as bigint)", data);
+  ASSERT_EQ(result.get(), data->childAt(0).get());
+}
+
+TEST_F(CastExprTest, skipCastEvaluation) {
+  // Inputs to error_on_odd_else_unknown are even, odd.
+  // Input to cast is an UNKNOWN vector which is not supported.
+  // Verify that input rows marked as errors are skipped.
+  {
+    auto data = makeRowVector({
+        makeFlatVector<int>(10, [&](auto row) { return row; }),
+    });
+
+    VELOX_ASSERT_THROW(
+        evaluate("try(cast(error_on_odd_else_unknown(c0) as INTEGER))", data),
+        "not a scalar type! kind: UNKNOWN");
+  }
+
+  // All inputs to error_on_odd_else_unknown are odd.
+  // All inputs to cast are errors, we skip evaluation.
+  {
+    auto data = makeRowVector({
+        makeFlatVector<int>(10, [&](auto row) { return row * 2 + 1; }),
+    });
+
+    auto result =
+        evaluate("try(cast(error_on_odd_else_unknown(c0) as INTEGER))", data);
+    ASSERT_EQ(BaseVector::countNulls(result->nulls(), result->size()), 10);
+  }
+
+  // Ensure trailing rows that are marked as error are handled correctly as they
+  // can result in intermediate result vectors of smaller size.
+  {
+    auto data = makeRowVector({
+        makeFlatVector<int64_t>({1, 2, 3, 0}),
+    });
+    auto result = evaluate("try(cast((c0 / c0) as VARCHAR))", data);
+    auto expected =
+        makeNullableFlatVector<StringView>({"1", "1", "1", std::nullopt});
+    assertEqualVectors(result, expected);
+  }
+}
+
+TEST_F(CastExprTest, intervalDayTimeToVarchar) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(
+          {kMillisInDay,
+           kMillisInHour,
+           kMillisInMinute,
+           kMillisInSecond,
+           5 * kMillisInDay + 14 * kMillisInHour + 20 * kMillisInMinute +
+               52 * kMillisInSecond + 88,
+           -(kMillisInDay + kMillisInHour + kMillisInMinute + kMillisInSecond +
+             88),
+           std::numeric_limits<int64_t>::min()},
+          INTERVAL_DAY_TIME()),
+  });
+
+  auto result = evaluate("cast(c0 as varchar)", data);
+  auto expected = makeFlatVector<std::string>({
+      "1 00:00:00.000",
+      "0 01:00:00.000",
+      "0 00:01:00.000",
+      "0 00:00:01.000",
+      "5 14:20:52.088",
+      "-1 01:01:01.088",
+      "-106751991167 07:12:55.808",
+  });
+
+  assertEqualVectors(expected, result);
+
+  // Reverse cast is not supported.
+  VELOX_ASSERT_THROW(
+      evaluate("cast('5 14:20:52.088' as interval day to second)", data),
+      "Cast from VARCHAR to INTERVAL DAY TO SECOND is not supported");
+}
+
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/expression/tests/ConjunctTest.cpp b/velox/expression/tests/ConjunctTest.cpp
new file mode 100644
index 0000000000000..280180664c271
--- /dev/null
+++ b/velox/expression/tests/ConjunctTest.cpp
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/init/Init.h>
+
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/parse/Expressions.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class ConjunctTest : public OperatorTestBase {};
+
+TEST_F(ConjunctTest, mixed) {
+  auto mixed = makeRowVector(
+      {makeFlatVector<int32_t>(18, [](auto row) { return row; }),
+       makeFlatVector<bool>(
+           18,
+           [](auto row) { return row % 3 == 0; },
+           [](auto row) { return row % 3 == 2; }),
+       makeFlatVector<bool>(
+           18,
+           [](auto row) { return (row / 3) % 3 == 0; },
+           [](auto row) { return (row / 3) % 3 == 2; })});
+  auto plan =
+      PlanBuilder()
+          .values({mixed})
+          .project({"c0", "c1", "c2", "if (c0 <9, c1 and c2, c1 or c2)"})
+          .planNode();
+  createDuckDbTable({mixed});
+
+  assertQuery(
+      plan, "select c0, c1, c2, if (c0 < 9, c1 and c2, c1 or c2) from tmp");
+
+  // Non-null and nullable
+  auto mixedOneNull = makeRowVector(
+      {makeFlatVector<int32_t>(18, [](auto row) { return row; }),
+       makeFlatVector<bool>(18, [](auto row) { return row % 3 == 0; }),
+       makeFlatVector<bool>(
+           18,
+           [](auto row) { return (row / 3) % 3 == 0; },
+           [](auto row) { return (row / 3) % 3 == 2; })});
+  plan = PlanBuilder()
+             .values({mixedOneNull})
+             .project({"c0", "c1", "c2", "if (c0 <9, c1 and c2, c1 or c2)"})
+             .planNode();
+  createDuckDbTable({mixedOneNull});
+
+  assertQuery(
+      plan, "select c0, c1, c2, if (c0 < 9, c1 and c2, c1 or c2) from tmp");
+
+  // Both are non-null
+  auto mixedNonNull = makeRowVector(
+      {makeFlatVector<int32_t>(18, [](auto row) { return row; }),
+       makeFlatVector<bool>(18, [](auto row) { return row % 3 == 0; }),
+       makeFlatVector<bool>(18, [](auto row) { return (row / 3) % 3 == 0; })});
+  plan = PlanBuilder()
+             .values({mixedNonNull})
+             .project({"c0", "c1", "c2", "if (c0 <9, c1 and c2, c1 or c2)"})
+             .planNode();
+  createDuckDbTable({mixedNonNull});
+
+  assertQuery(
+      plan, "select c0, c1, c2, if (c0 < 9, c1 and c2, c1 or c2) from tmp");
+}
+
+TEST_F(ConjunctTest, constant) {
+  for (auto counter = 0; counter < 9; ++counter) {
+    auto allSame = makeRowVector(
+        {makeFlatVector<int32_t>(18, [&](auto row) { return row; }),
+         makeFlatVector<bool>(
+             18,
+             [&](auto row) { return counter % 3 == 0; },
+             [&](auto row) { return counter % 3 == 2; }),
+         makeFlatVector<bool>(
+             18,
+             [&](auto row) { return (counter / 3) % 3 == 0; },
+             [&](auto row) { return (counter / 3) % 3 == 2; })});
+    auto plan =
+        PlanBuilder()
+            .values({allSame})
+            .project({"c0", "c1", "c2", "if (c0 <9, c1 and c2, c1 or c2)"})
+            .planNode();
+    createDuckDbTable({allSame});
+
+    assertQuery(
+        plan, "select c0, c1, c2, if (c0 < 9, c1 and c2, c1 or c2) from tmp");
+  }
+}
diff --git a/velox/expression/tests/CustomTypeTest.cpp b/velox/expression/tests/CustomTypeTest.cpp
index 5de7b287b476c..c55015d85900e 100644
--- a/velox/expression/tests/CustomTypeTest.cpp
+++ b/velox/expression/tests/CustomTypeTest.cpp
@@ -215,6 +215,8 @@ TEST_F(CustomTypeTest, getCustomTypeNames) {
           "JSON",
           "HYPERLOGLOG",
           "TIMESTAMP WITH TIME ZONE",
+          "UUID",
+          "IPADDRESS",
       }),
       names);
 
@@ -227,6 +229,8 @@ TEST_F(CustomTypeTest, getCustomTypeNames) {
           "JSON",
           "HYPERLOGLOG",
           "TIMESTAMP WITH TIME ZONE",
+          "UUID",
+          "IPADDRESS",
           "FANCY_INT",
       }),
       names);
diff --git a/velox/expression/tests/EvalCtxTest.cpp b/velox/expression/tests/EvalCtxTest.cpp
index 912e2b7f98ff9..0c9923f389c72 100644
--- a/velox/expression/tests/EvalCtxTest.cpp
+++ b/velox/expression/tests/EvalCtxTest.cpp
@@ -27,6 +27,10 @@ using namespace facebook::velox::test;
 
 class EvalCtxTest : public testing::Test, public VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   core::ExecCtx execCtx_{pool_.get(), nullptr};
 };
 
@@ -105,20 +109,20 @@ TEST_F(EvalCtxTest, vectorRecycler) {
 
 TEST_F(EvalCtxTest, ensureErrorsVectorSize) {
   EvalCtx context(&execCtx_);
-  context.ensureErrorsVectorSize(*context.errorsPtr(), 10);
+  context.ensureErrorsVectorSize(10);
   ASSERT_GE(context.errors()->size(), 10);
-  ASSERT_EQ(BaseVector::countNulls(context.errors()->nulls(), 10), 10);
+  ASSERT_EQ(context.errors()->countErrors(), 0);
 
   std::exception exception;
   *context.mutableThrowOnError() = false;
   context.setError(0, std::make_exception_ptr(exception));
 
-  ASSERT_EQ(BaseVector::countNulls(context.errors()->nulls(), 10), 9);
+  ASSERT_EQ(context.errors()->countErrors(), 1);
 
-  context.ensureErrorsVectorSize(*context.errorsPtr(), 20);
+  context.ensureErrorsVectorSize(20);
 
   ASSERT_GE(context.errors()->size(), 20);
-  ASSERT_EQ(BaseVector::countNulls(context.errors()->nulls(), 20), 19);
+  ASSERT_EQ(context.errors()->countErrors(), 1);
 }
 
 TEST_F(EvalCtxTest, setErrors) {
@@ -136,15 +140,18 @@ TEST_F(EvalCtxTest, setErrors) {
   ASSERT_EQ(errors->size(), rows.size());
   std::exception_ptr firstEx;
   for (auto i = 0; i < rows.size(); ++i) {
-    auto ex = std::static_pointer_cast<std::exception_ptr>(errors->valueAt(i));
-    VELOX_ASSERT_THROW(std::rethrow_exception(*ex), "This is a test.");
+    auto ex = errors->errorAt(i);
+    ASSERT_TRUE(ex.has_value());
+    ASSERT_TRUE(ex.value() != nullptr);
+    VELOX_ASSERT_THROW(std::rethrow_exception(*ex.value()), "This is a test.");
+    VELOX_ASSERT_THROW(errors->throwIfErrorAt(i), "This is a test.");
 
     // Verify that a single exception is re-used for all rows vs. each row
     // storing a copy.
     if (i == 0) {
-      firstEx = *ex;
+      firstEx = *ex.value();
     } else {
-      ASSERT_EQ(*ex, firstEx);
+      ASSERT_EQ(*ex.value(), firstEx);
     }
   }
 }
@@ -158,37 +165,37 @@ TEST_F(EvalCtxTest, addErrorsPreserveOldErrors) {
       0, std::make_exception_ptr(argumentError), *context.errorsPtr());
   context.addError(
       3, std::make_exception_ptr(argumentError), *context.errorsPtr());
-  ASSERT_EQ(BaseVector::countNulls(context.errors()->nulls(), 4), 2);
+  ASSERT_EQ(context.errors()->countErrors(), 2);
 
   // Add two out_of_range to anotherErrors.
-  ErrorVectorPtr anotherErrors;
+  EvalErrorsPtr anotherErrors;
   std::out_of_range rangeError{"out of range"};
   context.addError(0, std::make_exception_ptr(rangeError), anotherErrors);
   context.addError(4, std::make_exception_ptr(rangeError), anotherErrors);
-  ASSERT_EQ(BaseVector::countNulls(anotherErrors->nulls(), 5), 3);
+  ASSERT_EQ(context.errors()->countErrors(), 2);
 
   // Add errors in anotherErrors to context.errors() and check that the original
   // error at index 0 is preserved.
   SelectivityVector rows{5};
   context.addErrors(rows, anotherErrors, *context.errorsPtr());
   ASSERT_EQ(context.errors()->size(), 5);
-  ASSERT_EQ(BaseVector::countNulls(context.errors()->nulls(), 5), 2);
+  ASSERT_EQ(context.errors()->countErrors(), 3);
 
   auto checkErrors = [&](vector_size_t index, const char* message) {
-    ASSERT_GT(context.errors()->size(), index);
+    ASSERT_TRUE(context.errors()->hasErrorAt(index));
     try {
-      std::static_pointer_cast<std::exception_ptr>(
-          context.errors()->valueAt(index));
-    } catch (const std::exception& e) {
-      ASSERT_NE(std::strstr(e.what(), message), nullptr);
+      context.errors()->throwIfErrorAt(index);
+      FAIL() << "Expected exception";
+    } catch (std::exception& e) {
+      ASSERT_TRUE(strstr(e.what(), message) != nullptr);
     }
   };
 
   checkErrors(0, "invalid argument");
   checkErrors(3, "invalid argument");
   checkErrors(4, "out of range");
-  ASSERT_TRUE(context.errors()->isNullAt(1));
-  ASSERT_TRUE(context.errors()->isNullAt(2));
+  ASSERT_FALSE(context.errors()->hasErrorAt(1));
+  ASSERT_FALSE(context.errors()->hasErrorAt(2));
 }
 
 TEST_F(EvalCtxTest, localSingleRow) {
diff --git a/velox/expression/tests/EvalErrorsTest.cpp b/velox/expression/tests/EvalErrorsTest.cpp
new file mode 100644
index 0000000000000..fa012a7160b2a
--- /dev/null
+++ b/velox/expression/tests/EvalErrorsTest.cpp
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <exception>
+#include "gtest/gtest.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/expression/EvalCtx.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::exec {
+namespace {
+
+class EvalErrorsTest : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(EvalErrorsTest, noErrors) {
+  EvalErrors errors(pool(), 10);
+
+  ASSERT_EQ(errors.size(), 10);
+  ASSERT_EQ(errors.countErrors(), 0);
+  ASSERT_FALSE(errors.hasError());
+
+  for (auto i = 0; i < errors.size(); ++i) {
+    ASSERT_FALSE(errors.hasErrorAt(i));
+    ASSERT_NO_THROW(errors.throwIfErrorAt(i));
+    ASSERT_FALSE(errors.errorAt(i).has_value());
+    ASSERT_FALSE(bits::isBitSet(errors.errorFlags(), i));
+  }
+
+  // Test 'out-of-bounds' indices.
+  for (auto i = errors.size(); i < errors.size() + 5; ++i) {
+    ASSERT_FALSE(errors.hasErrorAt(i));
+    ASSERT_NO_THROW(errors.throwIfErrorAt(i));
+    ASSERT_FALSE(errors.errorAt(i).has_value());
+  }
+
+  SelectivityVector rows(123);
+  ASSERT_NO_THROW(errors.throwFirstError(rows));
+}
+
+TEST_F(EvalErrorsTest, someErrors) {
+  EvalErrors errors(pool(), 10);
+
+  errors.setError(3);
+
+  ASSERT_EQ(errors.size(), 10);
+  ASSERT_EQ(errors.countErrors(), 1);
+  ASSERT_TRUE(errors.hasError());
+  ASSERT_TRUE(errors.hasErrorAt(3));
+
+  for (auto i = 0; i < errors.size(); ++i) {
+    if (i != 3) {
+      ASSERT_FALSE(errors.hasErrorAt(i));
+      ASSERT_NO_THROW(errors.throwIfErrorAt(i));
+      ASSERT_FALSE(errors.errorAt(i).has_value());
+      ASSERT_FALSE(bits::isBitSet(errors.errorFlags(), i));
+    }
+  }
+
+  // Test 'out-of-bounds' index.
+  errors.setError(23);
+
+  ASSERT_EQ(errors.size(), 24);
+  ASSERT_EQ(errors.countErrors(), 2);
+  ASSERT_TRUE(errors.hasError());
+  ASSERT_TRUE(errors.hasErrorAt(3));
+  ASSERT_TRUE(errors.hasErrorAt(23));
+
+  for (auto i = 0; i < errors.size(); ++i) {
+    if (i != 3 && i != 23) {
+      ASSERT_FALSE(errors.hasErrorAt(i));
+      ASSERT_NO_THROW(errors.throwIfErrorAt(i));
+      ASSERT_FALSE(errors.errorAt(i).has_value());
+      ASSERT_FALSE(bits::isBitSet(errors.errorFlags(), i));
+    }
+  }
+
+  errors.clearError(3);
+
+  ASSERT_EQ(errors.size(), 24);
+  ASSERT_EQ(errors.countErrors(), 1);
+  ASSERT_TRUE(errors.hasError());
+  ASSERT_TRUE(errors.hasErrorAt(23));
+
+  for (auto i = 0; i < errors.size(); ++i) {
+    if (i != 23) {
+      ASSERT_FALSE(errors.hasErrorAt(i));
+      ASSERT_NO_THROW(errors.throwIfErrorAt(i));
+      ASSERT_FALSE(errors.errorAt(i).has_value());
+      ASSERT_FALSE(bits::isBitSet(errors.errorFlags(), i));
+    }
+  }
+
+  errors.clearError(23);
+
+  ASSERT_EQ(errors.size(), 24);
+  ASSERT_EQ(errors.countErrors(), 0);
+  ASSERT_FALSE(errors.hasError());
+
+  for (auto i = 0; i < errors.size(); ++i) {
+    ASSERT_FALSE(errors.hasErrorAt(i));
+    ASSERT_NO_THROW(errors.throwIfErrorAt(i));
+    ASSERT_FALSE(errors.errorAt(i).has_value());
+    ASSERT_FALSE(bits::isBitSet(errors.errorFlags(), i));
+  }
+}
+
+std::exception_ptr makeVeloxException(const std::string& errorMessage) {
+  try {
+    VELOX_USER_FAIL(errorMessage);
+    return nullptr;
+  } catch (...) {
+    return std::current_exception();
+  }
+}
+
+TEST_F(EvalErrorsTest, errorDetails) {
+  EvalErrors errors(pool(), 10);
+
+  errors.setError(0, makeVeloxException("Test error X"));
+  errors.setError(3, makeVeloxException("Test error Y"));
+  errors.setError(23, makeVeloxException("Test error Z"));
+
+  ASSERT_EQ(errors.size(), 24);
+  ASSERT_EQ(errors.countErrors(), 3);
+  ASSERT_TRUE(errors.hasError());
+
+  ASSERT_TRUE(errors.hasErrorAt(0));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(0), "Test error X");
+
+  ASSERT_TRUE(errors.hasErrorAt(3));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(3), "Test error Y");
+
+  ASSERT_TRUE(errors.hasErrorAt(23));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(23), "Test error Z");
+
+  SelectivityVector rows(123);
+  VELOX_ASSERT_THROW(errors.throwFirstError(rows), "Test error X");
+
+  rows.setValid(0, false);
+  rows.updateBounds();
+  VELOX_ASSERT_THROW(errors.throwFirstError(rows), "Test error Y");
+
+  for (auto i = 0; i < errors.size(); ++i) {
+    if (i != 0 && i != 3 && i != 23) {
+      ASSERT_FALSE(errors.hasErrorAt(i));
+      ASSERT_NO_THROW(errors.throwIfErrorAt(i));
+      ASSERT_FALSE(errors.errorAt(i).has_value());
+      ASSERT_FALSE(bits::isBitSet(errors.errorFlags(), i));
+    }
+  }
+}
+
+TEST_F(EvalErrorsTest, copyError) {
+  EvalErrors other(pool(), 10);
+  for (auto i = 0; i < 20; i += 3) {
+    other.setError(i);
+  }
+
+  ASSERT_EQ(other.countErrors(), 7);
+
+  // Copy errors from 3 rows. Only one of these has an error.
+  EvalErrors errors(pool(), 10);
+  errors.copyError(other, 10, 0);
+  errors.copyError(other, 11, 1);
+  errors.copyError(other, 12, 2);
+
+  ASSERT_EQ(errors.size(), 10);
+  ASSERT_EQ(errors.countErrors(), 1);
+  ASSERT_TRUE(errors.hasError());
+  ASSERT_TRUE(errors.hasErrorAt(2));
+
+  // Copy errors from all rows. Shift destination rows by 5.
+  for (auto i = 0; i < other.size(); ++i) {
+    errors.copyError(other, i, i + 5);
+  }
+
+  ASSERT_EQ(errors.size(), 24);
+  ASSERT_EQ(errors.countErrors(), 8);
+  ASSERT_TRUE(errors.hasError());
+  ASSERT_TRUE(errors.hasErrorAt(2));
+  ASSERT_TRUE(errors.hasErrorAt(5));
+  ASSERT_TRUE(errors.hasErrorAt(8));
+  ASSERT_TRUE(errors.hasErrorAt(11));
+  ASSERT_TRUE(errors.hasErrorAt(14));
+  ASSERT_TRUE(errors.hasErrorAt(17));
+  ASSERT_TRUE(errors.hasErrorAt(20));
+  ASSERT_TRUE(errors.hasErrorAt(23));
+}
+
+TEST_F(EvalErrorsTest, copyErrorWithDetails) {
+  EvalErrors other(pool(), 10);
+  for (auto i = 0; i < 20; i += 2) {
+    other.setError(i, makeVeloxException(fmt::format("Test error at {}", i)));
+  }
+
+  ASSERT_EQ(other.countErrors(), 10);
+
+  // Copy errors from rows 10 to 19. Shift destination row by 10 down: 0 to 9.
+  EvalErrors errors(pool(), 10);
+  for (auto i = 10; i < 30; ++i) {
+    errors.copyError(other, i, i - 10);
+  }
+
+  ASSERT_EQ(errors.size(), 10);
+  ASSERT_EQ(errors.countErrors(), 5);
+  ASSERT_TRUE(errors.hasError());
+
+  ASSERT_TRUE(errors.hasErrorAt(0));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(0), "Test error at 10");
+
+  ASSERT_TRUE(errors.hasErrorAt(2));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(2), "Test error at 12");
+
+  ASSERT_TRUE(errors.hasErrorAt(4));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(4), "Test error at 14");
+
+  ASSERT_TRUE(errors.hasErrorAt(6));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(6), "Test error at 16");
+
+  ASSERT_TRUE(errors.hasErrorAt(8));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(8), "Test error at 18");
+
+  // Copy one more error from row 0 to row 27.
+  errors.copyError(other, 0, 27);
+
+  ASSERT_EQ(errors.size(), 28);
+  ASSERT_EQ(errors.countErrors(), 6);
+  ASSERT_TRUE(errors.hasError());
+
+  ASSERT_TRUE(errors.hasErrorAt(27));
+  VELOX_ASSERT_THROW(errors.throwIfErrorAt(27), "Test error at 0");
+}
+
+TEST_F(EvalErrorsTest, copyErrors) {
+  EvalErrors other(pool(), 10);
+  for (auto i = 0; i < 20; i += 2) {
+    other.setError(i);
+  }
+
+  ASSERT_EQ(other.countErrors(), 10);
+
+  SelectivityVector rows(123, false);
+  rows.setValidRange(0, 5, true);
+  rows.setValidRange(10, 100, true);
+  rows.updateBounds();
+
+  EvalErrors errors(pool(), 10);
+  errors.copyErrors(rows, other);
+
+  ASSERT_EQ(errors.size(), 19);
+  ASSERT_EQ(errors.countErrors(), 8);
+  ASSERT_TRUE(errors.hasError());
+
+  ASSERT_TRUE(errors.hasErrorAt(0));
+  ASSERT_TRUE(errors.hasErrorAt(2));
+  ASSERT_TRUE(errors.hasErrorAt(4));
+  ASSERT_TRUE(errors.hasErrorAt(10));
+  ASSERT_TRUE(errors.hasErrorAt(12));
+  ASSERT_TRUE(errors.hasErrorAt(14));
+  ASSERT_TRUE(errors.hasErrorAt(16));
+  ASSERT_TRUE(errors.hasErrorAt(18));
+}
+
+TEST_F(EvalErrorsTest, copyAllErrors) {
+  EvalErrors other(pool(), 10);
+  for (auto i = 0; i < 20; i += 2) {
+    other.setError(i, makeVeloxException(fmt::format("Test error at {}", i)));
+  }
+
+  ASSERT_EQ(other.countErrors(), 10);
+
+  // Copy all errors from 'other' to this. Make sure pre-existing error doesn't
+  // get overwritten.
+  EvalErrors errors(pool(), 10);
+  errors.setError(4, makeVeloxException("Some other error"));
+  errors.copyErrors(other);
+
+  ASSERT_EQ(errors.size(), 19);
+  ASSERT_EQ(errors.countErrors(), 10);
+  ASSERT_TRUE(errors.hasError());
+
+  for (auto i = 0; i < 20; i += 2) {
+    ASSERT_TRUE(errors.hasErrorAt(i));
+    if (i == 4) {
+      VELOX_ASSERT_THROW(errors.throwIfErrorAt(i), "Some other error");
+    } else {
+      VELOX_ASSERT_THROW(
+          errors.throwIfErrorAt(i), fmt::format("Test error at {}", i));
+    }
+  }
+
+  for (auto i = 1; i < 20; i += 2) {
+    ASSERT_FALSE(errors.hasErrorAt(i));
+  }
+}
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/expression/tests/EvalSimplifiedTest.cpp b/velox/expression/tests/EvalSimplifiedTest.cpp
index 9d0cc6ea5ca22..9de2f57533d64 100644
--- a/velox/expression/tests/EvalSimplifiedTest.cpp
+++ b/velox/expression/tests/EvalSimplifiedTest.cpp
@@ -86,13 +86,13 @@ class EvalSimplifiedTest : public FunctionBaseTest {
 
     try {
       exprSetCommon.eval(rows, evalCtxCommon, commonEvalResult);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       exceptionCommonPtr = std::current_exception();
     }
 
     try {
       exprSetSimplified.eval(rows, evalCtxSimplified, simplifiedEvalResult);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       exceptionSimplifiedPtr = std::current_exception();
     }
 
@@ -212,6 +212,23 @@ TEST_F(EvalSimplifiedTest, dereference) {
   }
 }
 
+TEST_F(EvalSimplifiedTest, lambda) {
+  // filter(array, x -> x > 0).
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 0, -4, 3]",
+          "[-5, 0, -3, 1, 7]",
+      }),
+  });
+
+  SelectivityVector rows(data->size());
+  auto expr =
+      makeTypedExpr("filter(c0, x -> (x > 0))", asRowType(data->type()));
+  exec::ExprSet exprSetCommon({expr}, &execCtx_);
+  exec::ExprSetSimplified exprSetSimplified({expr}, &execCtx_);
+  compareEvals(exprSetCommon, exprSetSimplified, data, rows);
+}
+
 TEST_F(EvalSimplifiedTest, propagateNulls) {
   auto rowVector = makeRowVector({
       makeFlatVector<int64_t>({1, 2, 3}),
diff --git a/velox/expression/tests/ExprCompilerTest.cpp b/velox/expression/tests/ExprCompilerTest.cpp
index 9d187001d4685..e038c468e157c 100644
--- a/velox/expression/tests/ExprCompilerTest.cpp
+++ b/velox/expression/tests/ExprCompilerTest.cpp
@@ -16,6 +16,7 @@
 #include "gtest/gtest.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/Expr.h"
+#include "velox/expression/FieldReference.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/parse/Expressions.h"
@@ -28,12 +29,13 @@ namespace facebook::velox::exec::test {
 class ExprCompilerTest : public testing::Test,
                          public velox::test::VectorTestBase {
  protected:
-  void SetUp() override {
+  static void SetUpTestCase() {
+    parse::registerTypeResolver();
     functions::prestosql::registerAllScalarFunctions();
+    memory::MemoryManager::testingSetInstance({});
   }
 
-  static void SetUpTestCase() {
-    parse::registerTypeResolver();
+  void SetUp() override {
     functions::prestosql::registerAllScalarFunctions();
   }
 
@@ -100,7 +102,7 @@ class ExprCompilerTest : public testing::Test,
         std::vector<core::TypedExprPtr>{expr}, execCtx_.get());
   }
 
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
+  std::shared_ptr<core::QueryCtx> queryCtx_{velox::core::QueryCtx::create()};
   std::unique_ptr<core::ExecCtx> execCtx_{
       std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
 };
@@ -300,6 +302,59 @@ TEST_F(ExprCompilerTest, rewrites) {
           makeTypedExpr("c1 + 5", rowType),
       },
       execCtx_.get()));
+
+  auto exprSet = compile(makeTypedExpr(
+      "reduce(c0, 1, (s, x) -> s + x * 2, s -> s)",
+      ROW({"c0"}, {ARRAY(BIGINT())})));
+  ASSERT_EQ(exprSet->size(), 1);
+  ASSERT_EQ(
+      exprSet->expr(0)->toString(),
+      "plus(1:BIGINT, array_sum_propagate_element_null(transform(c0, (x) -> multiply(x, 2:BIGINT))))");
+
+  exprSet = compile(makeTypedExpr(
+      "reduce(c0, 1, (s, x) -> (s + 2) - x, s -> s)",
+      ROW({"c0"}, {ARRAY(BIGINT())})));
+  ASSERT_EQ(exprSet->size(), 1);
+  ASSERT_EQ(
+      exprSet->expr(0)->toString(),
+      "plus(1:BIGINT, array_sum_propagate_element_null(transform(c0, (x) -> minus(2:BIGINT, x))))");
+
+  exprSet = compile(makeTypedExpr(
+      "reduce(c0, 1, (s, x) -> if(x % 2 = 0, s + 3, s), s -> s)",
+      ROW({"c0"}, {ARRAY(BIGINT())})));
+  ASSERT_EQ(exprSet->size(), 1);
+  ASSERT_EQ(
+      exprSet->expr(0)->toString(),
+      "plus(1:BIGINT, array_sum_propagate_element_null(transform(c0, (x) -> switch(eq(mod(x, 2:BIGINT), 0:BIGINT), 3:BIGINT, 0:BIGINT))))");
+}
+
+TEST_F(ExprCompilerTest, eliminateUnnecessaryCast) {
+  auto exprSet =
+      compile(makeTypedExpr("cast(c0 as BIGINT)", ROW({{"c0", BIGINT()}})));
+  ASSERT_EQ(exprSet->size(), 1);
+  ASSERT_TRUE(dynamic_cast<const FieldReference*>(exprSet->expr(0).get()));
+}
+
+TEST_F(ExprCompilerTest, lambdaExpr) {
+  // Ensure that metadata computation correctly pulls in distinct fields from
+  // captured columns.
+
+  // Case 1: Standalone Expression
+  auto exprSet = compile(makeTypedExpr(
+      "find_first_index(c0, (x) -> (x = c1))",
+      ROW({"c0", "c1"}, {ARRAY(VARCHAR()), VARCHAR()})));
+  ASSERT_EQ(exprSet->size(), 1);
+  auto distinctFields = exprSet->expr(0)->distinctFields();
+  ASSERT_EQ(distinctFields.size(), 2);
+
+  // Case 2: Shared expression where the metadata is recomputed.
+  exprSet = compile(makeTypedExpr(
+      "if (find_first_index(c0, (x) -> (x = c1)) - 1 = 0, null::bigint, "
+      "find_first_index(c0, (x) -> (x = c1)) - 1)",
+      ROW({"c0", "c1"}, {ARRAY(VARCHAR()), VARCHAR()})));
+  ASSERT_EQ(exprSet->size(), 1);
+  distinctFields = exprSet->expr(0)->distinctFields();
+  ASSERT_EQ(distinctFields.size(), 2);
 }
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/expression/tests/ExprEncodingsTest.cpp b/velox/expression/tests/ExprEncodingsTest.cpp
index 9ca5ea7a712fd..7eb5b2e91d0c1 100644
--- a/velox/expression/tests/ExprEncodingsTest.cpp
+++ b/velox/expression/tests/ExprEncodingsTest.cpp
@@ -127,6 +127,10 @@ class ExprEncodingsTest
     : public testing::TestWithParam<std::tuple<int, int, bool>>,
       public VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
     // This test throws a lot of exceptions, so turn off stack trace capturing.
     FLAGS_velox_exception_user_stacktrace_enabled = false;
@@ -409,12 +413,12 @@ class ExprEncodingsTest
   void runWithError(const std::string& text) {
     exec::ExprSet exprs({parseExpression(text, testDataType_)}, execCtx_.get());
     auto row = testDataRow();
-    exec::EvalCtx context(execCtx_.get(), &exprs, row.get());
     auto size = row->size();
 
     vector_size_t begin = 0;
     vector_size_t end = size / 3 * 2;
     {
+      exec::EvalCtx context(execCtx_.get(), &exprs, row.get());
       auto rows = selectRange(begin, end);
       std::vector<VectorPtr> result(1);
 
@@ -426,6 +430,7 @@ class ExprEncodingsTest
     begin = size / 3;
     end = size;
     {
+      exec::EvalCtx context(execCtx_.get(), &exprs, row.get());
       auto rows = selectRange(begin, end);
       std::vector<VectorPtr> result(1);
 
@@ -484,7 +489,7 @@ class ExprEncodingsTest
         makeLazyVector);
   }
 
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
+  std::shared_ptr<core::QueryCtx> queryCtx_{velox::core::QueryCtx::create()};
   std::unique_ptr<core::ExecCtx> execCtx_{
       std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
   TestData testData_;
diff --git a/velox/expression/tests/ExprStatsTest.cpp b/velox/expression/tests/ExprStatsTest.cpp
index 810bc8867aa93..70394b4ce9176 100644
--- a/velox/expression/tests/ExprStatsTest.cpp
+++ b/velox/expression/tests/ExprStatsTest.cpp
@@ -158,10 +158,8 @@ struct Event {
 
 class TestListener : public exec::ExprSetListener {
  public:
-  explicit TestListener(
-      std::vector<Event>& events,
-      std::vector<std::string>& exceptions)
-      : events_{events}, exceptions_{exceptions}, exceptionCount_{0} {}
+  explicit TestListener(std::vector<Event>& events)
+      : events_{events}, exceptionCount_{0} {}
 
   void onCompletion(
       const std::string& uuid,
@@ -169,21 +167,8 @@ class TestListener : public exec::ExprSetListener {
     events_.push_back({uuid, event.stats, event.sqls});
   }
 
-  void onError(
-      const SelectivityVector& rows,
-      const ::facebook::velox::ErrorVector& errors,
-      const std::string& /*queryId*/) override {
-    rows.applyToSelected([&](auto row) {
-      exceptionCount_++;
-
-      try {
-        auto exception =
-            *std::static_pointer_cast<std::exception_ptr>(errors.valueAt(row));
-        std::rethrow_exception(exception);
-      } catch (const std::exception& e) {
-        exceptions_.push_back(e.what());
-      }
-    });
+  void onError(vector_size_t numRows, const std::string& /*queryId*/) override {
+    exceptionCount_ += numRows;
   }
 
   int exceptionCount() const {
@@ -193,12 +178,10 @@ class TestListener : public exec::ExprSetListener {
   void reset() {
     exceptionCount_ = 0;
     events_.clear();
-    exceptions_.clear();
   }
 
  private:
   std::vector<Event>& events_;
-  std::vector<std::string>& exceptions_;
   int exceptionCount_;
 };
 
@@ -207,8 +190,7 @@ TEST_F(ExprStatsTest, listener) {
 
   // Register a listener to receive stats on ExprSet destruction.
   std::vector<Event> events;
-  std::vector<std::string> exceptions;
-  auto listener = std::make_shared<TestListener>(events, exceptions);
+  auto listener = std::make_shared<TestListener>(events);
   ASSERT_TRUE(exec::registerExprSetListener(listener));
   ASSERT_FALSE(exec::registerExprSetListener(listener));
 
@@ -308,8 +290,7 @@ TEST_F(ExprStatsTest, specialForms) {
 
   // Register a listener to receive stats on ExprSet destruction.
   std::vector<Event> events;
-  std::vector<std::string> exceptions;
-  auto listener = std::make_shared<TestListener>(events, exceptions);
+  auto listener = std::make_shared<TestListener>(events);
   ASSERT_TRUE(exec::registerExprSetListener(listener));
 
   auto data = makeRowVector({
@@ -367,8 +348,7 @@ TEST_F(ExprStatsTest, specialForms) {
 TEST_F(ExprStatsTest, errorLog) {
   // Register a listener to log exceptions.
   std::vector<Event> events;
-  std::vector<std::string> exceptions;
-  auto listener = std::make_shared<TestListener>(events, exceptions);
+  auto listener = std::make_shared<TestListener>(events);
   ASSERT_TRUE(exec::registerExprSetListener(listener));
 
   auto data = makeRowVector(
@@ -386,14 +366,6 @@ TEST_F(ExprStatsTest, errorLog) {
 
   // Expect errors at rows 2 and 4.
   ASSERT_EQ(2, listener->exceptionCount());
-  ASSERT_EQ(2, exceptions.size());
-  for (const auto& exception : exceptions) {
-    ASSERT_TRUE(
-        exception.find("Context: cast((c0) as INTEGER)") != std::string::npos);
-    ASSERT_TRUE(
-        exception.find("Error Code: INVALID_ARGUMENT") != std::string::npos);
-    ASSERT_TRUE(exception.find("Stack trace:") != std::string::npos);
-  }
 
   // Test with multiple try expressions. Expect errors at rows 1, 2, 4, and 6.
   // The second row in c1 does not cause an additional error because the
@@ -405,7 +377,6 @@ TEST_F(ExprStatsTest, errorLog) {
 
   evaluate(*exprSet, data);
   ASSERT_EQ(4, listener->exceptionCount());
-  ASSERT_EQ(4, exceptions.size());
 
   // Test with nested try expressions. Expect errors at rows 2, 3, 4, and 6. Row
   // 5 in c2 does not cause an error because the corresponding row in c0 is
@@ -416,15 +387,6 @@ TEST_F(ExprStatsTest, errorLog) {
 
   evaluate(*exprSet, data);
   ASSERT_EQ(4, listener->exceptionCount());
-  ASSERT_EQ(4, exceptions.size());
-  ASSERT_TRUE(
-      exceptions[0].find("Error Code: INVALID_ARGUMENT") != std::string::npos);
-  ASSERT_TRUE(
-      exceptions[1].find("Error Code: INVALID_ARGUMENT") != std::string::npos);
-  ASSERT_TRUE(
-      exceptions[2].find("Error Code: ARITHMETIC_ERROR") != std::string::npos);
-  ASSERT_TRUE(
-      exceptions[3].find("Error Code: ARITHMETIC_ERROR") != std::string::npos);
 
   // Test with no error.
   listener->reset();
@@ -432,28 +394,32 @@ TEST_F(ExprStatsTest, errorLog) {
 
   evaluate(*exprSet, data);
   ASSERT_EQ(0, listener->exceptionCount());
-  ASSERT_EQ(0, exceptions.size());
 
   ASSERT_TRUE(exec::unregisterExprSetListener(listener));
 }
 
-TEST_F(ExprStatsTest, exceptionPreparingStatsForListener) {
-  // Currently a ConstantExpr of VARBINARY type does not support generating
-  // its sql form. Therefore, it throws an exception when ExprSet tries to
-  // generate its sql while preparing data for listeners in its destructor.
-  // This test replicates this scenario and ensures that the exception is
-  // handled and the process is not terminated.
+TEST_F(ExprStatsTest, complexConstants) {
+  // Expressions with constants of types not expressible in SQL should use
+  // '__complex_constant(c#)' pseudo functions.
+
   std::vector<Event> events;
-  std::vector<std::string> exceptions;
-  auto listener = std::make_shared<TestListener>(events, exceptions);
+  auto listener = std::make_shared<TestListener>(events);
   ASSERT_TRUE(exec::registerExprSetListener(listener));
-  auto varbinaryData = vectorMaker_.flatVector<StringView>(
-      {"12"_sv}, CppToType<Varbinary>::create());
+
   std::vector<core::TypedExprPtr> expressions = {
       std::make_shared<const core::ConstantTypedExpr>(
-          BaseVector::wrapInConstant(1, 0, varbinaryData))};
-  auto exprSet =
-      std::make_unique<exec::ExprSet>(std::move(expressions), &execCtx_);
-  evaluate(*exprSet, makeRowVector({varbinaryData}));
+          makeConstant("12"_sv, 1, VARBINARY()))};
+  {
+    auto exprSet =
+        std::make_unique<exec::ExprSet>(std::move(expressions), &execCtx_);
+    evaluate(*exprSet, makeRowVector(ROW({}), 10));
+  }
+
+  ASSERT_EQ(1, events.size());
+  ASSERT_EQ(0, listener->exceptionCount());
+
+  ASSERT_EQ(1, events[0].sqls.size());
+  ASSERT_EQ("__complex_constant(c0)", events[0].sqls[0]);
+
   ASSERT_TRUE(exec::unregisterExprSetListener(listener));
 }
diff --git a/velox/expression/tests/ExprTest.cpp b/velox/expression/tests/ExprTest.cpp
index 7fde123db500e..38738a315c6bf 100644
--- a/velox/expression/tests/ExprTest.cpp
+++ b/velox/expression/tests/ExprTest.cpp
@@ -33,6 +33,7 @@
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
@@ -45,6 +46,10 @@ namespace facebook::velox::test {
 namespace {
 class ExprTest : public testing::Test, public VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
     functions::prestosql::registerAllScalarFunctions();
     parse::registerTypeResolver();
@@ -52,9 +57,11 @@ class ExprTest : public testing::Test, public VectorTestBase {
 
   core::TypedExprPtr parseExpression(
       const std::string& text,
-      const RowTypePtr& rowType) {
+      const RowTypePtr& rowType,
+      const VectorPtr& complexConstants = nullptr) {
     auto untyped = parse::parseExpr(text, options_);
-    return core::Expressions::inferTypes(untyped, rowType, execCtx_->pool());
+    return core::Expressions::inferTypes(
+        untyped, rowType, execCtx_->pool(), complexConstants);
   }
 
   core::TypedExprPtr parseExpression(
@@ -89,11 +96,29 @@ class ExprTest : public testing::Test, public VectorTestBase {
   template <typename T = exec::ExprSet>
   std::unique_ptr<T> compileExpression(
       const std::string& expr,
-      const RowTypePtr& rowType) {
-    auto parsedExpression = parseExpression(expr, rowType);
+      const RowTypePtr& rowType,
+      const VectorPtr& complexConstants = nullptr) {
+    auto parsedExpression = parseExpression(expr, rowType, complexConstants);
     return compileExpression<T>(parsedExpression);
   }
 
+  std::unique_ptr<exec::ExprSet> compileNoConstantFolding(
+      const std::string& sql,
+      const RowTypePtr& rowType,
+      const VectorPtr& complexConstants = nullptr) {
+    auto expression = parseExpression(sql, rowType, complexConstants);
+    return compileNoConstantFolding(expression);
+  }
+
+  std::unique_ptr<exec::ExprSet> compileNoConstantFolding(
+      const core::TypedExprPtr& expression) {
+    std::vector<core::TypedExprPtr> expressions = {expression};
+    return std::make_unique<exec::ExprSet>(
+        std::move(expressions),
+        execCtx_.get(),
+        false /*enableConstantFolding*/);
+  }
+
   std::unique_ptr<exec::ExprSet> compileMultiple(
       const std::vector<std::string>& texts,
       const RowTypePtr& rowType) {
@@ -120,10 +145,12 @@ class ExprTest : public testing::Test, public VectorTestBase {
   std::vector<VectorPtr> evaluateMultiple(
       const std::vector<std::string>& texts,
       const RowVectorPtr& input,
-      const std::optional<SelectivityVector>& rows = std::nullopt) {
+      const std::optional<SelectivityVector>& rows = std::nullopt,
+      core::ExecCtx* execCtx = nullptr) {
     auto exprSet = compileMultiple(texts, asRowType(input->type()));
 
-    exec::EvalCtx context(execCtx_.get(), exprSet.get(), input.get());
+    exec::EvalCtx context(
+        execCtx ? execCtx : execCtx_.get(), exprSet.get(), input.get());
     std::vector<VectorPtr> result(texts.size());
     if (rows.has_value()) {
       exprSet->eval(*rows, context, result);
@@ -139,10 +166,12 @@ class ExprTest : public testing::Test, public VectorTestBase {
   evaluateMultipleWithStats(
       const std::vector<std::string>& texts,
       const RowVectorPtr& input,
-      std::vector<VectorPtr> resultToReuse = {}) {
+      std::vector<VectorPtr> resultToReuse = {},
+      core::ExecCtx* execCtx = nullptr) {
     auto exprSet = compileMultiple(texts, asRowType(input->type()));
 
-    exec::EvalCtx context(execCtx_.get(), exprSet.get(), input.get());
+    exec::EvalCtx context(
+        execCtx ? execCtx : execCtx_.get(), exprSet.get(), input.get());
 
     SelectivityVector rows(input->size());
     if (resultToReuse.empty()) {
@@ -159,14 +188,22 @@ class ExprTest : public testing::Test, public VectorTestBase {
   std::pair<VectorPtr, std::unordered_map<std::string, exec::ExprStats>>
   evaluateWithStats(const std::string& expression, const RowVectorPtr& input) {
     auto exprSet = compileExpression(expression, asRowType(input->type()));
+    return evaluateWithStats(exprSet.get(), input);
+  }
 
+  std::pair<VectorPtr, std::unordered_map<std::string, exec::ExprStats>>
+  evaluateWithStats(
+      exec::ExprSet* exprSetPtr,
+      const RowVectorPtr& input,
+      core::ExecCtx* execCtx = nullptr) {
     SelectivityVector rows(input->size());
     std::vector<VectorPtr> results(1);
 
-    exec::EvalCtx context(execCtx_.get(), exprSet.get(), input.get());
-    exprSet->eval(rows, context, results);
+    exec::EvalCtx context(
+        execCtx ? execCtx : execCtx_.get(), exprSetPtr, input.get());
+    exprSetPtr->eval(rows, context, results);
 
-    return {results[0], exprSet->stats()};
+    return {results[0], exprSetPtr->stats()};
   }
 
   template <
@@ -220,41 +257,6 @@ class ExprTest : public testing::Test, public VectorTestBase {
         valueType, std::move(value));
   }
 
-  // Create LazyVector that produces a flat vector and asserts that is is being
-  // loaded for a specific set of rows.
-  template <typename T>
-  std::shared_ptr<LazyVector> makeLazyFlatVector(
-      vector_size_t size,
-      std::function<T(vector_size_t /*row*/)> valueAt,
-      std::function<bool(vector_size_t /*row*/)> isNullAt,
-      vector_size_t expectedSize,
-      const std::function<vector_size_t(vector_size_t /*index*/)>&
-          expectedRowAt) {
-    return std::make_shared<LazyVector>(
-        execCtx_->pool(),
-        CppToType<T>::create(),
-        size,
-        std::make_unique<SimpleVectorLoader>([=](RowSet rows) {
-          VELOX_CHECK_EQ(rows.size(), expectedSize);
-          for (auto i = 0; i < rows.size(); i++) {
-            VELOX_CHECK_EQ(rows[i], expectedRowAt(i));
-          }
-          return makeFlatVector<T>(size, valueAt, isNullAt);
-        }));
-  }
-
-  VectorPtr wrapInLazyDictionary(VectorPtr vector) {
-    return std::make_shared<LazyVector>(
-        execCtx_->pool(),
-        vector->type(),
-        vector->size(),
-        std::make_unique<SimpleVectorLoader>([=](RowSet /*rows*/) {
-          auto indices =
-              makeIndices(vector->size(), [](auto row) { return row; });
-          return wrapInDictionary(indices, vector->size(), vector);
-        }));
-  }
-
   /// Remove ". Input data: .*" from the 'context'.
   std::string trimInputPath(const std::string& context) {
     auto pos = context.find(". Input data: ");
@@ -271,7 +273,7 @@ class ExprTest : public testing::Test, public VectorTestBase {
     VELOX_CHECK(startPos != std::string::npos);
     startPos += strlen(key);
     auto endPos = context.find(".", startPos);
-    VELOX_CHECK(endPos != std::string::npos);
+    VELOX_CHECK(endPos != std::string::npos, context);
     return context.substr(startPos, endPos - startPos);
   }
 
@@ -302,15 +304,16 @@ class ExprTest : public testing::Test, public VectorTestBase {
   }
 
   void verifyDataAndSqlPaths(const VeloxException& e, const VectorPtr& data) {
-    auto inputPath = extractInputPath(e.topLevelContext());
+    auto inputPath = extractInputPath(e.additionalContext());
     auto copy = restoreVector(inputPath);
     assertEqualVectors(data, copy);
 
-    auto sqlPath = extractSqlPath(e.topLevelContext());
+    auto sqlPath = extractSqlPath(e.additionalContext());
     auto sql = readSqlFromFile(sqlPath);
     ASSERT_NO_THROW(compileExpression(sql, asRowType(data->type())));
 
-    auto allSqlsPath = extractAllExprSqlPath(e.topLevelContext());
+    LOG(ERROR) << e.additionalContext();
+    auto allSqlsPath = extractAllExprSqlPath(e.additionalContext());
     auto allSqls = readSqlFromFile(allSqlsPath);
     ASSERT_NO_THROW(compileMultipleExprs(allSqls, asRowType(data->type())));
   }
@@ -338,20 +341,22 @@ class ExprTest : public testing::Test, public VectorTestBase {
     return sql;
   }
 
-  void assertError(
+  std::exception_ptr assertError(
       const std::string& expression,
       const VectorPtr& input,
       const std::string& context,
-      const std::string& topLevelContext,
+      const std::string& additionalContext,
       const std::string& message) {
     try {
       evaluate(expression, makeRowVector({input}));
-      ASSERT_TRUE(false) << "Expected an error";
+      EXPECT_TRUE(false) << "Expected an error";
     } catch (VeloxException& e) {
-      ASSERT_EQ(message, e.message());
-      ASSERT_EQ(context, trimInputPath(e.context()));
-      ASSERT_EQ(topLevelContext, trimInputPath(e.topLevelContext()));
+      EXPECT_EQ(context, trimInputPath(e.context()));
+      EXPECT_EQ(additionalContext, trimInputPath(e.additionalContext()));
+      EXPECT_EQ(message, e.message());
+      return e.wrappedException();
     }
+    return nullptr;
   }
 
   void assertErrorSimplified(
@@ -373,14 +378,14 @@ class ExprTest : public testing::Test, public VectorTestBase {
       const std::string& expression,
       const VectorPtr& input,
       const std::string& context,
-      const std::string& topLevelContext,
+      const std::string& additionalContext,
       const std::string& message) {
     try {
       evaluate(expression, makeRowVector({input}));
       EXPECT_TRUE(false) << "Expected an error";
     } catch (VeloxException& e) {
       EXPECT_EQ(context, trimInputPath(e.context()));
-      EXPECT_EQ(topLevelContext, trimInputPath(e.topLevelContext()));
+      EXPECT_EQ(additionalContext, trimInputPath(e.additionalContext()));
       EXPECT_EQ(message, e.message());
       return e.wrappedException();
     }
@@ -402,7 +407,7 @@ class ExprTest : public testing::Test, public VectorTestBase {
     return exprSet.exprs().front()->propagatesNulls();
   }
 
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
+  std::shared_ptr<core::QueryCtx> queryCtx_{velox::core::QueryCtx::create()};
   std::unique_ptr<core::ExecCtx> execCtx_{
       std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
   parse::ParseOptions options_;
@@ -415,7 +420,7 @@ class ParameterizedExprTest : public ExprTest,
     std::unordered_map<std::string, std::string> configData(
         {{core::QueryConfig::kEnableExpressionEvaluationCache,
           GetParam() ? "true" : "false"}});
-    queryCtx_ = std::make_shared<core::QueryCtx>(
+    queryCtx_ = velox::core::QueryCtx::create(
         nullptr, core::QueryConfig(std::move(configData)));
     execCtx_ = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get());
   }
@@ -795,8 +800,8 @@ TEST_P(ParameterizedExprTest, dictionaryAndConstantOverLazy) {
   auto row = makeRowVector({lazyVector});
   auto result = evaluate("plus5(c0)", row);
 
-  auto expected = makeFlatVector<int32_t>(
-      size, [](auto row) { return row + 5; }, isNullAt);
+  auto expected =
+      makeFlatVector<int32_t>(size, [](auto row) { return row + 5; }, isNullAt);
   assertEqualVectors(expected, result);
 
   // Wrap LazyVector in a dictionary (select only even rows).
@@ -854,10 +859,6 @@ namespace {
 // f(n) = n + rand() - non-deterministict function with a single argument
 class PlusRandomIntegerFunction : public exec::VectorFunction {
  public:
-  bool isDeterministic() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -890,15 +891,20 @@ class PlusRandomIntegerFunction : public exec::VectorFunction {
                 .build()};
   }
 };
+
+void registerPlusRandomIntegerFunction() {
+  exec::registerVectorFunction(
+      "plus_random",
+      PlusRandomIntegerFunction::signatures(),
+      std::make_unique<PlusRandomIntegerFunction>(),
+      exec::VectorFunctionMetadataBuilder().deterministic(false).build());
+}
 } // namespace
 
 // Test evaluating single-argument non-deterministic vector function on
 // constant vector. The function must be called on each row, not just one.
 TEST_P(ParameterizedExprTest, nonDeterministicVectorFunctionOnConstantInput) {
-  exec::registerVectorFunction(
-      "plus_random",
-      PlusRandomIntegerFunction::signatures(),
-      std::make_unique<PlusRandomIntegerFunction>());
+  registerPlusRandomIntegerFunction();
 
   const vector_size_t size = 1'000;
   auto row = makeRowVector({makeConstant(10, size)});
@@ -913,10 +919,7 @@ TEST_P(ParameterizedExprTest, nonDeterministicVectorFunctionOnConstantInput) {
 
 // Verify constant folding doesn't apply to non-deterministic functions.
 TEST_P(ParameterizedExprTest, nonDeterministicConstantFolding) {
-  exec::registerVectorFunction(
-      "plus_random",
-      PlusRandomIntegerFunction::signatures(),
-      std::make_unique<PlusRandomIntegerFunction>());
+  registerPlusRandomIntegerFunction();
 
   const vector_size_t size = 1'000;
   auto emptyRow = makeRowVector(ROW({}), size);
@@ -1191,8 +1194,8 @@ TEST_P(ParameterizedExprTest, lazyVectors) {
 
   auto result = evaluate("c0 + coalesce(c0, 1)", row);
 
-  auto expected = makeFlatVector<int64_t>(
-      size, [](auto row) { return row * 2; }, nullptr);
+  auto expected =
+      makeFlatVector<int64_t>(size, [](auto row) { return row * 2; }, nullptr);
   assertEqualVectors(expected, result);
 
   // Make LazyVector with nulls
@@ -1202,8 +1205,8 @@ TEST_P(ParameterizedExprTest, lazyVectors) {
 
   result = evaluate("c0 + coalesce(c0, 1)", row);
 
-  expected = makeFlatVector<int64_t>(
-      size, [](auto row) { return row * 2; }, isNullAt);
+  expected =
+      makeFlatVector<int64_t>(size, [](auto row) { return row * 2; }, isNullAt);
   assertEqualVectors(expected, result);
 }
 
@@ -1427,8 +1430,7 @@ class StatefulVectorFunction : public exec::VectorFunction {
     return {exec::FunctionSignatureBuilder()
                 .typeVariable("T")
                 .returnType("integer")
-                .argumentType("T")
-                .variableArity()
+                .variableArity("T")
                 .build()};
   }
 
@@ -1847,10 +1849,6 @@ namespace {
 // Returns the first value of the argument vector wrapped as a constant.
 class TestingConstantFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -1875,10 +1873,6 @@ class TestingConstantFunction : public exec::VectorFunction {
 // vector and indices from the second.
 class TestingDictionaryFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -1929,14 +1923,17 @@ class TestingSingleArgDeterministicFunction : public exec::VectorFunction {
 };
 
 } // namespace
-VELOX_DECLARE_VECTOR_FUNCTION(
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_testing_constant,
     TestingConstantFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<TestingConstantFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_testing_dictionary,
     TestingDictionaryFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<TestingDictionaryFunction>());
 
 VELOX_DECLARE_VECTOR_FUNCTION(
@@ -2008,7 +2005,7 @@ class NullArrayFunction : public exec::VectorFunction {
       VectorPtr& result) const override {
     // This function returns a vector of all nulls
     BaseVector::ensureWritable(rows, ARRAY(VARCHAR()), context.pool(), result);
-    result->addNulls(nullptr, rows);
+    result->addNulls(rows);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -2016,8 +2013,7 @@ class NullArrayFunction : public exec::VectorFunction {
     return {exec::FunctionSignatureBuilder()
                 .typeVariable("T")
                 .returnType("array(varchar)")
-                .argumentType("T")
-                .variableArity()
+                .variableArity("T")
                 .build()};
   }
 };
@@ -2097,7 +2093,10 @@ TEST_P(ParameterizedExprTest, rewriteInputs) {
   }
 }
 
-TEST_P(ParameterizedExprTest, memo) {
+TEST_F(ExprTest, memo) {
+  // Verify that dictionary memoization
+  // 1. correctly evaluates the unevaluated rows on subsequent runs
+  // 2. Only caches results if it encounters the same base twice
   auto base = makeArrayVector<int64_t>(
       1'000,
       [](auto row) { return row % 5 + 1; },
@@ -2109,24 +2108,55 @@ TEST_P(ParameterizedExprTest, memo) {
   auto rowType = ROW({"c0"}, {base->type()});
   auto exprSet = compileExpression("c0[1] = 1", rowType);
 
-  auto result = evaluate(
+  auto [result, stats] = evaluateWithStats(
       exprSet.get(), makeRowVector({wrapInDictionary(evenIndices, 100, base)}));
   auto expectedResult = makeFlatVector<bool>(
       100, [](auto row) { return (8 + row * 2) % 3 == 1; });
   assertEqualVectors(expectedResult, result);
+  VELOX_CHECK_EQ(stats["eq"].numProcessedRows, 100);
+  VELOX_CHECK(base.unique());
 
-  result = evaluate(
+  // After this results would be cached
+  std::tie(result, stats) = evaluateWithStats(
+      exprSet.get(), makeRowVector({wrapInDictionary(evenIndices, 100, base)}));
+  assertEqualVectors(expectedResult, result);
+  VELOX_CHECK_EQ(stats["eq"].numProcessedRows, 200);
+  VELOX_CHECK(!base.unique());
+
+  // Unevaluated rows are processed
+  std::tie(result, stats) = evaluateWithStats(
       exprSet.get(), makeRowVector({wrapInDictionary(oddIndices, 100, base)}));
   expectedResult = makeFlatVector<bool>(
       100, [](auto row) { return (9 + row * 2) % 3 == 1; });
   assertEqualVectors(expectedResult, result);
+  VELOX_CHECK_EQ(stats["eq"].numProcessedRows, 300);
+  VELOX_CHECK(!base.unique());
 
   auto everyFifth = makeIndices(100, [](auto row) { return row * 5; });
-  result = evaluate(
+  std::tie(result, stats) = evaluateWithStats(
       exprSet.get(), makeRowVector({wrapInDictionary(everyFifth, 100, base)}));
   expectedResult =
       makeFlatVector<bool>(100, [](auto row) { return (row * 5) % 3 == 1; });
   assertEqualVectors(expectedResult, result);
+  VELOX_CHECK_EQ(
+      stats["eq"].numProcessedRows,
+      360,
+      "Fewer rows expected as memoization should have kicked in.");
+  VELOX_CHECK(!base.unique());
+
+  // Create a new base
+  base = makeArrayVector<int64_t>(
+      1'000,
+      [](auto row) { return row % 5 + 1; },
+      [](auto row, auto index) { return (row % 3) + index; });
+
+  std::tie(result, stats) = evaluateWithStats(
+      exprSet.get(), makeRowVector({wrapInDictionary(oddIndices, 100, base)}));
+  expectedResult = makeFlatVector<bool>(
+      100, [](auto row) { return (9 + row * 2) % 3 == 1; });
+  assertEqualVectors(expectedResult, result);
+  VELOX_CHECK_EQ(stats["eq"].numProcessedRows, 460);
+  VELOX_CHECK(base.unique());
 }
 
 // This test triggers the situation when peelEncodings() produces an empty
@@ -2387,7 +2417,9 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
     FAIL() << "Expected an exception";
   } catch (const VeloxException& e) {
     ASSERT_EQ("always_throws(c0)", e.context());
-    ASSERT_EQ("plus(always_throws(c0), c1)", e.topLevelContext());
+    ASSERT_EQ(
+        "Top-level Expression: plus(always_throws(c0), c1)",
+        e.additionalContext());
   }
 
   try {
@@ -2396,8 +2428,8 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT)", e.context());
     ASSERT_EQ(
-        "plus(cast((c0) as BIGINT), mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT))",
-        e.topLevelContext());
+        "Top-level Expression: plus(cast((c0) as BIGINT), mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT))",
+        e.additionalContext());
   }
 
   try {
@@ -2406,14 +2438,14 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("mod(cast((c1) as BIGINT), 0:BIGINT)", e.context());
     ASSERT_EQ(
-        "plus(cast((c0) as BIGINT), mod(cast((c1) as BIGINT), 0:BIGINT))",
-        e.topLevelContext());
+        "Top-level Expression: plus(cast((c0) as BIGINT), mod(cast((c1) as BIGINT), 0:BIGINT))",
+        e.additionalContext());
   }
 
   // Enable saving vector and expression SQL for system errors only.
   auto tempDirectory = exec::test::TempDirectoryPath::create();
   FLAGS_velox_save_input_on_expression_system_failure_path =
-      tempDirectory->path;
+      tempDirectory->getPath();
 
   try {
     evaluate("runtime_error(c0) + c1", data);
@@ -2421,7 +2453,8 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("runtime_error(c0)", e.context());
     ASSERT_EQ(
-        "plus(runtime_error(c0), c1)", trimInputPath(e.topLevelContext()));
+        "Top-level Expression: plus(runtime_error(c0), c1)",
+        trimInputPath(e.additionalContext()));
     verifyDataAndSqlPaths(e, data);
   }
 
@@ -2431,8 +2464,8 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT)", e.context());
     ASSERT_EQ(
-        "plus(cast((c0) as BIGINT), mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT))",
-        e.topLevelContext())
+        "Top-level Expression: plus(cast((c0) as BIGINT), mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT))",
+        e.additionalContext())
         << e.errorSource();
   }
 
@@ -2442,12 +2475,13 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT)", e.context());
     ASSERT_EQ(
-        "plus(cast((c0) as BIGINT), mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT))",
-        e.topLevelContext());
+        "Top-level Expression: plus(cast((c0) as BIGINT), mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT))",
+        e.additionalContext());
   }
 
   // Enable saving vector and expression SQL for all errors.
-  FLAGS_velox_save_input_on_expression_any_failure_path = tempDirectory->path;
+  FLAGS_velox_save_input_on_expression_any_failure_path =
+      tempDirectory->getPath();
   FLAGS_velox_save_input_on_expression_system_failure_path = "";
 
   try {
@@ -2456,7 +2490,8 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("always_throws(c0)", e.context());
     ASSERT_EQ(
-        "plus(always_throws(c0), c1)", trimInputPath(e.topLevelContext()));
+        "Top-level Expression: plus(always_throws(c0), c1)",
+        trimInputPath(e.additionalContext()));
     verifyDataAndSqlPaths(e, data);
   }
 
@@ -2466,8 +2501,8 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT)", e.context());
     ASSERT_EQ(
-        "plus(cast((c0) as BIGINT), mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT))",
-        trimInputPath(e.topLevelContext()));
+        "Top-level Expression: plus(cast((c0) as BIGINT), mod(cast((plus(c0, c1)) as BIGINT), 0:BIGINT))",
+        trimInputPath(e.additionalContext()));
     verifyDataAndSqlPaths(e, data);
   }
 
@@ -2477,8 +2512,8 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("mod(cast((c1) as BIGINT), 0:BIGINT)", e.context());
     ASSERT_EQ(
-        "plus(cast((c0) as BIGINT), mod(cast((c1) as BIGINT), 0:BIGINT))",
-        trimInputPath(e.topLevelContext()));
+        "Top-level Expression: plus(cast((c0) as BIGINT), mod(cast((c1) as BIGINT), 0:BIGINT))",
+        trimInputPath(e.additionalContext()));
     verifyDataAndSqlPaths(e, data);
   }
 
@@ -2488,8 +2523,8 @@ TEST_P(ParameterizedExprTest, exceptionContext) {
   } catch (const VeloxException& e) {
     ASSERT_EQ("mod(cast((c1) as BIGINT), 0:BIGINT)", e.context());
     ASSERT_EQ(
-        "plus(cast((c0) as BIGINT), mod(cast((c1) as BIGINT), 0:BIGINT))",
-        trimInputPath(e.topLevelContext()));
+        "Top-level Expression: plus(cast((c0) as BIGINT), mod(cast((c1) as BIGINT), 0:BIGINT))",
+        trimInputPath(e.additionalContext()));
     verifyDataAndSqlPaths(e, data);
   }
 }
@@ -2512,19 +2547,19 @@ TEST_P(ParameterizedExprTest, stdExceptionContext) {
   registerFunction<AlwaysThrowsStdExceptionFunction, int64_t, int64_t>(
       {"throw_invalid_argument"});
 
-  auto wrappedEx = assertWrappedException(
+  auto wrappedEx = assertError(
       "throw_invalid_argument(c0) + 5",
       data,
       "throw_invalid_argument(c0)",
-      "plus(throw_invalid_argument(c0), 5:BIGINT)",
+      "Top-level Expression: plus(throw_invalid_argument(c0), 5:BIGINT)",
       "This is a test");
   ASSERT_THROW(std::rethrow_exception(wrappedEx), std::invalid_argument);
 
-  wrappedEx = assertWrappedException(
+  wrappedEx = assertError(
       "throw_invalid_argument(c0 + 5)",
       data,
-      "throw_invalid_argument(plus(c0, 5:BIGINT))",
-      "Same as context.",
+      "Top-level Expression: throw_invalid_argument(plus(c0, 5:BIGINT))",
+      "",
       "This is a test");
   ASSERT_THROW(std::rethrow_exception(wrappedEx), std::invalid_argument);
 }
@@ -2616,14 +2651,24 @@ TEST_P(ParameterizedExprTest, constantToSql) {
   ASSERT_EQ(toSql(18'506, DATE()), "'2020-09-01'::DATE");
   ASSERT_EQ(toSql(variant::null(TypeKind::INTEGER), DATE()), "NULL::DATE");
 
+  ASSERT_EQ(toSql(2134456LL, DECIMAL(18, 2)), "'21344.56'::DECIMAL(18, 2)");
+  ASSERT_EQ(
+      toSql(variant::null(TypeKind::BIGINT), DECIMAL(18, 2)),
+      "NULL::DECIMAL(18, 2)");
+  ASSERT_EQ(
+      toSql((int128_t)1'000'000'000'000'000'000, DECIMAL(38, 2)),
+      "'10000000000000000.00'::DECIMAL(38, 2)");
+  ASSERT_EQ(
+      toSql(variant::null(TypeKind::HUGEINT), DECIMAL(38, 2)),
+      "NULL::DECIMAL(38, 2)");
+
   ASSERT_EQ(
       toSql(Timestamp(123'456, 123'000)),
-      "'1970-01-02T10:17:36.000123000'::TIMESTAMP");
+      "'1970-01-02 10:17:36.000123000'::TIMESTAMP");
   ASSERT_EQ(toSql(variant::null(TypeKind::TIMESTAMP)), "NULL::TIMESTAMP");
 
   ASSERT_EQ(
-      toSql(123'456LL, INTERVAL_DAY_TIME()),
-      "'123456'::INTERVAL DAY TO SECOND");
+      toSql(123'456LL, INTERVAL_DAY_TIME()), "INTERVAL 123456 MILLISECOND");
   ASSERT_EQ(
       toSql(variant::null(TypeKind::BIGINT), INTERVAL_DAY_TIME()),
       "NULL::INTERVAL DAY TO SECOND");
@@ -2694,6 +2739,45 @@ TEST_P(ParameterizedExprTest, constantToSql) {
       toSqlComplex(BaseVector::createNullConstant(
           ROW({"a", "b"}, {BOOLEAN(), DOUBLE()}), 10, pool())),
       "NULL::STRUCT(a BOOLEAN, b DOUBLE)");
+  ASSERT_EQ(
+      toSqlComplex(BaseVector::createNullConstant(
+          ROW({"a", "b"}, {BOOLEAN(), ROW({"c", "d"}, {DOUBLE(), VARCHAR()})}),
+          10,
+          pool())),
+      "NULL::STRUCT(a BOOLEAN, b STRUCT(c DOUBLE, d VARCHAR))");
+}
+
+TEST_P(ParameterizedExprTest, constantJsonToSql) {
+  core::TypedExprPtr expression = std::make_shared<const core::CallTypedExpr>(
+      VARCHAR(),
+      std::vector<core::TypedExprPtr>{makeConstantExpr("[1, 2, 3]", JSON())},
+      "json_format");
+
+  auto exprSet = compileNoConstantFolding(expression);
+
+  std::vector<VectorPtr> complexConstants;
+  auto sql = exprSet->expr(0)->toSql(&complexConstants);
+
+  auto copy =
+      compileNoConstantFolding(sql, ROW({}), makeRowVector(complexConstants));
+  ASSERT_EQ(
+      exprSet->toString(false /*compact*/), copy->toString(false /*compact*/))
+      << sql;
+}
+
+TEST_P(ParameterizedExprTest, lambdaToSql) {
+  auto exprSet = compileNoConstantFolding(
+      "transform(array[1, 2, 3], x -> (x + cardinality(array[10, 20, 30])))",
+      ROW({}));
+
+  std::vector<VectorPtr> complexConstants;
+  auto sql = exprSet->expr(0)->toSql(&complexConstants);
+
+  auto copy =
+      compileNoConstantFolding(sql, ROW({}), makeRowVector(complexConstants));
+  ASSERT_EQ(
+      exprSet->toString(false /*compact*/), copy->toString(false /*compact*/))
+      << sql;
 }
 
 TEST_P(ParameterizedExprTest, toSql) {
@@ -2766,10 +2850,6 @@ namespace {
 // A naive function that wraps the input in a dictionary vector.
 class WrapInDictionaryFunc : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return true;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -2795,10 +2875,6 @@ class WrapInDictionaryFunc : public exec::VectorFunction {
 
 class LastRowNullFunc : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -2826,11 +2902,15 @@ TEST_P(ParameterizedExprTest, dictionaryResizedInAddNulls) {
   exec::registerVectorFunction(
       "dict_wrap",
       WrapInDictionaryFunc::signatures(),
-      std::make_unique<WrapInDictionaryFunc>());
+      std::make_unique<WrapInDictionaryFunc>(),
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
+
   exec::registerVectorFunction(
       "last_row_null",
       LastRowNullFunc::signatures(),
-      std::make_unique<LastRowNullFunc>());
+      std::make_unique<LastRowNullFunc>(),
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
+
   // This test verifies an edge case where applyFunctionWithPeeling may produce
   // a result vector which is dictionary encoded and has fewer values than
   // are rows.
@@ -2878,15 +2958,15 @@ TEST_P(ParameterizedExprTest, castExceptionContext) {
   assertError(
       "cast(c0 as bigint)",
       makeFlatVector<std::string>({"1a"}),
-      "cast((c0) as BIGINT)",
-      "Same as context.",
-      "Cannot cast VARCHAR '1a' to BIGINT. Non-whitespace character found after end of conversion: \"a\"");
+      "Top-level Expression: cast((c0) as BIGINT)",
+      "",
+      "Cannot cast VARCHAR '1a' to BIGINT. Non-whitespace character found after end of conversion: \"\"");
 
   assertError(
       "cast(c0 as timestamp)",
       makeFlatVector(std::vector<int8_t>{1}),
-      "cast((c0) as TIMESTAMP)",
-      "Same as context.",
+      "Top-level Expression: cast((c0) as TIMESTAMP)",
+      "",
       "Cannot cast TINYINT '1' to TIMESTAMP. Conversion to Timestamp is not supported");
 }
 
@@ -2895,7 +2975,7 @@ TEST_P(ParameterizedExprTest, switchExceptionContext) {
       "case c0 when 7 then c0 / 0 else 0 end",
       makeFlatVector(std::vector<int64_t>{7}),
       "divide(c0, 0:BIGINT)",
-      "switch(eq(c0, 7:BIGINT), divide(c0, 0:BIGINT), 0:BIGINT)",
+      "Top-level Expression: switch(eq(c0, 7:BIGINT), divide(c0, 0:BIGINT), 0:BIGINT)",
       "division by zero");
 }
 
@@ -2906,7 +2986,7 @@ TEST_P(ParameterizedExprTest, conjunctExceptionContext) {
       "if (c0 % 409 < 300 and c0 / 0 < 30, 1, 2)",
       data,
       "divide(c0, 0:BIGINT)",
-      "switch(and(lt(mod(c0, 409:BIGINT), 300:BIGINT), lt(divide(c0, 0:BIGINT), 30:BIGINT)), 1:BIGINT, 2:BIGINT)",
+      "Top-level Expression: switch(and(lt(mod(c0, 409:BIGINT), 300:BIGINT), lt(divide(c0, 0:BIGINT), 30:BIGINT)), 1:BIGINT, 2:BIGINT)",
       "division by zero");
 }
 
@@ -2918,7 +2998,7 @@ TEST_P(ParameterizedExprTest, lambdaExceptionContext) {
       "filter(c0, x -> (x / 0 > 1))",
       array,
       "divide(x, 0:BIGINT)",
-      "filter(c0, (x) -> gt(divide(x, 0:BIGINT), 1:BIGINT))",
+      "Top-level Expression: filter(c0, (x) -> gt(divide(x, 0:BIGINT), 1:BIGINT))",
       "division by zero");
 }
 
@@ -3340,6 +3420,43 @@ TEST_P(ParameterizedExprTest, addNulls) {
     EXPECT_EQ(mutableIndices[2], 1);
   }
 
+  // Make sure we dont overwrite the shared values_ buffer of a flatVector
+  {
+    // When the buffer needs to be reduced in size.
+    auto otherVector =
+        makeFlatVector<int64_t>(2 * kSize, [](auto row) { return row; });
+    auto valuesBufferCurrentSize = otherVector->values()->size();
+    VectorPtr input = std::make_shared<FlatVector<int64_t>>(
+        context.pool(),
+        BIGINT(),
+        nullptr,
+        kSize - 1,
+        otherVector->values(),
+        std::vector<BufferPtr>{});
+    exec::EvalCtx::addNulls(rows, rawNulls, context, BIGINT(), input);
+    checkResult(input);
+    ASSERT_EQ(valuesBufferCurrentSize, otherVector->values()->size());
+    ASSERT_NE(input->values(), otherVector->values());
+  }
+
+  {
+    // When the buffer needs to be increased in size.
+    auto otherVector =
+        makeFlatVector<int64_t>(kSize - 1, [](auto row) { return row; });
+    auto valuesBufferCurrentSize = otherVector->values()->size();
+    VectorPtr input = std::make_shared<FlatVector<int64_t>>(
+        context.pool(),
+        BIGINT(),
+        nullptr,
+        kSize - 1,
+        otherVector->values(),
+        std::vector<BufferPtr>{});
+    exec::EvalCtx::addNulls(rows, rawNulls, context, BIGINT(), input);
+    checkResult(input);
+    ASSERT_EQ(valuesBufferCurrentSize, otherVector->values()->size());
+    ASSERT_NE(input->values(), otherVector->values());
+  }
+
   // Verify that when adding nulls to a RowVector outside of its initial size,
   // we ensure that newly added rows outside of the initial size that are not
   // marked as null are still accessible.
@@ -3351,12 +3468,16 @@ TEST_P(ParameterizedExprTest, addNulls) {
     // We do not set null to row three.
     localRows.setValid(4, true);
     localRows.updateBounds();
+    auto nulls = allocateNulls(5, pool());
+    auto* rawNulls = nulls->asMutable<uint64_t>();
+    bits::setNull(rawNulls, 4, true);
     exec::EvalCtx::addNulls(
-        localRows, nullptr, context, rowVector->type(), rowVector);
+        localRows, rawNulls, context, rowVector->type(), rowVector);
     ASSERT_EQ(rowVector->size(), 5);
 
     rowVector->validate();
-    ASSERT_TRUE(rowVector->isNullAt(3));
+    // Unselected row does not need to be marked null, just has to be valid.
+    ASSERT_FALSE(rowVector->isNullAt(3));
   };
 
   {
@@ -3419,7 +3540,7 @@ TEST_P(ParameterizedExprTest, applyFunctionNoResult) {
       "always_throws_vector_function(c0) AND true",
       makeFlatVector<int32_t>({1, 2, 3}),
       "always_throws_vector_function(c0)",
-      "and(always_throws_vector_function(c0), true:BOOLEAN)",
+      "Top-level Expression: and(always_throws_vector_function(c0), true:BOOLEAN)",
       TestingAlwaysThrowsVectorFunction::kVeloxErrorMessage);
 
   exec::registerVectorFunction(
@@ -3431,7 +3552,7 @@ TEST_P(ParameterizedExprTest, applyFunctionNoResult) {
       "no_op(c0) AND true",
       makeFlatVector<int32_t>({1, 2, 3}),
       "no_op(c0)",
-      "and(no_op(c0), true:BOOLEAN)",
+      "Top-level Expression: and(no_op(c0), true:BOOLEAN)",
       "Function neither returned results nor threw exception.");
 }
 
@@ -3447,10 +3568,10 @@ TEST_P(ParameterizedExprTest, mapKeysAndValues) {
       MAP(BIGINT(), BIGINT()),
       makeNulls(vectorSize, nullEvery(3)),
       vectorSize,
-      makeIndices(vectorSize, [](auto /* row */) { return 0; }),
+      makeIndices(vectorSize, folly::identity),
       makeIndices(vectorSize, [](auto /* row */) { return 1; }),
-      makeFlatVector<int64_t>({1, 2, 3}),
-      makeFlatVector<int64_t>({10, 20, 30}));
+      makeFlatVector<int64_t>(vectorSize, folly::identity),
+      makeFlatVector<int64_t>(vectorSize, [](auto i) { return 10 * i; }));
   auto input = makeRowVector({mapVector});
   auto exprSet = compileMultiple(
       {"map_keys(c0)", "map_values(c0)"}, asRowType(input->type()));
@@ -3561,8 +3682,8 @@ TEST_P(ParameterizedExprTest, stdExceptionInVectorFunction) {
   assertError(
       "always_throws_vector_function(c0)",
       makeFlatVector<int32_t>({1, 2, 3}),
-      "always_throws_vector_function(c0)",
-      "Same as context.",
+      "Top-level Expression: always_throws_vector_function(c0)",
+      "",
       TestingAlwaysThrowsVectorFunction::kStdErrorMessage);
 
   assertErrorSimplified(
@@ -3611,6 +3732,165 @@ TEST_P(ParameterizedExprTest, cseUnderTry) {
       result);
 }
 
+namespace {
+// This UDF throws an exception for any argument equal to 31, otherwise it's the
+// identity function. Important for the test, it sizes the result only large
+// enough to hold all rows that didn't throw an error.
+class TestingShrinkForErrorsFunction : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VELOX_CHECK(args[0]->isFlatEncoding());
+
+    const auto* flatArg = args[0]->as<FlatVector<int8_t>>();
+
+    exec::LocalSelectivityVector remainingRows(context, rows);
+    context.applyToSelectedNoThrow(*remainingRows, [&](vector_size_t row) {
+      // Throw a user error (so it can be caught be try) if the argument is
+      // equal to 31.
+      VELOX_USER_CHECK_NE(flatArg->valueAt(row), 31, "Expected");
+    });
+
+    context.deselectErrors(*remainingRows);
+
+    // Create the result, importantly the size is rows.end() so may be smaller
+    // than the rows being processed after errors are deselected.
+    const auto localResult = std::make_shared<FlatVector<int8_t>>(
+        context.pool(),
+        outputType,
+        nullptr,
+        rows.end(),
+        flatArg->values(),
+        std::vector<BufferPtr>{});
+
+    context.moveOrCopyResult(localResult, *remainingRows, result);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    return {exec::FunctionSignatureBuilder()
+                .returnType("tinyint")
+                .argumentType("tinyint")
+                .build()};
+  }
+};
+} // namespace
+
+VELOX_DECLARE_VECTOR_FUNCTION(
+    udf_testing_shrink_for_errors,
+    TestingShrinkForErrorsFunction::signatures(),
+    std::make_unique<TestingShrinkForErrorsFunction>());
+
+TEST_P(ParameterizedExprTest, cseUnderTryWithIf) {
+  // This tests a particular case where shared subexpression computation can hit
+  // errors when combined with TRY. In this case a VectorFunction sizes the
+  // result based on rows.end(), can throw user exceptions, and doesn't resize
+  // the result Vector to include rows that produced exceptions. If that
+  // funciton is evaluated as part of CSE, e.g. on both sides of an if
+  // statement, and the last row produces an exception, the result Vector will
+  // be smaller than rows.size(). This test validates that in CSE we can
+  // tolerate this and does not rely on the fact the result Vector is at least
+  // rows.size() large, particularly when we're updating the result of a CSE to
+  // add new values, e.g. in the else portion of an if statement.
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_testing_shrink_for_errors, "testing_shrink_for_errors");
+
+  auto input = makeRowVector({
+      makeNullableFlatVector<bool>({true, false, true, false, true, false}),
+      makeNullableFlatVector<int8_t>({31, 3, 31, 31, 2, 31}),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "if(c0, testing_shrink_for_errors(c1), testing_shrink_for_errors(c1))",
+          input),
+      "Expected");
+
+  auto result = evaluate(
+      "try(if(c0, testing_shrink_for_errors(c1), testing_shrink_for_errors(c1)))",
+      input);
+
+  assertEqualVectors(
+      makeNullableFlatVector<int8_t>({
+          std::nullopt,
+          3,
+          std::nullopt,
+          std::nullopt,
+          2,
+          std::nullopt,
+      }),
+      result);
+}
+
+// Test AND/OR expressions with multiple conjucts generating errors in different
+// rows. With and without TRY.
+TEST_P(ParameterizedExprTest, failingConjuncts) {
+  auto input = makeRowVector({
+      makeFlatVector<std::string>({"10", "foo", "11"}),
+      makeFlatVector<std::string>({"bar", "10", "11"}),
+      makeFlatVector<int64_t>({1, 2, 3}),
+  });
+
+  // cast(c0 as bigint) throws on 1st row.
+  // cast(c1 as bigint) throws on 2nd row.
+  // c2 > 0 doesn't throw and returns true for all rows.
+
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "cast(c0 as bigint) > 0 AND cast(c1 as bigint) > 0 AND c2 > 0",
+          input),
+      "Cannot cast VARCHAR 'bar' to BIGINT.");
+
+  auto result = evaluate(
+      "try(cast(c0 as bigint) > 0 AND cast(c1 as bigint) > 0 AND c2 > 0)",
+      input);
+
+  auto expected =
+      makeNullableFlatVector<bool>({std::nullopt, std::nullopt, true});
+  assertEqualVectors(expected, result);
+
+  // c2 <> 1 returns false for 1st row and masks errors from other conjuncts.
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "cast(c0 as bigint) > 0 AND cast(c1 as bigint) > 0 AND c2 <> 1",
+          input),
+      "Cannot cast VARCHAR 'foo' to BIGINT.");
+
+  result = evaluate(
+      "try(cast(c0 as bigint) > 0 AND cast(c1 as bigint) > 0 AND c2 <> 1)",
+      input);
+  expected = makeNullableFlatVector<bool>({false, std::nullopt, true});
+  assertEqualVectors(expected, result);
+
+  // OR succeeds because c2 > 0 returns 'true' for all rows and masks errors
+  // from other conjuncts.
+
+  result = evaluate(
+      "cast(c0 as bigint) < 0 OR cast(c1 as bigint) < 0 OR c2 > 0", input);
+  expected = makeFlatVector<bool>({true, true, true});
+  assertEqualVectors(expected, result);
+
+  result = evaluate(
+      "try(cast(c0 as bigint) < 0 OR cast(c1 as bigint) < 0 OR c2 > 0)", input);
+  assertEqualVectors(expected, result);
+
+  // c2 <> 1 returns 'false' for 1st row and fails to mask errors from other
+  // conjuncts.
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "cast(c0 as bigint) < 0 OR cast(c1 as bigint) < 0 OR c2 <> 1", input),
+      "Cannot cast VARCHAR 'bar' to BIGINT.");
+
+  result = evaluate(
+      "try(cast(c0 as bigint) < 0 OR cast(c1 as bigint) < 0 OR c2 <> 1)",
+      input);
+  expected = makeNullableFlatVector<bool>({std::nullopt, true, true});
+  assertEqualVectors(expected, result);
+}
+
 TEST_P(ParameterizedExprTest, conjunctUnderTry) {
   auto input = makeRowVector({
       makeFlatVector<StringView>({"a"_sv, "b"_sv}),
@@ -4019,6 +4299,23 @@ TEST_F(ExprTest, commonSubExpressionWithPeeling) {
       ASSERT_EQ(totalDefaultNullFunc, 2);
       // It is evaluated twice during expr1 and 4 times during expr2.
       ASSERT_EQ(totalNotDefaultNullFunc, 6);
+      clearResults();
+    }
+    {
+      // Set max_shared_subexpr_results_cached low so the
+      // second result isn't cached, so expr1 is only evaluated once, but expr2
+      // is evaluated twice.
+      auto queryCtx = velox::core::QueryCtx::create(
+          nullptr,
+          core::QueryConfig(std::unordered_map<std::string, std::string>{
+              {core::QueryConfig::kMaxSharedSubexprResultsCached, "1"}}));
+      core::ExecCtx execCtx(pool_.get(), queryCtx.get());
+      auto results = makeRowVector(evaluateMultiple(
+          {expr1, expr2, expr1, expr2}, data, std::nullopt, &execCtx));
+      ASSERT_EQ(totalDefaultNullFunc, 2);
+      // It is evaluated twice during expr1 and 4 times during expr2, expr2 is
+      // evaluated twice.
+      ASSERT_EQ(totalNotDefaultNullFunc, 10);
     }
   }
 }
@@ -4250,7 +4547,7 @@ TEST_P(ParameterizedExprTest, lazyHandlingByDereference) {
   // Ensure FieldReference handles an input which has an encoding over a lazy
   // vector. Trying to access the inner flat vector of an input in the form
   // Row(Dict(Lazy(Row(Flat)))) will ensure an intermediate FieldReference
-  // expression in the tree recieves an input of the form Dict(Lazy(Row(Flat))).
+  // expression in the tree receives an input of the form Dict(Lazy(Row(Flat))).
   auto base = makeRowVector(
       {makeNullableFlatVector<int32_t>({1, std::nullopt, 3, 4, 5})});
   VectorPtr col1 = std::make_shared<LazyVector>(
@@ -4403,10 +4700,268 @@ TEST_P(ParameterizedExprTest, coalesceRowInputTypesAreTheSame) {
   }
 }
 
+TEST_P(ParameterizedExprTest, evaluatesArgumentsOnNonIncreasingSelection) {
+  auto makeLazy = [&](const auto& base, const auto& check) {
+    return std::make_shared<LazyVector>(
+        execCtx_->pool(),
+        base->type(),
+        base->size(),
+        std::make_unique<test::SimpleVectorLoader>([&](auto rows) {
+          check(rows);
+          return base;
+        }));
+  };
+  constexpr int kSize = 300;
+  auto c0 = makeFlatVector<int64_t>(kSize, folly::identity);
+
+  {
+    SCOPED_TRACE("No eager loading for AND clauses");
+    auto input = makeRowVector({
+        c0,
+        makeLazy(
+            c0,
+            [](auto& rows) {
+              // Only the rows passing c0 % 2 == 0 should be loaded.
+              VELOX_CHECK_EQ(rows.size(), (kSize + 1) / 2);
+              for (auto i : rows) {
+                VELOX_CHECK(i % 2 == 0);
+              }
+            }),
+    });
+    auto actual =
+        evaluate("c0 % 2 == 0 and c1 % 3 == 0 and c1 % 5 == 0", input);
+    auto expected =
+        makeFlatVector<bool>(kSize, [](auto i) { return i % 30 == 0; });
+    assertEqualVectors(expected, actual);
+  }
+
+  {
+    SCOPED_TRACE("IF inside AND");
+    auto input = makeRowVector({
+        c0,
+        makeLazy(
+            c0,
+            [](auto& rows) {
+              // Only the rows passing c0 % 2 == 0 should be loaded.
+              VELOX_CHECK_EQ(rows.size(), (kSize + 1) / 2);
+              for (auto i : rows) {
+                VELOX_CHECK(i % 2 == 0);
+              }
+            }),
+    });
+    auto actual =
+        evaluate("c0 % 2 == 0 and if (c0 % 3 == 0, c1, -1 * c1) >= 0", input);
+    auto expected =
+        makeFlatVector<bool>(kSize, [](auto i) { return i % 6 == 0; });
+    assertEqualVectors(expected, actual);
+  }
+
+  {
+    SCOPED_TRACE("AND inside IF");
+    auto input = makeRowVector({
+        c0,
+        makeLazy(
+            c0,
+            [&](auto& rows) {
+              // All rows should be loaded.
+              VELOX_CHECK_EQ(rows.size(), kSize);
+            }),
+    });
+    auto actual = evaluate(
+        "if (c0 % 2 == 0, c1 % 3 == 0 and c1 % 5 == 0, c1 % 7 == 0 and c1 % 11 == 0)",
+        input);
+    auto expected = makeFlatVector<bool>(kSize, [](auto i) {
+      return (i % 2 == 0 && i % 15 == 0) || (i % 2 != 0 && i % 77 == 0);
+    });
+    assertEqualVectors(expected, actual);
+  }
+
+  {
+    SCOPED_TRACE("Shared subexp");
+    auto c1 = makeFlatVector<int64_t>({0, 0});
+    auto c2 = makeFlatVector<int64_t>({1, 1});
+    auto input = makeRowVector({
+        makeNullableFlatVector<int64_t>({0, std::nullopt}),
+        makeLazy(
+            c1,
+            [&](auto& rows) {
+              // All rows should be loaded.
+              VELOX_CHECK_EQ(rows.size(), 2);
+            }),
+        c2,
+    });
+    auto actual =
+        evaluate("(c0 <> if (c1 < c2, 1, 0)) is null and c1 < c2", input);
+    assertEqualVectors(makeFlatVector<bool>({false, true}), actual);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     ExprTest,
     ParameterizedExprTest,
     testing::ValuesIn({false, true}));
 
+TEST_F(ExprTest, disablePeeling) {
+  // Verify that peeling is disabled when the config is set by checking whether
+  // the number of rows processed is equal to the alphabet size (when enabled)
+  // or the dictionary size (when disabled).
+  // Also, ensure that single arg function receives a flat vector even when
+  // peeling is disabled.
+
+  // This throws if input is not flat or constant.
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_testing_single_arg_deterministic, "testing_single_arg_deterministic");
+  // This wraps the input in a dictionary.
+  exec::registerVectorFunction(
+      "dict_wrap",
+      WrapInDictionaryFunc::signatures(),
+      std::make_unique<WrapInDictionaryFunc>(),
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
+  const std::vector<std::string> expressions = {"c0 + 1"};
+
+  auto flatInput = makeFlatVector<int64_t>({1, 2, 3});
+  auto flatSize = flatInput->size();
+  auto dictInput = wrapInDictionary(
+      makeIndices(2 * flatSize, [&](auto row) { return row % flatSize; }),
+      2 * flatSize,
+      flatInput);
+  auto dictSize = dictInput->size();
+
+  // Peeling Enabled (by default)
+  auto [result, stats] = evaluateMultipleWithStats(
+      expressions, makeRowVector({dictInput}), {}, execCtx_.get());
+
+  ASSERT_TRUE(stats.find("plus") != stats.end());
+  ASSERT_EQ(stats["plus"].numProcessedRows, flatSize);
+
+  // Peeling Disabled
+  std::unordered_map<std::string, std::string> configData(
+      {{core::QueryConfig::kDebugDisableExpressionWithPeeling, "true"}});
+  auto queryCtx = velox::core::QueryCtx::create(
+      nullptr, core::QueryConfig(std::move(configData)));
+  auto execCtx = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx.get());
+
+  std::tie(result, stats) = evaluateMultipleWithStats(
+      expressions, makeRowVector({dictInput}), {}, execCtx.get());
+
+  ASSERT_TRUE(stats.find("plus") != stats.end());
+  ASSERT_EQ(stats["plus"].numProcessedRows, dictSize);
+
+  // Ensure single arg function receives a flat vector.
+  // When top level column is dictionary wrapped.
+  ASSERT_NO_THROW(evaluateMultiple(
+      {"testing_single_arg_deterministic((c0))"},
+      makeRowVector({dictInput}),
+      {},
+      execCtx.get()));
+  // When intermediate column is dictionary wrapped.
+  // dict_wrap helps generate an intermediate dictionary vector.
+  ASSERT_NO_THROW(evaluateMultiple(
+      {"testing_single_arg_deterministic(dict_wrap(c0))"},
+      makeRowVector({flatInput}),
+      {},
+      execCtx.get()));
+}
+
+TEST_F(ExprTest, disableSharedSubExpressionReuse) {
+  // Verify that shared subexpression reuse is disabled when the config is set
+  // by confirming that the same rows are processed twice by the shared
+  // expression when its disabled.
+  const std::vector<std::string> expressions = {"c0 + 1", "(c0 + 1) = 0"};
+
+  auto flatInput = makeFlatVector<int64_t>({1, 2, 3});
+  auto flatSize = flatInput->size();
+
+  // SharedSubExpressionReuse Enabled (by default)
+  auto [result, stats] = evaluateMultipleWithStats(
+      expressions, makeRowVector({flatInput}), {}, execCtx_.get());
+
+  ASSERT_TRUE(stats.find("plus") != stats.end());
+  ASSERT_EQ(stats["plus"].numProcessedRows, flatSize);
+
+  // SharedSubExpressionReuse Disabled
+  std::unordered_map<std::string, std::string> configData(
+      {{core::QueryConfig::kDebugDisableCommonSubExpressions, "true"}});
+  auto queryCtx = velox::core::QueryCtx::create(
+      nullptr, core::QueryConfig(std::move(configData)));
+  auto execCtx = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx.get());
+
+  std::tie(result, stats) = evaluateMultipleWithStats(
+      expressions, makeRowVector({flatInput}), {}, execCtx.get());
+
+  ASSERT_TRUE(stats.find("plus") != stats.end());
+  ASSERT_EQ(stats["plus"].numProcessedRows, 2 * flatSize);
+}
+
+TEST_F(ExprTest, disableMemoization) {
+  // Verify that memoization is disabled when the config is set by confirming
+  // that the third invocation reuses the results.
+  auto flatInput = makeFlatVector<int64_t>({1, 2, 3});
+  auto flatSize = flatInput->size();
+  auto dictInput = wrapInDictionary(
+      makeIndices(2 * flatSize, [&](auto row) { return row % flatSize; }),
+      2 * flatSize,
+      flatInput);
+  auto dictSize = dictInput->size();
+  auto inputRow = makeRowVector({dictInput});
+
+  auto exprSet = compileExpression("c0 + 1", asRowType(inputRow->type()));
+  // Memoization Enabled (by default). We need to evaluate the expression
+  // atleast twice to enable memoization. The third invocation will use the
+  // memoized result.
+  evaluateWithStats(exprSet.get(), inputRow, execCtx_.get());
+  evaluateWithStats(exprSet.get(), inputRow, execCtx_.get());
+  auto [result, stats] =
+      evaluateWithStats(exprSet.get(), inputRow, execCtx_.get());
+
+  ASSERT_TRUE(stats.find("plus") != stats.end());
+  ASSERT_EQ(stats["plus"].numProcessedRows, 2 * flatSize);
+
+  // Memoization Disabled
+  std::unordered_map<std::string, std::string> configData(
+      {{core::QueryConfig::kDebugDisableExpressionWithMemoization, "true"}});
+  auto queryCtx = velox::core::QueryCtx::create(
+      nullptr, core::QueryConfig(std::move(configData)));
+  auto execCtx = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx.get());
+
+  exprSet = compileExpression("c0 + 1", asRowType(inputRow->type()));
+  evaluateWithStats(exprSet.get(), inputRow, execCtx.get());
+  evaluateWithStats(exprSet.get(), inputRow, execCtx.get());
+  std::tie(result, stats) =
+      evaluateWithStats(exprSet.get(), inputRow, execCtx.get());
+
+  ASSERT_TRUE(stats.find("plus") != stats.end());
+  ASSERT_EQ(stats["plus"].numProcessedRows, 3 * flatSize);
+}
+
+TEST_F(ExprTest, disabledeferredLazyLoading) {
+  // Verify that deferred lazy loading is disabled when the config is set by
+  // confirming that all rows are loaded even when only a subset is required.
+
+  // The following expression only requires 1 row to be loaded on c1.
+  const std::vector<std::string> expressions = {"(c0 < 2) AND (c1 > 0)"};
+  auto c0 = makeFlatVector<int64_t>({1, 2, 3});
+  auto valueAt = [](auto row) { return row; };
+  // Confirm only 1 row is loaded.
+  auto c1 = makeLazyFlatVector<int64_t>(3, valueAt, nullptr, 1);
+
+  // Deferred lazy loading enabled (by default). Confirm that only required rows
+  // are loaded.
+  auto [result, stats] = evaluateMultipleWithStats(
+      expressions, makeRowVector({c0, c1}), {}, execCtx_.get());
+
+  // Deferred lazy loading disabled. Confirm all rows will be loaded.
+  std::unordered_map<std::string, std::string> configData(
+      {{core::QueryConfig::kDebugDisableExpressionWithLazyInputs, "true"}});
+  auto queryCtx = velox::core::QueryCtx::create(
+      nullptr, core::QueryConfig(std::move(configData)));
+  auto execCtx = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx.get());
+
+  // Confirm that all rows are loaded.
+  c1 = makeLazyFlatVector<int64_t>(3, valueAt, nullptr, 3);
+  std::tie(result, stats) = evaluateMultipleWithStats(
+      expressions, makeRowVector({c0, c1}), {}, execCtx.get());
+}
+
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/expression/tests/ExprToSubfieldFilterTest.cpp b/velox/expression/tests/ExprToSubfieldFilterTest.cpp
index df9f93addbf14..32aff577d9d49 100644
--- a/velox/expression/tests/ExprToSubfieldFilterTest.cpp
+++ b/velox/expression/tests/ExprToSubfieldFilterTest.cpp
@@ -42,6 +42,7 @@ class ExprToSubfieldFilterTest : public testing::Test {
   static void SetUpTestSuite() {
     functions::prestosql::registerAllScalarFunctions();
     parse::registerTypeResolver();
+    memory::MemoryManager::testingSetInstance({});
   }
 
   core::TypedExprPtr parseExpr(
@@ -66,9 +67,9 @@ class ExprToSubfieldFilterTest : public testing::Test {
 
  private:
   std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::addDefaultLeafMemoryPool();
-  core::QueryCtx queryCtx_;
-  SimpleExpressionEvaluator evaluator_{&queryCtx_, pool_.get()};
+      memory::memoryManager()->addLeafPool();
+  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
+  SimpleExpressionEvaluator evaluator_{queryCtx_.get(), pool_.get()};
 };
 
 TEST_F(ExprToSubfieldFilterTest, eq) {
diff --git a/velox/expression/tests/ExpressionFuzzer.cpp b/velox/expression/tests/ExpressionFuzzer.cpp
deleted file mode 100644
index 12e9fa939426d..0000000000000
--- a/velox/expression/tests/ExpressionFuzzer.cpp
+++ /dev/null
@@ -1,1369 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <boost/algorithm/string.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-#include <folly/ScopeGuard.h>
-#include <glog/logging.h>
-#include <exception>
-#include <unordered_set>
-
-#include "velox/common/base/Exceptions.h"
-#include "velox/expression/Expr.h"
-#include "velox/expression/FunctionSignature.h"
-#include "velox/expression/ReverseSignatureBinder.h"
-#include "velox/expression/SimpleFunctionRegistry.h"
-#include "velox/expression/tests/ArgumentTypeFuzzer.h"
-#include "velox/expression/tests/ExpressionFuzzer.h"
-
-DEFINE_int32(steps, 10, "Number of expressions to generate and execute.");
-
-DEFINE_int32(
-    duration_sec,
-    0,
-    "For how long it should run (in seconds). If zero, "
-    "it executes exactly --steps iterations and exits.");
-
-DEFINE_int32(
-    batch_size,
-    100,
-    "The number of elements on each generated vector.");
-
-DEFINE_int32(
-    max_num_varargs,
-    5,
-    "The maximum number of variadic arguments fuzzer will generate for "
-    "functions that accept variadic arguments. Fuzzer will generate up to "
-    "max_num_varargs arguments for the variadic list in addition to the "
-    "required arguments by the function.");
-
-DEFINE_double(
-    null_ratio,
-    0.1,
-    "Chance of adding a null constant to the plan, or null value in a vector "
-    "(expressed as double from 0 to 1).");
-
-DEFINE_bool(
-    retry_with_try,
-    false,
-    "Retry failed expressions by wrapping it using a try() statement.");
-
-DEFINE_bool(
-    find_minimal_subexpression,
-    false,
-    "Automatically seeks minimum failed subexpression on result mismatch");
-
-DEFINE_bool(
-    disable_constant_folding,
-    false,
-    "Disable constant-folding in the common evaluation path.");
-
-DEFINE_bool(
-    enable_variadic_signatures,
-    false,
-    "Enable testing of function signatures with variadic arguments.");
-
-DEFINE_bool(
-    enable_dereference,
-    false,
-    "Allow fuzzer to generate random expressions with dereference and row_constructor functions.");
-
-DEFINE_string(
-    repro_persist_path,
-    "",
-    "Directory path for persistence of data and SQL when fuzzer fails for "
-    "future reproduction. Empty string disables this feature.");
-
-DEFINE_bool(
-    persist_and_run_once,
-    false,
-    "Persist repro info before evaluation and only run one iteration. "
-    "This is to rerun with the seed number and persist repro info upon a "
-    "crash failure. Only effective if repro_persist_path is set.");
-
-DEFINE_int32(
-    velox_fuzzer_max_level_of_nesting,
-    10,
-    "Max levels of expression nesting. The default value is 10 and minimum is 1.");
-
-DEFINE_bool(
-    velox_fuzzer_enable_complex_types,
-    false,
-    "Enable testing of function signatures with complex argument or return types.");
-
-DEFINE_double(
-    lazy_vector_generation_ratio,
-    0.0,
-    "Specifies the probability with which columns in the input row "
-    "vector will be selected to be wrapped in lazy encoding "
-    "(expressed as double from 0 to 1).");
-
-DEFINE_bool(
-    velox_fuzzer_enable_column_reuse,
-    false,
-    "Enable generation of expressions where one input column can be "
-    "used by multiple subexpressions");
-
-DEFINE_bool(
-    velox_fuzzer_enable_expression_reuse,
-    false,
-    "Enable generation of expressions that re-uses already generated "
-    "subexpressions.");
-
-DEFINE_string(
-    assign_function_tickets,
-    "",
-    "Comma separated list of function names and their tickets in the format "
-    "<function_name>=<tickets>. Every ticket represents an opportunity for "
-    "a function to be chosen from a pool of candidates. By default, "
-    "every function has one ticket, and the likelihood of a function "
-    "being picked can be increased by allotting it more tickets. Note "
-    "that in practice, increasing the number of tickets does not "
-    "proportionally increase the likelihood of selection, as the selection "
-    "process involves filtering the pool of candidates by a required "
-    "return type so not all functions may compete against the same number "
-    "of functions at every instance. Number of tickets must be a positive "
-    "integer. Example: eq=3,floor=5");
-
-DEFINE_int32(
-    max_expression_trees_per_step,
-    1,
-    "This sets an upper limit on the number of expression trees to generate "
-    "per step. These trees would be executed in the same ExprSet and can "
-    "re-use already generated columns and subexpressions (if re-use is "
-    "enabled).");
-
-namespace facebook::velox::test {
-
-namespace {
-
-using exec::SignatureBinder;
-
-/// Returns if `functionName` with the given `argTypes` is deterministic.
-/// Returns true if the function was not found or determinism cannot be
-/// established.
-bool isDeterministic(
-    const std::string& functionName,
-    const std::vector<TypePtr>& argTypes) {
-  // We know that the 'cast', 'and', and 'or' special forms are deterministic.
-  // Hard-code them here because they are not real functions and hence cannot be
-  // resolved by the code below.
-  if (functionName == "and" || functionName == "or" ||
-      functionName == "coalesce" || functionName == "if" ||
-      functionName == "switch" || functionName == "cast") {
-    return true;
-  }
-
-  // Check if this is a simple function.
-  if (auto simpleFunctionEntry =
-          exec::simpleFunctions().resolveFunction(functionName, argTypes)) {
-    return simpleFunctionEntry->getMetadata().isDeterministic();
-  }
-
-  // Vector functions are a bit more complicated. We need to fetch the list of
-  // available signatures and check if any of them bind given the current input
-  // arg types. If it binds (if there's a match), we fetch the function and
-  // return the isDeterministic bool.
-  try {
-    if (auto vectorFunctionSignatures =
-            exec::getVectorFunctionSignatures(functionName)) {
-      core::QueryConfig config({});
-      for (const auto& signature : *vectorFunctionSignatures) {
-        if (exec::SignatureBinder(*signature, argTypes).tryBind()) {
-          if (auto vectorFunction =
-                  exec::getVectorFunction(functionName, argTypes, {}, config)) {
-            return vectorFunction->isDeterministic();
-          }
-        }
-      }
-    }
-  }
-  // TODO: Some stateful functions can only be built when constant arguments are
-  // passed, making the getVectorFunction() call above to throw. We only have a
-  // few of these functions, so for now we assume they are deterministic so they
-  // are picked for Fuzz testing. Once we make the isDeterministic() flag static
-  // (and hence we won't need to build the function object in here) we can clean
-  // up this code.
-  catch (const std::exception& e) {
-    LOG(WARNING) << "Unable to determine if '" << functionName
-                 << "' is deterministic or not. Assuming it is.";
-    return true;
-  }
-
-  // functionName must be a special form.
-  LOG(WARNING) << "Unable to determine if '" << functionName
-               << "' is deterministic or not. Assuming it is.";
-  return true;
-}
-
-VectorFuzzer::Options getFuzzerOptions() {
-  VectorFuzzer::Options opts;
-  opts.vectorSize = FLAGS_batch_size;
-  opts.stringVariableLength = true;
-  opts.stringLength = 100;
-  opts.nullRatio = FLAGS_null_ratio;
-  return opts;
-}
-
-std::optional<CallableSignature> processConcreteSignature(
-    const std::string& functionName,
-    const std::vector<TypePtr>& argTypes,
-    const exec::FunctionSignature& signature) {
-  VELOX_CHECK(
-      signature.variables().empty(),
-      "Only concrete signatures are processed here.");
-
-  CallableSignature callable{
-      .name = functionName,
-      .args = argTypes,
-      .variableArity = signature.variableArity(),
-      .returnType =
-          SignatureBinder::tryResolveType(signature.returnType(), {}, {}),
-      .constantArgs = signature.constantArguments()};
-  VELOX_CHECK_NOT_NULL(callable.returnType);
-
-  bool onlyPrimitiveTypes = callable.returnType->isPrimitiveType();
-
-  for (const auto& arg : argTypes) {
-    onlyPrimitiveTypes = onlyPrimitiveTypes && arg->isPrimitiveType();
-  }
-
-  if (!(onlyPrimitiveTypes || FLAGS_velox_fuzzer_enable_complex_types)) {
-    LOG(WARNING) << "Skipping '" << callable.toString()
-                 << "' because it contains non-primitive types.";
-
-    return std::nullopt;
-  }
-  return callable;
-}
-
-// Determine whether type is or contains typeName. typeName should be in lower
-// case.
-bool containTypeName(
-    const exec::TypeSignature& type,
-    const std::string& typeName) {
-  auto sanitizedTypeName = exec::sanitizeName(type.baseName());
-  if (sanitizedTypeName == typeName) {
-    return true;
-  }
-  for (const auto& parameter : type.parameters()) {
-    if (containTypeName(parameter, typeName)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Determine whether the signature has an argument or return type that contains
-// typeName. typeName should be in lower case.
-bool useTypeName(
-    const exec::FunctionSignature& signature,
-    const std::string& typeName) {
-  if (containTypeName(signature.returnType(), typeName)) {
-    return true;
-  }
-  for (const auto& argument : signature.argumentTypes()) {
-    if (containTypeName(argument, typeName)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool isSupportedSignature(const exec::FunctionSignature& signature) {
-  // Not supporting lambda functions, or functions using decimal and
-  // timestamp with time zone types.
-  return !(
-      useTypeName(signature, "opaque") || useTypeName(signature, "function") ||
-      useTypeName(signature, "long_decimal") ||
-      useTypeName(signature, "short_decimal") ||
-      useTypeName(signature, "decimal") ||
-      useTypeName(signature, "timestamp with time zone") ||
-      useTypeName(signature, "interval day to second") ||
-      (FLAGS_velox_fuzzer_enable_complex_types &&
-       useTypeName(signature, "unknown")));
-}
-
-// Randomly pick columns from the input row vector to wrap in lazy.
-// Negative column indices represent lazy vectors that have been preloaded
-// before feeding them to the evaluator. This list is sorted on the absolute
-// value of the entries.
-std::vector<int> generateLazyColumnIds(
-    const RowVectorPtr& rowVector,
-    VectorFuzzer& vectorFuzzer) {
-  std::vector<int> columnsToWrapInLazy;
-  if (FLAGS_lazy_vector_generation_ratio > 0) {
-    for (int idx = 0; idx < rowVector->childrenSize(); idx++) {
-      VELOX_CHECK_NOT_NULL(rowVector->childAt(idx));
-      if (vectorFuzzer.coinToss(FLAGS_lazy_vector_generation_ratio)) {
-        columnsToWrapInLazy.push_back(
-            vectorFuzzer.coinToss(0.8) ? idx : -1 * idx);
-      }
-    }
-  }
-  return columnsToWrapInLazy;
-}
-
-/// Returns row numbers for non-null rows among all children in'data' or null
-/// if all rows are null.
-BufferPtr extractNonNullIndices(const RowVectorPtr& data) {
-  DecodedVector decoded;
-  SelectivityVector nonNullRows(data->size());
-
-  for (auto& child : data->children()) {
-    decoded.decode(*child);
-    auto* rawNulls = decoded.nulls();
-    if (rawNulls) {
-      nonNullRows.deselectNulls(rawNulls, 0, data->size());
-    }
-    if (!nonNullRows.hasSelections()) {
-      return nullptr;
-    }
-  }
-
-  BufferPtr indices = allocateIndices(nonNullRows.end(), data->pool());
-  auto rawIndices = indices->asMutable<vector_size_t>();
-  vector_size_t cnt = 0;
-  nonNullRows.applyToSelected(
-      [&](vector_size_t row) { rawIndices[cnt++] = row; });
-  VELOX_CHECK_GT(cnt, 0);
-  indices->setSize(cnt * sizeof(vector_size_t));
-  return indices;
-}
-
-/// Wraps child vectors of the specified 'rowVector' in dictionary using
-/// specified 'indices'. Returns new RowVector created from the wrapped vectors.
-RowVectorPtr wrapChildren(
-    const BufferPtr& indices,
-    const RowVectorPtr& rowVector) {
-  auto size = indices->size() / sizeof(vector_size_t);
-
-  std::vector<VectorPtr> newInputs;
-  for (const auto& child : rowVector->children()) {
-    newInputs.push_back(
-        BaseVector::wrapInDictionary(nullptr, indices, size, child));
-  }
-
-  return std::make_shared<RowVector>(
-      rowVector->pool(), rowVector->type(), nullptr, size, newInputs);
-}
-
-// Return the level of nestin of `type`. Return 0 if `type` is primitive.
-uint32_t levelOfNesting(const TypePtr& type) {
-  if (type->isPrimitiveType()) {
-    return 0;
-  }
-  switch (type->kind()) {
-    case TypeKind::ARRAY:
-      return 1 + levelOfNesting(type->asArray().elementType());
-    case TypeKind::MAP:
-      return 1 +
-          std::max(
-                 levelOfNesting(type->asMap().keyType()),
-                 levelOfNesting(type->asMap().valueType()));
-    case TypeKind::ROW: {
-      auto children = type->asRow().children();
-      VELOX_CHECK(!children.empty());
-      uint32_t maxChildNesting = 0;
-      for (const auto& child : children) {
-        maxChildNesting = std::max(maxChildNesting, levelOfNesting(child));
-      }
-      return 1 + maxChildNesting;
-    }
-    default:
-      VELOX_UNREACHABLE("Not a supported type.");
-  }
-}
-
-} // namespace
-
-ExpressionFuzzer::ExpressionFuzzer(
-    FunctionSignatureMap signatureMap,
-    size_t initialSeed,
-    int32_t maxLevelOfNesting)
-    : remainingLevelOfNesting_(std::max(1, maxLevelOfNesting)),
-      verifier_(
-          &execCtx_,
-          {FLAGS_disable_constant_folding,
-           FLAGS_repro_persist_path,
-           FLAGS_persist_and_run_once}),
-      vectorFuzzer_(getFuzzerOptions(), execCtx_.pool()),
-      expressionBank_(rng_, remainingLevelOfNesting_) {
-  seed(initialSeed);
-
-  size_t totalFunctions = 0;
-  size_t totalFunctionSignatures = 0;
-  std::vector<std::string> supportedFunctions;
-  size_t supportedFunctionSignatures = 0;
-  // A local random number generator to be used just in ExpressionFuzzer
-  // constructor. We do not use rng_ in this function because code in this
-  // function may change rng_ and cause it to mismatch with the seed printed in
-  // the log.
-  FuzzerGenerator localRng{
-      static_cast<FuzzerGenerator::result_type>(initialSeed)};
-  // Process each available signature for every function.
-  for (const auto& function : signatureMap) {
-    ++totalFunctions;
-    bool atLeastOneSupported = false;
-    for (const auto& signature : function.second) {
-      ++totalFunctionSignatures;
-
-      if (!isSupportedSignature(*signature)) {
-        continue;
-      }
-      if (!(signature->variables().empty() ||
-            FLAGS_velox_fuzzer_enable_complex_types)) {
-        LOG(WARNING) << "Skipping unsupported signature: " << function.first
-                     << signature->toString();
-        continue;
-      }
-      if (signature->variableArity() && !FLAGS_enable_variadic_signatures) {
-        LOG(WARNING) << "Skipping variadic function signature: "
-                     << function.first << signature->toString();
-        continue;
-      }
-
-      // Determine a list of concrete argument types that can bind to the
-      // signature. For non-parameterized signatures, these argument types will
-      // be used to create a callable signature. For parameterized signatures,
-      // these argument types are only used to fetch the function instance to
-      // get their determinism.
-      std::vector<TypePtr> argTypes;
-      if (signature->variables().empty()) {
-        bool supportedSignature = true;
-        for (const auto& arg : signature->argumentTypes()) {
-          auto resolvedType = SignatureBinder::tryResolveType(arg, {}, {});
-          if (!resolvedType) {
-            supportedSignature = false;
-            continue;
-          }
-          argTypes.push_back(resolvedType);
-        }
-
-        if (!supportedSignature) {
-          LOG(WARNING) << "Skipping unsupported signature with generic: "
-                       << function.first << signature->toString();
-          continue;
-        }
-      } else {
-        ArgumentTypeFuzzer typeFuzzer{*signature, localRng};
-        typeFuzzer.fuzzReturnType();
-        VELOX_CHECK_EQ(
-            typeFuzzer.fuzzArgumentTypes(FLAGS_max_num_varargs), true);
-        argTypes = typeFuzzer.argumentTypes();
-      }
-      if (!isDeterministic(function.first, argTypes)) {
-        LOG(WARNING) << "Skipping non-deterministic function: "
-                     << function.first << signature->toString();
-        continue;
-      }
-
-      if (!signature->variables().empty()) {
-        std::unordered_set<std::string> typeVariables;
-        for (const auto& [name, _] : signature->variables()) {
-          typeVariables.insert(name);
-        }
-        atLeastOneSupported = true;
-        ++supportedFunctionSignatures;
-        signatureTemplates_.emplace_back(SignatureTemplate{
-            function.first, signature, std::move(typeVariables)});
-      } else if (
-          auto callableFunction =
-              processConcreteSignature(function.first, argTypes, *signature)) {
-        atLeastOneSupported = true;
-        ++supportedFunctionSignatures;
-        signatures_.emplace_back(*callableFunction);
-      }
-    }
-
-    if (atLeastOneSupported) {
-      supportedFunctions.push_back(function.first);
-    }
-  }
-
-  auto unsupportedFunctions = totalFunctions - supportedFunctions.size();
-  auto unsupportedFunctionSignatures =
-      totalFunctionSignatures - supportedFunctionSignatures;
-  LOG(INFO) << fmt::format(
-      "Total candidate functions: {} ({} signatures)",
-      totalFunctions,
-      totalFunctionSignatures);
-  LOG(INFO) << fmt::format(
-      "Functions with at least one supported signature: {} ({:.2f}%)",
-      supportedFunctions.size(),
-      (double)supportedFunctions.size() / totalFunctions * 100);
-  LOG(INFO) << fmt::format(
-      "Functions with no supported signature: {} ({:.2f}%)",
-      unsupportedFunctions,
-      (double)unsupportedFunctions / totalFunctions * 100);
-  LOG(INFO) << fmt::format(
-      "Supported function signatures: {} ({:.2f}%)",
-      supportedFunctionSignatures,
-      (double)supportedFunctionSignatures / totalFunctionSignatures * 100);
-  LOG(INFO) << fmt::format(
-      "Unsupported function signatures: {} ({:.2f}%)",
-      unsupportedFunctionSignatures,
-      (double)unsupportedFunctionSignatures / totalFunctionSignatures * 100);
-
-  getTicketsForFunctions();
-
-  // We sort the available signatures before inserting them into
-  // typeToExpressionList_ and expressionToSignature_. The purpose of this step
-  // is to ensure the vector of function signatures associated with each key in
-  // signaturesMap_ has a deterministic order, so that we can deterministically
-  // generate expressions across platforms. We just do this once and the vector
-  // is small, so it doesn't need to be very efficient.
-  sortCallableSignatures(signatures_);
-
-  for (const auto& it : signatures_) {
-    auto returnType = typeToBaseName(it.returnType);
-    if (typeToExpressionList_[returnType].empty() ||
-        typeToExpressionList_[returnType].back() != it.name) {
-      // Ensure entries for a function name are added only once. This
-      // gives all others a fair chance to be selected. Since signatures
-      // are sorted on the function name this check will always work.
-      // Add multiple entries to increase likelihood of its selection.
-      addToTypeToExpressionListByTicketTimes(returnType, it.name);
-    }
-    expressionToSignature_[it.name][returnType].push_back(&it);
-  }
-
-  // Similarly, sort all template signatures.
-  sortSignatureTemplates(signatureTemplates_);
-
-  for (const auto& it : signatureTemplates_) {
-    auto& returnType = it.signature->returnType().baseName();
-    auto* returnTypeKey = &returnType;
-    if (it.typeVariables.find(returnType) != it.typeVariables.end()) {
-      // Return type is a template variable.
-      returnTypeKey = &kTypeParameterName;
-    }
-    if (typeToExpressionList_[*returnTypeKey].empty() ||
-        typeToExpressionList_[*returnTypeKey].back() != it.name) {
-      addToTypeToExpressionListByTicketTimes(*returnTypeKey, it.name);
-    }
-    expressionToTemplatedSignature_[it.name][*returnTypeKey].push_back(&it);
-  }
-
-  if (FLAGS_enable_dereference) {
-    addToTypeToExpressionListByTicketTimes("row", "row_constructor");
-    addToTypeToExpressionListByTicketTimes(kTypeParameterName, "dereference");
-  }
-
-  // Register function override (for cases where we want to restrict the types
-  // or parameters we pass to functions).
-  registerFuncOverride(
-      &ExpressionFuzzer::generateEmptyApproxSetArgs, "empty_approx_set");
-  registerFuncOverride(
-      &ExpressionFuzzer::generateRegexpReplaceArgs, "regexp_replace");
-  registerFuncOverride(&ExpressionFuzzer::generateSwitchArgs, "switch");
-
-  // Init stats and register listener.
-  for (auto& name : supportedFunctions) {
-    exprNameToStats_.insert({name, ExprUsageStats()});
-  }
-  statListener_ = std::make_shared<ExprStatsListener>(exprNameToStats_);
-  if (!exec::registerExprSetListener(statListener_)) {
-    LOG(WARNING) << "Listener should only be registered once.";
-  }
-}
-
-void ExpressionFuzzer::getTicketsForFunctions() {
-  if (FLAGS_assign_function_tickets.empty()) {
-    return;
-  }
-  std::vector<std::string> results;
-  boost::algorithm::split(
-      results, FLAGS_assign_function_tickets, boost::is_any_of(","));
-
-  for (auto& entry : results) {
-    std::vector<std::string> separated;
-    boost::algorithm::split(separated, entry, boost::is_any_of("="));
-    if (separated.size() != 2) {
-      LOG(FATAL)
-          << "Invalid format. Expected a function name and its number of "
-             "tickets separated by '=', instead found: "
-          << entry;
-    }
-    int tickets = 0;
-    try {
-      tickets = stoi(separated[1]);
-    } catch (std::exception& e) {
-      LOG(FATAL)
-          << "Invalid number of tickets. Expected a function name and its "
-             "number of tickets separated by '=', instead found: "
-          << entry << " Error encountered: " << e.what();
-    }
-
-    if (tickets < 1) {
-      LOG(FATAL)
-          << "Number of tickets should be a positive integer. Expected a "
-             "function name and its number of tickets separated by '=',"
-             " instead found: "
-          << entry;
-    }
-    functionsToTickets_.insert({separated[0], tickets});
-  }
-}
-
-int ExpressionFuzzer::getTickets(const std::string& funcName) {
-  auto itr = functionsToTickets_.find(funcName);
-  int tickets = 1;
-  if (itr != functionsToTickets_.end()) {
-    tickets = itr->second;
-  }
-  return tickets;
-}
-
-void ExpressionFuzzer::addToTypeToExpressionListByTicketTimes(
-    const std::string& type,
-    const std::string& funcName) {
-  int tickets = getTickets(funcName);
-  for (int i = 0; i < tickets; i++) {
-    typeToExpressionList_[type].push_back(funcName);
-  }
-}
-
-template <typename TFunc>
-void ExpressionFuzzer::registerFuncOverride(
-    TFunc func,
-    const std::string& name) {
-  funcArgOverrides_[name] = std::bind(func, this, std::placeholders::_1);
-}
-
-void ExpressionFuzzer::seed(size_t seed) {
-  currentSeed_ = seed;
-  vectorFuzzer_.reSeed(seed);
-  rng_.seed(currentSeed_);
-}
-
-void ExpressionFuzzer::reSeed() {
-  seed(rng_());
-}
-
-RowVectorPtr ExpressionFuzzer::generateRowVector() {
-  return vectorFuzzer_.fuzzInputRow(
-      ROW(std::move(inputRowNames_), std::move(inputRowTypes_)));
-}
-
-core::TypedExprPtr ExpressionFuzzer::generateArgConstant(const TypePtr& arg) {
-  if (vectorFuzzer_.coinToss(FLAGS_null_ratio)) {
-    return std::make_shared<core::ConstantTypedExpr>(
-        arg, variant::null(arg->kind()));
-  }
-  return std::make_shared<core::ConstantTypedExpr>(
-      vectorFuzzer_.fuzzConstant(arg, 1));
-}
-
-// Either generates a new column of the required type or if already generated
-// columns of the same type exist then there is a 30% chance that it will
-// re-use one of them.
-core::TypedExprPtr ExpressionFuzzer::generateArgColumn(const TypePtr& arg) {
-  auto& listOfCandidateCols = typeToColumnNames_[arg->toString()];
-  bool reuseColumn = FLAGS_velox_fuzzer_enable_column_reuse &&
-      !listOfCandidateCols.empty() && vectorFuzzer_.coinToss(0.3);
-  if (!reuseColumn) {
-    inputRowTypes_.emplace_back(arg);
-    inputRowNames_.emplace_back(fmt::format("c{}", inputRowTypes_.size() - 1));
-    listOfCandidateCols.push_back(inputRowNames_.back());
-    return std::make_shared<core::FieldAccessTypedExpr>(
-        arg, inputRowNames_.back());
-  }
-  size_t chosenColIndex = boost::random::uniform_int_distribution<uint32_t>(
-      0, listOfCandidateCols.size() - 1)(rng_);
-  return std::make_shared<core::FieldAccessTypedExpr>(
-      arg, listOfCandidateCols[chosenColIndex]);
-}
-
-core::TypedExprPtr ExpressionFuzzer::generateArg(const TypePtr& arg) {
-  size_t argClass =
-      boost::random::uniform_int_distribution<uint32_t>(0, 3)(rng_);
-
-  // Toss a coin and choose between a constant, a column reference, or another
-  // expression (function).
-  //
-  // TODO: Add more expression types:
-  // - Conjunctions
-  // - IF/ELSE/SWITCH
-  // - Lambdas
-  // - Try
-  if (argClass >= kArgExpression) {
-    if (remainingLevelOfNesting_ > 0) {
-      return generateExpression(arg);
-    }
-    argClass = boost::random::uniform_int_distribution<uint32_t>(0, 1)(rng_);
-  }
-
-  if (argClass == kArgConstant) {
-    return generateArgConstant(arg);
-  }
-  // argClass == kArgColumn
-  return generateArgColumn(arg);
-}
-
-std::vector<core::TypedExprPtr> ExpressionFuzzer::generateArgs(
-    const std::vector<TypePtr>& argTypes,
-    const std::vector<bool>& constantArgs,
-    uint32_t numVarArgs) {
-  std::vector<core::TypedExprPtr> inputExpressions;
-  inputExpressions.reserve(argTypes.size() + numVarArgs);
-
-  for (auto i = 0; i < argTypes.size(); ++i) {
-    inputExpressions.emplace_back(
-        generateArg(argTypes.at(i), constantArgs.at(i)));
-  }
-  // Append varargs to the argument list.
-  for (int i = 0; i < numVarArgs; i++) {
-    inputExpressions.emplace_back(
-        generateArg(argTypes.back(), constantArgs.back()));
-  }
-  return inputExpressions;
-}
-
-std::vector<core::TypedExprPtr> ExpressionFuzzer::generateArgs(
-    const CallableSignature& input) {
-  auto numVarArgs = !input.variableArity
-      ? 0
-      : boost::random::uniform_int_distribution<uint32_t>(
-            0, FLAGS_max_num_varargs)(rng_);
-  return generateArgs(input.args, input.constantArgs, numVarArgs);
-}
-
-core::TypedExprPtr ExpressionFuzzer::generateArg(
-    const TypePtr& arg,
-    bool isConstant) {
-  if (isConstant) {
-    return generateArgConstant(arg);
-  } else {
-    return generateArg(arg);
-  }
-}
-
-// Specialization for the "empty_approx_set" function: first optional
-// parameter needs to be constant.
-std::vector<core::TypedExprPtr> ExpressionFuzzer::generateEmptyApproxSetArgs(
-    const CallableSignature& input) {
-  if (input.args.empty()) {
-    return {};
-  }
-  return {generateArgConstant(input.args[0])};
-}
-
-// Specialization for the "regexp_replace" function: second and third
-// (optional) parameters always need to be constant.
-std::vector<core::TypedExprPtr> ExpressionFuzzer::generateRegexpReplaceArgs(
-    const CallableSignature& input) {
-  std::vector<core::TypedExprPtr> inputExpressions = {
-      generateArg(input.args[0]), generateArgConstant(input.args[1])};
-  if (input.args.size() == 3) {
-    inputExpressions.emplace_back(generateArgConstant(input.args[2]));
-  }
-  return inputExpressions;
-}
-
-std::vector<core::TypedExprPtr> ExpressionFuzzer::generateSwitchArgs(
-    const CallableSignature& input) {
-  VELOX_CHECK_EQ(
-      input.args.size(),
-      2,
-      "Only two inputs are expected from the template signature.");
-  size_t cases = boost::random::uniform_int_distribution<uint32_t>(1, 5)(rng_);
-  bool useFinalElse =
-      boost::random::uniform_int_distribution<uint32_t>(0, 1)(rng_) > 0;
-
-  auto conditionClauseType = input.args[0];
-  auto thenClauseType = input.args[1];
-  std::vector<core::TypedExprPtr> inputExpressions;
-  for (int case_idx = 0; case_idx < cases; case_idx++) {
-    inputExpressions.push_back(generateArg(conditionClauseType));
-    inputExpressions.push_back(generateArg(thenClauseType));
-  }
-  if (useFinalElse) {
-    inputExpressions.push_back(generateArg(thenClauseType));
-  }
-  return inputExpressions;
-}
-
-// Either generates a new expression of the required return type or if already
-// generated expressions of the same return type exist then there is a 30%
-// chance that it will re-use one of them.
-core::TypedExprPtr ExpressionFuzzer::generateExpression(
-    const TypePtr& returnType) {
-  VELOX_CHECK_GT(remainingLevelOfNesting_, 0);
-  --remainingLevelOfNesting_;
-  auto guard = folly::makeGuard([&] { ++remainingLevelOfNesting_; });
-
-  core::TypedExprPtr expression;
-  bool reuseExpression =
-      FLAGS_velox_fuzzer_enable_expression_reuse && vectorFuzzer_.coinToss(0.3);
-  if (reuseExpression) {
-    expression = expressionBank_.getRandomExpression(
-        returnType, remainingLevelOfNesting_ + 1);
-    if (expression) {
-      return expression;
-    }
-  }
-  auto baseType = typeToBaseName(returnType);
-  VELOX_CHECK_NE(
-      baseType, "T", "returnType should have all concrete types defined");
-  // Randomly pick among all functions that support this return type. Also,
-  // consider all functions that have return type "T" as they can
-  // support any concrete return type.
-  auto& baseList = typeToExpressionList_[baseType];
-  auto& templateList = typeToExpressionList_[kTypeParameterName];
-  uint32_t numEligible = baseList.size() + templateList.size();
-
-  if (numEligible > 0) {
-    size_t chosenExprIndex = boost::random::uniform_int_distribution<uint32_t>(
-        0, numEligible - 1)(rng_);
-    std::string chosenFunctionName;
-    if (chosenExprIndex < baseList.size()) {
-      chosenFunctionName = baseList[chosenExprIndex];
-    } else {
-      chosenExprIndex -= baseList.size();
-      chosenFunctionName = templateList[chosenExprIndex];
-    }
-
-    if (chosenFunctionName == "cast") {
-      expression = generateCastExpression(returnType);
-    } else if (chosenFunctionName == "row_constructor") {
-      // Avoid generating deeply nested types that is rarely used in practice.
-      if (levelOfNesting(returnType) < 3) {
-        expression = generateRowConstructorExpression(returnType);
-      }
-    } else if (chosenFunctionName == "dereference") {
-      expression = generateDereferenceExpression(returnType);
-    } else {
-      expression = generateExpressionFromConcreteSignatures(
-          returnType, chosenFunctionName);
-      if (!expression && FLAGS_velox_fuzzer_enable_complex_types) {
-        expression = generateExpressionFromSignatureTemplate(
-            returnType, chosenFunctionName);
-      }
-    }
-  }
-  if (!expression) {
-    VLOG(1) << "Couldn't find a proper function to return '"
-            << returnType->toString() << "'. Returning a constant instead.";
-    return generateArgConstant(returnType);
-  }
-  expressionBank_.insert(expression);
-  return expression;
-}
-
-std::vector<core::TypedExprPtr> ExpressionFuzzer::getArgsForCallable(
-    const CallableSignature& callable) {
-  auto funcIt = funcArgOverrides_.find(callable.name);
-  if (funcIt == funcArgOverrides_.end()) {
-    return generateArgs(callable);
-  }
-  return funcIt->second(callable);
-}
-
-core::TypedExprPtr ExpressionFuzzer::getCallExprFromCallable(
-    const CallableSignature& callable,
-    const TypePtr& type) {
-  auto args = getArgsForCallable(callable);
-  // Generate a CallTypedExpr with type because callable.returnType may not have
-  // the required field names.
-  return std::make_shared<core::CallTypedExpr>(type, args, callable.name);
-}
-
-const CallableSignature* ExpressionFuzzer::chooseRandomConcreteSignature(
-    const TypePtr& returnType,
-    const std::string& functionName) {
-  if (expressionToSignature_.find(functionName) ==
-      expressionToSignature_.end()) {
-    return nullptr;
-  }
-  auto baseType = typeToBaseName(returnType);
-  auto itr = expressionToSignature_[functionName].find(baseType);
-  if (itr == expressionToSignature_[functionName].end()) {
-    return nullptr;
-  }
-  // Only function signatures whose return type equals to returnType are
-  // eligible. There may be ineligible signatures in signaturesMap_ because
-  // the map keys only differentiate top-level type kinds.
-  std::vector<const CallableSignature*> eligible;
-  for (auto signature : itr->second) {
-    if (signature->returnType->equivalent(*returnType)) {
-      eligible.push_back(signature);
-    }
-  }
-  if (eligible.empty()) {
-    return nullptr;
-  }
-
-  // Randomly pick a function that can return `returnType`.
-  size_t idx = boost::random::uniform_int_distribution<uint32_t>(
-      0, eligible.size() - 1)(rng_);
-  return eligible[idx];
-}
-
-core::TypedExprPtr ExpressionFuzzer::generateExpressionFromConcreteSignatures(
-    const TypePtr& returnType,
-    const std::string& functionName) {
-  const auto* chosen = chooseRandomConcreteSignature(returnType, functionName);
-  if (!chosen) {
-    return nullptr;
-  }
-
-  markSelected(chosen->name);
-  return getCallExprFromCallable(*chosen, returnType);
-}
-
-const SignatureTemplate* ExpressionFuzzer::chooseRandomSignatureTemplate(
-    const TypePtr& returnType,
-    const std::string& typeName,
-    const std::string& functionName) {
-  std::vector<const SignatureTemplate*> eligible;
-  if (expressionToTemplatedSignature_.find(functionName) ==
-      expressionToTemplatedSignature_.end()) {
-    return nullptr;
-  }
-  auto it = expressionToTemplatedSignature_[functionName].find(typeName);
-  if (it == expressionToTemplatedSignature_[functionName].end()) {
-    return nullptr;
-  }
-  // Only function signatures whose return type can match returnType are
-  // eligible. There may be ineligible signatures in signaturesMap_ because
-  // the map keys only differentiate the top-level type names.
-  auto& signatureTemplates = it->second;
-  for (auto signatureTemplate : signatureTemplates) {
-    exec::ReverseSignatureBinder binder{
-        *signatureTemplate->signature, returnType};
-    if (binder.tryBind()) {
-      eligible.push_back(signatureTemplate);
-    }
-  }
-  if (eligible.empty()) {
-    return nullptr;
-  }
-
-  auto idx = boost::random::uniform_int_distribution<uint32_t>(
-      0, eligible.size() - 1)(rng_);
-  return eligible[idx];
-}
-
-core::TypedExprPtr ExpressionFuzzer::generateExpressionFromSignatureTemplate(
-    const TypePtr& returnType,
-    const std::string& functionName) {
-  auto typeName = typeToBaseName(returnType);
-
-  auto* chosen =
-      chooseRandomSignatureTemplate(returnType, typeName, functionName);
-  if (!chosen) {
-    chosen = chooseRandomSignatureTemplate(
-        returnType, kTypeParameterName, functionName);
-    if (!chosen) {
-      return nullptr;
-    }
-  }
-
-  auto chosenSignature = *chosen->signature;
-  ArgumentTypeFuzzer fuzzer{chosenSignature, returnType, rng_};
-  VELOX_CHECK_EQ(fuzzer.fuzzArgumentTypes(FLAGS_max_num_varargs), true);
-  auto& argumentTypes = fuzzer.argumentTypes();
-  auto constantArguments = chosenSignature.constantArguments();
-
-  // ArgumentFuzzer may generate duplicate arguments if the signature's
-  // variableArity is true, so we need to pad duplicate constant flags.
-  if (!constantArguments.empty()) {
-    auto repeat = argumentTypes.size() - constantArguments.size();
-    auto lastConstant = constantArguments.back();
-    for (int i = 0; i < repeat; ++i) {
-      constantArguments.push_back(lastConstant);
-    }
-  }
-
-  CallableSignature callable{
-      .name = chosen->name,
-      .args = argumentTypes,
-      .variableArity = false,
-      .returnType = returnType,
-      .constantArgs = constantArguments};
-
-  markSelected(chosen->name);
-  return getCallExprFromCallable(callable, returnType);
-}
-
-core::TypedExprPtr ExpressionFuzzer::generateCastExpression(
-    const TypePtr& returnType) {
-  const auto* callable = chooseRandomConcreteSignature(returnType, "cast");
-  if (!callable) {
-    return nullptr;
-  }
-
-  auto args = getArgsForCallable(*callable);
-  markSelected("cast");
-
-  // Generate try_cast expression with 50% chance.
-  bool nullOnFailure =
-      boost::random::uniform_int_distribution<uint32_t>(0, 1)(rng_);
-  return std::make_shared<core::CastTypedExpr>(returnType, args, nullOnFailure);
-}
-
-core::TypedExprPtr ExpressionFuzzer::generateRowConstructorExpression(
-    const TypePtr& returnType) {
-  VELOX_CHECK(returnType->isRow());
-  auto argTypes = asRowType(returnType)->children();
-  std::vector<bool> constantArgs(argTypes.size(), false);
-
-  auto inputExpressions = generateArgs(argTypes, constantArgs);
-  return std::make_shared<core::ConcatTypedExpr>(
-      asRowType(returnType)->names(), inputExpressions);
-}
-
-TypePtr ExpressionFuzzer::generateRandomRowTypeWithReferencedField(
-    uint32_t numFields,
-    uint32_t referencedIndex,
-    const TypePtr& referencedType) {
-  std::vector<TypePtr> fieldTypes(numFields);
-  std::vector<std::string> fieldNames(numFields);
-  for (auto i = 0; i < numFields; ++i) {
-    if (i == referencedIndex) {
-      fieldTypes[i] = referencedType;
-    } else {
-      fieldTypes[i] = vectorFuzzer_.randType();
-    }
-    fieldNames[i] = fmt::format("row_field{}", i);
-  }
-  return ROW(std::move(fieldNames), std::move(fieldTypes));
-}
-
-core::TypedExprPtr ExpressionFuzzer::generateDereferenceExpression(
-    const TypePtr& returnType) {
-  auto numFields =
-      boost::random::uniform_int_distribution<uint32_t>(1, 3)(rng_);
-  auto referencedIndex =
-      boost::random::uniform_int_distribution<uint32_t>(0, numFields - 1)(rng_);
-  auto argType = generateRandomRowTypeWithReferencedField(
-      numFields, referencedIndex, returnType);
-
-  auto inputExpressions = generateArgs({argType}, {false});
-  return std::make_shared<core::FieldAccessTypedExpr>(
-      returnType,
-      inputExpressions[0],
-      fmt::format("row_field{}", referencedIndex));
-}
-
-template <typename T>
-bool ExpressionFuzzer::isDone(size_t i, T startTime) const {
-  if (FLAGS_duration_sec > 0) {
-    std::chrono::duration<double> elapsed =
-        std::chrono::system_clock::now() - startTime;
-    return elapsed.count() >= FLAGS_duration_sec;
-  }
-  return i >= FLAGS_steps;
-}
-
-void ExpressionFuzzer::reset() {
-  VELOX_CHECK(inputRowTypes_.empty());
-  VELOX_CHECK(inputRowNames_.empty());
-  typeToColumnNames_.clear();
-  expressionBank_.reset();
-}
-
-void ExpressionFuzzer::logStats() {
-  std::vector<std::pair<std::string, ExprUsageStats>> entries;
-  uint64_t totalSelections = 0;
-  for (auto& elem : exprNameToStats_) {
-    totalSelections += elem.second.numTimesSelected;
-    entries.push_back(elem);
-  }
-
-  // sort by numProcessedRows
-  std::sort(entries.begin(), entries.end(), [](auto& left, auto& right) {
-    return left.second.numProcessedRows > right.second.numProcessedRows;
-  });
-  int maxEntriesLimit = std::min<size_t>(10, entries.size());
-  LOG(INFO) << "==============================> Top " << maxEntriesLimit
-            << " by number of rows processed";
-  LOG(INFO)
-      << "Format: functionName numTimesSelected proportionOfTimesSelected "
-         "numProcessedRows";
-  for (int i = 0; i < maxEntriesLimit; i++) {
-    LOG(INFO) << entries[i].first << " " << entries[i].second.numTimesSelected
-              << " " << std::fixed << std::setprecision(2)
-              << (entries[i].second.numTimesSelected * 100.00) / totalSelections
-              << "% " << entries[i].second.numProcessedRows;
-  }
-
-  LOG(INFO) << "==============================> Bottom " << maxEntriesLimit
-            << " by number of rows processed";
-  LOG(INFO)
-      << "Format: functionName numTimesSelected proportionOfTimesSelected "
-         "numProcessedRows";
-  for (int i = 0; i < maxEntriesLimit; i++) {
-    int idx = entries.size() - 1 - i;
-    LOG(INFO) << entries[idx].first << " "
-              << entries[idx].second.numTimesSelected << " " << std::fixed
-              << std::setprecision(2)
-              << (entries[idx].second.numTimesSelected * 100.00) /
-            totalSelections
-              << "% " << entries[idx].second.numProcessedRows;
-  }
-
-  // sort by numTimesSelected
-  std::sort(entries.begin(), entries.end(), [](auto& left, auto& right) {
-    return left.second.numTimesSelected > right.second.numTimesSelected;
-  });
-
-  LOG(INFO) << "==============================> All stats sorted by number "
-               "of times the function was chosen";
-  LOG(INFO)
-      << "Format: functionName numTimesSelected proportionOfTimesSelected "
-         "numProcessedRows";
-  for (auto& elem : entries) {
-    LOG(INFO) << elem.first << " " << elem.second.numTimesSelected << " "
-              << std::fixed << std::setprecision(2)
-              << (elem.second.numTimesSelected * 100.00) / totalSelections
-              << "% " << elem.second.numProcessedRows;
-  }
-}
-
-void ExpressionFuzzer::ExprBank::insert(const core::TypedExprPtr& expression) {
-  auto typeString = expression->type()->toString();
-  if (typeToExprsByLevel_.find(typeString) == typeToExprsByLevel_.end()) {
-    typeToExprsByLevel_.insert(
-        {typeString, ExprsIndexedByLevel(maxLevelOfNesting_ + 1)});
-  }
-  auto& expressionsByLevel = typeToExprsByLevel_[typeString];
-  int nestingLevel = getNestedLevel(expression);
-  VELOX_CHECK_LE(nestingLevel, maxLevelOfNesting_);
-  expressionsByLevel[nestingLevel].push_back(expression);
-}
-
-core::TypedExprPtr ExpressionFuzzer::ExprBank::getRandomExpression(
-    const facebook::velox::TypePtr& returnType,
-    int uptoLevelOfNesting) {
-  VELOX_CHECK_LE(uptoLevelOfNesting, maxLevelOfNesting_);
-  auto typeString = returnType->toString();
-  if (typeToExprsByLevel_.find(typeString) == typeToExprsByLevel_.end()) {
-    return nullptr;
-  }
-  auto& expressionsByLevel = typeToExprsByLevel_[typeString];
-  int totalToConsider = 0;
-  for (int i = 0; i <= uptoLevelOfNesting; i++) {
-    totalToConsider += expressionsByLevel[i].size();
-  }
-  if (totalToConsider > 0) {
-    int choice = boost::random::uniform_int_distribution<uint32_t>(
-        0, totalToConsider - 1)(rng_);
-    for (int i = 0; i <= uptoLevelOfNesting; i++) {
-      if (choice >= expressionsByLevel[i].size()) {
-        choice -= expressionsByLevel[i].size();
-        continue;
-      }
-      return expressionsByLevel[i][choice];
-    }
-    VELOX_CHECK(false, "Should have found an expression.");
-  }
-  return nullptr;
-}
-
-// Generates a row vector with child vectors corresponding to the same type as
-// the return type of the expression trees in 'plans'. These are used as
-// pre-allocated result vectors to be passed during expression evaluation.
-RowVectorPtr ExpressionFuzzer::generateResultVectors(
-    std::vector<core::TypedExprPtr>& plans) {
-  std::vector<VectorPtr> results;
-  std::vector<std::shared_ptr<const Type>> resultTypes;
-  size_t vectorSize = vectorFuzzer_.getOptions().vectorSize;
-  for (auto& plan : plans) {
-    results.push_back(
-        vectorFuzzer_.coinToss(0.5) ? vectorFuzzer_.fuzzFlat(plan->type())
-                                    : nullptr);
-    resultTypes.push_back(plan->type());
-  }
-  auto rowType = ROW(std::move(resultTypes));
-  return std::make_shared<RowVector>(
-      pool_.get(), rowType, BufferPtr(nullptr), vectorSize, results);
-}
-
-TypePtr ExpressionFuzzer::generateRootType() {
-  auto chooseFromConcreteSignatures =
-      boost::random::uniform_int_distribution<uint32_t>(0, 1)(rng_);
-
-  chooseFromConcreteSignatures =
-      (chooseFromConcreteSignatures && !signatures_.empty()) ||
-      (!chooseFromConcreteSignatures && signatureTemplates_.empty());
-  TypePtr rootType;
-  if (signatures_.empty() && signatureTemplates_.empty() &&
-      FLAGS_enable_dereference) {
-    // Dereference does not have signatures in either list. So even if these
-    // signature lists are both empty, we can still generate a random return
-    // type for dereference.
-    rootType = vectorFuzzer_.randType();
-  } else if (chooseFromConcreteSignatures) {
-    // Pick a random signature to choose the root return type.
-    VELOX_CHECK(!signatures_.empty(), "No function signature available.");
-    size_t idx = boost::random::uniform_int_distribution<uint32_t>(
-        0, signatures_.size() - 1)(rng_);
-    rootType = signatures_[idx].returnType;
-  } else {
-    // Pick a random concrete return type that can bind to the return type of
-    // a chosen signature.
-    VELOX_CHECK(
-        !signatureTemplates_.empty(), "No function signature available.");
-    size_t idx = boost::random::uniform_int_distribution<uint32_t>(
-        0, signatureTemplates_.size() - 1)(rng_);
-    ArgumentTypeFuzzer typeFuzzer{*signatureTemplates_[idx].signature, rng_};
-    rootType = typeFuzzer.fuzzReturnType();
-  }
-  return rootType;
-}
-
-void ExpressionFuzzer::retryWithTry(
-    std::vector<core::TypedExprPtr> plans,
-    const RowVectorPtr& rowVector,
-    const VectorPtr& resultVector,
-    const std::vector<int>& columnsToWrapInLazy) {
-  // Wrap each expression tree with 'try'.
-  std::vector<core::TypedExprPtr> tryPlans;
-  for (auto& plan : plans) {
-    tryPlans.push_back(std::make_shared<core::CallTypedExpr>(
-        plan->type(), std::vector<core::TypedExprPtr>{plan}, "try"));
-  }
-
-  RowVectorPtr tryResult;
-
-  // The function throws if anything goes wrong.
-  try {
-    tryResult =
-        verifier_
-            .verify(
-                tryPlans,
-                rowVector,
-                resultVector ? BaseVector::copy(*resultVector) : nullptr,
-                false, // canThrow
-                columnsToWrapInLazy)
-            .result;
-  } catch (const std::exception& e) {
-    if (FLAGS_find_minimal_subexpression) {
-      computeMinimumSubExpression(
-          {&execCtx_, {false, ""}},
-          vectorFuzzer_,
-          plans,
-          rowVector,
-          columnsToWrapInLazy);
-    }
-    throw;
-  }
-
-  // Re-evaluate the original expression on rows that didn't produce an
-  // error (i.e. returned non-NULL results when evaluated with TRY).
-  BufferPtr noErrorIndices = extractNonNullIndices(tryResult);
-
-  if (noErrorIndices != nullptr) {
-    auto noErrorRowVector = wrapChildren(noErrorIndices, rowVector);
-
-    LOG(INFO) << "Retrying original expression on " << noErrorRowVector->size()
-              << " rows without errors";
-
-    try {
-      verifier_.verify(
-          plans,
-          noErrorRowVector,
-          resultVector ? BaseVector::copy(*resultVector)
-                             ->slice(0, noErrorRowVector->size())
-                       : nullptr,
-          false, // canThrow
-          columnsToWrapInLazy);
-    } catch (const std::exception& e) {
-      if (FLAGS_find_minimal_subexpression) {
-        computeMinimumSubExpression(
-            {&execCtx_, {false, ""}},
-            vectorFuzzer_,
-            plans,
-            noErrorRowVector,
-            columnsToWrapInLazy);
-      }
-      throw;
-    }
-  }
-}
-
-void ExpressionFuzzer::go() {
-  VELOX_CHECK(
-      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
-      "Either --steps or --duration_sec needs to be greater than zero.")
-  VELOX_CHECK_GT(
-      FLAGS_max_expression_trees_per_step,
-      0,
-      "--max_expression_trees_per_step needs to be greater than zero.")
-
-  auto startTime = std::chrono::system_clock::now();
-  size_t i = 0;
-
-  while (!isDone(i, startTime)) {
-    LOG(INFO) << "==============================> Started iteration " << i
-              << " (seed: " << currentSeed_ << ")";
-    reset();
-
-    // Generate multiple expression trees and input data vectors. They can
-    // re-use columns and share sub-expressions if the appropriate flag is set.
-    int numExpressionTrees = boost::random::uniform_int_distribution<int>(
-        1, FLAGS_max_expression_trees_per_step)(rng_);
-    std::vector<core::TypedExprPtr> plans(numExpressionTrees);
-    for (int j = 0; j < numExpressionTrees; ++j) {
-      plans[j] = generateExpression(generateRootType());
-    }
-    auto rowVector = generateRowVector();
-    auto columnsToWrapInLazy = generateLazyColumnIds(rowVector, vectorFuzzer_);
-    auto resultVectors = generateResultVectors(plans);
-    ResultOrError result;
-
-    try {
-      result = verifier_.verify(
-          plans,
-          rowVector,
-          resultVectors ? BaseVector::copy(*resultVectors) : nullptr,
-          true, // canThrow
-          columnsToWrapInLazy);
-    } catch (const std::exception& e) {
-      if (FLAGS_find_minimal_subexpression) {
-        computeMinimumSubExpression(
-            {&execCtx_, {false, ""}},
-            vectorFuzzer_,
-            plans,
-            rowVector,
-            columnsToWrapInLazy);
-      }
-      throw;
-    }
-
-    // If both paths threw compatible exceptions, we add a try() function to
-    // the expression's root and execute it again. This time the expression
-    // cannot throw.
-    if (result.exceptionPtr && FLAGS_retry_with_try) {
-      LOG(INFO)
-          << "Both paths failed with compatible exceptions. Retrying expression using try().";
-      retryWithTry(plans, rowVector, resultVectors, columnsToWrapInLazy);
-    }
-
-    LOG(INFO) << "==============================> Done with iteration " << i;
-    reSeed();
-    ++i;
-  }
-  logStats();
-}
-
-void expressionFuzzer(FunctionSignatureMap signatureMap, size_t seed) {
-  ExpressionFuzzer(std::move(signatureMap), seed).go();
-}
-
-} // namespace facebook::velox::test
diff --git a/velox/expression/tests/ExpressionFuzzer.h b/velox/expression/tests/ExpressionFuzzer.h
deleted file mode 100644
index ecbb122b9730f..0000000000000
--- a/velox/expression/tests/ExpressionFuzzer.h
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/core/ITypedExpr.h"
-#include "velox/core/QueryCtx.h"
-#include "velox/expression/Expr.h"
-#include "velox/expression/tests/ExpressionVerifier.h"
-#include "velox/expression/tests/FuzzerToolkit.h"
-#include "velox/functions/FunctionRegistry.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
-
-DECLARE_int32(velox_fuzzer_max_level_of_nesting);
-
-namespace facebook::velox::test {
-
-// Generates random expressions based on `signatures`, random input data (via
-// VectorFuzzer), and executes them.
-void expressionFuzzer(FunctionSignatureMap signatureMap, size_t seed);
-
-class ExpressionFuzzer {
- public:
-  ExpressionFuzzer(
-      FunctionSignatureMap signatureMap,
-      size_t initialSeed,
-      int32_t maxLevelOfNesting = FLAGS_velox_fuzzer_max_level_of_nesting);
-
-  template <typename TFunc>
-  void registerFuncOverride(TFunc func, const std::string& name);
-
-  void go();
-
-  /// Return a random legit expression that returns returnType.
-  core::TypedExprPtr generateExpression(const TypePtr& returnType);
-
-  /// Used to enable re-use of sub-expressions by exposing an API that allows
-  /// for randomly picking an expression that has a specific return type and a
-  /// nesting level less than or equal to a specified limit. It ensures that all
-  /// expressions that are valid candidates have an equal probability of
-  /// selection.
-  class ExprBank {
-   public:
-    ExprBank(FuzzerGenerator& rng, int maxLevelOfNesting)
-        : rng_(rng), maxLevelOfNesting_(maxLevelOfNesting) {}
-
-    /// Adds an expression to the bank.
-    void insert(const core::TypedExprPtr& expression);
-
-    /// Returns a randomly selected expression of the requested 'returnType'
-    /// which is guaranteed to have a nesting level less than or equal to
-    /// 'uptoLevelOfNesting'. Returns a nullptr if no such function can be
-    /// found.
-    core::TypedExprPtr getRandomExpression(
-        const TypePtr& returnType,
-        int uptoLevelOfNesting);
-
-    /// Removes all the expressions from the bank. Should be called after
-    /// every fuzzer iteration.
-    void reset() {
-      typeToExprsByLevel_.clear();
-    }
-
-   private:
-    int getNestedLevel(const core::TypedExprPtr& expression) {
-      int level = 0;
-      for (auto& input : expression->inputs()) {
-        level = std::max(level, getNestedLevel(input) + 1);
-      }
-      return level;
-    }
-
-    /// Reference to the random generator of the expression fuzzer.
-    FuzzerGenerator& rng_;
-
-    /// Only expression having less than or equal to this level of nesting will
-    /// be supported.
-    int maxLevelOfNesting_;
-
-    /// Represents a vector where each index contains a list of expressions such
-    /// that the depth of each expression tree is equal to that index.
-    typedef std::vector<std::vector<core::TypedExprPtr>> ExprsIndexedByLevel;
-
-    /// Maps a 'Type' serialized as a string to an object of type
-    /// ExprsIndexedByLevel
-    std::unordered_map<std::string, ExprsIndexedByLevel> typeToExprsByLevel_;
-  };
-
- private:
-  struct ExprUsageStats {
-    // Num of times the expression was randomly selected.
-    int numTimesSelected = 0;
-    // Num of rows processed by the expression.
-    int numProcessedRows = 0;
-  };
-
-  // A utility class used to keep track of stats relevant to the fuzzer.
-  class ExprStatsListener : public exec::ExprSetListener {
-   public:
-    explicit ExprStatsListener(
-        std::unordered_map<std::string, ExprUsageStats>& exprNameToStats)
-        : exprNameToStats_(exprNameToStats) {}
-
-    void onCompletion(
-        const std::string& /*uuid*/,
-        const exec::ExprSetCompletionEvent& event) override {
-      for (auto& [funcName, stats] : event.stats) {
-        auto itr = exprNameToStats_.find(funcName);
-        if (itr == exprNameToStats_.end()) {
-          // Skip expressions like FieldReference and ConstantExpr
-          continue;
-        }
-        itr->second.numProcessedRows += stats.numProcessedRows;
-      }
-    }
-
-    // A no-op since we cannot tie errors directly to functions where they
-    // occurred.
-    void onError(
-        const SelectivityVector& /*rows*/,
-        const ::facebook::velox::ErrorVector& /*errors*/,
-        const std::string& /*queryId*/) override {}
-
-   private:
-    std::unordered_map<std::string, ExprUsageStats>& exprNameToStats_;
-  };
-
-  const std::string kTypeParameterName = "T";
-
-  enum ArgumentKind { kArgConstant = 0, kArgColumn = 1, kArgExpression = 2 };
-
-  void seed(size_t seed);
-
-  void reSeed();
-
-  // Parse --assign_function_tickets startup flag into a map that maps function
-  // name to its number of tickets.
-  void getTicketsForFunctions();
-
-  // Get tickets for one function assigned by the --assign_function_tickets
-  // flag. This function should be called after getTicketsForFunctions().
-  int getTickets(const std::string& funcName);
-
-  // Add `funcName` that returns `type` to typeToExpressionList_.
-  void addToTypeToExpressionListByTicketTimes(
-      const std::string& type,
-      const std::string& funcName);
-
-  void appendConjunctSignatures();
-
-  TypePtr generateRootType();
-
-  RowVectorPtr generateRowVector();
-
-  /// Randomize initial result vector data to test for correct null and data
-  /// setting in functions.
-  RowVectorPtr generateResultVectors(std::vector<core::TypedExprPtr>& plans);
-
-  core::TypedExprPtr generateArgConstant(const TypePtr& arg);
-
-  core::TypedExprPtr generateArgColumn(const TypePtr& arg);
-
-  core::TypedExprPtr generateArg(const TypePtr& arg);
-
-  std::vector<core::TypedExprPtr> generateArgs(const CallableSignature& input);
-
-  std::vector<core::TypedExprPtr> generateArgs(
-      const std::vector<TypePtr>& argTypes,
-      const std::vector<bool>& constantArgs,
-      uint32_t numVarArgs = 0);
-
-  core::TypedExprPtr generateArg(const TypePtr& arg, bool isConstant);
-
-  /// Specialization for the "like" function: second and third (optional)
-  /// parameters always need to be constant.
-  std::vector<core::TypedExprPtr> generateLikeArgs(
-      const CallableSignature& input);
-
-  /// Specialization for the "empty_approx_set" function: first optional
-  /// parameter needs to be constant.
-  std::vector<core::TypedExprPtr> generateEmptyApproxSetArgs(
-      const CallableSignature& input);
-
-  /// Specialization for the "regexp_replace" function: second and third
-  /// (optional) parameters always need to be constant.
-  std::vector<core::TypedExprPtr> generateRegexpReplaceArgs(
-      const CallableSignature& input);
-
-  // Return a vector of expressions for each argument of callable in order.
-  std::vector<core::TypedExprPtr> getArgsForCallable(
-      const CallableSignature& callable);
-
-  /// Specialization for the "switch" function. Takes in a signature that is of
-  /// the form Switch (condition, then): boolean, T -> T where the type variable
-  /// is bounded to a randomly selected type. It randomly decides the number
-  /// of cases (upto a max of 5) to generate and whether to include the else
-  /// clause. Finally, uses the type specified in the signature to generate
-  /// inputs with that return type.
-  std::vector<core::TypedExprPtr> generateSwitchArgs(
-      const CallableSignature& input);
-
-  core::TypedExprPtr getCallExprFromCallable(
-      const CallableSignature& callable,
-      const TypePtr& type);
-
-  /// Executes two steps:
-  /// #1. Retries executing the expression in `plan` by wrapping it in a `try()`
-  ///     clause and expecting it not to throw an exception.
-  /// #2. Re-execute the expression only on rows that produced non-NULL values
-  ///     in the previous step.
-  ///
-  /// Throws in case any of these steps fail.
-  void retryWithTry(
-      std::vector<core::TypedExprPtr> plans,
-      const RowVectorPtr& rowVector,
-      const VectorPtr& resultVectors,
-      const std::vector<int>& columnsToWrapInLazy);
-
-  /// Return a random signature mapped to functionName in expressionToSignature_
-  /// whose return type can match returnType. Return nullptr if no such
-  /// signature template exists.
-  const CallableSignature* chooseRandomConcreteSignature(
-      const TypePtr& returnType,
-      const std::string& functionName);
-
-  /// Generate an expression by randomly selecting a concrete function signature
-  /// that returns 'returnType' among all signatures that the function named
-  /// 'functionName' supports.
-  core::TypedExprPtr generateExpressionFromConcreteSignatures(
-      const TypePtr& returnType,
-      const std::string& functionName);
-
-  /// Return a random signature template mapped to typeName and functionName in
-  /// expressionToTemplatedSignature_ whose return type can match returnType.
-  /// Return nullptr if no such signature template exists.
-  const SignatureTemplate* chooseRandomSignatureTemplate(
-      const TypePtr& returnType,
-      const std::string& typeName,
-      const std::string& functionName);
-
-  /// Generate an expression by randomly selecting a function signature template
-  /// that returns 'returnType' among all signature templates that the function
-  /// named 'functionName' supports.
-  core::TypedExprPtr generateExpressionFromSignatureTemplate(
-      const TypePtr& returnType,
-      const std::string& functionName);
-
-  /// Generate a cast expression that returns the specified type. Return a
-  /// nullptr if casting to the specified type is not supported. The supported
-  /// types include primitive types, array, map, and row types right now.
-  core::TypedExprPtr generateCastExpression(const TypePtr& returnType);
-
-  // Generate an expression of the row_constructor special form that returns
-  // `returnType`. `returnType` must be a RowType.
-  core::TypedExprPtr generateRowConstructorExpression(
-      const TypePtr& returnType);
-
-  // Generate a random row type with `referencedType` be its field at
-  // `referencedIndex`.
-  TypePtr generateRandomRowTypeWithReferencedField(
-      uint32_t numFields,
-      uint32_t referencedIndex,
-      const TypePtr& referencedType);
-
-  // Generate an expression of the dereference special form that returns
-  // `returnType`.
-  core::TypedExprPtr generateDereferenceExpression(const TypePtr& returnType);
-
-  /// If --duration_sec > 0, check if we expired the time budget. Otherwise,
-  /// check if we expired the number of iterations (--steps).
-  template <typename T>
-  bool isDone(size_t i, T startTime) const;
-
-  /// Reset any stateful members. Should be called before every fuzzer
-  /// iteration.
-  void reset();
-
-  /// Should be called whenever a function is selected by the fuzzer.
-  void markSelected(const std::string& funcName) {
-    exprNameToStats_[funcName].numTimesSelected++;
-  }
-
-  /// Called at the end of a successful fuzzer run. It logs the top and bottom
-  /// 10 functions based on the num of rows processed by them. Also logs a full
-  /// list of all functions sorted in descending order by the num of times they
-  /// were selected by the fuzzer. Every logged function contains the
-  /// information in the following format which can be easily exported to a
-  /// spreadsheet for further analysis: functionName numTimesSelected
-  /// proportionOfTimesSelected numProcessedRows.
-  void logStats();
-
-  FuzzerGenerator rng_;
-  size_t currentSeed_{0};
-
-  std::vector<CallableSignature> signatures_;
-  std::vector<SignatureTemplate> signatureTemplates_;
-
-  /// Maps the base name of a return type signature to the function names that
-  /// support that return type. Base name could be "T" if the return type is a
-  /// type variable.
-  std::unordered_map<std::string, std::vector<std::string>>
-      typeToExpressionList_;
-
-  /// Maps the base name of a *concrete* return type signature to the function
-  /// names that support that return type. Those names then each further map to
-  /// a list of CallableSignature objects that they support. Base name could be
-  /// "T" if the return type is a type variable.
-  std::unordered_map<
-      std::string,
-      std::unordered_map<std::string, std::vector<const CallableSignature*>>>
-      expressionToSignature_;
-
-  /// Maps the base name of a *templated* return type signature to the function
-  /// names that support that return type. Those names then each further map to
-  /// a list of SignatureTemplate objects that they support. Base name could be
-  /// "T" if the return type is a type variable.
-  std::unordered_map<
-      std::string,
-      std::unordered_map<std::string, std::vector<const SignatureTemplate*>>>
-      expressionToTemplatedSignature_;
-
-  // A map that maps function name to its number of tickets parsed from the
-  // --assign_function_tickets startup flag .
-  std::unordered_map<std::string, int> functionsToTickets_;
-
-  /// The remaining levels of expression nesting. It's initialized by
-  /// FLAGS_max_level_of_nesting and updated in generateExpression(). When its
-  /// value decreases to 0, we don't generate subexpressions anymore.
-  int32_t remainingLevelOfNesting_;
-
-  /// We allow the arg generation routine to be specialized for particular
-  /// functions. This map stores the mapping between function name and the
-  /// overridden method.
-  using ArgsOverrideFunc = std::function<std::vector<core::TypedExprPtr>(
-      const CallableSignature& input)>;
-  std::unordered_map<std::string, ArgsOverrideFunc> funcArgOverrides_;
-
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  core::ExecCtx execCtx_{pool_.get(), queryCtx_.get()};
-  test::ExpressionVerifier verifier_;
-
-  test::VectorMaker vectorMaker_{execCtx_.pool()};
-  VectorFuzzer vectorFuzzer_;
-
-  /// Contains the input column references that need to be generated for one
-  /// particular iteration.
-  std::vector<TypePtr> inputRowTypes_;
-  std::vector<std::string> inputRowNames_;
-
-  /// Maps a 'Type' serialized as a string to the column names that have already
-  /// been generated. Used to easily look up columns that can be re-used when a
-  /// specific type is required as input to a callable.
-  std::unordered_map<std::string, std::vector<std::string>> typeToColumnNames_;
-
-  /// Used to track all generated expressions and support expreesion re-use.
-  ExprBank expressionBank_;
-
-  std::shared_ptr<ExprStatsListener> statListener_;
-  std::unordered_map<std::string, ExprUsageStats> exprNameToStats_;
-};
-
-} // namespace facebook::velox::test
diff --git a/velox/expression/tests/ExpressionFuzzerTest.cpp b/velox/expression/tests/ExpressionFuzzerTest.cpp
deleted file mode 100644
index 6af44a8b1a56d..0000000000000
--- a/velox/expression/tests/ExpressionFuzzerTest.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/init/Init.h>
-#include <gtest/gtest.h>
-#include <unordered_set>
-
-#include "velox/expression/tests/FuzzerRunner.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-
-DEFINE_int64(
-    seed,
-    0,
-    "Initial seed for random number generator used to reproduce previous "
-    "results (0 means start with random seed).");
-
-DEFINE_string(
-    only,
-    "",
-    "If specified, Fuzzer will only choose functions from "
-    "this comma separated list of function names "
-    "(e.g: --only \"split\" or --only \"substr,ltrim\").");
-
-DEFINE_string(
-    special_forms,
-    "and,or,cast,coalesce,if,switch",
-    "Comma-separated list of special forms to use in generated expression. "
-    "Supported special forms: and, or, coalesce, if, switch, cast.");
-
-int main(int argc, char** argv) {
-  facebook::velox::functions::prestosql::registerAllScalarFunctions();
-
-  ::testing::InitGoogleTest(&argc, argv);
-
-  // Calls common init functions in the necessary order, initializing
-  // singletons, installing proper signal handlers for better debugging
-  // experience, and initialize glog and gflags.
-  folly::init(&argc, &argv);
-
-  // TODO: List of the functions that at some point crash or fail and need to
-  // be fixed before we can enable.
-  std::unordered_set<std::string> skipFunctions = {
-      // Fuzzer and the underlying engine are confused about cardinality(HLL)
-      // (since HLL is a user defined type), and end up trying to use
-      // cardinality passing a VARBINARY (since HLL's implementation uses an
-      // alias to VARBINARY).
-      "cardinality",
-      "element_at",
-      "width_bucket",
-  };
-  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
-  return FuzzerRunner::run(
-      FLAGS_only, initialSeed, skipFunctions, FLAGS_special_forms);
-}
diff --git a/velox/expression/tests/ExpressionRunner.cpp b/velox/expression/tests/ExpressionRunner.cpp
index 86cf21db362e1..f6d9320e59f6a 100644
--- a/velox/expression/tests/ExpressionRunner.cpp
+++ b/velox/expression/tests/ExpressionRunner.cpp
@@ -115,20 +115,26 @@ void ExpressionRunner::run(
     vector_size_t numRows,
     const std::string& storeResultPath,
     const std::string& lazyColumnListPath,
-    bool findMinimalSubExpression) {
+    bool findMinimalSubExpression,
+    bool useSeperatePoolForInput) {
   VELOX_CHECK(!sql.empty());
-
-  std::shared_ptr<core::QueryCtx> queryCtx{std::make_shared<core::QueryCtx>()};
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  auto memoryManager = memory::memoryManager();
+  auto queryCtx = core::QueryCtx::create();
+  std::shared_ptr<memory::MemoryPool> deserializerPool{
+      memoryManager->addLeafPool()};
+  std::shared_ptr<memory::MemoryPool> pool = useSeperatePoolForInput
+      ? memoryManager->addLeafPool("exprEval")
+      : deserializerPool;
   core::ExecCtx execCtx{pool.get(), queryCtx.get()};
 
   RowVectorPtr inputVector;
+
   if (inputPath.empty()) {
     inputVector = std::make_shared<RowVector>(
-        pool.get(), ROW({}), nullptr, 1, std::vector<VectorPtr>{});
+        deserializerPool.get(), ROW({}), nullptr, 1, std::vector<VectorPtr>{});
   } else {
     inputVector = std::dynamic_pointer_cast<RowVector>(
-        restoreVectorFromFile(inputPath.c_str(), pool.get()));
+        restoreVectorFromFile(inputPath.c_str(), deserializerPool.get()));
     VELOX_CHECK_NOT_NULL(
         inputVector,
         "Input vector is not a RowVector: {}",
@@ -192,7 +198,7 @@ void ExpressionRunner::run(
           std::move(resultVector),
           true,
           columnsToWrapInLazy);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       if (findMinimalSubExpression) {
         VectorFuzzer::Options options;
         VectorFuzzer fuzzer(options, pool.get());
diff --git a/velox/expression/tests/ExpressionRunner.h b/velox/expression/tests/ExpressionRunner.h
index 1db985044093a..9bcddc15d6d3b 100644
--- a/velox/expression/tests/ExpressionRunner.h
+++ b/velox/expression/tests/ExpressionRunner.h
@@ -49,6 +49,15 @@ class ExpressionRunner {
   /// @param lazyColumnListPath The path to on-disk vector of column indices
   /// that specify which columns of the input row vector should be wrapped in
   /// lazy.
+  /// @param findMinimalSubExpression Whether to find minimum failing
+  ///        subexpression on result mismatch.
+  /// @param useSeperatePoolForInput Whether to use separate memory pools for
+  ///        input vector and expression evaluation. This helps trigger
+  ///        code-paths that can depend on vectors having different pools. For
+  ///        eg, when copying a flat string vector copies of the strings stored
+  ///        in the string buffers need to be created. If however, the pools
+  ///        were the same between the vectors then the buffers can simply be
+  ///        shared between them instead.
   ///
   /// User can refer to 'VectorSaver' class to see how to serialize/preserve
   /// vectors to disk.
@@ -61,7 +70,8 @@ class ExpressionRunner {
       vector_size_t numRows,
       const std::string& storeResultPath,
       const std::string& lazyColumnListPath,
-      bool findMinimalSubExpression = false);
+      bool findMinimalSubExpression = false,
+      bool useSeperatePoolForInput = true);
 
   /// Parse comma-separated SQL expressions. This should be treated as private
   /// except for tests.
diff --git a/velox/expression/tests/ExpressionRunnerTest.cpp b/velox/expression/tests/ExpressionRunnerTest.cpp
index 12c6771a08bc6..eadfe52dd315c 100644
--- a/velox/expression/tests/ExpressionRunnerTest.cpp
+++ b/velox/expression/tests/ExpressionRunnerTest.cpp
@@ -22,6 +22,7 @@
 #include "velox/expression/tests/ExpressionVerifier.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/sparksql/Register.h"
 #include "velox/vector/VectorSaver.h"
 
 using namespace facebook::velox;
@@ -52,6 +53,12 @@ DEFINE_string(
     "flag are mutually exclusive. If both are specified, --sql is used and "
     "--sql_path is ignored.");
 
+DEFINE_string(
+    registry,
+    "presto",
+    "Funciton registry to use for expression evaluation. Currently supported values are "
+    "presto and spark. Default is presto.");
+
 DEFINE_string(
     result_path,
     "",
@@ -79,12 +86,22 @@ DEFINE_string(
     "indices that specify which columns of the input row vector should "
     "be wrapped in lazy.");
 
+DEFINE_bool(
+    use_seperate_memory_pool_for_input_vector,
+    true,
+    "If true, expression evaluator and input vectors use different memory pools."
+    " This helps trigger code-paths that can depend on vectors having different"
+    " pools. For eg, when copying a flat string vector copies of the strings"
+    " stored in the string buffers need to be created. If however, the pools"
+    " were the same between the vectors then the buffers can simply be shared"
+    " between them instead.");
+
 static bool validateMode(const char* flagName, const std::string& value) {
   static const std::unordered_set<std::string> kModes = {
       "common", "simplified", "verify", "query"};
   if (kModes.count(value) != 1) {
-    std::cout << "Invalid value for --" << flagName << ": " << value << ". ";
-    std::cout << "Valid values are: " << folly::join(", ", kModes) << "."
+    std::cerr << "Invalid value for --" << flagName << ": " << value << ". ";
+    std::cerr << "Valid values are: " << folly::join(", ", kModes) << "."
               << std::endl;
     return false;
   }
@@ -92,7 +109,26 @@ static bool validateMode(const char* flagName, const std::string& value) {
   return true;
 }
 
+static bool validateRegistry(const char* flagName, const std::string& value) {
+  static const std::unordered_set<std::string> kRegistries = {
+      "presto", "spark"};
+  if (kRegistries.count(value) != 1) {
+    std::cerr << "Invalid value for --" << flagName << ": " << value << ". ";
+    std::cerr << "Valid values are: " << folly::join(", ", kRegistries) << "."
+              << std::endl;
+    return false;
+  }
+  if (value == "spark") {
+    functions::sparksql::registerFunctions("");
+  } else if (value == "presto") {
+    functions::prestosql::registerAllScalarFunctions();
+  }
+
+  return true;
+}
+
 DEFINE_validator(mode, &validateMode);
+DEFINE_validator(registry, &validateRegistry);
 
 DEFINE_int32(
     num_rows,
@@ -165,14 +201,14 @@ int main(int argc, char** argv) {
   // Calls common init functions in the necessary order, initializing
   // singletons, installing proper signal handlers for better debugging
   // experience, and initialize glog and gflags.
-  folly::init(&argc, &argv);
+  folly::Init init(&argc, &argv);
 
   if (!FLAGS_fuzzer_repro_path.empty()) {
     checkDirForExpectedFiles();
   }
 
   if (FLAGS_sql.empty() && FLAGS_sql_path.empty()) {
-    std::cout << "One of --sql or --sql_path flags must be set." << std::endl;
+    std::cerr << "One of --sql or --sql_path flags must be set." << std::endl;
     exit(1);
   }
 
@@ -181,9 +217,7 @@ int main(int argc, char** argv) {
     sql = restoreStringFromFile(FLAGS_sql_path.c_str());
     VELOX_CHECK(!sql.empty());
   }
-
-  functions::prestosql::registerAllScalarFunctions();
-  aggregate::prestosql::registerAllAggregateFunctions();
+  memory::initializeMemoryManager({});
   test::ExpressionRunner::run(
       FLAGS_input_path,
       sql,
@@ -193,5 +227,6 @@ int main(int argc, char** argv) {
       FLAGS_num_rows,
       FLAGS_store_result_path,
       FLAGS_lazy_column_list_path,
-      FLAGS_find_minimal_subexpression);
+      FLAGS_find_minimal_subexpression,
+      FLAGS_use_seperate_memory_pool_for_input_vector);
 }
diff --git a/velox/expression/tests/ExpressionRunnerUnitTest.cpp b/velox/expression/tests/ExpressionRunnerUnitTest.cpp
index 80d2a5eca5939..f128cf2129902 100644
--- a/velox/expression/tests/ExpressionRunnerUnitTest.cpp
+++ b/velox/expression/tests/ExpressionRunnerUnitTest.cpp
@@ -15,12 +15,12 @@
  */
 
 #include <gtest/gtest.h>
-#include "FuzzerRunner.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/tests/utils/TempFilePath.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/SignatureBinder.h"
-#include "velox/expression/tests/ExpressionFuzzer.h"
+#include "velox/expression/fuzzer/ExpressionFuzzer.h"
+#include "velox/expression/fuzzer/FuzzerRunner.h"
 #include "velox/expression/tests/ExpressionRunner.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/vector/VectorSaver.h"
@@ -35,17 +35,24 @@ class ExpressionRunnerUnitTest : public testing::Test, public VectorTestBase {
   }
 
  protected:
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  core::QueryCtx queryCtx_{};
-  core::ExecCtx execCtx_{pool_.get(), &queryCtx_};
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
+  core::ExecCtx execCtx_{pool_.get(), queryCtx_.get()};
 };
 
 TEST_F(ExpressionRunnerUnitTest, run) {
   auto inputFile = exec::test::TempFilePath::create();
   auto sqlFile = exec::test::TempFilePath::create();
   auto resultFile = exec::test::TempFilePath::create();
-  const char* inputPath = inputFile->path.data();
-  const char* resultPath = resultFile->path.data();
+  const auto inputPathStr = inputFile->getPath();
+  const char* inputPath = inputPathStr.data();
+  const auto resultPathStr = resultFile->getPath();
+  const char* resultPath = resultPathStr.data();
   const int vectorSize = 100;
 
   VectorMaker vectorMaker(pool_.get());
@@ -58,8 +65,20 @@ TEST_F(ExpressionRunnerUnitTest, run) {
   saveVectorToFile(inputVector.get(), inputPath);
   saveVectorToFile(resultVector.get(), resultPath);
 
-  EXPECT_NO_THROW(ExpressionRunner::run(
-      inputPath, "length(c0)", "", resultPath, "verify", 0, "", ""));
+  for (bool useSeperatePoolForInput : {true, false}) {
+    LOG(INFO) << "Using useSeperatePoolForInput: " << useSeperatePoolForInput;
+    EXPECT_NO_THROW(ExpressionRunner::run(
+        inputPath,
+        "length(c0)",
+        "",
+        resultPath,
+        "verify",
+        0,
+        "",
+        "",
+        false,
+        useSeperatePoolForInput));
+  }
 }
 
 TEST_F(ExpressionRunnerUnitTest, persistAndReproComplexSql) {
@@ -91,8 +110,10 @@ TEST_F(ExpressionRunnerUnitTest, persistAndReproComplexSql) {
   // Emulate a reproduce from complex constant SQL
   auto sqlFile = exec::test::TempFilePath::create();
   auto complexConstantsFile = exec::test::TempFilePath::create();
-  auto sqlPath = sqlFile->path.c_str();
-  auto complexConstantsPath = complexConstantsFile->path.c_str();
+  const auto complexConstantsFilePathStr = complexConstantsFile->getPath();
+  auto sqlPathStr = sqlFile->getPath();
+  auto sqlPath = sqlPathStr.c_str();
+  auto complexConstantsPath = complexConstantsFilePathStr.c_str();
 
   // Write to file..
   saveStringToFile(complexConstantsSql, sqlPath);
@@ -112,8 +133,8 @@ TEST_F(ExpressionRunnerUnitTest, persistAndReproComplexSql) {
 }
 
 TEST_F(ExpressionRunnerUnitTest, primitiveConstantsInexpressibleInSql) {
-  auto varbinaryData = vectorMaker_.flatVector<StringView>(
-      {"12"_sv}, CppToType<Varbinary>::create());
+  auto varbinaryData =
+      vectorMaker_.flatVector<StringView>({"12"_sv}, VARBINARY());
   auto constantExpr = std::make_shared<const core::ConstantTypedExpr>(
       BaseVector::wrapInConstant(1, 0, varbinaryData));
 
diff --git a/velox/expression/tests/ExpressionVerifier.cpp b/velox/expression/tests/ExpressionVerifier.cpp
index 1de32f79e00bc..d22ec7cbde9b1 100644
--- a/velox/expression/tests/ExpressionVerifier.cpp
+++ b/velox/expression/tests/ExpressionVerifier.cpp
@@ -39,44 +39,9 @@ void logRowVector(const RowVectorPtr& rowVector) {
     VLOG(1) << "\tAt " << i << ": " << rowVector->toString(i);
   }
 }
-namespace {
-auto createCopy(const VectorPtr& input) {
-  VectorPtr result;
-  SelectivityVector rows(input->size());
-  BaseVector::ensureWritable(rows, input->type(), input->pool(), result);
-  result->copy(input.get(), rows, nullptr);
-  return result;
-}
 } // namespace
 
-void compareVectors(
-    const VectorPtr& left,
-    const VectorPtr& right,
-    const SelectivityVector& rows) {
-  // Print vector contents if in verbose mode.
-  size_t vectorSize = left->size();
-  VLOG(1) << "== Result contents (common vs. simple): ";
-  rows.applyToSelected([&](vector_size_t row) {
-    VLOG(1) << fmt::format(
-        "At {} [ {} vs {} ]", row, left->toString(row), right->toString(row));
-  });
-  VLOG(1) << "===================";
-
-  rows.applyToSelected([&](vector_size_t row) {
-    VELOX_CHECK(
-        left->equalValueAt(right.get(), row, row),
-        "Different results at idx '{}': '{}' vs. '{}'",
-        row,
-        left->toString(row),
-        right->toString(row));
-  });
-
-  LOG(INFO) << "All results match.";
-}
-
-} // namespace
-
-ResultOrError ExpressionVerifier::verify(
+fuzzer::ResultOrError ExpressionVerifier::verify(
     const std::vector<core::TypedExprPtr>& plans,
     const RowVectorPtr& rowVector,
     VectorPtr&& resultVector,
@@ -142,6 +107,7 @@ ResultOrError ExpressionVerifier::verify(
 
   // Execute with common expression eval path. Some columns of the input row
   // vector will be wrapped in lazy as specified in 'columnsToWrapInLazy'.
+  bool unsupportedInputUncatchableError = false;
   try {
     exec::ExprSet exprSetCommon(
         plans, execCtx_, !options_.disableConstantFolding);
@@ -154,19 +120,31 @@ ResultOrError ExpressionVerifier::verify(
       logRowVector(inputRowVector);
     } else {
       // Copy loads lazy vectors so only do this when there are no lazy inputs.
-      copiedInput = createCopy(inputRowVector);
+      copiedInput = BaseVector::copy(*inputRowVector);
     }
 
     exec::EvalCtx evalCtxCommon(execCtx_, &exprSetCommon, inputRowVector.get());
     exprSetCommon.eval(rows, evalCtxCommon, commonEvalResult);
+
     if (copiedInput) {
-      SelectivityVector rows(copiedInput->size());
-      compareVectors(copiedInput, inputRowVector, rows);
+      // Flatten the input vector as an optimization if its very deeply nested.
+      fuzzer::compareVectors(
+          copiedInput,
+          BaseVector::copy(*inputRowVector),
+          "Copy of original input",
+          "Input after common");
     }
-  } catch (const VeloxUserError&) {
-    if (!canThrow) {
-      LOG(ERROR)
-          << "Common eval wasn't supposed to throw, but it did. Aborting.";
+  } catch (const VeloxException& e) {
+    if (e.errorCode() == error_code::kUnsupportedInputUncatchable) {
+      unsupportedInputUncatchableError = true;
+    } else if (!(canThrow && e.isUserError())) {
+      if (!canThrow) {
+        LOG(ERROR)
+            << "Common eval wasn't supposed to throw, but it did. Aborting.";
+      } else if (!e.isUserError()) {
+        LOG(ERROR)
+            << "Common eval: VeloxRuntimeErrors other than UNSUPPORTED_INPUT_UNCATCHABLE error are not allowed.";
+      }
       persistReproInfoIfNeeded(
           rowVector, columnsToWrapInLazy, copiedResult, sql, complexConstants);
       throw;
@@ -174,7 +152,7 @@ ResultOrError ExpressionVerifier::verify(
     exceptionCommonPtr = std::current_exception();
   } catch (...) {
     LOG(ERROR)
-        << "Common eval: Exceptions other than VeloxUserError are not allowed.";
+        << "Common eval: Exceptions other than VeloxUserError or VeloxRuntimeError of UNSUPPORTED_INPUT_UNCATCHABLE are not allowed.";
     persistReproInfoIfNeeded(
         rowVector, columnsToWrapInLazy, copiedResult, sql, complexConstants);
     throw;
@@ -188,18 +166,29 @@ ResultOrError ExpressionVerifier::verify(
     exec::EvalCtx evalCtxSimplified(
         execCtx_, &exprSetSimplified, rowVector.get());
 
-    auto copy = createCopy(rowVector);
+    auto copy = BaseVector::copy(*rowVector);
     exprSetSimplified.eval(rows, evalCtxSimplified, simplifiedEvalResult);
-    {
-      SelectivityVector rows(copy->size());
-      compareVectors(copy, rowVector, rows);
-    }
 
-  } catch (const VeloxUserError&) {
+    // Flatten the input vector as an optimization if its very deeply nested.
+    fuzzer::compareVectors(
+        copy,
+        BaseVector::copy(*rowVector),
+        "Copy of original input",
+        "Input after simplified");
+
+  } catch (const VeloxException& e) {
+    if (!e.isUserError() &&
+        e.errorCode() != error_code::kUnsupportedInputUncatchable) {
+      LOG(ERROR)
+          << "Simplified eval: VeloxRuntimeErrors other than UNSUPPORTED_INPUT_UNCATCHABLE error are not allowed.";
+      persistReproInfoIfNeeded(
+          rowVector, columnsToWrapInLazy, copiedResult, sql, complexConstants);
+      throw;
+    }
     exceptionSimplifiedPtr = std::current_exception();
   } catch (...) {
     LOG(ERROR)
-        << "Simplified eval: Exceptions other than VeloxUserError are not allowed.";
+        << "Simplified eval: Exceptions other than VeloxUserError or VeloxRuntimeError with UNSUPPORTED_INPUT are not allowed.";
     persistReproInfoIfNeeded(
         rowVector, columnsToWrapInLazy, copiedResult, sql, complexConstants);
     throw;
@@ -210,14 +199,19 @@ ResultOrError ExpressionVerifier::verify(
     if (exceptionCommonPtr || exceptionSimplifiedPtr) {
       // Throws in case exceptions are not compatible. If they are compatible,
       // return false to signal that the expression failed.
-      compareExceptions(exceptionCommonPtr, exceptionSimplifiedPtr);
-      return {nullptr, exceptionCommonPtr};
+      fuzzer::compareExceptions(exceptionCommonPtr, exceptionSimplifiedPtr);
+      return {nullptr, exceptionCommonPtr, unsupportedInputUncatchableError};
     } else {
       // Throws in case output is different.
       VELOX_CHECK_EQ(commonEvalResult.size(), plans.size());
       VELOX_CHECK_EQ(simplifiedEvalResult.size(), plans.size());
       for (int i = 0; i < plans.size(); ++i) {
-        compareVectors(commonEvalResult[i], simplifiedEvalResult[i], rows);
+        fuzzer::compareVectors(
+            commonEvalResult[i],
+            simplifiedEvalResult[i],
+            "common path results ",
+            "simplified path results",
+            rows);
       }
     }
   } catch (...) {
@@ -239,7 +233,8 @@ ResultOrError ExpressionVerifier::verify(
 
   return {
       VectorMaker(commonEvalResult[0]->pool()).rowVector(commonEvalResult),
-      nullptr};
+      nullptr,
+      unsupportedInputUncatchableError};
 }
 
 void ExpressionVerifier::persistReproInfoIfNeeded(
@@ -453,7 +448,7 @@ class MinimalSubExpressionFinder {
           results ? BaseVector::copy(*results) : nullptr,
           true, // canThrow
           columnsToWrapInLazy);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       success = false;
     }
     FLAGS_minloglevel = 0;
diff --git a/velox/expression/tests/ExpressionVerifier.h b/velox/expression/tests/ExpressionVerifier.h
index 796cb01eff92e..240768b2aa68f 100644
--- a/velox/expression/tests/ExpressionVerifier.h
+++ b/velox/expression/tests/ExpressionVerifier.h
@@ -18,7 +18,7 @@
 
 #include "velox/core/ITypedExpr.h"
 #include "velox/core/QueryCtx.h"
-#include "velox/expression/tests/FuzzerToolkit.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
 #include "velox/functions/FunctionRegistry.h"
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
@@ -46,9 +46,7 @@ class ExpressionVerifier {
   static constexpr const std::string_view kComplexConstantsFileName =
       "complex_constants";
 
-  ExpressionVerifier(
-      core::ExecCtx* FOLLY_NONNULL execCtx,
-      ExpressionVerifierOptions options)
+  ExpressionVerifier(core::ExecCtx* execCtx, ExpressionVerifierOptions options)
       : execCtx_(execCtx), options_(options) {}
 
   // Executes expressions both using common path (all evaluation
@@ -65,7 +63,7 @@ class ExpressionVerifier {
   //  - exception thrown by the common path if both paths failed with compatible
   //  exceptions.
   //  - throws otherwise (incompatible exceptions or different results).
-  ResultOrError verify(
+  fuzzer::ResultOrError verify(
       const std::vector<core::TypedExprPtr>& plans,
       const RowVectorPtr& rowVector,
       VectorPtr&& resultVector,
@@ -93,7 +91,7 @@ class ExpressionVerifier {
       const std::vector<VectorPtr>& complexConstants);
 
  private:
-  core::ExecCtx* FOLLY_NONNULL execCtx_;
+  core::ExecCtx* execCtx_;
   const ExpressionVerifierOptions options_;
 };
 
diff --git a/velox/expression/tests/ExpressionVerifierUnitTest.cpp b/velox/expression/tests/ExpressionVerifierUnitTest.cpp
index 39267649c9678..21593ce75fd9b 100644
--- a/velox/expression/tests/ExpressionVerifierUnitTest.cpp
+++ b/velox/expression/tests/ExpressionVerifierUnitTest.cpp
@@ -67,6 +67,10 @@ class ExpressionVerifierUnitTest : public testing::Test, public VectorTestBase {
   }
 
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   core::TypedExprPtr parseExpression(
       const std::string& text,
       const RowTypePtr& rowType) {
@@ -75,15 +79,16 @@ class ExpressionVerifierUnitTest : public testing::Test, public VectorTestBase {
     return core::Expressions::inferTypes(untyped, rowType, pool_.get());
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
-  core::QueryCtx queryCtx_{};
-  core::ExecCtx execCtx_{pool_.get(), &queryCtx_};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
+  core::ExecCtx execCtx_{pool_.get(), queryCtx_.get()};
 };
 
 TEST_F(ExpressionVerifierUnitTest, persistReproInfo) {
   filesystems::registerLocalFileSystem();
   auto reproFolder = exec::test::TempDirectoryPath::create();
-  const auto reproPath = reproFolder->path;
+  const auto reproPath = reproFolder->getPath();
   auto localFs = filesystems::getFileSystem(reproPath, nullptr);
 
   ExpressionVerifierOptions options{false, reproPath.c_str(), false};
diff --git a/velox/expression/tests/FunctionCallToSpecialFormTest.cpp b/velox/expression/tests/FunctionCallToSpecialFormTest.cpp
index 0111e46228252..7c9bd3a590222 100644
--- a/velox/expression/tests/FunctionCallToSpecialFormTest.cpp
+++ b/velox/expression/tests/FunctionCallToSpecialFormTest.cpp
@@ -36,6 +36,7 @@ class FunctionCallToSpecialFormTest : public testing::Test,
  protected:
   static void SetUpTestCase() {
     registerFunctionCallToSpecialForms();
+    memory::MemoryManager::testingSetInstance({});
   }
   const core::QueryConfig config_{{}};
 };
@@ -184,3 +185,48 @@ TEST_F(FunctionCallToSpecialFormTest, notASpecialForm) {
       config_);
   ASSERT_EQ(specialForm, nullptr);
 }
+
+class FunctionCallToSpecialFormSanitizeNameTest : public testing::Test,
+                                                  public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    // This class does not pre-register the special forms.
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(FunctionCallToSpecialFormSanitizeNameTest, sanitizeName) {
+  // Make sure no special forms are registered.
+  unregisterAllFunctionCallToSpecialForm();
+
+  ASSERT_FALSE(isFunctionCallToSpecialFormRegistered("and"));
+  ASSERT_FALSE(isFunctionCallToSpecialFormRegistered("AND"));
+  ASSERT_FALSE(isFunctionCallToSpecialFormRegistered("or"));
+  ASSERT_FALSE(isFunctionCallToSpecialFormRegistered("OR"));
+
+  registerFunctionCallToSpecialForm(
+      "and", std::make_unique<ConjunctCallToSpecialForm>(true /* isAnd */));
+  registerFunctionCallToSpecialForm(
+      "OR", std::make_unique<ConjunctCallToSpecialForm>(false /* isAnd */));
+
+  auto testLookup = [this](const std::string& name) {
+    auto type = resolveTypeForSpecialForm(name, {BOOLEAN(), BOOLEAN()});
+    ASSERT_EQ(type, BOOLEAN());
+
+    auto specialForm = constructSpecialForm(
+        name,
+        BOOLEAN(),
+        {std::make_shared<ConstantExpr>(
+             vectorMaker_.constantVector<bool>({true})),
+         std::make_shared<ConstantExpr>(
+             vectorMaker_.constantVector<bool>({false}))},
+        false,
+        core::QueryConfig{{}});
+    ASSERT_EQ(typeid(*specialForm), typeid(const ConjunctExpr&));
+  };
+
+  testLookup("and");
+  testLookup("AND");
+  testLookup("or");
+  testLookup("OR");
+}
diff --git a/velox/expression/tests/FuzzerRunner.cpp b/velox/expression/tests/FuzzerRunner.cpp
deleted file mode 100644
index ade9c3caf893d..0000000000000
--- a/velox/expression/tests/FuzzerRunner.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/expression/tests/FuzzerRunner.h"
-
-namespace {
-
-static const std::vector<std::string> kIntegralTypes{
-    "tinyint",
-    "smallint",
-    "integer",
-    "bigint",
-    "boolean"};
-static const std::vector<std::string> kFloatingPointTypes{"real", "double"};
-
-facebook::velox::exec::FunctionSignaturePtr makeCastSignature(
-    const std::string& fromType,
-    const std::string& toType) {
-  return facebook::velox::exec::FunctionSignatureBuilder()
-      .argumentType(fromType)
-      .returnType(toType)
-      .build();
-}
-
-void addCastFromIntegralSignatures(
-    const std::string& toType,
-    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
-  for (const auto& fromType : kIntegralTypes) {
-    signatures.push_back(makeCastSignature(fromType, toType));
-  }
-}
-
-void addCastFromFloatingPointSignatures(
-    const std::string& toType,
-    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
-  for (const auto& fromType : kFloatingPointTypes) {
-    signatures.push_back(makeCastSignature(fromType, toType));
-  }
-}
-
-void addCastFromVarcharSignature(
-    const std::string& toType,
-    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
-  signatures.push_back(makeCastSignature("varchar", toType));
-}
-
-void addCastFromTimestampSignature(
-    const std::string& toType,
-    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
-  signatures.push_back(makeCastSignature("timestamp", toType));
-}
-
-void addCastFromDateSignature(
-    const std::string& toType,
-    std::vector<facebook::velox::exec::FunctionSignaturePtr>& signatures) {
-  signatures.push_back(makeCastSignature("date", toType));
-}
-
-std::vector<facebook::velox::exec::FunctionSignaturePtr>
-getSignaturesForCast() {
-  std::vector<facebook::velox::exec::FunctionSignaturePtr> signatures;
-
-  // To integral types.
-  for (const auto& toType : kIntegralTypes) {
-    addCastFromIntegralSignatures(toType, signatures);
-    addCastFromFloatingPointSignatures(toType, signatures);
-    addCastFromVarcharSignature(toType, signatures);
-  }
-
-  // To floating-point types.
-  for (const auto& toType : kFloatingPointTypes) {
-    addCastFromIntegralSignatures(toType, signatures);
-    addCastFromFloatingPointSignatures(toType, signatures);
-    addCastFromVarcharSignature(toType, signatures);
-  }
-
-  // To varchar type.
-  addCastFromIntegralSignatures("varchar", signatures);
-  addCastFromFloatingPointSignatures("varchar", signatures);
-  addCastFromVarcharSignature("varchar", signatures);
-  addCastFromDateSignature("varchar", signatures);
-  addCastFromTimestampSignature("varchar", signatures);
-
-  // To timestamp type.
-  addCastFromVarcharSignature("timestamp", signatures);
-  addCastFromDateSignature("timestamp", signatures);
-
-  // To date type.
-  addCastFromVarcharSignature("date", signatures);
-  addCastFromTimestampSignature("date", signatures);
-
-  // For each supported translation pair T --> U, add signatures of array(T) -->
-  // array(U), map(varchar, T) --> map(varchar, U), row(T) --> row(U).
-  auto size = signatures.size();
-  for (auto i = 0; i < size; ++i) {
-    auto from = signatures[i]->argumentTypes()[0].baseName();
-    auto to = signatures[i]->returnType().baseName();
-
-    signatures.push_back(makeCastSignature(
-        fmt::format("array({})", from), fmt::format("array({})", to)));
-
-    signatures.push_back(makeCastSignature(
-        fmt::format("map(varchar, {})", from),
-        fmt::format("map(varchar, {})", to)));
-
-    signatures.push_back(makeCastSignature(
-        fmt::format("row({})", from), fmt::format("row({})", to)));
-  }
-  return signatures;
-}
-
-} // namespace
-
-// static
-const std::unordered_map<
-    std::string,
-    std::vector<facebook::velox::exec::FunctionSignaturePtr>>
-    FuzzerRunner::kSpecialForms = {
-        {"and",
-         std::vector<facebook::velox::exec::FunctionSignaturePtr>{
-             // Signature: and (condition,...) -> output:
-             // boolean, boolean,.. -> boolean
-             facebook::velox::exec::FunctionSignatureBuilder()
-                 .argumentType("boolean")
-                 .argumentType("boolean")
-                 .variableArity()
-                 .returnType("boolean")
-                 .build()}},
-        {"or",
-         std::vector<facebook::velox::exec::FunctionSignaturePtr>{
-             // Signature: or (condition,...) -> output:
-             // boolean, boolean,.. -> boolean
-             facebook::velox::exec::FunctionSignatureBuilder()
-                 .argumentType("boolean")
-                 .argumentType("boolean")
-                 .variableArity()
-                 .returnType("boolean")
-                 .build()}},
-        {"coalesce",
-         std::vector<facebook::velox::exec::FunctionSignaturePtr>{
-             // Signature: coalesce (input,...) -> output:
-             // T, T,.. -> T
-             facebook::velox::exec::FunctionSignatureBuilder()
-                 .typeVariable("T")
-                 .argumentType("T")
-                 .argumentType("T")
-                 .variableArity()
-                 .returnType("T")
-                 .build()}},
-        {
-            "if",
-            std::vector<facebook::velox::exec::FunctionSignaturePtr>{
-                // Signature: if (condition, then) -> output:
-                // boolean, T -> T
-                facebook::velox::exec::FunctionSignatureBuilder()
-                    .typeVariable("T")
-                    .argumentType("boolean")
-                    .argumentType("T")
-                    .returnType("T")
-                    .build(),
-                // Signature: if (condition, then, else) -> output:
-                // boolean, T, T -> T
-                facebook::velox::exec::FunctionSignatureBuilder()
-                    .typeVariable("T")
-                    .argumentType("boolean")
-                    .argumentType("T")
-                    .argumentType("T")
-                    .returnType("T")
-                    .build()},
-        },
-        {
-            "switch",
-            std::vector<facebook::velox::exec::FunctionSignaturePtr>{
-                // Signature: Switch (condition, then) -> output:
-                // boolean, T -> T
-                // This is only used to bind to a randomly selected type for the
-                // output, then while generating arguments, an override is used
-                // to generate inputs that can create variation of multiple
-                // cases and may or may not include a final else clause.
-                facebook::velox::exec::FunctionSignatureBuilder()
-                    .typeVariable("T")
-                    .argumentType("boolean")
-                    .argumentType("T")
-                    .returnType("T")
-                    .build()},
-        },
-        {
-            "cast",
-            /// TODO: Add supported Cast signatures to CastTypedExpr and expose
-            /// them to fuzzer instead of hard-coding signatures here.
-            getSignaturesForCast(),
-        },
-};
diff --git a/velox/expression/tests/FuzzerRunner.h b/velox/expression/tests/FuzzerRunner.h
deleted file mode 100644
index 5d5e5bf65daa3..0000000000000
--- a/velox/expression/tests/FuzzerRunner.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/String.h>
-#include <folly/init/Init.h>
-#include <gtest/gtest.h>
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include "velox/expression/tests/ExpressionFuzzer.h"
-#include "velox/functions/FunctionRegistry.h"
-
-/// FuzzerRunner leverages ExpressionFuzzer and VectorFuzzer to automatically
-/// generate and execute expression tests. It works by:
-///
-///  1. Taking an initial set of available function signatures.
-///  2. Generating a random expression tree based on the available function
-///     signatures.
-///  3. Generating a random set of input data (vector), with a variety of
-///     encodings and data layouts.
-///  4. Executing the expression using the common and simplified eval paths, and
-///     asserting results are the exact same.
-///  5. Rinse and repeat.
-///
-/// The common usage pattern is as following:
-///
-///  $ ./velox_expression_fuzzer_test --steps 10000
-///
-/// The important flags that control Fuzzer's behavior are:
-///
-///  --steps: how many iterations to run.
-///  --duration_sec: alternatively, for how many seconds it should run (takes
-///          precedence over --steps).
-///  --seed: pass a deterministic seed to reproduce the behavior (each iteration
-///          will print a seed as part of the logs).
-///  --v=1: verbose logging; print a lot more details about the execution.
-///  --only: restrict the functions to fuzz.
-///  --batch_size: size of input vector batches generated.
-///
-/// e.g:
-///
-///  $ ./velox_expression_fuzzer_test \
-///         --steps 10000 \
-///         --seed 123 \
-///         --v=1 \
-///         --only "substr,trim"
-
-class FuzzerRunner {
-  static std::unordered_set<std::string> splitNames(const std::string& names) {
-    // Parse, lower case and trim it.
-    std::vector<folly::StringPiece> nameList;
-    folly::split(',', names, nameList);
-    std::unordered_set<std::string> nameSet;
-
-    for (const auto& it : nameList) {
-      auto str = folly::trimWhitespace(it).toString();
-      folly::toLowerAscii(str);
-      nameSet.insert(str);
-    }
-    return nameSet;
-  }
-
-  // Parse the comma separated list of function names, and use it to filter the
-  // input signatures.
-  static facebook::velox::FunctionSignatureMap filterSignatures(
-      const facebook::velox::FunctionSignatureMap& input,
-      const std::string& onlyFunctions,
-      const std::unordered_set<std::string>& skipFunctions) {
-    if (onlyFunctions.empty()) {
-      if (skipFunctions.empty()) {
-        return input;
-      }
-      facebook::velox::FunctionSignatureMap output(input);
-      for (auto s : skipFunctions) {
-        auto str = s;
-        folly::toLowerAscii(str);
-        output.erase(str);
-      }
-      return output;
-    }
-
-    // Parse, lower case and trim it.
-    auto nameSet = splitNames(onlyFunctions);
-
-    // Use the generated set to filter the input signatures.
-    facebook::velox::FunctionSignatureMap output;
-    for (const auto& it : input) {
-      if (nameSet.count(it.first) > 0) {
-        output.insert(it);
-      }
-    }
-    return output;
-  }
-
-  static const std::unordered_map<
-      std::string,
-      std::vector<facebook::velox::exec::FunctionSignaturePtr>>
-      kSpecialForms;
-
-  static void appendSpecialForms(
-      const std::string& specialForms,
-      facebook::velox::FunctionSignatureMap& signatureMap) {
-    auto specialFormNames = splitNames(specialForms);
-    for (const auto& [name, signatures] : kSpecialForms) {
-      if (specialFormNames.count(name) == 0) {
-        LOG(INFO) << "Skipping special form: " << name;
-        continue;
-      }
-      std::vector<const facebook::velox::exec::FunctionSignature*>
-          rawSignatures;
-      for (const auto& signature : signatures) {
-        rawSignatures.push_back(signature.get());
-      }
-      signatureMap.insert({name, std::move(rawSignatures)});
-    }
-  }
-
- public:
-  static int run(
-      const std::string& onlyFunctions,
-      size_t seed,
-      const std::unordered_set<std::string>& skipFunctions,
-      const std::string& specialForms) {
-    runFromGtest(onlyFunctions, seed, skipFunctions, specialForms);
-    return RUN_ALL_TESTS();
-  }
-
-  static void runFromGtest(
-      const std::string& onlyFunctions,
-      size_t seed,
-      const std::unordered_set<std::string>& skipFunctions,
-      const std::string& specialForms) {
-    auto signatures = facebook::velox::getFunctionSignatures();
-    appendSpecialForms(specialForms, signatures);
-    facebook::velox::test::expressionFuzzer(
-        filterSignatures(signatures, onlyFunctions, skipFunctions), seed);
-  }
-};
diff --git a/velox/expression/tests/FuzzerToolkit.h b/velox/expression/tests/FuzzerToolkit.h
deleted file mode 100644
index 2644cdb51688d..0000000000000
--- a/velox/expression/tests/FuzzerToolkit.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/expression/FunctionSignature.h"
-#include "velox/vector/ComplexVector.h"
-
-namespace facebook::velox::test {
-
-// Represents one available function signature.
-struct CallableSignature {
-  // Function name.
-  std::string name;
-
-  // Input arguments and return type.
-  std::vector<TypePtr> args;
-  bool variableArity{false};
-  TypePtr returnType;
-
-  // Boolean flags identifying constant arguments.
-  std::vector<bool> constantArgs;
-
-  // Convenience print function.
-  std::string toString() const;
-};
-
-struct SignatureTemplate {
-  std::string name;
-  const exec::FunctionSignature* signature;
-  std::unordered_set<std::string> typeVariables;
-};
-
-struct ResultOrError {
-  RowVectorPtr result;
-  std::exception_ptr exceptionPtr;
-};
-
-/// Sort callable function signatures.
-void sortCallableSignatures(std::vector<CallableSignature>& signatures);
-
-/// Sort function signature templates.
-void sortSignatureTemplates(std::vector<SignatureTemplate>& signatures);
-
-void compareExceptions(
-    std::exception_ptr exceptionPtr,
-    std::exception_ptr otherExceptionPr);
-} // namespace facebook::velox::test
diff --git a/velox/expression/tests/GenericViewTest.cpp b/velox/expression/tests/GenericViewTest.cpp
index 9565930551946..ffc5993b4b3f3 100644
--- a/velox/expression/tests/GenericViewTest.cpp
+++ b/velox/expression/tests/GenericViewTest.cpp
@@ -131,21 +131,37 @@ TEST_F(GenericViewTest, primitive) {
 }
 
 TEST_F(GenericViewTest, compare) {
-  std::vector<std::optional<int64_t>> data = {1, 2, std::nullopt, 1};
+  {
+    auto vector = makeNullableFlatVector<int64_t>({1, 2, std::nullopt, 1});
+    DecodedVector decoded;
+    exec::VectorReader<Any> reader(decode(decoded, *vector));
 
-  auto vector = vectorMaker_.flatVectorNullable<int64_t>(data);
-  DecodedVector decoded;
-  exec::VectorReader<Any> reader(decode(decoded, *vector));
-  CompareFlags flags;
-  ASSERT_EQ(reader[0].compare(reader[0], flags).value(), 0);
-  ASSERT_EQ(reader[0].compare(reader[3], flags).value(), 0);
+    CompareFlags flags;
+    ASSERT_EQ(reader[0].compare(reader[0], flags).value(), 0);
+    ASSERT_EQ(reader[0].compare(reader[3], flags).value(), 0);
+
+    ASSERT_NE(reader[0].compare(reader[1], flags).value(), 0);
+    ASSERT_NE(reader[0].compare(reader[2], flags).value(), 0);
 
-  ASSERT_NE(reader[0].compare(reader[1], flags).value(), 0);
-  ASSERT_NE(reader[0].compare(reader[2], flags).value(), 0);
+    flags.nullHandlingMode =
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate;
+    VELOX_ASSERT_THROW(
+        reader[0].compare(reader[2], flags), "Ordering nulls is not supported");
+    ASSERT_TRUE(reader[0].compare(reader[1], flags).has_value());
+  }
 
-  flags.nullHandlingMode = CompareFlags::NullHandlingMode::StopAtNull;
-  ASSERT_FALSE(reader[0].compare(reader[2], flags).has_value());
-  ASSERT_TRUE(reader[0].compare(reader[1], flags).has_value());
+  // Test that [null, 1] = [null, 2] is false, and that
+  // [null, 1] = [null, 1] is indeterminate.
+  {
+    CompareFlags flags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+    auto arrayVector =
+        makeArrayVectorFromJson<int64_t>({"[null, 1]", "[null, 2]"});
+    DecodedVector decoded;
+    exec::VectorReader<Any> reader(decode(decoded, *arrayVector));
+    ASSERT_EQ(reader[0].compare(reader[1], flags).value(), -1);
+    ASSERT_EQ(reader[0].compare(reader[0], flags), kIndeterminate);
+  }
 }
 
 // Test reader<Generic> where generic elements are arrays<ints>
@@ -186,6 +202,46 @@ TEST_F(GenericViewTest, arrayOfGeneric) {
   }
 }
 
+TEST_F(GenericViewTest, toString) {
+  {
+    auto data = makeArrayVectorFromJson<int32_t>({
+        "[1, 2, 3]",
+    });
+
+    DecodedVector decoded(*data);
+    exec::VectorReader<Array<Any>> reader(&decoded);
+
+    auto arrayView = reader[0];
+    EXPECT_EQ("1", arrayView[0].value().toString());
+    EXPECT_EQ("2", arrayView[1].value().toString());
+    EXPECT_EQ("3", arrayView[2].value().toString());
+  }
+
+  {
+    auto data = makeMapVectorFromJson<int32_t, int64_t>({
+        "{1: 10, 2: null, 3: 30}",
+    });
+
+    auto keys = data->mapKeys();
+    auto values = data->mapValues();
+
+    DecodedVector decoded(*data);
+    exec::VectorReader<Map<Any, Any>> reader(&decoded);
+
+    auto mapView = reader[0];
+    auto it = mapView.begin();
+    for (auto i = 0; i < 3; ++i) {
+      EXPECT_EQ(keys->toString(i), it->first.toString());
+      if (values->isNullAt(i)) {
+        EXPECT_FALSE(it->second.has_value());
+      } else {
+        EXPECT_EQ(values->toString(i), it->second->toString());
+      }
+      ++it;
+    }
+  }
+}
+
 template <typename T>
 struct CompareFunc {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -756,7 +812,7 @@ struct ArrayHasDuplicateFunc {
       }
 
       if (set.count(*item)) {
-        // Item already exisits.
+        // Item already exists.
         out = true;
         return true;
       }
diff --git a/velox/expression/tests/GenericWriterTest.cpp b/velox/expression/tests/GenericWriterTest.cpp
index 15954381405a0..9f016d0be875b 100644
--- a/velox/expression/tests/GenericWriterTest.cpp
+++ b/velox/expression/tests/GenericWriterTest.cpp
@@ -55,7 +55,6 @@ TEST_F(GenericWriterTest, boolean) {
 
   writer.setOffset(0);
   auto& current = writer.current();
-  ASSERT_THROW(current.castTo<int32_t>(), VeloxUserError);
 
   ASSERT_NO_THROW(current.tryCastTo<int32_t>());
   ASSERT_TRUE(current.tryCastTo<int32_t>() == nullptr);
@@ -117,12 +116,7 @@ struct ArrayTrimFunction {
       const int64_t& n) {
     int64_t end = inputArray.size() - n;
     for (int i = 0; i < end; ++i) {
-      if (inputArray[i].has_value()) {
-        auto& newItem = out.add_item();
-        newItem.copy_from(inputArray[i].value());
-      } else {
-        out.add_null();
-      }
+      out.push_back(inputArray[i]);
     }
   }
 };
@@ -205,7 +199,6 @@ TEST_F(GenericWriterTest, arrayAnyCast) {
 
   writer.setOffset(0);
   auto& current = writer.current();
-  ASSERT_THROW(current.castTo<double>(), VeloxUserError);
 
   ASSERT_NO_THROW(current.tryCastTo<double>());
   ASSERT_TRUE(current.tryCastTo<double>() == nullptr);
@@ -261,7 +254,6 @@ TEST_F(GenericWriterTest, arrayIntCast) {
 
   writer.setOffset(0);
   auto& current = writer.current();
-  ASSERT_THROW(current.castTo<double>(), VeloxUserError);
 
   ASSERT_NO_THROW(current.tryCastTo<double>());
   ASSERT_TRUE(current.tryCastTo<double>() == nullptr);
diff --git a/velox/expression/tests/Main.cpp b/velox/expression/tests/Main.cpp
new file mode 100644
index 0000000000000..3b55575663ed0
--- /dev/null
+++ b/velox/expression/tests/Main.cpp
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::Init init(&argc, &argv, false);
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/expression/tests/MapWriterTest.cpp b/velox/expression/tests/MapWriterTest.cpp
index cee1b59c933e5..0e543c2da41a6 100644
--- a/velox/expression/tests/MapWriterTest.cpp
+++ b/velox/expression/tests/MapWriterTest.cpp
@@ -645,6 +645,64 @@ TEST_F(MapWriterTest, appendToKeysAndValues) {
   ASSERT_EQ(values->asFlatVector<int64_t>()->valueAt(1), 20);
 }
 
+// Make sure MapWriter correctly handles 'result' MapVector, where keys and
+// values child vectors have different sizes.
+TEST_F(MapWriterTest, differentKeyValueSizes) {
+  using out_t = Map<int32_t, int32_t>;
+  auto mapType = CppToType<out_t>::create();
+
+  // Keys vector is shorter than values vector.
+  auto result = std::make_shared<MapVector>(
+      pool(),
+      mapType,
+      nullptr, // no nulls
+      3,
+      makeIndices({0, 2, 4}), // offsets
+      makeIndices({2, 2, 2}), // sizes
+      makeFlatVector<int32_t>({0, 1, 0, 1, 0, 1}), // keys
+      makeFlatVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) // values
+  );
+
+  EXPECT_EQ(6, result->mapKeys()->size());
+  EXPECT_EQ(10, result->mapValues()->size());
+
+  {
+    // Write map at offset 0.
+    exec::VectorWriter<out_t> vectorWriter;
+    vectorWriter.init(*result);
+    vectorWriter.setOffset(0);
+    auto& mapWriter = vectorWriter.current();
+    mapWriter.copy_from(folly::F14FastMap<int64_t, int64_t>{{1, 2}});
+
+    vectorWriter.commit();
+    vectorWriter.finish();
+  }
+
+  {
+    // Write map at offset 2.
+    exec::VectorWriter<out_t> vectorWriter;
+    vectorWriter.init(*result);
+    vectorWriter.setOffset(2);
+    auto& mapWriter = vectorWriter.current();
+    mapWriter.copy_from(folly::F14FastMap<int64_t, int64_t>{{3, 4}});
+
+    vectorWriter.commit();
+    vectorWriter.finish();
+  }
+
+  // Verify sizes of keys and values vectors.
+  EXPECT_EQ(8, result->mapKeys()->size());
+  EXPECT_EQ(8, result->mapValues()->size());
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 2}},
+      {{0, 2}, {1, 3}},
+      {{3, 4}},
+  });
+
+  assertEqualVectors(expected, result);
+}
+
 // Make sure copy from MapView correctly resizes children vectors.
 TEST_F(MapWriterTest, copyFromViewTypeResizedChildren) {
   using out_t = Map<int64_t, Map<int64_t, int64_t>>;
@@ -697,5 +755,53 @@ TEST_F(MapWriterTest, copyFromViewTypeResizedChildren) {
   ASSERT_EQ(outerValues->mapValues()->asFlatVector<int64_t>()->size(), 6);
 }
 
+// Throws an error if n is even, otherwise creates a map of maps.
+template <typename T>
+struct ThrowsErrorsFunc {
+  template <typename TOut>
+  void call(TOut& out, const int64_t& n) {
+    for (auto i = 0; i < 3; i++) {
+      auto [keyWriter, valueWriter] = out.add_item();
+      keyWriter = i + n * 3;
+      for (auto j = 0; j < 3; j++) {
+        // If commit isn't called as part of error handling, the first inner
+        // map in odd number rows will pick up the entries from the last
+        // inner map of the previous row.
+        auto [innerKeyWriter, innerValueWriter] = valueWriter.add_item();
+        innerKeyWriter.copy_from(std::string(1, 'a' + (i * 3 + j)));
+        innerValueWriter = n * 10 + i * 3 + j;
+      }
+    }
+
+    VELOX_USER_CHECK_EQ(n % 2, 1);
+  }
+};
+
+TEST_F(MapWriterTest, errorHandlingE2E) {
+  registerFunction<
+      ThrowsErrorsFunc,
+      Map<int64_t, Map<Varchar, float>>,
+      int64_t>({"throws_errors"});
+
+  auto result = evaluate(
+      "try(throws_errors(c0))",
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6})}));
+
+  auto innerKeys = makeFlatVector<StringView>(
+      {"a", "b", "c", "d", "e", "f", "g", "h", "i", "a", "b", "c", "d", "e",
+       "f", "g", "h", "i", "a", "b", "c", "d", "e", "f", "g", "h", "i"});
+  auto innerValues = makeFlatVector<float>(
+      {10, 11, 12, 13, 14, 15, 16, 17, 18, 30, 31, 32, 33, 34,
+       35, 36, 37, 38, 50, 51, 52, 53, 54, 55, 56, 57, 58});
+  std::vector<vector_size_t> innerOffsets{0, 3, 6, 9, 12, 15, 18, 21, 24};
+  auto innerMaps = makeMapVector(innerOffsets, innerKeys, innerValues);
+
+  auto outerKeys = makeFlatVector<int64_t>({3, 4, 5, 9, 10, 11, 15, 16, 17});
+  std::vector<vector_size_t> outerOffsets{0, 3, 3, 6, 6, 9};
+  auto expected = makeMapVector(outerOffsets, outerKeys, innerMaps, {1, 3, 5});
+
+  assertEqualVectors(result, expected);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/expression/tests/PeeledEncodingTest.cpp b/velox/expression/tests/PeeledEncodingTest.cpp
index 342f2f1146703..36d16bdcfa2cd 100644
--- a/velox/expression/tests/PeeledEncodingTest.cpp
+++ b/velox/expression/tests/PeeledEncodingTest.cpp
@@ -34,6 +34,10 @@ class PeeledEncodingTest : public testing::Test, public VectorTestBase {
   };
 
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   static DictionaryWrap generateDictionaryWrap(
       VectorFuzzer& fuzzer,
       vector_size_t size) {
diff --git a/velox/expression/tests/RowWriterTest.cpp b/velox/expression/tests/RowWriterTest.cpp
index 242851b52c2eb..71c11704b6d83 100644
--- a/velox/expression/tests/RowWriterTest.cpp
+++ b/velox/expression/tests/RowWriterTest.cpp
@@ -537,5 +537,55 @@ TEST_F(RowWriterTest, finishPostSize) {
       11);
 }
 
+// Throws an error if n is even, otherwise creates a row.
+template <typename T>
+struct ThrowsErrorsFunc {
+  template <typename TOut>
+  void call(TOut& out, const int64_t& n) {
+    out.template get_writer_at<0>() = n;
+    auto& stringWriter = out.template get_writer_at<1>();
+    auto& arrayWriter = out.template get_writer_at<2>();
+    auto& mapWriter = out.template get_writer_at<3>();
+
+    for (auto i = 0; i < 3; i++) {
+      stringWriter.append(std::string(1, 'a' + i + n * 3));
+      arrayWriter.add_item() = n + i;
+      auto [keyWriter, valueWriter] = mapWriter.add_item();
+      keyWriter = n * 10 + i;
+      valueWriter = n * 100 + i;
+    }
+
+    VELOX_USER_CHECK_EQ(n % 2, 1);
+  }
+};
+
+TEST_F(RowWriterTest, errorHandlingE2E) {
+  registerFunction<
+      ThrowsErrorsFunc,
+      Row<int64_t, Varchar, Array<float>, Map<int32_t, double>>,
+      int64_t>({"throws_errors"});
+
+  auto result = evaluate(
+      "try(throws_errors(c0))",
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6})}));
+
+  auto field1 = makeFlatVector<int64_t>({1, 0, 3, 0, 5, 0});
+  auto field2 = makeFlatVector<StringView>({"def", "", "jkl", "", "pqr", ""});
+  auto field3 =
+      makeArrayVector<float>({{1, 2, 3}, {}, {3, 4, 5}, {}, {5, 6, 7}, {}});
+  auto field4 = makeMapVector<int32_t, double>(
+      {{{10, 100}, {11, 101}, {12, 102}},
+       {},
+       {{30, 300}, {31, 301}, {32, 302}},
+       {},
+       {{50, 500}, {51, 501}, {52, 502}},
+       {}});
+
+  auto expected = makeRowVector(
+      {field1, field2, field3, field4}, [](auto row) { return row % 2 == 1; });
+
+  assertEqualVectors(result, expected);
+}
+
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/expression/tests/SignatureBinderTest.cpp b/velox/expression/tests/SignatureBinderTest.cpp
index dec64247ffaf9..4889dcb02d123 100644
--- a/velox/expression/tests/SignatureBinderTest.cpp
+++ b/velox/expression/tests/SignatureBinderTest.cpp
@@ -20,7 +20,8 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
-using namespace facebook::velox;
+namespace facebook::velox::exec::test {
+namespace {
 
 void testSignatureBinder(
     const std::shared_ptr<exec::FunctionSignature>& signature,
@@ -239,6 +240,31 @@ TEST(SignatureBinderTest, decimals) {
           "Type variables cannot have constraints");
     }
   }
+  // Scalar function signature with fixed scale.
+  {
+    {
+      auto signature = exec::FunctionSignatureBuilder()
+                           .integerVariable("precision")
+                           .returnType("boolean")
+                           .argumentType("DECIMAL(precision, 6)")
+                           .build();
+      testSignatureBinder(signature, {DECIMAL(11, 6)}, BOOLEAN());
+      assertCannotResolve(signature, {DECIMAL(11, 8)});
+    }
+    {
+      auto signature = exec::FunctionSignatureBuilder()
+                           .integerVariable("precision")
+                           .integerVariable("scale")
+                           .returnType("DECIMAL(precision, scale)")
+                           .argumentType("DECIMAL(precision, 6)")
+                           .argumentType("DECIMAL(18, scale)")
+                           .build();
+      testSignatureBinder(
+          signature, {DECIMAL(11, 6), DECIMAL(18, 4)}, DECIMAL(11, 4));
+      assertCannotResolve(signature, {DECIMAL(11, 6), DECIMAL(20, 4)});
+      assertCannotResolve(signature, {DECIMAL(11, 8), DECIMAL(18, 4)});
+    }
+  }
 }
 
 TEST(SignatureBinderTest, computation) {
@@ -560,8 +586,7 @@ TEST(SignatureBinderTest, variableArity) {
   {
     auto signature = exec::FunctionSignatureBuilder()
                          .returnType("varchar")
-                         .argumentType("varchar")
-                         .variableArity()
+                         .variableArity("varchar")
                          .build();
 
     testSignatureBinder(signature, {}, VARCHAR());
@@ -576,8 +601,7 @@ TEST(SignatureBinderTest, variableArity) {
     auto signature = exec::FunctionSignatureBuilder()
                          .returnType("varchar")
                          .argumentType("integer")
-                         .argumentType("double")
-                         .variableArity()
+                         .variableArity("double")
                          .build();
 
     testSignatureBinder(signature, {INTEGER()}, VARCHAR());
@@ -591,8 +615,7 @@ TEST(SignatureBinderTest, variableArity) {
   {
     auto signature = exec::FunctionSignatureBuilder()
                          .returnType("varchar")
-                         .argumentType("any")
-                         .variableArity()
+                         .variableArity("any")
                          .build();
 
     testSignatureBinder(signature, {}, VARCHAR());
@@ -607,8 +630,7 @@ TEST(SignatureBinderTest, variableArity) {
     auto signature = exec::FunctionSignatureBuilder()
                          .returnType("timestamp")
                          .argumentType("integer")
-                         .argumentType("any")
-                         .variableArity()
+                         .variableArity("any")
                          .build();
 
     testSignatureBinder(signature, {INTEGER()}, TIMESTAMP());
@@ -657,8 +679,7 @@ TEST(SignatureBinderTest, unresolvable) {
   {
     auto signature = exec::FunctionSignatureBuilder()
                          .returnType("varchar")
-                         .argumentType("integer")
-                         .variableArity()
+                         .variableArity("integer")
                          .build();
 
     // wrong type
@@ -754,7 +775,7 @@ TEST(SignatureBinderTest, logicalType) {
     testSignatureBinder(signature, {INTERVAL_DAY_TIME()}, BIGINT());
   }
 
-  // Logical type as an return type.
+  // Logical type as a return type.
   {
     auto signature = exec::FunctionSignatureBuilder()
                          .returnType("interval day to second")
@@ -810,7 +831,7 @@ TEST(SignatureBinderTest, customType) {
           .returnType("bigint")
           .argumentType("fancy_type")
           .build(),
-      "Type doesn't exist: FANCY_TYPE");
+      "Type doesn't exist: 'FANCY_TYPE'");
 }
 
 TEST(SignatureBinderTest, hugeIntType) {
@@ -823,3 +844,84 @@ TEST(SignatureBinderTest, hugeIntType) {
     testSignatureBinder(signature, {HUGEINT()}, HUGEINT());
   }
 }
+
+TEST(SignatureBinderTest, namedRows) {
+  registerCustomType(
+      "timestamp with time zone",
+      std::make_unique<const TimestampWithTimeZoneTypeFactories>());
+
+  // Simple named row field.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("varchar")
+                         .argumentType("row(bla varchar)")
+                         .build();
+    testSignatureBinder(signature, {ROW({{"bla", VARCHAR()}})}, VARCHAR());
+
+    // Cannot bind if field doesn't have the same name set.
+    assertCannotResolve(signature, {ROW({{VARCHAR()}})});
+  }
+
+  // Multiple named row field.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("varchar")
+                         .argumentType("row(foo varchar, bigint, bar double)")
+                         .build();
+    testSignatureBinder(
+        signature,
+        {ROW({{"foo", VARCHAR()}, {"", BIGINT()}, {"bar", DOUBLE()}})},
+        VARCHAR());
+
+    // Binds even if the middle (unnamed) field has a name.
+    testSignatureBinder(
+        signature,
+        {ROW({{"foo", VARCHAR()}, {"fighters", BIGINT()}, {"bar", DOUBLE()}})},
+        VARCHAR());
+
+    // But not if one of the named fields is not.
+    assertCannotResolve(
+        signature,
+        {ROW({{"foo", VARCHAR()}, {"fighters", BIGINT()}, {"bla", DOUBLE()}})});
+  }
+
+  // Type with a space in the name.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("varchar")
+                         .argumentType("row(timestamp with time zone)")
+                         .build();
+    testSignatureBinder(
+        signature, {ROW({TIMESTAMP_WITH_TIME_ZONE()})}, VARCHAR());
+
+    // Ok to bind if even if the type has a field name set.
+    testSignatureBinder(
+        signature, {ROW({{"name", TIMESTAMP_WITH_TIME_ZONE()}})}, VARCHAR());
+  }
+
+  // Named type with a space.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("varchar")
+                         .argumentType("row(named timestamp with time zone)")
+                         .build();
+    testSignatureBinder(
+        signature, {ROW({{"named", TIMESTAMP_WITH_TIME_ZONE()}})}, VARCHAR());
+  }
+
+  // Nested named.
+  {
+    auto signature =
+        exec::FunctionSignatureBuilder()
+            .returnType("varchar")
+            .argumentType("row(my_map map(bigint, row(bla varchar)))")
+            .build();
+    testSignatureBinder(
+        signature,
+        {ROW({{"my_map", MAP(BIGINT(), ROW({{"bla", VARCHAR()}}))}})},
+        VARCHAR());
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/expression/tests/SimpleFunctionInitTest.cpp b/velox/expression/tests/SimpleFunctionInitTest.cpp
index 3d1a60121dd27..b0ea89621343d 100644
--- a/velox/expression/tests/SimpleFunctionInitTest.cpp
+++ b/velox/expression/tests/SimpleFunctionInitTest.cpp
@@ -37,6 +37,7 @@ struct NonDefaultWithArrayInitFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<int32_t>* /*first*/,
       const arg_type<velox::Array<int32_t>>* second) {
@@ -131,6 +132,7 @@ struct NonDefaultWithMapInitFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<int32_t>* /*first*/,
       const arg_type<velox::Map<int32_t, int64_t>>* second) {
@@ -200,6 +202,7 @@ struct InitAlwaysThrowsFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<int32_t>* /*first*/) {
     VELOX_USER_FAIL("Unconditional throw!");
diff --git a/velox/expression/tests/SimpleFunctionTest.cpp b/velox/expression/tests/SimpleFunctionTest.cpp
index be22ec0fceaf8..ae5d1b75a7454 100644
--- a/velox/expression/tests/SimpleFunctionTest.cpp
+++ b/velox/expression/tests/SimpleFunctionTest.cpp
@@ -19,9 +19,12 @@
 #include <string>
 
 #include <glog/logging.h>
+#include <gtest/gtest.h>
 #include "folly/lang/Hint.h"
-#include "gtest/gtest.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/Expr.h"
+#include "velox/expression/SimpleFunctionAdapter.h"
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
@@ -34,6 +37,7 @@
 using namespace facebook::velox;
 using namespace facebook::velox::test;
 namespace {
+
 class SimpleFunctionTest : public functions::test::FunctionBaseTest {
  protected:
   VectorPtr arraySum(const std::vector<std::vector<int64_t>>& data) {
@@ -41,6 +45,59 @@ class SimpleFunctionTest : public functions::test::FunctionBaseTest {
       return std::accumulate(data[row].begin(), data[row].end(), 0);
     });
   }
+
+  template <typename T>
+  struct CallNullFreeFuncVoidOut {
+    VELOX_DEFINE_FUNCTION_TYPES(T);
+
+    template <typename T1, typename T2>
+    void callNullFree(int32_t&, const T1&, const T2&) {}
+
+    template <typename T1>
+    void callNullFree(int32_t&, const T1&) {}
+  };
+
+  template <typename T>
+  struct CallNullFreeFuncBoolOut {
+    VELOX_DEFINE_FUNCTION_TYPES(T);
+
+    template <typename T1, typename T2>
+    bool callNullFree(int32_t&, const T1&, const T2&) {
+      return true;
+    }
+
+    template <typename T1>
+    bool callNullFree(int32_t&, const T1&) {
+      return true;
+    }
+  };
+
+  template <typename... TArgs>
+  void testCallNullFreeSupportFlatNotNulls(bool voidOutput, bool expected) {
+    using holderClassVoid = core::UDFHolder<
+        CallNullFreeFuncVoidOut<exec::VectorExec>,
+        exec::VectorExec,
+        int32_t,
+        ConstantChecker<TArgs...>,
+        typename UnwrapConstantType<TArgs>::type...>;
+    using holderClassBool = core::UDFHolder<
+        CallNullFreeFuncBoolOut<exec::VectorExec>,
+        exec::VectorExec,
+        int32_t,
+        ConstantChecker<TArgs...>,
+        typename UnwrapConstantType<TArgs>::type...>;
+    if (voidOutput) {
+      ASSERT_EQ(
+          expected,
+          exec::SimpleFunctionAdapter<holderClassVoid>()
+              .supportsFlatNoNullsFastPath());
+    } else {
+      ASSERT_EQ(
+          expected,
+          exec::SimpleFunctionAdapter<holderClassBool>()
+              .supportsFlatNoNullsFastPath());
+    }
+  }
 };
 
 template <typename T>
@@ -787,7 +844,7 @@ TEST_F(SimpleFunctionTest, stringReuseConstant) {
   // Test reusing the strings from an argument when that argument is in a
   // ConstantVector.  Note that the other 2 arguments are FlatVectors to
   // prevent constant peeling.
-  registerFunction<Substr, Varchar, Varchar, int32_t, int32_t>({"substr"});
+  registerFunction<Substr, Varchar, Varchar, int32_t, int32_t>({"test_substr"});
 
   auto constantVector = vectorMaker_.constantVector<StringView>(
       {"super happy fun string"_sv,
@@ -797,7 +854,8 @@ TEST_F(SimpleFunctionTest, stringReuseConstant) {
   auto lengths = vectorMaker_.flatVector({1, 2, 3});
 
   auto result = evaluate<FlatVector<StringView>>(
-      "substr(c0, c1, c2)", makeRowVector({constantVector, starts, lengths}));
+      "test_substr(c0, c1, c2)",
+      makeRowVector({constantVector, starts, lengths}));
 
   auto expected = vectorMaker_.flatVector({"s"_sv, "up"_sv, "per"_sv});
   assertEqualVectors(expected, result);
@@ -937,7 +995,7 @@ VectorPtr testVariadicArgReuse(
       exec::simpleFunctions()
           .resolveFunction(functionName, {})
           ->createFunction()
-          ->createVectorFunction({}, execCtx->queryCtx()->queryConfig());
+          ->createVectorFunction({}, {}, execCtx->queryCtx()->queryConfig());
 
   // Create a dummy EvalCtx.
   SelectivityVector rows(inputs[0]->size());
@@ -1051,6 +1109,7 @@ TEST_F(SimpleFunctionTest, isAsciiArgs) {
       StringInputFunction<exec::VectorExec>,
       exec::VectorExec,
       int32_t,
+      ConstantChecker<Varchar>,
       Varchar>;
   using function_t = exec::SimpleFunctionAdapter<holder_class_t>;
 
@@ -1078,7 +1137,7 @@ struct StringInputIntOutputFunction {
   }
 };
 
-TEST_F(SimpleFunctionTest, TestcallAscii) {
+TEST_F(SimpleFunctionTest, callAscii) {
   registerFunction<StringInputIntOutputFunction, int32_t, Varchar>(
       {"get_input_size"});
   auto asciiInput = makeFlatVector<std::string>({"abc123", "10% #\0"});
@@ -1156,4 +1215,398 @@ TEST_F(SimpleFunctionTest, simpleFunctionRegistryThreadSafe) {
     th.join();
   }
 }
+
+TEST_F(SimpleFunctionTest, flatNoNullsPathCallNullFree) {
+  // Void return type.
+  testCallNullFreeSupportFlatNotNulls<Map<int32_t, int32_t>>(true, false);
+  testCallNullFreeSupportFlatNotNulls<Array<int32_t>>(true, false);
+  testCallNullFreeSupportFlatNotNulls<Row<int32_t>>(true, false);
+  testCallNullFreeSupportFlatNotNulls<Any>(true, false);
+  testCallNullFreeSupportFlatNotNulls<Variadic<Any>>(true, false);
+  testCallNullFreeSupportFlatNotNulls<int32_t, Any>(true, false);
+  testCallNullFreeSupportFlatNotNulls<Any, int64_t>(true, false);
+
+  testCallNullFreeSupportFlatNotNulls<Variadic<int32_t>>(true, true);
+  testCallNullFreeSupportFlatNotNulls<int32_t>(true, true);
+  testCallNullFreeSupportFlatNotNulls<int64_t, int64_t>(true, true);
+  testCallNullFreeSupportFlatNotNulls<Varchar, Varchar>(true, true);
+
+  // Bool return type.
+  testCallNullFreeSupportFlatNotNulls<Map<int32_t, int32_t>>(false, false);
+  testCallNullFreeSupportFlatNotNulls<Array<int32_t>>(false, false);
+  testCallNullFreeSupportFlatNotNulls<Row<int32_t>>(false, false);
+  testCallNullFreeSupportFlatNotNulls<Any>(false, false);
+  testCallNullFreeSupportFlatNotNulls<Variadic<Any>>(false, false);
+  testCallNullFreeSupportFlatNotNulls<int32_t, Any>(false, false);
+  testCallNullFreeSupportFlatNotNulls<Any, int64_t>(false, false);
+
+  testCallNullFreeSupportFlatNotNulls<Variadic<int32_t>>(false, false);
+  testCallNullFreeSupportFlatNotNulls<int32_t>(false, false);
+  testCallNullFreeSupportFlatNotNulls<int64_t, int64_t>(false, false);
+  testCallNullFreeSupportFlatNotNulls<Varchar, Varchar>(false, false);
+}
+
+template <typename T>
+struct ConstantArgumentFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<int32_t>* /*first*/,
+      const arg_type<int32_t>* /*second*/,
+      const arg_type<Varchar>* /*third*/,
+      const arg_type<Generic<T1>>* /*fourth*/,
+      const arg_type<Array<int32_t>>* /*fifth*/,
+      const arg_type<Map<int32_t, int32_t>>* /*sixth*/) {}
+
+  bool callNullable(
+      out_type<int64_t>& out,
+      const arg_type<int32_t>* /*first*/,
+      const arg_type<int32_t>* /*second*/,
+      const arg_type<Varchar>* /*third*/,
+      const arg_type<Generic<T1>>* /*fourth*/,
+      const arg_type<Array<int32_t>>* /*fifth*/,
+      const arg_type<Map<int32_t, int32_t>>* /*sixth*/) {
+    out = 1;
+    return true;
+  }
+};
+
+TEST_F(SimpleFunctionTest, constantArgument) {
+  registerFunction<
+      ConstantArgumentFunction,
+      int64_t,
+      int32_t,
+      Constant<int32_t>,
+      Constant<Varchar>,
+      Constant<Generic<T1>>,
+      Constant<Array<int32_t>>,
+      Constant<Map<int32_t, int32_t>>>({"constant_argument_function"});
+  auto signatures = exec::simpleFunctions().getFunctionSignatures(
+      "constant_argument_function");
+  EXPECT_FALSE(signatures[0]->constantArguments().at(0));
+  EXPECT_TRUE(signatures[0]->constantArguments().at(1));
+  EXPECT_TRUE(signatures[0]->constantArguments().at(2));
+  EXPECT_TRUE(signatures[0]->constantArguments().at(3));
+  EXPECT_TRUE(signatures[0]->constantArguments().at(4));
+  EXPECT_TRUE(signatures[0]->constantArguments().at(5));
+}
+
+template <typename TExec>
+struct DecimalPlusOneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      const A* /*a*/) {
+    scale_ = getDecimalPrecisionScale(*inputTypes[0]).second;
+  }
+
+  template <typename R, typename A>
+  void call(R& out, A a) {
+    out = a + DecimalUtil::kPowersOfTen[scale_];
+  }
+
+ private:
+  int8_t scale_;
+};
+
+template <typename TExec>
+struct DecimalPlusTwoFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      const A* /*a*/) {
+    scale_ = getDecimalPrecisionScale(*inputTypes[0]).second;
+  }
+
+  template <typename R, typename A>
+  void call(R& out, A a) {
+    out = a + 2 * DecimalUtil::kPowersOfTen[scale_];
+  }
+
+ private:
+  int8_t scale_;
+};
+
+TEST_F(SimpleFunctionTest, decimals) {
+  const auto& registry = exec::simpleFunctions();
+
+  registerFunction<
+      DecimalPlusOneFunction,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P1, S1>>({"decimal_plus_one"});
+
+  auto signatures = registry.getFunctionSignatures("decimal_plus_one");
+
+  EXPECT_EQ(1, signatures.size());
+  EXPECT_EQ("(decimal(i1,i5)) -> decimal(i1,i5)", signatures[0]->toString());
+
+  registerFunction<
+      DecimalPlusOneFunction,
+      LongDecimal<P1, S1>,
+      LongDecimal<P1, S1>>({"decimal_plus_one"});
+
+  signatures = registry.getFunctionSignatures("decimal_plus_one");
+
+  EXPECT_EQ(1, signatures.size());
+  EXPECT_EQ("(decimal(i1,i5)) -> decimal(i1,i5)", signatures[0]->toString());
+
+  {
+    auto resolved =
+        registry.resolveFunction("decimal_plus_one", {DECIMAL(10, 2)});
+    ASSERT_TRUE(resolved.has_value());
+    EXPECT_EQ(DECIMAL(10, 2)->toString(), resolved->type()->toString());
+  }
+
+  {
+    auto resolved =
+        registry.resolveFunction("decimal_plus_one", {DECIMAL(30, 4)});
+    ASSERT_TRUE(resolved.has_value());
+    EXPECT_EQ(DECIMAL(30, 4)->toString(), resolved->type()->toString());
+  }
+
+  auto data = makeRowVector({
+      // 12.34, 25.67
+      makeFlatVector<int64_t>({1234, 2567}, DECIMAL(10, 2)),
+      // 0.1234, 0.2567
+      makeFlatVector<int128_t>({1234, 2567}, DECIMAL(30, 4)),
+  });
+
+  auto result = evaluate("decimal_plus_one(c0)", data);
+
+  // 13.34, 26.67
+  VectorPtr expected = makeFlatVector<int64_t>({1334, 2667}, DECIMAL(10, 2));
+  assertEqualVectors(expected, result);
+
+  result = evaluate("decimal_plus_one(c1)", data);
+
+  // 1.1234, 1.2567
+  expected = makeFlatVector<int128_t>({11234, 12567}, DECIMAL(30, 4));
+  assertEqualVectors(expected, result);
+
+  // Verify overwrite behavior. Register a different function using the same
+  // name and physical signature as decimal_plus_one. Expect the new function to
+  // be used for (short) -> short signature.
+  // Not overwrite function registry.
+  registerFunction<
+      DecimalPlusTwoFunction,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P1, S1>>({"decimal_plus_one"}, {}, false);
+  result = evaluate("decimal_plus_one(c1)", data);
+  assertEqualVectors(expected, result);
+
+  // Overwrite function registry.
+  registerFunction<
+      DecimalPlusTwoFunction,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P1, S1>>({"decimal_plus_one"});
+
+  result = evaluate("decimal_plus_one(c0)", data);
+
+  // 14.34, 27.67
+  expected = makeFlatVector<int64_t>({1434, 2767}, DECIMAL(10, 2));
+  assertEqualVectors(expected, result);
+
+  // Expect the original decimal_plus_one to be used for (long) -> long
+  // signature that wasn't overwritten.
+
+  result = evaluate("decimal_plus_one(c1)", data);
+
+  // 1.1234, 1.2567
+  expected = makeFlatVector<int128_t>({11234, 12567}, DECIMAL(30, 4));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(SimpleFunctionTest, decimalsWithConstraints) {
+  const auto& registry = exec::simpleFunctions();
+
+  registerFunction<
+      DecimalPlusTwoFunction,
+      ShortDecimal<P2, S1>,
+      ShortDecimal<P1, S1>>(
+      {"decimal_plus_two"},
+      {exec::SignatureVariable(
+          P2::name(),
+          fmt::format("{a_precision} + 1", fmt::arg("a_precision", P1::name())),
+          exec::ParameterType::kIntegerParameter)});
+
+  auto signatures = registry.getFunctionSignatures("decimal_plus_two");
+
+  EXPECT_EQ(1, signatures.size());
+  EXPECT_EQ("(decimal(i1,i5)) -> decimal(i2,i5)", signatures[0]->toString());
+  auto it = signatures[0]->variables().find("i2");
+  EXPECT_TRUE(it != signatures[0]->variables().end());
+  EXPECT_EQ("i1 + 1", it->second.constraint());
+
+  {
+    auto resolved =
+        registry.resolveFunction("decimal_plus_two", {DECIMAL(10, 2)});
+    ASSERT_TRUE(resolved.has_value());
+    EXPECT_EQ(DECIMAL(11, 2)->toString(), resolved->type()->toString());
+  }
+
+  registerFunction<
+      DecimalPlusTwoFunction,
+      ShortDecimal<P2, S2>,
+      ShortDecimal<P1, S1>>(
+      {"decimal_plus_two_2"},
+      {
+          exec::SignatureVariable(
+              P2::name(),
+              fmt::format(
+                  "{a_precision} + 1", fmt::arg("a_precision", P1::name())),
+              exec::ParameterType::kIntegerParameter),
+          exec::SignatureVariable(
+              S2::name(),
+              fmt::format("{a_scale} + 1", fmt::arg("a_scale", S1::name())),
+              exec::ParameterType::kIntegerParameter),
+      });
+
+  signatures = registry.getFunctionSignatures("decimal_plus_two_2");
+
+  EXPECT_EQ(1, signatures.size());
+  EXPECT_EQ("(decimal(i1,i5)) -> decimal(i2,i6)", signatures[0]->toString());
+  it = signatures[0]->variables().find("i2");
+  EXPECT_TRUE(it != signatures[0]->variables().end());
+  EXPECT_EQ("i1 + 1", it->second.constraint());
+
+  it = signatures[0]->variables().find("i6");
+  EXPECT_TRUE(it != signatures[0]->variables().end());
+  EXPECT_EQ("i5 + 1", it->second.constraint());
+
+  {
+    auto resolved =
+        registry.resolveFunction("decimal_plus_two_2", {DECIMAL(10, 2)});
+    ASSERT_TRUE(resolved.has_value());
+    EXPECT_EQ(DECIMAL(11, 3)->toString(), resolved->type()->toString());
+  }
+}
+
+template <typename TExec>
+struct NoThrowFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  Status call(out_type<int64_t>& out, const arg_type<int64_t>& in) {
+    if (in % 3 != 0) {
+      return Status::UserError("Input must be divisible by 3");
+    }
+
+    // Throwing exceptions is not recommended, but allowed.
+    VELOX_USER_CHECK(in % 2 == 0, "Input must be even");
+
+    if (in == 6) {
+      return Status::UnknownError("Input must not be 6");
+    }
+
+    out = in / 6;
+    return Status::OK();
+  }
+};
+
+TEST_F(SimpleFunctionTest, noThrow) {
+  registerFunction<NoThrowFunction, int64_t, int64_t>({"no_throw"});
+
+  auto result = evaluateOnce<int64_t, int64_t>("no_throw(c0)", 12);
+  EXPECT_EQ(2, result);
+
+  // Errors reported via Status.
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<int64_t, int64_t>("no_throw(c0)", 10)),
+      "Input must be divisible by 3");
+
+  result = evaluateOnce<int64_t, int64_t>("try(no_throw(c0))", 10);
+  EXPECT_EQ(std::nullopt, result);
+
+  // Errors reported by throwing exceptions.
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<int64_t, int64_t>("no_throw(c0)", 15)),
+      "Input must be even");
+
+  result = evaluateOnce<int64_t, int64_t>("try(no_throw(c0))", 15);
+  EXPECT_EQ(std::nullopt, result);
+
+  // Non-user errors cannot be suppressed by TRY.
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<int64_t, int64_t>("no_throw(c0)", 6)),
+      "Input must not be 6");
+
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<int64_t, int64_t>("try(no_throw(c0))", 6)),
+      "Input must not be 6");
+}
+
+template <typename TExec>
+struct CallNullableNoThrowFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  Status callNullable(out_type<int64_t>& out, const arg_type<int64_t>* in) {
+    if (!in) {
+      return Status::UserError("Input cannot be NULL");
+    }
+    out = *in + 1;
+    return Status::OK();
+  }
+};
+
+TEST_F(SimpleFunctionTest, callNullableNoThrow) {
+  registerFunction<CallNullableNoThrowFunction, int64_t, int64_t>(
+      {"nullable_no_throw"});
+  // Error reported via Status by callNullable.
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<int64_t, int64_t>("nullable_no_throw(c0)", std::nullopt)),
+      "Input cannot be NULL");
+  auto result = evaluateOnce<int64_t, int64_t>(
+      "try(nullable_no_throw(c0))", std::nullopt);
+  EXPECT_EQ(std::nullopt, result);
+
+  // No error.
+  result = evaluateOnce<int64_t, int64_t>("nullable_no_throw(c0)", 1);
+  EXPECT_EQ(2, result);
+}
+
+template <typename TExec>
+struct CallNullFreeNoThrowFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  Status callNullFree(out_type<int64_t>& out, const arg_type<int64_t>& in) {
+    if (in == 0) {
+      return Status::UserError("Input cannot be 0");
+    }
+    if (in % 2 == 0) {
+      return Status::UserError("Input cannot be even");
+    }
+    out = in + 1;
+    return Status::OK();
+  }
+};
+
+TEST_F(SimpleFunctionTest, callNullFreeNoThrow) {
+  registerFunction<CallNullFreeNoThrowFunction, int64_t, int64_t>(
+      {"null_free_no_throw"});
+  // Error reported via Status by callNullable.
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<int64_t, int64_t>("null_free_no_throw(c0)", 0)),
+      "Input cannot be 0");
+  auto result =
+      evaluateOnce<int64_t, int64_t>("try(null_free_no_throw(c0))", 0);
+  EXPECT_EQ(std::nullopt, result);
+
+  VELOX_ASSERT_THROW(
+      (evaluateOnce<int64_t, int64_t>("null_free_no_throw(c0)", 4)),
+      "Input cannot be even");
+  result = evaluateOnce<int64_t, int64_t>("try(null_free_no_throw(c0))", 4);
+  EXPECT_EQ(std::nullopt, result);
+
+  // No error.
+  result = evaluateOnce<int64_t, int64_t>("null_free_no_throw(c0)", 1);
+  EXPECT_EQ(2, result);
+}
+
 } // namespace
diff --git a/velox/expression/tests/SparkExpressionFuzzerTest.cpp b/velox/expression/tests/SparkExpressionFuzzerTest.cpp
deleted file mode 100644
index 73eacbfcbe2d5..0000000000000
--- a/velox/expression/tests/SparkExpressionFuzzerTest.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <folly/String.h>
-#include <folly/init/Init.h>
-#include <gtest/gtest.h>
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include "velox/expression/tests/FuzzerRunner.h"
-#include "velox/functions/sparksql/Register.h"
-
-DEFINE_int64(
-    seed,
-    123456,
-    "Initial seed for random number generator "
-    "(use it to reproduce previous results).");
-
-DEFINE_string(
-    only,
-    "",
-    "If specified, Fuzzer will only choose functions from "
-    "this comma separated list of function names "
-    "(e.g: --only \"split\" or --only \"substr,ltrim\").");
-
-DEFINE_string(
-    special_forms,
-    "and,or",
-    "Comma-separated list of special forms to use in generated expression. "
-    "Supported special forms: and, or, coalesce, if, switch, cast.");
-
-int main(int argc, char** argv) {
-  facebook::velox::functions::sparksql::registerFunctions("");
-
-  ::testing::InitGoogleTest(&argc, argv);
-
-  // Calls common init functions in the necessary order, initializing
-  // singletons, installing proper signal handlers for better debugging
-  // experience, and initialize glog and gflags.
-  folly::init(&argc, &argv);
-
-  // The following list are the Spark UDFs that hit issues
-  // For rlike you need the following combo in the only list:
-  // rlike, md5 and upper
-  std::unordered_set<std::string> skipFunctions = {
-      "regexp_extract",
-      "rlike",
-      "chr",
-      "replace",
-      "might_contain",
-      "unix_timestamp"};
-  return FuzzerRunner::run(
-      FLAGS_only, FLAGS_seed, skipFunctions, FLAGS_special_forms);
-}
diff --git a/velox/expression/tests/StringWriterTest.cpp b/velox/expression/tests/StringWriterTest.cpp
index 9f8543d95fad8..aec9d9cacb88a 100644
--- a/velox/expression/tests/StringWriterTest.cpp
+++ b/velox/expression/tests/StringWriterTest.cpp
@@ -18,9 +18,11 @@
 #include <glog/logging.h>
 #include "folly/Range.h"
 #include "gtest/gtest.h"
+#include "velox/expression/VectorWriters.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 namespace facebook::velox::expressions::test {
+using namespace facebook::velox::test;
 
 class StringWriterTest : public functions::test::FunctionBaseTest {};
 
@@ -103,4 +105,26 @@ TEST_F(StringWriterTest, copyFromCString) {
 
   ASSERT_EQ(vector->valueAt(0), "1 2 3 4 5 "_sv);
 }
+
+TEST_F(StringWriterTest, vectorWriter) {
+  auto vector = makeFlatVector<StringView>(3);
+  exec::VectorWriter<Varchar> writer;
+  writer.init(*vector);
+  writer.setOffset(0);
+  writer.current().copy_from("1 2 3");
+  writer.commitNull();
+
+  writer.setOffset(1);
+  writer.current().copy_from("4 5 6");
+  writer.commit(true);
+
+  writer.setOffset(2);
+  writer.current().copy_from("7 8 9");
+  writer.commit(false);
+  writer.finish();
+
+  auto expected = std::vector<std::optional<std::string>>{
+      std::nullopt, "4 5 6", std::nullopt};
+  assertEqualVectors(vector, makeNullableFlatVector(expected));
+}
 } // namespace facebook::velox::expressions::test
diff --git a/velox/expression/tests/TryExprTest.cpp b/velox/expression/tests/TryExprTest.cpp
index df50069a52d74..2f51e7c22bc2f 100644
--- a/velox/expression/tests/TryExprTest.cpp
+++ b/velox/expression/tests/TryExprTest.cpp
@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/vector/ConstantVector.h"
@@ -25,9 +26,32 @@
 
 namespace facebook::velox {
 
+using namespace common::testutil;
 using namespace facebook::velox::test;
 
-class TryExprTest : public functions::test::FunctionBaseTest {};
+class TryExprTest : public functions::test::FunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    FunctionBaseTest::SetUpTestCase();
+    TestValue::enable();
+  }
+
+  VectorPtr evaluateWithCustomMemoryPool(
+      const std::string& sql,
+      const RowVectorPtr& data,
+      memory::MemoryPool* pool) {
+    auto typedExpr = makeTypedExpr(sql, asRowType(data->type()));
+
+    core::ExecCtx execCtx{pool, queryCtx_.get()};
+    exec::ExprSet exprSet({typedExpr}, &execCtx);
+    exec::EvalCtx context(&execCtx, &exprSet, data.get());
+
+    std::vector<VectorPtr> result(1);
+    SelectivityVector allRows(data->size());
+    exprSet.eval(allRows, context, result);
+    return result[0];
+  }
+};
 
 TEST_F(TryExprTest, tryExpr) {
   auto a = makeFlatVector<int32_t>({10, 20, 30, 20, 50, 30});
@@ -212,10 +236,6 @@ class CreateConstantAndThrow : public exec::VectorFunction {
   CreateConstantAndThrow(bool throwOnFirstRow = false)
       : throwOnFirstRow_{throwOnFirstRow} {}
 
-  bool isDefaultNullBehavior() const override {
-    return true;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& /* args */,
@@ -444,4 +464,98 @@ TEST_F(TryExprTest, doesNotMutateSharedResults) {
   // Make sure input did not change.
   assertEqualVectors(input, makeFlatVector<StringView>({"1", "", ""}));
 }
+
+TEST_F(TryExprTest, decimalDivideByZero) {
+  options_.parseDecimalAsDouble = false;
+  auto shortDecimalFlatVector =
+      makeFlatVector<int64_t>({10, 20, 30}, DECIMAL(10, 2));
+  auto longDecimalFlatVector =
+      makeFlatVector<int128_t>({10100, 20202, 30300}, DECIMAL(30, 10));
+
+  auto result =
+      evaluate("try(c0 / 0.0)", makeRowVector({shortDecimalFlatVector}));
+  auto expectedShort = makeNullableFlatVector<int64_t>(
+      {std::nullopt, std::nullopt, std::nullopt}, DECIMAL(11, 2));
+  assertEqualVectors(expectedShort, result);
+
+  result = evaluate("try(c0 / 0.0)", makeRowVector({longDecimalFlatVector}));
+  auto expectedLong = makeNullableFlatVector<int128_t>(
+      {std::nullopt, std::nullopt, std::nullopt}, DECIMAL(31, 10));
+  assertEqualVectors(expectedLong, result);
+}
+
+// This test must be DEBUG_ONLY because it uses SCOPED_TESTVALUE_SET.
+DEBUG_ONLY_TEST_F(TryExprTest, errorRestoringContext) {
+  registerFunction<TestingAlwaysThrowsFunction, bool, bool>({"always_throws"});
+  // Use a constant input so the encoding is peeled, triggering the EvalCtx to
+  // be saved and restored.
+  auto data = makeRowVector({makeConstant(true, 3)});
+
+  // EvalCtx::restore calls addError to propagate errors to the original
+  // context, this can resize the ErrorVector leading to exceptions through a
+  // variety of paths.  For the sake of simplicity, the TestValue is used here
+  // to simulate an OOM.
+  std::string exceptionMessage =
+      "Expected exception. Pretend we're out of memory.";
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::EvalCtx::restore",
+      std::function<void(exec::EvalCtx*)>(
+          ([&](exec::EvalCtx*) { VELOX_FAIL(exceptionMessage); })));
+
+  VELOX_ASSERT_THROW(
+      evaluate("try(always_throws(c0))", data), exceptionMessage);
+}
+
+// Verify memory usage increase from wrapping an expression in TRY.
+//
+// When wrapping an expression memory usage increase should not exceed
+// the amount of memory needed to store 1 bit per row (to track whether an
+// error occurred or not).
+TEST_F(TryExprTest, memoryUsage) {
+  vector_size_t size = 10'000;
+
+  auto data = makeRowVector({makeFlatVector<int64_t>(size, folly::identity)});
+
+  // Measure memory usage without TRY.
+  int64_t baseline;
+
+  {
+    auto pool = rootPool_->addLeafChild("test-memory-usage");
+    auto result = evaluateWithCustomMemoryPool("c0 + 1", data, pool.get());
+    ASSERT_FALSE(result->mayHaveNulls());
+
+    baseline = pool->peakBytes();
+  }
+
+  // Measure memory usage with TRY over non-throwing expression.
+  {
+    // Memory allocation is not precisise. There is some padding, rounding and
+    // quantizing that makes it hard to tell exactly how much memory is
+    // allocated. Given that we only need 1 bit per row, allowing 4 bits per row
+    // seems conservative enough.
+    const auto expectedIncrease = size / 2;
+
+    auto pool = rootPool_->addLeafChild("test-memory-usage");
+    auto result = evaluateWithCustomMemoryPool("try(c0 + 1)", data, pool.get());
+    ASSERT_FALSE(result->mayHaveNulls());
+
+    ASSERT_GE(pool->peakBytes(), baseline);
+    ASSERT_LE(pool->peakBytes(), baseline + expectedIncrease)
+        << (pool->peakBytes() - baseline);
+  }
+
+  // Measure memory usage with TRY over expression that throws from every row.
+  {
+    const auto expectedIncrease = size / 2;
+
+    auto pool = rootPool_->addLeafChild("test-memory-usage");
+    auto result = evaluateWithCustomMemoryPool("try(c0 / 0)", data, pool.get());
+    ASSERT_TRUE(result->mayHaveNulls());
+
+    ASSERT_GE(pool->peakBytes(), baseline);
+    ASSERT_LE(pool->peakBytes(), baseline + expectedIncrease)
+        << (pool->peakBytes() - baseline);
+  }
+}
+
 } // namespace facebook::velox
diff --git a/velox/expression/type_calculation/CMakeLists.txt b/velox/expression/type_calculation/CMakeLists.txt
index 2e6a674c71d0a..0c0a3b114b1cf 100644
--- a/velox/expression/type_calculation/CMakeLists.txt
+++ b/velox/expression/type_calculation/CMakeLists.txt
@@ -15,7 +15,8 @@
 bison_target(
   TypeCalculationParser TypeCalculation.yy
   ${CMAKE_CURRENT_BINARY_DIR}/TypeCalculation.yy.cc
-  DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/TypeCalculation.yy.h)
+  DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/TypeCalculation.yy.h
+  COMPILE_FLAGS "-Werror -Wno-deprecated")
 
 flex_target(
   TypeCalculationScanner TypeCalculation.ll
@@ -23,10 +24,20 @@ flex_target(
 
 add_flex_bison_dependency(TypeCalculationScanner TypeCalculationParser)
 
+if(VELOX_MONO_LIBRARY)
+  add_custom_target(
+    velox_type_calculation_gen_src
+    DEPENDS ${BISON_TypeCalculationParser_OUTPUTS}
+            ${FLEX_TypeCalculationScanner_OUTPUTS})
+  add_dependencies(velox velox_type_calculation_gen_src)
+endif()
+
 include_directories(${PROJECT_BINARY_DIR})
 include_directories(${FLEX_INCLUDE_DIRS})
-add_library(
+velox_add_library(
   velox_type_calculation
-  ${BISON_TypeCalculationParser_OUTPUTS} ${FLEX_TypeCalculationScanner_OUTPUTS}
-  Scanner.h TypeCalculation.h)
-target_link_libraries(velox_type_calculation velox_common_base)
+  ${BISON_TypeCalculationParser_OUTPUTS}
+  ${FLEX_TypeCalculationScanner_OUTPUTS}
+  Scanner.h
+  TypeCalculation.h)
+velox_link_libraries(velox_type_calculation velox_common_base)
diff --git a/velox/expression/type_calculation/Scanner.h b/velox/expression/type_calculation/Scanner.h
index 81df42ca8ea14..aeddd8779f181 100644
--- a/velox/expression/type_calculation/Scanner.h
+++ b/velox/expression/type_calculation/Scanner.h
@@ -31,7 +31,7 @@ class Scanner : public yyFlexLexer {
       std::istream& arg_yyin,
       std::ostream& arg_yyout,
       std::unordered_map<std::string, int>& values)
-      : yyFlexLexer(&arg_yyin, &arg_yyout), values_(values){};
+      : yyFlexLexer(&arg_yyin, &arg_yyout), values_(values) {}
   int lex(Parser::semantic_type* yylval);
 
   void setValue(const std::string& varName, int value) {
diff --git a/velox/expression/type_calculation/TypeCalculation.ll b/velox/expression/type_calculation/TypeCalculation.ll
index d2aee1bc69d1e..46e8c271da62d 100644
--- a/velox/expression/type_calculation/TypeCalculation.ll
+++ b/velox/expression/type_calculation/TypeCalculation.ll
@@ -43,9 +43,12 @@ int yyFlexLexer::yylex() {
 
 #include "velox/expression/type_calculation/TypeCalculation.h"
 
-void facebook::velox::expression::calculation::evaluate(const std::string& calculation, std::unordered_map<std::string, int>& variables) {
-    std::istringstream is(calculation);
-    facebook::velox::expression::calculate::Scanner scanner{ is, std::cerr, variables};
-    facebook::velox::expression::calculate::Parser parser{ &scanner };
-    parser.parse();
+void facebook::velox::expression::calculation::evaluate(
+    const std::string& calculation,
+    std::unordered_map<std::string, int>& variables) {
+  std::istringstream is(calculation);
+  std::ostringstream os;
+  facebook::velox::expression::calculate::Scanner scanner{is, os, variables};
+  facebook::velox::expression::calculate::Parser parser{&scanner};
+  parser.parse();
 }
diff --git a/velox/expression/type_calculation/TypeCalculation.yy b/velox/expression/type_calculation/TypeCalculation.yy
index 0c756a8de3ec5..39dbdb230f1ea 100644
--- a/velox/expression/type_calculation/TypeCalculation.yy
+++ b/velox/expression/type_calculation/TypeCalculation.yy
@@ -32,7 +32,7 @@
 %nterm <long long>  iexp
 
 %nonassoc           ASSIGN
-%right              TERNARY
+%right              TERNARY COLON
 %left               EQ NEQ
 %left               LT LTE GT GTE
 %left               PLUS MINUS
@@ -45,26 +45,25 @@ calc    : VAR ASSIGN iexp           { scanner->setValue($1, $3); }
         | error                     { yyerrok; }
         ;
 
-iexp    : INT                       { $$ = $1; }
-        | iexp PLUS iexp            { $$ = $1 + $3; }
-        | iexp MINUS iexp           { $$ = $1 - $3; }
-        | iexp MULTIPLY iexp        { $$ = $1 * $3; }
-        | iexp DIVIDE iexp          { $$ = $1 / $3; }
-        | iexp MODULO iexp          { $$ = $1 % $3; }
-        | MINUS iexp %prec UMINUS   { $$ = -$2; }
-        | LPAREN iexp RPAREN        { $$ = $2; }
+iexp    : INT                               { $$ = $1; }
+        | iexp PLUS iexp                    { $$ = $1 + $3; }
+        | iexp MINUS iexp                   { $$ = $1 - $3; }
+        | iexp MULTIPLY iexp                { $$ = $1 * $3; }
+        | iexp DIVIDE iexp                  { $$ = $1 / $3; }
+        | iexp MODULO iexp                  { $$ = $1 % $3; }
+        | MINUS iexp %prec UMINUS           { $$ = -$2; }
+        | LPAREN iexp RPAREN                { $$ = $2; }
         | MAX LPAREN iexp COMMA iexp RPAREN { $$ = std::max($3, $5); }
         | MIN LPAREN iexp COMMA iexp RPAREN { $$ = std::min($3, $5); }
-        | iexp LT iexp              { $$ = $1 < $3; }
-        | iexp LTE iexp             { $$ = $1 <= $3; }
-        | iexp GT iexp              { $$ = $1 > $3; }
-        | iexp GTE iexp             { $$ = $1 >= $3; }
-        | iexp EQ iexp              { $$ = $1 == $3; }
-        | iexp NEQ iexp             { $$ = $1 != $3; }
-        | iexp TERNARY iexp COLON iexp { $$ = $1 ? $3 : $5; }
-        | VAR                       { $$ = scanner->getValue($1); }
+        | iexp LT iexp                      { $$ = $1 < $3; }
+        | iexp LTE iexp                     { $$ = $1 <= $3; }
+        | iexp GT iexp                      { $$ = $1 > $3; }
+        | iexp GTE iexp                     { $$ = $1 >= $3; }
+        | iexp EQ iexp                      { $$ = $1 == $3; }
+        | iexp NEQ iexp                     { $$ = $1 != $3; }
+        | iexp TERNARY iexp COLON iexp      { $$ = $1 ? $3 : $5; }
+        | VAR                               { $$ = scanner->getValue($1); }
         ;
-
 %%
 
 void facebook::velox::expression::calculate::Parser::error(const std::string& msg) {
diff --git a/velox/external/date/CMakeLists.txt b/velox/external/date/CMakeLists.txt
index 3cde881bc2a58..1cc626b2b60d1 100644
--- a/velox/external/date/CMakeLists.txt
+++ b/velox/external/date/CMakeLists.txt
@@ -9,8 +9,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-include_directories(SYSTEM velox/external)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_OS_TZDB")
 
-add_library(velox_external_date tz.cpp)
+velox_add_library(velox_external_date tz.cpp)
+velox_include_directories(velox_external_date SYSTEM PUBLIC velox/external)
+velox_compile_definitions(velox_external_date PRIVATE USE_OS_TZDB)
diff --git a/velox/external/date/date.h b/velox/external/date/date.h
index 62c150121f2fa..ac6d636dd4283 100644
--- a/velox/external/date/date.h
+++ b/velox/external/date/date.h
@@ -1,5 +1,5 @@
-#ifndef DATE_H
-#define DATE_H
+#ifndef VELOX_DATE_H
+#define VELOX_DATE_H
 
 // The MIT License (MIT)
 //
@@ -86,6 +86,10 @@
 #   pragma warning(disable : 4127)
 #endif
 
+namespace facebook
+{
+namespace velox
+{
 namespace date
 {
 
@@ -7933,7 +7937,9 @@ operator<<(std::basic_ostream<CharT, Traits>& os,
                  detail::get_units<CharT>(typename Period::type{});
 }
 
-}  // namespace date
+} // namespace date
+} // namespace velox
+} // namespace facebook
 
 #ifdef _MSC_VER
 #   pragma warning(pop)
@@ -7943,4 +7949,4 @@ operator<<(std::basic_ostream<CharT, Traits>& os,
 # pragma GCC diagnostic pop
 #endif
 
-#endif  // DATE_H
+#endif  // VELOX_DATE_H
diff --git a/velox/external/date/ios.h b/velox/external/date/ios.h
index ee54b9d084cd2..da1af46f66733 100644
--- a/velox/external/date/ios.h
+++ b/velox/external/date/ios.h
@@ -24,27 +24,33 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#ifndef ios_hpp
-#define ios_hpp
+#ifndef velox_ios_hpp
+#define velox_ios_hpp
 
 #if __APPLE__
 # include <TargetConditionals.h>
 # if TARGET_OS_IPHONE
 #   include <string>
 
+    namespace facebook
+    {
+    namespace velox
+    {
     namespace date
     {
     namespace iOSUtils
     {
-    
+
     std::string get_tzdata_path();
     std::string get_current_timezone();
-    
+
     }  // namespace iOSUtils
     }  // namespace date
+    }  // namespace velox
+    }  // namespace facebook
 
 # endif  // TARGET_OS_IPHONE
 #else   // !__APPLE__
 # define TARGET_OS_IPHONE 0
 #endif  // !__APPLE__
-#endif // ios_hpp
+#endif // velox_ios_hpp
diff --git a/velox/external/date/iso_week.h b/velox/external/date/iso_week.h
new file mode 100644
index 0000000000000..f173042aaccf9
--- /dev/null
+++ b/velox/external/date/iso_week.h
@@ -0,0 +1,1770 @@
+#ifndef ISO_WEEK_H
+#define ISO_WEEK_H
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2015, 2016, 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "date.h"
+
+#include <climits>
+
+namespace facebook
+{
+namespace velox
+{
+namespace date
+{
+namespace iso_week
+{
+
+// y/wn/wd
+// wn/wd/y
+// wd/wn/y
+
+using days = date::days;
+using weeks = date::weeks;
+using years = date::years;
+
+// time_point
+
+using sys_days = date::sys_days;
+using local_days = date::local_days;
+
+// types
+
+struct last_week
+{
+    explicit last_week() = default;
+};
+
+class weekday;
+class weeknum;
+class year;
+
+class year_weeknum;
+class year_lastweek;
+class weeknum_weekday;
+class lastweek_weekday;
+
+class year_weeknum_weekday;
+class year_lastweek_weekday;
+
+// date composition operators
+
+CONSTCD11 year_weeknum operator/(const year& y, const weeknum& wn) NOEXCEPT;
+CONSTCD11 year_weeknum operator/(const year& y, int            wn) NOEXCEPT;
+
+CONSTCD11 year_lastweek operator/(const year& y, last_week      wn) NOEXCEPT;
+
+CONSTCD11 weeknum_weekday operator/(const weeknum& wn, const weekday& wd) NOEXCEPT;
+CONSTCD11 weeknum_weekday operator/(const weeknum& wn, int            wd) NOEXCEPT;
+CONSTCD11 weeknum_weekday operator/(const weekday& wd, const weeknum& wn) NOEXCEPT;
+CONSTCD11 weeknum_weekday operator/(const weekday& wd, int            wn) NOEXCEPT;
+
+CONSTCD11 lastweek_weekday operator/(const last_week& wn, const weekday& wd) NOEXCEPT;
+CONSTCD11 lastweek_weekday operator/(const last_week& wn, int            wd) NOEXCEPT;
+CONSTCD11 lastweek_weekday operator/(const weekday& wd, const last_week& wn) NOEXCEPT;
+
+CONSTCD11 year_weeknum_weekday operator/(const year_weeknum& ywn, const weekday& wd) NOEXCEPT;
+CONSTCD11 year_weeknum_weekday operator/(const year_weeknum& ywn, int            wd) NOEXCEPT;
+CONSTCD11 year_weeknum_weekday operator/(const weeknum_weekday& wnwd, const year& y) NOEXCEPT;
+CONSTCD11 year_weeknum_weekday operator/(const weeknum_weekday& wnwd, int         y) NOEXCEPT;
+
+CONSTCD11 year_lastweek_weekday operator/(const year_lastweek& ylw, const weekday& wd) NOEXCEPT;
+CONSTCD11 year_lastweek_weekday operator/(const year_lastweek& ylw, int            wd) NOEXCEPT;
+
+CONSTCD11 year_lastweek_weekday operator/(const lastweek_weekday& lwwd, const year& y) NOEXCEPT;
+CONSTCD11 year_lastweek_weekday operator/(const lastweek_weekday& lwwd, int         y) NOEXCEPT;
+
+// weekday
+
+class weekday
+{
+    unsigned char wd_;
+public:
+    explicit CONSTCD11 weekday(unsigned wd) NOEXCEPT;
+    CONSTCD11 weekday(date::weekday wd) NOEXCEPT;
+    explicit weekday(int) = delete;
+    CONSTCD11 weekday(const sys_days& dp) NOEXCEPT;
+    CONSTCD11 explicit weekday(const local_days& dp) NOEXCEPT;
+
+    weekday& operator++()    NOEXCEPT;
+    weekday  operator++(int) NOEXCEPT;
+    weekday& operator--()    NOEXCEPT;
+    weekday  operator--(int) NOEXCEPT;
+
+    weekday& operator+=(const days& d) NOEXCEPT;
+    weekday& operator-=(const days& d) NOEXCEPT;
+
+    CONSTCD11 explicit operator unsigned() const NOEXCEPT;
+    CONSTCD11 operator date::weekday() const NOEXCEPT;
+    CONSTCD11 bool ok() const NOEXCEPT;
+
+private:
+    static CONSTCD11 unsigned char weekday_from_days(int z) NOEXCEPT;
+    static CONSTCD11 unsigned char to_iso_encoding(unsigned char) NOEXCEPT;
+    static CONSTCD11 unsigned from_iso_encoding(unsigned) NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const weekday& x, const weekday& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const weekday& x, const weekday& y) NOEXCEPT;
+
+CONSTCD14 weekday operator+(const weekday& x, const days&    y) NOEXCEPT;
+CONSTCD14 weekday operator+(const days&    x, const weekday& y) NOEXCEPT;
+CONSTCD14 weekday operator-(const weekday& x, const days&    y) NOEXCEPT;
+CONSTCD14 days    operator-(const weekday& x, const weekday& y) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd);
+
+// year
+
+class year
+{
+    short y_;
+
+public:
+    explicit CONSTCD11 year(int y) NOEXCEPT;
+
+    year& operator++()    NOEXCEPT;
+    year  operator++(int) NOEXCEPT;
+    year& operator--()    NOEXCEPT;
+    year  operator--(int) NOEXCEPT;
+
+    year& operator+=(const years& y) NOEXCEPT;
+    year& operator-=(const years& y) NOEXCEPT;
+
+    CONSTCD14 bool is_leap() const NOEXCEPT;
+
+    CONSTCD11 explicit operator int() const NOEXCEPT;
+    CONSTCD11 bool ok() const NOEXCEPT;
+
+    static CONSTCD11 year min() NOEXCEPT;
+    static CONSTCD11 year max() NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const year& x, const year& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const year& x, const year& y) NOEXCEPT;
+CONSTCD11 bool operator< (const year& x, const year& y) NOEXCEPT;
+CONSTCD11 bool operator> (const year& x, const year& y) NOEXCEPT;
+CONSTCD11 bool operator<=(const year& x, const year& y) NOEXCEPT;
+CONSTCD11 bool operator>=(const year& x, const year& y) NOEXCEPT;
+
+CONSTCD11 year  operator+(const year&  x, const years& y) NOEXCEPT;
+CONSTCD11 year  operator+(const years& x, const year&  y) NOEXCEPT;
+CONSTCD11 year  operator-(const year&  x, const years& y) NOEXCEPT;
+CONSTCD11 years operator-(const year&  x, const year&  y) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year& y);
+
+// weeknum
+
+class weeknum
+{
+    unsigned char wn_;
+
+public:
+    explicit CONSTCD11 weeknum(unsigned wn) NOEXCEPT;
+
+    weeknum& operator++()    NOEXCEPT;
+    weeknum  operator++(int) NOEXCEPT;
+    weeknum& operator--()    NOEXCEPT;
+    weeknum  operator--(int) NOEXCEPT;
+
+    weeknum& operator+=(const weeks& y) NOEXCEPT;
+    weeknum& operator-=(const weeks& y) NOEXCEPT;
+
+    CONSTCD11 explicit operator unsigned() const NOEXCEPT;
+    CONSTCD11 bool ok() const NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const weeknum& x, const weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const weeknum& x, const weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator< (const weeknum& x, const weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator> (const weeknum& x, const weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator<=(const weeknum& x, const weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator>=(const weeknum& x, const weeknum& y) NOEXCEPT;
+
+CONSTCD11 weeknum  operator+(const weeknum& x, const weeks&   y) NOEXCEPT;
+CONSTCD11 weeknum  operator+(const weeks&   x, const weeknum& y) NOEXCEPT;
+CONSTCD11 weeknum  operator-(const weeknum& x, const weeks&   y) NOEXCEPT;
+CONSTCD11 weeks    operator-(const weeknum& x, const weeknum& y) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum& wn);
+
+// year_weeknum
+
+class year_weeknum
+{
+    iso_week::year    y_;
+    iso_week::weeknum wn_;
+
+public:
+    CONSTCD11 year_weeknum(const iso_week::year& y, const iso_week::weeknum& wn) NOEXCEPT;
+
+    CONSTCD11 iso_week::year    year()    const NOEXCEPT;
+    CONSTCD11 iso_week::weeknum weeknum() const NOEXCEPT;
+
+    year_weeknum& operator+=(const years& dy) NOEXCEPT;
+    year_weeknum& operator-=(const years& dy) NOEXCEPT;
+
+    CONSTCD11 bool ok() const NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const year_weeknum& x, const year_weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const year_weeknum& x, const year_weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator< (const year_weeknum& x, const year_weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator> (const year_weeknum& x, const year_weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator<=(const year_weeknum& x, const year_weeknum& y) NOEXCEPT;
+CONSTCD11 bool operator>=(const year_weeknum& x, const year_weeknum& y) NOEXCEPT;
+
+CONSTCD11 year_weeknum operator+(const year_weeknum& ym, const years& dy) NOEXCEPT;
+CONSTCD11 year_weeknum operator+(const years& dy, const year_weeknum& ym) NOEXCEPT;
+CONSTCD11 year_weeknum operator-(const year_weeknum& ym, const years& dy) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_weeknum& ym);
+
+// year_lastweek
+
+class year_lastweek
+{
+    iso_week::year    y_;
+
+public:
+    CONSTCD11 explicit year_lastweek(const iso_week::year& y) NOEXCEPT;
+
+    CONSTCD11 iso_week::year    year()    const NOEXCEPT;
+    CONSTCD14 iso_week::weeknum weeknum() const NOEXCEPT;
+
+    year_lastweek& operator+=(const years& dy) NOEXCEPT;
+    year_lastweek& operator-=(const years& dy) NOEXCEPT;
+
+    CONSTCD11 bool ok() const NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const year_lastweek& x, const year_lastweek& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const year_lastweek& x, const year_lastweek& y) NOEXCEPT;
+CONSTCD11 bool operator< (const year_lastweek& x, const year_lastweek& y) NOEXCEPT;
+CONSTCD11 bool operator> (const year_lastweek& x, const year_lastweek& y) NOEXCEPT;
+CONSTCD11 bool operator<=(const year_lastweek& x, const year_lastweek& y) NOEXCEPT;
+CONSTCD11 bool operator>=(const year_lastweek& x, const year_lastweek& y) NOEXCEPT;
+
+CONSTCD11 year_lastweek operator+(const year_lastweek& ym, const years& dy) NOEXCEPT;
+CONSTCD11 year_lastweek operator+(const years& dy, const year_lastweek& ym) NOEXCEPT;
+CONSTCD11 year_lastweek operator-(const year_lastweek& ym, const years& dy) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_lastweek& ym);
+
+// weeknum_weekday
+
+class weeknum_weekday
+{
+    iso_week::weeknum wn_;
+    iso_week::weekday wd_;
+
+public:
+    CONSTCD11 weeknum_weekday(const iso_week::weeknum& wn,
+                              const iso_week::weekday& wd) NOEXCEPT;
+
+    CONSTCD11 iso_week::weeknum weeknum() const NOEXCEPT;
+    CONSTCD11 iso_week::weekday weekday() const NOEXCEPT;
+
+    CONSTCD14 bool ok() const NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator< (const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator> (const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator<=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator>=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum_weekday& md);
+
+// lastweek_weekday
+
+class lastweek_weekday
+{
+    iso_week::weekday wd_;
+
+public:
+    CONSTCD11 explicit lastweek_weekday(const iso_week::weekday& wd) NOEXCEPT;
+
+    CONSTCD11 iso_week::weekday weekday() const NOEXCEPT;
+
+    CONSTCD14 bool ok() const NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator< (const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator> (const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator<=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator>=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const lastweek_weekday& md);
+
+// year_lastweek_weekday
+
+class year_lastweek_weekday
+{
+    iso_week::year    y_;
+    iso_week::weekday wd_;
+
+public:
+    CONSTCD11 year_lastweek_weekday(const iso_week::year& y,
+                                    const iso_week::weekday& wd) NOEXCEPT;
+
+    year_lastweek_weekday& operator+=(const years& y) NOEXCEPT;
+    year_lastweek_weekday& operator-=(const years& y) NOEXCEPT;
+
+    CONSTCD11 iso_week::year    year()    const NOEXCEPT;
+    CONSTCD14 iso_week::weeknum weeknum() const NOEXCEPT;
+    CONSTCD11 iso_week::weekday weekday() const NOEXCEPT;
+
+    CONSTCD14 operator sys_days() const NOEXCEPT;
+    CONSTCD14 explicit operator local_days() const NOEXCEPT;
+    CONSTCD11 bool ok() const NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator< (const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator> (const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator<=(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator>=(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT;
+
+CONSTCD11 year_lastweek_weekday operator+(const year_lastweek_weekday& ywnwd, const years& y) NOEXCEPT;
+CONSTCD11 year_lastweek_weekday operator+(const years& y, const year_lastweek_weekday& ywnwd) NOEXCEPT;
+CONSTCD11 year_lastweek_weekday operator-(const year_lastweek_weekday& ywnwd, const years& y) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_lastweek_weekday& ywnwd);
+
+// class year_weeknum_weekday
+
+class year_weeknum_weekday
+{
+    iso_week::year    y_;
+    iso_week::weeknum wn_;
+    iso_week::weekday wd_;
+
+public:
+    CONSTCD11 year_weeknum_weekday(const iso_week::year& y, const iso_week::weeknum& wn,
+                                   const iso_week::weekday& wd) NOEXCEPT;
+    CONSTCD14 year_weeknum_weekday(const year_lastweek_weekday& ylwwd) NOEXCEPT;
+    CONSTCD14 year_weeknum_weekday(const sys_days& dp) NOEXCEPT;
+    CONSTCD14 explicit year_weeknum_weekday(const local_days& dp) NOEXCEPT;
+
+    year_weeknum_weekday& operator+=(const years& y) NOEXCEPT;
+    year_weeknum_weekday& operator-=(const years& y) NOEXCEPT;
+
+    CONSTCD11 iso_week::year    year()    const NOEXCEPT;
+    CONSTCD11 iso_week::weeknum weeknum() const NOEXCEPT;
+    CONSTCD11 iso_week::weekday weekday() const NOEXCEPT;
+
+    CONSTCD14 operator sys_days() const NOEXCEPT;
+    CONSTCD14 explicit operator local_days() const NOEXCEPT;
+    CONSTCD14 bool ok() const NOEXCEPT;
+
+private:
+    static CONSTCD14 year_weeknum_weekday from_days(days dp) NOEXCEPT;
+};
+
+CONSTCD11 bool operator==(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator!=(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator< (const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator> (const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator<=(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT;
+CONSTCD11 bool operator>=(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT;
+
+CONSTCD11 year_weeknum_weekday operator+(const year_weeknum_weekday& ywnwd, const years& y) NOEXCEPT;
+CONSTCD11 year_weeknum_weekday operator+(const years& y, const year_weeknum_weekday& ywnwd) NOEXCEPT;
+CONSTCD11 year_weeknum_weekday operator-(const year_weeknum_weekday& ywnwd, const years& y) NOEXCEPT;
+
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_weeknum_weekday& ywnwd);
+
+//----------------+
+// Implementation |
+//----------------+
+
+// weekday
+
+CONSTCD11
+inline
+unsigned char
+weekday::to_iso_encoding(unsigned char z) NOEXCEPT
+{
+    return z != 0 ? z : (unsigned char)7;
+}
+
+CONSTCD11
+inline
+unsigned
+weekday::from_iso_encoding(unsigned z) NOEXCEPT
+{
+    return z != 7 ? z : 0u;
+}
+
+CONSTCD11
+inline
+unsigned char
+weekday::weekday_from_days(int z) NOEXCEPT
+{
+    return to_iso_encoding(static_cast<unsigned char>(static_cast<unsigned>(
+        z >= -4 ? (z+4) % 7 : (z+5) % 7 + 6)));
+}
+
+CONSTCD11
+inline
+weekday::weekday(unsigned wd) NOEXCEPT
+    : wd_(static_cast<decltype(wd_)>(wd))
+    {}
+
+CONSTCD11
+inline
+weekday::weekday(date::weekday wd) NOEXCEPT
+    : wd_(wd.iso_encoding())
+    {}
+
+CONSTCD11
+inline
+weekday::weekday(const sys_days& dp) NOEXCEPT
+    : wd_(weekday_from_days(dp.time_since_epoch().count()))
+    {}
+
+CONSTCD11
+inline
+weekday::weekday(const local_days& dp) NOEXCEPT
+    : wd_(weekday_from_days(dp.time_since_epoch().count()))
+    {}
+
+inline weekday& weekday::operator++() NOEXCEPT {if (++wd_ == 8) wd_ = 1; return *this;}
+inline weekday weekday::operator++(int) NOEXCEPT {auto tmp(*this); ++(*this); return tmp;}
+inline weekday& weekday::operator--() NOEXCEPT {if (wd_-- == 1) wd_ = 7; return *this;}
+inline weekday weekday::operator--(int) NOEXCEPT {auto tmp(*this); --(*this); return tmp;}
+
+inline
+weekday&
+weekday::operator+=(const days& d) NOEXCEPT
+{
+    *this = *this + d;
+    return *this;
+}
+
+inline
+weekday&
+weekday::operator-=(const days& d) NOEXCEPT
+{
+    *this = *this - d;
+    return *this;
+}
+
+CONSTCD11
+inline
+weekday::operator unsigned() const NOEXCEPT
+{
+    return wd_;
+}
+
+CONSTCD11
+inline
+weekday::operator date::weekday() const NOEXCEPT
+{
+    return date::weekday{from_iso_encoding(unsigned{wd_})};
+}
+
+CONSTCD11 inline bool weekday::ok() const NOEXCEPT {return 1 <= wd_ && wd_ <= 7;}
+
+CONSTCD11
+inline
+bool
+operator==(const weekday& x, const weekday& y) NOEXCEPT
+{
+    return static_cast<unsigned>(x) == static_cast<unsigned>(y);
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const weekday& x, const weekday& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD14
+inline
+days
+operator-(const weekday& x, const weekday& y) NOEXCEPT
+{
+    auto const diff = static_cast<unsigned>(x) - static_cast<unsigned>(y);
+    return days{diff <= 6 ? diff : diff + 7};
+}
+
+CONSTCD14
+inline
+weekday
+operator+(const weekday& x, const days& y) NOEXCEPT
+{
+    auto const wdu = static_cast<long long>(static_cast<unsigned>(x) - 1u) + y.count();
+    auto const wk = (wdu >= 0 ? wdu : wdu-6) / 7;
+    return weekday{static_cast<unsigned>(wdu - wk * 7) + 1u};
+}
+
+CONSTCD14
+inline
+weekday
+operator+(const days& x, const weekday& y) NOEXCEPT
+{
+    return y + x;
+}
+
+CONSTCD14
+inline
+weekday
+operator-(const weekday& x, const days& y) NOEXCEPT
+{
+    return x + -y;
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd)
+{
+    switch (static_cast<unsigned>(wd))
+    {
+    case 7:
+        os << "Sun";
+        break;
+    case 1:
+        os << "Mon";
+        break;
+    case 2:
+        os << "Tue";
+        break;
+    case 3:
+        os << "Wed";
+        break;
+    case 4:
+        os << "Thu";
+        break;
+    case 5:
+        os << "Fri";
+        break;
+    case 6:
+        os << "Sat";
+        break;
+    default:
+        os << static_cast<unsigned>(wd) << " is not a valid weekday";
+        break;
+    }
+    return os;
+}
+
+// year
+
+CONSTCD11 inline year::year(int y) NOEXCEPT : y_(static_cast<decltype(y_)>(y)) {}
+inline year& year::operator++() NOEXCEPT {++y_; return *this;}
+inline year year::operator++(int) NOEXCEPT {auto tmp(*this); ++(*this); return tmp;}
+inline year& year::operator--() NOEXCEPT {--y_; return *this;}
+inline year year::operator--(int) NOEXCEPT {auto tmp(*this); --(*this); return tmp;}
+inline year& year::operator+=(const years& y) NOEXCEPT {*this = *this + y; return *this;}
+inline year& year::operator-=(const years& y) NOEXCEPT {*this = *this - y; return *this;}
+
+CONSTCD14
+inline
+bool
+year::is_leap() const NOEXCEPT
+{
+    const auto y = date::year{static_cast<int>(y_)};
+    const auto s0 = sys_days((y-years{1})/12/date::thu[date::last]);
+    const auto s1 = sys_days(y/12/date::thu[date::last]);
+    return s1-s0 != days{7*52};
+}
+
+CONSTCD11 inline year::operator int() const NOEXCEPT {return y_;}
+CONSTCD11 inline bool year::ok() const NOEXCEPT {return min() <= *this && *this <= max();}
+
+CONSTCD11
+inline
+year
+year::min() NOEXCEPT
+{
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    using std::chrono::hours;
+    using std::chrono::duration_cast;
+    static_assert(sizeof(seconds)*CHAR_BIT >= 41, "seconds may overflow");
+    static_assert(sizeof(hours)*CHAR_BIT >= 30, "hours may overflow");
+    return sizeof(minutes)*CHAR_BIT < 34 ?
+        year{1970} + duration_cast<years>(minutes::min()) :
+        year{std::numeric_limits<short>::min()};
+}
+
+CONSTCD11
+inline
+year
+year::max() NOEXCEPT
+{
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    using std::chrono::hours;
+    using std::chrono::duration_cast;
+    static_assert(sizeof(seconds)*CHAR_BIT >= 41, "seconds may overflow");
+    static_assert(sizeof(hours)*CHAR_BIT >= 30, "hours may overflow");
+    return sizeof(minutes)*CHAR_BIT < 34 ?
+        year{1969} + duration_cast<years>(minutes::max()) :
+        year{std::numeric_limits<short>::max()};
+}
+
+CONSTCD11
+inline
+bool
+operator==(const year& x, const year& y) NOEXCEPT
+{
+    return static_cast<int>(x) == static_cast<int>(y);
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const year& x, const year& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD11
+inline
+bool
+operator<(const year& x, const year& y) NOEXCEPT
+{
+    return static_cast<int>(x) < static_cast<int>(y);
+}
+
+CONSTCD11
+inline
+bool
+operator>(const year& x, const year& y) NOEXCEPT
+{
+    return y < x;
+}
+
+CONSTCD11
+inline
+bool
+operator<=(const year& x, const year& y) NOEXCEPT
+{
+    return !(y < x);
+}
+
+CONSTCD11
+inline
+bool
+operator>=(const year& x, const year& y) NOEXCEPT
+{
+    return !(x < y);
+}
+
+CONSTCD11
+inline
+years
+operator-(const year& x, const year& y) NOEXCEPT
+{
+    return years{static_cast<int>(x) - static_cast<int>(y)};
+}
+
+CONSTCD11
+inline
+year
+operator+(const year& x, const years& y) NOEXCEPT
+{
+    return year{static_cast<int>(x) + y.count()};
+}
+
+CONSTCD11
+inline
+year
+operator+(const years& x, const year& y) NOEXCEPT
+{
+    return y + x;
+}
+
+CONSTCD11
+inline
+year
+operator-(const year& x, const years& y) NOEXCEPT
+{
+    return year{static_cast<int>(x) - y.count()};
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year& y)
+{
+    date::detail::save_ostream<CharT, Traits> _(os);
+    os.fill('0');
+    os.flags(std::ios::dec | std::ios::internal);
+    os.width(4 + (y < year{0}));
+    os << static_cast<int>(y);
+    return os;
+}
+
+#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
+inline namespace literals
+{
+
+CONSTCD11
+inline
+iso_week::year
+operator "" _y(unsigned long long y) NOEXCEPT
+{
+    return iso_week::year(static_cast<int>(y));
+}
+
+CONSTCD11
+inline
+iso_week::weeknum
+operator "" _w(unsigned long long wn) NOEXCEPT
+{
+    return iso_week::weeknum(static_cast<unsigned>(wn));
+}
+
+#endif  // !defined(_MSC_VER) || (_MSC_VER >= 1900)
+
+CONSTDATA iso_week::last_week last{};
+
+CONSTDATA iso_week::weekday sun{7u};
+CONSTDATA iso_week::weekday mon{1u};
+CONSTDATA iso_week::weekday tue{2u};
+CONSTDATA iso_week::weekday wed{3u};
+CONSTDATA iso_week::weekday thu{4u};
+CONSTDATA iso_week::weekday fri{5u};
+CONSTDATA iso_week::weekday sat{6u};
+
+#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
+}  // inline namespace literals
+#endif
+
+// weeknum
+
+CONSTCD11
+inline
+weeknum::weeknum(unsigned wn) NOEXCEPT
+    : wn_(static_cast<decltype(wn_)>(wn))
+    {}
+
+inline weeknum& weeknum::operator++() NOEXCEPT {++wn_; return *this;}
+inline weeknum weeknum::operator++(int) NOEXCEPT {auto tmp(*this); ++(*this); return tmp;}
+inline weeknum& weeknum::operator--() NOEXCEPT {--wn_; return *this;}
+inline weeknum weeknum::operator--(int) NOEXCEPT {auto tmp(*this); --(*this); return tmp;}
+
+inline
+weeknum&
+weeknum::operator+=(const weeks& y) NOEXCEPT
+{
+    *this = *this + y;
+    return *this;
+}
+
+inline
+weeknum&
+weeknum::operator-=(const weeks& y) NOEXCEPT
+{
+    *this = *this - y;
+    return *this;
+}
+
+CONSTCD11 inline weeknum::operator unsigned() const NOEXCEPT {return wn_;}
+CONSTCD11 inline bool weeknum::ok() const NOEXCEPT {return 1 <= wn_ && wn_ <= 53;}
+
+CONSTCD11
+inline
+bool
+operator==(const weeknum& x, const weeknum& y) NOEXCEPT
+{
+    return static_cast<unsigned>(x) == static_cast<unsigned>(y);
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const weeknum& x, const weeknum& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD11
+inline
+bool
+operator<(const weeknum& x, const weeknum& y) NOEXCEPT
+{
+    return static_cast<unsigned>(x) < static_cast<unsigned>(y);
+}
+
+CONSTCD11
+inline
+bool
+operator>(const weeknum& x, const weeknum& y) NOEXCEPT
+{
+    return y < x;
+}
+
+CONSTCD11
+inline
+bool
+operator<=(const weeknum& x, const weeknum& y) NOEXCEPT
+{
+    return !(y < x);
+}
+
+CONSTCD11
+inline
+bool
+operator>=(const weeknum& x, const weeknum& y) NOEXCEPT
+{
+    return !(x < y);
+}
+
+CONSTCD11
+inline
+weeks
+operator-(const weeknum& x, const weeknum& y) NOEXCEPT
+{
+    return weeks{static_cast<weeks::rep>(static_cast<unsigned>(x)) -
+                 static_cast<weeks::rep>(static_cast<unsigned>(y))};
+}
+
+CONSTCD11
+inline
+weeknum
+operator+(const weeknum& x, const weeks& y) NOEXCEPT
+{
+    return weeknum{static_cast<unsigned>(x) + static_cast<unsigned>(y.count())};
+}
+
+CONSTCD11
+inline
+weeknum
+operator+(const weeks& x, const weeknum& y) NOEXCEPT
+{
+    return y + x;
+}
+
+CONSTCD11
+inline
+weeknum
+operator-(const weeknum& x, const weeks& y) NOEXCEPT
+{
+    return x + -y;
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum& wn)
+{
+    date::detail::save_ostream<CharT, Traits> _(os);
+    os << 'W';
+    os.fill('0');
+    os.flags(std::ios::dec | std::ios::right);
+    os.width(2);
+    os << static_cast<unsigned>(wn);
+    return os;
+}
+
+// year_weeknum
+
+CONSTCD11
+inline
+year_weeknum::year_weeknum(const iso_week::year& y, const iso_week::weeknum& wn) NOEXCEPT
+    : y_(y)
+    , wn_(wn)
+    {}
+
+CONSTCD11 inline year year_weeknum::year() const NOEXCEPT {return y_;}
+CONSTCD11 inline weeknum year_weeknum::weeknum() const NOEXCEPT {return wn_;}
+CONSTCD11 inline bool year_weeknum::ok() const NOEXCEPT
+{
+    return y_.ok() && 1u <= static_cast<unsigned>(wn_) && wn_ <= (y_/last).weeknum();
+}
+
+inline
+year_weeknum&
+year_weeknum::operator+=(const years& dy) NOEXCEPT
+{
+    *this = *this + dy;
+    return *this;
+}
+
+inline
+year_weeknum&
+year_weeknum::operator-=(const years& dy) NOEXCEPT
+{
+    *this = *this - dy;
+    return *this;
+}
+
+CONSTCD11
+inline
+bool
+operator==(const year_weeknum& x, const year_weeknum& y) NOEXCEPT
+{
+    return x.year() == y.year() && x.weeknum() == y.weeknum();
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const year_weeknum& x, const year_weeknum& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD11
+inline
+bool
+operator<(const year_weeknum& x, const year_weeknum& y) NOEXCEPT
+{
+    return x.year() < y.year() ? true
+        : (x.year() > y.year() ? false
+        : (x.weeknum() < y.weeknum()));
+}
+
+CONSTCD11
+inline
+bool
+operator>(const year_weeknum& x, const year_weeknum& y) NOEXCEPT
+{
+    return y < x;
+}
+
+CONSTCD11
+inline
+bool
+operator<=(const year_weeknum& x, const year_weeknum& y) NOEXCEPT
+{
+    return !(y < x);
+}
+
+CONSTCD11
+inline
+bool
+operator>=(const year_weeknum& x, const year_weeknum& y) NOEXCEPT
+{
+    return !(x < y);
+}
+
+CONSTCD11
+inline
+year_weeknum
+operator+(const year_weeknum& ym, const years& dy) NOEXCEPT
+{
+    return (ym.year() + dy) / ym.weeknum();
+}
+
+CONSTCD11
+inline
+year_weeknum
+operator+(const years& dy, const year_weeknum& ym) NOEXCEPT
+{
+    return ym + dy;
+}
+
+CONSTCD11
+inline
+year_weeknum
+operator-(const year_weeknum& ym, const years& dy) NOEXCEPT
+{
+    return ym + -dy;
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_weeknum& ywn)
+{
+    return os << ywn.year() << '-' << ywn.weeknum();
+}
+
+
+// year_lastweek
+
+CONSTCD11
+inline
+year_lastweek::year_lastweek(const iso_week::year& y) NOEXCEPT
+    : y_(y)
+    {}
+
+CONSTCD11 inline year year_lastweek::year() const NOEXCEPT {return y_;}
+
+CONSTCD14
+inline
+weeknum
+year_lastweek::weeknum() const NOEXCEPT
+{
+    return iso_week::weeknum(y_.is_leap() ? 53u : 52u);
+}
+
+CONSTCD11 inline bool year_lastweek::ok() const NOEXCEPT {return y_.ok();}
+
+inline
+year_lastweek&
+year_lastweek::operator+=(const years& dy) NOEXCEPT
+{
+    *this = *this + dy;
+    return *this;
+}
+
+inline
+year_lastweek&
+year_lastweek::operator-=(const years& dy) NOEXCEPT
+{
+    *this = *this - dy;
+    return *this;
+}
+
+CONSTCD11
+inline
+bool
+operator==(const year_lastweek& x, const year_lastweek& y) NOEXCEPT
+{
+    return x.year() == y.year();
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const year_lastweek& x, const year_lastweek& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD11
+inline
+bool
+operator<(const year_lastweek& x, const year_lastweek& y) NOEXCEPT
+{
+    return x.year() < y.year();
+}
+
+CONSTCD11
+inline
+bool
+operator>(const year_lastweek& x, const year_lastweek& y) NOEXCEPT
+{
+    return y < x;
+}
+
+CONSTCD11
+inline
+bool
+operator<=(const year_lastweek& x, const year_lastweek& y) NOEXCEPT
+{
+    return !(y < x);
+}
+
+CONSTCD11
+inline
+bool
+operator>=(const year_lastweek& x, const year_lastweek& y) NOEXCEPT
+{
+    return !(x < y);
+}
+
+CONSTCD11
+inline
+year_lastweek
+operator+(const year_lastweek& ym, const years& dy) NOEXCEPT
+{
+    return year_lastweek{ym.year() + dy};
+}
+
+CONSTCD11
+inline
+year_lastweek
+operator+(const years& dy, const year_lastweek& ym) NOEXCEPT
+{
+    return ym + dy;
+}
+
+CONSTCD11
+inline
+year_lastweek
+operator-(const year_lastweek& ym, const years& dy) NOEXCEPT
+{
+    return ym + -dy;
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_lastweek& ywn)
+{
+    return os << ywn.year() << "-W last";
+}
+
+// weeknum_weekday
+
+CONSTCD11
+inline
+weeknum_weekday::weeknum_weekday(const iso_week::weeknum& wn,
+                                 const iso_week::weekday& wd) NOEXCEPT
+    : wn_(wn)
+    , wd_(wd)
+    {}
+
+CONSTCD11 inline weeknum weeknum_weekday::weeknum() const NOEXCEPT {return wn_;}
+CONSTCD11 inline weekday weeknum_weekday::weekday() const NOEXCEPT {return wd_;}
+
+CONSTCD14
+inline
+bool
+weeknum_weekday::ok() const NOEXCEPT
+{
+    return wn_.ok() && wd_.ok();
+}
+
+CONSTCD11
+inline
+bool
+operator==(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT
+{
+    return x.weeknum() == y.weeknum() && x.weekday() == y.weekday();
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD11
+inline
+bool
+operator<(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT
+{
+    return x.weeknum() < y.weeknum() ? true
+        : (x.weeknum() > y.weeknum() ? false
+        : (static_cast<unsigned>(x.weekday()) < static_cast<unsigned>(y.weekday())));
+}
+
+CONSTCD11
+inline
+bool
+operator>(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT
+{
+    return y < x;
+}
+
+CONSTCD11
+inline
+bool
+operator<=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT
+{
+    return !(y < x);
+}
+
+CONSTCD11
+inline
+bool
+operator>=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT
+{
+    return !(x < y);
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum_weekday& md)
+{
+    return os << md.weeknum() << '-' << md.weekday();
+}
+
+// lastweek_weekday
+
+CONSTCD11
+inline
+lastweek_weekday::lastweek_weekday(const iso_week::weekday& wd) NOEXCEPT
+    : wd_(wd)
+    {}
+
+CONSTCD11 inline weekday lastweek_weekday::weekday() const NOEXCEPT {return wd_;}
+
+CONSTCD14
+inline
+bool
+lastweek_weekday::ok() const NOEXCEPT
+{
+    return wd_.ok();
+}
+
+CONSTCD11
+inline
+bool
+operator==(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT
+{
+    return x.weekday() == y.weekday();
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD11
+inline
+bool
+operator<(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT
+{
+    return static_cast<unsigned>(x.weekday()) < static_cast<unsigned>(y.weekday());
+}
+
+CONSTCD11
+inline
+bool
+operator>(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT
+{
+    return y < x;
+}
+
+CONSTCD11
+inline
+bool
+operator<=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT
+{
+    return !(y < x);
+}
+
+CONSTCD11
+inline
+bool
+operator>=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT
+{
+    return !(x < y);
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const lastweek_weekday& md)
+{
+    return os << "W last-" << md.weekday();
+}
+
+// year_lastweek_weekday
+
+CONSTCD11
+inline
+year_lastweek_weekday::year_lastweek_weekday(const iso_week::year& y,
+                                             const iso_week::weekday& wd) NOEXCEPT
+    : y_(y)
+    , wd_(wd)
+    {}
+
+inline
+year_lastweek_weekday&
+year_lastweek_weekday::operator+=(const years& y) NOEXCEPT
+{
+    *this = *this + y;
+    return *this;
+}
+
+inline
+year_lastweek_weekday&
+year_lastweek_weekday::operator-=(const years& y) NOEXCEPT
+{
+    *this = *this - y;
+    return *this;
+}
+
+CONSTCD11 inline year year_lastweek_weekday::year() const NOEXCEPT {return y_;}
+
+CONSTCD14
+inline
+weeknum
+year_lastweek_weekday::weeknum() const NOEXCEPT
+{
+    return (y_ / last).weeknum();
+}
+
+CONSTCD11 inline weekday year_lastweek_weekday::weekday() const NOEXCEPT {return wd_;}
+
+CONSTCD14
+inline
+year_lastweek_weekday::operator sys_days() const NOEXCEPT
+{
+    return sys_days(date::year{static_cast<int>(y_)}/date::dec/date::thu[date::last])
+         + (sun - thu) - (sun - wd_);
+}
+
+CONSTCD14
+inline
+year_lastweek_weekday::operator local_days() const NOEXCEPT
+{
+    return local_days(date::year{static_cast<int>(y_)}/date::dec/date::thu[date::last])
+         + (sun - thu) - (sun - wd_);
+}
+
+CONSTCD11
+inline
+bool
+year_lastweek_weekday::ok() const NOEXCEPT
+{
+    return y_.ok() && wd_.ok();
+}
+
+CONSTCD11
+inline
+bool
+operator==(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT
+{
+    return x.year() == y.year() && x.weekday() == y.weekday();
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD11
+inline
+bool
+operator<(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT
+{
+    return x.year() < y.year() ? true
+        : (x.year() > y.year() ? false
+        : (static_cast<unsigned>(x.weekday()) < static_cast<unsigned>(y.weekday())));
+}
+
+CONSTCD11
+inline
+bool
+operator>(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT
+{
+    return y < x;
+}
+
+CONSTCD11
+inline
+bool
+operator<=(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT
+{
+    return !(y < x);
+}
+
+CONSTCD11
+inline
+bool
+operator>=(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCEPT
+{
+    return !(x < y);
+}
+
+CONSTCD11
+inline
+year_lastweek_weekday
+operator+(const year_lastweek_weekday& ywnwd, const years& y)  NOEXCEPT
+{
+    return (ywnwd.year() + y) / last / ywnwd.weekday();
+}
+
+CONSTCD11
+inline
+year_lastweek_weekday
+operator+(const years& y, const year_lastweek_weekday& ywnwd)  NOEXCEPT
+{
+    return ywnwd + y;
+}
+
+CONSTCD11
+inline
+year_lastweek_weekday
+operator-(const year_lastweek_weekday& ywnwd, const years& y)  NOEXCEPT
+{
+    return ywnwd + -y;
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_lastweek_weekday& ywnwd)
+{
+    return os << ywnwd.year() << "-W last-" << ywnwd.weekday();
+}
+
+// year_weeknum_weekday
+
+CONSTCD11
+inline
+year_weeknum_weekday::year_weeknum_weekday(const iso_week::year& y,
+                                           const iso_week::weeknum& wn,
+                                           const iso_week::weekday& wd) NOEXCEPT
+    : y_(y)
+    , wn_(wn)
+    , wd_(wd)
+    {}
+
+CONSTCD14
+inline
+year_weeknum_weekday::year_weeknum_weekday(const year_lastweek_weekday& ylwwd) NOEXCEPT
+    : y_(ylwwd.year())
+    , wn_(ylwwd.weeknum())
+    , wd_(ylwwd.weekday())
+    {}
+
+CONSTCD14
+inline
+year_weeknum_weekday::year_weeknum_weekday(const sys_days& dp) NOEXCEPT
+    : year_weeknum_weekday(from_days(dp.time_since_epoch()))
+    {}
+
+CONSTCD14
+inline
+year_weeknum_weekday::year_weeknum_weekday(const local_days& dp) NOEXCEPT
+    : year_weeknum_weekday(from_days(dp.time_since_epoch()))
+    {}
+
+inline
+year_weeknum_weekday&
+year_weeknum_weekday::operator+=(const years& y) NOEXCEPT
+{
+    *this = *this + y;
+    return *this;
+}
+
+inline
+year_weeknum_weekday&
+year_weeknum_weekday::operator-=(const years& y) NOEXCEPT
+{
+    *this = *this - y;
+    return *this;
+}
+
+CONSTCD11 inline year year_weeknum_weekday::year() const NOEXCEPT {return y_;}
+CONSTCD11 inline weeknum year_weeknum_weekday::weeknum() const NOEXCEPT {return wn_;}
+CONSTCD11 inline weekday year_weeknum_weekday::weekday() const NOEXCEPT {return wd_;}
+
+CONSTCD14
+inline
+year_weeknum_weekday::operator sys_days() const NOEXCEPT
+{
+    return sys_days(date::year{static_cast<int>(y_)-1}/date::dec/date::thu[date::last])
+         + (date::mon - date::thu) + weeks{static_cast<unsigned>(wn_)-1} + (wd_ - mon);
+}
+
+CONSTCD14
+inline
+year_weeknum_weekday::operator local_days() const NOEXCEPT
+{
+    return local_days(date::year{static_cast<int>(y_)-1}/date::dec/date::thu[date::last])
+         + (date::mon - date::thu) + weeks{static_cast<unsigned>(wn_)-1} + (wd_ - mon);
+}
+
+CONSTCD14
+inline
+bool
+year_weeknum_weekday::ok() const NOEXCEPT
+{
+    return y_.ok() && wd_.ok() && iso_week::weeknum{1u} <= wn_ && wn_ <= year_lastweek{y_}.weeknum();
+}
+
+CONSTCD14
+inline
+year_weeknum_weekday
+year_weeknum_weekday::from_days(days d) NOEXCEPT
+{
+    const auto dp = sys_days{d};
+    const auto wd = iso_week::weekday{dp};
+    auto y = date::year_month_day{dp + days{3}}.year();
+    auto start = sys_days((y - date::years{1})/date::dec/date::thu[date::last]) + (mon-thu);
+    if (dp < start)
+    {
+        --y;
+        start = sys_days((y - date::years{1})/date::dec/date::thu[date::last]) + (mon-thu);
+    }
+    const auto wn = iso_week::weeknum(
+                       static_cast<unsigned>(date::trunc<weeks>(dp - start).count() + 1));
+    return {iso_week::year(static_cast<int>(y)), wn, wd};
+}
+
+CONSTCD11
+inline
+bool
+operator==(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT
+{
+    return x.year() == y.year() && x.weeknum() == y.weeknum() && x.weekday() == y.weekday();
+}
+
+CONSTCD11
+inline
+bool
+operator!=(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT
+{
+    return !(x == y);
+}
+
+CONSTCD11
+inline
+bool
+operator<(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT
+{
+    return x.year() < y.year() ? true
+        : (x.year() > y.year() ? false
+        : (x.weeknum() < y.weeknum() ? true
+        : (x.weeknum() > y.weeknum() ? false
+        : (static_cast<unsigned>(x.weekday()) < static_cast<unsigned>(y.weekday())))));
+}
+
+CONSTCD11
+inline
+bool
+operator>(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT
+{
+    return y < x;
+}
+
+CONSTCD11
+inline
+bool
+operator<=(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT
+{
+    return !(y < x);
+}
+
+CONSTCD11
+inline
+bool
+operator>=(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT
+{
+    return !(x < y);
+}
+
+CONSTCD11
+inline
+year_weeknum_weekday
+operator+(const year_weeknum_weekday& ywnwd, const years& y)  NOEXCEPT
+{
+    return (ywnwd.year() + y) / ywnwd.weeknum() / ywnwd.weekday();
+}
+
+CONSTCD11
+inline
+year_weeknum_weekday
+operator+(const years& y, const year_weeknum_weekday& ywnwd)  NOEXCEPT
+{
+    return ywnwd + y;
+}
+
+CONSTCD11
+inline
+year_weeknum_weekday
+operator-(const year_weeknum_weekday& ywnwd, const years& y)  NOEXCEPT
+{
+    return ywnwd + -y;
+}
+
+template<class CharT, class Traits>
+inline
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_weeknum_weekday& ywnwd)
+{
+    return os << ywnwd.year() << '-' << ywnwd.weeknum() << '-' << ywnwd.weekday();
+}
+
+// date composition operators
+
+CONSTCD11
+inline
+year_weeknum
+operator/(const year& y, const weeknum& wn) NOEXCEPT
+{
+    return {y, wn};
+}
+
+CONSTCD11
+inline
+year_weeknum
+operator/(const year& y, int wn) NOEXCEPT
+{
+    return y/weeknum(static_cast<unsigned>(wn));
+}
+
+CONSTCD11
+inline
+year_lastweek
+operator/(const year& y, last_week) NOEXCEPT
+{
+    return year_lastweek{y};
+}
+
+CONSTCD11
+inline
+weeknum_weekday
+operator/(const weeknum& wn, const weekday& wd) NOEXCEPT
+{
+    return {wn, wd};
+}
+
+CONSTCD11
+inline
+weeknum_weekday
+operator/(const weeknum& wn, int wd) NOEXCEPT
+{
+    return wn/weekday{static_cast<unsigned>(wd)};
+}
+
+CONSTCD11
+inline
+weeknum_weekday
+operator/(const weekday& wd, const weeknum& wn) NOEXCEPT
+{
+    return wn/wd;
+}
+
+CONSTCD11
+inline
+weeknum_weekday
+operator/(const weekday& wd, int wn) NOEXCEPT
+{
+    return weeknum{static_cast<unsigned>(wn)}/wd;
+}
+
+CONSTCD11
+inline
+lastweek_weekday
+operator/(const last_week&, const weekday& wd) NOEXCEPT
+{
+    return lastweek_weekday{wd};
+}
+
+CONSTCD11
+inline
+lastweek_weekday
+operator/(const last_week& wn, int wd) NOEXCEPT
+{
+    return wn / weekday{static_cast<unsigned>(wd)};
+}
+
+CONSTCD11
+inline
+lastweek_weekday
+operator/(const weekday& wd, const last_week& wn) NOEXCEPT
+{
+    return wn / wd;
+}
+
+CONSTCD11
+inline
+year_weeknum_weekday
+operator/(const year_weeknum& ywn, const weekday& wd) NOEXCEPT
+{
+    return {ywn.year(), ywn.weeknum(), wd};
+}
+
+CONSTCD11
+inline
+year_weeknum_weekday
+operator/(const year_weeknum& ywn, int wd) NOEXCEPT
+{
+    return ywn / weekday(static_cast<unsigned>(wd));
+}
+
+CONSTCD11
+inline
+year_weeknum_weekday
+operator/(const weeknum_weekday& wnwd, const year& y) NOEXCEPT
+{
+    return {y, wnwd.weeknum(), wnwd.weekday()};
+}
+
+CONSTCD11
+inline
+year_weeknum_weekday
+operator/(const weeknum_weekday& wnwd, int y) NOEXCEPT
+{
+    return wnwd / year{y};
+}
+
+CONSTCD11
+inline
+year_lastweek_weekday
+operator/(const year_lastweek& ylw, const weekday& wd) NOEXCEPT
+{
+    return {ylw.year(), wd};
+}
+
+CONSTCD11
+inline
+year_lastweek_weekday
+operator/(const year_lastweek& ylw, int wd) NOEXCEPT
+{
+    return ylw / weekday(static_cast<unsigned>(wd));
+}
+
+CONSTCD11
+inline
+year_lastweek_weekday
+operator/(const lastweek_weekday& lwwd, const year& y) NOEXCEPT
+{
+    return {y, lwwd.weekday()};
+}
+
+CONSTCD11
+inline
+year_lastweek_weekday
+operator/(const lastweek_weekday& lwwd, int y) NOEXCEPT
+{
+    return lwwd / year{y};
+}
+
+} // namespace iso_week
+} // namespace date
+} // namespace velox
+} // namespace facebook
+
+#endif  // ISO_WEEK_H
diff --git a/velox/external/date/patches/0001-int32_days_from_epoch-pr-6550.patch b/velox/external/date/patches/0001-int32_days_from_epoch-pr-6550.patch
new file mode 100644
index 0000000000000..de15ba49e6ecb
--- /dev/null
+++ b/velox/external/date/patches/0001-int32_days_from_epoch-pr-6550.patch
@@ -0,0 +1,92 @@
+diff --git a/fbcode/velox/external/date/date.h b/fbcode/velox/external/date/date.h
+--- a/fbcode/velox/external/date/date.h
++++ b/fbcode/velox/external/date/date.h
+@@ -396,7 +396,7 @@
+ 
+ class year
+ {
+-    short y_;
++    int y_;
+ 
+ public:
+     year() = default;
+@@ -2864,11 +2864,11 @@
+              "This algorithm has not been ported to a 16 bit unsigned integer");
+     static_assert(std::numeric_limits<int>::digits >= 20,
+              "This algorithm has not been ported to a 16 bit signed integer");
+-    auto const z = dp.count() + 719468;
++    auto const z = dp.count() + 719468L; // For velox, use long to avoid overflow.
+     auto const era = (z >= 0 ? z : z - 146096) / 146097;
+     auto const doe = static_cast<unsigned>(z - era * 146097);          // [0, 146096]
+     auto const yoe = (doe - doe/1460 + doe/36524 - doe/146096) / 365;  // [0, 399]
+-    auto const y = static_cast<days::rep>(yoe) + era * 400;
++    auto const y = static_cast<days::rep>(yoe + era * 400);
+     auto const doy = doe - (365*yoe + yoe/4 - yoe/100);                // [0, 365]
+     auto const mp = (5*doy + 2)/153;                                   // [0, 11]
+     auto const d = doy - (153*mp+2)/5 + 1;                             // [1, 31]
+diff --git a/fbcode/velox/functions/prestosql/tests/SequenceTest.cpp b/fbcode/velox/functions/prestosql/tests/SequenceTest.cpp
+--- a/fbcode/velox/functions/prestosql/tests/SequenceTest.cpp
++++ b/fbcode/velox/functions/prestosql/tests/SequenceTest.cpp
+@@ -145,6 +145,18 @@
+   testExpression("sequence(C0, C1)", {startVector, stopVector}, expected);
+ }
+ 
++TEST_F(SequenceTest, dateRange) {
++  const auto startVector = makeConstant<int32_t>(0, 1, DATE());
++  const auto stopVector =
++      makeConstant<int32_t>(std::numeric_limits<int32_t>::max(), 1, DATE());
++  const auto stepVector =
++      makeConstant<int32_t>(12 * 1'000'000, 1, INTERVAL_YEAR_MONTH());
++  const auto expected = makeArrayVector<int32_t>(
++      {{0, 365242500, 730485000, 1095727500, 1460970000, 1826212500}}, DATE());
++  testExpression(
++      "sequence(C0, C1, C2)", {startVector, stopVector, stepVector}, expected);
++}
++
+ TEST_F(SequenceTest, dateArgumentsExceedMaxEntries) {
+   const auto startVector = makeFlatVector<int32_t>({1991, 1992, 1992}, DATE());
+   const auto stopVector = makeFlatVector<int32_t>({1996, 198800, 1992}, DATE());
+@@ -211,16 +223,18 @@
+   const auto startVector = makeFlatVector<int32_t>(
+       {parseDate("1975-01-31"),
+        parseDate("1975-03-15"),
+-       parseDate("2023-12-31")},
++       parseDate("2023-12-31"),
++       parseDate("3892314-06-02")},
+       DATE());
+   const auto stopVector = makeFlatVector<int32_t>(
+       {parseDate("1975-06-20"),
+        parseDate("1974-12-15"),
+-       parseDate("2024-05-31")},
++       parseDate("2024-05-31"),
++       parseDate("4045127-11-23")},
+       DATE());
+ 
+   const auto stepVector =
+-      makeFlatVector<int32_t>({1, -1, 2}, INTERVAL_YEAR_MONTH());
++      makeFlatVector<int32_t>({1, -1, 2, 162700}, INTERVAL_YEAR_MONTH());
+   const auto expected = makeArrayVector<int32_t>(
+       {// last day of Feb
+        // result won't include 1975-06-20
+@@ -237,7 +251,20 @@
+        // leap year
+        {parseDate("2023-12-31"),
+         parseDate("2024-02-29"),
+-        parseDate("2024-04-30")}},
++        parseDate("2024-04-30")},
++       // range of date
++       {parseDate("3892314-06-02"),
++        parseDate("3905872-10-02"),
++        parseDate("3919431-02-02"),
++        parseDate("3932989-06-02"),
++        parseDate("3946547-10-02"),
++        parseDate("3960106-02-02"),
++        parseDate("3973664-06-02"),
++        parseDate("3987222-10-02"),
++        parseDate("4000781-02-02"),
++        parseDate("4014339-06-02"),
++        parseDate("4027897-10-02"),
++        parseDate("4041456-02-02")}},
+       DATE());
+   testExpression(
+       "sequence(C0, C1, C2)", {startVector, stopVector, stepVector}, expected);
diff --git a/velox/external/date/patches/0002-add_namespacing-pr-8332.patch b/velox/external/date/patches/0002-add_namespacing-pr-8332.patch
new file mode 100644
index 0000000000000..d42281d3f6bdb
--- /dev/null
+++ b/velox/external/date/patches/0002-add_namespacing-pr-8332.patch
@@ -0,0 +1,150 @@
+diff --git a/fbcode/velox/external/date/date.h b/fbcode/velox/external/date/date.h
+--- a/fbcode/velox/external/date/date.h
++++ b/fbcode/velox/external/date/date.h
+@@ -86,6 +86,10 @@
+ #   pragma warning(disable : 4127)
+ #endif
+ 
++namespace facebook
++{
++namespace velox
++{
+ namespace date
+ {
+ 
+@@ -7933,7 +7937,9 @@
+                  detail::get_units<CharT>(typename Period::type{});
+ }
+ 
+-}  // namespace date
++} // namespace date
++} // namespace velox
++} // namespace facebook
+ 
+ #ifdef _MSC_VER
+ #   pragma warning(pop)
+diff --git a/fbcode/velox/external/date/ios.h b/fbcode/velox/external/date/ios.h
+--- a/fbcode/velox/external/date/ios.h
++++ b/fbcode/velox/external/date/ios.h
+@@ -32,16 +32,22 @@
+ # if TARGET_OS_IPHONE
+ #   include <string>
+ 
++    namespace facebook
++    {
++    namespace velox
++    {
+     namespace date
+     {
+     namespace iOSUtils
+     {
+-    
++
+     std::string get_tzdata_path();
+     std::string get_current_timezone();
+-    
++
+     }  // namespace iOSUtils
+     }  // namespace date
++    }  // namespace velox
++    }  // namespace facebook
+ 
+ # endif  // TARGET_OS_IPHONE
+ #else   // !__APPLE__
+diff --git a/fbcode/velox/external/date/tz.cpp b/fbcode/velox/external/date/tz.cpp
+--- a/fbcode/velox/external/date/tz.cpp
++++ b/fbcode/velox/external/date/tz.cpp
+@@ -268,6 +268,10 @@
+ 
+ #endif  // !USE_OS_TZDB
+ 
++namespace facebook
++{
++namespace velox
++{
+ namespace date
+ {
+ // +---------------------+
+@@ -3860,6 +3864,8 @@
+ }
+ 
+ }  // namespace date
++}  // namespace velox
++}  // namespace facebook
+ 
+ #if defined(__GNUC__) && __GNUC__ < 5
+ # pragma GCC diagnostic pop
+diff --git a/fbcode/velox/external/date/tz.h b/fbcode/velox/external/date/tz.h
+--- a/fbcode/velox/external/date/tz.h
++++ b/fbcode/velox/external/date/tz.h
+@@ -143,6 +143,10 @@
+ #  endif
+ #endif
+ 
++namespace facebook
++{
++namespace velox
++{
+ namespace date
+ {
+ 
+@@ -2790,5 +2794,7 @@
+ #endif  // !MISSING_LEAP_SECONDS
+ 
+ }  // namespace date
++}  // namespace velox
++}  // namespace facebook
+ 
+ #endif  // TZ_H
+diff --git a/fbcode/velox/external/date/tz_private.h b/fbcode/velox/external/date/tz_private.h
+--- a/fbcode/velox/external/date/tz_private.h
++++ b/fbcode/velox/external/date/tz_private.h
+@@ -34,6 +34,12 @@
+ #include <vector>
+ #endif
+ 
++namespace facebook
++{
++
++namespace velox
++{
++
+ namespace date
+ {
+ 
+@@ -309,6 +315,10 @@
+ 
+ }  // namespace date
+ 
++}  // namespace velox
++
++}  // namespace facebook
++
+ #if defined(_MSC_VER) && (_MSC_VER < 1900)
+ #include "tz.h"
+ #endif
+diff --git a/fbcode/velox/external/date/iso_week.h b/fbcode/velox/external/date/iso_week.h
+--- a/fbcode/velox/external/date/iso_week.h
++++ b/fbcode/velox/external/date/iso_week.h
+@@ -27,12 +27,6 @@
+ 
+ #include <climits>
+ 
+-namespace facebook
+-{
+-namespace velox
+-{
+-namespace date
+-{
+ namespace iso_week
+ {
+ 
+@@ -1763,8 +1757,5 @@
+ }
+ 
+ } // namespace iso_week
+-} // namespace date
+-} // namespace velox
+-} // namespace facebook
+ 
+ #endif  // ISO_WEEK_H
diff --git a/velox/external/date/patches/0003-throw-on-unsupported-tz-conversion-pr-10097.patch b/velox/external/date/patches/0003-throw-on-unsupported-tz-conversion-pr-10097.patch
new file mode 100644
index 0000000000000..716c99d87177c
--- /dev/null
+++ b/velox/external/date/patches/0003-throw-on-unsupported-tz-conversion-pr-10097.patch
@@ -0,0 +1,72 @@
+diff --git a/fbcode/velox/external/date/tz.cpp b/fbcode/velox/external/date/tz.cpp
+--- a/fbcode/velox/external/date/tz.cpp
++++ b/fbcode/velox/external/date/tz.cpp
+@@ -2033,6 +2033,28 @@
+     }
+     for (auto j = 0u; i < transitions_.size(); ++i, ++j)
+         transitions_[i].info = ttinfos_.data() + indices[j];
++
++    // Use getline to discard the first newline, then read the extended
++    // information
++    std::string extended_info;
++    std::getline(inf, extended_info);
++    std::getline(inf, extended_info);
++    auto comma1 = extended_info.find(',');
++
++    // Extended info can either be just the name/offset, or name/offset and
++    // rules. If there are rules, they come in pairs (when the rule starts and
++    // when the rule ends), and are separated by commas (',').
++    if (comma1 != std::string::npos) {
++      auto comma2 = extended_info.find(',', comma1 + 1);
++      assert(comma2 != std::string::npos);
++
++      extended_info_.extended_name_ = extended_info.substr(0, comma1);
++      extended_info_.rule_start_ =
++          extended_info.substr(comma1 + 1, comma2 - comma1 - 1);
++      extended_info_.rule_end_ = extended_info.substr(comma2 + 1);
++    } else {
++      extended_info_.extended_name_ = std::move(extended_info);
++    }
+ }
+ 
+ void
+@@ -2125,6 +2147,16 @@
+     using namespace std::chrono;
+     assert(!transitions_.empty());
+     assert(i != transitions_.begin());
++
++    // Conversions past OS_TZDB items are not supported if the timezone has
++    // repetition rules. Fail instead of returning wrong results
++    if (i == transitions_.end() && extended_info_.has_rules()) {
++      std::stringstream ss;
++      ss << "Unable to convert timezone '" << name_ << "' past "
++         << transitions_.back().timepoint;
++      throw std::invalid_argument(ss.str());
++    }
++
+     sys_info r;
+     r.begin = i[-1].timepoint;
+     r.end = i != transitions_.end() ? i->timepoint :
+diff --git a/fbcode/velox/external/date/tz.h b/fbcode/velox/external/date/tz.h
+--- a/fbcode/velox/external/date/tz.h
++++ b/fbcode/velox/external/date/tz.h
+@@ -790,6 +790,19 @@
+ #if USE_OS_TZDB
+     std::vector<detail::transition>      transitions_;
+     std::vector<detail::expanded_ttinfo> ttinfos_;
++
++    // Stores extended OS_TZDB timezone information, in addition to possible
++    // repetition rules (although these are not supported yet)
++    struct {
++      std::string extended_name_;
++      std::string rule_start_;
++      std::string rule_end_;
++
++      bool has_rules() const {
++        return !rule_start_.empty();
++      }
++    } extended_info_;
++
+ #else  // !USE_OS_TZDB
+     std::vector<detail::zonelet>         zonelets_;
+ #endif  // !USE_OS_TZDB
diff --git a/velox/external/date/patches/0004-update-header-guards-pr-10269.patch b/velox/external/date/patches/0004-update-header-guards-pr-10269.patch
new file mode 100644
index 0000000000000..ab45671899afe
--- /dev/null
+++ b/velox/external/date/patches/0004-update-header-guards-pr-10269.patch
@@ -0,0 +1,75 @@
+diff --git a/velox/external/date/date.h b/velox/external/date/date.h
+index ccbd4587f..ac6d636dd 100644
+--- a/velox/external/date/date.h
++++ b/velox/external/date/date.h
+@@ -1,5 +1,5 @@
+-#ifndef DATE_H
+-#define DATE_H
++#ifndef VELOX_DATE_H
++#define VELOX_DATE_H
+
+ // The MIT License (MIT)
+ //
+@@ -7949,4 +7949,4 @@ operator<<(std::basic_ostream<CharT, Traits>& os,
+ # pragma GCC diagnostic pop
+ #endif
+
+-#endif  // DATE_H
++#endif  // VELOX_DATE_H
+diff --git a/velox/external/date/ios.h b/velox/external/date/ios.h
+index 467798983..da1af46f6 100644
+--- a/velox/external/date/ios.h
++++ b/velox/external/date/ios.h
+@@ -24,8 +24,8 @@
+ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ // SOFTWARE.
+
+-#ifndef ios_hpp
+-#define ios_hpp
++#ifndef velox_ios_hpp
++#define velox_ios_hpp
+
+ #if __APPLE__
+ # include <TargetConditionals.h>
+@@ -53,4 +53,4 @@
+ #else   // !__APPLE__
+ # define TARGET_OS_IPHONE 0
+ #endif  // !__APPLE__
+-#endif // ios_hpp
++#endif // velox_ios_hpp
+diff --git a/velox/external/date/tz.h b/velox/external/date/tz.h
+index 9512900b7..a70bda4ad 100644
+--- a/velox/external/date/tz.h
++++ b/velox/external/date/tz.h
+@@ -1,5 +1,5 @@
+-#ifndef TZ_H
+-#define TZ_H
++#ifndef VELOX_TZ_H
++#define VELOX_TZ_H
+
+ // The MIT License (MIT)
+ //
+@@ -2810,4 +2810,4 @@ to_gps_time(const tai_time<Duration>& t)
+ }  // namespace velox
+ }  // namespace facebook
+
+-#endif  // TZ_H
++#endif  // VELOX_TZ_H
+diff --git a/velox/external/date/tz_private.h b/velox/external/date/tz_private.h
+index 3a985d955..b85a617f2 100644
+--- a/velox/external/date/tz_private.h
++++ b/velox/external/date/tz_private.h
+@@ -1,5 +1,5 @@
+-#ifndef TZ_PRIVATE_H
+-#define TZ_PRIVATE_H
++#ifndef VELOX_TZ_PRIVATE_H
++#define VELOX_TZ_PRIVATE_H
+
+ // The MIT License (MIT)
+ //
+@@ -323,4 +323,4 @@ struct transition
+ #include "tz.h"
+ #endif
+
+-#endif  // TZ_PRIVATE_H
++#endif  // VELOX_TZ_PRIVATE_H
diff --git a/velox/external/date/patches/0005-add_error_type_for_invalid_timezone.patch b/velox/external/date/patches/0005-add_error_type_for_invalid_timezone.patch
new file mode 100644
index 0000000000000..90d20ed37a61b
--- /dev/null
+++ b/velox/external/date/patches/0005-add_error_type_for_invalid_timezone.patch
@@ -0,0 +1,51 @@
+diff --git a/velox/external/date/tz.cpp b/velox/external/date/tz.cpp
+index c3a3a8f7e..69513d7d3 100644
+--- a/velox/external/date/tz.cpp
++++ b/velox/external/date/tz.cpp
+@@ -3577,7 +3577,7 @@ tzdb::locate_zone(const std::string& tz_name) const
+                 return &*zi;
+         }
+ #endif  // !USE_OS_TZDB
+-        throw std::runtime_error(std::string(tz_name) + " not found in timezone database");
++        throw invalid_timezone(std::string(tz_name));
+     }
+     return &*zi;
+ }
+diff --git a/velox/external/date/tz.h b/velox/external/date/tz.h
+index a70bda4ad..c85b30eb7 100644
+--- a/velox/external/date/tz.h
++++ b/velox/external/date/tz.h
+@@ -284,6 +284,33 @@ ambiguous_local_time::make_msg(local_time<Duration> tp, const local_info& i)
+     return os.str();
+ }
+ 
++class invalid_timezone
++    : public std::runtime_error
++{
++public:
++    invalid_timezone(const std::string tz_name);
++
++private:
++    static
++    std::string
++    make_msg(const std::string tz_name);
++};
++
++inline
++invalid_timezone::invalid_timezone(const std::string tz_name)
++    : std::runtime_error(make_msg(tz_name))
++{
++}
++
++inline
++std::string
++invalid_timezone::make_msg(const std::string tz_name)
++{
++    std::ostringstream os;
++    os << tz_name << " not found in timezone database";
++    return os.str();
++}
++
+ class time_zone;
+ 
+ #if HAS_STRING_VIEW
diff --git a/velox/external/date/patches/README b/velox/external/date/patches/README
new file mode 100644
index 0000000000000..666fd06dbfdbc
--- /dev/null
+++ b/velox/external/date/patches/README
@@ -0,0 +1,2 @@
+Contains patches applied to the vendored library, for convenience when
+upgrading it.
diff --git a/velox/external/date/tz.cpp b/velox/external/date/tz.cpp
index 68436c3d89a55..69513d7d3145a 100644
--- a/velox/external/date/tz.cpp
+++ b/velox/external/date/tz.cpp
@@ -268,6 +268,10 @@ get_download_folder()
 
 #endif  // !USE_OS_TZDB
 
+namespace facebook
+{
+namespace velox
+{
 namespace date
 {
 // +---------------------+
@@ -2029,6 +2033,28 @@ time_zone::load_data(std::istream& inf,
     }
     for (auto j = 0u; i < transitions_.size(); ++i, ++j)
         transitions_[i].info = ttinfos_.data() + indices[j];
+
+    // Use getline to discard the first newline, then read the extended
+    // information
+    std::string extended_info;
+    std::getline(inf, extended_info);
+    std::getline(inf, extended_info);
+    auto comma1 = extended_info.find(',');
+
+    // Extended info can either be just the name/offset, or name/offset and
+    // rules. If there are rules, they come in pairs (when the rule starts and
+    // when the rule ends), and are separated by commas (',').
+    if (comma1 != std::string::npos) {
+      auto comma2 = extended_info.find(',', comma1 + 1);
+      assert(comma2 != std::string::npos);
+
+      extended_info_.extended_name_ = extended_info.substr(0, comma1);
+      extended_info_.rule_start_ =
+          extended_info.substr(comma1 + 1, comma2 - comma1 - 1);
+      extended_info_.rule_end_ = extended_info.substr(comma2 + 1);
+    } else {
+      extended_info_.extended_name_ = std::move(extended_info);
+    }
 }
 
 void
@@ -2121,6 +2147,16 @@ time_zone::load_sys_info(std::vector<detail::transition>::const_iterator i) cons
     using namespace std::chrono;
     assert(!transitions_.empty());
     assert(i != transitions_.begin());
+
+    // Conversions past OS_TZDB items are not supported if the timezone has
+    // repetition rules. Fail instead of returning wrong results
+    if (i == transitions_.end() && extended_info_.has_rules()) {
+      std::stringstream ss;
+      ss << "Unable to convert timezone '" << name_ << "' past "
+         << transitions_.back().timepoint;
+      throw std::invalid_argument(ss.str());
+    }
+
     sys_info r;
     r.begin = i[-1].timepoint;
     r.end = i != transitions_.end() ? i->timepoint :
@@ -3541,7 +3577,7 @@ tzdb::locate_zone(const std::string& tz_name) const
                 return &*zi;
         }
 #endif  // !USE_OS_TZDB
-        throw std::runtime_error(std::string(tz_name) + " not found in timezone database");
+        throw invalid_timezone(std::string(tz_name));
     }
     return &*zi;
 }
@@ -3860,6 +3896,8 @@ current_zone()
 }
 
 }  // namespace date
+}  // namespace velox
+}  // namespace facebook
 
 #if defined(__GNUC__) && __GNUC__ < 5
 # pragma GCC diagnostic pop
diff --git a/velox/external/date/tz.h b/velox/external/date/tz.h
index 2f4e542c42193..4ec0dbb44cfd2 100644
--- a/velox/external/date/tz.h
+++ b/velox/external/date/tz.h
@@ -1,5 +1,5 @@
-#ifndef TZ_H
-#define TZ_H
+#ifndef VELOX_TZ_H
+#define VELOX_TZ_H
 
 // The MIT License (MIT)
 //
@@ -143,6 +143,10 @@ static_assert(HAS_REMOTE_API == 0 ? AUTO_DOWNLOAD == 0 : true,
 #  endif
 #endif
 
+namespace facebook
+{
+namespace velox
+{
 namespace date
 {
 
@@ -280,6 +284,33 @@ ambiguous_local_time::make_msg(local_time<Duration> tp, const local_info& i)
     return os.str();
 }
 
+class invalid_timezone
+    : public std::runtime_error
+{
+public:
+    invalid_timezone(const std::string& tz_name);
+
+private:
+    static
+    std::string
+    make_msg(const std::string& tz_name);
+};
+
+inline
+invalid_timezone::invalid_timezone(const std::string& tz_name)
+    : std::runtime_error(make_msg(tz_name))
+{
+}
+
+inline
+std::string
+invalid_timezone::make_msg(const std::string& tz_name)
+{
+    std::ostringstream os;
+    os << tz_name << " not found in timezone database";
+    return os.str();
+}
+
 class time_zone;
 
 #if HAS_STRING_VIEW
@@ -786,6 +817,19 @@ class time_zone
 #if USE_OS_TZDB
     std::vector<detail::transition>      transitions_;
     std::vector<detail::expanded_ttinfo> ttinfos_;
+
+    // Stores extended OS_TZDB timezone information, in addition to possible
+    // repetition rules (although these are not supported yet)
+    struct {
+      std::string extended_name_;
+      std::string rule_start_;
+      std::string rule_end_;
+
+      bool has_rules() const {
+        return !rule_start_.empty();
+      }
+    } extended_info_;
+
 #else  // !USE_OS_TZDB
     std::vector<detail::zonelet>         zonelets_;
 #endif  // !USE_OS_TZDB
@@ -2790,5 +2834,7 @@ to_gps_time(const tai_time<Duration>& t)
 #endif  // !MISSING_LEAP_SECONDS
 
 }  // namespace date
+}  // namespace velox
+}  // namespace facebook
 
-#endif  // TZ_H
+#endif  // VELOX_TZ_H
diff --git a/velox/external/date/tz_private.h b/velox/external/date/tz_private.h
index 798fcf5ad1750..b85a617f2d6d0 100644
--- a/velox/external/date/tz_private.h
+++ b/velox/external/date/tz_private.h
@@ -1,5 +1,5 @@
-#ifndef TZ_PRIVATE_H
-#define TZ_PRIVATE_H
+#ifndef VELOX_TZ_PRIVATE_H
+#define VELOX_TZ_PRIVATE_H
 
 // The MIT License (MIT)
 //
@@ -34,6 +34,12 @@
 #include <vector>
 #endif
 
+namespace facebook
+{
+
+namespace velox
+{
+
 namespace date
 {
 
@@ -309,8 +315,12 @@ struct transition
 
 }  // namespace date
 
+}  // namespace velox
+
+}  // namespace facebook
+
 #if defined(_MSC_VER) && (_MSC_VER < 1900)
 #include "tz.h"
 #endif
 
-#endif  // TZ_PRIVATE_H
+#endif  // VELOX_TZ_PRIVATE_H
diff --git a/velox/external/duckdb/CMakeLists.txt b/velox/external/duckdb/CMakeLists.txt
deleted file mode 100644
index fac01e1d2db61..0000000000000
--- a/velox/external/duckdb/CMakeLists.txt
+++ /dev/null
@@ -1,37 +0,0 @@
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-add_subdirectory(tpch)
-
-add_compile_definitions(DISABLE_DUCKDB_REMOTE_INSTALL)
-
-add_library(
-  duckdb
-  duckdb-1.cpp
-  duckdb-2.cpp
-  duckdb-3.cpp
-  duckdb-4.cpp
-  duckdb-5.cpp
-  duckdb-6.cpp
-  duckdb-7.cpp
-  duckdb-8.cpp
-  duckdb-fastpforlib.cpp
-  duckdb-fmt.cpp
-  duckdb-hyperloglog.cpp
-  duckdb-libpg_query.cpp
-  duckdb-miniz.cpp
-  duckdb-re2.cpp
-  duckdb-utf8proc.cpp)
-
-set_property(TARGET duckdb PROPERTY JOB_POOL_COMPILE high_memory_pool)
-
-# Suppress warnings when compiling duckdb.
-target_compile_options(duckdb PRIVATE -w)
diff --git a/velox/external/duckdb/duckdb-1.cpp b/velox/external/duckdb/duckdb-1.cpp
deleted file mode 100644
index 472fed42070d7..0000000000000
--- a/velox/external/duckdb/duckdb-1.cpp
+++ /dev/null
@@ -1,17145 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-string SimilarCatalogEntry::GetQualifiedName() const {
-	D_ASSERT(Found());
-
-	return schema->name + "." + name;
-}
-
-Catalog::Catalog(DatabaseInstance &db)
-    : db(db), schemas(make_unique<CatalogSet>(*this, make_unique<DefaultSchemaGenerator>(*this))),
-      dependency_manager(make_unique<DependencyManager>(*this)) {
-	catalog_version = 0;
-}
-Catalog::~Catalog() {
-}
-
-Catalog &Catalog::GetCatalog(ClientContext &context) {
-	return context.db->GetCatalog();
-}
-
-CatalogEntry *Catalog::CreateTable(ClientContext &context, BoundCreateTableInfo *info) {
-	auto schema = GetSchema(context, info->base->schema);
-	return CreateTable(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info) {
-	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindCreateTableInfo(move(info));
-	return CreateTable(context, bound_info.get());
-}
-
-CatalogEntry *Catalog::CreateTable(ClientContext &context, SchemaCatalogEntry *schema, BoundCreateTableInfo *info) {
-	return schema->CreateTable(context, info);
-}
-
-CatalogEntry *Catalog::CreateView(ClientContext &context, CreateViewInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return CreateView(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreateView(ClientContext &context, SchemaCatalogEntry *schema, CreateViewInfo *info) {
-	return schema->CreateView(context, info);
-}
-
-CatalogEntry *Catalog::CreateSequence(ClientContext &context, CreateSequenceInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return CreateSequence(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreateType(ClientContext &context, CreateTypeInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return CreateType(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreateSequence(ClientContext &context, SchemaCatalogEntry *schema, CreateSequenceInfo *info) {
-	return schema->CreateSequence(context, info);
-}
-
-CatalogEntry *Catalog::CreateType(ClientContext &context, SchemaCatalogEntry *schema, CreateTypeInfo *info) {
-	return schema->CreateType(context, info);
-}
-
-CatalogEntry *Catalog::CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return CreateTableFunction(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreateTableFunction(ClientContext &context, SchemaCatalogEntry *schema,
-                                           CreateTableFunctionInfo *info) {
-	return schema->CreateTableFunction(context, info);
-}
-
-CatalogEntry *Catalog::CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return CreateCopyFunction(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreateCopyFunction(ClientContext &context, SchemaCatalogEntry *schema,
-                                          CreateCopyFunctionInfo *info) {
-	return schema->CreateCopyFunction(context, info);
-}
-
-CatalogEntry *Catalog::CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return CreatePragmaFunction(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreatePragmaFunction(ClientContext &context, SchemaCatalogEntry *schema,
-                                            CreatePragmaFunctionInfo *info) {
-	return schema->CreatePragmaFunction(context, info);
-}
-
-CatalogEntry *Catalog::CreateFunction(ClientContext &context, CreateFunctionInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return CreateFunction(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreateFunction(ClientContext &context, SchemaCatalogEntry *schema, CreateFunctionInfo *info) {
-	return schema->CreateFunction(context, info);
-}
-
-CatalogEntry *Catalog::CreateCollation(ClientContext &context, CreateCollationInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return CreateCollation(context, schema, info);
-}
-
-CatalogEntry *Catalog::CreateCollation(ClientContext &context, SchemaCatalogEntry *schema, CreateCollationInfo *info) {
-	return schema->CreateCollation(context, info);
-}
-
-CatalogEntry *Catalog::CreateSchema(ClientContext &context, CreateSchemaInfo *info) {
-	D_ASSERT(!info->schema.empty());
-	if (info->schema == TEMP_SCHEMA) {
-		throw CatalogException("Cannot create built-in schema \"%s\"", info->schema);
-	}
-
-	unordered_set<CatalogEntry *> dependencies;
-	auto entry = make_unique<SchemaCatalogEntry>(this, info->schema, info->internal);
-	auto result = entry.get();
-	if (!schemas->CreateEntry(context, info->schema, move(entry), dependencies)) {
-		if (info->on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
-			throw CatalogException("Schema with name %s already exists!", info->schema);
-		} else {
-			D_ASSERT(info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT);
-		}
-		return nullptr;
-	}
-	return result;
-}
-
-void Catalog::DropSchema(ClientContext &context, DropInfo *info) {
-	D_ASSERT(!info->name.empty());
-	ModifyCatalog();
-	if (!schemas->DropEntry(context, info->name, info->cascade)) {
-		if (!info->if_exists) {
-			throw CatalogException("Schema with name \"%s\" does not exist!", info->name);
-		}
-	}
-}
-
-void Catalog::DropEntry(ClientContext &context, DropInfo *info) {
-	ModifyCatalog();
-	if (info->type == CatalogType::SCHEMA_ENTRY) {
-		// DROP SCHEMA
-		DropSchema(context, info);
-		return;
-	}
-
-	auto lookup = LookupEntry(context, info->type, info->schema, info->name, info->if_exists);
-	if (!lookup.Found()) {
-		return;
-	}
-
-	lookup.schema->DropEntry(context, info);
-}
-
-CatalogEntry *Catalog::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	return AddFunction(context, schema, info);
-}
-
-CatalogEntry *Catalog::AddFunction(ClientContext &context, SchemaCatalogEntry *schema, CreateFunctionInfo *info) {
-	return schema->AddFunction(context, info);
-}
-
-SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &schema_name, bool if_exists,
-                                       QueryErrorContext error_context) {
-	D_ASSERT(!schema_name.empty());
-	if (schema_name == TEMP_SCHEMA) {
-		return ClientData::Get(context).temporary_objects.get();
-	}
-	auto entry = schemas->GetEntry(context, schema_name);
-	if (!entry && !if_exists) {
-		throw CatalogException(error_context.FormatError("Schema with name %s does not exist!", schema_name));
-	}
-	return (SchemaCatalogEntry *)entry;
-}
-
-void Catalog::ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback) {
-	// create all default schemas first
-	schemas->Scan(context, [&](CatalogEntry *entry) { callback(entry); });
-}
-
-SimilarCatalogEntry Catalog::SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
-                                                   const vector<SchemaCatalogEntry *> &schemas) {
-
-	vector<CatalogSet *> sets;
-	std::transform(schemas.begin(), schemas.end(), std::back_inserter(sets),
-	               [type](SchemaCatalogEntry *s) -> CatalogSet * { return &s->GetCatalogSet(type); });
-	pair<string, idx_t> most_similar {"", (idx_t)-1};
-	SchemaCatalogEntry *schema_of_most_similar = nullptr;
-	for (auto schema : schemas) {
-		auto entry = schema->GetCatalogSet(type).SimilarEntry(context, entry_name);
-		if (!entry.first.empty() && (most_similar.first.empty() || most_similar.second > entry.second)) {
-			most_similar = entry;
-			schema_of_most_similar = schema;
-		}
-	}
-
-	return {most_similar.first, most_similar.second, schema_of_most_similar};
-}
-
-CatalogException Catalog::CreateMissingEntryException(ClientContext &context, const string &entry_name,
-                                                      CatalogType type, const vector<SchemaCatalogEntry *> &schemas,
-                                                      QueryErrorContext error_context) {
-	auto entry = SimilarEntryInSchemas(context, entry_name, type, schemas);
-
-	vector<SchemaCatalogEntry *> unseen_schemas;
-	this->schemas->Scan([&schemas, &unseen_schemas](CatalogEntry *entry) {
-		auto schema_entry = (SchemaCatalogEntry *)entry;
-		if (std::find(schemas.begin(), schemas.end(), schema_entry) == schemas.end()) {
-			unseen_schemas.emplace_back(schema_entry);
-		}
-	});
-	auto unseen_entry = SimilarEntryInSchemas(context, entry_name, type, unseen_schemas);
-
-	string did_you_mean;
-	if (unseen_entry.Found() && unseen_entry.distance < entry.distance) {
-		did_you_mean = "\nDid you mean \"" + unseen_entry.GetQualifiedName() + "\"?";
-	} else if (entry.Found()) {
-		did_you_mean = "\nDid you mean \"" + entry.name + "\"?";
-	}
-
-	return CatalogException(error_context.FormatError("%s with name %s does not exist!%s", CatalogTypeToString(type),
-	                                                  entry_name, did_you_mean));
-}
-
-CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type, const string &schema_name,
-                                        const string &name, bool if_exists, QueryErrorContext error_context) {
-	if (!schema_name.empty()) {
-		auto schema = GetSchema(context, schema_name, if_exists, error_context);
-		if (!schema) {
-			D_ASSERT(if_exists);
-			return {nullptr, nullptr};
-		}
-
-		auto entry = schema->GetCatalogSet(type).GetEntry(context, name);
-		if (!entry && !if_exists) {
-			throw CreateMissingEntryException(context, name, type, {schema}, error_context);
-		}
-
-		return {schema, entry};
-	}
-
-	const auto &paths = ClientData::Get(context).catalog_search_path->Get();
-	for (const auto &path : paths) {
-		auto lookup = LookupEntry(context, type, path, name, true, error_context);
-		if (lookup.Found()) {
-			return lookup;
-		}
-	}
-
-	if (!if_exists) {
-		vector<SchemaCatalogEntry *> schemas;
-		for (const auto &path : paths) {
-			auto schema = GetSchema(context, path, true);
-			if (schema) {
-				schemas.emplace_back(schema);
-			}
-		}
-
-		throw CreateMissingEntryException(context, name, type, schemas, error_context);
-	}
-
-	return {nullptr, nullptr};
-}
-
-CatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema, const string &name) {
-	vector<CatalogType> entry_types {CatalogType::TABLE_ENTRY, CatalogType::SEQUENCE_ENTRY};
-
-	for (auto entry_type : entry_types) {
-		CatalogEntry *result = GetEntry(context, entry_type, schema, name, true);
-		if (result != nullptr) {
-			return result;
-		}
-	}
-
-	throw CatalogException("CatalogElement \"%s.%s\" does not exist!", schema, name);
-}
-
-CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema_name, const string &name,
-                                bool if_exists, QueryErrorContext error_context) {
-	return LookupEntry(context, type, schema_name, name, if_exists, error_context).entry;
-}
-
-template <>
-TableCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                     bool if_exists, QueryErrorContext error_context) {
-	auto entry = GetEntry(context, CatalogType::TABLE_ENTRY, schema_name, name, if_exists);
-	if (!entry) {
-		return nullptr;
-	}
-	if (entry->type != CatalogType::TABLE_ENTRY) {
-		throw CatalogException(error_context.FormatError("%s is not a table", name));
-	}
-	return (TableCatalogEntry *)entry;
-}
-
-template <>
-SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                        bool if_exists, QueryErrorContext error_context) {
-	return (SequenceCatalogEntry *)GetEntry(context, CatalogType::SEQUENCE_ENTRY, schema_name, name, if_exists,
-	                                        error_context);
-}
-
-template <>
-TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                             bool if_exists, QueryErrorContext error_context) {
-	return (TableFunctionCatalogEntry *)GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, schema_name, name,
-	                                             if_exists, error_context);
-}
-
-template <>
-CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                            bool if_exists, QueryErrorContext error_context) {
-	return (CopyFunctionCatalogEntry *)GetEntry(context, CatalogType::COPY_FUNCTION_ENTRY, schema_name, name, if_exists,
-	                                            error_context);
-}
-
-template <>
-PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                              bool if_exists, QueryErrorContext error_context) {
-	return (PragmaFunctionCatalogEntry *)GetEntry(context, CatalogType::PRAGMA_FUNCTION_ENTRY, schema_name, name,
-	                                              if_exists, error_context);
-}
-
-template <>
-AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                                 bool if_exists, QueryErrorContext error_context) {
-	auto entry = GetEntry(context, CatalogType::AGGREGATE_FUNCTION_ENTRY, schema_name, name, if_exists, error_context);
-	if (entry->type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
-		throw CatalogException(error_context.FormatError("%s is not an aggregate function", name));
-	}
-	return (AggregateFunctionCatalogEntry *)entry;
-}
-
-template <>
-CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                       bool if_exists, QueryErrorContext error_context) {
-	return (CollateCatalogEntry *)GetEntry(context, CatalogType::COLLATION_ENTRY, schema_name, name, if_exists,
-	                                       error_context);
-}
-
-template <>
-TypeCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                    bool if_exists, QueryErrorContext error_context) {
-	return (TypeCatalogEntry *)GetEntry(context, CatalogType::TYPE_ENTRY, schema_name, name, if_exists, error_context);
-}
-
-LogicalType Catalog::GetType(ClientContext &context, const string &schema, const string &name) {
-	auto user_type_catalog = GetEntry<TypeCatalogEntry>(context, schema, name);
-	auto result_type = user_type_catalog->user_type;
-	LogicalType::SetCatalog(result_type, user_type_catalog);
-	return result_type;
-}
-
-void Catalog::Alter(ClientContext &context, AlterInfo *info) {
-	ModifyCatalog();
-	auto lookup = LookupEntry(context, info->GetCatalogType(), info->schema, info->name);
-	D_ASSERT(lookup.Found()); // It must have thrown otherwise.
-	return lookup.schema->Alter(context, info);
-}
-
-idx_t Catalog::GetCatalogVersion() {
-	return catalog_version;
-}
-
-idx_t Catalog::ModifyCatalog() {
-	return catalog_version++;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-ColumnDependencyManager::ColumnDependencyManager() {
-}
-
-ColumnDependencyManager::~ColumnDependencyManager() {
-}
-
-void ColumnDependencyManager::AddGeneratedColumn(const ColumnDefinition &column,
-                                                 const case_insensitive_map_t<column_t> &name_map) {
-	D_ASSERT(column.Generated());
-	vector<string> referenced_columns;
-	column.GetListOfDependencies(referenced_columns);
-	vector<column_t> indices;
-	for (auto &col : referenced_columns) {
-		auto entry = name_map.find(col);
-		if (entry == name_map.end()) {
-			throw InvalidInputException("Referenced column \"%s\" was not found in the table", col);
-		}
-		indices.push_back(entry->second);
-	}
-	return AddGeneratedColumn(column.Oid(), indices);
-}
-
-void ColumnDependencyManager::AddGeneratedColumn(column_t index, const vector<column_t> &indices, bool root) {
-	if (indices.empty()) {
-		return;
-	}
-	auto &list = dependents_map[index];
-	// Create a link between the dependencies
-	for (auto &dep : indices) {
-		// Add this column as a dependency of the new column
-		list.insert(dep);
-		// Add the new column as a dependent of the column
-		dependencies_map[dep].insert(index);
-		// Inherit the dependencies
-		if (HasDependencies(dep)) {
-			auto &inherited_deps = dependents_map[dep];
-			D_ASSERT(!inherited_deps.empty());
-			for (auto &inherited_dep : inherited_deps) {
-				list.insert(inherited_dep);
-				dependencies_map[inherited_dep].insert(index);
-			}
-		}
-		if (!root) {
-			continue;
-		}
-		direct_dependencies[index].insert(dep);
-	}
-	if (!HasDependents(index)) {
-		return;
-	}
-	auto &dependents = dependencies_map[index];
-	if (dependents.count(index)) {
-		throw InvalidInputException("Circular dependency encountered when resolving generated column expressions");
-	}
-	// Also let the dependents of this generated column inherit the dependencies
-	for (auto &dependent : dependents) {
-		AddGeneratedColumn(dependent, indices, false);
-	}
-}
-
-vector<column_t> ColumnDependencyManager::RemoveColumn(column_t index, column_t column_amount) {
-	// Always add the initial column
-	deleted_columns.insert(index);
-
-	RemoveGeneratedColumn(index);
-	RemoveStandardColumn(index);
-
-	// Clean up the internal list
-	vector<column_t> new_indices = CleanupInternals(column_amount);
-	D_ASSERT(deleted_columns.empty());
-	return new_indices;
-}
-
-bool ColumnDependencyManager::IsDependencyOf(column_t gcol, column_t col) const {
-	auto entry = dependents_map.find(gcol);
-	if (entry == dependents_map.end()) {
-		return false;
-	}
-	auto &list = entry->second;
-	return list.count(col);
-}
-
-bool ColumnDependencyManager::HasDependencies(column_t index) const {
-	auto entry = dependents_map.find(index);
-	if (entry == dependents_map.end()) {
-		return false;
-	}
-	return true;
-}
-
-const unordered_set<column_t> &ColumnDependencyManager::GetDependencies(column_t index) const {
-	auto entry = dependents_map.find(index);
-	D_ASSERT(entry != dependents_map.end());
-	return entry->second;
-}
-
-bool ColumnDependencyManager::HasDependents(column_t index) const {
-	auto entry = dependencies_map.find(index);
-	if (entry == dependencies_map.end()) {
-		return false;
-	}
-	return true;
-}
-
-const unordered_set<column_t> &ColumnDependencyManager::GetDependents(column_t index) const {
-	auto entry = dependencies_map.find(index);
-	D_ASSERT(entry != dependencies_map.end());
-	return entry->second;
-}
-
-void ColumnDependencyManager::RemoveStandardColumn(column_t index) {
-	if (!HasDependents(index)) {
-		return;
-	}
-	auto dependents = dependencies_map[index];
-	for (auto &gcol : dependents) {
-		// If index is a direct dependency of gcol, remove it from the list
-		if (direct_dependencies.find(gcol) != direct_dependencies.end()) {
-			direct_dependencies[gcol].erase(index);
-		}
-		RemoveGeneratedColumn(gcol);
-	}
-	// Remove this column from the dependencies map
-	dependencies_map.erase(index);
-}
-
-void ColumnDependencyManager::RemoveGeneratedColumn(column_t index) {
-	deleted_columns.insert(index);
-	if (!HasDependencies(index)) {
-		return;
-	}
-	auto &dependencies = dependents_map[index];
-	for (auto &col : dependencies) {
-		// Remove this generated column from the list of this column
-		auto &col_dependents = dependencies_map[col];
-		D_ASSERT(col_dependents.count(index));
-		col_dependents.erase(index);
-		// If the resulting list is empty, remove the column from the dependencies map altogether
-		if (col_dependents.empty()) {
-			dependencies_map.erase(col);
-		}
-	}
-	// Remove this column from the dependents_map map
-	dependents_map.erase(index);
-}
-
-void ColumnDependencyManager::AdjustSingle(column_t idx, idx_t offset) {
-	D_ASSERT(idx >= offset);
-	column_t new_idx = idx - offset;
-	// Adjust this index in the dependents of this column
-	bool has_dependents = HasDependents(idx);
-	bool has_dependencies = HasDependencies(idx);
-
-	if (has_dependents) {
-		auto &dependents = GetDependents(idx);
-		for (auto &dep : dependents) {
-			auto &dep_dependencies = dependents_map[dep];
-			dep_dependencies.erase(idx);
-			D_ASSERT(!dep_dependencies.count(new_idx));
-			dep_dependencies.insert(new_idx);
-		}
-	}
-	if (has_dependencies) {
-		auto &dependencies = GetDependencies(idx);
-		for (auto &dep : dependencies) {
-			auto &dep_dependents = dependencies_map[dep];
-			dep_dependents.erase(idx);
-			D_ASSERT(!dep_dependents.count(new_idx));
-			dep_dependents.insert(new_idx);
-		}
-	}
-	if (has_dependents) {
-		D_ASSERT(!dependencies_map.count(new_idx));
-		dependencies_map[new_idx] = move(dependencies_map[idx]);
-		dependencies_map.erase(idx);
-	}
-	if (has_dependencies) {
-		D_ASSERT(!dependents_map.count(new_idx));
-		dependents_map[new_idx] = move(dependents_map[idx]);
-		dependents_map.erase(idx);
-	}
-}
-
-vector<column_t> ColumnDependencyManager::CleanupInternals(column_t column_amount) {
-	vector<column_t> to_adjust;
-	D_ASSERT(!deleted_columns.empty());
-	// Get the lowest index that was deleted
-	vector<column_t> new_indices(column_amount, DConstants::INVALID_INDEX);
-	column_t threshold = *deleted_columns.begin();
-
-	idx_t offset = 0;
-	for (column_t i = 0; i < column_amount; i++) {
-		new_indices[i] = i - offset;
-		if (deleted_columns.count(i)) {
-			offset++;
-			continue;
-		}
-		if (i > threshold && (HasDependencies(i) || HasDependents(i))) {
-			to_adjust.push_back(i);
-		}
-	}
-
-	// Adjust all indices inside the dependency managers internal mappings
-	for (auto &col : to_adjust) {
-		offset = col - new_indices[col];
-		AdjustSingle(col, offset);
-	}
-	deleted_columns.clear();
-	return new_indices;
-}
-
-stack<column_t> ColumnDependencyManager::GetBindOrder(const vector<ColumnDefinition> &columns) {
-	stack<column_t> bind_order;
-	queue<column_t> to_visit;
-	unordered_set<column_t> visited;
-
-	for (auto &entry : direct_dependencies) {
-		auto dependent = entry.first;
-		//! Skip the dependents that are also dependencies
-		if (dependencies_map.find(dependent) != dependencies_map.end()) {
-			continue;
-		}
-		bind_order.push(dependent);
-		visited.insert(dependent);
-		for (auto &dependency : direct_dependencies[dependent]) {
-			to_visit.push(dependency);
-		}
-	}
-
-	while (!to_visit.empty()) {
-		auto column = to_visit.front();
-		to_visit.pop();
-
-		//! If this column does not have dependencies, the queue stops getting filled
-		if (direct_dependencies.find(column) == direct_dependencies.end()) {
-			continue;
-		}
-		bind_order.push(column);
-		visited.insert(column);
-
-		for (auto &dependency : direct_dependencies[column]) {
-			to_visit.push(dependency);
-		}
-	}
-
-	// Add generated columns that have no dependencies, but still might need to have their type resolved
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto &col = columns[i];
-		// Not a generated column
-		if (!col.Generated()) {
-			continue;
-		}
-		// Already added to the bind_order stack
-		if (visited.count(i)) {
-			continue;
-		}
-		bind_order.push(i);
-	}
-
-	return bind_order;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-CopyFunctionCatalogEntry::CopyFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
-                                                   CreateCopyFunctionInfo *info)
-    : StandardEntry(CatalogType::COPY_FUNCTION_ENTRY, schema, catalog, info->name), function(info->function) {
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-IndexCatalogEntry::IndexCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info)
-    : StandardEntry(CatalogType::INDEX_ENTRY, schema, catalog, info->index_name), index(nullptr), sql(info->sql) {
-}
-
-IndexCatalogEntry::~IndexCatalogEntry() {
-	// remove the associated index from the info
-	if (!info || !index) {
-		return;
-	}
-	info->indexes.RemoveIndex(index);
-}
-
-string IndexCatalogEntry::ToSQL() {
-	if (sql.empty()) {
-		throw InternalException("Cannot convert INDEX to SQL because it was not created with a SQL statement");
-	}
-	if (sql[sql.size() - 1] != ';') {
-		sql += ";";
-	}
-	return sql;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-PragmaFunctionCatalogEntry::PragmaFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
-                                                       CreatePragmaFunctionInfo *info)
-    : StandardEntry(CatalogType::PRAGMA_FUNCTION_ENTRY, schema, catalog, info->name), functions(move(info->functions)) {
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-MacroCatalogEntry::MacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info)
-    : StandardEntry(
-          (info->function->type == MacroType::SCALAR_MACRO ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY),
-          schema, catalog, info->name),
-      function(move(info->function)) {
-	this->temporary = info->temporary;
-	this->internal = info->internal;
-}
-
-ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info)
-    : MacroCatalogEntry(catalog, schema, info) {
-}
-
-void ScalarMacroCatalogEntry::Serialize(Serializer &main_serializer) {
-	D_ASSERT(!internal);
-	auto &scalar_function = (ScalarMacroFunction &)*function;
-	FieldWriter writer(main_serializer);
-	writer.WriteString(schema->name);
-	writer.WriteString(name);
-	writer.WriteSerializable(*scalar_function.expression);
-	// writer.WriteSerializableList(function->parameters);
-	writer.WriteSerializableList(function->parameters);
-	writer.WriteField<uint32_t>((uint32_t)function->default_parameters.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &kv : function->default_parameters) {
-		serializer.WriteString(kv.first);
-		kv.second->Serialize(serializer);
-	}
-	writer.Finalize();
-}
-
-unique_ptr<CreateMacroInfo> ScalarMacroCatalogEntry::Deserialize(Deserializer &main_source) {
-	auto info = make_unique<CreateMacroInfo>(CatalogType::MACRO_ENTRY);
-	FieldReader reader(main_source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto func = make_unique<ScalarMacroFunction>(move(expression));
-	info->function = move(func);
-	info->function->parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
-	auto default_param_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < default_param_count; i++) {
-		auto name = source.Read<string>();
-		info->function->default_parameters[name] = ParsedExpression::Deserialize(source);
-	}
-	// dont like this
-	// info->type=CatalogType::MACRO_ENTRY;
-	reader.Finalize();
-	return info;
-}
-
-TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info)
-    : MacroCatalogEntry(catalog, schema, info) {
-}
-
-void TableMacroCatalogEntry::Serialize(Serializer &main_serializer) {
-	D_ASSERT(!internal);
-	FieldWriter writer(main_serializer);
-
-	auto &table_function = (TableMacroFunction &)*function;
-	writer.WriteString(schema->name);
-	writer.WriteString(name);
-	writer.WriteSerializable(*table_function.query_node);
-	writer.WriteSerializableList(function->parameters);
-	writer.WriteField<uint32_t>((uint32_t)function->default_parameters.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &kv : function->default_parameters) {
-		serializer.WriteString(kv.first);
-		kv.second->Serialize(serializer);
-	}
-	writer.Finalize();
-}
-
-unique_ptr<CreateMacroInfo> TableMacroCatalogEntry::Deserialize(Deserializer &main_source) {
-	auto info = make_unique<CreateMacroInfo>(CatalogType::TABLE_MACRO_ENTRY);
-	FieldReader reader(main_source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	auto query_node = reader.ReadRequiredSerializable<QueryNode>();
-	auto table_function = make_unique<TableMacroFunction>(move(query_node));
-	info->function = move(table_function);
-	info->function->parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
-	auto default_param_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < default_param_count; i++) {
-		auto name = source.Read<string>();
-		info->function->default_parameters[name] = ParsedExpression::Deserialize(source);
-	}
-
-	reader.Finalize();
-
-	return info;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <sstream>
-
-namespace duckdb {
-
-void FindForeignKeyInformation(CatalogEntry *entry, AlterForeignKeyType alter_fk_type,
-                               vector<unique_ptr<AlterForeignKeyInfo>> &fk_arrays) {
-	if (entry->type != CatalogType::TABLE_ENTRY) {
-		return;
-	}
-	auto *table_entry = (TableCatalogEntry *)entry;
-	for (idx_t i = 0; i < table_entry->constraints.size(); i++) {
-		auto &cond = table_entry->constraints[i];
-		if (cond->type != ConstraintType::FOREIGN_KEY) {
-			continue;
-		}
-		auto &fk = (ForeignKeyConstraint &)*cond;
-		if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-			fk_arrays.push_back(make_unique<AlterForeignKeyInfo>(fk.info.schema, fk.info.table, entry->name,
-			                                                     fk.pk_columns, fk.fk_columns, fk.info.pk_keys,
-			                                                     fk.info.fk_keys, alter_fk_type));
-		} else if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE &&
-		           alter_fk_type == AlterForeignKeyType::AFT_DELETE) {
-			throw CatalogException("Could not drop the table because this table is main key table of the table \"%s\"",
-			                       fk.info.table);
-		}
-	}
-}
-
-SchemaCatalogEntry::SchemaCatalogEntry(Catalog *catalog, string name_p, bool internal)
-    : CatalogEntry(CatalogType::SCHEMA_ENTRY, catalog, move(name_p)),
-      tables(*catalog, make_unique<DefaultViewGenerator>(*catalog, this)), indexes(*catalog), table_functions(*catalog),
-      copy_functions(*catalog), pragma_functions(*catalog),
-      functions(*catalog, make_unique<DefaultFunctionGenerator>(*catalog, this)), sequences(*catalog),
-      collations(*catalog), types(*catalog, make_unique<DefaultTypeGenerator>(*catalog, this)) {
-	this->internal = internal;
-}
-
-CatalogEntry *SchemaCatalogEntry::AddEntry(ClientContext &context, unique_ptr<StandardEntry> entry,
-                                           OnCreateConflict on_conflict, unordered_set<CatalogEntry *> dependencies) {
-	auto entry_name = entry->name;
-	auto entry_type = entry->type;
-	auto result = entry.get();
-
-	// first find the set for this entry
-	auto &set = GetCatalogSet(entry_type);
-
-	if (name != TEMP_SCHEMA) {
-		dependencies.insert(this);
-	} else {
-		entry->temporary = true;
-	}
-	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
-		// CREATE OR REPLACE: first try to drop the entry
-		auto old_entry = set.GetEntry(context, entry_name);
-		if (old_entry) {
-			if (old_entry->type != entry_type) {
-				throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", entry_name,
-				                       CatalogTypeToString(old_entry->type), CatalogTypeToString(entry_type));
-			}
-			(void)set.DropEntry(context, entry_name, false);
-		}
-	}
-	// now try to add the entry
-	if (!set.CreateEntry(context, entry_name, move(entry), dependencies)) {
-		// entry already exists!
-		if (on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
-			throw CatalogException("%s with name \"%s\" already exists!", CatalogTypeToString(entry_type), entry_name);
-		} else {
-			return nullptr;
-		}
-	}
-	return result;
-}
-
-CatalogEntry *SchemaCatalogEntry::AddEntry(ClientContext &context, unique_ptr<StandardEntry> entry,
-                                           OnCreateConflict on_conflict) {
-	unordered_set<CatalogEntry *> dependencies;
-	return AddEntry(context, move(entry), on_conflict, dependencies);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateSequence(ClientContext &context, CreateSequenceInfo *info) {
-	auto sequence = make_unique<SequenceCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(sequence), info->on_conflict);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateType(ClientContext &context, CreateTypeInfo *info) {
-	auto type_entry = make_unique<TypeCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(type_entry), info->on_conflict);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateTable(ClientContext &context, BoundCreateTableInfo *info) {
-	auto table = make_unique<TableCatalogEntry>(catalog, this, info);
-	table->storage->info->cardinality = table->storage->GetTotalRows();
-
-	CatalogEntry *entry = AddEntry(context, move(table), info->Base().on_conflict, info->dependencies);
-	if (!entry) {
-		return nullptr;
-	}
-
-	// add a foreign key constraint in main key table if there is a foreign key constraint
-	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
-	FindForeignKeyInformation(entry, AlterForeignKeyType::AFT_ADD, fk_arrays);
-	for (idx_t i = 0; i < fk_arrays.size(); i++) {
-		// alter primary key table
-		AlterForeignKeyInfo *fk_info = fk_arrays[i].get();
-		catalog->Alter(context, fk_info);
-
-		// make a dependency between this table and referenced table
-		auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
-		info->dependencies.insert(set.GetEntry(context, fk_info->name));
-	}
-	return entry;
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateView(ClientContext &context, CreateViewInfo *info) {
-	auto view = make_unique<ViewCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(view), info->on_conflict);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) {
-	unordered_set<CatalogEntry *> dependencies;
-	dependencies.insert(table);
-	auto index = make_unique<IndexCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(index), info->on_conflict, dependencies);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateCollation(ClientContext &context, CreateCollationInfo *info) {
-	auto collation = make_unique<CollateCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(collation), info->on_conflict);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info) {
-	auto table_function = make_unique<TableFunctionCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(table_function), info->on_conflict);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info) {
-	auto copy_function = make_unique<CopyFunctionCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(copy_function), info->on_conflict);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info) {
-	auto pragma_function = make_unique<PragmaFunctionCatalogEntry>(catalog, this, info);
-	return AddEntry(context, move(pragma_function), info->on_conflict);
-}
-
-CatalogEntry *SchemaCatalogEntry::CreateFunction(ClientContext &context, CreateFunctionInfo *info) {
-	unique_ptr<StandardEntry> function;
-	switch (info->type) {
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-		function = make_unique_base<StandardEntry, ScalarFunctionCatalogEntry>(catalog, this,
-		                                                                       (CreateScalarFunctionInfo *)info);
-		break;
-	case CatalogType::MACRO_ENTRY:
-		// create a macro function
-		function = make_unique_base<StandardEntry, ScalarMacroCatalogEntry>(catalog, this, (CreateMacroInfo *)info);
-		break;
-
-	case CatalogType::TABLE_MACRO_ENTRY:
-		// create a macro function
-		function = make_unique_base<StandardEntry, TableMacroCatalogEntry>(catalog, this, (CreateMacroInfo *)info);
-		break;
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-		D_ASSERT(info->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
-		// create an aggregate function
-		function = make_unique_base<StandardEntry, AggregateFunctionCatalogEntry>(catalog, this,
-		                                                                          (CreateAggregateFunctionInfo *)info);
-		break;
-	default:
-		throw InternalException("Unknown function type \"%s\"", CatalogTypeToString(info->type));
-	}
-	return AddEntry(context, move(function), info->on_conflict);
-}
-
-CatalogEntry *SchemaCatalogEntry::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
-	auto entry = GetCatalogSet(info->type).GetEntry(context, info->name);
-	if (!entry) {
-		return CreateFunction(context, info);
-	}
-
-	info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
-	switch (info->type) {
-	case CatalogType::SCALAR_FUNCTION_ENTRY: {
-		auto scalar_info = (CreateScalarFunctionInfo *)info;
-		auto &scalars = *(ScalarFunctionCatalogEntry *)entry;
-		for (const auto &scalar : scalars.functions) {
-			scalar_info->functions.emplace_back(scalar);
-		}
-		break;
-	}
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY: {
-		auto agg_info = (CreateAggregateFunctionInfo *)info;
-		auto &aggs = *(AggregateFunctionCatalogEntry *)entry;
-		for (const auto &agg : aggs.functions) {
-			agg_info->functions.AddFunction(agg);
-		}
-		break;
-	}
-	default:
-		// Macros can only be replaced because there is only one of each name.
-		throw InternalException("Unsupported function type \"%s\" for adding", CatalogTypeToString(info->type));
-	}
-	return CreateFunction(context, info);
-}
-
-void SchemaCatalogEntry::DropEntry(ClientContext &context, DropInfo *info) {
-	auto &set = GetCatalogSet(info->type);
-
-	// first find the entry
-	auto existing_entry = set.GetEntry(context, info->name);
-	if (!existing_entry) {
-		if (!info->if_exists) {
-			throw CatalogException("%s with name \"%s\" does not exist!", CatalogTypeToString(info->type), info->name);
-		}
-		return;
-	}
-	if (existing_entry->type != info->type) {
-		throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", info->name,
-		                       CatalogTypeToString(existing_entry->type), CatalogTypeToString(info->type));
-	}
-
-	// if there is a foreign key constraint, get that information
-	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
-	FindForeignKeyInformation(existing_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
-
-	if (!set.DropEntry(context, info->name, info->cascade)) {
-		throw InternalException("Could not drop element because of an internal error");
-	}
-
-	// remove the foreign key constraint in main key table if main key table's name is valid
-	for (idx_t i = 0; i < fk_arrays.size(); i++) {
-		// alter primary key tablee
-		Catalog::GetCatalog(context).Alter(context, fk_arrays[i].get());
-	}
-}
-
-void SchemaCatalogEntry::Alter(ClientContext &context, AlterInfo *info) {
-	CatalogType type = info->GetCatalogType();
-	auto &set = GetCatalogSet(type);
-	if (info->type == AlterType::CHANGE_OWNERSHIP) {
-		if (!set.AlterOwnership(context, (ChangeOwnershipInfo *)info)) {
-			throw CatalogException("Couldn't change ownership!");
-		}
-	} else {
-		string name = info->name;
-		if (!set.AlterEntry(context, name, info)) {
-			throw CatalogException("Entry with name \"%s\" does not exist!", name);
-		}
-	}
-}
-
-void SchemaCatalogEntry::Scan(ClientContext &context, CatalogType type,
-                              const std::function<void(CatalogEntry *)> &callback) {
-	auto &set = GetCatalogSet(type);
-	set.Scan(context, callback);
-}
-
-void SchemaCatalogEntry::Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback) {
-	auto &set = GetCatalogSet(type);
-	set.Scan(callback);
-}
-
-void SchemaCatalogEntry::Serialize(Serializer &serializer) {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSchemaInfo> SchemaCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateSchemaInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	reader.Finalize();
-
-	return info;
-}
-
-string SchemaCatalogEntry::ToSQL() {
-	std::stringstream ss;
-	ss << "CREATE SCHEMA " << name << ";";
-	return ss.str();
-}
-
-CatalogSet &SchemaCatalogEntry::GetCatalogSet(CatalogType type) {
-	switch (type) {
-	case CatalogType::VIEW_ENTRY:
-	case CatalogType::TABLE_ENTRY:
-		return tables;
-	case CatalogType::INDEX_ENTRY:
-		return indexes;
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-		return table_functions;
-	case CatalogType::COPY_FUNCTION_ENTRY:
-		return copy_functions;
-	case CatalogType::PRAGMA_FUNCTION_ENTRY:
-		return pragma_functions;
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-	case CatalogType::MACRO_ENTRY:
-		return functions;
-	case CatalogType::SEQUENCE_ENTRY:
-		return sequences;
-	case CatalogType::COLLATION_ENTRY:
-		return collations;
-	case CatalogType::TYPE_ENTRY:
-		return types;
-	default:
-		throw InternalException("Unsupported catalog type in schema");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-#include <algorithm>
-#include <sstream>
-
-namespace duckdb {
-
-SequenceCatalogEntry::SequenceCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateSequenceInfo *info)
-    : StandardEntry(CatalogType::SEQUENCE_ENTRY, schema, catalog, info->name), usage_count(info->usage_count),
-      counter(info->start_value), increment(info->increment), start_value(info->start_value),
-      min_value(info->min_value), max_value(info->max_value), cycle(info->cycle) {
-	this->temporary = info->temporary;
-}
-
-void SequenceCatalogEntry::Serialize(Serializer &serializer) {
-	FieldWriter writer(serializer);
-	writer.WriteString(schema->name);
-	writer.WriteString(name);
-	writer.WriteField<uint64_t>(usage_count);
-	writer.WriteField<int64_t>(increment);
-	writer.WriteField<int64_t>(min_value);
-	writer.WriteField<int64_t>(max_value);
-	writer.WriteField<int64_t>(counter);
-	writer.WriteField<bool>(cycle);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSequenceInfo> SequenceCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateSequenceInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	info->usage_count = reader.ReadRequired<uint64_t>();
-	info->increment = reader.ReadRequired<int64_t>();
-	info->min_value = reader.ReadRequired<int64_t>();
-	info->max_value = reader.ReadRequired<int64_t>();
-	info->start_value = reader.ReadRequired<int64_t>();
-	info->cycle = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	return info;
-}
-
-string SequenceCatalogEntry::ToSQL() {
-	std::stringstream ss;
-	ss << "CREATE SEQUENCE ";
-	ss << name;
-	ss << " INCREMENT BY " << increment;
-	ss << " MINVALUE " << min_value;
-	ss << " MAXVALUE " << max_value;
-	ss << " START " << counter;
-	ss << " " << (cycle ? "CYCLE" : "NO CYCLE") << ";";
-	return ss.str();
-}
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <sstream>
-
-namespace duckdb {
-
-const string &TableCatalogEntry::GetColumnName(column_t index) {
-	return columns[index].Name();
-}
-
-column_t TableCatalogEntry::GetColumnIndex(string &column_name, bool if_exists) {
-	auto entry = name_map.find(column_name);
-	if (entry == name_map.end()) {
-		// entry not found: try lower-casing the name
-		entry = name_map.find(StringUtil::Lower(column_name));
-		if (entry == name_map.end()) {
-			if (if_exists) {
-				return DConstants::INVALID_INDEX;
-			}
-			throw BinderException("Table \"%s\" does not have a column with name \"%s\"", name, column_name);
-		}
-	}
-	column_name = GetColumnName(entry->second);
-	return entry->second;
-}
-
-void AddDataTableIndex(DataTable *storage, vector<ColumnDefinition> &columns, vector<idx_t> &keys,
-                       IndexConstraintType constraint_type) {
-	// fetch types and create expressions for the index from the columns
-	vector<column_t> column_ids;
-	vector<unique_ptr<Expression>> unbound_expressions;
-	vector<unique_ptr<Expression>> bound_expressions;
-	idx_t key_nr = 0;
-	for (auto &key : keys) {
-		D_ASSERT(key < columns.size());
-		auto &column = columns[key];
-		if (column.Generated()) {
-			throw InvalidInputException("Creating index on generated column is not supported");
-		}
-
-		unbound_expressions.push_back(make_unique<BoundColumnRefExpression>(columns[key].Name(), columns[key].Type(),
-		                                                                    ColumnBinding(0, column_ids.size())));
-
-		bound_expressions.push_back(make_unique<BoundReferenceExpression>(columns[key].Type(), key_nr++));
-		column_ids.push_back(column.StorageOid());
-	}
-	// create an adaptive radix tree around the expressions
-	auto art = make_unique<ART>(column_ids, move(unbound_expressions), constraint_type);
-	storage->AddIndex(move(art), bound_expressions);
-}
-
-TableCatalogEntry::TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
-                                     std::shared_ptr<DataTable> inherited_storage)
-    : StandardEntry(CatalogType::TABLE_ENTRY, schema, catalog, info->Base().table), storage(move(inherited_storage)),
-      columns(move(info->Base().columns)), constraints(move(info->Base().constraints)),
-      bound_constraints(move(info->bound_constraints)),
-      column_dependency_manager(move(info->column_dependency_manager)) {
-	this->temporary = info->Base().temporary;
-	// add lower case aliases
-	this->name_map = move(info->name_map);
-#ifdef DEBUG
-	D_ASSERT(name_map.size() == columns.size());
-	for (idx_t i = 0; i < columns.size(); i++) {
-		D_ASSERT(name_map[columns[i].Name()] == i);
-	}
-#endif
-	// add the "rowid" alias, if there is no rowid column specified in the table
-	if (name_map.find("rowid") == name_map.end()) {
-		name_map["rowid"] = COLUMN_IDENTIFIER_ROW_ID;
-	}
-	if (!storage) {
-		// create the physical storage
-		vector<ColumnDefinition> storage_columns;
-		vector<ColumnDefinition> get_columns;
-		for (auto &col_def : columns) {
-			get_columns.push_back(col_def.Copy());
-			if (col_def.Generated()) {
-				continue;
-			}
-			storage_columns.push_back(col_def.Copy());
-		}
-		storage = make_shared<DataTable>(catalog->db, schema->name, name, move(storage_columns), move(info->data));
-
-		// create the unique indexes for the UNIQUE and PRIMARY KEY and FOREIGN KEY constraints
-		for (idx_t i = 0; i < bound_constraints.size(); i++) {
-			auto &constraint = bound_constraints[i];
-			if (constraint->type == ConstraintType::UNIQUE) {
-				// unique constraint: create a unique index
-				auto &unique = (BoundUniqueConstraint &)*constraint;
-				IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
-				if (unique.is_primary_key) {
-					constraint_type = IndexConstraintType::PRIMARY;
-				}
-				AddDataTableIndex(storage.get(), get_columns, unique.keys, constraint_type);
-			} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
-				// foreign key constraint: create a foreign key index
-				auto &bfk = (BoundForeignKeyConstraint &)*constraint;
-				if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
-				    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-					AddDataTableIndex(storage.get(), get_columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
-				}
-			}
-		}
-	}
-}
-
-bool TableCatalogEntry::ColumnExists(const string &name) {
-	auto iterator = name_map.find(name);
-	if (iterator == name_map.end()) {
-		return false;
-	}
-	return true;
-}
-
-idx_t TableCatalogEntry::StandardColumnCount() const {
-	idx_t count = 0;
-	for (auto &col : columns) {
-		if (col.Category() == TableColumnType::STANDARD) {
-			count++;
-		}
-	}
-	return count;
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
-	D_ASSERT(!internal);
-	if (info->type != AlterType::ALTER_TABLE) {
-		throw CatalogException("Can only modify table with ALTER TABLE statement");
-	}
-	auto table_info = (AlterTableInfo *)info;
-	switch (table_info->alter_table_type) {
-	case AlterTableType::RENAME_COLUMN: {
-		auto rename_info = (RenameColumnInfo *)table_info;
-		return RenameColumn(context, *rename_info);
-	}
-	case AlterTableType::RENAME_TABLE: {
-		auto rename_info = (RenameTableInfo *)table_info;
-		auto copied_table = Copy(context);
-		copied_table->name = rename_info->new_table_name;
-		return copied_table;
-	}
-	case AlterTableType::ADD_COLUMN: {
-		auto add_info = (AddColumnInfo *)table_info;
-		return AddColumn(context, *add_info);
-	}
-	case AlterTableType::REMOVE_COLUMN: {
-		auto remove_info = (RemoveColumnInfo *)table_info;
-		return RemoveColumn(context, *remove_info);
-	}
-	case AlterTableType::SET_DEFAULT: {
-		auto set_default_info = (SetDefaultInfo *)table_info;
-		return SetDefault(context, *set_default_info);
-	}
-	case AlterTableType::ALTER_COLUMN_TYPE: {
-		auto change_type_info = (ChangeColumnTypeInfo *)table_info;
-		return ChangeColumnType(context, *change_type_info);
-	}
-	case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
-		auto foreign_key_constraint_info = (AlterForeignKeyInfo *)table_info;
-		return SetForeignKeyConstraint(context, *foreign_key_constraint_info);
-	}
-	default:
-		throw InternalException("Unrecognized alter table type!");
-	}
-}
-
-static void RenameExpression(ParsedExpression &expr, RenameColumnInfo &info) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
-		if (colref.column_names.back() == info.old_name) {
-			colref.column_names.back() = info.new_name;
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { RenameExpression((ParsedExpression &)child, info); });
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::RenameColumn(ClientContext &context, RenameColumnInfo &info) {
-	auto rename_idx = GetColumnIndex(info.old_name);
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
-	create_info->temporary = temporary;
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto copy = columns[i].Copy();
-
-		if (rename_idx == i) {
-			copy.SetName(info.new_name);
-		}
-		create_info->columns.push_back(move(copy));
-		auto &col = create_info->columns[i];
-		if (col.Generated() && column_dependency_manager.IsDependencyOf(i, rename_idx)) {
-			RenameExpression(col.GeneratedExpressionMutable(), info);
-		}
-	}
-	for (idx_t c_idx = 0; c_idx < constraints.size(); c_idx++) {
-		auto copy = constraints[c_idx]->Copy();
-		switch (copy->type) {
-		case ConstraintType::NOT_NULL:
-			// NOT NULL constraint: no adjustments necessary
-			break;
-		case ConstraintType::CHECK: {
-			// CHECK constraint: need to rename column references that refer to the renamed column
-			auto &check = (CheckConstraint &)*copy;
-			RenameExpression(*check.expression, info);
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			// UNIQUE constraint: possibly need to rename columns
-			auto &unique = (UniqueConstraint &)*copy;
-			for (idx_t i = 0; i < unique.columns.size(); i++) {
-				if (unique.columns[i] == info.old_name) {
-					unique.columns[i] = info.new_name;
-				}
-			}
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			// FOREIGN KEY constraint: possibly need to rename columns
-			auto &fk = (ForeignKeyConstraint &)*copy;
-			vector<string> columns = fk.pk_columns;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				columns = fk.fk_columns;
-			} else if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < fk.fk_columns.size(); i++) {
-					columns.push_back(fk.fk_columns[i]);
-				}
-			}
-			for (idx_t i = 0; i < columns.size(); i++) {
-				if (columns[i] == info.old_name) {
-					throw CatalogException(
-					    "Cannot rename column \"%s\" because this is involved in the foreign key constraint",
-					    info.old_name);
-				}
-			}
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-		create_info->constraints.push_back(move(copy));
-	}
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::AddColumn(ClientContext &context, AddColumnInfo &info) {
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
-	create_info->temporary = temporary;
-
-	for (idx_t i = 0; i < columns.size(); i++) {
-		create_info->columns.push_back(columns[i].Copy());
-	}
-	for (auto &constraint : constraints) {
-		create_info->constraints.push_back(constraint->Copy());
-	}
-	Binder::BindLogicalType(context, info.new_column.TypeMutable(), schema->name);
-	info.new_column.SetOid(columns.size());
-	info.new_column.SetStorageOid(storage->column_definitions.size());
-
-	auto col = info.new_column.Copy();
-
-	create_info->columns.push_back(move(col));
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	auto new_storage =
-	    make_shared<DataTable>(context, *storage, info.new_column, bound_create_info->bound_defaults.back().get());
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(),
-	                                      new_storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::RemoveColumn(ClientContext &context, RemoveColumnInfo &info) {
-	auto removed_index = GetColumnIndex(info.removed_column, info.if_exists);
-	if (removed_index == DConstants::INVALID_INDEX) {
-		return nullptr;
-	}
-
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
-	create_info->temporary = temporary;
-
-	unordered_set<column_t> removed_columns;
-	if (column_dependency_manager.HasDependents(removed_index)) {
-		removed_columns = column_dependency_manager.GetDependents(removed_index);
-	}
-	if (!removed_columns.empty() && !info.cascade) {
-		throw CatalogException("Cannot drop column: column is a dependency of 1 or more generated column(s)");
-	}
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto &col = columns[i];
-		if (i == removed_index || removed_columns.count(i)) {
-			continue;
-		}
-		create_info->columns.push_back(col.Copy());
-	}
-	if (create_info->columns.empty()) {
-		throw CatalogException("Cannot drop column: table only has one column remaining!");
-	}
-	vector<column_t> adjusted_indices = column_dependency_manager.RemoveColumn(removed_index, columns.size());
-	// handle constraints for the new table
-	D_ASSERT(constraints.size() == bound_constraints.size());
-	for (idx_t constr_idx = 0; constr_idx < constraints.size(); constr_idx++) {
-		auto &constraint = constraints[constr_idx];
-		auto &bound_constraint = bound_constraints[constr_idx];
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &not_null_constraint = (BoundNotNullConstraint &)*bound_constraint;
-			if (not_null_constraint.index != removed_index) {
-				// the constraint is not about this column: we need to copy it
-				// we might need to shift the index back by one though, to account for the removed column
-				idx_t new_index = not_null_constraint.index;
-				new_index = adjusted_indices[new_index];
-				create_info->constraints.push_back(make_unique<NotNullConstraint>(new_index));
-			}
-			break;
-		}
-		case ConstraintType::CHECK: {
-			// CHECK constraint
-			auto &bound_check = (BoundCheckConstraint &)*bound_constraint;
-			// check if the removed column is part of the check constraint
-			if (bound_check.bound_columns.find(removed_index) != bound_check.bound_columns.end()) {
-				if (bound_check.bound_columns.size() > 1) {
-					// CHECK constraint that concerns mult
-					throw CatalogException(
-					    "Cannot drop column \"%s\" because there is a CHECK constraint that depends on it",
-					    info.removed_column);
-				} else {
-					// CHECK constraint that ONLY concerns this column, strip the constraint
-				}
-			} else {
-				// check constraint does not concern the removed column: simply re-add it
-				create_info->constraints.push_back(constraint->Copy());
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			auto copy = constraint->Copy();
-			auto &unique = (UniqueConstraint &)*copy;
-			if (unique.index != DConstants::INVALID_INDEX) {
-				if (unique.index == removed_index) {
-					throw CatalogException(
-					    "Cannot drop column \"%s\" because there is a UNIQUE constraint that depends on it",
-					    info.removed_column);
-				}
-				unique.index = adjusted_indices[unique.index];
-			}
-			create_info->constraints.push_back(move(copy));
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto copy = constraint->Copy();
-			auto &fk = (ForeignKeyConstraint &)*copy;
-			vector<string> columns = fk.pk_columns;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				columns = fk.fk_columns;
-			} else if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < fk.fk_columns.size(); i++) {
-					columns.push_back(fk.fk_columns[i]);
-				}
-			}
-			for (idx_t i = 0; i < columns.size(); i++) {
-				if (columns[i] == info.removed_column) {
-					throw CatalogException(
-					    "Cannot drop column \"%s\" because there is a FOREIGN KEY constraint that depends on it",
-					    info.removed_column);
-				}
-			}
-			create_info->constraints.push_back(move(copy));
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	if (columns[removed_index].Generated()) {
-		return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(),
-		                                      storage);
-	}
-	auto new_storage = make_shared<DataTable>(context, *storage, removed_index);
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(),
-	                                      new_storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::SetDefault(ClientContext &context, SetDefaultInfo &info) {
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
-	auto default_idx = GetColumnIndex(info.column_name);
-
-	// Copy all the columns, changing the value of the one that was specified by 'column_name'
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto copy = columns[i].Copy();
-		if (default_idx == i) {
-			// set the default value of this column
-			D_ASSERT(!copy.Generated()); // Shouldnt reach here - DEFAULT value isn't supported for Generated Columns
-			copy.SetDefaultValue(info.expression ? info.expression->Copy() : nullptr);
-		}
-		create_info->columns.push_back(move(copy));
-	}
-	// Copy all the constraints
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		create_info->constraints.push_back(move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
-	if (info.target_type.id() == LogicalTypeId::USER) {
-		auto &catalog = Catalog::GetCatalog(context);
-		info.target_type = catalog.GetType(context, schema->name, UserType::GetTypeName(info.target_type));
-	}
-	auto change_idx = GetColumnIndex(info.column_name);
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
-	create_info->temporary = temporary;
-
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto copy = columns[i].Copy();
-		if (change_idx == i) {
-			// set the type of this column
-			if (copy.Generated()) {
-				throw NotImplementedException("Changing types of generated columns is not supported yet");
-				// copy.ChangeGeneratedExpressionType(info.target_type);
-			}
-			copy.SetType(info.target_type);
-		}
-		// TODO: check if the generated_expression breaks, only delete it if it does
-		if (copy.Generated() && column_dependency_manager.IsDependencyOf(i, change_idx)) {
-			throw BinderException(
-			    "This column is referenced by the generated column \"%s\", so its type can not be changed",
-			    copy.Name());
-		}
-		create_info->columns.push_back(move(copy));
-	}
-
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		switch (constraint->type) {
-		case ConstraintType::CHECK: {
-			auto &bound_check = (BoundCheckConstraint &)*bound_constraints[i];
-			if (bound_check.bound_columns.find(change_idx) != bound_check.bound_columns.end()) {
-				throw BinderException("Cannot change the type of a column that has a CHECK constraint specified");
-			}
-			break;
-		}
-		case ConstraintType::NOT_NULL:
-			break;
-		case ConstraintType::UNIQUE: {
-			auto &bound_unique = (BoundUniqueConstraint &)*bound_constraints[i];
-			if (bound_unique.key_set.find(change_idx) != bound_unique.key_set.end()) {
-				throw BinderException(
-				    "Cannot change the type of a column that has a UNIQUE or PRIMARY KEY constraint specified");
-			}
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = (BoundForeignKeyConstraint &)*bound_constraints[i];
-			unordered_set<idx_t> key_set = bfk.pk_key_set;
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				key_set = bfk.fk_key_set;
-			} else if (bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < bfk.info.fk_keys.size(); i++) {
-					key_set.insert(bfk.info.fk_keys[i]);
-				}
-			}
-			if (key_set.find(change_idx) != key_set.end()) {
-				throw BinderException("Cannot change the type of a column that has a FOREIGN KEY constraint specified");
-			}
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-		create_info->constraints.push_back(move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	// bind the specified expression
-	vector<column_t> bound_columns;
-	AlterBinder expr_binder(*binder, context, *this, bound_columns, info.target_type);
-	auto expression = info.expression->Copy();
-	auto bound_expression = expr_binder.Bind(expression);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	if (bound_columns.empty()) {
-		bound_columns.push_back(COLUMN_IDENTIFIER_ROW_ID);
-	}
-
-	auto new_storage =
-	    make_shared<DataTable>(context, *storage, change_idx, info.target_type, move(bound_columns), *bound_expression);
-	auto result =
-	    make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), new_storage);
-	return move(result);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::SetForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info) {
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
-	create_info->temporary = temporary;
-
-	for (idx_t i = 0; i < columns.size(); i++) {
-		create_info->columns.push_back(columns[i].Copy());
-	}
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			ForeignKeyConstraint &fk = (ForeignKeyConstraint &)*constraint;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && fk.info.table == info.fk_table) {
-				continue;
-			}
-		}
-		create_info->constraints.push_back(move(constraint));
-	}
-	if (info.type == AlterForeignKeyType::AFT_ADD) {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE;
-		fk_info.schema = info.schema;
-		fk_info.table = info.fk_table;
-		fk_info.pk_keys = info.pk_keys;
-		fk_info.fk_keys = info.fk_keys;
-		create_info->constraints.push_back(
-		    make_unique<ForeignKeyConstraint>(info.pk_columns, info.fk_columns, move(fk_info)));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-ColumnDefinition &TableCatalogEntry::GetColumn(const string &name) {
-	auto entry = name_map.find(name);
-	if (entry == name_map.end() || entry->second == COLUMN_IDENTIFIER_ROW_ID) {
-		throw CatalogException("Column with name %s does not exist!", name);
-	}
-	auto column_index = entry->second;
-	return columns[column_index];
-}
-
-vector<LogicalType> TableCatalogEntry::GetTypes() {
-	vector<LogicalType> types;
-	for (auto &it : columns) {
-		if (it.Generated()) {
-			continue;
-		}
-		types.push_back(it.Type());
-	}
-	return types;
-}
-
-void TableCatalogEntry::Serialize(Serializer &serializer) {
-	D_ASSERT(!internal);
-
-	FieldWriter writer(serializer);
-	writer.WriteString(schema->name);
-	writer.WriteString(name);
-	writer.WriteRegularSerializableList(columns);
-	writer.WriteSerializableList(constraints);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateTableInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->table = reader.ReadRequired<string>();
-	info->columns = reader.ReadRequiredSerializableList<ColumnDefinition, ColumnDefinition>();
-	info->constraints = reader.ReadRequiredSerializableList<Constraint>();
-	reader.Finalize();
-
-	return info;
-}
-
-string TableCatalogEntry::ToSQL() {
-	std::stringstream ss;
-
-	ss << "CREATE TABLE ";
-
-	if (schema->name != DEFAULT_SCHEMA) {
-		ss << KeywordHelper::WriteOptionallyQuoted(schema->name) << ".";
-	}
-
-	ss << KeywordHelper::WriteOptionallyQuoted(name) << "(";
-
-	// find all columns that have NOT NULL specified, but are NOT primary key columns
-	unordered_set<idx_t> not_null_columns;
-	unordered_set<idx_t> unique_columns;
-	unordered_set<idx_t> pk_columns;
-	unordered_set<string> multi_key_pks;
-	vector<string> extra_constraints;
-	for (auto &constraint : constraints) {
-		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = (NotNullConstraint &)*constraint;
-			not_null_columns.insert(not_null.index);
-		} else if (constraint->type == ConstraintType::UNIQUE) {
-			auto &pk = (UniqueConstraint &)*constraint;
-			vector<string> constraint_columns = pk.columns;
-			if (pk.index != DConstants::INVALID_INDEX) {
-				// no columns specified: single column constraint
-				if (pk.is_primary_key) {
-					pk_columns.insert(pk.index);
-				} else {
-					unique_columns.insert(pk.index);
-				}
-			} else {
-				// multi-column constraint, this constraint needs to go at the end after all columns
-				if (pk.is_primary_key) {
-					// multi key pk column: insert set of columns into multi_key_pks
-					for (auto &col : pk.columns) {
-						multi_key_pks.insert(col);
-					}
-				}
-				extra_constraints.push_back(constraint->ToString());
-			}
-		} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			auto &fk = (ForeignKeyConstraint &)*constraint;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
-			    fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				extra_constraints.push_back(constraint->ToString());
-			}
-		} else {
-			extra_constraints.push_back(constraint->ToString());
-		}
-	}
-
-	for (idx_t i = 0; i < columns.size(); i++) {
-		if (i > 0) {
-			ss << ", ";
-		}
-		auto &column = columns[i];
-		ss << KeywordHelper::WriteOptionallyQuoted(column.Name()) << " ";
-		ss << column.Type().ToString();
-		bool not_null = not_null_columns.find(column.Oid()) != not_null_columns.end();
-		bool is_single_key_pk = pk_columns.find(column.Oid()) != pk_columns.end();
-		bool is_multi_key_pk = multi_key_pks.find(column.Name()) != multi_key_pks.end();
-		bool is_unique = unique_columns.find(column.Oid()) != unique_columns.end();
-		if (not_null && !is_single_key_pk && !is_multi_key_pk) {
-			// NOT NULL but not a primary key column
-			ss << " NOT NULL";
-		}
-		if (is_single_key_pk) {
-			// single column pk: insert constraint here
-			ss << " PRIMARY KEY";
-		}
-		if (is_unique) {
-			// single column unique: insert constraint here
-			ss << " UNIQUE";
-		}
-		if (column.DefaultValue()) {
-			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
-		}
-		if (column.Generated()) {
-			ss << " GENERATED ALWAYS AS(" << column.GeneratedExpression().ToString() << ")";
-		}
-	}
-	// print any extra constraints that still need to be printed
-	for (auto &extra_constraint : extra_constraints) {
-		ss << ", ";
-		ss << extra_constraint;
-	}
-
-	ss << ");";
-	return ss.str();
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::Copy(ClientContext &context) {
-	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
-	for (idx_t i = 0; i < columns.size(); i++) {
-		create_info->columns.push_back(columns[i].Copy());
-	}
-
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		create_info->constraints.push_back(move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-void TableCatalogEntry::SetAsRoot() {
-	storage->SetAsRoot();
-}
-
-void TableCatalogEntry::CommitAlter(AlterInfo &info) {
-	D_ASSERT(info.type == AlterType::ALTER_TABLE);
-	auto &alter_table = (AlterTableInfo &)info;
-	string column_name;
-	switch (alter_table.alter_table_type) {
-	case AlterTableType::REMOVE_COLUMN: {
-		auto &remove_info = (RemoveColumnInfo &)alter_table;
-		column_name = remove_info.removed_column;
-		break;
-	}
-	case AlterTableType::ALTER_COLUMN_TYPE: {
-		auto &change_info = (ChangeColumnTypeInfo &)alter_table;
-		column_name = change_info.column_name;
-		break;
-	}
-	default:
-		break;
-	}
-	if (column_name.empty()) {
-		return;
-	}
-	idx_t removed_index = DConstants::INVALID_INDEX;
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto &col = columns[i];
-		if (col.Name() == column_name) {
-			// No need to alter storage, removed column is generated column
-			if (col.Generated()) {
-				return;
-			}
-			removed_index = i;
-			break;
-		}
-	}
-	D_ASSERT(removed_index != DConstants::INVALID_INDEX);
-	storage->CommitDropColumn(removed_index);
-}
-
-void TableCatalogEntry::CommitDrop() {
-	storage->CommitDropTable();
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
-                                                     CreateTableFunctionInfo *info)
-    : StandardEntry(CatalogType::TABLE_FUNCTION_ENTRY, schema, catalog, info->name), functions(move(info->functions)) {
-	D_ASSERT(this->functions.size() > 0);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-#include <sstream>
-
-namespace duckdb {
-
-TypeCatalogEntry::TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info)
-    : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info->name), user_type(info->type) {
-	this->temporary = info->temporary;
-	this->internal = info->internal;
-}
-
-void TypeCatalogEntry::Serialize(Serializer &serializer) {
-	D_ASSERT(!internal);
-	FieldWriter writer(serializer);
-	writer.WriteString(schema->name);
-	writer.WriteString(name);
-	writer.WriteSerializable(user_type);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTypeInfo> TypeCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateTypeInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	info->type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return info;
-}
-
-string TypeCatalogEntry::ToSQL() {
-	std::stringstream ss;
-	switch (user_type.id()) {
-	case (LogicalTypeId::ENUM): {
-		Vector values_insert_order(EnumType::GetValuesInsertOrder(user_type));
-		idx_t size = EnumType::GetSize(user_type);
-		ss << "CREATE TYPE ";
-		ss << KeywordHelper::WriteOptionallyQuoted(name);
-		ss << " AS ENUM ( ";
-
-		for (idx_t i = 0; i < size; i++) {
-			ss << "'" << values_insert_order.GetValue(i).ToString() << "'";
-			if (i != size - 1) {
-				ss << ", ";
-			}
-		}
-		ss << ");";
-		break;
-	}
-	default:
-		throw InternalException("Logical Type can't be used as a User Defined Type");
-	}
-
-	return ss.str();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-void ViewCatalogEntry::Initialize(CreateViewInfo *info) {
-	query = move(info->query);
-	this->aliases = info->aliases;
-	this->types = info->types;
-	this->temporary = info->temporary;
-	this->sql = info->sql;
-	this->internal = info->internal;
-}
-
-ViewCatalogEntry::ViewCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateViewInfo *info)
-    : StandardEntry(CatalogType::VIEW_ENTRY, schema, catalog, info->view_name) {
-	Initialize(info);
-}
-
-unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
-	D_ASSERT(!internal);
-	if (info->type != AlterType::ALTER_VIEW) {
-		throw CatalogException("Can only modify view with ALTER VIEW statement");
-	}
-	auto view_info = (AlterViewInfo *)info;
-	switch (view_info->alter_view_type) {
-	case AlterViewType::RENAME_VIEW: {
-		auto rename_info = (RenameViewInfo *)view_info;
-		auto copied_view = Copy(context);
-		copied_view->name = rename_info->new_view_name;
-		return copied_view;
-	}
-	default:
-		throw InternalException("Unrecognized alter view type!");
-	}
-}
-
-void ViewCatalogEntry::Serialize(Serializer &serializer) {
-	D_ASSERT(!internal);
-	FieldWriter writer(serializer);
-	writer.WriteString(schema->name);
-	writer.WriteString(name);
-	writer.WriteString(sql);
-	writer.WriteSerializable(*query);
-	writer.WriteList<string>(aliases);
-	writer.WriteRegularSerializableList<LogicalType>(types);
-	writer.Finalize();
-}
-
-unique_ptr<CreateViewInfo> ViewCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateViewInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->view_name = reader.ReadRequired<string>();
-	info->sql = reader.ReadRequired<string>();
-	info->query = reader.ReadRequiredSerializable<SelectStatement>();
-	info->aliases = reader.ReadRequiredList<string>();
-	info->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return info;
-}
-
-string ViewCatalogEntry::ToSQL() {
-	if (sql.empty()) {
-		//! Return empty sql with view name so pragma view_tables don't complain
-		return sql;
-	}
-	return sql + "\n;";
-}
-
-unique_ptr<CatalogEntry> ViewCatalogEntry::Copy(ClientContext &context) {
-	D_ASSERT(!internal);
-	auto create_info = make_unique<CreateViewInfo>(schema->name, name);
-	create_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-	for (idx_t i = 0; i < aliases.size(); i++) {
-		create_info->aliases.push_back(aliases[i]);
-	}
-	for (idx_t i = 0; i < types.size(); i++) {
-		create_info->types.push_back(types[i]);
-	}
-	create_info->temporary = temporary;
-	create_info->sql = sql;
-
-	return make_unique<ViewCatalogEntry>(catalog, schema, create_info.get());
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-CatalogEntry::CatalogEntry(CatalogType type, Catalog *catalog_p, string name_p)
-    : oid(catalog_p->ModifyCatalog()), type(type), catalog(catalog_p), set(nullptr), name(move(name_p)), deleted(false),
-      temporary(false), internal(false), parent(nullptr) {
-}
-
-CatalogEntry::~CatalogEntry() {
-}
-
-void CatalogEntry::SetAsRoot() {
-}
-
-// LCOV_EXCL_START
-unique_ptr<CatalogEntry> CatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
-	throw InternalException("Unsupported alter type for catalog entry!");
-}
-
-unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) {
-	throw InternalException("Unsupported copy type for catalog entry!");
-}
-
-string CatalogEntry::ToSQL() {
-	throw InternalException("Unsupported catalog type for ToSQL()");
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-CatalogSearchPath::CatalogSearchPath(ClientContext &context_p) : context(context_p) {
-	SetPaths(ParsePaths(""));
-}
-
-void CatalogSearchPath::Set(const string &new_value, bool is_set_schema) {
-	auto new_paths = ParsePaths(new_value);
-	if (is_set_schema && new_paths.size() != 1) {
-		throw CatalogException("SET schema can set only 1 schema. This has %d", new_paths.size());
-	}
-	auto &catalog = Catalog::GetCatalog(context);
-	for (const auto &path : new_paths) {
-		if (!catalog.GetSchema(context, StringUtil::Lower(path), true)) {
-			throw CatalogException("SET %s: No schema named %s found.", is_set_schema ? "schema" : "search_path", path);
-		}
-	}
-	this->set_paths = move(new_paths);
-	SetPaths(set_paths);
-}
-
-const vector<string> &CatalogSearchPath::Get() {
-	return paths;
-}
-
-const string &CatalogSearchPath::GetOrDefault(const string &name) {
-	return name == INVALID_SCHEMA ? GetDefault() : name; // NOLINT
-}
-
-const string &CatalogSearchPath::GetDefault() {
-	const auto &paths = Get();
-	D_ASSERT(paths.size() >= 2);
-	D_ASSERT(paths[0] == TEMP_SCHEMA);
-	return paths[1];
-}
-
-void CatalogSearchPath::SetPaths(vector<string> new_paths) {
-	paths.clear();
-	paths.reserve(new_paths.size() + 3);
-	paths.emplace_back(TEMP_SCHEMA);
-	for (auto &path : new_paths) {
-		paths.push_back(move(path));
-	}
-	paths.emplace_back(DEFAULT_SCHEMA);
-	paths.emplace_back("pg_catalog");
-}
-
-vector<string> CatalogSearchPath::ParsePaths(const string &value) {
-	return StringUtil::SplitWithQuote(StringUtil::Lower(value));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Class responsible to keep track of state when removing entries from the catalog.
-//! When deleting, many types of errors can be thrown, since we want to avoid try/catch blocks
-//! this class makes sure that whatever elements were modified are returned to a correct state
-//! when exceptions are thrown.
-//! The idea here is to use RAII (Resource acquisition is initialization) to mimic a try/catch/finally block.
-//! If any exception is raised when this object exists, then its destructor will be called
-//! and the entry will return to its previous state during deconstruction.
-class EntryDropper {
-public:
-	//! Both constructor and destructor are privates because they should only be called by DropEntryDependencies
-	explicit EntryDropper(CatalogSet &catalog_set, idx_t entry_index)
-	    : catalog_set(catalog_set), entry_index(entry_index) {
-		old_deleted = catalog_set.entries[entry_index].get()->deleted;
-	}
-
-	~EntryDropper() {
-		catalog_set.entries[entry_index].get()->deleted = old_deleted;
-	}
-
-private:
-	//! The current catalog_set
-	CatalogSet &catalog_set;
-	//! Keeps track of the state of the entry before starting the delete
-	bool old_deleted;
-	//! Index of entry to be deleted
-	idx_t entry_index;
-};
-
-CatalogSet::CatalogSet(Catalog &catalog, unique_ptr<DefaultGenerator> defaults)
-    : catalog(catalog), defaults(move(defaults)) {
-}
-
-bool CatalogSet::CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-                             unordered_set<CatalogEntry *> &dependencies) {
-	auto &transaction = Transaction::GetTransaction(context);
-	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.write_lock);
-	// lock this catalog set to disallow reading
-	unique_lock<mutex> read_lock(catalog_lock);
-
-	// first check if the entry exists in the unordered set
-	idx_t entry_index;
-	auto mapping_value = GetMapping(context, name);
-	if (mapping_value == nullptr || mapping_value->deleted) {
-		// if it does not: entry has never been created
-
-		// check if there is a default entry
-		auto entry = CreateDefaultEntry(context, name, read_lock);
-		if (entry) {
-			return false;
-		}
-
-		// first create a dummy deleted entry for this entry
-		// so transactions started before the commit of this transaction don't
-		// see it yet
-		entry_index = current_entry++;
-		auto dummy_node = make_unique<CatalogEntry>(CatalogType::INVALID, value->catalog, name);
-		dummy_node->timestamp = 0;
-		dummy_node->deleted = true;
-		dummy_node->set = this;
-
-		entries[entry_index] = move(dummy_node);
-		PutMapping(context, name, entry_index);
-	} else {
-		entry_index = mapping_value->index;
-		auto &current = *entries[entry_index];
-		// if it does, we have to check version numbers
-		if (HasConflict(context, current.timestamp)) {
-			// current version has been written to by a currently active
-			// transaction
-			throw TransactionException("Catalog write-write conflict on create with \"%s\"", current.name);
-		}
-		// there is a current version that has been committed
-		// if it has not been deleted there is a conflict
-		if (!current.deleted) {
-			return false;
-		}
-	}
-	// create a new entry and replace the currently stored one
-	// set the timestamp to the timestamp of the current transaction
-	// and point it at the dummy node
-	value->timestamp = transaction.transaction_id;
-	value->set = this;
-
-	// now add the dependency set of this object to the dependency manager
-	catalog.dependency_manager->AddObject(context, value.get(), dependencies);
-
-	value->child = move(entries[entry_index]);
-	value->child->parent = value.get();
-	// push the old entry in the undo buffer for this transaction
-	transaction.PushCatalogEntry(value->child.get());
-	entries[entry_index] = move(value);
-	return true;
-}
-
-bool CatalogSet::GetEntryInternal(ClientContext &context, idx_t entry_index, CatalogEntry *&catalog_entry) {
-	catalog_entry = entries[entry_index].get();
-	// if it does: we have to retrieve the entry and to check version numbers
-	if (HasConflict(context, catalog_entry->timestamp)) {
-		// current version has been written to by a currently active
-		// transaction
-		throw TransactionException("Catalog write-write conflict on alter with \"%s\"", catalog_entry->name);
-	}
-	// there is a current version that has been committed by this transaction
-	if (catalog_entry->deleted) {
-		// if the entry was already deleted, it now does not exist anymore
-		// so we return that we could not find it
-		return false;
-	}
-	return true;
-}
-
-bool CatalogSet::GetEntryInternal(ClientContext &context, const string &name, idx_t &entry_index,
-                                  CatalogEntry *&catalog_entry) {
-	auto mapping_value = GetMapping(context, name);
-	if (mapping_value == nullptr || mapping_value->deleted) {
-		// the entry does not exist, check if we can create a default entry
-		return false;
-	}
-	entry_index = mapping_value->index;
-	return GetEntryInternal(context, entry_index, catalog_entry);
-}
-
-bool CatalogSet::AlterOwnership(ClientContext &context, ChangeOwnershipInfo *info) {
-	idx_t entry_index;
-	CatalogEntry *entry;
-	if (!GetEntryInternal(context, info->name, entry_index, entry)) {
-		return false;
-	}
-
-	auto owner_entry = catalog.GetEntry(context, info->owner_schema, info->owner_name);
-	if (!owner_entry) {
-		return false;
-	}
-
-	catalog.dependency_manager->AddOwnership(context, owner_entry, entry);
-
-	return true;
-}
-
-bool CatalogSet::AlterEntry(ClientContext &context, const string &name, AlterInfo *alter_info) {
-	auto &transaction = Transaction::GetTransaction(context);
-	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.write_lock);
-
-	// first check if the entry exists in the unordered set
-	idx_t entry_index;
-	CatalogEntry *entry;
-	if (!GetEntryInternal(context, name, entry_index, entry)) {
-		return false;
-	}
-	if (entry->internal) {
-		throw CatalogException("Cannot alter entry \"%s\" because it is an internal system entry", entry->name);
-	}
-
-	// lock this catalog set to disallow reading
-	lock_guard<mutex> read_lock(catalog_lock);
-
-	// create a new entry and replace the currently stored one
-	// set the timestamp to the timestamp of the current transaction
-	// and point it to the updated table node
-	string original_name = entry->name;
-	auto value = entry->AlterEntry(context, alter_info);
-	if (!value) {
-		// alter failed, but did not result in an error
-		return true;
-	}
-
-	if (value->name != original_name) {
-		auto mapping_value = GetMapping(context, value->name);
-		if (mapping_value && !mapping_value->deleted) {
-			auto entry = GetEntryForTransaction(context, entries[mapping_value->index].get());
-			if (!entry->deleted) {
-				string rename_err_msg =
-				    "Could not rename \"%s\" to \"%s\": another entry with this name already exists!";
-				throw CatalogException(rename_err_msg, original_name, value->name);
-			}
-		}
-		PutMapping(context, value->name, entry_index);
-		DeleteMapping(context, original_name);
-	}
-	//! Check the dependency manager to verify that there are no conflicting dependencies with this alter
-	catalog.dependency_manager->AlterObject(context, entry, value.get());
-
-	value->timestamp = transaction.transaction_id;
-	value->child = move(entries[entry_index]);
-	value->child->parent = value.get();
-	value->set = this;
-
-	// serialize the AlterInfo into a temporary buffer
-	BufferedSerializer serializer;
-	alter_info->Serialize(serializer);
-	BinaryData serialized_alter = serializer.GetData();
-
-	// push the old entry in the undo buffer for this transaction
-	transaction.PushCatalogEntry(value->child.get(), serialized_alter.data.get(), serialized_alter.size);
-	entries[entry_index] = move(value);
-
-	return true;
-}
-
-void CatalogSet::DropEntryDependencies(ClientContext &context, idx_t entry_index, CatalogEntry &entry, bool cascade) {
-
-	// Stores the deleted value of the entry before starting the process
-	EntryDropper dropper(*this, entry_index);
-
-	// To correctly delete the object and its dependencies, it temporarily is set to deleted.
-	entries[entry_index].get()->deleted = true;
-
-	// check any dependencies of this object
-	entry.catalog->dependency_manager->DropObject(context, &entry, cascade);
-
-	// dropper destructor is called here
-	// the destructor makes sure to return the value to the previous state
-	// dropper.~EntryDropper()
-}
-
-void CatalogSet::DropEntryInternal(ClientContext &context, idx_t entry_index, CatalogEntry &entry, bool cascade) {
-	auto &transaction = Transaction::GetTransaction(context);
-
-	DropEntryDependencies(context, entry_index, entry, cascade);
-
-	// create a new entry and replace the currently stored one
-	// set the timestamp to the timestamp of the current transaction
-	// and point it at the dummy node
-	auto value = make_unique<CatalogEntry>(CatalogType::DELETED_ENTRY, entry.catalog, entry.name);
-	value->timestamp = transaction.transaction_id;
-	value->child = move(entries[entry_index]);
-	value->child->parent = value.get();
-	value->set = this;
-	value->deleted = true;
-
-	// push the old entry in the undo buffer for this transaction
-	transaction.PushCatalogEntry(value->child.get());
-
-	entries[entry_index] = move(value);
-}
-
-bool CatalogSet::DropEntry(ClientContext &context, const string &name, bool cascade) {
-	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.write_lock);
-	// we can only delete an entry that exists
-	idx_t entry_index;
-	CatalogEntry *entry;
-	if (!GetEntryInternal(context, name, entry_index, entry)) {
-		return false;
-	}
-	if (entry->internal) {
-		throw CatalogException("Cannot drop entry \"%s\" because it is an internal system entry", entry->name);
-	}
-
-	DropEntryInternal(context, entry_index, *entry, cascade);
-	return true;
-}
-
-void CatalogSet::CleanupEntry(CatalogEntry *catalog_entry) {
-	// destroy the backed up entry: it is no longer required
-	D_ASSERT(catalog_entry->parent);
-	if (catalog_entry->parent->type != CatalogType::UPDATED_ENTRY) {
-		lock_guard<mutex> lock(catalog_lock);
-		if (!catalog_entry->deleted) {
-			// delete the entry from the dependency manager, if it is not deleted yet
-			catalog_entry->catalog->dependency_manager->EraseObject(catalog_entry);
-		}
-		auto parent = catalog_entry->parent;
-		parent->child = move(catalog_entry->child);
-		if (parent->deleted && !parent->child && !parent->parent) {
-			auto mapping_entry = mapping.find(parent->name);
-			D_ASSERT(mapping_entry != mapping.end());
-			auto index = mapping_entry->second->index;
-			auto entry = entries.find(index);
-			D_ASSERT(entry != entries.end());
-			if (entry->second.get() == parent) {
-				mapping.erase(mapping_entry);
-				entries.erase(entry);
-			}
-		}
-	}
-}
-
-bool CatalogSet::HasConflict(ClientContext &context, transaction_t timestamp) {
-	auto &transaction = Transaction::GetTransaction(context);
-	return (timestamp >= TRANSACTION_ID_START && timestamp != transaction.transaction_id) ||
-	       (timestamp < TRANSACTION_ID_START && timestamp > transaction.start_time);
-}
-
-MappingValue *CatalogSet::GetMapping(ClientContext &context, const string &name, bool get_latest) {
-	MappingValue *mapping_value;
-	auto entry = mapping.find(name);
-	if (entry != mapping.end()) {
-		mapping_value = entry->second.get();
-	} else {
-
-		return nullptr;
-	}
-	if (get_latest) {
-		return mapping_value;
-	}
-	while (mapping_value->child) {
-		if (UseTimestamp(context, mapping_value->timestamp)) {
-			break;
-		}
-		mapping_value = mapping_value->child.get();
-		D_ASSERT(mapping_value);
-	}
-	return mapping_value;
-}
-
-void CatalogSet::PutMapping(ClientContext &context, const string &name, idx_t entry_index) {
-	auto entry = mapping.find(name);
-	auto new_value = make_unique<MappingValue>(entry_index);
-	new_value->timestamp = Transaction::GetTransaction(context).transaction_id;
-	if (entry != mapping.end()) {
-		if (HasConflict(context, entry->second->timestamp)) {
-			throw TransactionException("Catalog write-write conflict on name \"%s\"", name);
-		}
-		new_value->child = move(entry->second);
-		new_value->child->parent = new_value.get();
-	}
-	mapping[name] = move(new_value);
-}
-
-void CatalogSet::DeleteMapping(ClientContext &context, const string &name) {
-	auto entry = mapping.find(name);
-	D_ASSERT(entry != mapping.end());
-	auto delete_marker = make_unique<MappingValue>(entry->second->index);
-	delete_marker->deleted = true;
-	delete_marker->timestamp = Transaction::GetTransaction(context).transaction_id;
-	delete_marker->child = move(entry->second);
-	delete_marker->child->parent = delete_marker.get();
-	mapping[name] = move(delete_marker);
-}
-
-bool CatalogSet::UseTimestamp(ClientContext &context, transaction_t timestamp) {
-	auto &transaction = Transaction::GetTransaction(context);
-	if (timestamp == transaction.transaction_id) {
-		// we created this version
-		return true;
-	}
-	if (timestamp < transaction.start_time) {
-		// this version was commited before we started the transaction
-		return true;
-	}
-	return false;
-}
-
-CatalogEntry *CatalogSet::GetEntryForTransaction(ClientContext &context, CatalogEntry *current) {
-	while (current->child) {
-		if (UseTimestamp(context, current->timestamp)) {
-			break;
-		}
-		current = current->child.get();
-		D_ASSERT(current);
-	}
-	return current;
-}
-
-CatalogEntry *CatalogSet::GetCommittedEntry(CatalogEntry *current) {
-	while (current->child) {
-		if (current->timestamp < TRANSACTION_ID_START) {
-			// this entry is committed: use it
-			break;
-		}
-		current = current->child.get();
-		D_ASSERT(current);
-	}
-	return current;
-}
-
-pair<string, idx_t> CatalogSet::SimilarEntry(ClientContext &context, const string &name) {
-	unique_lock<mutex> lock(catalog_lock);
-	CreateDefaultEntries(context, lock);
-
-	string result;
-	idx_t current_score = (idx_t)-1;
-	for (auto &kv : mapping) {
-		auto mapping_value = GetMapping(context, kv.first);
-		if (mapping_value && !mapping_value->deleted) {
-			auto ldist = StringUtil::LevenshteinDistance(kv.first, name);
-			if (ldist < current_score) {
-				current_score = ldist;
-				result = kv.first;
-			}
-		}
-	}
-	return {result, current_score};
-}
-
-CatalogEntry *CatalogSet::CreateEntryInternal(ClientContext &context, unique_ptr<CatalogEntry> entry) {
-	if (mapping.find(entry->name) != mapping.end()) {
-		return nullptr;
-	}
-	auto &name = entry->name;
-	auto entry_index = current_entry++;
-	auto catalog_entry = entry.get();
-
-	entry->set = this;
-	entry->timestamp = 0;
-
-	PutMapping(context, name, entry_index);
-	mapping[name]->timestamp = 0;
-	entries[entry_index] = move(entry);
-	return catalog_entry;
-}
-
-CatalogEntry *CatalogSet::CreateDefaultEntry(ClientContext &context, const string &name, unique_lock<mutex> &lock) {
-	// no entry found with this name, check for defaults
-	if (!defaults || defaults->created_all_entries) {
-		// no defaults either: return null
-		return nullptr;
-	}
-	// this catalog set has a default map defined
-	// check if there is a default entry that we can create with this name
-	lock.unlock();
-	auto entry = defaults->CreateDefaultEntry(context, name);
-
-	lock.lock();
-	if (!entry) {
-		// no default entry
-		return nullptr;
-	}
-	// there is a default entry! create it
-	auto result = CreateEntryInternal(context, move(entry));
-	if (result) {
-		return result;
-	}
-	// we found a default entry, but failed
-	// this means somebody else created the entry first
-	// just retry?
-	lock.unlock();
-	return GetEntry(context, name);
-}
-
-CatalogEntry *CatalogSet::GetEntry(ClientContext &context, const string &name) {
-	unique_lock<mutex> lock(catalog_lock);
-	auto mapping_value = GetMapping(context, name);
-	if (mapping_value != nullptr && !mapping_value->deleted) {
-		// we found an entry for this name
-		// check the version numbers
-
-		auto catalog_entry = entries[mapping_value->index].get();
-		CatalogEntry *current = GetEntryForTransaction(context, catalog_entry);
-		if (current->deleted || (current->name != name && !UseTimestamp(context, mapping_value->timestamp))) {
-			return nullptr;
-		}
-		return current;
-	}
-	return CreateDefaultEntry(context, name, lock);
-}
-
-void CatalogSet::UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp) {
-	entry->timestamp = timestamp;
-	mapping[entry->name]->timestamp = timestamp;
-}
-
-void CatalogSet::AdjustUserDependency(CatalogEntry *entry, ColumnDefinition &column, bool remove) {
-	CatalogEntry *user_type_catalog = (CatalogEntry *)LogicalType::GetCatalog(column.Type());
-	if (user_type_catalog) {
-		if (remove) {
-			catalog.dependency_manager->dependents_map[user_type_catalog].erase(entry->parent);
-			catalog.dependency_manager->dependencies_map[entry->parent].erase(user_type_catalog);
-		} else {
-			catalog.dependency_manager->dependents_map[user_type_catalog].insert(entry);
-			catalog.dependency_manager->dependencies_map[entry].insert(user_type_catalog);
-		}
-	}
-}
-
-void CatalogSet::AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table, ColumnDefinition &column,
-                                  bool remove) {
-	bool found = false;
-	if (column.Type().id() == LogicalTypeId::ENUM) {
-		for (auto &old_column : table->columns) {
-			if (old_column.Name() == column.Name() && old_column.Type().id() != LogicalTypeId::ENUM) {
-				AdjustUserDependency(entry, column, remove);
-				found = true;
-			}
-		}
-		if (!found) {
-			AdjustUserDependency(entry, column, remove);
-		}
-	} else if (!(column.Type().GetAlias().empty())) {
-		auto alias = column.Type().GetAlias();
-		for (auto &old_column : table->columns) {
-			auto old_alias = old_column.Type().GetAlias();
-			if (old_column.Name() == column.Name() && old_alias != alias) {
-				AdjustUserDependency(entry, column, remove);
-				found = true;
-			}
-		}
-		if (!found) {
-			AdjustUserDependency(entry, column, remove);
-		}
-	}
-}
-
-void CatalogSet::AdjustTableDependencies(CatalogEntry *entry) {
-	if (entry->type == CatalogType::TABLE_ENTRY && entry->parent->type == CatalogType::TABLE_ENTRY) {
-		// If it's a table entry we have to check for possibly removing or adding user type dependencies
-		auto old_table = (TableCatalogEntry *)entry->parent;
-		auto new_table = (TableCatalogEntry *)entry;
-
-		for (auto &new_column : new_table->columns) {
-			AdjustDependency(entry, old_table, new_column, false);
-		}
-		for (auto &old_column : old_table->columns) {
-			AdjustDependency(entry, new_table, old_column, true);
-		}
-	}
-}
-
-void CatalogSet::Undo(CatalogEntry *entry) {
-	lock_guard<mutex> write_lock(catalog.write_lock);
-
-	lock_guard<mutex> lock(catalog_lock);
-
-	// entry has to be restored
-	// and entry->parent has to be removed ("rolled back")
-
-	// i.e. we have to place (entry) as (entry->parent) again
-	auto &to_be_removed_node = entry->parent;
-
-	AdjustTableDependencies(entry);
-
-	if (!to_be_removed_node->deleted) {
-		// delete the entry from the dependency manager as well
-		catalog.dependency_manager->EraseObject(to_be_removed_node);
-	}
-	if (entry->name != to_be_removed_node->name) {
-		// rename: clean up the new name when the rename is rolled back
-		auto removed_entry = mapping.find(to_be_removed_node->name);
-		if (removed_entry->second->child) {
-			removed_entry->second->child->parent = nullptr;
-			mapping[to_be_removed_node->name] = move(removed_entry->second->child);
-		} else {
-			mapping.erase(removed_entry);
-		}
-	}
-	if (to_be_removed_node->parent) {
-		// if the to be removed node has a parent, set the child pointer to the
-		// to be restored node
-		to_be_removed_node->parent->child = move(to_be_removed_node->child);
-		entry->parent = to_be_removed_node->parent;
-	} else {
-		// otherwise we need to update the base entry tables
-		auto &name = entry->name;
-		to_be_removed_node->child->SetAsRoot();
-		entries[mapping[name]->index] = move(to_be_removed_node->child);
-		entry->parent = nullptr;
-	}
-
-	// restore the name if it was deleted
-	auto restored_entry = mapping.find(entry->name);
-	if (restored_entry->second->deleted || entry->type == CatalogType::INVALID) {
-		if (restored_entry->second->child) {
-			restored_entry->second->child->parent = nullptr;
-			mapping[entry->name] = move(restored_entry->second->child);
-		} else {
-			mapping.erase(restored_entry);
-		}
-	}
-	// we mark the catalog as being modified, since this action can lead to e.g. tables being dropped
-	entry->catalog->ModifyCatalog();
-}
-
-void CatalogSet::CreateDefaultEntries(ClientContext &context, unique_lock<mutex> &lock) {
-	if (!defaults || defaults->created_all_entries) {
-		return;
-	}
-	// this catalog set has a default set defined:
-	auto default_entries = defaults->GetDefaultEntries();
-	for (auto &default_entry : default_entries) {
-		auto map_entry = mapping.find(default_entry);
-		if (map_entry == mapping.end()) {
-			// we unlock during the CreateEntry, since it might reference other catalog sets...
-			// specifically for views this can happen since the view will be bound
-			lock.unlock();
-			auto entry = defaults->CreateDefaultEntry(context, default_entry);
-			if (!entry) {
-				throw InternalException("Failed to create default entry for %s", default_entry);
-			}
-
-			lock.lock();
-			CreateEntryInternal(context, move(entry));
-		}
-	}
-	defaults->created_all_entries = true;
-}
-
-void CatalogSet::Scan(ClientContext &context, const std::function<void(CatalogEntry *)> &callback) {
-	// lock the catalog set
-	unique_lock<mutex> lock(catalog_lock);
-	CreateDefaultEntries(context, lock);
-
-	for (auto &kv : entries) {
-		auto entry = kv.second.get();
-		entry = GetEntryForTransaction(context, entry);
-		if (!entry->deleted) {
-			callback(entry);
-		}
-	}
-}
-
-void CatalogSet::Scan(const std::function<void(CatalogEntry *)> &callback) {
-	// lock the catalog set
-	lock_guard<mutex> lock(catalog_lock);
-	for (auto &kv : entries) {
-		auto entry = kv.second.get();
-		entry = GetCommittedEntry(entry);
-		if (!entry->deleted) {
-			callback(entry);
-		}
-	}
-}
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static DefaultMacro internal_macros[] = {
-	{DEFAULT_SCHEMA, "current_user", {nullptr}, "'duckdb'"},                       // user name of current execution context
-	{DEFAULT_SCHEMA, "current_catalog", {nullptr}, "'duckdb'"},                    // name of current database (called "catalog" in the SQL standard)
-	{DEFAULT_SCHEMA, "current_database", {nullptr}, "'duckdb'"},                   // name of current database
-	{DEFAULT_SCHEMA, "user", {nullptr}, "current_user"},                           // equivalent to current_user
-	{DEFAULT_SCHEMA, "session_user", {nullptr}, "'duckdb'"},                       // session user name
-	{"pg_catalog", "inet_client_addr", {nullptr}, "NULL"},                       // address of the remote connection
-	{"pg_catalog", "inet_client_port", {nullptr}, "NULL"},                       // port of the remote connection
-	{"pg_catalog", "inet_server_addr", {nullptr}, "NULL"},                       // address of the local connection
-	{"pg_catalog", "inet_server_port", {nullptr}, "NULL"},                       // port of the local connection
-	{"pg_catalog", "pg_my_temp_schema", {nullptr}, "0"},                         // OID of session's temporary schema, or 0 if none
-	{"pg_catalog", "pg_is_other_temp_schema", {"schema_id", nullptr}, "false"},  // is schema another session's temporary schema?
-
-	{"pg_catalog", "pg_conf_load_time", {nullptr}, "current_timestamp"},         // configuration load time
-	{"pg_catalog", "pg_postmaster_start_time", {nullptr}, "current_timestamp"},  // server start time
-
-	{"pg_catalog", "pg_typeof", {"expression", nullptr}, "lower(typeof(expression))"},  // get the data type of any value
-
-	// privilege functions
-	// {"has_any_column_privilege", {"user", "table", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for any column of table
-	{"pg_catalog", "has_any_column_privilege", {"table", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for any column of table
-	// {"has_column_privilege", {"user", "table", "column", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for column
-	{"pg_catalog", "has_column_privilege", {"table", "column", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for column
-	// {"has_database_privilege", {"user", "database", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for database
-	{"pg_catalog", "has_database_privilege", {"database", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for database
-	// {"has_foreign_data_wrapper_privilege", {"user", "fdw", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for foreign-data wrapper
-	{"pg_catalog", "has_foreign_data_wrapper_privilege", {"fdw", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for foreign-data wrapper
-	// {"has_function_privilege", {"user", "function", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for function
-	{"pg_catalog", "has_function_privilege", {"function", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for function
-	// {"has_language_privilege", {"user", "language", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for language
-	{"pg_catalog", "has_language_privilege", {"language", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for language
-	// {"has_schema_privilege", {"user", "schema, privilege", nullptr}, "true"},  //boolean  //does user have privilege for schema
-	{"pg_catalog", "has_schema_privilege", {"schema", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for schema
-	// {"has_sequence_privilege", {"user", "sequence", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for sequence
-	{"pg_catalog", "has_sequence_privilege", {"sequence", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for sequence
-	// {"has_server_privilege", {"user", "server", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for foreign server
-	{"pg_catalog", "has_server_privilege", {"server", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for foreign server
-	// {"has_table_privilege", {"user", "table", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for table
-	{"pg_catalog", "has_table_privilege", {"table", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for table
-	// {"has_tablespace_privilege", {"user", "tablespace", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for tablespace
-	{"pg_catalog", "has_tablespace_privilege", {"tablespace", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for tablespace
-
-	// various postgres system functions
-	{"pg_catalog", "pg_get_viewdef", {"oid", nullptr}, "(select sql from duckdb_views() v where v.view_oid=oid)"},
-	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid/1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
-	{"pg_catalog", "pg_get_expr", {"pg_node_tree", "relation_oid", nullptr}, "pg_node_tree"},
-	{"pg_catalog", "format_pg_type", {"type_name", nullptr}, "case when logical_type='FLOAT' then 'real' when logical_type='DOUBLE' then 'double precision' when logical_type='DECIMAL' then 'numeric' when logical_type='VARCHAR' then 'character varying' when logical_type='BLOB' then 'bytea' when logical_type='TIMESTAMP' then 'timestamp without time zone' when logical_type='TIME' then 'time without time zone' else lower(logical_type) end"},
-	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, "(select format_pg_type(type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod/1000, ',', typemod%1000, ')') else '' end"},
-
-	{"pg_catalog", "pg_has_role", {"user", "role", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for role
-	{"pg_catalog", "pg_has_role", {"role", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for role
-
-	{"pg_catalog", "col_description", {"table_oid", "column_number", nullptr}, "NULL"},   // get comment for a table column
-	{"pg_catalog", "obj_description", {"object_oid", "catalog_name", nullptr}, "NULL"},   // get comment for a database object
-	{"pg_catalog", "shobj_description", {"object_oid", "catalog_name", nullptr}, "NULL"}, // get comment for a shared database object
-
-	// visibility functions
-	{"pg_catalog", "pg_collation_is_visible", {"collation_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_conversion_is_visible", {"conversion_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_function_is_visible", {"function_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_opclass_is_visible", {"opclass_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_operator_is_visible", {"operator_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_opfamily_is_visible", {"opclass_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_table_is_visible", {"table_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_ts_config_is_visible", {"config_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_ts_dict_is_visible", {"dict_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_ts_parser_is_visible", {"parser_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_ts_template_is_visible", {"template_oid", nullptr}, "true"},
-	{"pg_catalog", "pg_type_is_visible", {"type_oid", nullptr}, "true"},
-
-	{DEFAULT_SCHEMA, "round_even", {"x", "n", nullptr}, "CASE ((abs(x) * power(10, n+1)) % 10) WHEN 5 THEN round(x/2, n) * 2 ELSE round(x, n) END"},
-	{DEFAULT_SCHEMA, "roundbankers", {"x", "n", nullptr}, "round_even(x, n)"},
-	{DEFAULT_SCHEMA, "nullif", {"a", "b", nullptr}, "CASE WHEN a=b THEN NULL ELSE a END"},
-	{DEFAULT_SCHEMA, "list_append", {"l", "e", nullptr}, "list_concat(l, list_value(e))"},
-	{DEFAULT_SCHEMA, "array_append", {"arr", "el", nullptr}, "list_append(arr, el)"},
-	{DEFAULT_SCHEMA, "list_prepend", {"e", "l", nullptr}, "list_concat(list_value(e), l)"},
-	{DEFAULT_SCHEMA, "array_prepend", {"el", "arr", nullptr}, "list_prepend(el, arr)"},
-	{DEFAULT_SCHEMA, "array_pop_back", {"arr", nullptr}, "arr[:LEN(arr)-1]"},
-	{DEFAULT_SCHEMA, "array_pop_front", {"arr", nullptr}, "arr[2:]"},
-	{DEFAULT_SCHEMA, "array_push_back", {"arr", "e", nullptr}, "list_concat(arr, list_value(e))"},
-	{DEFAULT_SCHEMA, "array_push_front", {"arr", "e", nullptr}, "list_concat(list_value(e), arr)"},
-	{DEFAULT_SCHEMA, "generate_subscripts", {"arr", "dim", nullptr}, "unnest(generate_series(1, array_length(arr, dim)))"},
-	{DEFAULT_SCHEMA, "fdiv", {"x", "y", nullptr}, "floor(x/y)"},
-	{DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, "(x-y*floor(x/y))"},
-
-	// algebraic list aggregates
-	{DEFAULT_SCHEMA, "list_avg", {"l", nullptr}, "list_aggr(l, 'avg')"},
-	{DEFAULT_SCHEMA, "list_var_samp", {"l", nullptr}, "list_aggr(l, 'var_samp')"},
-	{DEFAULT_SCHEMA, "list_var_pop", {"l", nullptr}, "list_aggr(l, 'var_pop')"},
-	{DEFAULT_SCHEMA, "list_stddev_pop", {"l", nullptr}, "list_aggr(l, 'stddev_pop')"},
-	{DEFAULT_SCHEMA, "list_stddev_samp", {"l", nullptr}, "list_aggr(l, 'stddev_samp')"},
-	{DEFAULT_SCHEMA, "list_sem", {"l", nullptr}, "list_aggr(l, 'sem')"},
-
-	// distributive list aggregates
-	{DEFAULT_SCHEMA, "list_approx_count_distinct", {"l", nullptr}, "list_aggr(l, 'approx_count_distinct')"},
-	{DEFAULT_SCHEMA, "list_bit_xor", {"l", nullptr}, "list_aggr(l, 'bit_xor')"},
-	{DEFAULT_SCHEMA, "list_bit_or", {"l", nullptr}, "list_aggr(l, 'bit_or')"},
-	{DEFAULT_SCHEMA, "list_bit_and", {"l", nullptr}, "list_aggr(l, 'bit_and')"},
-	{DEFAULT_SCHEMA, "list_bool_and", {"l", nullptr}, "list_aggr(l, 'bool_and')"},
-	{DEFAULT_SCHEMA, "list_bool_or", {"l", nullptr}, "list_aggr(l, 'bool_or')"},
-	{DEFAULT_SCHEMA, "list_count", {"l", nullptr}, "list_aggr(l, 'count')"},
-	{DEFAULT_SCHEMA, "list_entropy", {"l", nullptr}, "list_aggr(l, 'entropy')"},
-	{DEFAULT_SCHEMA, "list_last", {"l", nullptr}, "list_aggr(l, 'last')"},
-	{DEFAULT_SCHEMA, "list_first", {"l", nullptr}, "list_aggr(l, 'first')"},
-	{DEFAULT_SCHEMA, "list_kurtosis", {"l", nullptr}, "list_aggr(l, 'kurtosis')"},
-	{DEFAULT_SCHEMA, "list_min", {"l", nullptr}, "list_aggr(l, 'min')"},
-	{DEFAULT_SCHEMA, "list_max", {"l", nullptr}, "list_aggr(l, 'max')"},
-	{DEFAULT_SCHEMA, "list_product", {"l", nullptr}, "list_aggr(l, 'product')"},
-	{DEFAULT_SCHEMA, "list_skewness", {"l", nullptr}, "list_aggr(l, 'skewness')"},
-	{DEFAULT_SCHEMA, "list_sum", {"l", nullptr}, "list_aggr(l, 'sum')"},
-	{DEFAULT_SCHEMA, "list_string_agg", {"l", nullptr}, "list_aggr(l, 'string_agg')"},
-
-	// holistic list aggregates
-	{DEFAULT_SCHEMA, "list_mode", {"l", nullptr}, "list_aggr(l, 'mode')"},
-	{DEFAULT_SCHEMA, "list_median", {"l", nullptr}, "list_aggr(l, 'median')"},
-	{DEFAULT_SCHEMA, "list_mad", {"l", nullptr}, "list_aggr(l, 'mad')"},
-
-	// nested list aggregates
-	{DEFAULT_SCHEMA, "list_histogram", {"l", nullptr}, "list_aggr(l, 'histogram')"},
-
-	{nullptr, nullptr, {nullptr}, nullptr}
-	};
-
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(DefaultMacro &default_macro, unique_ptr<MacroFunction> function) {
-	for (idx_t param_idx = 0; default_macro.parameters[param_idx] != nullptr; param_idx++) {
-		function->parameters.push_back(
-		    make_unique<ColumnRefExpression>(default_macro.parameters[param_idx]));
-	}
-
-	auto bind_info = make_unique<CreateMacroInfo>();
-	bind_info->schema = default_macro.schema;
-	bind_info->name = default_macro.name;
-	bind_info->temporary = true;
-	bind_info->internal = true;
-	bind_info->type = function->type == MacroType::TABLE_MACRO ? CatalogType::TABLE_MACRO_ENTRY : CatalogType::MACRO_ENTRY;
-	bind_info->function = move(function);
-	return bind_info;
-
-}
-
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(DefaultMacro &default_macro) {
-	// parse the expression
-	auto expressions = Parser::ParseExpressionList(default_macro.macro);
-	D_ASSERT(expressions.size() == 1);
-
-	auto result = make_unique<ScalarMacroFunction>(move(expressions[0]));
-	return CreateInternalTableMacroInfo(default_macro, move(result));
-}
-
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(DefaultMacro &default_macro) {
-	Parser parser;
-	parser.ParseQuery(default_macro.macro);
-	D_ASSERT(parser.statements.size() == 1);
-	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
-
-	auto &select = (SelectStatement &) *parser.statements[0];
-	auto result = make_unique<TableMacroFunction>(move(select.node));
-	return CreateInternalTableMacroInfo(default_macro, move(result));
-}
-
-static unique_ptr<CreateFunctionInfo> GetDefaultFunction(const string &input_schema, const string &input_name) {
-	auto schema = StringUtil::Lower(input_schema);
-	auto name = StringUtil::Lower(input_name);
-	for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
-		if (internal_macros[index].schema == schema && internal_macros[index].name == name) {
-			return DefaultFunctionGenerator::CreateInternalMacroInfo(internal_macros[index]);
-		}
-	}
-	return nullptr;
-}
-
-DefaultFunctionGenerator::DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry *schema)
-    : DefaultGenerator(catalog), schema(schema) {
-}
-
-unique_ptr<CatalogEntry> DefaultFunctionGenerator::CreateDefaultEntry(ClientContext &context,
-                                                                      const string &entry_name) {
-	auto info = GetDefaultFunction(schema->name, entry_name);
-	if (info) {
-		return make_unique_base<CatalogEntry, ScalarMacroCatalogEntry>(&catalog, schema, (CreateMacroInfo *)info.get());
-	}
-	return nullptr;
-}
-
-vector<string> DefaultFunctionGenerator::GetDefaultEntries() {
-	vector<string> result;
-	for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
-		if (internal_macros[index].schema == schema->name) {
-			result.emplace_back(internal_macros[index].name);
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct DefaultSchema {
-	const char *name;
-};
-
-static DefaultSchema internal_schemas[] = {{"information_schema"}, {"pg_catalog"}, {nullptr}};
-
-static bool GetDefaultSchema(const string &input_schema) {
-	auto schema = StringUtil::Lower(input_schema);
-	for (idx_t index = 0; internal_schemas[index].name != nullptr; index++) {
-		if (internal_schemas[index].name == schema) {
-			return true;
-		}
-	}
-	return false;
-}
-
-DefaultSchemaGenerator::DefaultSchemaGenerator(Catalog &catalog) : DefaultGenerator(catalog) {
-}
-
-unique_ptr<CatalogEntry> DefaultSchemaGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	if (GetDefaultSchema(entry_name)) {
-		return make_unique_base<CatalogEntry, SchemaCatalogEntry>(&catalog, StringUtil::Lower(entry_name), true);
-	}
-	return nullptr;
-}
-
-vector<string> DefaultSchemaGenerator::GetDefaultEntries() {
-	vector<string> result;
-	for (idx_t index = 0; internal_schemas[index].name != nullptr; index++) {
-		result.emplace_back(internal_schemas[index].name);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DefaultType {
-	const char *name;
-	LogicalTypeId type;
-};
-
-static DefaultType internal_types[] = {{"int", LogicalTypeId::INTEGER},
-                                       {"int4", LogicalTypeId::INTEGER},
-                                       {"signed", LogicalTypeId::INTEGER},
-                                       {"integer", LogicalTypeId::INTEGER},
-                                       {"integral", LogicalTypeId::INTEGER},
-                                       {"int32", LogicalTypeId::INTEGER},
-                                       {"varchar", LogicalTypeId::VARCHAR},
-                                       {"bpchar", LogicalTypeId::VARCHAR},
-                                       {"text", LogicalTypeId::VARCHAR},
-                                       {"string", LogicalTypeId::VARCHAR},
-                                       {"char", LogicalTypeId::VARCHAR},
-                                       {"nvarchar", LogicalTypeId::VARCHAR},
-                                       {"bytea", LogicalTypeId::BLOB},
-                                       {"blob", LogicalTypeId::BLOB},
-                                       {"varbinary", LogicalTypeId::BLOB},
-                                       {"binary", LogicalTypeId::BLOB},
-                                       {"int8", LogicalTypeId::BIGINT},
-                                       {"bigint", LogicalTypeId::BIGINT},
-                                       {"int64", LogicalTypeId::BIGINT},
-                                       {"long", LogicalTypeId::BIGINT},
-                                       {"oid", LogicalTypeId::BIGINT},
-                                       {"int2", LogicalTypeId::SMALLINT},
-                                       {"smallint", LogicalTypeId::SMALLINT},
-                                       {"short", LogicalTypeId::SMALLINT},
-                                       {"int16", LogicalTypeId::SMALLINT},
-                                       {"timestamp", LogicalTypeId::TIMESTAMP},
-                                       {"datetime", LogicalTypeId::TIMESTAMP},
-                                       {"timestamp_us", LogicalTypeId::TIMESTAMP},
-                                       {"timestamp_ms", LogicalTypeId::TIMESTAMP_MS},
-                                       {"timestamp_ns", LogicalTypeId::TIMESTAMP_NS},
-                                       {"timestamp_s", LogicalTypeId::TIMESTAMP_SEC},
-                                       {"bool", LogicalTypeId::BOOLEAN},
-                                       {"boolean", LogicalTypeId::BOOLEAN},
-                                       {"logical", LogicalTypeId::BOOLEAN},
-                                       {"decimal", LogicalTypeId::DECIMAL},
-                                       {"dec", LogicalTypeId::DECIMAL},
-                                       {"numeric", LogicalTypeId::DECIMAL},
-                                       {"real", LogicalTypeId::FLOAT},
-                                       {"float4", LogicalTypeId::FLOAT},
-                                       {"float", LogicalTypeId::FLOAT},
-                                       {"double", LogicalTypeId::DOUBLE},
-                                       {"float8", LogicalTypeId::DOUBLE},
-                                       {"tinyint", LogicalTypeId::TINYINT},
-                                       {"int1", LogicalTypeId::TINYINT},
-                                       {"date", LogicalTypeId::DATE},
-                                       {"time", LogicalTypeId::TIME},
-                                       {"interval", LogicalTypeId::INTERVAL},
-                                       {"hugeint", LogicalTypeId::HUGEINT},
-                                       {"int128", LogicalTypeId::HUGEINT},
-                                       {"uuid", LogicalTypeId::UUID},
-                                       {"guid", LogicalTypeId::UUID},
-                                       {"struct", LogicalTypeId::STRUCT},
-                                       {"row", LogicalTypeId::STRUCT},
-                                       {"list", LogicalTypeId::LIST},
-                                       {"map", LogicalTypeId::MAP},
-                                       {"utinyint", LogicalTypeId::UTINYINT},
-                                       {"uint8", LogicalTypeId::UTINYINT},
-                                       {"usmallint", LogicalTypeId::USMALLINT},
-                                       {"uint16", LogicalTypeId::USMALLINT},
-                                       {"uinteger", LogicalTypeId::UINTEGER},
-                                       {"uint32", LogicalTypeId::UINTEGER},
-                                       {"ubigint", LogicalTypeId::UBIGINT},
-                                       {"uint64", LogicalTypeId::UBIGINT},
-                                       {"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
-                                       {"timetz", LogicalTypeId::TIME_TZ},
-                                       {"json", LogicalTypeId::JSON},
-                                       {"null", LogicalTypeId::SQLNULL},
-                                       {nullptr, LogicalTypeId::INVALID}};
-
-LogicalTypeId DefaultTypeGenerator::GetDefaultType(const string &name) {
-	auto lower_str = StringUtil::Lower(name);
-	for (idx_t index = 0; internal_types[index].name != nullptr; index++) {
-		if (internal_types[index].name == lower_str) {
-			return internal_types[index].type;
-		}
-	}
-	return LogicalTypeId::INVALID;
-}
-
-DefaultTypeGenerator::DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry *schema)
-    : DefaultGenerator(catalog), schema(schema) {
-}
-
-unique_ptr<CatalogEntry> DefaultTypeGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	if (schema->name != DEFAULT_SCHEMA) {
-		return nullptr;
-	}
-	auto type_id = GetDefaultType(entry_name);
-	if (type_id == LogicalTypeId::INVALID) {
-		return nullptr;
-	}
-	CreateTypeInfo info;
-	info.name = entry_name;
-	info.type = LogicalType(type_id);
-	info.internal = true;
-	info.temporary = true;
-	return make_unique_base<CatalogEntry, TypeCatalogEntry>(&catalog, schema, &info);
-}
-
-vector<string> DefaultTypeGenerator::GetDefaultEntries() {
-	vector<string> result;
-	if (schema->name != DEFAULT_SCHEMA) {
-		return result;
-	}
-	for (idx_t index = 0; internal_types[index].name != nullptr; index++) {
-		result.emplace_back(internal_types[index].name);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DefaultView {
-	const char *schema;
-	const char *name;
-	const char *sql;
-};
-
-static DefaultView internal_views[] = {
-    {DEFAULT_SCHEMA, "pragma_database_list", "SELECT * FROM pragma_database_list()"},
-    {DEFAULT_SCHEMA, "sqlite_master", "select 'table' \"type\", table_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_tables union all select 'view' \"type\", view_name \"name\", view_name \"tbl_name\", 0 rootpage, sql from duckdb_views union all select 'index' \"type\", index_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_indexes;"},
-    {DEFAULT_SCHEMA, "sqlite_schema", "SELECT * FROM sqlite_master"},
-    {DEFAULT_SCHEMA, "sqlite_temp_master", "SELECT * FROM sqlite_master"},
-    {DEFAULT_SCHEMA, "sqlite_temp_schema", "SELECT * FROM sqlite_master"},
-    {DEFAULT_SCHEMA, "duckdb_constraints", "SELECT * FROM duckdb_constraints()"},
-    {DEFAULT_SCHEMA, "duckdb_columns", "SELECT * FROM duckdb_columns() WHERE NOT internal"},
-    {DEFAULT_SCHEMA, "duckdb_indexes", "SELECT * FROM duckdb_indexes()"},
-    {DEFAULT_SCHEMA, "duckdb_schemas", "SELECT * FROM duckdb_schemas() WHERE NOT internal"},
-    {DEFAULT_SCHEMA, "duckdb_tables", "SELECT * FROM duckdb_tables() WHERE NOT internal"},
-    {DEFAULT_SCHEMA, "duckdb_types", "SELECT * FROM duckdb_types()"},
-    {DEFAULT_SCHEMA, "duckdb_views", "SELECT * FROM duckdb_views() WHERE NOT internal"},
-    {"pg_catalog", "pg_am", "SELECT 0 oid, 'art' amname, NULL amhandler, 'i' amtype"},
-    {"pg_catalog", "pg_attribute", "SELECT table_oid attrelid, column_name attname, data_type_id atttypid, 0 attstattarget, NULL attlen, column_index attnum, 0 attndims, -1 attcacheoff, case when data_type ilike '%decimal%' then numeric_precision*1000+numeric_scale else -1 end atttypmod, false attbyval, NULL attstorage, NULL attalign, NOT is_nullable attnotnull, column_default IS NOT NULL atthasdef, false atthasmissing, '' attidentity, '' attgenerated, false attisdropped, true attislocal, 0 attinhcount, 0 attcollation, NULL attcompression, NULL attacl, NULL attoptions, NULL attfdwoptions, NULL attmissingval FROM duckdb_columns()"},
-    {"pg_catalog", "pg_attrdef", "SELECT column_index oid, table_oid adrelid, column_index adnum, column_default adbin from duckdb_columns() where column_default is not null;"},
-    {"pg_catalog", "pg_class", "SELECT table_oid oid, table_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, estimated_size::real reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, index_count > 0 relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'r' relkind, column_count relnatts, check_constraint_count relchecks, false relhasoids, has_primary_key relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_tables() UNION ALL SELECT view_oid oid, view_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'v' relkind, column_count relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_views() UNION ALL SELECT sequence_oid oid, sequence_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'S' relkind, 0 relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_sequences() UNION ALL SELECT index_oid oid, index_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, 't' relpersistence, 'i' relkind, NULL relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_indexes()"},
-    {"pg_catalog", "pg_constraint", "SELECT table_oid*1000000+constraint_index oid, constraint_text conname, schema_oid connamespace, CASE WHEN constraint_type='CHECK' then 'c' WHEN constraint_type='UNIQUE' then 'u' WHEN constraint_type='PRIMARY KEY' THEN 'p' ELSE 'x' END contype, false condeferrable, false condeferred, true convalidated, table_oid conrelid, 0 contypid, 0 conindid, 0 conparentid, 0 confrelid, NULL confupdtype, NULL confdeltype, NULL confmatchtype, true conislocal, 0 coninhcount, false connoinherit, constraint_column_indexes conkey, NULL confkey, NULL conpfeqop, NULL conppeqop, NULL conffeqop, NULL conexclop, expression conbin FROM duckdb_constraints()"},
-    {"pg_catalog", "pg_depend", "SELECT * FROM duckdb_dependencies()"},
-	{"pg_catalog", "pg_description", "SELECT NULL objoid, NULL classoid, NULL objsubid, NULL description WHERE 1=0"},
-    {"pg_catalog", "pg_enum", "SELECT NULL oid, NULL enumtypid, NULL enumsortorder, NULL enumlabel WHERE 1=0"},
-    {"pg_catalog", "pg_index", "SELECT index_oid indexrelid, table_oid indrelid, 0 indnatts, 0 indnkeyatts, is_unique indisunique, is_primary indisprimary, false indisexclusion, true indimmediate, false indisclustered, true indisvalid, false indcheckxmin, true indisready, true indislive, false indisreplident, NULL::INT[] indkey, NULL::OID[] indcollation, NULL::OID[] indclass, NULL::INT[] indoption, expressions indexprs, NULL indpred FROM duckdb_indexes()"},
-    {"pg_catalog", "pg_indexes", "SELECT schema_name schemaname, table_name tablename, index_name indexname, NULL \"tablespace\", sql indexdef FROM duckdb_indexes()"},
-    {"pg_catalog", "pg_namespace", "SELECT oid, schema_name nspname, 0 nspowner, NULL nspacl FROM duckdb_schemas()"},
-    {"pg_catalog", "pg_sequence", "SELECT sequence_oid seqrelid, 0 seqtypid, start_value seqstart, increment_by seqincrement, max_value seqmax, min_value seqmin, 0 seqcache, cycle seqcycle FROM duckdb_sequences()"},
-	{"pg_catalog", "pg_sequences", "SELECT schema_name schemaname, sequence_name sequencename, 'duckdb' sequenceowner, 0 data_type, start_value, min_value, max_value, increment_by, cycle, 0 cache_size, last_value FROM duckdb_sequences()"},
-    {"pg_catalog", "pg_tables", "SELECT schema_name schemaname, table_name tablename, 'duckdb' tableowner, NULL \"tablespace\", index_count > 0 hasindexes, false hasrules, false hastriggers FROM duckdb_tables()"},
-    {"pg_catalog", "pg_tablespace", "SELECT 0 oid, 'pg_default' spcname, 0 spcowner, NULL spcacl, NULL spcoptions"},
-    {"pg_catalog", "pg_type", "SELECT type_oid oid, format_pg_type(type_name) typname, schema_oid typnamespace, 0 typowner, type_size typlen, false typbyval, 'b' typtype, CASE WHEN type_category='NUMERIC' THEN 'N' WHEN type_category='STRING' THEN 'S' WHEN type_category='DATETIME' THEN 'D' WHEN type_category='BOOLEAN' THEN 'B' WHEN type_category='COMPOSITE' THEN 'C' WHEN type_category='USER' THEN 'U' ELSE 'X' END typcategory, false typispreferred, true typisdefined, NULL typdelim, NULL typrelid, NULL typsubscript, NULL typelem, NULL typarray, NULL typinput, NULL typoutput, NULL typreceive, NULL typsend, NULL typmodin, NULL typmodout, NULL typanalyze, 'd' typalign, 'p' typstorage, NULL typnotnull, NULL typbasetype, NULL typtypmod, NULL typndims, NULL typcollation, NULL typdefaultbin, NULL typdefault, NULL typacl FROM duckdb_types();"},
-    {"pg_catalog", "pg_views", "SELECT schema_name schemaname, view_name viewname, 'duckdb' viewowner, sql definition FROM duckdb_views()"},
-    {"information_schema", "columns", "SELECT NULL table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL datetime_precision, NULL interval_type, NULL interval_precision, NULL character_set_catalog, NULL character_set_schema, NULL character_set_name, NULL collation_catalog, NULL collation_schema, NULL collation_name, NULL domain_catalog, NULL domain_schema, NULL domain_name, NULL udt_catalog, NULL udt_schema, NULL udt_name, NULL scope_catalog, NULL scope_schema, NULL scope_name, NULL maximum_cardinality, NULL dtd_identifier, NULL is_self_referencing, NULL is_identity, NULL identity_generation, NULL identity_start, NULL identity_increment, NULL identity_maximum, NULL identity_minimum, NULL identity_cycle, NULL is_generated, NULL generation_expression, NULL is_updatable FROM duckdb_columns;"},
-    {"information_schema", "schemata", "SELECT NULL catalog_name, schema_name, 'duckdb' schema_owner, NULL default_character_set_catalog, NULL default_character_set_schema, NULL default_character_set_name, sql sql_path FROM duckdb_schemas()"},
-    {"information_schema", "tables", "SELECT NULL table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action FROM duckdb_tables() UNION ALL SELECT NULL table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action FROM duckdb_views;"},
-    {nullptr, nullptr, nullptr}};
-
-static unique_ptr<CreateViewInfo> GetDefaultView(const string &input_schema, const string &input_name) {
-	auto schema = StringUtil::Lower(input_schema);
-	auto name = StringUtil::Lower(input_name);
-	for (idx_t index = 0; internal_views[index].name != nullptr; index++) {
-		if (internal_views[index].schema == schema && internal_views[index].name == name) {
-			auto result = make_unique<CreateViewInfo>();
-			result->schema = schema;
-			result->sql = internal_views[index].sql;
-
-			Parser parser;
-			parser.ParseQuery(internal_views[index].sql);
-			D_ASSERT(parser.statements.size() == 1 && parser.statements[0]->type == StatementType::SELECT_STATEMENT);
-			result->query = unique_ptr_cast<SQLStatement, SelectStatement>(move(parser.statements[0]));
-			result->temporary = true;
-			result->internal = true;
-			result->view_name = name;
-			return result;
-		}
-	}
-	return nullptr;
-}
-
-DefaultViewGenerator::DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry *schema)
-    : DefaultGenerator(catalog), schema(schema) {
-}
-
-unique_ptr<CatalogEntry> DefaultViewGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	auto info = GetDefaultView(schema->name, entry_name);
-	if (info) {
-		auto binder = Binder::CreateBinder(context);
-		binder->BindCreateViewInfo(*info);
-
-		return make_unique_base<CatalogEntry, ViewCatalogEntry>(&catalog, schema, info.get());
-	}
-	return nullptr;
-}
-
-vector<string> DefaultViewGenerator::GetDefaultEntries() {
-	vector<string> result;
-	for (idx_t index = 0; internal_views[index].name != nullptr; index++) {
-		if (internal_views[index].schema == schema->name) {
-			result.emplace_back(internal_views[index].name);
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-DependencyManager::DependencyManager(Catalog &catalog) : catalog(catalog) {
-}
-
-void DependencyManager::AddObject(ClientContext &context, CatalogEntry *object,
-                                  unordered_set<CatalogEntry *> &dependencies) {
-	// check for each object in the sources if they were not deleted yet
-	for (auto &dependency : dependencies) {
-		idx_t entry_index;
-		CatalogEntry *catalog_entry;
-		if (!dependency->set) {
-			throw InternalException("Dependency has no set");
-		}
-		if (!dependency->set->GetEntryInternal(context, dependency->name, entry_index, catalog_entry)) {
-			throw InternalException("Dependency has already been deleted?");
-		}
-	}
-	// indexes do not require CASCADE to be dropped, they are simply always dropped along with the table
-	auto dependency_type = object->type == CatalogType::INDEX_ENTRY ? DependencyType::DEPENDENCY_AUTOMATIC
-	                                                                : DependencyType::DEPENDENCY_REGULAR;
-	// add the object to the dependents_map of each object that it depends on
-	for (auto &dependency : dependencies) {
-		dependents_map[dependency].insert(Dependency(object, dependency_type));
-	}
-	// create the dependents map for this object: it starts out empty
-	dependents_map[object] = dependency_set_t();
-	dependencies_map[object] = dependencies;
-}
-
-void DependencyManager::DropObject(ClientContext &context, CatalogEntry *object, bool cascade) {
-	D_ASSERT(dependents_map.find(object) != dependents_map.end());
-
-	// first check the objects that depend on this object
-	auto &dependent_objects = dependents_map[object];
-	for (auto &dep : dependent_objects) {
-		// look up the entry in the catalog set
-		auto &catalog_set = *dep.entry->set;
-		auto mapping_value = catalog_set.GetMapping(context, dep.entry->name, true /* get_latest */);
-		if (mapping_value == nullptr) {
-			continue;
-		}
-		idx_t entry_index = mapping_value->index;
-		CatalogEntry *dependency_entry;
-
-		if (!catalog_set.GetEntryInternal(context, entry_index, dependency_entry)) {
-			// the dependent object was already deleted, no conflict
-			continue;
-		}
-		// conflict: attempting to delete this object but the dependent object still exists
-		if (cascade || dep.dependency_type == DependencyType::DEPENDENCY_AUTOMATIC ||
-		    dep.dependency_type == DependencyType::DEPENDENCY_OWNS) {
-			// cascade: drop the dependent object
-			catalog_set.DropEntryInternal(context, entry_index, *dependency_entry, cascade);
-		} else {
-			// no cascade and there are objects that depend on this object: throw error
-			throw CatalogException("Cannot drop entry \"%s\" because there are entries that "
-			                       "depend on it. Use DROP...CASCADE to drop all dependents.",
-			                       object->name);
-		}
-	}
-}
-
-void DependencyManager::AlterObject(ClientContext &context, CatalogEntry *old_obj, CatalogEntry *new_obj) {
-	D_ASSERT(dependents_map.find(old_obj) != dependents_map.end());
-	D_ASSERT(dependencies_map.find(old_obj) != dependencies_map.end());
-
-	// first check the objects that depend on this object
-	vector<CatalogEntry *> owned_objects_to_add;
-	auto &dependent_objects = dependents_map[old_obj];
-	for (auto &dep : dependent_objects) {
-		// look up the entry in the catalog set
-		auto &catalog_set = *dep.entry->set;
-		idx_t entry_index;
-		CatalogEntry *dependency_entry;
-		if (!catalog_set.GetEntryInternal(context, dep.entry->name, entry_index, dependency_entry)) {
-			// the dependent object was already deleted, no conflict
-			continue;
-		}
-		if (dep.dependency_type == DependencyType::DEPENDENCY_OWNS) {
-			// the dependent object is owned by the current object
-			owned_objects_to_add.push_back(dep.entry);
-			continue;
-		}
-		// conflict: attempting to alter this object but the dependent object still exists
-		// no cascade and there are objects that depend on this object: throw error
-		throw CatalogException("Cannot alter entry \"%s\" because there are entries that "
-		                       "depend on it.",
-		                       old_obj->name);
-	}
-	// add the new object to the dependents_map of each object that it depends on
-	auto &old_dependencies = dependencies_map[old_obj];
-	vector<CatalogEntry *> to_delete;
-	for (auto &dependency : old_dependencies) {
-		if (dependency->type == CatalogType::TYPE_ENTRY) {
-			auto user_type = (TypeCatalogEntry *)dependency;
-			auto table = (TableCatalogEntry *)new_obj;
-			bool deleted_dependency = true;
-			for (auto &column : table->columns) {
-				if (column.Type() == user_type->user_type) {
-					deleted_dependency = false;
-					break;
-				}
-			}
-			if (deleted_dependency) {
-				to_delete.push_back(dependency);
-				continue;
-			}
-		}
-		dependents_map[dependency].insert(new_obj);
-	}
-	for (auto &dependency : to_delete) {
-		old_dependencies.erase(dependency);
-		dependents_map[dependency].erase(old_obj);
-	}
-
-	// We might have to add a type dependency
-	vector<CatalogEntry *> to_add;
-	if (new_obj->type == CatalogType::TABLE_ENTRY) {
-		auto table = (TableCatalogEntry *)new_obj;
-		for (auto &column : table->columns) {
-			auto user_type_catalog = LogicalType::GetCatalog(column.Type());
-			if (user_type_catalog) {
-				to_add.push_back(user_type_catalog);
-			}
-		}
-	}
-	// add the new object to the dependency manager
-	dependents_map[new_obj] = dependency_set_t();
-	dependencies_map[new_obj] = old_dependencies;
-
-	for (auto &dependency : to_add) {
-		dependencies_map[new_obj].insert(dependency);
-		dependents_map[dependency].insert(new_obj);
-	}
-
-	for (auto &dependency : owned_objects_to_add) {
-		dependents_map[new_obj].insert(Dependency(dependency, DependencyType::DEPENDENCY_OWNS));
-		dependents_map[dependency].insert(Dependency(new_obj, DependencyType::DEPENDENCY_OWNED_BY));
-		dependencies_map[new_obj].insert(dependency);
-	}
-}
-
-void DependencyManager::EraseObject(CatalogEntry *object) {
-	// obtain the writing lock
-	EraseObjectInternal(object);
-}
-
-void DependencyManager::EraseObjectInternal(CatalogEntry *object) {
-	if (dependents_map.find(object) == dependents_map.end()) {
-		// dependencies already removed
-		return;
-	}
-	D_ASSERT(dependents_map.find(object) != dependents_map.end());
-	D_ASSERT(dependencies_map.find(object) != dependencies_map.end());
-	// now for each of the dependencies, erase the entries from the dependents_map
-	for (auto &dependency : dependencies_map[object]) {
-		auto entry = dependents_map.find(dependency);
-		if (entry != dependents_map.end()) {
-			D_ASSERT(entry->second.find(object) != entry->second.end());
-			entry->second.erase(object);
-		}
-	}
-	// erase the dependents and dependencies for this object
-	dependents_map.erase(object);
-	dependencies_map.erase(object);
-}
-
-void DependencyManager::Scan(const std::function<void(CatalogEntry *, CatalogEntry *, DependencyType)> &callback) {
-	lock_guard<mutex> write_lock(catalog.write_lock);
-	for (auto &entry : dependents_map) {
-		for (auto &dependent : entry.second) {
-			callback(entry.first, dependent.entry, dependent.dependency_type);
-		}
-	}
-}
-
-void DependencyManager::AddOwnership(ClientContext &context, CatalogEntry *owner, CatalogEntry *entry) {
-	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.write_lock);
-
-	// If the owner is already owned by something else, throw an error
-	for (auto &dep : dependents_map[owner]) {
-		if (dep.dependency_type == DependencyType::DEPENDENCY_OWNED_BY) {
-			throw CatalogException(owner->name + " already owned by " + dep.entry->name);
-		}
-	}
-
-	// If the entry is already owned, throw an error
-	for (auto &dep : dependents_map[entry]) {
-		// if the entry is already owned, throw error
-		if (dep.entry != owner) {
-			throw CatalogException(entry->name + " already depends on " + dep.entry->name);
-		}
-		// if the entry owns the owner, throw error
-		if (dep.entry == owner && dep.dependency_type == DependencyType::DEPENDENCY_OWNS) {
-			throw CatalogException(entry->name + " already owns " + owner->name +
-			                       ". Cannot have circular dependencies");
-		}
-	}
-
-	// Emplace guarantees that the same object cannot be inserted twice in the unordered_set
-	// In the case AddOwnership is called twice, because of emplace, the object will not be repeated in the set.
-	// We use an automatic dependency because if the Owner gets deleted, then the owned objects are also deleted
-	dependents_map[owner].emplace(Dependency(entry, DependencyType::DEPENDENCY_OWNS));
-	dependents_map[entry].emplace(Dependency(owner, DependencyType::DEPENDENCY_OWNED_BY));
-	dependencies_map[owner].emplace(entry);
-}
-
-} // namespace duckdb
-
-
-
-
-#ifdef DUCKDB_DEBUG_ALLOCATION
-
-
-
-#include <execinfo.h>
-#endif
-
-namespace duckdb {
-
-AllocatedData::AllocatedData(Allocator &allocator, data_ptr_t pointer, idx_t allocated_size)
-    : allocator(allocator), pointer(pointer), allocated_size(allocated_size) {
-}
-AllocatedData::~AllocatedData() {
-	Reset();
-}
-
-void AllocatedData::Reset() {
-	if (!pointer) {
-		return;
-	}
-	allocator.FreeData(pointer, allocated_size);
-	pointer = nullptr;
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Info
-//===--------------------------------------------------------------------===//
-struct AllocatorDebugInfo {
-#ifdef DEBUG
-	AllocatorDebugInfo();
-	~AllocatorDebugInfo();
-
-	static string GetStackTrace(int max_depth = 128);
-
-	void AllocateData(data_ptr_t pointer, idx_t size);
-	void FreeData(data_ptr_t pointer, idx_t size);
-	void ReallocateData(data_ptr_t pointer, data_ptr_t new_pointer, idx_t old_size, idx_t new_size);
-
-private:
-	//! The number of bytes that are outstanding (i.e. that have been allocated - but not freed)
-	//! Used for debug purposes
-	atomic<idx_t> allocation_count;
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	mutex pointer_lock;
-	//! Set of active outstanding pointers together with stack traces
-	unordered_map<data_ptr_t, pair<idx_t, string>> pointers;
-#endif
-#endif
-};
-
-PrivateAllocatorData::PrivateAllocatorData() {
-}
-
-PrivateAllocatorData::~PrivateAllocatorData() {
-}
-
-//===--------------------------------------------------------------------===//
-// Allocator
-//===--------------------------------------------------------------------===//
-Allocator::Allocator()
-    : Allocator(Allocator::DefaultAllocate, Allocator::DefaultFree, Allocator::DefaultReallocate, nullptr) {
-}
-
-Allocator::Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p,
-                     reallocate_function_ptr_t reallocate_function_p, unique_ptr<PrivateAllocatorData> private_data_p)
-    : allocate_function(allocate_function_p), free_function(free_function_p),
-      reallocate_function(reallocate_function_p), private_data(move(private_data_p)) {
-	D_ASSERT(allocate_function);
-	D_ASSERT(free_function);
-	D_ASSERT(reallocate_function);
-#ifdef DEBUG
-	if (!private_data) {
-		private_data = make_unique<PrivateAllocatorData>();
-	}
-	private_data->debug_info = make_unique<AllocatorDebugInfo>();
-#endif
-}
-
-Allocator::~Allocator() {
-}
-
-data_ptr_t Allocator::AllocateData(idx_t size) {
-	auto result = allocate_function(private_data.get(), size);
-#ifdef DEBUG
-	D_ASSERT(private_data);
-	private_data->debug_info->AllocateData(result, size);
-#endif
-	return result;
-}
-
-void Allocator::FreeData(data_ptr_t pointer, idx_t size) {
-	if (!pointer) {
-		return;
-	}
-#ifdef DEBUG
-	D_ASSERT(private_data);
-	private_data->debug_info->FreeData(pointer, size);
-#endif
-	free_function(private_data.get(), pointer, size);
-}
-
-data_ptr_t Allocator::ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t size) {
-	if (!pointer) {
-		return nullptr;
-	}
-	auto new_pointer = reallocate_function(private_data.get(), pointer, old_size, size);
-#ifdef DEBUG
-	D_ASSERT(private_data);
-	private_data->debug_info->ReallocateData(pointer, new_pointer, old_size, size);
-#endif
-	return new_pointer;
-}
-
-Allocator &Allocator::DefaultAllocator() {
-	static Allocator DEFAULT_ALLOCATOR;
-	return DEFAULT_ALLOCATOR;
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Info (extended)
-//===--------------------------------------------------------------------===//
-#ifdef DEBUG
-AllocatorDebugInfo::AllocatorDebugInfo() {
-	allocation_count = 0;
-}
-AllocatorDebugInfo::~AllocatorDebugInfo() {
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	if (allocation_count != 0) {
-		printf("Outstanding allocations found for Allocator\n");
-		for (auto &entry : pointers) {
-			printf("Allocation of size %lld at address %p\n", entry.second.first, (void *)entry.first);
-			printf("Stack trace:\n%s\n", entry.second.second.c_str());
-			printf("\n");
-		}
-	}
-#endif
-	//! Verify that there is no outstanding memory still associated with the batched allocator
-	//! Only works for access to the batched allocator through the batched allocator interface
-	//! If this assertion triggers, enable DUCKDB_DEBUG_ALLOCATION for more information about the allocations
-	D_ASSERT(allocation_count == 0);
-}
-
-string AllocatorDebugInfo::GetStackTrace(int max_depth) {
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	string result;
-	auto callstack = unique_ptr<void *[]>(new void *[max_depth]);
-	int frames = backtrace(callstack.get(), max_depth);
-	char **strs = backtrace_symbols(callstack.get(), frames);
-	for (int i = 0; i < frames; i++) {
-		result += strs[i];
-		result += "\n";
-	}
-	free(strs);
-	return result;
-#else
-	throw InternalException("GetStackTrace not supported without DUCKDB_DEBUG_ALLOCATION");
-#endif
-}
-
-void AllocatorDebugInfo::AllocateData(data_ptr_t pointer, idx_t size) {
-	allocation_count += size;
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	lock_guard<mutex> l(pointer_lock);
-	pointers[pointer] = make_pair(size, GetStackTrace());
-#endif
-}
-
-void AllocatorDebugInfo::FreeData(data_ptr_t pointer, idx_t size) {
-	D_ASSERT(allocation_count >= size);
-	allocation_count -= size;
-#ifdef DUCKDB_DEBUG_ALLOCATION
-	lock_guard<mutex> l(pointer_lock);
-	// verify that the pointer exists
-	D_ASSERT(pointers.find(pointer) != pointers.end());
-	// verify that the stored size matches the passed in size
-	D_ASSERT(pointers[pointer].first == size);
-	// erase the pointer
-	pointers.erase(pointer);
-#endif
-}
-
-void AllocatorDebugInfo::ReallocateData(data_ptr_t pointer, data_ptr_t new_pointer, idx_t old_size, idx_t new_size) {
-	FreeData(pointer, old_size);
-	AllocateData(new_pointer, new_size);
-}
-
-#endif
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-ArrowSchemaWrapper::~ArrowSchemaWrapper() {
-	if (arrow_schema.release) {
-		for (int64_t child_idx = 0; child_idx < arrow_schema.n_children; child_idx++) {
-			auto &child = *arrow_schema.children[child_idx];
-			if (child.release) {
-				child.release(&child);
-			}
-		}
-		arrow_schema.release(&arrow_schema);
-		arrow_schema.release = nullptr;
-	}
-}
-
-ArrowArrayWrapper::~ArrowArrayWrapper() {
-	if (arrow_array.release) {
-		for (int64_t child_idx = 0; child_idx < arrow_array.n_children; child_idx++) {
-			auto &child = *arrow_array.children[child_idx];
-			if (child.release) {
-				child.release(&child);
-			}
-		}
-		arrow_array.release(&arrow_array);
-		arrow_array.release = nullptr;
-	}
-}
-
-ArrowArrayStreamWrapper::~ArrowArrayStreamWrapper() {
-	if (arrow_array_stream.release) {
-		arrow_array_stream.release(&arrow_array_stream);
-		arrow_array_stream.release = nullptr;
-	}
-}
-
-void ArrowArrayStreamWrapper::GetSchema(ArrowSchemaWrapper &schema) {
-	D_ASSERT(arrow_array_stream.get_schema);
-	// LCOV_EXCL_START
-	if (arrow_array_stream.get_schema(&arrow_array_stream, &schema.arrow_schema)) {
-		throw InvalidInputException("arrow_scan: get_schema failed(): %s", string(GetError()));
-	}
-	if (!schema.arrow_schema.release) {
-		throw InvalidInputException("arrow_scan: released schema passed");
-	}
-	if (schema.arrow_schema.n_children < 1) {
-		throw InvalidInputException("arrow_scan: empty schema passed");
-	}
-	// LCOV_EXCL_STOP
-}
-
-shared_ptr<ArrowArrayWrapper> ArrowArrayStreamWrapper::GetNextChunk() {
-	auto current_chunk = make_shared<ArrowArrayWrapper>();
-	if (arrow_array_stream.get_next(&arrow_array_stream, &current_chunk->arrow_array)) { // LCOV_EXCL_START
-		throw InvalidInputException("arrow_scan: get_next failed(): %s", string(GetError()));
-	} // LCOV_EXCL_STOP
-
-	return current_chunk;
-}
-
-const char *ArrowArrayStreamWrapper::GetError() { // LCOV_EXCL_START
-	return arrow_array_stream.get_last_error(&arrow_array_stream);
-} // LCOV_EXCL_STOP
-
-int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out) {
-	if (!stream->release) {
-		return -1;
-	}
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
-	if (!my_stream->column_types.empty()) {
-		QueryResult::ToArrowSchema(out, my_stream->column_types, my_stream->column_names, my_stream->timezone_config);
-		return 0;
-	}
-
-	auto &result = *my_stream->result;
-	if (!result.success) {
-		my_stream->last_error = "Query Failed";
-		return -1;
-	}
-	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = (StreamQueryResult &)result;
-		if (!stream_result.IsOpen()) {
-			my_stream->last_error = "Query Stream is closed";
-			return -1;
-		}
-	}
-	if (my_stream->column_types.empty()) {
-		my_stream->column_types = result.types;
-		my_stream->column_names = result.names;
-	}
-	QueryResult::ToArrowSchema(out, my_stream->column_types, my_stream->column_names, my_stream->timezone_config);
-	return 0;
-}
-
-int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *out) {
-	if (!stream->release) {
-		return -1;
-	}
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
-	auto &result = *my_stream->result;
-	if (!result.success) {
-		my_stream->last_error = "Query Failed";
-		return -1;
-	}
-	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = (StreamQueryResult &)result;
-		if (!stream_result.IsOpen()) {
-			// Nothing to output
-			out->release = nullptr;
-			return 0;
-		}
-	}
-	if (my_stream->column_types.empty()) {
-		my_stream->column_types = result.types;
-		my_stream->column_names = result.names;
-	}
-	unique_ptr<DataChunk> chunk_result = result.Fetch();
-	if (!chunk_result) {
-		// Nothing to output
-		out->release = nullptr;
-		return 0;
-	}
-	unique_ptr<DataChunk> agg_chunk_result = make_unique<DataChunk>();
-	agg_chunk_result->Initialize(Allocator::DefaultAllocator(), chunk_result->GetTypes());
-	agg_chunk_result->Append(*chunk_result, true);
-
-	while (agg_chunk_result->size() < my_stream->batch_size) {
-		auto new_chunk = result.Fetch();
-		if (!new_chunk) {
-			break;
-		} else {
-			agg_chunk_result->Append(*new_chunk, true);
-		}
-	}
-	agg_chunk_result->ToArrowArray(out);
-	return 0;
-}
-
-void ResultArrowArrayStreamWrapper::MyStreamRelease(struct ArrowArrayStream *stream) {
-	if (!stream->release) {
-		return;
-	}
-	stream->release = nullptr;
-	delete (ResultArrowArrayStreamWrapper *)stream->private_data;
-}
-
-const char *ResultArrowArrayStreamWrapper::MyStreamGetLastError(struct ArrowArrayStream *stream) {
-	if (!stream->release) {
-		return "stream was released";
-	}
-	D_ASSERT(stream->private_data);
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
-	return my_stream->last_error.c_str();
-}
-ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result_p, idx_t batch_size_p)
-    : result(move(result_p)) {
-	//! We first initialize the private data of the stream
-	stream.private_data = this;
-	//! Ceil Approx_Batch_Size/STANDARD_VECTOR_SIZE
-	if (batch_size_p == 0) {
-		throw std::runtime_error("Approximate Batch Size of Record Batch MUST be higher than 0");
-	}
-	batch_size = batch_size_p;
-	//! We initialize the stream functions
-	stream.get_schema = ResultArrowArrayStreamWrapper::MyStreamGetSchema;
-	stream.get_next = ResultArrowArrayStreamWrapper::MyStreamGetNext;
-	stream.release = ResultArrowArrayStreamWrapper::MyStreamRelease;
-	stream.get_last_error = ResultArrowArrayStreamWrapper::MyStreamGetLastError;
-}
-
-unique_ptr<DataChunk> ArrowUtil::FetchNext(QueryResult &result) {
-	auto chunk = result.Fetch();
-	if (!result.success) {
-		throw std::runtime_error(result.error);
-	}
-	return chunk;
-}
-
-unique_ptr<DataChunk> ArrowUtil::FetchChunk(QueryResult *result, idx_t chunk_size) {
-
-	auto data_chunk = FetchNext(*result);
-	if (!data_chunk) {
-		return data_chunk;
-	}
-	while (data_chunk->size() < chunk_size) {
-		auto next_chunk = FetchNext(*result);
-		if (!next_chunk || next_chunk->size() == 0) {
-			break;
-		}
-		data_chunk->Append(*next_chunk, true);
-	}
-	return data_chunk;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr) {
-	if (condition) {
-		return;
-	}
-	throw InternalException("Assertion triggered in file \"%s\" on line %d: %s", file, linenr, condition_name);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-uint64_t Checksum(uint8_t *buffer, size_t size) {
-	uint64_t result = 5381;
-	uint64_t *ptr = (uint64_t *)buffer;
-	size_t i;
-	// for efficiency, we first hash uint64_t values
-	for (i = 0; i < size / 8; i++) {
-		result ^= Hash(ptr[i]);
-	}
-	if (size - i * 8 > 0) {
-		// the remaining 0-7 bytes we hash using a string hash
-		result ^= Hash(buffer + i * 8, size - i * 8);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-StreamWrapper::~StreamWrapper() {
-}
-
-CompressedFile::CompressedFile(CompressedFileSystem &fs, unique_ptr<FileHandle> child_handle_p, const string &path)
-    : FileHandle(fs, path), compressed_fs(fs), child_handle(move(child_handle_p)) {
-}
-
-CompressedFile::~CompressedFile() {
-	Close();
-}
-
-void CompressedFile::Initialize(bool write) {
-	Close();
-
-	this->write = write;
-	stream_data.in_buf_size = compressed_fs.InBufferSize();
-	stream_data.out_buf_size = compressed_fs.OutBufferSize();
-	stream_data.in_buff = unique_ptr<data_t[]>(new data_t[stream_data.in_buf_size]);
-	stream_data.in_buff_start = stream_data.in_buff.get();
-	stream_data.in_buff_end = stream_data.in_buff.get();
-	stream_data.out_buff = unique_ptr<data_t[]>(new data_t[stream_data.out_buf_size]);
-	stream_data.out_buff_start = stream_data.out_buff.get();
-	stream_data.out_buff_end = stream_data.out_buff.get();
-
-	stream_wrapper = compressed_fs.CreateStream();
-	stream_wrapper->Initialize(*this, write);
-}
-
-int64_t CompressedFile::ReadData(void *buffer, int64_t remaining) {
-	idx_t total_read = 0;
-	while (true) {
-		// first check if there are input bytes available in the output buffers
-		if (stream_data.out_buff_start != stream_data.out_buff_end) {
-			// there is! copy it into the output buffer
-			idx_t available = MinValue<idx_t>(remaining, stream_data.out_buff_end - stream_data.out_buff_start);
-			memcpy(data_ptr_t(buffer) + total_read, stream_data.out_buff_start, available);
-
-			// increment the total read variables as required
-			stream_data.out_buff_start += available;
-			total_read += available;
-			remaining -= available;
-			if (remaining == 0) {
-				// done! read enough
-				return total_read;
-			}
-		}
-		if (!stream_wrapper) {
-			return total_read;
-		}
-
-		// ran out of buffer: read more data from the child stream
-		stream_data.out_buff_start = stream_data.out_buff.get();
-		stream_data.out_buff_end = stream_data.out_buff.get();
-		D_ASSERT(stream_data.in_buff_start <= stream_data.in_buff_end);
-		D_ASSERT(stream_data.in_buff_end <= stream_data.in_buff_start + stream_data.in_buf_size);
-
-		// read more input if none available
-		if (stream_data.in_buff_start == stream_data.in_buff_end) {
-			// empty input buffer: refill from the start
-			stream_data.in_buff_start = stream_data.in_buff.get();
-			stream_data.in_buff_end = stream_data.in_buff_start;
-			auto sz = child_handle->Read(stream_data.in_buff.get(), stream_data.in_buf_size);
-			if (sz <= 0) {
-				stream_wrapper.reset();
-				break;
-			}
-			stream_data.in_buff_end = stream_data.in_buff_start + sz;
-		}
-
-		auto finished = stream_wrapper->Read(stream_data);
-		if (finished) {
-			stream_wrapper.reset();
-		}
-	}
-	return total_read;
-}
-
-int64_t CompressedFile::WriteData(data_ptr_t buffer, int64_t nr_bytes) {
-	stream_wrapper->Write(*this, stream_data, buffer, nr_bytes);
-	return nr_bytes;
-}
-
-void CompressedFile::Close() {
-	if (stream_wrapper) {
-		stream_wrapper->Close();
-		stream_wrapper.reset();
-	}
-	stream_data.in_buff.reset();
-	stream_data.out_buff.reset();
-	stream_data.out_buff_start = nullptr;
-	stream_data.out_buff_end = nullptr;
-	stream_data.in_buff_start = nullptr;
-	stream_data.in_buff_end = nullptr;
-	stream_data.in_buf_size = 0;
-	stream_data.out_buf_size = 0;
-}
-
-int64_t CompressedFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &compressed_file = (CompressedFile &)handle;
-	return compressed_file.ReadData(buffer, nr_bytes);
-}
-
-int64_t CompressedFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &compressed_file = (CompressedFile &)handle;
-	return compressed_file.WriteData((data_ptr_t)buffer, nr_bytes);
-}
-
-void CompressedFileSystem::Reset(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
-	compressed_file.child_handle->Reset();
-	compressed_file.Initialize(compressed_file.write);
-}
-
-int64_t CompressedFileSystem::GetFileSize(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
-	return compressed_file.child_handle->GetFileSize();
-}
-
-bool CompressedFileSystem::OnDiskFile(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
-	return compressed_file.child_handle->OnDiskFile();
-}
-
-bool CompressedFileSystem::CanSeek() {
-	return false;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-constexpr const idx_t DConstants::INVALID_INDEX;
-const row_t MAX_ROW_ID = 4611686018427388000ULL; // 2^62
-const column_t COLUMN_IDENTIFIER_ROW_ID = (column_t)-1;
-const sel_t ZERO_VECTOR[STANDARD_VECTOR_SIZE] = {0};
-const double PI = 3.141592653589793;
-
-const transaction_t TRANSACTION_ID_START = 4611686018427388000ULL;                // 2^62
-const transaction_t MAX_TRANSACTION_ID = NumericLimits<transaction_t>::Maximum(); // 2^63
-const transaction_t NOT_DELETED_ID = NumericLimits<transaction_t>::Maximum() - 1; // 2^64 - 1
-const transaction_t MAXIMUM_QUERY_ID = NumericLimits<transaction_t>::Maximum();   // 2^64
-
-uint64_t NextPowerOfTwo(uint64_t v) {
-	v--;
-	v |= v >> 1;
-	v |= v >> 2;
-	v |= v >> 4;
-	v |= v >> 8;
-	v |= v >> 16;
-	v |= v >> 32;
-	v++;
-	return v;
-}
-
-} // namespace duckdb
-/*
-** This code taken from the SQLite test library.  Originally found on
-** the internet.  The original header comment follows this comment.
-** The code is largerly unchanged, but there have been some modifications.
-*/
-/*
- * This code implements the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest.  This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
- *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
- *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- */
-
-
-namespace duckdb {
-
-/*
- * Note: this code is harmless on little-endian machines.
- */
-static void ByteReverse(unsigned char *buf, unsigned longs) {
-	uint32_t t;
-	do {
-		t = (uint32_t)((unsigned)buf[3] << 8 | buf[2]) << 16 | ((unsigned)buf[1] << 8 | buf[0]);
-		*(uint32_t *)buf = t;
-		buf += 4;
-	} while (--longs);
-}
-/* The four core functions - F1 is optimized somewhat */
-
-/* #define F1(x, y, z) (x & y | ~x & z) */
-#define F1(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
-#define F2(x, y, z) F1(z, x, y)
-#define F3(x, y, z) ((x) ^ (y) ^ (z))
-#define F4(x, y, z) ((y) ^ ((x) | ~(z)))
-
-/* This is the central step in the MD5 algorithm. */
-#define MD5STEP(f, w, x, y, z, data, s) ((w) += f(x, y, z) + (data), (w) = (w) << (s) | (w) >> (32 - (s)), (w) += (x))
-
-/*
- * The core of the MD5 algorithm, this alters an existing MD5 hash to
- * reflect the addition of 16 longwords of new data.  MD5Update blocks
- * the data and converts bytes into longwords for this routine.
- */
-static void MD5Transform(uint32_t buf[4], const uint32_t in[16]) {
-	uint32_t a, b, c, d;
-
-	a = buf[0];
-	b = buf[1];
-	c = buf[2];
-	d = buf[3];
-
-	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
-	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
-	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
-	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
-	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
-	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
-	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
-	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
-	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
-	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
-	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
-	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
-	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
-	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
-	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
-	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
-	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
-	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
-	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
-	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
-	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
-	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
-	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
-	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
-	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
-	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
-	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
-	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
-	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
-	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
-	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
-	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
-	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
-	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
-	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
-	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
-	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
-	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
-	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
-	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
-	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
-	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
-	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
-	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
-	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
-	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
-	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
-	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
-	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
-	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
-	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
-	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
-	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
-	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
-	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
-	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
-	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
-	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
-	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
-	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
-	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
-	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
-	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
-	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
-	buf[0] += a;
-	buf[1] += b;
-	buf[2] += c;
-	buf[3] += d;
-}
-
-/*
- * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
- * initialization constants.
- */
-MD5Context::MD5Context() {
-	buf[0] = 0x67452301;
-	buf[1] = 0xefcdab89;
-	buf[2] = 0x98badcfe;
-	buf[3] = 0x10325476;
-	bits[0] = 0;
-	bits[1] = 0;
-}
-
-/*
- * Update context to reflect the concatenation of another buffer full
- * of bytes.
- */
-void MD5Context::MD5Update(const_data_ptr_t input, idx_t len) {
-	uint32_t t;
-
-	/* Update bitcount */
-
-	t = bits[0];
-	if ((bits[0] = t + ((uint32_t)len << 3)) < t) {
-		bits[1]++; /* Carry from low to high */
-	}
-	bits[1] += len >> 29;
-
-	t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
-
-	/* Handle any leading odd-sized chunks */
-
-	if (t) {
-		unsigned char *p = (unsigned char *)in + t;
-
-		t = 64 - t;
-		if (len < t) {
-			memcpy(p, input, len);
-			return;
-		}
-		memcpy(p, input, t);
-		ByteReverse(in, 16);
-		MD5Transform(buf, (uint32_t *)in);
-		input += t;
-		len -= t;
-	}
-
-	/* Process data in 64-byte chunks */
-
-	while (len >= 64) {
-		memcpy(in, input, 64);
-		ByteReverse(in, 16);
-		MD5Transform(buf, (uint32_t *)in);
-		input += 64;
-		len -= 64;
-	}
-
-	/* Handle any remaining bytes of data. */
-	memcpy(in, input, len);
-}
-
-/*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
- * 1 0* (64-bit count of bits processed, MSB-first)
- */
-void MD5Context::Finish(data_ptr_t out_digest) {
-	unsigned count;
-	unsigned char *p;
-
-	/* Compute number of bytes mod 64 */
-	count = (bits[0] >> 3) & 0x3F;
-
-	/* Set the first char of padding to 0x80.  This is safe since there is
-	   always at least one byte free */
-	p = in + count;
-	*p++ = 0x80;
-
-	/* Bytes of padding needed to make 64 bytes */
-	count = 64 - 1 - count;
-
-	/* Pad out to 56 mod 64 */
-	if (count < 8) {
-		/* Two lots of padding:  Pad the first block to 64 bytes */
-		memset(p, 0, count);
-		ByteReverse(in, 16);
-		MD5Transform(buf, (uint32_t *)in);
-
-		/* Now fill the next block with 56 bytes */
-		memset(in, 0, 56);
-	} else {
-		/* Pad block to 56 bytes */
-		memset(p, 0, count - 8);
-	}
-	ByteReverse(in, 14);
-
-	/* Append length in bits and transform */
-	((uint32_t *)in)[14] = bits[0];
-	((uint32_t *)in)[15] = bits[1];
-
-	MD5Transform(buf, (uint32_t *)in);
-	ByteReverse((unsigned char *)buf, 4);
-	memcpy(out_digest, buf, 16);
-}
-
-void MD5Context::DigestToBase16(const_data_ptr_t digest, char *zbuf) {
-	static char const HEX_CODES[] = "0123456789abcdef";
-	int i, j;
-
-	for (j = i = 0; i < 16; i++) {
-		int a = digest[i];
-		zbuf[j++] = HEX_CODES[(a >> 4) & 0xf];
-		zbuf[j++] = HEX_CODES[a & 0xf];
-	}
-}
-
-void MD5Context::FinishHex(char *out_digest) {
-	data_t digest[MD5_HASH_LENGTH_BINARY];
-	Finish(digest);
-	DigestToBase16(digest, out_digest);
-}
-
-string MD5Context::FinishHex() {
-	char digest[MD5_HASH_LENGTH_TEXT];
-	FinishHex(digest);
-	return string(digest, MD5_HASH_LENGTH_TEXT);
-}
-
-void MD5Context::Add(const char *data) {
-	MD5Update((const_data_ptr_t)data, strlen(data));
-}
-
-} // namespace duckdb
-// This file is licensed under Apache License 2.0
-// Source code taken from https://github.com/google/benchmark
-// It is highly modified
-
-
-
-
-namespace duckdb {
-
-inline uint64_t ChronoNow() {
-	return std::chrono::duration_cast<std::chrono::nanoseconds>(
-	           std::chrono::time_point_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now())
-	               .time_since_epoch())
-	    .count();
-}
-
-inline uint64_t Now() {
-#if defined(RDTSC)
-#if defined(__i386__)
-	uint64_t ret;
-	__asm__ volatile("rdtsc" : "=A"(ret));
-	return ret;
-#elif defined(__x86_64__) || defined(__amd64__)
-	uint64_t low, high;
-	__asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
-	return (high << 32) | low;
-#elif defined(__powerpc__) || defined(__ppc__)
-	uint64_t tbl, tbu0, tbu1;
-	asm("mftbu %0" : "=r"(tbu0));
-	asm("mftb  %0" : "=r"(tbl));
-	asm("mftbu %0" : "=r"(tbu1));
-	tbl &= -static_cast<int64>(tbu0 == tbu1);
-	return (tbu1 << 32) | tbl;
-#elif defined(__sparc__)
-	uint64_t tick;
-	asm(".byte 0x83, 0x41, 0x00, 0x00");
-	asm("mov   %%g1, %0" : "=r"(tick));
-	return tick;
-#elif defined(__ia64__)
-	uint64_t itc;
-	asm("mov %0 = ar.itc" : "=r"(itc));
-	return itc;
-#elif defined(COMPILER_MSVC) && defined(_M_IX86)
-	_asm rdtsc
-#elif defined(COMPILER_MSVC)
-	return __rdtsc();
-#elif defined(__aarch64__)
-	uint64_t virtual_timer_value;
-	asm volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
-	return virtual_timer_value;
-#elif defined(__ARM_ARCH)
-#if (__ARM_ARCH >= 6)
-	uint32_t pmccntr;
-	uint32_t pmuseren;
-	uint32_t pmcntenset;
-	asm volatile("mrc p15, 0, %0, c9, c14, 0" : "=r"(pmuseren));
-	if (pmuseren & 1) { // Allows reading perfmon counters for user mode code.
-		asm volatile("mrc p15, 0, %0, c9, c12, 1" : "=r"(pmcntenset));
-		if (pmcntenset & 0x80000000ul) { // Is it counting?
-			asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r"(pmccntr));
-			return static_cast<uint64_t>(pmccntr) * 64; // Should optimize to << 6
-		}
-	}
-#endif
-	return ChronoNow();
-#else
-	return ChronoNow();
-#endif
-#else
-	return ChronoNow();
-#endif // defined(RDTSC)
-}
-uint64_t CycleCounter::Tick() const {
-	return Now();
-}
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string CatalogTypeToString(CatalogType type) {
-	switch (type) {
-	case CatalogType::COLLATION_ENTRY:
-		return "Collation";
-	case CatalogType::TYPE_ENTRY:
-		return "Type";
-	case CatalogType::TABLE_ENTRY:
-		return "Table";
-	case CatalogType::SCHEMA_ENTRY:
-		return "Schema";
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-		return "Table Function";
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-		return "Scalar Function";
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-		return "Aggregate Function";
-	case CatalogType::COPY_FUNCTION_ENTRY:
-		return "Copy Function";
-	case CatalogType::PRAGMA_FUNCTION_ENTRY:
-		return "Pragma Function";
-	case CatalogType::MACRO_ENTRY:
-		return "Macro Function";
-	case CatalogType::TABLE_MACRO_ENTRY:
-		return "Table Macro Function";
-	case CatalogType::VIEW_ENTRY:
-		return "View";
-	case CatalogType::INDEX_ENTRY:
-		return "Index";
-	case CatalogType::PREPARED_STATEMENT:
-		return "Prepared Statement";
-	case CatalogType::SEQUENCE_ENTRY:
-		return "Sequence";
-	case CatalogType::INVALID:
-	case CatalogType::DELETED_ENTRY:
-	case CatalogType::UPDATED_ENTRY:
-		break;
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-CompressionType CompressionTypeFromString(const string &str) {
-	auto compression = StringUtil::Lower(str);
-	if (compression == "uncompressed") {
-		return CompressionType::COMPRESSION_UNCOMPRESSED;
-	} else if (compression == "rle") {
-		return CompressionType::COMPRESSION_RLE;
-	} else if (compression == "dictionary") {
-		return CompressionType::COMPRESSION_DICTIONARY;
-	} else if (compression == "pfor") {
-		return CompressionType::COMPRESSION_PFOR_DELTA;
-	} else if (compression == "bitpacking") {
-		return CompressionType::COMPRESSION_BITPACKING;
-	} else if (compression == "fsst") {
-		return CompressionType::COMPRESSION_FSST;
-	} else {
-		return CompressionType::COMPRESSION_AUTO;
-	}
-}
-
-string CompressionTypeToString(CompressionType type) {
-	switch (type) {
-	case CompressionType::COMPRESSION_UNCOMPRESSED:
-		return "Uncompressed";
-	case CompressionType::COMPRESSION_CONSTANT:
-		return "Constant";
-	case CompressionType::COMPRESSION_RLE:
-		return "RLE";
-	case CompressionType::COMPRESSION_DICTIONARY:
-		return "Dictionary";
-	case CompressionType::COMPRESSION_PFOR_DELTA:
-		return "PFOR";
-	case CompressionType::COMPRESSION_BITPACKING:
-		return "BitPacking";
-	case CompressionType::COMPRESSION_FSST:
-		return "FSST";
-	default:
-		throw InternalException("Unrecognized compression type!");
-	}
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string ExpressionTypeToString(ExpressionType type) {
-	switch (type) {
-	case ExpressionType::OPERATOR_CAST:
-		return "CAST";
-	case ExpressionType::OPERATOR_NOT:
-		return "NOT";
-	case ExpressionType::OPERATOR_IS_NULL:
-		return "IS_NULL";
-	case ExpressionType::OPERATOR_IS_NOT_NULL:
-		return "IS_NOT_NULL";
-	case ExpressionType::COMPARE_EQUAL:
-		return "EQUAL";
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return "NOTEQUAL";
-	case ExpressionType::COMPARE_LESSTHAN:
-		return "LESSTHAN";
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return "GREATERTHAN";
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return "LESSTHANOREQUALTO";
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return "GREATERTHANOREQUALTO";
-	case ExpressionType::COMPARE_IN:
-		return "IN";
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return "DISTINCT_FROM";
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return "NOT_DISTINCT_FROM";
-	case ExpressionType::CONJUNCTION_AND:
-		return "AND";
-	case ExpressionType::CONJUNCTION_OR:
-		return "OR";
-	case ExpressionType::VALUE_CONSTANT:
-		return "CONSTANT";
-	case ExpressionType::VALUE_PARAMETER:
-		return "PARAMETER";
-	case ExpressionType::VALUE_TUPLE:
-		return "TUPLE";
-	case ExpressionType::VALUE_TUPLE_ADDRESS:
-		return "TUPLE_ADDRESS";
-	case ExpressionType::VALUE_NULL:
-		return "NULL";
-	case ExpressionType::VALUE_VECTOR:
-		return "VECTOR";
-	case ExpressionType::VALUE_SCALAR:
-		return "SCALAR";
-	case ExpressionType::AGGREGATE:
-		return "AGGREGATE";
-	case ExpressionType::WINDOW_AGGREGATE:
-		return "WINDOW_AGGREGATE";
-	case ExpressionType::WINDOW_RANK:
-		return "RANK";
-	case ExpressionType::WINDOW_RANK_DENSE:
-		return "RANK_DENSE";
-	case ExpressionType::WINDOW_PERCENT_RANK:
-		return "PERCENT_RANK";
-	case ExpressionType::WINDOW_ROW_NUMBER:
-		return "ROW_NUMBER";
-	case ExpressionType::WINDOW_FIRST_VALUE:
-		return "FIRST_VALUE";
-	case ExpressionType::WINDOW_LAST_VALUE:
-		return "LAST_VALUE";
-	case ExpressionType::WINDOW_NTH_VALUE:
-		return "NTH_VALUE";
-	case ExpressionType::WINDOW_CUME_DIST:
-		return "CUME_DIST";
-	case ExpressionType::WINDOW_LEAD:
-		return "LEAD";
-	case ExpressionType::WINDOW_LAG:
-		return "LAG";
-	case ExpressionType::WINDOW_NTILE:
-		return "NTILE";
-	case ExpressionType::FUNCTION:
-		return "FUNCTION";
-	case ExpressionType::CASE_EXPR:
-		return "CASE";
-	case ExpressionType::OPERATOR_NULLIF:
-		return "NULLIF";
-	case ExpressionType::OPERATOR_COALESCE:
-		return "COALESCE";
-	case ExpressionType::ARRAY_EXTRACT:
-		return "ARRAY_EXTRACT";
-	case ExpressionType::ARRAY_SLICE:
-		return "ARRAY_SLICE";
-	case ExpressionType::STRUCT_EXTRACT:
-		return "STRUCT_EXTRACT";
-	case ExpressionType::SUBQUERY:
-		return "SUBQUERY";
-	case ExpressionType::STAR:
-		return "STAR";
-	case ExpressionType::PLACEHOLDER:
-		return "PLACEHOLDER";
-	case ExpressionType::COLUMN_REF:
-		return "COLUMN_REF";
-	case ExpressionType::FUNCTION_REF:
-		return "FUNCTION_REF";
-	case ExpressionType::TABLE_REF:
-		return "TABLE_REF";
-	case ExpressionType::CAST:
-		return "CAST";
-	case ExpressionType::COMPARE_NOT_IN:
-		return "COMPARE_NOT_IN";
-	case ExpressionType::COMPARE_BETWEEN:
-		return "COMPARE_BETWEEN";
-	case ExpressionType::COMPARE_NOT_BETWEEN:
-		return "COMPARE_NOT_BETWEEN";
-	case ExpressionType::VALUE_DEFAULT:
-		return "VALUE_DEFAULT";
-	case ExpressionType::BOUND_REF:
-		return "BOUND_REF";
-	case ExpressionType::BOUND_COLUMN_REF:
-		return "BOUND_COLUMN_REF";
-	case ExpressionType::BOUND_FUNCTION:
-		return "BOUND_FUNCTION";
-	case ExpressionType::BOUND_AGGREGATE:
-		return "BOUND_AGGREGATE";
-	case ExpressionType::GROUPING_FUNCTION:
-		return "GROUPING";
-	case ExpressionType::ARRAY_CONSTRUCTOR:
-		return "ARRAY_CONSTRUCTOR";
-	case ExpressionType::TABLE_STAR:
-		return "TABLE_STAR";
-	case ExpressionType::BOUND_UNNEST:
-		return "BOUND_UNNEST";
-	case ExpressionType::COLLATE:
-		return "COLLATE";
-	case ExpressionType::POSITIONAL_REFERENCE:
-		return "POSITIONAL_REFERENCE";
-	case ExpressionType::LAMBDA:
-		return "LAMBDA";
-	case ExpressionType::ARROW:
-		return "ARROW";
-	case ExpressionType::INVALID:
-		break;
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-string ExpressionTypeToOperator(ExpressionType type) {
-	switch (type) {
-	case ExpressionType::COMPARE_EQUAL:
-		return "=";
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return "!=";
-	case ExpressionType::COMPARE_LESSTHAN:
-		return "<";
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return ">";
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return "<=";
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return ">=";
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return "IS DISTINCT FROM";
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return "IS NOT DISTINCT FROM";
-	case ExpressionType::CONJUNCTION_AND:
-		return "AND";
-	case ExpressionType::CONJUNCTION_OR:
-		return "OR";
-	default:
-		return "";
-	}
-}
-
-ExpressionType NegateComparisionExpression(ExpressionType type) {
-	ExpressionType negated_type = ExpressionType::INVALID;
-	switch (type) {
-	case ExpressionType::COMPARE_EQUAL:
-		negated_type = ExpressionType::COMPARE_NOTEQUAL;
-		break;
-	case ExpressionType::COMPARE_NOTEQUAL:
-		negated_type = ExpressionType::COMPARE_EQUAL;
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		negated_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		negated_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		negated_type = ExpressionType::COMPARE_GREATERTHAN;
-		break;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		negated_type = ExpressionType::COMPARE_LESSTHAN;
-		break;
-	default:
-		throw InternalException("Unsupported comparison type in negation");
-	}
-	return negated_type;
-}
-
-ExpressionType FlipComparisionExpression(ExpressionType type) {
-	ExpressionType flipped_type = ExpressionType::INVALID;
-	switch (type) {
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-	case ExpressionType::COMPARE_NOTEQUAL:
-	case ExpressionType::COMPARE_EQUAL:
-		flipped_type = type;
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		flipped_type = ExpressionType::COMPARE_GREATERTHAN;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		flipped_type = ExpressionType::COMPARE_LESSTHAN;
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		flipped_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-		break;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		flipped_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
-		break;
-	default:
-		throw InternalException("Unsupported comparison type in flip");
-	}
-	return flipped_type;
-}
-
-ExpressionType OperatorToExpressionType(const string &op) {
-	if (op == "=" || op == "==") {
-		return ExpressionType::COMPARE_EQUAL;
-	} else if (op == "!=" || op == "<>") {
-		return ExpressionType::COMPARE_NOTEQUAL;
-	} else if (op == "<") {
-		return ExpressionType::COMPARE_LESSTHAN;
-	} else if (op == ">") {
-		return ExpressionType::COMPARE_GREATERTHAN;
-	} else if (op == "<=") {
-		return ExpressionType::COMPARE_LESSTHANOREQUALTO;
-	} else if (op == ">=") {
-		return ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-	}
-	return ExpressionType::INVALID;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-FileCompressionType FileCompressionTypeFromString(const string &input) {
-	auto parameter = StringUtil::Lower(input);
-	if (parameter == "infer" || parameter == "auto") {
-		return FileCompressionType::AUTO_DETECT;
-	} else if (parameter == "gzip") {
-		return FileCompressionType::GZIP;
-	} else if (parameter == "zstd") {
-		return FileCompressionType::ZSTD;
-	} else if (parameter == "uncompressed" || parameter == "none" || parameter.empty()) {
-		return FileCompressionType::UNCOMPRESSED;
-	} else {
-		throw ParserException("Unrecognized file compression type \"%s\"", input);
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-string JoinTypeToString(JoinType type) {
-	switch (type) {
-	case JoinType::LEFT:
-		return "LEFT";
-	case JoinType::RIGHT:
-		return "RIGHT";
-	case JoinType::INNER:
-		return "INNER";
-	case JoinType::OUTER:
-		return "FULL";
-	case JoinType::SEMI:
-		return "SEMI";
-	case JoinType::ANTI:
-		return "ANTI";
-	case JoinType::SINGLE:
-		return "SINGLE";
-	case JoinType::MARK:
-		return "MARK";
-	case JoinType::INVALID: // LCOV_EXCL_START
-		break;
-	}
-	return "INVALID";
-} // LCOV_EXCL_STOP
-
-bool IsLeftOuterJoin(JoinType type) {
-	return type == JoinType::LEFT || type == JoinType::OUTER;
-}
-
-bool IsRightOuterJoin(JoinType type) {
-	return type == JoinType::OUTER || type == JoinType::RIGHT;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Value <--> String Utilities
-//===--------------------------------------------------------------------===//
-// LCOV_EXCL_START
-string LogicalOperatorToString(LogicalOperatorType type) {
-	switch (type) {
-	case LogicalOperatorType::LOGICAL_GET:
-		return "GET";
-	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		return "CHUNK_GET";
-	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		return "DELIM_GET";
-	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		return "EMPTY_RESULT";
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		return "EXPRESSION_GET";
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		return "ANY_JOIN";
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		return "COMPARISON_JOIN";
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return "DELIM_JOIN";
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return "PROJECTION";
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return "FILTER";
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return "AGGREGATE";
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		return "WINDOW";
-	case LogicalOperatorType::LOGICAL_UNNEST:
-		return "UNNEST";
-	case LogicalOperatorType::LOGICAL_LIMIT:
-		return "LIMIT";
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		return "ORDER_BY";
-	case LogicalOperatorType::LOGICAL_TOP_N:
-		return "TOP_N";
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-		return "SAMPLE";
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		return "LIMIT_PERCENT";
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		return "COPY_TO_FILE";
-	case LogicalOperatorType::LOGICAL_JOIN:
-		return "JOIN";
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return "CROSS_PRODUCT";
-	case LogicalOperatorType::LOGICAL_UNION:
-		return "UNION";
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-		return "EXCEPT";
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		return "INTERSECT";
-	case LogicalOperatorType::LOGICAL_INSERT:
-		return "INSERT";
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		return "DISTINCT";
-	case LogicalOperatorType::LOGICAL_DELETE:
-		return "DELETE";
-	case LogicalOperatorType::LOGICAL_UPDATE:
-		return "UPDATE";
-	case LogicalOperatorType::LOGICAL_PREPARE:
-		return "PREPARE";
-	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		return "DUMMY_SCAN";
-	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		return "CREATE_INDEX";
-	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		return "CREATE_TABLE";
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		return "CREATE_MACRO";
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		return "EXPLAIN";
-	case LogicalOperatorType::LOGICAL_EXECUTE:
-		return "EXECUTE";
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		return "VACUUM";
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		return "REC_CTE";
-	case LogicalOperatorType::LOGICAL_CTE_REF:
-		return "CTE_SCAN";
-	case LogicalOperatorType::LOGICAL_SHOW:
-		return "SHOW";
-	case LogicalOperatorType::LOGICAL_ALTER:
-		return "ALTER";
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		return "CREATE_SEQUENCE";
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		return "CREATE_TYPE";
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		return "CREATE_VIEW";
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		return "CREATE_SCHEMA";
-	case LogicalOperatorType::LOGICAL_DROP:
-		return "DROP";
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-		return "PRAGMA";
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		return "TRANSACTION";
-	case LogicalOperatorType::LOGICAL_EXPORT:
-		return "EXPORT";
-	case LogicalOperatorType::LOGICAL_SET:
-		return "SET";
-	case LogicalOperatorType::LOGICAL_LOAD:
-		return "LOAD";
-	case LogicalOperatorType::LOGICAL_INVALID:
-		break;
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-struct DefaultOptimizerType {
-	const char *name;
-	OptimizerType type;
-};
-
-static DefaultOptimizerType internal_optimizer_types[] = {
-    {"expression_rewriter", OptimizerType::EXPRESSION_REWRITER},
-    {"filter_pullup", OptimizerType::FILTER_PULLUP},
-    {"filter_pushdown", OptimizerType::FILTER_PUSHDOWN},
-    {"regex_range", OptimizerType::REGEX_RANGE},
-    {"in_clause", OptimizerType::IN_CLAUSE},
-    {"join_order", OptimizerType::JOIN_ORDER},
-    {"deliminator", OptimizerType::DELIMINATOR},
-    {"unused_columns", OptimizerType::UNUSED_COLUMNS},
-    {"statistics_propagation", OptimizerType::STATISTICS_PROPAGATION},
-    {"common_subexpressions", OptimizerType::COMMON_SUBEXPRESSIONS},
-    {"common_aggregate", OptimizerType::COMMON_AGGREGATE},
-    {"column_lifetime", OptimizerType::COLUMN_LIFETIME},
-    {"top_n", OptimizerType::TOP_N},
-    {"reorder_filter", OptimizerType::REORDER_FILTER},
-    {nullptr, OptimizerType::INVALID}};
-
-string OptimizerTypeToString(OptimizerType type) {
-	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
-		if (internal_optimizer_types[i].type == type) {
-			return internal_optimizer_types[i].name;
-		}
-	}
-	throw InternalException("Invalid optimizer type");
-}
-
-OptimizerType OptimizerTypeFromString(const string &str) {
-	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
-		if (internal_optimizer_types[i].name == str) {
-			return internal_optimizer_types[i].type;
-		}
-	}
-	// optimizer not found, construct candidate list
-	vector<string> optimizer_names;
-	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
-		optimizer_names.emplace_back(internal_optimizer_types[i].name);
-	}
-	throw ParserException("Optimizer type \"%s\" not recognized\n%s", str,
-	                      StringUtil::CandidatesErrorMessage(optimizer_names, str, "Candidate optimizers"));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string PhysicalOperatorToString(PhysicalOperatorType type) {
-	switch (type) {
-	case PhysicalOperatorType::TABLE_SCAN:
-		return "TABLE_SCAN";
-	case PhysicalOperatorType::DUMMY_SCAN:
-		return "DUMMY_SCAN";
-	case PhysicalOperatorType::CHUNK_SCAN:
-		return "CHUNK_SCAN";
-	case PhysicalOperatorType::DELIM_SCAN:
-		return "DELIM_SCAN";
-	case PhysicalOperatorType::ORDER_BY:
-		return "ORDER_BY";
-	case PhysicalOperatorType::LIMIT:
-		return "LIMIT";
-	case PhysicalOperatorType::LIMIT_PERCENT:
-		return "LIMIT_PERCENT";
-	case PhysicalOperatorType::STREAMING_LIMIT:
-		return "STREAMING_LIMIT";
-	case PhysicalOperatorType::RESERVOIR_SAMPLE:
-		return "RESERVOIR_SAMPLE";
-	case PhysicalOperatorType::STREAMING_SAMPLE:
-		return "STREAMING_SAMPLE";
-	case PhysicalOperatorType::TOP_N:
-		return "TOP_N";
-	case PhysicalOperatorType::WINDOW:
-		return "WINDOW";
-	case PhysicalOperatorType::STREAMING_WINDOW:
-		return "STREAMING_WINDOW";
-	case PhysicalOperatorType::UNNEST:
-		return "UNNEST";
-	case PhysicalOperatorType::SIMPLE_AGGREGATE:
-		return "SIMPLE_AGGREGATE";
-	case PhysicalOperatorType::HASH_GROUP_BY:
-		return "HASH_GROUP_BY";
-	case PhysicalOperatorType::PERFECT_HASH_GROUP_BY:
-		return "PERFECT_HASH_GROUP_BY";
-	case PhysicalOperatorType::FILTER:
-		return "FILTER";
-	case PhysicalOperatorType::PROJECTION:
-		return "PROJECTION";
-	case PhysicalOperatorType::COPY_TO_FILE:
-		return "COPY_TO_FILE";
-	case PhysicalOperatorType::DELIM_JOIN:
-		return "DELIM_JOIN";
-	case PhysicalOperatorType::BLOCKWISE_NL_JOIN:
-		return "BLOCKWISE_NL_JOIN";
-	case PhysicalOperatorType::NESTED_LOOP_JOIN:
-		return "NESTED_LOOP_JOIN";
-	case PhysicalOperatorType::HASH_JOIN:
-		return "HASH_JOIN";
-	case PhysicalOperatorType::INDEX_JOIN:
-		return "INDEX_JOIN";
-	case PhysicalOperatorType::PIECEWISE_MERGE_JOIN:
-		return "PIECEWISE_MERGE_JOIN";
-	case PhysicalOperatorType::IE_JOIN:
-		return "IE_JOIN";
-	case PhysicalOperatorType::CROSS_PRODUCT:
-		return "CROSS_PRODUCT";
-	case PhysicalOperatorType::UNION:
-		return "UNION";
-	case PhysicalOperatorType::INSERT:
-		return "INSERT";
-	case PhysicalOperatorType::DELETE_OPERATOR:
-		return "DELETE";
-	case PhysicalOperatorType::UPDATE:
-		return "UPDATE";
-	case PhysicalOperatorType::EMPTY_RESULT:
-		return "EMPTY_RESULT";
-	case PhysicalOperatorType::CREATE_TABLE:
-		return "CREATE_TABLE";
-	case PhysicalOperatorType::CREATE_TABLE_AS:
-		return "CREATE_TABLE_AS";
-	case PhysicalOperatorType::CREATE_INDEX:
-		return "CREATE_INDEX";
-	case PhysicalOperatorType::EXPLAIN:
-		return "EXPLAIN";
-	case PhysicalOperatorType::EXPLAIN_ANALYZE:
-		return "EXPLAIN_ANALYZE";
-	case PhysicalOperatorType::EXECUTE:
-		return "EXECUTE";
-	case PhysicalOperatorType::VACUUM:
-		return "VACUUM";
-	case PhysicalOperatorType::RECURSIVE_CTE:
-		return "REC_CTE";
-	case PhysicalOperatorType::RECURSIVE_CTE_SCAN:
-		return "REC_CTE_SCAN";
-	case PhysicalOperatorType::EXPRESSION_SCAN:
-		return "EXPRESSION_SCAN";
-	case PhysicalOperatorType::ALTER:
-		return "ALTER";
-	case PhysicalOperatorType::CREATE_SEQUENCE:
-		return "CREATE_SEQUENCE";
-	case PhysicalOperatorType::CREATE_VIEW:
-		return "CREATE_VIEW";
-	case PhysicalOperatorType::CREATE_SCHEMA:
-		return "CREATE_SCHEMA";
-	case PhysicalOperatorType::CREATE_MACRO:
-		return "CREATE_MACRO";
-	case PhysicalOperatorType::DROP:
-		return "DROP";
-	case PhysicalOperatorType::PRAGMA:
-		return "PRAGMA";
-	case PhysicalOperatorType::TRANSACTION:
-		return "TRANSACTION";
-	case PhysicalOperatorType::PREPARE:
-		return "PREPARE";
-	case PhysicalOperatorType::EXPORT:
-		return "EXPORT";
-	case PhysicalOperatorType::SET:
-		return "SET";
-	case PhysicalOperatorType::LOAD:
-		return "LOAD";
-	case PhysicalOperatorType::INOUT_FUNCTION:
-		return "INOUT_FUNCTION";
-	case PhysicalOperatorType::CREATE_TYPE:
-		return "CREATE_TYPE";
-	case PhysicalOperatorType::RESULT_COLLECTOR:
-		return "RESULT_COLLECTOR";
-	case PhysicalOperatorType::INVALID:
-		break;
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string RelationTypeToString(RelationType type) {
-	switch (type) {
-	case RelationType::TABLE_RELATION:
-		return "TABLE_RELATION";
-	case RelationType::PROJECTION_RELATION:
-		return "PROJECTION_RELATION";
-	case RelationType::FILTER_RELATION:
-		return "FILTER_RELATION";
-	case RelationType::EXPLAIN_RELATION:
-		return "EXPLAIN_RELATION";
-	case RelationType::CROSS_PRODUCT_RELATION:
-		return "CROSS_PRODUCT_RELATION";
-	case RelationType::JOIN_RELATION:
-		return "JOIN_RELATION";
-	case RelationType::AGGREGATE_RELATION:
-		return "AGGREGATE_RELATION";
-	case RelationType::SET_OPERATION_RELATION:
-		return "SET_OPERATION_RELATION";
-	case RelationType::DISTINCT_RELATION:
-		return "DISTINCT_RELATION";
-	case RelationType::LIMIT_RELATION:
-		return "LIMIT_RELATION";
-	case RelationType::ORDER_RELATION:
-		return "ORDER_RELATION";
-	case RelationType::CREATE_VIEW_RELATION:
-		return "CREATE_VIEW_RELATION";
-	case RelationType::CREATE_TABLE_RELATION:
-		return "CREATE_TABLE_RELATION";
-	case RelationType::INSERT_RELATION:
-		return "INSERT_RELATION";
-	case RelationType::VALUE_LIST_RELATION:
-		return "VALUE_LIST_RELATION";
-	case RelationType::DELETE_RELATION:
-		return "DELETE_RELATION";
-	case RelationType::UPDATE_RELATION:
-		return "UPDATE_RELATION";
-	case RelationType::WRITE_CSV_RELATION:
-		return "WRITE_CSV_RELATION";
-	case RelationType::READ_CSV_RELATION:
-		return "READ_CSV_RELATION";
-	case RelationType::SUBQUERY_RELATION:
-		return "SUBQUERY_RELATION";
-	case RelationType::TABLE_FUNCTION_RELATION:
-		return "TABLE_FUNCTION_RELATION";
-	case RelationType::VIEW_RELATION:
-		return "VIEW_RELATION";
-	case RelationType::QUERY_RELATION:
-		return "QUERY_RELATION";
-	case RelationType::INVALID_RELATION:
-		break;
-	}
-	return "INVALID_RELATION";
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-string StatementTypeToString(StatementType type) {
-	switch (type) {
-	case StatementType::SELECT_STATEMENT:
-		return "SELECT";
-	case StatementType::INSERT_STATEMENT:
-		return "INSERT";
-	case StatementType::UPDATE_STATEMENT:
-		return "UPDATE";
-	case StatementType::DELETE_STATEMENT:
-		return "DELETE";
-	case StatementType::PREPARE_STATEMENT:
-		return "PREPARE";
-	case StatementType::EXECUTE_STATEMENT:
-		return "EXECUTE";
-	case StatementType::ALTER_STATEMENT:
-		return "ALTER";
-	case StatementType::TRANSACTION_STATEMENT:
-		return "TRANSACTION";
-	case StatementType::COPY_STATEMENT:
-		return "COPY";
-	case StatementType::ANALYZE_STATEMENT:
-		return "ANALYZE";
-	case StatementType::VARIABLE_SET_STATEMENT:
-		return "VARIABLE_SET";
-	case StatementType::CREATE_FUNC_STATEMENT:
-		return "CREATE_FUNC";
-	case StatementType::EXPLAIN_STATEMENT:
-		return "EXPLAIN";
-	case StatementType::CREATE_STATEMENT:
-		return "CREATE";
-	case StatementType::DROP_STATEMENT:
-		return "DROP";
-	case StatementType::PRAGMA_STATEMENT:
-		return "PRAGMA";
-	case StatementType::SHOW_STATEMENT:
-		return "SHOW";
-	case StatementType::VACUUM_STATEMENT:
-		return "VACUUM";
-	case StatementType::RELATION_STATEMENT:
-		return "RELATION";
-	case StatementType::EXPORT_STATEMENT:
-		return "EXPORT";
-	case StatementType::CALL_STATEMENT:
-		return "CALL";
-	case StatementType::SET_STATEMENT:
-		return "SET";
-	case StatementType::LOAD_STATEMENT:
-		return "LOAD";
-	case StatementType::EXTENSION_STATEMENT:
-		return "EXTENSION";
-	case StatementType::INVALID_STATEMENT:
-		break;
-	}
-	return "INVALID";
-}
-
-string StatementReturnTypeToString(StatementReturnType type) {
-	switch (type) {
-	case StatementReturnType::QUERY_RESULT:
-		return "QUERY_RESULT";
-	case StatementReturnType::CHANGED_ROWS:
-		return "CHANGED_ROWS";
-	case StatementReturnType::NOTHING:
-		return "NOTHING";
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-Exception::Exception(const string &msg) : std::exception(), type(ExceptionType::INVALID) {
-	exception_message_ = msg;
-}
-
-Exception::Exception(ExceptionType exception_type, const string &message) : std::exception(), type(exception_type) {
-	exception_message_ = ExceptionTypeToString(exception_type) + " Error: " + message;
-}
-
-const char *Exception::what() const noexcept {
-	return exception_message_.c_str();
-}
-
-bool Exception::UncaughtException() {
-#if __cplusplus >= 201703L
-	return std::uncaught_exceptions() > 0;
-#else
-	return std::uncaught_exception();
-#endif
-}
-
-string Exception::ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values) {
-	return ExceptionFormatValue::Format(msg, values);
-}
-
-string Exception::ExceptionTypeToString(ExceptionType type) {
-	switch (type) {
-	case ExceptionType::INVALID:
-		return "Invalid";
-	case ExceptionType::OUT_OF_RANGE:
-		return "Out of Range";
-	case ExceptionType::CONVERSION:
-		return "Conversion";
-	case ExceptionType::UNKNOWN_TYPE:
-		return "Unknown Type";
-	case ExceptionType::DECIMAL:
-		return "Decimal";
-	case ExceptionType::MISMATCH_TYPE:
-		return "Mismatch Type";
-	case ExceptionType::DIVIDE_BY_ZERO:
-		return "Divide by Zero";
-	case ExceptionType::OBJECT_SIZE:
-		return "Object Size";
-	case ExceptionType::INVALID_TYPE:
-		return "Invalid type";
-	case ExceptionType::SERIALIZATION:
-		return "Serialization";
-	case ExceptionType::TRANSACTION:
-		return "TransactionContext";
-	case ExceptionType::NOT_IMPLEMENTED:
-		return "Not implemented";
-	case ExceptionType::EXPRESSION:
-		return "Expression";
-	case ExceptionType::CATALOG:
-		return "Catalog";
-	case ExceptionType::PARSER:
-		return "Parser";
-	case ExceptionType::BINDER:
-		return "Binder";
-	case ExceptionType::PLANNER:
-		return "Planner";
-	case ExceptionType::SCHEDULER:
-		return "Scheduler";
-	case ExceptionType::EXECUTOR:
-		return "Executor";
-	case ExceptionType::CONSTRAINT:
-		return "Constraint";
-	case ExceptionType::INDEX:
-		return "Index";
-	case ExceptionType::STAT:
-		return "Stat";
-	case ExceptionType::CONNECTION:
-		return "Connection";
-	case ExceptionType::SYNTAX:
-		return "Syntax";
-	case ExceptionType::SETTINGS:
-		return "Settings";
-	case ExceptionType::OPTIMIZER:
-		return "Optimizer";
-	case ExceptionType::NULL_POINTER:
-		return "NullPointer";
-	case ExceptionType::IO:
-		return "IO";
-	case ExceptionType::INTERRUPT:
-		return "INTERRUPT";
-	case ExceptionType::FATAL:
-		return "FATAL";
-	case ExceptionType::INTERNAL:
-		return "INTERNAL";
-	case ExceptionType::INVALID_INPUT:
-		return "Invalid Input";
-	case ExceptionType::OUT_OF_MEMORY:
-		return "Out of Memory";
-	case ExceptionType::PERMISSION:
-		return "Permission";
-	default:
-		return "Unknown";
-	}
-}
-
-StandardException::StandardException(ExceptionType exception_type, const string &message)
-    : Exception(exception_type, message) {
-}
-
-CastException::CastException(const PhysicalType orig_type, const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION,
-                "Type " + TypeIdToString(orig_type) + " can't be cast as " + TypeIdToString(new_type)) {
-}
-
-CastException::CastException(const LogicalType &orig_type, const LogicalType &new_type)
-    : Exception(ExceptionType::CONVERSION,
-                "Type " + orig_type.ToString() + " can't be cast as " + new_type.ToString()) {
-}
-
-ValueOutOfRangeException::ValueOutOfRangeException(const int64_t value, const PhysicalType orig_type,
-                                                   const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION, "Type " + TypeIdToString(orig_type) + " with value " +
-                                               to_string((intmax_t)value) +
-                                               " can't be cast because the value is out of range "
-                                               "for the destination type " +
-                                               TypeIdToString(new_type)) {
-}
-
-ValueOutOfRangeException::ValueOutOfRangeException(const double value, const PhysicalType orig_type,
-                                                   const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION, "Type " + TypeIdToString(orig_type) + " with value " + to_string(value) +
-                                               " can't be cast because the value is out of range "
-                                               "for the destination type " +
-                                               TypeIdToString(new_type)) {
-}
-
-ValueOutOfRangeException::ValueOutOfRangeException(const hugeint_t value, const PhysicalType orig_type,
-                                                   const PhysicalType new_type)
-    : Exception(ExceptionType::CONVERSION, "Type " + TypeIdToString(orig_type) + " with value " + value.ToString() +
-                                               " can't be cast because the value is out of range "
-                                               "for the destination type " +
-                                               TypeIdToString(new_type)) {
-}
-
-ValueOutOfRangeException::ValueOutOfRangeException(const PhysicalType var_type, const idx_t length)
-    : Exception(ExceptionType::OUT_OF_RANGE,
-                "The value is too long to fit into type " + TypeIdToString(var_type) + "(" + to_string(length) + ")") {
-}
-
-ConversionException::ConversionException(const string &msg) : Exception(ExceptionType::CONVERSION, msg) {
-}
-
-InvalidTypeException::InvalidTypeException(PhysicalType type, const string &msg)
-    : Exception(ExceptionType::INVALID_TYPE, "Invalid Type [" + TypeIdToString(type) + "]: " + msg) {
-}
-
-InvalidTypeException::InvalidTypeException(const LogicalType &type, const string &msg)
-    : Exception(ExceptionType::INVALID_TYPE, "Invalid Type [" + type.ToString() + "]: " + msg) {
-}
-
-TypeMismatchException::TypeMismatchException(const PhysicalType type_1, const PhysicalType type_2, const string &msg)
-    : Exception(ExceptionType::MISMATCH_TYPE,
-                "Type " + TypeIdToString(type_1) + " does not match with " + TypeIdToString(type_2) + ". " + msg) {
-}
-
-TypeMismatchException::TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg)
-    : Exception(ExceptionType::MISMATCH_TYPE,
-                "Type " + type_1.ToString() + " does not match with " + type_2.ToString() + ". " + msg) {
-}
-
-TransactionException::TransactionException(const string &msg) : Exception(ExceptionType::TRANSACTION, msg) {
-}
-
-NotImplementedException::NotImplementedException(const string &msg) : Exception(ExceptionType::NOT_IMPLEMENTED, msg) {
-}
-
-OutOfRangeException::OutOfRangeException(const string &msg) : Exception(ExceptionType::OUT_OF_RANGE, msg) {
-}
-
-CatalogException::CatalogException(const string &msg) : StandardException(ExceptionType::CATALOG, msg) {
-}
-
-ParserException::ParserException(const string &msg) : StandardException(ExceptionType::PARSER, msg) {
-}
-
-PermissionException::PermissionException(const string &msg) : StandardException(ExceptionType::PERMISSION, msg) {
-}
-
-SyntaxException::SyntaxException(const string &msg) : Exception(ExceptionType::SYNTAX, msg) {
-}
-
-ConstraintException::ConstraintException(const string &msg) : Exception(ExceptionType::CONSTRAINT, msg) {
-}
-
-BinderException::BinderException(const string &msg) : StandardException(ExceptionType::BINDER, msg) {
-}
-
-IOException::IOException(const string &msg) : Exception(ExceptionType::IO, msg) {
-}
-
-SerializationException::SerializationException(const string &msg) : Exception(ExceptionType::SERIALIZATION, msg) {
-}
-
-SequenceException::SequenceException(const string &msg) : Exception(ExceptionType::SERIALIZATION, msg) {
-}
-
-InterruptException::InterruptException() : Exception(ExceptionType::INTERRUPT, "Interrupted!") {
-}
-
-FatalException::FatalException(const string &msg) : Exception(ExceptionType::FATAL, msg) {
-}
-
-InternalException::InternalException(const string &msg) : Exception(ExceptionType::INTERNAL, msg) {
-}
-
-InvalidInputException::InvalidInputException(const string &msg) : Exception(ExceptionType::INVALID_INPUT, msg) {
-}
-
-OutOfMemoryException::OutOfMemoryException(const string &msg) : Exception(ExceptionType::OUT_OF_MEMORY, msg) {
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ExceptionFormatValue::ExceptionFormatValue(double dbl_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE), dbl_val(dbl_val) {
-}
-ExceptionFormatValue::ExceptionFormatValue(int64_t int_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER), int_val(int_val) {
-}
-ExceptionFormatValue::ExceptionFormatValue(hugeint_t huge_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(Hugeint::ToString(huge_val)) {
-}
-ExceptionFormatValue::ExceptionFormatValue(string str_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(move(str_val)) {
-}
-
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value) {
-	return ExceptionFormatValue(TypeIdToString(value));
-}
-template <>
-ExceptionFormatValue
-ExceptionFormatValue::CreateFormatValue(LogicalType value) { // NOLINT: templating requires us to copy value here
-	return ExceptionFormatValue(value.ToString());
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value) {
-	return ExceptionFormatValue(double(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(double value) {
-	return ExceptionFormatValue(double(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value) {
-	return ExceptionFormatValue(move(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(const char *value) {
-	return ExceptionFormatValue(string(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value) {
-	return ExceptionFormatValue(string(value));
-}
-template <>
-ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value) {
-	return ExceptionFormatValue(value);
-}
-
-string ExceptionFormatValue::Format(const string &msg, vector<ExceptionFormatValue> &values) {
-	std::vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
-	for (auto &val : values) {
-		switch (val.type) {
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.dbl_val));
-			break;
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.int_val));
-			break;
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.str_val));
-			break;
-		}
-	}
-	return duckdb_fmt::vsprintf(msg, duckdb_fmt::basic_format_args<duckdb_fmt::printf_context>(
-	                                     format_args.data(), static_cast<int>(format_args.size())));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Field Writer
-//===--------------------------------------------------------------------===//
-FieldWriter::FieldWriter(Serializer &serializer_p)
-    : serializer(serializer_p), buffer(make_unique<BufferedSerializer>()), field_count(0), finalized(false) {
-}
-
-FieldWriter::~FieldWriter() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	D_ASSERT(finalized);
-	// finalize should always have been called, unless this is destroyed as part of stack unwinding
-	D_ASSERT(!buffer);
-}
-
-void FieldWriter::WriteData(const_data_ptr_t buffer_ptr, idx_t write_size) {
-	D_ASSERT(buffer);
-	buffer->WriteData(buffer_ptr, write_size);
-}
-
-template <>
-void FieldWriter::Write(const string &val) {
-	Write<uint32_t>((uint32_t)val.size());
-	if (!val.empty()) {
-		WriteData((const_data_ptr_t)val.c_str(), val.size());
-	}
-}
-
-void FieldWriter::Finalize() {
-	D_ASSERT(buffer);
-	D_ASSERT(!finalized);
-	finalized = true;
-	serializer.Write<uint32_t>(field_count);
-	serializer.Write<uint64_t>(buffer->blob.size);
-	serializer.WriteData(buffer->blob.data.get(), buffer->blob.size);
-
-	buffer.reset();
-}
-
-//===--------------------------------------------------------------------===//
-// Field Deserializer
-//===--------------------------------------------------------------------===//
-FieldDeserializer::FieldDeserializer(Deserializer &root) : root(root), remaining_data(idx_t(-1)) {
-}
-
-void FieldDeserializer::ReadData(data_ptr_t buffer, idx_t read_size) {
-	D_ASSERT(remaining_data != idx_t(-1));
-	D_ASSERT(read_size <= remaining_data);
-	root.ReadData(buffer, read_size);
-	remaining_data -= read_size;
-}
-
-idx_t FieldDeserializer::RemainingData() {
-	return remaining_data;
-}
-
-void FieldDeserializer::SetRemainingData(idx_t remaining_data) {
-	this->remaining_data = remaining_data;
-}
-
-//===--------------------------------------------------------------------===//
-// Field Reader
-//===--------------------------------------------------------------------===//
-FieldReader::FieldReader(Deserializer &source_p) : source(source_p), field_count(0), finalized(false) {
-	max_field_count = source_p.Read<uint32_t>();
-	total_size = source_p.Read<uint64_t>();
-	D_ASSERT(max_field_count > 0);
-	source.SetRemainingData(total_size);
-}
-
-FieldReader::~FieldReader() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	D_ASSERT(finalized);
-}
-
-void FieldReader::Finalize() {
-	D_ASSERT(!finalized);
-	finalized = true;
-	if (field_count < max_field_count) {
-		// we can handle this case by calling source.ReadData(buffer, source.RemainingData())
-		throw SerializationException("Not all fields were read. This file might have been written with a newer version "
-		                             "of DuckDB and is incompatible with this version of DuckDB.");
-	}
-	D_ASSERT(source.RemainingData() == 0);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-FileBuffer::FileBuffer(Allocator &allocator, FileBufferType type, uint64_t bufsiz)
-    : allocator(allocator), type(type), malloced_buffer(nullptr) {
-	SetMallocedSize(bufsiz);
-	malloced_buffer = allocator.AllocateData(malloced_size);
-	Construct(bufsiz);
-}
-
-FileBuffer::FileBuffer(FileBuffer &source, FileBufferType type_p) : allocator(source.allocator), type(type_p) {
-	// take over the structures of the source buffer
-	buffer = source.buffer;
-	size = source.size;
-	internal_buffer = source.internal_buffer;
-	internal_size = source.internal_size;
-	malloced_buffer = source.malloced_buffer;
-	malloced_size = source.malloced_size;
-
-	source.buffer = nullptr;
-	source.size = 0;
-	source.internal_buffer = nullptr;
-	source.internal_size = 0;
-	source.malloced_buffer = nullptr;
-	source.malloced_size = 0;
-}
-
-FileBuffer::~FileBuffer() {
-	if (!malloced_buffer) {
-		return;
-	}
-	allocator.FreeData(malloced_buffer, malloced_size);
-}
-
-void FileBuffer::SetMallocedSize(uint64_t &bufsiz) {
-	// make room for the block header (if this is not the db file header)
-	if (type == FileBufferType::MANAGED_BUFFER && bufsiz != Storage::FILE_HEADER_SIZE) {
-		bufsiz += Storage::BLOCK_HEADER_SIZE;
-	}
-	malloced_size = bufsiz;
-}
-
-void FileBuffer::Construct(uint64_t bufsiz) {
-	if (!malloced_buffer) {
-		throw std::bad_alloc();
-	}
-	internal_buffer = malloced_buffer;
-	internal_size = malloced_size;
-	buffer = internal_buffer + Storage::BLOCK_HEADER_SIZE;
-	size = internal_size - Storage::BLOCK_HEADER_SIZE;
-}
-
-void FileBuffer::Resize(uint64_t bufsiz) {
-	D_ASSERT(type == FileBufferType::MANAGED_BUFFER);
-	auto old_size = malloced_size;
-	SetMallocedSize(bufsiz);
-	malloced_buffer = allocator.ReallocateData(malloced_buffer, old_size, malloced_size);
-	Construct(bufsiz);
-}
-
-void FileBuffer::Read(FileHandle &handle, uint64_t location) {
-	handle.Read(internal_buffer, internal_size, location);
-}
-
-void FileBuffer::ReadAndChecksum(FileHandle &handle, uint64_t location) {
-	// read the buffer from disk
-	Read(handle, location);
-	// compute the checksum
-	auto stored_checksum = Load<uint64_t>(internal_buffer);
-	uint64_t computed_checksum = Checksum(buffer, size);
-	// verify the checksum
-	if (stored_checksum != computed_checksum) {
-		throw IOException("Corrupt database file: computed checksum %llu does not match stored checksum %llu in block",
-		                  computed_checksum, stored_checksum);
-	}
-}
-
-void FileBuffer::Write(FileHandle &handle, uint64_t location) {
-	handle.Write(internal_buffer, internal_size, location);
-}
-
-void FileBuffer::ChecksumAndWrite(FileHandle &handle, uint64_t location) {
-	// compute the checksum and write it to the start of the buffer (if not temp buffer)
-	uint64_t checksum = Checksum(buffer, size);
-	Store<uint64_t>(checksum, internal_buffer);
-	// now write the buffer
-	Write(handle, location);
-}
-
-void FileBuffer::Clear() {
-	memset(internal_buffer, 0, internal_size);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cstdint>
-#include <cstdio>
-
-#ifndef _WIN32
-#include <dirent.h>
-#include <fcntl.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#else
-#include <string>
-#include <sysinfoapi.h>
-
-#ifdef __MINGW32__
-// need to manually define this for mingw
-extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG);
-#endif
-
-#undef FILE_CREATE // woo mingw
-#endif
-
-namespace duckdb {
-
-FileSystem::~FileSystem() {
-}
-
-FileSystem &FileSystem::GetFileSystem(ClientContext &context) {
-	return *context.db->config.file_system;
-}
-
-FileOpener *FileSystem::GetFileOpener(ClientContext &context) {
-	return ClientData::Get(context).file_opener.get();
-}
-
-#ifndef _WIN32
-string FileSystem::PathSeparator() {
-	return "/";
-}
-
-void FileSystem::SetWorkingDirectory(const string &path) {
-	if (chdir(path.c_str()) != 0) {
-		throw IOException("Could not change working directory!");
-	}
-}
-
-idx_t FileSystem::GetAvailableMemory() {
-	errno = 0;
-	idx_t max_memory = MinValue<idx_t>((idx_t)sysconf(_SC_PHYS_PAGES) * (idx_t)sysconf(_SC_PAGESIZE), UINTPTR_MAX);
-	if (errno != 0) {
-		return DConstants::INVALID_INDEX;
-	}
-	return max_memory;
-}
-
-string FileSystem::GetWorkingDirectory() {
-	auto buffer = unique_ptr<char[]>(new char[PATH_MAX]);
-	char *ret = getcwd(buffer.get(), PATH_MAX);
-	if (!ret) {
-		throw IOException("Could not get working directory!");
-	}
-	return string(buffer.get());
-}
-#else
-
-string FileSystem::PathSeparator() {
-	return "\\";
-}
-
-void FileSystem::SetWorkingDirectory(const string &path) {
-	if (!SetCurrentDirectory(path.c_str())) {
-		throw IOException("Could not change working directory!");
-	}
-}
-
-idx_t FileSystem::GetAvailableMemory() {
-	ULONGLONG available_memory_kb;
-	if (GetPhysicallyInstalledSystemMemory(&available_memory_kb)) {
-		return MinValue<idx_t>(available_memory_kb * 1000, UINTPTR_MAX);
-	}
-	// fallback: try GlobalMemoryStatusEx
-	MEMORYSTATUSEX mem_state;
-	mem_state.dwLength = sizeof(MEMORYSTATUSEX);
-
-	if (GlobalMemoryStatusEx(&mem_state)) {
-		return MinValue<idx_t>(mem_state.ullTotalPhys, UINTPTR_MAX);
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-string FileSystem::GetWorkingDirectory() {
-	idx_t count = GetCurrentDirectory(0, nullptr);
-	if (count == 0) {
-		throw IOException("Could not get working directory!");
-	}
-	auto buffer = unique_ptr<char[]>(new char[count]);
-	idx_t ret = GetCurrentDirectory(count, buffer.get());
-	if (count != ret + 1) {
-		throw IOException("Could not get working directory!");
-	}
-	return string(buffer.get(), ret);
-}
-
-#endif
-
-string FileSystem::JoinPath(const string &a, const string &b) {
-	// FIXME: sanitize paths
-	return a + PathSeparator() + b;
-}
-
-string FileSystem::ConvertSeparators(const string &path) {
-	auto separator_str = PathSeparator();
-	char separator = separator_str[0];
-	if (separator == '/') {
-		// on unix-based systems we only accept / as a separator
-		return path;
-	}
-	// on windows-based systems we accept both
-	string result = path;
-	for (idx_t i = 0; i < result.size(); i++) {
-		if (result[i] == '/') {
-			result[i] = separator;
-		}
-	}
-	return result;
-}
-
-string FileSystem::ExtractBaseName(const string &path) {
-	auto normalized_path = ConvertSeparators(path);
-	auto sep = PathSeparator();
-	auto vec = StringUtil::Split(StringUtil::Split(normalized_path, sep).back(), ".");
-	return vec[0];
-}
-
-string FileSystem::GetHomeDirectory() {
-#ifdef DUCKDB_WINDOWS
-	const char *homedir = getenv("USERPROFILE");
-#else
-	const char *homedir = getenv("HOME");
-#endif
-	if (homedir) {
-		return homedir;
-	}
-	return string();
-}
-
-// LCOV_EXCL_START
-unique_ptr<FileHandle> FileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock,
-                                            FileCompressionType compression, FileOpener *opener) {
-	throw NotImplementedException("%s: OpenFile is not implemented!", GetName());
-}
-
-void FileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	throw NotImplementedException("%s: Read (with location) is not implemented!", GetName());
-}
-
-void FileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	throw NotImplementedException("%s: Write (with location) is not implemented!", GetName());
-}
-
-int64_t FileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	throw NotImplementedException("%s: Read is not implemented!", GetName());
-}
-
-int64_t FileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	throw NotImplementedException("%s: Write is not implemented!", GetName());
-}
-
-int64_t FileSystem::GetFileSize(FileHandle &handle) {
-	throw NotImplementedException("%s: GetFileSize is not implemented!", GetName());
-}
-
-time_t FileSystem::GetLastModifiedTime(FileHandle &handle) {
-	throw NotImplementedException("%s: GetLastModifiedTime is not implemented!", GetName());
-}
-
-FileType FileSystem::GetFileType(FileHandle &handle) {
-	return FileType::FILE_TYPE_INVALID;
-}
-
-void FileSystem::Truncate(FileHandle &handle, int64_t new_size) {
-	throw NotImplementedException("%s: Truncate is not implemented!", GetName());
-}
-
-bool FileSystem::DirectoryExists(const string &directory) {
-	throw NotImplementedException("%s: DirectoryExists is not implemented!", GetName());
-}
-
-void FileSystem::CreateDirectory(const string &directory) {
-	throw NotImplementedException("%s: CreateDirectory is not implemented!", GetName());
-}
-
-void FileSystem::RemoveDirectory(const string &directory) {
-	throw NotImplementedException("%s: RemoveDirectory is not implemented!", GetName());
-}
-
-bool FileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) {
-	throw NotImplementedException("%s: ListFiles is not implemented!", GetName());
-}
-
-void FileSystem::MoveFile(const string &source, const string &target) {
-	throw NotImplementedException("%s: MoveFile is not implemented!", GetName());
-}
-
-bool FileSystem::FileExists(const string &filename) {
-	throw NotImplementedException("%s: FileExists is not implemented!", GetName());
-}
-
-bool FileSystem::IsPipe(const string &filename) {
-	throw NotImplementedException("%s: IsPipe is not implemented!", GetName());
-}
-
-void FileSystem::RemoveFile(const string &filename) {
-	throw NotImplementedException("%s: RemoveFile is not implemented!", GetName());
-}
-
-void FileSystem::FileSync(FileHandle &handle) {
-	throw NotImplementedException("%s: FileSync is not implemented!", GetName());
-}
-
-vector<string> FileSystem::Glob(const string &path, FileOpener *opener) {
-	throw NotImplementedException("%s: Glob is not implemented!", GetName());
-}
-
-vector<string> FileSystem::Glob(const string &path, ClientContext &context) {
-	return Glob(path, GetFileOpener(context));
-}
-
-void FileSystem::RegisterSubSystem(unique_ptr<FileSystem> sub_fs) {
-	throw NotImplementedException("%s: Can't register a sub system on a non-virtual file system", GetName());
-}
-
-void FileSystem::RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> sub_fs) {
-	throw NotImplementedException("%s: Can't register a sub system on a non-virtual file system", GetName());
-}
-
-bool FileSystem::CanHandleFile(const string &fpath) {
-	throw NotImplementedException("%s: CanHandleFile is not implemented!", GetName());
-}
-
-void FileSystem::Seek(FileHandle &handle, idx_t location) {
-	throw NotImplementedException("%s: Seek is not implemented!", GetName());
-}
-
-void FileSystem::Reset(FileHandle &handle) {
-	handle.Seek(0);
-}
-
-idx_t FileSystem::SeekPosition(FileHandle &handle) {
-	throw NotImplementedException("%s: SeekPosition is not implemented!", GetName());
-}
-
-bool FileSystem::CanSeek() {
-	throw NotImplementedException("%s: CanSeek is not implemented!", GetName());
-}
-
-unique_ptr<FileHandle> FileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
-	throw NotImplementedException("%s: OpenCompressedFile is not implemented!", GetName());
-}
-
-bool FileSystem::OnDiskFile(FileHandle &handle) {
-	throw NotImplementedException("%s: OnDiskFile is not implemented!", GetName());
-}
-// LCOV_EXCL_STOP
-
-FileHandle::FileHandle(FileSystem &file_system, string path_p) : file_system(file_system), path(move(path_p)) {
-}
-
-FileHandle::~FileHandle() {
-}
-
-int64_t FileHandle::Read(void *buffer, idx_t nr_bytes) {
-	return file_system.Read(*this, buffer, nr_bytes);
-}
-
-int64_t FileHandle::Write(void *buffer, idx_t nr_bytes) {
-	return file_system.Write(*this, buffer, nr_bytes);
-}
-
-void FileHandle::Read(void *buffer, idx_t nr_bytes, idx_t location) {
-	file_system.Read(*this, buffer, nr_bytes, location);
-}
-
-void FileHandle::Write(void *buffer, idx_t nr_bytes, idx_t location) {
-	file_system.Write(*this, buffer, nr_bytes, location);
-}
-
-void FileHandle::Seek(idx_t location) {
-	file_system.Seek(*this, location);
-}
-
-void FileHandle::Reset() {
-	file_system.Reset(*this);
-}
-
-idx_t FileHandle::SeekPosition() {
-	return file_system.SeekPosition(*this);
-}
-
-bool FileHandle::CanSeek() {
-	return file_system.CanSeek();
-}
-
-string FileHandle::ReadLine() {
-	string result;
-	char buffer[1];
-	while (true) {
-		idx_t tuples_read = Read(buffer, 1);
-		if (tuples_read == 0 || buffer[0] == '\n') {
-			return result;
-		}
-		if (buffer[0] != '\r') {
-			result += buffer[0];
-		}
-	}
-}
-
-bool FileHandle::OnDiskFile() {
-	return file_system.OnDiskFile(*this);
-}
-
-idx_t FileHandle::GetFileSize() {
-	return file_system.GetFileSize(*this);
-}
-
-void FileHandle::Sync() {
-	file_system.FileSync(*this);
-}
-
-void FileHandle::Truncate(int64_t new_size) {
-	file_system.Truncate(*this, new_size);
-}
-
-FileType FileHandle::GetType() {
-	return file_system.GetFileType(*this);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-/*
-
-  0      2 bytes  magic header  0x1f, 0x8b (\037 \213)
-  2      1 byte   compression method
-                     0: store (copied)
-                     1: compress
-                     2: pack
-                     3: lzh
-                     4..7: reserved
-                     8: deflate
-  3      1 byte   flags
-                     bit 0 set: file probably ascii text
-                     bit 1 set: continuation of multi-part gzip file, part number present
-                     bit 2 set: extra field present
-                     bit 3 set: original file name present
-                     bit 4 set: file comment present
-                     bit 5 set: file is encrypted, encryption header present
-                     bit 6,7:   reserved
-  4      4 bytes  file modification time in Unix format
-  8      1 byte   extra flags (depend on compression method)
-  9      1 byte   OS type
-[
-         2 bytes  optional part number (second part=1)
-]?
-[
-         2 bytes  optional extra field length (e)
-        (e)bytes  optional extra field
-]?
-[
-           bytes  optional original file name, zero terminated
-]?
-[
-           bytes  optional file comment, zero terminated
-]?
-[
-        12 bytes  optional encryption header
-]?
-           bytes  compressed data
-         4 bytes  crc32
-         4 bytes  uncompressed input size modulo 2^32
-
- */
-
-static idx_t GZipConsumeString(FileHandle &input) {
-	idx_t size = 1; // terminator
-	char buffer[1];
-	while (input.Read(buffer, 1) == 1) {
-		if (buffer[0] == '\0') {
-			break;
-		}
-		size++;
-	}
-	return size;
-}
-
-struct MiniZStreamWrapper : public StreamWrapper {
-	~MiniZStreamWrapper() override;
-
-	CompressedFile *file = nullptr;
-	duckdb_miniz::mz_stream *mz_stream_ptr = nullptr;
-	bool writing = false;
-	duckdb_miniz::mz_ulong crc;
-	idx_t total_size;
-
-public:
-	void Initialize(CompressedFile &file, bool write) override;
-
-	bool Read(StreamData &stream_data) override;
-	void Write(CompressedFile &file, StreamData &stream_data, data_ptr_t buffer, int64_t nr_bytes) override;
-
-	void Close() override;
-
-	void FlushStream();
-};
-
-MiniZStreamWrapper::~MiniZStreamWrapper() {
-	// avoid closing if destroyed during stack unwinding
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	try {
-		Close();
-	} catch (...) {
-	}
-}
-
-void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
-	Close();
-	this->file = &file;
-	mz_stream_ptr = new duckdb_miniz::mz_stream();
-	memset(mz_stream_ptr, 0, sizeof(duckdb_miniz::mz_stream));
-	this->writing = write;
-
-	// TODO use custom alloc/free methods in miniz to throw exceptions on OOM
-	uint8_t gzip_hdr[GZIP_HEADER_MINSIZE];
-	if (write) {
-		crc = MZ_CRC32_INIT;
-		total_size = 0;
-
-		MiniZStream::InitializeGZIPHeader(gzip_hdr);
-		file.child_handle->Write(gzip_hdr, GZIP_HEADER_MINSIZE);
-
-		auto ret = mz_deflateInit2((duckdb_miniz::mz_streamp)mz_stream_ptr, duckdb_miniz::MZ_DEFAULT_LEVEL, MZ_DEFLATED,
-		                           -MZ_DEFAULT_WINDOW_BITS, 1, 0);
-		if (ret != duckdb_miniz::MZ_OK) {
-			throw InternalException("Failed to initialize miniz");
-		}
-	} else {
-		idx_t data_start = GZIP_HEADER_MINSIZE;
-		auto read_count = file.child_handle->Read(gzip_hdr, GZIP_HEADER_MINSIZE);
-		GZipFileSystem::VerifyGZIPHeader(gzip_hdr, read_count);
-
-		if (gzip_hdr[3] & GZIP_FLAG_NAME) {
-			file.child_handle->Seek(data_start);
-			data_start += GZipConsumeString(*file.child_handle);
-		}
-		file.child_handle->Seek(data_start);
-		// stream is now set to beginning of payload data
-		auto ret = duckdb_miniz::mz_inflateInit2((duckdb_miniz::mz_streamp)mz_stream_ptr, -MZ_DEFAULT_WINDOW_BITS);
-		if (ret != duckdb_miniz::MZ_OK) {
-			throw InternalException("Failed to initialize miniz");
-		}
-	}
-}
-
-bool MiniZStreamWrapper::Read(StreamData &sd) {
-	// actually decompress
-	mz_stream_ptr->next_in = (data_ptr_t)sd.in_buff_start;
-	D_ASSERT(sd.in_buff_end - sd.in_buff_start < NumericLimits<int32_t>::Maximum());
-	mz_stream_ptr->avail_in = (uint32_t)(sd.in_buff_end - sd.in_buff_start);
-	mz_stream_ptr->next_out = (data_ptr_t)sd.out_buff_end;
-	mz_stream_ptr->avail_out = (uint32_t)((sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_end);
-	auto ret = duckdb_miniz::mz_inflate(mz_stream_ptr, duckdb_miniz::MZ_NO_FLUSH);
-	if (ret != duckdb_miniz::MZ_OK && ret != duckdb_miniz::MZ_STREAM_END) {
-		throw IOException("Failed to decode gzip stream: %s", duckdb_miniz::mz_error(ret));
-	}
-	// update pointers following inflate()
-	sd.in_buff_start = (data_ptr_t)mz_stream_ptr->next_in;
-	sd.in_buff_end = sd.in_buff_start + mz_stream_ptr->avail_in;
-	sd.out_buff_end = (data_ptr_t)mz_stream_ptr->next_out;
-	D_ASSERT(sd.out_buff_end + mz_stream_ptr->avail_out == sd.out_buff.get() + sd.out_buf_size);
-	// if stream ended, deallocate inflator
-	if (ret == duckdb_miniz::MZ_STREAM_END) {
-		Close();
-		return true;
-	}
-	return false;
-}
-
-void MiniZStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t uncompressed_data,
-                               int64_t uncompressed_size) {
-	// update the src and the total size
-	crc = duckdb_miniz::mz_crc32(crc, (const unsigned char *)uncompressed_data, uncompressed_size);
-	total_size += uncompressed_size;
-
-	auto remaining = uncompressed_size;
-	while (remaining > 0) {
-		idx_t output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start;
-
-		mz_stream_ptr->next_in = (const unsigned char *)uncompressed_data;
-		mz_stream_ptr->avail_in = remaining;
-		mz_stream_ptr->next_out = sd.out_buff_start;
-		mz_stream_ptr->avail_out = output_remaining;
-
-		auto res = mz_deflate(mz_stream_ptr, duckdb_miniz::MZ_NO_FLUSH);
-		if (res != duckdb_miniz::MZ_OK) {
-			D_ASSERT(res != duckdb_miniz::MZ_STREAM_END);
-			throw InternalException("Failed to compress GZIP block");
-		}
-		sd.out_buff_start += output_remaining - mz_stream_ptr->avail_out;
-		if (mz_stream_ptr->avail_out == 0) {
-			// no more output buffer available: flush
-			file.child_handle->Write(sd.out_buff.get(), sd.out_buff_start - sd.out_buff.get());
-			sd.out_buff_start = sd.out_buff.get();
-		}
-		idx_t written = remaining - mz_stream_ptr->avail_in;
-		uncompressed_data += written;
-		remaining = mz_stream_ptr->avail_in;
-	}
-}
-
-void MiniZStreamWrapper::FlushStream() {
-	auto &sd = file->stream_data;
-	mz_stream_ptr->next_in = nullptr;
-	mz_stream_ptr->avail_in = 0;
-	while (true) {
-		auto output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start;
-		mz_stream_ptr->next_out = sd.out_buff_start;
-		mz_stream_ptr->avail_out = output_remaining;
-
-		auto res = mz_deflate(mz_stream_ptr, duckdb_miniz::MZ_FINISH);
-		sd.out_buff_start += (output_remaining - mz_stream_ptr->avail_out);
-		if (sd.out_buff_start > sd.out_buff.get()) {
-			file->child_handle->Write(sd.out_buff.get(), sd.out_buff_start - sd.out_buff.get());
-			sd.out_buff_start = sd.out_buff.get();
-		}
-		if (res == duckdb_miniz::MZ_STREAM_END) {
-			break;
-		}
-		if (res != duckdb_miniz::MZ_OK) {
-			throw InternalException("Failed to compress GZIP block");
-		}
-	}
-}
-
-void MiniZStreamWrapper::Close() {
-	if (!mz_stream_ptr) {
-		return;
-	}
-	if (writing) {
-		// flush anything remaining in the stream
-		FlushStream();
-
-		// write the footer
-		unsigned char gzip_footer[MiniZStream::GZIP_FOOTER_SIZE];
-		MiniZStream::InitializeGZIPFooter(gzip_footer, crc, total_size);
-		file->child_handle->Write(gzip_footer, MiniZStream::GZIP_FOOTER_SIZE);
-
-		duckdb_miniz::mz_deflateEnd(mz_stream_ptr);
-	} else {
-		duckdb_miniz::mz_inflateEnd(mz_stream_ptr);
-	}
-	delete mz_stream_ptr;
-	mz_stream_ptr = nullptr;
-	file = nullptr;
-}
-
-class GZipFile : public CompressedFile {
-public:
-	GZipFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
-	    : CompressedFile(gzip_fs, move(child_handle_p), path) {
-		Initialize(write);
-	}
-
-	GZipFileSystem gzip_fs;
-};
-
-void GZipFileSystem::VerifyGZIPHeader(uint8_t gzip_hdr[], idx_t read_count) {
-	// check for incorrectly formatted files
-	if (read_count != GZIP_HEADER_MINSIZE) {
-		throw IOException("Input is not a GZIP stream");
-	}
-	if (gzip_hdr[0] != 0x1F || gzip_hdr[1] != 0x8B) { // magic header
-		throw IOException("Input is not a GZIP stream");
-	}
-	if (gzip_hdr[2] != GZIP_COMPRESSION_DEFLATE) { // compression method
-		throw IOException("Unsupported GZIP compression method");
-	}
-	if (gzip_hdr[3] & GZIP_FLAG_UNSUPPORTED) {
-		throw IOException("Unsupported GZIP archive");
-	}
-}
-
-string GZipFileSystem::UncompressGZIPString(const string &in) {
-	// decompress file
-	auto body_ptr = in.data();
-
-	auto mz_stream_ptr = new duckdb_miniz::mz_stream();
-	memset(mz_stream_ptr, 0, sizeof(duckdb_miniz::mz_stream));
-
-	uint8_t gzip_hdr[GZIP_HEADER_MINSIZE];
-
-	// check for incorrectly formatted files
-
-	// TODO this is mostly the same as gzip_file_system.cpp
-	if (in.size() < GZIP_HEADER_MINSIZE) {
-		throw IOException("Input is not a GZIP stream");
-	}
-	memcpy(gzip_hdr, body_ptr, GZIP_HEADER_MINSIZE);
-	body_ptr += GZIP_HEADER_MINSIZE;
-	GZipFileSystem::VerifyGZIPHeader(gzip_hdr, GZIP_HEADER_MINSIZE);
-
-	if (gzip_hdr[3] & GZIP_FLAG_NAME) {
-		char c;
-		do {
-			c = *body_ptr;
-			body_ptr++;
-		} while (c != '\0' && (idx_t)(body_ptr - in.data()) < in.size());
-	}
-
-	// stream is now set to beginning of payload data
-	auto status = duckdb_miniz::mz_inflateInit2(mz_stream_ptr, -MZ_DEFAULT_WINDOW_BITS);
-	if (status != duckdb_miniz::MZ_OK) {
-		throw InternalException("Failed to initialize miniz");
-	}
-
-	auto bytes_remaining = in.size() - (body_ptr - in.data());
-	mz_stream_ptr->next_in = (unsigned char *)body_ptr;
-	mz_stream_ptr->avail_in = bytes_remaining;
-
-	unsigned char decompress_buffer[BUFSIZ];
-	string decompressed;
-
-	while (status == duckdb_miniz::MZ_OK) {
-		mz_stream_ptr->next_out = decompress_buffer;
-		mz_stream_ptr->avail_out = sizeof(decompress_buffer);
-		status = mz_inflate(mz_stream_ptr, duckdb_miniz::MZ_NO_FLUSH);
-		if (status != duckdb_miniz::MZ_STREAM_END && status != duckdb_miniz::MZ_OK) {
-			throw IOException("Failed to uncompress");
-		}
-		decompressed.append((char *)decompress_buffer, mz_stream_ptr->total_out - decompressed.size());
-	}
-	duckdb_miniz::mz_inflateEnd(mz_stream_ptr);
-	if (decompressed.empty()) {
-		throw IOException("Failed to uncompress");
-	}
-	return decompressed;
-}
-
-unique_ptr<FileHandle> GZipFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
-	auto path = handle->path;
-	return make_unique<GZipFile>(move(handle), path, write);
-}
-
-unique_ptr<StreamWrapper> GZipFileSystem::CreateStream() {
-	return make_unique<MiniZStreamWrapper>();
-}
-
-idx_t GZipFileSystem::InBufferSize() {
-	return BUFFER_SIZE;
-}
-
-idx_t GZipFileSystem::OutBufferSize() {
-	return BUFFER_SIZE;
-}
-
-} // namespace duckdb
-
-
-
-
-#include <limits>
-
-namespace duckdb {
-
-using std::numeric_limits;
-
-int8_t NumericLimits<int8_t>::Minimum() {
-	return numeric_limits<int8_t>::lowest();
-}
-
-int8_t NumericLimits<int8_t>::Maximum() {
-	return numeric_limits<int8_t>::max();
-}
-
-int16_t NumericLimits<int16_t>::Minimum() {
-	return numeric_limits<int16_t>::lowest();
-}
-
-int16_t NumericLimits<int16_t>::Maximum() {
-	return numeric_limits<int16_t>::max();
-}
-
-int32_t NumericLimits<int32_t>::Minimum() {
-	return numeric_limits<int32_t>::lowest();
-}
-
-int32_t NumericLimits<int32_t>::Maximum() {
-	return numeric_limits<int32_t>::max();
-}
-
-int64_t NumericLimits<int64_t>::Minimum() {
-	return numeric_limits<int64_t>::lowest();
-}
-
-int64_t NumericLimits<int64_t>::Maximum() {
-	return numeric_limits<int64_t>::max();
-}
-
-float NumericLimits<float>::Minimum() {
-	return numeric_limits<float>::lowest();
-}
-
-float NumericLimits<float>::Maximum() {
-	return numeric_limits<float>::max();
-}
-
-double NumericLimits<double>::Minimum() {
-	return numeric_limits<double>::lowest();
-}
-
-double NumericLimits<double>::Maximum() {
-	return numeric_limits<double>::max();
-}
-
-uint8_t NumericLimits<uint8_t>::Minimum() {
-	return numeric_limits<uint8_t>::lowest();
-}
-
-uint8_t NumericLimits<uint8_t>::Maximum() {
-	return numeric_limits<uint8_t>::max();
-}
-
-uint16_t NumericLimits<uint16_t>::Minimum() {
-	return numeric_limits<uint16_t>::lowest();
-}
-
-uint16_t NumericLimits<uint16_t>::Maximum() {
-	return numeric_limits<uint16_t>::max();
-}
-
-uint32_t NumericLimits<uint32_t>::Minimum() {
-	return numeric_limits<uint32_t>::lowest();
-}
-
-uint32_t NumericLimits<uint32_t>::Maximum() {
-	return numeric_limits<uint32_t>::max();
-}
-
-uint64_t NumericLimits<uint64_t>::Minimum() {
-	return numeric_limits<uint64_t>::lowest();
-}
-
-uint64_t NumericLimits<uint64_t>::Maximum() {
-	return numeric_limits<uint64_t>::max();
-}
-
-hugeint_t NumericLimits<hugeint_t>::Minimum() {
-	hugeint_t result;
-	result.lower = 1;
-	result.upper = numeric_limits<int64_t>::lowest();
-	return result;
-}
-
-hugeint_t NumericLimits<hugeint_t>::Maximum() {
-	hugeint_t result;
-	result.lower = numeric_limits<uint64_t>::max();
-	result.upper = numeric_limits<int64_t>::max();
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cstdint>
-#include <cstdio>
-#include <sys/stat.h>
-
-#ifndef _WIN32
-#include <dirent.h>
-#include <fcntl.h>
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
-#else
-
-
-#include <io.h>
-#include <string>
-
-#ifdef __MINGW32__
-// need to manually define this for mingw
-extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG);
-#endif
-
-#undef FILE_CREATE // woo mingw
-#endif
-
-namespace duckdb {
-
-static void AssertValidFileFlags(uint8_t flags) {
-#ifdef DEBUG
-	bool is_read = flags & FileFlags::FILE_FLAGS_READ;
-	bool is_write = flags & FileFlags::FILE_FLAGS_WRITE;
-	// require either READ or WRITE (or both)
-	D_ASSERT(is_read || is_write);
-	// CREATE/Append flags require writing
-	D_ASSERT(is_write || !(flags & FileFlags::FILE_FLAGS_APPEND));
-	D_ASSERT(is_write || !(flags & FileFlags::FILE_FLAGS_FILE_CREATE));
-	D_ASSERT(is_write || !(flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW));
-	// cannot combine CREATE and CREATE_NEW flags
-	D_ASSERT(!(flags & FileFlags::FILE_FLAGS_FILE_CREATE && flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW));
-#endif
-}
-
-#ifndef _WIN32
-bool LocalFileSystem::FileExists(const string &filename) {
-	if (!filename.empty()) {
-		if (access(filename.c_str(), 0) == 0) {
-			struct stat status;
-			stat(filename.c_str(), &status);
-			if (S_ISREG(status.st_mode)) {
-				return true;
-			}
-		}
-	}
-	// if any condition fails
-	return false;
-}
-
-bool LocalFileSystem::IsPipe(const string &filename) {
-	if (!filename.empty()) {
-		if (access(filename.c_str(), 0) == 0) {
-			struct stat status;
-			stat(filename.c_str(), &status);
-			if (S_ISFIFO(status.st_mode)) {
-				return true;
-			}
-		}
-	}
-	// if any condition fails
-	return false;
-}
-
-#else
-bool LocalFileSystem::FileExists(const string &filename) {
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
-	const wchar_t *wpath = unicode_path.c_str();
-	if (_waccess(wpath, 0) == 0) {
-		struct _stati64 status;
-		_wstati64(wpath, &status);
-		if (status.st_mode & S_IFREG) {
-			return true;
-		}
-	}
-	return false;
-}
-bool LocalFileSystem::IsPipe(const string &filename) {
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
-	const wchar_t *wpath = unicode_path.c_str();
-	if (_waccess(wpath, 0) == 0) {
-		struct _stati64 status;
-		_wstati64(wpath, &status);
-		if (status.st_mode & _S_IFCHR) {
-			return true;
-		}
-	}
-	return false;
-}
-#endif
-
-#ifndef _WIN32
-// somehow sometimes this is missing
-#ifndef O_CLOEXEC
-#define O_CLOEXEC 0
-#endif
-
-// Solaris
-#ifndef O_DIRECT
-#define O_DIRECT 0
-#endif
-
-struct UnixFileHandle : public FileHandle {
-public:
-	UnixFileHandle(FileSystem &file_system, string path, int fd) : FileHandle(file_system, move(path)), fd(fd) {
-	}
-	~UnixFileHandle() override {
-		Close();
-	}
-
-	int fd;
-
-public:
-	void Close() override {
-		if (fd != -1) {
-			close(fd);
-		}
-	};
-};
-
-static FileType GetFileTypeInternal(int fd) { // LCOV_EXCL_START
-	struct stat s;
-	if (fstat(fd, &s) == -1) {
-		return FileType::FILE_TYPE_INVALID;
-	}
-	switch (s.st_mode & S_IFMT) {
-	case S_IFBLK:
-		return FileType::FILE_TYPE_BLOCKDEV;
-	case S_IFCHR:
-		return FileType::FILE_TYPE_CHARDEV;
-	case S_IFIFO:
-		return FileType::FILE_TYPE_FIFO;
-	case S_IFDIR:
-		return FileType::FILE_TYPE_DIR;
-	case S_IFLNK:
-		return FileType::FILE_TYPE_LINK;
-	case S_IFREG:
-		return FileType::FILE_TYPE_REGULAR;
-	case S_IFSOCK:
-		return FileType::FILE_TYPE_SOCKET;
-	default:
-		return FileType::FILE_TYPE_INVALID;
-	}
-} // LCOV_EXCL_STOP
-
-unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock_type,
-                                                 FileCompressionType compression, FileOpener *opener) {
-	if (compression != FileCompressionType::UNCOMPRESSED) {
-		throw NotImplementedException("Unsupported compression type for default file system");
-	}
-
-	AssertValidFileFlags(flags);
-
-	int open_flags = 0;
-	int rc;
-	bool open_read = flags & FileFlags::FILE_FLAGS_READ;
-	bool open_write = flags & FileFlags::FILE_FLAGS_WRITE;
-	if (open_read && open_write) {
-		open_flags = O_RDWR;
-	} else if (open_read) {
-		open_flags = O_RDONLY;
-	} else if (open_write) {
-		open_flags = O_WRONLY;
-	} else {
-		throw InternalException("READ, WRITE or both should be specified when opening a file");
-	}
-	if (open_write) {
-		// need Read or Write
-		D_ASSERT(flags & FileFlags::FILE_FLAGS_WRITE);
-		open_flags |= O_CLOEXEC;
-		if (flags & FileFlags::FILE_FLAGS_FILE_CREATE) {
-			open_flags |= O_CREAT;
-		} else if (flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW) {
-			open_flags |= O_CREAT | O_TRUNC;
-		}
-		if (flags & FileFlags::FILE_FLAGS_APPEND) {
-			open_flags |= O_APPEND;
-		}
-	}
-	if (flags & FileFlags::FILE_FLAGS_DIRECT_IO) {
-#if defined(__sun) && defined(__SVR4)
-		throw Exception("DIRECT_IO not supported on Solaris");
-#endif
-#if defined(__DARWIN__) || defined(__APPLE__) || defined(__OpenBSD__)
-		// OSX does not have O_DIRECT, instead we need to use fcntl afterwards to support direct IO
-		open_flags |= O_SYNC;
-#else
-		open_flags |= O_DIRECT | O_SYNC;
-#endif
-	}
-	int fd = open(path.c_str(), open_flags, 0666);
-	if (fd == -1) {
-		throw IOException("Cannot open file \"%s\": %s", path, strerror(errno));
-	}
-	// #if defined(__DARWIN__) || defined(__APPLE__)
-	// 	if (flags & FileFlags::FILE_FLAGS_DIRECT_IO) {
-	// 		// OSX requires fcntl for Direct IO
-	// 		rc = fcntl(fd, F_NOCACHE, 1);
-	// 		if (fd == -1) {
-	// 			throw IOException("Could not enable direct IO for file \"%s\": %s", path, strerror(errno));
-	// 		}
-	// 	}
-	// #endif
-	if (lock_type != FileLockType::NO_LOCK) {
-		// set lock on file
-		// but only if it is not an input/output stream
-		auto file_type = GetFileTypeInternal(fd);
-		if (file_type != FileType::FILE_TYPE_FIFO && file_type != FileType::FILE_TYPE_SOCKET) {
-			struct flock fl;
-			memset(&fl, 0, sizeof fl);
-			fl.l_type = lock_type == FileLockType::READ_LOCK ? F_RDLCK : F_WRLCK;
-			fl.l_whence = SEEK_SET;
-			fl.l_start = 0;
-			fl.l_len = 0;
-			rc = fcntl(fd, F_SETLK, &fl);
-			if (rc == -1) {
-				throw IOException("Could not set lock on file \"%s\": %s", path, strerror(errno));
-			}
-		}
-	}
-	return make_unique<UnixFileHandle>(*this, path, fd);
-}
-
-void LocalFileSystem::SetFilePointer(FileHandle &handle, idx_t location) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	off_t offset = lseek(fd, location, SEEK_SET);
-	if (offset == (off_t)-1) {
-		throw IOException("Could not seek to location %lld for file \"%s\": %s", location, handle.path,
-		                  strerror(errno));
-	}
-}
-
-idx_t LocalFileSystem::GetFilePointer(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	off_t position = lseek(fd, 0, SEEK_CUR);
-	if (position == (off_t)-1) {
-		throw IOException("Could not get file position file \"%s\": %s", handle.path, strerror(errno));
-	}
-	return position;
-}
-
-void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	int64_t bytes_read = pread(fd, buffer, nr_bytes, location);
-	if (bytes_read == -1) {
-		throw IOException("Could not read from file \"%s\": %s", handle.path, strerror(errno));
-	}
-	if (bytes_read != nr_bytes) {
-		throw IOException("Could not read all bytes from file \"%s\": wanted=%lld read=%lld", handle.path, nr_bytes,
-		                  bytes_read);
-	}
-}
-
-int64_t LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	int64_t bytes_read = read(fd, buffer, nr_bytes);
-	if (bytes_read == -1) {
-		throw IOException("Could not read from file \"%s\": %s", handle.path, strerror(errno));
-	}
-	return bytes_read;
-}
-
-void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	int64_t bytes_written = pwrite(fd, buffer, nr_bytes, location);
-	if (bytes_written == -1) {
-		throw IOException("Could not write file \"%s\": %s", handle.path, strerror(errno));
-	}
-	if (bytes_written != nr_bytes) {
-		throw IOException("Could not write all bytes to file \"%s\": wanted=%lld wrote=%lld", handle.path, nr_bytes,
-		                  bytes_written);
-	}
-}
-
-int64_t LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	int64_t bytes_written = write(fd, buffer, nr_bytes);
-	if (bytes_written == -1) {
-		throw IOException("Could not write file \"%s\": %s", handle.path, strerror(errno));
-	}
-	return bytes_written;
-}
-
-int64_t LocalFileSystem::GetFileSize(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	struct stat s;
-	if (fstat(fd, &s) == -1) {
-		return -1;
-	}
-	return s.st_size;
-}
-
-time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	struct stat s;
-	if (fstat(fd, &s) == -1) {
-		return -1;
-	}
-	return s.st_mtime;
-}
-
-FileType LocalFileSystem::GetFileType(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	return GetFileTypeInternal(fd);
-}
-
-void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	if (ftruncate(fd, new_size) != 0) {
-		throw IOException("Could not truncate file \"%s\": %s", handle.path, strerror(errno));
-	}
-}
-
-bool LocalFileSystem::DirectoryExists(const string &directory) {
-	if (!directory.empty()) {
-		if (access(directory.c_str(), 0) == 0) {
-			struct stat status;
-			stat(directory.c_str(), &status);
-			if (status.st_mode & S_IFDIR) {
-				return true;
-			}
-		}
-	}
-	// if any condition fails
-	return false;
-}
-
-void LocalFileSystem::CreateDirectory(const string &directory) {
-	struct stat st;
-
-	if (stat(directory.c_str(), &st) != 0) {
-		/* Directory does not exist. EEXIST for race condition */
-		if (mkdir(directory.c_str(), 0755) != 0 && errno != EEXIST) {
-			throw IOException("Failed to create directory \"%s\"!", directory);
-		}
-	} else if (!S_ISDIR(st.st_mode)) {
-		throw IOException("Failed to create directory \"%s\": path exists but is not a directory!", directory);
-	}
-}
-
-int RemoveDirectoryRecursive(const char *path) {
-	DIR *d = opendir(path);
-	idx_t path_len = (idx_t)strlen(path);
-	int r = -1;
-
-	if (d) {
-		struct dirent *p;
-		r = 0;
-		while (!r && (p = readdir(d))) {
-			int r2 = -1;
-			char *buf;
-			idx_t len;
-			/* Skip the names "." and ".." as we don't want to recurse on them. */
-			if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, "..")) {
-				continue;
-			}
-			len = path_len + (idx_t)strlen(p->d_name) + 2;
-			buf = new char[len];
-			if (buf) {
-				struct stat statbuf;
-				snprintf(buf, len, "%s/%s", path, p->d_name);
-				if (!stat(buf, &statbuf)) {
-					if (S_ISDIR(statbuf.st_mode)) {
-						r2 = RemoveDirectoryRecursive(buf);
-					} else {
-						r2 = unlink(buf);
-					}
-				}
-				delete[] buf;
-			}
-			r = r2;
-		}
-		closedir(d);
-	}
-	if (!r) {
-		r = rmdir(path);
-	}
-	return r;
-}
-
-void LocalFileSystem::RemoveDirectory(const string &directory) {
-	RemoveDirectoryRecursive(directory.c_str());
-}
-
-void LocalFileSystem::RemoveFile(const string &filename) {
-	if (std::remove(filename.c_str()) != 0) {
-		throw IOException("Could not remove file \"%s\": %s", filename, strerror(errno));
-	}
-}
-
-bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) {
-	if (!DirectoryExists(directory)) {
-		return false;
-	}
-	DIR *dir = opendir(directory.c_str());
-	if (!dir) {
-		return false;
-	}
-	struct dirent *ent;
-	// loop over all files in the directory
-	while ((ent = readdir(dir)) != nullptr) {
-		string name = string(ent->d_name);
-		// skip . .. and empty files
-		if (name.empty() || name == "." || name == "..") {
-			continue;
-		}
-		// now stat the file to figure out if it is a regular file or directory
-		string full_path = JoinPath(directory, name);
-		if (access(full_path.c_str(), 0) != 0) {
-			continue;
-		}
-		struct stat status;
-		stat(full_path.c_str(), &status);
-		if (!(status.st_mode & S_IFREG) && !(status.st_mode & S_IFDIR)) {
-			// not a file or directory: skip
-			continue;
-		}
-		// invoke callback
-		callback(name, status.st_mode & S_IFDIR);
-	}
-	closedir(dir);
-	return true;
-}
-
-void LocalFileSystem::FileSync(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
-	if (fsync(fd) != 0) {
-		throw FatalException("fsync failed!");
-	}
-}
-
-void LocalFileSystem::MoveFile(const string &source, const string &target) {
-	//! FIXME: rename does not guarantee atomicity or overwriting target file if it exists
-	if (rename(source.c_str(), target.c_str()) != 0) {
-		throw IOException("Could not rename file!");
-	}
-}
-
-std::string LocalFileSystem::GetLastErrorAsString() {
-	return string();
-}
-
-#else
-
-constexpr char PIPE_PREFIX[] = "\\\\.\\pipe\\";
-
-// Returns the last Win32 error, in string format. Returns an empty string if there is no error.
-std::string LocalFileSystem::GetLastErrorAsString() {
-	// Get the error message, if any.
-	DWORD errorMessageID = GetLastError();
-	if (errorMessageID == 0)
-		return std::string(); // No error message has been recorded
-
-	LPSTR messageBuffer = nullptr;
-	idx_t size =
-	    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-	                   NULL, errorMessageID, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);
-
-	std::string message(messageBuffer, size);
-
-	// Free the buffer.
-	LocalFree(messageBuffer);
-
-	return message;
-}
-
-struct WindowsFileHandle : public FileHandle {
-public:
-	WindowsFileHandle(FileSystem &file_system, string path, HANDLE fd)
-	    : FileHandle(file_system, path), position(0), fd(fd) {
-	}
-	virtual ~WindowsFileHandle() {
-		Close();
-	}
-
-	idx_t position;
-	HANDLE fd;
-
-public:
-	void Close() override {
-		if (!fd) {
-			return;
-		}
-		CloseHandle(fd);
-		fd = nullptr;
-	};
-};
-
-unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock_type,
-                                                 FileCompressionType compression, FileOpener *opener) {
-	if (compression != FileCompressionType::UNCOMPRESSED) {
-		throw NotImplementedException("Unsupported compression type for default file system");
-	}
-	AssertValidFileFlags(flags);
-
-	DWORD desired_access;
-	DWORD share_mode;
-	DWORD creation_disposition = OPEN_EXISTING;
-	DWORD flags_and_attributes = FILE_ATTRIBUTE_NORMAL;
-	bool open_read = flags & FileFlags::FILE_FLAGS_READ;
-	bool open_write = flags & FileFlags::FILE_FLAGS_WRITE;
-	if (open_read && open_write) {
-		desired_access = GENERIC_READ | GENERIC_WRITE;
-		share_mode = 0;
-	} else if (open_read) {
-		desired_access = GENERIC_READ;
-		share_mode = FILE_SHARE_READ;
-	} else if (open_write) {
-		desired_access = GENERIC_WRITE;
-		share_mode = 0;
-	} else {
-		throw InternalException("READ, WRITE or both should be specified when opening a file");
-	}
-	if (open_write) {
-		if (flags & FileFlags::FILE_FLAGS_FILE_CREATE) {
-			creation_disposition = OPEN_ALWAYS;
-		} else if (flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW) {
-			creation_disposition = CREATE_ALWAYS;
-		}
-	}
-	if (flags & FileFlags::FILE_FLAGS_DIRECT_IO) {
-		flags_and_attributes |= FILE_FLAG_NO_BUFFERING;
-	}
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(path.c_str());
-	HANDLE hFile = CreateFileW(unicode_path.c_str(), desired_access, share_mode, NULL, creation_disposition,
-	                           flags_and_attributes, NULL);
-	if (hFile == INVALID_HANDLE_VALUE) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Cannot open file \"%s\": %s", path.c_str(), error);
-	}
-	auto handle = make_unique<WindowsFileHandle>(*this, path.c_str(), hFile);
-	if (flags & FileFlags::FILE_FLAGS_APPEND) {
-		auto file_size = GetFileSize(*handle);
-		SetFilePointer(*handle, file_size);
-	}
-	return move(handle);
-}
-
-void LocalFileSystem::SetFilePointer(FileHandle &handle, idx_t location) {
-	((WindowsFileHandle &)handle).position = location;
-}
-
-idx_t LocalFileSystem::GetFilePointer(FileHandle &handle) {
-	return ((WindowsFileHandle &)handle).position;
-}
-
-static DWORD FSInternalRead(FileHandle &handle, HANDLE hFile, void *buffer, int64_t nr_bytes, idx_t location) {
-	DWORD bytes_read = 0;
-	OVERLAPPED ov = {};
-	ov.Internal = 0;
-	ov.InternalHigh = 0;
-	ov.Offset = location & 0xFFFFFFFF;
-	ov.OffsetHigh = location >> 32;
-	ov.hEvent = 0;
-	auto rc = ReadFile(hFile, buffer, (DWORD)nr_bytes, &bytes_read, &ov);
-	if (!rc) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Could not read file \"%s\" (error in ReadFile): %s", handle.path, error);
-	}
-	return bytes_read;
-}
-
-void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-	auto bytes_read = FSInternalRead(handle, hFile, buffer, nr_bytes, location);
-	if (bytes_read != nr_bytes) {
-		throw IOException("Could not read all bytes from file \"%s\": wanted=%lld read=%lld", handle.path, nr_bytes,
-		                  bytes_read);
-	}
-}
-
-int64_t LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-	auto &pos = ((WindowsFileHandle &)handle).position;
-	auto n = std::min<idx_t>(std::max<idx_t>(GetFileSize(handle), pos) - pos, nr_bytes);
-	auto bytes_read = FSInternalRead(handle, hFile, buffer, n, pos);
-	pos += bytes_read;
-	return bytes_read;
-}
-
-static DWORD FSInternalWrite(FileHandle &handle, HANDLE hFile, void *buffer, int64_t nr_bytes, idx_t location) {
-	DWORD bytes_written = 0;
-	OVERLAPPED ov = {};
-	ov.Internal = 0;
-	ov.InternalHigh = 0;
-	ov.Offset = location & 0xFFFFFFFF;
-	ov.OffsetHigh = location >> 32;
-	ov.hEvent = 0;
-	auto rc = WriteFile(hFile, buffer, (DWORD)nr_bytes, &bytes_written, &ov);
-	if (!rc) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Could not write file \"%s\" (error in WriteFile): %s", handle.path, error);
-	}
-	return bytes_written;
-}
-
-void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-	auto bytes_written = FSInternalWrite(handle, hFile, buffer, nr_bytes, location);
-	if (bytes_written != nr_bytes) {
-		throw IOException("Could not write all bytes from file \"%s\": wanted=%lld wrote=%lld", handle.path, nr_bytes,
-		                  bytes_written);
-	}
-}
-
-int64_t LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-	auto &pos = ((WindowsFileHandle &)handle).position;
-	auto bytes_written = FSInternalWrite(handle, hFile, buffer, nr_bytes, pos);
-	pos += bytes_written;
-	return bytes_written;
-}
-
-int64_t LocalFileSystem::GetFileSize(FileHandle &handle) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-	LARGE_INTEGER result;
-	if (!GetFileSizeEx(hFile, &result)) {
-		return -1;
-	}
-	return result.QuadPart;
-}
-
-time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-
-	// https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfiletime
-	FILETIME last_write;
-	if (GetFileTime(hFile, nullptr, nullptr, &last_write) == 0) {
-		return -1;
-	}
-
-	// https://stackoverflow.com/questions/29266743/what-is-dwlowdatetime-and-dwhighdatetime
-	ULARGE_INTEGER ul;
-	ul.LowPart = last_write.dwLowDateTime;
-	ul.HighPart = last_write.dwHighDateTime;
-	int64_t fileTime64 = ul.QuadPart;
-
-	// fileTime64 contains a 64-bit value representing the number of
-	// 100-nanosecond intervals since January 1, 1601 (UTC).
-	// https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
-
-	// Adapted from: https://stackoverflow.com/questions/6161776/convert-windows-filetime-to-second-in-unix-linux
-	const auto WINDOWS_TICK = 10000000;
-	const auto SEC_TO_UNIX_EPOCH = 11644473600LL;
-	time_t result = (fileTime64 / WINDOWS_TICK - SEC_TO_UNIX_EPOCH);
-	return result;
-}
-
-void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-	// seek to the location
-	SetFilePointer(handle, new_size);
-	// now set the end of file position
-	if (!SetEndOfFile(hFile)) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failure in SetEndOfFile call on file \"%s\": %s", handle.path, error);
-	}
-}
-
-static DWORD WindowsGetFileAttributes(const string &filename) {
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
-	return GetFileAttributesW(unicode_path.c_str());
-}
-
-bool LocalFileSystem::DirectoryExists(const string &directory) {
-	DWORD attrs = WindowsGetFileAttributes(directory);
-	return (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY));
-}
-
-void LocalFileSystem::CreateDirectory(const string &directory) {
-	if (DirectoryExists(directory)) {
-		return;
-	}
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(directory.c_str());
-	if (directory.empty() || !CreateDirectoryW(unicode_path.c_str(), NULL) || !DirectoryExists(directory)) {
-		throw IOException("Could not create directory!");
-	}
-}
-
-static void DeleteDirectoryRecursive(FileSystem &fs, string directory) {
-	fs.ListFiles(directory, [&](const string &fname, bool is_directory) {
-		if (is_directory) {
-			DeleteDirectoryRecursive(fs, fs.JoinPath(directory, fname));
-		} else {
-			fs.RemoveFile(fs.JoinPath(directory, fname));
-		}
-	});
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(directory.c_str());
-	if (!RemoveDirectoryW(unicode_path.c_str())) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failed to delete directory \"%s\": %s", directory, error);
-	}
-}
-
-void LocalFileSystem::RemoveDirectory(const string &directory) {
-	if (FileExists(directory)) {
-		throw IOException("Attempting to delete directory \"%s\", but it is a file and not a directory!", directory);
-	}
-	if (!DirectoryExists(directory)) {
-		return;
-	}
-	DeleteDirectoryRecursive(*this, directory.c_str());
-}
-
-void LocalFileSystem::RemoveFile(const string &filename) {
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
-	if (!DeleteFileW(unicode_path.c_str())) {
-		auto error = LocalFileSystem::GetLastErrorAsString();
-		throw IOException("Failed to delete file \"%s\": %s", filename, error);
-	}
-}
-
-bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) {
-	string search_dir = JoinPath(directory, "*");
-
-	auto unicode_path = WindowsUtil::UTF8ToUnicode(search_dir.c_str());
-
-	WIN32_FIND_DATAW ffd;
-	HANDLE hFind = FindFirstFileW(unicode_path.c_str(), &ffd);
-	if (hFind == INVALID_HANDLE_VALUE) {
-		return false;
-	}
-	do {
-		string cFileName = WindowsUtil::UnicodeToUTF8(ffd.cFileName);
-		if (cFileName == "." || cFileName == "..") {
-			continue;
-		}
-		callback(cFileName, ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
-	} while (FindNextFileW(hFind, &ffd) != 0);
-
-	DWORD dwError = GetLastError();
-	if (dwError != ERROR_NO_MORE_FILES) {
-		FindClose(hFind);
-		return false;
-	}
-
-	FindClose(hFind);
-	return true;
-}
-
-void LocalFileSystem::FileSync(FileHandle &handle) {
-	HANDLE hFile = ((WindowsFileHandle &)handle).fd;
-	if (FlushFileBuffers(hFile) == 0) {
-		throw IOException("Could not flush file handle to disk!");
-	}
-}
-
-void LocalFileSystem::MoveFile(const string &source, const string &target) {
-	auto source_unicode = WindowsUtil::UTF8ToUnicode(source.c_str());
-	auto target_unicode = WindowsUtil::UTF8ToUnicode(target.c_str());
-	if (!MoveFileW(source_unicode.c_str(), target_unicode.c_str())) {
-		throw IOException("Could not move file");
-	}
-}
-
-FileType LocalFileSystem::GetFileType(FileHandle &handle) {
-	auto path = ((WindowsFileHandle &)handle).path;
-	// pipes in windows are just files in '\\.\pipe\' folder
-	if (strncmp(path.c_str(), PIPE_PREFIX, strlen(PIPE_PREFIX)) == 0) {
-		return FileType::FILE_TYPE_FIFO;
-	}
-	DWORD attrs = WindowsGetFileAttributes(path.c_str());
-	if (attrs != INVALID_FILE_ATTRIBUTES) {
-		if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
-			return FileType::FILE_TYPE_DIR;
-		} else {
-			return FileType::FILE_TYPE_REGULAR;
-		}
-	}
-	return FileType::FILE_TYPE_INVALID;
-}
-#endif
-
-bool LocalFileSystem::CanSeek() {
-	return true;
-}
-
-bool LocalFileSystem::OnDiskFile(FileHandle &handle) {
-	return true;
-}
-
-void LocalFileSystem::Seek(FileHandle &handle, idx_t location) {
-	if (!CanSeek()) {
-		throw IOException("Cannot seek in files of this type");
-	}
-	SetFilePointer(handle, location);
-}
-
-idx_t LocalFileSystem::SeekPosition(FileHandle &handle) {
-	if (!CanSeek()) {
-		throw IOException("Cannot seek in files of this type");
-	}
-	return GetFilePointer(handle);
-}
-
-static bool HasGlob(const string &str) {
-	for (idx_t i = 0; i < str.size(); i++) {
-		switch (str[i]) {
-		case '*':
-		case '?':
-		case '[':
-			return true;
-		default:
-			break;
-		}
-	}
-	return false;
-}
-
-static void GlobFiles(FileSystem &fs, const string &path, const string &glob, bool match_directory,
-                      vector<string> &result, bool join_path) {
-	fs.ListFiles(path, [&](const string &fname, bool is_directory) {
-		if (is_directory != match_directory) {
-			return;
-		}
-		if (LikeFun::Glob(fname.c_str(), fname.size(), glob.c_str(), glob.size())) {
-			if (join_path) {
-				result.push_back(fs.JoinPath(path, fname));
-			} else {
-				result.push_back(fname);
-			}
-		}
-	});
-}
-
-vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
-	if (path.empty()) {
-		return vector<string>();
-	}
-	// split up the path into separate chunks
-	vector<string> splits;
-	idx_t last_pos = 0;
-	for (idx_t i = 0; i < path.size(); i++) {
-		if (path[i] == '\\' || path[i] == '/') {
-			if (i == last_pos) {
-				// empty: skip this position
-				last_pos = i + 1;
-				continue;
-			}
-			if (splits.empty()) {
-				splits.push_back(path.substr(0, i));
-			} else {
-				splits.push_back(path.substr(last_pos, i - last_pos));
-			}
-			last_pos = i + 1;
-		}
-	}
-	splits.push_back(path.substr(last_pos, path.size() - last_pos));
-	// handle absolute paths
-	bool absolute_path = false;
-	if (path[0] == '/') {
-		// first character is a slash -  unix absolute path
-		absolute_path = true;
-	} else if (StringUtil::Contains(splits[0], ":")) {
-		// first split has a colon -  windows absolute path
-		absolute_path = true;
-	} else if (splits[0] == "~") {
-		// starts with home directory
-		auto home_directory = GetHomeDirectory();
-		if (!home_directory.empty()) {
-			absolute_path = true;
-			splits[0] = home_directory;
-		}
-	}
-	// Check if the path has a glob at all
-	if (!HasGlob(path)) {
-		// no glob: return only the file (if it exists or is a pipe)
-		vector<string> result;
-		if (FileExists(path) || IsPipe(path)) {
-			result.push_back(path);
-		} else if (!absolute_path) {
-			Value value;
-			if (opener->TryGetCurrentSetting("file_search_path", value)) {
-				auto search_paths_str = value.ToString();
-				std::vector<std::string> search_paths = StringUtil::Split(search_paths_str, ',');
-				for (const auto &search_path : search_paths) {
-					auto joined_path = JoinPath(search_path, path);
-					if (FileExists(joined_path) || IsPipe(joined_path)) {
-						result.push_back(joined_path);
-					}
-				}
-			}
-		}
-		return result;
-	}
-	vector<string> previous_directories;
-	if (absolute_path) {
-		// for absolute paths, we don't start by scanning the current directory
-		previous_directories.push_back(splits[0]);
-	}
-	for (idx_t i = absolute_path ? 1 : 0; i < splits.size(); i++) {
-		bool is_last_chunk = i + 1 == splits.size();
-		bool has_glob = HasGlob(splits[i]);
-		// if it's the last chunk we need to find files, otherwise we find directories
-		// not the last chunk: gather a list of all directories that match the glob pattern
-		vector<string> result;
-		if (!has_glob) {
-			// no glob, just append as-is
-			if (previous_directories.empty()) {
-				result.push_back(splits[i]);
-			} else {
-				for (auto &prev_directory : previous_directories) {
-					result.push_back(JoinPath(prev_directory, splits[i]));
-				}
-			}
-		} else {
-			if (previous_directories.empty()) {
-				// no previous directories: list in the current path
-				GlobFiles(*this, ".", splits[i], !is_last_chunk, result, false);
-			} else {
-				// previous directories
-				// we iterate over each of the previous directories, and apply the glob of the current directory
-				for (auto &prev_directory : previous_directories) {
-					GlobFiles(*this, prev_directory, splits[i], !is_last_chunk, result, true);
-				}
-			}
-		}
-		if (is_last_chunk || result.empty()) {
-			return result;
-		}
-		previous_directories = move(result);
-	}
-	return vector<string>();
-}
-
-unique_ptr<FileSystem> FileSystem::CreateLocal() {
-	return make_unique<LocalFileSystem>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cctype>
-#include <cmath>
-#include <cstdlib>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Cast bool -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(bool input, bool &result, bool strict) {
-	return NumericTryCast::Operation<bool, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<bool, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, float &result, bool strict) {
-	return NumericTryCast::Operation<bool, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(bool input, double &result, bool strict) {
-	return NumericTryCast::Operation<bool, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int8_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(int8_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int8_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<int8_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int16_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(int16_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int16_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<int16_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int32_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(int32_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int32_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<int32_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int64_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(int64_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(int64_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<int64_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast hugeint_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(hugeint_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(hugeint_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<hugeint_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint8_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uint8_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint8_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uint8_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint16_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uint16_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint16_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uint16_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint32_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uint32_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint32_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uint32_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint64_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(uint64_t input, bool &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, float &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(uint64_t input, double &result, bool strict) {
-	return NumericTryCast::Operation<uint64_t, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast float -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(float input, bool &result, bool strict) {
-	return NumericTryCast::Operation<float, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<float, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<float, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<float, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<float, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<float, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<float, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, float &result, bool strict) {
-	return NumericTryCast::Operation<float, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(float input, double &result, bool strict) {
-	return NumericTryCast::Operation<float, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast double -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(double input, bool &result, bool strict) {
-	return NumericTryCast::Operation<double, bool>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, int8_t &result, bool strict) {
-	return NumericTryCast::Operation<double, int8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, int16_t &result, bool strict) {
-	return NumericTryCast::Operation<double, int16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, int32_t &result, bool strict) {
-	return NumericTryCast::Operation<double, int32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, int64_t &result, bool strict) {
-	return NumericTryCast::Operation<double, int64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, hugeint_t &result, bool strict) {
-	return NumericTryCast::Operation<double, hugeint_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uint8_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uint8_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uint16_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uint16_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uint32_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uint32_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, uint64_t &result, bool strict) {
-	return NumericTryCast::Operation<double, uint64_t>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, float &result, bool strict) {
-	return NumericTryCast::Operation<double, float>(input, result, strict);
-}
-
-template <>
-bool TryCast::Operation(double input, double &result, bool strict) {
-	return NumericTryCast::Operation<double, double>(input, result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast String -> Numeric
-//===--------------------------------------------------------------------===//
-template <typename T>
-struct IntegerCastData {
-	using Result = T;
-	Result result;
-	bool seen_decimal;
-};
-
-struct IntegerCastOperation {
-	template <class T, bool NEGATIVE>
-	static bool HandleDigit(T &state, uint8_t digit) {
-		using result_t = typename T::Result;
-		if (NEGATIVE) {
-			if (state.result < (NumericLimits<result_t>::Minimum() + digit) / 10) {
-				return false;
-			}
-			state.result = state.result * 10 - digit;
-		} else {
-			if (state.result > (NumericLimits<result_t>::Maximum() - digit) / 10) {
-				return false;
-			}
-			state.result = state.result * 10 + digit;
-		}
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleExponent(T &state, int32_t exponent) {
-		using result_t = typename T::Result;
-		double dbl_res = state.result * std::pow(10.0L, exponent);
-		if (dbl_res < NumericLimits<result_t>::Minimum() || dbl_res > NumericLimits<result_t>::Maximum()) {
-			return false;
-		}
-		state.result = (result_t)std::nearbyint(dbl_res);
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleDecimal(T &state, uint8_t digit) {
-		if (state.seen_decimal) {
-			return true;
-		}
-		state.seen_decimal = true;
-		// round the integer based on what is after the decimal point
-		// if digit >= 5, then we round up (or down in case of negative numbers)
-		auto increment = digit >= 5;
-		if (!increment) {
-			return true;
-		}
-		if (NEGATIVE) {
-			if (state.result == NumericLimits<typename T::Result>::Minimum()) {
-				return false;
-			}
-			state.result--;
-		} else {
-			if (state.result == NumericLimits<typename T::Result>::Maximum()) {
-				return false;
-			}
-			state.result++;
-		}
-		return true;
-	}
-
-	template <class T>
-	static bool Finalize(T &state) {
-		return true;
-	}
-};
-
-template <class T, bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation>
-static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict) {
-	idx_t start_pos = NEGATIVE || *buf == '+' ? 1 : 0;
-	idx_t pos = start_pos;
-	while (pos < len) {
-		if (!StringUtil::CharacterIsDigit(buf[pos])) {
-			// not a digit!
-			if (buf[pos] == '.') {
-				if (strict) {
-					return false;
-				}
-				bool number_before_period = pos > start_pos;
-				// decimal point: we accept decimal values for integers as well
-				// we just truncate them
-				// make sure everything after the period is a number
-				pos++;
-				idx_t start_digit = pos;
-				while (pos < len) {
-					if (!StringUtil::CharacterIsDigit(buf[pos])) {
-						break;
-					}
-					if (!OP::template HandleDecimal<T, NEGATIVE>(result, buf[pos] - '0')) {
-						return false;
-					}
-					pos++;
-				}
-				// make sure there is either (1) one number after the period, or (2) one number before the period
-				// i.e. we accept "1." and ".1" as valid numbers, but not "."
-				if (!(number_before_period || pos > start_digit)) {
-					return false;
-				}
-				if (pos >= len) {
-					break;
-				}
-			}
-			if (StringUtil::CharacterIsSpace(buf[pos])) {
-				// skip any trailing spaces
-				while (++pos < len) {
-					if (!StringUtil::CharacterIsSpace(buf[pos])) {
-						return false;
-					}
-				}
-				break;
-			}
-			if (ALLOW_EXPONENT) {
-				if (buf[pos] == 'e' || buf[pos] == 'E') {
-					if (pos == start_pos) {
-						return false;
-					}
-					pos++;
-					if (pos >= len) {
-						return false;
-					}
-					using ExponentData = IntegerCastData<int32_t>;
-					ExponentData exponent {0, false};
-					int negative = buf[pos] == '-';
-					if (negative) {
-						if (!IntegerCastLoop<ExponentData, true, false>(buf + pos, len - pos, exponent, strict)) {
-							return false;
-						}
-					} else {
-						if (!IntegerCastLoop<ExponentData, false, false>(buf + pos, len - pos, exponent, strict)) {
-							return false;
-						}
-					}
-					return OP::template HandleExponent<T, NEGATIVE>(result, exponent.result);
-				}
-			}
-			return false;
-		}
-		uint8_t digit = buf[pos++] - '0';
-		if (!OP::template HandleDigit<T, NEGATIVE>(result, digit)) {
-			return false;
-		}
-	}
-	if (!OP::template Finalize<T>(result)) {
-		return false;
-	}
-	return pos > start_pos;
-}
-
-template <class T, bool IS_SIGNED = true, bool ALLOW_EXPONENT = true, class OP = IntegerCastOperation,
-          bool ZERO_INITIALIZE = true>
-static bool TryIntegerCast(const char *buf, idx_t len, T &result, bool strict) {
-	// skip any spaces at the start
-	while (len > 0 && StringUtil::CharacterIsSpace(*buf)) {
-		buf++;
-		len--;
-	}
-	if (len == 0) {
-		return false;
-	}
-	int negative = *buf == '-';
-
-	if (ZERO_INITIALIZE) {
-		memset(&result, 0, sizeof(T));
-	}
-	if (!negative) {
-		return IntegerCastLoop<T, false, ALLOW_EXPONENT, OP>(buf, len, result, strict);
-	} else {
-		if (!IS_SIGNED) {
-			// Need to check if its not -0
-			idx_t pos = 1;
-			while (pos < len) {
-				if (buf[pos++] != '0') {
-					return false;
-				}
-			}
-		}
-		return IntegerCastLoop<T, true, ALLOW_EXPONENT, OP>(buf, len, result, strict);
-	}
-}
-
-template <typename T, bool IS_SIGNED = true>
-static inline bool TrySimpleIntegerCast(const char *buf, idx_t len, T &result, bool strict) {
-	IntegerCastData<T> data;
-	if (TryIntegerCast<IntegerCastData<T>, IS_SIGNED>(buf, len, data, strict)) {
-		result = data.result;
-		return true;
-	}
-	return false;
-}
-
-template <>
-bool TryCast::Operation(string_t input, bool &result, bool strict) {
-	auto input_data = input.GetDataUnsafe();
-	auto input_size = input.GetSize();
-
-	switch (input_size) {
-	case 1: {
-		char c = std::tolower(*input_data);
-		if (c == 't' || (!strict && c == '1')) {
-			result = true;
-			return true;
-		} else if (c == 'f' || (!strict && c == '0')) {
-			result = false;
-			return true;
-		}
-		return false;
-	}
-	case 4: {
-		char t = std::tolower(input_data[0]);
-		char r = std::tolower(input_data[1]);
-		char u = std::tolower(input_data[2]);
-		char e = std::tolower(input_data[3]);
-		if (t == 't' && r == 'r' && u == 'u' && e == 'e') {
-			result = true;
-			return true;
-		}
-		return false;
-	}
-	case 5: {
-		char f = std::tolower(input_data[0]);
-		char a = std::tolower(input_data[1]);
-		char l = std::tolower(input_data[2]);
-		char s = std::tolower(input_data[3]);
-		char e = std::tolower(input_data[4]);
-		if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') {
-			result = false;
-			return true;
-		}
-		return false;
-	}
-	default:
-		return false;
-	}
-}
-template <>
-bool TryCast::Operation(string_t input, int8_t &result, bool strict) {
-	return TrySimpleIntegerCast<int8_t>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, int16_t &result, bool strict) {
-	return TrySimpleIntegerCast<int16_t>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, int32_t &result, bool strict) {
-	return TrySimpleIntegerCast<int32_t>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, int64_t &result, bool strict) {
-	return TrySimpleIntegerCast<int64_t>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-
-template <>
-bool TryCast::Operation(string_t input, uint8_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint8_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, uint16_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint16_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, uint32_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint32_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-template <>
-bool TryCast::Operation(string_t input, uint64_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint64_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-
-template <class T>
-static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict) {
-	// skip any spaces at the start
-	while (len > 0 && StringUtil::CharacterIsSpace(*buf)) {
-		buf++;
-		len--;
-	}
-	if (len == 0) {
-		return false;
-	}
-	if (*buf == '+') {
-		buf++;
-		len--;
-	}
-	auto endptr = buf + len;
-	auto parse_result = duckdb_fast_float::from_chars(buf, buf + len, result);
-	if (parse_result.ec != std::errc()) {
-		return false;
-	}
-	auto current_end = parse_result.ptr;
-	if (!strict) {
-		while (current_end < endptr && StringUtil::CharacterIsSpace(*current_end)) {
-			current_end++;
-		}
-	}
-	return current_end == endptr;
-}
-
-template <>
-bool TryCast::Operation(string_t input, float &result, bool strict) {
-	return TryDoubleCast<float>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-
-template <>
-bool TryCast::Operation(string_t input, double &result, bool strict) {
-	return TryDoubleCast<double>(input.GetDataUnsafe(), input.GetSize(), result, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Date
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(date_t input, date_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-template <>
-bool TryCast::Operation(date_t input, timestamp_t &result, bool strict) {
-	if (input == date_t::infinity()) {
-		result = timestamp_t::infinity();
-		return true;
-	} else if (input == date_t::ninfinity()) {
-		result = timestamp_t::ninfinity();
-		return true;
-	}
-	return Timestamp::TryFromDatetime(input, Time::FromTime(0, 0, 0), result);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Time
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(dtime_t input, dtime_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Timestamps
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(timestamp_t input, date_t &result, bool strict) {
-	result = Timestamp::GetDate(input);
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, dtime_t &result, bool strict) {
-	if (!Timestamp::IsFinite(input)) {
-		return false;
-	}
-	result = Timestamp::GetTime(input);
-	return true;
-}
-
-template <>
-bool TryCast::Operation(timestamp_t input, timestamp_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast from Interval
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCast::Operation(interval_t input, interval_t &result, bool strict) {
-	result = input;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Non-Standard Timestamps
-//===--------------------------------------------------------------------===//
-template <>
-duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(Timestamp::FromEpochNanoSeconds(input.value), result);
-}
-template <>
-duckdb::string_t CastFromTimestampMS::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(Timestamp::FromEpochMs(input.value), result);
-}
-template <>
-duckdb::string_t CastFromTimestampSec::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(Timestamp::FromEpochSeconds(input.value), result);
-}
-
-template <>
-timestamp_t CastTimestampUsToMs::Operation(timestamp_t input) {
-	timestamp_t cast_timestamp(Timestamp::GetEpochMs(input));
-	return cast_timestamp;
-}
-
-template <>
-timestamp_t CastTimestampUsToNs::Operation(timestamp_t input) {
-	timestamp_t cast_timestamp(Timestamp::GetEpochNanoSeconds(input));
-	return cast_timestamp;
-}
-
-template <>
-timestamp_t CastTimestampUsToSec::Operation(timestamp_t input) {
-	timestamp_t cast_timestamp(Timestamp::GetEpochSeconds(input));
-	return cast_timestamp;
-}
-template <>
-timestamp_t CastTimestampMsToUs::Operation(timestamp_t input) {
-	return Timestamp::FromEpochMs(input.value);
-}
-
-template <>
-timestamp_t CastTimestampNsToUs::Operation(timestamp_t input) {
-	return Timestamp::FromEpochNanoSeconds(input.value);
-}
-
-template <>
-timestamp_t CastTimestampSecToUs::Operation(timestamp_t input) {
-	return Timestamp::FromEpochSeconds(input.value);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Timestamp
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToTimestampNS::Operation(string_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	result = Timestamp::GetEpochNanoSeconds(result);
-	return true;
-}
-
-template <>
-bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	result = Timestamp::GetEpochMs(result);
-	return true;
-}
-
-template <>
-bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	result = Timestamp::GetEpochSeconds(result);
-	return true;
-}
-
-template <>
-bool TryCastToTimestampNS::Operation(date_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	if (!TryMultiplyOperator::Operation(result.value, Interval::NANOS_PER_MICRO, result.value)) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	result.value /= Interval::MICROS_PER_MSEC;
-	return true;
-}
-
-template <>
-bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	result.value /= Interval::MICROS_PER_MSEC * Interval::MSECS_PER_SEC;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Blob
-//===--------------------------------------------------------------------===//
-template <>
-string_t CastFromBlob::Operation(string_t input, Vector &vector) {
-	idx_t result_size = Blob::GetStringSize(input);
-
-	string_t result = StringVector::EmptyString(vector, result_size);
-	Blob::ToString(input, result.GetDataWriteable());
-	result.Finalize();
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Blob
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
-                              bool strict) {
-	idx_t result_size;
-	if (!Blob::TryGetBlobSize(input, result_size, error_message)) {
-		return false;
-	}
-
-	result = StringVector::EmptyString(result_vector, result_size);
-	Blob::ToBlob(input, (data_ptr_t)result.GetDataWriteable());
-	result.Finalize();
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From UUID
-//===--------------------------------------------------------------------===//
-template <>
-string_t CastFromUUID::Operation(hugeint_t input, Vector &vector) {
-	string_t result = StringVector::EmptyString(vector, 36);
-	UUID::ToString(input, result.GetDataWriteable());
-	result.Finalize();
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To UUID
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, string *error_message,
-                              bool strict) {
-	return UUID::FromString(input.GetString(), result);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Date
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, date_t &result, string *error_message, bool strict) {
-	if (!TryCast::Operation<string_t, date_t>(input, result, strict)) {
-		HandleCastError::AssignError(Date::ConversionError(input), error_message);
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCast::Operation(string_t input, date_t &result, bool strict) {
-	idx_t pos;
-	return Date::TryConvertDate(input.GetDataUnsafe(), input.GetSize(), pos, result, strict);
-}
-
-template <>
-date_t Cast::Operation(string_t input) {
-	return Date::FromCString(input.GetDataUnsafe(), input.GetSize());
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Time
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, string *error_message, bool strict) {
-	if (!TryCast::Operation<string_t, dtime_t>(input, result, strict)) {
-		HandleCastError::AssignError(Time::ConversionError(input), error_message);
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCast::Operation(string_t input, dtime_t &result, bool strict) {
-	idx_t pos;
-	return Time::TryConvertTime(input.GetDataUnsafe(), input.GetSize(), pos, result, strict);
-}
-
-template <>
-dtime_t Cast::Operation(string_t input) {
-	return Time::FromCString(input.GetDataUnsafe(), input.GetSize());
-}
-
-//===--------------------------------------------------------------------===//
-// Cast To Timestamp
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, string *error_message, bool strict) {
-	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
-		HandleCastError::AssignError(Timestamp::ConversionError(input), error_message);
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryCast::Operation(string_t input, timestamp_t &result, bool strict) {
-	return Timestamp::TryConvertTimestamp(input.GetDataUnsafe(), input.GetSize(), result);
-}
-
-template <>
-timestamp_t Cast::Operation(string_t input) {
-	return Timestamp::FromCString(input.GetDataUnsafe(), input.GetSize());
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Interval
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastErrorMessage::Operation(string_t input, interval_t &result, string *error_message, bool strict) {
-	return Interval::FromCString(input.GetDataUnsafe(), input.GetSize(), result, error_message, strict);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast From Hugeint
-//===--------------------------------------------------------------------===//
-// parsing hugeint from string is done a bit differently for performance reasons
-// for other integer types we keep track of a single value
-// and multiply that value by 10 for every digit we read
-// however, for hugeints, multiplication is very expensive (>20X as expensive as for int64)
-// for that reason, we parse numbers first into an int64 value
-// when that value is full, we perform a HUGEINT multiplication to flush it into the hugeint
-// this takes the number of HUGEINT multiplications down from [0-38] to [0-2]
-struct HugeIntCastData {
-	hugeint_t hugeint;
-	int64_t intermediate;
-	uint8_t digits;
-	bool decimal;
-
-	bool Flush() {
-		if (digits == 0 && intermediate == 0) {
-			return true;
-		}
-		if (hugeint.lower != 0 || hugeint.upper != 0) {
-			if (digits > 38) {
-				return false;
-			}
-			if (!Hugeint::TryMultiply(hugeint, Hugeint::POWERS_OF_TEN[digits], hugeint)) {
-				return false;
-			}
-		}
-		if (!Hugeint::AddInPlace(hugeint, hugeint_t(intermediate))) {
-			return false;
-		}
-		digits = 0;
-		intermediate = 0;
-		return true;
-	}
-};
-
-struct HugeIntegerCastOperation {
-	template <class T, bool NEGATIVE>
-	static bool HandleDigit(T &result, uint8_t digit) {
-		if (NEGATIVE) {
-			if (result.intermediate < (NumericLimits<int64_t>::Minimum() + digit) / 10) {
-				// intermediate is full: need to flush it
-				if (!result.Flush()) {
-					return false;
-				}
-			}
-			result.intermediate = result.intermediate * 10 - digit;
-		} else {
-			if (result.intermediate > (NumericLimits<int64_t>::Maximum() - digit) / 10) {
-				if (!result.Flush()) {
-					return false;
-				}
-			}
-			result.intermediate = result.intermediate * 10 + digit;
-		}
-		result.digits++;
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleExponent(T &result, int32_t exponent) {
-		if (!result.Flush()) {
-			return false;
-		}
-		if (exponent < -38 || exponent > 38) {
-			// out of range for exact exponent: use double and convert
-			double dbl_res = Hugeint::Cast<double>(result.hugeint) * std::pow(10.0L, exponent);
-			if (dbl_res < Hugeint::Cast<double>(NumericLimits<hugeint_t>::Minimum()) ||
-			    dbl_res > Hugeint::Cast<double>(NumericLimits<hugeint_t>::Maximum())) {
-				return false;
-			}
-			result.hugeint = Hugeint::Convert(dbl_res);
-			return true;
-		}
-		if (exponent < 0) {
-			// negative exponent: divide by power of 10
-			result.hugeint = Hugeint::Divide(result.hugeint, Hugeint::POWERS_OF_TEN[-exponent]);
-			return true;
-		} else {
-			// positive exponent: multiply by power of 10
-			return Hugeint::TryMultiply(result.hugeint, Hugeint::POWERS_OF_TEN[exponent], result.hugeint);
-		}
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleDecimal(T &result, uint8_t digit) {
-		// Integer casts round
-		if (!result.decimal) {
-			if (!result.Flush()) {
-				return false;
-			}
-			if (NEGATIVE) {
-				result.intermediate = -(digit >= 5);
-			} else {
-				result.intermediate = (digit >= 5);
-			}
-		}
-		result.decimal = true;
-
-		return true;
-	}
-
-	template <class T>
-	static bool Finalize(T &result) {
-		return result.Flush();
-	}
-};
-
-template <>
-bool TryCast::Operation(string_t input, hugeint_t &result, bool strict) {
-	HugeIntCastData data;
-	if (!TryIntegerCast<HugeIntCastData, true, true, HugeIntegerCastOperation>(input.GetDataUnsafe(), input.GetSize(),
-	                                                                           data, strict)) {
-		return false;
-	}
-	result = data.hugeint;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal String Cast
-//===--------------------------------------------------------------------===//
-template <class T>
-struct DecimalCastData {
-	T result;
-	uint8_t width;
-	uint8_t scale;
-	uint8_t digit_count;
-	uint8_t decimal_count;
-};
-
-struct DecimalCastOperation {
-	template <class T, bool NEGATIVE>
-	static bool HandleDigit(T &state, uint8_t digit) {
-		if (state.result == 0 && digit == 0) {
-			// leading zero's don't count towards the digit count
-			return true;
-		}
-		if (state.digit_count == state.width - state.scale) {
-			// width of decimal type is exceeded!
-			return false;
-		}
-		state.digit_count++;
-		if (NEGATIVE) {
-			state.result = state.result * 10 - digit;
-		} else {
-			state.result = state.result * 10 + digit;
-		}
-		return true;
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleExponent(T &state, int32_t exponent) {
-		Finalize<T>(state);
-		if (exponent < 0) {
-			for (idx_t i = 0; i < idx_t(-int64_t(exponent)); i++) {
-				state.result /= 10;
-				if (state.result == 0) {
-					break;
-				}
-			}
-			return true;
-		} else {
-			// positive exponent: append 0's
-			for (idx_t i = 0; i < idx_t(exponent); i++) {
-				if (!HandleDigit<T, NEGATIVE>(state, 0)) {
-					return false;
-				}
-			}
-			return true;
-		}
-	}
-
-	template <class T, bool NEGATIVE>
-	static bool HandleDecimal(T &state, uint8_t digit) {
-		if (state.decimal_count == state.scale) {
-			// we exceeded the amount of supported decimals
-			// however, we don't throw an error here
-			// we just truncate the decimal
-			return true;
-		}
-		state.decimal_count++;
-		if (NEGATIVE) {
-			state.result = state.result * 10 - digit;
-		} else {
-			state.result = state.result * 10 + digit;
-		}
-		return true;
-	}
-
-	template <class T>
-	static bool Finalize(T &state) {
-		// if we have not gotten exactly "scale" decimals, we need to multiply the result
-		// e.g. if we have a string "1.0" that is cast to a DECIMAL(9,3), the value needs to be 1000
-		// but we have only gotten the value "10" so far, so we multiply by 1000
-		for (uint8_t i = state.decimal_count; i < state.scale; i++) {
-			state.result *= 10;
-		}
-		return true;
-	}
-};
-
-template <class T>
-bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint8_t width, uint8_t scale) {
-	DecimalCastData<T> state;
-	state.result = 0;
-	state.width = width;
-	state.scale = scale;
-	state.digit_count = 0;
-	state.decimal_count = 0;
-	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false>(input.GetDataUnsafe(),
-	                                                                                 input.GetSize(), state, false)) {
-		string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", input.GetString(),
-		                                  (int)width, (int)scale);
-		HandleCastError::AssignError(error, error_message);
-		return false;
-	}
-	result = state.result;
-	return true;
-}
-
-template <>
-bool TryCastToDecimal::Operation(string_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int16_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(string_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int32_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(string_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryDecimalStringCast<int64_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return TryDecimalStringCast<hugeint_t>(input, result, error_message, width, scale);
-}
-
-template <>
-string_t StringCastFromDecimal::Operation(int16_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int16_t, uint16_t>(input, scale, result);
-}
-
-template <>
-string_t StringCastFromDecimal::Operation(int32_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int32_t, uint32_t>(input, scale, result);
-}
-
-template <>
-string_t StringCastFromDecimal::Operation(int64_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int64_t, uint64_t>(input, scale, result);
-}
-
-template <>
-string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return HugeintToStringCast::FormatDecimal(input, scale, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal Casts
-//===--------------------------------------------------------------------===//
-// Decimal <-> Bool
-//===--------------------------------------------------------------------===//
-template <class T, class OP = NumericHelper>
-bool TryCastBoolToDecimal(bool input, T &result, string *error_message, uint8_t width, uint8_t scale) {
-	if (width > scale) {
-		result = input ? OP::POWERS_OF_TEN[scale] : 0;
-		return true;
-	} else {
-		return TryCast::Operation<bool, T>(input, result);
-	}
-}
-
-template <>
-bool TryCastToDecimal::Operation(bool input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastBoolToDecimal<int16_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(bool input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastBoolToDecimal<int32_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(bool input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastBoolToDecimal<int64_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(bool input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastBoolToDecimal<hugeint_t, Hugeint>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCast::Operation<int16_t, bool>(input, result);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCast::Operation<int32_t, bool>(input, result);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCast::Operation<int64_t, bool>(input, result);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCast::Operation<hugeint_t, bool>(input, result);
-}
-
-//===--------------------------------------------------------------------===//
-// Numeric -> Decimal Cast
-//===--------------------------------------------------------------------===//
-struct SignedToDecimalOperator {
-	template <class SRC, class DST>
-	static bool Operation(SRC input, DST max_width) {
-		return int64_t(input) >= int64_t(max_width) || int64_t(input) <= int64_t(-max_width);
-	}
-};
-
-struct UnsignedToDecimalOperator {
-	template <class SRC, class DST>
-	static bool Operation(SRC input, DST max_width) {
-		return uint64_t(input) >= uint64_t(max_width);
-	}
-};
-
-template <class SRC, class DST, class OP = SignedToDecimalOperator>
-bool StandardNumericToDecimalCast(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
-	// check for overflow
-	DST max_width = NumericHelper::POWERS_OF_TEN[width - scale];
-	if (OP::template Operation<SRC, DST>(input, max_width)) {
-		string error = StringUtil::Format("Could not cast value %d to DECIMAL(%d,%d)", input, width, scale);
-		HandleCastError::AssignError(error, error_message);
-		return false;
-	}
-	result = DST(input) * NumericHelper::POWERS_OF_TEN[scale];
-	return true;
-}
-
-template <class SRC>
-bool NumericToHugeDecimalCast(SRC input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	// check for overflow
-	hugeint_t max_width = Hugeint::POWERS_OF_TEN[width - scale];
-	hugeint_t hinput = Hugeint::Convert(input);
-	if (hinput >= max_width || hinput <= -max_width) {
-		string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", hinput.ToString(), width, scale);
-		HandleCastError::AssignError(error, error_message);
-		return false;
-	}
-	result = hinput * Hugeint::POWERS_OF_TEN[scale];
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int8_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(int8_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int16_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int8_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int32_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int8_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int8_t, int64_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return NumericToHugeDecimalCast<int8_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int16_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int16_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int32_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int16_t, int64_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<int16_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int32_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int16_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int32_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int32_t, int64_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<int32_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast int64_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int16_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int32_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<int64_t, int64_t>(input, result, error_message, width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<int64_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint8_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int16_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                 width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int32_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                 width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint8_t, int64_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                 width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<uint8_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint16_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int16_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int32_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint16_t, int64_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<uint16_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint32_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int16_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int32_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint32_t, int64_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<uint32_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast uint64_t -> Decimal
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int16_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int32_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return StandardNumericToDecimalCast<uint64_t, int64_t, UnsignedToDecimalOperator>(input, result, error_message,
-	                                                                                  width, scale);
-}
-template <>
-bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return NumericToHugeDecimalCast<uint64_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Hugeint -> Decimal Cast
-//===--------------------------------------------------------------------===//
-template <class DST>
-bool HugeintToDecimalCast(hugeint_t input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
-	// check for overflow
-	hugeint_t max_width = Hugeint::POWERS_OF_TEN[width - scale];
-	if (input >= max_width || input <= -max_width) {
-		string error = StringUtil::Format("Could not cast value %s to DECIMAL(%d,%d)", input.ToString(), width, scale);
-		HandleCastError::AssignError(error, error_message);
-		return false;
-	}
-	result = Hugeint::Cast<DST>(input * Hugeint::POWERS_OF_TEN[scale]);
-	return true;
-}
-
-template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return HugeintToDecimalCast<int16_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return HugeintToDecimalCast<int32_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return HugeintToDecimalCast<int64_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                 uint8_t scale) {
-	return HugeintToDecimalCast<hugeint_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Float/Double -> Decimal Cast
-//===--------------------------------------------------------------------===//
-template <class SRC, class DST>
-bool DoubleToDecimalCast(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
-	double value = input * NumericHelper::DOUBLE_POWERS_OF_TEN[scale];
-	// Add the sign (-1, 0, 1) times a tiny value to fix floating point issues (issue 3091)
-	double sign = (double(0) < value) - (value < double(0));
-	value += 1e-9 * sign;
-	if (value <= -NumericHelper::DOUBLE_POWERS_OF_TEN[width] || value >= NumericHelper::DOUBLE_POWERS_OF_TEN[width]) {
-		string error = StringUtil::Format("Could not cast value %f to DECIMAL(%d,%d)", value, width, scale);
-		HandleCastError::AssignError(error, error_message);
-		return false;
-	}
-	result = Cast::Operation<SRC, DST>(value);
-	return true;
-}
-
-template <>
-bool TryCastToDecimal::Operation(float input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<float, int16_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(float input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<float, int32_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(float input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<float, int64_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(float input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<float, hugeint_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(double input, int16_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<double, int16_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(double input, int32_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<double, int32_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(double input, int64_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<double, int64_t>(input, result, error_message, width, scale);
-}
-
-template <>
-bool TryCastToDecimal::Operation(double input, hugeint_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return DoubleToDecimalCast<double, hugeint_t>(input, result, error_message, width, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal -> Numeric Cast
-//===--------------------------------------------------------------------===//
-template <class SRC, class DST>
-bool TryCastDecimalToNumeric(SRC input, DST &result, string *error_message, uint8_t scale) {
-	// Round away from 0.
-	const auto power = NumericHelper::POWERS_OF_TEN[scale];
-	// https://graphics.stanford.edu/~seander/bithacks.html#ConditionalNegate
-	const auto fNegate = int64_t(input < 0);
-	const auto rounding = ((power ^ -fNegate) + fNegate) / 2;
-	const auto scaled_value = (input + rounding) / power;
-	if (!TryCast::Operation<SRC, DST>(scaled_value, result)) {
-		string error = StringUtil::Format("Failed to cast decimal value %d to type %s", scaled_value, GetTypeId<DST>());
-		HandleCastError::AssignError(error, error_message);
-		return false;
-	}
-	return true;
-}
-
-template <class DST>
-bool TryCastHugeDecimalToNumeric(hugeint_t input, DST &result, string *error_message, uint8_t scale) {
-	const auto power = Hugeint::POWERS_OF_TEN[scale];
-	const auto rounding = ((input < 0) ? -power : power) / 2;
-	auto scaled_value = (input + rounding) / power;
-	if (!TryCast::Operation<hugeint_t, DST>(scaled_value, result)) {
-		string error = StringUtil::Format("Failed to cast decimal value %s to type %s",
-		                                  ConvertToString::Operation(scaled_value), GetTypeId<DST>());
-		HandleCastError::AssignError(error, error_message);
-		return false;
-	}
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> int8_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int8_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int8_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int8_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int8_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> int16_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int16_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int16_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int16_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int16_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> int32_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int32_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int32_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int32_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int32_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> int64_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, int64_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, int64_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, int64_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<int64_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uint8_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint8_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint8_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint8_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint8_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uint16_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint16_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint16_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint16_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint16_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uint32_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint32_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint32_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint32_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint32_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> uint64_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, uint64_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, uint64_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, uint64_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<uint64_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> hugeint_t
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int16_t, hugeint_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int32_t, hugeint_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToNumeric<int64_t, hugeint_t>(input, result, error_message, scale);
-}
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastHugeDecimalToNumeric<hugeint_t>(input, result, error_message, scale);
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal -> Float/Double Cast
-//===--------------------------------------------------------------------===//
-template <class SRC, class DST>
-bool TryCastDecimalToFloatingPoint(SRC input, DST &result, uint8_t scale) {
-	result = Cast::Operation<SRC, DST>(input) / DST(NumericHelper::DOUBLE_POWERS_OF_TEN[scale]);
-	return true;
-}
-
-// DECIMAL -> FLOAT
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, float &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int16_t, float>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, float &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int32_t, float>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, float &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int64_t, float>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, float &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<hugeint_t, float>(input, result, scale);
-}
-
-// DECIMAL -> DOUBLE
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, double &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int16_t, double>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, double &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int32_t, double>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, double &result, string *error_message, uint8_t width, uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<int64_t, double>(input, result, scale);
-}
-
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, double &result, string *error_message, uint8_t width,
-                                   uint8_t scale) {
-	return TryCastDecimalToFloatingPoint<hugeint_t, double>(input, result, scale);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-template <class T>
-string StandardStringCast(T input) {
-	Vector v(LogicalType::VARCHAR);
-	return StringCast::Operation(input, v).GetString();
-}
-
-template <>
-string ConvertToString::Operation(bool input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(int8_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(int16_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(int32_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(int64_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uint8_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uint16_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uint32_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(uint64_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(hugeint_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(float input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(double input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(interval_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(date_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(dtime_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(timestamp_t input) {
-	return StandardStringCast(input);
-}
-template <>
-string ConvertToString::Operation(string_t input) {
-	return input.GetString();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Cast Numeric -> String
-//===--------------------------------------------------------------------===//
-template <>
-string_t StringCast::Operation(bool input, Vector &vector) {
-	if (input) {
-		return StringVector::AddString(vector, "true", 4);
-	} else {
-		return StringVector::AddString(vector, "false", 5);
-	}
-}
-
-template <>
-string_t StringCast::Operation(int8_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int8_t, uint8_t>(input, vector);
-}
-
-template <>
-string_t StringCast::Operation(int16_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int16_t, uint16_t>(input, vector);
-}
-template <>
-string_t StringCast::Operation(int32_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int32_t, uint32_t>(input, vector);
-}
-
-template <>
-string_t StringCast::Operation(int64_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<int64_t, uint64_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(uint8_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint8_t, uint64_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(uint16_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint16_t, uint64_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(uint32_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint32_t, uint64_t>(input, vector);
-}
-template <>
-duckdb::string_t StringCast::Operation(uint64_t input, Vector &vector) {
-	return NumericHelper::FormatSigned<uint64_t, uint64_t>(input, vector);
-}
-
-template <>
-string_t StringCast::Operation(float input, Vector &vector) {
-	std::string s = duckdb_fmt::format("{}", input);
-	return StringVector::AddString(vector, s);
-}
-
-template <>
-string_t StringCast::Operation(double input, Vector &vector) {
-	std::string s = duckdb_fmt::format("{}", input);
-	return StringVector::AddString(vector, s);
-}
-
-template <>
-string_t StringCast::Operation(interval_t input, Vector &vector) {
-	char buffer[70];
-	idx_t length = IntervalToStringCast::Format(input, buffer);
-	return StringVector::AddString(vector, buffer, length);
-}
-
-template <>
-duckdb::string_t StringCast::Operation(hugeint_t input, Vector &vector) {
-	return HugeintToStringCast::FormatSigned(input, vector);
-}
-
-template <>
-duckdb::string_t StringCast::Operation(date_t input, Vector &vector) {
-	if (input == date_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
-	} else if (input == date_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
-	}
-	int32_t date[3];
-	Date::Convert(input, date[0], date[1], date[2]);
-
-	idx_t year_length;
-	bool add_bc;
-	idx_t length = DateToStringCast::Length(date, year_length, add_bc);
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	DateToStringCast::Format(data, date, year_length, add_bc);
-
-	result.Finalize();
-	return result;
-}
-
-template <>
-duckdb::string_t StringCast::Operation(dtime_t input, Vector &vector) {
-	int32_t time[4];
-	Time::Convert(input, time[0], time[1], time[2], time[3]);
-
-	char micro_buffer[10];
-	idx_t length = TimeToStringCast::Length(time, micro_buffer);
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	TimeToStringCast::Format(data, length, time, micro_buffer);
-
-	result.Finalize();
-	return result;
-}
-
-template <>
-duckdb::string_t StringCast::Operation(timestamp_t input, Vector &vector) {
-	if (input == timestamp_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
-	} else if (input == timestamp_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
-	}
-	date_t date_entry;
-	dtime_t time_entry;
-	Timestamp::Convert(input, date_entry, time_entry);
-
-	int32_t date[3], time[4];
-	Date::Convert(date_entry, date[0], date[1], date[2]);
-	Time::Convert(time_entry, time[0], time[1], time[2], time[3]);
-
-	// format for timestamp is DATE TIME (separated by space)
-	idx_t year_length;
-	bool add_bc;
-	char micro_buffer[6];
-	idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
-	idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
-	idx_t length = date_length + time_length + 1;
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	DateToStringCast::Format(data, date, year_length, add_bc);
-	data[date_length] = ' ';
-	TimeToStringCast::Format(data + date_length + 1, time_length, time, micro_buffer);
-
-	result.Finalize();
-	return result;
-}
-
-template <>
-duckdb::string_t StringCast::Operation(duckdb::string_t input, Vector &result) {
-	return StringVector::AddStringOrBlob(result, input);
-}
-
-template <>
-string_t StringCastTZ::Operation(dtime_t input, Vector &vector) {
-	int32_t time[4];
-	Time::Convert(input, time[0], time[1], time[2], time[3]);
-
-	// format for timetz is TIME+00
-	char micro_buffer[10];
-	const auto time_length = TimeToStringCast::Length(time, micro_buffer);
-	const idx_t length = time_length + 3;
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	idx_t pos = 0;
-	TimeToStringCast::Format(data + pos, length, time, micro_buffer);
-	pos += time_length;
-	data[pos++] = '+';
-	data[pos++] = '0';
-	data[pos++] = '0';
-
-	result.Finalize();
-	return result;
-}
-
-template <>
-string_t StringCastTZ::Operation(timestamp_t input, Vector &vector) {
-	if (input == timestamp_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
-	} else if (input == timestamp_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
-	}
-	date_t date_entry;
-	dtime_t time_entry;
-	Timestamp::Convert(input, date_entry, time_entry);
-
-	int32_t date[3], time[4];
-	Date::Convert(date_entry, date[0], date[1], date[2]);
-	Time::Convert(time_entry, time[0], time[1], time[2], time[3]);
-
-	// format for timestamptz is DATE TIME+00 (separated by space)
-	idx_t year_length;
-	bool add_bc;
-	char micro_buffer[6];
-	const idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
-	const idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
-	const idx_t length = date_length + 1 + time_length + 3;
-
-	string_t result = StringVector::EmptyString(vector, length);
-	auto data = result.GetDataWriteable();
-
-	idx_t pos = 0;
-	DateToStringCast::Format(data + pos, date, year_length, add_bc);
-	pos += date_length;
-	data[pos++] = ' ';
-	TimeToStringCast::Format(data + pos, time_length, time, micro_buffer);
-	pos += time_length;
-	data[pos++] = '+';
-	data[pos++] = '0';
-	data[pos++] = '0';
-
-	result.Finalize();
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-class PipeFile : public FileHandle {
-public:
-	PipeFile(unique_ptr<FileHandle> child_handle_p, const string &path)
-	    : FileHandle(pipe_fs, path), child_handle(move(child_handle_p)) {
-	}
-
-	PipeFileSystem pipe_fs;
-	unique_ptr<FileHandle> child_handle;
-
-public:
-	int64_t ReadChunk(void *buffer, int64_t nr_bytes);
-	int64_t WriteChunk(void *buffer, int64_t nr_bytes);
-
-	void Close() override {
-	}
-};
-
-int64_t PipeFile::ReadChunk(void *buffer, int64_t nr_bytes) {
-	return child_handle->Read(buffer, nr_bytes);
-}
-int64_t PipeFile::WriteChunk(void *buffer, int64_t nr_bytes) {
-	return child_handle->Write(buffer, nr_bytes);
-}
-
-void PipeFileSystem::Reset(FileHandle &handle) {
-	throw InternalException("Cannot reset pipe file system");
-}
-
-int64_t PipeFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &pipe = (PipeFile &)handle;
-	return pipe.ReadChunk(buffer, nr_bytes);
-}
-
-int64_t PipeFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &pipe = (PipeFile &)handle;
-	return pipe.WriteChunk(buffer, nr_bytes);
-}
-
-int64_t PipeFileSystem::GetFileSize(FileHandle &handle) {
-	return 0;
-}
-
-void PipeFileSystem::FileSync(FileHandle &handle) {
-}
-
-unique_ptr<FileHandle> PipeFileSystem::OpenPipe(unique_ptr<FileHandle> handle) {
-	auto path = handle->path;
-	return make_unique<PipeFile>(move(handle), path);
-}
-
-} // namespace duckdb
-
-
-
-
-#include <stdio.h>
-
-#ifndef DUCKDB_DISABLE_PRINT
-#ifdef DUCKDB_WINDOWS
-#include <io.h>
-#endif
-#endif
-
-namespace duckdb {
-
-// LCOV_EXCL_START
-void Printer::Print(const string &str) {
-#ifndef DUCKDB_DISABLE_PRINT
-#ifdef DUCKDB_WINDOWS
-	if (IsTerminal()) {
-		// print utf8 to terminal
-		auto unicode = WindowsUtil::UTF8ToMBCS(str.c_str());
-		fprintf(stderr, "%s\n", unicode.c_str());
-		return;
-	}
-#endif
-	fprintf(stderr, "%s\n", str.c_str());
-#endif
-}
-
-void Printer::PrintProgress(int percentage, const char *pbstr, int pbwidth) {
-#ifndef DUCKDB_DISABLE_PRINT
-	int lpad = (int)(percentage / 100.0 * pbwidth);
-	int rpad = pbwidth - lpad;
-	printf("\r%3d%% [%.*s%*s]", percentage, lpad, pbstr, rpad, "");
-	fflush(stdout);
-#endif
-}
-
-void Printer::FinishProgressBarPrint(const char *pbstr, int pbwidth) {
-#ifndef DUCKDB_DISABLE_PRINT
-	PrintProgress(100, pbstr, pbwidth);
-	printf(" \n");
-	fflush(stdout);
-#endif
-}
-
-bool Printer::IsTerminal() {
-#ifndef DUCKDB_DISABLE_PRINT
-#ifdef DUCKDB_WINDOWS
-	return GetFileType(GetStdHandle(STD_ERROR_HANDLE)) == FILE_TYPE_CHAR;
-#else
-	throw InternalException("IsTerminal is only implemented for Windows");
-#endif
-#endif
-	return false;
-}
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-ProgressBar::ProgressBar(Executor &executor, idx_t show_progress_after, bool print_progress)
-    : executor(executor), show_progress_after(show_progress_after), current_percentage(-1),
-      print_progress(print_progress) {
-}
-
-double ProgressBar::GetCurrentPercentage() {
-	return current_percentage;
-}
-
-void ProgressBar::Start() {
-	profiler.Start();
-	current_percentage = 0;
-	supported = true;
-}
-
-void ProgressBar::Update(bool final) {
-	if (!supported) {
-		return;
-	}
-	double new_percentage;
-	supported = executor.GetPipelinesProgress(new_percentage);
-	if (!supported) {
-		return;
-	}
-	auto sufficient_time_elapsed = profiler.Elapsed() > show_progress_after / 1000.0;
-	if (new_percentage > current_percentage) {
-		current_percentage = new_percentage;
-	}
-	if (supported && print_progress && sufficient_time_elapsed && current_percentage > -1 && print_progress) {
-		if (final) {
-			Printer::FinishProgressBarPrint(PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
-		} else {
-			Printer::PrintProgress(current_percentage, PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-#include <random>
-
-namespace duckdb {
-
-struct RandomState {
-	RandomState() {
-	}
-
-	pcg32 pcg;
-};
-
-RandomEngine::RandomEngine(int64_t seed) : random_state(make_unique<RandomState>()) {
-	if (seed < 0) {
-		random_state->pcg.seed(pcg_extras::seed_seq_from<std::random_device>());
-	} else {
-		random_state->pcg.seed(seed);
-	}
-}
-
-RandomEngine::~RandomEngine() {
-}
-
-double RandomEngine::NextRandom(double min, double max) {
-	D_ASSERT(max >= min);
-	return min + (NextRandom() * (max - min));
-}
-
-double RandomEngine::NextRandom() {
-	return random_state->pcg() / double(std::numeric_limits<uint32_t>::max());
-}
-uint32_t RandomEngine::NextRandomInteger() {
-	return random_state->pcg();
-}
-
-void RandomEngine::SetSeed(uint32_t seed) {
-	random_state->pcg.seed(seed);
-}
-
-} // namespace duckdb
-#include <vector>
-#include <memory>
-
-
-
-
-namespace duckdb_re2 {
-
-Regex::Regex(const std::string &pattern, RegexOptions options) {
-	RE2::Options o;
-	o.set_case_sensitive(options == RegexOptions::CASE_INSENSITIVE);
-	regex = std::make_shared<duckdb_re2::RE2>(StringPiece(pattern), o);
-}
-
-bool RegexSearchInternal(const char *input, Match &match, const Regex &r, RE2::Anchor anchor, size_t start,
-                         size_t end) {
-	auto &regex = r.GetRegex();
-	std::vector<StringPiece> target_groups;
-	auto group_count = regex.NumberOfCapturingGroups() + 1;
-	target_groups.resize(group_count);
-	match.groups.clear();
-	if (!regex.Match(StringPiece(input), start, end, anchor, target_groups.data(), group_count)) {
-		return false;
-	}
-	for (auto &group : target_groups) {
-		GroupMatch group_match;
-		group_match.text = group.ToString();
-		group_match.position = group.data() - input;
-		match.groups.emplace_back(group_match);
-	}
-	return true;
-}
-
-bool RegexSearch(const std::string &input, Match &match, const Regex &regex) {
-	return RegexSearchInternal(input.c_str(), match, regex, RE2::UNANCHORED, 0, input.size());
-}
-
-bool RegexMatch(const std::string &input, Match &match, const Regex &regex) {
-	return RegexSearchInternal(input.c_str(), match, regex, RE2::ANCHOR_BOTH, 0, input.size());
-}
-
-bool RegexMatch(const char *start, const char *end, Match &match, const Regex &regex) {
-	return RegexSearchInternal(start, match, regex, RE2::ANCHOR_BOTH, 0, end - start);
-}
-
-bool RegexMatch(const std::string &input, const Regex &regex) {
-	Match nop_match;
-	return RegexSearchInternal(input.c_str(), nop_match, regex, RE2::ANCHOR_BOTH, 0, input.size());
-}
-
-std::vector<Match> RegexFindAll(const std::string &input, const Regex &regex) {
-	std::vector<Match> matches;
-	size_t position = 0;
-	Match match;
-	while (RegexSearchInternal(input.c_str(), match, regex, RE2::UNANCHORED, position, input.size())) {
-		position += match.position(0) + match.length(0);
-		matches.emplace_back(std::move(match));
-	}
-	return matches;
-}
-
-} // namespace duckdb_re2
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_operations/row_aggregate.cpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-void RowOperations::InitializeStates(RowLayout &layout, Vector &addresses, const SelectionVector &sel, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-	auto pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	auto &offsets = layout.GetOffsets();
-	auto aggr_idx = layout.ColumnCount();
-
-	for (auto &aggr : layout.GetAggregates()) {
-		for (idx_t i = 0; i < count; ++i) {
-			auto row_idx = sel.get_index(i);
-			auto row = pointers[row_idx];
-			aggr.function.initialize(row + offsets[aggr_idx]);
-		}
-		++aggr_idx;
-	}
-}
-
-void RowOperations::DestroyStates(RowLayout &layout, Vector &addresses, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-	//	Move to the first aggregate state
-	VectorOperations::AddInPlace(addresses, layout.GetAggrOffset(), count);
-	for (auto &aggr : layout.GetAggregates()) {
-		if (aggr.function.destructor) {
-			aggr.function.destructor(addresses, count);
-		}
-		// Move to the next aggregate state
-		VectorOperations::AddInPlace(addresses, aggr.payload_size, count);
-	}
-}
-
-void RowOperations::UpdateStates(AggregateObject &aggr, Vector &addresses, DataChunk &payload, idx_t arg_idx,
-                                 idx_t count) {
-	AggregateInputData aggr_input_data(aggr.bind_data);
-	aggr.function.update(aggr.child_count == 0 ? nullptr : &payload.data[arg_idx], aggr_input_data, aggr.child_count,
-	                     addresses, count);
-}
-
-void RowOperations::UpdateFilteredStates(AggregateFilterData &filter_data, AggregateObject &aggr, Vector &addresses,
-                                         DataChunk &payload, idx_t arg_idx) {
-	idx_t count = filter_data.ApplyFilter(payload);
-
-	Vector filtered_addresses(addresses, filter_data.true_sel, count);
-	filtered_addresses.Normalify(count);
-
-	UpdateStates(aggr, filtered_addresses, filter_data.filtered_payload, arg_idx, count);
-}
-
-void RowOperations::CombineStates(RowLayout &layout, Vector &sources, Vector &targets, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-
-	//	Move to the first aggregate states
-	VectorOperations::AddInPlace(sources, layout.GetAggrOffset(), count);
-	VectorOperations::AddInPlace(targets, layout.GetAggrOffset(), count);
-	for (auto &aggr : layout.GetAggregates()) {
-		D_ASSERT(aggr.function.combine);
-		AggregateInputData aggr_input_data(aggr.bind_data);
-		aggr.function.combine(sources, targets, aggr_input_data, count);
-
-		// Move to the next aggregate states
-		VectorOperations::AddInPlace(sources, aggr.payload_size, count);
-		VectorOperations::AddInPlace(targets, aggr.payload_size, count);
-	}
-}
-
-void RowOperations::FinalizeStates(RowLayout &layout, Vector &addresses, DataChunk &result, idx_t aggr_idx) {
-	//	Move to the first aggregate state
-	VectorOperations::AddInPlace(addresses, layout.GetAggrOffset(), result.size());
-
-	auto &aggregates = layout.GetAggregates();
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &target = result.data[aggr_idx + i];
-		auto &aggr = aggregates[i];
-		AggregateInputData aggr_input_data(aggr.bind_data);
-		aggr.function.finalize(addresses, aggr_input_data, target, result.size(), 0);
-
-		// Move to the next aggregate state
-		VectorOperations::AddInPlace(addresses, aggr.payload_size, result.size());
-	}
-}
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_operations/row_external.cpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-namespace duckdb {
-
-void RowOperations::SwizzleColumns(const RowLayout &layout, const data_ptr_t base_row_ptr, const idx_t count) {
-	const idx_t row_width = layout.GetRowWidth();
-	data_ptr_t heap_row_ptrs[STANDARD_VECTOR_SIZE];
-	idx_t done = 0;
-	while (done != count) {
-		const idx_t next = MinValue<idx_t>(count - done, STANDARD_VECTOR_SIZE);
-		const data_ptr_t row_ptr = base_row_ptr + done * row_width;
-		// Load heap row pointers
-		data_ptr_t heap_ptr_ptr = row_ptr + layout.GetHeapPointerOffset();
-		for (idx_t i = 0; i < next; i++) {
-			heap_row_ptrs[i] = Load<data_ptr_t>(heap_ptr_ptr);
-			heap_ptr_ptr += row_width;
-		}
-		// Loop through the blob columns
-		for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-			auto physical_type = layout.GetTypes()[col_idx].InternalType();
-			if (TypeIsConstantSize(physical_type)) {
-				continue;
-			}
-			data_ptr_t col_ptr = row_ptr + layout.GetOffsets()[col_idx];
-			if (physical_type == PhysicalType::VARCHAR) {
-				data_ptr_t string_ptr = col_ptr + sizeof(uint32_t) + string_t::PREFIX_LENGTH;
-				for (idx_t i = 0; i < next; i++) {
-					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
-						// Overwrite the string pointer with the within-row offset (if not inlined)
-						Store<idx_t>(Load<data_ptr_t>(string_ptr) - heap_row_ptrs[i], string_ptr);
-					}
-					col_ptr += row_width;
-					string_ptr += row_width;
-				}
-			} else {
-				// Non-varchar blob columns
-				for (idx_t i = 0; i < next; i++) {
-					// Overwrite the column data pointer with the within-row offset
-					Store<idx_t>(Load<data_ptr_t>(col_ptr) - heap_row_ptrs[i], col_ptr);
-					col_ptr += row_width;
-				}
-			}
-		}
-		done += next;
-	}
-}
-
-void RowOperations::SwizzleHeapPointer(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
-                                       const idx_t count) {
-	const idx_t row_width = layout.GetRowWidth();
-	row_ptr += layout.GetHeapPointerOffset();
-	idx_t cumulative_offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		Store<idx_t>(cumulative_offset, row_ptr);
-		cumulative_offset += Load<uint32_t>(heap_base_ptr + cumulative_offset);
-		row_ptr += row_width;
-	}
-}
-
-void RowOperations::UnswizzlePointers(const RowLayout &layout, const data_ptr_t base_row_ptr,
-                                      const data_ptr_t base_heap_ptr, const idx_t count) {
-	const idx_t row_width = layout.GetRowWidth();
-	data_ptr_t heap_row_ptrs[STANDARD_VECTOR_SIZE];
-	idx_t done = 0;
-	while (done != count) {
-		const idx_t next = MinValue<idx_t>(count - done, STANDARD_VECTOR_SIZE);
-		const data_ptr_t row_ptr = base_row_ptr + done * row_width;
-		// Restore heap row pointers
-		data_ptr_t heap_ptr_ptr = row_ptr + layout.GetHeapPointerOffset();
-		for (idx_t i = 0; i < next; i++) {
-			heap_row_ptrs[i] = base_heap_ptr + Load<idx_t>(heap_ptr_ptr);
-			Store<data_ptr_t>(heap_row_ptrs[i], heap_ptr_ptr);
-			heap_ptr_ptr += row_width;
-		}
-		// Loop through the blob columns
-		for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-			auto physical_type = layout.GetTypes()[col_idx].InternalType();
-			if (TypeIsConstantSize(physical_type)) {
-				continue;
-			}
-			data_ptr_t col_ptr = row_ptr + layout.GetOffsets()[col_idx];
-			if (physical_type == PhysicalType::VARCHAR) {
-				data_ptr_t string_ptr = col_ptr + sizeof(uint32_t) + string_t::PREFIX_LENGTH;
-				for (idx_t i = 0; i < next; i++) {
-					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
-						// Overwrite the string offset with the pointer (if not inlined)
-						Store<data_ptr_t>(heap_row_ptrs[i] + Load<idx_t>(string_ptr), string_ptr);
-					}
-					col_ptr += row_width;
-					string_ptr += row_width;
-				}
-			} else {
-				// Non-varchar blob columns
-				for (idx_t i = 0; i < next; i++) {
-					// Overwrite the column data offset with the pointer
-					Store<data_ptr_t>(heap_row_ptrs[i] + Load<idx_t>(col_ptr), col_ptr);
-					col_ptr += row_width;
-				}
-			}
-		}
-		done += next;
-	}
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// row_gather.cpp
-// Description: This file contains the implementation of the gather operators
-//===--------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-using ValidityBytes = RowLayout::ValidityBytes;
-
-template <class T>
-static void TemplatedGatherLoop(Vector &rows, const SelectionVector &row_sel, Vector &col,
-                                const SelectionVector &col_sel, idx_t count, idx_t col_offset, idx_t col_no,
-                                idx_t build_size) {
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	auto data = FlatVector::GetData<T>(col);
-	auto &col_mask = FlatVector::Validity(col);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto row_idx = row_sel.get_index(i);
-		auto row = ptrs[row_idx];
-		auto col_idx = col_sel.get_index(i);
-		data[col_idx] = Load<T>(row + col_offset);
-		ValidityBytes row_mask(row);
-		if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
-			if (build_size > STANDARD_VECTOR_SIZE && col_mask.AllValid()) {
-				//! We need to initialize the mask with the vector size.
-				col_mask.Initialize(build_size);
-			}
-			col_mask.SetInvalid(col_idx);
-		}
-	}
-}
-
-static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vector &col,
-                               const SelectionVector &col_sel, idx_t count, idx_t col_offset, idx_t col_no) {
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-
-	// Build the gather locations
-	auto data_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
-	auto mask_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
-	for (idx_t i = 0; i < count; i++) {
-		auto row_idx = row_sel.get_index(i);
-		mask_locations[i] = ptrs[row_idx];
-		data_locations[i] = Load<data_ptr_t>(ptrs[row_idx] + col_offset);
-	}
-
-	// Deserialise into the selected locations
-	RowOperations::HeapGather(col, count, col_sel, col_no, data_locations.get(), mask_locations.get());
-}
-
-void RowOperations::Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
-                           const idx_t count, const idx_t col_offset, const idx_t col_no, const idx_t build_size) {
-	D_ASSERT(rows.GetVectorType() == VectorType::FLAT_VECTOR);
-	D_ASSERT(rows.GetType().id() == LogicalTypeId::POINTER); // "Cannot gather from non-pointer type!"
-
-	col.SetVectorType(VectorType::FLAT_VECTOR);
-	switch (col.GetType().InternalType()) {
-	case PhysicalType::UINT8:
-		TemplatedGatherLoop<uint8_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedGatherLoop<uint16_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedGatherLoop<uint32_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedGatherLoop<uint64_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedGatherLoop<int8_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGatherLoop<int16_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGatherLoop<int32_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGatherLoop<int64_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::INT128:
-		TemplatedGatherLoop<hugeint_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedGatherLoop<float>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGatherLoop<double>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedGatherLoop<interval_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedGatherLoop<string_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
-		break;
-	case PhysicalType::LIST:
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-		GatherNestedVector(rows, row_sel, col, col_sel, count, col_offset, col_no);
-		break;
-	default:
-		throw InternalException("Unimplemented type for RowOperations::Gather");
-	}
-}
-
-template <class T>
-static void TemplatedFullScanLoop(Vector &rows, Vector &col, idx_t count, idx_t col_offset, idx_t col_no) {
-	// Precompute mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	auto data = FlatVector::GetData<T>(col);
-	//	auto &col_mask = FlatVector::Validity(col);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto row = ptrs[i];
-		data[i] = Load<T>(row + col_offset);
-		ValidityBytes row_mask(row);
-		if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
-			throw InternalException("Null value comparisons not implemented for perfect hash table yet");
-			//			col_mask.SetInvalid(i);
-		}
-	}
-}
-
-void RowOperations::FullScanColumn(const RowLayout &layout, Vector &rows, Vector &col, idx_t count, idx_t col_no) {
-	const auto col_offset = layout.GetOffsets()[col_no];
-	col.SetVectorType(VectorType::FLAT_VECTOR);
-	switch (col.GetType().InternalType()) {
-	case PhysicalType::UINT8:
-		TemplatedFullScanLoop<uint8_t>(rows, col, count, col_offset, col_no);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedFullScanLoop<uint16_t>(rows, col, count, col_offset, col_no);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedFullScanLoop<uint32_t>(rows, col, count, col_offset, col_no);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedFullScanLoop<uint64_t>(rows, col, count, col_offset, col_no);
-		break;
-	case PhysicalType::INT8:
-		TemplatedFullScanLoop<int8_t>(rows, col, count, col_offset, col_no);
-		break;
-	case PhysicalType::INT16:
-		TemplatedFullScanLoop<int16_t>(rows, col, count, col_offset, col_no);
-		break;
-	case PhysicalType::INT32:
-		TemplatedFullScanLoop<int32_t>(rows, col, count, col_offset, col_no);
-		break;
-	case PhysicalType::INT64:
-		TemplatedFullScanLoop<int64_t>(rows, col, count, col_offset, col_no);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for RowOperations::FullScanColumn");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-template <class T>
-static void TemplatedHeapGather(Vector &v, const idx_t count, const SelectionVector &sel, data_ptr_t *key_locations) {
-	auto target = FlatVector::GetData<T>(v);
-
-	for (idx_t i = 0; i < count; ++i) {
-		const auto col_idx = sel.get_index(i);
-		target[col_idx] = Load<T>(key_locations[i]);
-		key_locations[i] += sizeof(T);
-	}
-}
-
-static void HeapGatherStringVector(Vector &v, const idx_t vcount, const SelectionVector &sel,
-                                   data_ptr_t *key_locations) {
-	const auto &validity = FlatVector::Validity(v);
-	auto target = FlatVector::GetData<string_t>(v);
-
-	for (idx_t i = 0; i < vcount; i++) {
-		const auto col_idx = sel.get_index(i);
-		if (!validity.RowIsValid(col_idx)) {
-			continue;
-		}
-		auto len = Load<uint32_t>(key_locations[i]);
-		key_locations[i] += sizeof(uint32_t);
-		target[col_idx] = StringVector::AddStringOrBlob(v, string_t((const char *)key_locations[i], len));
-		key_locations[i] += len;
-	}
-}
-
-static void HeapGatherStructVector(Vector &v, const idx_t vcount, const SelectionVector &sel,
-                                   data_ptr_t *key_locations) {
-	// struct must have a validitymask for its fields
-	auto &child_types = StructType::GetChildTypes(v.GetType());
-	const idx_t struct_validitymask_size = (child_types.size() + 7) / 8;
-	data_ptr_t struct_validitymask_locations[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < vcount; i++) {
-		// use key_locations as the validitymask, and create struct_key_locations
-		struct_validitymask_locations[i] = key_locations[i];
-		key_locations[i] += struct_validitymask_size;
-	}
-
-	// now deserialize into the struct vectors
-	auto &children = StructVector::GetEntries(v);
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		RowOperations::HeapGather(*children[i], vcount, sel, i, key_locations, struct_validitymask_locations);
-	}
-}
-
-static void HeapGatherListVector(Vector &v, const idx_t vcount, const SelectionVector &sel, data_ptr_t *key_locations) {
-	const auto &validity = FlatVector::Validity(v);
-
-	auto child_type = ListType::GetChildType(v.GetType());
-	auto list_data = ListVector::GetData(v);
-	data_ptr_t list_entry_locations[STANDARD_VECTOR_SIZE];
-
-	uint64_t entry_offset = ListVector::GetListSize(v);
-	for (idx_t i = 0; i < vcount; i++) {
-		const auto col_idx = sel.get_index(i);
-		if (!validity.RowIsValid(col_idx)) {
-			continue;
-		}
-		// read list length
-		auto entry_remaining = Load<uint64_t>(key_locations[i]);
-		key_locations[i] += sizeof(uint64_t);
-		// set list entry attributes
-		list_data[col_idx].length = entry_remaining;
-		list_data[col_idx].offset = entry_offset;
-		// skip over the validity mask
-		data_ptr_t validitymask_location = key_locations[i];
-		idx_t offset_in_byte = 0;
-		key_locations[i] += (entry_remaining + 7) / 8;
-		// entry sizes
-		data_ptr_t var_entry_size_ptr = nullptr;
-		if (!TypeIsConstantSize(child_type.InternalType())) {
-			var_entry_size_ptr = key_locations[i];
-			key_locations[i] += entry_remaining * sizeof(idx_t);
-		}
-
-		// now read the list data
-		while (entry_remaining > 0) {
-			auto next = MinValue(entry_remaining, (idx_t)STANDARD_VECTOR_SIZE);
-
-			// initialize a new vector to append
-			Vector append_vector(v.GetType());
-			append_vector.SetVectorType(v.GetVectorType());
-
-			auto &list_vec_to_append = ListVector::GetEntry(append_vector);
-
-			// set validity
-			//! Since we are constructing the vector, this will always be a flat vector.
-			auto &append_validity = FlatVector::Validity(list_vec_to_append);
-			for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-				append_validity.Set(entry_idx, *(validitymask_location) & (1 << offset_in_byte));
-				if (++offset_in_byte == 8) {
-					validitymask_location++;
-					offset_in_byte = 0;
-				}
-			}
-
-			// compute entry sizes and set locations where the list entries are
-			if (TypeIsConstantSize(child_type.InternalType())) {
-				// constant size list entries
-				const idx_t type_size = GetTypeIdSize(child_type.InternalType());
-				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-					list_entry_locations[entry_idx] = key_locations[i];
-					key_locations[i] += type_size;
-				}
-			} else {
-				// variable size list entries
-				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-					list_entry_locations[entry_idx] = key_locations[i];
-					key_locations[i] += Load<idx_t>(var_entry_size_ptr);
-					var_entry_size_ptr += sizeof(idx_t);
-				}
-			}
-
-			// now deserialize and add to listvector
-			RowOperations::HeapGather(list_vec_to_append, next, *FlatVector::IncrementalSelectionVector(), 0,
-			                          list_entry_locations, nullptr);
-			ListVector::Append(v, list_vec_to_append, next);
-
-			// update for next iteration
-			entry_remaining -= next;
-			entry_offset += next;
-		}
-	}
-}
-
-void RowOperations::HeapGather(Vector &v, const idx_t &vcount, const SelectionVector &sel, const idx_t &col_no,
-                               data_ptr_t *key_locations, data_ptr_t *validitymask_locations) {
-	v.SetVectorType(VectorType::FLAT_VECTOR);
-
-	auto &validity = FlatVector::Validity(v);
-	if (validitymask_locations) {
-		// Precompute mask indexes
-		idx_t entry_idx;
-		idx_t idx_in_entry;
-		ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-		for (idx_t i = 0; i < vcount; i++) {
-			ValidityBytes row_mask(validitymask_locations[i]);
-			const auto valid = row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
-			const auto col_idx = sel.get_index(i);
-			validity.Set(col_idx, valid);
-		}
-	}
-
-	auto type = v.GetType().InternalType();
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedHeapGather<int8_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INT16:
-		TemplatedHeapGather<int16_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INT32:
-		TemplatedHeapGather<int32_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INT64:
-		TemplatedHeapGather<int64_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedHeapGather<uint8_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedHeapGather<uint16_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedHeapGather<uint32_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedHeapGather<uint64_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INT128:
-		TemplatedHeapGather<hugeint_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedHeapGather<float>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedHeapGather<double>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedHeapGather<interval_t>(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::VARCHAR:
-		HeapGatherStringVector(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::STRUCT:
-		HeapGatherStructVector(v, vcount, sel, key_locations);
-		break;
-	case PhysicalType::LIST:
-		HeapGatherListVector(v, vcount, sel, key_locations);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented deserialize from row-format");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-static void ComputeStringEntrySizes(VectorData &vdata, idx_t entry_sizes[], const idx_t ser_count,
-                                    const SelectionVector &sel, const idx_t offset) {
-	auto strings = (string_t *)vdata.data;
-	for (idx_t i = 0; i < ser_count; i++) {
-		auto idx = sel.get_index(i);
-		auto str_idx = vdata.sel->get_index(idx) + offset;
-		if (vdata.validity.RowIsValid(str_idx)) {
-			entry_sizes[i] += sizeof(uint32_t) + strings[str_idx].GetSize();
-		}
-	}
-}
-
-static void ComputeStructEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-                                    const SelectionVector &sel, idx_t offset) {
-	// obtain child vectors
-	idx_t num_children;
-	auto &children = StructVector::GetEntries(v);
-	num_children = children.size();
-	// add struct validitymask size
-	const idx_t struct_validitymask_size = (num_children + 7) / 8;
-	for (idx_t i = 0; i < ser_count; i++) {
-		entry_sizes[i] += struct_validitymask_size;
-	}
-	// compute size of child vectors
-	for (auto &struct_vector : children) {
-		RowOperations::ComputeEntrySizes(*struct_vector, entry_sizes, vcount, ser_count, sel, offset);
-	}
-}
-
-static void ComputeListEntrySizes(Vector &v, VectorData &vdata, idx_t entry_sizes[], idx_t ser_count,
-                                  const SelectionVector &sel, idx_t offset) {
-	auto list_data = ListVector::GetData(v);
-	auto &child_vector = ListVector::GetEntry(v);
-	idx_t list_entry_sizes[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < ser_count; i++) {
-		auto idx = sel.get_index(i);
-		auto source_idx = vdata.sel->get_index(idx) + offset;
-		if (vdata.validity.RowIsValid(source_idx)) {
-			auto list_entry = list_data[source_idx];
-
-			// make room for list length, list validitymask
-			entry_sizes[i] += sizeof(list_entry.length);
-			entry_sizes[i] += (list_entry.length + 7) / 8;
-
-			// serialize size of each entry (if non-constant size)
-			if (!TypeIsConstantSize(ListType::GetChildType(v.GetType()).InternalType())) {
-				entry_sizes[i] += list_entry.length * sizeof(list_entry.length);
-			}
-
-			// compute size of each the elements in list_entry and sum them
-			auto entry_remaining = list_entry.length;
-			auto entry_offset = list_entry.offset;
-			while (entry_remaining > 0) {
-				// the list entry can span multiple vectors
-				auto next = MinValue((idx_t)STANDARD_VECTOR_SIZE, entry_remaining);
-
-				// compute and add to the total
-				std::fill_n(list_entry_sizes, next, 0);
-				RowOperations::ComputeEntrySizes(child_vector, list_entry_sizes, next, next,
-				                                 *FlatVector::IncrementalSelectionVector(), entry_offset);
-				for (idx_t list_idx = 0; list_idx < next; list_idx++) {
-					entry_sizes[i] += list_entry_sizes[list_idx];
-				}
-
-				// update for next iteration
-				entry_remaining -= next;
-				entry_offset += next;
-			}
-		}
-	}
-}
-
-void RowOperations::ComputeEntrySizes(Vector &v, VectorData &vdata, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-                                      const SelectionVector &sel, idx_t offset) {
-	const auto physical_type = v.GetType().InternalType();
-	if (TypeIsConstantSize(physical_type)) {
-		const auto type_size = GetTypeIdSize(physical_type);
-		for (idx_t i = 0; i < ser_count; i++) {
-			entry_sizes[i] += type_size;
-		}
-	} else {
-		switch (physical_type) {
-		case PhysicalType::VARCHAR:
-			ComputeStringEntrySizes(vdata, entry_sizes, ser_count, sel, offset);
-			break;
-		case PhysicalType::STRUCT:
-			ComputeStructEntrySizes(v, entry_sizes, vcount, ser_count, sel, offset);
-			break;
-		case PhysicalType::LIST:
-			ComputeListEntrySizes(v, vdata, entry_sizes, ser_count, sel, offset);
-			break;
-		default:
-			// LCOV_EXCL_START
-			throw NotImplementedException("Column with variable size type %s cannot be serialized to row-format",
-			                              v.GetType().ToString());
-			// LCOV_EXCL_STOP
-		}
-	}
-}
-
-void RowOperations::ComputeEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-                                      const SelectionVector &sel, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
-	ComputeEntrySizes(v, vdata, entry_sizes, vcount, ser_count, sel, offset);
-}
-
-template <class T>
-static void TemplatedHeapScatter(VectorData &vdata, const SelectionVector &sel, idx_t count, idx_t col_idx,
-                                 data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	auto source = (T *)vdata.data;
-	if (!validitymask_locations) {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-
-			auto target = (T *)key_locations[i];
-			Store<T>(source[source_idx], (data_ptr_t)target);
-			key_locations[i] += sizeof(T);
-		}
-	} else {
-		idx_t entry_idx;
-		idx_t idx_in_entry;
-		ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-		const auto bit = ~(1UL << idx_in_entry);
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-
-			auto target = (T *)key_locations[i];
-			Store<T>(source[source_idx], (data_ptr_t)target);
-			key_locations[i] += sizeof(T);
-
-			// set the validitymask
-			if (!vdata.validity.RowIsValid(source_idx)) {
-				*(validitymask_locations[i] + entry_idx) &= bit;
-			}
-		}
-	}
-}
-
-static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_idx,
-                                    data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
-
-	auto strings = (string_t *)vdata.data;
-	if (!validitymask_locations) {
-		for (idx_t i = 0; i < ser_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			if (vdata.validity.RowIsValid(source_idx)) {
-				auto &string_entry = strings[source_idx];
-				// store string size
-				Store<uint32_t>(string_entry.GetSize(), key_locations[i]);
-				key_locations[i] += sizeof(uint32_t);
-				// store the string
-				memcpy(key_locations[i], string_entry.GetDataUnsafe(), string_entry.GetSize());
-				key_locations[i] += string_entry.GetSize();
-			}
-		}
-	} else {
-		idx_t entry_idx;
-		idx_t idx_in_entry;
-		ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-		const auto bit = ~(1UL << idx_in_entry);
-		for (idx_t i = 0; i < ser_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			if (vdata.validity.RowIsValid(source_idx)) {
-				auto &string_entry = strings[source_idx];
-				// store string size
-				Store<uint32_t>(string_entry.GetSize(), key_locations[i]);
-				key_locations[i] += sizeof(uint32_t);
-				// store the string
-				memcpy(key_locations[i], string_entry.GetDataUnsafe(), string_entry.GetSize());
-				key_locations[i] += string_entry.GetSize();
-			} else {
-				// set the validitymask
-				*(validitymask_locations[i] + entry_idx) &= bit;
-			}
-		}
-	}
-}
-
-static void HeapScatterStructVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_idx,
-                                    data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
-
-	auto &children = StructVector::GetEntries(v);
-	idx_t num_children = children.size();
-
-	// the whole struct itself can be NULL
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-	const auto bit = ~(1UL << idx_in_entry);
-
-	// struct must have a validitymask for its fields
-	const idx_t struct_validitymask_size = (num_children + 7) / 8;
-	data_ptr_t struct_validitymask_locations[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < ser_count; i++) {
-		// initialize the struct validity mask
-		struct_validitymask_locations[i] = key_locations[i];
-		memset(struct_validitymask_locations[i], -1, struct_validitymask_size);
-		key_locations[i] += struct_validitymask_size;
-
-		// set whether the whole struct is null
-		auto idx = sel.get_index(i);
-		auto source_idx = vdata.sel->get_index(idx) + offset;
-		if (validitymask_locations && !vdata.validity.RowIsValid(source_idx)) {
-			*(validitymask_locations[i] + entry_idx) &= bit;
-		}
-	}
-
-	// now serialize the struct vectors
-	for (idx_t i = 0; i < children.size(); i++) {
-		auto &struct_vector = *children[i];
-		RowOperations::HeapScatter(struct_vector, vcount, sel, ser_count, i, key_locations,
-		                           struct_validitymask_locations, offset);
-	}
-}
-
-static void HeapScatterListVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_no,
-                                  data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
-
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-	auto list_data = ListVector::GetData(v);
-
-	auto &child_vector = ListVector::GetEntry(v);
-
-	VectorData list_vdata;
-	child_vector.Orrify(ListVector::GetListSize(v), list_vdata);
-	auto child_type = ListType::GetChildType(v.GetType()).InternalType();
-
-	idx_t list_entry_sizes[STANDARD_VECTOR_SIZE];
-	data_ptr_t list_entry_locations[STANDARD_VECTOR_SIZE];
-
-	for (idx_t i = 0; i < ser_count; i++) {
-		auto idx = sel.get_index(i);
-		auto source_idx = vdata.sel->get_index(idx) + offset;
-		if (!vdata.validity.RowIsValid(source_idx)) {
-			if (validitymask_locations) {
-				// set the row validitymask for this column to invalid
-				ValidityBytes row_mask(validitymask_locations[i]);
-				row_mask.SetInvalidUnsafe(entry_idx, idx_in_entry);
-			}
-			continue;
-		}
-		auto list_entry = list_data[source_idx];
-
-		// store list length
-		Store<uint64_t>(list_entry.length, key_locations[i]);
-		key_locations[i] += sizeof(list_entry.length);
-
-		// make room for the validitymask
-		data_ptr_t list_validitymask_location = key_locations[i];
-		idx_t entry_offset_in_byte = 0;
-		idx_t validitymask_size = (list_entry.length + 7) / 8;
-		memset(list_validitymask_location, -1, validitymask_size);
-		key_locations[i] += validitymask_size;
-
-		// serialize size of each entry (if non-constant size)
-		data_ptr_t var_entry_size_ptr = nullptr;
-		if (!TypeIsConstantSize(child_type)) {
-			var_entry_size_ptr = key_locations[i];
-			key_locations[i] += list_entry.length * sizeof(idx_t);
-		}
-
-		auto entry_remaining = list_entry.length;
-		auto entry_offset = list_entry.offset;
-		while (entry_remaining > 0) {
-			// the list entry can span multiple vectors
-			auto next = MinValue((idx_t)STANDARD_VECTOR_SIZE, entry_remaining);
-
-			// serialize list validity
-			for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-				auto list_idx = list_vdata.sel->get_index(entry_idx) + entry_offset;
-				if (!list_vdata.validity.RowIsValid(list_idx)) {
-					*(list_validitymask_location) &= ~(1UL << entry_offset_in_byte);
-				}
-				if (++entry_offset_in_byte == 8) {
-					list_validitymask_location++;
-					entry_offset_in_byte = 0;
-				}
-			}
-
-			if (TypeIsConstantSize(child_type)) {
-				// constant size list entries: set list entry locations
-				const idx_t type_size = GetTypeIdSize(child_type);
-				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-					list_entry_locations[entry_idx] = key_locations[i];
-					key_locations[i] += type_size;
-				}
-			} else {
-				// variable size list entries: compute entry sizes and set list entry locations
-				std::fill_n(list_entry_sizes, next, 0);
-				RowOperations::ComputeEntrySizes(child_vector, list_entry_sizes, next, next,
-				                                 *FlatVector::IncrementalSelectionVector(), entry_offset);
-				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
-					list_entry_locations[entry_idx] = key_locations[i];
-					key_locations[i] += list_entry_sizes[entry_idx];
-					Store<idx_t>(list_entry_sizes[entry_idx], var_entry_size_ptr);
-					var_entry_size_ptr += sizeof(idx_t);
-				}
-			}
-
-			// now serialize to the locations
-			RowOperations::HeapScatter(child_vector, ListVector::GetListSize(v),
-			                           *FlatVector::IncrementalSelectionVector(), next, 0, list_entry_locations,
-			                           nullptr, entry_offset);
-
-			// update for next iteration
-			entry_remaining -= next;
-			entry_offset += next;
-		}
-	}
-}
-
-void RowOperations::HeapScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_idx,
-                                data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	if (TypeIsConstantSize(v.GetType().InternalType())) {
-		VectorData vdata;
-		v.Orrify(vcount, vdata);
-		RowOperations::HeapScatterVData(vdata, v.GetType().InternalType(), sel, ser_count, col_idx, key_locations,
-		                                validitymask_locations, offset);
-	} else {
-		switch (v.GetType().InternalType()) {
-		case PhysicalType::VARCHAR:
-			HeapScatterStringVector(v, vcount, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-			break;
-		case PhysicalType::STRUCT:
-			HeapScatterStructVector(v, vcount, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-			break;
-		case PhysicalType::LIST:
-			HeapScatterListVector(v, vcount, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-			break;
-		default:
-			// LCOV_EXCL_START
-			throw NotImplementedException("Serialization of variable length vector with type %s",
-			                              v.GetType().ToString());
-			// LCOV_EXCL_STOP
-		}
-	}
-}
-
-void RowOperations::HeapScatterVData(VectorData &vdata, PhysicalType type, const SelectionVector &sel, idx_t ser_count,
-                                     idx_t col_idx, data_ptr_t *key_locations, data_ptr_t *validitymask_locations,
-                                     idx_t offset) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedHeapScatter<int8_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::INT16:
-		TemplatedHeapScatter<int16_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::INT32:
-		TemplatedHeapScatter<int32_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::INT64:
-		TemplatedHeapScatter<int64_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedHeapScatter<uint8_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedHeapScatter<uint16_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedHeapScatter<uint32_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedHeapScatter<uint64_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::INT128:
-		TemplatedHeapScatter<hugeint_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedHeapScatter<float>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedHeapScatter<double>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedHeapScatter<interval_t>(vdata, sel, ser_count, col_idx, key_locations, validitymask_locations, offset);
-		break;
-	default:
-		throw NotImplementedException("FIXME: Serialize to of constant type column to row-format");
-	}
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// row_match.cpp
-// Description: This file contains the implementation of the match operators
-//===--------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-using ValidityBytes = RowLayout::ValidityBytes;
-using Predicates = RowOperations::Predicates;
-
-template <typename OP>
-static idx_t SelectComparison(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                              SelectionVector *true_sel, SelectionVector *false_sel) {
-	throw NotImplementedException("Unsupported nested comparison operand for RowOperations::Match");
-}
-
-template <>
-idx_t SelectComparison<Equals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                               SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<NotEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedNotEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<GreaterThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<GreaterThanEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                          SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<LessThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                 SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<LessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                       SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <class T, class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchType(VectorData &col, Vector &rows, SelectionVector &sel, idx_t &count, idx_t col_offset,
-                               idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
-	// Precompute row_mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-	auto data = (T *)col.data;
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	idx_t match_count = 0;
-	if (!col.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-
-			auto row = ptrs[idx];
-			ValidityBytes row_mask(row);
-			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
-
-			auto col_idx = col.sel->get_index(idx);
-			if (!col.validity.RowIsValid(col_idx)) {
-				if (isnull) {
-					// match: move to next value to compare
-					sel.set_index(match_count++, idx);
-				} else {
-					if (NO_MATCH_SEL) {
-						no_match->set_index(no_match_count++, idx);
-					}
-				}
-			} else {
-				auto value = Load<T>(row + col_offset);
-				if (!isnull && OP::template Operation<T>(data[col_idx], value)) {
-					sel.set_index(match_count++, idx);
-				} else {
-					if (NO_MATCH_SEL) {
-						no_match->set_index(no_match_count++, idx);
-					}
-				}
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-
-			auto row = ptrs[idx];
-			ValidityBytes row_mask(row);
-			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
-
-			auto col_idx = col.sel->get_index(idx);
-			auto value = Load<T>(row + col_offset);
-			if (!isnull && OP::template Operation<T>(data[col_idx], value)) {
-				sel.set_index(match_count++, idx);
-			} else {
-				if (NO_MATCH_SEL) {
-					no_match->set_index(no_match_count++, idx);
-				}
-			}
-		}
-	}
-	count = match_count;
-}
-
-template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchNested(Vector &col, Vector &rows, SelectionVector &sel, idx_t &count, const idx_t col_offset,
-                                 const idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
-	// Gather a dense Vector containing the column values being matched
-	Vector key(col.GetType());
-	RowOperations::Gather(rows, sel, key, *FlatVector::IncrementalSelectionVector(), count, col_offset, col_no);
-
-	// Densify the input column
-	Vector sliced(col, sel, count);
-
-	if (NO_MATCH_SEL) {
-		SelectionVector no_match_sel_offset(no_match->data() + no_match_count);
-		auto match_count = SelectComparison<OP>(sliced, key, sel, count, &sel, &no_match_sel_offset);
-		no_match_count += count - match_count;
-		count = match_count;
-	} else {
-		count = SelectComparison<OP>(sliced, key, sel, count, &sel, nullptr);
-	}
-}
-
-template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchOp(Vector &vec, VectorData &col, const RowLayout &layout, Vector &rows, SelectionVector &sel,
-                             idx_t &count, idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
-	if (count == 0) {
-		return;
-	}
-	auto col_offset = layout.GetOffsets()[col_no];
-	switch (layout.GetTypes()[col_no].InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedMatchType<int8_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                             no_match_count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedMatchType<int16_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                              no_match_count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedMatchType<int32_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                              no_match_count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedMatchType<int64_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                              no_match_count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedMatchType<uint8_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                              no_match_count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedMatchType<uint16_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                               no_match_count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedMatchType<uint32_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                               no_match_count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedMatchType<uint64_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                               no_match_count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedMatchType<hugeint_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                                no_match_count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedMatchType<float, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                            no_match_count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedMatchType<double, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                             no_match_count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedMatchType<interval_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                                 no_match_count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedMatchType<string_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                               no_match_count);
-		break;
-	case PhysicalType::LIST:
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-		TemplatedMatchNested<OP, NO_MATCH_SEL>(vec, rows, sel, count, col_offset, col_no, no_match, no_match_count);
-		break;
-	default:
-		throw InternalException("Unsupported column type for RowOperations::Match");
-	}
-}
-
-template <bool NO_MATCH_SEL>
-static void TemplatedMatch(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
-                           const Predicates &predicates, SelectionVector &sel, idx_t &count, SelectionVector *no_match,
-                           idx_t &no_match_count) {
-	for (idx_t col_no = 0; col_no < predicates.size(); ++col_no) {
-		auto &vec = columns.data[col_no];
-		auto &col = col_data[col_no];
-		switch (predicates[col_no]) {
-		case ExpressionType::COMPARE_EQUAL:
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			TemplatedMatchOp<Equals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                       no_match_count);
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-			TemplatedMatchOp<NotEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                          no_match_count);
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			TemplatedMatchOp<GreaterThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                            no_match_count);
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			TemplatedMatchOp<GreaterThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                                  no_match_count);
-			break;
-		case ExpressionType::COMPARE_LESSTHAN:
-			TemplatedMatchOp<LessThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                         no_match_count);
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			TemplatedMatchOp<LessThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                               no_match_count);
-			break;
-		default:
-			throw InternalException("Unsupported comparison type for RowOperations::Match");
-		}
-	}
-}
-
-idx_t RowOperations::Match(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
-                           const Predicates &predicates, SelectionVector &sel, idx_t count, SelectionVector *no_match,
-                           idx_t &no_match_count) {
-	if (no_match) {
-		TemplatedMatch<true>(columns, col_data, layout, rows, predicates, sel, count, no_match, no_match_count);
-	} else {
-		TemplatedMatch<false>(columns, col_data, layout, rows, predicates, sel, count, no_match, no_match_count);
-	}
-
-	return count;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-void TemplatedRadixScatter(VectorData &vdata, const SelectionVector &sel, idx_t add_count, data_ptr_t *key_locations,
-                           const bool desc, const bool has_null, const bool nulls_first, const bool is_little_endian,
-                           const idx_t offset) {
-	auto source = (T *)vdata.data;
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write validity and according value
-			if (validity.RowIsValid(source_idx)) {
-				key_locations[i][0] = valid;
-				Radix::EncodeData<T>(key_locations[i] + 1, source[source_idx], is_little_endian);
-				// invert bits if desc
-				if (desc) {
-					for (idx_t s = 1; s < sizeof(T) + 1; s++) {
-						*(key_locations[i] + s) = ~*(key_locations[i] + s);
-					}
-				}
-			} else {
-				key_locations[i][0] = invalid;
-				memset(key_locations[i] + 1, '\0', sizeof(T));
-			}
-			key_locations[i] += sizeof(T) + 1;
-		}
-	} else {
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write value
-			Radix::EncodeData<T>(key_locations[i], source[source_idx], is_little_endian);
-			// invert bits if desc
-			if (desc) {
-				for (idx_t s = 0; s < sizeof(T); s++) {
-					*(key_locations[i] + s) = ~*(key_locations[i] + s);
-				}
-			}
-			key_locations[i] += sizeof(T);
-		}
-	}
-}
-
-void RadixScatterStringVector(VectorData &vdata, const SelectionVector &sel, idx_t add_count, data_ptr_t *key_locations,
-                              const bool desc, const bool has_null, const bool nulls_first, const idx_t prefix_len,
-                              idx_t offset) {
-	auto source = (string_t *)vdata.data;
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write validity and according value
-			if (validity.RowIsValid(source_idx)) {
-				key_locations[i][0] = valid;
-				Radix::EncodeStringDataPrefix(key_locations[i] + 1, source[source_idx], prefix_len);
-				// invert bits if desc
-				if (desc) {
-					for (idx_t s = 1; s < prefix_len + 1; s++) {
-						*(key_locations[i] + s) = ~*(key_locations[i] + s);
-					}
-				}
-			} else {
-				key_locations[i][0] = invalid;
-				memset(key_locations[i] + 1, '\0', prefix_len);
-			}
-			key_locations[i] += prefix_len + 1;
-		}
-	} else {
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write value
-			Radix::EncodeStringDataPrefix(key_locations[i], source[source_idx], prefix_len);
-			// invert bits if desc
-			if (desc) {
-				for (idx_t s = 0; s < prefix_len; s++) {
-					*(key_locations[i] + s) = ~*(key_locations[i] + s);
-				}
-			}
-			key_locations[i] += prefix_len;
-		}
-	}
-}
-
-void RadixScatterListVector(Vector &v, VectorData &vdata, const SelectionVector &sel, idx_t add_count,
-                            data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
-                            const idx_t prefix_len, const idx_t width, const idx_t offset) {
-	auto list_data = ListVector::GetData(v);
-	auto &child_vector = ListVector::GetEntry(v);
-	auto list_size = ListVector::GetListSize(v);
-
-	// serialize null values
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			data_ptr_t key_location = key_locations[i] + 1;
-			// write validity and according value
-			if (validity.RowIsValid(source_idx)) {
-				key_locations[i][0] = valid;
-				key_locations[i]++;
-				auto &list_entry = list_data[source_idx];
-				if (list_entry.length > 0) {
-					// denote that the list is not empty with a 1
-					key_locations[i][0] = 1;
-					key_locations[i]++;
-					RowOperations::RadixScatter(child_vector, list_size, *FlatVector::IncrementalSelectionVector(), 1,
-					                            key_locations + i, false, true, false, prefix_len, width - 1,
-					                            list_entry.offset);
-				} else {
-					// denote that the list is empty with a 0
-					key_locations[i][0] = 0;
-					key_locations[i]++;
-					memset(key_locations[i], '\0', width - 2);
-				}
-				// invert bits if desc
-				if (desc) {
-					for (idx_t s = 0; s < width - 1; s++) {
-						*(key_location + s) = ~*(key_location + s);
-					}
-				}
-			} else {
-				key_locations[i][0] = invalid;
-				memset(key_locations[i] + 1, '\0', width - 1);
-				key_locations[i] += width;
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			auto &list_entry = list_data[source_idx];
-			data_ptr_t key_location = key_locations[i];
-			if (list_entry.length > 0) {
-				// denote that the list is not empty with a 1
-				key_locations[i][0] = 1;
-				key_locations[i]++;
-				RowOperations::RadixScatter(child_vector, list_size, *FlatVector::IncrementalSelectionVector(), 1,
-				                            key_locations + i, false, true, false, prefix_len, width - 1,
-				                            list_entry.offset);
-			} else {
-				// denote that the list is empty with a 0
-				key_locations[i][0] = 0;
-				key_locations[i]++;
-				memset(key_locations[i], '\0', width - 1);
-			}
-			// invert bits if desc
-			if (desc) {
-				for (idx_t s = 0; s < width; s++) {
-					*(key_location + s) = ~*(key_location + s);
-				}
-			}
-		}
-	}
-}
-
-void RadixScatterStructVector(Vector &v, VectorData &vdata, idx_t vcount, const SelectionVector &sel, idx_t add_count,
-                              data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
-                              const idx_t prefix_len, idx_t width, const idx_t offset) {
-	// serialize null values
-	if (has_null) {
-		auto &validity = vdata.validity;
-		const data_t valid = nulls_first ? 1 : 0;
-		const data_t invalid = 1 - valid;
-
-		for (idx_t i = 0; i < add_count; i++) {
-			auto idx = sel.get_index(i);
-			auto source_idx = vdata.sel->get_index(idx) + offset;
-			// write validity and according value
-			if (validity.RowIsValid(source_idx)) {
-				key_locations[i][0] = valid;
-			} else {
-				key_locations[i][0] = invalid;
-			}
-			key_locations[i]++;
-		}
-		width--;
-	}
-	// serialize the struct
-	auto &child_vector = *StructVector::GetEntries(v)[0];
-	RowOperations::RadixScatter(child_vector, vcount, *FlatVector::IncrementalSelectionVector(), add_count,
-	                            key_locations, false, true, false, prefix_len, width, offset);
-	// invert bits if desc
-	if (desc) {
-		for (idx_t i = 0; i < add_count; i++) {
-			for (idx_t s = 0; s < width; s++) {
-				*(key_locations[i] - width + s) = ~*(key_locations[i] - width + s);
-			}
-		}
-	}
-}
-
-void RowOperations::RadixScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-                                 data_ptr_t *key_locations, bool desc, bool has_null, bool nulls_first,
-                                 idx_t prefix_len, idx_t width, idx_t offset) {
-	auto is_little_endian = Radix::IsLittleEndian();
-
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
-	switch (v.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedRadixScatter<int8_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                              is_little_endian, offset);
-		break;
-	case PhysicalType::INT16:
-		TemplatedRadixScatter<int16_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                               is_little_endian, offset);
-		break;
-	case PhysicalType::INT32:
-		TemplatedRadixScatter<int32_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                               is_little_endian, offset);
-		break;
-	case PhysicalType::INT64:
-		TemplatedRadixScatter<int64_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                               is_little_endian, offset);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedRadixScatter<uint8_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                               is_little_endian, offset);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedRadixScatter<uint16_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                                is_little_endian, offset);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedRadixScatter<uint32_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                                is_little_endian, offset);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedRadixScatter<uint64_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                                is_little_endian, offset);
-		break;
-	case PhysicalType::INT128:
-		TemplatedRadixScatter<hugeint_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                                 is_little_endian, offset);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedRadixScatter<float>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                             is_little_endian, offset);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedRadixScatter<double>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                              is_little_endian, offset);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedRadixScatter<interval_t>(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                                  is_little_endian, offset);
-		break;
-	case PhysicalType::VARCHAR:
-		RadixScatterStringVector(vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, prefix_len, offset);
-		break;
-	case PhysicalType::LIST:
-		RadixScatterListVector(v, vdata, sel, ser_count, key_locations, desc, has_null, nulls_first, prefix_len, width,
-		                       offset);
-		break;
-	case PhysicalType::STRUCT:
-		RadixScatterStructVector(v, vdata, vcount, sel, ser_count, key_locations, desc, has_null, nulls_first,
-		                         prefix_len, width, offset);
-		break;
-	default:
-		throw NotImplementedException("Cannot ORDER BY column with type %s", v.GetType().ToString());
-	}
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// row_scatter.cpp
-// Description: This file contains the implementation of the row scattering
-//              operators
-//===--------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-using ValidityBytes = RowLayout::ValidityBytes;
-
-template <class T>
-static void TemplatedScatter(VectorData &col, Vector &rows, const SelectionVector &sel, const idx_t count,
-                             const idx_t col_offset, const idx_t col_no) {
-	auto data = (T *)col.data;
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-
-	if (!col.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto col_idx = col.sel->get_index(idx);
-			auto row = ptrs[idx];
-
-			auto isnull = !col.validity.RowIsValid(col_idx);
-			T store_value = isnull ? NullValue<T>() : data[col_idx];
-			Store<T>(store_value, row + col_offset);
-			if (isnull) {
-				ValidityBytes col_mask(ptrs[idx]);
-				col_mask.SetInvalidUnsafe(col_no);
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto col_idx = col.sel->get_index(idx);
-			auto row = ptrs[idx];
-
-			Store<T>(data[col_idx], row + col_offset);
-		}
-	}
-}
-
-static void ComputeStringEntrySizes(const VectorData &col, idx_t entry_sizes[], const SelectionVector &sel,
-                                    const idx_t count, const idx_t offset = 0) {
-	auto data = (const string_t *)col.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto col_idx = col.sel->get_index(idx) + offset;
-		const auto &str = data[col_idx];
-		if (col.validity.RowIsValid(col_idx) && !str.IsInlined()) {
-			entry_sizes[i] += str.GetSize();
-		}
-	}
-}
-
-static void ScatterStringVector(VectorData &col, Vector &rows, data_ptr_t str_locations[], const SelectionVector &sel,
-                                const idx_t count, const idx_t col_offset, const idx_t col_no) {
-	auto string_data = (string_t *)col.data;
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto col_idx = col.sel->get_index(idx);
-		auto row = ptrs[idx];
-		if (!col.validity.RowIsValid(col_idx)) {
-			ValidityBytes col_mask(row);
-			col_mask.SetInvalidUnsafe(col_no);
-			Store<string_t>(NullValue<string_t>(), row + col_offset);
-		} else if (string_data[col_idx].IsInlined()) {
-			Store<string_t>(string_data[col_idx], row + col_offset);
-		} else {
-			const auto &str = string_data[col_idx];
-			string_t inserted((const char *)str_locations[i], str.GetSize());
-			memcpy(inserted.GetDataWriteable(), str.GetDataUnsafe(), str.GetSize());
-			str_locations[i] += str.GetSize();
-			inserted.Finalize();
-			Store<string_t>(inserted, row + col_offset);
-		}
-	}
-}
-
-static void ScatterNestedVector(Vector &vec, VectorData &col, Vector &rows, data_ptr_t data_locations[],
-                                const SelectionVector &sel, const idx_t count, const idx_t col_offset,
-                                const idx_t col_no, const idx_t vcount) {
-	// Store pointers to the data in the row
-	// Do this first because SerializeVector destroys the locations
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	data_ptr_t validitymask_locations[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto row = ptrs[idx];
-		validitymask_locations[i] = row;
-
-		Store<data_ptr_t>(data_locations[i], row + col_offset);
-	}
-
-	// Serialise the data
-	RowOperations::HeapScatter(vec, vcount, sel, count, col_no, data_locations, validitymask_locations);
-}
-
-void RowOperations::Scatter(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
-                            RowDataCollection &string_heap, const SelectionVector &sel, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-
-	// Set the validity mask for each row before inserting data
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	for (idx_t i = 0; i < count; ++i) {
-		auto row_idx = sel.get_index(i);
-		auto row = ptrs[row_idx];
-		ValidityBytes(row).SetAllValid(layout.ColumnCount());
-	}
-
-	const auto vcount = columns.size();
-	auto &offsets = layout.GetOffsets();
-	auto &types = layout.GetTypes();
-
-	// Compute the entry size of the variable size columns
-	vector<BufferHandle> handles;
-	data_ptr_t data_locations[STANDARD_VECTOR_SIZE];
-	if (!layout.AllConstant()) {
-		idx_t entry_sizes[STANDARD_VECTOR_SIZE];
-		std::fill_n(entry_sizes, count, sizeof(uint32_t));
-		for (idx_t col_no = 0; col_no < types.size(); col_no++) {
-			if (TypeIsConstantSize(types[col_no].InternalType())) {
-				continue;
-			}
-
-			auto &vec = columns.data[col_no];
-			auto &col = col_data[col_no];
-			switch (types[col_no].InternalType()) {
-			case PhysicalType::VARCHAR:
-				ComputeStringEntrySizes(col, entry_sizes, sel, count);
-				break;
-			case PhysicalType::LIST:
-			case PhysicalType::MAP:
-			case PhysicalType::STRUCT:
-				RowOperations::ComputeEntrySizes(vec, col, entry_sizes, vcount, count, sel);
-				break;
-			default:
-				throw InternalException("Unsupported type for RowOperations::Scatter");
-			}
-		}
-
-		// Build out the buffer space
-		string_heap.Build(count, data_locations, entry_sizes);
-
-		// Serialize information that is needed for swizzling if the computation goes out-of-core
-		const idx_t heap_pointer_offset = layout.GetHeapPointerOffset();
-		for (idx_t i = 0; i < count; i++) {
-			auto row_idx = sel.get_index(i);
-			auto row = ptrs[row_idx];
-			// Pointer to this row in the heap block
-			Store<data_ptr_t>(data_locations[i], row + heap_pointer_offset);
-			// Row size is stored in the heap in front of each row
-			Store<uint32_t>(entry_sizes[i], data_locations[i]);
-			data_locations[i] += sizeof(uint32_t);
-		}
-	}
-
-	for (idx_t col_no = 0; col_no < types.size(); col_no++) {
-		auto &vec = columns.data[col_no];
-		auto &col = col_data[col_no];
-		auto col_offset = offsets[col_no];
-
-		switch (types[col_no].InternalType()) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-			TemplatedScatter<int8_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::INT16:
-			TemplatedScatter<int16_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::INT32:
-			TemplatedScatter<int32_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::INT64:
-			TemplatedScatter<int64_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::UINT8:
-			TemplatedScatter<uint8_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::UINT16:
-			TemplatedScatter<uint16_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::UINT32:
-			TemplatedScatter<uint32_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::UINT64:
-			TemplatedScatter<uint64_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::INT128:
-			TemplatedScatter<hugeint_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::FLOAT:
-			TemplatedScatter<float>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::DOUBLE:
-			TemplatedScatter<double>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::INTERVAL:
-			TemplatedScatter<interval_t>(col, rows, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::VARCHAR:
-			ScatterStringVector(col, rows, data_locations, sel, count, col_offset, col_no);
-			break;
-		case PhysicalType::LIST:
-		case PhysicalType::MAP:
-		case PhysicalType::STRUCT:
-			ScatterNestedVector(vec, col, rows, data_locations, sel, count, col_offset, col_no, vcount);
-			break;
-		default:
-			throw InternalException("Unsupported type for RowOperations::Scatter");
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-#include <cstring>
-
-namespace duckdb {
-
-BufferedDeserializer::BufferedDeserializer(data_ptr_t ptr, idx_t data_size) : ptr(ptr), endptr(ptr + data_size) {
-}
-
-BufferedDeserializer::BufferedDeserializer(BufferedSerializer &serializer)
-    : BufferedDeserializer(serializer.data, serializer.maximum_size) {
-}
-
-void BufferedDeserializer::ReadData(data_ptr_t buffer, idx_t read_size) {
-	if (ptr + read_size > endptr) {
-		throw SerializationException("Failed to deserialize: not enough data in buffer to fulfill read request");
-	}
-	memcpy(buffer, ptr, read_size);
-	ptr += read_size;
-}
-
-} // namespace duckdb
-
-
-
-
-#include <cstring>
-#include <algorithm>
-
-namespace duckdb {
-
-BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, FileOpener *opener)
-    : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), total_read(0) {
-	handle =
-	    fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, FileLockType::READ_LOCK, FileSystem::DEFAULT_COMPRESSION, opener);
-	file_size = fs.GetFileSize(*handle);
-}
-
-void BufferedFileReader::ReadData(data_ptr_t target_buffer, uint64_t read_size) {
-	// first copy anything we can from the buffer
-	data_ptr_t end_ptr = target_buffer + read_size;
-	while (true) {
-		idx_t to_read = MinValue<idx_t>(end_ptr - target_buffer, read_data - offset);
-		if (to_read > 0) {
-			memcpy(target_buffer, data.get() + offset, to_read);
-			offset += to_read;
-			target_buffer += to_read;
-		}
-		if (target_buffer < end_ptr) {
-			D_ASSERT(offset == read_data);
-			total_read += read_data;
-			// did not finish reading yet but exhausted buffer
-			// read data into buffer
-			offset = 0;
-			read_data = fs.Read(*handle, data.get(), FILE_BUFFER_SIZE);
-			if (read_data == 0) {
-				throw SerializationException("not enough data in file to deserialize result");
-			}
-		} else {
-			return;
-		}
-	}
-}
-
-bool BufferedFileReader::Finished() {
-	return total_read + offset == file_size;
-}
-
-} // namespace duckdb
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-// Remove this when we switch C++17: https://stackoverflow.com/a/53350948
-constexpr uint8_t BufferedFileWriter::DEFAULT_OPEN_FLAGS;
-
-BufferedFileWriter::BufferedFileWriter(FileSystem &fs, const string &path_p, uint8_t open_flags, FileOpener *opener)
-    : fs(fs), path(path_p), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), total_written(0) {
-	handle = fs.OpenFile(path, open_flags, FileLockType::WRITE_LOCK, FileSystem::DEFAULT_COMPRESSION, opener);
-}
-
-int64_t BufferedFileWriter::GetFileSize() {
-	return fs.GetFileSize(*handle);
-}
-
-idx_t BufferedFileWriter::GetTotalWritten() {
-	return total_written + offset;
-}
-
-void BufferedFileWriter::WriteData(const_data_ptr_t buffer, uint64_t write_size) {
-	// first copy anything we can from the buffer
-	const_data_ptr_t end_ptr = buffer + write_size;
-	while (buffer < end_ptr) {
-		idx_t to_write = MinValue<idx_t>((end_ptr - buffer), FILE_BUFFER_SIZE - offset);
-		D_ASSERT(to_write > 0);
-		memcpy(data.get() + offset, buffer, to_write);
-		offset += to_write;
-		buffer += to_write;
-		if (offset == FILE_BUFFER_SIZE) {
-			Flush();
-		}
-	}
-}
-
-void BufferedFileWriter::Flush() {
-	if (offset == 0) {
-		return;
-	}
-	fs.Write(*handle, data.get(), offset);
-	total_written += offset;
-	offset = 0;
-}
-
-void BufferedFileWriter::Sync() {
-	Flush();
-	handle->Sync();
-}
-
-void BufferedFileWriter::Truncate(int64_t size) {
-	// truncate the physical file on disk
-	handle->Truncate(size);
-	// reset anything written in the buffer
-	offset = 0;
-}
-
-} // namespace duckdb
-
-
-#include <cstring>
-
-namespace duckdb {
-
-BufferedSerializer::BufferedSerializer(idx_t maximum_size)
-    : BufferedSerializer(unique_ptr<data_t[]>(new data_t[maximum_size]), maximum_size) {
-}
-
-BufferedSerializer::BufferedSerializer(unique_ptr<data_t[]> data, idx_t size) : maximum_size(size), data(data.get()) {
-	blob.size = 0;
-	blob.data = move(data);
-}
-
-BufferedSerializer::BufferedSerializer(data_ptr_t data, idx_t size) : maximum_size(size), data(data) {
-	blob.size = 0;
-}
-
-void BufferedSerializer::WriteData(const_data_ptr_t buffer, idx_t write_size) {
-	if (blob.size + write_size >= maximum_size) {
-		do {
-			maximum_size *= 2;
-		} while (blob.size + write_size > maximum_size);
-		auto new_data = new data_t[maximum_size];
-		memcpy(new_data, data, blob.size);
-		data = new_data;
-		blob.data = unique_ptr<data_t[]>(new_data);
-	}
-
-	memcpy(data + blob.size, buffer, write_size);
-	blob.size += write_size;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-template <>
-string Deserializer::Read() {
-	uint32_t size = Read<uint32_t>();
-	if (size == 0) {
-		return string();
-	}
-	auto buffer = unique_ptr<data_t[]>(new data_t[size]);
-	ReadData(buffer.get(), size);
-	return string((char *)buffer.get(), size);
-}
-
-void Deserializer::ReadStringVector(vector<string> &list) {
-	uint32_t sz = Read<uint32_t>();
-	list.resize(sz);
-	for (idx_t i = 0; i < sz; i++) {
-		list[i] = Read<string>();
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-bool Comparators::TieIsBreakable(const idx_t &col_idx, const data_ptr_t row_ptr, const RowLayout &row_layout) {
-	// Check if the blob is NULL
-	ValidityBytes row_mask(row_ptr);
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-	if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
-		// Can't break a NULL tie
-		return false;
-	}
-	if (row_layout.GetTypes()[col_idx].InternalType() == PhysicalType::VARCHAR) {
-		const auto &tie_col_offset = row_layout.GetOffsets()[col_idx];
-		string_t tie_string = Load<string_t>(row_ptr + tie_col_offset);
-		if (tie_string.GetSize() < string_t::INLINE_LENGTH) {
-			// No need to break the tie - we already compared the full string
-			return false;
-		}
-	}
-	return true;
-}
-
-int Comparators::CompareTuple(const SBScanState &left, const SBScanState &right, const data_ptr_t &l_ptr,
-                              const data_ptr_t &r_ptr, const SortLayout &sort_layout, const bool &external_sort) {
-	// Compare the sorting columns one by one
-	int comp_res = 0;
-	data_ptr_t l_ptr_offset = l_ptr;
-	data_ptr_t r_ptr_offset = r_ptr;
-	for (idx_t col_idx = 0; col_idx < sort_layout.column_count; col_idx++) {
-		comp_res = FastMemcmp(l_ptr_offset, r_ptr_offset, sort_layout.column_sizes[col_idx]);
-		if (comp_res == 0 && !sort_layout.constant_size[col_idx]) {
-			comp_res = BreakBlobTie(col_idx, left, right, sort_layout, external_sort);
-		}
-		if (comp_res != 0) {
-			break;
-		}
-		l_ptr_offset += sort_layout.column_sizes[col_idx];
-		r_ptr_offset += sort_layout.column_sizes[col_idx];
-	}
-	return comp_res;
-}
-
-int Comparators::CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::VARCHAR:
-		return TemplatedCompareVal<string_t>(l_ptr, r_ptr);
-	case PhysicalType::LIST:
-	case PhysicalType::STRUCT: {
-		auto l_nested_ptr = Load<data_ptr_t>(l_ptr);
-		auto r_nested_ptr = Load<data_ptr_t>(r_ptr);
-		return CompareValAndAdvance(l_nested_ptr, r_nested_ptr, type);
-	}
-	default:
-		throw NotImplementedException("Unimplemented CompareVal for type %s", type.ToString());
-	}
-}
-
-int Comparators::BreakBlobTie(const idx_t &tie_col, const SBScanState &left, const SBScanState &right,
-                              const SortLayout &sort_layout, const bool &external) {
-	const idx_t &col_idx = sort_layout.sorting_to_blob_col.at(tie_col);
-	data_ptr_t l_data_ptr = left.DataPtr(*left.sb->blob_sorting_data);
-	data_ptr_t r_data_ptr = right.DataPtr(*right.sb->blob_sorting_data);
-	if (!TieIsBreakable(col_idx, l_data_ptr, sort_layout.blob_layout)) {
-		// Quick check to see if ties can be broken
-		return 0;
-	}
-	// Align the pointers
-	const auto &tie_col_offset = sort_layout.blob_layout.GetOffsets()[col_idx];
-	l_data_ptr += tie_col_offset;
-	r_data_ptr += tie_col_offset;
-	// Do the comparison
-	const int order = sort_layout.order_types[tie_col] == OrderType::DESCENDING ? -1 : 1;
-	const auto &type = sort_layout.blob_layout.GetTypes()[col_idx];
-	int result;
-	if (external) {
-		// Store heap pointers
-		data_ptr_t l_heap_ptr = left.HeapPtr(*left.sb->blob_sorting_data);
-		data_ptr_t r_heap_ptr = right.HeapPtr(*right.sb->blob_sorting_data);
-		// Unswizzle offset to pointer
-		UnswizzleSingleValue(l_data_ptr, l_heap_ptr, type);
-		UnswizzleSingleValue(r_data_ptr, r_heap_ptr, type);
-		// Compare
-		result = CompareVal(l_data_ptr, r_data_ptr, type);
-		// Swizzle the pointers back to offsets
-		SwizzleSingleValue(l_data_ptr, l_heap_ptr, type);
-		SwizzleSingleValue(r_data_ptr, r_heap_ptr, type);
-	} else {
-		result = CompareVal(l_data_ptr, r_data_ptr, type);
-	}
-	return order * result;
-}
-
-template <class T>
-int Comparators::TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_t &right_ptr) {
-	const auto left_val = Load<T>(left_ptr);
-	const auto right_val = Load<T>(right_ptr);
-	if (Equals::Operation<T>(left_val, right_val)) {
-		return 0;
-	} else if (LessThan::Operation<T>(left_val, right_val)) {
-		return -1;
-	} else {
-		return 1;
-	}
-}
-
-int Comparators::CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedCompareAndAdvance<int8_t>(l_ptr, r_ptr);
-	case PhysicalType::INT16:
-		return TemplatedCompareAndAdvance<int16_t>(l_ptr, r_ptr);
-	case PhysicalType::INT32:
-		return TemplatedCompareAndAdvance<int32_t>(l_ptr, r_ptr);
-	case PhysicalType::INT64:
-		return TemplatedCompareAndAdvance<int64_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT8:
-		return TemplatedCompareAndAdvance<uint8_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT16:
-		return TemplatedCompareAndAdvance<uint16_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT32:
-		return TemplatedCompareAndAdvance<uint32_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT64:
-		return TemplatedCompareAndAdvance<uint64_t>(l_ptr, r_ptr);
-	case PhysicalType::INT128:
-		return TemplatedCompareAndAdvance<hugeint_t>(l_ptr, r_ptr);
-	case PhysicalType::FLOAT:
-		return TemplatedCompareAndAdvance<float>(l_ptr, r_ptr);
-	case PhysicalType::DOUBLE:
-		return TemplatedCompareAndAdvance<double>(l_ptr, r_ptr);
-	case PhysicalType::INTERVAL:
-		return TemplatedCompareAndAdvance<interval_t>(l_ptr, r_ptr);
-	case PhysicalType::VARCHAR:
-		return CompareStringAndAdvance(l_ptr, r_ptr);
-	case PhysicalType::LIST:
-		return CompareListAndAdvance(l_ptr, r_ptr, ListType::GetChildType(type));
-	case PhysicalType::STRUCT:
-		return CompareStructAndAdvance(l_ptr, r_ptr, StructType::GetChildTypes(type));
-	default:
-		throw NotImplementedException("Unimplemented CompareValAndAdvance for type %s", type.ToString());
-	}
-}
-
-template <class T>
-int Comparators::TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr) {
-	auto result = TemplatedCompareVal<T>(left_ptr, right_ptr);
-	left_ptr += sizeof(T);
-	right_ptr += sizeof(T);
-	return result;
-}
-
-int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr) {
-	// Construct the string_t
-	uint32_t left_string_size = Load<uint32_t>(left_ptr);
-	uint32_t right_string_size = Load<uint32_t>(right_ptr);
-	left_ptr += sizeof(uint32_t);
-	right_ptr += sizeof(uint32_t);
-	string_t left_val((const char *)left_ptr, left_string_size);
-	string_t right_val((const char *)right_ptr, right_string_size);
-	left_ptr += left_string_size;
-	right_ptr += right_string_size;
-	// Compare
-	return TemplatedCompareVal<string_t>((data_ptr_t)&left_val, (data_ptr_t)&right_val);
-}
-
-int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-                                         const child_list_t<LogicalType> &types) {
-	idx_t count = types.size();
-	// Load validity masks
-	ValidityBytes left_validity(left_ptr);
-	ValidityBytes right_validity(right_ptr);
-	left_ptr += (count + 7) / 8;
-	right_ptr += (count + 7) / 8;
-	// Initialize variables
-	bool left_valid;
-	bool right_valid;
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	// Compare
-	int comp_res = 0;
-	for (idx_t i = 0; i < count; i++) {
-		ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		auto &type = types[i].second;
-		if ((left_valid && right_valid) || TypeIsConstantSize(type.InternalType())) {
-			comp_res = CompareValAndAdvance(left_ptr, right_ptr, types[i].second);
-		}
-		if (!left_valid && !right_valid) {
-			comp_res = 0;
-		} else if (!left_valid) {
-			comp_res = 1;
-		} else if (!right_valid) {
-			comp_res = -1;
-		}
-		if (comp_res != 0) {
-			break;
-		}
-	}
-	return comp_res;
-}
-
-int Comparators::CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type) {
-	// Load list lengths
-	auto left_len = Load<idx_t>(left_ptr);
-	auto right_len = Load<idx_t>(right_ptr);
-	left_ptr += sizeof(idx_t);
-	right_ptr += sizeof(idx_t);
-	// Load list validity masks
-	ValidityBytes left_validity(left_ptr);
-	ValidityBytes right_validity(right_ptr);
-	left_ptr += (left_len + 7) / 8;
-	right_ptr += (right_len + 7) / 8;
-	// Compare
-	int comp_res = 0;
-	idx_t count = MinValue(left_len, right_len);
-	if (TypeIsConstantSize(type.InternalType())) {
-		// Templated code for fixed-size types
-		switch (type.InternalType()) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-			comp_res = TemplatedCompareListLoop<int8_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT16:
-			comp_res = TemplatedCompareListLoop<int16_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT32:
-			comp_res = TemplatedCompareListLoop<int32_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT64:
-			comp_res = TemplatedCompareListLoop<int64_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT8:
-			comp_res = TemplatedCompareListLoop<uint8_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT16:
-			comp_res = TemplatedCompareListLoop<uint16_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT32:
-			comp_res = TemplatedCompareListLoop<uint32_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT64:
-			comp_res = TemplatedCompareListLoop<uint64_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT128:
-			comp_res = TemplatedCompareListLoop<hugeint_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::FLOAT:
-			comp_res = TemplatedCompareListLoop<float>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::DOUBLE:
-			comp_res = TemplatedCompareListLoop<double>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INTERVAL:
-			comp_res = TemplatedCompareListLoop<interval_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		default:
-			throw NotImplementedException("CompareListAndAdvance for fixed-size type %s", type.ToString());
-		}
-	} else {
-		// Variable-sized list entries
-		bool left_valid;
-		bool right_valid;
-		idx_t entry_idx;
-		idx_t idx_in_entry;
-		// Size (in bytes) of all variable-sizes entries is stored before the entries begin,
-		// to make deserialization easier. We need to skip over them
-		left_ptr += left_len * sizeof(idx_t);
-		right_ptr += right_len * sizeof(idx_t);
-		for (idx_t i = 0; i < count; i++) {
-			ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-			left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-			right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-			if (left_valid && right_valid) {
-				switch (type.InternalType()) {
-				case PhysicalType::LIST:
-					comp_res = CompareListAndAdvance(left_ptr, right_ptr, ListType::GetChildType(type));
-					break;
-				case PhysicalType::VARCHAR:
-					comp_res = CompareStringAndAdvance(left_ptr, right_ptr);
-					break;
-				case PhysicalType::STRUCT:
-					comp_res = CompareStructAndAdvance(left_ptr, right_ptr, StructType::GetChildTypes(type));
-					break;
-				default:
-					throw NotImplementedException("CompareListAndAdvance for variable-size type %s", type.ToString());
-				}
-			} else if (!left_valid && !right_valid) {
-				comp_res = 0;
-			} else if (left_valid) {
-				comp_res = -1;
-			} else {
-				comp_res = 1;
-			}
-			if (comp_res != 0) {
-				break;
-			}
-		}
-	}
-	// All values that we looped over were equal
-	if (comp_res == 0 && left_len != right_len) {
-		// Smaller lists first
-		if (left_len < right_len) {
-			comp_res = -1;
-		} else {
-			comp_res = 1;
-		}
-	}
-	return comp_res;
-}
-
-template <class T>
-int Comparators::TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-                                          const ValidityBytes &left_validity, const ValidityBytes &right_validity,
-                                          const idx_t &count) {
-	int comp_res = 0;
-	bool left_valid;
-	bool right_valid;
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	for (idx_t i = 0; i < count; i++) {
-		ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		comp_res = TemplatedCompareAndAdvance<T>(left_ptr, right_ptr);
-		if (!left_valid && !right_valid) {
-			comp_res = 0;
-		} else if (!left_valid) {
-			comp_res = 1;
-		} else if (!right_valid) {
-			comp_res = -1;
-		}
-		if (comp_res != 0) {
-			break;
-		}
-	}
-	return comp_res;
-}
-
-void Comparators::UnswizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::VARCHAR) {
-		data_ptr += sizeof(uint32_t) + string_t::PREFIX_LENGTH;
-	}
-	Store<data_ptr_t>(heap_ptr + Load<idx_t>(data_ptr), data_ptr);
-}
-
-void Comparators::SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::VARCHAR) {
-		data_ptr += sizeof(uint32_t) + string_t::PREFIX_LENGTH;
-	}
-	Store<idx_t>(Load<data_ptr_t>(data_ptr) - heap_ptr, data_ptr);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-MergeSorter::MergeSorter(GlobalSortState &state, BufferManager &buffer_manager)
-    : state(state), buffer_manager(buffer_manager), sort_layout(state.sort_layout) {
-}
-
-void MergeSorter::PerformInMergeRound() {
-	while (true) {
-		{
-			lock_guard<mutex> pair_guard(state.lock);
-			if (state.pair_idx == state.num_pairs) {
-				break;
-			}
-			GetNextPartition();
-		}
-		MergePartition();
-	}
-}
-
-void MergeSorter::MergePartition() {
-	auto &left_block = *left->sb;
-	auto &right_block = *right->sb;
-#ifdef DEBUG
-	D_ASSERT(left_block.radix_sorting_data.size() == left_block.payload_data->data_blocks.size());
-	D_ASSERT(right_block.radix_sorting_data.size() == right_block.payload_data->data_blocks.size());
-	if (!state.payload_layout.AllConstant() && state.external) {
-		D_ASSERT(left_block.payload_data->data_blocks.size() == left_block.payload_data->heap_blocks.size());
-		D_ASSERT(right_block.payload_data->data_blocks.size() == right_block.payload_data->heap_blocks.size());
-	}
-	if (!sort_layout.all_constant) {
-		D_ASSERT(left_block.radix_sorting_data.size() == left_block.blob_sorting_data->data_blocks.size());
-		D_ASSERT(right_block.radix_sorting_data.size() == right_block.blob_sorting_data->data_blocks.size());
-		if (state.external) {
-			D_ASSERT(left_block.blob_sorting_data->data_blocks.size() ==
-			         left_block.blob_sorting_data->heap_blocks.size());
-			D_ASSERT(right_block.blob_sorting_data->data_blocks.size() ==
-			         right_block.blob_sorting_data->heap_blocks.size());
-		}
-	}
-#endif
-	// Set up the write block
-	// Each merge task produces a SortedBlock with exactly state.block_capacity rows or less
-	result->InitializeWrite();
-	// Initialize arrays to store merge data
-	bool left_smaller[STANDARD_VECTOR_SIZE];
-	idx_t next_entry_sizes[STANDARD_VECTOR_SIZE];
-	// Merge loop
-#ifdef DEBUG
-	auto l_count = left->Remaining();
-	auto r_count = right->Remaining();
-#endif
-	while (true) {
-		auto l_remaining = left->Remaining();
-		auto r_remaining = right->Remaining();
-		if (l_remaining + r_remaining == 0) {
-			// Done
-			break;
-		}
-		const idx_t next = MinValue(l_remaining + r_remaining, (idx_t)STANDARD_VECTOR_SIZE);
-		if (l_remaining != 0 && r_remaining != 0) {
-			// Compute the merge (not needed if one side is exhausted)
-			ComputeMerge(next, left_smaller);
-		}
-		// Actually merge the data (radix, blob, and payload)
-		MergeRadix(next, left_smaller);
-		if (!sort_layout.all_constant) {
-			MergeData(*result->blob_sorting_data, *left_block.blob_sorting_data, *right_block.blob_sorting_data, next,
-			          left_smaller, next_entry_sizes, true);
-			D_ASSERT(result->radix_sorting_data.size() == result->blob_sorting_data->data_blocks.size());
-		}
-		MergeData(*result->payload_data, *left_block.payload_data, *right_block.payload_data, next, left_smaller,
-		          next_entry_sizes, false);
-		D_ASSERT(result->radix_sorting_data.size() == result->payload_data->data_blocks.size());
-	}
-#ifdef DEBUG
-	D_ASSERT(result->Count() == l_count + r_count);
-#endif
-}
-
-void MergeSorter::GetNextPartition() {
-	// Create result block
-	state.sorted_blocks_temp[state.pair_idx].push_back(make_unique<SortedBlock>(buffer_manager, state));
-	result = state.sorted_blocks_temp[state.pair_idx].back().get();
-	// Determine which blocks must be merged
-	auto &left_block = *state.sorted_blocks[state.pair_idx * 2];
-	auto &right_block = *state.sorted_blocks[state.pair_idx * 2 + 1];
-	const idx_t l_count = left_block.Count();
-	const idx_t r_count = right_block.Count();
-	// Initialize left and right reader
-	left = make_unique<SBScanState>(buffer_manager, state);
-	right = make_unique<SBScanState>(buffer_manager, state);
-	// Compute the work that this thread must do using Merge Path
-	idx_t l_end;
-	idx_t r_end;
-	if (state.l_start + state.r_start + state.block_capacity < l_count + r_count) {
-		left->sb = state.sorted_blocks[state.pair_idx * 2].get();
-		right->sb = state.sorted_blocks[state.pair_idx * 2 + 1].get();
-		const idx_t intersection = state.l_start + state.r_start + state.block_capacity;
-		GetIntersection(intersection, l_end, r_end);
-		D_ASSERT(l_end <= l_count);
-		D_ASSERT(r_end <= r_count);
-		D_ASSERT(intersection == l_end + r_end);
-	} else {
-		l_end = l_count;
-		r_end = r_count;
-	}
-	// Create slices of the data that this thread must merge
-	left->SetIndices(0, 0);
-	right->SetIndices(0, 0);
-	left_input = left_block.CreateSlice(state.l_start, l_end, left->entry_idx);
-	right_input = right_block.CreateSlice(state.r_start, r_end, right->entry_idx);
-	left->sb = left_input.get();
-	right->sb = right_input.get();
-	state.l_start = l_end;
-	state.r_start = r_end;
-	D_ASSERT(left->Remaining() + right->Remaining() == state.block_capacity || (l_end == l_count && r_end == r_count));
-	// Update global state
-	if (state.l_start == l_count && state.r_start == r_count) {
-		// Delete references to previous pair
-		state.sorted_blocks[state.pair_idx * 2] = nullptr;
-		state.sorted_blocks[state.pair_idx * 2 + 1] = nullptr;
-		// Advance pair
-		state.pair_idx++;
-		state.l_start = 0;
-		state.r_start = 0;
-	}
-}
-
-int MergeSorter::CompareUsingGlobalIndex(SBScanState &l, SBScanState &r, const idx_t l_idx, const idx_t r_idx) {
-	D_ASSERT(l_idx < l.sb->Count());
-	D_ASSERT(r_idx < r.sb->Count());
-
-	// Easy comparison using the previous result (intersections must increase monotonically)
-	if (l_idx < state.l_start) {
-		return -1;
-	}
-	if (r_idx < state.r_start) {
-		return 1;
-	}
-
-	l.sb->GlobalToLocalIndex(l_idx, l.block_idx, l.entry_idx);
-	r.sb->GlobalToLocalIndex(r_idx, r.block_idx, r.entry_idx);
-
-	l.PinRadix(l.block_idx);
-	r.PinRadix(r.block_idx);
-	data_ptr_t l_ptr = l.radix_handle.Ptr() + l.entry_idx * sort_layout.entry_size;
-	data_ptr_t r_ptr = r.radix_handle.Ptr() + r.entry_idx * sort_layout.entry_size;
-
-	int comp_res;
-	if (sort_layout.all_constant) {
-		comp_res = FastMemcmp(l_ptr, r_ptr, sort_layout.comparison_size);
-	} else {
-		l.PinData(*l.sb->blob_sorting_data);
-		r.PinData(*r.sb->blob_sorting_data);
-		comp_res = Comparators::CompareTuple(l, r, l_ptr, r_ptr, sort_layout, state.external);
-	}
-	return comp_res;
-}
-
-void MergeSorter::GetIntersection(const idx_t diagonal, idx_t &l_idx, idx_t &r_idx) {
-	const idx_t l_count = left->sb->Count();
-	const idx_t r_count = right->sb->Count();
-	// Cover some edge cases
-	// Code coverage off because these edge cases cannot happen unless other code changes
-	// Edge cases have been tested extensively while developing Merge Path in a script
-	// LCOV_EXCL_START
-	if (diagonal >= l_count + r_count) {
-		l_idx = l_count;
-		r_idx = r_count;
-		return;
-	} else if (diagonal == 0) {
-		l_idx = 0;
-		r_idx = 0;
-		return;
-	} else if (l_count == 0) {
-		l_idx = 0;
-		r_idx = diagonal;
-		return;
-	} else if (r_count == 0) {
-		r_idx = 0;
-		l_idx = diagonal;
-		return;
-	}
-	// LCOV_EXCL_STOP
-	// Determine offsets for the binary search
-	const idx_t l_offset = MinValue(l_count, diagonal);
-	const idx_t r_offset = diagonal > l_count ? diagonal - l_count : 0;
-	D_ASSERT(l_offset + r_offset == diagonal);
-	const idx_t search_space = diagonal > MaxValue(l_count, r_count) ? l_count + r_count - diagonal
-	                                                                 : MinValue(diagonal, MinValue(l_count, r_count));
-	// Double binary search
-	idx_t li = 0;
-	idx_t ri = search_space - 1;
-	idx_t middle;
-	int comp_res;
-	while (li <= ri) {
-		middle = (li + ri) / 2;
-		l_idx = l_offset - middle;
-		r_idx = r_offset + middle;
-		if (l_idx == l_count || r_idx == 0) {
-			comp_res = CompareUsingGlobalIndex(*left, *right, l_idx - 1, r_idx);
-			if (comp_res > 0) {
-				l_idx--;
-				r_idx++;
-			} else {
-				return;
-			}
-			if (l_idx == 0 || r_idx == r_count) {
-				// This case is incredibly difficult to cover as it is dependent on parallelism randomness
-				// But it has been tested extensively during development in a script
-				// LCOV_EXCL_START
-				return;
-				// LCOV_EXCL_STOP
-			} else {
-				break;
-			}
-		}
-		comp_res = CompareUsingGlobalIndex(*left, *right, l_idx, r_idx);
-		if (comp_res > 0) {
-			li = middle + 1;
-		} else {
-			ri = middle - 1;
-		}
-	}
-	int l_r_min1 = CompareUsingGlobalIndex(*left, *right, l_idx, r_idx - 1);
-	int l_min1_r = CompareUsingGlobalIndex(*left, *right, l_idx - 1, r_idx);
-	if (l_r_min1 > 0 && l_min1_r < 0) {
-		return;
-	} else if (l_r_min1 > 0) {
-		l_idx--;
-		r_idx++;
-	} else if (l_min1_r < 0) {
-		l_idx++;
-		r_idx--;
-	}
-}
-
-void MergeSorter::ComputeMerge(const idx_t &count, bool left_smaller[]) {
-	auto &l = *left;
-	auto &r = *right;
-	auto &l_sorted_block = *l.sb;
-	auto &r_sorted_block = *r.sb;
-	// Save indices to restore afterwards
-	idx_t l_block_idx_before = l.block_idx;
-	idx_t l_entry_idx_before = l.entry_idx;
-	idx_t r_block_idx_before = r.block_idx;
-	idx_t r_entry_idx_before = r.entry_idx;
-	// Data pointers for both sides
-	data_ptr_t l_radix_ptr;
-	data_ptr_t r_radix_ptr;
-	// Compute the merge of the next 'count' tuples
-	idx_t compared = 0;
-	while (compared < count) {
-		// Move to the next block (if needed)
-		if (l.block_idx < l_sorted_block.radix_sorting_data.size() &&
-		    l.entry_idx == l_sorted_block.radix_sorting_data[l.block_idx].count) {
-			l.block_idx++;
-			l.entry_idx = 0;
-		}
-		if (r.block_idx < r_sorted_block.radix_sorting_data.size() &&
-		    r.entry_idx == r_sorted_block.radix_sorting_data[r.block_idx].count) {
-			r.block_idx++;
-			r.entry_idx = 0;
-		}
-		const bool l_done = l.block_idx == l_sorted_block.radix_sorting_data.size();
-		const bool r_done = r.block_idx == r_sorted_block.radix_sorting_data.size();
-		if (l_done || r_done) {
-			// One of the sides is exhausted, no need to compare
-			break;
-		}
-		// Pin the radix sorting data
-		if (!l_done) {
-			left->PinRadix(l.block_idx);
-			l_radix_ptr = left->RadixPtr();
-		}
-		if (!r_done) {
-			right->PinRadix(r.block_idx);
-			r_radix_ptr = right->RadixPtr();
-		}
-		const idx_t &l_count = !l_done ? l_sorted_block.radix_sorting_data[l.block_idx].count : 0;
-		const idx_t &r_count = !r_done ? r_sorted_block.radix_sorting_data[r.block_idx].count : 0;
-		// Compute the merge
-		if (sort_layout.all_constant) {
-			// All sorting columns are constant size
-			for (; compared < count && l.entry_idx < l_count && r.entry_idx < r_count; compared++) {
-				left_smaller[compared] = FastMemcmp(l_radix_ptr, r_radix_ptr, sort_layout.comparison_size) < 0;
-				const bool &l_smaller = left_smaller[compared];
-				const bool r_smaller = !l_smaller;
-				// Use comparison bool (0 or 1) to increment entries and pointers
-				l.entry_idx += l_smaller;
-				r.entry_idx += r_smaller;
-				l_radix_ptr += l_smaller * sort_layout.entry_size;
-				r_radix_ptr += r_smaller * sort_layout.entry_size;
-			}
-		} else {
-			// Pin the blob data
-			if (!l_done) {
-				left->PinData(*l_sorted_block.blob_sorting_data);
-			}
-			if (!r_done) {
-				right->PinData(*r_sorted_block.blob_sorting_data);
-			}
-			// Merge with variable size sorting columns
-			for (; compared < count && l.entry_idx < l_count && r.entry_idx < r_count; compared++) {
-				left_smaller[compared] =
-				    Comparators::CompareTuple(*left, *right, l_radix_ptr, r_radix_ptr, sort_layout, state.external) < 0;
-				const bool &l_smaller = left_smaller[compared];
-				const bool r_smaller = !l_smaller;
-				// Use comparison bool (0 or 1) to increment entries and pointers
-				l.entry_idx += l_smaller;
-				r.entry_idx += r_smaller;
-				l_radix_ptr += l_smaller * sort_layout.entry_size;
-				r_radix_ptr += r_smaller * sort_layout.entry_size;
-			}
-		}
-	}
-	// Reset block indices
-	left->SetIndices(l_block_idx_before, l_entry_idx_before);
-	right->SetIndices(r_block_idx_before, r_entry_idx_before);
-}
-
-void MergeSorter::MergeRadix(const idx_t &count, const bool left_smaller[]) {
-	auto &l = *left;
-	auto &r = *right;
-	// Save indices to restore afterwards
-	idx_t l_block_idx_before = l.block_idx;
-	idx_t l_entry_idx_before = l.entry_idx;
-	idx_t r_block_idx_before = r.block_idx;
-	idx_t r_entry_idx_before = r.entry_idx;
-
-	auto &l_blocks = l.sb->radix_sorting_data;
-	auto &r_blocks = r.sb->radix_sorting_data;
-	RowDataBlock *l_block;
-	RowDataBlock *r_block;
-
-	data_ptr_t l_ptr;
-	data_ptr_t r_ptr;
-
-	RowDataBlock *result_block = &result->radix_sorting_data.back();
-	auto result_handle = buffer_manager.Pin(result_block->block);
-	data_ptr_t result_ptr = result_handle.Ptr() + result_block->count * sort_layout.entry_size;
-
-	idx_t copied = 0;
-	while (copied < count) {
-		// Move to the next block (if needed)
-		if (l.block_idx < l_blocks.size() && l.entry_idx == l_blocks[l.block_idx].count) {
-			// Delete reference to previous block
-			l_blocks[l.block_idx].block = nullptr;
-			// Advance block
-			l.block_idx++;
-			l.entry_idx = 0;
-		}
-		if (r.block_idx < r_blocks.size() && r.entry_idx == r_blocks[r.block_idx].count) {
-			// Delete reference to previous block
-			r_blocks[r.block_idx].block = nullptr;
-			// Advance block
-			r.block_idx++;
-			r.entry_idx = 0;
-		}
-		const bool l_done = l.block_idx == l_blocks.size();
-		const bool r_done = r.block_idx == r_blocks.size();
-		// Pin the radix sortable blocks
-		if (!l_done) {
-			l_block = &l_blocks[l.block_idx];
-			left->PinRadix(l.block_idx);
-			l_ptr = l.RadixPtr();
-		}
-		if (!r_done) {
-			r_block = &r_blocks[r.block_idx];
-			r.PinRadix(r.block_idx);
-			r_ptr = r.RadixPtr();
-		}
-		const idx_t &l_count = !l_done ? l_block->count : 0;
-		const idx_t &r_count = !r_done ? r_block->count : 0;
-		// Copy using computed merge
-		if (!l_done && !r_done) {
-			// Both sides have data - merge
-			MergeRows(l_ptr, l.entry_idx, l_count, r_ptr, r.entry_idx, r_count, result_block, result_ptr,
-			          sort_layout.entry_size, left_smaller, copied, count);
-		} else if (r_done) {
-			// Right side is exhausted
-			FlushRows(l_ptr, l.entry_idx, l_count, result_block, result_ptr, sort_layout.entry_size, copied, count);
-		} else {
-			// Left side is exhausted
-			FlushRows(r_ptr, r.entry_idx, r_count, result_block, result_ptr, sort_layout.entry_size, copied, count);
-		}
-	}
-	// Reset block indices
-	left->SetIndices(l_block_idx_before, l_entry_idx_before);
-	right->SetIndices(r_block_idx_before, r_entry_idx_before);
-}
-
-void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedData &r_data, const idx_t &count,
-                            const bool left_smaller[], idx_t next_entry_sizes[], bool reset_indices) {
-	auto &l = *left;
-	auto &r = *right;
-	// Save indices to restore afterwards
-	idx_t l_block_idx_before = l.block_idx;
-	idx_t l_entry_idx_before = l.entry_idx;
-	idx_t r_block_idx_before = r.block_idx;
-	idx_t r_entry_idx_before = r.entry_idx;
-
-	const auto &layout = result_data.layout;
-	const idx_t row_width = layout.GetRowWidth();
-	const idx_t heap_pointer_offset = layout.GetHeapPointerOffset();
-
-	// Left and right row data to merge
-	data_ptr_t l_ptr;
-	data_ptr_t r_ptr;
-	// Accompanying left and right heap data (if needed)
-	data_ptr_t l_heap_ptr;
-	data_ptr_t r_heap_ptr;
-
-	// Result rows to write to
-	RowDataBlock *result_data_block = &result_data.data_blocks.back();
-	auto result_data_handle = buffer_manager.Pin(result_data_block->block);
-	data_ptr_t result_data_ptr = result_data_handle.Ptr() + result_data_block->count * row_width;
-	// Result heap to write to (if needed)
-	RowDataBlock *result_heap_block;
-	BufferHandle result_heap_handle;
-	data_ptr_t result_heap_ptr;
-	if (!layout.AllConstant() && state.external) {
-		result_heap_block = &result_data.heap_blocks.back();
-		result_heap_handle = buffer_manager.Pin(result_heap_block->block);
-		result_heap_ptr = result_heap_handle.Ptr() + result_heap_block->byte_offset;
-	}
-
-	idx_t copied = 0;
-	while (copied < count) {
-		// Move to new data blocks (if needed)
-		if (l.block_idx < l_data.data_blocks.size() && l.entry_idx == l_data.data_blocks[l.block_idx].count) {
-			// Delete reference to previous block
-			l_data.data_blocks[l.block_idx].block = nullptr;
-			if (!layout.AllConstant() && state.external) {
-				l_data.heap_blocks[l.block_idx].block = nullptr;
-			}
-			// Advance block
-			l.block_idx++;
-			l.entry_idx = 0;
-		}
-		if (r.block_idx < r_data.data_blocks.size() && r.entry_idx == r_data.data_blocks[r.block_idx].count) {
-			// Delete reference to previous block
-			r_data.data_blocks[r.block_idx].block = nullptr;
-			if (!layout.AllConstant() && state.external) {
-				r_data.heap_blocks[r.block_idx].block = nullptr;
-			}
-			// Advance block
-			r.block_idx++;
-			r.entry_idx = 0;
-		}
-		const bool l_done = l.block_idx == l_data.data_blocks.size();
-		const bool r_done = r.block_idx == r_data.data_blocks.size();
-		// Pin the row data blocks
-		if (!l_done) {
-			l.PinData(l_data);
-			l_ptr = l.DataPtr(l_data);
-		}
-		if (!r_done) {
-			r.PinData(r_data);
-			r_ptr = r.DataPtr(r_data);
-		}
-		const idx_t &l_count = !l_done ? l_data.data_blocks[l.block_idx].count : 0;
-		const idx_t &r_count = !r_done ? r_data.data_blocks[r.block_idx].count : 0;
-		// Perform the merge
-		if (layout.AllConstant() || !state.external) {
-			// If all constant size, or if we are doing an in-memory sort, we do not need to touch the heap
-			if (!l_done && !r_done) {
-				// Both sides have data - merge
-				MergeRows(l_ptr, l.entry_idx, l_count, r_ptr, r.entry_idx, r_count, result_data_block, result_data_ptr,
-				          row_width, left_smaller, copied, count);
-			} else if (r_done) {
-				// Right side is exhausted
-				FlushRows(l_ptr, l.entry_idx, l_count, result_data_block, result_data_ptr, row_width, copied, count);
-			} else {
-				// Left side is exhausted
-				FlushRows(r_ptr, r.entry_idx, r_count, result_data_block, result_data_ptr, row_width, copied, count);
-			}
-		} else {
-			// External sorting with variable size data. Pin the heap blocks too
-			if (!l_done) {
-				l_heap_ptr = l.BaseHeapPtr(l_data) + Load<idx_t>(l_ptr + heap_pointer_offset);
-				D_ASSERT(l_heap_ptr - l.BaseHeapPtr(l_data) >= 0);
-				D_ASSERT((idx_t)(l_heap_ptr - l.BaseHeapPtr(l_data)) < l_data.heap_blocks[l.block_idx].byte_offset);
-			}
-			if (!r_done) {
-				r_heap_ptr = r.BaseHeapPtr(r_data) + Load<idx_t>(r_ptr + heap_pointer_offset);
-				D_ASSERT(r_heap_ptr - r.BaseHeapPtr(r_data) >= 0);
-				D_ASSERT((idx_t)(r_heap_ptr - r.BaseHeapPtr(r_data)) < r_data.heap_blocks[r.block_idx].byte_offset);
-			}
-			// Both the row and heap data need to be dealt with
-			if (!l_done && !r_done) {
-				// Both sides have data - merge
-				idx_t l_idx_copy = l.entry_idx;
-				idx_t r_idx_copy = r.entry_idx;
-				data_ptr_t result_data_ptr_copy = result_data_ptr;
-				idx_t copied_copy = copied;
-				// Merge row data
-				MergeRows(l_ptr, l_idx_copy, l_count, r_ptr, r_idx_copy, r_count, result_data_block,
-				          result_data_ptr_copy, row_width, left_smaller, copied_copy, count);
-				const idx_t merged = copied_copy - copied;
-				// Compute the entry sizes and number of heap bytes that will be copied
-				idx_t copy_bytes = 0;
-				data_ptr_t l_heap_ptr_copy = l_heap_ptr;
-				data_ptr_t r_heap_ptr_copy = r_heap_ptr;
-				for (idx_t i = 0; i < merged; i++) {
-					// Store base heap offset in the row data
-					Store<idx_t>(result_heap_block->byte_offset + copy_bytes, result_data_ptr + heap_pointer_offset);
-					result_data_ptr += row_width;
-					// Compute entry size and add to total
-					const bool &l_smaller = left_smaller[copied + i];
-					const bool r_smaller = !l_smaller;
-					auto &entry_size = next_entry_sizes[copied + i];
-					entry_size =
-					    l_smaller * Load<uint32_t>(l_heap_ptr_copy) + r_smaller * Load<uint32_t>(r_heap_ptr_copy);
-					D_ASSERT(entry_size >= sizeof(uint32_t));
-					D_ASSERT(l_heap_ptr_copy - l.BaseHeapPtr(l_data) + l_smaller * entry_size <=
-					         l_data.heap_blocks[l.block_idx].byte_offset);
-					D_ASSERT(r_heap_ptr_copy - r.BaseHeapPtr(r_data) + r_smaller * entry_size <=
-					         r_data.heap_blocks[r.block_idx].byte_offset);
-					l_heap_ptr_copy += l_smaller * entry_size;
-					r_heap_ptr_copy += r_smaller * entry_size;
-					copy_bytes += entry_size;
-				}
-				// Reallocate result heap block size (if needed)
-				if (result_heap_block->byte_offset + copy_bytes > result_heap_block->capacity) {
-					idx_t new_capacity = result_heap_block->byte_offset + copy_bytes;
-					buffer_manager.ReAllocate(result_heap_block->block, new_capacity);
-					result_heap_block->capacity = new_capacity;
-					result_heap_ptr = result_heap_handle.Ptr() + result_heap_block->byte_offset;
-				}
-				D_ASSERT(result_heap_block->byte_offset + copy_bytes <= result_heap_block->capacity);
-				// Now copy the heap data
-				for (idx_t i = 0; i < merged; i++) {
-					const bool &l_smaller = left_smaller[copied + i];
-					const bool r_smaller = !l_smaller;
-					const auto &entry_size = next_entry_sizes[copied + i];
-					memcpy(result_heap_ptr, (data_ptr_t)(l_smaller * (idx_t)l_heap_ptr + r_smaller * (idx_t)r_heap_ptr),
-					       entry_size);
-					D_ASSERT(Load<uint32_t>(result_heap_ptr) == entry_size);
-					result_heap_ptr += entry_size;
-					l_heap_ptr += l_smaller * entry_size;
-					r_heap_ptr += r_smaller * entry_size;
-					l.entry_idx += l_smaller;
-					r.entry_idx += r_smaller;
-				}
-				// Update result indices and pointers
-				result_heap_block->count += merged;
-				result_heap_block->byte_offset += copy_bytes;
-				copied += merged;
-			} else if (r_done) {
-				// Right side is exhausted - flush left
-				FlushBlobs(layout, l_count, l_ptr, l.entry_idx, l_heap_ptr, result_data_block, result_data_ptr,
-				           result_heap_block, result_heap_handle, result_heap_ptr, copied, count);
-			} else {
-				// Left side is exhausted - flush right
-				FlushBlobs(layout, r_count, r_ptr, r.entry_idx, r_heap_ptr, result_data_block, result_data_ptr,
-				           result_heap_block, result_heap_handle, result_heap_ptr, copied, count);
-			}
-			D_ASSERT(result_data_block->count == result_heap_block->count);
-		}
-	}
-	if (reset_indices) {
-		left->SetIndices(l_block_idx_before, l_entry_idx_before);
-		right->SetIndices(r_block_idx_before, r_entry_idx_before);
-	}
-}
-
-void MergeSorter::MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &l_count, data_ptr_t &r_ptr,
-                            idx_t &r_entry_idx, const idx_t &r_count, RowDataBlock *target_block,
-                            data_ptr_t &target_ptr, const idx_t &entry_size, const bool left_smaller[], idx_t &copied,
-                            const idx_t &count) {
-	const idx_t next = MinValue(count - copied, target_block->capacity - target_block->count);
-	idx_t i;
-	for (i = 0; i < next && l_entry_idx < l_count && r_entry_idx < r_count; i++) {
-		const bool &l_smaller = left_smaller[copied + i];
-		const bool r_smaller = !l_smaller;
-		// Use comparison bool (0 or 1) to copy an entry from either side
-		FastMemcpy(target_ptr, (data_ptr_t)(l_smaller * (idx_t)l_ptr + r_smaller * (idx_t)r_ptr), entry_size);
-		target_ptr += entry_size;
-		// Use the comparison bool to increment entries and pointers
-		l_entry_idx += l_smaller;
-		r_entry_idx += r_smaller;
-		l_ptr += l_smaller * entry_size;
-		r_ptr += r_smaller * entry_size;
-	}
-	// Update counts
-	target_block->count += i;
-	copied += i;
-}
-
-void MergeSorter::FlushRows(data_ptr_t &source_ptr, idx_t &source_entry_idx, const idx_t &source_count,
-                            RowDataBlock *target_block, data_ptr_t &target_ptr, const idx_t &entry_size, idx_t &copied,
-                            const idx_t &count) {
-	// Compute how many entries we can fit
-	idx_t next = MinValue(count - copied, target_block->capacity - target_block->count);
-	next = MinValue(next, source_count - source_entry_idx);
-	// Copy them all in a single memcpy
-	const idx_t copy_bytes = next * entry_size;
-	memcpy(target_ptr, source_ptr, copy_bytes);
-	target_ptr += copy_bytes;
-	source_ptr += copy_bytes;
-	// Update counts
-	source_entry_idx += next;
-	target_block->count += next;
-	copied += next;
-}
-
-void MergeSorter::FlushBlobs(const RowLayout &layout, const idx_t &source_count, data_ptr_t &source_data_ptr,
-                             idx_t &source_entry_idx, data_ptr_t &source_heap_ptr, RowDataBlock *target_data_block,
-                             data_ptr_t &target_data_ptr, RowDataBlock *target_heap_block,
-                             BufferHandle &target_heap_handle, data_ptr_t &target_heap_ptr, idx_t &copied,
-                             const idx_t &count) {
-	const idx_t row_width = layout.GetRowWidth();
-	const idx_t heap_pointer_offset = layout.GetHeapPointerOffset();
-	idx_t source_entry_idx_copy = source_entry_idx;
-	data_ptr_t target_data_ptr_copy = target_data_ptr;
-	idx_t copied_copy = copied;
-	// Flush row data
-	FlushRows(source_data_ptr, source_entry_idx_copy, source_count, target_data_block, target_data_ptr_copy, row_width,
-	          copied_copy, count);
-	const idx_t flushed = copied_copy - copied;
-	// Compute the entry sizes and number of heap bytes that will be copied
-	idx_t copy_bytes = 0;
-	data_ptr_t source_heap_ptr_copy = source_heap_ptr;
-	for (idx_t i = 0; i < flushed; i++) {
-		// Store base heap offset in the row data
-		Store<idx_t>(target_heap_block->byte_offset + copy_bytes, target_data_ptr + heap_pointer_offset);
-		target_data_ptr += row_width;
-		// Compute entry size and add to total
-		auto entry_size = Load<uint32_t>(source_heap_ptr_copy);
-		D_ASSERT(entry_size >= sizeof(uint32_t));
-		source_heap_ptr_copy += entry_size;
-		copy_bytes += entry_size;
-	}
-	// Reallocate result heap block size (if needed)
-	if (target_heap_block->byte_offset + copy_bytes > target_heap_block->capacity) {
-		idx_t new_capacity = target_heap_block->byte_offset + copy_bytes;
-		buffer_manager.ReAllocate(target_heap_block->block, new_capacity);
-		target_heap_block->capacity = new_capacity;
-		target_heap_ptr = target_heap_handle.Ptr() + target_heap_block->byte_offset;
-	}
-	D_ASSERT(target_heap_block->byte_offset + copy_bytes <= target_heap_block->capacity);
-	// Copy the heap data in one go
-	memcpy(target_heap_ptr, source_heap_ptr, copy_bytes);
-	target_heap_ptr += copy_bytes;
-	source_heap_ptr += copy_bytes;
-	source_entry_idx += flushed;
-	copied += flushed;
-	// Update result indices and pointers
-	target_heap_block->count += flushed;
-	target_heap_block->byte_offset += copy_bytes;
-	D_ASSERT(target_heap_block->byte_offset <= target_heap_block->capacity);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-//! Calls std::sort on strings that are tied by their prefix after the radix sort
-static void SortTiedBlobs(BufferManager &buffer_manager, const data_ptr_t dataptr, const idx_t &start, const idx_t &end,
-                          const idx_t &tie_col, bool *ties, const data_ptr_t blob_ptr, const SortLayout &sort_layout) {
-	const auto row_width = sort_layout.blob_layout.GetRowWidth();
-	const idx_t &col_idx = sort_layout.sorting_to_blob_col.at(tie_col);
-	// Locate the first blob row in question
-	data_ptr_t row_ptr = dataptr + start * sort_layout.entry_size;
-	data_ptr_t blob_row_ptr = blob_ptr + Load<uint32_t>(row_ptr + sort_layout.comparison_size) * row_width;
-	if (!Comparators::TieIsBreakable(col_idx, blob_row_ptr, sort_layout.blob_layout)) {
-		// Quick check to see if ties can be broken
-		return;
-	}
-	// Fill pointer array for sorting
-	auto ptr_block = unique_ptr<data_ptr_t[]>(new data_ptr_t[end - start]);
-	auto entry_ptrs = (data_ptr_t *)ptr_block.get();
-	for (idx_t i = start; i < end; i++) {
-		entry_ptrs[i - start] = row_ptr;
-		row_ptr += sort_layout.entry_size;
-	}
-	// Slow pointer-based sorting
-	const int order = sort_layout.order_types[tie_col] == OrderType::DESCENDING ? -1 : 1;
-	const auto &tie_col_offset = sort_layout.blob_layout.GetOffsets()[col_idx];
-	auto logical_type = sort_layout.blob_layout.GetTypes()[col_idx];
-	std::sort(entry_ptrs, entry_ptrs + end - start,
-	          [&blob_ptr, &order, &sort_layout, &tie_col_offset, &row_width, &logical_type](const data_ptr_t l,
-	                                                                                        const data_ptr_t r) {
-		          idx_t left_idx = Load<uint32_t>(l + sort_layout.comparison_size);
-		          idx_t right_idx = Load<uint32_t>(r + sort_layout.comparison_size);
-		          data_ptr_t left_ptr = blob_ptr + left_idx * row_width + tie_col_offset;
-		          data_ptr_t right_ptr = blob_ptr + right_idx * row_width + tie_col_offset;
-		          return order * Comparators::CompareVal(left_ptr, right_ptr, logical_type) < 0;
-	          });
-	// Re-order
-	auto temp_block =
-	    buffer_manager.Allocate(MaxValue((end - start) * sort_layout.entry_size, (idx_t)Storage::BLOCK_SIZE));
-	data_ptr_t temp_ptr = temp_block.Ptr();
-	for (idx_t i = 0; i < end - start; i++) {
-		FastMemcpy(temp_ptr, entry_ptrs[i], sort_layout.entry_size);
-		temp_ptr += sort_layout.entry_size;
-	}
-	memcpy(dataptr + start * sort_layout.entry_size, temp_block.Ptr(), (end - start) * sort_layout.entry_size);
-	// Determine if there are still ties (if this is not the last column)
-	if (tie_col < sort_layout.column_count - 1) {
-		data_ptr_t idx_ptr = dataptr + start * sort_layout.entry_size + sort_layout.comparison_size;
-		// Load current entry
-		data_ptr_t current_ptr = blob_ptr + Load<uint32_t>(idx_ptr) * row_width + tie_col_offset;
-		for (idx_t i = 0; i < end - start - 1; i++) {
-			// Load next entry and compare
-			idx_ptr += sort_layout.entry_size;
-			data_ptr_t next_ptr = blob_ptr + Load<uint32_t>(idx_ptr) * row_width + tie_col_offset;
-			ties[start + i] = Comparators::CompareVal(current_ptr, next_ptr, logical_type) == 0;
-			current_ptr = next_ptr;
-		}
-	}
-}
-
-//! Identifies sequences of rows that are tied by the prefix of a blob column, and sorts them
-static void SortTiedBlobs(BufferManager &buffer_manager, SortedBlock &sb, bool *ties, data_ptr_t dataptr,
-                          const idx_t &count, const idx_t &tie_col, const SortLayout &sort_layout) {
-	D_ASSERT(!ties[count - 1]);
-	auto &blob_block = sb.blob_sorting_data->data_blocks.back();
-	auto blob_handle = buffer_manager.Pin(blob_block.block);
-	const data_ptr_t blob_ptr = blob_handle.Ptr();
-
-	for (idx_t i = 0; i < count; i++) {
-		if (!ties[i]) {
-			continue;
-		}
-		idx_t j;
-		for (j = i; j < count; j++) {
-			if (!ties[j]) {
-				break;
-			}
-		}
-		SortTiedBlobs(buffer_manager, dataptr, i, j + 1, tie_col, ties, blob_ptr, sort_layout);
-		i = j;
-	}
-}
-
-//! Returns whether there are any 'true' values in the ties[] array
-static bool AnyTies(bool ties[], const idx_t &count) {
-	D_ASSERT(!ties[count - 1]);
-	bool any_ties = false;
-	for (idx_t i = 0; i < count - 1; i++) {
-		any_ties = any_ties || ties[i];
-	}
-	return any_ties;
-}
-
-//! Compares subsequent rows to check for ties
-static void ComputeTies(data_ptr_t dataptr, const idx_t &count, const idx_t &col_offset, const idx_t &tie_size,
-                        bool ties[], const SortLayout &sort_layout) {
-	D_ASSERT(!ties[count - 1]);
-	D_ASSERT(col_offset + tie_size <= sort_layout.comparison_size);
-	// Align dataptr
-	dataptr += col_offset;
-	for (idx_t i = 0; i < count - 1; i++) {
-		ties[i] = ties[i] && FastMemcmp(dataptr, dataptr + sort_layout.entry_size, tie_size) == 0;
-		dataptr += sort_layout.entry_size;
-	}
-}
-
-//! Textbook LSD radix sort
-void RadixSortLSD(BufferManager &buffer_manager, const data_ptr_t &dataptr, const idx_t &count, const idx_t &col_offset,
-                  const idx_t &row_width, const idx_t &sorting_size) {
-	auto temp_block = buffer_manager.Allocate(MaxValue(count * row_width, (idx_t)Storage::BLOCK_SIZE));
-	bool swap = false;
-
-	idx_t counts[SortConstants::VALUES_PER_RADIX];
-	for (idx_t r = 1; r <= sorting_size; r++) {
-		// Init counts to 0
-		memset(counts, 0, sizeof(counts));
-		// Const some values for convenience
-		const data_ptr_t source_ptr = swap ? temp_block.Ptr() : dataptr;
-		const data_ptr_t target_ptr = swap ? dataptr : temp_block.Ptr();
-		const idx_t offset = col_offset + sorting_size - r;
-		// Collect counts
-		data_ptr_t offset_ptr = source_ptr + offset;
-		for (idx_t i = 0; i < count; i++) {
-			counts[*offset_ptr]++;
-			offset_ptr += row_width;
-		}
-		// Compute offsets from counts
-		idx_t max_count = counts[0];
-		for (idx_t val = 1; val < SortConstants::VALUES_PER_RADIX; val++) {
-			max_count = MaxValue<idx_t>(max_count, counts[val]);
-			counts[val] = counts[val] + counts[val - 1];
-		}
-		if (max_count == count) {
-			continue;
-		}
-		// Re-order the data in temporary array
-		data_ptr_t row_ptr = source_ptr + (count - 1) * row_width;
-		for (idx_t i = 0; i < count; i++) {
-			idx_t &radix_offset = --counts[*(row_ptr + offset)];
-			FastMemcpy(target_ptr + radix_offset * row_width, row_ptr, row_width);
-			row_ptr -= row_width;
-		}
-		swap = !swap;
-	}
-	// Move data back to original buffer (if it was swapped)
-	if (swap) {
-		memcpy(dataptr, temp_block.Ptr(), count * row_width);
-	}
-}
-
-//! Insertion sort, used when count of values is low
-inline void InsertionSort(const data_ptr_t orig_ptr, const data_ptr_t temp_ptr, const idx_t &count,
-                          const idx_t &col_offset, const idx_t &row_width, const idx_t &total_comp_width,
-                          const idx_t &offset, bool swap) {
-	const data_ptr_t source_ptr = swap ? temp_ptr : orig_ptr;
-	const data_ptr_t target_ptr = swap ? orig_ptr : temp_ptr;
-	if (count > 1) {
-		const idx_t total_offset = col_offset + offset;
-		auto temp_val = unique_ptr<data_t[]>(new data_t[row_width]);
-		const data_ptr_t val = temp_val.get();
-		const auto comp_width = total_comp_width - offset;
-		for (idx_t i = 1; i < count; i++) {
-			FastMemcpy(val, source_ptr + i * row_width, row_width);
-			idx_t j = i;
-			while (j > 0 &&
-			       FastMemcmp(source_ptr + (j - 1) * row_width + total_offset, val + total_offset, comp_width) > 0) {
-				FastMemcpy(source_ptr + j * row_width, source_ptr + (j - 1) * row_width, row_width);
-				j--;
-			}
-			FastMemcpy(source_ptr + j * row_width, val, row_width);
-		}
-	}
-	if (swap) {
-		memcpy(target_ptr, source_ptr, count * row_width);
-	}
-}
-
-//! MSD radix sort that switches to insertion sort with low bucket sizes
-void RadixSortMSD(const data_ptr_t orig_ptr, const data_ptr_t temp_ptr, const idx_t &count, const idx_t &col_offset,
-                  const idx_t &row_width, const idx_t &comp_width, const idx_t &offset, idx_t locations[], bool swap) {
-	const data_ptr_t source_ptr = swap ? temp_ptr : orig_ptr;
-	const data_ptr_t target_ptr = swap ? orig_ptr : temp_ptr;
-	// Init counts to 0
-	memset(locations, 0, SortConstants::MSD_RADIX_LOCATIONS * sizeof(idx_t));
-	idx_t *counts = locations + 1;
-	// Collect counts
-	const idx_t total_offset = col_offset + offset;
-	data_ptr_t offset_ptr = source_ptr + total_offset;
-	for (idx_t i = 0; i < count; i++) {
-		counts[*offset_ptr]++;
-		offset_ptr += row_width;
-	}
-	// Compute locations from counts
-	idx_t max_count = 0;
-	for (idx_t radix = 0; radix < SortConstants::VALUES_PER_RADIX; radix++) {
-		max_count = MaxValue<idx_t>(max_count, counts[radix]);
-		counts[radix] += locations[radix];
-	}
-	if (max_count != count) {
-		// Re-order the data in temporary array
-		data_ptr_t row_ptr = source_ptr;
-		for (idx_t i = 0; i < count; i++) {
-			const idx_t &radix_offset = locations[*(row_ptr + total_offset)]++;
-			FastMemcpy(target_ptr + radix_offset * row_width, row_ptr, row_width);
-			row_ptr += row_width;
-		}
-		swap = !swap;
-	}
-	// Check if done
-	if (offset == comp_width - 1) {
-		if (swap) {
-			memcpy(orig_ptr, temp_ptr, count * row_width);
-		}
-		return;
-	}
-	if (max_count == count) {
-		RadixSortMSD(orig_ptr, temp_ptr, count, col_offset, row_width, comp_width, offset + 1,
-		             locations + SortConstants::MSD_RADIX_LOCATIONS, swap);
-		return;
-	}
-	// Recurse
-	idx_t radix_count = locations[0];
-	for (idx_t radix = 0; radix < SortConstants::VALUES_PER_RADIX; radix++) {
-		const idx_t loc = (locations[radix] - radix_count) * row_width;
-		if (radix_count > SortConstants::INSERTION_SORT_THRESHOLD) {
-			RadixSortMSD(orig_ptr + loc, temp_ptr + loc, radix_count, col_offset, row_width, comp_width, offset + 1,
-			             locations + SortConstants::MSD_RADIX_LOCATIONS, swap);
-		} else if (radix_count != 0) {
-			InsertionSort(orig_ptr + loc, temp_ptr + loc, radix_count, col_offset, row_width, comp_width, offset + 1,
-			              swap);
-		}
-		radix_count = locations[radix + 1] - locations[radix];
-	}
-}
-
-//! Calls different sort functions, depending on the count and sorting sizes
-void RadixSort(BufferManager &buffer_manager, const data_ptr_t &dataptr, const idx_t &count, const idx_t &col_offset,
-               const idx_t &sorting_size, const SortLayout &sort_layout) {
-	if (count <= SortConstants::INSERTION_SORT_THRESHOLD) {
-		InsertionSort(dataptr, nullptr, count, 0, sort_layout.entry_size, sort_layout.comparison_size, 0, false);
-	} else if (sorting_size <= SortConstants::MSD_RADIX_SORT_SIZE_THRESHOLD) {
-		RadixSortLSD(buffer_manager, dataptr, count, col_offset, sort_layout.entry_size, sorting_size);
-	} else {
-		auto temp_block = buffer_manager.Allocate(MaxValue(count * sort_layout.entry_size, (idx_t)Storage::BLOCK_SIZE));
-		auto preallocated_array = unique_ptr<idx_t[]>(new idx_t[sorting_size * SortConstants::MSD_RADIX_LOCATIONS]);
-		RadixSortMSD(dataptr, temp_block.Ptr(), count, col_offset, sort_layout.entry_size, sorting_size, 0,
-		             preallocated_array.get(), false);
-	}
-}
-
-//! Identifies sequences of rows that are tied, and calls radix sort on these
-static void SubSortTiedTuples(BufferManager &buffer_manager, const data_ptr_t dataptr, const idx_t &count,
-                              const idx_t &col_offset, const idx_t &sorting_size, bool ties[],
-                              const SortLayout &sort_layout) {
-	D_ASSERT(!ties[count - 1]);
-	for (idx_t i = 0; i < count; i++) {
-		if (!ties[i]) {
-			continue;
-		}
-		idx_t j;
-		for (j = i + 1; j < count; j++) {
-			if (!ties[j]) {
-				break;
-			}
-		}
-		RadixSort(buffer_manager, dataptr + i * sort_layout.entry_size, j - i + 1, col_offset, sorting_size,
-		          sort_layout);
-		i = j;
-	}
-}
-
-void LocalSortState::SortInMemory() {
-	auto &sb = *sorted_blocks.back();
-	auto &block = sb.radix_sorting_data.back();
-	const auto &count = block.count;
-	auto handle = buffer_manager->Pin(block.block);
-	const auto dataptr = handle.Ptr();
-	// Assign an index to each row
-	data_ptr_t idx_dataptr = dataptr + sort_layout->comparison_size;
-	for (uint32_t i = 0; i < count; i++) {
-		Store<uint32_t>(i, idx_dataptr);
-		idx_dataptr += sort_layout->entry_size;
-	}
-	// Radix sort and break ties until no more ties, or until all columns are sorted
-	idx_t sorting_size = 0;
-	idx_t col_offset = 0;
-	unique_ptr<bool[]> ties_ptr;
-	bool *ties = nullptr;
-	for (idx_t i = 0; i < sort_layout->column_count; i++) {
-		sorting_size += sort_layout->column_sizes[i];
-		if (sort_layout->constant_size[i] && i < sort_layout->column_count - 1) {
-			// Add columns to the sorting size until we reach a variable size column, or the last column
-			continue;
-		}
-
-		if (!ties) {
-			// This is the first sort
-			RadixSort(*buffer_manager, dataptr, count, col_offset, sorting_size, *sort_layout);
-			ties_ptr = unique_ptr<bool[]>(new bool[count]);
-			ties = ties_ptr.get();
-			std::fill_n(ties, count - 1, true);
-			ties[count - 1] = false;
-		} else {
-			// For subsequent sorts, we only have to subsort the tied tuples
-			SubSortTiedTuples(*buffer_manager, dataptr, count, col_offset, sorting_size, ties, *sort_layout);
-		}
-
-		if (sort_layout->constant_size[i] && i == sort_layout->column_count - 1) {
-			// All columns are sorted, no ties to break because last column is constant size
-			break;
-		}
-
-		ComputeTies(dataptr, count, col_offset, sorting_size, ties, *sort_layout);
-		if (!AnyTies(ties, count)) {
-			// No ties, stop sorting
-			break;
-		}
-
-		if (!sort_layout->constant_size[i]) {
-			SortTiedBlobs(*buffer_manager, sb, ties, dataptr, count, i, *sort_layout);
-			if (!AnyTies(ties, count)) {
-				// No more ties after tie-breaking, stop
-				break;
-			}
-		}
-
-		col_offset += sorting_size;
-		sorting_size = 0;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#include <numeric>
-
-namespace duckdb {
-
-idx_t GetNestedSortingColSize(idx_t &col_size, const LogicalType &type) {
-	auto physical_type = type.InternalType();
-	if (TypeIsConstantSize(physical_type)) {
-		col_size += GetTypeIdSize(physical_type);
-		return 0;
-	} else {
-		switch (physical_type) {
-		case PhysicalType::VARCHAR: {
-			// Nested strings are between 4 and 11 chars long for alignment
-			auto size_before_str = col_size;
-			col_size += 11;
-			col_size -= (col_size - 12) % 8;
-			return col_size - size_before_str;
-		}
-		case PhysicalType::LIST:
-			// Lists get 2 bytes (null and empty list)
-			col_size += 2;
-			return GetNestedSortingColSize(col_size, ListType::GetChildType(type));
-		case PhysicalType::MAP:
-		case PhysicalType::STRUCT:
-			// Structs get 1 bytes (null)
-			col_size++;
-			return GetNestedSortingColSize(col_size, StructType::GetChildType(type, 0));
-		default:
-			throw NotImplementedException("Unable to order column with type %s", type.ToString());
-		}
-	}
-}
-
-SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
-    : column_count(orders.size()), all_constant(true), comparison_size(0), entry_size(0) {
-	vector<LogicalType> blob_layout_types;
-	for (idx_t i = 0; i < column_count; i++) {
-		const auto &order = orders[i];
-
-		order_types.push_back(order.type);
-		order_by_null_types.push_back(order.null_order);
-		auto &expr = *order.expression;
-		logical_types.push_back(expr.return_type);
-
-		auto physical_type = expr.return_type.InternalType();
-		constant_size.push_back(TypeIsConstantSize(physical_type));
-
-		if (order.stats) {
-			stats.push_back(order.stats.get());
-			has_null.push_back(stats.back()->CanHaveNull());
-		} else {
-			stats.push_back(nullptr);
-			has_null.push_back(true);
-		}
-
-		idx_t col_size = has_null.back() ? 1 : 0;
-		prefix_lengths.push_back(0);
-		if (!TypeIsConstantSize(physical_type) && physical_type != PhysicalType::VARCHAR) {
-			prefix_lengths.back() = GetNestedSortingColSize(col_size, expr.return_type);
-		} else if (physical_type == PhysicalType::VARCHAR) {
-			idx_t size_before = col_size;
-			if (stats.back()) {
-				auto &str_stats = (StringStatistics &)*stats.back();
-				col_size += str_stats.max_string_length;
-				if (col_size > 12) {
-					col_size = 12;
-				} else {
-					constant_size.back() = true;
-				}
-			} else {
-				col_size = 12;
-			}
-			prefix_lengths.back() = col_size - size_before;
-		} else {
-			col_size += GetTypeIdSize(physical_type);
-		}
-
-		comparison_size += col_size;
-		column_sizes.push_back(col_size);
-	}
-	entry_size = comparison_size + sizeof(uint32_t);
-
-	// 8-byte alignment
-	if (entry_size % 8 != 0) {
-		// First assign more bytes to strings instead of aligning
-		idx_t bytes_to_fill = 8 - (entry_size % 8);
-		for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-			if (bytes_to_fill == 0) {
-				break;
-			}
-			if (logical_types[col_idx].InternalType() == PhysicalType::VARCHAR && stats[col_idx]) {
-				auto &str_stats = (StringStatistics &)*stats[col_idx];
-				idx_t diff = str_stats.max_string_length - prefix_lengths[col_idx];
-				if (diff > 0) {
-					// Increase all sizes accordingly
-					idx_t increase = MinValue(bytes_to_fill, diff);
-					column_sizes[col_idx] += increase;
-					prefix_lengths[col_idx] += increase;
-					constant_size[col_idx] = increase == diff;
-					comparison_size += increase;
-					entry_size += increase;
-					bytes_to_fill -= increase;
-				}
-			}
-		}
-		entry_size = AlignValue(entry_size);
-	}
-
-	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-		all_constant = all_constant && constant_size[col_idx];
-		if (!constant_size[col_idx]) {
-			sorting_to_blob_col[col_idx] = blob_layout_types.size();
-			blob_layout_types.push_back(logical_types[col_idx]);
-		}
-	}
-
-	blob_layout.Initialize(blob_layout_types);
-}
-
-LocalSortState::LocalSortState() : initialized(false) {
-}
-
-static idx_t EntriesPerBlock(idx_t width) {
-	return (Storage::BLOCK_SIZE + width * STANDARD_VECTOR_SIZE - 1) / width;
-}
-
-void LocalSortState::Initialize(GlobalSortState &global_sort_state, BufferManager &buffer_manager_p) {
-	sort_layout = &global_sort_state.sort_layout;
-	payload_layout = &global_sort_state.payload_layout;
-	buffer_manager = &buffer_manager_p;
-	// Radix sorting data
-	radix_sorting_data = make_unique<RowDataCollection>(*buffer_manager, EntriesPerBlock(sort_layout->entry_size),
-	                                                    sort_layout->entry_size);
-	// Blob sorting data
-	if (!sort_layout->all_constant) {
-		auto blob_row_width = sort_layout->blob_layout.GetRowWidth();
-		blob_sorting_data =
-		    make_unique<RowDataCollection>(*buffer_manager, EntriesPerBlock(blob_row_width), blob_row_width);
-		blob_sorting_heap = make_unique<RowDataCollection>(*buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
-	}
-	// Payload data
-	auto payload_row_width = payload_layout->GetRowWidth();
-	payload_data =
-	    make_unique<RowDataCollection>(*buffer_manager, EntriesPerBlock(payload_row_width), payload_row_width);
-	payload_heap = make_unique<RowDataCollection>(*buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
-	// Init done
-	initialized = true;
-}
-
-void LocalSortState::SinkChunk(DataChunk &sort, DataChunk &payload) {
-	D_ASSERT(sort.size() == payload.size());
-	// Build and serialize sorting data to radix sortable rows
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	auto handles = radix_sorting_data->Build(sort.size(), data_pointers, nullptr);
-	for (idx_t sort_col = 0; sort_col < sort.ColumnCount(); sort_col++) {
-		bool has_null = sort_layout->has_null[sort_col];
-		bool nulls_first = sort_layout->order_by_null_types[sort_col] == OrderByNullType::NULLS_FIRST;
-		bool desc = sort_layout->order_types[sort_col] == OrderType::DESCENDING;
-		RowOperations::RadixScatter(sort.data[sort_col], sort.size(), sel_ptr, sort.size(), data_pointers, desc,
-		                            has_null, nulls_first, sort_layout->prefix_lengths[sort_col],
-		                            sort_layout->column_sizes[sort_col]);
-	}
-
-	// Also fully serialize blob sorting columns (to be able to break ties
-	if (!sort_layout->all_constant) {
-		DataChunk blob_chunk;
-		blob_chunk.SetCardinality(sort.size());
-		for (idx_t sort_col = 0; sort_col < sort.ColumnCount(); sort_col++) {
-			if (!sort_layout->constant_size[sort_col]) {
-				blob_chunk.data.emplace_back(sort.data[sort_col]);
-			}
-		}
-		handles = blob_sorting_data->Build(blob_chunk.size(), data_pointers, nullptr);
-		auto blob_data = blob_chunk.Orrify();
-		RowOperations::Scatter(blob_chunk, blob_data.get(), sort_layout->blob_layout, addresses, *blob_sorting_heap,
-		                       sel_ptr, blob_chunk.size());
-	}
-
-	// Finally, serialize payload data
-	handles = payload_data->Build(payload.size(), data_pointers, nullptr);
-	auto input_data = payload.Orrify();
-	RowOperations::Scatter(payload, input_data.get(), *payload_layout, addresses, *payload_heap, sel_ptr,
-	                       payload.size());
-}
-
-idx_t LocalSortState::SizeInBytes() const {
-	idx_t size_in_bytes = radix_sorting_data->SizeInBytes() + payload_data->SizeInBytes();
-	if (!sort_layout->all_constant) {
-		size_in_bytes += blob_sorting_data->SizeInBytes() + blob_sorting_heap->SizeInBytes();
-	}
-	if (!payload_layout->AllConstant()) {
-		size_in_bytes += payload_heap->SizeInBytes();
-	}
-	return size_in_bytes;
-}
-
-void LocalSortState::Sort(GlobalSortState &global_sort_state, bool reorder_heap) {
-	D_ASSERT(radix_sorting_data->count == payload_data->count);
-	if (radix_sorting_data->count == 0) {
-		return;
-	}
-	// Move all data to a single SortedBlock
-	sorted_blocks.emplace_back(make_unique<SortedBlock>(*buffer_manager, global_sort_state));
-	auto &sb = *sorted_blocks.back();
-	// Fixed-size sorting data
-	auto sorting_block = ConcatenateBlocks(*radix_sorting_data);
-	sb.radix_sorting_data.push_back(move(sorting_block));
-	// Variable-size sorting data
-	if (!sort_layout->all_constant) {
-		auto &blob_data = *blob_sorting_data;
-		auto new_block = ConcatenateBlocks(blob_data);
-		sb.blob_sorting_data->data_blocks.push_back(move(new_block));
-	}
-	// Payload data
-	auto payload_block = ConcatenateBlocks(*payload_data);
-	sb.payload_data->data_blocks.push_back(move(payload_block));
-	// Now perform the actual sort
-	SortInMemory();
-	// Re-order before the merge sort
-	ReOrder(global_sort_state, reorder_heap);
-}
-
-RowDataBlock LocalSortState::ConcatenateBlocks(RowDataCollection &row_data) {
-	// Create block with the correct capacity
-	const idx_t &entry_size = row_data.entry_size;
-	idx_t capacity = MaxValue(((idx_t)Storage::BLOCK_SIZE + entry_size - 1) / entry_size, row_data.count);
-	RowDataBlock new_block(*buffer_manager, capacity, entry_size);
-	new_block.count = row_data.count;
-	auto new_block_handle = buffer_manager->Pin(new_block.block);
-	data_ptr_t new_block_ptr = new_block_handle.Ptr();
-	// Copy the data of the blocks into a single block
-	for (auto &block : row_data.blocks) {
-		auto block_handle = buffer_manager->Pin(block.block);
-		memcpy(new_block_ptr, block_handle.Ptr(), block.count * entry_size);
-		new_block_ptr += block.count * entry_size;
-	}
-	row_data.blocks.clear();
-	row_data.count = 0;
-	return new_block;
-}
-
-void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataCollection &heap, GlobalSortState &gstate,
-                             bool reorder_heap) {
-	sd.swizzled = reorder_heap;
-	auto &unordered_data_block = sd.data_blocks.back();
-	const idx_t &count = unordered_data_block.count;
-	auto unordered_data_handle = buffer_manager->Pin(unordered_data_block.block);
-	const data_ptr_t unordered_data_ptr = unordered_data_handle.Ptr();
-	// Create new block that will hold re-ordered row data
-	RowDataBlock ordered_data_block(*buffer_manager, unordered_data_block.capacity, unordered_data_block.entry_size);
-	ordered_data_block.count = count;
-	auto ordered_data_handle = buffer_manager->Pin(ordered_data_block.block);
-	data_ptr_t ordered_data_ptr = ordered_data_handle.Ptr();
-	// Re-order fixed-size row layout
-	const idx_t row_width = sd.layout.GetRowWidth();
-	const idx_t sorting_entry_size = gstate.sort_layout.entry_size;
-	for (idx_t i = 0; i < count; i++) {
-		auto index = Load<uint32_t>(sorting_ptr);
-		FastMemcpy(ordered_data_ptr, unordered_data_ptr + index * row_width, row_width);
-		ordered_data_ptr += row_width;
-		sorting_ptr += sorting_entry_size;
-	}
-	// Replace the unordered data block with the re-ordered data block
-	sd.data_blocks.clear();
-	sd.data_blocks.push_back(move(ordered_data_block));
-	// Deal with the heap (if necessary)
-	if (!sd.layout.AllConstant() && reorder_heap) {
-		// Swizzle the column pointers to offsets
-		RowOperations::SwizzleColumns(sd.layout, ordered_data_handle.Ptr(), count);
-		// Create a single heap block to store the ordered heap
-		idx_t total_byte_offset = std::accumulate(heap.blocks.begin(), heap.blocks.end(), 0,
-		                                          [](idx_t a, const RowDataBlock &b) { return a + b.byte_offset; });
-		idx_t heap_block_size = MaxValue(total_byte_offset, (idx_t)Storage::BLOCK_SIZE);
-		RowDataBlock ordered_heap_block(*buffer_manager, heap_block_size, 1);
-		ordered_heap_block.count = count;
-		ordered_heap_block.byte_offset = total_byte_offset;
-		auto ordered_heap_handle = buffer_manager->Pin(ordered_heap_block.block);
-		data_ptr_t ordered_heap_ptr = ordered_heap_handle.Ptr();
-		// Fill the heap in order
-		ordered_data_ptr = ordered_data_handle.Ptr();
-		const idx_t heap_pointer_offset = sd.layout.GetHeapPointerOffset();
-		for (idx_t i = 0; i < count; i++) {
-			auto heap_row_ptr = Load<data_ptr_t>(ordered_data_ptr + heap_pointer_offset);
-			auto heap_row_size = Load<uint32_t>(heap_row_ptr);
-			memcpy(ordered_heap_ptr, heap_row_ptr, heap_row_size);
-			ordered_heap_ptr += heap_row_size;
-			ordered_data_ptr += row_width;
-		}
-		// Swizzle the base pointer to the offset of each row in the heap
-		RowOperations::SwizzleHeapPointer(sd.layout, ordered_data_handle.Ptr(), ordered_heap_handle.Ptr(), count);
-		// Move the re-ordered heap to the SortedData, and clear the local heap
-		sd.heap_blocks.push_back(move(ordered_heap_block));
-		heap.pinned_blocks.clear();
-		heap.blocks.clear();
-		heap.count = 0;
-	}
-}
-
-void LocalSortState::ReOrder(GlobalSortState &gstate, bool reorder_heap) {
-	auto &sb = *sorted_blocks.back();
-	auto sorting_handle = buffer_manager->Pin(sb.radix_sorting_data.back().block);
-	const data_ptr_t sorting_ptr = sorting_handle.Ptr() + gstate.sort_layout.comparison_size;
-	// Re-order variable size sorting columns
-	if (!gstate.sort_layout.all_constant) {
-		ReOrder(*sb.blob_sorting_data, sorting_ptr, *blob_sorting_heap, gstate, reorder_heap);
-	}
-	// And the payload
-	ReOrder(*sb.payload_data, sorting_ptr, *payload_heap, gstate, reorder_heap);
-}
-
-GlobalSortState::GlobalSortState(BufferManager &buffer_manager, const vector<BoundOrderByNode> &orders,
-                                 RowLayout &payload_layout)
-    : buffer_manager(buffer_manager), sort_layout(SortLayout(orders)), payload_layout(payload_layout),
-      block_capacity(0), external(false) {
-}
-
-void GlobalSortState::AddLocalState(LocalSortState &local_sort_state) {
-	if (!local_sort_state.radix_sorting_data) {
-		return;
-	}
-
-	// Sort accumulated data
-	// we only re-order the heap when the data is expected to not fit in memory
-	// re-ordering the heap avoids random access when reading/merging but incurs a significant cost of shuffling data
-	// when data fits in memory, doing random access on reads is cheaper than re-shuffling
-	local_sort_state.Sort(*this, external || !local_sort_state.sorted_blocks.empty());
-
-	// Append local state sorted data to this global state
-	lock_guard<mutex> append_guard(lock);
-	for (auto &sb : local_sort_state.sorted_blocks) {
-		sorted_blocks.push_back(move(sb));
-	}
-	auto &payload_heap = local_sort_state.payload_heap;
-	for (idx_t i = 0; i < payload_heap->blocks.size(); i++) {
-		heap_blocks.push_back(move(payload_heap->blocks[i]));
-		pinned_blocks.push_back(move(payload_heap->pinned_blocks[i]));
-	}
-	if (!sort_layout.all_constant) {
-		auto &blob_heap = local_sort_state.blob_sorting_heap;
-		for (idx_t i = 0; i < blob_heap->blocks.size(); i++) {
-			heap_blocks.push_back(move(blob_heap->blocks[i]));
-			pinned_blocks.push_back(move(blob_heap->pinned_blocks[i]));
-		}
-	}
-}
-
-void GlobalSortState::PrepareMergePhase() {
-	// Determine if we need to use do an external sort
-	idx_t total_heap_size =
-	    std::accumulate(sorted_blocks.begin(), sorted_blocks.end(), (idx_t)0,
-	                    [](idx_t a, const unique_ptr<SortedBlock> &b) { return a + b->HeapSize(); });
-	if (external || (pinned_blocks.empty() && total_heap_size > 0.25 * buffer_manager.GetMaxMemory())) {
-		external = true;
-	}
-	// Use the data that we have to determine which partition size to use during the merge
-	if (external && total_heap_size > 0) {
-		// If we have variable size data we need to be conservative, as there might be skew
-		idx_t max_block_size = 0;
-		for (auto &sb : sorted_blocks) {
-			idx_t size_in_bytes = sb->SizeInBytes();
-			if (size_in_bytes > max_block_size) {
-				max_block_size = size_in_bytes;
-				block_capacity = sb->Count();
-			}
-		}
-	} else {
-		for (auto &sb : sorted_blocks) {
-			block_capacity = MaxValue(block_capacity, sb->Count());
-		}
-	}
-	// Unswizzle and pin heap blocks if we can fit everything in memory
-	if (!external) {
-		for (auto &sb : sorted_blocks) {
-			sb->blob_sorting_data->Unswizzle();
-			sb->payload_data->Unswizzle();
-		}
-	}
-}
-
-void GlobalSortState::InitializeMergeRound() {
-	D_ASSERT(sorted_blocks_temp.empty());
-	// If we reverse this list, the blocks that were merged last will be merged first in the next round
-	// These are still in memory, therefore this reduces the amount of read/write to disk!
-	std::reverse(sorted_blocks.begin(), sorted_blocks.end());
-	// Uneven number of blocks - keep one on the side
-	if (sorted_blocks.size() % 2 == 1) {
-		odd_one_out = move(sorted_blocks.back());
-		sorted_blocks.pop_back();
-	}
-	// Init merge path path indices
-	pair_idx = 0;
-	num_pairs = sorted_blocks.size() / 2;
-	l_start = 0;
-	r_start = 0;
-	// Allocate room for merge results
-	for (idx_t p_idx = 0; p_idx < num_pairs; p_idx++) {
-		sorted_blocks_temp.emplace_back();
-	}
-}
-
-void GlobalSortState::CompleteMergeRound(bool keep_radix_data) {
-	sorted_blocks.clear();
-	for (auto &sorted_block_vector : sorted_blocks_temp) {
-		sorted_blocks.push_back(make_unique<SortedBlock>(buffer_manager, *this));
-		sorted_blocks.back()->AppendSortedBlocks(sorted_block_vector);
-	}
-	sorted_blocks_temp.clear();
-	if (odd_one_out) {
-		sorted_blocks.push_back(move(odd_one_out));
-		odd_one_out = nullptr;
-	}
-	// Only one block left: Done!
-	if (sorted_blocks.size() == 1 && !keep_radix_data) {
-		sorted_blocks[0]->radix_sorting_data.clear();
-		sorted_blocks[0]->blob_sorting_data = nullptr;
-	}
-}
-void GlobalSortState::Print() {
-	PayloadScanner scanner(*this, false);
-	DataChunk chunk;
-	chunk.Initialize(Allocator::DefaultAllocator(), scanner.GetPayloadTypes());
-	for (;;) {
-		scanner.Scan(chunk);
-		const auto count = chunk.size();
-		if (!count) {
-			break;
-		}
-		chunk.Print();
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#include <numeric>
-
-namespace duckdb {
-
-SortedData::SortedData(SortedDataType type, const RowLayout &layout, BufferManager &buffer_manager,
-                       GlobalSortState &state)
-    : type(type), layout(layout), swizzled(false), buffer_manager(buffer_manager), state(state) {
-}
-
-idx_t SortedData::Count() {
-	idx_t count = std::accumulate(data_blocks.begin(), data_blocks.end(), (idx_t)0,
-	                              [](idx_t a, const RowDataBlock &b) { return a + b.count; });
-	if (!layout.AllConstant() && state.external) {
-		D_ASSERT(count == std::accumulate(heap_blocks.begin(), heap_blocks.end(), (idx_t)0,
-		                                  [](idx_t a, const RowDataBlock &b) { return a + b.count; }));
-	}
-	return count;
-}
-
-void SortedData::CreateBlock() {
-	auto capacity =
-	    MaxValue(((idx_t)Storage::BLOCK_SIZE + layout.GetRowWidth() - 1) / layout.GetRowWidth(), state.block_capacity);
-	data_blocks.emplace_back(buffer_manager, capacity, layout.GetRowWidth());
-	if (!layout.AllConstant() && state.external) {
-		heap_blocks.emplace_back(buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
-		D_ASSERT(data_blocks.size() == heap_blocks.size());
-	}
-}
-
-unique_ptr<SortedData> SortedData::CreateSlice(idx_t start_block_index, idx_t end_block_index, idx_t end_entry_index) {
-	// Add the corresponding blocks to the result
-	auto result = make_unique<SortedData>(type, layout, buffer_manager, state);
-	for (idx_t i = start_block_index; i <= end_block_index; i++) {
-		result->data_blocks.push_back(data_blocks[i]);
-		if (!layout.AllConstant() && state.external) {
-			result->heap_blocks.push_back(heap_blocks[i]);
-		}
-	}
-	// All of the blocks that come before block with idx = start_block_idx can be reset (other references exist)
-	for (idx_t i = 0; i < start_block_index; i++) {
-		data_blocks[i].block = nullptr;
-		if (!layout.AllConstant() && state.external) {
-			heap_blocks[i].block = nullptr;
-		}
-	}
-	// Use start and end entry indices to set the boundaries
-	D_ASSERT(end_entry_index <= result->data_blocks.back().count);
-	result->data_blocks.back().count = end_entry_index;
-	if (!layout.AllConstant() && state.external) {
-		result->heap_blocks.back().count = end_entry_index;
-	}
-	return result;
-}
-
-void SortedData::Unswizzle() {
-	if (layout.AllConstant() || !swizzled) {
-		return;
-	}
-	for (idx_t i = 0; i < data_blocks.size(); i++) {
-		auto &data_block = data_blocks[i];
-		auto &heap_block = heap_blocks[i];
-		auto data_handle_p = buffer_manager.Pin(data_block.block);
-		auto heap_handle_p = buffer_manager.Pin(heap_block.block);
-		RowOperations::UnswizzlePointers(layout, data_handle_p.Ptr(), heap_handle_p.Ptr(), data_block.count);
-		state.heap_blocks.push_back(move(heap_block));
-		state.pinned_blocks.push_back(move(heap_handle_p));
-	}
-	heap_blocks.clear();
-}
-
-SortedBlock::SortedBlock(BufferManager &buffer_manager, GlobalSortState &state)
-    : buffer_manager(buffer_manager), state(state), sort_layout(state.sort_layout),
-      payload_layout(state.payload_layout) {
-	blob_sorting_data = make_unique<SortedData>(SortedDataType::BLOB, sort_layout.blob_layout, buffer_manager, state);
-	payload_data = make_unique<SortedData>(SortedDataType::PAYLOAD, payload_layout, buffer_manager, state);
-}
-
-idx_t SortedBlock::Count() const {
-	idx_t count = std::accumulate(radix_sorting_data.begin(), radix_sorting_data.end(), 0,
-	                              [](idx_t a, const RowDataBlock &b) { return a + b.count; });
-	if (!sort_layout.all_constant) {
-		D_ASSERT(count == blob_sorting_data->Count());
-	}
-	D_ASSERT(count == payload_data->Count());
-	return count;
-}
-
-void SortedBlock::InitializeWrite() {
-	CreateBlock();
-	if (!sort_layout.all_constant) {
-		blob_sorting_data->CreateBlock();
-	}
-	payload_data->CreateBlock();
-}
-
-void SortedBlock::CreateBlock() {
-	auto capacity = MaxValue(((idx_t)Storage::BLOCK_SIZE + sort_layout.entry_size - 1) / sort_layout.entry_size,
-	                         state.block_capacity);
-	radix_sorting_data.emplace_back(buffer_manager, capacity, sort_layout.entry_size);
-}
-
-void SortedBlock::AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blocks) {
-	D_ASSERT(Count() == 0);
-	for (auto &sb : sorted_blocks) {
-		for (auto &radix_block : sb->radix_sorting_data) {
-			radix_sorting_data.push_back(move(radix_block));
-		}
-		if (!sort_layout.all_constant) {
-			for (auto &blob_block : sb->blob_sorting_data->data_blocks) {
-				blob_sorting_data->data_blocks.push_back(move(blob_block));
-			}
-			for (auto &heap_block : sb->blob_sorting_data->heap_blocks) {
-				blob_sorting_data->heap_blocks.push_back(move(heap_block));
-			}
-		}
-		for (auto &payload_data_block : sb->payload_data->data_blocks) {
-			payload_data->data_blocks.push_back(move(payload_data_block));
-		}
-		if (!payload_data->layout.AllConstant()) {
-			for (auto &payload_heap_block : sb->payload_data->heap_blocks) {
-				payload_data->heap_blocks.push_back(move(payload_heap_block));
-			}
-		}
-	}
-}
-
-void SortedBlock::GlobalToLocalIndex(const idx_t &global_idx, idx_t &local_block_index, idx_t &local_entry_index) {
-	if (global_idx == Count()) {
-		local_block_index = radix_sorting_data.size() - 1;
-		local_entry_index = radix_sorting_data.back().count;
-		return;
-	}
-	D_ASSERT(global_idx < Count());
-	local_entry_index = global_idx;
-	for (local_block_index = 0; local_block_index < radix_sorting_data.size(); local_block_index++) {
-		const idx_t &block_count = radix_sorting_data[local_block_index].count;
-		if (local_entry_index >= block_count) {
-			local_entry_index -= block_count;
-		} else {
-			break;
-		}
-	}
-	D_ASSERT(local_entry_index < radix_sorting_data[local_block_index].count);
-}
-
-unique_ptr<SortedBlock> SortedBlock::CreateSlice(const idx_t start, const idx_t end, idx_t &entry_idx) {
-	// Identify blocks/entry indices of this slice
-	idx_t start_block_index;
-	idx_t start_entry_index;
-	GlobalToLocalIndex(start, start_block_index, start_entry_index);
-	idx_t end_block_index;
-	idx_t end_entry_index;
-	GlobalToLocalIndex(end, end_block_index, end_entry_index);
-	// Add the corresponding blocks to the result
-	auto result = make_unique<SortedBlock>(buffer_manager, state);
-	for (idx_t i = start_block_index; i <= end_block_index; i++) {
-		result->radix_sorting_data.push_back(radix_sorting_data[i]);
-	}
-	// Reset all blocks that come before block with idx = start_block_idx (slice holds new reference)
-	for (idx_t i = 0; i < start_block_index; i++) {
-		radix_sorting_data[i].block = nullptr;
-	}
-	// Use start and end entry indices to set the boundaries
-	entry_idx = start_entry_index;
-	D_ASSERT(end_entry_index <= result->radix_sorting_data.back().count);
-	result->radix_sorting_data.back().count = end_entry_index;
-	// Same for the var size sorting data
-	if (!sort_layout.all_constant) {
-		result->blob_sorting_data = blob_sorting_data->CreateSlice(start_block_index, end_block_index, end_entry_index);
-	}
-	// And the payload data
-	result->payload_data = payload_data->CreateSlice(start_block_index, end_block_index, end_entry_index);
-	return result;
-}
-
-idx_t SortedBlock::HeapSize() const {
-	idx_t result = 0;
-	if (!sort_layout.all_constant) {
-		for (auto &block : blob_sorting_data->heap_blocks) {
-			result += block.capacity;
-		}
-	}
-	if (!payload_layout.AllConstant()) {
-		for (auto &block : payload_data->heap_blocks) {
-			result += block.capacity;
-		}
-	}
-	return result;
-}
-
-idx_t SortedBlock::SizeInBytes() const {
-	idx_t bytes = 0;
-	for (idx_t i = 0; i < radix_sorting_data.size(); i++) {
-		bytes += radix_sorting_data[i].capacity * sort_layout.entry_size;
-		if (!sort_layout.all_constant) {
-			bytes += blob_sorting_data->data_blocks[i].capacity * sort_layout.blob_layout.GetRowWidth();
-			bytes += blob_sorting_data->heap_blocks[i].capacity;
-		}
-		bytes += payload_data->data_blocks[i].capacity * payload_layout.GetRowWidth();
-		if (!payload_layout.AllConstant()) {
-			bytes += payload_data->heap_blocks[i].capacity;
-		}
-	}
-	return bytes;
-}
-
-SBScanState::SBScanState(BufferManager &buffer_manager, GlobalSortState &state)
-    : buffer_manager(buffer_manager), sort_layout(state.sort_layout), state(state), block_idx(0), entry_idx(0) {
-}
-
-void SBScanState::PinRadix(idx_t block_idx_to) {
-	auto &radix_sorting_data = sb->radix_sorting_data;
-	D_ASSERT(block_idx_to < radix_sorting_data.size());
-	auto &block = radix_sorting_data[block_idx_to];
-	if (!radix_handle.IsValid() || radix_handle.GetBlockId() != block.block->BlockId()) {
-		radix_handle = buffer_manager.Pin(block.block);
-	}
-}
-
-void SBScanState::PinData(SortedData &sd) {
-	D_ASSERT(block_idx < sd.data_blocks.size());
-	auto &data_handle = sd.type == SortedDataType::BLOB ? blob_sorting_data_handle : payload_data_handle;
-	auto &heap_handle = sd.type == SortedDataType::BLOB ? blob_sorting_heap_handle : payload_heap_handle;
-
-	auto &data_block = sd.data_blocks[block_idx];
-	if (!data_handle.IsValid() || data_handle.GetBlockId() != data_block.block->BlockId()) {
-		data_handle = buffer_manager.Pin(data_block.block);
-	}
-	if (sd.layout.AllConstant() || !state.external) {
-		return;
-	}
-	auto &heap_block = sd.heap_blocks[block_idx];
-	if (!heap_handle.IsValid() || heap_handle.GetBlockId() != heap_block.block->BlockId()) {
-		heap_handle = buffer_manager.Pin(heap_block.block);
-	}
-}
-
-data_ptr_t SBScanState::RadixPtr() const {
-	return radix_handle.Ptr() + entry_idx * sort_layout.entry_size;
-}
-
-data_ptr_t SBScanState::DataPtr(SortedData &sd) const {
-	auto &data_handle = sd.type == SortedDataType::BLOB ? blob_sorting_data_handle : payload_data_handle;
-	D_ASSERT(sd.data_blocks[block_idx].block->Readers() != 0 &&
-	         data_handle.GetBlockId() == sd.data_blocks[block_idx].block->BlockId());
-	return data_handle.Ptr() + entry_idx * sd.layout.GetRowWidth();
-}
-
-data_ptr_t SBScanState::HeapPtr(SortedData &sd) const {
-	return BaseHeapPtr(sd) + Load<idx_t>(DataPtr(sd) + sd.layout.GetHeapPointerOffset());
-}
-
-data_ptr_t SBScanState::BaseHeapPtr(SortedData &sd) const {
-	auto &heap_handle = sd.type == SortedDataType::BLOB ? blob_sorting_heap_handle : payload_heap_handle;
-	D_ASSERT(!sd.layout.AllConstant() && state.external);
-	D_ASSERT(sd.heap_blocks[block_idx].block->Readers() != 0 &&
-	         heap_handle.GetBlockId() == sd.heap_blocks[block_idx].block->BlockId());
-	return heap_handle.Ptr();
-}
-
-idx_t SBScanState::Remaining() const {
-	const auto &blocks = sb->radix_sorting_data;
-	idx_t remaining = 0;
-	if (block_idx < blocks.size()) {
-		remaining += blocks[block_idx].count - entry_idx;
-		for (idx_t i = block_idx + 1; i < blocks.size(); i++) {
-			remaining += blocks[i].count;
-		}
-	}
-	return remaining;
-}
-
-void SBScanState::SetIndices(idx_t block_idx_to, idx_t entry_idx_to) {
-	block_idx = block_idx_to;
-	entry_idx = entry_idx_to;
-}
-
-PayloadScanner::PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state, bool flush_p)
-    : sorted_data(sorted_data), read_state(global_sort_state.buffer_manager, global_sort_state),
-      total_count(sorted_data.Count()), global_sort_state(global_sort_state), total_scanned(0), flush(flush_p) {
-}
-
-PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, bool flush_p)
-    : PayloadScanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state, flush_p) {
-}
-
-PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_idx)
-    : sorted_data(*global_sort_state.sorted_blocks[0]->payload_data),
-      read_state(global_sort_state.buffer_manager, global_sort_state),
-      total_count(sorted_data.data_blocks[block_idx].count), global_sort_state(global_sort_state), total_scanned(0),
-      flush(false) {
-	read_state.SetIndices(block_idx, 0);
-}
-
-void PayloadScanner::Scan(DataChunk &chunk) {
-	auto count = MinValue((idx_t)STANDARD_VECTOR_SIZE, total_count - total_scanned);
-	if (count == 0) {
-		chunk.SetCardinality(count);
-		return;
-	}
-	// Eagerly delete references to blocks that we've passed
-	if (flush) {
-		for (idx_t i = 0; i < read_state.block_idx; i++) {
-			sorted_data.data_blocks[i].block = nullptr;
-		}
-	}
-	const idx_t &row_width = sorted_data.layout.GetRowWidth();
-	// Set up a batch of pointers to scan data from
-	idx_t scanned = 0;
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	while (scanned < count) {
-		read_state.PinData(sorted_data);
-		auto &data_block = sorted_data.data_blocks[read_state.block_idx];
-		idx_t next = MinValue(data_block.count - read_state.entry_idx, count - scanned);
-		const data_ptr_t data_ptr = read_state.payload_data_handle.Ptr() + read_state.entry_idx * row_width;
-		// Set up the next pointers
-		data_ptr_t row_ptr = data_ptr;
-		for (idx_t i = 0; i < next; i++) {
-			data_pointers[scanned + i] = row_ptr;
-			row_ptr += row_width;
-		}
-		// Unswizzle the offsets back to pointers (if needed)
-		if (!sorted_data.layout.AllConstant() && global_sort_state.external) {
-			RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle.Ptr(), next);
-		}
-		// Update state indices
-		read_state.entry_idx += next;
-		if (read_state.entry_idx == data_block.count) {
-			read_state.block_idx++;
-			read_state.entry_idx = 0;
-		}
-		scanned += next;
-	}
-	D_ASSERT(scanned == count);
-	// Deserialize the payload data
-	for (idx_t col_idx = 0; col_idx < sorted_data.layout.ColumnCount(); col_idx++) {
-		const auto col_offset = sorted_data.layout.GetOffsets()[col_idx];
-		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), chunk.data[col_idx],
-		                      *FlatVector::IncrementalSelectionVector(), count, col_offset, col_idx);
-	}
-	chunk.SetCardinality(count);
-	chunk.Verify();
-	total_scanned += scanned;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#include <algorithm>
-#include <cctype>
-#include <iomanip>
-#include <memory>
-#include <sstream>
-#include <stdarg.h>
-#include <string.h>
-
-namespace duckdb {
-
-bool StringUtil::Contains(const string &haystack, const string &needle) {
-	return (haystack.find(needle) != string::npos);
-}
-
-void StringUtil::LTrim(string &str) {
-	auto it = str.begin();
-	while (CharacterIsSpace(*it)) {
-		it++;
-	}
-	str.erase(str.begin(), it);
-}
-
-// Remove trailing ' ', '\f', '\n', '\r', '\t', '\v'
-void StringUtil::RTrim(string &str) {
-	str.erase(find_if(str.rbegin(), str.rend(), [](int ch) { return ch > 0 && !CharacterIsSpace(ch); }).base(),
-	          str.end());
-}
-
-void StringUtil::Trim(string &str) {
-	StringUtil::LTrim(str);
-	StringUtil::RTrim(str);
-}
-
-bool StringUtil::StartsWith(string str, string prefix) {
-	if (prefix.size() > str.size()) {
-		return false;
-	}
-	return equal(prefix.begin(), prefix.end(), str.begin());
-}
-
-bool StringUtil::EndsWith(const string &str, const string &suffix) {
-	if (suffix.size() > str.size()) {
-		return false;
-	}
-	return equal(suffix.rbegin(), suffix.rend(), str.rbegin());
-}
-
-string StringUtil::Repeat(const string &str, idx_t n) {
-	std::ostringstream os;
-	for (idx_t i = 0; i < n; i++) {
-		os << str;
-	}
-	return (os.str());
-}
-
-vector<string> StringUtil::Split(const string &str, char delimiter) {
-	std::stringstream ss(str);
-	vector<string> lines;
-	string temp;
-	while (getline(ss, temp, delimiter)) {
-		lines.push_back(temp);
-	}
-	return (lines);
-}
-
-namespace string_util_internal {
-
-inline void SkipSpaces(const string &str, idx_t &index) {
-	while (index < str.size() && std::isspace(str[index])) {
-		index++;
-	}
-}
-
-inline void ConsumeLetter(const string &str, idx_t &index, char expected) {
-	if (index >= str.size() || str[index] != expected) {
-		throw ParserException("Invalid quoted list: %s", str);
-	}
-
-	index++;
-}
-
-template <typename F>
-inline void TakeWhile(const string &str, idx_t &index, const F &cond, string &taker) {
-	while (index < str.size() && cond(str[index])) {
-		taker.push_back(str[index]);
-		index++;
-	}
-}
-
-inline string TakePossiblyQuotedItem(const string &str, idx_t &index, char delimiter, char quote) {
-	string entry;
-
-	if (str[index] == quote) {
-		index++;
-		TakeWhile(
-		    str, index, [quote](char c) { return c != quote; }, entry);
-		ConsumeLetter(str, index, quote);
-	} else {
-		TakeWhile(
-		    str, index, [delimiter, quote](char c) { return c != delimiter && c != quote && !std::isspace(c); }, entry);
-	}
-
-	return entry;
-}
-
-} // namespace string_util_internal
-
-vector<string> StringUtil::SplitWithQuote(const string &str, char delimiter, char quote) {
-	vector<string> entries;
-	idx_t i = 0;
-
-	string_util_internal::SkipSpaces(str, i);
-	while (i < str.size()) {
-		if (!entries.empty()) {
-			string_util_internal::ConsumeLetter(str, i, delimiter);
-		}
-
-		entries.emplace_back(string_util_internal::TakePossiblyQuotedItem(str, i, delimiter, quote));
-		string_util_internal::SkipSpaces(str, i);
-	}
-
-	return entries;
-}
-
-string StringUtil::Join(const vector<string> &input, const string &separator) {
-	return StringUtil::Join(input, input.size(), separator, [](const string &s) { return s; });
-}
-
-string StringUtil::BytesToHumanReadableString(idx_t bytes) {
-	string db_size;
-	auto kilobytes = bytes / 1000;
-	auto megabytes = kilobytes / 1000;
-	kilobytes -= megabytes * 1000;
-	auto gigabytes = megabytes / 1000;
-	megabytes -= gigabytes * 1000;
-	auto terabytes = gigabytes / 1000;
-	gigabytes -= terabytes * 1000;
-	if (terabytes > 0) {
-		return to_string(terabytes) + "." + to_string(gigabytes / 100) + "TB";
-	} else if (gigabytes > 0) {
-		return to_string(gigabytes) + "." + to_string(megabytes / 100) + "GB";
-	} else if (megabytes > 0) {
-		return to_string(megabytes) + "." + to_string(kilobytes / 100) + "MB";
-	} else if (kilobytes > 0) {
-		return to_string(kilobytes) + "KB";
-	} else {
-		return to_string(bytes) + " bytes";
-	}
-}
-
-string StringUtil::Upper(const string &str) {
-	string copy(str);
-	transform(copy.begin(), copy.end(), copy.begin(), [](unsigned char c) { return std::toupper(c); });
-	return (copy);
-}
-
-string StringUtil::Lower(const string &str) {
-	string copy(str);
-	transform(copy.begin(), copy.end(), copy.begin(), [](unsigned char c) { return std::tolower(c); });
-	return (copy);
-}
-
-vector<string> StringUtil::Split(const string &input, const string &split) {
-	vector<string> splits;
-
-	idx_t last = 0;
-	idx_t input_len = input.size();
-	idx_t split_len = split.size();
-	while (last <= input_len) {
-		idx_t next = input.find(split, last);
-		if (next == string::npos) {
-			next = input_len;
-		}
-
-		// Push the substring [last, next) on to splits
-		string substr = input.substr(last, next - last);
-		if (substr.empty() == false) {
-			splits.push_back(substr);
-		}
-		last = next + split_len;
-	}
-	return splits;
-}
-
-string StringUtil::Replace(string source, const string &from, const string &to) {
-	idx_t start_pos = 0;
-	while ((start_pos = source.find(from, start_pos)) != string::npos) {
-		source.replace(start_pos, from.length(), to);
-		start_pos += to.length(); // In case 'to' contains 'from', like
-		                          // replacing 'x' with 'yx'
-	}
-	return source;
-}
-
-vector<string> StringUtil::TopNStrings(vector<pair<string, idx_t>> scores, idx_t n, idx_t threshold) {
-	if (scores.empty()) {
-		return vector<string>();
-	}
-	sort(scores.begin(), scores.end(),
-	     [](const pair<string, idx_t> &a, const pair<string, idx_t> &b) -> bool { return a.second < b.second; });
-	vector<string> result;
-	result.push_back(scores[0].first);
-	for (idx_t i = 1; i < MinValue<idx_t>(scores.size(), n); i++) {
-		if (scores[i].second > threshold) {
-			break;
-		}
-		result.push_back(scores[i].first);
-	}
-	return result;
-}
-
-struct LevenshteinArray {
-	LevenshteinArray(idx_t len1, idx_t len2) : len1(len1) {
-		dist = unique_ptr<idx_t[]>(new idx_t[len1 * len2]);
-	}
-
-	idx_t &Score(idx_t i, idx_t j) {
-		return dist[GetIndex(i, j)];
-	}
-
-private:
-	idx_t len1;
-	unique_ptr<idx_t[]> dist;
-
-	idx_t GetIndex(idx_t i, idx_t j) {
-		return j * len1 + i;
-	}
-};
-
-// adapted from https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#C++
-idx_t StringUtil::LevenshteinDistance(const string &s1_p, const string &s2_p) {
-	auto s1 = StringUtil::Lower(s1_p);
-	auto s2 = StringUtil::Lower(s2_p);
-	idx_t len1 = s1.size();
-	idx_t len2 = s2.size();
-	if (len1 == 0) {
-		return len2;
-	}
-	if (len2 == 0) {
-		return len1;
-	}
-	LevenshteinArray array(len1 + 1, len2 + 1);
-	array.Score(0, 0) = 0;
-	for (idx_t i = 0; i <= len1; i++) {
-		array.Score(i, 0) = i;
-	}
-	for (idx_t j = 0; j <= len2; j++) {
-		array.Score(0, j) = j;
-	}
-	for (idx_t i = 1; i <= len1; i++) {
-		for (idx_t j = 1; j <= len2; j++) {
-			// d[i][j] = std::min({ d[i - 1][j] + 1,
-			//                      d[i][j - 1] + 1,
-			//                      d[i - 1][j - 1] + (s1[i - 1] == s2[j - 1] ? 0 : 1) });
-			int equal = s1[i - 1] == s2[j - 1] ? 0 : 1;
-			idx_t adjacent_score1 = array.Score(i - 1, j) + 1;
-			idx_t adjacent_score2 = array.Score(i, j - 1) + 1;
-			idx_t adjacent_score3 = array.Score(i - 1, j - 1) + equal;
-
-			idx_t t = MinValue<idx_t>(adjacent_score1, adjacent_score2);
-			array.Score(i, j) = MinValue<idx_t>(t, adjacent_score3);
-		}
-	}
-	return array.Score(len1, len2);
-}
-
-vector<string> StringUtil::TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n,
-                                           idx_t threshold) {
-	vector<pair<string, idx_t>> scores;
-	scores.reserve(strings.size());
-	for (auto &str : strings) {
-		scores.emplace_back(str, LevenshteinDistance(str, target));
-	}
-	return TopNStrings(scores, n, threshold);
-}
-
-string StringUtil::CandidatesMessage(const vector<string> &candidates, const string &candidate) {
-	string result_str;
-	if (!candidates.empty()) {
-		result_str = "\n" + candidate + ": ";
-		for (idx_t i = 0; i < candidates.size(); i++) {
-			if (i > 0) {
-				result_str += ", ";
-			}
-			result_str += "\"" + candidates[i] + "\"";
-		}
-	}
-	return result_str;
-}
-
-string StringUtil::CandidatesErrorMessage(const vector<string> &strings, const string &target,
-                                          const string &message_prefix, idx_t n) {
-	auto closest_strings = StringUtil::TopNLevenshtein(strings, target, n);
-	return StringUtil::CandidatesMessage(closest_strings, message_prefix);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-#include <sstream>
-
-namespace duckdb {
-
-RenderTree::RenderTree(idx_t width_p, idx_t height_p) : width(width_p), height(height_p) {
-	nodes = unique_ptr<unique_ptr<RenderTreeNode>[]>(new unique_ptr<RenderTreeNode>[(width + 1) * (height + 1)]);
-}
-
-RenderTreeNode *RenderTree::GetNode(idx_t x, idx_t y) {
-	if (x >= width || y >= height) {
-		return nullptr;
-	}
-	return nodes[GetPosition(x, y)].get();
-}
-
-bool RenderTree::HasNode(idx_t x, idx_t y) {
-	if (x >= width || y >= height) {
-		return false;
-	}
-	return nodes[GetPosition(x, y)].get() != nullptr;
-}
-
-idx_t RenderTree::GetPosition(idx_t x, idx_t y) {
-	return y * width + x;
-}
-
-void RenderTree::SetNode(idx_t x, idx_t y, unique_ptr<RenderTreeNode> node) {
-	nodes[GetPosition(x, y)] = move(node);
-}
-
-void TreeRenderer::RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y) {
-	for (idx_t x = 0; x < root.width; x++) {
-		if (x * config.NODE_RENDER_WIDTH >= config.MAXIMUM_RENDER_WIDTH) {
-			break;
-		}
-		if (root.HasNode(x, y)) {
-			ss << config.LTCORNER;
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2 - 1);
-			if (y == 0) {
-				// top level node: no node above this one
-				ss << config.HORIZONTAL;
-			} else {
-				// render connection to node above this one
-				ss << config.DMIDDLE;
-			}
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2 - 1);
-			ss << config.RTCORNER;
-		} else {
-			ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
-		}
-	}
-	ss << std::endl;
-}
-
-void TreeRenderer::RenderBottomLayer(RenderTree &root, std::ostream &ss, idx_t y) {
-	for (idx_t x = 0; x <= root.width; x++) {
-		if (x * config.NODE_RENDER_WIDTH >= config.MAXIMUM_RENDER_WIDTH) {
-			break;
-		}
-		if (root.HasNode(x, y)) {
-			ss << config.LDCORNER;
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2 - 1);
-			if (root.HasNode(x, y + 1)) {
-				// node below this one: connect to that one
-				ss << config.TMIDDLE;
-			} else {
-				// no node below this one: end the box
-				ss << config.HORIZONTAL;
-			}
-			ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2 - 1);
-			ss << config.RDCORNER;
-		} else if (root.HasNode(x, y + 1)) {
-			ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
-			ss << config.VERTICAL;
-			ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
-		} else {
-			ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
-		}
-	}
-	ss << std::endl;
-}
-
-string AdjustTextForRendering(string source, idx_t max_render_width) {
-	idx_t cpos = 0;
-	idx_t render_width = 0;
-	vector<pair<idx_t, idx_t>> render_widths;
-	while (cpos < source.size()) {
-		idx_t char_render_width = Utf8Proc::RenderWidth(source.c_str(), source.size(), cpos);
-		cpos = Utf8Proc::NextGraphemeCluster(source.c_str(), source.size(), cpos);
-		render_width += char_render_width;
-		render_widths.emplace_back(cpos, render_width);
-		if (render_width > max_render_width) {
-			break;
-		}
-	}
-	if (render_width > max_render_width) {
-		// need to find a position to truncate
-		for (idx_t pos = render_widths.size(); pos > 0; pos--) {
-			if (render_widths[pos - 1].second < max_render_width - 4) {
-				return source.substr(0, render_widths[pos - 1].first) + "..." +
-				       string(max_render_width - render_widths[pos - 1].second - 3, ' ');
-			}
-		}
-		source = "...";
-	}
-	// need to pad with spaces
-	idx_t total_spaces = max_render_width - render_width;
-	idx_t half_spaces = total_spaces / 2;
-	idx_t extra_left_space = total_spaces % 2 == 0 ? 0 : 1;
-	return string(half_spaces + extra_left_space, ' ') + source + string(half_spaces, ' ');
-}
-
-static bool NodeHasMultipleChildren(RenderTree &root, idx_t x, idx_t y) {
-	for (; x < root.width && !root.HasNode(x + 1, y); x++) {
-		if (root.HasNode(x + 1, y + 1)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-void TreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y) {
-	// we first need to figure out how high our boxes are going to be
-	vector<vector<string>> extra_info;
-	idx_t extra_height = 0;
-	extra_info.resize(root.width);
-	for (idx_t x = 0; x < root.width; x++) {
-		auto node = root.GetNode(x, y);
-		if (node) {
-			SplitUpExtraInfo(node->extra_text, extra_info[x]);
-			if (extra_info[x].size() > extra_height) {
-				extra_height = extra_info[x].size();
-			}
-		}
-	}
-	extra_height = MinValue<idx_t>(extra_height, config.MAX_EXTRA_LINES);
-	idx_t halfway_point = (extra_height + 1) / 2;
-	// now we render the actual node
-	for (idx_t render_y = 0; render_y <= extra_height; render_y++) {
-		for (idx_t x = 0; x < root.width; x++) {
-			if (x * config.NODE_RENDER_WIDTH >= config.MAXIMUM_RENDER_WIDTH) {
-				break;
-			}
-			auto node = root.GetNode(x, y);
-			if (!node) {
-				if (render_y == halfway_point) {
-					bool has_child_to_the_right = NodeHasMultipleChildren(root, x, y);
-					if (root.HasNode(x, y + 1)) {
-						// node right below this one
-						ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2);
-						ss << config.RTCORNER;
-						if (has_child_to_the_right) {
-							// but we have another child to the right! keep rendering the line
-							ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH / 2);
-						} else {
-							// only a child below this one: fill the rest with spaces
-							ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
-						}
-					} else if (has_child_to_the_right) {
-						// child to the right, but no child right below this one: render a full line
-						ss << StringUtil::Repeat(config.HORIZONTAL, config.NODE_RENDER_WIDTH);
-					} else {
-						// empty spot: render spaces
-						ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
-					}
-				} else if (render_y >= halfway_point) {
-					if (root.HasNode(x, y + 1)) {
-						// we have a node below this empty spot: render a vertical line
-						ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
-						ss << config.VERTICAL;
-						ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH / 2);
-					} else {
-						// empty spot: render spaces
-						ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
-					}
-				} else {
-					// empty spot: render spaces
-					ss << StringUtil::Repeat(" ", config.NODE_RENDER_WIDTH);
-				}
-			} else {
-				ss << config.VERTICAL;
-				// figure out what to render
-				string render_text;
-				if (render_y == 0) {
-					render_text = node->name;
-				} else {
-					if (render_y <= extra_info[x].size()) {
-						render_text = extra_info[x][render_y - 1];
-					}
-				}
-				render_text = AdjustTextForRendering(render_text, config.NODE_RENDER_WIDTH - 2);
-				ss << render_text;
-
-				if (render_y == halfway_point && NodeHasMultipleChildren(root, x, y)) {
-					ss << config.LMIDDLE;
-				} else {
-					ss << config.VERTICAL;
-				}
-			}
-		}
-		ss << std::endl;
-	}
-}
-
-string TreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string TreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string TreeRenderer::ToString(const QueryProfiler::TreeNode &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-string TreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
-	Render(op, ss);
-	return ss.str();
-}
-
-void TreeRenderer::Render(const LogicalOperator &op, std::ostream &ss) {
-	auto tree = CreateTree(op);
-	ToStream(*tree, ss);
-}
-
-void TreeRenderer::Render(const PhysicalOperator &op, std::ostream &ss) {
-	auto tree = CreateTree(op);
-	ToStream(*tree, ss);
-}
-
-void TreeRenderer::Render(const QueryProfiler::TreeNode &op, std::ostream &ss) {
-	auto tree = CreateTree(op);
-	ToStream(*tree, ss);
-}
-
-void TreeRenderer::Render(const Pipeline &op, std::ostream &ss) {
-	auto tree = CreateTree(op);
-	ToStream(*tree, ss);
-}
-
-void TreeRenderer::ToStream(RenderTree &root, std::ostream &ss) {
-	while (root.width * config.NODE_RENDER_WIDTH > config.MAXIMUM_RENDER_WIDTH) {
-		if (config.NODE_RENDER_WIDTH - 2 < config.MINIMUM_RENDER_WIDTH) {
-			break;
-		}
-		config.NODE_RENDER_WIDTH -= 2;
-	}
-
-	for (idx_t y = 0; y < root.height; y++) {
-		// start by rendering the top layer
-		RenderTopLayer(root, ss, y);
-		// now we render the content of the boxes
-		RenderBoxContent(root, ss, y);
-		// render the bottom layer of each of the boxes
-		RenderBottomLayer(root, ss, y);
-	}
-}
-
-bool TreeRenderer::CanSplitOnThisChar(char l) {
-	return (l < '0' || (l > '9' && l < 'A') || (l > 'Z' && l < 'a')) && l != '_';
-}
-
-bool TreeRenderer::IsPadding(char l) {
-	return l == ' ' || l == '\t' || l == '\n' || l == '\r';
-}
-
-string TreeRenderer::RemovePadding(string l) {
-	idx_t start = 0, end = l.size();
-	while (start < l.size() && IsPadding(l[start])) {
-		start++;
-	}
-	while (end > 0 && IsPadding(l[end - 1])) {
-		end--;
-	}
-	return l.substr(start, end - start);
-}
-
-void TreeRenderer::SplitStringBuffer(const string &source, vector<string> &result) {
-	D_ASSERT(Utf8Proc::IsValid(source.c_str(), source.size()));
-	idx_t max_line_render_size = config.NODE_RENDER_WIDTH - 2;
-	// utf8 in prompt, get render width
-	idx_t cpos = 0;
-	idx_t start_pos = 0;
-	idx_t render_width = 0;
-	idx_t last_possible_split = 0;
-	while (cpos < source.size()) {
-		// check if we can split on this character
-		if (CanSplitOnThisChar(source[cpos])) {
-			last_possible_split = cpos;
-		}
-		size_t char_render_width = Utf8Proc::RenderWidth(source.c_str(), source.size(), cpos);
-		idx_t next_cpos = Utf8Proc::NextGraphemeCluster(source.c_str(), source.size(), cpos);
-		if (render_width + char_render_width > max_line_render_size) {
-			if (last_possible_split <= start_pos + 8) {
-				last_possible_split = cpos;
-			}
-			result.push_back(source.substr(start_pos, last_possible_split - start_pos));
-			start_pos = last_possible_split;
-			cpos = last_possible_split;
-			render_width = 0;
-		}
-		cpos = next_cpos;
-		render_width += char_render_width;
-	}
-	if (source.size() > start_pos) {
-		result.push_back(source.substr(start_pos, source.size() - start_pos));
-	}
-}
-
-void TreeRenderer::SplitUpExtraInfo(const string &extra_info, vector<string> &result) {
-	if (extra_info.empty()) {
-		return;
-	}
-	if (!Utf8Proc::IsValid(extra_info.c_str(), extra_info.size())) {
-		return;
-	}
-	auto splits = StringUtil::Split(extra_info, "\n");
-	if (!splits.empty() && splits[0] != "[INFOSEPARATOR]") {
-		result.push_back(ExtraInfoSeparator());
-	}
-	for (auto &split : splits) {
-		if (split == "[INFOSEPARATOR]") {
-			result.push_back(ExtraInfoSeparator());
-			continue;
-		}
-		string str = RemovePadding(split);
-		if (str.empty()) {
-			continue;
-		}
-		SplitStringBuffer(str, result);
-	}
-}
-
-string TreeRenderer::ExtraInfoSeparator() {
-	return StringUtil::Repeat(string(config.HORIZONTAL) + " ", (config.NODE_RENDER_WIDTH - 7) / 2);
-}
-
-unique_ptr<RenderTreeNode> TreeRenderer::CreateRenderNode(string name, string extra_info) {
-	auto result = make_unique<RenderTreeNode>();
-	result->name = move(name);
-	result->extra_text = move(extra_info);
-	return result;
-}
-
-class TreeChildrenIterator {
-public:
-	template <class T>
-	static bool HasChildren(const T &op) {
-		return !op.children.empty();
-	}
-	template <class T>
-	static void Iterate(const T &op, const std::function<void(const T &child)> &callback) {
-		for (auto &child : op.children) {
-			callback(*child);
-		}
-	}
-};
-
-template <>
-bool TreeChildrenIterator::HasChildren(const PhysicalOperator &op) {
-	if (op.type == PhysicalOperatorType::DELIM_JOIN) {
-		return true;
-	}
-	return !op.children.empty();
-}
-template <>
-void TreeChildrenIterator::Iterate(const PhysicalOperator &op,
-                                   const std::function<void(const PhysicalOperator &child)> &callback) {
-	for (auto &child : op.children) {
-		callback(*child);
-	}
-	if (op.type == PhysicalOperatorType::DELIM_JOIN) {
-		auto &delim = (PhysicalDelimJoin &)op;
-		callback(*delim.join);
-	}
-}
-
-struct PipelineRenderNode {
-	explicit PipelineRenderNode(PhysicalOperator &op) : op(op) {
-	}
-
-	PhysicalOperator &op;
-	unique_ptr<PipelineRenderNode> child;
-};
-
-template <>
-bool TreeChildrenIterator::HasChildren(const PipelineRenderNode &op) {
-	return op.child.get();
-}
-
-template <>
-void TreeChildrenIterator::Iterate(const PipelineRenderNode &op,
-                                   const std::function<void(const PipelineRenderNode &child)> &callback) {
-	if (op.child) {
-		callback(*op.child);
-	}
-}
-
-template <class T>
-static void GetTreeWidthHeight(const T &op, idx_t &width, idx_t &height) {
-	if (!TreeChildrenIterator::HasChildren(op)) {
-		width = 1;
-		height = 1;
-		return;
-	}
-	width = 0;
-	height = 0;
-
-	TreeChildrenIterator::Iterate<T>(op, [&](const T &child) {
-		idx_t child_width, child_height;
-		GetTreeWidthHeight<T>(child, child_width, child_height);
-		width += child_width;
-		height = MaxValue<idx_t>(height, child_height);
-	});
-	height++;
-}
-
-template <class T>
-idx_t TreeRenderer::CreateRenderTreeRecursive(RenderTree &result, const T &op, idx_t x, idx_t y) {
-	auto node = TreeRenderer::CreateNode(op);
-	result.SetNode(x, y, move(node));
-
-	if (!TreeChildrenIterator::HasChildren(op)) {
-		return 1;
-	}
-	idx_t width = 0;
-	// render the children of this node
-	TreeChildrenIterator::Iterate<T>(
-	    op, [&](const T &child) { width += CreateRenderTreeRecursive<T>(result, child, x + width, y + 1); });
-	return width;
-}
-
-template <class T>
-unique_ptr<RenderTree> TreeRenderer::CreateRenderTree(const T &op) {
-	idx_t width, height;
-	GetTreeWidthHeight<T>(op, width, height);
-
-	auto result = make_unique<RenderTree>(width, height);
-
-	// now fill in the tree
-	CreateRenderTreeRecursive<T>(*result, op, 0, 0);
-	return result;
-}
-
-unique_ptr<RenderTreeNode> TreeRenderer::CreateNode(const LogicalOperator &op) {
-	return CreateRenderNode(op.GetName(), op.ParamsToString());
-}
-
-unique_ptr<RenderTreeNode> TreeRenderer::CreateNode(const PhysicalOperator &op) {
-	return CreateRenderNode(op.GetName(), op.ParamsToString());
-}
-
-unique_ptr<RenderTreeNode> TreeRenderer::CreateNode(const PipelineRenderNode &op) {
-	return CreateNode(op.op);
-}
-
-string TreeRenderer::ExtractExpressionsRecursive(ExpressionInfo &state) {
-	string result = "\n[INFOSEPARATOR]";
-	result += "\n" + state.function_name;
-	result += "\n" + StringUtil::Format("%.9f", double(state.function_time));
-	if (state.children.empty()) {
-		return result;
-	}
-	// render the children of this node
-	for (auto &child : state.children) {
-		result += ExtractExpressionsRecursive(*child);
-	}
-	return result;
-}
-
-unique_ptr<RenderTreeNode> TreeRenderer::CreateNode(const QueryProfiler::TreeNode &op) {
-	auto result = TreeRenderer::CreateRenderNode(op.name, op.extra_info);
-	result->extra_text += "\n[INFOSEPARATOR]";
-	result->extra_text += "\n" + to_string(op.info.elements);
-	string timing = StringUtil::Format("%.2f", op.info.time);
-	result->extra_text += "\n(" + timing + "s)";
-	if (config.detailed) {
-		for (auto &info : op.info.executors_info) {
-			if (!info) {
-				continue;
-			}
-			for (auto &executor_info : info->roots) {
-				string sample_count = to_string(executor_info->sample_count);
-				result->extra_text += "\n[INFOSEPARATOR]";
-				result->extra_text += "\nsample_count: " + sample_count;
-				string sample_tuples_count = to_string(executor_info->sample_tuples_count);
-				result->extra_text += "\n[INFOSEPARATOR]";
-				result->extra_text += "\nsample_tuples_count: " + sample_tuples_count;
-				string total_count = to_string(executor_info->total_count);
-				result->extra_text += "\n[INFOSEPARATOR]";
-				result->extra_text += "\ntotal_count: " + total_count;
-				for (auto &state : executor_info->root->children) {
-					result->extra_text += ExtractExpressionsRecursive(*state);
-				}
-			}
-		}
-	}
-	return result;
-}
-
-unique_ptr<RenderTree> TreeRenderer::CreateTree(const LogicalOperator &op) {
-	return CreateRenderTree<LogicalOperator>(op);
-}
-
-unique_ptr<RenderTree> TreeRenderer::CreateTree(const PhysicalOperator &op) {
-	return CreateRenderTree<PhysicalOperator>(op);
-}
-
-unique_ptr<RenderTree> TreeRenderer::CreateTree(const QueryProfiler::TreeNode &op) {
-	return CreateRenderTree<QueryProfiler::TreeNode>(op);
-}
-
-unique_ptr<RenderTree> TreeRenderer::CreateTree(const Pipeline &op) {
-	auto operators = op.GetOperators();
-	D_ASSERT(!operators.empty());
-	unique_ptr<PipelineRenderNode> node;
-	for (auto &op : operators) {
-		auto new_node = make_unique<PipelineRenderNode>(*op);
-		new_node->child = move(node);
-		node = move(new_node);
-	}
-	return CreateRenderTree<PipelineRenderNode>(*node);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-BatchedChunkCollection::BatchedChunkCollection(Allocator &allocator) : allocator(allocator) {
-}
-
-void BatchedChunkCollection::Append(DataChunk &input, idx_t batch_index) {
-	D_ASSERT(batch_index != DConstants::INVALID_INDEX);
-	auto entry = data.find(batch_index);
-	ChunkCollection *collection;
-	if (entry == data.end()) {
-		auto new_collection = make_unique<ChunkCollection>(allocator);
-		collection = new_collection.get();
-		data.insert(make_pair(batch_index, move(new_collection)));
-	} else {
-		collection = entry->second.get();
-	}
-	collection->Append(input);
-}
-
-void BatchedChunkCollection::Merge(BatchedChunkCollection &other) {
-	for (auto &entry : other.data) {
-		if (data.find(entry.first) != data.end()) {
-			throw InternalException(
-			    "BatchChunkCollection::Merge error - batch index %d is present in both collections. This occurs when "
-			    "batch indexes are not uniquely distributed over threads",
-			    entry.first);
-		}
-		data[entry.first] = move(entry.second);
-	}
-	other.data.clear();
-}
-
-void BatchedChunkCollection::InitializeScan(BatchedChunkScanState &state) {
-	state.iterator = data.begin();
-	state.chunk_index = 0;
-}
-
-void BatchedChunkCollection::Scan(BatchedChunkScanState &state, DataChunk &output) {
-	while (state.iterator != data.end()) {
-		// check if there is a chunk remaining in this collection
-		auto collection = state.iterator->second.get();
-		if (state.chunk_index < collection->ChunkCount()) {
-			// there is! increment the chunk count
-			output.Reference(collection->GetChunk(state.chunk_index));
-			state.chunk_index++;
-			return;
-		}
-		// there isn't! move to the next collection
-		state.iterator++;
-		state.chunk_index = 0;
-	}
-}
-
-string BatchedChunkCollection::ToString() const {
-	string result;
-	result += "Batched Chunk Collection\n";
-	for (auto &entry : data) {
-		result += "Batch Index - " + to_string(entry.first) + "\n";
-		result += entry.second->ToString() + "\n\n";
-	}
-	return result;
-}
-
-void BatchedChunkCollection::Print() const {
-	Printer::Print(ToString());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-constexpr const char *Blob::HEX_TABLE;
-const int Blob::HEX_MAP[256] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
-    -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-
-idx_t Blob::GetStringSize(string_t blob) {
-	auto data = (const_data_ptr_t)blob.GetDataUnsafe();
-	auto len = blob.GetSize();
-	idx_t str_len = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] >= 32 && data[i] <= 127 && data[i] != '\\') {
-			// ascii characters are rendered as-is
-			str_len++;
-		} else {
-			// non-ascii characters are rendered as hexadecimal (e.g. \x00)
-			str_len += 4;
-		}
-	}
-	return str_len;
-}
-
-void Blob::ToString(string_t blob, char *output) {
-	auto data = (const_data_ptr_t)blob.GetDataUnsafe();
-	auto len = blob.GetSize();
-	idx_t str_idx = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] >= 32 && data[i] <= 127 && data[i] != '\\') {
-			// ascii characters are rendered as-is
-			output[str_idx++] = data[i];
-		} else {
-			auto byte_a = data[i] >> 4;
-			auto byte_b = data[i] & 0x0F;
-			D_ASSERT(byte_a >= 0 && byte_a < 16);
-			D_ASSERT(byte_b >= 0 && byte_b < 16);
-			// non-ascii characters are rendered as hexadecimal (e.g. \x00)
-			output[str_idx++] = '\\';
-			output[str_idx++] = 'x';
-			output[str_idx++] = Blob::HEX_TABLE[byte_a];
-			output[str_idx++] = Blob::HEX_TABLE[byte_b];
-		}
-	}
-	D_ASSERT(str_idx == GetStringSize(blob));
-}
-
-string Blob::ToString(string_t blob) {
-	auto str_len = GetStringSize(blob);
-	auto buffer = std::unique_ptr<char[]>(new char[str_len]);
-	Blob::ToString(blob, buffer.get());
-	return string(buffer.get(), str_len);
-}
-
-bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
-	auto len = str.GetSize();
-	str_len = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] == '\\') {
-			if (i + 3 >= len) {
-				string error = "Invalid hex escape code encountered in string -> blob conversion: "
-				               "unterminated escape code at end of blob";
-				HandleCastError::AssignError(error, error_message);
-				return false;
-			}
-			if (data[i + 1] != 'x' || Blob::HEX_MAP[data[i + 2]] < 0 || Blob::HEX_MAP[data[i + 3]] < 0) {
-				string error =
-				    StringUtil::Format("Invalid hex escape code encountered in string -> blob conversion: %s",
-				                       string((char *)data + i, 4));
-				HandleCastError::AssignError(error, error_message);
-				return false;
-			}
-			str_len++;
-			i += 3;
-		} else if (data[i] >= 32 && data[i] <= 127) {
-			str_len++;
-		} else {
-			string error = "Invalid byte encountered in STRING -> BLOB conversion. All non-ascii characters "
-			               "must be escaped with hex codes (e.g. \\xAA)";
-			HandleCastError::AssignError(error, error_message);
-			return false;
-		}
-	}
-	return true;
-}
-
-idx_t Blob::GetBlobSize(string_t str) {
-	string error_message;
-	idx_t str_len;
-	if (!Blob::TryGetBlobSize(str, str_len, &error_message)) {
-		throw ConversionException(error_message);
-	}
-	return str_len;
-}
-
-void Blob::ToBlob(string_t str, data_ptr_t output) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
-	auto len = str.GetSize();
-	idx_t blob_idx = 0;
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] == '\\') {
-			int byte_a = Blob::HEX_MAP[data[i + 2]];
-			int byte_b = Blob::HEX_MAP[data[i + 3]];
-			D_ASSERT(i + 3 < len);
-			D_ASSERT(byte_a >= 0 && byte_b >= 0);
-			D_ASSERT(data[i + 1] == 'x');
-			output[blob_idx++] = (byte_a << 4) + byte_b;
-			i += 3;
-		} else if (data[i] >= 32 && data[i] <= 127) {
-			output[blob_idx++] = data_t(data[i]);
-		} else {
-			throw ConversionException("Invalid byte encountered in STRING -> BLOB conversion. All non-ascii characters "
-			                          "must be escaped with hex codes (e.g. \\xAA)");
-		}
-	}
-	D_ASSERT(blob_idx == GetBlobSize(str));
-}
-
-string Blob::ToBlob(string_t str) {
-	auto blob_len = GetBlobSize(str);
-	auto buffer = std::unique_ptr<char[]>(new char[blob_len]);
-	Blob::ToBlob(str, (data_ptr_t)buffer.get());
-	return string(buffer.get(), blob_len);
-}
-
-// base64 functions are adapted from https://gist.github.com/tomykaira/f0fd86b6c73063283afe550bc5d77594
-idx_t Blob::ToBase64Size(string_t blob) {
-	// every 4 characters in base64 encode 3 bytes, plus (potential) padding at the end
-	auto input_size = blob.GetSize();
-	return ((input_size + 2) / 3) * 4;
-}
-
-void Blob::ToBase64(string_t blob, char *output) {
-	auto input_data = (const_data_ptr_t)blob.GetDataUnsafe();
-	auto input_size = blob.GetSize();
-	idx_t out_idx = 0;
-	idx_t i;
-	// convert the bulk of the string to base64
-	// this happens in steps of 3 bytes -> 4 output bytes
-	for (i = 0; i + 2 < input_size; i += 3) {
-		output[out_idx++] = Blob::BASE64_MAP[(input_data[i] >> 2) & 0x3F];
-		output[out_idx++] = Blob::BASE64_MAP[((input_data[i] & 0x3) << 4) | ((input_data[i + 1] & 0xF0) >> 4)];
-		output[out_idx++] = Blob::BASE64_MAP[((input_data[i + 1] & 0xF) << 2) | ((input_data[i + 2] & 0xC0) >> 6)];
-		output[out_idx++] = Blob::BASE64_MAP[input_data[i + 2] & 0x3F];
-	}
-
-	if (i < input_size) {
-		// there are one or two bytes left over: we have to insert padding
-		// first write the first 6 bits of the first byte
-		output[out_idx++] = Blob::BASE64_MAP[(input_data[i] >> 2) & 0x3F];
-		// now check the character count
-		if (i == input_size - 1) {
-			// single byte left over: convert the remainder of that byte and insert padding
-			output[out_idx++] = Blob::BASE64_MAP[((input_data[i] & 0x3) << 4)];
-			output[out_idx++] = Blob::BASE64_PADDING;
-		} else {
-			// two bytes left over: convert the second byte as well
-			output[out_idx++] = Blob::BASE64_MAP[((input_data[i] & 0x3) << 4) | ((input_data[i + 1] & 0xF0) >> 4)];
-			output[out_idx++] = Blob::BASE64_MAP[((input_data[i + 1] & 0xF) << 2)];
-		}
-		output[out_idx++] = Blob::BASE64_PADDING;
-	}
-}
-
-static constexpr int BASE64_DECODING_TABLE[256] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-    -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-    22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
-    45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-
-idx_t Blob::FromBase64Size(string_t str) {
-	auto input_data = str.GetDataUnsafe();
-	auto input_size = str.GetSize();
-	if (input_size % 4 != 0) {
-		// valid base64 needs to always be cleanly divisible by 4
-		throw ConversionException("Could not decode string \"%s\" as base64: length must be a multiple of 4",
-		                          str.GetString());
-	}
-	if (input_size < 4) {
-		// empty string
-		return 0;
-	}
-	auto base_size = input_size / 4 * 3;
-	// check for padding to figure out the length
-	if (input_data[input_size - 2] == Blob::BASE64_PADDING) {
-		// two bytes of padding
-		return base_size - 2;
-	}
-	if (input_data[input_size - 1] == Blob::BASE64_PADDING) {
-		// one byte of padding
-		return base_size - 1;
-	}
-	// no padding
-	return base_size;
-}
-
-template <bool ALLOW_PADDING>
-uint32_t DecodeBase64Bytes(const string_t &str, const_data_ptr_t input_data, idx_t base_idx) {
-	int decoded_bytes[4];
-	for (idx_t decode_idx = 0; decode_idx < 4; decode_idx++) {
-		if (ALLOW_PADDING && decode_idx >= 2 && input_data[base_idx + decode_idx] == Blob::BASE64_PADDING) {
-			// the last two bytes of a base64 string can have padding: in this case we set the byte to 0
-			decoded_bytes[decode_idx] = 0;
-		} else {
-			decoded_bytes[decode_idx] = BASE64_DECODING_TABLE[input_data[base_idx + decode_idx]];
-		}
-		if (decoded_bytes[decode_idx] < 0) {
-			throw ConversionException(
-			    "Could not decode string \"%s\" as base64: invalid byte value '%d' at position %d", str.GetString(),
-			    input_data[base_idx + decode_idx], base_idx + decode_idx);
-		}
-	}
-	return (decoded_bytes[0] << 3 * 6) + (decoded_bytes[1] << 2 * 6) + (decoded_bytes[2] << 1 * 6) +
-	       (decoded_bytes[3] << 0 * 6);
-}
-
-void Blob::FromBase64(string_t str, data_ptr_t output, idx_t output_size) {
-	D_ASSERT(output_size == FromBase64Size(str));
-	auto input_data = (const_data_ptr_t)str.GetDataUnsafe();
-	auto input_size = str.GetSize();
-	if (input_size == 0) {
-		return;
-	}
-	idx_t out_idx = 0;
-	idx_t i = 0;
-	for (i = 0; i + 4 < input_size; i += 4) {
-		auto combined = DecodeBase64Bytes<false>(str, input_data, i);
-		output[out_idx++] = (combined >> 2 * 8) & 0xFF;
-		output[out_idx++] = (combined >> 1 * 8) & 0xFF;
-		output[out_idx++] = (combined >> 0 * 8) & 0xFF;
-	}
-	// decode the final four bytes: padding is allowed here
-	auto combined = DecodeBase64Bytes<true>(str, input_data, i);
-	output[out_idx++] = (combined >> 2 * 8) & 0xFF;
-	if (out_idx < output_size) {
-		output[out_idx++] = (combined >> 1 * 8) & 0xFF;
-	}
-	if (out_idx < output_size) {
-		output[out_idx++] = (combined >> 0 * 8) & 0xFF;
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-const int64_t NumericHelper::POWERS_OF_TEN[] {1,
-                                              10,
-                                              100,
-                                              1000,
-                                              10000,
-                                              100000,
-                                              1000000,
-                                              10000000,
-                                              100000000,
-                                              1000000000,
-                                              10000000000,
-                                              100000000000,
-                                              1000000000000,
-                                              10000000000000,
-                                              100000000000000,
-                                              1000000000000000,
-                                              10000000000000000,
-                                              100000000000000000,
-                                              1000000000000000000};
-
-const double NumericHelper::DOUBLE_POWERS_OF_TEN[] {1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,
-                                                    1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-                                                    1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
-                                                    1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39};
-
-template <>
-int NumericHelper::UnsignedLength(uint8_t value) {
-	int length = 1;
-	length += value >= 10;
-	length += value >= 100;
-	return length;
-}
-
-template <>
-int NumericHelper::UnsignedLength(uint16_t value) {
-	int length = 1;
-	length += value >= 10;
-	length += value >= 100;
-	length += value >= 1000;
-	length += value >= 10000;
-	return length;
-}
-
-template <>
-int NumericHelper::UnsignedLength(uint32_t value) {
-	if (value >= 10000) {
-		int length = 5;
-		length += value >= 100000;
-		length += value >= 1000000;
-		length += value >= 10000000;
-		length += value >= 100000000;
-		length += value >= 1000000000;
-		return length;
-	} else {
-		int length = 1;
-		length += value >= 10;
-		length += value >= 100;
-		length += value >= 1000;
-		return length;
-	}
-}
-
-template <>
-int NumericHelper::UnsignedLength(uint64_t value) {
-	if (value >= 10000000000ULL) {
-		if (value >= 1000000000000000ULL) {
-			int length = 16;
-			length += value >= 10000000000000000ULL;
-			length += value >= 100000000000000000ULL;
-			length += value >= 1000000000000000000ULL;
-			length += value >= 10000000000000000000ULL;
-			return length;
-		} else {
-			int length = 11;
-			length += value >= 100000000000ULL;
-			length += value >= 1000000000000ULL;
-			length += value >= 10000000000000ULL;
-			length += value >= 100000000000000ULL;
-			return length;
-		}
-	} else {
-		if (value >= 100000ULL) {
-			int length = 6;
-			length += value >= 1000000ULL;
-			length += value >= 10000000ULL;
-			length += value >= 100000000ULL;
-			length += value >= 1000000000ULL;
-			return length;
-		} else {
-			int length = 1;
-			length += value >= 10ULL;
-			length += value >= 100ULL;
-			length += value >= 1000ULL;
-			length += value >= 10000ULL;
-			return length;
-		}
-	}
-}
-
-template <>
-std::string NumericHelper::ToString(hugeint_t value) {
-	return Hugeint::ToString(value);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-#include <cstring>
-
-namespace duckdb {
-
-ChunkCollection::ChunkCollection(Allocator &allocator) : allocator(allocator), count(0) {
-}
-
-ChunkCollection::ChunkCollection(ClientContext &context) : ChunkCollection(Allocator::Get(context)) {
-}
-
-void ChunkCollection::Verify() {
-#ifdef DEBUG
-	for (auto &chunk : chunks) {
-		chunk->Verify();
-	}
-#endif
-}
-
-void ChunkCollection::Append(ChunkCollection &other) {
-	for (auto &chunk : other.chunks) {
-		Append(*chunk);
-	}
-}
-
-void ChunkCollection::Merge(ChunkCollection &other) {
-	if (other.count == 0) {
-		return;
-	}
-	if (count == 0) {
-		chunks = move(other.chunks);
-		types = move(other.types);
-		count = other.count;
-		return;
-	}
-	unique_ptr<DataChunk> old_back;
-	if (!chunks.empty() && chunks.back()->size() != STANDARD_VECTOR_SIZE) {
-		old_back = move(chunks.back());
-		chunks.pop_back();
-		count -= old_back->size();
-	}
-	for (auto &chunk : other.chunks) {
-		chunks.push_back(move(chunk));
-	}
-	count += other.count;
-	if (old_back) {
-		Append(*old_back);
-	}
-	Verify();
-}
-
-void ChunkCollection::Append(DataChunk &new_chunk) {
-	if (new_chunk.size() == 0) {
-		return;
-	}
-	new_chunk.Verify();
-
-	// we have to ensure that every chunk in the ChunkCollection is completely
-	// filled, otherwise our O(1) lookup in GetValue and SetValue does not work
-	// first fill the latest chunk, if it exists
-	count += new_chunk.size();
-
-	idx_t remaining_data = new_chunk.size();
-	idx_t offset = 0;
-	if (chunks.empty()) {
-		// first chunk
-		types = new_chunk.GetTypes();
-	} else {
-		// the types of the new chunk should match the types of the previous one
-		D_ASSERT(types.size() == new_chunk.ColumnCount());
-		auto new_types = new_chunk.GetTypes();
-		for (idx_t i = 0; i < types.size(); i++) {
-			if (new_types[i] != types[i]) {
-				throw TypeMismatchException(new_types[i], types[i], "Type mismatch when combining rows");
-			}
-			if (types[i].InternalType() == PhysicalType::LIST) {
-				// need to check all the chunks because they can have only-null list entries
-				for (auto &chunk : chunks) {
-					auto &chunk_vec = chunk->data[i];
-					auto &new_vec = new_chunk.data[i];
-					auto &chunk_type = chunk_vec.GetType();
-					auto &new_type = new_vec.GetType();
-					if (chunk_type != new_type) {
-						throw TypeMismatchException(chunk_type, new_type, "Type mismatch when combining lists");
-					}
-				}
-			}
-			// TODO check structs, too
-		}
-
-		// first append data to the current chunk
-		DataChunk &last_chunk = *chunks.back();
-		idx_t added_data = MinValue<idx_t>(remaining_data, STANDARD_VECTOR_SIZE - last_chunk.size());
-		if (added_data > 0) {
-			// copy <added_data> elements to the last chunk
-			new_chunk.Normalify();
-			// have to be careful here: setting the cardinality without calling normalify can cause incorrect partial
-			// decompression
-			idx_t old_count = new_chunk.size();
-			new_chunk.SetCardinality(added_data);
-
-			last_chunk.Append(new_chunk);
-			remaining_data -= added_data;
-			// reset the chunk to the old data
-			new_chunk.SetCardinality(old_count);
-			offset = added_data;
-		}
-	}
-
-	if (remaining_data > 0) {
-		// create a new chunk and fill it with the remainder
-		auto chunk = make_unique<DataChunk>();
-		chunk->Initialize(allocator, types);
-		new_chunk.Copy(*chunk, offset);
-		chunks.push_back(move(chunk));
-	}
-}
-
-void ChunkCollection::Append(unique_ptr<DataChunk> new_chunk) {
-	if (types.empty()) {
-		types = new_chunk->GetTypes();
-	}
-	D_ASSERT(types == new_chunk->GetTypes());
-	count += new_chunk->size();
-	chunks.push_back(move(new_chunk));
-}
-
-void ChunkCollection::Fuse(ChunkCollection &other) {
-	if (count == 0) {
-		chunks.reserve(other.ChunkCount());
-		for (idx_t chunk_idx = 0; chunk_idx < other.ChunkCount(); ++chunk_idx) {
-			auto lhs = make_unique<DataChunk>();
-			auto &rhs = other.GetChunk(chunk_idx);
-			lhs->data.reserve(rhs.data.size());
-			for (auto &v : rhs.data) {
-				lhs->data.emplace_back(Vector(v));
-			}
-			lhs->SetCardinality(rhs.size());
-			chunks.push_back(move(lhs));
-		}
-		count = other.Count();
-	} else {
-		D_ASSERT(this->ChunkCount() == other.ChunkCount());
-		for (idx_t chunk_idx = 0; chunk_idx < ChunkCount(); ++chunk_idx) {
-			auto &lhs = this->GetChunk(chunk_idx);
-			auto &rhs = other.GetChunk(chunk_idx);
-			D_ASSERT(lhs.size() == rhs.size());
-			for (auto &v : rhs.data) {
-				lhs.data.emplace_back(Vector(v));
-			}
-		}
-	}
-	types.insert(types.end(), other.types.begin(), other.types.end());
-}
-
-// returns an int similar to a C comparator:
-// -1 if left < right
-// 0 if left == right
-// 1 if left > right
-
-template <class TYPE>
-static int8_t TemplatedCompareValue(Vector &left_vec, Vector &right_vec, idx_t left_idx, idx_t right_idx) {
-	D_ASSERT(left_vec.GetType() == right_vec.GetType());
-	auto left_val = FlatVector::GetData<TYPE>(left_vec)[left_idx];
-	auto right_val = FlatVector::GetData<TYPE>(right_vec)[right_idx];
-	if (Equals::Operation<TYPE>(left_val, right_val)) {
-		return 0;
-	}
-	if (LessThan::Operation<TYPE>(left_val, right_val)) {
-		return -1;
-	}
-	return 1;
-}
-
-// return type here is int32 because strcmp() on some platforms returns rather large values
-static int32_t CompareValue(Vector &left_vec, Vector &right_vec, idx_t vector_idx_left, idx_t vector_idx_right,
-                            OrderByNullType null_order) {
-	auto left_null = FlatVector::IsNull(left_vec, vector_idx_left);
-	auto right_null = FlatVector::IsNull(right_vec, vector_idx_right);
-
-	if (left_null && right_null) {
-		return 0;
-	} else if (right_null) {
-		return null_order == OrderByNullType::NULLS_FIRST ? 1 : -1;
-	} else if (left_null) {
-		return null_order == OrderByNullType::NULLS_FIRST ? -1 : 1;
-	}
-
-	switch (left_vec.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedCompareValue<int8_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::INT16:
-		return TemplatedCompareValue<int16_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::INT32:
-		return TemplatedCompareValue<int32_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::INT64:
-		return TemplatedCompareValue<int64_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::UINT8:
-		return TemplatedCompareValue<uint8_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::UINT16:
-		return TemplatedCompareValue<uint16_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::UINT32:
-		return TemplatedCompareValue<uint32_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::UINT64:
-		return TemplatedCompareValue<uint64_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::INT128:
-		return TemplatedCompareValue<hugeint_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::FLOAT:
-		return TemplatedCompareValue<float>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::DOUBLE:
-		return TemplatedCompareValue<double>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::VARCHAR:
-		return TemplatedCompareValue<string_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	case PhysicalType::INTERVAL:
-		return TemplatedCompareValue<interval_t>(left_vec, right_vec, vector_idx_left, vector_idx_right);
-	default:
-		throw NotImplementedException("Type for comparison");
-	}
-}
-
-static int CompareTuple(ChunkCollection *sort_by, vector<OrderType> &desc, vector<OrderByNullType> &null_order,
-                        idx_t left, idx_t right) {
-	D_ASSERT(sort_by);
-
-	idx_t chunk_idx_left = left / STANDARD_VECTOR_SIZE;
-	idx_t chunk_idx_right = right / STANDARD_VECTOR_SIZE;
-	idx_t vector_idx_left = left % STANDARD_VECTOR_SIZE;
-	idx_t vector_idx_right = right % STANDARD_VECTOR_SIZE;
-
-	auto &left_chunk = sort_by->GetChunk(chunk_idx_left);
-	auto &right_chunk = sort_by->GetChunk(chunk_idx_right);
-
-	for (idx_t col_idx = 0; col_idx < desc.size(); col_idx++) {
-		auto order_type = desc[col_idx];
-
-		auto &left_vec = left_chunk.data[col_idx];
-		auto &right_vec = right_chunk.data[col_idx];
-
-		D_ASSERT(left_vec.GetVectorType() == VectorType::FLAT_VECTOR);
-		D_ASSERT(right_vec.GetVectorType() == VectorType::FLAT_VECTOR);
-		D_ASSERT(left_vec.GetType() == right_vec.GetType());
-
-		auto comp_res = CompareValue(left_vec, right_vec, vector_idx_left, vector_idx_right, null_order[col_idx]);
-
-		if (comp_res == 0) {
-			continue;
-		}
-		return comp_res < 0 ? (order_type == OrderType::ASCENDING ? -1 : 1)
-		                    : (order_type == OrderType::ASCENDING ? 1 : -1);
-	}
-	return 0;
-}
-
-static int64_t QuicksortInitial(ChunkCollection *sort_by, vector<OrderType> &desc, vector<OrderByNullType> &null_order,
-                                idx_t *result) {
-	// select pivot
-	int64_t pivot = 0;
-	int64_t low = 0, high = sort_by->Count() - 1;
-	// now insert elements
-	for (idx_t i = 1; i < sort_by->Count(); i++) {
-		if (CompareTuple(sort_by, desc, null_order, i, pivot) <= 0) {
-			result[low++] = i;
-		} else {
-			result[high--] = i;
-		}
-	}
-	D_ASSERT(low == high);
-	result[low] = pivot;
-	return low;
-}
-
-struct QuicksortInfo {
-	QuicksortInfo(int64_t left_p, int64_t right_p) : left(left_p), right(right_p) {
-	}
-
-	int64_t left;
-	int64_t right;
-};
-
-struct QuicksortStack {
-	std::queue<QuicksortInfo> info_queue;
-
-	QuicksortInfo Pop() {
-		auto element = info_queue.front();
-		info_queue.pop();
-		return element;
-	}
-
-	bool IsEmpty() {
-		return info_queue.empty();
-	}
-
-	void Enqueue(int64_t left, int64_t right) {
-		if (left >= right) {
-			return;
-		}
-		info_queue.emplace(left, right);
-	}
-};
-
-static void QuicksortInPlace(ChunkCollection *sort_by, vector<OrderType> &desc, vector<OrderByNullType> &null_order,
-                             idx_t *result, QuicksortInfo info, QuicksortStack &stack) {
-	auto left = info.left;
-	auto right = info.right;
-
-	D_ASSERT(left < right);
-
-	int64_t middle = left + (right - left) / 2;
-	int64_t pivot = result[middle];
-	// move the mid point value to the front.
-	int64_t i = left + 1;
-	int64_t j = right;
-
-	std::swap(result[middle], result[left]);
-	bool all_equal = true;
-	while (i <= j) {
-		if (result) {
-			while (i <= j) {
-				int cmp = CompareTuple(sort_by, desc, null_order, result[i], pivot);
-				if (cmp < 0) {
-					all_equal = false;
-				} else if (cmp > 0) {
-					all_equal = false;
-					break;
-				}
-				i++;
-			}
-		}
-
-		while (i <= j && CompareTuple(sort_by, desc, null_order, result[j], pivot) > 0) {
-			j--;
-		}
-
-		if (i < j) {
-			std::swap(result[i], result[j]);
-		}
-	}
-	std::swap(result[i - 1], result[left]);
-	int64_t part = i - 1;
-
-	if (all_equal) {
-		return;
-	}
-
-	stack.Enqueue(left, part - 1);
-	stack.Enqueue(part + 1, right);
-}
-
-void ChunkCollection::Sort(vector<OrderType> &desc, vector<OrderByNullType> &null_order, idx_t result[]) {
-	if (count == 0) {
-		return;
-	}
-	D_ASSERT(result);
-
-	// start off with an initial quicksort
-	int64_t part = QuicksortInitial(this, desc, null_order, result);
-
-	// now continuously perform
-	QuicksortStack stack;
-	stack.Enqueue(0, part);
-	stack.Enqueue(part + 1, count - 1);
-	while (!stack.IsEmpty()) {
-		auto element = stack.Pop();
-		QuicksortInPlace(this, desc, null_order, result, element, stack);
-	}
-}
-
-// FIXME make this more efficient by not using the Value API
-// just use memcpy in the vectors
-// assert that there is no selection list
-void ChunkCollection::Reorder(idx_t order_org[]) {
-	auto order = unique_ptr<idx_t[]>(new idx_t[count]);
-	memcpy(order.get(), order_org, sizeof(idx_t) * count);
-
-	// adapted from https://stackoverflow.com/a/7366196/2652376
-
-	auto val_buf = vector<Value>();
-	val_buf.resize(ColumnCount());
-
-	idx_t j, k;
-	for (idx_t i = 0; i < count; i++) {
-		for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-			val_buf[col_idx] = GetValue(col_idx, i);
-		}
-		j = i;
-		while (true) {
-			k = order[j];
-			order[j] = j;
-			if (k == i) {
-				break;
-			}
-			for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-				SetValue(col_idx, j, GetValue(col_idx, k));
-			}
-			j = k;
-		}
-		for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-			SetValue(col_idx, j, val_buf[col_idx]);
-		}
-	}
-}
-
-Value ChunkCollection::GetValue(idx_t column, idx_t index) {
-	return chunks[LocateChunk(index)]->GetValue(column, index % STANDARD_VECTOR_SIZE);
-}
-
-void ChunkCollection::SetValue(idx_t column, idx_t index, const Value &value) {
-	chunks[LocateChunk(index)]->SetValue(column, index % STANDARD_VECTOR_SIZE, value);
-}
-
-void ChunkCollection::CopyCell(idx_t column, idx_t index, Vector &target, idx_t target_offset) {
-	auto &chunk = GetChunkForRow(index);
-	auto &source = chunk.data[column];
-	const auto source_offset = index % STANDARD_VECTOR_SIZE;
-	VectorOperations::Copy(source, target, source_offset + 1, source_offset, target_offset);
-}
-
-string ChunkCollection::ToString() const {
-	return chunks.empty() ? "ChunkCollection [ 0 ]"
-	                      : "ChunkCollection [ " + std::to_string(count) + " ]: \n" + chunks[0]->ToString();
-}
-
-void ChunkCollection::Print() const {
-	Printer::Print(ToString());
-}
-
-bool ChunkCollection::Equals(ChunkCollection &other) {
-	if (count != other.count) {
-		return false;
-	}
-	if (ColumnCount() != other.ColumnCount()) {
-		return false;
-	}
-	// first try to compare the results as-is
-	bool compare_equals = true;
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-		for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-			auto lvalue = GetValue(col_idx, row_idx);
-			auto rvalue = other.GetValue(col_idx, row_idx);
-			if (!Value::ValuesAreEqual(lvalue, rvalue)) {
-				compare_equals = false;
-				break;
-			}
-		}
-		if (!compare_equals) {
-			break;
-		}
-	}
-	if (compare_equals) {
-		return true;
-	}
-	for (auto &type : types) {
-		// sort not supported
-		if (type.InternalType() == PhysicalType::LIST || type.InternalType() == PhysicalType::STRUCT) {
-			return false;
-		}
-	}
-	// if the results are not equal,
-	// sort both chunk collections to ensure the comparison is not order insensitive
-	vector<OrderType> desc(ColumnCount(), OrderType::DESCENDING);
-	vector<OrderByNullType> null_order(ColumnCount(), OrderByNullType::NULLS_FIRST);
-	auto this_order = unique_ptr<idx_t[]>(new idx_t[count]);
-	auto other_order = unique_ptr<idx_t[]>(new idx_t[count]);
-	Sort(desc, null_order, this_order.get());
-	other.Sort(desc, null_order, other_order.get());
-
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-		auto lrow = this_order[row_idx];
-		auto rrow = other_order[row_idx];
-		for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-			auto lvalue = GetValue(col_idx, lrow);
-			auto rvalue = other.GetValue(col_idx, rrow);
-			if (!Value::ValuesAreEqual(lvalue, rvalue)) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-DataChunk::DataChunk() : count(0), capacity(STANDARD_VECTOR_SIZE) {
-}
-
-DataChunk::~DataChunk() {
-}
-
-void DataChunk::InitializeEmpty(const vector<LogicalType> &types) {
-	capacity = STANDARD_VECTOR_SIZE;
-	D_ASSERT(data.empty());   // can only be initialized once
-	D_ASSERT(!types.empty()); // empty chunk not allowed
-	for (idx_t i = 0; i < types.size(); i++) {
-		data.emplace_back(Vector(types[i], nullptr));
-	}
-}
-
-void DataChunk::Initialize(Allocator &allocator, const vector<LogicalType> &types) {
-	D_ASSERT(data.empty());   // can only be initialized once
-	D_ASSERT(!types.empty()); // empty chunk not allowed
-	capacity = STANDARD_VECTOR_SIZE;
-	for (idx_t i = 0; i < types.size(); i++) {
-		VectorCache cache(allocator, types[i]);
-		data.emplace_back(cache);
-		vector_caches.push_back(move(cache));
-	}
-}
-
-void DataChunk::Initialize(ClientContext &context, const vector<LogicalType> &types) {
-	Initialize(Allocator::Get(context), types);
-}
-
-void DataChunk::Reset() {
-	if (data.empty()) {
-		return;
-	}
-	if (vector_caches.size() != data.size()) {
-		throw InternalException("VectorCache and column count mismatch in DataChunk::Reset");
-	}
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		data[i].ResetFromCache(vector_caches[i]);
-	}
-	capacity = STANDARD_VECTOR_SIZE;
-	SetCardinality(0);
-}
-
-void DataChunk::Destroy() {
-	data.clear();
-	vector_caches.clear();
-	capacity = 0;
-	SetCardinality(0);
-}
-
-Value DataChunk::GetValue(idx_t col_idx, idx_t index) const {
-	D_ASSERT(index < size());
-	return data[col_idx].GetValue(index);
-}
-
-void DataChunk::SetValue(idx_t col_idx, idx_t index, const Value &val) {
-	data[col_idx].SetValue(index, val);
-}
-
-void DataChunk::Reference(DataChunk &chunk) {
-	D_ASSERT(chunk.ColumnCount() <= ColumnCount());
-	SetCardinality(chunk);
-	SetCapacity(chunk);
-	for (idx_t i = 0; i < chunk.ColumnCount(); i++) {
-		data[i].Reference(chunk.data[i]);
-	}
-}
-
-void DataChunk::Move(DataChunk &chunk) {
-	SetCardinality(chunk);
-	SetCapacity(chunk);
-	data = move(chunk.data);
-	vector_caches = move(chunk.vector_caches);
-
-	chunk.Destroy();
-}
-
-void DataChunk::Copy(DataChunk &other, idx_t offset) const {
-	D_ASSERT(ColumnCount() == other.ColumnCount());
-	D_ASSERT(other.size() == 0);
-
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		D_ASSERT(other.data[i].GetVectorType() == VectorType::FLAT_VECTOR);
-		VectorOperations::Copy(data[i], other.data[i], size(), offset, 0);
-	}
-	other.SetCardinality(size() - offset);
-}
-
-void DataChunk::Copy(DataChunk &other, const SelectionVector &sel, const idx_t source_count, const idx_t offset) const {
-	D_ASSERT(ColumnCount() == other.ColumnCount());
-	D_ASSERT(other.size() == 0);
-	D_ASSERT((offset + source_count) <= size());
-
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		D_ASSERT(other.data[i].GetVectorType() == VectorType::FLAT_VECTOR);
-		VectorOperations::Copy(data[i], other.data[i], sel, source_count, offset, 0);
-	}
-	other.SetCardinality(source_count - offset);
-}
-
-void DataChunk::Split(DataChunk &other, idx_t split_idx) {
-	D_ASSERT(other.size() == 0);
-	D_ASSERT(other.data.empty());
-	D_ASSERT(split_idx < data.size());
-	const idx_t num_cols = data.size();
-	for (idx_t col_idx = split_idx; col_idx < num_cols; col_idx++) {
-		other.data.push_back(move(data[col_idx]));
-		other.vector_caches.push_back(move(vector_caches[col_idx]));
-	}
-	for (idx_t col_idx = split_idx; col_idx < num_cols; col_idx++) {
-		data.pop_back();
-		vector_caches.pop_back();
-	}
-	other.SetCardinality(*this);
-	other.SetCapacity(*this);
-}
-
-void DataChunk::Fuse(DataChunk &other) {
-	D_ASSERT(other.size() == size());
-	const idx_t num_cols = other.data.size();
-	for (idx_t col_idx = 0; col_idx < num_cols; ++col_idx) {
-		data.emplace_back(move(other.data[col_idx]));
-		vector_caches.emplace_back(move(other.vector_caches[col_idx]));
-	}
-	other.Destroy();
-}
-
-void DataChunk::Append(const DataChunk &other, bool resize, SelectionVector *sel, idx_t sel_count) {
-	idx_t new_size = sel ? size() + sel_count : size() + other.size();
-	if (other.size() == 0) {
-		return;
-	}
-	if (ColumnCount() != other.ColumnCount()) {
-		throw InternalException("Column counts of appending chunk doesn't match!");
-	}
-	if (new_size > capacity) {
-		if (resize) {
-			for (idx_t i = 0; i < ColumnCount(); i++) {
-				data[i].Resize(size(), new_size);
-			}
-			capacity = new_size;
-		} else {
-			throw InternalException("Can't append chunk to other chunk without resizing");
-		}
-	}
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		D_ASSERT(data[i].GetVectorType() == VectorType::FLAT_VECTOR);
-		if (sel) {
-			VectorOperations::Copy(other.data[i], data[i], *sel, sel_count, 0, size());
-		} else {
-			VectorOperations::Copy(other.data[i], data[i], other.size(), 0, size());
-		}
-	}
-	SetCardinality(new_size);
-}
-
-void DataChunk::Normalify() {
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		data[i].Normalify(size());
-	}
-}
-
-vector<LogicalType> DataChunk::GetTypes() {
-	vector<LogicalType> types;
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		types.push_back(data[i].GetType());
-	}
-	return types;
-}
-
-string DataChunk::ToString() const {
-	string retval = "Chunk - [" + to_string(ColumnCount()) + " Columns]\n";
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		retval += "- " + data[i].ToString(size()) + "\n";
-	}
-	return retval;
-}
-
-void DataChunk::Serialize(Serializer &serializer) {
-	// write the count
-	serializer.Write<sel_t>(size());
-	serializer.Write<idx_t>(ColumnCount());
-	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		// write the types
-		data[col_idx].GetType().Serialize(serializer);
-	}
-	// write the data
-	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		data[col_idx].Serialize(size(), serializer);
-	}
-}
-
-void DataChunk::Deserialize(Deserializer &source) {
-	auto rows = source.Read<sel_t>();
-	idx_t column_count = source.Read<idx_t>();
-
-	vector<LogicalType> types;
-	for (idx_t i = 0; i < column_count; i++) {
-		types.push_back(LogicalType::Deserialize(source));
-	}
-	Initialize(Allocator::DefaultAllocator(), types);
-	// now load the column data
-	SetCardinality(rows);
-	for (idx_t i = 0; i < column_count; i++) {
-		data[i].Deserialize(rows, source);
-	}
-	Verify();
-}
-
-void DataChunk::Slice(const SelectionVector &sel_vector, idx_t count_p) {
-	this->count = count_p;
-	SelCache merge_cache;
-	for (idx_t c = 0; c < ColumnCount(); c++) {
-		data[c].Slice(sel_vector, count_p, merge_cache);
-	}
-}
-
-void DataChunk::Slice(DataChunk &other, const SelectionVector &sel, idx_t count_p, idx_t col_offset) {
-	D_ASSERT(other.ColumnCount() <= col_offset + ColumnCount());
-	this->count = count_p;
-	SelCache merge_cache;
-	for (idx_t c = 0; c < other.ColumnCount(); c++) {
-		if (other.data[c].GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-			// already a dictionary! merge the dictionaries
-			data[col_offset + c].Reference(other.data[c]);
-			data[col_offset + c].Slice(sel, count_p, merge_cache);
-		} else {
-			data[col_offset + c].Slice(other.data[c], sel, count_p);
-		}
-	}
-}
-
-unique_ptr<VectorData[]> DataChunk::Orrify() {
-	auto orrified_data = unique_ptr<VectorData[]>(new VectorData[ColumnCount()]);
-	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		data[col_idx].Orrify(size(), orrified_data[col_idx]);
-	}
-	return orrified_data;
-}
-
-void DataChunk::Hash(Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalType::HASH);
-	VectorOperations::Hash(data[0], result, size());
-	for (idx_t i = 1; i < ColumnCount(); i++) {
-		VectorOperations::CombineHash(result, data[i], size());
-	}
-}
-
-void DataChunk::Verify() {
-#ifdef DEBUG
-	D_ASSERT(size() <= capacity);
-	// verify that all vectors in this chunk have the chunk selection vector
-	for (idx_t i = 0; i < ColumnCount(); i++) {
-		data[i].Verify(size());
-	}
-#endif
-}
-
-void DataChunk::Print() {
-	Printer::Print(ToString());
-}
-
-struct DuckDBArrowArrayChildHolder {
-	ArrowArray array;
-	//! need max three pointers for strings
-	duckdb::array<const void *, 3> buffers = {{nullptr, nullptr, nullptr}};
-	unique_ptr<Vector> vector;
-	unique_ptr<data_t[]> offsets;
-	unique_ptr<data_t[]> data;
-	//! Children of nested structures
-	::duckdb::vector<DuckDBArrowArrayChildHolder> children;
-	::duckdb::vector<ArrowArray *> children_ptrs;
-};
-
-struct DuckDBArrowArrayHolder {
-	vector<DuckDBArrowArrayChildHolder> children = {};
-	vector<ArrowArray *> children_ptrs = {};
-	array<const void *, 1> buffers = {{nullptr}};
-	vector<shared_ptr<ArrowArrayWrapper>> arrow_original_array;
-};
-
-static void ReleaseDuckDBArrowArray(ArrowArray *array) {
-	if (!array || !array->release) {
-		return;
-	}
-	array->release = nullptr;
-	auto holder = static_cast<DuckDBArrowArrayHolder *>(array->private_data);
-	delete holder;
-}
-
-void InitializeChild(DuckDBArrowArrayChildHolder &child_holder, idx_t size) {
-	auto &child = child_holder.array;
-	child.private_data = nullptr;
-	child.release = ReleaseDuckDBArrowArray;
-	child.n_children = 0;
-	child.null_count = 0;
-	child.offset = 0;
-	child.dictionary = nullptr;
-	child.buffers = child_holder.buffers.data();
-
-	child.length = size;
-}
-
-void SetChildValidityMask(Vector &vector, ArrowArray &child) {
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto &mask = FlatVector::Validity(vector);
-	if (!mask.AllValid()) {
-		//! any bits are set: might have nulls
-		child.null_count = -1;
-	} else {
-		//! no bits are set; we know there are no nulls
-		child.null_count = 0;
-	}
-	child.buffers[0] = (void *)mask.GetData();
-}
-
-void SetArrowChild(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &type, Vector &data, idx_t size);
-
-void SetList(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &type, Vector &data, idx_t size) {
-	auto &child = child_holder.array;
-	child_holder.vector = make_unique<Vector>(data);
-
-	//! Lists have two buffers
-	child.n_buffers = 2;
-	//! Second Buffer is the list offsets
-	child_holder.offsets = unique_ptr<data_t[]>(new data_t[sizeof(uint32_t) * (size + 1)]);
-	child.buffers[1] = child_holder.offsets.get();
-	auto offset_ptr = (uint32_t *)child.buffers[1];
-	auto list_data = FlatVector::GetData<list_entry_t>(data);
-	auto list_mask = FlatVector::Validity(data);
-	idx_t offset = 0;
-	offset_ptr[0] = 0;
-	for (idx_t i = 0; i < size; i++) {
-		auto &le = list_data[i];
-
-		if (list_mask.RowIsValid(i)) {
-			offset += le.length;
-		}
-
-		offset_ptr[i + 1] = offset;
-	}
-	auto list_size = ListVector::GetListSize(data);
-	child_holder.children.resize(1);
-	InitializeChild(child_holder.children[0], list_size);
-	child.n_children = 1;
-	child_holder.children_ptrs.push_back(&child_holder.children[0].array);
-	child.children = &child_holder.children_ptrs[0];
-	auto &child_vector = ListVector::GetEntry(data);
-	auto &child_type = ListType::GetChildType(type);
-	SetArrowChild(child_holder.children[0], child_type, child_vector, list_size);
-	SetChildValidityMask(child_vector, child_holder.children[0].array);
-}
-
-void SetStruct(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &type, Vector &data, idx_t size) {
-	auto &child = child_holder.array;
-	child_holder.vector = make_unique<Vector>(data);
-
-	//! Structs only have validity buffers
-	child.n_buffers = 1;
-	auto &children = StructVector::GetEntries(*child_holder.vector);
-	child.n_children = children.size();
-	child_holder.children.resize(child.n_children);
-	for (auto &struct_child : child_holder.children) {
-		InitializeChild(struct_child, size);
-		child_holder.children_ptrs.push_back(&struct_child.array);
-	}
-	child.children = &child_holder.children_ptrs[0];
-	for (idx_t child_idx = 0; child_idx < child_holder.children.size(); child_idx++) {
-		SetArrowChild(child_holder.children[child_idx], StructType::GetChildType(type, child_idx), *children[child_idx],
-		              size);
-		SetChildValidityMask(*children[child_idx], child_holder.children[child_idx].array);
-	}
-}
-
-void SetStructMap(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &type, Vector &data, idx_t size) {
-	auto &child = child_holder.array;
-	child_holder.vector = make_unique<Vector>(data);
-
-	//! Structs only have validity buffers
-	child.n_buffers = 1;
-	auto &children = StructVector::GetEntries(*child_holder.vector);
-	child.n_children = children.size();
-	child_holder.children.resize(child.n_children);
-	auto list_size = ListVector::GetListSize(*children[0]);
-	child.length = list_size;
-	for (auto &struct_child : child_holder.children) {
-		InitializeChild(struct_child, list_size);
-		child_holder.children_ptrs.push_back(&struct_child.array);
-	}
-	child.children = &child_holder.children_ptrs[0];
-	auto &child_types = StructType::GetChildTypes(type);
-	for (idx_t child_idx = 0; child_idx < child_holder.children.size(); child_idx++) {
-		auto &list_vector_child = ListVector::GetEntry(*children[child_idx]);
-		if (child_idx == 0) {
-			VectorData list_data;
-			children[child_idx]->Orrify(size, list_data);
-			auto list_child_validity = FlatVector::Validity(list_vector_child);
-			if (!list_child_validity.AllValid()) {
-				//! Get the offsets to check from the selection vector
-				auto list_offsets = FlatVector::GetData<list_entry_t>(*children[child_idx]);
-				for (idx_t list_idx = 0; list_idx < size; list_idx++) {
-					auto offset = list_offsets[list_data.sel->get_index(list_idx)];
-					if (!list_child_validity.CheckAllValid(offset.length + offset.offset, offset.offset)) {
-						throw std::runtime_error("Arrow doesnt accept NULL keys on Maps");
-					}
-				}
-			}
-		} else {
-			SetChildValidityMask(list_vector_child, child_holder.children[child_idx].array);
-		}
-		SetArrowChild(child_holder.children[child_idx], ListType::GetChildType(child_types[child_idx].second),
-		              list_vector_child, list_size);
-	}
-}
-
-struct ArrowUUIDConversion {
-	using internal_type_t = hugeint_t;
-
-	static unique_ptr<Vector> InitializeVector(Vector &data, idx_t size) {
-		return make_unique<Vector>(LogicalType::VARCHAR, size);
-	}
-
-	static idx_t GetStringLength(hugeint_t value) {
-		return UUID::STRING_SIZE;
-	}
-
-	static string_t ConvertValue(Vector &tgt_vec, string_t *tgt_ptr, internal_type_t *src_ptr, idx_t row) {
-		auto str_value = UUID::ToString(src_ptr[row]);
-		// Have to store this string
-		tgt_ptr[row] = StringVector::AddStringOrBlob(tgt_vec, str_value);
-		return tgt_ptr[row];
-	}
-};
-
-struct ArrowVarcharConversion {
-	using internal_type_t = string_t;
-
-	static unique_ptr<Vector> InitializeVector(Vector &data, idx_t size) {
-		return make_unique<Vector>(data);
-	}
-	static idx_t GetStringLength(string_t value) {
-		return value.GetSize();
-	}
-
-	static string_t ConvertValue(Vector &tgt_vec, string_t *tgt_ptr, internal_type_t *src_ptr, idx_t row) {
-		return src_ptr[row];
-	}
-};
-
-template <class CONVERT, class VECTOR_TYPE>
-void SetVarchar(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &type, Vector &data, idx_t size) {
-	auto &child = child_holder.array;
-	child_holder.vector = CONVERT::InitializeVector(data, size);
-	auto target_data_ptr = FlatVector::GetData<string_t>(data);
-	child.n_buffers = 3;
-	child_holder.offsets = unique_ptr<data_t[]>(new data_t[sizeof(uint32_t) * (size + 1)]);
-	child.buffers[1] = child_holder.offsets.get();
-	D_ASSERT(child.buffers[1]);
-	//! step 1: figure out total string length:
-	idx_t total_string_length = 0;
-	auto source_ptr = FlatVector::GetData<VECTOR_TYPE>(data);
-	auto &mask = FlatVector::Validity(data);
-	for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-		if (!mask.RowIsValid(row_idx)) {
-			continue;
-		}
-		total_string_length += CONVERT::GetStringLength(source_ptr[row_idx]);
-	}
-	//! step 2: allocate this much
-	child_holder.data = unique_ptr<data_t[]>(new data_t[total_string_length]);
-	child.buffers[2] = child_holder.data.get();
-	D_ASSERT(child.buffers[2]);
-	//! step 3: assign buffers
-	idx_t current_heap_offset = 0;
-	auto target_ptr = (uint32_t *)child.buffers[1];
-
-	for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-		target_ptr[row_idx] = current_heap_offset;
-		if (!mask.RowIsValid(row_idx)) {
-			continue;
-		}
-		string_t str = CONVERT::ConvertValue(*child_holder.vector, target_data_ptr, source_ptr, row_idx);
-		memcpy((void *)((uint8_t *)child.buffers[2] + current_heap_offset), str.GetDataUnsafe(), str.GetSize());
-		current_heap_offset += str.GetSize();
-	}
-	target_ptr[size] = current_heap_offset; //! need to terminate last string!
-}
-
-void SetArrowChild(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &type, Vector &data, idx_t size) {
-	auto &child = child_holder.array;
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN: {
-		//! Gotta bitpack these booleans
-		child_holder.vector = make_unique<Vector>(data);
-		child.n_buffers = 2;
-		idx_t num_bytes = (size + 8 - 1) / 8;
-		child_holder.data = unique_ptr<data_t[]>(new data_t[sizeof(uint8_t) * num_bytes]);
-		child.buffers[1] = child_holder.data.get();
-		auto source_ptr = FlatVector::GetData<uint8_t>(*child_holder.vector);
-		auto target_ptr = (uint8_t *)child.buffers[1];
-		idx_t target_pos = 0;
-		idx_t cur_bit = 0;
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (cur_bit == 8) {
-				target_pos++;
-				cur_bit = 0;
-			}
-			if (source_ptr[row_idx] == 0) {
-				//! We set the bit to 0
-				target_ptr[target_pos] &= ~(1 << cur_bit);
-			} else {
-				//! We set the bit to 1
-				target_ptr[target_pos] |= 1 << cur_bit;
-			}
-			cur_bit++;
-		}
-		break;
-	}
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIME_TZ:
-		child_holder.vector = make_unique<Vector>(data);
-		child.n_buffers = 2;
-		child.buffers[1] = (void *)FlatVector::GetData(*child_holder.vector);
-		break;
-	case LogicalTypeId::SQLNULL:
-		child.n_buffers = 1;
-		break;
-	case LogicalTypeId::DECIMAL: {
-		child.n_buffers = 2;
-		child_holder.vector = make_unique<Vector>(data);
-
-		//! We have to convert to INT128
-		switch (type.InternalType()) {
-
-		case PhysicalType::INT16: {
-			child_holder.data = unique_ptr<data_t[]>(new data_t[sizeof(hugeint_t) * (size)]);
-			child.buffers[1] = child_holder.data.get();
-			auto source_ptr = FlatVector::GetData<int16_t>(*child_holder.vector);
-			auto target_ptr = (hugeint_t *)child.buffers[1];
-			for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-				target_ptr[row_idx] = source_ptr[row_idx];
-			}
-			break;
-		}
-		case PhysicalType::INT32: {
-			child_holder.data = unique_ptr<data_t[]>(new data_t[sizeof(hugeint_t) * (size)]);
-			child.buffers[1] = child_holder.data.get();
-			auto source_ptr = FlatVector::GetData<int32_t>(*child_holder.vector);
-			auto target_ptr = (hugeint_t *)child.buffers[1];
-			for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-				target_ptr[row_idx] = source_ptr[row_idx];
-			}
-			break;
-		}
-		case PhysicalType::INT64: {
-			child_holder.data = unique_ptr<data_t[]>(new data_t[sizeof(hugeint_t) * (size)]);
-			child.buffers[1] = child_holder.data.get();
-			auto source_ptr = FlatVector::GetData<int64_t>(*child_holder.vector);
-			auto target_ptr = (hugeint_t *)child.buffers[1];
-			for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-				target_ptr[row_idx] = source_ptr[row_idx];
-			}
-			break;
-		}
-		case PhysicalType::INT128: {
-			child.buffers[1] = (void *)FlatVector::GetData(*child_holder.vector);
-			break;
-		}
-		default:
-			throw std::runtime_error("Unsupported physical type for Decimal" + TypeIdToString(type.InternalType()));
-		}
-		break;
-	}
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::JSON:
-	case LogicalTypeId::VARCHAR: {
-		SetVarchar<ArrowVarcharConversion, string_t>(child_holder, type, data, size);
-		break;
-	}
-	case LogicalTypeId::UUID: {
-		SetVarchar<ArrowUUIDConversion, hugeint_t>(child_holder, type, data, size);
-		break;
-	}
-	case LogicalTypeId::LIST: {
-		SetList(child_holder, type, data, size);
-		break;
-	}
-	case LogicalTypeId::STRUCT: {
-		SetStruct(child_holder, type, data, size);
-		break;
-	}
-	case LogicalTypeId::MAP: {
-		child_holder.vector = make_unique<Vector>(data);
-
-		auto &map_mask = FlatVector::Validity(*child_holder.vector);
-		child.n_buffers = 2;
-		//! Maps have one child
-		child.n_children = 1;
-		child_holder.children.resize(1);
-		InitializeChild(child_holder.children[0], size);
-		child_holder.children_ptrs.push_back(&child_holder.children[0].array);
-		//! Second Buffer is the offsets
-		child_holder.offsets = unique_ptr<data_t[]>(new data_t[sizeof(uint32_t) * (size + 1)]);
-		child.buffers[1] = child_holder.offsets.get();
-		auto &struct_children = StructVector::GetEntries(data);
-		auto offset_ptr = (uint32_t *)child.buffers[1];
-		auto list_data = FlatVector::GetData<list_entry_t>(*struct_children[0]);
-		idx_t offset = 0;
-		offset_ptr[0] = 0;
-		for (idx_t i = 0; i < size; i++) {
-			auto &le = list_data[i];
-			if (map_mask.RowIsValid(i)) {
-				offset += le.length;
-			}
-			offset_ptr[i + 1] = offset;
-		}
-		child.children = &child_holder.children_ptrs[0];
-		//! We need to set up a struct
-		auto struct_type = LogicalType::STRUCT(StructType::GetChildTypes(type));
-
-		SetStructMap(child_holder.children[0], struct_type, *child_holder.vector, size);
-		break;
-	}
-	case LogicalTypeId::INTERVAL: {
-		//! convert interval from month/days/ucs to milliseconds
-		child_holder.vector = make_unique<Vector>(data);
-		child.n_buffers = 2;
-		child_holder.data = unique_ptr<data_t[]>(new data_t[sizeof(int64_t) * (size)]);
-		child.buffers[1] = child_holder.data.get();
-		auto source_ptr = FlatVector::GetData<interval_t>(*child_holder.vector);
-		auto target_ptr = (int64_t *)child.buffers[1];
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			target_ptr[row_idx] = Interval::GetMilli(source_ptr[row_idx]);
-		}
-		break;
-	}
-	case LogicalTypeId::ENUM: {
-		// We need to initialize our dictionary
-		child_holder.children.resize(1);
-		idx_t dict_size = EnumType::GetSize(type);
-		InitializeChild(child_holder.children[0], dict_size);
-		Vector dictionary(EnumType::GetValuesInsertOrder(type));
-		SetArrowChild(child_holder.children[0], dictionary.GetType(), dictionary, dict_size);
-		child_holder.children_ptrs.push_back(&child_holder.children[0].array);
-
-		// now we set the data
-		child.dictionary = child_holder.children_ptrs[0];
-		child_holder.vector = make_unique<Vector>(data);
-		child.n_buffers = 2;
-		child.buffers[1] = (void *)FlatVector::GetData(*child_holder.vector);
-
-		break;
-	}
-	default:
-		throw std::runtime_error("Unsupported type " + type.ToString());
-	}
-}
-
-void DataChunk::ToArrowArray(ArrowArray *out_array) {
-	Normalify();
-	D_ASSERT(out_array);
-
-	// Allocate as unique_ptr first to cleanup properly on error
-	auto root_holder = make_unique<DuckDBArrowArrayHolder>();
-
-	// Allocate the children
-	root_holder->children.resize(ColumnCount());
-	root_holder->children_ptrs.resize(ColumnCount(), nullptr);
-	for (size_t i = 0; i < ColumnCount(); ++i) {
-		root_holder->children_ptrs[i] = &root_holder->children[i].array;
-	}
-	out_array->children = root_holder->children_ptrs.data();
-	out_array->n_children = ColumnCount();
-
-	// Configure root array
-	out_array->length = size();
-	out_array->n_children = ColumnCount();
-	out_array->n_buffers = 1;
-	out_array->buffers = root_holder->buffers.data(); // there is no actual buffer there since we don't have NULLs
-	out_array->offset = 0;
-	out_array->null_count = 0; // needs to be 0
-	out_array->dictionary = nullptr;
-
-	//! Configure child arrays
-	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		auto &child_holder = root_holder->children[col_idx];
-		InitializeChild(child_holder, size());
-		auto &vector = child_holder.vector;
-		auto &child = child_holder.array;
-		auto vec_buffer = data[col_idx].GetBuffer();
-		if (vec_buffer->GetAuxiliaryData() &&
-		    vec_buffer->GetAuxiliaryDataType() == VectorAuxiliaryDataType::ARROW_AUXILIARY) {
-			auto arrow_aux_data = (ArrowAuxiliaryData *)vec_buffer->GetAuxiliaryData();
-			root_holder->arrow_original_array.push_back(arrow_aux_data->arrow_array);
-		}
-		//! We could, in theory, output other types of vectors here, currently only FLAT Vectors
-		SetArrowChild(child_holder, GetTypes()[col_idx], data[col_idx], size());
-		SetChildValidityMask(*vector, child);
-		out_array->children[col_idx] = &child;
-	}
-
-	// Release ownership to caller
-	out_array->private_data = root_holder.release();
-	out_array->release = ReleaseDuckDBArrowArray;
-}
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-2.cpp b/velox/external/duckdb/duckdb-2.cpp
deleted file mode 100644
index 1f5f403fff6b0..0000000000000
--- a/velox/external/duckdb/duckdb-2.cpp
+++ /dev/null
@@ -1,17355 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-
-
-
-
-
-
-
-#include <cstring>
-#include <cctype>
-#include <algorithm>
-
-namespace duckdb {
-
-static_assert(sizeof(date_t) == sizeof(int32_t), "date_t was padded");
-
-const char *Date::PINF = "infinity";  // NOLINT
-const char *Date::NINF = "-infinity"; // NOLINT
-const char *Date::EPOCH = "epoch";    // NOLINT
-
-const string_t Date::MONTH_NAMES_ABBREVIATED[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-                                                  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-const string_t Date::MONTH_NAMES[] = {"January", "February", "March",     "April",   "May",      "June",
-                                      "July",    "August",   "September", "October", "November", "December"};
-const string_t Date::DAY_NAMES[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
-const string_t Date::DAY_NAMES_ABBREVIATED[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-
-const int32_t Date::NORMAL_DAYS[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-const int32_t Date::CUMULATIVE_DAYS[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
-const int32_t Date::LEAP_DAYS[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-const int32_t Date::CUMULATIVE_LEAP_DAYS[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366};
-const int8_t Date::MONTH_PER_DAY_OF_YEAR[] = {
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-    2,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
-    3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
-    4,  4,  4,  4,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
-    5,  5,  5,  5,  5,  5,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,
-    6,  6,  6,  6,  6,  6,  6,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
-    8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
-    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12};
-const int8_t Date::LEAP_MONTH_PER_DAY_OF_YEAR[] = {
-    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-    2,  2,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
-    3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
-    4,  4,  4,  4,  4,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
-    5,  5,  5,  5,  5,  5,  5,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,
-    6,  6,  6,  6,  6,  6,  6,  6,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
-    8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
-    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12};
-const int32_t Date::CUMULATIVE_YEAR_DAYS[] = {
-    0,      365,    730,    1096,   1461,   1826,   2191,   2557,   2922,   3287,   3652,   4018,   4383,   4748,
-    5113,   5479,   5844,   6209,   6574,   6940,   7305,   7670,   8035,   8401,   8766,   9131,   9496,   9862,
-    10227,  10592,  10957,  11323,  11688,  12053,  12418,  12784,  13149,  13514,  13879,  14245,  14610,  14975,
-    15340,  15706,  16071,  16436,  16801,  17167,  17532,  17897,  18262,  18628,  18993,  19358,  19723,  20089,
-    20454,  20819,  21184,  21550,  21915,  22280,  22645,  23011,  23376,  23741,  24106,  24472,  24837,  25202,
-    25567,  25933,  26298,  26663,  27028,  27394,  27759,  28124,  28489,  28855,  29220,  29585,  29950,  30316,
-    30681,  31046,  31411,  31777,  32142,  32507,  32872,  33238,  33603,  33968,  34333,  34699,  35064,  35429,
-    35794,  36160,  36525,  36890,  37255,  37621,  37986,  38351,  38716,  39082,  39447,  39812,  40177,  40543,
-    40908,  41273,  41638,  42004,  42369,  42734,  43099,  43465,  43830,  44195,  44560,  44926,  45291,  45656,
-    46021,  46387,  46752,  47117,  47482,  47847,  48212,  48577,  48942,  49308,  49673,  50038,  50403,  50769,
-    51134,  51499,  51864,  52230,  52595,  52960,  53325,  53691,  54056,  54421,  54786,  55152,  55517,  55882,
-    56247,  56613,  56978,  57343,  57708,  58074,  58439,  58804,  59169,  59535,  59900,  60265,  60630,  60996,
-    61361,  61726,  62091,  62457,  62822,  63187,  63552,  63918,  64283,  64648,  65013,  65379,  65744,  66109,
-    66474,  66840,  67205,  67570,  67935,  68301,  68666,  69031,  69396,  69762,  70127,  70492,  70857,  71223,
-    71588,  71953,  72318,  72684,  73049,  73414,  73779,  74145,  74510,  74875,  75240,  75606,  75971,  76336,
-    76701,  77067,  77432,  77797,  78162,  78528,  78893,  79258,  79623,  79989,  80354,  80719,  81084,  81450,
-    81815,  82180,  82545,  82911,  83276,  83641,  84006,  84371,  84736,  85101,  85466,  85832,  86197,  86562,
-    86927,  87293,  87658,  88023,  88388,  88754,  89119,  89484,  89849,  90215,  90580,  90945,  91310,  91676,
-    92041,  92406,  92771,  93137,  93502,  93867,  94232,  94598,  94963,  95328,  95693,  96059,  96424,  96789,
-    97154,  97520,  97885,  98250,  98615,  98981,  99346,  99711,  100076, 100442, 100807, 101172, 101537, 101903,
-    102268, 102633, 102998, 103364, 103729, 104094, 104459, 104825, 105190, 105555, 105920, 106286, 106651, 107016,
-    107381, 107747, 108112, 108477, 108842, 109208, 109573, 109938, 110303, 110669, 111034, 111399, 111764, 112130,
-    112495, 112860, 113225, 113591, 113956, 114321, 114686, 115052, 115417, 115782, 116147, 116513, 116878, 117243,
-    117608, 117974, 118339, 118704, 119069, 119435, 119800, 120165, 120530, 120895, 121260, 121625, 121990, 122356,
-    122721, 123086, 123451, 123817, 124182, 124547, 124912, 125278, 125643, 126008, 126373, 126739, 127104, 127469,
-    127834, 128200, 128565, 128930, 129295, 129661, 130026, 130391, 130756, 131122, 131487, 131852, 132217, 132583,
-    132948, 133313, 133678, 134044, 134409, 134774, 135139, 135505, 135870, 136235, 136600, 136966, 137331, 137696,
-    138061, 138427, 138792, 139157, 139522, 139888, 140253, 140618, 140983, 141349, 141714, 142079, 142444, 142810,
-    143175, 143540, 143905, 144271, 144636, 145001, 145366, 145732, 146097};
-
-void Date::ExtractYearOffset(int32_t &n, int32_t &year, int32_t &year_offset) {
-	year = Date::EPOCH_YEAR;
-	// first we normalize n to be in the year range [1970, 2370]
-	// since leap years repeat every 400 years, we can safely normalize just by "shifting" the CumulativeYearDays array
-	while (n < 0) {
-		n += Date::DAYS_PER_YEAR_INTERVAL;
-		year -= Date::YEAR_INTERVAL;
-	}
-	while (n >= Date::DAYS_PER_YEAR_INTERVAL) {
-		n -= Date::DAYS_PER_YEAR_INTERVAL;
-		year += Date::YEAR_INTERVAL;
-	}
-	// interpolation search
-	// we can find an upper bound of the year by assuming each year has 365 days
-	year_offset = n / 365;
-	// because of leap years we might be off by a little bit: compensate by decrementing the year offset until we find
-	// our year
-	while (n < Date::CUMULATIVE_YEAR_DAYS[year_offset]) {
-		year_offset--;
-		D_ASSERT(year_offset >= 0);
-	}
-	year += year_offset;
-	D_ASSERT(n >= Date::CUMULATIVE_YEAR_DAYS[year_offset]);
-}
-
-void Date::Convert(date_t d, int32_t &year, int32_t &month, int32_t &day) {
-	auto n = d.days;
-	int32_t year_offset;
-	Date::ExtractYearOffset(n, year, year_offset);
-
-	day = n - Date::CUMULATIVE_YEAR_DAYS[year_offset];
-	D_ASSERT(day >= 0 && day <= 365);
-
-	bool is_leap_year = (Date::CUMULATIVE_YEAR_DAYS[year_offset + 1] - Date::CUMULATIVE_YEAR_DAYS[year_offset]) == 366;
-	if (is_leap_year) {
-		month = Date::LEAP_MONTH_PER_DAY_OF_YEAR[day];
-		day -= Date::CUMULATIVE_LEAP_DAYS[month - 1];
-	} else {
-		month = Date::MONTH_PER_DAY_OF_YEAR[day];
-		day -= Date::CUMULATIVE_DAYS[month - 1];
-	}
-	day++;
-	D_ASSERT(day > 0 && day <= (is_leap_year ? Date::LEAP_DAYS[month] : Date::NORMAL_DAYS[month]));
-	D_ASSERT(month > 0 && month <= 12);
-}
-
-bool Date::TryFromDate(int32_t year, int32_t month, int32_t day, date_t &result) {
-	int32_t n = 0;
-	if (!Date::IsValid(year, month, day)) {
-		return false;
-	}
-	n += Date::IsLeapYear(year) ? Date::CUMULATIVE_LEAP_DAYS[month - 1] : Date::CUMULATIVE_DAYS[month - 1];
-	n += day - 1;
-	if (year < 1970) {
-		int32_t diff_from_base = 1970 - year;
-		int32_t year_index = 400 - (diff_from_base % 400);
-		int32_t fractions = diff_from_base / 400;
-		n += Date::CUMULATIVE_YEAR_DAYS[year_index];
-		n -= Date::DAYS_PER_YEAR_INTERVAL;
-		n -= fractions * Date::DAYS_PER_YEAR_INTERVAL;
-	} else if (year >= 2370) {
-		int32_t diff_from_base = year - 2370;
-		int32_t year_index = diff_from_base % 400;
-		int32_t fractions = diff_from_base / 400;
-		n += Date::CUMULATIVE_YEAR_DAYS[year_index];
-		n += Date::DAYS_PER_YEAR_INTERVAL;
-		n += fractions * Date::DAYS_PER_YEAR_INTERVAL;
-	} else {
-		n += Date::CUMULATIVE_YEAR_DAYS[year - 1970];
-	}
-#ifdef DEBUG
-	int32_t y, m, d;
-	Date::Convert(date_t(n), y, m, d);
-	D_ASSERT(year == y);
-	D_ASSERT(month == m);
-	D_ASSERT(day == d);
-#endif
-	result = date_t(n);
-	return true;
-}
-
-date_t Date::FromDate(int32_t year, int32_t month, int32_t day) {
-	date_t result;
-	if (!Date::TryFromDate(year, month, day, result)) {
-		throw ConversionException("Date out of range: %d-%d-%d", year, month, day);
-	}
-	return result;
-}
-
-bool Date::ParseDoubleDigit(const char *buf, idx_t len, idx_t &pos, int32_t &result) {
-	if (pos < len && StringUtil::CharacterIsDigit(buf[pos])) {
-		result = buf[pos++] - '0';
-		if (pos < len && StringUtil::CharacterIsDigit(buf[pos])) {
-			result = (buf[pos++] - '0') + result * 10;
-		}
-		return true;
-	}
-	return false;
-}
-
-static bool TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const char *special) {
-	auto p = pos;
-	for (; p < len && *special; ++p) {
-		const auto s = *special++;
-		if (!s || StringUtil::CharacterToLower(buf[p]) != s) {
-			return false;
-		}
-	}
-	pos = p;
-	return true;
-}
-
-bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool strict) {
-	pos = 0;
-	if (len == 0) {
-		return false;
-	}
-
-	int32_t day = 0;
-	int32_t month = -1;
-	int32_t year = 0;
-	bool yearneg = false;
-	int sep;
-
-	// skip leading spaces
-	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-		pos++;
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-	if (buf[pos] == '-') {
-		yearneg = true;
-		pos++;
-		if (pos >= len) {
-			return false;
-		}
-	}
-	if (!StringUtil::CharacterIsDigit(buf[pos])) {
-		// Check for special values
-		if (TryConvertDateSpecial(buf, len, pos, PINF)) {
-			result = yearneg ? date_t::ninfinity() : date_t::infinity();
-		} else if (TryConvertDateSpecial(buf, len, pos, EPOCH)) {
-			result = date_t::epoch();
-		} else {
-			return false;
-		}
-		// skip trailing spaces - parsing must be strict here
-		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-			pos++;
-		}
-		return pos == len;
-	}
-	// first parse the year
-	for (; pos < len && StringUtil::CharacterIsDigit(buf[pos]); pos++) {
-		if (year >= 100000000) {
-			return false;
-		}
-		year = (buf[pos] - '0') + year * 10;
-	}
-	if (yearneg) {
-		year = -year;
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-
-	// fetch the separator
-	sep = buf[pos++];
-	if (sep != ' ' && sep != '-' && sep != '/' && sep != '\\') {
-		// invalid separator
-		return false;
-	}
-
-	// parse the month
-	if (!Date::ParseDoubleDigit(buf, len, pos, month)) {
-		return false;
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-
-	if (buf[pos++] != sep) {
-		return false;
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-
-	// now parse the day
-	if (!Date::ParseDoubleDigit(buf, len, pos, day)) {
-		return false;
-	}
-
-	// check for an optional trailing " (BC)""
-	if (len - pos >= 5 && StringUtil::CharacterIsSpace(buf[pos]) && buf[pos + 1] == '(' &&
-	    StringUtil::CharacterToLower(buf[pos + 2]) == 'b' && StringUtil::CharacterToLower(buf[pos + 3]) == 'c' &&
-	    buf[pos + 4] == ')') {
-		if (yearneg || year == 0) {
-			return false;
-		}
-		year = -year + 1;
-		pos += 5;
-	}
-
-	// in strict mode, check remaining string for non-space characters
-	if (strict) {
-		// skip trailing spaces
-		while (pos < len && StringUtil::CharacterIsSpace((unsigned char)buf[pos])) {
-			pos++;
-		}
-		// check position. if end was not reached, non-space chars remaining
-		if (pos < len) {
-			return false;
-		}
-	} else {
-		// in non-strict mode, check for any direct trailing digits
-		if (pos < len && StringUtil::CharacterIsDigit((unsigned char)buf[pos])) {
-			return false;
-		}
-	}
-
-	return Date::TryFromDate(year, month, day, result);
-}
-
-string Date::ConversionError(const string &str) {
-	return StringUtil::Format("date field value out of range: \"%s\", "
-	                          "expected format is (YYYY-MM-DD)",
-	                          str);
-}
-
-string Date::ConversionError(string_t str) {
-	return ConversionError(str.GetString());
-}
-
-date_t Date::FromCString(const char *buf, idx_t len, bool strict) {
-	date_t result;
-	idx_t pos;
-	if (!TryConvertDate(buf, len, pos, result, strict)) {
-		throw ConversionException(ConversionError(string(buf, len)));
-	}
-	return result;
-}
-
-date_t Date::FromString(const string &str, bool strict) {
-	return Date::FromCString(str.c_str(), str.size(), strict);
-}
-
-string Date::ToString(date_t date) {
-	// PG displays temporal infinities in lowercase,
-	// but numerics in Titlecase.
-	if (date == date_t::infinity()) {
-		return PINF;
-	} else if (date == date_t::ninfinity()) {
-		return NINF;
-	}
-	int32_t date_units[3];
-	idx_t year_length;
-	bool add_bc;
-	Date::Convert(date, date_units[0], date_units[1], date_units[2]);
-
-	auto length = DateToStringCast::Length(date_units, year_length, add_bc);
-	auto buffer = unique_ptr<char[]>(new char[length]);
-	DateToStringCast::Format(buffer.get(), date_units, year_length, add_bc);
-	return string(buffer.get(), length);
-}
-
-string Date::Format(int32_t year, int32_t month, int32_t day) {
-	return ToString(Date::FromDate(year, month, day));
-}
-
-bool Date::IsLeapYear(int32_t year) {
-	return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
-}
-
-bool Date::IsValid(int32_t year, int32_t month, int32_t day) {
-	if (month < 1 || month > 12) {
-		return false;
-	}
-	if (day < 1) {
-		return false;
-	}
-	if (year <= DATE_MIN_YEAR) {
-		if (year < DATE_MIN_YEAR) {
-			return false;
-		} else if (year == DATE_MIN_YEAR) {
-			if (month < DATE_MIN_MONTH || (month == DATE_MIN_MONTH && day < DATE_MIN_DAY)) {
-				return false;
-			}
-		}
-	}
-	if (year >= DATE_MAX_YEAR) {
-		if (year > DATE_MAX_YEAR) {
-			return false;
-		} else if (year == DATE_MAX_YEAR) {
-			if (month > DATE_MAX_MONTH || (month == DATE_MAX_MONTH && day > DATE_MAX_DAY)) {
-				return false;
-			}
-		}
-	}
-	return Date::IsLeapYear(year) ? day <= Date::LEAP_DAYS[month] : day <= Date::NORMAL_DAYS[month];
-}
-
-int32_t Date::MonthDays(int32_t year, int32_t month) {
-	D_ASSERT(month >= 1 && month <= 12);
-	return Date::IsLeapYear(year) ? Date::LEAP_DAYS[month] : Date::NORMAL_DAYS[month];
-}
-
-date_t Date::EpochDaysToDate(int32_t epoch) {
-	return (date_t)epoch;
-}
-
-int32_t Date::EpochDays(date_t date) {
-	return date.days;
-}
-
-date_t Date::EpochToDate(int64_t epoch) {
-	return date_t(epoch / Interval::SECS_PER_DAY);
-}
-
-int64_t Date::Epoch(date_t date) {
-	return ((int64_t)date.days) * Interval::SECS_PER_DAY;
-}
-
-int64_t Date::EpochNanoseconds(date_t date) {
-	return ((int64_t)date.days) * (Interval::MICROS_PER_DAY * 1000);
-}
-
-int32_t Date::ExtractYear(date_t d, int32_t *last_year) {
-	auto n = d.days;
-	// cached look up: check if year of this date is the same as the last one we looked up
-	// note that this only works for years in the range [1970, 2370]
-	if (n >= Date::CUMULATIVE_YEAR_DAYS[*last_year] && n < Date::CUMULATIVE_YEAR_DAYS[*last_year + 1]) {
-		return Date::EPOCH_YEAR + *last_year;
-	}
-	int32_t year;
-	Date::ExtractYearOffset(n, year, *last_year);
-	return year;
-}
-
-int32_t Date::ExtractYear(timestamp_t ts, int32_t *last_year) {
-	return Date::ExtractYear(Timestamp::GetDate(ts), last_year);
-}
-
-int32_t Date::ExtractYear(date_t d) {
-	int32_t year, year_offset;
-	Date::ExtractYearOffset(d.days, year, year_offset);
-	return year;
-}
-
-int32_t Date::ExtractMonth(date_t date) {
-	int32_t out_year, out_month, out_day;
-	Date::Convert(date, out_year, out_month, out_day);
-	return out_month;
-}
-
-int32_t Date::ExtractDay(date_t date) {
-	int32_t out_year, out_month, out_day;
-	Date::Convert(date, out_year, out_month, out_day);
-	return out_day;
-}
-
-int32_t Date::ExtractDayOfTheYear(date_t date) {
-	int32_t year, year_offset;
-	Date::ExtractYearOffset(date.days, year, year_offset);
-	return date.days - Date::CUMULATIVE_YEAR_DAYS[year_offset] + 1;
-}
-
-int32_t Date::ExtractISODayOfTheWeek(date_t date) {
-	// date of 0 is 1970-01-01, which was a Thursday (4)
-	// -7 = 4
-	// -6 = 5
-	// -5 = 6
-	// -4 = 7
-	// -3 = 1
-	// -2 = 2
-	// -1 = 3
-	// 0  = 4
-	// 1  = 5
-	// 2  = 6
-	// 3  = 7
-	// 4  = 1
-	// 5  = 2
-	// 6  = 3
-	// 7  = 4
-	if (date.days < 0) {
-		// negative date: start off at 4 and cycle downwards
-		return (7 - ((-int64_t(date.days) + 3) % 7));
-	} else {
-		// positive date: start off at 4 and cycle upwards
-		return ((int64_t(date.days) + 3) % 7) + 1;
-	}
-}
-
-static int32_t GetISOYearWeek(int32_t &year, int32_t month, int32_t day) {
-	auto day_of_the_year =
-	    (Date::IsLeapYear(year) ? Date::CUMULATIVE_LEAP_DAYS[month] : Date::CUMULATIVE_DAYS[month]) + day;
-	// get the first day of the first week of the year
-	// the first week is the week that has the 4th of January in it
-	const auto weekday_of_the_fourth = Date::ExtractISODayOfTheWeek(Date::FromDate(year, 1, 4));
-	// if fourth is monday, then fourth is the first day
-	// if fourth is tuesday, third is the first day
-	// if fourth is wednesday, second is the first day
-	// if fourth is thursday, first is the first day
-	// if fourth is friday - sunday, day is in the previous year
-	// (day is 0-based, weekday is 1-based)
-	const auto first_day_of_the_first_isoweek = 4 - weekday_of_the_fourth;
-	if (day_of_the_year < first_day_of_the_first_isoweek) {
-		// day is part of last year (13th month)
-		--year;
-		return GetISOYearWeek(year, 12, day);
-	} else {
-		return ((day_of_the_year - first_day_of_the_first_isoweek) / 7) + 1;
-	}
-}
-
-void Date::ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week) {
-	int32_t month, day;
-	Date::Convert(date, year, month, day);
-	week = GetISOYearWeek(year, month - 1, day - 1);
-}
-
-int32_t Date::ExtractISOWeekNumber(date_t date) {
-	int32_t year, week;
-	ExtractISOYearWeek(date, year, week);
-	return week;
-}
-
-int32_t Date::ExtractISOYearNumber(date_t date) {
-	int32_t year, week;
-	ExtractISOYearWeek(date, year, week);
-	return year;
-}
-
-int32_t Date::ExtractWeekNumberRegular(date_t date, bool monday_first) {
-	int32_t year, month, day;
-	Date::Convert(date, year, month, day);
-	month -= 1;
-	day -= 1;
-	// get the day of the year
-	auto day_of_the_year =
-	    (Date::IsLeapYear(year) ? Date::CUMULATIVE_LEAP_DAYS[month] : Date::CUMULATIVE_DAYS[month]) + day;
-	// now figure out the first monday or sunday of the year
-	// what day is January 1st?
-	auto day_of_jan_first = Date::ExtractISODayOfTheWeek(Date::FromDate(year, 1, 1));
-	// monday = 1, sunday = 7
-	int32_t first_week_start;
-	if (monday_first) {
-		// have to find next "1"
-		if (day_of_jan_first == 1) {
-			// jan 1 is monday: starts immediately
-			first_week_start = 0;
-		} else {
-			// jan 1 is not monday: count days until next monday
-			first_week_start = 8 - day_of_jan_first;
-		}
-	} else {
-		first_week_start = 7 - day_of_jan_first;
-	}
-	if (day_of_the_year < first_week_start) {
-		// day occurs before first week starts: week 0
-		return 0;
-	}
-	return ((day_of_the_year - first_week_start) / 7) + 1;
-}
-
-// Returns the date of the monday of the current week.
-date_t Date::GetMondayOfCurrentWeek(date_t date) {
-	int32_t dotw = Date::ExtractISODayOfTheWeek(date);
-	return date - (dotw - 1);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-template <class SIGNED, class UNSIGNED>
-string TemplatedDecimalToString(SIGNED value, uint8_t scale) {
-	auto len = DecimalToString::DecimalLength<SIGNED, UNSIGNED>(value, scale);
-	auto data = unique_ptr<char[]>(new char[len + 1]);
-	DecimalToString::FormatDecimal<SIGNED, UNSIGNED>(value, scale, data.get(), len);
-	return string(data.get(), len);
-}
-
-string Decimal::ToString(int16_t value, uint8_t scale) {
-	return TemplatedDecimalToString<int16_t, uint16_t>(value, scale);
-}
-
-string Decimal::ToString(int32_t value, uint8_t scale) {
-	return TemplatedDecimalToString<int32_t, uint32_t>(value, scale);
-}
-
-string Decimal::ToString(int64_t value, uint8_t scale) {
-	return TemplatedDecimalToString<int64_t, uint64_t>(value, scale);
-}
-
-string Decimal::ToString(hugeint_t value, uint8_t scale) {
-	auto len = HugeintToStringCast::DecimalLength(value, scale);
-	auto data = unique_ptr<char[]>(new char[len + 1]);
-	HugeintToStringCast::FormatDecimal(value, scale, data.get(), len);
-	return string(data.get(), len);
-}
-
-} // namespace duckdb
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-template <>
-hash_t Hash(uint64_t val) {
-	return murmurhash64(val);
-}
-
-template <>
-hash_t Hash(int64_t val) {
-	return murmurhash64((uint64_t)val);
-}
-
-template <>
-hash_t Hash(hugeint_t val) {
-	return murmurhash64(val.lower) ^ murmurhash64(val.upper);
-}
-
-template <>
-hash_t Hash(float val) {
-	return std::hash<float> {}(val);
-}
-
-template <>
-hash_t Hash(double val) {
-	return std::hash<double> {}(val);
-}
-
-template <>
-hash_t Hash(interval_t val) {
-	return Hash(val.days) ^ Hash(val.months) ^ Hash(val.micros);
-}
-
-template <>
-hash_t Hash(const char *str) {
-	return Hash(str, strlen(str));
-}
-
-template <>
-hash_t Hash(string_t val) {
-	return Hash(val.GetDataUnsafe(), val.GetSize());
-}
-
-template <>
-hash_t Hash(char *val) {
-	return Hash<const char *>(val);
-}
-
-// MIT License
-// Copyright (c) 2018-2021 Martin Ankerl
-// https://github.com/martinus/robin-hood-hashing/blob/3.11.5/LICENSE
-hash_t HashBytes(void *ptr, size_t len) noexcept {
-	static constexpr uint64_t M = UINT64_C(0xc6a4a7935bd1e995);
-	static constexpr uint64_t SEED = UINT64_C(0xe17a1465);
-	static constexpr unsigned int R = 47;
-
-	auto const *const data64 = static_cast<uint64_t const *>(ptr);
-	uint64_t h = SEED ^ (len * M);
-
-	size_t const n_blocks = len / 8;
-	for (size_t i = 0; i < n_blocks; ++i) {
-		auto k = Load<uint64_t>(reinterpret_cast<const_data_ptr_t>(data64 + i));
-
-		k *= M;
-		k ^= k >> R;
-		k *= M;
-
-		h ^= k;
-		h *= M;
-	}
-
-	auto const *const data8 = reinterpret_cast<uint8_t const *>(data64 + n_blocks);
-	switch (len & 7U) {
-	case 7:
-		h ^= static_cast<uint64_t>(data8[6]) << 48U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 6:
-		h ^= static_cast<uint64_t>(data8[5]) << 40U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 5:
-		h ^= static_cast<uint64_t>(data8[4]) << 32U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 4:
-		h ^= static_cast<uint64_t>(data8[3]) << 24U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 3:
-		h ^= static_cast<uint64_t>(data8[2]) << 16U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 2:
-		h ^= static_cast<uint64_t>(data8[1]) << 8U;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	case 1:
-		h ^= static_cast<uint64_t>(data8[0]);
-		h *= M;
-		DUCKDB_EXPLICIT_FALLTHROUGH;
-	default:
-		break;
-	}
-	h ^= h >> R;
-	h *= M;
-	h ^= h >> R;
-	return static_cast<hash_t>(h);
-}
-
-hash_t Hash(const char *val, size_t size) {
-	return HashBytes((void *)val, size);
-}
-
-hash_t Hash(uint8_t *val, size_t size) {
-	return HashBytes((void *)val, size);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <cmath>
-#include <limits>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// String Conversion
-//===--------------------------------------------------------------------===//
-const hugeint_t Hugeint::POWERS_OF_TEN[] {
-    hugeint_t(1),
-    hugeint_t(10),
-    hugeint_t(100),
-    hugeint_t(1000),
-    hugeint_t(10000),
-    hugeint_t(100000),
-    hugeint_t(1000000),
-    hugeint_t(10000000),
-    hugeint_t(100000000),
-    hugeint_t(1000000000),
-    hugeint_t(10000000000),
-    hugeint_t(100000000000),
-    hugeint_t(1000000000000),
-    hugeint_t(10000000000000),
-    hugeint_t(100000000000000),
-    hugeint_t(1000000000000000),
-    hugeint_t(10000000000000000),
-    hugeint_t(100000000000000000),
-    hugeint_t(1000000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10),
-    hugeint_t(1000000000000000000) * hugeint_t(100),
-    hugeint_t(1000000000000000000) * hugeint_t(1000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(10000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(100000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000000000),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000000000) * hugeint_t(10),
-    hugeint_t(1000000000000000000) * hugeint_t(1000000000000000000) * hugeint_t(100)};
-
-static uint8_t PositiveHugeintHighestBit(hugeint_t bits) {
-	uint8_t out = 0;
-	if (bits.upper) {
-		out = 64;
-		uint64_t up = bits.upper;
-		while (up) {
-			up >>= 1;
-			out++;
-		}
-	} else {
-		uint64_t low = bits.lower;
-		while (low) {
-			low >>= 1;
-			out++;
-		}
-	}
-	return out;
-}
-
-static bool PositiveHugeintIsBitSet(hugeint_t lhs, uint8_t bit_position) {
-	if (bit_position < 64) {
-		return lhs.lower & (uint64_t(1) << uint64_t(bit_position));
-	} else {
-		return lhs.upper & (uint64_t(1) << uint64_t(bit_position - 64));
-	}
-}
-
-hugeint_t PositiveHugeintLeftShift(hugeint_t lhs, uint32_t amount) {
-	D_ASSERT(amount > 0 && amount < 64);
-	hugeint_t result;
-	result.lower = lhs.lower << amount;
-	result.upper = (lhs.upper << amount) + (lhs.lower >> (64 - amount));
-	return result;
-}
-
-hugeint_t Hugeint::DivModPositive(hugeint_t lhs, uint64_t rhs, uint64_t &remainder) {
-	D_ASSERT(lhs.upper >= 0);
-	// DivMod code adapted from:
-	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
-
-	// initialize the result and remainder to 0
-	hugeint_t div_result;
-	div_result.lower = 0;
-	div_result.upper = 0;
-	remainder = 0;
-
-	uint8_t highest_bit_set = PositiveHugeintHighestBit(lhs);
-	// now iterate over the amount of bits that are set in the LHS
-	for (uint8_t x = highest_bit_set; x > 0; x--) {
-		// left-shift the current result and remainder by 1
-		div_result = PositiveHugeintLeftShift(div_result, 1);
-		remainder <<= 1;
-		// we get the value of the bit at position X, where position 0 is the least-significant bit
-		if (PositiveHugeintIsBitSet(lhs, x - 1)) {
-			// increment the remainder
-			remainder++;
-		}
-		if (remainder >= rhs) {
-			// the remainder has passed the division multiplier: add one to the divide result
-			remainder -= rhs;
-			div_result.lower++;
-			if (div_result.lower == 0) {
-				// overflow
-				div_result.upper++;
-			}
-		}
-	}
-	return div_result;
-}
-
-string Hugeint::ToString(hugeint_t input) {
-	uint64_t remainder;
-	string result;
-	bool negative = input.upper < 0;
-	if (negative) {
-		NegateInPlace(input);
-	}
-	while (true) {
-		if (!input.lower && !input.upper) {
-			break;
-		}
-		input = Hugeint::DivModPositive(input, 10, remainder);
-		result = string(1, '0' + remainder) + result; // NOLINT
-	}
-	if (result.empty()) {
-		// value is zero
-		return "0";
-	}
-	return negative ? "-" + result : result;
-}
-
-//===--------------------------------------------------------------------===//
-// Multiply
-//===--------------------------------------------------------------------===//
-bool Hugeint::TryMultiply(hugeint_t lhs, hugeint_t rhs, hugeint_t &result) {
-	bool lhs_negative = lhs.upper < 0;
-	bool rhs_negative = rhs.upper < 0;
-	if (lhs_negative) {
-		NegateInPlace(lhs);
-	}
-	if (rhs_negative) {
-		NegateInPlace(rhs);
-	}
-#if ((__GNUC__ >= 5) || defined(__clang__)) && defined(__SIZEOF_INT128__)
-	__uint128_t left = __uint128_t(lhs.lower) + (__uint128_t(lhs.upper) << 64);
-	__uint128_t right = __uint128_t(rhs.lower) + (__uint128_t(rhs.upper) << 64);
-	__uint128_t result_i128;
-	if (__builtin_mul_overflow(left, right, &result_i128)) {
-		return false;
-	}
-	uint64_t upper = uint64_t(result_i128 >> 64);
-	if (upper & 0x8000000000000000) {
-		return false;
-	}
-	result.upper = int64_t(upper);
-	result.lower = uint64_t(result_i128 & 0xffffffffffffffff);
-#else
-	// Multiply code adapted from:
-	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
-
-	// split values into 4 32-bit parts
-	uint64_t top[4] = {uint64_t(lhs.upper) >> 32, uint64_t(lhs.upper) & 0xffffffff, lhs.lower >> 32,
-	                   lhs.lower & 0xffffffff};
-	uint64_t bottom[4] = {uint64_t(rhs.upper) >> 32, uint64_t(rhs.upper) & 0xffffffff, rhs.lower >> 32,
-	                      rhs.lower & 0xffffffff};
-	uint64_t products[4][4];
-
-	// multiply each component of the values
-	for (auto x = 0; x < 4; x++) {
-		for (auto y = 0; y < 4; y++) {
-			products[x][y] = top[x] * bottom[y];
-		}
-	}
-
-	// if any of these products are set to a non-zero value, there is always an overflow
-	if (products[0][0] || products[0][1] || products[0][2] || products[1][0] || products[2][0] || products[1][1]) {
-		return false;
-	}
-	// if the high bits of any of these are set, there is always an overflow
-	if ((products[0][3] & 0xffffffff80000000) || (products[1][2] & 0xffffffff80000000) ||
-	    (products[2][1] & 0xffffffff80000000) || (products[3][0] & 0xffffffff80000000)) {
-		return false;
-	}
-
-	// otherwise we merge the result of the different products together in-order
-
-	// first row
-	uint64_t fourth32 = (products[3][3] & 0xffffffff);
-	uint64_t third32 = (products[3][2] & 0xffffffff) + (products[3][3] >> 32);
-	uint64_t second32 = (products[3][1] & 0xffffffff) + (products[3][2] >> 32);
-	uint64_t first32 = (products[3][0] & 0xffffffff) + (products[3][1] >> 32);
-
-	// second row
-	third32 += (products[2][3] & 0xffffffff);
-	second32 += (products[2][2] & 0xffffffff) + (products[2][3] >> 32);
-	first32 += (products[2][1] & 0xffffffff) + (products[2][2] >> 32);
-
-	// third row
-	second32 += (products[1][3] & 0xffffffff);
-	first32 += (products[1][2] & 0xffffffff) + (products[1][3] >> 32);
-
-	// fourth row
-	first32 += (products[0][3] & 0xffffffff);
-
-	// move carry to next digit
-	third32 += fourth32 >> 32;
-	second32 += third32 >> 32;
-	first32 += second32 >> 32;
-
-	// check if the combination of the different products resulted in an overflow
-	if (first32 & 0xffffff80000000) {
-		return false;
-	}
-
-	// remove carry from current digit
-	fourth32 &= 0xffffffff;
-	third32 &= 0xffffffff;
-	second32 &= 0xffffffff;
-	first32 &= 0xffffffff;
-
-	// combine components
-	result.lower = (third32 << 32) | fourth32;
-	result.upper = (first32 << 32) | second32;
-#endif
-	if (lhs_negative ^ rhs_negative) {
-		NegateInPlace(result);
-	}
-	return true;
-}
-
-hugeint_t Hugeint::Multiply(hugeint_t lhs, hugeint_t rhs) {
-	hugeint_t result;
-	if (!TryMultiply(lhs, rhs, result)) {
-		throw OutOfRangeException("Overflow in HUGEINT multiplication!");
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Divide
-//===--------------------------------------------------------------------===//
-hugeint_t Hugeint::DivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder) {
-	// division by zero not allowed
-	D_ASSERT(!(rhs.upper == 0 && rhs.lower == 0));
-
-	bool lhs_negative = lhs.upper < 0;
-	bool rhs_negative = rhs.upper < 0;
-	if (lhs_negative) {
-		Hugeint::NegateInPlace(lhs);
-	}
-	if (rhs_negative) {
-		Hugeint::NegateInPlace(rhs);
-	}
-	// DivMod code adapted from:
-	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
-
-	// initialize the result and remainder to 0
-	hugeint_t div_result;
-	div_result.lower = 0;
-	div_result.upper = 0;
-	remainder.lower = 0;
-	remainder.upper = 0;
-
-	uint8_t highest_bit_set = PositiveHugeintHighestBit(lhs);
-	// now iterate over the amount of bits that are set in the LHS
-	for (uint8_t x = highest_bit_set; x > 0; x--) {
-		// left-shift the current result and remainder by 1
-		div_result = PositiveHugeintLeftShift(div_result, 1);
-		remainder = PositiveHugeintLeftShift(remainder, 1);
-
-		// we get the value of the bit at position X, where position 0 is the least-significant bit
-		if (PositiveHugeintIsBitSet(lhs, x - 1)) {
-			// increment the remainder
-			Hugeint::AddInPlace(remainder, 1);
-		}
-		if (Hugeint::GreaterThanEquals(remainder, rhs)) {
-			// the remainder has passed the division multiplier: add one to the divide result
-			remainder = Hugeint::Subtract(remainder, rhs);
-			Hugeint::AddInPlace(div_result, 1);
-		}
-	}
-	if (lhs_negative ^ rhs_negative) {
-		Hugeint::NegateInPlace(div_result);
-	}
-	if (lhs_negative) {
-		Hugeint::NegateInPlace(remainder);
-	}
-	return div_result;
-}
-
-hugeint_t Hugeint::Divide(hugeint_t lhs, hugeint_t rhs) {
-	hugeint_t remainder;
-	return Hugeint::DivMod(lhs, rhs, remainder);
-}
-
-hugeint_t Hugeint::Modulo(hugeint_t lhs, hugeint_t rhs) {
-	hugeint_t remainder;
-	Hugeint::DivMod(lhs, rhs, remainder);
-	return remainder;
-}
-
-//===--------------------------------------------------------------------===//
-// Add/Subtract
-//===--------------------------------------------------------------------===//
-bool Hugeint::AddInPlace(hugeint_t &lhs, hugeint_t rhs) {
-	int overflow = lhs.lower + rhs.lower < lhs.lower;
-	if (rhs.upper >= 0) {
-		// RHS is positive: check for overflow
-		if (lhs.upper > (std::numeric_limits<int64_t>::max() - rhs.upper - overflow)) {
-			return false;
-		}
-		lhs.upper = lhs.upper + overflow + rhs.upper;
-	} else {
-		// RHS is negative: check for underflow
-		if (lhs.upper < std::numeric_limits<int64_t>::min() - rhs.upper - overflow) {
-			return false;
-		}
-		lhs.upper = lhs.upper + (overflow + rhs.upper);
-	}
-	lhs.lower += rhs.lower;
-	if (lhs.upper == std::numeric_limits<int64_t>::min() && lhs.lower == 0) {
-		return false;
-	}
-	return true;
-}
-
-bool Hugeint::SubtractInPlace(hugeint_t &lhs, hugeint_t rhs) {
-	// underflow
-	int underflow = lhs.lower - rhs.lower > lhs.lower;
-	if (rhs.upper >= 0) {
-		// RHS is positive: check for underflow
-		if (lhs.upper < (std::numeric_limits<int64_t>::min() + rhs.upper + underflow)) {
-			return false;
-		}
-		lhs.upper = (lhs.upper - rhs.upper) - underflow;
-	} else {
-		// RHS is negative: check for overflow
-		if (lhs.upper > std::numeric_limits<int64_t>::min() &&
-		    lhs.upper - 1 >= (std::numeric_limits<int64_t>::max() + rhs.upper + underflow)) {
-			return false;
-		}
-		lhs.upper = lhs.upper - (rhs.upper + underflow);
-	}
-	lhs.lower -= rhs.lower;
-	if (lhs.upper == std::numeric_limits<int64_t>::min() && lhs.lower == 0) {
-		return false;
-	}
-	return true;
-}
-
-hugeint_t Hugeint::Add(hugeint_t lhs, hugeint_t rhs) {
-	if (!AddInPlace(lhs, rhs)) {
-		throw OutOfRangeException("Overflow in HUGEINT addition");
-	}
-	return lhs;
-}
-
-hugeint_t Hugeint::Subtract(hugeint_t lhs, hugeint_t rhs) {
-	if (!SubtractInPlace(lhs, rhs)) {
-		throw OutOfRangeException("Underflow in HUGEINT addition");
-	}
-	return lhs;
-}
-
-//===--------------------------------------------------------------------===//
-// Hugeint Cast/Conversion
-//===--------------------------------------------------------------------===//
-template <class DST, bool SIGNED = true>
-bool HugeintTryCastInteger(hugeint_t input, DST &result) {
-	switch (input.upper) {
-	case 0:
-		// positive number: check if the positive number is in range
-		if (input.lower <= uint64_t(NumericLimits<DST>::Maximum())) {
-			result = DST(input.lower);
-			return true;
-		}
-		break;
-	case -1:
-		if (!SIGNED) {
-			return false;
-		}
-		// negative number: check if the negative number is in range
-		if (input.lower >= NumericLimits<uint64_t>::Maximum() - uint64_t(NumericLimits<DST>::Maximum())) {
-			result = -DST(NumericLimits<uint64_t>::Maximum() - input.lower) - 1;
-			return true;
-		}
-		break;
-	default:
-		break;
-	}
-	return false;
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int8_t &result) {
-	return HugeintTryCastInteger<int8_t>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int16_t &result) {
-	return HugeintTryCastInteger<int16_t>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int32_t &result) {
-	return HugeintTryCastInteger<int32_t>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int64_t &result) {
-	return HugeintTryCastInteger<int64_t>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint8_t &result) {
-	return HugeintTryCastInteger<uint8_t, false>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint16_t &result) {
-	return HugeintTryCastInteger<uint16_t, false>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint32_t &result) {
-	return HugeintTryCastInteger<uint32_t, false>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint64_t &result) {
-	return HugeintTryCastInteger<uint64_t, false>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, hugeint_t &result) {
-	result = input;
-	return true;
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, float &result) {
-	double dbl_result;
-	Hugeint::TryCast(input, dbl_result);
-	result = (float)dbl_result;
-	return true;
-}
-
-template <class REAL_T>
-bool CastBigintToFloating(hugeint_t input, REAL_T &result) {
-	switch (input.upper) {
-	case -1:
-		// special case for upper = -1 to avoid rounding issues in small negative numbers
-		result = -REAL_T(NumericLimits<uint64_t>::Maximum() - input.lower) - 1;
-		break;
-	default:
-		result = REAL_T(input.lower) + REAL_T(input.upper) * REAL_T(NumericLimits<uint64_t>::Maximum());
-		break;
-	}
-	return true;
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, double &result) {
-	return CastBigintToFloating<double>(input, result);
-}
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, long double &result) {
-	return CastBigintToFloating<long double>(input, result);
-}
-
-template <class DST>
-hugeint_t HugeintConvertInteger(DST input) {
-	hugeint_t result;
-	result.lower = (uint64_t)input;
-	result.upper = (input < 0) * -1;
-	return result;
-}
-
-template <>
-bool Hugeint::TryConvert(int8_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<int8_t>(value);
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(int16_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<int16_t>(value);
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(int32_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<int32_t>(value);
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(int64_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<int64_t>(value);
-	return true;
-}
-template <>
-bool Hugeint::TryConvert(uint8_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<uint8_t>(value);
-	return true;
-}
-template <>
-bool Hugeint::TryConvert(uint16_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<uint16_t>(value);
-	return true;
-}
-template <>
-bool Hugeint::TryConvert(uint32_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<uint32_t>(value);
-	return true;
-}
-template <>
-bool Hugeint::TryConvert(uint64_t value, hugeint_t &result) {
-	result = HugeintConvertInteger<uint64_t>(value);
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(float value, hugeint_t &result) {
-	return Hugeint::TryConvert(double(value), result);
-}
-
-template <class REAL_T>
-bool ConvertFloatingToBigint(REAL_T value, hugeint_t &result) {
-	if (!Value::IsFinite<REAL_T>(value)) {
-		return false;
-	}
-	if (value <= -170141183460469231731687303715884105728.0 || value >= 170141183460469231731687303715884105727.0) {
-		return false;
-	}
-	bool negative = value < 0;
-	if (negative) {
-		value = -value;
-	}
-	result.lower = (uint64_t)fmod(value, REAL_T(NumericLimits<uint64_t>::Maximum()));
-	result.upper = (uint64_t)(value / REAL_T(NumericLimits<uint64_t>::Maximum()));
-	if (negative) {
-		Hugeint::NegateInPlace(result);
-	}
-	return true;
-}
-
-template <>
-bool Hugeint::TryConvert(double value, hugeint_t &result) {
-	return ConvertFloatingToBigint<double>(value, result);
-}
-
-template <>
-bool Hugeint::TryConvert(long double value, hugeint_t &result) {
-	return ConvertFloatingToBigint<long double>(value, result);
-}
-
-//===--------------------------------------------------------------------===//
-// hugeint_t operators
-//===--------------------------------------------------------------------===//
-hugeint_t::hugeint_t(int64_t value) {
-	auto result = Hugeint::Convert(value);
-	this->lower = result.lower;
-	this->upper = result.upper;
-}
-
-bool hugeint_t::operator==(const hugeint_t &rhs) const {
-	return Hugeint::Equals(*this, rhs);
-}
-
-bool hugeint_t::operator!=(const hugeint_t &rhs) const {
-	return Hugeint::NotEquals(*this, rhs);
-}
-
-bool hugeint_t::operator<(const hugeint_t &rhs) const {
-	return Hugeint::LessThan(*this, rhs);
-}
-
-bool hugeint_t::operator<=(const hugeint_t &rhs) const {
-	return Hugeint::LessThanEquals(*this, rhs);
-}
-
-bool hugeint_t::operator>(const hugeint_t &rhs) const {
-	return Hugeint::GreaterThan(*this, rhs);
-}
-
-bool hugeint_t::operator>=(const hugeint_t &rhs) const {
-	return Hugeint::GreaterThanEquals(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator+(const hugeint_t &rhs) const {
-	return Hugeint::Add(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator-(const hugeint_t &rhs) const {
-	return Hugeint::Subtract(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator*(const hugeint_t &rhs) const {
-	return Hugeint::Multiply(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator/(const hugeint_t &rhs) const {
-	return Hugeint::Divide(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator%(const hugeint_t &rhs) const {
-	return Hugeint::Modulo(*this, rhs);
-}
-
-hugeint_t hugeint_t::operator-() const {
-	return Hugeint::Negate(*this);
-}
-
-hugeint_t hugeint_t::operator>>(const hugeint_t &rhs) const {
-	hugeint_t result;
-	uint64_t shift = rhs.lower;
-	if (rhs.upper != 0 || shift >= 128) {
-		return hugeint_t(0);
-	} else if (shift == 0) {
-		return *this;
-	} else if (shift == 64) {
-		result.upper = (upper < 0) ? -1 : 0;
-		result.lower = upper;
-	} else if (shift < 64) {
-		// perform lower shift in unsigned integer, and mask away the most significant bit
-		result.lower = (uint64_t(upper) << (64 - shift)) | (lower >> shift);
-		result.upper = upper >> shift;
-	} else {
-		D_ASSERT(shift < 128);
-		result.lower = upper >> (shift - 64);
-		result.upper = (upper < 0) ? -1 : 0;
-	}
-	return result;
-}
-
-hugeint_t hugeint_t::operator<<(const hugeint_t &rhs) const {
-	if (upper < 0) {
-		return hugeint_t(0);
-	}
-	hugeint_t result;
-	uint64_t shift = rhs.lower;
-	if (rhs.upper != 0 || shift >= 128) {
-		return hugeint_t(0);
-	} else if (shift == 64) {
-		result.upper = lower;
-		result.lower = 0;
-	} else if (shift == 0) {
-		return *this;
-	} else if (shift < 64) {
-		// perform upper shift in unsigned integer, and mask away the most significant bit
-		uint64_t upper_shift = ((uint64_t(upper) << shift) + (lower >> (64 - shift))) & 0x7FFFFFFFFFFFFFFF;
-		result.lower = lower << shift;
-		result.upper = upper_shift;
-	} else {
-		D_ASSERT(shift < 128);
-		result.lower = 0;
-		result.upper = (lower << (shift - 64)) & 0x7FFFFFFFFFFFFFFF;
-	}
-	return result;
-}
-
-hugeint_t hugeint_t::operator&(const hugeint_t &rhs) const {
-	hugeint_t result;
-	result.lower = lower & rhs.lower;
-	result.upper = upper & rhs.upper;
-	return result;
-}
-
-hugeint_t hugeint_t::operator|(const hugeint_t &rhs) const {
-	hugeint_t result;
-	result.lower = lower | rhs.lower;
-	result.upper = upper | rhs.upper;
-	return result;
-}
-
-hugeint_t hugeint_t::operator^(const hugeint_t &rhs) const {
-	hugeint_t result;
-	result.lower = lower ^ rhs.lower;
-	result.upper = upper ^ rhs.upper;
-	return result;
-}
-
-hugeint_t hugeint_t::operator~() const {
-	hugeint_t result;
-	result.lower = ~lower;
-	result.upper = ~upper;
-	return result;
-}
-
-hugeint_t &hugeint_t::operator+=(const hugeint_t &rhs) {
-	Hugeint::AddInPlace(*this, rhs);
-	return *this;
-}
-hugeint_t &hugeint_t::operator-=(const hugeint_t &rhs) {
-	Hugeint::SubtractInPlace(*this, rhs);
-	return *this;
-}
-hugeint_t &hugeint_t::operator*=(const hugeint_t &rhs) {
-	*this = Hugeint::Multiply(*this, rhs);
-	return *this;
-}
-hugeint_t &hugeint_t::operator/=(const hugeint_t &rhs) {
-	*this = Hugeint::Divide(*this, rhs);
-	return *this;
-}
-hugeint_t &hugeint_t::operator%=(const hugeint_t &rhs) {
-	*this = Hugeint::Modulo(*this, rhs);
-	return *this;
-}
-hugeint_t &hugeint_t::operator>>=(const hugeint_t &rhs) {
-	*this = *this >> rhs;
-	return *this;
-}
-hugeint_t &hugeint_t::operator<<=(const hugeint_t &rhs) {
-	*this = *this << rhs;
-	return *this;
-}
-hugeint_t &hugeint_t::operator&=(const hugeint_t &rhs) {
-	lower &= rhs.lower;
-	upper &= rhs.upper;
-	return *this;
-}
-hugeint_t &hugeint_t::operator|=(const hugeint_t &rhs) {
-	lower |= rhs.lower;
-	upper |= rhs.upper;
-	return *this;
-}
-hugeint_t &hugeint_t::operator^=(const hugeint_t &rhs) {
-	lower ^= rhs.lower;
-	upper ^= rhs.upper;
-	return *this;
-}
-
-string hugeint_t::ToString() const {
-	return Hugeint::ToString(*this);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-HyperLogLog::HyperLogLog() : hll(nullptr) {
-	hll = duckdb_hll::hll_create();
-	// Insert into a dense hll can be vectorized, sparse cannot, so we immediately convert
-	duckdb_hll::hllSparseToDense((duckdb_hll::robj *)hll);
-}
-
-HyperLogLog::HyperLogLog(void *hll) : hll(hll) {
-}
-
-HyperLogLog::~HyperLogLog() {
-	duckdb_hll::hll_destroy((duckdb_hll::robj *)hll);
-}
-
-void HyperLogLog::Add(data_ptr_t element, idx_t size) {
-	if (duckdb_hll::hll_add((duckdb_hll::robj *)hll, element, size) == HLL_C_ERR) {
-		throw InternalException("Could not add to HLL?");
-	}
-}
-
-idx_t HyperLogLog::Count() const {
-	// exception from size_t ban
-	size_t result;
-
-	if (duckdb_hll::hll_count((duckdb_hll::robj *)hll, &result) != HLL_C_OK) {
-		throw InternalException("Could not count HLL?");
-	}
-	return result;
-}
-
-unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog &other) {
-	duckdb_hll::robj *hlls[2];
-	hlls[0] = (duckdb_hll::robj *)hll;
-	hlls[1] = (duckdb_hll::robj *)other.hll;
-	auto new_hll = duckdb_hll::hll_merge(hlls, 2);
-	if (!new_hll) {
-		throw InternalException("Could not merge HLLs");
-	}
-	return unique_ptr<HyperLogLog>(new HyperLogLog((void *)new_hll));
-}
-
-HyperLogLog *HyperLogLog::MergePointer(HyperLogLog &other) {
-	duckdb_hll::robj *hlls[2];
-	hlls[0] = (duckdb_hll::robj *)hll;
-	hlls[1] = (duckdb_hll::robj *)other.hll;
-	auto new_hll = duckdb_hll::hll_merge(hlls, 2);
-	if (!new_hll) {
-		throw Exception("Could not merge HLLs");
-	}
-	return new HyperLogLog((void *)new_hll);
-}
-
-unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog logs[], idx_t count) {
-	auto hlls_uptr = unique_ptr<duckdb_hll::robj *[]> {
-		new duckdb_hll::robj *[count]
-	};
-	auto hlls = hlls_uptr.get();
-	for (idx_t i = 0; i < count; i++) {
-		hlls[i] = (duckdb_hll::robj *)logs[i].hll;
-	}
-	auto new_hll = duckdb_hll::hll_merge(hlls, count);
-	if (!new_hll) {
-		throw InternalException("Could not merge HLLs");
-	}
-	return unique_ptr<HyperLogLog>(new HyperLogLog((void *)new_hll));
-}
-
-idx_t HyperLogLog::GetSize() {
-	return duckdb_hll::get_size();
-}
-
-data_ptr_t HyperLogLog::GetPtr() const {
-	return (data_ptr_t)((duckdb_hll::robj *)hll)->ptr;
-}
-
-unique_ptr<HyperLogLog> HyperLogLog::Copy() {
-	auto result = make_unique<HyperLogLog>();
-	lock_guard<mutex> guard(lock);
-	memcpy(result->GetPtr(), GetPtr(), GetSize());
-	D_ASSERT(result->Count() == Count());
-	return result;
-}
-
-void HyperLogLog::Serialize(FieldWriter &writer) const {
-	writer.WriteField<HLLStorageType>(HLLStorageType::UNCOMPRESSED);
-	writer.WriteBlob(GetPtr(), GetSize());
-}
-
-unique_ptr<HyperLogLog> HyperLogLog::Deserialize(FieldReader &reader) {
-	auto result = make_unique<HyperLogLog>();
-	auto storage_type = reader.ReadRequired<HLLStorageType>();
-	switch (storage_type) {
-	case HLLStorageType::UNCOMPRESSED:
-		reader.ReadBlob(result->GetPtr(), GetSize());
-		break;
-	default:
-		throw SerializationException("Unknown HyperLogLog storage type!");
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Vectorized HLL implementation
-//===--------------------------------------------------------------------===//
-//! Taken from https://nullprogram.com/blog/2018/07/31/
-template <class T>
-inline uint64_t TemplatedHash(const T &elem) {
-	uint64_t x = elem;
-	x ^= x >> 30;
-	x *= UINT64_C(0xbf58476d1ce4e5b9);
-	x ^= x >> 27;
-	x *= UINT64_C(0x94d049bb133111eb);
-	x ^= x >> 31;
-	return x;
-}
-
-template <>
-inline uint64_t TemplatedHash(const hugeint_t &elem) {
-	return TemplatedHash<uint64_t>(Load<uint64_t>((data_ptr_t)&elem.upper)) ^ TemplatedHash<uint64_t>(elem.lower);
-}
-
-template <idx_t rest>
-inline void CreateIntegerRecursive(const data_ptr_t &data, uint64_t &x) {
-	x ^= (uint64_t)data[rest - 1] << ((rest - 1) * 8);
-	return CreateIntegerRecursive<rest - 1>(data, x);
-}
-
-template <>
-inline void CreateIntegerRecursive<1>(const data_ptr_t &data, uint64_t &x) {
-	x ^= (uint64_t)data[0];
-}
-
-inline uint64_t HashOtherSize(const data_ptr_t &data, const idx_t &len) {
-	uint64_t x = 0;
-	switch (len & 7) {
-	case 7:
-		CreateIntegerRecursive<7>(data, x);
-		break;
-	case 6:
-		CreateIntegerRecursive<6>(data, x);
-		break;
-	case 5:
-		CreateIntegerRecursive<5>(data, x);
-		break;
-	case 4:
-		CreateIntegerRecursive<4>(data, x);
-		break;
-	case 3:
-		CreateIntegerRecursive<3>(data, x);
-		break;
-	case 2:
-		CreateIntegerRecursive<2>(data, x);
-		break;
-	case 1:
-		CreateIntegerRecursive<1>(data, x);
-		break;
-	case 0:
-		break;
-	}
-	return TemplatedHash<uint64_t>(x);
-}
-
-template <>
-inline uint64_t TemplatedHash(const string_t &elem) {
-	data_ptr_t data = (data_ptr_t)elem.GetDataUnsafe();
-	const auto &len = elem.GetSize();
-	uint64_t h = 0;
-	for (idx_t i = 0; i + sizeof(uint64_t) <= len; i += sizeof(uint64_t)) {
-		h ^= TemplatedHash<uint64_t>(Load<uint64_t>(data));
-		data += sizeof(uint64_t);
-	}
-	switch (len & (sizeof(uint64_t) - 1)) {
-	case 4:
-		h ^= TemplatedHash<uint32_t>(Load<uint32_t>(data));
-		break;
-	case 2:
-		h ^= TemplatedHash<uint16_t>(Load<uint16_t>(data));
-		break;
-	case 1:
-		h ^= TemplatedHash<uint8_t>(Load<uint8_t>(data));
-		break;
-	default:
-		h ^= HashOtherSize(data, len);
-	}
-	return h;
-}
-
-template <class T>
-void TemplatedComputeHashes(VectorData &vdata, const idx_t &count, uint64_t hashes[]) {
-	T *data = (T *)vdata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (vdata.validity.RowIsValid(idx)) {
-			hashes[i] = TemplatedHash<T>(data[idx]);
-		} else {
-			hashes[i] = 0;
-		}
-	}
-}
-
-static void ComputeHashes(VectorData &vdata, const LogicalType &type, uint64_t hashes[], idx_t count) {
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::UINT8:
-		return TemplatedComputeHashes<uint8_t>(vdata, count, hashes);
-	case PhysicalType::INT16:
-	case PhysicalType::UINT16:
-		return TemplatedComputeHashes<uint16_t>(vdata, count, hashes);
-	case PhysicalType::INT32:
-	case PhysicalType::UINT32:
-	case PhysicalType::FLOAT:
-		return TemplatedComputeHashes<uint32_t>(vdata, count, hashes);
-	case PhysicalType::INT64:
-	case PhysicalType::UINT64:
-	case PhysicalType::DOUBLE:
-		return TemplatedComputeHashes<uint64_t>(vdata, count, hashes);
-	case PhysicalType::INT128:
-	case PhysicalType::INTERVAL:
-		static_assert(sizeof(hugeint_t) == sizeof(interval_t), "ComputeHashes assumes these are the same size!");
-		return TemplatedComputeHashes<hugeint_t>(vdata, count, hashes);
-	case PhysicalType::VARCHAR:
-		return TemplatedComputeHashes<string_t>(vdata, count, hashes);
-	default:
-		throw InternalException("Unimplemented type for HyperLogLog::ComputeHashes");
-	}
-}
-
-//! Taken from https://stackoverflow.com/a/72088344
-static inline uint8_t CountTrailingZeros(uint64_t &x) {
-	static constexpr const uint64_t DEBRUIJN = 0x03f79d71b4cb0a89;
-	static constexpr const uint8_t LOOKUP[] = {0,  47, 1,  56, 48, 27, 2,  60, 57, 49, 41, 37, 28, 16, 3,  61,
-	                                           54, 58, 35, 52, 50, 42, 21, 44, 38, 32, 29, 23, 17, 11, 4,  62,
-	                                           46, 55, 26, 59, 40, 36, 15, 53, 34, 51, 20, 43, 31, 22, 10, 45,
-	                                           25, 39, 14, 33, 19, 30, 9,  24, 13, 18, 8,  12, 7,  6,  5,  63};
-	return LOOKUP[(DEBRUIJN * (x ^ (x - 1))) >> 58];
-}
-
-static inline void ComputeIndexAndCount(uint64_t &hash, uint8_t &prefix) {
-	uint64_t index = hash & ((1 << 12) - 1); /* Register index. */
-	hash >>= 12;                             /* Remove bits used to address the register. */
-	hash |= ((uint64_t)1 << (64 - 12));      /* Make sure the count will be <= Q+1. */
-
-	prefix = CountTrailingZeros(hash) + 1; /* Add 1 since we count the "00000...1" pattern. */
-	hash = index;
-}
-
-void HyperLogLog::ProcessEntries(VectorData &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
-                                 idx_t count) {
-	ComputeHashes(vdata, type, hashes, count);
-	for (idx_t i = 0; i < count; i++) {
-		ComputeIndexAndCount(hashes[i], counts[i]);
-	}
-}
-
-void HyperLogLog::AddToLogs(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], HyperLogLog **logs[],
-                            const SelectionVector *log_sel) {
-	AddToLogsInternal(vdata, count, indices, counts, (void ****)logs, log_sel);
-}
-
-void HyperLogLog::AddToLog(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[]) {
-	lock_guard<mutex> guard(lock);
-	AddToSingleLogInternal(vdata, count, indices, counts, hll);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-bool Interval::FromString(const string &str, interval_t &result) {
-	string error_message;
-	return Interval::FromCString(str.c_str(), str.size(), result, &error_message, false);
-}
-
-template <class T>
-void IntervalTryAddition(T &target, int64_t input, int64_t multiplier) {
-	int64_t addition;
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(input, multiplier, addition)) {
-		throw OutOfRangeException("interval value is out of range");
-	}
-	T addition_base = Cast::Operation<int64_t, T>(addition);
-	if (!TryAddOperator::Operation<T, T, T>(target, addition_base, target)) {
-		throw OutOfRangeException("interval value is out of range");
-	}
-}
-
-bool Interval::FromCString(const char *str, idx_t len, interval_t &result, string *error_message, bool strict) {
-	idx_t pos = 0;
-	idx_t start_pos;
-	bool negative;
-	bool found_any = false;
-	int64_t number;
-	DatePartSpecifier specifier;
-	string specifier_str;
-
-	result.days = 0;
-	result.micros = 0;
-	result.months = 0;
-
-	if (len == 0) {
-		return false;
-	}
-
-	switch (str[pos]) {
-	case '@':
-		pos++;
-		goto standard_interval;
-	case 'P':
-	case 'p':
-		pos++;
-		goto posix_interval;
-	default:
-		goto standard_interval;
-	}
-standard_interval:
-	// start parsing a standard interval (e.g. 2 years 3 months...)
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if (c == ' ' || c == '\t' || c == '\n') {
-			// skip spaces
-			continue;
-		} else if (c >= '0' && c <= '9') {
-			// start parsing a positive number
-			negative = false;
-			goto interval_parse_number;
-		} else if (c == '-') {
-			// negative number
-			negative = true;
-			pos++;
-			goto interval_parse_number;
-		} else if (c == 'a' || c == 'A') {
-			// parse the word "ago" as the final specifier
-			goto interval_parse_ago;
-		} else {
-			// unrecognized character, expected a number or end of string
-			return false;
-		}
-	}
-	goto end_of_string;
-interval_parse_number:
-	start_pos = pos;
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if (c >= '0' && c <= '9') {
-			// the number continues
-			continue;
-		} else if (c == ':') {
-			// colon: we are parsing a time
-			goto interval_parse_time;
-		} else {
-			if (pos == start_pos) {
-				return false;
-			}
-			// finished the number, parse it from the string
-			string_t nr_string(str + start_pos, pos - start_pos);
-			number = Cast::Operation<string_t, int64_t>(nr_string);
-			if (negative) {
-				number = -number;
-			}
-			goto interval_parse_identifier;
-		}
-	}
-	goto end_of_string;
-interval_parse_time : {
-	// parse the remainder of the time as a Time type
-	dtime_t time;
-	idx_t pos;
-	if (!Time::TryConvertTime(str + start_pos, len - start_pos, pos, time)) {
-		return false;
-	}
-	result.micros += time.micros;
-	found_any = true;
-	goto end_of_string;
-}
-interval_parse_identifier:
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if (c == ' ' || c == '\t' || c == '\n') {
-			// skip spaces at the start
-			continue;
-		} else {
-			break;
-		}
-	}
-	// now parse the identifier
-	start_pos = pos;
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
-			// keep parsing the string
-			continue;
-		} else {
-			break;
-		}
-	}
-	specifier_str = string(str + start_pos, pos - start_pos);
-	if (!TryGetDatePartSpecifier(specifier_str, specifier)) {
-		HandleCastError::AssignError(StringUtil::Format("extract specifier \"%s\" not recognized", specifier_str),
-		                             error_message);
-		return false;
-	}
-	// add the specifier to the interval
-	switch (specifier) {
-	case DatePartSpecifier::MILLENNIUM:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_MILLENIUM);
-		break;
-	case DatePartSpecifier::CENTURY:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_CENTURY);
-		break;
-	case DatePartSpecifier::DECADE:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_DECADE);
-		break;
-	case DatePartSpecifier::YEAR:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_YEAR);
-		break;
-	case DatePartSpecifier::QUARTER:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_QUARTER);
-		break;
-	case DatePartSpecifier::MONTH:
-		IntervalTryAddition<int32_t>(result.months, number, 1);
-		break;
-	case DatePartSpecifier::DAY:
-		IntervalTryAddition<int32_t>(result.days, number, 1);
-		break;
-	case DatePartSpecifier::WEEK:
-		IntervalTryAddition<int32_t>(result.days, number, DAYS_PER_WEEK);
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		IntervalTryAddition<int64_t>(result.micros, number, 1);
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_MSEC);
-		break;
-	case DatePartSpecifier::SECOND:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_SEC);
-		break;
-	case DatePartSpecifier::MINUTE:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_MINUTE);
-		break;
-	case DatePartSpecifier::HOUR:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_HOUR);
-		break;
-	default:
-		HandleCastError::AssignError(
-		    StringUtil::Format("extract specifier \"%s\" not supported for interval", specifier_str), error_message);
-		return false;
-	}
-	found_any = true;
-	goto standard_interval;
-interval_parse_ago:
-	D_ASSERT(str[pos] == 'a' || str[pos] == 'A');
-	// parse the "ago" string at the end of the interval
-	if (len - pos < 3) {
-		return false;
-	}
-	pos++;
-	if (!(str[pos] == 'g' || str[pos] == 'G')) {
-		return false;
-	}
-	pos++;
-	if (!(str[pos] == 'o' || str[pos] == 'O')) {
-		return false;
-	}
-	pos++;
-	// parse any trailing whitespace
-	for (; pos < len; pos++) {
-		char c = str[pos];
-		if (c == ' ' || c == '\t' || c == '\n') {
-			continue;
-		} else {
-			return false;
-		}
-	}
-	// invert all the values
-	result.months = -result.months;
-	result.days = -result.days;
-	result.micros = -result.micros;
-	goto end_of_string;
-end_of_string:
-	if (!found_any) {
-		// end of string and no identifiers were found: cannot convert empty interval
-		return false;
-	}
-	return true;
-posix_interval:
-	return false;
-}
-
-string Interval::ToString(const interval_t &interval) {
-	char buffer[70];
-	idx_t length = IntervalToStringCast::Format(interval, buffer);
-	return string(buffer, length);
-}
-
-int64_t Interval::GetMilli(const interval_t &val) {
-	int64_t milli_month, milli_day, milli;
-	if (!TryMultiplyOperator::Operation((int64_t)val.months, Interval::MICROS_PER_MONTH / 1000, milli_month)) {
-		throw ConversionException("Could not convert Interval to Milliseconds");
-	}
-	if (!TryMultiplyOperator::Operation((int64_t)val.days, Interval::MICROS_PER_DAY / 1000, milli_day)) {
-		throw ConversionException("Could not convert Interval to Milliseconds");
-	}
-	milli = val.micros / 1000;
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(milli, milli_month, milli)) {
-		throw ConversionException("Could not convert Interval to Milliseconds");
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(milli, milli_day, milli)) {
-		throw ConversionException("Could not convert Interval to Milliseconds");
-	}
-	return milli;
-}
-
-int64_t Interval::GetMicro(const interval_t &val) {
-	int64_t micro_month, micro_day, micro_total;
-	micro_total = val.micros;
-	if (!TryMultiplyOperator::Operation((int64_t)val.months, MICROS_PER_MONTH, micro_month)) {
-		throw ConversionException("Could not convert Month to Microseconds");
-	}
-	if (!TryMultiplyOperator::Operation((int64_t)val.days, MICROS_PER_DAY, micro_day)) {
-		throw ConversionException("Could not convert Day to Microseconds");
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(micro_total, micro_month, micro_total)) {
-		throw ConversionException("Could not convert Interval to Microseconds");
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(micro_total, micro_day, micro_total)) {
-		throw ConversionException("Could not convert Interval to Microseconds");
-	}
-
-	return micro_total;
-}
-
-int64_t Interval::GetNanoseconds(const interval_t &val) {
-	int64_t nano;
-	const auto micro_total = GetMicro(val);
-	if (!TryMultiplyOperator::Operation(micro_total, NANOS_PER_MICRO, nano)) {
-		throw ConversionException("Could not convert Interval to Nanoseconds");
-	}
-
-	return nano;
-}
-
-interval_t Interval::GetAge(timestamp_t timestamp_1, timestamp_t timestamp_2) {
-	D_ASSERT(Timestamp::IsFinite(timestamp_1) && Timestamp::IsFinite(timestamp_2));
-	date_t date1, date2;
-	dtime_t time1, time2;
-
-	Timestamp::Convert(timestamp_1, date1, time1);
-	Timestamp::Convert(timestamp_2, date2, time2);
-
-	// and from date extract the years, months and days
-	int32_t year1, month1, day1;
-	int32_t year2, month2, day2;
-	Date::Convert(date1, year1, month1, day1);
-	Date::Convert(date2, year2, month2, day2);
-	// finally perform the differences
-	auto year_diff = year1 - year2;
-	auto month_diff = month1 - month2;
-	auto day_diff = day1 - day2;
-
-	// and from time extract hours, minutes, seconds and milliseconds
-	int32_t hour1, min1, sec1, micros1;
-	int32_t hour2, min2, sec2, micros2;
-	Time::Convert(time1, hour1, min1, sec1, micros1);
-	Time::Convert(time2, hour2, min2, sec2, micros2);
-	// finally perform the differences
-	auto hour_diff = hour1 - hour2;
-	auto min_diff = min1 - min2;
-	auto sec_diff = sec1 - sec2;
-	auto micros_diff = micros1 - micros2;
-
-	// flip sign if necessary
-	bool sign_flipped = false;
-	if (timestamp_1 < timestamp_2) {
-		year_diff = -year_diff;
-		month_diff = -month_diff;
-		day_diff = -day_diff;
-		hour_diff = -hour_diff;
-		min_diff = -min_diff;
-		sec_diff = -sec_diff;
-		micros_diff = -micros_diff;
-		sign_flipped = true;
-	}
-	// now propagate any negative field into the next higher field
-	while (micros_diff < 0) {
-		micros_diff += MICROS_PER_SEC;
-		sec_diff--;
-	}
-	while (sec_diff < 0) {
-		sec_diff += SECS_PER_MINUTE;
-		min_diff--;
-	}
-	while (min_diff < 0) {
-		min_diff += MINS_PER_HOUR;
-		hour_diff--;
-	}
-	while (hour_diff < 0) {
-		hour_diff += HOURS_PER_DAY;
-		day_diff--;
-	}
-	while (day_diff < 0) {
-		if (timestamp_1 < timestamp_2) {
-			day_diff += Date::IsLeapYear(year1) ? Date::LEAP_DAYS[month1] : Date::NORMAL_DAYS[month1];
-			month_diff--;
-		} else {
-			day_diff += Date::IsLeapYear(year2) ? Date::LEAP_DAYS[month2] : Date::NORMAL_DAYS[month2];
-			month_diff--;
-		}
-	}
-	while (month_diff < 0) {
-		month_diff += MONTHS_PER_YEAR;
-		year_diff--;
-	}
-
-	// recover sign if necessary
-	if (sign_flipped) {
-		year_diff = -year_diff;
-		month_diff = -month_diff;
-		day_diff = -day_diff;
-		hour_diff = -hour_diff;
-		min_diff = -min_diff;
-		sec_diff = -sec_diff;
-		micros_diff = -micros_diff;
-	}
-	interval_t interval;
-	interval.months = year_diff * MONTHS_PER_YEAR + month_diff;
-	interval.days = day_diff;
-	interval.micros = Time::FromTime(hour_diff, min_diff, sec_diff, micros_diff).micros;
-
-	return interval;
-}
-
-interval_t Interval::GetDifference(timestamp_t timestamp_1, timestamp_t timestamp_2) {
-	if (!Timestamp::IsFinite(timestamp_1) || !Timestamp::IsFinite(timestamp_2)) {
-		throw InvalidInputException("Cannot subtract infinite timestamps");
-	}
-	const auto us_1 = Timestamp::GetEpochMicroSeconds(timestamp_1);
-	const auto us_2 = Timestamp::GetEpochMicroSeconds(timestamp_2);
-	int64_t delta_us;
-	if (!TrySubtractOperator::Operation(us_1, us_2, delta_us)) {
-		throw ConversionException("Timestamp difference is out of bounds");
-	}
-	return FromMicro(delta_us);
-}
-
-interval_t Interval::FromMicro(int64_t delta_us) {
-	interval_t result;
-	result.months = 0;
-	result.days = delta_us / Interval::MICROS_PER_DAY;
-	result.micros = delta_us % Interval::MICROS_PER_DAY;
-
-	return result;
-}
-
-static void NormalizeIntervalEntries(interval_t input, int64_t &months, int64_t &days, int64_t &micros) {
-	int64_t extra_months_d = input.days / Interval::DAYS_PER_MONTH;
-	int64_t extra_months_micros = input.micros / Interval::MICROS_PER_MONTH;
-	input.days -= extra_months_d * Interval::DAYS_PER_MONTH;
-	input.micros -= extra_months_micros * Interval::MICROS_PER_MONTH;
-
-	int64_t extra_days_micros = input.micros / Interval::MICROS_PER_DAY;
-	input.micros -= extra_days_micros * Interval::MICROS_PER_DAY;
-
-	months = input.months + extra_months_d + extra_months_micros;
-	days = input.days + extra_days_micros;
-	micros = input.micros;
-}
-
-bool Interval::Equals(interval_t left, interval_t right) {
-	return left.months == right.months && left.days == right.days && left.micros == right.micros;
-}
-
-bool Interval::GreaterThan(interval_t left, interval_t right) {
-	int64_t lmonths, ldays, lmicros;
-	int64_t rmonths, rdays, rmicros;
-	NormalizeIntervalEntries(left, lmonths, ldays, lmicros);
-	NormalizeIntervalEntries(right, rmonths, rdays, rmicros);
-
-	if (lmonths > rmonths) {
-		return true;
-	} else if (lmonths < rmonths) {
-		return false;
-	}
-	if (ldays > rdays) {
-		return true;
-	} else if (ldays < rdays) {
-		return false;
-	}
-	return lmicros > rmicros;
-}
-
-bool Interval::GreaterThanEquals(interval_t left, interval_t right) {
-	return GreaterThan(left, right) || Equals(left, right);
-}
-
-date_t Interval::Add(date_t left, interval_t right) {
-	if (!Date::IsFinite(left)) {
-		return left;
-	}
-	date_t result;
-	if (right.months != 0) {
-		int32_t year, month, day;
-		Date::Convert(left, year, month, day);
-		int32_t year_diff = right.months / Interval::MONTHS_PER_YEAR;
-		year += year_diff;
-		month += right.months - year_diff * Interval::MONTHS_PER_YEAR;
-		if (month > Interval::MONTHS_PER_YEAR) {
-			year++;
-			month -= Interval::MONTHS_PER_YEAR;
-		} else if (month <= 0) {
-			year--;
-			month += Interval::MONTHS_PER_YEAR;
-		}
-		day = MinValue<int32_t>(day, Date::MonthDays(year, month));
-		result = Date::FromDate(year, month, day);
-	} else {
-		result = left;
-	}
-	if (right.days != 0) {
-		if (!TryAddOperator::Operation(result.days, right.days, result.days)) {
-			throw OutOfRangeException("Date out of range");
-		}
-	}
-	if (right.micros != 0) {
-		if (!TryAddOperator::Operation(result.days, int32_t(right.micros / Interval::MICROS_PER_DAY), result.days)) {
-			throw OutOfRangeException("Date out of range");
-		}
-	}
-	if (!Date::IsFinite(result)) {
-		throw OutOfRangeException("Date out of range");
-	}
-	return result;
-}
-
-dtime_t Interval::Add(dtime_t left, interval_t right, date_t &date) {
-	int64_t diff = right.micros - ((right.micros / Interval::MICROS_PER_DAY) * Interval::MICROS_PER_DAY);
-	left += diff;
-	if (left.micros >= Interval::MICROS_PER_DAY) {
-		left.micros -= Interval::MICROS_PER_DAY;
-		date.days++;
-	} else if (left.micros < 0) {
-		left.micros += Interval::MICROS_PER_DAY;
-		date.days--;
-	}
-	return left;
-}
-
-timestamp_t Interval::Add(timestamp_t left, interval_t right) {
-	if (!Timestamp::IsFinite(left)) {
-		return left;
-	}
-	date_t date;
-	dtime_t time;
-	Timestamp::Convert(left, date, time);
-	auto new_date = Interval::Add(date, right);
-	auto new_time = Interval::Add(time, right, new_date);
-	return Timestamp::FromDatetime(new_date, new_time);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-RowDataCollection::RowDataCollection(BufferManager &buffer_manager, idx_t block_capacity, idx_t entry_size,
-                                     bool keep_pinned)
-    : buffer_manager(buffer_manager), count(0), block_capacity(block_capacity), entry_size(entry_size),
-      keep_pinned(keep_pinned) {
-	D_ASSERT(block_capacity * entry_size >= Storage::BLOCK_SIZE);
-}
-
-idx_t RowDataCollection::AppendToBlock(RowDataBlock &block, BufferHandle &handle,
-                                       vector<BlockAppendEntry> &append_entries, idx_t remaining, idx_t entry_sizes[]) {
-	idx_t append_count = 0;
-	data_ptr_t dataptr;
-	if (entry_sizes) {
-		D_ASSERT(entry_size == 1);
-		// compute how many entries fit if entry size is variable
-		dataptr = handle.Ptr() + block.byte_offset;
-		for (idx_t i = 0; i < remaining; i++) {
-			if (block.byte_offset + entry_sizes[i] > block.capacity) {
-				if (block.count == 0 && append_count == 0 && entry_sizes[i] > block.capacity) {
-					// special case: single entry is bigger than block capacity
-					// resize current block to fit the entry, append it, and move to the next block
-					block.capacity = entry_sizes[i];
-					buffer_manager.ReAllocate(block.block, block.capacity);
-					dataptr = handle.Ptr();
-					append_count++;
-					block.byte_offset += entry_sizes[i];
-				}
-				break;
-			}
-			append_count++;
-			block.byte_offset += entry_sizes[i];
-		}
-	} else {
-		append_count = MinValue<idx_t>(remaining, block.capacity - block.count);
-		dataptr = handle.Ptr() + block.count * entry_size;
-	}
-	append_entries.emplace_back(dataptr, append_count);
-	block.count += append_count;
-	return append_count;
-}
-
-vector<BufferHandle> RowDataCollection::Build(idx_t added_count, data_ptr_t key_locations[], idx_t entry_sizes[],
-                                              const SelectionVector *sel) {
-	vector<BufferHandle> handles;
-	vector<BlockAppendEntry> append_entries;
-
-	// first allocate space of where to serialize the keys and payload columns
-	idx_t remaining = added_count;
-	{
-		// first append to the last block (if any)
-		lock_guard<mutex> append_lock(rdc_lock);
-		count += added_count;
-
-		if (!blocks.empty()) {
-			auto &last_block = blocks.back();
-			if (last_block.count < last_block.capacity) {
-				// last block has space: pin the buffer of this block
-				auto handle = buffer_manager.Pin(last_block.block);
-				// now append to the block
-				idx_t append_count = AppendToBlock(last_block, handle, append_entries, remaining, entry_sizes);
-				remaining -= append_count;
-				handles.push_back(move(handle));
-			}
-		}
-		while (remaining > 0) {
-			// now for the remaining data, allocate new buffers to store the data and append there
-			RowDataBlock new_block(buffer_manager, block_capacity, entry_size);
-			auto handle = buffer_manager.Pin(new_block.block);
-
-			// offset the entry sizes array if we have added entries already
-			idx_t *offset_entry_sizes = entry_sizes ? entry_sizes + added_count - remaining : nullptr;
-
-			idx_t append_count = AppendToBlock(new_block, handle, append_entries, remaining, offset_entry_sizes);
-			D_ASSERT(new_block.count > 0);
-			remaining -= append_count;
-
-			blocks.push_back(move(new_block));
-			if (keep_pinned) {
-				pinned_blocks.push_back(move(handle));
-			} else {
-				handles.push_back(move(handle));
-			}
-		}
-	}
-	// now set up the key_locations based on the append entries
-	idx_t append_idx = 0;
-	for (auto &append_entry : append_entries) {
-		idx_t next = append_idx + append_entry.count;
-		if (entry_sizes) {
-			for (; append_idx < next; append_idx++) {
-				key_locations[append_idx] = append_entry.baseptr;
-				append_entry.baseptr += entry_sizes[append_idx];
-			}
-		} else {
-			for (; append_idx < next; append_idx++) {
-				auto idx = sel->get_index(append_idx);
-				key_locations[idx] = append_entry.baseptr;
-				append_entry.baseptr += entry_size;
-			}
-		}
-	}
-	// return the unique pointers to the handles because they must stay pinned
-	return handles;
-}
-
-void RowDataCollection::Merge(RowDataCollection &other) {
-	RowDataCollection temp(buffer_manager, Storage::BLOCK_SIZE, 1);
-	{
-		//	One lock at a time to avoid deadlocks
-		lock_guard<mutex> read_lock(other.rdc_lock);
-		temp.count = other.count;
-		temp.block_capacity = other.block_capacity;
-		temp.entry_size = other.entry_size;
-		temp.blocks = move(other.blocks);
-		other.count = 0;
-	}
-
-	lock_guard<mutex> write_lock(rdc_lock);
-	count += temp.count;
-	block_capacity = MaxValue(block_capacity, temp.block_capacity);
-	entry_size = MaxValue(entry_size, temp.entry_size);
-	for (auto &block : temp.blocks) {
-		blocks.emplace_back(move(block));
-	}
-	for (auto &handle : temp.pinned_blocks) {
-		pinned_blocks.emplace_back(move(handle));
-	}
-}
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_layout.cpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-RowLayout::RowLayout()
-    : flag_width(0), data_width(0), aggr_width(0), row_width(0), all_constant(true), heap_pointer_offset(0) {
-}
-
-void RowLayout::Initialize(vector<LogicalType> types_p, Aggregates aggregates_p, bool align) {
-	offsets.clear();
-	types = move(types_p);
-
-	// Null mask at the front - 1 bit per value.
-	flag_width = ValidityBytes::ValidityMaskSize(types.size());
-	row_width = flag_width;
-
-	// Whether all columns are constant size.
-	for (const auto &type : types) {
-		all_constant = all_constant && TypeIsConstantSize(type.InternalType());
-	}
-
-	// This enables pointer swizzling for out-of-core computation.
-	if (!all_constant) {
-		// When unswizzled the pointer lives here.
-		// When swizzled, the pointer is replaced by an offset.
-		heap_pointer_offset = row_width;
-		// The 8 byte pointer will be replaced with an 8 byte idx_t when swizzled.
-		// However, this cannot be sizeof(data_ptr_t), since 32 bit builds use 4 byte pointers.
-		row_width += sizeof(idx_t);
-	}
-
-	// Data columns. No alignment required.
-	for (const auto &type : types) {
-		offsets.push_back(row_width);
-		const auto internal_type = type.InternalType();
-		if (TypeIsConstantSize(internal_type) || internal_type == PhysicalType::VARCHAR) {
-			row_width += GetTypeIdSize(type.InternalType());
-		} else {
-			// Variable size types use pointers to the actual data (can be swizzled).
-			// Again, we would use sizeof(data_ptr_t), but this is not guaranteed to be equal to sizeof(idx_t).
-			row_width += sizeof(idx_t);
-		}
-	}
-
-	// Alignment padding for aggregates
-#ifndef DUCKDB_ALLOW_UNDEFINED
-	if (align) {
-		row_width = AlignValue(row_width);
-	}
-#endif
-	data_width = row_width - flag_width;
-
-	// Aggregate fields.
-	aggregates = move(aggregates_p);
-	for (auto &aggregate : aggregates) {
-		offsets.push_back(row_width);
-		row_width += aggregate.payload_size;
-#ifndef DUCKDB_ALLOW_UNDEFINED
-		D_ASSERT(aggregate.payload_size == AlignValue(aggregate.payload_size));
-#endif
-	}
-	aggr_width = row_width - data_width - flag_width;
-
-	// Alignment padding for the next row
-#ifndef DUCKDB_ALLOW_UNDEFINED
-	if (align) {
-		row_width = AlignValue(row_width);
-	}
-#endif
-}
-
-void RowLayout::Initialize(vector<LogicalType> types_p, bool align) {
-	Initialize(move(types_p), Aggregates(), align);
-}
-
-void RowLayout::Initialize(Aggregates aggregates_p, bool align) {
-	Initialize(vector<LogicalType>(), move(aggregates_p), align);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-SelectionData::SelectionData(idx_t count) {
-	owned_data = unique_ptr<sel_t[]>(new sel_t[count]);
-#ifdef DEBUG
-	for (idx_t i = 0; i < count; i++) {
-		owned_data[i] = std::numeric_limits<sel_t>::max();
-	}
-#endif
-}
-
-// LCOV_EXCL_START
-string SelectionVector::ToString(idx_t count) const {
-	string result = "Selection Vector (" + to_string(count) + ") [";
-	for (idx_t i = 0; i < count; i++) {
-		if (i != 0) {
-			result += ", ";
-		}
-		result += to_string(get_index(i));
-	}
-	result += "]";
-	return result;
-}
-
-void SelectionVector::Print(idx_t count) const {
-	Printer::Print(ToString(count));
-}
-// LCOV_EXCL_STOP
-
-buffer_ptr<SelectionData> SelectionVector::Slice(const SelectionVector &sel, idx_t count) const {
-	auto data = make_buffer<SelectionData>(count);
-	auto result_ptr = data->owned_data.get();
-	// for every element, we perform result[i] = target[new[i]]
-	for (idx_t i = 0; i < count; i++) {
-		auto new_idx = sel.get_index(i);
-		auto idx = this->get_index(new_idx);
-		result_ptr[i] = idx;
-	}
-	return data;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-StringHeap::StringHeap() : allocator(Allocator::DefaultAllocator()) {
-}
-
-void StringHeap::Destroy() {
-	allocator.Destroy();
-}
-
-void StringHeap::Move(StringHeap &other) {
-	other.allocator.Move(allocator);
-}
-
-string_t StringHeap::AddString(const char *data, idx_t len) {
-	D_ASSERT(Utf8Proc::Analyze(data, len) != UnicodeType::INVALID);
-	return AddBlob(data, len);
-}
-
-string_t StringHeap::AddString(const char *data) {
-	return AddString(data, strlen(data));
-}
-
-string_t StringHeap::AddString(const string &data) {
-	return AddString(data.c_str(), data.size());
-}
-
-string_t StringHeap::AddString(const string_t &data) {
-	return AddString(data.GetDataUnsafe(), data.GetSize());
-}
-
-string_t StringHeap::AddBlob(const char *data, idx_t len) {
-	auto insert_string = EmptyString(len);
-	auto insert_pos = insert_string.GetDataWriteable();
-	memcpy(insert_pos, data, len);
-	insert_string.Finalize();
-	return insert_string;
-}
-
-string_t StringHeap::AddBlob(const string_t &data) {
-	return AddBlob(data.GetDataUnsafe(), data.GetSize());
-}
-
-string_t StringHeap::EmptyString(idx_t len) {
-	D_ASSERT(len >= string_t::INLINE_LENGTH);
-	auto insert_pos = (const char *)allocator.Allocate(len);
-	return string_t(insert_pos, len);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-void string_t::Verify() {
-	auto dataptr = GetDataUnsafe();
-	(void)dataptr;
-	D_ASSERT(dataptr);
-
-#ifdef DEBUG
-	auto utf_type = Utf8Proc::Analyze(dataptr, GetSize());
-	D_ASSERT(utf_type != UnicodeType::INVALID);
-#endif
-
-	// verify that the prefix contains the first four characters of the string
-	for (idx_t i = 0; i < MinValue<uint32_t>(PREFIX_LENGTH, GetSize()); i++) {
-		D_ASSERT(GetPrefix()[i] == dataptr[i]);
-	}
-	// verify that for strings with length < INLINE_LENGTH, the rest of the string is zero
-	for (idx_t i = GetSize(); i < INLINE_LENGTH; i++) {
-		D_ASSERT(GetDataUnsafe()[i] == '\0');
-	}
-}
-
-void string_t::VerifyNull() {
-	for (idx_t i = 0; i < GetSize(); i++) {
-		D_ASSERT(GetDataUnsafe()[i] != '\0');
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-#include <cstring>
-#include <sstream>
-#include <cctype>
-
-namespace duckdb {
-
-static_assert(sizeof(dtime_t) == sizeof(int64_t), "dtime_t was padded");
-
-// string format is hh:mm:ss.microsecondsZ
-// microseconds and Z are optional
-// ISO 8601
-
-bool Time::TryConvertInternal(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict) {
-	int32_t hour = -1, min = -1, sec = -1, micros = -1;
-	pos = 0;
-
-	if (len == 0) {
-		return false;
-	}
-
-	int sep;
-
-	// skip leading spaces
-	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-		pos++;
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-
-	if (!StringUtil::CharacterIsDigit(buf[pos])) {
-		return false;
-	}
-
-	if (!Date::ParseDoubleDigit(buf, len, pos, hour)) {
-		return false;
-	}
-	if (hour < 0 || hour >= 24) {
-		return false;
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-
-	// fetch the separator
-	sep = buf[pos++];
-	if (sep != ':') {
-		// invalid separator
-		return false;
-	}
-
-	if (!Date::ParseDoubleDigit(buf, len, pos, min)) {
-		return false;
-	}
-	if (min < 0 || min >= 60) {
-		return false;
-	}
-
-	if (pos >= len) {
-		return false;
-	}
-
-	if (buf[pos++] != sep) {
-		return false;
-	}
-
-	if (!Date::ParseDoubleDigit(buf, len, pos, sec)) {
-		return false;
-	}
-	if (sec < 0 || sec >= 60) {
-		return false;
-	}
-
-	micros = 0;
-	if (pos < len && buf[pos] == '.') {
-		pos++;
-		// we expect some microseconds
-		int32_t mult = 100000;
-		for (; pos < len && StringUtil::CharacterIsDigit(buf[pos]); pos++, mult /= 10) {
-			if (mult > 0) {
-				micros += (buf[pos] - '0') * mult;
-			}
-		}
-	}
-
-	// in strict mode, check remaining string for non-space characters
-	if (strict) {
-		// skip trailing spaces
-		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-			pos++;
-		}
-		// check position. if end was not reached, non-space chars remaining
-		if (pos < len) {
-			return false;
-		}
-	}
-
-	result = Time::FromTime(hour, min, sec, micros);
-	return true;
-}
-
-bool Time::TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict) {
-	if (!Time::TryConvertInternal(buf, len, pos, result, strict)) {
-		if (!strict) {
-			// last chance, check if we can parse as timestamp
-			timestamp_t timestamp;
-			if (Timestamp::TryConvertTimestamp(buf, len, timestamp)) {
-				result = Timestamp::GetTime(timestamp);
-				return true;
-			}
-		}
-		return false;
-	}
-	return true;
-}
-
-string Time::ConversionError(const string &str) {
-	return StringUtil::Format("time field value out of range: \"%s\", "
-	                          "expected format is ([YYYY-MM-DD ]HH:MM:SS[.MS])",
-	                          str);
-}
-
-string Time::ConversionError(string_t str) {
-	return Time::ConversionError(str.GetString());
-}
-
-dtime_t Time::FromCString(const char *buf, idx_t len, bool strict) {
-	dtime_t result;
-	idx_t pos;
-	if (!Time::TryConvertTime(buf, len, pos, result, strict)) {
-		throw ConversionException(ConversionError(string(buf, len)));
-	}
-	return result;
-}
-
-dtime_t Time::FromString(const string &str, bool strict) {
-	return Time::FromCString(str.c_str(), str.size(), strict);
-}
-
-string Time::ToString(dtime_t time) {
-	int32_t time_units[4];
-	Time::Convert(time, time_units[0], time_units[1], time_units[2], time_units[3]);
-
-	char micro_buffer[6];
-	auto length = TimeToStringCast::Length(time_units, micro_buffer);
-	auto buffer = unique_ptr<char[]>(new char[length]);
-	TimeToStringCast::Format(buffer.get(), length, time_units, micro_buffer);
-	return string(buffer.get(), length);
-}
-
-string Time::ToUTCOffset(int hour_offset, int minute_offset) {
-	dtime_t time((hour_offset * Interval::MINS_PER_HOUR + minute_offset) * Interval::MICROS_PER_MINUTE);
-
-	char buffer[1 + 2 + 1 + 2];
-	idx_t length = 0;
-	buffer[length++] = (time.micros < 0 ? '-' : '+');
-	time.micros = std::abs(time.micros);
-
-	int32_t time_units[4];
-	Time::Convert(time, time_units[0], time_units[1], time_units[2], time_units[3]);
-
-	TimeToStringCast::FormatTwoDigits(buffer + length, time_units[0]);
-	length += 2;
-	if (time_units[1]) {
-		buffer[length++] = ':';
-		TimeToStringCast::FormatTwoDigits(buffer + length, time_units[1]);
-		length += 2;
-	}
-
-	return string(buffer, length);
-}
-
-dtime_t Time::FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
-	int64_t result;
-	result = hour;                                             // hours
-	result = result * Interval::MINS_PER_HOUR + minute;        // hours -> minutes
-	result = result * Interval::SECS_PER_MINUTE + second;      // minutes -> seconds
-	result = result * Interval::MICROS_PER_SEC + microseconds; // seconds -> microseconds
-	return dtime_t(result);
-}
-
-// LCOV_EXCL_START
-#ifdef DEBUG
-static bool AssertValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
-	if (hour < 0 || hour >= 24) {
-		return false;
-	}
-	if (minute < 0 || minute >= 60) {
-		return false;
-	}
-	if (second < 0 || second > 60) {
-		return false;
-	}
-	if (microseconds < 0 || microseconds > 1000000) {
-		return false;
-	}
-	return true;
-}
-#endif
-// LCOV_EXCL_STOP
-
-void Time::Convert(dtime_t dtime, int32_t &hour, int32_t &min, int32_t &sec, int32_t &micros) {
-	int64_t time = dtime.micros;
-	hour = int32_t(time / Interval::MICROS_PER_HOUR);
-	time -= int64_t(hour) * Interval::MICROS_PER_HOUR;
-	min = int32_t(time / Interval::MICROS_PER_MINUTE);
-	time -= int64_t(min) * Interval::MICROS_PER_MINUTE;
-	sec = int32_t(time / Interval::MICROS_PER_SEC);
-	time -= int64_t(sec) * Interval::MICROS_PER_SEC;
-	micros = int32_t(time);
-#ifdef DEBUG
-	D_ASSERT(AssertValidTime(hour, min, sec, micros));
-#endif
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-#include <ctime>
-
-namespace duckdb {
-
-static_assert(sizeof(timestamp_t) == sizeof(int64_t), "timestamp_t was padded");
-
-// timestamp/datetime uses 64 bits, high 32 bits for date and low 32 bits for time
-// string format is YYYY-MM-DDThh:mm:ssZ
-// T may be a space
-// Z is optional
-// ISO 8601
-bool Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result) {
-	idx_t pos;
-	date_t date;
-	dtime_t time;
-	if (!Date::TryConvertDate(str, len, pos, date)) {
-		return false;
-	}
-	if (pos == len) {
-		// no time: only a date or special
-		if (date == date_t::infinity()) {
-			result = timestamp_t::infinity();
-			return true;
-		} else if (date == date_t::ninfinity()) {
-			result = timestamp_t::ninfinity();
-			return true;
-		}
-		return Timestamp::TryFromDatetime(date, dtime_t(0), result);
-	}
-	// try to parse a time field
-	if (str[pos] == ' ' || str[pos] == 'T') {
-		pos++;
-	}
-	idx_t time_pos = 0;
-	if (!Time::TryConvertTime(str + pos, len - pos, time_pos, time)) {
-		return false;
-	}
-	pos += time_pos;
-	if (!Timestamp::TryFromDatetime(date, time, result)) {
-		return false;
-	}
-	if (pos < len) {
-		// skip a "Z" at the end (as per the ISO8601 specs)
-		if (str[pos] == 'Z') {
-			pos++;
-		}
-		int hour_offset, minute_offset;
-		if (Timestamp::TryParseUTCOffset(str, pos, len, hour_offset, minute_offset)) {
-			result -= hour_offset * Interval::MICROS_PER_HOUR + minute_offset * Interval::MICROS_PER_MINUTE;
-		}
-
-		// skip any spaces at the end
-		while (pos < len && StringUtil::CharacterIsSpace(str[pos])) {
-			pos++;
-		}
-		if (pos < len) {
-			return false;
-		}
-	}
-	return true;
-}
-
-string Timestamp::ConversionError(const string &str) {
-	return StringUtil::Format("timestamp field value out of range: \"%s\", "
-	                          "expected format is (YYYY-MM-DD HH:MM:SS[.MS])",
-	                          str);
-}
-
-string Timestamp::ConversionError(string_t str) {
-	return Timestamp::ConversionError(str.GetString());
-}
-
-timestamp_t Timestamp::FromCString(const char *str, idx_t len) {
-	timestamp_t result;
-	if (!Timestamp::TryConvertTimestamp(str, len, result)) {
-		throw ConversionException(Timestamp::ConversionError(string(str, len)));
-	}
-	return result;
-}
-
-bool Timestamp::TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset, int &minute_offset) {
-	minute_offset = 0;
-	idx_t curpos = pos;
-	// parse the next 3 characters
-	if (curpos + 3 > len) {
-		// no characters left to parse
-		return false;
-	}
-	char sign_char = str[curpos];
-	if (sign_char != '+' && sign_char != '-') {
-		// expected either + or -
-		return false;
-	}
-	curpos++;
-	if (!StringUtil::CharacterIsDigit(str[curpos]) || !StringUtil::CharacterIsDigit(str[curpos + 1])) {
-		// expected +HH or -HH
-		return false;
-	}
-	hour_offset = (str[curpos] - '0') * 10 + (str[curpos + 1] - '0');
-	if (sign_char == '-') {
-		hour_offset = -hour_offset;
-	}
-	curpos += 2;
-
-	// optional minute specifier: expected either "MM" or ":MM"
-	if (curpos >= len) {
-		// done, nothing left
-		pos = curpos;
-		return true;
-	}
-	if (str[curpos] == ':') {
-		curpos++;
-	}
-	if (curpos + 2 > len || !StringUtil::CharacterIsDigit(str[curpos]) ||
-	    !StringUtil::CharacterIsDigit(str[curpos + 1])) {
-		// no MM specifier
-		pos = curpos;
-		return true;
-	}
-	// we have an MM specifier: parse it
-	minute_offset = (str[curpos] - '0') * 10 + (str[curpos + 1] - '0');
-	if (sign_char == '-') {
-		minute_offset = -minute_offset;
-	}
-	pos = curpos + 2;
-	return true;
-}
-
-timestamp_t Timestamp::FromString(const string &str) {
-	return Timestamp::FromCString(str.c_str(), str.size());
-}
-
-string Timestamp::ToString(timestamp_t timestamp) {
-	if (timestamp == timestamp_t::infinity()) {
-		return Date::PINF;
-	} else if (timestamp == timestamp_t::ninfinity()) {
-		return Date::NINF;
-	}
-	date_t date;
-	dtime_t time;
-	Timestamp::Convert(timestamp, date, time);
-	return Date::ToString(date) + " " + Time::ToString(time);
-}
-
-date_t Timestamp::GetDate(timestamp_t timestamp) {
-	if (timestamp == timestamp_t::infinity()) {
-		return date_t::infinity();
-	} else if (timestamp == timestamp_t::ninfinity()) {
-		return date_t::ninfinity();
-	}
-	return date_t((timestamp.value + (timestamp.value < 0)) / Interval::MICROS_PER_DAY - (timestamp.value < 0));
-}
-
-dtime_t Timestamp::GetTime(timestamp_t timestamp) {
-	if (!IsFinite(timestamp)) {
-		throw ConversionException("Can't get TIME of infinite TIMESTAMP");
-	}
-	date_t date = Timestamp::GetDate(timestamp);
-	return dtime_t(timestamp.value - (int64_t(date.days) * int64_t(Interval::MICROS_PER_DAY)));
-}
-
-bool Timestamp::TryFromDatetime(date_t date, dtime_t time, timestamp_t &result) {
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::MICROS_PER_DAY, result.value)) {
-		return false;
-	}
-	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(result.value, time.micros, result.value)) {
-		return false;
-	}
-	return Timestamp::IsFinite(result);
-}
-
-timestamp_t Timestamp::FromDatetime(date_t date, dtime_t time) {
-	timestamp_t result;
-	if (!TryFromDatetime(date, time, result)) {
-		throw Exception("Overflow exception in date/time -> timestamp conversion");
-	}
-	return result;
-}
-
-void Timestamp::Convert(timestamp_t timestamp, date_t &out_date, dtime_t &out_time) {
-	out_date = GetDate(timestamp);
-	int64_t days_micros;
-	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(out_date.days, Interval::MICROS_PER_DAY,
-	                                                               days_micros)) {
-		throw ConversionException("Date out of range in timestamp conversion");
-	}
-	out_time = dtime_t(timestamp.value - days_micros);
-	D_ASSERT(timestamp == Timestamp::FromDatetime(out_date, out_time));
-}
-
-timestamp_t Timestamp::GetCurrentTimestamp() {
-	auto now = system_clock::now();
-	auto epoch_ms = duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
-	return Timestamp::FromEpochMs(epoch_ms);
-}
-
-timestamp_t Timestamp::FromEpochSeconds(int64_t sec) {
-	int64_t result;
-	if (!TryMultiplyOperator::Operation(sec, Interval::MICROS_PER_SEC, result)) {
-		throw ConversionException("Could not convert Timestamp(S) to Timestamp(US)");
-	}
-	return timestamp_t(result);
-}
-
-timestamp_t Timestamp::FromEpochMs(int64_t ms) {
-	int64_t result;
-	if (!TryMultiplyOperator::Operation(ms, Interval::MICROS_PER_MSEC, result)) {
-		throw ConversionException("Could not convert Timestamp(MS) to Timestamp(US)");
-	}
-	return timestamp_t(result);
-}
-
-timestamp_t Timestamp::FromEpochMicroSeconds(int64_t micros) {
-	return timestamp_t(micros);
-}
-
-timestamp_t Timestamp::FromEpochNanoSeconds(int64_t ns) {
-	return timestamp_t(ns / 1000);
-}
-
-int64_t Timestamp::GetEpochSeconds(timestamp_t timestamp) {
-	return timestamp.value / Interval::MICROS_PER_SEC;
-}
-
-int64_t Timestamp::GetEpochMs(timestamp_t timestamp) {
-	return timestamp.value / Interval::MICROS_PER_MSEC;
-}
-
-int64_t Timestamp::GetEpochMicroSeconds(timestamp_t timestamp) {
-	return timestamp.value;
-}
-
-int64_t Timestamp::GetEpochNanoSeconds(timestamp_t timestamp) {
-	int64_t result;
-	int64_t ns_in_us = 1000;
-	if (!TryMultiplyOperator::Operation(timestamp.value, ns_in_us, result)) {
-		throw ConversionException("Could not convert Timestamp(US) to Timestamp(NS)");
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-bool UUID::FromString(string str, hugeint_t &result) {
-	auto hex2char = [](char ch) -> unsigned char {
-		if (ch >= '0' && ch <= '9') {
-			return ch - '0';
-		}
-		if (ch >= 'a' && ch <= 'f') {
-			return 10 + ch - 'a';
-		}
-		if (ch >= 'A' && ch <= 'F') {
-			return 10 + ch - 'A';
-		}
-		return 0;
-	};
-	auto is_hex = [](char ch) -> bool {
-		return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
-	};
-
-	if (str.empty()) {
-		return false;
-	}
-	int has_braces = 0;
-	if (str.front() == '{') {
-		has_braces = 1;
-	}
-	if (has_braces && str.back() != '}') {
-		return false;
-	}
-
-	result.lower = 0;
-	result.upper = 0;
-	size_t count = 0;
-	for (size_t i = has_braces; i < str.size() - has_braces; ++i) {
-		if (str[i] == '-') {
-			continue;
-		}
-		if (count >= 32 || !is_hex(str[i])) {
-			return false;
-		}
-		if (count >= 16) {
-			result.lower = (result.lower << 4) | hex2char(str[i]);
-		} else {
-			result.upper = (result.upper << 4) | hex2char(str[i]);
-		}
-		count++;
-	}
-	// Flip the first bit to make `order by uuid` same as `order by uuid::varchar`
-	result.upper ^= (int64_t(1) << 63);
-	return count == 32;
-}
-
-void UUID::ToString(hugeint_t input, char *buf) {
-	auto byte_to_hex = [](char byte_val, char *buf, idx_t &pos) {
-		static char const HEX_DIGITS[] = "0123456789abcdef";
-		buf[pos++] = HEX_DIGITS[(byte_val >> 4) & 0xf];
-		buf[pos++] = HEX_DIGITS[byte_val & 0xf];
-	};
-
-	// Flip back before convert to string
-	int64_t upper = input.upper ^ (int64_t(1) << 63);
-	idx_t pos = 0;
-	byte_to_hex(upper >> 56 & 0xFF, buf, pos);
-	byte_to_hex(upper >> 48 & 0xFF, buf, pos);
-	byte_to_hex(upper >> 40 & 0xFF, buf, pos);
-	byte_to_hex(upper >> 32 & 0xFF, buf, pos);
-	buf[pos++] = '-';
-	byte_to_hex(upper >> 24 & 0xFF, buf, pos);
-	byte_to_hex(upper >> 16 & 0xFF, buf, pos);
-	buf[pos++] = '-';
-	byte_to_hex(upper >> 8 & 0xFF, buf, pos);
-	byte_to_hex(upper & 0xFF, buf, pos);
-	buf[pos++] = '-';
-	byte_to_hex(input.lower >> 56 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 48 & 0xFF, buf, pos);
-	buf[pos++] = '-';
-	byte_to_hex(input.lower >> 40 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 32 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 24 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 16 & 0xFF, buf, pos);
-	byte_to_hex(input.lower >> 8 & 0xFF, buf, pos);
-	byte_to_hex(input.lower & 0xFF, buf, pos);
-}
-
-hugeint_t UUID::GenerateRandomUUID(RandomEngine &engine) {
-	uint8_t bytes[16];
-	for (int i = 0; i < 16; i += 4) {
-		*reinterpret_cast<uint32_t *>(bytes + i) = engine.NextRandomInteger();
-	}
-	// variant must be 10xxxxxx
-	bytes[8] &= 0xBF;
-	bytes[8] |= 0x80;
-	// version must be 0100xxxx
-	bytes[6] &= 0x4F;
-	bytes[6] |= 0x40;
-
-	hugeint_t result;
-	result.upper = 0;
-	result.upper |= ((int64_t)bytes[0] << 56);
-	result.upper |= ((int64_t)bytes[1] << 48);
-	result.upper |= ((int64_t)bytes[3] << 40);
-	result.upper |= ((int64_t)bytes[4] << 32);
-	result.upper |= ((int64_t)bytes[5] << 24);
-	result.upper |= ((int64_t)bytes[6] << 16);
-	result.upper |= ((int64_t)bytes[7] << 8);
-	result.upper |= bytes[8];
-	result.lower = 0;
-	result.lower |= ((uint64_t)bytes[8] << 56);
-	result.lower |= ((uint64_t)bytes[9] << 48);
-	result.lower |= ((uint64_t)bytes[10] << 40);
-	result.lower |= ((uint64_t)bytes[11] << 32);
-	result.lower |= ((uint64_t)bytes[12] << 24);
-	result.lower |= ((uint64_t)bytes[13] << 16);
-	result.lower |= ((uint64_t)bytes[14] << 8);
-	result.lower |= bytes[15];
-	return result;
-}
-
-hugeint_t UUID::GenerateRandomUUID() {
-	RandomEngine engine;
-	return GenerateRandomUUID(engine);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ValidityData::ValidityData(idx_t count) : TemplatedValidityData(count) {
-}
-ValidityData::ValidityData(const ValidityMask &original, idx_t count)
-    : TemplatedValidityData(original.GetData(), count) {
-}
-
-void ValidityMask::Combine(const ValidityMask &other, idx_t count) {
-	if (other.AllValid()) {
-		// X & 1 = X
-		return;
-	}
-	if (AllValid()) {
-		// 1 & Y = Y
-		Initialize(other);
-		return;
-	}
-	if (validity_mask == other.validity_mask) {
-		// X & X == X
-		return;
-	}
-	// have to merge
-	// create a new validity mask that contains the combined mask
-	auto owned_data = move(validity_data);
-	auto data = GetData();
-	auto other_data = other.GetData();
-
-	Initialize(count);
-	auto result_data = GetData();
-
-	auto entry_count = ValidityData::EntryCount(count);
-	for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-		result_data[entry_idx] = data[entry_idx] & other_data[entry_idx];
-	}
-}
-
-// LCOV_EXCL_START
-string ValidityMask::ToString(idx_t count) const {
-	string result = "Validity Mask (" + to_string(count) + ") [";
-	for (idx_t i = 0; i < count; i++) {
-		result += RowIsValid(i) ? "." : "X";
-	}
-	result += "]";
-	return result;
-}
-// LCOV_EXCL_STOP
-
-void ValidityMask::Resize(idx_t old_size, idx_t new_size) {
-	if (validity_mask) {
-		auto new_size_count = EntryCount(new_size);
-		auto old_size_count = EntryCount(old_size);
-		auto new_owned_data = unique_ptr<validity_t[]>(new validity_t[new_size_count]);
-		for (idx_t entry_idx = 0; entry_idx < old_size_count; entry_idx++) {
-			new_owned_data[entry_idx] = validity_mask[entry_idx];
-		}
-		for (idx_t entry_idx = old_size_count; entry_idx < new_size_count; entry_idx++) {
-			new_owned_data[entry_idx] = ValidityData::MAX_ENTRY;
-		}
-		validity_data->owned_data = move(new_owned_data);
-		validity_mask = validity_data->owned_data.get();
-	} else {
-		Initialize(new_size);
-	}
-}
-
-void ValidityMask::Slice(const ValidityMask &other, idx_t offset) {
-	if (other.AllValid()) {
-		validity_mask = nullptr;
-		validity_data.reset();
-		return;
-	}
-	if (offset == 0) {
-		Initialize(other);
-		return;
-	}
-	ValidityMask new_mask(STANDARD_VECTOR_SIZE);
-
-// FIXME THIS NEEDS FIXING!
-#if 1
-	for (idx_t i = offset; i < STANDARD_VECTOR_SIZE; i++) {
-		new_mask.Set(i - offset, other.RowIsValid(i));
-	}
-	Initialize(new_mask);
-#else
-	// first shift the "whole" units
-	idx_t entire_units = offset / BITS_PER_VALUE;
-	idx_t sub_units = offset - entire_units * BITS_PER_VALUE;
-	if (entire_units > 0) {
-		idx_t validity_idx;
-		for (validity_idx = 0; validity_idx + entire_units < STANDARD_ENTRY_COUNT; validity_idx++) {
-			new_mask.validity_mask[validity_idx] = other.validity_mask[validity_idx + entire_units];
-		}
-	}
-	// now we shift the remaining sub units
-	// this gets a bit more complicated because we have to shift over the borders of the entries
-	// e.g. suppose we have 2 entries of length 4 and we left-shift by two
-	// 0101|1010
-	// a regular left-shift of both gets us:
-	// 0100|1000
-	// we then OR the overflow (right-shifted by BITS_PER_VALUE - offset) together to get the correct result
-	// 0100|1000 ->
-	// 0110|1000
-	if (sub_units > 0) {
-		idx_t validity_idx;
-		for (validity_idx = 0; validity_idx + 1 < STANDARD_ENTRY_COUNT; validity_idx++) {
-			new_mask.validity_mask[validity_idx] =
-			    (other.validity_mask[validity_idx] >> sub_units) |
-			    (other.validity_mask[validity_idx + 1] << (BITS_PER_VALUE - sub_units));
-		}
-		new_mask.validity_mask[validity_idx] >>= sub_units;
-	}
-#ifdef DEBUG
-	for (idx_t i = offset; i < STANDARD_VECTOR_SIZE; i++) {
-		D_ASSERT(new_mask.RowIsValid(i - offset) == other.RowIsValid(i));
-	}
-	Initialize(new_mask);
-#endif
-#endif
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <utility>
-#include <cmath>
-
-namespace duckdb {
-
-Value::Value(LogicalType type) : type_(move(type)), is_null(true) {
-}
-
-Value::Value(int32_t val) : type_(LogicalType::INTEGER), is_null(false) {
-	value_.integer = val;
-}
-
-Value::Value(int64_t val) : type_(LogicalType::BIGINT), is_null(false) {
-	value_.bigint = val;
-}
-
-Value::Value(float val) : type_(LogicalType::FLOAT), is_null(false) {
-	value_.float_ = val;
-}
-
-Value::Value(double val) : type_(LogicalType::DOUBLE), is_null(false) {
-	value_.double_ = val;
-}
-
-Value::Value(const char *val) : Value(val ? string(val) : string()) {
-}
-
-Value::Value(std::nullptr_t val) : Value(LogicalType::VARCHAR) {
-}
-
-Value::Value(string_t val) : Value(string(val.GetDataUnsafe(), val.GetSize())) {
-}
-
-Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false), str_value(move(val)) {
-	if (!Value::StringIsValid(str_value.c_str(), str_value.size())) {
-		throw Exception("String value is not valid UTF8");
-	}
-}
-
-Value::~Value() {
-}
-
-Value::Value(const Value &other)
-    : type_(other.type_), is_null(other.is_null), value_(other.value_), str_value(other.str_value),
-      struct_value(other.struct_value), list_value(other.list_value) {
-}
-
-Value::Value(Value &&other) noexcept
-    : type_(move(other.type_)), is_null(other.is_null), value_(other.value_), str_value(move(other.str_value)),
-      struct_value(move(other.struct_value)), list_value(move(other.list_value)) {
-}
-
-Value &Value::operator=(const Value &other) {
-	type_ = other.type_;
-	is_null = other.is_null;
-	value_ = other.value_;
-	str_value = other.str_value;
-	struct_value = other.struct_value;
-	list_value = other.list_value;
-	return *this;
-}
-
-Value &Value::operator=(Value &&other) noexcept {
-	type_ = move(other.type_);
-	is_null = other.is_null;
-	value_ = other.value_;
-	str_value = move(other.str_value);
-	struct_value = move(other.struct_value);
-	list_value = move(other.list_value);
-	return *this;
-}
-
-Value Value::MinimumValue(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return Value::BOOLEAN(false);
-	case LogicalTypeId::TINYINT:
-		return Value::TINYINT(NumericLimits<int8_t>::Minimum());
-	case LogicalTypeId::SMALLINT:
-		return Value::SMALLINT(NumericLimits<int16_t>::Minimum());
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::SQLNULL:
-		return Value::INTEGER(NumericLimits<int32_t>::Minimum());
-	case LogicalTypeId::BIGINT:
-		return Value::BIGINT(NumericLimits<int64_t>::Minimum());
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(NumericLimits<hugeint_t>::Minimum());
-	case LogicalTypeId::UUID:
-		return Value::UUID(NumericLimits<hugeint_t>::Minimum());
-	case LogicalTypeId::UTINYINT:
-		return Value::UTINYINT(NumericLimits<uint8_t>::Minimum());
-	case LogicalTypeId::USMALLINT:
-		return Value::USMALLINT(NumericLimits<uint16_t>::Minimum());
-	case LogicalTypeId::UINTEGER:
-		return Value::UINTEGER(NumericLimits<uint32_t>::Minimum());
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(NumericLimits<uint64_t>::Minimum());
-	case LogicalTypeId::DATE:
-		return Value::DATE(Date::FromDate(Date::DATE_MIN_YEAR, Date::DATE_MIN_MONTH, Date::DATE_MIN_DAY));
-	case LogicalTypeId::TIME:
-		return Value::TIME(dtime_t(0));
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY),
-		                        dtime_t(0));
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return MinimumValue(LogicalType::TIMESTAMP).CastAs(LogicalType::TIMESTAMP_S);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return MinimumValue(LogicalType::TIMESTAMP).CastAs(LogicalType::TIMESTAMP_MS);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Minimum()));
-	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(dtime_t(0));
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(Timestamp::FromDatetime(
-		    Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY), dtime_t(0)));
-	case LogicalTypeId::FLOAT:
-		return Value::FLOAT(NumericLimits<float>::Minimum());
-	case LogicalTypeId::DOUBLE:
-		return Value::DOUBLE(NumericLimits<double>::Minimum());
-	case LogicalTypeId::DECIMAL: {
-		auto width = DecimalType::GetWidth(type);
-		auto scale = DecimalType::GetScale(type);
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return Value::DECIMAL(int16_t(-NumericHelper::POWERS_OF_TEN[width] + 1), width, scale);
-		case PhysicalType::INT32:
-			return Value::DECIMAL(int32_t(-NumericHelper::POWERS_OF_TEN[width] + 1), width, scale);
-		case PhysicalType::INT64:
-			return Value::DECIMAL(int64_t(-NumericHelper::POWERS_OF_TEN[width] + 1), width, scale);
-		case PhysicalType::INT128:
-			return Value::DECIMAL(-Hugeint::POWERS_OF_TEN[width] + 1, width, scale);
-		default:
-			throw InternalException("Unknown decimal type");
-		}
-	}
-	case LogicalTypeId::ENUM:
-		return Value::ENUM(0, type);
-	default:
-		throw InvalidTypeException(type, "MinimumValue requires numeric type");
-	}
-}
-
-Value Value::MaximumValue(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return Value::BOOLEAN(true);
-	case LogicalTypeId::TINYINT:
-		return Value::TINYINT(NumericLimits<int8_t>::Maximum());
-	case LogicalTypeId::SMALLINT:
-		return Value::SMALLINT(NumericLimits<int16_t>::Maximum());
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::SQLNULL:
-		return Value::INTEGER(NumericLimits<int32_t>::Maximum());
-	case LogicalTypeId::BIGINT:
-		return Value::BIGINT(NumericLimits<int64_t>::Maximum());
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(NumericLimits<hugeint_t>::Maximum());
-	case LogicalTypeId::UUID:
-		return Value::UUID(NumericLimits<hugeint_t>::Maximum());
-	case LogicalTypeId::UTINYINT:
-		return Value::UTINYINT(NumericLimits<uint8_t>::Maximum());
-	case LogicalTypeId::USMALLINT:
-		return Value::USMALLINT(NumericLimits<uint16_t>::Maximum());
-	case LogicalTypeId::UINTEGER:
-		return Value::UINTEGER(NumericLimits<uint32_t>::Maximum());
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(NumericLimits<uint64_t>::Maximum());
-	case LogicalTypeId::DATE:
-		return Value::DATE(Date::FromDate(Date::DATE_MAX_YEAR, Date::DATE_MAX_MONTH, Date::DATE_MAX_DAY));
-	case LogicalTypeId::TIME:
-		return Value::TIME(dtime_t(Interval::SECS_PER_DAY * Interval::MICROS_PER_SEC - 1));
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
-	case LogicalTypeId::TIMESTAMP_MS:
-		return MaximumValue(LogicalType::TIMESTAMP).CastAs(LogicalType::TIMESTAMP_MS);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return MaximumValue(LogicalType::TIMESTAMP).CastAs(LogicalType::TIMESTAMP_S);
-	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(dtime_t(Interval::SECS_PER_DAY * Interval::MICROS_PER_SEC - 1));
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return MaximumValue(LogicalType::TIMESTAMP);
-	case LogicalTypeId::FLOAT:
-		return Value::FLOAT(NumericLimits<float>::Maximum());
-	case LogicalTypeId::DOUBLE:
-		return Value::DOUBLE(NumericLimits<double>::Maximum());
-	case LogicalTypeId::DECIMAL: {
-		auto width = DecimalType::GetWidth(type);
-		auto scale = DecimalType::GetScale(type);
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return Value::DECIMAL(int16_t(NumericHelper::POWERS_OF_TEN[width] - 1), width, scale);
-		case PhysicalType::INT32:
-			return Value::DECIMAL(int32_t(NumericHelper::POWERS_OF_TEN[width] - 1), width, scale);
-		case PhysicalType::INT64:
-			return Value::DECIMAL(int64_t(NumericHelper::POWERS_OF_TEN[width] - 1), width, scale);
-		case PhysicalType::INT128:
-			return Value::DECIMAL(Hugeint::POWERS_OF_TEN[width] - 1, width, scale);
-		default:
-			throw InternalException("Unknown decimal type");
-		}
-	}
-	case LogicalTypeId::ENUM:
-		return Value::ENUM(EnumType::GetSize(type) - 1, type);
-	default:
-		throw InvalidTypeException(type, "MaximumValue requires numeric type");
-	}
-}
-
-Value Value::BOOLEAN(int8_t value) {
-	Value result(LogicalType::BOOLEAN);
-	result.value_.boolean = value ? true : false;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TINYINT(int8_t value) {
-	Value result(LogicalType::TINYINT);
-	result.value_.tinyint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::SMALLINT(int16_t value) {
-	Value result(LogicalType::SMALLINT);
-	result.value_.smallint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::INTEGER(int32_t value) {
-	Value result(LogicalType::INTEGER);
-	result.value_.integer = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::BIGINT(int64_t value) {
-	Value result(LogicalType::BIGINT);
-	result.value_.bigint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::HUGEINT(hugeint_t value) {
-	Value result(LogicalType::HUGEINT);
-	result.value_.hugeint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UUID(hugeint_t value) {
-	Value result(LogicalType::UUID);
-	result.value_.hugeint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UUID(const string &value) {
-	Value result(LogicalType::UUID);
-	result.value_.hugeint = UUID::FromString(value);
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UTINYINT(uint8_t value) {
-	Value result(LogicalType::UTINYINT);
-	result.value_.utinyint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::USMALLINT(uint16_t value) {
-	Value result(LogicalType::USMALLINT);
-	result.value_.usmallint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UINTEGER(uint32_t value) {
-	Value result(LogicalType::UINTEGER);
-	result.value_.uinteger = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::UBIGINT(uint64_t value) {
-	Value result(LogicalType::UBIGINT);
-	result.value_.ubigint = value;
-	result.is_null = false;
-	return result;
-}
-
-bool Value::FloatIsFinite(float value) {
-	return !(std::isnan(value) || std::isinf(value));
-}
-
-bool Value::DoubleIsFinite(double value) {
-	return !(std::isnan(value) || std::isinf(value));
-}
-
-template <>
-bool Value::IsNan(float input) {
-	return std::isnan(input);
-}
-
-template <>
-bool Value::IsNan(double input) {
-	return std::isnan(input);
-}
-
-template <>
-bool Value::IsFinite(float input) {
-	return Value::FloatIsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(double input) {
-	return Value::DoubleIsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(date_t input) {
-	return Date::IsFinite(input);
-}
-
-template <>
-bool Value::IsFinite(timestamp_t input) {
-	return Timestamp::IsFinite(input);
-}
-
-bool Value::StringIsValid(const char *str, idx_t length) {
-	auto utf_type = Utf8Proc::Analyze(str, length);
-	return utf_type != UnicodeType::INVALID;
-}
-
-Value Value::DECIMAL(int16_t value, uint8_t width, uint8_t scale) {
-	D_ASSERT(width <= Decimal::MAX_WIDTH_INT16);
-	Value result(LogicalType::DECIMAL(width, scale));
-	result.value_.smallint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DECIMAL(int32_t value, uint8_t width, uint8_t scale) {
-	D_ASSERT(width >= Decimal::MAX_WIDTH_INT16 && width <= Decimal::MAX_WIDTH_INT32);
-	Value result(LogicalType::DECIMAL(width, scale));
-	result.value_.integer = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DECIMAL(int64_t value, uint8_t width, uint8_t scale) {
-	auto decimal_type = LogicalType::DECIMAL(width, scale);
-	Value result(decimal_type);
-	switch (decimal_type.InternalType()) {
-	case PhysicalType::INT16:
-		result.value_.smallint = value;
-		break;
-	case PhysicalType::INT32:
-		result.value_.integer = value;
-		break;
-	case PhysicalType::INT64:
-		result.value_.bigint = value;
-		break;
-	default:
-		result.value_.hugeint = value;
-		break;
-	}
-	result.type_.Verify();
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DECIMAL(hugeint_t value, uint8_t width, uint8_t scale) {
-	D_ASSERT(width >= Decimal::MAX_WIDTH_INT64 && width <= Decimal::MAX_WIDTH_INT128);
-	Value result(LogicalType::DECIMAL(width, scale));
-	result.value_.hugeint = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::FLOAT(float value) {
-	Value result(LogicalType::FLOAT);
-	result.value_.float_ = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DOUBLE(double value) {
-	Value result(LogicalType::DOUBLE);
-	result.value_.double_ = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::HASH(hash_t value) {
-	Value result(LogicalType::HASH);
-	result.value_.hash = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::POINTER(uintptr_t value) {
-	Value result(LogicalType::POINTER);
-	result.value_.pointer = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DATE(date_t value) {
-	Value result(LogicalType::DATE);
-	result.value_.date = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::DATE(int32_t year, int32_t month, int32_t day) {
-	return Value::DATE(Date::FromDate(year, month, day));
-}
-
-Value Value::TIME(dtime_t value) {
-	Value result(LogicalType::TIME);
-	result.value_.time = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMETZ(dtime_t value) {
-	Value result(LogicalType::TIME_TZ);
-	result.value_.time = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros) {
-	return Value::TIME(Time::FromTime(hour, min, sec, micros));
-}
-
-Value Value::TIMESTAMP(timestamp_t value) {
-	Value result(LogicalType::TIMESTAMP);
-	result.value_.timestamp = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMPTZ(timestamp_t value) {
-	Value result(LogicalType::TIMESTAMP_TZ);
-	result.value_.timestamp = value;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMPNS(timestamp_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_NS);
-	result.value_.timestamp = timestamp;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMPMS(timestamp_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_MS);
-	result.value_.timestamp = timestamp;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMPSEC(timestamp_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_S);
-	result.value_.timestamp = timestamp;
-	result.is_null = false;
-	return result;
-}
-
-Value Value::TIMESTAMP(date_t date, dtime_t time) {
-	return Value::TIMESTAMP(Timestamp::FromDatetime(date, time));
-}
-
-Value Value::TIMESTAMP(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec,
-                       int32_t micros) {
-	auto val = Value::TIMESTAMP(Date::FromDate(year, month, day), Time::FromTime(hour, min, sec, micros));
-	val.type_ = LogicalType::TIMESTAMP;
-	return val;
-}
-
-Value Value::STRUCT(child_list_t<Value> values) {
-	Value result;
-	child_list_t<LogicalType> child_types;
-	for (auto &child : values) {
-		child_types.push_back(make_pair(move(child.first), child.second.type()));
-		result.struct_value.push_back(move(child.second));
-	}
-	result.type_ = LogicalType::STRUCT(move(child_types));
-
-	result.is_null = false;
-	return result;
-}
-
-Value Value::MAP(Value key, Value value) {
-	Value result;
-	child_list_t<LogicalType> child_types;
-	child_types.push_back({"key", key.type()});
-	child_types.push_back({"value", value.type()});
-
-	result.type_ = LogicalType::MAP(move(child_types));
-
-	result.struct_value.push_back(move(key));
-	result.struct_value.push_back(move(value));
-	result.is_null = false;
-	return result;
-}
-
-Value Value::LIST(vector<Value> values) {
-	if (values.empty()) {
-		throw InternalException("Value::LIST requires a non-empty list of values. Use Value::EMPTYLIST instead.");
-	}
-#ifdef DEBUG
-	for (idx_t i = 1; i < values.size(); i++) {
-		D_ASSERT(values[i].type() == values[0].type());
-	}
-#endif
-	Value result;
-	result.type_ = LogicalType::LIST(values[0].type());
-	result.list_value = move(values);
-	result.is_null = false;
-	return result;
-}
-
-Value Value::LIST(LogicalType child_type, vector<Value> values) {
-	if (values.empty()) {
-		return Value::EMPTYLIST(move(child_type));
-	}
-	for (auto &val : values) {
-		val = val.CastAs(child_type);
-	}
-	return Value::LIST(move(values));
-}
-
-Value Value::EMPTYLIST(LogicalType child_type) {
-	Value result;
-	result.type_ = LogicalType::LIST(move(child_type));
-	result.is_null = false;
-	return result;
-}
-
-Value Value::BLOB(const_data_ptr_t data, idx_t len) {
-	Value result(LogicalType::BLOB);
-	result.is_null = false;
-	result.str_value = string((const char *)data, len);
-	return result;
-}
-
-Value Value::BLOB(const string &data) {
-	Value result(LogicalType::BLOB);
-	result.is_null = false;
-	result.str_value = Blob::ToBlob(string_t(data));
-	return result;
-}
-
-Value Value::JSON(const char *val) {
-	auto result = Value(val);
-	result.type_ = LogicalTypeId::JSON;
-	return result;
-}
-
-Value Value::JSON(string_t val) {
-	auto result = Value(val);
-	result.type_ = LogicalTypeId::JSON;
-	return result;
-}
-
-Value Value::JSON(string val) {
-	auto result = Value(move(val));
-	result.type_ = LogicalTypeId::JSON;
-	return result;
-}
-
-Value Value::ENUM(uint64_t value, const LogicalType &original_type) {
-	D_ASSERT(original_type.id() == LogicalTypeId::ENUM);
-	Value result(original_type);
-	switch (original_type.InternalType()) {
-	case PhysicalType::UINT8:
-		result.value_.utinyint = value;
-		break;
-	case PhysicalType::UINT16:
-		result.value_.usmallint = value;
-		break;
-	case PhysicalType::UINT32:
-		result.value_.uinteger = value;
-		break;
-	case PhysicalType::UINT64: //  DEDUP_POINTER_ENUM
-		result.value_.ubigint = value;
-		break;
-	default:
-		throw InternalException("Incorrect Physical Type for ENUM");
-	}
-	result.is_null = false;
-	return result;
-}
-
-Value Value::INTERVAL(int32_t months, int32_t days, int64_t micros) {
-	Value result(LogicalType::INTERVAL);
-	result.is_null = false;
-	result.value_.interval.months = months;
-	result.value_.interval.days = days;
-	result.value_.interval.micros = micros;
-	return result;
-}
-
-Value Value::INTERVAL(interval_t interval) {
-	return Value::INTERVAL(interval.months, interval.days, interval.micros);
-}
-
-//===--------------------------------------------------------------------===//
-// CreateValue
-//===--------------------------------------------------------------------===//
-template <>
-Value Value::CreateValue(bool value) {
-	return Value::BOOLEAN(value);
-}
-
-template <>
-Value Value::CreateValue(int8_t value) {
-	return Value::TINYINT(value);
-}
-
-template <>
-Value Value::CreateValue(int16_t value) {
-	return Value::SMALLINT(value);
-}
-
-template <>
-Value Value::CreateValue(int32_t value) {
-	return Value::INTEGER(value);
-}
-
-template <>
-Value Value::CreateValue(int64_t value) {
-	return Value::BIGINT(value);
-}
-
-template <>
-Value Value::CreateValue(uint8_t value) {
-	return Value::UTINYINT(value);
-}
-
-template <>
-Value Value::CreateValue(uint16_t value) {
-	return Value::USMALLINT(value);
-}
-
-template <>
-Value Value::CreateValue(uint32_t value) {
-	return Value::UINTEGER(value);
-}
-
-template <>
-Value Value::CreateValue(uint64_t value) {
-	return Value::UBIGINT(value);
-}
-
-template <>
-Value Value::CreateValue(hugeint_t value) {
-	return Value::HUGEINT(value);
-}
-
-template <>
-Value Value::CreateValue(date_t value) {
-	return Value::DATE(value);
-}
-
-template <>
-Value Value::CreateValue(dtime_t value) {
-	return Value::TIME(value);
-}
-
-template <>
-Value Value::CreateValue(timestamp_t value) {
-	return Value::TIMESTAMP(value);
-}
-
-template <>
-Value Value::CreateValue(const char *value) {
-	return Value(string(value));
-}
-
-template <>
-Value Value::CreateValue(string value) { // NOLINT: required for templating
-	return Value::BLOB(value);
-}
-
-template <>
-Value Value::CreateValue(string_t value) {
-	return Value(value);
-}
-
-template <>
-Value Value::CreateValue(float value) {
-	return Value::FLOAT(value);
-}
-
-template <>
-Value Value::CreateValue(double value) {
-	return Value::DOUBLE(value);
-}
-
-template <>
-Value Value::CreateValue(interval_t value) {
-	return Value::INTERVAL(value);
-}
-
-template <>
-Value Value::CreateValue(Value value) {
-	return value;
-}
-
-//===--------------------------------------------------------------------===//
-// GetValue
-//===--------------------------------------------------------------------===//
-template <class T>
-T Value::GetValueInternal() const {
-	if (IsNull()) {
-		return NullValue<T>();
-	}
-	switch (type_.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return Cast::Operation<bool, T>(value_.boolean);
-	case LogicalTypeId::TINYINT:
-		return Cast::Operation<int8_t, T>(value_.tinyint);
-	case LogicalTypeId::SMALLINT:
-		return Cast::Operation<int16_t, T>(value_.smallint);
-	case LogicalTypeId::INTEGER:
-		return Cast::Operation<int32_t, T>(value_.integer);
-	case LogicalTypeId::BIGINT:
-		return Cast::Operation<int64_t, T>(value_.bigint);
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UUID:
-		return Cast::Operation<hugeint_t, T>(value_.hugeint);
-	case LogicalTypeId::DATE:
-		return Cast::Operation<date_t, T>(value_.date);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return Cast::Operation<dtime_t, T>(value_.time);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Cast::Operation<timestamp_t, T>(value_.timestamp);
-	case LogicalTypeId::UTINYINT:
-		return Cast::Operation<uint8_t, T>(value_.utinyint);
-	case LogicalTypeId::USMALLINT:
-		return Cast::Operation<uint16_t, T>(value_.usmallint);
-	case LogicalTypeId::UINTEGER:
-		return Cast::Operation<uint32_t, T>(value_.uinteger);
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::UBIGINT:
-		return Cast::Operation<uint64_t, T>(value_.ubigint);
-	case LogicalTypeId::FLOAT:
-		return Cast::Operation<float, T>(value_.float_);
-	case LogicalTypeId::DOUBLE:
-		return Cast::Operation<double, T>(value_.double_);
-	case LogicalTypeId::VARCHAR:
-		return Cast::Operation<string_t, T>(str_value.c_str());
-	case LogicalTypeId::INTERVAL:
-		return Cast::Operation<interval_t, T>(value_.interval);
-	case LogicalTypeId::DECIMAL:
-		return CastAs(LogicalType::DOUBLE).GetValueInternal<T>();
-	case LogicalTypeId::ENUM: {
-		switch (type_.InternalType()) {
-		case PhysicalType::UINT8:
-			return Cast::Operation<uint8_t, T>(value_.utinyint);
-		case PhysicalType::UINT16:
-			return Cast::Operation<uint16_t, T>(value_.usmallint);
-		case PhysicalType::UINT32:
-			return Cast::Operation<uint32_t, T>(value_.uinteger);
-		default:
-			throw InternalException("Invalid Internal Type for ENUMs");
-		}
-	}
-
-	default:
-		throw NotImplementedException("Unimplemented type \"%s\" for GetValue()", type_.ToString());
-	}
-}
-
-template <>
-bool Value::GetValue() const {
-	return GetValueInternal<int8_t>();
-}
-template <>
-int8_t Value::GetValue() const {
-	return GetValueInternal<int8_t>();
-}
-template <>
-int16_t Value::GetValue() const {
-	return GetValueInternal<int16_t>();
-}
-template <>
-int32_t Value::GetValue() const {
-	if (type_.id() == LogicalTypeId::DATE) {
-		return value_.integer;
-	}
-	return GetValueInternal<int32_t>();
-}
-template <>
-int64_t Value::GetValue() const {
-	switch (type_.id()) {
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return value_.bigint;
-	default:
-		return GetValueInternal<int64_t>();
-	}
-}
-template <>
-hugeint_t Value::GetValue() const {
-	return GetValueInternal<hugeint_t>();
-}
-template <>
-uint8_t Value::GetValue() const {
-	return GetValueInternal<uint8_t>();
-}
-template <>
-uint16_t Value::GetValue() const {
-	return GetValueInternal<uint16_t>();
-}
-template <>
-uint32_t Value::GetValue() const {
-	return GetValueInternal<uint32_t>();
-}
-template <>
-uint64_t Value::GetValue() const {
-	return GetValueInternal<uint64_t>();
-}
-template <>
-string Value::GetValue() const {
-	return ToString();
-}
-template <>
-float Value::GetValue() const {
-	return GetValueInternal<float>();
-}
-template <>
-double Value::GetValue() const {
-	return GetValueInternal<double>();
-}
-template <>
-date_t Value::GetValue() const {
-	return GetValueInternal<date_t>();
-}
-template <>
-dtime_t Value::GetValue() const {
-	return GetValueInternal<dtime_t>();
-}
-template <>
-timestamp_t Value::GetValue() const {
-	return GetValueInternal<timestamp_t>();
-}
-
-template <>
-DUCKDB_API interval_t Value::GetValue() const {
-	return GetValueInternal<interval_t>();
-}
-
-template <>
-DUCKDB_API Value Value::GetValue() const {
-	return Value(*this);
-}
-
-uintptr_t Value::GetPointer() const {
-	D_ASSERT(type() == LogicalType::POINTER);
-	return value_.pointer;
-}
-
-Value Value::Numeric(const LogicalType &type, int64_t value) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		D_ASSERT(value == 0 || value == 1);
-		return Value::BOOLEAN(value ? 1 : 0);
-	case LogicalTypeId::TINYINT:
-		D_ASSERT(value >= NumericLimits<int8_t>::Minimum() && value <= NumericLimits<int8_t>::Maximum());
-		return Value::TINYINT((int8_t)value);
-	case LogicalTypeId::SMALLINT:
-		D_ASSERT(value >= NumericLimits<int16_t>::Minimum() && value <= NumericLimits<int16_t>::Maximum());
-		return Value::SMALLINT((int16_t)value);
-	case LogicalTypeId::INTEGER:
-		D_ASSERT(value >= NumericLimits<int32_t>::Minimum() && value <= NumericLimits<int32_t>::Maximum());
-		return Value::INTEGER((int32_t)value);
-	case LogicalTypeId::BIGINT:
-		return Value::BIGINT(value);
-	case LogicalTypeId::UTINYINT:
-		D_ASSERT(value >= NumericLimits<uint8_t>::Minimum() && value <= NumericLimits<uint8_t>::Maximum());
-		return Value::UTINYINT((uint8_t)value);
-	case LogicalTypeId::USMALLINT:
-		D_ASSERT(value >= NumericLimits<uint16_t>::Minimum() && value <= NumericLimits<uint16_t>::Maximum());
-		return Value::USMALLINT((uint16_t)value);
-	case LogicalTypeId::UINTEGER:
-		D_ASSERT(value >= NumericLimits<uint32_t>::Minimum() && value <= NumericLimits<uint32_t>::Maximum());
-		return Value::UINTEGER((uint32_t)value);
-	case LogicalTypeId::UBIGINT:
-		D_ASSERT(value >= 0);
-		return Value::UBIGINT(value);
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(value);
-	case LogicalTypeId::DECIMAL:
-		return Value::DECIMAL(value, DecimalType::GetWidth(type), DecimalType::GetScale(type));
-	case LogicalTypeId::FLOAT:
-		return Value((float)value);
-	case LogicalTypeId::DOUBLE:
-		return Value((double)value);
-	case LogicalTypeId::POINTER:
-		return Value::POINTER(value);
-	case LogicalTypeId::DATE:
-		D_ASSERT(value >= NumericLimits<int32_t>::Minimum() && value <= NumericLimits<int32_t>::Maximum());
-		return Value::DATE(date_t(value));
-	case LogicalTypeId::TIME:
-		return Value::TIME(dtime_t(value));
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(timestamp_t(value));
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_t(value));
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(timestamp_t(value));
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(timestamp_t(value));
-	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(dtime_t(value));
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_t(value));
-	case LogicalTypeId::ENUM:
-		switch (type.InternalType()) {
-		case PhysicalType::UINT8:
-			D_ASSERT(value >= NumericLimits<uint8_t>::Minimum() && value <= NumericLimits<uint8_t>::Maximum());
-			return Value::UTINYINT((uint8_t)value);
-		case PhysicalType::UINT16:
-			D_ASSERT(value >= NumericLimits<uint16_t>::Minimum() && value <= NumericLimits<uint16_t>::Maximum());
-			return Value::USMALLINT((uint16_t)value);
-		case PhysicalType::UINT32:
-			D_ASSERT(value >= NumericLimits<uint32_t>::Minimum() && value <= NumericLimits<uint32_t>::Maximum());
-			return Value::UINTEGER((uint32_t)value);
-		default:
-			throw InternalException("Enum doesn't accept this physical type");
-		}
-	default:
-		throw InvalidTypeException(type, "Numeric requires numeric type");
-	}
-}
-
-Value Value::Numeric(const LogicalType &type, hugeint_t value) {
-#ifdef DEBUG
-	// perform a throwing cast to verify that the type fits
-	Value::HUGEINT(value).CastAs(type);
-#endif
-	switch (type.id()) {
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(value);
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(Hugeint::Cast<uint64_t>(value));
-	default:
-		return Value::Numeric(type, Hugeint::Cast<int64_t>(value));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// GetValueUnsafe
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::BOOL);
-	return value_.boolean;
-}
-
-template <>
-int8_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT8 || type_.InternalType() == PhysicalType::BOOL);
-	return value_.tinyint;
-}
-
-template <>
-int16_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT16);
-	return value_.smallint;
-}
-
-template <>
-int32_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
-	return value_.integer;
-}
-
-template <>
-int64_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.bigint;
-}
-
-template <>
-hugeint_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT128);
-	return value_.hugeint;
-}
-
-template <>
-uint8_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT8);
-	return value_.utinyint;
-}
-
-template <>
-uint16_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT16);
-	return value_.usmallint;
-}
-
-template <>
-uint32_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT32);
-	return value_.uinteger;
-}
-
-template <>
-uint64_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT64);
-	return value_.ubigint;
-}
-
-template <>
-string Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::VARCHAR);
-	return str_value;
-}
-
-template <>
-DUCKDB_API string_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::VARCHAR);
-	return string_t(str_value);
-}
-
-template <>
-float Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::FLOAT);
-	return value_.float_;
-}
-
-template <>
-double Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::DOUBLE);
-	return value_.double_;
-}
-
-template <>
-date_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
-	return value_.date;
-}
-
-template <>
-dtime_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.time;
-}
-
-template <>
-timestamp_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timestamp;
-}
-
-template <>
-interval_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::INTERVAL);
-	return value_.interval;
-}
-
-//===--------------------------------------------------------------------===//
-// GetReferenceUnsafe
-//===--------------------------------------------------------------------===//
-template <>
-int8_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT8 || type_.InternalType() == PhysicalType::BOOL);
-	return value_.tinyint;
-}
-
-template <>
-int16_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT16);
-	return value_.smallint;
-}
-
-template <>
-int32_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
-	return value_.integer;
-}
-
-template <>
-int64_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.bigint;
-}
-
-template <>
-hugeint_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT128);
-	return value_.hugeint;
-}
-
-template <>
-uint8_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT8);
-	return value_.utinyint;
-}
-
-template <>
-uint16_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT16);
-	return value_.usmallint;
-}
-
-template <>
-uint32_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT32);
-	return value_.uinteger;
-}
-
-template <>
-uint64_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT64);
-	return value_.ubigint;
-}
-
-template <>
-float &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::FLOAT);
-	return value_.float_;
-}
-
-template <>
-double &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::DOUBLE);
-	return value_.double_;
-}
-
-template <>
-date_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
-	return value_.date;
-}
-
-template <>
-dtime_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.time;
-}
-
-template <>
-timestamp_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timestamp;
-}
-
-template <>
-interval_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INTERVAL);
-	return value_.interval;
-}
-
-//===--------------------------------------------------------------------===//
-// Hash
-//===--------------------------------------------------------------------===//
-hash_t Value::Hash() const {
-	if (IsNull()) {
-		return 0;
-	}
-	switch (type_.InternalType()) {
-	case PhysicalType::BOOL:
-		return duckdb::Hash(value_.boolean);
-	case PhysicalType::INT8:
-		return duckdb::Hash(value_.tinyint);
-	case PhysicalType::INT16:
-		return duckdb::Hash(value_.smallint);
-	case PhysicalType::INT32:
-		return duckdb::Hash(value_.integer);
-	case PhysicalType::INT64:
-		return duckdb::Hash(value_.bigint);
-	case PhysicalType::UINT8:
-		return duckdb::Hash(value_.utinyint);
-	case PhysicalType::UINT16:
-		return duckdb::Hash(value_.usmallint);
-	case PhysicalType::UINT32:
-		return duckdb::Hash(value_.uinteger);
-	case PhysicalType::UINT64:
-		return duckdb::Hash(value_.ubigint);
-	case PhysicalType::INT128:
-		return duckdb::Hash(value_.hugeint);
-	case PhysicalType::FLOAT:
-		return duckdb::Hash(value_.float_);
-	case PhysicalType::DOUBLE:
-		return duckdb::Hash(value_.double_);
-	case PhysicalType::INTERVAL:
-		return duckdb::Hash(value_.interval);
-	case PhysicalType::VARCHAR:
-		return duckdb::Hash(string_t(StringValue::Get(*this)));
-	case PhysicalType::STRUCT: {
-		auto &struct_children = StructValue::GetChildren(*this);
-		hash_t hash = 0;
-		for (auto &entry : struct_children) {
-			hash ^= entry.Hash();
-		}
-		return hash;
-	}
-	case PhysicalType::LIST: {
-		auto &list_children = ListValue::GetChildren(*this);
-		hash_t hash = 0;
-		for (auto &entry : list_children) {
-			hash ^= entry.Hash();
-		}
-		return hash;
-	}
-	default:
-		throw InternalException("Unimplemented type for value hash");
-	}
-}
-
-string Value::ToString() const {
-	if (IsNull()) {
-		return "NULL";
-	}
-	switch (type_.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return value_.boolean ? "True" : "False";
-	case LogicalTypeId::TINYINT:
-		return to_string(value_.tinyint);
-	case LogicalTypeId::SMALLINT:
-		return to_string(value_.smallint);
-	case LogicalTypeId::INTEGER:
-		return to_string(value_.integer);
-	case LogicalTypeId::BIGINT:
-		return to_string(value_.bigint);
-	case LogicalTypeId::UTINYINT:
-		return to_string(value_.utinyint);
-	case LogicalTypeId::USMALLINT:
-		return to_string(value_.usmallint);
-	case LogicalTypeId::UINTEGER:
-		return to_string(value_.uinteger);
-	case LogicalTypeId::UBIGINT:
-		return to_string(value_.ubigint);
-	case LogicalTypeId::HUGEINT:
-		return Hugeint::ToString(value_.hugeint);
-	case LogicalTypeId::UUID:
-		return UUID::ToString(value_.hugeint);
-	case LogicalTypeId::FLOAT:
-		return duckdb_fmt::format("{}", value_.float_);
-	case LogicalTypeId::DOUBLE:
-		return duckdb_fmt::format("{}", value_.double_);
-	case LogicalTypeId::DECIMAL: {
-		auto internal_type = type_.InternalType();
-		auto scale = DecimalType::GetScale(type_);
-		if (internal_type == PhysicalType::INT16) {
-			return Decimal::ToString(value_.smallint, scale);
-		} else if (internal_type == PhysicalType::INT32) {
-			return Decimal::ToString(value_.integer, scale);
-		} else if (internal_type == PhysicalType::INT64) {
-			return Decimal::ToString(value_.bigint, scale);
-		} else {
-			D_ASSERT(internal_type == PhysicalType::INT128);
-			return Decimal::ToString(value_.hugeint, scale);
-		}
-	}
-	case LogicalTypeId::DATE:
-		return Date::ToString(value_.date);
-	case LogicalTypeId::TIME:
-		return Time::ToString(value_.time);
-	case LogicalTypeId::TIMESTAMP:
-		return Timestamp::ToString(value_.timestamp);
-	case LogicalTypeId::TIME_TZ:
-		return Time::ToString(value_.time) + Time::ToUTCOffset(0, 0);
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		// Infinite TSTZ values do not display offsets in PG.
-		auto ret = Timestamp::ToString(value_.timestamp);
-		if (Timestamp::IsFinite(value_.timestamp)) {
-			ret += Time::ToUTCOffset(0, 0);
-		}
-		return ret;
-	}
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Timestamp::ToString(Timestamp::FromEpochSeconds(value_.timestamp.value));
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Timestamp::ToString(Timestamp::FromEpochMs(value_.timestamp.value));
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Timestamp::ToString(Timestamp::FromEpochNanoSeconds(value_.timestamp.value));
-	case LogicalTypeId::INTERVAL:
-		return Interval::ToString(value_.interval);
-	case LogicalTypeId::JSON:
-	case LogicalTypeId::VARCHAR:
-		return str_value;
-	case LogicalTypeId::BLOB:
-		return Blob::ToString(string_t(str_value));
-	case LogicalTypeId::POINTER:
-		return to_string(value_.pointer);
-	case LogicalTypeId::STRUCT: {
-		string ret = "{";
-		auto &child_types = StructType::GetChildTypes(type_);
-		for (size_t i = 0; i < struct_value.size(); i++) {
-			auto &name = child_types[i].first;
-			auto &child = struct_value[i];
-			ret += "'" + name + "': " + child.ToString();
-			if (i < struct_value.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += "}";
-		return ret;
-	}
-	case LogicalTypeId::LIST: {
-		string ret = "[";
-		for (size_t i = 0; i < list_value.size(); i++) {
-			auto &child = list_value[i];
-			ret += child.ToString();
-			if (i < list_value.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += "]";
-		return ret;
-	}
-	case LogicalTypeId::MAP: {
-		string ret = "{";
-		auto &key_list = struct_value[0].list_value;
-		auto &value_list = struct_value[1].list_value;
-		for (size_t i = 0; i < key_list.size(); i++) {
-			ret += key_list[i].ToString() + "=" + value_list[i].ToString();
-			if (i < key_list.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += "}";
-		return ret;
-	}
-	case LogicalTypeId::ENUM: {
-		auto &values_insert_order = EnumType::GetValuesInsertOrder(type_);
-		uint64_t enum_idx;
-		switch (type_.InternalType()) {
-		case PhysicalType::UINT8:
-			enum_idx = value_.utinyint;
-			break;
-		case PhysicalType::UINT16:
-			enum_idx = value_.usmallint;
-			break;
-		case PhysicalType::UINT32:
-			enum_idx = value_.uinteger;
-			break;
-		case PhysicalType::UINT64:
-			return string((const char *)value_.bigint);
-		default:
-			throw InternalException("ENUM can only have unsigned integers as physical types");
-		}
-		return values_insert_order.GetValue(enum_idx).ToString();
-	}
-	default:
-		throw NotImplementedException("Unimplemented type for printing: %s", type_.ToString());
-	}
-}
-
-string Value::ToSQLString() const {
-	if (IsNull()) {
-		return ToString();
-	}
-	switch (type_.id()) {
-	case LogicalTypeId::UUID:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::INTERVAL:
-	case LogicalTypeId::BLOB:
-		return "'" + ToString() + "'::" + type_.ToString();
-	case LogicalTypeId::VARCHAR:
-		return "'" + StringUtil::Replace(ToString(), "'", "''") + "'";
-	case LogicalTypeId::STRUCT: {
-		string ret = "{";
-		auto &child_types = StructType::GetChildTypes(type_);
-		for (size_t i = 0; i < struct_value.size(); i++) {
-			auto &name = child_types[i].first;
-			auto &child = struct_value[i];
-			ret += "'" + name + "': " + child.ToSQLString();
-			if (i < struct_value.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += "}";
-		return ret;
-	}
-	case LogicalTypeId::FLOAT:
-		if (!FloatIsFinite(FloatValue::Get(*this))) {
-			return "'" + ToString() + "'::" + type_.ToString();
-		}
-		return ToString();
-	case LogicalTypeId::DOUBLE: {
-		double val = DoubleValue::Get(*this);
-		if (!DoubleIsFinite(val)) {
-			if (!Value::IsNan(val)) {
-				// to infinity and beyond
-				return val < 0 ? "-1e1000" : "1e1000";
-			}
-			return "'" + ToString() + "'::" + type_.ToString();
-		}
-		return ToString();
-	}
-	case LogicalTypeId::LIST: {
-		string ret = "[";
-		for (size_t i = 0; i < list_value.size(); i++) {
-			auto &child = list_value[i];
-			ret += child.ToSQLString();
-			if (i < list_value.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += "]";
-		return ret;
-	}
-	default:
-		return ToString();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Type-specific getters
-//===--------------------------------------------------------------------===//
-bool BooleanValue::Get(const Value &value) {
-	return value.GetValueUnsafe<bool>();
-}
-
-int8_t TinyIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<int8_t>();
-}
-
-int16_t SmallIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<int16_t>();
-}
-
-int32_t IntegerValue::Get(const Value &value) {
-	return value.GetValueUnsafe<int32_t>();
-}
-
-int64_t BigIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<int64_t>();
-}
-
-hugeint_t HugeIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<hugeint_t>();
-}
-
-uint8_t UTinyIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uint8_t>();
-}
-
-uint16_t USmallIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uint16_t>();
-}
-
-uint32_t UIntegerValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uint32_t>();
-}
-
-uint64_t UBigIntValue::Get(const Value &value) {
-	return value.GetValueUnsafe<uint64_t>();
-}
-
-float FloatValue::Get(const Value &value) {
-	return value.GetValueUnsafe<float>();
-}
-
-double DoubleValue::Get(const Value &value) {
-	return value.GetValueUnsafe<double>();
-}
-
-const string &StringValue::Get(const Value &value) {
-	D_ASSERT(value.type().InternalType() == PhysicalType::VARCHAR);
-	return value.str_value;
-}
-
-date_t DateValue::Get(const Value &value) {
-	return value.GetValueUnsafe<date_t>();
-}
-
-dtime_t TimeValue::Get(const Value &value) {
-	return value.GetValueUnsafe<dtime_t>();
-}
-
-timestamp_t TimestampValue::Get(const Value &value) {
-	return value.GetValueUnsafe<timestamp_t>();
-}
-
-interval_t IntervalValue::Get(const Value &value) {
-	return value.GetValueUnsafe<interval_t>();
-}
-
-const vector<Value> &StructValue::GetChildren(const Value &value) {
-	D_ASSERT(value.type().InternalType() == PhysicalType::STRUCT);
-	return value.struct_value;
-}
-
-const vector<Value> &ListValue::GetChildren(const Value &value) {
-	D_ASSERT(value.type().InternalType() == PhysicalType::LIST);
-	return value.list_value;
-}
-
-hugeint_t IntegralValue::Get(const Value &value) {
-	switch (value.type().InternalType()) {
-	case PhysicalType::INT8:
-		return TinyIntValue::Get(value);
-	case PhysicalType::INT16:
-		return SmallIntValue::Get(value);
-	case PhysicalType::INT32:
-		return IntegerValue::Get(value);
-	case PhysicalType::INT64:
-		return BigIntValue::Get(value);
-	case PhysicalType::INT128:
-		return HugeIntValue::Get(value);
-	case PhysicalType::UINT8:
-		return UTinyIntValue::Get(value);
-	case PhysicalType::UINT16:
-		return USmallIntValue::Get(value);
-	case PhysicalType::UINT32:
-		return UIntegerValue::Get(value);
-	case PhysicalType::UINT64:
-		return UBigIntValue::Get(value);
-	default:
-		throw InternalException("Invalid internal type \"%s\" for IntegralValue::Get", value.type().ToString());
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Comparison Operators
-//===--------------------------------------------------------------------===//
-bool Value::operator==(const Value &rhs) const {
-	return ValueOperations::Equals(*this, rhs);
-}
-
-bool Value::operator!=(const Value &rhs) const {
-	return ValueOperations::NotEquals(*this, rhs);
-}
-
-bool Value::operator<(const Value &rhs) const {
-	return ValueOperations::LessThan(*this, rhs);
-}
-
-bool Value::operator>(const Value &rhs) const {
-	return ValueOperations::GreaterThan(*this, rhs);
-}
-
-bool Value::operator<=(const Value &rhs) const {
-	return ValueOperations::LessThanEquals(*this, rhs);
-}
-
-bool Value::operator>=(const Value &rhs) const {
-	return ValueOperations::GreaterThanEquals(*this, rhs);
-}
-
-bool Value::operator==(const int64_t &rhs) const {
-	return *this == Value::Numeric(type_, rhs);
-}
-
-bool Value::operator!=(const int64_t &rhs) const {
-	return *this != Value::Numeric(type_, rhs);
-}
-
-bool Value::operator<(const int64_t &rhs) const {
-	return *this < Value::Numeric(type_, rhs);
-}
-
-bool Value::operator>(const int64_t &rhs) const {
-	return *this > Value::Numeric(type_, rhs);
-}
-
-bool Value::operator<=(const int64_t &rhs) const {
-	return *this <= Value::Numeric(type_, rhs);
-}
-
-bool Value::operator>=(const int64_t &rhs) const {
-	return *this >= Value::Numeric(type_, rhs);
-}
-
-bool Value::TryCastAs(const LogicalType &target_type, Value &new_value, string *error_message, bool strict) const {
-	if (type_ == target_type) {
-		new_value = Copy();
-		return true;
-	}
-	Vector input(*this);
-	Vector result(target_type);
-	if (!VectorOperations::TryCast(input, result, 1, error_message, strict)) {
-		return false;
-	}
-	new_value = result.GetValue(0);
-	return true;
-}
-
-Value Value::CastAs(const LogicalType &target_type, bool strict) const {
-	Value new_value;
-	string error_message;
-	if (!TryCastAs(target_type, new_value, &error_message, strict)) {
-		throw InvalidInputException("Failed to cast value: %s", error_message);
-	}
-	return new_value;
-}
-
-bool Value::TryCastAs(const LogicalType &target_type, bool strict) {
-	Value new_value;
-	string error_message;
-	if (!TryCastAs(target_type, new_value, &error_message, strict)) {
-		return false;
-	}
-	type_ = target_type;
-	is_null = new_value.is_null;
-	value_ = new_value.value_;
-	str_value = new_value.str_value;
-	struct_value = new_value.struct_value;
-	list_value = new_value.list_value;
-	return true;
-}
-
-void Value::Serialize(Serializer &main_serializer) const {
-	FieldWriter writer(main_serializer);
-	writer.WriteSerializable(type_);
-	writer.WriteField<bool>(IsNull());
-	if (!IsNull()) {
-		auto &serializer = writer.GetSerializer();
-		switch (type_.InternalType()) {
-		case PhysicalType::BOOL:
-			serializer.Write<int8_t>(value_.boolean);
-			break;
-		case PhysicalType::INT8:
-			serializer.Write<int8_t>(value_.tinyint);
-			break;
-		case PhysicalType::INT16:
-			serializer.Write<int16_t>(value_.smallint);
-			break;
-		case PhysicalType::INT32:
-			serializer.Write<int32_t>(value_.integer);
-			break;
-		case PhysicalType::INT64:
-			serializer.Write<int64_t>(value_.bigint);
-			break;
-		case PhysicalType::UINT8:
-			serializer.Write<uint8_t>(value_.utinyint);
-			break;
-		case PhysicalType::UINT16:
-			serializer.Write<uint16_t>(value_.usmallint);
-			break;
-		case PhysicalType::UINT32:
-			serializer.Write<uint32_t>(value_.uinteger);
-			break;
-		case PhysicalType::UINT64:
-			serializer.Write<uint64_t>(value_.ubigint);
-			break;
-		case PhysicalType::INT128:
-			serializer.Write<hugeint_t>(value_.hugeint);
-			break;
-		case PhysicalType::FLOAT:
-			serializer.Write<float>(value_.float_);
-			break;
-		case PhysicalType::DOUBLE:
-			serializer.Write<double>(value_.double_);
-			break;
-		case PhysicalType::INTERVAL:
-			serializer.Write<interval_t>(value_.interval);
-			break;
-		case PhysicalType::VARCHAR:
-			serializer.WriteString(str_value);
-			break;
-		default: {
-			Vector v(*this);
-			v.Serialize(1, serializer);
-			break;
-		}
-		}
-	}
-	writer.Finalize();
-}
-
-Value Value::Deserialize(Deserializer &main_source) {
-	FieldReader reader(main_source);
-	auto type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto is_null = reader.ReadRequired<bool>();
-	Value new_value = Value(type);
-	if (is_null) {
-		reader.Finalize();
-		return new_value;
-	}
-	new_value.is_null = false;
-	auto &source = reader.GetSource();
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		new_value.value_.boolean = source.Read<int8_t>();
-		break;
-	case PhysicalType::INT8:
-		new_value.value_.tinyint = source.Read<int8_t>();
-		break;
-	case PhysicalType::INT16:
-		new_value.value_.smallint = source.Read<int16_t>();
-		break;
-	case PhysicalType::INT32:
-		new_value.value_.integer = source.Read<int32_t>();
-		break;
-	case PhysicalType::INT64:
-		new_value.value_.bigint = source.Read<int64_t>();
-		break;
-	case PhysicalType::UINT8:
-		new_value.value_.utinyint = source.Read<uint8_t>();
-		break;
-	case PhysicalType::UINT16:
-		new_value.value_.usmallint = source.Read<uint16_t>();
-		break;
-	case PhysicalType::UINT32:
-		new_value.value_.uinteger = source.Read<uint32_t>();
-		break;
-	case PhysicalType::UINT64:
-		new_value.value_.ubigint = source.Read<uint64_t>();
-		break;
-	case PhysicalType::INT128:
-		new_value.value_.hugeint = source.Read<hugeint_t>();
-		break;
-	case PhysicalType::FLOAT:
-		new_value.value_.float_ = source.Read<float>();
-		break;
-	case PhysicalType::DOUBLE:
-		new_value.value_.double_ = source.Read<double>();
-		break;
-	case PhysicalType::INTERVAL:
-		new_value.value_.interval = source.Read<interval_t>();
-		break;
-	case PhysicalType::VARCHAR:
-		new_value.str_value = source.Read<string>();
-		break;
-	default: {
-		Vector v(type);
-		v.Deserialize(1, source);
-		new_value = v.GetValue(0);
-		break;
-	}
-	}
-	reader.Finalize();
-	return new_value;
-}
-
-void Value::Print() const {
-	Printer::Print(ToString());
-}
-
-bool Value::NotDistinctFrom(const Value &lvalue, const Value &rvalue) {
-	return ValueOperations::NotDistinctFrom(lvalue, rvalue);
-}
-
-bool Value::ValuesAreEqual(const Value &result_value, const Value &value) {
-	if (result_value.IsNull() != value.IsNull()) {
-		return false;
-	}
-	if (result_value.IsNull() && value.IsNull()) {
-		// NULL = NULL in checking code
-		return true;
-	}
-	switch (value.type_.id()) {
-	case LogicalTypeId::FLOAT: {
-		auto other = result_value.CastAs(LogicalType::FLOAT);
-		float ldecimal = value.value_.float_;
-		float rdecimal = other.value_.float_;
-		return ApproxEqual(ldecimal, rdecimal);
-	}
-	case LogicalTypeId::DOUBLE: {
-		auto other = result_value.CastAs(LogicalType::DOUBLE);
-		double ldecimal = value.value_.double_;
-		double rdecimal = other.value_.double_;
-		return ApproxEqual(ldecimal, rdecimal);
-	}
-	case LogicalTypeId::VARCHAR: {
-		auto other = result_value.CastAs(LogicalType::VARCHAR);
-		// some results might contain padding spaces, e.g. when rendering
-		// VARCHAR(10) and the string only has 6 characters, they will be padded
-		// with spaces to 10 in the rendering. We don't do that here yet as we
-		// are looking at internal structures. So just ignore any extra spaces
-		// on the right
-		string left = other.str_value;
-		string right = value.str_value;
-		StringUtil::RTrim(left);
-		StringUtil::RTrim(right);
-		return left == right;
-	}
-	default:
-		if (result_value.type_.id() == LogicalTypeId::FLOAT || result_value.type_.id() == LogicalTypeId::DOUBLE) {
-			return Value::ValuesAreEqual(value, result_value);
-		}
-		return value == result_value;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cstring> // strlen() on Solaris
-
-namespace duckdb {
-
-Vector::Vector(LogicalType type_p, bool create_data, bool zero_data, idx_t capacity)
-    : vector_type(VectorType::FLAT_VECTOR), type(move(type_p)), data(nullptr) {
-	if (create_data) {
-		Initialize(zero_data, capacity);
-	}
-}
-
-Vector::Vector(LogicalType type_p, idx_t capacity) : Vector(move(type_p), true, false, capacity) {
-}
-
-Vector::Vector(LogicalType type_p, data_ptr_t dataptr)
-    : vector_type(VectorType::FLAT_VECTOR), type(move(type_p)), data(dataptr) {
-	if (dataptr && type.id() == LogicalTypeId::INVALID) {
-		throw InternalException("Cannot create a vector of type INVALID!");
-	}
-}
-
-Vector::Vector(const VectorCache &cache) : type(cache.GetType()) {
-	ResetFromCache(cache);
-}
-
-Vector::Vector(Vector &other) : type(other.type) {
-	Reference(other);
-}
-
-Vector::Vector(Vector &other, const SelectionVector &sel, idx_t count) : type(other.type) {
-	Slice(other, sel, count);
-}
-
-Vector::Vector(Vector &other, idx_t offset) : type(other.type) {
-	Slice(other, offset);
-}
-
-Vector::Vector(const Value &value) : type(value.type()) {
-	Reference(value);
-}
-
-Vector::Vector(Vector &&other) noexcept
-    : vector_type(other.vector_type), type(move(other.type)), data(other.data), validity(move(other.validity)),
-      buffer(move(other.buffer)), auxiliary(move(other.auxiliary)) {
-}
-
-void Vector::Reference(const Value &value) {
-	D_ASSERT(GetType().id() == value.type().id());
-	this->vector_type = VectorType::CONSTANT_VECTOR;
-	buffer = VectorBuffer::CreateConstantVector(value.type());
-	auto internal_type = value.type().InternalType();
-	if (internal_type == PhysicalType::STRUCT) {
-		auto struct_buffer = make_unique<VectorStructBuffer>();
-		auto &child_types = StructType::GetChildTypes(value.type());
-		auto &child_vectors = struct_buffer->GetChildren();
-		auto &value_children = StructValue::GetChildren(value);
-		for (idx_t i = 0; i < child_types.size(); i++) {
-			auto vector = make_unique<Vector>(value.IsNull() ? Value(child_types[i].second) : value_children[i]);
-			child_vectors.push_back(move(vector));
-		}
-		auxiliary = move(struct_buffer);
-		if (value.IsNull()) {
-			SetValue(0, value);
-		}
-	} else if (internal_type == PhysicalType::LIST) {
-		auto list_buffer = make_unique<VectorListBuffer>(value.type());
-		auxiliary = move(list_buffer);
-		data = buffer->GetData();
-		SetValue(0, value);
-	} else {
-		auxiliary.reset();
-		data = buffer->GetData();
-		SetValue(0, value);
-	}
-}
-
-void Vector::Reference(Vector &other) {
-	D_ASSERT(other.GetType() == GetType());
-	Reinterpret(other);
-}
-
-void Vector::ReferenceAndSetType(Vector &other) {
-	type = other.GetType();
-	Reference(other);
-}
-
-void Vector::Reinterpret(Vector &other) {
-	vector_type = other.vector_type;
-	AssignSharedPointer(buffer, other.buffer);
-	AssignSharedPointer(auxiliary, other.auxiliary);
-	data = other.data;
-	validity = other.validity;
-}
-
-void Vector::ResetFromCache(const VectorCache &cache) {
-	cache.ResetFromCache(*this);
-}
-
-void Vector::Slice(Vector &other, idx_t offset) {
-	if (other.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		Reference(other);
-		return;
-	}
-	D_ASSERT(other.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	auto internal_type = GetType().InternalType();
-	if (internal_type == PhysicalType::STRUCT) {
-		Vector new_vector(GetType());
-		auto &entries = StructVector::GetEntries(new_vector);
-		auto &other_entries = StructVector::GetEntries(other);
-		D_ASSERT(entries.size() == other_entries.size());
-		for (idx_t i = 0; i < entries.size(); i++) {
-			entries[i]->Slice(*other_entries[i], offset);
-		}
-		if (offset > 0) {
-			new_vector.validity.Slice(other.validity, offset);
-		} else {
-			new_vector.validity = other.validity;
-		}
-		Reference(new_vector);
-	} else {
-		Reference(other);
-		if (offset > 0) {
-			data = data + GetTypeIdSize(internal_type) * offset;
-			validity.Slice(other.validity, offset);
-		}
-	}
-}
-
-void Vector::Slice(Vector &other, const SelectionVector &sel, idx_t count) {
-	Reference(other);
-	Slice(sel, count);
-}
-
-void Vector::Slice(const SelectionVector &sel, idx_t count) {
-	if (GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// dictionary on a constant is just a constant
-		return;
-	}
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		// already a dictionary, slice the current dictionary
-		auto &current_sel = DictionaryVector::SelVector(*this);
-		auto sliced_dictionary = current_sel.Slice(sel, count);
-		buffer = make_buffer<DictionaryBuffer>(move(sliced_dictionary));
-		if (GetType().InternalType() == PhysicalType::STRUCT) {
-			auto &child_vector = DictionaryVector::Child(*this);
-
-			Vector new_child(child_vector);
-			new_child.auxiliary = make_buffer<VectorStructBuffer>(new_child, sel, count);
-			auxiliary = make_buffer<VectorChildBuffer>(move(new_child));
-		}
-		return;
-	}
-	Vector child_vector(*this);
-	auto internal_type = GetType().InternalType();
-	if (internal_type == PhysicalType::STRUCT) {
-		child_vector.auxiliary = make_buffer<VectorStructBuffer>(*this, sel, count);
-	}
-	auto child_ref = make_buffer<VectorChildBuffer>(move(child_vector));
-	auto dict_buffer = make_buffer<DictionaryBuffer>(sel);
-	vector_type = VectorType::DICTIONARY_VECTOR;
-	buffer = move(dict_buffer);
-	auxiliary = move(child_ref);
-}
-
-void Vector::Slice(const SelectionVector &sel, idx_t count, SelCache &cache) {
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR && GetType().InternalType() != PhysicalType::STRUCT) {
-		// dictionary vector: need to merge dictionaries
-		// check if we have a cached entry
-		auto &current_sel = DictionaryVector::SelVector(*this);
-		auto target_data = current_sel.data();
-		auto entry = cache.cache.find(target_data);
-		if (entry != cache.cache.end()) {
-			// cached entry exists: use that
-			this->buffer = make_buffer<DictionaryBuffer>(((DictionaryBuffer &)*entry->second).GetSelVector());
-			vector_type = VectorType::DICTIONARY_VECTOR;
-		} else {
-			Slice(sel, count);
-			cache.cache[target_data] = this->buffer;
-		}
-	} else {
-		Slice(sel, count);
-	}
-}
-
-void Vector::Initialize(bool zero_data, idx_t capacity) {
-	auxiliary.reset();
-	validity.Reset();
-	auto &type = GetType();
-	auto internal_type = type.InternalType();
-	if (internal_type == PhysicalType::STRUCT) {
-		auto struct_buffer = make_unique<VectorStructBuffer>(type, capacity);
-		auxiliary = move(struct_buffer);
-	} else if (internal_type == PhysicalType::LIST) {
-		auto list_buffer = make_unique<VectorListBuffer>(type, capacity);
-		auxiliary = move(list_buffer);
-	}
-	auto type_size = GetTypeIdSize(internal_type);
-	if (type_size > 0) {
-		buffer = VectorBuffer::CreateStandardVector(type, capacity);
-		data = buffer->GetData();
-		if (zero_data) {
-			memset(data, 0, capacity * type_size);
-		}
-	}
-}
-
-struct DataArrays {
-	Vector &vec;
-	data_ptr_t data;
-	VectorBuffer *buffer;
-	idx_t type_size;
-	bool is_nested;
-	DataArrays(Vector &vec, data_ptr_t data, VectorBuffer *buffer, idx_t type_size, bool is_nested)
-	    : vec(vec), data(data), buffer(buffer), type_size(type_size), is_nested(is_nested) {};
-};
-
-void FindChildren(std::vector<DataArrays> &to_resize, VectorBuffer &auxiliary) {
-	if (auxiliary.GetBufferType() == VectorBufferType::LIST_BUFFER) {
-		auto &buffer = (VectorListBuffer &)auxiliary;
-		auto &child = buffer.GetChild();
-		auto data = child.GetData();
-		if (!data) {
-			//! Nested type
-			DataArrays arrays(child, data, child.GetBuffer().get(), GetTypeIdSize(child.GetType().InternalType()),
-			                  true);
-			to_resize.emplace_back(arrays);
-			FindChildren(to_resize, *child.GetAuxiliary());
-		} else {
-			DataArrays arrays(child, data, child.GetBuffer().get(), GetTypeIdSize(child.GetType().InternalType()),
-			                  false);
-			to_resize.emplace_back(arrays);
-		}
-	} else if (auxiliary.GetBufferType() == VectorBufferType::STRUCT_BUFFER) {
-		auto &buffer = (VectorStructBuffer &)auxiliary;
-		auto &children = buffer.GetChildren();
-		for (auto &child : children) {
-			auto data = child->GetData();
-			if (!data) {
-				//! Nested type
-				DataArrays arrays(*child, data, child->GetBuffer().get(),
-				                  GetTypeIdSize(child->GetType().InternalType()), true);
-				to_resize.emplace_back(arrays);
-				FindChildren(to_resize, *child->GetAuxiliary());
-			} else {
-				DataArrays arrays(*child, data, child->GetBuffer().get(),
-				                  GetTypeIdSize(child->GetType().InternalType()), false);
-				to_resize.emplace_back(arrays);
-			}
-		}
-	}
-}
-void Vector::Resize(idx_t cur_size, idx_t new_size) {
-	std::vector<DataArrays> to_resize;
-	if (!buffer) {
-		buffer = make_unique<VectorBuffer>(0);
-	}
-	if (!data) {
-		//! this is a nested structure
-		DataArrays arrays(*this, data, buffer.get(), GetTypeIdSize(GetType().InternalType()), true);
-		to_resize.emplace_back(arrays);
-		FindChildren(to_resize, *auxiliary);
-	} else {
-		DataArrays arrays(*this, data, buffer.get(), GetTypeIdSize(GetType().InternalType()), false);
-		to_resize.emplace_back(arrays);
-	}
-	for (auto &data_to_resize : to_resize) {
-		if (!data_to_resize.is_nested) {
-			auto new_data = unique_ptr<data_t[]>(new data_t[new_size * data_to_resize.type_size]);
-			memcpy(new_data.get(), data_to_resize.data, cur_size * data_to_resize.type_size * sizeof(data_t));
-			data_to_resize.buffer->SetData(move(new_data));
-			data_to_resize.vec.data = data_to_resize.buffer->GetData();
-		}
-		data_to_resize.vec.validity.Resize(cur_size, new_size);
-	}
-}
-
-void Vector::SetValue(idx_t index, const Value &val) {
-	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		// dictionary: apply dictionary and forward to child
-		auto &sel_vector = DictionaryVector::SelVector(*this);
-		auto &child = DictionaryVector::Child(*this);
-		return child.SetValue(sel_vector.get_index(index), val);
-	}
-	if (val.type().InternalType() != GetType().InternalType()) {
-		SetValue(index, val.CastAs(GetType()));
-		return;
-	}
-
-	validity.EnsureWritable();
-	validity.Set(index, !val.IsNull());
-	if (val.IsNull() && GetType().InternalType() != PhysicalType::STRUCT) {
-		// for structs we still need to set the child-entries to NULL
-		// so we do not bail out yet
-		return;
-	}
-
-	switch (GetType().InternalType()) {
-	case PhysicalType::BOOL:
-		((bool *)data)[index] = val.GetValueUnsafe<bool>();
-		break;
-	case PhysicalType::INT8:
-		((int8_t *)data)[index] = val.GetValueUnsafe<int8_t>();
-		break;
-	case PhysicalType::INT16:
-		((int16_t *)data)[index] = val.GetValueUnsafe<int16_t>();
-		break;
-	case PhysicalType::INT32:
-		((int32_t *)data)[index] = val.GetValueUnsafe<int32_t>();
-		break;
-	case PhysicalType::INT64:
-		((int64_t *)data)[index] = val.GetValueUnsafe<int64_t>();
-		break;
-	case PhysicalType::INT128:
-		((hugeint_t *)data)[index] = val.GetValueUnsafe<hugeint_t>();
-		break;
-	case PhysicalType::UINT8:
-		((uint8_t *)data)[index] = val.GetValueUnsafe<uint8_t>();
-		break;
-	case PhysicalType::UINT16:
-		((uint16_t *)data)[index] = val.GetValueUnsafe<uint16_t>();
-		break;
-	case PhysicalType::UINT32:
-		((uint32_t *)data)[index] = val.GetValueUnsafe<uint32_t>();
-		break;
-	case PhysicalType::UINT64:
-		((uint64_t *)data)[index] = val.GetValueUnsafe<uint64_t>();
-		break;
-	case PhysicalType::FLOAT:
-		((float *)data)[index] = val.GetValueUnsafe<float>();
-		break;
-	case PhysicalType::DOUBLE:
-		((double *)data)[index] = val.GetValueUnsafe<double>();
-		break;
-	case PhysicalType::INTERVAL:
-		((interval_t *)data)[index] = val.GetValueUnsafe<interval_t>();
-		break;
-	case PhysicalType::VARCHAR:
-		((string_t *)data)[index] = StringVector::AddStringOrBlob(*this, StringValue::Get(val));
-		break;
-	case PhysicalType::STRUCT: {
-		D_ASSERT(GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR);
-
-		auto &children = StructVector::GetEntries(*this);
-		auto &val_children = StructValue::GetChildren(val);
-		D_ASSERT(val.IsNull() || children.size() == val_children.size());
-		for (size_t i = 0; i < children.size(); i++) {
-			auto &vec_child = children[i];
-			if (!val.IsNull()) {
-				auto &struct_child = val_children[i];
-				vec_child->SetValue(index, struct_child);
-			} else {
-				vec_child->SetValue(index, Value());
-			}
-		}
-		break;
-	}
-	case PhysicalType::LIST: {
-		auto offset = ListVector::GetListSize(*this);
-		auto &val_children = ListValue::GetChildren(val);
-		if (!val_children.empty()) {
-			for (idx_t i = 0; i < val_children.size(); i++) {
-				ListVector::PushBack(*this, val_children[i]);
-			}
-		}
-		//! now set the pointer
-		auto &entry = ((list_entry_t *)data)[index];
-		entry.length = val_children.size();
-		entry.offset = offset;
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented type for Vector::SetValue");
-	}
-}
-
-Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
-	const Vector *vector = &v_p;
-	idx_t index = index_p;
-	bool finished = false;
-	while (!finished) {
-		switch (vector->GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR:
-			index = 0;
-			finished = true;
-			break;
-		case VectorType::FLAT_VECTOR:
-			finished = true;
-			break;
-			// dictionary: apply dictionary and forward to child
-		case VectorType::DICTIONARY_VECTOR: {
-			auto &sel_vector = DictionaryVector::SelVector(*vector);
-			auto &child = DictionaryVector::Child(*vector);
-			vector = &child;
-			index = sel_vector.get_index(index);
-			break;
-		}
-		case VectorType::SEQUENCE_VECTOR: {
-			int64_t start, increment;
-			SequenceVector::GetSequence(*vector, start, increment);
-			return Value::Numeric(vector->GetType(), start + increment * index);
-		}
-		default:
-			throw InternalException("Unimplemented vector type for Vector::GetValue");
-		}
-	}
-	auto data = vector->data;
-	auto &validity = vector->validity;
-	auto &type = vector->GetType();
-
-	if (!validity.RowIsValid(index)) {
-		return Value(vector->GetType());
-	}
-	switch (vector->GetType().id()) {
-	case LogicalTypeId::BOOLEAN:
-		return Value::BOOLEAN(((bool *)data)[index]);
-	case LogicalTypeId::TINYINT:
-		return Value::TINYINT(((int8_t *)data)[index]);
-	case LogicalTypeId::SMALLINT:
-		return Value::SMALLINT(((int16_t *)data)[index]);
-	case LogicalTypeId::INTEGER:
-		return Value::INTEGER(((int32_t *)data)[index]);
-	case LogicalTypeId::DATE:
-		return Value::DATE(((date_t *)data)[index]);
-	case LogicalTypeId::TIME:
-		return Value::TIME(((dtime_t *)data)[index]);
-	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(((dtime_t *)data)[index]);
-	case LogicalTypeId::BIGINT:
-		return Value::BIGINT(((int64_t *)data)[index]);
-	case LogicalTypeId::UTINYINT:
-		return Value::UTINYINT(((uint8_t *)data)[index]);
-	case LogicalTypeId::USMALLINT:
-		return Value::USMALLINT(((uint16_t *)data)[index]);
-	case LogicalTypeId::UINTEGER:
-		return Value::UINTEGER(((uint32_t *)data)[index]);
-	case LogicalTypeId::UBIGINT:
-		return Value::UBIGINT(((uint64_t *)data)[index]);
-	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(((timestamp_t *)data)[index]);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(((timestamp_t *)data)[index]);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(((timestamp_t *)data)[index]);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(((timestamp_t *)data)[index]);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(((timestamp_t *)data)[index]);
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(((hugeint_t *)data)[index]);
-	case LogicalTypeId::UUID:
-		return Value::UUID(((hugeint_t *)data)[index]);
-	case LogicalTypeId::DECIMAL: {
-		auto width = DecimalType::GetWidth(type);
-		auto scale = DecimalType::GetScale(type);
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return Value::DECIMAL(((int16_t *)data)[index], width, scale);
-		case PhysicalType::INT32:
-			return Value::DECIMAL(((int32_t *)data)[index], width, scale);
-		case PhysicalType::INT64:
-			return Value::DECIMAL(((int64_t *)data)[index], width, scale);
-		case PhysicalType::INT128:
-			return Value::DECIMAL(((hugeint_t *)data)[index], width, scale);
-		default:
-			throw InternalException("Widths bigger than 38 are not supported");
-		}
-	}
-	case LogicalTypeId::ENUM: {
-		switch (type.InternalType()) {
-		case PhysicalType::UINT8:
-			return Value::ENUM(((uint8_t *)data)[index], type);
-		case PhysicalType::UINT16:
-			return Value::ENUM(((uint16_t *)data)[index], type);
-		case PhysicalType::UINT32:
-			return Value::ENUM(((uint32_t *)data)[index], type);
-		case PhysicalType::UINT64: //  DEDUP_POINTER_ENUM
-			return Value::ENUM(((uint64_t *)data)[index], type);
-		default:
-			throw InternalException("ENUM can only have unsigned integers as physical types");
-		}
-	}
-	case LogicalTypeId::POINTER:
-		return Value::POINTER(((uintptr_t *)data)[index]);
-	case LogicalTypeId::FLOAT:
-		return Value::FLOAT(((float *)data)[index]);
-	case LogicalTypeId::DOUBLE:
-		return Value::DOUBLE(((double *)data)[index]);
-	case LogicalTypeId::INTERVAL:
-		return Value::INTERVAL(((interval_t *)data)[index]);
-	case LogicalTypeId::VARCHAR: {
-		auto str = ((string_t *)data)[index];
-		return Value(str.GetString());
-	}
-	case LogicalTypeId::JSON: {
-		auto str = ((string_t *)data)[index];
-		return Value::JSON(str.GetString());
-	}
-	case LogicalTypeId::AGGREGATE_STATE:
-	case LogicalTypeId::BLOB: {
-		auto str = ((string_t *)data)[index];
-		return Value::BLOB((const_data_ptr_t)str.GetDataUnsafe(), str.GetSize());
-	}
-	case LogicalTypeId::MAP: {
-		auto &child_entries = StructVector::GetEntries(*vector);
-		Value key = child_entries[0]->GetValue(index);
-		Value value = child_entries[1]->GetValue(index);
-		return Value::MAP(move(key), move(value));
-	}
-	case LogicalTypeId::STRUCT: {
-		// we can derive the value schema from the vector schema
-		auto &child_entries = StructVector::GetEntries(*vector);
-		child_list_t<Value> children;
-		for (idx_t child_idx = 0; child_idx < child_entries.size(); child_idx++) {
-			auto &struct_child = child_entries[child_idx];
-			children.push_back(make_pair(StructType::GetChildName(type, child_idx), struct_child->GetValue(index_p)));
-		}
-		return Value::STRUCT(move(children));
-	}
-	case LogicalTypeId::LIST: {
-		auto offlen = ((list_entry_t *)data)[index];
-		auto &child_vec = ListVector::GetEntry(*vector);
-		std::vector<Value> children;
-		for (idx_t i = offlen.offset; i < offlen.offset + offlen.length; i++) {
-			children.push_back(child_vec.GetValue(i));
-		}
-		return Value::LIST(ListType::GetChildType(type), move(children));
-	}
-	default:
-		throw InternalException("Unimplemented type for value access");
-	}
-}
-
-Value Vector::GetValue(idx_t index) const {
-	return GetValue(*this, index);
-}
-
-// LCOV_EXCL_START
-string VectorTypeToString(VectorType type) {
-	switch (type) {
-	case VectorType::FLAT_VECTOR:
-		return "FLAT";
-	case VectorType::SEQUENCE_VECTOR:
-		return "SEQUENCE";
-	case VectorType::DICTIONARY_VECTOR:
-		return "DICTIONARY";
-	case VectorType::CONSTANT_VECTOR:
-		return "CONSTANT";
-	default:
-		return "UNKNOWN";
-	}
-}
-
-string Vector::ToString(idx_t count) const {
-	string retval =
-	    VectorTypeToString(GetVectorType()) + " " + GetType().ToString() + ": " + to_string(count) + " = [ ";
-	switch (GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-	case VectorType::DICTIONARY_VECTOR:
-		for (idx_t i = 0; i < count; i++) {
-			retval += GetValue(i).ToString() + (i == count - 1 ? "" : ", ");
-		}
-		break;
-	case VectorType::CONSTANT_VECTOR:
-		retval += GetValue(0).ToString();
-		break;
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment;
-		SequenceVector::GetSequence(*this, start, increment);
-		for (idx_t i = 0; i < count; i++) {
-			retval += to_string(start + increment * i) + (i == count - 1 ? "" : ", ");
-		}
-		break;
-	}
-	default:
-		retval += "UNKNOWN VECTOR TYPE";
-		break;
-	}
-	retval += "]";
-	return retval;
-}
-
-void Vector::Print(idx_t count) {
-	Printer::Print(ToString(count));
-}
-
-string Vector::ToString() const {
-	string retval = VectorTypeToString(GetVectorType()) + " " + GetType().ToString() + ": (UNKNOWN COUNT) [ ";
-	switch (GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-	case VectorType::DICTIONARY_VECTOR:
-		break;
-	case VectorType::CONSTANT_VECTOR:
-		retval += GetValue(0).ToString();
-		break;
-	case VectorType::SEQUENCE_VECTOR: {
-		break;
-	}
-	default:
-		retval += "UNKNOWN VECTOR TYPE";
-		break;
-	}
-	retval += "]";
-	return retval;
-}
-
-void Vector::Print() {
-	Printer::Print(ToString());
-}
-// LCOV_EXCL_STOP
-
-template <class T>
-static void TemplatedFlattenConstantVector(data_ptr_t data, data_ptr_t old_data, idx_t count) {
-	auto constant = Load<T>(old_data);
-	auto output = (T *)data;
-	for (idx_t i = 0; i < count; i++) {
-		output[i] = constant;
-	}
-}
-
-void Vector::Normalify(idx_t count) {
-	switch (GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		// already a flat vector
-		break;
-	case VectorType::DICTIONARY_VECTOR: {
-		// create a new flat vector of this type
-		Vector other(GetType(), count);
-		// now copy the data of this vector to the other vector, removing the selection vector in the process
-		VectorOperations::Copy(*this, other, count, 0, 0);
-		// create a reference to the data in the other vector
-		this->Reference(other);
-		break;
-	}
-	case VectorType::CONSTANT_VECTOR: {
-		bool is_null = ConstantVector::IsNull(*this);
-		// allocate a new buffer for the vector
-		auto old_buffer = move(buffer);
-		auto old_data = data;
-		buffer = VectorBuffer::CreateStandardVector(type, MaxValue<idx_t>(STANDARD_VECTOR_SIZE, count));
-		data = buffer->GetData();
-		vector_type = VectorType::FLAT_VECTOR;
-		if (is_null) {
-			// constant NULL, set nullmask
-			validity.EnsureWritable();
-			validity.SetAllInvalid(count);
-			return;
-		}
-		// non-null constant: have to repeat the constant
-		switch (GetType().InternalType()) {
-		case PhysicalType::BOOL:
-			TemplatedFlattenConstantVector<bool>(data, old_data, count);
-			break;
-		case PhysicalType::INT8:
-			TemplatedFlattenConstantVector<int8_t>(data, old_data, count);
-			break;
-		case PhysicalType::INT16:
-			TemplatedFlattenConstantVector<int16_t>(data, old_data, count);
-			break;
-		case PhysicalType::INT32:
-			TemplatedFlattenConstantVector<int32_t>(data, old_data, count);
-			break;
-		case PhysicalType::INT64:
-			TemplatedFlattenConstantVector<int64_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT8:
-			TemplatedFlattenConstantVector<uint8_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT16:
-			TemplatedFlattenConstantVector<uint16_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT32:
-			TemplatedFlattenConstantVector<uint32_t>(data, old_data, count);
-			break;
-		case PhysicalType::UINT64:
-			TemplatedFlattenConstantVector<uint64_t>(data, old_data, count);
-			break;
-		case PhysicalType::INT128:
-			TemplatedFlattenConstantVector<hugeint_t>(data, old_data, count);
-			break;
-		case PhysicalType::FLOAT:
-			TemplatedFlattenConstantVector<float>(data, old_data, count);
-			break;
-		case PhysicalType::DOUBLE:
-			TemplatedFlattenConstantVector<double>(data, old_data, count);
-			break;
-		case PhysicalType::INTERVAL:
-			TemplatedFlattenConstantVector<interval_t>(data, old_data, count);
-			break;
-		case PhysicalType::VARCHAR:
-			TemplatedFlattenConstantVector<string_t>(data, old_data, count);
-			break;
-		case PhysicalType::LIST: {
-			TemplatedFlattenConstantVector<list_entry_t>(data, old_data, count);
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			auto normalified_buffer = make_unique<VectorStructBuffer>();
-
-			auto &new_children = normalified_buffer->GetChildren();
-
-			auto &child_entries = StructVector::GetEntries(*this);
-			for (auto &child : child_entries) {
-				D_ASSERT(child->GetVectorType() == VectorType::CONSTANT_VECTOR);
-				auto vector = make_unique<Vector>(*child);
-				vector->Normalify(count);
-				new_children.push_back(move(vector));
-			}
-			auxiliary = move(normalified_buffer);
-		} break;
-		default:
-			throw InternalException("Unimplemented type for VectorOperations::Normalify");
-		}
-		break;
-	}
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment;
-		SequenceVector::GetSequence(*this, start, increment);
-
-		buffer = VectorBuffer::CreateStandardVector(GetType());
-		data = buffer->GetData();
-		VectorOperations::GenerateSequence(*this, count, start, increment);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented type for normalify");
-	}
-}
-
-void Vector::Normalify(const SelectionVector &sel, idx_t count) {
-	switch (GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		// already a flat vector
-		break;
-	case VectorType::SEQUENCE_VECTOR: {
-		int64_t start, increment;
-		SequenceVector::GetSequence(*this, start, increment);
-
-		buffer = VectorBuffer::CreateStandardVector(GetType());
-		data = buffer->GetData();
-		VectorOperations::GenerateSequence(*this, count, sel, start, increment);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented type for normalify with selection vector");
-	}
-}
-
-void Vector::Orrify(idx_t count, VectorData &data) {
-	switch (GetVectorType()) {
-	case VectorType::DICTIONARY_VECTOR: {
-		auto &sel = DictionaryVector::SelVector(*this);
-		auto &child = DictionaryVector::Child(*this);
-		if (child.GetVectorType() == VectorType::FLAT_VECTOR) {
-			data.sel = &sel;
-			data.data = FlatVector::GetData(child);
-			data.validity = FlatVector::Validity(child);
-		} else {
-			// dictionary with non-flat child: create a new reference to the child and normalify it
-			Vector child_vector(child);
-			child_vector.Normalify(sel, count);
-			auto new_aux = make_buffer<VectorChildBuffer>(move(child_vector));
-
-			data.sel = &sel;
-			data.data = FlatVector::GetData(new_aux->data);
-			data.validity = FlatVector::Validity(new_aux->data);
-			this->auxiliary = move(new_aux);
-		}
-		break;
-	}
-	case VectorType::CONSTANT_VECTOR:
-		data.sel = ConstantVector::ZeroSelectionVector(count, data.owned_sel);
-		data.data = ConstantVector::GetData(*this);
-		data.validity = ConstantVector::Validity(*this);
-		break;
-	default:
-		Normalify(count);
-		data.sel = FlatVector::IncrementalSelectionVector();
-		data.data = FlatVector::GetData(*this);
-		data.validity = FlatVector::Validity(*this);
-		break;
-	}
-}
-
-void Vector::Sequence(int64_t start, int64_t increment) {
-	this->vector_type = VectorType::SEQUENCE_VECTOR;
-	this->buffer = make_buffer<VectorBuffer>(sizeof(int64_t) * 2);
-	auto data = (int64_t *)buffer->GetData();
-	data[0] = start;
-	data[1] = increment;
-	validity.Reset();
-	auxiliary.reset();
-}
-
-void Vector::Serialize(idx_t count, Serializer &serializer) {
-	auto &type = GetType();
-
-	VectorData vdata;
-	Orrify(count, vdata);
-
-	const auto write_validity = (count > 0) && !vdata.validity.AllValid();
-	serializer.Write<bool>(write_validity);
-	if (write_validity) {
-		ValidityMask flat_mask(count);
-		for (idx_t i = 0; i < count; ++i) {
-			auto row_idx = vdata.sel->get_index(i);
-			flat_mask.Set(i, vdata.validity.RowIsValid(row_idx));
-		}
-		serializer.WriteData((const_data_ptr_t)flat_mask.GetData(), flat_mask.ValidityMaskSize(count));
-	}
-	if (TypeIsConstantSize(type.InternalType())) {
-		// constant size type: simple copy
-		idx_t write_size = GetTypeIdSize(type.InternalType()) * count;
-		auto ptr = unique_ptr<data_t[]>(new data_t[write_size]);
-		VectorOperations::WriteToStorage(*this, count, ptr.get());
-		serializer.WriteData(ptr.get(), write_size);
-	} else {
-		switch (type.InternalType()) {
-		case PhysicalType::VARCHAR: {
-			auto strings = (string_t *)vdata.data;
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = vdata.sel->get_index(i);
-				auto source = !vdata.validity.RowIsValid(idx) ? NullValue<string_t>() : strings[idx];
-				serializer.WriteStringLen((const_data_ptr_t)source.GetDataUnsafe(), source.GetSize());
-			}
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			Normalify(count);
-			auto &entries = StructVector::GetEntries(*this);
-			for (auto &entry : entries) {
-				entry->Serialize(count, serializer);
-			}
-			break;
-		}
-		case PhysicalType::LIST: {
-			auto &child = ListVector::GetEntry(*this);
-			auto list_size = ListVector::GetListSize(*this);
-
-			// serialize the list entries in a flat array
-			auto data = unique_ptr<list_entry_t[]>(new list_entry_t[count]);
-			auto source_array = (list_entry_t *)vdata.data;
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = vdata.sel->get_index(i);
-				auto source = source_array[idx];
-				data[i].offset = source.offset;
-				data[i].length = source.length;
-			}
-
-			// write the list size
-			serializer.Write<idx_t>(list_size);
-			serializer.WriteData((data_ptr_t)data.get(), count * sizeof(list_entry_t));
-
-			child.Serialize(list_size, serializer);
-			break;
-		}
-		default:
-			throw InternalException("Unimplemented variable width type for Vector::Serialize!");
-		}
-	}
-}
-
-void Vector::Deserialize(idx_t count, Deserializer &source) {
-	auto &type = GetType();
-
-	auto &validity = FlatVector::Validity(*this);
-	validity.Reset();
-	const auto has_validity = source.Read<bool>();
-	if (has_validity) {
-		validity.Initialize(count);
-		source.ReadData((data_ptr_t)validity.GetData(), validity.ValidityMaskSize(count));
-	}
-
-	if (TypeIsConstantSize(type.InternalType())) {
-		// constant size type: read fixed amount of data from
-		auto column_size = GetTypeIdSize(type.InternalType()) * count;
-		auto ptr = unique_ptr<data_t[]>(new data_t[column_size]);
-		source.ReadData(ptr.get(), column_size);
-
-		VectorOperations::ReadFromStorage(ptr.get(), count, *this);
-	} else {
-		switch (type.InternalType()) {
-		case PhysicalType::VARCHAR: {
-			auto strings = FlatVector::GetData<string_t>(*this);
-			for (idx_t i = 0; i < count; i++) {
-				// read the strings
-				auto str = source.Read<string>();
-				// now add the string to the StringHeap of the vector
-				// and write the pointer into the vector
-				if (validity.RowIsValid(i)) {
-					strings[i] = StringVector::AddStringOrBlob(*this, str);
-				}
-			}
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			auto &entries = StructVector::GetEntries(*this);
-			for (auto &entry : entries) {
-				entry->Deserialize(count, source);
-			}
-			break;
-		}
-		case PhysicalType::LIST: {
-			// read the list size
-			auto list_size = source.Read<idx_t>();
-			ListVector::Reserve(*this, list_size);
-			ListVector::SetListSize(*this, list_size);
-
-			// read the list entry
-			auto list_entries = FlatVector::GetData(*this);
-			source.ReadData(list_entries, count * sizeof(list_entry_t));
-
-			// deserialize the child vector
-			auto &child = ListVector::GetEntry(*this);
-			child.Deserialize(list_size, source);
-
-			break;
-		}
-		default:
-			throw InternalException("Unimplemented variable width type for Vector::Deserialize!");
-		}
-	}
-}
-
-void Vector::SetVectorType(VectorType vector_type_p) {
-	this->vector_type = vector_type_p;
-	if (TypeIsConstantSize(GetType().InternalType()) &&
-	    (GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR)) {
-		auxiliary.reset();
-	}
-	if (vector_type == VectorType::CONSTANT_VECTOR && GetType().InternalType() == PhysicalType::STRUCT) {
-		auto &entries = StructVector::GetEntries(*this);
-		for (auto &entry : entries) {
-			entry->SetVectorType(vector_type);
-		}
-	}
-}
-
-void Vector::UTFVerify(const SelectionVector &sel, idx_t count) {
-#ifdef DEBUG
-	if (count == 0) {
-		return;
-	}
-	if (GetType().InternalType() == PhysicalType::VARCHAR) {
-		// we just touch all the strings and let the sanitizer figure out if any
-		// of them are deallocated/corrupt
-		switch (GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR: {
-			auto string = ConstantVector::GetData<string_t>(*this);
-			if (!ConstantVector::IsNull(*this)) {
-				string->Verify();
-			}
-			break;
-		}
-		case VectorType::FLAT_VECTOR: {
-			auto strings = FlatVector::GetData<string_t>(*this);
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel.get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					strings[oidx].Verify();
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-#endif
-}
-
-void Vector::UTFVerify(idx_t count) {
-	auto flat_sel = FlatVector::IncrementalSelectionVector();
-
-	UTFVerify(*flat_sel, count);
-}
-
-void Vector::VerifyMap(Vector &vector_p, const SelectionVector &sel_p, idx_t count) {
-#ifdef DEBUG
-	D_ASSERT(vector_p.GetType().id() == LogicalTypeId::MAP);
-	auto valid_check = CheckMapValidity(vector_p, count, sel_p);
-	D_ASSERT(valid_check == MapInvalidReason::VALID);
-#endif // DEBUG
-}
-
-void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count) {
-#ifdef DEBUG
-	if (count == 0) {
-		return;
-	}
-	Vector *vector = &vector_p;
-	const SelectionVector *sel = &sel_p;
-	SelectionVector owned_sel;
-	auto &type = vector->GetType();
-	auto vtype = vector->GetVectorType();
-	if (vector->GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(*vector);
-		D_ASSERT(child.GetVectorType() != VectorType::DICTIONARY_VECTOR);
-		auto &dict_sel = DictionaryVector::SelVector(*vector);
-		// merge the selection vectors and verify the child
-		auto new_buffer = dict_sel.Slice(*sel, count);
-		owned_sel.Initialize(new_buffer);
-		sel = &owned_sel;
-		vector = &child;
-		vtype = vector->GetVectorType();
-	}
-	if (TypeIsConstantSize(type.InternalType()) &&
-	    (vtype == VectorType::CONSTANT_VECTOR || vtype == VectorType::FLAT_VECTOR)) {
-		D_ASSERT(!vector->auxiliary);
-	}
-	if (type.id() == LogicalTypeId::VARCHAR || type.id() == LogicalTypeId::JSON) {
-		// verify that there are no '\0' bytes in string values
-		switch (vtype) {
-		case VectorType::FLAT_VECTOR: {
-			auto &validity = FlatVector::Validity(*vector);
-			auto strings = FlatVector::GetData<string_t>(*vector);
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel->get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					strings[oidx].VerifyNull();
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		auto &child_types = StructType::GetChildTypes(type);
-		D_ASSERT(!child_types.empty());
-		// create a selection vector of the non-null entries of the struct vector
-		auto &children = StructVector::GetEntries(*vector);
-		D_ASSERT(child_types.size() == children.size());
-		for (idx_t child_idx = 0; child_idx < children.size(); child_idx++) {
-			D_ASSERT(children[child_idx]->GetType() == child_types[child_idx].second);
-			Vector::Verify(*children[child_idx], sel_p, count);
-			if (vtype == VectorType::CONSTANT_VECTOR) {
-				D_ASSERT(children[child_idx]->GetVectorType() == VectorType::CONSTANT_VECTOR);
-				if (ConstantVector::IsNull(*vector)) {
-					D_ASSERT(ConstantVector::IsNull(*children[child_idx]));
-				}
-			}
-			if (vtype != VectorType::FLAT_VECTOR) {
-				continue;
-			}
-			ValidityMask *child_validity;
-			SelectionVector owned_child_sel;
-			const SelectionVector *child_sel = &owned_child_sel;
-			if (children[child_idx]->GetVectorType() == VectorType::FLAT_VECTOR) {
-				child_sel = FlatVector::IncrementalSelectionVector();
-				child_validity = &FlatVector::Validity(*children[child_idx]);
-			} else if (children[child_idx]->GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-				auto &child = DictionaryVector::Child(*children[child_idx]);
-				if (child.GetVectorType() != VectorType::FLAT_VECTOR) {
-					continue;
-				}
-				child_validity = &FlatVector::Validity(child);
-				child_sel = &DictionaryVector::SelVector(*children[child_idx]);
-			} else if (children[child_idx]->GetVectorType() == VectorType::CONSTANT_VECTOR) {
-				child_sel = ConstantVector::ZeroSelectionVector(count, owned_child_sel);
-				child_validity = &ConstantVector::Validity(*children[child_idx]);
-			} else {
-				continue;
-			}
-			// for any NULL entry in the struct, the child should be NULL as well
-			auto &validity = FlatVector::Validity(*vector);
-			for (idx_t i = 0; i < count; i++) {
-				auto index = sel->get_index(i);
-				if (!validity.RowIsValid(index)) {
-					auto child_index = child_sel->get_index(sel_p.get_index(i));
-					D_ASSERT(!child_validity->RowIsValid(child_index));
-				}
-			}
-		}
-		if (vector->GetType().id() == LogicalTypeId::MAP) {
-			VerifyMap(*vector, *sel, count);
-		}
-	}
-
-	if (type.InternalType() == PhysicalType::LIST) {
-		if (vtype == VectorType::CONSTANT_VECTOR) {
-			if (!ConstantVector::IsNull(*vector)) {
-				auto &child = ListVector::GetEntry(*vector);
-				SelectionVector child_sel(ListVector::GetListSize(*vector));
-				idx_t child_count = 0;
-				auto le = ConstantVector::GetData<list_entry_t>(*vector);
-				D_ASSERT(le->offset + le->length <= ListVector::GetListSize(*vector));
-				for (idx_t k = 0; k < le->length; k++) {
-					child_sel.set_index(child_count++, le->offset + k);
-				}
-				Vector::Verify(child, child_sel, child_count);
-			}
-		} else if (vtype == VectorType::FLAT_VECTOR) {
-			auto &validity = FlatVector::Validity(*vector);
-			auto &child = ListVector::GetEntry(*vector);
-			auto child_size = ListVector::GetListSize(*vector);
-			auto list_data = FlatVector::GetData<list_entry_t>(*vector);
-			idx_t total_size = 0;
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel->get_index(i);
-				auto &le = list_data[idx];
-				if (validity.RowIsValid(idx)) {
-					D_ASSERT(le.offset + le.length <= child_size);
-					total_size += le.length;
-				}
-			}
-			SelectionVector child_sel(total_size);
-			idx_t child_count = 0;
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel->get_index(i);
-				auto &le = list_data[idx];
-				if (validity.RowIsValid(idx)) {
-					D_ASSERT(le.offset + le.length <= child_size);
-					for (idx_t k = 0; k < le.length; k++) {
-						child_sel.set_index(child_count++, le.offset + k);
-					}
-				}
-			}
-			Vector::Verify(child, child_sel, child_count);
-		}
-	}
-#endif
-}
-
-void Vector::Verify(idx_t count) {
-	auto flat_sel = FlatVector::IncrementalSelectionVector();
-	Verify(*this, *flat_sel, count);
-}
-
-void FlatVector::SetNull(Vector &vector, idx_t idx, bool is_null) {
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-	vector.validity.Set(idx, !is_null);
-	if (is_null && vector.GetType().InternalType() == PhysicalType::STRUCT) {
-		// set all child entries to null as well
-		auto &entries = StructVector::GetEntries(vector);
-		for (auto &entry : entries) {
-			FlatVector::SetNull(*entry, idx, is_null);
-		}
-	}
-}
-
-void ConstantVector::SetNull(Vector &vector, bool is_null) {
-	D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	vector.validity.Set(0, !is_null);
-	if (is_null && vector.GetType().InternalType() == PhysicalType::STRUCT) {
-		// set all child entries to null as well
-		auto &entries = StructVector::GetEntries(vector);
-		for (auto &entry : entries) {
-			entry->SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(*entry, is_null);
-		}
-	}
-}
-
-const SelectionVector *ConstantVector::ZeroSelectionVector(idx_t count, SelectionVector &owned_sel) {
-	if (count <= STANDARD_VECTOR_SIZE) {
-		return ConstantVector::ZeroSelectionVector();
-	}
-	owned_sel.Initialize(count);
-	for (idx_t i = 0; i < count; i++) {
-		owned_sel.set_index(i, 0);
-	}
-	return &owned_sel;
-}
-
-void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, idx_t count) {
-	auto &source_type = source.GetType();
-	switch (source_type.InternalType()) {
-	case PhysicalType::LIST: {
-		// retrieve the list entry from the source vector
-		VectorData vdata;
-		source.Orrify(count, vdata);
-
-		auto list_index = vdata.sel->get_index(position);
-		if (!vdata.validity.RowIsValid(list_index)) {
-			// list is null: create null value
-			Value null_value(source_type);
-			vector.Reference(null_value);
-			break;
-		}
-
-		auto list_data = (list_entry_t *)vdata.data;
-		auto list_entry = list_data[list_index];
-
-		// add the list entry as the first element of "vector"
-		// FIXME: we only need to allocate space for 1 tuple here
-		auto target_data = FlatVector::GetData<list_entry_t>(vector);
-		target_data[0] = list_entry;
-
-		// create a reference to the child list of the source vector
-		auto &child = ListVector::GetEntry(vector);
-		child.Reference(ListVector::GetEntry(source));
-
-		ListVector::SetListSize(vector, ListVector::GetListSize(source));
-		vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		VectorData vdata;
-		source.Orrify(count, vdata);
-
-		auto struct_index = vdata.sel->get_index(position);
-		if (!vdata.validity.RowIsValid(struct_index)) {
-			// null struct: create null value
-			Value null_value(source_type);
-			vector.Reference(null_value);
-			break;
-		}
-
-		// struct: pass constant reference into child entries
-		auto &source_entries = StructVector::GetEntries(source);
-		auto &target_entries = StructVector::GetEntries(vector);
-		for (idx_t i = 0; i < source_entries.size(); i++) {
-			ConstantVector::Reference(*target_entries[i], *source_entries[i], position, count);
-		}
-		vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		break;
-	}
-	default:
-		// default behavior: get a value from the vector and reference it
-		// this is not that expensive for scalar types
-		auto value = source.GetValue(position);
-		vector.Reference(value);
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-		break;
-	}
-}
-
-string_t StringVector::AddString(Vector &vector, const char *data, idx_t len) {
-	return StringVector::AddString(vector, string_t(data, len));
-}
-
-string_t StringVector::AddStringOrBlob(Vector &vector, const char *data, idx_t len) {
-	return StringVector::AddStringOrBlob(vector, string_t(data, len));
-}
-
-string_t StringVector::AddString(Vector &vector, const char *data) {
-	return StringVector::AddString(vector, string_t(data, strlen(data)));
-}
-
-string_t StringVector::AddString(Vector &vector, const string &data) {
-	return StringVector::AddString(vector, string_t(data.c_str(), data.size()));
-}
-
-string_t StringVector::AddString(Vector &vector, string_t data) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::VARCHAR || vector.GetType().id() == LogicalTypeId::JSON);
-	if (data.IsInlined()) {
-		// string will be inlined: no need to store in string heap
-		return data;
-	}
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = (VectorStringBuffer &)*vector.auxiliary;
-	return string_buffer.AddString(data);
-}
-
-string_t StringVector::AddStringOrBlob(Vector &vector, string_t data) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (data.IsInlined()) {
-		// string will be inlined: no need to store in string heap
-		return data;
-	}
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = (VectorStringBuffer &)*vector.auxiliary;
-	return string_buffer.AddBlob(data);
-}
-
-string_t StringVector::EmptyString(Vector &vector, idx_t len) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (len < string_t::INLINE_LENGTH) {
-		return string_t(len);
-	}
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRING_BUFFER);
-	auto &string_buffer = (VectorStringBuffer &)*vector.auxiliary;
-	return string_buffer.EmptyString(len);
-}
-
-void StringVector::AddHandle(Vector &vector, BufferHandle handle) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	auto &string_buffer = (VectorStringBuffer &)*vector.auxiliary;
-	string_buffer.AddHeapReference(make_buffer<ManagedVectorBuffer>(move(handle)));
-}
-
-void StringVector::AddBuffer(Vector &vector, buffer_ptr<VectorBuffer> buffer) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	D_ASSERT(buffer.get() != vector.auxiliary.get());
-	if (!vector.auxiliary) {
-		vector.auxiliary = make_buffer<VectorStringBuffer>();
-	}
-	auto &string_buffer = (VectorStringBuffer &)*vector.auxiliary;
-	string_buffer.AddHeapReference(move(buffer));
-}
-
-void StringVector::AddHeapReference(Vector &vector, Vector &other) {
-	D_ASSERT(vector.GetType().InternalType() == PhysicalType::VARCHAR);
-	D_ASSERT(other.GetType().InternalType() == PhysicalType::VARCHAR);
-
-	if (other.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		StringVector::AddHeapReference(vector, DictionaryVector::Child(other));
-		return;
-	}
-	if (!other.auxiliary) {
-		return;
-	}
-	StringVector::AddBuffer(vector, other.auxiliary);
-}
-
-vector<unique_ptr<Vector>> &StructVector::GetEntries(Vector &vector) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::STRUCT || vector.GetType().id() == LogicalTypeId::MAP);
-	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vector);
-		return StructVector::GetEntries(child);
-	}
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(vector.auxiliary);
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::STRUCT_BUFFER);
-	return ((VectorStructBuffer *)vector.auxiliary.get())->GetChildren();
-}
-
-const vector<unique_ptr<Vector>> &StructVector::GetEntries(const Vector &vector) {
-	return GetEntries((Vector &)vector);
-}
-
-const Vector &ListVector::GetEntry(const Vector &vector) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST);
-	if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vector);
-		return ListVector::GetEntry(child);
-	}
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(vector.auxiliary);
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::LIST_BUFFER);
-	return ((VectorListBuffer *)vector.auxiliary.get())->GetChild();
-}
-
-Vector &ListVector::GetEntry(Vector &vector) {
-	const Vector &cvector = vector;
-	return const_cast<Vector &>(ListVector::GetEntry(cvector));
-}
-
-void ListVector::Reserve(Vector &vector, idx_t required_capacity) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST);
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(vector.auxiliary);
-	D_ASSERT(vector.auxiliary->GetBufferType() == VectorBufferType::LIST_BUFFER);
-	auto &child_buffer = *((VectorListBuffer *)vector.auxiliary.get());
-	child_buffer.Reserve(required_capacity);
-}
-
-template <class T>
-void TemplatedSearchInMap(Vector &list, T key, vector<idx_t> &offsets, bool is_key_null, idx_t offset, idx_t length) {
-	auto &list_vector = ListVector::GetEntry(list);
-	VectorData vector_data;
-	list_vector.Orrify(ListVector::GetListSize(list), vector_data);
-	auto data = (T *)vector_data.data;
-	auto validity_mask = vector_data.validity;
-
-	if (is_key_null) {
-		for (idx_t i = offset; i < offset + length; i++) {
-			if (!validity_mask.RowIsValid(i)) {
-				offsets.push_back(i);
-			}
-		}
-	} else {
-		for (idx_t i = offset; i < offset + length; i++) {
-			if (!validity_mask.RowIsValid(i)) {
-				continue;
-			}
-			if (key == data[i]) {
-				offsets.push_back(i);
-			}
-		}
-	}
-}
-
-template <class T>
-void TemplatedSearchInMap(Vector &list, const Value &key, vector<idx_t> &offsets, bool is_key_null, idx_t offset,
-                          idx_t length) {
-	TemplatedSearchInMap<T>(list, key.template GetValueUnsafe<T>(), offsets, is_key_null, offset, length);
-}
-
-void SearchStringInMap(Vector &list, const string &key, vector<idx_t> &offsets, bool is_key_null, idx_t offset,
-                       idx_t length) {
-	auto &list_vector = ListVector::GetEntry(list);
-	VectorData vector_data;
-	list_vector.Orrify(ListVector::GetListSize(list), vector_data);
-	auto data = (string_t *)vector_data.data;
-	auto validity_mask = vector_data.validity;
-	if (is_key_null) {
-		for (idx_t i = offset; i < offset + length; i++) {
-			if (!validity_mask.RowIsValid(i)) {
-				offsets.push_back(i);
-			}
-		}
-	} else {
-		string_t key_str_t(key);
-		for (idx_t i = offset; i < offset + length; i++) {
-			if (!validity_mask.RowIsValid(i)) {
-				continue;
-			}
-			if (Equals::Operation<string_t>(data[i], key_str_t)) {
-				offsets.push_back(i);
-			}
-		}
-	}
-}
-
-vector<idx_t> ListVector::Search(Vector &list, const Value &key, idx_t row) {
-	vector<idx_t> offsets;
-
-	auto &list_vector = ListVector::GetEntry(list);
-	auto &entry = ((list_entry_t *)list.GetData())[row];
-
-	switch (list_vector.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedSearchInMap<int8_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::INT16:
-		TemplatedSearchInMap<int16_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::INT32:
-		TemplatedSearchInMap<int32_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::INT64:
-		TemplatedSearchInMap<int64_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::INT128:
-		TemplatedSearchInMap<hugeint_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedSearchInMap<uint8_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedSearchInMap<uint16_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedSearchInMap<uint32_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedSearchInMap<uint64_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedSearchInMap<float>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedSearchInMap<double>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	case PhysicalType::VARCHAR:
-		SearchStringInMap(list, StringValue::Get(key), offsets, key.IsNull(), entry.offset, entry.length);
-		break;
-	default:
-		throw InvalidTypeException(list.GetType().id(), "Invalid type for List Vector Search");
-	}
-	return offsets;
-}
-
-Value ListVector::GetValuesFromOffsets(Vector &list, vector<idx_t> &offsets) {
-	auto &child_vec = ListVector::GetEntry(list);
-	vector<Value> list_values;
-	list_values.reserve(offsets.size());
-	for (auto &offset : offsets) {
-		list_values.push_back(child_vec.GetValue(offset));
-	}
-	return Value::LIST(ListType::GetChildType(list.GetType()), move(list_values));
-}
-
-idx_t ListVector::GetListSize(const Vector &vec) {
-	if (vec.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vec);
-		return ListVector::GetListSize(child);
-	}
-	D_ASSERT(vec.auxiliary);
-	return ((VectorListBuffer &)*vec.auxiliary).size;
-}
-
-void ListVector::ReferenceEntry(Vector &vector, Vector &other) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST);
-	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
-	         vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	D_ASSERT(other.GetType().id() == LogicalTypeId::LIST);
-	D_ASSERT(other.GetVectorType() == VectorType::FLAT_VECTOR || other.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	vector.auxiliary = other.auxiliary;
-}
-
-void ListVector::SetListSize(Vector &vec, idx_t size) {
-	if (vec.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-		auto &child = DictionaryVector::Child(vec);
-		ListVector::SetListSize(child, size);
-	}
-	((VectorListBuffer &)*vec.auxiliary).size = size;
-}
-
-void ListVector::Append(Vector &target, const Vector &source, idx_t source_size, idx_t source_offset) {
-	if (source_size - source_offset == 0) {
-		//! Nothing to add
-		return;
-	}
-	auto &target_buffer = (VectorListBuffer &)*target.auxiliary;
-	target_buffer.Append(source, source_size, source_offset);
-}
-
-void ListVector::Append(Vector &target, const Vector &source, const SelectionVector &sel, idx_t source_size,
-                        idx_t source_offset) {
-	if (source_size - source_offset == 0) {
-		//! Nothing to add
-		return;
-	}
-	auto &target_buffer = (VectorListBuffer &)*target.auxiliary;
-	target_buffer.Append(source, sel, source_size, source_offset);
-}
-
-void ListVector::PushBack(Vector &target, const Value &insert) {
-	auto &target_buffer = (VectorListBuffer &)*target.auxiliary;
-	target_buffer.PushBack(insert);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-buffer_ptr<VectorBuffer> VectorBuffer::CreateStandardVector(PhysicalType type, idx_t capacity) {
-	return make_buffer<VectorBuffer>(capacity * GetTypeIdSize(type));
-}
-
-buffer_ptr<VectorBuffer> VectorBuffer::CreateConstantVector(PhysicalType type) {
-	return make_buffer<VectorBuffer>(GetTypeIdSize(type));
-}
-
-buffer_ptr<VectorBuffer> VectorBuffer::CreateConstantVector(const LogicalType &type) {
-	return VectorBuffer::CreateConstantVector(type.InternalType());
-}
-
-buffer_ptr<VectorBuffer> VectorBuffer::CreateStandardVector(const LogicalType &type, idx_t capacity) {
-	return VectorBuffer::CreateStandardVector(type.InternalType(), capacity);
-}
-
-VectorStringBuffer::VectorStringBuffer() : VectorBuffer(VectorBufferType::STRING_BUFFER) {
-}
-
-VectorStructBuffer::VectorStructBuffer() : VectorBuffer(VectorBufferType::STRUCT_BUFFER) {
-}
-
-VectorStructBuffer::VectorStructBuffer(const LogicalType &type, idx_t capacity)
-    : VectorBuffer(VectorBufferType::STRUCT_BUFFER) {
-	auto &child_types = StructType::GetChildTypes(type);
-	for (auto &child_type : child_types) {
-		auto vector = make_unique<Vector>(child_type.second, capacity);
-		children.push_back(move(vector));
-	}
-}
-
-VectorStructBuffer::VectorStructBuffer(Vector &other, const SelectionVector &sel, idx_t count)
-    : VectorBuffer(VectorBufferType::STRUCT_BUFFER) {
-	auto &other_vector = StructVector::GetEntries(other);
-	for (auto &child_vector : other_vector) {
-		auto vector = make_unique<Vector>(*child_vector, sel, count);
-		children.push_back(move(vector));
-	}
-}
-
-VectorStructBuffer::~VectorStructBuffer() {
-}
-
-VectorListBuffer::VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER), capacity(initial_capacity), child(move(vector)) {
-}
-
-VectorListBuffer::VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER), capacity(initial_capacity),
-      child(make_unique<Vector>(ListType::GetChildType(list_type), initial_capacity)) {
-}
-
-void VectorListBuffer::Reserve(idx_t to_reserve) {
-	if (to_reserve > capacity) {
-		idx_t new_capacity = NextPowerOfTwo(to_reserve);
-		D_ASSERT(new_capacity >= to_reserve);
-		child->Resize(capacity, new_capacity);
-		capacity = new_capacity;
-	}
-}
-
-void VectorListBuffer::Append(const Vector &to_append, idx_t to_append_size, idx_t source_offset) {
-	Reserve(size + to_append_size - source_offset);
-	VectorOperations::Copy(to_append, *child, to_append_size, source_offset, size);
-	size += to_append_size - source_offset;
-}
-
-void VectorListBuffer::Append(const Vector &to_append, const SelectionVector &sel, idx_t to_append_size,
-                              idx_t source_offset) {
-	Reserve(size + to_append_size - source_offset);
-	VectorOperations::Copy(to_append, *child, sel, to_append_size, source_offset, size);
-	size += to_append_size - source_offset;
-}
-
-void VectorListBuffer::PushBack(const Value &insert) {
-	if (size + 1 > capacity) {
-		child->Resize(capacity, capacity * 2);
-		capacity *= 2;
-	}
-	child->SetValue(size++, insert);
-}
-
-VectorListBuffer::~VectorListBuffer() {
-}
-
-ManagedVectorBuffer::ManagedVectorBuffer(BufferHandle handle)
-    : VectorBuffer(VectorBufferType::MANAGED_BUFFER), handle(move(handle)) {
-}
-
-ManagedVectorBuffer::~ManagedVectorBuffer() {
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-class VectorCacheBuffer : public VectorBuffer {
-public:
-	explicit VectorCacheBuffer(Allocator &allocator, const LogicalType &type_p)
-	    : VectorBuffer(VectorBufferType::OPAQUE_BUFFER), type(type_p) {
-		auto internal_type = type.InternalType();
-		switch (internal_type) {
-		case PhysicalType::LIST: {
-			// memory for the list offsets
-			owned_data = allocator.Allocate(STANDARD_VECTOR_SIZE * GetTypeIdSize(internal_type));
-			// child data of the list
-			auto &child_type = ListType::GetChildType(type);
-			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type));
-			auto child_vector = make_unique<Vector>(child_type, false, false);
-			auxiliary = make_unique<VectorListBuffer>(move(child_vector));
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			auto &child_types = StructType::GetChildTypes(type);
-			for (auto &child_type : child_types) {
-				child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type.second));
-			}
-			auto struct_buffer = make_unique<VectorStructBuffer>(type);
-			auxiliary = move(struct_buffer);
-			break;
-		}
-		default:
-			owned_data = allocator.Allocate(STANDARD_VECTOR_SIZE * GetTypeIdSize(internal_type));
-			break;
-		}
-	}
-
-	void ResetFromCache(Vector &result, const buffer_ptr<VectorBuffer> &buffer) {
-		D_ASSERT(type == result.GetType());
-		auto internal_type = type.InternalType();
-		result.vector_type = VectorType::FLAT_VECTOR;
-		AssignSharedPointer(result.buffer, buffer);
-		result.validity.Reset();
-		switch (internal_type) {
-		case PhysicalType::LIST: {
-			result.data = owned_data->get();
-			// reinitialize the VectorListBuffer
-			AssignSharedPointer(result.auxiliary, auxiliary);
-			// propagate through child
-			auto &list_buffer = (VectorListBuffer &)*result.auxiliary;
-			list_buffer.capacity = STANDARD_VECTOR_SIZE;
-			list_buffer.size = 0;
-
-			auto &list_child = list_buffer.GetChild();
-			auto &child_cache = (VectorCacheBuffer &)*child_caches[0];
-			child_cache.ResetFromCache(list_child, child_caches[0]);
-			break;
-		}
-		case PhysicalType::STRUCT: {
-			// struct does not have data
-			result.data = nullptr;
-			// reinitialize the VectorStructBuffer
-			AssignSharedPointer(result.auxiliary, auxiliary);
-			// propagate through children
-			auto &children = ((VectorStructBuffer &)*result.auxiliary).GetChildren();
-			for (idx_t i = 0; i < children.size(); i++) {
-				auto &child_cache = (VectorCacheBuffer &)*child_caches[i];
-				child_cache.ResetFromCache(*children[i], child_caches[i]);
-			}
-			break;
-		}
-		default:
-			// regular type: no aux data and reset data to cached data
-			result.data = owned_data->get();
-			result.auxiliary.reset();
-			break;
-		}
-	}
-
-	const LogicalType &GetType() {
-		return type;
-	}
-
-private:
-	//! The type of the vector cache
-	LogicalType type;
-	//! Owned data
-	unique_ptr<AllocatedData> owned_data;
-	//! Child caches (if any). Used for nested types.
-	vector<buffer_ptr<VectorBuffer>> child_caches;
-	//! Aux data for the vector (if any)
-	buffer_ptr<VectorBuffer> auxiliary;
-};
-
-VectorCache::VectorCache(Allocator &allocator, const LogicalType &type_p) {
-	buffer = make_unique<VectorCacheBuffer>(allocator, type_p);
-}
-
-void VectorCache::ResetFromCache(Vector &result) const {
-	D_ASSERT(buffer);
-	auto &vcache = (VectorCacheBuffer &)*buffer;
-	vcache.ResetFromCache(result, buffer);
-}
-
-const LogicalType &VectorCache::GetType() const {
-	auto &vcache = (VectorCacheBuffer &)*buffer;
-	return vcache.GetType();
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-const SelectionVector *ConstantVector::ZeroSelectionVector() {
-	static const SelectionVector ZERO_SELECTION_VECTOR = SelectionVector((sel_t *)ConstantVector::ZERO_VECTOR);
-	return &ZERO_SELECTION_VECTOR;
-}
-
-const SelectionVector *FlatVector::IncrementalSelectionVector() {
-	static const SelectionVector INCREMENTAL_SELECTION_VECTOR;
-	return &INCREMENTAL_SELECTION_VECTOR;
-}
-
-const sel_t ConstantVector::ZERO_VECTOR[STANDARD_VECTOR_SIZE] = {0};
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cmath>
-
-namespace duckdb {
-
-LogicalType::LogicalType() : LogicalType(LogicalTypeId::INVALID) {
-}
-
-LogicalType::LogicalType(LogicalTypeId id) : id_(id) {
-	physical_type_ = GetInternalType();
-}
-LogicalType::LogicalType(LogicalTypeId id, shared_ptr<ExtraTypeInfo> type_info_p)
-    : id_(id), type_info_(move(type_info_p)) {
-	physical_type_ = GetInternalType();
-}
-
-LogicalType::LogicalType(const LogicalType &other)
-    : id_(other.id_), physical_type_(other.physical_type_), type_info_(other.type_info_) {
-}
-
-LogicalType::LogicalType(LogicalType &&other) noexcept
-    : id_(other.id_), physical_type_(other.physical_type_), type_info_(move(other.type_info_)) {
-}
-
-hash_t LogicalType::Hash() const {
-	return duckdb::Hash<uint8_t>((uint8_t)id_);
-}
-
-PhysicalType LogicalType::GetInternalType() {
-	switch (id_) {
-	case LogicalTypeId::BOOLEAN:
-		return PhysicalType::BOOL;
-	case LogicalTypeId::TINYINT:
-		return PhysicalType::INT8;
-	case LogicalTypeId::UTINYINT:
-		return PhysicalType::UINT8;
-	case LogicalTypeId::SMALLINT:
-		return PhysicalType::INT16;
-	case LogicalTypeId::USMALLINT:
-		return PhysicalType::UINT16;
-	case LogicalTypeId::SQLNULL:
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::INTEGER:
-		return PhysicalType::INT32;
-	case LogicalTypeId::UINTEGER:
-		return PhysicalType::UINT32;
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return PhysicalType::INT64;
-	case LogicalTypeId::UBIGINT:
-		return PhysicalType::UINT64;
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UUID:
-		return PhysicalType::INT128;
-	case LogicalTypeId::FLOAT:
-		return PhysicalType::FLOAT;
-	case LogicalTypeId::DOUBLE:
-		return PhysicalType::DOUBLE;
-	case LogicalTypeId::DECIMAL: {
-		if (!type_info_) {
-			return PhysicalType::INVALID;
-		}
-		auto width = DecimalType::GetWidth(*this);
-		if (width <= Decimal::MAX_WIDTH_INT16) {
-			return PhysicalType::INT16;
-		} else if (width <= Decimal::MAX_WIDTH_INT32) {
-			return PhysicalType::INT32;
-		} else if (width <= Decimal::MAX_WIDTH_INT64) {
-			return PhysicalType::INT64;
-		} else if (width <= Decimal::MAX_WIDTH_INT128) {
-			return PhysicalType::INT128;
-		} else {
-			throw InternalException("Widths bigger than %d are not supported", DecimalType::MaxWidth());
-		}
-	}
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::CHAR:
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::JSON:
-		return PhysicalType::VARCHAR;
-	case LogicalTypeId::INTERVAL:
-		return PhysicalType::INTERVAL;
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::STRUCT:
-		return PhysicalType::STRUCT;
-	case LogicalTypeId::LIST:
-		return PhysicalType::LIST;
-	case LogicalTypeId::POINTER:
-		// LCOV_EXCL_START
-		if (sizeof(uintptr_t) == sizeof(uint32_t)) {
-			return PhysicalType::UINT32;
-		} else if (sizeof(uintptr_t) == sizeof(uint64_t)) {
-			return PhysicalType::UINT64;
-		} else {
-			throw InternalException("Unsupported pointer size");
-		}
-		// LCOV_EXCL_STOP
-	case LogicalTypeId::VALIDITY:
-		return PhysicalType::BIT;
-	case LogicalTypeId::ENUM: {
-		D_ASSERT(type_info_);
-		return EnumType::GetPhysicalType(*this);
-	}
-	case LogicalTypeId::TABLE:
-	case LogicalTypeId::ANY:
-	case LogicalTypeId::INVALID:
-	case LogicalTypeId::UNKNOWN:
-		return PhysicalType::INVALID;
-	case LogicalTypeId::USER:
-		return PhysicalType::UNKNOWN;
-	case LogicalTypeId::AGGREGATE_STATE:
-		return PhysicalType::VARCHAR;
-	default:
-		throw InternalException("Invalid LogicalType %s", ToString());
-	}
-}
-
-constexpr const LogicalTypeId LogicalType::INVALID;
-constexpr const LogicalTypeId LogicalType::SQLNULL;
-constexpr const LogicalTypeId LogicalType::BOOLEAN;
-constexpr const LogicalTypeId LogicalType::TINYINT;
-constexpr const LogicalTypeId LogicalType::UTINYINT;
-constexpr const LogicalTypeId LogicalType::SMALLINT;
-constexpr const LogicalTypeId LogicalType::USMALLINT;
-constexpr const LogicalTypeId LogicalType::INTEGER;
-constexpr const LogicalTypeId LogicalType::UINTEGER;
-constexpr const LogicalTypeId LogicalType::BIGINT;
-constexpr const LogicalTypeId LogicalType::UBIGINT;
-constexpr const LogicalTypeId LogicalType::HUGEINT;
-constexpr const LogicalTypeId LogicalType::UUID;
-constexpr const LogicalTypeId LogicalType::FLOAT;
-constexpr const LogicalTypeId LogicalType::DOUBLE;
-constexpr const LogicalTypeId LogicalType::DATE;
-
-constexpr const LogicalTypeId LogicalType::TIMESTAMP;
-constexpr const LogicalTypeId LogicalType::TIMESTAMP_MS;
-constexpr const LogicalTypeId LogicalType::TIMESTAMP_NS;
-constexpr const LogicalTypeId LogicalType::TIMESTAMP_S;
-
-constexpr const LogicalTypeId LogicalType::TIME;
-
-constexpr const LogicalTypeId LogicalType::TIME_TZ;
-constexpr const LogicalTypeId LogicalType::TIMESTAMP_TZ;
-
-constexpr const LogicalTypeId LogicalType::HASH;
-constexpr const LogicalTypeId LogicalType::POINTER;
-
-constexpr const LogicalTypeId LogicalType::VARCHAR;
-constexpr const LogicalTypeId LogicalType::JSON;
-
-constexpr const LogicalTypeId LogicalType::BLOB;
-constexpr const LogicalTypeId LogicalType::INTERVAL;
-constexpr const LogicalTypeId LogicalType::ROW_TYPE;
-
-// TODO these are incomplete and should maybe not exist as such
-constexpr const LogicalTypeId LogicalType::TABLE;
-
-constexpr const LogicalTypeId LogicalType::ANY;
-
-const vector<LogicalType> LogicalType::Numeric() {
-	vector<LogicalType> types = {LogicalType::TINYINT,   LogicalType::SMALLINT,  LogicalType::INTEGER,
-	                             LogicalType::BIGINT,    LogicalType::HUGEINT,   LogicalType::FLOAT,
-	                             LogicalType::DOUBLE,    LogicalTypeId::DECIMAL, LogicalType::UTINYINT,
-	                             LogicalType::USMALLINT, LogicalType::UINTEGER,  LogicalType::UBIGINT};
-	return types;
-}
-
-const vector<LogicalType> LogicalType::Integral() {
-	vector<LogicalType> types = {LogicalType::TINYINT,   LogicalType::SMALLINT, LogicalType::INTEGER,
-	                             LogicalType::BIGINT,    LogicalType::HUGEINT,  LogicalType::UTINYINT,
-	                             LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT};
-	return types;
-}
-
-const vector<LogicalType> LogicalType::AllTypes() {
-	vector<LogicalType> types = {
-	    LogicalType::BOOLEAN,  LogicalType::TINYINT,   LogicalType::SMALLINT,     LogicalType::INTEGER,
-	    LogicalType::BIGINT,   LogicalType::DATE,      LogicalType::TIMESTAMP,    LogicalType::DOUBLE,
-	    LogicalType::FLOAT,    LogicalType::VARCHAR,   LogicalType::BLOB,         LogicalType::INTERVAL,
-	    LogicalType::HUGEINT,  LogicalTypeId::DECIMAL, LogicalType::UTINYINT,     LogicalType::USMALLINT,
-	    LogicalType::UINTEGER, LogicalType::UBIGINT,   LogicalType::TIME,         LogicalTypeId::LIST,
-	    LogicalTypeId::STRUCT, LogicalType::TIME_TZ,   LogicalType::TIMESTAMP_TZ, LogicalTypeId::MAP,
-	    LogicalType::UUID,     LogicalType::JSON};
-	return types;
-}
-
-const PhysicalType ROW_TYPE = PhysicalType::INT64;
-
-// LCOV_EXCL_START
-string TypeIdToString(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-		return "BOOL";
-	case PhysicalType::INT8:
-		return "INT8";
-	case PhysicalType::INT16:
-		return "INT16";
-	case PhysicalType::INT32:
-		return "INT32";
-	case PhysicalType::INT64:
-		return "INT64";
-	case PhysicalType::UINT8:
-		return "UINT8";
-	case PhysicalType::UINT16:
-		return "UINT16";
-	case PhysicalType::UINT32:
-		return "UINT32";
-	case PhysicalType::UINT64:
-		return "UINT64";
-	case PhysicalType::INT128:
-		return "INT128";
-	case PhysicalType::FLOAT:
-		return "FLOAT";
-	case PhysicalType::DOUBLE:
-		return "DOUBLE";
-	case PhysicalType::VARCHAR:
-		return "VARCHAR";
-	case PhysicalType::INTERVAL:
-		return "INTERVAL";
-	case PhysicalType::STRUCT:
-		return "STRUCT";
-	case PhysicalType::LIST:
-		return "LIST";
-	case PhysicalType::INVALID:
-		return "INVALID";
-	case PhysicalType::BIT:
-		return "BIT";
-	case PhysicalType::NA:
-		return "NA";
-	case PhysicalType::HALF_FLOAT:
-		return "HALF_FLOAT";
-	case PhysicalType::STRING:
-		return "ARROW_STRING";
-	case PhysicalType::BINARY:
-		return "BINARY";
-	case PhysicalType::FIXED_SIZE_BINARY:
-		return "FIXED_SIZE_BINARY";
-	case PhysicalType::DATE32:
-		return "DATE32";
-	case PhysicalType::DATE64:
-		return "DATE64";
-	case PhysicalType::TIMESTAMP:
-		return "TIMESTAMP";
-	case PhysicalType::TIME32:
-		return "TIME32";
-	case PhysicalType::TIME64:
-		return "TIME64";
-	case PhysicalType::UNION:
-		return "UNION";
-	case PhysicalType::DICTIONARY:
-		return "DICTIONARY";
-	case PhysicalType::MAP:
-		return "MAP";
-	case PhysicalType::EXTENSION:
-		return "EXTENSION";
-	case PhysicalType::FIXED_SIZE_LIST:
-		return "FIXED_SIZE_LIST";
-	case PhysicalType::DURATION:
-		return "DURATION";
-	case PhysicalType::LARGE_STRING:
-		return "LARGE_STRING";
-	case PhysicalType::LARGE_BINARY:
-		return "LARGE_BINARY";
-	case PhysicalType::LARGE_LIST:
-		return "LARGE_LIST";
-	case PhysicalType::UNKNOWN:
-		return "UNKNOWN";
-	}
-	return "INVALID";
-}
-// LCOV_EXCL_STOP
-
-idx_t GetTypeIdSize(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-	case PhysicalType::BOOL:
-		return sizeof(bool);
-	case PhysicalType::INT8:
-		return sizeof(int8_t);
-	case PhysicalType::INT16:
-		return sizeof(int16_t);
-	case PhysicalType::INT32:
-		return sizeof(int32_t);
-	case PhysicalType::INT64:
-		return sizeof(int64_t);
-	case PhysicalType::UINT8:
-		return sizeof(uint8_t);
-	case PhysicalType::UINT16:
-		return sizeof(uint16_t);
-	case PhysicalType::UINT32:
-		return sizeof(uint32_t);
-	case PhysicalType::UINT64:
-		return sizeof(uint64_t);
-	case PhysicalType::INT128:
-		return sizeof(hugeint_t);
-	case PhysicalType::FLOAT:
-		return sizeof(float);
-	case PhysicalType::DOUBLE:
-		return sizeof(double);
-	case PhysicalType::VARCHAR:
-		return sizeof(string_t);
-	case PhysicalType::INTERVAL:
-		return sizeof(interval_t);
-	case PhysicalType::STRUCT:
-	case PhysicalType::UNKNOWN:
-		return 0; // no own payload
-	case PhysicalType::LIST:
-		return sizeof(list_entry_t); // offset + len
-	default:
-		throw InternalException("Invalid PhysicalType for GetTypeIdSize");
-	}
-}
-
-bool TypeIsConstantSize(PhysicalType type) {
-	return (type >= PhysicalType::BOOL && type <= PhysicalType::DOUBLE) ||
-	       (type >= PhysicalType::FIXED_SIZE_BINARY && type <= PhysicalType::INTERVAL) ||
-	       type == PhysicalType::INTERVAL || type == PhysicalType::INT128;
-}
-bool TypeIsIntegral(PhysicalType type) {
-	return (type >= PhysicalType::UINT8 && type <= PhysicalType::INT64) || type == PhysicalType::INT128;
-}
-bool TypeIsNumeric(PhysicalType type) {
-	return (type >= PhysicalType::UINT8 && type <= PhysicalType::DOUBLE) || type == PhysicalType::INT128;
-}
-bool TypeIsInteger(PhysicalType type) {
-	return (type >= PhysicalType::UINT8 && type <= PhysicalType::INT64) || type == PhysicalType::INT128;
-}
-
-// LCOV_EXCL_START
-string LogicalTypeIdToString(LogicalTypeId id) {
-	switch (id) {
-	case LogicalTypeId::BOOLEAN:
-		return "BOOLEAN";
-	case LogicalTypeId::TINYINT:
-		return "TINYINT";
-	case LogicalTypeId::SMALLINT:
-		return "SMALLINT";
-	case LogicalTypeId::INTEGER:
-		return "INTEGER";
-	case LogicalTypeId::BIGINT:
-		return "BIGINT";
-	case LogicalTypeId::HUGEINT:
-		return "HUGEINT";
-	case LogicalTypeId::UUID:
-		return "UUID";
-	case LogicalTypeId::UTINYINT:
-		return "UTINYINT";
-	case LogicalTypeId::USMALLINT:
-		return "USMALLINT";
-	case LogicalTypeId::UINTEGER:
-		return "UINTEGER";
-	case LogicalTypeId::UBIGINT:
-		return "UBIGINT";
-	case LogicalTypeId::DATE:
-		return "DATE";
-	case LogicalTypeId::TIME:
-		return "TIME";
-	case LogicalTypeId::TIMESTAMP:
-		return "TIMESTAMP";
-	case LogicalTypeId::TIMESTAMP_MS:
-		return "TIMESTAMP_MS";
-	case LogicalTypeId::TIMESTAMP_NS:
-		return "TIMESTAMP_NS";
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return "TIMESTAMP_S";
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return "TIMESTAMP WITH TIME ZONE";
-	case LogicalTypeId::TIME_TZ:
-		return "TIME WITH TIME ZONE";
-	case LogicalTypeId::FLOAT:
-		return "FLOAT";
-	case LogicalTypeId::DOUBLE:
-		return "DOUBLE";
-	case LogicalTypeId::DECIMAL:
-		return "DECIMAL";
-	case LogicalTypeId::VARCHAR:
-		return "VARCHAR";
-	case LogicalTypeId::BLOB:
-		return "BLOB";
-	case LogicalTypeId::CHAR:
-		return "CHAR";
-	case LogicalTypeId::INTERVAL:
-		return "INTERVAL";
-	case LogicalTypeId::SQLNULL:
-		return "NULL";
-	case LogicalTypeId::ANY:
-		return "ANY";
-	case LogicalTypeId::VALIDITY:
-		return "VALIDITY";
-	case LogicalTypeId::STRUCT:
-		return "STRUCT";
-	case LogicalTypeId::LIST:
-		return "LIST";
-	case LogicalTypeId::MAP:
-		return "MAP";
-	case LogicalTypeId::POINTER:
-		return "POINTER";
-	case LogicalTypeId::TABLE:
-		return "TABLE";
-	case LogicalTypeId::INVALID:
-		return "INVALID";
-	case LogicalTypeId::UNKNOWN:
-		return "UNKNOWN";
-	case LogicalTypeId::ENUM:
-		return "ENUM";
-	case LogicalTypeId::AGGREGATE_STATE:
-		return "AGGREGATE_STATE";
-	case LogicalTypeId::USER:
-		return "USER";
-	case LogicalTypeId::JSON:
-		return "JSON";
-	}
-	return "UNDEFINED";
-}
-
-string LogicalType::ToString() const {
-	auto alias = GetAlias();
-	if (!alias.empty()) {
-		return alias;
-	}
-	switch (id_) {
-	case LogicalTypeId::STRUCT: {
-		if (!type_info_) {
-			return "STRUCT";
-		}
-		auto &child_types = StructType::GetChildTypes(*this);
-		string ret = "STRUCT(";
-		for (size_t i = 0; i < child_types.size(); i++) {
-			ret += child_types[i].first + " " + child_types[i].second.ToString();
-			if (i < child_types.size() - 1) {
-				ret += ", ";
-			}
-		}
-		ret += ")";
-		return ret;
-	}
-	case LogicalTypeId::LIST: {
-		if (!type_info_) {
-			return "LIST";
-		}
-		return ListType::GetChildType(*this).ToString() + "[]";
-	}
-	case LogicalTypeId::MAP: {
-		if (!type_info_) {
-			return "MAP";
-		}
-		auto &child_types = StructType::GetChildTypes(*this);
-		if (child_types.empty()) {
-			return "MAP(?)";
-		}
-		if (child_types.size() != 2) {
-			throw InternalException("Map needs exactly two child elements");
-		}
-		return "MAP(" + ListType::GetChildType(child_types[0].second).ToString() + ", " +
-		       ListType::GetChildType(child_types[1].second).ToString() + ")";
-	}
-	case LogicalTypeId::DECIMAL: {
-		if (!type_info_) {
-			return "DECIMAL";
-		}
-		auto width = DecimalType::GetWidth(*this);
-		auto scale = DecimalType::GetScale(*this);
-		if (width == 0) {
-			return "DECIMAL";
-		}
-		return StringUtil::Format("DECIMAL(%d,%d)", width, scale);
-	}
-	case LogicalTypeId::ENUM: {
-		return KeywordHelper::WriteOptionallyQuoted(EnumType::GetTypeName(*this));
-	}
-	case LogicalTypeId::USER: {
-		return KeywordHelper::WriteOptionallyQuoted(UserType::GetTypeName(*this));
-	}
-	case LogicalTypeId::AGGREGATE_STATE: {
-		return AggregateStateType::GetTypeName(*this);
-	}
-	default:
-		return LogicalTypeIdToString(id_);
-	}
-}
-// LCOV_EXCL_STOP
-
-LogicalTypeId TransformStringToLogicalTypeId(const string &str) {
-	auto type = DefaultTypeGenerator::GetDefaultType(str);
-	if (type == LogicalTypeId::INVALID) {
-		// This is a User Type, at this point we don't know if its one of the User Defined Types or an error
-		// It is checked in the binder
-		type = LogicalTypeId::USER;
-	}
-	return type;
-}
-
-LogicalType TransformStringToLogicalType(const string &str) {
-	if (StringUtil::Lower(str) == "null") {
-		return LogicalType::SQLNULL;
-	}
-	return Parser::ParseColumnList("dummy " + str)[0].Type();
-}
-
-bool LogicalType::IsIntegral() const {
-	switch (id_) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::HUGEINT:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool LogicalType::IsNumeric() const {
-	switch (id_) {
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool LogicalType::GetDecimalProperties(uint8_t &width, uint8_t &scale) const {
-	switch (id_) {
-	case LogicalTypeId::SQLNULL:
-		width = 0;
-		scale = 0;
-		break;
-	case LogicalTypeId::BOOLEAN:
-		width = 1;
-		scale = 0;
-		break;
-	case LogicalTypeId::TINYINT:
-		// tinyint: [-127, 127] = DECIMAL(3,0)
-		width = 3;
-		scale = 0;
-		break;
-	case LogicalTypeId::SMALLINT:
-		// smallint: [-32767, 32767] = DECIMAL(5,0)
-		width = 5;
-		scale = 0;
-		break;
-	case LogicalTypeId::INTEGER:
-		// integer: [-2147483647, 2147483647] = DECIMAL(10,0)
-		width = 10;
-		scale = 0;
-		break;
-	case LogicalTypeId::BIGINT:
-		// bigint: [-9223372036854775807, 9223372036854775807] = DECIMAL(19,0)
-		width = 19;
-		scale = 0;
-		break;
-	case LogicalTypeId::UTINYINT:
-		// UInt8 — [0 : 255]
-		width = 3;
-		scale = 0;
-		break;
-	case LogicalTypeId::USMALLINT:
-		// UInt16 — [0 : 65535]
-		width = 5;
-		scale = 0;
-		break;
-	case LogicalTypeId::UINTEGER:
-		// UInt32 — [0 : 4294967295]
-		width = 10;
-		scale = 0;
-		break;
-	case LogicalTypeId::UBIGINT:
-		// UInt64 — [0 : 18446744073709551615]
-		width = 20;
-		scale = 0;
-		break;
-	case LogicalTypeId::HUGEINT:
-		// hugeint: max size decimal (38, 0)
-		// note that a hugeint is not guaranteed to fit in this
-		width = 38;
-		scale = 0;
-		break;
-	case LogicalTypeId::DECIMAL:
-		width = DecimalType::GetWidth(*this);
-		scale = DecimalType::GetScale(*this);
-		break;
-	default:
-		return false;
-	}
-	return true;
-}
-
-LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalType &right) {
-	if (left.id() < right.id()) {
-		return right;
-	} else if (right.id() < left.id()) {
-		return left;
-	} else {
-		// Since both left and right are equal we get the left type as our type_id for checks
-		auto type_id = left.id();
-		if (type_id == LogicalTypeId::ENUM) {
-			// If both types are different ENUMs we do a string comparison.
-			return left == right ? left : LogicalType::VARCHAR;
-		}
-		if (type_id == LogicalTypeId::VARCHAR) {
-			// varchar: use type that has collation (if any)
-			if (StringType::GetCollation(right).empty()) {
-				return left;
-			} else {
-				return right;
-			}
-		} else if (type_id == LogicalTypeId::DECIMAL) {
-			// unify the width/scale so that the resulting decimal always fits
-			// "width - scale" gives us the number of digits on the left side of the decimal point
-			// "scale" gives us the number of digits allowed on the right of the deciaml point
-			// using the max of these of the two types gives us the new decimal size
-			auto extra_width_left = DecimalType::GetWidth(left) - DecimalType::GetScale(left);
-			auto extra_width_right = DecimalType::GetWidth(right) - DecimalType::GetScale(right);
-			auto extra_width = MaxValue<uint8_t>(extra_width_left, extra_width_right);
-			auto scale = MaxValue<uint8_t>(DecimalType::GetScale(left), DecimalType::GetScale(right));
-			auto width = extra_width + scale;
-			if (width > DecimalType::MaxWidth()) {
-				// if the resulting decimal does not fit, we truncate the scale
-				width = DecimalType::MaxWidth();
-				scale = width - extra_width;
-			}
-			return LogicalType::DECIMAL(width, scale);
-		} else if (type_id == LogicalTypeId::LIST) {
-			// list: perform max recursively on child type
-			auto new_child = MaxLogicalType(ListType::GetChildType(left), ListType::GetChildType(right));
-			return LogicalType::LIST(move(new_child));
-		} else if (type_id == LogicalTypeId::STRUCT) {
-			// struct: perform recursively
-			auto &left_child_types = StructType::GetChildTypes(left);
-			auto &right_child_types = StructType::GetChildTypes(right);
-			if (left_child_types.size() != right_child_types.size()) {
-				// child types are not of equal size, we can't cast anyway
-				// just return the left child
-				return left;
-			}
-			child_list_t<LogicalType> child_types;
-			for (idx_t i = 0; i < left_child_types.size(); i++) {
-				auto child_type = MaxLogicalType(left_child_types[i].second, right_child_types[i].second);
-				child_types.push_back(make_pair(left_child_types[i].first, move(child_type)));
-			}
-			return LogicalType::STRUCT(move(child_types));
-		} else {
-			// types are equal but no extra specifier: just return the type
-			return left;
-		}
-	}
-}
-
-void LogicalType::Verify() const {
-#ifdef DEBUG
-	if (id_ == LogicalTypeId::DECIMAL) {
-		D_ASSERT(DecimalType::GetWidth(*this) >= 1 && DecimalType::GetWidth(*this) <= Decimal::MAX_WIDTH_DECIMAL);
-		D_ASSERT(DecimalType::GetScale(*this) >= 0 && DecimalType::GetScale(*this) <= DecimalType::GetWidth(*this));
-	}
-#endif
-}
-
-bool ApproxEqual(float ldecimal, float rdecimal) {
-	if (Value::IsNan(ldecimal) && Value::IsNan(rdecimal)) {
-		return true;
-	}
-	if (!Value::FloatIsFinite(ldecimal) || !Value::FloatIsFinite(rdecimal)) {
-		return ldecimal == rdecimal;
-	}
-	float epsilon = std::fabs(rdecimal) * 0.01 + 0.00000001;
-	return std::fabs(ldecimal - rdecimal) <= epsilon;
-}
-
-bool ApproxEqual(double ldecimal, double rdecimal) {
-	if (Value::IsNan(ldecimal) && Value::IsNan(rdecimal)) {
-		return true;
-	}
-	if (!Value::DoubleIsFinite(ldecimal) || !Value::DoubleIsFinite(rdecimal)) {
-		return ldecimal == rdecimal;
-	}
-	double epsilon = std::fabs(rdecimal) * 0.01 + 0.00000001;
-	return std::fabs(ldecimal - rdecimal) <= epsilon;
-}
-
-//===--------------------------------------------------------------------===//
-// Extra Type Info
-//===--------------------------------------------------------------------===//
-enum class ExtraTypeInfoType : uint8_t {
-	INVALID_TYPE_INFO = 0,
-	GENERIC_TYPE_INFO = 1,
-	DECIMAL_TYPE_INFO = 2,
-	STRING_TYPE_INFO = 3,
-	LIST_TYPE_INFO = 4,
-	STRUCT_TYPE_INFO = 5,
-	ENUM_TYPE_INFO = 6,
-	USER_TYPE_INFO = 7,
-	AGGREGATE_STATE_TYPE_INFO = 8
-};
-
-struct ExtraTypeInfo {
-	explicit ExtraTypeInfo(ExtraTypeInfoType type) : type(type) {
-	}
-	explicit ExtraTypeInfo(ExtraTypeInfoType type, string alias) : type(type), alias(move(alias)) {
-	}
-	virtual ~ExtraTypeInfo() {
-	}
-
-	ExtraTypeInfoType type;
-	string alias;
-	TypeCatalogEntry *catalog_entry = nullptr;
-
-public:
-	bool Equals(ExtraTypeInfo *other_p) const {
-		if (type == ExtraTypeInfoType::INVALID_TYPE_INFO || type == ExtraTypeInfoType::STRING_TYPE_INFO ||
-		    type == ExtraTypeInfoType::GENERIC_TYPE_INFO) {
-			if (!other_p) {
-				if (!alias.empty()) {
-					return false;
-				}
-				return true;
-			}
-			if (alias != other_p->alias) {
-				return false;
-			}
-			return true;
-		}
-		if (!other_p) {
-			return false;
-		}
-		if (type != other_p->type) {
-			return false;
-		}
-		auto &other = (ExtraTypeInfo &)*other_p;
-		return alias == other.alias && EqualsInternal(other_p);
-	}
-	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
-	virtual void Serialize(FieldWriter &writer) const {};
-	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
-	static void Serialize(ExtraTypeInfo *info, FieldWriter &writer);
-	//! Deserializes a blob back into an ExtraTypeInfo
-	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
-
-protected:
-	virtual bool EqualsInternal(ExtraTypeInfo *other_p) const {
-		// Do nothing
-		return true;
-	}
-};
-
-void LogicalType::SetAlias(string &alias) {
-	if (!type_info_) {
-		type_info_ = make_shared<ExtraTypeInfo>(ExtraTypeInfoType::GENERIC_TYPE_INFO, alias);
-	} else {
-		type_info_->alias = alias;
-	}
-}
-
-string LogicalType::GetAlias() const {
-	if (!type_info_) {
-		return string();
-	} else {
-		return type_info_->alias;
-	}
-}
-
-void LogicalType::SetCatalog(LogicalType &type, TypeCatalogEntry *catalog_entry) {
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	((ExtraTypeInfo &)*info).catalog_entry = catalog_entry;
-}
-TypeCatalogEntry *LogicalType::GetCatalog(const LogicalType &type) {
-	auto info = type.AuxInfo();
-	if (!info) {
-		return nullptr;
-	}
-	return ((ExtraTypeInfo &)*info).catalog_entry;
-}
-
-//===--------------------------------------------------------------------===//
-// Decimal Type
-//===--------------------------------------------------------------------===//
-struct DecimalTypeInfo : public ExtraTypeInfo {
-	DecimalTypeInfo(uint8_t width_p, uint8_t scale_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::DECIMAL_TYPE_INFO), width(width_p), scale(scale_p) {
-	}
-
-	uint8_t width;
-	uint8_t scale;
-
-public:
-	void Serialize(FieldWriter &writer) const override {
-		writer.WriteField<uint8_t>(width);
-		writer.WriteField<uint8_t>(scale);
-	}
-
-	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
-		auto width = reader.ReadRequired<uint8_t>();
-		auto scale = reader.ReadRequired<uint8_t>();
-		return make_shared<DecimalTypeInfo>(width, scale);
-	}
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (DecimalTypeInfo &)*other_p;
-		return width == other.width && scale == other.scale;
-	}
-};
-
-uint8_t DecimalType::GetWidth(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((DecimalTypeInfo &)*info).width;
-}
-
-uint8_t DecimalType::GetScale(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((DecimalTypeInfo &)*info).scale;
-}
-
-uint8_t DecimalType::MaxWidth() {
-	return 38;
-}
-
-LogicalType LogicalType::DECIMAL(int width, int scale) {
-	auto type_info = make_shared<DecimalTypeInfo>(width, scale);
-	return LogicalType(LogicalTypeId::DECIMAL, move(type_info));
-}
-
-//===--------------------------------------------------------------------===//
-// String Type
-//===--------------------------------------------------------------------===//
-struct StringTypeInfo : public ExtraTypeInfo {
-	explicit StringTypeInfo(string collation_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::STRING_TYPE_INFO), collation(move(collation_p)) {
-	}
-
-	string collation;
-
-public:
-	void Serialize(FieldWriter &writer) const override {
-		writer.WriteString(collation);
-	}
-
-	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
-		auto collation = reader.ReadRequired<string>();
-		return make_shared<StringTypeInfo>(move(collation));
-	}
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		// collation info has no impact on equality
-		return true;
-	}
-};
-
-string StringType::GetCollation(const LogicalType &type) {
-	if (type.id() != LogicalTypeId::VARCHAR) {
-		return string();
-	}
-	auto info = type.AuxInfo();
-	if (!info) {
-		return string();
-	}
-	if (info->type == ExtraTypeInfoType::GENERIC_TYPE_INFO) {
-		return string();
-	}
-	return ((StringTypeInfo &)*info).collation;
-}
-
-LogicalType LogicalType::VARCHAR_COLLATION(string collation) { // NOLINT
-	auto string_info = make_shared<StringTypeInfo>(move(collation));
-	return LogicalType(LogicalTypeId::VARCHAR, move(string_info));
-}
-
-//===--------------------------------------------------------------------===//
-// List Type
-//===--------------------------------------------------------------------===//
-struct ListTypeInfo : public ExtraTypeInfo {
-	explicit ListTypeInfo(LogicalType child_type_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::LIST_TYPE_INFO), child_type(move(child_type_p)) {
-	}
-
-	LogicalType child_type;
-
-public:
-	void Serialize(FieldWriter &writer) const override {
-		writer.WriteSerializable(child_type);
-	}
-
-	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
-		auto child_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		return make_shared<ListTypeInfo>(move(child_type));
-	}
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (ListTypeInfo &)*other_p;
-		return child_type == other.child_type;
-	}
-};
-
-const LogicalType &ListType::GetChildType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::LIST);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((ListTypeInfo &)*info).child_type;
-}
-
-LogicalType LogicalType::LIST(LogicalType child) {
-	auto info = make_shared<ListTypeInfo>(move(child));
-	return LogicalType(LogicalTypeId::LIST, move(info));
-}
-
-//===--------------------------------------------------------------------===//
-// Struct Type
-//===--------------------------------------------------------------------===//
-struct StructTypeInfo : public ExtraTypeInfo {
-	explicit StructTypeInfo(child_list_t<LogicalType> child_types_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::STRUCT_TYPE_INFO), child_types(move(child_types_p)) {
-	}
-
-	child_list_t<LogicalType> child_types;
-
-public:
-	void Serialize(FieldWriter &writer) const override {
-		writer.WriteField<uint32_t>(child_types.size());
-		auto &serializer = writer.GetSerializer();
-		for (idx_t i = 0; i < child_types.size(); i++) {
-			serializer.WriteString(child_types[i].first);
-			child_types[i].second.Serialize(serializer);
-		}
-	}
-
-	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
-		child_list_t<LogicalType> child_list;
-		auto child_types_size = reader.ReadRequired<uint32_t>();
-		auto &source = reader.GetSource();
-		for (uint32_t i = 0; i < child_types_size; i++) {
-			auto name = source.Read<string>();
-			auto type = LogicalType::Deserialize(source);
-			child_list.push_back(make_pair(move(name), move(type)));
-		}
-		return make_shared<StructTypeInfo>(move(child_list));
-	}
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (StructTypeInfo &)*other_p;
-		return child_types == other.child_types;
-	}
-};
-
-struct AggregateStateTypeInfo : public ExtraTypeInfo {
-	explicit AggregateStateTypeInfo(aggregate_state_t state_type_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO), state_type(move(state_type_p)) {
-	}
-
-	aggregate_state_t state_type;
-
-public:
-	void Serialize(FieldWriter &writer) const override {
-		auto &serializer = writer.GetSerializer();
-		writer.WriteString(state_type.function_name);
-		state_type.return_type.Serialize(serializer);
-		writer.WriteField<uint32_t>(state_type.bound_argument_types.size());
-		for (idx_t i = 0; i < state_type.bound_argument_types.size(); i++) {
-			state_type.bound_argument_types[i].Serialize(serializer);
-		}
-	}
-
-	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
-		auto &source = reader.GetSource();
-
-		auto function_name = reader.ReadRequired<string>();
-		auto return_type = LogicalType::Deserialize(source);
-		auto bound_argument_types_size = reader.ReadRequired<uint32_t>();
-		vector<LogicalType> bound_argument_types;
-
-		for (uint32_t i = 0; i < bound_argument_types_size; i++) {
-			auto type = LogicalType::Deserialize(source);
-			bound_argument_types.push_back(move(type));
-		}
-		return make_shared<AggregateStateTypeInfo>(
-		    aggregate_state_t(move(function_name), move(return_type), move(bound_argument_types)));
-	}
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (AggregateStateTypeInfo &)*other_p;
-		return state_type.function_name == other.state_type.function_name &&
-		       state_type.return_type == other.state_type.return_type &&
-		       state_type.bound_argument_types == other.state_type.bound_argument_types;
-	}
-};
-
-const aggregate_state_t &AggregateStateType::GetStateType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::AGGREGATE_STATE);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((AggregateStateTypeInfo &)*info).state_type;
-}
-
-const string AggregateStateType::GetTypeName(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::AGGREGATE_STATE);
-	auto info = type.AuxInfo();
-	if (!info) {
-		return "AGGREGATE_STATE<?>";
-	}
-	auto aggr_state = ((AggregateStateTypeInfo &)*info).state_type;
-	return "AGGREGATE_STATE<" + aggr_state.function_name + "(" +
-	       StringUtil::Join(aggr_state.bound_argument_types, aggr_state.bound_argument_types.size(), ", ",
-	                        [](const LogicalType &arg_type) { return arg_type.ToString(); }) +
-	       ")" + "::" + aggr_state.return_type.ToString() + ">";
-}
-
-const child_list_t<LogicalType> &StructType::GetChildTypes(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::MAP);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((StructTypeInfo &)*info).child_types;
-}
-
-const LogicalType &StructType::GetChildType(const LogicalType &type, idx_t index) {
-	auto &child_types = StructType::GetChildTypes(type);
-	D_ASSERT(index < child_types.size());
-	return child_types[index].second;
-}
-
-const string &StructType::GetChildName(const LogicalType &type, idx_t index) {
-	auto &child_types = StructType::GetChildTypes(type);
-	D_ASSERT(index < child_types.size());
-	return child_types[index].first;
-}
-
-idx_t StructType::GetChildCount(const LogicalType &type) {
-	return StructType::GetChildTypes(type).size();
-}
-
-LogicalType LogicalType::STRUCT(child_list_t<LogicalType> children) {
-	auto info = make_shared<StructTypeInfo>(move(children));
-	return LogicalType(LogicalTypeId::STRUCT, move(info));
-}
-
-LogicalType LogicalType::AGGREGATE_STATE(aggregate_state_t state_type) { // NOLINT
-	auto info = make_shared<AggregateStateTypeInfo>(move(state_type));
-	return LogicalType(LogicalTypeId::AGGREGATE_STATE, move(info));
-}
-
-//===--------------------------------------------------------------------===//
-// Map Type
-//===--------------------------------------------------------------------===//
-LogicalType LogicalType::MAP(child_list_t<LogicalType> children) {
-	auto info = make_shared<StructTypeInfo>(move(children));
-	return LogicalType(LogicalTypeId::MAP, move(info));
-}
-
-LogicalType LogicalType::MAP(LogicalType key, LogicalType value) {
-	child_list_t<LogicalType> child_types;
-	child_types.push_back({"key", LogicalType::LIST(move(key))});
-	child_types.push_back({"value", LogicalType::LIST(move(value))});
-	return LogicalType::MAP(move(child_types));
-}
-
-const LogicalType &MapType::KeyType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::MAP);
-	return ListType::GetChildType(StructType::GetChildTypes(type)[0].second);
-}
-
-const LogicalType &MapType::ValueType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::MAP);
-	return ListType::GetChildType(StructType::GetChildTypes(type)[1].second);
-}
-
-//===--------------------------------------------------------------------===//
-// User Type
-//===--------------------------------------------------------------------===//
-struct UserTypeInfo : public ExtraTypeInfo {
-	explicit UserTypeInfo(string name_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(move(name_p)) {
-	}
-
-	string user_type_name;
-
-public:
-	void Serialize(FieldWriter &writer) const override {
-		writer.WriteString(user_type_name);
-	}
-
-	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
-		auto enum_name = reader.ReadRequired<string>();
-		return make_shared<UserTypeInfo>(move(enum_name));
-	}
-
-protected:
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (UserTypeInfo &)*other_p;
-		return other.user_type_name == user_type_name;
-	}
-};
-
-const string &UserType::GetTypeName(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::USER);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((UserTypeInfo &)*info).user_type_name;
-}
-
-LogicalType LogicalType::USER(const string &user_type_name) {
-	auto info = make_shared<UserTypeInfo>(user_type_name);
-	return LogicalType(LogicalTypeId::USER, move(info));
-}
-
-//===--------------------------------------------------------------------===//
-// Enum Type
-//===--------------------------------------------------------------------===//
-
-enum EnumDictType : uint8_t { INVALID = 0, VECTOR_DICT = 1, DEDUP_POINTER = 2 };
-
-struct EnumTypeInfo : public ExtraTypeInfo {
-	explicit EnumTypeInfo(string enum_name_p, Vector &values_insert_order_p, idx_t dict_size_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), dict_type(EnumDictType::VECTOR_DICT),
-	      enum_name(move(enum_name_p)), values_insert_order(values_insert_order_p), dict_size(dict_size_p) {
-	}
-	explicit EnumTypeInfo()
-	    : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), dict_type(EnumDictType::DEDUP_POINTER),
-	      enum_name("dedup_pointer"), values_insert_order(Vector(LogicalType::VARCHAR)), dict_size(0) {
-	}
-	EnumDictType dict_type;
-	string enum_name;
-	Vector values_insert_order;
-	idx_t dict_size;
-
-protected:
-	// Equalities are only used in enums with different catalog entries
-	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (EnumTypeInfo &)*other_p;
-		if (dict_type != other.dict_type) {
-			return false;
-		}
-		if (dict_type == EnumDictType::DEDUP_POINTER) {
-			return true;
-		}
-		D_ASSERT(dict_type == EnumDictType::VECTOR_DICT);
-		// We must check if both enums have the same size
-		if (other.dict_size != dict_size) {
-			return false;
-		}
-		auto other_vector_ptr = FlatVector::GetData<string_t>(other.values_insert_order);
-		auto this_vector_ptr = FlatVector::GetData<string_t>(values_insert_order);
-
-		// Now we must check if all strings are the same
-		for (idx_t i = 0; i < dict_size; i++) {
-			if (!Equals::Operation(other_vector_ptr[i], this_vector_ptr[i])) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	void Serialize(FieldWriter &writer) const override {
-		if (dict_type != EnumDictType::VECTOR_DICT) {
-			throw InternalException("Cannot serialize non-vector dictionary ENUM types");
-		}
-		writer.WriteField<uint32_t>(dict_size);
-		writer.WriteString(enum_name);
-		((Vector &)values_insert_order).Serialize(dict_size, writer.GetSerializer());
-	}
-};
-
-template <class T>
-struct EnumTypeInfoTemplated : public EnumTypeInfo {
-	explicit EnumTypeInfoTemplated(const string &enum_name_p, Vector &values_insert_order_p, idx_t size_p)
-	    : EnumTypeInfo(enum_name_p, values_insert_order_p, size_p) {
-		for (idx_t count = 0; count < size_p; count++) {
-			values[values_insert_order_p.GetValue(count).ToString()] = count;
-		}
-	}
-
-	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size) {
-		auto enum_name = reader.ReadRequired<string>();
-		Vector values_insert_order(LogicalType::VARCHAR, size);
-		values_insert_order.Deserialize(size, reader.GetSource());
-		return make_shared<EnumTypeInfoTemplated>(move(enum_name), values_insert_order, size);
-	}
-	unordered_map<string, T> values;
-};
-
-const string &EnumType::GetTypeName(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).enum_name;
-}
-
-static PhysicalType EnumVectorDictType(idx_t size) {
-	if (size <= NumericLimits<uint8_t>::Maximum()) {
-		return PhysicalType::UINT8;
-	} else if (size <= NumericLimits<uint16_t>::Maximum()) {
-		return PhysicalType::UINT16;
-	} else if (size <= NumericLimits<uint32_t>::Maximum()) {
-		return PhysicalType::UINT32;
-	} else {
-		throw InternalException("Enum size must be lower than " + std::to_string(NumericLimits<uint32_t>::Maximum()));
-	}
-}
-
-LogicalType LogicalType::ENUM(const string &enum_name, Vector &ordered_data, idx_t size) {
-	// Generate EnumTypeInfo
-	shared_ptr<ExtraTypeInfo> info;
-	auto enum_internal_type = EnumVectorDictType(size);
-	switch (enum_internal_type) {
-	case PhysicalType::UINT8:
-		info = make_shared<EnumTypeInfoTemplated<uint8_t>>(enum_name, ordered_data, size);
-		break;
-	case PhysicalType::UINT16:
-		info = make_shared<EnumTypeInfoTemplated<uint16_t>>(enum_name, ordered_data, size);
-		break;
-	case PhysicalType::UINT32:
-		info = make_shared<EnumTypeInfoTemplated<uint32_t>>(enum_name, ordered_data, size);
-		break;
-	default:
-		throw InternalException("Invalid Physical Type for ENUMs");
-	}
-	// Generate Actual Enum Type
-	return LogicalType(LogicalTypeId::ENUM, info);
-}
-
-LogicalType LogicalType::DEDUP_POINTER_ENUM() { // NOLINT
-	auto info = make_shared<EnumTypeInfo>();
-	D_ASSERT(info->dict_type == EnumDictType::DEDUP_POINTER);
-	return LogicalType(LogicalTypeId::ENUM, info);
-}
-
-template <class T>
-int64_t TemplatedGetPos(unordered_map<string, T> &map, const string &key) {
-	auto it = map.find(key);
-	if (it == map.end()) {
-		return -1;
-	}
-	return it->second;
-}
-int64_t EnumType::GetPos(const LogicalType &type, const string &key) {
-	auto info = type.AuxInfo();
-	switch (type.InternalType()) {
-	case PhysicalType::UINT8:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint8_t> &)*info).values, key);
-	case PhysicalType::UINT16:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint16_t> &)*info).values, key);
-	case PhysicalType::UINT32:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint32_t> &)*info).values, key);
-	default:
-		throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-	}
-}
-
-const string EnumType::GetValue(const Value &val) {
-	auto info = val.type().AuxInfo();
-	auto &enum_info = ((EnumTypeInfo &)*info);
-	if (enum_info.dict_type == EnumDictType::DEDUP_POINTER) {
-		return (const char *)val.GetValue<uint64_t>();
-	}
-	auto &values_insert_order = ((EnumTypeInfo &)*info).values_insert_order;
-	return StringValue::Get(values_insert_order.GetValue(val.GetValue<uint32_t>()));
-}
-
-Vector &EnumType::GetValuesInsertOrder(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).values_insert_order;
-}
-
-idx_t EnumType::GetSize(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).dict_size;
-}
-
-void EnumType::SetCatalog(LogicalType &type, TypeCatalogEntry *catalog_entry) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	((EnumTypeInfo &)*info).catalog_entry = catalog_entry;
-}
-TypeCatalogEntry *EnumType::GetCatalog(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).catalog_entry;
-}
-
-PhysicalType EnumType::GetPhysicalType(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto aux_info = type.AuxInfo();
-	D_ASSERT(aux_info);
-	auto &info = (EnumTypeInfo &)*aux_info;
-
-	if (info.dict_type == EnumDictType::DEDUP_POINTER) {
-		return PhysicalType::UINT64; // for pointer enum types
-	}
-	D_ASSERT(info.dict_type == EnumDictType::VECTOR_DICT);
-	return EnumVectorDictType(info.dict_size);
-}
-
-//===--------------------------------------------------------------------===//
-// Extra Type Info
-//===--------------------------------------------------------------------===//
-void ExtraTypeInfo::Serialize(ExtraTypeInfo *info, FieldWriter &writer) {
-	if (!info) {
-		writer.WriteField<ExtraTypeInfoType>(ExtraTypeInfoType::INVALID_TYPE_INFO);
-		writer.WriteString(string());
-	} else {
-		writer.WriteField<ExtraTypeInfoType>(info->type);
-		info->Serialize(writer);
-		writer.WriteString(info->alias);
-	}
-}
-shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(FieldReader &reader) {
-	auto type = reader.ReadRequired<ExtraTypeInfoType>();
-	shared_ptr<ExtraTypeInfo> extra_info;
-	switch (type) {
-	case ExtraTypeInfoType::INVALID_TYPE_INFO: {
-		auto alias = reader.ReadField<string>(string());
-		if (!alias.empty()) {
-			return make_shared<ExtraTypeInfo>(type, alias);
-		}
-		return nullptr;
-	} break;
-	case ExtraTypeInfoType::GENERIC_TYPE_INFO: {
-		extra_info = make_shared<ExtraTypeInfo>(type);
-	} break;
-	case ExtraTypeInfoType::DECIMAL_TYPE_INFO:
-		extra_info = DecimalTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::STRING_TYPE_INFO:
-		extra_info = StringTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::LIST_TYPE_INFO:
-		extra_info = ListTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::STRUCT_TYPE_INFO:
-		extra_info = StructTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::USER_TYPE_INFO:
-		extra_info = UserTypeInfo::Deserialize(reader);
-		break;
-	case ExtraTypeInfoType::ENUM_TYPE_INFO: {
-		auto enum_size = reader.ReadRequired<uint32_t>();
-		auto enum_internal_type = EnumVectorDictType(enum_size);
-		switch (enum_internal_type) {
-		case PhysicalType::UINT8:
-			extra_info = EnumTypeInfoTemplated<uint8_t>::Deserialize(reader, enum_size);
-			break;
-		case PhysicalType::UINT16:
-			extra_info = EnumTypeInfoTemplated<uint16_t>::Deserialize(reader, enum_size);
-			break;
-		case PhysicalType::UINT32:
-			extra_info = EnumTypeInfoTemplated<uint32_t>::Deserialize(reader, enum_size);
-			break;
-		default:
-			throw InternalException("Invalid Physical Type for ENUMs");
-		}
-	} break;
-	case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO:
-		extra_info = AggregateStateTypeInfo::Deserialize(reader);
-		break;
-
-	default:
-		throw InternalException("Unimplemented type info in ExtraTypeInfo::Deserialize");
-	}
-	auto alias = reader.ReadField<string>(string());
-	extra_info->alias = alias;
-	return extra_info;
-}
-
-//===--------------------------------------------------------------------===//
-// Logical Type
-//===--------------------------------------------------------------------===//
-
-// the destructor needs to know about the extra type info
-LogicalType::~LogicalType() {
-}
-
-void LogicalType::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<LogicalTypeId>(id_);
-	ExtraTypeInfo::Serialize(type_info_.get(), writer);
-	writer.Finalize();
-}
-
-LogicalType LogicalType::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto id = reader.ReadRequired<LogicalTypeId>();
-	auto info = ExtraTypeInfo::Deserialize(reader);
-	reader.Finalize();
-
-	return LogicalType(id, move(info));
-}
-
-bool LogicalType::operator==(const LogicalType &rhs) const {
-	if (id_ != rhs.id_) {
-		return false;
-	}
-	if (type_info_.get() == rhs.type_info_.get()) {
-		return true;
-	}
-	if (type_info_) {
-		return type_info_->Equals(rhs.type_info_.get());
-	} else {
-		D_ASSERT(rhs.type_info_);
-		return rhs.type_info_->Equals(type_info_.get());
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Comparison Operations
-//===--------------------------------------------------------------------===//
-
-struct ValuePositionComparator {
-	// Return true if the positional Values definitely match.
-	// Default to the same as the final value
-	template <typename OP>
-	static inline bool Definite(const Value &lhs, const Value &rhs) {
-		return Final<OP>(lhs, rhs);
-	}
-
-	// Select the positional Values that need further testing.
-	// Usually this means Is Not Distinct, as those are the semantics used by Postges
-	template <typename OP>
-	static inline bool Possible(const Value &lhs, const Value &rhs) {
-		return ValueOperations::NotDistinctFrom(lhs, rhs);
-	}
-
-	// Return true if the positional Values definitely match in the final position
-	// This needs to be specialised.
-	template <typename OP>
-	static inline bool Final(const Value &lhs, const Value &rhs) {
-		return false;
-	}
-
-	// Tie-break based on length when one of the sides has been exhausted, returning true if the LHS matches.
-	// This essentially means that the existing positions compare equal.
-	// Default to the same semantics as the OP for idx_t. This works in most cases.
-	template <typename OP>
-	static inline bool TieBreak(const idx_t lpos, const idx_t rpos) {
-		return OP::Operation(lpos, rpos);
-	}
-};
-
-// Equals must always check every column
-template <>
-inline bool ValuePositionComparator::Definite<duckdb::Equals>(const Value &lhs, const Value &rhs) {
-	return false;
-}
-
-template <>
-inline bool ValuePositionComparator::Final<duckdb::Equals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::NotDistinctFrom(lhs, rhs);
-}
-
-// NotEquals must check everything that matched
-template <>
-inline bool ValuePositionComparator::Possible<duckdb::NotEquals>(const Value &lhs, const Value &rhs) {
-	return true;
-}
-
-template <>
-inline bool ValuePositionComparator::Final<duckdb::NotEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::NotDistinctFrom(lhs, rhs);
-}
-
-// Non-strict inequalities must use strict comparisons for Definite
-template <>
-bool ValuePositionComparator::Definite<duckdb::LessThanEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctLessThan(lhs, rhs);
-}
-
-template <>
-bool ValuePositionComparator::Final<duckdb::LessThanEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctLessThanEquals(lhs, rhs);
-}
-
-template <>
-bool ValuePositionComparator::Definite<duckdb::GreaterThanEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctGreaterThan(lhs, rhs);
-}
-
-template <>
-bool ValuePositionComparator::Final<duckdb::GreaterThanEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctGreaterThanEquals(lhs, rhs);
-}
-
-// Strict inequalities just use strict for both Definite and Final
-template <>
-bool ValuePositionComparator::Final<duckdb::LessThan>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctLessThan(lhs, rhs);
-}
-
-template <>
-bool ValuePositionComparator::Final<duckdb::GreaterThan>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctGreaterThan(lhs, rhs);
-}
-
-template <class OP>
-static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
-	const auto &left_type = left.type();
-	const auto &right_type = right.type();
-	if (left_type != right_type) {
-		Value left_copy = left;
-		Value right_copy = right;
-
-		LogicalType comparison_type = BoundComparisonExpression::BindComparison(left_type, right_type);
-		if (!left_copy.TryCastAs(comparison_type) || !right_copy.TryCastAs(comparison_type)) {
-			return false;
-		}
-		D_ASSERT(left_copy.type() == right_copy.type());
-		return TemplatedBooleanOperation<OP>(left_copy, right_copy);
-	}
-	switch (left_type.InternalType()) {
-	case PhysicalType::BOOL:
-		return OP::Operation(left.GetValueUnsafe<bool>(), right.GetValueUnsafe<bool>());
-	case PhysicalType::INT8:
-		return OP::Operation(left.GetValueUnsafe<int8_t>(), right.GetValueUnsafe<int8_t>());
-	case PhysicalType::INT16:
-		return OP::Operation(left.GetValueUnsafe<int16_t>(), right.GetValueUnsafe<int16_t>());
-	case PhysicalType::INT32:
-		return OP::Operation(left.GetValueUnsafe<int32_t>(), right.GetValueUnsafe<int32_t>());
-	case PhysicalType::INT64:
-		return OP::Operation(left.GetValueUnsafe<int64_t>(), right.GetValueUnsafe<int64_t>());
-	case PhysicalType::UINT8:
-		return OP::Operation(left.GetValueUnsafe<uint8_t>(), right.GetValueUnsafe<uint8_t>());
-	case PhysicalType::UINT16:
-		return OP::Operation(left.GetValueUnsafe<uint16_t>(), right.GetValueUnsafe<uint16_t>());
-	case PhysicalType::UINT32:
-		return OP::Operation(left.GetValueUnsafe<uint32_t>(), right.GetValueUnsafe<uint32_t>());
-	case PhysicalType::UINT64:
-		return OP::Operation(left.GetValueUnsafe<uint64_t>(), right.GetValueUnsafe<uint64_t>());
-	case PhysicalType::INT128:
-		return OP::Operation(left.GetValueUnsafe<hugeint_t>(), right.GetValueUnsafe<hugeint_t>());
-	case PhysicalType::FLOAT:
-		return OP::Operation(left.GetValueUnsafe<float>(), right.GetValueUnsafe<float>());
-	case PhysicalType::DOUBLE:
-		return OP::Operation(left.GetValueUnsafe<double>(), right.GetValueUnsafe<double>());
-	case PhysicalType::INTERVAL:
-		return OP::Operation(left.GetValueUnsafe<interval_t>(), right.GetValueUnsafe<interval_t>());
-	case PhysicalType::VARCHAR:
-		return OP::Operation(StringValue::Get(left), StringValue::Get(right));
-	case PhysicalType::STRUCT: {
-		auto &left_children = StructValue::GetChildren(left);
-		auto &right_children = StructValue::GetChildren(right);
-		// this should be enforced by the type
-		D_ASSERT(left_children.size() == right_children.size());
-		idx_t i = 0;
-		for (; i < left_children.size() - 1; ++i) {
-			if (ValuePositionComparator::Definite<OP>(left_children[i], right_children[i])) {
-				return true;
-			}
-			if (!ValuePositionComparator::Possible<OP>(left_children[i], right_children[i])) {
-				return false;
-			}
-		}
-		return ValuePositionComparator::Final<OP>(left_children[i], right_children[i]);
-	}
-	case PhysicalType::LIST: {
-		auto &left_children = ListValue::GetChildren(left);
-		auto &right_children = ListValue::GetChildren(right);
-		for (idx_t pos = 0;; ++pos) {
-			if (pos == left_children.size() || pos == right_children.size()) {
-				return ValuePositionComparator::TieBreak<OP>(left_children.size(), right_children.size());
-			}
-			if (ValuePositionComparator::Definite<OP>(left_children[pos], right_children[pos])) {
-				return true;
-			}
-			if (!ValuePositionComparator::Possible<OP>(left_children[pos], right_children[pos])) {
-				return false;
-			}
-		}
-		return false;
-	}
-	default:
-		throw InternalException("Unimplemented type for value comparison");
-	}
-}
-
-bool ValueOperations::Equals(const Value &left, const Value &right) {
-	if (left.IsNull() || right.IsNull()) {
-		throw InternalException("Comparison on NULL values");
-	}
-	return TemplatedBooleanOperation<duckdb::Equals>(left, right);
-}
-
-bool ValueOperations::NotEquals(const Value &left, const Value &right) {
-	return !ValueOperations::Equals(left, right);
-}
-
-bool ValueOperations::GreaterThan(const Value &left, const Value &right) {
-	if (left.IsNull() || right.IsNull()) {
-		throw InternalException("Comparison on NULL values");
-	}
-	return TemplatedBooleanOperation<duckdb::GreaterThan>(left, right);
-}
-
-bool ValueOperations::GreaterThanEquals(const Value &left, const Value &right) {
-	if (left.IsNull() || right.IsNull()) {
-		throw InternalException("Comparison on NULL values");
-	}
-	return TemplatedBooleanOperation<duckdb::GreaterThanEquals>(left, right);
-}
-
-bool ValueOperations::LessThan(const Value &left, const Value &right) {
-	return ValueOperations::GreaterThan(right, left);
-}
-
-bool ValueOperations::LessThanEquals(const Value &left, const Value &right) {
-	return ValueOperations::GreaterThanEquals(right, left);
-}
-
-bool ValueOperations::NotDistinctFrom(const Value &left, const Value &right) {
-	if (left.IsNull() && right.IsNull()) {
-		return true;
-	}
-	if (left.IsNull() != right.IsNull()) {
-		return false;
-	}
-	return TemplatedBooleanOperation<duckdb::Equals>(left, right);
-}
-
-bool ValueOperations::DistinctFrom(const Value &left, const Value &right) {
-	return !ValueOperations::NotDistinctFrom(left, right);
-}
-
-bool ValueOperations::DistinctGreaterThan(const Value &left, const Value &right) {
-	if (left.IsNull() && right.IsNull()) {
-		return false;
-	} else if (right.IsNull()) {
-		return false;
-	} else if (left.IsNull()) {
-		return true;
-	}
-	return TemplatedBooleanOperation<duckdb::GreaterThan>(left, right);
-}
-
-bool ValueOperations::DistinctGreaterThanEquals(const Value &left, const Value &right) {
-	if (left.IsNull()) {
-		return true;
-	} else if (right.IsNull()) {
-		return false;
-	}
-	return TemplatedBooleanOperation<duckdb::GreaterThanEquals>(left, right);
-}
-
-bool ValueOperations::DistinctLessThan(const Value &left, const Value &right) {
-	return ValueOperations::DistinctGreaterThan(right, left);
-}
-
-bool ValueOperations::DistinctLessThanEquals(const Value &left, const Value &right) {
-	return ValueOperations::DistinctGreaterThanEquals(right, left);
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// boolean_operators.cpp
-// Description: This file contains the implementation of the boolean
-// operations AND OR !
-//===--------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// AND/OR
-//===--------------------------------------------------------------------===//
-template <class OP>
-static void TemplatedBooleanNullmask(Vector &left, Vector &right, Vector &result, idx_t count) {
-	D_ASSERT(left.GetType().id() == LogicalTypeId::BOOLEAN && right.GetType().id() == LogicalTypeId::BOOLEAN &&
-	         result.GetType().id() == LogicalTypeId::BOOLEAN);
-
-	if (left.GetVectorType() == VectorType::CONSTANT_VECTOR && right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// operation on two constants, result is constant vector
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto ldata = ConstantVector::GetData<uint8_t>(left);
-		auto rdata = ConstantVector::GetData<uint8_t>(right);
-		auto result_data = ConstantVector::GetData<bool>(result);
-
-		bool is_null = OP::Operation(*ldata > 0, *rdata > 0, ConstantVector::IsNull(left),
-		                             ConstantVector::IsNull(right), *result_data);
-		ConstantVector::SetNull(result, is_null);
-	} else {
-		// perform generic loop
-		VectorData ldata, rdata;
-		left.Orrify(count, ldata);
-		right.Orrify(count, rdata);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto left_data = (uint8_t *)ldata.data; // we use uint8 to avoid load of gunk bools
-		auto right_data = (uint8_t *)rdata.data;
-		auto result_data = FlatVector::GetData<bool>(result);
-		auto &result_mask = FlatVector::Validity(result);
-		if (!ldata.validity.AllValid() || !rdata.validity.AllValid()) {
-			for (idx_t i = 0; i < count; i++) {
-				auto lidx = ldata.sel->get_index(i);
-				auto ridx = rdata.sel->get_index(i);
-				bool is_null =
-				    OP::Operation(left_data[lidx] > 0, right_data[ridx] > 0, !ldata.validity.RowIsValid(lidx),
-				                  !rdata.validity.RowIsValid(ridx), result_data[i]);
-				result_mask.Set(i, !is_null);
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto lidx = ldata.sel->get_index(i);
-				auto ridx = rdata.sel->get_index(i);
-				result_data[i] = OP::SimpleOperation(left_data[lidx], right_data[ridx]);
-			}
-		}
-	}
-}
-
-/*
-SQL AND Rules:
-
-TRUE  AND TRUE   = TRUE
-TRUE  AND FALSE  = FALSE
-TRUE  AND NULL   = NULL
-FALSE AND TRUE   = FALSE
-FALSE AND FALSE  = FALSE
-FALSE AND NULL   = FALSE
-NULL  AND TRUE   = NULL
-NULL  AND FALSE  = FALSE
-NULL  AND NULL   = NULL
-
-Basically:
-- Only true if both are true
-- False if either is false (regardless of NULLs)
-- NULL otherwise
-*/
-struct TernaryAnd {
-	static bool SimpleOperation(bool left, bool right) {
-		return left && right;
-	}
-	static bool Operation(bool left, bool right, bool left_null, bool right_null, bool &result) {
-		if (left_null && right_null) {
-			// both NULL:
-			// result is NULL
-			return true;
-		} else if (left_null) {
-			// left is NULL:
-			// result is FALSE if right is false
-			// result is NULL if right is true
-			result = right;
-			return right;
-		} else if (right_null) {
-			// right is NULL:
-			// result is FALSE if left is false
-			// result is NULL if left is true
-			result = left;
-			return left;
-		} else {
-			// no NULL: perform the AND
-			result = left && right;
-			return false;
-		}
-	}
-};
-
-void VectorOperations::And(Vector &left, Vector &right, Vector &result, idx_t count) {
-	TemplatedBooleanNullmask<TernaryAnd>(left, right, result, count);
-}
-
-/*
-SQL OR Rules:
-
-OR
-TRUE  OR TRUE  = TRUE
-TRUE  OR FALSE = TRUE
-TRUE  OR NULL  = TRUE
-FALSE OR TRUE  = TRUE
-FALSE OR FALSE = FALSE
-FALSE OR NULL  = NULL
-NULL  OR TRUE  = TRUE
-NULL  OR FALSE = NULL
-NULL  OR NULL  = NULL
-
-Basically:
-- Only false if both are false
-- True if either is true (regardless of NULLs)
-- NULL otherwise
-*/
-
-struct TernaryOr {
-	static bool SimpleOperation(bool left, bool right) {
-		return left || right;
-	}
-	static bool Operation(bool left, bool right, bool left_null, bool right_null, bool &result) {
-		if (left_null && right_null) {
-			// both NULL:
-			// result is NULL
-			return true;
-		} else if (left_null) {
-			// left is NULL:
-			// result is TRUE if right is true
-			// result is NULL if right is false
-			result = right;
-			return !right;
-		} else if (right_null) {
-			// right is NULL:
-			// result is TRUE if left is true
-			// result is NULL if left is false
-			result = left;
-			return !left;
-		} else {
-			// no NULL: perform the OR
-			result = left || right;
-			return false;
-		}
-	}
-};
-
-void VectorOperations::Or(Vector &left, Vector &right, Vector &result, idx_t count) {
-	TemplatedBooleanNullmask<TernaryOr>(left, right, result, count);
-}
-
-struct NotOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return !left;
-	}
-};
-
-void VectorOperations::Not(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType() == LogicalType::BOOLEAN && result.GetType() == LogicalType::BOOLEAN);
-	UnaryExecutor::Execute<bool, bool, NotOperator>(input, result, count);
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// comparison_operators.cpp
-// Description: This file contains the implementation of the comparison
-// operations == != >= <= > <
-//===--------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-bool EqualsFloat(T left, T right) {
-	if (DUCKDB_UNLIKELY(Value::IsNan(left) && Value::IsNan(right))) {
-		return true;
-	}
-	return left == right;
-}
-
-template <>
-bool Equals::Operation(float left, float right) {
-	return EqualsFloat<float>(left, right);
-}
-
-template <>
-bool Equals::Operation(double left, double right) {
-	return EqualsFloat<double>(left, right);
-}
-
-template <class T>
-bool GreaterThanFloat(T left, T right) {
-	// handle nans
-	// nan is always bigger than everything else
-	bool left_is_nan = Value::IsNan(left);
-	bool right_is_nan = Value::IsNan(right);
-	// if right is nan, there is no number that is bigger than right
-	if (DUCKDB_UNLIKELY(right_is_nan)) {
-		return false;
-	}
-	// if left is nan, but right is not, left is always bigger
-	if (DUCKDB_UNLIKELY(left_is_nan)) {
-		return true;
-	}
-	return left > right;
-}
-
-template <>
-bool GreaterThan::Operation(float left, float right) {
-	return GreaterThanFloat<float>(left, right);
-}
-
-template <>
-bool GreaterThan::Operation(double left, double right) {
-	return GreaterThanFloat<double>(left, right);
-}
-
-template <class T>
-bool GreaterThanEqualsFloat(T left, T right) {
-	// handle nans
-	// nan is always bigger than everything else
-	bool left_is_nan = Value::IsNan(left);
-	bool right_is_nan = Value::IsNan(right);
-	// if right is nan, there is no bigger number
-	// we only return true if left is also nan (in which case the numbers are equal)
-	if (DUCKDB_UNLIKELY(right_is_nan)) {
-		return left_is_nan;
-	}
-	// if left is nan, but right is not, left is always bigger
-	if (DUCKDB_UNLIKELY(left_is_nan)) {
-		return true;
-	}
-	return left >= right;
-}
-
-template <>
-bool GreaterThanEquals::Operation(float left, float right) {
-	return GreaterThanEqualsFloat<float>(left, right);
-}
-
-template <>
-bool GreaterThanEquals::Operation(double left, double right) {
-	return GreaterThanEqualsFloat<double>(left, right);
-}
-
-struct ComparisonSelector {
-	template <typename OP>
-	static idx_t Select(Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-	                    SelectionVector *false_sel) {
-		throw NotImplementedException("Unknown comparison operation!");
-	}
-};
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::Equals>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                        idx_t count, SelectionVector *true_sel,
-                                                        SelectionVector *false_sel) {
-	return VectorOperations::Equals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::NotEquals>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                           idx_t count, SelectionVector *true_sel,
-                                                           SelectionVector *false_sel) {
-	return VectorOperations::NotEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::GreaterThan>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                             idx_t count, SelectionVector *true_sel,
-                                                             SelectionVector *false_sel) {
-	return VectorOperations::GreaterThan(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &right,
-                                                                   const SelectionVector *sel, idx_t count,
-                                                                   SelectionVector *true_sel,
-                                                                   SelectionVector *false_sel) {
-	return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::LessThan>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                          idx_t count, SelectionVector *true_sel,
-                                                          SelectionVector *false_sel) {
-	return VectorOperations::LessThan(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-inline idx_t ComparisonSelector::Select<duckdb::LessThanEquals>(Vector &left, Vector &right, const SelectionVector *sel,
-                                                                idx_t count, SelectionVector *true_sel,
-                                                                SelectionVector *false_sel) {
-	return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-static void ComparesNotNull(VectorData &ldata, VectorData &rdata, ValidityMask &vresult, idx_t count) {
-	for (idx_t i = 0; i < count; ++i) {
-		auto lidx = ldata.sel->get_index(i);
-		auto ridx = rdata.sel->get_index(i);
-		if (!ldata.validity.RowIsValid(lidx) || !rdata.validity.RowIsValid(ridx)) {
-			vresult.SetInvalid(i);
-		}
-	}
-}
-
-template <typename OP>
-static void NestedComparisonExecutor(Vector &left, Vector &right, Vector &result, idx_t count) {
-	const auto left_constant = left.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	const auto right_constant = right.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-	if ((left_constant && ConstantVector::IsNull(left)) || (right_constant && ConstantVector::IsNull(right))) {
-		// either left or right is constant NULL: result is constant NULL
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-
-	if (left_constant && right_constant) {
-		// both sides are constant, and neither is NULL so just compare one element.
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		SelectionVector true_sel(1);
-		auto match_count = ComparisonSelector::Select<OP>(left, right, nullptr, 1, &true_sel, nullptr);
-		auto result_data = ConstantVector::GetData<bool>(result);
-		result_data[0] = match_count > 0;
-		return;
-	}
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<bool>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	VectorData leftv, rightv;
-	left.Orrify(count, leftv);
-	right.Orrify(count, rightv);
-	if (!leftv.validity.AllValid() || !rightv.validity.AllValid()) {
-		ComparesNotNull(leftv, rightv, result_validity, count);
-	}
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-	idx_t match_count = ComparisonSelector::Select<OP>(left, right, nullptr, count, &true_sel, &false_sel);
-
-	for (idx_t i = 0; i < match_count; ++i) {
-		const auto idx = true_sel.get_index(i);
-		result_data[idx] = true;
-	}
-
-	const idx_t no_match_count = count - match_count;
-	for (idx_t i = 0; i < no_match_count; ++i) {
-		const auto idx = false_sel.get_index(i);
-		result_data[idx] = false;
-	}
-}
-
-struct ComparisonExecutor {
-private:
-	template <class T, class OP>
-	static inline void TemplatedExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		BinaryExecutor::Execute<T, T, bool, OP>(left, right, result, count);
-	}
-
-public:
-	template <class OP>
-	static inline void Execute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		D_ASSERT(left.GetType() == right.GetType() && result.GetType() == LogicalType::BOOLEAN);
-		// the inplace loops take the result as the last parameter
-		switch (left.GetType().InternalType()) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-			TemplatedExecute<int8_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INT16:
-			TemplatedExecute<int16_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INT32:
-			TemplatedExecute<int32_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INT64:
-			TemplatedExecute<int64_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT8:
-			TemplatedExecute<uint8_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT16:
-			TemplatedExecute<uint16_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT32:
-			TemplatedExecute<uint32_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::UINT64:
-			TemplatedExecute<uint64_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INT128:
-			TemplatedExecute<hugeint_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::FLOAT:
-			TemplatedExecute<float, OP>(left, right, result, count);
-			break;
-		case PhysicalType::DOUBLE:
-			TemplatedExecute<double, OP>(left, right, result, count);
-			break;
-		case PhysicalType::INTERVAL:
-			TemplatedExecute<interval_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::VARCHAR:
-			TemplatedExecute<string_t, OP>(left, right, result, count);
-			break;
-		case PhysicalType::LIST:
-		case PhysicalType::MAP:
-		case PhysicalType::STRUCT:
-			NestedComparisonExecutor<OP>(left, right, result, count);
-			break;
-		default:
-			throw InternalException("Invalid type for comparison");
-		}
-	}
-};
-
-void VectorOperations::Equals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::Equals>(left, right, result, count);
-}
-
-void VectorOperations::NotEquals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::NotEquals>(left, right, result, count);
-}
-
-void VectorOperations::GreaterThanEquals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::GreaterThanEquals>(left, right, result, count);
-}
-
-void VectorOperations::LessThanEquals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::LessThanEquals>(left, right, result, count);
-}
-
-void VectorOperations::GreaterThan(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::GreaterThan>(left, right, result, count);
-}
-
-void VectorOperations::LessThan(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::LessThan>(left, right, result, count);
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// generators.cpp
-// Description: This file contains the implementation of different generators
-//===--------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-void TemplatedGenerateSequence(Vector &result, idx_t count, int64_t start, int64_t increment) {
-	D_ASSERT(result.GetType().IsNumeric());
-	if (start > NumericLimits<T>::Maximum() || increment > NumericLimits<T>::Maximum()) {
-		throw Exception("Sequence start or increment out of type range");
-	}
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<T>(result);
-	auto value = (T)start;
-	for (idx_t i = 0; i < count; i++) {
-		if (i > 0) {
-			value += increment;
-		}
-		result_data[i] = value;
-	}
-}
-
-void VectorOperations::GenerateSequence(Vector &result, idx_t count, int64_t start, int64_t increment) {
-	if (!result.GetType().IsNumeric()) {
-		throw InvalidTypeException(result.GetType(), "Can only generate sequences for numeric values!");
-	}
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		TemplatedGenerateSequence<int8_t>(result, count, start, increment);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGenerateSequence<int16_t>(result, count, start, increment);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGenerateSequence<int32_t>(result, count, start, increment);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGenerateSequence<int64_t>(result, count, start, increment);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedGenerateSequence<float>(result, count, start, increment);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGenerateSequence<double>(result, count, start, increment);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for generate sequence");
-	}
-}
-
-template <class T>
-void TemplatedGenerateSequence(Vector &result, idx_t count, const SelectionVector &sel, int64_t start,
-                               int64_t increment) {
-	D_ASSERT(result.GetType().IsNumeric());
-	if (start > NumericLimits<T>::Maximum() || increment > NumericLimits<T>::Maximum()) {
-		throw Exception("Sequence start or increment out of type range");
-	}
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<T>(result);
-	auto value = (T)start;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		result_data[idx] = value + increment * idx;
-	}
-}
-
-void VectorOperations::GenerateSequence(Vector &result, idx_t count, const SelectionVector &sel, int64_t start,
-                                        int64_t increment) {
-	if (!result.GetType().IsNumeric()) {
-		throw InvalidTypeException(result.GetType(), "Can only generate sequences for numeric values!");
-	}
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		TemplatedGenerateSequence<int8_t>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGenerateSequence<int16_t>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGenerateSequence<int32_t>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGenerateSequence<int64_t>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedGenerateSequence<float>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGenerateSequence<double>(result, count, sel, start, increment);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for generate sequence");
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct DistinctBinaryLambdaWrapper {
-	template <class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(LEFT_TYPE left, RIGHT_TYPE right, bool is_left_null, bool is_right_null) {
-		return OP::template Operation<LEFT_TYPE>(left, right, is_left_null, is_right_null);
-	}
-};
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                       RESULT_TYPE *__restrict result_data, const SelectionVector *__restrict lsel,
-                                       const SelectionVector *__restrict rsel, idx_t count, ValidityMask &lmask,
-                                       ValidityMask &rmask, ValidityMask &result_mask) {
-	for (idx_t i = 0; i < count; i++) {
-		auto lindex = lsel->get_index(i);
-		auto rindex = rsel->get_index(i);
-		auto lentry = ldata[lindex];
-		auto rentry = rdata[rindex];
-		result_data[i] =
-		    OP::template Operation<LEFT_TYPE>(lentry, rentry, !lmask.RowIsValid(lindex), !rmask.RowIsValid(rindex));
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteConstant(Vector &left, Vector &right, Vector &result) {
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-	auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
-	auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
-	auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
-	*result_data =
-	    OP::template Operation<LEFT_TYPE>(*ldata, *rdata, ConstantVector::IsNull(left), ConstantVector::IsNull(right));
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteGeneric(Vector &left, Vector &right, Vector &result, idx_t count) {
-	if (left.GetVectorType() == VectorType::CONSTANT_VECTOR && right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		DistinctExecuteConstant<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(left, right, result);
-	} else {
-		VectorData ldata, rdata;
-
-		left.Orrify(count, ldata);
-		right.Orrify(count, rdata);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-		DistinctExecuteGenericLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(
-		    (LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data, result_data, ldata.sel, rdata.sel, count, ldata.validity,
-		    rdata.validity, FlatVector::Validity(result));
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteSwitch(Vector &left, Vector &right, Vector &result, idx_t count) {
-	DistinctExecuteGeneric<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(left, right, result, count);
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-	DistinctExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(left, right, result, count);
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-static inline idx_t
-DistinctSelectGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                          const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-                          const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
-                          ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-	idx_t true_count = 0, false_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto result_idx = result_sel->get_index(i);
-		auto lindex = lsel->get_index(i);
-		auto rindex = rsel->get_index(i);
-		if (NO_NULL) {
-			if (OP::Operation(ldata[lindex], rdata[rindex], false, false)) {
-				if (HAS_TRUE_SEL) {
-					true_sel->set_index(true_count++, result_idx);
-				}
-			} else {
-				if (HAS_FALSE_SEL) {
-					false_sel->set_index(false_count++, result_idx);
-				}
-			}
-		} else {
-			if (OP::Operation(ldata[lindex], rdata[rindex], !lmask.RowIsValid(lindex), !rmask.RowIsValid(rindex))) {
-				if (HAS_TRUE_SEL) {
-					true_sel->set_index(true_count++, result_idx);
-				}
-			} else {
-				if (HAS_FALSE_SEL) {
-					false_sel->set_index(false_count++, result_idx);
-				}
-			}
-		}
-	}
-	if (HAS_TRUE_SEL) {
-		return true_count;
-	} else {
-		return count - false_count;
-	}
-}
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL>
-static inline idx_t
-DistinctSelectGenericLoopSelSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                   const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-                                   const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
-                                   ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (true_sel && false_sel) {
-		return DistinctSelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, true>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	} else if (true_sel) {
-		return DistinctSelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, false>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	} else {
-		D_ASSERT(false_sel);
-		return DistinctSelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, false, true>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-static inline idx_t
-DistinctSelectGenericLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-                                const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
-                                ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (!lmask.AllValid() || !rmask.AllValid()) {
-		return DistinctSelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, false>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	} else {
-		return DistinctSelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, true>(
-		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-static idx_t DistinctSelectGeneric(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-	VectorData ldata, rdata;
-
-	left.Orrify(count, ldata);
-	right.Orrify(count, rdata);
-
-	return DistinctSelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>((LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data,
-	                                                                  ldata.sel, rdata.sel, sel, count, ldata.validity,
-	                                                                  rdata.validity, true_sel, false_sel);
-}
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool NO_NULL,
-          bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-static inline idx_t DistinctSelectFlatLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                           const SelectionVector *sel, idx_t count, ValidityMask &lmask,
-                                           ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-	idx_t true_count = 0, false_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t result_idx = sel->get_index(i);
-		idx_t lidx = LEFT_CONSTANT ? 0 : i;
-		idx_t ridx = RIGHT_CONSTANT ? 0 : i;
-		const bool lnull = !lmask.RowIsValid(lidx);
-		const bool rnull = !rmask.RowIsValid(ridx);
-		bool comparison_result = OP::Operation(ldata[lidx], rdata[ridx], lnull, rnull);
-		if (HAS_TRUE_SEL) {
-			true_sel->set_index(true_count, result_idx);
-			true_count += comparison_result;
-		}
-		if (HAS_FALSE_SEL) {
-			false_sel->set_index(false_count, result_idx);
-			false_count += !comparison_result;
-		}
-	}
-	if (HAS_TRUE_SEL) {
-		return true_count;
-	} else {
-		return count - false_count;
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool NO_NULL>
-static inline idx_t DistinctSelectFlatLoopSelSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                                    const SelectionVector *sel, idx_t count, ValidityMask &lmask,
-                                                    ValidityMask &rmask, SelectionVector *true_sel,
-                                                    SelectionVector *false_sel) {
-	if (true_sel && false_sel) {
-		return DistinctSelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, NO_NULL, true, true>(
-		    ldata, rdata, sel, count, lmask, rmask, true_sel, false_sel);
-	} else if (true_sel) {
-		return DistinctSelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, NO_NULL, true, false>(
-		    ldata, rdata, sel, count, lmask, rmask, true_sel, false_sel);
-	} else {
-		D_ASSERT(false_sel);
-		return DistinctSelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, NO_NULL, false, true>(
-		    ldata, rdata, sel, count, lmask, rmask, true_sel, false_sel);
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-static inline idx_t DistinctSelectFlatLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-                                                 const SelectionVector *sel, idx_t count, ValidityMask &lmask,
-                                                 ValidityMask &rmask, SelectionVector *true_sel,
-                                                 SelectionVector *false_sel) {
-	return DistinctSelectFlatLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, true>(
-	    ldata, rdata, sel, count, lmask, rmask, true_sel, false_sel);
-}
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-static idx_t DistinctSelectFlat(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                SelectionVector *true_sel, SelectionVector *false_sel) {
-	auto ldata = FlatVector::GetData<LEFT_TYPE>(left);
-	auto rdata = FlatVector::GetData<RIGHT_TYPE>(right);
-	if (LEFT_CONSTANT) {
-		ValidityMask validity;
-		if (ConstantVector::IsNull(left)) {
-			validity.SetAllInvalid(1);
-		}
-		return DistinctSelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-		    ldata, rdata, sel, count, validity, FlatVector::Validity(right), true_sel, false_sel);
-	} else if (RIGHT_CONSTANT) {
-		ValidityMask validity;
-		if (ConstantVector::IsNull(right)) {
-			validity.SetAllInvalid(1);
-		}
-		return DistinctSelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-		    ldata, rdata, sel, count, FlatVector::Validity(left), validity, true_sel, false_sel);
-	} else {
-		return DistinctSelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-		    ldata, rdata, sel, count, FlatVector::Validity(left), FlatVector::Validity(right), true_sel, false_sel);
-	}
-}
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-static idx_t DistinctSelectConstant(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
-	auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
-
-	// both sides are constant, return either 0 or the count
-	// in this case we do not fill in the result selection vector at all
-	if (!OP::Operation(*ldata, *rdata, ConstantVector::IsNull(left), ConstantVector::IsNull(right))) {
-		if (false_sel) {
-			for (idx_t i = 0; i < count; i++) {
-				false_sel->set_index(i, sel->get_index(i));
-			}
-		}
-		return 0;
-	} else {
-		if (true_sel) {
-			for (idx_t i = 0; i < count; i++) {
-				true_sel->set_index(i, sel->get_index(i));
-			}
-		}
-		return count;
-	}
-}
-
-template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-static idx_t DistinctSelect(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                            SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-	if (left.GetVectorType() == VectorType::CONSTANT_VECTOR && right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		return DistinctSelectConstant<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
-	} else if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-	           right.GetVectorType() == VectorType::FLAT_VECTOR) {
-		return DistinctSelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, true, false>(left, right, sel, count, true_sel, false_sel);
-	} else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
-	           right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		return DistinctSelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, true>(left, right, sel, count, true_sel, false_sel);
-	} else if (left.GetVectorType() == VectorType::FLAT_VECTOR && right.GetVectorType() == VectorType::FLAT_VECTOR) {
-		return DistinctSelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, false>(left, right, sel, count, true_sel,
-		                                                                   false_sel);
-	} else {
-		return DistinctSelectGeneric<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
-	}
-}
-
-template <class OP>
-static idx_t DistinctSelectNotNull(Vector &left, Vector &right, const idx_t count, idx_t &true_count,
-                                   const SelectionVector &sel, SelectionVector &maybe_vec, OptionalSelection &true_opt,
-                                   OptionalSelection &false_opt) {
-	VectorData lvdata, rvdata;
-	left.Orrify(count, lvdata);
-	right.Orrify(count, rvdata);
-
-	auto &lmask = lvdata.validity;
-	auto &rmask = rvdata.validity;
-
-	idx_t remaining = 0;
-	if (lmask.AllValid() && rmask.AllValid()) {
-		//	None are NULL, distinguish values.
-		for (idx_t i = 0; i < count; ++i) {
-			const auto idx = sel.get_index(i);
-			maybe_vec.set_index(remaining++, idx);
-		}
-		return remaining;
-	}
-
-	// Slice the Vectors down to the rows that are not determined (i.e., neither is NULL)
-	SelectionVector slicer(count);
-	true_count = 0;
-	idx_t false_count = 0;
-	for (idx_t i = 0; i < count; ++i) {
-		const auto result_idx = sel.get_index(i);
-		const auto lidx = lvdata.sel->get_index(i);
-		const auto ridx = rvdata.sel->get_index(i);
-		const auto lnull = !lmask.RowIsValid(lidx);
-		const auto rnull = !rmask.RowIsValid(ridx);
-		if (lnull || rnull) {
-			// If either is NULL then we can major distinguish them
-			if (!OP::Operation(false, false, lnull, rnull)) {
-				false_opt.Append(false_count, result_idx);
-			} else {
-				true_opt.Append(true_count, result_idx);
-			}
-		} else {
-			//	Neither is NULL, distinguish values.
-			slicer.set_index(remaining, i);
-			maybe_vec.set_index(remaining++, result_idx);
-		}
-	}
-
-	true_opt.Advance(true_count);
-	false_opt.Advance(false_count);
-
-	if (remaining && remaining < count) {
-		left.Slice(slicer, remaining);
-		right.Slice(slicer, remaining);
-	}
-
-	return remaining;
-}
-
-struct PositionComparator {
-	// Select the rows that definitely match.
-	// Default to the same as the final row
-	template <typename OP>
-	static idx_t Definite(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-	                      SelectionVector *true_sel, SelectionVector &false_sel) {
-		return Final<OP>(left, right, sel, count, true_sel, &false_sel);
-	}
-
-	// Select the possible rows that need further testing.
-	// Usually this means Is Not Distinct, as those are the semantics used by Postges
-	template <typename OP>
-	static idx_t Possible(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-	                      SelectionVector &true_sel, SelectionVector *false_sel) {
-		return VectorOperations::NestedEquals(left, right, sel, count, &true_sel, false_sel);
-	}
-
-	// Select the matching rows for the final position.
-	// This needs to be specialised.
-	template <typename OP>
-	static idx_t Final(Vector &left, Vector &right, const SelectionVector &sel, idx_t count, SelectionVector *true_sel,
-	                   SelectionVector *false_sel) {
-		return 0;
-	}
-
-	// Tie-break based on length when one of the sides has been exhausted, returning true if the LHS matches.
-	// This essentially means that the existing positions compare equal.
-	// Default to the same semantics as the OP for idx_t. This works in most cases.
-	template <typename OP>
-	static bool TieBreak(const idx_t lpos, const idx_t rpos) {
-		return OP::Operation(lpos, rpos, false, false);
-	}
-};
-
-// NotDistinctFrom must always check every column
-template <>
-idx_t PositionComparator::Definite<duckdb::NotDistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                            idx_t count, SelectionVector *true_sel,
-                                                            SelectionVector &false_sel) {
-	return 0;
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::NotDistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                         idx_t count, SelectionVector *true_sel,
-                                                         SelectionVector *false_sel) {
-	return VectorOperations::NestedEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-// DistinctFrom must check everything that matched
-template <>
-idx_t PositionComparator::Possible<duckdb::DistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                         idx_t count, SelectionVector &true_sel,
-                                                         SelectionVector *false_sel) {
-	return count;
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctFrom>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                      idx_t count, SelectionVector *true_sel,
-                                                      SelectionVector *false_sel) {
-	return VectorOperations::NestedNotEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-// Non-strict inequalities must use strict comparisons for Definite
-template <>
-idx_t PositionComparator::Definite<duckdb::DistinctLessThanEquals>(Vector &left, Vector &right,
-                                                                   const SelectionVector &sel, idx_t count,
-                                                                   SelectionVector *true_sel,
-                                                                   SelectionVector &false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, &false_sel);
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctLessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                                idx_t count, SelectionVector *true_sel,
-                                                                SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t PositionComparator::Definite<duckdb::DistinctGreaterThanEquals>(Vector &left, Vector &right,
-                                                                      const SelectionVector &sel, idx_t count,
-                                                                      SelectionVector *true_sel,
-                                                                      SelectionVector &false_sel) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, &false_sel);
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctGreaterThanEquals>(Vector &left, Vector &right,
-                                                                   const SelectionVector &sel, idx_t count,
-                                                                   SelectionVector *true_sel,
-                                                                   SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-// Strict inequalities just use strict for both Definite and Final
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctLessThan>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                          idx_t count, SelectionVector *true_sel,
-                                                          SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t PositionComparator::Final<duckdb::DistinctGreaterThan>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                             idx_t count, SelectionVector *true_sel,
-                                                             SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-using StructEntries = vector<unique_ptr<Vector>>;
-
-static void ExtractNestedSelection(const SelectionVector &slice_sel, const idx_t count, const SelectionVector &sel,
-                                   OptionalSelection &opt) {
-
-	for (idx_t i = 0; i < count;) {
-		const auto slice_idx = slice_sel.get_index(i);
-		const auto result_idx = sel.get_index(slice_idx);
-		opt.Append(i, result_idx);
-	}
-	opt.Advance(count);
-}
-
-static void DensifyNestedSelection(const SelectionVector &dense_sel, const idx_t count, SelectionVector &slice_sel) {
-	for (idx_t i = 0; i < count; ++i) {
-		slice_sel.set_index(i, dense_sel.get_index(i));
-	}
-}
-
-template <class OP>
-static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t count, const SelectionVector &sel,
-                                  OptionalSelection &true_opt, OptionalSelection &false_opt) {
-	if (count == 0) {
-		return 0;
-	}
-
-	// Avoid allocating in the 99% of the cases where we don't need to.
-	StructEntries lsliced, rsliced;
-	auto &lchildren = StructVector::GetEntries(left);
-	auto &rchildren = StructVector::GetEntries(right);
-	D_ASSERT(lchildren.size() == rchildren.size());
-
-	// In order to reuse the comparators, we have to track what passed and failed internally.
-	// To do that, we need local SVs that we then merge back into the real ones after every pass.
-	const auto vcount = count;
-	SelectionVector slice_sel(count);
-	for (idx_t i = 0; i < count; ++i) {
-		slice_sel.set_index(i, i);
-	}
-
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-
-	idx_t match_count = 0;
-	for (idx_t col_no = 0; col_no < lchildren.size(); ++col_no) {
-		// Slice the children to maintain density
-		Vector lchild(*lchildren[col_no]);
-		lchild.Normalify(vcount);
-		lchild.Slice(slice_sel, count);
-
-		Vector rchild(*rchildren[col_no]);
-		rchild.Normalify(vcount);
-		rchild.Slice(slice_sel, count);
-
-		// Find everything that definitely matches
-		auto true_count = PositionComparator::Definite<OP>(lchild, rchild, slice_sel, count, &true_sel, false_sel);
-		if (true_count > 0) {
-			auto false_count = count - true_count;
-
-			// Extract the definite matches into the true result
-			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
-
-			// Remove the definite matches from the slicing vector
-			DensifyNestedSelection(false_sel, false_count, slice_sel);
-
-			match_count += true_count;
-			count -= true_count;
-		}
-
-		if (col_no != lchildren.size() - 1) {
-			// Find what might match on the next position
-			true_count = PositionComparator::Possible<OP>(lchild, rchild, slice_sel, count, true_sel, &false_sel);
-			auto false_count = count - true_count;
-
-			// Extract the definite failures into the false result
-			ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
-
-			// Remove any definite failures from the slicing vector
-			if (false_count) {
-				DensifyNestedSelection(true_sel, true_count, slice_sel);
-			}
-
-			count = true_count;
-		} else {
-			true_count = PositionComparator::Final<OP>(lchild, rchild, slice_sel, count, &true_sel, &false_sel);
-			auto false_count = count - true_count;
-
-			// Extract the definite matches into the true result
-			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
-
-			// Extract the definite failures into the false result
-			ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
-
-			match_count += true_count;
-		}
-	}
-	return match_count;
-}
-
-static void PositionListCursor(SelectionVector &cursor, VectorData &vdata, const idx_t pos,
-                               const SelectionVector &slice_sel, const idx_t count) {
-	const auto data = (const list_entry_t *)vdata.data;
-	for (idx_t i = 0; i < count; ++i) {
-		const auto slice_idx = slice_sel.get_index(i);
-
-		const auto lidx = vdata.sel->get_index(slice_idx);
-		const auto &entry = data[lidx];
-		cursor.set_index(i, entry.offset + pos);
-	}
-}
-
-template <class OP>
-static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const SelectionVector &sel,
-                                OptionalSelection &true_opt, OptionalSelection &false_opt) {
-	if (count == 0) {
-		return count;
-	}
-
-	// Create dictionary views of the children so we can vectorise the positional comparisons.
-	SelectionVector lcursor(count);
-	SelectionVector rcursor(count);
-
-	ListVector::GetEntry(left).Normalify(count);
-	ListVector::GetEntry(right).Normalify(count);
-	Vector lchild(ListVector::GetEntry(left), lcursor, count);
-	Vector rchild(ListVector::GetEntry(right), rcursor, count);
-
-	// To perform the positional comparison, we use a vectorisation of the following algorithm:
-	// bool CompareLists(T *left, idx_t nleft, T *right, nright) {
-	// 	for (idx_t pos = 0; ; ++pos) {
-	// 		if (nleft == pos || nright == pos)
-	// 			return OP::TieBreak(nleft, nright);
-	// 		if (OP::Definite(*left, *right))
-	// 			return true;
-	// 		if (!OP::Maybe(*left, *right))
-	// 			return false;
-	// 		}
-	//	 	++left, ++right;
-	// 	}
-	// }
-
-	// Get pointers to the list entries
-	VectorData lvdata;
-	left.Orrify(count, lvdata);
-	const auto ldata = (const list_entry_t *)lvdata.data;
-
-	VectorData rvdata;
-	right.Orrify(count, rvdata);
-	const auto rdata = (const list_entry_t *)rvdata.data;
-
-	// In order to reuse the comparators, we have to track what passed and failed internally.
-	// To do that, we need local SVs that we then merge back into the real ones after every pass.
-	SelectionVector slice_sel(count);
-	for (idx_t i = 0; i < count; ++i) {
-		slice_sel.set_index(i, i);
-	}
-
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-
-	idx_t match_count = 0;
-	for (idx_t pos = 0; count > 0; ++pos) {
-		// Set up the cursors for the current position
-		PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
-		PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
-
-		// Tie-break the pairs where one of the LISTs is exhausted.
-		idx_t true_count = 0;
-		idx_t false_count = 0;
-		idx_t maybe_count = 0;
-		for (idx_t i = 0; i < count; ++i) {
-			const auto slice_idx = slice_sel.get_index(i);
-			const auto lidx = lvdata.sel->get_index(slice_idx);
-			const auto &lentry = ldata[lidx];
-			const auto ridx = rvdata.sel->get_index(slice_idx);
-			const auto &rentry = rdata[ridx];
-			if (lentry.length == pos || rentry.length == pos) {
-				const auto idx = sel.get_index(slice_idx);
-				if (PositionComparator::TieBreak<OP>(lentry.length, rentry.length)) {
-					true_opt.Append(true_count, idx);
-				} else {
-					false_opt.Append(false_count, idx);
-				}
-			} else {
-				true_sel.set_index(maybe_count++, slice_idx);
-			}
-		}
-		true_opt.Advance(true_count);
-		false_opt.Advance(false_count);
-		match_count += true_count;
-
-		// Redensify the list cursors
-		if (maybe_count < count) {
-			count = maybe_count;
-			DensifyNestedSelection(true_sel, count, slice_sel);
-			PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
-			PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
-		}
-
-		// Find everything that definitely matches
-		true_count = PositionComparator::Definite<OP>(lchild, rchild, slice_sel, count, &true_sel, false_sel);
-		if (true_count) {
-			false_count = count - true_count;
-			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
-			match_count += true_count;
-
-			// Redensify the list cursors
-			count -= true_count;
-			DensifyNestedSelection(false_sel, count, slice_sel);
-			PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
-			PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
-		}
-
-		// Find what might match on the next position
-		true_count = PositionComparator::Possible<OP>(lchild, rchild, slice_sel, count, true_sel, &false_sel);
-		false_count = count - true_count;
-		ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
-
-		if (false_count) {
-			DensifyNestedSelection(true_sel, true_count, slice_sel);
-		}
-		count = true_count;
-	}
-
-	return match_count;
-}
-
-template <class OP, class OPNESTED>
-static idx_t DistinctSelectNested(Vector &left, Vector &right, const SelectionVector *sel, const idx_t count,
-                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	// The Select operations all use a dense pair of input vectors to partition
-	// a selection vector in a single pass. But to implement progressive comparisons,
-	// we have to make multiple passes, so we need to keep track of the original input positions
-	// and then scatter the output selections when we are done.
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-
-	// Make buffered selections for progressive comparisons
-	// TODO: Remove unnecessary allocations
-	SelectionVector true_vec(count);
-	OptionalSelection true_opt(&true_vec);
-
-	SelectionVector false_vec(count);
-	OptionalSelection false_opt(&false_vec);
-
-	SelectionVector maybe_vec(count);
-
-	// Handle NULL nested values
-	Vector l_not_null(left);
-	Vector r_not_null(right);
-
-	idx_t match_count = 0;
-	auto unknown =
-	    DistinctSelectNotNull<OP>(l_not_null, r_not_null, count, match_count, *sel, maybe_vec, true_opt, false_opt);
-
-	if (PhysicalType::LIST == left.GetType().InternalType()) {
-		match_count += DistinctSelectList<OPNESTED>(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt);
-	} else {
-		match_count += DistinctSelectStruct<OPNESTED>(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt);
-	}
-
-	// Copy the buffered selections to the output selections
-	if (true_sel) {
-		DensifyNestedSelection(true_vec, match_count, *true_sel);
-	}
-
-	if (false_sel) {
-		DensifyNestedSelection(false_vec, count - match_count, *false_sel);
-	}
-
-	return match_count;
-}
-
-template <typename OP>
-static void NestedDistinctExecute(Vector &left, Vector &right, Vector &result, idx_t count);
-
-template <class T, class OP>
-static inline void TemplatedDistinctExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-	DistinctExecute<T, T, bool, OP>(left, right, result, count);
-}
-template <class OP>
-static void ExecuteDistinct(Vector &left, Vector &right, Vector &result, idx_t count) {
-	D_ASSERT(left.GetType() == right.GetType() && result.GetType() == LogicalType::BOOLEAN);
-	// the inplace loops take the result as the last parameter
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedDistinctExecute<int8_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedDistinctExecute<int16_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedDistinctExecute<int32_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedDistinctExecute<int64_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedDistinctExecute<uint8_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedDistinctExecute<uint16_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedDistinctExecute<uint32_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedDistinctExecute<uint64_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedDistinctExecute<hugeint_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedDistinctExecute<float, OP>(left, right, result, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedDistinctExecute<double, OP>(left, right, result, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedDistinctExecute<interval_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedDistinctExecute<string_t, OP>(left, right, result, count);
-		break;
-	case PhysicalType::LIST:
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-		NestedDistinctExecute<OP>(left, right, result, count);
-		break;
-	default:
-		throw InternalException("Invalid type for distinct comparison");
-	}
-}
-
-template <class OP, class OPNESTED = OP>
-static idx_t TemplatedDistinctSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                              SelectionVector *true_sel, SelectionVector *false_sel) {
-	// the inplace loops take the result as the last parameter
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return DistinctSelect<int8_t, int8_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INT16:
-		return DistinctSelect<int16_t, int16_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INT32:
-		return DistinctSelect<int32_t, int32_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INT64:
-		return DistinctSelect<int64_t, int64_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::UINT8:
-		return DistinctSelect<uint8_t, uint8_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::UINT16:
-		return DistinctSelect<uint16_t, uint16_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::UINT32:
-		return DistinctSelect<uint32_t, uint32_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::UINT64:
-		return DistinctSelect<uint64_t, uint64_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INT128:
-		return DistinctSelect<hugeint_t, hugeint_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::FLOAT:
-		return DistinctSelect<float, float, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::DOUBLE:
-		return DistinctSelect<double, double, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INTERVAL:
-		return DistinctSelect<interval_t, interval_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::VARCHAR:
-		return DistinctSelect<string_t, string_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-	case PhysicalType::LIST:
-		return DistinctSelectNested<OP, OPNESTED>(left, right, sel, count, true_sel, false_sel);
-	default:
-		throw InternalException("Invalid type for distinct selection");
-	}
-}
-
-template <typename OP>
-static void NestedDistinctExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-	const auto left_constant = left.GetVectorType() == VectorType::CONSTANT_VECTOR;
-	const auto right_constant = right.GetVectorType() == VectorType::CONSTANT_VECTOR;
-
-	if (left_constant && right_constant) {
-		// both sides are constant, so just compare one element.
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto result_data = ConstantVector::GetData<bool>(result);
-		SelectionVector true_sel(1);
-		auto match_count = TemplatedDistinctSelectOperation<OP>(left, right, nullptr, 1, &true_sel, nullptr);
-		result_data[0] = match_count > 0;
-		return;
-	}
-
-	SelectionVector true_sel(count);
-	SelectionVector false_sel(count);
-
-	// DISTINCT is either true or false
-	idx_t match_count = TemplatedDistinctSelectOperation<OP>(left, right, nullptr, count, &true_sel, &false_sel);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<bool>(result);
-
-	for (idx_t i = 0; i < match_count; ++i) {
-		const auto idx = true_sel.get_index(i);
-		result_data[idx] = true;
-	}
-
-	const idx_t no_match_count = count - match_count;
-	for (idx_t i = 0; i < no_match_count; ++i) {
-		const auto idx = false_sel.get_index(i);
-		result_data[idx] = false;
-	}
-}
-
-void VectorOperations::DistinctFrom(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ExecuteDistinct<duckdb::DistinctFrom>(left, right, result, count);
-}
-
-void VectorOperations::NotDistinctFrom(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ExecuteDistinct<duckdb::NotDistinctFrom>(left, right, result, count);
-}
-
-// true := A != B with nulls being equal
-idx_t VectorOperations::DistinctFrom(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                     SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctFrom>(left, right, sel, count, true_sel, false_sel);
-}
-// true := A == B with nulls being equal
-idx_t VectorOperations::NotDistinctFrom(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                        SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::NotDistinctFrom>(left, right, sel, count, true_sel, false_sel);
-}
-
-// true := A > B with nulls being maximal
-idx_t VectorOperations::DistinctGreaterThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                            SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan>(left, right, sel, count, true_sel, false_sel);
-}
-
-// true := A > B with nulls being minimal
-idx_t VectorOperations::DistinctGreaterThanNullsFirst(Vector &left, Vector &right, const SelectionVector *sel,
-                                                      idx_t count, SelectionVector *true_sel,
-                                                      SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanNullsFirst, duckdb::DistinctGreaterThan>(
-	    left, right, sel, count, true_sel, false_sel);
-}
-// true := A >= B with nulls being maximal
-idx_t VectorOperations::DistinctGreaterThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanEquals>(left, right, sel, count, true_sel,
-	                                                                           false_sel);
-}
-// true := A < B with nulls being maximal
-idx_t VectorOperations::DistinctLessThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                         SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThan>(left, right, sel, count, true_sel, false_sel);
-}
-
-// true := A < B with nulls being minimal
-idx_t VectorOperations::DistinctLessThanNullsFirst(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThanNullsFirst, duckdb::DistinctLessThan>(
-	    left, right, sel, count, true_sel, false_sel);
-}
-
-// true := A <= B with nulls being maximal
-idx_t VectorOperations::DistinctLessThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                               SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThanEquals>(left, right, sel, count, true_sel,
-	                                                                        false_sel);
-}
-
-// true := A != B with nulls being equal, inputs selected
-idx_t VectorOperations::NestedNotEquals(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                        SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctFrom>(left, right, &sel, count, true_sel, false_sel);
-}
-// true := A == B with nulls being equal, inputs selected
-idx_t VectorOperations::NestedEquals(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                     SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::NotDistinctFrom>(left, right, &sel, count, true_sel, false_sel);
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// null_operators.cpp
-// Description: This file contains the implementation of the
-// IS NULL/NOT IS NULL operators
-//===--------------------------------------------------------------------===//
-
-
-
-
-namespace duckdb {
-
-template <bool INVERSE>
-void IsNullLoop(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(result.GetType() == LogicalType::BOOLEAN);
-
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto result_data = ConstantVector::GetData<bool>(result);
-		*result_data = INVERSE ? !ConstantVector::IsNull(input) : ConstantVector::IsNull(input);
-	} else {
-		VectorData data;
-		input.Orrify(count, data);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<bool>(result);
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = data.sel->get_index(i);
-			result_data[i] = INVERSE ? data.validity.RowIsValid(idx) : !data.validity.RowIsValid(idx);
-		}
-	}
-}
-
-void VectorOperations::IsNotNull(Vector &input, Vector &result, idx_t count) {
-	IsNullLoop<true>(input, result, count);
-}
-
-void VectorOperations::IsNull(Vector &input, Vector &result, idx_t count) {
-	IsNullLoop<false>(input, result, count);
-}
-
-bool VectorOperations::HasNotNull(Vector &input, idx_t count) {
-	if (count == 0) {
-		return false;
-	}
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		return !ConstantVector::IsNull(input);
-	} else {
-		VectorData data;
-		input.Orrify(count, data);
-
-		if (data.validity.AllValid()) {
-			return true;
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = data.sel->get_index(i);
-			if (data.validity.RowIsValid(idx)) {
-				return true;
-			}
-		}
-		return false;
-	}
-}
-
-bool VectorOperations::HasNull(Vector &input, idx_t count) {
-	if (count == 0) {
-		return false;
-	}
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		return ConstantVector::IsNull(input);
-	} else {
-		VectorData data;
-		input.Orrify(count, data);
-
-		if (data.validity.AllValid()) {
-			return false;
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = data.sel->get_index(i);
-			if (!data.validity.RowIsValid(idx)) {
-				return true;
-			}
-		}
-		return false;
-	}
-}
-
-idx_t VectorOperations::CountNotNull(Vector &input, const idx_t count) {
-	idx_t valid = 0;
-
-	VectorData vdata;
-	input.Orrify(count, vdata);
-	if (vdata.validity.AllValid()) {
-		return count;
-	}
-	switch (input.GetVectorType()) {
-	case VectorType::FLAT_VECTOR:
-		valid += vdata.validity.CountValid(count);
-		break;
-	case VectorType::CONSTANT_VECTOR:
-		valid += vdata.validity.CountValid(1) * count;
-		break;
-	default:
-		for (idx_t i = 0; i < count; ++i) {
-			const auto row_idx = vdata.sel->get_index(i);
-			valid += int(vdata.validity.RowIsValid(row_idx));
-		}
-		break;
-	}
-
-	return valid;
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// numeric_inplace_operators.cpp
-// Description: This file contains the implementation of numeric inplace ops
-// += *= /= -= %=
-//===--------------------------------------------------------------------===//
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// In-Place Addition
-//===--------------------------------------------------------------------===//
-
-void VectorOperations::AddInPlace(Vector &input, int64_t right, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::POINTER);
-	if (right == 0) {
-		return;
-	}
-	switch (input.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR: {
-		D_ASSERT(!ConstantVector::IsNull(input));
-		auto data = ConstantVector::GetData<uintptr_t>(input);
-		*data += right;
-		break;
-	}
-	default: {
-		D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
-		auto data = FlatVector::GetData<uintptr_t>(input);
-		for (idx_t i = 0; i < count; i++) {
-			data[i] += right;
-		}
-		break;
-	}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class OP>
-struct VectorStringCastOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto result = (Vector *)dataptr;
-		return OP::template Operation<INPUT_TYPE>(input, *result);
-	}
-};
-
-struct VectorTryCastData {
-	VectorTryCastData(Vector &result_p, string *error_message_p, bool strict_p)
-	    : result(result_p), error_message(error_message_p), strict(strict_p) {
-	}
-
-	Vector &result;
-	string *error_message;
-	bool strict;
-	bool all_converted = true;
-};
-
-template <class OP>
-struct VectorTryCastOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output))) {
-			return output;
-		}
-		auto data = (VectorTryCastData *)dataptr;
-		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, data->error_message, data->all_converted);
-	}
-};
-
-template <class OP>
-struct VectorTryCastStrictOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (VectorTryCastData *)dataptr;
-		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->strict))) {
-			return output;
-		}
-		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, data->error_message, data->all_converted);
-	}
-};
-
-template <class OP>
-struct VectorTryCastErrorOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (VectorTryCastData *)dataptr;
-		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(
-		        OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->error_message, data->strict))) {
-			return output;
-		}
-		bool has_error = data->error_message && !data->error_message->empty();
-		return HandleVectorCastError::Operation<RESULT_TYPE>(
-		    has_error ? *data->error_message : CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask, idx,
-		    data->error_message, data->all_converted);
-	}
-};
-
-template <class OP>
-struct VectorTryCastStringOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (VectorTryCastData *)dataptr;
-		RESULT_TYPE output;
-		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->result,
-		                                                                  data->error_message, data->strict))) {
-			return output;
-		}
-		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
-		                                                     idx, data->error_message, data->all_converted);
-	}
-};
-
-template <class SRC, class DST, class OP>
-static bool TemplatedVectorTryCastLoop(Vector &source, Vector &result, idx_t count, bool strict,
-                                       string *error_message) {
-	VectorTryCastData input(result, error_message, strict);
-	UnaryExecutor::GenericExecute<SRC, DST, OP>(source, result, count, &input, error_message);
-	return input.all_converted;
-}
-
-template <class SRC, class DST, class OP>
-static bool VectorTryCastLoop(Vector &source, Vector &result, idx_t count, string *error_message) {
-	return TemplatedVectorTryCastLoop<SRC, DST, VectorTryCastOperator<OP>>(source, result, count, false, error_message);
-}
-
-template <class SRC, class DST, class OP>
-static bool VectorTryCastStrictLoop(Vector &source, Vector &result, idx_t count, bool strict, string *error_message) {
-	return TemplatedVectorTryCastLoop<SRC, DST, VectorTryCastStrictOperator<OP>>(source, result, count, strict,
-	                                                                             error_message);
-}
-
-template <class SRC, class DST, class OP>
-static bool VectorTryCastErrorLoop(Vector &source, Vector &result, idx_t count, bool strict, string *error_message) {
-	return TemplatedVectorTryCastLoop<SRC, DST, VectorTryCastErrorOperator<OP>>(source, result, count, strict,
-	                                                                            error_message);
-}
-
-template <class SRC, class DST, class OP>
-static bool VectorTryCastStringLoop(Vector &source, Vector &result, idx_t count, bool strict, string *error_message) {
-	return TemplatedVectorTryCastLoop<SRC, DST, VectorTryCastStringOperator<OP>>(source, result, count, strict,
-	                                                                             error_message);
-}
-
-template <class SRC, class OP>
-static void VectorStringCast(Vector &source, Vector &result, idx_t count) {
-	D_ASSERT(result.GetType().InternalType() == PhysicalType::VARCHAR);
-	UnaryExecutor::GenericExecute<SRC, string_t, VectorStringCastOperator<OP>>(source, result, count, (void *)&result);
-}
-
-template <class SRC>
-static bool NumericCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::BOOLEAN:
-		return VectorTryCastLoop<SRC, bool, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::TINYINT:
-		return VectorTryCastLoop<SRC, int8_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::SMALLINT:
-		return VectorTryCastLoop<SRC, int16_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::INTEGER:
-		return VectorTryCastLoop<SRC, int32_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::BIGINT:
-		return VectorTryCastLoop<SRC, int64_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::UTINYINT:
-		return VectorTryCastLoop<SRC, uint8_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::USMALLINT:
-		return VectorTryCastLoop<SRC, uint16_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::UINTEGER:
-		return VectorTryCastLoop<SRC, uint32_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::UBIGINT:
-		return VectorTryCastLoop<SRC, uint64_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::HUGEINT:
-		return VectorTryCastLoop<SRC, hugeint_t, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::FLOAT:
-		return VectorTryCastLoop<SRC, float, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::DOUBLE:
-		return VectorTryCastLoop<SRC, double, duckdb::NumericTryCast>(source, result, count, error_message);
-	case LogicalTypeId::DECIMAL:
-		return ToDecimalCast<SRC>(source, result, count, error_message);
-	case LogicalTypeId::JSON:
-	case LogicalTypeId::VARCHAR: {
-		VectorStringCast<SRC, duckdb::StringCast>(source, result, count);
-		return true;
-	}
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-template <class T>
-bool FillEnum(string_t *source_data, ValidityMask &source_mask, const LogicalType &source_type, T *result_data,
-              ValidityMask &result_mask, const LogicalType &result_type, idx_t count, string *error_message,
-              const SelectionVector *sel) {
-	bool all_converted = true;
-	for (idx_t i = 0; i < count; i++) {
-		idx_t source_idx = i;
-		if (sel) {
-			source_idx = sel->get_index(i);
-		}
-		if (source_mask.RowIsValid(source_idx)) {
-			auto string_value = source_data[source_idx].GetString();
-			auto pos = EnumType::GetPos(result_type, string_value);
-			if (pos == -1) {
-				result_data[i] =
-				    HandleVectorCastError::Operation<T>(CastExceptionText<string_t, T>(source_data[source_idx]),
-				                                        result_mask, i, error_message, all_converted);
-			} else {
-				result_data[i] = pos;
-			}
-		} else {
-			result_mask.SetInvalid(i);
-		}
-	}
-	return all_converted;
-}
-
-template <class T>
-bool TransformEnum(Vector &source, Vector &result, idx_t count, string *error_message) {
-	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
-	auto enum_name = EnumType::GetTypeName(result.GetType());
-	switch (source.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR: {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		auto source_data = ConstantVector::GetData<string_t>(source);
-		auto source_mask = ConstantVector::Validity(source);
-		auto result_data = ConstantVector::GetData<T>(result);
-		auto &result_mask = ConstantVector::Validity(result);
-
-		return FillEnum(source_data, source_mask, source.GetType(), result_data, result_mask, result.GetType(), 1,
-		                error_message, nullptr);
-	}
-	default: {
-		VectorData vdata;
-		source.Orrify(count, vdata);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-
-		auto source_data = (string_t *)vdata.data;
-		auto source_sel = vdata.sel;
-		auto source_mask = vdata.validity;
-		auto result_data = FlatVector::GetData<T>(result);
-		auto &result_mask = FlatVector::Validity(result);
-
-		return FillEnum(source_data, source_mask, source.GetType(), result_data, result_mask, result.GetType(), count,
-		                error_message, source_sel);
-	}
-	}
-}
-static bool VectorStringCastNumericSwitch(Vector &source, Vector &result, idx_t count, bool strict,
-                                          string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::ENUM: {
-		switch (result.GetType().InternalType()) {
-		case PhysicalType::UINT8:
-			return TransformEnum<uint8_t>(source, result, count, error_message);
-		case PhysicalType::UINT16:
-			return TransformEnum<uint16_t>(source, result, count, error_message);
-		case PhysicalType::UINT32:
-			return TransformEnum<uint32_t>(source, result, count, error_message);
-		default:
-			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-		}
-	}
-	case LogicalTypeId::BOOLEAN:
-		return VectorTryCastStrictLoop<string_t, bool, duckdb::TryCast>(source, result, count, strict, error_message);
-	case LogicalTypeId::TINYINT:
-		return VectorTryCastStrictLoop<string_t, int8_t, duckdb::TryCast>(source, result, count, strict, error_message);
-	case LogicalTypeId::SMALLINT:
-		return VectorTryCastStrictLoop<string_t, int16_t, duckdb::TryCast>(source, result, count, strict,
-		                                                                   error_message);
-	case LogicalTypeId::INTEGER:
-		return VectorTryCastStrictLoop<string_t, int32_t, duckdb::TryCast>(source, result, count, strict,
-		                                                                   error_message);
-	case LogicalTypeId::BIGINT:
-		return VectorTryCastStrictLoop<string_t, int64_t, duckdb::TryCast>(source, result, count, strict,
-		                                                                   error_message);
-	case LogicalTypeId::UTINYINT:
-		return VectorTryCastStrictLoop<string_t, uint8_t, duckdb::TryCast>(source, result, count, strict,
-		                                                                   error_message);
-	case LogicalTypeId::USMALLINT:
-		return VectorTryCastStrictLoop<string_t, uint16_t, duckdb::TryCast>(source, result, count, strict,
-		                                                                    error_message);
-	case LogicalTypeId::UINTEGER:
-		return VectorTryCastStrictLoop<string_t, uint32_t, duckdb::TryCast>(source, result, count, strict,
-		                                                                    error_message);
-	case LogicalTypeId::UBIGINT:
-		return VectorTryCastStrictLoop<string_t, uint64_t, duckdb::TryCast>(source, result, count, strict,
-		                                                                    error_message);
-	case LogicalTypeId::HUGEINT:
-		return VectorTryCastStrictLoop<string_t, hugeint_t, duckdb::TryCast>(source, result, count, strict,
-		                                                                     error_message);
-	case LogicalTypeId::FLOAT:
-		return VectorTryCastStrictLoop<string_t, float, duckdb::TryCast>(source, result, count, strict, error_message);
-	case LogicalTypeId::DOUBLE:
-		return VectorTryCastStrictLoop<string_t, double, duckdb::TryCast>(source, result, count, strict, error_message);
-	case LogicalTypeId::INTERVAL:
-		return VectorTryCastErrorLoop<string_t, interval_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
-		                                                                                 error_message);
-	case LogicalTypeId::DECIMAL:
-		return ToDecimalCast<string_t>(source, result, count, error_message);
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-static bool StringCastSwitch(Vector &source, Vector &result, idx_t count, bool strict, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::DATE:
-		return VectorTryCastErrorLoop<string_t, date_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
-		                                                                             error_message);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return VectorTryCastErrorLoop<string_t, dtime_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
-		                                                                              error_message);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return VectorTryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
-		                                                                                  error_message);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return VectorTryCastStrictLoop<string_t, timestamp_t, duckdb::TryCastToTimestampNS>(source, result, count,
-		                                                                                    strict, error_message);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return VectorTryCastStrictLoop<string_t, timestamp_t, duckdb::TryCastToTimestampSec>(source, result, count,
-		                                                                                     strict, error_message);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return VectorTryCastStrictLoop<string_t, timestamp_t, duckdb::TryCastToTimestampMS>(source, result, count,
-		                                                                                    strict, error_message);
-	case LogicalTypeId::BLOB:
-		return VectorTryCastStringLoop<string_t, string_t, duckdb::TryCastToBlob>(source, result, count, strict,
-		                                                                          error_message);
-	case LogicalTypeId::UUID:
-		return VectorTryCastStringLoop<string_t, hugeint_t, duckdb::TryCastToUUID>(source, result, count, strict,
-		                                                                           error_message);
-	case LogicalTypeId::SQLNULL:
-		return TryVectorNullCast(source, result, count, error_message);
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		result.Reinterpret(source);
-		return true;
-	default:
-		return VectorStringCastNumericSwitch(source, result, count, strict, error_message);
-	}
-}
-
-static bool DateCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// date to varchar
-		VectorStringCast<date_t, duckdb::StringCast>(source, result, count);
-		return true;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		// date to timestamp
-		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCast>(source, result, count, error_message);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampNS>(source, result, count,
-		                                                                            error_message);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampSec>(source, result, count,
-		                                                                             error_message);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampMS>(source, result, count,
-		                                                                            error_message);
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-static bool TimeCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// time to varchar
-		VectorStringCast<dtime_t, duckdb::StringCast>(source, result, count);
-		return true;
-	case LogicalTypeId::TIME_TZ:
-		// time to time with time zone
-		UnaryExecutor::Execute<dtime_t, dtime_t, duckdb::Cast>(source, result, count);
-		return true;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-static bool TimeTzCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// time with time zone to varchar
-		VectorStringCast<dtime_t, duckdb::StringCastTZ>(source, result, count);
-		return true;
-	case LogicalTypeId::TIME:
-		// time with time zone to time
-		UnaryExecutor::Execute<dtime_t, dtime_t, duckdb::Cast>(source, result, count);
-		return true;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-static bool TimestampCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// timestamp to varchar
-		VectorStringCast<timestamp_t, duckdb::StringCast>(source, result, count);
-		break;
-	case LogicalTypeId::DATE:
-		// timestamp to date
-		UnaryExecutor::Execute<timestamp_t, date_t, duckdb::Cast>(source, result, count);
-		break;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		// timestamp to time
-		UnaryExecutor::Execute<timestamp_t, dtime_t, duckdb::Cast>(source, result, count);
-		break;
-	case LogicalTypeId::TIMESTAMP_TZ:
-		// timestamp (us) to timestamp with time zone
-		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::Cast>(source, result, count);
-		break;
-	case LogicalTypeId::TIMESTAMP_NS:
-		// timestamp (us) to timestamp (ns)
-		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::CastTimestampUsToNs>(source, result, count);
-		break;
-	case LogicalTypeId::TIMESTAMP_MS:
-		// timestamp (us) to timestamp (ms)
-		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::CastTimestampUsToMs>(source, result, count);
-		break;
-	case LogicalTypeId::TIMESTAMP_SEC:
-		// timestamp (us) to timestamp (s)
-		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::CastTimestampUsToSec>(source, result, count);
-		break;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-	return true;
-}
-
-static bool TimestampTzCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// timestamp with time zone to varchar
-		VectorStringCast<timestamp_t, duckdb::StringCastTZ>(source, result, count);
-		break;
-	case LogicalTypeId::TIME_TZ:
-		// timestamp with time zone to time with time zone.
-		// TODO: set the offset to +00
-		UnaryExecutor::Execute<timestamp_t, dtime_t, duckdb::Cast>(source, result, count);
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		// timestamp with time zone to timestamp (us)
-		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::Cast>(source, result, count);
-		break;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-	return true;
-}
-
-static bool TimestampNsCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// timestamp (ns) to varchar
-		VectorStringCast<timestamp_t, duckdb::CastFromTimestampNS>(source, result, count);
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		// timestamp (ns) to timestamp (us)
-		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::CastTimestampNsToUs>(source, result, count);
-		break;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-	return true;
-}
-
-static bool TimestampMsCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// timestamp (ms) to varchar
-		VectorStringCast<timestamp_t, duckdb::CastFromTimestampMS>(source, result, count);
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		// timestamp (ms) to timestamp (us)
-		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::CastTimestampMsToUs>(source, result, count);
-		break;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-	return true;
-}
-
-static bool TimestampSecCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// timestamp (sec) to varchar
-		VectorStringCast<timestamp_t, duckdb::CastFromTimestampSec>(source, result, count);
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		// timestamp (s) to timestamp (us)
-		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::CastTimestampSecToUs>(source, result, count);
-		break;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-	return true;
-}
-
-static bool IntervalCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// time to varchar
-		VectorStringCast<interval_t, duckdb::StringCast>(source, result, count);
-		break;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-	return true;
-}
-
-static bool UUIDCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// uuid to varchar
-		VectorStringCast<hugeint_t, duckdb::CastFromUUID>(source, result, count);
-		break;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-	return true;
-}
-
-static bool BlobCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		// blob to varchar
-		VectorStringCast<string_t, duckdb::CastFromBlob>(source, result, count);
-		break;
-	case LogicalTypeId::AGGREGATE_STATE:
-		result.Reinterpret(source);
-		break;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-	return true;
-}
-
-static bool ValueStringCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	switch (result.GetType().id()) {
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::JSON:
-		if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(source.GetVectorType());
-		} else {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto src_val = source.GetValue(i);
-			if (src_val.IsNull()) {
-				result.SetValue(i, Value(result.GetType()));
-			} else {
-				auto str_val = src_val.ToString();
-				result.SetValue(i, Value(str_val));
-			}
-		}
-		return true;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-static bool ListCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	switch (result.GetType().id()) {
-	case LogicalTypeId::LIST: {
-		// only handle constant and flat vectors here for now
-		if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(source.GetVectorType());
-			ConstantVector::SetNull(result, ConstantVector::IsNull(source));
-
-			auto ldata = ConstantVector::GetData<list_entry_t>(source);
-			auto tdata = ConstantVector::GetData<list_entry_t>(result);
-			*tdata = *ldata;
-		} else {
-			source.Normalify(count);
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			FlatVector::SetValidity(result, FlatVector::Validity(source));
-
-			auto ldata = FlatVector::GetData<list_entry_t>(source);
-			auto tdata = FlatVector::GetData<list_entry_t>(result);
-			for (idx_t i = 0; i < count; i++) {
-				tdata[i] = ldata[i];
-			}
-		}
-		auto &source_cc = ListVector::GetEntry(source);
-		auto source_size = ListVector::GetListSize(source);
-
-		ListVector::Reserve(result, source_size);
-		auto &append_vector = ListVector::GetEntry(result);
-
-		VectorOperations::Cast(source_cc, append_vector, source_size);
-		ListVector::SetListSize(result, source_size);
-		D_ASSERT(ListVector::GetListSize(result) == source_size);
-		return true;
-	}
-	default:
-		return ValueStringCastSwitch(source, result, count, error_message);
-	}
-}
-
-template <class SRC_TYPE, class RES_TYPE>
-bool FillEnum(Vector &source, Vector &result, idx_t count, string *error_message) {
-	bool all_converted = true;
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	auto &str_vec = EnumType::GetValuesInsertOrder(source.GetType());
-	auto str_vec_ptr = FlatVector::GetData<string_t>(str_vec);
-
-	auto res_enum_type = result.GetType();
-
-	VectorData vdata;
-	source.Orrify(count, vdata);
-
-	auto source_data = (SRC_TYPE *)vdata.data;
-	auto source_sel = vdata.sel;
-	auto source_mask = vdata.validity;
-
-	auto result_data = FlatVector::GetData<RES_TYPE>(result);
-	auto &result_mask = FlatVector::Validity(result);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto src_idx = source_sel->get_index(i);
-		if (!source_mask.RowIsValid(src_idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-		auto str = str_vec_ptr[source_data[src_idx]].GetString();
-		auto key = EnumType::GetPos(res_enum_type, str);
-		if (key == -1) {
-			// key doesn't exist on result enum
-			if (!error_message) {
-				result_data[i] = HandleVectorCastError::Operation<RES_TYPE>(
-				    CastExceptionText<SRC_TYPE, RES_TYPE>(source_data[src_idx]), result_mask, i, error_message,
-				    all_converted);
-			} else {
-				result_mask.SetInvalid(i);
-			}
-			continue;
-		}
-		result_data[i] = key;
-	}
-	return all_converted;
-}
-
-template <class SRC_TYPE>
-bool FillEnumResultTemplate(Vector &source, Vector &result, idx_t count, string *error_message) {
-	switch (source.GetType().InternalType()) {
-	case PhysicalType::UINT8:
-		return FillEnum<SRC_TYPE, uint8_t>(source, result, count, error_message);
-	case PhysicalType::UINT16:
-		return FillEnum<SRC_TYPE, uint16_t>(source, result, count, error_message);
-	case PhysicalType::UINT32:
-		return FillEnum<SRC_TYPE, uint32_t>(source, result, count, error_message);
-	default:
-		throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-	}
-}
-
-void EnumToVarchar(Vector &source, Vector &result, idx_t count, PhysicalType enum_physical_type) {
-	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(source.GetVectorType());
-	} else {
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-	}
-	auto &str_vec = EnumType::GetValuesInsertOrder(source.GetType());
-	auto str_vec_ptr = FlatVector::GetData<string_t>(str_vec);
-	auto res_vec_ptr = FlatVector::GetData<string_t>(result);
-
-	// TODO remove value api from this loop
-	for (idx_t i = 0; i < count; i++) {
-		auto src_val = source.GetValue(i);
-		if (src_val.IsNull()) {
-			result.SetValue(i, Value());
-			continue;
-		}
-
-		uint64_t enum_idx;
-		switch (enum_physical_type) {
-		case PhysicalType::UINT8:
-			enum_idx = UTinyIntValue::Get(src_val);
-			break;
-		case PhysicalType::UINT16:
-			enum_idx = USmallIntValue::Get(src_val);
-			break;
-		case PhysicalType::UINT32:
-			enum_idx = UIntegerValue::Get(src_val);
-			break;
-		case PhysicalType::UINT64: //  DEDUP_POINTER_ENUM
-		{
-			res_vec_ptr[i] = (const char *)UBigIntValue::Get(src_val);
-			continue;
-		}
-
-		default:
-			throw InternalException("ENUM can only have unsigned integers as physical types");
-		}
-		res_vec_ptr[i] = str_vec_ptr[enum_idx];
-	}
-}
-
-static bool EnumCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message, bool strict) {
-	auto enum_physical_type = source.GetType().InternalType();
-	switch (result.GetType().id()) {
-	case LogicalTypeId::ENUM: {
-		// This means they are both ENUMs, but of different types.
-		switch (enum_physical_type) {
-		case PhysicalType::UINT8:
-			return FillEnumResultTemplate<uint8_t>(source, result, count, error_message);
-		case PhysicalType::UINT16:
-			return FillEnumResultTemplate<uint16_t>(source, result, count, error_message);
-		case PhysicalType::UINT32:
-			return FillEnumResultTemplate<uint32_t>(source, result, count, error_message);
-		default:
-			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-		}
-	}
-	case LogicalTypeId::JSON:
-	case LogicalTypeId::VARCHAR: {
-		EnumToVarchar(source, result, count, enum_physical_type);
-		break;
-	}
-	default: {
-		// Cast to varchar
-		Vector varchar_cast(LogicalType::VARCHAR, count);
-		EnumToVarchar(source, varchar_cast, count, enum_physical_type);
-		// Try to cast from varchar to whatever we wanted before
-		VectorOperations::TryCast(varchar_cast, result, count, error_message, strict);
-		break;
-	}
-	}
-	return true;
-}
-
-static bool AggregateStateToBlobCast(Vector &source, Vector &result, idx_t count, string *error_message, bool strict) {
-	if (result.GetType().id() != LogicalTypeId::BLOB) {
-		throw TypeMismatchException(source.GetType(), result.GetType(),
-		                            "Cannot cast AGGREGATE_STATE to anything but BLOB");
-	}
-	result.Reinterpret(source);
-	return true;
-}
-
-static bool StructCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	switch (result.GetType().id()) {
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::MAP: {
-		auto &source_child_types = StructType::GetChildTypes(source.GetType());
-		auto &result_child_types = StructType::GetChildTypes(result.GetType());
-		if (source_child_types.size() != result_child_types.size()) {
-			throw TypeMismatchException(source.GetType(), result.GetType(), "Cannot cast STRUCTs of different size");
-		}
-		auto &source_children = StructVector::GetEntries(source);
-		D_ASSERT(source_children.size() == source_child_types.size());
-
-		auto &result_children = StructVector::GetEntries(result);
-		for (idx_t c_idx = 0; c_idx < result_child_types.size(); c_idx++) {
-			auto &result_child_vector = result_children[c_idx];
-			auto &source_child_vector = *source_children[c_idx];
-			if (result_child_vector->GetType() != source_child_vector.GetType()) {
-				VectorOperations::Cast(source_child_vector, *result_child_vector, count, false);
-			} else {
-				result_child_vector->Reference(source_child_vector);
-			}
-		}
-		if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, ConstantVector::IsNull(source));
-		} else {
-			source.Normalify(count);
-			FlatVector::Validity(result) = FlatVector::Validity(source);
-		}
-		return true;
-	}
-	case LogicalTypeId::JSON:
-	case LogicalTypeId::VARCHAR:
-		if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(source.GetVectorType());
-		} else {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto src_val = source.GetValue(i);
-			auto str_val = src_val.ToString();
-			result.SetValue(i, Value(str_val));
-		}
-		return true;
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-bool VectorOperations::TryCast(Vector &source, Vector &result, idx_t count, string *error_message, bool strict) {
-	D_ASSERT(source.GetType() != result.GetType());
-	// first switch on source type
-	switch (source.GetType().id()) {
-	case LogicalTypeId::BOOLEAN:
-		return NumericCastSwitch<bool>(source, result, count, error_message);
-	case LogicalTypeId::TINYINT:
-		return NumericCastSwitch<int8_t>(source, result, count, error_message);
-	case LogicalTypeId::SMALLINT:
-		return NumericCastSwitch<int16_t>(source, result, count, error_message);
-	case LogicalTypeId::INTEGER:
-		return NumericCastSwitch<int32_t>(source, result, count, error_message);
-	case LogicalTypeId::BIGINT:
-		return NumericCastSwitch<int64_t>(source, result, count, error_message);
-	case LogicalTypeId::UTINYINT:
-		return NumericCastSwitch<uint8_t>(source, result, count, error_message);
-	case LogicalTypeId::USMALLINT:
-		return NumericCastSwitch<uint16_t>(source, result, count, error_message);
-	case LogicalTypeId::UINTEGER:
-		return NumericCastSwitch<uint32_t>(source, result, count, error_message);
-	case LogicalTypeId::UBIGINT:
-		return NumericCastSwitch<uint64_t>(source, result, count, error_message);
-	case LogicalTypeId::HUGEINT:
-		return NumericCastSwitch<hugeint_t>(source, result, count, error_message);
-	case LogicalTypeId::UUID:
-		return UUIDCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::DECIMAL:
-		return DecimalCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::FLOAT:
-		return NumericCastSwitch<float>(source, result, count, error_message);
-	case LogicalTypeId::DOUBLE:
-		return NumericCastSwitch<double>(source, result, count, error_message);
-	case LogicalTypeId::DATE:
-		return DateCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::TIME:
-		return TimeCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::TIME_TZ:
-		return TimeTzCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::TIMESTAMP:
-		return TimestampCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return TimestampTzCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::TIMESTAMP_NS:
-		return TimestampNsCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::TIMESTAMP_MS:
-		return TimestampMsCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return TimestampSecCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::INTERVAL:
-		return IntervalCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::JSON:
-	case LogicalTypeId::VARCHAR:
-		return StringCastSwitch(source, result, count, strict, error_message);
-	case LogicalTypeId::BLOB:
-		return BlobCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::SQLNULL: {
-		// cast a NULL to another type, just copy the properties and change the type
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return true;
-	}
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::STRUCT:
-		return StructCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::LIST:
-		return ListCastSwitch(source, result, count, error_message);
-	case LogicalTypeId::ENUM:
-		return EnumCastSwitch(source, result, count, error_message, strict);
-	case LogicalTypeId::AGGREGATE_STATE:
-		return AggregateStateToBlobCast(source, result, count, error_message, strict);
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-void VectorOperations::Cast(Vector &source, Vector &result, idx_t count, bool strict) {
-	VectorOperations::TryCast(source, result, count, nullptr, strict);
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// copy.cpp
-// Description: This file contains the implementation of the different copy
-// functions
-//===--------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-static void TemplatedCopy(const Vector &source, const SelectionVector &sel, Vector &target, idx_t source_offset,
-                          idx_t target_offset, idx_t copy_count) {
-	auto ldata = FlatVector::GetData<T>(source);
-	auto tdata = FlatVector::GetData<T>(target);
-	for (idx_t i = 0; i < copy_count; i++) {
-		auto source_idx = sel.get_index(source_offset + i);
-		tdata[target_offset + i] = ldata[source_idx];
-	}
-}
-
-void VectorOperations::Copy(const Vector &source_p, Vector &target, const SelectionVector &sel_p, idx_t source_count,
-                            idx_t source_offset, idx_t target_offset) {
-	D_ASSERT(source_offset <= source_count);
-	D_ASSERT(source_p.GetType() == target.GetType());
-	idx_t copy_count = source_count - source_offset;
-
-	SelectionVector owned_sel;
-	const SelectionVector *sel = &sel_p;
-
-	const Vector *source = &source_p;
-	bool finished = false;
-	while (!finished) {
-		switch (source->GetVectorType()) {
-		case VectorType::DICTIONARY_VECTOR: {
-			// dictionary vector: merge selection vectors
-			auto &child = DictionaryVector::Child(*source);
-			auto &dict_sel = DictionaryVector::SelVector(*source);
-			// merge the selection vectors and verify the child
-			auto new_buffer = dict_sel.Slice(*sel, source_count);
-			owned_sel.Initialize(new_buffer);
-			sel = &owned_sel;
-			source = &child;
-			break;
-		}
-		case VectorType::SEQUENCE_VECTOR: {
-			int64_t start, increment;
-			Vector seq(source->GetType());
-			SequenceVector::GetSequence(*source, start, increment);
-			VectorOperations::GenerateSequence(seq, source_count, *sel, start, increment);
-			VectorOperations::Copy(seq, target, *sel, source_count, source_offset, target_offset);
-			return;
-		}
-		case VectorType::CONSTANT_VECTOR:
-			sel = ConstantVector::ZeroSelectionVector(copy_count, owned_sel);
-			finished = true;
-			break;
-		case VectorType::FLAT_VECTOR:
-			finished = true;
-			break;
-		default:
-			throw NotImplementedException("FIXME unimplemented vector type for VectorOperations::Copy");
-		}
-	}
-
-	if (copy_count == 0) {
-		return;
-	}
-
-	// Allow copying of a single value to constant vectors
-	const auto target_vector_type = target.GetVectorType();
-	if (copy_count == 1 && target_vector_type == VectorType::CONSTANT_VECTOR) {
-		target_offset = 0;
-		target.SetVectorType(VectorType::FLAT_VECTOR);
-	}
-	D_ASSERT(target.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	// first copy the nullmask
-	auto &tmask = FlatVector::Validity(target);
-	if (source->GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		const bool valid = !ConstantVector::IsNull(*source);
-		for (idx_t i = 0; i < copy_count; i++) {
-			tmask.Set(target_offset + i, valid);
-		}
-	} else {
-		auto &smask = FlatVector::Validity(*source);
-		if (smask.IsMaskSet()) {
-			for (idx_t i = 0; i < copy_count; i++) {
-				auto idx = sel->get_index(source_offset + i);
-
-				if (smask.RowIsValid(idx)) {
-					// set valid
-					if (!tmask.AllValid()) {
-						tmask.SetValidUnsafe(target_offset + i);
-					}
-				} else {
-					// set invalid
-					if (tmask.AllValid()) {
-						auto init_size = MaxValue<idx_t>(STANDARD_VECTOR_SIZE, target_offset + copy_count);
-						tmask.Initialize(init_size);
-					}
-					tmask.SetInvalidUnsafe(target_offset + i);
-				}
-			}
-		}
-	}
-
-	D_ASSERT(sel);
-
-	// now copy over the data
-	switch (source->GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedCopy<int8_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedCopy<int16_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedCopy<int32_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedCopy<int64_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedCopy<uint8_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedCopy<uint16_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedCopy<uint32_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedCopy<uint64_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedCopy<hugeint_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedCopy<float>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedCopy<double>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedCopy<interval_t>(*source, *sel, target, source_offset, target_offset, copy_count);
-		break;
-	case PhysicalType::VARCHAR: {
-		auto ldata = FlatVector::GetData<string_t>(*source);
-		auto tdata = FlatVector::GetData<string_t>(target);
-		for (idx_t i = 0; i < copy_count; i++) {
-			auto source_idx = sel->get_index(source_offset + i);
-			auto target_idx = target_offset + i;
-			if (tmask.RowIsValid(target_idx)) {
-				tdata[target_idx] = StringVector::AddStringOrBlob(target, ldata[source_idx]);
-			}
-		}
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		auto &source_children = StructVector::GetEntries(*source);
-		auto &target_children = StructVector::GetEntries(target);
-		D_ASSERT(source_children.size() == target_children.size());
-		for (idx_t i = 0; i < source_children.size(); i++) {
-			VectorOperations::Copy(*source_children[i], *target_children[i], sel_p, source_count, source_offset,
-			                       target_offset);
-		}
-		break;
-	}
-	case PhysicalType::LIST: {
-		D_ASSERT(target.GetType().InternalType() == PhysicalType::LIST);
-
-		auto &source_child = ListVector::GetEntry(*source);
-		auto sdata = FlatVector::GetData<list_entry_t>(*source);
-		auto tdata = FlatVector::GetData<list_entry_t>(target);
-
-		if (target_vector_type == VectorType::CONSTANT_VECTOR) {
-			// If we are only writing one value, then the copied values (if any) are contiguous
-			// and we can just Append from the offset position
-			if (!tmask.RowIsValid(target_offset)) {
-				break;
-			}
-			auto source_idx = sel->get_index(source_offset);
-			auto &source_entry = sdata[source_idx];
-			const idx_t source_child_size = source_entry.length + source_entry.offset;
-
-			//! overwrite constant target vectors.
-			ListVector::SetListSize(target, 0);
-			ListVector::Append(target, source_child, source_child_size, source_entry.offset);
-
-			auto &target_entry = tdata[target_offset];
-			target_entry.length = source_entry.length;
-			target_entry.offset = 0;
-		} else {
-			//! if the source has list offsets, we need to append them to the target
-			//! build a selection vector for the copied child elements
-			vector<sel_t> child_rows;
-			for (idx_t i = 0; i < copy_count; ++i) {
-				if (tmask.RowIsValid(target_offset + i)) {
-					auto source_idx = sel->get_index(source_offset + i);
-					auto &source_entry = sdata[source_idx];
-					for (idx_t j = 0; j < source_entry.length; ++j) {
-						child_rows.emplace_back(source_entry.offset + j);
-					}
-				}
-			}
-			idx_t source_child_size = child_rows.size();
-			SelectionVector child_sel(child_rows.data());
-
-			idx_t old_target_child_len = ListVector::GetListSize(target);
-
-			//! append to list itself
-			ListVector::Append(target, source_child, child_sel, source_child_size);
-
-			//! now write the list offsets
-			for (idx_t i = 0; i < copy_count; i++) {
-				auto source_idx = sel->get_index(source_offset + i);
-				auto &source_entry = sdata[source_idx];
-				auto &target_entry = tdata[target_offset + i];
-
-				target_entry.length = source_entry.length;
-				target_entry.offset = old_target_child_len;
-				if (tmask.RowIsValid(target_offset + i)) {
-					old_target_child_len += target_entry.length;
-				}
-			}
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Unimplemented type '%s' for copy!",
-		                              TypeIdToString(source->GetType().InternalType()));
-	}
-
-	if (target_vector_type != VectorType::FLAT_VECTOR) {
-		target.SetVectorType(target_vector_type);
-	}
-}
-
-void VectorOperations::Copy(const Vector &source, Vector &target, idx_t source_count, idx_t source_offset,
-                            idx_t target_offset) {
-	VectorOperations::Copy(source, target, *FlatVector::IncrementalSelectionVector(), source_count, source_offset,
-	                       target_offset);
-}
-
-} // namespace duckdb
-//===--------------------------------------------------------------------===//
-// hash.cpp
-// Description: This file contains the vectorized hash implementations
-//===--------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct HashOp {
-	static const hash_t NULL_HASH = 0xbf58476d1ce4e5b9;
-
-	template <class T>
-	static inline hash_t Operation(T input, bool is_null) {
-		return is_null ? NULL_HASH : duckdb::Hash<T>(input);
-	}
-};
-
-static inline hash_t CombineHashScalar(hash_t a, hash_t b) {
-	return (a * UINT64_C(0xbf58476d1ce4e5b9)) ^ b;
-}
-
-template <bool HAS_RSEL, class T>
-static inline void TightLoopHash(T *__restrict ldata, hash_t *__restrict result_data, const SelectionVector *rsel,
-                                 idx_t count, const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
-	if (!mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			result_data[ridx] = HashOp::Operation(ldata[idx], !mask.RowIsValid(idx));
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			result_data[ridx] = duckdb::Hash<T>(ldata[idx]);
-		}
-	}
-}
-
-template <bool HAS_RSEL, class T>
-static inline void TemplatedLoopHash(Vector &input, Vector &result, const SelectionVector *rsel, idx_t count) {
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		auto ldata = ConstantVector::GetData<T>(input);
-		auto result_data = ConstantVector::GetData<hash_t>(result);
-		*result_data = HashOp::Operation(*ldata, ConstantVector::IsNull(input));
-	} else {
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-
-		VectorData idata;
-		input.Orrify(count, idata);
-
-		TightLoopHash<HAS_RSEL, T>((T *)idata.data, FlatVector::GetData<hash_t>(result), rsel, count, idata.sel,
-		                           idata.validity);
-	}
-}
-
-template <bool HAS_RSEL, bool FIRST_HASH>
-static inline void StructLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
-	auto &children = StructVector::GetEntries(input);
-
-	D_ASSERT(!children.empty());
-	idx_t col_no = 0;
-	if (HAS_RSEL) {
-		if (FIRST_HASH) {
-			VectorOperations::Hash(*children[col_no++], hashes, *rsel, count);
-		} else {
-			VectorOperations::CombineHash(hashes, *children[col_no++], *rsel, count);
-		}
-		while (col_no < children.size()) {
-			VectorOperations::CombineHash(hashes, *children[col_no++], *rsel, count);
-		}
-	} else {
-		if (FIRST_HASH) {
-			VectorOperations::Hash(*children[col_no++], hashes, count);
-		} else {
-			VectorOperations::CombineHash(hashes, *children[col_no++], count);
-		}
-		while (col_no < children.size()) {
-			VectorOperations::CombineHash(hashes, *children[col_no++], count);
-		}
-	}
-}
-
-template <bool HAS_RSEL, bool FIRST_HASH>
-static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
-	auto hdata = FlatVector::GetData<hash_t>(hashes);
-
-	VectorData idata;
-	input.Orrify(count, idata);
-	const auto ldata = (const list_entry_t *)idata.data;
-
-	// Hash the children into a temporary
-	auto &child = ListVector::GetEntry(input);
-	const auto child_count = ListVector::GetListSize(input);
-
-	Vector child_hashes(LogicalType::HASH, child_count);
-	VectorOperations::Hash(child, child_hashes, child_count);
-	auto chdata = FlatVector::GetData<hash_t>(child_hashes);
-
-	// Reduce the number of entries to check to the non-empty ones
-	SelectionVector unprocessed(count);
-	SelectionVector cursor(HAS_RSEL ? STANDARD_VECTOR_SIZE : count);
-	idx_t remaining = 0;
-	for (idx_t i = 0; i < count; ++i) {
-		const idx_t ridx = HAS_RSEL ? rsel->get_index(i) : i;
-		const auto lidx = idata.sel->get_index(ridx);
-		const auto &entry = ldata[lidx];
-		if (idata.validity.RowIsValid(lidx) && entry.length > 0) {
-			unprocessed.set_index(remaining++, ridx);
-			cursor.set_index(ridx, entry.offset);
-		} else if (FIRST_HASH) {
-			hdata[ridx] = HashOp::NULL_HASH;
-		}
-		// Empty or NULL non-first elements have no effect.
-	}
-
-	count = remaining;
-	if (count == 0) {
-		return;
-	}
-
-	// Merge the first position hash into the main hash
-	idx_t position = 1;
-	if (FIRST_HASH) {
-		remaining = 0;
-		for (idx_t i = 0; i < count; ++i) {
-			const auto ridx = unprocessed.get_index(i);
-			const auto cidx = cursor.get_index(ridx);
-			hdata[ridx] = chdata[cidx];
-
-			const auto lidx = idata.sel->get_index(ridx);
-			const auto &entry = ldata[lidx];
-			if (entry.length > position) {
-				// Entry still has values to hash
-				unprocessed.set_index(remaining++, ridx);
-				cursor.set_index(ridx, cidx + 1);
-			}
-		}
-		count = remaining;
-		if (count == 0) {
-			return;
-		}
-		++position;
-	}
-
-	// Combine the hashes for the remaining positions until there are none left
-	for (;; ++position) {
-		remaining = 0;
-		for (idx_t i = 0; i < count; ++i) {
-			const auto ridx = unprocessed.get_index(i);
-			const auto cidx = cursor.get_index(ridx);
-			hdata[ridx] = CombineHashScalar(hdata[ridx], chdata[cidx]);
-
-			const auto lidx = idata.sel->get_index(ridx);
-			const auto &entry = ldata[lidx];
-			if (entry.length > position) {
-				// Entry still has values to hash
-				unprocessed.set_index(remaining++, ridx);
-				cursor.set_index(ridx, cidx + 1);
-			}
-		}
-
-		count = remaining;
-		if (count == 0) {
-			break;
-		}
-	}
-}
-
-template <bool HAS_RSEL>
-static inline void HashTypeSwitch(Vector &input, Vector &result, const SelectionVector *rsel, idx_t count) {
-	D_ASSERT(result.GetType().id() == LogicalType::HASH);
-	switch (input.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedLoopHash<HAS_RSEL, int8_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedLoopHash<HAS_RSEL, int16_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedLoopHash<HAS_RSEL, int32_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedLoopHash<HAS_RSEL, int64_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedLoopHash<HAS_RSEL, uint8_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedLoopHash<HAS_RSEL, uint16_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedLoopHash<HAS_RSEL, uint32_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedLoopHash<HAS_RSEL, uint64_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedLoopHash<HAS_RSEL, hugeint_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedLoopHash<HAS_RSEL, float>(input, result, rsel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedLoopHash<HAS_RSEL, double>(input, result, rsel, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedLoopHash<HAS_RSEL, interval_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedLoopHash<HAS_RSEL, string_t>(input, result, rsel, count);
-		break;
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-		StructLoopHash<HAS_RSEL, true>(input, result, rsel, count);
-		break;
-	case PhysicalType::LIST:
-		ListLoopHash<HAS_RSEL, true>(input, result, rsel, count);
-		break;
-	default:
-		throw InvalidTypeException(input.GetType(), "Invalid type for hash");
-	}
-}
-
-void VectorOperations::Hash(Vector &input, Vector &result, idx_t count) {
-	HashTypeSwitch<false>(input, result, nullptr, count);
-}
-
-void VectorOperations::Hash(Vector &input, Vector &result, const SelectionVector &sel, idx_t count) {
-	HashTypeSwitch<true>(input, result, &sel, count);
-}
-
-template <bool HAS_RSEL, class T>
-static inline void TightLoopCombineHashConstant(T *__restrict ldata, hash_t constant_hash, hash_t *__restrict hash_data,
-                                                const SelectionVector *rsel, idx_t count,
-                                                const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
-	if (!mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			auto other_hash = HashOp::Operation(ldata[idx], !mask.RowIsValid(idx));
-			hash_data[ridx] = CombineHashScalar(constant_hash, other_hash);
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			auto other_hash = duckdb::Hash<T>(ldata[idx]);
-			hash_data[ridx] = CombineHashScalar(constant_hash, other_hash);
-		}
-	}
-}
-
-template <bool HAS_RSEL, class T>
-static inline void TightLoopCombineHash(T *__restrict ldata, hash_t *__restrict hash_data, const SelectionVector *rsel,
-                                        idx_t count, const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
-	if (!mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			auto other_hash = HashOp::Operation(ldata[idx], !mask.RowIsValid(idx));
-			hash_data[ridx] = CombineHashScalar(hash_data[ridx], other_hash);
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
-			auto idx = sel_vector->get_index(ridx);
-			auto other_hash = duckdb::Hash<T>(ldata[idx]);
-			hash_data[ridx] = CombineHashScalar(hash_data[ridx], other_hash);
-		}
-	}
-}
-
-template <bool HAS_RSEL, class T>
-void TemplatedLoopCombineHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR && hashes.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto ldata = ConstantVector::GetData<T>(input);
-		auto hash_data = ConstantVector::GetData<hash_t>(hashes);
-
-		auto other_hash = HashOp::Operation(*ldata, ConstantVector::IsNull(input));
-		*hash_data = CombineHashScalar(*hash_data, other_hash);
-	} else {
-		VectorData idata;
-		input.Orrify(count, idata);
-		if (hashes.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			// mix constant with non-constant, first get the constant value
-			auto constant_hash = *ConstantVector::GetData<hash_t>(hashes);
-			// now re-initialize the hashes vector to an empty flat vector
-			hashes.SetVectorType(VectorType::FLAT_VECTOR);
-			TightLoopCombineHashConstant<HAS_RSEL, T>((T *)idata.data, constant_hash,
-			                                          FlatVector::GetData<hash_t>(hashes), rsel, count, idata.sel,
-			                                          idata.validity);
-		} else {
-			D_ASSERT(hashes.GetVectorType() == VectorType::FLAT_VECTOR);
-			TightLoopCombineHash<HAS_RSEL, T>((T *)idata.data, FlatVector::GetData<hash_t>(hashes), rsel, count,
-			                                  idata.sel, idata.validity);
-		}
-	}
-}
-
-template <bool HAS_RSEL>
-static inline void CombineHashTypeSwitch(Vector &hashes, Vector &input, const SelectionVector *rsel, idx_t count) {
-	D_ASSERT(hashes.GetType().id() == LogicalType::HASH);
-	switch (input.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedLoopCombineHash<HAS_RSEL, int8_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedLoopCombineHash<HAS_RSEL, int16_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedLoopCombineHash<HAS_RSEL, int32_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedLoopCombineHash<HAS_RSEL, int64_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedLoopCombineHash<HAS_RSEL, uint8_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedLoopCombineHash<HAS_RSEL, uint16_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedLoopCombineHash<HAS_RSEL, uint32_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedLoopCombineHash<HAS_RSEL, uint64_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedLoopCombineHash<HAS_RSEL, hugeint_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedLoopCombineHash<HAS_RSEL, float>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedLoopCombineHash<HAS_RSEL, double>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedLoopCombineHash<HAS_RSEL, interval_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedLoopCombineHash<HAS_RSEL, string_t>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-		StructLoopHash<HAS_RSEL, false>(input, hashes, rsel, count);
-		break;
-	case PhysicalType::LIST:
-		ListLoopHash<HAS_RSEL, false>(input, hashes, rsel, count);
-		break;
-	default:
-		throw InvalidTypeException(input.GetType(), "Invalid type for hash");
-	}
-}
-
-void VectorOperations::CombineHash(Vector &hashes, Vector &input, idx_t count) {
-	CombineHashTypeSwitch<false>(hashes, input, nullptr, count);
-}
-
-void VectorOperations::CombineHash(Vector &hashes, Vector &input, const SelectionVector &rsel, idx_t count) {
-	CombineHashTypeSwitch<true>(hashes, input, &rsel, count);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-template <class T>
-static void CopyToStorageLoop(VectorData &vdata, idx_t count, data_ptr_t target) {
-	auto ldata = (T *)vdata.data;
-	auto result_data = (T *)target;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (!vdata.validity.RowIsValid(idx)) {
-			result_data[i] = NullValue<T>();
-		} else {
-			result_data[i] = ldata[idx];
-		}
-	}
-}
-
-void VectorOperations::WriteToStorage(Vector &source, idx_t count, data_ptr_t target) {
-	if (count == 0) {
-		return;
-	}
-	VectorData vdata;
-	source.Orrify(count, vdata);
-
-	switch (source.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		CopyToStorageLoop<int8_t>(vdata, count, target);
-		break;
-	case PhysicalType::INT16:
-		CopyToStorageLoop<int16_t>(vdata, count, target);
-		break;
-	case PhysicalType::INT32:
-		CopyToStorageLoop<int32_t>(vdata, count, target);
-		break;
-	case PhysicalType::INT64:
-		CopyToStorageLoop<int64_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT8:
-		CopyToStorageLoop<uint8_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT16:
-		CopyToStorageLoop<uint16_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT32:
-		CopyToStorageLoop<uint32_t>(vdata, count, target);
-		break;
-	case PhysicalType::UINT64:
-		CopyToStorageLoop<uint64_t>(vdata, count, target);
-		break;
-	case PhysicalType::INT128:
-		CopyToStorageLoop<hugeint_t>(vdata, count, target);
-		break;
-	case PhysicalType::FLOAT:
-		CopyToStorageLoop<float>(vdata, count, target);
-		break;
-	case PhysicalType::DOUBLE:
-		CopyToStorageLoop<double>(vdata, count, target);
-		break;
-	case PhysicalType::INTERVAL:
-		CopyToStorageLoop<interval_t>(vdata, count, target);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for WriteToStorage");
-	}
-}
-
-template <class T>
-static void ReadFromStorageLoop(data_ptr_t source, idx_t count, Vector &result) {
-	auto ldata = (T *)source;
-	auto result_data = FlatVector::GetData<T>(result);
-	for (idx_t i = 0; i < count; i++) {
-		result_data[i] = ldata[i];
-	}
-}
-
-void VectorOperations::ReadFromStorage(data_ptr_t source, idx_t count, Vector &result) {
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		ReadFromStorageLoop<int8_t>(source, count, result);
-		break;
-	case PhysicalType::INT16:
-		ReadFromStorageLoop<int16_t>(source, count, result);
-		break;
-	case PhysicalType::INT32:
-		ReadFromStorageLoop<int32_t>(source, count, result);
-		break;
-	case PhysicalType::INT64:
-		ReadFromStorageLoop<int64_t>(source, count, result);
-		break;
-	case PhysicalType::UINT8:
-		ReadFromStorageLoop<uint8_t>(source, count, result);
-		break;
-	case PhysicalType::UINT16:
-		ReadFromStorageLoop<uint16_t>(source, count, result);
-		break;
-	case PhysicalType::UINT32:
-		ReadFromStorageLoop<uint32_t>(source, count, result);
-		break;
-	case PhysicalType::UINT64:
-		ReadFromStorageLoop<uint64_t>(source, count, result);
-		break;
-	case PhysicalType::INT128:
-		ReadFromStorageLoop<hugeint_t>(source, count, result);
-		break;
-	case PhysicalType::FLOAT:
-		ReadFromStorageLoop<float>(source, count, result);
-		break;
-	case PhysicalType::DOUBLE:
-		ReadFromStorageLoop<double>(source, count, result);
-		break;
-	case PhysicalType::INTERVAL:
-		ReadFromStorageLoop<interval_t>(source, count, result);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for ReadFromStorage");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-VirtualFileSystem::VirtualFileSystem() : default_fs(FileSystem::CreateLocal()) {
-	RegisterSubSystem(FileCompressionType::GZIP, make_unique<GZipFileSystem>());
-}
-
-unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock,
-                                                   FileCompressionType compression, FileOpener *opener) {
-	if (compression == FileCompressionType::AUTO_DETECT) {
-		// auto detect compression settings based on file name
-		auto lower_path = StringUtil::Lower(path);
-		if (StringUtil::EndsWith(lower_path, ".gz")) {
-			compression = FileCompressionType::GZIP;
-		} else if (StringUtil::EndsWith(lower_path, ".zst")) {
-			compression = FileCompressionType::ZSTD;
-		} else {
-			compression = FileCompressionType::UNCOMPRESSED;
-		}
-	}
-	// open the base file handle
-	auto file_handle = FindFileSystem(path)->OpenFile(path, flags, lock, FileCompressionType::UNCOMPRESSED, opener);
-	if (file_handle->GetType() == FileType::FILE_TYPE_FIFO) {
-		file_handle = PipeFileSystem::OpenPipe(move(file_handle));
-	} else if (compression != FileCompressionType::UNCOMPRESSED) {
-		auto entry = compressed_fs.find(compression);
-		if (entry == compressed_fs.end()) {
-			throw NotImplementedException(
-			    "Attempting to open a compressed file, but the compression type is not supported");
-		}
-		file_handle = entry->second->OpenCompressedFile(move(file_handle), flags & FileFlags::FILE_FLAGS_WRITE);
-	}
-	return file_handle;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-#ifdef DUCKDB_WINDOWS
-
-std::wstring WindowsUtil::UTF8ToUnicode(const char *input) {
-	idx_t result_size;
-
-	result_size = MultiByteToWideChar(CP_UTF8, 0, input, -1, nullptr, 0);
-	if (result_size == 0) {
-		throw IOException("Failure in MultiByteToWideChar");
-	}
-	auto buffer = unique_ptr<wchar_t[]>(new wchar_t[result_size]);
-	result_size = MultiByteToWideChar(CP_UTF8, 0, input, -1, buffer.get(), result_size);
-	if (result_size == 0) {
-		throw IOException("Failure in MultiByteToWideChar");
-	}
-	return std::wstring(buffer.get(), result_size);
-}
-
-static string WideCharToMultiByteWrapper(LPCWSTR input, uint32_t code_page) {
-	idx_t result_size;
-
-	result_size = WideCharToMultiByte(code_page, 0, input, -1, 0, 0, 0, 0);
-	if (result_size == 0) {
-		throw IOException("Failure in WideCharToMultiByte");
-	}
-	auto buffer = unique_ptr<char[]>(new char[result_size]);
-	result_size = WideCharToMultiByte(code_page, 0, input, -1, buffer.get(), result_size, 0, 0);
-	if (result_size == 0) {
-		throw IOException("Failure in WideCharToMultiByte");
-	}
-	return string(buffer.get(), result_size - 1);
-}
-
-string WindowsUtil::UnicodeToUTF8(LPCWSTR input) {
-	return WideCharToMultiByteWrapper(input, CP_UTF8);
-}
-
-static string WindowsUnicodeToMBCS(LPCWSTR unicode_text, int use_ansi) {
-	uint32_t code_page = use_ansi ? CP_ACP : CP_OEMCP;
-	return WideCharToMultiByteWrapper(unicode_text, code_page);
-}
-
-string WindowsUtil::UTF8ToMBCS(const char *input, bool use_ansi) {
-	auto unicode = WindowsUtil::UTF8ToUnicode(input);
-	return WindowsUnicodeToMBCS(unicode.c_str(), use_ansi);
-}
-
-#endif
-
-} // namespace duckdb
-
-
-
-#include <vector>
-
-namespace duckdb {
-
-AdaptiveFilter::AdaptiveFilter(const Expression &expr)
-    : iteration_count(0), observe_interval(10), execute_interval(20), warmup(true) {
-	auto &conj_expr = (const BoundConjunctionExpression &)expr;
-	D_ASSERT(conj_expr.children.size() > 1);
-	for (idx_t idx = 0; idx < conj_expr.children.size(); idx++) {
-		permutation.push_back(idx);
-		if (idx != conj_expr.children.size() - 1) {
-			swap_likeliness.push_back(100);
-		}
-	}
-	right_random_border = 100 * (conj_expr.children.size() - 1);
-}
-
-AdaptiveFilter::AdaptiveFilter(TableFilterSet *table_filters)
-    : iteration_count(0), observe_interval(10), execute_interval(20), warmup(true) {
-	for (auto &table_filter : table_filters->filters) {
-		permutation.push_back(table_filter.first);
-		swap_likeliness.push_back(100);
-	}
-	swap_likeliness.pop_back();
-	right_random_border = 100 * (table_filters->filters.size() - 1);
-}
-void AdaptiveFilter::AdaptRuntimeStatistics(double duration) {
-	iteration_count++;
-	runtime_sum += duration;
-
-	if (!warmup) {
-		// the last swap was observed
-		if (observe && iteration_count == observe_interval) {
-			// keep swap if runtime decreased, else reverse swap
-			if (prev_mean - (runtime_sum / iteration_count) <= 0) {
-				// reverse swap because runtime didn't decrease
-				std::swap(permutation[swap_idx], permutation[swap_idx + 1]);
-
-				// decrease swap likeliness, but make sure there is always a small likeliness left
-				if (swap_likeliness[swap_idx] > 1) {
-					swap_likeliness[swap_idx] /= 2;
-				}
-			} else {
-				// keep swap because runtime decreased, reset likeliness
-				swap_likeliness[swap_idx] = 100;
-			}
-			observe = false;
-
-			// reset values
-			iteration_count = 0;
-			runtime_sum = 0.0;
-		} else if (!observe && iteration_count == execute_interval) {
-			// save old mean to evaluate swap
-			prev_mean = runtime_sum / iteration_count;
-
-			// get swap index and swap likeliness
-			std::uniform_int_distribution<int> distribution(1, right_random_border); // a <= i <= b
-			idx_t random_number = distribution(generator) - 1;
-
-			swap_idx = random_number / 100;                    // index to be swapped
-			idx_t likeliness = random_number - 100 * swap_idx; // random number between [0, 100)
-
-			// check if swap is going to happen
-			if (swap_likeliness[swap_idx] > likeliness) { // always true for the first swap of an index
-				// swap
-				std::swap(permutation[swap_idx], permutation[swap_idx + 1]);
-
-				// observe whether swap will be applied
-				observe = true;
-			}
-
-			// reset values
-			iteration_count = 0;
-			runtime_sum = 0.0;
-		}
-	} else {
-		if (iteration_count == 5) {
-			// initially set all values
-			iteration_count = 0;
-			runtime_sum = 0.0;
-			observe = false;
-			warmup = false;
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cmath>
-
-namespace duckdb {
-
-using ValidityBytes = RowLayout::ValidityBytes;
-
-GroupedAggregateHashTable::GroupedAggregateHashTable(Allocator &allocator, BufferManager &buffer_manager,
-                                                     vector<LogicalType> group_types, vector<LogicalType> payload_types,
-                                                     const vector<BoundAggregateExpression *> &bindings,
-                                                     HtEntryType entry_type)
-    : GroupedAggregateHashTable(allocator, buffer_manager, move(group_types), move(payload_types),
-                                AggregateObject::CreateAggregateObjects(bindings), entry_type) {
-}
-
-GroupedAggregateHashTable::GroupedAggregateHashTable(Allocator &allocator, BufferManager &buffer_manager,
-                                                     vector<LogicalType> group_types)
-    : GroupedAggregateHashTable(allocator, buffer_manager, move(group_types), {}, vector<AggregateObject>()) {
-}
-
-GroupedAggregateHashTable::GroupedAggregateHashTable(Allocator &allocator, BufferManager &buffer_manager,
-                                                     vector<LogicalType> group_types_p,
-                                                     vector<LogicalType> payload_types_p,
-                                                     vector<AggregateObject> aggregate_objects_p,
-                                                     HtEntryType entry_type)
-    : BaseAggregateHashTable(allocator, aggregate_objects_p, buffer_manager, move(payload_types_p)),
-      entry_type(entry_type), capacity(0), entries(0), payload_page_offset(0), is_finalized(false),
-      ht_offsets(LogicalTypeId::BIGINT), hash_salts(LogicalTypeId::SMALLINT),
-      group_compare_vector(STANDARD_VECTOR_SIZE), no_match_vector(STANDARD_VECTOR_SIZE),
-      empty_vector(STANDARD_VECTOR_SIZE) {
-
-	// Append hash column to the end and initialise the row layout
-	group_types_p.emplace_back(LogicalType::HASH);
-	layout.Initialize(move(group_types_p), move(aggregate_objects_p));
-
-	// HT layout
-	hash_offset = layout.GetOffsets()[layout.ColumnCount() - 1];
-
-	tuple_size = layout.GetRowWidth();
-
-	D_ASSERT(tuple_size <= Storage::BLOCK_SIZE);
-	tuples_per_block = Storage::BLOCK_SIZE / tuple_size;
-	hashes_hdl = buffer_manager.Allocate(Storage::BLOCK_SIZE);
-	hashes_hdl_ptr = hashes_hdl.Ptr();
-
-	switch (entry_type) {
-	case HtEntryType::HT_WIDTH_64: {
-		hash_prefix_shift = (HASH_WIDTH - sizeof(aggr_ht_entry_64::salt)) * 8;
-		Resize<aggr_ht_entry_64>(STANDARD_VECTOR_SIZE * 2);
-		break;
-	}
-	case HtEntryType::HT_WIDTH_32: {
-		hash_prefix_shift = (HASH_WIDTH - sizeof(aggr_ht_entry_32::salt)) * 8;
-		Resize<aggr_ht_entry_32>(STANDARD_VECTOR_SIZE * 2);
-		break;
-	}
-	default:
-		throw InternalException("Unknown HT entry width");
-	}
-
-	// create additional hash tables for distinct aggrs
-	auto &aggregates = layout.GetAggregates();
-	distinct_hashes.resize(aggregates.size());
-
-	idx_t payload_idx = 0;
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggr = aggregates[i];
-		if (aggr.distinct) {
-			// layout types minus hash column plus aggr return type
-			vector<LogicalType> distinct_group_types(layout.GetTypes());
-			(void)distinct_group_types.pop_back();
-			for (idx_t child_idx = 0; child_idx < aggr.child_count; child_idx++) {
-				distinct_group_types.push_back(payload_types[payload_idx + child_idx]);
-			}
-			distinct_hashes[i] =
-			    make_unique<GroupedAggregateHashTable>(allocator, buffer_manager, distinct_group_types);
-		}
-		payload_idx += aggr.child_count;
-	}
-	predicates.resize(layout.ColumnCount() - 1, ExpressionType::COMPARE_EQUAL);
-	string_heap = make_unique<RowDataCollection>(buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
-}
-
-GroupedAggregateHashTable::~GroupedAggregateHashTable() {
-	Destroy();
-}
-
-template <class FUNC>
-void GroupedAggregateHashTable::PayloadApply(FUNC fun) {
-	if (entries == 0) {
-		return;
-	}
-	idx_t apply_entries = entries;
-	idx_t page_nr = 0;
-	idx_t page_offset = 0;
-
-	for (auto &payload_chunk_ptr : payload_hds_ptrs) {
-		auto this_entries = MinValue(tuples_per_block, apply_entries);
-		page_offset = 0;
-		for (data_ptr_t ptr = payload_chunk_ptr, end = payload_chunk_ptr + this_entries * tuple_size; ptr < end;
-		     ptr += tuple_size) {
-			fun(page_nr, page_offset++, ptr);
-		}
-		apply_entries -= this_entries;
-		page_nr++;
-	}
-	D_ASSERT(apply_entries == 0);
-}
-
-void GroupedAggregateHashTable::NewBlock() {
-	auto pin = buffer_manager.Allocate(Storage::BLOCK_SIZE);
-	payload_hds.push_back(move(pin));
-	payload_hds_ptrs.push_back(payload_hds.back().Ptr());
-	payload_page_offset = 0;
-}
-
-void GroupedAggregateHashTable::Destroy() {
-	// check if there is a destructor
-	bool has_destructor = false;
-	for (auto &aggr : layout.GetAggregates()) {
-		if (aggr.function.destructor) {
-			has_destructor = true;
-		}
-	}
-	if (!has_destructor) {
-		return;
-	}
-	// there are aggregates with destructors: loop over the hash table
-	// and call the destructor method for each of the aggregates
-	data_ptr_t data_pointers[STANDARD_VECTOR_SIZE];
-	Vector state_vector(LogicalType::POINTER, (data_ptr_t)data_pointers);
-	idx_t count = 0;
-
-	PayloadApply([&](idx_t page_nr, idx_t page_offset, data_ptr_t ptr) {
-		data_pointers[count++] = ptr;
-		if (count == STANDARD_VECTOR_SIZE) {
-			RowOperations::DestroyStates(layout, state_vector, count);
-			count = 0;
-		}
-	});
-	RowOperations::DestroyStates(layout, state_vector, count);
-}
-
-template <class ENTRY>
-void GroupedAggregateHashTable::VerifyInternal() {
-	auto hashes_ptr = (ENTRY *)hashes_hdl_ptr;
-	D_ASSERT(payload_hds.size() == payload_hds_ptrs.size());
-	idx_t count = 0;
-	for (idx_t i = 0; i < capacity; i++) {
-		if (hashes_ptr[i].page_nr > 0) {
-			D_ASSERT(hashes_ptr[i].page_offset < tuples_per_block);
-			D_ASSERT(hashes_ptr[i].page_nr <= payload_hds.size());
-			auto ptr = payload_hds_ptrs[hashes_ptr[i].page_nr - 1] + ((hashes_ptr[i].page_offset) * tuple_size);
-			auto hash = Load<hash_t>(ptr + hash_offset);
-			D_ASSERT((hashes_ptr[i].salt) == (hash >> hash_prefix_shift));
-
-			count++;
-		}
-	}
-	D_ASSERT(count == entries);
-}
-
-idx_t GroupedAggregateHashTable::MaxCapacity() {
-	idx_t max_pages = 0;
-	idx_t max_tuples = 0;
-
-	switch (entry_type) {
-	case HtEntryType::HT_WIDTH_32:
-		max_pages = NumericLimits<uint8_t>::Maximum();
-		max_tuples = NumericLimits<uint16_t>::Maximum();
-		break;
-	default:
-		D_ASSERT(entry_type == HtEntryType::HT_WIDTH_64);
-		max_pages = NumericLimits<uint32_t>::Maximum();
-		max_tuples = NumericLimits<uint16_t>::Maximum();
-		break;
-	}
-
-	return max_pages * MinValue(max_tuples, (idx_t)Storage::BLOCK_SIZE / tuple_size);
-}
-
-void GroupedAggregateHashTable::Verify() {
-#ifdef DEBUG
-	switch (entry_type) {
-	case HtEntryType::HT_WIDTH_32:
-		VerifyInternal<aggr_ht_entry_32>();
-		break;
-	case HtEntryType::HT_WIDTH_64:
-		VerifyInternal<aggr_ht_entry_64>();
-		break;
-	}
-#endif
-}
-
-template <class ENTRY>
-void GroupedAggregateHashTable::Resize(idx_t size) {
-	Verify();
-
-	D_ASSERT(!is_finalized);
-
-	if (size <= capacity) {
-		throw InternalException("Cannot downsize a hash table!");
-	}
-	D_ASSERT(size >= STANDARD_VECTOR_SIZE);
-
-	// size needs to be a power of 2
-	D_ASSERT((size & (size - 1)) == 0);
-	bitmask = size - 1;
-
-	auto byte_size = size * sizeof(ENTRY);
-	if (byte_size > (idx_t)Storage::BLOCK_SIZE) {
-		hashes_hdl = buffer_manager.Allocate(byte_size);
-		hashes_hdl_ptr = hashes_hdl.Ptr();
-	}
-	memset(hashes_hdl_ptr, 0, byte_size);
-	hashes_end_ptr = hashes_hdl_ptr + byte_size;
-	capacity = size;
-
-	auto hashes_arr = (ENTRY *)hashes_hdl_ptr;
-
-	PayloadApply([&](idx_t page_nr, idx_t page_offset, data_ptr_t ptr) {
-		auto hash = Load<hash_t>(ptr + hash_offset);
-		D_ASSERT((hash & bitmask) == (hash % capacity));
-		auto entry_idx = (idx_t)hash & bitmask;
-		while (hashes_arr[entry_idx].page_nr > 0) {
-			entry_idx++;
-			if (entry_idx >= capacity) {
-				entry_idx = 0;
-			}
-		}
-
-		D_ASSERT(!hashes_arr[entry_idx].page_nr);
-		D_ASSERT(hash >> hash_prefix_shift <= NumericLimits<uint16_t>::Maximum());
-
-		hashes_arr[entry_idx].salt = hash >> hash_prefix_shift;
-		hashes_arr[entry_idx].page_nr = page_nr + 1;
-		hashes_arr[entry_idx].page_offset = page_offset;
-	});
-
-	Verify();
-}
-
-idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, DataChunk &payload) {
-	Vector hashes(LogicalType::HASH);
-	groups.Hash(hashes);
-
-	return AddChunk(groups, hashes, payload);
-}
-
-idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashes, DataChunk &payload) {
-	D_ASSERT(!is_finalized);
-
-	if (groups.size() == 0) {
-		return 0;
-	}
-	// dummy
-	SelectionVector new_groups(STANDARD_VECTOR_SIZE);
-
-	D_ASSERT(groups.ColumnCount() + 1 == layout.ColumnCount());
-	for (idx_t i = 0; i < groups.ColumnCount(); i++) {
-		D_ASSERT(groups.GetTypes()[i] == layout.GetTypes()[i]);
-	}
-
-	Vector addresses(LogicalType::POINTER);
-	auto new_group_count = FindOrCreateGroups(groups, group_hashes, addresses, new_groups);
-	VectorOperations::AddInPlace(addresses, layout.GetAggrOffset(), payload.size());
-
-	// now every cell has an entry
-	// update the aggregates
-	idx_t payload_idx = 0;
-
-	auto &aggregates = layout.GetAggregates();
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		// for any entries for which a group was found, update the aggregate
-		auto &aggr = aggregates[aggr_idx];
-		if (aggr.distinct) {
-			// construct chunk for secondary hash table probing
-			vector<LogicalType> probe_types(groups.GetTypes());
-			for (idx_t i = 0; i < aggr.child_count; i++) {
-				probe_types.push_back(payload_types[payload_idx + i]);
-			}
-			DataChunk probe_chunk;
-			probe_chunk.Initialize(Allocator::DefaultAllocator(), probe_types);
-			for (idx_t group_idx = 0; group_idx < groups.ColumnCount(); group_idx++) {
-				probe_chunk.data[group_idx].Reference(groups.data[group_idx]);
-			}
-			for (idx_t i = 0; i < aggr.child_count; i++) {
-				probe_chunk.data[groups.ColumnCount() + i].Reference(payload.data[payload_idx + i]);
-			}
-			probe_chunk.SetCardinality(groups);
-			probe_chunk.Verify();
-
-			Vector dummy_addresses(LogicalType::POINTER);
-			// this is the actual meat, find out which groups plus payload
-			// value have not been seen yet
-			idx_t new_group_count =
-			    distinct_hashes[aggr_idx]->FindOrCreateGroups(probe_chunk, dummy_addresses, new_groups);
-			if (new_group_count > 0) {
-				// now fix up the payload and addresses accordingly by creating
-				// a selection vector
-				DataChunk distinct_payload;
-				distinct_payload.Initialize(Allocator::DefaultAllocator(), payload.GetTypes());
-				distinct_payload.Slice(payload, new_groups, new_group_count);
-				distinct_payload.Verify();
-
-				Vector distinct_addresses(addresses, new_groups, new_group_count);
-				distinct_addresses.Verify(new_group_count);
-
-				if (aggr.filter) {
-					distinct_addresses.Normalify(new_group_count);
-					RowOperations::UpdateFilteredStates(filter_set.GetFilterData(aggr_idx), aggr, distinct_addresses,
-					                                    distinct_payload, payload_idx);
-				} else {
-					RowOperations::UpdateStates(aggr, distinct_addresses, distinct_payload, payload_idx,
-					                            new_group_count);
-				}
-			}
-		} else if (aggr.filter) {
-			RowOperations::UpdateFilteredStates(filter_set.GetFilterData(aggr_idx), aggr, addresses, payload,
-			                                    payload_idx);
-		} else {
-			RowOperations::UpdateStates(aggr, addresses, payload, payload_idx, payload.size());
-		}
-
-		// move to the next aggregate
-		payload_idx += aggr.child_count;
-		VectorOperations::AddInPlace(addresses, aggr.payload_size, payload.size());
-	}
-
-	Verify();
-	return new_group_count;
-}
-
-void GroupedAggregateHashTable::FetchAggregates(DataChunk &groups, DataChunk &result) {
-	groups.Verify();
-	D_ASSERT(groups.ColumnCount() + 1 == layout.ColumnCount());
-	for (idx_t i = 0; i < result.ColumnCount(); i++) {
-		D_ASSERT(result.data[i].GetType() == payload_types[i]);
-	}
-	result.SetCardinality(groups);
-	if (groups.size() == 0) {
-		return;
-	}
-	// find the groups associated with the addresses
-	// FIXME: this should not use the FindOrCreateGroups, creating them is unnecessary
-	Vector addresses(LogicalType::POINTER);
-	FindOrCreateGroups(groups, addresses);
-	// now fetch the aggregates
-	RowOperations::FinalizeStates(layout, addresses, result, 0);
-}
-
-template <class ENTRY>
-idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, Vector &group_hashes, Vector &addresses,
-                                                            SelectionVector &new_groups_out) {
-	D_ASSERT(!is_finalized);
-
-	if (entries + groups.size() > MaxCapacity()) {
-		throw InternalException("Hash table capacity reached");
-	}
-
-	// resize at 50% capacity, also need to fit the entire vector
-	if (capacity - entries <= groups.size() || entries > capacity / LOAD_FACTOR) {
-		Resize<ENTRY>(capacity * 2);
-	}
-
-	D_ASSERT(capacity - entries >= groups.size());
-	D_ASSERT(groups.ColumnCount() + 1 == layout.ColumnCount());
-	// we need to be able to fit at least one vector of data
-	D_ASSERT(capacity - entries >= groups.size());
-	D_ASSERT(group_hashes.GetType() == LogicalType::HASH);
-
-	group_hashes.Normalify(groups.size());
-	auto group_hashes_ptr = FlatVector::GetData<hash_t>(group_hashes);
-
-	D_ASSERT(ht_offsets.GetVectorType() == VectorType::FLAT_VECTOR);
-	D_ASSERT(ht_offsets.GetType() == LogicalType::BIGINT);
-
-	D_ASSERT(addresses.GetType() == LogicalType::POINTER);
-	addresses.Normalify(groups.size());
-	auto addresses_ptr = FlatVector::GetData<data_ptr_t>(addresses);
-
-	// now compute the entry in the table based on the hash using a modulo
-	UnaryExecutor::Execute<hash_t, uint64_t>(group_hashes, ht_offsets, groups.size(), [&](hash_t element) {
-		D_ASSERT((element & bitmask) == (element % capacity));
-		return (element & bitmask);
-	});
-	auto ht_offsets_ptr = FlatVector::GetData<uint64_t>(ht_offsets);
-
-	// precompute the hash salts for faster comparison below
-	D_ASSERT(hash_salts.GetType() == LogicalType::SMALLINT);
-	UnaryExecutor::Execute<hash_t, uint16_t>(group_hashes, hash_salts, groups.size(),
-	                                         [&](hash_t element) { return (element >> hash_prefix_shift); });
-	auto hash_salts_ptr = FlatVector::GetData<uint16_t>(hash_salts);
-
-	// we start out with all entries [0, 1, 2, ..., groups.size()]
-	const SelectionVector *sel_vector = FlatVector::IncrementalSelectionVector();
-
-	idx_t remaining_entries = groups.size();
-
-	// make a chunk that references the groups and the hashes
-	DataChunk group_chunk;
-	group_chunk.InitializeEmpty(layout.GetTypes());
-	for (idx_t grp_idx = 0; grp_idx < groups.ColumnCount(); grp_idx++) {
-		group_chunk.data[grp_idx].Reference(groups.data[grp_idx]);
-	}
-	group_chunk.data[groups.ColumnCount()].Reference(group_hashes);
-	group_chunk.SetCardinality(groups);
-
-	// orrify all the groups
-	auto group_data = group_chunk.Orrify();
-
-	idx_t new_group_count = 0;
-	while (remaining_entries > 0) {
-		idx_t new_entry_count = 0;
-		idx_t need_compare_count = 0;
-		idx_t no_match_count = 0;
-
-		// first figure out for each remaining whether or not it belongs to a full or empty group
-		for (idx_t i = 0; i < remaining_entries; i++) {
-			const idx_t index = sel_vector->get_index(i);
-			const auto ht_entry_ptr = ((ENTRY *)this->hashes_hdl_ptr) + ht_offsets_ptr[index];
-			if (ht_entry_ptr->page_nr == 0) { // we use page number 0 as a "unused marker"
-				// cell is empty; setup the new entry
-				if (payload_page_offset == tuples_per_block || payload_hds.empty()) {
-					NewBlock();
-				}
-
-				auto entry_payload_ptr = payload_hds_ptrs.back() + (payload_page_offset * tuple_size);
-
-				D_ASSERT(group_hashes_ptr[index] >> hash_prefix_shift <= NumericLimits<uint16_t>::Maximum());
-				D_ASSERT(payload_page_offset < tuples_per_block);
-				D_ASSERT(payload_hds.size() < NumericLimits<uint32_t>::Maximum());
-				D_ASSERT(payload_page_offset + 1 < NumericLimits<uint16_t>::Maximum());
-
-				ht_entry_ptr->salt = group_hashes_ptr[index] >> hash_prefix_shift;
-
-				// page numbers start at one so we can use 0 as empty flag
-				// GetPtr undoes this
-				ht_entry_ptr->page_nr = payload_hds.size();
-				ht_entry_ptr->page_offset = payload_page_offset++;
-
-				// update selection lists for outer loops
-				empty_vector.set_index(new_entry_count++, index);
-				new_groups_out.set_index(new_group_count++, index);
-				entries++;
-
-				addresses_ptr[index] = entry_payload_ptr;
-
-			} else {
-				// cell is occupied: add to check list
-				// only need to check if hash salt in ptr == prefix of hash in payload
-				if (ht_entry_ptr->salt == hash_salts_ptr[index]) {
-					group_compare_vector.set_index(need_compare_count++, index);
-
-					auto page_ptr = payload_hds_ptrs[ht_entry_ptr->page_nr - 1];
-					auto page_offset = ht_entry_ptr->page_offset * tuple_size;
-					addresses_ptr[index] = page_ptr + page_offset;
-
-				} else {
-					no_match_vector.set_index(no_match_count++, index);
-				}
-			}
-		}
-
-		// for each of the locations that are empty, serialize the group columns to the locations
-		RowOperations::Scatter(group_chunk, group_data.get(), layout, addresses, *string_heap, empty_vector,
-		                       new_entry_count);
-		RowOperations::InitializeStates(layout, addresses, empty_vector, new_entry_count);
-
-		// now we have only the tuples remaining that might match to an existing group
-		// start performing comparisons with each of the groups
-		RowOperations::Match(group_chunk, group_data.get(), layout, addresses, predicates, group_compare_vector,
-		                     need_compare_count, &no_match_vector, no_match_count);
-
-		// each of the entries that do not match we move them to the next entry in the HT
-		for (idx_t i = 0; i < no_match_count; i++) {
-			idx_t index = no_match_vector.get_index(i);
-			ht_offsets_ptr[index]++;
-			if (ht_offsets_ptr[index] >= capacity) {
-				ht_offsets_ptr[index] = 0;
-			}
-		}
-		sel_vector = &no_match_vector;
-		remaining_entries = no_match_count;
-	}
-
-	return new_group_count;
-}
-
-// this is to support distinct aggregations where we need to record whether we
-// have already seen a value for a group
-idx_t GroupedAggregateHashTable::FindOrCreateGroups(DataChunk &groups, Vector &group_hashes, Vector &addresses_out,
-                                                    SelectionVector &new_groups_out) {
-	switch (entry_type) {
-	case HtEntryType::HT_WIDTH_64:
-		return FindOrCreateGroupsInternal<aggr_ht_entry_64>(groups, group_hashes, addresses_out, new_groups_out);
-	case HtEntryType::HT_WIDTH_32:
-		return FindOrCreateGroupsInternal<aggr_ht_entry_32>(groups, group_hashes, addresses_out, new_groups_out);
-	default:
-		throw InternalException("Unknown HT entry width");
-	}
-}
-
-void GroupedAggregateHashTable::FindOrCreateGroups(DataChunk &groups, Vector &addresses) {
-	// create a dummy new_groups sel vector
-	SelectionVector new_groups(STANDARD_VECTOR_SIZE);
-	FindOrCreateGroups(groups, addresses, new_groups);
-}
-
-idx_t GroupedAggregateHashTable::FindOrCreateGroups(DataChunk &groups, Vector &addresses_out,
-                                                    SelectionVector &new_groups_out) {
-	Vector hashes(LogicalType::HASH);
-	groups.Hash(hashes);
-	return FindOrCreateGroups(groups, hashes, addresses_out, new_groups_out);
-}
-
-struct FlushMoveState {
-	FlushMoveState(Allocator &allocator, RowLayout &layout)
-	    : new_groups(STANDARD_VECTOR_SIZE), group_addresses(LogicalType::POINTER),
-	      new_groups_sel(STANDARD_VECTOR_SIZE) {
-		vector<LogicalType> group_types(layout.GetTypes().begin(), layout.GetTypes().end() - 1);
-		groups.Initialize(allocator, group_types);
-	}
-
-	DataChunk groups;
-	SelectionVector new_groups;
-	Vector group_addresses;
-	SelectionVector new_groups_sel;
-};
-
-void GroupedAggregateHashTable::FlushMove(FlushMoveState &state, Vector &source_addresses, Vector &source_hashes,
-                                          idx_t count) {
-	D_ASSERT(source_addresses.GetType() == LogicalType::POINTER);
-	D_ASSERT(source_hashes.GetType() == LogicalType::HASH);
-
-	state.groups.Reset();
-	state.groups.SetCardinality(count);
-	for (idx_t i = 0; i < state.groups.ColumnCount(); i++) {
-		auto &column = state.groups.data[i];
-		const auto col_offset = layout.GetOffsets()[i];
-		RowOperations::Gather(source_addresses, *FlatVector::IncrementalSelectionVector(), column,
-		                      *FlatVector::IncrementalSelectionVector(), count, col_offset, i);
-	}
-
-	FindOrCreateGroups(state.groups, source_hashes, state.group_addresses, state.new_groups_sel);
-
-	RowOperations::CombineStates(layout, source_addresses, state.group_addresses, count);
-}
-
-void GroupedAggregateHashTable::Combine(GroupedAggregateHashTable &other) {
-	D_ASSERT(!is_finalized);
-
-	D_ASSERT(other.layout.GetAggrWidth() == layout.GetAggrWidth());
-	D_ASSERT(other.layout.GetDataWidth() == layout.GetDataWidth());
-	D_ASSERT(other.layout.GetRowWidth() == layout.GetRowWidth());
-	D_ASSERT(other.tuples_per_block == tuples_per_block);
-
-	if (other.entries == 0) {
-		return;
-	}
-
-	Vector addresses(LogicalType::POINTER);
-	auto addresses_ptr = FlatVector::GetData<data_ptr_t>(addresses);
-
-	Vector hashes(LogicalType::HASH);
-	auto hashes_ptr = FlatVector::GetData<hash_t>(hashes);
-
-	idx_t group_idx = 0;
-
-	FlushMoveState state(allocator, layout);
-	other.PayloadApply([&](idx_t page_nr, idx_t page_offset, data_ptr_t ptr) {
-		auto hash = Load<hash_t>(ptr + hash_offset);
-
-		hashes_ptr[group_idx] = hash;
-		addresses_ptr[group_idx] = ptr;
-		group_idx++;
-		if (group_idx == STANDARD_VECTOR_SIZE) {
-			FlushMove(state, addresses, hashes, group_idx);
-			group_idx = 0;
-		}
-	});
-	FlushMove(state, addresses, hashes, group_idx);
-	string_heap->Merge(*other.string_heap);
-	Verify();
-}
-
-struct PartitionInfo {
-	PartitionInfo() : addresses(LogicalType::POINTER), hashes(LogicalType::HASH), group_count(0) {
-		addresses_ptr = FlatVector::GetData<data_ptr_t>(addresses);
-		hashes_ptr = FlatVector::GetData<hash_t>(hashes);
-	};
-	Vector addresses;
-	Vector hashes;
-	idx_t group_count;
-	data_ptr_t *addresses_ptr;
-	hash_t *hashes_ptr;
-};
-
-void GroupedAggregateHashTable::Partition(vector<GroupedAggregateHashTable *> &partition_hts, hash_t mask,
-                                          idx_t shift) {
-	D_ASSERT(partition_hts.size() > 1);
-	vector<PartitionInfo> partition_info(partition_hts.size());
-
-	FlushMoveState state(allocator, layout);
-	PayloadApply([&](idx_t page_nr, idx_t page_offset, data_ptr_t ptr) {
-		auto hash = Load<hash_t>(ptr + hash_offset);
-
-		idx_t partition = (hash & mask) >> shift;
-		D_ASSERT(partition < partition_hts.size());
-
-		auto &info = partition_info[partition];
-
-		info.hashes_ptr[info.group_count] = hash;
-		info.addresses_ptr[info.group_count] = ptr;
-		info.group_count++;
-		if (info.group_count == STANDARD_VECTOR_SIZE) {
-			D_ASSERT(partition_hts[partition]);
-			partition_hts[partition]->FlushMove(state, info.addresses, info.hashes, info.group_count);
-			info.group_count = 0;
-		}
-	});
-
-	idx_t info_idx = 0;
-	idx_t total_count = 0;
-	for (auto &partition_entry : partition_hts) {
-		auto &info = partition_info[info_idx++];
-		partition_entry->FlushMove(state, info.addresses, info.hashes, info.group_count);
-
-		partition_entry->string_heap->Merge(*string_heap);
-		partition_entry->Verify();
-		total_count += partition_entry->Size();
-	}
-	D_ASSERT(total_count == entries);
-}
-
-idx_t GroupedAggregateHashTable::Scan(idx_t &scan_position, DataChunk &result) {
-	Vector addresses(LogicalType::POINTER);
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-
-	auto remaining = entries - scan_position;
-	if (remaining == 0) {
-		return 0;
-	}
-	auto this_n = MinValue((idx_t)STANDARD_VECTOR_SIZE, remaining);
-
-	auto chunk_idx = scan_position / tuples_per_block;
-	auto chunk_offset = (scan_position % tuples_per_block) * tuple_size;
-	D_ASSERT(chunk_offset + tuple_size <= Storage::BLOCK_SIZE);
-
-	auto read_ptr = payload_hds_ptrs[chunk_idx++];
-	for (idx_t i = 0; i < this_n; i++) {
-		data_pointers[i] = read_ptr + chunk_offset;
-		chunk_offset += tuple_size;
-		if (chunk_offset >= tuples_per_block * tuple_size) {
-			read_ptr = payload_hds_ptrs[chunk_idx++];
-			chunk_offset = 0;
-		}
-	}
-
-	result.SetCardinality(this_n);
-	// fetch the group columns (ignoring the final hash column
-	const auto group_cols = layout.ColumnCount() - 1;
-	for (idx_t i = 0; i < group_cols; i++) {
-		auto &column = result.data[i];
-		const auto col_offset = layout.GetOffsets()[i];
-		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), column,
-		                      *FlatVector::IncrementalSelectionVector(), result.size(), col_offset, i);
-	}
-
-	RowOperations::FinalizeStates(layout, addresses, result, group_cols);
-
-	scan_position += this_n;
-	return this_n;
-}
-
-void GroupedAggregateHashTable::Finalize() {
-	if (is_finalized) {
-		return;
-	}
-
-	// early release hashes, not needed for partition/scan
-	hashes_hdl.Destroy();
-	is_finalized = true;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-BaseAggregateHashTable::BaseAggregateHashTable(Allocator &allocator, const vector<AggregateObject> &aggregates,
-                                               BufferManager &buffer_manager, vector<LogicalType> payload_types_p)
-    : allocator(allocator), buffer_manager(buffer_manager), payload_types(move(payload_types_p)) {
-	filter_set.Initialize(allocator, aggregates, payload_types);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-ColumnBindingResolver::ColumnBindingResolver() {
-}
-
-void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN || op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		// special case: comparison join
-		auto &comp_join = (LogicalComparisonJoin &)op;
-		// first get the bindings of the LHS and resolve the LHS expressions
-		VisitOperator(*comp_join.children[0]);
-		for (auto &cond : comp_join.conditions) {
-			VisitExpression(&cond.left);
-		}
-		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-			// visit the duplicate eliminated columns on the LHS, if any
-			auto &delim_join = (LogicalDelimJoin &)op;
-			for (auto &expr : delim_join.duplicate_eliminated_columns) {
-				VisitExpression(&expr);
-			}
-		}
-		// then get the bindings of the RHS and resolve the RHS expressions
-		VisitOperator(*comp_join.children[1]);
-		for (auto &cond : comp_join.conditions) {
-			VisitExpression(&cond.right);
-		}
-		// finally update the bindings with the result bindings of the join
-		bindings = op.GetColumnBindings();
-		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
-		// ANY join, this join is different because we evaluate the expression on the bindings of BOTH join sides at
-		// once i.e. we set the bindings first to the bindings of the entire join, and then resolve the expressions of
-		// this operator
-		VisitOperatorChildren(op);
-		bindings = op.GetColumnBindings();
-		VisitOperatorExpressions(op);
-		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_CREATE_INDEX) {
-		// CREATE INDEX statement, add the columns of the table with table index 0 to the binding set
-		// afterwards bind the expressions of the CREATE INDEX statement
-		auto &create_index = (LogicalCreateIndex &)op;
-		bindings = LogicalOperator::GenerateColumnBindings(0, create_index.table.columns.size());
-		VisitOperatorExpressions(op);
-		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_GET) {
-		//! We first need to update the current set of bindings and then visit operator expressions
-		bindings = op.GetColumnBindings();
-		VisitOperatorExpressions(op);
-		return;
-	}
-	// general case
-	// first visit the children of this operator
-	VisitOperatorChildren(op);
-	// now visit the expressions of this operator to resolve any bound column references
-	VisitOperatorExpressions(op);
-	// finally update the current set of bindings to the current set of column bindings
-	bindings = op.GetColumnBindings();
-}
-
-unique_ptr<Expression> ColumnBindingResolver::VisitReplace(BoundColumnRefExpression &expr,
-                                                           unique_ptr<Expression> *expr_ptr) {
-	D_ASSERT(expr.depth == 0);
-	// check the current set of column bindings to see which index corresponds to the column reference
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		if (expr.binding == bindings[i]) {
-			return make_unique<BoundReferenceExpression>(expr.alias, expr.return_type, i);
-		}
-	}
-	// LCOV_EXCL_START
-	// could not bind the column reference, this should never happen and indicates a bug in the code
-	// generate an error message
-	string bound_columns = "[";
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		if (i != 0) {
-			bound_columns += " ";
-		}
-		bound_columns += to_string(bindings[i].table_index) + "." + to_string(bindings[i].column_index);
-	}
-	bound_columns += "]";
-
-	throw InternalException("Failed to bind column reference \"%s\" [%d.%d] (bindings: %s)", expr.alias,
-	                        expr.binding.table_index, expr.binding.column_index, bound_columns);
-	// LCOV_EXCL_STOP
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct BothInclusiveBetweenOperator {
-	template <class T>
-	static inline bool Operation(T input, T lower, T upper) {
-		return GreaterThanEquals::Operation<T>(input, lower) && LessThanEquals::Operation<T>(input, upper);
-	}
-};
-
-struct LowerInclusiveBetweenOperator {
-	template <class T>
-	static inline bool Operation(T input, T lower, T upper) {
-		return GreaterThanEquals::Operation<T>(input, lower) && LessThan::Operation<T>(input, upper);
-	}
-};
-
-struct UpperInclusiveBetweenOperator {
-	template <class T>
-	static inline bool Operation(T input, T lower, T upper) {
-		return GreaterThan::Operation<T>(input, lower) && LessThanEquals::Operation<T>(input, upper);
-	}
-};
-
-struct ExclusiveBetweenOperator {
-	template <class T>
-	static inline bool Operation(T input, T lower, T upper) {
-		return GreaterThan::Operation<T>(input, lower) && LessThan::Operation<T>(input, upper);
-	}
-};
-
-template <class OP>
-static idx_t BetweenLoopTypeSwitch(Vector &input, Vector &lower, Vector &upper, const SelectionVector *sel, idx_t count,
-                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-	switch (input.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TernaryExecutor::Select<int8_t, int8_t, int8_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                           false_sel);
-	case PhysicalType::INT16:
-		return TernaryExecutor::Select<int16_t, int16_t, int16_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                              false_sel);
-	case PhysicalType::INT32:
-		return TernaryExecutor::Select<int32_t, int32_t, int32_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                              false_sel);
-	case PhysicalType::INT64:
-		return TernaryExecutor::Select<int64_t, int64_t, int64_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                              false_sel);
-	case PhysicalType::INT128:
-		return TernaryExecutor::Select<hugeint_t, hugeint_t, hugeint_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                    false_sel);
-	case PhysicalType::UINT8:
-		return TernaryExecutor::Select<uint8_t, uint8_t, uint8_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                              false_sel);
-	case PhysicalType::UINT16:
-		return TernaryExecutor::Select<uint16_t, uint16_t, uint16_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                 false_sel);
-	case PhysicalType::UINT32:
-		return TernaryExecutor::Select<uint32_t, uint32_t, uint32_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                 false_sel);
-	case PhysicalType::UINT64:
-		return TernaryExecutor::Select<uint64_t, uint64_t, uint64_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                 false_sel);
-	case PhysicalType::FLOAT:
-		return TernaryExecutor::Select<float, float, float, OP>(input, lower, upper, sel, count, true_sel, false_sel);
-	case PhysicalType::DOUBLE:
-		return TernaryExecutor::Select<double, double, double, OP>(input, lower, upper, sel, count, true_sel,
-		                                                           false_sel);
-	case PhysicalType::VARCHAR:
-		return TernaryExecutor::Select<string_t, string_t, string_t, OP>(input, lower, upper, sel, count, true_sel,
-		                                                                 false_sel);
-	default:
-		throw InvalidTypeException(input.GetType(), "Invalid type for BETWEEN");
-	}
-}
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundBetweenExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
-	result->AddChild(expr.input.get());
-	result->AddChild(expr.lower.get());
-	result->AddChild(expr.upper.get());
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, Vector &result) {
-	// resolve the children
-	state->intermediate_chunk.Reset();
-
-	auto &input = state->intermediate_chunk.data[0];
-	auto &lower = state->intermediate_chunk.data[1];
-	auto &upper = state->intermediate_chunk.data[2];
-
-	Execute(*expr.input, state->child_states[0].get(), sel, count, input);
-	Execute(*expr.lower, state->child_states[1].get(), sel, count, lower);
-	Execute(*expr.upper, state->child_states[2].get(), sel, count, upper);
-
-	Vector intermediate1(LogicalType::BOOLEAN);
-	Vector intermediate2(LogicalType::BOOLEAN);
-
-	if (expr.upper_inclusive && expr.lower_inclusive) {
-		VectorOperations::GreaterThanEquals(input, lower, intermediate1, count);
-		VectorOperations::LessThanEquals(input, upper, intermediate2, count);
-	} else if (expr.lower_inclusive) {
-		VectorOperations::GreaterThanEquals(input, lower, intermediate1, count);
-		VectorOperations::LessThan(input, upper, intermediate2, count);
-	} else if (expr.upper_inclusive) {
-		VectorOperations::GreaterThan(input, lower, intermediate1, count);
-		VectorOperations::LessThanEquals(input, upper, intermediate2, count);
-	} else {
-		VectorOperations::GreaterThan(input, lower, intermediate1, count);
-		VectorOperations::LessThan(input, upper, intermediate2, count);
-	}
-	VectorOperations::And(intermediate1, intermediate2, result, count);
-}
-
-idx_t ExpressionExecutor::Select(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	// resolve the children
-	Vector input(state->intermediate_chunk.data[0]);
-	Vector lower(state->intermediate_chunk.data[1]);
-	Vector upper(state->intermediate_chunk.data[2]);
-
-	Execute(*expr.input, state->child_states[0].get(), sel, count, input);
-	Execute(*expr.lower, state->child_states[1].get(), sel, count, lower);
-	Execute(*expr.upper, state->child_states[2].get(), sel, count, upper);
-
-	if (expr.upper_inclusive && expr.lower_inclusive) {
-		return BetweenLoopTypeSwitch<BothInclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel,
-		                                                           false_sel);
-	} else if (expr.lower_inclusive) {
-		return BetweenLoopTypeSwitch<LowerInclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel,
-		                                                            false_sel);
-	} else if (expr.upper_inclusive) {
-		return BetweenLoopTypeSwitch<UpperInclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel,
-		                                                            false_sel);
-	} else {
-		return BetweenLoopTypeSwitch<ExclusiveBetweenOperator>(input, lower, upper, sel, count, true_sel, false_sel);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct CaseExpressionState : public ExpressionState {
-	CaseExpressionState(const Expression &expr, ExpressionExecutorState &root)
-	    : ExpressionState(expr, root), true_sel(STANDARD_VECTOR_SIZE), false_sel(STANDARD_VECTOR_SIZE) {
-	}
-
-	SelectionVector true_sel;
-	SelectionVector false_sel;
-};
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCaseExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<CaseExpressionState>(expr, root);
-	for (auto &case_check : expr.case_checks) {
-		result->AddChild(case_check.when_expr.get());
-		result->AddChild(case_check.then_expr.get());
-	}
-	result->AddChild(expr.else_expr.get());
-	result->Finalize();
-	return move(result);
-}
-
-void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionState *state_p, const SelectionVector *sel,
-                                 idx_t count, Vector &result) {
-	auto state = (CaseExpressionState *)state_p;
-
-	state->intermediate_chunk.Reset();
-
-	// first execute the check expression
-	auto current_true_sel = &state->true_sel;
-	auto current_false_sel = &state->false_sel;
-	auto current_sel = sel;
-	idx_t current_count = count;
-	for (idx_t i = 0; i < expr.case_checks.size(); i++) {
-		auto &case_check = expr.case_checks[i];
-		auto &intermediate_result = state->intermediate_chunk.data[i * 2 + 1];
-		auto check_state = state->child_states[i * 2].get();
-		auto then_state = state->child_states[i * 2 + 1].get();
-
-		idx_t tcount =
-		    Select(*case_check.when_expr, check_state, current_sel, current_count, current_true_sel, current_false_sel);
-		if (tcount == 0) {
-			// everything is false: do nothing
-			continue;
-		}
-		idx_t fcount = current_count - tcount;
-		if (fcount == 0 && current_count == count) {
-			// everything is true in the first CHECK statement
-			// we can skip the entire case and only execute the TRUE side
-			Execute(*case_check.then_expr, then_state, sel, count, result);
-			return;
-		} else {
-			// we need to execute and then fill in the desired tuples in the result
-			Execute(*case_check.then_expr, then_state, current_true_sel, tcount, intermediate_result);
-			FillSwitch(intermediate_result, result, *current_true_sel, tcount);
-		}
-		// continue with the false tuples
-		current_sel = current_false_sel;
-		current_count = fcount;
-		if (fcount == 0) {
-			// everything is true: we are done
-			break;
-		}
-	}
-	if (current_count > 0) {
-		auto else_state = state->child_states.back().get();
-		if (current_count == count) {
-			// everything was false, we can just evaluate the else expression directly
-			Execute(*expr.else_expr, else_state, sel, count, result);
-			return;
-		} else {
-			auto &intermediate_result = state->intermediate_chunk.data[expr.case_checks.size() * 2];
-
-			D_ASSERT(current_sel);
-			Execute(*expr.else_expr, else_state, current_sel, current_count, intermediate_result);
-			FillSwitch(intermediate_result, result, *current_sel, current_count);
-		}
-	}
-	if (sel) {
-		result.Slice(*sel, count);
-	}
-}
-
-template <class T>
-void TemplatedFillLoop(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count) {
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto res = FlatVector::GetData<T>(result);
-	auto &result_mask = FlatVector::Validity(result);
-	if (vector.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto data = ConstantVector::GetData<T>(vector);
-		if (ConstantVector::IsNull(vector)) {
-			for (idx_t i = 0; i < count; i++) {
-				result_mask.SetInvalid(sel.get_index(i));
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				res[sel.get_index(i)] = *data;
-			}
-		}
-	} else {
-		VectorData vdata;
-		vector.Orrify(count, vdata);
-		auto data = (T *)vdata.data;
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = vdata.sel->get_index(i);
-			auto res_idx = sel.get_index(i);
-
-			res[res_idx] = data[source_idx];
-			result_mask.Set(res_idx, vdata.validity.RowIsValid(source_idx));
-		}
-	}
-}
-
-void ValidityFillLoop(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count) {
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto &result_mask = FlatVector::Validity(result);
-	if (vector.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		if (ConstantVector::IsNull(vector)) {
-			for (idx_t i = 0; i < count; i++) {
-				result_mask.SetInvalid(sel.get_index(i));
-			}
-		}
-	} else {
-		VectorData vdata;
-		vector.Orrify(count, vdata);
-		if (vdata.validity.AllValid()) {
-			return;
-		}
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = vdata.sel->get_index(i);
-			if (!vdata.validity.RowIsValid(source_idx)) {
-				result_mask.SetInvalid(sel.get_index(i));
-			}
-		}
-	}
-}
-
-void ExpressionExecutor::FillSwitch(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count) {
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedFillLoop<int8_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedFillLoop<int16_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedFillLoop<int32_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedFillLoop<int64_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedFillLoop<uint8_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedFillLoop<uint16_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedFillLoop<uint32_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedFillLoop<uint64_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedFillLoop<hugeint_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedFillLoop<float>(vector, result, sel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedFillLoop<double>(vector, result, sel, count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedFillLoop<interval_t>(vector, result, sel, count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedFillLoop<string_t>(vector, result, sel, count);
-		StringVector::AddHeapReference(result, vector);
-		break;
-	case PhysicalType::STRUCT: {
-		auto &vector_entries = StructVector::GetEntries(vector);
-		auto &result_entries = StructVector::GetEntries(result);
-		ValidityFillLoop(vector, result, sel, count);
-		D_ASSERT(vector_entries.size() == result_entries.size());
-		for (idx_t i = 0; i < vector_entries.size(); i++) {
-			FillSwitch(*vector_entries[i], *result_entries[i], sel, count);
-		}
-		break;
-	}
-	case PhysicalType::LIST: {
-		idx_t offset = ListVector::GetListSize(result);
-		auto &list_child = ListVector::GetEntry(vector);
-		ListVector::Append(result, list_child, ListVector::GetListSize(vector));
-
-		// all the false offsets need to be incremented by true_child.count
-		TemplatedFillLoop<list_entry_t>(vector, result, sel, count);
-		if (offset == 0) {
-			break;
-		}
-
-		auto result_data = FlatVector::GetData<list_entry_t>(result);
-		for (idx_t i = 0; i < count; i++) {
-			auto result_idx = sel.get_index(i);
-			result_data[result_idx].offset += offset;
-		}
-
-		Vector::Verify(result, sel, count);
-		break;
-	}
-	default:
-		throw NotImplementedException("Unimplemented type for case expression: %s", result.GetType().ToString());
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCastExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
-	result->AddChild(expr.child.get());
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundCastExpression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, Vector &result) {
-	// resolve the child
-	state->intermediate_chunk.Reset();
-
-	auto &child = state->intermediate_chunk.data[0];
-	auto child_state = state->child_states[0].get();
-
-	Execute(*expr.child, child_state, sel, count, child);
-	if (expr.try_cast) {
-		string error_message;
-		VectorOperations::TryCast(child, result, count, &error_message);
-	} else {
-		// cast it to the type specified by the cast expression
-		D_ASSERT(result.GetType() == expr.return_type);
-		VectorOperations::Cast(child, result, count);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundComparisonExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
-	result->AddChild(expr.left.get());
-	result->AddChild(expr.right.get());
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundComparisonExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	// resolve the children
-	state->intermediate_chunk.Reset();
-	auto &left = state->intermediate_chunk.data[0];
-	auto &right = state->intermediate_chunk.data[1];
-
-	Execute(*expr.left, state->child_states[0].get(), sel, count, left);
-	Execute(*expr.right, state->child_states[1].get(), sel, count, right);
-
-	switch (expr.type) {
-	case ExpressionType::COMPARE_EQUAL:
-		VectorOperations::Equals(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_NOTEQUAL:
-		VectorOperations::NotEquals(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_LESSTHAN:
-		VectorOperations::LessThan(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-		VectorOperations::GreaterThan(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		VectorOperations::LessThanEquals(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		VectorOperations::GreaterThanEquals(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		VectorOperations::DistinctFrom(left, right, result, count);
-		break;
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		VectorOperations::NotDistinctFrom(left, right, result, count);
-		break;
-	default:
-		throw InternalException("Unknown comparison type!");
-	}
-}
-
-template <typename OP>
-static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                   SelectionVector *true_sel, SelectionVector *false_sel);
-
-template <class OP>
-static idx_t TemplatedSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                      SelectionVector *true_sel, SelectionVector *false_sel) {
-	// the inplace loops take the result as the last parameter
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return BinaryExecutor::Select<int8_t, int8_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INT16:
-		return BinaryExecutor::Select<int16_t, int16_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INT32:
-		return BinaryExecutor::Select<int32_t, int32_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INT64:
-		return BinaryExecutor::Select<int64_t, int64_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::UINT8:
-		return BinaryExecutor::Select<uint8_t, uint8_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::UINT16:
-		return BinaryExecutor::Select<uint16_t, uint16_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::UINT32:
-		return BinaryExecutor::Select<uint32_t, uint32_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::UINT64:
-		return BinaryExecutor::Select<uint64_t, uint64_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INT128:
-		return BinaryExecutor::Select<hugeint_t, hugeint_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::FLOAT:
-		return BinaryExecutor::Select<float, float, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::DOUBLE:
-		return BinaryExecutor::Select<double, double, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::INTERVAL:
-		return BinaryExecutor::Select<interval_t, interval_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::VARCHAR:
-		return BinaryExecutor::Select<string_t, string_t, OP>(left, right, sel, count, true_sel, false_sel);
-	case PhysicalType::LIST:
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-		return NestedSelectOperation<OP>(left, right, sel, count, true_sel, false_sel);
-	default:
-		throw InternalException("Invalid type for comparison");
-	}
-}
-
-struct NestedSelector {
-	// Select the matching rows for the values of a nested type that are not both NULL.
-	// Those semantics are the same as the corresponding non-distinct comparator
-	template <typename OP>
-	static idx_t Select(Vector &left, Vector &right, const SelectionVector &sel, idx_t count, SelectionVector *true_sel,
-	                    SelectionVector *false_sel) {
-		throw InvalidTypeException(left.GetType(), "Invalid operation for nested SELECT");
-	}
-};
-
-template <>
-idx_t NestedSelector::Select<duckdb::Equals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                             SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::NotEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                                SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedNotEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::LessThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                               SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::LessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                     idx_t count, SelectionVector *true_sel,
-                                                     SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::GreaterThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t NestedSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &right, const SelectionVector &sel,
-                                                        idx_t count, SelectionVector *true_sel,
-                                                        SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-static inline idx_t SelectNotNull(Vector &left, Vector &right, const idx_t count, const SelectionVector &sel,
-                                  SelectionVector &maybe_vec, OptionalSelection &false_opt) {
-
-	VectorData lvdata, rvdata;
-	left.Orrify(count, lvdata);
-	right.Orrify(count, rvdata);
-
-	auto &lmask = lvdata.validity;
-	auto &rmask = rvdata.validity;
-
-	// For top-level comparisons, NULL semantics are in effect,
-	// so filter out any NULLs
-	idx_t remaining = 0;
-	if (lmask.AllValid() && rmask.AllValid()) {
-		//	None are NULL, distinguish values.
-		for (idx_t i = 0; i < count; ++i) {
-			const auto idx = sel.get_index(i);
-			maybe_vec.set_index(remaining++, idx);
-		}
-		return remaining;
-	}
-
-	// Slice the Vectors down to the rows that are not determined (i.e., neither is NULL)
-	SelectionVector slicer(count);
-	idx_t false_count = 0;
-	for (idx_t i = 0; i < count; ++i) {
-		const auto result_idx = sel.get_index(i);
-		const auto lidx = lvdata.sel->get_index(i);
-		const auto ridx = rvdata.sel->get_index(i);
-		if (!lmask.RowIsValid(lidx) || !rmask.RowIsValid(ridx)) {
-			false_opt.Append(false_count, result_idx);
-		} else {
-			//	Neither is NULL, distinguish values.
-			slicer.set_index(remaining, i);
-			maybe_vec.set_index(remaining++, result_idx);
-		}
-	}
-	false_opt.Advance(false_count);
-
-	if (remaining && remaining < count) {
-		left.Slice(slicer, remaining);
-		right.Slice(slicer, remaining);
-	}
-
-	return remaining;
-}
-
-static void ScatterSelection(SelectionVector *target, const idx_t count, const SelectionVector &dense_vec) {
-	if (target) {
-		for (idx_t i = 0; i < count; ++i) {
-			target->set_index(i, dense_vec.get_index(i));
-		}
-	}
-}
-
-template <typename OP>
-static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-	// The Select operations all use a dense pair of input vectors to partition
-	// a selection vector in a single pass. But to implement progressive comparisons,
-	// we have to make multiple passes, so we need to keep track of the original input positions
-	// and then scatter the output selections when we are done.
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-
-	// Make buffered selections for progressive comparisons
-	// TODO: Remove unnecessary allocations
-	SelectionVector true_vec(count);
-	OptionalSelection true_opt(&true_vec);
-
-	SelectionVector false_vec(count);
-	OptionalSelection false_opt(&false_vec);
-
-	SelectionVector maybe_vec(count);
-
-	// Handle NULL nested values
-	Vector l_not_null(left);
-	Vector r_not_null(right);
-
-	auto match_count = SelectNotNull(l_not_null, r_not_null, count, *sel, maybe_vec, false_opt);
-	auto no_match_count = count - match_count;
-	count = match_count;
-
-	//	Now that we have handled the NULLs, we can use the recursive nested comparator for the rest.
-	match_count = NestedSelector::Select<OP>(l_not_null, r_not_null, maybe_vec, count, true_opt, false_opt);
-	no_match_count += (count - match_count);
-
-	// Copy the buffered selections to the output selections
-	ScatterSelection(true_sel, match_count, true_vec);
-	ScatterSelection(false_sel, no_match_count, false_vec);
-
-	return match_count;
-}
-
-idx_t VectorOperations::Equals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                               SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::Equals>(left, right, sel, count, true_sel, false_sel);
-}
-
-idx_t VectorOperations::NotEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::NotEquals>(left, right, sel, count, true_sel, false_sel);
-}
-
-idx_t VectorOperations::GreaterThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::GreaterThan>(left, right, sel, count, true_sel, false_sel);
-}
-
-idx_t VectorOperations::GreaterThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                          SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::GreaterThanEquals>(left, right, sel, count, true_sel, false_sel);
-}
-
-idx_t VectorOperations::LessThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                 SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::LessThan>(left, right, sel, count, true_sel, false_sel);
-}
-
-idx_t VectorOperations::LessThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-                                       SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::LessThanEquals>(left, right, sel, count, true_sel, false_sel);
-}
-
-idx_t ExpressionExecutor::Select(const BoundComparisonExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-                                 SelectionVector *false_sel) {
-	// resolve the children
-	state->intermediate_chunk.Reset();
-	auto &left = state->intermediate_chunk.data[0];
-	auto &right = state->intermediate_chunk.data[1];
-
-	Execute(*expr.left, state->child_states[0].get(), sel, count, left);
-	Execute(*expr.right, state->child_states[1].get(), sel, count, right);
-
-	switch (expr.type) {
-	case ExpressionType::COMPARE_EQUAL:
-		return VectorOperations::Equals(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return VectorOperations::NotEquals(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return VectorOperations::LessThan(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return VectorOperations::GreaterThan(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return VectorOperations::DistinctFrom(left, right, sel, count, true_sel, false_sel);
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return VectorOperations::NotDistinctFrom(left, right, sel, count, true_sel, false_sel);
-	default:
-		throw InternalException("Unknown comparison type!");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#include <random>
-
-namespace duckdb {
-
-struct ConjunctionState : public ExpressionState {
-	ConjunctionState(const Expression &expr, ExpressionExecutorState &root) : ExpressionState(expr, root) {
-		adaptive_filter = make_unique<AdaptiveFilter>(expr);
-	}
-	unique_ptr<AdaptiveFilter> adaptive_filter;
-};
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundConjunctionExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ConjunctionState>(expr, root);
-	for (auto &child : expr.children) {
-		result->AddChild(child.get());
-	}
-	result->Finalize();
-	return move(result);
-}
-
-void ExpressionExecutor::Execute(const BoundConjunctionExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	// execute the children
-	state->intermediate_chunk.Reset();
-	for (idx_t i = 0; i < expr.children.size(); i++) {
-		auto &current_result = state->intermediate_chunk.data[i];
-		Execute(*expr.children[i], state->child_states[i].get(), sel, count, current_result);
-		if (i == 0) {
-			// move the result
-			result.Reference(current_result);
-		} else {
-			Vector intermediate(LogicalType::BOOLEAN);
-			// AND/OR together
-			switch (expr.type) {
-			case ExpressionType::CONJUNCTION_AND:
-				VectorOperations::And(current_result, result, intermediate, count);
-				break;
-			case ExpressionType::CONJUNCTION_OR:
-				VectorOperations::Or(current_result, result, intermediate, count);
-				break;
-			default:
-				throw InternalException("Unknown conjunction type!");
-			}
-			result.Reference(intermediate);
-		}
-	}
-}
-
-idx_t ExpressionExecutor::Select(const BoundConjunctionExpression &expr, ExpressionState *state_p,
-                                 const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-                                 SelectionVector *false_sel) {
-	auto state = (ConjunctionState *)state_p;
-
-	if (expr.type == ExpressionType::CONJUNCTION_AND) {
-		// get runtime statistics
-		auto start_time = high_resolution_clock::now();
-
-		const SelectionVector *current_sel = sel;
-		idx_t current_count = count;
-		idx_t false_count = 0;
-
-		unique_ptr<SelectionVector> temp_true, temp_false;
-		if (false_sel) {
-			temp_false = make_unique<SelectionVector>(STANDARD_VECTOR_SIZE);
-		}
-		if (!true_sel) {
-			temp_true = make_unique<SelectionVector>(STANDARD_VECTOR_SIZE);
-			true_sel = temp_true.get();
-		}
-		for (idx_t i = 0; i < expr.children.size(); i++) {
-			idx_t tcount = Select(*expr.children[state->adaptive_filter->permutation[i]],
-			                      state->child_states[state->adaptive_filter->permutation[i]].get(), current_sel,
-			                      current_count, true_sel, temp_false.get());
-			idx_t fcount = current_count - tcount;
-			if (fcount > 0 && false_sel) {
-				// move failing tuples into the false_sel
-				// tuples passed, move them into the actual result vector
-				for (idx_t i = 0; i < fcount; i++) {
-					false_sel->set_index(false_count++, temp_false->get_index(i));
-				}
-			}
-			current_count = tcount;
-			if (current_count == 0) {
-				break;
-			}
-			if (current_count < count) {
-				// tuples were filtered out: move on to using the true_sel to only evaluate passing tuples in subsequent
-				// iterations
-				current_sel = true_sel;
-			}
-		}
-
-		// adapt runtime statistics
-		auto end_time = high_resolution_clock::now();
-		state->adaptive_filter->AdaptRuntimeStatistics(duration_cast<duration<double>>(end_time - start_time).count());
-		return current_count;
-	} else {
-		// get runtime statistics
-		auto start_time = high_resolution_clock::now();
-
-		const SelectionVector *current_sel = sel;
-		idx_t current_count = count;
-		idx_t result_count = 0;
-
-		unique_ptr<SelectionVector> temp_true, temp_false;
-		if (true_sel) {
-			temp_true = make_unique<SelectionVector>(STANDARD_VECTOR_SIZE);
-		}
-		if (!false_sel) {
-			temp_false = make_unique<SelectionVector>(STANDARD_VECTOR_SIZE);
-			false_sel = temp_false.get();
-		}
-		for (idx_t i = 0; i < expr.children.size(); i++) {
-			idx_t tcount = Select(*expr.children[state->adaptive_filter->permutation[i]],
-			                      state->child_states[state->adaptive_filter->permutation[i]].get(), current_sel,
-			                      current_count, temp_true.get(), false_sel);
-			if (tcount > 0) {
-				if (true_sel) {
-					// tuples passed, move them into the actual result vector
-					for (idx_t i = 0; i < tcount; i++) {
-						true_sel->set_index(result_count++, temp_true->get_index(i));
-					}
-				}
-				// now move on to check only the non-passing tuples
-				current_count -= tcount;
-				current_sel = false_sel;
-			}
-		}
-
-		// adapt runtime statistics
-		auto end_time = high_resolution_clock::now();
-		state->adaptive_filter->AdaptRuntimeStatistics(duration_cast<duration<double>>(end_time - start_time).count());
-		return result_count;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundConstantExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundConstantExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	D_ASSERT(expr.value.type() == expr.return_type);
-	result.Reference(expr.value);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-ExecuteFunctionState::ExecuteFunctionState(const Expression &expr, ExpressionExecutorState &root)
-    : ExpressionState(expr, root) {
-}
-
-ExecuteFunctionState::~ExecuteFunctionState() {
-}
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundFunctionExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ExecuteFunctionState>(expr, root);
-	for (auto &child : expr.children) {
-		result->AddChild(child.get());
-	}
-	result->Finalize();
-	if (expr.function.init_local_state) {
-		result->local_state = expr.function.init_local_state(expr, expr.bind_info.get());
-	}
-	return move(result);
-}
-
-void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	state->intermediate_chunk.Reset();
-	auto &arguments = state->intermediate_chunk;
-	if (!state->types.empty()) {
-		for (idx_t i = 0; i < expr.children.size(); i++) {
-			D_ASSERT(state->types[i] == expr.children[i]->return_type);
-			Execute(*expr.children[i], state->child_states[i].get(), sel, count, arguments.data[i]);
-#ifdef DEBUG
-			if (expr.children[i]->return_type.id() == LogicalTypeId::VARCHAR) {
-				arguments.data[i].UTFVerify(count);
-			}
-#endif
-		}
-		arguments.Verify();
-	}
-	arguments.SetCardinality(count);
-	state->profiler.BeginSample();
-	expr.function.function(arguments, *state, result);
-	state->profiler.EndSample(count);
-	D_ASSERT(result.GetType() == expr.return_type);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundOperatorExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
-	for (auto &child : expr.children) {
-		result->AddChild(child.get());
-	}
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	// special handling for special snowflake 'IN'
-	// IN has n children
-	if (expr.type == ExpressionType::COMPARE_IN || expr.type == ExpressionType::COMPARE_NOT_IN) {
-		if (expr.children.size() < 2) {
-			throw Exception("IN needs at least two children");
-		}
-
-		Vector left(expr.children[0]->return_type);
-		// eval left side
-		Execute(*expr.children[0], state->child_states[0].get(), sel, count, left);
-
-		// init result to false
-		Vector intermediate(LogicalType::BOOLEAN);
-		Value false_val = Value::BOOLEAN(false);
-		intermediate.Reference(false_val);
-
-		// in rhs is a list of constants
-		// for every child, OR the result of the comparision with the left
-		// to get the overall result.
-		for (idx_t child = 1; child < expr.children.size(); child++) {
-			Vector vector_to_check(expr.children[child]->return_type);
-			Vector comp_res(LogicalType::BOOLEAN);
-
-			Execute(*expr.children[child], state->child_states[child].get(), sel, count, vector_to_check);
-			VectorOperations::Equals(left, vector_to_check, comp_res, count);
-
-			if (child == 1) {
-				// first child: move to result
-				intermediate.Reference(comp_res);
-			} else {
-				// otherwise OR together
-				Vector new_result(LogicalType::BOOLEAN, true, false);
-				VectorOperations::Or(intermediate, comp_res, new_result, count);
-				intermediate.Reference(new_result);
-			}
-		}
-		if (expr.type == ExpressionType::COMPARE_NOT_IN) {
-			// NOT IN: invert result
-			VectorOperations::Not(intermediate, result, count);
-		} else {
-			// directly use the result
-			result.Reference(intermediate);
-		}
-	} else if (expr.type == ExpressionType::OPERATOR_COALESCE) {
-		SelectionVector sel_a(count);
-		SelectionVector sel_b(count);
-		SelectionVector slice_sel(count);
-		SelectionVector result_sel(count);
-		SelectionVector *next_sel = &sel_a;
-		const SelectionVector *current_sel = sel;
-		idx_t remaining_count = count;
-		idx_t next_count;
-		for (idx_t child = 0; child < expr.children.size(); child++) {
-			Vector vector_to_check(expr.children[child]->return_type);
-			Execute(*expr.children[child], state->child_states[child].get(), current_sel, remaining_count,
-			        vector_to_check);
-
-			VectorData vdata;
-			vector_to_check.Orrify(remaining_count, vdata);
-
-			idx_t result_count = 0;
-			next_count = 0;
-			for (idx_t i = 0; i < remaining_count; i++) {
-				auto base_idx = current_sel ? current_sel->get_index(i) : i;
-				auto idx = vdata.sel->get_index(i);
-				if (vdata.validity.RowIsValid(idx)) {
-					slice_sel.set_index(result_count, i);
-					result_sel.set_index(result_count++, base_idx);
-				} else {
-					next_sel->set_index(next_count++, base_idx);
-				}
-			}
-			if (result_count > 0) {
-				vector_to_check.Slice(slice_sel, result_count);
-				FillSwitch(vector_to_check, result, result_sel, result_count);
-			}
-			current_sel = next_sel;
-			next_sel = next_sel == &sel_a ? &sel_b : &sel_a;
-			remaining_count = next_count;
-			if (next_count == 0) {
-				break;
-			}
-		}
-		if (remaining_count > 0) {
-			for (idx_t i = 0; i < remaining_count; i++) {
-				FlatVector::SetNull(result, current_sel->get_index(i), true);
-			}
-		}
-		if (sel) {
-			result.Slice(*sel, count);
-		} else if (count == 1) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-	} else if (expr.children.size() == 1) {
-		state->intermediate_chunk.Reset();
-		auto &child = state->intermediate_chunk.data[0];
-
-		Execute(*expr.children[0], state->child_states[0].get(), sel, count, child);
-		switch (expr.type) {
-		case ExpressionType::OPERATOR_NOT: {
-			VectorOperations::Not(child, result, count);
-			break;
-		}
-		case ExpressionType::OPERATOR_IS_NULL: {
-			VectorOperations::IsNull(child, result, count);
-			break;
-		}
-		case ExpressionType::OPERATOR_IS_NOT_NULL: {
-			VectorOperations::IsNotNull(child, result, count);
-			break;
-		}
-		default:
-			throw NotImplementedException("Unsupported operator type with 1 child!");
-		}
-	} else {
-		throw NotImplementedException("operator");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundParameterExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundParameterExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	D_ASSERT(expr.value);
-	D_ASSERT(expr.value->type() == expr.return_type);
-	result.Reference(*expr.value);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundReferenceExpression &expr,
-                                                                ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
-	result->Finalize();
-	return result;
-}
-
-void ExpressionExecutor::Execute(const BoundReferenceExpression &expr, ExpressionState *state,
-                                 const SelectionVector *sel, idx_t count, Vector &result) {
-	D_ASSERT(expr.index != DConstants::INVALID_INDEX);
-	D_ASSERT(expr.index < chunk->ColumnCount());
-	if (sel) {
-		result.Slice(chunk->data[expr.index], *sel, count);
-	} else {
-		result.Reference(chunk->data[expr.index]);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ExpressionExecutor::ExpressionExecutor(Allocator &allocator) : allocator(allocator) {
-}
-
-ExpressionExecutor::ExpressionExecutor(Allocator &allocator, const Expression *expression)
-    : ExpressionExecutor(allocator) {
-	D_ASSERT(expression);
-	AddExpression(*expression);
-}
-
-ExpressionExecutor::ExpressionExecutor(Allocator &allocator, const Expression &expression)
-    : ExpressionExecutor(allocator) {
-	AddExpression(expression);
-}
-
-ExpressionExecutor::ExpressionExecutor(Allocator &allocator, const vector<unique_ptr<Expression>> &exprs)
-    : ExpressionExecutor(allocator) {
-	D_ASSERT(exprs.size() > 0);
-	for (auto &expr : exprs) {
-		AddExpression(*expr);
-	}
-}
-
-void ExpressionExecutor::AddExpression(const Expression &expr) {
-	expressions.push_back(&expr);
-	auto state = make_unique<ExpressionExecutorState>(expr.ToString());
-	Initialize(expr, *state);
-	states.push_back(move(state));
-}
-
-void ExpressionExecutor::Initialize(const Expression &expression, ExpressionExecutorState &state) {
-	state.executor = this;
-	state.root_state = InitializeState(expression, state);
-}
-
-void ExpressionExecutor::Execute(DataChunk *input, DataChunk &result) {
-	SetChunk(input);
-	D_ASSERT(expressions.size() == result.ColumnCount());
-	D_ASSERT(!expressions.empty());
-
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		ExecuteExpression(i, result.data[i]);
-	}
-	result.SetCardinality(input ? input->size() : 1);
-	result.Verify();
-}
-
-void ExpressionExecutor::ExecuteExpression(DataChunk &input, Vector &result) {
-	SetChunk(&input);
-	ExecuteExpression(result);
-}
-
-idx_t ExpressionExecutor::SelectExpression(DataChunk &input, SelectionVector &sel) {
-	D_ASSERT(expressions.size() == 1);
-	SetChunk(&input);
-	states[0]->profiler.BeginSample();
-	idx_t selected_tuples = Select(*expressions[0], states[0]->root_state.get(), nullptr, input.size(), &sel, nullptr);
-	states[0]->profiler.EndSample(chunk ? chunk->size() : 0);
-	return selected_tuples;
-}
-
-void ExpressionExecutor::ExecuteExpression(Vector &result) {
-	D_ASSERT(expressions.size() == 1);
-	ExecuteExpression(0, result);
-}
-
-void ExpressionExecutor::ExecuteExpression(idx_t expr_idx, Vector &result) {
-	D_ASSERT(expr_idx < expressions.size());
-	D_ASSERT(result.GetType().id() == expressions[expr_idx]->return_type.id());
-	states[expr_idx]->profiler.BeginSample();
-	Execute(*expressions[expr_idx], states[expr_idx]->root_state.get(), nullptr, chunk ? chunk->size() : 1, result);
-	states[expr_idx]->profiler.EndSample(chunk ? chunk->size() : 0);
-}
-
-Value ExpressionExecutor::EvaluateScalar(const Expression &expr) {
-	D_ASSERT(expr.IsFoldable());
-	D_ASSERT(expr.IsScalar());
-	// use an ExpressionExecutor to execute the expression
-	ExpressionExecutor executor(Allocator::DefaultAllocator(), expr);
-
-	Vector result(expr.return_type);
-	executor.ExecuteExpression(result);
-
-	D_ASSERT(result.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	auto result_value = result.GetValue(0);
-	D_ASSERT(result_value.type().InternalType() == expr.return_type.InternalType());
-	return result_value;
-}
-
-bool ExpressionExecutor::TryEvaluateScalar(const Expression &expr, Value &result) {
-	try {
-		result = EvaluateScalar(expr);
-		return true;
-	} catch (...) {
-		return false;
-	}
-}
-
-void ExpressionExecutor::Verify(const Expression &expr, Vector &vector, idx_t count) {
-	D_ASSERT(expr.return_type.id() == vector.GetType().id());
-	vector.Verify(count);
-	if (expr.verification_stats) {
-		expr.verification_stats->Verify(vector, count);
-	}
-}
-
-unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const Expression &expr,
-                                                                ExpressionExecutorState &state) {
-	switch (expr.expression_class) {
-	case ExpressionClass::BOUND_REF:
-		return InitializeState((const BoundReferenceExpression &)expr, state);
-	case ExpressionClass::BOUND_BETWEEN:
-		return InitializeState((const BoundBetweenExpression &)expr, state);
-	case ExpressionClass::BOUND_CASE:
-		return InitializeState((const BoundCaseExpression &)expr, state);
-	case ExpressionClass::BOUND_CAST:
-		return InitializeState((const BoundCastExpression &)expr, state);
-	case ExpressionClass::BOUND_COMPARISON:
-		return InitializeState((const BoundComparisonExpression &)expr, state);
-	case ExpressionClass::BOUND_CONJUNCTION:
-		return InitializeState((const BoundConjunctionExpression &)expr, state);
-	case ExpressionClass::BOUND_CONSTANT:
-		return InitializeState((const BoundConstantExpression &)expr, state);
-	case ExpressionClass::BOUND_FUNCTION:
-		return InitializeState((const BoundFunctionExpression &)expr, state);
-	case ExpressionClass::BOUND_OPERATOR:
-		return InitializeState((const BoundOperatorExpression &)expr, state);
-	case ExpressionClass::BOUND_PARAMETER:
-		return InitializeState((const BoundParameterExpression &)expr, state);
-	default:
-		throw InternalException("Attempting to initialize state of expression of unknown type!");
-	}
-}
-
-void ExpressionExecutor::Execute(const Expression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, Vector &result) {
-#ifdef DEBUG
-	if (result.GetVectorType() == VectorType::FLAT_VECTOR) {
-		D_ASSERT(FlatVector::Validity(result).CheckAllValid(count));
-	}
-#endif
-
-	if (count == 0) {
-		return;
-	}
-	switch (expr.expression_class) {
-	case ExpressionClass::BOUND_BETWEEN:
-		Execute((const BoundBetweenExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_REF:
-		Execute((const BoundReferenceExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_CASE:
-		Execute((const BoundCaseExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_CAST:
-		Execute((const BoundCastExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_COMPARISON:
-		Execute((const BoundComparisonExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_CONJUNCTION:
-		Execute((const BoundConjunctionExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_CONSTANT:
-		Execute((const BoundConstantExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_FUNCTION:
-		Execute((const BoundFunctionExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_OPERATOR:
-		Execute((const BoundOperatorExpression &)expr, state, sel, count, result);
-		break;
-	case ExpressionClass::BOUND_PARAMETER:
-		Execute((const BoundParameterExpression &)expr, state, sel, count, result);
-		break;
-	default:
-		throw InternalException("Attempting to execute expression of unknown type!");
-	}
-	Verify(expr, result, count);
-}
-
-idx_t ExpressionExecutor::Select(const Expression &expr, ExpressionState *state, const SelectionVector *sel,
-                                 idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (count == 0) {
-		return 0;
-	}
-	D_ASSERT(true_sel || false_sel);
-	D_ASSERT(expr.return_type.id() == LogicalTypeId::BOOLEAN);
-	switch (expr.expression_class) {
-	case ExpressionClass::BOUND_BETWEEN:
-		return Select((BoundBetweenExpression &)expr, state, sel, count, true_sel, false_sel);
-	case ExpressionClass::BOUND_COMPARISON:
-		return Select((BoundComparisonExpression &)expr, state, sel, count, true_sel, false_sel);
-	case ExpressionClass::BOUND_CONJUNCTION:
-		return Select((BoundConjunctionExpression &)expr, state, sel, count, true_sel, false_sel);
-	default:
-		return DefaultSelect(expr, state, sel, count, true_sel, false_sel);
-	}
-}
-
-template <bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-static inline idx_t DefaultSelectLoop(const SelectionVector *bsel, uint8_t *__restrict bdata, ValidityMask &mask,
-                                      const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-                                      SelectionVector *false_sel) {
-	idx_t true_count = 0, false_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto bidx = bsel->get_index(i);
-		auto result_idx = sel->get_index(i);
-		if (bdata[bidx] > 0 && (NO_NULL || mask.RowIsValid(bidx))) {
-			if (HAS_TRUE_SEL) {
-				true_sel->set_index(true_count++, result_idx);
-			}
-		} else {
-			if (HAS_FALSE_SEL) {
-				false_sel->set_index(false_count++, result_idx);
-			}
-		}
-	}
-	if (HAS_TRUE_SEL) {
-		return true_count;
-	} else {
-		return count - false_count;
-	}
-}
-
-template <bool NO_NULL>
-static inline idx_t DefaultSelectSwitch(VectorData &idata, const SelectionVector *sel, idx_t count,
-                                        SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (true_sel && false_sel) {
-		return DefaultSelectLoop<NO_NULL, true, true>(idata.sel, (uint8_t *)idata.data, idata.validity, sel, count,
-		                                              true_sel, false_sel);
-	} else if (true_sel) {
-		return DefaultSelectLoop<NO_NULL, true, false>(idata.sel, (uint8_t *)idata.data, idata.validity, sel, count,
-		                                               true_sel, false_sel);
-	} else {
-		D_ASSERT(false_sel);
-		return DefaultSelectLoop<NO_NULL, false, true>(idata.sel, (uint8_t *)idata.data, idata.validity, sel, count,
-		                                               true_sel, false_sel);
-	}
-}
-
-idx_t ExpressionExecutor::DefaultSelect(const Expression &expr, ExpressionState *state, const SelectionVector *sel,
-                                        idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	// generic selection of boolean expression:
-	// resolve the true/false expression first
-	// then use that to generate the selection vector
-	bool intermediate_bools[STANDARD_VECTOR_SIZE];
-	Vector intermediate(LogicalType::BOOLEAN, (data_ptr_t)intermediate_bools);
-	Execute(expr, state, sel, count, intermediate);
-
-	VectorData idata;
-	intermediate.Orrify(count, idata);
-
-	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector();
-	}
-	if (!idata.validity.AllValid()) {
-		return DefaultSelectSwitch<false>(idata, sel, count, true_sel, false_sel);
-	} else {
-		return DefaultSelectSwitch<true>(idata, sel, count, true_sel, false_sel);
-	}
-}
-
-vector<unique_ptr<ExpressionExecutorState>> &ExpressionExecutor::GetStates() {
-	return states;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-void ExpressionState::AddChild(Expression *expr) {
-	types.push_back(expr->return_type);
-	child_states.push_back(ExpressionExecutor::InitializeState(*expr, root));
-}
-
-void ExpressionState::Finalize() {
-	if (!types.empty()) {
-		intermediate_chunk.Initialize(root.executor->allocator, types);
-	}
-}
-ExpressionState::ExpressionState(const Expression &expr, ExpressionExecutorState &root)
-    : expr(expr), root(root), name(expr.ToString()) {
-}
-
-ExpressionExecutorState::ExpressionExecutorState(const string &name) : profiler(), name(name) {
-}
-} // namespace duckdb
-
-
-
-
-
-
-#include <algorithm>
-#include <cstring>
-#include <ctgmath>
-
-namespace duckdb {
-
-ART::ART(const vector<column_t> &column_ids, const vector<unique_ptr<Expression>> &unbound_expressions,
-         IndexConstraintType constraint_type)
-    : Index(IndexType::ART, column_ids, unbound_expressions, constraint_type) {
-	tree = nullptr;
-	is_little_endian = Radix::IsLittleEndian();
-	for (idx_t i = 0; i < types.size(); i++) {
-		switch (types[i]) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-		case PhysicalType::INT16:
-		case PhysicalType::INT32:
-		case PhysicalType::INT64:
-		case PhysicalType::INT128:
-		case PhysicalType::UINT8:
-		case PhysicalType::UINT16:
-		case PhysicalType::UINT32:
-		case PhysicalType::UINT64:
-		case PhysicalType::FLOAT:
-		case PhysicalType::DOUBLE:
-		case PhysicalType::VARCHAR:
-			break;
-		default:
-			throw InvalidTypeException(logical_types[i], "Invalid type for index");
-		}
-	}
-}
-
-ART::~ART() {
-}
-
-bool ART::LeafMatches(Node *node, Key &key, unsigned depth) {
-	auto leaf = static_cast<Leaf *>(node);
-	Key &leaf_key = *leaf->value;
-	for (idx_t i = depth; i < leaf_key.len; i++) {
-		if (leaf_key[i] != key[i]) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-unique_ptr<IndexScanState> ART::InitializeScanSinglePredicate(Transaction &transaction, Value value,
-                                                              ExpressionType expression_type) {
-	auto result = make_unique<ARTIndexScanState>();
-	result->values[0] = value;
-	result->expressions[0] = expression_type;
-	return move(result);
-}
-
-unique_ptr<IndexScanState> ART::InitializeScanTwoPredicates(Transaction &transaction, Value low_value,
-                                                            ExpressionType low_expression_type, Value high_value,
-                                                            ExpressionType high_expression_type) {
-	auto result = make_unique<ARTIndexScanState>();
-	result->values[0] = low_value;
-	result->expressions[0] = low_expression_type;
-	result->values[1] = high_value;
-	result->expressions[1] = high_expression_type;
-	return move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Insert
-//===--------------------------------------------------------------------===//
-template <class T>
-static void TemplatedGenerateKeys(Vector &input, idx_t count, vector<unique_ptr<Key>> &keys, bool is_little_endian) {
-	VectorData idata;
-	input.Orrify(count, idata);
-
-	auto input_data = (T *)idata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = idata.sel->get_index(i);
-		if (idata.validity.RowIsValid(idx)) {
-			keys.push_back(Key::CreateKey<T>(input_data[idx], is_little_endian));
-		} else {
-			keys.push_back(nullptr);
-		}
-	}
-}
-
-template <class T>
-static void ConcatenateKeys(Vector &input, idx_t count, vector<unique_ptr<Key>> &keys, bool is_little_endian) {
-	VectorData idata;
-	input.Orrify(count, idata);
-
-	auto input_data = (T *)idata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = idata.sel->get_index(i);
-		if (!idata.validity.RowIsValid(idx) || !keys[i]) {
-			// either this column is NULL, or the previous column is NULL!
-			keys[i] = nullptr;
-		} else {
-			// concatenate the keys
-			auto old_key = move(keys[i]);
-			auto new_key = Key::CreateKey<T>(input_data[idx], is_little_endian);
-			auto key_len = old_key->len + new_key->len;
-			auto compound_data = unique_ptr<data_t[]>(new data_t[key_len]);
-			memcpy(compound_data.get(), old_key->data.get(), old_key->len);
-			memcpy(compound_data.get() + old_key->len, new_key->data.get(), new_key->len);
-			keys[i] = make_unique<Key>(move(compound_data), key_len);
-		}
-	}
-}
-
-void ART::GenerateKeys(DataChunk &input, vector<unique_ptr<Key>> &keys) {
-	keys.reserve(STANDARD_VECTOR_SIZE);
-	// generate keys for the first input column
-	switch (input.data[0].GetType().InternalType()) {
-	case PhysicalType::BOOL:
-		TemplatedGenerateKeys<bool>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::INT8:
-		TemplatedGenerateKeys<int8_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::INT16:
-		TemplatedGenerateKeys<int16_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::INT32:
-		TemplatedGenerateKeys<int32_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::INT64:
-		TemplatedGenerateKeys<int64_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::INT128:
-		TemplatedGenerateKeys<hugeint_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedGenerateKeys<uint8_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedGenerateKeys<uint16_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedGenerateKeys<uint32_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedGenerateKeys<uint64_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedGenerateKeys<float>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGenerateKeys<double>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedGenerateKeys<string_t>(input.data[0], input.size(), keys, is_little_endian);
-		break;
-	default:
-		throw InternalException("Invalid type for index");
-	}
-
-	for (idx_t i = 1; i < input.ColumnCount(); i++) {
-		// for each of the remaining columns, concatenate
-		switch (input.data[i].GetType().InternalType()) {
-		case PhysicalType::BOOL:
-			ConcatenateKeys<bool>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::INT8:
-			ConcatenateKeys<int8_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::INT16:
-			ConcatenateKeys<int16_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::INT32:
-			ConcatenateKeys<int32_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::INT64:
-			ConcatenateKeys<int64_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::INT128:
-			ConcatenateKeys<hugeint_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::UINT8:
-			ConcatenateKeys<uint8_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::UINT16:
-			ConcatenateKeys<uint16_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::UINT32:
-			ConcatenateKeys<uint32_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::UINT64:
-			ConcatenateKeys<uint64_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::FLOAT:
-			ConcatenateKeys<float>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::DOUBLE:
-			ConcatenateKeys<double>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		case PhysicalType::VARCHAR:
-			ConcatenateKeys<string_t>(input.data[i], input.size(), keys, is_little_endian);
-			break;
-		default:
-			throw InternalException("Invalid type for index");
-		}
-	}
-}
-
-bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
-	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-	D_ASSERT(logical_types[0] == input.data[0].GetType());
-
-	// generate the keys for the given input
-	vector<unique_ptr<Key>> keys;
-	GenerateKeys(input, keys);
-
-	// now insert the elements into the index
-	row_ids.Normalify(input.size());
-	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
-	idx_t failed_index = DConstants::INVALID_INDEX;
-	for (idx_t i = 0; i < input.size(); i++) {
-		if (!keys[i]) {
-			continue;
-		}
-
-		row_t row_id = row_identifiers[i];
-		if (!Insert(tree, move(keys[i]), 0, row_id)) {
-			// failed to insert because of constraint violation
-			failed_index = i;
-			break;
-		}
-	}
-	if (failed_index != DConstants::INVALID_INDEX) {
-		// failed to insert because of constraint violation: remove previously inserted entries
-		// generate keys again
-		keys.clear();
-		GenerateKeys(input, keys);
-		unique_ptr<Key> key;
-
-		// now erase the entries
-		for (idx_t i = 0; i < failed_index; i++) {
-			if (!keys[i]) {
-				continue;
-			}
-			row_t row_id = row_identifiers[i];
-			Erase(tree, *keys[i], 0, row_id);
-		}
-		return false;
-	}
-	return true;
-}
-
-bool ART::Append(IndexLock &lock, DataChunk &appended_data, Vector &row_identifiers) {
-	DataChunk expression_result;
-	expression_result.Initialize(Allocator::DefaultAllocator(), logical_types);
-
-	// first resolve the expressions for the index
-	ExecuteExpressions(appended_data, expression_result);
-
-	// now insert into the index
-	return Insert(lock, expression_result, row_identifiers);
-}
-
-void ART::VerifyAppend(DataChunk &chunk) {
-	VerifyExistence(chunk, VerifyExistenceType::APPEND);
-}
-
-void ART::VerifyAppendForeignKey(DataChunk &chunk, string *err_msg_ptr) {
-	VerifyExistence(chunk, VerifyExistenceType::APPEND_FK, err_msg_ptr);
-}
-
-void ART::VerifyDeleteForeignKey(DataChunk &chunk, string *err_msg_ptr) {
-	VerifyExistence(chunk, VerifyExistenceType::DELETE_FK, err_msg_ptr);
-}
-
-bool ART::InsertToLeaf(Leaf &leaf, row_t row_id) {
-	if (IsUnique() && leaf.num_elements != 0) {
-		return false;
-	}
-	leaf.Insert(row_id);
-	return true;
-}
-
-bool ART::Insert(unique_ptr<Node> &node, unique_ptr<Key> value, unsigned depth, row_t row_id) {
-	Key &key = *value;
-	if (!node) {
-		// node is currently empty, create a leaf here with the key
-		node = make_unique<Leaf>(*this, move(value), row_id);
-		return true;
-	}
-
-	if (node->type == NodeType::NLeaf) {
-		// Replace leaf with Node4 and store both leaves in it
-		auto leaf = static_cast<Leaf *>(node.get());
-
-		Key &existing_key = *leaf->value;
-		uint32_t new_prefix_length = 0;
-		// Leaf node is already there, update row_id vector
-		if (depth + new_prefix_length == existing_key.len && existing_key.len == key.len) {
-			return InsertToLeaf(*leaf, row_id);
-		}
-		while (existing_key[depth + new_prefix_length] == key[depth + new_prefix_length]) {
-			new_prefix_length++;
-			// Leaf node is already there, update row_id vector
-			if (depth + new_prefix_length == existing_key.len && existing_key.len == key.len) {
-				return InsertToLeaf(*leaf, row_id);
-			}
-		}
-
-		unique_ptr<Node> new_node = make_unique<Node4>(*this, new_prefix_length);
-		new_node->prefix_length = new_prefix_length;
-		memcpy(new_node->prefix.get(), &key[depth], new_prefix_length);
-		Node4::Insert(*this, new_node, existing_key[depth + new_prefix_length], node);
-		unique_ptr<Node> leaf_node = make_unique<Leaf>(*this, move(value), row_id);
-		Node4::Insert(*this, new_node, key[depth + new_prefix_length], leaf_node);
-		node = move(new_node);
-		return true;
-	}
-
-	// Handle prefix of inner node
-	if (node->prefix_length) {
-		uint32_t mismatch_pos = Node::PrefixMismatch(*this, node.get(), key, depth);
-		if (mismatch_pos != node->prefix_length) {
-			// Prefix differs, create new node
-			unique_ptr<Node> new_node = make_unique<Node4>(*this, mismatch_pos);
-			new_node->prefix_length = mismatch_pos;
-			memcpy(new_node->prefix.get(), node->prefix.get(), mismatch_pos);
-			// Break up prefix
-			auto node_ptr = node.get();
-			Node4::Insert(*this, new_node, node->prefix[mismatch_pos], node);
-			node_ptr->prefix_length -= (mismatch_pos + 1);
-			memmove(node_ptr->prefix.get(), node_ptr->prefix.get() + mismatch_pos + 1, node_ptr->prefix_length);
-			unique_ptr<Node> leaf_node = make_unique<Leaf>(*this, move(value), row_id);
-			Node4::Insert(*this, new_node, key[depth + mismatch_pos], leaf_node);
-			node = move(new_node);
-			return true;
-		}
-		depth += node->prefix_length;
-	}
-
-	// Recurse
-	idx_t pos = node->GetChildPos(key[depth]);
-	if (pos != DConstants::INVALID_INDEX) {
-		auto child = node->GetChild(pos);
-		return Insert(*child, move(value), depth + 1, row_id);
-	}
-	unique_ptr<Node> new_node = make_unique<Leaf>(*this, move(value), row_id);
-	Node::InsertLeaf(*this, node, key[depth], new_node);
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Delete
-//===--------------------------------------------------------------------===//
-void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
-	DataChunk expression_result;
-	expression_result.Initialize(Allocator::DefaultAllocator(), logical_types);
-
-	// first resolve the expressions
-	ExecuteExpressions(input, expression_result);
-
-	// then generate the keys for the given input
-	vector<unique_ptr<Key>> keys;
-	GenerateKeys(expression_result, keys);
-
-	// now erase the elements from the database
-	row_ids.Normalify(input.size());
-	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
-
-	for (idx_t i = 0; i < input.size(); i++) {
-		if (!keys[i]) {
-			continue;
-		}
-		Erase(tree, *keys[i], 0, row_identifiers[i]);
-#ifdef DEBUG
-		auto node = Lookup(tree, *keys[i], 0);
-		if (node) {
-			auto leaf = static_cast<Leaf *>(node);
-			for (idx_t k = 0; k < leaf->num_elements; k++) {
-				D_ASSERT(leaf->GetRowId(k) != row_identifiers[i]);
-			}
-		}
-#endif
-	}
-}
-
-void ART::Erase(unique_ptr<Node> &node, Key &key, unsigned depth, row_t row_id) {
-	if (!node) {
-		return;
-	}
-	// Delete a leaf from a tree
-	if (node->type == NodeType::NLeaf) {
-		// Make sure we have the right leaf
-		if (ART::LeafMatches(node.get(), key, depth)) {
-			auto leaf = static_cast<Leaf *>(node.get());
-			leaf->Remove(row_id);
-			if (leaf->num_elements == 0) {
-				node.reset();
-			}
-		}
-		return;
-	}
-
-	// Handle prefix
-	if (node->prefix_length) {
-		if (Node::PrefixMismatch(*this, node.get(), key, depth) != node->prefix_length) {
-			return;
-		}
-		depth += node->prefix_length;
-	}
-	idx_t pos = node->GetChildPos(key[depth]);
-	if (pos != DConstants::INVALID_INDEX) {
-		auto child = node->GetChild(pos);
-		D_ASSERT(child);
-
-		unique_ptr<Node> &child_ref = *child;
-		if (child_ref->type == NodeType::NLeaf && LeafMatches(child_ref.get(), key, depth)) {
-			// Leaf found, remove entry
-			auto leaf = static_cast<Leaf *>(child_ref.get());
-			leaf->Remove(row_id);
-			if (leaf->num_elements == 0) {
-				// Leaf is empty, delete leaf, decrement node counter and maybe shrink node
-				Node::Erase(*this, node, pos);
-			}
-		} else {
-			// Recurse
-			Erase(*child, key, depth + 1, row_id);
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Point Query
-//===--------------------------------------------------------------------===//
-static unique_ptr<Key> CreateKey(ART &art, PhysicalType type, Value &value) {
-	D_ASSERT(type == value.type().InternalType());
-	switch (type) {
-	case PhysicalType::BOOL:
-		return Key::CreateKey<bool>(value, art.is_little_endian);
-	case PhysicalType::INT8:
-		return Key::CreateKey<int8_t>(value, art.is_little_endian);
-	case PhysicalType::INT16:
-		return Key::CreateKey<int16_t>(value, art.is_little_endian);
-	case PhysicalType::INT32:
-		return Key::CreateKey<int32_t>(value, art.is_little_endian);
-	case PhysicalType::INT64:
-		return Key::CreateKey<int64_t>(value, art.is_little_endian);
-	case PhysicalType::UINT8:
-		return Key::CreateKey<uint8_t>(value, art.is_little_endian);
-	case PhysicalType::UINT16:
-		return Key::CreateKey<uint16_t>(value, art.is_little_endian);
-	case PhysicalType::UINT32:
-		return Key::CreateKey<uint32_t>(value, art.is_little_endian);
-	case PhysicalType::UINT64:
-		return Key::CreateKey<uint64_t>(value, art.is_little_endian);
-	case PhysicalType::INT128:
-		return Key::CreateKey<hugeint_t>(value, art.is_little_endian);
-	case PhysicalType::FLOAT:
-		return Key::CreateKey<float>(value, art.is_little_endian);
-	case PhysicalType::DOUBLE:
-		return Key::CreateKey<double>(value, art.is_little_endian);
-	case PhysicalType::VARCHAR:
-		return Key::CreateKey<string_t>(value, art.is_little_endian);
-	default:
-		throw InternalException("Invalid type for index");
-	}
-}
-
-bool ART::SearchEqual(ARTIndexScanState *state, idx_t max_count, vector<row_t> &result_ids) {
-	auto key = CreateKey(*this, types[0], state->values[0]);
-	auto leaf = static_cast<Leaf *>(Lookup(tree, *key, 0));
-	if (!leaf) {
-		return true;
-	}
-	if (leaf->num_elements > max_count) {
-		return false;
-	}
-	for (idx_t i = 0; i < leaf->num_elements; i++) {
-		row_t row_id = leaf->GetRowId(i);
-		result_ids.push_back(row_id);
-	}
-	return true;
-}
-
-void ART::SearchEqualJoinNoFetch(Value &equal_value, idx_t &result_size) {
-	//! We need to look for a leaf
-	auto key = CreateKey(*this, types[0], equal_value);
-	auto leaf = static_cast<Leaf *>(Lookup(tree, *key, 0));
-	if (!leaf) {
-		return;
-	}
-	result_size = leaf->num_elements;
-}
-
-Node *ART::Lookup(unique_ptr<Node> &node, Key &key, unsigned depth) {
-	auto node_val = node.get();
-
-	while (node_val) {
-		if (node_val->type == NodeType::NLeaf) {
-			auto leaf = static_cast<Leaf *>(node_val);
-			Key &leaf_key = *leaf->value;
-			//! Check leaf
-			for (idx_t i = depth; i < leaf_key.len; i++) {
-				if (leaf_key[i] != key[i]) {
-					return nullptr;
-				}
-			}
-			return node_val;
-		}
-		if (node_val->prefix_length) {
-			for (idx_t pos = 0; pos < node_val->prefix_length; pos++) {
-				if (key[depth + pos] != node_val->prefix[pos]) {
-					return nullptr;
-				}
-			}
-			depth += node_val->prefix_length;
-		}
-		idx_t pos = node_val->GetChildPos(key[depth]);
-		if (pos == DConstants::INVALID_INDEX) {
-			return nullptr;
-		}
-		node_val = node_val->GetChild(pos)->get();
-		D_ASSERT(node_val);
-
-		depth++;
-	}
-
-	return nullptr;
-}
-
-//===--------------------------------------------------------------------===//
-// Iterator scans
-//===--------------------------------------------------------------------===//
-template <bool HAS_BOUND, bool INCLUSIVE>
-bool ART::IteratorScan(ARTIndexScanState *state, Iterator *it, Key *bound, idx_t max_count, vector<row_t> &result_ids) {
-	bool has_next;
-	do {
-		if (HAS_BOUND) {
-			D_ASSERT(bound);
-			if (INCLUSIVE) {
-				if (*it->node->value > *bound) {
-					break;
-				}
-			} else {
-				if (*it->node->value >= *bound) {
-					break;
-				}
-			}
-		}
-		if (result_ids.size() + it->node->num_elements > max_count) {
-			// adding these elements would exceed the max count
-			return false;
-		}
-		for (idx_t i = 0; i < it->node->num_elements; i++) {
-			row_t row_id = it->node->GetRowId(i);
-			result_ids.push_back(row_id);
-		}
-		has_next = ART::IteratorNext(*it);
-	} while (has_next);
-	return true;
-}
-
-void Iterator::SetEntry(idx_t entry_depth, IteratorEntry entry) {
-	if (stack.size() < entry_depth + 1) {
-		stack.resize(MaxValue<idx_t>(8, MaxValue<idx_t>(entry_depth + 1, stack.size() * 2)));
-	}
-	stack[entry_depth] = entry;
-}
-
-bool ART::IteratorNext(Iterator &it) {
-	// Skip leaf
-	if ((it.depth) && ((it.stack[it.depth - 1].node)->type == NodeType::NLeaf)) {
-		it.depth--;
-	}
-
-	// Look for the next leaf
-	while (it.depth > 0) {
-		auto &top = it.stack[it.depth - 1];
-		Node *node = top.node;
-
-		if (node->type == NodeType::NLeaf) {
-			// found a leaf: move to next node
-			it.node = (Leaf *)node;
-			return true;
-		}
-
-		// Find next node
-		top.pos = node->GetNextPos(top.pos);
-		if (top.pos != DConstants::INVALID_INDEX) {
-			// next node found: go there
-			it.SetEntry(it.depth, IteratorEntry(node->GetChild(top.pos)->get(), DConstants::INVALID_INDEX));
-			it.depth++;
-		} else {
-			// no node found: move up the tree
-			it.depth--;
-		}
-	}
-	return false;
-}
-
-//===--------------------------------------------------------------------===//
-// Greater Than
-// Returns: True (If found leaf >= key)
-//          False (Otherwise)
-//===--------------------------------------------------------------------===//
-bool ART::Bound(unique_ptr<Node> &n, Key &key, Iterator &it, bool inclusive) {
-	it.depth = 0;
-	bool equal = false;
-	if (!n) {
-		return false;
-	}
-	Node *node = n.get();
-
-	idx_t depth = 0;
-	while (true) {
-		it.SetEntry(it.depth, IteratorEntry(node, 0));
-		auto &top = it.stack[it.depth];
-		it.depth++;
-		if (!equal) {
-			while (node->type != NodeType::NLeaf) {
-				node = node->GetChild(node->GetMin())->get();
-				auto &c_top = it.stack[it.depth];
-				c_top.node = node;
-				it.depth++;
-			}
-		}
-		if (node->type == NodeType::NLeaf) {
-			// found a leaf node: check if it is bigger or equal than the current key
-			auto leaf = static_cast<Leaf *>(node);
-			it.node = leaf;
-			// if the search is not inclusive the leaf node could still be equal to the current value
-			// check if leaf is equal to the current key
-			if (*leaf->value == key) {
-				// if its not inclusive check if there is a next leaf
-				if (!inclusive && !IteratorNext(it)) {
-					return false;
-				} else {
-					return true;
-				}
-			}
-
-			if (*leaf->value > key) {
-				return true;
-			}
-			// Leaf is lower than key
-			// Check if next leaf is still lower than key
-			while (IteratorNext(it)) {
-				if (*it.node->value == key) {
-					// if its not inclusive check if there is a next leaf
-					if (!inclusive && !IteratorNext(it)) {
-						return false;
-					} else {
-						return true;
-					}
-				} else if (*it.node->value > key) {
-					// if its not inclusive check if there is a next leaf
-					return true;
-				}
-			}
-			return false;
-		}
-		uint32_t mismatch_pos = Node::PrefixMismatch(*this, node, key, depth);
-		if (mismatch_pos != node->prefix_length) {
-			if (node->prefix[mismatch_pos] < key[depth + mismatch_pos]) {
-				// Less
-				it.depth--;
-				return IteratorNext(it);
-			} else {
-				// Greater
-				top.pos = DConstants::INVALID_INDEX;
-				return IteratorNext(it);
-			}
-		}
-		// prefix matches, search inside the child for the key
-		depth += node->prefix_length;
-
-		top.pos = node->GetChildGreaterEqual(key[depth], equal);
-		if (top.pos == DConstants::INVALID_INDEX) {
-			// Find min leaf
-			top.pos = node->GetMin();
-		}
-		node = node->GetChild(top.pos)->get();
-		//! This means all children of this node qualify as geq
-
-		depth++;
-	}
-}
-
-bool ART::SearchGreater(ARTIndexScanState *state, bool inclusive, idx_t max_count, vector<row_t> &result_ids) {
-	Iterator *it = &state->iterator;
-	auto key = CreateKey(*this, types[0], state->values[0]);
-
-	// greater than scan: first set the iterator to the node at which we will start our scan by finding the lowest node
-	// that satisfies our requirement
-	if (!it->start) {
-		bool found = ART::Bound(tree, *key, *it, inclusive);
-		if (!found) {
-			return true;
-		}
-		it->start = true;
-	}
-	// after that we continue the scan; we don't need to check the bounds as any value following this value is
-	// automatically bigger and hence satisfies our predicate
-	return IteratorScan<false, false>(state, it, nullptr, max_count, result_ids);
-}
-
-//===--------------------------------------------------------------------===//
-// Less Than
-//===--------------------------------------------------------------------===//
-static Leaf &FindMinimum(Iterator &it, Node &node) {
-	Node *next = nullptr;
-	idx_t pos = 0;
-	switch (node.type) {
-	case NodeType::NLeaf:
-		it.node = (Leaf *)&node;
-		return (Leaf &)node;
-	case NodeType::N4:
-		next = ((Node4 &)node).child[0].get();
-		break;
-	case NodeType::N16:
-		next = ((Node16 &)node).child[0].get();
-		break;
-	case NodeType::N48: {
-		auto &n48 = (Node48 &)node;
-		while (n48.child_index[pos] == Node::EMPTY_MARKER) {
-			pos++;
-		}
-		next = n48.child[n48.child_index[pos]].get();
-		break;
-	}
-	case NodeType::N256: {
-		auto &n256 = (Node256 &)node;
-		while (!n256.child[pos]) {
-			pos++;
-		}
-		next = n256.child[pos].get();
-		break;
-	}
-	}
-	it.SetEntry(it.depth, IteratorEntry(&node, pos));
-	it.depth++;
-	return FindMinimum(it, *next);
-}
-
-bool ART::SearchLess(ARTIndexScanState *state, bool inclusive, idx_t max_count, vector<row_t> &result_ids) {
-	if (!tree) {
-		return true;
-	}
-
-	Iterator *it = &state->iterator;
-	auto upper_bound = CreateKey(*this, types[0], state->values[0]);
-
-	if (!it->start) {
-		// first find the minimum value in the ART: we start scanning from this value
-		auto &minimum = FindMinimum(state->iterator, *tree);
-		// early out min value higher than upper bound query
-		if (*minimum.value > *upper_bound) {
-			return true;
-		}
-		it->start = true;
-	}
-	// now continue the scan until we reach the upper bound
-	if (inclusive) {
-		return IteratorScan<true, true>(state, it, upper_bound.get(), max_count, result_ids);
-	} else {
-		return IteratorScan<true, false>(state, it, upper_bound.get(), max_count, result_ids);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Closed Range Query
-//===--------------------------------------------------------------------===//
-bool ART::SearchCloseRange(ARTIndexScanState *state, bool left_inclusive, bool right_inclusive, idx_t max_count,
-                           vector<row_t> &result_ids) {
-	auto lower_bound = CreateKey(*this, types[0], state->values[0]);
-	auto upper_bound = CreateKey(*this, types[0], state->values[1]);
-	Iterator *it = &state->iterator;
-	// first find the first node that satisfies the left predicate
-	if (!it->start) {
-		bool found = ART::Bound(tree, *lower_bound, *it, left_inclusive);
-		if (!found) {
-			return true;
-		}
-		it->start = true;
-	}
-	// now continue the scan until we reach the upper bound
-	if (right_inclusive) {
-		return IteratorScan<true, true>(state, it, upper_bound.get(), max_count, result_ids);
-	} else {
-		return IteratorScan<true, false>(state, it, upper_bound.get(), max_count, result_ids);
-	}
-}
-
-bool ART::Scan(Transaction &transaction, DataTable &table, IndexScanState &table_state, idx_t max_count,
-               vector<row_t> &result_ids) {
-	auto state = (ARTIndexScanState *)&table_state;
-
-	D_ASSERT(state->values[0].type().InternalType() == types[0]);
-
-	vector<row_t> row_ids;
-	bool success = true;
-	if (state->values[1].IsNull()) {
-		lock_guard<mutex> l(lock);
-		// single predicate
-		switch (state->expressions[0]) {
-		case ExpressionType::COMPARE_EQUAL:
-			success = SearchEqual(state, max_count, row_ids);
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			success = SearchGreater(state, true, max_count, row_ids);
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			success = SearchGreater(state, false, max_count, row_ids);
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			success = SearchLess(state, true, max_count, row_ids);
-			break;
-		case ExpressionType::COMPARE_LESSTHAN:
-			success = SearchLess(state, false, max_count, row_ids);
-			break;
-		default:
-			throw InternalException("Operation not implemented");
-		}
-	} else {
-		lock_guard<mutex> l(lock);
-		// two predicates
-		D_ASSERT(state->values[1].type().InternalType() == types[0]);
-		bool left_inclusive = state->expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
-		bool right_inclusive = state->expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
-		success = SearchCloseRange(state, left_inclusive, right_inclusive, max_count, row_ids);
-	}
-	if (!success) {
-		return false;
-	}
-	if (row_ids.empty()) {
-		return true;
-	}
-	// sort the row ids
-	sort(row_ids.begin(), row_ids.end());
-	// duplicate eliminate the row ids and append them to the row ids of the state
-	result_ids.reserve(row_ids.size());
-
-	result_ids.push_back(row_ids[0]);
-	for (idx_t i = 1; i < row_ids.size(); i++) {
-		if (row_ids[i] != row_ids[i - 1]) {
-			result_ids.push_back(row_ids[i]);
-		}
-	}
-	return true;
-}
-
-void ART::VerifyExistence(DataChunk &chunk, VerifyExistenceType verify_type, string *err_msg_ptr) {
-	if (verify_type != VerifyExistenceType::DELETE_FK && !IsUnique()) {
-		return;
-	}
-
-	DataChunk expression_result;
-	expression_result.Initialize(Allocator::DefaultAllocator(), logical_types);
-
-	// unique index, check
-	lock_guard<mutex> l(lock);
-	// first resolve the expressions for the index
-	ExecuteExpressions(chunk, expression_result);
-
-	// generate the keys for the given input
-	vector<unique_ptr<Key>> keys;
-	GenerateKeys(expression_result, keys);
-
-	for (idx_t i = 0; i < chunk.size(); i++) {
-		if (!keys[i]) {
-			continue;
-		}
-		Node *node_ptr = Lookup(tree, *keys[i], 0);
-		bool throw_exception =
-		    verify_type == VerifyExistenceType::APPEND_FK ? node_ptr == nullptr : node_ptr != nullptr;
-		if (!throw_exception) {
-			continue;
-		}
-		string key_name;
-		for (idx_t k = 0; k < expression_result.ColumnCount(); k++) {
-			if (k > 0) {
-				key_name += ", ";
-			}
-			key_name += unbound_expressions[k]->GetName() + ": " + expression_result.data[k].GetValue(i).ToString();
-		}
-		string exception_msg;
-		switch (verify_type) {
-		case VerifyExistenceType::APPEND: {
-			// node already exists in tree
-			string type = IsPrimary() ? "primary key" : "unique";
-			exception_msg = "duplicate key \"" + key_name + "\" violates ";
-			exception_msg += type + " constraint";
-			break;
-		}
-		case VerifyExistenceType::APPEND_FK: {
-			// found node no exists in tree
-			exception_msg =
-			    "violates foreign key constraint because key \"" + key_name + "\" does not exist in referenced table";
-			break;
-		}
-		case VerifyExistenceType::DELETE_FK: {
-			// found node exists in tree
-			exception_msg =
-			    "violates foreign key constraint because key \"" + key_name + "\" exist in table has foreign key";
-			break;
-		}
-		}
-		if (err_msg_ptr) {
-			err_msg_ptr[i] = exception_msg;
-		} else {
-			throw ConstraintException(exception_msg);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-Key::Key(unique_ptr<data_t[]> data, idx_t len) : len(len), data(move(data)) {
-}
-
-template <>
-unique_ptr<Key> Key::CreateKey(string_t value, bool is_little_endian) {
-	idx_t len = value.GetSize() + 1;
-	auto data = unique_ptr<data_t[]>(new data_t[len]);
-	memcpy(data.get(), value.GetDataUnsafe(), len - 1);
-	data[len - 1] = '\0';
-	return make_unique<Key>(move(data), len);
-}
-
-template <>
-unique_ptr<Key> Key::CreateKey(const char *value, bool is_little_endian) {
-	return Key::CreateKey(string_t(value, strlen(value)), is_little_endian);
-}
-
-bool Key::operator>(const Key &k) const {
-	for (idx_t i = 0; i < MinValue<idx_t>(len, k.len); i++) {
-		if (data[i] > k.data[i]) {
-			return true;
-		} else if (data[i] < k.data[i]) {
-			return false;
-		}
-	}
-	return len > k.len;
-}
-
-bool Key::operator<(const Key &k) const {
-	for (idx_t i = 0; i < MinValue<idx_t>(len, k.len); i++) {
-		if (data[i] < k.data[i]) {
-			return true;
-		} else if (data[i] > k.data[i]) {
-			return false;
-		}
-	}
-	return len < k.len;
-}
-
-bool Key::operator>=(const Key &k) const {
-	for (idx_t i = 0; i < MinValue<idx_t>(len, k.len); i++) {
-		if (data[i] > k.data[i]) {
-			return true;
-		} else if (data[i] < k.data[i]) {
-			return false;
-		}
-	}
-	return len >= k.len;
-}
-
-bool Key::operator==(const Key &k) const {
-	if (len != k.len) {
-		return false;
-	}
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] != k.data[i]) {
-			return false;
-		}
-	}
-	return true;
-}
-} // namespace duckdb
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-Leaf::Leaf(ART &art, unique_ptr<Key> value, row_t row_id) : Node(art, NodeType::NLeaf, 0) {
-	this->value = move(value);
-	this->capacity = 1;
-	this->row_ids = unique_ptr<row_t[]>(new row_t[this->capacity]);
-	this->row_ids[0] = row_id;
-	this->num_elements = 1;
-}
-
-void Leaf::Insert(row_t row_id) {
-	// Grow array
-	if (num_elements == capacity) {
-		auto new_row_id = unique_ptr<row_t[]>(new row_t[capacity * 2]);
-		memcpy(new_row_id.get(), row_ids.get(), capacity * sizeof(row_t));
-		capacity *= 2;
-		row_ids = move(new_row_id);
-	}
-	row_ids[num_elements++] = row_id;
-}
-
-void Leaf::Remove(row_t row_id) {
-	idx_t entry_offset = DConstants::INVALID_INDEX;
-	for (idx_t i = 0; i < num_elements; i++) {
-		if (row_ids[i] == row_id) {
-			entry_offset = i;
-			break;
-		}
-	}
-	if (entry_offset == DConstants::INVALID_INDEX) {
-		return;
-	}
-	num_elements--;
-	if (capacity > 2 && num_elements < capacity / 2) {
-		// Shrink array, if less than half full
-		auto new_row_id = unique_ptr<row_t[]>(new row_t[capacity / 2]);
-		memcpy(new_row_id.get(), row_ids.get(), entry_offset * sizeof(row_t));
-		memcpy(new_row_id.get() + entry_offset, row_ids.get() + entry_offset + 1,
-		       (num_elements - entry_offset) * sizeof(row_t));
-		capacity /= 2;
-		row_ids = move(new_row_id);
-	} else {
-		// Copy the rest
-		for (idx_t j = entry_offset; j < num_elements; j++) {
-			row_ids[j] = row_ids[j + 1];
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-Node::Node(ART &art, NodeType type, size_t compressed_prefix_size) : prefix_length(0), count(0), type(type) {
-	this->prefix = unique_ptr<uint8_t[]>(new uint8_t[compressed_prefix_size]);
-}
-
-void Node::CopyPrefix(ART &art, Node *src, Node *dst) {
-	dst->prefix_length = src->prefix_length;
-	memcpy(dst->prefix.get(), src->prefix.get(), src->prefix_length);
-}
-
-// LCOV_EXCL_START
-unique_ptr<Node> *Node::GetChild(idx_t pos) {
-	D_ASSERT(0);
-	return nullptr;
-}
-
-idx_t Node::GetMin() {
-	D_ASSERT(0);
-	return 0;
-}
-// LCOV_EXCL_STOP
-
-uint32_t Node::PrefixMismatch(ART &art, Node *node, Key &key, uint64_t depth) {
-	uint64_t pos;
-	for (pos = 0; pos < node->prefix_length; pos++) {
-		if (key[depth + pos] != node->prefix[pos]) {
-			return pos;
-		}
-	}
-	return pos;
-}
-
-void Node::InsertLeaf(ART &art, unique_ptr<Node> &node, uint8_t key, unique_ptr<Node> &new_node) {
-	switch (node->type) {
-	case NodeType::N4:
-		Node4::Insert(art, node, key, new_node);
-		break;
-	case NodeType::N16:
-		Node16::Insert(art, node, key, new_node);
-		break;
-	case NodeType::N48:
-		Node48::Insert(art, node, key, new_node);
-		break;
-	case NodeType::N256:
-		Node256::Insert(art, node, key, new_node);
-		break;
-	default:
-		throw InternalException("Unrecognized leaf type for insert");
-	}
-}
-
-void Node::Erase(ART &art, unique_ptr<Node> &node, idx_t pos) {
-	switch (node->type) {
-	case NodeType::N4: {
-		Node4::Erase(art, node, pos);
-		break;
-	}
-	case NodeType::N16: {
-		Node16::Erase(art, node, pos);
-		break;
-	}
-	case NodeType::N48: {
-		Node48::Erase(art, node, pos);
-		break;
-	}
-	case NodeType::N256:
-		Node256::Erase(art, node, pos);
-		break;
-	default:
-		throw InternalException("Unrecognized leaf type for erase");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-Node16::Node16(ART &art, size_t compression_length) : Node(art, NodeType::N16, compression_length) {
-	memset(key, 16, sizeof(key));
-}
-
-idx_t Node16::GetChildPos(uint8_t k) {
-	for (idx_t pos = 0; pos < count; pos++) {
-		if (key[pos] == k) {
-			return pos;
-		}
-	}
-	return Node::GetChildPos(k);
-}
-
-idx_t Node16::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = 0; pos < count; pos++) {
-		if (key[pos] >= k) {
-			if (key[pos] == k) {
-				equal = true;
-			} else {
-				equal = false;
-			}
-
-			return pos;
-		}
-	}
-	return Node::GetChildGreaterEqual(k, equal);
-}
-
-idx_t Node16::GetNextPos(idx_t pos) {
-	if (pos == DConstants::INVALID_INDEX) {
-		return 0;
-	}
-	pos++;
-	return pos < count ? pos : DConstants::INVALID_INDEX;
-}
-
-unique_ptr<Node> *Node16::GetChild(idx_t pos) {
-	D_ASSERT(pos < count);
-	return &child[pos];
-}
-
-idx_t Node16::GetMin() {
-	return 0;
-}
-
-void Node16::Insert(ART &art, unique_ptr<Node> &node, uint8_t key_byte, unique_ptr<Node> &child) {
-	Node16 *n = static_cast<Node16 *>(node.get());
-
-	if (n->count < 16) {
-		// Insert element
-		idx_t pos = 0;
-		while (pos < node->count && n->key[pos] < key_byte) {
-			pos++;
-		}
-		if (n->child[pos] != nullptr) {
-			for (idx_t i = n->count; i > pos; i--) {
-				n->key[i] = n->key[i - 1];
-				n->child[i] = move(n->child[i - 1]);
-			}
-		}
-		n->key[pos] = key_byte;
-		n->child[pos] = move(child);
-		n->count++;
-	} else {
-		// Grow to Node48
-		auto new_node = make_unique<Node48>(art, n->prefix_length);
-		for (idx_t i = 0; i < node->count; i++) {
-			new_node->child_index[n->key[i]] = i;
-			new_node->child[i] = move(n->child[i]);
-		}
-		CopyPrefix(art, n, new_node.get());
-		new_node->count = node->count;
-		node = move(new_node);
-
-		Node48::Insert(art, node, key_byte, child);
-	}
-}
-
-void Node16::Erase(ART &art, unique_ptr<Node> &node, int pos) {
-	Node16 *n = static_cast<Node16 *>(node.get());
-	// erase the child and decrease the count
-	n->child[pos].reset();
-	n->count--;
-	// potentially move any children backwards
-	for (; pos < n->count; pos++) {
-		n->key[pos] = n->key[pos + 1];
-		n->child[pos] = move(n->child[pos + 1]);
-	}
-	if (node->count <= 3) {
-		// Shrink node
-		auto new_node = make_unique<Node4>(art, n->prefix_length);
-		for (unsigned i = 0; i < n->count; i++) {
-			new_node->key[new_node->count] = n->key[i];
-			new_node->child[new_node->count++] = move(n->child[i]);
-		}
-		CopyPrefix(art, n, new_node.get());
-		node = move(new_node);
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-Node256::Node256(ART &art, size_t compression_length) : Node(art, NodeType::N256, compression_length) {
-}
-
-idx_t Node256::GetChildPos(uint8_t k) {
-	if (child[k]) {
-		return k;
-	} else {
-		return DConstants::INVALID_INDEX;
-	}
-}
-
-idx_t Node256::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = k; pos < 256; pos++) {
-		if (child[pos]) {
-			if (pos == k) {
-				equal = true;
-			} else {
-				equal = false;
-			}
-			return pos;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-idx_t Node256::GetMin() {
-	for (idx_t i = 0; i < 256; i++) {
-		if (child[i]) {
-			return i;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-idx_t Node256::GetNextPos(idx_t pos) {
-	for (pos == DConstants::INVALID_INDEX ? pos = 0 : pos++; pos < 256; pos++) {
-		if (child[pos]) {
-			return pos;
-		}
-	}
-	return Node::GetNextPos(pos);
-}
-
-unique_ptr<Node> *Node256::GetChild(idx_t pos) {
-	D_ASSERT(child[pos]);
-	return &child[pos];
-}
-
-void Node256::Insert(ART &art, unique_ptr<Node> &node, uint8_t key_byte, unique_ptr<Node> &child) {
-	Node256 *n = static_cast<Node256 *>(node.get());
-
-	n->count++;
-	n->child[key_byte] = move(child);
-}
-
-void Node256::Erase(ART &art, unique_ptr<Node> &node, int pos) {
-	Node256 *n = static_cast<Node256 *>(node.get());
-
-	n->child[pos].reset();
-	n->count--;
-	if (node->count <= 36) {
-		auto new_node = make_unique<Node48>(art, n->prefix_length);
-		CopyPrefix(art, n, new_node.get());
-		for (idx_t i = 0; i < 256; i++) {
-			if (n->child[i]) {
-				new_node->child_index[i] = new_node->count;
-				new_node->child[new_node->count] = move(n->child[i]);
-				new_node->count++;
-			}
-		}
-		node = move(new_node);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-Node4::Node4(ART &art, size_t compression_length) : Node(art, NodeType::N4, compression_length) {
-	memset(key, 0, sizeof(key));
-}
-
-idx_t Node4::GetChildPos(uint8_t k) {
-	for (idx_t pos = 0; pos < count; pos++) {
-		if (key[pos] == k) {
-			return pos;
-		}
-	}
-	return Node::GetChildPos(k);
-}
-
-idx_t Node4::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = 0; pos < count; pos++) {
-		if (key[pos] >= k) {
-			if (key[pos] == k) {
-				equal = true;
-			} else {
-				equal = false;
-			}
-			return pos;
-		}
-	}
-	return Node::GetChildGreaterEqual(k, equal);
-}
-
-idx_t Node4::GetMin() {
-	return 0;
-}
-
-idx_t Node4::GetNextPos(idx_t pos) {
-	if (pos == DConstants::INVALID_INDEX) {
-		return 0;
-	}
-	pos++;
-	return pos < count ? pos : DConstants::INVALID_INDEX;
-}
-
-unique_ptr<Node> *Node4::GetChild(idx_t pos) {
-	D_ASSERT(pos < count);
-	return &child[pos];
-}
-
-void Node4::Insert(ART &art, unique_ptr<Node> &node, uint8_t key_byte, unique_ptr<Node> &child) {
-	Node4 *n = static_cast<Node4 *>(node.get());
-
-	// Insert leaf into inner node
-	if (node->count < 4) {
-		// Insert element
-		idx_t pos = 0;
-		while ((pos < node->count) && (n->key[pos] < key_byte)) {
-			pos++;
-		}
-		if (n->child[pos] != nullptr) {
-			for (idx_t i = n->count; i > pos; i--) {
-				n->key[i] = n->key[i - 1];
-				n->child[i] = move(n->child[i - 1]);
-			}
-		}
-		n->key[pos] = key_byte;
-		n->child[pos] = move(child);
-		n->count++;
-	} else {
-		// Grow to Node16
-		auto new_node = make_unique<Node16>(art, n->prefix_length);
-		new_node->count = 4;
-		CopyPrefix(art, node.get(), new_node.get());
-		for (idx_t i = 0; i < 4; i++) {
-			new_node->key[i] = n->key[i];
-			new_node->child[i] = move(n->child[i]);
-		}
-		node = move(new_node);
-		Node16::Insert(art, node, key_byte, child);
-	}
-}
-
-void Node4::Erase(ART &art, unique_ptr<Node> &node, int pos) {
-	Node4 *n = static_cast<Node4 *>(node.get());
-	D_ASSERT(pos < n->count);
-
-	// erase the child and decrease the count
-	n->child[pos].reset();
-	n->count--;
-	// potentially move any children backwards
-	for (; pos < n->count; pos++) {
-		n->key[pos] = n->key[pos + 1];
-		n->child[pos] = move(n->child[pos + 1]);
-	}
-
-	// This is a one way node
-	if (n->count == 1) {
-		auto childref = n->child[0].get();
-		//! concatenate prefixes
-		auto new_length = node->prefix_length + childref->prefix_length + 1;
-		//! have to allocate space in our prefix array
-		unique_ptr<uint8_t[]> new_prefix = unique_ptr<uint8_t[]>(new uint8_t[new_length]);
-
-		//! first move the existing prefix (if any)
-		for (uint32_t i = 0; i < childref->prefix_length; i++) {
-			new_prefix[new_length - (i + 1)] = childref->prefix[childref->prefix_length - (i + 1)];
-		}
-		//! now move the current key as part of the prefix
-		new_prefix[node->prefix_length] = n->key[0];
-		//! finally add the old prefix
-		for (uint32_t i = 0; i < node->prefix_length; i++) {
-			new_prefix[i] = node->prefix[i];
-		}
-		//! set new prefix and move the child
-		childref->prefix = move(new_prefix);
-		childref->prefix_length = new_length;
-		node = move(n->child[0]);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-Node48::Node48(ART &art, size_t compression_length) : Node(art, NodeType::N48, compression_length) {
-	for (idx_t i = 0; i < 256; i++) {
-		child_index[i] = Node::EMPTY_MARKER;
-	}
-}
-
-idx_t Node48::GetChildPos(uint8_t k) {
-	if (child_index[k] == Node::EMPTY_MARKER) {
-		return DConstants::INVALID_INDEX;
-	} else {
-		return k;
-	}
-}
-
-idx_t Node48::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = k; pos < 256; pos++) {
-		if (child_index[pos] != Node::EMPTY_MARKER) {
-			if (pos == k) {
-				equal = true;
-			} else {
-				equal = false;
-			}
-			return pos;
-		}
-	}
-	return Node::GetChildGreaterEqual(k, equal);
-}
-
-idx_t Node48::GetNextPos(idx_t pos) {
-	for (pos == DConstants::INVALID_INDEX ? pos = 0 : pos++; pos < 256; pos++) {
-		if (child_index[pos] != Node::EMPTY_MARKER) {
-			return pos;
-		}
-	}
-	return Node::GetNextPos(pos);
-}
-
-unique_ptr<Node> *Node48::GetChild(idx_t pos) {
-	D_ASSERT(child_index[pos] != Node::EMPTY_MARKER);
-	return &child[child_index[pos]];
-}
-
-idx_t Node48::GetMin() {
-	for (idx_t i = 0; i < 256; i++) {
-		if (child_index[i] != Node::EMPTY_MARKER) {
-			return i;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-void Node48::Insert(ART &art, unique_ptr<Node> &node, uint8_t key_byte, unique_ptr<Node> &child) {
-	Node48 *n = static_cast<Node48 *>(node.get());
-
-	// Insert leaf into inner node
-	if (node->count < 48) {
-		// Insert element
-		idx_t pos = n->count;
-		if (n->child[pos]) {
-			// find an empty position in the node list if the current position is occupied
-			pos = 0;
-			while (n->child[pos]) {
-				pos++;
-			}
-		}
-		n->child[pos] = move(child);
-		n->child_index[key_byte] = pos;
-		n->count++;
-	} else {
-		// Grow to Node256
-		auto new_node = make_unique<Node256>(art, n->prefix_length);
-		for (idx_t i = 0; i < 256; i++) {
-			if (n->child_index[i] != Node::EMPTY_MARKER) {
-				new_node->child[i] = move(n->child[n->child_index[i]]);
-			}
-		}
-		new_node->count = n->count;
-		CopyPrefix(art, n, new_node.get());
-		node = move(new_node);
-		Node256::Insert(art, node, key_byte, child);
-	}
-}
-
-void Node48::Erase(ART &art, unique_ptr<Node> &node, int pos) {
-	Node48 *n = static_cast<Node48 *>(node.get());
-
-	n->child[n->child_index[pos]].reset();
-	n->child_index[pos] = Node::EMPTY_MARKER;
-	n->count--;
-	if (node->count <= 12) {
-		auto new_node = make_unique<Node16>(art, n->prefix_length);
-		CopyPrefix(art, n, new_node.get());
-		for (idx_t i = 0; i < 256; i++) {
-			if (n->child_index[i] != Node::EMPTY_MARKER) {
-				new_node->key[new_node->count] = i;
-				new_node->child[new_node->count++] = move(n->child[n->child_index[i]]);
-			}
-		}
-		node = move(new_node);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-using ValidityBytes = JoinHashTable::ValidityBytes;
-using ScanStructure = JoinHashTable::ScanStructure;
-
-JoinHashTable::JoinHashTable(BufferManager &buffer_manager, const vector<JoinCondition> &conditions,
-                             vector<LogicalType> btypes, JoinType type)
-    : buffer_manager(buffer_manager), build_types(move(btypes)), entry_size(0), tuple_size(0),
-      vfound(Value::BOOLEAN(false)), join_type(type), finalized(false), has_null(false) {
-	for (auto &condition : conditions) {
-		D_ASSERT(condition.left->return_type == condition.right->return_type);
-		auto type = condition.left->return_type;
-		if (condition.comparison == ExpressionType::COMPARE_EQUAL ||
-		    condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
-		    condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM) {
-			// all equality conditions should be at the front
-			// all other conditions at the back
-			// this assert checks that
-			D_ASSERT(equality_types.size() == condition_types.size());
-			equality_types.push_back(type);
-		}
-
-		predicates.push_back(condition.comparison);
-		null_values_are_equal.push_back(condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
-		                                condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM);
-
-		condition_types.push_back(type);
-	}
-	// at least one equality is necessary
-	D_ASSERT(!equality_types.empty());
-
-	// Types for the layout
-	vector<LogicalType> layout_types(condition_types);
-	layout_types.insert(layout_types.end(), build_types.begin(), build_types.end());
-	if (IsRightOuterJoin(join_type)) {
-		// full/right outer joins need an extra bool to keep track of whether or not a tuple has found a matching entry
-		// we place the bool before the NEXT pointer
-		layout_types.emplace_back(LogicalType::BOOLEAN);
-	}
-	layout_types.emplace_back(LogicalType::HASH);
-	layout.Initialize(layout_types, false);
-
-	const auto &offsets = layout.GetOffsets();
-	tuple_size = offsets[condition_types.size() + build_types.size()];
-	pointer_offset = offsets.back();
-	entry_size = layout.GetRowWidth();
-
-	// compute the per-block capacity of this HT
-	idx_t block_capacity = MaxValue<idx_t>(STANDARD_VECTOR_SIZE, (Storage::BLOCK_SIZE / entry_size) + 1);
-	block_collection = make_unique<RowDataCollection>(buffer_manager, block_capacity, entry_size);
-	string_heap = make_unique<RowDataCollection>(buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
-}
-
-JoinHashTable::~JoinHashTable() {
-}
-
-void JoinHashTable::ApplyBitmask(Vector &hashes, idx_t count) {
-	if (hashes.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		D_ASSERT(!ConstantVector::IsNull(hashes));
-		auto indices = ConstantVector::GetData<hash_t>(hashes);
-		*indices = *indices & bitmask;
-	} else {
-		hashes.Normalify(count);
-		auto indices = FlatVector::GetData<hash_t>(hashes);
-		for (idx_t i = 0; i < count; i++) {
-			indices[i] &= bitmask;
-		}
-	}
-}
-
-void JoinHashTable::ApplyBitmask(Vector &hashes, const SelectionVector &sel, idx_t count, Vector &pointers) {
-	VectorData hdata;
-	hashes.Orrify(count, hdata);
-
-	auto hash_data = (hash_t *)hdata.data;
-	auto result_data = FlatVector::GetData<data_ptr_t *>(pointers);
-	auto main_ht = (data_ptr_t *)hash_map.Ptr();
-	for (idx_t i = 0; i < count; i++) {
-		auto rindex = sel.get_index(i);
-		auto hindex = hdata.sel->get_index(rindex);
-		auto hash = hash_data[hindex];
-		result_data[rindex] = main_ht + (hash & bitmask);
-	}
-}
-
-void JoinHashTable::Hash(DataChunk &keys, const SelectionVector &sel, idx_t count, Vector &hashes) {
-	if (count == keys.size()) {
-		// no null values are filtered: use regular hash functions
-		VectorOperations::Hash(keys.data[0], hashes, keys.size());
-		for (idx_t i = 1; i < equality_types.size(); i++) {
-			VectorOperations::CombineHash(hashes, keys.data[i], keys.size());
-		}
-	} else {
-		// null values were filtered: use selection vector
-		VectorOperations::Hash(keys.data[0], hashes, sel, count);
-		for (idx_t i = 1; i < equality_types.size(); i++) {
-			VectorOperations::CombineHash(hashes, keys.data[i], sel, count);
-		}
-	}
-}
-
-static idx_t FilterNullValues(VectorData &vdata, const SelectionVector &sel, idx_t count, SelectionVector &result) {
-	idx_t result_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto key_idx = vdata.sel->get_index(idx);
-		if (vdata.validity.RowIsValid(key_idx)) {
-			result.set_index(result_count++, idx);
-		}
-	}
-	return result_count;
-}
-
-idx_t JoinHashTable::PrepareKeys(DataChunk &keys, unique_ptr<VectorData[]> &key_data,
-                                 const SelectionVector *&current_sel, SelectionVector &sel, bool build_side) {
-	key_data = keys.Orrify();
-
-	// figure out which keys are NULL, and create a selection vector out of them
-	current_sel = FlatVector::IncrementalSelectionVector();
-	idx_t added_count = keys.size();
-	if (build_side && IsRightOuterJoin(join_type)) {
-		// in case of a right or full outer join, we cannot remove NULL keys from the build side
-		return added_count;
-	}
-	for (idx_t i = 0; i < keys.ColumnCount(); i++) {
-		if (!null_values_are_equal[i]) {
-			if (key_data[i].validity.AllValid()) {
-				continue;
-			}
-			added_count = FilterNullValues(key_data[i], *current_sel, added_count, sel);
-			// null values are NOT equal for this column, filter them out
-			current_sel = &sel;
-		}
-	}
-	return added_count;
-}
-
-void JoinHashTable::Build(DataChunk &keys, DataChunk &payload) {
-	D_ASSERT(!finalized);
-	D_ASSERT(keys.size() == payload.size());
-	if (keys.size() == 0) {
-		return;
-	}
-	// special case: correlated mark join
-	if (join_type == JoinType::MARK && !correlated_mark_join_info.correlated_types.empty()) {
-		auto &info = correlated_mark_join_info;
-		lock_guard<mutex> mj_lock(info.mj_lock);
-		// Correlated MARK join
-		// for the correlated mark join we need to keep track of COUNT(*) and COUNT(COLUMN) for each of the correlated
-		// columns push into the aggregate hash table
-		D_ASSERT(info.correlated_counts);
-		info.group_chunk.SetCardinality(keys);
-		for (idx_t i = 0; i < info.correlated_types.size(); i++) {
-			info.group_chunk.data[i].Reference(keys.data[i]);
-		}
-		if (info.correlated_payload.data.empty()) {
-			vector<LogicalType> types;
-			types.push_back(keys.data[info.correlated_types.size()].GetType());
-			info.correlated_payload.InitializeEmpty(types);
-		}
-		info.correlated_payload.SetCardinality(keys);
-		info.correlated_payload.data[0].Reference(keys.data[info.correlated_types.size()]);
-		info.correlated_counts->AddChunk(info.group_chunk, info.correlated_payload);
-	}
-
-	// prepare the keys for processing
-	unique_ptr<VectorData[]> key_data;
-	const SelectionVector *current_sel;
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	idx_t added_count = PrepareKeys(keys, key_data, current_sel, sel, true);
-	if (added_count < keys.size()) {
-		has_null = true;
-	}
-	if (added_count == 0) {
-		return;
-	}
-
-	// build out the buffer space
-	Vector addresses(LogicalType::POINTER);
-	auto key_locations = FlatVector::GetData<data_ptr_t>(addresses);
-	auto handles = block_collection->Build(added_count, key_locations, nullptr, current_sel);
-
-	// hash the keys and obtain an entry in the list
-	// note that we only hash the keys used in the equality comparison
-	Vector hash_values(LogicalType::HASH);
-	Hash(keys, *current_sel, added_count, hash_values);
-
-	// build a chunk so we can handle nested types that need more than Orrification
-	DataChunk source_chunk;
-	source_chunk.InitializeEmpty(layout.GetTypes());
-
-	vector<VectorData> source_data;
-	source_data.reserve(layout.ColumnCount());
-
-	// serialize the keys to the key locations
-	for (idx_t i = 0; i < keys.ColumnCount(); i++) {
-		source_chunk.data[i].Reference(keys.data[i]);
-		source_data.emplace_back(move(key_data[i]));
-	}
-	// now serialize the payload
-	D_ASSERT(build_types.size() == payload.ColumnCount());
-	for (idx_t i = 0; i < payload.ColumnCount(); i++) {
-		source_chunk.data[source_data.size()].Reference(payload.data[i]);
-		VectorData pdata;
-		payload.data[i].Orrify(payload.size(), pdata);
-		source_data.emplace_back(move(pdata));
-	}
-	if (IsRightOuterJoin(join_type)) {
-		// for FULL/RIGHT OUTER joins initialize the "found" boolean to false
-		source_chunk.data[source_data.size()].Reference(vfound);
-		VectorData fdata;
-		vfound.Orrify(keys.size(), fdata);
-		source_data.emplace_back(move(fdata));
-	}
-
-	// serialise the hashes at the end
-	source_chunk.data[source_data.size()].Reference(hash_values);
-	VectorData hdata;
-	hash_values.Orrify(keys.size(), hdata);
-	source_data.emplace_back(move(hdata));
-
-	source_chunk.SetCardinality(keys);
-
-	RowOperations::Scatter(source_chunk, source_data.data(), layout, addresses, *string_heap, *current_sel,
-	                       added_count);
-}
-
-void JoinHashTable::InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[]) {
-	D_ASSERT(hashes.GetType().id() == LogicalType::HASH);
-
-	// use bitmask to get position in array
-	ApplyBitmask(hashes, count);
-
-	hashes.Normalify(count);
-
-	D_ASSERT(hashes.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto pointers = (data_ptr_t *)hash_map.Ptr();
-	auto indices = FlatVector::GetData<hash_t>(hashes);
-	for (idx_t i = 0; i < count; i++) {
-		auto index = indices[i];
-		// set prev in current key to the value (NOTE: this will be nullptr if
-		// there is none)
-		Store<data_ptr_t>(pointers[index], key_locations[i] + pointer_offset);
-
-		// set pointer to current tuple
-		pointers[index] = key_locations[i];
-	}
-}
-
-void JoinHashTable::Finalize() {
-	// the build has finished, now iterate over all the nodes and construct the final hash table
-	// select a HT that has at least 50% empty space
-	idx_t capacity = NextPowerOfTwo(MaxValue<idx_t>(Count() * 2, (Storage::BLOCK_SIZE / sizeof(data_ptr_t)) + 1));
-	// size needs to be a power of 2
-	D_ASSERT((capacity & (capacity - 1)) == 0);
-	bitmask = capacity - 1;
-
-	// allocate the HT and initialize it with all-zero entries
-	hash_map = buffer_manager.Allocate(capacity * sizeof(data_ptr_t));
-	memset(hash_map.Ptr(), 0, capacity * sizeof(data_ptr_t));
-
-	Vector hashes(LogicalType::HASH);
-	auto hash_data = FlatVector::GetData<hash_t>(hashes);
-	data_ptr_t key_locations[STANDARD_VECTOR_SIZE];
-	// now construct the actual hash table; scan the nodes
-	// as we can the nodes we pin all the blocks of the HT and keep them pinned until the HT is destroyed
-	// this is so that we can keep pointers around to the blocks
-	// FIXME: if we cannot keep everything pinned in memory, we could switch to an out-of-memory merge join or so
-	for (auto &block : block_collection->blocks) {
-		auto handle = buffer_manager.Pin(block.block);
-		data_ptr_t dataptr = handle.Ptr();
-		idx_t entry = 0;
-		while (entry < block.count) {
-			// fetch the next vector of entries from the blocks
-			idx_t next = MinValue<idx_t>(STANDARD_VECTOR_SIZE, block.count - entry);
-			for (idx_t i = 0; i < next; i++) {
-				hash_data[i] = Load<hash_t>((data_ptr_t)(dataptr + pointer_offset));
-				key_locations[i] = dataptr;
-				dataptr += entry_size;
-			}
-			// now insert into the hash table
-			InsertHashes(hashes, next, key_locations);
-
-			entry += next;
-		}
-		pinned_handles.push_back(move(handle));
-	}
-
-	finalized = true;
-}
-
-unique_ptr<ScanStructure> JoinHashTable::Probe(DataChunk &keys) {
-	D_ASSERT(Count() > 0); // should be handled before
-	D_ASSERT(finalized);
-
-	// set up the scan structure
-	auto ss = make_unique<ScanStructure>(*this);
-
-	if (join_type != JoinType::INNER) {
-		ss->found_match = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
-		memset(ss->found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-	}
-
-	// first prepare the keys for probing
-	const SelectionVector *current_sel;
-	ss->count = PrepareKeys(keys, ss->key_data, current_sel, ss->sel_vector, false);
-	if (ss->count == 0) {
-		return ss;
-	}
-
-	// hash all the keys
-	Vector hashes(LogicalType::HASH);
-	Hash(keys, *current_sel, ss->count, hashes);
-
-	// now initialize the pointers of the scan structure based on the hashes
-	ApplyBitmask(hashes, *current_sel, ss->count, ss->pointers);
-
-	// create the selection vector linking to only non-empty entries
-	idx_t count = 0;
-	auto pointers = FlatVector::GetData<data_ptr_t>(ss->pointers);
-	for (idx_t i = 0; i < ss->count; i++) {
-		auto idx = current_sel->get_index(i);
-		pointers[idx] = Load<data_ptr_t>(pointers[idx]);
-		if (pointers[idx]) {
-			ss->sel_vector.set_index(count++, idx);
-		}
-	}
-	ss->count = count;
-	return ss;
-}
-
-ScanStructure::ScanStructure(JoinHashTable &ht)
-    : pointers(LogicalType::POINTER), sel_vector(STANDARD_VECTOR_SIZE), ht(ht), finished(false) {
-}
-
-void ScanStructure::Next(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	if (finished) {
-		return;
-	}
-
-	switch (ht.join_type) {
-	case JoinType::INNER:
-	case JoinType::RIGHT:
-		NextInnerJoin(keys, left, result);
-		break;
-	case JoinType::SEMI:
-		NextSemiJoin(keys, left, result);
-		break;
-	case JoinType::MARK:
-		NextMarkJoin(keys, left, result);
-		break;
-	case JoinType::ANTI:
-		NextAntiJoin(keys, left, result);
-		break;
-	case JoinType::OUTER:
-	case JoinType::LEFT:
-		NextLeftJoin(keys, left, result);
-		break;
-	case JoinType::SINGLE:
-		NextSingleJoin(keys, left, result);
-		break;
-	default:
-		throw InternalException("Unhandled join type in JoinHashTable");
-	}
-}
-
-idx_t ScanStructure::ResolvePredicates(DataChunk &keys, SelectionVector &match_sel, SelectionVector *no_match_sel) {
-	// Start with the scan selection
-	for (idx_t i = 0; i < this->count; ++i) {
-		match_sel.set_index(i, this->sel_vector.get_index(i));
-	}
-	idx_t no_match_count = 0;
-
-	return RowOperations::Match(keys, key_data.get(), ht.layout, pointers, ht.predicates, match_sel, this->count,
-	                            no_match_sel, no_match_count);
-}
-
-idx_t ScanStructure::ScanInnerJoin(DataChunk &keys, SelectionVector &result_vector) {
-	while (true) {
-		// resolve the predicates for this set of keys
-		idx_t result_count = ResolvePredicates(keys, result_vector, nullptr);
-
-		// after doing all the comparisons set the found_match vector
-		if (found_match) {
-			for (idx_t i = 0; i < result_count; i++) {
-				auto idx = result_vector.get_index(i);
-				found_match[idx] = true;
-			}
-		}
-		if (result_count > 0) {
-			return result_count;
-		}
-		// no matches found: check the next set of pointers
-		AdvancePointers();
-		if (this->count == 0) {
-			return 0;
-		}
-	}
-}
-
-void ScanStructure::AdvancePointers(const SelectionVector &sel, idx_t sel_count) {
-	// now for all the pointers, we move on to the next set of pointers
-	idx_t new_count = 0;
-	auto ptrs = FlatVector::GetData<data_ptr_t>(this->pointers);
-	for (idx_t i = 0; i < sel_count; i++) {
-		auto idx = sel.get_index(i);
-		ptrs[idx] = Load<data_ptr_t>(ptrs[idx] + ht.pointer_offset);
-		if (ptrs[idx]) {
-			this->sel_vector.set_index(new_count++, idx);
-		}
-	}
-	this->count = new_count;
-}
-
-void ScanStructure::AdvancePointers() {
-	AdvancePointers(this->sel_vector, this->count);
-}
-
-void ScanStructure::GatherResult(Vector &result, const SelectionVector &result_vector,
-                                 const SelectionVector &sel_vector, const idx_t count, const idx_t col_no) {
-	const auto col_offset = ht.layout.GetOffsets()[col_no];
-	RowOperations::Gather(pointers, sel_vector, result, result_vector, count, col_offset, col_no);
-}
-
-void ScanStructure::GatherResult(Vector &result, const SelectionVector &sel_vector, const idx_t count,
-                                 const idx_t col_idx) {
-	GatherResult(result, *FlatVector::IncrementalSelectionVector(), sel_vector, count, col_idx);
-}
-
-void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	D_ASSERT(result.ColumnCount() == left.ColumnCount() + ht.build_types.size());
-	if (this->count == 0) {
-		// no pointers left to chase
-		return;
-	}
-
-	SelectionVector result_vector(STANDARD_VECTOR_SIZE);
-
-	idx_t result_count = ScanInnerJoin(keys, result_vector);
-	if (result_count > 0) {
-		if (IsRightOuterJoin(ht.join_type)) {
-			// full/right outer join: mark join matches as FOUND in the HT
-			auto ptrs = FlatVector::GetData<data_ptr_t>(pointers);
-			for (idx_t i = 0; i < result_count; i++) {
-				auto idx = result_vector.get_index(i);
-				// NOTE: threadsan reports this as a data race because this can be set concurrently by separate threads
-				// Technically it is, but it does not matter, since the only value that can be written is "true"
-				Store<bool>(true, ptrs[idx] + ht.tuple_size);
-			}
-		}
-		// matches were found
-		// construct the result
-		// on the LHS, we create a slice using the result vector
-		result.Slice(left, result_vector, result_count);
-
-		// on the RHS, we need to fetch the data from the hash table
-		for (idx_t i = 0; i < ht.build_types.size(); i++) {
-			auto &vector = result.data[left.ColumnCount() + i];
-			D_ASSERT(vector.GetType() == ht.build_types[i]);
-			GatherResult(vector, result_vector, result_count, i + ht.condition_types.size());
-		}
-		AdvancePointers();
-	}
-}
-
-void ScanStructure::ScanKeyMatches(DataChunk &keys) {
-	// the semi-join, anti-join and mark-join we handle a differently from the inner join
-	// since there can be at most STANDARD_VECTOR_SIZE results
-	// we handle the entire chunk in one call to Next().
-	// for every pointer, we keep chasing pointers and doing comparisons.
-	// this results in a boolean array indicating whether or not the tuple has a match
-	SelectionVector match_sel(STANDARD_VECTOR_SIZE), no_match_sel(STANDARD_VECTOR_SIZE);
-	while (this->count > 0) {
-		// resolve the predicates for the current set of pointers
-		idx_t match_count = ResolvePredicates(keys, match_sel, &no_match_sel);
-		idx_t no_match_count = this->count - match_count;
-
-		// mark each of the matches as found
-		for (idx_t i = 0; i < match_count; i++) {
-			found_match[match_sel.get_index(i)] = true;
-		}
-		// continue searching for the ones where we did not find a match yet
-		AdvancePointers(no_match_sel, no_match_count);
-	}
-}
-
-template <bool MATCH>
-void ScanStructure::NextSemiOrAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	D_ASSERT(left.ColumnCount() == result.ColumnCount());
-	D_ASSERT(keys.size() == left.size());
-	// create the selection vector from the matches that were found
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	idx_t result_count = 0;
-	for (idx_t i = 0; i < keys.size(); i++) {
-		if (found_match[i] == MATCH) {
-			// part of the result
-			sel.set_index(result_count++, i);
-		}
-	}
-	// construct the final result
-	if (result_count > 0) {
-		// we only return the columns on the left side
-		// reference the columns of the left side from the result
-		result.Slice(left, sel, result_count);
-	} else {
-		D_ASSERT(result.size() == 0);
-	}
-}
-
-void ScanStructure::NextSemiJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	// first scan for key matches
-	ScanKeyMatches(keys);
-	// then construct the result from all tuples with a match
-	NextSemiOrAntiJoin<true>(keys, left, result);
-
-	finished = true;
-}
-
-void ScanStructure::NextAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	// first scan for key matches
-	ScanKeyMatches(keys);
-	// then construct the result from all tuples that did not find a match
-	NextSemiOrAntiJoin<false>(keys, left, result);
-
-	finished = true;
-}
-
-void ScanStructure::ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &child, DataChunk &result) {
-	// for the initial set of columns we just reference the left side
-	result.SetCardinality(child);
-	for (idx_t i = 0; i < child.ColumnCount(); i++) {
-		result.data[i].Reference(child.data[i]);
-	}
-	auto &mark_vector = result.data.back();
-	mark_vector.SetVectorType(VectorType::FLAT_VECTOR);
-	// first we set the NULL values from the join keys
-	// if there is any NULL in the keys, the result is NULL
-	auto bool_result = FlatVector::GetData<bool>(mark_vector);
-	auto &mask = FlatVector::Validity(mark_vector);
-	for (idx_t col_idx = 0; col_idx < join_keys.ColumnCount(); col_idx++) {
-		if (ht.null_values_are_equal[col_idx]) {
-			continue;
-		}
-		VectorData jdata;
-		join_keys.data[col_idx].Orrify(join_keys.size(), jdata);
-		if (!jdata.validity.AllValid()) {
-			for (idx_t i = 0; i < join_keys.size(); i++) {
-				auto jidx = jdata.sel->get_index(i);
-				mask.Set(i, jdata.validity.RowIsValidUnsafe(jidx));
-			}
-		}
-	}
-	// now set the remaining entries to either true or false based on whether a match was found
-	if (found_match) {
-		for (idx_t i = 0; i < child.size(); i++) {
-			bool_result[i] = found_match[i];
-		}
-	} else {
-		memset(bool_result, 0, sizeof(bool) * child.size());
-	}
-	// if the right side contains NULL values, the result of any FALSE becomes NULL
-	if (ht.has_null) {
-		for (idx_t i = 0; i < child.size(); i++) {
-			if (!bool_result[i]) {
-				mask.SetInvalid(i);
-			}
-		}
-	}
-}
-
-void ScanStructure::NextMarkJoin(DataChunk &keys, DataChunk &input, DataChunk &result) {
-	D_ASSERT(result.ColumnCount() == input.ColumnCount() + 1);
-	D_ASSERT(result.data.back().GetType() == LogicalType::BOOLEAN);
-	// this method should only be called for a non-empty HT
-	D_ASSERT(ht.Count() > 0);
-
-	ScanKeyMatches(keys);
-	if (ht.correlated_mark_join_info.correlated_types.empty()) {
-		ConstructMarkJoinResult(keys, input, result);
-	} else {
-		auto &info = ht.correlated_mark_join_info;
-		// there are correlated columns
-		// first we fetch the counts from the aggregate hashtable corresponding to these entries
-		D_ASSERT(keys.ColumnCount() == info.group_chunk.ColumnCount() + 1);
-		info.group_chunk.SetCardinality(keys);
-		for (idx_t i = 0; i < info.group_chunk.ColumnCount(); i++) {
-			info.group_chunk.data[i].Reference(keys.data[i]);
-		}
-		info.correlated_counts->FetchAggregates(info.group_chunk, info.result_chunk);
-
-		// for the initial set of columns we just reference the left side
-		result.SetCardinality(input);
-		for (idx_t i = 0; i < input.ColumnCount(); i++) {
-			result.data[i].Reference(input.data[i]);
-		}
-		// create the result matching vector
-		auto &last_key = keys.data.back();
-		auto &result_vector = result.data.back();
-		// first set the nullmask based on whether or not there were NULL values in the join key
-		result_vector.SetVectorType(VectorType::FLAT_VECTOR);
-		auto bool_result = FlatVector::GetData<bool>(result_vector);
-		auto &mask = FlatVector::Validity(result_vector);
-		switch (last_key.GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR:
-			if (ConstantVector::IsNull(last_key)) {
-				mask.SetAllInvalid(input.size());
-			}
-			break;
-		case VectorType::FLAT_VECTOR:
-			mask.Copy(FlatVector::Validity(last_key), input.size());
-			break;
-		default: {
-			VectorData kdata;
-			last_key.Orrify(keys.size(), kdata);
-			for (idx_t i = 0; i < input.size(); i++) {
-				auto kidx = kdata.sel->get_index(i);
-				mask.Set(i, kdata.validity.RowIsValid(kidx));
-			}
-			break;
-		}
-		}
-
-		auto count_star = FlatVector::GetData<int64_t>(info.result_chunk.data[0]);
-		auto count = FlatVector::GetData<int64_t>(info.result_chunk.data[1]);
-		// set the entries to either true or false based on whether a match was found
-		for (idx_t i = 0; i < input.size(); i++) {
-			D_ASSERT(count_star[i] >= count[i]);
-			bool_result[i] = found_match ? found_match[i] : false;
-			if (!bool_result[i] && count_star[i] > count[i]) {
-				// RHS has NULL value and result is false: set to null
-				mask.SetInvalid(i);
-			}
-			if (count_star[i] == 0) {
-				// count == 0, set nullmask to false (we know the result is false now)
-				mask.SetValid(i);
-			}
-		}
-	}
-	finished = true;
-}
-
-void ScanStructure::NextLeftJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
-	// a LEFT OUTER JOIN is identical to an INNER JOIN except all tuples that do
-	// not have a match must return at least one tuple (with the right side set
-	// to NULL in every column)
-	NextInnerJoin(keys, left, result);
-	if (result.size() == 0) {
-		// no entries left from the normal join
-		// fill in the result of the remaining left tuples
-		// together with NULL values on the right-hand side
-		idx_t remaining_count = 0;
-		SelectionVector sel(STANDARD_VECTOR_SIZE);
-		for (idx_t i = 0; i < left.size(); i++) {
-			if (!found_match[i]) {
-				sel.set_index(remaining_count++, i);
-			}
-		}
-		if (remaining_count > 0) {
-			// have remaining tuples
-			// slice the left side with tuples that did not find a match
-			result.Slice(left, sel, remaining_count);
-
-			// now set the right side to NULL
-			for (idx_t i = left.ColumnCount(); i < result.ColumnCount(); i++) {
-				Vector &vec = result.data[i];
-				vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(vec, true);
-			}
-		}
-		finished = true;
-	}
-}
-
-void ScanStructure::NextSingleJoin(DataChunk &keys, DataChunk &input, DataChunk &result) {
-	// single join
-	// this join is similar to the semi join except that
-	// (1) we actually return data from the RHS and
-	// (2) we return NULL for that data if there is no match
-	idx_t result_count = 0;
-	SelectionVector result_sel(STANDARD_VECTOR_SIZE);
-	SelectionVector match_sel(STANDARD_VECTOR_SIZE), no_match_sel(STANDARD_VECTOR_SIZE);
-	while (this->count > 0) {
-		// resolve the predicates for the current set of pointers
-		idx_t match_count = ResolvePredicates(keys, match_sel, &no_match_sel);
-		idx_t no_match_count = this->count - match_count;
-
-		// mark each of the matches as found
-		for (idx_t i = 0; i < match_count; i++) {
-			// found a match for this index
-			auto index = match_sel.get_index(i);
-			found_match[index] = true;
-			result_sel.set_index(result_count++, index);
-		}
-		// continue searching for the ones where we did not find a match yet
-		AdvancePointers(no_match_sel, no_match_count);
-	}
-	// reference the columns of the left side from the result
-	D_ASSERT(input.ColumnCount() > 0);
-	for (idx_t i = 0; i < input.ColumnCount(); i++) {
-		result.data[i].Reference(input.data[i]);
-	}
-	// now fetch the data from the RHS
-	for (idx_t i = 0; i < ht.build_types.size(); i++) {
-		auto &vector = result.data[input.ColumnCount() + i];
-		// set NULL entries for every entry that was not found
-		auto &mask = FlatVector::Validity(vector);
-		mask.SetAllInvalid(input.size());
-		for (idx_t j = 0; j < result_count; j++) {
-			mask.SetValid(result_sel.get_index(j));
-		}
-		// for the remaining values we fetch the values
-		GatherResult(vector, result_sel, result_sel, result_count, i + ht.condition_types.size());
-	}
-	result.SetCardinality(input.size());
-
-	// like the SEMI, ANTI and MARK join types, the SINGLE join only ever does one pass over the HT per input chunk
-	finished = true;
-}
-
-void JoinHashTable::ScanFullOuter(DataChunk &result, JoinHTScanState &state) {
-	// scan the HT starting from the current position and check which rows from the build side did not find a match
-	Vector addresses(LogicalType::POINTER);
-	auto key_locations = FlatVector::GetData<data_ptr_t>(addresses);
-	idx_t found_entries = 0;
-	{
-		lock_guard<mutex> state_lock(state.lock);
-		for (; state.block_position < block_collection->blocks.size(); state.block_position++, state.position = 0) {
-			auto &block = block_collection->blocks[state.block_position];
-			auto &handle = pinned_handles[state.block_position];
-			auto baseptr = handle.Ptr();
-			for (; state.position < block.count; state.position++) {
-				auto tuple_base = baseptr + state.position * entry_size;
-				auto found_match = Load<bool>(tuple_base + tuple_size);
-				if (!found_match) {
-					key_locations[found_entries++] = tuple_base;
-					if (found_entries == STANDARD_VECTOR_SIZE) {
-						state.position++;
-						break;
-					}
-				}
-			}
-			if (found_entries == STANDARD_VECTOR_SIZE) {
-				break;
-			}
-		}
-	}
-	result.SetCardinality(found_entries);
-	if (found_entries > 0) {
-		idx_t left_column_count = result.ColumnCount() - build_types.size();
-		const auto &sel_vector = *FlatVector::IncrementalSelectionVector();
-		// set the left side as a constant NULL
-		for (idx_t i = 0; i < left_column_count; i++) {
-			Vector &vec = result.data[i];
-			vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(vec, true);
-		}
-		// gather the values from the RHS
-		for (idx_t i = 0; i < build_types.size(); i++) {
-			auto &vector = result.data[left_column_count + i];
-			D_ASSERT(vector.GetType() == build_types[i]);
-			const auto col_no = condition_types.size() + i;
-			const auto col_offset = layout.GetOffsets()[col_no];
-			RowOperations::Gather(addresses, sel_vector, vector, sel_vector, found_entries, col_offset, col_no);
-		}
-	}
-}
-
-idx_t JoinHashTable::FillWithHTOffsets(data_ptr_t *key_locations, JoinHTScanState &state) {
-
-	// iterate over blocks
-	idx_t key_count = 0;
-	while (state.block_position < block_collection->blocks.size()) {
-		auto &block = block_collection->blocks[state.block_position];
-		auto handle = buffer_manager.Pin(block.block);
-		auto base_ptr = handle.Ptr();
-		// go through all the tuples within this block
-		while (state.position < block.count) {
-			auto tuple_base = base_ptr + state.position * entry_size;
-			// store its locations
-			key_locations[key_count++] = tuple_base;
-			state.position++;
-		}
-		state.block_position++;
-		state.position = 0;
-	}
-	return key_count;
-}
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-template <class OP>
-struct ComparisonOperationWrapper {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_is_null, bool right_is_null) {
-		if (left_is_null || right_is_null) {
-			return false;
-		}
-		return OP::Operation(left, right);
-	}
-};
-
-struct InitialNestedLoopJoin {
-	template <class T, class OP>
-	static idx_t Operation(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos, idx_t &rpos,
-	                       SelectionVector &lvector, SelectionVector &rvector, idx_t current_match_count) {
-		// initialize phase of nested loop join
-		// fill lvector and rvector with matches from the base vectors
-		VectorData left_data, right_data;
-		left.Orrify(left_size, left_data);
-		right.Orrify(right_size, right_data);
-
-		auto ldata = (T *)left_data.data;
-		auto rdata = (T *)right_data.data;
-		idx_t result_count = 0;
-		for (; rpos < right_size; rpos++) {
-			idx_t right_position = right_data.sel->get_index(rpos);
-			bool right_is_valid = right_data.validity.RowIsValid(right_position);
-			for (; lpos < left_size; lpos++) {
-				if (result_count == STANDARD_VECTOR_SIZE) {
-					// out of space!
-					return result_count;
-				}
-				idx_t left_position = left_data.sel->get_index(lpos);
-				bool left_is_valid = left_data.validity.RowIsValid(left_position);
-				if (OP::Operation(ldata[left_position], rdata[right_position], !left_is_valid, !right_is_valid)) {
-					// emit tuple
-					lvector.set_index(result_count, lpos);
-					rvector.set_index(result_count, rpos);
-					result_count++;
-				}
-			}
-			lpos = 0;
-		}
-		return result_count;
-	}
-};
-
-struct RefineNestedLoopJoin {
-	template <class T, class OP>
-	static idx_t Operation(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos, idx_t &rpos,
-	                       SelectionVector &lvector, SelectionVector &rvector, idx_t current_match_count) {
-		VectorData left_data, right_data;
-		left.Orrify(left_size, left_data);
-		right.Orrify(right_size, right_data);
-
-		// refine phase of the nested loop join
-		// refine lvector and rvector based on matches of subsequent conditions (in case there are multiple conditions
-		// in the join)
-		D_ASSERT(current_match_count > 0);
-		auto ldata = (T *)left_data.data;
-		auto rdata = (T *)right_data.data;
-		idx_t result_count = 0;
-		for (idx_t i = 0; i < current_match_count; i++) {
-			auto lidx = lvector.get_index(i);
-			auto ridx = rvector.get_index(i);
-			auto left_idx = left_data.sel->get_index(lidx);
-			auto right_idx = right_data.sel->get_index(ridx);
-			bool left_is_valid = left_data.validity.RowIsValid(left_idx);
-			bool right_is_valid = right_data.validity.RowIsValid(right_idx);
-			if (OP::Operation(ldata[left_idx], rdata[right_idx], !left_is_valid, !right_is_valid)) {
-				lvector.set_index(result_count, lidx);
-				rvector.set_index(result_count, ridx);
-				result_count++;
-			}
-		}
-		return result_count;
-	}
-};
-
-template <class NLTYPE, class OP>
-static idx_t NestedLoopJoinTypeSwitch(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos,
-                                      idx_t &rpos, SelectionVector &lvector, SelectionVector &rvector,
-                                      idx_t current_match_count) {
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return NLTYPE::template Operation<int8_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                              current_match_count);
-	case PhysicalType::INT16:
-		return NLTYPE::template Operation<int16_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                               current_match_count);
-	case PhysicalType::INT32:
-		return NLTYPE::template Operation<int32_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                               current_match_count);
-	case PhysicalType::INT64:
-		return NLTYPE::template Operation<int64_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                               current_match_count);
-	case PhysicalType::UINT8:
-		return NLTYPE::template Operation<uint8_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                               current_match_count);
-	case PhysicalType::UINT16:
-		return NLTYPE::template Operation<uint16_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	case PhysicalType::UINT32:
-		return NLTYPE::template Operation<uint32_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	case PhysicalType::UINT64:
-		return NLTYPE::template Operation<uint64_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	case PhysicalType::INT128:
-		return NLTYPE::template Operation<hugeint_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                 rvector, current_match_count);
-	case PhysicalType::FLOAT:
-		return NLTYPE::template Operation<float, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                             current_match_count);
-	case PhysicalType::DOUBLE:
-		return NLTYPE::template Operation<double, OP>(left, right, left_size, right_size, lpos, rpos, lvector, rvector,
-		                                              current_match_count);
-	case PhysicalType::INTERVAL:
-		return NLTYPE::template Operation<interval_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                  rvector, current_match_count);
-	case PhysicalType::VARCHAR:
-		return NLTYPE::template Operation<string_t, OP>(left, right, left_size, right_size, lpos, rpos, lvector,
-		                                                rvector, current_match_count);
-	default:
-		throw InternalException("Unimplemented type for join!");
-	}
-}
-
-template <class NLTYPE>
-idx_t NestedLoopJoinComparisonSwitch(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos,
-                                     idx_t &rpos, SelectionVector &lvector, SelectionVector &rvector,
-                                     idx_t current_match_count, ExpressionType comparison_type) {
-	D_ASSERT(left.GetType() == right.GetType());
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		return NestedLoopJoinTypeSwitch<NLTYPE, ComparisonOperationWrapper<duckdb::Equals>>(
-		    left, right, left_size, right_size, lpos, rpos, lvector, rvector, current_match_count);
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return NestedLoopJoinTypeSwitch<NLTYPE, ComparisonOperationWrapper<duckdb::NotEquals>>(
-		    left, right, left_size, right_size, lpos, rpos, lvector, rvector, current_match_count);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return NestedLoopJoinTypeSwitch<NLTYPE, ComparisonOperationWrapper<duckdb::LessThan>>(
-		    left, right, left_size, right_size, lpos, rpos, lvector, rvector, current_match_count);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return NestedLoopJoinTypeSwitch<NLTYPE, ComparisonOperationWrapper<duckdb::GreaterThan>>(
-		    left, right, left_size, right_size, lpos, rpos, lvector, rvector, current_match_count);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return NestedLoopJoinTypeSwitch<NLTYPE, ComparisonOperationWrapper<duckdb::LessThanEquals>>(
-		    left, right, left_size, right_size, lpos, rpos, lvector, rvector, current_match_count);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return NestedLoopJoinTypeSwitch<NLTYPE, ComparisonOperationWrapper<duckdb::GreaterThanEquals>>(
-		    left, right, left_size, right_size, lpos, rpos, lvector, rvector, current_match_count);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return NestedLoopJoinTypeSwitch<NLTYPE, duckdb::DistinctFrom>(left, right, left_size, right_size, lpos, rpos,
-		                                                              lvector, rvector, current_match_count);
-	default:
-		throw NotImplementedException("Unimplemented comparison type for join!");
-	}
-}
-
-idx_t NestedLoopJoinInner::Perform(idx_t &lpos, idx_t &rpos, DataChunk &left_conditions, DataChunk &right_conditions,
-                                   SelectionVector &lvector, SelectionVector &rvector,
-                                   const vector<JoinCondition> &conditions) {
-	D_ASSERT(left_conditions.ColumnCount() == right_conditions.ColumnCount());
-	if (lpos >= left_conditions.size() || rpos >= right_conditions.size()) {
-		return 0;
-	}
-	// for the first condition, lvector and rvector are not set yet
-	// we initialize them using the InitialNestedLoopJoin
-	idx_t match_count = NestedLoopJoinComparisonSwitch<InitialNestedLoopJoin>(
-	    left_conditions.data[0], right_conditions.data[0], left_conditions.size(), right_conditions.size(), lpos, rpos,
-	    lvector, rvector, 0, conditions[0].comparison);
-	// now resolve the rest of the conditions
-	for (idx_t i = 1; i < conditions.size(); i++) {
-		// check if we have run out of tuples to compare
-		if (match_count == 0) {
-			return 0;
-		}
-		// if not, get the vectors to compare
-		Vector &l = left_conditions.data[i];
-		Vector &r = right_conditions.data[i];
-		// then we refine the currently obtained results using the RefineNestedLoopJoin
-		match_count = NestedLoopJoinComparisonSwitch<RefineNestedLoopJoin>(
-		    l, r, left_conditions.size(), right_conditions.size(), lpos, rpos, lvector, rvector, match_count,
-		    conditions[i].comparison);
-	}
-	return match_count;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-template <class T, class OP>
-static void TemplatedMarkJoin(Vector &left, Vector &right, idx_t lcount, idx_t rcount, bool found_match[]) {
-	VectorData left_data, right_data;
-	left.Orrify(lcount, left_data);
-	right.Orrify(rcount, right_data);
-
-	auto ldata = (T *)left_data.data;
-	auto rdata = (T *)right_data.data;
-	for (idx_t i = 0; i < lcount; i++) {
-		if (found_match[i]) {
-			continue;
-		}
-		auto lidx = left_data.sel->get_index(i);
-		if (!left_data.validity.RowIsValid(lidx)) {
-			continue;
-		}
-		for (idx_t j = 0; j < rcount; j++) {
-			auto ridx = right_data.sel->get_index(j);
-			if (!right_data.validity.RowIsValid(ridx)) {
-				continue;
-			}
-			if (OP::Operation(ldata[lidx], rdata[ridx])) {
-				found_match[i] = true;
-				break;
-			}
-		}
-	}
-}
-
-template <class OP>
-static void MarkJoinSwitch(Vector &left, Vector &right, idx_t lcount, idx_t rcount, bool found_match[]) {
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedMarkJoin<int8_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::INT16:
-		return TemplatedMarkJoin<int16_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::INT32:
-		return TemplatedMarkJoin<int32_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::INT64:
-		return TemplatedMarkJoin<int64_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::INT128:
-		return TemplatedMarkJoin<hugeint_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT8:
-		return TemplatedMarkJoin<uint8_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT16:
-		return TemplatedMarkJoin<uint16_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT32:
-		return TemplatedMarkJoin<uint32_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::UINT64:
-		return TemplatedMarkJoin<uint64_t, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::FLOAT:
-		return TemplatedMarkJoin<float, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::DOUBLE:
-		return TemplatedMarkJoin<double, OP>(left, right, lcount, rcount, found_match);
-	case PhysicalType::VARCHAR:
-		return TemplatedMarkJoin<string_t, OP>(left, right, lcount, rcount, found_match);
-	default:
-		throw NotImplementedException("Unimplemented type for mark join!");
-	}
-}
-
-static void MarkJoinComparisonSwitch(Vector &left, Vector &right, idx_t lcount, idx_t rcount, bool found_match[],
-                                     ExpressionType comparison_type) {
-	D_ASSERT(left.GetType() == right.GetType());
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		return MarkJoinSwitch<duckdb::Equals>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return MarkJoinSwitch<duckdb::NotEquals>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return MarkJoinSwitch<duckdb::LessThan>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return MarkJoinSwitch<duckdb::GreaterThan>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return MarkJoinSwitch<duckdb::LessThanEquals>(left, right, lcount, rcount, found_match);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return MarkJoinSwitch<duckdb::GreaterThanEquals>(left, right, lcount, rcount, found_match);
-	default:
-		throw NotImplementedException("Unimplemented comparison type for join!");
-	}
-}
-
-void NestedLoopJoinMark::Perform(DataChunk &left, ChunkCollection &right, bool found_match[],
-                                 const vector<JoinCondition> &conditions) {
-	// initialize a new temporary selection vector for the left chunk
-	// loop over all chunks in the RHS
-	for (idx_t chunk_idx = 0; chunk_idx < right.ChunkCount(); chunk_idx++) {
-		DataChunk &right_chunk = right.GetChunk(chunk_idx);
-		for (idx_t i = 0; i < conditions.size(); i++) {
-			MarkJoinComparisonSwitch(left.data[i], right_chunk.data[i], left.size(), right_chunk.size(), found_match,
-			                         conditions[i].comparison);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-AggregateObject::AggregateObject(AggregateFunction function, FunctionData *bind_data, idx_t child_count,
-                                 idx_t payload_size, bool distinct, PhysicalType return_type, Expression *filter)
-    : function(move(function)), bind_data(bind_data), child_count(child_count), payload_size(payload_size),
-      distinct(distinct), return_type(return_type), filter(filter) {
-}
-
-AggregateObject::AggregateObject(BoundAggregateExpression *aggr)
-    : AggregateObject(aggr->function, aggr->bind_info.get(), aggr->children.size(),
-                      AlignValue(aggr->function.state_size()), aggr->distinct, aggr->return_type.InternalType(),
-                      aggr->filter.get()) {
-}
-
-vector<AggregateObject> AggregateObject::CreateAggregateObjects(const vector<BoundAggregateExpression *> &bindings) {
-	vector<AggregateObject> aggregates;
-	aggregates.reserve(aggregates.size());
-	for (auto &binding : bindings) {
-		aggregates.emplace_back(binding);
-	}
-	return aggregates;
-}
-
-AggregateFilterData::AggregateFilterData(Allocator &allocator, Expression &filter_expr,
-                                         const vector<LogicalType> &payload_types)
-    : filter_executor(allocator, &filter_expr), true_sel(STANDARD_VECTOR_SIZE) {
-	if (payload_types.empty()) {
-		return;
-	}
-	filtered_payload.Initialize(allocator, payload_types);
-}
-
-idx_t AggregateFilterData::ApplyFilter(DataChunk &payload) {
-	filtered_payload.Reset();
-
-	auto count = filter_executor.SelectExpression(payload, true_sel);
-	filtered_payload.Slice(payload, true_sel, count);
-	return count;
-}
-
-AggregateFilterDataSet::AggregateFilterDataSet() {
-}
-
-void AggregateFilterDataSet::Initialize(Allocator &allocator, const vector<AggregateObject> &aggregates,
-                                        const vector<LogicalType> &payload_types) {
-	bool has_filters = false;
-	for (auto &aggregate : aggregates) {
-		if (aggregate.filter) {
-			has_filters = true;
-			break;
-		}
-	}
-	if (!has_filters) {
-		// no filters: nothing to do
-		return;
-	}
-	filter_data.resize(aggregates.size());
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggr = aggregates[aggr_idx];
-		if (aggr.filter) {
-			filter_data[aggr_idx] = make_unique<AggregateFilterData>(allocator, *aggr.filter, payload_types);
-		}
-	}
-}
-
-AggregateFilterData &AggregateFilterDataSet::GetFilterData(idx_t aggr_idx) {
-	D_ASSERT(aggr_idx < filter_data.size());
-	D_ASSERT(filter_data[aggr_idx]);
-	return *filter_data[aggr_idx];
-}
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
-                                             vector<unique_ptr<Expression>> expressions, idx_t estimated_cardinality,
-                                             PhysicalOperatorType type)
-    : PhysicalHashAggregate(context, move(types), move(expressions), {}, estimated_cardinality, type) {
-}
-
-PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
-                                             vector<unique_ptr<Expression>> expressions,
-                                             vector<unique_ptr<Expression>> groups_p, idx_t estimated_cardinality,
-                                             PhysicalOperatorType type)
-    : PhysicalHashAggregate(context, move(types), move(expressions), move(groups_p), {}, {}, estimated_cardinality,
-                            type) {
-}
-
-PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types,
-                                             vector<unique_ptr<Expression>> expressions,
-                                             vector<unique_ptr<Expression>> groups_p,
-                                             vector<GroupingSet> grouping_sets_p,
-                                             vector<vector<idx_t>> grouping_functions_p, idx_t estimated_cardinality,
-                                             PhysicalOperatorType type)
-    : PhysicalOperator(type, move(types), estimated_cardinality), groups(move(groups_p)),
-      grouping_sets(move(grouping_sets_p)), grouping_functions(move(grouping_functions_p)), any_distinct(false) {
-	// get a list of all aggregates to be computed
-	for (auto &expr : groups) {
-		group_types.push_back(expr->return_type);
-	}
-	if (grouping_sets.empty()) {
-		GroupingSet set;
-		for (idx_t i = 0; i < group_types.size(); i++) {
-			set.insert(i);
-		}
-		grouping_sets.push_back(move(set));
-	}
-	vector<LogicalType> payload_types_filters;
-	for (auto &expr : expressions) {
-		D_ASSERT(expr->expression_class == ExpressionClass::BOUND_AGGREGATE);
-		D_ASSERT(expr->IsAggregate());
-		auto &aggr = (BoundAggregateExpression &)*expr;
-		bindings.push_back(&aggr);
-
-		if (aggr.distinct) {
-			any_distinct = true;
-		}
-
-		aggregate_return_types.push_back(aggr.return_type);
-		for (auto &child : aggr.children) {
-			payload_types.push_back(child->return_type);
-		}
-		if (aggr.filter) {
-			payload_types_filters.push_back(aggr.filter->return_type);
-		}
-		if (!aggr.function.combine) {
-			throw InternalException("Aggregate function %s is missing a combine method", aggr.function.name);
-		}
-		aggregates.push_back(move(expr));
-	}
-
-	for (const auto &pay_filters : payload_types_filters) {
-		payload_types.push_back(pay_filters);
-	}
-
-	// filter_indexes must be pre-built, not lazily instantiated in parallel...
-	idx_t aggregate_input_idx = 0;
-	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
-		aggregate_input_idx += aggr.children.size();
-	}
-	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
-		if (aggr.filter) {
-			auto &bound_ref_expr = (BoundReferenceExpression &)*aggr.filter;
-			auto it = filter_indexes.find(aggr.filter.get());
-			if (it == filter_indexes.end()) {
-				filter_indexes[aggr.filter.get()] = bound_ref_expr.index;
-				bound_ref_expr.index = aggregate_input_idx++;
-			} else {
-				++aggregate_input_idx;
-			}
-		}
-	}
-
-	for (auto &grouping_set : grouping_sets) {
-		radix_tables.emplace_back(grouping_set, *this);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class HashAggregateGlobalState : public GlobalSinkState {
-public:
-	HashAggregateGlobalState(const PhysicalHashAggregate &op, ClientContext &context) {
-		radix_states.reserve(op.radix_tables.size());
-		for (auto &rt : op.radix_tables) {
-			radix_states.push_back(rt.GetGlobalSinkState(context));
-		}
-	}
-
-	vector<unique_ptr<GlobalSinkState>> radix_states;
-};
-
-class HashAggregateLocalState : public LocalSinkState {
-public:
-	HashAggregateLocalState(const PhysicalHashAggregate &op, ExecutionContext &context) {
-		if (!op.payload_types.empty()) {
-			aggregate_input_chunk.InitializeEmpty(op.payload_types);
-		}
-
-		radix_states.reserve(op.radix_tables.size());
-		for (auto &rt : op.radix_tables) {
-			radix_states.push_back(rt.GetLocalSinkState(context));
-		}
-	}
-
-	DataChunk aggregate_input_chunk;
-
-	vector<unique_ptr<LocalSinkState>> radix_states;
-};
-
-void PhysicalHashAggregate::SetMultiScan(GlobalSinkState &state) {
-	auto &gstate = (HashAggregateGlobalState &)state;
-	for (auto &radix_state : gstate.radix_states) {
-		RadixPartitionedHashTable::SetMultiScan(*radix_state);
-	}
-}
-
-unique_ptr<GlobalSinkState> PhysicalHashAggregate::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<HashAggregateGlobalState>(*this, context);
-}
-
-unique_ptr<LocalSinkState> PhysicalHashAggregate::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<HashAggregateLocalState>(*this, context);
-}
-
-SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                           DataChunk &input) const {
-	auto &llstate = (HashAggregateLocalState &)lstate;
-	auto &gstate = (HashAggregateGlobalState &)state;
-
-	DataChunk &aggregate_input_chunk = llstate.aggregate_input_chunk;
-
-	idx_t aggregate_input_idx = 0;
-	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
-		for (auto &child_expr : aggr.children) {
-			D_ASSERT(child_expr->type == ExpressionType::BOUND_REF);
-			auto &bound_ref_expr = (BoundReferenceExpression &)*child_expr;
-			D_ASSERT(bound_ref_expr.index < input.data.size());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[bound_ref_expr.index]);
-		}
-	}
-	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
-		if (aggr.filter) {
-			auto it = filter_indexes.find(aggr.filter.get());
-			D_ASSERT(it != filter_indexes.end());
-			D_ASSERT(it->second < input.data.size());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[it->second]);
-		}
-	}
-
-	aggregate_input_chunk.SetCardinality(input.size());
-	aggregate_input_chunk.Verify();
-
-	for (idx_t i = 0; i < radix_tables.size(); i++) {
-		radix_tables[i].Sink(context, *gstate.radix_states[i], *llstate.radix_states[i], input, aggregate_input_chunk);
-	}
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalHashAggregate::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const {
-	auto &gstate = (HashAggregateGlobalState &)state;
-	auto &llstate = (HashAggregateLocalState &)lstate;
-
-	for (idx_t i = 0; i < radix_tables.size(); i++) {
-		radix_tables[i].Combine(context, *gstate.radix_states[i], *llstate.radix_states[i]);
-	}
-}
-
-class HashAggregateFinalizeEvent : public Event {
-public:
-	HashAggregateFinalizeEvent(const PhysicalHashAggregate &op_p, HashAggregateGlobalState &gstate_p,
-	                           Pipeline *pipeline_p)
-	    : Event(pipeline_p->executor), op(op_p), gstate(gstate_p), pipeline(pipeline_p) {
-	}
-
-	const PhysicalHashAggregate &op;
-	HashAggregateGlobalState &gstate;
-	Pipeline *pipeline;
-
-public:
-	void Schedule() override {
-		vector<unique_ptr<Task>> tasks;
-		for (idx_t i = 0; i < op.radix_tables.size(); i++) {
-			op.radix_tables[i].ScheduleTasks(pipeline->executor, shared_from_this(), *gstate.radix_states[i], tasks);
-		}
-		D_ASSERT(!tasks.empty());
-		SetTasks(move(tasks));
-	}
-};
-
-SinkFinalizeType PhysicalHashAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                 GlobalSinkState &gstate_p) const {
-	auto &gstate = (HashAggregateGlobalState &)gstate_p;
-	bool any_partitioned = false;
-	for (idx_t i = 0; i < gstate.radix_states.size(); i++) {
-		bool is_partitioned = radix_tables[i].Finalize(context, *gstate.radix_states[i]);
-		if (is_partitioned) {
-			any_partitioned = true;
-		}
-	}
-	if (any_partitioned) {
-		auto new_event = make_shared<HashAggregateFinalizeEvent>(*this, gstate, &pipeline);
-		event.InsertEvent(move(new_event));
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class PhysicalHashAggregateState : public GlobalSourceState {
-public:
-	explicit PhysicalHashAggregateState(ClientContext &context, const PhysicalHashAggregate &op) : scan_index(0) {
-		for (auto &rt : op.radix_tables) {
-			radix_states.push_back(rt.GetGlobalSourceState(context));
-		}
-	}
-
-	idx_t scan_index;
-
-	vector<unique_ptr<GlobalSourceState>> radix_states;
-};
-
-unique_ptr<GlobalSourceState> PhysicalHashAggregate::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<PhysicalHashAggregateState>(context, *this);
-}
-
-void PhysicalHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                    LocalSourceState &lstate) const {
-	auto &gstate = (HashAggregateGlobalState &)*sink_state;
-	auto &state = (PhysicalHashAggregateState &)gstate_p;
-	while (state.scan_index < state.radix_states.size()) {
-		radix_tables[state.scan_index].GetData(context, chunk, *gstate.radix_states[state.scan_index],
-		                                       *state.radix_states[state.scan_index]);
-		if (chunk.size() != 0) {
-			return;
-		}
-
-		state.scan_index++;
-	}
-}
-
-string PhysicalHashAggregate::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		if (i > 0) {
-			result += "\n";
-		}
-		result += groups[i]->GetName();
-	}
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
-		if (i > 0 || !groups.empty()) {
-			result += "\n";
-		}
-		result += aggregates[i]->GetName();
-		if (aggregate.filter) {
-			result += " Filter: " + aggregate.filter->GetName();
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-3.cpp b/velox/external/duckdb/duckdb-3.cpp
deleted file mode 100644
index 93015e1fa01f3..0000000000000
--- a/velox/external/duckdb/duckdb-3.cpp
+++ /dev/null
@@ -1,16839 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalPerfectHashAggregate::PhysicalPerfectHashAggregate(ClientContext &context, vector<LogicalType> types_p,
-                                                           vector<unique_ptr<Expression>> aggregates_p,
-                                                           vector<unique_ptr<Expression>> groups_p,
-                                                           vector<unique_ptr<BaseStatistics>> group_stats,
-                                                           vector<idx_t> required_bits_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::PERFECT_HASH_GROUP_BY, move(types_p), estimated_cardinality),
-      groups(move(groups_p)), aggregates(move(aggregates_p)), required_bits(move(required_bits_p)) {
-	D_ASSERT(groups.size() == group_stats.size());
-	group_minima.reserve(group_stats.size());
-	for (auto &stats : group_stats) {
-		D_ASSERT(stats);
-		auto &nstats = (NumericStatistics &)*stats;
-		D_ASSERT(!nstats.min.IsNull());
-		group_minima.push_back(move(nstats.min));
-	}
-	for (auto &expr : groups) {
-		group_types.push_back(expr->return_type);
-	}
-
-	vector<BoundAggregateExpression *> bindings;
-	vector<LogicalType> payload_types_filters;
-	for (auto &expr : aggregates) {
-		D_ASSERT(expr->expression_class == ExpressionClass::BOUND_AGGREGATE);
-		D_ASSERT(expr->IsAggregate());
-		auto &aggr = (BoundAggregateExpression &)*expr;
-		bindings.push_back(&aggr);
-
-		D_ASSERT(!aggr.distinct);
-		D_ASSERT(aggr.function.combine);
-		for (auto &child : aggr.children) {
-			payload_types.push_back(child->return_type);
-		}
-		if (aggr.filter) {
-			payload_types_filters.push_back(aggr.filter->return_type);
-		}
-	}
-	for (const auto &pay_filters : payload_types_filters) {
-		payload_types.push_back(pay_filters);
-	}
-	aggregate_objects = AggregateObject::CreateAggregateObjects(bindings);
-
-	// filter_indexes must be pre-built, not lazily instantiated in parallel...
-	idx_t aggregate_input_idx = 0;
-	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
-		aggregate_input_idx += aggr.children.size();
-	}
-	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
-		if (aggr.filter) {
-			auto &bound_ref_expr = (BoundReferenceExpression &)*aggr.filter;
-			auto it = filter_indexes.find(aggr.filter.get());
-			if (it == filter_indexes.end()) {
-				filter_indexes[aggr.filter.get()] = bound_ref_expr.index;
-				bound_ref_expr.index = aggregate_input_idx++;
-			} else {
-				++aggregate_input_idx;
-			}
-		}
-	}
-}
-
-unique_ptr<PerfectAggregateHashTable> PhysicalPerfectHashAggregate::CreateHT(Allocator &allocator,
-                                                                             ClientContext &context) const {
-	return make_unique<PerfectAggregateHashTable>(allocator, BufferManager::GetBufferManager(context), group_types,
-	                                              payload_types, aggregate_objects, group_minima, required_bits);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class PerfectHashAggregateGlobalState : public GlobalSinkState {
-public:
-	PerfectHashAggregateGlobalState(const PhysicalPerfectHashAggregate &op, ClientContext &context)
-	    : ht(op.CreateHT(Allocator::Get(context), context)) {
-	}
-
-	//! The lock for updating the global aggregate state
-	mutex lock;
-	//! The global aggregate hash table
-	unique_ptr<PerfectAggregateHashTable> ht;
-};
-
-class PerfectHashAggregateLocalState : public LocalSinkState {
-public:
-	PerfectHashAggregateLocalState(const PhysicalPerfectHashAggregate &op, ExecutionContext &context)
-	    : ht(op.CreateHT(Allocator::Get(context.client), context.client)) {
-		group_chunk.InitializeEmpty(op.group_types);
-		if (!op.payload_types.empty()) {
-			aggregate_input_chunk.InitializeEmpty(op.payload_types);
-		}
-	}
-
-	//! The local aggregate hash table
-	unique_ptr<PerfectAggregateHashTable> ht;
-	DataChunk group_chunk;
-	DataChunk aggregate_input_chunk;
-};
-
-unique_ptr<GlobalSinkState> PhysicalPerfectHashAggregate::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<PerfectHashAggregateGlobalState>(*this, context);
-}
-
-unique_ptr<LocalSinkState> PhysicalPerfectHashAggregate::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<PerfectHashAggregateLocalState>(*this, context);
-}
-
-SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, GlobalSinkState &state,
-                                                  LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &lstate = (PerfectHashAggregateLocalState &)lstate_p;
-	DataChunk &group_chunk = lstate.group_chunk;
-	DataChunk &aggregate_input_chunk = lstate.aggregate_input_chunk;
-
-	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
-		auto &group = groups[group_idx];
-		D_ASSERT(group->type == ExpressionType::BOUND_REF);
-		auto &bound_ref_expr = (BoundReferenceExpression &)*group;
-		group_chunk.data[group_idx].Reference(input.data[bound_ref_expr.index]);
-	}
-	idx_t aggregate_input_idx = 0;
-	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
-		for (auto &child_expr : aggr.children) {
-			D_ASSERT(child_expr->type == ExpressionType::BOUND_REF);
-			auto &bound_ref_expr = (BoundReferenceExpression &)*child_expr;
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[bound_ref_expr.index]);
-		}
-	}
-	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
-		if (aggr.filter) {
-			auto it = filter_indexes.find(aggr.filter.get());
-			D_ASSERT(it != filter_indexes.end());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[it->second]);
-		}
-	}
-
-	group_chunk.SetCardinality(input.size());
-
-	aggregate_input_chunk.SetCardinality(input.size());
-
-	group_chunk.Verify();
-	aggregate_input_chunk.Verify();
-	D_ASSERT(aggregate_input_chunk.ColumnCount() == 0 || group_chunk.size() == aggregate_input_chunk.size());
-
-	lstate.ht->AddChunk(group_chunk, aggregate_input_chunk);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-void PhysicalPerfectHashAggregate::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                           LocalSinkState &lstate_p) const {
-	auto &lstate = (PerfectHashAggregateLocalState &)lstate_p;
-	auto &gstate = (PerfectHashAggregateGlobalState &)gstate_p;
-
-	lock_guard<mutex> l(gstate.lock);
-	gstate.ht->Combine(*lstate.ht);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class PerfectHashAggregateState : public GlobalSourceState {
-public:
-	PerfectHashAggregateState() : ht_scan_position(0) {
-	}
-
-	//! The current position to scan the HT for output tuples
-	idx_t ht_scan_position;
-};
-
-unique_ptr<GlobalSourceState> PhysicalPerfectHashAggregate::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<PerfectHashAggregateState>();
-}
-
-void PhysicalPerfectHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                           LocalSourceState &lstate) const {
-	auto &state = (PerfectHashAggregateState &)gstate_p;
-	auto &gstate = (PerfectHashAggregateGlobalState &)*sink_state;
-
-	gstate.ht->Scan(state.ht_scan_position, chunk);
-}
-
-string PhysicalPerfectHashAggregate::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		if (i > 0) {
-			result += "\n";
-		}
-		result += groups[i]->GetName();
-	}
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		if (i > 0 || !groups.empty()) {
-			result += "\n";
-		}
-		result += aggregates[i]->GetName();
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
-		if (aggregate.filter) {
-			result += " Filter: " + aggregate.filter->GetName();
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalSimpleAggregate::PhysicalSimpleAggregate(vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-                                                 idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::SIMPLE_AGGREGATE, move(types), estimated_cardinality),
-      aggregates(move(expressions)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-struct AggregateState {
-	explicit AggregateState(const vector<unique_ptr<Expression>> &aggregate_expressions) {
-		for (auto &aggregate : aggregate_expressions) {
-			D_ASSERT(aggregate->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-			auto &aggr = (BoundAggregateExpression &)*aggregate;
-			auto state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
-			aggr.function.initialize(state.get());
-			aggregates.push_back(move(state));
-			destructors.push_back(aggr.function.destructor);
-		}
-	}
-	~AggregateState() {
-		D_ASSERT(destructors.size() == aggregates.size());
-		for (idx_t i = 0; i < destructors.size(); i++) {
-			if (!destructors[i]) {
-				continue;
-			}
-			Vector state_vector(Value::POINTER((uintptr_t)aggregates[i].get()));
-			state_vector.SetVectorType(VectorType::FLAT_VECTOR);
-
-			destructors[i](state_vector, 1);
-		}
-	}
-
-	void Move(AggregateState &other) {
-		other.aggregates = move(aggregates);
-		other.destructors = move(destructors);
-	}
-
-	//! The aggregate values
-	vector<unique_ptr<data_t[]>> aggregates;
-	// The destructors
-	vector<aggregate_destructor_t> destructors;
-};
-
-class SimpleAggregateGlobalState : public GlobalSinkState {
-public:
-	explicit SimpleAggregateGlobalState(const vector<unique_ptr<Expression>> &aggregates)
-	    : state(aggregates), finished(false) {
-	}
-
-	//! The lock for updating the global aggregate state
-	mutex lock;
-	//! The global aggregate state
-	AggregateState state;
-	//! Whether or not the aggregate is finished
-	bool finished;
-};
-
-class SimpleAggregateLocalState : public LocalSinkState {
-public:
-	SimpleAggregateLocalState(Allocator &allocator, const vector<unique_ptr<Expression>> &aggregates,
-	                          const vector<LogicalType> &child_types)
-	    : state(aggregates), child_executor(allocator) {
-		vector<LogicalType> payload_types;
-		vector<AggregateObject> aggregate_objects;
-		for (auto &aggregate : aggregates) {
-			D_ASSERT(aggregate->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-			auto &aggr = (BoundAggregateExpression &)*aggregate;
-			// initialize the payload chunk
-			if (!aggr.children.empty()) {
-				for (auto &child : aggr.children) {
-					payload_types.push_back(child->return_type);
-					child_executor.AddExpression(*child);
-				}
-			}
-			aggregate_objects.emplace_back(&aggr);
-		}
-		if (!payload_types.empty()) { // for select count(*) from t; there is no payload at all
-			payload_chunk.Initialize(allocator, payload_types);
-		}
-		filter_set.Initialize(allocator, aggregate_objects, child_types);
-	}
-	void Reset() {
-		payload_chunk.Reset();
-	}
-
-	//! The local aggregate state
-	AggregateState state;
-	//! The executor
-	ExpressionExecutor child_executor;
-	//! The payload chunk
-	DataChunk payload_chunk;
-	//! Aggregate filter data set
-	AggregateFilterDataSet filter_set;
-};
-
-unique_ptr<GlobalSinkState> PhysicalSimpleAggregate::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<SimpleAggregateGlobalState>(aggregates);
-}
-
-unique_ptr<LocalSinkState> PhysicalSimpleAggregate::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<SimpleAggregateLocalState>(Allocator::Get(context.client), aggregates, children[0]->GetTypes());
-}
-
-SinkResultType PhysicalSimpleAggregate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                             DataChunk &input) const {
-	auto &sink = (SimpleAggregateLocalState &)lstate;
-	// perform the aggregation inside the local state
-	idx_t payload_idx = 0, payload_expr_idx = 0;
-	sink.Reset();
-
-	DataChunk &payload_chunk = sink.payload_chunk;
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[aggr_idx];
-		idx_t payload_cnt = 0;
-		// resolve the filter (if any)
-		if (aggregate.filter) {
-			auto &filtered_data = sink.filter_set.GetFilterData(aggr_idx);
-			auto count = filtered_data.ApplyFilter(input);
-
-			sink.child_executor.SetChunk(filtered_data.filtered_payload);
-			payload_chunk.SetCardinality(count);
-		} else {
-			sink.child_executor.SetChunk(input);
-			payload_chunk.SetCardinality(input);
-		}
-		// resolve the child expressions of the aggregate (if any)
-		if (!aggregate.children.empty()) {
-			for (idx_t i = 0; i < aggregate.children.size(); ++i) {
-				sink.child_executor.ExecuteExpression(payload_expr_idx, payload_chunk.data[payload_idx + payload_cnt]);
-				payload_expr_idx++;
-				payload_cnt++;
-			}
-		}
-
-		AggregateInputData aggr_input_data(aggregate.bind_info.get());
-		aggregate.function.simple_update(payload_cnt == 0 ? nullptr : &payload_chunk.data[payload_idx], aggr_input_data,
-		                                 payload_cnt, sink.state.aggregates[aggr_idx].get(), payload_chunk.size());
-		payload_idx += payload_cnt;
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-void PhysicalSimpleAggregate::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const {
-	auto &gstate = (SimpleAggregateGlobalState &)state;
-	auto &source = (SimpleAggregateLocalState &)lstate;
-	D_ASSERT(!gstate.finished);
-
-	// finalize: combine the local state into the global state
-	// all aggregates are combinable: we might be doing a parallel aggregate
-	// use the combine method to combine the partial aggregates
-	lock_guard<mutex> glock(gstate.lock);
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[aggr_idx];
-		Vector source_state(Value::POINTER((uintptr_t)source.state.aggregates[aggr_idx].get()));
-		Vector dest_state(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
-
-		AggregateInputData aggr_input_data(aggregate.bind_info.get());
-		aggregate.function.combine(source_state, dest_state, aggr_input_data, 1);
-	}
-
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &source.child_executor, "child_executor", 0);
-	client_profiler.Flush(context.thread.profiler);
-}
-
-SinkFinalizeType PhysicalSimpleAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                   GlobalSinkState &gstate_p) const {
-	auto &gstate = (SimpleAggregateGlobalState &)gstate_p;
-
-	D_ASSERT(!gstate.finished);
-	gstate.finished = true;
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class SimpleAggregateState : public GlobalSourceState {
-public:
-	SimpleAggregateState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalSimpleAggregate::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<SimpleAggregateState>();
-}
-
-void PhysicalSimpleAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                      LocalSourceState &lstate) const {
-	auto &gstate = (SimpleAggregateGlobalState &)*sink_state;
-	auto &state = (SimpleAggregateState &)gstate_p;
-	D_ASSERT(gstate.finished);
-	if (state.finished) {
-		return;
-	}
-
-	// initialize the result chunk with the aggregate values
-	chunk.SetCardinality(1);
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[aggr_idx];
-
-		Vector state_vector(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
-		AggregateInputData aggr_input_data(aggregate.bind_info.get());
-		aggregate.function.finalize(state_vector, aggr_input_data, chunk.data[aggr_idx], 1, 0);
-	}
-	state.finished = true;
-}
-
-string PhysicalSimpleAggregate::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
-		if (i > 0) {
-			result += "\n";
-		}
-		result += aggregates[i]->GetName();
-		if (aggregate.filter) {
-			result += " Filter: " + aggregate.filter->GetName();
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalStreamingWindow::PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                                                 idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, move(types), estimated_cardinality), select_list(move(select_list)) {
-}
-
-class StreamingWindowGlobalState : public GlobalOperatorState {
-public:
-	StreamingWindowGlobalState() : row_number(1) {
-	}
-
-	//! The next row number.
-	std::atomic<int64_t> row_number;
-};
-
-class StreamingWindowState : public OperatorState {
-public:
-	StreamingWindowState() : initialized(false) {
-	}
-
-	void Initialize(DataChunk &input, const vector<unique_ptr<Expression>> &expressions) {
-		for (idx_t expr_idx = 0; expr_idx < expressions.size(); expr_idx++) {
-			auto &expr = *expressions[expr_idx];
-			switch (expr.GetExpressionType()) {
-			case ExpressionType::WINDOW_FIRST_VALUE: {
-				auto &wexpr = (BoundWindowExpression &)expr;
-				auto &ref = (BoundReferenceExpression &)*wexpr.children[0];
-				const_vectors.push_back(make_unique<Vector>(input.data[ref.index].GetValue(0)));
-				break;
-			}
-			case ExpressionType::WINDOW_PERCENT_RANK: {
-				const_vectors.push_back(make_unique<Vector>(Value((double)0)));
-				break;
-			}
-			case ExpressionType::WINDOW_RANK:
-			case ExpressionType::WINDOW_RANK_DENSE: {
-				const_vectors.push_back(make_unique<Vector>(Value((int64_t)1)));
-				break;
-			}
-			default:
-				const_vectors.push_back(nullptr);
-			}
-		}
-		initialized = true;
-	}
-
-public:
-	bool initialized;
-	vector<unique_ptr<Vector>> const_vectors;
-};
-
-unique_ptr<GlobalOperatorState> PhysicalStreamingWindow::GetGlobalOperatorState(ClientContext &context) const {
-	return make_unique<StreamingWindowGlobalState>();
-}
-
-unique_ptr<OperatorState> PhysicalStreamingWindow::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<StreamingWindowState>();
-}
-
-OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                    GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (StreamingWindowGlobalState &)gstate_p;
-	auto &state = (StreamingWindowState &)state_p;
-	if (!state.initialized) {
-		state.Initialize(input, select_list);
-	}
-	// Put payload columns in place
-	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
-		chunk.data[col_idx].Reference(input.data[col_idx]);
-	}
-	// Compute window function
-	const idx_t count = input.size();
-	for (idx_t expr_idx = 0; expr_idx < select_list.size(); expr_idx++) {
-		idx_t col_idx = input.data.size() + expr_idx;
-		auto &expr = *select_list[expr_idx];
-		switch (expr.GetExpressionType()) {
-		case ExpressionType::WINDOW_FIRST_VALUE:
-		case ExpressionType::WINDOW_PERCENT_RANK:
-		case ExpressionType::WINDOW_RANK:
-		case ExpressionType::WINDOW_RANK_DENSE: {
-			// Reference constant vector
-			chunk.data[col_idx].Reference(*state.const_vectors[expr_idx]);
-			break;
-		}
-		case ExpressionType::WINDOW_ROW_NUMBER: {
-			// Set row numbers
-			auto rdata = FlatVector::GetData<int64_t>(chunk.data[col_idx]);
-			for (idx_t i = 0; i < count; i++) {
-				rdata[i] = gstate.row_number + i;
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("%s for StreamingWindow", ExpressionTypeToString(expr.GetExpressionType()));
-		}
-	}
-	gstate.row_number += count;
-	chunk.SetCardinality(count);
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-string PhysicalStreamingWindow::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < select_list.size(); i++) {
-		if (i > 0) {
-			result += "\n";
-		}
-		result += select_list[i]->GetName();
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-#include <cmath>
-#include <numeric>
-
-namespace duckdb {
-
-using counts_t = std::vector<size_t>;
-
-//	Global sink state
-class WindowGlobalState : public GlobalSinkState {
-public:
-	WindowGlobalState(Allocator &allocator, const PhysicalWindow &op_p, ClientContext &context)
-	    : op(op_p), buffer_manager(BufferManager::GetBufferManager(context)), chunks(allocator),
-	      over_collection(allocator), hash_collection(allocator), mode(DBConfig::GetConfig(context).window_mode) {
-	}
-	const PhysicalWindow &op;
-	BufferManager &buffer_manager;
-	mutex lock;
-	ChunkCollection chunks;
-	ChunkCollection over_collection;
-	ChunkCollection hash_collection;
-	counts_t counts;
-	WindowAggregationMode mode;
-};
-
-//	Per-thread sink state
-class WindowLocalState : public LocalSinkState {
-public:
-	explicit WindowLocalState(Allocator &allocator, const PhysicalWindow &op_p, const unsigned partition_bits = 10)
-	    : op(op_p), chunks(allocator), over_collection(allocator), hash_collection(allocator),
-	      partition_count(size_t(1) << partition_bits) {
-	}
-
-	const PhysicalWindow &op;
-	ChunkCollection chunks;
-	ChunkCollection over_collection;
-	ChunkCollection hash_collection;
-	const size_t partition_count;
-	counts_t counts;
-};
-
-// Per-thread read state
-class WindowOperatorState : public LocalSourceState {
-public:
-	WindowOperatorState(Allocator &allocator, const PhysicalWindow &op, ExecutionContext &context)
-	    : buffer_manager(BufferManager::GetBufferManager(context.client)), chunks(allocator),
-	      window_results(allocator) {
-		auto &gstate = (WindowGlobalState &)*op.sink_state;
-		// initialize thread-local operator state
-		partitions = gstate.counts.size();
-		next_part = 0;
-		position = 0;
-	}
-
-	BufferManager &buffer_manager;
-	//! The number of partitions to process (0 if there is no partitioning)
-	size_t partitions;
-	//! The output read position.
-	size_t next_part;
-	//! The generated input chunks
-	ChunkCollection chunks;
-	//! The generated output chunks
-	ChunkCollection window_results;
-	//! The read cursor
-	idx_t position;
-
-	unique_ptr<GlobalSortState> global_sort_state;
-};
-
-// this implements a sorted window functions variant
-PhysicalWindow::PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                               idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, move(types), estimated_cardinality), select_list(move(select_list)) {
-}
-
-template <typename INPUT_TYPE>
-struct ChunkIterator {
-
-	ChunkIterator(ChunkCollection &collection, const idx_t col_idx)
-	    : collection(collection), col_idx(col_idx), chunk_begin(0), chunk_end(0), ch_idx(0), data(nullptr),
-	      validity(nullptr) {
-		Update(0);
-	}
-
-	inline void Update(idx_t r) {
-		if (r >= chunk_end) {
-			ch_idx = collection.LocateChunk(r);
-			auto &ch = collection.GetChunk(ch_idx);
-			chunk_begin = ch_idx * STANDARD_VECTOR_SIZE;
-			chunk_end = chunk_begin + ch.size();
-			auto &vector = ch.data[col_idx];
-			data = FlatVector::GetData<INPUT_TYPE>(vector);
-			validity = &FlatVector::Validity(vector);
-		}
-	}
-
-	inline bool IsValid(idx_t r) {
-		return validity->RowIsValid(r - chunk_begin);
-	}
-
-	inline INPUT_TYPE GetValue(idx_t r) {
-		return data[r - chunk_begin];
-	}
-
-private:
-	ChunkCollection &collection;
-	idx_t col_idx;
-	idx_t chunk_begin;
-	idx_t chunk_end;
-	idx_t ch_idx;
-	const INPUT_TYPE *data;
-	ValidityMask *validity;
-};
-
-template <typename INPUT_TYPE>
-static void MaskTypedColumn(ValidityMask &mask, ChunkCollection &over_collection, const idx_t c) {
-	ChunkIterator<INPUT_TYPE> ci(over_collection, c);
-
-	//	Record the first value
-	idx_t r = 0;
-	auto prev_valid = ci.IsValid(r);
-	auto prev = ci.GetValue(r);
-
-	//	Process complete blocks
-	const auto count = over_collection.Count();
-	const auto entry_count = mask.EntryCount(count);
-	for (idx_t entry_idx = 0; entry_idx < entry_count; ++entry_idx) {
-		auto validity_entry = mask.GetValidityEntry(entry_idx);
-
-		//	Skip the block if it is all boundaries.
-		idx_t next = MinValue<idx_t>(r + ValidityMask::BITS_PER_VALUE, count);
-		if (ValidityMask::AllValid(validity_entry)) {
-			r = next;
-			continue;
-		}
-
-		//	Scan the rows in the complete block
-		idx_t start = r;
-		for (; r < next; ++r) {
-			//	Update the chunk for this row
-			ci.Update(r);
-
-			auto curr_valid = ci.IsValid(r);
-			auto curr = ci.GetValue(r);
-			if (!ValidityMask::RowIsValid(validity_entry, r - start)) {
-				if (curr_valid != prev_valid || (curr_valid && !Equals::Operation(curr, prev))) {
-					mask.SetValidUnsafe(r);
-				}
-			}
-			prev_valid = curr_valid;
-			prev = curr;
-		}
-	}
-}
-
-static void MaskColumn(ValidityMask &mask, ChunkCollection &over_collection, const idx_t c) {
-	auto &vector = over_collection.GetChunk(0).data[c];
-	switch (vector.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		MaskTypedColumn<int8_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT16:
-		MaskTypedColumn<int16_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT32:
-		MaskTypedColumn<int32_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT64:
-		MaskTypedColumn<int64_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT8:
-		MaskTypedColumn<uint8_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT16:
-		MaskTypedColumn<uint16_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT32:
-		MaskTypedColumn<uint32_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::UINT64:
-		MaskTypedColumn<uint64_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INT128:
-		MaskTypedColumn<hugeint_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::FLOAT:
-		MaskTypedColumn<float>(mask, over_collection, c);
-		break;
-	case PhysicalType::DOUBLE:
-		MaskTypedColumn<double>(mask, over_collection, c);
-		break;
-	case PhysicalType::VARCHAR:
-		MaskTypedColumn<string_t>(mask, over_collection, c);
-		break;
-	case PhysicalType::INTERVAL:
-		MaskTypedColumn<interval_t>(mask, over_collection, c);
-		break;
-	default:
-		throw NotImplementedException("Type for comparison");
-		break;
-	}
-}
-
-static idx_t FindNextStart(const ValidityMask &mask, idx_t l, const idx_t r, idx_t &n) {
-	if (mask.AllValid()) {
-		auto start = MinValue(l + n - 1, r);
-		n -= MinValue(n, r - l);
-		return start;
-	}
-
-	while (l < r) {
-		//	If l is aligned with the start of a block, and the block is blank, then skip forward one block.
-		idx_t entry_idx;
-		idx_t shift;
-		mask.GetEntryIndex(l, entry_idx, shift);
-
-		const auto block = mask.GetValidityEntry(entry_idx);
-		if (mask.NoneValid(block) && !shift) {
-			l += ValidityMask::BITS_PER_VALUE;
-			continue;
-		}
-
-		// Loop over the block
-		for (; shift < ValidityMask::BITS_PER_VALUE && l < r; ++shift, ++l) {
-			if (mask.RowIsValid(block, shift) && --n == 0) {
-				return MinValue(l, r);
-			}
-		}
-	}
-
-	//	Didn't find a start so return the end of the range
-	return r;
-}
-
-static idx_t FindPrevStart(const ValidityMask &mask, const idx_t l, idx_t r, idx_t &n) {
-	if (mask.AllValid()) {
-		auto start = (r <= l + n) ? l : r - n;
-		n -= r - start;
-		return start;
-	}
-
-	while (l < r) {
-		// If r is aligned with the start of a block, and the previous block is blank,
-		// then skip backwards one block.
-		idx_t entry_idx;
-		idx_t shift;
-		mask.GetEntryIndex(r - 1, entry_idx, shift);
-
-		const auto block = mask.GetValidityEntry(entry_idx);
-		if (mask.NoneValid(block) && (shift + 1 == ValidityMask::BITS_PER_VALUE)) {
-			// r is nonzero (> l) and word aligned, so this will not underflow.
-			r -= ValidityMask::BITS_PER_VALUE;
-			continue;
-		}
-
-		// Loop backwards over the block
-		// shift is probing r-1 >= l >= 0
-		for (++shift; shift-- > 0; --r) {
-			if (mask.RowIsValid(block, shift) && --n == 0) {
-				return MaxValue(l, r - 1);
-			}
-		}
-	}
-
-	//	Didn't find a start so return the start of the range
-	return l;
-}
-
-static void MaterializeExpressions(Expression **exprs, idx_t expr_count, ChunkCollection &input,
-                                   ChunkCollection &output, bool scalar = false) {
-	if (expr_count == 0) {
-		return;
-	}
-
-	auto &allocator = input.GetAllocator();
-	vector<LogicalType> types;
-	ExpressionExecutor executor(allocator);
-	for (idx_t expr_idx = 0; expr_idx < expr_count; ++expr_idx) {
-		types.push_back(exprs[expr_idx]->return_type);
-		executor.AddExpression(*exprs[expr_idx]);
-	}
-
-	for (idx_t i = 0; i < input.ChunkCount(); i++) {
-		DataChunk chunk;
-		chunk.Initialize(allocator, types);
-
-		executor.Execute(input.GetChunk(i), chunk);
-
-		chunk.Verify();
-		output.Append(chunk);
-
-		if (scalar) {
-			break;
-		}
-	}
-}
-
-static void MaterializeExpression(Expression *expr, ChunkCollection &input, ChunkCollection &output,
-                                  bool scalar = false) {
-	MaterializeExpressions(&expr, 1, input, output, scalar);
-}
-
-static void SortCollectionForPartition(WindowOperatorState &state, BoundWindowExpression *wexpr, ChunkCollection &input,
-                                       ChunkCollection &over, ChunkCollection *hashes, const hash_t hash_bin,
-                                       const hash_t hash_mask) {
-	if (input.Count() == 0) {
-		return;
-	}
-	auto &allocator = input.GetAllocator();
-
-	vector<BoundOrderByNode> orders;
-	// we sort by both 1) partition by expression list and 2) order by expressions
-	for (idx_t prt_idx = 0; prt_idx < wexpr->partitions.size(); prt_idx++) {
-		if (wexpr->partitions_stats.empty() || !wexpr->partitions_stats[prt_idx]) {
-			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, wexpr->partitions[prt_idx]->Copy(),
-			                    nullptr);
-		} else {
-			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, wexpr->partitions[prt_idx]->Copy(),
-			                    wexpr->partitions_stats[prt_idx]->Copy());
-		}
-	}
-	for (const auto &order : wexpr->orders) {
-		orders.push_back(order.Copy());
-	}
-
-	// fuse input and sort collection into one
-	// (sorting columns are not decoded, and we need them later)
-	auto payload_types = input.Types();
-	payload_types.insert(payload_types.end(), over.Types().begin(), over.Types().end());
-	DataChunk payload_chunk;
-	payload_chunk.InitializeEmpty(payload_types);
-
-	// initialise partitioning memory
-	// to minimise copying, we fill up a chunk and then sink it.
-	SelectionVector sel;
-	DataChunk over_partition;
-	DataChunk payload_partition;
-	if (hashes) {
-		sel.Initialize(STANDARD_VECTOR_SIZE);
-		over_partition.Initialize(allocator, over.Types());
-		payload_partition.Initialize(allocator, payload_types);
-	}
-
-	// initialize row layout for sorting
-	RowLayout payload_layout;
-	payload_layout.Initialize(payload_types);
-
-	// initialize sorting states
-	state.global_sort_state = make_unique<GlobalSortState>(state.buffer_manager, orders, payload_layout);
-	auto &global_sort_state = *state.global_sort_state;
-	LocalSortState local_sort_state;
-	local_sort_state.Initialize(global_sort_state, state.buffer_manager);
-
-	// sink collection chunks into row format
-	const idx_t chunk_count = over.ChunkCount();
-	for (idx_t i = 0; i < chunk_count; i++) {
-		auto &input_chunk = *input.Chunks()[i];
-		for (idx_t col_idx = 0; col_idx < input_chunk.ColumnCount(); ++col_idx) {
-			payload_chunk.data[col_idx].Reference(input_chunk.data[col_idx]);
-		}
-		auto &over_chunk = *over.Chunks()[i];
-		for (idx_t col_idx = 0; col_idx < over_chunk.ColumnCount(); ++col_idx) {
-			payload_chunk.data[input_chunk.ColumnCount() + col_idx].Reference(over_chunk.data[col_idx]);
-		}
-		payload_chunk.SetCardinality(input_chunk);
-
-		// Extract the hash partition, if any
-		if (hashes) {
-			auto &hash_chunk = *hashes->Chunks()[i];
-			auto hash_size = hash_chunk.size();
-			auto hash_data = FlatVector::GetData<hash_t>(hash_chunk.data[0]);
-			idx_t bin_size = 0;
-			for (idx_t i = 0; i < hash_size; ++i) {
-				if ((hash_data[i] & hash_mask) == hash_bin) {
-					sel.set_index(bin_size++, i);
-				}
-			}
-
-			// Flush the partition chunks if we would overflow
-			if (over_partition.size() + bin_size > STANDARD_VECTOR_SIZE) {
-				local_sort_state.SinkChunk(over_partition, payload_partition);
-				over_partition.Reset();
-				payload_partition.Reset();
-			}
-
-			// Copy the data for each collection.
-			if (bin_size) {
-				over_partition.Append(over_chunk, false, &sel, bin_size);
-				payload_partition.Append(payload_chunk, false, &sel, bin_size);
-			}
-		} else {
-			local_sort_state.SinkChunk(over_chunk, payload_chunk);
-		}
-	}
-
-	// Flush any ragged partition chunks
-	if (over_partition.size() > 0) {
-		local_sort_state.SinkChunk(over_partition, payload_partition);
-		over_partition.Reset();
-		payload_partition.Reset();
-	}
-
-	// If there are no hashes, release the input to save memory.
-	if (!hashes) {
-		over.Reset();
-		input.Reset();
-	}
-
-	// add local state to global state, which sorts the data
-	global_sort_state.AddLocalState(local_sort_state);
-	// Prepare for merge phase (in this case we never have a merge phase, but this call is still needed)
-	global_sort_state.PrepareMergePhase();
-}
-
-static void ScanSortedPartition(WindowOperatorState &state, ChunkCollection &input,
-                                const vector<LogicalType> &input_types, ChunkCollection &over,
-                                const vector<LogicalType> &over_types) {
-	auto &global_sort_state = *state.global_sort_state;
-
-	auto payload_types = input_types;
-	payload_types.insert(payload_types.end(), over_types.begin(), over_types.end());
-	auto &allocator = input.GetAllocator();
-
-	// scan the sorted row data
-	PayloadScanner scanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
-	for (;;) {
-		DataChunk payload_chunk;
-		payload_chunk.Initialize(allocator, payload_types);
-		payload_chunk.SetCardinality(0);
-		scanner.Scan(payload_chunk);
-		if (payload_chunk.size() == 0) {
-			break;
-		}
-
-		// split into two
-		DataChunk over_chunk;
-		payload_chunk.Split(over_chunk, input_types.size());
-
-		// append back to collection
-		input.Append(payload_chunk);
-		over.Append(over_chunk);
-	}
-}
-
-static void HashChunk(Allocator &allocator, counts_t &counts, DataChunk &hash_chunk, DataChunk &sort_chunk,
-                      const idx_t partition_cols) {
-	const vector<LogicalType> hash_types(1, LogicalType::HASH);
-	hash_chunk.Initialize(allocator, hash_types);
-	hash_chunk.SetCardinality(sort_chunk);
-	auto &hash_vector = hash_chunk.data[0];
-
-	const auto count = sort_chunk.size();
-	VectorOperations::Hash(sort_chunk.data[0], hash_vector, count);
-	for (idx_t prt_idx = 1; prt_idx < partition_cols; ++prt_idx) {
-		VectorOperations::CombineHash(hash_vector, sort_chunk.data[prt_idx], count);
-	}
-
-	const auto partition_mask = hash_t(counts.size() - 1);
-	auto hashes = FlatVector::GetData<hash_t>(hash_vector);
-	if (hash_vector.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		const auto bin = (hashes[0] & partition_mask);
-		counts[bin] += count;
-	} else {
-		for (idx_t i = 0; i < count; ++i) {
-			const auto bin = (hashes[i] & partition_mask);
-			++counts[bin];
-		}
-	}
-}
-
-static void MaterializeOverForWindow(Allocator &allocator, BoundWindowExpression *wexpr, DataChunk &input_chunk,
-                                     DataChunk &over_chunk) {
-	vector<LogicalType> over_types;
-	ExpressionExecutor executor(allocator);
-
-	// we sort by both 1) partition by expression list and 2) order by expressions
-	for (idx_t prt_idx = 0; prt_idx < wexpr->partitions.size(); prt_idx++) {
-		auto &pexpr = wexpr->partitions[prt_idx];
-		over_types.push_back(pexpr->return_type);
-		executor.AddExpression(*pexpr);
-	}
-
-	for (idx_t ord_idx = 0; ord_idx < wexpr->orders.size(); ord_idx++) {
-		auto &oexpr = wexpr->orders[ord_idx].expression;
-		over_types.push_back(oexpr->return_type);
-		executor.AddExpression(*oexpr);
-	}
-
-	D_ASSERT(!over_types.empty());
-
-	over_chunk.Initialize(allocator, over_types);
-	executor.Execute(input_chunk, over_chunk);
-
-	over_chunk.Verify();
-}
-
-static inline bool BoundaryNeedsPeer(const WindowBoundary &boundary) {
-	switch (boundary) {
-	case WindowBoundary::CURRENT_ROW_RANGE:
-	case WindowBoundary::EXPR_PRECEDING_RANGE:
-	case WindowBoundary::EXPR_FOLLOWING_RANGE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-struct WindowBoundariesState {
-	static inline bool IsScalar(const unique_ptr<Expression> &expr) {
-		return expr ? expr->IsScalar() : true;
-	}
-
-	explicit WindowBoundariesState(BoundWindowExpression *wexpr)
-	    : type(wexpr->type), start_boundary(wexpr->start), end_boundary(wexpr->end),
-	      partition_count(wexpr->partitions.size()), order_count(wexpr->orders.size()),
-	      range_sense(wexpr->orders.empty() ? OrderType::INVALID : wexpr->orders[0].type),
-	      scalar_start(IsScalar(wexpr->start_expr)), scalar_end(IsScalar(wexpr->end_expr)),
-	      has_preceding_range(wexpr->start == WindowBoundary::EXPR_PRECEDING_RANGE ||
-	                          wexpr->end == WindowBoundary::EXPR_PRECEDING_RANGE),
-	      has_following_range(wexpr->start == WindowBoundary::EXPR_FOLLOWING_RANGE ||
-	                          wexpr->end == WindowBoundary::EXPR_FOLLOWING_RANGE),
-	      needs_peer(BoundaryNeedsPeer(wexpr->end) || wexpr->type == ExpressionType::WINDOW_CUME_DIST) {
-	}
-
-	// Cached lookups
-	const ExpressionType type;
-	const WindowBoundary start_boundary;
-	const WindowBoundary end_boundary;
-	const idx_t partition_count;
-	const idx_t order_count;
-	const OrderType range_sense;
-	const bool scalar_start;
-	const bool scalar_end;
-	const bool has_preceding_range;
-	const bool has_following_range;
-	const bool needs_peer;
-
-	idx_t partition_start = 0;
-	idx_t partition_end = 0;
-	idx_t peer_start = 0;
-	idx_t peer_end = 0;
-	idx_t valid_start = 0;
-	idx_t valid_end = 0;
-	int64_t window_start = -1;
-	int64_t window_end = -1;
-	bool is_same_partition = false;
-	bool is_peer = false;
-};
-
-static bool WindowNeedsRank(BoundWindowExpression *wexpr) {
-	return wexpr->type == ExpressionType::WINDOW_PERCENT_RANK || wexpr->type == ExpressionType::WINDOW_RANK ||
-	       wexpr->type == ExpressionType::WINDOW_RANK_DENSE || wexpr->type == ExpressionType::WINDOW_CUME_DIST;
-}
-
-template <typename T>
-static T GetCell(ChunkCollection &collection, idx_t column, idx_t index) {
-	D_ASSERT(collection.ColumnCount() > column);
-	auto &chunk = collection.GetChunkForRow(index);
-	auto &source = chunk.data[column];
-	const auto source_offset = index % STANDARD_VECTOR_SIZE;
-	const auto data = FlatVector::GetData<T>(source);
-	return data[source_offset];
-}
-
-static bool CellIsNull(ChunkCollection &collection, idx_t column, idx_t index) {
-	D_ASSERT(collection.ColumnCount() > column);
-	auto &chunk = collection.GetChunkForRow(index);
-	auto &source = chunk.data[column];
-	const auto source_offset = index % STANDARD_VECTOR_SIZE;
-	return FlatVector::IsNull(source, source_offset);
-}
-
-template <typename T>
-struct ChunkCollectionIterator {
-	using iterator = ChunkCollectionIterator<T>;
-	using iterator_category = std::forward_iterator_tag;
-	using difference_type = std::ptrdiff_t;
-	using value_type = T;
-	using reference = T;
-	using pointer = idx_t;
-
-	ChunkCollectionIterator(ChunkCollection &coll_p, idx_t col_no_p, pointer pos_p = 0)
-	    : coll(&coll_p), col_no(col_no_p), pos(pos_p) {
-	}
-
-	inline reference operator*() const {
-		return GetCell<T>(*coll, col_no, pos);
-	}
-	inline explicit operator pointer() const {
-		return pos;
-	}
-
-	inline iterator &operator++() {
-		++pos;
-		return *this;
-	}
-	inline iterator operator++(int) {
-		auto result = *this;
-		++(*this);
-		return result;
-	}
-
-	friend inline bool operator==(const iterator &a, const iterator &b) {
-		return a.pos == b.pos;
-	}
-	friend inline bool operator!=(const iterator &a, const iterator &b) {
-		return a.pos != b.pos;
-	}
-
-private:
-	ChunkCollection *coll;
-	idx_t col_no;
-	pointer pos;
-};
-
-template <typename T, typename OP>
-struct OperationCompare : public std::function<bool(T, T)> {
-	inline bool operator()(const T &lhs, const T &val) const {
-		return OP::template Operation(lhs, val);
-	}
-};
-
-template <typename T, typename OP, bool FROM>
-static idx_t FindTypedRangeBound(ChunkCollection &over, const idx_t order_col, const idx_t order_begin,
-                                 const idx_t order_end, ChunkCollection &boundary, const idx_t boundary_row) {
-	D_ASSERT(!CellIsNull(boundary, 0, boundary_row));
-	const auto val = GetCell<T>(boundary, 0, boundary_row);
-
-	OperationCompare<T, OP> comp;
-	ChunkCollectionIterator<T> begin(over, order_col, order_begin);
-	ChunkCollectionIterator<T> end(over, order_col, order_end);
-	if (FROM) {
-		return idx_t(std::lower_bound(begin, end, val, comp));
-	} else {
-		return idx_t(std::upper_bound(begin, end, val, comp));
-	}
-}
-
-template <typename OP, bool FROM>
-static idx_t FindRangeBound(ChunkCollection &over, const idx_t order_col, const idx_t order_begin,
-                            const idx_t order_end, ChunkCollection &boundary, const idx_t expr_idx) {
-	const auto &over_types = over.Types();
-	D_ASSERT(over_types.size() > order_col);
-	D_ASSERT(boundary.Types().size() == 1);
-	D_ASSERT(boundary.Types()[0] == over_types[order_col]);
-
-	switch (over_types[order_col].InternalType()) {
-	case PhysicalType::INT8:
-		return FindTypedRangeBound<int8_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INT16:
-		return FindTypedRangeBound<int16_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INT32:
-		return FindTypedRangeBound<int32_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INT64:
-		return FindTypedRangeBound<int64_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::UINT8:
-		return FindTypedRangeBound<uint8_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::UINT16:
-		return FindTypedRangeBound<uint16_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::UINT32:
-		return FindTypedRangeBound<uint32_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::UINT64:
-		return FindTypedRangeBound<uint64_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INT128:
-		return FindTypedRangeBound<hugeint_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::FLOAT:
-		return FindTypedRangeBound<float, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::DOUBLE:
-		return FindTypedRangeBound<double, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INTERVAL:
-		return FindTypedRangeBound<interval_t, OP, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	default:
-		throw InternalException("Unsupported column type for RANGE");
-	}
-}
-
-template <bool FROM>
-static idx_t FindOrderedRangeBound(ChunkCollection &over, const idx_t order_col, const OrderType range_sense,
-                                   const idx_t order_begin, const idx_t order_end, ChunkCollection &boundary,
-                                   const idx_t expr_idx) {
-	switch (range_sense) {
-	case OrderType::ASCENDING:
-		return FindRangeBound<LessThan, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	case OrderType::DESCENDING:
-		return FindRangeBound<GreaterThan, FROM>(over, order_col, order_begin, order_end, boundary, expr_idx);
-	default:
-		throw InternalException("Unsupported ORDER BY sense for RANGE");
-	}
-}
-
-static void UpdateWindowBoundaries(WindowBoundariesState &bounds, const idx_t input_size, const idx_t row_idx,
-                                   ChunkCollection &over_collection, ChunkCollection &boundary_start_collection,
-                                   ChunkCollection &boundary_end_collection, const ValidityMask &partition_mask,
-                                   const ValidityMask &order_mask) {
-
-	// RANGE sorting parameters
-	const auto order_col = bounds.partition_count;
-
-	if (bounds.partition_count + bounds.order_count > 0) {
-
-		// determine partition and peer group boundaries to ultimately figure out window size
-		bounds.is_same_partition = !partition_mask.RowIsValidUnsafe(row_idx);
-		bounds.is_peer = !order_mask.RowIsValidUnsafe(row_idx);
-
-		// when the partition changes, recompute the boundaries
-		if (!bounds.is_same_partition) {
-			bounds.partition_start = row_idx;
-			bounds.peer_start = row_idx;
-
-			// find end of partition
-			bounds.partition_end = input_size;
-			if (bounds.partition_count) {
-				idx_t n = 1;
-				bounds.partition_end = FindNextStart(partition_mask, bounds.partition_start + 1, input_size, n);
-			}
-
-			// Find valid ordering values for the new partition
-			// so we can exclude NULLs from RANGE expression computations
-			bounds.valid_start = bounds.partition_start;
-			bounds.valid_end = bounds.partition_end;
-
-			if ((bounds.valid_start < bounds.valid_end) && bounds.has_preceding_range) {
-				// Exclude any leading NULLs
-				if (CellIsNull(over_collection, order_col, bounds.valid_start)) {
-					idx_t n = 1;
-					bounds.valid_start = FindNextStart(order_mask, bounds.valid_start + 1, bounds.valid_end, n);
-				}
-			}
-
-			if ((bounds.valid_start < bounds.valid_end) && bounds.has_following_range) {
-				// Exclude any trailing NULLs
-				if (CellIsNull(over_collection, order_col, bounds.valid_end - 1)) {
-					idx_t n = 1;
-					bounds.valid_end = FindPrevStart(order_mask, bounds.valid_start, bounds.valid_end, n);
-				}
-			}
-
-		} else if (!bounds.is_peer) {
-			bounds.peer_start = row_idx;
-		}
-
-		if (bounds.needs_peer) {
-			bounds.peer_end = bounds.partition_end;
-			if (bounds.order_count) {
-				idx_t n = 1;
-				bounds.peer_end = FindNextStart(order_mask, bounds.peer_start + 1, bounds.partition_end, n);
-			}
-		}
-
-	} else {
-		bounds.is_same_partition = false;
-		bounds.is_peer = true;
-		bounds.partition_end = input_size;
-		bounds.peer_end = bounds.partition_end;
-	}
-
-	// determine window boundaries depending on the type of expression
-	bounds.window_start = -1;
-	bounds.window_end = -1;
-
-	switch (bounds.start_boundary) {
-	case WindowBoundary::UNBOUNDED_PRECEDING:
-		bounds.window_start = bounds.partition_start;
-		break;
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		bounds.window_start = row_idx;
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		bounds.window_start = bounds.peer_start;
-		break;
-	case WindowBoundary::EXPR_PRECEDING_ROWS: {
-		bounds.window_start =
-		    (int64_t)row_idx - GetCell<int64_t>(boundary_start_collection, 0, bounds.scalar_start ? 0 : row_idx);
-		break;
-	}
-	case WindowBoundary::EXPR_FOLLOWING_ROWS: {
-		bounds.window_start =
-		    row_idx + GetCell<int64_t>(boundary_start_collection, 0, bounds.scalar_start ? 0 : row_idx);
-		break;
-	}
-	case WindowBoundary::EXPR_PRECEDING_RANGE: {
-		const auto expr_idx = bounds.scalar_start ? 0 : row_idx;
-		if (CellIsNull(boundary_start_collection, 0, expr_idx)) {
-			bounds.window_start = bounds.peer_start;
-		} else {
-			bounds.window_start =
-			    FindOrderedRangeBound<true>(over_collection, order_col, bounds.range_sense, bounds.valid_start, row_idx,
-			                                boundary_start_collection, expr_idx);
-		}
-		break;
-	}
-	case WindowBoundary::EXPR_FOLLOWING_RANGE: {
-		const auto expr_idx = bounds.scalar_start ? 0 : row_idx;
-		if (CellIsNull(boundary_start_collection, 0, expr_idx)) {
-			bounds.window_start = bounds.peer_start;
-		} else {
-			bounds.window_start = FindOrderedRangeBound<true>(over_collection, order_col, bounds.range_sense, row_idx,
-			                                                  bounds.valid_end, boundary_start_collection, expr_idx);
-		}
-		break;
-	}
-	default:
-		throw InternalException("Unsupported window start boundary");
-	}
-
-	switch (bounds.end_boundary) {
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		bounds.window_end = row_idx + 1;
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		bounds.window_end = bounds.peer_end;
-		break;
-	case WindowBoundary::UNBOUNDED_FOLLOWING:
-		bounds.window_end = bounds.partition_end;
-		break;
-	case WindowBoundary::EXPR_PRECEDING_ROWS:
-		bounds.window_end =
-		    (int64_t)row_idx - GetCell<int64_t>(boundary_end_collection, 0, bounds.scalar_end ? 0 : row_idx) + 1;
-		break;
-	case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		bounds.window_end = row_idx + GetCell<int64_t>(boundary_end_collection, 0, bounds.scalar_end ? 0 : row_idx) + 1;
-		break;
-	case WindowBoundary::EXPR_PRECEDING_RANGE: {
-		const auto expr_idx = bounds.scalar_end ? 0 : row_idx;
-		if (CellIsNull(boundary_end_collection, 0, expr_idx)) {
-			bounds.window_end = bounds.peer_end;
-		} else {
-			bounds.window_end =
-			    FindOrderedRangeBound<false>(over_collection, order_col, bounds.range_sense, bounds.valid_start,
-			                                 row_idx, boundary_end_collection, expr_idx);
-		}
-		break;
-	}
-	case WindowBoundary::EXPR_FOLLOWING_RANGE: {
-		const auto expr_idx = bounds.scalar_end ? 0 : row_idx;
-		if (CellIsNull(boundary_end_collection, 0, expr_idx)) {
-			bounds.window_end = bounds.peer_end;
-		} else {
-			bounds.window_end = FindOrderedRangeBound<false>(over_collection, order_col, bounds.range_sense, row_idx,
-			                                                 bounds.valid_end, boundary_end_collection, expr_idx);
-		}
-		break;
-	}
-	default:
-		throw InternalException("Unsupported window end boundary");
-	}
-
-	// clamp windows to partitions if they should exceed
-	if (bounds.window_start < (int64_t)bounds.partition_start) {
-		bounds.window_start = bounds.partition_start;
-	}
-	if (bounds.window_start > (int64_t)bounds.partition_end) {
-		bounds.window_start = bounds.partition_end;
-	}
-	if (bounds.window_end < (int64_t)bounds.partition_start) {
-		bounds.window_end = bounds.partition_start;
-	}
-	if (bounds.window_end > (int64_t)bounds.partition_end) {
-		bounds.window_end = bounds.partition_end;
-	}
-
-	if (bounds.window_start < 0 || bounds.window_end < 0) {
-		throw InternalException("Failed to compute window boundaries");
-	}
-}
-
-static void ComputeWindowExpression(BoundWindowExpression *wexpr, ChunkCollection &input, ChunkCollection &output,
-                                    ChunkCollection &over, const ValidityMask &partition_mask,
-                                    const ValidityMask &order_mask, WindowAggregationMode mode) {
-
-	// TODO we could evaluate those expressions in parallel
-	auto &allocator = input.GetAllocator();
-	// evaluate inner expressions of window functions, could be more complex
-	ChunkCollection payload_collection(allocator);
-	vector<Expression *> exprs;
-	for (auto &child : wexpr->children) {
-		exprs.push_back(child.get());
-	}
-	// TODO: child may be a scalar, don't need to materialize the whole collection then
-	MaterializeExpressions(exprs.data(), exprs.size(), input, payload_collection);
-
-	ChunkCollection leadlag_offset_collection(allocator);
-	ChunkCollection leadlag_default_collection(allocator);
-	if (wexpr->type == ExpressionType::WINDOW_LEAD || wexpr->type == ExpressionType::WINDOW_LAG) {
-		if (wexpr->offset_expr) {
-			MaterializeExpression(wexpr->offset_expr.get(), input, leadlag_offset_collection,
-			                      wexpr->offset_expr->IsScalar());
-		}
-		if (wexpr->default_expr) {
-			MaterializeExpression(wexpr->default_expr.get(), input, leadlag_default_collection,
-			                      wexpr->default_expr->IsScalar());
-		}
-	}
-
-	// evaluate the FILTER clause and stuff it into a large mask for compactness and reuse
-	ValidityMask filter_mask;
-	vector<validity_t> filter_bits;
-	if (wexpr->filter_expr) {
-		// 	Start with all invalid and set the ones that pass
-		filter_bits.resize(ValidityMask::ValidityMaskSize(input.Count()), 0);
-		filter_mask.Initialize(filter_bits.data());
-		ExpressionExecutor filter_execution(allocator, *wexpr->filter_expr);
-		SelectionVector true_sel(STANDARD_VECTOR_SIZE);
-		idx_t base_idx = 0;
-		for (auto &chunk : input.Chunks()) {
-			const auto filtered = filter_execution.SelectExpression(*chunk, true_sel);
-			for (idx_t f = 0; f < filtered; ++f) {
-				filter_mask.SetValid(base_idx + true_sel[f]);
-			}
-			base_idx += chunk->size();
-		}
-	}
-
-	// evaluate boundaries if present. Parser has checked boundary types.
-	ChunkCollection boundary_start_collection(allocator);
-	if (wexpr->start_expr) {
-		MaterializeExpression(wexpr->start_expr.get(), input, boundary_start_collection, wexpr->start_expr->IsScalar());
-	}
-
-	ChunkCollection boundary_end_collection(allocator);
-	if (wexpr->end_expr) {
-		MaterializeExpression(wexpr->end_expr.get(), input, boundary_end_collection, wexpr->end_expr->IsScalar());
-	}
-
-	// Set up a validity mask for IGNORE NULLS
-	ValidityMask ignore_nulls;
-	if (wexpr->ignore_nulls) {
-		switch (wexpr->type) {
-		case ExpressionType::WINDOW_LEAD:
-		case ExpressionType::WINDOW_LAG:
-		case ExpressionType::WINDOW_FIRST_VALUE:
-		case ExpressionType::WINDOW_LAST_VALUE:
-		case ExpressionType::WINDOW_NTH_VALUE: {
-			idx_t pos = 0;
-			for (auto &chunk : payload_collection.Chunks()) {
-				const auto count = chunk->size();
-				VectorData vdata;
-				chunk->data[0].Orrify(count, vdata);
-				if (!vdata.validity.AllValid()) {
-					//	Lazily materialise the contents when we find the first NULL
-					if (ignore_nulls.AllValid()) {
-						ignore_nulls.Initialize(payload_collection.Count());
-					}
-					// Write to the current position
-					// Chunks in a collection are full, so we don't have to worry about raggedness
-					auto dst = ignore_nulls.GetData() + ignore_nulls.EntryCount(pos);
-					auto src = vdata.validity.GetData();
-					for (auto entry_count = vdata.validity.EntryCount(count); entry_count-- > 0;) {
-						*dst++ = *src++;
-					}
-				}
-				pos += count;
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-
-	// build a segment tree for frame-adhering aggregates
-	// see http://www.vldb.org/pvldb/vol8/p1058-leis.pdf
-	unique_ptr<WindowSegmentTree> segment_tree = nullptr;
-
-	if (wexpr->aggregate) {
-		segment_tree = make_unique<WindowSegmentTree>(*(wexpr->aggregate), wexpr->bind_info.get(), wexpr->return_type,
-		                                              &payload_collection, filter_mask, mode);
-	}
-
-	WindowBoundariesState bounds(wexpr);
-	uint64_t dense_rank = 1, rank_equal = 0, rank = 1;
-
-	// this is the main loop, go through all sorted rows and compute window function result
-	const vector<LogicalType> output_types(1, wexpr->return_type);
-	DataChunk output_chunk;
-	output_chunk.Initialize(allocator, output_types);
-	for (idx_t row_idx = 0; row_idx < input.Count(); row_idx++) {
-		// Grow the chunk if necessary.
-		const auto output_offset = row_idx % STANDARD_VECTOR_SIZE;
-		if (output_offset == 0) {
-			output.Append(output_chunk);
-			output_chunk.Reset();
-			output_chunk.SetCardinality(MinValue(idx_t(STANDARD_VECTOR_SIZE), input.Count() - row_idx));
-		}
-		auto &result = output_chunk.data[0];
-
-		// special case, OVER (), aggregate over everything
-		UpdateWindowBoundaries(bounds, input.Count(), row_idx, over, boundary_start_collection, boundary_end_collection,
-		                       partition_mask, order_mask);
-		if (WindowNeedsRank(wexpr)) {
-			if (!bounds.is_same_partition || row_idx == 0) { // special case for first row, need to init
-				dense_rank = 1;
-				rank = 1;
-				rank_equal = 0;
-			} else if (!bounds.is_peer) {
-				dense_rank++;
-				rank += rank_equal;
-				rank_equal = 0;
-			}
-			rank_equal++;
-		}
-
-		// if no values are read for window, result is NULL
-		if (bounds.window_start >= bounds.window_end) {
-			FlatVector::SetNull(result, output_offset, true);
-			continue;
-		}
-
-		switch (wexpr->type) {
-		case ExpressionType::WINDOW_AGGREGATE: {
-			segment_tree->Compute(result, output_offset, bounds.window_start, bounds.window_end);
-			break;
-		}
-		case ExpressionType::WINDOW_ROW_NUMBER: {
-			auto rdata = FlatVector::GetData<int64_t>(result);
-			rdata[output_offset] = row_idx - bounds.partition_start + 1;
-			break;
-		}
-		case ExpressionType::WINDOW_RANK_DENSE: {
-			auto rdata = FlatVector::GetData<int64_t>(result);
-			rdata[output_offset] = dense_rank;
-			break;
-		}
-		case ExpressionType::WINDOW_RANK: {
-			auto rdata = FlatVector::GetData<int64_t>(result);
-			rdata[output_offset] = rank;
-			break;
-		}
-		case ExpressionType::WINDOW_PERCENT_RANK: {
-			int64_t denom = (int64_t)bounds.partition_end - bounds.partition_start - 1;
-			double percent_rank = denom > 0 ? ((double)rank - 1) / denom : 0;
-			auto rdata = FlatVector::GetData<double>(result);
-			rdata[output_offset] = percent_rank;
-			break;
-		}
-		case ExpressionType::WINDOW_CUME_DIST: {
-			int64_t denom = (int64_t)bounds.partition_end - bounds.partition_start;
-			double cume_dist = denom > 0 ? ((double)(bounds.peer_end - bounds.partition_start)) / denom : 0;
-			auto rdata = FlatVector::GetData<double>(result);
-			rdata[output_offset] = cume_dist;
-			break;
-		}
-		case ExpressionType::WINDOW_NTILE: {
-			D_ASSERT(payload_collection.ColumnCount() == 1);
-			auto n_param = GetCell<int64_t>(payload_collection, 0, row_idx);
-			// With thanks from SQLite's ntileValueFunc()
-			int64_t n_total = bounds.partition_end - bounds.partition_start;
-			if (n_param > n_total) {
-				// more groups allowed than we have values
-				// map every entry to a unique group
-				n_param = n_total;
-			}
-			int64_t n_size = (n_total / n_param);
-			// find the row idx within the group
-			D_ASSERT(row_idx >= bounds.partition_start);
-			int64_t adjusted_row_idx = row_idx - bounds.partition_start;
-			// now compute the ntile
-			int64_t n_large = n_total - n_param * n_size;
-			int64_t i_small = n_large * (n_size + 1);
-			int64_t result_ntile;
-
-			D_ASSERT((n_large * (n_size + 1) + (n_param - n_large) * n_size) == n_total);
-
-			if (adjusted_row_idx < i_small) {
-				result_ntile = 1 + adjusted_row_idx / (n_size + 1);
-			} else {
-				result_ntile = 1 + n_large + (adjusted_row_idx - i_small) / n_size;
-			}
-			// result has to be between [1, NTILE]
-			D_ASSERT(result_ntile >= 1 && result_ntile <= n_param);
-			auto rdata = FlatVector::GetData<int64_t>(result);
-			rdata[output_offset] = result_ntile;
-			break;
-		}
-		case ExpressionType::WINDOW_LEAD:
-		case ExpressionType::WINDOW_LAG: {
-			int64_t offset = 1;
-			if (wexpr->offset_expr) {
-				offset = GetCell<int64_t>(leadlag_offset_collection, 0, wexpr->offset_expr->IsScalar() ? 0 : row_idx);
-			}
-			int64_t val_idx = (int64_t)row_idx;
-			if (wexpr->type == ExpressionType::WINDOW_LEAD) {
-				val_idx += offset;
-			} else {
-				val_idx -= offset;
-			}
-
-			idx_t delta = 0;
-			if (val_idx < (int64_t)row_idx) {
-				// Count backwards
-				delta = idx_t(row_idx - val_idx);
-				val_idx = FindPrevStart(ignore_nulls, bounds.partition_start, row_idx, delta);
-			} else if (val_idx > (int64_t)row_idx) {
-				delta = idx_t(val_idx - row_idx);
-				val_idx = FindNextStart(ignore_nulls, row_idx + 1, bounds.partition_end, delta);
-			}
-			// else offset is zero, so don't move.
-
-			if (!delta) {
-				payload_collection.CopyCell(0, val_idx, result, output_offset);
-			} else if (wexpr->default_expr) {
-				const auto source_row = wexpr->default_expr->IsScalar() ? 0 : row_idx;
-				leadlag_default_collection.CopyCell(0, source_row, result, output_offset);
-			} else {
-				FlatVector::SetNull(result, output_offset, true);
-			}
-			break;
-		}
-		case ExpressionType::WINDOW_FIRST_VALUE: {
-			idx_t n = 1;
-			const auto first_idx = FindNextStart(ignore_nulls, bounds.window_start, bounds.window_end, n);
-			payload_collection.CopyCell(0, first_idx, result, output_offset);
-			break;
-		}
-		case ExpressionType::WINDOW_LAST_VALUE: {
-			idx_t n = 1;
-			payload_collection.CopyCell(0, FindPrevStart(ignore_nulls, bounds.window_start, bounds.window_end, n),
-			                            result, output_offset);
-			break;
-		}
-		case ExpressionType::WINDOW_NTH_VALUE: {
-			D_ASSERT(payload_collection.ColumnCount() == 2);
-			// Returns value evaluated at the row that is the n'th row of the window frame (counting from 1);
-			// returns NULL if there is no such row.
-			if (CellIsNull(payload_collection, 1, row_idx)) {
-				FlatVector::SetNull(result, output_offset, true);
-			} else {
-				auto n_param = GetCell<int64_t>(payload_collection, 1, row_idx);
-				if (n_param < 1) {
-					FlatVector::SetNull(result, output_offset, true);
-				} else {
-					auto n = idx_t(n_param);
-					const auto nth_index = FindNextStart(ignore_nulls, bounds.window_start, bounds.window_end, n);
-					if (!n) {
-						payload_collection.CopyCell(0, nth_index, result, output_offset);
-					} else {
-						FlatVector::SetNull(result, output_offset, true);
-					}
-				}
-			}
-			break;
-		}
-		default:
-			throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr->type));
-		}
-	}
-
-	// Push the last chunk
-	output.Append(output_chunk);
-}
-
-using WindowExpressions = vector<BoundWindowExpression *>;
-
-static void ComputeWindowExpressions(WindowExpressions &window_exprs, ChunkCollection &input,
-                                     ChunkCollection &window_results, ChunkCollection &over,
-                                     WindowAggregationMode mode) {
-	//	Idempotency
-	if (input.Count() == 0) {
-		return;
-	}
-	//	Pick out a function for the OVER clause
-	auto over_expr = window_exprs[0];
-
-	//	Set bits for the start of each partition
-	vector<validity_t> partition_bits(ValidityMask::EntryCount(input.Count()), 0);
-	ValidityMask partition_mask(partition_bits.data());
-	partition_mask.SetValid(0);
-
-	for (idx_t c = 0; c < over_expr->partitions.size(); ++c) {
-		MaskColumn(partition_mask, over, c);
-	}
-
-	//	Set bits for the start of each peer group.
-	//	Partitions also break peer groups, so start with the partition bits.
-	const auto sort_col_count = over_expr->partitions.size() + over_expr->orders.size();
-	ValidityMask order_mask(partition_mask, input.Count());
-	for (idx_t c = over_expr->partitions.size(); c < sort_col_count; ++c) {
-		MaskColumn(order_mask, over, c);
-	}
-
-	//	Compute the functions columnwise
-	for (idx_t expr_idx = 0; expr_idx < window_exprs.size(); ++expr_idx) {
-		ChunkCollection output(input.GetAllocator());
-		ComputeWindowExpression(window_exprs[expr_idx], input, output, over, partition_mask, order_mask, mode);
-		window_results.Fuse(output);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-static void GeneratePartition(Allocator &allocator, WindowOperatorState &state, WindowGlobalState &gstate,
-                              const idx_t hash_bin) {
-	auto &op = (PhysicalWindow &)gstate.op;
-	WindowExpressions window_exprs;
-	for (idx_t expr_idx = 0; expr_idx < op.select_list.size(); ++expr_idx) {
-		D_ASSERT(op.select_list[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-		auto wexpr = reinterpret_cast<BoundWindowExpression *>(op.select_list[expr_idx].get());
-		window_exprs.emplace_back(wexpr);
-	}
-
-	//	Get rid of any stale data
-	state.chunks.Reset();
-	state.window_results.Reset();
-	state.position = 0;
-	state.global_sort_state = nullptr;
-
-	//	Pick out a function for the OVER clause
-	auto over_expr = window_exprs[0];
-
-	// There are three types of partitions:
-	// 1. No partition (no sorting)
-	// 2. One partition (sorting, but no hashing)
-	// 3. Multiple partitions (sorting and hashing)
-	const auto input_types = gstate.chunks.Types();
-	const auto over_types = gstate.over_collection.Types();
-
-	if (gstate.counts.empty() && hash_bin == 0) {
-		ChunkCollection &input = gstate.chunks;
-		ChunkCollection output(allocator);
-		ChunkCollection &over = gstate.over_collection;
-
-		const auto has_sorting = over_expr->partitions.size() + over_expr->orders.size();
-		if (has_sorting && input.Count() > 0) {
-			// 2. One partition
-			SortCollectionForPartition(state, over_expr, input, over, nullptr, 0, 0);
-
-			// Overwrite the collections with the sorted data
-			ScanSortedPartition(state, input, input_types, over, over_types);
-		}
-
-		ComputeWindowExpressions(window_exprs, input, output, over, gstate.mode);
-		state.chunks.Merge(input);
-		state.window_results.Merge(output);
-
-	} else if (hash_bin < gstate.counts.size() && gstate.counts[hash_bin] > 0) {
-		// 3. Multiple partitions
-		const auto hash_mask = hash_t(gstate.counts.size() - 1);
-		SortCollectionForPartition(state, over_expr, gstate.chunks, gstate.over_collection, &gstate.hash_collection,
-		                           hash_bin, hash_mask);
-
-		// Scan the sorted data into new Collections
-		ChunkCollection input(allocator);
-		ChunkCollection output(allocator);
-		ChunkCollection over(allocator);
-		ScanSortedPartition(state, input, input_types, over, over_types);
-
-		ComputeWindowExpressions(window_exprs, input, output, over, gstate.mode);
-		state.chunks.Merge(input);
-		state.window_results.Merge(output);
-	}
-}
-
-static void Scan(WindowOperatorState &state, DataChunk &chunk) {
-	ChunkCollection &big_data = state.chunks;
-	ChunkCollection &window_results = state.window_results;
-
-	if (state.position >= big_data.Count()) {
-		return;
-	}
-
-	// just return what was computed before, appending the result cols of the window expressions at the end
-	auto &proj_ch = big_data.GetChunkForRow(state.position);
-	auto &wind_ch = window_results.GetChunkForRow(state.position);
-
-	idx_t out_idx = 0;
-	D_ASSERT(proj_ch.size() == wind_ch.size());
-	chunk.SetCardinality(proj_ch);
-	for (idx_t col_idx = 0; col_idx < proj_ch.ColumnCount(); col_idx++) {
-		chunk.data[out_idx++].Reference(proj_ch.data[col_idx]);
-	}
-	for (idx_t col_idx = 0; col_idx < wind_ch.ColumnCount(); col_idx++) {
-		chunk.data[out_idx++].Reference(wind_ch.data[col_idx]);
-	}
-	chunk.Verify();
-
-	state.position += STANDARD_VECTOR_SIZE;
-}
-
-SinkResultType PhysicalWindow::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
-                                    DataChunk &input) const {
-	auto &lstate = (WindowLocalState &)lstate_p;
-	lstate.chunks.Append(input);
-
-	// Compute the over columns and the hash values for this block (if any)
-	const auto over_idx = 0;
-	auto over_expr = reinterpret_cast<BoundWindowExpression *>(select_list[over_idx].get());
-
-	auto &allocator = Allocator::Get(context.client);
-	const auto sort_col_count = over_expr->partitions.size() + over_expr->orders.size();
-	if (sort_col_count > 0) {
-		DataChunk over_chunk;
-		MaterializeOverForWindow(allocator, over_expr, input, over_chunk);
-
-		if (!over_expr->partitions.empty()) {
-			if (lstate.counts.empty()) {
-				lstate.counts.resize(lstate.partition_count, 0);
-			}
-
-			DataChunk hash_chunk;
-			HashChunk(allocator, lstate.counts, hash_chunk, over_chunk, over_expr->partitions.size());
-			lstate.hash_collection.Append(hash_chunk);
-			D_ASSERT(lstate.chunks.Count() == lstate.hash_collection.Count());
-		}
-
-		lstate.over_collection.Append(over_chunk);
-		D_ASSERT(lstate.chunks.Count() == lstate.over_collection.Count());
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalWindow::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &lstate = (WindowLocalState &)lstate_p;
-	if (lstate.chunks.Count() == 0) {
-		return;
-	}
-	auto &gstate = (WindowGlobalState &)gstate_p;
-	lock_guard<mutex> glock(gstate.lock);
-	gstate.chunks.Merge(lstate.chunks);
-	gstate.over_collection.Merge(lstate.over_collection);
-	gstate.hash_collection.Merge(lstate.hash_collection);
-	if (gstate.counts.empty()) {
-		gstate.counts = lstate.counts;
-	} else {
-		D_ASSERT(gstate.counts.size() == lstate.counts.size());
-		for (idx_t i = 0; i < gstate.counts.size(); ++i) {
-			gstate.counts[i] += lstate.counts[i];
-		}
-	}
-}
-
-unique_ptr<LocalSinkState> PhysicalWindow::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<WindowLocalState>(Allocator::Get(context.client), *this);
-}
-
-unique_ptr<GlobalSinkState> PhysicalWindow::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<WindowGlobalState>(Allocator::Get(context), *this, context);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class WindowGlobalSourceState : public GlobalSourceState {
-public:
-	explicit WindowGlobalSourceState(const PhysicalWindow &op) : op(op), next_part(0) {
-	}
-
-	const PhysicalWindow &op;
-	//! The output read position.
-	atomic<idx_t> next_part;
-
-public:
-	idx_t MaxThreads() override {
-		auto &state = (WindowGlobalState &)*op.sink_state;
-
-		// If there is only one partition, we have to process it on one thread.
-		if (state.counts.empty()) {
-			return 1;
-		}
-
-		idx_t max_threads = 0;
-		for (const auto count : state.counts) {
-			if (count > 0) {
-				max_threads++;
-			}
-		}
-
-		return max_threads;
-	}
-};
-
-unique_ptr<LocalSourceState> PhysicalWindow::GetLocalSourceState(ExecutionContext &context,
-                                                                 GlobalSourceState &gstate) const {
-	return make_unique<WindowOperatorState>(Allocator::Get(context.client), *this, context);
-}
-
-unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<WindowGlobalSourceState>(*this);
-}
-
-void PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                             LocalSourceState &lstate_p) const {
-	auto &state = (WindowOperatorState &)lstate_p;
-	auto &global_source = (WindowGlobalSourceState &)gstate_p;
-	auto &gstate = (WindowGlobalState &)*sink_state;
-
-	do {
-		if (state.position >= state.chunks.Count()) {
-			auto hash_bin = global_source.next_part++;
-			for (; hash_bin < state.partitions; hash_bin = global_source.next_part++) {
-				if (gstate.counts[hash_bin] > 0) {
-					break;
-				}
-			}
-			GeneratePartition(Allocator::Get(context.client), state, gstate, hash_bin);
-		}
-		Scan(state, chunk);
-		if (chunk.size() != 0) {
-			return;
-		} else {
-			break;
-		}
-	} while (true);
-	D_ASSERT(chunk.size() == 0);
-}
-
-string PhysicalWindow::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < select_list.size(); i++) {
-		if (i > 0) {
-			result += "\n";
-		}
-		result += select_list[i]->GetName();
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-PhysicalFilter::PhysicalFilter(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                               idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::FILTER, move(types), estimated_cardinality) {
-	D_ASSERT(select_list.size() > 0);
-	if (select_list.size() > 1) {
-		// create a big AND out of the expressions
-		auto conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-		for (auto &expr : select_list) {
-			conjunction->children.push_back(move(expr));
-		}
-		expression = move(conjunction);
-	} else {
-		expression = move(select_list[0]);
-	}
-}
-
-class FilterState : public OperatorState {
-public:
-	explicit FilterState(ExecutionContext &context, Expression &expr)
-	    : executor(Allocator::Get(context.client), expr), sel(STANDARD_VECTOR_SIZE) {
-	}
-
-	ExpressionExecutor executor;
-	SelectionVector sel;
-
-public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &executor, "filter", 0);
-	}
-};
-
-unique_ptr<OperatorState> PhysicalFilter::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<FilterState>(context, *expression);
-}
-
-OperatorResultType PhysicalFilter::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                           GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (FilterState &)state_p;
-	idx_t result_count = state.executor.SelectExpression(input, state.sel);
-	if (result_count == input.size()) {
-		// nothing was filtered: skip adding any selection vectors
-		chunk.Reference(input);
-	} else {
-		chunk.Slice(input, state.sel, result_count);
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-string PhysicalFilter::ParamsToString() const {
-	return expression->GetName();
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-PhysicalBatchCollector::PhysicalBatchCollector(PreparedStatementData &data) : PhysicalResultCollector(data) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class BatchCollectorGlobalState : public GlobalSinkState {
-public:
-	explicit BatchCollectorGlobalState(Allocator &allocator) : data(allocator) {
-	}
-
-	mutex glock;
-	BatchedChunkCollection data;
-	unique_ptr<MaterializedQueryResult> result;
-};
-
-class BatchCollectorLocalState : public LocalSinkState {
-public:
-	explicit BatchCollectorLocalState(Allocator &allocator) : data(allocator) {
-	}
-
-	BatchedChunkCollection data;
-};
-
-SinkResultType PhysicalBatchCollector::Sink(ExecutionContext &context, GlobalSinkState &gstate,
-                                            LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &state = (BatchCollectorLocalState &)lstate_p;
-	state.data.Append(input, state.batch_index);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalBatchCollector::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                     LocalSinkState &lstate_p) const {
-	auto &gstate = (BatchCollectorGlobalState &)gstate_p;
-	auto &state = (BatchCollectorLocalState &)lstate_p;
-
-	lock_guard<mutex> lock(gstate.glock);
-	gstate.data.Merge(state.data);
-}
-
-SinkFinalizeType PhysicalBatchCollector::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  GlobalSinkState &gstate_p) const {
-	auto &gstate = (BatchCollectorGlobalState &)gstate_p;
-	auto result =
-	    make_unique<MaterializedQueryResult>(statement_type, properties, types, names, context.shared_from_this());
-	DataChunk output;
-	output.Initialize(BufferAllocator::Get(context), types);
-
-	BatchedChunkScanState state;
-	gstate.data.InitializeScan(state);
-	while (true) {
-		output.Reset();
-		gstate.data.Scan(state, output);
-		if (output.size() == 0) {
-			break;
-		}
-		result->collection.Append(output);
-	}
-
-	gstate.result = move(result);
-	return SinkFinalizeType::READY;
-}
-
-unique_ptr<LocalSinkState> PhysicalBatchCollector::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<BatchCollectorLocalState>(Allocator::DefaultAllocator());
-}
-
-unique_ptr<GlobalSinkState> PhysicalBatchCollector::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<BatchCollectorGlobalState>(Allocator::DefaultAllocator());
-}
-
-unique_ptr<QueryResult> PhysicalBatchCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = (BatchCollectorGlobalState &)state;
-	D_ASSERT(gstate.result);
-	return move(gstate.result);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-PhysicalExecute::PhysicalExecute(PhysicalOperator *plan)
-    : PhysicalOperator(PhysicalOperatorType::EXECUTE, plan->types, -1), plan(plan) {
-}
-
-vector<PhysicalOperator *> PhysicalExecute::GetChildren() const {
-	return {plan};
-}
-
-void PhysicalExecute::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	// EXECUTE statement: build pipeline on child
-	plan->BuildPipelines(executor, current, state);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class ExplainAnalyzeStateGlobalState : public GlobalSinkState {
-public:
-	string analyzed_plan;
-};
-
-SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                            DataChunk &input) const {
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-SinkFinalizeType PhysicalExplainAnalyze::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  GlobalSinkState &gstate_p) const {
-	auto &gstate = (ExplainAnalyzeStateGlobalState &)gstate_p;
-	auto &profiler = QueryProfiler::Get(context);
-	gstate.analyzed_plan = profiler.ToString();
-	return SinkFinalizeType::READY;
-}
-
-unique_ptr<GlobalSinkState> PhysicalExplainAnalyze::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<ExplainAnalyzeStateGlobalState>();
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class ExplainAnalyzeState : public GlobalSourceState {
-public:
-	ExplainAnalyzeState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalExplainAnalyze::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<ExplainAnalyzeState>();
-}
-
-void PhysicalExplainAnalyze::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &source_state,
-                                     LocalSourceState &lstate) const {
-	auto &state = (ExplainAnalyzeState &)source_state;
-	auto &gstate = (ExplainAnalyzeStateGlobalState &)*sink_state;
-	if (state.finished) {
-		return;
-	}
-	chunk.SetValue(0, 0, Value("analyzed_plan"));
-	chunk.SetValue(1, 0, Value(gstate.analyzed_plan));
-	chunk.SetCardinality(1);
-
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalLimit::PhysicalLimit(vector<LogicalType> types, idx_t limit, idx_t offset,
-                             unique_ptr<Expression> limit_expression, unique_ptr<Expression> offset_expression,
-                             idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::LIMIT, move(types), estimated_cardinality), limit_value(limit),
-      offset_value(offset), limit_expression(move(limit_expression)), offset_expression(move(offset_expression)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class LimitGlobalState : public GlobalSinkState {
-public:
-	explicit LimitGlobalState(Allocator &allocator, const PhysicalLimit &op) : data(allocator) {
-		limit = 0;
-		offset = 0;
-	}
-
-	mutex glock;
-	idx_t limit;
-	idx_t offset;
-	BatchedChunkCollection data;
-};
-
-class LimitLocalState : public LocalSinkState {
-public:
-	explicit LimitLocalState(Allocator &allocator, const PhysicalLimit &op) : current_offset(0), data(allocator) {
-		this->limit = op.limit_expression ? DConstants::INVALID_INDEX : op.limit_value;
-		this->offset = op.offset_expression ? DConstants::INVALID_INDEX : op.offset_value;
-	}
-
-	idx_t current_offset;
-	idx_t limit;
-	idx_t offset;
-	BatchedChunkCollection data;
-};
-
-unique_ptr<GlobalSinkState> PhysicalLimit::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<LimitGlobalState>(Allocator::Get(context), *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalLimit::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<LimitLocalState>(Allocator::Get(context.client), *this);
-}
-
-bool PhysicalLimit::ComputeOffset(ExecutionContext &context, DataChunk &input, idx_t &limit, idx_t &offset,
-                                  idx_t current_offset, idx_t &max_element, Expression *limit_expression,
-                                  Expression *offset_expression) {
-	if (limit != DConstants::INVALID_INDEX && offset != DConstants::INVALID_INDEX) {
-		max_element = limit + offset;
-		if ((limit == 0 || current_offset >= max_element) && !(limit_expression || offset_expression)) {
-			return false;
-		}
-	}
-
-	// get the next chunk from the child
-	if (limit == DConstants::INVALID_INDEX) {
-		limit = 1ULL << 62ULL;
-		Value val = GetDelimiter(context, input, limit_expression);
-		if (!val.IsNull()) {
-			limit = val.GetValue<idx_t>();
-		}
-		if (limit > 1ULL << 62ULL) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", limit, 1ULL << 62ULL);
-		}
-	}
-	if (offset == DConstants::INVALID_INDEX) {
-		offset = 0;
-		Value val = GetDelimiter(context, input, offset_expression);
-		if (!val.IsNull()) {
-			offset = val.GetValue<idx_t>();
-		}
-		if (offset > 1ULL << 62ULL) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset, 1ULL << 62ULL);
-		}
-	}
-	max_element = limit + offset;
-	if (limit == 0 || current_offset >= max_element) {
-		return false;
-	}
-	return true;
-}
-
-SinkResultType PhysicalLimit::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-                                   DataChunk &input) const {
-
-	D_ASSERT(input.size() > 0);
-	auto &state = (LimitLocalState &)lstate;
-	auto &limit = state.limit;
-	auto &offset = state.offset;
-
-	idx_t max_element;
-	if (!ComputeOffset(context, input, limit, offset, state.current_offset, max_element, limit_expression.get(),
-	                   offset_expression.get())) {
-		return SinkResultType::FINISHED;
-	}
-	state.data.Append(input, lstate.batch_index);
-	state.current_offset += input.size();
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalLimit::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (LimitGlobalState &)gstate_p;
-	auto &state = (LimitLocalState &)lstate_p;
-
-	lock_guard<mutex> lock(gstate.glock);
-	gstate.limit = state.limit;
-	gstate.offset = state.offset;
-	gstate.data.Merge(state.data);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class LimitSourceState : public GlobalSourceState {
-public:
-	LimitSourceState() {
-		initialized = false;
-		current_offset = 0;
-	}
-
-	bool initialized;
-	idx_t current_offset;
-	BatchedChunkScanState scan_state;
-};
-
-unique_ptr<GlobalSourceState> PhysicalLimit::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<LimitSourceState>();
-}
-
-void PhysicalLimit::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                            LocalSourceState &lstate) const {
-	auto &gstate = (LimitGlobalState &)*sink_state;
-	auto &state = (LimitSourceState &)gstate_p;
-	while (state.current_offset < gstate.limit + gstate.offset) {
-		if (!state.initialized) {
-			gstate.data.InitializeScan(state.scan_state);
-			state.initialized = true;
-		}
-		gstate.data.Scan(state.scan_state, chunk);
-		if (chunk.size() == 0) {
-			break;
-		}
-		if (HandleOffset(chunk, state.current_offset, gstate.offset, gstate.limit)) {
-			break;
-		}
-	}
-}
-
-bool PhysicalLimit::HandleOffset(DataChunk &input, idx_t &current_offset, idx_t offset, idx_t limit) {
-	idx_t max_element = limit + offset;
-	if (limit == DConstants::INVALID_INDEX) {
-		max_element = DConstants::INVALID_INDEX;
-	}
-	idx_t input_size = input.size();
-	if (current_offset < offset) {
-		// we are not yet at the offset point
-		if (current_offset + input.size() > offset) {
-			// however we will reach it in this chunk
-			// we have to copy part of the chunk with an offset
-			idx_t start_position = offset - current_offset;
-			auto chunk_count = MinValue<idx_t>(limit, input.size() - start_position);
-			SelectionVector sel(STANDARD_VECTOR_SIZE);
-			for (idx_t i = 0; i < chunk_count; i++) {
-				sel.set_index(i, start_position + i);
-			}
-			// set up a slice of the input chunks
-			input.Slice(input, sel, chunk_count);
-		} else {
-			current_offset += input_size;
-			return false;
-		}
-	} else {
-		// have to copy either the entire chunk or part of it
-		idx_t chunk_count;
-		if (current_offset + input.size() >= max_element) {
-			// have to limit the count of the chunk
-			chunk_count = max_element - current_offset;
-		} else {
-			// we copy the entire chunk
-			chunk_count = input.size();
-		}
-		// instead of copying we just change the pointer in the current chunk
-		input.Reference(input);
-		input.SetCardinality(chunk_count);
-	}
-
-	current_offset += input_size;
-	return true;
-}
-
-Value PhysicalLimit::GetDelimiter(ExecutionContext &context, DataChunk &input, Expression *expr) {
-	DataChunk limit_chunk;
-	vector<LogicalType> types {expr->return_type};
-	auto &allocator = Allocator::Get(context.client);
-	limit_chunk.Initialize(allocator, types);
-	ExpressionExecutor limit_executor(allocator, expr);
-	auto input_size = input.size();
-	input.SetCardinality(1);
-	limit_executor.Execute(input, limit_chunk);
-	input.SetCardinality(input_size);
-	auto limit_value = limit_chunk.GetValue(0, 0);
-	return limit_value;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class LimitPercentGlobalState : public GlobalSinkState {
-public:
-	explicit LimitPercentGlobalState(Allocator &allocator, const PhysicalLimitPercent &op)
-	    : current_offset(0), data(allocator) {
-		if (!op.limit_expression) {
-			this->limit_percent = op.limit_percent;
-			is_limit_percent_delimited = true;
-		} else {
-			this->limit_percent = 100.0;
-		}
-
-		if (!op.offset_expression) {
-			this->offset = op.offset_value;
-			is_offset_delimited = true;
-		} else {
-			this->offset = 0;
-		}
-	}
-
-	idx_t current_offset;
-	double limit_percent;
-	idx_t offset;
-	ChunkCollection data;
-
-	bool is_limit_percent_delimited = false;
-	bool is_offset_delimited = false;
-};
-
-unique_ptr<GlobalSinkState> PhysicalLimitPercent::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<LimitPercentGlobalState>(Allocator::Get(context), *this);
-}
-
-SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-                                          DataChunk &input) const {
-	D_ASSERT(input.size() > 0);
-	auto &state = (LimitPercentGlobalState &)gstate;
-	auto &limit_percent = state.limit_percent;
-	auto &offset = state.offset;
-
-	// get the next chunk from the child
-	if (!state.is_limit_percent_delimited) {
-		Value val = PhysicalLimit::GetDelimiter(context, input, limit_expression.get());
-		if (!val.IsNull()) {
-			limit_percent = val.GetValue<double>();
-		}
-		if (limit_percent < 0.0) {
-			throw BinderException("Percentage value(%f) can't be negative", limit_percent);
-		}
-		state.is_limit_percent_delimited = true;
-	}
-	if (!state.is_offset_delimited) {
-		Value val = PhysicalLimit::GetDelimiter(context, input, offset_expression.get());
-		if (!val.IsNull()) {
-			offset = val.GetValue<idx_t>();
-		}
-		if (offset > 1ULL << 62ULL) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset, 1ULL << 62ULL);
-		}
-		state.is_offset_delimited = true;
-	}
-
-	if (!PhysicalLimit::HandleOffset(input, state.current_offset, offset, DConstants::INVALID_INDEX)) {
-		return SinkResultType::NEED_MORE_INPUT;
-	}
-
-	state.data.Append(input);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class LimitPercentOperatorState : public GlobalSourceState {
-public:
-	LimitPercentOperatorState() : chunk_idx(0), limit(DConstants::INVALID_INDEX), current_offset(0) {
-	}
-
-	idx_t chunk_idx;
-	idx_t limit;
-	idx_t current_offset;
-};
-
-unique_ptr<GlobalSourceState> PhysicalLimitPercent::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<LimitPercentOperatorState>();
-}
-
-void PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                   LocalSourceState &lstate) const {
-	auto &gstate = (LimitPercentGlobalState &)*sink_state;
-	auto &state = (LimitPercentOperatorState &)gstate_p;
-	auto &limit_percent = gstate.limit_percent;
-	auto &offset = gstate.offset;
-	auto &limit = state.limit;
-	auto &current_offset = state.current_offset;
-
-	if (gstate.is_limit_percent_delimited && limit == DConstants::INVALID_INDEX) {
-		idx_t count = gstate.data.Count();
-		if (count > 0) {
-			count += offset;
-		}
-		limit = MinValue((idx_t)(limit_percent / 100 * count), count);
-		if (limit == 0) {
-			return;
-		}
-	}
-
-	if (current_offset >= limit || state.chunk_idx >= gstate.data.ChunkCount()) {
-		return;
-	}
-
-	DataChunk &input = gstate.data.GetChunk(state.chunk_idx);
-	state.chunk_idx++;
-	if (PhysicalLimit::HandleOffset(input, current_offset, 0, limit)) {
-		chunk.Reference(input);
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void PhysicalLoad::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                           LocalSourceState &lstate) const {
-	auto &db = DatabaseInstance::GetDatabase(context.client);
-	if (info->load_type == LoadType::INSTALL || info->load_type == LoadType::FORCE_INSTALL) {
-		ExtensionHelper::InstallExtension(db, info->filename, info->load_type == LoadType::FORCE_INSTALL);
-	} else {
-		ExtensionHelper::LoadExternalExtension(db, info->filename);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-PhysicalMaterializedCollector::PhysicalMaterializedCollector(PreparedStatementData &data, bool parallel)
-    : PhysicalResultCollector(data), parallel(parallel) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class MaterializedCollectorGlobalState : public GlobalSinkState {
-public:
-	mutex glock;
-	unique_ptr<MaterializedQueryResult> result;
-};
-
-SinkResultType PhysicalMaterializedCollector::Sink(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                                   LocalSinkState &lstate, DataChunk &input) const {
-	auto &gstate = (MaterializedCollectorGlobalState &)gstate_p;
-	lock_guard<mutex> lock(gstate.glock);
-	gstate.result->collection.Append(input);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<GlobalSinkState> PhysicalMaterializedCollector::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_unique<MaterializedCollectorGlobalState>();
-	state->result =
-	    make_unique<MaterializedQueryResult>(statement_type, properties, types, names, context.shared_from_this());
-	return move(state);
-}
-
-unique_ptr<QueryResult> PhysicalMaterializedCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = (MaterializedCollectorGlobalState &)state;
-	D_ASSERT(gstate.result);
-	return move(gstate.result);
-}
-
-bool PhysicalMaterializedCollector::ParallelSink() const {
-	return parallel;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void PhysicalPragma::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                             LocalSourceState &lstate) const {
-	auto &client = context.client;
-	FunctionParameters parameters {info.parameters, info.named_parameters};
-	function.function(client, parameters);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void PhysicalPrepare::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                              LocalSourceState &lstate) const {
-	auto &client = context.client;
-
-	// store the prepared statement in the context
-	ClientData::Get(client).prepared_statements[name] = prepared;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class SampleGlobalSinkState : public GlobalSinkState {
-public:
-	explicit SampleGlobalSinkState(Allocator &allocator, SampleOptions &options) {
-		if (options.is_percentage) {
-			auto percentage = options.sample_size.GetValue<double>();
-			if (percentage == 0) {
-				return;
-			}
-			sample = make_unique<ReservoirSamplePercentage>(allocator, percentage, options.seed);
-		} else {
-			auto size = options.sample_size.GetValue<int64_t>();
-			if (size == 0) {
-				return;
-			}
-			sample = make_unique<ReservoirSample>(allocator, size, options.seed);
-		}
-	}
-
-	//! The lock for updating the global aggregate state
-	mutex lock;
-	//! The reservoir sample
-	unique_ptr<BlockingSample> sample;
-};
-
-unique_ptr<GlobalSinkState> PhysicalReservoirSample::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<SampleGlobalSinkState>(Allocator::Get(context), *options);
-}
-
-SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                             DataChunk &input) const {
-	auto &gstate = (SampleGlobalSinkState &)state;
-	if (!gstate.sample) {
-		return SinkResultType::FINISHED;
-	}
-	// we implement reservoir sampling without replacement and exponential jumps here
-	// the algorithm is adopted from the paper Weighted random sampling with a reservoir by Pavlos S. Efraimidis et al.
-	// note that the original algorithm is about weighted sampling; this is a simplified approach for uniform sampling
-	lock_guard<mutex> glock(gstate.lock);
-	gstate.sample->AddToReservoir(input);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-void PhysicalReservoirSample::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                      LocalSourceState &lstate) const {
-	auto &sink = (SampleGlobalSinkState &)*this->sink_state;
-	if (!sink.sample) {
-		return;
-	}
-	auto sample_chunk = sink.sample->GetChunk();
-	if (!sample_chunk) {
-		return;
-	}
-	chunk.Move(*sample_chunk);
-}
-
-string PhysicalReservoirSample::ParamsToString() const {
-	return options->sample_size.ToString() + (options->is_percentage ? "%" : " rows");
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalResultCollector::PhysicalResultCollector(PreparedStatementData &data)
-    : PhysicalOperator(PhysicalOperatorType::RESULT_COLLECTOR, {LogicalType::BOOLEAN}, 0),
-      statement_type(data.statement_type), properties(data.properties), plan(data.plan.get()), names(data.names) {
-	this->types = data.types;
-}
-
-unique_ptr<PhysicalResultCollector> PhysicalResultCollector::GetResultCollector(ClientContext &context,
-                                                                                PreparedStatementData &data) {
-	auto &config = DBConfig::GetConfig(context);
-	bool use_materialized_collector = !config.preserve_insertion_order || !data.plan->AllSourcesSupportBatchIndex();
-	if (use_materialized_collector) {
-		// parallel materialized collector only if we don't care about maintaining insertion order
-		return make_unique_base<PhysicalResultCollector, PhysicalMaterializedCollector>(
-		    data, !config.preserve_insertion_order);
-	} else {
-		// we care about maintaining insertion order and the sources all support batch indexes
-		// use a batch collector
-		return make_unique_base<PhysicalResultCollector, PhysicalBatchCollector>(data);
-	}
-}
-
-vector<PhysicalOperator *> PhysicalResultCollector::GetChildren() const {
-	return {plan};
-}
-
-void PhysicalResultCollector::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	// operator is a sink, build a pipeline
-	sink_state.reset();
-
-	// single operator:
-	// the operator becomes the data source of the current pipeline
-	state.SetPipelineSource(current, this);
-	// we create a new pipeline starting from the child
-	D_ASSERT(children.size() == 0);
-	D_ASSERT(plan);
-
-	BuildChildPipeline(executor, current, state, plan);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                          LocalSourceState &lstate) const {
-	auto option = DBConfig::GetOptionByName(name);
-	if (!option) {
-		// check if this is an extra extension variable
-		auto &config = DBConfig::GetConfig(context.client);
-		auto entry = config.extension_parameters.find(name);
-		if (entry == config.extension_parameters.end()) {
-			// it is not!
-			// get a list of all options
-			vector<string> potential_names;
-			for (idx_t i = 0, option_count = DBConfig::GetOptionCount(); i < option_count; i++) {
-				potential_names.emplace_back(DBConfig::GetOptionByIndex(i)->name);
-			}
-			for (auto &entry : config.extension_parameters) {
-				potential_names.push_back(entry.first);
-			}
-
-			throw CatalogException("unrecognized configuration parameter \"%s\"\n%s", name,
-			                       StringUtil::CandidatesErrorMessage(potential_names, name, "Did you mean"));
-		}
-		//! it is!
-		auto &extension_option = entry->second;
-		auto &target_type = extension_option.type;
-		Value target_value = value.CastAs(target_type);
-		if (extension_option.set_function) {
-			extension_option.set_function(context.client, scope, target_value);
-		}
-		if (scope == SetScope::GLOBAL) {
-			config.set_variables[name] = move(target_value);
-		} else {
-			auto &client_config = ClientConfig::GetConfig(context.client);
-			client_config.set_variables[name] = move(target_value);
-		}
-		return;
-	}
-	SetScope variable_scope = scope;
-	if (variable_scope == SetScope::AUTOMATIC) {
-		if (option->set_local) {
-			variable_scope = SetScope::SESSION;
-		} else {
-			D_ASSERT(option->set_global);
-			variable_scope = SetScope::GLOBAL;
-		}
-	}
-
-	Value input = value.CastAs(option->parameter_type);
-	switch (variable_scope) {
-	case SetScope::GLOBAL: {
-		if (!option->set_global) {
-			throw CatalogException("option \"%s\" cannot be set globally", name);
-		}
-		auto &db = DatabaseInstance::GetDatabase(context.client);
-		auto &config = DBConfig::GetConfig(context.client);
-		option->set_global(&db, config, input);
-		break;
-	}
-	case SetScope::SESSION:
-		if (!option->set_local) {
-			throw CatalogException("option \"%s\" cannot be set locally", name);
-		}
-		option->set_local(context.client, input);
-		break;
-	default:
-		throw InternalException("Unsupported SetScope for variable");
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-PhysicalStreamingLimit::PhysicalStreamingLimit(vector<LogicalType> types, idx_t limit, idx_t offset,
-                                               unique_ptr<Expression> limit_expression,
-                                               unique_ptr<Expression> offset_expression, idx_t estimated_cardinality,
-                                               bool parallel)
-    : PhysicalOperator(PhysicalOperatorType::STREAMING_LIMIT, move(types), estimated_cardinality), limit_value(limit),
-      offset_value(offset), limit_expression(move(limit_expression)), offset_expression(move(offset_expression)),
-      parallel(parallel) {
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class StreamingLimitOperatorState : public OperatorState {
-public:
-	explicit StreamingLimitOperatorState(const PhysicalStreamingLimit &op) {
-		this->limit = op.limit_expression ? DConstants::INVALID_INDEX : op.limit_value;
-		this->offset = op.offset_expression ? DConstants::INVALID_INDEX : op.offset_value;
-	}
-
-	idx_t limit;
-	idx_t offset;
-};
-
-class StreamingLimitGlobalState : public GlobalOperatorState {
-public:
-	StreamingLimitGlobalState() : current_offset(0) {
-	}
-
-	std::atomic<idx_t> current_offset;
-};
-
-unique_ptr<OperatorState> PhysicalStreamingLimit::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<StreamingLimitOperatorState>(*this);
-}
-
-unique_ptr<GlobalOperatorState> PhysicalStreamingLimit::GetGlobalOperatorState(ClientContext &context) const {
-	return make_unique<StreamingLimitGlobalState>();
-}
-
-OperatorResultType PhysicalStreamingLimit::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (StreamingLimitGlobalState &)gstate_p;
-	auto &state = (StreamingLimitOperatorState &)state_p;
-	auto &limit = state.limit;
-	auto &offset = state.offset;
-	idx_t current_offset = gstate.current_offset.fetch_add(input.size());
-	idx_t max_element;
-	if (!PhysicalLimit::ComputeOffset(context, input, limit, offset, current_offset, max_element,
-	                                  limit_expression.get(), offset_expression.get())) {
-		return OperatorResultType::FINISHED;
-	}
-	if (PhysicalLimit::HandleOffset(input, current_offset, offset, limit)) {
-		chunk.Reference(input);
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-bool PhysicalStreamingLimit::IsOrderDependent() const {
-	return !parallel;
-}
-
-bool PhysicalStreamingLimit::ParallelOperator() const {
-	return parallel;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-PhysicalStreamingSample::PhysicalStreamingSample(vector<LogicalType> types, SampleMethod method, double percentage,
-                                                 int64_t seed, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::STREAMING_SAMPLE, move(types), estimated_cardinality), method(method),
-      percentage(percentage / 100), seed(seed) {
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class StreamingSampleOperatorState : public OperatorState {
-public:
-	explicit StreamingSampleOperatorState(int64_t seed) : random(seed) {
-	}
-
-	RandomEngine random;
-};
-
-void PhysicalStreamingSample::SystemSample(DataChunk &input, DataChunk &result, OperatorState &state_p) const {
-	// system sampling: we throw one dice per chunk
-	auto &state = (StreamingSampleOperatorState &)state_p;
-	double rand = state.random.NextRandom();
-	if (rand <= percentage) {
-		// rand is smaller than sample_size: output chunk
-		result.Reference(input);
-	}
-}
-
-void PhysicalStreamingSample::BernoulliSample(DataChunk &input, DataChunk &result, OperatorState &state_p) const {
-	// bernoulli sampling: we throw one dice per tuple
-	// then slice the result chunk
-	auto &state = (StreamingSampleOperatorState &)state_p;
-	idx_t result_count = 0;
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < input.size(); i++) {
-		double rand = state.random.NextRandom();
-		if (rand <= percentage) {
-			sel.set_index(result_count++, i);
-		}
-	}
-	if (result_count > 0) {
-		result.Slice(input, sel, result_count);
-	}
-}
-
-unique_ptr<OperatorState> PhysicalStreamingSample::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<StreamingSampleOperatorState>(seed);
-}
-
-OperatorResultType PhysicalStreamingSample::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                    GlobalOperatorState &gstate, OperatorState &state) const {
-	switch (method) {
-	case SampleMethod::BERNOULLI_SAMPLE:
-		BernoulliSample(input, chunk, state);
-		break;
-	case SampleMethod::SYSTEM_SAMPLE:
-		SystemSample(input, chunk, state);
-		break;
-	default:
-		throw InternalException("Unsupported sample method for streaming sample");
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-string PhysicalStreamingSample::ParamsToString() const {
-	return SampleMethodToString(method) + ": " + to_string(100 * percentage) + "%";
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void PhysicalTransaction::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                  LocalSourceState &lstate) const {
-	auto &client = context.client;
-
-	switch (info->type) {
-	case TransactionType::BEGIN_TRANSACTION: {
-		if (client.transaction.IsAutoCommit()) {
-			// start the active transaction
-			// if autocommit is active, we have already called
-			// BeginTransaction by setting autocommit to false we
-			// prevent it from being closed after this query, hence
-			// preserving the transaction context for the next query
-			client.transaction.SetAutoCommit(false);
-		} else {
-			throw TransactionException("cannot start a transaction within a transaction");
-		}
-		break;
-	}
-	case TransactionType::COMMIT: {
-		if (client.transaction.IsAutoCommit()) {
-			throw TransactionException("cannot commit - no transaction is active");
-		} else {
-			// explicitly commit the current transaction
-			client.transaction.Commit();
-		}
-		break;
-	}
-	case TransactionType::ROLLBACK: {
-		if (client.transaction.IsAutoCommit()) {
-			throw TransactionException("cannot rollback - no transaction is active");
-		} else {
-			// explicitly rollback the current transaction
-			client.transaction.Rollback();
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Unrecognized transaction type!");
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void PhysicalVacuum::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	// NOP
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-PerfectHashJoinExecutor::PerfectHashJoinExecutor(const PhysicalHashJoin &join_p, JoinHashTable &ht_p,
-                                                 PerfectHashJoinStats perfect_join_stats)
-    : join(join_p), ht(ht_p), perfect_join_statistics(move(perfect_join_stats)) {
-}
-
-bool PerfectHashJoinExecutor::CanDoPerfectHashJoin() {
-	return perfect_join_statistics.is_build_small;
-}
-
-//===--------------------------------------------------------------------===//
-// Build
-//===--------------------------------------------------------------------===//
-bool PerfectHashJoinExecutor::BuildPerfectHashTable(LogicalType &key_type) {
-	// First, allocate memory for each build column
-	auto build_size = perfect_join_statistics.build_range + 1;
-	for (const auto &type : ht.build_types) {
-		perfect_hash_table.emplace_back(type, build_size);
-	}
-	// and for duplicate_checking
-	bitmap_build_idx = unique_ptr<bool[]>(new bool[build_size]);
-	memset(bitmap_build_idx.get(), 0, sizeof(bool) * build_size); // set false
-
-	// Now fill columns with build data
-	JoinHTScanState join_ht_state;
-	return FullScanHashTable(join_ht_state, key_type);
-}
-
-bool PerfectHashJoinExecutor::FullScanHashTable(JoinHTScanState &state, LogicalType &key_type) {
-	Vector tuples_addresses(LogicalType::POINTER, ht.Count());              // allocate space for all the tuples
-	auto key_locations = FlatVector::GetData<data_ptr_t>(tuples_addresses); // get a pointer to vector data
-	// TODO: In a parallel finalize: One should exclusively lock and each thread should do one part of the code below.
-	// Go through all the blocks and fill the keys addresses
-	auto keys_count = ht.FillWithHTOffsets(key_locations, state);
-	// Scan the build keys in the hash table
-	Vector build_vector(key_type, keys_count);
-	RowOperations::FullScanColumn(ht.layout, tuples_addresses, build_vector, keys_count, 0);
-	// Now fill the selection vector using the build keys and create a sequential vector
-	// todo: add check for fast pass when probe is part of build domain
-	SelectionVector sel_build(keys_count + 1);
-	SelectionVector sel_tuples(keys_count + 1);
-	bool success = FillSelectionVectorSwitchBuild(build_vector, sel_build, sel_tuples, keys_count);
-	// early out
-	if (!success) {
-		return false;
-	}
-	if (unique_keys == perfect_join_statistics.build_range + 1 && !ht.has_null) {
-		perfect_join_statistics.is_build_dense = true;
-	}
-	keys_count = unique_keys; // do not consider keys out of the range
-	// Full scan the remaining build columns and fill the perfect hash table
-	for (idx_t i = 0; i < ht.build_types.size(); i++) {
-		auto build_size = perfect_join_statistics.build_range + 1;
-		auto &vector = perfect_hash_table[i];
-		D_ASSERT(vector.GetType() == ht.build_types[i]);
-		const auto col_no = ht.condition_types.size() + i;
-		const auto col_offset = ht.layout.GetOffsets()[col_no];
-		RowOperations::Gather(tuples_addresses, sel_tuples, vector, sel_build, keys_count, col_offset, col_no,
-		                      build_size);
-	}
-	return true;
-}
-
-bool PerfectHashJoinExecutor::FillSelectionVectorSwitchBuild(Vector &source, SelectionVector &sel_vec,
-                                                             SelectionVector &seq_sel_vec, idx_t count) {
-	switch (source.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		return TemplatedFillSelectionVectorBuild<int8_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::INT16:
-		return TemplatedFillSelectionVectorBuild<int16_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::INT32:
-		return TemplatedFillSelectionVectorBuild<int32_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::INT64:
-		return TemplatedFillSelectionVectorBuild<int64_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT8:
-		return TemplatedFillSelectionVectorBuild<uint8_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT16:
-		return TemplatedFillSelectionVectorBuild<uint16_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT32:
-		return TemplatedFillSelectionVectorBuild<uint32_t>(source, sel_vec, seq_sel_vec, count);
-	case PhysicalType::UINT64:
-		return TemplatedFillSelectionVectorBuild<uint64_t>(source, sel_vec, seq_sel_vec, count);
-	default:
-		throw NotImplementedException("Type not supported for perfect hash join");
-	}
-}
-
-template <typename T>
-bool PerfectHashJoinExecutor::TemplatedFillSelectionVectorBuild(Vector &source, SelectionVector &sel_vec,
-                                                                SelectionVector &seq_sel_vec, idx_t count) {
-	if (perfect_join_statistics.build_min.IsNull() || perfect_join_statistics.build_max.IsNull()) {
-		return false;
-	}
-	auto min_value = perfect_join_statistics.build_min.GetValueUnsafe<T>();
-	auto max_value = perfect_join_statistics.build_max.GetValueUnsafe<T>();
-	VectorData vector_data;
-	source.Orrify(count, vector_data);
-	auto data = reinterpret_cast<T *>(vector_data.data);
-	// generate the selection vector
-	for (idx_t i = 0, sel_idx = 0; i < count; ++i) {
-		auto data_idx = vector_data.sel->get_index(i);
-		auto input_value = data[data_idx];
-		// add index to selection vector if value in the range
-		if (min_value <= input_value && input_value <= max_value) {
-			auto idx = (idx_t)(input_value - min_value); // subtract min value to get the idx position
-			sel_vec.set_index(sel_idx, idx);
-			if (bitmap_build_idx[idx]) {
-				return false;
-			} else {
-				bitmap_build_idx[idx] = true;
-				unique_keys++;
-			}
-			seq_sel_vec.set_index(sel_idx++, i);
-		}
-	}
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Probe
-//===--------------------------------------------------------------------===//
-class PerfectHashJoinState : public OperatorState {
-public:
-	PerfectHashJoinState(Allocator &allocator, const PhysicalHashJoin &join) : probe_executor(allocator) {
-		join_keys.Initialize(allocator, join.condition_types);
-		for (auto &cond : join.conditions) {
-			probe_executor.AddExpression(*cond.left);
-		}
-		build_sel_vec.Initialize(STANDARD_VECTOR_SIZE);
-		probe_sel_vec.Initialize(STANDARD_VECTOR_SIZE);
-		seq_sel_vec.Initialize(STANDARD_VECTOR_SIZE);
-	}
-
-	DataChunk join_keys;
-	ExpressionExecutor probe_executor;
-	SelectionVector build_sel_vec;
-	SelectionVector probe_sel_vec;
-	SelectionVector seq_sel_vec;
-};
-
-unique_ptr<OperatorState> PerfectHashJoinExecutor::GetOperatorState(ExecutionContext &context) {
-	auto state = make_unique<PerfectHashJoinState>(Allocator::Get(context.client), join);
-	return move(state);
-}
-
-OperatorResultType PerfectHashJoinExecutor::ProbePerfectHashTable(ExecutionContext &context, DataChunk &input,
-                                                                  DataChunk &result, OperatorState &state_p) {
-	auto &state = (PerfectHashJoinState &)state_p;
-	// keeps track of how many probe keys have a match
-	idx_t probe_sel_count = 0;
-
-	// fetch the join keys from the chunk
-	state.join_keys.Reset();
-	state.probe_executor.Execute(input, state.join_keys);
-	// select the keys that are in the min-max range
-	auto &keys_vec = state.join_keys.data[0];
-	auto keys_count = state.join_keys.size();
-	// todo: add check for fast pass when probe is part of build domain
-	FillSelectionVectorSwitchProbe(keys_vec, state.build_sel_vec, state.probe_sel_vec, keys_count, probe_sel_count);
-
-	// If build is dense and probe is in build's domain, just reference probe
-	if (perfect_join_statistics.is_build_dense && keys_count == probe_sel_count) {
-		result.Reference(input);
-	} else {
-		// otherwise, filter it out the values that do not match
-		result.Slice(input, state.probe_sel_vec, probe_sel_count, 0);
-	}
-	// on the build side, we need to fetch the data and build dictionary vectors with the sel_vec
-	for (idx_t i = 0; i < ht.build_types.size(); i++) {
-		auto &result_vector = result.data[input.ColumnCount() + i];
-		D_ASSERT(result_vector.GetType() == ht.build_types[i]);
-		auto &build_vec = perfect_hash_table[i];
-		result_vector.Reference(build_vec);
-		result_vector.Slice(state.build_sel_vec, probe_sel_count);
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-void PerfectHashJoinExecutor::FillSelectionVectorSwitchProbe(Vector &source, SelectionVector &build_sel_vec,
-                                                             SelectionVector &probe_sel_vec, idx_t count,
-                                                             idx_t &probe_sel_count) {
-	switch (source.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		TemplatedFillSelectionVectorProbe<int8_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedFillSelectionVectorProbe<int16_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedFillSelectionVectorProbe<int32_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedFillSelectionVectorProbe<int64_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedFillSelectionVectorProbe<uint8_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedFillSelectionVectorProbe<uint16_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedFillSelectionVectorProbe<uint32_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedFillSelectionVectorProbe<uint64_t>(source, build_sel_vec, probe_sel_vec, count, probe_sel_count);
-		break;
-	default:
-		throw NotImplementedException("Type not supported");
-	}
-}
-
-template <typename T>
-void PerfectHashJoinExecutor::TemplatedFillSelectionVectorProbe(Vector &source, SelectionVector &build_sel_vec,
-                                                                SelectionVector &probe_sel_vec, idx_t count,
-                                                                idx_t &probe_sel_count) {
-	auto min_value = perfect_join_statistics.build_min.GetValueUnsafe<T>();
-	auto max_value = perfect_join_statistics.build_max.GetValueUnsafe<T>();
-
-	VectorData vector_data;
-	source.Orrify(count, vector_data);
-	auto data = reinterpret_cast<T *>(vector_data.data);
-	auto validity_mask = &vector_data.validity;
-	// build selection vector for non-dense build
-	if (validity_mask->AllValid()) {
-		for (idx_t i = 0, sel_idx = 0; i < count; ++i) {
-			// retrieve value from vector
-			auto data_idx = vector_data.sel->get_index(i);
-			auto input_value = data[data_idx];
-			// add index to selection vector if value in the range
-			if (min_value <= input_value && input_value <= max_value) {
-				auto idx = (idx_t)(input_value - min_value); // subtract min value to get the idx position
-				                                             // check for matches in the build
-				if (bitmap_build_idx[idx]) {
-					build_sel_vec.set_index(sel_idx, idx);
-					probe_sel_vec.set_index(sel_idx++, i);
-					probe_sel_count++;
-				}
-			}
-		}
-	} else {
-		for (idx_t i = 0, sel_idx = 0; i < count; ++i) {
-			// retrieve value from vector
-			auto data_idx = vector_data.sel->get_index(i);
-			if (!validity_mask->RowIsValid(data_idx)) {
-				continue;
-			}
-			auto input_value = data[data_idx];
-			// add index to selection vector if value in the range
-			if (min_value <= input_value && input_value <= max_value) {
-				auto idx = (idx_t)(input_value - min_value); // subtract min value to get the idx position
-				                                             // check for matches in the build
-				if (bitmap_build_idx[idx]) {
-					build_sel_vec.set_index(sel_idx, idx);
-					probe_sel_vec.set_index(sel_idx++, i);
-					probe_sel_count++;
-				}
-			}
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalBlockwiseNLJoin::PhysicalBlockwiseNLJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                                 unique_ptr<PhysicalOperator> right, unique_ptr<Expression> condition,
-                                                 JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalJoin(op, PhysicalOperatorType::BLOCKWISE_NL_JOIN, join_type, estimated_cardinality),
-      condition(move(condition)) {
-	children.push_back(move(left));
-	children.push_back(move(right));
-	// MARK and SINGLE joins not handled
-	D_ASSERT(join_type != JoinType::MARK);
-	D_ASSERT(join_type != JoinType::SINGLE);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class BlockwiseNLJoinLocalState : public LocalSinkState {
-public:
-	BlockwiseNLJoinLocalState() {
-	}
-};
-
-class BlockwiseNLJoinGlobalState : public GlobalSinkState {
-public:
-	explicit BlockwiseNLJoinGlobalState(Allocator &allocator) : right_chunks(allocator) {
-	}
-
-	mutex lock;
-	ChunkCollection right_chunks;
-	//! Whether or not a tuple on the RHS has found a match, only used for FULL OUTER joins
-	unique_ptr<bool[]> rhs_found_match;
-};
-
-unique_ptr<GlobalSinkState> PhysicalBlockwiseNLJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<BlockwiseNLJoinGlobalState>(Allocator::Get(context));
-}
-
-unique_ptr<LocalSinkState> PhysicalBlockwiseNLJoin::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<BlockwiseNLJoinLocalState>();
-}
-
-SinkResultType PhysicalBlockwiseNLJoin::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                             DataChunk &input) const {
-	auto &gstate = (BlockwiseNLJoinGlobalState &)state;
-	lock_guard<mutex> nl_lock(gstate.lock);
-	gstate.right_chunks.Append(input);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalBlockwiseNLJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                   GlobalSinkState &gstate_p) const {
-	auto &gstate = (BlockwiseNLJoinGlobalState &)gstate_p;
-	if (IsRightOuterJoin(join_type)) {
-		gstate.rhs_found_match = unique_ptr<bool[]>(new bool[gstate.right_chunks.Count()]);
-		memset(gstate.rhs_found_match.get(), 0, sizeof(bool) * gstate.right_chunks.Count());
-	}
-	if (gstate.right_chunks.Count() == 0 && EmptyResultIfRHSIsEmpty()) {
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class BlockwiseNLJoinState : public OperatorState {
-public:
-	explicit BlockwiseNLJoinState(ExecutionContext &context, const PhysicalBlockwiseNLJoin &op)
-	    : left_position(0), right_position(0), executor(Allocator::Get(context.client), *op.condition) {
-		if (IsLeftOuterJoin(op.join_type)) {
-			left_found_match = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
-			memset(left_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-		}
-	}
-
-	//! Whether or not a tuple on the LHS has found a match, only used for LEFT OUTER and FULL OUTER joins
-	unique_ptr<bool[]> left_found_match;
-	idx_t left_position;
-	idx_t right_position;
-	ExpressionExecutor executor;
-};
-
-unique_ptr<OperatorState> PhysicalBlockwiseNLJoin::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<BlockwiseNLJoinState>(context, *this);
-}
-
-OperatorResultType PhysicalBlockwiseNLJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                    GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	D_ASSERT(input.size() > 0);
-	auto &state = (BlockwiseNLJoinState &)state_p;
-	auto &gstate = (BlockwiseNLJoinGlobalState &)*sink_state;
-
-	if (gstate.right_chunks.Count() == 0) {
-		// empty RHS
-		if (!EmptyResultIfRHSIsEmpty()) {
-			PhysicalComparisonJoin::ConstructEmptyJoinResult(join_type, false, input, chunk);
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			return OperatorResultType::FINISHED;
-		}
-	}
-
-	// now perform the actual join
-	// we construct a combined DataChunk by referencing the LHS and the RHS
-	// every step that we do not have output results we shift the vectors of the RHS one up or down
-	// this creates a new "alignment" between the tuples, exhausting all possible O(n^2) combinations
-	// while allowing us to use vectorized execution for every step
-	idx_t result_count = 0;
-	do {
-		if (state.left_position >= input.size()) {
-			// exhausted LHS, have to pull new LHS chunk
-			if (state.left_found_match) {
-				// left join: before we move to the next chunk, see if we need to output any vectors that didn't
-				// have a match found
-				PhysicalJoin::ConstructLeftJoinResult(input, chunk, state.left_found_match.get());
-				memset(state.left_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-			}
-			state.left_position = 0;
-			state.right_position = 0;
-			return OperatorResultType::NEED_MORE_INPUT;
-		}
-		auto &lchunk = input;
-		auto &rchunk = gstate.right_chunks.GetChunk(state.right_position);
-
-		// fill in the current element of the LHS into the chunk
-		D_ASSERT(chunk.ColumnCount() == lchunk.ColumnCount() + rchunk.ColumnCount());
-		for (idx_t i = 0; i < lchunk.ColumnCount(); i++) {
-			ConstantVector::Reference(chunk.data[i], lchunk.data[i], state.left_position, lchunk.size());
-		}
-		// for the RHS we just reference the entire vector
-		for (idx_t i = 0; i < rchunk.ColumnCount(); i++) {
-			chunk.data[lchunk.ColumnCount() + i].Reference(rchunk.data[i]);
-		}
-		chunk.SetCardinality(rchunk.size());
-
-		// now perform the computation
-		SelectionVector match_sel(STANDARD_VECTOR_SIZE);
-		result_count = state.executor.SelectExpression(chunk, match_sel);
-		if (result_count > 0) {
-			// found a match!
-			// set the match flags in the LHS
-			if (state.left_found_match) {
-				state.left_found_match[state.left_position] = true;
-			}
-			// set the match flags in the RHS
-			if (gstate.rhs_found_match) {
-				for (idx_t i = 0; i < result_count; i++) {
-					auto idx = match_sel.get_index(i);
-					gstate.rhs_found_match[state.right_position * STANDARD_VECTOR_SIZE + idx] = true;
-				}
-			}
-			chunk.Slice(match_sel, result_count);
-		} else {
-			// no result: reset the chunk
-			chunk.Reset();
-		}
-		// move to the next tuple on the LHS
-		state.left_position++;
-		if (state.left_position >= input.size()) {
-			// exhausted the current chunk, move to the next RHS chunk
-			state.right_position++;
-			if (state.right_position < gstate.right_chunks.ChunkCount()) {
-				// we still have chunks left! start over on the LHS
-				state.left_position = 0;
-			}
-		}
-	} while (result_count == 0);
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-string PhysicalBlockwiseNLJoin::ParamsToString() const {
-	string extra_info = JoinTypeToString(join_type) + "\n";
-	extra_info += condition->GetName();
-	return extra_info;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class BlockwiseNLJoinScanState : public GlobalSourceState {
-public:
-	explicit BlockwiseNLJoinScanState(const PhysicalBlockwiseNLJoin &op) : op(op), right_outer_position(0) {
-	}
-
-	mutex lock;
-	const PhysicalBlockwiseNLJoin &op;
-	//! The position in the RHS in the final scan of the FULL OUTER JOIN
-	idx_t right_outer_position;
-
-public:
-	idx_t MaxThreads() override {
-		auto &sink = (BlockwiseNLJoinGlobalState &)*op.sink_state;
-		return sink.right_chunks.Count() / (STANDARD_VECTOR_SIZE * 10);
-	}
-};
-
-unique_ptr<GlobalSourceState> PhysicalBlockwiseNLJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<BlockwiseNLJoinScanState>(*this);
-}
-
-void PhysicalBlockwiseNLJoin::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                      LocalSourceState &lstate) const {
-	D_ASSERT(IsRightOuterJoin(join_type));
-	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
-	auto &sink = (BlockwiseNLJoinGlobalState &)*sink_state;
-	auto &state = (BlockwiseNLJoinScanState &)gstate;
-
-	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan the found_match for any chunks we
-	// still need to output
-	lock_guard<mutex> l(state.lock);
-	PhysicalComparisonJoin::ConstructFullOuterJoinResult(sink.rhs_found_match.get(), sink.right_chunks, chunk,
-	                                                     state.right_outer_position);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-PhysicalComparisonJoin::PhysicalComparisonJoin(LogicalOperator &op, PhysicalOperatorType type,
-                                               vector<JoinCondition> conditions_p, JoinType join_type,
-                                               idx_t estimated_cardinality)
-    : PhysicalJoin(op, type, join_type, estimated_cardinality) {
-	conditions.resize(conditions_p.size());
-	// we reorder conditions so the ones with COMPARE_EQUAL occur first
-	idx_t equal_position = 0;
-	idx_t other_position = conditions_p.size() - 1;
-	for (idx_t i = 0; i < conditions_p.size(); i++) {
-		if (conditions_p[i].comparison == ExpressionType::COMPARE_EQUAL ||
-		    conditions_p[i].comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			// COMPARE_EQUAL and COMPARE_NOT_DISTINCT_FROM, move to the start
-			conditions[equal_position++] = std::move(conditions_p[i]);
-		} else {
-			// other expression, move to the end
-			conditions[other_position--] = std::move(conditions_p[i]);
-		}
-	}
-}
-
-string PhysicalComparisonJoin::ParamsToString() const {
-	string extra_info = JoinTypeToString(join_type) + "\n";
-	for (auto &it : conditions) {
-		string op = ExpressionTypeToOperator(it.comparison);
-		extra_info += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n";
-	}
-	return extra_info;
-}
-
-void PhysicalComparisonJoin::ConstructEmptyJoinResult(JoinType join_type, bool has_null, DataChunk &input,
-                                                      DataChunk &result) {
-	// empty hash table, special case
-	if (join_type == JoinType::ANTI) {
-		// anti join with empty hash table, NOP join
-		// return the input
-		D_ASSERT(input.ColumnCount() == result.ColumnCount());
-		result.Reference(input);
-	} else if (join_type == JoinType::MARK) {
-		// MARK join with empty hash table
-		D_ASSERT(join_type == JoinType::MARK);
-		D_ASSERT(result.ColumnCount() == input.ColumnCount() + 1);
-		auto &result_vector = result.data.back();
-		D_ASSERT(result_vector.GetType() == LogicalType::BOOLEAN);
-		// for every data vector, we just reference the child chunk
-		result.SetCardinality(input);
-		for (idx_t i = 0; i < input.ColumnCount(); i++) {
-			result.data[i].Reference(input.data[i]);
-		}
-		// for the MARK vector:
-		// if the HT has no NULL values (i.e. empty result set), return a vector that has false for every input
-		// entry if the HT has NULL values (i.e. result set had values, but all were NULL), return a vector that
-		// has NULL for every input entry
-		if (!has_null) {
-			auto bool_result = FlatVector::GetData<bool>(result_vector);
-			for (idx_t i = 0; i < result.size(); i++) {
-				bool_result[i] = false;
-			}
-		} else {
-			FlatVector::Validity(result_vector).SetAllInvalid(result.size());
-		}
-	} else if (join_type == JoinType::LEFT || join_type == JoinType::OUTER || join_type == JoinType::SINGLE) {
-		// LEFT/FULL OUTER/SINGLE join and build side is empty
-		// for the LHS we reference the data
-		result.SetCardinality(input.size());
-		for (idx_t i = 0; i < input.ColumnCount(); i++) {
-			result.data[i].Reference(input.data[i]);
-		}
-		// for the RHS
-		for (idx_t k = input.ColumnCount(); k < result.ColumnCount(); k++) {
-			result.data[k].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result.data[k], true);
-		}
-	}
-}
-
-void PhysicalComparisonJoin::ConstructFullOuterJoinResult(bool *found_match, ChunkCollection &input, DataChunk &result,
-                                                          idx_t &scan_position) {
-	// fill in NULL values for the LHS
-	SelectionVector rsel(STANDARD_VECTOR_SIZE);
-	while (scan_position < input.Count()) {
-		auto &rhs_chunk = input.GetChunk(scan_position / STANDARD_VECTOR_SIZE);
-		idx_t result_count = 0;
-		// figure out which tuples didn't find a match in the RHS
-		for (idx_t i = 0; i < rhs_chunk.size(); i++) {
-			if (!found_match[scan_position + i]) {
-				rsel.set_index(result_count++, i);
-			}
-		}
-		scan_position += STANDARD_VECTOR_SIZE;
-		if (result_count > 0) {
-			// if there were any tuples that didn't find a match, output them
-			idx_t left_column_count = result.ColumnCount() - input.ColumnCount();
-			for (idx_t i = 0; i < left_column_count; i++) {
-				result.data[i].SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(result.data[i], true);
-			}
-			for (idx_t col_idx = 0; col_idx < rhs_chunk.ColumnCount(); col_idx++) {
-				result.data[left_column_count + col_idx].Slice(rhs_chunk.data[col_idx], rsel, result_count);
-			}
-			result.SetCardinality(result_count);
-			return;
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-PhysicalCrossProduct::PhysicalCrossProduct(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
-                                           unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::CROSS_PRODUCT, move(types), estimated_cardinality) {
-	children.push_back(move(left));
-	children.push_back(move(right));
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class CrossProductGlobalState : public GlobalSinkState {
-public:
-	explicit CrossProductGlobalState(ClientContext &context) : rhs_materialized(BufferAllocator::Get(context)) {
-	}
-
-	ChunkCollection rhs_materialized;
-	mutex rhs_lock;
-};
-
-unique_ptr<GlobalSinkState> PhysicalCrossProduct::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<CrossProductGlobalState>(context);
-}
-
-SinkResultType PhysicalCrossProduct::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
-                                          DataChunk &input) const {
-	auto &sink = (CrossProductGlobalState &)state;
-	lock_guard<mutex> client_guard(sink.rhs_lock);
-	sink.rhs_materialized.Append(input);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class CrossProductOperatorState : public OperatorState {
-public:
-	CrossProductOperatorState() : right_position(0) {
-	}
-
-	idx_t right_position;
-};
-
-unique_ptr<OperatorState> PhysicalCrossProduct::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<CrossProductOperatorState>();
-}
-
-OperatorResultType PhysicalCrossProduct::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                 GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (CrossProductOperatorState &)state_p;
-	auto &sink = (CrossProductGlobalState &)*sink_state;
-	auto &right_collection = sink.rhs_materialized;
-
-	if (sink.rhs_materialized.Count() == 0) {
-		// no RHS: empty result
-		return OperatorResultType::FINISHED;
-	}
-	if (state.right_position >= right_collection.Count()) {
-		// ran out of entries on the RHS
-		// reset the RHS and move to the next chunk on the LHS
-		state.right_position = 0;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-
-	auto &left_chunk = input;
-	// now match the current vector of the left relation with the current row
-	// from the right relation
-	chunk.SetCardinality(left_chunk.size());
-	// create a reference to the vectors of the left column
-	for (idx_t i = 0; i < left_chunk.ColumnCount(); i++) {
-		chunk.data[i].Reference(left_chunk.data[i]);
-	}
-	// duplicate the values on the right side
-	auto &right_chunk = right_collection.GetChunkForRow(state.right_position);
-	auto row_in_chunk = state.right_position % STANDARD_VECTOR_SIZE;
-	for (idx_t i = 0; i < right_collection.ColumnCount(); i++) {
-		ConstantVector::Reference(chunk.data[left_chunk.ColumnCount() + i], right_chunk.data[i], row_in_chunk,
-		                          right_chunk.size());
-	}
-
-	// for the next iteration, move to the next position on the right side
-	state.right_position++;
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalCrossProduct::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	PhysicalJoin::BuildJoinPipelines(executor, current, state, *this);
-}
-
-vector<const PhysicalOperator *> PhysicalCrossProduct::GetSources() const {
-	return children[0]->GetSources();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalDelimJoin::PhysicalDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-                                     vector<PhysicalOperator *> delim_scans, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::DELIM_JOIN, move(types), estimated_cardinality), join(move(original_join)),
-      delim_scans(move(delim_scans)) {
-	D_ASSERT(join->children.size() == 2);
-	// now for the original join
-	// we take its left child, this is the side that we will duplicate eliminate
-	children.push_back(move(join->children[0]));
-
-	// we replace it with a PhysicalChunkCollectionScan, that scans the ChunkCollection that we keep cached
-	// the actual chunk collection to scan will be created in the DelimJoinGlobalState
-	auto cached_chunk_scan = make_unique<PhysicalChunkScan>(children[0]->GetTypes(), PhysicalOperatorType::CHUNK_SCAN,
-	                                                        estimated_cardinality);
-	join->children[0] = move(cached_chunk_scan);
-}
-
-vector<PhysicalOperator *> PhysicalDelimJoin::GetChildren() const {
-	vector<PhysicalOperator *> result;
-	for (auto &child : children) {
-		result.push_back(child.get());
-	}
-	result.push_back(join.get());
-	result.push_back(distinct.get());
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class DelimJoinGlobalState : public GlobalSinkState {
-public:
-	explicit DelimJoinGlobalState(Allocator &allocator, const PhysicalDelimJoin *delim_join) : lhs_data(allocator) {
-		D_ASSERT(delim_join->delim_scans.size() > 0);
-		// set up the delim join chunk to scan in the original join
-		auto &cached_chunk_scan = (PhysicalChunkScan &)*delim_join->join->children[0];
-		cached_chunk_scan.collection = &lhs_data;
-	}
-
-	ChunkCollection lhs_data;
-	mutex lhs_lock;
-
-	void Merge(ChunkCollection &input) {
-		lock_guard<mutex> guard(lhs_lock);
-		lhs_data.Append(input);
-	}
-};
-
-class DelimJoinLocalState : public LocalSinkState {
-public:
-	explicit DelimJoinLocalState(Allocator &allocator) : lhs_data(allocator) {
-	}
-
-	unique_ptr<LocalSinkState> distinct_state;
-	ChunkCollection lhs_data;
-
-	void Append(DataChunk &input) {
-		lhs_data.Append(input);
-	}
-};
-
-unique_ptr<GlobalSinkState> PhysicalDelimJoin::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_unique<DelimJoinGlobalState>(BufferAllocator::Get(context), this);
-	distinct->sink_state = distinct->GetGlobalSinkState(context);
-	if (delim_scans.size() > 1) {
-		PhysicalHashAggregate::SetMultiScan(*distinct->sink_state);
-	}
-	return move(state);
-}
-
-unique_ptr<LocalSinkState> PhysicalDelimJoin::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_unique<DelimJoinLocalState>(Allocator::Get(context.client));
-	state->distinct_state = distinct->GetLocalSinkState(context);
-	return move(state);
-}
-
-SinkResultType PhysicalDelimJoin::Sink(ExecutionContext &context, GlobalSinkState &state_p, LocalSinkState &lstate_p,
-                                       DataChunk &input) const {
-	auto &lstate = (DelimJoinLocalState &)lstate_p;
-	lstate.lhs_data.Append(input);
-	distinct->Sink(context, *distinct->sink_state, *lstate.distinct_state, input);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalDelimJoin::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const {
-	auto &lstate = (DelimJoinLocalState &)lstate_p;
-	auto &gstate = (DelimJoinGlobalState &)state;
-	gstate.Merge(lstate.lhs_data);
-	distinct->Combine(context, *distinct->sink_state, *lstate.distinct_state);
-}
-
-SinkFinalizeType PhysicalDelimJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &client,
-                                             GlobalSinkState &gstate) const {
-	// finalize the distinct HT
-	D_ASSERT(distinct);
-	distinct->Finalize(pipeline, event, client, *distinct->sink_state);
-	return SinkFinalizeType::READY;
-}
-
-string PhysicalDelimJoin::ParamsToString() const {
-	return join->ParamsToString();
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalDelimJoin::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	op_state.reset();
-	sink_state.reset();
-
-	// duplicate eliminated join
-	auto pipeline = make_shared<Pipeline>(executor);
-	state.SetPipelineSink(*pipeline, this);
-	current.AddDependency(pipeline);
-
-	// recurse into the pipeline child
-	children[0]->BuildPipelines(executor, *pipeline, state);
-	if (type == PhysicalOperatorType::DELIM_JOIN) {
-		// recurse into the actual join
-		// any pipelines in there depend on the main pipeline
-		// any scan of the duplicate eliminated data on the RHS depends on this pipeline
-		// we add an entry to the mapping of (PhysicalOperator*) -> (Pipeline*)
-		for (auto &delim_scan : delim_scans) {
-			state.delim_join_dependencies[delim_scan] = pipeline.get();
-		}
-		join->BuildPipelines(executor, current, state);
-	}
-	if (!state.recursive_cte) {
-		// regular pipeline: schedule it
-		state.AddPipeline(executor, move(pipeline));
-	} else {
-		// CTE pipeline! add it to the CTE pipelines
-		auto &cte = (PhysicalRecursiveCTE &)*state.recursive_cte;
-		cte.pipelines.push_back(move(pipeline));
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                   unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                                   const vector<idx_t> &left_projection_map,
-                                   const vector<idx_t> &right_projection_map_p, vector<LogicalType> delim_types,
-                                   idx_t estimated_cardinality, PerfectHashJoinStats perfect_join_stats)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::HASH_JOIN, move(cond), join_type, estimated_cardinality),
-      right_projection_map(right_projection_map_p), delim_types(move(delim_types)),
-      perfect_join_statistics(move(perfect_join_stats)) {
-
-	children.push_back(move(left));
-	children.push_back(move(right));
-
-	D_ASSERT(left_projection_map.empty());
-	for (auto &condition : conditions) {
-		condition_types.push_back(condition.left->return_type);
-	}
-
-	// for ANTI, SEMI and MARK join, we only need to store the keys, so for these the build types are empty
-	if (join_type != JoinType::ANTI && join_type != JoinType::SEMI && join_type != JoinType::MARK) {
-		build_types = LogicalOperator::MapTypes(children[1]->GetTypes(), right_projection_map);
-	}
-}
-
-PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                   unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                                   idx_t estimated_cardinality, PerfectHashJoinStats perfect_join_state)
-    : PhysicalHashJoin(op, move(left), move(right), move(cond), join_type, {}, {}, {}, estimated_cardinality,
-                       std::move(perfect_join_state)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class HashJoinLocalState : public LocalSinkState {
-public:
-	HashJoinLocalState(Allocator &allocator, const PhysicalHashJoin &hj) : build_executor(allocator) {
-		if (!hj.right_projection_map.empty()) {
-			build_chunk.Initialize(allocator, hj.build_types);
-		}
-		for (auto &cond : hj.conditions) {
-			build_executor.AddExpression(*cond.right);
-		}
-		join_keys.Initialize(allocator, hj.condition_types);
-	}
-
-	DataChunk build_chunk;
-	DataChunk join_keys;
-	ExpressionExecutor build_executor;
-};
-
-class HashJoinGlobalState : public GlobalSinkState {
-public:
-	HashJoinGlobalState() {
-	}
-
-	//! The HT used by the join
-	unique_ptr<JoinHashTable> hash_table;
-	//! The perfect hash join executor (if any)
-	unique_ptr<PerfectHashJoinExecutor> perfect_join_executor;
-	//! Whether or not the hash table has been finalized
-	bool finalized = false;
-};
-
-unique_ptr<GlobalSinkState> PhysicalHashJoin::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_unique<HashJoinGlobalState>();
-	state->hash_table =
-	    make_unique<JoinHashTable>(BufferManager::GetBufferManager(context), conditions, build_types, join_type);
-	if (!delim_types.empty() && join_type == JoinType::MARK) {
-		// correlated MARK join
-		if (delim_types.size() + 1 == conditions.size()) {
-			// the correlated MARK join has one more condition than the amount of correlated columns
-			// this is the case in a correlated ANY() expression
-			// in this case we need to keep track of additional entries, namely:
-			// - (1) the total amount of elements per group
-			// - (2) the amount of non-null elements per group
-			// we need these to correctly deal with the cases of either:
-			// - (1) the group being empty [in which case the result is always false, even if the comparison is NULL]
-			// - (2) the group containing a NULL value [in which case FALSE becomes NULL]
-			auto &info = state->hash_table->correlated_mark_join_info;
-
-			vector<LogicalType> payload_types;
-			vector<BoundAggregateExpression *> correlated_aggregates;
-			unique_ptr<BoundAggregateExpression> aggr;
-
-			// jury-rigging the GroupedAggregateHashTable
-			// we need a count_star and a count to get counts with and without NULLs
-			aggr = AggregateFunction::BindAggregateFunction(context, CountStarFun::GetFunction(), {}, nullptr, false);
-			correlated_aggregates.push_back(&*aggr);
-			payload_types.push_back(aggr->return_type);
-			info.correlated_aggregates.push_back(move(aggr));
-
-			auto count_fun = CountFun::GetFunction();
-			vector<unique_ptr<Expression>> children;
-			// this is a dummy but we need it to make the hash table understand whats going on
-			children.push_back(make_unique_base<Expression, BoundReferenceExpression>(count_fun.return_type, 0));
-			aggr = AggregateFunction::BindAggregateFunction(context, count_fun, move(children), nullptr, false);
-			correlated_aggregates.push_back(&*aggr);
-			payload_types.push_back(aggr->return_type);
-			info.correlated_aggregates.push_back(move(aggr));
-
-			auto &allocator = Allocator::Get(context);
-			info.correlated_counts = make_unique<GroupedAggregateHashTable>(
-			    allocator, BufferManager::GetBufferManager(context), delim_types, payload_types, correlated_aggregates);
-			info.correlated_types = delim_types;
-			info.group_chunk.Initialize(allocator, delim_types);
-			info.result_chunk.Initialize(allocator, payload_types);
-		}
-	}
-	// for perfect hash join
-	state->perfect_join_executor =
-	    make_unique<PerfectHashJoinExecutor>(*this, *state->hash_table, perfect_join_statistics);
-	return move(state);
-}
-
-unique_ptr<LocalSinkState> PhysicalHashJoin::GetLocalSinkState(ExecutionContext &context) const {
-	auto &allocator = Allocator::Get(context.client);
-	auto state = make_unique<HashJoinLocalState>(allocator, *this);
-	return move(state);
-}
-
-SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
-                                      DataChunk &input) const {
-	auto &sink = (HashJoinGlobalState &)state;
-	auto &lstate = (HashJoinLocalState &)lstate_p;
-	// resolve the join keys for the right chunk
-	lstate.join_keys.Reset();
-	lstate.build_executor.Execute(input, lstate.join_keys);
-	// TODO: add statement to check for possible per
-	// build the HT
-	if (!right_projection_map.empty()) {
-		// there is a projection map: fill the build chunk with the projected columns
-		lstate.build_chunk.Reset();
-		lstate.build_chunk.SetCardinality(input);
-		for (idx_t i = 0; i < right_projection_map.size(); i++) {
-			lstate.build_chunk.data[i].Reference(input.data[right_projection_map[i]]);
-		}
-		sink.hash_table->Build(lstate.join_keys, lstate.build_chunk);
-	} else if (!build_types.empty()) {
-		// there is not a projected map: place the entire right chunk in the HT
-		sink.hash_table->Build(lstate.join_keys, input);
-	} else {
-		// there are only keys: place an empty chunk in the payload
-		lstate.build_chunk.SetCardinality(input.size());
-		sink.hash_table->Build(lstate.join_keys, lstate.build_chunk);
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalHashJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &state = (HashJoinLocalState &)lstate;
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &state.build_executor, "build_executor", 1);
-	client_profiler.Flush(context.thread.profiler);
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                            GlobalSinkState &gstate) const {
-	auto &sink = (HashJoinGlobalState &)gstate;
-	// check for possible perfect hash table
-	auto use_perfect_hash = sink.perfect_join_executor->CanDoPerfectHashJoin();
-	if (use_perfect_hash) {
-		D_ASSERT(sink.hash_table->equality_types.size() == 1);
-		auto key_type = sink.hash_table->equality_types[0];
-		use_perfect_hash = sink.perfect_join_executor->BuildPerfectHashTable(key_type);
-	}
-	// In case of a large build side or duplicates, use regular hash join
-	if (!use_perfect_hash) {
-		sink.perfect_join_executor.reset();
-		sink.hash_table->Finalize();
-	}
-	sink.finalized = true;
-	if (sink.hash_table->Count() == 0 && EmptyResultIfRHSIsEmpty()) {
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class PhysicalHashJoinState : public OperatorState {
-public:
-	explicit PhysicalHashJoinState(Allocator &allocator) : probe_executor(allocator) {
-	}
-
-	DataChunk join_keys;
-	ExpressionExecutor probe_executor;
-	unique_ptr<JoinHashTable::ScanStructure> scan_structure;
-	unique_ptr<OperatorState> perfect_hash_join_state;
-
-public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &probe_executor, "probe_executor", 0);
-	}
-};
-
-unique_ptr<OperatorState> PhysicalHashJoin::GetOperatorState(ExecutionContext &context) const {
-	auto &allocator = Allocator::Get(context.client);
-	auto &sink = (HashJoinGlobalState &)*sink_state;
-	auto state = make_unique<PhysicalHashJoinState>(allocator);
-	if (sink.perfect_join_executor) {
-		state->perfect_hash_join_state = sink.perfect_join_executor->GetOperatorState(context);
-	} else {
-		state->join_keys.Initialize(allocator, condition_types);
-		for (auto &cond : conditions) {
-			state->probe_executor.AddExpression(*cond.left);
-		}
-	}
-	return move(state);
-}
-
-OperatorResultType PhysicalHashJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                             GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (PhysicalHashJoinState &)state_p;
-	auto &sink = (HashJoinGlobalState &)*sink_state;
-	D_ASSERT(sink.finalized);
-
-	if (sink.hash_table->Count() == 0 && EmptyResultIfRHSIsEmpty()) {
-		return OperatorResultType::FINISHED;
-	}
-	if (sink.perfect_join_executor) {
-		return sink.perfect_join_executor->ProbePerfectHashTable(context, input, chunk, *state.perfect_hash_join_state);
-	}
-
-	if (state.scan_structure) {
-		// still have elements remaining from the previous probe (i.e. we got
-		// >1024 elements in the previous probe)
-		state.scan_structure->Next(state.join_keys, input, chunk);
-		if (chunk.size() > 0) {
-			return OperatorResultType::HAVE_MORE_OUTPUT;
-		}
-		state.scan_structure = nullptr;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-
-	// probe the HT
-	if (sink.hash_table->Count() == 0) {
-		ConstructEmptyJoinResult(sink.hash_table->join_type, sink.hash_table->has_null, input, chunk);
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-	// resolve the join keys for the left chunk
-	state.join_keys.Reset();
-	state.probe_executor.Execute(input, state.join_keys);
-
-	// perform the actual probe
-	state.scan_structure = sink.hash_table->Probe(state.join_keys);
-	state.scan_structure->Next(state.join_keys, input, chunk);
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class HashJoinScanState : public GlobalSourceState {
-public:
-	explicit HashJoinScanState(const PhysicalHashJoin &op) : op(op) {
-	}
-
-	const PhysicalHashJoin &op;
-	//! Only used for FULL OUTER JOIN: scan state of the final scan to find unmatched tuples in the build-side
-	JoinHTScanState ht_scan_state;
-
-	idx_t MaxThreads() override {
-		auto &sink = (HashJoinGlobalState &)*op.sink_state;
-		return sink.hash_table->Count() / (STANDARD_VECTOR_SIZE * 10);
-	}
-};
-
-unique_ptr<GlobalSourceState> PhysicalHashJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<HashJoinScanState>(*this);
-}
-
-void PhysicalHashJoin::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                               LocalSourceState &lstate) const {
-	D_ASSERT(IsRightOuterJoin(join_type));
-	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
-	auto &sink = (HashJoinGlobalState &)*sink_state;
-	auto &state = (HashJoinScanState &)gstate;
-	sink.hash_table->ScanFullOuter(chunk, state.ht_scan_state);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <thread>
-
-namespace duckdb {
-
-PhysicalIEJoin::PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                               unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                               idx_t estimated_cardinality)
-    : PhysicalRangeJoin(op, PhysicalOperatorType::IE_JOIN, move(left), move(right), move(cond), join_type,
-                        estimated_cardinality) {
-
-	// 1. let L1 (resp. L2) be the array of column X (resp. Y)
-	D_ASSERT(conditions.size() >= 2);
-	lhs_orders.resize(2);
-	rhs_orders.resize(2);
-	for (idx_t i = 0; i < 2; ++i) {
-		auto &cond = conditions[i];
-		D_ASSERT(cond.left->return_type == cond.right->return_type);
-		join_key_types.push_back(cond.left->return_type);
-
-		// Convert the conditions to sort orders
-		auto left = cond.left->Copy();
-		auto right = cond.right->Copy();
-		auto sense = OrderType::INVALID;
-
-		// 2. if (op1 ∈ {>, ≥}) sort L1 in descending order
-		// 3. else if (op1 ∈ {<, ≤}) sort L1 in ascending order
-		// 4. if (op2 ∈ {>, ≥}) sort L2 in ascending order
-		// 5. else if (op2 ∈ {<, ≤}) sort L2 in descending order
-		switch (cond.comparison) {
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			sense = i ? OrderType::ASCENDING : OrderType::DESCENDING;
-			break;
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			sense = i ? OrderType::DESCENDING : OrderType::ASCENDING;
-			break;
-		default:
-			throw NotImplementedException("Unimplemented join type for IEJoin");
-		}
-		lhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, move(left)));
-		rhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, move(right)));
-	}
-
-	for (idx_t i = 2; i < conditions.size(); ++i) {
-		auto &cond = conditions[i];
-		D_ASSERT(cond.left->return_type == cond.right->return_type);
-		join_key_types.push_back(cond.left->return_type);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class IEJoinLocalState : public LocalSinkState {
-public:
-	using LocalSortedTable = PhysicalRangeJoin::LocalSortedTable;
-
-	IEJoinLocalState(Allocator &allocator, const PhysicalRangeJoin &op, const idx_t child)
-	    : table(allocator, op, child) {
-	}
-
-	//! The local sort state
-	LocalSortedTable table;
-};
-
-class IEJoinGlobalState : public GlobalSinkState {
-public:
-	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-public:
-	IEJoinGlobalState(ClientContext &context, const PhysicalIEJoin &op) : child(0) {
-		tables.resize(2);
-		RowLayout lhs_layout;
-		lhs_layout.Initialize(op.children[0]->types);
-		vector<BoundOrderByNode> lhs_order;
-		lhs_order.emplace_back(op.lhs_orders[0][0].Copy());
-		tables[0] = make_unique<GlobalSortedTable>(context, lhs_order, lhs_layout);
-
-		RowLayout rhs_layout;
-		rhs_layout.Initialize(op.children[1]->types);
-		vector<BoundOrderByNode> rhs_order;
-		rhs_order.emplace_back(op.rhs_orders[0][0].Copy());
-		tables[1] = make_unique<GlobalSortedTable>(context, rhs_order, rhs_layout);
-	}
-
-	IEJoinGlobalState(IEJoinGlobalState &prev)
-	    : GlobalSinkState(prev), tables(move(prev.tables)), child(prev.child + 1) {
-	}
-
-	void Sink(DataChunk &input, IEJoinLocalState &lstate) {
-		auto &table = *tables[child];
-		auto &global_sort_state = table.global_sort_state;
-		auto &local_sort_state = lstate.table.local_sort_state;
-
-		// Sink the data into the local sort state
-		lstate.table.Sink(input, global_sort_state);
-
-		// When sorting data reaches a certain size, we sort it
-		if (local_sort_state.SizeInBytes() >= table.memory_per_thread) {
-			local_sort_state.Sort(global_sort_state, true);
-		}
-	}
-
-	vector<unique_ptr<GlobalSortedTable>> tables;
-	size_t child;
-};
-
-unique_ptr<GlobalSinkState> PhysicalIEJoin::GetGlobalSinkState(ClientContext &context) const {
-	D_ASSERT(!sink_state);
-	return make_unique<IEJoinGlobalState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalIEJoin::GetLocalSinkState(ExecutionContext &context) const {
-	idx_t sink_child = 0;
-	if (sink_state) {
-		const auto &ie_sink = (IEJoinGlobalState &)*sink_state;
-		sink_child = ie_sink.child;
-	}
-	return make_unique<IEJoinLocalState>(Allocator::Get(context.client), *this, sink_child);
-}
-
-SinkResultType PhysicalIEJoin::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
-                                    DataChunk &input) const {
-	auto &gstate = (IEJoinGlobalState &)gstate_p;
-	auto &lstate = (IEJoinLocalState &)lstate_p;
-
-	gstate.Sink(input, lstate);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalIEJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (IEJoinGlobalState &)gstate_p;
-	auto &lstate = (IEJoinLocalState &)lstate_p;
-	gstate.tables[gstate.child]->Combine(lstate.table);
-	auto &client_profiler = QueryProfiler::Get(context.client);
-
-	context.thread.profiler.Flush(this, &lstate.table.executor, gstate.child ? "rhs_executor" : "lhs_executor", 1);
-	client_profiler.Flush(context.thread.profiler);
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalIEJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                          GlobalSinkState &gstate_p) const {
-	auto &gstate = (IEJoinGlobalState &)gstate_p;
-	auto &table = *gstate.tables[gstate.child];
-	auto &global_sort_state = table.global_sort_state;
-
-	if ((gstate.child == 1 && IsRightOuterJoin(join_type)) || (gstate.child == 0 && IsLeftOuterJoin(join_type))) {
-		// for FULL/LEFT/RIGHT OUTER JOIN, initialize found_match to false for every tuple
-		table.IntializeMatches();
-	}
-	if (gstate.child == 1 && global_sort_state.sorted_blocks.empty() && EmptyResultIfRHSIsEmpty()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Sort the current input child
-	table.Finalize(pipeline, event);
-
-	// Move to the next input child
-	++gstate.child;
-
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-OperatorResultType PhysicalIEJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                           GlobalOperatorState &gstate, OperatorState &state) const {
-	return OperatorResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-struct SBIterator {
-	static int ComparisonValue(ExpressionType comparison) {
-		switch (comparison) {
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_GREATERTHAN:
-			return -1;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			return 0;
-		default:
-			throw InternalException("Unimplemented comparison type for IEJoin!");
-		}
-	}
-
-	explicit SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p = 0)
-	    : sort_layout(gss.sort_layout), block_count(gss.sorted_blocks[0]->radix_sorting_data.size()),
-	      block_capacity(gss.block_capacity), cmp_size(sort_layout.comparison_size), entry_size(sort_layout.entry_size),
-	      all_constant(sort_layout.all_constant), external(gss.external), cmp(ComparisonValue(comparison)),
-	      scan(gss.buffer_manager, gss), block_ptr(nullptr), entry_ptr(nullptr) {
-
-		scan.sb = gss.sorted_blocks[0].get();
-		scan.block_idx = block_count;
-		SetIndex(entry_idx_p);
-	}
-
-	inline idx_t GetIndex() const {
-		return entry_idx;
-	}
-
-	inline void SetIndex(idx_t entry_idx_p) {
-		const auto new_block_idx = entry_idx_p / block_capacity;
-		if (new_block_idx != scan.block_idx) {
-			scan.SetIndices(new_block_idx, 0);
-			if (new_block_idx < block_count) {
-				scan.PinRadix(scan.block_idx);
-				block_ptr = scan.RadixPtr();
-				if (!all_constant) {
-					scan.PinData(*scan.sb->blob_sorting_data);
-				}
-			}
-		}
-
-		scan.entry_idx = entry_idx_p % block_capacity;
-		entry_ptr = block_ptr + scan.entry_idx * entry_size;
-		entry_idx = entry_idx_p;
-	}
-
-	inline SBIterator &operator++() {
-		if (++scan.entry_idx < block_capacity) {
-			entry_ptr += entry_size;
-			++entry_idx;
-		} else {
-			SetIndex(entry_idx + 1);
-		}
-
-		return *this;
-	}
-
-	inline SBIterator &operator--() {
-		if (scan.entry_idx) {
-			--scan.entry_idx;
-			--entry_idx;
-			entry_ptr -= entry_size;
-		} else {
-			SetIndex(entry_idx - 1);
-		}
-
-		return *this;
-	}
-
-	inline bool Compare(const SBIterator &other) const {
-		int comp_res;
-		if (all_constant) {
-			comp_res = FastMemcmp(entry_ptr, other.entry_ptr, cmp_size);
-		} else {
-			comp_res = Comparators::CompareTuple(scan, other.scan, entry_ptr, other.entry_ptr, sort_layout, external);
-		}
-
-		return comp_res <= cmp;
-	}
-
-	// Fixed comparison parameters
-	const SortLayout &sort_layout;
-	const idx_t block_count;
-	const idx_t block_capacity;
-	const size_t cmp_size;
-	const size_t entry_size;
-	const bool all_constant;
-	const bool external;
-	const int cmp;
-
-	// Iteration state
-	SBScanState scan;
-	idx_t entry_idx;
-	data_ptr_t block_ptr;
-	data_ptr_t entry_ptr;
-};
-
-struct IEJoinUnion {
-	using SortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-	static idx_t AppendKey(SortedTable &table, ExpressionExecutor &executor, SortedTable &marked, int64_t increment,
-	                       int64_t base, const idx_t block_idx);
-
-	static void Sort(SortedTable &table) {
-		auto &global_sort_state = table.global_sort_state;
-		global_sort_state.PrepareMergePhase();
-		while (global_sort_state.sorted_blocks.size() > 1) {
-			global_sort_state.InitializeMergeRound();
-			MergeSorter merge_sorter(global_sort_state, global_sort_state.buffer_manager);
-			merge_sorter.PerformInMergeRound();
-			global_sort_state.CompleteMergeRound(true);
-		}
-	}
-
-	template <typename T>
-	static vector<T> ExtractColumn(SortedTable &table, idx_t col_idx) {
-		vector<T> result;
-		result.reserve(table.count);
-
-		auto &gstate = table.global_sort_state;
-		auto &blocks = *gstate.sorted_blocks[0]->payload_data;
-		PayloadScanner scanner(blocks, gstate, false);
-
-		DataChunk payload;
-		payload.Initialize(Allocator::DefaultAllocator(), gstate.payload_layout.GetTypes());
-		for (;;) {
-			scanner.Scan(payload);
-			const auto count = payload.size();
-			if (!count) {
-				break;
-			}
-
-			const auto data_ptr = FlatVector::GetData<T>(payload.data[col_idx]);
-			result.insert(result.end(), data_ptr, data_ptr + count);
-		}
-
-		return result;
-	}
-
-	IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, SortedTable &t1, const idx_t b1, SortedTable &t2,
-	            const idx_t b2);
-
-	idx_t SearchL1(idx_t pos);
-	bool NextRow();
-
-	//! Inverted loop
-	idx_t JoinComplexBlocks(SelectionVector &lsel, SelectionVector &rsel);
-
-	//! L1
-	unique_ptr<SortedTable> l1;
-	//! L2
-	unique_ptr<SortedTable> l2;
-
-	//! Li
-	vector<int64_t> li;
-	//! P
-	vector<idx_t> p;
-
-	//! B
-	vector<validity_t> bit_array;
-	ValidityMask bit_mask;
-
-	//! Bloom Filter
-	static constexpr idx_t BLOOM_CHUNK_BITS = 1024;
-	idx_t bloom_count;
-	vector<validity_t> bloom_array;
-	ValidityMask bloom_filter;
-
-	//! Iteration state
-	idx_t n;
-	idx_t i;
-	idx_t j;
-	unique_ptr<SBIterator> op1;
-	unique_ptr<SBIterator> off1;
-	unique_ptr<SBIterator> op2;
-	unique_ptr<SBIterator> off2;
-	int64_t lrid;
-};
-
-idx_t IEJoinUnion::AppendKey(SortedTable &table, ExpressionExecutor &executor, SortedTable &marked, int64_t increment,
-                             int64_t base, const idx_t block_idx) {
-	LocalSortState local_sort_state;
-	local_sort_state.Initialize(marked.global_sort_state, marked.global_sort_state.buffer_manager);
-
-	// Reading
-	const auto valid = table.count - table.has_null;
-	auto &gstate = table.global_sort_state;
-	PayloadScanner scanner(gstate, block_idx);
-	auto table_idx = block_idx * gstate.block_capacity;
-
-	DataChunk scanned;
-	scanned.Initialize(Allocator::DefaultAllocator(), scanner.GetPayloadTypes());
-
-	// Writing
-	auto types = local_sort_state.sort_layout->logical_types;
-	const idx_t payload_idx = types.size();
-
-	const auto &payload_types = local_sort_state.payload_layout->GetTypes();
-	types.insert(types.end(), payload_types.begin(), payload_types.end());
-	const idx_t rid_idx = types.size() - 1;
-
-	DataChunk keys;
-	DataChunk payload;
-	keys.Initialize(Allocator::DefaultAllocator(), types);
-
-	idx_t inserted = 0;
-	for (auto rid = base; table_idx < valid;) {
-		scanner.Scan(scanned);
-
-		// NULLs are at the end, so stop when we reach them
-		auto scan_count = scanned.size();
-		if (table_idx + scan_count > valid) {
-			scan_count = valid - table_idx;
-			scanned.SetCardinality(scan_count);
-		}
-		if (scan_count == 0) {
-			break;
-		}
-		table_idx += scan_count;
-
-		// Compute the input columns from the payload
-		keys.Reset();
-		keys.Split(payload, rid_idx);
-		executor.Execute(scanned, keys);
-
-		// Mark the rid column
-		payload.data[0].Sequence(rid, increment);
-		payload.SetCardinality(scan_count);
-		keys.Fuse(payload);
-		rid += increment * scan_count;
-
-		// Sort on the sort columns (which will no longer be needed)
-		keys.Split(payload, payload_idx);
-		local_sort_state.SinkChunk(keys, payload);
-		inserted += scan_count;
-		keys.Fuse(payload);
-
-		// Flush when we have enough data
-		if (local_sort_state.SizeInBytes() >= marked.memory_per_thread) {
-			local_sort_state.Sort(marked.global_sort_state, true);
-		}
-	}
-	marked.global_sort_state.AddLocalState(local_sort_state);
-	marked.count += inserted;
-
-	return inserted;
-}
-
-IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, SortedTable &t1, const idx_t b1,
-                         SortedTable &t2, const idx_t b2)
-    : n(0), i(0) {
-	auto &allocator = Allocator::Get(context);
-	// input : query Q with 2 join predicates t1.X op1 t2.X' and t1.Y op2 t2.Y', tables T, T' of sizes m and n resp.
-	// output: a list of tuple pairs (ti , tj)
-	// Note that T/T' are already sorted on X/X' and contain the payload data
-	// We only join the two block numbers and use the sizes of the blocks as the counts
-
-	// 0. Filter out tables with no overlap
-	if (!t1.BlockSize(b1) || !t2.BlockSize(b2)) {
-		return;
-	}
-
-	const auto &cmp1 = op.conditions[0].comparison;
-	SBIterator bounds1(t1.global_sort_state, cmp1);
-	SBIterator bounds2(t2.global_sort_state, cmp1);
-
-	// t1.X[0] op1 t2.X'[-1]
-	bounds1.SetIndex(bounds1.block_capacity * b1);
-	bounds2.SetIndex(bounds2.block_capacity * b2 + t2.BlockSize(b2) - 1);
-	if (!bounds1.Compare(bounds2)) {
-		return;
-	}
-
-	// 1. let L1 (resp. L2) be the array of column X (resp. Y )
-	const auto &order1 = op.lhs_orders[0][0];
-	const auto &order2 = op.lhs_orders[1][0];
-
-	// 2. if (op1 ∈ {>, ≥}) sort L1 in descending order
-	// 3. else if (op1 ∈ {<, ≤}) sort L1 in ascending order
-
-	// For the union algorithm, we make a unified table with the keys and the rids as the payload:
-	//		X/X', Y/Y', R/R'/Li
-	// The first position is the sort key.
-	vector<LogicalType> types;
-	types.emplace_back(order2.expression->return_type);
-	types.emplace_back(LogicalType::BIGINT);
-	RowLayout payload_layout;
-	payload_layout.Initialize(types);
-
-	// Sort on the first expression
-	auto ref = make_unique<BoundReferenceExpression>(order1.expression->return_type, 0);
-	vector<BoundOrderByNode> orders;
-	orders.emplace_back(BoundOrderByNode(order1.type, order1.null_order, move(ref)));
-
-	l1 = make_unique<SortedTable>(context, orders, payload_layout);
-
-	// LHS has positive rids
-	ExpressionExecutor l_executor(allocator);
-	l_executor.AddExpression(*order1.expression);
-	l_executor.AddExpression(*order2.expression);
-	AppendKey(t1, l_executor, *l1, 1, 1, b1);
-
-	// RHS has negative rids
-	ExpressionExecutor r_executor(allocator);
-	r_executor.AddExpression(*op.rhs_orders[0][0].expression);
-	r_executor.AddExpression(*op.rhs_orders[1][0].expression);
-	AppendKey(t2, r_executor, *l1, -1, -1, b2);
-
-	Sort(*l1);
-
-	op1 = make_unique<SBIterator>(l1->global_sort_state, cmp1);
-	off1 = make_unique<SBIterator>(l1->global_sort_state, cmp1);
-
-	// We don't actually need the L1 column, just its sort key, which is in the sort blocks
-	li = ExtractColumn<int64_t>(*l1, types.size() - 1);
-
-	// 4. if (op2 ∈ {>, ≥}) sort L2 in ascending order
-	// 5. else if (op2 ∈ {<, ≤}) sort L2 in descending order
-
-	// We sort on Y/Y' to obtain the sort keys and the permutation array.
-	// For this we just need a two-column table of Y, P
-	types.clear();
-	types.emplace_back(LogicalType::BIGINT);
-	payload_layout.Initialize(types);
-
-	// Sort on the first expression
-	orders.clear();
-	ref = make_unique<BoundReferenceExpression>(order2.expression->return_type, 0);
-	orders.emplace_back(BoundOrderByNode(order2.type, order2.null_order, move(ref)));
-
-	ExpressionExecutor executor(allocator);
-	executor.AddExpression(*orders[0].expression);
-
-	l2 = make_unique<SortedTable>(context, orders, payload_layout);
-	for (idx_t base = 0, block_idx = 0; block_idx < l1->BlockCount(); ++block_idx) {
-		base += AppendKey(*l1, executor, *l2, 1, base, block_idx);
-	}
-
-	Sort(*l2);
-
-	// We don't actually need the L2 column, just its sort key, which is in the sort blocks
-
-	// 6. compute the permutation array P of L2 w.r.t. L1
-	p = ExtractColumn<idx_t>(*l2, types.size() - 1);
-
-	// 7. initialize bit-array B (|B| = n), and set all bits to 0
-	n = l2->count.load();
-	bit_array.resize(ValidityMask::EntryCount(n), 0);
-	bit_mask.Initialize(bit_array.data());
-
-	// Bloom filter
-	bloom_count = (n + (BLOOM_CHUNK_BITS - 1)) / BLOOM_CHUNK_BITS;
-	bloom_array.resize(ValidityMask::EntryCount(bloom_count), 0);
-	bloom_filter.Initialize(bloom_array.data());
-
-	// 11. for(i←1 to n) do
-	const auto &cmp2 = op.conditions[1].comparison;
-	op2 = make_unique<SBIterator>(l2->global_sort_state, cmp2);
-	off2 = make_unique<SBIterator>(l2->global_sort_state, cmp2);
-	i = 0;
-	j = 0;
-	(void)NextRow();
-}
-
-idx_t IEJoinUnion::SearchL1(idx_t pos) {
-	// Perform an exponential search in the appropriate direction
-	op1->SetIndex(pos);
-
-	idx_t step = 1;
-	auto hi = pos;
-	auto lo = pos;
-	if (!op1->cmp) {
-		// Scan left for loose inequality
-		lo -= MinValue(step, lo);
-		step *= 2;
-		off1->SetIndex(lo);
-		while (lo > 0 && op1->Compare(*off1)) {
-			hi = lo;
-			lo -= MinValue(step, lo);
-			step *= 2;
-			off1->SetIndex(lo);
-		}
-	} else {
-		// Scan right for strict inequality
-		hi += MinValue(step, n - hi);
-		step *= 2;
-		off1->SetIndex(hi);
-		while (hi < n && !op1->Compare(*off1)) {
-			lo = hi;
-			hi += MinValue(step, n - hi);
-			step *= 2;
-			off1->SetIndex(hi);
-		}
-	}
-
-	// Binary search the target area
-	while (lo < hi) {
-		const auto mid = lo + (hi - lo) / 2;
-		off1->SetIndex(mid);
-		if (op1->Compare(*off1)) {
-			hi = mid;
-		} else {
-			lo = mid + 1;
-		}
-	}
-
-	off1->SetIndex(lo);
-
-	return lo;
-}
-
-bool IEJoinUnion::NextRow() {
-	for (; i < n; ++i) {
-		// 12. pos ← P[i]
-		auto pos = p[i];
-		lrid = li[pos];
-		if (lrid < 0) {
-			continue;
-		}
-
-		// 16. B[pos] ← 1
-		op2->SetIndex(i);
-		for (; off2->GetIndex() < n; ++(*off2)) {
-			if (!off2->Compare(*op2)) {
-				break;
-			}
-			const auto p2 = p[off2->GetIndex()];
-			if (li[p2] < 0) {
-				// Only mark rhs matches.
-				bit_mask.SetValid(p2);
-				bloom_filter.SetValid(p2 / BLOOM_CHUNK_BITS);
-			}
-		}
-
-		// 9.  if (op1 ∈ {≤,≥} and op2 ∈ {≤,≥}) eqOff = 0
-		// 10. else eqOff = 1
-		// No, because there could be more than one equal value.
-		// Find the leftmost off1 where L1[pos] op1 L1[off1..n]
-		// These are the rows that satisfy the op1 condition
-		// and that is where we should start scanning B from
-		j = SearchL1(pos);
-
-		return true;
-	}
-	return false;
-}
-
-static idx_t NextValid(const ValidityMask &bits, idx_t j, const idx_t n) {
-	if (j >= n) {
-		return n;
-	}
-
-	// We can do a first approximation by checking entries one at a time
-	// which gives 64:1.
-	idx_t entry_idx, idx_in_entry;
-	bits.GetEntryIndex(j, entry_idx, idx_in_entry);
-	auto entry = bits.GetValidityEntry(entry_idx++);
-
-	// Trim the bits before the start position
-	entry &= (ValidityMask::ValidityBuffer::MAX_ENTRY << idx_in_entry);
-
-	// Check the non-ragged entries
-	for (const auto entry_count = bits.EntryCount(n); entry_idx < entry_count; ++entry_idx) {
-		if (entry) {
-			for (; idx_in_entry < bits.BITS_PER_VALUE; ++idx_in_entry, ++j) {
-				if (bits.RowIsValid(entry, idx_in_entry)) {
-					return j;
-				}
-			}
-		} else {
-			j += bits.BITS_PER_VALUE - idx_in_entry;
-		}
-
-		entry = bits.GetValidityEntry(entry_idx);
-		idx_in_entry = 0;
-	}
-
-	// Check the final entry
-	for (; j < n; ++idx_in_entry, ++j) {
-		if (bits.RowIsValid(entry, idx_in_entry)) {
-			return j;
-		}
-	}
-
-	return j;
-}
-
-idx_t IEJoinUnion::JoinComplexBlocks(SelectionVector &lsel, SelectionVector &rsel) {
-	// 8. initialize join result as an empty list for tuple pairs
-	idx_t result_count = 0;
-
-	// 11. for(i←1 to n) do
-	while (i < n) {
-		// 13. for (j ← pos+eqOff to n) do
-		for (;;) {
-			// 14. if B[j] = 1 then
-
-			//	Use the Bloom filter to find candidate blocks
-			while (j < n) {
-				auto bloom_begin = NextValid(bloom_filter, j / BLOOM_CHUNK_BITS, bloom_count) * BLOOM_CHUNK_BITS;
-				auto bloom_end = MinValue<idx_t>(n, bloom_begin + BLOOM_CHUNK_BITS);
-
-				j = MaxValue<idx_t>(j, bloom_begin);
-				j = NextValid(bit_mask, j, bloom_end);
-				if (j < bloom_end) {
-					break;
-				}
-			}
-
-			if (j >= n) {
-				break;
-			}
-
-			// Filter out tuples with the same sign (they come from the same table)
-			const auto rrid = li[j];
-			++j;
-
-			// 15. add tuples w.r.t. (L1[j], L1[i]) to join result
-			if (lrid > 0 && rrid < 0) {
-				lsel.set_index(result_count, sel_t(+lrid - 1));
-				rsel.set_index(result_count, sel_t(-rrid - 1));
-				++result_count;
-				if (result_count == STANDARD_VECTOR_SIZE) {
-					// out of space!
-					return result_count;
-				}
-			}
-		}
-		++i;
-
-		if (!NextRow()) {
-			break;
-		}
-	}
-
-	return result_count;
-}
-
-class IEJoinState : public OperatorState {
-public:
-	explicit IEJoinState(Allocator &allocator, const PhysicalIEJoin &op) : local_left(allocator, op, 0) {};
-
-	IEJoinLocalState local_left;
-};
-
-class IEJoinLocalSourceState : public LocalSourceState {
-public:
-	explicit IEJoinLocalSourceState(Allocator &allocator, const PhysicalIEJoin &op)
-	    : op(op), true_sel(STANDARD_VECTOR_SIZE), left_executor(allocator), right_executor(allocator),
-	      left_matches(nullptr), right_matches(nullptr) {
-
-		if (op.conditions.size() < 3) {
-			return;
-		}
-
-		vector<LogicalType> left_types;
-		vector<LogicalType> right_types;
-		for (idx_t i = 2; i < op.conditions.size(); ++i) {
-			const auto &cond = op.conditions[i];
-
-			left_types.push_back(cond.left->return_type);
-			left_executor.AddExpression(*cond.left);
-
-			right_types.push_back(cond.left->return_type);
-			right_executor.AddExpression(*cond.right);
-		}
-
-		left_keys.Initialize(allocator, left_types);
-		right_keys.Initialize(allocator, right_types);
-	}
-
-	idx_t SelectOuterRows(bool *matches) {
-		idx_t count = 0;
-		for (; outer_idx < outer_count; ++outer_idx) {
-			if (!matches[outer_idx]) {
-				true_sel.set_index(count++, outer_idx);
-				if (count >= STANDARD_VECTOR_SIZE) {
-					break;
-				}
-			}
-		}
-
-		return count;
-	}
-
-	const PhysicalIEJoin &op;
-
-	// Joining
-	unique_ptr<IEJoinUnion> joiner;
-
-	idx_t left_base;
-	idx_t left_block_index;
-
-	idx_t right_base;
-	idx_t right_block_index;
-
-	// Trailing predicates
-	SelectionVector true_sel;
-
-	ExpressionExecutor left_executor;
-	DataChunk left_keys;
-
-	ExpressionExecutor right_executor;
-	DataChunk right_keys;
-
-	// Outer joins
-	idx_t outer_idx;
-	idx_t outer_count;
-	bool *left_matches;
-	bool *right_matches;
-};
-
-void PhysicalIEJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &chunk, LocalSourceState &state_p) const {
-	auto &state = (IEJoinLocalSourceState &)state_p;
-	auto &ie_sink = (IEJoinGlobalState &)*sink_state;
-	auto &left_table = *ie_sink.tables[0];
-	auto &right_table = *ie_sink.tables[1];
-
-	const auto left_cols = children[0]->GetTypes().size();
-	do {
-		SelectionVector lsel(STANDARD_VECTOR_SIZE);
-		SelectionVector rsel(STANDARD_VECTOR_SIZE);
-		auto result_count = state.joiner->JoinComplexBlocks(lsel, rsel);
-		if (result_count == 0) {
-			// exhausted this pair
-			return;
-		}
-
-		// found matches: extract them
-		chunk.Reset();
-		SliceSortedPayload(chunk, left_table.global_sort_state, state.left_block_index, lsel, result_count, 0);
-		SliceSortedPayload(chunk, right_table.global_sort_state, state.right_block_index, rsel, result_count,
-		                   left_cols);
-		chunk.SetCardinality(result_count);
-
-		auto sel = FlatVector::IncrementalSelectionVector();
-		if (conditions.size() > 2) {
-			// If there are more expressions to compute,
-			// split the result chunk into the left and right halves
-			// so we can compute the values for comparison.
-			const auto tail_cols = conditions.size() - 2;
-
-			DataChunk right_chunk;
-			chunk.Split(right_chunk, left_cols);
-			state.left_executor.SetChunk(chunk);
-			state.right_executor.SetChunk(right_chunk);
-
-			auto tail_count = result_count;
-			auto true_sel = &state.true_sel;
-			for (size_t cmp_idx = 0; cmp_idx < tail_cols; ++cmp_idx) {
-				auto &left = state.left_keys.data[cmp_idx];
-				state.left_executor.ExecuteExpression(cmp_idx, left);
-
-				auto &right = state.right_keys.data[cmp_idx];
-				state.right_executor.ExecuteExpression(cmp_idx, right);
-
-				if (tail_count < result_count) {
-					left.Slice(*sel, tail_count);
-					right.Slice(*sel, tail_count);
-				}
-				tail_count = SelectJoinTail(conditions[cmp_idx + 2].comparison, left, right, sel, tail_count, true_sel);
-				sel = true_sel;
-			}
-			chunk.Fuse(right_chunk);
-
-			if (tail_count < result_count) {
-				result_count = tail_count;
-				chunk.Slice(*sel, result_count);
-			}
-		}
-
-		// found matches: mark the found matches if required
-		if (left_table.found_match) {
-			for (idx_t i = 0; i < result_count; i++) {
-				left_table.found_match[state.left_base + lsel[sel->get_index(i)]] = true;
-			}
-		}
-		if (right_table.found_match) {
-			for (idx_t i = 0; i < result_count; i++) {
-				right_table.found_match[state.right_base + rsel[sel->get_index(i)]] = true;
-			}
-		}
-		chunk.Verify();
-	} while (chunk.size() == 0);
-}
-
-class IEJoinGlobalSourceState : public GlobalSourceState {
-public:
-	explicit IEJoinGlobalSourceState(const PhysicalIEJoin &op)
-	    : op(op), initialized(false), next_pair(0), completed(0), left_outers(0), next_left(0), right_outers(0),
-	      next_right(0) {
-	}
-
-	void Initialize(IEJoinGlobalState &sink_state) {
-		lock_guard<mutex> initializing(lock);
-		if (initialized) {
-			return;
-		}
-
-		// Compute the starting row for reach block
-		// (In theory these are all the same size, but you never know...)
-		auto &left_table = *sink_state.tables[0];
-		const auto left_blocks = left_table.BlockCount();
-		idx_t left_base = 0;
-
-		for (size_t lhs = 0; lhs < left_blocks; ++lhs) {
-			left_bases.emplace_back(left_base);
-			left_base += left_table.BlockSize(lhs);
-		}
-
-		auto &right_table = *sink_state.tables[1];
-		const auto right_blocks = right_table.BlockCount();
-		idx_t right_base = 0;
-		for (size_t rhs = 0; rhs < right_blocks; ++rhs) {
-			right_bases.emplace_back(right_base);
-			right_base += right_table.BlockSize(rhs);
-		}
-
-		// Outer join block counts
-		if (left_table.found_match) {
-			left_outers = left_blocks;
-		}
-
-		if (right_table.found_match) {
-			right_outers = right_blocks;
-		}
-
-		// Ready for action
-		initialized = true;
-	}
-
-public:
-	idx_t MaxThreads() override {
-		// We can't leverage any more threads than block pairs.
-		const auto &sink_state = ((IEJoinGlobalState &)*op.sink_state);
-		return sink_state.tables[0]->BlockCount() * sink_state.tables[1]->BlockCount();
-	}
-
-	void GetNextPair(ClientContext &client, IEJoinGlobalState &gstate, IEJoinLocalSourceState &lstate) {
-		auto &left_table = *gstate.tables[0];
-		auto &right_table = *gstate.tables[1];
-
-		const auto left_blocks = left_table.BlockCount();
-		const auto right_blocks = right_table.BlockCount();
-		const auto pair_count = left_blocks * right_blocks;
-
-		// Regular block
-		const auto i = next_pair++;
-		if (i < pair_count) {
-			const auto b1 = i / right_blocks;
-			const auto b2 = i % right_blocks;
-
-			lstate.left_block_index = b1;
-			lstate.left_base = left_bases[b1];
-
-			lstate.right_block_index = b2;
-			lstate.right_base = right_bases[b2];
-
-			lstate.joiner = make_unique<IEJoinUnion>(client, op, left_table, b1, right_table, b2);
-			return;
-		} else {
-			--next_pair;
-		}
-
-		// Outer joins
-		if (!left_outers && !right_outers) {
-			return;
-		}
-
-		// Spin wait for regular blocks to finish(!)
-		while (completed < pair_count) {
-			std::this_thread::yield();
-		}
-
-		// Left outer blocks
-		const auto l = next_left++;
-		if (l < left_outers) {
-			lstate.left_block_index = l;
-			lstate.left_base = left_bases[l];
-
-			lstate.left_matches = left_table.found_match.get() + lstate.left_base;
-			lstate.outer_idx = 0;
-			lstate.outer_count = left_table.BlockSize(l);
-			return;
-		} else {
-			lstate.left_matches = nullptr;
-			--next_left;
-		}
-
-		// Right outer block
-		const auto r = next_right++;
-		if (r < right_outers) {
-			lstate.right_block_index = r;
-			lstate.right_base = right_bases[r];
-
-			lstate.right_matches = right_table.found_match.get() + lstate.right_base;
-			lstate.outer_idx = 0;
-			lstate.outer_count = right_table.BlockSize(r);
-			return;
-		} else {
-			lstate.right_matches = nullptr;
-			--next_right;
-		}
-	}
-
-	void PairCompleted(ClientContext &client, IEJoinGlobalState &gstate, IEJoinLocalSourceState &lstate) {
-		lstate.joiner.reset();
-		++completed;
-		GetNextPair(client, gstate, lstate);
-	}
-
-	const PhysicalIEJoin &op;
-
-	mutex lock;
-	bool initialized;
-
-	// Join queue state
-	std::atomic<size_t> next_pair;
-	std::atomic<size_t> completed;
-
-	// Block base row number
-	vector<idx_t> left_bases;
-	vector<idx_t> right_bases;
-
-	// Outer joins
-	idx_t left_outers;
-	std::atomic<idx_t> next_left;
-
-	idx_t right_outers;
-	std::atomic<idx_t> next_right;
-};
-
-unique_ptr<GlobalSourceState> PhysicalIEJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<IEJoinGlobalSourceState>(*this);
-}
-
-unique_ptr<LocalSourceState> PhysicalIEJoin::GetLocalSourceState(ExecutionContext &context,
-                                                                 GlobalSourceState &gstate) const {
-	return make_unique<IEJoinLocalSourceState>(Allocator::Get(context.client), *this);
-}
-
-void PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &result, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	auto &ie_sink = (IEJoinGlobalState &)*sink_state;
-	auto &ie_gstate = (IEJoinGlobalSourceState &)gstate;
-	auto &ie_lstate = (IEJoinLocalSourceState &)lstate;
-
-	ie_gstate.Initialize(ie_sink);
-
-	if (!ie_lstate.joiner) {
-		ie_gstate.GetNextPair(context.client, ie_sink, ie_lstate);
-	}
-
-	// Process INNER results
-	while (ie_lstate.joiner) {
-		ResolveComplexJoin(context, result, ie_lstate);
-
-		if (result.size()) {
-			return;
-		}
-
-		ie_gstate.PairCompleted(context.client, ie_sink, ie_lstate);
-	}
-
-	// Process LEFT OUTER results
-	const auto left_cols = children[0]->GetTypes().size();
-	while (ie_lstate.left_matches) {
-		const idx_t count = ie_lstate.SelectOuterRows(ie_lstate.left_matches);
-		if (!count) {
-			ie_gstate.GetNextPair(context.client, ie_sink, ie_lstate);
-			continue;
-		}
-
-		SliceSortedPayload(result, ie_sink.tables[0]->global_sort_state, ie_lstate.left_base, ie_lstate.true_sel,
-		                   count);
-
-		// Fill in NULLs to the right
-		for (auto col_idx = left_cols; col_idx < result.ColumnCount(); ++col_idx) {
-			result.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result.data[col_idx], true);
-		}
-
-		result.SetCardinality(count);
-		result.Verify();
-
-		return;
-	}
-
-	// Process RIGHT OUTER results
-	while (ie_lstate.right_matches) {
-		const idx_t count = ie_lstate.SelectOuterRows(ie_lstate.right_matches);
-		if (!count) {
-			ie_gstate.GetNextPair(context.client, ie_sink, ie_lstate);
-			continue;
-		}
-
-		SliceSortedPayload(result, ie_sink.tables[1]->global_sort_state, ie_lstate.right_base, ie_lstate.true_sel,
-		                   count, left_cols);
-
-		// Fill in NULLs to the left
-		for (idx_t col_idx = 0; col_idx < left_cols; ++col_idx) {
-			result.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result.data[col_idx], true);
-		}
-
-		result.SetCardinality(count);
-		result.Verify();
-
-		return;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalIEJoin::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	D_ASSERT(children.size() == 2);
-	if (state.recursive_cte) {
-		throw NotImplementedException("IEJoins are not supported in recursive CTEs yet");
-	}
-
-	// Build the LHS
-	auto lhs_pipeline = make_shared<Pipeline>(executor);
-	state.SetPipelineSink(*lhs_pipeline, this);
-	D_ASSERT(children[0].get());
-	children[0]->BuildPipelines(executor, *lhs_pipeline, state);
-
-	// Build the RHS
-	auto rhs_pipeline = make_shared<Pipeline>(executor);
-	state.SetPipelineSink(*rhs_pipeline, this);
-	D_ASSERT(children[1].get());
-	children[1]->BuildPipelines(executor, *rhs_pipeline, state);
-
-	// RHS => LHS => current
-	current.AddDependency(rhs_pipeline);
-	rhs_pipeline->AddDependency(lhs_pipeline);
-
-	state.AddPipeline(executor, move(lhs_pipeline));
-	state.AddPipeline(executor, move(rhs_pipeline));
-
-	// Now build both and scan
-	state.SetPipelineSource(current, this);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class IndexJoinOperatorState : public OperatorState {
-public:
-	IndexJoinOperatorState(Allocator &allocator, const PhysicalIndexJoin &op) : probe_executor(allocator) {
-		rhs_rows.resize(STANDARD_VECTOR_SIZE);
-		result_sizes.resize(STANDARD_VECTOR_SIZE);
-
-		join_keys.Initialize(allocator, op.condition_types);
-		for (auto &cond : op.conditions) {
-			probe_executor.AddExpression(*cond.left);
-		}
-		if (!op.fetch_types.empty()) {
-			rhs_chunk.Initialize(allocator, op.fetch_types);
-		}
-		rhs_sel.Initialize(STANDARD_VECTOR_SIZE);
-	}
-
-	bool first_fetch = true;
-	idx_t lhs_idx = 0;
-	idx_t rhs_idx = 0;
-	idx_t result_size = 0;
-	vector<idx_t> result_sizes;
-	DataChunk join_keys;
-	DataChunk rhs_chunk;
-	SelectionVector rhs_sel;
-	//! Vector of rows that mush be fetched for every LHS key
-	vector<vector<row_t>> rhs_rows;
-	ExpressionExecutor probe_executor;
-
-public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &probe_executor, "probe_executor", 0);
-	}
-};
-
-PhysicalIndexJoin::PhysicalIndexJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                     unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                                     const vector<idx_t> &left_projection_map_p, vector<idx_t> right_projection_map_p,
-                                     vector<column_t> column_ids_p, Index *index_p, bool lhs_first,
-                                     idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::INDEX_JOIN, move(op.types), estimated_cardinality),
-      left_projection_map(left_projection_map_p), right_projection_map(move(right_projection_map_p)), index(index_p),
-      conditions(move(cond)), join_type(join_type), lhs_first(lhs_first) {
-	column_ids = move(column_ids_p);
-	children.push_back(move(left));
-	children.push_back(move(right));
-	for (auto &condition : conditions) {
-		condition_types.push_back(condition.left->return_type);
-	}
-	//! Only add to fetch_ids columns that are not indexed
-	for (auto &index_id : index->column_ids) {
-		index_ids.insert(index_id);
-	}
-	for (idx_t column_id = 0; column_id < column_ids.size(); column_id++) {
-		auto it = index_ids.find(column_ids[column_id]);
-		if (it == index_ids.end()) {
-			fetch_ids.push_back(column_ids[column_id]);
-			fetch_types.push_back(children[1]->types[column_id]);
-		}
-	}
-	if (right_projection_map.empty()) {
-		for (column_t i = 0; i < column_ids.size(); i++) {
-			right_projection_map.push_back(i);
-		}
-	}
-	if (left_projection_map.empty()) {
-		for (column_t i = 0; i < children[0]->types.size(); i++) {
-			left_projection_map.push_back(i);
-		}
-	}
-}
-
-unique_ptr<OperatorState> PhysicalIndexJoin::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<IndexJoinOperatorState>(Allocator::Get(context.client), *this);
-}
-
-void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                               OperatorState &state_p) const {
-	auto &transaction = Transaction::GetTransaction(context.client);
-	auto &phy_tbl_scan = (PhysicalTableScan &)*children[1];
-	auto &bind_tbl = (TableScanBindData &)*phy_tbl_scan.bind_data;
-	auto &state = (IndexJoinOperatorState &)state_p;
-
-	auto tbl = bind_tbl.table->storage.get();
-	idx_t output_sel_idx = 0;
-	vector<row_t> fetch_rows;
-
-	while (output_sel_idx < STANDARD_VECTOR_SIZE && state.lhs_idx < input.size()) {
-		if (state.rhs_idx < state.result_sizes[state.lhs_idx]) {
-			state.rhs_sel.set_index(output_sel_idx++, state.lhs_idx);
-			if (!fetch_types.empty()) {
-				//! We need to collect the rows we want to fetch
-				fetch_rows.push_back(state.rhs_rows[state.lhs_idx][state.rhs_idx]);
-			}
-			state.rhs_idx++;
-		} else {
-			//! We are done with the matches from this LHS Key
-			state.rhs_idx = 0;
-			state.lhs_idx++;
-		}
-	}
-	//! Now we fetch the RHS data
-	if (!fetch_types.empty()) {
-		if (fetch_rows.empty()) {
-			return;
-		}
-		state.rhs_chunk.Reset();
-		ColumnFetchState fetch_state;
-		Vector row_ids(LogicalType::ROW_TYPE, (data_ptr_t)&fetch_rows[0]);
-		tbl->Fetch(transaction, state.rhs_chunk, fetch_ids, row_ids, output_sel_idx, fetch_state);
-	}
-
-	//! Now we actually produce our result chunk
-	idx_t left_offset = lhs_first ? 0 : right_projection_map.size();
-	idx_t right_offset = lhs_first ? left_projection_map.size() : 0;
-	idx_t rhs_column_idx = 0;
-	for (idx_t i = 0; i < right_projection_map.size(); i++) {
-		auto it = index_ids.find(column_ids[right_projection_map[i]]);
-		if (it == index_ids.end()) {
-			chunk.data[right_offset + i].Reference(state.rhs_chunk.data[rhs_column_idx++]);
-		} else {
-			chunk.data[right_offset + i].Slice(state.join_keys.data[0], state.rhs_sel, output_sel_idx);
-		}
-	}
-	for (idx_t i = 0; i < left_projection_map.size(); i++) {
-		chunk.data[left_offset + i].Slice(input.data[left_projection_map[i]], state.rhs_sel, output_sel_idx);
-	}
-
-	state.result_size = output_sel_idx;
-	chunk.SetCardinality(state.result_size);
-}
-
-void PhysicalIndexJoin::GetRHSMatches(ExecutionContext &context, DataChunk &input, OperatorState &state_p) const {
-	auto &state = (IndexJoinOperatorState &)state_p;
-	auto &art = (ART &)*index;
-	auto &transaction = Transaction::GetTransaction(context.client);
-	for (idx_t i = 0; i < input.size(); i++) {
-		auto equal_value = state.join_keys.GetValue(0, i);
-		auto index_state = art.InitializeScanSinglePredicate(transaction, equal_value, ExpressionType::COMPARE_EQUAL);
-		state.rhs_rows[i].clear();
-		if (!equal_value.IsNull()) {
-			if (fetch_types.empty()) {
-				IndexLock lock;
-				index->InitializeLock(lock);
-				art.SearchEqualJoinNoFetch(equal_value, state.result_sizes[i]);
-			} else {
-				IndexLock lock;
-				index->InitializeLock(lock);
-				art.SearchEqual((ARTIndexScanState *)index_state.get(), (idx_t)-1, state.rhs_rows[i]);
-				state.result_sizes[i] = state.rhs_rows[i].size();
-			}
-		} else {
-			//! This is null so no matches
-			state.result_sizes[i] = 0;
-		}
-	}
-	for (idx_t i = input.size(); i < STANDARD_VECTOR_SIZE; i++) {
-		//! No LHS chunk value so result size is empty
-		state.result_sizes[i] = 0;
-	}
-}
-
-OperatorResultType PhysicalIndexJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                              GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (IndexJoinOperatorState &)state_p;
-
-	state.result_size = 0;
-	if (state.first_fetch) {
-		state.probe_executor.Execute(input, state.join_keys);
-
-		//! Fill Matches for the current LHS chunk
-		GetRHSMatches(context, input, state_p);
-		state.first_fetch = false;
-	}
-	//! Check if we need to get a new LHS chunk
-	if (state.lhs_idx >= input.size()) {
-		state.lhs_idx = 0;
-		state.rhs_idx = 0;
-		state.first_fetch = true;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-	//! Output vectors
-	if (state.lhs_idx < input.size()) {
-		Output(context, input, chunk, state_p);
-	}
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalIndexJoin::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	// index join: we only continue into the LHS
-	// the right side is probed by the index join
-	// so we don't need to do anything in the pipeline with this child
-	state.AddPipelineOperator(current, this);
-	children[0]->BuildPipelines(executor, current, state);
-}
-
-vector<const PhysicalOperator *> PhysicalIndexJoin::GetSources() const {
-	return children[0]->GetSources();
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-PhysicalJoin::PhysicalJoin(LogicalOperator &op, PhysicalOperatorType type, JoinType join_type,
-                           idx_t estimated_cardinality)
-    : PhysicalOperator(type, op.types, estimated_cardinality), join_type(join_type) {
-}
-
-bool PhysicalJoin::EmptyResultIfRHSIsEmpty() const {
-	// empty RHS with INNER, RIGHT or SEMI join means empty result set
-	switch (join_type) {
-	case JoinType::INNER:
-	case JoinType::RIGHT:
-	case JoinType::SEMI:
-		return true;
-	default:
-		return false;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalJoin::BuildJoinPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state,
-                                      PhysicalOperator &op) {
-	op.op_state.reset();
-	op.sink_state.reset();
-
-	// on the LHS (probe child), the operator becomes a regular operator
-	state.AddPipelineOperator(current, &op);
-	if (op.IsSource()) {
-		// FULL or RIGHT outer join
-		// schedule a scan of the node as a child pipeline
-		// this scan has to be performed AFTER all the probing has happened
-		if (state.recursive_cte) {
-			throw NotImplementedException("FULL and RIGHT outer joins are not supported in recursive CTEs yet");
-		}
-		state.AddChildPipeline(executor, current);
-	}
-	// continue building the pipeline on this child
-	op.children[0]->BuildPipelines(executor, current, state);
-
-	// on the RHS (build side), we construct a new child pipeline with this pipeline as its source
-	op.BuildChildPipeline(executor, current, state, op.children[1].get());
-}
-
-void PhysicalJoin::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	PhysicalJoin::BuildJoinPipelines(executor, current, state, *this);
-}
-
-vector<const PhysicalOperator *> PhysicalJoin::GetSources() const {
-	auto result = children[0]->GetSources();
-	if (IsSource()) {
-		result.push_back(this);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalNestedLoopJoin::PhysicalNestedLoopJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                               unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond,
-                                               JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::NESTED_LOOP_JOIN, move(cond), join_type, estimated_cardinality) {
-	children.push_back(move(left));
-	children.push_back(move(right));
-}
-
-static bool HasNullValues(DataChunk &chunk) {
-	for (idx_t col_idx = 0; col_idx < chunk.ColumnCount(); col_idx++) {
-		VectorData vdata;
-		chunk.data[col_idx].Orrify(chunk.size(), vdata);
-
-		if (vdata.validity.AllValid()) {
-			continue;
-		}
-		for (idx_t i = 0; i < chunk.size(); i++) {
-			auto idx = vdata.sel->get_index(i);
-			if (!vdata.validity.RowIsValid(idx)) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-template <bool MATCH>
-static void ConstructSemiOrAntiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]) {
-	D_ASSERT(left.ColumnCount() == result.ColumnCount());
-	// create the selection vector from the matches that were found
-	idx_t result_count = 0;
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < left.size(); i++) {
-		if (found_match[i] == MATCH) {
-			sel.set_index(result_count++, i);
-		}
-	}
-	// construct the final result
-	if (result_count > 0) {
-		// we only return the columns on the left side
-		// project them using the result selection vector
-		// reference the columns of the left side from the result
-		result.Slice(left, sel, result_count);
-	} else {
-		result.SetCardinality(0);
-	}
-}
-
-void PhysicalJoin::ConstructSemiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]) {
-	ConstructSemiOrAntiJoinResult<true>(left, result, found_match);
-}
-
-void PhysicalJoin::ConstructAntiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]) {
-	ConstructSemiOrAntiJoinResult<false>(left, result, found_match);
-}
-
-void PhysicalJoin::ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &left, DataChunk &result, bool found_match[],
-                                           bool has_null) {
-	// for the initial set of columns we just reference the left side
-	result.SetCardinality(left);
-	for (idx_t i = 0; i < left.ColumnCount(); i++) {
-		result.data[i].Reference(left.data[i]);
-	}
-	auto &mark_vector = result.data.back();
-	mark_vector.SetVectorType(VectorType::FLAT_VECTOR);
-	// first we set the NULL values from the join keys
-	// if there is any NULL in the keys, the result is NULL
-	auto bool_result = FlatVector::GetData<bool>(mark_vector);
-	auto &mask = FlatVector::Validity(mark_vector);
-	for (idx_t col_idx = 0; col_idx < join_keys.ColumnCount(); col_idx++) {
-		VectorData jdata;
-		join_keys.data[col_idx].Orrify(join_keys.size(), jdata);
-		if (!jdata.validity.AllValid()) {
-			for (idx_t i = 0; i < join_keys.size(); i++) {
-				auto jidx = jdata.sel->get_index(i);
-				mask.Set(i, jdata.validity.RowIsValid(jidx));
-			}
-		}
-	}
-	// now set the remaining entries to either true or false based on whether a match was found
-	if (found_match) {
-		for (idx_t i = 0; i < left.size(); i++) {
-			bool_result[i] = found_match[i];
-		}
-	} else {
-		memset(bool_result, 0, sizeof(bool) * left.size());
-	}
-	// if the right side contains NULL values, the result of any FALSE becomes NULL
-	if (has_null) {
-		for (idx_t i = 0; i < left.size(); i++) {
-			if (!bool_result[i]) {
-				mask.SetInvalid(i);
-			}
-		}
-	}
-}
-
-bool PhysicalNestedLoopJoin::IsSupported(const vector<JoinCondition> &conditions) {
-	for (auto &cond : conditions) {
-		if (cond.left->return_type.InternalType() == PhysicalType::STRUCT ||
-		    cond.left->return_type.InternalType() == PhysicalType::LIST) {
-			return false;
-		}
-	}
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class NestedLoopJoinLocalState : public LocalSinkState {
-public:
-	explicit NestedLoopJoinLocalState(Allocator &allocator, const vector<JoinCondition> &conditions)
-	    : rhs_executor(allocator) {
-		vector<LogicalType> condition_types;
-		for (auto &cond : conditions) {
-			rhs_executor.AddExpression(*cond.right);
-			condition_types.push_back(cond.right->return_type);
-		}
-		right_condition.Initialize(allocator, condition_types);
-	}
-
-	//! The chunk holding the right condition
-	DataChunk right_condition;
-	//! The executor of the RHS condition
-	ExpressionExecutor rhs_executor;
-};
-
-class NestedLoopJoinGlobalState : public GlobalSinkState {
-public:
-	explicit NestedLoopJoinGlobalState(Allocator &allocator)
-	    : right_data(allocator), right_chunks(allocator), has_null(false) {
-	}
-
-	mutex nj_lock;
-	//! Materialized data of the RHS
-	ChunkCollection right_data;
-	//! Materialized join condition of the RHS
-	ChunkCollection right_chunks;
-	//! Whether or not the RHS of the nested loop join has NULL values
-	bool has_null;
-	//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
-	unique_ptr<bool[]> right_found_match;
-};
-
-SinkResultType PhysicalNestedLoopJoin::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                            DataChunk &input) const {
-	auto &gstate = (NestedLoopJoinGlobalState &)state;
-	auto &nlj_state = (NestedLoopJoinLocalState &)lstate;
-
-	// resolve the join expression of the right side
-	nlj_state.right_condition.Reset();
-	nlj_state.rhs_executor.Execute(input, nlj_state.right_condition);
-
-	// if we have not seen any NULL values yet, and we are performing a MARK join, check if there are NULL values in
-	// this chunk
-	if (join_type == JoinType::MARK && !gstate.has_null) {
-		if (HasNullValues(nlj_state.right_condition)) {
-			gstate.has_null = true;
-		}
-	}
-
-	// append the data and the
-	lock_guard<mutex> nj_guard(gstate.nj_lock);
-	gstate.right_data.Append(input);
-	gstate.right_chunks.Append(nlj_state.right_condition);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalNestedLoopJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &state = (NestedLoopJoinLocalState &)lstate;
-	auto &client_profiler = QueryProfiler::Get(context.client);
-
-	context.thread.profiler.Flush(this, &state.rhs_executor, "rhs_executor", 1);
-	client_profiler.Flush(context.thread.profiler);
-}
-
-SinkFinalizeType PhysicalNestedLoopJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  GlobalSinkState &gstate_p) const {
-	auto &gstate = (NestedLoopJoinGlobalState &)gstate_p;
-	if (join_type == JoinType::OUTER || join_type == JoinType::RIGHT) {
-		// for FULL/RIGHT OUTER JOIN, initialize found_match to false for every tuple
-		gstate.right_found_match = unique_ptr<bool[]>(new bool[gstate.right_data.Count()]);
-		memset(gstate.right_found_match.get(), 0, sizeof(bool) * gstate.right_data.Count());
-	}
-	if (gstate.right_chunks.Count() == 0 && EmptyResultIfRHSIsEmpty()) {
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-	return SinkFinalizeType::READY;
-}
-
-unique_ptr<GlobalSinkState> PhysicalNestedLoopJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<NestedLoopJoinGlobalState>(Allocator::Get(context));
-}
-
-unique_ptr<LocalSinkState> PhysicalNestedLoopJoin::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<NestedLoopJoinLocalState>(Allocator::Get(context.client), conditions);
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class PhysicalNestedLoopJoinState : public OperatorState {
-public:
-	PhysicalNestedLoopJoinState(Allocator &allocator, const PhysicalNestedLoopJoin &op,
-	                            const vector<JoinCondition> &conditions)
-	    : fetch_next_left(true), fetch_next_right(false), right_chunk(0), lhs_executor(allocator), left_tuple(0),
-	      right_tuple(0) {
-		vector<LogicalType> condition_types;
-		for (auto &cond : conditions) {
-			lhs_executor.AddExpression(*cond.left);
-			condition_types.push_back(cond.left->return_type);
-		}
-		left_condition.Initialize(allocator, condition_types);
-		if (IsLeftOuterJoin(op.join_type)) {
-			left_found_match = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
-			memset(left_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-		}
-	}
-
-	bool fetch_next_left;
-	bool fetch_next_right;
-	idx_t right_chunk;
-	DataChunk left_condition;
-	//! The executor of the LHS condition
-	ExpressionExecutor lhs_executor;
-
-	idx_t left_tuple;
-	idx_t right_tuple;
-
-	unique_ptr<bool[]> left_found_match;
-
-public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &lhs_executor, "lhs_executor", 0);
-	}
-};
-
-unique_ptr<OperatorState> PhysicalNestedLoopJoin::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<PhysicalNestedLoopJoinState>(Allocator::Get(context.client), *this, conditions);
-}
-
-OperatorResultType PhysicalNestedLoopJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (NestedLoopJoinGlobalState &)*sink_state;
-
-	if (gstate.right_chunks.Count() == 0) {
-		// empty RHS
-		if (!EmptyResultIfRHSIsEmpty()) {
-			ConstructEmptyJoinResult(join_type, gstate.has_null, input, chunk);
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			return OperatorResultType::FINISHED;
-		}
-	}
-
-	switch (join_type) {
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-	case JoinType::MARK:
-		// simple joins can have max STANDARD_VECTOR_SIZE matches per chunk
-		ResolveSimpleJoin(context, input, chunk, state_p);
-		return OperatorResultType::NEED_MORE_INPUT;
-	case JoinType::LEFT:
-	case JoinType::INNER:
-	case JoinType::OUTER:
-	case JoinType::RIGHT:
-		return ResolveComplexJoin(context, input, chunk, state_p);
-	default:
-		throw NotImplementedException("Unimplemented type for nested loop join!");
-	}
-}
-
-void PhysicalNestedLoopJoin::ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                               OperatorState &state_p) const {
-	auto &state = (PhysicalNestedLoopJoinState &)state_p;
-	auto &gstate = (NestedLoopJoinGlobalState &)*sink_state;
-
-	// resolve the left join condition for the current chunk
-	state.lhs_executor.Execute(input, state.left_condition);
-
-	bool found_match[STANDARD_VECTOR_SIZE] = {false};
-	NestedLoopJoinMark::Perform(state.left_condition, gstate.right_chunks, found_match, conditions);
-	switch (join_type) {
-	case JoinType::MARK:
-		// now construct the mark join result from the found matches
-		PhysicalJoin::ConstructMarkJoinResult(state.left_condition, input, chunk, found_match, gstate.has_null);
-		break;
-	case JoinType::SEMI:
-		// construct the semi join result from the found matches
-		PhysicalJoin::ConstructSemiJoinResult(input, chunk, found_match);
-		break;
-	case JoinType::ANTI:
-		// construct the anti join result from the found matches
-		PhysicalJoin::ConstructAntiJoinResult(input, chunk, found_match);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for simple nested loop join!");
-	}
-}
-
-void PhysicalJoin::ConstructLeftJoinResult(DataChunk &left, DataChunk &result, bool found_match[]) {
-	SelectionVector remaining_sel(STANDARD_VECTOR_SIZE);
-	idx_t remaining_count = 0;
-	for (idx_t i = 0; i < left.size(); i++) {
-		if (!found_match[i]) {
-			remaining_sel.set_index(remaining_count++, i);
-		}
-	}
-	if (remaining_count > 0) {
-		result.Slice(left, remaining_sel, remaining_count);
-		for (idx_t idx = left.ColumnCount(); idx < result.ColumnCount(); idx++) {
-			result.data[idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result.data[idx], true);
-		}
-	}
-}
-
-OperatorResultType PhysicalNestedLoopJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &input,
-                                                              DataChunk &chunk, OperatorState &state_p) const {
-	auto &state = (PhysicalNestedLoopJoinState &)state_p;
-	auto &gstate = (NestedLoopJoinGlobalState &)*sink_state;
-
-	idx_t match_count;
-	do {
-		if (state.fetch_next_right) {
-			// we exhausted the chunk on the right: move to the next chunk on the right
-			state.right_chunk++;
-			state.left_tuple = 0;
-			state.right_tuple = 0;
-			state.fetch_next_right = false;
-			// check if we exhausted all chunks on the RHS
-			if (state.right_chunk >= gstate.right_chunks.ChunkCount()) {
-				state.fetch_next_left = true;
-				// we exhausted all chunks on the right: move to the next chunk on the left
-				if (IsLeftOuterJoin(join_type)) {
-					// left join: before we move to the next chunk, see if we need to output any vectors that didn't
-					// have a match found
-					PhysicalJoin::ConstructLeftJoinResult(input, chunk, state.left_found_match.get());
-					memset(state.left_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-				}
-				return OperatorResultType::NEED_MORE_INPUT;
-			}
-		}
-		if (state.fetch_next_left) {
-			// resolve the left join condition for the current chunk
-			state.left_condition.Reset();
-			state.lhs_executor.Execute(input, state.left_condition);
-
-			state.left_tuple = 0;
-			state.right_tuple = 0;
-			state.right_chunk = 0;
-			state.fetch_next_left = false;
-		}
-		// now we have a left and a right chunk that we can join together
-		// note that we only get here in the case of a LEFT, INNER or FULL join
-		auto &left_chunk = input;
-		auto &right_chunk = gstate.right_chunks.GetChunk(state.right_chunk);
-		auto &right_data = gstate.right_data.GetChunk(state.right_chunk);
-
-		// sanity check
-		left_chunk.Verify();
-		right_chunk.Verify();
-		right_data.Verify();
-
-		// now perform the join
-		SelectionVector lvector(STANDARD_VECTOR_SIZE), rvector(STANDARD_VECTOR_SIZE);
-		match_count = NestedLoopJoinInner::Perform(state.left_tuple, state.right_tuple, state.left_condition,
-		                                           right_chunk, lvector, rvector, conditions);
-		// we have finished resolving the join conditions
-		if (match_count > 0) {
-			// we have matching tuples!
-			// construct the result
-			if (state.left_found_match) {
-				for (idx_t i = 0; i < match_count; i++) {
-					state.left_found_match[lvector.get_index(i)] = true;
-				}
-			}
-			if (gstate.right_found_match) {
-				for (idx_t i = 0; i < match_count; i++) {
-					gstate.right_found_match[state.right_chunk * STANDARD_VECTOR_SIZE + rvector.get_index(i)] = true;
-				}
-			}
-			chunk.Slice(input, lvector, match_count);
-			chunk.Slice(right_data, rvector, match_count, input.ColumnCount());
-		}
-
-		// check if we exhausted the RHS, if we did we need to move to the next right chunk in the next iteration
-		if (state.right_tuple >= right_chunk.size()) {
-			state.fetch_next_right = true;
-		}
-	} while (match_count == 0);
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class NestedLoopJoinScanState : public GlobalSourceState {
-public:
-	explicit NestedLoopJoinScanState(const PhysicalNestedLoopJoin &op) : op(op), right_outer_position(0) {
-	}
-
-	mutex lock;
-	const PhysicalNestedLoopJoin &op;
-	idx_t right_outer_position;
-
-public:
-	idx_t MaxThreads() override {
-		auto &sink = (NestedLoopJoinGlobalState &)*op.sink_state;
-		return sink.right_chunks.Count() / (STANDARD_VECTOR_SIZE * 10);
-	}
-};
-
-unique_ptr<GlobalSourceState> PhysicalNestedLoopJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<NestedLoopJoinScanState>(*this);
-}
-
-void PhysicalNestedLoopJoin::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                     LocalSourceState &lstate) const {
-	D_ASSERT(IsRightOuterJoin(join_type));
-	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
-	auto &sink = (NestedLoopJoinGlobalState &)*sink_state;
-	auto &state = (NestedLoopJoinScanState &)gstate;
-
-	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan the found_match for any chunks we
-	// still need to output
-	lock_guard<mutex> l(state.lock);
-	ConstructFullOuterJoinResult(sink.right_found_match.get(), sink.right_data, chunk, state.right_outer_position);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-                                                       unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond,
-                                                       JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalRangeJoin(op, PhysicalOperatorType::PIECEWISE_MERGE_JOIN, move(left), move(right), move(cond), join_type,
-                        estimated_cardinality) {
-
-	for (auto &cond : conditions) {
-		D_ASSERT(cond.left->return_type == cond.right->return_type);
-		join_key_types.push_back(cond.left->return_type);
-
-		// Convert the conditions to sort orders
-		auto left = cond.left->Copy();
-		auto right = cond.right->Copy();
-		switch (cond.comparison) {
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			lhs_orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, move(left)));
-			rhs_orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, move(right)));
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			lhs_orders.emplace_back(BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, move(left)));
-			rhs_orders.emplace_back(BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, move(right)));
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			// Allowed in multi-predicate joins, but can't be first/sort.
-			D_ASSERT(!lhs_orders.empty());
-			lhs_orders.emplace_back(BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, move(left)));
-			rhs_orders.emplace_back(BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, move(right)));
-			break;
-
-		default:
-			// COMPARE EQUAL not supported with merge join
-			throw NotImplementedException("Unimplemented join type for merge join");
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class MergeJoinLocalState : public LocalSinkState {
-public:
-	explicit MergeJoinLocalState(Allocator &allocator, const PhysicalRangeJoin &op, const idx_t child)
-	    : table(allocator, op, child) {
-	}
-
-	//! The local sort state
-	PhysicalRangeJoin::LocalSortedTable table;
-};
-
-class MergeJoinGlobalState : public GlobalSinkState {
-public:
-	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-public:
-	MergeJoinGlobalState(ClientContext &context, const PhysicalPiecewiseMergeJoin &op) {
-		RowLayout rhs_layout;
-		rhs_layout.Initialize(op.children[1]->types);
-		vector<BoundOrderByNode> rhs_order;
-		rhs_order.emplace_back(op.rhs_orders[0].Copy());
-		table = make_unique<GlobalSortedTable>(context, rhs_order, rhs_layout);
-	}
-
-	inline idx_t Count() const {
-		return table->count;
-	}
-
-	void Sink(DataChunk &input, MergeJoinLocalState &lstate) {
-		auto &global_sort_state = table->global_sort_state;
-		auto &local_sort_state = lstate.table.local_sort_state;
-
-		// Sink the data into the local sort state
-		lstate.table.Sink(input, global_sort_state);
-
-		// When sorting data reaches a certain size, we sort it
-		if (local_sort_state.SizeInBytes() >= table->memory_per_thread) {
-			local_sort_state.Sort(global_sort_state, true);
-		}
-	}
-
-	unique_ptr<GlobalSortedTable> table;
-};
-
-unique_ptr<GlobalSinkState> PhysicalPiecewiseMergeJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<MergeJoinGlobalState>(context, *this);
-}
-
-unique_ptr<LocalSinkState> PhysicalPiecewiseMergeJoin::GetLocalSinkState(ExecutionContext &context) const {
-	// We only sink the RHS
-	return make_unique<MergeJoinLocalState>(Allocator::Get(context.client), *this, 1);
-}
-
-SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                                LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &gstate = (MergeJoinGlobalState &)gstate_p;
-	auto &lstate = (MergeJoinLocalState &)lstate_p;
-
-	gstate.Sink(input, lstate);
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                         LocalSinkState &lstate_p) const {
-	auto &gstate = (MergeJoinGlobalState &)gstate_p;
-	auto &lstate = (MergeJoinLocalState &)lstate_p;
-	gstate.table->Combine(lstate.table);
-	auto &client_profiler = QueryProfiler::Get(context.client);
-
-	context.thread.profiler.Flush(this, &lstate.table.executor, "rhs_executor", 1);
-	client_profiler.Flush(context.thread.profiler);
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalPiecewiseMergeJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                      GlobalSinkState &gstate_p) const {
-	auto &gstate = (MergeJoinGlobalState &)gstate_p;
-	auto &global_sort_state = gstate.table->global_sort_state;
-
-	if (IsRightOuterJoin(join_type)) {
-		// for FULL/RIGHT OUTER JOIN, initialize found_match to false for every tuple
-		gstate.table->IntializeMatches();
-	}
-	if (global_sort_state.sorted_blocks.empty() && EmptyResultIfRHSIsEmpty()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Sort the current input child
-	gstate.table->Finalize(pipeline, event);
-
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-class PiecewiseMergeJoinState : public OperatorState {
-public:
-	using LocalSortedTable = PhysicalRangeJoin::LocalSortedTable;
-
-	explicit PiecewiseMergeJoinState(Allocator &allocator, const PhysicalPiecewiseMergeJoin &op,
-	                                 BufferManager &buffer_manager, bool force_external)
-	    : allocator(allocator), op(op), buffer_manager(buffer_manager), force_external(force_external),
-	      left_position(0), first_fetch(true), finished(true), right_position(0), right_chunk_index(0),
-	      rhs_executor(allocator) {
-		vector<LogicalType> condition_types;
-		for (auto &order : op.lhs_orders) {
-			condition_types.push_back(order.expression->return_type);
-		}
-		if (IsLeftOuterJoin(op.join_type)) {
-			lhs_found_match = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
-			memset(lhs_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-		}
-		lhs_layout.Initialize(op.children[0]->types);
-		lhs_payload.Initialize(allocator, op.children[0]->types);
-
-		lhs_order.emplace_back(op.lhs_orders[0].Copy());
-
-		// Set up shared data for multiple predicates
-		sel.Initialize(STANDARD_VECTOR_SIZE);
-		condition_types.clear();
-		for (auto &order : op.rhs_orders) {
-			rhs_executor.AddExpression(*order.expression);
-			condition_types.push_back(order.expression->return_type);
-		}
-		rhs_keys.Initialize(allocator, condition_types);
-	}
-
-	Allocator &allocator;
-	const PhysicalPiecewiseMergeJoin &op;
-	BufferManager &buffer_manager;
-	bool force_external;
-
-	// Block sorting
-	DataChunk lhs_payload;
-	unique_ptr<bool[]> lhs_found_match;
-	vector<BoundOrderByNode> lhs_order;
-	RowLayout lhs_layout;
-	unique_ptr<LocalSortedTable> lhs_local_table;
-	unique_ptr<GlobalSortState> lhs_global_state;
-
-	// Simple scans
-	idx_t left_position;
-
-	// Complex scans
-	bool first_fetch;
-	bool finished;
-	idx_t right_position;
-	idx_t right_chunk_index;
-	idx_t right_base;
-
-	// Secondary predicate shared data
-	SelectionVector sel;
-	DataChunk rhs_keys;
-	DataChunk rhs_input;
-	ExpressionExecutor rhs_executor;
-
-public:
-	void ResolveJoinKeys(DataChunk &input) {
-		// sort by join key
-		lhs_global_state = make_unique<GlobalSortState>(buffer_manager, lhs_order, lhs_layout);
-		lhs_local_table = make_unique<LocalSortedTable>(allocator, op, 0);
-		lhs_local_table->Sink(input, *lhs_global_state);
-
-		// Set external (can be forced with the PRAGMA)
-		lhs_global_state->external = force_external;
-		lhs_global_state->AddLocalState(lhs_local_table->local_sort_state);
-		lhs_global_state->PrepareMergePhase();
-		while (lhs_global_state->sorted_blocks.size() > 1) {
-			MergeSorter merge_sorter(*lhs_global_state, buffer_manager);
-			merge_sorter.PerformInMergeRound();
-			lhs_global_state->CompleteMergeRound();
-		}
-
-		// Scan the sorted payload
-		D_ASSERT(lhs_global_state->sorted_blocks.size() == 1);
-
-		PayloadScanner scanner(*lhs_global_state->sorted_blocks[0]->payload_data, *lhs_global_state);
-		lhs_payload.Reset();
-		scanner.Scan(lhs_payload);
-
-		// Recompute the sorted keys from the sorted input
-		lhs_local_table->keys.Reset();
-		lhs_local_table->executor.Execute(lhs_payload, lhs_local_table->keys);
-	}
-
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		if (lhs_local_table) {
-			context.thread.profiler.Flush(op, &lhs_local_table->executor, "lhs_executor", 0);
-		}
-	}
-};
-
-unique_ptr<OperatorState> PhysicalPiecewiseMergeJoin::GetOperatorState(ExecutionContext &context) const {
-	auto &buffer_manager = BufferManager::GetBufferManager(context.client);
-	auto &config = ClientConfig::GetConfig(context.client);
-	return make_unique<PiecewiseMergeJoinState>(Allocator::Get(context.client), *this, buffer_manager,
-	                                            config.force_external);
-}
-
-static inline idx_t SortedBlockNotNull(const idx_t base, const idx_t count, const idx_t not_null) {
-	return MinValue(base + count, MaxValue(base, not_null)) - base;
-}
-
-static int MergeJoinComparisonValue(ExpressionType comparison) {
-	switch (comparison) {
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return -1;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return 0;
-	default:
-		throw InternalException("Unimplemented comparison type for merge join!");
-	}
-}
-
-struct BlockMergeInfo {
-	GlobalSortState &state;
-	//! The block being scanned
-	const idx_t block_idx;
-	//! The number of not-NULL values in the block (they are at the end)
-	const idx_t not_null;
-	//! The current offset in the block
-	idx_t &entry_idx;
-	SelectionVector result;
-
-	BlockMergeInfo(GlobalSortState &state, idx_t block_idx, idx_t &entry_idx, idx_t not_null)
-	    : state(state), block_idx(block_idx), not_null(not_null), entry_idx(entry_idx), result(STANDARD_VECTOR_SIZE) {
-	}
-};
-
-static void MergeJoinPinSortingBlock(SBScanState &scan, const idx_t block_idx) {
-	scan.SetIndices(block_idx, 0);
-	scan.PinRadix(block_idx);
-
-	auto &sd = *scan.sb->blob_sorting_data;
-	if (block_idx < sd.data_blocks.size()) {
-		scan.PinData(sd);
-	}
-}
-
-static data_ptr_t MergeJoinRadixPtr(SBScanState &scan, const idx_t entry_idx) {
-	scan.entry_idx = entry_idx;
-	return scan.RadixPtr();
-}
-
-static idx_t MergeJoinSimpleBlocks(PiecewiseMergeJoinState &lstate, MergeJoinGlobalState &rstate, bool *found_match,
-                                   const ExpressionType comparison) {
-	const auto cmp = MergeJoinComparisonValue(comparison);
-
-	// The sort parameters should all be the same
-	auto &lsort = *lstate.lhs_global_state;
-	auto &rsort = rstate.table->global_sort_state;
-	D_ASSERT(lsort.sort_layout.all_constant == rsort.sort_layout.all_constant);
-	const auto all_constant = lsort.sort_layout.all_constant;
-	D_ASSERT(lsort.external == rsort.external);
-	const auto external = lsort.external;
-
-	// There should only be one sorted block if they have been sorted
-	D_ASSERT(lsort.sorted_blocks.size() == 1);
-	SBScanState lread(lsort.buffer_manager, lsort);
-	lread.sb = lsort.sorted_blocks[0].get();
-
-	const idx_t l_block_idx = 0;
-	idx_t l_entry_idx = 0;
-	const auto lhs_not_null = lstate.lhs_local_table->count - lstate.lhs_local_table->has_null;
-	MergeJoinPinSortingBlock(lread, l_block_idx);
-	auto l_ptr = MergeJoinRadixPtr(lread, l_entry_idx);
-
-	D_ASSERT(rsort.sorted_blocks.size() == 1);
-	SBScanState rread(rsort.buffer_manager, rsort);
-	rread.sb = rsort.sorted_blocks[0].get();
-
-	const auto cmp_size = lsort.sort_layout.comparison_size;
-	const auto entry_size = lsort.sort_layout.entry_size;
-
-	idx_t right_base = 0;
-	for (idx_t r_block_idx = 0; r_block_idx < rread.sb->radix_sorting_data.size(); r_block_idx++) {
-		// we only care about the BIGGEST value in each of the RHS data blocks
-		// because we want to figure out if the LHS values are less than [or equal] to ANY value
-		// get the biggest value from the RHS chunk
-		MergeJoinPinSortingBlock(rread, r_block_idx);
-
-		auto &rblock = rread.sb->radix_sorting_data[r_block_idx];
-		const auto r_not_null =
-		    SortedBlockNotNull(right_base, rblock.count, rstate.table->count - rstate.table->has_null);
-		if (r_not_null == 0) {
-			break;
-		}
-		const auto r_entry_idx = r_not_null - 1;
-		right_base += rblock.count;
-
-		auto r_ptr = MergeJoinRadixPtr(rread, r_entry_idx);
-
-		// now we start from the current lpos value and check if we found a new value that is [<= OR <] the max RHS
-		// value
-		while (true) {
-			int comp_res;
-			if (all_constant) {
-				comp_res = FastMemcmp(l_ptr, r_ptr, cmp_size);
-			} else {
-				lread.entry_idx = l_entry_idx;
-				rread.entry_idx = r_entry_idx;
-				comp_res = Comparators::CompareTuple(lread, rread, l_ptr, r_ptr, lsort.sort_layout, external);
-			}
-
-			if (comp_res <= cmp) {
-				// found a match for lpos, set it in the found_match vector
-				found_match[l_entry_idx] = true;
-				l_entry_idx++;
-				l_ptr += entry_size;
-				if (l_entry_idx >= lhs_not_null) {
-					// early out: we exhausted the entire LHS and they all match
-					return 0;
-				}
-			} else {
-				// we found no match: any subsequent value from the LHS we scan now will be bigger and thus also not
-				// match move to the next RHS chunk
-				break;
-			}
-		}
-	}
-	return 0;
-}
-
-void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   OperatorState &state_p) const {
-	auto &state = (PiecewiseMergeJoinState &)state_p;
-	auto &gstate = (MergeJoinGlobalState &)*sink_state;
-
-	state.ResolveJoinKeys(input);
-	auto &lhs_table = *state.lhs_local_table;
-
-	// perform the actual join
-	bool found_match[STANDARD_VECTOR_SIZE];
-	memset(found_match, 0, sizeof(found_match));
-	MergeJoinSimpleBlocks(state, gstate, found_match, conditions[0].comparison);
-
-	// use the sorted payload
-	const auto lhs_not_null = lhs_table.count - lhs_table.has_null;
-	auto &payload = state.lhs_payload;
-
-	// now construct the result based on the join result
-	switch (join_type) {
-	case JoinType::MARK: {
-		// The only part of the join keys that is actually used is the validity mask.
-		// Since the payload is sorted, we can just set the tail end of the validity masks to invalid.
-		for (auto &key : lhs_table.keys.data) {
-			key.Normalify(lhs_table.keys.size());
-			auto &mask = FlatVector::Validity(key);
-			if (mask.AllValid()) {
-				continue;
-			}
-			mask.SetAllValid(lhs_not_null);
-			for (idx_t i = lhs_not_null; i < lhs_table.count; ++i) {
-				mask.SetInvalid(i);
-			}
-		}
-		// So we make a set of keys that have the validity mask set for the
-		PhysicalJoin::ConstructMarkJoinResult(lhs_table.keys, payload, chunk, found_match, gstate.table->has_null);
-		break;
-	}
-	case JoinType::SEMI:
-		PhysicalJoin::ConstructSemiJoinResult(payload, chunk, found_match);
-		break;
-	case JoinType::ANTI:
-		PhysicalJoin::ConstructAntiJoinResult(payload, chunk, found_match);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented join type for merge join");
-	}
-}
-
-static idx_t MergeJoinComplexBlocks(BlockMergeInfo &l, BlockMergeInfo &r, const ExpressionType comparison) {
-	const auto cmp = MergeJoinComparisonValue(comparison);
-
-	// The sort parameters should all be the same
-	D_ASSERT(l.state.sort_layout.all_constant == r.state.sort_layout.all_constant);
-	const auto all_constant = r.state.sort_layout.all_constant;
-	D_ASSERT(l.state.external == r.state.external);
-	const auto external = l.state.external;
-
-	// There should only be one sorted block if they have been sorted
-	D_ASSERT(l.state.sorted_blocks.size() == 1);
-	SBScanState lread(l.state.buffer_manager, l.state);
-	lread.sb = l.state.sorted_blocks[0].get();
-	D_ASSERT(lread.sb->radix_sorting_data.size() == 1);
-	MergeJoinPinSortingBlock(lread, l.block_idx);
-	auto l_start = MergeJoinRadixPtr(lread, 0);
-	auto l_ptr = MergeJoinRadixPtr(lread, l.entry_idx);
-
-	D_ASSERT(r.state.sorted_blocks.size() == 1);
-	SBScanState rread(r.state.buffer_manager, r.state);
-	rread.sb = r.state.sorted_blocks[0].get();
-
-	if (r.entry_idx >= r.not_null) {
-		return 0;
-	}
-
-	MergeJoinPinSortingBlock(rread, r.block_idx);
-	auto r_ptr = MergeJoinRadixPtr(rread, r.entry_idx);
-
-	const auto cmp_size = l.state.sort_layout.comparison_size;
-	const auto entry_size = l.state.sort_layout.entry_size;
-
-	idx_t result_count = 0;
-	while (true) {
-		if (l.entry_idx < l.not_null) {
-			int comp_res;
-			if (all_constant) {
-				comp_res = FastMemcmp(l_ptr, r_ptr, cmp_size);
-			} else {
-				lread.entry_idx = l.entry_idx;
-				rread.entry_idx = r.entry_idx;
-				comp_res = Comparators::CompareTuple(lread, rread, l_ptr, r_ptr, l.state.sort_layout, external);
-			}
-
-			if (comp_res <= cmp) {
-				// left side smaller: found match
-				l.result.set_index(result_count, sel_t(l.entry_idx));
-				r.result.set_index(result_count, sel_t(r.entry_idx));
-				result_count++;
-				// move left side forward
-				l.entry_idx++;
-				l_ptr += entry_size;
-				if (result_count == STANDARD_VECTOR_SIZE) {
-					// out of space!
-					break;
-				}
-				continue;
-			}
-		}
-		// right side smaller or equal, or left side exhausted: move
-		// right pointer forward reset left side to start
-		r.entry_idx++;
-		if (r.entry_idx >= r.not_null) {
-			break;
-		}
-		r_ptr += entry_size;
-
-		l_ptr = l_start;
-		l.entry_idx = 0;
-	}
-
-	return result_count;
-}
-
-OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &input,
-                                                                  DataChunk &chunk, OperatorState &state_p) const {
-	auto &state = (PiecewiseMergeJoinState &)state_p;
-	auto &gstate = (MergeJoinGlobalState &)*sink_state;
-	auto &rsorted = *gstate.table->global_sort_state.sorted_blocks[0];
-	const auto left_cols = input.ColumnCount();
-	const auto tail_cols = conditions.size() - 1;
-	do {
-		if (state.first_fetch) {
-			state.ResolveJoinKeys(input);
-
-			state.right_chunk_index = 0;
-			state.right_base = 0;
-			state.left_position = 0;
-			state.right_position = 0;
-			state.first_fetch = false;
-			state.finished = false;
-		}
-		if (state.finished) {
-			if (IsLeftOuterJoin(join_type)) {
-				// left join: before we move to the next chunk, see if we need to output any vectors that didn't
-				// have a match found
-				PhysicalJoin::ConstructLeftJoinResult(state.lhs_payload, chunk, state.lhs_found_match.get());
-				memset(state.lhs_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-			}
-			state.first_fetch = true;
-			state.finished = false;
-			return OperatorResultType::NEED_MORE_INPUT;
-		}
-
-		auto &lhs_table = *state.lhs_local_table;
-		const auto lhs_not_null = lhs_table.count - lhs_table.has_null;
-		BlockMergeInfo left_info(*state.lhs_global_state, 0, state.left_position, lhs_not_null);
-
-		const auto &rblock = rsorted.radix_sorting_data[state.right_chunk_index];
-		const auto rhs_not_null =
-		    SortedBlockNotNull(state.right_base, rblock.count, gstate.table->count - gstate.table->has_null);
-		BlockMergeInfo right_info(gstate.table->global_sort_state, state.right_chunk_index, state.right_position,
-		                          rhs_not_null);
-
-		idx_t result_count = MergeJoinComplexBlocks(left_info, right_info, conditions[0].comparison);
-		if (result_count == 0) {
-			// exhausted this chunk on the right side
-			// move to the next right chunk
-			state.left_position = 0;
-			state.right_position = 0;
-			state.right_base += rsorted.radix_sorting_data[state.right_chunk_index].count;
-			state.right_chunk_index++;
-			if (state.right_chunk_index >= rsorted.radix_sorting_data.size()) {
-				state.finished = true;
-			}
-		} else {
-			// found matches: extract them
-			chunk.Reset();
-			for (idx_t c = 0; c < state.lhs_payload.ColumnCount(); ++c) {
-				chunk.data[c].Slice(state.lhs_payload.data[c], left_info.result, result_count);
-			}
-			SliceSortedPayload(chunk, right_info.state, right_info.block_idx, right_info.result, result_count,
-			                   left_cols);
-			chunk.SetCardinality(result_count);
-
-			auto sel = FlatVector::IncrementalSelectionVector();
-			if (tail_cols) {
-				// If there are more expressions to compute,
-				// split the result chunk into the left and right halves
-				// so we can compute the values for comparison.
-				chunk.Split(state.rhs_input, left_cols);
-				state.rhs_executor.SetChunk(state.rhs_input);
-				state.rhs_keys.Reset();
-
-				auto tail_count = result_count;
-				for (size_t cmp_idx = 1; cmp_idx < conditions.size(); ++cmp_idx) {
-					Vector left(lhs_table.keys.data[cmp_idx]);
-					left.Slice(left_info.result, result_count);
-
-					auto &right = state.rhs_keys.data[cmp_idx];
-					state.rhs_executor.ExecuteExpression(cmp_idx, right);
-
-					if (tail_count < result_count) {
-						left.Slice(*sel, tail_count);
-						right.Slice(*sel, tail_count);
-					}
-					tail_count =
-					    SelectJoinTail(conditions[cmp_idx].comparison, left, right, sel, tail_count, &state.sel);
-					sel = &state.sel;
-				}
-				chunk.Fuse(state.rhs_input);
-
-				if (tail_count < result_count) {
-					result_count = tail_count;
-					chunk.Slice(*sel, result_count);
-				}
-			}
-
-			// found matches: mark the found matches if required
-			if (state.lhs_found_match) {
-				for (idx_t i = 0; i < result_count; i++) {
-					state.lhs_found_match[left_info.result[sel->get_index(i)]] = true;
-				}
-			}
-			if (gstate.table->found_match) {
-				//	Absolute position of the block + start position inside that block
-				for (idx_t i = 0; i < result_count; i++) {
-					gstate.table->found_match[state.right_base + right_info.result[sel->get_index(i)]] = true;
-				}
-			}
-			chunk.SetCardinality(result_count);
-			chunk.Verify();
-		}
-	} while (chunk.size() == 0);
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-OperatorResultType PhysicalPiecewiseMergeJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                       GlobalOperatorState &gstate_p, OperatorState &state) const {
-	auto &gstate = (MergeJoinGlobalState &)*sink_state;
-
-	if (gstate.Count() == 0) {
-		// empty RHS
-		if (!EmptyResultIfRHSIsEmpty()) {
-			ConstructEmptyJoinResult(join_type, gstate.table->has_null, input, chunk);
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			return OperatorResultType::FINISHED;
-		}
-	}
-
-	input.Verify();
-	switch (join_type) {
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-	case JoinType::MARK:
-		// simple joins can have max STANDARD_VECTOR_SIZE matches per chunk
-		ResolveSimpleJoin(context, input, chunk, state);
-		return OperatorResultType::NEED_MORE_INPUT;
-	case JoinType::LEFT:
-	case JoinType::INNER:
-	case JoinType::RIGHT:
-	case JoinType::OUTER:
-		return ResolveComplexJoin(context, input, chunk, state);
-	default:
-		throw NotImplementedException("Unimplemented type for piecewise merge loop join!");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class PiecewiseJoinScanState : public GlobalSourceState {
-public:
-	explicit PiecewiseJoinScanState(const PhysicalPiecewiseMergeJoin &op) : op(op), right_outer_position(0) {
-	}
-
-	mutex lock;
-	const PhysicalPiecewiseMergeJoin &op;
-	unique_ptr<PayloadScanner> scanner;
-	idx_t right_outer_position;
-
-public:
-	idx_t MaxThreads() override {
-		auto &sink = (MergeJoinGlobalState &)*op.sink_state;
-		return sink.Count() / (STANDARD_VECTOR_SIZE * idx_t(10));
-	}
-};
-
-unique_ptr<GlobalSourceState> PhysicalPiecewiseMergeJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<PiecewiseJoinScanState>(*this);
-}
-
-void PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context, DataChunk &result, GlobalSourceState &gstate,
-                                         LocalSourceState &lstate) const {
-	D_ASSERT(IsRightOuterJoin(join_type));
-	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
-	auto &sink = (MergeJoinGlobalState &)*sink_state;
-	auto &state = (PiecewiseJoinScanState &)gstate;
-
-	lock_guard<mutex> l(state.lock);
-	if (!state.scanner) {
-		// Initialize scanner (if not yet initialized)
-		auto &sort_state = sink.table->global_sort_state;
-		if (sort_state.sorted_blocks.empty()) {
-			return;
-		}
-		state.scanner = make_unique<PayloadScanner>(*sort_state.sorted_blocks[0]->payload_data, sort_state);
-	}
-
-	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan the found_match for any chunks we
-	// still need to output
-	const auto found_match = sink.table->found_match.get();
-
-	// ConstructFullOuterJoinResult(sink.table->found_match.get(), sink.right_chunks, chunk,
-	// state.right_outer_position);
-	DataChunk rhs_chunk;
-	rhs_chunk.Initialize(Allocator::Get(context.client), sink.table->global_sort_state.payload_layout.GetTypes());
-	SelectionVector rsel(STANDARD_VECTOR_SIZE);
-	for (;;) {
-		// Read the next sorted chunk
-		state.scanner->Scan(rhs_chunk);
-
-		const auto count = rhs_chunk.size();
-		if (count == 0) {
-			return;
-		}
-
-		idx_t result_count = 0;
-		// figure out which tuples didn't find a match in the RHS
-		for (idx_t i = 0; i < count; i++) {
-			if (!found_match[state.right_outer_position + i]) {
-				rsel.set_index(result_count++, i);
-			}
-		}
-		state.right_outer_position += count;
-
-		if (result_count > 0) {
-			// if there were any tuples that didn't find a match, output them
-			const idx_t left_column_count = children[0]->types.size();
-			for (idx_t col_idx = 0; col_idx < left_column_count; ++col_idx) {
-				result.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(result.data[col_idx], true);
-			}
-			const idx_t right_column_count = children[1]->types.size();
-			;
-			for (idx_t col_idx = 0; col_idx < right_column_count; ++col_idx) {
-				result.data[left_column_count + col_idx].Slice(rhs_chunk.data[col_idx], rsel, result_count);
-			}
-			result.SetCardinality(result_count);
-			return;
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <thread>
-
-namespace duckdb {
-
-PhysicalRangeJoin::LocalSortedTable::LocalSortedTable(Allocator &allocator, const PhysicalRangeJoin &op,
-                                                      const idx_t child)
-    : op(op), executor(allocator), has_null(0), count(0) {
-	// Initialize order clause expression executor and key DataChunk
-	vector<LogicalType> types;
-	for (const auto &cond : op.conditions) {
-		const auto &expr = child ? cond.right : cond.left;
-		executor.AddExpression(*expr);
-
-		types.push_back(expr->return_type);
-	}
-	keys.Initialize(allocator, types);
-}
-
-void PhysicalRangeJoin::LocalSortedTable::Sink(DataChunk &input, GlobalSortState &global_sort_state) {
-	// Initialize local state (if necessary)
-	if (!local_sort_state.initialized) {
-		local_sort_state.Initialize(global_sort_state, global_sort_state.buffer_manager);
-	}
-
-	// Obtain sorting columns
-	keys.Reset();
-	executor.Execute(input, keys);
-
-	// Count the NULLs so we can exclude them later
-	has_null += MergeNulls(op.conditions);
-	count += keys.size();
-
-	//	Only sort the primary key
-	DataChunk join_head;
-	join_head.data.emplace_back(Vector(keys.data[0]));
-	join_head.SetCardinality(keys.size());
-
-	// Sink the data into the local sort state
-	local_sort_state.SinkChunk(join_head, input);
-}
-
-PhysicalRangeJoin::GlobalSortedTable::GlobalSortedTable(ClientContext &context, const vector<BoundOrderByNode> &orders,
-                                                        RowLayout &payload_layout)
-    : global_sort_state(BufferManager::GetBufferManager(context), orders, payload_layout), has_null(0), count(0),
-      memory_per_thread(0) {
-	D_ASSERT(orders.size() == 1);
-
-	// Set external (can be force with the PRAGMA)
-	auto &config = ClientConfig::GetConfig(context);
-	global_sort_state.external = config.force_external;
-	// Memory usage per thread should scale with max mem / num threads
-	// We take 1/4th of this, to be conservative
-	idx_t max_memory = global_sort_state.buffer_manager.GetMaxMemory();
-	idx_t num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
-	memory_per_thread = (max_memory / num_threads) / 4;
-}
-
-void PhysicalRangeJoin::GlobalSortedTable::Combine(LocalSortedTable &ltable) {
-	global_sort_state.AddLocalState(ltable.local_sort_state);
-	has_null += ltable.has_null;
-	count += ltable.count;
-}
-
-void PhysicalRangeJoin::GlobalSortedTable::IntializeMatches() {
-	found_match = unique_ptr<bool[]>(new bool[Count()]);
-	memset(found_match.get(), 0, sizeof(bool) * Count());
-}
-
-void PhysicalRangeJoin::GlobalSortedTable::Print() {
-	global_sort_state.Print();
-}
-
-class RangeJoinMergeTask : public ExecutorTask {
-public:
-	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-public:
-	RangeJoinMergeTask(shared_ptr<Event> event_p, ClientContext &context, GlobalSortedTable &table)
-	    : ExecutorTask(context), event(move(event_p)), context(context), table(table) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		// Initialize iejoin sorted and iterate until done
-		auto &global_sort_state = table.global_sort_state;
-		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
-		merge_sorter.PerformInMergeRound();
-		event->FinishTask();
-
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	shared_ptr<Event> event;
-	ClientContext &context;
-	GlobalSortedTable &table;
-};
-
-class RangeJoinMergeEvent : public Event {
-public:
-	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
-
-public:
-	RangeJoinMergeEvent(GlobalSortedTable &table_p, Pipeline &pipeline_p)
-	    : Event(pipeline_p.executor), table(table_p), pipeline(pipeline_p) {
-	}
-
-	GlobalSortedTable &table;
-	Pipeline &pipeline;
-
-public:
-	void Schedule() override {
-		auto &context = pipeline.GetClientContext();
-
-		// Schedule tasks equal to the number of threads, which will each merge multiple partitions
-		auto &ts = TaskScheduler::GetScheduler(context);
-		idx_t num_threads = ts.NumberOfThreads();
-
-		vector<unique_ptr<Task>> iejoin_tasks;
-		for (idx_t tnum = 0; tnum < num_threads; tnum++) {
-			iejoin_tasks.push_back(make_unique<RangeJoinMergeTask>(shared_from_this(), context, table));
-		}
-		SetTasks(move(iejoin_tasks));
-	}
-
-	void FinishEvent() override {
-		auto &global_sort_state = table.global_sort_state;
-
-		global_sort_state.CompleteMergeRound(true);
-		if (global_sort_state.sorted_blocks.size() > 1) {
-			// Multiple blocks remaining: Schedule the next round
-			table.ScheduleMergeTasks(pipeline, *this);
-		}
-	}
-};
-
-void PhysicalRangeJoin::GlobalSortedTable::ScheduleMergeTasks(Pipeline &pipeline, Event &event) {
-	// Initialize global sort state for a round of merging
-	global_sort_state.InitializeMergeRound();
-	auto new_event = make_shared<RangeJoinMergeEvent>(*this, pipeline);
-	event.InsertEvent(move(new_event));
-}
-
-void PhysicalRangeJoin::GlobalSortedTable::Finalize(Pipeline &pipeline, Event &event) {
-	// Prepare for merge sort phase
-	global_sort_state.PrepareMergePhase();
-
-	// Start the merge phase or finish if a merge is not necessary
-	if (global_sort_state.sorted_blocks.size() > 1) {
-		ScheduleMergeTasks(pipeline, event);
-	}
-}
-
-PhysicalRangeJoin::PhysicalRangeJoin(LogicalOperator &op, PhysicalOperatorType type, unique_ptr<PhysicalOperator> left,
-                                     unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-                                     idx_t estimated_cardinality)
-    : PhysicalComparisonJoin(op, type, move(cond), join_type, estimated_cardinality) {
-	// Reorder the conditions so that ranges are at the front.
-	// TODO: use stats to improve the choice?
-	// TODO: Prefer fixed length types?
-	if (conditions.size() > 1) {
-		auto conditions_p = std::move(conditions);
-		conditions.resize(conditions_p.size());
-		idx_t range_position = 0;
-		idx_t other_position = conditions_p.size();
-		for (idx_t i = 0; i < conditions_p.size(); ++i) {
-			switch (conditions_p[i].comparison) {
-			case ExpressionType::COMPARE_LESSTHAN:
-			case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			case ExpressionType::COMPARE_GREATERTHAN:
-			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-				conditions[range_position++] = std::move(conditions_p[i]);
-				break;
-			default:
-				conditions[--other_position] = std::move(conditions_p[i]);
-				break;
-			}
-		}
-	}
-
-	children.push_back(move(left));
-	children.push_back(move(right));
-}
-
-idx_t PhysicalRangeJoin::LocalSortedTable::MergeNulls(const vector<JoinCondition> &conditions) {
-	// Merge the validity masks of the comparison keys into the primary
-	// Return the number of NULLs in the resulting chunk
-	D_ASSERT(keys.ColumnCount() > 0);
-	const auto count = keys.size();
-
-	size_t all_constant = 0;
-	for (auto &v : keys.data) {
-		if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			++all_constant;
-		}
-	}
-
-	auto &primary = keys.data[0];
-	if (all_constant == keys.data.size()) {
-		//	Either all NULL or no NULLs
-		for (auto &v : keys.data) {
-			if (ConstantVector::IsNull(v)) {
-				ConstantVector::SetNull(primary, true);
-				return count;
-			}
-		}
-		return 0;
-	} else if (keys.ColumnCount() > 1) {
-		//	Normalify the primary, as it will need to merge arbitrary validity masks
-		primary.Normalify(count);
-		auto &pvalidity = FlatVector::Validity(primary);
-		D_ASSERT(keys.ColumnCount() == conditions.size());
-		for (size_t c = 1; c < keys.data.size(); ++c) {
-			// Skip comparisons that accept NULLs
-			if (conditions[c].comparison == ExpressionType::COMPARE_DISTINCT_FROM) {
-				continue;
-			}
-			//	Orrify the rest, as the sort code will do this anyway.
-			auto &v = keys.data[c];
-			VectorData vdata;
-			v.Orrify(count, vdata);
-			auto &vvalidity = vdata.validity;
-			if (vvalidity.AllValid()) {
-				continue;
-			}
-			pvalidity.EnsureWritable();
-			switch (v.GetVectorType()) {
-			case VectorType::FLAT_VECTOR: {
-				// Merge entire entries
-				auto pmask = pvalidity.GetData();
-				const auto entry_count = pvalidity.EntryCount(count);
-				for (idx_t entry_idx = 0; entry_idx < entry_count; ++entry_idx) {
-					pmask[entry_idx] &= vvalidity.GetValidityEntry(entry_idx);
-				}
-				break;
-			}
-			case VectorType::CONSTANT_VECTOR:
-				// All or nothing
-				if (ConstantVector::IsNull(v)) {
-					pvalidity.SetAllInvalid(count);
-					return count;
-				}
-				break;
-			default:
-				// One by one
-				for (idx_t i = 0; i < count; ++i) {
-					const auto idx = vdata.sel->get_index(i);
-					if (!vvalidity.RowIsValidUnsafe(idx)) {
-						pvalidity.SetInvalidUnsafe(i);
-					}
-				}
-				break;
-			}
-		}
-		return count - pvalidity.CountValid(count);
-	} else {
-		return count - VectorOperations::CountNotNull(primary, count);
-	}
-}
-
-void PhysicalRangeJoin::SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
-                                           const SelectionVector &result, const idx_t result_count,
-                                           const idx_t left_cols) {
-	// There should only be one sorted block if they have been sorted
-	D_ASSERT(state.sorted_blocks.size() == 1);
-	SBScanState read_state(state.buffer_manager, state);
-	read_state.sb = state.sorted_blocks[0].get();
-	auto &sorted_data = *read_state.sb->payload_data;
-
-	read_state.SetIndices(block_idx, 0);
-	read_state.PinData(sorted_data);
-	const auto data_ptr = read_state.DataPtr(sorted_data);
-
-	// Set up a batch of pointers to scan data from
-	Vector addresses(LogicalType::POINTER, result_count);
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-
-	// Set up the data pointers for the values that are actually referenced
-	const idx_t &row_width = sorted_data.layout.GetRowWidth();
-
-	auto prev_idx = result.get_index(0);
-	SelectionVector gsel(result_count);
-	idx_t addr_count = 0;
-	gsel.set_index(0, addr_count);
-	data_pointers[addr_count] = data_ptr + prev_idx * row_width;
-	for (idx_t i = 1; i < result_count; ++i) {
-		const auto row_idx = result.get_index(i);
-		if (row_idx != prev_idx) {
-			data_pointers[++addr_count] = data_ptr + row_idx * row_width;
-			prev_idx = row_idx;
-		}
-		gsel.set_index(i, addr_count);
-	}
-	++addr_count;
-
-	// Unswizzle the offsets back to pointers (if needed)
-	if (!sorted_data.layout.AllConstant() && state.external) {
-		RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle.Ptr(),
-		                                 addr_count);
-	}
-
-	// Deserialize the payload data
-	auto sel = FlatVector::IncrementalSelectionVector();
-	for (idx_t col_idx = 0; col_idx < sorted_data.layout.ColumnCount(); col_idx++) {
-		const auto col_offset = sorted_data.layout.GetOffsets()[col_idx];
-		auto &col = payload.data[left_cols + col_idx];
-		RowOperations::Gather(addresses, *sel, col, *sel, addr_count, col_offset, col_idx);
-		col.Slice(gsel, result_count);
-	}
-}
-
-idx_t PhysicalRangeJoin::SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
-                                        const SelectionVector *sel, idx_t count, SelectionVector *true_sel) {
-	switch (condition) {
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return VectorOperations::NotEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return VectorOperations::LessThan(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return VectorOperations::GreaterThan(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return VectorOperations::DistinctFrom(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-	case ExpressionType::COMPARE_EQUAL:
-	default:
-		throw InternalException("Unsupported comparison type for PhysicalRangeJoin");
-	}
-
-	return count;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalOrder::PhysicalOrder(vector<LogicalType> types, vector<BoundOrderByNode> orders, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::ORDER_BY, move(types), estimated_cardinality), orders(move(orders)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class OrderGlobalState : public GlobalSinkState {
-public:
-	OrderGlobalState(BufferManager &buffer_manager, const PhysicalOrder &order, RowLayout &payload_layout)
-	    : global_sort_state(buffer_manager, order.orders, payload_layout) {
-	}
-
-	//! Global sort state
-	GlobalSortState global_sort_state;
-	//! Memory usage per thread
-	idx_t memory_per_thread;
-};
-
-class OrderLocalState : public LocalSinkState {
-public:
-	OrderLocalState(ExecutionContext &context, const vector<BoundOrderByNode> &orders)
-	    : executor(Allocator::Get(context.client)) {
-		// Initialize order clause expression executor and DataChunk
-		vector<LogicalType> types;
-		for (auto &order : orders) {
-			types.push_back(order.expression->return_type);
-			executor.AddExpression(*order.expression);
-		}
-		sort.Initialize(Allocator::Get(context.client), types);
-	}
-
-public:
-	//! The local sort state
-	LocalSortState local_sort_state;
-	//! Local copy of the sorting expression executor
-	ExpressionExecutor executor;
-	//! Holds a vector of incoming sorting columns
-	DataChunk sort;
-};
-
-unique_ptr<GlobalSinkState> PhysicalOrder::GetGlobalSinkState(ClientContext &context) const {
-	// Get the payload layout from the return types
-	RowLayout payload_layout;
-	payload_layout.Initialize(types);
-	auto state = make_unique<OrderGlobalState>(BufferManager::GetBufferManager(context), *this, payload_layout);
-	// Set external (can be force with the PRAGMA)
-	state->global_sort_state.external = ClientConfig::GetConfig(context).force_external;
-	// Memory usage per thread should scale with max mem / num threads
-	// We take 1/4th of this, to be conservative
-	idx_t max_memory = BufferManager::GetBufferManager(context).GetMaxMemory();
-	idx_t num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
-	state->memory_per_thread = (max_memory / num_threads) / 4;
-	return move(state);
-}
-
-unique_ptr<LocalSinkState> PhysicalOrder::GetLocalSinkState(ExecutionContext &context) const {
-	auto result = make_unique<OrderLocalState>(context, orders);
-	return move(result);
-}
-
-SinkResultType PhysicalOrder::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
-                                   DataChunk &input) const {
-	auto &gstate = (OrderGlobalState &)gstate_p;
-	auto &lstate = (OrderLocalState &)lstate_p;
-
-	auto &global_sort_state = gstate.global_sort_state;
-	auto &local_sort_state = lstate.local_sort_state;
-
-	// Initialize local state (if necessary)
-	if (!local_sort_state.initialized) {
-		local_sort_state.Initialize(global_sort_state, BufferManager::GetBufferManager(context.client));
-	}
-
-	// Obtain sorting columns
-	auto &sort = lstate.sort;
-	sort.Reset();
-	lstate.executor.Execute(input, sort);
-
-	// Sink the data into the local sort state
-	sort.Verify();
-	input.Verify();
-	local_sort_state.SinkChunk(sort, input);
-
-	// When sorting data reaches a certain size, we sort it
-	if (local_sort_state.SizeInBytes() >= gstate.memory_per_thread) {
-		local_sort_state.Sort(global_sort_state, true);
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalOrder::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (OrderGlobalState &)gstate_p;
-	auto &lstate = (OrderLocalState &)lstate_p;
-	gstate.global_sort_state.AddLocalState(lstate.local_sort_state);
-}
-
-class PhysicalOrderMergeTask : public ExecutorTask {
-public:
-	PhysicalOrderMergeTask(shared_ptr<Event> event_p, ClientContext &context, OrderGlobalState &state)
-	    : ExecutorTask(context), event(move(event_p)), context(context), state(state) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		// Initialize merge sorted and iterate until done
-		auto &global_sort_state = state.global_sort_state;
-		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
-		merge_sorter.PerformInMergeRound();
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	shared_ptr<Event> event;
-	ClientContext &context;
-	OrderGlobalState &state;
-};
-
-class OrderMergeEvent : public Event {
-public:
-	OrderMergeEvent(OrderGlobalState &gstate_p, Pipeline &pipeline_p)
-	    : Event(pipeline_p.executor), gstate(gstate_p), pipeline(pipeline_p) {
-	}
-
-	OrderGlobalState &gstate;
-	Pipeline &pipeline;
-
-public:
-	void Schedule() override {
-		auto &context = pipeline.GetClientContext();
-
-		// Schedule tasks equal to the number of threads, which will each merge multiple partitions
-		auto &ts = TaskScheduler::GetScheduler(context);
-		idx_t num_threads = ts.NumberOfThreads();
-
-		vector<unique_ptr<Task>> merge_tasks;
-		for (idx_t tnum = 0; tnum < num_threads; tnum++) {
-			merge_tasks.push_back(make_unique<PhysicalOrderMergeTask>(shared_from_this(), context, gstate));
-		}
-		SetTasks(move(merge_tasks));
-	}
-
-	void FinishEvent() override {
-		auto &global_sort_state = gstate.global_sort_state;
-
-		global_sort_state.CompleteMergeRound();
-		if (global_sort_state.sorted_blocks.size() > 1) {
-			// Multiple blocks remaining: Schedule the next round
-			PhysicalOrder::ScheduleMergeTasks(pipeline, *this, gstate);
-		}
-	}
-};
-
-SinkFinalizeType PhysicalOrder::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                         GlobalSinkState &gstate_p) const {
-	auto &state = (OrderGlobalState &)gstate_p;
-	auto &global_sort_state = state.global_sort_state;
-
-	if (global_sort_state.sorted_blocks.empty()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
-
-	// Prepare for merge sort phase
-	global_sort_state.PrepareMergePhase();
-
-	// Start the merge phase or finish if a merge is not necessary
-	if (global_sort_state.sorted_blocks.size() > 1) {
-		PhysicalOrder::ScheduleMergeTasks(pipeline, event, state);
-	}
-	return SinkFinalizeType::READY;
-}
-
-void PhysicalOrder::ScheduleMergeTasks(Pipeline &pipeline, Event &event, OrderGlobalState &state) {
-	// Initialize global sort state for a round of merging
-	state.global_sort_state.InitializeMergeRound();
-	auto new_event = make_shared<OrderMergeEvent>(state, pipeline);
-	event.InsertEvent(move(new_event));
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class PhysicalOrderOperatorState : public GlobalSourceState {
-public:
-	//! Payload scanner
-	unique_ptr<PayloadScanner> scanner;
-};
-
-unique_ptr<GlobalSourceState> PhysicalOrder::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<PhysicalOrderOperatorState>();
-}
-
-void PhysicalOrder::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                            LocalSourceState &lstate) const {
-	auto &state = (PhysicalOrderOperatorState &)gstate;
-
-	if (!state.scanner) {
-		// Initialize scanner (if not yet initialized)
-		auto &gstate = (OrderGlobalState &)*this->sink_state;
-		auto &global_sort_state = gstate.global_sort_state;
-		if (global_sort_state.sorted_blocks.empty()) {
-			return;
-		}
-		state.scanner =
-		    make_unique<PayloadScanner>(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
-	}
-
-	// Scan the next data chunk
-	state.scanner->Scan(chunk);
-}
-
-string PhysicalOrder::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (i > 0) {
-			result += "\n";
-		}
-		result += orders[i].expression->ToString() + " ";
-		result += orders[i].type == OrderType::DESCENDING ? "DESC" : "ASC";
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalTopN::PhysicalTopN(vector<LogicalType> types, vector<BoundOrderByNode> orders, idx_t limit, idx_t offset,
-                           idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::TOP_N, move(types), estimated_cardinality), orders(move(orders)),
-      limit(limit), offset(offset) {
-}
-
-//===--------------------------------------------------------------------===//
-// Heaps
-//===--------------------------------------------------------------------===//
-class TopNHeap;
-
-struct TopNScanState {
-	unique_ptr<PayloadScanner> scanner;
-	idx_t pos;
-	bool exclude_offset;
-};
-
-class TopNSortState {
-public:
-	explicit TopNSortState(TopNHeap &heap);
-
-	TopNHeap &heap;
-	unique_ptr<LocalSortState> local_state;
-	unique_ptr<GlobalSortState> global_state;
-	idx_t count;
-	bool is_sorted;
-
-public:
-	void Initialize();
-	void Append(DataChunk &sort_chunk, DataChunk &payload);
-
-	void Sink(DataChunk &input);
-	void Finalize();
-
-	void Move(TopNSortState &other);
-
-	void InitializeScan(TopNScanState &state, bool exclude_offset);
-	void Scan(TopNScanState &state, DataChunk &chunk);
-};
-
-class TopNHeap {
-public:
-	TopNHeap(ClientContext &context, const vector<LogicalType> &payload_types, const vector<BoundOrderByNode> &orders,
-	         idx_t limit, idx_t offset);
-	TopNHeap(ExecutionContext &context, const vector<LogicalType> &payload_types,
-	         const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset);
-	TopNHeap(BufferManager &buffer_manager, Allocator &allocator, const vector<LogicalType> &payload_types,
-	         const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset);
-
-	Allocator &allocator;
-	BufferManager &buffer_manager;
-	const vector<LogicalType> &payload_types;
-	const vector<BoundOrderByNode> &orders;
-	idx_t limit;
-	idx_t offset;
-	TopNSortState sort_state;
-	ExpressionExecutor executor;
-	DataChunk sort_chunk;
-	DataChunk compare_chunk;
-	DataChunk payload_chunk;
-	//! A set of boundary values that determine either the minimum or the maximum value we have to consider for our
-	//! top-n
-	DataChunk boundary_values;
-	//! Whether or not the boundary_values has been set. The boundary_values are only set after a reduce step
-	bool has_boundary_values;
-
-	SelectionVector final_sel;
-	SelectionVector true_sel;
-	SelectionVector false_sel;
-	SelectionVector new_remaining_sel;
-
-public:
-	void Sink(DataChunk &input);
-	void Combine(TopNHeap &other);
-	void Reduce();
-	void Finalize();
-
-	void ExtractBoundaryValues(DataChunk &current_chunk, DataChunk &prev_chunk);
-
-	void InitializeScan(TopNScanState &state, bool exclude_offset);
-	void Scan(TopNScanState &state, DataChunk &chunk);
-
-	bool CheckBoundaryValues(DataChunk &sort_chunk, DataChunk &payload);
-};
-
-//===--------------------------------------------------------------------===//
-// TopNSortState
-//===--------------------------------------------------------------------===//
-TopNSortState::TopNSortState(TopNHeap &heap) : heap(heap), count(0), is_sorted(false) {
-}
-
-void TopNSortState::Initialize() {
-	RowLayout layout;
-	layout.Initialize(heap.payload_types);
-	auto &buffer_manager = heap.buffer_manager;
-	global_state = make_unique<GlobalSortState>(buffer_manager, heap.orders, layout);
-	local_state = make_unique<LocalSortState>();
-	local_state->Initialize(*global_state, buffer_manager);
-}
-
-void TopNSortState::Append(DataChunk &sort_chunk, DataChunk &payload) {
-	D_ASSERT(!is_sorted);
-	if (heap.has_boundary_values) {
-		if (!heap.CheckBoundaryValues(sort_chunk, payload)) {
-			return;
-		}
-	}
-
-	local_state->SinkChunk(sort_chunk, payload);
-	count += payload.size();
-}
-
-void TopNSortState::Sink(DataChunk &input) {
-	// compute the ordering values for the new chunk
-	heap.sort_chunk.Reset();
-	heap.executor.Execute(input, heap.sort_chunk);
-
-	// append the new chunk to what we have already
-	Append(heap.sort_chunk, input);
-}
-
-void TopNSortState::Move(TopNSortState &other) {
-	local_state = move(other.local_state);
-	global_state = move(other.global_state);
-	count = other.count;
-	is_sorted = other.is_sorted;
-}
-
-void TopNSortState::Finalize() {
-	D_ASSERT(!is_sorted);
-	global_state->AddLocalState(*local_state);
-
-	global_state->PrepareMergePhase();
-	while (global_state->sorted_blocks.size() > 1) {
-		MergeSorter merge_sorter(*global_state, heap.buffer_manager);
-		merge_sorter.PerformInMergeRound();
-		global_state->CompleteMergeRound();
-	}
-	is_sorted = true;
-}
-
-void TopNSortState::InitializeScan(TopNScanState &state, bool exclude_offset) {
-	D_ASSERT(is_sorted);
-	if (global_state->sorted_blocks.empty()) {
-		state.scanner = nullptr;
-	} else {
-		D_ASSERT(global_state->sorted_blocks.size() == 1);
-		state.scanner = make_unique<PayloadScanner>(*global_state->sorted_blocks[0]->payload_data, *global_state);
-	}
-	state.pos = 0;
-	state.exclude_offset = exclude_offset && heap.offset > 0;
-}
-
-void TopNSortState::Scan(TopNScanState &state, DataChunk &chunk) {
-	if (!state.scanner) {
-		return;
-	}
-	auto offset = heap.offset;
-	auto limit = heap.limit;
-	D_ASSERT(is_sorted);
-	while (chunk.size() == 0) {
-		state.scanner->Scan(chunk);
-		if (chunk.size() == 0) {
-			break;
-		}
-		idx_t start = state.pos;
-		idx_t end = state.pos + chunk.size();
-		state.pos = end;
-
-		idx_t chunk_start = 0;
-		idx_t chunk_end = chunk.size();
-		if (state.exclude_offset) {
-			// we need to exclude all tuples before the OFFSET
-			// check if we should include anything
-			if (end <= offset) {
-				// end is smaller than offset: include nothing!
-				chunk.Reset();
-				continue;
-			} else if (start < offset) {
-				// we need to slice
-				chunk_start = offset - start;
-			}
-		}
-		// check if we need to truncate at the offset + limit mark
-		if (start >= offset + limit) {
-			// we are finished
-			chunk_end = 0;
-		} else if (end > offset + limit) {
-			// the end extends past the offset + limit
-			// truncate the current chunk
-			chunk_end = offset + limit - start;
-		}
-		D_ASSERT(chunk_end - chunk_start <= STANDARD_VECTOR_SIZE);
-		if (chunk_end == chunk_start) {
-			chunk.Reset();
-			break;
-		} else if (chunk_start > 0) {
-			SelectionVector sel(STANDARD_VECTOR_SIZE);
-			for (idx_t i = chunk_start; i < chunk_end; i++) {
-				sel.set_index(i - chunk_start, i);
-			}
-			chunk.Slice(sel, chunk_end - chunk_start);
-		} else if (chunk_end != chunk.size()) {
-			chunk.SetCardinality(chunk_end);
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// TopNHeap
-//===--------------------------------------------------------------------===//
-TopNHeap::TopNHeap(BufferManager &buffer_manager, Allocator &allocator, const vector<LogicalType> &payload_types_p,
-                   const vector<BoundOrderByNode> &orders_p, idx_t limit, idx_t offset)
-    : allocator(allocator), buffer_manager(buffer_manager), payload_types(payload_types_p), orders(orders_p),
-      limit(limit), offset(offset), sort_state(*this), executor(allocator), has_boundary_values(false),
-      final_sel(STANDARD_VECTOR_SIZE), true_sel(STANDARD_VECTOR_SIZE), false_sel(STANDARD_VECTOR_SIZE),
-      new_remaining_sel(STANDARD_VECTOR_SIZE) {
-	// initialize the executor and the sort_chunk
-	vector<LogicalType> sort_types;
-	for (auto &order : orders) {
-		auto &expr = order.expression;
-		sort_types.push_back(expr->return_type);
-		executor.AddExpression(*expr);
-	}
-	payload_chunk.Initialize(allocator, payload_types);
-	sort_chunk.Initialize(allocator, sort_types);
-	compare_chunk.Initialize(allocator, sort_types);
-	boundary_values.Initialize(allocator, sort_types);
-	sort_state.Initialize();
-}
-
-TopNHeap::TopNHeap(ClientContext &context, const vector<LogicalType> &payload_types,
-                   const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset)
-    : TopNHeap(BufferManager::GetBufferManager(context), BufferAllocator::Get(context), payload_types, orders, limit,
-               offset) {
-}
-
-TopNHeap::TopNHeap(ExecutionContext &context, const vector<LogicalType> &payload_types,
-                   const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset)
-    : TopNHeap(BufferManager::GetBufferManager(context.client), Allocator::Get(context.client), payload_types, orders,
-               limit, offset) {
-}
-
-void TopNHeap::Sink(DataChunk &input) {
-	sort_state.Sink(input);
-}
-
-void TopNHeap::Combine(TopNHeap &other) {
-	other.Finalize();
-
-	TopNScanState state;
-	other.InitializeScan(state, false);
-	while (true) {
-		payload_chunk.Reset();
-		other.Scan(state, payload_chunk);
-		if (payload_chunk.size() == 0) {
-			break;
-		}
-		Sink(payload_chunk);
-	}
-	Reduce();
-}
-
-void TopNHeap::Finalize() {
-	sort_state.Finalize();
-}
-
-void TopNHeap::Reduce() {
-	idx_t min_sort_threshold = MaxValue<idx_t>(STANDARD_VECTOR_SIZE * 5, 2 * (limit + offset));
-	if (sort_state.count < min_sort_threshold) {
-		// only reduce when we pass two times the limit + offset, or 5 vectors (whichever comes first)
-		return;
-	}
-	sort_state.Finalize();
-	TopNSortState new_state(*this);
-	new_state.Initialize();
-
-	TopNScanState state;
-	sort_state.InitializeScan(state, false);
-
-	DataChunk new_chunk;
-	new_chunk.Initialize(allocator, payload_types);
-
-	DataChunk *current_chunk = &new_chunk;
-	DataChunk *prev_chunk = &payload_chunk;
-	has_boundary_values = false;
-	while (true) {
-		current_chunk->Reset();
-		Scan(state, *current_chunk);
-		if (current_chunk->size() == 0) {
-			ExtractBoundaryValues(*current_chunk, *prev_chunk);
-			break;
-		}
-		new_state.Sink(*current_chunk);
-		std::swap(current_chunk, prev_chunk);
-	}
-
-	sort_state.Move(new_state);
-}
-
-void TopNHeap::ExtractBoundaryValues(DataChunk &current_chunk, DataChunk &prev_chunk) {
-	// extract the last entry of the prev_chunk and set as minimum value
-	D_ASSERT(prev_chunk.size() > 0);
-	for (idx_t col_idx = 0; col_idx < current_chunk.ColumnCount(); col_idx++) {
-		ConstantVector::Reference(current_chunk.data[col_idx], prev_chunk.data[col_idx], prev_chunk.size() - 1,
-		                          prev_chunk.size());
-	}
-	current_chunk.SetCardinality(1);
-	sort_chunk.Reset();
-	executor.Execute(&current_chunk, sort_chunk);
-
-	boundary_values.Reset();
-	boundary_values.Append(sort_chunk);
-	boundary_values.SetCardinality(1);
-	for (idx_t i = 0; i < boundary_values.ColumnCount(); i++) {
-		boundary_values.data[i].SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-	has_boundary_values = true;
-}
-
-bool TopNHeap::CheckBoundaryValues(DataChunk &sort_chunk, DataChunk &payload) {
-	// we have boundary values
-	// from these boundary values, determine which values we should insert (if any)
-	idx_t final_count = 0;
-
-	SelectionVector remaining_sel(nullptr);
-	idx_t remaining_count = sort_chunk.size();
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (remaining_sel.data()) {
-			compare_chunk.data[i].Slice(sort_chunk.data[i], remaining_sel, remaining_count);
-		} else {
-			compare_chunk.data[i].Reference(sort_chunk.data[i]);
-		}
-		bool is_last = i + 1 == orders.size();
-		idx_t true_count;
-		if (orders[i].null_order == OrderByNullType::NULLS_LAST) {
-			if (orders[i].type == OrderType::ASCENDING) {
-				true_count = VectorOperations::DistinctLessThan(compare_chunk.data[i], boundary_values.data[i],
-				                                                &remaining_sel, remaining_count, &true_sel, &false_sel);
-			} else {
-				true_count = VectorOperations::DistinctGreaterThanNullsFirst(compare_chunk.data[i],
-				                                                             boundary_values.data[i], &remaining_sel,
-				                                                             remaining_count, &true_sel, &false_sel);
-			}
-		} else {
-			D_ASSERT(orders[i].null_order == OrderByNullType::NULLS_FIRST);
-			if (orders[i].type == OrderType::ASCENDING) {
-				true_count = VectorOperations::DistinctLessThanNullsFirst(compare_chunk.data[i],
-				                                                          boundary_values.data[i], &remaining_sel,
-				                                                          remaining_count, &true_sel, &false_sel);
-			} else {
-				true_count =
-				    VectorOperations::DistinctGreaterThan(compare_chunk.data[i], boundary_values.data[i],
-				                                          &remaining_sel, remaining_count, &true_sel, &false_sel);
-			}
-		}
-
-		if (true_count > 0) {
-			memcpy(final_sel.data() + final_count, true_sel.data(), true_count * sizeof(sel_t));
-			final_count += true_count;
-		}
-		idx_t false_count = remaining_count - true_count;
-		if (false_count > 0) {
-			// check what we should continue to check
-			compare_chunk.data[i].Slice(sort_chunk.data[i], false_sel, false_count);
-			remaining_count = VectorOperations::NotDistinctFrom(compare_chunk.data[i], boundary_values.data[i],
-			                                                    &false_sel, false_count, &new_remaining_sel, nullptr);
-			if (is_last) {
-				memcpy(final_sel.data() + final_count, new_remaining_sel.data(), remaining_count * sizeof(sel_t));
-				final_count += remaining_count;
-			} else {
-				remaining_sel.Initialize(new_remaining_sel);
-			}
-		} else {
-			break;
-		}
-	}
-	if (final_count == 0) {
-		return false;
-	}
-	if (final_count < sort_chunk.size()) {
-		sort_chunk.Slice(final_sel, final_count);
-		payload.Slice(final_sel, final_count);
-	}
-	return true;
-}
-
-void TopNHeap::InitializeScan(TopNScanState &state, bool exclude_offset) {
-	sort_state.InitializeScan(state, exclude_offset);
-}
-
-void TopNHeap::Scan(TopNScanState &state, DataChunk &chunk) {
-	sort_state.Scan(state, chunk);
-}
-
-class TopNGlobalState : public GlobalSinkState {
-public:
-	TopNGlobalState(ClientContext &context, const vector<LogicalType> &payload_types,
-	                const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset)
-	    : heap(context, payload_types, orders, limit, offset) {
-	}
-
-	mutex lock;
-	TopNHeap heap;
-};
-
-class TopNLocalState : public LocalSinkState {
-public:
-	TopNLocalState(ExecutionContext &context, const vector<LogicalType> &payload_types,
-	               const vector<BoundOrderByNode> &orders, idx_t limit, idx_t offset)
-	    : heap(context, payload_types, orders, limit, offset) {
-	}
-
-	TopNHeap heap;
-};
-
-unique_ptr<LocalSinkState> PhysicalTopN::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<TopNLocalState>(context, types, orders, limit, offset);
-}
-
-unique_ptr<GlobalSinkState> PhysicalTopN::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<TopNGlobalState>(context, types, orders, limit, offset);
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-SinkResultType PhysicalTopN::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                  DataChunk &input) const {
-	// append to the local sink state
-	auto &sink = (TopNLocalState &)lstate;
-	sink.heap.Sink(input);
-	sink.heap.Reduce();
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-void PhysicalTopN::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const {
-	auto &gstate = (TopNGlobalState &)state;
-	auto &lstate = (TopNLocalState &)lstate_p;
-
-	// scan the local top N and append it to the global heap
-	lock_guard<mutex> glock(gstate.lock);
-	gstate.heap.Combine(lstate.heap);
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-SinkFinalizeType PhysicalTopN::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                        GlobalSinkState &gstate_p) const {
-	auto &gstate = (TopNGlobalState &)gstate_p;
-	// global finalize: compute the final top N
-	gstate.heap.Finalize();
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class TopNOperatorState : public GlobalSourceState {
-public:
-	TopNScanState state;
-	bool initialized = false;
-};
-
-unique_ptr<GlobalSourceState> PhysicalTopN::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<TopNOperatorState>();
-}
-
-void PhysicalTopN::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                           LocalSourceState &lstate) const {
-	if (limit == 0) {
-		return;
-	}
-	auto &state = (TopNOperatorState &)gstate_p;
-	auto &gstate = (TopNGlobalState &)*sink_state;
-
-	if (!state.initialized) {
-		gstate.heap.InitializeScan(state.state, true);
-		state.initialized = true;
-	}
-	gstate.heap.Scan(state.state, chunk);
-}
-
-string PhysicalTopN::ParamsToString() const {
-	string result;
-	result += "Top " + to_string(limit);
-	if (offset > 0) {
-		result += "\n";
-		result += "Offset " + to_string(offset);
-	}
-	result += "\n[INFOSEPARATOR]";
-	for (idx_t i = 0; i < orders.size(); i++) {
-		result += "\n";
-		result += orders[i].expression->ToString() + " ";
-		result += orders[i].type == OrderType::DESCENDING ? "DESC" : "ASC";
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-#include <cctype>
-#include <cstring>
-#include <fstream>
-
-namespace duckdb {
-
-static bool ParseBoolean(const Value &value, const string &loption);
-
-static bool ParseBoolean(const vector<Value> &set, const string &loption) {
-	if (set.empty()) {
-		// no option specified: default to true
-		return true;
-	}
-	if (set.size() > 1) {
-		throw BinderException("\"%s\" expects a single argument as a boolean value (e.g. TRUE or 1)", loption);
-	}
-	return ParseBoolean(set[0], loption);
-}
-
-static bool ParseBoolean(const Value &value, const string &loption) {
-
-	if (value.type().id() == LogicalTypeId::LIST) {
-		auto &children = ListValue::GetChildren(value);
-		return ParseBoolean(children, loption);
-	}
-	if (value.type() == LogicalType::FLOAT || value.type() == LogicalType::DOUBLE ||
-	    value.type().id() == LogicalTypeId::DECIMAL) {
-		throw BinderException("\"%s\" expects a boolean value (e.g. TRUE or 1)", loption);
-	}
-	return BooleanValue::Get(value.CastAs(LogicalType::BOOLEAN));
-}
-
-static string ParseString(const Value &value, const string &loption) {
-	if (value.type().id() == LogicalTypeId::LIST) {
-		auto &children = ListValue::GetChildren(value);
-		if (children.size() != 1) {
-			throw BinderException("\"%s\" expects a single argument as a string value", loption);
-		}
-		return ParseString(children[0], loption);
-	}
-	if (value.type().id() != LogicalTypeId::VARCHAR) {
-		throw BinderException("\"%s\" expects a string argument!", loption);
-	}
-	return value.GetValue<string>();
-}
-
-static int64_t ParseInteger(const Value &value, const string &loption) {
-	if (value.type().id() == LogicalTypeId::LIST) {
-		auto &children = ListValue::GetChildren(value);
-		if (children.size() != 1) {
-			// no option specified or multiple options specified
-			throw BinderException("\"%s\" expects a single argument as an integer value", loption);
-		}
-		return ParseInteger(children[0], loption);
-	}
-	return value.GetValue<int64_t>();
-}
-
-static vector<bool> ParseColumnList(const vector<Value> &set, vector<string> &names, const string &loption) {
-	vector<bool> result;
-
-	if (set.empty()) {
-		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
-	}
-	// list of options: parse the list
-	unordered_map<string, bool> option_map;
-	for (idx_t i = 0; i < set.size(); i++) {
-		option_map[set[i].ToString()] = false;
-	}
-	result.resize(names.size(), false);
-	for (idx_t i = 0; i < names.size(); i++) {
-		auto entry = option_map.find(names[i]);
-		if (entry != option_map.end()) {
-			result[i] = true;
-			entry->second = true;
-		}
-	}
-	for (auto &entry : option_map) {
-		if (!entry.second) {
-			throw BinderException("\"%s\" expected to find %s, but it was not found in the table", loption,
-			                      entry.first.c_str());
-		}
-	}
-	return result;
-}
-
-static vector<bool> ParseColumnList(const Value &value, vector<string> &names, const string &loption) {
-	vector<bool> result;
-
-	// Only accept a list of arguments
-	if (value.type().id() != LogicalTypeId::LIST) {
-		// Support a single argument if it's '*'
-		if (value.type().id() == LogicalTypeId::VARCHAR && value.GetValue<string>() == "*") {
-			result.resize(names.size(), true);
-			return result;
-		}
-		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
-	}
-	auto &children = ListValue::GetChildren(value);
-	// accept '*' as single argument
-	if (children.size() == 1 && children[0].type().id() == LogicalTypeId::VARCHAR &&
-	    children[0].GetValue<string>() == "*") {
-		result.resize(names.size(), true);
-		return result;
-	}
-	return ParseColumnList(children, names, loption);
-}
-
-struct CSVFileHandle {
-public:
-	explicit CSVFileHandle(unique_ptr<FileHandle> file_handle_p) : file_handle(move(file_handle_p)) {
-		can_seek = file_handle->CanSeek();
-		plain_file_source = file_handle->OnDiskFile() && can_seek;
-		file_size = file_handle->GetFileSize();
-	}
-
-	bool CanSeek() {
-		return can_seek;
-	}
-	void Seek(idx_t position) {
-		if (!can_seek) {
-			throw InternalException("Cannot seek in this file");
-		}
-		file_handle->Seek(position);
-	}
-	idx_t SeekPosition() {
-		if (!can_seek) {
-			throw InternalException("Cannot seek in this file");
-		}
-		return file_handle->SeekPosition();
-	}
-	void Reset() {
-		if (plain_file_source) {
-			file_handle->Reset();
-		} else {
-			if (!reset_enabled) {
-				throw InternalException("Reset called but reset is not enabled for this CSV Handle");
-			}
-			read_position = 0;
-		}
-	}
-	bool PlainFileSource() {
-		return plain_file_source;
-	}
-
-	bool OnDiskFile() {
-		return file_handle->OnDiskFile();
-	}
-
-	idx_t FileSize() {
-		return file_size;
-	}
-
-	idx_t Read(void *buffer, idx_t nr_bytes) {
-		if (!plain_file_source) {
-			// not a plain file source: we need to do some bookkeeping around the reset functionality
-			idx_t result_offset = 0;
-			if (read_position < buffer_size) {
-				// we need to read from our cached buffer
-				auto buffer_read_count = MinValue<idx_t>(nr_bytes, buffer_size - read_position);
-				memcpy(buffer, cached_buffer.get() + read_position, buffer_read_count);
-				result_offset += buffer_read_count;
-				read_position += buffer_read_count;
-				if (result_offset == nr_bytes) {
-					return nr_bytes;
-				}
-			} else if (!reset_enabled && cached_buffer) {
-				// reset is disabled but we still have cached data
-				// we can remove any cached data
-				cached_buffer.reset();
-				buffer_size = 0;
-				buffer_capacity = 0;
-				read_position = 0;
-			}
-			// we have data left to read from the file
-			// read directly into the buffer
-			auto bytes_read = file_handle->Read((char *)buffer + result_offset, nr_bytes - result_offset);
-			read_position += bytes_read;
-			if (reset_enabled) {
-				// if reset caching is enabled, we need to cache the bytes that we have read
-				if (buffer_size + bytes_read >= buffer_capacity) {
-					// no space; first enlarge the buffer
-					buffer_capacity = MaxValue<idx_t>(NextPowerOfTwo(buffer_size + bytes_read), buffer_capacity * 2);
-
-					auto new_buffer = unique_ptr<data_t[]>(new data_t[buffer_capacity]);
-					if (buffer_size > 0) {
-						memcpy(new_buffer.get(), cached_buffer.get(), buffer_size);
-					}
-					cached_buffer = move(new_buffer);
-				}
-				memcpy(cached_buffer.get() + buffer_size, (char *)buffer + result_offset, bytes_read);
-				buffer_size += bytes_read;
-			}
-
-			return result_offset + bytes_read;
-		} else {
-			return file_handle->Read(buffer, nr_bytes);
-		}
-	}
-
-	string ReadLine() {
-		string result;
-		char buffer[1];
-		while (true) {
-			idx_t tuples_read = Read(buffer, 1);
-			if (tuples_read == 0 || buffer[0] == '\n') {
-				return result;
-			}
-			if (buffer[0] != '\r') {
-				result += buffer[0];
-			}
-		}
-	}
-
-	void DisableReset() {
-		this->reset_enabled = false;
-	}
-
-private:
-	unique_ptr<FileHandle> file_handle;
-	bool reset_enabled = true;
-	bool can_seek = false;
-	bool plain_file_source = false;
-	idx_t file_size = 0;
-	// reset support
-	unique_ptr<data_t[]> cached_buffer;
-	idx_t read_position = 0;
-	idx_t buffer_size = 0;
-	idx_t buffer_capacity = 0;
-};
-
-void BufferedCSVReaderOptions::SetDelimiter(const string &input) {
-	this->delimiter = StringUtil::Replace(input, "\\t", "\t");
-	this->has_delimiter = true;
-	if (input.empty()) {
-		this->delimiter = string("\0", 1);
-	}
-}
-
-void BufferedCSVReaderOptions::SetDateFormat(LogicalTypeId type, const string &format, bool read_format) {
-	string error;
-	if (read_format) {
-		auto &date_format = this->date_format[type];
-		error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
-		date_format.format_specifier = format;
-	} else {
-		auto &date_format = this->write_date_format[type];
-		error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
-	}
-	if (!error.empty()) {
-		throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
-	}
-	has_format[type] = true;
-}
-
-void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value &value,
-                                             vector<string> &expected_names) {
-	if (SetBaseOption(loption, value)) {
-		return;
-	}
-	if (loption == "auto_detect") {
-		auto_detect = ParseBoolean(value, loption);
-	} else if (loption == "sample_size") {
-		int64_t sample_size = ParseInteger(value, loption);
-		if (sample_size < 1 && sample_size != -1) {
-			throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1");
-		}
-		if (sample_size == -1) {
-			sample_chunks = std::numeric_limits<uint64_t>::max();
-			sample_chunk_size = STANDARD_VECTOR_SIZE;
-		} else if (sample_size <= STANDARD_VECTOR_SIZE) {
-			sample_chunk_size = sample_size;
-			sample_chunks = 1;
-		} else {
-			sample_chunk_size = STANDARD_VECTOR_SIZE;
-			sample_chunks = sample_size / STANDARD_VECTOR_SIZE;
-		}
-	} else if (loption == "skip") {
-		skip_rows = ParseInteger(value, loption);
-	} else if (loption == "max_line_size" || loption == "maximum_line_size") {
-		maximum_line_size = ParseInteger(value, loption);
-	} else if (loption == "sample_chunk_size") {
-		sample_chunk_size = ParseInteger(value, loption);
-		if (sample_chunk_size > STANDARD_VECTOR_SIZE) {
-			throw BinderException(
-			    "Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be bigger than STANDARD_VECTOR_SIZE %d",
-			    STANDARD_VECTOR_SIZE);
-		} else if (sample_chunk_size < 1) {
-			throw BinderException("Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be smaller than 1");
-		}
-	} else if (loption == "sample_chunks") {
-		sample_chunks = ParseInteger(value, loption);
-		if (sample_chunks < 1) {
-			throw BinderException("Unsupported parameter for SAMPLE_CHUNKS: cannot be smaller than 1");
-		}
-	} else if (loption == "force_not_null") {
-		force_not_null = ParseColumnList(value, expected_names, loption);
-	} else if (loption == "date_format" || loption == "dateformat") {
-		string format = ParseString(value, loption);
-		SetDateFormat(LogicalTypeId::DATE, format, true);
-	} else if (loption == "timestamp_format" || loption == "timestampformat") {
-		string format = ParseString(value, loption);
-		SetDateFormat(LogicalTypeId::TIMESTAMP, format, true);
-	} else if (loption == "escape") {
-		escape = ParseString(value, loption);
-		has_escape = true;
-	} else if (loption == "ignore_errors") {
-		ignore_errors = ParseBoolean(value, loption);
-	} else {
-		throw BinderException("Unrecognized option for CSV reader \"%s\"", loption);
-	}
-}
-
-void BufferedCSVReaderOptions::SetWriteOption(const string &loption, const Value &value) {
-	if (SetBaseOption(loption, value)) {
-		return;
-	}
-
-	if (loption == "force_quote") {
-		force_quote = ParseColumnList(value, names, loption);
-	} else if (loption == "date_format" || loption == "dateformat") {
-		string format = ParseString(value, loption);
-		SetDateFormat(LogicalTypeId::DATE, format, false);
-	} else if (loption == "timestamp_format" || loption == "timestampformat") {
-		string format = ParseString(value, loption);
-		if (StringUtil::Lower(format) == "iso") {
-			format = "%Y-%m-%dT%H:%M:%S.%fZ";
-		}
-		SetDateFormat(LogicalTypeId::TIMESTAMP, format, false);
-	} else {
-		throw BinderException("Unrecognized option CSV writer \"%s\"", loption);
-	}
-}
-
-bool BufferedCSVReaderOptions::SetBaseOption(const string &loption, const Value &value) {
-	// Make sure this function was only called after the option was turned into lowercase
-	D_ASSERT(!std::any_of(loption.begin(), loption.end(), ::isupper));
-
-	if (StringUtil::StartsWith(loption, "delim") || StringUtil::StartsWith(loption, "sep")) {
-		SetDelimiter(ParseString(value, loption));
-	} else if (loption == "quote") {
-		quote = ParseString(value, loption);
-		has_quote = true;
-	} else if (loption == "escape") {
-		escape = ParseString(value, loption);
-		has_escape = true;
-	} else if (loption == "header") {
-		header = ParseBoolean(value, loption);
-		has_header = true;
-	} else if (loption == "null" || loption == "nullstr") {
-		null_str = ParseString(value, loption);
-	} else if (loption == "encoding") {
-		auto encoding = StringUtil::Lower(ParseString(value, loption));
-		if (encoding != "utf8" && encoding != "utf-8") {
-			throw BinderException("Copy is only supported for UTF-8 encoded files, ENCODING 'UTF-8'");
-		}
-	} else if (loption == "compression") {
-		compression = FileCompressionTypeFromString(ParseString(value, loption));
-	} else {
-		// unrecognized option in base CSV
-		return false;
-	}
-	return true;
-}
-
-std::string BufferedCSVReaderOptions::ToString() const {
-	return "DELIMITER='" + delimiter + (has_delimiter ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
-	       ", QUOTE='" + quote + (has_quote ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
-	       ", ESCAPE='" + escape + (has_escape ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
-	       ", HEADER=" + std::to_string(header) +
-	       (has_header ? "" : (auto_detect ? " (auto detected)" : "' (default)")) +
-	       ", SAMPLE_SIZE=" + std::to_string(sample_chunk_size * sample_chunks) +
-	       ", IGNORE_ERRORS=" + std::to_string(ignore_errors) + ", ALL_VARCHAR=" + std::to_string(all_varchar);
-}
-
-static string GetLineNumberStr(idx_t linenr, bool linenr_estimated) {
-	string estimated = (linenr_estimated ? string(" (estimated)") : string(""));
-	return to_string(linenr + 1) + estimated;
-}
-
-static bool StartsWithNumericDate(string &separator, const string &value) {
-	auto begin = value.c_str();
-	auto end = begin + value.size();
-
-	//	StrpTimeFormat::Parse will skip whitespace, so we can too
-	auto field1 = std::find_if_not(begin, end, StringUtil::CharacterIsSpace);
-	if (field1 == end) {
-		return false;
-	}
-
-	//	first numeric field must start immediately
-	if (!StringUtil::CharacterIsDigit(*field1)) {
-		return false;
-	}
-	auto literal1 = std::find_if_not(field1, end, StringUtil::CharacterIsDigit);
-	if (literal1 == end) {
-		return false;
-	}
-
-	//	second numeric field must exist
-	auto field2 = std::find_if(literal1, end, StringUtil::CharacterIsDigit);
-	if (field2 == end) {
-		return false;
-	}
-	auto literal2 = std::find_if_not(field2, end, StringUtil::CharacterIsDigit);
-	if (literal2 == end) {
-		return false;
-	}
-
-	//	third numeric field must exist
-	auto field3 = std::find_if(literal2, end, StringUtil::CharacterIsDigit);
-	if (field3 == end) {
-		return false;
-	}
-
-	//	second literal must match first
-	if (((field3 - literal2) != (field2 - literal1)) || strncmp(literal1, literal2, (field2 - literal1)) != 0) {
-		return false;
-	}
-
-	//	copy the literal as the separator, escaping percent signs
-	separator.clear();
-	while (literal1 < field2) {
-		const auto literal_char = *literal1++;
-		if (literal_char == '%') {
-			separator.push_back(literal_char);
-		}
-		separator.push_back(literal_char);
-	}
-
-	return true;
-}
-
-string GenerateDateFormat(const string &separator, const char *format_template) {
-	string format_specifier = format_template;
-
-	//	replace all dashes with the separator
-	for (auto pos = std::find(format_specifier.begin(), format_specifier.end(), '-'); pos != format_specifier.end();
-	     pos = std::find(pos + separator.size(), format_specifier.end(), '-')) {
-		format_specifier.replace(pos, pos + 1, separator);
-	}
-
-	return format_specifier;
-}
-
-TextSearchShiftArray::TextSearchShiftArray() {
-}
-
-TextSearchShiftArray::TextSearchShiftArray(string search_term) : length(search_term.size()) {
-	if (length > 255) {
-		throw Exception("Size of delimiter/quote/escape in CSV reader is limited to 255 bytes");
-	}
-	// initialize the shifts array
-	shifts = unique_ptr<uint8_t[]>(new uint8_t[length * 255]);
-	memset(shifts.get(), 0, length * 255 * sizeof(uint8_t));
-	// iterate over each of the characters in the array
-	for (idx_t main_idx = 0; main_idx < length; main_idx++) {
-		uint8_t current_char = (uint8_t)search_term[main_idx];
-		// now move over all the remaining positions
-		for (idx_t i = main_idx; i < length; i++) {
-			bool is_match = true;
-			// check if the prefix matches at this position
-			// if it does, we move to this position after encountering the current character
-			for (idx_t j = 0; j < main_idx; j++) {
-				if (search_term[i - main_idx + j] != search_term[j]) {
-					is_match = false;
-				}
-			}
-			if (!is_match) {
-				continue;
-			}
-			shifts[i * 255 + current_char] = main_idx + 1;
-		}
-	}
-}
-
-BufferedCSVReader::BufferedCSVReader(FileSystem &fs_p, Allocator &allocator, FileOpener *opener_p,
-                                     BufferedCSVReaderOptions options_p, const vector<LogicalType> &requested_types)
-    : fs(fs_p), allocator(allocator), opener(opener_p), options(move(options_p)), buffer_size(0), position(0),
-      start(0) {
-	file_handle = OpenCSV(options);
-	Initialize(requested_types);
-}
-
-BufferedCSVReader::BufferedCSVReader(ClientContext &context, BufferedCSVReaderOptions options_p,
-                                     const vector<LogicalType> &requested_types)
-    : BufferedCSVReader(FileSystem::GetFileSystem(context), Allocator::Get(context), FileSystem::GetFileOpener(context),
-                        move(options_p), requested_types) {
-}
-
-BufferedCSVReader::~BufferedCSVReader() {
-}
-
-idx_t BufferedCSVReader::GetFileSize() {
-	return file_handle ? file_handle->FileSize() : 0;
-}
-
-void BufferedCSVReader::Initialize(const vector<LogicalType> &requested_types) {
-	PrepareComplexParser();
-	if (options.auto_detect) {
-		sql_types = SniffCSV(requested_types);
-		if (sql_types.empty()) {
-			throw Exception("Failed to detect column types from CSV: is the file a valid CSV file?");
-		}
-		if (cached_chunks.empty()) {
-			JumpToBeginning(options.skip_rows, options.header);
-		}
-	} else {
-		sql_types = requested_types;
-		ResetBuffer();
-		SkipRowsAndReadHeader(options.skip_rows, options.header);
-	}
-	InitParseChunk(sql_types.size());
-	// we only need reset support during the automatic CSV type detection
-	// since reset support might require caching (in the case of streams), we disable it for the remainder
-	file_handle->DisableReset();
-}
-
-void BufferedCSVReader::PrepareComplexParser() {
-	delimiter_search = TextSearchShiftArray(options.delimiter);
-	escape_search = TextSearchShiftArray(options.escape);
-	quote_search = TextSearchShiftArray(options.quote);
-}
-
-unique_ptr<CSVFileHandle> BufferedCSVReader::OpenCSV(const BufferedCSVReaderOptions &options) {
-	auto file_handle = fs.OpenFile(options.file_path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK,
-	                               options.compression, this->opener);
-	return make_unique<CSVFileHandle>(move(file_handle));
-}
-
-// Helper function to generate column names
-static string GenerateColumnName(const idx_t total_cols, const idx_t col_number, const string &prefix = "column") {
-	int max_digits = NumericHelper::UnsignedLength(total_cols - 1);
-	int digits = NumericHelper::UnsignedLength(col_number);
-	string leading_zeros = string(max_digits - digits, '0');
-	string value = to_string(col_number);
-	return string(prefix + leading_zeros + value);
-}
-
-// Helper function for UTF-8 aware space trimming
-static string TrimWhitespace(const string &col_name) {
-	utf8proc_int32_t codepoint;
-	auto str = reinterpret_cast<const utf8proc_uint8_t *>(col_name.c_str());
-	idx_t size = col_name.size();
-	// Find the first character that is not left trimmed
-	idx_t begin = 0;
-	while (begin < size) {
-		auto bytes = utf8proc_iterate(str + begin, size - begin, &codepoint);
-		D_ASSERT(bytes > 0);
-		if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
-			break;
-		}
-		begin += bytes;
-	}
-
-	// Find the last character that is not right trimmed
-	idx_t end;
-	end = begin;
-	for (auto next = begin; next < col_name.size();) {
-		auto bytes = utf8proc_iterate(str + next, size - next, &codepoint);
-		D_ASSERT(bytes > 0);
-		next += bytes;
-		if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
-			end = next;
-		}
-	}
-
-	// return the trimmed string
-	return col_name.substr(begin, end - begin);
-}
-
-static string NormalizeColumnName(const string &col_name) {
-	// normalize UTF8 characters to NFKD
-	auto nfkd = utf8proc_NFKD((const utf8proc_uint8_t *)col_name.c_str(), col_name.size());
-	const string col_name_nfkd = string((const char *)nfkd, strlen((const char *)nfkd));
-	free(nfkd);
-
-	// only keep ASCII characters 0-9 a-z A-Z and replace spaces with regular whitespace
-	string col_name_ascii = "";
-	for (idx_t i = 0; i < col_name_nfkd.size(); i++) {
-		if (col_name_nfkd[i] == '_' || (col_name_nfkd[i] >= '0' && col_name_nfkd[i] <= '9') ||
-		    (col_name_nfkd[i] >= 'A' && col_name_nfkd[i] <= 'Z') ||
-		    (col_name_nfkd[i] >= 'a' && col_name_nfkd[i] <= 'z')) {
-			col_name_ascii += col_name_nfkd[i];
-		} else if (StringUtil::CharacterIsSpace(col_name_nfkd[i])) {
-			col_name_ascii += " ";
-		}
-	}
-
-	// trim whitespace and replace remaining whitespace by _
-	string col_name_trimmed = TrimWhitespace(col_name_ascii);
-	string col_name_cleaned = "";
-	bool in_whitespace = false;
-	for (idx_t i = 0; i < col_name_trimmed.size(); i++) {
-		if (col_name_trimmed[i] == ' ') {
-			if (!in_whitespace) {
-				col_name_cleaned += "_";
-				in_whitespace = true;
-			}
-		} else {
-			col_name_cleaned += col_name_trimmed[i];
-			in_whitespace = false;
-		}
-	}
-
-	// don't leave string empty; if not empty, make lowercase
-	if (col_name_cleaned.empty()) {
-		col_name_cleaned = "_";
-	} else {
-		col_name_cleaned = StringUtil::Lower(col_name_cleaned);
-	}
-
-	// prepend _ if name starts with a digit or is a reserved keyword
-	if (KeywordHelper::IsKeyword(col_name_cleaned) || (col_name_cleaned[0] >= '0' && col_name_cleaned[0] <= '9')) {
-		col_name_cleaned = "_" + col_name_cleaned;
-	}
-	return col_name_cleaned;
-}
-
-void BufferedCSVReader::ResetBuffer() {
-	buffer.reset();
-	buffer_size = 0;
-	position = 0;
-	start = 0;
-	cached_buffers.clear();
-}
-
-void BufferedCSVReader::ResetStream() {
-	if (!file_handle->CanSeek()) {
-		// seeking to the beginning appears to not be supported in all compiler/os-scenarios,
-		// so we have to create a new stream source here for now
-		file_handle->Reset();
-	} else {
-		file_handle->Seek(0);
-	}
-	linenr = 0;
-	linenr_estimated = false;
-	bytes_per_line_avg = 0;
-	sample_chunk_idx = 0;
-	jumping_samples = false;
-}
-
-void BufferedCSVReader::InitParseChunk(idx_t num_cols) {
-	// adapt not null info
-	if (options.force_not_null.size() != num_cols) {
-		options.force_not_null.resize(num_cols, false);
-	}
-	if (num_cols == parse_chunk.ColumnCount()) {
-		parse_chunk.Reset();
-	} else {
-		parse_chunk.Destroy();
-
-		// initialize the parse_chunk with a set of VARCHAR types
-		vector<LogicalType> varchar_types(num_cols, LogicalType::VARCHAR);
-		parse_chunk.Initialize(allocator, varchar_types);
-	}
-}
-
-void BufferedCSVReader::JumpToBeginning(idx_t skip_rows = 0, bool skip_header = false) {
-	ResetBuffer();
-	ResetStream();
-	sample_chunk_idx = 0;
-	bytes_in_chunk = 0;
-	end_of_file_reached = false;
-	bom_checked = false;
-	SkipRowsAndReadHeader(skip_rows, skip_header);
-}
-
-void BufferedCSVReader::SkipRowsAndReadHeader(idx_t skip_rows, bool skip_header) {
-	for (idx_t i = 0; i < skip_rows; i++) {
-		// ignore skip rows
-		string read_line = file_handle->ReadLine();
-		linenr++;
-	}
-
-	if (skip_header) {
-		// ignore the first line as a header line
-		InitParseChunk(sql_types.size());
-		ParseCSV(ParserMode::PARSING_HEADER);
-	}
-}
-
-bool BufferedCSVReader::JumpToNextSample() {
-	// get bytes contained in the previously read chunk
-	idx_t remaining_bytes_in_buffer = buffer_size - start;
-	bytes_in_chunk -= remaining_bytes_in_buffer;
-	if (remaining_bytes_in_buffer == 0) {
-		return false;
-	}
-
-	// assess if it makes sense to jump, based on size of the first chunk relative to size of the entire file
-	if (sample_chunk_idx == 0) {
-		idx_t bytes_first_chunk = bytes_in_chunk;
-		double chunks_fit = (file_handle->FileSize() / (double)bytes_first_chunk);
-		jumping_samples = chunks_fit >= options.sample_chunks;
-
-		// jump back to the beginning
-		JumpToBeginning(options.skip_rows, options.header);
-		sample_chunk_idx++;
-		return true;
-	}
-
-	if (end_of_file_reached || sample_chunk_idx >= options.sample_chunks) {
-		return false;
-	}
-
-	// if we deal with any other sources than plaintext files, jumping_samples can be tricky. In that case
-	// we just read x continuous chunks from the stream TODO: make jumps possible for zipfiles.
-	if (!file_handle->PlainFileSource() || !jumping_samples) {
-		sample_chunk_idx++;
-		return true;
-	}
-
-	// update average bytes per line
-	double bytes_per_line = bytes_in_chunk / (double)options.sample_chunk_size;
-	bytes_per_line_avg = ((bytes_per_line_avg * (sample_chunk_idx)) + bytes_per_line) / (sample_chunk_idx + 1);
-
-	// if none of the previous conditions were met, we can jump
-	idx_t partition_size = (idx_t)round(file_handle->FileSize() / (double)options.sample_chunks);
-
-	// calculate offset to end of the current partition
-	int64_t offset = partition_size - bytes_in_chunk - remaining_bytes_in_buffer;
-	auto current_pos = file_handle->SeekPosition();
-
-	if (current_pos + offset < file_handle->FileSize()) {
-		// set position in stream and clear failure bits
-		file_handle->Seek(current_pos + offset);
-
-		// estimate linenr
-		linenr += (idx_t)round((offset + remaining_bytes_in_buffer) / bytes_per_line_avg);
-		linenr_estimated = true;
-	} else {
-		// seek backwards from the end in last chunk and hope to catch the end of the file
-		// TODO: actually it would be good to make sure that the end of file is being reached, because
-		// messy end-lines are quite common. For this case, however, we first need a skip_end detection anyways.
-		file_handle->Seek(file_handle->FileSize() - bytes_in_chunk);
-
-		// estimate linenr
-		linenr = (idx_t)round((file_handle->FileSize() - bytes_in_chunk) / bytes_per_line_avg);
-		linenr_estimated = true;
-	}
-
-	// reset buffers and parse chunk
-	ResetBuffer();
-
-	// seek beginning of next line
-	// FIXME: if this jump ends up in a quoted linebreak, we will have a problem
-	string read_line = file_handle->ReadLine();
-	linenr++;
-
-	sample_chunk_idx++;
-
-	return true;
-}
-
-void BufferedCSVReader::SetDateFormat(const string &format_specifier, const LogicalTypeId &sql_type) {
-	options.has_format[sql_type] = true;
-	auto &date_format = options.date_format[sql_type];
-	date_format.format_specifier = format_specifier;
-	StrTimeFormat::ParseFormatSpecifier(date_format.format_specifier, date_format);
-}
-
-bool BufferedCSVReader::TryCastValue(const Value &value, const LogicalType &sql_type) {
-	if (options.has_format[LogicalTypeId::DATE] && sql_type.id() == LogicalTypeId::DATE) {
-		date_t result;
-		string error_message;
-		return options.date_format[LogicalTypeId::DATE].TryParseDate(string_t(StringValue::Get(value)), result,
-		                                                             error_message);
-	} else if (options.has_format[LogicalTypeId::TIMESTAMP] && sql_type.id() == LogicalTypeId::TIMESTAMP) {
-		timestamp_t result;
-		string error_message;
-		return options.date_format[LogicalTypeId::TIMESTAMP].TryParseTimestamp(string_t(StringValue::Get(value)),
-		                                                                       result, error_message);
-	} else {
-		Value new_value;
-		string error_message;
-		return value.TryCastAs(sql_type, new_value, &error_message, true);
-	}
-}
-
-struct TryCastDateOperator {
-	static bool Operation(BufferedCSVReaderOptions &options, string_t input, date_t &result, string &error_message) {
-		return options.date_format[LogicalTypeId::DATE].TryParseDate(input, result, error_message);
-	}
-};
-
-struct TryCastTimestampOperator {
-	static bool Operation(BufferedCSVReaderOptions &options, string_t input, timestamp_t &result,
-	                      string &error_message) {
-		return options.date_format[LogicalTypeId::TIMESTAMP].TryParseTimestamp(input, result, error_message);
-	}
-};
-
-template <class OP, class T>
-static bool TemplatedTryCastDateVector(BufferedCSVReaderOptions &options, Vector &input_vector, Vector &result_vector,
-                                       idx_t count, string &error_message) {
-	D_ASSERT(input_vector.GetType().id() == LogicalTypeId::VARCHAR);
-	bool all_converted = true;
-	UnaryExecutor::Execute<string_t, T>(input_vector, result_vector, count, [&](string_t input) {
-		T result;
-		if (!OP::Operation(options, input, result, error_message)) {
-			all_converted = false;
-		}
-		return result;
-	});
-	return all_converted;
-}
-
-bool TryCastDateVector(BufferedCSVReaderOptions &options, Vector &input_vector, Vector &result_vector, idx_t count,
-                       string &error_message) {
-	return TemplatedTryCastDateVector<TryCastDateOperator, date_t>(options, input_vector, result_vector, count,
-	                                                               error_message);
-}
-
-bool TryCastTimestampVector(BufferedCSVReaderOptions &options, Vector &input_vector, Vector &result_vector, idx_t count,
-                            string &error_message) {
-	return TemplatedTryCastDateVector<TryCastTimestampOperator, timestamp_t>(options, input_vector, result_vector,
-	                                                                         count, error_message);
-}
-
-bool BufferedCSVReader::TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type) {
-	// try vector-cast from string to sql_type
-	Vector dummy_result(sql_type);
-	if (options.has_format[LogicalTypeId::DATE] && sql_type == LogicalTypeId::DATE) {
-		// use the date format to cast the chunk
-		string error_message;
-		return TryCastDateVector(options, parse_chunk_col, dummy_result, size, error_message);
-	} else if (options.has_format[LogicalTypeId::TIMESTAMP] && sql_type == LogicalTypeId::TIMESTAMP) {
-		// use the timestamp format to cast the chunk
-		string error_message;
-		return TryCastTimestampVector(options, parse_chunk_col, dummy_result, size, error_message);
-	} else {
-		// target type is not varchar: perform a cast
-		string error_message;
-		return VectorOperations::TryCast(parse_chunk_col, dummy_result, size, &error_message, true);
-	}
-}
-
-enum class QuoteRule : uint8_t { QUOTES_RFC = 0, QUOTES_OTHER = 1, NO_QUOTES = 2 };
-
-void BufferedCSVReader::DetectDialect(const vector<LogicalType> &requested_types,
-                                      BufferedCSVReaderOptions &original_options,
-                                      vector<BufferedCSVReaderOptions> &info_candidates, idx_t &best_num_cols) {
-	// set up the candidates we consider for delimiter and quote rules based on user input
-	vector<string> delim_candidates;
-	vector<QuoteRule> quoterule_candidates;
-	vector<vector<string>> quote_candidates_map;
-	vector<vector<string>> escape_candidates_map = {{""}, {"\\"}, {""}};
-
-	if (options.has_delimiter) {
-		// user provided a delimiter: use that delimiter
-		delim_candidates = {options.delimiter};
-	} else {
-		// no delimiter provided: try standard/common delimiters
-		delim_candidates = {",", "|", ";", "\t"};
-	}
-	if (options.has_quote) {
-		// user provided quote: use that quote rule
-		quote_candidates_map = {{options.quote}, {options.quote}, {options.quote}};
-	} else {
-		// no quote rule provided: use standard/common quotes
-		quote_candidates_map = {{"\""}, {"\"", "'"}, {""}};
-	}
-	if (options.has_escape) {
-		// user provided escape: use that escape rule
-		if (options.escape.empty()) {
-			quoterule_candidates = {QuoteRule::QUOTES_RFC};
-		} else {
-			quoterule_candidates = {QuoteRule::QUOTES_OTHER};
-		}
-		escape_candidates_map[static_cast<uint8_t>(quoterule_candidates[0])] = {options.escape};
-	} else {
-		// no escape provided: try standard/common escapes
-		quoterule_candidates = {QuoteRule::QUOTES_RFC, QuoteRule::QUOTES_OTHER, QuoteRule::NO_QUOTES};
-	}
-
-	idx_t best_consistent_rows = 0;
-	for (auto quoterule : quoterule_candidates) {
-		const auto &quote_candidates = quote_candidates_map[static_cast<uint8_t>(quoterule)];
-		for (const auto &quote : quote_candidates) {
-			for (const auto &delim : delim_candidates) {
-				const auto &escape_candidates = escape_candidates_map[static_cast<uint8_t>(quoterule)];
-				for (const auto &escape : escape_candidates) {
-					BufferedCSVReaderOptions sniff_info = original_options;
-					sniff_info.delimiter = delim;
-					sniff_info.quote = quote;
-					sniff_info.escape = escape;
-
-					options = sniff_info;
-					PrepareComplexParser();
-
-					JumpToBeginning(original_options.skip_rows);
-					sniffed_column_counts.clear();
-
-					if (!TryParseCSV(ParserMode::SNIFFING_DIALECT)) {
-						continue;
-					}
-
-					idx_t start_row = original_options.skip_rows;
-					idx_t consistent_rows = 0;
-					idx_t num_cols = 0;
-
-					for (idx_t row = 0; row < sniffed_column_counts.size(); row++) {
-						if (sniffed_column_counts[row] == num_cols) {
-							consistent_rows++;
-						} else {
-							num_cols = sniffed_column_counts[row];
-							start_row = row + original_options.skip_rows;
-							consistent_rows = 1;
-						}
-					}
-
-					// some logic
-					bool more_values = (consistent_rows > best_consistent_rows && num_cols >= best_num_cols);
-					bool single_column_before = best_num_cols < 2 && num_cols > best_num_cols;
-					bool rows_consistent =
-					    start_row + consistent_rows - original_options.skip_rows == sniffed_column_counts.size();
-					bool more_than_one_row = (consistent_rows > 1);
-					bool more_than_one_column = (num_cols > 1);
-					bool start_good = !info_candidates.empty() && (start_row <= info_candidates.front().skip_rows);
-
-					if (!requested_types.empty() && requested_types.size() != num_cols) {
-						continue;
-					} else if ((more_values || single_column_before) && rows_consistent) {
-						sniff_info.skip_rows = start_row;
-						sniff_info.num_cols = num_cols;
-						best_consistent_rows = consistent_rows;
-						best_num_cols = num_cols;
-
-						info_candidates.clear();
-						info_candidates.push_back(sniff_info);
-					} else if (more_than_one_row && more_than_one_column && start_good && rows_consistent) {
-						bool same_quote_is_candidate = false;
-						for (auto &info_candidate : info_candidates) {
-							if (quote.compare(info_candidate.quote) == 0) {
-								same_quote_is_candidate = true;
-							}
-						}
-						if (!same_quote_is_candidate) {
-							sniff_info.skip_rows = start_row;
-							sniff_info.num_cols = num_cols;
-							info_candidates.push_back(sniff_info);
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-void BufferedCSVReader::DetectCandidateTypes(const vector<LogicalType> &type_candidates,
-                                             const map<LogicalTypeId, vector<const char *>> &format_template_candidates,
-                                             const vector<BufferedCSVReaderOptions> &info_candidates,
-                                             BufferedCSVReaderOptions &original_options, idx_t best_num_cols,
-                                             vector<vector<LogicalType>> &best_sql_types_candidates,
-                                             std::map<LogicalTypeId, vector<string>> &best_format_candidates,
-                                             DataChunk &best_header_row) {
-	BufferedCSVReaderOptions best_options;
-	idx_t min_varchar_cols = best_num_cols + 1;
-
-	// check which info candidate leads to minimum amount of non-varchar columns...
-	for (const auto &t : format_template_candidates) {
-		best_format_candidates[t.first].clear();
-	}
-	for (auto &info_candidate : info_candidates) {
-		options = info_candidate;
-		vector<vector<LogicalType>> info_sql_types_candidates(options.num_cols, type_candidates);
-		std::map<LogicalTypeId, bool> has_format_candidates;
-		std::map<LogicalTypeId, vector<string>> format_candidates;
-		for (const auto &t : format_template_candidates) {
-			has_format_candidates[t.first] = false;
-			format_candidates[t.first].clear();
-		}
-
-		// set all sql_types to VARCHAR so we can do datatype detection based on VARCHAR values
-		sql_types.clear();
-		sql_types.assign(options.num_cols, LogicalType::VARCHAR);
-
-		// jump to beginning and skip potential header
-		JumpToBeginning(options.skip_rows, true);
-		DataChunk header_row;
-		header_row.Initialize(allocator, sql_types);
-		parse_chunk.Copy(header_row);
-
-		if (header_row.size() == 0) {
-			continue;
-		}
-
-		// init parse chunk and read csv with info candidate
-		InitParseChunk(sql_types.size());
-		ParseCSV(ParserMode::SNIFFING_DATATYPES);
-		for (idx_t row_idx = 0; row_idx <= parse_chunk.size(); row_idx++) {
-			bool is_header_row = row_idx == 0;
-			idx_t row = row_idx - 1;
-			for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) {
-				auto &col_type_candidates = info_sql_types_candidates[col];
-				while (col_type_candidates.size() > 1) {
-					const auto &sql_type = col_type_candidates.back();
-					// try cast from string to sql_type
-					Value dummy_val;
-					if (is_header_row) {
-						dummy_val = header_row.GetValue(col, 0);
-					} else {
-						dummy_val = parse_chunk.GetValue(col, row);
-					}
-					// try formatting for date types if the user did not specify one and it starts with numeric values.
-					string separator;
-					if (has_format_candidates.count(sql_type.id()) && !original_options.has_format[sql_type.id()] &&
-					    StartsWithNumericDate(separator, StringValue::Get(dummy_val))) {
-						// generate date format candidates the first time through
-						auto &type_format_candidates = format_candidates[sql_type.id()];
-						const auto had_format_candidates = has_format_candidates[sql_type.id()];
-						if (!has_format_candidates[sql_type.id()]) {
-							has_format_candidates[sql_type.id()] = true;
-							// order by preference
-							auto entry = format_template_candidates.find(sql_type.id());
-							if (entry != format_template_candidates.end()) {
-								const auto &format_template_list = entry->second;
-								for (const auto &t : format_template_list) {
-									const auto format_string = GenerateDateFormat(separator, t);
-									// don't parse ISO 8601
-									if (format_string.find("%Y-%m-%d") == string::npos) {
-										type_format_candidates.emplace_back(format_string);
-									}
-								}
-							}
-							//	initialise the first candidate
-							options.has_format[sql_type.id()] = true;
-							//	all formats are constructed to be valid
-							SetDateFormat(type_format_candidates.back(), sql_type.id());
-						}
-						// check all formats and keep the first one that works
-						StrpTimeFormat::ParseResult result;
-						auto save_format_candidates = type_format_candidates;
-						while (!type_format_candidates.empty()) {
-							//	avoid using exceptions for flow control...
-							auto &current_format = options.date_format[sql_type.id()];
-							if (current_format.Parse(StringValue::Get(dummy_val), result)) {
-								break;
-							}
-							//	doesn't work - move to the next one
-							type_format_candidates.pop_back();
-							options.has_format[sql_type.id()] = (!type_format_candidates.empty());
-							if (!type_format_candidates.empty()) {
-								SetDateFormat(type_format_candidates.back(), sql_type.id());
-							}
-						}
-						//	if none match, then this is not a value of type sql_type,
-						if (type_format_candidates.empty()) {
-							//	so restore the candidates that did work.
-							//	or throw them out if they were generated by this value.
-							if (had_format_candidates) {
-								type_format_candidates.swap(save_format_candidates);
-								if (!type_format_candidates.empty()) {
-									SetDateFormat(type_format_candidates.back(), sql_type.id());
-								}
-							} else {
-								has_format_candidates[sql_type.id()] = false;
-							}
-						}
-					}
-					// try cast from string to sql_type
-					if (TryCastValue(dummy_val, sql_type)) {
-						break;
-					} else {
-						col_type_candidates.pop_back();
-					}
-				}
-			}
-			// reset type detection, because first row could be header,
-			// but only do it if csv has more than one line (including header)
-			if (parse_chunk.size() > 0 && is_header_row) {
-				info_sql_types_candidates = vector<vector<LogicalType>>(options.num_cols, type_candidates);
-				for (auto &f : format_candidates) {
-					f.second.clear();
-				}
-				for (auto &h : has_format_candidates) {
-					h.second = false;
-				}
-			}
-		}
-
-		idx_t varchar_cols = 0;
-		for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) {
-			auto &col_type_candidates = info_sql_types_candidates[col];
-			// check number of varchar columns
-			const auto &col_type = col_type_candidates.back();
-			if (col_type == LogicalType::VARCHAR) {
-				varchar_cols++;
-			}
-		}
-
-		// it's good if the dialect creates more non-varchar columns, but only if we sacrifice < 30% of best_num_cols.
-		if (varchar_cols < min_varchar_cols && parse_chunk.ColumnCount() > (best_num_cols * 0.7)) {
-			// we have a new best_options candidate
-			best_options = info_candidate;
-			min_varchar_cols = varchar_cols;
-			best_sql_types_candidates = info_sql_types_candidates;
-			best_format_candidates = format_candidates;
-			best_header_row.Destroy();
-			auto header_row_types = header_row.GetTypes();
-			best_header_row.Initialize(allocator, header_row_types);
-			header_row.Copy(best_header_row);
-		}
-	}
-
-	options = best_options;
-	for (const auto &best : best_format_candidates) {
-		if (!best.second.empty()) {
-			SetDateFormat(best.second.back(), best.first);
-		}
-	}
-}
-
-void BufferedCSVReader::DetectHeader(const vector<vector<LogicalType>> &best_sql_types_candidates,
-                                     const DataChunk &best_header_row) {
-	// information for header detection
-	bool first_row_consistent = true;
-	bool first_row_nulls = false;
-
-	// check if header row is all null and/or consistent with detected column data types
-	first_row_nulls = true;
-	for (idx_t col = 0; col < best_sql_types_candidates.size(); col++) {
-		auto dummy_val = best_header_row.GetValue(col, 0);
-		if (!dummy_val.IsNull()) {
-			first_row_nulls = false;
-		}
-
-		// try cast to sql_type of column
-		const auto &sql_type = best_sql_types_candidates[col].back();
-		if (!TryCastValue(dummy_val, sql_type)) {
-			first_row_consistent = false;
-		}
-	}
-
-	// update parser info, and read, generate & set col_names based on previous findings
-	if (((!first_row_consistent || first_row_nulls) && !options.has_header) || (options.has_header && options.header)) {
-		options.header = true;
-		case_insensitive_map_t<idx_t> name_collision_count;
-		// get header names from CSV
-		for (idx_t col = 0; col < options.num_cols; col++) {
-			const auto &val = best_header_row.GetValue(col, 0);
-			string col_name = val.ToString();
-
-			// generate name if field is empty
-			if (col_name.empty() || val.IsNull()) {
-				col_name = GenerateColumnName(options.num_cols, col);
-			}
-
-			// normalize names or at least trim whitespace
-			if (options.normalize_names) {
-				col_name = NormalizeColumnName(col_name);
-			} else {
-				col_name = TrimWhitespace(col_name);
-			}
-
-			// avoid duplicate header names
-			const string col_name_raw = col_name;
-			while (name_collision_count.find(col_name) != name_collision_count.end()) {
-				name_collision_count[col_name] += 1;
-				col_name = col_name + "_" + to_string(name_collision_count[col_name]);
-			}
-
-			col_names.push_back(col_name);
-			name_collision_count[col_name] = 0;
-		}
-
-	} else {
-		options.header = false;
-		for (idx_t col = 0; col < options.num_cols; col++) {
-			string column_name = GenerateColumnName(options.num_cols, col);
-			col_names.push_back(column_name);
-		}
-	}
-}
-
-vector<LogicalType> BufferedCSVReader::RefineTypeDetection(const vector<LogicalType> &type_candidates,
-                                                           const vector<LogicalType> &requested_types,
-                                                           vector<vector<LogicalType>> &best_sql_types_candidates,
-                                                           map<LogicalTypeId, vector<string>> &best_format_candidates) {
-	// for the type refine we set the SQL types to VARCHAR for all columns
-	sql_types.clear();
-	sql_types.assign(options.num_cols, LogicalType::VARCHAR);
-
-	vector<LogicalType> detected_types;
-
-	// if data types were provided, exit here if number of columns does not match
-	if (!requested_types.empty()) {
-		if (requested_types.size() != options.num_cols) {
-			throw InvalidInputException(
-			    "Error while determining column types: found %lld columns but expected %d. (%s)", options.num_cols,
-			    requested_types.size(), options.ToString());
-		} else {
-			detected_types = requested_types;
-		}
-	} else if (options.all_varchar) {
-		// return all types varchar
-		detected_types = sql_types;
-	} else {
-		// jump through the rest of the file and continue to refine the sql type guess
-		while (JumpToNextSample()) {
-			InitParseChunk(sql_types.size());
-			// if jump ends up a bad line, we just skip this chunk
-			if (!TryParseCSV(ParserMode::SNIFFING_DATATYPES)) {
-				continue;
-			}
-			for (idx_t col = 0; col < parse_chunk.ColumnCount(); col++) {
-				vector<LogicalType> &col_type_candidates = best_sql_types_candidates[col];
-				while (col_type_candidates.size() > 1) {
-					const auto &sql_type = col_type_candidates.back();
-					//	narrow down the date formats
-					if (best_format_candidates.count(sql_type.id())) {
-						auto &best_type_format_candidates = best_format_candidates[sql_type.id()];
-						auto save_format_candidates = best_type_format_candidates;
-						while (!best_type_format_candidates.empty()) {
-							if (TryCastVector(parse_chunk.data[col], parse_chunk.size(), sql_type)) {
-								break;
-							}
-							//	doesn't work - move to the next one
-							best_type_format_candidates.pop_back();
-							options.has_format[sql_type.id()] = (!best_type_format_candidates.empty());
-							if (!best_type_format_candidates.empty()) {
-								SetDateFormat(best_type_format_candidates.back(), sql_type.id());
-							}
-						}
-						//	if none match, then this is not a column of type sql_type,
-						if (best_type_format_candidates.empty()) {
-							//	so restore the candidates that did work.
-							best_type_format_candidates.swap(save_format_candidates);
-							if (!best_type_format_candidates.empty()) {
-								SetDateFormat(best_type_format_candidates.back(), sql_type.id());
-							}
-						}
-					}
-
-					if (TryCastVector(parse_chunk.data[col], parse_chunk.size(), sql_type)) {
-						break;
-					} else {
-						col_type_candidates.pop_back();
-					}
-				}
-			}
-
-			if (!jumping_samples) {
-				if ((sample_chunk_idx)*options.sample_chunk_size <= options.buffer_size) {
-					// cache parse chunk
-					// create a new chunk and fill it with the remainder
-					auto chunk = make_unique<DataChunk>();
-					auto parse_chunk_types = parse_chunk.GetTypes();
-					chunk->Move(parse_chunk);
-					cached_chunks.push(move(chunk));
-				} else {
-					while (!cached_chunks.empty()) {
-						cached_chunks.pop();
-					}
-				}
-			}
-		}
-
-		// set sql types
-		for (auto &best_sql_types_candidate : best_sql_types_candidates) {
-			LogicalType d_type = best_sql_types_candidate.back();
-			if (best_sql_types_candidate.size() == type_candidates.size()) {
-				d_type = LogicalType::VARCHAR;
-			}
-			detected_types.push_back(d_type);
-		}
-	}
-
-	return detected_types;
-}
-
-vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &requested_types) {
-	for (auto &type : requested_types) {
-		// auto detect for blobs not supported: there may be invalid UTF-8 in the file
-		if (type.id() == LogicalTypeId::BLOB) {
-			return requested_types;
-		}
-	}
-
-	// #######
-	// ### dialect detection
-	// #######
-	BufferedCSVReaderOptions original_options = options;
-	vector<BufferedCSVReaderOptions> info_candidates;
-	idx_t best_num_cols = 0;
-
-	DetectDialect(requested_types, original_options, info_candidates, best_num_cols);
-
-	// if no dialect candidate was found, then file was most likely empty and we throw an exception
-	if (info_candidates.empty()) {
-		throw InvalidInputException(
-		    "Error in file \"%s\": CSV options could not be auto-detected. Consider setting parser options manually.",
-		    options.file_path);
-	}
-
-	// #######
-	// ### type detection (initial)
-	// #######
-	// type candidates, ordered by descending specificity (~ from high to low)
-	vector<LogicalType> type_candidates = {
-	    LogicalType::VARCHAR, LogicalType::TIMESTAMP,
-	    LogicalType::DATE,    LogicalType::TIME,
-	    LogicalType::DOUBLE,  /* LogicalType::FLOAT,*/ LogicalType::BIGINT,
-	    LogicalType::INTEGER, /*LogicalType::SMALLINT, LogicalType::TINYINT,*/ LogicalType::BOOLEAN,
-	    LogicalType::SQLNULL};
-	// format template candidates, ordered by descending specificity (~ from high to low)
-	std::map<LogicalTypeId, vector<const char *>> format_template_candidates = {
-	    {LogicalTypeId::DATE, {"%m-%d-%Y", "%m-%d-%y", "%d-%m-%Y", "%d-%m-%y", "%Y-%m-%d", "%y-%m-%d"}},
-	    {LogicalTypeId::TIMESTAMP,
-	     {"%Y-%m-%d %H:%M:%S.%f", "%m-%d-%Y %I:%M:%S %p", "%m-%d-%y %I:%M:%S %p", "%d-%m-%Y %H:%M:%S",
-	      "%d-%m-%y %H:%M:%S", "%Y-%m-%d %H:%M:%S", "%y-%m-%d %H:%M:%S"}},
-	};
-	vector<vector<LogicalType>> best_sql_types_candidates;
-	map<LogicalTypeId, vector<string>> best_format_candidates;
-	DataChunk best_header_row;
-	DetectCandidateTypes(type_candidates, format_template_candidates, info_candidates, original_options, best_num_cols,
-	                     best_sql_types_candidates, best_format_candidates, best_header_row);
-
-	// #######
-	// ### header detection
-	// #######
-	options.num_cols = best_num_cols;
-	DetectHeader(best_sql_types_candidates, best_header_row);
-
-	// #######
-	// ### type detection (refining)
-	// #######
-	return RefineTypeDetection(type_candidates, requested_types, best_sql_types_candidates, best_format_candidates);
-}
-
-bool BufferedCSVReader::TryParseComplexCSV(DataChunk &insert_chunk, string &error_message) {
-	// used for parsing algorithm
-	bool finished_chunk = false;
-	idx_t column = 0;
-	vector<idx_t> escape_positions;
-	uint8_t delimiter_pos = 0, escape_pos = 0, quote_pos = 0;
-	idx_t offset = 0;
-
-	// read values into the buffer (if any)
-	if (position >= buffer_size) {
-		if (!ReadBuffer(start)) {
-			return true;
-		}
-	}
-	// start parsing the first value
-	start = position;
-	goto value_start;
-value_start:
-	/* state: value_start */
-	// this state parses the first characters of a value
-	offset = 0;
-	delimiter_pos = 0;
-	quote_pos = 0;
-	do {
-		idx_t count = 0;
-		for (; position < buffer_size; position++) {
-			quote_search.Match(quote_pos, buffer[position]);
-			delimiter_search.Match(delimiter_pos, buffer[position]);
-			count++;
-			if (delimiter_pos == options.delimiter.size()) {
-				// found a delimiter, add the value
-				offset = options.delimiter.size() - 1;
-				goto add_value;
-			} else if (StringUtil::CharacterIsNewline(buffer[position])) {
-				// found a newline, add the row
-				goto add_row;
-			}
-			if (count > quote_pos) {
-				// did not find a quote directly at the start of the value, stop looking for the quote now
-				goto normal;
-			}
-			if (quote_pos == options.quote.size()) {
-				// found a quote, go to quoted loop and skip the initial quote
-				start += options.quote.size();
-				goto in_quotes;
-			}
-		}
-	} while (ReadBuffer(start));
-	// file ends while scanning for quote/delimiter, go to final state
-	goto final_state;
-normal:
-	/* state: normal parsing state */
-	// this state parses the remainder of a non-quoted value until we reach a delimiter or newline
-	position++;
-	do {
-		for (; position < buffer_size; position++) {
-			delimiter_search.Match(delimiter_pos, buffer[position]);
-			if (delimiter_pos == options.delimiter.size()) {
-				offset = options.delimiter.size() - 1;
-				goto add_value;
-			} else if (StringUtil::CharacterIsNewline(buffer[position])) {
-				goto add_row;
-			}
-		}
-	} while (ReadBuffer(start));
-	goto final_state;
-add_value:
-	AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
-	// increase position by 1 and move start to the new position
-	offset = 0;
-	start = ++position;
-	if (position >= buffer_size && !ReadBuffer(start)) {
-		// file ends right after delimiter, go to final state
-		goto final_state;
-	}
-	goto value_start;
-add_row : {
-	// check type of newline (\r or \n)
-	bool carriage_return = buffer[position] == '\r';
-	AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
-	finished_chunk = AddRow(insert_chunk, column);
-	// increase position by 1 and move start to the new position
-	offset = 0;
-	start = ++position;
-	if (position >= buffer_size && !ReadBuffer(start)) {
-		// file ends right after newline, go to final state
-		goto final_state;
-	}
-	if (carriage_return) {
-		// \r newline, go to special state that parses an optional \n afterwards
-		goto carriage_return;
-	} else {
-		// \n newline, move to value start
-		if (finished_chunk) {
-			return true;
-		}
-		goto value_start;
-	}
-}
-in_quotes:
-	/* state: in_quotes */
-	// this state parses the remainder of a quoted value
-	quote_pos = 0;
-	escape_pos = 0;
-	position++;
-	do {
-		for (; position < buffer_size; position++) {
-			quote_search.Match(quote_pos, buffer[position]);
-			escape_search.Match(escape_pos, buffer[position]);
-			if (quote_pos == options.quote.size()) {
-				goto unquote;
-			} else if (escape_pos == options.escape.size()) {
-				escape_positions.push_back(position - start - (options.escape.size() - 1));
-				goto handle_escape;
-			}
-		}
-	} while (ReadBuffer(start));
-	// still in quoted state at the end of the file, error:
-	error_message = StringUtil::Format("Error in file \"%s\" on line %s: unterminated quotes. (%s)", options.file_path,
-	                                   GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-	return false;
-unquote:
-	/* state: unquote */
-	// this state handles the state directly after we unquote
-	// in this state we expect either another quote (entering the quoted state again, and escaping the quote)
-	// or a delimiter/newline, ending the current value and moving on to the next value
-	delimiter_pos = 0;
-	quote_pos = 0;
-	position++;
-	if (position >= buffer_size && !ReadBuffer(start)) {
-		// file ends right after unquote, go to final state
-		offset = options.quote.size();
-		goto final_state;
-	}
-	if (StringUtil::CharacterIsNewline(buffer[position])) {
-		// quote followed by newline, add row
-		offset = options.quote.size();
-		goto add_row;
-	}
-	do {
-		idx_t count = 0;
-		for (; position < buffer_size; position++) {
-			quote_search.Match(quote_pos, buffer[position]);
-			delimiter_search.Match(delimiter_pos, buffer[position]);
-			count++;
-			if (count > delimiter_pos && count > quote_pos) {
-				error_message = StringUtil::Format(
-				    "Error in file \"%s\" on line %s: quote should be followed by end of value, end "
-				    "of row or another quote. (%s)",
-				    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-				return false;
-			}
-			if (delimiter_pos == options.delimiter.size()) {
-				// quote followed by delimiter, add value
-				offset = options.quote.size() + options.delimiter.size() - 1;
-				goto add_value;
-			} else if (quote_pos == options.quote.size() &&
-			           (options.escape.empty() || options.escape == options.quote)) {
-				// quote followed by quote, go back to quoted state and add to escape
-				escape_positions.push_back(position - start - (options.quote.size() - 1));
-				goto in_quotes;
-			}
-		}
-	} while (ReadBuffer(start));
-	error_message = StringUtil::Format(
-	    "Error in file \"%s\" on line %s: quote should be followed by end of value, end of row or another quote. (%s)",
-	    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-	return false;
-handle_escape:
-	escape_pos = 0;
-	quote_pos = 0;
-	position++;
-	do {
-		idx_t count = 0;
-		for (; position < buffer_size; position++) {
-			quote_search.Match(quote_pos, buffer[position]);
-			escape_search.Match(escape_pos, buffer[position]);
-			count++;
-			if (count > escape_pos && count > quote_pos) {
-				error_message = StringUtil::Format(
-				    "Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)",
-				    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-				return false;
-			}
-			if (quote_pos == options.quote.size() || escape_pos == options.escape.size()) {
-				// found quote or escape: move back to quoted state
-				goto in_quotes;
-			}
-		}
-	} while (ReadBuffer(start));
-	error_message =
-	    StringUtil::Format("Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)",
-	                       options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-	return false;
-carriage_return:
-	/* state: carriage_return */
-	// this stage optionally skips a newline (\n) character, which allows \r\n to be interpreted as a single line
-	if (buffer[position] == '\n') {
-		// newline after carriage return: skip
-		start = ++position;
-		if (position >= buffer_size && !ReadBuffer(start)) {
-			// file ends right after newline, go to final state
-			goto final_state;
-		}
-	}
-	if (finished_chunk) {
-		return true;
-	}
-	goto value_start;
-final_state:
-	if (finished_chunk) {
-		return true;
-	}
-	if (column > 0 || position > start) {
-		// remaining values to be added to the chunk
-		AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
-		finished_chunk = AddRow(insert_chunk, column);
-	}
-	// final stage, only reached after parsing the file is finished
-	// flush the parsed chunk and finalize parsing
-	if (mode == ParserMode::PARSING) {
-		Flush(insert_chunk);
-	}
-
-	end_of_file_reached = true;
-	return true;
-}
-
-bool BufferedCSVReader::TryParseSimpleCSV(DataChunk &insert_chunk, string &error_message) {
-	// used for parsing algorithm
-	bool finished_chunk = false;
-	idx_t column = 0;
-	idx_t offset = 0;
-	vector<idx_t> escape_positions;
-
-	// read values into the buffer (if any)
-	if (position >= buffer_size) {
-		if (!ReadBuffer(start)) {
-			return true;
-		}
-	}
-	// start parsing the first value
-	goto value_start;
-value_start:
-	offset = 0;
-	/* state: value_start */
-	// this state parses the first character of a value
-	if (buffer[position] == options.quote[0]) {
-		// quote: actual value starts in the next position
-		// move to in_quotes state
-		start = position + 1;
-		goto in_quotes;
-	} else {
-		// no quote, move to normal parsing state
-		start = position;
-		goto normal;
-	}
-normal:
-	/* state: normal parsing state */
-	// this state parses the remainder of a non-quoted value until we reach a delimiter or newline
-	do {
-		for (; position < buffer_size; position++) {
-			if (buffer[position] == options.delimiter[0]) {
-				// delimiter: end the value and add it to the chunk
-				goto add_value;
-			} else if (StringUtil::CharacterIsNewline(buffer[position])) {
-				// newline: add row
-				goto add_row;
-			}
-		}
-	} while (ReadBuffer(start));
-	// file ends during normal scan: go to end state
-	goto final_state;
-add_value:
-	AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
-	// increase position by 1 and move start to the new position
-	offset = 0;
-	start = ++position;
-	if (position >= buffer_size && !ReadBuffer(start)) {
-		// file ends right after delimiter, go to final state
-		goto final_state;
-	}
-	goto value_start;
-add_row : {
-	// check type of newline (\r or \n)
-	bool carriage_return = buffer[position] == '\r';
-	AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
-	finished_chunk = AddRow(insert_chunk, column);
-	// increase position by 1 and move start to the new position
-	offset = 0;
-	start = ++position;
-	if (position >= buffer_size && !ReadBuffer(start)) {
-		// file ends right after delimiter, go to final state
-		goto final_state;
-	}
-	if (carriage_return) {
-		// \r newline, go to special state that parses an optional \n afterwards
-		goto carriage_return;
-	} else {
-		// \n newline, move to value start
-		if (finished_chunk) {
-			return true;
-		}
-		goto value_start;
-	}
-}
-in_quotes:
-	/* state: in_quotes */
-	// this state parses the remainder of a quoted value
-	position++;
-	do {
-		for (; position < buffer_size; position++) {
-			if (buffer[position] == options.quote[0]) {
-				// quote: move to unquoted state
-				goto unquote;
-			} else if (buffer[position] == options.escape[0]) {
-				// escape: store the escaped position and move to handle_escape state
-				escape_positions.push_back(position - start);
-				goto handle_escape;
-			}
-		}
-	} while (ReadBuffer(start));
-	// still in quoted state at the end of the file, error:
-	throw InvalidInputException("Error in file \"%s\" on line %s: unterminated quotes. (%s)", options.file_path,
-	                            GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-unquote:
-	/* state: unquote */
-	// this state handles the state directly after we unquote
-	// in this state we expect either another quote (entering the quoted state again, and escaping the quote)
-	// or a delimiter/newline, ending the current value and moving on to the next value
-	position++;
-	if (position >= buffer_size && !ReadBuffer(start)) {
-		// file ends right after unquote, go to final state
-		offset = 1;
-		goto final_state;
-	}
-	if (buffer[position] == options.quote[0] && (options.escape.empty() || options.escape[0] == options.quote[0])) {
-		// escaped quote, return to quoted state and store escape position
-		escape_positions.push_back(position - start);
-		goto in_quotes;
-	} else if (buffer[position] == options.delimiter[0]) {
-		// delimiter, add value
-		offset = 1;
-		goto add_value;
-	} else if (StringUtil::CharacterIsNewline(buffer[position])) {
-		offset = 1;
-		goto add_row;
-	} else {
-		error_message = StringUtil::Format(
-		    "Error in file \"%s\" on line %s: quote should be followed by end of value, end of "
-		    "row or another quote. (%s)",
-		    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-		return false;
-	}
-handle_escape:
-	/* state: handle_escape */
-	// escape should be followed by a quote or another escape character
-	position++;
-	if (position >= buffer_size && !ReadBuffer(start)) {
-		error_message = StringUtil::Format(
-		    "Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)", options.file_path,
-		    GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-		return false;
-	}
-	if (buffer[position] != options.quote[0] && buffer[position] != options.escape[0]) {
-		error_message = StringUtil::Format(
-		    "Error in file \"%s\" on line %s: neither QUOTE nor ESCAPE is proceeded by ESCAPE. (%s)", options.file_path,
-		    GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
-		return false;
-	}
-	// escape was followed by quote or escape, go back to quoted state
-	goto in_quotes;
-carriage_return:
-	/* state: carriage_return */
-	// this stage optionally skips a newline (\n) character, which allows \r\n to be interpreted as a single line
-	if (buffer[position] == '\n') {
-		// newline after carriage return: skip
-		// increase position by 1 and move start to the new position
-		start = ++position;
-		if (position >= buffer_size && !ReadBuffer(start)) {
-			// file ends right after delimiter, go to final state
-			goto final_state;
-		}
-	}
-	if (finished_chunk) {
-		return true;
-	}
-	goto value_start;
-final_state:
-	if (finished_chunk) {
-		return true;
-	}
-
-	if (column > 0 || position > start) {
-		// remaining values to be added to the chunk
-		AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
-		finished_chunk = AddRow(insert_chunk, column);
-	}
-
-	// final stage, only reached after parsing the file is finished
-	// flush the parsed chunk and finalize parsing
-	if (mode == ParserMode::PARSING) {
-		Flush(insert_chunk);
-	}
-
-	end_of_file_reached = true;
-	return true;
-}
-
-bool BufferedCSVReader::ReadBuffer(idx_t &start) {
-	auto old_buffer = move(buffer);
-
-	// the remaining part of the last buffer
-	idx_t remaining = buffer_size - start;
-
-	bool large_buffers = mode == ParserMode::PARSING && !file_handle->OnDiskFile() && file_handle->CanSeek();
-	idx_t buffer_read_size = large_buffers ? INITIAL_BUFFER_SIZE_LARGE : INITIAL_BUFFER_SIZE;
-
-	while (remaining > buffer_read_size) {
-		buffer_read_size *= 2;
-	}
-
-	// Check line length
-	if (remaining > options.maximum_line_size) {
-		throw InvalidInputException("Maximum line size of %llu bytes exceeded!", options.maximum_line_size);
-	}
-
-	buffer = unique_ptr<char[]>(new char[buffer_read_size + remaining + 1]);
-	buffer_size = remaining + buffer_read_size;
-	if (remaining > 0) {
-		// remaining from last buffer: copy it here
-		memcpy(buffer.get(), old_buffer.get() + start, remaining);
-	}
-	idx_t read_count = file_handle->Read(buffer.get() + remaining, buffer_read_size);
-
-	bytes_in_chunk += read_count;
-	buffer_size = remaining + read_count;
-	buffer[buffer_size] = '\0';
-	if (old_buffer) {
-		cached_buffers.push_back(move(old_buffer));
-	}
-	start = 0;
-	position = remaining;
-	if (!bom_checked) {
-		bom_checked = true;
-		if (read_count >= 3 && buffer[0] == '\xEF' && buffer[1] == '\xBB' && buffer[2] == '\xBF') {
-			position += 3;
-		}
-	}
-
-	return read_count > 0;
-}
-
-void BufferedCSVReader::ParseCSV(DataChunk &insert_chunk) {
-	// if no auto-detect or auto-detect with jumping samples, we have nothing cached and start from the beginning
-	if (cached_chunks.empty()) {
-		cached_buffers.clear();
-	} else {
-		auto &chunk = cached_chunks.front();
-		parse_chunk.Move(*chunk);
-		cached_chunks.pop();
-		Flush(insert_chunk);
-		return;
-	}
-
-	string error_message;
-	if (!TryParseCSV(ParserMode::PARSING, insert_chunk, error_message)) {
-		throw InvalidInputException(error_message);
-	}
-}
-
-bool BufferedCSVReader::TryParseCSV(ParserMode mode) {
-	DataChunk dummy_chunk;
-	string error_message;
-	return TryParseCSV(mode, dummy_chunk, error_message);
-}
-
-void BufferedCSVReader::ParseCSV(ParserMode mode) {
-	DataChunk dummy_chunk;
-	string error_message;
-	if (!TryParseCSV(mode, dummy_chunk, error_message)) {
-		throw InvalidInputException(error_message);
-	}
-}
-
-bool BufferedCSVReader::TryParseCSV(ParserMode parser_mode, DataChunk &insert_chunk, string &error_message) {
-	mode = parser_mode;
-
-	if (options.quote.size() <= 1 && options.escape.size() <= 1 && options.delimiter.size() == 1) {
-		return TryParseSimpleCSV(insert_chunk, error_message);
-	} else {
-		return TryParseComplexCSV(insert_chunk, error_message);
-	}
-}
-
-void BufferedCSVReader::AddValue(char *str_val, idx_t length, idx_t &column, vector<idx_t> &escape_positions) {
-	if (length == 0 && column == 0) {
-		row_empty = true;
-	} else {
-		row_empty = false;
-	}
-
-	if (!sql_types.empty() && column == sql_types.size() && length == 0) {
-		// skip a single trailing delimiter in last column
-		return;
-	}
-	if (mode == ParserMode::SNIFFING_DIALECT) {
-		column++;
-		return;
-	}
-	if (column >= sql_types.size()) {
-		if (options.ignore_errors) {
-			error_column_overflow = true;
-			return;
-		} else {
-			throw InvalidInputException("Error on line %s: expected %lld values per row, but got more. (%s)",
-			                            GetLineNumberStr(linenr, linenr_estimated).c_str(), sql_types.size(),
-			                            options.ToString());
-		}
-	}
-
-	// insert the line number into the chunk
-	idx_t row_entry = parse_chunk.size();
-
-	str_val[length] = '\0';
-
-	// test against null string
-	if (!options.force_not_null[column] && strcmp(options.null_str.c_str(), str_val) == 0) {
-		FlatVector::SetNull(parse_chunk.data[column], row_entry, true);
-	} else {
-		auto &v = parse_chunk.data[column];
-		auto parse_data = FlatVector::GetData<string_t>(v);
-		if (!escape_positions.empty()) {
-			// remove escape characters (if any)
-			string old_val = str_val;
-			string new_val = "";
-			idx_t prev_pos = 0;
-			for (idx_t i = 0; i < escape_positions.size(); i++) {
-				idx_t next_pos = escape_positions[i];
-				new_val += old_val.substr(prev_pos, next_pos - prev_pos);
-
-				if (options.escape.empty() || options.escape == options.quote) {
-					prev_pos = next_pos + options.quote.size();
-				} else {
-					prev_pos = next_pos + options.escape.size();
-				}
-			}
-			new_val += old_val.substr(prev_pos, old_val.size() - prev_pos);
-			escape_positions.clear();
-			parse_data[row_entry] = StringVector::AddStringOrBlob(v, string_t(new_val));
-		} else {
-			parse_data[row_entry] = string_t(str_val, length);
-		}
-	}
-
-	// move to the next column
-	column++;
-}
-
-bool BufferedCSVReader::AddRow(DataChunk &insert_chunk, idx_t &column) {
-	linenr++;
-
-	if (row_empty) {
-		row_empty = false;
-		if (sql_types.size() != 1) {
-			column = 0;
-			return false;
-		}
-	}
-
-	// Error forwarded by 'ignore_errors' - originally encountered in 'AddValue'
-	if (error_column_overflow) {
-		D_ASSERT(options.ignore_errors);
-		error_column_overflow = false;
-		column = 0;
-		return false;
-	}
-
-	if (column < sql_types.size() && mode != ParserMode::SNIFFING_DIALECT) {
-		if (options.ignore_errors) {
-			column = 0;
-			return false;
-		} else {
-			throw InvalidInputException("Error on line %s: expected %lld values per row, but got %d. (%s)",
-			                            GetLineNumberStr(linenr, linenr_estimated).c_str(), sql_types.size(), column,
-			                            options.ToString());
-		}
-	}
-
-	if (mode == ParserMode::SNIFFING_DIALECT) {
-		sniffed_column_counts.push_back(column);
-
-		if (sniffed_column_counts.size() == options.sample_chunk_size) {
-			return true;
-		}
-	} else {
-		parse_chunk.SetCardinality(parse_chunk.size() + 1);
-	}
-
-	if (mode == ParserMode::PARSING_HEADER) {
-		return true;
-	}
-
-	if (mode == ParserMode::SNIFFING_DATATYPES && parse_chunk.size() == options.sample_chunk_size) {
-		return true;
-	}
-
-	if (mode == ParserMode::PARSING && parse_chunk.size() == STANDARD_VECTOR_SIZE) {
-		Flush(insert_chunk);
-		return true;
-	}
-
-	column = 0;
-	return false;
-}
-
-void BufferedCSVReader::Flush(DataChunk &insert_chunk) {
-	if (parse_chunk.size() == 0) {
-		return;
-	}
-
-	bool conversion_error_ignored = false;
-
-	// convert the columns in the parsed chunk to the types of the table
-	insert_chunk.SetCardinality(parse_chunk);
-	for (idx_t col_idx = 0; col_idx < sql_types.size(); col_idx++) {
-		if (sql_types[col_idx].id() == LogicalTypeId::VARCHAR) {
-			// target type is varchar: no need to convert
-			// just test that all strings are valid utf-8 strings
-			auto parse_data = FlatVector::GetData<string_t>(parse_chunk.data[col_idx]);
-			for (idx_t i = 0; i < parse_chunk.size(); i++) {
-				if (!FlatVector::IsNull(parse_chunk.data[col_idx], i)) {
-					auto s = parse_data[i];
-					auto utf_type = Utf8Proc::Analyze(s.GetDataUnsafe(), s.GetSize());
-					if (utf_type == UnicodeType::INVALID) {
-						string col_name = to_string(col_idx);
-						if (col_idx < col_names.size()) {
-							col_name = "\"" + col_names[col_idx] + "\"";
-						}
-						throw InvalidInputException("Error in file \"%s\" between line %llu and %llu in column \"%s\": "
-						                            "file is not valid UTF8. Parser options: %s",
-						                            options.file_path, linenr - parse_chunk.size(), linenr, col_name,
-						                            options.ToString());
-					}
-				}
-			}
-			insert_chunk.data[col_idx].Reference(parse_chunk.data[col_idx]);
-		} else {
-			string error_message;
-			bool success;
-			if (options.has_format[LogicalTypeId::DATE] && sql_types[col_idx].id() == LogicalTypeId::DATE) {
-				// use the date format to cast the chunk
-				success = TryCastDateVector(options, parse_chunk.data[col_idx], insert_chunk.data[col_idx],
-				                            parse_chunk.size(), error_message);
-			} else if (options.has_format[LogicalTypeId::TIMESTAMP] &&
-			           sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP) {
-				// use the date format to cast the chunk
-				success = TryCastTimestampVector(options, parse_chunk.data[col_idx], insert_chunk.data[col_idx],
-				                                 parse_chunk.size(), error_message);
-			} else {
-				// target type is not varchar: perform a cast
-				success = VectorOperations::TryCast(parse_chunk.data[col_idx], insert_chunk.data[col_idx],
-				                                    parse_chunk.size(), &error_message);
-			}
-			if (success) {
-				continue;
-			}
-			if (options.ignore_errors) {
-				conversion_error_ignored = true;
-				continue;
-			}
-			string col_name = to_string(col_idx);
-			if (col_idx < col_names.size()) {
-				col_name = "\"" + col_names[col_idx] + "\"";
-			}
-
-			if (options.auto_detect) {
-				throw InvalidInputException("%s in column %s, between line %llu and %llu. Parser "
-				                            "options: %s. Consider either increasing the sample size "
-				                            "(SAMPLE_SIZE=X [X rows] or SAMPLE_SIZE=-1 [all rows]), "
-				                            "or skipping column conversion (ALL_VARCHAR=1)",
-				                            error_message, col_name, linenr - parse_chunk.size() + 1, linenr,
-				                            options.ToString());
-			} else {
-				throw InvalidInputException("%s between line %llu and %llu in column %s. Parser options: %s ",
-				                            error_message, linenr - parse_chunk.size(), linenr, col_name,
-				                            options.ToString());
-			}
-		}
-	}
-	if (conversion_error_ignored) {
-		D_ASSERT(options.ignore_errors);
-		SelectionVector succesful_rows;
-		succesful_rows.Initialize(parse_chunk.size());
-		idx_t sel_size = 0;
-
-		for (idx_t row_idx = 0; row_idx < parse_chunk.size(); row_idx++) {
-			bool failed = false;
-			for (idx_t column_idx = 0; column_idx < sql_types.size(); column_idx++) {
-
-				auto &inserted_column = insert_chunk.data[column_idx];
-				auto &parsed_column = parse_chunk.data[column_idx];
-
-				bool was_already_null = FlatVector::IsNull(parsed_column, row_idx);
-				if (!was_already_null && FlatVector::IsNull(inserted_column, row_idx)) {
-					failed = true;
-					break;
-				}
-			}
-			if (!failed) {
-				succesful_rows.set_index(sel_size++, row_idx);
-			}
-		}
-		insert_chunk.Slice(succesful_rows, sel_size);
-	}
-	parse_chunk.Reset();
-}
-} // namespace duckdb
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-class CopyToFunctionGlobalState : public GlobalSinkState {
-public:
-	explicit CopyToFunctionGlobalState(unique_ptr<GlobalFunctionData> global_state)
-	    : rows_copied(0), global_state(move(global_state)) {
-	}
-
-	idx_t rows_copied;
-	unique_ptr<GlobalFunctionData> global_state;
-};
-
-class CopyToFunctionLocalState : public LocalSinkState {
-public:
-	explicit CopyToFunctionLocalState(unique_ptr<LocalFunctionData> local_state) : local_state(move(local_state)) {
-	}
-	unique_ptr<LocalFunctionData> local_state;
-};
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-void MoveTmpFile(ClientContext &context, const string &tmp_file_path) {
-	auto &fs = FileSystem::GetFileSystem(context);
-	auto file_path = tmp_file_path.substr(0, tmp_file_path.length() - 4);
-	if (fs.FileExists(file_path)) {
-		fs.RemoveFile(file_path);
-	}
-	fs.MoveFile(tmp_file_path, file_path);
-}
-
-PhysicalCopyToFile::PhysicalCopyToFile(vector<LogicalType> types, CopyFunction function_p,
-                                       unique_ptr<FunctionData> bind_data, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::COPY_TO_FILE, move(types), estimated_cardinality),
-      function(move(function_p)), bind_data(move(bind_data)) {
-}
-
-SinkResultType PhysicalCopyToFile::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-                                        DataChunk &input) const {
-	auto &g = (CopyToFunctionGlobalState &)gstate;
-	auto &l = (CopyToFunctionLocalState &)lstate;
-
-	g.rows_copied += input.size();
-	function.copy_to_sink(context, *bind_data, *g.global_state, *l.local_state, input);
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalCopyToFile::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &g = (CopyToFunctionGlobalState &)gstate;
-	auto &l = (CopyToFunctionLocalState &)lstate;
-
-	if (function.copy_to_combine) {
-		function.copy_to_combine(context, *bind_data, *g.global_state, *l.local_state);
-	}
-}
-
-SinkFinalizeType PhysicalCopyToFile::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                              GlobalSinkState &gstate_p) const {
-	auto &gstate = (CopyToFunctionGlobalState &)gstate_p;
-	if (function.copy_to_finalize) {
-		function.copy_to_finalize(context, *bind_data, *gstate.global_state);
-
-		if (use_tmp_file) {
-			MoveTmpFile(context, file_path);
-		}
-	}
-	return SinkFinalizeType::READY;
-}
-
-unique_ptr<LocalSinkState> PhysicalCopyToFile::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<CopyToFunctionLocalState>(function.copy_to_initialize_local(context, *bind_data));
-}
-unique_ptr<GlobalSinkState> PhysicalCopyToFile::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<CopyToFunctionGlobalState>(function.copy_to_initialize_global(context, *bind_data, file_path));
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CopyToFileState : public GlobalSourceState {
-public:
-	CopyToFileState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCopyToFile::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CopyToFileState>();
-}
-
-void PhysicalCopyToFile::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                 LocalSourceState &lstate) const {
-	auto &state = (CopyToFileState &)gstate;
-	auto &g = (CopyToFunctionGlobalState &)*sink_state;
-	if (state.finished) {
-		return;
-	}
-
-	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(g.rows_copied));
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class DeleteGlobalState : public GlobalSinkState {
-public:
-	explicit DeleteGlobalState(Allocator &allocator)
-	    : deleted_count(0), return_chunk_collection(allocator), returned_chunk_count(0) {
-	}
-
-	mutex delete_lock;
-	idx_t deleted_count;
-	ChunkCollection return_chunk_collection;
-	idx_t returned_chunk_count;
-};
-
-class DeleteLocalState : public LocalSinkState {
-public:
-	DeleteLocalState(Allocator &allocator, const vector<LogicalType> &table_types) {
-		delete_chunk.Initialize(allocator, table_types);
-	}
-	DataChunk delete_chunk;
-};
-
-SinkResultType PhysicalDelete::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                    DataChunk &input) const {
-	auto &gstate = (DeleteGlobalState &)state;
-	auto &ustate = (DeleteLocalState &)lstate;
-
-	// get rows and
-	auto &transaction = Transaction::GetTransaction(context.client);
-	auto &row_identifiers = input.data[row_id_index];
-
-	vector<column_t> column_ids;
-	for (idx_t i = 0; i < table.column_definitions.size(); i++) {
-		column_ids.emplace_back(i);
-	};
-	auto cfs = ColumnFetchState();
-
-	lock_guard<mutex> delete_guard(gstate.delete_lock);
-	if (return_chunk) {
-		row_identifiers.Normalify(input.size());
-		table.Fetch(transaction, ustate.delete_chunk, column_ids, row_identifiers, input.size(), cfs);
-		gstate.return_chunk_collection.Append(ustate.delete_chunk);
-	}
-	gstate.deleted_count += table.Delete(tableref, context.client, row_identifiers, input.size());
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<GlobalSinkState> PhysicalDelete::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<DeleteGlobalState>(Allocator::Get(context));
-}
-
-unique_ptr<LocalSinkState> PhysicalDelete::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<DeleteLocalState>(Allocator::Get(context.client), table.GetTypes());
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class DeleteSourceState : public GlobalSourceState {
-public:
-	DeleteSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalDelete::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<DeleteSourceState>();
-}
-
-void PhysicalDelete::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	auto &state = (DeleteSourceState &)gstate;
-	auto &g = (DeleteGlobalState &)*sink_state;
-	if (state.finished) {
-		return;
-	}
-
-	if (!return_chunk) {
-		chunk.SetCardinality(1);
-		chunk.SetValue(0, 0, Value::BIGINT(g.deleted_count));
-		state.finished = true;
-	}
-
-	idx_t chunk_return = g.returned_chunk_count;
-	if (chunk_return >= g.return_chunk_collection.Chunks().size()) {
-		return;
-	}
-	chunk.Reference(g.return_chunk_collection.GetChunk(chunk_return));
-	chunk.SetCardinality((g.return_chunk_collection.GetChunk(chunk_return)).size());
-	g.returned_chunk_count += 1;
-	if (g.returned_chunk_count >= g.return_chunk_collection.Chunks().size()) {
-		state.finished = true;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-#include <sstream>
-
-namespace duckdb {
-
-using std::stringstream;
-
-static void WriteCatalogEntries(stringstream &ss, vector<CatalogEntry *> &entries) {
-	for (auto &entry : entries) {
-		if (entry->internal) {
-			continue;
-		}
-		ss << entry->ToSQL() << std::endl;
-	}
-	ss << std::endl;
-}
-
-static void WriteStringStreamToFile(FileSystem &fs, FileOpener *opener, stringstream &ss, const string &path) {
-	auto ss_string = ss.str();
-	auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW,
-	                          FileLockType::WRITE_LOCK, FileSystem::DEFAULT_COMPRESSION, opener);
-	fs.Write(*handle, (void *)ss_string.c_str(), ss_string.size());
-	handle.reset();
-}
-
-static void WriteValueAsSQL(stringstream &ss, Value &val) {
-	if (val.type().IsNumeric()) {
-		ss << val.ToString();
-	} else {
-		ss << "'" << val.ToString() << "'";
-	}
-}
-
-static void WriteCopyStatement(FileSystem &fs, stringstream &ss, TableCatalogEntry *table, CopyInfo &info,
-                               ExportedTableData &exported_table, CopyFunction const &function) {
-	ss << "COPY ";
-
-	if (exported_table.schema_name != DEFAULT_SCHEMA) {
-		ss << KeywordHelper::WriteOptionallyQuoted(exported_table.schema_name) << ".";
-	}
-
-	ss << KeywordHelper::WriteOptionallyQuoted(exported_table.table_name) << " FROM '" << exported_table.file_path
-	   << "' (";
-
-	// write the copy options
-	ss << "FORMAT '" << info.format << "'";
-	if (info.format == "csv") {
-		// insert default csv options, if not specified
-		if (info.options.find("header") == info.options.end()) {
-			info.options["header"].push_back(Value::INTEGER(0));
-		}
-		if (info.options.find("delimiter") == info.options.end() && info.options.find("sep") == info.options.end() &&
-		    info.options.find("delim") == info.options.end()) {
-			info.options["delimiter"].push_back(Value(","));
-		}
-		if (info.options.find("quote") == info.options.end()) {
-			info.options["quote"].push_back(Value("\""));
-		}
-	}
-	for (auto &copy_option : info.options) {
-		ss << ", " << copy_option.first << " ";
-		if (copy_option.second.size() == 1) {
-			WriteValueAsSQL(ss, copy_option.second[0]);
-		} else {
-			// FIXME handle multiple options
-			throw NotImplementedException("FIXME: serialize list of options");
-		}
-	}
-	ss << ");" << std::endl;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class ExportSourceState : public GlobalSourceState {
-public:
-	ExportSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalExport::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<ExportSourceState>();
-}
-
-void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	auto &state = (ExportSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-
-	auto &ccontext = context.client;
-	auto &fs = FileSystem::GetFileSystem(ccontext);
-	auto *opener = FileSystem::GetFileOpener(ccontext);
-
-	// gather all catalog types to export
-	vector<CatalogEntry *> schemas;
-	vector<CatalogEntry *> custom_types;
-	vector<CatalogEntry *> sequences;
-	vector<CatalogEntry *> tables;
-	vector<CatalogEntry *> views;
-	vector<CatalogEntry *> indexes;
-	vector<CatalogEntry *> macros;
-
-	auto schema_list = Catalog::GetCatalog(ccontext).schemas->GetEntries<SchemaCatalogEntry>(context.client);
-	for (auto &schema : schema_list) {
-		if (!schema->internal) {
-			schemas.push_back(schema);
-		}
-		schema->Scan(context.client, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-			if (entry->internal) {
-				return;
-			}
-			if (entry->type != CatalogType::TABLE_ENTRY) {
-				views.push_back(entry);
-			}
-		});
-		schema->Scan(context.client, CatalogType::SEQUENCE_ENTRY,
-		             [&](CatalogEntry *entry) { sequences.push_back(entry); });
-		schema->Scan(context.client, CatalogType::TYPE_ENTRY,
-		             [&](CatalogEntry *entry) { custom_types.push_back(entry); });
-		schema->Scan(context.client, CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) { indexes.push_back(entry); });
-		schema->Scan(context.client, CatalogType::MACRO_ENTRY, [&](CatalogEntry *entry) {
-			if (!entry->internal && entry->type == CatalogType::MACRO_ENTRY) {
-				macros.push_back(entry);
-			}
-		});
-		schema->Scan(context.client, CatalogType::TABLE_MACRO_ENTRY, [&](CatalogEntry *entry) {
-			if (!entry->internal && entry->type == CatalogType::TABLE_MACRO_ENTRY) {
-				macros.push_back(entry);
-			}
-		});
-	}
-
-	// consider the order of tables because of foreign key constraint
-	for (idx_t i = 0; i < exported_tables.data.size(); i++) {
-		tables.push_back((CatalogEntry *)exported_tables.data[i].entry);
-	}
-
-	// order macro's by timestamp so nested macro's are imported nicely
-	sort(macros.begin(), macros.end(),
-	     [](const CatalogEntry *lhs, const CatalogEntry *rhs) { return lhs->oid < rhs->oid; });
-
-	// write the schema.sql file
-	// export order is SCHEMA -> SEQUENCE -> TABLE -> VIEW -> INDEX
-
-	stringstream ss;
-	WriteCatalogEntries(ss, schemas);
-	WriteCatalogEntries(ss, custom_types);
-	WriteCatalogEntries(ss, sequences);
-	WriteCatalogEntries(ss, tables);
-	WriteCatalogEntries(ss, views);
-	WriteCatalogEntries(ss, indexes);
-	WriteCatalogEntries(ss, macros);
-
-	WriteStringStreamToFile(fs, opener, ss, fs.JoinPath(info->file_path, "schema.sql"));
-
-	// write the load.sql file
-	// for every table, we write COPY INTO statement with the specified options
-	stringstream load_ss;
-	for (idx_t i = 0; i < exported_tables.data.size(); i++) {
-		auto &table = exported_tables.data[i].entry;
-		auto exported_table_info = exported_tables.data[i].table_data;
-		WriteCopyStatement(fs, load_ss, table, *info, exported_table_info, function);
-	}
-	WriteStringStreamToFile(fs, opener, load_ss, fs.JoinPath(info->file_path, "load.sql"));
-	state.finished = true;
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-SinkResultType PhysicalExport::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-                                    DataChunk &input) const {
-	// nop
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalExport::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	// EXPORT has an optional child
-	// we only need to schedule child pipelines if there is a child
-	state.SetPipelineSource(current, this);
-	if (children.empty()) {
-		return;
-	}
-	PhysicalOperator::BuildPipelines(executor, current, state);
-}
-
-vector<const PhysicalOperator *> PhysicalExport::GetSources() const {
-	return {this};
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class InsertGlobalState : public GlobalSinkState {
-public:
-	explicit InsertGlobalState(Allocator &allocator)
-	    : insert_count(0), return_chunk_collection(allocator), returned_chunk_count(0) {
-	}
-
-	mutex lock;
-	idx_t insert_count;
-	ChunkCollection return_chunk_collection;
-	idx_t returned_chunk_count;
-};
-
-class InsertLocalState : public LocalSinkState {
-public:
-	InsertLocalState(Allocator &allocator, const vector<LogicalType> &types,
-	                 const vector<unique_ptr<Expression>> &bound_defaults)
-	    : default_executor(allocator, bound_defaults) {
-		insert_chunk.Initialize(allocator, types);
-	}
-
-	DataChunk insert_chunk;
-	ExpressionExecutor default_executor;
-};
-
-PhysicalInsert::PhysicalInsert(vector<LogicalType> types, TableCatalogEntry *table, vector<idx_t> column_index_map,
-                               vector<unique_ptr<Expression>> bound_defaults, idx_t estimated_cardinality,
-                               bool return_chunk)
-    : PhysicalOperator(PhysicalOperatorType::INSERT, move(types), estimated_cardinality),
-      column_index_map(std::move(column_index_map)), table(table), bound_defaults(move(bound_defaults)),
-      return_chunk(return_chunk) {
-}
-
-SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                    DataChunk &chunk) const {
-	auto &gstate = (InsertGlobalState &)state;
-	auto &istate = (InsertLocalState &)lstate;
-
-	chunk.Normalify();
-	istate.default_executor.SetChunk(chunk);
-
-	istate.insert_chunk.Reset();
-	istate.insert_chunk.SetCardinality(chunk);
-
-	if (!column_index_map.empty()) {
-		// columns specified by the user, use column_index_map
-		for (idx_t i = 0; i < table->columns.size(); i++) {
-			auto &col = table->columns[i];
-			if (col.Generated()) {
-				continue;
-			}
-			auto storage_idx = col.StorageOid();
-			if (column_index_map[i] == DConstants::INVALID_INDEX) {
-				// insert default value
-				istate.default_executor.ExecuteExpression(i, istate.insert_chunk.data[storage_idx]);
-			} else {
-				// get value from child chunk
-				D_ASSERT((idx_t)column_index_map[i] < chunk.ColumnCount());
-				D_ASSERT(istate.insert_chunk.data[storage_idx].GetType() == chunk.data[column_index_map[i]].GetType());
-				istate.insert_chunk.data[storage_idx].Reference(chunk.data[column_index_map[i]]);
-			}
-		}
-	} else {
-		// no columns specified, just append directly
-		for (idx_t i = 0; i < istate.insert_chunk.ColumnCount(); i++) {
-			D_ASSERT(istate.insert_chunk.data[i].GetType() == chunk.data[i].GetType());
-			istate.insert_chunk.data[i].Reference(chunk.data[i]);
-		}
-	}
-
-	lock_guard<mutex> glock(gstate.lock);
-	table->storage->Append(*table, context.client, istate.insert_chunk);
-
-	if (return_chunk) {
-		gstate.return_chunk_collection.Append(istate.insert_chunk);
-	}
-
-	gstate.insert_count += chunk.size();
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<InsertGlobalState>(Allocator::Get(context));
-}
-
-unique_ptr<LocalSinkState> PhysicalInsert::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<InsertLocalState>(Allocator::Get(context.client), table->GetTypes(), bound_defaults);
-}
-
-void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &state = (InsertLocalState &)lstate;
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
-	client_profiler.Flush(context.thread.profiler);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class InsertSourceState : public GlobalSourceState {
-public:
-	InsertSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalInsert::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<InsertSourceState>();
-}
-
-void PhysicalInsert::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	auto &state = (InsertSourceState &)gstate;
-	auto &insert_gstate = (InsertGlobalState &)*sink_state;
-	if (state.finished) {
-		return;
-	}
-	if (!return_chunk) {
-		chunk.SetCardinality(1);
-		chunk.SetValue(0, 0, Value::BIGINT(insert_gstate.insert_count));
-		state.finished = true;
-	}
-
-	idx_t chunk_return = insert_gstate.returned_chunk_count;
-	if (chunk_return >= insert_gstate.return_chunk_collection.Chunks().size()) {
-		return;
-	}
-
-	chunk.Reference(insert_gstate.return_chunk_collection.GetChunk(chunk_return));
-	chunk.SetCardinality((insert_gstate.return_chunk_collection.GetChunk(chunk_return)).size());
-	insert_gstate.returned_chunk_count += 1;
-	if (insert_gstate.returned_chunk_count >= insert_gstate.return_chunk_collection.Chunks().size()) {
-		state.finished = true;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class UpdateGlobalState : public GlobalSinkState {
-public:
-	explicit UpdateGlobalState(Allocator &allocator)
-	    : updated_count(0), return_chunk_collection(allocator), returned_chunk_count(0) {
-	}
-
-	mutex lock;
-	idx_t updated_count;
-	unordered_set<row_t> updated_columns;
-	ChunkCollection return_chunk_collection;
-	idx_t returned_chunk_count;
-};
-
-class UpdateLocalState : public LocalSinkState {
-public:
-	UpdateLocalState(Allocator &allocator, const vector<unique_ptr<Expression>> &expressions,
-	                 const vector<LogicalType> &table_types, const vector<unique_ptr<Expression>> &bound_defaults)
-	    : default_executor(allocator, bound_defaults) {
-		// initialize the update chunk
-		vector<LogicalType> update_types;
-		update_types.reserve(expressions.size());
-		for (auto &expr : expressions) {
-			update_types.push_back(expr->return_type);
-		}
-		update_chunk.Initialize(allocator, update_types);
-		// initialize the mock chunk
-		mock_chunk.Initialize(allocator, table_types);
-	}
-
-	DataChunk update_chunk;
-	DataChunk mock_chunk;
-	ExpressionExecutor default_executor;
-};
-
-SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                    DataChunk &chunk) const {
-	auto &gstate = (UpdateGlobalState &)state;
-	auto &ustate = (UpdateLocalState &)lstate;
-
-	DataChunk &update_chunk = ustate.update_chunk;
-	DataChunk &mock_chunk = ustate.mock_chunk;
-
-	chunk.Normalify();
-	ustate.default_executor.SetChunk(chunk);
-
-	// update data in the base table
-	// the row ids are given to us as the last column of the child chunk
-	auto &row_ids = chunk.data[chunk.ColumnCount() - 1];
-	update_chunk.SetCardinality(chunk);
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (expressions[i]->type == ExpressionType::VALUE_DEFAULT) {
-			// default expression, set to the default value of the column
-			ustate.default_executor.ExecuteExpression(columns[i], update_chunk.data[i]);
-		} else {
-			D_ASSERT(expressions[i]->type == ExpressionType::BOUND_REF);
-			// index into child chunk
-			auto &binding = (BoundReferenceExpression &)*expressions[i];
-			update_chunk.data[i].Reference(chunk.data[binding.index]);
-		}
-	}
-
-	lock_guard<mutex> glock(gstate.lock);
-	if (update_is_del_and_insert) {
-		// index update or update on complex type, perform a delete and an append instead
-
-		// figure out which rows have not yet been deleted in this update
-		// this is required since we might see the same row_id multiple times
-		// in the case of an UPDATE query that e.g. has joins
-		auto row_id_data = FlatVector::GetData<row_t>(row_ids);
-		SelectionVector sel(STANDARD_VECTOR_SIZE);
-		idx_t update_count = 0;
-		for (idx_t i = 0; i < update_chunk.size(); i++) {
-			auto row_id = row_id_data[i];
-			if (gstate.updated_columns.find(row_id) == gstate.updated_columns.end()) {
-				gstate.updated_columns.insert(row_id);
-				sel.set_index(update_count++, i);
-			}
-		}
-		if (update_count != update_chunk.size()) {
-			// we need to slice here
-			update_chunk.Slice(sel, update_count);
-		}
-		table.Delete(tableref, context.client, row_ids, update_chunk.size());
-		// for the append we need to arrange the columns in a specific manner (namely the "standard table order")
-		mock_chunk.SetCardinality(update_chunk);
-		for (idx_t i = 0; i < columns.size(); i++) {
-			mock_chunk.data[columns[i]].Reference(update_chunk.data[i]);
-		}
-		table.Append(tableref, context.client, mock_chunk);
-	} else {
-		if (return_chunk) {
-			mock_chunk.SetCardinality(update_chunk);
-			for (idx_t i = 0; i < columns.size(); i++) {
-				mock_chunk.data[columns[i]].Reference(update_chunk.data[i]);
-			}
-		}
-		table.Update(tableref, context.client, row_ids, columns, update_chunk);
-	}
-
-	if (return_chunk) {
-		gstate.return_chunk_collection.Append(mock_chunk);
-	}
-
-	gstate.updated_count += chunk.size();
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<GlobalSinkState> PhysicalUpdate::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<UpdateGlobalState>(Allocator::Get(context));
-}
-
-unique_ptr<LocalSinkState> PhysicalUpdate::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<UpdateLocalState>(Allocator::Get(context.client), expressions, table.GetTypes(), bound_defaults);
-}
-
-void PhysicalUpdate::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &state = (UpdateLocalState &)lstate;
-	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
-	client_profiler.Flush(context.thread.profiler);
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class UpdateSourceState : public GlobalSourceState {
-public:
-	UpdateSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalUpdate::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<UpdateSourceState>();
-}
-
-void PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	auto &state = (UpdateSourceState &)gstate;
-	auto &g = (UpdateGlobalState &)*sink_state;
-	if (state.finished) {
-		return;
-	}
-	if (!return_chunk) {
-		chunk.SetCardinality(1);
-		chunk.SetValue(0, 0, Value::BIGINT(g.updated_count));
-		state.finished = true;
-	}
-
-	idx_t chunk_return = g.returned_chunk_count;
-	if (chunk_return >= g.return_chunk_collection.Chunks().size()) {
-		return;
-	}
-	chunk.Reference(g.return_chunk_collection.GetChunk(chunk_return));
-	chunk.SetCardinality((g.return_chunk_collection.GetChunk(chunk_return)).size());
-	g.returned_chunk_count += 1;
-	if (g.returned_chunk_count >= g.return_chunk_collection.Chunks().size()) {
-		state.finished = true;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-class ProjectionState : public OperatorState {
-public:
-	explicit ProjectionState(ExecutionContext &context, const vector<unique_ptr<Expression>> &expressions)
-	    : executor(Allocator::Get(context.client), expressions) {
-	}
-
-	ExpressionExecutor executor;
-
-public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &executor, "projection", 0);
-	}
-};
-
-PhysicalProjection::PhysicalProjection(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                                       idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::PROJECTION, move(types), estimated_cardinality),
-      select_list(move(select_list)) {
-}
-
-OperatorResultType PhysicalProjection::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                               GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (ProjectionState &)state_p;
-	state.executor.Execute(input, chunk);
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-unique_ptr<OperatorState> PhysicalProjection::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<ProjectionState>(context, select_list);
-}
-
-string PhysicalProjection::ParamsToString() const {
-	string extra_info;
-	for (auto &expr : select_list) {
-		extra_info += expr->GetName() + "\n";
-	}
-	return extra_info;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class TableInOutLocalState : public OperatorState {
-public:
-	TableInOutLocalState() {
-	}
-
-	unique_ptr<LocalTableFunctionState> local_state;
-};
-
-class TableInOutGlobalState : public GlobalOperatorState {
-public:
-	TableInOutGlobalState() {
-	}
-
-	unique_ptr<GlobalTableFunctionState> global_state;
-};
-
-PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types, TableFunction function_p,
-                                                       unique_ptr<FunctionData> bind_data_p,
-                                                       vector<column_t> column_ids_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::INOUT_FUNCTION, move(types), estimated_cardinality),
-      function(move(function_p)), bind_data(move(bind_data_p)), column_ids(move(column_ids_p)) {
-}
-
-unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(ExecutionContext &context) const {
-	auto &gstate = (TableInOutGlobalState &)*op_state;
-	auto result = make_unique<TableInOutLocalState>();
-	if (function.init_local) {
-		TableFunctionInitInput input(bind_data.get(), column_ids, nullptr);
-		result->local_state = function.init_local(context, input, gstate.global_state.get());
-	}
-	return move(result);
-}
-
-unique_ptr<GlobalOperatorState> PhysicalTableInOutFunction::GetGlobalOperatorState(ClientContext &context) const {
-	auto result = make_unique<TableInOutGlobalState>();
-	if (function.init_global) {
-		TableFunctionInitInput input(bind_data.get(), column_ids, nullptr);
-		result->global_state = function.init_global(context, input);
-	}
-	return move(result);
-}
-
-OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                       GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (TableInOutGlobalState &)gstate_p;
-	auto &state = (TableInOutLocalState &)state_p;
-	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
-	return function.in_out_function(context, data, input, chunk);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class UnnestOperatorState : public OperatorState {
-public:
-	UnnestOperatorState(Allocator &allocator, const vector<unique_ptr<Expression>> &select_list)
-	    : parent_position(0), list_position(0), list_length(-1), first_fetch(true), executor(allocator) {
-		vector<LogicalType> list_data_types;
-		for (auto &exp : select_list) {
-			D_ASSERT(exp->type == ExpressionType::BOUND_UNNEST);
-			auto bue = (BoundUnnestExpression *)exp.get();
-			list_data_types.push_back(bue->child->return_type);
-			executor.AddExpression(*bue->child.get());
-		}
-		list_data.Initialize(allocator, list_data_types);
-
-		list_vector_data.resize(list_data.ColumnCount());
-		list_child_data.resize(list_data.ColumnCount());
-	}
-
-	idx_t parent_position;
-	idx_t list_position;
-	int64_t list_length;
-	bool first_fetch;
-
-	ExpressionExecutor executor;
-	DataChunk list_data;
-	vector<VectorData> list_vector_data;
-	vector<VectorData> list_child_data;
-};
-
-// this implements a sorted window functions variant
-PhysicalUnnest::PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                               idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, move(types), estimated_cardinality), select_list(std::move(select_list)) {
-	D_ASSERT(!this->select_list.empty());
-}
-
-static void UnnestNull(idx_t start, idx_t end, Vector &result) {
-	if (result.GetType().InternalType() == PhysicalType::STRUCT) {
-		auto &children = StructVector::GetEntries(result);
-		for (auto &child : children) {
-			UnnestNull(start, end, *child);
-		}
-	}
-	auto &validity = FlatVector::Validity(result);
-	for (idx_t i = start; i < end; i++) {
-		validity.SetInvalid(i);
-	}
-	if (result.GetType().InternalType() == PhysicalType::STRUCT) {
-		auto &struct_children = StructVector::GetEntries(result);
-		for (auto &child : struct_children) {
-			UnnestNull(start, end, *child);
-		}
-	}
-}
-
-template <class T>
-static void TemplatedUnnest(VectorData &vdata, idx_t start, idx_t end, Vector &result) {
-	auto source_data = (T *)vdata.data;
-	auto &source_mask = vdata.validity;
-	auto result_data = FlatVector::GetData<T>(result);
-	auto &result_mask = FlatVector::Validity(result);
-
-	for (idx_t i = start; i < end; i++) {
-		auto source_idx = vdata.sel->get_index(i);
-		auto target_idx = i - start;
-		if (source_mask.RowIsValid(source_idx)) {
-			result_data[target_idx] = source_data[source_idx];
-			result_mask.SetValid(target_idx);
-		} else {
-			result_mask.SetInvalid(target_idx);
-		}
-	}
-}
-
-static void UnnestValidity(VectorData &vdata, idx_t start, idx_t end, Vector &result) {
-	auto &source_mask = vdata.validity;
-	auto &result_mask = FlatVector::Validity(result);
-
-	for (idx_t i = start; i < end; i++) {
-		auto source_idx = vdata.sel->get_index(i);
-		auto target_idx = i - start;
-		result_mask.Set(target_idx, source_mask.RowIsValid(source_idx));
-	}
-}
-
-static void UnnestVector(VectorData &vdata, Vector &source, idx_t list_size, idx_t start, idx_t end, Vector &result) {
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedUnnest<int8_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::INT16:
-		TemplatedUnnest<int16_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::INT32:
-		TemplatedUnnest<int32_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::INT64:
-		TemplatedUnnest<int64_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::INT128:
-		TemplatedUnnest<hugeint_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedUnnest<uint8_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedUnnest<uint16_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedUnnest<uint32_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedUnnest<uint64_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedUnnest<float>(vdata, start, end, result);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedUnnest<double>(vdata, start, end, result);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedUnnest<interval_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedUnnest<string_t>(vdata, start, end, result);
-		break;
-	case PhysicalType::LIST: {
-		auto &target = ListVector::GetEntry(result);
-		target.Reference(ListVector::GetEntry(source));
-		ListVector::SetListSize(result, ListVector::GetListSize(source));
-		TemplatedUnnest<list_entry_t>(vdata, start, end, result);
-		break;
-	}
-	case PhysicalType::STRUCT: {
-		auto &source_entries = StructVector::GetEntries(source);
-		auto &target_entries = StructVector::GetEntries(result);
-		UnnestValidity(vdata, start, end, result);
-		for (idx_t i = 0; i < source_entries.size(); i++) {
-			VectorData sdata;
-			source_entries[i]->Orrify(list_size, sdata);
-			UnnestVector(sdata, *source_entries[i], list_size, start, end, *target_entries[i]);
-		}
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented type for UNNEST");
-	}
-}
-
-unique_ptr<OperatorState> PhysicalUnnest::GetOperatorState(ExecutionContext &context) const {
-	return PhysicalUnnest::GetState(context, select_list);
-}
-
-unique_ptr<OperatorState> PhysicalUnnest::GetState(ExecutionContext &context,
-                                                   const vector<unique_ptr<Expression>> &select_list) {
-	return make_unique<UnnestOperatorState>(Allocator::Get(context.client), select_list);
-}
-
-OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   OperatorState &state_p,
-                                                   const vector<unique_ptr<Expression>> &select_list,
-                                                   bool include_input) {
-	auto &state = (UnnestOperatorState &)state_p;
-	do {
-		if (state.first_fetch) {
-			// get the list data to unnest
-			state.list_data.Reset();
-			state.executor.Execute(input, state.list_data);
-
-			// paranoia aplenty
-			state.list_data.Verify();
-			D_ASSERT(input.size() == state.list_data.size());
-			D_ASSERT(state.list_data.ColumnCount() == select_list.size());
-			D_ASSERT(state.list_vector_data.size() == state.list_data.ColumnCount());
-			D_ASSERT(state.list_child_data.size() == state.list_data.ColumnCount());
-
-			// initialize VectorData object so the nullmask can accessed
-			for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-				auto &list_vector = state.list_data.data[col_idx];
-				list_vector.Orrify(state.list_data.size(), state.list_vector_data[col_idx]);
-
-				if (list_vector.GetType() == LogicalType::SQLNULL) {
-					// UNNEST(NULL)
-					auto &child_vector = list_vector;
-					child_vector.Orrify(0, state.list_child_data[col_idx]);
-				} else {
-					auto list_size = ListVector::GetListSize(list_vector);
-					auto &child_vector = ListVector::GetEntry(list_vector);
-					child_vector.Orrify(list_size, state.list_child_data[col_idx]);
-				}
-			}
-			state.first_fetch = false;
-		}
-		if (state.parent_position >= input.size()) {
-			// finished with this input chunk
-			state.parent_position = 0;
-			state.list_position = 0;
-			state.list_length = -1;
-			state.first_fetch = true;
-			return OperatorResultType::NEED_MORE_INPUT;
-		}
-
-		// need to figure out how many times we need to repeat for current row
-		if (state.list_length < 0) {
-			for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-				auto &vdata = state.list_vector_data[col_idx];
-				auto current_idx = vdata.sel->get_index(state.parent_position);
-
-				int64_t list_length;
-				// deal with NULL values
-				if (!vdata.validity.RowIsValid(current_idx)) {
-					list_length = 0;
-				} else {
-					auto list_data = (list_entry_t *)vdata.data;
-					auto list_entry = list_data[current_idx];
-					list_length = (int64_t)list_entry.length;
-				}
-
-				if (list_length > state.list_length) {
-					state.list_length = list_length;
-				}
-			}
-		}
-
-		D_ASSERT(state.list_length >= 0);
-
-		auto this_chunk_len = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.list_length - state.list_position);
-
-		// first cols are from child, last n cols from unnest
-		chunk.SetCardinality(this_chunk_len);
-
-		idx_t output_offset = 0;
-		if (include_input) {
-			for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-				ConstantVector::Reference(chunk.data[col_idx], input.data[col_idx], state.parent_position,
-				                          input.size());
-			}
-			output_offset = input.ColumnCount();
-		}
-
-		for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-			auto &result_vector = chunk.data[col_idx + output_offset];
-
-			if (state.list_data.data[col_idx].GetType() == LogicalType::SQLNULL) {
-				// UNNEST(NULL)
-				chunk.SetCardinality(0);
-			} else {
-				auto &vdata = state.list_vector_data[col_idx];
-				auto &child_data = state.list_child_data[col_idx];
-				auto current_idx = vdata.sel->get_index(state.parent_position);
-
-				auto list_data = (list_entry_t *)vdata.data;
-				auto list_entry = list_data[current_idx];
-
-				idx_t list_count;
-				if (state.list_position >= list_entry.length) {
-					list_count = 0;
-				} else {
-					list_count = MinValue<idx_t>(this_chunk_len, list_entry.length - state.list_position);
-				}
-
-				if (list_entry.length > state.list_position) {
-					if (!vdata.validity.RowIsValid(current_idx)) {
-						UnnestNull(0, list_count, result_vector);
-					} else {
-						auto &list_vector = state.list_data.data[col_idx];
-						auto &child_vector = ListVector::GetEntry(list_vector);
-						auto list_size = ListVector::GetListSize(list_vector);
-
-						auto base_offset = list_entry.offset + state.list_position;
-						UnnestVector(child_data, child_vector, list_size, base_offset, base_offset + list_count,
-						             result_vector);
-					}
-				}
-
-				UnnestNull(list_count, this_chunk_len, result_vector);
-			}
-		}
-
-		state.list_position += this_chunk_len;
-		if ((int64_t)state.list_position == state.list_length) {
-			state.parent_position++;
-			state.list_length = -1;
-			state.list_position = 0;
-		}
-
-		chunk.Verify();
-	} while (chunk.size() == 0);
-	return OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                           GlobalOperatorState &gstate, OperatorState &state) const {
-	return ExecuteInternal(context, input, chunk, state, select_list);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-class PhysicalChunkScanState : public GlobalSourceState {
-public:
-	explicit PhysicalChunkScanState() : chunk_index(0) {
-	}
-
-	//! The current position in the scan
-	idx_t chunk_index;
-};
-
-unique_ptr<GlobalSourceState> PhysicalChunkScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<PhysicalChunkScanState>();
-}
-
-void PhysicalChunkScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                LocalSourceState &lstate) const {
-	auto &state = (PhysicalChunkScanState &)gstate;
-	D_ASSERT(collection);
-	if (collection->Count() == 0) {
-		return;
-	}
-	D_ASSERT(chunk.GetTypes() == collection->Types());
-	if (state.chunk_index >= collection->ChunkCount()) {
-		return;
-	}
-	auto &collection_chunk = collection->GetChunk(state.chunk_index);
-	chunk.Reference(collection_chunk);
-	state.chunk_index++;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalChunkScan::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	// check if there is any additional action we need to do depending on the type
-	switch (type) {
-	case PhysicalOperatorType::DELIM_SCAN: {
-		auto entry = state.delim_join_dependencies.find(this);
-		D_ASSERT(entry != state.delim_join_dependencies.end());
-		// this chunk scan introduces a dependency to the current pipeline
-		// namely a dependency on the duplicate elimination pipeline to finish
-		auto delim_dependency = entry->second->shared_from_this();
-		auto delim_sink = state.GetPipelineSink(*delim_dependency);
-		D_ASSERT(delim_sink);
-		D_ASSERT(delim_sink->type == PhysicalOperatorType::DELIM_JOIN);
-		auto &delim_join = (PhysicalDelimJoin &)*delim_sink;
-		current.AddDependency(delim_dependency);
-		state.SetPipelineSource(current, (PhysicalOperator *)delim_join.distinct.get());
-		return;
-	}
-	case PhysicalOperatorType::RECURSIVE_CTE_SCAN:
-		if (!state.recursive_cte) {
-			throw InternalException("Recursive CTE scan found without recursive CTE node");
-		}
-		break;
-	default:
-		break;
-	}
-	D_ASSERT(children.empty());
-	state.SetPipelineSource(current, this);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class DummyScanState : public GlobalSourceState {
-public:
-	DummyScanState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalDummyScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<DummyScanState>();
-}
-
-void PhysicalDummyScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                LocalSourceState &lstate) const {
-	auto &state = (DummyScanState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	// return a single row on the first call to the dummy scan
-	chunk.SetCardinality(1);
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void PhysicalEmptyResult::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                  LocalSourceState &lstate) const {
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-class ExpressionScanState : public OperatorState {
-public:
-	explicit ExpressionScanState(Allocator &allocator, const PhysicalExpressionScan &op) : expression_index(0) {
-		temp_chunk.Initialize(allocator, op.GetTypes());
-	}
-
-	//! The current position in the scan
-	idx_t expression_index;
-	//! Temporary chunk for evaluating expressions
-	DataChunk temp_chunk;
-};
-
-unique_ptr<OperatorState> PhysicalExpressionScan::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<ExpressionScanState>(Allocator::Get(context.client), *this);
-}
-
-OperatorResultType PhysicalExpressionScan::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                   GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (ExpressionScanState &)state_p;
-
-	for (; chunk.size() + input.size() <= STANDARD_VECTOR_SIZE && state.expression_index < expressions.size();
-	     state.expression_index++) {
-		state.temp_chunk.Reset();
-		EvaluateExpression(Allocator::Get(context.client), state.expression_index, &input, state.temp_chunk);
-		chunk.Append(state.temp_chunk);
-	}
-	if (state.expression_index < expressions.size()) {
-		return OperatorResultType::HAVE_MORE_OUTPUT;
-	} else {
-		state.expression_index = 0;
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-}
-
-void PhysicalExpressionScan::EvaluateExpression(Allocator &allocator, idx_t expression_idx, DataChunk *child_chunk,
-                                                DataChunk &result) const {
-	ExpressionExecutor executor(allocator, expressions[expression_idx]);
-	if (child_chunk) {
-		child_chunk->Verify();
-		executor.Execute(*child_chunk, result);
-	} else {
-		executor.Execute(result);
-	}
-}
-
-bool PhysicalExpressionScan::IsFoldable() const {
-	for (auto &expr_list : expressions) {
-		for (auto &expr : expr_list) {
-			if (!expr->IsFoldable()) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <utility>
-
-namespace duckdb {
-
-PhysicalTableScan::PhysicalTableScan(vector<LogicalType> types, TableFunction function_p,
-                                     unique_ptr<FunctionData> bind_data_p, vector<column_t> column_ids_p,
-                                     vector<string> names_p, unique_ptr<TableFilterSet> table_filters_p,
-                                     idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::TABLE_SCAN, move(types), estimated_cardinality),
-      function(move(function_p)), bind_data(move(bind_data_p)), column_ids(move(column_ids_p)), names(move(names_p)),
-      table_filters(move(table_filters_p)) {
-}
-
-class TableScanGlobalSourceState : public GlobalSourceState {
-public:
-	TableScanGlobalSourceState(ClientContext &context, const PhysicalTableScan &op) {
-		if (op.function.init_global) {
-			TableFunctionInitInput input(op.bind_data.get(), op.column_ids, op.table_filters.get());
-			global_state = op.function.init_global(context, input);
-			if (global_state) {
-				max_threads = global_state->MaxThreads();
-			}
-		} else {
-			max_threads = 1;
-		}
-	}
-
-	idx_t max_threads = 0;
-	unique_ptr<GlobalTableFunctionState> global_state;
-
-	idx_t MaxThreads() override {
-		return max_threads;
-	}
-};
-
-class TableScanLocalSourceState : public LocalSourceState {
-public:
-	TableScanLocalSourceState(ExecutionContext &context, TableScanGlobalSourceState &gstate,
-	                          const PhysicalTableScan &op) {
-		if (op.function.init_local) {
-			TableFunctionInitInput input(op.bind_data.get(), op.column_ids, op.table_filters.get());
-			local_state = op.function.init_local(context, input, gstate.global_state.get());
-		}
-	}
-
-	unique_ptr<LocalTableFunctionState> local_state;
-};
-
-unique_ptr<LocalSourceState> PhysicalTableScan::GetLocalSourceState(ExecutionContext &context,
-                                                                    GlobalSourceState &gstate) const {
-	return make_unique<TableScanLocalSourceState>(context, (TableScanGlobalSourceState &)gstate, *this);
-}
-
-unique_ptr<GlobalSourceState> PhysicalTableScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<TableScanGlobalSourceState>(context, *this);
-}
-
-void PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                LocalSourceState &lstate) const {
-	D_ASSERT(!column_ids.empty());
-	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
-	auto &state = (TableScanLocalSourceState &)lstate;
-
-	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
-	function.function(context.client, data, chunk);
-}
-
-double PhysicalTableScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
-	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
-	if (function.table_scan_progress) {
-		return function.table_scan_progress(context, bind_data.get(), gstate.global_state.get());
-	}
-	// if table_scan_progress is not implemented we don't support this function yet in the progress bar
-	return -1;
-}
-
-idx_t PhysicalTableScan::GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                       LocalSourceState &lstate) const {
-	D_ASSERT(SupportsBatchIndex());
-	D_ASSERT(function.get_batch_index);
-	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
-	auto &state = (TableScanLocalSourceState &)lstate;
-	return function.get_batch_index(context.client, bind_data.get(), state.local_state.get(),
-	                                gstate.global_state.get());
-}
-
-string PhysicalTableScan::GetName() const {
-	return StringUtil::Upper(function.name);
-}
-
-string PhysicalTableScan::ParamsToString() const {
-	string result;
-	if (function.to_string) {
-		result = function.to_string(bind_data.get());
-		result += "\n[INFOSEPARATOR]\n";
-	}
-	if (function.projection_pushdown) {
-		for (idx_t i = 0; i < column_ids.size(); i++) {
-			if (column_ids[i] < names.size()) {
-				if (i > 0) {
-					result += "\n";
-				}
-				result += names[column_ids[i]];
-			}
-		}
-	}
-	if (function.filter_pushdown && table_filters) {
-		result += "\n[INFOSEPARATOR]\n";
-		result += "Filters: ";
-		for (auto &f : table_filters->filters) {
-			auto &column_index = f.first;
-			auto &filter = f.second;
-			if (column_index < names.size()) {
-				result += filter->ToString(names[column_ids[column_index]]);
-				result += "\n";
-			}
-		}
-	}
-	return result;
-}
-
-bool PhysicalTableScan::Equals(const PhysicalOperator &other_p) const {
-	if (type != other_p.type) {
-		return false;
-	}
-	auto &other = (PhysicalTableScan &)other_p;
-	if (function.function != other.function.function) {
-		return false;
-	}
-	if (column_ids != other.column_ids) {
-		return false;
-	}
-	if (!FunctionData::Equals(bind_data.get(), other.bind_data.get())) {
-		return false;
-	}
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class AlterSourceState : public GlobalSourceState {
-public:
-	AlterSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalAlter::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<AlterSourceState>();
-}
-
-void PhysicalAlter::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                            LocalSourceState &lstate) const {
-	auto &state = (AlterSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	auto &catalog = Catalog::GetCatalog(context.client);
-	catalog.Alter(context.client, info.get());
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CreateFunctionSourceState : public GlobalSourceState {
-public:
-	CreateFunctionSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateFunction::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CreateFunctionSourceState>();
-}
-
-void PhysicalCreateFunction::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                     LocalSourceState &lstate) const {
-	auto &state = (CreateFunctionSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	Catalog::GetCatalog(context.client).CreateFunction(context.client, info.get());
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CreateIndexSourceState : public GlobalSourceState {
-public:
-	CreateIndexSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateIndex::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CreateIndexSourceState>();
-}
-
-void PhysicalCreateIndex::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                  LocalSourceState &lstate) const {
-	auto &state = (CreateIndexSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	if (column_ids.empty()) {
-		throw BinderException("CREATE INDEX does not refer to any columns in the base table!");
-	}
-
-	auto &schema = *table.schema;
-	auto index_entry = (IndexCatalogEntry *)schema.CreateIndex(context.client, info.get(), &table);
-	if (!index_entry) {
-		// index already exists, but error ignored because of IF NOT EXISTS
-		return;
-	}
-
-	unique_ptr<Index> index;
-	switch (info->index_type) {
-	case IndexType::ART: {
-		index = make_unique<ART>(column_ids, unbound_expressions,
-		                         info->unique ? IndexConstraintType::UNIQUE : IndexConstraintType::NONE);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented index type");
-	}
-	index_entry->index = index.get();
-	index_entry->info = table.storage->info;
-	table.storage->AddIndex(move(index), expressions);
-
-	chunk.SetCardinality(0);
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CreateSchemaSourceState : public GlobalSourceState {
-public:
-	CreateSchemaSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateSchema::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CreateSchemaSourceState>();
-}
-
-void PhysicalCreateSchema::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                   LocalSourceState &lstate) const {
-	auto &state = (CreateSchemaSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	Catalog::GetCatalog(context.client).CreateSchema(context.client, info.get());
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CreateSequenceSourceState : public GlobalSourceState {
-public:
-	CreateSequenceSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateSequence::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CreateSequenceSourceState>();
-}
-
-void PhysicalCreateSequence::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                     LocalSourceState &lstate) const {
-	auto &state = (CreateSequenceSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	Catalog::GetCatalog(context.client).CreateSequence(context.client, info.get());
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalCreateTable::PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry *schema,
-                                         unique_ptr<BoundCreateTableInfo> info, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE, op.types, estimated_cardinality), schema(schema),
-      info(move(info)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CreateTableSourceState : public GlobalSourceState {
-public:
-	CreateTableSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateTable::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CreateTableSourceState>();
-}
-
-void PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                  LocalSourceState &lstate) const {
-	auto &state = (CreateTableSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	auto &catalog = Catalog::GetCatalog(context.client);
-	catalog.CreateTable(context.client, schema, info.get());
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalCreateTableAs::PhysicalCreateTableAs(LogicalOperator &op, SchemaCatalogEntry *schema,
-                                             unique_ptr<BoundCreateTableInfo> info, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE_AS, op.types, estimated_cardinality), schema(schema),
-      info(move(info)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class CreateTableAsGlobalState : public GlobalSinkState {
-public:
-	CreateTableAsGlobalState() {
-		inserted_count = 0;
-	}
-
-	mutex append_lock;
-	TableCatalogEntry *table;
-	int64_t inserted_count;
-};
-
-unique_ptr<GlobalSinkState> PhysicalCreateTableAs::GetGlobalSinkState(ClientContext &context) const {
-	auto sink = make_unique<CreateTableAsGlobalState>();
-	auto &catalog = Catalog::GetCatalog(context);
-	sink->table = (TableCatalogEntry *)catalog.CreateTable(context, schema, info.get());
-	return move(sink);
-}
-
-SinkResultType PhysicalCreateTableAs::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
-                                           DataChunk &input) const {
-	auto &sink = (CreateTableAsGlobalState &)state;
-	if (sink.table) {
-		lock_guard<mutex> client_guard(sink.append_lock);
-		sink.table->storage->Append(*sink.table, context.client, input);
-		sink.inserted_count += input.size();
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CreateTableAsSourceState : public GlobalSourceState {
-public:
-	CreateTableAsSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateTableAs::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CreateTableAsSourceState>();
-}
-
-void PhysicalCreateTableAs::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                    LocalSourceState &lstate) const {
-	auto &state = (CreateTableAsSourceState &)gstate;
-	auto &sink = (CreateTableAsGlobalState &)*sink_state;
-	if (state.finished) {
-		return;
-	}
-	if (sink.table) {
-		chunk.SetCardinality(1);
-		chunk.SetValue(0, 0, Value::BIGINT(sink.inserted_count));
-	}
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::CREATE_TYPE, {LogicalType::BIGINT}, estimated_cardinality),
-      info(move(info)) {
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CreateTypeSourceState : public GlobalSourceState {
-public:
-	CreateTypeSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateType::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CreateTypeSourceState>();
-}
-
-void PhysicalCreateType::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                 LocalSourceState &lstate) const {
-	auto &state = (CreateTypeSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	auto &catalog = Catalog::GetCatalog(context.client);
-	catalog.CreateType(context.client, info.get());
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class CreateViewSourceState : public GlobalSourceState {
-public:
-	CreateViewSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateView::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<CreateViewSourceState>();
-}
-
-void PhysicalCreateView::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                 LocalSourceState &lstate) const {
-	auto &state = (CreateViewSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	Catalog::GetCatalog(context.client).CreateView(context.client, info.get());
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class DropSourceState : public GlobalSourceState {
-public:
-	DropSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalDrop::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<DropSourceState>();
-}
-
-void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                           LocalSourceState &lstate) const {
-	auto &state = (DropSourceState &)gstate;
-	if (state.finished) {
-		return;
-	}
-	switch (info->type) {
-	case CatalogType::PREPARED_STATEMENT: {
-		// DEALLOCATE silently ignores errors
-		auto &statements = ClientData::Get(context.client).prepared_statements;
-		if (statements.find(info->name) != statements.end()) {
-			statements.erase(info->name);
-		}
-		break;
-	}
-	default:
-		Catalog::GetCatalog(context.client).DropEntry(context.client, info.get());
-		break;
-	}
-	state.finished = true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PhysicalRecursiveCTE::PhysicalRecursiveCTE(vector<LogicalType> types, bool union_all, unique_ptr<PhysicalOperator> top,
-                                           unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::RECURSIVE_CTE, move(types), estimated_cardinality), union_all(union_all) {
-	children.push_back(move(top));
-	children.push_back(move(bottom));
-}
-
-PhysicalRecursiveCTE::~PhysicalRecursiveCTE() {
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class RecursiveCTEState : public GlobalSinkState {
-public:
-	explicit RecursiveCTEState(ClientContext &context, const PhysicalRecursiveCTE &op)
-	    : intermediate_table(Allocator::Get(context)), new_groups(STANDARD_VECTOR_SIZE) {
-		ht = make_unique<GroupedAggregateHashTable>(Allocator::Get(context), BufferManager::GetBufferManager(context),
-		                                            op.types, vector<LogicalType>(),
-		                                            vector<BoundAggregateExpression *>());
-	}
-
-	unique_ptr<GroupedAggregateHashTable> ht;
-
-	bool intermediate_empty = true;
-	ChunkCollection intermediate_table;
-	idx_t chunk_idx = 0;
-	SelectionVector new_groups;
-};
-
-unique_ptr<GlobalSinkState> PhysicalRecursiveCTE::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<RecursiveCTEState>(context, *this);
-}
-
-idx_t PhysicalRecursiveCTE::ProbeHT(DataChunk &chunk, RecursiveCTEState &state) const {
-	Vector dummy_addresses(LogicalType::POINTER);
-
-	// Use the HT to eliminate duplicate rows
-	idx_t new_group_count = state.ht->FindOrCreateGroups(chunk, dummy_addresses, state.new_groups);
-
-	// we only return entries we have not seen before (i.e. new groups)
-	chunk.Slice(state.new_groups, new_group_count);
-
-	return new_group_count;
-}
-
-SinkResultType PhysicalRecursiveCTE::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                          DataChunk &input) const {
-	auto &gstate = (RecursiveCTEState &)state;
-	if (!union_all) {
-		idx_t match_count = ProbeHT(input, gstate);
-		if (match_count > 0) {
-			gstate.intermediate_table.Append(input);
-		}
-	} else {
-		gstate.intermediate_table.Append(input);
-	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-void PhysicalRecursiveCTE::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                   LocalSourceState &lstate) const {
-	auto &gstate = (RecursiveCTEState &)*sink_state;
-	while (chunk.size() == 0) {
-		if (gstate.chunk_idx < gstate.intermediate_table.ChunkCount()) {
-			// scan any chunks we have collected so far
-			chunk.Reference(gstate.intermediate_table.GetChunk(gstate.chunk_idx));
-			gstate.chunk_idx++;
-			break;
-		} else {
-			// we have run out of chunks
-			// now we need to recurse
-			// we set up the working table as the data we gathered in this iteration of the recursion
-			working_table->Reset();
-			working_table->Merge(gstate.intermediate_table);
-			// and we clear the intermediate table
-			gstate.intermediate_table.Reset();
-			gstate.chunk_idx = 0;
-			// now we need to re-execute all of the pipelines that depend on the recursion
-			ExecuteRecursivePipelines(context);
-
-			// check if we obtained any results
-			// if not, we are done
-			if (gstate.intermediate_table.Count() == 0) {
-				break;
-			}
-		}
-	}
-}
-
-void PhysicalRecursiveCTE::ExecuteRecursivePipelines(ExecutionContext &context) const {
-	if (pipelines.empty()) {
-		throw InternalException("Missing pipelines for recursive CTE");
-	}
-
-	for (auto &pipeline : pipelines) {
-		auto sink = pipeline->GetSink();
-		if (sink != this) {
-			// reset the sink state for any intermediate sinks
-			sink->sink_state = sink->GetGlobalSinkState(context.client);
-		}
-		for (auto &op : pipeline->GetOperators()) {
-			if (op) {
-				op->op_state = op->GetGlobalOperatorState(context.client);
-			}
-		}
-		pipeline->Reset();
-	}
-	auto &executor = pipelines[0]->executor;
-
-	vector<shared_ptr<Event>> events;
-	executor.ReschedulePipelines(pipelines, events);
-
-	while (true) {
-		executor.WorkOnTasks();
-		if (executor.HasError()) {
-			executor.ThrowException();
-		}
-		bool finished = true;
-		for (auto &event : events) {
-			if (!event->IsFinished()) {
-				finished = false;
-				break;
-			}
-		}
-		if (finished) {
-			// all pipelines finished: done!
-			break;
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalRecursiveCTE::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	op_state.reset();
-	sink_state.reset();
-
-	// recursive CTE
-	state.SetPipelineSource(current, this);
-	// the LHS of the recursive CTE is our initial state
-	// we build this pipeline as normal
-	auto pipeline_child = children[0].get();
-	// for the RHS, we gather all pipelines that depend on the recursive cte
-	// these pipelines need to be rerun
-	if (state.recursive_cte) {
-		throw InternalException("Recursive CTE detected WITHIN a recursive CTE node");
-	}
-	state.recursive_cte = this;
-
-	auto recursive_pipeline = make_shared<Pipeline>(executor);
-	state.SetPipelineSink(*recursive_pipeline, this);
-	children[1]->BuildPipelines(executor, *recursive_pipeline, state);
-
-	pipelines.push_back(move(recursive_pipeline));
-
-	state.recursive_cte = nullptr;
-
-	BuildChildPipeline(executor, current, state, pipeline_child);
-}
-
-vector<const PhysicalOperator *> PhysicalRecursiveCTE::GetSources() const {
-	return {this};
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-PhysicalUnion::PhysicalUnion(vector<LogicalType> types, unique_ptr<PhysicalOperator> top,
-                             unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::UNION, move(types), estimated_cardinality) {
-	children.push_back(move(top));
-	children.push_back(move(bottom));
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalUnion::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	if (state.recursive_cte) {
-		throw NotImplementedException("UNIONS are not supported in recursive CTEs yet");
-	}
-	op_state.reset();
-	sink_state.reset();
-
-	auto union_pipeline = make_shared<Pipeline>(executor);
-	auto pipeline_ptr = union_pipeline.get();
-	auto &child_pipelines = state.GetChildPipelines(executor);
-	auto &child_dependencies = state.GetChildDependencies(executor);
-	auto &union_pipelines = state.GetUnionPipelines(executor);
-	// set up dependencies for any child pipelines to this union pipeline
-	auto child_entry = child_pipelines.find(&current);
-	if (child_entry != child_pipelines.end()) {
-		for (auto &current_child : child_entry->second) {
-			D_ASSERT(child_dependencies.find(current_child.get()) != child_dependencies.end());
-			child_dependencies[current_child.get()].push_back(pipeline_ptr);
-		}
-	}
-	// for the current pipeline, continue building on the LHS
-	state.SetPipelineOperators(*union_pipeline, state.GetPipelineOperators(current));
-	children[0]->BuildPipelines(executor, current, state);
-	// insert the union pipeline as a union pipeline of the current node
-	union_pipelines[&current].push_back(move(union_pipeline));
-
-	// for the union pipeline, build on the RHS
-	state.SetPipelineSink(*pipeline_ptr, state.GetPipelineSink(current));
-	children[1]->BuildPipelines(executor, *pipeline_ptr, state);
-}
-
-vector<const PhysicalOperator *> PhysicalUnion::GetSources() const {
-	vector<const PhysicalOperator *> result;
-	for (auto &child : children) {
-		auto child_sources = child->GetSources();
-		result.insert(result.end(), child_sources.begin(), child_sources.end());
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-static idx_t PartitionInfoNPartitions(const idx_t n_partitions_upper_bound) {
-	idx_t n_partitions = 1;
-	while (n_partitions <= n_partitions_upper_bound / 2) {
-		n_partitions *= 2;
-		if (n_partitions >= 256) {
-			break;
-		}
-	}
-	return n_partitions;
-}
-
-static idx_t PartitionInfoRadixBits(const idx_t n_partitions) {
-	idx_t radix_bits = 0;
-	auto radix_partitions_copy = n_partitions;
-	while (radix_partitions_copy - 1) {
-		radix_bits++;
-		radix_partitions_copy >>= 1;
-	}
-	return radix_bits;
-}
-
-static hash_t PartitionInfoRadixMask(const idx_t radix_bits, const idx_t radix_shift) {
-	hash_t radix_mask = 0;
-	// we use the fifth byte of the 64 bit hash as radix source
-	for (idx_t i = 0; i < radix_bits; i++) {
-		radix_mask = (radix_mask << 1) | 1;
-	}
-	radix_mask <<= radix_shift;
-	return radix_mask;
-}
-
-RadixPartitionInfo::RadixPartitionInfo(const idx_t n_partitions_upper_bound)
-    : n_partitions(PartitionInfoNPartitions(n_partitions_upper_bound)),
-      radix_bits(PartitionInfoRadixBits(n_partitions)), radix_mask(PartitionInfoRadixMask(radix_bits, RADIX_SHIFT)) {
-
-	// finalize_threads needs to be a power of 2
-	D_ASSERT(n_partitions > 0);
-	D_ASSERT(n_partitions <= 256);
-	D_ASSERT((n_partitions & (n_partitions - 1)) == 0);
-	D_ASSERT(radix_bits <= 8);
-}
-
-PartitionableHashTable::PartitionableHashTable(Allocator &allocator, BufferManager &buffer_manager_p,
-                                               RadixPartitionInfo &partition_info_p, vector<LogicalType> group_types_p,
-                                               vector<LogicalType> payload_types_p,
-                                               vector<BoundAggregateExpression *> bindings_p)
-    : allocator(allocator), buffer_manager(buffer_manager_p), group_types(move(group_types_p)),
-      payload_types(move(payload_types_p)), bindings(move(bindings_p)), is_partitioned(false),
-      partition_info(partition_info_p), hashes(LogicalType::HASH), hashes_subset(LogicalType::HASH) {
-
-	sel_vectors.resize(partition_info.n_partitions);
-	sel_vector_sizes.resize(partition_info.n_partitions);
-	group_subset.Initialize(allocator, group_types);
-	if (!payload_types.empty()) {
-		payload_subset.Initialize(allocator, payload_types);
-	}
-
-	for (hash_t r = 0; r < partition_info.n_partitions; r++) {
-		sel_vectors[r].Initialize();
-	}
-}
-
-idx_t PartitionableHashTable::ListAddChunk(HashTableList &list, DataChunk &groups, Vector &group_hashes,
-                                           DataChunk &payload) {
-	if (list.empty() || list.back()->Size() + groups.size() > list.back()->MaxCapacity()) {
-		if (!list.empty()) {
-			// early release first part of ht and prevent adding of more data
-			list.back()->Finalize();
-		}
-		list.push_back(make_unique<GroupedAggregateHashTable>(allocator, buffer_manager, group_types, payload_types,
-		                                                      bindings, HtEntryType::HT_WIDTH_32));
-	}
-	return list.back()->AddChunk(groups, group_hashes, payload);
-}
-
-idx_t PartitionableHashTable::AddChunk(DataChunk &groups, DataChunk &payload, bool do_partition) {
-	groups.Hash(hashes);
-
-	// we partition when we are asked to or when the unpartitioned ht runs out of space
-	if (!IsPartitioned() && do_partition) {
-		Partition();
-	}
-
-	if (!IsPartitioned()) {
-		return ListAddChunk(unpartitioned_hts, groups, hashes, payload);
-	}
-
-	// makes no sense to do this with 1 partition
-	D_ASSERT(partition_info.n_partitions > 0);
-
-	for (hash_t r = 0; r < partition_info.n_partitions; r++) {
-		sel_vector_sizes[r] = 0;
-	}
-
-	hashes.Normalify(groups.size());
-	auto hashes_ptr = FlatVector::GetData<hash_t>(hashes);
-
-	for (idx_t i = 0; i < groups.size(); i++) {
-		auto partition = (hashes_ptr[i] & partition_info.radix_mask) >> partition_info.RADIX_SHIFT;
-		D_ASSERT(partition < partition_info.n_partitions);
-		sel_vectors[partition].set_index(sel_vector_sizes[partition]++, i);
-	}
-
-#ifdef DEBUG
-	// make sure we have lost no rows
-	idx_t total_count = 0;
-	for (idx_t r = 0; r < partition_info.n_partitions; r++) {
-		total_count += sel_vector_sizes[r];
-	}
-	D_ASSERT(total_count == groups.size());
-#endif
-	idx_t group_count = 0;
-	for (hash_t r = 0; r < partition_info.n_partitions; r++) {
-		group_subset.Slice(groups, sel_vectors[r], sel_vector_sizes[r]);
-		payload_subset.Slice(payload, sel_vectors[r], sel_vector_sizes[r]);
-		hashes_subset.Slice(hashes, sel_vectors[r], sel_vector_sizes[r]);
-
-		group_count += ListAddChunk(radix_partitioned_hts[r], group_subset, hashes_subset, payload_subset);
-	}
-	return group_count;
-}
-
-void PartitionableHashTable::Partition() {
-	D_ASSERT(!IsPartitioned());
-	D_ASSERT(radix_partitioned_hts.size() == 0);
-	D_ASSERT(partition_info.n_partitions > 1);
-
-	vector<GroupedAggregateHashTable *> partition_hts(partition_info.n_partitions);
-	for (auto &unpartitioned_ht : unpartitioned_hts) {
-		for (idx_t r = 0; r < partition_info.n_partitions; r++) {
-			radix_partitioned_hts[r].push_back(make_unique<GroupedAggregateHashTable>(
-			    allocator, buffer_manager, group_types, payload_types, bindings, HtEntryType::HT_WIDTH_32));
-			partition_hts[r] = radix_partitioned_hts[r].back().get();
-		}
-		unpartitioned_ht->Partition(partition_hts, partition_info.radix_mask, partition_info.RADIX_SHIFT);
-		unpartitioned_ht.reset();
-	}
-	unpartitioned_hts.clear();
-	is_partitioned = true;
-}
-
-bool PartitionableHashTable::IsPartitioned() {
-	return is_partitioned;
-}
-
-HashTableList PartitionableHashTable::GetPartition(idx_t partition) {
-	D_ASSERT(IsPartitioned());
-	D_ASSERT(partition < partition_info.n_partitions);
-	D_ASSERT(radix_partitioned_hts.size() > partition);
-	return move(radix_partitioned_hts[partition]);
-}
-HashTableList PartitionableHashTable::GetUnpartitioned() {
-	D_ASSERT(!IsPartitioned());
-	return move(unpartitioned_hts);
-}
-
-void PartitionableHashTable::Finalize() {
-	if (IsPartitioned()) {
-		for (auto &ht_list : radix_partitioned_hts) {
-			for (auto &ht : ht_list.second) {
-				D_ASSERT(ht);
-				ht->Finalize();
-			}
-		}
-	} else {
-		for (auto &ht : unpartitioned_hts) {
-			D_ASSERT(ht);
-			ht->Finalize();
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-PerfectAggregateHashTable::PerfectAggregateHashTable(Allocator &allocator, BufferManager &buffer_manager,
-                                                     const vector<LogicalType> &group_types_p,
-                                                     vector<LogicalType> payload_types_p,
-                                                     vector<AggregateObject> aggregate_objects_p,
-                                                     vector<Value> group_minima_p, vector<idx_t> required_bits_p)
-    : BaseAggregateHashTable(allocator, aggregate_objects_p, buffer_manager, move(payload_types_p)),
-      addresses(LogicalType::POINTER), required_bits(move(required_bits_p)), total_required_bits(0),
-      group_minima(move(group_minima_p)), sel(STANDARD_VECTOR_SIZE) {
-	for (auto &group_bits : required_bits) {
-		total_required_bits += group_bits;
-	}
-	// the total amount of groups we allocate space for is 2^required_bits
-	total_groups = 1 << total_required_bits;
-	// we don't need to store the groups in a perfect hash table, since the group keys can be deduced by their location
-	grouping_columns = group_types_p.size();
-	layout.Initialize(move(aggregate_objects_p));
-	tuple_size = layout.GetRowWidth();
-
-	// allocate and null initialize the data
-	owned_data = unique_ptr<data_t[]>(new data_t[tuple_size * total_groups]);
-	data = owned_data.get();
-
-	// set up the empty payloads for every tuple, and initialize the "occupied" flag to false
-	group_is_set = unique_ptr<bool[]>(new bool[total_groups]);
-	memset(group_is_set.get(), 0, total_groups * sizeof(bool));
-}
-
-PerfectAggregateHashTable::~PerfectAggregateHashTable() {
-	Destroy();
-}
-
-template <class T>
-static void ComputeGroupLocationTemplated(VectorData &group_data, Value &min, uintptr_t *address_data,
-                                          idx_t current_shift, idx_t count) {
-	auto data = (T *)group_data.data;
-	auto min_val = min.GetValueUnsafe<T>();
-	if (!group_data.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto index = group_data.sel->get_index(i);
-			// check if the value is NULL
-			// NULL groups are considered as "0" in the hash table
-			// that is to say, they have no effect on the position of the element (because 0 << shift is 0)
-			// we only need to handle non-null values here
-			if (group_data.validity.RowIsValid(index)) {
-				D_ASSERT(data[index] >= min_val);
-				uintptr_t adjusted_value = (data[index] - min_val) + 1;
-				address_data[i] += adjusted_value << current_shift;
-			}
-		}
-	} else {
-		// no null values: we can directly compute the addresses
-		for (idx_t i = 0; i < count; i++) {
-			auto index = group_data.sel->get_index(i);
-			uintptr_t adjusted_value = (data[index] - min_val) + 1;
-			address_data[i] += adjusted_value << current_shift;
-		}
-	}
-}
-
-static void ComputeGroupLocation(Vector &group, Value &min, uintptr_t *address_data, idx_t current_shift, idx_t count) {
-	VectorData vdata;
-	group.Orrify(count, vdata);
-
-	switch (group.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		ComputeGroupLocationTemplated<int8_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::INT16:
-		ComputeGroupLocationTemplated<int16_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::INT32:
-		ComputeGroupLocationTemplated<int32_t>(vdata, min, address_data, current_shift, count);
-		break;
-	case PhysicalType::INT64:
-		ComputeGroupLocationTemplated<int64_t>(vdata, min, address_data, current_shift, count);
-		break;
-	default:
-		throw InternalException("Unsupported group type for perfect aggregate hash table");
-	}
-}
-
-void PerfectAggregateHashTable::AddChunk(DataChunk &groups, DataChunk &payload) {
-	// first we need to find the location in the HT of each of the groups
-	auto address_data = FlatVector::GetData<uintptr_t>(addresses);
-	// zero-initialize the address data
-	memset(address_data, 0, groups.size() * sizeof(uintptr_t));
-	D_ASSERT(groups.ColumnCount() == group_minima.size());
-
-	// then compute the actual group location by iterating over each of the groups
-	idx_t current_shift = total_required_bits;
-	for (idx_t i = 0; i < groups.ColumnCount(); i++) {
-		current_shift -= required_bits[i];
-		ComputeGroupLocation(groups.data[i], group_minima[i], address_data, current_shift, groups.size());
-	}
-	// now we have the HT entry number for every tuple
-	// compute the actual pointer to the data by adding it to the base HT pointer and multiplying by the tuple size
-	idx_t needs_init = 0;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		D_ASSERT(address_data[i] < total_groups);
-		const auto group = address_data[i];
-		address_data[i] = uintptr_t(data) + address_data[i] * tuple_size;
-		if (!group_is_set[group]) {
-			group_is_set[group] = true;
-			sel.set_index(needs_init++, i);
-			if (needs_init == STANDARD_VECTOR_SIZE) {
-				RowOperations::InitializeStates(layout, addresses, sel, needs_init);
-				needs_init = 0;
-			}
-		}
-	}
-	RowOperations::InitializeStates(layout, addresses, sel, needs_init);
-
-	// after finding the group location we update the aggregates
-	idx_t payload_idx = 0;
-	auto &aggregates = layout.GetAggregates();
-	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = aggregates[aggr_idx];
-		auto input_count = (idx_t)aggregate.child_count;
-		if (aggregate.filter) {
-			RowOperations::UpdateFilteredStates(filter_set.GetFilterData(aggr_idx), aggregate, addresses, payload,
-			                                    payload_idx);
-		} else {
-			RowOperations::UpdateStates(aggregate, addresses, payload, payload_idx, payload.size());
-		}
-		// move to the next aggregate
-		payload_idx += input_count;
-		VectorOperations::AddInPlace(addresses, aggregate.payload_size, payload.size());
-	}
-}
-
-void PerfectAggregateHashTable::Combine(PerfectAggregateHashTable &other) {
-	D_ASSERT(total_groups == other.total_groups);
-	D_ASSERT(tuple_size == other.tuple_size);
-
-	Vector source_addresses(LogicalType::POINTER);
-	Vector target_addresses(LogicalType::POINTER);
-	auto source_addresses_ptr = FlatVector::GetData<data_ptr_t>(source_addresses);
-	auto target_addresses_ptr = FlatVector::GetData<data_ptr_t>(target_addresses);
-
-	// iterate over all entries of both hash tables and call combine for all entries that can be combined
-	data_ptr_t source_ptr = other.data;
-	data_ptr_t target_ptr = data;
-	idx_t combine_count = 0;
-	idx_t reinit_count = 0;
-	const auto &reinit_sel = *FlatVector::IncrementalSelectionVector();
-	for (idx_t i = 0; i < total_groups; i++) {
-		auto has_entry_source = other.group_is_set[i];
-		// we only have any work to do if the source has an entry for this group
-		if (has_entry_source) {
-			auto has_entry_target = group_is_set[i];
-			if (has_entry_target) {
-				// both source and target have an entry: need to combine
-				source_addresses_ptr[combine_count] = source_ptr;
-				target_addresses_ptr[combine_count] = target_ptr;
-				combine_count++;
-				if (combine_count == STANDARD_VECTOR_SIZE) {
-					RowOperations::CombineStates(layout, source_addresses, target_addresses, combine_count);
-					combine_count = 0;
-				}
-			} else {
-				group_is_set[i] = true;
-				// only source has an entry for this group: we can just memcpy it over
-				memcpy(target_ptr, source_ptr, tuple_size);
-				// we clear this entry in the other HT as we "consume" the entry here
-				other.group_is_set[i] = false;
-			}
-		}
-		source_ptr += tuple_size;
-		target_ptr += tuple_size;
-	}
-	RowOperations::CombineStates(layout, source_addresses, target_addresses, combine_count);
-	RowOperations::InitializeStates(layout, addresses, reinit_sel, reinit_count);
-}
-
-template <class T>
-static void ReconstructGroupVectorTemplated(uint32_t group_values[], Value &min, idx_t mask, idx_t shift,
-                                            idx_t entry_count, Vector &result) {
-	auto data = FlatVector::GetData<T>(result);
-	auto &validity_mask = FlatVector::Validity(result);
-	auto min_data = min.GetValueUnsafe<T>();
-	for (idx_t i = 0; i < entry_count; i++) {
-		// extract the value of this group from the total group index
-		auto group_index = (group_values[i] >> shift) & mask;
-		if (group_index == 0) {
-			// if it is 0, the value is NULL
-			validity_mask.SetInvalid(i);
-		} else {
-			// otherwise we add the value (minus 1) to the min value
-			data[i] = min_data + group_index - 1;
-		}
-	}
-}
-
-static void ReconstructGroupVector(uint32_t group_values[], Value &min, idx_t required_bits, idx_t shift,
-                                   idx_t entry_count, Vector &result) {
-	// construct the mask for this entry
-	idx_t mask = (1 << required_bits) - 1;
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		ReconstructGroupVectorTemplated<int8_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::INT16:
-		ReconstructGroupVectorTemplated<int16_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::INT32:
-		ReconstructGroupVectorTemplated<int32_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	case PhysicalType::INT64:
-		ReconstructGroupVectorTemplated<int64_t>(group_values, min, mask, shift, entry_count, result);
-		break;
-	default:
-		throw InternalException("Invalid type for perfect aggregate HT group");
-	}
-}
-
-void PerfectAggregateHashTable::Scan(idx_t &scan_position, DataChunk &result) {
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	uint32_t group_values[STANDARD_VECTOR_SIZE];
-
-	// iterate over the HT until we either have exhausted the entire HT, or
-	idx_t entry_count = 0;
-	for (; scan_position < total_groups; scan_position++) {
-		if (group_is_set[scan_position]) {
-			// this group is set: add it to the set of groups to extract
-			data_pointers[entry_count] = data + tuple_size * scan_position;
-			group_values[entry_count] = scan_position;
-			entry_count++;
-			if (entry_count == STANDARD_VECTOR_SIZE) {
-				scan_position++;
-				break;
-			}
-		}
-	}
-	if (entry_count == 0) {
-		// no entries found
-		return;
-	}
-	// first reconstruct the groups from the group index
-	idx_t shift = total_required_bits;
-	for (idx_t i = 0; i < grouping_columns; i++) {
-		shift -= required_bits[i];
-		ReconstructGroupVector(group_values, group_minima[i], required_bits[i], shift, entry_count, result.data[i]);
-	}
-	// then construct the payloads
-	result.SetCardinality(entry_count);
-	RowOperations::FinalizeStates(layout, addresses, result, grouping_columns);
-}
-
-void PerfectAggregateHashTable::Destroy() {
-	// check if there is any destructor to call
-	bool has_destructor = false;
-	for (auto &aggr : layout.GetAggregates()) {
-		if (aggr.function.destructor) {
-			has_destructor = true;
-		}
-	}
-	if (!has_destructor) {
-		return;
-	}
-	// there are aggregates with destructors: loop over the hash table
-	// and call the destructor method for each of the aggregates
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-	idx_t count = 0;
-
-	// iterate over all initialised slots of the hash table
-	data_ptr_t payload_ptr = data;
-	for (idx_t i = 0; i < total_groups; i++) {
-		if (group_is_set[i]) {
-			data_pointers[count++] = payload_ptr;
-			if (count == STANDARD_VECTOR_SIZE) {
-				RowOperations::DestroyStates(layout, addresses, count);
-				count = 0;
-			}
-		}
-		payload_ptr += tuple_size;
-	}
-	RowOperations::DestroyStates(layout, addresses, count);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-string PhysicalOperator::GetName() const {
-	return PhysicalOperatorToString(type);
-}
-
-string PhysicalOperator::ToString() const {
-	TreeRenderer renderer;
-	return renderer.ToString(*this);
-}
-
-// LCOV_EXCL_START
-void PhysicalOperator::Print() const {
-	Printer::Print(ToString());
-}
-// LCOV_EXCL_STOP
-
-vector<PhysicalOperator *> PhysicalOperator::GetChildren() const {
-	vector<PhysicalOperator *> result;
-	for (auto &child : children) {
-		result.push_back(child.get());
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Operator
-//===--------------------------------------------------------------------===//
-// LCOV_EXCL_START
-unique_ptr<OperatorState> PhysicalOperator::GetOperatorState(ExecutionContext &context) const {
-	return make_unique<OperatorState>();
-}
-
-unique_ptr<GlobalOperatorState> PhysicalOperator::GetGlobalOperatorState(ClientContext &context) const {
-	return make_unique<GlobalOperatorState>();
-}
-
-OperatorResultType PhysicalOperator::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                             GlobalOperatorState &gstate, OperatorState &state) const {
-	throw InternalException("Calling Execute on a node that is not an operator!");
-}
-// LCOV_EXCL_STOP
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-unique_ptr<LocalSourceState> PhysicalOperator::GetLocalSourceState(ExecutionContext &context,
-                                                                   GlobalSourceState &gstate) const {
-	return make_unique<LocalSourceState>();
-}
-
-unique_ptr<GlobalSourceState> PhysicalOperator::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<GlobalSourceState>();
-}
-
-// LCOV_EXCL_START
-void PhysicalOperator::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                               LocalSourceState &lstate) const {
-	throw InternalException("Calling GetData on a node that is not a source!");
-}
-
-idx_t PhysicalOperator::GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                      LocalSourceState &lstate) const {
-	throw InternalException("Calling GetBatchIndex on a node that does not support it");
-}
-
-double PhysicalOperator::GetProgress(ClientContext &context, GlobalSourceState &gstate) const {
-	return -1;
-}
-// LCOV_EXCL_STOP
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-// LCOV_EXCL_START
-SinkResultType PhysicalOperator::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-                                      DataChunk &input) const {
-	throw InternalException("Calling Sink on a node that is not a sink!");
-}
-// LCOV_EXCL_STOP
-
-void PhysicalOperator::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-}
-
-SinkFinalizeType PhysicalOperator::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                            GlobalSinkState &gstate) const {
-	return SinkFinalizeType::READY;
-}
-
-unique_ptr<LocalSinkState> PhysicalOperator::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<LocalSinkState>();
-}
-
-unique_ptr<GlobalSinkState> PhysicalOperator::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<GlobalSinkState>();
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Construction
-//===--------------------------------------------------------------------===//
-void PhysicalOperator::AddPipeline(Executor &executor, shared_ptr<Pipeline> pipeline, PipelineBuildState &state) {
-	if (!state.recursive_cte) {
-		// regular pipeline: schedule it
-		state.AddPipeline(executor, move(pipeline));
-	} else {
-		// CTE pipeline! add it to the CTE pipelines
-		auto &cte = (PhysicalRecursiveCTE &)*state.recursive_cte;
-		cte.pipelines.push_back(move(pipeline));
-	}
-}
-
-void PhysicalOperator::BuildChildPipeline(Executor &executor, Pipeline &current, PipelineBuildState &state,
-                                          PhysicalOperator *pipeline_child) {
-	auto pipeline = make_shared<Pipeline>(executor);
-	state.SetPipelineSink(*pipeline, this);
-	// the current is dependent on this pipeline to complete
-	current.AddDependency(pipeline);
-	// recurse into the pipeline child
-	pipeline_child->BuildPipelines(executor, *pipeline, state);
-	AddPipeline(executor, move(pipeline), state);
-}
-
-void PhysicalOperator::BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) {
-	op_state.reset();
-	if (IsSink()) {
-		// operator is a sink, build a pipeline
-		sink_state.reset();
-
-		// single operator:
-		// the operator becomes the data source of the current pipeline
-		state.SetPipelineSource(current, this);
-		// we create a new pipeline starting from the child
-		D_ASSERT(children.size() == 1);
-
-		BuildChildPipeline(executor, current, state, children[0].get());
-	} else {
-		// operator is not a sink! recurse in children
-		if (children.empty()) {
-			// source
-			state.SetPipelineSource(current, this);
-		} else {
-			if (children.size() != 1) {
-				throw InternalException("Operator not supported in BuildPipelines");
-			}
-			state.AddPipelineOperator(current, this);
-			children[0]->BuildPipelines(executor, current, state);
-		}
-	}
-}
-
-vector<const PhysicalOperator *> PhysicalOperator::GetSources() const {
-	vector<const PhysicalOperator *> result;
-	if (IsSink()) {
-		D_ASSERT(children.size() == 1);
-		result.push_back(this);
-		return result;
-	} else {
-		if (children.empty()) {
-			// source
-			result.push_back(this);
-			return result;
-		} else {
-			if (children.size() != 1) {
-				throw InternalException("Operator not supported in GetSource");
-			}
-			return children[0]->GetSources();
-		}
-	}
-}
-
-bool PhysicalOperator::AllSourcesSupportBatchIndex() const {
-	auto sources = GetSources();
-	for (auto &source : sources) {
-		if (!source->SupportsBatchIndex()) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void PhysicalOperator::Verify() {
-#ifdef DEBUG
-	auto sources = GetSources();
-	D_ASSERT(!sources.empty());
-	for (auto &child : children) {
-		child->Verify();
-	}
-#endif
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static uint32_t RequiredBitsForValue(uint32_t n) {
-	idx_t required_bits = 0;
-	while (n > 0) {
-		n >>= 1;
-		required_bits++;
-	}
-	return required_bits;
-}
-
-static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate &op, vector<idx_t> &bits_per_group) {
-	if (op.grouping_sets.size() > 1 || !op.grouping_functions.empty()) {
-		return false;
-	}
-	idx_t perfect_hash_bits = 0;
-	if (op.group_stats.empty()) {
-		op.group_stats.resize(op.groups.size());
-	}
-	for (idx_t group_idx = 0; group_idx < op.groups.size(); group_idx++) {
-		auto &group = op.groups[group_idx];
-		auto &stats = op.group_stats[group_idx];
-
-		switch (group->return_type.InternalType()) {
-		case PhysicalType::INT8:
-		case PhysicalType::INT16:
-		case PhysicalType::INT32:
-		case PhysicalType::INT64:
-			break;
-		default:
-			// we only support simple integer types for perfect hashing
-			return false;
-		}
-		// check if the group has stats available
-		auto &group_type = group->return_type;
-		if (!stats) {
-			// no stats, but we might still be able to use perfect hashing if the type is small enough
-			// for small types we can just set the stats to [type_min, type_max]
-			switch (group_type.InternalType()) {
-			case PhysicalType::INT8:
-				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
-				break;
-			case PhysicalType::INT16:
-				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
-				break;
-			default:
-				// type is too large and there are no stats: skip perfect hashing
-				return false;
-			}
-			// we had no stats before, so we have no clue if there are null values or not
-			stats->validity_stats = make_unique<ValidityStatistics>(true);
-		}
-		auto &nstats = (NumericStatistics &)*stats;
-
-		if (nstats.min.IsNull() || nstats.max.IsNull()) {
-			return false;
-		}
-		// we have a min and a max value for the stats: use that to figure out how many bits we have
-		// we add two here, one for the NULL value, and one to make the computation one-indexed
-		// (e.g. if min and max are the same, we still need one entry in total)
-		int64_t range;
-		switch (group_type.InternalType()) {
-		case PhysicalType::INT8:
-			range = int64_t(nstats.max.GetValueUnsafe<int8_t>()) - int64_t(nstats.min.GetValueUnsafe<int8_t>());
-			break;
-		case PhysicalType::INT16:
-			range = int64_t(nstats.max.GetValueUnsafe<int16_t>()) - int64_t(nstats.min.GetValueUnsafe<int16_t>());
-			break;
-		case PhysicalType::INT32:
-			range = int64_t(nstats.max.GetValueUnsafe<int32_t>()) - int64_t(nstats.min.GetValueUnsafe<int32_t>());
-			break;
-		case PhysicalType::INT64:
-			if (!TrySubtractOperator::Operation(nstats.max.GetValueUnsafe<int64_t>(),
-			                                    nstats.min.GetValueUnsafe<int64_t>(), range)) {
-				return false;
-			}
-			break;
-		default:
-			throw InternalException("Unsupported type for perfect hash (should be caught before)");
-		}
-		// bail out on any range bigger than 2^32
-		if (range >= NumericLimits<int32_t>::Maximum()) {
-			return false;
-		}
-		range += 2;
-		// figure out how many bits we need
-		idx_t required_bits = RequiredBitsForValue(range);
-		bits_per_group.push_back(required_bits);
-		perfect_hash_bits += required_bits;
-		// check if we have exceeded the bits for the hash
-		if (perfect_hash_bits > ClientConfig::GetConfig(context).perfect_ht_threshold) {
-			// too many bits for perfect hash
-			return false;
-		}
-	}
-	for (auto &expression : op.expressions) {
-		auto &aggregate = (BoundAggregateExpression &)*expression;
-		if (aggregate.distinct || !aggregate.function.combine) {
-			// distinct aggregates are not supported in perfect hash aggregates
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate &op) {
-	unique_ptr<PhysicalOperator> groupby;
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	plan = ExtractAggregateExpressions(move(plan), op.expressions, op.groups);
-
-	if (op.groups.empty()) {
-		// no groups, check if we can use a simple aggregation
-		// special case: aggregate entire columns together
-		bool use_simple_aggregation = true;
-		for (auto &expression : op.expressions) {
-			auto &aggregate = (BoundAggregateExpression &)*expression;
-			if (!aggregate.function.simple_update || aggregate.distinct) {
-				// unsupported aggregate for simple aggregation: use hash aggregation
-				use_simple_aggregation = false;
-				break;
-			}
-		}
-		if (use_simple_aggregation) {
-			groupby = make_unique_base<PhysicalOperator, PhysicalSimpleAggregate>(op.types, move(op.expressions),
-			                                                                      op.estimated_cardinality);
-		} else {
-			groupby = make_unique_base<PhysicalOperator, PhysicalHashAggregate>(context, op.types, move(op.expressions),
-			                                                                    op.estimated_cardinality);
-		}
-	} else {
-		// groups! create a GROUP BY aggregator
-		// use a perfect hash aggregate if possible
-		vector<idx_t> required_bits;
-		if (CanUsePerfectHashAggregate(context, op, required_bits)) {
-			groupby = make_unique_base<PhysicalOperator, PhysicalPerfectHashAggregate>(
-			    context, op.types, move(op.expressions), move(op.groups), move(op.group_stats), move(required_bits),
-			    op.estimated_cardinality);
-		} else {
-			groupby = make_unique_base<PhysicalOperator, PhysicalHashAggregate>(
-			    context, op.types, move(op.expressions), move(op.groups), move(op.grouping_sets),
-			    move(op.grouping_functions), op.estimated_cardinality);
-		}
-	}
-	groupby->children.push_back(move(plan));
-	return groupby;
-}
-
-unique_ptr<PhysicalOperator>
-PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator> child,
-                                                   vector<unique_ptr<Expression>> &aggregates,
-                                                   vector<unique_ptr<Expression>> &groups) {
-	vector<unique_ptr<Expression>> expressions;
-	vector<LogicalType> types;
-
-	for (auto &group : groups) {
-		auto ref = make_unique<BoundReferenceExpression>(group->return_type, expressions.size());
-		types.push_back(group->return_type);
-		expressions.push_back(move(group));
-		group = move(ref);
-	}
-
-	for (auto &aggr : aggregates) {
-		auto &bound_aggr = (BoundAggregateExpression &)*aggr;
-		for (auto &child : bound_aggr.children) {
-			auto ref = make_unique<BoundReferenceExpression>(child->return_type, expressions.size());
-			types.push_back(child->return_type);
-			expressions.push_back(move(child));
-			child = move(ref);
-		}
-		if (bound_aggr.filter) {
-			auto &filter = bound_aggr.filter;
-			auto ref = make_unique<BoundReferenceExpression>(filter->return_type, expressions.size());
-			types.push_back(filter->return_type);
-			expressions.push_back(move(filter));
-			bound_aggr.filter = move(ref);
-		}
-	}
-	if (expressions.empty()) {
-		return child;
-	}
-	auto projection = make_unique<PhysicalProjection>(move(types), move(expressions), child->estimated_cardinality);
-	projection->children.push_back(move(child));
-	return move(projection);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAnyJoin &op) {
-	// first visit the child nodes
-	D_ASSERT(op.children.size() == 2);
-	D_ASSERT(op.condition);
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-
-	// create the blockwise NL join
-	return make_unique<PhysicalBlockwiseNLJoin>(op, move(left), move(right), move(op.condition), op.join_type,
-	                                            op.estimated_cardinality);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalChunkGet &op) {
-	D_ASSERT(op.children.size() == 0);
-	D_ASSERT(op.collection);
-
-	// create a PhysicalChunkScan pointing towards the owned collection
-	auto chunk_scan =
-	    make_unique<PhysicalChunkScan>(op.types, PhysicalOperatorType::CHUNK_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = move(op.collection);
-	chunk_scan->collection = chunk_scan->owned_collection.get();
-	return move(chunk_scan);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static bool CanPlanIndexJoin(Transaction &transaction, TableScanBindData *bind_data, PhysicalTableScan &scan) {
-	if (!bind_data) {
-		// not a table scan
-		return false;
-	}
-	auto table = bind_data->table;
-	if (transaction.storage.Find(table->storage.get())) {
-		// transaction local appends: skip index join
-		return false;
-	}
-	if (scan.table_filters && !scan.table_filters->filters.empty()) {
-		// table scan filters
-		return false;
-	}
-	return true;
-}
-
-bool ExtractNumericValue(Value val, int64_t &result) {
-	if (!val.type().IsIntegral()) {
-		switch (val.type().InternalType()) {
-		case PhysicalType::INT16:
-			result = val.GetValueUnsafe<int16_t>();
-			break;
-		case PhysicalType::INT32:
-			result = val.GetValueUnsafe<int32_t>();
-			break;
-		case PhysicalType::INT64:
-			result = val.GetValueUnsafe<int64_t>();
-			break;
-		default:
-			return false;
-		}
-	} else {
-		if (!val.TryCastAs(LogicalType::BIGINT)) {
-			return false;
-		}
-		result = val.GetValue<int64_t>();
-	}
-	return true;
-}
-
-void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &join_state) {
-	// we only do this optimization for inner joins
-	if (op.join_type != JoinType::INNER) {
-		return;
-	}
-	// with one condition
-	if (op.conditions.size() != 1) {
-		return;
-	}
-	// with propagated statistics
-	if (op.join_stats.empty()) {
-		return;
-	}
-	// with equality condition and null values not equal
-	for (auto &&condition : op.conditions) {
-		if (condition.comparison != ExpressionType::COMPARE_EQUAL) {
-			return;
-		}
-	}
-	// with integral internal types
-	for (auto &&join_stat : op.join_stats) {
-		if (!TypeIsInteger(join_stat->type.InternalType()) || join_stat->type.InternalType() == PhysicalType::INT128) {
-			// perfect join not possible for non-integral types or hugeint
-			return;
-		}
-	}
-
-	// and when the build range is smaller than the threshold
-	auto stats_build = reinterpret_cast<NumericStatistics *>(op.join_stats[0].get()); // lhs stats
-	if (stats_build->min.IsNull() || stats_build->max.IsNull()) {
-		return;
-	}
-	int64_t min_value, max_value;
-	if (!ExtractNumericValue(stats_build->min, min_value) || !ExtractNumericValue(stats_build->max, max_value)) {
-		return;
-	}
-	int64_t build_range;
-	if (!TrySubtractOperator::Operation(max_value, min_value, build_range)) {
-		return;
-	}
-
-	// Fill join_stats for invisible join
-	auto stats_probe = reinterpret_cast<NumericStatistics *>(op.join_stats[1].get()); // rhs stats
-
-	// The max size our build must have to run the perfect HJ
-	const idx_t MAX_BUILD_SIZE = 1000000;
-	join_state.probe_min = stats_probe->min;
-	join_state.probe_max = stats_probe->max;
-	join_state.build_min = stats_build->min;
-	join_state.build_max = stats_build->max;
-	join_state.estimated_cardinality = op.estimated_cardinality;
-	join_state.build_range = build_range;
-	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.IsNull() || stats_probe->min.IsNull()) {
-		return;
-	}
-	if (stats_build->min <= stats_probe->min && stats_probe->max <= stats_build->max) {
-		join_state.is_probe_in_domain = true;
-	}
-	join_state.is_build_small = true;
-	return;
-}
-
-static void CanUseIndexJoin(TableScanBindData *tbl, Expression &expr, Index **result_index) {
-	tbl->table->storage->info->indexes.Scan([&](Index &index) {
-		if (index.unbound_expressions.size() != 1) {
-			return false;
-		}
-		if (expr.alias == index.unbound_expressions[0]->alias) {
-			*result_index = &index;
-			return true;
-		}
-		return false;
-	});
-}
-
-void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index **left_index, Index **right_index,
-                        PhysicalOperator *left, PhysicalOperator *right) {
-	auto &transaction = Transaction::GetTransaction(context);
-	// check if one of the tables has an index on column
-	if (op.join_type == JoinType::INNER && op.conditions.size() == 1) {
-		// check if one of the children are table scans and if they have an index in the join attribute
-		// (op.condition)
-		if (left->type == PhysicalOperatorType::TABLE_SCAN) {
-			auto &tbl_scan = (PhysicalTableScan &)*left;
-			auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
-			if (CanPlanIndexJoin(transaction, tbl, tbl_scan)) {
-				CanUseIndexJoin(tbl, *op.conditions[0].left, left_index);
-			}
-		}
-		if (right->type == PhysicalOperatorType::TABLE_SCAN) {
-			auto &tbl_scan = (PhysicalTableScan &)*right;
-			auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
-			if (CanPlanIndexJoin(transaction, tbl, tbl_scan)) {
-				CanUseIndexJoin(tbl, *op.conditions[0].right, right_index);
-			}
-		}
-	}
-}
-
-static void RewriteJoinCondition(Expression &expr, idx_t offset) {
-	if (expr.type == ExpressionType::BOUND_REF) {
-		auto &ref = (BoundReferenceExpression &)expr;
-		ref.index += offset;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { RewriteJoinCondition(child, offset); });
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparisonJoin &op) {
-	// now visit the children
-	D_ASSERT(op.children.size() == 2);
-	idx_t lhs_cardinality = op.children[0]->EstimateCardinality(context);
-	idx_t rhs_cardinality = op.children[1]->EstimateCardinality(context);
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-	D_ASSERT(left && right);
-
-	if (op.conditions.empty()) {
-		// no conditions: insert a cross product
-		return make_unique<PhysicalCrossProduct>(op.types, move(left), move(right), op.estimated_cardinality);
-	}
-
-	bool has_equality = false;
-	// bool has_inequality = false;
-	size_t has_range = 0;
-	for (size_t c = 0; c < op.conditions.size(); ++c) {
-		auto &cond = op.conditions[c];
-		switch (cond.comparison) {
-		case ExpressionType::COMPARE_EQUAL:
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-			has_equality = true;
-			break;
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			++has_range;
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			// has_inequality = true;
-			break;
-		default:
-			throw NotImplementedException("Unimplemented comparison join");
-		}
-	}
-
-	unique_ptr<PhysicalOperator> plan;
-	if (has_equality) {
-		Index *left_index {}, *right_index {};
-		TransformIndexJoin(context, op, &left_index, &right_index, left.get(), right.get());
-		if (left_index &&
-		    (ClientConfig::GetConfig(context).force_index_join || rhs_cardinality < 0.01 * lhs_cardinality)) {
-			auto &tbl_scan = (PhysicalTableScan &)*left;
-			swap(op.conditions[0].left, op.conditions[0].right);
-			return make_unique<PhysicalIndexJoin>(op, move(right), move(left), move(op.conditions), op.join_type,
-			                                      op.right_projection_map, op.left_projection_map, tbl_scan.column_ids,
-			                                      left_index, false, op.estimated_cardinality);
-		}
-		if (right_index &&
-		    (ClientConfig::GetConfig(context).force_index_join || lhs_cardinality < 0.01 * rhs_cardinality)) {
-			auto &tbl_scan = (PhysicalTableScan &)*right;
-			return make_unique<PhysicalIndexJoin>(op, move(left), move(right), move(op.conditions), op.join_type,
-			                                      op.left_projection_map, op.right_projection_map, tbl_scan.column_ids,
-			                                      right_index, true, op.estimated_cardinality);
-		}
-		// Equality join with small number of keys : possible perfect join optimization
-		PerfectHashJoinStats perfect_join_stats;
-		CheckForPerfectJoinOpt(op, perfect_join_stats);
-		plan = make_unique<PhysicalHashJoin>(op, move(left), move(right), move(op.conditions), op.join_type,
-		                                     op.left_projection_map, op.right_projection_map, move(op.delim_types),
-		                                     op.estimated_cardinality, perfect_join_stats);
-
-	} else {
-		bool can_merge = has_range > 0;
-		bool can_iejoin = has_range >= 2 && rec_ctes.empty();
-		switch (op.join_type) {
-		case JoinType::SEMI:
-		case JoinType::ANTI:
-		case JoinType::MARK:
-			can_merge = can_merge && op.conditions.size() == 1;
-			can_iejoin = false;
-			break;
-		default:
-			break;
-		}
-		if (can_iejoin) {
-			plan = make_unique<PhysicalIEJoin>(op, move(left), move(right), move(op.conditions), op.join_type,
-			                                   op.estimated_cardinality);
-		} else if (can_merge) {
-			// range join: use piecewise merge join
-			plan = make_unique<PhysicalPiecewiseMergeJoin>(op, move(left), move(right), move(op.conditions),
-			                                               op.join_type, op.estimated_cardinality);
-		} else if (PhysicalNestedLoopJoin::IsSupported(op.conditions)) {
-			// inequality join: use nested loop
-			plan = make_unique<PhysicalNestedLoopJoin>(op, move(left), move(right), move(op.conditions), op.join_type,
-			                                           op.estimated_cardinality);
-		} else {
-			for (auto &cond : op.conditions) {
-				RewriteJoinCondition(*cond.right, left->types.size());
-			}
-			auto condition = JoinCondition::CreateExpression(move(op.conditions));
-			plan = make_unique<PhysicalBlockwiseNLJoin>(op, move(left), move(right), move(condition), op.join_type,
-			                                            op.estimated_cardinality);
-		}
-	}
-	return plan;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCopyToFile &op) {
-	auto plan = CreatePlan(*op.children[0]);
-	bool use_tmp_file = op.is_file_and_exists && op.use_tmp_file;
-	if (use_tmp_file) {
-		op.file_path += ".tmp";
-	}
-	// COPY from select statement to file
-	auto copy = make_unique<PhysicalCopyToFile>(op.types, op.function, move(op.bind_data), op.estimated_cardinality);
-	copy->file_path = op.file_path;
-	copy->use_tmp_file = use_tmp_file;
-
-	copy->children.push_back(move(plan));
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreate &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		return make_unique<PhysicalCreateSequence>(unique_ptr_cast<CreateInfo, CreateSequenceInfo>(move(op.info)),
-		                                           op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		return make_unique<PhysicalCreateView>(unique_ptr_cast<CreateInfo, CreateViewInfo>(move(op.info)),
-		                                       op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		return make_unique<PhysicalCreateSchema>(unique_ptr_cast<CreateInfo, CreateSchemaInfo>(move(op.info)),
-		                                         op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		return make_unique<PhysicalCreateFunction>(unique_ptr_cast<CreateInfo, CreateMacroInfo>(move(op.info)),
-		                                           op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		return make_unique<PhysicalCreateType>(unique_ptr_cast<CreateInfo, CreateTypeInfo>(move(op.info)),
-		                                       op.estimated_cardinality);
-	default:
-		throw NotImplementedException("Unimplemented type for logical simple create");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateIndex &op) {
-	D_ASSERT(op.children.empty());
-	dependencies.insert(&op.table);
-	return make_unique<PhysicalCreateIndex>(op, op.table, op.column_ids, move(op.expressions), move(op.info),
-	                                        move(op.unbound_expressions), op.estimated_cardinality);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void ExtractDependencies(Expression &expr, unordered_set<CatalogEntry *> &dependencies) {
-	if (expr.type == ExpressionType::BOUND_FUNCTION) {
-		auto &function = (BoundFunctionExpression &)expr;
-		if (function.function.dependency) {
-			function.function.dependency(function, dependencies);
-		}
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExtractDependencies(child, dependencies); });
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
-	// extract dependencies from any default values
-	for (auto &default_value : op.info->bound_defaults) {
-		if (default_value) {
-			ExtractDependencies(*default_value, op.info->dependencies);
-		}
-	}
-	auto &create_info = (CreateTableInfo &)*op.info->base;
-	auto &catalog = Catalog::GetCatalog(context);
-	auto existing_entry =
-	    catalog.GetEntry(context, CatalogType::TABLE_ENTRY, create_info.schema, create_info.table, true);
-	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;
-	if ((!existing_entry || replace) && !op.children.empty()) {
-		D_ASSERT(op.children.size() == 1);
-		auto create = make_unique<PhysicalCreateTableAs>(op, op.schema, move(op.info), op.estimated_cardinality);
-		auto plan = CreatePlan(*op.children[0]);
-		create->children.push_back(move(plan));
-		return move(create);
-	} else {
-		return make_unique<PhysicalCreateTable>(op, op.schema, move(op.info), op.estimated_cardinality);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCrossProduct &op) {
-	D_ASSERT(op.children.size() == 2);
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-	return make_unique<PhysicalCrossProduct>(op.types, move(left), move(right), op.estimated_cardinality);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op) {
-	D_ASSERT(op.children.size() == 1);
-	D_ASSERT(op.expressions.size() == 1);
-	D_ASSERT(op.expressions[0]->type == ExpressionType::BOUND_REF);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	// get the index of the row_id column
-	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
-
-	dependencies.insert(op.table);
-	auto del = make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index,
-	                                       op.estimated_cardinality, op.return_chunk);
-	del->children.push_back(move(plan));
-	return move(del);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimGet &op) {
-	D_ASSERT(op.children.empty());
-
-	// create a PhysicalChunkScan without an owned_collection, the collection will be added later
-	auto chunk_scan =
-	    make_unique<PhysicalChunkScan>(op.types, PhysicalOperatorType::DELIM_SCAN, op.estimated_cardinality);
-	return move(chunk_scan);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void GatherDelimScans(PhysicalOperator *op, vector<PhysicalOperator *> &delim_scans) {
-	D_ASSERT(op);
-	if (op->type == PhysicalOperatorType::DELIM_SCAN) {
-		delim_scans.push_back(op);
-	}
-	for (auto &child : op->children) {
-		GatherDelimScans(child.get(), delim_scans);
-	}
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimJoin &op) {
-	// first create the underlying join
-	auto plan = CreatePlan((LogicalComparisonJoin &)op);
-	// this should create a join, not a cross product
-	D_ASSERT(plan && plan->type != PhysicalOperatorType::CROSS_PRODUCT);
-	// duplicate eliminated join
-	// first gather the scans on the duplicate eliminated data set from the RHS
-	vector<PhysicalOperator *> delim_scans;
-	GatherDelimScans(plan->children[1].get(), delim_scans);
-	if (delim_scans.empty()) {
-		// no duplicate eliminated scans in the RHS!
-		// in this case we don't need to create a delim join
-		// just push the normal join
-		return plan;
-	}
-	vector<LogicalType> delim_types;
-	vector<unique_ptr<Expression>> distinct_groups, distinct_expressions;
-	for (auto &delim_expr : op.duplicate_eliminated_columns) {
-		D_ASSERT(delim_expr->type == ExpressionType::BOUND_REF);
-		auto &bound_ref = (BoundReferenceExpression &)*delim_expr;
-		delim_types.push_back(bound_ref.return_type);
-		distinct_groups.push_back(make_unique<BoundReferenceExpression>(bound_ref.return_type, bound_ref.index));
-	}
-	// now create the duplicate eliminated join
-	auto delim_join = make_unique<PhysicalDelimJoin>(op.types, move(plan), delim_scans, op.estimated_cardinality);
-	// we still have to create the DISTINCT clause that is used to generate the duplicate eliminated chunk
-	delim_join->distinct = make_unique<PhysicalHashAggregate>(context, delim_types, move(distinct_expressions),
-	                                                          move(distinct_groups), op.estimated_cardinality);
-	return move(delim_join);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<PhysicalOperator> child,
-                                                                     vector<unique_ptr<Expression>> distinct_targets) {
-	D_ASSERT(child);
-	D_ASSERT(!distinct_targets.empty());
-
-	auto &types = child->GetTypes();
-	vector<unique_ptr<Expression>> groups, aggregates, projections;
-	idx_t group_count = distinct_targets.size();
-	unordered_map<idx_t, idx_t> group_by_references;
-	vector<LogicalType> aggregate_types;
-	// creates one group per distinct_target
-	for (idx_t i = 0; i < distinct_targets.size(); i++) {
-		auto &target = distinct_targets[i];
-		if (target->type == ExpressionType::BOUND_REF) {
-			auto &bound_ref = (BoundReferenceExpression &)*target;
-			group_by_references[bound_ref.index] = i;
-		}
-		aggregate_types.push_back(target->return_type);
-		groups.push_back(move(target));
-	}
-	bool requires_projection = false;
-	if (types.size() != group_count) {
-		requires_projection = true;
-	}
-	// we need to create one aggregate per column in the select_list
-	for (idx_t i = 0; i < types.size(); ++i) {
-		auto logical_type = types[i];
-		// check if we can directly refer to a group, or if we need to push an aggregate with FIRST
-		auto entry = group_by_references.find(i);
-		if (entry != group_by_references.end()) {
-			auto group_index = entry->second;
-			// entry is found: can directly refer to a group
-			projections.push_back(make_unique<BoundReferenceExpression>(logical_type, group_index));
-			if (group_index != i) {
-				// we require a projection only if this group element is out of order
-				requires_projection = true;
-			}
-		} else {
-			// entry is not one of the groups: need to push a FIRST aggregate
-			auto bound = make_unique<BoundReferenceExpression>(logical_type, i);
-			vector<unique_ptr<Expression>> first_children;
-			first_children.push_back(move(bound));
-			auto first_aggregate = AggregateFunction::BindAggregateFunction(
-			    context, FirstFun::GetFunction(logical_type), move(first_children), nullptr, false);
-			// add the projection
-			projections.push_back(make_unique<BoundReferenceExpression>(logical_type, group_count + aggregates.size()));
-			// push it to the list of aggregates
-			aggregate_types.push_back(logical_type);
-			aggregates.push_back(move(first_aggregate));
-			requires_projection = true;
-		}
-	}
-
-	child = ExtractAggregateExpressions(move(child), aggregates, groups);
-
-	// we add a physical hash aggregation in the plan to select the distinct groups
-	auto groupby = make_unique<PhysicalHashAggregate>(context, aggregate_types, move(aggregates), move(groups),
-	                                                  child->estimated_cardinality);
-	groupby->children.push_back(move(child));
-	if (!requires_projection) {
-		return move(groupby);
-	}
-
-	// we add a physical projection on top of the aggregation to project all members in the select list
-	auto aggr_projection = make_unique<PhysicalProjection>(types, move(projections), groupby->estimated_cardinality);
-	aggr_projection->children.push_back(move(groupby));
-	return move(aggr_projection);
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-	return CreateDistinctOn(move(plan), move(op.distinct_targets));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDummyScan &op) {
-	D_ASSERT(op.children.size() == 0);
-	return make_unique<PhysicalDummyScan>(op.types, op.estimated_cardinality);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalEmptyResult &op) {
-	D_ASSERT(op.children.size() == 0);
-	return make_unique<PhysicalEmptyResult>(op.types, op.estimated_cardinality);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExecute &op) {
-	if (!op.prepared->plan) {
-		D_ASSERT(op.children.size() == 1);
-		auto owned_plan = CreatePlan(*op.children[0]);
-		auto execute = make_unique<PhysicalExecute>(owned_plan.get());
-		execute->owned_plan = move(owned_plan);
-		execute->prepared = move(op.prepared);
-		return move(execute);
-	} else {
-		D_ASSERT(op.children.size() == 0);
-		return make_unique<PhysicalExecute>(op.prepared->plan.get());
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExplain &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto logical_plan_opt = op.children[0]->ToString();
-	auto plan = CreatePlan(*op.children[0]);
-	if (op.explain_type == ExplainType::EXPLAIN_ANALYZE) {
-		auto result = make_unique<PhysicalExplainAnalyze>(op.types);
-		result->children.push_back(move(plan));
-		return move(result);
-	}
-
-	op.physical_plan = plan->ToString();
-	// the output of the explain
-	vector<string> keys, values;
-	switch (ClientConfig::GetConfig(context).explain_output_type) {
-	case ExplainOutputType::OPTIMIZED_ONLY:
-		keys = {"logical_opt"};
-		values = {logical_plan_opt};
-		break;
-	case ExplainOutputType::PHYSICAL_ONLY:
-		keys = {"physical_plan"};
-		values = {op.physical_plan};
-		break;
-	default:
-		keys = {"logical_plan", "logical_opt", "physical_plan"};
-		values = {op.logical_plan_unopt, logical_plan_opt, op.physical_plan};
-	}
-
-	// create a ChunkCollection from the output
-	auto &allocator = Allocator::Get(context);
-	auto collection = make_unique<ChunkCollection>(allocator);
-
-	DataChunk chunk;
-	chunk.Initialize(allocator, op.types);
-	for (idx_t i = 0; i < keys.size(); i++) {
-		chunk.SetValue(0, chunk.size(), Value(keys[i]));
-		chunk.SetValue(1, chunk.size(), Value(values[i]));
-		chunk.SetCardinality(chunk.size() + 1);
-		if (chunk.size() == STANDARD_VECTOR_SIZE) {
-			collection->Append(chunk);
-			chunk.Reset();
-		}
-	}
-	collection->Append(chunk);
-
-	// create a chunk scan to output the result
-	auto chunk_scan =
-	    make_unique<PhysicalChunkScan>(op.types, PhysicalOperatorType::CHUNK_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = move(collection);
-	chunk_scan->collection = chunk_scan->owned_collection.get();
-	return move(chunk_scan);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExport &op) {
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.enable_external_access) {
-		throw PermissionException("Export is disabled through configuration");
-	}
-	auto export_node = make_unique<PhysicalExport>(op.types, op.function, move(op.copy_info), op.estimated_cardinality,
-	                                               op.exported_tables);
-	// plan the underlying copy statements, if any
-	if (!op.children.empty()) {
-		auto plan = CreatePlan(*op.children[0]);
-		export_node->children.push_back(move(plan));
-	}
-	return move(export_node);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExpressionGet &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-
-	auto expr_scan = make_unique<PhysicalExpressionScan>(op.types, move(op.expressions), op.estimated_cardinality);
-	expr_scan->children.push_back(move(plan));
-	if (!expr_scan->IsFoldable()) {
-		return move(expr_scan);
-	}
-	auto &allocator = Allocator::Get(context);
-	// simple expression scan (i.e. no subqueries to evaluate and no prepared statement parameters)
-	// we can evaluate all the expressions right now and turn this into a chunk collection scan
-	auto chunk_scan =
-	    make_unique<PhysicalChunkScan>(op.types, PhysicalOperatorType::CHUNK_SCAN, expr_scan->expressions.size());
-	chunk_scan->owned_collection = make_unique<ChunkCollection>(allocator);
-	chunk_scan->collection = chunk_scan->owned_collection.get();
-
-	DataChunk chunk;
-	chunk.Initialize(allocator, op.types);
-	for (idx_t expression_idx = 0; expression_idx < expr_scan->expressions.size(); expression_idx++) {
-		chunk.Reset();
-		expr_scan->EvaluateExpression(allocator, expression_idx, nullptr, chunk);
-		chunk_scan->owned_collection->Append(chunk);
-	}
-	return move(chunk_scan);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalFilter &op) {
-	D_ASSERT(op.children.size() == 1);
-	unique_ptr<PhysicalOperator> plan = CreatePlan(*op.children[0]);
-	if (!op.expressions.empty()) {
-		D_ASSERT(plan->types.size() > 0);
-		// create a filter if there is anything to filter
-		auto filter = make_unique<PhysicalFilter>(plan->types, move(op.expressions), op.estimated_cardinality);
-		filter->children.push_back(move(plan));
-		plan = move(filter);
-	}
-	if (!op.projection_map.empty()) {
-		// there is a projection map, generate a physical projection
-		vector<unique_ptr<Expression>> select_list;
-		for (idx_t i = 0; i < op.projection_map.size(); i++) {
-			select_list.push_back(make_unique<BoundReferenceExpression>(op.types[i], op.projection_map[i]));
-		}
-		auto proj = make_unique<PhysicalProjection>(op.types, move(select_list), op.estimated_cardinality);
-		proj->children.push_back(move(plan));
-		plan = move(proj);
-	}
-	return plan;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<TableFilterSet> CreateTableFilterSet(TableFilterSet &table_filters, vector<column_t> &column_ids) {
-	// create the table filter map
-	auto table_filter_set = make_unique<TableFilterSet>();
-	for (auto &table_filter : table_filters.filters) {
-		// find the relative column index from the absolute column index into the table
-		idx_t column_index = DConstants::INVALID_INDEX;
-		for (idx_t i = 0; i < column_ids.size(); i++) {
-			if (table_filter.first == column_ids[i]) {
-				column_index = i;
-				break;
-			}
-		}
-		if (column_index == DConstants::INVALID_INDEX) {
-			throw InternalException("Could not find column index for table filter");
-		}
-		table_filter_set->filters[column_index] = move(table_filter.second);
-	}
-	return table_filter_set;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalGet &op) {
-	if (!op.children.empty()) {
-		// this is for table producing functions that consume subquery results
-		D_ASSERT(op.children.size() == 1);
-		auto node = make_unique<PhysicalTableInOutFunction>(op.returned_types, op.function, move(op.bind_data),
-		                                                    op.column_ids, op.estimated_cardinality);
-		node->children.push_back(CreatePlan(move(op.children[0])));
-		return move(node);
-	}
-
-	unique_ptr<TableFilterSet> table_filters;
-	if (!op.table_filters.filters.empty()) {
-		table_filters = CreateTableFilterSet(op.table_filters, op.column_ids);
-	}
-
-	if (op.function.dependency) {
-		op.function.dependency(dependencies, op.bind_data.get());
-	}
-	// create the table scan node
-	if (!op.function.projection_pushdown) {
-		// function does not support projection pushdown
-		auto node = make_unique<PhysicalTableScan>(op.returned_types, op.function, move(op.bind_data), op.column_ids,
-		                                           op.names, move(table_filters), op.estimated_cardinality);
-		// first check if an additional projection is necessary
-		if (op.column_ids.size() == op.returned_types.size()) {
-			bool projection_necessary = false;
-			for (idx_t i = 0; i < op.column_ids.size(); i++) {
-				if (op.column_ids[i] != i) {
-					projection_necessary = true;
-					break;
-				}
-			}
-			if (!projection_necessary) {
-				// a projection is not necessary if all columns have been requested in-order
-				// in that case we just return the node
-
-				return move(node);
-			}
-		}
-		// push a projection on top that does the projection
-		vector<LogicalType> types;
-		vector<unique_ptr<Expression>> expressions;
-		for (auto &column_id : op.column_ids) {
-			if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
-				types.emplace_back(LogicalType::BIGINT);
-				expressions.push_back(make_unique<BoundConstantExpression>(Value::BIGINT(0)));
-			} else {
-				auto type = op.returned_types[column_id];
-				types.push_back(type);
-				expressions.push_back(make_unique<BoundReferenceExpression>(type, column_id));
-			}
-		}
-
-		auto projection = make_unique<PhysicalProjection>(move(types), move(expressions), op.estimated_cardinality);
-		projection->children.push_back(move(node));
-		return move(projection);
-	} else {
-		return make_unique<PhysicalTableScan>(op.types, op.function, move(op.bind_data), op.column_ids, op.names,
-		                                      move(table_filters), op.estimated_cardinality);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op) {
-	unique_ptr<PhysicalOperator> plan;
-	if (!op.children.empty()) {
-		D_ASSERT(op.children.size() == 1);
-		plan = CreatePlan(*op.children[0]);
-	}
-
-	dependencies.insert(op.table);
-	auto insert = make_unique<PhysicalInsert>(op.types, op.table, op.column_index_map, move(op.bound_defaults),
-	                                          op.estimated_cardinality, op.return_chunk);
-	if (plan) {
-		insert->children.push_back(move(plan));
-	}
-	return move(insert);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalLimit &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-	auto &config = DBConfig::GetConfig(context);
-	unique_ptr<PhysicalOperator> limit;
-	if (!config.preserve_insertion_order) {
-		// use parallel streaming limit if insertion order is not important
-		limit = make_unique<PhysicalStreamingLimit>(op.types, (idx_t)op.limit_val, op.offset_val, move(op.limit),
-		                                            move(op.offset), op.estimated_cardinality, true);
-	} else {
-		// maintaining insertion order is important
-		bool all_sources_support_batch_index = plan->AllSourcesSupportBatchIndex();
-
-		if (all_sources_support_batch_index) {
-			// source supports batch index: use parallel batch limit
-			limit = make_unique<PhysicalLimit>(op.types, (idx_t)op.limit_val, op.offset_val, move(op.limit),
-			                                   move(op.offset), op.estimated_cardinality);
-		} else {
-			// source does not support batch index: use a non-parallel streaming limit
-			limit = make_unique<PhysicalStreamingLimit>(op.types, (idx_t)op.limit_val, op.offset_val, move(op.limit),
-			                                            move(op.offset), op.estimated_cardinality, false);
-		}
-	}
-
-	limit->children.push_back(move(plan));
-	return limit;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalLimitPercent &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	auto limit = make_unique<PhysicalLimitPercent>(op.types, op.limit_percent, op.offset_val, move(op.limit),
-	                                               move(op.offset), op.estimated_cardinality);
-	limit->children.push_back(move(plan));
-	return move(limit);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOrder &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-	if (!op.orders.empty()) {
-		auto order = make_unique<PhysicalOrder>(op.types, move(op.orders), op.estimated_cardinality);
-		order->children.push_back(move(plan));
-		plan = move(order);
-	}
-	return plan;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPragma &op) {
-	return make_unique<PhysicalPragma>(op.function, op.info, op.estimated_cardinality);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPrepare &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	// generate physical plan
-	auto plan = CreatePlan(*op.children[0]);
-	op.prepared->types = plan->types;
-	op.prepared->plan = move(plan);
-
-	return make_unique<PhysicalPrepare>(op.name, move(op.prepared), op.estimated_cardinality);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalProjection &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-
-#ifdef DEBUG
-	for (auto &expr : op.expressions) {
-		D_ASSERT(!expr->IsWindow());
-		D_ASSERT(!expr->IsAggregate());
-	}
-#endif
-	if (plan->types.size() == op.types.size()) {
-		// check if this projection can be omitted entirely
-		// this happens if a projection simply emits the columns in the same order
-		// e.g. PROJECTION(#0, #1, #2, #3, ...)
-		bool omit_projection = true;
-		for (idx_t i = 0; i < op.types.size(); i++) {
-			if (op.expressions[i]->type == ExpressionType::BOUND_REF) {
-				auto &bound_ref = (BoundReferenceExpression &)*op.expressions[i];
-				if (bound_ref.index == i) {
-					continue;
-				}
-			}
-			omit_projection = false;
-			break;
-		}
-		if (omit_projection) {
-			// the projection only directly projects the child' columns: omit it entirely
-			return plan;
-		}
-	}
-
-	auto projection = make_unique<PhysicalProjection>(op.types, move(op.expressions), op.estimated_cardinality);
-	projection->children.push_back(move(plan));
-	return move(projection);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalRecursiveCTE &op) {
-	D_ASSERT(op.children.size() == 2);
-
-	// Create the working_table that the PhysicalRecursiveCTE will use for evaluation.
-	auto working_table = std::make_shared<ChunkCollection>(context);
-
-	// Add the ChunkCollection to the context of this PhysicalPlanGenerator
-	rec_ctes[op.table_index] = working_table;
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-
-	auto cte =
-	    make_unique<PhysicalRecursiveCTE>(op.types, op.union_all, move(left), move(right), op.estimated_cardinality);
-	cte->working_table = working_table;
-
-	return move(cte);
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCTERef &op) {
-	D_ASSERT(op.children.empty());
-
-	auto chunk_scan =
-	    make_unique<PhysicalChunkScan>(op.types, PhysicalOperatorType::RECURSIVE_CTE_SCAN, op.estimated_cardinality);
-
-	// CreatePlan of a LogicalRecursiveCTE must have happened before.
-	auto cte = rec_ctes.find(op.cte_index);
-	if (cte == rec_ctes.end()) {
-		throw Exception("Referenced recursive CTE does not exist.");
-	}
-	chunk_scan->collection = cte->second.get();
-	return move(chunk_scan);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSample &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	unique_ptr<PhysicalOperator> sample;
-	switch (op.sample_options->method) {
-	case SampleMethod::RESERVOIR_SAMPLE:
-		sample = make_unique<PhysicalReservoirSample>(op.types, move(op.sample_options), op.estimated_cardinality);
-		break;
-	case SampleMethod::SYSTEM_SAMPLE:
-	case SampleMethod::BERNOULLI_SAMPLE:
-		if (!op.sample_options->is_percentage) {
-			throw ParserException("Sample method %s cannot be used with a discrete sample count, either switch to "
-			                      "reservoir sampling or use a sample_size",
-			                      SampleMethodToString(op.sample_options->method));
-		}
-		sample = make_unique<PhysicalStreamingSample>(op.types, op.sample_options->method,
-		                                              op.sample_options->sample_size.GetValue<double>(),
-		                                              op.sample_options->seed, op.estimated_cardinality);
-		break;
-	default:
-		throw InternalException("Unimplemented sample method");
-	}
-	sample->children.push_back(move(plan));
-	return sample;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSet &op) {
-	return make_unique<PhysicalSet>(op.name, op.value, op.scope, op.estimated_cardinality);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSetOperation &op) {
-	D_ASSERT(op.children.size() == 2);
-
-	auto left = CreatePlan(*op.children[0]);
-	auto right = CreatePlan(*op.children[1]);
-
-	if (left->GetTypes() != right->GetTypes()) {
-		throw Exception("Type mismatch for SET OPERATION");
-	}
-
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_UNION:
-		// UNION
-		return make_unique<PhysicalUnion>(op.types, move(left), move(right), op.estimated_cardinality);
-	default: {
-		// EXCEPT/INTERSECT
-		D_ASSERT(op.type == LogicalOperatorType::LOGICAL_EXCEPT || op.type == LogicalOperatorType::LOGICAL_INTERSECT);
-		auto &types = left->GetTypes();
-		vector<JoinCondition> conditions;
-		// create equality condition for all columns
-		for (idx_t i = 0; i < types.size(); i++) {
-			JoinCondition cond;
-			cond.left = make_unique<BoundReferenceExpression>(types[i], i);
-			cond.right = make_unique<BoundReferenceExpression>(types[i], i);
-			cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-			conditions.push_back(move(cond));
-		}
-		// EXCEPT is ANTI join
-		// INTERSECT is SEMI join
-		PerfectHashJoinStats join_stats; // used in inner joins only
-		JoinType join_type = op.type == LogicalOperatorType::LOGICAL_EXCEPT ? JoinType::ANTI : JoinType::SEMI;
-		return make_unique<PhysicalHashJoin>(op, move(left), move(right), move(conditions), join_type,
-		                                     op.estimated_cardinality, join_stats);
-	}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalShow &op) {
-	DataChunk output;
-	output.Initialize(Allocator::Get(context), op.types);
-
-	auto collection = make_unique<ChunkCollection>(Allocator::Get(context));
-	for (idx_t column_idx = 0; column_idx < op.types_select.size(); column_idx++) {
-		auto type = op.types_select[column_idx];
-		auto &name = op.aliases[column_idx];
-
-		// "name", TypeId::VARCHAR
-		output.SetValue(0, output.size(), Value(name));
-		// "type", TypeId::VARCHAR
-		output.SetValue(1, output.size(), Value(type.ToString()));
-		// "null", TypeId::VARCHAR
-		output.SetValue(2, output.size(), Value("YES"));
-		// "pk", TypeId::BOOL
-		output.SetValue(3, output.size(), Value());
-		// "dflt_value", TypeId::VARCHAR
-		output.SetValue(4, output.size(), Value());
-		// "extra", TypeId::VARCHAR
-		output.SetValue(5, output.size(), Value());
-
-		output.SetCardinality(output.size() + 1);
-		if (output.size() == STANDARD_VECTOR_SIZE) {
-			collection->Append(output);
-			output.Reset();
-		}
-	}
-
-	collection->Append(output);
-
-	// create a chunk scan to output the result
-	auto chunk_scan =
-	    make_unique<PhysicalChunkScan>(op.types, PhysicalOperatorType::CHUNK_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = move(collection);
-	chunk_scan->collection = chunk_scan->owned_collection.get();
-	return move(chunk_scan);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSimple &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_ALTER:
-		return make_unique<PhysicalAlter>(unique_ptr_cast<ParseInfo, AlterInfo>(move(op.info)),
-		                                  op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_DROP:
-		return make_unique<PhysicalDrop>(unique_ptr_cast<ParseInfo, DropInfo>(move(op.info)), op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		return make_unique<PhysicalTransaction>(unique_ptr_cast<ParseInfo, TransactionInfo>(move(op.info)),
-		                                        op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		return make_unique<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(move(op.info)),
-		                                   op.estimated_cardinality);
-	case LogicalOperatorType::LOGICAL_LOAD:
-		return make_unique<PhysicalLoad>(unique_ptr_cast<ParseInfo, LoadInfo>(move(op.info)), op.estimated_cardinality);
-	default:
-		throw NotImplementedException("Unimplemented type for logical simple operator");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalTopN &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	auto top_n =
-	    make_unique<PhysicalTopN>(op.types, move(op.orders), (idx_t)op.limit, op.offset, op.estimated_cardinality);
-	top_n->children.push_back(move(plan));
-	return move(top_n);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUnnest &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-	auto unnest = make_unique<PhysicalUnnest>(op.types, move(op.expressions), op.estimated_cardinality);
-	unnest->children.push_back(move(plan));
-	return move(unnest);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-
-	dependencies.insert(op.table);
-	auto update = make_unique<PhysicalUpdate>(op.types, *op.table, *op.table->storage, op.columns, move(op.expressions),
-	                                          move(op.bound_defaults), op.estimated_cardinality, op.return_chunk);
-
-	update->update_is_del_and_insert = op.update_is_del_and_insert;
-	update->children.push_back(move(plan));
-	return move(update);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-#include <numeric>
-
-namespace duckdb {
-
-static bool IsStreamingWindow(unique_ptr<Expression> &expr) {
-	auto wexpr = reinterpret_cast<BoundWindowExpression *>(expr.get());
-	if (!wexpr->partitions.empty() || !wexpr->orders.empty() || wexpr->ignore_nulls) {
-		return false;
-	}
-	switch (wexpr->type) {
-	// TODO: add more expression types here?
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_RANK_DENSE:
-	case ExpressionType::WINDOW_ROW_NUMBER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	auto plan = CreatePlan(*op.children[0]);
-#ifdef DEBUG
-	for (auto &expr : op.expressions) {
-		D_ASSERT(expr->IsWindow());
-	}
-#endif
-
-	// Slice types
-	auto types = op.types;
-	const auto output_idx = types.size() - op.expressions.size();
-	types.resize(output_idx);
-
-	// Identify streaming windows
-	vector<idx_t> blocking_windows;
-	vector<idx_t> streaming_windows;
-	for (idx_t expr_idx = 0; expr_idx < op.expressions.size(); expr_idx++) {
-		if (IsStreamingWindow(op.expressions[expr_idx])) {
-			streaming_windows.push_back(expr_idx);
-		} else {
-			blocking_windows.push_back(expr_idx);
-		}
-	}
-
-	// Process the window functions by sharing the partition/order definitions
-	vector<idx_t> evaluation_order;
-	while (!blocking_windows.empty() || !streaming_windows.empty()) {
-		const bool process_streaming = blocking_windows.empty();
-		auto &remaining = process_streaming ? streaming_windows : blocking_windows;
-
-		// Find all functions that share the partitioning of the first remaining expression
-		const auto over_idx = remaining[0];
-		auto over_expr = reinterpret_cast<BoundWindowExpression *>(op.expressions[over_idx].get());
-
-		vector<idx_t> matching;
-		vector<idx_t> unprocessed;
-		for (const auto &expr_idx : remaining) {
-			D_ASSERT(op.expressions[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-			auto wexpr = reinterpret_cast<BoundWindowExpression *>(op.expressions[expr_idx].get());
-			if (over_expr->KeysAreCompatible(wexpr)) {
-				matching.emplace_back(expr_idx);
-			} else {
-				unprocessed.emplace_back(expr_idx);
-			}
-		}
-		remaining.swap(unprocessed);
-
-		// Extract the matching expressions
-		vector<unique_ptr<Expression>> select_list;
-		for (const auto &expr_idx : matching) {
-			select_list.emplace_back(move(op.expressions[expr_idx]));
-			types.emplace_back(op.types[output_idx + expr_idx]);
-		}
-
-		// Chain the new window operator on top of the plan
-		unique_ptr<PhysicalOperator> window;
-		if (process_streaming) {
-			window = make_unique<PhysicalStreamingWindow>(types, move(select_list), op.estimated_cardinality);
-		} else {
-			window = make_unique<PhysicalWindow>(types, move(select_list), op.estimated_cardinality);
-		}
-		window->children.push_back(move(plan));
-		plan = move(window);
-
-		// Remember the projection order if we changed it
-		if (!remaining.empty() || !evaluation_order.empty()) {
-			evaluation_order.insert(evaluation_order.end(), matching.begin(), matching.end());
-		}
-	}
-
-	// Put everything back into place if it moved
-	if (!evaluation_order.empty()) {
-		vector<unique_ptr<Expression>> select_list(op.types.size());
-		// The inputs don't move
-		for (idx_t i = 0; i < output_idx; ++i) {
-			select_list[i] = make_unique<BoundReferenceExpression>(op.types[i], i);
-		}
-		// The outputs have been rearranged
-		for (idx_t i = 0; i < evaluation_order.size(); ++i) {
-			const auto expr_idx = evaluation_order[i] + output_idx;
-			select_list[expr_idx] = make_unique<BoundReferenceExpression>(op.types[expr_idx], i + output_idx);
-		}
-		auto proj = make_unique<PhysicalProjection>(op.types, move(select_list), op.estimated_cardinality);
-		proj->children.push_back(move(plan));
-		plan = move(proj);
-	}
-
-	return plan;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-class DependencyExtractor : public LogicalOperatorVisitor {
-public:
-	explicit DependencyExtractor(unordered_set<CatalogEntry *> &dependencies) : dependencies(dependencies) {
-	}
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundFunctionExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		// extract dependencies from the bound function expression
-		if (expr.function.dependency) {
-			expr.function.dependency(expr, dependencies);
-		}
-		return nullptr;
-	}
-
-private:
-	unordered_set<CatalogEntry *> &dependencies;
-};
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(unique_ptr<LogicalOperator> op) {
-	auto &profiler = QueryProfiler::Get(context);
-
-	// first resolve column references
-	profiler.StartPhase("column_binding");
-	ColumnBindingResolver resolver;
-	resolver.VisitOperator(*op);
-	profiler.EndPhase();
-
-	// now resolve types of all the operators
-	profiler.StartPhase("resolve_types");
-	op->ResolveOperatorTypes();
-	profiler.EndPhase();
-
-	// extract dependencies from the logical plan
-	DependencyExtractor extractor(dependencies);
-	extractor.VisitOperator(*op);
-
-	// then create the main physical plan
-	profiler.StartPhase("create_plan");
-	auto plan = CreatePlan(*op);
-	profiler.EndPhase();
-
-	plan->Verify();
-	return plan;
-}
-
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &op) {
-	op.estimated_cardinality = op.EstimateCardinality(context);
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_GET:
-		return CreatePlan((LogicalGet &)op);
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return CreatePlan((LogicalProjection &)op);
-	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		return CreatePlan((LogicalEmptyResult &)op);
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return CreatePlan((LogicalFilter &)op);
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return CreatePlan((LogicalAggregate &)op);
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		return CreatePlan((LogicalWindow &)op);
-	case LogicalOperatorType::LOGICAL_UNNEST:
-		return CreatePlan((LogicalUnnest &)op);
-	case LogicalOperatorType::LOGICAL_LIMIT:
-		return CreatePlan((LogicalLimit &)op);
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		return CreatePlan((LogicalLimitPercent &)op);
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-		return CreatePlan((LogicalSample &)op);
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		return CreatePlan((LogicalOrder &)op);
-	case LogicalOperatorType::LOGICAL_TOP_N:
-		return CreatePlan((LogicalTopN &)op);
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		return CreatePlan((LogicalCopyToFile &)op);
-	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		return CreatePlan((LogicalDummyScan &)op);
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		return CreatePlan((LogicalAnyJoin &)op);
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return CreatePlan((LogicalDelimJoin &)op);
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		return CreatePlan((LogicalComparisonJoin &)op);
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return CreatePlan((LogicalCrossProduct &)op);
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		return CreatePlan((LogicalSetOperation &)op);
-	case LogicalOperatorType::LOGICAL_INSERT:
-		return CreatePlan((LogicalInsert &)op);
-	case LogicalOperatorType::LOGICAL_DELETE:
-		return CreatePlan((LogicalDelete &)op);
-	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		return CreatePlan((LogicalChunkGet &)op);
-	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		return CreatePlan((LogicalDelimGet &)op);
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		return CreatePlan((LogicalExpressionGet &)op);
-	case LogicalOperatorType::LOGICAL_UPDATE:
-		return CreatePlan((LogicalUpdate &)op);
-	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		return CreatePlan((LogicalCreateTable &)op);
-	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		return CreatePlan((LogicalCreateIndex &)op);
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		return CreatePlan((LogicalExplain &)op);
-	case LogicalOperatorType::LOGICAL_SHOW:
-		return CreatePlan((LogicalShow &)op);
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		return CreatePlan((LogicalDistinct &)op);
-	case LogicalOperatorType::LOGICAL_PREPARE:
-		return CreatePlan((LogicalPrepare &)op);
-	case LogicalOperatorType::LOGICAL_EXECUTE:
-		return CreatePlan((LogicalExecute &)op);
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		return CreatePlan((LogicalCreate &)op);
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-		return CreatePlan((LogicalPragma &)op);
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-	case LogicalOperatorType::LOGICAL_ALTER:
-	case LogicalOperatorType::LOGICAL_DROP:
-	case LogicalOperatorType::LOGICAL_VACUUM:
-	case LogicalOperatorType::LOGICAL_LOAD:
-		return CreatePlan((LogicalSimple &)op);
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		return CreatePlan((LogicalRecursiveCTE &)op);
-	case LogicalOperatorType::LOGICAL_CTE_REF:
-		return CreatePlan((LogicalCTERef &)op);
-	case LogicalOperatorType::LOGICAL_EXPORT:
-		return CreatePlan((LogicalExport &)op);
-	case LogicalOperatorType::LOGICAL_SET:
-		return CreatePlan((LogicalSet &)op);
-	default:
-		throw NotImplementedException("Unimplemented logical operator type!");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-RadixPartitionedHashTable::RadixPartitionedHashTable(GroupingSet &grouping_set_p, const PhysicalHashAggregate &op_p)
-    : grouping_set(grouping_set_p), op(op_p) {
-
-	for (idx_t i = 0; i < op.groups.size(); i++) {
-		if (grouping_set.find(i) == grouping_set.end()) {
-			null_groups.push_back(i);
-		}
-	}
-
-	// 10000 seems like a good compromise here
-	radix_limit = 10000;
-
-	if (grouping_set.empty()) {
-		// fake a single group with a constant value for aggregation without groups
-		group_types.emplace_back(LogicalType::TINYINT);
-	}
-	for (auto &entry : grouping_set) {
-		D_ASSERT(entry < op.group_types.size());
-		group_types.push_back(op.group_types[entry]);
-	}
-	// compute the GROUPING values
-	// for each parameter to the GROUPING clause, we check if the hash table groups on this particular group
-	// if it does, we return 0, otherwise we return 1
-	// we then use bitshifts to combine these values
-	for (auto &grouping : op.grouping_functions) {
-		int64_t grouping_value = 0;
-		for (idx_t i = 0; i < grouping.size(); i++) {
-			if (grouping_set.find(grouping[i]) == grouping_set.end()) {
-				// we don't group on this value!
-				grouping_value += 1 << (grouping.size() - (i + 1));
-			}
-		}
-		grouping_values.push_back(Value::BIGINT(grouping_value));
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-class RadixHTGlobalState : public GlobalSinkState {
-public:
-	explicit RadixHTGlobalState(ClientContext &context)
-	    : is_empty(true), multi_scan(true), total_groups(0),
-	      partition_info((idx_t)TaskScheduler::GetScheduler(context).NumberOfThreads()) {
-	}
-
-	vector<unique_ptr<PartitionableHashTable>> intermediate_hts;
-	vector<unique_ptr<GroupedAggregateHashTable>> finalized_hts;
-
-	//! Whether or not any tuples were added to the HT
-	bool is_empty;
-	//! Whether or not the hash table should be scannable multiple times
-	bool multi_scan;
-	//! The lock for updating the global aggregate state
-	mutex lock;
-	//! a counter to determine if we should switch over to p
-	atomic<idx_t> total_groups;
-
-	bool is_finalized = false;
-	bool is_partitioned = false;
-
-	RadixPartitionInfo partition_info;
-};
-
-class RadixHTLocalState : public LocalSinkState {
-public:
-	explicit RadixHTLocalState(const RadixPartitionedHashTable &ht) : is_empty(true) {
-		// if there are no groups we create a fake group so everything has the same group
-		group_chunk.InitializeEmpty(ht.group_types);
-		if (ht.grouping_set.empty()) {
-			group_chunk.data[0].Reference(Value::TINYINT(42));
-		}
-	}
-
-	DataChunk group_chunk;
-	//! The aggregate HT
-	unique_ptr<PartitionableHashTable> ht;
-
-	//! Whether or not any tuples were added to the HT
-	bool is_empty;
-};
-
-void RadixPartitionedHashTable::SetMultiScan(GlobalSinkState &state) {
-	auto &gstate = (RadixHTGlobalState &)state;
-	gstate.multi_scan = true;
-}
-
-unique_ptr<GlobalSinkState> RadixPartitionedHashTable::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<RadixHTGlobalState>(context);
-}
-
-unique_ptr<LocalSinkState> RadixPartitionedHashTable::GetLocalSinkState(ExecutionContext &context) const {
-	return make_unique<RadixHTLocalState>(*this);
-}
-
-void RadixPartitionedHashTable::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                     DataChunk &input, DataChunk &aggregate_input_chunk) const {
-	auto &llstate = (RadixHTLocalState &)lstate;
-	auto &gstate = (RadixHTGlobalState &)state;
-	D_ASSERT(!gstate.is_finalized);
-
-	DataChunk &group_chunk = llstate.group_chunk;
-	idx_t chunk_index = 0;
-	for (auto &group_idx : grouping_set) {
-		auto &group = op.groups[group_idx];
-		D_ASSERT(group->type == ExpressionType::BOUND_REF);
-		auto &bound_ref_expr = (BoundReferenceExpression &)*group;
-		group_chunk.data[chunk_index++].Reference(input.data[bound_ref_expr.index]);
-	}
-	group_chunk.SetCardinality(input.size());
-	group_chunk.Verify();
-
-	// if we have non-combinable aggregates (e.g. string_agg) or any distinct aggregates we cannot keep parallel hash
-	// tables
-	if (ForceSingleHT(state)) {
-		lock_guard<mutex> glock(gstate.lock);
-		gstate.is_empty = gstate.is_empty && group_chunk.size() == 0;
-		if (gstate.finalized_hts.empty()) {
-			gstate.finalized_hts.push_back(make_unique<GroupedAggregateHashTable>(
-			    Allocator::Get(context.client), BufferManager::GetBufferManager(context.client), group_types,
-			    op.payload_types, op.bindings, HtEntryType::HT_WIDTH_64));
-		}
-		D_ASSERT(gstate.finalized_hts.size() == 1);
-		D_ASSERT(gstate.finalized_hts[0]);
-		gstate.total_groups += gstate.finalized_hts[0]->AddChunk(group_chunk, aggregate_input_chunk);
-		return;
-	}
-
-	D_ASSERT(!op.any_distinct);
-
-	if (group_chunk.size() > 0) {
-		llstate.is_empty = false;
-	}
-
-	if (!llstate.ht) {
-		llstate.ht = make_unique<PartitionableHashTable>(
-		    Allocator::Get(context.client), BufferManager::GetBufferManager(context.client), gstate.partition_info,
-		    group_types, op.payload_types, op.bindings);
-	}
-
-	gstate.total_groups +=
-	    llstate.ht->AddChunk(group_chunk, aggregate_input_chunk,
-	                         gstate.total_groups > radix_limit && gstate.partition_info.n_partitions > 1);
-}
-
-void RadixPartitionedHashTable::Combine(ExecutionContext &context, GlobalSinkState &state,
-                                        LocalSinkState &lstate) const {
-	auto &llstate = (RadixHTLocalState &)lstate;
-	auto &gstate = (RadixHTGlobalState &)state;
-	D_ASSERT(!gstate.is_finalized);
-
-	// this actually does not do a lot but just pushes the local HTs into the global state so we can later combine them
-	// in parallel
-
-	if (ForceSingleHT(state)) {
-		D_ASSERT(gstate.finalized_hts.size() <= 1);
-		return;
-	}
-
-	if (!llstate.ht) {
-		return; // no data
-	}
-
-	if (!llstate.ht->IsPartitioned() && gstate.partition_info.n_partitions > 1 && gstate.total_groups > radix_limit) {
-		llstate.ht->Partition();
-	}
-
-	lock_guard<mutex> glock(gstate.lock);
-	D_ASSERT(!op.any_distinct);
-
-	if (!llstate.is_empty) {
-		gstate.is_empty = false;
-	}
-
-	// we will never add new values to these HTs so we can drop the first part of the HT
-	llstate.ht->Finalize();
-
-	// at this point we just collect them the PhysicalHashAggregateFinalizeTask (below) will merge them in parallel
-	gstate.intermediate_hts.push_back(move(llstate.ht));
-}
-
-bool RadixPartitionedHashTable::Finalize(ClientContext &context, GlobalSinkState &gstate_p) const {
-	auto &gstate = (RadixHTGlobalState &)gstate_p;
-	D_ASSERT(!gstate.is_finalized);
-	gstate.is_finalized = true;
-
-	// special case if we have non-combinable aggregates
-	// we have already aggreagted into a global shared HT that does not require any additional finalization steps
-	if (ForceSingleHT(gstate)) {
-		D_ASSERT(gstate.finalized_hts.size() <= 1);
-		D_ASSERT(gstate.finalized_hts.empty() || gstate.finalized_hts[0]);
-		return false;
-	}
-
-	// we can have two cases now, non-partitioned for few groups and radix-partitioned for very many groups.
-	// go through all of the child hts and see if we ever called partition() on any of them
-	// if we did, its the latter case.
-	bool any_partitioned = false;
-	for (auto &pht : gstate.intermediate_hts) {
-		if (pht->IsPartitioned()) {
-			any_partitioned = true;
-			break;
-		}
-	}
-
-	auto &allocator = Allocator::Get(context);
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	if (any_partitioned) {
-		// if one is partitioned, all have to be
-		// this should mostly have already happened in Combine, but if not we do it here
-		for (auto &pht : gstate.intermediate_hts) {
-			if (!pht->IsPartitioned()) {
-				pht->Partition();
-			}
-		}
-		// schedule additional tasks to combine the partial HTs
-		gstate.finalized_hts.resize(gstate.partition_info.n_partitions);
-		for (idx_t r = 0; r < gstate.partition_info.n_partitions; r++) {
-			gstate.finalized_hts[r] = make_unique<GroupedAggregateHashTable>(
-			    allocator, buffer_manager, group_types, op.payload_types, op.bindings, HtEntryType::HT_WIDTH_64);
-		}
-		gstate.is_partitioned = true;
-		return true;
-	} else { // in the non-partitioned case we immediately combine all the unpartitioned hts created by the threads.
-		     // TODO possible optimization, if total count < limit for 32 bit ht, use that one
-		     // create this ht here so finalize needs no lock on gstate
-
-		gstate.finalized_hts.push_back(make_unique<GroupedAggregateHashTable>(
-		    allocator, buffer_manager, group_types, op.payload_types, op.bindings, HtEntryType::HT_WIDTH_64));
-		for (auto &pht : gstate.intermediate_hts) {
-			auto unpartitioned = pht->GetUnpartitioned();
-			for (auto &unpartitioned_ht : unpartitioned) {
-				D_ASSERT(unpartitioned_ht);
-				gstate.finalized_hts[0]->Combine(*unpartitioned_ht);
-				unpartitioned_ht.reset();
-			}
-			unpartitioned.clear();
-		}
-		D_ASSERT(gstate.finalized_hts[0]);
-		gstate.finalized_hts[0]->Finalize();
-		return false;
-	}
-}
-
-// this task is run in multiple threads and combines the radix-partitioned hash tables into a single onen and then
-// folds them into the global ht finally.
-class RadixAggregateFinalizeTask : public ExecutorTask {
-public:
-	RadixAggregateFinalizeTask(Executor &executor, shared_ptr<Event> event_p, RadixHTGlobalState &state_p,
-	                           idx_t radix_p)
-	    : ExecutorTask(executor), event(move(event_p)), state(state_p), radix(radix_p) {
-	}
-
-	static void FinalizeHT(RadixHTGlobalState &gstate, idx_t radix) {
-		D_ASSERT(gstate.partition_info.n_partitions <= gstate.finalized_hts.size());
-		D_ASSERT(gstate.finalized_hts[radix]);
-		for (auto &pht : gstate.intermediate_hts) {
-			for (auto &ht : pht->GetPartition(radix)) {
-				gstate.finalized_hts[radix]->Combine(*ht);
-				ht.reset();
-			}
-		}
-		gstate.finalized_hts[radix]->Finalize();
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		FinalizeHT(state, radix);
-		event->FinishTask();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	shared_ptr<Event> event;
-	RadixHTGlobalState &state;
-	idx_t radix;
-};
-
-void RadixPartitionedHashTable::ScheduleTasks(Executor &executor, const shared_ptr<Event> &event,
-                                              GlobalSinkState &state, vector<unique_ptr<Task>> &tasks) const {
-	auto &gstate = (RadixHTGlobalState &)state;
-	if (!gstate.is_partitioned) {
-		return;
-	}
-	for (idx_t r = 0; r < gstate.partition_info.n_partitions; r++) {
-		D_ASSERT(gstate.partition_info.n_partitions <= gstate.finalized_hts.size());
-		D_ASSERT(gstate.finalized_hts[r]);
-		tasks.push_back(make_unique<RadixAggregateFinalizeTask>(executor, event, gstate, r));
-	}
-}
-
-bool RadixPartitionedHashTable::ForceSingleHT(GlobalSinkState &state) const {
-	auto &gstate = (RadixHTGlobalState &)state;
-	return op.any_distinct || gstate.partition_info.n_partitions < 2;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-class RadixHTGlobalSourceState : public GlobalSourceState {
-public:
-	explicit RadixHTGlobalSourceState(Allocator &allocator, const RadixPartitionedHashTable &ht)
-	    : ht_index(0), ht_scan_position(0), finished(false) {
-		auto scan_chunk_types = ht.group_types;
-		for (auto &aggr_type : ht.op.aggregate_return_types) {
-			scan_chunk_types.push_back(aggr_type);
-		}
-		scan_chunk.Initialize(allocator, scan_chunk_types);
-	}
-
-	//! Materialized GROUP BY expressions & aggregates
-	DataChunk scan_chunk;
-	//! The current position to scan the HT for output tuples
-	idx_t ht_index;
-	idx_t ht_scan_position;
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> RadixPartitionedHashTable::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<RadixHTGlobalSourceState>(Allocator::Get(context), *this);
-}
-
-void RadixPartitionedHashTable::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSinkState &sink_state,
-                                        GlobalSourceState &source_state) const {
-	auto &gstate = (RadixHTGlobalState &)sink_state;
-	auto &state = (RadixHTGlobalSourceState &)source_state;
-	D_ASSERT(gstate.is_finalized);
-	if (state.finished) {
-		return;
-	}
-
-	state.scan_chunk.Reset();
-	// special case hack to sort out aggregating from empty intermediates
-	// for aggregations without groups
-	if (gstate.is_empty && grouping_set.empty()) {
-		D_ASSERT(chunk.ColumnCount() == null_groups.size() + op.aggregates.size());
-		// for each column in the aggregates, set to initial state
-		chunk.SetCardinality(1);
-		for (auto null_group : null_groups) {
-			chunk.data[null_group].SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(chunk.data[null_group], true);
-		}
-		for (idx_t i = 0; i < op.aggregates.size(); i++) {
-			D_ASSERT(op.aggregates[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-			auto &aggr = (BoundAggregateExpression &)*op.aggregates[i];
-			auto aggr_state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
-			aggr.function.initialize(aggr_state.get());
-
-			AggregateInputData aggr_input_data(aggr.bind_info.get());
-			Vector state_vector(Value::POINTER((uintptr_t)aggr_state.get()));
-			aggr.function.finalize(state_vector, aggr_input_data, chunk.data[null_groups.size() + i], 1, 0);
-			if (aggr.function.destructor) {
-				aggr.function.destructor(state_vector, 1);
-			}
-		}
-		state.finished = true;
-		return;
-	}
-	if (gstate.is_empty && !state.finished) {
-		state.finished = true;
-		return;
-	}
-	idx_t elements_found = 0;
-
-	while (true) {
-		if (state.ht_index == gstate.finalized_hts.size()) {
-			state.finished = true;
-			return;
-		}
-		D_ASSERT(gstate.finalized_hts[state.ht_index]);
-		elements_found = gstate.finalized_hts[state.ht_index]->Scan(state.ht_scan_position, state.scan_chunk);
-
-		if (elements_found > 0) {
-			break;
-		}
-		if (!gstate.multi_scan) {
-			gstate.finalized_hts[state.ht_index].reset();
-		}
-		state.ht_index++;
-		state.ht_scan_position = 0;
-	}
-
-	// compute the final projection list
-	chunk.SetCardinality(elements_found);
-
-	idx_t chunk_index = 0;
-	for (auto &entry : grouping_set) {
-		chunk.data[entry].Reference(state.scan_chunk.data[chunk_index++]);
-	}
-	for (auto null_group : null_groups) {
-		chunk.data[null_group].SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(chunk.data[null_group], true);
-	}
-	for (idx_t col_idx = 0; col_idx < op.aggregates.size(); col_idx++) {
-		chunk.data[op.groups.size() + col_idx].Reference(state.scan_chunk.data[group_types.size() + col_idx]);
-	}
-	D_ASSERT(op.grouping_functions.size() == grouping_values.size());
-	for (idx_t i = 0; i < op.grouping_functions.size(); i++) {
-		chunk.data[op.groups.size() + op.aggregates.size() + i].Reference(grouping_values[i]);
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-ReservoirSample::ReservoirSample(Allocator &allocator, idx_t sample_count, int64_t seed)
-    : BlockingSample(seed), sample_count(sample_count), reservoir(allocator) {
-}
-
-void ReservoirSample::AddToReservoir(DataChunk &input) {
-	if (sample_count == 0) {
-		return;
-	}
-	// Input: A population V of n weighted items
-	// Output: A reservoir R with a size m
-	// 1: The first m items of V are inserted into R
-	// first we need to check if the reservoir already has "m" elements
-	if (reservoir.Count() < sample_count) {
-		if (FillReservoir(input) == 0) {
-			// entire chunk was consumed by reservoir
-			return;
-		}
-	}
-	// find the position of next_index relative to current_count
-	idx_t remaining = input.size();
-	idx_t base_offset = 0;
-	while (true) {
-		idx_t offset = base_reservoir_sample.next_index - base_reservoir_sample.current_count;
-		if (offset >= remaining) {
-			// not in this chunk! increment current count and go to the next chunk
-			base_reservoir_sample.current_count += remaining;
-			return;
-		}
-		// in this chunk! replace the element
-		ReplaceElement(input, base_offset + offset);
-		// shift the chunk forward
-		remaining -= offset;
-		base_offset += offset;
-	}
-}
-
-unique_ptr<DataChunk> ReservoirSample::GetChunk() {
-	return reservoir.Fetch();
-}
-
-void ReservoirSample::ReplaceElement(DataChunk &input, idx_t index_in_chunk) {
-	// replace the entry in the reservoir
-	// 8. The item in R with the minimum key is replaced by item vi
-	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-		reservoir.SetValue(col_idx, base_reservoir_sample.min_entry, input.GetValue(col_idx, index_in_chunk));
-	}
-	base_reservoir_sample.ReplaceElement();
-}
-
-idx_t ReservoirSample::FillReservoir(DataChunk &input) {
-	idx_t chunk_count = input.size();
-	input.Normalify();
-
-	// we have not: append to the reservoir
-	idx_t required_count;
-	if (reservoir.Count() + chunk_count >= sample_count) {
-		// have to limit the count of the chunk
-		required_count = sample_count - reservoir.Count();
-	} else {
-		// we copy the entire chunk
-		required_count = chunk_count;
-	}
-	// instead of copying we just change the pointer in the current chunk
-	input.SetCardinality(required_count);
-	reservoir.Append(input);
-
-	base_reservoir_sample.InitializeReservoir(reservoir.Count(), sample_count);
-
-	// check if there are still elements remaining
-	// this happens if we are on a boundary
-	// for example, input.size() is 1024, but our sample size is 10
-	if (required_count == chunk_count) {
-		// we are done here
-		return 0;
-	}
-	// we still need to process a part of the chunk
-	// create a selection vector of the remaining elements
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	for (idx_t i = required_count; i < chunk_count; i++) {
-		sel.set_index(i - required_count, i);
-	}
-	// slice the input vector and continue
-	input.Slice(sel, chunk_count - required_count);
-	return input.size();
-}
-
-ReservoirSamplePercentage::ReservoirSamplePercentage(Allocator &allocator, double percentage, int64_t seed)
-    : BlockingSample(seed), allocator(allocator), sample_percentage(percentage / 100.0), current_count(0),
-      is_finalized(false) {
-	reservoir_sample_size = idx_t(sample_percentage * RESERVOIR_THRESHOLD);
-	current_sample = make_unique<ReservoirSample>(allocator, reservoir_sample_size, random.NextRandomInteger());
-}
-
-void ReservoirSamplePercentage::AddToReservoir(DataChunk &input) {
-	if (current_count + input.size() > RESERVOIR_THRESHOLD) {
-		// we don't have enough space in our current reservoir
-		// first check what we still need to append to the current sample
-		idx_t append_to_current_sample_count = RESERVOIR_THRESHOLD - current_count;
-		idx_t append_to_next_sample = input.size() - append_to_current_sample_count;
-		if (append_to_current_sample_count > 0) {
-			// we have elements remaining, first add them to the current sample
-			input.Normalify();
-
-			input.SetCardinality(append_to_current_sample_count);
-			current_sample->AddToReservoir(input);
-		}
-		if (append_to_next_sample > 0) {
-			// slice the input for the remainder
-			SelectionVector sel(STANDARD_VECTOR_SIZE);
-			for (idx_t i = 0; i < append_to_next_sample; i++) {
-				sel.set_index(i, append_to_current_sample_count + i);
-			}
-			input.Slice(sel, append_to_next_sample);
-		}
-		// now our first sample is filled: append it to the set of finished samples
-		finished_samples.push_back(move(current_sample));
-
-		// allocate a new sample, and potentially add the remainder of the current input to that sample
-		current_sample = make_unique<ReservoirSample>(allocator, reservoir_sample_size, random.NextRandomInteger());
-		if (append_to_next_sample > 0) {
-			current_sample->AddToReservoir(input);
-		}
-		current_count = append_to_next_sample;
-	} else {
-		// we can just append to the current sample
-		current_count += input.size();
-		current_sample->AddToReservoir(input);
-	}
-}
-
-unique_ptr<DataChunk> ReservoirSamplePercentage::GetChunk() {
-	if (!is_finalized) {
-		Finalize();
-	}
-	while (!finished_samples.empty()) {
-		auto &front = finished_samples.front();
-		auto chunk = front->GetChunk();
-		if (chunk && chunk->size() > 0) {
-			return chunk;
-		}
-		// move to the next sample
-		finished_samples.erase(finished_samples.begin());
-	}
-	return nullptr;
-}
-
-void ReservoirSamplePercentage::Finalize() {
-	// need to finalize the current sample, if any
-	if (current_count > 0) {
-		// create a new sample
-		auto new_sample_size = idx_t(round(sample_percentage * current_count));
-		auto new_sample = make_unique<ReservoirSample>(allocator, new_sample_size, random.NextRandomInteger());
-		while (true) {
-			auto chunk = current_sample->GetChunk();
-			if (!chunk || chunk->size() == 0) {
-				break;
-			}
-			new_sample->AddToReservoir(*chunk);
-		}
-		finished_samples.push_back(move(new_sample));
-	}
-	is_finalized = true;
-}
-
-BaseReservoirSampling::BaseReservoirSampling(int64_t seed) : random(seed) {
-	next_index = 0;
-	min_threshold = 0;
-	min_entry = 0;
-	current_count = 0;
-}
-
-BaseReservoirSampling::BaseReservoirSampling() : BaseReservoirSampling(-1) {
-}
-
-void BaseReservoirSampling::InitializeReservoir(idx_t cur_size, idx_t sample_size) {
-	//! 1: The first m items of V are inserted into R
-	//! first we need to check if the reservoir already has "m" elements
-	if (cur_size == sample_size) {
-		//! 2. For each item vi ∈ R: Calculate a key ki = random(0, 1)
-		//! we then define the threshold to enter the reservoir T_w as the minimum key of R
-		//! we use a priority queue to extract the minimum key in O(1) time
-		for (idx_t i = 0; i < sample_size; i++) {
-			double k_i = random.NextRandom();
-			reservoir_weights.push(std::make_pair(-k_i, i));
-		}
-		SetNextEntry();
-	}
-}
-
-void BaseReservoirSampling::SetNextEntry() {
-	//! 4. Let r = random(0, 1) and Xw = log(r) / log(T_w)
-	auto &min_key = reservoir_weights.top();
-	double t_w = -min_key.first;
-	double r = random.NextRandom();
-	double x_w = log(r) / log(t_w);
-	//! 5. From the current item vc skip items until item vi , such that:
-	//! 6. wc +wc+1 +···+wi−1 < Xw <= wc +wc+1 +···+wi−1 +wi
-	//! since all our weights are 1 (uniform sampling), we can just determine the amount of elements to skip
-	min_threshold = t_w;
-	min_entry = min_key.second;
-	next_index = MaxValue<idx_t>(1, idx_t(round(x_w)));
-	current_count = 0;
-}
-
-void BaseReservoirSampling::ReplaceElement() {
-	//! replace the entry in the reservoir
-	//! pop the minimum entry
-	reservoir_weights.pop();
-	//! now update the reservoir
-	//! 8. Let tw = Tw i , r2 = random(tw,1) and vi’s key: ki = (r2)1/wi
-	//! 9. The new threshold Tw is the new minimum key of R
-	//! we generate a random number between (min_threshold, 1)
-	double r2 = random.NextRandom(min_threshold, 1);
-	//! now we insert the new weight into the reservoir
-	reservoir_weights.push(std::make_pair(-r2, min_entry));
-	//! we update the min entry with the new min entry in the reservoir
-	SetNextEntry();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-WindowSegmentTree::WindowSegmentTree(AggregateFunction &aggregate, FunctionData *bind_info,
-                                     const LogicalType &result_type_p, ChunkCollection *input,
-                                     const ValidityMask &filter_mask_p, WindowAggregationMode mode_p)
-    : aggregate(aggregate), bind_info(bind_info), result_type(result_type_p), state(aggregate.state_size()),
-      statep(Value::POINTER((idx_t)state.data())), frame(0, 0), active(0, 1),
-      statev(Value::POINTER((idx_t)state.data())), internal_nodes(0), input_ref(input), filter_mask(filter_mask_p),
-      mode(mode_p) {
-#if STANDARD_VECTOR_SIZE < 512
-	throw NotImplementedException("Window functions are not supported for vector sizes < 512");
-#endif
-	statep.Normalify(STANDARD_VECTOR_SIZE);
-	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
-
-	if (input_ref && input_ref->ColumnCount() > 0) {
-		filter_sel.Initialize(STANDARD_VECTOR_SIZE);
-		inputs.Initialize(Allocator::DefaultAllocator(), input_ref->Types());
-		// if we have a frame-by-frame method, share the single state
-		if (aggregate.window && UseWindowAPI()) {
-			AggregateInit();
-			inputs.Reference(input_ref->GetChunk(0));
-		} else if (aggregate.combine && UseCombineAPI()) {
-			ConstructTree();
-		}
-	}
-}
-
-WindowSegmentTree::~WindowSegmentTree() {
-	if (!aggregate.destructor) {
-		// nothing to destroy
-		return;
-	}
-	// call the destructor for all the intermediate states
-	data_ptr_t address_data[STANDARD_VECTOR_SIZE];
-	Vector addresses(LogicalType::POINTER, (data_ptr_t)address_data);
-	idx_t count = 0;
-	for (idx_t i = 0; i < internal_nodes; i++) {
-		address_data[count++] = data_ptr_t(levels_flat_native.get() + i * state.size());
-		if (count == STANDARD_VECTOR_SIZE) {
-			aggregate.destructor(addresses, count);
-			count = 0;
-		}
-	}
-	if (count > 0) {
-		aggregate.destructor(addresses, count);
-	}
-
-	if (aggregate.window && UseWindowAPI()) {
-		aggregate.destructor(statev, 1);
-	}
-}
-
-void WindowSegmentTree::AggregateInit() {
-	aggregate.initialize(state.data());
-}
-
-void WindowSegmentTree::AggegateFinal(Vector &result, idx_t rid) {
-	AggregateInputData aggr_input_data(bind_info);
-	aggregate.finalize(statev, aggr_input_data, result, 1, rid);
-
-	if (aggregate.destructor) {
-		aggregate.destructor(statev, 1);
-	}
-}
-
-void WindowSegmentTree::ExtractFrame(idx_t begin, idx_t end) {
-	const auto size = end - begin;
-	if (size >= STANDARD_VECTOR_SIZE) {
-		throw InternalException("Cannot compute window aggregation: bounds are too large");
-	}
-
-	const idx_t start_in_vector = begin % STANDARD_VECTOR_SIZE;
-	const auto input_count = input_ref->ColumnCount();
-	if (start_in_vector + size <= STANDARD_VECTOR_SIZE) {
-		inputs.SetCardinality(size);
-		auto &chunk = input_ref->GetChunkForRow(begin);
-		for (idx_t i = 0; i < input_count; ++i) {
-			auto &v = inputs.data[i];
-			auto &vec = chunk.data[i];
-			v.Slice(vec, start_in_vector);
-			v.Verify(size);
-		}
-	} else {
-		inputs.Reset();
-		inputs.SetCardinality(size);
-
-		// we cannot just slice the individual vector!
-		auto &chunk_a = input_ref->GetChunkForRow(begin);
-		auto &chunk_b = input_ref->GetChunkForRow(end);
-		idx_t chunk_a_count = chunk_a.size() - start_in_vector;
-		idx_t chunk_b_count = inputs.size() - chunk_a_count;
-		for (idx_t i = 0; i < input_count; ++i) {
-			auto &v = inputs.data[i];
-			VectorOperations::Copy(chunk_a.data[i], v, chunk_a.size(), start_in_vector, 0);
-			VectorOperations::Copy(chunk_b.data[i], v, chunk_b_count, 0, chunk_a_count);
-		}
-	}
-
-	// Slice to any filtered rows
-	if (!filter_mask.AllValid()) {
-		idx_t filtered = 0;
-		for (idx_t i = begin; i < end; ++i) {
-			if (filter_mask.RowIsValid(i)) {
-				filter_sel.set_index(filtered++, i - begin);
-			}
-		}
-		if (filtered != inputs.size()) {
-			inputs.Slice(filter_sel, filtered);
-		}
-	}
-}
-
-void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end) {
-	D_ASSERT(begin <= end);
-	if (begin == end) {
-		return;
-	}
-
-	if (end - begin >= STANDARD_VECTOR_SIZE) {
-		throw InternalException("Cannot compute window aggregation: bounds are too large");
-	}
-
-	Vector s(statep, 0);
-	if (l_idx == 0) {
-		ExtractFrame(begin, end);
-		AggregateInputData aggr_input_data(bind_info);
-		aggregate.update(&inputs.data[0], aggr_input_data, input_ref->ColumnCount(), s, inputs.size());
-	} else {
-		inputs.Reset();
-		inputs.SetCardinality(end - begin);
-		// find out where the states begin
-		data_ptr_t begin_ptr = levels_flat_native.get() + state.size() * (begin + levels_flat_start[l_idx - 1]);
-		// set up a vector of pointers that point towards the set of states
-		Vector v(LogicalType::POINTER);
-		auto pdata = FlatVector::GetData<data_ptr_t>(v);
-		for (idx_t i = 0; i < inputs.size(); i++) {
-			pdata[i] = begin_ptr + i * state.size();
-		}
-		v.Verify(inputs.size());
-		AggregateInputData aggr_input_data(bind_info);
-		aggregate.combine(v, s, aggr_input_data, inputs.size());
-	}
-}
-
-void WindowSegmentTree::ConstructTree() {
-	D_ASSERT(input_ref);
-	D_ASSERT(inputs.ColumnCount() > 0);
-
-	// compute space required to store internal nodes of segment tree
-	internal_nodes = 0;
-	idx_t level_nodes = input_ref->Count();
-	do {
-		level_nodes = (level_nodes + (TREE_FANOUT - 1)) / TREE_FANOUT;
-		internal_nodes += level_nodes;
-	} while (level_nodes > 1);
-	levels_flat_native = unique_ptr<data_t[]>(new data_t[internal_nodes * state.size()]);
-	levels_flat_start.push_back(0);
-
-	idx_t levels_flat_offset = 0;
-	idx_t level_current = 0;
-	// level 0 is data itself
-	idx_t level_size;
-	// iterate over the levels of the segment tree
-	while ((level_size = (level_current == 0 ? input_ref->Count()
-	                                         : levels_flat_offset - levels_flat_start[level_current - 1])) > 1) {
-		for (idx_t pos = 0; pos < level_size; pos += TREE_FANOUT) {
-			// compute the aggregate for this entry in the segment tree
-			AggregateInit();
-			WindowSegmentValue(level_current, pos, MinValue(level_size, pos + TREE_FANOUT));
-
-			memcpy(levels_flat_native.get() + (levels_flat_offset * state.size()), state.data(), state.size());
-
-			levels_flat_offset++;
-		}
-
-		levels_flat_start.push_back(levels_flat_offset);
-		level_current++;
-	}
-
-	// Corner case: single element in the window
-	if (levels_flat_offset == 0) {
-		aggregate.initialize(levels_flat_native.get());
-	}
-}
-
-void WindowSegmentTree::Compute(Vector &result, idx_t rid, idx_t begin, idx_t end) {
-	D_ASSERT(input_ref);
-
-	// No arguments, so just count
-	if (inputs.ColumnCount() == 0) {
-		D_ASSERT(GetTypeIdSize(result_type.InternalType()) == sizeof(idx_t));
-		auto data = FlatVector::GetData<idx_t>(result);
-		// Slice to any filtered rows
-		if (!filter_mask.AllValid()) {
-			idx_t filtered = 0;
-			for (idx_t i = begin; i < end; ++i) {
-				filtered += filter_mask.RowIsValid(i);
-			}
-			data[rid] = filtered;
-		} else {
-			data[rid] = end - begin;
-		}
-		return;
-	}
-
-	// If we have a window function, use that
-	if (aggregate.window && UseWindowAPI()) {
-		// Frame boundaries
-		auto prev = frame;
-		frame = FrameBounds(begin, end);
-
-		// Extract the range
-		auto &coll = *input_ref;
-		const auto prev_active = active;
-		const FrameBounds combined(MinValue(frame.first, prev.first), MaxValue(frame.second, prev.second));
-
-		// The chunk bounds are the range that includes the begin and end - 1
-		const FrameBounds prev_chunks(coll.LocateChunk(prev_active.first), coll.LocateChunk(prev_active.second - 1));
-		const FrameBounds active_chunks(coll.LocateChunk(combined.first), coll.LocateChunk(combined.second - 1));
-
-		// Extract the range
-		if (active_chunks.first == active_chunks.second) {
-			// If all the data is in a single chunk, then just reference it
-			if (prev_chunks != active_chunks || (!prev.first && !prev.second)) {
-				inputs.Reference(coll.GetChunk(active_chunks.first));
-			}
-		} else if (active_chunks.first == prev_chunks.first && prev_chunks.first != prev_chunks.second) {
-			// If the start chunk did not change, and we are not just a reference, then extend if necessary
-			for (auto chunk_idx = prev_chunks.second + 1; chunk_idx <= active_chunks.second; ++chunk_idx) {
-				inputs.Append(coll.GetChunk(chunk_idx), true);
-			}
-		} else {
-			// If the first chunk changed, start over
-			inputs.Reset();
-			for (auto chunk_idx = active_chunks.first; chunk_idx <= active_chunks.second; ++chunk_idx) {
-				inputs.Append(coll.GetChunk(chunk_idx), true);
-			}
-		}
-
-		active = FrameBounds(active_chunks.first * STANDARD_VECTOR_SIZE,
-		                     MinValue((active_chunks.second + 1) * STANDARD_VECTOR_SIZE, coll.Count()));
-
-		AggregateInputData aggr_input_data(bind_info);
-		aggregate.window(inputs.data.data(), filter_mask, aggr_input_data, inputs.ColumnCount(), state.data(), frame,
-		                 prev, result, rid, active.first);
-		return;
-	}
-
-	AggregateInit();
-
-	// Aggregate everything at once if we can't combine states
-	if (!aggregate.combine || !UseCombineAPI()) {
-		WindowSegmentValue(0, begin, end);
-		AggegateFinal(result, rid);
-		return;
-	}
-
-	for (idx_t l_idx = 0; l_idx < levels_flat_start.size() + 1; l_idx++) {
-		idx_t parent_begin = begin / TREE_FANOUT;
-		idx_t parent_end = end / TREE_FANOUT;
-		if (parent_begin == parent_end) {
-			WindowSegmentValue(l_idx, begin, end);
-			break;
-		}
-		idx_t group_begin = parent_begin * TREE_FANOUT;
-		if (begin != group_begin) {
-			WindowSegmentValue(l_idx, begin, group_begin + TREE_FANOUT);
-			parent_begin++;
-		}
-		idx_t group_end = parent_end * TREE_FANOUT;
-		if (end != group_end) {
-			WindowSegmentValue(l_idx, group_end, end);
-		}
-		begin = parent_begin;
-		end = parent_end;
-	}
-
-	AggegateFinal(result, rid);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-struct AvgState {
-	uint64_t count;
-	T value;
-
-	void Initialize() {
-		this->count = 0;
-	}
-
-	void Combine(const AvgState<T> &other) {
-		this->count += other.count;
-		this->value += other.value;
-	}
-};
-
-struct KahanAvgState {
-	uint64_t count;
-	double value;
-	double err;
-
-	void Initialize() {
-		this->count = 0;
-		this->err = 0.0;
-	}
-
-	void Combine(const KahanAvgState &other) {
-		this->count += other.count;
-		KahanAddInternal(other.value, this->value, this->err);
-		KahanAddInternal(other.err, this->value, this->err);
-	}
-};
-
-struct AverageDecimalBindData : public FunctionData {
-	explicit AverageDecimalBindData(double scale) : scale(scale) {
-	}
-
-	double scale;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<AverageDecimalBindData>(scale);
-	};
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (AverageDecimalBindData &)other_p;
-		return scale == other.scale;
-	}
-};
-
-struct AverageSetOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->Initialize();
-	}
-	template <class STATE>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->Combine(source);
-	}
-	template <class STATE>
-	static void AddValues(STATE *state, idx_t count) {
-		state->count += count;
-	}
-};
-
-template <class T>
-static T GetAverageDivident(uint64_t count, FunctionData *bind_data) {
-	T divident = T(count);
-	if (bind_data) {
-		auto &avg_bind_data = (AverageDecimalBindData &)*bind_data;
-		divident *= avg_bind_data.scale;
-	}
-	return divident;
-}
-
-struct IntegerAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			double divident = GetAverageDivident<double>(state->count, aggr_input_data.bind_data);
-			target[idx] = double(state->value) / divident;
-		}
-	}
-};
-
-struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperation, HugeintAdd> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			long double divident = GetAverageDivident<long double>(state->count, aggr_input_data.bind_data);
-			target[idx] = Hugeint::Cast<long double>(state->value) / divident;
-		}
-	}
-};
-
-struct HugeintAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			long double divident = GetAverageDivident<long double>(state->count, aggr_input_data.bind_data);
-			target[idx] = Hugeint::Cast<long double>(state->value) / divident;
-		}
-	}
-};
-
-struct NumericAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			if (!Value::DoubleIsFinite(state->value)) {
-				throw OutOfRangeException("AVG is out of range!");
-			}
-			target[idx] = (state->value / state->count);
-		}
-	}
-};
-
-struct KahanAverageOperation : public BaseSumOperation<AverageSetOperation, KahanAdd> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			if (!Value::DoubleIsFinite(state->value)) {
-				throw OutOfRangeException("AVG is out of range!");
-			}
-			target[idx] = (state->value / state->count) + (state->err / state->count);
-		}
-	}
-};
-
-AggregateFunction GetAverageAggregate(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregate<AvgState<int64_t>, int16_t, double, IntegerAverageOperation>(
-		    LogicalType::SMALLINT, LogicalType::DOUBLE, true);
-	case PhysicalType::INT32: {
-		auto function =
-		    AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, int32_t, double, IntegerAverageOperationHugeint>(
-		        LogicalType::INTEGER, LogicalType::DOUBLE, true);
-		return function;
-	}
-	case PhysicalType::INT64: {
-		auto function =
-		    AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, int64_t, double, IntegerAverageOperationHugeint>(
-		        LogicalType::BIGINT, LogicalType::DOUBLE, true);
-		return function;
-	}
-	case PhysicalType::INT128:
-		return AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, hugeint_t, double, HugeintAverageOperation>(
-		    LogicalType::HUGEINT, LogicalType::DOUBLE, true);
-	default:
-		throw InternalException("Unimplemented average aggregate");
-	}
-}
-
-unique_ptr<FunctionData> BindDecimalAvg(ClientContext &context, AggregateFunction &function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	function = GetAverageAggregate(decimal_type.InternalType());
-	function.name = "avg";
-	function.arguments[0] = decimal_type;
-	function.return_type = LogicalType::DOUBLE;
-	return make_unique<AverageDecimalBindData>(
-	    Hugeint::Cast<double>(Hugeint::POWERS_OF_TEN[DecimalType::GetScale(decimal_type)]));
-}
-
-void AvgFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet avg("avg");
-	avg.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, true, nullptr, BindDecimalAvg));
-	avg.AddFunction(GetAverageAggregate(PhysicalType::INT16));
-	avg.AddFunction(GetAverageAggregate(PhysicalType::INT32));
-	avg.AddFunction(GetAverageAggregate(PhysicalType::INT64));
-	avg.AddFunction(GetAverageAggregate(PhysicalType::INT128));
-	avg.AddFunction(AggregateFunction::UnaryAggregate<AvgState<double>, double, double, NumericAverageOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
-	set.AddFunction(avg);
-
-	avg.name = "mean";
-	set.AddFunction(avg);
-
-	AggregateFunctionSet favg("favg");
-	favg.AddFunction(AggregateFunction::UnaryAggregate<KahanAvgState, double, double, KahanAverageOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
-	set.AddFunction(favg);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-void Corr::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet corr("corr");
-	corr.AddFunction(AggregateFunction::BinaryAggregate<CorrState, double, double, double, CorrOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(corr);
-}
-} // namespace duckdb
-
-
-
-
-
-
-#include <cmath>
-
-namespace duckdb {
-
-void CovarPopFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet covar_pop("covar_pop");
-	covar_pop.AddFunction(AggregateFunction::BinaryAggregate<CovarState, double, double, double, CovarPopOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(covar_pop);
-}
-
-void CovarSampFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet covar_samp("covar_samp");
-	covar_samp.AddFunction(AggregateFunction::BinaryAggregate<CovarState, double, double, double, CovarSampOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(covar_samp);
-}
-
-} // namespace duckdb
-
-
-
-
-#include <cmath>
-
-namespace duckdb {
-
-void StdDevSampFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet stddev_samp("stddev_samp");
-	stddev_samp.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, STDDevSampOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(stddev_samp);
-	AggregateFunctionSet stddev("stddev");
-	stddev.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, STDDevSampOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(stddev);
-}
-
-void StdDevPopFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet stddev_pop("stddev_pop");
-	stddev_pop.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, STDDevPopOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(stddev_pop);
-}
-
-void VarPopFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet var_pop("var_pop");
-	var_pop.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, VarPopOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(var_pop);
-}
-
-void VarSampFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet var_samp("var_samp");
-	var_samp.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, VarSampOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(var_samp);
-}
-void VarianceFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet var_samp("variance");
-	var_samp.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, VarSampOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(var_samp);
-}
-
-void StandardErrorOfTheMeanFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet sem("sem");
-	sem.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, StandardErrorOfTheMeanOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(sem);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterAlgebraicAggregates() {
-	Register<AvgFun>();
-
-	Register<CovarSampFun>();
-	Register<CovarPopFun>();
-
-	Register<StdDevSampFun>();
-	Register<StdDevPopFun>();
-	Register<VarPopFun>();
-	Register<VarSampFun>();
-	Register<VarianceFun>();
-	Register<StandardErrorOfTheMeanFun>();
-	Register<Corr>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct ApproxDistinctCountState {
-	HyperLogLog *log;
-};
-
-struct ApproxCountDistinctFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->log = nullptr;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.log) {
-			return;
-		}
-		if (!target->log) {
-			target->log = new HyperLogLog();
-		}
-		D_ASSERT(target->log);
-		D_ASSERT(source.log);
-		auto new_log = target->log->MergePointer(*source.log);
-		delete target->log;
-		target->log = new_log;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->log) {
-			target[idx] = state->log->Count();
-		} else {
-			target[idx] = 0;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->log) {
-			delete state->log;
-		}
-	}
-};
-
-static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count,
-                                                    data_ptr_t state, idx_t count) {
-	D_ASSERT(input_count == 1);
-
-	auto agg_state = (ApproxDistinctCountState *)state;
-	if (!agg_state->log) {
-		agg_state->log = new HyperLogLog();
-	}
-
-	VectorData vdata;
-	inputs[0].Orrify(count, vdata);
-
-	uint64_t indices[STANDARD_VECTOR_SIZE];
-	uint8_t counts[STANDARD_VECTOR_SIZE];
-
-	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
-	agg_state->log->AddToLog(vdata, count, indices, counts);
-}
-
-static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count,
-                                              Vector &state_vector, idx_t count) {
-	D_ASSERT(input_count == 1);
-
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
-	auto states = (ApproxDistinctCountState **)sdata.data;
-
-	for (idx_t i = 0; i < count; i++) {
-		auto agg_state = states[sdata.sel->get_index(i)];
-		if (!agg_state->log) {
-			agg_state->log = new HyperLogLog();
-		}
-	}
-
-	VectorData vdata;
-	inputs[0].Orrify(count, vdata);
-
-	uint64_t indices[STANDARD_VECTOR_SIZE];
-	uint8_t counts[STANDARD_VECTOR_SIZE];
-
-	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
-	HyperLogLog::AddToLogs(vdata, count, indices, counts, (HyperLogLog ***)states, sdata.sel);
-}
-
-AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type) {
-	return AggregateFunction(
-	    {input_type}, LogicalTypeId::BIGINT, AggregateFunction::StateSize<ApproxDistinctCountState>,
-	    AggregateFunction::StateInitialize<ApproxDistinctCountState, ApproxCountDistinctFunction>,
-	    ApproxCountDistinctUpdateFunction,
-	    AggregateFunction::StateCombine<ApproxDistinctCountState, ApproxCountDistinctFunction>,
-	    AggregateFunction::StateFinalize<ApproxDistinctCountState, int64_t, ApproxCountDistinctFunction>,
-	    ApproxCountDistinctSimpleUpdateFunction, nullptr,
-	    AggregateFunction::StateDestroy<ApproxDistinctCountState, ApproxCountDistinctFunction>);
-}
-
-void ApproxCountDistinctFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet approx_count("approx_count_distinct");
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UTINYINT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::USMALLINT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UINTEGER));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UBIGINT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TINYINT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::SMALLINT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::BIGINT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::HUGEINT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::FLOAT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::DOUBLE));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::VARCHAR));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP_TZ));
-	set.AddFunction(approx_count);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T, class T2>
-struct ArgMinMaxState {
-	T arg;
-	T2 value;
-	bool is_initialized;
-};
-
-template <class T>
-static void ArgMinMaxDestroyValue(T value) {
-}
-
-template <>
-void ArgMinMaxDestroyValue(string_t value) {
-	if (!value.IsInlined()) {
-		delete[] value.GetDataUnsafe();
-	}
-}
-
-template <class T>
-static void ArgMinMaxAssignValue(T &target, T new_value, bool is_initialized) {
-	target = new_value;
-}
-
-template <>
-void ArgMinMaxAssignValue(string_t &target, string_t new_value, bool is_initialized) {
-	if (is_initialized) {
-		ArgMinMaxDestroyValue(target);
-	}
-	if (new_value.IsInlined()) {
-		target = new_value;
-	} else {
-		// non-inlined string, need to allocate space for it
-		auto len = new_value.GetSize();
-		auto ptr = new char[len];
-		memcpy(ptr, new_value.GetDataUnsafe(), len);
-
-		target = string_t(ptr, len);
-	}
-}
-
-template <class COMPARATOR>
-struct ArgMinMaxBase {
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->is_initialized) {
-			ArgMinMaxDestroyValue(state->arg);
-			ArgMinMaxDestroyValue(state->value);
-		}
-	}
-
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->is_initialized = false;
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		if (!state->is_initialized) {
-			ArgMinMaxAssignValue<A_TYPE>(state->arg, x_data[xidx], false);
-			ArgMinMaxAssignValue<B_TYPE>(state->value, y_data[yidx], false);
-			state->is_initialized = true;
-		} else {
-			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x_data[xidx], y_data[yidx]);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE>
-	static void Execute(STATE *state, A_TYPE x_data, B_TYPE y_data) {
-		if (COMPARATOR::Operation(y_data, state->value)) {
-			ArgMinMaxAssignValue<A_TYPE>(state->arg, x_data, true);
-			ArgMinMaxAssignValue<B_TYPE>(state->value, y_data, true);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.is_initialized) {
-			return;
-		}
-		if (!target->is_initialized || COMPARATOR::Operation(source.value, target->value)) {
-			ArgMinMaxAssignValue(target->arg, source.arg, target->is_initialized);
-			ArgMinMaxAssignValue(target->value, source.value, target->is_initialized);
-			target->is_initialized = true;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-template <class COMPARATOR>
-struct StringArgMinMax : public ArgMinMaxBase<COMPARATOR> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_initialized) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = StringVector::AddStringOrBlob(result, state->arg);
-		}
-	}
-};
-
-template <class COMPARATOR>
-struct NumericArgMinMax : public ArgMinMaxBase<COMPARATOR> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_initialized) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->arg;
-		}
-	}
-};
-
-using NumericArgMinOperation = NumericArgMinMax<LessThan>;
-using NumericArgMaxOperation = NumericArgMinMax<GreaterThan>;
-using StringArgMinOperation = StringArgMinMax<LessThan>;
-using StringArgMaxOperation = StringArgMinMax<GreaterThan>;
-
-template <class OP, class T, class T2>
-AggregateFunction GetArgMinMaxFunctionInternal(const LogicalType &arg_2, const LogicalType &arg) {
-	auto function = AggregateFunction::BinaryAggregate<ArgMinMaxState<T, T2>, T, T2, T, OP>(arg, arg_2, arg);
-	if (arg.InternalType() == PhysicalType::VARCHAR || arg_2.InternalType() == PhysicalType::VARCHAR) {
-		function.destructor = AggregateFunction::StateDestroy<ArgMinMaxState<T, T2>, OP>;
-	}
-	return function;
-}
-template <class OP, class T>
-AggregateFunction GetArgMinMaxFunctionArg2(const LogicalType &arg_2, const LogicalType &arg) {
-	switch (arg_2.InternalType()) {
-	case PhysicalType::INT32:
-		return GetArgMinMaxFunctionInternal<OP, T, int32_t>(arg_2, arg);
-	case PhysicalType::INT64:
-		return GetArgMinMaxFunctionInternal<OP, T, int64_t>(arg_2, arg);
-	case PhysicalType::DOUBLE:
-		return GetArgMinMaxFunctionInternal<OP, T, double>(arg_2, arg);
-	case PhysicalType::VARCHAR:
-		return GetArgMinMaxFunctionInternal<OP, T, string_t>(arg_2, arg);
-	default:
-		throw InternalException("Unimplemented arg_min/arg_max aggregate");
-	}
-}
-
-template <class OP, class T>
-void AddArgMinMaxFunctionArg2(AggregateFunctionSet &fun, const LogicalType &arg) {
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::INTEGER, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::BIGINT, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::DOUBLE, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::VARCHAR, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::DATE, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::TIMESTAMP, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::TIMESTAMP_TZ, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::BLOB, arg));
-}
-
-template <class OP, class STRING_OP>
-static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
-	AddArgMinMaxFunctionArg2<OP, int32_t>(fun, LogicalType::INTEGER);
-	AddArgMinMaxFunctionArg2<OP, int64_t>(fun, LogicalType::BIGINT);
-	AddArgMinMaxFunctionArg2<OP, double>(fun, LogicalType::DOUBLE);
-	AddArgMinMaxFunctionArg2<STRING_OP, string_t>(fun, LogicalType::VARCHAR);
-	AddArgMinMaxFunctionArg2<OP, date_t>(fun, LogicalType::DATE);
-	AddArgMinMaxFunctionArg2<OP, timestamp_t>(fun, LogicalType::TIMESTAMP);
-	AddArgMinMaxFunctionArg2<OP, timestamp_t>(fun, LogicalType::TIMESTAMP_TZ);
-	AddArgMinMaxFunctionArg2<STRING_OP, string_t>(fun, LogicalType::BLOB);
-}
-
-void ArgMinFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("argmin");
-	AddArgMinMaxFunctions<NumericArgMinOperation, StringArgMinOperation>(fun);
-	set.AddFunction(fun);
-
-	//! Add min_by alias
-	fun.name = "min_by";
-	set.AddFunction(fun);
-
-	//! Add arg_min alias
-	fun.name = "arg_min";
-	set.AddFunction(fun);
-}
-
-void ArgMaxFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("argmax");
-	AddArgMinMaxFunctions<NumericArgMaxOperation, StringArgMaxOperation>(fun);
-	set.AddFunction(fun);
-
-	//! Add max_by alias
-	fun.name = "max_by";
-	set.AddFunction(fun);
-
-	//! Add arg_max alias
-	fun.name = "arg_max";
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-struct BitState {
-	bool is_set;
-	T value;
-};
-
-template <class OP>
-static AggregateFunction GetBitfieldUnaryAggregate(LogicalType type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint8_t>, int8_t, int8_t, OP>(type, type);
-	case LogicalTypeId::SMALLINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint16_t>, int16_t, int16_t, OP>(type, type);
-	case LogicalTypeId::INTEGER:
-		return AggregateFunction::UnaryAggregate<BitState<uint32_t>, int32_t, int32_t, OP>(type, type);
-	case LogicalTypeId::BIGINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint64_t>, int64_t, int64_t, OP>(type, type);
-	case LogicalTypeId::HUGEINT:
-		return AggregateFunction::UnaryAggregate<BitState<hugeint_t>, hugeint_t, hugeint_t, OP>(type, type);
-	case LogicalTypeId::UTINYINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint8_t>, uint8_t, uint8_t, OP>(type, type);
-	case LogicalTypeId::USMALLINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint16_t>, uint16_t, uint16_t, OP>(type, type);
-	case LogicalTypeId::UINTEGER:
-		return AggregateFunction::UnaryAggregate<BitState<uint32_t>, uint32_t, uint32_t, OP>(type, type);
-	case LogicalTypeId::UBIGINT:
-		return AggregateFunction::UnaryAggregate<BitState<uint64_t>, uint64_t, uint64_t, OP>(type, type);
-	default:
-		throw InternalException("Unimplemented bitfield type for unary aggregate");
-	}
-}
-
-struct BitAndOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		//  If there are no matching rows, BIT_AND() returns a null value.
-		state->is_set = false;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			state->is_set = true;
-			state->value = input[idx];
-		} else {
-			state->value &= input[idx];
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		//  count is irrelevant
-		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->value;
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.is_set) {
-			// source is NULL, nothing to do.
-			return;
-		}
-		if (!target->is_set) {
-			// target is NULL, use source value directly.
-			*target = source;
-		} else {
-			target->value &= source.value;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-void BitAndFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet bit_and("bit_and");
-	for (auto &type : LogicalType::Integral()) {
-		bit_and.AddFunction(GetBitfieldUnaryAggregate<BitAndOperation>(type));
-	}
-	set.AddFunction(bit_and);
-}
-
-struct BitOrOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		//  If there are no matching rows, BIT_OR() returns a null value.
-		state->is_set = false;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			state->is_set = true;
-			state->value = input[idx];
-		} else {
-			state->value |= input[idx];
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		//  count is irrelevant
-		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->value;
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.is_set) {
-			// source is NULL, nothing to do.
-			return;
-		}
-		if (!target->is_set) {
-			// target is NULL, use source value directly.
-			*target = source;
-		} else {
-			target->value |= source.value;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-void BitOrFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet bit_or("bit_or");
-	for (auto &type : LogicalType::Integral()) {
-		bit_or.AddFunction(GetBitfieldUnaryAggregate<BitOrOperation>(type));
-	}
-	set.AddFunction(bit_or);
-}
-
-struct BitXorOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		//  If there are no matching rows, BIT_XOR() returns a null value.
-		state->is_set = false;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			state->is_set = true;
-			state->value = input[idx];
-		} else {
-			state->value ^= input[idx];
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		//  count is irrelevant
-		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->value;
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.is_set) {
-			// source is NULL, nothing to do.
-			return;
-		}
-		if (!target->is_set) {
-			// target is NULL, use source value directly.
-			*target = source;
-		} else {
-			target->value ^= source.value;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-void BitXorFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet bit_xor("bit_xor");
-	for (auto &type : LogicalType::Integral()) {
-		bit_xor.AddFunction(GetBitfieldUnaryAggregate<BitXorOperation>(type));
-	}
-	set.AddFunction(bit_xor);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct BoolState {
-	bool empty;
-	bool val;
-};
-
-struct BoolAndFunFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->val = true;
-		state->empty = true;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->val = target->val && source.val;
-		target->empty = target->empty && source.empty;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->empty) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		target[idx] = state->val;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		state->empty = false;
-		state->val = input[idx] && state->val;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct BoolOrFunFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->val = false;
-		state->empty = true;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->val = target->val || source.val;
-		target->empty = target->empty && source.empty;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->empty) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		target[idx] = state->val;
-	}
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		state->empty = false;
-		state->val = input[idx] || state->val;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction BoolOrFun::GetFunction() {
-	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolOrFunFunction>(
-	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
-	fun.name = "bool_or";
-	return fun;
-}
-
-AggregateFunction BoolAndFun::GetFunction() {
-	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolAndFunFunction>(
-	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
-	fun.name = "bool_and";
-	return fun;
-}
-
-void BoolOrFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunction bool_or_function = BoolOrFun::GetFunction();
-	AggregateFunctionSet bool_or("bool_or");
-	bool_or.AddFunction(bool_or_function);
-	set.AddFunction(bool_or);
-}
-
-void BoolAndFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunction bool_and_function = BoolAndFun::GetFunction();
-	AggregateFunctionSet bool_and("bool_and");
-	bool_and.AddFunction(bool_and_function);
-	set.AddFunction(bool_and);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct BaseCountFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		*state = 0;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		*target += source;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		target[idx] = *state;
-	}
-};
-
-struct CountStarFunction : public BaseCountFunction {
-	template <class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, idx_t idx) {
-		*state += 1;
-	}
-
-	template <class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, idx_t count) {
-		*state += count;
-	}
-};
-
-struct CountFunction : public BaseCountFunction {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		*state += 1;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		*state += count;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction CountFun::GetFunction() {
-	auto fun = AggregateFunction::UnaryAggregate<int64_t, int64_t, int64_t, CountFunction>(
-	    LogicalType(LogicalTypeId::ANY), LogicalType::BIGINT);
-	fun.name = "count";
-	return fun;
-}
-
-AggregateFunction CountStarFun::GetFunction() {
-	auto fun = AggregateFunction::NullaryAggregate<int64_t, int64_t, CountStarFunction>(LogicalType::BIGINT);
-	fun.name = "count_star";
-	return fun;
-}
-
-unique_ptr<BaseStatistics> CountPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                               FunctionData *bind_data, vector<unique_ptr<BaseStatistics>> &child_stats,
-                                               NodeStatistics *node_stats) {
-	if (!expr.distinct && child_stats[0] && !child_stats[0]->CanHaveNull()) {
-		// count on a column without null values: use count star
-		expr.function = CountStarFun::GetFunction();
-		expr.function.name = "count_star";
-		expr.children.clear();
-	}
-	return nullptr;
-}
-
-void CountFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunction count_function = CountFun::GetFunction();
-	count_function.statistics = CountPropagateStats;
-	AggregateFunctionSet count("count");
-	count.AddFunction(count_function);
-	// the count function can also be called without arguments
-	count_function.arguments.clear();
-	count_function.statistics = nullptr;
-	count.AddFunction(count_function);
-	set.AddFunction(count);
-}
-
-void CountStarFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet count("count_star");
-	count.AddFunction(CountStarFun::GetFunction());
-	set.AddFunction(count);
-}
-
-} // namespace duckdb
-
-
-
-
-
-#include <unordered_map>
-
-namespace duckdb {
-
-template <class T>
-struct EntropyState {
-	using DistinctMap = unordered_map<T, idx_t>;
-
-	idx_t count;
-	DistinctMap *distinct;
-
-	EntropyState &operator=(const EntropyState &other) = delete;
-
-	EntropyState &Assign(const EntropyState &other) {
-		D_ASSERT(!distinct);
-		distinct = new DistinctMap(*other.distinct);
-		count = other.count;
-		return *this;
-	}
-};
-
-struct EntropyFunctionBase {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->distinct = nullptr;
-		state->count = 0;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.distinct) {
-			return;
-		}
-		if (!target->distinct) {
-			target->Assign(source);
-			return;
-		}
-		for (auto &val : *source.distinct) {
-			auto value = val.first;
-			(*target->distinct)[value] += val.second;
-		}
-		target->count += source.count;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		double count = state->count;
-		if (state->distinct) {
-			double entropy = 0;
-			for (auto &val : *state->distinct) {
-				entropy += (val.second / count) * log2(count / val.second);
-			}
-			target[idx] = entropy;
-		} else {
-			target[idx] = 0;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->distinct) {
-			delete state->distinct;
-		}
-	}
-};
-
-struct EntropyFunction : EntropyFunctionBase {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->distinct) {
-			state->distinct = new unordered_map<INPUT_TYPE, idx_t>();
-		}
-		(*state->distinct)[input[idx]]++;
-		state->count++;
-	}
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-};
-
-struct EntropyFunctionString : EntropyFunctionBase {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->distinct) {
-			state->distinct = new unordered_map<string, idx_t>();
-		}
-		auto value = input[idx].GetString();
-		(*state->distinct)[value]++;
-		state->count++;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-};
-
-template <typename INPUT_TYPE, typename RESULT_TYPE>
-AggregateFunction GetEntropyFunction(const LogicalType &input_type, const LogicalType &result_type) {
-	return AggregateFunction::UnaryAggregateDestructor<EntropyState<INPUT_TYPE>, INPUT_TYPE, RESULT_TYPE,
-	                                                   EntropyFunction>(input_type, result_type);
-}
-
-AggregateFunction GetEntropyFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::UINT16:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<uint16_t>, uint16_t, double, EntropyFunction>(
-		    LogicalType::USMALLINT, LogicalType::DOUBLE);
-	case PhysicalType::UINT32:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<uint32_t>, uint32_t, double, EntropyFunction>(
-		    LogicalType::UINTEGER, LogicalType::DOUBLE);
-	case PhysicalType::UINT64:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<uint64_t>, uint64_t, double, EntropyFunction>(
-		    LogicalType::UBIGINT, LogicalType::DOUBLE);
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<int16_t>, int16_t, double, EntropyFunction>(
-		    LogicalType::SMALLINT, LogicalType::DOUBLE);
-	case PhysicalType::INT32:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<int32_t>, int32_t, double, EntropyFunction>(
-		    LogicalType::INTEGER, LogicalType::DOUBLE);
-	case PhysicalType::INT64:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<int64_t>, int64_t, double, EntropyFunction>(
-		    LogicalType::BIGINT, LogicalType::DOUBLE);
-	case PhysicalType::FLOAT:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<float>, float, double, EntropyFunction>(
-		    LogicalType::FLOAT, LogicalType::DOUBLE);
-	case PhysicalType::DOUBLE:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<double>, double, double, EntropyFunction>(
-		    LogicalType::DOUBLE, LogicalType::DOUBLE);
-	case PhysicalType::VARCHAR:
-		return AggregateFunction::UnaryAggregateDestructor<EntropyState<string>, string_t, double,
-		                                                   EntropyFunctionString>(LogicalType::VARCHAR,
-		                                                                          LogicalType::DOUBLE);
-
-	default:
-		throw InternalException("Unimplemented approximate_count aggregate");
-	}
-}
-
-void EntropyFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet entropy("entropy");
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::UINT16));
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::UINT32));
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::UINT64));
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::FLOAT));
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::INT16));
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::INT32));
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::INT64));
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::DOUBLE));
-	entropy.AddFunction(GetEntropyFunction(PhysicalType::VARCHAR));
-	entropy.AddFunction(GetEntropyFunction<int64_t, double>(LogicalType::TIMESTAMP, LogicalType::DOUBLE));
-	entropy.AddFunction(GetEntropyFunction<int64_t, double>(LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE));
-	set.AddFunction(entropy);
-}
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-4.cpp b/velox/external/duckdb/duckdb-4.cpp
deleted file mode 100644
index 7d4819d47d8f4..0000000000000
--- a/velox/external/duckdb/duckdb-4.cpp
+++ /dev/null
@@ -1,16728 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-struct FirstState {
-	T value;
-	bool is_set;
-	bool is_null;
-};
-
-struct FirstFunctionBase {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->is_set = false;
-		state->is_null = false;
-	}
-
-	static bool IgnoreNull() {
-		return false;
-	}
-};
-
-template <bool LAST>
-struct FirstFunction : public FirstFunctionBase {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (LAST || !state->is_set) {
-			state->is_set = true;
-			if (!mask.RowIsValid(idx)) {
-				state->is_null = true;
-			} else {
-				state->is_null = false;
-				state->value = input[idx];
-			}
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!target->is_set) {
-			*target = source;
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set || state->is_null) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->value;
-		}
-	}
-};
-
-template <bool LAST>
-struct FirstFunctionString : public FirstFunctionBase {
-	template <class STATE>
-	static void SetValue(STATE *state, string_t value, bool is_null) {
-		state->is_set = true;
-		if (is_null) {
-			state->is_null = true;
-		} else {
-			if (value.IsInlined()) {
-				state->value = value;
-			} else {
-				// non-inlined string, need to allocate space for it
-				auto len = value.GetSize();
-				auto ptr = new char[len];
-				memcpy(ptr, value.GetDataUnsafe(), len);
-
-				state->value = string_t(ptr, len);
-			}
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (LAST || !state->is_set) {
-			SetValue(state, input[idx], !mask.RowIsValid(idx));
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.is_set && (LAST || !target->is_set)) {
-			SetValue(target, source.value, source.is_null);
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set || state->is_null) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = StringVector::AddStringOrBlob(result, state->value);
-		}
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->is_set && !state->is_null && !state->value.IsInlined()) {
-			delete[] state->value.GetDataUnsafe();
-		}
-	}
-};
-
-struct FirstStateVector {
-	Vector *value;
-};
-
-template <bool LAST>
-struct FirstVectorFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->value = nullptr;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->value) {
-			delete state->value;
-		}
-	}
-	static bool IgnoreNull() {
-		return false;
-	}
-
-	template <class STATE>
-	static void SetValue(STATE *state, Vector &input, const idx_t idx) {
-		if (!state->value) {
-			state->value = new Vector(input.GetType());
-			state->value->SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-		sel_t selv = idx;
-		SelectionVector sel(&selv);
-		VectorOperations::Copy(input, *state->value, sel, 1, 0, 0);
-	}
-
-	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
-		auto &input = inputs[0];
-		VectorData sdata;
-		state_vector.Orrify(count, sdata);
-
-		auto states = (FirstStateVector **)sdata.data;
-		for (idx_t i = 0; i < count; i++) {
-			auto state = states[sdata.sel->get_index(i)];
-			if (LAST || !state->value) {
-				SetValue(state, input, i);
-			}
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.value && (LAST || !target->value)) {
-			SetValue(target, *source.value, 0);
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->value) {
-			// we need to use FlatVector::SetNull here
-			// since for STRUCT columns only setting the validity mask of the struct is incorrect
-			// as for a struct column, we need to also set ALL child columns to NULL
-			if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				FlatVector::SetNull(result, idx, true);
-			}
-		} else {
-			VectorOperations::Copy(*state->value, result, 1, 0, idx);
-		}
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function.arguments[0] = arguments[0]->return_type;
-		function.return_type = arguments[0]->return_type;
-		return nullptr;
-	}
-};
-
-template <class T, bool LAST>
-static AggregateFunction GetFirstAggregateTemplated(LogicalType type) {
-	auto agg = AggregateFunction::UnaryAggregate<FirstState<T>, T, T, FirstFunction<LAST>>(type, type);
-	return agg;
-}
-
-template <bool LAST>
-static AggregateFunction GetFirstFunction(const LogicalType &type);
-
-template <bool LAST>
-AggregateFunction GetDecimalFirstFunction(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
-	switch (type.InternalType()) {
-	case PhysicalType::INT16:
-		return GetFirstFunction<LAST>(LogicalType::SMALLINT);
-	case PhysicalType::INT32:
-		return GetFirstFunction<LAST>(LogicalType::INTEGER);
-	case PhysicalType::INT64:
-		return GetFirstFunction<LAST>(LogicalType::BIGINT);
-	default:
-		return GetFirstFunction<LAST>(LogicalType::HUGEINT);
-	}
-}
-
-template <bool LAST>
-static AggregateFunction GetFirstFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return GetFirstAggregateTemplated<int8_t, LAST>(type);
-	case LogicalTypeId::TINYINT:
-		return GetFirstAggregateTemplated<int8_t, LAST>(type);
-	case LogicalTypeId::SMALLINT:
-		return GetFirstAggregateTemplated<int16_t, LAST>(type);
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::DATE:
-		return GetFirstAggregateTemplated<int32_t, LAST>(type);
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return GetFirstAggregateTemplated<int64_t, LAST>(type);
-	case LogicalTypeId::UTINYINT:
-		return GetFirstAggregateTemplated<uint8_t, LAST>(type);
-	case LogicalTypeId::USMALLINT:
-		return GetFirstAggregateTemplated<uint16_t, LAST>(type);
-	case LogicalTypeId::UINTEGER:
-		return GetFirstAggregateTemplated<uint32_t, LAST>(type);
-	case LogicalTypeId::UBIGINT:
-		return GetFirstAggregateTemplated<uint64_t, LAST>(type);
-	case LogicalTypeId::HUGEINT:
-		return GetFirstAggregateTemplated<hugeint_t, LAST>(type);
-	case LogicalTypeId::FLOAT:
-		return GetFirstAggregateTemplated<float, LAST>(type);
-	case LogicalTypeId::DOUBLE:
-		return GetFirstAggregateTemplated<double, LAST>(type);
-	case LogicalTypeId::INTERVAL:
-		return GetFirstAggregateTemplated<interval_t, LAST>(type);
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BLOB: {
-		auto agg = AggregateFunction::UnaryAggregateDestructor<FirstState<string_t>, string_t, string_t,
-		                                                       FirstFunctionString<LAST>>(type, type);
-		return agg;
-	}
-	case LogicalTypeId::DECIMAL: {
-		type.Verify();
-		AggregateFunction function = GetDecimalFirstFunction<LAST>(type);
-		function.arguments[0] = type;
-		function.return_type = type;
-		return function;
-	}
-	default: {
-		using OP = FirstVectorFunction<LAST>;
-		return AggregateFunction({type}, type, AggregateFunction::StateSize<FirstStateVector>,
-		                         AggregateFunction::StateInitialize<FirstStateVector, OP>, OP::Update,
-		                         AggregateFunction::StateCombine<FirstStateVector, OP>,
-		                         AggregateFunction::StateFinalize<FirstStateVector, void, OP>, nullptr, OP::Bind,
-		                         AggregateFunction::StateDestroy<FirstStateVector, OP>, nullptr, nullptr);
-	}
-	}
-}
-
-AggregateFunction FirstFun::GetFunction(const LogicalType &type) {
-	auto fun = GetFirstFunction<false>(type);
-	fun.name = "first";
-	return fun;
-}
-
-template <bool LAST>
-unique_ptr<FunctionData> BindDecimalFirst(ClientContext &context, AggregateFunction &function,
-                                          vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	function = GetFirstFunction<LAST>(decimal_type);
-	function.name = "first";
-	function.return_type = decimal_type;
-	return nullptr;
-}
-
-void FirstFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet first("first");
-	AggregateFunctionSet last("last");
-	for (auto &type : LogicalType::AllTypes()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			first.AddFunction(AggregateFunction({type}, type, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-			                                    BindDecimalFirst<false>, nullptr, nullptr, nullptr));
-			last.AddFunction(AggregateFunction({type}, type, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-			                                   BindDecimalFirst<true>, nullptr, nullptr, nullptr));
-		} else {
-			first.AddFunction(GetFirstFunction<false>(type));
-			last.AddFunction(GetFirstFunction<true>(type));
-		}
-	}
-	set.AddFunction(first);
-	first.name = "arbitrary";
-	set.AddFunction(first);
-
-	set.AddFunction(last);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-struct KurtosisState {
-	idx_t n;
-	double sum;
-	double sum_sqr;
-	double sum_cub;
-	double sum_four;
-};
-
-struct KurtosisOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->n = 0;
-		state->sum = state->sum_sqr = state->sum_cub = state->sum_four = 0.0;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
-		state->n++;
-		state->sum += data[idx];
-		state->sum_sqr += pow(data[idx], 2);
-		state->sum_cub += pow(data[idx], 3);
-		state->sum_four += pow(data[idx], 4);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.n == 0) {
-			return;
-		}
-		target->n += source.n;
-		target->sum += source.sum;
-		target->sum_sqr += source.sum_sqr;
-		target->sum_cub += source.sum_cub;
-		target->sum_four += source.sum_four;
-	}
-
-	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, TARGET_TYPE *target, ValidityMask &mask,
-	                     idx_t idx) {
-		auto n = (double)state->n;
-		if (n <= 3) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		double temp = 1 / n;
-		//! This is necessary due to linux 32 bits
-		long double temp_aux = 1 / n;
-		if (state->sum_sqr - state->sum * state->sum * temp == 0 ||
-		    state->sum_sqr - state->sum * state->sum * temp_aux == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		double m4 =
-		    temp * (state->sum_four - 4 * state->sum_cub * state->sum * temp +
-		            6 * state->sum_sqr * state->sum * state->sum * temp * temp - 3 * pow(state->sum, 4) * pow(temp, 3));
-
-		double m2 = temp * (state->sum_sqr - state->sum * state->sum * temp);
-		if (((m2 * m2) - 3 * (n - 1)) == 0 || ((n - 2) * (n - 3)) == 0) { // LCOV_EXCL_START
-			mask.SetInvalid(idx);
-		} // LCOV_EXCL_STOP
-		target[idx] = (n - 1) * ((n + 1) * m4 / (m2 * m2) - 3 * (n - 1)) / ((n - 2) * (n - 3));
-		if (!Value::DoubleIsFinite(target[idx])) {
-			throw OutOfRangeException("Kurtosis is out of range!");
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-void KurtosisFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet function_set("kurtosis");
-	function_set.AddFunction(AggregateFunction::UnaryAggregate<KurtosisState, double, double, KurtosisOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(function_set);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-struct MinMaxState {
-	T value;
-	bool isset;
-};
-
-template <class OP>
-static AggregateFunction GetUnaryAggregate(LogicalType type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int8_t>, int8_t, int8_t, OP>(type, type);
-	case LogicalTypeId::TINYINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int8_t>, int8_t, int8_t, OP>(type, type);
-	case LogicalTypeId::SMALLINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int16_t>, int16_t, int16_t, OP>(type, type);
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::INTEGER:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int32_t>, int32_t, int32_t, OP>(type, type);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIME_TZ:
-	case LogicalTypeId::BIGINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int64_t>, int64_t, int64_t, OP>(type, type, true);
-	case LogicalTypeId::UTINYINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint8_t>, uint8_t, uint8_t, OP>(type, type, true);
-	case LogicalTypeId::USMALLINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint16_t>, uint16_t, uint16_t, OP>(type, type, true);
-	case LogicalTypeId::UINTEGER:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint32_t>, uint32_t, uint32_t, OP>(type, type, true);
-	case LogicalTypeId::UBIGINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint64_t>, uint64_t, uint64_t, OP>(type, type, true);
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UUID:
-		return AggregateFunction::UnaryAggregate<MinMaxState<hugeint_t>, hugeint_t, hugeint_t, OP>(type, type, true);
-	case LogicalTypeId::FLOAT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<float>, float, float, OP>(type, type, true);
-	case LogicalTypeId::DOUBLE:
-		return AggregateFunction::UnaryAggregate<MinMaxState<double>, double, double, OP>(type, type, true);
-	case LogicalTypeId::INTERVAL:
-		return AggregateFunction::UnaryAggregate<MinMaxState<interval_t>, interval_t, interval_t, OP>(type, type, true);
-	default:
-		throw InternalException("Unimplemented type for min/max aggregate");
-	}
-}
-
-struct MinMaxBase {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->isset = false;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		D_ASSERT(mask.RowIsValid(0));
-		if (!state->isset) {
-			OP::template Assign<INPUT_TYPE, STATE>(state, input[0]);
-			state->isset = true;
-		} else {
-			OP::template Execute<INPUT_TYPE, STATE>(state, input[0]);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->isset) {
-			OP::template Assign<INPUT_TYPE, STATE>(state, input[idx]);
-			state->isset = true;
-		} else {
-			OP::template Execute<INPUT_TYPE, STATE>(state, input[idx]);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct NumericMinMaxBase : public MinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE *state, INPUT_TYPE input) {
-		state->value = input;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		mask.Set(idx, state->isset);
-		target[idx] = state->value;
-	}
-};
-
-struct MinOperation : public NumericMinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		if (LessThan::Operation<INPUT_TYPE>(input, state->value)) {
-			state->value = input;
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.isset) {
-			// source is NULL, nothing to do
-			return;
-		}
-		if (!target->isset) {
-			// target is NULL, use source value directly
-			*target = source;
-		} else if (GreaterThan::Operation(target->value, source.value)) {
-			target->value = source.value;
-		}
-	}
-};
-
-struct MaxOperation : public NumericMinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		if (GreaterThan::Operation<INPUT_TYPE>(input, state->value)) {
-			state->value = input;
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.isset) {
-			// source is NULL, nothing to do
-			return;
-		}
-		if (!target->isset) {
-			// target is NULL, use source value directly
-			*target = source;
-		} else if (LessThan::Operation(target->value, source.value)) {
-			target->value = source.value;
-		}
-	}
-};
-
-struct StringMinMaxBase : public MinMaxBase {
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->isset && !state->value.IsInlined()) {
-			delete[] state->value.GetDataUnsafe();
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE *state, INPUT_TYPE input) {
-		Destroy(state);
-		if (input.IsInlined()) {
-			state->value = input;
-		} else {
-			// non-inlined string, need to allocate space for it
-			auto len = input.GetSize();
-			auto ptr = new char[len];
-			memcpy(ptr, input.GetDataUnsafe(), len);
-
-			state->value = string_t(ptr, len);
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->isset) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = StringVector::AddStringOrBlob(result, state->value);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.isset) {
-			// source is NULL, nothing to do
-			return;
-		}
-		if (!target->isset) {
-			// target is NULL, use source value directly
-			Assign(target, source.value);
-			target->isset = true;
-		} else {
-			OP::template Execute<string_t, STATE>(target, source.value);
-		}
-	}
-};
-
-struct MinOperationString : public StringMinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		if (LessThan::Operation<INPUT_TYPE>(input, state->value)) {
-			Assign(state, input);
-		}
-	}
-};
-
-struct MaxOperationString : public StringMinMaxBase {
-	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		if (GreaterThan::Operation<INPUT_TYPE>(input, state->value)) {
-			Assign(state, input);
-		}
-	}
-};
-
-template <typename T, class OP>
-static bool TemplatedOptimumType(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount) {
-	VectorData lvdata, rvdata;
-	left.Orrify(lcount, lvdata);
-	right.Orrify(rcount, rvdata);
-
-	lidx = lvdata.sel->get_index(lidx);
-	ridx = rvdata.sel->get_index(ridx);
-
-	auto ldata = (const T *)lvdata.data;
-	auto rdata = (const T *)rvdata.data;
-
-	auto &lval = ldata[lidx];
-	auto &rval = rdata[ridx];
-
-	auto lnull = !lvdata.validity.RowIsValid(lidx);
-	auto rnull = !rvdata.validity.RowIsValid(ridx);
-
-	return OP::Operation(lval, rval, lnull, rnull);
-}
-
-template <class OP>
-static bool TemplatedOptimumList(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount);
-
-template <class OP>
-static bool TemplatedOptimumStruct(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount);
-
-template <class OP>
-static bool TemplatedOptimumValue(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount) {
-	D_ASSERT(left.GetType() == right.GetType());
-	switch (left.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedOptimumType<int8_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::INT16:
-		return TemplatedOptimumType<int16_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::INT32:
-		return TemplatedOptimumType<int32_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::INT64:
-		return TemplatedOptimumType<int64_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::UINT8:
-		return TemplatedOptimumType<uint8_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::UINT16:
-		return TemplatedOptimumType<uint16_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::UINT32:
-		return TemplatedOptimumType<uint32_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::UINT64:
-		return TemplatedOptimumType<uint64_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::INT128:
-		return TemplatedOptimumType<hugeint_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::FLOAT:
-		return TemplatedOptimumType<float, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::DOUBLE:
-		return TemplatedOptimumType<double, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::INTERVAL:
-		return TemplatedOptimumType<interval_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::VARCHAR:
-		return TemplatedOptimumType<string_t, OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::LIST:
-		return TemplatedOptimumList<OP>(left, lidx, lcount, right, ridx, rcount);
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-		return TemplatedOptimumStruct<OP>(left, lidx, lcount, right, ridx, rcount);
-	default:
-		throw InternalException("Invalid type for distinct comparison");
-	}
-}
-
-template <class OP>
-static bool TemplatedOptimumStruct(Vector &left, idx_t lidx_p, idx_t lcount, Vector &right, idx_t ridx_p,
-                                   idx_t rcount) {
-	// STRUCT dictionaries apply to all the children
-	// so map the indexes first
-	VectorData lvdata, rvdata;
-	left.Orrify(lcount, lvdata);
-	right.Orrify(rcount, rvdata);
-
-	idx_t lidx = lvdata.sel->get_index(lidx_p);
-	idx_t ridx = rvdata.sel->get_index(ridx_p);
-
-	// DISTINCT semantics are in effect for nested types
-	auto lnull = !lvdata.validity.RowIsValid(lidx);
-	auto rnull = !rvdata.validity.RowIsValid(ridx);
-	if (lnull || rnull) {
-		return OP::Operation(0, 0, lnull, rnull);
-	}
-
-	auto &lchildren = StructVector::GetEntries(left);
-	auto &rchildren = StructVector::GetEntries(right);
-
-	D_ASSERT(lchildren.size() == rchildren.size());
-	for (idx_t col_no = 0; col_no < lchildren.size(); ++col_no) {
-		auto &lchild = *lchildren[col_no];
-		auto &rchild = *rchildren[col_no];
-
-		// Strict comparisons use the OP for definite
-		if (TemplatedOptimumValue<OP>(lchild, lidx_p, lcount, rchild, ridx_p, rcount)) {
-			return true;
-		}
-
-		if (col_no == lchildren.size() - 1) {
-			break;
-		}
-
-		// Strict comparisons use IS NOT DISTINCT for possible
-		if (!TemplatedOptimumValue<NotDistinctFrom>(lchild, lidx_p, lcount, rchild, ridx_p, rcount)) {
-			return false;
-		}
-	}
-
-	return false;
-}
-
-template <class OP>
-static bool TemplatedOptimumList(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount) {
-	VectorData lvdata, rvdata;
-	left.Orrify(lcount, lvdata);
-	right.Orrify(rcount, rvdata);
-
-	// Update the indexes and vector sizes for recursion.
-	lidx = lvdata.sel->get_index(lidx);
-	ridx = rvdata.sel->get_index(ridx);
-
-	lcount = ListVector::GetListSize(left);
-	rcount = ListVector::GetListSize(right);
-
-	// DISTINCT semantics are in effect for nested types
-	auto lnull = !lvdata.validity.RowIsValid(lidx);
-	auto rnull = !rvdata.validity.RowIsValid(ridx);
-	if (lnull || rnull) {
-		return OP::Operation(0, 0, lnull, rnull);
-	}
-
-	auto &lchild = ListVector::GetEntry(left);
-	auto &rchild = ListVector::GetEntry(right);
-
-	auto ldata = (const list_entry_t *)lvdata.data;
-	auto rdata = (const list_entry_t *)rvdata.data;
-
-	auto &lval = ldata[lidx];
-	auto &rval = rdata[ridx];
-
-	for (idx_t pos = 0;; ++pos) {
-		// Tie-breaking uses the OP
-		if (pos == lval.length || pos == rval.length) {
-			return OP::Operation(lval.length, rval.length, false, false);
-		}
-
-		// Strict comparisons use the OP for definite
-		lidx = lval.offset + pos;
-		ridx = rval.offset + pos;
-		if (TemplatedOptimumValue<OP>(lchild, lidx, lcount, rchild, ridx, rcount)) {
-			return true;
-		}
-
-		// Strict comparisons use IS NOT DISTINCT for possible
-		if (!TemplatedOptimumValue<NotDistinctFrom>(lchild, lidx, lcount, rchild, ridx, rcount)) {
-			return false;
-		}
-	}
-
-	return false;
-}
-
-struct VectorMinMaxState {
-	Vector *value;
-};
-
-struct VectorMinMaxBase {
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->value = nullptr;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->value) {
-			delete state->value;
-		}
-		state->value = nullptr;
-	}
-
-	template <class STATE>
-	static void Assign(STATE *state, Vector &input, const idx_t idx) {
-		if (!state->value) {
-			state->value = new Vector(input.GetType());
-			state->value->SetVectorType(VectorType::CONSTANT_VECTOR);
-		}
-		sel_t selv = idx;
-		SelectionVector sel(&selv);
-		VectorOperations::Copy(input, *state->value, sel, 1, 0, 0);
-	}
-
-	template <class STATE>
-	static void Execute(STATE *state, Vector &input, const idx_t idx, const idx_t count) {
-		Assign(state, input, idx);
-	}
-
-	template <class STATE, class OP>
-	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
-		auto &input = inputs[0];
-		VectorData idata;
-		input.Orrify(count, idata);
-
-		VectorData sdata;
-		state_vector.Orrify(count, sdata);
-
-		auto states = (STATE **)sdata.data;
-		for (idx_t i = 0; i < count; i++) {
-			const auto idx = idata.sel->get_index(i);
-			if (!idata.validity.RowIsValid(idx)) {
-				continue;
-			}
-			const auto sidx = sdata.sel->get_index(i);
-			auto state = states[sidx];
-			if (!state->value) {
-				Assign(state, input, i);
-			} else {
-				OP::template Execute(state, input, i, count);
-			}
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.value) {
-			return;
-		} else if (!target->value) {
-			Assign(target, *source.value, 0);
-		} else {
-			OP::template Execute(target, *source.value, 0, 1);
-		}
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->value) {
-			// we need to use SetNull here
-			// since for STRUCT columns only setting the validity mask of the struct is incorrect
-			// as for a struct column, we need to also set ALL child columns to NULL
-			switch (result.GetVectorType()) {
-			case VectorType::FLAT_VECTOR:
-				FlatVector::SetNull(result, idx, true);
-				break;
-			case VectorType::CONSTANT_VECTOR:
-				ConstantVector::SetNull(result, true);
-				break;
-			default:
-				throw InternalException("Invalid result vector type for nested min/max");
-			}
-		} else {
-			VectorOperations::Copy(*state->value, result, 1, 0, idx);
-		}
-	}
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		function.arguments[0] = arguments[0]->return_type;
-		function.return_type = arguments[0]->return_type;
-		return nullptr;
-	}
-};
-
-struct MinOperationVector : public VectorMinMaxBase {
-	template <class STATE>
-	static void Execute(STATE *state, Vector &input, const idx_t idx, const idx_t count) {
-		if (TemplatedOptimumValue<DistinctLessThan>(input, idx, count, *state->value, 0, 1)) {
-			Assign(state, input, idx);
-		}
-	}
-};
-
-struct MaxOperationVector : public VectorMinMaxBase {
-	template <class STATE>
-	static void Execute(STATE *state, Vector &input, const idx_t idx, const idx_t count) {
-		if (TemplatedOptimumValue<DistinctGreaterThan>(input, idx, count, *state->value, 0, 1)) {
-			Assign(state, input, idx);
-		}
-	}
-};
-
-template <class OP>
-unique_ptr<FunctionData> BindDecimalMinMax(ClientContext &context, AggregateFunction &function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	auto name = function.name;
-	switch (decimal_type.InternalType()) {
-	case PhysicalType::INT16:
-		function = GetUnaryAggregate<OP>(LogicalType::SMALLINT);
-		break;
-	case PhysicalType::INT32:
-		function = GetUnaryAggregate<OP>(LogicalType::INTEGER);
-		break;
-	case PhysicalType::INT64:
-		function = GetUnaryAggregate<OP>(LogicalType::BIGINT);
-		break;
-	default:
-		function = GetUnaryAggregate<OP>(LogicalType::HUGEINT);
-		break;
-	}
-	function.name = move(name);
-	function.arguments[0] = decimal_type;
-	function.return_type = decimal_type;
-	return nullptr;
-}
-
-template <typename OP, typename STATE>
-static AggregateFunction GetMinMaxFunction(const LogicalType &type) {
-	return AggregateFunction({type}, type, AggregateFunction::StateSize<STATE>,
-	                         AggregateFunction::StateInitialize<STATE, OP>, OP::template Update<STATE, OP>,
-	                         AggregateFunction::StateCombine<STATE, OP>,
-	                         AggregateFunction::StateFinalize<STATE, void, OP>, nullptr, OP::Bind,
-	                         AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-template <class OP, class OP_STRING, class OP_VECTOR>
-static void AddMinMaxOperator(AggregateFunctionSet &set) {
-	for (auto &type : LogicalType::AllTypes()) {
-		if (type.id() == LogicalTypeId::VARCHAR || type.id() == LogicalTypeId::BLOB || type.id() == LogicalType::JSON) {
-			set.AddFunction(
-			    AggregateFunction::UnaryAggregateDestructor<MinMaxState<string_t>, string_t, string_t, OP_STRING>(
-			        type.id(), type.id()));
-		} else if (type.id() == LogicalTypeId::DECIMAL) {
-			set.AddFunction(AggregateFunction({type}, type, nullptr, nullptr, nullptr, nullptr, nullptr, false, nullptr,
-			                                  BindDecimalMinMax<OP>));
-		} else if (type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP ||
-		           type.id() == LogicalTypeId::STRUCT) {
-			set.AddFunction(GetMinMaxFunction<OP_VECTOR, VectorMinMaxState>(type));
-
-		} else {
-			set.AddFunction(GetUnaryAggregate<OP>(type));
-		}
-	}
-}
-
-void MinFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet min("min");
-	AddMinMaxOperator<MinOperation, MinOperationString, MinOperationVector>(min);
-	set.AddFunction(min);
-}
-
-void MaxFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet max("max");
-	AddMinMaxOperator<MaxOperation, MaxOperationString, MaxOperationVector>(max);
-	set.AddFunction(max);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct ProductState {
-	bool empty;
-	double val;
-};
-
-struct ProductFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->val = 1;
-		state->empty = true;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->val *= source.val;
-		target->empty = target->empty && source.empty;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->empty) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		target[idx] = state->val;
-	}
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (state->empty) {
-			state->empty = false;
-		}
-		state->val *= input[idx];
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-AggregateFunction ProductFun::GetFunction() {
-	auto fun = AggregateFunction::UnaryAggregate<ProductState, double, double, ProductFunction>(
-	    LogicalType(LogicalTypeId::DOUBLE), LogicalType::DOUBLE);
-	fun.name = "product";
-	return fun;
-}
-
-void ProductFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunction product_function = ProductFun::GetFunction();
-	AggregateFunctionSet product("product");
-	product.AddFunction(product_function);
-	set.AddFunction(product);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-struct SkewState {
-	size_t n;
-	double sum;
-	double sum_sqr;
-	double sum_cub;
-};
-
-struct SkewnessOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->n = 0;
-		state->sum = state->sum_sqr = state->sum_cub = 0;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
-		state->n++;
-		state->sum += data[idx];
-		state->sum_sqr += pow(data[idx], 2);
-		state->sum_cub += pow(data[idx], 3);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.n == 0) {
-			return;
-		}
-
-		target->n += source.n;
-		target->sum += source.sum;
-		target->sum_sqr += source.sum_sqr;
-		target->sum_cub += source.sum_cub;
-	}
-
-	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, TARGET_TYPE *target, ValidityMask &mask,
-	                     idx_t idx) {
-		if (state->n <= 2) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		double n = state->n;
-		double temp = 1 / n;
-		double div = (std::sqrt(std::pow(temp * (state->sum_sqr - state->sum * state->sum * temp), 3)));
-		if (div == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		double temp1 = std::sqrt(n * (n - 1)) / (n - 2);
-		target[idx] = temp1 * temp *
-		              (state->sum_cub - 3 * state->sum_sqr * state->sum * temp + 2 * pow(state->sum, 3) * temp * temp) /
-		              div;
-		if (!Value::DoubleIsFinite(target[idx])) {
-			throw OutOfRangeException("SKEW is out of range!");
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-void SkewFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet function_set("skewness");
-	function_set.AddFunction(AggregateFunction::UnaryAggregate<SkewState, double, double, SkewnessOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(function_set);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct StringAggState {
-	idx_t size;
-	idx_t alloc_size;
-	char *dataptr;
-};
-
-struct StringAggBindData : public FunctionData {
-	explicit StringAggBindData(string sep_p) : sep(move(sep_p)) {
-	}
-
-	string sep;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StringAggBindData>(sep);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (StringAggBindData &)other_p;
-		return sep == other.sep;
-	}
-};
-
-struct StringAggFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->dataptr = nullptr;
-		state->alloc_size = 0;
-		state->size = 0;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->dataptr) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = StringVector::AddString(result, state->dataptr, state->size);
-		}
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->dataptr) {
-			delete[] state->dataptr;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	static inline void PerformOperation(StringAggState *state, const char *str, const char *sep, idx_t str_size,
-	                                    idx_t sep_size) {
-		if (!state->dataptr) {
-			// first iteration: allocate space for the string and copy it into the state
-			state->alloc_size = MaxValue<idx_t>(8, NextPowerOfTwo(str_size));
-			state->dataptr = new char[state->alloc_size];
-			state->size = str_size;
-			memcpy(state->dataptr, str, str_size);
-		} else {
-			// subsequent iteration: first check if we have space to place the string and separator
-			idx_t required_size = state->size + str_size + sep_size;
-			if (required_size > state->alloc_size) {
-				// no space! allocate extra space
-				while (state->alloc_size < required_size) {
-					state->alloc_size *= 2;
-				}
-				auto new_data = new char[state->alloc_size];
-				memcpy(new_data, state->dataptr, state->size);
-				delete[] state->dataptr;
-				state->dataptr = new_data;
-			}
-			// copy the separator
-			memcpy(state->dataptr + state->size, sep, sep_size);
-			state->size += sep_size;
-			// copy the string
-			memcpy(state->dataptr + state->size, str, str_size);
-			state->size += str_size;
-		}
-	}
-
-	static inline void PerformOperation(StringAggState *state, string_t str, FunctionData *data_p) {
-		auto &data = (StringAggBindData &)*data_p;
-		PerformOperation(state, str.GetDataUnsafe(), data.sep.c_str(), str.GetSize(), data.sep.size());
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *str_data,
-	                      ValidityMask &str_mask, idx_t str_idx) {
-		PerformOperation(state, str_data[str_idx], aggr_input_data.bind_data);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		if (!source.dataptr) {
-			// source is not set: skip combining
-			return;
-		}
-		PerformOperation(target, string_t(source.dataptr, source.size), aggr_input_data.bind_data);
-	}
-};
-
-unique_ptr<FunctionData> StringAggBind(ClientContext &context, AggregateFunction &function,
-                                       vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() == 1) {
-		// single argument: default to comma
-		return make_unique<StringAggBindData>(",");
-	}
-	D_ASSERT(arguments.size() == 2);
-	if (!arguments[1]->IsFoldable()) {
-		throw BinderException("Separator argument to StringAgg must be a constant");
-	}
-	auto separator_val = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-	if (separator_val.IsNull()) {
-		arguments[0] = make_unique<BoundConstantExpression>(Value(LogicalType::VARCHAR));
-	}
-	function.arguments.erase(function.arguments.begin() + 1);
-	return make_unique<StringAggBindData>(separator_val.ToString());
-}
-
-void StringAggFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet string_agg("string_agg");
-	string_agg.AddFunction(
-	    AggregateFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                      AggregateFunction::StateSize<StringAggState>,
-	                      AggregateFunction::StateInitialize<StringAggState, StringAggFunction>,
-	                      AggregateFunction::UnaryScatterUpdate<StringAggState, string_t, StringAggFunction>,
-	                      AggregateFunction::StateCombine<StringAggState, StringAggFunction>,
-	                      AggregateFunction::StateFinalize<StringAggState, string_t, StringAggFunction>,
-	                      AggregateFunction::UnaryUpdate<StringAggState, string_t, StringAggFunction>, StringAggBind,
-	                      AggregateFunction::StateDestroy<StringAggState, StringAggFunction>));
-	string_agg.AddFunction(
-	    AggregateFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, AggregateFunction::StateSize<StringAggState>,
-	                      AggregateFunction::StateInitialize<StringAggState, StringAggFunction>,
-	                      AggregateFunction::UnaryScatterUpdate<StringAggState, string_t, StringAggFunction>,
-	                      AggregateFunction::StateCombine<StringAggState, StringAggFunction>,
-	                      AggregateFunction::StateFinalize<StringAggState, string_t, StringAggFunction>,
-	                      AggregateFunction::UnaryUpdate<StringAggState, string_t, StringAggFunction>, StringAggBind,
-	                      AggregateFunction::StateDestroy<StringAggState, StringAggFunction>));
-	set.AddFunction(string_agg);
-	string_agg.name = "group_concat";
-	set.AddFunction(string_agg);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct SumSetOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->Initialize();
-	}
-	template <class STATE>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->Combine(source);
-	}
-	template <class STATE>
-	static void AddValues(STATE *state, idx_t count) {
-		state->isset = true;
-	}
-};
-
-struct IntegerSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->isset) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = Hugeint::Convert(state->value);
-		}
-	}
-};
-
-struct SumToHugeintOperation : public BaseSumOperation<SumSetOperation, HugeintAdd> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->isset) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->value;
-		}
-	}
-};
-
-template <class ADD_OPERATOR>
-struct DoubleSumOperation : public BaseSumOperation<SumSetOperation, ADD_OPERATOR> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->isset) {
-			mask.SetInvalid(idx);
-		} else {
-			if (!Value::DoubleIsFinite(state->value)) {
-				throw OutOfRangeException("SUM is out of range!");
-			}
-			target[idx] = state->value;
-		}
-	}
-};
-
-using NumericSumOperation = DoubleSumOperation<RegularAdd>;
-using KahanSumOperation = DoubleSumOperation<KahanAdd>;
-
-struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd> {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->isset) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->value;
-		}
-	}
-};
-
-unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                             FunctionData *bind_data, vector<unique_ptr<BaseStatistics>> &child_stats,
-                                             NodeStatistics *node_stats) {
-	if (child_stats[0] && node_stats && node_stats->has_max_cardinality) {
-		auto &numeric_stats = (NumericStatistics &)*child_stats[0];
-		if (numeric_stats.min.IsNull() || numeric_stats.max.IsNull()) {
-			return nullptr;
-		}
-		auto internal_type = numeric_stats.min.type().InternalType();
-		hugeint_t max_negative;
-		hugeint_t max_positive;
-		switch (internal_type) {
-		case PhysicalType::INT32:
-			max_negative = numeric_stats.min.GetValueUnsafe<int32_t>();
-			max_positive = numeric_stats.max.GetValueUnsafe<int32_t>();
-			break;
-		case PhysicalType::INT64:
-			max_negative = numeric_stats.min.GetValueUnsafe<int64_t>();
-			max_positive = numeric_stats.max.GetValueUnsafe<int64_t>();
-			break;
-		default:
-			throw InternalException("Unsupported type for propagate sum stats");
-		}
-		auto max_sum_negative = max_negative * hugeint_t(node_stats->max_cardinality);
-		auto max_sum_positive = max_positive * hugeint_t(node_stats->max_cardinality);
-		if (max_sum_positive >= NumericLimits<int64_t>::Maximum() ||
-		    max_sum_negative <= NumericLimits<int64_t>::Minimum()) {
-			// sum can potentially exceed int64_t bounds: use hugeint sum
-			return nullptr;
-		}
-		// total sum is guaranteed to fit in a single int64: use int64 sum instead of hugeint sum
-		switch (internal_type) {
-		case PhysicalType::INT32:
-			expr.function =
-			    AggregateFunction::UnaryAggregate<SumState<int64_t>, int32_t, hugeint_t, IntegerSumOperation>(
-			        LogicalType::INTEGER, LogicalType::HUGEINT, true);
-			expr.function.name = "sum";
-			break;
-		case PhysicalType::INT64:
-			expr.function =
-			    AggregateFunction::UnaryAggregate<SumState<int64_t>, int64_t, hugeint_t, IntegerSumOperation>(
-			        LogicalType::BIGINT, LogicalType::HUGEINT, true);
-			expr.function.name = "sum";
-			break;
-		default:
-			throw InternalException("Unsupported type for propagate sum stats");
-		}
-	}
-	return nullptr;
-}
-
-AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregate<SumState<int64_t>, int16_t, hugeint_t, IntegerSumOperation>(
-		    LogicalType::SMALLINT, LogicalType::HUGEINT, true);
-	case PhysicalType::INT32: {
-		auto function =
-		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int32_t, hugeint_t, SumToHugeintOperation>(
-		        LogicalType::INTEGER, LogicalType::HUGEINT, true);
-		function.statistics = SumPropagateStats;
-		return function;
-	}
-	case PhysicalType::INT64: {
-		auto function =
-		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int64_t, hugeint_t, SumToHugeintOperation>(
-		        LogicalType::BIGINT, LogicalType::HUGEINT, true);
-		function.statistics = SumPropagateStats;
-		return function;
-	}
-	case PhysicalType::INT128:
-		return AggregateFunction::UnaryAggregate<SumState<hugeint_t>, hugeint_t, hugeint_t, HugeintSumOperation>(
-		    LogicalType::HUGEINT, LogicalType::HUGEINT, true);
-	default:
-		throw InternalException("Unimplemented sum aggregate");
-	}
-}
-
-unique_ptr<FunctionData> BindDecimalSum(ClientContext &context, AggregateFunction &function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	function = SumFun::GetSumAggregate(decimal_type.InternalType());
-	function.name = "sum";
-	function.arguments[0] = decimal_type;
-	function.return_type = LogicalType::DECIMAL(Decimal::MAX_WIDTH_DECIMAL, DecimalType::GetScale(decimal_type));
-	return nullptr;
-}
-
-void SumFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet sum("sum");
-	// decimal
-	sum.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, true, nullptr, BindDecimalSum));
-	sum.AddFunction(GetSumAggregate(PhysicalType::INT16));
-	sum.AddFunction(GetSumAggregate(PhysicalType::INT32));
-	sum.AddFunction(GetSumAggregate(PhysicalType::INT64));
-	sum.AddFunction(GetSumAggregate(PhysicalType::INT128));
-	sum.AddFunction(AggregateFunction::UnaryAggregate<SumState<double>, double, double, NumericSumOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
-
-	set.AddFunction(sum);
-
-	// fsum
-	AggregateFunctionSet fsum("fsum");
-	fsum.AddFunction(AggregateFunction::UnaryAggregate<KahanSumState, double, double, KahanSumOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
-
-	set.AddFunction(fsum);
-
-	fsum.name = "kahan_sum";
-	set.AddFunction(fsum);
-
-	fsum.name = "sumKahan";
-	set.AddFunction(fsum);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterDistributiveAggregates() {
-	Register<BitAndFun>();
-	Register<BitOrFun>();
-	Register<BitXorFun>();
-	Register<CountStarFun>();
-	Register<CountFun>();
-	Register<FirstFun>();
-	Register<MaxFun>();
-	Register<MinFun>();
-	Register<SumFun>();
-	Register<StringAggFun>();
-	Register<ApproxCountDistinctFun>();
-	Register<ProductFun>();
-	Register<BoolOrFun>();
-	Register<BoolAndFun>();
-	Register<ArgMinFun>();
-	Register<ArgMaxFun>();
-	Register<SkewFun>();
-	Register<KurtosisFun>();
-	Register<EntropyFun>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#include <algorithm>
-#include <cmath>
-#include <stdlib.h>
-
-namespace duckdb {
-
-struct ApproxQuantileState {
-	duckdb_tdigest::TDigest *h;
-	idx_t pos;
-};
-
-struct ApproximateQuantileBindData : public FunctionData {
-	explicit ApproximateQuantileBindData(float quantile_p) : quantiles(1, quantile_p) {
-	}
-
-	explicit ApproximateQuantileBindData(const vector<float> &quantiles_p) : quantiles(quantiles_p) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ApproximateQuantileBindData>(quantiles);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (ApproximateQuantileBindData &)other_p;
-		return quantiles == other.quantiles;
-	}
-
-	vector<float> quantiles;
-};
-
-struct ApproxQuantileOperation {
-	using SAVE_TYPE = duckdb_tdigest::Value;
-
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->pos = 0;
-		state->h = nullptr;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
-		if (!state->h) {
-			state->h = new duckdb_tdigest::TDigest(100);
-		}
-
-		state->h->add(Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]));
-		state->pos++;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.pos == 0) {
-			return;
-		}
-		D_ASSERT(source.h);
-		if (!target->h) {
-			target->h = new duckdb_tdigest::TDigest(100);
-		}
-		target->h->merge(source.h);
-		target->pos += source.pos;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->h) {
-			delete state->h;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct ApproxQuantileScalarOperation : public ApproxQuantileOperation {
-
-	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, TARGET_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-
-		if (state->pos == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		D_ASSERT(state->h);
-		D_ASSERT(aggr_input_data.bind_data);
-		state->h->compress();
-		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
-		D_ASSERT(bind_data->quantiles.size() == 1);
-		target[idx] = Cast::template Operation<SAVE_TYPE, TARGET_TYPE>(state->h->quantile(bind_data->quantiles[0]));
-	}
-};
-
-AggregateFunction GetApproximateQuantileAggregateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, int16_t, int16_t,
-		                                                   ApproxQuantileScalarOperation>(LogicalType::SMALLINT,
-		                                                                                  LogicalType::SMALLINT);
-
-	case PhysicalType::INT32:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, int32_t, int32_t,
-		                                                   ApproxQuantileScalarOperation>(LogicalType::INTEGER,
-		                                                                                  LogicalType::INTEGER);
-
-	case PhysicalType::INT64:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, int64_t, int64_t,
-		                                                   ApproxQuantileScalarOperation>(LogicalType::BIGINT,
-		                                                                                  LogicalType::BIGINT);
-	case PhysicalType::DOUBLE:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxQuantileState, double, double,
-		                                                   ApproxQuantileScalarOperation>(LogicalType::DOUBLE,
-		                                                                                  LogicalType::DOUBLE);
-
-	default:
-		throw InternalException("Unimplemented quantile aggregate");
-	}
-}
-
-static float CheckApproxQuantile(const Value &quantile_val) {
-	auto quantile = quantile_val.GetValue<float>();
-
-	if (quantile_val.IsNull() || quantile < 0 || quantile > 1) {
-		throw BinderException("APPROXIMATE QUANTILE can only take parameters in range [0, 1]");
-	}
-
-	return quantile;
-}
-
-unique_ptr<FunctionData> BindApproxQuantile(ClientContext &context, AggregateFunction &function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[1]->IsScalar()) {
-		throw BinderException("APPROXIMATE QUANTILE can only take constant quantile parameters");
-	}
-	Value quantile_val = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-
-	vector<float> quantiles;
-	if (quantile_val.type().id() != LogicalTypeId::LIST) {
-		quantiles.push_back(CheckApproxQuantile(quantile_val));
-	} else {
-		for (const auto &element_val : ListValue::GetChildren(quantile_val)) {
-			quantiles.push_back(CheckApproxQuantile(element_val));
-		}
-	}
-
-	// remove the quantile argument so we can use the unary aggregate
-	arguments.pop_back();
-	return make_unique<ApproximateQuantileBindData>(quantiles);
-}
-
-unique_ptr<FunctionData> BindApproxQuantileDecimal(ClientContext &context, AggregateFunction &function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindApproxQuantile(context, function, arguments);
-	function = GetApproximateQuantileAggregateFunction(arguments[0]->return_type.InternalType());
-	function.name = "approx_quantile";
-	return bind_data;
-}
-
-AggregateFunction GetApproximateQuantileAggregate(PhysicalType type) {
-	auto fun = GetApproximateQuantileAggregateFunction(type);
-	fun.bind = BindApproxQuantile;
-	// temporarily push an argument so we can bind the actual quantile
-	fun.arguments.emplace_back(LogicalType::FLOAT);
-	return fun;
-}
-
-template <class CHILD_TYPE>
-struct ApproxQuantileListOperation : public ApproxQuantileOperation {
-
-	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result_list, AggregateInputData &aggr_input_data, STATE *state, RESULT_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->pos == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
-
-		auto &result = ListVector::GetEntry(result_list);
-		auto ridx = ListVector::GetListSize(result_list);
-		ListVector::Reserve(result_list, ridx + bind_data->quantiles.size());
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		D_ASSERT(state->h);
-		state->h->compress();
-
-		auto &entry = target[idx];
-		entry.offset = ridx;
-		entry.length = bind_data->quantiles.size();
-		for (size_t q = 0; q < entry.length; ++q) {
-			const auto &quantile = bind_data->quantiles[q];
-			rdata[ridx + q] = Cast::template Operation<SAVE_TYPE, CHILD_TYPE>(state->h->quantile(quantile));
-		}
-
-		ListVector::SetListSize(result_list, entry.offset + entry.length);
-	}
-
-	template <class STATE_TYPE, class RESULT_TYPE>
-	static void FinalizeList(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count, // NOLINT
-	                         idx_t offset) {
-		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
-
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ListVector::Reserve(result, bind_data->quantiles.size());
-
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
-			auto &mask = ConstantVector::Validity(result);
-			Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[0], rdata, mask, 0);
-		} else {
-			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			ListVector::Reserve(result, (offset + count) * bind_data->quantiles.size());
-
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-			auto &mask = FlatVector::Validity(result);
-			for (idx_t i = 0; i < count; i++) {
-				Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata, mask, i + offset);
-			}
-		}
-
-		result.Verify(count);
-	}
-};
-
-template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-static AggregateFunction ApproxQuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) {
-	LogicalType result_type = LogicalType::LIST(child_type);
-	return AggregateFunction(
-	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-	    AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	    OP::template FinalizeList<STATE, RESULT_TYPE>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>, nullptr,
-	    AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-template <typename INPUT_TYPE, typename SAVE_TYPE>
-AggregateFunction GetTypedApproxQuantileListAggregateFunction(const LogicalType &type) {
-	using STATE = ApproxQuantileState;
-	using OP = ApproxQuantileListOperation<INPUT_TYPE>;
-	auto fun = ApproxQuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
-	return fun;
-}
-
-AggregateFunction GetApproxQuantileListAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return GetTypedApproxQuantileListAggregateFunction<int8_t, int8_t>(type);
-	case LogicalTypeId::SMALLINT:
-		return GetTypedApproxQuantileListAggregateFunction<int16_t, int16_t>(type);
-	case LogicalTypeId::INTEGER:
-		return GetTypedApproxQuantileListAggregateFunction<int32_t, int32_t>(type);
-	case LogicalTypeId::BIGINT:
-		return GetTypedApproxQuantileListAggregateFunction<int64_t, int64_t>(type);
-	case LogicalTypeId::HUGEINT:
-		return GetTypedApproxQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-
-	case LogicalTypeId::FLOAT:
-		return GetTypedApproxQuantileListAggregateFunction<float, float>(type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedApproxQuantileListAggregateFunction<double, double>(type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedApproxQuantileListAggregateFunction<int16_t, int16_t>(type);
-		case PhysicalType::INT32:
-			return GetTypedApproxQuantileListAggregateFunction<int32_t, int32_t>(type);
-		case PhysicalType::INT64:
-			return GetTypedApproxQuantileListAggregateFunction<int64_t, int64_t>(type);
-		case PhysicalType::INT128:
-			return GetTypedApproxQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-		default:
-			throw NotImplementedException("Unimplemented approximate quantile list aggregate");
-		}
-		break;
-
-	default:
-		// TODO: Add quantitative temporal types
-		throw NotImplementedException("Unimplemented approximate quantile list aggregate");
-	}
-}
-
-unique_ptr<FunctionData> BindApproxQuantileDecimalList(ClientContext &context, AggregateFunction &function,
-                                                       vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindApproxQuantile(context, function, arguments);
-	function = GetApproxQuantileListAggregateFunction(arguments[0]->return_type);
-	function.name = "approx_quantile";
-	return bind_data;
-}
-
-AggregateFunction GetApproxQuantileListAggregate(const LogicalType &type) {
-	auto fun = GetApproxQuantileListAggregateFunction(type);
-	fun.bind = BindApproxQuantile;
-	// temporarily push an argument so we can bind the actual quantile
-	auto list_of_float = LogicalType::LIST(LogicalType::FLOAT);
-	fun.arguments.push_back(list_of_float);
-	return fun;
-}
-
-void ApproximateQuantileFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet approx_quantile("approx_quantile");
-	approx_quantile.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::FLOAT}, LogicalTypeId::DECIMAL,
-	                                              nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                                              BindApproxQuantileDecimal));
-
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(PhysicalType::INT16));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(PhysicalType::INT32));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(PhysicalType::INT64));
-	approx_quantile.AddFunction(GetApproximateQuantileAggregate(PhysicalType::DOUBLE));
-
-	// List variants
-	approx_quantile.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::FLOAT)},
-	                                              LogicalType::LIST(LogicalTypeId::DECIMAL), nullptr, nullptr, nullptr,
-	                                              nullptr, nullptr, nullptr, BindApproxQuantileDecimalList));
-
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::TINYINT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::SMALLINT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::INTEGER));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::BIGINT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::HUGEINT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::FLOAT));
-	approx_quantile.AddFunction(GetApproxQuantileListAggregate(LogicalTypeId::DOUBLE));
-
-	set.AddFunction(approx_quantile);
-}
-
-} // namespace duckdb
-// MODE( <expr1> )
-// Returns the most frequent value for the values within expr1.
-// NULL values are ignored. If all the values are NULL, or there are 0 rows, then the function returns NULL.
-
-
-
-
-
-
-
-
-#include <functional>
-
-namespace std {
-
-template <>
-struct hash<duckdb::interval_t> {
-	inline size_t operator()(const duckdb::interval_t &val) const {
-		return hash<int32_t> {}(val.days) ^ hash<int32_t> {}(val.months) ^ hash<int64_t> {}(val.micros);
-	}
-};
-
-template <>
-struct hash<duckdb::hugeint_t> {
-	inline size_t operator()(const duckdb::hugeint_t &val) const {
-		return hash<int64_t> {}(val.upper) ^ hash<int64_t> {}(val.lower);
-	}
-};
-
-} // namespace std
-
-namespace duckdb {
-
-using FrameBounds = std::pair<idx_t, idx_t>;
-
-template <class KEY_TYPE>
-struct ModeState {
-	using Counts = unordered_map<KEY_TYPE, size_t>;
-
-	Counts *frequency_map;
-	KEY_TYPE *mode;
-	size_t nonzero;
-	bool valid;
-	size_t count;
-
-	void Initialize() {
-		frequency_map = nullptr;
-		mode = nullptr;
-		nonzero = 0;
-		valid = false;
-		count = 0;
-	}
-
-	void Destroy() {
-		if (frequency_map) {
-			delete frequency_map;
-		}
-		if (mode) {
-			delete mode;
-		}
-	}
-
-	void Reset() {
-		Counts empty;
-		frequency_map->swap(empty);
-		nonzero = 0;
-		count = 0;
-		valid = false;
-	}
-
-	void ModeAdd(const KEY_TYPE &key) {
-		auto new_count = ((*frequency_map)[key] += 1);
-		if (new_count == 1) {
-			++nonzero;
-		}
-		if (new_count > count) {
-			valid = true;
-			count = new_count;
-			if (mode) {
-				*mode = key;
-			} else {
-				mode = new KEY_TYPE(key);
-			}
-		}
-	}
-
-	void ModeRm(const KEY_TYPE &key) {
-		auto i = frequency_map->find(key);
-		auto old_count = i->second;
-		nonzero -= int(old_count == 1);
-
-		i->second -= 1;
-		if (count == old_count && key == *mode) {
-			valid = false;
-		}
-	}
-
-	typename Counts::const_iterator Scan() const {
-		//! Initialize control variables to first variable of the frequency map
-		auto highest_frequency = frequency_map->begin();
-		for (auto i = highest_frequency; i != frequency_map->end(); ++i) {
-			// Tie break with the lowest
-			if (i->second > highest_frequency->second ||
-			    (i->second == highest_frequency->second && i->first < highest_frequency->first)) {
-				highest_frequency = i;
-			}
-		}
-		return highest_frequency;
-	}
-};
-
-struct ModeIncluded {
-	inline explicit ModeIncluded(const ValidityMask &fmask_p, const ValidityMask &dmask_p, idx_t bias_p)
-	    : fmask(fmask_p), dmask(dmask_p), bias(bias_p) {
-	}
-
-	inline bool operator()(const idx_t &idx) const {
-		return fmask.RowIsValid(idx) && dmask.RowIsValid(idx - bias);
-	}
-	const ValidityMask &fmask;
-	const ValidityMask &dmask;
-	const idx_t bias;
-};
-
-template <typename KEY_TYPE>
-struct ModeFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->Initialize();
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->frequency_map) {
-			state->frequency_map = new unordered_map<KEY_TYPE, size_t>();
-		}
-		auto key = KEY_TYPE(input[idx]);
-		(*state->frequency_map)[key]++;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!source.frequency_map) {
-			return;
-		}
-		if (!target->frequency_map) {
-			// Copy - don't destroy! Otherwise windowing will break.
-			target->frequency_map = new unordered_map<KEY_TYPE, size_t>(*source.frequency_map);
-			return;
-		}
-		for (auto &val : *source.frequency_map) {
-			(*target->frequency_map)[val.first] += val.second;
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, INPUT_TYPE *target, ValidityMask &mask,
-	                     idx_t idx) {
-		if (!state->frequency_map) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		auto highest_frequency = state->Scan();
-		if (highest_frequency != state->frequency_map->end()) {
-			target[idx] = INPUT_TYPE(highest_frequency->first);
-		} else {
-			mask.SetInvalid(idx);
-		}
-	}
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		if (!state->frequency_map) {
-			state->frequency_map = new unordered_map<KEY_TYPE, size_t>();
-		}
-		auto key = KEY_TYPE(input[0]);
-		(*state->frequency_map)[key] += count;
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   AggregateInputData &, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
-	                   Vector &result, idx_t rid, idx_t bias) {
-		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
-
-		ModeIncluded included(fmask, dmask, bias);
-
-		if (!state->frequency_map) {
-			state->frequency_map = new unordered_map<KEY_TYPE, size_t>();
-		}
-		const double tau = .25;
-		if (state->nonzero <= tau * state->frequency_map->size()) {
-			state->Reset();
-			// for f ∈ F do
-			for (auto f = frame.first; f < frame.second; ++f) {
-				if (included(f)) {
-					state->ModeAdd(KEY_TYPE(data[f]));
-				}
-			}
-		} else {
-			// for f ∈ P \ F do
-			for (auto p = prev.first; p < frame.first; ++p) {
-				if (included(p)) {
-					state->ModeRm(KEY_TYPE(data[p]));
-				}
-			}
-			for (auto p = frame.second; p < prev.second; ++p) {
-				if (included(p)) {
-					state->ModeRm(KEY_TYPE(data[p]));
-				}
-			}
-
-			// for f ∈ F \ P do
-			for (auto f = frame.first; f < prev.first; ++f) {
-				if (included(f)) {
-					state->ModeAdd(KEY_TYPE(data[f]));
-				}
-			}
-			for (auto f = prev.second; f < frame.second; ++f) {
-				if (included(f)) {
-					state->ModeAdd(KEY_TYPE(data[f]));
-				}
-			}
-		}
-
-		if (!state->valid) {
-			// Rescan
-			auto highest_frequency = state->Scan();
-			if (highest_frequency != state->frequency_map->end()) {
-				*(state->mode) = highest_frequency->first;
-				state->count = highest_frequency->second;
-				state->valid = (state->count > 0);
-			}
-		}
-
-		if (state->valid) {
-			rdata[rid] = RESULT_TYPE(*state->mode);
-		} else {
-			rmask.Set(rid, false);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		state->Destroy();
-	}
-};
-
-template <typename INPUT_TYPE, typename KEY_TYPE>
-AggregateFunction GetTypedModeFunction(const LogicalType &type) {
-	using STATE = ModeState<KEY_TYPE>;
-	using OP = ModeFunction<KEY_TYPE>;
-	auto func = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, INPUT_TYPE, OP>(type, type);
-	func.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, INPUT_TYPE, OP>;
-	return func;
-}
-
-AggregateFunction GetModeAggregate(const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::INT8:
-		return GetTypedModeFunction<int8_t, int8_t>(type);
-	case PhysicalType::UINT8:
-		return GetTypedModeFunction<uint8_t, uint8_t>(type);
-	case PhysicalType::INT16:
-		return GetTypedModeFunction<int16_t, int16_t>(type);
-	case PhysicalType::UINT16:
-		return GetTypedModeFunction<uint16_t, uint16_t>(type);
-	case PhysicalType::INT32:
-		return GetTypedModeFunction<int32_t, int32_t>(type);
-	case PhysicalType::UINT32:
-		return GetTypedModeFunction<uint32_t, uint32_t>(type);
-	case PhysicalType::INT64:
-		return GetTypedModeFunction<int64_t, int64_t>(type);
-	case PhysicalType::UINT64:
-		return GetTypedModeFunction<uint64_t, uint64_t>(type);
-	case PhysicalType::INT128:
-		return GetTypedModeFunction<hugeint_t, hugeint_t>(type);
-
-	case PhysicalType::FLOAT:
-		return GetTypedModeFunction<float, float>(type);
-	case PhysicalType::DOUBLE:
-		return GetTypedModeFunction<double, double>(type);
-
-	case PhysicalType::INTERVAL:
-		return GetTypedModeFunction<interval_t, interval_t>(type);
-
-	case PhysicalType::VARCHAR:
-		return GetTypedModeFunction<string_t, string>(type);
-
-	default:
-		throw NotImplementedException("Unimplemented mode aggregate");
-	}
-}
-
-unique_ptr<FunctionData> BindModeDecimal(ClientContext &context, AggregateFunction &function,
-                                         vector<unique_ptr<Expression>> &arguments) {
-	function = GetModeAggregate(arguments[0]->return_type);
-	function.name = "mode";
-	return nullptr;
-}
-
-void ModeFun::RegisterFunction(BuiltinFunctions &set) {
-	const vector<LogicalType> TEMPORAL = {LogicalType::DATE,         LogicalType::TIMESTAMP, LogicalType::TIME,
-	                                      LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,   LogicalType::INTERVAL};
-
-	AggregateFunctionSet mode("mode");
-	mode.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                   nullptr, nullptr, nullptr, BindModeDecimal));
-
-	for (const auto &type : LogicalType::Numeric()) {
-		if (type.id() != LogicalTypeId::DECIMAL) {
-			mode.AddFunction(GetModeAggregate(type));
-		}
-	}
-
-	for (const auto &type : TEMPORAL) {
-		mode.AddFunction(GetModeAggregate(type));
-	}
-
-	mode.AddFunction(GetModeAggregate(LogicalType::VARCHAR));
-
-	set.AddFunction(mode);
-}
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-#include <stdlib.h>
-#include <utility>
-
-namespace duckdb {
-
-// Hugeint arithmetic
-hugeint_t operator*(const hugeint_t &h, const double &d) {
-	D_ASSERT(d >= 0 && d <= 1);
-	return Hugeint::Convert(Hugeint::Cast<double>(h) * d);
-}
-
-// Interval arithmetic
-interval_t operator*(const interval_t &i, const double &d) {
-	D_ASSERT(d >= 0 && d <= 1);
-	return Interval::FromMicro(std::llround(Interval::GetMicro(i) * d));
-}
-
-inline interval_t operator+(const interval_t &lhs, const interval_t &rhs) {
-	return Interval::FromMicro(Interval::GetMicro(lhs) + Interval::GetMicro(rhs));
-}
-
-inline interval_t operator-(const interval_t &lhs, const interval_t &rhs) {
-	return Interval::FromMicro(Interval::GetMicro(lhs) - Interval::GetMicro(rhs));
-}
-
-using FrameBounds = std::pair<idx_t, idx_t>;
-
-template <typename SAVE_TYPE>
-struct QuantileState {
-	using SaveType = SAVE_TYPE;
-
-	// Regular aggregation
-	std::vector<SaveType> v;
-
-	// Windowed Quantile indirection
-	std::vector<idx_t> w;
-	idx_t pos;
-
-	// Windowed MAD indirection
-	std::vector<idx_t> m;
-
-	QuantileState() : pos(0) {
-	}
-
-	~QuantileState() {
-	}
-
-	inline void SetPos(size_t pos_p) {
-		pos = pos_p;
-		if (pos >= w.size()) {
-			w.resize(pos);
-		}
-	}
-};
-
-struct QuantileIncluded {
-	inline explicit QuantileIncluded(const ValidityMask &fmask_p, const ValidityMask &dmask_p, idx_t bias_p)
-	    : fmask(fmask_p), dmask(dmask_p), bias(bias_p) {
-	}
-
-	inline bool operator()(const idx_t &idx) const {
-		return fmask.RowIsValid(idx) && dmask.RowIsValid(idx - bias);
-	}
-
-	inline bool AllValid() const {
-		return fmask.AllValid() && dmask.AllValid();
-	}
-
-	const ValidityMask &fmask;
-	const ValidityMask &dmask;
-	const idx_t bias;
-};
-
-void ReuseIndexes(idx_t *index, const FrameBounds &frame, const FrameBounds &prev) {
-	idx_t j = 0;
-
-	//  Copy overlapping indices
-	for (idx_t p = 0; p < (prev.second - prev.first); ++p) {
-		auto idx = index[p];
-
-		//  Shift down into any hole
-		if (j != p) {
-			index[j] = idx;
-		}
-
-		//  Skip overlapping values
-		if (frame.first <= idx && idx < frame.second) {
-			++j;
-		}
-	}
-
-	//  Insert new indices
-	if (j > 0) {
-		// Overlap: append the new ends
-		for (auto f = frame.first; f < prev.first; ++f, ++j) {
-			index[j] = f;
-		}
-		for (auto f = prev.second; f < frame.second; ++f, ++j) {
-			index[j] = f;
-		}
-	} else {
-		//  No overlap: overwrite with new values
-		for (auto f = frame.first; f < frame.second; ++f, ++j) {
-			index[j] = f;
-		}
-	}
-}
-
-static idx_t ReplaceIndex(idx_t *index, const FrameBounds &frame, const FrameBounds &prev) { // NOLINT
-	D_ASSERT(index);
-
-	idx_t j = 0;
-	for (idx_t p = 0; p < (prev.second - prev.first); ++p) {
-		auto idx = index[p];
-		if (j != p) {
-			break;
-		}
-
-		if (frame.first <= idx && idx < frame.second) {
-			++j;
-		}
-	}
-	index[j] = frame.second - 1;
-
-	return j;
-}
-
-template <class INPUT_TYPE>
-static inline int CanReplace(const idx_t *index, const INPUT_TYPE *fdata, const idx_t j, const idx_t k0, const idx_t k1,
-                             const QuantileIncluded &validity) {
-	D_ASSERT(index);
-
-	// NULLs sort to the end, so if we have inserted a NULL,
-	// it must be past the end of the quantile to be replaceable.
-	// Note that the quantile values are never NULL.
-	const auto ij = index[j];
-	if (!validity(ij)) {
-		return k1 < j ? 1 : 0;
-	}
-
-	auto curr = fdata[ij];
-	if (k1 < j) {
-		auto hi = fdata[index[k0]];
-		return hi < curr ? 1 : 0;
-	} else if (j < k0) {
-		auto lo = fdata[index[k1]];
-		return curr < lo ? -1 : 0;
-	}
-
-	return 0;
-}
-
-template <class INPUT_TYPE>
-struct IndirectLess {
-	inline explicit IndirectLess(const INPUT_TYPE *inputs_p) : inputs(inputs_p) {
-	}
-
-	inline bool operator()(const idx_t &lhi, const idx_t &rhi) const {
-		return inputs[lhi] < inputs[rhi];
-	}
-
-	const INPUT_TYPE *inputs;
-};
-
-struct CastInterpolation {
-
-	template <class INPUT_TYPE, class TARGET_TYPE>
-	static inline TARGET_TYPE Cast(const INPUT_TYPE &src, Vector &result) {
-		return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(src);
-	}
-	template <typename TARGET_TYPE>
-	static inline TARGET_TYPE Interpolate(const TARGET_TYPE &lo, const double d, const TARGET_TYPE &hi) {
-		const auto delta = hi - lo;
-		return lo + delta * d;
-	}
-};
-
-template <>
-interval_t CastInterpolation::Cast(const dtime_t &src, Vector &result) {
-	return {0, 0, src.micros};
-}
-
-template <>
-double CastInterpolation::Interpolate(const double &lo, const double d, const double &hi) {
-	return lo * (1.0 - d) + hi * d;
-}
-
-template <>
-dtime_t CastInterpolation::Interpolate(const dtime_t &lo, const double d, const dtime_t &hi) {
-	return dtime_t(std::llround(lo.micros * (1.0 - d) + hi.micros * d));
-}
-
-template <>
-timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d, const timestamp_t &hi) {
-	return timestamp_t(std::llround(lo.value * (1.0 - d) + hi.value * d));
-}
-
-template <>
-string_t CastInterpolation::Cast(const std::string &src, Vector &result) {
-	return StringVector::AddString(result, src);
-}
-
-template <>
-string_t CastInterpolation::Cast(const string_t &src, Vector &result) {
-	return StringVector::AddString(result, src);
-}
-
-// Direct access
-template <typename T>
-struct QuantileDirect {
-	using INPUT_TYPE = T;
-	using RESULT_TYPE = T;
-
-	inline const INPUT_TYPE &operator()(const INPUT_TYPE &x) const {
-		return x;
-	}
-};
-
-// Indirect access
-template <typename T>
-struct QuantileIndirect {
-	using INPUT_TYPE = idx_t;
-	using RESULT_TYPE = T;
-	const RESULT_TYPE *data;
-
-	explicit QuantileIndirect(const RESULT_TYPE *data_p) : data(data_p) {
-	}
-
-	inline RESULT_TYPE operator()(const idx_t &input) const {
-		return data[input];
-	}
-};
-
-// Composed access
-template <typename OUTER, typename INNER>
-struct QuantileComposed {
-	using INPUT_TYPE = typename INNER::INPUT_TYPE;
-	using RESULT_TYPE = typename OUTER::RESULT_TYPE;
-
-	const OUTER &outer;
-	const INNER &inner;
-
-	explicit QuantileComposed(const OUTER &outer_p, const INNER &inner_p) : outer(outer_p), inner(inner_p) {
-	}
-
-	inline RESULT_TYPE operator()(const idx_t &input) const {
-		return outer(inner(input));
-	}
-};
-
-// Accessed comparison
-template <typename ACCESSOR>
-struct QuantileLess {
-	using INPUT_TYPE = typename ACCESSOR::INPUT_TYPE;
-	const ACCESSOR &accessor;
-	explicit QuantileLess(const ACCESSOR &accessor_p) : accessor(accessor_p) {
-	}
-
-	inline bool operator()(const INPUT_TYPE &lhs, const INPUT_TYPE &rhs) const {
-		return accessor(lhs) < accessor(rhs);
-	}
-};
-
-// Continuous interpolation
-template <bool DISCRETE>
-struct Interpolator {
-	Interpolator(const double q, const idx_t n_p)
-	    : n(n_p), RN((double)(n_p - 1) * q), FRN(floor(RN)), CRN(ceil(RN)), begin(0), end(n_p) {
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	TARGET_TYPE Operation(INPUT_TYPE *v_t, Vector &result, const ACCESSOR &accessor = ACCESSOR()) const {
-		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		QuantileLess<ACCESSOR> comp(accessor);
-		if (CRN == FRN) {
-			std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
-			return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-		} else {
-			std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
-			std::nth_element(v_t + FRN, v_t + CRN, v_t + end, comp);
-			auto lo = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-			auto hi = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[CRN]), result);
-			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
-		}
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	TARGET_TYPE Replace(const INPUT_TYPE *v_t, Vector &result, const ACCESSOR &accessor = ACCESSOR()) const {
-		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		if (CRN == FRN) {
-			return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-		} else {
-			auto lo = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-			auto hi = CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[CRN]), result);
-			return CastInterpolation::Interpolate<TARGET_TYPE>(lo, RN - FRN, hi);
-		}
-	}
-
-	const idx_t n;
-	const double RN;
-	const idx_t FRN;
-	const idx_t CRN;
-
-	idx_t begin;
-	idx_t end;
-};
-
-// Discrete "interpolation"
-template <>
-struct Interpolator<true> {
-	Interpolator(const double q, const idx_t n_p)
-	    : n(n_p), RN((double)(n_p - 1) * q), FRN(floor(RN)), CRN(FRN), begin(0), end(n_p) {
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	TARGET_TYPE Operation(INPUT_TYPE *v_t, Vector &result, const ACCESSOR &accessor = ACCESSOR()) const {
-		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		QuantileLess<ACCESSOR> comp(accessor);
-		std::nth_element(v_t + begin, v_t + FRN, v_t + end, comp);
-		return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-	}
-
-	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
-	TARGET_TYPE Replace(const INPUT_TYPE *v_t, Vector &result, const ACCESSOR &accessor = ACCESSOR()) const {
-		using ACCESS_TYPE = typename ACCESSOR::RESULT_TYPE;
-		return CastInterpolation::Cast<ACCESS_TYPE, TARGET_TYPE>(accessor(v_t[FRN]), result);
-	}
-
-	const idx_t n;
-	const double RN;
-	const idx_t FRN;
-	const idx_t CRN;
-
-	idx_t begin;
-	idx_t end;
-};
-
-struct QuantileBindData : public FunctionData {
-	explicit QuantileBindData(double quantile_p) : quantiles(1, quantile_p), order(1, 0) {
-	}
-
-	explicit QuantileBindData(const vector<double> &quantiles_p) : quantiles(quantiles_p) {
-		for (idx_t i = 0; i < quantiles.size(); ++i) {
-			order.push_back(i);
-		}
-
-		IndirectLess<double> lt(quantiles.data());
-		std::sort(order.begin(), order.end(), lt);
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<QuantileBindData>(quantiles);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (QuantileBindData &)other_p;
-		return quantiles == other.quantiles && order == other.order;
-	}
-
-	vector<double> quantiles;
-	vector<idx_t> order;
-};
-
-struct QuantileOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		new (state) STATE;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
-		state->v.emplace_back(data[idx]);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.v.empty()) {
-			return;
-		}
-		target->v.insert(target->v.end(), source.v.begin(), source.v.end());
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		state->~STATE();
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-template <class STATE_TYPE, class RESULT_TYPE, class OP>
-static void ExecuteListFinalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result,
-                                idx_t count, // NOLINT
-                                idx_t offset) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-	D_ASSERT(aggr_input_data.bind_data);
-	auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
-
-	if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ListVector::Reserve(result, bind_data->quantiles.size());
-
-		auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-		auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
-		auto &mask = ConstantVector::Validity(result);
-		OP::template Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[0], rdata, mask, 0);
-	} else {
-		D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		ListVector::Reserve(result, (offset + count) * bind_data->quantiles.size());
-
-		auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-		auto &mask = FlatVector::Validity(result);
-		for (idx_t i = 0; i < count; i++) {
-			OP::template Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata, mask, i + offset);
-		}
-	}
-
-	result.Verify(count);
-}
-
-template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-static AggregateFunction QuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) { // NOLINT
-	LogicalType result_type = LogicalType::LIST(child_type);
-	return AggregateFunction(
-	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-	    AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	    ExecuteListFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>, nullptr,
-	    AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-template <bool DISCRETE>
-struct QuantileScalarOperation : public QuantileOperation {
-
-	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, RESULT_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->v.empty()) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
-		D_ASSERT(bind_data->quantiles.size() == 1);
-		Interpolator<DISCRETE> interp(bind_data->quantiles[0], state->v.size());
-		target[idx] = interp.template Operation<typename STATE::SaveType, RESULT_TYPE>(state->v.data(), result);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   AggregateInputData &aggr_input_data, STATE *state, const FrameBounds &frame,
-	                   const FrameBounds &prev, Vector &result, idx_t ridx, idx_t bias) {
-		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
-
-		QuantileIncluded included(fmask, dmask, bias);
-
-		//  Lazily initialise frame state
-		auto prev_pos = state->pos;
-		state->SetPos(frame.second - frame.first);
-
-		auto index = state->w.data();
-		D_ASSERT(index);
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
-
-		// Find the two positions needed
-		const auto q = bind_data->quantiles[0];
-
-		bool replace = false;
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
-			//  Fixed frame size
-			const auto j = ReplaceIndex(index, frame, prev);
-			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
-				Interpolator<DISCRETE> interp(q, prev_pos);
-				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
-				if (replace) {
-					state->pos = prev_pos;
-				}
-			}
-		} else {
-			ReuseIndexes(index, frame, prev);
-		}
-
-		if (!replace && !included.AllValid()) {
-			// Remove the NULLs
-			state->pos = std::partition(index, index + state->pos, included) - index;
-		}
-		if (state->pos) {
-			Interpolator<DISCRETE> interp(q, state->pos);
-
-			using ID = QuantileIndirect<INPUT_TYPE>;
-			ID indirect(data);
-			rdata[ridx] = replace ? interp.template Replace<idx_t, RESULT_TYPE, ID>(index, result, indirect)
-			                      : interp.template Operation<idx_t, RESULT_TYPE, ID>(index, result, indirect);
-		} else {
-			rmask.Set(ridx, false);
-		}
-	}
-};
-
-template <typename INPUT_TYPE, typename SAVED_TYPE>
-AggregateFunction GetTypedDiscreteQuantileAggregateFunction(const LogicalType &type) {
-	using STATE = QuantileState<SAVED_TYPE>;
-	using OP = QuantileScalarOperation<true>;
-	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, INPUT_TYPE, OP>(type, type);
-	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, INPUT_TYPE, OP>;
-	return fun;
-}
-
-AggregateFunction GetDiscreteQuantileAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return GetTypedDiscreteQuantileAggregateFunction<int8_t, int8_t>(type);
-	case LogicalTypeId::SMALLINT:
-		return GetTypedDiscreteQuantileAggregateFunction<int16_t, int16_t>(type);
-	case LogicalTypeId::INTEGER:
-		return GetTypedDiscreteQuantileAggregateFunction<int32_t, int32_t>(type);
-	case LogicalTypeId::BIGINT:
-		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
-	case LogicalTypeId::HUGEINT:
-		return GetTypedDiscreteQuantileAggregateFunction<hugeint_t, hugeint_t>(type);
-
-	case LogicalTypeId::FLOAT:
-		return GetTypedDiscreteQuantileAggregateFunction<float, float>(type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedDiscreteQuantileAggregateFunction<double, double>(type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedDiscreteQuantileAggregateFunction<int16_t, int16_t>(type);
-		case PhysicalType::INT32:
-			return GetTypedDiscreteQuantileAggregateFunction<int32_t, int32_t>(type);
-		case PhysicalType::INT64:
-			return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
-		case PhysicalType::INT128:
-			return GetTypedDiscreteQuantileAggregateFunction<hugeint_t, hugeint_t>(type);
-		default:
-			throw NotImplementedException("Unimplemented discrete quantile aggregate");
-		}
-		break;
-
-	case LogicalTypeId::DATE:
-		return GetTypedDiscreteQuantileAggregateFunction<int32_t, int32_t>(type);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
-	case LogicalTypeId::INTERVAL:
-		return GetTypedDiscreteQuantileAggregateFunction<interval_t, interval_t>(type);
-
-	case LogicalTypeId::VARCHAR:
-		return GetTypedDiscreteQuantileAggregateFunction<string_t, std::string>(type);
-
-	default:
-		throw NotImplementedException("Unimplemented discrete quantile aggregate");
-	}
-}
-
-template <class CHILD_TYPE, bool DISCRETE>
-struct QuantileListOperation : public QuantileOperation {
-
-	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result_list, AggregateInputData &aggr_input_data, STATE *state, RESULT_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->v.empty()) {
-			mask.SetInvalid(idx);
-			return;
-		}
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
-
-		auto &result = ListVector::GetEntry(result_list);
-		auto ridx = ListVector::GetListSize(result_list);
-		ListVector::Reserve(result_list, ridx + bind_data->quantiles.size());
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		auto v_t = state->v.data();
-		D_ASSERT(v_t);
-
-		auto &entry = target[idx];
-		entry.offset = ridx;
-		idx_t lower = 0;
-		for (const auto &q : bind_data->order) {
-			const auto &quantile = bind_data->quantiles[q];
-			Interpolator<DISCRETE> interp(quantile, state->v.size());
-			interp.begin = lower;
-			rdata[ridx + q] = interp.template Operation<typename STATE::SaveType, CHILD_TYPE>(v_t, result);
-			lower = interp.FRN;
-		}
-		entry.length = bind_data->quantiles.size();
-
-		ListVector::SetListSize(result_list, entry.offset + entry.length);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   AggregateInputData &aggr_input_data, STATE *state, const FrameBounds &frame,
-	                   const FrameBounds &prev, Vector &list, idx_t lidx, idx_t bias) {
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
-
-		QuantileIncluded included(fmask, dmask, bias);
-
-		// Result is a constant LIST<RESULT_TYPE> with a fixed length
-		auto ldata = FlatVector::GetData<RESULT_TYPE>(list);
-		auto &lmask = FlatVector::Validity(list);
-		auto &lentry = ldata[lidx];
-		lentry.offset = ListVector::GetListSize(list);
-		lentry.length = bind_data->quantiles.size();
-
-		ListVector::Reserve(list, lentry.offset + lentry.length);
-		ListVector::SetListSize(list, lentry.offset + lentry.length);
-		auto &result = ListVector::GetEntry(list);
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		//  Lazily initialise frame state
-		auto prev_pos = state->pos;
-		state->SetPos(frame.second - frame.first);
-
-		auto index = state->w.data();
-
-		// We can generalise replacement for quantile lists by observing that when a replacement is
-		// valid for a single quantile, it is valid for all quantiles greater/less than that quantile
-		// based on whether the insertion is below/above the quantile location.
-		// So if a replaced index in an IQR is located between Q25 and Q50, but has a value below Q25,
-		// then Q25 must be recomputed, but Q50 and Q75 are unaffected.
-		// For a single element list, this reduces to the scalar case.
-		std::pair<idx_t, idx_t> replaceable {state->pos, 0};
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
-			//  Fixed frame size
-			const auto j = ReplaceIndex(index, frame, prev);
-			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
-				for (const auto &q : bind_data->order) {
-					const auto &quantile = bind_data->quantiles[q];
-					Interpolator<DISCRETE> interp(quantile, prev_pos);
-					const auto replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
-					if (replace < 0) {
-						//	Replacement is before this quantile, so the rest will be replaceable too.
-						replaceable.first = MinValue(replaceable.first, interp.FRN);
-						replaceable.second = prev_pos;
-						break;
-					} else if (replace > 0) {
-						//	Replacement is after this quantile, so everything before it is replaceable too.
-						replaceable.first = 0;
-						replaceable.second = MaxValue(replaceable.second, interp.CRN);
-					}
-				}
-				if (replaceable.first < replaceable.second) {
-					state->pos = prev_pos;
-				}
-			}
-		} else {
-			ReuseIndexes(index, frame, prev);
-		}
-
-		if (replaceable.first >= replaceable.second && !included.AllValid()) {
-			// Remove the NULLs
-			state->pos = std::partition(index, index + state->pos, included) - index;
-		}
-
-		if (state->pos) {
-			using ID = QuantileIndirect<INPUT_TYPE>;
-			ID indirect(data);
-			for (const auto &q : bind_data->order) {
-				const auto &quantile = bind_data->quantiles[q];
-				Interpolator<DISCRETE> interp(quantile, state->pos);
-				if (replaceable.first <= interp.FRN && interp.CRN <= replaceable.second) {
-					rdata[lentry.offset + q] = interp.template Replace<idx_t, CHILD_TYPE, ID>(index, result, indirect);
-				} else {
-					// Make sure we don't disturb any replacements
-					if (replaceable.first < replaceable.second) {
-						if (interp.FRN < replaceable.first) {
-							interp.end = replaceable.first;
-						}
-						if (replaceable.second < interp.CRN) {
-							interp.begin = replaceable.second;
-						}
-					}
-					rdata[lentry.offset + q] =
-					    interp.template Operation<idx_t, CHILD_TYPE, ID>(index, result, indirect);
-				}
-			}
-		} else {
-			lmask.Set(lidx, false);
-		}
-	}
-};
-
-template <typename INPUT_TYPE, typename SAVE_TYPE>
-AggregateFunction GetTypedDiscreteQuantileListAggregateFunction(const LogicalType &type) {
-	using STATE = QuantileState<SAVE_TYPE>;
-	using OP = QuantileListOperation<INPUT_TYPE, true>;
-	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
-	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
-	return fun;
-}
-
-AggregateFunction GetDiscreteQuantileListAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return GetTypedDiscreteQuantileListAggregateFunction<int8_t, int8_t>(type);
-	case LogicalTypeId::SMALLINT:
-		return GetTypedDiscreteQuantileListAggregateFunction<int16_t, int16_t>(type);
-	case LogicalTypeId::INTEGER:
-		return GetTypedDiscreteQuantileListAggregateFunction<int32_t, int32_t>(type);
-	case LogicalTypeId::BIGINT:
-		return GetTypedDiscreteQuantileListAggregateFunction<int64_t, int64_t>(type);
-	case LogicalTypeId::HUGEINT:
-		return GetTypedDiscreteQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-
-	case LogicalTypeId::FLOAT:
-		return GetTypedDiscreteQuantileListAggregateFunction<float, float>(type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedDiscreteQuantileListAggregateFunction<double, double>(type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedDiscreteQuantileListAggregateFunction<int16_t, int16_t>(type);
-		case PhysicalType::INT32:
-			return GetTypedDiscreteQuantileListAggregateFunction<int32_t, int32_t>(type);
-		case PhysicalType::INT64:
-			return GetTypedDiscreteQuantileListAggregateFunction<int64_t, int64_t>(type);
-		case PhysicalType::INT128:
-			return GetTypedDiscreteQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-		default:
-			throw NotImplementedException("Unimplemented discrete quantile list aggregate");
-		}
-		break;
-
-	case LogicalTypeId::DATE:
-		return GetTypedDiscreteQuantileListAggregateFunction<date_t, date_t>(type);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return GetTypedDiscreteQuantileListAggregateFunction<timestamp_t, timestamp_t>(type);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return GetTypedDiscreteQuantileListAggregateFunction<dtime_t, dtime_t>(type);
-	case LogicalTypeId::INTERVAL:
-		return GetTypedDiscreteQuantileListAggregateFunction<interval_t, interval_t>(type);
-
-	case LogicalTypeId::VARCHAR:
-		return GetTypedDiscreteQuantileListAggregateFunction<string_t, std::string>(type);
-
-	default:
-		throw NotImplementedException("Unimplemented discrete quantile list aggregate");
-	}
-}
-
-template <typename INPUT_TYPE, typename TARGET_TYPE>
-AggregateFunction GetTypedContinuousQuantileAggregateFunction(const LogicalType &input_type,
-                                                              const LogicalType &target_type) {
-	using STATE = QuantileState<INPUT_TYPE>;
-	using OP = QuantileScalarOperation<false>;
-	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
-	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
-	return fun;
-}
-
-AggregateFunction GetContinuousQuantileAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return GetTypedContinuousQuantileAggregateFunction<int8_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::SMALLINT:
-		return GetTypedContinuousQuantileAggregateFunction<int16_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::INTEGER:
-		return GetTypedContinuousQuantileAggregateFunction<int32_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::BIGINT:
-		return GetTypedContinuousQuantileAggregateFunction<int64_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::HUGEINT:
-		return GetTypedContinuousQuantileAggregateFunction<hugeint_t, double>(type, LogicalType::DOUBLE);
-
-	case LogicalTypeId::FLOAT:
-		return GetTypedContinuousQuantileAggregateFunction<float, float>(type, type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedContinuousQuantileAggregateFunction<double, double>(type, type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedContinuousQuantileAggregateFunction<int16_t, int16_t>(type, type);
-		case PhysicalType::INT32:
-			return GetTypedContinuousQuantileAggregateFunction<int32_t, int32_t>(type, type);
-		case PhysicalType::INT64:
-			return GetTypedContinuousQuantileAggregateFunction<int64_t, int64_t>(type, type);
-		case PhysicalType::INT128:
-			return GetTypedContinuousQuantileAggregateFunction<hugeint_t, hugeint_t>(type, type);
-		default:
-			throw NotImplementedException("Unimplemented continuous quantile DECIMAL aggregate");
-		}
-		break;
-
-	case LogicalTypeId::DATE:
-		return GetTypedContinuousQuantileAggregateFunction<date_t, timestamp_t>(type, LogicalType::TIMESTAMP);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return GetTypedContinuousQuantileAggregateFunction<timestamp_t, timestamp_t>(type, type);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return GetTypedContinuousQuantileAggregateFunction<dtime_t, dtime_t>(type, type);
-
-	default:
-		throw NotImplementedException("Unimplemented continuous quantile aggregate");
-	}
-}
-
-template <typename INPUT_TYPE, typename CHILD_TYPE>
-AggregateFunction GetTypedContinuousQuantileListAggregateFunction(const LogicalType &input_type,
-                                                                  const LogicalType &result_type) {
-	using STATE = QuantileState<INPUT_TYPE>;
-	using OP = QuantileListOperation<CHILD_TYPE, false>;
-	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(input_type, result_type);
-	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
-	return fun;
-}
-
-AggregateFunction GetContinuousQuantileListAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return GetTypedContinuousQuantileListAggregateFunction<int8_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::SMALLINT:
-		return GetTypedContinuousQuantileListAggregateFunction<int16_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::INTEGER:
-		return GetTypedContinuousQuantileListAggregateFunction<int32_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::BIGINT:
-		return GetTypedContinuousQuantileListAggregateFunction<int64_t, double>(type, LogicalType::DOUBLE);
-	case LogicalTypeId::HUGEINT:
-		return GetTypedContinuousQuantileListAggregateFunction<hugeint_t, double>(type, LogicalType::DOUBLE);
-
-	case LogicalTypeId::FLOAT:
-		return GetTypedContinuousQuantileListAggregateFunction<float, float>(type, type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedContinuousQuantileListAggregateFunction<double, double>(type, type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedContinuousQuantileListAggregateFunction<int16_t, int16_t>(type, type);
-		case PhysicalType::INT32:
-			return GetTypedContinuousQuantileListAggregateFunction<int32_t, int32_t>(type, type);
-		case PhysicalType::INT64:
-			return GetTypedContinuousQuantileListAggregateFunction<int64_t, int64_t>(type, type);
-		case PhysicalType::INT128:
-			return GetTypedContinuousQuantileListAggregateFunction<hugeint_t, hugeint_t>(type, type);
-		default:
-			throw NotImplementedException("Unimplemented discrete quantile DECIMAL list aggregate");
-		}
-		break;
-
-	case LogicalTypeId::DATE:
-		return GetTypedContinuousQuantileListAggregateFunction<date_t, timestamp_t>(type, LogicalType::TIMESTAMP);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return GetTypedContinuousQuantileListAggregateFunction<timestamp_t, timestamp_t>(type, type);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return GetTypedContinuousQuantileListAggregateFunction<dtime_t, dtime_t>(type, type);
-
-	default:
-		throw NotImplementedException("Unimplemented discrete quantile list aggregate");
-	}
-}
-
-template <typename T, typename R, typename MEDIAN_TYPE>
-struct MadAccessor {
-	using INPUT_TYPE = T;
-	using RESULT_TYPE = R;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto delta = input - median;
-		return TryAbsOperator::Operation<RESULT_TYPE, RESULT_TYPE>(delta);
-	}
-};
-
-// hugeint_t - double => undefined
-template <>
-struct MadAccessor<hugeint_t, double, double> {
-	using INPUT_TYPE = hugeint_t;
-	using RESULT_TYPE = double;
-	using MEDIAN_TYPE = double;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto delta = Hugeint::Cast<double>(input) - median;
-		return TryAbsOperator::Operation<double, double>(delta);
-	}
-};
-
-// date_t - timestamp_t => interval_t
-template <>
-struct MadAccessor<date_t, interval_t, timestamp_t> {
-	using INPUT_TYPE = date_t;
-	using RESULT_TYPE = interval_t;
-	using MEDIAN_TYPE = timestamp_t;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto dt = Cast::Operation<date_t, timestamp_t>(input);
-		const auto delta = dt - median;
-		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
-	}
-};
-
-// timestamp_t - timestamp_t => int64_t
-template <>
-struct MadAccessor<timestamp_t, interval_t, timestamp_t> {
-	using INPUT_TYPE = timestamp_t;
-	using RESULT_TYPE = interval_t;
-	using MEDIAN_TYPE = timestamp_t;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto delta = input - median;
-		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
-	}
-};
-
-// dtime_t - dtime_t => int64_t
-template <>
-struct MadAccessor<dtime_t, interval_t, dtime_t> {
-	using INPUT_TYPE = dtime_t;
-	using RESULT_TYPE = interval_t;
-	using MEDIAN_TYPE = dtime_t;
-	const MEDIAN_TYPE &median;
-	explicit MadAccessor(const MEDIAN_TYPE &median_p) : median(median_p) {
-	}
-	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
-		const auto delta = input - median;
-		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
-	}
-};
-
-template <typename MEDIAN_TYPE>
-struct MedianAbsoluteDeviationOperation : public QuantileOperation {
-
-	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, RESULT_TYPE *target, ValidityMask &mask,
-	                     idx_t idx) {
-		if (state->v.empty()) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		using SAVE_TYPE = typename STATE::SaveType;
-		Interpolator<false> interp(0.5, state->v.size());
-		const auto med = interp.template Operation<SAVE_TYPE, MEDIAN_TYPE>(state->v.data(), result);
-
-		MadAccessor<SAVE_TYPE, RESULT_TYPE, MEDIAN_TYPE> accessor(med);
-		target[idx] = interp.template Operation<SAVE_TYPE, RESULT_TYPE>(state->v.data(), result, accessor);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
-	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   AggregateInputData &, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
-	                   Vector &result, idx_t ridx, idx_t bias) {
-		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
-
-		QuantileIncluded included(fmask, dmask, bias);
-
-		//  Lazily initialise frame state
-		auto prev_pos = state->pos;
-		state->SetPos(frame.second - frame.first);
-
-		auto index = state->w.data();
-		D_ASSERT(index);
-
-		// We need a second index for the second pass.
-		if (state->pos > state->m.size()) {
-			state->m.resize(state->pos);
-		}
-
-		auto index2 = state->m.data();
-		D_ASSERT(index2);
-
-		// The replacement trick does not work on the second index because if
-		// the median has changed, the previous order is not correct.
-		// It is probably close, however, and so reuse is helpful.
-		ReuseIndexes(index2, frame, prev);
-		std::partition(index2, index2 + state->pos, included);
-
-		// Find the two positions needed for the median
-		const float q = 0.5;
-
-		bool replace = false;
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
-			//  Fixed frame size
-			const auto j = ReplaceIndex(index, frame, prev);
-			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
-				Interpolator<false> interp(q, prev_pos);
-				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
-				if (replace) {
-					state->pos = prev_pos;
-				}
-			}
-		} else {
-			ReuseIndexes(index, frame, prev);
-		}
-
-		if (!replace && !included.AllValid()) {
-			// Remove the NULLs
-			state->pos = std::partition(index, index + state->pos, included) - index;
-		}
-
-		if (state->pos) {
-			Interpolator<false> interp(q, state->pos);
-
-			// Compute or replace median from the first index
-			using ID = QuantileIndirect<INPUT_TYPE>;
-			ID indirect(data);
-			const auto med = replace ? interp.template Replace<idx_t, MEDIAN_TYPE, ID>(index, result, indirect)
-			                         : interp.template Operation<idx_t, MEDIAN_TYPE, ID>(index, result, indirect);
-
-			// Compute mad from the second index
-			using MAD = MadAccessor<INPUT_TYPE, RESULT_TYPE, MEDIAN_TYPE>;
-			MAD mad(med);
-
-			using MadIndirect = QuantileComposed<MAD, ID>;
-			MadIndirect mad_indirect(mad, indirect);
-			rdata[ridx] = interp.template Operation<idx_t, RESULT_TYPE, MadIndirect>(index2, result, mad_indirect);
-		} else {
-			rmask.Set(ridx, false);
-		}
-	}
-};
-
-template <typename INPUT_TYPE, typename MEDIAN_TYPE, typename TARGET_TYPE>
-AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const LogicalType &input_type,
-                                                                   const LogicalType &target_type) {
-	using STATE = QuantileState<INPUT_TYPE>;
-	using OP = MedianAbsoluteDeviationOperation<MEDIAN_TYPE>;
-	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
-	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
-	return fun;
-}
-
-AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::FLOAT:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<float, float, float>(type, type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<double, double, double>(type, type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedMedianAbsoluteDeviationAggregateFunction<int16_t, int16_t, int16_t>(type, type);
-		case PhysicalType::INT32:
-			return GetTypedMedianAbsoluteDeviationAggregateFunction<int32_t, int32_t, int32_t>(type, type);
-		case PhysicalType::INT64:
-			return GetTypedMedianAbsoluteDeviationAggregateFunction<int64_t, int64_t, int64_t>(type, type);
-		case PhysicalType::INT128:
-			return GetTypedMedianAbsoluteDeviationAggregateFunction<hugeint_t, hugeint_t, hugeint_t>(type, type);
-		default:
-			throw NotImplementedException("Unimplemented Median Absolute Deviation DECIMAL aggregate");
-		}
-		break;
-
-	case LogicalTypeId::DATE:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<date_t, timestamp_t, interval_t>(type,
-		                                                                                         LogicalType::INTERVAL);
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<timestamp_t, timestamp_t, interval_t>(
-		    type, LogicalType::INTERVAL);
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return GetTypedMedianAbsoluteDeviationAggregateFunction<dtime_t, dtime_t, interval_t>(type,
-		                                                                                      LogicalType::INTERVAL);
-
-	default:
-		throw NotImplementedException("Unimplemented Median Absolute Deviation aggregate");
-	}
-}
-
-unique_ptr<FunctionData> BindMedian(ClientContext &context, AggregateFunction &function,
-                                    vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<QuantileBindData>(0.5);
-}
-
-unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunction &function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindMedian(context, function, arguments);
-
-	function = GetDiscreteQuantileAggregateFunction(arguments[0]->return_type);
-	function.name = "median";
-	return bind_data;
-}
-
-unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &context, AggregateFunction &function,
-                                                            vector<unique_ptr<Expression>> &arguments) {
-	function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type);
-	function.name = "mad";
-	return nullptr;
-}
-
-static double CheckQuantile(const Value &quantile_val) {
-	auto quantile = quantile_val.GetValue<double>();
-
-	if (quantile_val.IsNull() || quantile < 0 || quantile > 1) {
-		throw BinderException("QUANTILE can only take parameters in the range [0, 1]");
-	}
-
-	return quantile;
-}
-
-unique_ptr<FunctionData> BindQuantile(ClientContext &context, AggregateFunction &function,
-                                      vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[1]->IsFoldable()) {
-		throw BinderException("QUANTILE can only take constant parameters");
-	}
-	Value quantile_val = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-	vector<double> quantiles;
-	if (quantile_val.type().id() != LogicalTypeId::LIST) {
-		quantiles.push_back(CheckQuantile(quantile_val));
-	} else {
-		for (const auto &element_val : ListValue::GetChildren(quantile_val)) {
-			quantiles.push_back(CheckQuantile(element_val));
-		}
-	}
-
-	arguments.pop_back();
-	return make_unique<QuantileBindData>(quantiles);
-}
-
-unique_ptr<FunctionData> BindDiscreteQuantileDecimal(ClientContext &context, AggregateFunction &function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindQuantile(context, function, arguments);
-	function = GetDiscreteQuantileAggregateFunction(arguments[0]->return_type);
-	function.name = "quantile_disc";
-	return bind_data;
-}
-
-unique_ptr<FunctionData> BindDiscreteQuantileDecimalList(ClientContext &context, AggregateFunction &function,
-                                                         vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindQuantile(context, function, arguments);
-	function = GetDiscreteQuantileListAggregateFunction(arguments[0]->return_type);
-	function.name = "quantile_disc";
-	return bind_data;
-}
-
-unique_ptr<FunctionData> BindContinuousQuantileDecimal(ClientContext &context, AggregateFunction &function,
-                                                       vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindQuantile(context, function, arguments);
-	function = GetContinuousQuantileAggregateFunction(arguments[0]->return_type);
-	function.name = "quantile_cont";
-	return bind_data;
-}
-
-unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &context, AggregateFunction &function,
-                                                           vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindQuantile(context, function, arguments);
-	function = GetContinuousQuantileListAggregateFunction(arguments[0]->return_type);
-	function.name = "quantile_cont";
-	return bind_data;
-}
-
-static bool CanInterpolate(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::INTERVAL:
-	case LogicalTypeId::VARCHAR:
-		return false;
-	default:
-		return true;
-	}
-}
-
-AggregateFunction GetMedianAggregate(const LogicalType &type) {
-	auto fun = CanInterpolate(type) ? GetContinuousQuantileAggregateFunction(type)
-	                                : GetDiscreteQuantileAggregateFunction(type);
-	fun.bind = BindMedian;
-	return fun;
-}
-
-AggregateFunction GetDiscreteQuantileAggregate(const LogicalType &type) {
-	auto fun = GetDiscreteQuantileAggregateFunction(type);
-	fun.bind = BindQuantile;
-	// temporarily push an argument so we can bind the actual quantile
-	fun.arguments.emplace_back(LogicalType::DOUBLE);
-	return fun;
-}
-
-AggregateFunction GetDiscreteQuantileListAggregate(const LogicalType &type) {
-	auto fun = GetDiscreteQuantileListAggregateFunction(type);
-	fun.bind = BindQuantile;
-	// temporarily push an argument so we can bind the actual quantile
-	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
-	fun.arguments.push_back(list_of_double);
-	return fun;
-}
-
-AggregateFunction GetContinuousQuantileAggregate(const LogicalType &type) {
-	auto fun = GetContinuousQuantileAggregateFunction(type);
-	fun.bind = BindQuantile;
-	// temporarily push an argument so we can bind the actual quantile
-	fun.arguments.emplace_back(LogicalType::DOUBLE);
-	return fun;
-}
-
-AggregateFunction GetContinuousQuantileListAggregate(const LogicalType &type) {
-	auto fun = GetContinuousQuantileListAggregateFunction(type);
-	fun.bind = BindQuantile;
-	// temporarily push an argument so we can bind the actual quantile
-	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
-	fun.arguments.push_back(list_of_double);
-	return fun;
-}
-
-void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
-	const vector<LogicalType> QUANTILES = {LogicalType::TINYINT,  LogicalType::SMALLINT,     LogicalType::INTEGER,
-	                                       LogicalType::BIGINT,   LogicalType::HUGEINT,      LogicalType::FLOAT,
-	                                       LogicalType::DOUBLE,   LogicalType::DATE,         LogicalType::TIMESTAMP,
-	                                       LogicalType::TIME,     LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,
-	                                       LogicalType::INTERVAL, LogicalType::VARCHAR};
-
-	AggregateFunctionSet median("median");
-	median.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                     nullptr, nullptr, nullptr, BindMedianDecimal));
-
-	AggregateFunctionSet quantile_disc("quantile_disc");
-	quantile_disc.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::DOUBLE}, LogicalTypeId::DECIMAL,
-	                                            nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                                            BindDiscreteQuantileDecimal));
-	quantile_disc.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::DOUBLE)},
-	                                            LogicalType::LIST(LogicalTypeId::DECIMAL), nullptr, nullptr, nullptr,
-	                                            nullptr, nullptr, nullptr, BindDiscreteQuantileDecimalList));
-
-	AggregateFunctionSet quantile_cont("quantile_cont");
-	quantile_cont.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::DOUBLE}, LogicalTypeId::DECIMAL,
-	                                            nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-	                                            BindContinuousQuantileDecimal));
-	quantile_cont.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::DOUBLE)},
-	                                            LogicalType::LIST(LogicalTypeId::DECIMAL), nullptr, nullptr, nullptr,
-	                                            nullptr, nullptr, nullptr, BindContinuousQuantileDecimalList));
-
-	for (const auto &type : QUANTILES) {
-		median.AddFunction(GetMedianAggregate(type));
-		quantile_disc.AddFunction(GetDiscreteQuantileAggregate(type));
-		quantile_disc.AddFunction(GetDiscreteQuantileListAggregate(type));
-		if (CanInterpolate(type)) {
-			quantile_cont.AddFunction(GetContinuousQuantileAggregate(type));
-			quantile_cont.AddFunction(GetContinuousQuantileListAggregate(type));
-		}
-	}
-
-	set.AddFunction(median);
-	set.AddFunction(quantile_disc);
-	set.AddFunction(quantile_cont);
-
-	quantile_disc.name = "quantile";
-	set.AddFunction(quantile_disc);
-
-	AggregateFunctionSet mad("mad");
-	mad.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, nullptr, BindMedianAbsoluteDeviationDecimal));
-
-	const vector<LogicalType> MADS = {LogicalType::FLOAT,     LogicalType::DOUBLE, LogicalType::DATE,
-	                                  LogicalType::TIMESTAMP, LogicalType::TIME,   LogicalType::TIMESTAMP_TZ,
-	                                  LogicalType::TIME_TZ};
-	for (const auto &type : MADS) {
-		mad.AddFunction(GetMedianAbsoluteDeviationAggregateFunction(type));
-	}
-	set.AddFunction(mad);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#include <algorithm>
-#include <stdlib.h>
-
-namespace duckdb {
-
-template <typename T>
-struct ReservoirQuantileState {
-	T *v;
-	idx_t len;
-	idx_t pos;
-	BaseReservoirSampling *r_samp;
-
-	void Resize(idx_t new_len) {
-		if (new_len <= len) {
-			return;
-		}
-		v = (T *)realloc(v, new_len * sizeof(T));
-		if (!v) {
-			throw InternalException("Memory allocation failure");
-		}
-		len = new_len;
-	}
-
-	void ReplaceElement(T &input) {
-		v[r_samp->min_entry] = input;
-		r_samp->ReplaceElement();
-	}
-
-	void FillReservoir(idx_t sample_size, T element) {
-		if (pos < sample_size) {
-			v[pos++] = element;
-			r_samp->InitializeReservoir(pos, len);
-		} else {
-			D_ASSERT(r_samp->next_index >= r_samp->current_count);
-			if (r_samp->next_index == r_samp->current_count) {
-				ReplaceElement(element);
-			}
-		}
-	}
-};
-
-struct ReservoirQuantileBindData : public FunctionData {
-	ReservoirQuantileBindData(double quantile_p, int32_t sample_size_p)
-	    : quantiles(1, quantile_p), sample_size(sample_size_p) {
-	}
-
-	ReservoirQuantileBindData(const vector<double> &quantiles_p, int32_t sample_size_p)
-	    : quantiles(quantiles_p), sample_size(sample_size_p) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ReservoirQuantileBindData>(quantiles, sample_size);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (ReservoirQuantileBindData &)other_p;
-		return quantiles == other.quantiles && sample_size == other.sample_size;
-	}
-
-	vector<double> quantiles;
-	int32_t sample_size;
-};
-
-struct ReservoirQuantileOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->v = nullptr;
-		state->len = 0;
-		state->pos = 0;
-		state->r_samp = nullptr;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
-		}
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *data, ValidityMask &mask,
-	                      idx_t idx) {
-		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
-		D_ASSERT(bind_data);
-		if (state->pos == 0) {
-			state->Resize(bind_data->sample_size);
-		}
-		if (!state->r_samp) {
-			state->r_samp = new BaseReservoirSampling();
-		}
-		D_ASSERT(state->v);
-		state->FillReservoir(bind_data->sample_size, data[idx]);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.pos == 0) {
-			return;
-		}
-		if (target->pos == 0) {
-			target->Resize(source.len);
-		}
-		if (!target->r_samp) {
-			target->r_samp = new BaseReservoirSampling();
-		}
-		for (idx_t src_idx = 0; src_idx < source.pos; src_idx++) {
-			target->FillReservoir(target->len, source.v[src_idx]);
-		}
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->v) {
-			free(state->v);
-			state->v = nullptr;
-		}
-		if (state->r_samp) {
-			delete state->r_samp;
-			state->r_samp = nullptr;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct ReservoirQuantileScalarOperation : public ReservoirQuantileOperation {
-	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, TARGET_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->pos == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		D_ASSERT(state->v);
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
-		auto v_t = state->v;
-		D_ASSERT(bind_data->quantiles.size() == 1);
-		auto offset = (idx_t)((double)(state->pos - 1) * bind_data->quantiles[0]);
-		std::nth_element(v_t, v_t + offset, v_t + state->pos);
-		target[idx] = v_t[offset];
-	}
-};
-
-AggregateFunction GetReservoirQuantileAggregateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::INT8:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<int8_t>, int8_t, int8_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::TINYINT,
-		                                                                                     LogicalType::TINYINT);
-
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<int16_t>, int16_t, int16_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::SMALLINT,
-		                                                                                     LogicalType::SMALLINT);
-
-	case PhysicalType::INT32:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<int32_t>, int32_t, int32_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::INTEGER,
-		                                                                                     LogicalType::INTEGER);
-
-	case PhysicalType::INT64:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<int64_t>, int64_t, int64_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::BIGINT,
-		                                                                                     LogicalType::BIGINT);
-
-	case PhysicalType::INT128:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<hugeint_t>, hugeint_t, hugeint_t,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::HUGEINT,
-		                                                                                     LogicalType::HUGEINT);
-	case PhysicalType::FLOAT:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<float>, float, float,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::FLOAT,
-		                                                                                     LogicalType::FLOAT);
-	case PhysicalType::DOUBLE:
-		return AggregateFunction::UnaryAggregateDestructor<ReservoirQuantileState<double>, double, double,
-		                                                   ReservoirQuantileScalarOperation>(LogicalType::DOUBLE,
-		                                                                                     LogicalType::DOUBLE);
-	default:
-		throw InternalException("Unimplemented reservoir quantile aggregate");
-	}
-}
-
-template <class CHILD_TYPE>
-struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
-
-	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result_list, AggregateInputData &aggr_input_data, STATE *state, RESULT_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->pos == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
-
-		auto &result = ListVector::GetEntry(result_list);
-		auto ridx = ListVector::GetListSize(result_list);
-		ListVector::Reserve(result_list, ridx + bind_data->quantiles.size());
-		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
-
-		auto v_t = state->v;
-		D_ASSERT(v_t);
-
-		auto &entry = target[idx];
-		entry.offset = ridx;
-		entry.length = bind_data->quantiles.size();
-		for (size_t q = 0; q < entry.length; ++q) {
-			const auto &quantile = bind_data->quantiles[q];
-			auto offset = (idx_t)((double)(state->pos - 1) * quantile);
-			std::nth_element(v_t, v_t + offset, v_t + state->pos);
-			rdata[ridx + q] = v_t[offset];
-		}
-
-		ListVector::SetListSize(result_list, entry.offset + entry.length);
-	}
-
-	template <class STATE_TYPE, class RESULT_TYPE>
-	static void FinalizeList(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count, // NOLINT
-	                         idx_t offset) {
-		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
-
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ListVector::Reserve(result, bind_data->quantiles.size());
-
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
-			auto &mask = ConstantVector::Validity(result);
-			Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[0], rdata, mask, 0);
-		} else {
-			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			ListVector::Reserve(result, (offset + count) * bind_data->quantiles.size());
-
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-			auto &mask = FlatVector::Validity(result);
-			for (idx_t i = 0; i < count; i++) {
-				Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata, mask, i + offset);
-			}
-		}
-
-		result.Verify(count);
-	}
-};
-
-template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-static AggregateFunction ReservoirQuantileListAggregate(const LogicalType &input_type, const LogicalType &child_type) {
-	LogicalType result_type = LogicalType::LIST(child_type);
-	return AggregateFunction(
-	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-	    AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	    OP::template FinalizeList<STATE, RESULT_TYPE>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>, nullptr,
-	    AggregateFunction::StateDestroy<STATE, OP>);
-}
-
-template <typename INPUT_TYPE, typename SAVE_TYPE>
-AggregateFunction GetTypedReservoirQuantileListAggregateFunction(const LogicalType &type) {
-	using STATE = ReservoirQuantileState<SAVE_TYPE>;
-	using OP = ReservoirQuantileListOperation<INPUT_TYPE>;
-	auto fun = ReservoirQuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
-	return fun;
-}
-
-AggregateFunction GetReservoirQuantileListAggregateFunction(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return GetTypedReservoirQuantileListAggregateFunction<int8_t, int8_t>(type);
-	case LogicalTypeId::SMALLINT:
-		return GetTypedReservoirQuantileListAggregateFunction<int16_t, int16_t>(type);
-	case LogicalTypeId::INTEGER:
-		return GetTypedReservoirQuantileListAggregateFunction<int32_t, int32_t>(type);
-	case LogicalTypeId::BIGINT:
-		return GetTypedReservoirQuantileListAggregateFunction<int64_t, int64_t>(type);
-	case LogicalTypeId::HUGEINT:
-		return GetTypedReservoirQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-
-	case LogicalTypeId::FLOAT:
-		return GetTypedReservoirQuantileListAggregateFunction<float, float>(type);
-	case LogicalTypeId::DOUBLE:
-		return GetTypedReservoirQuantileListAggregateFunction<double, double>(type);
-	case LogicalTypeId::DECIMAL:
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-			return GetTypedReservoirQuantileListAggregateFunction<int16_t, int16_t>(type);
-		case PhysicalType::INT32:
-			return GetTypedReservoirQuantileListAggregateFunction<int32_t, int32_t>(type);
-		case PhysicalType::INT64:
-			return GetTypedReservoirQuantileListAggregateFunction<int64_t, int64_t>(type);
-		case PhysicalType::INT128:
-			return GetTypedReservoirQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
-		default:
-			throw NotImplementedException("Unimplemented reservoir quantile list aggregate");
-		}
-		break;
-
-	default:
-		// TODO: Add quantitative temporal types
-		throw NotImplementedException("Unimplemented reservoir quantile list aggregate");
-	}
-}
-
-static double CheckReservoirQuantile(const Value &quantile_val) {
-	auto quantile = quantile_val.GetValue<double>();
-
-	if (quantile_val.IsNull() || quantile < 0 || quantile > 1) {
-		throw BinderException("RESERVOIR_QUANTILE can only take parameters in the range [0, 1]");
-	}
-
-	return quantile;
-}
-
-unique_ptr<FunctionData> BindReservoirQuantile(ClientContext &context, AggregateFunction &function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[1]->IsFoldable()) {
-		throw BinderException("RESERVOIR_QUANTILE can only take constant quantile parameters");
-	}
-	Value quantile_val = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-	vector<double> quantiles;
-	if (quantile_val.type().id() != LogicalTypeId::LIST) {
-		quantiles.push_back(CheckReservoirQuantile(quantile_val));
-	} else {
-		for (const auto &element_val : ListValue::GetChildren(quantile_val)) {
-			quantiles.push_back(CheckReservoirQuantile(element_val));
-		}
-	}
-
-	if (arguments.size() <= 2) {
-		arguments.pop_back();
-		return make_unique<ReservoirQuantileBindData>(quantiles, 8192);
-	}
-	if (!arguments[2]->IsFoldable()) {
-		throw BinderException("RESERVOIR_QUANTILE can only take constant sample size parameters");
-	}
-	Value sample_size_val = ExpressionExecutor::EvaluateScalar(*arguments[2]);
-	auto sample_size = sample_size_val.GetValue<int32_t>();
-
-	if (sample_size_val.IsNull() || sample_size <= 0) {
-		throw BinderException("Size of the RESERVOIR_QUANTILE sample must be bigger than 0");
-	}
-
-	// remove the quantile argument so we can use the unary aggregate
-	arguments.pop_back();
-	arguments.pop_back();
-	return make_unique<ReservoirQuantileBindData>(quantiles, sample_size);
-}
-
-unique_ptr<FunctionData> BindReservoirQuantileDecimal(ClientContext &context, AggregateFunction &function,
-                                                      vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindReservoirQuantile(context, function, arguments);
-	function = GetReservoirQuantileAggregateFunction(arguments[0]->return_type.InternalType());
-	function.name = "reservoir_quantile";
-	return bind_data;
-}
-
-AggregateFunction GetReservoirQuantileAggregate(PhysicalType type) {
-	auto fun = GetReservoirQuantileAggregateFunction(type);
-	fun.bind = BindReservoirQuantile;
-	// temporarily push an argument so we can bind the actual quantile
-	fun.arguments.emplace_back(LogicalType::DOUBLE);
-	return fun;
-}
-
-unique_ptr<FunctionData> BindReservoirQuantileDecimalList(ClientContext &context, AggregateFunction &function,
-                                                          vector<unique_ptr<Expression>> &arguments) {
-	auto bind_data = BindReservoirQuantile(context, function, arguments);
-	function = GetReservoirQuantileListAggregateFunction(arguments[0]->return_type);
-	function.name = "reservoir_quantile";
-	return bind_data;
-}
-
-AggregateFunction GetReservoirQuantileListAggregate(const LogicalType &type) {
-	auto fun = GetReservoirQuantileListAggregateFunction(type);
-	fun.bind = BindReservoirQuantile;
-	// temporarily push an argument so we can bind the actual quantile
-	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
-	fun.arguments.push_back(list_of_double);
-	return fun;
-}
-
-static void DefineReservoirQuantile(AggregateFunctionSet &set, const LogicalType &type) {
-	//	Four versions: type, scalar/list[, count]
-	auto fun = GetReservoirQuantileAggregate(type.InternalType());
-	fun.bind = BindReservoirQuantile;
-	set.AddFunction(fun);
-
-	fun.arguments.emplace_back(LogicalType::INTEGER);
-	set.AddFunction(fun);
-
-	// List variants
-	fun = GetReservoirQuantileListAggregate(type);
-	set.AddFunction(fun);
-
-	fun.arguments.emplace_back(LogicalType::INTEGER);
-	set.AddFunction(fun);
-}
-
-void ReservoirQuantileFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet reservoir_quantile("reservoir_quantile");
-
-	// DECIMAL
-	reservoir_quantile.AddFunction(
-	    AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::DOUBLE, LogicalType::INTEGER}, LogicalTypeId::DECIMAL,
-	                      nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, BindReservoirQuantileDecimal));
-	reservoir_quantile.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::DOUBLE},
-	                                                 LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr, nullptr,
-	                                                 nullptr, nullptr, BindReservoirQuantileDecimal));
-	reservoir_quantile.AddFunction(
-	    AggregateFunction({LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::DOUBLE), LogicalType::INTEGER},
-	                      LogicalType::LIST(LogicalTypeId::DECIMAL), nullptr, nullptr, nullptr, nullptr, nullptr,
-	                      nullptr, BindReservoirQuantileDecimalList));
-
-	reservoir_quantile.AddFunction(AggregateFunction(
-	    {LogicalTypeId::DECIMAL, LogicalType::LIST(LogicalType::DOUBLE)}, LogicalType::LIST(LogicalTypeId::DECIMAL),
-	    nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, BindReservoirQuantileDecimalList));
-
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::TINYINT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::SMALLINT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::INTEGER);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::BIGINT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::HUGEINT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::FLOAT);
-	DefineReservoirQuantile(reservoir_quantile, LogicalTypeId::DOUBLE);
-
-	set.AddFunction(reservoir_quantile);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterHolisticAggregates() {
-	Register<QuantileFun>();
-	Register<ModeFun>();
-	Register<ApproximateQuantileFun>();
-	Register<ReservoirQuantileFun>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct HistogramFunctor {
-	template <class T, class MAP_TYPE = map<T, idx_t>>
-	static void HistogramUpdate(VectorData &sdata, VectorData &input_data, idx_t count) {
-
-		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
-		for (idx_t i = 0; i < count; i++) {
-			if (input_data.validity.RowIsValid(input_data.sel->get_index(i))) {
-				auto state = states[sdata.sel->get_index(i)];
-				if (!state->hist) {
-					state->hist = new MAP_TYPE();
-				}
-				auto value = (T *)input_data.data;
-				(*state->hist)[value[input_data.sel->get_index(i)]]++;
-			}
-		}
-	}
-
-	template <class T>
-	static Value HistogramFinalize(T first) {
-		return Value::CreateValue(first);
-	}
-};
-
-struct HistogramStringFunctor {
-	template <class T, class MAP_TYPE = map<T, idx_t>>
-	static void HistogramUpdate(VectorData &sdata, VectorData &input_data, idx_t count) {
-
-		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
-		for (idx_t i = 0; i < count; i++) {
-			if (input_data.validity.RowIsValid(input_data.sel->get_index(i))) {
-				auto state = states[sdata.sel->get_index(i)];
-				if (!state->hist) {
-					state->hist = new MAP_TYPE();
-				}
-				auto value = (string_t *)input_data.data;
-				(*state->hist)[value[input_data.sel->get_index(i)].GetString()]++;
-			}
-		}
-	}
-
-	template <class T>
-	static Value HistogramFinalize(T first) {
-		string_t value = first;
-		return Value::CreateValue(value);
-	}
-};
-
-struct HistogramFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->hist = nullptr;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->hist) {
-			delete state->hist;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-template <class OP, class T, class MAP_TYPE>
-static void HistogramUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector,
-                                    idx_t count) {
-
-	D_ASSERT(input_count == 1);
-
-	auto &input = inputs[0];
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
-	VectorData input_data;
-	input.Orrify(count, input_data);
-
-	OP::template HistogramUpdate<T, MAP_TYPE>(sdata, input_data, count);
-}
-
-template <class T, class MAP_TYPE>
-static void HistogramCombineFunction(Vector &state, Vector &combined, AggregateInputData &, idx_t count) {
-
-	VectorData sdata;
-	state.Orrify(count, sdata);
-	auto states_ptr = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
-
-	auto combined_ptr = FlatVector::GetData<HistogramAggState<T, MAP_TYPE> *>(combined);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto state = states_ptr[sdata.sel->get_index(i)];
-		if (!state->hist) {
-			continue;
-		}
-		if (!combined_ptr[i]->hist) {
-			combined_ptr[i]->hist = new MAP_TYPE();
-		}
-		D_ASSERT(combined_ptr[i]->hist);
-		D_ASSERT(state->hist);
-		for (auto &entry : *state->hist) {
-			(*combined_ptr[i]->hist)[entry.first] += entry.second;
-		}
-	}
-}
-
-template <class OP, class T, class MAP_TYPE>
-static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count,
-                                      idx_t offset) {
-
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
-	auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
-
-	auto &mask = FlatVector::Validity(result);
-
-	auto &child_entries = StructVector::GetEntries(result);
-	auto &bucket_list = child_entries[0];
-	auto &count_list = child_entries[1];
-
-	auto old_len = ListVector::GetListSize(*bucket_list);
-
-	auto &bucket_validity = FlatVector::Validity(*bucket_list);
-	auto &count_validity = FlatVector::Validity(*count_list);
-
-	for (idx_t i = 0; i < count; i++) {
-
-		const auto rid = i + offset;
-		auto state = states[sdata.sel->get_index(i)];
-		if (!state->hist) {
-			mask.SetInvalid(rid);
-			bucket_validity.SetInvalid(rid);
-			count_validity.SetInvalid(rid);
-			continue;
-		}
-
-		for (auto &entry : *state->hist) {
-			Value bucket_value = OP::template HistogramFinalize<T>(entry.first);
-			ListVector::PushBack(*bucket_list, bucket_value);
-			auto count_value = Value::CreateValue(entry.second);
-			ListVector::PushBack(*count_list, count_value);
-		}
-
-		auto list_struct_data = FlatVector::GetData<list_entry_t>(*bucket_list);
-		list_struct_data[rid].length = ListVector::GetListSize(*bucket_list) - old_len;
-		list_struct_data[rid].offset = old_len;
-
-		list_struct_data = FlatVector::GetData<list_entry_t>(*count_list);
-		list_struct_data[rid].length = ListVector::GetListSize(*count_list) - old_len;
-		list_struct_data[rid].offset = old_len;
-		old_len += list_struct_data[rid].length;
-	}
-}
-
-unique_ptr<FunctionData> HistogramBindFunction(ClientContext &context, AggregateFunction &function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(arguments.size() == 1);
-	child_list_t<LogicalType> struct_children;
-	struct_children.push_back({"bucket", LogicalType::LIST(arguments[0]->return_type)});
-	struct_children.push_back({"count", LogicalType::LIST(LogicalType::UBIGINT)});
-	auto struct_type = LogicalType::MAP(move(struct_children));
-
-	function.return_type = struct_type;
-	return make_unique<VariableReturnBindData>(function.return_type);
-}
-
-template <class OP, class T, class MAP_TYPE = map<T, idx_t>>
-static AggregateFunction GetHistogramFunction(const LogicalType &type) {
-
-	using STATE_TYPE = HistogramAggState<T, MAP_TYPE>;
-
-	return AggregateFunction("histogram", {type}, LogicalTypeId::MAP, AggregateFunction::StateSize<STATE_TYPE>,
-	                         AggregateFunction::StateInitialize<STATE_TYPE, HistogramFunction>,
-	                         HistogramUpdateFunction<OP, T, MAP_TYPE>, HistogramCombineFunction<T, MAP_TYPE>,
-	                         HistogramFinalizeFunction<OP, T, MAP_TYPE>, nullptr, HistogramBindFunction,
-	                         AggregateFunction::StateDestroy<STATE_TYPE, HistogramFunction>);
-}
-
-template <class OP, class T, bool IS_ORDERED>
-AggregateFunction GetMapType(const LogicalType &type) {
-
-	if (IS_ORDERED) {
-		return GetHistogramFunction<OP, T>(type);
-	}
-	return GetHistogramFunction<OP, T, unordered_map<T, idx_t>>(type);
-}
-
-template <bool IS_ORDERED = true>
-AggregateFunction GetHistogramFunction(const LogicalType &type) {
-
-	switch (type.id()) {
-	case LogicalType::BOOLEAN:
-		return GetMapType<HistogramFunctor, bool, IS_ORDERED>(type);
-	case LogicalType::UTINYINT:
-		return GetMapType<HistogramFunctor, uint8_t, IS_ORDERED>(type);
-	case LogicalType::USMALLINT:
-		return GetMapType<HistogramFunctor, uint16_t, IS_ORDERED>(type);
-	case LogicalType::UINTEGER:
-		return GetMapType<HistogramFunctor, uint32_t, IS_ORDERED>(type);
-	case LogicalType::UBIGINT:
-		return GetMapType<HistogramFunctor, uint64_t, IS_ORDERED>(type);
-	case LogicalType::TINYINT:
-		return GetMapType<HistogramFunctor, int8_t, IS_ORDERED>(type);
-	case LogicalType::SMALLINT:
-		return GetMapType<HistogramFunctor, int16_t, IS_ORDERED>(type);
-	case LogicalType::INTEGER:
-		return GetMapType<HistogramFunctor, int32_t, IS_ORDERED>(type);
-	case LogicalType::BIGINT:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case LogicalType::FLOAT:
-		return GetMapType<HistogramFunctor, float, IS_ORDERED>(type);
-	case LogicalType::DOUBLE:
-		return GetMapType<HistogramFunctor, double, IS_ORDERED>(type);
-	case LogicalType::VARCHAR:
-		return GetMapType<HistogramStringFunctor, string, IS_ORDERED>(type);
-	case LogicalType::TIMESTAMP:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case LogicalType::TIMESTAMP_TZ:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case LogicalType::TIMESTAMP_S:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case LogicalType::TIMESTAMP_MS:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case LogicalType::TIMESTAMP_NS:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case LogicalType::TIME:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case LogicalType::TIME_TZ:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
-	case LogicalType::DATE:
-		return GetMapType<HistogramFunctor, int32_t, IS_ORDERED>(type);
-	default:
-		throw InternalException("Unimplemented histogram aggregate");
-	}
-}
-
-void HistogramFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("histogram");
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::BOOLEAN));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::UTINYINT));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::USMALLINT));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::UINTEGER));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::UBIGINT));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::TINYINT));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::SMALLINT));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::INTEGER));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::BIGINT));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::FLOAT));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::DOUBLE));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::VARCHAR));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIMESTAMP));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIMESTAMP_TZ));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIMESTAMP_S));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIMESTAMP_MS));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIMESTAMP_NS));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIME));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::TIME_TZ));
-	fun.AddFunction(GetHistogramFunction<>(LogicalType::DATE));
-	set.AddFunction(fun);
-}
-
-AggregateFunction HistogramFun::GetHistogramUnorderedMap(LogicalType &type) {
-	const auto &const_type = type;
-	return GetHistogramFunction<false>(const_type);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-struct ListAggState {
-	Vector *list_vector;
-};
-
-struct ListFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->list_vector = nullptr;
-	}
-
-	template <class STATE>
-	static void Destroy(STATE *state) {
-		if (state->list_vector) {
-			delete state->list_vector;
-		}
-	}
-	static bool IgnoreNull() {
-		return false;
-	}
-};
-
-static void ListUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector,
-                               idx_t count) {
-	D_ASSERT(input_count == 1);
-
-	auto &input = inputs[0];
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
-
-	auto list_vector_type = LogicalType::LIST(input.GetType());
-
-	auto states = (ListAggState **)sdata.data;
-	if (input.GetVectorType() == VectorType::SEQUENCE_VECTOR) {
-		input.Normalify(count);
-	}
-	for (idx_t i = 0; i < count; i++) {
-		auto state = states[sdata.sel->get_index(i)];
-		if (!state->list_vector) {
-			// NOTE: any number bigger than 1 can cause DuckDB to run out of memory for specific queries
-			// consisting of millions of groups in the group by and complex (nested) vectors
-			state->list_vector = new Vector(list_vector_type, 1);
-		}
-		ListVector::Append(*state->list_vector, input, i + 1, i);
-	}
-}
-
-static void ListCombineFunction(Vector &state, Vector &combined, AggregateInputData &, idx_t count) {
-	VectorData sdata;
-	state.Orrify(count, sdata);
-	auto states_ptr = (ListAggState **)sdata.data;
-
-	auto combined_ptr = FlatVector::GetData<ListAggState *>(combined);
-	for (idx_t i = 0; i < count; i++) {
-		auto state = states_ptr[sdata.sel->get_index(i)];
-		if (!state->list_vector) {
-			// NULL, no need to append.
-			continue;
-		}
-		if (!combined_ptr[i]->list_vector) {
-			// NOTE: initializing this with a capacity of ListVector::GetListSize(*state->list_vector) causes
-			// DuckDB to run out of memory for multiple threads with millions of groups in the group by and complex
-			// (nested) vectors
-			combined_ptr[i]->list_vector = new Vector(state->list_vector->GetType(), 1);
-		}
-		ListVector::Append(*combined_ptr[i]->list_vector, ListVector::GetEntry(*state->list_vector),
-		                   ListVector::GetListSize(*state->list_vector));
-	}
-}
-
-static void ListFinalize(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count, idx_t offset) {
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
-	auto states = (ListAggState **)sdata.data;
-
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-	auto &mask = FlatVector::Validity(result);
-	auto list_struct_data = FlatVector::GetData<list_entry_t>(result);
-	size_t total_len = ListVector::GetListSize(result);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto state = states[sdata.sel->get_index(i)];
-		const auto rid = i + offset;
-		if (!state->list_vector) {
-			mask.SetInvalid(rid);
-			continue;
-		}
-
-		auto &state_lv = *state->list_vector;
-		auto state_lv_count = ListVector::GetListSize(state_lv);
-		list_struct_data[rid].length = state_lv_count;
-		list_struct_data[rid].offset = total_len;
-		total_len += state_lv_count;
-
-		auto &list_vec_to_append = ListVector::GetEntry(state_lv);
-		ListVector::Append(result, list_vec_to_append, state_lv_count);
-	}
-}
-
-unique_ptr<FunctionData> ListBindFunction(ClientContext &context, AggregateFunction &function,
-                                          vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() == 1);
-	function.return_type = LogicalType::LIST(arguments[0]->return_type);
-	return nullptr;
-}
-
-void ListFun::RegisterFunction(BuiltinFunctions &set) {
-	auto agg =
-	    AggregateFunction("list", {LogicalType::ANY}, LogicalTypeId::LIST, AggregateFunction::StateSize<ListAggState>,
-	                      AggregateFunction::StateInitialize<ListAggState, ListFunction>, ListUpdateFunction,
-	                      ListCombineFunction, ListFinalize, nullptr, ListBindFunction,
-	                      AggregateFunction::StateDestroy<ListAggState, ListFunction>, nullptr, nullptr);
-	set.AddFunction(agg);
-	agg.name = "array_agg";
-	set.AddFunction(agg);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterNestedAggregates() {
-	Register<ListFun>();
-	Register<HistogramFun>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-struct RegrState {
-	double sum;
-	size_t count;
-};
-
-struct RegrAvgFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->sum = 0;
-		state->count = 0;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->sum += source.sum;
-		target->count += source.count;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->sum / (double)state->count;
-		}
-	}
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-struct RegrAvgXFunction : RegrAvgFunction {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		state->sum += y_data[yidx];
-		state->count++;
-	}
-};
-
-struct RegrAvgYFunction : RegrAvgFunction {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		state->sum += x_data[xidx];
-		state->count++;
-	}
-};
-
-void RegrAvgxFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet corr("regr_avgx");
-	corr.AddFunction(AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgXFunction>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(corr);
-}
-
-void RegrAvgyFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet corr("regr_avgy");
-	corr.AddFunction(AggregateFunction::BinaryAggregate<RegrState, double, double, double, RegrAvgYFunction>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(corr);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-void RegrCountFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet corr("regr_count");
-	corr.AddFunction(AggregateFunction::BinaryAggregate<size_t, double, double, uint32_t, RegrCountFunction>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::UINTEGER));
-	set.AddFunction(corr);
-}
-
-} // namespace duckdb
-//! AVG(y)-REGR_SLOPE(y,x)*AVG(x)
-
-
-
-
-
-namespace duckdb {
-
-struct RegrInterceptState {
-	size_t count;
-	double sum_x;
-	double sum_y;
-	RegrSlopeState slope;
-};
-
-struct RegrInterceptOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->count = 0;
-		state->sum_x = 0;
-		state->sum_y = 0;
-		RegrSlopeOperation::Initialize<RegrSlopeState>(&state->slope);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		state->count++;
-		state->sum_x += y_data[yidx];
-		state->sum_y += x_data[xidx];
-		RegrSlopeOperation::Operation<A_TYPE, B_TYPE, RegrSlopeState, OP>(&state->slope, aggr_input_data, x_data,
-		                                                                  y_data, amask, bmask, xidx, yidx);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		target->count += source.count;
-		target->sum_x += source.sum_x;
-		target->sum_y += source.sum_y;
-		RegrSlopeOperation::Combine<RegrSlopeState, OP>(source.slope, &target->slope, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		RegrSlopeOperation::Finalize<T, RegrSlopeState>(result, aggr_input_data, &state->slope, target, mask, idx);
-		auto x_avg = state->sum_x / state->count;
-		auto y_avg = state->sum_y / state->count;
-		target[idx] = y_avg - target[idx] * x_avg;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-void RegrInterceptFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_intercept");
-	fun.AddFunction(
-	    AggregateFunction::BinaryAggregate<RegrInterceptState, double, double, double, RegrInterceptOperation>(
-	        LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-// Returns the coefficient of determination for non-null pairs in a group.
-// It is computed for non-null pairs using the following formula:
-// null                 if var_pop(x) = 0, else
-// 1                    if var_pop(y) = 0 and var_pop(x) <> 0, else
-// power(corr(y,x), 2)
-
-
-
-
-
-namespace duckdb {
-struct RegrR2State {
-	CorrState corr;
-	StddevState var_pop_x;
-	StddevState var_pop_y;
-};
-
-struct RegrR2Operation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		CorrOperation::Initialize<CorrState>(&state->corr);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop_x);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop_y);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		CorrOperation::Operation<A_TYPE, B_TYPE, CorrState, OP>(&state->corr, aggr_input_data, y_data, x_data, bmask,
-		                                                        amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop_x, aggr_input_data, y_data, bmask,
-		                                                        yidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop_y, aggr_input_data, x_data, amask,
-		                                                        xidx);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CorrOperation::Combine<CorrState, OP>(source.corr, &target->corr, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_x, &target->var_pop_x, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_y, &target->var_pop_y, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		auto var_pop_x = state->var_pop_x.count > 1 ? (state->var_pop_x.dsquared / state->var_pop_x.count) : 0;
-		if (!Value::DoubleIsFinite(var_pop_x)) {
-			throw OutOfRangeException("VARPOP(X) is out of range!");
-		}
-		if (var_pop_x == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		auto var_pop_y = state->var_pop_y.count > 1 ? (state->var_pop_y.dsquared / state->var_pop_y.count) : 0;
-		if (!Value::DoubleIsFinite(var_pop_y)) {
-			throw OutOfRangeException("VARPOP(Y) is out of range!");
-		}
-		if (var_pop_y == 0) {
-			target[idx] = 1;
-			return;
-		}
-		CorrOperation::Finalize<T, CorrState>(result, aggr_input_data, &state->corr, target, mask, idx);
-		target[idx] = pow(target[idx], 2);
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-void RegrR2Fun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_r2");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrR2State, double, double, double, RegrR2Operation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
-}
-} // namespace duckdb
-// REGR_SLOPE(y, x)
-// Returns the slope of the linear regression line for non-null pairs in a group.
-// It is computed for non-null pairs using the following formula:
-// COVAR_POP(x,y) / VAR_POP(x)
-
-//! Input : Any numeric type
-//! Output : Double
-
-
-
-
-
-namespace duckdb {
-
-void RegrSlopeFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_slope");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrSlopeState, double, double, double, RegrSlopeOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-// regr_sxx
-// Returns REGR_COUNT(y, x) * VAR_POP(x) for non-null pairs.
-// regrsyy
-// Returns REGR_COUNT(y, x) * VAR_POP(y) for non-null pairs.
-
-
-
-
-
-namespace duckdb {
-
-struct RegrSState {
-	size_t count;
-	StddevState var_pop;
-};
-
-struct RegrBaseOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		RegrCountFunction::Initialize<size_t>(&state->count);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->var_pop.count == 0) {
-			mask.SetInvalid(idx);
-			return;
-		}
-		auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
-		if (!Value::DoubleIsFinite(var_pop)) {
-			throw OutOfRangeException("VARPOP is out of range!");
-		}
-		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
-		target[idx] *= var_pop;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct RegrSXXOperation : RegrBaseOperation {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, y_data, bmask, yidx);
-	}
-};
-
-struct RegrSYYOperation : RegrBaseOperation {
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, x_data, bmask, xidx);
-	}
-};
-
-void RegrSXXFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_sxx");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSXXOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
-}
-
-void RegrSYYFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_syy");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrSState, double, double, double, RegrSYYOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-// Returns REGR_COUNT(expr1, expr2) * COVAR_POP(expr1, expr2) for non-null pairs.
-
-
-
-
-
-
-namespace duckdb {
-
-struct RegrSXyState {
-	size_t count;
-	CovarState cov_pop;
-};
-
-struct RegrSXYOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		RegrCountFunction::Initialize<size_t>(&state->count);
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, aggr_input_data, x_data, y_data,
-		                                                          amask, bmask, xidx, yidx);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, aggr_input_data);
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		CovarPopOperation::Finalize<T, CovarState>(result, aggr_input_data, &state->cov_pop, target, mask, idx);
-		auto cov_pop = target[idx];
-		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
-		target[idx] *= cov_pop;
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-void RegrSXYFun::RegisterFunction(BuiltinFunctions &set) {
-	AggregateFunctionSet fun("regr_sxy");
-	fun.AddFunction(AggregateFunction::BinaryAggregate<RegrSXyState, double, double, double, RegrSXYOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE));
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterRegressiveAggregates() {
-	Register<RegrAvgxFun>();
-	Register<RegrAvgyFun>();
-	Register<RegrCountFun>();
-	Register<RegrSlopeFun>();
-	Register<RegrR2Fun>();
-	Register<RegrSYYFun>();
-	Register<RegrSXXFun>();
-	Register<RegrSXYFun>();
-	Register<RegrInterceptFun>();
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct SortedAggregateBindData : public FunctionData {
-
-	// TODO: Collection sorting does not handle OrderByNullType correctly
-	// so this is the third hack around it...
-	static OrderByNullType NormaliseNullOrder(OrderType sense, OrderByNullType null_order) {
-		if (sense != OrderType::DESCENDING) {
-			return null_order;
-		}
-
-		switch (null_order) {
-		case OrderByNullType::NULLS_FIRST:
-			return OrderByNullType::NULLS_LAST;
-		case OrderByNullType::NULLS_LAST:
-			return OrderByNullType::NULLS_FIRST;
-		default:
-			throw InternalException("Unknown NULL order sense");
-		}
-	}
-
-	SortedAggregateBindData(const AggregateFunction &function_p, vector<unique_ptr<Expression>> &children,
-	                        unique_ptr<FunctionData> bind_info_p, const BoundOrderModifier &order_bys)
-	    : function(function_p), bind_info(move(bind_info_p)) {
-		arg_types.reserve(children.size());
-		for (const auto &child : children) {
-			arg_types.emplace_back(child->return_type);
-		}
-		for (auto &order : order_bys.orders) {
-			order_sense.emplace_back(order.type);
-			null_order.emplace_back(NormaliseNullOrder(order.type, order.null_order));
-			sort_types.emplace_back(order.expression->return_type);
-		}
-	}
-
-	SortedAggregateBindData(const SortedAggregateBindData &other)
-	    : function(other.function), arg_types(other.arg_types), order_sense(other.order_sense),
-	      null_order(other.null_order), sort_types(other.sort_types) {
-		if (other.bind_info) {
-			bind_info = other.bind_info->Copy();
-		}
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<SortedAggregateBindData>(*this);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const SortedAggregateBindData &)other_p;
-		if (bind_info && other.bind_info) {
-			if (!bind_info->Equals(*other.bind_info)) {
-				return false;
-			}
-		} else if (bind_info || other.bind_info) {
-			return false;
-		}
-		return function == other.function && order_sense == other.order_sense && null_order == other.null_order &&
-		       sort_types == other.sort_types;
-	}
-
-	AggregateFunction function;
-	vector<LogicalType> arg_types;
-	unique_ptr<FunctionData> bind_info;
-
-	vector<OrderType> order_sense;
-	vector<OrderByNullType> null_order;
-	vector<LogicalType> sort_types;
-};
-
-struct SortedAggregateState {
-	SortedAggregateState()
-	    : arguments(Allocator::DefaultAllocator()), ordering(Allocator::DefaultAllocator()), nsel(0) {
-	}
-
-	ChunkCollection arguments;
-	ChunkCollection ordering;
-
-	// Selection for scattering
-	SelectionVector sel;
-	idx_t nsel;
-};
-
-struct SortedAggregateFunction {
-	template <typename STATE>
-	static void Initialize(STATE *state) {
-		new (state) STATE();
-	}
-
-	template <typename STATE>
-	static void Destroy(STATE *state) {
-		state->~STATE();
-	}
-
-	static void ProjectInputs(Vector inputs[], SortedAggregateBindData *order_bind, idx_t input_count, idx_t count,
-	                          DataChunk &arg_chunk, DataChunk &sort_chunk) {
-		idx_t col = 0;
-
-		arg_chunk.InitializeEmpty(order_bind->arg_types);
-		for (auto &dst : arg_chunk.data) {
-			dst.Reference(inputs[col++]);
-		}
-		arg_chunk.SetCardinality(count);
-
-		sort_chunk.InitializeEmpty(order_bind->sort_types);
-		for (auto &dst : sort_chunk.data) {
-			dst.Reference(inputs[col++]);
-		}
-		sort_chunk.SetCardinality(count);
-	}
-
-	static void SimpleUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-	                         idx_t count) {
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
-		DataChunk arg_chunk;
-		DataChunk sort_chunk;
-		ProjectInputs(inputs, order_bind, input_count, count, arg_chunk, sort_chunk);
-
-		const auto order_state = (SortedAggregateState *)state;
-		order_state->arguments.Append(arg_chunk);
-		order_state->ordering.Append(sort_chunk);
-	}
-
-	static void ScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &states,
-	                          idx_t count) {
-		if (!count) {
-			return;
-		}
-
-		// Append the arguments to the two sub-collections
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
-		DataChunk arg_inputs;
-		DataChunk sort_inputs;
-		ProjectInputs(inputs, order_bind, input_count, count, arg_inputs, sort_inputs);
-
-		// We have to scatter the chunks one at a time
-		// so build a selection vector for each one.
-		VectorData svdata;
-		states.Orrify(count, svdata);
-
-		// Build the selection vector for each state.
-		auto sdata = (SortedAggregateState **)svdata.data;
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = svdata.sel->get_index(i);
-			auto order_state = sdata[sidx];
-			if (!order_state->sel.data()) {
-				order_state->sel.Initialize();
-			}
-			order_state->sel.set_index(order_state->nsel++, i);
-		}
-
-		// Append nonempty slices to the arguments
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = svdata.sel->get_index(i);
-			auto order_state = sdata[sidx];
-			if (!order_state->nsel) {
-				continue;
-			}
-
-			DataChunk arg_chunk;
-			arg_chunk.InitializeEmpty(arg_inputs.GetTypes());
-			arg_chunk.Slice(arg_inputs, order_state->sel, order_state->nsel);
-			order_state->arguments.Append(arg_chunk);
-
-			DataChunk sort_chunk;
-			sort_chunk.InitializeEmpty(sort_inputs.GetTypes());
-			sort_chunk.Slice(sort_inputs, order_state->sel, order_state->nsel);
-			order_state->ordering.Append(sort_chunk);
-
-			// Mark the slice as empty now we have consumed it.
-			order_state->nsel = 0;
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.arguments.Count() == 0) {
-			return;
-		}
-		target->arguments.Append(const_cast<ChunkCollection &>(source.arguments));
-		target->ordering.Append(const_cast<ChunkCollection &>(source.ordering));
-	}
-
-	static void Finalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                     idx_t offset) {
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
-
-		//	 Reusable inner state
-		vector<data_t> agg_state(order_bind->function.state_size());
-		Vector agg_state_vec(Value::POINTER((idx_t)agg_state.data()));
-
-		// Sorting buffer
-		vector<idx_t> reordering;
-
-		// State variables
-		const auto input_count = order_bind->function.arguments.size();
-		auto bind_info = order_bind->bind_info.get();
-		AggregateInputData aggr_bind_info(bind_info);
-
-		// Inner aggregate APIs
-		auto initialize = order_bind->function.initialize;
-		auto destructor = order_bind->function.destructor;
-		auto simple_update = order_bind->function.simple_update;
-		auto update = order_bind->function.update;
-		auto finalize = order_bind->function.finalize;
-
-		auto sdata = FlatVector::GetData<SortedAggregateState *>(states);
-		for (idx_t i = 0; i < count; ++i) {
-			initialize(agg_state.data());
-			auto state = sdata[i];
-
-			// Apply the sort before delegating the chunks
-			const auto agg_count = state->ordering.Count();
-			if (agg_count > 0) {
-				reordering.resize(agg_count);
-				state->ordering.Sort(order_bind->order_sense, order_bind->null_order, reordering.data());
-				state->arguments.Reorder(reordering.data());
-			}
-
-			for (auto &chunk : state->arguments.Chunks()) {
-				// These are all simple updates, so use it if available
-				if (simple_update) {
-					simple_update(chunk->data.data(), aggr_bind_info, input_count, agg_state.data(), chunk->size());
-				} else {
-					// We are only updating a constant state
-					agg_state_vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-					update(chunk->data.data(), aggr_bind_info, input_count, agg_state_vec, chunk->size());
-				}
-			}
-
-			// Finalize a single value at the next offset
-			agg_state_vec.SetVectorType(states.GetVectorType());
-			finalize(agg_state_vec, aggr_bind_info, result, 1, i + offset);
-
-			if (destructor) {
-				destructor(agg_state_vec, 1);
-			}
-		}
-	}
-};
-
-unique_ptr<FunctionData> AggregateFunction::BindSortedAggregate(AggregateFunction &bound_function,
-                                                                vector<unique_ptr<Expression>> &children,
-                                                                unique_ptr<FunctionData> bind_info,
-                                                                unique_ptr<BoundOrderModifier> order_bys) {
-
-	auto sorted_bind = make_unique<SortedAggregateBindData>(bound_function, children, move(bind_info), *order_bys);
-
-	// The arguments are the children plus the sort columns.
-	for (auto &order : order_bys->orders) {
-		children.emplace_back(move(order.expression));
-	}
-
-	vector<LogicalType> arguments;
-	arguments.reserve(children.size());
-	for (const auto &child : children) {
-		arguments.emplace_back(child->return_type);
-	}
-
-	// Replace the aggregate with the wrapper
-	bound_function = AggregateFunction(
-	    bound_function.name, arguments, bound_function.return_type, AggregateFunction::StateSize<SortedAggregateState>,
-	    AggregateFunction::StateInitialize<SortedAggregateState, SortedAggregateFunction>,
-	    SortedAggregateFunction::ScatterUpdate,
-	    AggregateFunction::StateCombine<SortedAggregateState, SortedAggregateFunction>,
-	    SortedAggregateFunction::Finalize, SortedAggregateFunction::SimpleUpdate, nullptr,
-	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>);
-
-	return move(sorted_bind);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//! The target type determines the preferred implicit casts
-static int64_t TargetTypeCost(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::INTEGER:
-		return 103;
-	case LogicalTypeId::BIGINT:
-		return 101;
-	case LogicalTypeId::DOUBLE:
-		return 102;
-	case LogicalTypeId::HUGEINT:
-		return 120;
-	case LogicalTypeId::TIMESTAMP:
-		return 120;
-	case LogicalTypeId::VARCHAR:
-		return 149;
-	case LogicalTypeId::DECIMAL:
-		return 104;
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::LIST:
-		return 160;
-	default:
-		return 110;
-	}
-}
-
-static int64_t ImplicitCastTinyint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastSmallint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastInteger(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastBigint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUTinyint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUSmallint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUInteger(const LogicalType &to) {
-	switch (to.id()) {
-
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastUBigint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastFloat(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::DOUBLE:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastDouble(const LogicalType &to) {
-	switch (to.id()) {
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastDecimal(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastHugeint(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-static int64_t ImplicitCastDate(const LogicalType &to) {
-	switch (to.id()) {
-	case LogicalTypeId::TIMESTAMP:
-		return TargetTypeCost(to);
-	default:
-		return -1;
-	}
-}
-
-int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to) {
-	if (to.id() == LogicalTypeId::ANY) {
-		// anything can be cast to ANY type for no cost
-		return 0;
-	}
-	if (from.id() == LogicalTypeId::SQLNULL) {
-		// NULL expression can be cast to anything
-		return TargetTypeCost(to);
-	}
-	if (from.id() == LogicalTypeId::UNKNOWN) {
-		// parameter expression can be cast to anything for no cost
-		return 0;
-	}
-	if (from.id() == LogicalTypeId::BLOB && to.id() == LogicalTypeId::VARCHAR) {
-		// Implicit cast not allowed from BLOB to VARCHAR
-		return -1;
-	}
-	if ((from.id() == LogicalTypeId::VARCHAR && to.id() == LogicalTypeId::JSON) ||
-	    (from.id() == LogicalTypeId::JSON && to.id() == LogicalTypeId::VARCHAR)) {
-		// Virtually no cost, just a different tag
-		return 1;
-	}
-	if (to.id() == LogicalTypeId::VARCHAR || to.id() == LogicalTypeId::JSON) {
-		// everything can be cast to VARCHAR/JSON, but this cast has a high cost
-		return TargetTypeCost(to);
-	}
-	if (from.id() == LogicalTypeId::LIST && to.id() == LogicalTypeId::LIST) {
-		// Lists can be cast if their child types can be cast
-		return ImplicitCast(ListType::GetChildType(from), ListType::GetChildType(to));
-	}
-	if ((from.id() == LogicalTypeId::TIMESTAMP_SEC || from.id() == LogicalTypeId::TIMESTAMP_MS ||
-	     from.id() == LogicalTypeId::TIMESTAMP_NS) &&
-	    to.id() == LogicalTypeId::TIMESTAMP) {
-		//! Any timestamp type can be converted to the default (us) type at low cost
-		return 101;
-	}
-	if ((to.id() == LogicalTypeId::TIMESTAMP_SEC || to.id() == LogicalTypeId::TIMESTAMP_MS ||
-	     to.id() == LogicalTypeId::TIMESTAMP_NS) &&
-	    from.id() == LogicalTypeId::TIMESTAMP) {
-		//! Any timestamp type can be converted to the default (us) type at low cost
-		return 100;
-	}
-	switch (from.id()) {
-	case LogicalTypeId::TINYINT:
-		return ImplicitCastTinyint(to);
-	case LogicalTypeId::SMALLINT:
-		return ImplicitCastSmallint(to);
-	case LogicalTypeId::INTEGER:
-		return ImplicitCastInteger(to);
-	case LogicalTypeId::BIGINT:
-		return ImplicitCastBigint(to);
-	case LogicalTypeId::UTINYINT:
-		return ImplicitCastUTinyint(to);
-	case LogicalTypeId::USMALLINT:
-		return ImplicitCastUSmallint(to);
-	case LogicalTypeId::UINTEGER:
-		return ImplicitCastUInteger(to);
-	case LogicalTypeId::UBIGINT:
-		return ImplicitCastUBigint(to);
-	case LogicalTypeId::HUGEINT:
-		return ImplicitCastHugeint(to);
-	case LogicalTypeId::FLOAT:
-		return ImplicitCastFloat(to);
-	case LogicalTypeId::DOUBLE:
-		return ImplicitCastDouble(to);
-	case LogicalTypeId::DATE:
-		return ImplicitCastDate(to);
-	case LogicalTypeId::DECIMAL:
-		return ImplicitCastDecimal(to);
-	default:
-		return -1;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-typedef CompressionFunction (*get_compression_function_t)(PhysicalType type);
-typedef bool (*compression_supports_type_t)(PhysicalType type);
-
-struct DefaultCompressionMethod {
-	CompressionType type;
-	get_compression_function_t get_function;
-	compression_supports_type_t supports_type;
-};
-
-static DefaultCompressionMethod internal_compression_methods[] = {
-    {CompressionType::COMPRESSION_CONSTANT, ConstantFun::GetFunction, ConstantFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_UNCOMPRESSED, UncompressedFun::GetFunction, UncompressedFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_RLE, RLEFun::GetFunction, RLEFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_BITPACKING, BitpackingFun::GetFunction, BitpackingFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_DICTIONARY, DictionaryCompressionFun::GetFunction,
-     DictionaryCompressionFun::TypeIsSupported},
-    {CompressionType::COMPRESSION_AUTO, nullptr, nullptr}};
-
-static CompressionFunction *FindCompressionFunction(CompressionFunctionSet &set, CompressionType type,
-                                                    PhysicalType data_type) {
-	auto &functions = set.functions;
-	auto comp_entry = functions.find(type);
-	if (comp_entry != functions.end()) {
-		auto &type_functions = comp_entry->second;
-		auto type_entry = type_functions.find(data_type);
-		if (type_entry != type_functions.end()) {
-			return &type_entry->second;
-		}
-	}
-	return nullptr;
-}
-
-static CompressionFunction *LoadCompressionFunction(CompressionFunctionSet &set, CompressionType type,
-                                                    PhysicalType data_type) {
-	for (idx_t index = 0; internal_compression_methods[index].get_function; index++) {
-		const auto &method = internal_compression_methods[index];
-		if (method.type == type) {
-			// found the correct compression type
-			if (!method.supports_type(data_type)) {
-				// but it does not support this data type: bail out
-				return nullptr;
-			}
-			// the type is supported: create the function and insert it into the set
-			auto function = method.get_function(data_type);
-			set.functions[type].insert(make_pair(data_type, function));
-			return FindCompressionFunction(set, type, data_type);
-		}
-	}
-	throw InternalException("Unsupported compression function type");
-}
-
-static void TryLoadCompression(DBConfig &config, vector<CompressionFunction *> &result, CompressionType type,
-                               PhysicalType data_type) {
-	auto function = config.GetCompressionFunction(type, data_type);
-	if (!function) {
-		return;
-	}
-	result.push_back(function);
-}
-
-vector<CompressionFunction *> DBConfig::GetCompressionFunctions(PhysicalType data_type) {
-	vector<CompressionFunction *> result;
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_UNCOMPRESSED, data_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_RLE, data_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_BITPACKING, data_type);
-	TryLoadCompression(*this, result, CompressionType::COMPRESSION_DICTIONARY, data_type);
-	return result;
-}
-
-CompressionFunction *DBConfig::GetCompressionFunction(CompressionType type, PhysicalType data_type) {
-	// check if the function is already loaded
-	auto function = FindCompressionFunction(*compression_functions, type, data_type);
-	if (function) {
-		return function;
-	}
-	// else load the function
-	return LoadCompressionFunction(*compression_functions, type, data_type);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-FunctionData::~FunctionData() {
-}
-
-bool FunctionData::Equals(const FunctionData *left, const FunctionData *right) {
-	if (left == right) {
-		return true;
-	}
-	if (!left || !right) {
-		return false;
-	}
-	return left->Equals(*right);
-}
-
-TableFunctionData::~TableFunctionData() {
-}
-
-unique_ptr<FunctionData> TableFunctionData::Copy() const {
-	throw InternalException("Copy not supported for TableFunctionData");
-}
-
-bool TableFunctionData::Equals(const FunctionData &other) const {
-	return false;
-}
-
-Function::Function(string name_p) : name(move(name_p)) {
-}
-Function::~Function() {
-}
-
-SimpleFunction::SimpleFunction(string name_p, vector<LogicalType> arguments_p, LogicalType varargs_p)
-    : Function(move(name_p)), arguments(move(arguments_p)), varargs(move(varargs_p)) {
-}
-
-SimpleFunction::~SimpleFunction() {
-}
-
-string SimpleFunction::ToString() {
-	return Function::CallToString(name, arguments);
-}
-
-bool SimpleFunction::HasVarArgs() const {
-	return varargs.id() != LogicalTypeId::INVALID;
-}
-
-SimpleNamedParameterFunction::SimpleNamedParameterFunction(string name_p, vector<LogicalType> arguments_p,
-                                                           LogicalType varargs_p)
-    : SimpleFunction(move(name_p), move(arguments_p), move(varargs_p)) {
-}
-
-SimpleNamedParameterFunction::~SimpleNamedParameterFunction() {
-}
-
-string SimpleNamedParameterFunction::ToString() {
-	return Function::CallToString(name, arguments, named_parameters);
-}
-
-bool SimpleNamedParameterFunction::HasNamedParameters() {
-	return !named_parameters.empty();
-}
-
-BaseScalarFunction::BaseScalarFunction(string name_p, vector<LogicalType> arguments_p, LogicalType return_type_p,
-                                       bool has_side_effects, LogicalType varargs_p, bool propagates_null_values_p)
-    : SimpleFunction(move(name_p), move(arguments_p), move(varargs_p)), return_type(move(return_type_p)),
-      has_side_effects(has_side_effects), propagates_null_values(propagates_null_values_p) {
-}
-
-BaseScalarFunction::~BaseScalarFunction() {
-}
-
-string BaseScalarFunction::ToString() {
-	return Function::CallToString(name, arguments, return_type);
-}
-
-// add your initializer for new functions here
-void BuiltinFunctions::Initialize() {
-	RegisterSQLiteFunctions();
-	RegisterReadFunctions();
-	RegisterTableFunctions();
-	RegisterArrowFunctions();
-
-	RegisterAlgebraicAggregates();
-	RegisterDistributiveAggregates();
-	RegisterNestedAggregates();
-	RegisterHolisticAggregates();
-	RegisterRegressiveAggregates();
-
-	RegisterDateFunctions();
-	RegisterEnumFunctions();
-	RegisterGenericFunctions();
-	RegisterMathFunctions();
-	RegisterOperators();
-	RegisterSequenceFunctions();
-	RegisterStringFunctions();
-	RegisterNestedFunctions();
-	RegisterTrigonometricsFunctions();
-
-	RegisterPragmaFunctions();
-
-	// initialize collations
-	AddCollation("nocase", LowerFun::GetFunction(), true);
-	AddCollation("noaccent", StripAccentsFun::GetFunction());
-	AddCollation("nfc", NFCNormalizeFun::GetFunction());
-}
-
-BuiltinFunctions::BuiltinFunctions(ClientContext &context, Catalog &catalog) : context(context), catalog(catalog) {
-}
-
-void BuiltinFunctions::AddCollation(string name, ScalarFunction function, bool combinable,
-                                    bool not_required_for_equality) {
-	CreateCollationInfo info(move(name), move(function), combinable, not_required_for_equality);
-	catalog.CreateCollation(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(AggregateFunctionSet set) {
-	CreateAggregateFunctionInfo info(move(set));
-	catalog.CreateFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(AggregateFunction function) {
-	CreateAggregateFunctionInfo info(move(function));
-	catalog.CreateFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(PragmaFunction function) {
-	CreatePragmaFunctionInfo info(move(function));
-	catalog.CreatePragmaFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(const string &name, vector<PragmaFunction> functions) {
-	CreatePragmaFunctionInfo info(name, move(functions));
-	catalog.CreatePragmaFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(ScalarFunction function) {
-	CreateScalarFunctionInfo info(move(function));
-	catalog.CreateFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction function) { // NOLINT: false positive
-	for (auto &name : names) {
-		function.name = name;
-		AddFunction(function);
-	}
-}
-
-void BuiltinFunctions::AddFunction(ScalarFunctionSet set) {
-	CreateScalarFunctionInfo info(move(set));
-	catalog.CreateFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(TableFunction function) {
-	CreateTableFunctionInfo info(move(function));
-	catalog.CreateTableFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(TableFunctionSet set) {
-	CreateTableFunctionInfo info(move(set));
-	catalog.CreateTableFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(CopyFunction function) {
-	CreateCopyFunctionInfo info(move(function));
-	catalog.CreateCopyFunction(context, &info);
-}
-
-hash_t BaseScalarFunction::Hash() const {
-	hash_t hash = return_type.Hash();
-	for (auto &arg : arguments) {
-		duckdb::CombineHash(hash, arg.Hash());
-	}
-	return hash;
-}
-
-string Function::CallToString(const string &name, const vector<LogicalType> &arguments) {
-	string result = name + "(";
-	result += StringUtil::Join(arguments, arguments.size(), ", ",
-	                           [](const LogicalType &argument) { return argument.ToString(); });
-	return result + ")";
-}
-
-string Function::CallToString(const string &name, const vector<LogicalType> &arguments,
-                              const LogicalType &return_type) {
-	string result = CallToString(name, arguments);
-	result += " -> " + return_type.ToString();
-	return result;
-}
-
-string Function::CallToString(const string &name, const vector<LogicalType> &arguments,
-                              const named_parameter_type_map_t &named_parameters) {
-	vector<string> input_arguments;
-	input_arguments.reserve(arguments.size() + named_parameters.size());
-	for (auto &arg : arguments) {
-		input_arguments.push_back(arg.ToString());
-	}
-	for (auto &kv : named_parameters) {
-		input_arguments.push_back(StringUtil::Format("%s : %s", kv.first, kv.second.ToString()));
-	}
-	return StringUtil::Format("%s(%s)", name, StringUtil::Join(input_arguments, ", "));
-}
-
-static int64_t BindVarArgsFunctionCost(SimpleFunction &func, vector<LogicalType> &arguments) {
-	if (arguments.size() < func.arguments.size()) {
-		// not enough arguments to fulfill the non-vararg part of the function
-		return -1;
-	}
-	int64_t cost = 0;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		LogicalType arg_type = i < func.arguments.size() ? func.arguments[i] : func.varargs;
-		if (arguments[i] == arg_type) {
-			// arguments match: do nothing
-			continue;
-		}
-		int64_t cast_cost = CastRules::ImplicitCast(arguments[i], arg_type);
-		if (cast_cost >= 0) {
-			// we can implicitly cast, add the cost to the total cost
-			cost += cast_cost;
-		} else {
-			// we can't implicitly cast: throw an error
-			return -1;
-		}
-	}
-	return cost;
-}
-
-static int64_t BindFunctionCost(SimpleFunction &func, vector<LogicalType> &arguments) {
-	if (func.HasVarArgs()) {
-		// special case varargs function
-		return BindVarArgsFunctionCost(func, arguments);
-	}
-	if (func.arguments.size() != arguments.size()) {
-		// invalid argument count: check the next function
-		return -1;
-	}
-	int64_t cost = 0;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		if (arguments[i].id() == func.arguments[i].id()) {
-			// arguments match: do nothing
-			continue;
-		}
-		int64_t cast_cost = CastRules::ImplicitCast(arguments[i], func.arguments[i]);
-		if (cast_cost >= 0) {
-			// we can implicitly cast, add the cost to the total cost
-			cost += cast_cost;
-		} else {
-			// we can't implicitly cast: throw an error
-			return -1;
-		}
-	}
-	return cost;
-}
-
-template <class T>
-static vector<idx_t> BindFunctionsFromArguments(const string &name, vector<T> &functions,
-                                                vector<LogicalType> &arguments, string &error) {
-	idx_t best_function = DConstants::INVALID_INDEX;
-	int64_t lowest_cost = NumericLimits<int64_t>::Maximum();
-	vector<idx_t> candidate_functions;
-	for (idx_t f_idx = 0; f_idx < functions.size(); f_idx++) {
-		auto &func = functions[f_idx];
-		// check the arguments of the function
-		int64_t cost = BindFunctionCost(func, arguments);
-		if (cost < 0) {
-			// auto casting was not possible
-			continue;
-		}
-		if (cost == lowest_cost) {
-			candidate_functions.push_back(f_idx);
-			continue;
-		}
-		if (cost > lowest_cost) {
-			continue;
-		}
-		candidate_functions.clear();
-		lowest_cost = cost;
-		best_function = f_idx;
-	}
-	if (best_function == DConstants::INVALID_INDEX) {
-		// no matching function was found, throw an error
-		string call_str = Function::CallToString(name, arguments);
-		string candidate_str = "";
-		for (auto &f : functions) {
-			candidate_str += "\t" + f.ToString() + "\n";
-		}
-		error = StringUtil::Format("No function matches the given name and argument types '%s'. You might need to add "
-		                           "explicit type casts.\n\tCandidate functions:\n%s",
-		                           call_str, candidate_str);
-		return candidate_functions;
-	}
-	candidate_functions.push_back(best_function);
-	return candidate_functions;
-}
-
-template <class T>
-static idx_t MultipleCandidateException(const string &name, vector<T> &functions, vector<idx_t> &candidate_functions,
-                                        vector<LogicalType> &arguments, string &error) {
-	D_ASSERT(functions.size() > 1);
-	// there are multiple possible function definitions
-	// throw an exception explaining which overloads are there
-	string call_str = Function::CallToString(name, arguments);
-	string candidate_str = "";
-	for (auto &conf : candidate_functions) {
-		auto &f = functions[conf];
-		candidate_str += "\t" + f.ToString() + "\n";
-	}
-	error = StringUtil::Format("Could not choose a best candidate function for the function call \"%s\". In order to "
-	                           "select one, please add explicit type casts.\n\tCandidate functions:\n%s",
-	                           call_str, candidate_str);
-	return DConstants::INVALID_INDEX;
-}
-
-template <class T>
-static idx_t BindFunctionFromArguments(const string &name, vector<T> &functions, vector<LogicalType> &arguments,
-                                       string &error, bool &cast_parameters) {
-	auto candidate_functions = BindFunctionsFromArguments<T>(name, functions, arguments, error);
-	if (candidate_functions.empty()) {
-		// no candidates
-		return DConstants::INVALID_INDEX;
-	}
-	cast_parameters = true;
-	if (candidate_functions.size() > 1) {
-		// multiple candidates, check if there are any unknown arguments
-		bool has_parameters = false;
-		for (auto &arg_type : arguments) {
-			if (arg_type.id() == LogicalTypeId::UNKNOWN) {
-				//! there are! disable casting of parameters, but do not throw an error
-				cast_parameters = false;
-				has_parameters = true;
-				break;
-			}
-		}
-		if (!has_parameters) {
-			return MultipleCandidateException(name, functions, candidate_functions, arguments, error);
-		}
-	}
-	return candidate_functions[0];
-}
-
-idx_t Function::BindFunction(const string &name, vector<ScalarFunction> &functions, vector<LogicalType> &arguments,
-                             string &error, bool &cast_parameters) {
-	return BindFunctionFromArguments(name, functions, arguments, error, cast_parameters);
-}
-
-idx_t Function::BindFunction(const string &name, vector<AggregateFunction> &functions, vector<LogicalType> &arguments,
-                             string &error, bool &cast_parameters) {
-	return BindFunctionFromArguments(name, functions, arguments, error, cast_parameters);
-}
-
-idx_t Function::BindFunction(const string &name, vector<AggregateFunction> &functions, vector<LogicalType> &arguments,
-                             string &error) {
-	bool cast_parameters;
-	return BindFunction(name, functions, arguments, error, cast_parameters);
-}
-
-idx_t Function::BindFunction(const string &name, vector<TableFunction> &functions, vector<LogicalType> &arguments,
-                             string &error) {
-	bool cast_parameters;
-	return BindFunctionFromArguments(name, functions, arguments, error, cast_parameters);
-}
-
-idx_t Function::BindFunction(const string &name, vector<PragmaFunction> &functions, PragmaInfo &info, string &error) {
-	vector<LogicalType> types;
-	for (auto &value : info.parameters) {
-		types.push_back(value.type());
-	}
-	bool cast_parameters;
-	idx_t entry = BindFunctionFromArguments(name, functions, types, error, cast_parameters);
-	if (entry == DConstants::INVALID_INDEX) {
-		throw BinderException(error);
-	}
-	auto &candidate_function = functions[entry];
-	// cast the input parameters
-	for (idx_t i = 0; i < info.parameters.size(); i++) {
-		auto target_type =
-		    i < candidate_function.arguments.size() ? candidate_function.arguments[i] : candidate_function.varargs;
-		info.parameters[i] = info.parameters[i].CastAs(target_type);
-	}
-	return entry;
-}
-
-vector<LogicalType> GetLogicalTypesFromExpressions(vector<unique_ptr<Expression>> &arguments) {
-	vector<LogicalType> types;
-	types.reserve(arguments.size());
-	for (auto &argument : arguments) {
-		types.push_back(argument->return_type);
-	}
-	return types;
-}
-
-idx_t Function::BindFunction(const string &name, vector<ScalarFunction> &functions,
-                             vector<unique_ptr<Expression>> &arguments, string &error, bool &cast_parameters) {
-	auto types = GetLogicalTypesFromExpressions(arguments);
-	return Function::BindFunction(name, functions, types, error, cast_parameters);
-}
-
-idx_t Function::BindFunction(const string &name, vector<AggregateFunction> &functions,
-                             vector<unique_ptr<Expression>> &arguments, string &error) {
-	auto types = GetLogicalTypesFromExpressions(arguments);
-	return Function::BindFunction(name, functions, types, error);
-}
-
-idx_t Function::BindFunction(const string &name, vector<TableFunction> &functions,
-                             vector<unique_ptr<Expression>> &arguments, string &error) {
-	auto types = GetLogicalTypesFromExpressions(arguments);
-	return Function::BindFunction(name, functions, types, error);
-}
-
-enum class LogicalTypeComparisonResult { IDENTICAL_TYPE, TARGET_IS_ANY, DIFFERENT_TYPES };
-
-LogicalTypeComparisonResult RequiresCast(const LogicalType &source_type, const LogicalType &target_type) {
-	if (target_type.id() == LogicalTypeId::ANY) {
-		return LogicalTypeComparisonResult::TARGET_IS_ANY;
-	}
-	if (source_type == target_type) {
-		return LogicalTypeComparisonResult::IDENTICAL_TYPE;
-	}
-	if (source_type.id() == LogicalTypeId::LIST && target_type.id() == LogicalTypeId::LIST) {
-		return RequiresCast(ListType::GetChildType(source_type), ListType::GetChildType(target_type));
-	}
-	return LogicalTypeComparisonResult::DIFFERENT_TYPES;
-}
-
-void BaseScalarFunction::CastToFunctionArguments(vector<unique_ptr<Expression>> &children,
-                                                 bool cast_parameter_expressions) {
-	for (idx_t i = 0; i < children.size(); i++) {
-		auto target_type = i < this->arguments.size() ? this->arguments[i] : this->varargs;
-		target_type.Verify();
-		// check if the source type is a paramter, and we have disabled casting of parameters
-		if (children[i]->return_type.id() == LogicalTypeId::UNKNOWN && !cast_parameter_expressions) {
-			continue;
-		}
-		// check if the type of child matches the type of function argument
-		// if not we need to add a cast
-		auto cast_result = RequiresCast(children[i]->return_type, target_type);
-		// except for one special case: if the function accepts ANY argument
-		// in that case we don't add a cast
-		if (cast_result == LogicalTypeComparisonResult::DIFFERENT_TYPES) {
-			children[i] = BoundCastExpression::AddCastToType(move(children[i]), target_type);
-		}
-	}
-}
-
-unique_ptr<Expression> ScalarFunction::BindScalarFunction(ClientContext &context, const string &schema,
-                                                          const string &name, vector<unique_ptr<Expression>> children,
-                                                          string &error, bool is_operator, Binder *binder) {
-	// bind the function
-	auto function = Catalog::GetCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
-	D_ASSERT(function && function->type == CatalogType::SCALAR_FUNCTION_ENTRY);
-	return ScalarFunction::BindScalarFunction(context, (ScalarFunctionCatalogEntry &)*function, move(children), error,
-	                                          is_operator, binder);
-}
-
-unique_ptr<Expression> ScalarFunction::BindScalarFunction(ClientContext &context, ScalarFunctionCatalogEntry &func,
-                                                          vector<unique_ptr<Expression>> children, string &error,
-                                                          bool is_operator, Binder *binder) {
-	// bind the function
-	bool cast_parameters;
-	idx_t best_function = Function::BindFunction(func.name, func.functions, children, error, cast_parameters);
-	if (best_function == DConstants::INVALID_INDEX) {
-		return nullptr;
-	}
-
-	// found a matching function!
-	auto &bound_function = func.functions[best_function];
-
-	if (bound_function.null_handling == FunctionNullHandling::NULL_IN_NULL_OUT) {
-		for (auto &child : children) {
-			if (child->return_type == LogicalTypeId::SQLNULL) {
-				if (binder) {
-					binder->RemoveParameters(children);
-				}
-				return make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL));
-			}
-		}
-	}
-
-	return ScalarFunction::BindScalarFunction(context, bound_function, move(children), is_operator, cast_parameters);
-}
-
-unique_ptr<BoundFunctionExpression> ScalarFunction::BindScalarFunction(ClientContext &context,
-                                                                       ScalarFunction bound_function,
-                                                                       vector<unique_ptr<Expression>> children,
-                                                                       bool is_operator, bool cast_parameters) {
-	unique_ptr<FunctionData> bind_info;
-	if (bound_function.bind) {
-		bind_info = bound_function.bind(context, bound_function, children);
-	}
-	// check if we need to add casts to the children
-	bound_function.CastToFunctionArguments(children, cast_parameters);
-
-	// now create the function
-	auto return_type = bound_function.return_type;
-	return make_unique<BoundFunctionExpression>(move(return_type), move(bound_function), move(children),
-	                                            move(bind_info), is_operator);
-}
-
-unique_ptr<BoundAggregateExpression> AggregateFunction::BindAggregateFunction(
-    ClientContext &context, AggregateFunction bound_function, vector<unique_ptr<Expression>> children,
-    unique_ptr<Expression> filter, bool is_distinct, unique_ptr<BoundOrderModifier> order_bys, bool cast_parameters) {
-	unique_ptr<FunctionData> bind_info;
-	if (bound_function.bind) {
-		bind_info = bound_function.bind(context, bound_function, children);
-		// we may have lost some arguments in the bind
-		children.resize(MinValue(bound_function.arguments.size(), children.size()));
-	}
-
-	// check if we need to add casts to the children
-	bound_function.CastToFunctionArguments(children, cast_parameters);
-
-	// Special case: for ORDER BY aggregates, we wrap the aggregate function in a SortedAggregateFunction
-	// The children are the sort clauses and the binding contains the ordering data.
-	if (order_bys && !order_bys->orders.empty()) {
-		bind_info = BindSortedAggregate(bound_function, children, move(bind_info), move(order_bys));
-	}
-
-	return make_unique<BoundAggregateExpression>(move(bound_function), move(children), move(filter), move(bind_info),
-	                                             is_distinct);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-// MacroFunction::MacroFunction(unique_ptr<ParsedExpression> expression) : expression(move(expression)) {}
-
-MacroFunction::MacroFunction(MacroType type) : type(type) {
-}
-
-string MacroFunction::ValidateArguments(MacroFunction &macro_def, const string &name, FunctionExpression &function_expr,
-                                        vector<unique_ptr<ParsedExpression>> &positionals,
-                                        unordered_map<string, unique_ptr<ParsedExpression>> &defaults) {
-
-	// separate positional and default arguments
-	for (auto &arg : function_expr.children) {
-		if (arg->type == ExpressionType::VALUE_CONSTANT && !arg->alias.empty()) {
-			// default argument
-			if (macro_def.default_parameters.find(arg->alias) == macro_def.default_parameters.end()) {
-				return StringUtil::Format("Macro %s does not have default parameter %s!", name, arg->alias);
-			} else if (defaults.find(arg->alias) != defaults.end()) {
-				return StringUtil::Format("Duplicate default parameters %s!", arg->alias);
-			}
-			defaults[arg->alias] = move(arg);
-		} else if (!defaults.empty()) {
-			return "Positional parameters cannot come after parameters with a default value!";
-		} else {
-			// positional argument
-			positionals.push_back(move(arg));
-		}
-	}
-
-	// validate if the right number of arguments was supplied
-	string error;
-	auto &parameters = macro_def.parameters;
-	if (parameters.size() != positionals.size()) {
-		error = StringUtil::Format(
-		    "Macro function '%s(%s)' requires ", name,
-		    StringUtil::Join(parameters, parameters.size(), ", ", [](const unique_ptr<ParsedExpression> &p) {
-			    return ((ColumnRefExpression &)*p).column_names[0];
-		    }));
-		error += parameters.size() == 1 ? "a single positional argument"
-		                                : StringUtil::Format("%i positional arguments", parameters.size());
-		error += ", but ";
-		error += positionals.size() == 1 ? "a single positional argument was"
-		                                 : StringUtil::Format("%i positional arguments were", positionals.size());
-		error += " provided.";
-		return error;
-	}
-
-	// fill in default value where this was not supplied
-	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		if (defaults.find(it->first) == defaults.end()) {
-			defaults[it->first] = it->second->Copy();
-		}
-	}
-
-	return error;
-}
-
-void MacroFunction::CopyProperties(MacroFunction &other) {
-	other.type = type;
-	for (auto &param : parameters) {
-		other.parameters.push_back(param->Copy());
-	}
-	for (auto &kv : default_parameters) {
-		other.default_parameters[kv.first] = kv.second->Copy();
-	}
-}
-
-string MacroFunction::ToSQL(const string &schema, const string &name) {
-	vector<string> param_strings;
-	for (auto &param : parameters) {
-		param_strings.push_back(param->ToString());
-	}
-	for (auto &named_param : default_parameters) {
-		param_strings.push_back(StringUtil::Format("%s := %s", named_param.first, named_param.second->ToString()));
-	}
-
-	return StringUtil::Format("CREATE MACRO %s.%s(%s) AS ", schema, name, StringUtil::Join(param_strings, ", "));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cctype>
-
-namespace duckdb {
-
-static void PragmaEnableProfilingStatement(ClientContext &context, const FunctionParameters &parameters) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_profiler = true;
-	config.emit_profiler_output = true;
-}
-
-void RegisterEnableProfiling(BuiltinFunctions &set) {
-	vector<PragmaFunction> functions;
-	functions.push_back(PragmaFunction::PragmaStatement(string(), PragmaEnableProfilingStatement));
-
-	set.AddFunction("enable_profile", functions);
-	set.AddFunction("enable_profiling", functions);
-}
-
-static void PragmaDisableProfiling(ClientContext &context, const FunctionParameters &parameters) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_profiler = false;
-}
-
-static void PragmaEnableProgressBar(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_progress_bar = true;
-}
-
-static void PragmaDisableProgressBar(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_progress_bar = false;
-}
-
-static void PragmaEnablePrintProgressBar(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).print_progress_bar = true;
-}
-
-static void PragmaDisablePrintProgressBar(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).print_progress_bar = false;
-}
-
-static void PragmaEnableVerification(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).query_verification_enabled = true;
-}
-
-static void PragmaDisableVerification(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).query_verification_enabled = false;
-}
-
-static void PragmaEnableForceParallelism(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_parallelism = true;
-}
-
-static void PragmaEnableForceIndexJoin(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).force_index_join = true;
-}
-
-static void PragmaForceCheckpoint(ClientContext &context, const FunctionParameters &parameters) {
-	DBConfig::GetConfig(context).force_checkpoint = true;
-}
-
-static void PragmaDisableForceParallelism(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_parallelism = false;
-}
-
-static void PragmaEnableObjectCache(ClientContext &context, const FunctionParameters &parameters) {
-	DBConfig::GetConfig(context).object_cache_enable = true;
-}
-
-static void PragmaDisableObjectCache(ClientContext &context, const FunctionParameters &parameters) {
-	DBConfig::GetConfig(context).object_cache_enable = false;
-}
-
-static void PragmaEnableCheckpointOnShutdown(ClientContext &context, const FunctionParameters &parameters) {
-	DBConfig::GetConfig(context).checkpoint_on_shutdown = true;
-}
-
-static void PragmaDisableCheckpointOnShutdown(ClientContext &context, const FunctionParameters &parameters) {
-	DBConfig::GetConfig(context).checkpoint_on_shutdown = false;
-}
-
-static void PragmaEnableOptimizer(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_optimizer = true;
-}
-
-static void PragmaDisableOptimizer(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_optimizer = false;
-}
-
-void PragmaFunctions::RegisterFunction(BuiltinFunctions &set) {
-	RegisterEnableProfiling(set);
-
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_profile", PragmaDisableProfiling));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_profiling", PragmaDisableProfiling));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_verification", PragmaEnableVerification));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_verification", PragmaDisableVerification));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("verify_parallelism", PragmaEnableForceParallelism));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_verify_parallelism", PragmaDisableForceParallelism));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_object_cache", PragmaEnableObjectCache));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_object_cache", PragmaDisableObjectCache));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_optimizer", PragmaEnableOptimizer));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_optimizer", PragmaDisableOptimizer));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("force_index_join", PragmaEnableForceIndexJoin));
-	set.AddFunction(PragmaFunction::PragmaStatement("force_checkpoint", PragmaForceCheckpoint));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_progress_bar", PragmaEnableProgressBar));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_progress_bar", PragmaDisableProgressBar));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_print_progress_bar", PragmaEnablePrintProgressBar));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_print_progress_bar", PragmaDisablePrintProgressBar));
-
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_checkpoint_on_shutdown", PragmaEnableCheckpointOnShutdown));
-	set.AddFunction(
-	    PragmaFunction::PragmaStatement("disable_checkpoint_on_shutdown", PragmaDisableCheckpointOnShutdown));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-string PragmaTableInfo(ClientContext &context, const FunctionParameters &parameters) {
-	return StringUtil::Format("SELECT * FROM pragma_table_info('%s');", parameters.values[0].ToString());
-}
-
-string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT name FROM sqlite_master ORDER BY name;";
-}
-
-string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
-	return R"(
-			SELECT
-				t.table_name,
-				LIST(c.column_name order by c.column_name) AS column_names,
-				LIST(c.data_type order by c.column_name) AS column_types,
-				FIRST(t.temporary) AS temporary
-			FROM duckdb_tables t
-			JOIN duckdb_columns c
-			USING (table_oid)
-			GROUP BY t.table_name
-			ORDER BY t.table_name;
-	)";
-}
-
-string PragmaAllProfiling(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_last_profiling_output() JOIN pragma_detailed_profiling_output() ON "
-	       "(pragma_last_profiling_output.operator_id);";
-}
-
-string PragmaDatabaseList(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_database_list() ORDER BY 1;";
-}
-
-string PragmaCollations(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_collations() ORDER BY 1;";
-}
-
-string PragmaFunctionsQuery(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_functions() ORDER BY 1;";
-}
-
-string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
-	// PRAGMA table_info but with some aliases
-	return StringUtil::Format(
-	    "SELECT name AS \"column_name\", type as \"column_type\", CASE WHEN \"notnull\" THEN 'NO' ELSE 'YES' "
-	    "END AS \"null\", NULL AS \"key\", dflt_value AS \"default\", NULL AS \"extra\" FROM pragma_table_info('%s');",
-	    parameters.values[0].ToString());
-}
-
-string PragmaVersion(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_version();";
-}
-
-string PragmaImportDatabase(ClientContext &context, const FunctionParameters &parameters) {
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.enable_external_access) {
-		throw PermissionException("Import is disabled through configuration");
-	}
-	auto &fs = FileSystem::GetFileSystem(context);
-	auto *opener = FileSystem::GetFileOpener(context);
-
-	string query;
-	// read the "shema.sql" and "load.sql" files
-	vector<string> files = {"schema.sql", "load.sql"};
-	for (auto &file : files) {
-		auto file_path = fs.JoinPath(parameters.values[0].ToString(), file);
-		auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
-		                          FileSystem::DEFAULT_COMPRESSION, opener);
-		auto fsize = fs.GetFileSize(*handle);
-		auto buffer = unique_ptr<char[]>(new char[fsize]);
-		fs.Read(*handle, buffer.get(), fsize);
-
-		query += string(buffer.get(), fsize);
-	}
-	return query;
-}
-
-string PragmaDatabaseSize(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_database_size();";
-}
-
-string PragmaStorageInfo(ClientContext &context, const FunctionParameters &parameters) {
-	return StringUtil::Format("SELECT * FROM pragma_storage_info('%s');", parameters.values[0].ToString());
-}
-
-void PragmaQueries::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(PragmaFunction::PragmaCall("table_info", PragmaTableInfo, {LogicalType::VARCHAR}));
-	set.AddFunction(PragmaFunction::PragmaCall("storage_info", PragmaStorageInfo, {LogicalType::VARCHAR}));
-	set.AddFunction(PragmaFunction::PragmaStatement("show_tables", PragmaShowTables));
-	set.AddFunction(PragmaFunction::PragmaStatement("show_tables_expanded", PragmaShowTablesExpanded));
-	set.AddFunction(PragmaFunction::PragmaStatement("database_list", PragmaDatabaseList));
-	set.AddFunction(PragmaFunction::PragmaStatement("collations", PragmaCollations));
-	set.AddFunction(PragmaFunction::PragmaCall("show", PragmaShow, {LogicalType::VARCHAR}));
-	set.AddFunction(PragmaFunction::PragmaStatement("version", PragmaVersion));
-	set.AddFunction(PragmaFunction::PragmaStatement("database_size", PragmaDatabaseSize));
-	set.AddFunction(PragmaFunction::PragmaStatement("functions", PragmaFunctionsQuery));
-	set.AddFunction(PragmaFunction::PragmaCall("import_database", PragmaImportDatabase, {LogicalType::VARCHAR}));
-	set.AddFunction(PragmaFunction::PragmaStatement("all_profiling_output", PragmaAllProfiling));
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-PragmaFunction::PragmaFunction(string name, PragmaType pragma_type, pragma_query_t query, pragma_function_t function,
-                               vector<LogicalType> arguments, LogicalType varargs)
-    : SimpleNamedParameterFunction(move(name), move(arguments), move(varargs)), type(pragma_type), query(query),
-      function(function) {
-}
-
-PragmaFunction PragmaFunction::PragmaCall(const string &name, pragma_query_t query, vector<LogicalType> arguments,
-                                          LogicalType varargs) {
-	return PragmaFunction(name, PragmaType::PRAGMA_CALL, query, nullptr, move(arguments), move(varargs));
-}
-
-PragmaFunction PragmaFunction::PragmaCall(const string &name, pragma_function_t function, vector<LogicalType> arguments,
-                                          LogicalType varargs) {
-	return PragmaFunction(name, PragmaType::PRAGMA_CALL, nullptr, function, move(arguments), move(varargs));
-}
-
-PragmaFunction PragmaFunction::PragmaStatement(const string &name, pragma_query_t query) {
-	vector<LogicalType> types;
-	return PragmaFunction(name, PragmaType::PRAGMA_STATEMENT, query, nullptr, move(types), LogicalType::INVALID);
-}
-
-PragmaFunction PragmaFunction::PragmaStatement(const string &name, pragma_function_t function) {
-	vector<LogicalType> types;
-	return PragmaFunction(name, PragmaType::PRAGMA_STATEMENT, nullptr, function, move(types), LogicalType::INVALID);
-}
-
-string PragmaFunction::ToString() {
-	switch (type) {
-	case PragmaType::PRAGMA_STATEMENT:
-		return StringUtil::Format("PRAGMA %s", name);
-	case PragmaType::PRAGMA_CALL: {
-		return StringUtil::Format("PRAGMA %s", SimpleNamedParameterFunction::ToString());
-	}
-	default:
-		return "UNKNOWN";
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct Base64EncodeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto result_str = StringVector::EmptyString(result, Blob::ToBase64Size(input));
-		Blob::ToBase64(input, result_str.GetDataWriteable());
-		result_str.Finalize();
-		return result_str;
-	}
-};
-
-struct Base64DecodeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto result_size = Blob::FromBase64Size(input);
-		auto result_blob = StringVector::EmptyString(result, result_size);
-		Blob::FromBase64(input, (data_ptr_t)result_blob.GetDataWriteable(), result_size);
-		result_blob.Finalize();
-		return result_blob;
-	}
-};
-
-static void Base64EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// decode is also a nop cast, but requires verification if the provided string is actually
-	UnaryExecutor::ExecuteString<string_t, string_t, Base64EncodeOperator>(args.data[0], result, args.size());
-}
-
-static void Base64DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// decode is also a nop cast, but requires verification if the provided string is actually
-	UnaryExecutor::ExecuteString<string_t, string_t, Base64DecodeOperator>(args.data[0], result, args.size());
-}
-
-void Base64Fun::RegisterFunction(BuiltinFunctions &set) {
-	// base64 encode
-	ScalarFunction to_base64({LogicalType::BLOB}, LogicalType::VARCHAR, Base64EncodeFunction);
-	set.AddFunction({"base64", "to_base64"}, to_base64); // to_base64 is a mysql alias
-
-	set.AddFunction(ScalarFunction("from_base64", {LogicalType::VARCHAR}, LogicalType::BLOB, Base64DecodeFunction));
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-static void EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// encode is essentially a nop cast from varchar to blob
-	// we only need to reinterpret the data using the blob type
-	result.Reinterpret(args.data[0]);
-}
-
-struct BlobDecodeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		auto input_data = input.GetDataUnsafe();
-		auto input_length = input.GetSize();
-		if (Utf8Proc::Analyze(input_data, input_length) == UnicodeType::INVALID) {
-			throw ConversionException(
-			    "Failure in decode: could not convert blob to UTF8 string, the blob contained invalid UTF8 characters");
-		}
-		return input;
-	}
-};
-
-static void DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// decode is also a nop cast, but requires verification if the provided string is actually
-	UnaryExecutor::Execute<string_t, string_t, BlobDecodeOperator>(args.data[0], result, args.size());
-	StringVector::AddHeapReference(result, args.data[0]);
-}
-
-void EncodeFun::RegisterFunction(BuiltinFunctions &set) {
-	// encode goes from varchar -> blob, this never fails
-	set.AddFunction(ScalarFunction("encode", {LogicalType::VARCHAR}, LogicalType::BLOB, EncodeFunction));
-	// decode goes from blob -> varchar, this fails if the varchar is not valid utf8
-	set.AddFunction(ScalarFunction("decode", {LogicalType::BLOB}, LogicalType::VARCHAR, DecodeFunction));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void AgeFunctionStandard(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-	auto current_timestamp = Timestamp::GetCurrentTimestamp();
-
-	UnaryExecutor::ExecuteWithNulls<timestamp_t, interval_t>(input.data[0], result, input.size(),
-	                                                         [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
-		                                                         if (Timestamp::IsFinite(input)) {
-			                                                         return Interval::GetAge(current_timestamp, input);
-		                                                         } else {
-			                                                         mask.SetInvalid(idx);
-			                                                         return interval_t();
-		                                                         }
-	                                                         });
-}
-
-static void AgeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 2);
-
-	BinaryExecutor::ExecuteWithNulls<timestamp_t, timestamp_t, interval_t>(
-	    input.data[0], input.data[1], result, input.size(),
-	    [&](timestamp_t input1, timestamp_t input2, ValidityMask &mask, idx_t idx) {
-		    if (Timestamp::IsFinite(input1) && Timestamp::IsFinite(input2)) {
-			    return Interval::GetAge(input1, input2);
-		    } else {
-			    mask.SetInvalid(idx);
-			    return interval_t();
-		    }
-	    });
-}
-
-void AgeFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet age("age");
-	age.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::INTERVAL, AgeFunctionStandard));
-	age.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP}, LogicalType::INTERVAL, AgeFunction));
-	set.AddFunction(age);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CurrentBindData : public FunctionData {
-	ClientContext &context;
-
-	explicit CurrentBindData(ClientContext &context) : context(context) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<CurrentBindData>(context);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		return true;
-	}
-};
-
-static timestamp_t GetTransactionTimestamp(ExpressionState &state) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (CurrentBindData &)*func_expr.bind_info;
-	return info.context.ActiveTransaction().start_timestamp;
-}
-
-static void CurrentTimeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 0);
-
-	auto val = Value::TIME(Timestamp::GetTime(GetTransactionTimestamp(state)));
-	result.Reference(val);
-}
-
-static void CurrentDateFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 0);
-
-	auto val = Value::DATE(Timestamp::GetDate(GetTransactionTimestamp(state)));
-	result.Reference(val);
-}
-
-static void CurrentTimestampFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 0);
-
-	auto val = Value::TIMESTAMP(GetTransactionTimestamp(state));
-	result.Reference(val);
-}
-
-unique_ptr<FunctionData> BindCurrentTime(ClientContext &context, ScalarFunction &bound_function,
-                                         vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<CurrentBindData>(context);
-}
-
-void CurrentTimeFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("get_current_time", {}, LogicalType::TIME, CurrentTimeFunction, false, BindCurrentTime));
-}
-
-void CurrentDateFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("current_date", {}, LogicalType::DATE, CurrentDateFunction, false, BindCurrentTime));
-}
-
-void CurrentTimestampFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    {"now", "get_current_timestamp"},
-	    ScalarFunction({}, LogicalType::TIMESTAMP, CurrentTimestampFunction, false, false, BindCurrentTime));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-// This function is an implementation of the "period-crossing" date difference function from T-SQL
-// https://docs.microsoft.com/en-us/sql/t-sql/functions/datediff-transact-sql?view=sql-server-ver15
-struct DateDiff {
-	template <class TA, class TB, class TR, class OP>
-	static inline void BinaryExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		BinaryExecutor::ExecuteWithNulls<TA, TB, TR>(
-		    left, right, result, count, [&](TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
-			    if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
-				    return OP::template Operation<TA, TB, TR>(startdate, enddate);
-			    } else {
-				    mask.SetInvalid(idx);
-				    return TR();
-			    }
-		    });
-	}
-
-	struct YearOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractYear(enddate) - Date::ExtractYear(startdate);
-		}
-	};
-
-	struct MonthOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			int32_t start_year, start_month, start_day;
-			Date::Convert(startdate, start_year, start_month, start_day);
-			int32_t end_year, end_month, end_day;
-			Date::Convert(enddate, end_year, end_month, end_day);
-
-			return (end_year * 12 + end_month - 1) - (start_year * 12 + start_month - 1);
-		}
-	};
-
-	struct DayOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::EpochDays(enddate) - Date::EpochDays(startdate);
-		}
-	};
-
-	struct DecadeOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractYear(enddate) / 10 - Date::ExtractYear(startdate) / 10;
-		}
-	};
-
-	struct CenturyOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractYear(enddate) / 100 - Date::ExtractYear(startdate) / 100;
-		}
-	};
-
-	struct MilleniumOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractYear(enddate) / 1000 - Date::ExtractYear(startdate) / 1000;
-		}
-	};
-
-	struct QuarterOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			int32_t start_year, start_month, start_day;
-			Date::Convert(startdate, start_year, start_month, start_day);
-			int32_t end_year, end_month, end_day;
-			Date::Convert(enddate, end_year, end_month, end_day);
-
-			return (end_year * 12 + end_month - 1) / Interval::MONTHS_PER_QUARTER -
-			       (start_year * 12 + start_month - 1) / Interval::MONTHS_PER_QUARTER;
-		}
-	};
-
-	struct WeekOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::Epoch(enddate) / Interval::SECS_PER_WEEK - Date::Epoch(startdate) / Interval::SECS_PER_WEEK;
-		}
-	};
-
-	struct ISOYearOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::ExtractISOYearNumber(enddate) - Date::ExtractISOYearNumber(startdate);
-		}
-	};
-
-	struct MicrosecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::EpochNanoseconds(enddate) / Interval::NANOS_PER_MICRO -
-			       Date::EpochNanoseconds(startdate) / Interval::NANOS_PER_MICRO;
-		}
-	};
-
-	struct MillisecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::EpochNanoseconds(enddate) / Interval::NANOS_PER_MSEC -
-			       Date::EpochNanoseconds(startdate) / Interval::NANOS_PER_MSEC;
-		}
-	};
-
-	struct SecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::Epoch(enddate) - Date::Epoch(startdate);
-		}
-	};
-
-	struct MinutesOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::Epoch(enddate) / Interval::SECS_PER_MINUTE -
-			       Date::Epoch(startdate) / Interval::SECS_PER_MINUTE;
-		}
-	};
-
-	struct HoursOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::Epoch(enddate) / Interval::SECS_PER_HOUR - Date::Epoch(startdate) / Interval::SECS_PER_HOUR;
-		}
-	};
-};
-
-// TIMESTAMP specialisations
-template <>
-int64_t DateDiff::YearOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return YearOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate), Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::MonthOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return MonthOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                         Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::DayOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return DayOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate), Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::DecadeOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return DecadeOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                          Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::CenturyOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return CenturyOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                           Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::MilleniumOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return MilleniumOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                             Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::QuarterOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return QuarterOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                           Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::WeekOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return WeekOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate), Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::ISOYearOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return ISOYearOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
-	                                                           Timestamp::GetDate(enddate));
-}
-
-template <>
-int64_t DateDiff::MicrosecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate);
-}
-
-template <>
-int64_t DateDiff::MillisecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return Timestamp::GetEpochMs(enddate) - Timestamp::GetEpochMs(startdate);
-}
-
-template <>
-int64_t DateDiff::SecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return Timestamp::GetEpochSeconds(enddate) - Timestamp::GetEpochSeconds(startdate);
-}
-
-template <>
-int64_t DateDiff::MinutesOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return Timestamp::GetEpochSeconds(enddate) / Interval::SECS_PER_MINUTE -
-	       Timestamp::GetEpochSeconds(startdate) / Interval::SECS_PER_MINUTE;
-}
-
-template <>
-int64_t DateDiff::HoursOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
-	return Timestamp::GetEpochSeconds(enddate) / Interval::SECS_PER_HOUR -
-	       Timestamp::GetEpochSeconds(startdate) / Interval::SECS_PER_HOUR;
-}
-
-// TIME specialisations
-template <>
-int64_t DateDiff::YearOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"year\" not recognized");
-}
-
-template <>
-int64_t DateDiff::MonthOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"month\" not recognized");
-}
-
-template <>
-int64_t DateDiff::DayOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"day\" not recognized");
-}
-
-template <>
-int64_t DateDiff::DecadeOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"decade\" not recognized");
-}
-
-template <>
-int64_t DateDiff::CenturyOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"century\" not recognized");
-}
-
-template <>
-int64_t DateDiff::MilleniumOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"millennium\" not recognized");
-}
-
-template <>
-int64_t DateDiff::QuarterOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"quarter\" not recognized");
-}
-
-template <>
-int64_t DateDiff::WeekOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"week\" not recognized");
-}
-
-template <>
-int64_t DateDiff::ISOYearOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"isoyear\" not recognized");
-}
-
-template <>
-int64_t DateDiff::MicrosecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros - startdate.micros;
-}
-
-template <>
-int64_t DateDiff::MillisecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros / Interval::MICROS_PER_MSEC - startdate.micros / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DateDiff::SecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros / Interval::MICROS_PER_SEC - startdate.micros / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DateDiff::MinutesOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros / Interval::MICROS_PER_MINUTE - startdate.micros / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DateDiff::HoursOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros / Interval::MICROS_PER_HOUR - startdate.micros / Interval::MICROS_PER_HOUR;
-}
-
-template <typename TA, typename TB, typename TR>
-static int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-		return DateDiff::YearOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MONTH:
-		return DateDiff::MonthOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-		return DateDiff::DayOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::DECADE:
-		return DateDiff::DecadeOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::CENTURY:
-		return DateDiff::CenturyOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MILLENNIUM:
-		return DateDiff::MilleniumOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::QUARTER:
-		return DateDiff::QuarterOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		return DateDiff::WeekOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::ISOYEAR:
-		return DateDiff::ISOYearOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MICROSECONDS:
-		return DateDiff::MicrosecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MILLISECONDS:
-		return DateDiff::MillisecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		return DateDiff::SecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MINUTE:
-		return DateDiff::MinutesOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::HOUR:
-		return DateDiff::HoursOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATEDIFF");
-	}
-}
-
-struct DateDiffTernaryOperator {
-	template <typename TS, typename TA, typename TB, typename TR>
-	static inline TR Operation(TS part, TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
-		if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
-			return DifferenceDates<TA, TB, TR>(GetDatePartSpecifier(part.GetString()), startdate, enddate);
-		} else {
-			mask.SetInvalid(idx);
-			return TR();
-		}
-	}
-};
-
-template <typename TA, typename TB, typename TR>
-static void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::YearOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MONTH:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MonthOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::DayOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::DECADE:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::DecadeOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::CENTURY:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::CenturyOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MILLENNIUM:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MilleniumOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::QUARTER:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::QuarterOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::WeekOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::ISOYEAR:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::ISOYearOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MicrosecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MillisecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::SecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MINUTE:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MinutesOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::HOUR:
-		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::HoursOperator>(left, right, result, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATEDIFF");
-	}
-}
-
-template <typename T>
-static void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-	auto &part_arg = args.data[0];
-	auto &start_arg = args.data[1];
-	auto &end_arg = args.data[2];
-
-	if (part_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// Common case of constant part.
-		if (ConstantVector::IsNull(part_arg)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateDiffBinaryExecutor<T, T, int64_t>(type, start_arg, end_arg, result, args.size());
-		}
-	} else {
-		TernaryExecutor::ExecuteWithNulls<string_t, T, T, int64_t>(
-		    part_arg, start_arg, end_arg, result, args.size(),
-		    DateDiffTernaryOperator::Operation<string_t, T, T, int64_t>);
-	}
-}
-
-void DateDiffFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet date_diff("date_diff");
-	date_diff.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE, LogicalType::DATE},
-	                                     LogicalType::BIGINT, DateDiffFunction<date_t>));
-	date_diff.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
-	                                     LogicalType::BIGINT, DateDiffFunction<timestamp_t>));
-	date_diff.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME, LogicalType::TIME},
-	                                     LogicalType::BIGINT, DateDiffFunction<dtime_t>));
-	set.AddFunction(date_diff);
-
-	date_diff.name = "datediff";
-	set.AddFunction(date_diff);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &result) {
-	auto specifier = StringUtil::Lower(specifier_p);
-	if (specifier == "year" || specifier == "y" || specifier == "years") {
-		result = DatePartSpecifier::YEAR;
-	} else if (specifier == "month" || specifier == "mon" || specifier == "months" || specifier == "mons") {
-		result = DatePartSpecifier::MONTH;
-	} else if (specifier == "day" || specifier == "days" || specifier == "d" || specifier == "dayofmonth") {
-		result = DatePartSpecifier::DAY;
-	} else if (specifier == "decade" || specifier == "decades") {
-		result = DatePartSpecifier::DECADE;
-	} else if (specifier == "century" || specifier == "centuries") {
-		result = DatePartSpecifier::CENTURY;
-	} else if (specifier == "millennium" || specifier == "millennia" || specifier == "millenium") {
-		result = DatePartSpecifier::MILLENNIUM;
-	} else if (specifier == "microseconds" || specifier == "microsecond") {
-		result = DatePartSpecifier::MICROSECONDS;
-	} else if (specifier == "milliseconds" || specifier == "millisecond" || specifier == "ms" || specifier == "msec" ||
-	           specifier == "msecs") {
-		result = DatePartSpecifier::MILLISECONDS;
-	} else if (specifier == "second" || specifier == "seconds" || specifier == "s") {
-		result = DatePartSpecifier::SECOND;
-	} else if (specifier == "minute" || specifier == "minutes" || specifier == "m") {
-		result = DatePartSpecifier::MINUTE;
-	} else if (specifier == "hour" || specifier == "hours" || specifier == "h") {
-		result = DatePartSpecifier::HOUR;
-	} else if (specifier == "epoch") {
-		// seconds since 1970-01-01
-		result = DatePartSpecifier::EPOCH;
-	} else if (specifier == "dow" || specifier == "dayofweek" || specifier == "weekday") {
-		// day of the week (Sunday = 0, Saturday = 6)
-		result = DatePartSpecifier::DOW;
-	} else if (specifier == "isodow") {
-		// isodow (Monday = 1, Sunday = 7)
-		result = DatePartSpecifier::ISODOW;
-	} else if (specifier == "week" || specifier == "weeks" || specifier == "w" || specifier == "weekofyear") {
-		// ISO week number
-		result = DatePartSpecifier::WEEK;
-	} else if (specifier == "doy" || specifier == "dayofyear") {
-		// day of the year (1-365/366)
-		result = DatePartSpecifier::DOY;
-	} else if (specifier == "quarter" || specifier == "quarters") {
-		// quarter of the year (1-4)
-		result = DatePartSpecifier::QUARTER;
-	} else if (specifier == "yearweek") {
-		// Combined isoyear and isoweek YYYYWW
-		result = DatePartSpecifier::YEARWEEK;
-	} else if (specifier == "isoyear") {
-		// ISO year (first week of the year may be in previous year)
-		result = DatePartSpecifier::ISOYEAR;
-	} else if (specifier == "era") {
-		result = DatePartSpecifier::ERA;
-	} else if (specifier == "timezone") {
-		result = DatePartSpecifier::TIMEZONE;
-	} else if (specifier == "timezone_hour") {
-		result = DatePartSpecifier::TIMEZONE_HOUR;
-	} else if (specifier == "timezone_minute") {
-		result = DatePartSpecifier::TIMEZONE_MINUTE;
-	} else {
-		return false;
-	}
-	return true;
-}
-
-DatePartSpecifier GetDatePartSpecifier(const string &specifier) {
-	DatePartSpecifier result;
-	if (!TryGetDatePartSpecifier(specifier, result)) {
-		throw ConversionException("extract specifier \"%s\" not recognized", specifier);
-	}
-	return result;
-}
-
-DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType &type) {
-	const auto part = GetDatePartSpecifier(specifier);
-	switch (type.id()) {
-	case LogicalType::TIMESTAMP:
-	case LogicalType::TIMESTAMP_TZ:
-		return part;
-	case LogicalType::DATE:
-		switch (part) {
-		case DatePartSpecifier::YEAR:
-		case DatePartSpecifier::MONTH:
-		case DatePartSpecifier::DAY:
-		case DatePartSpecifier::DECADE:
-		case DatePartSpecifier::CENTURY:
-		case DatePartSpecifier::MILLENNIUM:
-		case DatePartSpecifier::DOW:
-		case DatePartSpecifier::ISODOW:
-		case DatePartSpecifier::ISOYEAR:
-		case DatePartSpecifier::WEEK:
-		case DatePartSpecifier::QUARTER:
-		case DatePartSpecifier::DOY:
-		case DatePartSpecifier::YEARWEEK:
-		case DatePartSpecifier::ERA:
-			return part;
-		default:
-			break;
-		}
-		break;
-	case LogicalType::TIME:
-		switch (part) {
-		case DatePartSpecifier::MICROSECONDS:
-		case DatePartSpecifier::MILLISECONDS:
-		case DatePartSpecifier::SECOND:
-		case DatePartSpecifier::MINUTE:
-		case DatePartSpecifier::HOUR:
-		case DatePartSpecifier::EPOCH:
-		case DatePartSpecifier::TIMEZONE:
-		case DatePartSpecifier::TIMEZONE_HOUR:
-		case DatePartSpecifier::TIMEZONE_MINUTE:
-			return part;
-		default:
-			break;
-		}
-		break;
-	case LogicalType::INTERVAL:
-		switch (part) {
-		case DatePartSpecifier::YEAR:
-		case DatePartSpecifier::MONTH:
-		case DatePartSpecifier::DAY:
-		case DatePartSpecifier::DECADE:
-		case DatePartSpecifier::CENTURY:
-		case DatePartSpecifier::QUARTER:
-		case DatePartSpecifier::MILLENNIUM:
-		case DatePartSpecifier::MICROSECONDS:
-		case DatePartSpecifier::MILLISECONDS:
-		case DatePartSpecifier::SECOND:
-		case DatePartSpecifier::MINUTE:
-		case DatePartSpecifier::HOUR:
-		case DatePartSpecifier::EPOCH:
-			return part;
-		default:
-			break;
-		}
-		break;
-	default:
-		break;
-	}
-
-	throw NotImplementedException("\"%s\" units \"%s\" not recognized", LogicalTypeIdToString(type.id()), specifier);
-}
-
-template <int64_t MIN, int64_t MAX>
-static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
-	// we can always propagate simple date part statistics
-	// since the min and max can never exceed these bounds
-	auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(MIN), Value::BIGINT(MAX),
-	                                             StatisticsType::LOCAL_STATS);
-	if (!child_stats[0]) {
-		// if there are no child stats, we don't know
-		result->validity_stats = make_unique<ValidityStatistics>(true);
-	} else if (child_stats[0]->validity_stats) {
-		result->validity_stats = child_stats[0]->validity_stats->Copy();
-	}
-	return move(result);
-}
-
-struct DatePart {
-	template <class T, class OP>
-	static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
-		// we can only propagate complex date part stats if the child has stats
-		if (!child_stats[0]) {
-			return nullptr;
-		}
-		auto &nstats = (NumericStatistics &)*child_stats[0];
-		if (nstats.min.IsNull() || nstats.max.IsNull()) {
-			return nullptr;
-		}
-		// run the operator on both the min and the max, this gives us the [min, max] bound
-		auto min = nstats.min.GetValueUnsafe<T>();
-		auto max = nstats.max.GetValueUnsafe<T>();
-		if (min > max) {
-			return nullptr;
-		}
-		// Infinities prevent us from computing generic ranges
-		if (!Value::IsFinite(min) || !Value::IsFinite(max)) {
-			return nullptr;
-		}
-		auto min_part = OP::template Operation<T, int64_t>(min);
-		auto max_part = OP::template Operation<T, int64_t>(max);
-		auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(min_part),
-		                                             Value::BIGINT(max_part), StatisticsType::LOCAL_STATS);
-		if (child_stats[0]->validity_stats) {
-			result->validity_stats = child_stats[0]->validity_stats->Copy();
-		}
-		return move(result);
-	}
-
-	template <typename OP>
-	struct PartOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input, ValidityMask &mask, idx_t idx, void *dataptr) {
-			if (Value::IsFinite(input)) {
-				return OP::template Operation<TA, TR>(input);
-			} else {
-				mask.SetInvalid(idx);
-				return TR();
-			}
-		}
-	};
-
-	template <class TA, class TR, class OP>
-	static void UnaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-		D_ASSERT(input.ColumnCount() >= 1);
-		using IOP = PartOperator<OP>;
-		UnaryExecutor::GenericExecute<TA, TR, IOP>(input.data[0], result, input.size(), nullptr, true);
-	}
-
-	struct YearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractYear(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, YearOperator>(input.child_stats);
-		}
-	};
-
-	struct MonthOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractMonth(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			// min/max of month operator is [1, 12]
-			return PropagateSimpleDatePartStatistics<1, 12>(input.child_stats);
-		}
-	};
-
-	struct DayOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractDay(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			// min/max of day operator is [1, 31]
-			return PropagateSimpleDatePartStatistics<1, 31>(input.child_stats);
-		}
-	};
-
-	struct DecadeOperator {
-		// From the PG docs: "The year field divided by 10"
-		template <typename TR>
-		static inline TR DecadeFromYear(TR yyyy) {
-			return yyyy / 10;
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return DecadeFromYear(YearOperator::Operation<TA, TR>(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, DecadeOperator>(input.child_stats);
-		}
-	};
-
-	struct CenturyOperator {
-		// From the PG docs:
-		// "The first century starts at 0001-01-01 00:00:00 AD, although they did not know it at the time.
-		// This definition applies to all Gregorian calendar countries.
-		// There is no century number 0, you go from -1 century to 1 century.
-		// If you disagree with this, please write your complaint to: Pope, Cathedral Saint-Peter of Roma, Vatican."
-		// (To be fair, His Holiness had nothing to do with this -
-		// it was the lack of zero in the counting systems of the time...)
-		template <typename TR>
-		static inline TR CenturyFromYear(TR yyyy) {
-			if (yyyy > 0) {
-				return ((yyyy - 1) / 100) + 1;
-			} else {
-				return (yyyy / 100) - 1;
-			}
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return CenturyFromYear(YearOperator::Operation<TA, TR>(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, CenturyOperator>(input.child_stats);
-		}
-	};
-
-	struct MillenniumOperator {
-		// See the century comment
-		template <typename TR>
-		static inline TR MillenniumFromYear(TR yyyy) {
-			if (yyyy > 0) {
-				return ((yyyy - 1) / 1000) + 1;
-			} else {
-				return (yyyy / 1000) - 1;
-			}
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return MillenniumFromYear<TR>(YearOperator::Operation<TA, TR>(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, MillenniumOperator>(input.child_stats);
-		}
-	};
-
-	struct QuarterOperator {
-		template <class TR>
-		static inline TR QuarterFromMonth(TR mm) {
-			return (mm - 1) / Interval::MONTHS_PER_QUARTER + 1;
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return QuarterFromMonth(Date::ExtractMonth(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			// min/max of quarter operator is [1, 4]
-			return PropagateSimpleDatePartStatistics<1, 4>(input.child_stats);
-		}
-	};
-
-	struct DayOfWeekOperator {
-		template <class TR>
-		static inline TR DayOfWeekFromISO(TR isodow) {
-			// day of the week (Sunday = 0, Saturday = 6)
-			// turn sunday into 0 by doing mod 7
-			return isodow % 7;
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return DayOfWeekFromISO(Date::ExtractISODayOfTheWeek(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 6>(input.child_stats);
-		}
-	};
-
-	struct ISODayOfWeekOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			// isodow (Monday = 1, Sunday = 7)
-			return Date::ExtractISODayOfTheWeek(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<1, 7>(input.child_stats);
-		}
-	};
-
-	struct DayOfYearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractDayOfTheYear(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<1, 366>(input.child_stats);
-		}
-	};
-
-	struct WeekOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractISOWeekNumber(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<1, 54>(input.child_stats);
-		}
-	};
-
-	struct ISOYearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::ExtractISOYearNumber(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, ISOYearOperator>(input.child_stats);
-		}
-	};
-
-	struct YearWeekOperator {
-		template <class TR>
-		static inline TR YearWeekFromParts(TR yyyy, TR ww) {
-			return yyyy * 100 + ((yyyy > 0) ? ww : -ww);
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t yyyy, ww;
-			Date::ExtractISOYearWeek(input, yyyy, ww);
-			return YearWeekFromParts(yyyy, ww);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, YearWeekOperator>(input.child_stats);
-		}
-	};
-
-	struct MicrosecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60000000>(input.child_stats);
-		}
-	};
-
-	struct MillisecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60000>(input.child_stats);
-		}
-	};
-
-	struct SecondsOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60>(input.child_stats);
-		}
-	};
-
-	struct MinutesOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 60>(input.child_stats);
-		}
-	};
-
-	struct HoursOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 24>(input.child_stats);
-		}
-	};
-
-	struct EpochOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::Epoch(input);
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, EpochOperator>(input.child_stats);
-		}
-	};
-
-	struct EraOperator {
-		template <class TR>
-		static inline TR EraFromYear(TR yyyy) {
-			return yyyy > 0 ? 1 : 0;
-		}
-
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return EraFromYear(Date::ExtractYear(input));
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 1>(input.child_stats);
-		}
-	};
-
-	struct TimezoneOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			// Regular timestamps are UTC.
-			return 0;
-		}
-
-		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateSimpleDatePartStatistics<0, 0>(input.child_stats);
-		}
-	};
-
-	// These are all zero and have the same restrictions
-	using TimezoneHourOperator = TimezoneOperator;
-	using TimezoneMinuteOperator = TimezoneOperator;
-
-	struct StructOperator {
-		using part_codes_t = vector<DatePartSpecifier>;
-		using part_mask_t = uint64_t;
-
-		enum MaskBits : uint8_t {
-			YMD = 1 << 0,
-			DOW = 1 << 1,
-			DOY = 1 << 2,
-			EPOCH = 1 << 3,
-			TIME = 1 << 4,
-			ZONE = 1 << 5,
-			ISO = 1 << 6
-		};
-
-		static part_mask_t GetMask(const part_codes_t &part_codes) {
-			part_mask_t mask = 0;
-			for (const auto &part_code : part_codes) {
-				switch (part_code) {
-				case DatePartSpecifier::YEAR:
-				case DatePartSpecifier::MONTH:
-				case DatePartSpecifier::DAY:
-				case DatePartSpecifier::DECADE:
-				case DatePartSpecifier::CENTURY:
-				case DatePartSpecifier::MILLENNIUM:
-				case DatePartSpecifier::QUARTER:
-				case DatePartSpecifier::ERA:
-					mask |= YMD;
-					break;
-				case DatePartSpecifier::YEARWEEK:
-				case DatePartSpecifier::WEEK:
-				case DatePartSpecifier::ISOYEAR:
-					mask |= ISO;
-					break;
-				case DatePartSpecifier::DOW:
-				case DatePartSpecifier::ISODOW:
-					mask |= DOW;
-					break;
-				case DatePartSpecifier::DOY:
-					mask |= DOY;
-					break;
-				case DatePartSpecifier::EPOCH:
-					mask |= EPOCH;
-					break;
-				case DatePartSpecifier::MICROSECONDS:
-				case DatePartSpecifier::MILLISECONDS:
-				case DatePartSpecifier::SECOND:
-				case DatePartSpecifier::MINUTE:
-				case DatePartSpecifier::HOUR:
-					mask |= TIME;
-					break;
-				case DatePartSpecifier::TIMEZONE:
-				case DatePartSpecifier::TIMEZONE_HOUR:
-				case DatePartSpecifier::TIMEZONE_MINUTE:
-					mask |= ZONE;
-					break;
-				}
-			}
-			return mask;
-		}
-
-		template <typename P>
-		static inline P HasPartValue(P *part_values, DatePartSpecifier part) {
-			return part_values[int(part)];
-		}
-
-		template <class TA, class TR>
-		static inline void Operation(TR **part_values, const TA &input, const idx_t idx, const part_mask_t mask) {
-			TR *part_data;
-			// YMD calculations
-			int32_t yyyy = 1970;
-			int32_t mm = 0;
-			int32_t dd = 1;
-			if (mask & YMD) {
-				Date::Convert(input, yyyy, mm, dd);
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEAR))) {
-					part_data[idx] = yyyy;
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::MONTH))) {
-					part_data[idx] = mm;
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DAY))) {
-					part_data[idx] = dd;
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DECADE))) {
-					part_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY))) {
-					part_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM))) {
-					part_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER))) {
-					part_data[idx] = QuarterOperator::QuarterFromMonth(mm);
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ERA))) {
-					part_data[idx] = EraOperator::EraFromYear(yyyy);
-				}
-			}
-
-			// Week calculations
-			if (mask & DOW) {
-				auto isodow = Date::ExtractISODayOfTheWeek(input);
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DOW))) {
-					part_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ISODOW))) {
-					part_data[idx] = isodow;
-				}
-			}
-
-			// ISO calculations
-			if (mask & ISO) {
-				int32_t ww = 0;
-				int32_t iyyy = 0;
-				Date::ExtractISOYearWeek(input, iyyy, ww);
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::WEEK))) {
-					part_data[idx] = ww;
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ISOYEAR))) {
-					part_data[idx] = iyyy;
-				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEARWEEK))) {
-					part_data[idx] = YearWeekOperator::YearWeekFromParts(iyyy, ww);
-				}
-			}
-
-			if (mask & EPOCH) {
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
-					part_data[idx] = Date::Epoch(input);
-				}
-			}
-			if (mask & DOY) {
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DOY))) {
-					part_data[idx] = Date::ExtractDayOfTheYear(input);
-				}
-			}
-		}
-	};
-};
-
-template <class T>
-static void LastYearFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	int32_t last_year = 0;
-	UnaryExecutor::ExecuteWithNulls<T, int64_t>(args.data[0], result, args.size(),
-	                                            [&](T input, ValidityMask &mask, idx_t idx) {
-		                                            if (Value::IsFinite(input)) {
-			                                            return Date::ExtractYear(input, &last_year);
-		                                            } else {
-			                                            mask.SetInvalid(idx);
-			                                            return 0;
-		                                            }
-	                                            });
-}
-
-template <>
-int64_t DatePart::YearOperator::Operation(timestamp_t input) {
-	return YearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::YearOperator::Operation(interval_t input) {
-	return input.months / Interval::MONTHS_PER_YEAR;
-}
-
-template <>
-int64_t DatePart::YearOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"year\" not recognized");
-}
-
-template <>
-int64_t DatePart::MonthOperator::Operation(timestamp_t input) {
-	return MonthOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::MonthOperator::Operation(interval_t input) {
-	return input.months % Interval::MONTHS_PER_YEAR;
-}
-
-template <>
-int64_t DatePart::MonthOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"month\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOperator::Operation(timestamp_t input) {
-	return DayOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::DayOperator::Operation(interval_t input) {
-	return input.days;
-}
-
-template <>
-int64_t DatePart::DayOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"day\" not recognized");
-}
-
-template <>
-int64_t DatePart::DecadeOperator::Operation(interval_t input) {
-	return input.months / Interval::MONTHS_PER_DECADE;
-}
-
-template <>
-int64_t DatePart::DecadeOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"decade\" not recognized");
-}
-
-template <>
-int64_t DatePart::CenturyOperator::Operation(interval_t input) {
-	return input.months / Interval::MONTHS_PER_CENTURY;
-}
-
-template <>
-int64_t DatePart::CenturyOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"century\" not recognized");
-}
-
-template <>
-int64_t DatePart::MillenniumOperator::Operation(interval_t input) {
-	return input.months / Interval::MONTHS_PER_MILLENIUM;
-}
-
-template <>
-int64_t DatePart::MillenniumOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"millennium\" not recognized");
-}
-
-template <>
-int64_t DatePart::QuarterOperator::Operation(timestamp_t input) {
-	return QuarterOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::QuarterOperator::Operation(interval_t input) {
-	return MonthOperator::Operation<interval_t, int64_t>(input) / Interval::MONTHS_PER_QUARTER + 1;
-}
-
-template <>
-int64_t DatePart::QuarterOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"quarter\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOfWeekOperator::Operation(timestamp_t input) {
-	return DayOfWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::DayOfWeekOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"dow\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOfWeekOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"dow\" not recognized");
-}
-
-template <>
-int64_t DatePart::ISODayOfWeekOperator::Operation(timestamp_t input) {
-	return ISODayOfWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::ISODayOfWeekOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"isodow\" not recognized");
-}
-
-template <>
-int64_t DatePart::ISODayOfWeekOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"isodow\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOfYearOperator::Operation(timestamp_t input) {
-	return DayOfYearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::DayOfYearOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"doy\" not recognized");
-}
-
-template <>
-int64_t DatePart::DayOfYearOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"doy\" not recognized");
-}
-
-template <>
-int64_t DatePart::WeekOperator::Operation(timestamp_t input) {
-	return WeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::WeekOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"week\" not recognized");
-}
-
-template <>
-int64_t DatePart::WeekOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"week\" not recognized");
-}
-
-template <>
-int64_t DatePart::ISOYearOperator::Operation(timestamp_t input) {
-	return ISOYearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::ISOYearOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"isoyear\" not recognized");
-}
-
-template <>
-int64_t DatePart::ISOYearOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"isoyear\" not recognized");
-}
-
-template <>
-int64_t DatePart::YearWeekOperator::Operation(timestamp_t input) {
-	return YearWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::YearWeekOperator::Operation(interval_t input) {
-	const auto yyyy = YearOperator::Operation<interval_t, int64_t>(input);
-	const auto ww = WeekOperator::Operation<interval_t, int64_t>(input);
-	return YearWeekOperator::YearWeekFromParts<int64_t>(yyyy, ww);
-}
-
-template <>
-int64_t DatePart::YearWeekOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"yearweek\" not recognized");
-}
-
-template <>
-int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
-	auto time = Timestamp::GetTime(input);
-	// remove everything but the second & microsecond part
-	return time.micros % Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MicrosecondsOperator::Operation(interval_t input) {
-	// remove everything but the second & microsecond part
-	return input.micros % Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MicrosecondsOperator::Operation(dtime_t input) {
-	// remove everything but the second & microsecond part
-	return input.micros % Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MillisecondsOperator::Operation(timestamp_t input) {
-	return MicrosecondsOperator::Operation<timestamp_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DatePart::MillisecondsOperator::Operation(interval_t input) {
-	return MicrosecondsOperator::Operation<interval_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DatePart::MillisecondsOperator::Operation(dtime_t input) {
-	return MicrosecondsOperator::Operation<dtime_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DatePart::SecondsOperator::Operation(timestamp_t input) {
-	return MicrosecondsOperator::Operation<timestamp_t, int64_t>(input) / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DatePart::SecondsOperator::Operation(interval_t input) {
-	return MicrosecondsOperator::Operation<interval_t, int64_t>(input) / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DatePart::SecondsOperator::Operation(dtime_t input) {
-	return MicrosecondsOperator::Operation<dtime_t, int64_t>(input) / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DatePart::MinutesOperator::Operation(timestamp_t input) {
-	auto time = Timestamp::GetTime(input);
-	// remove the hour part, and truncate to minutes
-	return (time.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MinutesOperator::Operation(interval_t input) {
-	// remove the hour part, and truncate to minutes
-	return (input.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::MinutesOperator::Operation(dtime_t input) {
-	// remove the hour part, and truncate to minutes
-	return (input.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DatePart::HoursOperator::Operation(timestamp_t input) {
-	return Timestamp::GetTime(input).micros / Interval::MICROS_PER_HOUR;
-}
-
-template <>
-int64_t DatePart::HoursOperator::Operation(interval_t input) {
-	return input.micros / Interval::MICROS_PER_HOUR;
-}
-
-template <>
-int64_t DatePart::HoursOperator::Operation(dtime_t input) {
-	return input.micros / Interval::MICROS_PER_HOUR;
-}
-
-template <>
-int64_t DatePart::EpochOperator::Operation(timestamp_t input) {
-	return Timestamp::GetEpochSeconds(input);
-}
-
-template <>
-int64_t DatePart::EpochOperator::Operation(interval_t input) {
-	int64_t interval_years = input.months / Interval::MONTHS_PER_YEAR;
-	int64_t interval_days;
-	interval_days = Interval::DAYS_PER_YEAR * interval_years;
-	interval_days += Interval::DAYS_PER_MONTH * (input.months % Interval::MONTHS_PER_YEAR);
-	interval_days += input.days;
-	int64_t interval_epoch;
-	interval_epoch = interval_days * Interval::SECS_PER_DAY;
-	// we add 0.25 days per year to sort of account for leap days
-	interval_epoch += interval_years * (Interval::SECS_PER_DAY / 4);
-	interval_epoch += input.micros / Interval::MICROS_PER_SEC;
-	return interval_epoch;
-}
-
-template <>
-int64_t DatePart::EpochOperator::Operation(dtime_t input) {
-	return input.micros / Interval::MICROS_PER_SEC;
-}
-
-template <>
-unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<dtime_t>(ClientContext &context,
-                                                                                 FunctionStatisticsInput &input) {
-	// time seconds range over a single day
-	return PropagateSimpleDatePartStatistics<0, 86400>(input.child_stats);
-}
-
-template <>
-int64_t DatePart::EraOperator::Operation(timestamp_t input) {
-	return EraOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
-}
-
-template <>
-int64_t DatePart::EraOperator::Operation(interval_t input) {
-	throw NotImplementedException("interval units \"era\" not recognized");
-}
-
-template <>
-int64_t DatePart::EraOperator::Operation(dtime_t input) {
-	throw NotImplementedException("\"time\" units \"era\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneOperator::Operation(date_t input) {
-	throw NotImplementedException("\"date\" units \"timezone\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneOperator::Operation(interval_t input) {
-	throw NotImplementedException("\"interval\" units \"timezone\" not recognized");
-}
-
-template <>
-int64_t DatePart::TimezoneOperator::Operation(dtime_t input) {
-	return 0;
-}
-
-template <>
-void DatePart::StructOperator::Operation(int64_t **part_values, const dtime_t &input, const idx_t idx,
-                                         const part_mask_t mask) {
-	int64_t *part_data;
-	if (mask & TIME) {
-		const auto micros = MicrosecondsOperator::Operation<dtime_t, int64_t>(input);
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS))) {
-			part_data[idx] = micros;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS))) {
-			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::SECOND))) {
-			part_data[idx] = micros / Interval::MICROS_PER_SEC;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE))) {
-			part_data[idx] = MinutesOperator::Operation<dtime_t, int64_t>(input);
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::HOUR))) {
-			part_data[idx] = HoursOperator::Operation<dtime_t, int64_t>(input);
-		}
-	}
-
-	if (mask & EPOCH) {
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
-			part_data[idx] = EpochOperator::Operation<dtime_t, int64_t>(input);
-			;
-		}
-	}
-
-	if (mask & ZONE) {
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE))) {
-			part_data[idx] = 0;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_HOUR))) {
-			part_data[idx] = 0;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_MINUTE))) {
-			part_data[idx] = 0;
-		}
-	}
-}
-
-template <>
-void DatePart::StructOperator::Operation(int64_t **part_values, const timestamp_t &input, const idx_t idx,
-                                         const part_mask_t mask) {
-	date_t d;
-	dtime_t t;
-	Timestamp::Convert(input, d, t);
-
-	// Both define epoch, and the correct value is the sum.
-	// So mask it out and compute it separately.
-	Operation(part_values, d, idx, mask & ~EPOCH);
-	Operation(part_values, t, idx, mask & ~EPOCH);
-
-	if (mask & EPOCH) {
-		auto part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
-		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<timestamp_t, int64_t>(input);
-		}
-	}
-}
-
-template <>
-void DatePart::StructOperator::Operation(int64_t **part_values, const interval_t &input, const idx_t idx,
-                                         const part_mask_t mask) {
-	int64_t *part_data;
-	if (mask & YMD) {
-		const auto mm = input.months % Interval::MONTHS_PER_YEAR;
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEAR))) {
-			part_data[idx] = input.months / Interval::MONTHS_PER_YEAR;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MONTH))) {
-			part_data[idx] = mm;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::DAY))) {
-			part_data[idx] = input.days;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::DECADE))) {
-			part_data[idx] = input.months / Interval::MONTHS_PER_DECADE;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY))) {
-			part_data[idx] = input.months / Interval::MONTHS_PER_CENTURY;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM))) {
-			part_data[idx] = input.months / Interval::MONTHS_PER_MILLENIUM;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER))) {
-			part_data[idx] = mm / Interval::MONTHS_PER_QUARTER + 1;
-		}
-	}
-
-	if (mask & TIME) {
-		const auto micros = MicrosecondsOperator::Operation<interval_t, int64_t>(input);
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS))) {
-			part_data[idx] = micros;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS))) {
-			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::SECOND))) {
-			part_data[idx] = micros / Interval::MICROS_PER_SEC;
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE))) {
-			part_data[idx] = MinutesOperator::Operation<interval_t, int64_t>(input);
-		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::HOUR))) {
-			part_data[idx] = HoursOperator::Operation<interval_t, int64_t>(input);
-		}
-	}
-
-	if (mask & EPOCH) {
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
-			part_data[idx] = EpochOperator::Operation<interval_t, int64_t>(input);
-		}
-	}
-}
-
-template <typename T>
-static int64_t ExtractElement(DatePartSpecifier type, T element) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-		return DatePart::YearOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MONTH:
-		return DatePart::MonthOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::DAY:
-		return DatePart::DayOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::DECADE:
-		return DatePart::DecadeOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::CENTURY:
-		return DatePart::CenturyOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MILLENNIUM:
-		return DatePart::MillenniumOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::QUARTER:
-		return DatePart::QuarterOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::DOW:
-		return DatePart::DayOfWeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::ISODOW:
-		return DatePart::ISODayOfWeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::DOY:
-		return DatePart::DayOfYearOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::WEEK:
-		return DatePart::WeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::ISOYEAR:
-		return DatePart::ISOYearOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::YEARWEEK:
-		return DatePart::YearWeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::EPOCH:
-		return DatePart::EpochOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MICROSECONDS:
-		return DatePart::MicrosecondsOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MILLISECONDS:
-		return DatePart::MillisecondsOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::SECOND:
-		return DatePart::SecondsOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::MINUTE:
-		return DatePart::MinutesOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::HOUR:
-		return DatePart::HoursOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::ERA:
-		return DatePart::EraOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::TIMEZONE:
-	case DatePartSpecifier::TIMEZONE_HOUR:
-	case DatePartSpecifier::TIMEZONE_MINUTE:
-		return DatePart::TimezoneOperator::template Operation<T, int64_t>(element);
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATEPART");
-	}
-}
-
-template <typename T>
-static void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto &spec_arg = args.data[0];
-	auto &date_arg = args.data[1];
-
-	BinaryExecutor::ExecuteWithNulls<string_t, T, int64_t>(
-	    spec_arg, date_arg, result, args.size(), [&](string_t specifier, T date, ValidityMask &mask, idx_t idx) {
-		    if (Value::IsFinite(date)) {
-			    return ExtractElement<T>(GetDatePartSpecifier(specifier.GetString()), date);
-		    } else {
-			    mask.SetInvalid(idx);
-			    return int64_t(0);
-		    }
-	    });
-}
-
-void AddGenericDatePartOperator(BuiltinFunctions &set, const string &name, scalar_function_t date_func,
-                                scalar_function_t ts_func, scalar_function_t interval_func,
-                                function_statistics_t date_stats, function_statistics_t ts_stats) {
-	ScalarFunctionSet operator_set(name);
-	operator_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, move(date_func), false, false,
-	                                        nullptr, nullptr, date_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, move(ts_func), false, false,
-	                                        nullptr, nullptr, ts_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, move(interval_func)));
-	set.AddFunction(operator_set);
-}
-
-template <class OP>
-static void AddDatePartOperator(BuiltinFunctions &set, string name) {
-	AddGenericDatePartOperator(set, name, DatePart::UnaryFunction<date_t, int64_t, OP>,
-	                           DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
-	                           ScalarFunction::UnaryFunction<interval_t, int64_t, OP>,
-	                           OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>);
-}
-
-void AddGenericTimePartOperator(BuiltinFunctions &set, const string &name, scalar_function_t date_func,
-                                scalar_function_t ts_func, scalar_function_t interval_func, scalar_function_t time_func,
-                                function_statistics_t date_stats, function_statistics_t ts_stats,
-                                function_statistics_t time_stats) {
-	ScalarFunctionSet operator_set(name);
-	operator_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, move(date_func), false, false,
-	                                        nullptr, nullptr, date_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, move(ts_func), false, false,
-	                                        nullptr, nullptr, ts_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, move(interval_func)));
-	operator_set.AddFunction(ScalarFunction({LogicalType::TIME}, LogicalType::BIGINT, move(time_func), false, false,
-	                                        nullptr, nullptr, time_stats));
-	set.AddFunction(operator_set);
-}
-
-template <class OP>
-static void AddTimePartOperator(BuiltinFunctions &set, string name) {
-	AddGenericTimePartOperator(
-	    set, name, DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
-	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, ScalarFunction::UnaryFunction<dtime_t, int64_t, OP>,
-	    OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>,
-	    OP::template PropagateStatistics<dtime_t>);
-}
-
-struct LastDayOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		int32_t yyyy, mm, dd;
-		Date::Convert(input, yyyy, mm, dd);
-		yyyy += (mm / 12);
-		mm %= 12;
-		++mm;
-		return Date::FromDate(yyyy, mm, 1) - 1;
-	}
-};
-
-template <>
-date_t LastDayOperator::Operation(timestamp_t input) {
-	return LastDayOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-struct MonthNameOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Date::MONTH_NAMES[DatePart::MonthOperator::Operation<TA, int64_t>(input) - 1];
-	}
-};
-
-struct DayNameOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Date::DAY_NAMES[DatePart::DayOfWeekOperator::Operation<TA, int64_t>(input)];
-	}
-};
-
-struct StructDatePart {
-	using part_codes_t = vector<DatePartSpecifier>;
-
-	struct BindData : public VariableReturnBindData {
-		part_codes_t part_codes;
-
-		explicit BindData(const LogicalType &stype, const part_codes_t &part_codes_p)
-		    : VariableReturnBindData(stype), part_codes(part_codes_p) {
-		}
-
-		unique_ptr<FunctionData> Copy() const override {
-			return make_unique<BindData>(stype, part_codes);
-		}
-	};
-
-	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
-	                                     vector<unique_ptr<Expression>> &arguments) {
-		// collect names and deconflict, construct return type
-		if (!arguments[0]->IsFoldable()) {
-			throw BinderException("%s can only take constant lists of part names", bound_function.name);
-		}
-
-		case_insensitive_set_t name_collision_set;
-		child_list_t<LogicalType> struct_children;
-		part_codes_t part_codes;
-
-		Value parts_list = ExpressionExecutor::EvaluateScalar(*arguments[0]);
-		if (parts_list.type().id() == LogicalTypeId::LIST) {
-			auto &list_children = ListValue::GetChildren(parts_list);
-			if (list_children.empty()) {
-				throw BinderException("%s requires non-empty lists of part names", bound_function.name);
-			}
-			for (const auto &part_value : list_children) {
-				if (part_value.IsNull()) {
-					throw BinderException("NULL struct entry name in %s", bound_function.name);
-				}
-				const auto part_name = part_value.ToString();
-				const auto part_code = GetDateTypePartSpecifier(part_name, arguments[1]->return_type);
-				if (name_collision_set.find(part_name) != name_collision_set.end()) {
-					throw BinderException("Duplicate struct entry name \"%s\" in %s", part_name, bound_function.name);
-				}
-				name_collision_set.insert(part_name);
-				part_codes.emplace_back(part_code);
-				struct_children.emplace_back(make_pair(part_name, LogicalType::BIGINT));
-			}
-		} else {
-			throw BinderException("%s can only take constant lists of part names", bound_function.name);
-		}
-
-		arguments.erase(arguments.begin());
-		bound_function.arguments.erase(bound_function.arguments.begin());
-		bound_function.return_type = LogicalType::STRUCT(move(struct_children));
-		return make_unique<BindData>(bound_function.return_type, part_codes);
-	}
-
-	template <typename INPUT_TYPE>
-	static void Function(DataChunk &args, ExpressionState &state, Vector &result) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
-		auto &info = (BindData &)*func_expr.bind_info;
-		D_ASSERT(args.ColumnCount() == 1);
-
-		const auto count = args.size();
-		Vector &input = args.data[0];
-		vector<int64_t *> part_values(int(DatePartSpecifier::TIMEZONE_MINUTE) + 1, nullptr);
-		const auto part_mask = DatePart::StructOperator::GetMask(info.part_codes);
-
-		auto &child_entries = StructVector::GetEntries(result);
-
-		// The first computer of a part "owns" it
-		// and other requestors just reference the owner
-		vector<size_t> owners(int(DatePartSpecifier::TIMEZONE_MINUTE) + 1, child_entries.size());
-		for (size_t col = 0; col < child_entries.size(); ++col) {
-			const auto part_index = size_t(info.part_codes[col]);
-			if (owners[part_index] == child_entries.size()) {
-				owners[part_index] = col;
-			}
-		}
-
-		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-			if (ConstantVector::IsNull(input)) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				ConstantVector::SetNull(result, false);
-				for (size_t col = 0; col < child_entries.size(); ++col) {
-					auto &child_entry = child_entries[col];
-					ConstantVector::SetNull(*child_entry, false);
-					const auto part_index = size_t(info.part_codes[col]);
-					if (owners[part_index] == col) {
-						part_values[part_index] = ConstantVector::GetData<int64_t>(*child_entry);
-					}
-				}
-				auto tdata = ConstantVector::GetData<INPUT_TYPE>(input);
-				if (Value::IsFinite(tdata[0])) {
-					DatePart::StructOperator::Operation(part_values.data(), tdata[0], 0, part_mask);
-				} else {
-					for (auto &child_entry : child_entries) {
-						ConstantVector::SetNull(*child_entry, true);
-					}
-				}
-			}
-		} else {
-			VectorData rdata;
-			input.Orrify(count, rdata);
-
-			const auto &arg_valid = rdata.validity;
-			auto tdata = (const INPUT_TYPE *)rdata.data;
-
-			// Start with a valid flat vector
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto &res_valid = FlatVector::Validity(result);
-			if (res_valid.GetData()) {
-				res_valid.SetAllValid(count);
-			}
-
-			// Start with valid children
-			for (size_t col = 0; col < child_entries.size(); ++col) {
-				auto &child_entry = child_entries[col];
-				child_entry->SetVectorType(VectorType::FLAT_VECTOR);
-				auto &child_validity = FlatVector::Validity(*child_entry);
-				if (child_validity.GetData()) {
-					child_validity.SetAllValid(count);
-				}
-
-				// Pre-multiplex
-				const auto part_index = size_t(info.part_codes[col]);
-				if (owners[part_index] == col) {
-					part_values[part_index] = FlatVector::GetData<int64_t>(*child_entry);
-				}
-			}
-
-			for (idx_t i = 0; i < count; ++i) {
-				const auto idx = rdata.sel->get_index(i);
-				if (arg_valid.RowIsValid(idx)) {
-					if (Value::IsFinite(tdata[idx])) {
-						DatePart::StructOperator::Operation(part_values.data(), tdata[idx], idx, part_mask);
-					} else {
-						for (auto &child_entry : child_entries) {
-							FlatVector::Validity(*child_entry).SetInvalid(idx);
-						}
-					}
-				} else {
-					res_valid.SetInvalid(idx);
-					for (auto &child_entry : child_entries) {
-						FlatVector::Validity(*child_entry).SetInvalid(idx);
-					}
-				}
-			}
-		}
-
-		// Reference any duplicate parts
-		for (size_t col = 0; col < child_entries.size(); ++col) {
-			const auto part_index = size_t(info.part_codes[col]);
-			const auto owner = owners[part_index];
-			if (owner != col) {
-				child_entries[col]->Reference(*child_entries[owner]);
-			}
-		}
-
-		result.Verify(count);
-	}
-
-	template <typename INPUT_TYPE>
-	static ScalarFunction GetFunction(const LogicalType &temporal_type) {
-		auto part_type = LogicalType::LIST(LogicalType::VARCHAR);
-		auto result_type = LogicalType::STRUCT({});
-		return ScalarFunction({part_type, temporal_type}, result_type, Function<INPUT_TYPE>, false, false, Bind);
-	}
-};
-
-void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
-	// register the individual operators
-	AddGenericDatePartOperator(set, "year", LastYearFunction<date_t>, LastYearFunction<timestamp_t>,
-	                           ScalarFunction::UnaryFunction<interval_t, int64_t, DatePart::YearOperator>,
-	                           DatePart::YearOperator::PropagateStatistics<date_t>,
-	                           DatePart::YearOperator::PropagateStatistics<timestamp_t>);
-	AddDatePartOperator<DatePart::MonthOperator>(set, "month");
-	AddDatePartOperator<DatePart::DayOperator>(set, "day");
-	AddDatePartOperator<DatePart::DecadeOperator>(set, "decade");
-	AddDatePartOperator<DatePart::CenturyOperator>(set, "century");
-	AddDatePartOperator<DatePart::MillenniumOperator>(set, "millennium");
-	AddDatePartOperator<DatePart::QuarterOperator>(set, "quarter");
-	AddDatePartOperator<DatePart::DayOfWeekOperator>(set, "dayofweek");
-	AddDatePartOperator<DatePart::ISODayOfWeekOperator>(set, "isodow");
-	AddDatePartOperator<DatePart::DayOfYearOperator>(set, "dayofyear");
-	AddDatePartOperator<DatePart::WeekOperator>(set, "week");
-	AddDatePartOperator<DatePart::ISOYearOperator>(set, "isoyear");
-	AddDatePartOperator<DatePart::EraOperator>(set, "era");
-	AddDatePartOperator<DatePart::TimezoneOperator>(set, "timezone");
-	AddDatePartOperator<DatePart::TimezoneHourOperator>(set, "timezone_hour");
-	AddDatePartOperator<DatePart::TimezoneMinuteOperator>(set, "timezone_minute");
-	AddTimePartOperator<DatePart::EpochOperator>(set, "epoch");
-	AddTimePartOperator<DatePart::MicrosecondsOperator>(set, "microsecond");
-	AddTimePartOperator<DatePart::MillisecondsOperator>(set, "millisecond");
-	AddTimePartOperator<DatePart::SecondsOperator>(set, "second");
-	AddTimePartOperator<DatePart::MinutesOperator>(set, "minute");
-	AddTimePartOperator<DatePart::HoursOperator>(set, "hour");
-
-	//  register combinations
-	AddDatePartOperator<DatePart::YearWeekOperator>(set, "yearweek");
-
-	//  register various aliases
-	AddDatePartOperator<DatePart::DayOperator>(set, "dayofmonth");
-	AddDatePartOperator<DatePart::DayOfWeekOperator>(set, "weekday");
-	AddDatePartOperator<DatePart::WeekOperator>(set, "weekofyear"); //  Note that WeekOperator is ISO-8601, not US
-
-	//  register the last_day function
-	ScalarFunctionSet last_day("last_day");
-	last_day.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::DATE,
-	                                    DatePart::UnaryFunction<date_t, date_t, LastDayOperator>));
-	last_day.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::DATE,
-	                                    DatePart::UnaryFunction<timestamp_t, date_t, LastDayOperator>));
-	set.AddFunction(last_day);
-
-	//  register the monthname function
-	ScalarFunctionSet monthname("monthname");
-	monthname.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::VARCHAR,
-	                                     DatePart::UnaryFunction<date_t, string_t, MonthNameOperator>));
-	monthname.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                     DatePart::UnaryFunction<timestamp_t, string_t, MonthNameOperator>));
-	set.AddFunction(monthname);
-
-	//  register the dayname function
-	ScalarFunctionSet dayname("dayname");
-	dayname.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::VARCHAR,
-	                                   DatePart::UnaryFunction<date_t, string_t, DayNameOperator>));
-	dayname.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                   DatePart::UnaryFunction<timestamp_t, string_t, DayNameOperator>));
-	set.AddFunction(dayname);
-
-	// finally the actual date_part function
-	ScalarFunctionSet date_part("date_part");
-	date_part.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::BIGINT, DatePartFunction<date_t>));
-	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::BIGINT,
-	                                     DatePartFunction<timestamp_t>));
-	date_part.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME}, LogicalType::BIGINT, DatePartFunction<dtime_t>));
-	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::BIGINT,
-	                                     DatePartFunction<interval_t>));
-
-	// struct variants
-	date_part.AddFunction(StructDatePart::GetFunction<date_t>(LogicalType::DATE));
-	date_part.AddFunction(StructDatePart::GetFunction<timestamp_t>(LogicalType::TIMESTAMP));
-	date_part.AddFunction(StructDatePart::GetFunction<dtime_t>(LogicalType::TIME));
-	date_part.AddFunction(StructDatePart::GetFunction<interval_t>(LogicalType::INTERVAL));
-
-	set.AddFunction(date_part);
-	date_part.name = "datepart";
-	set.AddFunction(date_part);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DateSub {
-	template <class TA, class TB, class TR, class OP>
-	static inline void BinaryExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		BinaryExecutor::ExecuteWithNulls<TA, TB, TR>(
-		    left, right, result, count, [&](TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
-			    if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
-				    return OP::template Operation<TA, TB, TR>(startdate, enddate);
-			    } else {
-				    mask.SetInvalid(idx);
-				    return TR();
-			    }
-		    });
-	}
-
-	struct MonthOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-
-			if (start_ts > end_ts) {
-				return -MonthOperator::Operation<TA, TB, TR>(end_ts, start_ts);
-			}
-			// The number of complete months depends on whether end_ts is on the last day of the month.
-			date_t end_date;
-			dtime_t end_time;
-			Timestamp::Convert(end_ts, end_date, end_time);
-
-			int32_t yyyy, mm, dd;
-			Date::Convert(end_date, yyyy, mm, dd);
-			const auto end_days = Date::MonthDays(yyyy, mm);
-			if (end_days == dd) {
-				// Now check whether the start day is after the end day
-				date_t start_date;
-				dtime_t start_time;
-				Timestamp::Convert(start_ts, start_date, start_time);
-				Date::Convert(start_date, yyyy, mm, dd);
-				if (dd > end_days || (dd == end_days && start_time < end_time)) {
-					// Move back to the same time on the last day of the (shorter) end month
-					start_date = Date::FromDate(yyyy, mm, end_days);
-					start_ts = Timestamp::FromDatetime(start_date, start_time);
-				}
-			}
-
-			// Our interval difference will now give the correct result.
-			// Note that PG gives different interval subtraction results,
-			// so if we change this we will have to reimplement.
-			return Interval::GetAge(end_ts, start_ts).months;
-		}
-	};
-
-	struct QuarterOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_QUARTER;
-		}
-	};
-
-	struct YearOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_YEAR;
-		}
-	};
-
-	struct DecadeOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_DECADE;
-		}
-	};
-
-	struct CenturyOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_CENTURY;
-		}
-	};
-
-	struct MilleniumOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA start_ts, TB end_ts) {
-			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_MILLENIUM;
-		}
-	};
-
-	struct DayOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return (Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate)) /
-			       Interval::MICROS_PER_DAY;
-		}
-	};
-
-	struct WeekOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return (Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate)) /
-			       Interval::MICROS_PER_WEEK;
-		}
-	};
-
-	struct MicrosecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return (Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate));
-		}
-	};
-
-	struct MillisecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return (Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate)) /
-			       Interval::MICROS_PER_MSEC;
-		}
-	};
-
-	struct SecondsOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return (Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate)) /
-			       Interval::MICROS_PER_SEC;
-		}
-	};
-
-	struct MinutesOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return (Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate)) /
-			       Interval::MICROS_PER_MINUTE;
-		}
-	};
-
-	struct HoursOperator {
-		template <class TA, class TB, class TR>
-		static inline TR Operation(TA startdate, TB enddate) {
-			return (Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate)) /
-			       Interval::MICROS_PER_HOUR;
-		}
-	};
-};
-
-// DATE specialisations
-template <>
-int64_t DateSub::YearOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return YearOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                  Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MonthOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MonthOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                   Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::DayOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return DayOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                 Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::DecadeOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return DecadeOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                    Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::CenturyOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return CenturyOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                     Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MilleniumOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MilleniumOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                       Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::QuarterOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return QuarterOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                     Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::WeekOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return WeekOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                  Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MicrosecondsOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MicrosecondsOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                          Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MillisecondsOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MillisecondsOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                          Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::SecondsOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return SecondsOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                     Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::MinutesOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return MinutesOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                     Timestamp::FromDatetime(enddate, t0));
-}
-
-template <>
-int64_t DateSub::HoursOperator::Operation(date_t startdate, date_t enddate) {
-	dtime_t t0(0);
-	return HoursOperator::Operation<timestamp_t, timestamp_t, int64_t>(Timestamp::FromDatetime(startdate, t0),
-	                                                                   Timestamp::FromDatetime(enddate, t0));
-}
-
-// TIME specialisations
-template <>
-int64_t DateSub::YearOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"year\" not recognized");
-}
-
-template <>
-int64_t DateSub::MonthOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"month\" not recognized");
-}
-
-template <>
-int64_t DateSub::DayOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"day\" not recognized");
-}
-
-template <>
-int64_t DateSub::DecadeOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"decade\" not recognized");
-}
-
-template <>
-int64_t DateSub::CenturyOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"century\" not recognized");
-}
-
-template <>
-int64_t DateSub::MilleniumOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"millennium\" not recognized");
-}
-
-template <>
-int64_t DateSub::QuarterOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"quarter\" not recognized");
-}
-
-template <>
-int64_t DateSub::WeekOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	throw NotImplementedException("\"time\" units \"week\" not recognized");
-}
-
-template <>
-int64_t DateSub::MicrosecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return enddate.micros - startdate.micros;
-}
-
-template <>
-int64_t DateSub::MillisecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return (enddate.micros - startdate.micros) / Interval::MICROS_PER_MSEC;
-}
-
-template <>
-int64_t DateSub::SecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return (enddate.micros - startdate.micros) / Interval::MICROS_PER_SEC;
-}
-
-template <>
-int64_t DateSub::MinutesOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return (enddate.micros - startdate.micros) / Interval::MICROS_PER_MINUTE;
-}
-
-template <>
-int64_t DateSub::HoursOperator::Operation(dtime_t startdate, dtime_t enddate) {
-	return (enddate.micros - startdate.micros) / Interval::MICROS_PER_HOUR;
-}
-
-template <typename TA, typename TB, typename TR>
-static int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddate) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-	case DatePartSpecifier::ISOYEAR:
-		return DateSub::YearOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MONTH:
-		return DateSub::MonthOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-		return DateSub::DayOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::DECADE:
-		return DateSub::DecadeOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::CENTURY:
-		return DateSub::CenturyOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MILLENNIUM:
-		return DateSub::MilleniumOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::QUARTER:
-		return DateSub::QuarterOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		return DateSub::WeekOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MICROSECONDS:
-		return DateSub::MicrosecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MILLISECONDS:
-		return DateSub::MillisecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		return DateSub::SecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::MINUTE:
-		return DateSub::MinutesOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	case DatePartSpecifier::HOUR:
-		return DateSub::HoursOperator::template Operation<TA, TB, TR>(startdate, enddate);
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATESUB");
-	}
-}
-
-struct DateSubTernaryOperator {
-	template <typename TS, typename TA, typename TB, typename TR>
-	static inline TR Operation(TS part, TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
-		if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
-			return SubtractDateParts<TA, TB, TR>(GetDatePartSpecifier(part.GetString()), startdate, enddate);
-		} else {
-			mask.SetInvalid(idx);
-			return TR();
-		}
-	}
-};
-
-template <typename TA, typename TB, typename TR>
-static void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
-	switch (type) {
-	case DatePartSpecifier::YEAR:
-	case DatePartSpecifier::ISOYEAR:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::YearOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MONTH:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MonthOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::DayOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::DECADE:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::DecadeOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::CENTURY:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::CenturyOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MILLENNIUM:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MilleniumOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::QUARTER:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::QuarterOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::WeekOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MicrosecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MillisecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::SecondsOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::MINUTE:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::MinutesOperator>(left, right, result, count);
-		break;
-	case DatePartSpecifier::HOUR:
-		DateSub::BinaryExecute<TA, TB, TR, DateSub::HoursOperator>(left, right, result, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATESUB");
-	}
-}
-
-template <typename T>
-static void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-	auto &part_arg = args.data[0];
-	auto &start_arg = args.data[1];
-	auto &end_arg = args.data[2];
-
-	if (part_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// Common case of constant part.
-		if (ConstantVector::IsNull(part_arg)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateSubBinaryExecutor<T, T, int64_t>(type, start_arg, end_arg, result, args.size());
-		}
-	} else {
-		TernaryExecutor::ExecuteWithNulls<string_t, T, T, int64_t>(
-		    part_arg, start_arg, end_arg, result, args.size(),
-		    DateSubTernaryOperator::Operation<string_t, T, T, int64_t>);
-	}
-}
-
-void DateSubFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet date_sub("date_sub");
-	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE, LogicalType::DATE},
-	                                    LogicalType::BIGINT, DateSubFunction<date_t>));
-	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
-	                                    LogicalType::BIGINT, DateSubFunction<timestamp_t>));
-	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME, LogicalType::TIME},
-	                                    LogicalType::BIGINT, DateSubFunction<dtime_t>));
-	set.AddFunction(date_sub);
-
-	date_sub.name = "datesub";
-	set.AddFunction(date_sub);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DateTrunc {
-	template <class TA, class TR, class OP>
-	static inline TR UnaryFunction(TA input) {
-		if (Value::IsFinite(input)) {
-			return OP::template Operation<TA, TR>(input);
-		} else {
-			return Cast::template Operation<TA, TR>(input);
-		}
-	}
-
-	template <class TA, class TR, class OP>
-	static inline void UnaryExecute(Vector &left, Vector &result, idx_t count) {
-		UnaryExecutor::Execute<TA, TR>(left, result, count, UnaryFunction<TA, TR, OP>);
-	}
-
-	struct MillenniumOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate((Date::ExtractYear(input) / 1000) * 1000, 1, 1);
-		}
-	};
-
-	struct CenturyOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate((Date::ExtractYear(input) / 100) * 100, 1, 1);
-		}
-	};
-
-	struct DecadeOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate((Date::ExtractYear(input) / 10) * 10, 1, 1);
-		}
-	};
-
-	struct YearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate(Date::ExtractYear(input), 1, 1);
-		}
-	};
-
-	struct QuarterOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t yyyy, mm, dd;
-			Date::Convert(input, yyyy, mm, dd);
-			mm = 1 + (((mm - 1) / 3) * 3);
-			return Date::FromDate(yyyy, mm, 1);
-		}
-	};
-
-	struct MonthOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::FromDate(Date::ExtractYear(input), Date::ExtractMonth(input), 1);
-		}
-	};
-
-	struct WeekOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return Date::GetMondayOfCurrentWeek(input);
-		}
-	};
-
-	struct ISOYearOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			date_t date = Date::GetMondayOfCurrentWeek(input);
-			date.days -= (Date::ExtractISOWeekNumber(date) - 1) * Interval::DAYS_PER_WEEK;
-
-			return date;
-		}
-	};
-
-	struct DayOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return input;
-		}
-	};
-
-	struct HourOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t hour, min, sec, micros;
-			date_t date;
-			dtime_t time;
-			Timestamp::Convert(input, date, time);
-			Time::Convert(time, hour, min, sec, micros);
-			return Timestamp::FromDatetime(date, Time::FromTime(hour, 0, 0, 0));
-		}
-	};
-
-	struct MinuteOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t hour, min, sec, micros;
-			date_t date;
-			dtime_t time;
-			Timestamp::Convert(input, date, time);
-			Time::Convert(time, hour, min, sec, micros);
-			return Timestamp::FromDatetime(date, Time::FromTime(hour, min, 0, 0));
-		}
-	};
-
-	struct SecondOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t hour, min, sec, micros;
-			date_t date;
-			dtime_t time;
-			Timestamp::Convert(input, date, time);
-			Time::Convert(time, hour, min, sec, micros);
-			return Timestamp::FromDatetime(date, Time::FromTime(hour, min, sec, 0));
-		}
-	};
-
-	struct MillisecondOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			int32_t hour, min, sec, micros;
-			date_t date;
-			dtime_t time;
-			Timestamp::Convert(input, date, time);
-			Time::Convert(time, hour, min, sec, micros);
-			micros -= micros % Interval::MICROS_PER_MSEC;
-			return Timestamp::FromDatetime(date, Time::FromTime(hour, min, sec, micros));
-		}
-	};
-
-	struct MicrosecondOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
-			return input;
-		}
-	};
-};
-
-// DATE specialisations
-template <>
-date_t DateTrunc::MillenniumOperator::Operation(timestamp_t input) {
-	return MillenniumOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::MillenniumOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(MillenniumOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::MillenniumOperator::Operation(timestamp_t input) {
-	return MillenniumOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::CenturyOperator::Operation(timestamp_t input) {
-	return CenturyOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::CenturyOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(CenturyOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::CenturyOperator::Operation(timestamp_t input) {
-	return CenturyOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::DecadeOperator::Operation(timestamp_t input) {
-	return DecadeOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::DecadeOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(DecadeOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::DecadeOperator::Operation(timestamp_t input) {
-	return DecadeOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::YearOperator::Operation(timestamp_t input) {
-	return YearOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::YearOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(YearOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::YearOperator::Operation(timestamp_t input) {
-	return YearOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::QuarterOperator::Operation(timestamp_t input) {
-	return QuarterOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::QuarterOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(QuarterOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::QuarterOperator::Operation(timestamp_t input) {
-	return QuarterOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::MonthOperator::Operation(timestamp_t input) {
-	return MonthOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::MonthOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(MonthOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::MonthOperator::Operation(timestamp_t input) {
-	return MonthOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::WeekOperator::Operation(timestamp_t input) {
-	return WeekOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::WeekOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(WeekOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::WeekOperator::Operation(timestamp_t input) {
-	return WeekOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::ISOYearOperator::Operation(timestamp_t input) {
-	return ISOYearOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::ISOYearOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(ISOYearOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::ISOYearOperator::Operation(timestamp_t input) {
-	return ISOYearOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::DayOperator::Operation(timestamp_t input) {
-	return DayOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
-}
-
-template <>
-timestamp_t DateTrunc::DayOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(DayOperator::Operation<date_t, date_t>(input), dtime_t(0));
-}
-
-template <>
-timestamp_t DateTrunc::DayOperator::Operation(timestamp_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
-}
-
-template <>
-date_t DateTrunc::HourOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::HourOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::HourOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(HourOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-template <>
-date_t DateTrunc::MinuteOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::MinuteOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::MinuteOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(HourOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-template <>
-date_t DateTrunc::SecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::SecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::SecondOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(DayOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-template <>
-date_t DateTrunc::MillisecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::MillisecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::MillisecondOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(MillisecondOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-template <>
-date_t DateTrunc::MicrosecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, date_t>(input);
-}
-
-template <>
-timestamp_t DateTrunc::MicrosecondOperator::Operation(date_t input) {
-	return DayOperator::Operation<date_t, timestamp_t>(input);
-}
-
-template <>
-date_t DateTrunc::MicrosecondOperator::Operation(timestamp_t input) {
-	return Timestamp::GetDate(MicrosecondOperator::Operation<timestamp_t, timestamp_t>(input));
-}
-
-// INTERVAL specialisations
-template <>
-interval_t DateTrunc::MillenniumOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_MILLENIUM) * Interval::MONTHS_PER_MILLENIUM;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::CenturyOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_CENTURY) * Interval::MONTHS_PER_CENTURY;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::DecadeOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_DECADE) * Interval::MONTHS_PER_DECADE;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::YearOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_YEAR) * Interval::MONTHS_PER_YEAR;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::QuarterOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	input.months = (input.months / Interval::MONTHS_PER_QUARTER) * Interval::MONTHS_PER_QUARTER;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::MonthOperator::Operation(interval_t input) {
-	input.days = 0;
-	input.micros = 0;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::WeekOperator::Operation(interval_t input) {
-	input.micros = 0;
-	input.days = (input.days / Interval::DAYS_PER_WEEK) * Interval::DAYS_PER_WEEK;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::ISOYearOperator::Operation(interval_t input) {
-	return YearOperator::Operation<interval_t, interval_t>(input);
-}
-
-template <>
-interval_t DateTrunc::DayOperator::Operation(interval_t input) {
-	input.micros = 0;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::HourOperator::Operation(interval_t input) {
-	input.micros = (input.micros / Interval::MICROS_PER_HOUR) * Interval::MICROS_PER_HOUR;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::MinuteOperator::Operation(interval_t input) {
-	input.micros = (input.micros / Interval::MICROS_PER_MINUTE) * Interval::MICROS_PER_MINUTE;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::SecondOperator::Operation(interval_t input) {
-	input.micros = (input.micros / Interval::MICROS_PER_SEC) * Interval::MICROS_PER_SEC;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::MillisecondOperator::Operation(interval_t input) {
-	input.micros = (input.micros / Interval::MICROS_PER_MSEC) * Interval::MICROS_PER_MSEC;
-	return input;
-}
-
-template <>
-interval_t DateTrunc::MicrosecondOperator::Operation(interval_t input) {
-	return input;
-}
-
-template <class TA, class TR>
-static TR TruncateElement(DatePartSpecifier type, TA element) {
-	if (!Value::IsFinite(element)) {
-		return Cast::template Operation<TA, TR>(element);
-	}
-
-	switch (type) {
-	case DatePartSpecifier::MILLENNIUM:
-		return DateTrunc::MillenniumOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::CENTURY:
-		return DateTrunc::CenturyOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::DECADE:
-		return DateTrunc::DecadeOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::YEAR:
-		return DateTrunc::YearOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::QUARTER:
-		return DateTrunc::QuarterOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::MONTH:
-		return DateTrunc::MonthOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		return DateTrunc::WeekOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::ISOYEAR:
-		return DateTrunc::ISOYearOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-		return DateTrunc::DayOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::HOUR:
-		return DateTrunc::HourOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::MINUTE:
-		return DateTrunc::MinuteOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		return DateTrunc::SecondOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::MILLISECONDS:
-		return DateTrunc::MillisecondOperator::Operation<TA, TR>(element);
-	case DatePartSpecifier::MICROSECONDS:
-		return DateTrunc::MicrosecondOperator::Operation<TA, TR>(element);
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATETRUNC");
-	}
-}
-
-struct DateTruncBinaryOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA specifier, TB date) {
-		return TruncateElement<TB, TR>(GetDatePartSpecifier(specifier.GetString()), date);
-	}
-};
-
-template <typename TA, typename TR>
-static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector &result, idx_t count) {
-	switch (type) {
-	case DatePartSpecifier::MILLENNIUM:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MillenniumOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::CENTURY:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::CenturyOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::DECADE:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::DecadeOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::YEAR:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::YearOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::QUARTER:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::QuarterOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::MONTH:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MonthOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::WeekOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::ISOYEAR:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::ISOYearOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::DayOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::HOUR:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::HourOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::MINUTE:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MinuteOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::SecondOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MillisecondOperator>(left, result, count);
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MicrosecondOperator>(left, result, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATETRUNC");
-	}
-}
-
-template <typename TA, typename TR>
-static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto &part_arg = args.data[0];
-	auto &date_arg = args.data[1];
-
-	if (part_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		// Common case of constant part.
-		if (ConstantVector::IsNull(part_arg)) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-		} else {
-			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateTruncUnaryExecutor<TA, TR>(type, date_arg, result, args.size());
-		}
-	} else {
-		BinaryExecutor::ExecuteStandard<string_t, TA, TR, DateTruncBinaryOperator>(part_arg, date_arg, result,
-		                                                                           args.size());
-	}
-}
-
-template <class TA, class TR, class OP>
-static unique_ptr<BaseStatistics> DateTruncStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
-	// we can only propagate date stats if the child has stats
-	if (!child_stats[1]) {
-		return nullptr;
-	}
-	auto &nstats = (NumericStatistics &)*child_stats[1];
-	if (nstats.min.IsNull() || nstats.max.IsNull()) {
-		return nullptr;
-	}
-	// run the operator on both the min and the max, this gives us the [min, max] bound
-	auto min = nstats.min.GetValueUnsafe<TA>();
-	auto max = nstats.max.GetValueUnsafe<TA>();
-	if (min > max) {
-		throw InternalException("Invalid DATETRUNC child statistics");
-	}
-
-	// Infinite values are unmodified
-	auto min_part = DateTrunc::UnaryFunction<TA, TR, OP>(min);
-	auto max_part = DateTrunc::UnaryFunction<TA, TR, OP>(max);
-
-	auto min_value = Value::CreateValue(min_part);
-	auto max_value = Value::CreateValue(max_part);
-	auto result = make_unique<NumericStatistics>(min_value.type(), min_value, max_value, StatisticsType::LOCAL_STATS);
-	if (child_stats[0]->validity_stats) {
-		result->validity_stats = child_stats[1]->validity_stats->Copy();
-	}
-	return move(result);
-}
-
-template <class TA, class TR, class OP>
-static unique_ptr<BaseStatistics> PropagateDateTruncStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-	return DateTruncStatistics<TA, TR, OP>(input.child_stats);
-}
-
-template <typename TA, typename TR>
-static function_statistics_t DateTruncStats(DatePartSpecifier type) {
-	switch (type) {
-	case DatePartSpecifier::MILLENNIUM:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MillenniumOperator>;
-	case DatePartSpecifier::CENTURY:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::CenturyOperator>;
-	case DatePartSpecifier::DECADE:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::DecadeOperator>;
-	case DatePartSpecifier::YEAR:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::YearOperator>;
-	case DatePartSpecifier::QUARTER:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::QuarterOperator>;
-	case DatePartSpecifier::MONTH:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MonthOperator>;
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::WeekOperator>;
-	case DatePartSpecifier::ISOYEAR:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::ISOYearOperator>;
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::DayOperator>;
-	case DatePartSpecifier::HOUR:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::HourOperator>;
-	case DatePartSpecifier::MINUTE:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MinuteOperator>;
-	case DatePartSpecifier::SECOND:
-	case DatePartSpecifier::EPOCH:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::SecondOperator>;
-	case DatePartSpecifier::MILLISECONDS:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MillisecondOperator>;
-	case DatePartSpecifier::MICROSECONDS:
-		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MicrosecondOperator>;
-	default:
-		throw NotImplementedException("Specifier type not implemented for DATETRUNC statistics");
-	}
-}
-
-static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[0]->IsFoldable()) {
-		return nullptr;
-	}
-
-	// Rebind to return a date if we are truncating that far
-	Value part_value = ExpressionExecutor::EvaluateScalar(*arguments[0]);
-	if (part_value.IsNull()) {
-		return nullptr;
-	}
-	const auto part_name = part_value.ToString();
-	const auto part_code = GetDatePartSpecifier(part_name);
-	switch (part_code) {
-	case DatePartSpecifier::MILLENNIUM:
-	case DatePartSpecifier::CENTURY:
-	case DatePartSpecifier::DECADE:
-	case DatePartSpecifier::YEAR:
-	case DatePartSpecifier::QUARTER:
-	case DatePartSpecifier::MONTH:
-	case DatePartSpecifier::WEEK:
-	case DatePartSpecifier::YEARWEEK:
-	case DatePartSpecifier::ISOYEAR:
-	case DatePartSpecifier::DAY:
-	case DatePartSpecifier::DOW:
-	case DatePartSpecifier::ISODOW:
-	case DatePartSpecifier::DOY:
-		switch (arguments[1]->return_type.id()) {
-		case LogicalType::TIMESTAMP:
-			bound_function.function = DateTruncFunction<timestamp_t, date_t>;
-			bound_function.statistics = DateTruncStats<timestamp_t, date_t>(part_code);
-			break;
-		case LogicalType::DATE:
-			bound_function.function = DateTruncFunction<date_t, date_t>;
-			bound_function.statistics = DateTruncStats<date_t, date_t>(part_code);
-			break;
-		default:
-			break;
-		}
-		bound_function.return_type = LogicalType::DATE;
-		break;
-	default:
-		switch (arguments[1]->return_type.id()) {
-		case LogicalType::TIMESTAMP:
-			bound_function.statistics = DateTruncStats<timestamp_t, timestamp_t>(part_code);
-			break;
-		case LogicalType::DATE:
-			bound_function.statistics = DateTruncStats<timestamp_t, date_t>(part_code);
-			break;
-		default:
-			break;
-		}
-		break;
-	}
-
-	return nullptr;
-}
-
-void DateTruncFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet date_trunc("date_trunc");
-	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
-	                                      DateTruncFunction<timestamp_t, timestamp_t>, false, false, DateTruncBind));
-	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::TIMESTAMP,
-	                                      DateTruncFunction<date_t, timestamp_t>, false, false, DateTruncBind));
-	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
-	                                      DateTruncFunction<interval_t, interval_t>));
-	set.AddFunction(date_trunc);
-	date_trunc.name = "datetrunc";
-	set.AddFunction(date_trunc);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct EpochSecOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		return Timestamp::FromEpochSeconds(input);
-	}
-};
-
-static void EpochSecFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-
-	UnaryExecutor::Execute<int64_t, timestamp_t, EpochSecOperator>(input.data[0], result, input.size());
-}
-
-struct EpochMillisOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		return Timestamp::FromEpochMs(input);
-	}
-};
-
-static void EpochMillisFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-
-	UnaryExecutor::Execute<int64_t, timestamp_t, EpochMillisOperator>(input.data[0], result, input.size());
-}
-
-void EpochFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet epoch("epoch_ms");
-	epoch.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochMillisFunction));
-	set.AddFunction(epoch);
-	// to_timestamp is an alias from Postgres that converts the time in seconds to a timestamp
-	ScalarFunctionSet to_timestamp("to_timestamp");
-	to_timestamp.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochSecFunction));
-	set.AddFunction(to_timestamp);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <cmath>
-
-namespace duckdb {
-
-struct MakeDateOperator {
-	template <typename YYYY, typename MM, typename DD, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd) {
-		return Date::FromDate(yyyy, mm, dd);
-	}
-};
-
-template <typename T>
-static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 3);
-	auto &yyyy = input.data[0];
-	auto &mm = input.data[1];
-	auto &dd = input.data[2];
-
-	TernaryExecutor::Execute<T, T, T, date_t>(yyyy, mm, dd, result, input.size(),
-	                                          MakeDateOperator::Operation<T, T, T, date_t>);
-}
-
-template <typename T>
-static void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
-	// this should be guaranteed by the binder
-	D_ASSERT(input.ColumnCount() == 1);
-	auto &vec = input.data[0];
-
-	auto &children = StructVector::GetEntries(vec);
-	D_ASSERT(children.size() == 3);
-	auto &yyyy = *children[0];
-	auto &mm = *children[1];
-	auto &dd = *children[2];
-
-	TernaryExecutor::Execute<T, T, T, date_t>(yyyy, mm, dd, result, input.size(), Date::FromDate);
-}
-
-struct MakeTimeOperator {
-	template <typename HH, typename MM, typename SS, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(HH hh, MM mm, SS ss) {
-		int64_t secs = ss;
-		int64_t micros = std::round((ss - secs) * Interval::MICROS_PER_SEC);
-		return Time::FromTime(hh, mm, secs, micros);
-	}
-};
-
-template <typename T>
-static void ExecuteMakeTime(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 3);
-	auto &yyyy = input.data[0];
-	auto &mm = input.data[1];
-	auto &dd = input.data[2];
-
-	TernaryExecutor::Execute<T, T, double, dtime_t>(yyyy, mm, dd, result, input.size(),
-	                                                MakeTimeOperator::Operation<T, T, double, dtime_t>);
-}
-
-struct MakeTimestampOperator {
-	template <typename YYYY, typename MM, typename DD, typename HR, typename MN, typename SS, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd, HR hr, MN mn, SS ss) {
-		const auto d = MakeDateOperator::Operation<YYYY, MM, DD, date_t>(yyyy, mm, dd);
-		const auto t = MakeTimeOperator::Operation<HR, MN, SS, dtime_t>(hr, mn, ss);
-		return Timestamp::FromDatetime(d, t);
-	}
-};
-
-template <typename T>
-static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 6);
-
-	auto func = MakeTimestampOperator::Operation<T, T, T, T, T, double, timestamp_t>;
-	SenaryExecutor::Execute<T, T, T, T, T, double, timestamp_t>(input, result, func);
-}
-
-void MakeDateFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet make_date("make_date");
-	make_date.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                     LogicalType::DATE, ExecuteMakeDate<int64_t>));
-
-	child_list_t<LogicalType> make_date_children {
-	    {"year", LogicalType::BIGINT}, {"month", LogicalType::BIGINT}, {"day", LogicalType::BIGINT}};
-	make_date.AddFunction(
-	    ScalarFunction({LogicalType::STRUCT(make_date_children)}, LogicalType::DATE, ExecuteStructMakeDate<int64_t>));
-	set.AddFunction(make_date);
-
-	ScalarFunctionSet make_time("make_time");
-	make_time.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
-	                                     LogicalType::TIME, ExecuteMakeTime<int64_t>));
-	set.AddFunction(make_time);
-
-	ScalarFunctionSet make_timestamp("make_timestamp");
-	make_timestamp.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT,
-	                                           LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
-	                                          LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
-	set.AddFunction(make_timestamp);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cctype>
-
-namespace duckdb {
-
-idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
-	switch (specifier) {
-	case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME:
-	case StrTimeSpecifier::ABBREVIATED_MONTH_NAME:
-		return 3;
-	case StrTimeSpecifier::WEEKDAY_DECIMAL:
-		return 1;
-	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-	case StrTimeSpecifier::HOUR_24_PADDED:
-	case StrTimeSpecifier::HOUR_12_PADDED:
-	case StrTimeSpecifier::MINUTE_PADDED:
-	case StrTimeSpecifier::SECOND_PADDED:
-	case StrTimeSpecifier::AM_PM:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-		return 2;
-	case StrTimeSpecifier::MICROSECOND_PADDED:
-		return 6;
-	case StrTimeSpecifier::MILLISECOND_PADDED:
-		return 3;
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-		return 3;
-	default:
-		return 0;
-	}
-}
-
-void StrTimeFormat::AddLiteral(string literal) {
-	constant_size += literal.size();
-	literals.push_back(move(literal));
-}
-
-void StrTimeFormat::AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) {
-	AddLiteral(move(preceding_literal));
-	specifiers.push_back(specifier);
-}
-
-void StrfTimeFormat::AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) {
-	is_date_specifier.push_back(IsDateSpecifier(specifier));
-	idx_t specifier_size = StrfTimepecifierSize(specifier);
-	if (specifier_size == 0) {
-		// variable length specifier
-		var_length_specifiers.push_back(specifier);
-	} else {
-		// constant size specifier
-		constant_size += specifier_size;
-	}
-	StrTimeFormat::AddFormatSpecifier(move(preceding_literal), specifier);
-}
-
-idx_t StrfTimeFormat::GetSpecifierLength(StrTimeSpecifier specifier, date_t date, dtime_t time, int32_t utc_offset,
-                                         const char *tz_name) {
-	switch (specifier) {
-	case StrTimeSpecifier::FULL_WEEKDAY_NAME:
-		return Date::DAY_NAMES[Date::ExtractISODayOfTheWeek(date) % 7].GetSize();
-	case StrTimeSpecifier::FULL_MONTH_NAME:
-		return Date::MONTH_NAMES[Date::ExtractMonth(date) - 1].GetSize();
-	case StrTimeSpecifier::YEAR_DECIMAL: {
-		auto year = Date::ExtractYear(date);
-		return NumericHelper::SignedLength<int32_t, uint32_t>(year);
-	}
-	case StrTimeSpecifier::MONTH_DECIMAL: {
-		idx_t len = 1;
-		auto month = Date::ExtractMonth(date);
-		len += month >= 10;
-		return len;
-	}
-	case StrTimeSpecifier::UTC_OFFSET:
-		// ±HH or ±HH:MM
-		return (utc_offset % 60) ? 6 : 3;
-	case StrTimeSpecifier::TZ_NAME:
-		if (tz_name) {
-			return strlen(tz_name);
-		}
-		// empty for now
-		return 0;
-	case StrTimeSpecifier::HOUR_24_DECIMAL:
-	case StrTimeSpecifier::HOUR_12_DECIMAL:
-	case StrTimeSpecifier::MINUTE_DECIMAL:
-	case StrTimeSpecifier::SECOND_DECIMAL: {
-		// time specifiers
-		idx_t len = 1;
-		int32_t hour, min, sec, msec;
-		Time::Convert(time, hour, min, sec, msec);
-		switch (specifier) {
-		case StrTimeSpecifier::HOUR_24_DECIMAL:
-			len += hour >= 10;
-			break;
-		case StrTimeSpecifier::HOUR_12_DECIMAL:
-			hour = hour % 12;
-			if (hour == 0) {
-				hour = 12;
-			}
-			len += hour >= 10;
-			break;
-		case StrTimeSpecifier::MINUTE_DECIMAL:
-			len += min >= 10;
-			break;
-		case StrTimeSpecifier::SECOND_DECIMAL:
-			len += sec >= 10;
-			break;
-		default:
-			throw InternalException("Time specifier mismatch");
-		}
-		return len;
-	}
-	case StrTimeSpecifier::DAY_OF_MONTH:
-		return NumericHelper::UnsignedLength<uint32_t>(Date::ExtractDay(date));
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-		return NumericHelper::UnsignedLength<uint32_t>(Date::ExtractDayOfTheYear(date));
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-		return NumericHelper::UnsignedLength<uint32_t>(Date::ExtractYear(date) % 100);
-	default:
-		throw InternalException("Unimplemented specifier for GetSpecifierLength");
-	}
-}
-
-//! Returns the total length of the date formatted by this format specifier
-idx_t StrfTimeFormat::GetLength(date_t date, dtime_t time, int32_t utc_offset, const char *tz_name) {
-	idx_t size = constant_size;
-	if (!var_length_specifiers.empty()) {
-		for (auto &specifier : var_length_specifiers) {
-			size += GetSpecifierLength(specifier, date, time, utc_offset, tz_name);
-		}
-	}
-	return size;
-}
-
-char *StrfTimeFormat::WriteString(char *target, const string_t &str) {
-	idx_t size = str.GetSize();
-	memcpy(target, str.GetDataUnsafe(), size);
-	return target + size;
-}
-
-// write a value in the range of 0..99 unpadded (e.g. "1", "2", ... "98", "99")
-char *StrfTimeFormat::Write2(char *target, uint8_t value) {
-	D_ASSERT(value < 100);
-	if (value >= 10) {
-		return WritePadded2(target, value);
-	} else {
-		*target = char(uint8_t('0') + value);
-		return target + 1;
-	}
-}
-
-// write a value in the range of 0..99 padded to 2 digits
-char *StrfTimeFormat::WritePadded2(char *target, uint32_t value) {
-	D_ASSERT(value < 100);
-	auto index = static_cast<unsigned>(value * 2);
-	*target++ = duckdb_fmt::internal::data::digits[index];
-	*target++ = duckdb_fmt::internal::data::digits[index + 1];
-	return target;
-}
-
-// write a value in the range of 0..999 padded
-char *StrfTimeFormat::WritePadded3(char *target, uint32_t value) {
-	D_ASSERT(value < 1000);
-	if (value >= 100) {
-		WritePadded2(target + 1, value % 100);
-		*target = char(uint8_t('0') + value / 100);
-		return target + 3;
-	} else {
-		*target = '0';
-		target++;
-		return WritePadded2(target, value);
-	}
-}
-
-// write a value in the range of 0..999999 padded to 6 digits
-char *StrfTimeFormat::WritePadded(char *target, uint32_t value, size_t padding) {
-	D_ASSERT(padding % 2 == 0);
-	for (size_t i = 0; i < padding / 2; i++) {
-		int decimals = value % 100;
-		WritePadded2(target + padding - 2 * (i + 1), decimals);
-		value /= 100;
-	}
-	return target + padding;
-}
-
-bool StrfTimeFormat::IsDateSpecifier(StrTimeSpecifier specifier) {
-	switch (specifier) {
-	case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME:
-	case StrTimeSpecifier::FULL_WEEKDAY_NAME:
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-	case StrTimeSpecifier::WEEKDAY_DECIMAL:
-		return true;
-	default:
-		return false;
-	}
-}
-
-char *StrfTimeFormat::WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target) {
-	switch (specifier) {
-	case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME: {
-		auto dow = Date::ExtractISODayOfTheWeek(date);
-		target = WriteString(target, Date::DAY_NAMES_ABBREVIATED[dow % 7]);
-		break;
-	}
-	case StrTimeSpecifier::FULL_WEEKDAY_NAME: {
-		auto dow = Date::ExtractISODayOfTheWeek(date);
-		target = WriteString(target, Date::DAY_NAMES[dow % 7]);
-		break;
-	}
-	case StrTimeSpecifier::WEEKDAY_DECIMAL: {
-		auto dow = Date::ExtractISODayOfTheWeek(date);
-		*target = char('0' + uint8_t(dow % 7));
-		target++;
-		break;
-	}
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED: {
-		int32_t doy = Date::ExtractDayOfTheYear(date);
-		target = WritePadded3(target, doy);
-		break;
-	}
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-		target = WritePadded2(target, Date::ExtractWeekNumberRegular(date, true));
-		break;
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-		target = WritePadded2(target, Date::ExtractWeekNumberRegular(date, false));
-		break;
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL: {
-		uint32_t doy = Date::ExtractDayOfTheYear(date);
-		target += NumericHelper::UnsignedLength<uint32_t>(doy);
-		NumericHelper::FormatUnsigned(doy, target);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented date specifier for strftime");
-	}
-	return target;
-}
-
-char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name,
-                                             char *target) {
-	// data contains [0] year, [1] month, [2] day, [3] hour, [4] minute, [5] second, [6] msec, [7] utc
-	switch (specifier) {
-	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-		target = WritePadded2(target, data[2]);
-		break;
-	case StrTimeSpecifier::ABBREVIATED_MONTH_NAME: {
-		auto &month_name = Date::MONTH_NAMES_ABBREVIATED[data[1] - 1];
-		return WriteString(target, month_name);
-	}
-	case StrTimeSpecifier::FULL_MONTH_NAME: {
-		auto &month_name = Date::MONTH_NAMES[data[1] - 1];
-		return WriteString(target, month_name);
-	}
-	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-		target = WritePadded2(target, data[1]);
-		break;
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-		target = WritePadded2(target, AbsValue(data[0]) % 100);
-		break;
-	case StrTimeSpecifier::YEAR_DECIMAL:
-		if (data[0] >= 0 && data[0] <= 9999) {
-			target = WritePadded(target, data[0], 4);
-		} else {
-			int32_t year = data[0];
-			if (data[0] < 0) {
-				*target = '-';
-				year = -year;
-				target++;
-			}
-			auto len = NumericHelper::UnsignedLength<uint32_t>(year);
-			NumericHelper::FormatUnsigned(year, target + len);
-			target += len;
-		}
-		break;
-	case StrTimeSpecifier::HOUR_24_PADDED: {
-		target = WritePadded2(target, data[3]);
-		break;
-	}
-	case StrTimeSpecifier::HOUR_12_PADDED: {
-		int hour = data[3] % 12;
-		if (hour == 0) {
-			hour = 12;
-		}
-		target = WritePadded2(target, hour);
-		break;
-	}
-	case StrTimeSpecifier::AM_PM:
-		*target++ = data[3] >= 12 ? 'P' : 'A';
-		*target++ = 'M';
-		break;
-	case StrTimeSpecifier::MINUTE_PADDED: {
-		target = WritePadded2(target, data[4]);
-		break;
-	}
-	case StrTimeSpecifier::SECOND_PADDED:
-		target = WritePadded2(target, data[5]);
-		break;
-	case StrTimeSpecifier::MICROSECOND_PADDED:
-		target = WritePadded(target, data[6], 6);
-		break;
-	case StrTimeSpecifier::MILLISECOND_PADDED:
-		target = WritePadded3(target, data[6] / 1000);
-		break;
-	case StrTimeSpecifier::UTC_OFFSET: {
-		*target++ = (data[7] < 0) ? '-' : '+';
-
-		auto offset = abs(data[7]);
-		auto offset_hours = offset / Interval::MINS_PER_HOUR;
-		auto offset_minutes = offset % Interval::MINS_PER_HOUR;
-		target = WritePadded2(target, offset_hours);
-		if (offset_minutes) {
-			*target++ = ':';
-			target = WritePadded2(target, offset_minutes);
-		}
-		break;
-	}
-	case StrTimeSpecifier::TZ_NAME:
-		if (tz_name) {
-			strcpy(target, tz_name);
-			target += strlen(tz_name);
-		}
-		break;
-	case StrTimeSpecifier::DAY_OF_MONTH: {
-		target = Write2(target, data[2] % 100);
-		break;
-	}
-	case StrTimeSpecifier::MONTH_DECIMAL: {
-		target = Write2(target, data[1]);
-		break;
-	}
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY: {
-		target = Write2(target, data[0] % 100);
-		break;
-	}
-	case StrTimeSpecifier::HOUR_24_DECIMAL: {
-		target = Write2(target, data[3]);
-		break;
-	}
-	case StrTimeSpecifier::HOUR_12_DECIMAL: {
-		int hour = data[3] % 12;
-		if (hour == 0) {
-			hour = 12;
-		}
-		target = Write2(target, hour);
-		break;
-	}
-	case StrTimeSpecifier::MINUTE_DECIMAL: {
-		target = Write2(target, data[4]);
-		break;
-	}
-	case StrTimeSpecifier::SECOND_DECIMAL: {
-		target = Write2(target, data[5]);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented specifier for WriteStandardSpecifier in strftime");
-	}
-	return target;
-}
-
-void StrfTimeFormat::FormatString(date_t date, int32_t data[8], const char *tz_name, char *target) {
-	D_ASSERT(specifiers.size() + 1 == literals.size());
-	idx_t i;
-	for (i = 0; i < specifiers.size(); i++) {
-		// first copy the current literal
-		memcpy(target, literals[i].c_str(), literals[i].size());
-		target += literals[i].size();
-		// now copy the specifier
-		if (is_date_specifier[i]) {
-			target = WriteDateSpecifier(specifiers[i], date, target);
-		} else {
-			target = WriteStandardSpecifier(specifiers[i], data, tz_name, target);
-		}
-	}
-	// copy the final literal into the target
-	memcpy(target, literals[i].c_str(), literals[i].size());
-}
-
-void StrfTimeFormat::FormatString(date_t date, dtime_t time, char *target) {
-	int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
-	Date::Convert(date, data[0], data[1], data[2]);
-	Time::Convert(time, data[3], data[4], data[5], data[6]);
-	data[7] = 0;
-
-	FormatString(date, data, nullptr, target);
-}
-
-string StrfTimeFormat::Format(timestamp_t timestamp, const string &format_str) {
-	StrfTimeFormat format;
-	format.ParseFormatSpecifier(format_str, format);
-
-	auto date = Timestamp::GetDate(timestamp);
-	auto time = Timestamp::GetTime(timestamp);
-
-	auto len = format.GetLength(date, time, 0, nullptr);
-	auto result = unique_ptr<char[]>(new char[len]);
-	format.FormatString(date, time, result.get());
-	return string(result.get(), len);
-}
-
-string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeFormat &format) {
-	if (format_string.empty()) {
-		return "Empty format string";
-	}
-	format.specifiers.clear();
-	format.literals.clear();
-	format.numeric_width.clear();
-	format.constant_size = 0;
-	idx_t pos = 0;
-	string current_literal;
-	for (idx_t i = 0; i < format_string.size(); i++) {
-		if (format_string[i] == '%') {
-			if (i + 1 == format_string.size()) {
-				return "Trailing format character %";
-			}
-			if (i > pos) {
-				// push the previous string to the current literal
-				current_literal += format_string.substr(pos, i - pos);
-			}
-			char format_char = format_string[++i];
-			if (format_char == '%') {
-				// special case: %%
-				// set the pos for the next literal and continue
-				pos = i;
-				continue;
-			}
-			StrTimeSpecifier specifier;
-			if (format_char == '-' && i + 1 < format_string.size()) {
-				format_char = format_string[++i];
-				switch (format_char) {
-				case 'd':
-					specifier = StrTimeSpecifier::DAY_OF_MONTH;
-					break;
-				case 'm':
-					specifier = StrTimeSpecifier::MONTH_DECIMAL;
-					break;
-				case 'y':
-					specifier = StrTimeSpecifier::YEAR_WITHOUT_CENTURY;
-					break;
-				case 'H':
-					specifier = StrTimeSpecifier::HOUR_24_DECIMAL;
-					break;
-				case 'I':
-					specifier = StrTimeSpecifier::HOUR_12_DECIMAL;
-					break;
-				case 'M':
-					specifier = StrTimeSpecifier::MINUTE_DECIMAL;
-					break;
-				case 'S':
-					specifier = StrTimeSpecifier::SECOND_DECIMAL;
-					break;
-				case 'j':
-					specifier = StrTimeSpecifier::DAY_OF_YEAR_DECIMAL;
-					break;
-				default:
-					return "Unrecognized format for strftime/strptime: %-" + string(1, format_char);
-				}
-			} else {
-				switch (format_char) {
-				case 'a':
-					specifier = StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME;
-					break;
-				case 'A':
-					specifier = StrTimeSpecifier::FULL_WEEKDAY_NAME;
-					break;
-				case 'w':
-					specifier = StrTimeSpecifier::WEEKDAY_DECIMAL;
-					break;
-				case 'd':
-					specifier = StrTimeSpecifier::DAY_OF_MONTH_PADDED;
-					break;
-				case 'h':
-				case 'b':
-					specifier = StrTimeSpecifier::ABBREVIATED_MONTH_NAME;
-					break;
-				case 'B':
-					specifier = StrTimeSpecifier::FULL_MONTH_NAME;
-					break;
-				case 'm':
-					specifier = StrTimeSpecifier::MONTH_DECIMAL_PADDED;
-					break;
-				case 'y':
-					specifier = StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED;
-					break;
-				case 'Y':
-					specifier = StrTimeSpecifier::YEAR_DECIMAL;
-					break;
-				case 'H':
-					specifier = StrTimeSpecifier::HOUR_24_PADDED;
-					break;
-				case 'I':
-					specifier = StrTimeSpecifier::HOUR_12_PADDED;
-					break;
-				case 'p':
-					specifier = StrTimeSpecifier::AM_PM;
-					break;
-				case 'M':
-					specifier = StrTimeSpecifier::MINUTE_PADDED;
-					break;
-				case 'S':
-					specifier = StrTimeSpecifier::SECOND_PADDED;
-					break;
-				case 'f':
-					specifier = StrTimeSpecifier::MICROSECOND_PADDED;
-					break;
-				case 'g':
-					specifier = StrTimeSpecifier::MILLISECOND_PADDED;
-					break;
-				case 'z':
-					specifier = StrTimeSpecifier::UTC_OFFSET;
-					break;
-				case 'Z':
-					specifier = StrTimeSpecifier::TZ_NAME;
-					break;
-				case 'j':
-					specifier = StrTimeSpecifier::DAY_OF_YEAR_PADDED;
-					break;
-				case 'U':
-					specifier = StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST;
-					break;
-				case 'W':
-					specifier = StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST;
-					break;
-				case 'c':
-				case 'x':
-				case 'X':
-				case 'T': {
-					string subformat;
-					if (format_char == 'c') {
-						// %c: Locale’s appropriate date and time representation.
-						// we push the ISO timestamp representation here
-						subformat = "%Y-%m-%d %H:%M:%S";
-					} else if (format_char == 'x') {
-						// %x - Locale’s appropriate date representation.
-						// we push the ISO date format here
-						subformat = "%Y-%m-%d";
-					} else if (format_char == 'X' || format_char == 'T') {
-						// %X - Locale’s appropriate time representation.
-						// we push the ISO time format here
-						subformat = "%H:%M:%S";
-					}
-					// parse the subformat in a separate format specifier
-					StrfTimeFormat locale_format;
-					string error = StrTimeFormat::ParseFormatSpecifier(subformat, locale_format);
-					D_ASSERT(error.empty());
-					// add the previous literal to the first literal of the subformat
-					locale_format.literals[0] = move(current_literal) + locale_format.literals[0];
-					current_literal = "";
-					// now push the subformat into the current format specifier
-					for (idx_t i = 0; i < locale_format.specifiers.size(); i++) {
-						format.AddFormatSpecifier(move(locale_format.literals[i]), locale_format.specifiers[i]);
-					}
-					pos = i + 1;
-					continue;
-				}
-				default:
-					return "Unrecognized format for strftime/strptime: %" + string(1, format_char);
-				}
-			}
-			format.AddFormatSpecifier(move(current_literal), specifier);
-			current_literal = "";
-			pos = i + 1;
-		}
-	}
-	// add the final literal
-	if (pos < format_string.size()) {
-		current_literal += format_string.substr(pos, format_string.size() - pos);
-	}
-	format.AddLiteral(move(current_literal));
-	return string();
-}
-
-struct StrfTimeBindData : public FunctionData {
-	explicit StrfTimeBindData(StrfTimeFormat format_p, string format_string_p)
-	    : format(move(format_p)), format_string(move(format_string_p)) {
-	}
-
-	StrfTimeFormat format;
-	string format_string;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StrfTimeBindData>(format, format_string);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StrfTimeBindData &)other_p;
-		return format_string == other.format_string;
-	}
-};
-
-template <bool REVERSED>
-static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[REVERSED ? 0 : 1]->IsFoldable()) {
-		throw InvalidInputException("strftime format must be a constant");
-	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[REVERSED ? 0 : 1]);
-	auto format_string = options_str.GetValue<string>();
-	StrfTimeFormat format;
-	if (!options_str.IsNull()) {
-		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-		if (!error.empty()) {
-			throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
-		}
-	}
-	return make_unique<StrfTimeBindData>(format, format_string);
-}
-
-void StrfTimeFormat::ConvertDateVector(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::DATE);
-	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
-	UnaryExecutor::ExecuteWithNulls<date_t, string_t>(input, result, count,
-	                                                  [&](date_t input, ValidityMask &mask, idx_t idx) {
-		                                                  if (Date::IsFinite(input)) {
-			                                                  dtime_t time(0);
-			                                                  idx_t len = GetLength(input, time, 0, nullptr);
-			                                                  string_t target = StringVector::EmptyString(result, len);
-			                                                  FormatString(input, time, target.GetDataWriteable());
-			                                                  target.Finalize();
-			                                                  return target;
-		                                                  } else {
-			                                                  mask.SetInvalid(idx);
-			                                                  return string_t();
-		                                                  }
-	                                                  });
-}
-
-template <bool REVERSED>
-static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
-
-	if (ConstantVector::IsNull(args.data[REVERSED ? 0 : 1])) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	info.format.ConvertDateVector(args.data[REVERSED ? 1 : 0], result, args.size());
-}
-
-void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP);
-	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
-	UnaryExecutor::ExecuteWithNulls<timestamp_t, string_t>(
-	    input, result, count, [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
-		    if (Timestamp::IsFinite(input)) {
-			    date_t date;
-			    dtime_t time;
-			    Timestamp::Convert(input, date, time);
-			    idx_t len = GetLength(date, time, 0, nullptr);
-			    string_t target = StringVector::EmptyString(result, len);
-			    FormatString(date, time, target.GetDataWriteable());
-			    target.Finalize();
-			    return target;
-		    } else {
-			    mask.SetInvalid(idx);
-			    return string_t();
-		    }
-	    });
-}
-
-template <bool REVERSED>
-static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
-
-	if (ConstantVector::IsNull(args.data[REVERSED ? 0 : 1])) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	info.format.ConvertTimestampVector(args.data[REVERSED ? 1 : 0], result, args.size());
-}
-
-void StrfTimeFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet strftime("strftime");
-
-	strftime.AddFunction(ScalarFunction({LogicalType::DATE, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate<false>, false, false, StrfTimeBindFunction<false>));
-
-	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp<false>, false, false, StrfTimeBindFunction<false>));
-
-	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate<true>, false, false, StrfTimeBindFunction<true>));
-
-	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp<true>, false, false, StrfTimeBindFunction<true>));
-
-	set.AddFunction(strftime);
-}
-
-void StrpTimeFormat::AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) {
-	numeric_width.push_back(NumericSpecifierWidth(specifier));
-	StrTimeFormat::AddFormatSpecifier(move(preceding_literal), specifier);
-}
-
-int StrpTimeFormat::NumericSpecifierWidth(StrTimeSpecifier specifier) {
-	switch (specifier) {
-	case StrTimeSpecifier::WEEKDAY_DECIMAL:
-		return 1;
-	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-	case StrTimeSpecifier::DAY_OF_MONTH:
-	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-	case StrTimeSpecifier::MONTH_DECIMAL:
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-	case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-	case StrTimeSpecifier::HOUR_24_PADDED:
-	case StrTimeSpecifier::HOUR_24_DECIMAL:
-	case StrTimeSpecifier::HOUR_12_PADDED:
-	case StrTimeSpecifier::HOUR_12_DECIMAL:
-	case StrTimeSpecifier::MINUTE_PADDED:
-	case StrTimeSpecifier::MINUTE_DECIMAL:
-	case StrTimeSpecifier::SECOND_PADDED:
-	case StrTimeSpecifier::SECOND_DECIMAL:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-		return 2;
-	case StrTimeSpecifier::MILLISECOND_PADDED:
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-		return 3;
-	case StrTimeSpecifier::YEAR_DECIMAL:
-		return 4;
-	case StrTimeSpecifier::MICROSECOND_PADDED:
-		return 6;
-	default:
-		return -1;
-	}
-}
-
-enum class TimeSpecifierAMOrPM : uint8_t { TIME_SPECIFIER_NONE = 0, TIME_SPECIFIER_AM = 1, TIME_SPECIFIER_PM = 2 };
-
-int32_t StrpTimeFormat::TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
-                                           idx_t collection_count) {
-	for (idx_t c = 0; c < collection_count; c++) {
-		auto &entry = collection[c];
-		auto entry_data = entry.GetDataUnsafe();
-		auto entry_size = entry.GetSize();
-		// check if this entry matches
-		if (pos + entry_size > size) {
-			// too big: can't match
-			continue;
-		}
-		// compare the characters
-		idx_t i;
-		for (i = 0; i < entry_size; i++) {
-			if (std::tolower(entry_data[i]) != std::tolower(data[pos + i])) {
-				break;
-			}
-		}
-		if (i == entry_size) {
-			// full match
-			pos += entry_size;
-			return c;
-		}
-	}
-	return -1;
-}
-
-//! Parses a timestamp using the given specifier
-bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
-	auto &result_data = result.data;
-	auto &error_message = result.error_message;
-	auto &error_position = result.error_position;
-
-	// initialize the result
-	result_data[0] = 1900;
-	result_data[1] = 1;
-	result_data[2] = 1;
-	result_data[3] = 0;
-	result_data[4] = 0;
-	result_data[5] = 0;
-	result_data[6] = 0;
-	result_data[7] = 0;
-
-	auto data = str.GetDataUnsafe();
-	idx_t size = str.GetSize();
-	// skip leading spaces
-	while (StringUtil::CharacterIsSpace(*data)) {
-		data++;
-		size--;
-	}
-	idx_t pos = 0;
-	TimeSpecifierAMOrPM ampm = TimeSpecifierAMOrPM::TIME_SPECIFIER_NONE;
-
-	// Year offset state (Year+W/j)
-	auto offset_specifier = StrTimeSpecifier::WEEKDAY_DECIMAL;
-	uint64_t weekno = 0;
-	uint64_t weekday = 0;
-	uint64_t yearday = 0;
-
-	for (idx_t i = 0;; i++) {
-		D_ASSERT(i < literals.size());
-		// first compare the literal
-		const auto &literal = literals[i];
-		for (size_t l = 0; l < literal.size();) {
-			// Match runs of spaces to runs of spaces.
-			if (StringUtil::CharacterIsSpace(literal[l])) {
-				if (!StringUtil::CharacterIsSpace(data[pos])) {
-					error_message = "Space does not match, expected " + literals[i];
-					error_position = pos;
-					return false;
-				}
-				for (++pos; pos < size && StringUtil::CharacterIsSpace(data[pos]); ++pos) {
-					continue;
-				}
-				for (++l; l < literal.size() && StringUtil::CharacterIsSpace(literal[l]); ++l) {
-					continue;
-				}
-				continue;
-			}
-			// literal does not match
-			if (data[pos++] != literal[l++]) {
-				error_message = "Literal does not match, expected " + literal;
-				error_position = pos;
-				return false;
-			}
-		}
-		if (i == specifiers.size()) {
-			break;
-		}
-		// now parse the specifier
-		if (numeric_width[i] > 0) {
-			// numeric specifier: parse a number
-			uint64_t number = 0;
-			size_t start_pos = pos;
-			size_t end_pos = start_pos + numeric_width[i];
-			while (pos < size && pos < end_pos && StringUtil::CharacterIsDigit(data[pos])) {
-				number = number * 10 + data[pos] - '0';
-				pos++;
-			}
-			if (pos == start_pos) {
-				// expected a number here
-				error_message = "Expected a number";
-				error_position = start_pos;
-				return false;
-			}
-			switch (specifiers[i]) {
-			case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-			case StrTimeSpecifier::DAY_OF_MONTH:
-				if (number < 1 || number > 31) {
-					error_message = "Day out of range, expected a value between 1 and 31";
-					error_position = start_pos;
-					return false;
-				}
-				// day of the month
-				result_data[2] = number;
-				offset_specifier = specifiers[i];
-				break;
-			case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-			case StrTimeSpecifier::MONTH_DECIMAL:
-				if (number < 1 || number > 12) {
-					error_message = "Month out of range, expected a value between 1 and 12";
-					error_position = start_pos;
-					return false;
-				}
-				// month number
-				result_data[1] = number;
-				offset_specifier = specifiers[i];
-				break;
-			case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
-			case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
-				// year without century..
-				// Python uses 69 as a crossover point (i.e. >= 69 is 19.., < 69 is 20..)
-				if (number >= 100) {
-					// %y only supports numbers between [0..99]
-					error_message = "Year without century out of range, expected a value between 0 and 99";
-					error_position = start_pos;
-					return false;
-				}
-				if (number >= 69) {
-					result_data[0] = int32_t(1900 + number);
-				} else {
-					result_data[0] = int32_t(2000 + number);
-				}
-				break;
-			case StrTimeSpecifier::YEAR_DECIMAL:
-				// year as full number
-				result_data[0] = number;
-				break;
-			case StrTimeSpecifier::HOUR_24_PADDED:
-			case StrTimeSpecifier::HOUR_24_DECIMAL:
-				if (number >= 24) {
-					error_message = "Hour out of range, expected a value between 0 and 23";
-					error_position = start_pos;
-					return false;
-				}
-				// hour as full number
-				result_data[3] = number;
-				break;
-			case StrTimeSpecifier::HOUR_12_PADDED:
-			case StrTimeSpecifier::HOUR_12_DECIMAL:
-				if (number < 1 || number > 12) {
-					error_message = "Hour12 out of range, expected a value between 1 and 12";
-					error_position = start_pos;
-					return false;
-				}
-				// 12-hour number: start off by just storing the number
-				result_data[3] = number;
-				break;
-			case StrTimeSpecifier::MINUTE_PADDED:
-			case StrTimeSpecifier::MINUTE_DECIMAL:
-				if (number >= 60) {
-					error_message = "Minutes out of range, expected a value between 0 and 59";
-					error_position = start_pos;
-					return false;
-				}
-				// minutes
-				result_data[4] = number;
-				break;
-			case StrTimeSpecifier::SECOND_PADDED:
-			case StrTimeSpecifier::SECOND_DECIMAL:
-				if (number >= 60) {
-					error_message = "Seconds out of range, expected a value between 0 and 59";
-					error_position = start_pos;
-					return false;
-				}
-				// seconds
-				result_data[5] = number;
-				break;
-			case StrTimeSpecifier::MICROSECOND_PADDED:
-				D_ASSERT(number < 1000000ULL); // enforced by the length of the number
-				// milliseconds
-				result_data[6] = number;
-				break;
-			case StrTimeSpecifier::MILLISECOND_PADDED:
-				D_ASSERT(number < 1000ULL); // enforced by the length of the number
-				// milliseconds
-				result_data[6] = number * 1000;
-				break;
-			case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-			case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
-				// m/d overrides WU/w but does not conflict
-				switch (offset_specifier) {
-				case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-				case StrTimeSpecifier::DAY_OF_MONTH:
-				case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-				case StrTimeSpecifier::MONTH_DECIMAL:
-					// Just validate, don't use
-					break;
-				case StrTimeSpecifier::WEEKDAY_DECIMAL:
-					// First offset specifier
-					offset_specifier = specifiers[i];
-					break;
-				default:
-					error_message = "Multiple year offsets specified";
-					error_position = start_pos;
-					return false;
-				}
-				if (number > 53) {
-					error_message = "Week out of range, expected a value between 0 and 53";
-					error_position = start_pos;
-					return false;
-				}
-				weekno = number;
-				break;
-			case StrTimeSpecifier::WEEKDAY_DECIMAL:
-				if (number > 6) {
-					error_message = "Weekday out of range, expected a value between 0 and 6";
-					error_position = start_pos;
-					return false;
-				}
-				weekday = number;
-				break;
-			case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-			case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL:
-				// m/d overrides j but does not conflict
-				switch (offset_specifier) {
-				case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-				case StrTimeSpecifier::DAY_OF_MONTH:
-				case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-				case StrTimeSpecifier::MONTH_DECIMAL:
-					// Just validate, don't use
-					break;
-				case StrTimeSpecifier::WEEKDAY_DECIMAL:
-					// First offset specifier
-					offset_specifier = specifiers[i];
-					break;
-				default:
-					error_message = "Multiple year offsets specified";
-					error_position = start_pos;
-					return false;
-				}
-				if (number < 1 || number > 366) {
-					error_message = "Year day out of range, expected a value between 1 and 366";
-					error_position = start_pos;
-					return false;
-				}
-				yearday = number;
-				break;
-			default:
-				throw NotImplementedException("Unsupported specifier for strptime");
-			}
-		} else {
-			switch (specifiers[i]) {
-			case StrTimeSpecifier::AM_PM: {
-				// parse the next 2 characters
-				if (pos + 2 > size) {
-					// no characters left to parse
-					error_message = "Expected AM/PM";
-					error_position = pos;
-					return false;
-				}
-				char pa_char = char(std::tolower(data[pos]));
-				char m_char = char(std::tolower(data[pos + 1]));
-				if (m_char != 'm') {
-					error_message = "Expected AM/PM";
-					error_position = pos;
-					return false;
-				}
-				if (pa_char == 'p') {
-					ampm = TimeSpecifierAMOrPM::TIME_SPECIFIER_PM;
-				} else if (pa_char == 'a') {
-					ampm = TimeSpecifierAMOrPM::TIME_SPECIFIER_AM;
-				} else {
-					error_message = "Expected AM/PM";
-					error_position = pos;
-					return false;
-				}
-				pos += 2;
-				break;
-			}
-			// we parse weekday names, but we don't use them as information
-			case StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME:
-				if (TryParseCollection(data, pos, size, Date::DAY_NAMES_ABBREVIATED, 7) < 0) {
-					error_message = "Expected an abbreviated day name (Mon, Tue, Wed, Thu, Fri, Sat, Sun)";
-					error_position = pos;
-					return false;
-				}
-				break;
-			case StrTimeSpecifier::FULL_WEEKDAY_NAME:
-				if (TryParseCollection(data, pos, size, Date::DAY_NAMES, 7) < 0) {
-					error_message = "Expected a full day name (Monday, Tuesday, etc...)";
-					error_position = pos;
-					return false;
-				}
-				break;
-			case StrTimeSpecifier::ABBREVIATED_MONTH_NAME: {
-				int32_t month = TryParseCollection(data, pos, size, Date::MONTH_NAMES_ABBREVIATED, 12);
-				if (month < 0) {
-					error_message = "Expected an abbreviated month name (Jan, Feb, Mar, etc..)";
-					error_position = pos;
-					return false;
-				}
-				result_data[1] = month + 1;
-				break;
-			}
-			case StrTimeSpecifier::FULL_MONTH_NAME: {
-				int32_t month = TryParseCollection(data, pos, size, Date::MONTH_NAMES, 12);
-				if (month < 0) {
-					error_message = "Expected a full month name (January, February, etc...)";
-					error_position = pos;
-					return false;
-				}
-				result_data[1] = month + 1;
-				break;
-			}
-			case StrTimeSpecifier::UTC_OFFSET: {
-				int hour_offset, minute_offset;
-				if (!Timestamp::TryParseUTCOffset(data, pos, size, hour_offset, minute_offset)) {
-					error_message = "Expected +HH[MM] or -HH[MM]";
-					error_position = pos;
-					return false;
-				}
-				result_data[7] = hour_offset * Interval::MINS_PER_HOUR + minute_offset;
-				break;
-			}
-			case StrTimeSpecifier::TZ_NAME: {
-				// skip leading spaces
-				while (pos < size && StringUtil::CharacterIsSpace(data[pos])) {
-					pos++;
-				}
-				const auto tz_begin = data + pos;
-				// stop when we encounter a space or the end of the string
-				while (pos < size && !StringUtil::CharacterIsSpace(data[pos])) {
-					pos++;
-				}
-				const auto tz_end = data + pos;
-				// Can't fully validate without a list - caller's responsibility.
-				// But tz must not be empty.
-				if (tz_end == tz_begin) {
-					error_message = "Empty Time Zone name";
-					error_position = tz_begin - data;
-					return false;
-				}
-				result.tz.assign(tz_begin, tz_end);
-				break;
-			}
-			default:
-				throw NotImplementedException("Unsupported specifier for strptime");
-			}
-		}
-	}
-	// skip trailing spaces
-	while (pos < size && StringUtil::CharacterIsSpace(data[pos])) {
-		pos++;
-	}
-	if (pos != size) {
-		error_message = "Full specifier did not match: trailing characters";
-		error_position = pos;
-		return false;
-	}
-	if (ampm != TimeSpecifierAMOrPM::TIME_SPECIFIER_NONE) {
-		if (result_data[3] > 12) {
-			error_message =
-			    "Invalid hour: " + to_string(result_data[3]) + " AM/PM, expected an hour within the range [0..12]";
-			return false;
-		}
-		// adjust the hours based on the AM or PM specifier
-		if (ampm == TimeSpecifierAMOrPM::TIME_SPECIFIER_AM) {
-			// AM: 12AM=0, 1AM=1, 2AM=2, ..., 11AM=11
-			if (result_data[3] == 12) {
-				result_data[3] = 0;
-			}
-		} else {
-			// PM: 12PM=12, 1PM=13, 2PM=14, ..., 11PM=23
-			if (result_data[3] != 12) {
-				result_data[3] += 12;
-			}
-		}
-	}
-	switch (offset_specifier) {
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
-	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST: {
-		// Adjust weekday to be 0-based for the week type
-		weekday = (weekday + 7 - int(offset_specifier == StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST)) % 7;
-		// Get the start of week 1, move back 7 days and then weekno * 7 + weekday gives the date
-		const auto jan1 = Date::FromDate(result_data[0], 1, 1);
-		auto yeardate = Date::GetMondayOfCurrentWeek(jan1);
-		yeardate -= int(offset_specifier == StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST);
-		// Is there a week 0?
-		yeardate -= 7 * int(yeardate >= jan1);
-		yeardate += weekno * 7 + weekday;
-		Date::Convert(yeardate, result_data[0], result_data[1], result_data[2]);
-		break;
-	}
-	case StrTimeSpecifier::DAY_OF_YEAR_PADDED:
-	case StrTimeSpecifier::DAY_OF_YEAR_DECIMAL: {
-		auto yeardate = Date::FromDate(result_data[0], 1, 1);
-		yeardate += yearday - 1;
-		Date::Convert(yeardate, result_data[0], result_data[1], result_data[2]);
-		break;
-	}
-	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
-	case StrTimeSpecifier::DAY_OF_MONTH:
-	case StrTimeSpecifier::MONTH_DECIMAL_PADDED:
-	case StrTimeSpecifier::MONTH_DECIMAL:
-		// m/d overrides UWw/j
-		break;
-	default:
-		D_ASSERT(offset_specifier == StrTimeSpecifier::WEEKDAY_DECIMAL);
-		break;
-	}
-
-	return true;
-}
-
-struct StrpTimeBindData : public FunctionData {
-	explicit StrpTimeBindData(StrpTimeFormat format_p, string format_string_p)
-	    : format(move(format_p)), format_string(move(format_string_p)) {
-	}
-
-	StrpTimeFormat format;
-	string format_string;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StrpTimeBindData>(format, format_string);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StrpTimeBindData &)other_p;
-		return format_string == other.format_string;
-	}
-};
-
-static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[1]->IsFoldable()) {
-		throw InvalidInputException("strptime format must be a constant");
-	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-	string format_string = options_str.ToString();
-	StrpTimeFormat format;
-	if (!options_str.IsNull()) {
-		if (options_str.type().id() != LogicalTypeId::VARCHAR) {
-			throw InvalidInputException("strptime format must be a string");
-		}
-		format.format_specifier = format_string;
-		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-		if (!error.empty()) {
-			throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
-		}
-		if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
-			bound_function.return_type = LogicalType::TIMESTAMP_TZ;
-		}
-	}
-	return make_unique<StrpTimeBindData>(format, format_string);
-}
-
-StrpTimeFormat::ParseResult StrpTimeFormat::Parse(const string &format_string, const string &text) {
-	StrpTimeFormat format;
-	format.format_specifier = format_string;
-	string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-	if (!error.empty()) {
-		throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
-	}
-	StrpTimeFormat::ParseResult result;
-	if (!format.Parse(text, result)) {
-		throw InvalidInputException("Failed to parse string \"%s\" with format specifier \"%s\"", text, format_string);
-	}
-	return result;
-}
-
-string StrpTimeFormat::FormatStrpTimeError(const string &input, idx_t position) {
-	if (position == DConstants::INVALID_INDEX) {
-		return string();
-	}
-	return input + "\n" + string(position, ' ') + "^";
-}
-
-date_t StrpTimeFormat::ParseResult::ToDate() {
-	return Date::FromDate(data[0], data[1], data[2]);
-}
-
-timestamp_t StrpTimeFormat::ParseResult::ToTimestamp() {
-	date_t date = Date::FromDate(data[0], data[1], data[2]);
-	const auto hour_offset = data[7] / Interval::MINS_PER_HOUR;
-	const auto mins_offset = data[7] % Interval::MINS_PER_HOUR;
-	dtime_t time = Time::FromTime(data[3] - hour_offset, data[4] - mins_offset, data[5], data[6]);
-	return Timestamp::FromDatetime(date, time);
-}
-
-string StrpTimeFormat::ParseResult::FormatError(string_t input, const string &format_specifier) {
-	return StringUtil::Format("Could not parse string \"%s\" according to format specifier \"%s\"\n%s\nError: %s",
-	                          input.GetString(), format_specifier,
-	                          FormatStrpTimeError(input.GetString(), error_position), error_message);
-}
-
-bool StrpTimeFormat::TryParseDate(string_t input, date_t &result, string &error_message) {
-	ParseResult parse_result;
-	if (!Parse(input, parse_result)) {
-		error_message = parse_result.FormatError(input, format_specifier);
-		return false;
-	}
-	result = parse_result.ToDate();
-	return true;
-}
-
-bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, string &error_message) {
-	ParseResult parse_result;
-	if (!Parse(input, parse_result)) {
-		error_message = parse_result.FormatError(input, format_specifier);
-		return false;
-	}
-	result = parse_result.ToTimestamp();
-	return true;
-}
-
-date_t StrpTimeFormat::ParseDate(string_t input) {
-	ParseResult result;
-	if (!Parse(input, result)) {
-		throw InvalidInputException(result.FormatError(input, format_specifier));
-	}
-	return result.ToDate();
-}
-
-timestamp_t StrpTimeFormat::ParseTimestamp(string_t input) {
-	ParseResult result;
-	if (!Parse(input, result)) {
-		throw InvalidInputException(result.FormatError(input, format_specifier));
-	}
-	return result.ToTimestamp();
-}
-
-static void StrpTimeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StrpTimeBindData &)*func_expr.bind_info;
-
-	if (ConstantVector::IsNull(args.data[1])) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		return;
-	}
-	UnaryExecutor::Execute<string_t, timestamp_t>(args.data[0], result, args.size(),
-	                                              [&](string_t input) { return info.format.ParseTimestamp(input); });
-}
-
-void StrpTimeFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet strptime("strptime");
-
-	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP, StrpTimeFunction,
-	                          false, false, StrpTimeBindFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	strptime.AddFunction(fun);
-
-	set.AddFunction(strptime);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct ToYearsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.days = 0;
-		result.micros = 0;
-		if (!TryMultiplyOperator::Operation<int32_t, int32_t, int32_t>(input, Interval::MONTHS_PER_YEAR,
-		                                                               result.months)) {
-			throw OutOfRangeException("Interval value %d years out of range", input);
-		}
-		return result;
-	}
-};
-
-struct ToMonthsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = input;
-		result.days = 0;
-		result.micros = 0;
-		return result;
-	}
-};
-
-struct ToDaysOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = input;
-		result.micros = 0;
-		return result;
-	}
-};
-
-struct ToHoursOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(input, Interval::MICROS_PER_HOUR,
-		                                                               result.micros)) {
-			throw OutOfRangeException("Interval value %d hours out of range", input);
-		}
-		return result;
-	}
-};
-
-struct ToMinutesOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(input, Interval::MICROS_PER_MINUTE,
-		                                                               result.micros)) {
-			throw OutOfRangeException("Interval value %d minutes out of range", input);
-		}
-		return result;
-	}
-};
-
-struct ToSecondsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(input, Interval::MICROS_PER_SEC,
-		                                                               result.micros)) {
-			throw OutOfRangeException("Interval value %d seconds out of range", input);
-		}
-		return result;
-	}
-};
-
-struct ToMilliSecondsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(input, Interval::MICROS_PER_MSEC,
-		                                                               result.micros)) {
-			throw OutOfRangeException("Interval value %d milliseconds out of range", input);
-		}
-		return result;
-	}
-};
-
-struct ToMicroSecondsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		interval_t result;
-		result.months = 0;
-		result.days = 0;
-		result.micros = input;
-		return result;
-	}
-};
-
-void ToIntervalFun::RegisterFunction(BuiltinFunctions &set) {
-	// register the individual operators
-	set.AddFunction(ScalarFunction("to_years", {LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>));
-	set.AddFunction(ScalarFunction("to_months", {LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>));
-	set.AddFunction(ScalarFunction("to_days", {LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>));
-	set.AddFunction(ScalarFunction("to_hours", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>));
-	set.AddFunction(ScalarFunction("to_minutes", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>));
-	set.AddFunction(ScalarFunction("to_seconds", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToSecondsOperator>));
-	set.AddFunction(ScalarFunction("to_milliseconds", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToMilliSecondsOperator>));
-	set.AddFunction(ScalarFunction("to_microseconds", {LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                               ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterDateFunctions() {
-	Register<AgeFun>();
-	Register<DateDiffFun>();
-	Register<DatePartFun>();
-	Register<DateSubFun>();
-	Register<DateTruncFun>();
-	Register<CurrentTimeFun>();
-	Register<CurrentDateFun>();
-	Register<CurrentTimestampFun>();
-	Register<EpochFun>();
-	Register<MakeDateFun>();
-	Register<StrfTimeFun>();
-	Register<StrpTimeFun>();
-	Register<ToIntervalFun>();
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-static void EnumFirstFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 1);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
-	auto val = Value(enum_vector.GetValue(0));
-	result.Reference(val);
-}
-
-static void EnumLastFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 1);
-	auto enum_size = EnumType::GetSize(input.GetTypes()[0]);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
-	auto val = Value(enum_vector.GetValue(enum_size - 1));
-	result.Reference(val);
-}
-
-static void EnumRangeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 1);
-	auto enum_size = EnumType::GetSize(input.GetTypes()[0]);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
-	vector<Value> enum_values;
-	for (idx_t i = 0; i < enum_size; i++) {
-		enum_values.emplace_back(enum_vector.GetValue(i));
-	}
-	auto val = Value::LIST(enum_values);
-	result.Reference(val);
-}
-
-static void EnumRangeBoundaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 2);
-	idx_t start, end;
-	auto first_param = input.GetValue(0, 0);
-	auto second_param = input.GetValue(1, 0);
-
-	auto &enum_vector = first_param.IsNull() ? EnumType::GetValuesInsertOrder(input.GetTypes()[1])
-	                                         : EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
-
-	if (first_param.IsNull()) {
-		start = 0;
-	} else {
-		start = first_param.GetValue<uint32_t>();
-	}
-	if (second_param.IsNull()) {
-		end = EnumType::GetSize(input.GetTypes()[0]);
-	} else {
-		end = second_param.GetValue<uint32_t>() + 1;
-	}
-	vector<Value> enum_values;
-	for (idx_t i = start; i < end; i++) {
-		enum_values.emplace_back(enum_vector.GetValue(i));
-	}
-	Value val;
-	if (enum_values.empty()) {
-		val = Value::EMPTYLIST(LogicalType::VARCHAR);
-	} else {
-		val = Value::LIST(enum_values);
-	}
-	result.Reference(val);
-}
-
-unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarFunction &bound_function,
-                                          vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-	return nullptr;
-}
-
-unique_ptr<FunctionData> BindEnumRangeBoundaryFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                       vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM && arguments[0]->return_type != LogicalType::SQLNULL) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-	if (arguments[1]->return_type.id() != LogicalTypeId::ENUM && arguments[1]->return_type != LogicalType::SQLNULL) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-	if (arguments[0]->return_type == LogicalType::SQLNULL && arguments[1]->return_type == LogicalType::SQLNULL) {
-		throw BinderException("This function needs an ENUM as an argument");
-	}
-	if (arguments[0]->return_type.id() == LogicalTypeId::ENUM &&
-	    arguments[1]->return_type.id() == LogicalTypeId::ENUM &&
-	    arguments[0]->return_type != arguments[1]->return_type) {
-
-		throw BinderException("The parameters need to link to ONLY one enum OR be NULL ");
-	}
-	return nullptr;
-}
-
-void EnumFirst::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("enum_first", {LogicalType::ANY}, LogicalType::VARCHAR, EnumFirstFunction, false,
-	                               BindEnumFunction));
-}
-
-void EnumLast::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("enum_last", {LogicalType::ANY}, LogicalType::VARCHAR, EnumLastFunction, false,
-	                               BindEnumFunction));
-}
-
-void EnumRange::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("enum_range", {LogicalType::ANY}, LogicalType::LIST(LogicalType::VARCHAR),
-	                               EnumRangeFunction, false, BindEnumFunction));
-}
-
-void EnumRangeBoundary::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("enum_range_boundary", {LogicalType::ANY, LogicalType::ANY},
-	                          LogicalType::LIST(LogicalType::VARCHAR), EnumRangeBoundaryFunction, false,
-	                          BindEnumRangeBoundaryFunction);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterEnumFunctions() {
-	Register<EnumFirst>();
-	Register<EnumLast>();
-	Register<EnumRange>();
-	Register<EnumRangeBoundary>();
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-static void AliasFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	Value v(state.expr.alias.empty() ? func_expr.children[0]->GetName() : state.expr.alias);
-	result.Reference(v);
-}
-
-void AliasFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("alias", {LogicalType::ANY}, LogicalType::VARCHAR, AliasFunction));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-struct ConstantOrNullBindData : public FunctionData {
-	explicit ConstantOrNullBindData(Value val) : value(move(val)) {
-	}
-
-	Value value;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ConstantOrNullBindData>(value);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ConstantOrNullBindData &)other_p;
-		return value == other.value;
-	}
-};
-
-static void ConstantOrNullFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (ConstantOrNullBindData &)*func_expr.bind_info;
-	result.Reference(info.value);
-	for (idx_t idx = 0; idx < args.ColumnCount(); idx++) {
-		switch (args.data[idx].GetVectorType()) {
-		case VectorType::FLAT_VECTOR: {
-			auto &input_mask = FlatVector::Validity(args.data[idx]);
-			if (!input_mask.AllValid()) {
-				// there are null values: need to merge them into the result
-				result.Normalify(args.size());
-				auto &result_mask = FlatVector::Validity(result);
-				result_mask.Combine(input_mask, args.size());
-			}
-			break;
-		}
-		case VectorType::CONSTANT_VECTOR: {
-			if (ConstantVector::IsNull(args.data[idx])) {
-				// input is constant null, return constant null
-				result.Reference(info.value);
-				ConstantVector::SetNull(result, true);
-				return;
-			}
-			break;
-		}
-		default: {
-			VectorData vdata;
-			args.data[idx].Orrify(args.size(), vdata);
-			if (!vdata.validity.AllValid()) {
-				result.Normalify(args.size());
-				auto &result_mask = FlatVector::Validity(result);
-				for (idx_t i = 0; i < args.size(); i++) {
-					if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
-						result_mask.SetInvalid(i);
-					}
-				}
-			}
-			break;
-		}
-		}
-	}
-}
-
-ScalarFunction ConstantOrNull::GetFunction(LogicalType return_type) {
-	return ScalarFunction("constant_or_null", {}, move(return_type), ConstantOrNullFunction);
-}
-
-unique_ptr<FunctionData> ConstantOrNull::Bind(Value value) {
-	return make_unique<ConstantOrNullBindData>(move(value));
-}
-
-bool ConstantOrNull::IsConstantOrNull(BoundFunctionExpression &expr, const Value &val) {
-	if (expr.function.name != "constant_or_null") {
-		return false;
-	}
-	D_ASSERT(expr.bind_info);
-	auto &bind_data = (ConstantOrNullBindData &)*expr.bind_info;
-	D_ASSERT(bind_data.value.type() == val.type());
-	return bind_data.value == val;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CurrentSettingBindData : public FunctionData {
-	explicit CurrentSettingBindData(Value value_p) : value(move(value_p)) {
-	}
-
-	Value value;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<CurrentSettingBindData>(value);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const CurrentSettingBindData &)other_p;
-		return Value::NotDistinctFrom(value, other.value);
-	}
-};
-
-static void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (CurrentSettingBindData &)*func_expr.bind_info;
-	result.Reference(info.value);
-}
-
-unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-
-	auto &key_child = arguments[0];
-
-	if (key_child->return_type.id() != LogicalTypeId::VARCHAR ||
-	    key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
-		throw ParserException("Key name for current_setting needs to be a constant string");
-	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(*key_child.get());
-	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
-	auto &key_str = StringValue::Get(key_val);
-	if (key_val.IsNull() || key_str.empty()) {
-		throw ParserException("Key name for current_setting needs to be neither NULL nor empty");
-	}
-
-	auto key = StringUtil::Lower(key_str);
-	Value val;
-	if (!context.TryGetCurrentSetting(key, val)) {
-		throw InvalidInputException("unrecognized configuration parameter \"%s\"", key_str);
-	}
-
-	bound_function.return_type = val.type();
-	return make_unique<CurrentSettingBindData>(val);
-}
-
-void CurrentSettingFun::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("current_setting", {LogicalType::VARCHAR}, LogicalType::ANY, CurrentSettingFunction,
-	                          false, CurrentSettingBind);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-static void HashFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	args.Hash(result);
-}
-
-void HashFun::RegisterFunction(BuiltinFunctions &set) {
-	auto hash_fun = ScalarFunction("hash", {LogicalType::ANY}, LogicalType::HASH, HashFunction);
-	hash_fun.varargs = LogicalType::ANY;
-	set.AddFunction(hash_fun);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-template <class OP>
-struct LeastOperator {
-	template <class T>
-	static T Operation(T left, T right) {
-		return OP::Operation(left, right) ? left : right;
-	}
-};
-
-template <class T, class OP, bool IS_STRING = false>
-static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	if (args.ColumnCount() == 1) {
-		// single input: nop
-		result.Reference(args.data[0]);
-		return;
-	}
-	auto result_type = VectorType::CONSTANT_VECTOR;
-	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-		if (args.data[col_idx].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			// non-constant input: result is not a constant vector
-			result_type = VectorType::FLAT_VECTOR;
-		}
-		if (IS_STRING) {
-			// for string vectors we add a reference to the heap of the children
-			StringVector::AddHeapReference(result, args.data[col_idx]);
-		}
-	}
-
-	auto result_data = FlatVector::GetData<T>(result);
-	auto &result_mask = FlatVector::Validity(result);
-	// copy over the first column
-	bool result_has_value[STANDARD_VECTOR_SIZE];
-	{
-		VectorData vdata;
-		args.data[0].Orrify(args.size(), vdata);
-		auto input_data = (T *)vdata.data;
-		for (idx_t i = 0; i < args.size(); i++) {
-			auto vindex = vdata.sel->get_index(i);
-			if (vdata.validity.RowIsValid(vindex)) {
-				result_data[i] = input_data[vindex];
-				result_has_value[i] = true;
-			} else {
-				result_has_value[i] = false;
-			}
-		}
-	}
-	// now handle the remainder of the columns
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		if (args.data[col_idx].GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    ConstantVector::IsNull(args.data[col_idx])) {
-			// ignore null vector
-			continue;
-		}
-
-		VectorData vdata;
-		args.data[col_idx].Orrify(args.size(), vdata);
-
-		auto input_data = (T *)vdata.data;
-		if (!vdata.validity.AllValid()) {
-			// potential new null entries: have to check the null mask
-			for (idx_t i = 0; i < args.size(); i++) {
-				auto vindex = vdata.sel->get_index(i);
-				if (vdata.validity.RowIsValid(vindex)) {
-					// not a null entry: perform the operation and add to new set
-					auto ivalue = input_data[vindex];
-					if (!result_has_value[i] || OP::template Operation<T>(ivalue, result_data[i])) {
-						result_has_value[i] = true;
-						result_data[i] = ivalue;
-					}
-				}
-			}
-		} else {
-			// no new null entries: only need to perform the operation
-			for (idx_t i = 0; i < args.size(); i++) {
-				auto vindex = vdata.sel->get_index(i);
-
-				auto ivalue = input_data[vindex];
-				if (!result_has_value[i] || OP::template Operation<T>(ivalue, result_data[i])) {
-					result_has_value[i] = true;
-					result_data[i] = ivalue;
-				}
-			}
-		}
-	}
-	for (idx_t i = 0; i < args.size(); i++) {
-		if (!result_has_value[i]) {
-			result_mask.SetInvalid(i);
-		}
-	}
-	result.SetVectorType(result_type);
-}
-
-template <typename T, class OP>
-ScalarFunction GetLeastGreatestFunction(const LogicalType &type) {
-	return ScalarFunction({type}, type, LeastGreatestFunction<T, OP>, true, false, nullptr, nullptr, nullptr, nullptr,
-	                      type, FunctionNullHandling::SPECIAL_HANDLING);
-}
-
-template <class OP>
-static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name) {
-	ScalarFunctionSet fun_set(fun_name);
-	fun_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::BIGINT, LeastGreatestFunction<int64_t, OP>,
-	                                   true, false, nullptr, nullptr, nullptr, nullptr, LogicalType::BIGINT,
-	                                   FunctionNullHandling::SPECIAL_HANDLING));
-	fun_set.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::HUGEINT,
-	                                   LeastGreatestFunction<hugeint_t, OP>, true, false, nullptr, nullptr, nullptr,
-	                                   nullptr, LogicalType::HUGEINT, FunctionNullHandling::SPECIAL_HANDLING));
-	fun_set.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, LeastGreatestFunction<double, OP>,
-	                                   true, false, nullptr, nullptr, nullptr, nullptr, LogicalType::DOUBLE,
-	                                   FunctionNullHandling::SPECIAL_HANDLING));
-	fun_set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                   LeastGreatestFunction<string_t, OP, true>, true, false, nullptr, nullptr,
-	                                   nullptr, nullptr, LogicalType::VARCHAR, FunctionNullHandling::SPECIAL_HANDLING));
-
-	fun_set.AddFunction(GetLeastGreatestFunction<timestamp_t, OP>(LogicalType::TIMESTAMP));
-	fun_set.AddFunction(GetLeastGreatestFunction<time_t, OP>(LogicalType::TIME));
-	fun_set.AddFunction(GetLeastGreatestFunction<date_t, OP>(LogicalType::DATE));
-
-	fun_set.AddFunction(GetLeastGreatestFunction<timestamp_t, OP>(LogicalType::TIMESTAMP_TZ));
-	fun_set.AddFunction(GetLeastGreatestFunction<time_t, OP>(LogicalType::TIME_TZ));
-
-	set.AddFunction(fun_set);
-}
-
-void LeastFun::RegisterFunction(BuiltinFunctions &set) {
-	RegisterLeastGreatest<duckdb::LessThan>(set, "least");
-}
-
-void GreatestFun::RegisterFunction(BuiltinFunctions &set) {
-	RegisterLeastGreatest<duckdb::GreaterThan>(set, "greatest");
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct StatsBindData : public FunctionData {
-	explicit StatsBindData(string stats_p = string()) : stats(move(stats_p)) {
-	}
-
-	string stats;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StatsBindData>(stats);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StatsBindData &)other_p;
-		return stats == other.stats;
-	}
-};
-
-static void StatsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StatsBindData &)*func_expr.bind_info;
-	if (info.stats.empty()) {
-		info.stats = "No statistics";
-	}
-	Value v(info.stats);
-	result.Reference(v);
-}
-
-unique_ptr<FunctionData> StatsBind(ClientContext &context, ScalarFunction &bound_function,
-                                   vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<StatsBindData>();
-}
-
-static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &bind_data = input.bind_data;
-	if (child_stats[0]) {
-		auto &info = (StatsBindData &)*bind_data;
-		info.stats = child_stats[0]->ToString();
-	}
-	return nullptr;
-}
-
-void StatsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("stats", {LogicalType::ANY}, LogicalType::VARCHAR, StatsFunction, true, StatsBind,
-	                               nullptr, StatsPropagateStats));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-static void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	Value v(args.data[0].GetType().ToString());
-	result.Reference(v);
-}
-
-void TypeOfFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("typeof", {LogicalType::ANY}, LogicalType::VARCHAR, TypeOfFunction));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterGenericFunctions() {
-	Register<AliasFun>();
-	Register<HashFun>();
-	Register<LeastFun>();
-	Register<GreatestFun>();
-	Register<StatsFun>();
-	Register<TypeOfFun>();
-	Register<CurrentSettingFun>();
-	Register<SystemFun>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <typename INPUT_TYPE, typename INDEX_TYPE>
-INDEX_TYPE ValueOffset(const INPUT_TYPE &value) {
-	return 0;
-}
-
-template <>
-int64_t ValueOffset(const list_entry_t &value) {
-	return value.offset;
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE>
-INDEX_TYPE ValueLength(const INPUT_TYPE &value) {
-	return 0;
-}
-
-template <>
-int64_t ValueLength(const list_entry_t &value) {
-	return value.length;
-}
-
-template <>
-int32_t ValueLength(const string_t &value) {
-	return LengthFun::Length<string_t, int32_t>(value);
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE>
-bool ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value) {
-	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
-	if (index < 0) {
-		if (-index > length) {
-			return false;
-		}
-		index = length + index;
-	} else if (index > length) {
-		index = length;
-	}
-	return true;
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE>
-static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end, bool begin_valid, bool end_valid) {
-	// Clamp offsets
-	begin = begin_valid ? begin : 0;
-	end = end_valid ? end : ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
-	if (!ClampIndex(begin, value) || !ClampIndex(end, value)) {
-		return false;
-	}
-	end = MaxValue<INDEX_TYPE>(begin, end);
-
-	return true;
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE>
-INPUT_TYPE SliceValue(Vector &result, INPUT_TYPE input, INDEX_TYPE begin, INDEX_TYPE end) {
-	return input;
-}
-
-template <>
-list_entry_t SliceValue(Vector &result, list_entry_t input, int64_t begin, int64_t end) {
-	input.offset += begin;
-	input.length = end - begin;
-	return input;
-}
-
-template <>
-string_t SliceValue(Vector &result, string_t input, int32_t begin, int32_t end) {
-	// one-based - zero has strange semantics
-	return SubstringFun::SubstringScalarFunction(result, input, begin + 1, end - begin);
-}
-
-template <typename INPUT_TYPE, typename INDEX_TYPE>
-static void ExecuteSlice(Vector &result, Vector &s, Vector &b, Vector &e, const idx_t count) {
-	if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto rdata = ConstantVector::GetData<INPUT_TYPE>(result);
-		auto sdata = ConstantVector::GetData<INPUT_TYPE>(s);
-		auto bdata = ConstantVector::GetData<INDEX_TYPE>(b);
-		auto edata = ConstantVector::GetData<INDEX_TYPE>(e);
-
-		auto sliced = sdata[0];
-		auto begin = (bdata[0] > 0) ? bdata[0] - 1 : bdata[0];
-		auto end = edata[0];
-
-		auto svalid = !ConstantVector::IsNull(s);
-		auto bvalid = !ConstantVector::IsNull(b);
-		auto evalid = !ConstantVector::IsNull(e);
-
-		// Try to slice
-		if (!svalid || !ClampSlice(sliced, begin, end, bvalid, evalid)) {
-			ConstantVector::SetNull(result, true);
-		} else {
-			rdata[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
-		}
-	} else {
-		VectorData sdata, bdata, edata;
-
-		s.Orrify(count, sdata);
-		b.Orrify(count, bdata);
-		e.Orrify(count, edata);
-
-		auto rdata = FlatVector::GetData<INPUT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
-
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = sdata.sel->get_index(i);
-			auto bidx = bdata.sel->get_index(i);
-			auto eidx = edata.sel->get_index(i);
-
-			auto sliced = ((INPUT_TYPE *)sdata.data)[sidx];
-			auto begin = ((INDEX_TYPE *)bdata.data)[bidx];
-			auto end = ((INDEX_TYPE *)edata.data)[eidx];
-
-			begin = (begin > 0) ? begin - 1 : begin;
-
-			auto svalid = sdata.validity.RowIsValid(sidx);
-			auto bvalid = bdata.validity.RowIsValid(bidx);
-			auto evalid = edata.validity.RowIsValid(eidx);
-
-			// Try to slice
-			if (!svalid || !ClampSlice(sliced, begin, end, bvalid, evalid)) {
-				rmask.SetInvalid(i);
-			} else {
-				rdata[i] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
-			}
-		}
-	}
-
-	result.Verify(count);
-}
-
-static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-	D_ASSERT(args.data.size() == 3);
-	auto count = args.size();
-
-	Vector &s = args.data[0];
-	Vector &b = args.data[1];
-	Vector &e = args.data[2];
-
-	s.Normalify(count);
-	switch (result.GetType().id()) {
-	case LogicalTypeId::LIST:
-		// Share the value dictionary as we are just going to slice it
-		ListVector::ReferenceEntry(result, s);
-		ExecuteSlice<list_entry_t, int64_t>(result, s, b, e, count);
-		break;
-	case LogicalTypeId::VARCHAR:
-		ExecuteSlice<string_t, int32_t>(result, s, b, e, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented");
-	}
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			break;
-		}
-	}
-}
-
-static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 3);
-	switch (arguments[0]->return_type.id()) {
-	case LogicalTypeId::LIST:
-		// The result is the same type
-		bound_function.return_type = arguments[0]->return_type;
-		break;
-	case LogicalTypeId::VARCHAR:
-		// string slice returns a string, but can only accept 32 bit integers
-		bound_function.return_type = arguments[0]->return_type;
-		bound_function.arguments[1] = LogicalType::INTEGER;
-		bound_function.arguments[2] = LogicalType::INTEGER;
-		break;
-	case LogicalTypeId::SQLNULL:
-	case LogicalTypeId::UNKNOWN:
-		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
-		bound_function.return_type = LogicalType::SQLNULL;
-		break;
-	default:
-		throw BinderException("ARRAY_SLICE can only operate on LISTs and VARCHARs");
-	}
-
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-void ArraySliceFun::RegisterFunction(BuiltinFunctions &set) {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun({LogicalType::ANY, LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::ANY,
-	                   ArraySliceFunction, false, false, ArraySliceBind);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction({"array_slice", "list_slice"}, fun);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-template <class T>
-static inline bool ValueEqualsOrNot(const T &left, const T &right) {
-	return left == right;
-}
-
-template <>
-inline bool ValueEqualsOrNot(const string_t &left, const string_t &right) {
-	return StringComparisonOperators::EqualsOrNot<false>(left, right);
-}
-
-struct ContainsFunctor {
-	static inline bool Initialize() {
-		return false;
-	}
-	static inline bool UpdateResultEntries(idx_t child_idx) {
-		return true;
-	}
-};
-
-struct PositionFunctor {
-	static inline int32_t Initialize() {
-		return 0;
-	}
-	static inline int32_t UpdateResultEntries(idx_t child_idx) {
-		return child_idx + 1;
-	}
-};
-
-template <class CHILD_TYPE, class RETURN_TYPE, class OP>
-static void TemplatedContainsOrPosition(DataChunk &args, ExpressionState &state, Vector &result,
-                                        bool is_nested = false) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto count = args.size();
-	Vector &list = args.data[0];
-	Vector &value_vector = args.data[1];
-
-	// Create a result vector of type RETURN_TYPE
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_entries = FlatVector::GetData<RETURN_TYPE>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	if (list.GetType().id() == LogicalTypeId::SQLNULL) {
-		result_validity.SetInvalid(0);
-		return;
-	}
-
-	auto list_size = ListVector::GetListSize(list);
-	auto &child_vector = ListVector::GetEntry(list);
-
-	VectorData child_data;
-	child_vector.Orrify(list_size, child_data);
-
-	VectorData list_data;
-	list.Orrify(count, list_data);
-	auto list_entries = (list_entry_t *)list_data.data;
-
-	VectorData value_data;
-	value_vector.Orrify(count, value_data);
-
-	// not required for a comparison of nested types
-	auto child_value = FlatVector::GetData<CHILD_TYPE>(child_vector);
-	auto values = FlatVector::GetData<CHILD_TYPE>(value_vector);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto list_index = list_data.sel->get_index(i);
-		auto value_index = value_data.sel->get_index(i);
-
-		if (!list_data.validity.RowIsValid(list_index) || !value_data.validity.RowIsValid(value_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-
-		const auto &list_entry = list_entries[list_index];
-
-		result_entries[i] = OP::Initialize();
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-
-			auto child_value_idx = child_data.sel->get_index(list_entry.offset + child_idx);
-			if (!child_data.validity.RowIsValid(child_value_idx)) {
-				continue;
-			}
-
-			if (!is_nested) {
-				if (ValueEqualsOrNot<CHILD_TYPE>(child_value[child_value_idx], values[value_index])) {
-					result_entries[i] = OP::UpdateResultEntries(child_idx);
-					break; // Found value in list, no need to look further
-				}
-			} else {
-				// FIXME: using Value is less efficient than modifying the vector comparison code
-				// to more efficiently compare nested types
-				if (ValueEqualsOrNot<Value>(child_vector.GetValue(child_value_idx),
-				                            value_vector.GetValue(value_index))) {
-					result_entries[i] = OP::UpdateResultEntries(child_idx);
-					break; // Found value in list, no need to look further
-				}
-			}
-		}
-	}
-}
-
-template <class T, class OP>
-static void ListContainsOrPosition(DataChunk &args, ExpressionState &state, Vector &result) {
-	switch (args.data[1].GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedContainsOrPosition<int8_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::INT16:
-		TemplatedContainsOrPosition<int16_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::INT32:
-		TemplatedContainsOrPosition<int32_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::INT64:
-		TemplatedContainsOrPosition<int64_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::INT128:
-		TemplatedContainsOrPosition<hugeint_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedContainsOrPosition<uint8_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedContainsOrPosition<uint16_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedContainsOrPosition<uint32_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedContainsOrPosition<uint64_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedContainsOrPosition<float, T, OP>(args, state, result);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedContainsOrPosition<double, T, OP>(args, state, result);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedContainsOrPosition<string_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::MAP:
-	case PhysicalType::STRUCT:
-	case PhysicalType::LIST:
-		TemplatedContainsOrPosition<int8_t, T, OP>(args, state, result, true);
-		break;
-	default:
-		throw NotImplementedException("This function has not been implemented for this type");
-	}
-}
-
-static void ListContainsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	return ListContainsOrPosition<bool, ContainsFunctor>(args, state, result);
-}
-
-static void ListPositionFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	return ListContainsOrPosition<int32_t, PositionFunctor>(args, state, result);
-}
-
-template <LogicalTypeId RETURN_TYPE>
-static unique_ptr<FunctionData> ListContainsOrPositionBind(ClientContext &context, ScalarFunction &bound_function,
-                                                           vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-
-	const auto &list = arguments[0]->return_type; // change to list
-	const auto &value = arguments[1]->return_type;
-	if (list.id() == LogicalTypeId::UNKNOWN) {
-		bound_function.return_type = RETURN_TYPE;
-		if (value.id() != LogicalTypeId::UNKNOWN) {
-			// only list is a parameter, cast it to a list of value type
-			bound_function.arguments[0] = LogicalType::LIST(value);
-			bound_function.arguments[1] = value;
-		}
-	} else if (value.id() == LogicalTypeId::UNKNOWN) {
-		// only value is a parameter: we expect the child type of list
-		auto const &child_type = ListType::GetChildType(list);
-		bound_function.arguments[0] = list;
-		bound_function.arguments[1] = child_type;
-		bound_function.return_type = RETURN_TYPE;
-	} else {
-		auto const &child_type = ListType::GetChildType(list);
-		auto max_child_type = LogicalType::MaxLogicalType(child_type, value);
-		auto list_type = LogicalType::LIST(max_child_type);
-
-		bound_function.arguments[0] = list_type;
-		bound_function.arguments[1] = value == max_child_type ? value : max_child_type;
-
-		// list_contains and list_position only differ in their return type
-		bound_function.return_type = RETURN_TYPE;
-	}
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-static unique_ptr<FunctionData> ListContainsBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	return ListContainsOrPositionBind<LogicalType::BOOLEAN>(context, bound_function, arguments);
-}
-
-static unique_ptr<FunctionData> ListPositionBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	return ListContainsOrPositionBind<LogicalType::INTEGER>(context, bound_function, arguments);
-}
-
-ScalarFunction ListContainsFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
-	                      LogicalType::BOOLEAN,                                    // return type
-	                      ListContainsFunction, false, false, ListContainsBind, nullptr);
-}
-
-ScalarFunction ListPositionFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
-	                      LogicalType::INTEGER,                                    // return type
-	                      ListPositionFunction, false, false, ListPositionBind, nullptr);
-}
-
-void ListContainsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_contains", "array_contains", "list_has", "array_has"}, GetFunction());
-}
-
-void ListPositionFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_position", "list_indexof", "array_position", "array_indexof"}, GetFunction());
-}
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-
-	Vector &input = args.data[0];
-	if (input.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.Reference(input);
-		return;
-	}
-
-	idx_t count = args.size();
-
-	VectorData list_data;
-	input.Orrify(count, list_data);
-	auto list_entries = (list_entry_t *)list_data.data;
-
-	auto &child_vector = ListVector::GetEntry(input);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_entries = FlatVector::GetData<list_entry_t>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	if (child_vector.GetType().id() == LogicalTypeId::SQLNULL) {
-		auto result_entries = FlatVector::GetData<list_entry_t>(result);
-		for (idx_t i = 0; i < count; i++) {
-			auto list_index = list_data.sel->get_index(i);
-			if (!list_data.validity.RowIsValid(list_index)) {
-				result_validity.SetInvalid(i);
-				continue;
-			}
-			result_entries[i].offset = 0;
-			result_entries[i].length = 0;
-		}
-		return;
-	}
-
-	auto child_size = ListVector::GetListSize(input);
-	VectorData child_data;
-	child_vector.Orrify(child_size, child_data);
-	auto child_entries = (list_entry_t *)child_data.data;
-	auto &data_vector = ListVector::GetEntry(child_vector);
-
-	idx_t offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto list_index = list_data.sel->get_index(i);
-		if (!list_data.validity.RowIsValid(list_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-		auto list_entry = list_entries[list_index];
-
-		idx_t source_offset = 0;
-		// Find first valid child list entry to get offset
-		for (idx_t j = 0; j < list_entry.length; j++) {
-			auto child_list_index = child_data.sel->get_index(list_entry.offset + j);
-			if (child_data.validity.RowIsValid(child_list_index)) {
-				source_offset = child_entries[child_list_index].offset;
-				break;
-			}
-		}
-
-		idx_t length = 0;
-		// Find last valid child list entry to get length
-		for (idx_t j = list_entry.length - 1; j != (idx_t)-1; j--) {
-			auto child_list_index = child_data.sel->get_index(list_entry.offset + j);
-			if (child_data.validity.RowIsValid(child_list_index)) {
-				auto child_entry = child_entries[child_list_index];
-				length = child_entry.offset + child_entry.length - source_offset;
-				break;
-			}
-		}
-		ListVector::Append(result, data_vector, source_offset + length, source_offset);
-
-		result_entries[i].offset = offset;
-		result_entries[i].length = length;
-		offset += length;
-	}
-
-	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ListFlattenBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 1);
-
-	auto &input_type = arguments[0]->return_type;
-	bound_function.arguments[0] = input_type;
-	if (input_type.id() == LogicalTypeId::UNKNOWN) {
-		bound_function.arguments[0] = LogicalType(LogicalTypeId::UNKNOWN);
-		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
-		return nullptr;
-	}
-	D_ASSERT(input_type.id() == LogicalTypeId::LIST);
-
-	auto child_type = ListType::GetChildType(input_type);
-	if (child_type.id() == LogicalType::SQLNULL) {
-		bound_function.return_type = input_type;
-		return make_unique<VariableReturnBindData>(bound_function.return_type);
-	}
-	D_ASSERT(child_type.id() == LogicalTypeId::LIST);
-
-	bound_function.return_type = child_type;
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &list_stats = (ListStatistics &)*child_stats[0];
-	if (!list_stats.child_stats || list_stats.child_stats->type == LogicalTypeId::SQLNULL) {
-		return nullptr;
-	}
-
-	auto child_copy = list_stats.child_stats->Copy();
-	child_copy->validity_stats = make_unique<ValidityStatistics>(true);
-	return child_copy;
-}
-
-void ListFlattenFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::LIST(LogicalType::ANY))}, LogicalType::LIST(LogicalType::ANY),
-	                   ListFlattenFunction, false, false, ListFlattenBind, nullptr, ListFlattenStats);
-	set.AddFunction({"flatten"}, fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-// FIXME: use a local state for each thread to increase performance?
-// FIXME: benchmark the use of simple_update against using update (if applicable)
-
-struct ListAggregatesBindData : public FunctionData {
-	ListAggregatesBindData(const LogicalType &stype_p, unique_ptr<Expression> aggr_expr_p);
-	~ListAggregatesBindData() override;
-
-	LogicalType stype;
-	unique_ptr<Expression> aggr_expr;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ListAggregatesBindData>(stype, aggr_expr->Copy());
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ListAggregatesBindData &)other_p;
-		return stype == other.stype && aggr_expr->Equals(other.aggr_expr.get());
-	}
-};
-
-ListAggregatesBindData::ListAggregatesBindData(const LogicalType &stype_p, unique_ptr<Expression> aggr_expr_p)
-    : stype(stype_p), aggr_expr(move(aggr_expr_p)) {
-}
-
-ListAggregatesBindData::~ListAggregatesBindData() {
-}
-
-struct StateVector {
-	StateVector(idx_t count_p, unique_ptr<Expression> aggr_expr_p)
-	    : count(count_p), aggr_expr(move(aggr_expr_p)), state_vector(Vector(LogicalType::POINTER, count_p)) {
-	}
-
-	~StateVector() {
-		// destroy objects within the aggregate states
-		auto &aggr = (BoundAggregateExpression &)*aggr_expr;
-		if (aggr.function.destructor) {
-			aggr.function.destructor(state_vector, count);
-		}
-	}
-
-	idx_t count;
-	unique_ptr<Expression> aggr_expr;
-	Vector state_vector;
-};
-
-struct FinalizeValueFunctor {
-	template <class T>
-	static Value FinalizeValue(T first) {
-		return Value::CreateValue(first);
-	}
-};
-
-struct FinalizeStringValueFunctor {
-	template <class T>
-	static Value FinalizeValue(T first) {
-		string_t value = first;
-		return Value::CreateValue(value);
-	}
-};
-
-struct AggregateFunctor {
-	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
-	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
-	}
-};
-
-struct DistinctFunctor {
-	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
-	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
-
-		VectorData sdata;
-		state_vector.Orrify(count, sdata);
-		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
-
-		auto result_data = FlatVector::GetData<list_entry_t>(result);
-
-		idx_t offset = 0;
-		for (idx_t i = 0; i < count; i++) {
-
-			auto state = states[sdata.sel->get_index(i)];
-			result_data[i].offset = offset;
-
-			if (!state->hist) {
-				result_data[i].length = 0;
-				continue;
-			}
-
-			result_data[i].length = state->hist->size();
-			offset += state->hist->size();
-
-			for (auto &entry : *state->hist) {
-				Value bucket_value = OP::template FinalizeValue<T>(entry.first);
-				ListVector::PushBack(result, bucket_value);
-			}
-		}
-		result.Verify(count);
-	}
-};
-
-struct UniqueFunctor {
-	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
-	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
-
-		VectorData sdata;
-		state_vector.Orrify(count, sdata);
-		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
-
-		auto result_data = FlatVector::GetData<uint64_t>(result);
-
-		for (idx_t i = 0; i < count; i++) {
-
-			auto state = states[sdata.sel->get_index(i)];
-
-			if (!state->hist) {
-				result_data[i] = 0;
-				continue;
-			}
-
-			result_data[i] = state->hist->size();
-		}
-		result.Verify(count);
-	}
-};
-
-template <class FUNCTION_FUNCTOR, bool IS_AGGR = false>
-static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
-	auto count = args.size();
-	Vector &lists = args.data[0];
-
-	// set the result vector
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto &result_validity = FlatVector::Validity(result);
-
-	if (lists.GetType().id() == LogicalTypeId::SQLNULL) {
-		result_validity.SetInvalid(0);
-		return;
-	}
-
-	// get the aggregate function
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (ListAggregatesBindData &)*func_expr.bind_info;
-	auto &aggr = (BoundAggregateExpression &)*info.aggr_expr;
-	AggregateInputData aggr_input_data(aggr.bind_info.get());
-
-	D_ASSERT(aggr.function.update);
-
-	auto lists_size = ListVector::GetListSize(lists);
-	auto &child_vector = ListVector::GetEntry(lists);
-
-	VectorData child_data;
-	child_vector.Orrify(lists_size, child_data);
-
-	VectorData lists_data;
-	lists.Orrify(count, lists_data);
-	auto list_entries = (list_entry_t *)lists_data.data;
-
-	// state_buffer holds the state for each list of this chunk
-	idx_t size = aggr.function.state_size();
-	auto state_buffer = unique_ptr<data_t[]>(new data_t[size * count]);
-
-	// state vector for initialize and finalize
-	StateVector state_vector(count, info.aggr_expr->Copy());
-	auto states = FlatVector::GetData<data_ptr_t>(state_vector.state_vector);
-
-	// state vector of STANDARD_VECTOR_SIZE holds the pointers to the states
-	Vector state_vector_update = Vector(LogicalType::POINTER);
-	auto states_update = FlatVector::GetData<data_ptr_t>(state_vector_update);
-
-	// selection vector pointing to the data
-	SelectionVector sel_vector(STANDARD_VECTOR_SIZE);
-	idx_t states_idx = 0;
-
-	for (idx_t i = 0; i < count; i++) {
-
-		// initialize the state for this list
-		auto state_ptr = state_buffer.get() + size * i;
-		states[i] = state_ptr;
-		aggr.function.initialize(states[i]);
-
-		auto lists_index = lists_data.sel->get_index(i);
-		const auto &list_entry = list_entries[lists_index];
-
-		// nothing to do for this list
-		if (!lists_data.validity.RowIsValid(lists_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-
-		// skip empty list
-		if (list_entry.length == 0) {
-			continue;
-		}
-
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-
-			// states vector is full, update
-			if (states_idx == STANDARD_VECTOR_SIZE) {
-
-				// update the aggregate state(s)
-				Vector slice = Vector(child_vector, sel_vector, states_idx);
-				aggr.function.update(&slice, aggr_input_data, 1, state_vector_update, states_idx);
-
-				// reset values
-				states_idx = 0;
-			}
-
-			auto source_idx = child_data.sel->get_index(list_entry.offset + child_idx);
-			sel_vector.set_index(states_idx, source_idx);
-			states_update[states_idx] = state_ptr;
-			states_idx++;
-		}
-	}
-
-	// update the remaining elements of the last list(s)
-	if (states_idx != 0) {
-		Vector slice = Vector(child_vector, sel_vector, states_idx);
-		aggr.function.update(&slice, aggr_input_data, 1, state_vector_update, states_idx);
-	}
-
-	if (IS_AGGR) {
-		// finalize all the aggregate states
-		aggr.function.finalize(state_vector.state_vector, aggr_input_data, result, count, 0);
-
-	} else {
-		// finalize manually to use the map
-		D_ASSERT(aggr.function.arguments.size() == 1);
-		auto key_type = aggr.function.arguments[0];
-
-		switch (key_type.InternalType()) {
-		case PhysicalType::BOOL:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, bool>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::UINT8:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint8_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::UINT16:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint16_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::UINT32:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint32_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::UINT64:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, uint64_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::INT8:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int8_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::INT16:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int16_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::INT32:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::INT64:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::FLOAT:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, float>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::DOUBLE:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, double>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::DATE32:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::DATE64:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::TIMESTAMP:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::TIME32:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::TIME64:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::STRING:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeStringValueFunctor, string>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::LARGE_STRING:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeStringValueFunctor, string>(
-			    result, state_vector.state_vector, count);
-			break;
-		case PhysicalType::VARCHAR:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeStringValueFunctor, string>(
-			    result, state_vector.state_vector, count);
-			break;
-		default:
-			throw InternalException("Unimplemented histogram aggregate");
-		}
-	}
-}
-
-static void ListAggregateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
-	D_ASSERT(args.ColumnCount() == 2);
-	ListAggregatesFunction<AggregateFunctor, true>(args, state, result);
-}
-
-static void ListDistinctFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
-	D_ASSERT(args.ColumnCount() == 1);
-	ListAggregatesFunction<DistinctFunctor>(args, state, result);
-}
-
-static void ListUniqueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
-	D_ASSERT(args.ColumnCount() == 1);
-	ListAggregatesFunction<UniqueFunctor>(args, state, result);
-}
-
-template <bool IS_AGGR = false>
-static unique_ptr<FunctionData> ListAggregatesBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                           const LogicalType &list_child_type,
-                                                           AggregateFunction &aggr_function) {
-
-	// create the child expression and its type
-	vector<unique_ptr<Expression>> children;
-	auto expr = make_unique<BoundConstantExpression>(Value(list_child_type));
-	children.push_back(move(expr));
-
-	auto bound_aggr_function = AggregateFunction::BindAggregateFunction(context, aggr_function, move(children));
-	bound_function.arguments[0] = LogicalType::LIST(bound_aggr_function->function.arguments[0]);
-
-	if (IS_AGGR) {
-		bound_function.return_type = bound_aggr_function->function.return_type;
-	}
-
-	return make_unique<ListAggregatesBindData>(bound_function.return_type, move(bound_aggr_function));
-}
-
-template <bool IS_AGGR = false>
-static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
-		bound_function.arguments[0] = LogicalType::SQLNULL;
-		bound_function.return_type = LogicalType::SQLNULL;
-		return make_unique<VariableReturnBindData>(bound_function.return_type);
-	}
-
-	bool is_parameter = arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN;
-	auto list_child_type = is_parameter ? LogicalTypeId::UNKNOWN : ListType::GetChildType(arguments[0]->return_type);
-
-	string function_name = "histogram";
-	if (IS_AGGR) { // get the name of the aggregate function
-
-		if (!arguments[1]->IsFoldable()) {
-			throw InvalidInputException("Aggregate function name must be a constant");
-		}
-		// get the function name
-		Value function_value = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		function_name = function_value.ToString();
-	}
-
-	// look up the aggregate function in the catalog
-	QueryErrorContext error_context(nullptr, 0);
-	auto func = (AggregateFunctionCatalogEntry *)Catalog::GetCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(
-	    context, DEFAULT_SCHEMA, function_name, false, error_context);
-	D_ASSERT(func->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
-
-	if (is_parameter) {
-		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
-		bound_function.return_type = LogicalType::SQLNULL;
-		return nullptr;
-	}
-
-	// find a matching aggregate function
-	string error;
-	vector<LogicalType> types;
-	types.push_back(list_child_type);
-	auto best_function_idx = Function::BindFunction(func->name, func->functions, types, error);
-	if (best_function_idx == DConstants::INVALID_INDEX) {
-		throw BinderException("No matching aggregate function");
-	}
-
-	// found a matching function, bind it as an aggregate
-	auto &best_function = func->functions[best_function_idx];
-
-	if (IS_AGGR) {
-		return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, list_child_type, best_function);
-	}
-
-	// create the unordered map histogram function
-	D_ASSERT(best_function.arguments.size() == 1);
-	auto key_type = best_function.arguments[0];
-	auto aggr_function = HistogramFun::GetHistogramUnorderedMap(key_type);
-	return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, list_child_type, aggr_function);
-}
-
-static unique_ptr<FunctionData> ListAggregateBind(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-
-	// the list column and the name of the aggregate function
-	D_ASSERT(bound_function.arguments.size() == 2);
-	D_ASSERT(arguments.size() == 2);
-
-	return ListAggregatesBind<true>(context, bound_function, arguments);
-}
-
-static unique_ptr<FunctionData> ListDistinctBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(bound_function.arguments.size() == 1);
-	D_ASSERT(arguments.size() == 1);
-	bound_function.return_type = arguments[0]->return_type;
-
-	return ListAggregatesBind<>(context, bound_function, arguments);
-}
-
-static unique_ptr<FunctionData> ListUniqueBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(bound_function.arguments.size() == 1);
-	D_ASSERT(arguments.size() == 1);
-	bound_function.return_type = LogicalType::UBIGINT;
-
-	return ListAggregatesBind<>(context, bound_function, arguments);
-}
-
-ScalarFunction ListAggregateFun::GetFunction() {
-	auto result = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY,
-	                             ListAggregateFunction, false, false, ListAggregateBind);
-	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return result;
-}
-
-ScalarFunction ListDistinctFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),
-	                      ListDistinctFunction, false, false, ListDistinctBind);
-}
-
-ScalarFunction ListUniqueFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::UBIGINT, ListUniqueFunction, false, false,
-	                      ListUniqueBind);
-}
-
-void ListAggregateFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_aggregate", "array_aggregate", "list_aggr", "array_aggr"}, GetFunction());
-}
-
-void ListDistinctFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_distinct", "array_distinct"}, GetFunction());
-}
-
-void ListUniqueFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_unique", "array_unique"}, GetFunction());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto count = args.size();
-
-	Vector &lhs = args.data[0];
-	Vector &rhs = args.data[1];
-	if (lhs.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.Reference(rhs);
-		return;
-	}
-	if (rhs.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.Reference(lhs);
-		return;
-	}
-
-	VectorData lhs_data;
-	VectorData rhs_data;
-	lhs.Orrify(count, lhs_data);
-	rhs.Orrify(count, rhs_data);
-	auto lhs_entries = (list_entry_t *)lhs_data.data;
-	auto rhs_entries = (list_entry_t *)rhs_data.data;
-
-	auto lhs_list_size = ListVector::GetListSize(lhs);
-	auto rhs_list_size = ListVector::GetListSize(rhs);
-	auto &lhs_child = ListVector::GetEntry(lhs);
-	auto &rhs_child = ListVector::GetEntry(rhs);
-	VectorData lhs_child_data;
-	VectorData rhs_child_data;
-	lhs_child.Orrify(lhs_list_size, lhs_child_data);
-	rhs_child.Orrify(rhs_list_size, rhs_child_data);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_entries = FlatVector::GetData<list_entry_t>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	idx_t offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto lhs_list_index = lhs_data.sel->get_index(i);
-		auto rhs_list_index = rhs_data.sel->get_index(i);
-		if (!lhs_data.validity.RowIsValid(lhs_list_index) && !rhs_data.validity.RowIsValid(rhs_list_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-		result_entries[i].offset = offset;
-		result_entries[i].length = 0;
-		if (lhs_data.validity.RowIsValid(lhs_list_index)) {
-			const auto &lhs_entry = lhs_entries[lhs_list_index];
-			result_entries[i].length += lhs_entry.length;
-			ListVector::Append(result, lhs_child, *lhs_child_data.sel, lhs_entry.offset + lhs_entry.length,
-			                   lhs_entry.offset);
-		}
-		if (rhs_data.validity.RowIsValid(rhs_list_index)) {
-			const auto &rhs_entry = rhs_entries[rhs_list_index];
-			result_entries[i].length += rhs_entry.length;
-			ListVector::Append(result, rhs_child, *rhs_child_data.sel, rhs_entry.offset + rhs_entry.length,
-			                   rhs_entry.offset);
-		}
-		offset += result_entries[i].length;
-	}
-	D_ASSERT(ListVector::GetListSize(result) == offset);
-
-	if (lhs.GetVectorType() == VectorType::CONSTANT_VECTOR && rhs.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-
-	auto &lhs = arguments[0]->return_type;
-	auto &rhs = arguments[1]->return_type;
-	if (lhs.id() == LogicalTypeId::SQLNULL || rhs.id() == LogicalTypeId::SQLNULL) {
-		// we mimic postgres behaviour: list_concat(NULL, my_list) = my_list
-		bound_function.arguments[0] = lhs;
-		bound_function.arguments[1] = rhs;
-		bound_function.return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs;
-	} else {
-		D_ASSERT(lhs.id() == LogicalTypeId::LIST);
-		D_ASSERT(rhs.id() == LogicalTypeId::LIST);
-
-		// Resolve list type
-		LogicalType child_type = LogicalType::SQLNULL;
-		for (const auto &argument : arguments) {
-			child_type = LogicalType::MaxLogicalType(child_type, ListType::GetChildType(argument->return_type));
-		}
-		auto list_type = LogicalType::LIST(move(child_type));
-
-		bound_function.arguments[0] = list_type;
-		bound_function.arguments[1] = list_type;
-		bound_function.return_type = list_type;
-	}
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	D_ASSERT(child_stats.size() == 2);
-	if (!child_stats[0] || !child_stats[1]) {
-		return nullptr;
-	}
-
-	auto &left_stats = (ListStatistics &)*child_stats[0];
-	auto &right_stats = (ListStatistics &)*child_stats[1];
-
-	auto stats = left_stats.Copy();
-	stats->Merge(right_stats);
-
-	return stats;
-}
-
-ScalarFunction ListConcatFun::GetFunction() {
-	// the arguments and return types are actually set in the binder function
-	auto fun = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)},
-	                          LogicalType::LIST(LogicalType::ANY), ListConcatFunction, false, false, ListConcatBind,
-	                          nullptr, ListConcatStats);
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
-}
-
-void ListConcatFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_concat", "list_cat", "array_concat", "array_cat"}, GetFunction());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T, bool HEAP_REF = false, bool VALIDITY_ONLY = false>
-void ListExtractTemplate(idx_t count, VectorData &list_data, VectorData &offsets_data, Vector &child_vector,
-                         idx_t list_size, Vector &result) {
-	VectorData child_data;
-	child_vector.Orrify(list_size, child_data);
-
-	T *result_data;
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	if (!VALIDITY_ONLY) {
-		result_data = FlatVector::GetData<T>(result);
-	}
-	auto &result_mask = FlatVector::Validity(result);
-
-	// heap-ref once
-	if (HEAP_REF) {
-		StringVector::AddHeapReference(result, child_vector);
-	}
-
-	// this is lifted from ExecuteGenericLoop because we can't push the list child data into this otherwise
-	// should have gone with GetValue perhaps
-	for (idx_t i = 0; i < count; i++) {
-		auto list_index = list_data.sel->get_index(i);
-		auto offsets_index = offsets_data.sel->get_index(i);
-		if (list_data.validity.RowIsValid(list_index) && offsets_data.validity.RowIsValid(offsets_index)) {
-			auto list_entry = ((list_entry_t *)list_data.data)[list_index];
-			auto offsets_entry = ((int64_t *)offsets_data.data)[offsets_index];
-
-			// 1-based indexing
-			if (offsets_entry == 0) {
-				result_mask.SetInvalid(i);
-				continue;
-			}
-			offsets_entry = (offsets_entry > 0) ? offsets_entry - 1 : offsets_entry;
-
-			idx_t child_offset;
-			if (offsets_entry < 0) {
-				if ((idx_t)-offsets_entry > list_entry.length) {
-					result_mask.SetInvalid(i);
-					continue;
-				}
-				child_offset = list_entry.offset + list_entry.length + offsets_entry;
-			} else {
-				if ((idx_t)offsets_entry >= list_entry.length) {
-					result_mask.SetInvalid(i);
-					continue;
-				}
-				child_offset = list_entry.offset + offsets_entry;
-			}
-			if (child_data.validity.RowIsValid(child_offset)) {
-				if (!VALIDITY_ONLY) {
-					result_data[i] = ((T *)child_data.data)[child_offset];
-				}
-			} else {
-				result_mask.SetInvalid(i);
-			}
-		} else {
-			result_mask.SetInvalid(i);
-		}
-	}
-	if (count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-static void ExecuteListExtractInternal(const idx_t count, VectorData &list, VectorData &offsets, Vector &child_vector,
-                                       idx_t list_size, Vector &result) {
-	D_ASSERT(child_vector.GetType() == result.GetType());
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		ListExtractTemplate<int8_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INT16:
-		ListExtractTemplate<int16_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INT32:
-		ListExtractTemplate<int32_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INT64:
-		ListExtractTemplate<int64_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INT128:
-		ListExtractTemplate<hugeint_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT8:
-		ListExtractTemplate<uint8_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT16:
-		ListExtractTemplate<uint16_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT32:
-		ListExtractTemplate<uint32_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT64:
-		ListExtractTemplate<uint64_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::FLOAT:
-		ListExtractTemplate<float>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::DOUBLE:
-		ListExtractTemplate<double>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::VARCHAR:
-		ListExtractTemplate<string_t, true>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INTERVAL:
-		ListExtractTemplate<interval_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::STRUCT: {
-		auto &entries = StructVector::GetEntries(child_vector);
-		auto &result_entries = StructVector::GetEntries(result);
-		D_ASSERT(entries.size() == result_entries.size());
-		// extract the child entries of the struct
-		for (idx_t i = 0; i < entries.size(); i++) {
-			ExecuteListExtractInternal(count, list, offsets, *entries[i], list_size, *result_entries[i]);
-		}
-		// extract the validity mask
-		ListExtractTemplate<bool, false, true>(count, list, offsets, child_vector, list_size, result);
-		break;
-	}
-	case PhysicalType::LIST: {
-		// nested list: we have to reference the child
-		auto &child_child_list = ListVector::GetEntry(child_vector);
-
-		ListVector::GetEntry(result).Reference(child_child_list);
-		ListVector::SetListSize(result, ListVector::GetListSize(child_vector));
-		ListExtractTemplate<list_entry_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	}
-	default:
-		throw NotImplementedException("Unimplemented type for LIST_EXTRACT");
-	}
-}
-
-static void ExecuteListExtract(Vector &result, Vector &list, Vector &offsets, const idx_t count) {
-	D_ASSERT(list.GetType().id() == LogicalTypeId::LIST);
-	VectorData list_data;
-	VectorData offsets_data;
-
-	list.Orrify(count, list_data);
-	offsets.Orrify(count, offsets_data);
-	ExecuteListExtractInternal(count, list_data, offsets_data, ListVector::GetEntry(list),
-	                           ListVector::GetListSize(list), result);
-	result.Verify(count);
-}
-
-static void ExecuteStringExtract(Vector &result, Vector &input_vector, Vector &subscript_vector, const idx_t count) {
-	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    input_vector, subscript_vector, result, count, [&](string_t input_string, int64_t subscript) {
-		    return SubstringFun::SubstringScalarFunction(result, input_string, subscript, 1);
-	    });
-}
-
-static void ListExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto count = args.size();
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-	}
-
-	Vector &base = args.data[0];
-	Vector &subscript = args.data[1];
-
-	switch (base.GetType().id()) {
-	case LogicalTypeId::LIST:
-		ExecuteListExtract(result, base, subscript, count);
-		break;
-	case LogicalTypeId::VARCHAR:
-		ExecuteStringExtract(result, base, subscript, count);
-		break;
-	case LogicalTypeId::SQLNULL:
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented");
-	}
-}
-
-static unique_ptr<FunctionData> ListExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-	D_ASSERT(LogicalTypeId::LIST == arguments[0]->return_type.id());
-	// list extract returns the child type of the list as return type
-	bound_function.return_type = ListType::GetChildType(arguments[0]->return_type);
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-static unique_ptr<BaseStatistics> ListExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &list_stats = (ListStatistics &)*child_stats[0];
-	if (!list_stats.child_stats) {
-		return nullptr;
-	}
-	auto child_copy = list_stats.child_stats->Copy();
-	// list_extract always pushes a NULL, since if the offset is out of range for a list it inserts a null
-	child_copy->validity_stats = make_unique<ValidityStatistics>(true);
-	return child_copy;
-}
-
-void ListExtractFun::RegisterFunction(BuiltinFunctions &set) {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction lfun({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::ANY,
-	                    ListExtractFunction, false, false, ListExtractBind, nullptr, ListExtractStats);
-
-	ScalarFunction sfun({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, ListExtractFunction, false,
-	                    false, nullptr);
-
-	ScalarFunctionSet list_extract("list_extract");
-	list_extract.AddFunction(lfun);
-	list_extract.AddFunction(sfun);
-	set.AddFunction(list_extract);
-
-	ScalarFunctionSet list_element("list_element");
-	list_element.AddFunction(lfun);
-	list_element.AddFunction(sfun);
-	set.AddFunction(list_element);
-
-	ScalarFunctionSet array_extract("array_extract");
-	array_extract.AddFunction(lfun);
-	array_extract.AddFunction(sfun);
-	array_extract.AddFunction(StructExtractFun::GetFunction());
-	set.AddFunction(array_extract);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct ListSortBindData : public FunctionData {
-	ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, const LogicalType &return_type_p,
-	                 const LogicalType &child_type_p, ClientContext &context_p);
-	~ListSortBindData() override;
-
-	OrderType order_type;
-	OrderByNullType null_order;
-	LogicalType return_type;
-	LogicalType child_type;
-
-	vector<LogicalType> types;
-	vector<LogicalType> payload_types;
-
-	ClientContext &context;
-	unique_ptr<GlobalSortState> global_sort_state;
-	RowLayout payload_layout;
-	vector<BoundOrderByNode> orders;
-
-public:
-	bool Equals(const FunctionData &other_p) const override;
-	unique_ptr<FunctionData> Copy() const override;
-};
-
-ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p,
-                                   const LogicalType &return_type_p, const LogicalType &child_type_p,
-                                   ClientContext &context_p)
-    : order_type(order_type_p), null_order(null_order_p), return_type(return_type_p), child_type(child_type_p),
-      context(context_p) {
-
-	// get the vector types
-	types.emplace_back(LogicalType::USMALLINT);
-	types.emplace_back(child_type);
-	D_ASSERT(types.size() == 2);
-
-	// get the payload types
-	payload_types.emplace_back(LogicalType::UINTEGER);
-	D_ASSERT(payload_types.size() == 1);
-
-	// initialize the payload layout
-	payload_layout.Initialize(payload_types);
-
-	// get the BoundOrderByNode
-	auto idx_col_expr = make_unique_base<Expression, BoundReferenceExpression>(LogicalType::USMALLINT, 0);
-	auto lists_col_expr = make_unique_base<Expression, BoundReferenceExpression>(child_type, 1);
-	orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, move(idx_col_expr));
-	orders.emplace_back(order_type, null_order, move(lists_col_expr));
-}
-
-unique_ptr<FunctionData> ListSortBindData::Copy() const {
-	return make_unique<ListSortBindData>(order_type, null_order, return_type, child_type, context);
-}
-
-bool ListSortBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (ListSortBindData &)other_p;
-	return order_type == other.order_type && null_order == other.null_order;
-}
-
-ListSortBindData::~ListSortBindData() {
-}
-
-// create the key_chunk and the payload_chunk and sink them into the local_sort_state
-void SinkDataChunk(Vector *child_vector, SelectionVector &sel, idx_t offset_lists_indices, vector<LogicalType> &types,
-                   vector<LogicalType> &payload_types, Vector &payload_vector, LocalSortState &local_sort_state,
-                   bool &data_to_sort, Vector &lists_indices) {
-
-	// slice the child vector
-	Vector slice(*child_vector, sel, offset_lists_indices);
-
-	// initialize and fill key_chunk
-	DataChunk key_chunk;
-	key_chunk.InitializeEmpty(types);
-	key_chunk.data[0].Reference(lists_indices);
-	key_chunk.data[1].Reference(slice);
-	key_chunk.SetCardinality(offset_lists_indices);
-
-	// initialize and fill key_chunk and payload_chunk
-	DataChunk payload_chunk;
-	payload_chunk.InitializeEmpty(payload_types);
-	payload_chunk.data[0].Reference(payload_vector);
-	payload_chunk.SetCardinality(offset_lists_indices);
-
-	// sink
-	local_sort_state.SinkChunk(key_chunk, payload_chunk);
-	data_to_sort = true;
-}
-
-static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() >= 1 && args.ColumnCount() <= 3);
-	auto count = args.size();
-	Vector &lists = args.data[0];
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto &result_validity = FlatVector::Validity(result);
-
-	if (lists.GetType().id() == LogicalTypeId::SQLNULL) {
-		result_validity.SetInvalid(0);
-		return;
-	}
-
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (ListSortBindData &)*func_expr.bind_info;
-
-	// initialize the global and local sorting state
-	auto &buffer_manager = BufferManager::GetBufferManager(info.context);
-	info.global_sort_state = make_unique<GlobalSortState>(buffer_manager, info.orders, info.payload_layout);
-	auto &global_sort_state = *info.global_sort_state;
-	LocalSortState local_sort_state;
-	local_sort_state.Initialize(global_sort_state, buffer_manager);
-
-	// get the child vector
-	auto lists_size = ListVector::GetListSize(lists);
-	auto &child_vector = ListVector::GetEntry(lists);
-	VectorData child_data;
-	child_vector.Orrify(lists_size, child_data);
-
-	// get the lists data
-	VectorData lists_data;
-	lists.Orrify(count, lists_data);
-	auto list_entries = (list_entry_t *)lists_data.data;
-
-	// create the lists_indices vector, this contains an element for each list's entry,
-	// the element corresponds to the list's index, e.g. for [1, 2, 4], [5, 4]
-	// lists_indices contains [0, 0, 0, 1, 1]
-	Vector lists_indices(LogicalType::USMALLINT);
-	auto lists_indices_data = FlatVector::GetData<uint16_t>(lists_indices);
-
-	// create the payload_vector, this is just a vector containing incrementing integers
-	// this will later be used as the 'new' selection vector of the child_vector, after
-	// rearranging the payload according to the sorting order
-	Vector payload_vector(LogicalType::UINTEGER);
-	auto payload_vector_data = FlatVector::GetData<uint32_t>(payload_vector);
-
-	// selection vector pointing to the data of the child vector,
-	// used for slicing the child_vector correctly
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-
-	idx_t offset_lists_indices = 0;
-	uint32_t incr_payload_count = 0;
-	bool data_to_sort = false;
-
-	for (idx_t i = 0; i < count; i++) {
-
-		auto lists_index = lists_data.sel->get_index(i);
-		const auto &list_entry = list_entries[lists_index];
-
-		// nothing to do for this list
-		if (!lists_data.validity.RowIsValid(lists_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-
-		// empty list, no sorting required
-		if (list_entry.length == 0) {
-			continue;
-		}
-
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-
-			// lists_indices vector is full, sink
-			if (offset_lists_indices == STANDARD_VECTOR_SIZE) {
-				SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
-				              local_sort_state, data_to_sort, lists_indices);
-				offset_lists_indices = 0;
-			}
-
-			auto source_idx = child_data.sel->get_index(list_entry.offset + child_idx);
-			sel.set_index(offset_lists_indices, source_idx);
-			lists_indices_data[offset_lists_indices] = (uint32_t)i;
-			payload_vector_data[offset_lists_indices] = incr_payload_count;
-			offset_lists_indices++;
-			incr_payload_count++;
-		}
-	}
-
-	if (offset_lists_indices != 0) {
-		SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
-		              local_sort_state, data_to_sort, lists_indices);
-	}
-
-	if (data_to_sort) {
-
-		// add local state to global state, which sorts the data
-		global_sort_state.AddLocalState(local_sort_state);
-		global_sort_state.PrepareMergePhase();
-
-		// selection vector that is to be filled with the 'sorted' payload
-		SelectionVector sel_sorted(incr_payload_count);
-		idx_t sel_sorted_idx = 0;
-
-		// scan the sorted row data
-		PayloadScanner scanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
-		for (;;) {
-			DataChunk result_chunk;
-			result_chunk.Initialize(Allocator::DefaultAllocator(), info.payload_types);
-			result_chunk.SetCardinality(0);
-			scanner.Scan(result_chunk);
-			if (result_chunk.size() == 0) {
-				break;
-			}
-
-			// construct the selection vector with the new order from the result vectors
-			Vector result_vector(result_chunk.data[0]);
-			auto result_data = FlatVector::GetData<uint32_t>(result_vector);
-			auto row_count = result_chunk.size();
-
-			for (idx_t i = 0; i < row_count; i++) {
-				sel_sorted.set_index(sel_sorted_idx, result_data[i]);
-				sel_sorted_idx++;
-			}
-		}
-
-		D_ASSERT(sel_sorted_idx == incr_payload_count);
-		child_vector.Slice(sel_sorted, sel_sorted_idx);
-		child_vector.Normalify(sel_sorted_idx);
-	}
-
-	result.Reference(lists);
-}
-
-static unique_ptr<FunctionData> ListSortBind(ClientContext &context, ScalarFunction &bound_function,
-                                             vector<unique_ptr<Expression>> &arguments, OrderType &order,
-                                             OrderByNullType &null_order) {
-	bound_function.arguments[0] = arguments[0]->return_type;
-	bound_function.return_type = arguments[0]->return_type;
-	auto child_type = ListType::GetChildType(arguments[0]->return_type);
-
-	return make_unique<ListSortBindData>(order, null_order, bound_function.return_type, child_type, context);
-}
-
-OrderByNullType GetNullOrder(vector<unique_ptr<Expression>> &arguments, idx_t idx) {
-
-	if (!arguments[idx]->IsFoldable()) {
-		throw InvalidInputException("Null sorting order must be a constant");
-	}
-	Value null_order_value = ExpressionExecutor::EvaluateScalar(*arguments[idx]);
-	auto null_order_name = null_order_value.ToString();
-	std::transform(null_order_name.begin(), null_order_name.end(), null_order_name.begin(), ::toupper);
-	if (null_order_name != "NULLS FIRST" && null_order_name != "NULLS LAST") {
-		throw InvalidInputException("Null sorting order must be either NULLS FIRST or NULLS LAST");
-	}
-
-	if (null_order_name == "NULLS LAST") {
-		return OrderByNullType::NULLS_LAST;
-	}
-	return OrderByNullType::NULLS_FIRST;
-}
-
-static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(bound_function.arguments.size() >= 1 && bound_function.arguments.size() <= 3);
-	D_ASSERT(arguments.size() >= 1 && arguments.size() <= 3);
-
-	// set default values
-	auto &config = DBConfig::GetConfig(context);
-	auto order = config.default_order_type;
-	auto null_order = config.default_null_order;
-
-	// get the sorting order
-	if (arguments.size() >= 2) {
-
-		if (!arguments[1]->IsFoldable()) {
-			throw InvalidInputException("Sorting order must be a constant");
-		}
-		Value order_value = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		auto order_name = order_value.ToString();
-		std::transform(order_name.begin(), order_name.end(), order_name.begin(), ::toupper);
-		if (order_name != "DESC" && order_name != "ASC") {
-			throw InvalidInputException("Sorting order must be either ASC or DESC");
-		}
-		if (order_name == "DESC") {
-			order = OrderType::DESCENDING;
-		} else {
-			order = OrderType::ASCENDING;
-		}
-	}
-
-	// get the null sorting order
-	if (arguments.size() == 3) {
-		null_order = GetNullOrder(arguments, 2);
-	}
-
-	return ListSortBind(context, bound_function, arguments, order, null_order);
-}
-
-static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, ScalarFunction &bound_function,
-                                                    vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(bound_function.arguments.size() == 1 || bound_function.arguments.size() == 2);
-	D_ASSERT(arguments.size() == 1 || arguments.size() == 2);
-
-	// set (reverse) default values
-	auto &config = DBConfig::GetConfig(context);
-	auto order = (config.default_order_type == OrderType::ASCENDING) ? OrderType::DESCENDING : OrderType::ASCENDING;
-	auto null_order = config.default_null_order;
-
-	// get the null sorting order
-	if (arguments.size() == 2) {
-		null_order = GetNullOrder(arguments, 1);
-	}
-
-	return ListSortBind(context, bound_function, arguments, order, null_order);
-}
-
-void ListSortFun::RegisterFunction(BuiltinFunctions &set) {
-
-	// normal sort
-
-	// one parameter: list
-	ScalarFunction sort({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY), ListSortFunction,
-	                    false, false, ListNormalSortBind);
-
-	// two parameters: list, order
-	ScalarFunction sort_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
-	                          LogicalType::LIST(LogicalType::ANY), ListSortFunction, false, false, ListNormalSortBind);
-
-	// three parameters: list, order, null order
-	ScalarFunction sort_orders({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                           LogicalType::LIST(LogicalType::ANY), ListSortFunction, false, false, ListNormalSortBind);
-
-	ScalarFunctionSet list_sort("list_sort");
-	list_sort.AddFunction(sort);
-	list_sort.AddFunction(sort_order);
-	list_sort.AddFunction(sort_orders);
-	set.AddFunction(list_sort);
-
-	ScalarFunctionSet array_sort("array_sort");
-	array_sort.AddFunction(sort);
-	array_sort.AddFunction(sort_order);
-	array_sort.AddFunction(sort_orders);
-	set.AddFunction(array_sort);
-
-	// reverse sort
-
-	// one parameter: list
-	ScalarFunction sort_reverse({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),
-	                            ListSortFunction, false, false, ListReverseSortBind);
-
-	// two parameters: list, null order
-	ScalarFunction sort_reverse_null_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
-	                                       LogicalType::LIST(LogicalType::ANY), ListSortFunction, false, false,
-	                                       ListReverseSortBind);
-
-	ScalarFunctionSet list_reverse_sort("list_reverse_sort");
-	list_reverse_sort.AddFunction(sort_reverse);
-	list_reverse_sort.AddFunction(sort_reverse_null_order);
-	set.AddFunction(list_reverse_sort);
-
-	ScalarFunctionSet array_reverse_sort("array_reverse_sort");
-	array_reverse_sort.AddFunction(sort_reverse);
-	array_reverse_sort.AddFunction(sort_reverse_null_order);
-	set.AddFunction(array_reverse_sort);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-	auto &child_type = ListType::GetChildType(result.GetType());
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-	}
-
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	for (idx_t i = 0; i < args.size(); i++) {
-		result_data[i].offset = ListVector::GetListSize(result);
-		for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-			auto val = args.GetValue(col_idx, i).CastAs(child_type);
-			ListVector::PushBack(result, val);
-		}
-		result_data[i].length = args.ColumnCount();
-	}
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
-	// collect names and deconflict, construct return type
-	LogicalType child_type = LogicalType::SQLNULL;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		child_type = LogicalType::MaxLogicalType(child_type, arguments[i]->return_type);
-	}
-
-	// this is more for completeness reasons
-	bound_function.varargs = child_type;
-	bound_function.return_type = LogicalType::LIST(move(child_type));
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	auto list_stats = make_unique<ListStatistics>(expr.return_type);
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		if (child_stats[i]) {
-			list_stats->child_stats->Merge(*child_stats[i]);
-		} else {
-			list_stats->child_stats.reset();
-			return move(list_stats);
-		}
-	}
-	return move(list_stats);
-}
-
-void ListValueFun::RegisterFunction(BuiltinFunctions &set) {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun("list_value", {}, LogicalTypeId::LIST, ListValueFunction, false, ListValueBind, nullptr,
-	                   ListValueStats);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-	fun.name = "list_pack";
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct NumericRangeInfo {
-	using TYPE = int64_t;
-	using INCREMENT_TYPE = int64_t;
-
-	static int64_t DefaultStart() {
-		return 0;
-	}
-	static int64_t DefaultIncrement() {
-		return 1;
-	}
-
-	static uint64_t ListLength(int64_t start_value, int64_t end_value, int64_t increment_value, bool inclusive_bound) {
-		if (increment_value == 0) {
-			return 0;
-		}
-		if (start_value > end_value && increment_value > 0) {
-			return 0;
-		}
-		if (start_value < end_value && increment_value < 0) {
-			return 0;
-		}
-		hugeint_t total_diff = AbsValue(hugeint_t(end_value) - hugeint_t(start_value));
-		hugeint_t increment = AbsValue(hugeint_t(increment_value));
-		hugeint_t total_values = total_diff / increment;
-		if (total_diff % increment == 0) {
-			if (inclusive_bound) {
-				total_values += 1;
-			}
-		} else {
-			total_values += 1;
-		}
-		if (total_values > NumericLimits<uint32_t>::Maximum()) {
-			throw InvalidInputException("Lists larger than 2^32 elements are not supported");
-		}
-		return Hugeint::Cast<uint64_t>(total_values);
-	}
-
-	static void Increment(int64_t &input, int64_t increment) {
-		input += increment;
-	}
-};
-struct TimestampRangeInfo {
-	using TYPE = timestamp_t;
-	using INCREMENT_TYPE = interval_t;
-
-	static timestamp_t DefaultStart() {
-		throw InternalException("Default start not implemented for timestamp range");
-	}
-	static interval_t DefaultIncrement() {
-		throw InternalException("Default increment not implemented for timestamp range");
-	}
-	static uint64_t ListLength(timestamp_t start_value, timestamp_t end_value, interval_t increment_value,
-	                           bool inclusive_bound) {
-		bool is_positive = increment_value.months > 0 || increment_value.days > 0 || increment_value.micros > 0;
-		bool is_negative = increment_value.months < 0 || increment_value.days < 0 || increment_value.micros < 0;
-		if (!is_negative && !is_positive) {
-			// interval is 0: no result
-			return 0;
-		}
-		// We don't allow infinite bounds because they generate errors or infinite loops
-		if (!Timestamp::IsFinite(start_value) || !Timestamp::IsFinite(end_value)) {
-			throw InvalidInputException("Interval infinite bounds not supported");
-		}
-
-		if (is_negative && is_positive) {
-			// we don't allow a mix of
-			throw InvalidInputException("Interval with mix of negative/positive entries not supported");
-		}
-		if (start_value > end_value && is_positive) {
-			return 0;
-		}
-		if (start_value < end_value && is_negative) {
-			return 0;
-		}
-		int64_t total_values = 0;
-		if (is_negative) {
-			// negative interval, start_value is going down
-			while (inclusive_bound ? start_value >= end_value : start_value > end_value) {
-				start_value = Interval::Add(start_value, increment_value);
-				total_values++;
-				if (total_values > NumericLimits<uint32_t>::Maximum()) {
-					throw InvalidInputException("Lists larger than 2^32 elements are not supported");
-				}
-			}
-		} else {
-			// positive interval, start_value is going up
-			while (inclusive_bound ? start_value <= end_value : start_value < end_value) {
-				start_value = Interval::Add(start_value, increment_value);
-				total_values++;
-				if (total_values > NumericLimits<uint32_t>::Maximum()) {
-					throw InvalidInputException("Lists larger than 2^32 elements are not supported");
-				}
-			}
-		}
-		return total_values;
-	}
-
-	static void Increment(timestamp_t &input, interval_t increment) {
-		input = Interval::Add(input, increment);
-	}
-};
-
-template <class OP, bool INCLUSIVE_BOUND>
-class RangeInfoStruct {
-public:
-	explicit RangeInfoStruct(DataChunk &args_p) : args(args_p) {
-		switch (args.ColumnCount()) {
-		case 1:
-			args.data[0].Orrify(args.size(), vdata[0]);
-			break;
-		case 2:
-			args.data[0].Orrify(args.size(), vdata[0]);
-			args.data[1].Orrify(args.size(), vdata[1]);
-			break;
-		case 3:
-			args.data[0].Orrify(args.size(), vdata[0]);
-			args.data[1].Orrify(args.size(), vdata[1]);
-			args.data[2].Orrify(args.size(), vdata[2]);
-			break;
-		default:
-			throw InternalException("Unsupported number of parameters for range");
-		}
-	}
-
-	bool RowIsValid(idx_t row_idx) {
-		for (idx_t i = 0; i < args.ColumnCount(); i++) {
-			auto idx = vdata[i].sel->get_index(row_idx);
-			if (!vdata[i].validity.RowIsValid(idx)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	typename OP::TYPE StartListValue(idx_t row_idx) {
-		if (args.ColumnCount() == 1) {
-			return OP::DefaultStart();
-		} else {
-			auto data = (typename OP::TYPE *)vdata[0].data;
-			auto idx = vdata[0].sel->get_index(row_idx);
-			return data[idx];
-		}
-	}
-
-	typename OP::TYPE EndListValue(idx_t row_idx) {
-		idx_t vdata_idx = args.ColumnCount() == 1 ? 0 : 1;
-		auto data = (typename OP::TYPE *)vdata[vdata_idx].data;
-		auto idx = vdata[vdata_idx].sel->get_index(row_idx);
-		return data[idx];
-	}
-
-	typename OP::INCREMENT_TYPE ListIncrementValue(idx_t row_idx) {
-		if (args.ColumnCount() < 3) {
-			return OP::DefaultIncrement();
-		} else {
-			auto data = (typename OP::INCREMENT_TYPE *)vdata[2].data;
-			auto idx = vdata[2].sel->get_index(row_idx);
-			return data[idx];
-		}
-	}
-
-	void GetListValues(idx_t row_idx, typename OP::TYPE &start_value, typename OP::TYPE &end_value,
-	                   typename OP::INCREMENT_TYPE &increment_value) {
-		start_value = StartListValue(row_idx);
-		end_value = EndListValue(row_idx);
-		increment_value = ListIncrementValue(row_idx);
-	}
-
-	uint64_t ListLength(idx_t row_idx) {
-		typename OP::TYPE start_value;
-		typename OP::TYPE end_value;
-		typename OP::INCREMENT_TYPE increment_value;
-		GetListValues(row_idx, start_value, end_value, increment_value);
-		return OP::ListLength(start_value, end_value, increment_value, INCLUSIVE_BOUND);
-	}
-
-private:
-	DataChunk &args;
-	VectorData vdata[3];
-};
-
-template <class OP, bool INCLUSIVE_BOUND>
-static void ListRangeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-	RangeInfoStruct<OP, INCLUSIVE_BOUND> info(args);
-	idx_t args_size = 1;
-	auto result_type = VectorType::CONSTANT_VECTOR;
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			args_size = args.size();
-			result_type = VectorType::FLAT_VECTOR;
-			break;
-		}
-	}
-	auto list_data = FlatVector::GetData<list_entry_t>(result);
-	auto &result_validity = FlatVector::Validity(result);
-	int64_t total_size = 0;
-	for (idx_t i = 0; i < args_size; i++) {
-		if (!info.RowIsValid(i)) {
-			result_validity.SetInvalid(i);
-			list_data[i].offset = total_size;
-			list_data[i].length = 0;
-		} else {
-			list_data[i].offset = total_size;
-			list_data[i].length = info.ListLength(i);
-			total_size += list_data[i].length;
-		}
-	}
-
-	// now construct the child vector of the list
-	ListVector::Reserve(result, total_size);
-	auto range_data = FlatVector::GetData<typename OP::TYPE>(ListVector::GetEntry(result));
-	idx_t total_idx = 0;
-	for (idx_t i = 0; i < args_size; i++) {
-		typename OP::TYPE start_value = info.StartListValue(i);
-		typename OP::INCREMENT_TYPE increment = info.ListIncrementValue(i);
-
-		typename OP::TYPE range_value = start_value;
-		for (idx_t range_idx = 0; range_idx < list_data[i].length; range_idx++) {
-			if (range_idx > 0) {
-				OP::Increment(range_value, increment);
-			}
-			range_data[total_idx++] = range_value;
-		}
-	}
-
-	ListVector::SetListSize(result, total_size);
-	result.SetVectorType(result_type);
-
-	result.Verify(args.size());
-}
-
-void ListRangeFun::RegisterFunction(BuiltinFunctions &set) {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunctionSet range_set("range");
-	range_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::LIST(LogicalType::BIGINT),
-	                                     ListRangeFunction<NumericRangeInfo, false>));
-	range_set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT},
-	                                     LogicalType::LIST(LogicalType::BIGINT),
-	                                     ListRangeFunction<NumericRangeInfo, false>));
-	range_set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                     LogicalType::LIST(LogicalType::BIGINT),
-	                                     ListRangeFunction<NumericRangeInfo, false>));
-	range_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
-	                                     LogicalType::LIST(LogicalType::TIMESTAMP),
-	                                     ListRangeFunction<TimestampRangeInfo, false>));
-	set.AddFunction(range_set);
-
-	ScalarFunctionSet generate_series("generate_series");
-	generate_series.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::LIST(LogicalType::BIGINT),
-	                                           ListRangeFunction<NumericRangeInfo, true>));
-	generate_series.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT},
-	                                           LogicalType::LIST(LogicalType::BIGINT),
-	                                           ListRangeFunction<NumericRangeInfo, true>));
-	generate_series.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                           LogicalType::LIST(LogicalType::BIGINT),
-	                                           ListRangeFunction<NumericRangeInfo, true>));
-	generate_series.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
-	                                           LogicalType::LIST(LogicalType::TIMESTAMP),
-	                                           ListRangeFunction<TimestampRangeInfo, true>));
-	set.AddFunction(generate_series);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-static void CardinalityFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &map = args.data[0];
-	VectorData list_data;
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<uint64_t>(result);
-
-	auto &children = StructVector::GetEntries(map);
-	children[0]->Orrify(args.size(), list_data);
-	for (idx_t row = 0; row < args.size(); row++) {
-		auto list_entry = ((list_entry_t *)list_data.data)[list_data.sel->get_index(row)];
-		result_data[row] = list_entry.length;
-	}
-
-	if (args.size() == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static unique_ptr<FunctionData> CardinalityBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-
-	if (arguments[0]->return_type.id() != LogicalTypeId::MAP) {
-		throw BinderException("Cardinality can only operate on MAPs");
-	}
-
-	bound_function.return_type = LogicalType::UBIGINT;
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-void CardinalityFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction fun("cardinality", {LogicalType::ANY}, LogicalType::UBIGINT, CardinalityFunction, false,
-	                   CardinalityBind);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-// TODO: this doesn't recursively verify maps if maps are nested
-MapInvalidReason CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel) {
-	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
-	VectorData map_vdata;
-	map.Orrify(count, map_vdata);
-	auto &map_validity = map_vdata.validity;
-
-	auto &key_vector = *(StructVector::GetEntries(map)[0]);
-	VectorData key_vdata;
-	key_vector.Orrify(count, key_vdata);
-	auto key_data = (list_entry_t *)key_vdata.data;
-	auto &key_validity = key_vdata.validity;
-
-	auto &key_entries = ListVector::GetEntry(key_vector);
-	VectorData key_entry_vdata;
-	key_entries.Orrify(count, key_entry_vdata);
-	auto &entry_validity = key_entry_vdata.validity;
-
-	for (idx_t row = 0; row < count; row++) {
-		auto mapped_row = sel.get_index(row);
-		auto row_idx = map_vdata.sel->get_index(mapped_row);
-		// map is allowed to be NULL
-		if (!map_validity.RowIsValid(row_idx)) {
-			continue;
-		}
-		row_idx = key_vdata.sel->get_index(row);
-		if (!key_validity.RowIsValid(row_idx)) {
-			return MapInvalidReason::NULL_KEY_LIST;
-		}
-		value_set_t unique_keys;
-		for (idx_t i = 0; i < key_data[row_idx].length; i++) {
-			auto index = key_data[row_idx].offset + i;
-			index = key_entry_vdata.sel->get_index(index);
-			if (!entry_validity.RowIsValid(index)) {
-				return MapInvalidReason::NULL_KEY;
-			}
-			auto value = key_entries.GetValue(index);
-			auto result = unique_keys.insert(value);
-			if (!result.second) {
-				return MapInvalidReason::DUPLICATE_KEY;
-			}
-		}
-	}
-	return MapInvalidReason::VALID;
-}
-
-static void MapConversionVerify(Vector &vector, idx_t count) {
-	auto valid_check = CheckMapValidity(vector, count);
-	switch (valid_check) {
-	case MapInvalidReason::VALID:
-		break;
-	case MapInvalidReason::DUPLICATE_KEY: {
-		throw InvalidInputException("Map keys have to be unique");
-	}
-	case MapInvalidReason::NULL_KEY: {
-		throw InvalidInputException("Map keys can not be NULL");
-	}
-	case MapInvalidReason::NULL_KEY_LIST: {
-		throw InvalidInputException("The list of map keys is not allowed to be NULL");
-	}
-	default: {
-		throw InternalException("MapInvalidReason not implemented");
-	}
-	}
-}
-
-static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
-
-	//! Otherwise if its not a constant vector, this breaks the optimizer
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-	}
-
-	auto &child_entries = StructVector::GetEntries(result);
-	D_ASSERT(child_entries.size() == 2);
-	auto &key_vector = *child_entries[0];
-	auto &value_vector = *child_entries[1];
-	if (args.data.empty()) {
-		// no arguments: construct an empty map
-		ListVector::SetListSize(key_vector, 0);
-		key_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto list_data = ConstantVector::GetData<list_entry_t>(key_vector);
-		list_data->offset = 0;
-		list_data->length = 0;
-
-		ListVector::SetListSize(value_vector, 0);
-		value_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		list_data = ConstantVector::GetData<list_entry_t>(value_vector);
-		list_data->offset = 0;
-		list_data->length = 0;
-
-		result.Verify(args.size());
-		return;
-	}
-
-	if (ListVector::GetListSize(args.data[0]) != ListVector::GetListSize(args.data[1])) {
-		throw Exception("Key list has a different size from Value list");
-	}
-
-	key_vector.Reference(args.data[0]);
-	value_vector.Reference(args.data[1]);
-	MapConversionVerify(result, args.size());
-
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> MapBind(ClientContext &context, ScalarFunction &bound_function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	child_list_t<LogicalType> child_types;
-
-	if (arguments.size() != 2 && !arguments.empty()) {
-		throw Exception("We need exactly two lists for a map");
-	}
-	if (arguments.size() == 2) {
-		if (arguments[0]->return_type.id() != LogicalTypeId::LIST) {
-			throw Exception("First argument is not a list");
-		}
-		if (arguments[1]->return_type.id() != LogicalTypeId::LIST) {
-			throw Exception("Second argument is not a list");
-		}
-		child_types.push_back(make_pair("key", arguments[0]->return_type));
-		child_types.push_back(make_pair("value", arguments[1]->return_type));
-	}
-
-	if (arguments.empty()) {
-		auto empty = LogicalType::LIST(LogicalTypeId::SQLNULL);
-		child_types.push_back(make_pair("key", empty));
-		child_types.push_back(make_pair("value", empty));
-	}
-
-	//! this is more for completeness reasons
-	bound_function.return_type = LogicalType::MAP(move(child_types));
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-void MapFun::RegisterFunction(BuiltinFunctions &set) {
-	//! the arguments and return types are actually set in the binder function
-	ScalarFunction fun("map", {}, LogicalTypeId::MAP, MapFunction, false, MapBind);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-void FillResult(Value &values, Vector &result, idx_t row) {
-	//! First Initialize List Vector
-	idx_t current_offset = ListVector::GetListSize(result);
-	//! Push Values to List Vector
-	auto &list_values = ListValue::GetChildren(values);
-	for (idx_t i = 0; i < list_values.size(); i++) {
-		ListVector::PushBack(result, list_values[i]);
-	}
-
-	//! now set the pointer
-	auto &entry = ((list_entry_t *)result.GetData())[row];
-	entry.length = list_values.size();
-	entry.offset = current_offset;
-}
-
-static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.data.size() == 2);
-	D_ASSERT(args.data[0].GetType().id() == LogicalTypeId::MAP);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	auto &map = args.data[0];
-	auto &key = args.data[1];
-
-	auto key_value = key.GetValue(0);
-	VectorData offset_data;
-
-	auto &children = StructVector::GetEntries(map);
-	children[0]->Orrify(args.size(), offset_data);
-	auto &key_type = ListType::GetChildType(children[0]->GetType());
-	if (key_type != LogicalTypeId::SQLNULL) {
-		key_value = key_value.CastAs(key_type);
-	}
-	for (idx_t row = 0; row < args.size(); row++) {
-		auto offsets = ListVector::Search(*children[0], key_value, offset_data.sel->get_index(row));
-		auto values = ListVector::GetValuesFromOffsets(*children[1], offsets);
-		FillResult(values, result, row);
-	}
-
-	if (args.size() == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> MapExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	if (arguments.size() != 2) {
-		throw BinderException("MAP_EXTRACT must have exactly two arguments");
-	}
-	if (arguments[0]->return_type.id() != LogicalTypeId::MAP) {
-		throw BinderException("MAP_EXTRACT can only operate on MAPs");
-	}
-	auto &child_types = StructType::GetChildTypes(arguments[0]->return_type);
-	auto &value_type = ListType::GetChildType(child_types[1].second);
-
-	//! Here we have to construct the List Type that will be returned
-	bound_function.return_type = LogicalType::LIST(value_type);
-	return make_unique<VariableReturnBindData>(value_type);
-}
-
-void MapExtractFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction fun("map_extract", {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, MapExtractFunction, false,
-	                   MapExtractBind);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-	fun.name = "element_at";
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-#include <cmath>
-#include <errno.h>
-
-namespace duckdb {
-
-template <class TR, class OP>
-static scalar_function_t GetScalarIntegerUnaryFunctionFixedReturn(const LogicalType &type) {
-	scalar_function_t function;
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		function = &ScalarFunction::UnaryFunction<int8_t, TR, OP>;
-		break;
-	case LogicalTypeId::SMALLINT:
-		function = &ScalarFunction::UnaryFunction<int16_t, TR, OP>;
-		break;
-	case LogicalTypeId::INTEGER:
-		function = &ScalarFunction::UnaryFunction<int32_t, TR, OP>;
-		break;
-	case LogicalTypeId::BIGINT:
-		function = &ScalarFunction::UnaryFunction<int64_t, TR, OP>;
-		break;
-	case LogicalTypeId::HUGEINT:
-		function = &ScalarFunction::UnaryFunction<hugeint_t, TR, OP>;
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarIntegerUnaryFunctionFixedReturn");
-	}
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// nextafter
-//===--------------------------------------------------------------------===//
-struct NextAfterOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA base, TB exponent) {
-		throw NotImplementedException("Unimplemented type for NextAfter Function");
-	}
-
-	template <class TA, class TB, class TR>
-	static inline double Operation(double input, double approximate_to) {
-		return nextafter(input, approximate_to);
-	}
-	template <class TA, class TB, class TR>
-	static inline float Operation(float input, float approximate_to) {
-		return nextafterf(input, approximate_to);
-	}
-};
-
-void NextAfterFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet next_after_fun("nextafter");
-	next_after_fun.AddFunction(
-	    ScalarFunction("nextafter", {LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                   ScalarFunction::BinaryFunction<double, double, double, NextAfterOperator>, false));
-	next_after_fun.AddFunction(ScalarFunction("nextafter", {LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT,
-	                                          ScalarFunction::BinaryFunction<float, float, float, NextAfterOperator>,
-	                                          false));
-	set.AddFunction(next_after_fun);
-}
-
-//===--------------------------------------------------------------------===//
-// abs
-//===--------------------------------------------------------------------===//
-static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 1);
-	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &lstats = (NumericStatistics &)*child_stats[0];
-	Value new_min, new_max;
-	bool potential_overflow = true;
-	if (!lstats.min.IsNull() && !lstats.max.IsNull()) {
-		switch (expr.return_type.InternalType()) {
-		case PhysicalType::INT8:
-			potential_overflow = lstats.min.GetValue<int8_t>() == NumericLimits<int8_t>::Minimum();
-			break;
-		case PhysicalType::INT16:
-			potential_overflow = lstats.min.GetValue<int16_t>() == NumericLimits<int16_t>::Minimum();
-			break;
-		case PhysicalType::INT32:
-			potential_overflow = lstats.min.GetValue<int32_t>() == NumericLimits<int32_t>::Minimum();
-			break;
-		case PhysicalType::INT64:
-			potential_overflow = lstats.min.GetValue<int64_t>() == NumericLimits<int64_t>::Minimum();
-			break;
-		default:
-			return nullptr;
-		}
-	}
-	if (potential_overflow) {
-		new_min = Value(expr.return_type);
-		new_max = Value(expr.return_type);
-	} else {
-		// no potential overflow
-
-		// compute stats
-		auto current_min = lstats.min.GetValue<int64_t>();
-		auto current_max = lstats.max.GetValue<int64_t>();
-
-		int64_t min_val, max_val;
-
-		if (current_min < 0 && current_max < 0) {
-			// if both min and max are below zero, then min=abs(cur_max) and max=abs(cur_min)
-			min_val = AbsValue(current_max);
-			max_val = AbsValue(current_min);
-		} else if (current_min < 0) {
-			D_ASSERT(current_max >= 0);
-			// if min is below zero and max is above 0, then min=0 and max=max(cur_max, abs(cur_min))
-			min_val = 0;
-			max_val = MaxValue(AbsValue(current_min), current_max);
-		} else {
-			// if both current_min and current_max are > 0, then the abs is a no-op and can be removed entirely
-			*input.expr_ptr = move(input.expr.children[0]);
-			return move(child_stats[0]);
-		}
-		new_min = Value::Numeric(expr.return_type, min_val);
-		new_max = Value::Numeric(expr.return_type, max_val);
-		expr.function.function = ScalarFunction::GetScalarUnaryFunction<AbsOperator>(expr.return_type);
-	}
-	auto stats =
-	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
-	stats->validity_stats = lstats.validity_stats->Copy();
-	return move(stats);
-}
-
-template <class OP>
-unique_ptr<FunctionData> DecimalUnaryOpBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	auto decimal_type = arguments[0]->return_type;
-	switch (decimal_type.InternalType()) {
-	case PhysicalType::INT16:
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<OP>(LogicalTypeId::SMALLINT);
-		break;
-	case PhysicalType::INT32:
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<OP>(LogicalTypeId::INTEGER);
-		break;
-	case PhysicalType::INT64:
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<OP>(LogicalTypeId::BIGINT);
-		break;
-	default:
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<OP>(LogicalTypeId::HUGEINT);
-		break;
-	}
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = decimal_type;
-	return nullptr;
-}
-
-void AbsFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet abs("abs");
-	for (auto &type : LogicalType::Numeric()) {
-		switch (type.id()) {
-		case LogicalTypeId::DECIMAL:
-			abs.AddFunction(ScalarFunction({type}, type, nullptr, false, false, DecimalUnaryOpBind<AbsOperator>));
-			break;
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT: {
-			ScalarFunction func({type}, type, ScalarFunction::GetScalarUnaryFunction<TryAbsOperator>(type));
-			func.statistics = PropagateAbsStats;
-			abs.AddFunction(func);
-			break;
-		}
-		case LogicalTypeId::UTINYINT:
-		case LogicalTypeId::USMALLINT:
-		case LogicalTypeId::UINTEGER:
-		case LogicalTypeId::UBIGINT:
-			abs.AddFunction(ScalarFunction({type}, type, ScalarFunction::NopFunction));
-			break;
-		default:
-			abs.AddFunction(ScalarFunction({type}, type, ScalarFunction::GetScalarUnaryFunction<AbsOperator>(type)));
-			break;
-		}
-	}
-	set.AddFunction(abs);
-	abs.name = "@";
-	set.AddFunction(abs);
-}
-
-//===--------------------------------------------------------------------===//
-// bit_count
-//===--------------------------------------------------------------------===//
-struct BitCntOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		using TU = typename std::make_unsigned<TA>::type;
-		TR count = 0;
-		for (auto value = TU(input); value > 0; value >>= 1) {
-			count += TR(value & 1);
-		}
-		return count;
-	}
-};
-
-void BitCountFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("bit_count");
-	functions.AddFunction(ScalarFunction({LogicalType::TINYINT}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<int8_t, int8_t, BitCntOperator>));
-	functions.AddFunction(ScalarFunction({LogicalType::SMALLINT}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<int16_t, int8_t, BitCntOperator>));
-	functions.AddFunction(ScalarFunction({LogicalType::INTEGER}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<int32_t, int8_t, BitCntOperator>));
-	functions.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TINYINT,
-	                                     ScalarFunction::UnaryFunction<int64_t, int8_t, BitCntOperator>));
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// sign
-//===--------------------------------------------------------------------===//
-struct SignOperator {
-	template <class TA, class TR>
-	static TR Operation(TA input) {
-		if (input == TA(0)) {
-			return 0;
-		} else if (input > TA(0)) {
-			return 1;
-		} else {
-			return -1;
-		}
-	}
-};
-
-template <>
-int8_t SignOperator::Operation(float input) {
-	if (input == 0 || Value::IsNan(input)) {
-		return 0;
-	} else if (input > 0) {
-		return 1;
-	} else {
-		return -1;
-	}
-}
-
-template <>
-int8_t SignOperator::Operation(double input) {
-	if (input == 0 || Value::IsNan(input)) {
-		return 0;
-	} else if (input > 0) {
-		return 1;
-	} else {
-		return -1;
-	}
-}
-
-void SignFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet sign("sign");
-	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			continue;
-		} else {
-			sign.AddFunction(
-			    ScalarFunction({type}, LogicalType::TINYINT,
-			                   ScalarFunction::GetScalarUnaryFunctionFixedReturn<int8_t, SignOperator>(type)));
-		}
-	}
-	set.AddFunction(sign);
-}
-
-//===--------------------------------------------------------------------===//
-// ceil
-//===--------------------------------------------------------------------===//
-struct CeilOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::ceil(left);
-	}
-};
-
-template <class T, class POWERS_OF_TEN, class OP>
-static void GenericRoundFunctionDecimal(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	OP::template Operation<T, POWERS_OF_TEN>(input, DecimalType::GetScale(func_expr.children[0]->return_type), result);
-}
-
-template <class OP>
-unique_ptr<FunctionData> BindGenericRoundFunctionDecimal(ClientContext &context, ScalarFunction &bound_function,
-                                                         vector<unique_ptr<Expression>> &arguments) {
-	// ceil essentially removes the scale
-	auto &decimal_type = arguments[0]->return_type;
-	auto scale = DecimalType::GetScale(decimal_type);
-	auto width = DecimalType::GetWidth(decimal_type);
-	if (scale == 0) {
-		bound_function.function = ScalarFunction::NopFunction;
-	} else {
-		switch (decimal_type.InternalType()) {
-		case PhysicalType::INT16:
-			bound_function.function = GenericRoundFunctionDecimal<int16_t, NumericHelper, OP>;
-			break;
-		case PhysicalType::INT32:
-			bound_function.function = GenericRoundFunctionDecimal<int32_t, NumericHelper, OP>;
-			break;
-		case PhysicalType::INT64:
-			bound_function.function = GenericRoundFunctionDecimal<int64_t, NumericHelper, OP>;
-			break;
-		default:
-			bound_function.function = GenericRoundFunctionDecimal<hugeint_t, Hugeint, OP>;
-			break;
-		}
-	}
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = LogicalType::DECIMAL(width, 0);
-	return nullptr;
-}
-
-struct CeilDecimalOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input < 0) {
-				// below 0 we floor the number (e.g. -10.5 -> -10)
-				return input / power_of_ten;
-			} else {
-				// above 0 we ceil the number
-				return ((input - 1) / power_of_ten) + 1;
-			}
-		});
-	}
-};
-
-void CeilFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet ceil("ceil");
-	for (auto &type : LogicalType::Numeric()) {
-		scalar_function_t func = nullptr;
-		bind_scalar_function_t bind_func = nullptr;
-		if (type.IsIntegral()) {
-			// no ceil for integral numbers
-			continue;
-		}
-		switch (type.id()) {
-		case LogicalTypeId::FLOAT:
-			func = ScalarFunction::UnaryFunction<float, float, CeilOperator>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			func = ScalarFunction::UnaryFunction<double, double, CeilOperator>;
-			break;
-		case LogicalTypeId::DECIMAL:
-			bind_func = BindGenericRoundFunctionDecimal<CeilDecimalOperator>;
-			break;
-		default:
-			throw InternalException("Unimplemented numeric type for function \"ceil\"");
-		}
-		ceil.AddFunction(ScalarFunction({type}, type, func, false, false, bind_func));
-	}
-
-	set.AddFunction(ceil);
-	ceil.name = "ceiling";
-	set.AddFunction(ceil);
-}
-
-//===--------------------------------------------------------------------===//
-// floor
-//===--------------------------------------------------------------------===//
-struct FloorOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::floor(left);
-	}
-};
-
-struct FloorDecimalOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input < 0) {
-				// below 0 we ceil the number (e.g. -10.5 -> -11)
-				return ((input + 1) / power_of_ten) - 1;
-			} else {
-				// above 0 we floor the number
-				return input / power_of_ten;
-			}
-		});
-	}
-};
-
-void FloorFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet floor("floor");
-	for (auto &type : LogicalType::Numeric()) {
-		scalar_function_t func = nullptr;
-		bind_scalar_function_t bind_func = nullptr;
-		if (type.IsIntegral()) {
-			// no floor for integral numbers
-			continue;
-		}
-		switch (type.id()) {
-		case LogicalTypeId::FLOAT:
-			func = ScalarFunction::UnaryFunction<float, float, FloorOperator>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			func = ScalarFunction::UnaryFunction<double, double, FloorOperator>;
-			break;
-		case LogicalTypeId::DECIMAL:
-			bind_func = BindGenericRoundFunctionDecimal<FloorDecimalOperator>;
-			break;
-		default:
-			throw InternalException("Unimplemented numeric type for function \"floor\"");
-		}
-		floor.AddFunction(ScalarFunction({type}, type, func, false, false, bind_func));
-	}
-	set.AddFunction(floor);
-}
-
-//===--------------------------------------------------------------------===//
-// round
-//===--------------------------------------------------------------------===//
-struct RoundOperatorPrecision {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB precision) {
-		double rounded_value;
-		if (precision < 0) {
-			double modifier = std::pow(10, -precision);
-			rounded_value = (std::round(input / modifier)) * modifier;
-			if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
-				return 0;
-			}
-		} else {
-			double modifier = std::pow(10, precision);
-			rounded_value = (std::round(input * modifier)) / modifier;
-			if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
-				return input;
-			}
-		}
-		return rounded_value;
-	}
-};
-
-struct RoundOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		double rounded_value = round(input);
-		if (std::isinf(rounded_value) || std::isnan(rounded_value)) {
-			return input;
-		}
-		return rounded_value;
-	}
-};
-
-struct RoundDecimalOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
-		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
-		T addition = power_of_ten / 2;
-		// regular round rounds towards the nearest number
-		// in case of a tie we round away from zero
-		// i.e. -10.5 -> -11, 10.5 -> 11
-		// we implement this by adding (positive) or subtracting (negative) 0.5
-		// and then flooring the number
-		// e.g. 10.5 + 0.5 = 11, floor(11) = 11
-		//      10.4 + 0.5 = 10.9, floor(10.9) = 10
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input < 0) {
-				input -= addition;
-			} else {
-				input += addition;
-			}
-			return input / power_of_ten;
-		});
-	}
-};
-
-struct RoundPrecisionFunctionData : public FunctionData {
-	explicit RoundPrecisionFunctionData(int32_t target_scale) : target_scale(target_scale) {
-	}
-
-	int32_t target_scale;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<RoundPrecisionFunctionData>(target_scale);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const RoundPrecisionFunctionData &)other_p;
-		return target_scale == other.target_scale;
-	}
-};
-
-template <class T, class POWERS_OF_TEN_CLASS>
-static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RoundPrecisionFunctionData &)*func_expr.bind_info;
-	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
-	if (-info.target_scale >= width) {
-		// scale too big for width
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		result.SetValue(0, Value::INTEGER(0));
-		return;
-	}
-	T divide_power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale];
-	T multiply_power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale];
-	T addition = divide_power_of_ten / 2;
-
-	UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-		if (input < 0) {
-			input -= addition;
-		} else {
-			input += addition;
-		}
-		return input / divide_power_of_ten * multiply_power_of_ten;
-	});
-}
-
-template <class T, class POWERS_OF_TEN_CLASS>
-static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RoundPrecisionFunctionData &)*func_expr.bind_info;
-	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-	T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale];
-	T addition = power_of_ten / 2;
-	UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-		if (input < 0) {
-			input -= addition;
-		} else {
-			input += addition;
-		}
-		return input / power_of_ten;
-	});
-}
-
-unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-	auto &decimal_type = arguments[0]->return_type;
-	if (!arguments[1]->IsFoldable()) {
-		throw NotImplementedException("ROUND(DECIMAL, INTEGER) with non-constant precision is not supported");
-	}
-	Value val = ExpressionExecutor::EvaluateScalar(*arguments[1]).CastAs(LogicalType::INTEGER);
-	if (val.IsNull()) {
-		throw NotImplementedException("ROUND(DECIMAL, INTEGER) with non-constant precision is not supported");
-	}
-	// our new precision becomes the round value
-	// e.g. ROUND(DECIMAL(18,3), 1) -> DECIMAL(18,1)
-	// but ONLY if the round value is positive
-	// if it is negative the scale becomes zero
-	// i.e. ROUND(DECIMAL(18,3), -1) -> DECIMAL(18,0)
-	int32_t round_value = IntegerValue::Get(val);
-	uint8_t target_scale;
-	auto width = DecimalType::GetWidth(decimal_type);
-	auto scale = DecimalType::GetScale(decimal_type);
-	if (round_value < 0) {
-		target_scale = 0;
-		switch (decimal_type.InternalType()) {
-		case PhysicalType::INT16:
-			bound_function.function = DecimalRoundNegativePrecisionFunction<int16_t, NumericHelper>;
-			break;
-		case PhysicalType::INT32:
-			bound_function.function = DecimalRoundNegativePrecisionFunction<int32_t, NumericHelper>;
-			break;
-		case PhysicalType::INT64:
-			bound_function.function = DecimalRoundNegativePrecisionFunction<int64_t, NumericHelper>;
-			break;
-		default:
-			bound_function.function = DecimalRoundNegativePrecisionFunction<hugeint_t, Hugeint>;
-			break;
-		}
-	} else {
-		if (round_value >= (int32_t)scale) {
-			// if round_value is bigger than or equal to scale we do nothing
-			bound_function.function = ScalarFunction::NopFunction;
-			target_scale = scale;
-		} else {
-			target_scale = round_value;
-			switch (decimal_type.InternalType()) {
-			case PhysicalType::INT16:
-				bound_function.function = DecimalRoundPositivePrecisionFunction<int16_t, NumericHelper>;
-				break;
-			case PhysicalType::INT32:
-				bound_function.function = DecimalRoundPositivePrecisionFunction<int32_t, NumericHelper>;
-				break;
-			case PhysicalType::INT64:
-				bound_function.function = DecimalRoundPositivePrecisionFunction<int64_t, NumericHelper>;
-				break;
-			default:
-				bound_function.function = DecimalRoundPositivePrecisionFunction<hugeint_t, Hugeint>;
-				break;
-			}
-		}
-	}
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = LogicalType::DECIMAL(width, target_scale);
-	return make_unique<RoundPrecisionFunctionData>(round_value);
-}
-
-void RoundFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet round("round");
-	for (auto &type : LogicalType::Numeric()) {
-		scalar_function_t round_prec_func = nullptr;
-		scalar_function_t round_func = nullptr;
-		bind_scalar_function_t bind_func = nullptr;
-		bind_scalar_function_t bind_prec_func = nullptr;
-		if (type.IsIntegral()) {
-			// no round for integral numbers
-			continue;
-		}
-		switch (type.id()) {
-		case LogicalTypeId::FLOAT:
-			round_func = ScalarFunction::UnaryFunction<float, float, RoundOperator>;
-			round_prec_func = ScalarFunction::BinaryFunction<float, int32_t, float, RoundOperatorPrecision>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			round_func = ScalarFunction::UnaryFunction<double, double, RoundOperator>;
-			round_prec_func = ScalarFunction::BinaryFunction<double, int32_t, double, RoundOperatorPrecision>;
-			break;
-		case LogicalTypeId::DECIMAL:
-			bind_func = BindGenericRoundFunctionDecimal<RoundDecimalOperator>;
-			bind_prec_func = BindDecimalRoundPrecision;
-			break;
-		default:
-			throw InternalException("Unimplemented numeric type for function \"floor\"");
-		}
-		round.AddFunction(ScalarFunction({type}, type, round_func, false, false, bind_func));
-		round.AddFunction(
-		    ScalarFunction({type, LogicalType::INTEGER}, type, round_prec_func, false, false, bind_prec_func));
-	}
-	set.AddFunction(round);
-}
-
-//===--------------------------------------------------------------------===//
-// exp
-//===--------------------------------------------------------------------===//
-struct ExpOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::exp(left);
-	}
-};
-
-void ExpFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("exp", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, ExpOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// pow
-//===--------------------------------------------------------------------===//
-struct PowOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA base, TB exponent) {
-		return std::pow(base, exponent);
-	}
-};
-
-void PowFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction power_function("pow", {LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                              ScalarFunction::BinaryFunction<double, double, double, PowOperator>);
-	set.AddFunction(power_function);
-	power_function.name = "power";
-	set.AddFunction(power_function);
-	power_function.name = "**";
-	set.AddFunction(power_function);
-	power_function.name = "^";
-	set.AddFunction(power_function);
-}
-
-//===--------------------------------------------------------------------===//
-// sqrt
-//===--------------------------------------------------------------------===//
-struct SqrtOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < 0) {
-			throw OutOfRangeException("cannot take square root of a negative number");
-		}
-		return std::sqrt(input);
-	}
-};
-
-void SqrtFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("sqrt", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, SqrtOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// cbrt
-//===--------------------------------------------------------------------===//
-struct CbRtOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::cbrt(left);
-	}
-};
-
-void CbrtFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("cbrt", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, CbRtOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// ln
-//===--------------------------------------------------------------------===//
-
-struct LnOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < 0) {
-			throw OutOfRangeException("cannot take logarithm of a negative number");
-		}
-		if (input == 0) {
-			throw OutOfRangeException("cannot take logarithm of zero");
-		}
-		return std::log(input);
-	}
-};
-
-void LnFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("ln", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, LnOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// log
-//===--------------------------------------------------------------------===//
-struct Log10Operator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < 0) {
-			throw OutOfRangeException("cannot take logarithm of a negative number");
-		}
-		if (input == 0) {
-			throw OutOfRangeException("cannot take logarithm of zero");
-		}
-		return std::log10(input);
-	}
-};
-
-void Log10Fun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"log10", "log"}, ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                                                 ScalarFunction::UnaryFunction<double, double, Log10Operator>));
-}
-
-//===--------------------------------------------------------------------===//
-// log2
-//===--------------------------------------------------------------------===//
-struct Log2Operator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < 0) {
-			throw OutOfRangeException("cannot take logarithm of a negative number");
-		}
-		if (input == 0) {
-			throw OutOfRangeException("cannot take logarithm of zero");
-		}
-		return std::log2(input);
-	}
-};
-
-void Log2Fun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("log2", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, Log2Operator>));
-}
-
-//===--------------------------------------------------------------------===//
-// pi
-//===--------------------------------------------------------------------===//
-static void PiFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 0);
-	Value pi_value = Value::DOUBLE(PI);
-	result.Reference(pi_value);
-}
-
-void PiFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("pi", {}, LogicalType::DOUBLE, PiFunction));
-}
-
-//===--------------------------------------------------------------------===//
-// degrees
-//===--------------------------------------------------------------------===//
-struct DegreesOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return left * (180 / PI);
-	}
-};
-
-void DegreesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("degrees", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, DegreesOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// radians
-//===--------------------------------------------------------------------===//
-struct RadiansOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return left * (PI / 180);
-	}
-};
-
-void RadiansFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("radians", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, RadiansOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// isnan
-//===--------------------------------------------------------------------===//
-struct IsNanOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Value::IsNan(input);
-	}
-};
-
-void IsNanFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet funcs("isnan");
-	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<float, bool, IsNanOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<double, bool, IsNanOperator>));
-	set.AddFunction(funcs);
-}
-
-//===--------------------------------------------------------------------===//
-// isinf
-//===--------------------------------------------------------------------===//
-struct IsInfiniteOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return !Value::IsNan(input) && !Value::IsFinite(input);
-	}
-};
-
-template <>
-bool IsInfiniteOperator::Operation(date_t input) {
-	return !Value::IsFinite(input);
-}
-
-template <>
-bool IsInfiniteOperator::Operation(timestamp_t input) {
-	return !Value::IsFinite(input);
-}
-
-void IsInfiniteFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet funcs("isinf");
-	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<float, bool, IsInfiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<double, bool, IsInfiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<date_t, bool, IsInfiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsInfiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsInfiniteOperator>));
-	set.AddFunction(funcs);
-}
-
-//===--------------------------------------------------------------------===//
-// isfinite
-//===--------------------------------------------------------------------===//
-struct IsFiniteOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return Value::IsFinite(input);
-	}
-};
-
-void IsFiniteFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet funcs("isfinite");
-	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<float, bool, IsFiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<double, bool, IsFiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<date_t, bool, IsFiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsFiniteOperator>));
-	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN,
-	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsFiniteOperator>));
-	set.AddFunction(funcs);
-}
-
-//===--------------------------------------------------------------------===//
-// sin
-//===--------------------------------------------------------------------===//
-template <class OP>
-struct NoInfiniteDoubleWrapper {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		if (DUCKDB_UNLIKELY(!Value::IsFinite(input))) {
-			if (Value::IsNan(input)) {
-				return input;
-			}
-			throw OutOfRangeException("input value %lf is out of range for numeric function", input);
-		}
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input);
-	}
-};
-
-struct SinOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return std::sin(input);
-	}
-};
-
-void SinFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("sin", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<SinOperator>>));
-}
-
-//===--------------------------------------------------------------------===//
-// cos
-//===--------------------------------------------------------------------===//
-struct CosOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::cos(input);
-	}
-};
-
-void CosFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("cos", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<CosOperator>>));
-}
-
-//===--------------------------------------------------------------------===//
-// tan
-//===--------------------------------------------------------------------===//
-struct TanOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::tan(input);
-	}
-};
-
-void TanFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("tan", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<TanOperator>>));
-}
-
-//===--------------------------------------------------------------------===//
-// asin
-//===--------------------------------------------------------------------===//
-struct ASinOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input < -1 || input > 1) {
-			throw Exception("ASIN is undefined outside [-1,1]");
-		}
-		return (double)std::asin(input);
-	}
-};
-
-void AsinFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("asin", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<ASinOperator>>));
-}
-
-//===--------------------------------------------------------------------===//
-// atan
-//===--------------------------------------------------------------------===//
-struct ATanOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::atan(input);
-	}
-};
-
-void AtanFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("atan", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, ATanOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// atan2
-//===--------------------------------------------------------------------===//
-struct ATan2 {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return (double)std::atan2(left, right);
-	}
-};
-
-void Atan2Fun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("atan2", {LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::BinaryFunction<double, double, double, ATan2>));
-}
-
-//===--------------------------------------------------------------------===//
-// acos
-//===--------------------------------------------------------------------===//
-struct ACos {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return (double)std::acos(input);
-	}
-};
-
-void AcosFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("acos", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<ACos>>));
-}
-
-//===--------------------------------------------------------------------===//
-// cot
-//===--------------------------------------------------------------------===//
-struct CotOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return 1.0 / (double)std::tan(input);
-	}
-};
-
-void CotFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("cot", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<CotOperator>>));
-}
-
-//===--------------------------------------------------------------------===//
-// gamma
-//===--------------------------------------------------------------------===//
-struct GammaOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input == 0) {
-			throw OutOfRangeException("cannot take gamma of zero");
-		}
-		return std::tgamma(input);
-	}
-};
-
-void GammaFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("gamma", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, GammaOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// gamma
-//===--------------------------------------------------------------------===//
-struct LogGammaOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		if (input == 0) {
-			throw OutOfRangeException("cannot take log gamma of zero");
-		}
-		return std::lgamma(input);
-	}
-};
-
-void LogGammaFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("lgamma", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, LogGammaOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// factorial(), !
-//===--------------------------------------------------------------------===//
-
-struct FactorialOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		TR ret = 1;
-		for (TA i = 2; i <= left; i++) {
-			ret *= i;
-		}
-		return ret;
-	}
-};
-
-void FactorialFun::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction({LogicalType::INTEGER}, LogicalType::HUGEINT,
-	                          ScalarFunction::UnaryFunction<int32_t, hugeint_t, FactorialOperator>);
-
-	set.AddFunction({"factorial", "!__postfix"}, fun);
-}
-
-//===--------------------------------------------------------------------===//
-// even
-//===--------------------------------------------------------------------===//
-struct EvenOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		double value;
-		if (left >= 0) {
-			value = std::ceil(left);
-		} else {
-			value = std::ceil(-left);
-			value = -value;
-		}
-		if (std::floor(value / 2) * 2 != value) {
-			if (left >= 0) {
-				return value += 1;
-			}
-			return value -= 1;
-		}
-		return value;
-	}
-};
-
-void EvenFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("even", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               ScalarFunction::UnaryFunction<double, double, EvenOperator>));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct RandomBindData : public FunctionData {
-	ClientContext &context;
-
-	explicit RandomBindData(ClientContext &context) : context(context) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<RandomBindData>(context);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		return true;
-	}
-};
-
-struct RandomLocalState : public FunctionLocalState {
-	explicit RandomLocalState(uint32_t seed) : random_engine(seed) {
-	}
-
-	RandomEngine random_engine;
-};
-
-static void RandomFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = (RandomLocalState &)*ExecuteFunctionState::GetFunctionState(state);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<double>(result);
-	for (idx_t i = 0; i < args.size(); i++) {
-		result_data[i] = lstate.random_engine.NextRandom();
-	}
-}
-
-unique_ptr<FunctionData> RandomBind(ClientContext &context, ScalarFunction &bound_function,
-                                    vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<RandomBindData>(context);
-}
-
-static unique_ptr<FunctionLocalState> RandomInitLocalState(const BoundFunctionExpression &expr,
-                                                           FunctionData *bind_data) {
-	auto &info = (RandomBindData &)*bind_data;
-	auto &random_engine = RandomEngine::Get(info.context);
-	return make_unique<RandomLocalState>(random_engine.NextRandomInteger());
-}
-
-void RandomFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("random", {}, LogicalType::DOUBLE, RandomFunction, true, RandomBind, nullptr,
-	                               nullptr, RandomInitLocalState));
-}
-
-static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = (RandomLocalState &)*ExecuteFunctionState::GetFunctionState(state);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<hugeint_t>(result);
-
-	for (idx_t i = 0; i < args.size(); i++) {
-		result_data[i] = UUID::GenerateRandomUUID(lstate.random_engine);
-	}
-}
-
-void UUIDFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, false, true, RandomBind, nullptr, nullptr,
-	                             RandomInitLocalState);
-	// generate a random uuid
-	set.AddFunction({"uuid", "gen_random_uuid"}, uuid_function);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct SetseedBindData : public FunctionData {
-	//! The client context for the function call
-	ClientContext &context;
-
-	explicit SetseedBindData(ClientContext &context) : context(context) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<SetseedBindData>(context);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		return true;
-	}
-};
-
-static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (SetseedBindData &)*func_expr.bind_info;
-	auto &input = args.data[0];
-	input.Normalify(args.size());
-
-	auto input_seeds = FlatVector::GetData<double>(input);
-	uint32_t half_max = NumericLimits<uint32_t>::Maximum() / 2;
-
-	auto &random_engine = RandomEngine::Get(info.context);
-	for (idx_t i = 0; i < args.size(); i++) {
-		if (input_seeds[i] < -1.0 || input_seeds[i] > 1.0) {
-			throw Exception("SETSEED accepts seed values between -1.0 and 1.0, inclusive");
-		}
-		uint32_t norm_seed = (input_seeds[i] + 1.0) * half_max;
-		random_engine.SetSeed(norm_seed);
-	}
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	ConstantVector::SetNull(result, true);
-}
-
-unique_ptr<FunctionData> SetSeedBind(ClientContext &context, ScalarFunction &bound_function,
-                                     vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<SetseedBindData>(context);
-}
-
-void SetseedFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("setseed", {LogicalType::DOUBLE}, LogicalType::SQLNULL, SetSeedFunction, true, SetSeedBind));
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterMathFunctions() {
-	Register<AbsFun>();
-	Register<SignFun>();
-
-	Register<CeilFun>();
-	Register<FloorFun>();
-	Register<RoundFun>();
-
-	Register<DegreesFun>();
-	Register<RadiansFun>();
-
-	Register<CbrtFun>();
-	Register<ExpFun>();
-	Register<Log2Fun>();
-	Register<Log10Fun>();
-	Register<LnFun>();
-	Register<PowFun>();
-	Register<RandomFun>();
-	Register<SetseedFun>();
-	Register<SqrtFun>();
-
-	Register<PiFun>();
-
-	Register<BitCountFun>();
-
-	Register<GammaFun>();
-	Register<LogGammaFun>();
-
-	Register<FactorialFun>();
-
-	Register<NextAfterFun>();
-
-	Register<EvenFun>();
-
-	Register<IsNanFun>();
-	Register<IsInfiniteFun>();
-	Register<IsFiniteFun>();
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterNestedFunctions() {
-	Register<ArraySliceFun>();
-	Register<StructPackFun>();
-	Register<StructExtractFun>();
-	Register<StructInsertFun>();
-	Register<ListConcatFun>();
-	Register<ListContainsFun>();
-	Register<ListPositionFun>();
-	Register<ListAggregateFun>();
-	Register<ListDistinctFun>();
-	Register<ListUniqueFun>();
-	Register<ListValueFun>();
-	Register<ListExtractFun>();
-	Register<ListSortFun>();
-	Register<ListRangeFun>();
-	Register<ListFlattenFun>();
-	Register<MapFun>();
-	Register<MapExtractFun>();
-	Register<CardinalityFun>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-#include <limits>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// + [add]
-//===--------------------------------------------------------------------===//
-template <>
-float AddOperator::Operation(float left, float right) {
-	auto result = left + right;
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in addition of float!");
-	}
-	return result;
-}
-
-template <>
-double AddOperator::Operation(double left, double right) {
-	auto result = left + right;
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in addition of double!");
-	}
-	return result;
-}
-
-template <>
-interval_t AddOperator::Operation(interval_t left, interval_t right) {
-	left.months = AddOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(left.months, right.months);
-	left.days = AddOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(left.days, right.days);
-	left.micros = AddOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(left.micros, right.micros);
-	return left;
-}
-
-template <>
-date_t AddOperator::Operation(date_t left, int32_t right) {
-	if (!Value::IsFinite(left)) {
-		return left;
-	}
-	int32_t days;
-	if (!TryAddOperator::Operation(left.days, right, days)) {
-		throw OutOfRangeException("Date out of range");
-	}
-	date_t result(days);
-	if (!Value::IsFinite(result)) {
-		throw OutOfRangeException("Date out of range");
-	}
-	return result;
-}
-
-template <>
-date_t AddOperator::Operation(int32_t left, date_t right) {
-	return AddOperator::Operation<date_t, int32_t, date_t>(right, left);
-}
-
-template <>
-timestamp_t AddOperator::Operation(date_t left, dtime_t right) {
-	if (left == date_t::infinity()) {
-		return timestamp_t::infinity();
-	} else if (left == date_t::ninfinity()) {
-		return timestamp_t::ninfinity();
-	}
-	timestamp_t result;
-	if (!Timestamp::TryFromDatetime(left, right, result)) {
-		throw OutOfRangeException("Timestamp out of range");
-	}
-	return result;
-}
-
-template <>
-timestamp_t AddOperator::Operation(dtime_t left, date_t right) {
-	return AddOperator::Operation<date_t, dtime_t, timestamp_t>(right, left);
-}
-
-template <>
-date_t AddOperator::Operation(date_t left, interval_t right) {
-	return Interval::Add(left, right);
-}
-
-template <>
-date_t AddOperator::Operation(interval_t left, date_t right) {
-	return AddOperator::Operation<date_t, interval_t, date_t>(right, left);
-}
-
-template <>
-timestamp_t AddOperator::Operation(timestamp_t left, interval_t right) {
-	return Interval::Add(left, right);
-}
-
-template <>
-timestamp_t AddOperator::Operation(interval_t left, timestamp_t right) {
-	return AddOperator::Operation<timestamp_t, interval_t, timestamp_t>(right, left);
-}
-
-//===--------------------------------------------------------------------===//
-// + [add] with overflow check
-//===--------------------------------------------------------------------===//
-struct OverflowCheckedAddition {
-	template <class SRCTYPE, class UTYPE>
-	static inline bool Operation(SRCTYPE left, SRCTYPE right, SRCTYPE &result) {
-		UTYPE uresult = AddOperator::Operation<UTYPE, UTYPE, UTYPE>(UTYPE(left), UTYPE(right));
-		if (uresult < NumericLimits<SRCTYPE>::Minimum() || uresult > NumericLimits<SRCTYPE>::Maximum()) {
-			return false;
-		}
-		result = SRCTYPE(uresult);
-		return true;
-	}
-};
-
-template <>
-bool TryAddOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
-	return OverflowCheckedAddition::Operation<uint8_t, uint16_t>(left, right, result);
-}
-template <>
-bool TryAddOperator::Operation(uint16_t left, uint16_t right, uint16_t &result) {
-	return OverflowCheckedAddition::Operation<uint16_t, uint32_t>(left, right, result);
-}
-template <>
-bool TryAddOperator::Operation(uint32_t left, uint32_t right, uint32_t &result) {
-	return OverflowCheckedAddition::Operation<uint32_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(uint64_t left, uint64_t right, uint64_t &result) {
-	if (NumericLimits<uint64_t>::Maximum() - left < right) {
-		return false;
-	}
-	return OverflowCheckedAddition::Operation<uint64_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(int8_t left, int8_t right, int8_t &result) {
-	return OverflowCheckedAddition::Operation<int8_t, int16_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(int16_t left, int16_t right, int16_t &result) {
-	return OverflowCheckedAddition::Operation<int16_t, int32_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(int32_t left, int32_t right, int32_t &result) {
-	return OverflowCheckedAddition::Operation<int32_t, int64_t>(left, right, result);
-}
-
-template <>
-bool TryAddOperator::Operation(int64_t left, int64_t right, int64_t &result) {
-#if (__GNUC__ >= 5) || defined(__clang__)
-	if (__builtin_add_overflow(left, right, &result)) {
-		return false;
-	}
-#else
-	// https://blog.regehr.org/archives/1139
-	result = int64_t((uint64_t)left + (uint64_t)right);
-	if ((left < 0 && right < 0 && result >= 0) || (left >= 0 && right >= 0 && result < 0)) {
-		return false;
-	}
-#endif
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// add decimal with overflow check
-//===--------------------------------------------------------------------===//
-template <class T, T min, T max>
-bool TryDecimalAddTemplated(T left, T right, T &result) {
-	if (right < 0) {
-		if (min - right > left) {
-			return false;
-		}
-	} else {
-		if (max - right < left) {
-			return false;
-		}
-	}
-	result = left + right;
-	return true;
-}
-
-template <>
-bool TryDecimalAdd::Operation(int16_t left, int16_t right, int16_t &result) {
-	return TryDecimalAddTemplated<int16_t, -9999, 9999>(left, right, result);
-}
-
-template <>
-bool TryDecimalAdd::Operation(int32_t left, int32_t right, int32_t &result) {
-	return TryDecimalAddTemplated<int32_t, -999999999, 999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalAdd::Operation(int64_t left, int64_t right, int64_t &result) {
-	return TryDecimalAddTemplated<int64_t, -999999999999999999, 999999999999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalAdd::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	result = left + right;
-	if (result <= -Hugeint::POWERS_OF_TEN[38] || result >= Hugeint::POWERS_OF_TEN[38]) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-hugeint_t DecimalAddOverflowCheck::Operation(hugeint_t left, hugeint_t right) {
-	hugeint_t result;
-	if (!TryDecimalAdd::Operation(left, right, result)) {
-		throw OutOfRangeException("Overflow in addition of DECIMAL(38) (%s + %s);", left.ToString(), right.ToString());
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// add time operator
-//===--------------------------------------------------------------------===//
-template <>
-dtime_t AddTimeOperator::Operation(dtime_t left, interval_t right) {
-	date_t date(0);
-	return Interval::Add(left, right, date);
-}
-
-template <>
-dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right) {
-	return AddTimeOperator::Operation<dtime_t, interval_t, dtime_t>(right, left);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <limits>
-
-namespace duckdb {
-
-template <class OP>
-static scalar_function_t GetScalarIntegerFunction(PhysicalType type) {
-	scalar_function_t function;
-	switch (type) {
-	case PhysicalType::INT8:
-		function = &ScalarFunction::BinaryFunction<int8_t, int8_t, int8_t, OP>;
-		break;
-	case PhysicalType::INT16:
-		function = &ScalarFunction::BinaryFunction<int16_t, int16_t, int16_t, OP>;
-		break;
-	case PhysicalType::INT32:
-		function = &ScalarFunction::BinaryFunction<int32_t, int32_t, int32_t, OP>;
-		break;
-	case PhysicalType::INT64:
-		function = &ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, OP>;
-		break;
-	case PhysicalType::UINT8:
-		function = &ScalarFunction::BinaryFunction<uint8_t, uint8_t, uint8_t, OP>;
-		break;
-	case PhysicalType::UINT16:
-		function = &ScalarFunction::BinaryFunction<uint16_t, uint16_t, uint16_t, OP>;
-		break;
-	case PhysicalType::UINT32:
-		function = &ScalarFunction::BinaryFunction<uint32_t, uint32_t, uint32_t, OP>;
-		break;
-	case PhysicalType::UINT64:
-		function = &ScalarFunction::BinaryFunction<uint64_t, uint64_t, uint64_t, OP>;
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarBinaryFunction");
-	}
-	return function;
-}
-
-template <class OP>
-static scalar_function_t GetScalarBinaryFunction(PhysicalType type) {
-	scalar_function_t function;
-	switch (type) {
-	case PhysicalType::INT128:
-		function = &ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, OP>;
-		break;
-	case PhysicalType::FLOAT:
-		function = &ScalarFunction::BinaryFunction<float, float, float, OP>;
-		break;
-	case PhysicalType::DOUBLE:
-		function = &ScalarFunction::BinaryFunction<double, double, double, OP>;
-		break;
-	default:
-		function = GetScalarIntegerFunction<OP>(type);
-		break;
-	}
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// + [add]
-//===--------------------------------------------------------------------===//
-struct AddPropagateStatistics {
-	template <class T, class OP>
-	static bool Operation(LogicalType type, NumericStatistics &lstats, NumericStatistics &rstats, Value &new_min,
-	                      Value &new_max) {
-		T min, max;
-		// new min is min+min
-		if (!OP::Operation(lstats.min.GetValueUnsafe<T>(), rstats.min.GetValueUnsafe<T>(), min)) {
-			return true;
-		}
-		// new max is max+max
-		if (!OP::Operation(lstats.max.GetValueUnsafe<T>(), rstats.max.GetValueUnsafe<T>(), max)) {
-			return true;
-		}
-		new_min = Value::Numeric(type, min);
-		new_max = Value::Numeric(type, max);
-		return false;
-	}
-};
-
-struct SubtractPropagateStatistics {
-	template <class T, class OP>
-	static bool Operation(LogicalType type, NumericStatistics &lstats, NumericStatistics &rstats, Value &new_min,
-	                      Value &new_max) {
-		T min, max;
-		if (!OP::Operation(lstats.min.GetValueUnsafe<T>(), rstats.max.GetValueUnsafe<T>(), min)) {
-			return true;
-		}
-		if (!OP::Operation(lstats.max.GetValueUnsafe<T>(), rstats.min.GetValueUnsafe<T>(), max)) {
-			return true;
-		}
-		new_min = Value::Numeric(type, min);
-		new_max = Value::Numeric(type, max);
-		return false;
-	}
-};
-
-template <class OP, class PROPAGATE, class BASEOP>
-static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 2);
-	// can only propagate stats if the children have stats
-	if (!child_stats[0] || !child_stats[1]) {
-		return nullptr;
-	}
-	auto &lstats = (NumericStatistics &)*child_stats[0];
-	auto &rstats = (NumericStatistics &)*child_stats[1];
-	Value new_min, new_max;
-	bool potential_overflow = true;
-	if (!lstats.min.IsNull() && !lstats.max.IsNull() && !rstats.min.IsNull() && !rstats.max.IsNull()) {
-		switch (expr.return_type.InternalType()) {
-		case PhysicalType::INT8:
-			potential_overflow =
-			    PROPAGATE::template Operation<int8_t, OP>(expr.return_type, lstats, rstats, new_min, new_max);
-			break;
-		case PhysicalType::INT16:
-			potential_overflow =
-			    PROPAGATE::template Operation<int16_t, OP>(expr.return_type, lstats, rstats, new_min, new_max);
-			break;
-		case PhysicalType::INT32:
-			potential_overflow =
-			    PROPAGATE::template Operation<int32_t, OP>(expr.return_type, lstats, rstats, new_min, new_max);
-			break;
-		case PhysicalType::INT64:
-			potential_overflow =
-			    PROPAGATE::template Operation<int64_t, OP>(expr.return_type, lstats, rstats, new_min, new_max);
-			break;
-		default:
-			return nullptr;
-		}
-	}
-	if (potential_overflow) {
-		new_min = Value(expr.return_type);
-		new_max = Value(expr.return_type);
-	} else {
-		// no potential overflow: replace with non-overflowing operator
-		expr.function.function = GetScalarIntegerFunction<BASEOP>(expr.return_type.InternalType());
-	}
-	auto stats =
-	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
-	stats->validity_stats = ValidityStatistics::Combine(lstats.validity_stats, rstats.validity_stats);
-	return move(stats);
-}
-
-template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
-unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-	// get the max width and scale of the input arguments
-	uint8_t max_width = 0, max_scale = 0, max_width_over_scale = 0;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		if (arguments[i]->return_type.id() == LogicalTypeId::UNKNOWN) {
-			continue;
-		}
-		uint8_t width, scale;
-		auto can_convert = arguments[i]->return_type.GetDecimalProperties(width, scale);
-		if (!can_convert) {
-			throw InternalException("Could not convert type %s to a decimal.", arguments[i]->return_type.ToString());
-		}
-		max_width = MaxValue<uint8_t>(width, max_width);
-		max_scale = MaxValue<uint8_t>(scale, max_scale);
-		max_width_over_scale = MaxValue<uint8_t>(width - scale, max_width_over_scale);
-	}
-	D_ASSERT(max_width > 0);
-	// for addition/subtraction, we add 1 to the width to ensure we don't overflow
-	bool check_overflow = false;
-	auto required_width = MaxValue<uint8_t>(max_scale + max_width_over_scale, max_width) + 1;
-	if (required_width > Decimal::MAX_WIDTH_INT64 && max_width <= Decimal::MAX_WIDTH_INT64) {
-		// we don't automatically promote past the hugeint boundary to avoid the large hugeint performance penalty
-		check_overflow = true;
-		required_width = Decimal::MAX_WIDTH_INT64;
-	}
-	if (required_width > Decimal::MAX_WIDTH_DECIMAL) {
-		// target width does not fit in decimal at all: truncate the scale and perform overflow detection
-		check_overflow = true;
-		required_width = Decimal::MAX_WIDTH_DECIMAL;
-	}
-	// arithmetic between two decimal arguments: check the types of the input arguments
-	LogicalType result_type = LogicalType::DECIMAL(required_width, max_scale);
-	// we cast all input types to the specified type
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		// first check if the cast is necessary
-		// if the argument has a matching scale and internal type as the output type, no casting is necessary
-		auto &argument_type = arguments[i]->return_type;
-		uint8_t width, scale;
-		argument_type.GetDecimalProperties(width, scale);
-		if (scale == DecimalType::GetScale(result_type) && argument_type.InternalType() == result_type.InternalType()) {
-			bound_function.arguments[i] = argument_type;
-		} else {
-			bound_function.arguments[i] = result_type;
-		}
-	}
-	bound_function.return_type = result_type;
-	// now select the physical function to execute
-	if (check_overflow) {
-		bound_function.function = GetScalarBinaryFunction<OPOVERFLOWCHECK>(result_type.InternalType());
-	} else {
-		bound_function.function = GetScalarBinaryFunction<OP>(result_type.InternalType());
-	}
-	if (result_type.InternalType() != PhysicalType::INT128) {
-		if (IS_SUBTRACT) {
-			bound_function.statistics =
-			    PropagateNumericStats<TryDecimalSubtract, SubtractPropagateStatistics, SubtractOperator>;
-		} else {
-			bound_function.statistics = PropagateNumericStats<TryDecimalAdd, AddPropagateStatistics, AddOperator>;
-		}
-	}
-	return nullptr;
-}
-
-unique_ptr<FunctionData> NopDecimalBind(ClientContext &context, ScalarFunction &bound_function,
-                                        vector<unique_ptr<Expression>> &arguments) {
-	bound_function.return_type = arguments[0]->return_type;
-	bound_function.arguments[0] = arguments[0]->return_type;
-	return nullptr;
-}
-
-ScalarFunction AddFun::GetFunction(const LogicalType &type) {
-	D_ASSERT(type.IsNumeric());
-	if (type.id() == LogicalTypeId::DECIMAL) {
-		return ScalarFunction("+", {type}, type, ScalarFunction::NopFunction, false, NopDecimalBind);
-	} else {
-		return ScalarFunction("+", {type}, type, ScalarFunction::NopFunction);
-	}
-}
-
-ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalType &right_type) {
-	if (left_type.IsNumeric() && left_type.id() == right_type.id()) {
-		if (left_type.id() == LogicalTypeId::DECIMAL) {
-			return ScalarFunction("+", {left_type, right_type}, left_type, nullptr, false,
-			                      BindDecimalAddSubtract<AddOperator, DecimalAddOverflowCheck>);
-		} else if (left_type.IsIntegral() && left_type.id() != LogicalTypeId::HUGEINT) {
-			return ScalarFunction("+", {left_type, right_type}, left_type,
-			                      GetScalarIntegerFunction<AddOperatorOverflowCheck>(left_type.InternalType()), false,
-			                      nullptr, nullptr,
-			                      PropagateNumericStats<TryAddOperator, AddPropagateStatistics, AddOperator>);
-		} else {
-			return ScalarFunction("+", {left_type, right_type}, left_type,
-			                      GetScalarBinaryFunction<AddOperator>(left_type.InternalType()));
-		}
-	}
-
-	switch (left_type.id()) {
-	case LogicalTypeId::DATE:
-		if (right_type.id() == LogicalTypeId::INTEGER) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE,
-			                      ScalarFunction::BinaryFunction<date_t, int32_t, date_t, AddOperator>);
-		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE,
-			                      ScalarFunction::BinaryFunction<date_t, interval_t, date_t, AddOperator>);
-		} else if (right_type.id() == LogicalTypeId::TIME) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                      ScalarFunction::BinaryFunction<date_t, dtime_t, timestamp_t, AddOperator>);
-		}
-		break;
-	case LogicalTypeId::INTEGER:
-		if (right_type.id() == LogicalTypeId::DATE) {
-			return ScalarFunction("+", {left_type, right_type}, right_type,
-			                      ScalarFunction::BinaryFunction<int32_t, date_t, date_t, AddOperator>);
-		}
-		break;
-	case LogicalTypeId::INTERVAL:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::INTERVAL,
-			                      ScalarFunction::BinaryFunction<interval_t, interval_t, interval_t, AddOperator>);
-		} else if (right_type.id() == LogicalTypeId::DATE) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE,
-			                      ScalarFunction::BinaryFunction<interval_t, date_t, date_t, AddOperator>);
-		} else if (right_type.id() == LogicalTypeId::TIME) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME,
-			                      ScalarFunction::BinaryFunction<interval_t, dtime_t, dtime_t, AddTimeOperator>);
-		} else if (right_type.id() == LogicalTypeId::TIMESTAMP) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                      ScalarFunction::BinaryFunction<interval_t, timestamp_t, timestamp_t, AddOperator>);
-		}
-		break;
-	case LogicalTypeId::TIME:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME,
-			                      ScalarFunction::BinaryFunction<dtime_t, interval_t, dtime_t, AddTimeOperator>);
-		} else if (right_type.id() == LogicalTypeId::DATE) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                      ScalarFunction::BinaryFunction<dtime_t, date_t, timestamp_t, AddOperator>);
-		}
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP,
-			                      ScalarFunction::BinaryFunction<timestamp_t, interval_t, timestamp_t, AddOperator>);
-		}
-		break;
-	default:
-		break;
-	}
-	// LCOV_EXCL_START
-	throw NotImplementedException("AddFun for types %s, %s", LogicalTypeIdToString(left_type.id()),
-	                              LogicalTypeIdToString(right_type.id()));
-	// LCOV_EXCL_STOP
-}
-
-void AddFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("+");
-	for (auto &type : LogicalType::Numeric()) {
-		// unary add function is a nop, but only exists for numeric types
-		functions.AddFunction(GetFunction(type));
-		// binary add function adds two numbers together
-		functions.AddFunction(GetFunction(type, type));
-	}
-	// we can add integers to dates
-	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTEGER));
-	functions.AddFunction(GetFunction(LogicalType::INTEGER, LogicalType::DATE));
-	// we can add intervals together
-	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::INTERVAL));
-	// we can add intervals to dates/times/timestamps
-	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTERVAL));
-	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::DATE));
-
-	functions.AddFunction(GetFunction(LogicalType::TIME, LogicalType::INTERVAL));
-	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::TIME));
-
-	functions.AddFunction(GetFunction(LogicalType::TIMESTAMP, LogicalType::INTERVAL));
-	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::TIMESTAMP));
-
-	// we can add times to dates
-	functions.AddFunction(GetFunction(LogicalType::TIME, LogicalType::DATE));
-	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::TIME));
-
-	// we can add lists together
-	functions.AddFunction(ListConcatFun::GetFunction());
-
-	set.AddFunction(functions);
-
-	functions.name = "add";
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// - [subtract]
-//===--------------------------------------------------------------------===//
-struct NegateOperator {
-	template <class T>
-	static bool CanNegate(T input) {
-		using Limits = std::numeric_limits<T>;
-		return !(Limits::is_integer && Limits::is_signed && Limits::lowest() == input);
-	}
-
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		auto cast = (TR)input;
-		if (!CanNegate<TR>(cast)) {
-			throw OutOfRangeException("Overflow in negation of integer!");
-		}
-		return -cast;
-	}
-};
-
-template <>
-bool NegateOperator::CanNegate(float input) {
-	return Value::FloatIsFinite(input);
-}
-
-template <>
-bool NegateOperator::CanNegate(double input) {
-	return Value::DoubleIsFinite(input);
-}
-
-template <>
-interval_t NegateOperator::Operation(interval_t input) {
-	interval_t result;
-	result.months = NegateOperator::Operation<int32_t, int32_t>(input.months);
-	result.days = NegateOperator::Operation<int32_t, int32_t>(input.days);
-	result.micros = NegateOperator::Operation<int64_t, int64_t>(input.micros);
-	return result;
-}
-
-unique_ptr<FunctionData> DecimalNegateBind(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	auto &decimal_type = arguments[0]->return_type;
-	auto width = DecimalType::GetWidth(decimal_type);
-	if (width <= Decimal::MAX_WIDTH_INT16) {
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<NegateOperator>(LogicalTypeId::SMALLINT);
-	} else if (width <= Decimal::MAX_WIDTH_INT32) {
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<NegateOperator>(LogicalTypeId::INTEGER);
-	} else if (width <= Decimal::MAX_WIDTH_INT64) {
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<NegateOperator>(LogicalTypeId::BIGINT);
-	} else {
-		D_ASSERT(width <= Decimal::MAX_WIDTH_INT128);
-		bound_function.function = ScalarFunction::GetScalarUnaryFunction<NegateOperator>(LogicalTypeId::HUGEINT);
-	}
-	decimal_type.Verify();
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = decimal_type;
-	return nullptr;
-}
-
-struct NegatePropagateStatistics {
-	template <class T>
-	static bool Operation(LogicalType type, NumericStatistics &istats, Value &new_min, Value &new_max) {
-		auto max_value = istats.max.GetValueUnsafe<T>();
-		auto min_value = istats.min.GetValueUnsafe<T>();
-		if (!NegateOperator::CanNegate<T>(min_value) || !NegateOperator::CanNegate<T>(max_value)) {
-			return true;
-		}
-		// new min is -max
-		new_min = Value::Numeric(type, NegateOperator::Operation<T, T>(max_value));
-		// new max is -min
-		new_max = Value::Numeric(type, NegateOperator::Operation<T, T>(min_value));
-		return false;
-	}
-};
-
-static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 1);
-	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &istats = (NumericStatistics &)*child_stats[0];
-	Value new_min, new_max;
-	bool potential_overflow = true;
-	if (!istats.min.IsNull() && !istats.max.IsNull()) {
-		switch (expr.return_type.InternalType()) {
-		case PhysicalType::INT8:
-			potential_overflow =
-			    NegatePropagateStatistics::Operation<int8_t>(expr.return_type, istats, new_min, new_max);
-			break;
-		case PhysicalType::INT16:
-			potential_overflow =
-			    NegatePropagateStatistics::Operation<int16_t>(expr.return_type, istats, new_min, new_max);
-			break;
-		case PhysicalType::INT32:
-			potential_overflow =
-			    NegatePropagateStatistics::Operation<int32_t>(expr.return_type, istats, new_min, new_max);
-			break;
-		case PhysicalType::INT64:
-			potential_overflow =
-			    NegatePropagateStatistics::Operation<int64_t>(expr.return_type, istats, new_min, new_max);
-			break;
-		default:
-			return nullptr;
-		}
-	}
-	if (potential_overflow) {
-		new_min = Value(expr.return_type);
-		new_max = Value(expr.return_type);
-	}
-	auto stats =
-	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
-	if (istats.validity_stats) {
-		stats->validity_stats = istats.validity_stats->Copy();
-	}
-	return move(stats);
-}
-
-ScalarFunction SubtractFun::GetFunction(const LogicalType &type) {
-	if (type.id() == LogicalTypeId::INTERVAL) {
-		return ScalarFunction("-", {type}, type, ScalarFunction::UnaryFunction<interval_t, interval_t, NegateOperator>);
-	} else if (type.id() == LogicalTypeId::DECIMAL) {
-		return ScalarFunction("-", {type}, type, nullptr, false, DecimalNegateBind, nullptr, NegateBindStatistics);
-	} else {
-		D_ASSERT(type.IsNumeric());
-		return ScalarFunction("-", {type}, type, ScalarFunction::GetScalarUnaryFunction<NegateOperator>(type), false,
-		                      nullptr, nullptr, NegateBindStatistics);
-	}
-}
-
-ScalarFunction SubtractFun::GetFunction(const LogicalType &left_type, const LogicalType &right_type) {
-	if (left_type.IsNumeric() && left_type.id() == right_type.id()) {
-		if (left_type.id() == LogicalTypeId::DECIMAL) {
-			return ScalarFunction("-", {left_type, right_type}, left_type, nullptr, false,
-			                      BindDecimalAddSubtract<SubtractOperator, DecimalSubtractOverflowCheck, true>);
-		} else if (left_type.IsIntegral() && left_type.id() != LogicalTypeId::HUGEINT) {
-			return ScalarFunction(
-			    "-", {left_type, right_type}, left_type,
-			    GetScalarIntegerFunction<SubtractOperatorOverflowCheck>(left_type.InternalType()), false, nullptr,
-			    nullptr, PropagateNumericStats<TrySubtractOperator, SubtractPropagateStatistics, SubtractOperator>);
-		} else {
-			return ScalarFunction("-", {left_type, right_type}, left_type,
-			                      GetScalarBinaryFunction<SubtractOperator>(left_type.InternalType()));
-		}
-	}
-
-	switch (left_type.id()) {
-	case LogicalTypeId::DATE:
-		if (right_type.id() == LogicalTypeId::DATE) {
-			return ScalarFunction("-", {left_type, right_type}, LogicalType::BIGINT,
-			                      ScalarFunction::BinaryFunction<date_t, date_t, int64_t, SubtractOperator>);
-		} else if (right_type.id() == LogicalTypeId::INTEGER) {
-			return ScalarFunction("-", {left_type, right_type}, LogicalType::DATE,
-			                      ScalarFunction::BinaryFunction<date_t, int32_t, date_t, SubtractOperator>);
-		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("-", {left_type, right_type}, LogicalType::DATE,
-			                      ScalarFunction::BinaryFunction<date_t, interval_t, date_t, SubtractOperator>);
-		}
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		if (right_type.id() == LogicalTypeId::TIMESTAMP) {
-			return ScalarFunction(
-			    "-", {left_type, right_type}, LogicalType::INTERVAL,
-			    ScalarFunction::BinaryFunction<timestamp_t, timestamp_t, interval_t, SubtractOperator>);
-		} else if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction(
-			    "-", {left_type, right_type}, LogicalType::TIMESTAMP,
-			    ScalarFunction::BinaryFunction<timestamp_t, interval_t, timestamp_t, SubtractOperator>);
-		}
-		break;
-	case LogicalTypeId::INTERVAL:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("-", {left_type, right_type}, LogicalType::INTERVAL,
-			                      ScalarFunction::BinaryFunction<interval_t, interval_t, interval_t, SubtractOperator>);
-		}
-		break;
-	case LogicalTypeId::TIME:
-		if (right_type.id() == LogicalTypeId::INTERVAL) {
-			return ScalarFunction("-", {left_type, right_type}, LogicalType::TIME,
-			                      ScalarFunction::BinaryFunction<dtime_t, interval_t, dtime_t, SubtractTimeOperator>);
-		}
-		break;
-	default:
-		break;
-	}
-	// LCOV_EXCL_START
-	throw NotImplementedException("SubtractFun for types %s, %s", LogicalTypeIdToString(left_type.id()),
-	                              LogicalTypeIdToString(right_type.id()));
-	// LCOV_EXCL_STOP
-}
-
-void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("-");
-	for (auto &type : LogicalType::Numeric()) {
-		// unary subtract function, negates the input (i.e. multiplies by -1)
-		functions.AddFunction(GetFunction(type));
-		// binary subtract function "a - b", subtracts b from a
-		functions.AddFunction(GetFunction(type, type));
-	}
-	// we can subtract dates from each other
-	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::DATE));
-	// we can subtract integers from dates
-	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTEGER));
-	// we can subtract timestamps from each other
-	functions.AddFunction(GetFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP));
-	// we can subtract intervals from each other
-	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::INTERVAL));
-	// we can subtract intervals from dates/times/timestamps, but not the other way around
-	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTERVAL));
-	functions.AddFunction(GetFunction(LogicalType::TIME, LogicalType::INTERVAL));
-	functions.AddFunction(GetFunction(LogicalType::TIMESTAMP, LogicalType::INTERVAL));
-	// we can negate intervals
-	functions.AddFunction(GetFunction(LogicalType::INTERVAL));
-	set.AddFunction(functions);
-
-	functions.name = "subtract";
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// * [multiply]
-//===--------------------------------------------------------------------===//
-struct MultiplyPropagateStatistics {
-	template <class T, class OP>
-	static bool Operation(LogicalType type, NumericStatistics &lstats, NumericStatistics &rstats, Value &new_min,
-	                      Value &new_max) {
-		// statistics propagation on the multiplication is slightly less straightforward because of negative numbers
-		// the new min/max depend on the signs of the input types
-		// if both are positive the result is [lmin * rmin][lmax * rmax]
-		// if lmin/lmax are negative the result is [lmin * rmax][lmax * rmin]
-		// etc
-		// rather than doing all this switcheroo we just multiply all combinations of lmin/lmax with rmin/rmax
-		// and check what the minimum/maximum value is
-		T lvals[] {lstats.min.GetValueUnsafe<T>(), lstats.max.GetValueUnsafe<T>()};
-		T rvals[] {rstats.min.GetValueUnsafe<T>(), rstats.max.GetValueUnsafe<T>()};
-		T min = NumericLimits<T>::Maximum();
-		T max = NumericLimits<T>::Minimum();
-		// multiplications
-		for (idx_t l = 0; l < 2; l++) {
-			for (idx_t r = 0; r < 2; r++) {
-				T result;
-				if (!OP::Operation(lvals[l], rvals[r], result)) {
-					// potential overflow
-					return true;
-				}
-				if (result < min) {
-					min = result;
-				}
-				if (result > max) {
-					max = result;
-				}
-			}
-		}
-		new_min = Value::Numeric(type, min);
-		new_max = Value::Numeric(type, max);
-		return false;
-	}
-};
-
-unique_ptr<FunctionData> BindDecimalMultiply(ClientContext &context, ScalarFunction &bound_function,
-                                             vector<unique_ptr<Expression>> &arguments) {
-	uint8_t result_width = 0, result_scale = 0;
-	uint8_t max_width = 0;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		if (arguments[i]->return_type.id() == LogicalTypeId::UNKNOWN) {
-			continue;
-		}
-		uint8_t width, scale;
-		auto can_convert = arguments[i]->return_type.GetDecimalProperties(width, scale);
-		if (!can_convert) {
-			throw InternalException("Could not convert type %s to a decimal?", arguments[i]->return_type.ToString());
-		}
-		if (width > max_width) {
-			max_width = width;
-		}
-		result_width += width;
-		result_scale += scale;
-	}
-	D_ASSERT(max_width > 0);
-	if (result_scale > Decimal::MAX_WIDTH_DECIMAL) {
-		throw OutOfRangeException(
-		    "Needed scale %d to accurately represent the multiplication result, but this is out of range of the "
-		    "DECIMAL type. Max scale is %d; could not perform an accurate multiplication. Either add a cast to DOUBLE, "
-		    "or add an explicit cast to a decimal with a lower scale.",
-		    result_scale, Decimal::MAX_WIDTH_DECIMAL);
-	}
-	bool check_overflow = false;
-	if (result_width > Decimal::MAX_WIDTH_INT64 && max_width <= Decimal::MAX_WIDTH_INT64 &&
-	    result_scale < Decimal::MAX_WIDTH_INT64) {
-		check_overflow = true;
-		result_width = Decimal::MAX_WIDTH_INT64;
-	}
-	if (result_width > Decimal::MAX_WIDTH_DECIMAL) {
-		check_overflow = true;
-		result_width = Decimal::MAX_WIDTH_DECIMAL;
-	}
-	LogicalType result_type = LogicalType::DECIMAL(result_width, result_scale);
-	// since our scale is the summation of our input scales, we do not need to cast to the result scale
-	// however, we might need to cast to the correct internal type
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		auto &argument_type = arguments[i]->return_type;
-		if (argument_type.InternalType() == result_type.InternalType()) {
-			bound_function.arguments[i] = argument_type;
-		} else {
-			uint8_t width, scale;
-			if (!argument_type.GetDecimalProperties(width, scale)) {
-				scale = 0;
-			}
-
-			bound_function.arguments[i] = LogicalType::DECIMAL(result_width, scale);
-		}
-	}
-	result_type.Verify();
-	bound_function.return_type = result_type;
-	// now select the physical function to execute
-	if (check_overflow) {
-		bound_function.function = GetScalarBinaryFunction<DecimalMultiplyOverflowCheck>(result_type.InternalType());
-	} else {
-		bound_function.function = GetScalarBinaryFunction<MultiplyOperator>(result_type.InternalType());
-	}
-	if (result_type.InternalType() != PhysicalType::INT128) {
-		bound_function.statistics =
-		    PropagateNumericStats<TryDecimalMultiply, MultiplyPropagateStatistics, MultiplyOperator>;
-	}
-	return nullptr;
-}
-
-void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("*");
-	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			functions.AddFunction(ScalarFunction({type, type}, type, nullptr, true, false, BindDecimalMultiply));
-		} else if (TypeIsIntegral(type.InternalType()) && type.id() != LogicalTypeId::HUGEINT) {
-			functions.AddFunction(ScalarFunction(
-			    {type, type}, type, GetScalarIntegerFunction<MultiplyOperatorOverflowCheck>(type.InternalType()), true,
-			    false, nullptr, nullptr,
-			    PropagateNumericStats<TryMultiplyOperator, MultiplyPropagateStatistics, MultiplyOperator>));
-		} else {
-			functions.AddFunction(ScalarFunction({type, type}, type,
-			                                     GetScalarBinaryFunction<MultiplyOperator>(type.InternalType()), true));
-		}
-	}
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                   ScalarFunction::BinaryFunction<interval_t, int64_t, interval_t, MultiplyOperator>, true));
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::BIGINT, LogicalType::INTERVAL}, LogicalType::INTERVAL,
-	                   ScalarFunction::BinaryFunction<int64_t, interval_t, interval_t, MultiplyOperator>, true));
-	set.AddFunction(functions);
-
-	functions.name = "multiply";
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// / [divide]
-//===--------------------------------------------------------------------===//
-template <>
-float DivideOperator::Operation(float left, float right) {
-	auto result = left / right;
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in division of float!");
-	}
-	return result;
-}
-
-template <>
-double DivideOperator::Operation(double left, double right) {
-	auto result = left / right;
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in division of double!");
-	}
-	return result;
-}
-
-template <>
-hugeint_t DivideOperator::Operation(hugeint_t left, hugeint_t right) {
-	if (right.lower == 0 && right.upper == 0) {
-		throw InternalException("Hugeint division by zero!");
-	}
-	return left / right;
-}
-
-template <>
-interval_t DivideOperator::Operation(interval_t left, int64_t right) {
-	left.days /= right;
-	left.months /= right;
-	left.micros /= right;
-	return left;
-}
-
-struct BinaryZeroIsNullWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		if (right == 0) {
-			mask.SetInvalid(idx);
-			return left;
-		} else {
-			return OP::template Operation<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(left, right);
-		}
-	}
-
-	static bool AddsNulls() {
-		return true;
-	}
-};
-
-struct BinaryZeroIsNullHugeintWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		if (right.upper == 0 && right.lower == 0) {
-			mask.SetInvalid(idx);
-			return left;
-		} else {
-			return OP::template Operation<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(left, right);
-		}
-	}
-
-	static bool AddsNulls() {
-		return true;
-	}
-};
-
-template <class TA, class TB, class TC, class OP, class ZWRAPPER = BinaryZeroIsNullWrapper>
-static void BinaryScalarFunctionIgnoreZero(DataChunk &input, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<TA, TB, TC, OP, ZWRAPPER>(input.data[0], input.data[1], result, input.size());
-}
-
-template <class OP>
-static scalar_function_t GetBinaryFunctionIgnoreZero(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		return BinaryScalarFunctionIgnoreZero<int8_t, int8_t, int8_t, OP>;
-	case LogicalTypeId::SMALLINT:
-		return BinaryScalarFunctionIgnoreZero<int16_t, int16_t, int16_t, OP>;
-	case LogicalTypeId::INTEGER:
-		return BinaryScalarFunctionIgnoreZero<int32_t, int32_t, int32_t, OP>;
-	case LogicalTypeId::BIGINT:
-		return BinaryScalarFunctionIgnoreZero<int64_t, int64_t, int64_t, OP>;
-	case LogicalTypeId::UTINYINT:
-		return BinaryScalarFunctionIgnoreZero<uint8_t, uint8_t, uint8_t, OP>;
-	case LogicalTypeId::USMALLINT:
-		return BinaryScalarFunctionIgnoreZero<uint16_t, uint16_t, uint16_t, OP>;
-	case LogicalTypeId::UINTEGER:
-		return BinaryScalarFunctionIgnoreZero<uint32_t, uint32_t, uint32_t, OP>;
-	case LogicalTypeId::UBIGINT:
-		return BinaryScalarFunctionIgnoreZero<uint64_t, uint64_t, uint64_t, OP>;
-	case LogicalTypeId::HUGEINT:
-		return BinaryScalarFunctionIgnoreZero<hugeint_t, hugeint_t, hugeint_t, OP, BinaryZeroIsNullHugeintWrapper>;
-	case LogicalTypeId::FLOAT:
-		return BinaryScalarFunctionIgnoreZero<float, float, float, OP>;
-	case LogicalTypeId::DOUBLE:
-		return BinaryScalarFunctionIgnoreZero<double, double, double, OP>;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarUnaryFunction");
-	}
-}
-
-void DivideFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("/");
-	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			continue;
-		} else {
-			functions.AddFunction(
-			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<DivideOperator>(type)));
-		}
-	}
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
-
-	set.AddFunction(functions);
-
-	functions.name = "divide";
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// % [modulo]
-//===--------------------------------------------------------------------===//
-template <>
-float ModuloOperator::Operation(float left, float right) {
-	D_ASSERT(right != 0);
-	auto result = std::fmod(left, right);
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in modulo of float!");
-	}
-	return result;
-}
-
-template <>
-double ModuloOperator::Operation(double left, double right) {
-	D_ASSERT(right != 0);
-	auto result = std::fmod(left, right);
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in modulo of double!");
-	}
-	return result;
-}
-
-template <>
-hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right) {
-	if (right.lower == 0 && right.upper == 0) {
-		throw InternalException("Hugeint division by zero!");
-	}
-	return left % right;
-}
-
-void ModFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("%");
-	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
-			continue;
-		} else {
-			functions.AddFunction(
-			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<ModuloOperator>(type)));
-		}
-	}
-	set.AddFunction(functions);
-	functions.name = "mod";
-	set.AddFunction(functions);
-}
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-5.cpp b/velox/external/duckdb/duckdb-5.cpp
deleted file mode 100644
index fec1be3ea7204..0000000000000
--- a/velox/external/duckdb/duckdb-5.cpp
+++ /dev/null
@@ -1,16980 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-
-
-namespace duckdb {
-
-template <class OP>
-static scalar_function_t GetScalarIntegerUnaryFunction(const LogicalType &type) {
-	scalar_function_t function;
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		function = &ScalarFunction::UnaryFunction<int8_t, int8_t, OP>;
-		break;
-	case LogicalTypeId::SMALLINT:
-		function = &ScalarFunction::UnaryFunction<int16_t, int16_t, OP>;
-		break;
-	case LogicalTypeId::INTEGER:
-		function = &ScalarFunction::UnaryFunction<int32_t, int32_t, OP>;
-		break;
-	case LogicalTypeId::BIGINT:
-		function = &ScalarFunction::UnaryFunction<int64_t, int64_t, OP>;
-		break;
-	case LogicalTypeId::UTINYINT:
-		function = &ScalarFunction::UnaryFunction<uint8_t, uint8_t, OP>;
-		break;
-	case LogicalTypeId::USMALLINT:
-		function = &ScalarFunction::UnaryFunction<uint16_t, uint16_t, OP>;
-		break;
-	case LogicalTypeId::UINTEGER:
-		function = &ScalarFunction::UnaryFunction<uint32_t, uint32_t, OP>;
-		break;
-	case LogicalTypeId::UBIGINT:
-		function = &ScalarFunction::UnaryFunction<uint64_t, uint64_t, OP>;
-		break;
-	case LogicalTypeId::HUGEINT:
-		function = &ScalarFunction::UnaryFunction<hugeint_t, hugeint_t, OP>;
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarIntegerUnaryFunction");
-	}
-	return function;
-}
-
-template <class OP>
-static scalar_function_t GetScalarIntegerBinaryFunction(const LogicalType &type) {
-	scalar_function_t function;
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
-		function = &ScalarFunction::BinaryFunction<int8_t, int8_t, int8_t, OP>;
-		break;
-	case LogicalTypeId::SMALLINT:
-		function = &ScalarFunction::BinaryFunction<int16_t, int16_t, int16_t, OP>;
-		break;
-	case LogicalTypeId::INTEGER:
-		function = &ScalarFunction::BinaryFunction<int32_t, int32_t, int32_t, OP>;
-		break;
-	case LogicalTypeId::BIGINT:
-		function = &ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, OP>;
-		break;
-	case LogicalTypeId::UTINYINT:
-		function = &ScalarFunction::BinaryFunction<uint8_t, uint8_t, uint8_t, OP>;
-		break;
-	case LogicalTypeId::USMALLINT:
-		function = &ScalarFunction::BinaryFunction<uint16_t, uint16_t, uint16_t, OP>;
-		break;
-	case LogicalTypeId::UINTEGER:
-		function = &ScalarFunction::BinaryFunction<uint32_t, uint32_t, uint32_t, OP>;
-		break;
-	case LogicalTypeId::UBIGINT:
-		function = &ScalarFunction::BinaryFunction<uint64_t, uint64_t, uint64_t, OP>;
-		break;
-	case LogicalTypeId::HUGEINT:
-		function = &ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, OP>;
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for GetScalarIntegerBinaryFunction");
-	}
-	return function;
-}
-
-//===--------------------------------------------------------------------===//
-// & [bitwise_and]
-//===--------------------------------------------------------------------===//
-struct BitwiseANDOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left & right;
-	}
-};
-
-void BitwiseAndFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("&");
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseANDOperator>(type)));
-	}
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// | [bitwise_or]
-//===--------------------------------------------------------------------===//
-struct BitwiseOROperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left | right;
-	}
-};
-
-void BitwiseOrFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("|");
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseOROperator>(type)));
-	}
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// # [bitwise_xor]
-//===--------------------------------------------------------------------===//
-struct BitwiseXOROperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left ^ right;
-	}
-};
-
-void BitwiseXorFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("xor");
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseXOROperator>(type)));
-	}
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// << [bitwise_left_shift]
-//===--------------------------------------------------------------------===//
-
-struct BitwiseShiftLeftOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB shift) {
-		TA max_shift = TA(sizeof(TA) * 8);
-		if (input < 0) {
-			throw OutOfRangeException("Cannot left-shift negative number %s", NumericHelper::ToString(input));
-		}
-		if (shift < 0) {
-			throw OutOfRangeException("Cannot left-shift by negative number %s", NumericHelper::ToString(shift));
-		}
-		if (shift >= max_shift) {
-			if (input == 0) {
-				return 0;
-			}
-			throw OutOfRangeException("Left-shift value %s is out of range", NumericHelper::ToString(shift));
-		}
-		if (shift == 0) {
-			return input;
-		}
-		TA max_value = (TA(1) << (max_shift - shift - 1));
-		if (input >= max_value) {
-			throw OutOfRangeException("Overflow in left shift (%s << %s)", NumericHelper::ToString(input),
-			                          NumericHelper::ToString(shift));
-		}
-		return input << shift;
-	}
-};
-
-void LeftShiftFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("<<");
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftLeftOperator>(type)));
-	}
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// >> [bitwise_right_shift]
-//===--------------------------------------------------------------------===//
-template <class T>
-bool RightShiftInRange(T shift) {
-	return shift >= 0 && shift < T(sizeof(T) * 8);
-}
-
-struct BitwiseShiftRightOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB shift) {
-		return RightShiftInRange(shift) ? input >> shift : 0;
-	}
-};
-
-void RightShiftFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions(">>");
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(
-		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftRightOperator>(type)));
-	}
-	set.AddFunction(functions);
-}
-
-//===--------------------------------------------------------------------===//
-// ~ [bitwise_not]
-//===--------------------------------------------------------------------===//
-struct BitwiseNotOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return ~input;
-	}
-};
-
-void BitwiseNotFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("~");
-	for (auto &type : LogicalType::Integral()) {
-		functions.AddFunction(ScalarFunction({type}, type, GetScalarIntegerUnaryFunction<BitwiseNotOperator>(type)));
-	}
-	set.AddFunction(functions);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <limits>
-#include <algorithm>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// * [multiply]
-//===--------------------------------------------------------------------===//
-template <>
-float MultiplyOperator::Operation(float left, float right) {
-	auto result = left * right;
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in multiplication of float!");
-	}
-	return result;
-}
-
-template <>
-double MultiplyOperator::Operation(double left, double right) {
-	auto result = left * right;
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in multiplication of double!");
-	}
-	return result;
-}
-
-template <>
-interval_t MultiplyOperator::Operation(interval_t left, int64_t right) {
-	left.months = MultiplyOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(left.months, right);
-	left.days = MultiplyOperatorOverflowCheck::Operation<int32_t, int32_t, int32_t>(left.days, right);
-	left.micros = MultiplyOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(left.micros, right);
-	return left;
-}
-
-template <>
-interval_t MultiplyOperator::Operation(int64_t left, interval_t right) {
-	return MultiplyOperator::Operation<interval_t, int64_t, interval_t>(right, left);
-}
-
-//===--------------------------------------------------------------------===//
-// * [multiply] with overflow check
-//===--------------------------------------------------------------------===//
-struct OverflowCheckedMultiply {
-	template <class SRCTYPE, class UTYPE>
-	static inline bool Operation(SRCTYPE left, SRCTYPE right, SRCTYPE &result) {
-		UTYPE uresult = MultiplyOperator::Operation<UTYPE, UTYPE, UTYPE>(UTYPE(left), UTYPE(right));
-		if (uresult < NumericLimits<SRCTYPE>::Minimum() || uresult > NumericLimits<SRCTYPE>::Maximum()) {
-			return false;
-		}
-		result = SRCTYPE(uresult);
-		return true;
-	}
-};
-
-template <>
-bool TryMultiplyOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
-	return OverflowCheckedMultiply::Operation<uint8_t, uint16_t>(left, right, result);
-}
-template <>
-bool TryMultiplyOperator::Operation(uint16_t left, uint16_t right, uint16_t &result) {
-	return OverflowCheckedMultiply::Operation<uint16_t, uint32_t>(left, right, result);
-}
-template <>
-bool TryMultiplyOperator::Operation(uint32_t left, uint32_t right, uint32_t &result) {
-	return OverflowCheckedMultiply::Operation<uint32_t, uint64_t>(left, right, result);
-}
-template <>
-bool TryMultiplyOperator::Operation(uint64_t left, uint64_t right, uint64_t &result) {
-	if (left > right) {
-		std::swap(left, right);
-	}
-	if (left > NumericLimits<uint32_t>::Maximum()) {
-		return false;
-	}
-	uint32_t c = right >> 32;
-	uint32_t d = NumericLimits<uint32_t>::Maximum() & right;
-	uint64_t r = left * c;
-	uint64_t s = left * d;
-	if (r > NumericLimits<uint32_t>::Maximum()) {
-		return false;
-	}
-	r <<= 32;
-	if (NumericLimits<uint64_t>::Maximum() - s < r) {
-		return false;
-	}
-	return OverflowCheckedMultiply::Operation<uint64_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(int8_t left, int8_t right, int8_t &result) {
-	return OverflowCheckedMultiply::Operation<int8_t, int16_t>(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(int16_t left, int16_t right, int16_t &result) {
-	return OverflowCheckedMultiply::Operation<int16_t, int32_t>(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(int32_t left, int32_t right, int32_t &result) {
-	return OverflowCheckedMultiply::Operation<int32_t, int64_t>(left, right, result);
-}
-
-template <>
-bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result) {
-#if (__GNUC__ >= 5) || defined(__clang__)
-	if (__builtin_mul_overflow(left, right, &result)) {
-		return false;
-	}
-#else
-	if (left == std::numeric_limits<int64_t>::min()) {
-		if (right == 0) {
-			result = 0;
-			return true;
-		}
-		if (right == 1) {
-			result = left;
-			return true;
-		}
-		return false;
-	}
-	if (right == std::numeric_limits<int64_t>::min()) {
-		if (left == 0) {
-			result = 0;
-			return true;
-		}
-		if (left == 1) {
-			result = right;
-			return true;
-		}
-		return false;
-	}
-	uint64_t left_non_negative = uint64_t(std::abs(left));
-	uint64_t right_non_negative = uint64_t(std::abs(right));
-	// split values into 2 32-bit parts
-	uint64_t left_high_bits = left_non_negative >> 32;
-	uint64_t left_low_bits = left_non_negative & 0xffffffff;
-	uint64_t right_high_bits = right_non_negative >> 32;
-	uint64_t right_low_bits = right_non_negative & 0xffffffff;
-
-	// check the high bits of both
-	// the high bits define the overflow
-	if (left_high_bits == 0) {
-		if (right_high_bits != 0) {
-			// only the right has high bits set
-			// multiply the high bits of right with the low bits of left
-			// multiply the low bits, and carry any overflow to the high bits
-			// then check for any overflow
-			auto low_low = left_low_bits * right_low_bits;
-			auto low_high = left_low_bits * right_high_bits;
-			auto high_bits = low_high + (low_low >> 32);
-			if (high_bits & 0xffffff80000000) {
-				// there is! abort
-				return false;
-			}
-		}
-	} else if (right_high_bits == 0) {
-		// only the left has high bits set
-		// multiply the high bits of left with the low bits of right
-		// multiply the low bits, and carry any overflow to the high bits
-		// then check for any overflow
-		auto low_low = left_low_bits * right_low_bits;
-		auto high_low = left_high_bits * right_low_bits;
-		auto high_bits = high_low + (low_low >> 32);
-		if (high_bits & 0xffffff80000000) {
-			// there is! abort
-			return false;
-		}
-	} else {
-		// both left and right have high bits set: guaranteed overflow
-		// abort!
-		return false;
-	}
-	// now we know that there is no overflow, we can just perform the multiplication
-	result = left * right;
-#endif
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// multiply  decimal with overflow check
-//===--------------------------------------------------------------------===//
-template <class T, T min, T max>
-bool TryDecimalMultiplyTemplated(T left, T right, T &result) {
-	if (!TryMultiplyOperator::Operation(left, right, result) || result < min || result > max) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool TryDecimalMultiply::Operation(int16_t left, int16_t right, int16_t &result) {
-	return TryDecimalMultiplyTemplated<int16_t, -9999, 9999>(left, right, result);
-}
-
-template <>
-bool TryDecimalMultiply::Operation(int32_t left, int32_t right, int32_t &result) {
-	return TryDecimalMultiplyTemplated<int32_t, -999999999, 999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalMultiply::Operation(int64_t left, int64_t right, int64_t &result) {
-	return TryDecimalMultiplyTemplated<int64_t, -999999999999999999, 999999999999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalMultiply::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	result = left * right;
-	if (result <= -Hugeint::POWERS_OF_TEN[38] || result >= Hugeint::POWERS_OF_TEN[38]) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-hugeint_t DecimalMultiplyOverflowCheck::Operation(hugeint_t left, hugeint_t right) {
-	hugeint_t result;
-	if (!TryDecimalMultiply::Operation(left, right, result)) {
-		throw OutOfRangeException("Overflow in multiplication of DECIMAL(38) (%s * %s). You might want to add an "
-		                          "explicit cast to a decimal with a smaller scale.",
-		                          left.ToString(), right.ToString());
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-#include <limits>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// - [subtract]
-//===--------------------------------------------------------------------===//
-template <>
-float SubtractOperator::Operation(float left, float right) {
-	auto result = left - right;
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in subtraction of float!");
-	}
-	return result;
-}
-
-template <>
-double SubtractOperator::Operation(double left, double right) {
-	auto result = left - right;
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in subtraction of double!");
-	}
-	return result;
-}
-
-template <>
-int64_t SubtractOperator::Operation(date_t left, date_t right) {
-	return int64_t(left.days) - int64_t(right.days);
-}
-
-template <>
-date_t SubtractOperator::Operation(date_t left, int32_t right) {
-	if (!Date::IsFinite(left)) {
-		return left;
-	}
-	int32_t days;
-	if (!TrySubtractOperator::Operation(left.days, right, days)) {
-		throw OutOfRangeException("Date out of range");
-	}
-
-	date_t result(days);
-	if (!Date::IsFinite(result)) {
-		throw OutOfRangeException("Date out of range");
-	}
-	return result;
-}
-
-template <>
-interval_t SubtractOperator::Operation(interval_t left, interval_t right) {
-	interval_t result;
-	result.months = left.months - right.months;
-	result.days = left.days - right.days;
-	result.micros = left.micros - right.micros;
-	return result;
-}
-
-template <>
-date_t SubtractOperator::Operation(date_t left, interval_t right) {
-	right.months = -right.months;
-	right.days = -right.days;
-	right.micros = -right.micros;
-	return AddOperator::Operation<date_t, interval_t, date_t>(left, right);
-}
-
-template <>
-timestamp_t SubtractOperator::Operation(timestamp_t left, interval_t right) {
-	right.months = -right.months;
-	right.days = -right.days;
-	right.micros = -right.micros;
-	return AddOperator::Operation<timestamp_t, interval_t, timestamp_t>(left, right);
-}
-
-template <>
-interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right) {
-	return Interval::GetDifference(left, right);
-}
-
-//===--------------------------------------------------------------------===//
-// - [subtract] with overflow check
-//===--------------------------------------------------------------------===//
-struct OverflowCheckedSubtract {
-	template <class SRCTYPE, class UTYPE>
-	static inline bool Operation(SRCTYPE left, SRCTYPE right, SRCTYPE &result) {
-		UTYPE uresult = SubtractOperator::Operation<UTYPE, UTYPE, UTYPE>(UTYPE(left), UTYPE(right));
-		if (uresult < NumericLimits<SRCTYPE>::Minimum() || uresult > NumericLimits<SRCTYPE>::Maximum()) {
-			return false;
-		}
-		result = SRCTYPE(uresult);
-		return true;
-	}
-};
-
-template <>
-bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result) {
-	if (right > left) {
-		return false;
-	}
-	return OverflowCheckedSubtract::Operation<uint8_t, uint16_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(uint16_t left, uint16_t right, uint16_t &result) {
-	if (right > left) {
-		return false;
-	}
-	return OverflowCheckedSubtract::Operation<uint16_t, uint32_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(uint32_t left, uint32_t right, uint32_t &result) {
-	if (right > left) {
-		return false;
-	}
-	return OverflowCheckedSubtract::Operation<uint32_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(uint64_t left, uint64_t right, uint64_t &result) {
-	if (right > left) {
-		return false;
-	}
-	return OverflowCheckedSubtract::Operation<uint64_t, uint64_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(int8_t left, int8_t right, int8_t &result) {
-	return OverflowCheckedSubtract::Operation<int8_t, int16_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(int16_t left, int16_t right, int16_t &result) {
-	return OverflowCheckedSubtract::Operation<int16_t, int32_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(int32_t left, int32_t right, int32_t &result) {
-	return OverflowCheckedSubtract::Operation<int32_t, int64_t>(left, right, result);
-}
-
-template <>
-bool TrySubtractOperator::Operation(int64_t left, int64_t right, int64_t &result) {
-#if (__GNUC__ >= 5) || defined(__clang__)
-	if (__builtin_sub_overflow(left, right, &result)) {
-		return false;
-	}
-#else
-	if (right < 0) {
-		if (NumericLimits<int64_t>::Maximum() + right < left) {
-			return false;
-		}
-	} else {
-		if (NumericLimits<int64_t>::Minimum() + right > left) {
-			return false;
-		}
-	}
-	result = left - right;
-#endif
-	return true;
-}
-
-template <>
-bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	result = left;
-	return Hugeint::SubtractInPlace(result, right);
-}
-
-//===--------------------------------------------------------------------===//
-// subtract decimal with overflow check
-//===--------------------------------------------------------------------===//
-template <class T, T min, T max>
-bool TryDecimalSubtractTemplated(T left, T right, T &result) {
-	if (right < 0) {
-		if (max + right < left) {
-			return false;
-		}
-	} else {
-		if (min + right > left) {
-			return false;
-		}
-	}
-	result = left - right;
-	return true;
-}
-
-template <>
-bool TryDecimalSubtract::Operation(int16_t left, int16_t right, int16_t &result) {
-	return TryDecimalSubtractTemplated<int16_t, -9999, 9999>(left, right, result);
-}
-
-template <>
-bool TryDecimalSubtract::Operation(int32_t left, int32_t right, int32_t &result) {
-	return TryDecimalSubtractTemplated<int32_t, -999999999, 999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalSubtract::Operation(int64_t left, int64_t right, int64_t &result) {
-	return TryDecimalSubtractTemplated<int64_t, -999999999999999999, 999999999999999999>(left, right, result);
-}
-
-template <>
-bool TryDecimalSubtract::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
-	result = left - right;
-	if (result <= -Hugeint::POWERS_OF_TEN[38] || result >= Hugeint::POWERS_OF_TEN[38]) {
-		return false;
-	}
-	return true;
-}
-
-template <>
-hugeint_t DecimalSubtractOverflowCheck::Operation(hugeint_t left, hugeint_t right) {
-	hugeint_t result;
-	if (!TryDecimalSubtract::Operation(left, right, result)) {
-		throw OutOfRangeException("Overflow in subtract of DECIMAL(38) (%s - %s);", left.ToString(), right.ToString());
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// subtract time operator
-//===--------------------------------------------------------------------===//
-template <>
-dtime_t SubtractTimeOperator::Operation(dtime_t left, interval_t right) {
-	right.micros = -right.micros;
-	return AddTimeOperator::Operation<dtime_t, interval_t, dtime_t>(left, right);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterOperators() {
-	Register<AddFun>();
-	Register<SubtractFun>();
-	Register<MultiplyFun>();
-	Register<DivideFun>();
-	Register<ModFun>();
-	Register<LeftShiftFun>();
-	Register<RightShiftFun>();
-	Register<BitwiseAndFun>();
-	Register<BitwiseOrFun>();
-	Register<BitwiseXorFun>();
-	Register<BitwiseNotFun>();
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterPragmaFunctions() {
-	Register<PragmaQueries>();
-	Register<PragmaFunctions>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct NextvalBindData : public FunctionData {
-	//! The client context for the function call
-	ClientContext &context;
-	//! The sequence to use for the nextval computation; only if
-	SequenceCatalogEntry *sequence;
-
-	NextvalBindData(ClientContext &context, SequenceCatalogEntry *sequence) : context(context), sequence(sequence) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<NextvalBindData>(context, sequence);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (NextvalBindData &)other_p;
-		return sequence == other.sequence;
-	}
-};
-
-struct CurrentSequenceValueOperator {
-	static int64_t Operation(Transaction &transaction, SequenceCatalogEntry *seq) {
-		lock_guard<mutex> seqlock(seq->lock);
-		int64_t result;
-		if (seq->usage_count == 0u) {
-			throw SequenceException("currval: sequence is not yet defined in this session");
-		}
-		result = seq->last_value;
-		return result;
-	}
-};
-
-struct NextSequenceValueOperator {
-	static int64_t Operation(Transaction &transaction, SequenceCatalogEntry *seq) {
-		lock_guard<mutex> seqlock(seq->lock);
-		int64_t result;
-		result = seq->counter;
-		bool overflow = !TryAddOperator::Operation(seq->counter, seq->increment, seq->counter);
-		if (seq->cycle) {
-			if (overflow) {
-				seq->counter = seq->increment < 0 ? seq->max_value : seq->min_value;
-			} else if (seq->counter < seq->min_value) {
-				seq->counter = seq->max_value;
-			} else if (seq->counter > seq->max_value) {
-				seq->counter = seq->min_value;
-			}
-		} else {
-			if (result < seq->min_value || (overflow && seq->increment < 0)) {
-				throw SequenceException("nextval: reached minimum value of sequence \"%s\" (%lld)", seq->name,
-				                        seq->min_value);
-			}
-			if (result > seq->max_value || overflow) {
-				throw SequenceException("nextval: reached maximum value of sequence \"%s\" (%lld)", seq->name,
-				                        seq->max_value);
-			}
-		}
-		seq->last_value = result;
-		seq->usage_count++;
-		transaction.sequence_usage[seq] = SequenceValue(seq->usage_count, seq->counter);
-		return result;
-	}
-};
-
-struct NextValData {
-	NextValData(NextvalBindData &bind_data_p, Transaction &transaction_p)
-	    : bind_data(bind_data_p), transaction(transaction_p) {
-	}
-
-	NextvalBindData &bind_data;
-	Transaction &transaction;
-};
-
-template <class OP>
-static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (NextvalBindData &)*func_expr.bind_info;
-	auto &input = args.data[0];
-
-	auto &transaction = Transaction::GetTransaction(info.context);
-	if (info.sequence) {
-		// sequence to use is hard coded
-		// increment the sequence
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<int64_t>(result);
-		for (idx_t i = 0; i < args.size(); i++) {
-			// get the next value from the sequence
-			result_data[i] = OP::Operation(transaction, info.sequence);
-		}
-	} else {
-		NextValData next_val_input(info, transaction);
-		// sequence to use comes from the input
-		UnaryExecutor::Execute<string_t, int64_t>(input, result, args.size(), [&](string_t value) {
-			auto qname = QualifiedName::Parse(value.GetString());
-			// fetch the sequence from the catalog
-			auto sequence = Catalog::GetCatalog(info.context)
-			                    .GetEntry<SequenceCatalogEntry>(info.context, qname.schema, qname.name);
-			// finally get the next value from the sequence
-			return OP::Operation(transaction, sequence);
-		});
-	}
-}
-
-static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	SequenceCatalogEntry *sequence = nullptr;
-	if (arguments[0]->IsFoldable()) {
-		// parameter to nextval function is a foldable constant
-		// evaluate the constant and perform the catalog lookup already
-		auto seqname = ExpressionExecutor::EvaluateScalar(*arguments[0]);
-		if (!seqname.IsNull()) {
-			D_ASSERT(seqname.type().id() == LogicalTypeId::VARCHAR);
-			auto qname = QualifiedName::Parse(StringValue::Get(seqname));
-			sequence = Catalog::GetCatalog(context).GetEntry<SequenceCatalogEntry>(context, qname.schema, qname.name);
-		}
-	}
-	return make_unique<NextvalBindData>(context, sequence);
-}
-
-static void NextValDependency(BoundFunctionExpression &expr, unordered_set<CatalogEntry *> &dependencies) {
-	auto &info = (NextvalBindData &)*expr.bind_info;
-	if (info.sequence) {
-		dependencies.insert(info.sequence);
-	}
-}
-
-void NextvalFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("nextval", {LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                               NextValFunction<NextSequenceValueOperator>, true, NextValBind, NextValDependency));
-}
-
-void CurrvalFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("currval", {LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                               NextValFunction<CurrentSequenceValueOperator>, true, NextValBind,
-	                               NextValDependency));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterSequenceFunctions() {
-	Register<NextvalFun>();
-	Register<CurrvalFun>();
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct AsciiOperator {
-	template <class TA, class TR>
-	static inline TR Operation(const TA &input) {
-		auto str = input.GetDataUnsafe();
-		if (Utf8Proc::Analyze(str, input.GetSize()) == UnicodeType::ASCII) {
-			return str[0];
-		}
-		int utf8_bytes = 4;
-		return Utf8Proc::UTF8ToCodepoint(str, utf8_bytes);
-	}
-};
-
-void ASCII::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction ascii("ascii", {LogicalType::VARCHAR}, LogicalType::INTEGER,
-	                     ScalarFunction::UnaryFunction<string_t, int32_t, AsciiOperator>);
-	set.AddFunction(ascii);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-#include <string.h>
-
-namespace duckdb {
-
-uint8_t UpperFun::ascii_to_upper_map[] = {
-    0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
-    22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
-    44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,
-    66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,
-    88,  89,  90,  91,  92,  93,  94,  95,  96,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
-    78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  123, 124, 125, 126, 127, 128, 129, 130, 131,
-    132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
-    154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
-    198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-    220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
-    242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254};
-uint8_t LowerFun::ascii_to_lower_map[] = {
-    0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
-    22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
-    44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  97,
-    98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
-    120, 121, 122, 91,  92,  93,  94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
-    110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
-    132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
-    154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
-    198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-    220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
-    242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254};
-
-template <bool IS_UPPER>
-static string_t ASCIICaseConvert(Vector &result, const char *input_data, idx_t input_length) {
-	idx_t output_length = input_length;
-	auto result_str = StringVector::EmptyString(result, output_length);
-	auto result_data = result_str.GetDataWriteable();
-	for (idx_t i = 0; i < input_length; i++) {
-		result_data[i] = IS_UPPER ? UpperFun::ascii_to_upper_map[uint8_t(input_data[i])]
-		                          : LowerFun::ascii_to_lower_map[uint8_t(input_data[i])];
-	}
-	result_str.Finalize();
-	return result_str;
-}
-
-template <bool IS_UPPER>
-static idx_t GetResultLength(const char *input_data, idx_t input_length) {
-	idx_t output_length = 0;
-	for (idx_t i = 0; i < input_length;) {
-		if (input_data[i] & 0x80) {
-			// unicode
-			int sz = 0;
-			int codepoint = utf8proc_codepoint(input_data + i, sz);
-			int converted_codepoint = IS_UPPER ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint);
-			int new_sz = utf8proc_codepoint_length(converted_codepoint);
-			D_ASSERT(new_sz >= 0);
-			output_length += new_sz;
-			i += sz;
-		} else {
-			// ascii
-			output_length++;
-			i++;
-		}
-	}
-	return output_length;
-}
-
-template <bool IS_UPPER>
-static void CaseConvert(const char *input_data, idx_t input_length, char *result_data) {
-	for (idx_t i = 0; i < input_length;) {
-		if (input_data[i] & 0x80) {
-			// non-ascii character
-			int sz = 0, new_sz = 0;
-			int codepoint = utf8proc_codepoint(input_data + i, sz);
-			int converted_codepoint = IS_UPPER ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint);
-			auto success = utf8proc_codepoint_to_utf8(converted_codepoint, new_sz, result_data);
-			D_ASSERT(success);
-			(void)success;
-			result_data += new_sz;
-			i += sz;
-		} else {
-			// ascii
-			*result_data = IS_UPPER ? UpperFun::ascii_to_upper_map[uint8_t(input_data[i])]
-			                        : LowerFun::ascii_to_lower_map[uint8_t(input_data[i])];
-			result_data++;
-			i++;
-		}
-	}
-}
-
-idx_t LowerFun::LowerLength(const char *input_data, idx_t input_length) {
-	return GetResultLength<false>(input_data, input_length);
-}
-
-void LowerFun::LowerCase(const char *input_data, idx_t input_length, char *result_data) {
-	CaseConvert<false>(input_data, input_length, result_data);
-}
-
-template <bool IS_UPPER>
-static string_t UnicodeCaseConvert(Vector &result, const char *input_data, idx_t input_length) {
-	// first figure out the output length
-	idx_t output_length = GetResultLength<IS_UPPER>(input_data, input_length);
-	auto result_str = StringVector::EmptyString(result, output_length);
-	auto result_data = result_str.GetDataWriteable();
-
-	CaseConvert<IS_UPPER>(input_data, input_length, result_data);
-	result_str.Finalize();
-	return result_str;
-}
-
-template <bool IS_UPPER>
-struct CaseConvertOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetDataUnsafe();
-		auto input_length = input.GetSize();
-		return UnicodeCaseConvert<IS_UPPER>(result, input_data, input_length);
-	}
-};
-
-template <bool IS_UPPER>
-static void CaseConvertFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, CaseConvertOperator<IS_UPPER>>(args.data[0], result, args.size());
-}
-
-template <bool IS_UPPER>
-struct CaseConvertOperatorASCII {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetDataUnsafe();
-		auto input_length = input.GetSize();
-		return ASCIICaseConvert<IS_UPPER>(result, input_data, input_length);
-	}
-};
-
-template <bool IS_UPPER>
-static void CaseConvertFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, CaseConvertOperatorASCII<IS_UPPER>>(args.data[0], result,
-	                                                                                     args.size());
-}
-
-template <bool IS_UPPER>
-static unique_ptr<BaseStatistics> CaseConvertPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 1);
-	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
-		expr.function.function = CaseConvertFunctionASCII<IS_UPPER>;
-	}
-	return nullptr;
-}
-
-ScalarFunction LowerFun::GetFunction() {
-	return ScalarFunction("lower", {LogicalType::VARCHAR}, LogicalType::VARCHAR, CaseConvertFunction<false>, false,
-	                      nullptr, nullptr, CaseConvertPropagateStats<false>);
-}
-
-void LowerFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"lower", "lcase"}, LowerFun::GetFunction());
-}
-
-void UpperFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"upper", "ucase"},
-	                ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, CaseConvertFunction<true>, false,
-	                               false, nullptr, nullptr, CaseConvertPropagateStats<true>));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct ChrOperator {
-	template <class TA, class TR>
-	static inline TR Operation(const TA &input) {
-		char c[5] = {'\0', '\0', '\0', '\0', '\0'};
-		int utf8_bytes = 4;
-		if (input < 0 || !Utf8Proc::CodepointToUtf8(input, utf8_bytes, &c[0])) {
-			throw InvalidInputException("Invalid UTF8 Codepoint %d", input);
-		}
-		return string_t(&c[0]);
-	}
-};
-
-void CHR::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction chr("chr", {LogicalType::INTEGER}, LogicalType::VARCHAR,
-	                   ScalarFunction::UnaryFunction<int32_t, string_t, ChrOperator>);
-	set.AddFunction(chr);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <string.h>
-
-namespace duckdb {
-
-static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	// iterate over the vectors to count how large the final string will be
-	idx_t constant_lengths = 0;
-	vector<idx_t> result_lengths(args.size(), 0);
-	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-		auto &input = args.data[col_idx];
-		D_ASSERT(input.GetType().id() == LogicalTypeId::VARCHAR);
-		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			if (ConstantVector::IsNull(input)) {
-				// constant null, skip
-				continue;
-			}
-			auto input_data = ConstantVector::GetData<string_t>(input);
-			constant_lengths += input_data->GetSize();
-		} else {
-			// non-constant vector: set the result type to a flat vector
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			// now get the lengths of each of the input elements
-			VectorData vdata;
-			input.Orrify(args.size(), vdata);
-
-			auto input_data = (string_t *)vdata.data;
-			// now add the length of each vector to the result length
-			for (idx_t i = 0; i < args.size(); i++) {
-				auto idx = vdata.sel->get_index(i);
-				if (!vdata.validity.RowIsValid(idx)) {
-					continue;
-				}
-				result_lengths[i] += input_data[idx].GetSize();
-			}
-		}
-	}
-
-	// first we allocate the empty strings for each of the values
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t i = 0; i < args.size(); i++) {
-		// allocate an empty string of the required size
-		idx_t str_length = constant_lengths + result_lengths[i];
-		result_data[i] = StringVector::EmptyString(result, str_length);
-		// we reuse the result_lengths vector to store the currently appended size
-		result_lengths[i] = 0;
-	}
-
-	// now that the empty space for the strings has been allocated, perform the concatenation
-	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-		auto &input = args.data[col_idx];
-
-		// loop over the vector and concat to all results
-		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			// constant vector
-			if (ConstantVector::IsNull(input)) {
-				// constant null, skip
-				continue;
-			}
-			// append the constant vector to each of the strings
-			auto input_data = ConstantVector::GetData<string_t>(input);
-			auto input_ptr = input_data->GetDataUnsafe();
-			auto input_len = input_data->GetSize();
-			for (idx_t i = 0; i < args.size(); i++) {
-				memcpy(result_data[i].GetDataWriteable() + result_lengths[i], input_ptr, input_len);
-				result_lengths[i] += input_len;
-			}
-		} else {
-			// standard vector
-			VectorData idata;
-			input.Orrify(args.size(), idata);
-
-			auto input_data = (string_t *)idata.data;
-			for (idx_t i = 0; i < args.size(); i++) {
-				auto idx = idata.sel->get_index(i);
-				if (!idata.validity.RowIsValid(idx)) {
-					continue;
-				}
-				auto input_ptr = input_data[idx].GetDataUnsafe();
-				auto input_len = input_data[idx].GetSize();
-				memcpy(result_data[i].GetDataWriteable() + result_lengths[i], input_ptr, input_len);
-				result_lengths[i] += input_len;
-			}
-		}
-	}
-	for (idx_t i = 0; i < args.size(); i++) {
-		result_data[i].Finalize();
-	}
-}
-
-static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, string_t, string_t>(
-	    args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b) {
-		    auto a_data = a.GetDataUnsafe();
-		    auto b_data = b.GetDataUnsafe();
-		    auto a_length = a.GetSize();
-		    auto b_length = b.GetSize();
-
-		    auto target_length = a_length + b_length;
-		    auto target = StringVector::EmptyString(result, target_length);
-		    auto target_data = target.GetDataWriteable();
-
-		    memcpy(target_data, a_data, a_length);
-		    memcpy(target_data + a_length, b_data, b_length);
-		    target.Finalize();
-		    return target;
-	    });
-}
-
-static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const SelectionVector &sep_sel,
-                              const SelectionVector &rsel, idx_t count, Vector &result) {
-	vector<idx_t> result_lengths(args.size(), 0);
-	vector<bool> has_results(args.size(), false);
-	auto orrified_data = unique_ptr<VectorData[]>(new VectorData[args.ColumnCount() - 1]);
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		args.data[col_idx].Orrify(args.size(), orrified_data[col_idx - 1]);
-	}
-
-	// first figure out the lengths
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		auto &idata = orrified_data[col_idx - 1];
-
-		auto input_data = (string_t *)idata.data;
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = rsel.get_index(i);
-			auto sep_idx = sep_sel.get_index(ridx);
-			auto idx = idata.sel->get_index(ridx);
-			if (!idata.validity.RowIsValid(idx)) {
-				continue;
-			}
-			if (has_results[ridx]) {
-				result_lengths[ridx] += sep_data[sep_idx].GetSize();
-			}
-			result_lengths[ridx] += input_data[idx].GetSize();
-			has_results[ridx] = true;
-		}
-	}
-
-	// first we allocate the empty strings for each of the values
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t i = 0; i < count; i++) {
-		auto ridx = rsel.get_index(i);
-		// allocate an empty string of the required size
-		result_data[ridx] = StringVector::EmptyString(result, result_lengths[ridx]);
-		// we reuse the result_lengths vector to store the currently appended size
-		result_lengths[ridx] = 0;
-		has_results[ridx] = false;
-	}
-
-	// now that the empty space for the strings has been allocated, perform the concatenation
-	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		auto &idata = orrified_data[col_idx - 1];
-		auto input_data = (string_t *)idata.data;
-		for (idx_t i = 0; i < count; i++) {
-			auto ridx = rsel.get_index(i);
-			auto sep_idx = sep_sel.get_index(ridx);
-			auto idx = idata.sel->get_index(ridx);
-			if (!idata.validity.RowIsValid(idx)) {
-				continue;
-			}
-			if (has_results[ridx]) {
-				auto sep_size = sep_data[sep_idx].GetSize();
-				auto sep_ptr = sep_data[sep_idx].GetDataUnsafe();
-				memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], sep_ptr, sep_size);
-				result_lengths[ridx] += sep_size;
-			}
-			auto input_ptr = input_data[idx].GetDataUnsafe();
-			auto input_len = input_data[idx].GetSize();
-			memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], input_ptr, input_len);
-			result_lengths[ridx] += input_len;
-			has_results[ridx] = true;
-		}
-	}
-	for (idx_t i = 0; i < count; i++) {
-		auto ridx = rsel.get_index(i);
-		result_data[ridx].Finalize();
-	}
-}
-
-static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &separator = args.data[0];
-	VectorData vdata;
-	separator.Orrify(args.size(), vdata);
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
-		if (args.data[col_idx].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			break;
-		}
-	}
-	switch (separator.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR: {
-		if (ConstantVector::IsNull(separator)) {
-			// constant NULL as separator: return constant NULL vector
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-		// no null values
-		auto sel = FlatVector::IncrementalSelectionVector();
-		TemplatedConcatWS(args, (string_t *)vdata.data, *vdata.sel, *sel, args.size(), result);
-		return;
-	}
-	default: {
-		// default case: loop over nullmask and create a non-null selection vector
-		idx_t not_null_count = 0;
-		SelectionVector not_null_vector(STANDARD_VECTOR_SIZE);
-		auto &result_mask = FlatVector::Validity(result);
-		for (idx_t i = 0; i < args.size(); i++) {
-			if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
-				result_mask.SetInvalid(i);
-			} else {
-				not_null_vector.set_index(not_null_count++, i);
-			}
-		}
-		TemplatedConcatWS(args, (string_t *)vdata.data, *vdata.sel, not_null_vector, not_null_count, result);
-		return;
-	}
-	}
-}
-
-void ConcatFun::RegisterFunction(BuiltinFunctions &set) {
-	// the concat operator and concat function have different behavior regarding NULLs
-	// this is strange but seems consistent with postgresql and mysql
-	// (sqlite does not support the concat function, only the concat operator)
-
-	// the concat operator behaves as one would expect: any NULL value present results in a NULL
-	// i.e. NULL || 'hello' = NULL
-	// the concat function, however, treats NULL values as an empty string
-	// i.e. concat(NULL, 'hello') = 'hello'
-	// concat_ws functions similarly to the concat function, except the result is NULL if the separator is NULL
-	// if the separator is not NULL, however, NULL values are counted as empty string
-	// there is one separate rule: there are no separators added between NULL values
-	// so the NULL value and empty string are different!
-	// e.g.:
-	// concat_ws(',', NULL, NULL) = ""
-	// concat_ws(',', '', '') = ","
-	ScalarFunction concat = ScalarFunction("concat", {LogicalType::VARCHAR}, LogicalType::VARCHAR, ConcatFunction);
-	concat.varargs = LogicalType::VARCHAR;
-	concat.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(concat);
-
-	ScalarFunctionSet concat_op("||");
-	concat_op.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR, ConcatOperator));
-	concat_op.AddFunction(ScalarFunction({LogicalType::BLOB, LogicalType::BLOB}, LogicalType::BLOB, ConcatOperator));
-	concat_op.AddFunction(ListConcatFun::GetFunction());
-	for (auto &fun : concat_op.functions) {
-		fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	}
-	set.AddFunction(concat_op);
-
-	ScalarFunction concat_ws = ScalarFunction("concat_ws", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                          LogicalType::VARCHAR, ConcatWSFunction);
-	concat_ws.varargs = LogicalType::VARCHAR;
-	concat_ws.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(concat_ws);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-template <class UNSIGNED, int NEEDLE_SIZE>
-static idx_t ContainsUnaligned(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-                               idx_t base_offset) {
-	if (NEEDLE_SIZE > haystack_size) {
-		// needle is bigger than haystack: haystack cannot contain needle
-		return DConstants::INVALID_INDEX;
-	}
-	// contains for a small unaligned needle (3/5/6/7 bytes)
-	// we perform unsigned integer comparisons to check for equality of the entire needle in a single comparison
-	// this implementation is inspired by the memmem implementation of freebsd
-
-	// first we set up the needle and the first NEEDLE_SIZE characters of the haystack as UNSIGNED integers
-	UNSIGNED needle_entry = 0;
-	UNSIGNED haystack_entry = 0;
-	const UNSIGNED start = (sizeof(UNSIGNED) * 8) - 8;
-	const UNSIGNED shift = (sizeof(UNSIGNED) - NEEDLE_SIZE) * 8;
-	for (int i = 0; i < NEEDLE_SIZE; i++) {
-		needle_entry |= UNSIGNED(needle[i]) << UNSIGNED(start - i * 8);
-		haystack_entry |= UNSIGNED(haystack[i]) << UNSIGNED(start - i * 8);
-	}
-	// now we perform the actual search
-	for (idx_t offset = NEEDLE_SIZE; offset < haystack_size; offset++) {
-		// for this position we first compare the haystack with the needle
-		if (haystack_entry == needle_entry) {
-			return base_offset + offset - NEEDLE_SIZE;
-		}
-		// now we adjust the haystack entry by
-		// (1) removing the left-most character (shift by 8)
-		// (2) adding the next character (bitwise or, with potential shift)
-		// this shift is only necessary if the needle size is not aligned with the unsigned integer size
-		// (e.g. needle size 3, unsigned integer size 4, we need to shift by 1)
-		haystack_entry = (haystack_entry << 8) | ((UNSIGNED(haystack[offset])) << shift);
-	}
-	if (haystack_entry == needle_entry) {
-		return base_offset + haystack_size - NEEDLE_SIZE;
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-template <class UNSIGNED>
-static idx_t ContainsAligned(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-                             idx_t base_offset) {
-	if (sizeof(UNSIGNED) > haystack_size) {
-		// needle is bigger than haystack: haystack cannot contain needle
-		return DConstants::INVALID_INDEX;
-	}
-	// contains for a small needle aligned with unsigned integer (2/4/8)
-	// similar to ContainsUnaligned, but simpler because we only need to do a reinterpret cast
-	auto needle_entry = Load<UNSIGNED>(needle);
-	for (idx_t offset = 0; offset <= haystack_size - sizeof(UNSIGNED); offset++) {
-		// for this position we first compare the haystack with the needle
-		auto haystack_entry = Load<UNSIGNED>(haystack + offset);
-		if (needle_entry == haystack_entry) {
-			return base_offset + offset;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-idx_t ContainsGeneric(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-                      idx_t needle_size, idx_t base_offset) {
-	if (needle_size > haystack_size) {
-		// needle is bigger than haystack: haystack cannot contain needle
-		return DConstants::INVALID_INDEX;
-	}
-	// this implementation is inspired by Raphael Javaux's faststrstr (https://github.com/RaphaelJ/fast_strstr)
-	// generic contains; note that we can't use strstr because we don't have null-terminated strings anymore
-	// we keep track of a shifting window sum of all characters with window size equal to needle_size
-	// this shifting sum is used to avoid calling into memcmp;
-	// we only need to call into memcmp when the window sum is equal to the needle sum
-	// when that happens, the characters are potentially the same and we call into memcmp to check if they are
-	uint32_t sums_diff = 0;
-	for (idx_t i = 0; i < needle_size; i++) {
-		sums_diff += haystack[i];
-		sums_diff -= needle[i];
-	}
-	idx_t offset = 0;
-	while (true) {
-		if (sums_diff == 0 && haystack[offset] == needle[0]) {
-			if (memcmp(haystack + offset, needle, needle_size) == 0) {
-				return base_offset + offset;
-			}
-		}
-		if (offset >= haystack_size - needle_size) {
-			return DConstants::INVALID_INDEX;
-		}
-		sums_diff -= haystack[offset];
-		sums_diff += haystack[offset + needle_size];
-		offset++;
-	}
-}
-
-idx_t ContainsFun::Find(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-                        idx_t needle_size) {
-	D_ASSERT(needle_size > 0);
-	// start off by performing a memchr to find the first character of the
-	auto location = memchr(haystack, needle[0], haystack_size);
-	if (location == nullptr) {
-		return DConstants::INVALID_INDEX;
-	}
-	idx_t base_offset = (const unsigned char *)location - haystack;
-	haystack_size -= base_offset;
-	haystack = (const unsigned char *)location;
-	// switch algorithm depending on needle size
-	switch (needle_size) {
-	case 1:
-		return base_offset;
-	case 2:
-		return ContainsAligned<uint16_t>(haystack, haystack_size, needle, base_offset);
-	case 3:
-		return ContainsUnaligned<uint32_t, 3>(haystack, haystack_size, needle, base_offset);
-	case 4:
-		return ContainsAligned<uint32_t>(haystack, haystack_size, needle, base_offset);
-	case 5:
-		return ContainsUnaligned<uint64_t, 5>(haystack, haystack_size, needle, base_offset);
-	case 6:
-		return ContainsUnaligned<uint64_t, 6>(haystack, haystack_size, needle, base_offset);
-	case 7:
-		return ContainsUnaligned<uint64_t, 7>(haystack, haystack_size, needle, base_offset);
-	case 8:
-		return ContainsAligned<uint64_t>(haystack, haystack_size, needle, base_offset);
-	default:
-		return ContainsGeneric(haystack, haystack_size, needle, needle_size, base_offset);
-	}
-}
-
-idx_t ContainsFun::Find(const string_t &haystack_s, const string_t &needle_s) {
-	auto haystack = (const unsigned char *)haystack_s.GetDataUnsafe();
-	auto haystack_size = haystack_s.GetSize();
-	auto needle = (const unsigned char *)needle_s.GetDataUnsafe();
-	auto needle_size = needle_s.GetSize();
-	if (needle_size == 0) {
-		// empty needle: always true
-		return 0;
-	}
-	return ContainsFun::Find(haystack, haystack_size, needle, needle_size);
-}
-
-struct ContainsOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return ContainsFun::Find(left, right) != DConstants::INVALID_INDEX;
-	}
-};
-
-ScalarFunction ContainsFun::GetFunction() {
-	return ScalarFunction("contains",                                   // name of the function
-	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list
-	                      LogicalType::BOOLEAN,                         // return type
-	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, ContainsOperator>);
-}
-
-void ContainsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(GetFunction());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct InstrOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA haystack, TB needle) {
-		int64_t string_position = 0;
-
-		auto location = ContainsFun::Find(haystack, needle);
-		if (location != DConstants::INVALID_INDEX) {
-			auto len = (utf8proc_ssize_t)location;
-			auto str = reinterpret_cast<const utf8proc_uint8_t *>(haystack.GetDataUnsafe());
-			D_ASSERT(len <= (utf8proc_ssize_t)haystack.GetSize());
-			for (++string_position; len > 0; ++string_position) {
-				utf8proc_int32_t codepoint;
-				auto bytes = utf8proc_iterate(str, len, &codepoint);
-				str += bytes;
-				len -= bytes;
-			}
-		}
-		return string_position;
-	}
-};
-
-struct InstrAsciiOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA haystack, TB needle) {
-		auto location = ContainsFun::Find(haystack, needle);
-		return location == DConstants::INVALID_INDEX ? 0 : location + 1;
-	}
-};
-
-static unique_ptr<BaseStatistics> InStrPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 2);
-	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	// for strpos, we only care if the FIRST string has unicode or not
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
-		expr.function.function = ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrAsciiOperator>;
-	}
-	return nullptr;
-}
-
-void InstrFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction instr("instr",                                      // name of the function
-	                     {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list
-	                     LogicalType::BIGINT,                          // return type
-	                     ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrOperator>, false, nullptr,
-	                     nullptr, InStrPropagateStats);
-	set.AddFunction(instr);
-	instr.name = "strpos";
-	set.AddFunction(instr);
-	instr.name = "position";
-	set.AddFunction(instr);
-}
-
-} // namespace duckdb
-
-
-
-
-#include <ctype.h>
-
-namespace duckdb {
-
-static inline map<char, idx_t> GetSet(const string_t &str) {
-	auto map_of_chars = map<char, idx_t> {};
-	idx_t str_len = str.GetSize();
-	auto s = str.GetDataUnsafe();
-
-	for (idx_t pos = 0; pos < str_len; pos++) {
-		map_of_chars.insert(std::make_pair(s[pos], 1));
-	}
-	return map_of_chars;
-}
-
-static double JaccardSimilarity(const string_t &str, const string_t &txt) {
-	if (str.GetSize() < 1 || txt.GetSize() < 1) {
-		throw InvalidInputException("Jaccard Function: An argument too short!");
-	}
-	map<char, idx_t> m_str, m_txt;
-
-	m_str = GetSet(str);
-	m_txt = GetSet(txt);
-
-	if (m_str.size() > m_txt.size()) {
-		m_str.swap(m_txt);
-	}
-
-	for (auto const &achar : m_str) {
-		++m_txt[achar.first];
-	}
-	// m_txt.size is now size of union.
-
-	idx_t size_intersect = 0;
-	for (const auto &apair : m_txt) {
-		if (apair.second > 1) {
-			size_intersect++;
-		}
-	}
-
-	return (double)size_intersect / (double)m_txt.size();
-}
-
-static double JaccardScalarFunction(Vector &result, const string_t str, string_t tgt) {
-	return (double)JaccardSimilarity(str, tgt);
-}
-
-static void JaccardFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &tgt_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, string_t, double>(
-	    str_vec, tgt_vec, result, args.size(),
-	    [&](string_t str, string_t tgt) { return JaccardScalarFunction(result, str, tgt); });
-}
-
-void JaccardFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet jaccard("jaccard");
-	jaccard.AddFunction(ScalarFunction("jaccard", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::DOUBLE,
-	                                   JaccardFunction)); // Pointer to function implementation
-	set.AddFunction(jaccard);
-}
-
-} // namespace duckdb
-
-
-
-#include <ctype.h>
-#include <algorithm>
-
-namespace duckdb {
-
-static string_t LeftScalarFunction(Vector &result, const string_t str, int64_t pos) {
-	if (pos >= 0) {
-		return SubstringFun::SubstringScalarFunction(result, str, 1, pos);
-	}
-
-	int64_t num_characters = LengthFun::Length<string_t, int64_t>(str);
-	pos = MaxValue<int64_t>(0, num_characters + pos);
-	return SubstringFun::SubstringScalarFunction(result, str, 1, pos);
-}
-
-static void LeftFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &pos_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    str_vec, pos_vec, result, args.size(),
-	    [&](string_t str, int64_t pos) { return LeftScalarFunction(result, str, pos); });
-}
-
-void LeftFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("left", {LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, LeftFunction));
-}
-
-static string_t RightScalarFunction(Vector &result, const string_t str, int64_t pos) {
-	int64_t num_characters = LengthFun::Length<string_t, int64_t>(str);
-	if (pos >= 0) {
-		int64_t len = MinValue<int64_t>(num_characters, pos);
-		int64_t start = num_characters - len + 1;
-		return SubstringFun::SubstringScalarFunction(result, str, start, len);
-	}
-
-	int64_t len = num_characters - MinValue<int64_t>(num_characters, -pos);
-	int64_t start = num_characters - len + 1;
-	return SubstringFun::SubstringScalarFunction(result, str, start, len);
-}
-
-static void RightFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &pos_vec = args.data[1];
-	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    str_vec, pos_vec, result, args.size(),
-	    [&](string_t str, int64_t pos) { return RightScalarFunction(result, str, pos); });
-}
-
-void RightFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("right", {LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, RightFunction));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-// length returns the size in characters
-struct StringLengthOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return LengthFun::Length<TA, TR>(input);
-	}
-};
-
-struct ArrayLengthOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return input.length;
-	}
-};
-
-struct ArrayLengthBinaryOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB dimension) {
-		if (dimension != 1) {
-			throw NotImplementedException("array_length for dimensions other than 1 not implemented");
-		}
-		return input.length;
-	}
-};
-
-// strlen returns the size in bytes
-struct StrLenOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return input.GetSize();
-	}
-};
-
-// bitlen returns the size in bits
-struct BitLenOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return 8 * input.GetSize();
-	}
-};
-
-static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() == 1);
-	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
-		expr.function.function = ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>;
-	}
-	return nullptr;
-}
-
-static unique_ptr<FunctionData> ListLengthBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	bound_function.arguments[0] = arguments[0]->return_type;
-	return nullptr;
-}
-
-void LengthFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction array_length_unary = ScalarFunction(
-	    {LogicalType::LIST(LogicalType::ANY)}, LogicalType::BIGINT,
-	    ScalarFunction::UnaryFunction<list_entry_t, int64_t, ArrayLengthOperator>, false, false, ListLengthBind);
-	ScalarFunctionSet length("length");
-	length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                                  ScalarFunction::UnaryFunction<string_t, int64_t, StringLengthOperator>, false,
-	                                  false, nullptr, nullptr, LengthPropagateStats));
-	length.AddFunction(array_length_unary);
-	set.AddFunction(length);
-	length.name = "len";
-	set.AddFunction(length);
-
-	ScalarFunctionSet array_length("array_length");
-	array_length.AddFunction(array_length_unary);
-	array_length.AddFunction(
-	    ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::BIGINT,
-	                   ScalarFunction::BinaryFunction<list_entry_t, int64_t, int64_t, ArrayLengthBinaryOperator>, false,
-	                   false, ListLengthBind));
-	set.AddFunction(array_length);
-
-	set.AddFunction(ScalarFunction("strlen", {LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                               ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>));
-	set.AddFunction(ScalarFunction("bit_length", {LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                               ScalarFunction::UnaryFunction<string_t, int64_t, BitLenOperator>));
-	// length for BLOB type
-	set.AddFunction(ScalarFunction("octet_length", {LogicalType::BLOB}, LogicalType::BIGINT,
-	                               ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>));
-}
-
-struct UnicodeOperator {
-	template <class TA, class TR>
-	static inline TR Operation(const TA &input) {
-		auto str = reinterpret_cast<const utf8proc_uint8_t *>(input.GetDataUnsafe());
-		auto len = input.GetSize();
-		utf8proc_int32_t codepoint;
-		(void)utf8proc_iterate(str, len, &codepoint);
-		return codepoint;
-	}
-};
-
-void UnicodeFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction unicode("unicode", {LogicalType::VARCHAR}, LogicalType::INTEGER,
-	                       ScalarFunction::UnaryFunction<string_t, int32_t, UnicodeOperator>);
-	set.AddFunction(unicode);
-	unicode.name = "ord";
-	set.AddFunction(unicode);
-}
-
-} // namespace duckdb
-
-
-
-
-#include <ctype.h>
-#include <algorithm>
-
-namespace duckdb {
-
-// See: https://www.kdnuggets.com/2020/10/optimizing-levenshtein-distance-measuring-text-similarity.html
-// And: Iterative 2-row algorithm: https://en.wikipedia.org/wiki/Levenshtein_distance
-// Note: A first implementation using the array algorithm version resulted in an error raised by duckdb
-// (too muach memory usage)
-
-static idx_t LevenshteinDistance(const string_t &txt, const string_t &tgt) {
-	auto txt_len = txt.GetSize();
-	auto tgt_len = tgt.GetSize();
-
-	if (txt_len < 1) {
-		throw InvalidInputException("Levenshtein Function: 1st argument too short");
-	}
-
-	if (tgt_len < 1) {
-		throw InvalidInputException("Levenshtein Function: 2nd argument too short");
-	}
-
-	auto txt_str = txt.GetDataUnsafe();
-	auto tgt_str = tgt.GetDataUnsafe();
-
-	// Create two working vectors
-	std::vector<idx_t> distances0(tgt_len + 1, 0);
-	std::vector<idx_t> distances1(tgt_len + 1, 0);
-
-	idx_t cost_substitution = 0;
-	idx_t cost_insertion = 0;
-	idx_t cost_deletion = 0;
-
-	// initialize distances0 vector
-	// edit distance for an empty txt string is just the number of characters to delete from tgt
-	for (idx_t pos_tgt = 0; pos_tgt <= tgt_len; pos_tgt++) {
-		distances0[pos_tgt] = pos_tgt;
-	}
-
-	for (idx_t pos_txt = 0; pos_txt < txt_len; pos_txt++) {
-		// calculate distances1 (current raw distances) from the previous row
-
-		distances1[0] = pos_txt + 1;
-
-		for (idx_t pos_tgt = 0; pos_tgt < tgt_len; pos_tgt++) {
-			cost_deletion = distances0[pos_tgt + 1] + 1;
-			cost_insertion = distances1[pos_tgt] + 1;
-			cost_substitution = distances0[pos_tgt];
-
-			if (txt_str[pos_txt] != tgt_str[pos_tgt]) {
-				cost_substitution += 1;
-			}
-
-			distances1[pos_tgt + 1] = MinValue(cost_deletion, MinValue(cost_substitution, cost_insertion));
-		}
-		// copy distances1 (current row) to distances0 (previous row) for next iteration
-		// since data in distances1 is always invalidated, a swap without copy is more efficient
-		distances0 = distances1;
-	}
-
-	return distances0[tgt_len];
-}
-
-static int64_t LevenshteinScalarFunction(Vector &result, const string_t str, string_t tgt) {
-	return (int64_t)LevenshteinDistance(str, tgt);
-}
-
-static void LevenshteinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &tgt_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, string_t, int64_t>(
-	    str_vec, tgt_vec, result, args.size(),
-	    [&](string_t str, string_t tgt) { return LevenshteinScalarFunction(result, str, tgt); });
-}
-
-void LevenshteinFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet levenshtein("levenshtein");
-	levenshtein.AddFunction(ScalarFunction("levenshtein", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                       LogicalType::BIGINT,
-	                                       LevenshteinFunction)); // Pointer to function implementation
-	set.AddFunction(levenshtein);
-
-	ScalarFunctionSet editdist3("editdist3");
-	editdist3.AddFunction(ScalarFunction("levenshtein", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                     LogicalType::BIGINT, LevenshteinFunction));
-	set.AddFunction(editdist3);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct StandardCharacterReader {
-	static char Operation(const char *data, idx_t pos) {
-		return data[pos];
-	}
-};
-
-struct ASCIILCaseReader {
-	static char Operation(const char *data, idx_t pos) {
-		return (char)LowerFun::ascii_to_lower_map[(uint8_t)data[pos]];
-	}
-};
-
-template <char PERCENTAGE, char UNDERSCORE, class READER = StandardCharacterReader>
-bool TemplatedLikeOperator(const char *sdata, idx_t slen, const char *pdata, idx_t plen, char escape) {
-	idx_t pidx = 0;
-	idx_t sidx = 0;
-	for (; pidx < plen && sidx < slen; pidx++) {
-		char pchar = READER::Operation(pdata, pidx);
-		char schar = READER::Operation(sdata, sidx);
-		if (pchar == escape) {
-			pidx++;
-			if (pidx == plen) {
-				throw SyntaxException("Like pattern must not end with escape character!");
-			}
-			if (pdata[pidx] != schar) {
-				return false;
-			}
-			sidx++;
-		} else if (pchar == UNDERSCORE) {
-			sidx++;
-		} else if (pchar == PERCENTAGE) {
-			pidx++;
-			while (pidx < plen && pdata[pidx] == PERCENTAGE) {
-				pidx++;
-			}
-			if (pidx == plen) {
-				return true; /* tail is acceptable */
-			}
-			for (; sidx < slen; sidx++) {
-				if (TemplatedLikeOperator<PERCENTAGE, UNDERSCORE, READER>(sdata + sidx, slen - sidx, pdata + pidx,
-				                                                          plen - pidx, escape)) {
-					return true;
-				}
-			}
-			return false;
-		} else if (pchar == schar) {
-			sidx++;
-		} else {
-			return false;
-		}
-	}
-	while (pidx < plen && pdata[pidx] == PERCENTAGE) {
-		pidx++;
-	}
-	return pidx == plen && sidx == slen;
-}
-
-struct LikeSegment {
-	explicit LikeSegment(string pattern) : pattern(move(pattern)) {
-	}
-
-	string pattern;
-};
-
-struct LikeMatcher : public FunctionData {
-	LikeMatcher(string like_pattern_p, vector<LikeSegment> segments, bool has_start_percentage, bool has_end_percentage)
-	    : like_pattern(move(like_pattern_p)), segments(move(segments)), has_start_percentage(has_start_percentage),
-	      has_end_percentage(has_end_percentage) {
-	}
-
-	bool Match(string_t &str) {
-		auto str_data = (const unsigned char *)str.GetDataUnsafe();
-		auto str_len = str.GetSize();
-		idx_t segment_idx = 0;
-		idx_t end_idx = segments.size() - 1;
-		if (!has_start_percentage) {
-			// no start sample_size: match the first part of the string directly
-			auto &segment = segments[0];
-			if (str_len < segment.pattern.size()) {
-				return false;
-			}
-			if (memcmp(str_data, segment.pattern.c_str(), segment.pattern.size()) != 0) {
-				return false;
-			}
-			str_data += segment.pattern.size();
-			str_len -= segment.pattern.size();
-			segment_idx++;
-			if (segments.size() == 1) {
-				// only one segment, and it matches
-				// we have a match if there is an end sample_size, OR if the memcmp was an exact match (remaining str is
-				// empty)
-				return has_end_percentage || str_len == 0;
-			}
-		}
-		// main match loop: for every segment in the middle, use Contains to find the needle in the haystack
-		for (; segment_idx < end_idx; segment_idx++) {
-			auto &segment = segments[segment_idx];
-			// find the pattern of the current segment
-			idx_t next_offset = ContainsFun::Find(str_data, str_len, (const unsigned char *)segment.pattern.c_str(),
-			                                      segment.pattern.size());
-			if (next_offset == DConstants::INVALID_INDEX) {
-				// could not find this pattern in the string: no match
-				return false;
-			}
-			idx_t offset = next_offset + segment.pattern.size();
-			str_data += offset;
-			str_len -= offset;
-		}
-		if (!has_end_percentage) {
-			end_idx--;
-			// no end sample_size: match the final segment now
-			auto &segment = segments.back();
-			if (str_len < segment.pattern.size()) {
-				return false;
-			}
-			if (memcmp(str_data + str_len - segment.pattern.size(), segment.pattern.c_str(), segment.pattern.size()) !=
-			    0) {
-				return false;
-			}
-			return true;
-		} else {
-			auto &segment = segments.back();
-			// find the pattern of the current segment
-			idx_t next_offset = ContainsFun::Find(str_data, str_len, (const unsigned char *)segment.pattern.c_str(),
-			                                      segment.pattern.size());
-			return next_offset != DConstants::INVALID_INDEX;
-		}
-	}
-
-	static unique_ptr<LikeMatcher> CreateLikeMatcher(string like_pattern, char escape = '\0') {
-		vector<LikeSegment> segments;
-		idx_t last_non_pattern = 0;
-		bool has_start_percentage = false;
-		bool has_end_percentage = false;
-		for (idx_t i = 0; i < like_pattern.size(); i++) {
-			auto ch = like_pattern[i];
-			if (ch == escape || ch == '%' || ch == '_') {
-				// special character, push a constant pattern
-				if (i > last_non_pattern) {
-					segments.emplace_back(like_pattern.substr(last_non_pattern, i - last_non_pattern));
-				}
-				last_non_pattern = i + 1;
-				if (ch == escape || ch == '_') {
-					// escape or underscore: could not create efficient like matcher
-					// FIXME: we could handle escaped percentages here
-					return nullptr;
-				} else {
-					// sample_size
-					if (i == 0) {
-						has_start_percentage = true;
-					}
-					if (i + 1 == like_pattern.size()) {
-						has_end_percentage = true;
-					}
-				}
-			}
-		}
-		if (last_non_pattern < like_pattern.size()) {
-			segments.emplace_back(like_pattern.substr(last_non_pattern, like_pattern.size() - last_non_pattern));
-		}
-		if (segments.empty()) {
-			return nullptr;
-		}
-		return make_unique<LikeMatcher>(move(like_pattern), move(segments), has_start_percentage, has_end_percentage);
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<LikeMatcher>(like_pattern, segments, has_start_percentage, has_end_percentage);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const LikeMatcher &)other_p;
-		return like_pattern == other.like_pattern;
-	}
-
-private:
-	string like_pattern;
-	vector<LikeSegment> segments;
-	bool has_start_percentage;
-	bool has_end_percentage;
-};
-
-static unique_ptr<FunctionData> LikeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
-	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
-	if (arguments[1]->IsFoldable()) {
-		Value pattern_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		return LikeMatcher::CreateLikeMatcher(pattern_str.ToString());
-	}
-	return nullptr;
-}
-
-bool LikeOperatorFunction(const char *s, idx_t slen, const char *pattern, idx_t plen, char escape) {
-	return TemplatedLikeOperator<'%', '_'>(s, slen, pattern, plen, escape);
-}
-
-bool LikeOperatorFunction(string_t &s, string_t &pat, char escape = '\0') {
-	return LikeOperatorFunction(s.GetDataUnsafe(), s.GetSize(), pat.GetDataUnsafe(), pat.GetSize(), escape);
-}
-
-bool LikeFun::Glob(const char *string, idx_t slen, const char *pattern, idx_t plen) {
-	idx_t sidx = 0;
-	idx_t pidx = 0;
-main_loop : {
-	// main matching loop
-	while (sidx < slen && pidx < plen) {
-		char s = string[sidx];
-		char p = pattern[pidx];
-		switch (p) {
-		case '*': {
-			// asterisk: match any set of characters
-			// skip any subsequent asterisks
-			pidx++;
-			while (pidx < plen && pattern[pidx] == '*') {
-				pidx++;
-			}
-			// if the asterisk is the last character, the pattern always matches
-			if (pidx == plen) {
-				return true;
-			}
-			// recursively match the remainder of the pattern
-			for (; sidx < slen; sidx++) {
-				if (LikeFun::Glob(string + sidx, slen - sidx, pattern + pidx, plen - pidx)) {
-					return true;
-				}
-			}
-			return false;
-		}
-		case '?':
-			// wildcard: matches anything but null
-			break;
-		case '[':
-			pidx++;
-			goto parse_bracket;
-		case '\\':
-			// escape character, next character needs to match literally
-			pidx++;
-			// check that we still have a character remaining
-			if (pidx == plen) {
-				return false;
-			}
-			p = pattern[pidx];
-			if (s != p) {
-				return false;
-			}
-			break;
-		default:
-			// not a control character: characters need to match literally
-			if (s != p) {
-				return false;
-			}
-			break;
-		}
-		sidx++;
-		pidx++;
-	}
-	while (pidx < plen && pattern[pidx] == '*') {
-		pidx++;
-	}
-	// we are finished only if we have consumed the full pattern
-	return pidx == plen && sidx == slen;
-}
-parse_bracket : {
-	// inside a bracket
-	if (pidx == plen) {
-		return false;
-	}
-	// check the first character
-	// if it is an exclamation mark we need to invert our logic
-	char p = pattern[pidx];
-	char s = string[sidx];
-	bool invert = false;
-	if (p == '!') {
-		invert = true;
-		pidx++;
-	}
-	bool found_match = invert;
-	idx_t start_pos = pidx;
-	bool found_closing_bracket = false;
-	// now check the remainder of the pattern
-	while (pidx < plen) {
-		p = pattern[pidx];
-		// if the first character is a closing bracket, we match it literally
-		// otherwise it indicates an end of bracket
-		if (p == ']' && pidx > start_pos) {
-			// end of bracket found: we are done
-			found_closing_bracket = true;
-			pidx++;
-			break;
-		}
-		// we either match a range (a-b) or a single character (a)
-		// check if the next character is a dash
-		if (pidx + 1 == plen) {
-			// no next character!
-			break;
-		}
-		bool matches;
-		if (pattern[pidx + 1] == '-') {
-			// range! find the next character in the range
-			if (pidx + 2 == plen) {
-				break;
-			}
-			char next_char = pattern[pidx + 2];
-			// check if the current character is within the range
-			matches = s >= p && s <= next_char;
-			// shift the pattern forward past the range
-			pidx += 3;
-		} else {
-			// no range! perform a direct match
-			matches = p == s;
-			// shift the pattern forward past the character
-			pidx++;
-		}
-		if (found_match == invert && matches) {
-			// found a match! set the found_matches flag
-			// we keep on pattern matching after this until we reach the end bracket
-			// however, we don't need to update the found_match flag anymore
-			found_match = !invert;
-		}
-	}
-	if (!found_closing_bracket) {
-		// no end of bracket: invalid pattern
-		return false;
-	}
-	if (!found_match) {
-		// did not match the bracket: return false;
-		return false;
-	}
-	// finished the bracket matching: move forward
-	sidx++;
-	goto main_loop;
-}
-}
-
-static char GetEscapeChar(string_t escape) {
-	// Only one escape character should be allowed
-	if (escape.GetSize() > 1) {
-		throw SyntaxException("Invalid escape string. Escape string must be empty or one character.");
-	}
-	return escape.GetSize() == 0 ? '\0' : *escape.GetDataUnsafe();
-}
-
-struct LikeEscapeOperator {
-	template <class TA, class TB, class TC>
-	static inline bool Operation(TA str, TB pattern, TC escape) {
-		char escape_char = GetEscapeChar(escape);
-		return LikeOperatorFunction(str.GetDataUnsafe(), str.GetSize(), pattern.GetDataUnsafe(), pattern.GetSize(),
-		                            escape_char);
-	}
-};
-
-struct NotLikeEscapeOperator {
-	template <class TA, class TB, class TC>
-	static inline bool Operation(TA str, TB pattern, TC escape) {
-		return !LikeEscapeOperator::Operation(str, pattern, escape);
-	}
-};
-
-struct LikeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return LikeOperatorFunction(str, pattern);
-	}
-};
-
-bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0') {
-	auto str_data = str.GetDataUnsafe();
-	auto str_size = str.GetSize();
-	auto pat_data = pattern.GetDataUnsafe();
-	auto pat_size = pattern.GetSize();
-
-	// lowercase both the str and the pattern
-	idx_t str_llength = LowerFun::LowerLength(str_data, str_size);
-	auto str_ldata = unique_ptr<char[]>(new char[str_llength]);
-	LowerFun::LowerCase(str_data, str_size, str_ldata.get());
-
-	idx_t pat_llength = LowerFun::LowerLength(pat_data, pat_size);
-	auto pat_ldata = unique_ptr<char[]>(new char[pat_llength]);
-	LowerFun::LowerCase(pat_data, pat_size, pat_ldata.get());
-	string_t str_lcase(str_ldata.get(), str_llength);
-	string_t pat_lcase(pat_ldata.get(), pat_llength);
-	return LikeOperatorFunction(str_lcase, pat_lcase, escape);
-}
-
-struct ILikeEscapeOperator {
-	template <class TA, class TB, class TC>
-	static inline bool Operation(TA str, TB pattern, TC escape) {
-		char escape_char = GetEscapeChar(escape);
-		return ILikeOperatorFunction(str, pattern, escape_char);
-	}
-};
-
-struct NotILikeEscapeOperator {
-	template <class TA, class TB, class TC>
-	static inline bool Operation(TA str, TB pattern, TC escape) {
-		return !ILikeEscapeOperator::Operation(str, pattern, escape);
-	}
-};
-
-struct ILikeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return ILikeOperatorFunction(str, pattern);
-	}
-};
-
-struct NotLikeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return !LikeOperatorFunction(str, pattern);
-	}
-};
-
-struct NotILikeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return !ILikeOperator::Operation<TA, TB, TR>(str, pattern);
-	}
-};
-
-struct ILikeOperatorASCII {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return TemplatedLikeOperator<'%', '_', ASCIILCaseReader>(str.GetDataUnsafe(), str.GetSize(),
-		                                                         pattern.GetDataUnsafe(), pattern.GetSize(), '\0');
-	}
-};
-
-struct NotILikeOperatorASCII {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return !ILikeOperatorASCII::Operation<TA, TB, TR>(str, pattern);
-	}
-};
-
-struct GlobOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA str, TB pattern) {
-		return LikeFun::Glob(str.GetDataUnsafe(), str.GetSize(), pattern.GetDataUnsafe(), pattern.GetSize());
-	}
-};
-
-// This can be moved to the scalar_function class
-template <typename FUNC>
-static void LikeEscapeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str = args.data[0];
-	auto &pattern = args.data[1];
-	auto &escape = args.data[2];
-
-	TernaryExecutor::Execute<string_t, string_t, string_t, bool>(
-	    str, pattern, escape, result, args.size(), FUNC::template Operation<string_t, string_t, string_t>);
-}
-
-template <class ASCII_OP>
-static unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	D_ASSERT(child_stats.size() >= 1);
-	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
-		expr.function.function = ScalarFunction::BinaryFunction<string_t, string_t, bool, ASCII_OP>;
-	}
-	return nullptr;
-}
-
-template <class OP, bool INVERT>
-static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	if (func_expr.bind_info) {
-		auto &matcher = (LikeMatcher &)*func_expr.bind_info;
-		// use fast like matcher
-		UnaryExecutor::Execute<string_t, bool>(input.data[0], result, input.size(), [&](string_t input) {
-			return INVERT ? !matcher.Match(input) : matcher.Match(input);
-		});
-	} else {
-		// use generic like matcher
-		BinaryExecutor::ExecuteStandard<string_t, string_t, bool, OP>(input.data[0], input.data[1], result,
-		                                                              input.size());
-	}
-}
-void LikeFun::RegisterFunction(BuiltinFunctions &set) {
-	// like
-	set.AddFunction(ScalarFunction("~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               RegularLikeFunction<LikeOperator, false>, false, LikeBindFunction));
-	// not like
-	set.AddFunction(ScalarFunction("!~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               RegularLikeFunction<NotLikeOperator, true>, false, LikeBindFunction));
-	// glob
-	set.AddFunction(ScalarFunction("~~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               ScalarFunction::BinaryFunction<string_t, string_t, bool, GlobOperator>));
-	// ilike
-	set.AddFunction(ScalarFunction("~~*", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               ScalarFunction::BinaryFunction<string_t, string_t, bool, ILikeOperator>, false,
-	                               nullptr, nullptr, ILikePropagateStats<ILikeOperatorASCII>));
-	// not ilike
-	set.AddFunction(ScalarFunction("!~~*", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               ScalarFunction::BinaryFunction<string_t, string_t, bool, NotILikeOperator>, false,
-	                               nullptr, nullptr, ILikePropagateStats<NotILikeOperatorASCII>));
-}
-
-void LikeEscapeFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"like_escape"}, ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                                LogicalType::BOOLEAN, LikeEscapeFunction<LikeEscapeOperator>));
-	set.AddFunction({"not_like_escape"},
-	                ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::BOOLEAN, LikeEscapeFunction<NotLikeEscapeOperator>));
-
-	set.AddFunction({"ilike_escape"}, ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                                 LogicalType::BOOLEAN, LikeEscapeFunction<ILikeEscapeOperator>));
-	set.AddFunction({"not_ilike_escape"},
-	                ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::BOOLEAN, LikeEscapeFunction<NotILikeEscapeOperator>));
-}
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct MD5Operator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto hash = StringVector::EmptyString(result, MD5Context::MD5_HASH_LENGTH_TEXT);
-		MD5Context context;
-		context.Add(input);
-		context.FinishHex(hash.GetDataWriteable());
-		hash.Finalize();
-		return hash;
-	}
-};
-
-struct MD5Number128Operator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		data_t digest[MD5Context::MD5_HASH_LENGTH_BINARY];
-
-		MD5Context context;
-		context.Add(input);
-		context.Finish(digest);
-		return *reinterpret_cast<hugeint_t *>(digest);
-	}
-};
-
-template <bool lower>
-struct MD5Number64Operator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		data_t digest[MD5Context::MD5_HASH_LENGTH_BINARY];
-
-		MD5Context context;
-		context.Add(input);
-		context.Finish(digest);
-		return *reinterpret_cast<uint64_t *>(&digest[lower ? 8 : 0]);
-	}
-};
-
-static void MD5Function(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::ExecuteString<string_t, string_t, MD5Operator>(input, result, args.size());
-}
-
-static void MD5NumberFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::Execute<string_t, hugeint_t, MD5Number128Operator>(input, result, args.size());
-}
-
-static void MD5NumberUpperFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::Execute<string_t, uint64_t, MD5Number64Operator<false>>(input, result, args.size());
-}
-
-static void MD5NumberLowerFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input = args.data[0];
-
-	UnaryExecutor::Execute<string_t, uint64_t, MD5Number64Operator<true>>(input, result, args.size());
-}
-
-void MD5Fun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("md5",                  // name of the function
-	                               {LogicalType::VARCHAR}, // argument list
-	                               LogicalType::VARCHAR,   // return type
-	                               MD5Function));          // pointer to function implementation
-
-	set.AddFunction(ScalarFunction("md5_number",           // name of the function
-	                               {LogicalType::VARCHAR}, // argument list
-	                               LogicalType::HUGEINT,   // return type
-	                               MD5NumberFunction));    // pointer to function implementation
-
-	set.AddFunction(ScalarFunction("md5_number_upper",       // name of the function
-	                               {LogicalType::VARCHAR},   // argument list
-	                               LogicalType::UBIGINT,     // return type
-	                               MD5NumberUpperFunction)); // pointer to function implementation
-
-	set.AddFunction(ScalarFunction("md5_number_lower",       // name of the function
-	                               {LogicalType::VARCHAR},   // argument list
-	                               LogicalType::UBIGINT,     // return type
-	                               MD5NumberLowerFunction)); // pointer to function implementation
-}
-
-} // namespace duckdb
-
-
-
-#include <ctype.h>
-#include <algorithm>
-
-namespace duckdb {
-
-static int64_t MismatchesScalarFunction(Vector &result, const string_t str, string_t tgt) {
-	idx_t str_len = str.GetSize();
-	idx_t tgt_len = tgt.GetSize();
-
-	if (str_len != tgt_len) {
-		throw InvalidInputException("Mismatch Function: Strings must be of equal length!");
-	}
-	if (str_len < 1) {
-		throw InvalidInputException("Mismatch Function: Strings must be of length > 0!");
-	}
-
-	idx_t mismatches = 0;
-	auto str_str = str.GetDataUnsafe();
-	auto tgt_str = tgt.GetDataUnsafe();
-
-	for (idx_t idx = 0; idx < str_len; ++idx) {
-		if (str_str[idx] != tgt_str[idx]) {
-			mismatches++;
-		}
-	}
-	return (int64_t)mismatches;
-}
-
-static void MismatchesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vec = args.data[0];
-	auto &tgt_vec = args.data[1];
-
-	BinaryExecutor::Execute<string_t, string_t, int64_t>(
-	    str_vec, tgt_vec, result, args.size(),
-	    [&](string_t str, string_t tgt) { return MismatchesScalarFunction(result, str, tgt); });
-}
-
-void MismatchesFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet mismatches("mismatches");
-	mismatches.AddFunction(ScalarFunction("mismatches", {LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                      LogicalType::BIGINT,
-	                                      MismatchesFunction)); // Pointer to function implementation
-	set.AddFunction(mismatches);
-
-	ScalarFunctionSet hamming("hamming");
-	hamming.AddFunction(ScalarFunction("mismatches", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                                   MismatchesFunction)); // Pointer to function implementation
-	set.AddFunction(hamming);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct NFCNormalizeOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetDataUnsafe();
-		auto input_length = input.GetSize();
-		if (StripAccentsFun::IsAscii(input_data, input_length)) {
-			return input;
-		}
-		auto normalized_str = Utf8Proc::Normalize(input_data, input_length);
-		D_ASSERT(normalized_str);
-		auto result_str = StringVector::AddString(result, normalized_str);
-		free(normalized_str);
-		return result_str;
-	}
-};
-
-static void NFCNormalizeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-
-	UnaryExecutor::ExecuteString<string_t, string_t, NFCNormalizeOperator>(args.data[0], result, args.size());
-	StringVector::AddHeapReference(result, args.data[0]);
-}
-
-ScalarFunction NFCNormalizeFun::GetFunction() {
-	return ScalarFunction("nfc_normalize", {LogicalType::VARCHAR}, LogicalType::VARCHAR, NFCNormalizeFunction);
-}
-
-void NFCNormalizeFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(NFCNormalizeFun::GetFunction());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static pair<idx_t, idx_t> PadCountChars(const idx_t len, const char *data, const idx_t size) {
-	//  Count how much of str will fit in the output
-	auto str = reinterpret_cast<const utf8proc_uint8_t *>(data);
-	idx_t nbytes = 0;
-	idx_t nchars = 0;
-	for (; nchars < len && nbytes < size; ++nchars) {
-		utf8proc_int32_t codepoint;
-		auto bytes = utf8proc_iterate(str + nbytes, size - nbytes, &codepoint);
-		D_ASSERT(bytes > 0);
-		nbytes += bytes;
-	}
-
-	return pair<idx_t, idx_t>(nbytes, nchars);
-}
-
-static bool InsertPadding(const idx_t len, const string_t &pad, vector<char> &result) {
-	//  Copy the padding until the output is long enough
-	auto data = pad.GetDataUnsafe();
-	auto size = pad.GetSize();
-
-	//  Check whether we need data that we don't have
-	if (len > 0 && size == 0) {
-		return false;
-	}
-
-	//  Insert characters until we have all we need.
-	auto str = reinterpret_cast<const utf8proc_uint8_t *>(data);
-	idx_t nbytes = 0;
-	for (idx_t nchars = 0; nchars < len; ++nchars) {
-		//  If we are at the end of the pad, flush all of it and loop back
-		if (nbytes >= size) {
-			result.insert(result.end(), data, data + size);
-			nbytes = 0;
-		}
-
-		//  Write the next character
-		utf8proc_int32_t codepoint;
-		auto bytes = utf8proc_iterate(str + nbytes, size - nbytes, &codepoint);
-		D_ASSERT(bytes > 0);
-		nbytes += bytes;
-	}
-
-	//  Flush the remaining pad
-	result.insert(result.end(), data, data + nbytes);
-
-	return true;
-}
-
-static string_t LeftPadFunction(const string_t &str, const int32_t len, const string_t &pad, vector<char> &result) {
-	//  Reuse the buffer
-	result.clear();
-
-	// Get information about the base string
-	auto data_str = str.GetDataUnsafe();
-	auto size_str = str.GetSize();
-
-	//  Count how much of str will fit in the output
-	auto written = PadCountChars(len, data_str, size_str);
-
-	//  Left pad by the number of characters still needed
-	if (!InsertPadding(len - written.second, pad, result)) {
-		throw Exception("Insufficient padding in LPAD.");
-	}
-
-	//  Append as much of the original string as fits
-	result.insert(result.end(), data_str, data_str + written.first);
-
-	return string_t(result.data(), result.size());
-}
-
-struct LeftPadOperator {
-	static inline string_t Operation(const string_t &str, const int32_t len, const string_t &pad,
-	                                 vector<char> &result) {
-		return LeftPadFunction(str, len, pad, result);
-	}
-};
-
-static string_t RightPadFunction(const string_t &str, const int32_t len, const string_t &pad, vector<char> &result) {
-	//  Reuse the buffer
-	result.clear();
-
-	// Get information about the base string
-	auto data_str = str.GetDataUnsafe();
-	auto size_str = str.GetSize();
-
-	// Count how much of str will fit in the output
-	auto written = PadCountChars(len, data_str, size_str);
-
-	//  Append as much of the original string as fits
-	result.insert(result.end(), data_str, data_str + written.first);
-
-	//  Right pad by the number of characters still needed
-	if (!InsertPadding(len - written.second, pad, result)) {
-		throw Exception("Insufficient padding in RPAD.");
-	};
-
-	return string_t(result.data(), result.size());
-}
-
-struct RightPadOperator {
-	static inline string_t Operation(const string_t &str, const int32_t len, const string_t &pad,
-	                                 vector<char> &result) {
-		return RightPadFunction(str, len, pad, result);
-	}
-};
-
-template <class OP>
-static void PadFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vector = args.data[0];
-	auto &len_vector = args.data[1];
-	auto &pad_vector = args.data[2];
-
-	vector<char> buffer;
-	TernaryExecutor::Execute<string_t, int32_t, string_t, string_t>(
-	    str_vector, len_vector, pad_vector, result, args.size(), [&](string_t str, int32_t len, string_t pad) {
-		    len = MaxValue<int32_t>(len, 0);
-		    return StringVector::AddString(result, OP::Operation(str, len, pad, buffer));
-	    });
-}
-
-void LpadFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("lpad",                                      // name of the function
-	                               {LogicalType::VARCHAR, LogicalType::INTEGER, // argument list
-	                                LogicalType::VARCHAR},
-	                               LogicalType::VARCHAR,           // return type
-	                               PadFunction<LeftPadOperator>)); // pointer to function implementation
-}
-
-void RpadFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("rpad",                                      // name of the function
-	                               {LogicalType::VARCHAR, LogicalType::INTEGER, // argument list
-	                                LogicalType::VARCHAR},
-	                               LogicalType::VARCHAR,            // return type
-	                               PadFunction<RightPadOperator>)); // pointer to function implementation
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-static bool PrefixFunction(const string_t &str, const string_t &pattern);
-
-struct PrefixOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return PrefixFunction(left, right);
-	}
-};
-static bool PrefixFunction(const string_t &str, const string_t &pattern) {
-	auto str_length = str.GetSize();
-	auto patt_length = pattern.GetSize();
-	if (patt_length > str_length) {
-		return false;
-	}
-	if (patt_length <= string_t::PREFIX_LENGTH) {
-		// short prefix
-		if (patt_length == 0) {
-			// length = 0, return true
-			return true;
-		}
-
-		// prefix early out
-		const char *str_pref = str.GetPrefix();
-		const char *patt_pref = pattern.GetPrefix();
-		for (idx_t i = 0; i < patt_length; ++i) {
-			if (str_pref[i] != patt_pref[i]) {
-				return false;
-			}
-		}
-		return true;
-	} else {
-		// prefix early out
-		const char *str_pref = str.GetPrefix();
-		const char *patt_pref = pattern.GetPrefix();
-		for (idx_t i = 0; i < string_t::PREFIX_LENGTH; ++i) {
-			if (str_pref[i] != patt_pref[i]) {
-				// early out
-				return false;
-			}
-		}
-		// compare the rest of the prefix
-		const char *str_data = str.GetDataUnsafe();
-		const char *patt_data = pattern.GetDataUnsafe();
-		D_ASSERT(patt_length <= str_length);
-		for (idx_t i = string_t::PREFIX_LENGTH; i < patt_length; ++i) {
-			if (str_data[i] != patt_data[i]) {
-				return false;
-			}
-		}
-		return true;
-	}
-}
-
-ScalarFunction PrefixFun::GetFunction() {
-	return ScalarFunction("prefix",                                     // name of the function
-	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list
-	                      LogicalType::BOOLEAN,                         // return type
-	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, PrefixOperator>);
-}
-
-void PrefixFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(GetFunction());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct FMTPrintf {
-	template <class CTX>
-	static string OP(const char *format_str, std::vector<duckdb_fmt::basic_format_arg<CTX>> &format_args) {
-		return duckdb_fmt::vsprintf(
-		    format_str, duckdb_fmt::basic_format_args<CTX>(format_args.data(), static_cast<int>(format_args.size())));
-	}
-};
-
-struct FMTFormat {
-	template <class CTX>
-	static string OP(const char *format_str, std::vector<duckdb_fmt::basic_format_arg<CTX>> &format_args) {
-		return duckdb_fmt::vformat(
-		    format_str, duckdb_fmt::basic_format_args<CTX>(format_args.data(), static_cast<int>(format_args.size())));
-	}
-};
-
-unique_ptr<FunctionData> BindPrintfFunction(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	for (idx_t i = 1; i < arguments.size(); i++) {
-		switch (arguments[i]->return_type.id()) {
-		case LogicalTypeId::BOOLEAN:
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT:
-		case LogicalTypeId::FLOAT:
-		case LogicalTypeId::DOUBLE:
-		case LogicalTypeId::VARCHAR:
-			// these types are natively supported
-			bound_function.arguments.push_back(arguments[i]->return_type);
-			break;
-		case LogicalTypeId::DECIMAL:
-			// decimal type: add cast to double
-			bound_function.arguments.emplace_back(LogicalType::DOUBLE);
-			break;
-		case LogicalTypeId::UNKNOWN:
-			// parameter: accept any input and rebind later
-			bound_function.arguments.emplace_back(LogicalType::ANY);
-			break;
-		default:
-			// all other types: add cast to string
-			bound_function.arguments.emplace_back(LogicalType::VARCHAR);
-			break;
-		}
-	}
-	return nullptr;
-}
-
-template <class FORMAT_FUN, class CTX>
-static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &format_string = args.data[0];
-	auto &result_validity = FlatVector::Validity(result);
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	result_validity.Initialize(args.size());
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		switch (args.data[i].GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR:
-			if (ConstantVector::IsNull(args.data[i])) {
-				// constant null! result is always NULL regardless of other input
-				result.SetVectorType(VectorType::CONSTANT_VECTOR);
-				ConstantVector::SetNull(result, true);
-				return;
-			}
-			break;
-		default:
-			// FLAT VECTOR, we can directly OR the nullmask
-			args.data[i].Normalify(args.size());
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			result_validity.Combine(FlatVector::Validity(args.data[i]), args.size());
-			break;
-		}
-	}
-	idx_t count = result.GetVectorType() == VectorType::CONSTANT_VECTOR ? 1 : args.size();
-
-	auto format_data = FlatVector::GetData<string_t>(format_string);
-	auto result_data = FlatVector::GetData<string_t>(result);
-	for (idx_t idx = 0; idx < count; idx++) {
-		if (result.GetVectorType() == VectorType::FLAT_VECTOR && FlatVector::IsNull(result, idx)) {
-			// this entry is NULL: skip it
-			continue;
-		}
-
-		// first fetch the format string
-		auto fmt_idx = format_string.GetVectorType() == VectorType::CONSTANT_VECTOR ? 0 : idx;
-		auto format_string = format_data[fmt_idx].GetString();
-
-		// now gather all the format arguments
-		std::vector<duckdb_fmt::basic_format_arg<CTX>> format_args;
-		std::vector<unique_ptr<data_t[]>> string_args;
-
-		for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-			auto &col = args.data[col_idx];
-			idx_t arg_idx = col.GetVectorType() == VectorType::CONSTANT_VECTOR ? 0 : idx;
-			switch (col.GetType().id()) {
-			case LogicalTypeId::BOOLEAN: {
-				auto arg_data = FlatVector::GetData<bool>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::TINYINT: {
-				auto arg_data = FlatVector::GetData<int8_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::SMALLINT: {
-				auto arg_data = FlatVector::GetData<int8_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::INTEGER: {
-				auto arg_data = FlatVector::GetData<int32_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::BIGINT: {
-				auto arg_data = FlatVector::GetData<int64_t>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::FLOAT: {
-				auto arg_data = FlatVector::GetData<float>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::DOUBLE: {
-				auto arg_data = FlatVector::GetData<double>(col);
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
-				break;
-			}
-			case LogicalTypeId::VARCHAR: {
-				auto arg_data = FlatVector::GetData<string_t>(col);
-				auto string_view =
-				    duckdb_fmt::basic_string_view<char>(arg_data[arg_idx].GetDataUnsafe(), arg_data[arg_idx].GetSize());
-				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(string_view));
-				break;
-			}
-			default:
-				throw InternalException("Unexpected type for printf format");
-			}
-		}
-		// finally actually perform the format
-		string dynamic_result = FORMAT_FUN::template OP<CTX>(format_string.c_str(), format_args);
-		result_data[idx] = StringVector::AddString(result, dynamic_result);
-	}
-}
-
-void PrintfFun::RegisterFunction(BuiltinFunctions &set) {
-	// duckdb_fmt::printf_context, duckdb_fmt::vsprintf
-	ScalarFunction printf_fun =
-	    ScalarFunction("printf", {LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                   PrintfFunction<FMTPrintf, duckdb_fmt::printf_context>, false, BindPrintfFunction);
-	printf_fun.varargs = LogicalType::ANY;
-	set.AddFunction(printf_fun);
-
-	// duckdb_fmt::format_context, duckdb_fmt::vformat
-	ScalarFunction format_fun =
-	    ScalarFunction("format", {LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                   PrintfFunction<FMTFormat, duckdb_fmt::format_context>, false, BindPrintfFunction);
-	format_fun.varargs = LogicalType::ANY;
-	set.AddFunction(format_fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p)
-    : options(options), constant_string(move(constant_string_p)) {
-	constant_pattern = !constant_string.empty();
-	if (constant_pattern) {
-		auto pattern = make_unique<RE2>(constant_string, options);
-		if (!pattern->ok()) {
-			throw Exception(pattern->error());
-		}
-
-		range_success = pattern->PossibleMatchRange(&range_min, &range_max, 1000);
-	} else {
-		range_success = false;
-	}
-}
-
-static bool RegexOptionsEquals(const duckdb_re2::RE2::Options &opt_a, const duckdb_re2::RE2::Options &opt_b) {
-	return opt_a.case_sensitive() == opt_b.case_sensitive();
-}
-
-RegexpMatchesBindData::~RegexpMatchesBindData() {
-}
-
-unique_ptr<FunctionData> RegexpMatchesBindData::Copy() const {
-	return make_unique<RegexpMatchesBindData>(options, constant_string);
-}
-
-bool RegexpMatchesBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const RegexpMatchesBindData &)other_p;
-	return constant_string == other.constant_string && RegexOptionsEquals(options, other.options);
-}
-
-static inline duckdb_re2::StringPiece CreateStringPiece(string_t &input) {
-	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
-}
-
-static void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr) {
-	for (idx_t i = 0; i < options.size(); i++) {
-		switch (options[i]) {
-		case 'c':
-			// case-sensitive matching
-			result.set_case_sensitive(true);
-			break;
-		case 'i':
-			// case-insensitive matching
-			result.set_case_sensitive(false);
-			break;
-		case 'l':
-			// literal matching
-			result.set_literal(true);
-			break;
-		case 'm':
-		case 'n':
-		case 'p':
-			// newline-sensitive matching
-			result.set_dot_nl(false);
-			break;
-		case 's':
-			// non-newline-sensitive matching
-			result.set_dot_nl(true);
-			break;
-		case 'g':
-			// global replace, only available for regexp_replace
-			if (global_replace) {
-				*global_replace = true;
-			} else {
-				throw InvalidInputException("Option 'g' (global replace) is only valid for regexp_replace");
-			}
-			break;
-		case ' ':
-		case '\t':
-		case '\n':
-			// ignore whitespace
-			break;
-		default:
-			throw InvalidInputException("Unrecognized Regex option %c", options[i]);
-		}
-	}
-}
-
-struct RegexPartialMatch {
-	static inline bool Operation(const duckdb_re2::StringPiece &input, duckdb_re2::RE2 &re) {
-		return duckdb_re2::RE2::PartialMatch(input, re);
-	}
-};
-
-struct RegexFullMatch {
-	static inline bool Operation(const duckdb_re2::StringPiece &input, duckdb_re2::RE2 &re) {
-		return duckdb_re2::RE2::FullMatch(input, re);
-	}
-};
-
-struct RegexLocalState : public FunctionLocalState {
-	explicit RegexLocalState(RegexpMatchesBindData &info)
-	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
-	                       info.options) {
-		D_ASSERT(info.constant_pattern);
-	}
-
-	explicit RegexLocalState(RegexpExtractBindData &info)
-	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size())) {
-		D_ASSERT(info.constant_pattern);
-	}
-
-	RE2 constant_pattern;
-};
-
-static unique_ptr<FunctionLocalState> RegexInitLocalState(const BoundFunctionExpression &expr,
-                                                          FunctionData *bind_data) {
-	auto &info = (RegexpMatchesBindData &)*bind_data;
-	if (info.constant_pattern) {
-		return make_unique<RegexLocalState>(info);
-	}
-	return nullptr;
-}
-
-template <class OP>
-static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpMatchesBindData &)*func_expr.bind_info;
-
-	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
-		UnaryExecutor::Execute<string_t, bool>(strings, result, args.size(), [&](string_t input) {
-			return OP::Operation(CreateStringPiece(input), lstate.constant_pattern);
-		});
-	} else {
-		BinaryExecutor::Execute<string_t, string_t, bool>(strings, patterns, result, args.size(),
-		                                                  [&](string_t input, string_t pattern) {
-			                                                  RE2 re(CreateStringPiece(pattern), info.options);
-			                                                  if (!re.ok()) {
-				                                                  throw Exception(re.error());
-			                                                  }
-			                                                  return OP::Operation(CreateStringPiece(input), re);
-		                                                  });
-	}
-}
-
-static unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
-	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
-	RE2::Options options;
-	options.set_log_errors(false);
-	if (arguments.size() == 3) {
-		if (!arguments[2]->IsFoldable()) {
-			throw InvalidInputException("Regex options field must be a constant");
-		}
-		Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[2]);
-		if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
-			ParseRegexOptions(StringValue::Get(options_str), options);
-		}
-	}
-
-	if (arguments[1]->IsFoldable()) {
-		Value pattern_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-			return make_unique<RegexpMatchesBindData>(options, StringValue::Get(pattern_str));
-		}
-	}
-	return make_unique<RegexpMatchesBindData>(options, "");
-}
-
-static void RegexReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpReplaceBindData &)*func_expr.bind_info;
-
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-	auto &replaces = args.data[2];
-
-	TernaryExecutor::Execute<string_t, string_t, string_t, string_t>(
-	    strings, patterns, replaces, result, args.size(), [&](string_t input, string_t pattern, string_t replace) {
-		    RE2 re(CreateStringPiece(pattern), info.options);
-		    std::string sstring = input.GetString();
-		    if (info.global_replace) {
-			    RE2::GlobalReplace(&sstring, re, CreateStringPiece(replace));
-		    } else {
-			    RE2::Replace(&sstring, re, CreateStringPiece(replace));
-		    }
-		    return StringVector::AddString(result, sstring);
-	    });
-}
-
-unique_ptr<FunctionData> RegexpReplaceBindData::Copy() const {
-	auto copy = make_unique<RegexpReplaceBindData>();
-	copy->options = options;
-	copy->global_replace = global_replace;
-	return move(copy);
-}
-
-bool RegexpReplaceBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const RegexpReplaceBindData &)other_p;
-	return global_replace == other.global_replace && RegexOptionsEquals(options, other.options);
-}
-
-static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	auto data = make_unique<RegexpReplaceBindData>();
-	data->options.set_log_errors(false);
-	if (arguments.size() == 4) {
-		if (!arguments[3]->IsFoldable()) {
-			throw InvalidInputException("Regex options field must be a constant");
-		}
-		Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[3]);
-		if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
-			ParseRegexOptions(StringValue::Get(options_str), data->options, &data->global_replace);
-		}
-	}
-
-	return move(data);
-}
-
-inline static string_t Extract(const string_t &input, Vector &result, const RE2 &re,
-                               const duckdb_re2::StringPiece &rewrite) {
-	std::string extracted;
-	RE2::Extract(input.GetString(), re, rewrite, &extracted);
-	return StringVector::AddString(result, extracted.c_str(), extracted.size());
-}
-
-static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	const auto &info = (RegexpExtractBindData &)*func_expr.bind_info;
-
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-	if (info.constant_pattern) {
-		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
-		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
-			return Extract(input, result, lstate.constant_pattern, info.rewrite);
-		});
-	} else {
-		BinaryExecutor::Execute<string_t, string_t, string_t>(strings, patterns, result, args.size(),
-		                                                      [&](string_t input, string_t pattern) {
-			                                                      RE2 re(CreateStringPiece(pattern));
-			                                                      return Extract(input, result, re, info.rewrite);
-		                                                      });
-	}
-}
-
-static unique_ptr<FunctionLocalState> RegexExtractInitLocalState(const BoundFunctionExpression &expr,
-                                                                 FunctionData *bind_data) {
-	auto &info = (RegexpExtractBindData &)*bind_data;
-	if (info.constant_pattern) {
-		return make_unique<RegexLocalState>(info);
-	}
-	return nullptr;
-}
-
-RegexpExtractBindData::RegexpExtractBindData(bool constant_pattern, const string &constant_string,
-                                             const string &group_string_p)
-    : constant_pattern(constant_pattern), constant_string(constant_string), group_string(group_string_p),
-      rewrite(group_string) {
-}
-
-unique_ptr<FunctionData> RegexpExtractBindData::Copy() const {
-	return make_unique<RegexpExtractBindData>(constant_pattern, constant_string, group_string);
-}
-
-bool RegexpExtractBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const RegexpExtractBindData &)other_p;
-	return constant_string == other.constant_string && group_string == other.group_string;
-}
-
-static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() >= 2);
-
-	bool constant_pattern = arguments[1]->IsFoldable();
-	string pattern = "";
-	if (constant_pattern) {
-		Value pattern_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-			pattern = StringValue::Get(pattern_str);
-		}
-	}
-
-	string group_string = "";
-	if (arguments.size() == 3) {
-		if (!arguments[2]->IsFoldable()) {
-			throw InvalidInputException("Group index field field must be a constant!");
-		}
-		Value group = ExpressionExecutor::EvaluateScalar(*arguments[2]);
-		if (!group.IsNull()) {
-			auto group_idx = group.GetValue<int32_t>();
-			if (group_idx < 0 || group_idx > 9) {
-				throw InvalidInputException("Group index must be between 0 and 9!");
-			}
-			group_string = "\\" + to_string(group_idx);
-		}
-	} else {
-		group_string = "\\0";
-	}
-
-	return make_unique<RegexpExtractBindData>(constant_pattern, pattern, group_string);
-}
-
-void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet regexp_full_match("regexp_full_match");
-	regexp_full_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                                             RegexpMatchesFunction<RegexFullMatch>, false, false, RegexpMatchesBind,
-	                                             nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	                                             FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_full_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                             LogicalType::BOOLEAN, RegexpMatchesFunction<RegexFullMatch>, false,
-	                                             false, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
-	                                             LogicalType::INVALID, FunctionNullHandling::SPECIAL_HANDLING));
-
-	ScalarFunctionSet regexp_partial_match("regexp_matches");
-	regexp_partial_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                                                RegexpMatchesFunction<RegexPartialMatch>, false, false,
-	                                                RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
-	                                                LogicalType::INVALID, FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_partial_match.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                   RegexpMatchesFunction<RegexPartialMatch>, false, false, RegexpMatchesBind, nullptr, nullptr,
-	                   RegexInitLocalState, LogicalType::INVALID, FunctionNullHandling::SPECIAL_HANDLING));
-
-	ScalarFunctionSet regexp_replace("regexp_replace");
-	regexp_replace.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                          LogicalType::VARCHAR, RegexReplaceFunction, false, false,
-	                                          RegexReplaceBind));
-	regexp_replace.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                   LogicalType::VARCHAR, RegexReplaceFunction, false, false, RegexReplaceBind));
-
-	ScalarFunctionSet regexp_extract("regexp_extract");
-	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                          RegexExtractFunction, false, false, RegexExtractBind, nullptr, nullptr,
-	                                          RegexExtractInitLocalState, LogicalType::INVALID,
-	                                          FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER},
-	                                          LogicalType::VARCHAR, RegexExtractFunction, false, false,
-	                                          RegexExtractBind, nullptr, nullptr, RegexExtractInitLocalState,
-	                                          LogicalType::INVALID, FunctionNullHandling::SPECIAL_HANDLING));
-
-	set.AddFunction(regexp_full_match);
-	set.AddFunction(regexp_partial_match);
-	set.AddFunction(regexp_replace);
-	set.AddFunction(regexp_extract);
-}
-
-} // namespace duckdb
-
-
-
-
-
-#include <string.h>
-#include <ctype.h>
-
-namespace duckdb {
-
-static string_t RepeatScalarFunction(const string_t &str, const int64_t cnt, vector<char> &result) {
-	// Get information about the repeated string
-	auto input_str = str.GetDataUnsafe();
-	auto size_str = str.GetSize();
-
-	//  Reuse the buffer
-	result.clear();
-	for (auto remaining = cnt; remaining-- > 0;) {
-		result.insert(result.end(), input_str, input_str + size_str);
-	}
-
-	return string_t(result.data(), result.size());
-}
-
-static void RepeatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &str_vector = args.data[0];
-	auto &cnt_vector = args.data[1];
-
-	vector<char> buffer;
-	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    str_vector, cnt_vector, result, args.size(), [&](string_t str, int64_t cnt) {
-		    return StringVector::AddString(result, RepeatScalarFunction(str, cnt, buffer));
-	    });
-}
-
-void RepeatFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("repeat",                                    // name of the function
-	                               {LogicalType::VARCHAR, LogicalType::BIGINT}, // argument list
-	                               LogicalType::VARCHAR,                        // return type
-	                               RepeatFunction));                            // pointer to function implementation
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#include <string.h>
-#include <ctype.h>
-#include <unordered_map>
-
-namespace duckdb {
-
-static idx_t NextNeedle(const char *input_haystack, idx_t size_haystack, const char *input_needle,
-                        const idx_t size_needle) {
-	// Needle needs something to proceed
-	if (size_needle > 0) {
-		// Haystack should be bigger or equal size to the needle
-		for (idx_t string_position = 0; (size_haystack - string_position) >= size_needle; ++string_position) {
-			// Compare Needle to the Haystack
-			if ((memcmp(input_haystack + string_position, input_needle, size_needle) == 0)) {
-				return string_position;
-			}
-		}
-	}
-	// Did not find the needle
-	return size_haystack;
-}
-
-static string_t ReplaceScalarFunction(const string_t &haystack, const string_t &needle, const string_t &thread,
-                                      vector<char> &result) {
-	// Get information about the needle, the haystack and the "thread"
-	auto input_haystack = haystack.GetDataUnsafe();
-	auto size_haystack = haystack.GetSize();
-
-	auto input_needle = needle.GetDataUnsafe();
-	auto size_needle = needle.GetSize();
-
-	auto input_thread = thread.GetDataUnsafe();
-	auto size_thread = thread.GetSize();
-
-	//  Reuse the buffer
-	result.clear();
-
-	for (;;) {
-		//  Append the non-matching characters
-		auto string_position = NextNeedle(input_haystack, size_haystack, input_needle, size_needle);
-		result.insert(result.end(), input_haystack, input_haystack + string_position);
-		input_haystack += string_position;
-		size_haystack -= string_position;
-
-		//  Stop when we have read the entire haystack
-		if (size_haystack == 0) {
-			break;
-		}
-
-		//  Replace the matching characters
-		result.insert(result.end(), input_thread, input_thread + size_thread);
-		input_haystack += size_needle;
-		size_haystack -= size_needle;
-	}
-
-	return string_t(result.data(), result.size());
-}
-
-static void ReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &haystack_vector = args.data[0];
-	auto &needle_vector = args.data[1];
-	auto &thread_vector = args.data[2];
-
-	vector<char> buffer;
-	TernaryExecutor::Execute<string_t, string_t, string_t, string_t>(
-	    haystack_vector, needle_vector, thread_vector, result, args.size(),
-	    [&](string_t input_string, string_t needle_string, string_t thread_string) {
-		    return StringVector::AddString(result,
-		                                   ReplaceScalarFunction(input_string, needle_string, thread_string, buffer));
-	    });
-}
-
-void ReplaceFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("replace",             // name of the function
-	                               {LogicalType::VARCHAR, // argument list
-	                                LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::VARCHAR, // return type
-	                               ReplaceFunction));    // pointer to function implementation
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <string.h>
-
-namespace duckdb {
-
-//! Fast ASCII string reverse, returns false if the input data is not ascii
-static bool StrReverseASCII(const char *input, idx_t n, char *output) {
-	for (idx_t i = 0; i < n; i++) {
-		if (input[i] & 0x80) {
-			// non-ascii character
-			return false;
-		}
-		output[n - i - 1] = input[i];
-	}
-	return true;
-}
-
-//! Unicode string reverse using grapheme breakers
-static void StrReverseUnicode(const char *input, idx_t n, char *output) {
-	utf8proc_grapheme_callback(input, n, [&](size_t start, size_t end) {
-		memcpy(output + n - end, input + start, end - start);
-		return true;
-	});
-}
-
-struct ReverseOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetDataUnsafe();
-		auto input_length = input.GetSize();
-
-		auto target = StringVector::EmptyString(result, input_length);
-		auto target_data = target.GetDataWriteable();
-		if (!StrReverseASCII(input_data, input_length, target_data)) {
-			StrReverseUnicode(input_data, input_length, target_data);
-		}
-		target.Finalize();
-		return target;
-	}
-};
-
-static void ReverseFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, ReverseOperator>(args.data[0], result, args.size());
-}
-
-void ReverseFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("reverse", {LogicalType::VARCHAR}, LogicalType::VARCHAR, ReverseFunction));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct StringSplitIterator {
-public:
-	explicit StringSplitIterator(idx_t size) : size(size) {
-	}
-	virtual ~StringSplitIterator() {
-	}
-
-	idx_t size;
-
-public:
-	virtual idx_t Next(const char *input) = 0;
-	bool HasNext() {
-		return offset < size;
-	}
-	idx_t Start() {
-		return start;
-	}
-
-protected:
-	idx_t start = 0;  // end of last place a delim match was found
-	idx_t offset = 0; // current position
-};
-
-struct AsciiStringSplitIterator : virtual public StringSplitIterator {
-public:
-	AsciiStringSplitIterator(size_t size, const char *delim, const size_t delim_size)
-	    : StringSplitIterator(size), delim(delim), delim_size(delim_size) {
-	}
-	idx_t Next(const char *input) override {
-		// special case: separate by empty delimiter
-		if (delim_size == 0) {
-			offset++;
-			start = offset;
-			return offset;
-		}
-		for (offset = start; HasNext(); offset++) {
-			// potential delimiter match
-			if (input[offset] == delim[0] && offset + delim_size <= size) {
-				idx_t i;
-				for (i = 1; i < delim_size; i++) {
-					if (input[offset + i] != delim[i]) {
-						break;
-					}
-				}
-				// delimiter found: skip start over delimiter
-				if (i == delim_size) {
-					start = offset + delim_size;
-					return offset;
-				}
-			}
-		}
-		return offset;
-	}
-
-protected:
-	const char *delim;
-	size_t delim_size;
-};
-
-struct UnicodeStringSplitIterator : virtual public StringSplitIterator {
-public:
-	UnicodeStringSplitIterator(size_t input_size, const char *delim, const size_t delim_size)
-	    : StringSplitIterator(input_size), delim_size(delim_size) {
-		int cp_sz;
-		for (idx_t i = 0; i < delim_size; i += cp_sz) {
-			delim_cps.push_back(utf8proc_codepoint(delim, cp_sz));
-		}
-	}
-	idx_t Next(const char *input) override {
-		// special case: separate by empty delimiter
-		if (delim_size == 0) {
-			offset = utf8proc_next_grapheme(input, size, offset);
-			start = offset;
-			return offset;
-		}
-		int cp_sz;
-		for (offset = start; HasNext(); offset = utf8proc_next_grapheme(input, size, offset)) {
-			// potential delimiter match
-			if (utf8proc_codepoint(&input[offset], cp_sz) == delim_cps[0] && offset + delim_size <= size) {
-				idx_t delim_offset = cp_sz;
-				for (idx_t i = 1; i < delim_cps.size(); i++) {
-					if (utf8proc_codepoint(&input[offset + delim_offset], cp_sz) != delim_cps[i]) {
-						break;
-					}
-					delim_offset += cp_sz;
-				}
-				// delimiter found: skip start over delimiter
-				if (delim_offset == delim_size) {
-					start = offset + delim_size;
-					return offset;
-				}
-			}
-		}
-		return offset;
-	}
-
-protected:
-	vector<utf8proc_int32_t> delim_cps;
-	size_t delim_size;
-};
-
-struct RegexStringSplitIterator : virtual public StringSplitIterator {
-public:
-	RegexStringSplitIterator(size_t input_size, unique_ptr<RE2> re, const bool ascii_only)
-	    : StringSplitIterator(input_size), re(move(re)), ascii_only(ascii_only) {
-	}
-	idx_t Next(const char *input) override {
-		duckdb_re2::StringPiece input_sp(input, size);
-		duckdb_re2::StringPiece match;
-		if (re->Match(input_sp, start, size, RE2::UNANCHORED, &match, 1)) {
-			offset = match.data() - input;
-			// special case: 0 length match
-			if (match.empty() && start < size) {
-				if (ascii_only) {
-					offset++;
-				} else {
-					offset = utf8proc_next_grapheme(input, size, offset);
-				}
-				start = offset;
-			} else {
-				start = offset + match.size();
-			}
-		} else {
-			offset = size;
-		}
-		return offset;
-	}
-
-protected:
-	unique_ptr<RE2> re;
-	bool ascii_only;
-};
-
-void BaseStringSplitFunction(const char *input, StringSplitIterator &iter, Vector &result) {
-	// special case: empty string
-	if (iter.size == 0) {
-		Value val = StringVector::AddString(ListVector::GetEntry(result), &input[0], 0);
-		ListVector::PushBack(result, val);
-		return;
-	}
-	while (iter.HasNext()) {
-		idx_t start = iter.Start();
-		idx_t end = iter.Next(input);
-		size_t length = end - start;
-		Value to_insert(StringVector::AddString(ListVector::GetEntry(result), &input[start], length));
-		ListVector::PushBack(result, to_insert);
-	}
-}
-
-unique_ptr<Vector> BaseStringSplitFunction(string_t input, string_t delim, const bool regex) {
-	const char *input_data = input.GetDataUnsafe();
-	size_t input_size = input.GetSize();
-	const char *delim_data = delim.GetDataUnsafe();
-	size_t delim_size = delim.GetSize();
-
-	bool ascii_only = Utf8Proc::Analyze(input_data, input_size) == UnicodeType::ASCII;
-
-	auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto output = make_unique<Vector>(list_type);
-	unique_ptr<StringSplitIterator> iter;
-	if (regex) {
-		auto re = make_unique<RE2>(duckdb_re2::StringPiece(delim_data, delim_size));
-		if (!re->ok()) {
-			throw Exception(re->error());
-		}
-		iter = make_unique_base<StringSplitIterator, RegexStringSplitIterator>(input_size, move(re), ascii_only);
-	} else if (ascii_only) {
-		iter = make_unique_base<StringSplitIterator, AsciiStringSplitIterator>(input_size, delim_data, delim_size);
-	} else {
-		iter = make_unique_base<StringSplitIterator, UnicodeStringSplitIterator>(input_size, delim_data, delim_size);
-	}
-	BaseStringSplitFunction(input_data, *iter, *output);
-
-	return output;
-}
-
-static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector &result, const bool regex) {
-	VectorData input_data;
-	args.data[0].Orrify(args.size(), input_data);
-	auto inputs = (string_t *)input_data.data;
-
-	VectorData delim_data;
-	args.data[1].Orrify(args.size(), delim_data);
-	auto delims = (string_t *)delim_data.data;
-
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	ListVector::SetListSize(result, 0);
-
-	auto list_struct_data = FlatVector::GetData<list_entry_t>(result);
-	auto list_vector_type = LogicalType::LIST(LogicalType::VARCHAR);
-
-	idx_t total_len = 0;
-	auto &result_mask = FlatVector::Validity(result);
-	for (idx_t i = 0; i < args.size(); i++) {
-		auto input_idx = input_data.sel->get_index(i);
-		auto delim_idx = delim_data.sel->get_index(i);
-		if (!input_data.validity.RowIsValid(input_idx)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-		string_t input = inputs[input_idx];
-
-		unique_ptr<Vector> split_input;
-		if (!delim_data.validity.RowIsValid(delim_idx)) {
-			// special case: delimiter is NULL
-			split_input = make_unique<Vector>(list_vector_type);
-			Value val(input);
-			ListVector::PushBack(*split_input, val);
-		} else {
-			string_t delim = delims[delim_idx];
-			split_input = BaseStringSplitFunction(input, delim, regex);
-		}
-		list_struct_data[i].length = ListVector::GetListSize(*split_input);
-		list_struct_data[i].offset = total_len;
-		total_len += ListVector::GetListSize(*split_input);
-		ListVector::Append(result, ListVector::GetEntry(*split_input), ListVector::GetListSize(*split_input));
-	}
-
-	D_ASSERT(ListVector::GetListSize(result) == total_len);
-	if (args.data[0].GetVectorType() == VectorType::CONSTANT_VECTOR &&
-	    args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static void StringSplitFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	StringSplitExecutor(args, state, result, false);
-}
-
-static void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	StringSplitExecutor(args, state, result, true);
-}
-
-void StringSplitFun::RegisterFunction(BuiltinFunctions &set) {
-	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-
-	auto regular_fun =
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitFunction);
-	regular_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction({"string_split", "str_split", "string_to_array", "split"}, regular_fun);
-
-	auto regex_fun =
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitRegexFunction);
-	regex_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction({"string_split_regex", "str_split_regex", "regexp_split_to_array"}, regex_fun);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-bool StripAccentsFun::IsAscii(const char *input, idx_t n) {
-	for (idx_t i = 0; i < n; i++) {
-		if (input[i] & 0x80) {
-			// non-ascii character
-			return false;
-		}
-	}
-	return true;
-}
-
-struct StripAccentsOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		if (StripAccentsFun::IsAscii(input.GetDataUnsafe(), input.GetSize())) {
-			return input;
-		}
-
-		// non-ascii, perform collation
-		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetDataUnsafe(), input.GetSize());
-		auto result_str = StringVector::AddString(result, (const char *)stripped);
-		free(stripped);
-		return result_str;
-	}
-};
-
-static void StripAccentsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 1);
-
-	UnaryExecutor::ExecuteString<string_t, string_t, StripAccentsOperator>(args.data[0], result, args.size());
-	StringVector::AddHeapReference(result, args.data[0]);
-}
-
-ScalarFunction StripAccentsFun::GetFunction() {
-	return ScalarFunction("strip_accents", {LogicalType::VARCHAR}, LogicalType::VARCHAR, StripAccentsFunction);
-}
-
-void StripAccentsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(StripAccentsFun::GetFunction());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-string_t SubstringEmptyString(Vector &result) {
-	auto result_string = StringVector::EmptyString(result, 0);
-	result_string.Finalize();
-	return result_string;
-}
-
-string_t SubstringSlice(Vector &result, const char *input_data, int64_t offset, int64_t length) {
-	auto result_string = StringVector::EmptyString(result, length);
-	auto result_data = result_string.GetDataWriteable();
-	memcpy(result_data, input_data + offset, length);
-	result_string.Finalize();
-	return result_string;
-}
-
-// compute start and end characters from the given input size and offset/length
-bool SubstringStartEnd(int64_t input_size, int64_t offset, int64_t length, int64_t &start, int64_t &end) {
-	if (length == 0) {
-		return false;
-	}
-	if (offset > 0) {
-		// positive offset: scan from start
-		start = MinValue<int64_t>(input_size, offset - 1);
-	} else if (offset < 0) {
-		// negative offset: scan from end (i.e. start = end + offset)
-		start = MaxValue<int64_t>(input_size + offset, 0);
-	} else {
-		// offset = 0: special case, we start 1 character BEHIND the first character
-		start = 0;
-		length--;
-		if (length <= 0) {
-			return false;
-		}
-	}
-	if (length > 0) {
-		// positive length: go forward (i.e. end = start + offset)
-		end = MinValue<int64_t>(input_size, start + length);
-	} else {
-		// negative length: go backwards (i.e. end = start, start = start + length)
-		end = start;
-		start = MaxValue<int64_t>(0, end + length);
-	}
-	if (start == end) {
-		return false;
-	}
-	D_ASSERT(start < end);
-	return true;
-}
-
-string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetDataUnsafe();
-	auto input_size = input.GetSize();
-
-	int64_t start, end;
-	if (!SubstringStartEnd(input_size, offset, length, start, end)) {
-		return SubstringEmptyString(result);
-	}
-	return SubstringSlice(result, input_data, start, end - start);
-}
-
-string_t SubstringFun::SubstringScalarFunction(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetDataUnsafe();
-	auto input_size = input.GetSize();
-
-	// we don't know yet if the substring is ascii, but we assume it is (for now)
-	// first get the start and end as if this was an ascii string
-	int64_t start, end;
-	if (!SubstringStartEnd(input_size, offset, length, start, end)) {
-		return SubstringEmptyString(result);
-	}
-
-	// now check if all the characters between 0 and end are ascii characters
-	// note that we scan one further to check for a potential combining diacritics (e.g. i + diacritic is ï)
-	bool is_ascii = true;
-	idx_t ascii_end = MinValue<idx_t>(end + 1, input_size);
-	for (idx_t i = 0; i < ascii_end; i++) {
-		if (input_data[i] & 0x80) {
-			// found a non-ascii character: eek
-			is_ascii = false;
-			break;
-		}
-	}
-	if (is_ascii) {
-		// all characters are ascii, we can just slice the substring
-		return SubstringSlice(result, input_data, start, end - start);
-	}
-	// if the characters are not ascii, we need to scan grapheme clusters
-	// first figure out which direction we need to scan
-	// offset = 0 case is taken care of in SubstringStartEnd
-	if (offset < 0) {
-		// negative offset, this case is more difficult
-		// we first need to count the number of characters in the string
-		idx_t num_characters = 0;
-		utf8proc_grapheme_callback(input_data, input_size, [&](size_t start, size_t end) {
-			num_characters++;
-			return true;
-		});
-		// now call substring start and end again, but with the number of unicode characters this time
-		SubstringStartEnd(num_characters, offset, length, start, end);
-	}
-
-	// now scan the graphemes of the string to find the positions of the start and end characters
-	int64_t current_character = 0;
-	idx_t start_pos = DConstants::INVALID_INDEX, end_pos = input_size;
-	utf8proc_grapheme_callback(input_data, input_size, [&](size_t gstart, size_t gend) {
-		if (current_character == start) {
-			start_pos = gstart;
-		} else if (current_character == end) {
-			end_pos = gstart;
-			return false;
-		}
-		current_character++;
-		return true;
-	});
-	if (start_pos == DConstants::INVALID_INDEX) {
-		return SubstringEmptyString(result);
-	}
-	// after we have found these, we can slice the substring
-	return SubstringSlice(result, input_data, start_pos, end_pos - start_pos);
-}
-
-static void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input_vector = args.data[0];
-	auto &offset_vector = args.data[1];
-	if (args.ColumnCount() == 3) {
-		auto &length_vector = args.data[2];
-
-		TernaryExecutor::Execute<string_t, int64_t, int64_t, string_t>(
-		    input_vector, offset_vector, length_vector, result, args.size(),
-		    [&](string_t input_string, int64_t offset, int64_t length) {
-			    return SubstringFun::SubstringScalarFunction(result, input_string, offset, length);
-		    });
-	} else {
-		BinaryExecutor::Execute<string_t, int64_t, string_t>(
-		    input_vector, offset_vector, result, args.size(), [&](string_t input_string, int64_t offset) {
-			    return SubstringFun::SubstringScalarFunction(result, input_string, offset,
-			                                                 NumericLimits<int64_t>::Maximum() - offset);
-		    });
-	}
-}
-
-static void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &input_vector = args.data[0];
-	auto &offset_vector = args.data[1];
-	if (args.ColumnCount() == 3) {
-		auto &length_vector = args.data[2];
-
-		TernaryExecutor::Execute<string_t, int64_t, int64_t, string_t>(
-		    input_vector, offset_vector, length_vector, result, args.size(),
-		    [&](string_t input_string, int64_t offset, int64_t length) {
-			    return SubstringASCII(result, input_string, offset, length);
-		    });
-	} else {
-		BinaryExecutor::Execute<string_t, int64_t, string_t>(
-		    input_vector, offset_vector, result, args.size(), [&](string_t input_string, int64_t offset) {
-			    return SubstringASCII(result, input_string, offset, NumericLimits<int64_t>::Maximum() - offset);
-		    });
-	}
-}
-
-static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	// we only care about the stats of the first child (i.e. the string)
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
-		expr.function.function = SubstringFunctionASCII;
-	}
-	return nullptr;
-}
-
-void SubstringFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet substr("substring");
-	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                  LogicalType::VARCHAR, SubstringFunction, false, false, nullptr, nullptr,
-	                                  SubstringPropagateStats));
-	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                                  SubstringFunction, false, false, nullptr, nullptr, SubstringPropagateStats));
-	set.AddFunction(substr);
-	substr.name = "substr";
-	set.AddFunction(substr);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-static bool SuffixFunction(const string_t &str, const string_t &suffix);
-
-struct SuffixOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return SuffixFunction(left, right);
-	}
-};
-
-static bool SuffixFunction(const string_t &str, const string_t &suffix) {
-	auto suffix_size = suffix.GetSize();
-	auto str_size = str.GetSize();
-	if (suffix_size > str_size) {
-		return false;
-	}
-
-	auto suffix_data = suffix.GetDataUnsafe();
-	auto str_data = str.GetDataUnsafe();
-	int32_t suf_idx = suffix_size - 1;
-	idx_t str_idx = str_size - 1;
-	for (; suf_idx >= 0; --suf_idx, --str_idx) {
-		if (suffix_data[suf_idx] != str_data[str_idx]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-ScalarFunction SuffixFun::GetFunction() {
-	return ScalarFunction("suffix",                                     // name of the function
-	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list
-	                      LogicalType::BOOLEAN,                         // return type
-	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, SuffixOperator>);
-}
-
-void SuffixFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(GetFunction());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <string.h>
-
-namespace duckdb {
-
-template <bool LTRIM, bool RTRIM>
-struct TrimOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetDataUnsafe();
-		auto size = input.GetSize();
-
-		utf8proc_int32_t codepoint;
-		auto str = reinterpret_cast<const utf8proc_uint8_t *>(data);
-
-		// Find the first character that is not left trimmed
-		idx_t begin = 0;
-		if (LTRIM) {
-			while (begin < size) {
-				auto bytes = utf8proc_iterate(str + begin, size - begin, &codepoint);
-				D_ASSERT(bytes > 0);
-				if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
-					break;
-				}
-				begin += bytes;
-			}
-		}
-
-		// Find the last character that is not right trimmed
-		idx_t end;
-		if (RTRIM) {
-			end = begin;
-			for (auto next = begin; next < size;) {
-				auto bytes = utf8proc_iterate(str + next, size - next, &codepoint);
-				D_ASSERT(bytes > 0);
-				next += bytes;
-				if (utf8proc_category(codepoint) != UTF8PROC_CATEGORY_ZS) {
-					end = next;
-				}
-			}
-		} else {
-			end = size;
-		}
-
-		// Copy the trimmed string
-		auto target = StringVector::EmptyString(result, end - begin);
-		auto output = target.GetDataWriteable();
-		memcpy(output, data + begin, end - begin);
-
-		target.Finalize();
-		return target;
-	}
-};
-
-template <bool LTRIM, bool RTRIM>
-static void UnaryTrimFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	UnaryExecutor::ExecuteString<string_t, string_t, TrimOperator<LTRIM, RTRIM>>(args.data[0], result, args.size());
-}
-
-static void GetIgnoredCodepoints(string_t ignored, unordered_set<utf8proc_int32_t> &ignored_codepoints) {
-	auto dataptr = (utf8proc_uint8_t *)ignored.GetDataUnsafe();
-	auto size = ignored.GetSize();
-	idx_t pos = 0;
-	while (pos < size) {
-		utf8proc_int32_t codepoint;
-		pos += utf8proc_iterate(dataptr + pos, size - pos, &codepoint);
-		ignored_codepoints.insert(codepoint);
-	}
-}
-
-template <bool LTRIM, bool RTRIM>
-static void BinaryTrimFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	BinaryExecutor::Execute<string_t, string_t, string_t>(
-	    input.data[0], input.data[1], result, input.size(), [&](string_t input, string_t ignored) {
-		    auto data = input.GetDataUnsafe();
-		    auto size = input.GetSize();
-
-		    unordered_set<utf8proc_int32_t> ignored_codepoints;
-		    GetIgnoredCodepoints(ignored, ignored_codepoints);
-
-		    utf8proc_int32_t codepoint;
-		    auto str = reinterpret_cast<const utf8proc_uint8_t *>(data);
-
-		    // Find the first character that is not left trimmed
-		    idx_t begin = 0;
-		    if (LTRIM) {
-			    while (begin < size) {
-				    auto bytes = utf8proc_iterate(str + begin, size - begin, &codepoint);
-				    if (ignored_codepoints.find(codepoint) == ignored_codepoints.end()) {
-					    break;
-				    }
-				    begin += bytes;
-			    }
-		    }
-
-		    // Find the last character that is not right trimmed
-		    idx_t end;
-		    if (RTRIM) {
-			    end = begin;
-			    for (auto next = begin; next < size;) {
-				    auto bytes = utf8proc_iterate(str + next, size - next, &codepoint);
-				    D_ASSERT(bytes > 0);
-				    next += bytes;
-				    if (ignored_codepoints.find(codepoint) == ignored_codepoints.end()) {
-					    end = next;
-				    }
-			    }
-		    } else {
-			    end = size;
-		    }
-
-		    // Copy the trimmed string
-		    auto target = StringVector::EmptyString(result, end - begin);
-		    auto output = target.GetDataWriteable();
-		    memcpy(output, data + begin, end - begin);
-
-		    target.Finalize();
-		    return target;
-	    });
-}
-
-void TrimFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet ltrim("ltrim");
-	ScalarFunctionSet rtrim("rtrim");
-	ScalarFunctionSet trim("trim");
-
-	ltrim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<true, false>));
-	rtrim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<false, true>));
-	trim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<true, true>));
-
-	ltrim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                 BinaryTrimFunction<true, false>));
-	rtrim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                 BinaryTrimFunction<false, true>));
-	trim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                BinaryTrimFunction<true, true>));
-
-	set.AddFunction(ltrim);
-	set.AddFunction(rtrim);
-	set.AddFunction(trim);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterStringFunctions() {
-	Register<ReverseFun>();
-	Register<LowerFun>();
-	Register<UpperFun>();
-	Register<StripAccentsFun>();
-	Register<ConcatFun>();
-	Register<ContainsFun>();
-	Register<LengthFun>();
-	Register<LikeFun>();
-	Register<LikeEscapeFun>();
-	Register<LpadFun>();
-	Register<LeftFun>();
-	Register<MD5Fun>();
-	Register<RightFun>();
-	Register<PrintfFun>();
-	Register<RegexpFun>();
-	Register<SubstringFun>();
-	Register<InstrFun>();
-	Register<PrefixFun>();
-	Register<RepeatFun>();
-	Register<ReplaceFun>();
-	Register<RpadFun>();
-	Register<SuffixFun>();
-	Register<TrimFun>();
-	Register<UnicodeFun>();
-	Register<NFCNormalizeFun>();
-	Register<StringSplitFun>();
-	Register<ASCII>();
-	Register<CHR>();
-	Register<MismatchesFun>();
-	Register<LevenshteinFun>();
-	Register<JaccardFun>();
-
-	// blob functions
-	Register<Base64Fun>();
-	Register<EncodeFun>();
-
-	// uuid functions
-	Register<UUIDFun>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct StructExtractBindData : public FunctionData {
-	StructExtractBindData(string key, idx_t index, LogicalType type) : key(move(key)), index(index), type(move(type)) {
-	}
-
-	string key;
-	idx_t index;
-	LogicalType type;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<StructExtractBindData>(key, index, type);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StructExtractBindData &)other_p;
-		return key == other.key && index == other.index && type == other.type;
-	}
-};
-
-static void StructExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (StructExtractBindData &)*func_expr.bind_info;
-
-	// this should be guaranteed by the binder
-	auto &vec = args.data[0];
-
-	vec.Verify(args.size());
-	auto &children = StructVector::GetEntries(vec);
-	D_ASSERT(info.index < children.size());
-	auto &struct_child = children[info.index];
-	result.Reference(*struct_child);
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 2);
-	D_ASSERT(LogicalTypeId::STRUCT == arguments[0]->return_type.id());
-	auto &struct_children = StructType::GetChildTypes(arguments[0]->return_type);
-	if (struct_children.empty()) {
-		throw InternalException("Can't extract something from an empty struct");
-	}
-
-	auto &key_child = arguments[1];
-
-	if (key_child->return_type.id() != LogicalTypeId::VARCHAR ||
-	    key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
-		throw BinderException("Key name for struct_extract needs to be a constant string");
-	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(*key_child.get());
-	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
-	auto &key_str = StringValue::Get(key_val);
-	if (key_val.IsNull() || key_str.empty()) {
-		throw BinderException("Key name for struct_extract needs to be neither NULL nor empty");
-	}
-	string key = StringUtil::Lower(key_str);
-
-	LogicalType return_type;
-	idx_t key_index = 0;
-	bool found_key = false;
-
-	for (size_t i = 0; i < struct_children.size(); i++) {
-		auto &child = struct_children[i];
-		if (StringUtil::Lower(child.first) == key) {
-			found_key = true;
-			key_index = i;
-			return_type = child.second;
-			break;
-		}
-	}
-
-	if (!found_key) {
-		vector<string> candidates;
-		candidates.reserve(struct_children.size());
-		for (auto &struct_child : struct_children) {
-			candidates.push_back(struct_child.first);
-		}
-		auto closest_settings = StringUtil::TopNLevenshtein(candidates, key);
-		auto message = StringUtil::CandidatesMessage(closest_settings, "Candidate Entries");
-		throw BinderException("Could not find key \"%s\" in struct\n%s", key, message);
-	}
-
-	bound_function.return_type = return_type;
-	bound_function.arguments[0] = arguments[0]->return_type;
-	return make_unique<StructExtractBindData>(key, key_index, return_type);
-}
-
-static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &bind_data = input.bind_data;
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &struct_stats = (StructStatistics &)*child_stats[0];
-	auto &info = (StructExtractBindData &)*bind_data;
-	if (info.index >= struct_stats.child_stats.size() || !struct_stats.child_stats[info.index]) {
-		return nullptr;
-	}
-	return struct_stats.child_stats[info.index]->Copy();
-}
-
-ScalarFunction StructExtractFun::GetFunction() {
-	return ScalarFunction("struct_extract", {LogicalTypeId::STRUCT, LogicalType::VARCHAR}, LogicalType::ANY,
-	                      StructExtractFunction, false, StructExtractBind, nullptr, PropagateStructExtractStats);
-}
-
-void StructExtractFun::RegisterFunction(BuiltinFunctions &set) {
-	// the arguments and return types are actually set in the binder function
-	auto fun = GetFunction();
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void StructInsertFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &starting_vec = args.data[0];
-
-	starting_vec.Verify(args.size());
-
-	auto &starting_child_entries = StructVector::GetEntries(starting_vec);
-
-	auto &result_child_entries = StructVector::GetEntries(result);
-
-	// Assign the starting vector entries to the result vector
-	for (size_t i = 0; i < starting_child_entries.size(); i++) {
-		auto &starting_child = starting_child_entries[i];
-		result_child_entries[i]->Reference(*starting_child);
-	}
-
-	// Assign the new entries to the result vector
-	for (size_t i = 1; i < args.ColumnCount(); i++) {
-		result_child_entries[starting_child_entries.size() + i - 1]->Reference(args.data[i]);
-	}
-
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	case_insensitive_set_t name_collision_set;
-
-	if (arguments.empty()) {
-		throw Exception("Missing required arguments for struct_insert function.");
-	}
-
-	if (LogicalTypeId::STRUCT != arguments[0]->return_type.id()) {
-		throw Exception("The first argument to struct_insert must be a STRUCT");
-	}
-
-	if (arguments.size() < 2) {
-		throw Exception("Can't insert nothing into a struct");
-	}
-
-	child_list_t<LogicalType> new_struct_children;
-
-	auto &existing_struct_children = StructType::GetChildTypes(arguments[0]->return_type);
-
-	for (size_t i = 0; i < existing_struct_children.size(); i++) {
-		auto &child = existing_struct_children[i];
-		name_collision_set.insert(child.first);
-		new_struct_children.push_back(make_pair(child.first, child.second));
-	}
-
-	// Loop through the additional arguments (name/value pairs)
-	for (idx_t i = 1; i < arguments.size(); i++) {
-		auto &child = arguments[i];
-		if (child->alias.empty() && bound_function.name == "struct_insert") {
-			throw BinderException("Need named argument for struct insert, e.g. STRUCT_PACK(a := b)");
-		}
-		if (name_collision_set.find(child->alias) != name_collision_set.end()) {
-			throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
-		}
-		name_collision_set.insert(child->alias);
-		new_struct_children.push_back(make_pair(child->alias, arguments[i]->return_type));
-	}
-
-	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(move(new_struct_children));
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-
-	auto &existing_struct_stats = (StructStatistics &)*child_stats[0];
-	auto new_struct_stats = make_unique<StructStatistics>(expr.return_type);
-
-	for (idx_t i = 0; i < existing_struct_stats.child_stats.size(); i++) {
-		new_struct_stats->child_stats[i] =
-		    existing_struct_stats.child_stats[i] ? existing_struct_stats.child_stats[i]->Copy() : nullptr;
-	}
-
-	auto offset = new_struct_stats->child_stats.size() - child_stats.size();
-	for (idx_t i = 1; i < child_stats.size(); i++) {
-		new_struct_stats->child_stats[offset + i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
-	}
-	return move(new_struct_stats);
-}
-
-void StructInsertFun::RegisterFunction(BuiltinFunctions &set) {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun("struct_insert", {}, LogicalTypeId::STRUCT, StructInsertFunction, false, StructInsertBind,
-	                   nullptr, StructInsertStats);
-	fun.varargs = LogicalType::ANY;
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void StructPackFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-#ifdef DEBUG
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (VariableReturnBindData &)*func_expr.bind_info;
-	// this should never happen if the binder below is sane
-	D_ASSERT(args.ColumnCount() == StructType::GetChildTypes(info.stype).size());
-#endif
-	bool all_const = true;
-	auto &child_entries = StructVector::GetEntries(result);
-	for (size_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			all_const = false;
-		}
-		// same holds for this
-		child_entries[i]->Reference(args.data[i]);
-	}
-	result.SetVectorType(all_const ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
-
-	result.Verify(args.size());
-}
-
-static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
-	case_insensitive_set_t name_collision_set;
-
-	// collect names and deconflict, construct return type
-	if (arguments.empty()) {
-		throw Exception("Can't pack nothing into a struct");
-	}
-	child_list_t<LogicalType> struct_children;
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		auto &child = arguments[i];
-		if (child->alias.empty() && bound_function.name == "struct_pack") {
-			throw BinderException("Need named argument for struct pack, e.g. STRUCT_PACK(a := b)");
-		}
-		if (child->alias.empty() && bound_function.name == "row") {
-			child->alias = "v" + std::to_string(i + 1);
-		}
-		if (name_collision_set.find(child->alias) != name_collision_set.end()) {
-			throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
-		}
-		name_collision_set.insert(child->alias);
-		struct_children.push_back(make_pair(child->alias, arguments[i]->return_type));
-	}
-
-	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(move(struct_children));
-	return make_unique<VariableReturnBindData>(bound_function.return_type);
-}
-
-unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
-	auto &child_stats = input.child_stats;
-	auto &expr = input.expr;
-	auto struct_stats = make_unique<StructStatistics>(expr.return_type);
-	D_ASSERT(child_stats.size() == struct_stats->child_stats.size());
-	for (idx_t i = 0; i < struct_stats->child_stats.size(); i++) {
-		struct_stats->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
-	}
-	return move(struct_stats);
-}
-
-void StructPackFun::RegisterFunction(BuiltinFunctions &set) {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun("struct_pack", {}, LogicalTypeId::STRUCT, StructPackFunction, false, StructPackBind, nullptr,
-	                   StructPackStats);
-	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-	fun.name = "row";
-	set.AddFunction(fun);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-// aggregate state export
-struct ExportAggregateBindData : public FunctionData {
-	AggregateFunction &aggr;
-	idx_t state_size;
-
-	explicit ExportAggregateBindData(AggregateFunction &aggr_p, idx_t state_size_p)
-	    : aggr(aggr_p), state_size(state_size_p) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ExportAggregateBindData>(aggr, state_size);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ExportAggregateBindData &)other_p;
-		return aggr == other.aggr && state_size == other.state_size;
-	}
-
-	static ExportAggregateBindData &GetFrom(ExpressionState &state) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
-		return (ExportAggregateBindData &)*func_expr.bind_info;
-	}
-};
-
-struct CombineState : public FunctionLocalState {
-	idx_t state_size;
-
-	unique_ptr<data_t[]> state_buffer0, state_buffer1;
-	Vector state_vector0, state_vector1;
-
-	explicit CombineState(idx_t state_size_p)
-	    : state_size(state_size_p), state_buffer0(unique_ptr<data_t[]>(new data_t[state_size_p])),
-	      state_buffer1(unique_ptr<data_t[]>(new data_t[state_size_p])),
-	      state_vector0(Value::POINTER((uintptr_t)state_buffer0.get())),
-	      state_vector1(Value::POINTER((uintptr_t)state_buffer1.get())) {
-	}
-};
-
-static unique_ptr<FunctionLocalState> InitCombineState(const BoundFunctionExpression &expr, FunctionData *bind_data_p) {
-	auto &bind_data = *(ExportAggregateBindData *)bind_data_p;
-	return make_unique<CombineState>(bind_data.state_size);
-}
-
-struct FinalizeState : public FunctionLocalState {
-	idx_t state_size;
-	unique_ptr<data_t[]> state_buffer;
-	Vector addresses;
-
-	explicit FinalizeState(idx_t state_size_p)
-	    : state_size(state_size_p),
-	      state_buffer(unique_ptr<data_t[]>(new data_t[STANDARD_VECTOR_SIZE * AlignValue(state_size_p)])),
-	      addresses(LogicalType::POINTER) {
-	}
-};
-
-static unique_ptr<FunctionLocalState> InitFinalizeState(const BoundFunctionExpression &expr,
-                                                        FunctionData *bind_data_p) {
-	auto &bind_data = *(ExportAggregateBindData *)bind_data_p;
-	return make_unique<FinalizeState>(bind_data.state_size);
-}
-
-static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
-	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
-	auto &local_state = (FinalizeState &)*((ExecuteFunctionState &)state_p).local_state;
-
-	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size());
-	D_ASSERT(input.data.size() == 1);
-	D_ASSERT(input.data[0].GetType().id() == LogicalTypeId::AGGREGATE_STATE);
-	auto aligned_state_size = AlignValue(bind_data.state_size);
-
-	auto state_vec_ptr = FlatVector::GetData<data_ptr_t>(local_state.addresses);
-
-	VectorData state_data;
-	input.data[0].Orrify(input.size(), state_data);
-	for (idx_t i = 0; i < input.size(); i++) {
-		auto state_idx = state_data.sel->get_index(i);
-		auto state_entry = &((string_t *)state_data.data)[state_idx];
-		auto target_ptr = (const char *)local_state.state_buffer.get() + aligned_state_size * i;
-
-		if (state_data.validity.RowIsValid(state_idx)) {
-			D_ASSERT(state_entry->GetSize() == bind_data.state_size);
-			memcpy((void *)target_ptr, state_entry->GetDataUnsafe(), bind_data.state_size);
-		} else {
-			// create a dummy state because finalize does not understand NULLs in its input
-			// we put the NULL back in explicitly below
-			bind_data.aggr.initialize((data_ptr_t)target_ptr);
-		}
-		state_vec_ptr[i] = (data_ptr_t)target_ptr;
-	}
-
-	AggregateInputData aggr_input_data(nullptr);
-	bind_data.aggr.finalize(local_state.addresses, aggr_input_data, result, input.size(), 0);
-
-	for (idx_t i = 0; i < input.size(); i++) {
-		auto state_idx = state_data.sel->get_index(i);
-		if (!state_data.validity.RowIsValid(state_idx)) {
-			FlatVector::SetNull(result, i, true);
-		}
-	}
-}
-
-static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
-	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
-	auto &local_state = (CombineState &)*((ExecuteFunctionState &)state_p).local_state;
-
-	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size());
-
-	D_ASSERT(input.data.size() == 2);
-	D_ASSERT(input.data[0].GetType().id() == LogicalTypeId::AGGREGATE_STATE);
-	D_ASSERT(input.data[0].GetType() == result.GetType());
-
-	if (input.data[0].GetType().InternalType() != input.data[1].GetType().InternalType()) {
-		throw IOException("Aggregate state combine type mismatch, expect %s, got %s",
-		                  input.data[0].GetType().ToString(), input.data[1].GetType().ToString());
-	}
-
-	VectorData state0_data, state1_data;
-	input.data[0].Orrify(input.size(), state0_data);
-	input.data[1].Orrify(input.size(), state1_data);
-
-	auto result_ptr = FlatVector::GetData<string_t>(result);
-
-	for (idx_t i = 0; i < input.size(); i++) {
-		auto state0_idx = state0_data.sel->get_index(i);
-		auto state1_idx = state1_data.sel->get_index(i);
-
-		auto &state0 = ((string_t *)state0_data.data)[state0_idx];
-		auto &state1 = ((string_t *)state1_data.data)[state1_idx];
-
-		// if both are NULL, we return NULL. If either of them is not, the result is that one
-		if (!state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
-			FlatVector::SetNull(result, i, true);
-			continue;
-		}
-		if (state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] =
-			    StringVector::AddStringOrBlob(result, (const char *)state0.GetDataUnsafe(), bind_data.state_size);
-			continue;
-		}
-		if (!state0_data.validity.RowIsValid(state0_idx) && state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] =
-			    StringVector::AddStringOrBlob(result, (const char *)state1.GetDataUnsafe(), bind_data.state_size);
-			continue;
-		}
-
-		// we actually have to combine
-		if (state0.GetSize() != bind_data.state_size || state1.GetSize() != bind_data.state_size) {
-			throw IOException("Aggregate state size mismatch, expect %llu, got %llu and %llu", bind_data.state_size,
-			                  state0.GetSize(), state1.GetSize());
-		}
-
-		memcpy(local_state.state_buffer0.get(), state0.GetDataUnsafe(), bind_data.state_size);
-		memcpy(local_state.state_buffer1.get(), state1.GetDataUnsafe(), bind_data.state_size);
-
-		AggregateInputData aggr_input_data(nullptr);
-		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);
-
-		result_ptr[i] =
-		    StringVector::AddStringOrBlob(result, (const char *)local_state.state_buffer1.get(), bind_data.state_size);
-	}
-}
-
-static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
-
-	// grab the aggregate type and bind the aggregate again
-
-	// the aggregate name and types are in the logical type of the aggregate state, make sure its sane
-	auto &arg_return_type = arguments[0]->return_type;
-	for (auto &arg_type : bound_function.arguments) {
-		arg_type = arg_return_type;
-	}
-
-	if (arg_return_type.id() != LogicalTypeId::AGGREGATE_STATE) {
-		throw BinderException("Can only FINALIZE aggregate state, not %s", arg_return_type.ToString());
-	}
-	// combine
-	if (arguments.size() == 2 && arguments[0]->return_type != arguments[1]->return_type &&
-	    arguments[1]->return_type.id() != LogicalTypeId::BLOB) {
-		throw BinderException("Cannot COMBINE aggregate states from different functions, %s <> %s",
-		                      arguments[0]->return_type.ToString(), arguments[1]->return_type.ToString());
-	}
-
-	// following error states are only reachable when someone messes up creating the state_type which is impossible from
-	// SQL
-
-	auto state_type = AggregateStateType::GetStateType(arg_return_type);
-
-	// now we can look up the function in the catalog again and bind it
-	auto func = Catalog::GetCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA,
-	                                                  state_type.function_name);
-	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
-		throw InternalException("Could not find aggregate %s", state_type.function_name);
-	}
-	auto aggr = (AggregateFunctionCatalogEntry *)func;
-
-	string error;
-	idx_t best_function = Function::BindFunction(aggr->name, aggr->functions, state_type.bound_argument_types, error);
-	if (best_function == DConstants::INVALID_INDEX) {
-		throw InternalException("Could not re-bind exported aggregate %s: %s", state_type.function_name, error);
-	}
-	auto &bound_aggr = aggr->functions[best_function];
-	if (bound_aggr.return_type != state_type.return_type || bound_aggr.arguments != state_type.bound_argument_types) {
-		throw InternalException("Type mismatch for exported aggregate %s", state_type.function_name);
-	}
-
-	if (bound_function.name == "finalize") {
-		bound_function.return_type = bound_aggr.return_type;
-	} else {
-		D_ASSERT(bound_function.name == "combine");
-		bound_function.return_type = arg_return_type;
-	}
-
-	return make_unique<ExportAggregateBindData>(bound_aggr, bound_aggr.state_size());
-}
-
-static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                                    idx_t offset) {
-	D_ASSERT(offset == 0);
-	auto bind_data = (ExportAggregateFunctionBindData *)aggr_input_data.bind_data;
-	auto state_size = bind_data->aggregate->function.state_size();
-	auto blob_ptr = FlatVector::GetData<string_t>(result);
-	auto addresses_ptr = FlatVector::GetData<data_ptr_t>(state);
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-		auto data_ptr = addresses_ptr[row_idx];
-		blob_ptr[row_idx] = StringVector::AddStringOrBlob(result, (const char *)data_ptr, state_size);
-	}
-}
-
-ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p) {
-	D_ASSERT(aggregate_p->type == ExpressionType::BOUND_AGGREGATE);
-	aggregate = unique_ptr<BoundAggregateExpression>((BoundAggregateExpression *)aggregate_p.release());
-}
-
-unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
-	return make_unique<ExportAggregateFunctionBindData>(aggregate->Copy());
-}
-
-bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const ExportAggregateFunctionBindData &)other_p;
-	return aggregate->Equals(other.aggregate.get());
-}
-
-unique_ptr<BoundAggregateExpression>
-ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggregate) {
-	auto &bound_function = child_aggregate->function;
-	if (!bound_function.combine) {
-		throw BinderException("Cannot use EXPORT_STATE for non-combinable function %s", bound_function.name);
-	}
-	if (bound_function.bind) {
-		throw BinderException("Cannot use EXPORT_STATE on aggregate functions with custom binders");
-	}
-	if (bound_function.destructor) {
-		throw BinderException("Cannot use EXPORT_STATE on aggregate functions with custom destructors");
-	}
-	// this should be required
-	D_ASSERT(bound_function.state_size);
-	D_ASSERT(bound_function.finalize);
-	D_ASSERT(!bound_function.window);
-
-	D_ASSERT(child_aggregate->function.return_type.id() != LogicalTypeId::INVALID);
-#ifdef DEBUG
-	for (auto &arg_type : child_aggregate->function.arguments) {
-		D_ASSERT(arg_type.id() != LogicalTypeId::INVALID);
-	}
-#endif
-	auto export_bind_data = make_unique<ExportAggregateFunctionBindData>(child_aggregate->Copy());
-	aggregate_state_t state_type(child_aggregate->function.name, child_aggregate->function.return_type,
-	                             child_aggregate->function.arguments);
-	auto return_type = LogicalType::AGGREGATE_STATE(move(state_type));
-
-	auto export_function =
-	    AggregateFunction("aggregate_state_export_" + bound_function.name, bound_function.arguments, return_type,
-	                      bound_function.state_size, bound_function.initialize, bound_function.update,
-	                      bound_function.combine, ExportAggregateFinalize, bound_function.simple_update,
-	                      /* can't bind this again */ nullptr, /* no dynamic state yet */ nullptr,
-	                      /* can't propagate statistics */ nullptr, nullptr);
-
-	return make_unique<BoundAggregateExpression>(export_function, move(child_aggregate->children),
-	                                             move(child_aggregate->filter), move(export_bind_data),
-	                                             child_aggregate->distinct);
-}
-
-ScalarFunction ExportAggregateFunction::GetFinalize() {
-	auto result =
-	    ScalarFunction("finalize", {LogicalTypeId::AGGREGATE_STATE}, LogicalTypeId::INVALID, AggregateStateFinalize,
-	                   false, BindAggregateState, nullptr, nullptr, InitFinalizeState);
-	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return result;
-}
-
-ScalarFunction ExportAggregateFunction::GetCombine() {
-	auto result =
-	    ScalarFunction("combine", {LogicalTypeId::AGGREGATE_STATE, LogicalTypeId::ANY}, LogicalTypeId::AGGREGATE_STATE,
-	                   AggregateStateCombine, false, BindAggregateState, nullptr, nullptr, InitCombineState);
-	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-// current_query
-struct SystemBindData : public FunctionData {
-	ClientContext &context;
-
-	explicit SystemBindData(ClientContext &context) : context(context) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<SystemBindData>(context);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		return true;
-	}
-
-	static SystemBindData &GetFrom(ExpressionState &state) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
-		return (SystemBindData &)*func_expr.bind_info;
-	}
-};
-
-unique_ptr<FunctionData> BindSystemFunction(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<SystemBindData>(context);
-}
-
-static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &info = SystemBindData::GetFrom(state);
-	Value val(info.context.GetCurrentQuery());
-	result.Reference(val);
-}
-
-// current_schema
-static void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	Value val(ClientData::Get(SystemBindData::GetFrom(state).context).catalog_search_path->GetDefault());
-	result.Reference(val);
-}
-
-// current_schemas
-static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	vector<Value> schema_list;
-	vector<string> search_path = ClientData::Get(SystemBindData::GetFrom(state).context).catalog_search_path->Get();
-	std::transform(search_path.begin(), search_path.end(), std::back_inserter(schema_list),
-	               [](const string &s) -> Value { return Value(s); });
-	auto val = Value::LIST(schema_list);
-	result.Reference(val);
-}
-
-// txid_current
-static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &transaction = Transaction::GetTransaction(SystemBindData::GetFrom(state).context);
-	auto val = Value::BIGINT(transaction.start_time);
-	result.Reference(val);
-}
-
-// version
-static void VersionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto val = Value(DuckDB::LibraryVersion());
-	result.Reference(val);
-}
-
-void SystemFun::RegisterFunction(BuiltinFunctions &set) {
-	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-
-	set.AddFunction(
-	    ScalarFunction("current_query", {}, LogicalType::VARCHAR, CurrentQueryFunction, true, BindSystemFunction));
-	set.AddFunction(
-	    ScalarFunction("current_schema", {}, LogicalType::VARCHAR, CurrentSchemaFunction, false, BindSystemFunction));
-	set.AddFunction(ScalarFunction("current_schemas", {LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction,
-	                               false, BindSystemFunction));
-	set.AddFunction(
-	    ScalarFunction("txid_current", {}, LogicalType::BIGINT, TransactionIdCurrent, false, BindSystemFunction));
-	set.AddFunction(ScalarFunction("version", {}, LogicalType::VARCHAR, VersionFunction));
-	set.AddFunction(ExportAggregateFunction::GetCombine());
-	set.AddFunction(ExportAggregateFunction::GetFinalize());
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterTrigonometricsFunctions() {
-	Register<SinFun>();
-	Register<CosFun>();
-	Register<TanFun>();
-	Register<AsinFun>();
-	Register<AcosFun>();
-	Register<AtanFun>();
-	Register<CotFun>();
-	Register<Atan2Fun>();
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-FunctionLocalState::~FunctionLocalState() {
-}
-
-ScalarFunction::ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
-                               scalar_function_t function, bool has_side_effects, bind_scalar_function_t bind,
-                               dependency_function_t dependency, function_statistics_t statistics,
-                               init_local_state_t init_local_state, LogicalType varargs, bool propagate_null_values,
-                               FunctionNullHandling null_handling)
-    : BaseScalarFunction(move(name), move(arguments), move(return_type), has_side_effects, move(varargs),
-                         propagate_null_values),
-      function(move(function)), bind(bind), init_local_state(init_local_state), dependency(dependency),
-      statistics(statistics), null_handling(null_handling) {
-}
-
-ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
-                               bool propagate_null_values, bool has_side_effects, bind_scalar_function_t bind,
-                               dependency_function_t dependency, function_statistics_t statistics,
-                               init_local_state_t init_local_state, LogicalType varargs,
-                               FunctionNullHandling null_handling)
-    : ScalarFunction(string(), move(arguments), move(return_type), move(function), has_side_effects, bind, dependency,
-                     statistics, init_local_state, move(varargs), propagate_null_values, null_handling) {
-}
-
-bool ScalarFunction::operator==(const ScalarFunction &rhs) const {
-	return CompareScalarFunctionT(rhs.function) && bind == rhs.bind && dependency == rhs.dependency &&
-	       statistics == rhs.statistics;
-}
-bool ScalarFunction::operator!=(const ScalarFunction &rhs) const {
-	return !(*this == rhs);
-}
-
-bool ScalarFunction::Equal(const ScalarFunction &rhs) const {
-	// number of types
-	if (this->arguments.size() != rhs.arguments.size()) {
-		return false;
-	}
-	// argument types
-	for (idx_t i = 0; i < this->arguments.size(); ++i) {
-		if (this->arguments[i] != rhs.arguments[i]) {
-			return false;
-		}
-	}
-	// return type
-	if (this->return_type != rhs.return_type) {
-		return false;
-	}
-	// varargs
-	if (this->varargs != rhs.varargs) {
-		return false;
-	}
-
-	return true; // they are equal
-}
-
-bool ScalarFunction::CompareScalarFunctionT(const scalar_function_t &other) const {
-	typedef void(scalar_function_ptr_t)(DataChunk &, ExpressionState &, Vector &);
-
-	auto func_ptr = (scalar_function_ptr_t **)function.template target<scalar_function_ptr_t *>();
-	auto other_ptr = (scalar_function_ptr_t **)other.template target<scalar_function_ptr_t *>();
-
-	// Case the functions were created from lambdas the target will return a nullptr
-	if (!func_ptr && !other_ptr) {
-		return true;
-	}
-	if (func_ptr == nullptr || other_ptr == nullptr) {
-		// scalar_function_t (std::functions) from lambdas cannot be compared
-		return false;
-	}
-	return ((size_t)*func_ptr == (size_t)*other_ptr);
-}
-
-void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() >= 1);
-	result.Reference(input.data[0]);
-}
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar_macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-ScalarMacroFunction::ScalarMacroFunction(unique_ptr<ParsedExpression> expression)
-    : MacroFunction(MacroType::SCALAR_MACRO), expression(move(expression)) {
-}
-
-ScalarMacroFunction::ScalarMacroFunction(void) : MacroFunction(MacroType::SCALAR_MACRO) {
-}
-
-unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
-	auto result = make_unique<ScalarMacroFunction>();
-	result->expression = expression->Copy();
-	CopyProperties(*result);
-
-	return move(result);
-}
-
-void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
-	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &col_ref = (ColumnRefExpression &)*expr;
-		auto &col_names = col_ref.column_names;
-		if (col_names.size() == 2 && col_names[0] == MacroBinding::MACRO_NAME) {
-			col_names.erase(col_names.begin());
-		}
-	} else {
-		ParsedExpressionIterator::EnumerateChildren(
-		    *expr, [](unique_ptr<ParsedExpression> &child) { RemoveQualificationRecursive(child); });
-	}
-}
-
-string ScalarMacroFunction::ToSQL(const string &schema, const string &name) {
-	// In case of nested macro's we need to fix it a bit
-	auto expression_copy = expression->Copy();
-	RemoveQualificationRecursive(expression_copy);
-	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("(%s);", expression_copy->ToString());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-LogicalType GetArrowLogicalType(ArrowSchema &schema,
-                                std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
-                                idx_t col_idx) {
-	auto format = string(schema.format);
-	if (arrow_convert_data.find(col_idx) == arrow_convert_data.end()) {
-		arrow_convert_data[col_idx] = make_unique<ArrowConvertData>();
-	}
-	if (format == "n") {
-		return LogicalType::SQLNULL;
-	} else if (format == "b") {
-		return LogicalType::BOOLEAN;
-	} else if (format == "c") {
-		return LogicalType::TINYINT;
-	} else if (format == "s") {
-		return LogicalType::SMALLINT;
-	} else if (format == "i") {
-		return LogicalType::INTEGER;
-	} else if (format == "l") {
-		return LogicalType::BIGINT;
-	} else if (format == "C") {
-		return LogicalType::UTINYINT;
-	} else if (format == "S") {
-		return LogicalType::USMALLINT;
-	} else if (format == "I") {
-		return LogicalType::UINTEGER;
-	} else if (format == "L") {
-		return LogicalType::UBIGINT;
-	} else if (format == "f") {
-		return LogicalType::FLOAT;
-	} else if (format == "g") {
-		return LogicalType::DOUBLE;
-	} else if (format[0] == 'd') { //! this can be either decimal128 or decimal 256 (e.g., d:38,0)
-		std::string parameters = format.substr(format.find(':'));
-		uint8_t width = std::stoi(parameters.substr(1, parameters.find(',')));
-		uint8_t scale = std::stoi(parameters.substr(parameters.find(',') + 1));
-		if (width > 38) {
-			throw NotImplementedException("Unsupported Internal Arrow Type for Decimal %s", format);
-		}
-		return LogicalType::DECIMAL(width, scale);
-	} else if (format == "u") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
-		return LogicalType::VARCHAR;
-	} else if (format == "U") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
-		return LogicalType::VARCHAR;
-	} else if (format == "tsn:") {
-		return LogicalTypeId::TIMESTAMP_NS;
-	} else if (format == "tsu:") {
-		return LogicalTypeId::TIMESTAMP;
-	} else if (format == "tsm:") {
-		return LogicalTypeId::TIMESTAMP_MS;
-	} else if (format == "tss:") {
-		return LogicalTypeId::TIMESTAMP_SEC;
-	} else if (format == "tdD") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::DAYS);
-		return LogicalType::DATE;
-	} else if (format == "tdm") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
-		return LogicalType::DATE;
-	} else if (format == "tts") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
-		return LogicalType::TIME;
-	} else if (format == "ttm") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
-		return LogicalType::TIME;
-	} else if (format == "ttu") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
-		return LogicalType::TIME;
-	} else if (format == "ttn") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
-		return LogicalType::TIME;
-	} else if (format == "tDs") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
-		return LogicalType::INTERVAL;
-	} else if (format == "tDm") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
-		return LogicalType::INTERVAL;
-	} else if (format == "tDu") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
-		return LogicalType::INTERVAL;
-	} else if (format == "tDn") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
-		return LogicalType::INTERVAL;
-	} else if (format == "tiD") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::DAYS);
-		return LogicalType::INTERVAL;
-	} else if (format == "tiM") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTHS);
-		return LogicalType::INTERVAL;
-	} else if (format == "+l") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
-		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
-		return LogicalType::LIST(child_type);
-	} else if (format == "+L") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
-		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
-		return LogicalType::LIST(child_type);
-	} else if (format[0] == '+' && format[1] == 'w') {
-		std::string parameters = format.substr(format.find(':') + 1);
-		idx_t fixed_size = std::stoi(parameters);
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
-		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
-		return LogicalType::LIST(move(child_type));
-	} else if (format == "+s") {
-		child_list_t<LogicalType> child_types;
-		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
-			auto child_type = GetArrowLogicalType(*schema.children[type_idx], arrow_convert_data, col_idx);
-			child_types.push_back({schema.children[type_idx]->name, child_type});
-		}
-		return LogicalType::STRUCT(move(child_types));
-
-	} else if (format == "+m") {
-		child_list_t<LogicalType> child_types;
-		//! First type will be struct, so we skip it
-		auto &struct_schema = *schema.children[0];
-		for (idx_t type_idx = 0; type_idx < (idx_t)struct_schema.n_children; type_idx++) {
-			//! The other types must be added on lists
-			auto child_type = GetArrowLogicalType(*struct_schema.children[type_idx], arrow_convert_data, col_idx);
-
-			auto list_type = LogicalType::LIST(child_type);
-			child_types.push_back({struct_schema.children[type_idx]->name, list_type});
-		}
-		return LogicalType::MAP(move(child_types));
-	} else if (format == "z") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
-		return LogicalType::BLOB;
-	} else if (format == "Z") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
-		return LogicalType::BLOB;
-	} else if (format[0] == 'w') {
-		std::string parameters = format.substr(format.find(':') + 1);
-		idx_t fixed_size = std::stoi(parameters);
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
-		return LogicalType::BLOB;
-	} else if (format[0] == 't' && format[1] == 's') {
-		// Timestamp with Timezone
-		if (format[2] == 'n') {
-			arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
-		} else if (format[2] == 'u') {
-			arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
-		} else if (format[2] == 'm') {
-			arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
-		} else if (format[2] == 's') {
-			arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
-		} else {
-			throw NotImplementedException(" Timestamptz precision of not accepted");
-		}
-		// TODO right now we just get the UTC value. We probably want to support this properly in the future
-		return LogicalType::TIMESTAMP_TZ;
-	} else {
-		throw NotImplementedException("Unsupported Internal Arrow Type %s", format);
-	}
-}
-
-// Renames repeated columns and case sensitive columns
-void RenameArrowColumns(vector<string> &names) {
-	unordered_map<string, idx_t> name_map;
-	for (auto &column_name : names) {
-		// put it all lower_case
-		auto low_column_name = StringUtil::Lower(column_name);
-		if (name_map.find(low_column_name) == name_map.end()) {
-			// Name does not exist yet
-			name_map[low_column_name]++;
-		} else {
-			// Name already exists, we add _x where x is the repetition number
-			string new_column_name = column_name + "_" + std::to_string(name_map[low_column_name]);
-			auto new_column_name_low = StringUtil::Lower(new_column_name);
-			while (name_map.find(new_column_name_low) != name_map.end()) {
-				// This name is already here due to a previous definition
-				name_map[low_column_name]++;
-				new_column_name = column_name + "_" + std::to_string(name_map[low_column_name]);
-				new_column_name_low = StringUtil::Lower(new_column_name);
-			}
-			column_name = new_column_name;
-			name_map[new_column_name_low]++;
-		}
-	}
-}
-
-unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
-                                                           vector<LogicalType> &return_types, vector<string> &names) {
-	auto stream_factory_ptr = input.inputs[0].GetPointer();
-	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();
-	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer();
-	auto rows_per_thread = input.inputs[3].GetValue<uint64_t>();
-
-	pair<unordered_map<idx_t, string>, vector<string>> project_columns;
-	auto res = make_unique<ArrowScanFunctionData>(rows_per_thread, stream_factory_produce, stream_factory_ptr);
-
-	auto &data = *res;
-	stream_factory_get_schema(stream_factory_ptr, data.schema_root);
-	for (idx_t col_idx = 0; col_idx < (idx_t)data.schema_root.arrow_schema.n_children; col_idx++) {
-		auto &schema = *data.schema_root.arrow_schema.children[col_idx];
-		if (!schema.release) {
-			throw InvalidInputException("arrow_scan: released schema passed");
-		}
-		if (schema.dictionary) {
-			res->arrow_convert_data[col_idx] =
-			    make_unique<ArrowConvertData>(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));
-			return_types.emplace_back(GetArrowLogicalType(*schema.dictionary, res->arrow_convert_data, col_idx));
-		} else {
-			return_types.emplace_back(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));
-		}
-		auto format = string(schema.format);
-		auto name = string(schema.name);
-		if (name.empty()) {
-			name = string("v") + to_string(col_idx);
-		}
-		names.push_back(name);
-	}
-	RenameArrowColumns(names);
-	return move(res);
-}
-
-unique_ptr<ArrowArrayStreamWrapper> ProduceArrowScan(const ArrowScanFunctionData &function,
-                                                     const vector<column_t> &column_ids, TableFilterSet *filters) {
-	//! Generate Projection Pushdown Vector
-	pair<unordered_map<idx_t, string>, vector<string>> project_columns;
-	D_ASSERT(!column_ids.empty());
-	for (idx_t idx = 0; idx < column_ids.size(); idx++) {
-		auto col_idx = column_ids[idx];
-		if (col_idx != COLUMN_IDENTIFIER_ROW_ID) {
-			auto &schema = *function.schema_root.arrow_schema.children[col_idx];
-			project_columns.first[idx] = schema.name;
-			project_columns.second.emplace_back(schema.name);
-		}
-	}
-	return function.scanner_producer(function.stream_factory_ptr, project_columns, filters);
-}
-
-idx_t ArrowTableFunction::ArrowScanMaxThreads(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
-	if (bind_data.number_of_rows <= 0 || ClientConfig::GetConfig(context).verify_parallelism) {
-		return context.db->NumberOfThreads();
-	}
-	return ((bind_data.number_of_rows + bind_data.rows_per_thread - 1) / bind_data.rows_per_thread) + 1;
-}
-
-bool ArrowScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p, ArrowScanLocalState &state,
-                                ArrowScanGlobalState &parallel_state) {
-	lock_guard<mutex> parallel_lock(parallel_state.main_mutex);
-	state.chunk_offset = 0;
-
-	auto current_chunk = parallel_state.stream->GetNextChunk();
-	while (current_chunk->arrow_array.length == 0 && current_chunk->arrow_array.release) {
-		current_chunk = parallel_state.stream->GetNextChunk();
-	}
-	state.chunk = move(current_chunk);
-	//! have we run out of chunks? we are done
-	if (!state.chunk->arrow_array.release) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(ClientContext &context,
-                                                                             TableFunctionInitInput &input) {
-	auto &bind_data = (const ArrowScanFunctionData &)*input.bind_data;
-	auto result = make_unique<ArrowScanGlobalState>();
-	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters);
-	result->max_threads = ArrowScanMaxThreads(context, input.bind_data);
-	return move(result);
-}
-
-unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(ExecutionContext &context,
-                                                                           TableFunctionInitInput &input,
-                                                                           GlobalTableFunctionState *global_state_p) {
-	auto &global_state = (ArrowScanGlobalState &)*global_state_p;
-	auto current_chunk = make_unique<ArrowArrayWrapper>();
-	auto result = make_unique<ArrowScanLocalState>(move(current_chunk));
-	result->column_ids = input.column_ids;
-	result->filters = input.filters;
-	if (!ArrowScanParallelStateNext(context.client, input.bind_data, *result, global_state)) {
-		return nullptr;
-	}
-	return move(result);
-}
-
-void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	if (!data_p.local_state) {
-		return;
-	}
-	auto &data = (ArrowScanFunctionData &)*data_p.bind_data;
-	auto &state = (ArrowScanLocalState &)*data_p.local_state;
-	auto &global_state = (ArrowScanGlobalState &)*data_p.global_state;
-
-	//! Out of tuples in this chunk
-	if (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) {
-		if (!ArrowScanParallelStateNext(context, data_p.bind_data, state, global_state)) {
-			return;
-		}
-	}
-	int64_t output_size = MinValue<int64_t>(STANDARD_VECTOR_SIZE, state.chunk->arrow_array.length - state.chunk_offset);
-	data.lines_read += output_size;
-	output.SetCardinality(output_size);
-	ArrowToDuckDB(state, data.arrow_convert_data, output, data.lines_read - output_size);
-	output.Verify();
-	state.chunk_offset += output.size();
-}
-
-unique_ptr<NodeStatistics> ArrowTableFunction::ArrowScanCardinality(ClientContext &context, const FunctionData *data) {
-	auto &bind_data = (ArrowScanFunctionData &)*data;
-	return make_unique<NodeStatistics>(bind_data.number_of_rows, bind_data.number_of_rows);
-}
-
-double ArrowTableFunction::ArrowProgress(ClientContext &context, const FunctionData *bind_data_p,
-                                         const GlobalTableFunctionState *global_state) {
-	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
-	if (bind_data.number_of_rows == 0) {
-		return 100;
-	}
-	auto percentage = bind_data.lines_read * 100.0 / bind_data.number_of_rows;
-	return percentage;
-}
-
-void ArrowTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction arrow("arrow_scan",
-	                    {LogicalType::POINTER, LogicalType::POINTER, LogicalType::POINTER, LogicalType::UBIGINT},
-	                    ArrowScanFunction, ArrowScanBind, ArrowScanInitGlobal, ArrowScanInitLocal);
-	arrow.cardinality = ArrowScanCardinality;
-	arrow.projection_pushdown = true;
-	arrow.filter_pushdown = true;
-	arrow.table_scan_progress = ArrowProgress;
-	set.AddFunction(arrow);
-}
-
-void BuiltinFunctions::RegisterArrowFunctions() {
-	ArrowTableFunction::RegisterFunction(*this);
-}
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-void ShiftRight(unsigned char *ar, int size, int shift) {
-	int carry = 0;
-	while (shift--) {
-		for (int i = size - 1; i >= 0; --i) {
-			int next = (ar[i] & 1) ? 0x80 : 0;
-			ar[i] = carry | (ar[i] >> 1);
-			carry = next;
-		}
-	}
-}
-
-void SetValidityMask(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
-                     int64_t nested_offset, bool add_null = false) {
-	auto &mask = FlatVector::Validity(vector);
-	if (array.null_count != 0 && array.buffers[0]) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		auto bit_offset = scan_state.chunk_offset + array.offset;
-		if (nested_offset != -1) {
-			bit_offset = nested_offset;
-		}
-		auto n_bitmask_bytes = (size + 8 - 1) / 8;
-		mask.EnsureWritable();
-		if (bit_offset % 8 == 0) {
-			//! just memcpy nullmask
-			memcpy((void *)mask.GetData(), (uint8_t *)array.buffers[0] + bit_offset / 8, n_bitmask_bytes);
-		} else {
-			//! need to re-align nullmask
-			std::vector<uint8_t> temp_nullmask(n_bitmask_bytes + 1);
-			memcpy(temp_nullmask.data(), (uint8_t *)array.buffers[0] + bit_offset / 8, n_bitmask_bytes + 1);
-			ShiftRight(temp_nullmask.data(), n_bitmask_bytes + 1,
-			           bit_offset % 8); //! why this has to be a right shift is a mystery to me
-			memcpy((void *)mask.GetData(), (data_ptr_t)temp_nullmask.data(), n_bitmask_bytes);
-		}
-	}
-	if (add_null) {
-		//! We are setting a validity mask of the data part of dictionary vector
-		//! For some reason, Nulls are allowed to be indexes, hence we need to set the last element here to be null
-		//! We might have to resize the mask
-		mask.Resize(size, size + 1);
-		mask.SetInvalid(size);
-	}
-}
-
-void GetValidityMask(ValidityMask &mask, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size) {
-	if (array.null_count != 0 && array.buffers[0]) {
-		auto bit_offset = scan_state.chunk_offset + array.offset;
-		auto n_bitmask_bytes = (size + 8 - 1) / 8;
-		mask.EnsureWritable();
-		if (bit_offset % 8 == 0) {
-			//! just memcpy nullmask
-			memcpy((void *)mask.GetData(), (uint8_t *)array.buffers[0] + bit_offset / 8, n_bitmask_bytes);
-		} else {
-			//! need to re-align nullmask
-			std::vector<uint8_t> temp_nullmask(n_bitmask_bytes + 1);
-			memcpy(temp_nullmask.data(), (uint8_t *)array.buffers[0] + bit_offset / 8, n_bitmask_bytes + 1);
-			ShiftRight(temp_nullmask.data(), n_bitmask_bytes + 1,
-			           bit_offset % 8); //! why this has to be a right shift is a mystery to me
-			memcpy((void *)mask.GetData(), (data_ptr_t)temp_nullmask.data(), n_bitmask_bytes);
-		}
-	}
-}
-
-void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
-                         std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
-                         std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset = -1,
-                         ValidityMask *parent_mask = nullptr);
-
-void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
-                       std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
-                       std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset, ValidityMask *parent_mask) {
-	auto original_type = arrow_convert_data[col_idx]->variable_sz_type[arrow_convert_idx.first++];
-	idx_t list_size = 0;
-	SetValidityMask(vector, array, scan_state, size, nested_offset);
-	idx_t start_offset = 0;
-	idx_t cur_offset = 0;
-	if (original_type.first == ArrowVariableSizeType::FIXED_SIZE) {
-		//! Have to check validity mask before setting this up
-		idx_t offset = (scan_state.chunk_offset + array.offset) * original_type.second;
-		if (nested_offset != -1) {
-			offset = original_type.second * nested_offset;
-		}
-		start_offset = offset;
-		auto list_data = FlatVector::GetData<list_entry_t>(vector);
-		for (idx_t i = 0; i < size; i++) {
-			auto &le = list_data[i];
-			le.offset = cur_offset;
-			le.length = original_type.second;
-			cur_offset += original_type.second;
-		}
-		list_size = cur_offset;
-	} else if (original_type.first == ArrowVariableSizeType::NORMAL) {
-		auto offsets = (uint32_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
-		if (nested_offset != -1) {
-			offsets = (uint32_t *)array.buffers[1] + nested_offset;
-		}
-		start_offset = offsets[0];
-		auto list_data = FlatVector::GetData<list_entry_t>(vector);
-		for (idx_t i = 0; i < size; i++) {
-			auto &le = list_data[i];
-			le.offset = cur_offset;
-			le.length = offsets[i + 1] - offsets[i];
-			cur_offset += le.length;
-		}
-		list_size = offsets[size];
-	} else {
-		auto offsets = (uint64_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
-		if (nested_offset != -1) {
-			offsets = (uint64_t *)array.buffers[1] + nested_offset;
-		}
-		start_offset = offsets[0];
-		auto list_data = FlatVector::GetData<list_entry_t>(vector);
-		for (idx_t i = 0; i < size; i++) {
-			auto &le = list_data[i];
-			le.offset = cur_offset;
-			le.length = offsets[i + 1] - offsets[i];
-			cur_offset += le.length;
-		}
-		list_size = offsets[size];
-	}
-	list_size -= start_offset;
-	ListVector::Reserve(vector, list_size);
-	ListVector::SetListSize(vector, list_size);
-	auto &child_vector = ListVector::GetEntry(vector);
-	SetValidityMask(child_vector, *array.children[0], scan_state, list_size, start_offset);
-	auto &list_mask = FlatVector::Validity(vector);
-	if (parent_mask) {
-		//! Since this List is owned by a struct we must guarantee their validity map matches on Null
-		if (!parent_mask->AllValid()) {
-			for (idx_t i = 0; i < size; i++) {
-				if (!parent_mask->RowIsValid(i)) {
-					list_mask.SetInvalid(i);
-				}
-			}
-		}
-	}
-	if (list_size == 0 && start_offset == 0) {
-		ColumnArrowToDuckDB(child_vector, *array.children[0], scan_state, list_size, arrow_convert_data, col_idx,
-		                    arrow_convert_idx, -1);
-	} else {
-		ColumnArrowToDuckDB(child_vector, *array.children[0], scan_state, list_size, arrow_convert_data, col_idx,
-		                    arrow_convert_idx, start_offset);
-	}
-}
-
-void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
-                       std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
-                       std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset) {
-	auto original_type = arrow_convert_data[col_idx]->variable_sz_type[arrow_convert_idx.first++];
-	SetValidityMask(vector, array, scan_state, size, nested_offset);
-	if (original_type.first == ArrowVariableSizeType::FIXED_SIZE) {
-		//! Have to check validity mask before setting this up
-		idx_t offset = (scan_state.chunk_offset + array.offset) * original_type.second;
-		if (nested_offset != -1) {
-			offset = original_type.second * nested_offset;
-		}
-		auto cdata = (char *)array.buffers[1];
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				continue;
-			}
-			auto bptr = cdata + offset;
-			auto blob_len = original_type.second;
-			FlatVector::GetData<string_t>(vector)[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
-			offset += blob_len;
-		}
-	} else if (original_type.first == ArrowVariableSizeType::NORMAL) {
-		auto offsets = (uint32_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
-		if (nested_offset != -1) {
-			offsets = (uint32_t *)array.buffers[1] + array.offset + nested_offset;
-		}
-		auto cdata = (char *)array.buffers[2];
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				continue;
-			}
-			auto bptr = cdata + offsets[row_idx];
-			auto blob_len = offsets[row_idx + 1] - offsets[row_idx];
-			FlatVector::GetData<string_t>(vector)[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
-		}
-	} else {
-		//! Check if last offset is higher than max uint32
-		if (((uint64_t *)array.buffers[1])[array.length] > NumericLimits<uint32_t>::Maximum()) { // LCOV_EXCL_START
-			throw std::runtime_error("DuckDB does not support Blobs over 4GB");
-		} // LCOV_EXCL_STOP
-		auto offsets = (uint64_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
-		if (nested_offset != -1) {
-			offsets = (uint64_t *)array.buffers[1] + array.offset + nested_offset;
-		}
-		auto cdata = (char *)array.buffers[2];
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				continue;
-			}
-			auto bptr = cdata + offsets[row_idx];
-			auto blob_len = offsets[row_idx + 1] - offsets[row_idx];
-			FlatVector::GetData<string_t>(vector)[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
-		}
-	}
-}
-
-void ArrowToDuckDBMapVerify(Vector &vector, idx_t count) {
-	auto valid_check = CheckMapValidity(vector, count);
-	switch (valid_check) {
-	case MapInvalidReason::VALID:
-		break;
-	case MapInvalidReason::DUPLICATE_KEY: {
-		throw InvalidInputException("Arrow map contains duplicate key, which isn't supported by DuckDB map type");
-	}
-	case MapInvalidReason::NULL_KEY: {
-		throw InvalidInputException("Arrow map contains NULL as map key, which isn't supported by DuckDB map type");
-	}
-	case MapInvalidReason::NULL_KEY_LIST: {
-		throw InvalidInputException("Arrow map contains NULL as key list, which isn't supported by DuckDB map type");
-	}
-	default: {
-		throw InternalException("MapInvalidReason not implemented");
-	}
-	}
-}
-
-void ArrowToDuckDBMapList(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
-                          unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
-                          pair<idx_t, idx_t> &arrow_convert_idx, uint32_t *offsets, ValidityMask *parent_mask) {
-	idx_t list_size = offsets[size] - offsets[0];
-	ListVector::Reserve(vector, list_size);
-
-	auto &child_vector = ListVector::GetEntry(vector);
-	auto list_data = FlatVector::GetData<list_entry_t>(vector);
-	auto cur_offset = 0;
-	for (idx_t i = 0; i < size; i++) {
-		auto &le = list_data[i];
-		le.offset = cur_offset;
-		le.length = offsets[i + 1] - offsets[i];
-		cur_offset += le.length;
-	}
-	ListVector::SetListSize(vector, list_size);
-	if (list_size == 0 && offsets[0] == 0) {
-		SetValidityMask(child_vector, array, scan_state, list_size, -1);
-	} else {
-		SetValidityMask(child_vector, array, scan_state, list_size, offsets[0]);
-	}
-
-	auto &list_mask = FlatVector::Validity(vector);
-	if (parent_mask) {
-		//! Since this List is owned by a struct we must guarantee their validity map matches on Null
-		if (!parent_mask->AllValid()) {
-			for (idx_t i = 0; i < size; i++) {
-				if (!parent_mask->RowIsValid(i)) {
-					list_mask.SetInvalid(i);
-				}
-			}
-		}
-	}
-	if (list_size == 0 && offsets[0] == 0) {
-		ColumnArrowToDuckDB(child_vector, array, scan_state, list_size, arrow_convert_data, col_idx, arrow_convert_idx,
-		                    -1);
-	} else {
-		ColumnArrowToDuckDB(child_vector, array, scan_state, list_size, arrow_convert_data, col_idx, arrow_convert_idx,
-		                    offsets[0]);
-	}
-}
-template <class T>
-static void SetVectorString(Vector &vector, idx_t size, char *cdata, T *offsets) {
-	auto strings = FlatVector::GetData<string_t>(vector);
-	for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-		if (FlatVector::IsNull(vector, row_idx)) {
-			continue;
-		}
-		auto cptr = cdata + offsets[row_idx];
-		auto str_len = offsets[row_idx + 1] - offsets[row_idx];
-		strings[row_idx] = string_t(cptr, str_len);
-	}
-}
-
-void DirectConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset) {
-	auto internal_type = GetTypeIdSize(vector.GetType().InternalType());
-	auto data_ptr = (data_ptr_t)array.buffers[1] + internal_type * (scan_state.chunk_offset + array.offset);
-	if (nested_offset != -1) {
-		data_ptr = (data_ptr_t)array.buffers[1] + internal_type * (array.offset + nested_offset);
-	}
-	FlatVector::SetData(vector, data_ptr);
-}
-
-template <class T>
-void TimeConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
-                    idx_t size, int64_t conversion) {
-	auto tgt_ptr = (dtime_t *)FlatVector::GetData(vector);
-	auto &validity_mask = FlatVector::Validity(vector);
-	auto src_ptr = (T *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-	if (nested_offset != -1) {
-		src_ptr = (T *)array.buffers[1] + nested_offset + array.offset;
-	}
-	for (idx_t row = 0; row < size; row++) {
-		if (!validity_mask.RowIsValid(row)) {
-			continue;
-		}
-		if (!TryMultiplyOperator::Operation((int64_t)src_ptr[row], conversion, tgt_ptr[row].micros)) {
-			throw ConversionException("Could not convert Time to Microsecond");
-		}
-	}
-}
-
-void TimestampTZConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
-                           idx_t size, int64_t conversion) {
-	auto tgt_ptr = (timestamp_t *)FlatVector::GetData(vector);
-	auto &validity_mask = FlatVector::Validity(vector);
-	auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-	if (nested_offset != -1) {
-		src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
-	}
-	for (idx_t row = 0; row < size; row++) {
-		if (!validity_mask.RowIsValid(row)) {
-			continue;
-		}
-		if (!TryMultiplyOperator::Operation(src_ptr[row], conversion, tgt_ptr[row].value)) {
-			throw ConversionException("Could not convert TimestampTZ to Microsecond");
-		}
-	}
-}
-
-void IntervalConversionUs(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
-                          idx_t size, int64_t conversion) {
-	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
-	auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-	if (nested_offset != -1) {
-		src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
-	}
-	for (idx_t row = 0; row < size; row++) {
-		tgt_ptr[row].days = 0;
-		tgt_ptr[row].months = 0;
-		if (!TryMultiplyOperator::Operation(src_ptr[row], conversion, tgt_ptr[row].micros)) {
-			throw ConversionException("Could not convert Interval to Microsecond");
-		}
-	}
-}
-
-void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
-                              idx_t size) {
-	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
-	auto src_ptr = (int32_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-	if (nested_offset != -1) {
-		src_ptr = (int32_t *)array.buffers[1] + nested_offset + array.offset;
-	}
-	for (idx_t row = 0; row < size; row++) {
-		tgt_ptr[row].days = 0;
-		tgt_ptr[row].micros = 0;
-		tgt_ptr[row].months = src_ptr[row];
-	}
-}
-
-void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
-                         std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
-                         std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset, ValidityMask *parent_mask) {
-	switch (vector.GetType().id()) {
-	case LogicalTypeId::SQLNULL:
-		vector.Reference(Value());
-		break;
-	case LogicalTypeId::BOOLEAN: {
-		//! Arrow bit-packs boolean values
-		//! Lets first figure out where we are in the source array
-		auto src_ptr = (uint8_t *)array.buffers[1] + (scan_state.chunk_offset + array.offset) / 8;
-
-		if (nested_offset != -1) {
-			src_ptr = (uint8_t *)array.buffers[1] + (nested_offset + array.offset) / 8;
-		}
-		auto tgt_ptr = (uint8_t *)FlatVector::GetData(vector);
-		int src_pos = 0;
-		idx_t cur_bit = scan_state.chunk_offset % 8;
-		if (nested_offset != -1) {
-			cur_bit = nested_offset % 8;
-		}
-		for (idx_t row = 0; row < size; row++) {
-			if ((src_ptr[src_pos] & (1 << cur_bit)) == 0) {
-				tgt_ptr[row] = 0;
-			} else {
-				tgt_ptr[row] = 1;
-			}
-			cur_bit++;
-			if (cur_bit == 8) {
-				src_pos++;
-				cur_bit = 0;
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS: {
-		DirectConversion(vector, array, scan_state, nested_offset);
-		break;
-	}
-	case LogicalTypeId::JSON:
-	case LogicalTypeId::VARCHAR: {
-		auto original_type = arrow_convert_data[col_idx]->variable_sz_type[arrow_convert_idx.first++];
-		auto cdata = (char *)array.buffers[2];
-		if (original_type.first == ArrowVariableSizeType::SUPER_SIZE) {
-			if (((uint64_t *)array.buffers[1])[array.length] > NumericLimits<uint32_t>::Maximum()) { // LCOV_EXCL_START
-				throw std::runtime_error("DuckDB does not support Strings over 4GB");
-			} // LCOV_EXCL_STOP
-			auto offsets = (uint64_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
-			if (nested_offset != -1) {
-				offsets = (uint64_t *)array.buffers[1] + array.offset + nested_offset;
-			}
-			SetVectorString(vector, size, cdata, offsets);
-		} else {
-			auto offsets = (uint32_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
-			if (nested_offset != -1) {
-				offsets = (uint32_t *)array.buffers[1] + array.offset + nested_offset;
-			}
-			SetVectorString(vector, size, cdata, offsets);
-		}
-		break;
-	}
-	case LogicalTypeId::DATE: {
-		auto precision = arrow_convert_data[col_idx]->date_time_precision[arrow_convert_idx.second++];
-		switch (precision) {
-		case ArrowDateTimeType::DAYS: {
-			DirectConversion(vector, array, scan_state, nested_offset);
-			break;
-		}
-		case ArrowDateTimeType::MILLISECONDS: {
-			//! convert date from nanoseconds to days
-			auto src_ptr = (uint64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-			if (nested_offset != -1) {
-				src_ptr = (uint64_t *)array.buffers[1] + nested_offset + array.offset;
-			}
-			auto tgt_ptr = (date_t *)FlatVector::GetData(vector);
-			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row] = date_t(int64_t(src_ptr[row]) / (1000 * 60 * 60 * 24));
-			}
-			break;
-		}
-		default:
-			throw std::runtime_error("Unsupported precision for Date Type ");
-		}
-		break;
-	}
-	case LogicalTypeId::TIME: {
-		auto precision = arrow_convert_data[col_idx]->date_time_precision[arrow_convert_idx.second++];
-		switch (precision) {
-		case ArrowDateTimeType::SECONDS: {
-			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, size, 1000000);
-			break;
-		}
-		case ArrowDateTimeType::MILLISECONDS: {
-			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, size, 1000);
-			break;
-		}
-		case ArrowDateTimeType::MICROSECONDS: {
-			TimeConversion<int64_t>(vector, array, scan_state, nested_offset, size, 1);
-			break;
-		}
-		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = (dtime_t *)FlatVector::GetData(vector);
-			auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-			if (nested_offset != -1) {
-				src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
-			}
-			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row].micros = src_ptr[row] / 1000;
-			}
-			break;
-		}
-		default:
-			throw std::runtime_error("Unsupported precision for Time Type ");
-		}
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		auto precision = arrow_convert_data[col_idx]->date_time_precision[arrow_convert_idx.second++];
-		switch (precision) {
-		case ArrowDateTimeType::SECONDS: {
-			TimestampTZConversion(vector, array, scan_state, nested_offset, size, 1000000);
-			break;
-		}
-		case ArrowDateTimeType::MILLISECONDS: {
-			TimestampTZConversion(vector, array, scan_state, nested_offset, size, 1000);
-			break;
-		}
-		case ArrowDateTimeType::MICROSECONDS: {
-			DirectConversion(vector, array, scan_state, nested_offset);
-			break;
-		}
-		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = (timestamp_t *)FlatVector::GetData(vector);
-			auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-			if (nested_offset != -1) {
-				src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
-			}
-			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row].value = src_ptr[row] / 1000;
-			}
-			break;
-		}
-		default:
-			throw std::runtime_error("Unsupported precision for TimestampTZ Type ");
-		}
-		break;
-	}
-	case LogicalTypeId::INTERVAL: {
-		auto precision = arrow_convert_data[col_idx]->date_time_precision[arrow_convert_idx.second++];
-		switch (precision) {
-		case ArrowDateTimeType::SECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, size, 1000000);
-			break;
-		}
-		case ArrowDateTimeType::DAYS:
-		case ArrowDateTimeType::MILLISECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, size, 1000);
-			break;
-		}
-		case ArrowDateTimeType::MICROSECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, size, 1);
-			break;
-		}
-		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
-			auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-			if (nested_offset != -1) {
-				src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
-			}
-			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row].micros = src_ptr[row] / 1000;
-				tgt_ptr[row].days = 0;
-				tgt_ptr[row].months = 0;
-			}
-			break;
-		}
-		case ArrowDateTimeType::MONTHS: {
-			IntervalConversionMonths(vector, array, scan_state, nested_offset, size);
-			break;
-		}
-		default:
-			throw std::runtime_error("Unsupported precision for Interval/Duration Type ");
-		}
-		break;
-	}
-	case LogicalTypeId::DECIMAL: {
-		auto val_mask = FlatVector::Validity(vector);
-		//! We have to convert from INT128
-		auto src_ptr = (hugeint_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
-		if (nested_offset != -1) {
-			src_ptr = (hugeint_t *)array.buffers[1] + nested_offset + array.offset;
-		}
-		switch (vector.GetType().InternalType()) {
-		case PhysicalType::INT16: {
-			auto tgt_ptr = (int16_t *)FlatVector::GetData(vector);
-			for (idx_t row = 0; row < size; row++) {
-				if (val_mask.RowIsValid(row)) {
-					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
-					D_ASSERT(result);
-					(void)result;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT32: {
-			auto tgt_ptr = (int32_t *)FlatVector::GetData(vector);
-			for (idx_t row = 0; row < size; row++) {
-				if (val_mask.RowIsValid(row)) {
-					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
-					D_ASSERT(result);
-					(void)result;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT64: {
-			auto tgt_ptr = (int64_t *)FlatVector::GetData(vector);
-			for (idx_t row = 0; row < size; row++) {
-				if (val_mask.RowIsValid(row)) {
-					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
-					D_ASSERT(result);
-					(void)result;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT128: {
-			FlatVector::SetData(vector, (data_ptr_t)array.buffers[1] + GetTypeIdSize(vector.GetType().InternalType()) *
-			                                                               (scan_state.chunk_offset + array.offset));
-			break;
-		}
-		default:
-			throw std::runtime_error("Unsupported physical type for Decimal: " +
-			                         TypeIdToString(vector.GetType().InternalType()));
-		}
-		break;
-	}
-	case LogicalTypeId::BLOB: {
-		ArrowToDuckDBBlob(vector, array, scan_state, size, arrow_convert_data, col_idx, arrow_convert_idx,
-		                  nested_offset);
-		break;
-	}
-	case LogicalTypeId::LIST: {
-		ArrowToDuckDBList(vector, array, scan_state, size, arrow_convert_data, col_idx, arrow_convert_idx,
-		                  nested_offset, parent_mask);
-		break;
-	}
-	case LogicalTypeId::MAP: {
-		//! Since this is a map we skip first child, because its a struct
-		auto &struct_arrow = *array.children[0];
-		auto &child_entries = StructVector::GetEntries(vector);
-		D_ASSERT(child_entries.size() == 2);
-		auto offsets = (uint32_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
-		if (nested_offset != -1) {
-			offsets = (uint32_t *)array.buffers[1] + nested_offset;
-		}
-		auto &struct_validity_mask = FlatVector::Validity(vector);
-		//! Fill the children
-		for (idx_t type_idx = 0; type_idx < (idx_t)struct_arrow.n_children; type_idx++) {
-			ArrowToDuckDBMapList(*child_entries[type_idx], *struct_arrow.children[type_idx], scan_state, size,
-			                     arrow_convert_data, col_idx, arrow_convert_idx, offsets, &struct_validity_mask);
-		}
-		ArrowToDuckDBMapVerify(vector, size);
-		break;
-	}
-	case LogicalTypeId::STRUCT: {
-		//! Fill the children
-		auto &child_entries = StructVector::GetEntries(vector);
-		auto &struct_validity_mask = FlatVector::Validity(vector);
-		for (idx_t type_idx = 0; type_idx < (idx_t)array.n_children; type_idx++) {
-			SetValidityMask(*child_entries[type_idx], *array.children[type_idx], scan_state, size, nested_offset);
-			if (!struct_validity_mask.AllValid()) {
-				auto &child_validity_mark = FlatVector::Validity(*child_entries[type_idx]);
-				for (idx_t i = 0; i < size; i++) {
-					if (!struct_validity_mask.RowIsValid(i)) {
-						child_validity_mark.SetInvalid(i);
-					}
-				}
-			}
-			ColumnArrowToDuckDB(*child_entries[type_idx], *array.children[type_idx], scan_state, size,
-			                    arrow_convert_data, col_idx, arrow_convert_idx, nested_offset, &struct_validity_mask);
-		}
-		break;
-	}
-	default:
-		throw std::runtime_error("Unsupported type " + vector.GetType().ToString());
-	}
-}
-
-template <class T>
-static void SetSelectionVectorLoop(SelectionVector &sel, data_ptr_t indices_p, idx_t size) {
-	auto indices = (T *)indices_p;
-	for (idx_t row = 0; row < size; row++) {
-		sel.set_index(row, indices[row]);
-	}
-}
-
-template <class T>
-static void SetSelectionVectorLoopWithChecks(SelectionVector &sel, data_ptr_t indices_p, idx_t size) {
-
-	auto indices = (T *)indices_p;
-	for (idx_t row = 0; row < size; row++) {
-		if (indices[row] > NumericLimits<uint32_t>::Maximum()) {
-			throw std::runtime_error("DuckDB only supports indices that fit on an uint32");
-		}
-		sel.set_index(row, indices[row]);
-	}
-}
-
-template <class T>
-static void SetMaskedSelectionVectorLoop(SelectionVector &sel, data_ptr_t indices_p, idx_t size, ValidityMask &mask,
-                                         idx_t last_element_pos) {
-	auto indices = (T *)indices_p;
-	for (idx_t row = 0; row < size; row++) {
-		if (mask.RowIsValid(row)) {
-			sel.set_index(row, indices[row]);
-		} else {
-			//! Need to point out to last element
-			sel.set_index(row, last_element_pos);
-		}
-	}
-}
-
-void SetSelectionVector(SelectionVector &sel, data_ptr_t indices_p, LogicalType &logical_type, idx_t size,
-                        ValidityMask *mask = nullptr, idx_t last_element_pos = 0) {
-	sel.Initialize(size);
-
-	if (mask) {
-		switch (logical_type.id()) {
-		case LogicalTypeId::UTINYINT:
-			SetMaskedSelectionVectorLoop<uint8_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::TINYINT:
-			SetMaskedSelectionVectorLoop<int8_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::USMALLINT:
-			SetMaskedSelectionVectorLoop<uint16_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::SMALLINT:
-			SetMaskedSelectionVectorLoop<int16_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::UINTEGER:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! Its guaranteed that our indices will point to the last element, so just throw an error
-				throw std::runtime_error("DuckDB only supports indices that fit on an uint32");
-			}
-			SetMaskedSelectionVectorLoop<uint32_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::INTEGER:
-			SetMaskedSelectionVectorLoop<int32_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::UBIGINT:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! Its guaranteed that our indices will point to the last element, so just throw an error
-				throw std::runtime_error("DuckDB only supports indices that fit on an uint32");
-			}
-			SetMaskedSelectionVectorLoop<uint64_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-		case LogicalTypeId::BIGINT:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! Its guaranteed that our indices will point to the last element, so just throw an error
-				throw std::runtime_error("DuckDB only supports indices that fit on an uint32");
-			}
-			SetMaskedSelectionVectorLoop<int64_t>(sel, indices_p, size, *mask, last_element_pos);
-			break;
-
-		default:
-			throw std::runtime_error("(Arrow) Unsupported type for selection vectors " + logical_type.ToString());
-		}
-
-	} else {
-		switch (logical_type.id()) {
-		case LogicalTypeId::UTINYINT:
-			SetSelectionVectorLoop<uint8_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::TINYINT:
-			SetSelectionVectorLoop<int8_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::USMALLINT:
-			SetSelectionVectorLoop<uint16_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::SMALLINT:
-			SetSelectionVectorLoop<int16_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::UINTEGER:
-			SetSelectionVectorLoop<uint32_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::INTEGER:
-			SetSelectionVectorLoop<int32_t>(sel, indices_p, size);
-			break;
-		case LogicalTypeId::UBIGINT:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! We need to check if our indexes fit in a uint32_t
-				SetSelectionVectorLoopWithChecks<uint64_t>(sel, indices_p, size);
-			} else {
-				SetSelectionVectorLoop<uint64_t>(sel, indices_p, size);
-			}
-			break;
-		case LogicalTypeId::BIGINT:
-			if (last_element_pos > NumericLimits<uint32_t>::Maximum()) {
-				//! We need to check if our indexes fit in a uint32_t
-				SetSelectionVectorLoopWithChecks<int64_t>(sel, indices_p, size);
-			} else {
-				SetSelectionVectorLoop<int64_t>(sel, indices_p, size);
-			}
-			break;
-		default:
-			throw std::runtime_error("(Arrow) Unsupported type for selection vectors " + logical_type.ToString());
-		}
-	}
-}
-
-void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
-                                   std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
-                                   idx_t col_idx, std::pair<idx_t, idx_t> &arrow_convert_idx) {
-	SelectionVector sel;
-	auto &dict_vectors = scan_state.arrow_dictionary_vectors;
-	if (dict_vectors.find(col_idx) == dict_vectors.end()) {
-		//! We need to set the dictionary data for this column
-		auto base_vector = make_unique<Vector>(vector.GetType(), array.dictionary->length);
-		SetValidityMask(*base_vector, *array.dictionary, scan_state, array.dictionary->length, 0, array.null_count > 0);
-		ColumnArrowToDuckDB(*base_vector, *array.dictionary, scan_state, array.dictionary->length, arrow_convert_data,
-		                    col_idx, arrow_convert_idx);
-		dict_vectors[col_idx] = move(base_vector);
-	}
-	auto dictionary_type = arrow_convert_data[col_idx]->dictionary_type;
-	//! Get Pointer to Indices of Dictionary
-	auto indices = (data_ptr_t)array.buffers[1] +
-	               GetTypeIdSize(dictionary_type.InternalType()) * (scan_state.chunk_offset + array.offset);
-	if (array.null_count > 0) {
-		ValidityMask indices_validity;
-		GetValidityMask(indices_validity, array, scan_state, size);
-		SetSelectionVector(sel, indices, dictionary_type, size, &indices_validity, array.dictionary->length);
-	} else {
-		SetSelectionVector(sel, indices, dictionary_type, size);
-	}
-	vector.Slice(*dict_vectors[col_idx], sel, size);
-}
-
-void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state,
-                                       unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
-                                       DataChunk &output, idx_t start) {
-	for (idx_t idx = 0; idx < output.ColumnCount(); idx++) {
-		auto col_idx = scan_state.column_ids[idx];
-		std::pair<idx_t, idx_t> arrow_convert_idx {0, 0};
-		auto &array = *scan_state.chunk->arrow_array.children[idx];
-		if (!array.release) {
-			throw InvalidInputException("arrow_scan: released array passed");
-		}
-		if (array.length != scan_state.chunk->arrow_array.length) {
-			throw InvalidInputException("arrow_scan: array length mismatch");
-		}
-		output.data[idx].GetBuffer()->SetAuxiliaryData(make_unique<ArrowAuxiliaryData>(scan_state.chunk));
-		if (array.dictionary) {
-			ColumnArrowToDuckDBDictionary(output.data[idx], array, scan_state, output.size(), arrow_convert_data,
-			                              col_idx, arrow_convert_idx);
-		} else {
-			SetValidityMask(output.data[idx], array, scan_state, output.size(), -1);
-			ColumnArrowToDuckDB(output.data[idx], array, scan_state, output.size(), arrow_convert_data, col_idx,
-			                    arrow_convert_idx);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunctionBindInput &input,
-                                               vector<LogicalType> &return_types, vector<string> &names) {
-	return_types.emplace_back(LogicalType::BOOLEAN);
-	names.emplace_back("Success");
-	return nullptr;
-}
-
-template <bool FORCE>
-static void TemplatedCheckpointFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &transaction_manager = TransactionManager::Get(context);
-	transaction_manager.Checkpoint(context, FORCE);
-}
-
-void CheckpointFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction checkpoint("checkpoint", {}, TemplatedCheckpointFunction<false>, CheckpointBind);
-	set.AddFunction(checkpoint);
-	TableFunction force_checkpoint("force_checkpoint", {}, TemplatedCheckpointFunction<true>, CheckpointBind);
-	set.AddFunction(force_checkpoint);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-#include <limits>
-
-namespace duckdb {
-
-void SubstringDetection(string &str_1, string &str_2, const string &name_str_1, const string &name_str_2) {
-	if (str_1.empty() || str_2.empty()) {
-		return;
-	}
-	if (str_1.find(str_2) != string::npos || str_2.find(str_1) != std::string::npos) {
-		throw BinderException("%s must not appear in the %s specification and vice versa", name_str_1, name_str_2);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Bind
-//===--------------------------------------------------------------------===//
-
-void BaseCSVData::Finalize() {
-	// verify that the options are correct in the final pass
-	if (options.escape.empty()) {
-		options.escape = options.quote;
-	}
-	// escape and delimiter must not be substrings of each other
-	if (options.has_delimiter && options.has_escape) {
-		SubstringDetection(options.delimiter, options.escape, "DELIMITER", "ESCAPE");
-	}
-	// delimiter and quote must not be substrings of each other
-	if (options.has_quote && options.has_delimiter) {
-		SubstringDetection(options.quote, options.delimiter, "DELIMITER", "QUOTE");
-	}
-	// escape and quote must not be substrings of each other (but can be the same)
-	if (options.quote != options.escape && options.has_quote && options.has_escape) {
-		SubstringDetection(options.quote, options.escape, "QUOTE", "ESCAPE");
-	}
-	if (!options.null_str.empty()) {
-		// null string and delimiter must not be substrings of each other
-		if (options.has_delimiter) {
-			SubstringDetection(options.delimiter, options.null_str, "DELIMITER", "NULL");
-		}
-		// quote/escape and nullstr must not be substrings of each other
-		if (options.has_quote) {
-			SubstringDetection(options.quote, options.null_str, "QUOTE", "NULL");
-		}
-		if (options.has_escape) {
-			SubstringDetection(options.escape, options.null_str, "ESCAPE", "NULL");
-		}
-	}
-}
-
-static Value ConvertVectorToValue(vector<Value> set) {
-	if (set.empty()) {
-		return Value::EMPTYLIST(LogicalType::BOOLEAN);
-	}
-	return Value::LIST(move(set));
-}
-
-static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyInfo &info, vector<string> &names,
-                                             vector<LogicalType> &sql_types) {
-	auto bind_data = make_unique<WriteCSVData>(info.file_path, sql_types, names);
-
-	// check all the options in the copy info
-	for (auto &option : info.options) {
-		auto loption = StringUtil::Lower(option.first);
-		auto &set = option.second;
-		bind_data->options.SetWriteOption(loption, ConvertVectorToValue(move(set)));
-	}
-	// verify the parsed options
-	if (bind_data->options.force_quote.empty()) {
-		// no FORCE_QUOTE specified: initialize to false
-		bind_data->options.force_quote.resize(names.size(), false);
-	}
-	bind_data->Finalize();
-	bind_data->is_simple = bind_data->options.delimiter.size() == 1 && bind_data->options.escape.size() == 1 &&
-	                       bind_data->options.quote.size() == 1;
-	return move(bind_data);
-}
-
-static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, CopyInfo &info, vector<string> &expected_names,
-                                            vector<LogicalType> &expected_types) {
-	auto bind_data = make_unique<ReadCSVData>();
-	bind_data->sql_types = expected_types;
-
-	string file_pattern = info.file_path;
-
-	auto &fs = FileSystem::GetFileSystem(context);
-	bind_data->files = fs.Glob(file_pattern, context);
-	if (bind_data->files.empty()) {
-		throw IOException("No files found that match the pattern \"%s\"", file_pattern);
-	}
-
-	auto &options = bind_data->options;
-
-	// check all the options in the copy info
-	for (auto &option : info.options) {
-		auto loption = StringUtil::Lower(option.first);
-		auto &set = option.second;
-		options.SetReadOption(loption, ConvertVectorToValue(move(set)), expected_names);
-	}
-	// verify the parsed options
-	if (options.force_not_null.empty()) {
-		// no FORCE_QUOTE specified: initialize to false
-		options.force_not_null.resize(expected_types.size(), false);
-	}
-	bind_data->Finalize();
-	return move(bind_data);
-}
-
-//===--------------------------------------------------------------------===//
-// Helper writing functions
-//===--------------------------------------------------------------------===//
-static string AddEscapes(string &to_be_escaped, const string &escape, const string &val) {
-	idx_t i = 0;
-	string new_val = "";
-	idx_t found = val.find(to_be_escaped);
-
-	while (found != string::npos) {
-		while (i < found) {
-			new_val += val[i];
-			i++;
-		}
-		new_val += escape;
-		found = val.find(to_be_escaped, found + escape.length());
-	}
-	while (i < val.length()) {
-		new_val += val[i];
-		i++;
-	}
-	return new_val;
-}
-
-static bool RequiresQuotes(WriteCSVData &csv_data, const char *str, idx_t len) {
-	auto &options = csv_data.options;
-	// check if the string is equal to the null string
-	if (len == options.null_str.size() && memcmp(str, options.null_str.c_str(), len) == 0) {
-		return true;
-	}
-	if (csv_data.is_simple) {
-		// simple CSV: check for newlines, quotes and delimiter all at once
-		for (idx_t i = 0; i < len; i++) {
-			if (str[i] == '\n' || str[i] == '\r' || str[i] == options.quote[0] || str[i] == options.delimiter[0]) {
-				// newline, write a quoted string
-				return true;
-			}
-		}
-		// no newline, quote or delimiter in the string
-		// no quoting or escaping necessary
-		return false;
-	} else {
-		// CSV with complex quotes/delimiter (multiple bytes)
-
-		// first check for \n, \r, \n\r in string
-		for (idx_t i = 0; i < len; i++) {
-			if (str[i] == '\n' || str[i] == '\r') {
-				// newline, write a quoted string
-				return true;
-			}
-		}
-
-		// check for delimiter
-		if (ContainsFun::Find((const unsigned char *)str, len, (const unsigned char *)options.delimiter.c_str(),
-		                      options.delimiter.size()) != DConstants::INVALID_INDEX) {
-			return true;
-		}
-		// check for quote
-		if (ContainsFun::Find((const unsigned char *)str, len, (const unsigned char *)options.quote.c_str(),
-		                      options.quote.size()) != DConstants::INVALID_INDEX) {
-			return true;
-		}
-		return false;
-	}
-}
-
-static void WriteQuotedString(Serializer &serializer, WriteCSVData &csv_data, const char *str, idx_t len,
-                              bool force_quote) {
-	auto &options = csv_data.options;
-	if (!force_quote) {
-		// force quote is disabled: check if we need to add quotes anyway
-		force_quote = RequiresQuotes(csv_data, str, len);
-	}
-	if (force_quote) {
-		// quoting is enabled: we might need to escape things in the string
-		bool requires_escape = false;
-		if (csv_data.is_simple) {
-			// simple CSV
-			// do a single loop to check for a quote or escape value
-			for (idx_t i = 0; i < len; i++) {
-				if (str[i] == options.quote[0] || str[i] == options.escape[0]) {
-					requires_escape = true;
-					break;
-				}
-			}
-		} else {
-			// complex CSV
-			// check for quote or escape separately
-			if (ContainsFun::Find((const unsigned char *)str, len, (const unsigned char *)options.quote.c_str(),
-			                      options.quote.size()) != DConstants::INVALID_INDEX) {
-				requires_escape = true;
-			} else if (ContainsFun::Find((const unsigned char *)str, len, (const unsigned char *)options.escape.c_str(),
-			                             options.escape.size()) != DConstants::INVALID_INDEX) {
-				requires_escape = true;
-			}
-		}
-		if (!requires_escape) {
-			// fast path: no need to escape anything
-			serializer.WriteBufferData(options.quote);
-			serializer.WriteData((const_data_ptr_t)str, len);
-			serializer.WriteBufferData(options.quote);
-			return;
-		}
-
-		// slow path: need to add escapes
-		string new_val(str, len);
-		new_val = AddEscapes(options.escape, options.escape, new_val);
-		if (options.escape != options.quote) {
-			// need to escape quotes separately
-			new_val = AddEscapes(options.quote, options.escape, new_val);
-		}
-		serializer.WriteBufferData(options.quote);
-		serializer.WriteBufferData(new_val);
-		serializer.WriteBufferData(options.quote);
-	} else {
-		serializer.WriteData((const_data_ptr_t)str, len);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-struct LocalReadCSVData : public LocalFunctionData {
-	//! The thread-local buffer to write data into
-	BufferedSerializer serializer;
-	//! A chunk with VARCHAR columns to cast intermediates into
-	DataChunk cast_chunk;
-};
-
-struct GlobalWriteCSVData : public GlobalFunctionData {
-	GlobalWriteCSVData(FileSystem &fs, const string &file_path, FileOpener *opener, FileCompressionType compression)
-	    : fs(fs) {
-		handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW,
-		                     FileLockType::WRITE_LOCK, compression, opener);
-	}
-
-	void WriteData(const_data_ptr_t data, idx_t size) {
-		lock_guard<mutex> flock(lock);
-		handle->Write((void *)data, size);
-	}
-
-	FileSystem &fs;
-	//! The mutex for writing to the physical file
-	mutex lock;
-	//! The file handle to write to
-	unique_ptr<FileHandle> handle;
-};
-
-static unique_ptr<LocalFunctionData> WriteCSVInitializeLocal(ExecutionContext &context, FunctionData &bind_data) {
-	auto &csv_data = (WriteCSVData &)bind_data;
-	auto local_data = make_unique<LocalReadCSVData>();
-
-	// create the chunk with VARCHAR types
-	vector<LogicalType> types;
-	types.resize(csv_data.options.names.size(), LogicalType::VARCHAR);
-
-	local_data->cast_chunk.Initialize(Allocator::Get(context.client), types);
-	return move(local_data);
-}
-
-static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &context, FunctionData &bind_data,
-                                                               const string &file_path) {
-	auto &csv_data = (WriteCSVData &)bind_data;
-	auto &options = csv_data.options;
-	auto global_data = make_unique<GlobalWriteCSVData>(FileSystem::GetFileSystem(context), file_path,
-	                                                   FileSystem::GetFileOpener(context), options.compression);
-
-	if (options.header) {
-		BufferedSerializer serializer;
-		// write the header line to the file
-		for (idx_t i = 0; i < csv_data.options.names.size(); i++) {
-			if (i != 0) {
-				serializer.WriteBufferData(options.delimiter);
-			}
-			WriteQuotedString(serializer, csv_data, csv_data.options.names[i].c_str(), csv_data.options.names[i].size(),
-			                  false);
-		}
-		serializer.WriteBufferData(csv_data.newline);
-
-		global_data->WriteData(serializer.blob.data.get(), serializer.blob.size);
-	}
-	return move(global_data);
-}
-
-static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                         LocalFunctionData &lstate, DataChunk &input) {
-	auto &csv_data = (WriteCSVData &)bind_data;
-	auto &options = csv_data.options;
-	auto &local_data = (LocalReadCSVData &)lstate;
-	auto &global_state = (GlobalWriteCSVData &)gstate;
-
-	// write data into the local buffer
-
-	// first cast the columns of the chunk to varchar
-	auto &cast_chunk = local_data.cast_chunk;
-	cast_chunk.SetCardinality(input);
-	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-		if (csv_data.sql_types[col_idx].id() == LogicalTypeId::VARCHAR) {
-			// VARCHAR, just create a reference
-			cast_chunk.data[col_idx].Reference(input.data[col_idx]);
-		} else if (options.has_format[LogicalTypeId::DATE] && csv_data.sql_types[col_idx].id() == LogicalTypeId::DATE) {
-			// use the date format to cast the chunk
-			csv_data.options.write_date_format[LogicalTypeId::DATE].ConvertDateVector(
-			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
-		} else if (options.has_format[LogicalTypeId::TIMESTAMP] &&
-		           csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP) {
-			// use the timestamp format to cast the chunk
-			csv_data.options.write_date_format[LogicalTypeId::TIMESTAMP].ConvertTimestampVector(
-			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
-		} else {
-			// non varchar column, perform the cast
-			VectorOperations::Cast(input.data[col_idx], cast_chunk.data[col_idx], input.size());
-		}
-	}
-
-	cast_chunk.Normalify();
-	auto &writer = local_data.serializer;
-	// now loop over the vectors and output the values
-	for (idx_t row_idx = 0; row_idx < cast_chunk.size(); row_idx++) {
-		// write values
-		for (idx_t col_idx = 0; col_idx < cast_chunk.ColumnCount(); col_idx++) {
-			if (col_idx != 0) {
-				writer.WriteBufferData(options.delimiter);
-			}
-			if (FlatVector::IsNull(cast_chunk.data[col_idx], row_idx)) {
-				// write null value
-				writer.WriteBufferData(options.null_str);
-				continue;
-			}
-
-			// non-null value, fetch the string value from the cast chunk
-			auto str_data = FlatVector::GetData<string_t>(cast_chunk.data[col_idx]);
-			auto str_value = str_data[row_idx];
-			// FIXME: we could gain some performance here by checking for certain types if they ever require quotes
-			// (e.g. integers only require quotes if the delimiter is a number, decimals only require quotes if the
-			// delimiter is a number or "." character)
-			WriteQuotedString(writer, csv_data, str_value.GetDataUnsafe(), str_value.GetSize(),
-			                  csv_data.options.force_quote[col_idx]);
-		}
-		writer.WriteBufferData(csv_data.newline);
-	}
-	// check if we should flush what we have currently written
-	if (writer.blob.size >= csv_data.flush_size) {
-		global_state.WriteData(writer.blob.data.get(), writer.blob.size);
-		writer.Reset();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Combine
-//===--------------------------------------------------------------------===//
-static void WriteCSVCombine(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                            LocalFunctionData &lstate) {
-	auto &local_data = (LocalReadCSVData &)lstate;
-	auto &global_state = (GlobalWriteCSVData &)gstate;
-	auto &writer = local_data.serializer;
-	// flush the local writer
-	if (writer.blob.size > 0) {
-		global_state.WriteData(writer.blob.data.get(), writer.blob.size);
-		writer.Reset();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Finalize
-//===--------------------------------------------------------------------===//
-void WriteCSVFinalize(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate) {
-	auto &global_state = (GlobalWriteCSVData &)gstate;
-
-	global_state.handle->Close();
-	global_state.handle.reset();
-}
-
-void CSVCopyFunction::RegisterFunction(BuiltinFunctions &set) {
-	CopyFunction info("csv");
-	info.copy_to_bind = WriteCSVBind;
-	info.copy_to_initialize_local = WriteCSVInitializeLocal;
-	info.copy_to_initialize_global = WriteCSVInitializeGlobal;
-	info.copy_to_sink = WriteCSVSink;
-	info.copy_to_combine = WriteCSVCombine;
-	info.copy_to_finalize = WriteCSVFinalize;
-
-	info.copy_from_bind = ReadCSVBind;
-	info.copy_from_function = ReadCSVTableFunction::GetFunction();
-
-	info.extension = "csv";
-
-	set.AddFunction(info);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct GlobFunctionBindData : public TableFunctionData {
-	vector<string> files;
-};
-
-static unique_ptr<FunctionData> GlobFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                 vector<LogicalType> &return_types, vector<string> &names) {
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.enable_external_access) {
-		throw PermissionException("Globbing is disabled through configuration");
-	}
-	auto result = make_unique<GlobFunctionBindData>();
-	auto &fs = FileSystem::GetFileSystem(context);
-	result->files = fs.Glob(StringValue::Get(input.inputs[0]), context);
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("file");
-	return move(result);
-}
-
-struct GlobFunctionState : public GlobalTableFunctionState {
-	GlobFunctionState() : current_idx(0) {
-	}
-
-	idx_t current_idx;
-};
-
-static unique_ptr<GlobalTableFunctionState> GlobFunctionInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<GlobFunctionState>();
-}
-
-static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (GlobFunctionBindData &)*data_p.bind_data;
-	auto &state = (GlobFunctionState &)*data_p.global_state;
-
-	idx_t count = 0;
-	idx_t next_idx = MinValue<idx_t>(state.current_idx + STANDARD_VECTOR_SIZE, bind_data.files.size());
-	for (; state.current_idx < next_idx; state.current_idx++) {
-		output.data[0].SetValue(count, bind_data.files[state.current_idx]);
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void GlobTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet glob("glob");
-	glob.AddFunction(TableFunction({LogicalType::VARCHAR}, GlobFunction, GlobFunctionBind, GlobFunctionInit));
-	set.AddFunction(glob);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct PragmaDetailedProfilingOutputOperatorData : public GlobalTableFunctionState {
-	explicit PragmaDetailedProfilingOutputOperatorData() : chunk_index(0), initialized(false) {
-	}
-	idx_t chunk_index;
-	bool initialized;
-};
-
-struct PragmaDetailedProfilingOutputData : public TableFunctionData {
-	explicit PragmaDetailedProfilingOutputData(vector<LogicalType> &types) : types(types) {
-	}
-	unique_ptr<ChunkCollection> collection;
-	vector<LogicalType> types;
-};
-
-static unique_ptr<FunctionData> PragmaDetailedProfilingOutputBind(ClientContext &context, TableFunctionBindInput &input,
-                                                                  vector<LogicalType> &return_types,
-                                                                  vector<string> &names) {
-	names.emplace_back("OPERATOR_ID");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("ANNOTATION");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("ID");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("NAME");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("TIME");
-	return_types.emplace_back(LogicalType::DOUBLE);
-
-	names.emplace_back("CYCLES_PER_TUPLE");
-	return_types.emplace_back(LogicalType::DOUBLE);
-
-	names.emplace_back("SAMPLE_SIZE");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("INPUT_SIZE");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("EXTRA_INFO");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return make_unique<PragmaDetailedProfilingOutputData>(return_types);
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaDetailedProfilingOutputInit(ClientContext &context,
-                                                                       TableFunctionInitInput &input) {
-	return make_unique<PragmaDetailedProfilingOutputOperatorData>();
-}
-
-// Insert a row into the given datachunk
-static void SetValue(DataChunk &output, int index, int op_id, string annotation, int id, string name, double time,
-                     int sample_counter, int tuple_counter, string extra_info) {
-	output.SetValue(0, index, op_id);
-	output.SetValue(1, index, move(annotation));
-	output.SetValue(2, index, id);
-	output.SetValue(3, index, move(name));
-#if defined(RDTSC)
-	output.SetValue(4, index, Value(nullptr));
-	output.SetValue(5, index, time);
-#else
-	output.SetValue(4, index, time);
-	output.SetValue(5, index, Value(nullptr));
-
-#endif
-	output.SetValue(6, index, sample_counter);
-	output.SetValue(7, index, tuple_counter);
-	output.SetValue(8, index, move(extra_info));
-}
-
-static void ExtractFunctions(ChunkCollection &collection, ExpressionInfo &info, DataChunk &chunk, int op_id,
-                             int &fun_id) {
-	if (info.hasfunction) {
-		D_ASSERT(info.sample_tuples_count != 0);
-		SetValue(chunk, chunk.size(), op_id, "Function", fun_id++, info.function_name,
-		         int(info.function_time) / double(info.sample_tuples_count), info.sample_tuples_count,
-		         info.tuples_count, "");
-
-		chunk.SetCardinality(chunk.size() + 1);
-		if (chunk.size() == STANDARD_VECTOR_SIZE) {
-			collection.Append(chunk);
-			chunk.Reset();
-		}
-	}
-	if (info.children.empty()) {
-		return;
-	}
-	// extract the children of this node
-	for (auto &child : info.children) {
-		ExtractFunctions(collection, *child, chunk, op_id, fun_id);
-	}
-}
-
-static void PragmaDetailedProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p,
-                                                  DataChunk &output) {
-	auto &state = (PragmaDetailedProfilingOutputOperatorData &)*data_p.global_state;
-	auto &data = (PragmaDetailedProfilingOutputData &)*data_p.bind_data;
-
-	if (!state.initialized) {
-		// create a ChunkCollection
-		auto collection = make_unique<ChunkCollection>(context);
-
-		// create a chunk
-		DataChunk chunk;
-		chunk.Initialize(context, data.types);
-
-		// Initialize ids
-		int operator_counter = 1;
-		int function_counter = 1;
-		int expression_counter = 1;
-		if (ClientData::Get(context).query_profiler_history->GetPrevProfilers().empty()) {
-			return;
-		}
-		// For each Operator
-		for (auto op :
-		     ClientData::Get(context).query_profiler_history->GetPrevProfilers().back().second->GetTreeMap()) {
-			// For each Expression Executor
-			for (auto &expr_executor : op.second->info.executors_info) {
-				// For each Expression tree
-				if (!expr_executor) {
-					continue;
-				}
-				for (auto &expr_timer : expr_executor->roots) {
-					D_ASSERT(expr_timer->sample_tuples_count != 0);
-					SetValue(chunk, chunk.size(), operator_counter, "ExpressionRoot", expression_counter++,
-					         // Sometimes, cycle counter is not accurate, too big or too small. return 0 for
-					         // those cases
-					         expr_timer->name, int(expr_timer->time) / double(expr_timer->sample_tuples_count),
-					         expr_timer->sample_tuples_count, expr_timer->tuples_count, expr_timer->extra_info);
-					// Increment cardinality
-					chunk.SetCardinality(chunk.size() + 1);
-					// Check whether data chunk is full or not
-					if (chunk.size() == STANDARD_VECTOR_SIZE) {
-						collection->Append(chunk);
-						chunk.Reset();
-					}
-					// Extract all functions inside the tree
-					ExtractFunctions(*collection, *expr_timer->root, chunk, operator_counter, function_counter);
-				}
-			}
-			operator_counter++;
-		}
-		collection->Append(chunk);
-		data.collection = move(collection);
-		state.initialized = true;
-	}
-
-	if (state.chunk_index >= data.collection->ChunkCount()) {
-		output.SetCardinality(0);
-		return;
-	}
-	output.Reference(data.collection->GetChunk(state.chunk_index++));
-}
-
-void PragmaDetailedProfilingOutput::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_detailed_profiling_output", {}, PragmaDetailedProfilingOutputFunction,
-	                              PragmaDetailedProfilingOutputBind, PragmaDetailedProfilingOutputInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct PragmaLastProfilingOutputOperatorData : public GlobalTableFunctionState {
-	PragmaLastProfilingOutputOperatorData() : chunk_index(0), initialized(false) {
-	}
-	idx_t chunk_index;
-	bool initialized;
-};
-
-struct PragmaLastProfilingOutputData : public TableFunctionData {
-	explicit PragmaLastProfilingOutputData(vector<LogicalType> &types) : types(types) {
-	}
-	unique_ptr<ChunkCollection> collection;
-	vector<LogicalType> types;
-};
-
-static unique_ptr<FunctionData> PragmaLastProfilingOutputBind(ClientContext &context, TableFunctionBindInput &input,
-                                                              vector<LogicalType> &return_types,
-                                                              vector<string> &names) {
-	names.emplace_back("OPERATOR_ID");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("NAME");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("TIME");
-	return_types.emplace_back(LogicalType::DOUBLE);
-
-	names.emplace_back("CARDINALITY");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("DESCRIPTION");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return make_unique<PragmaLastProfilingOutputData>(return_types);
-}
-
-static void SetValue(DataChunk &output, int index, int op_id, string name, double time, int64_t car,
-                     string description) {
-	output.SetValue(0, index, op_id);
-	output.SetValue(1, index, move(name));
-	output.SetValue(2, index, time);
-	output.SetValue(3, index, car);
-	output.SetValue(4, index, move(description));
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaLastProfilingOutputInit(ClientContext &context,
-                                                                   TableFunctionInitInput &input) {
-	return make_unique<PragmaLastProfilingOutputOperatorData>();
-}
-
-static void PragmaLastProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &state = (PragmaLastProfilingOutputOperatorData &)*data_p.global_state;
-	auto &data = (PragmaLastProfilingOutputData &)*data_p.bind_data;
-	if (!state.initialized) {
-		// create a ChunkCollection
-		auto collection = make_unique<ChunkCollection>(context);
-
-		DataChunk chunk;
-		chunk.Initialize(context, data.types);
-		int operator_counter = 1;
-		if (!ClientData::Get(context).query_profiler_history->GetPrevProfilers().empty()) {
-			for (auto op :
-			     ClientData::Get(context).query_profiler_history->GetPrevProfilers().back().second->GetTreeMap()) {
-				SetValue(chunk, chunk.size(), operator_counter++, op.second->name, op.second->info.time,
-				         op.second->info.elements, " ");
-				chunk.SetCardinality(chunk.size() + 1);
-				if (chunk.size() == STANDARD_VECTOR_SIZE) {
-					collection->Append(chunk);
-					chunk.Reset();
-				}
-			}
-		}
-		collection->Append(chunk);
-		data.collection = move(collection);
-		state.initialized = true;
-	}
-
-	if (state.chunk_index >= data.collection->ChunkCount()) {
-		output.SetCardinality(0);
-		return;
-	}
-	output.Reference(data.collection->GetChunk(state.chunk_index++));
-}
-
-void PragmaLastProfilingOutput::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_last_profiling_output", {}, PragmaLastProfilingOutputFunction,
-	                              PragmaLastProfilingOutputBind, PragmaLastProfilingOutputInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Range (integers)
-//===--------------------------------------------------------------------===//
-struct RangeFunctionBindData : public TableFunctionData {
-	hugeint_t start;
-	hugeint_t end;
-	hugeint_t increment;
-
-public:
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const RangeFunctionBindData &)other_p;
-		return other.start == start && other.end == end && other.increment == increment;
-	}
-};
-
-template <bool GENERATE_SERIES>
-static unique_ptr<FunctionData> RangeFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_unique<RangeFunctionBindData>();
-	auto &inputs = input.inputs;
-	if (inputs.size() < 2) {
-		// single argument: only the end is specified
-		result->start = 0;
-		result->end = inputs[0].GetValue<int64_t>();
-	} else {
-		// two arguments: first two arguments are start and end
-		result->start = inputs[0].GetValue<int64_t>();
-		result->end = inputs[1].GetValue<int64_t>();
-	}
-	if (inputs.size() < 3) {
-		result->increment = 1;
-	} else {
-		result->increment = inputs[2].GetValue<int64_t>();
-	}
-	if (result->increment == 0) {
-		throw BinderException("interval cannot be 0!");
-	}
-	if (result->start > result->end && result->increment > 0) {
-		throw BinderException("start is bigger than end, but increment is positive: cannot generate infinite series");
-	} else if (result->start < result->end && result->increment < 0) {
-		throw BinderException("start is smaller than end, but increment is negative: cannot generate infinite series");
-	}
-	return_types.emplace_back(LogicalType::BIGINT);
-	if (GENERATE_SERIES) {
-		// generate_series has inclusive bounds on the RHS
-		if (result->increment < 0) {
-			result->end = result->end - 1;
-		} else {
-			result->end = result->end + 1;
-		}
-		names.emplace_back("generate_series");
-	} else {
-		names.emplace_back("range");
-	}
-	return move(result);
-}
-
-struct RangeFunctionState : public GlobalTableFunctionState {
-	RangeFunctionState() : current_idx(0) {
-	}
-
-	int64_t current_idx;
-};
-
-static unique_ptr<GlobalTableFunctionState> RangeFunctionInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<RangeFunctionState>();
-}
-
-static void RangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (RangeFunctionBindData &)*data_p.bind_data;
-	auto &state = (RangeFunctionState &)*data_p.global_state;
-
-	auto increment = bind_data.increment;
-	auto end = bind_data.end;
-	hugeint_t current_value = bind_data.start + increment * state.current_idx;
-	int64_t current_value_i64;
-	if (!Hugeint::TryCast<int64_t>(current_value, current_value_i64)) {
-		return;
-	}
-	// set the result vector as a sequence vector
-	output.data[0].Sequence(current_value_i64, Hugeint::Cast<int64_t>(increment));
-	int64_t offset = increment < 0 ? 1 : -1;
-	idx_t remaining = MinValue<idx_t>(Hugeint::Cast<idx_t>((end - current_value + (increment + offset)) / increment),
-	                                  STANDARD_VECTOR_SIZE);
-	// increment the index pointer by the remaining count
-	state.current_idx += remaining;
-	output.SetCardinality(remaining);
-}
-
-unique_ptr<NodeStatistics> RangeCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (RangeFunctionBindData &)*bind_data_p;
-	idx_t cardinality = Hugeint::Cast<idx_t>((bind_data.end - bind_data.start) / bind_data.increment);
-	return make_unique<NodeStatistics>(cardinality, cardinality);
-}
-
-//===--------------------------------------------------------------------===//
-// Range (timestamp)
-//===--------------------------------------------------------------------===//
-struct RangeDateTimeBindData : public TableFunctionData {
-	timestamp_t start;
-	timestamp_t end;
-	interval_t increment;
-	bool inclusive_bound;
-	bool greater_than_check;
-
-public:
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const RangeDateTimeBindData &)other_p;
-		return other.start == start && other.end == end && other.increment == increment &&
-		       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check;
-	}
-
-	bool Finished(timestamp_t current_value) {
-		if (greater_than_check) {
-			if (inclusive_bound) {
-				return current_value > end;
-			} else {
-				return current_value >= end;
-			}
-		} else {
-			if (inclusive_bound) {
-				return current_value < end;
-			} else {
-				return current_value <= end;
-			}
-		}
-	}
-};
-
-template <bool GENERATE_SERIES>
-static unique_ptr<FunctionData> RangeDateTimeBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_unique<RangeDateTimeBindData>();
-	auto &inputs = input.inputs;
-	D_ASSERT(inputs.size() == 3);
-	result->start = inputs[0].GetValue<timestamp_t>();
-	result->end = inputs[1].GetValue<timestamp_t>();
-	result->increment = inputs[2].GetValue<interval_t>();
-
-	// Infinities either cause errors or infinite loops, so just ban them
-	if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) {
-		throw BinderException("RANGE with infinite bounds is not supported");
-	}
-
-	if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) {
-		throw BinderException("interval cannot be 0!");
-	}
-	// all elements should point in the same direction
-	if (result->increment.months > 0 || result->increment.days > 0 || result->increment.micros > 0) {
-		if (result->increment.months < 0 || result->increment.days < 0 || result->increment.micros < 0) {
-			throw BinderException("RANGE with composite interval that has mixed signs is not supported");
-		}
-		result->greater_than_check = true;
-		if (result->start > result->end) {
-			throw BinderException(
-			    "start is bigger than end, but increment is positive: cannot generate infinite series");
-		}
-	} else {
-		result->greater_than_check = false;
-		if (result->start < result->end) {
-			throw BinderException(
-			    "start is smaller than end, but increment is negative: cannot generate infinite series");
-		}
-	}
-	return_types.push_back(inputs[0].type());
-	if (GENERATE_SERIES) {
-		// generate_series has inclusive bounds on the RHS
-		result->inclusive_bound = true;
-		names.emplace_back("generate_series");
-	} else {
-		result->inclusive_bound = false;
-		names.emplace_back("range");
-	}
-	return move(result);
-}
-
-struct RangeDateTimeState : public GlobalTableFunctionState {
-	explicit RangeDateTimeState(timestamp_t start_p) : current_state(start_p) {
-	}
-
-	timestamp_t current_state;
-	bool finished = false;
-};
-
-static unique_ptr<GlobalTableFunctionState> RangeDateTimeInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (RangeDateTimeBindData &)*input.bind_data;
-	return make_unique<RangeDateTimeState>(bind_data.start);
-}
-
-static void RangeDateTimeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (RangeDateTimeBindData &)*data_p.bind_data;
-	auto &state = (RangeDateTimeState &)*data_p.global_state;
-	if (state.finished) {
-		return;
-	}
-
-	idx_t size = 0;
-	auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
-	while (true) {
-		data[size++] = state.current_state;
-		state.current_state =
-		    AddOperator::Operation<timestamp_t, interval_t, timestamp_t>(state.current_state, bind_data.increment);
-		if (bind_data.Finished(state.current_state)) {
-			state.finished = true;
-			break;
-		}
-		if (size >= STANDARD_VECTOR_SIZE) {
-			break;
-		}
-	}
-	output.SetCardinality(size);
-}
-
-void RangeTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet range("range");
-
-	TableFunction range_function({LogicalType::BIGINT}, RangeFunction, RangeFunctionBind<false>, RangeFunctionInit);
-	range_function.cardinality = RangeCardinality;
-
-	// single argument range: (end) - implicit start = 0 and increment = 1
-	range.AddFunction(range_function);
-	// two arguments range: (start, end) - implicit increment = 1
-	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT};
-	range.AddFunction(range_function);
-	// three arguments range: (start, end, increment)
-	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT};
-	range.AddFunction(range_function);
-	range.AddFunction(TableFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
-	                                RangeDateTimeFunction, RangeDateTimeBind<false>, RangeDateTimeInit));
-	set.AddFunction(range);
-	// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
-	TableFunctionSet generate_series("generate_series");
-	range_function.bind = RangeFunctionBind<true>;
-	range_function.arguments = {LogicalType::BIGINT};
-	generate_series.AddFunction(range_function);
-	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT};
-	generate_series.AddFunction(range_function);
-	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT};
-	generate_series.AddFunction(range_function);
-	generate_series.AddFunction(TableFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
-	                                          RangeDateTimeFunction, RangeDateTimeBind<true>, RangeDateTimeInit));
-	set.AddFunction(generate_series);
-}
-
-void BuiltinFunctions::RegisterTableFunctions() {
-	CheckpointFunction::RegisterFunction(*this);
-	GlobTableFunction::RegisterFunction(*this);
-	RangeTableFunction::RegisterFunction(*this);
-	RepeatTableFunction::RegisterFunction(*this);
-	SummaryTableFunction::RegisterFunction(*this);
-	UnnestTableFunction::RegisterFunction(*this);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-#include <limits>
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctionBindInput &input,
-                                            vector<LogicalType> &return_types, vector<string> &names) {
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.enable_external_access) {
-		throw PermissionException("Scanning CSV files is disabled through configuration");
-	}
-	auto result = make_unique<ReadCSVData>();
-	auto &options = result->options;
-
-	auto &file_pattern = StringValue::Get(input.inputs[0]);
-
-	auto &fs = FileSystem::GetFileSystem(context);
-	result->files = fs.Glob(file_pattern, context);
-	if (result->files.empty()) {
-		throw IOException("No files found that match the pattern \"%s\"", file_pattern);
-	}
-
-	for (auto &kv : input.named_parameters) {
-		auto loption = StringUtil::Lower(kv.first);
-		if (loption == "columns") {
-			auto &child_type = kv.second.type();
-			if (child_type.id() != LogicalTypeId::STRUCT) {
-				throw BinderException("read_csv columns requires a struct as input");
-			}
-			auto &struct_children = StructValue::GetChildren(kv.second);
-			D_ASSERT(StructType::GetChildCount(child_type) == struct_children.size());
-			for (idx_t i = 0; i < struct_children.size(); i++) {
-				auto &name = StructType::GetChildName(child_type, i);
-				auto &val = struct_children[i];
-				names.push_back(name);
-				if (val.type().id() != LogicalTypeId::VARCHAR) {
-					throw BinderException("read_csv requires a type specification as string");
-				}
-				return_types.emplace_back(TransformStringToLogicalType(StringValue::Get(val)));
-			}
-			if (names.empty()) {
-				throw BinderException("read_csv requires at least a single column as input!");
-			}
-		} else if (loption == "all_varchar") {
-			options.all_varchar = BooleanValue::Get(kv.second);
-		} else if (loption == "normalize_names") {
-			options.normalize_names = BooleanValue::Get(kv.second);
-		} else if (loption == "filename") {
-			options.include_file_name = BooleanValue::Get(kv.second);
-		} else {
-			options.SetReadOption(loption, kv.second, names);
-		}
-	}
-	if (!options.auto_detect && return_types.empty()) {
-		throw BinderException("read_csv requires columns to be specified. Use read_csv_auto or set read_csv(..., "
-		                      "AUTO_DETECT=TRUE) to automatically guess columns.");
-	}
-	if (options.auto_detect) {
-		options.file_path = result->files[0];
-		auto initial_reader = make_unique<BufferedCSVReader>(context, options);
-
-		return_types.assign(initial_reader->sql_types.begin(), initial_reader->sql_types.end());
-		if (names.empty()) {
-			names.assign(initial_reader->col_names.begin(), initial_reader->col_names.end());
-		} else {
-			D_ASSERT(return_types.size() == names.size());
-		}
-		result->initial_reader = move(initial_reader);
-	} else {
-		result->sql_types = return_types;
-		D_ASSERT(return_types.size() == names.size());
-	}
-	if (result->options.include_file_name) {
-		return_types.emplace_back(LogicalType::VARCHAR);
-		names.emplace_back("filename");
-	}
-	return move(result);
-}
-
-struct ReadCSVOperatorData : public GlobalTableFunctionState {
-	//! The CSV reader
-	unique_ptr<BufferedCSVReader> csv_reader;
-	//! The index of the next file to read (i.e. current file + 1)
-	idx_t file_index;
-	//! Total File Size
-	idx_t file_size;
-	//! How many bytes were read up to this point
-	atomic<idx_t> bytes_read;
-};
-
-static unique_ptr<GlobalTableFunctionState> ReadCSVInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (ReadCSVData &)*input.bind_data;
-	auto result = make_unique<ReadCSVOperatorData>();
-	if (bind_data.initial_reader) {
-		result->csv_reader = move(bind_data.initial_reader);
-	} else {
-		bind_data.options.file_path = bind_data.files[0];
-		result->csv_reader = make_unique<BufferedCSVReader>(context, bind_data.options, bind_data.sql_types);
-	}
-	result->file_size = result->csv_reader->GetFileSize();
-	result->file_index = 1;
-	return move(result);
-}
-
-static unique_ptr<FunctionData> ReadCSVAutoBind(ClientContext &context, TableFunctionBindInput &input,
-                                                vector<LogicalType> &return_types, vector<string> &names) {
-	input.named_parameters["auto_detect"] = Value::BOOLEAN(true);
-	return ReadCSVBind(context, input, return_types, names);
-}
-
-static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (ReadCSVData &)*data_p.bind_data;
-	auto &data = (ReadCSVOperatorData &)*data_p.global_state;
-	do {
-		data.csv_reader->ParseCSV(output);
-		data.bytes_read = data.csv_reader->bytes_in_chunk;
-		if (output.size() == 0 && data.file_index < bind_data.files.size()) {
-			// exhausted this file, but we have more files we can read
-			// open the next file and increment the counter
-			bind_data.options.file_path = bind_data.files[data.file_index];
-			data.csv_reader = make_unique<BufferedCSVReader>(context, bind_data.options, data.csv_reader->sql_types);
-			data.file_index++;
-		} else {
-			break;
-		}
-	} while (true);
-	if (bind_data.options.include_file_name) {
-		auto &col = output.data.back();
-		col.SetValue(0, Value(data.csv_reader->options.file_path));
-		col.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-static void ReadCSVAddNamedParameters(TableFunction &table_function) {
-	table_function.named_parameters["sep"] = LogicalType::VARCHAR;
-	table_function.named_parameters["delim"] = LogicalType::VARCHAR;
-	table_function.named_parameters["quote"] = LogicalType::VARCHAR;
-	table_function.named_parameters["escape"] = LogicalType::VARCHAR;
-	table_function.named_parameters["nullstr"] = LogicalType::VARCHAR;
-	table_function.named_parameters["columns"] = LogicalType::ANY;
-	table_function.named_parameters["header"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["auto_detect"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["sample_size"] = LogicalType::BIGINT;
-	table_function.named_parameters["sample_chunk_size"] = LogicalType::BIGINT;
-	table_function.named_parameters["sample_chunks"] = LogicalType::BIGINT;
-	table_function.named_parameters["all_varchar"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["dateformat"] = LogicalType::VARCHAR;
-	table_function.named_parameters["timestampformat"] = LogicalType::VARCHAR;
-	table_function.named_parameters["normalize_names"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["compression"] = LogicalType::VARCHAR;
-	table_function.named_parameters["filename"] = LogicalType::BOOLEAN;
-	table_function.named_parameters["skip"] = LogicalType::BIGINT;
-	table_function.named_parameters["max_line_size"] = LogicalType::VARCHAR;
-	table_function.named_parameters["maximum_line_size"] = LogicalType::VARCHAR;
-}
-
-double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p,
-                         const GlobalTableFunctionState *global_state) {
-	auto &data = (const ReadCSVOperatorData &)*global_state;
-	if (data.file_size == 0) {
-		return 100;
-	}
-	auto percentage = (data.bytes_read * 100.0) / data.file_size;
-	return percentage;
-}
-
-TableFunction ReadCSVTableFunction::GetFunction() {
-	TableFunction read_csv("read_csv", {LogicalType::VARCHAR}, ReadCSVFunction, ReadCSVBind, ReadCSVInit);
-	read_csv.table_scan_progress = CSVReaderProgress;
-	ReadCSVAddNamedParameters(read_csv);
-	return read_csv;
-}
-
-void ReadCSVTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ReadCSVTableFunction::GetFunction());
-
-	TableFunction read_csv_auto("read_csv_auto", {LogicalType::VARCHAR}, ReadCSVFunction, ReadCSVAutoBind, ReadCSVInit);
-	read_csv_auto.table_scan_progress = CSVReaderProgress;
-	ReadCSVAddNamedParameters(read_csv_auto);
-	set.AddFunction(read_csv_auto);
-}
-
-unique_ptr<TableFunctionRef> ReadCSVReplacement(ClientContext &context, const string &table_name,
-                                                ReplacementScanData *data) {
-	auto lower_name = StringUtil::Lower(table_name);
-	// remove any compression
-	if (StringUtil::EndsWith(lower_name, ".gz")) {
-		lower_name = lower_name.substr(0, lower_name.size() - 3);
-	} else if (StringUtil::EndsWith(lower_name, ".zst")) {
-		lower_name = lower_name.substr(0, lower_name.size() - 4);
-	}
-	if (!StringUtil::EndsWith(lower_name, ".csv") && !StringUtil::EndsWith(lower_name, ".tsv")) {
-		return nullptr;
-	}
-	auto table_function = make_unique<TableFunctionRef>();
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_unique<ConstantExpression>(Value(table_name)));
-	table_function->function = make_unique<FunctionExpression>("read_csv_auto", move(children));
-	return table_function;
-}
-
-void BuiltinFunctions::RegisterReadFunctions() {
-	CSVCopyFunction::RegisterFunction(*this);
-	ReadCSVTableFunction::RegisterFunction(*this);
-
-	auto &config = DBConfig::GetConfig(context);
-	config.replacement_scans.emplace_back(ReadCSVReplacement);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct RepeatFunctionData : public TableFunctionData {
-	RepeatFunctionData(Value value, idx_t target_count) : value(move(value)), target_count(target_count) {
-	}
-
-	Value value;
-	idx_t target_count;
-};
-
-struct RepeatOperatorData : public GlobalTableFunctionState {
-	RepeatOperatorData() : current_count(0) {
-	}
-	idx_t current_count;
-};
-
-static unique_ptr<FunctionData> RepeatBind(ClientContext &context, TableFunctionBindInput &input,
-                                           vector<LogicalType> &return_types, vector<string> &names) {
-	// the repeat function returns the type of the first argument
-	auto &inputs = input.inputs;
-	return_types.push_back(inputs[0].type());
-	names.push_back(inputs[0].ToString());
-	return make_unique<RepeatFunctionData>(inputs[0], inputs[1].GetValue<int64_t>());
-}
-
-static unique_ptr<GlobalTableFunctionState> RepeatInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<RepeatOperatorData>();
-}
-
-static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (const RepeatFunctionData &)*data_p.bind_data;
-	auto &state = (RepeatOperatorData &)*data_p.global_state;
-
-	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
-	output.data[0].Reference(bind_data.value);
-	output.SetCardinality(remaining);
-	state.current_count += remaining;
-}
-
-static unique_ptr<NodeStatistics> RepeatCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const RepeatFunctionData &)*bind_data_p;
-	return make_unique<NodeStatistics>(bind_data.target_count, bind_data.target_count);
-}
-
-void RepeatTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction repeat("repeat", {LogicalType::ANY, LogicalType::BIGINT}, RepeatFunction, RepeatBind, RepeatInit);
-	repeat.cardinality = RepeatCardinality;
-	set.AddFunction(repeat);
-}
-
-} // namespace duckdb
-
-
-
-
-
-// this function makes not that much sense on its own but is a demo for table-parameter table-producing functions
-
-namespace duckdb {
-
-static unique_ptr<FunctionData> SummaryFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("summary");
-
-	for (idx_t i = 0; i < input.input_table_types.size(); i++) {
-		return_types.push_back(input.input_table_types[i]);
-		names.emplace_back(input.input_table_names[i]);
-	}
-
-	return make_unique<TableFunctionData>();
-}
-
-static OperatorResultType SummaryFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
-                                          DataChunk &output) {
-	output.SetCardinality(input.size());
-
-	for (idx_t row_idx = 0; row_idx < input.size(); row_idx++) {
-		string summary_val = "[";
-
-		for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-			summary_val += input.GetValue(col_idx, row_idx).ToString();
-			if (col_idx < input.ColumnCount() - 1) {
-				summary_val += ", ";
-			}
-		}
-		summary_val += "]";
-		output.SetValue(0, row_idx, Value(summary_val));
-	}
-	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-		output.data[col_idx + 1].Reference(input.data[col_idx]);
-	}
-	return OperatorResultType::NEED_MORE_INPUT;
-}
-
-void SummaryTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction summary_function("summary", {LogicalType::TABLE}, nullptr, SummaryFunctionBind);
-	summary_function.in_out_function = SummaryFunction;
-	set.AddFunction(summary_function);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-#include <set>
-
-namespace duckdb {
-
-struct DuckDBColumnsData : public GlobalTableFunctionState {
-	DuckDBColumnsData() : offset(0), column_offset(0) {
-	}
-
-	vector<CatalogEntry *> entries;
-	idx_t offset;
-	idx_t column_offset;
-};
-
-static unique_ptr<FunctionData> DuckDBColumnsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("table_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("table_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("column_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("column_index");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("column_default");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("is_nullable");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("data_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("data_type_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("character_maximum_length");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("numeric_precision");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("numeric_precision_radix");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("numeric_scale");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBColumnsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBColumnsData>();
-
-	// scan all the schemas for tables and views and collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	}
-
-	// check the temp schema as well
-	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::TABLE_ENTRY,
-	                                                 [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	return move(result);
-}
-
-class ColumnHelper {
-public:
-	static unique_ptr<ColumnHelper> Create(CatalogEntry *entry);
-
-	virtual ~ColumnHelper() {
-	}
-
-	virtual StandardEntry *Entry() = 0;
-	virtual idx_t NumColumns() = 0;
-	virtual const string &ColumnName(idx_t col) = 0;
-	virtual const LogicalType &ColumnType(idx_t col) = 0;
-	virtual const Value ColumnDefault(idx_t col) = 0;
-	virtual bool IsNullable(idx_t col) = 0;
-
-	void WriteColumns(idx_t index, idx_t start_col, idx_t end_col, DataChunk &output);
-};
-
-class TableColumnHelper : public ColumnHelper {
-public:
-	explicit TableColumnHelper(TableCatalogEntry *entry) : entry(entry) {
-		for (auto &constraint : entry->constraints) {
-			if (constraint->type == ConstraintType::NOT_NULL) {
-				auto &not_null = *reinterpret_cast<NotNullConstraint *>(constraint.get());
-				not_null_cols.insert(not_null.index);
-			}
-		}
-	}
-
-	StandardEntry *Entry() override {
-		return entry;
-	}
-	idx_t NumColumns() override {
-		return entry->columns.size();
-	}
-	const string &ColumnName(idx_t col) override {
-		return entry->columns[col].Name();
-	}
-	const LogicalType &ColumnType(idx_t col) override {
-		return entry->columns[col].Type();
-	}
-	const Value ColumnDefault(idx_t col) override {
-		if (entry->columns[col].DefaultValue()) {
-			return Value(entry->columns[col].DefaultValue()->ToString());
-		}
-		return Value();
-	}
-	bool IsNullable(idx_t col) override {
-		return not_null_cols.find(col) == not_null_cols.end();
-	}
-
-private:
-	TableCatalogEntry *entry;
-	std::set<idx_t> not_null_cols;
-};
-
-class ViewColumnHelper : public ColumnHelper {
-public:
-	explicit ViewColumnHelper(ViewCatalogEntry *entry) : entry(entry) {
-	}
-
-	StandardEntry *Entry() override {
-		return entry;
-	}
-	idx_t NumColumns() override {
-		return entry->types.size();
-	}
-	const string &ColumnName(idx_t col) override {
-		return entry->aliases[col];
-	}
-	const LogicalType &ColumnType(idx_t col) override {
-		return entry->types[col];
-	}
-	const Value ColumnDefault(idx_t col) override {
-		return Value();
-	}
-	bool IsNullable(idx_t col) override {
-		return true;
-	}
-
-private:
-	ViewCatalogEntry *entry;
-};
-
-unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry *entry) {
-	switch (entry->type) {
-	case CatalogType::TABLE_ENTRY:
-		return make_unique<TableColumnHelper>((TableCatalogEntry *)entry);
-	case CatalogType::VIEW_ENTRY:
-		return make_unique<ViewColumnHelper>((ViewCatalogEntry *)entry);
-	default:
-		throw NotImplementedException("Unsupported catalog type for duckdb_columns");
-	}
-}
-
-void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_col, DataChunk &output) {
-	for (idx_t i = start_col; i < end_col; i++) {
-		auto index = start_index + (i - start_col);
-		auto &entry = *Entry();
-
-		// schema_oid, BIGINT
-		output.SetValue(0, index, Value::BIGINT(entry.schema->oid));
-		// schema_name, VARCHAR
-		output.SetValue(1, index, entry.schema->name);
-		// table_oid, BIGINT
-		output.SetValue(2, index, Value::BIGINT(entry.oid));
-		// table_name, VARCHAR
-		output.SetValue(3, index, entry.name);
-		// column_name, VARCHAR
-		output.SetValue(4, index, Value(ColumnName(i)));
-		// column_index, INTEGER
-		output.SetValue(5, index, Value::INTEGER(i + 1));
-		// internal, BOOLEAN
-		output.SetValue(6, index, Value::BOOLEAN(entry.internal));
-		// column_default, VARCHAR
-		output.SetValue(7, index, Value(ColumnDefault(i)));
-		// is_nullable, BOOLEAN
-		output.SetValue(8, index, Value::BOOLEAN(IsNullable(i)));
-		// data_type, VARCHAR
-		const LogicalType &type = ColumnType(i);
-		output.SetValue(9, index, Value(type.ToString()));
-		// data_type_id, BIGINT
-		output.SetValue(10, index, Value::BIGINT(int(type.id())));
-		if (type == LogicalType::VARCHAR) {
-			// FIXME: need check constraints in place to set this correctly
-			// character_maximum_length, INTEGER
-			output.SetValue(11, index, Value());
-		} else {
-			// "character_maximum_length", PhysicalType::INTEGER
-			output.SetValue(11, index, Value());
-		}
-
-		Value numeric_precision, numeric_scale, numeric_precision_radix;
-		switch (type.id()) {
-		case LogicalTypeId::DECIMAL:
-			numeric_precision = Value::INTEGER(DecimalType::GetWidth(type));
-			numeric_scale = Value::INTEGER(DecimalType::GetScale(type));
-			numeric_precision_radix = Value::INTEGER(10);
-			break;
-		case LogicalTypeId::HUGEINT:
-			numeric_precision = Value::INTEGER(128);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::BIGINT:
-			numeric_precision = Value::INTEGER(64);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::INTEGER:
-			numeric_precision = Value::INTEGER(32);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::SMALLINT:
-			numeric_precision = Value::INTEGER(16);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::TINYINT:
-			numeric_precision = Value::INTEGER(8);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::FLOAT:
-			numeric_precision = Value::INTEGER(24);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		case LogicalTypeId::DOUBLE:
-			numeric_precision = Value::INTEGER(53);
-			numeric_scale = Value::INTEGER(0);
-			numeric_precision_radix = Value::INTEGER(2);
-			break;
-		default:
-			numeric_precision = Value();
-			numeric_scale = Value();
-			numeric_precision_radix = Value();
-			break;
-		}
-
-		// numeric_precision, INTEGER
-		output.SetValue(12, index, numeric_precision);
-		// numeric_precision_radix, INTEGER
-		output.SetValue(13, index, numeric_precision_radix);
-		// numeric_scale, INTEGER
-		output.SetValue(14, index, numeric_scale);
-	}
-}
-
-void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBColumnsData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-
-	// We need to track the offset of the relation we're writing as well as the last column
-	// we wrote from that relation (if any); it's possible that we can fill up the output
-	// with a partial list of columns from a relation and will need to pick up processing the
-	// next chunk at the same spot.
-	idx_t next = data.offset;
-	idx_t column_offset = data.column_offset;
-	idx_t index = 0;
-	while (next < data.entries.size() && index < STANDARD_VECTOR_SIZE) {
-		auto column_helper = ColumnHelper::Create(data.entries[next]);
-		idx_t columns = column_helper->NumColumns();
-
-		// Check to see if we are going to exceed the maximum index for a DataChunk
-		if (index + (columns - column_offset) > STANDARD_VECTOR_SIZE) {
-			idx_t column_limit = column_offset + (STANDARD_VECTOR_SIZE - index);
-			output.SetCardinality(STANDARD_VECTOR_SIZE);
-			column_helper->WriteColumns(index, column_offset, column_limit, output);
-
-			// Make the current column limit the column offset when we process the next chunk
-			column_offset = column_limit;
-			break;
-		} else {
-			// Otherwise, write all of the columns from the current relation and
-			// then move on to the next one.
-			output.SetCardinality(index + (columns - column_offset));
-			column_helper->WriteColumns(index, column_offset, columns, output);
-			index += columns - column_offset;
-			next++;
-			column_offset = 0;
-		}
-	}
-	data.offset = next;
-	data.column_offset = column_offset;
-}
-
-void DuckDBColumnsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_columns", {}, DuckDBColumnsFunction, DuckDBColumnsBind, DuckDBColumnsInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBConstraintsData : public GlobalTableFunctionState {
-	DuckDBConstraintsData() : offset(0), constraint_offset(0) {
-	}
-
-	vector<CatalogEntry *> entries;
-	idx_t offset;
-	idx_t constraint_offset;
-};
-
-static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                      vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("table_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("table_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("constraint_index");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	// CHECK, PRIMARY KEY or UNIQUE
-	names.emplace_back("constraint_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("constraint_text");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("expression");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("constraint_column_indexes");
-	;
-	return_types.push_back(LogicalType::LIST(LogicalType::BIGINT));
-
-	names.emplace_back("constraint_column_names");
-	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBConstraintsData>();
-
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	};
-
-	// check the temp schema as well
-	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::TABLE_ENTRY,
-	                                                 [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	return move(result);
-}
-
-void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBConstraintsData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-
-		if (entry->type != CatalogType::TABLE_ENTRY) {
-			data.offset++;
-			continue;
-		}
-
-		auto &table = (TableCatalogEntry &)*entry;
-		for (; data.constraint_offset < table.constraints.size() && count < STANDARD_VECTOR_SIZE;
-		     data.constraint_offset++) {
-			auto &constraint = table.constraints[data.constraint_offset];
-			// return values:
-			// schema_name, LogicalType::VARCHAR
-			output.SetValue(0, count, Value(table.schema->name));
-			// schema_oid, LogicalType::BIGINT
-			output.SetValue(1, count, Value::BIGINT(table.schema->oid));
-			// table_name, LogicalType::VARCHAR
-			output.SetValue(2, count, Value(table.name));
-			// table_oid, LogicalType::BIGINT
-			output.SetValue(3, count, Value::BIGINT(table.oid));
-
-			// constraint_index, BIGINT
-			output.SetValue(4, count, Value::BIGINT(data.constraint_offset));
-
-			// constraint_type, VARCHAR
-			string constraint_type;
-			switch (constraint->type) {
-			case ConstraintType::CHECK:
-				constraint_type = "CHECK";
-				break;
-			case ConstraintType::UNIQUE: {
-				auto &unique = (UniqueConstraint &)*constraint;
-				constraint_type = unique.is_primary_key ? "PRIMARY KEY" : "UNIQUE";
-				break;
-			}
-			case ConstraintType::NOT_NULL:
-				constraint_type = "NOT NULL";
-				break;
-			case ConstraintType::FOREIGN_KEY:
-				constraint_type = "FOREIGN KEY";
-				break;
-			default:
-				throw NotImplementedException("Unimplemented constraint for duckdb_constraints");
-			}
-			output.SetValue(5, count, Value(constraint_type));
-
-			// constraint_text, VARCHAR
-			output.SetValue(6, count, Value(constraint->ToString()));
-
-			// expression, VARCHAR
-			Value expression_text;
-			if (constraint->type == ConstraintType::CHECK) {
-				auto &check = (CheckConstraint &)*constraint;
-				expression_text = Value(check.expression->ToString());
-			}
-			output.SetValue(7, count, expression_text);
-
-			auto &bound_constraint = (BoundConstraint &)*table.bound_constraints[data.constraint_offset];
-			vector<column_t> column_index_list;
-			switch (bound_constraint.type) {
-			case ConstraintType::CHECK: {
-				auto &bound_check = (BoundCheckConstraint &)bound_constraint;
-				for (auto &col_idx : bound_check.bound_columns) {
-					column_index_list.push_back(col_idx);
-				}
-				break;
-			}
-			case ConstraintType::UNIQUE: {
-				auto &bound_unique = (BoundUniqueConstraint &)bound_constraint;
-				for (auto &col_idx : bound_unique.keys) {
-					column_index_list.push_back(column_t(col_idx));
-				}
-				break;
-			}
-			case ConstraintType::NOT_NULL: {
-				auto &bound_not_null = (BoundNotNullConstraint &)bound_constraint;
-				column_index_list.push_back(bound_not_null.index);
-				break;
-			}
-			case ConstraintType::FOREIGN_KEY: {
-				auto &bound_foreign_key = (BoundForeignKeyConstraint &)bound_constraint;
-				for (auto &col_idx : bound_foreign_key.info.fk_keys) {
-					column_index_list.push_back(column_t(col_idx));
-				}
-				break;
-			}
-			default:
-				throw NotImplementedException("Unimplemented constraint for duckdb_constraints");
-			}
-
-			vector<Value> index_list;
-			vector<Value> column_name_list;
-			for (auto column_index : column_index_list) {
-				index_list.push_back(Value::BIGINT(column_index));
-				column_name_list.emplace_back(table.columns[column_index].Name());
-			}
-
-			// constraint_column_indexes, LIST
-			output.SetValue(8, count, Value::LIST(move(index_list)));
-
-			// constraint_column_names, LIST
-			output.SetValue(9, count, Value::LIST(move(column_name_list)));
-
-			count++;
-		}
-		if (data.constraint_offset >= table.constraints.size()) {
-			data.constraint_offset = 0;
-			data.offset++;
-		}
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBConstraintsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_constraints", {}, DuckDBConstraintsFunction, DuckDBConstraintsBind,
-	                              DuckDBConstraintsInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DependencyInformation {
-	CatalogEntry *object;
-	CatalogEntry *dependent;
-	DependencyType type;
-};
-
-struct DuckDBDependenciesData : public GlobalTableFunctionState {
-	DuckDBDependenciesData() : offset(0) {
-	}
-
-	vector<DependencyInformation> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBDependenciesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                       vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("classid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("objid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("objsubid");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("refclassid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("refobjid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("refobjsubid");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("deptype");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBDependenciesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBDependenciesData>();
-
-	// scan all the schemas and collect them
-	auto &catalog = Catalog::GetCatalog(context);
-	auto &dependency_manager = catalog.GetDependencyManager();
-	dependency_manager.Scan([&](CatalogEntry *obj, CatalogEntry *dependent, DependencyType type) {
-		DependencyInformation info;
-		info.object = obj;
-		info.dependent = dependent;
-		info.type = type;
-		result->entries.push_back(info);
-	});
-
-	return move(result);
-}
-
-void DuckDBDependenciesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBDependenciesData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-
-		// return values:
-		// classid, LogicalType::BIGINT
-		output.SetValue(0, count, Value::BIGINT(0));
-		// objid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(entry.object->oid));
-		// objsubid, LogicalType::INTEGER
-		output.SetValue(2, count, Value::INTEGER(0));
-		// refclassid, LogicalType::BIGINT
-		output.SetValue(3, count, Value::BIGINT(0));
-		// refobjid, LogicalType::BIGINT
-		output.SetValue(4, count, Value::BIGINT(entry.dependent->oid));
-		// refobjsubid, LogicalType::INTEGER
-		output.SetValue(5, count, Value::INTEGER(0));
-		// deptype, LogicalType::VARCHAR
-		string dependency_type_str;
-		switch (entry.type) {
-		case DependencyType::DEPENDENCY_REGULAR:
-			dependency_type_str = "n";
-			break;
-		case DependencyType::DEPENDENCY_AUTOMATIC:
-			dependency_type_str = "a";
-			break;
-		default:
-			throw NotImplementedException("Unimplemented dependency type");
-		}
-		output.SetValue(6, count, Value(dependency_type_str));
-
-		data.offset++;
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBDependenciesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_dependencies", {}, DuckDBDependenciesFunction, DuckDBDependenciesBind,
-	                              DuckDBDependenciesInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct ExtensionInformation {
-	string name;
-	bool loaded = false;
-	bool installed = false;
-	string file_path;
-	string description;
-};
-
-struct DuckDBExtensionsData : public GlobalTableFunctionState {
-	DuckDBExtensionsData() : offset(0) {
-	}
-
-	vector<ExtensionInformation> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBExtensionsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                     vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("extension_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("loaded");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("installed");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("install_path");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("description");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBExtensionsData>();
-
-	auto &fs = FileSystem::GetFileSystem(context);
-	auto &db = DatabaseInstance::GetDatabase(context);
-
-	map<string, ExtensionInformation> installed_extensions;
-	auto extension_count = ExtensionHelper::DefaultExtensionCount();
-	for (idx_t i = 0; i < extension_count; i++) {
-		auto extension = ExtensionHelper::GetDefaultExtension(i);
-		ExtensionInformation info;
-		info.name = extension.name;
-		info.installed = extension.statically_loaded;
-		info.loaded = false;
-		info.file_path = extension.statically_loaded ? "(BUILT-IN)" : string();
-		info.description = extension.description;
-		installed_extensions[info.name] = move(info);
-	}
-
-	// scan the install directory for installed extensions
-	auto ext_directory = ExtensionHelper::ExtensionDirectory(fs);
-	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
-		if (!StringUtil::EndsWith(path, ".duckdb_extension")) {
-			return;
-		}
-		ExtensionInformation info;
-		info.name = fs.ExtractBaseName(path);
-		info.loaded = false;
-		info.file_path = fs.JoinPath(ext_directory, path);
-		auto entry = installed_extensions.find(info.name);
-		if (entry == installed_extensions.end()) {
-			installed_extensions[info.name] = move(info);
-		} else {
-			if (!entry->second.loaded) {
-				entry->second.file_path = info.file_path;
-			}
-			entry->second.installed = true;
-		}
-	});
-
-	// now check the list of currently loaded extensions
-	auto &loaded_extensions = db.LoadedExtensions();
-	for (auto &ext_name : loaded_extensions) {
-		auto entry = installed_extensions.find(ext_name);
-		if (entry == installed_extensions.end()) {
-			ExtensionInformation info;
-			info.name = ext_name;
-			info.loaded = true;
-			installed_extensions[ext_name] = move(info);
-		} else {
-			entry->second.loaded = true;
-		}
-	}
-
-	result->entries.reserve(installed_extensions.size());
-	for (auto &kv : installed_extensions) {
-		result->entries.push_back(move(kv.second));
-	}
-	return move(result);
-}
-
-void DuckDBExtensionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBExtensionsData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-
-		// return values:
-		// extension_name LogicalType::VARCHAR
-		output.SetValue(0, count, Value(entry.name));
-		// loaded LogicalType::BOOLEAN
-		output.SetValue(1, count, Value::BOOLEAN(entry.loaded));
-		// installed LogicalType::BOOLEAN
-		output.SetValue(2, count, !entry.installed && entry.loaded ? Value() : Value::BOOLEAN(entry.installed));
-		// install_path LogicalType::VARCHAR
-		output.SetValue(3, count, Value(entry.file_path));
-		// description LogicalType::VARCHAR
-		output.SetValue(4, count, Value(entry.description));
-
-		data.offset++;
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBExtensionsFun::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet functions("duckdb_extensions");
-	functions.AddFunction(TableFunction({}, DuckDBExtensionsFunction, DuckDBExtensionsBind, DuckDBExtensionsInit));
-	set.AddFunction(functions);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBFunctionsData : public GlobalTableFunctionState {
-	DuckDBFunctionsData() : offset(0), offset_in_entry(0) {
-	}
-
-	vector<CatalogEntry *> entries;
-	idx_t offset;
-	idx_t offset_in_entry;
-};
-
-static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("function_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("function_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("description");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("return_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("parameters");
-	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("parameter_types");
-	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("varargs");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("macro_definition");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("has_side_effects");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	return nullptr;
-}
-
-static void ExtractFunctionsFromSchema(ClientContext &context, SchemaCatalogEntry &schema,
-                                       DuckDBFunctionsData &result) {
-	schema.Scan(context, CatalogType::SCALAR_FUNCTION_ENTRY,
-	            [&](CatalogEntry *entry) { result.entries.push_back(entry); });
-	schema.Scan(context, CatalogType::TABLE_FUNCTION_ENTRY,
-	            [&](CatalogEntry *entry) { result.entries.push_back(entry); });
-	schema.Scan(context, CatalogType::PRAGMA_FUNCTION_ENTRY,
-	            [&](CatalogEntry *entry) { result.entries.push_back(entry); });
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBFunctionsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBFunctionsData>();
-
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		ExtractFunctionsFromSchema(context, *schema, *result);
-	};
-	ExtractFunctionsFromSchema(context, *ClientData::Get(context).temporary_objects, *result);
-
-	std::sort(result->entries.begin(), result->entries.end(),
-	          [&](CatalogEntry *a, CatalogEntry *b) { return (int)a->type < (int)b->type; });
-	return move(result);
-}
-
-struct ScalarFunctionExtractor {
-	static idx_t FunctionCount(ScalarFunctionCatalogEntry &entry) {
-		return entry.functions.size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("scalar");
-	}
-
-	static Value GetFunctionDescription(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetReturnType(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value(entry.functions[offset].return_type.ToString());
-	}
-
-	static Value GetParameters(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions[offset].arguments.size(); i++) {
-			results.emplace_back("col" + to_string(i));
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetParameterTypes(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions[offset].arguments.size(); i++) {
-			results.emplace_back(entry.functions[offset].arguments[i].ToString());
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetVarArgs(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return entry.functions[offset].varargs.id() == LogicalTypeId::INVALID
-		           ? Value()
-		           : Value(entry.functions[offset].varargs.ToString());
-	}
-
-	static Value GetMacroDefinition(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value HasSideEffects(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value::BOOLEAN(entry.functions[offset].has_side_effects);
-	}
-};
-
-struct AggregateFunctionExtractor {
-	static idx_t FunctionCount(AggregateFunctionCatalogEntry &entry) {
-		return entry.functions.size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("aggregate");
-	}
-
-	static Value GetFunctionDescription(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetReturnType(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value(entry.functions[offset].return_type.ToString());
-	}
-
-	static Value GetParameters(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions[offset].arguments.size(); i++) {
-			results.emplace_back("col" + to_string(i));
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetParameterTypes(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions[offset].arguments.size(); i++) {
-			results.emplace_back(entry.functions[offset].arguments[i].ToString());
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetVarArgs(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return entry.functions[offset].varargs.id() == LogicalTypeId::INVALID
-		           ? Value()
-		           : Value(entry.functions[offset].varargs.ToString());
-	}
-
-	static Value GetMacroDefinition(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value HasSideEffects(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value::BOOLEAN(entry.functions[offset].has_side_effects);
-	}
-};
-
-struct MacroExtractor {
-	static idx_t FunctionCount(ScalarMacroCatalogEntry &entry) {
-		return 1;
-	}
-
-	static Value GetFunctionType() {
-		return Value("macro");
-	}
-
-	static Value GetFunctionDescription(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetReturnType(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetParameters(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (auto &param : entry.function->parameters) {
-			D_ASSERT(param->type == ExpressionType::COLUMN_REF);
-			auto &colref = (ColumnRefExpression &)*param;
-			results.emplace_back(colref.GetColumnName());
-		}
-		for (auto &param_entry : entry.function->default_parameters) {
-			results.emplace_back(param_entry.first);
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetParameterTypes(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.function->parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		for (idx_t i = 0; i < entry.function->default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetVarArgs(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetMacroDefinition(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		D_ASSERT(entry.function->type == MacroType::SCALAR_MACRO);
-		auto &func = (ScalarMacroFunction &)*entry.function;
-		return func.expression->ToString();
-	}
-
-	static Value HasSideEffects(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-};
-
-struct TableMacroExtractor {
-	static idx_t FunctionCount(TableMacroCatalogEntry &entry) {
-		return 1;
-	}
-
-	static Value GetFunctionType() {
-		return Value("table_macro");
-	}
-
-	static Value GetFunctionDescription(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetReturnType(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetParameters(TableMacroCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (auto &param : entry.function->parameters) {
-			D_ASSERT(param->type == ExpressionType::COLUMN_REF);
-			auto &colref = (ColumnRefExpression &)*param;
-			results.emplace_back(colref.GetColumnName());
-		}
-		for (auto &param_entry : entry.function->default_parameters) {
-			results.emplace_back(param_entry.first);
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetParameterTypes(TableMacroCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.function->parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		for (idx_t i = 0; i < entry.function->default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetVarArgs(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetMacroDefinition(TableMacroCatalogEntry &entry, idx_t offset) {
-		if (entry.function->type == MacroType::SCALAR_MACRO) {
-			auto &func = (ScalarMacroFunction &)*entry.function;
-			return func.expression->ToString();
-		}
-		return Value();
-	}
-
-	static Value HasSideEffects(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-};
-
-struct TableFunctionExtractor {
-	static idx_t FunctionCount(TableFunctionCatalogEntry &entry) {
-		return entry.functions.size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("table");
-	}
-
-	static Value GetFunctionDescription(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetReturnType(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetParameters(TableFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions[offset].arguments.size(); i++) {
-			results.emplace_back("col" + to_string(i));
-		}
-		for (auto &param : entry.functions[offset].named_parameters) {
-			results.emplace_back(param.first);
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetParameterTypes(TableFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions[offset].arguments.size(); i++) {
-			results.emplace_back(entry.functions[offset].arguments[i].ToString());
-		}
-		for (auto &param : entry.functions[offset].named_parameters) {
-			results.emplace_back(param.second.ToString());
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetVarArgs(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return entry.functions[offset].varargs.id() == LogicalTypeId::INVALID
-		           ? Value()
-		           : Value(entry.functions[offset].varargs.ToString());
-	}
-
-	static Value GetMacroDefinition(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value HasSideEffects(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-};
-
-struct PragmaFunctionExtractor {
-	static idx_t FunctionCount(PragmaFunctionCatalogEntry &entry) {
-		return entry.functions.size();
-	}
-
-	static Value GetFunctionType() {
-		return Value("pragma");
-	}
-
-	static Value GetFunctionDescription(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetReturnType(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value GetParameters(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions[offset].arguments.size(); i++) {
-			results.emplace_back("col" + to_string(i));
-		}
-		for (auto &param : entry.functions[offset].named_parameters) {
-			results.emplace_back(param.first);
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetParameterTypes(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		vector<Value> results;
-		for (idx_t i = 0; i < entry.functions[offset].arguments.size(); i++) {
-			results.emplace_back(entry.functions[offset].arguments[i].ToString());
-		}
-		for (auto &param : entry.functions[offset].named_parameters) {
-			results.emplace_back(param.second.ToString());
-		}
-		return Value::LIST(LogicalType::VARCHAR, move(results));
-	}
-
-	static Value GetVarArgs(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return entry.functions[offset].varargs.id() == LogicalTypeId::INVALID
-		           ? Value()
-		           : Value(entry.functions[offset].varargs.ToString());
-	}
-
-	static Value GetMacroDefinition(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
-	static Value HasSideEffects(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-};
-
-template <class T, class OP>
-bool ExtractFunctionData(StandardEntry *entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
-	auto &function = (T &)*entry;
-	// schema_name, LogicalType::VARCHAR
-	output.SetValue(0, output_offset, Value(entry->schema->name));
-
-	// function_name, LogicalType::VARCHAR
-	output.SetValue(1, output_offset, Value(entry->name));
-
-	// function_type, LogicalType::VARCHAR
-	output.SetValue(2, output_offset, Value(OP::GetFunctionType()));
-
-	// function_description, LogicalType::VARCHAR
-	output.SetValue(3, output_offset, OP::GetFunctionDescription(function, function_idx));
-
-	// return_type, LogicalType::VARCHAR
-	output.SetValue(4, output_offset, OP::GetReturnType(function, function_idx));
-
-	// parameters, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(5, output_offset, OP::GetParameters(function, function_idx));
-
-	// parameter_types, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(6, output_offset, OP::GetParameterTypes(function, function_idx));
-
-	// varargs, LogicalType::VARCHAR
-	output.SetValue(7, output_offset, OP::GetVarArgs(function, function_idx));
-
-	// macro_definition, LogicalType::VARCHAR
-	output.SetValue(8, output_offset, OP::GetMacroDefinition(function, function_idx));
-
-	// has_side_effects, LogicalType::BOOLEAN
-	output.SetValue(9, output_offset, OP::HasSideEffects(function, function_idx));
-
-	return function_idx + 1 == OP::FunctionCount(function);
-}
-
-void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBFunctionsData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-		auto standard_entry = (StandardEntry *)entry;
-		bool finished = false;
-
-		switch (entry->type) {
-		case CatalogType::SCALAR_FUNCTION_ENTRY:
-			finished = ExtractFunctionData<ScalarFunctionCatalogEntry, ScalarFunctionExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
-			break;
-		case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-			finished = ExtractFunctionData<AggregateFunctionCatalogEntry, AggregateFunctionExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
-			break;
-		case CatalogType::TABLE_MACRO_ENTRY:
-			finished = ExtractFunctionData<TableMacroCatalogEntry, TableMacroExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
-			break;
-
-		case CatalogType::MACRO_ENTRY:
-			finished = ExtractFunctionData<ScalarMacroCatalogEntry, MacroExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
-			break;
-		case CatalogType::TABLE_FUNCTION_ENTRY:
-			finished = ExtractFunctionData<TableFunctionCatalogEntry, TableFunctionExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
-			break;
-		case CatalogType::PRAGMA_FUNCTION_ENTRY:
-			finished = ExtractFunctionData<PragmaFunctionCatalogEntry, PragmaFunctionExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
-			break;
-		default:
-			throw InternalException("FIXME: unrecognized function type in duckdb_functions");
-		}
-		if (finished) {
-			// finished with this function, move to the next function
-			data.offset++;
-			data.offset_in_entry = 0;
-		} else {
-			// more functions remain
-			data.offset_in_entry++;
-		}
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBFunctionsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_functions", {}, DuckDBFunctionsFunction, DuckDBFunctionsBind, DuckDBFunctionsInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBIndexesData : public GlobalTableFunctionState {
-	DuckDBIndexesData() : offset(0) {
-	}
-
-	vector<CatalogEntry *> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBIndexesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("index_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("index_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("table_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("table_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("is_unique");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("is_primary");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("expressions");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBIndexesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBIndexesData>();
-
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	};
-
-	// check the temp schema as well
-	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::INDEX_ENTRY,
-	                                                 [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	return move(result);
-}
-
-void DuckDBIndexesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBIndexesData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-
-		auto &index = (IndexCatalogEntry &)*entry;
-		// return values:
-
-		// schema_name, VARCHAR
-		output.SetValue(0, count, Value(index.schema->name));
-		// schema_oid, BIGINT
-		output.SetValue(1, count, Value::BIGINT(index.schema->oid));
-		// index_name, VARCHAR
-		output.SetValue(2, count, Value(index.name));
-		// index_oid, BIGINT
-		output.SetValue(3, count, Value::BIGINT(index.oid));
-		// table_name, VARCHAR
-		output.SetValue(4, count, Value(index.info->table));
-		// table_oid, BIGINT
-		// find the table in the catalog
-		auto &catalog = Catalog::GetCatalog(context);
-		auto table_entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, index.info->schema, index.info->table);
-		output.SetValue(5, count, Value::BIGINT(table_entry->oid));
-		// is_unique, BOOLEAN
-		output.SetValue(6, count, Value::BOOLEAN(index.index->IsUnique()));
-		// is_primary, BOOLEAN
-		output.SetValue(7, count, Value::BOOLEAN(index.index->IsPrimary()));
-		// expressions, VARCHAR
-		output.SetValue(8, count, Value());
-		// sql, VARCHAR
-		output.SetValue(9, count, Value(index.ToSQL()));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBIndexesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_indexes", {}, DuckDBIndexesFunction, DuckDBIndexesBind, DuckDBIndexesInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBKeywordsData : public GlobalTableFunctionState {
-	DuckDBKeywordsData() : offset(0) {
-	}
-
-	vector<ParserKeyword> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBKeywordsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                   vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("keyword_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("keyword_category");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBKeywordsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBKeywordsData>();
-	result->entries = Parser::KeywordList();
-	return move(result);
-}
-
-void DuckDBKeywordsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBKeywordsData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-
-		// keyword_name, VARCHAR
-		output.SetValue(0, count, Value(entry.name));
-		// keyword_category, VARCHAR
-		string category_name;
-		switch (entry.category) {
-		case KeywordCategory::KEYWORD_RESERVED:
-			category_name = "reserved";
-			break;
-		case KeywordCategory::KEYWORD_UNRESERVED:
-			category_name = "unreserved";
-			break;
-		case KeywordCategory::KEYWORD_TYPE_FUNC:
-			category_name = "type_function";
-			break;
-		case KeywordCategory::KEYWORD_COL_NAME:
-			category_name = "column_name";
-			break;
-		default:
-			throw InternalException("Unrecognized keyword category");
-		}
-		output.SetValue(1, count, Value(move(category_name)));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBKeywordsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_keywords", {}, DuckDBKeywordsFunction, DuckDBKeywordsBind, DuckDBKeywordsInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBSchemasData : public GlobalTableFunctionState {
-	DuckDBSchemasData() : offset(0) {
-	}
-
-	vector<SchemaCatalogEntry *> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBSchemasBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBSchemasInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBSchemasData>();
-
-	// scan all the schemas and collect them
-	Catalog::GetCatalog(context).ScanSchemas(
-	    context, [&](CatalogEntry *entry) { result->entries.push_back((SchemaCatalogEntry *)entry); });
-	// get the temp schema as well
-	result->entries.push_back(ClientData::Get(context).temporary_objects.get());
-
-	return move(result);
-}
-
-void DuckDBSchemasFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBSchemasData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-
-		// return values:
-		// "oid", PhysicalType::BIGINT
-		output.SetValue(0, count, Value::BIGINT(entry->oid));
-		// "schema_name", PhysicalType::VARCHAR
-		output.SetValue(1, count, Value(entry->name));
-		// "internal", PhysicalType::BOOLEAN
-		output.SetValue(2, count, Value::BOOLEAN(entry->internal));
-		// "sql", PhysicalType::VARCHAR
-		output.SetValue(3, count, Value());
-
-		data.offset++;
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBSchemasFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_schemas", {}, DuckDBSchemasFunction, DuckDBSchemasBind, DuckDBSchemasInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBSequencesData : public GlobalTableFunctionState {
-	DuckDBSequencesData() : offset(0) {
-	}
-
-	vector<CatalogEntry *> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBSequencesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("sequence_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("sequence_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("temporary");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("start_value");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("min_value");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("max_value");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("increment_by");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("cycle");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("last_value");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBSequencesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBSequencesData>();
-
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::SEQUENCE_ENTRY,
-		             [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	};
-
-	// check the temp schema as well
-	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::SEQUENCE_ENTRY,
-	                                                 [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	return move(result);
-}
-
-void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBSequencesData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-
-		auto &seq = (SequenceCatalogEntry &)*entry;
-		// return values:
-		// schema_name, VARCHAR
-		output.SetValue(0, count, Value(seq.schema->name));
-		// schema_oid, BIGINT
-		output.SetValue(1, count, Value::BIGINT(seq.schema->oid));
-		// sequence_name, VARCHAR
-		output.SetValue(2, count, Value(seq.name));
-		// sequence_oid, BIGINT
-		output.SetValue(3, count, Value::BIGINT(seq.oid));
-		// temporary, BOOLEAN
-		output.SetValue(4, count, Value::BOOLEAN(seq.temporary));
-		// start_value, BIGINT
-		output.SetValue(5, count, Value::BIGINT(seq.start_value));
-		// min_value, BIGINT
-		output.SetValue(6, count, Value::BIGINT(seq.min_value));
-		// max_value, BIGINT
-		output.SetValue(7, count, Value::BIGINT(seq.max_value));
-		// increment_by, BIGINT
-		output.SetValue(8, count, Value::BIGINT(seq.increment));
-		// cycle, BOOLEAN
-		output.SetValue(9, count, Value::BOOLEAN(seq.cycle));
-		// last_value, BIGINT
-		output.SetValue(10, count, seq.usage_count == 0 ? Value() : Value::BOOLEAN(seq.last_value));
-		// sql, LogicalType::VARCHAR
-		output.SetValue(11, count, Value(seq.ToSQL()));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBSequencesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_sequences", {}, DuckDBSequencesFunction, DuckDBSequencesBind, DuckDBSequencesInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBSettingValue {
-	string name;
-	string value;
-	string description;
-	string input_type;
-};
-
-struct DuckDBSettingsData : public GlobalTableFunctionState {
-	DuckDBSettingsData() : offset(0) {
-	}
-
-	vector<DuckDBSettingValue> settings;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBSettingsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                   vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("value");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("description");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("input_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBSettingsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBSettingsData>();
-
-	auto &config = DBConfig::GetConfig(context);
-	auto options_count = DBConfig::GetOptionCount();
-	for (idx_t i = 0; i < options_count; i++) {
-		auto option = DBConfig::GetOptionByIndex(i);
-		D_ASSERT(option);
-		DuckDBSettingValue value;
-		value.name = option->name;
-		value.value = option->get_setting(context).ToString();
-		value.description = option->description;
-		value.input_type = LogicalTypeIdToString(option->parameter_type);
-
-		result->settings.push_back(move(value));
-	}
-	for (auto &ext_param : config.extension_parameters) {
-		Value setting_val;
-		string setting_str_val;
-		if (context.TryGetCurrentSetting(ext_param.first, setting_val)) {
-			setting_str_val = setting_val.ToString();
-		}
-		DuckDBSettingValue value;
-		value.name = ext_param.first;
-		value.value = move(setting_str_val);
-		value.description = ext_param.second.description;
-		value.input_type = ext_param.second.type.ToString();
-
-		result->settings.push_back(move(value));
-	}
-	return move(result);
-}
-
-void DuckDBSettingsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBSettingsData &)*data_p.global_state;
-	if (data.offset >= data.settings.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.settings.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.settings[data.offset++];
-
-		// return values:
-		// name, LogicalType::VARCHAR
-		output.SetValue(0, count, Value(entry.name));
-		// value, LogicalType::VARCHAR
-		output.SetValue(1, count, Value(entry.value));
-		// description, LogicalType::VARCHAR
-		output.SetValue(2, count, Value(entry.description));
-		// input_type, LogicalType::VARCHAR
-		output.SetValue(3, count, Value(entry.input_type));
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBSettingsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_settings", {}, DuckDBSettingsFunction, DuckDBSettingsBind, DuckDBSettingsInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBTablesData : public GlobalTableFunctionState {
-	DuckDBTablesData() : offset(0) {
-	}
-
-	vector<CatalogEntry *> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBTablesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                 vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("table_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("table_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("temporary");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("has_primary_key");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("estimated_size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("column_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("index_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("check_constraint_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBTablesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBTablesData>();
-
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	};
-
-	// check the temp schema as well
-	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::TABLE_ENTRY,
-	                                                 [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	return move(result);
-}
-
-static bool TableHasPrimaryKey(TableCatalogEntry &table) {
-	for (auto &constraint : table.constraints) {
-		if (constraint->type == ConstraintType::UNIQUE) {
-			auto &unique = (UniqueConstraint &)*constraint;
-			if (unique.is_primary_key) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-static idx_t CheckConstraintCount(TableCatalogEntry &table) {
-	idx_t check_count = 0;
-	for (auto &constraint : table.constraints) {
-		if (constraint->type == ConstraintType::CHECK) {
-			check_count++;
-		}
-	}
-	return check_count;
-}
-
-void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBTablesData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-
-		if (entry->type != CatalogType::TABLE_ENTRY) {
-			continue;
-		}
-		auto &table = (TableCatalogEntry &)*entry;
-		// return values:
-		// schema_name, LogicalType::VARCHAR
-		output.SetValue(0, count, Value(table.schema->name));
-		// schema_oid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(table.schema->oid));
-		// table_name, LogicalType::VARCHAR
-		output.SetValue(2, count, Value(table.name));
-		// table_oid, LogicalType::BIGINT
-		output.SetValue(3, count, Value::BIGINT(table.oid));
-		// internal, LogicalType::BOOLEAN
-		output.SetValue(4, count, Value::BOOLEAN(table.internal));
-		// temporary, LogicalType::BOOLEAN
-		output.SetValue(5, count, Value::BOOLEAN(table.temporary));
-		// has_primary_key, LogicalType::BOOLEAN
-		output.SetValue(6, count, Value::BOOLEAN(TableHasPrimaryKey(table)));
-		// estimated_size, LogicalType::BIGINT
-		output.SetValue(7, count, Value::BIGINT(table.storage->info->cardinality.load()));
-		// column_count, LogicalType::BIGINT
-		output.SetValue(8, count, Value::BIGINT(table.columns.size()));
-		// index_count, LogicalType::BIGINT
-		output.SetValue(9, count, Value::BIGINT(table.storage->info->indexes.Count()));
-		// check_constraint_count, LogicalType::BIGINT
-		output.SetValue(10, count, Value::BIGINT(CheckConstraintCount(table)));
-		// sql, LogicalType::VARCHAR
-		output.SetValue(11, count, Value(table.ToSQL()));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBTablesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_tables", {}, DuckDBTablesFunction, DuckDBTablesBind, DuckDBTablesInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBTypesData : public GlobalTableFunctionState {
-	DuckDBTypesData() : offset(0) {
-	}
-
-	vector<TypeCatalogEntry *> entries;
-	idx_t offset;
-	unordered_set<int64_t> oids;
-};
-
-static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("type_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("type_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type_size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("logical_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	// NUMERIC, STRING, DATETIME, BOOLEAN, COMPOSITE, USER
-	names.emplace_back("type_category");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBTypesData>();
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TYPE_ENTRY,
-		             [&](CatalogEntry *entry) { result->entries.push_back((TypeCatalogEntry *)entry); });
-	};
-
-	// check the temp schema as well
-	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::TYPE_ENTRY, [&](CatalogEntry *entry) {
-		result->entries.push_back((TypeCatalogEntry *)entry);
-	});
-	return move(result);
-}
-
-void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBTypesData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &type_entry = data.entries[data.offset++];
-		auto &type = type_entry->user_type;
-
-		// return values:
-		// schema_name, LogicalType::VARCHAR
-		output.SetValue(0, count, Value(type_entry->schema->name));
-		// schema_oid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(type_entry->schema->oid));
-		// type_oid, BIGINT
-		int64_t oid;
-		if (type_entry->internal) {
-			oid = int64_t(type.id());
-		} else {
-			oid = type_entry->oid;
-		}
-		Value oid_val;
-		if (data.oids.find(oid) == data.oids.end()) {
-			data.oids.insert(oid);
-			oid_val = Value::BIGINT(oid);
-		} else {
-			oid_val = Value();
-		}
-		output.SetValue(2, count, oid_val);
-		// type_name, VARCHAR
-		output.SetValue(3, count, Value(type_entry->name));
-		// type_size, BIGINT
-		auto internal_type = type.InternalType();
-		output.SetValue(4, count,
-		                internal_type == PhysicalType::INVALID ? Value() : Value::BIGINT(GetTypeIdSize(internal_type)));
-		// logical_type, VARCHAR
-		output.SetValue(5, count, Value(LogicalTypeIdToString(type.id())));
-		// type_category, VARCHAR
-		string category;
-		switch (type.id()) {
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT:
-		case LogicalTypeId::DECIMAL:
-		case LogicalTypeId::FLOAT:
-		case LogicalTypeId::DOUBLE:
-		case LogicalTypeId::UTINYINT:
-		case LogicalTypeId::USMALLINT:
-		case LogicalTypeId::UINTEGER:
-		case LogicalTypeId::UBIGINT:
-		case LogicalTypeId::HUGEINT:
-			category = "NUMERIC";
-			break;
-		case LogicalTypeId::DATE:
-		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::INTERVAL:
-		case LogicalTypeId::TIME_TZ:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			category = "DATETIME";
-			break;
-		case LogicalTypeId::CHAR:
-		case LogicalTypeId::VARCHAR:
-			category = "STRING";
-			break;
-		case LogicalTypeId::BOOLEAN:
-			category = "BOOLEAN";
-			break;
-		case LogicalTypeId::STRUCT:
-		case LogicalTypeId::LIST:
-		case LogicalTypeId::MAP:
-			category = "COMPOSITE";
-			break;
-		default:
-			break;
-		}
-		output.SetValue(6, count, category.empty() ? Value() : Value(category));
-		// internal, BOOLEAN
-		output.SetValue(7, count, Value::BOOLEAN(type_entry->internal));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBTypesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_types", {}, DuckDBTypesFunction, DuckDBTypesBind, DuckDBTypesInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct DuckDBViewsData : public GlobalTableFunctionState {
-	DuckDBViewsData() : offset(0) {
-	}
-
-	vector<CatalogEntry *> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> DuckDBViewsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("schema_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("view_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("view_oid");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("internal");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("temporary");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("column_count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("sql");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> DuckDBViewsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBViewsData>();
-
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::VIEW_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	};
-
-	// check the temp schema as well
-	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::VIEW_ENTRY,
-	                                                 [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	return move(result);
-}
-
-void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBViewsData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
-
-		if (entry->type != CatalogType::VIEW_ENTRY) {
-			continue;
-		}
-		auto &view = (ViewCatalogEntry &)*entry;
-
-		// return values:
-		// schema_name, LogicalType::VARCHAR
-		output.SetValue(0, count, Value(view.schema->name));
-		// schema_oid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(view.schema->oid));
-		// view_name, LogicalType::VARCHAR
-		output.SetValue(2, count, Value(view.name));
-		// view_oid, LogicalType::BIGINT
-		output.SetValue(3, count, Value::BIGINT(view.oid));
-		// internal, LogicalType::BOOLEAN
-		output.SetValue(4, count, Value::BOOLEAN(view.internal));
-		// temporary, LogicalType::BOOLEAN
-		output.SetValue(5, count, Value::BOOLEAN(view.temporary));
-		// column_count, LogicalType::BIGINT
-		output.SetValue(6, count, Value::BIGINT(view.types.size()));
-		// sql, LogicalType::VARCHAR
-		output.SetValue(7, count, Value(view.ToSQL()));
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void DuckDBViewsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("duckdb_views", {}, DuckDBViewsFunction, DuckDBViewsBind, DuckDBViewsInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct PragmaCollateData : public GlobalTableFunctionState {
-	PragmaCollateData() : offset(0) {
-	}
-
-	vector<string> entries;
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> PragmaCollateBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("collname");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaCollateInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<PragmaCollateData>();
-
-	Catalog::GetCatalog(context).schemas->Scan(context, [&](CatalogEntry *entry) {
-		auto schema = (SchemaCatalogEntry *)entry;
-		schema->Scan(context, CatalogType::COLLATION_ENTRY,
-		             [&](CatalogEntry *entry) { result->entries.push_back(entry->name); });
-	});
-
-	return move(result);
-}
-
-static void PragmaCollateFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaCollateData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, data.entries.size());
-	output.SetCardinality(next - data.offset);
-	for (idx_t i = data.offset; i < next; i++) {
-		auto index = i - data.offset;
-		output.SetValue(0, index, Value(data.entries[i]));
-	}
-
-	data.offset = next;
-}
-
-void PragmaCollations::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("pragma_collations", {}, PragmaCollateFunction, PragmaCollateBind, PragmaCollateInit));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct PragmaDatabaseListData : public GlobalTableFunctionState {
-	PragmaDatabaseListData() : finished(false) {
-	}
-
-	bool finished;
-};
-
-static unique_ptr<FunctionData> PragmaDatabaseListBind(ClientContext &context, TableFunctionBindInput &input,
-                                                       vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("seq");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("file");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaDatabaseListInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaDatabaseListData>();
-}
-
-void PragmaDatabaseListFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaDatabaseListData &)*data_p.global_state;
-	if (data.finished) {
-		return;
-	}
-
-	output.SetCardinality(1);
-	output.data[0].SetValue(0, Value::INTEGER(0));
-	output.data[1].SetValue(0, Value("main"));
-	output.data[2].SetValue(0, Value(StorageManager::GetStorageManager(context).GetDBPath()));
-
-	data.finished = true;
-}
-
-void PragmaDatabaseList::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_database_list", {}, PragmaDatabaseListFunction, PragmaDatabaseListBind,
-	                              PragmaDatabaseListInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
-	PragmaDatabaseSizeData() : finished(false) {
-	}
-
-	bool finished;
-};
-
-static unique_ptr<FunctionData> PragmaDatabaseSizeBind(ClientContext &context, TableFunctionBindInput &input,
-                                                       vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("database_size");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("block_size");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("total_blocks");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("used_blocks");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("free_blocks");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("wal_size");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("memory_usage");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("memory_limit");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaDatabaseSizeInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaDatabaseSizeData>();
-}
-
-void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaDatabaseSizeData &)*data_p.global_state;
-	if (data.finished) {
-		return;
-	}
-	auto &storage = StorageManager::GetStorageManager(context);
-	auto &block_manager = BlockManager::GetBlockManager(context);
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-
-	output.SetCardinality(1);
-	if (!storage.InMemory()) {
-		auto total_blocks = block_manager.TotalBlocks();
-		auto block_size = Storage::BLOCK_ALLOC_SIZE;
-		auto free_blocks = block_manager.FreeBlocks();
-		auto used_blocks = total_blocks - free_blocks;
-		auto bytes = (total_blocks * block_size);
-		auto wal = storage.GetWriteAheadLog();
-		auto wal_size = wal ? wal->GetWALSize() : 0;
-		output.data[0].SetValue(0, Value(StringUtil::BytesToHumanReadableString(bytes)));
-		output.data[1].SetValue(0, Value::BIGINT(block_size));
-		output.data[2].SetValue(0, Value::BIGINT(total_blocks));
-		output.data[3].SetValue(0, Value::BIGINT(used_blocks));
-		output.data[4].SetValue(0, Value::BIGINT(free_blocks));
-		output.data[5].SetValue(0, Value(StringUtil::BytesToHumanReadableString(wal_size)));
-	} else {
-		output.data[0].SetValue(0, Value());
-		output.data[1].SetValue(0, Value());
-		output.data[2].SetValue(0, Value());
-		output.data[3].SetValue(0, Value());
-		output.data[4].SetValue(0, Value());
-		output.data[5].SetValue(0, Value());
-	}
-	output.data[6].SetValue(0, Value(StringUtil::BytesToHumanReadableString(buffer_manager.GetUsedMemory())));
-	auto max_memory = buffer_manager.GetMaxMemory();
-	output.data[7].SetValue(0, max_memory == (idx_t)-1 ? Value("Unlimited")
-	                                                   : Value(StringUtil::BytesToHumanReadableString(max_memory)));
-
-	data.finished = true;
-}
-
-void PragmaDatabaseSize::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_database_size", {}, PragmaDatabaseSizeFunction, PragmaDatabaseSizeBind,
-	                              PragmaDatabaseSizeInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct PragmaFunctionsData : public GlobalTableFunctionState {
-	PragmaFunctionsData() : offset(0), offset_in_entry(0) {
-	}
-
-	vector<CatalogEntry *> entries;
-	idx_t offset;
-	idx_t offset_in_entry;
-};
-
-static unique_ptr<FunctionData> PragmaFunctionsBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("parameters");
-	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
-
-	names.emplace_back("varargs");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("return_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("side_effects");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaFunctionsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<PragmaFunctionsData>();
-
-	Catalog::GetCatalog(context).schemas->Scan(context, [&](CatalogEntry *entry) {
-		auto schema = (SchemaCatalogEntry *)entry;
-		schema->Scan(context, CatalogType::SCALAR_FUNCTION_ENTRY,
-		             [&](CatalogEntry *entry) { result->entries.push_back(entry); });
-	});
-
-	return move(result);
-}
-
-void AddFunction(BaseScalarFunction &f, idx_t &count, DataChunk &output, bool is_aggregate) {
-	output.SetValue(0, count, Value(f.name));
-	output.SetValue(1, count, Value(is_aggregate ? "AGGREGATE" : "SCALAR"));
-	auto result_data = FlatVector::GetData<list_entry_t>(output.data[2]);
-	result_data[count].offset = ListVector::GetListSize(output.data[2]);
-	result_data[count].length = f.arguments.size();
-	string parameters;
-	for (idx_t i = 0; i < f.arguments.size(); i++) {
-		auto val = Value(f.arguments[i].ToString());
-		ListVector::PushBack(output.data[2], val);
-	}
-
-	output.SetValue(3, count, f.varargs.id() != LogicalTypeId::INVALID ? Value(f.varargs.ToString()) : Value());
-	output.SetValue(4, count, f.return_type.ToString());
-	output.SetValue(5, count, Value::BOOLEAN(f.has_side_effects));
-
-	count++;
-}
-
-static void PragmaFunctionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaFunctionsData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	idx_t count = 0;
-	while (count < STANDARD_VECTOR_SIZE && data.offset < data.entries.size()) {
-		auto &entry = data.entries[data.offset];
-		switch (entry->type) {
-		case CatalogType::SCALAR_FUNCTION_ENTRY: {
-			auto &func = (ScalarFunctionCatalogEntry &)*entry;
-			if (data.offset_in_entry >= func.functions.size()) {
-				data.offset++;
-				data.offset_in_entry = 0;
-				break;
-			}
-			AddFunction(func.functions[data.offset_in_entry++], count, output, false);
-			break;
-		}
-		case CatalogType::AGGREGATE_FUNCTION_ENTRY: {
-			auto &aggr = (AggregateFunctionCatalogEntry &)*entry;
-			if (data.offset_in_entry >= aggr.functions.size()) {
-				data.offset++;
-				data.offset_in_entry = 0;
-				break;
-			}
-			AddFunction(aggr.functions[data.offset_in_entry++], count, output, true);
-			break;
-		}
-		default:
-			data.offset++;
-			break;
-		}
-	}
-	output.SetCardinality(count);
-}
-
-void PragmaFunctionPragma::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("pragma_functions", {}, PragmaFunctionsFunction, PragmaFunctionsBind, PragmaFunctionsInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-struct PragmaStorageFunctionData : public TableFunctionData {
-	explicit PragmaStorageFunctionData(TableCatalogEntry *table_entry) : table_entry(table_entry) {
-	}
-
-	TableCatalogEntry *table_entry;
-	vector<vector<Value>> storage_info;
-};
-
-struct PragmaStorageOperatorData : public GlobalTableFunctionState {
-	PragmaStorageOperatorData() : offset(0) {
-	}
-
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, TableFunctionBindInput &input,
-                                                      vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("row_group_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("column_name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("column_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("column_path");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("segment_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("segment_type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("start");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("count");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("compression");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("stats");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("has_updates");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("persistent");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("block_id");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	names.emplace_back("block_offset");
-	return_types.emplace_back(LogicalType::BIGINT);
-
-	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
-
-	// look up the table name in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, qname.schema, qname.name);
-	if (entry->type != CatalogType::TABLE_ENTRY) {
-		throw Exception("storage_info requires a table as parameter");
-	}
-	auto table_entry = (TableCatalogEntry *)entry;
-
-	auto result = make_unique<PragmaStorageFunctionData>(table_entry);
-	result->storage_info = table_entry->storage->GetStorageInfo();
-	return move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaStorageInfoInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaStorageOperatorData>();
-}
-
-static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (PragmaStorageFunctionData &)*data_p.bind_data;
-	auto &data = (PragmaStorageOperatorData &)*data_p.global_state;
-	idx_t count = 0;
-	while (data.offset < bind_data.storage_info.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = bind_data.storage_info[data.offset++];
-		D_ASSERT(entry.size() + 1 == output.ColumnCount());
-		idx_t result_idx = 0;
-		for (idx_t col_idx = 0; col_idx < entry.size(); col_idx++, result_idx++) {
-			if (col_idx == 1) {
-				// write the column name
-				auto column_index = entry[col_idx].GetValue<int64_t>();
-				output.SetValue(result_idx, count, Value(bind_data.table_entry->columns[column_index].Name()));
-				result_idx++;
-			}
-			output.SetValue(result_idx, count, entry[col_idx]);
-		}
-
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void PragmaStorageInfo::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_storage_info", {LogicalType::VARCHAR}, PragmaStorageInfoFunction,
-	                              PragmaStorageInfoBind, PragmaStorageInfoInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-struct PragmaTableFunctionData : public TableFunctionData {
-	explicit PragmaTableFunctionData(CatalogEntry *entry_p) : entry(entry_p) {
-	}
-
-	CatalogEntry *entry;
-};
-
-struct PragmaTableOperatorData : public GlobalTableFunctionState {
-	PragmaTableOperatorData() : offset(0) {
-	}
-	idx_t offset;
-};
-
-static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("cid");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("type");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("notnull");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	names.emplace_back("dflt_value");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	names.emplace_back("pk");
-	return_types.emplace_back(LogicalType::BOOLEAN);
-
-	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
-
-	// look up the table name in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, qname.schema, qname.name);
-	return make_unique<PragmaTableFunctionData>(entry);
-}
-
-unique_ptr<GlobalTableFunctionState> PragmaTableInfoInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaTableOperatorData>();
-}
-
-static void CheckConstraints(TableCatalogEntry *table, idx_t oid, bool &out_not_null, bool &out_pk) {
-	out_not_null = false;
-	out_pk = false;
-	// check all constraints
-	// FIXME: this is pretty inefficient, it probably doesn't matter
-	for (auto &constraint : table->bound_constraints) {
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &not_null = (BoundNotNullConstraint &)*constraint;
-			if (not_null.index == oid) {
-				out_not_null = true;
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			auto &unique = (BoundUniqueConstraint &)*constraint;
-			if (unique.is_primary_key && unique.key_set.find(oid) != unique.key_set.end()) {
-				out_pk = true;
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-}
-
-static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry *table, DataChunk &output) {
-	if (data.offset >= table->columns.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, table->columns.size());
-	output.SetCardinality(next - data.offset);
-
-	for (idx_t i = data.offset; i < next; i++) {
-		bool not_null, pk;
-		auto index = i - data.offset;
-		auto &column = table->columns[i];
-		D_ASSERT(column.Oid() < (idx_t)NumericLimits<int32_t>::Maximum());
-		CheckConstraints(table, column.Oid(), not_null, pk);
-
-		// return values:
-		// "cid", PhysicalType::INT32
-		output.SetValue(0, index, Value::INTEGER((int32_t)column.Oid()));
-		// "name", PhysicalType::VARCHAR
-		output.SetValue(1, index, Value(column.Name()));
-		// "type", PhysicalType::VARCHAR
-		output.SetValue(2, index, Value(column.Type().ToString()));
-		// "notnull", PhysicalType::BOOL
-		output.SetValue(3, index, Value::BOOLEAN(not_null));
-		// "dflt_value", PhysicalType::VARCHAR
-		Value def_value = column.DefaultValue() ? Value(column.DefaultValue()->ToString()) : Value();
-		output.SetValue(4, index, def_value);
-		// "pk", PhysicalType::BOOL
-		output.SetValue(5, index, Value::BOOLEAN(pk));
-	}
-	data.offset = next;
-}
-
-static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry *view, DataChunk &output) {
-	if (data.offset >= view->types.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, view->types.size());
-	output.SetCardinality(next - data.offset);
-
-	for (idx_t i = data.offset; i < next; i++) {
-		auto index = i - data.offset;
-		auto type = view->types[index];
-		auto &name = view->aliases[index];
-		// return values:
-		// "cid", PhysicalType::INT32
-
-		output.SetValue(0, index, Value::INTEGER((int32_t)index));
-		// "name", PhysicalType::VARCHAR
-		output.SetValue(1, index, Value(name));
-		// "type", PhysicalType::VARCHAR
-		output.SetValue(2, index, Value(type.ToString()));
-		// "notnull", PhysicalType::BOOL
-		output.SetValue(3, index, Value::BOOLEAN(false));
-		// "dflt_value", PhysicalType::VARCHAR
-		output.SetValue(4, index, Value());
-		// "pk", PhysicalType::BOOL
-		output.SetValue(5, index, Value::BOOLEAN(false));
-	}
-	data.offset = next;
-}
-
-static void PragmaTableInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (PragmaTableFunctionData &)*data_p.bind_data;
-	auto &state = (PragmaTableOperatorData &)*data_p.global_state;
-	switch (bind_data.entry->type) {
-	case CatalogType::TABLE_ENTRY:
-		PragmaTableInfoTable(state, (TableCatalogEntry *)bind_data.entry, output);
-		break;
-	case CatalogType::VIEW_ENTRY:
-		PragmaTableInfoView(state, (ViewCatalogEntry *)bind_data.entry, output);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented catalog type for pragma_table_info");
-	}
-}
-
-void PragmaTableInfo::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_table_info", {LogicalType::VARCHAR}, PragmaTableInfoFunction,
-	                              PragmaTableInfoBind, PragmaTableInfoInit));
-}
-
-} // namespace duckdb
-
-
-
-
-#include <cmath>
-#include <limits>
-
-namespace duckdb {
-
-struct TestAllTypesData : public GlobalTableFunctionState {
-	TestAllTypesData() : offset(0) {
-	}
-
-	vector<vector<Value>> entries;
-	idx_t offset;
-};
-
-vector<TestType> TestAllTypesFun::GetTestTypes() {
-	vector<TestType> result;
-	// scalar types/numerics
-	result.emplace_back(LogicalType::BOOLEAN, "bool");
-	result.emplace_back(LogicalType::TINYINT, "tinyint");
-	result.emplace_back(LogicalType::SMALLINT, "smallint");
-	result.emplace_back(LogicalType::INTEGER, "int");
-	result.emplace_back(LogicalType::BIGINT, "bigint");
-	result.emplace_back(LogicalType::HUGEINT, "hugeint");
-	result.emplace_back(LogicalType::UTINYINT, "utinyint");
-	result.emplace_back(LogicalType::USMALLINT, "usmallint");
-	result.emplace_back(LogicalType::UINTEGER, "uint");
-	result.emplace_back(LogicalType::UBIGINT, "ubigint");
-	result.emplace_back(LogicalType::DATE, "date");
-	result.emplace_back(LogicalType::TIME, "time");
-	result.emplace_back(LogicalType::TIMESTAMP, "timestamp");
-	result.emplace_back(LogicalType::TIMESTAMP_S, "timestamp_s");
-	result.emplace_back(LogicalType::TIMESTAMP_MS, "timestamp_ms");
-	result.emplace_back(LogicalType::TIMESTAMP_NS, "timestamp_ns");
-	result.emplace_back(LogicalType::TIME_TZ, "time_tz");
-	result.emplace_back(LogicalType::TIMESTAMP_TZ, "timestamp_tz");
-	result.emplace_back(LogicalType::FLOAT, "float");
-	result.emplace_back(LogicalType::DOUBLE, "double");
-	result.emplace_back(LogicalType::DECIMAL(4, 1), "dec_4_1");
-	result.emplace_back(LogicalType::DECIMAL(9, 4), "dec_9_4");
-	result.emplace_back(LogicalType::DECIMAL(18, 6), "dec_18_6");
-	result.emplace_back(LogicalType::DECIMAL(38, 10), "dec38_10");
-	result.emplace_back(LogicalType::UUID, "uuid");
-
-	// interval
-	interval_t min_interval;
-	min_interval.months = 0;
-	min_interval.days = 0;
-	min_interval.micros = 0;
-
-	interval_t max_interval;
-	max_interval.months = 999;
-	max_interval.days = 999;
-	max_interval.micros = 999999999;
-	result.emplace_back(LogicalType::INTERVAL, "interval", Value::INTERVAL(min_interval),
-	                    Value::INTERVAL(max_interval));
-	// strings/blobs
-	result.emplace_back(LogicalType::VARCHAR, "varchar", Value("🦆🦆🦆🦆🦆🦆"), Value("goose"));
-	result.emplace_back(LogicalType::JSON, "json", Value("🦆🦆🦆🦆🦆🦆"), Value("goose"));
-	result.emplace_back(LogicalType::BLOB, "blob", Value::BLOB("thisisalongblob\\x00withnullbytes"),
-	                    Value("\\x00\\x00\\x00a"));
-
-	// enums
-	Vector small_enum(LogicalType::VARCHAR, 2);
-	auto small_enum_ptr = FlatVector::GetData<string_t>(small_enum);
-	small_enum_ptr[0] = StringVector::AddStringOrBlob(small_enum, "DUCK_DUCK_ENUM");
-	small_enum_ptr[1] = StringVector::AddStringOrBlob(small_enum, "GOOSE");
-	result.emplace_back(LogicalType::ENUM("small_enum", small_enum, 2), "small_enum");
-
-	Vector medium_enum(LogicalType::VARCHAR, 300);
-	auto medium_enum_ptr = FlatVector::GetData<string_t>(medium_enum);
-	for (idx_t i = 0; i < 300; i++) {
-		medium_enum_ptr[i] = StringVector::AddStringOrBlob(medium_enum, string("enum_") + to_string(i));
-	}
-	result.emplace_back(LogicalType::ENUM("medium_enum", medium_enum, 300), "medium_enum");
-
-	// this is a big one... not sure if we should push this one here, but it's required for completeness
-	Vector large_enum(LogicalType::VARCHAR, 70000);
-	auto large_enum_ptr = FlatVector::GetData<string_t>(large_enum);
-	for (idx_t i = 0; i < 70000; i++) {
-		large_enum_ptr[i] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(i));
-	}
-	result.emplace_back(LogicalType::ENUM("large_enum", large_enum, 70000), "large_enum");
-
-	// arrays
-	auto int_list_type = LogicalType::LIST(LogicalType::INTEGER);
-	auto empty_int_list = Value::EMPTYLIST(LogicalType::INTEGER);
-	auto int_list = Value::LIST({Value::INTEGER(42), Value::INTEGER(999), Value(LogicalType::INTEGER),
-	                             Value(LogicalType::INTEGER), Value::INTEGER(-42)});
-	result.emplace_back(int_list_type, "int_array", empty_int_list, int_list);
-
-	auto double_list_type = LogicalType::LIST(LogicalType::DOUBLE);
-	auto empty_double_list = Value::EMPTYLIST(LogicalType::DOUBLE);
-	auto double_list = Value::LIST(
-	    {Value::DOUBLE(42), Value::DOUBLE(NAN), Value::DOUBLE(std::numeric_limits<double>::infinity()),
-	     Value::DOUBLE(-std::numeric_limits<double>::infinity()), Value(LogicalType::DOUBLE), Value::DOUBLE(-42)});
-	result.emplace_back(double_list_type, "double_array", empty_double_list, double_list);
-
-	auto date_list_type = LogicalType::LIST(LogicalType::DATE);
-	auto empty_date_list = Value::EMPTYLIST(LogicalType::DATE);
-	auto date_list =
-	    Value::LIST({Value::DATE(date_t()), Value::DATE(date_t::infinity()), Value::DATE(date_t::ninfinity()),
-	                 Value(LogicalType::DATE), Value::DATE(Date::FromString("2022-05-12"))});
-	result.emplace_back(date_list_type, "date_array", empty_date_list, date_list);
-
-	auto timestamp_list_type = LogicalType::LIST(LogicalType::TIMESTAMP);
-	auto empty_timestamp_list = Value::EMPTYLIST(LogicalType::TIMESTAMP);
-	auto timestamp_list = Value::LIST({Value::TIMESTAMP(timestamp_t()), Value::TIMESTAMP(timestamp_t::infinity()),
-	                                   Value::TIMESTAMP(timestamp_t::ninfinity()), Value(LogicalType::TIMESTAMP),
-	                                   Value::TIMESTAMP(Timestamp::FromString("2022-05-12 16:23:45"))});
-	result.emplace_back(timestamp_list_type, "timestamp_array", empty_timestamp_list, timestamp_list);
-
-	auto timestamptz_list_type = LogicalType::LIST(LogicalType::TIMESTAMP_TZ);
-	auto empty_timestamptz_list = Value::EMPTYLIST(LogicalType::TIMESTAMP_TZ);
-	auto timestamptz_list = Value::LIST({Value::TIMESTAMPTZ(timestamp_t()), Value::TIMESTAMPTZ(timestamp_t::infinity()),
-	                                     Value::TIMESTAMPTZ(timestamp_t::ninfinity()), Value(LogicalType::TIMESTAMP_TZ),
-	                                     Value::TIMESTAMPTZ(Timestamp::FromString("2022-05-12 16:23:45-07"))});
-	result.emplace_back(timestamptz_list_type, "timestamptz_array", empty_timestamptz_list, timestamptz_list);
-
-	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto empty_varchar_list = Value::EMPTYLIST(LogicalType::VARCHAR);
-	auto varchar_list =
-	    Value::LIST({Value("🦆🦆🦆🦆🦆🦆"), Value("goose"), Value(LogicalType::VARCHAR), Value("")});
-	result.emplace_back(varchar_list_type, "varchar_array", empty_varchar_list, varchar_list);
-
-	// nested arrays
-	auto nested_list_type = LogicalType::LIST(int_list_type);
-	auto empty_nested_list = Value::EMPTYLIST(int_list_type);
-	auto nested_int_list = Value::LIST({empty_int_list, int_list, Value(int_list_type), empty_int_list, int_list});
-	result.emplace_back(nested_list_type, "nested_int_array", empty_nested_list, nested_int_list);
-
-	// structs
-	child_list_t<LogicalType> struct_type_list;
-	struct_type_list.push_back(make_pair("a", LogicalType::INTEGER));
-	struct_type_list.push_back(make_pair("b", LogicalType::VARCHAR));
-	auto struct_type = LogicalType::STRUCT(move(struct_type_list));
-
-	child_list_t<Value> min_struct_list;
-	min_struct_list.push_back(make_pair("a", Value(LogicalType::INTEGER)));
-	min_struct_list.push_back(make_pair("b", Value(LogicalType::VARCHAR)));
-	auto min_struct_val = Value::STRUCT(move(min_struct_list));
-
-	child_list_t<Value> max_struct_list;
-	max_struct_list.push_back(make_pair("a", Value::INTEGER(42)));
-	max_struct_list.push_back(make_pair("b", Value("🦆🦆🦆🦆🦆🦆")));
-	auto max_struct_val = Value::STRUCT(move(max_struct_list));
-
-	result.emplace_back(struct_type, "struct", min_struct_val, max_struct_val);
-
-	// structs with lists
-	child_list_t<LogicalType> struct_list_type_list;
-	struct_list_type_list.push_back(make_pair("a", int_list_type));
-	struct_list_type_list.push_back(make_pair("b", varchar_list_type));
-	auto struct_list_type = LogicalType::STRUCT(move(struct_list_type_list));
-
-	child_list_t<Value> min_struct_vl_list;
-	min_struct_vl_list.push_back(make_pair("a", Value(int_list_type)));
-	min_struct_vl_list.push_back(make_pair("b", Value(varchar_list_type)));
-	auto min_struct_val_list = Value::STRUCT(move(min_struct_vl_list));
-
-	child_list_t<Value> max_struct_vl_list;
-	max_struct_vl_list.push_back(make_pair("a", int_list));
-	max_struct_vl_list.push_back(make_pair("b", varchar_list));
-	auto max_struct_val_list = Value::STRUCT(move(max_struct_vl_list));
-
-	result.emplace_back(struct_list_type, "struct_of_arrays", move(min_struct_val_list), move(max_struct_val_list));
-
-	// array of structs
-	auto array_of_structs_type = LogicalType::LIST(struct_type);
-	auto min_array_of_struct_val = Value::EMPTYLIST(struct_type);
-	auto max_array_of_struct_val = Value::LIST({min_struct_val, max_struct_val, Value(struct_type)});
-	result.emplace_back(array_of_structs_type, "array_of_structs", move(min_array_of_struct_val),
-	                    move(max_array_of_struct_val));
-
-	// map
-	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-	auto min_map_value = Value::MAP(Value::EMPTYLIST(LogicalType::VARCHAR), Value::EMPTYLIST(LogicalType::VARCHAR));
-	auto max_map_value = Value::MAP(Value::LIST({Value("key1"), Value("key2")}),
-	                                Value::LIST({Value("🦆🦆🦆🦆🦆🦆"), Value("goose")}));
-	result.emplace_back(map_type, "map", move(min_map_value), move(max_map_value));
-
-	return result;
-}
-
-static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                 vector<LogicalType> &return_types, vector<string> &names) {
-	auto test_types = TestAllTypesFun::GetTestTypes();
-	for (auto &test_type : test_types) {
-		return_types.push_back(move(test_type.type));
-		names.push_back(move(test_type.name));
-	}
-	return nullptr;
-}
-
-unique_ptr<GlobalTableFunctionState> TestAllTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<TestAllTypesData>();
-	auto test_types = TestAllTypesFun::GetTestTypes();
-	// 3 rows: min, max and NULL
-	result->entries.resize(3);
-	// initialize the values
-	for (auto &test_type : test_types) {
-		result->entries[0].push_back(move(test_type.min_value));
-		result->entries[1].push_back(move(test_type.max_value));
-		result->entries[2].emplace_back(move(test_type.type));
-	}
-	return move(result);
-}
-
-void TestAllTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (TestAllTypesData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	// start returning values
-	// either fill up the chunk or return all the remaining columns
-	idx_t count = 0;
-	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &vals = data.entries[data.offset++];
-		for (idx_t col_idx = 0; col_idx < vals.size(); col_idx++) {
-			output.SetValue(col_idx, count, vals[col_idx]);
-		}
-		count++;
-	}
-	output.SetCardinality(count);
-}
-
-void TestAllTypesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("test_all_types", {}, TestAllTypesFunction, TestAllTypesBind, TestAllTypesInit));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-// FLAT, CONSTANT, DICTIONARY, SEQUENCE
-struct TestVectorBindData : public TableFunctionData {
-	LogicalType type;
-	bool all_flat;
-};
-
-struct TestVectorTypesData : public GlobalTableFunctionState {
-	TestVectorTypesData() : offset(0) {
-	}
-
-	vector<unique_ptr<DataChunk>> entries;
-	idx_t offset;
-};
-
-struct TestVectorInfo {
-	TestVectorInfo(const LogicalType &type, const map<LogicalTypeId, TestType> &test_type_map,
-	               vector<unique_ptr<DataChunk>> &entries)
-	    : type(type), test_type_map(test_type_map), entries(entries) {
-	}
-
-	const LogicalType &type;
-	const map<LogicalTypeId, TestType> &test_type_map;
-	vector<unique_ptr<DataChunk>> &entries;
-};
-
-struct TestVectorFlat {
-	static constexpr const idx_t TEST_VECTOR_CARDINALITY = 3;
-
-	static vector<Value> GenerateValues(TestVectorInfo &info, const LogicalType &type) {
-		vector<Value> result;
-		switch (type.InternalType()) {
-		case PhysicalType::STRUCT: {
-			vector<child_list_t<Value>> struct_children;
-			auto &child_types = StructType::GetChildTypes(type);
-
-			struct_children.resize(TEST_VECTOR_CARDINALITY);
-			for (auto &child_type : child_types) {
-				auto child_values = GenerateValues(info, child_type.second);
-
-				for (idx_t i = 0; i < child_values.size(); i++) {
-					struct_children[i].push_back(make_pair(child_type.first, move(child_values[i])));
-				}
-			}
-			for (auto &struct_child : struct_children) {
-				result.push_back(Value::STRUCT(move(struct_child)));
-			}
-			break;
-		}
-		case PhysicalType::LIST: {
-			auto &child_type = ListType::GetChildType(type);
-			auto child_values = GenerateValues(info, child_type);
-
-			result.push_back(Value::LIST(child_type, {child_values[0], child_values[1]}));
-			result.push_back(Value::LIST(child_type, {}));
-			result.push_back(Value::LIST(child_type, {child_values[2]}));
-			break;
-		}
-		default: {
-			auto entry = info.test_type_map.find(type.id());
-			if (entry == info.test_type_map.end()) {
-				throw NotImplementedException("Unimplemented type for test_vector_types %s", type.ToString());
-			}
-			result.push_back(entry->second.min_value);
-			result.push_back(entry->second.max_value);
-			result.emplace_back(type);
-			break;
-		}
-		}
-		return result;
-	}
-
-	static void Generate(TestVectorInfo &info) {
-		vector<Value> result_values = GenerateValues(info, info.type);
-		for (idx_t cur_row = 0; cur_row < result_values.size(); cur_row += STANDARD_VECTOR_SIZE) {
-			auto result = make_unique<DataChunk>();
-			result->Initialize(Allocator::DefaultAllocator(), {info.type});
-			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, result_values.size() - cur_row);
-			for (idx_t i = 0; i < cardinality; i++) {
-				result->data[0].SetValue(i, result_values[cur_row + i]);
-			}
-			result->SetCardinality(cardinality);
-			info.entries.push_back(move(result));
-		}
-	}
-};
-
-struct TestVectorConstant {
-	static void Generate(TestVectorInfo &info) {
-		auto values = TestVectorFlat::GenerateValues(info, info.type);
-		for (idx_t cur_row = 0; cur_row < TestVectorFlat::TEST_VECTOR_CARDINALITY; cur_row += STANDARD_VECTOR_SIZE) {
-			auto result = make_unique<DataChunk>();
-			result->Initialize(Allocator::DefaultAllocator(), {info.type});
-			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, TestVectorFlat::TEST_VECTOR_CARDINALITY - cur_row);
-			result->data[0].SetValue(0, values[0]);
-			result->data[0].SetVectorType(VectorType::CONSTANT_VECTOR);
-			result->SetCardinality(cardinality);
-
-			info.entries.push_back(move(result));
-		}
-	}
-};
-
-struct TestVectorSequence {
-	static void GenerateVector(TestVectorInfo &info, const LogicalType &type, Vector &result) {
-		D_ASSERT(type == result.GetType());
-		switch (type.id()) {
-		case LogicalTypeId::TINYINT:
-		case LogicalTypeId::SMALLINT:
-		case LogicalTypeId::INTEGER:
-		case LogicalTypeId::BIGINT:
-		case LogicalTypeId::UTINYINT:
-		case LogicalTypeId::USMALLINT:
-		case LogicalTypeId::UINTEGER:
-		case LogicalTypeId::UBIGINT:
-			result.Sequence(3, 2);
-			return;
-		default:
-			break;
-		}
-		switch (type.InternalType()) {
-		case PhysicalType::STRUCT: {
-			auto &child_entries = StructVector::GetEntries(result);
-			for (auto &child_entry : child_entries) {
-				GenerateVector(info, child_entry->GetType(), *child_entry);
-			}
-			break;
-		}
-		case PhysicalType::LIST: {
-			auto data = FlatVector::GetData<list_entry_t>(result);
-			data[0].offset = 0;
-			data[0].length = 2;
-			data[1].offset = 2;
-			data[1].length = 0;
-			data[2].offset = 2;
-			data[2].length = 1;
-
-			GenerateVector(info, ListType::GetChildType(type), ListVector::GetEntry(result));
-			ListVector::SetListSize(result, 3);
-			break;
-		}
-		default: {
-			auto entry = info.test_type_map.find(type.id());
-			if (entry == info.test_type_map.end()) {
-				throw NotImplementedException("Unimplemented type for test_vector_types %s", type.ToString());
-			}
-			result.SetValue(0, entry->second.min_value);
-			result.SetValue(1, entry->second.max_value);
-			result.SetValue(2, Value(type));
-			break;
-		}
-		}
-	}
-
-	static void Generate(TestVectorInfo &info) {
-#if STANDARD_VECTOR_SIZE > 2
-		auto result = make_unique<DataChunk>();
-		result->Initialize(Allocator::DefaultAllocator(), {info.type});
-
-		GenerateVector(info, info.type, result->data[0]);
-		result->SetCardinality(3);
-		info.entries.push_back(move(result));
-#endif
-	}
-};
-
-struct TestVectorDictionary {
-	static void Generate(TestVectorInfo &info) {
-		idx_t current_chunk = info.entries.size();
-
-		unordered_set<idx_t> slice_entries {1, 2};
-
-		TestVectorFlat::Generate(info);
-		idx_t current_idx = 0;
-		for (idx_t i = current_chunk; i < info.entries.size(); i++) {
-			auto &chunk = *info.entries[i];
-			SelectionVector sel(STANDARD_VECTOR_SIZE);
-			idx_t sel_idx = 0;
-			for (idx_t k = 0; k < chunk.size(); k++) {
-				if (slice_entries.count(current_idx + k) > 0) {
-					sel.set_index(sel_idx++, k);
-				}
-			}
-			chunk.Slice(sel, sel_idx);
-			current_idx += chunk.size();
-		}
-	}
-};
-
-static unique_ptr<FunctionData> TestVectorTypesBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_unique<TestVectorBindData>();
-	result->type = input.inputs[0].type();
-	result->all_flat = BooleanValue::Get(input.inputs[1]);
-
-	return_types.push_back(result->type);
-	names.emplace_back("test_vector");
-	return move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (TestVectorBindData &)*input.bind_data;
-
-	auto result = make_unique<TestVectorTypesData>();
-
-	auto test_types = TestAllTypesFun::GetTestTypes();
-
-	map<LogicalTypeId, TestType> test_type_map;
-	for (auto &test_type : test_types) {
-		test_type_map.insert(make_pair(test_type.type.id(), move(test_type)));
-	}
-
-	TestVectorInfo info(bind_data.type, test_type_map, result->entries);
-	TestVectorFlat::Generate(info);
-	TestVectorConstant::Generate(info);
-	TestVectorDictionary::Generate(info);
-	TestVectorSequence::Generate(info);
-	for (auto &entry : result->entries) {
-		entry->Verify();
-	}
-	if (bind_data.all_flat) {
-		for (auto &entry : result->entries) {
-			entry->Normalify();
-			entry->Verify();
-		}
-	}
-	return move(result);
-}
-
-void TestVectorTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (TestVectorTypesData &)*data_p.global_state;
-	if (data.offset >= data.entries.size()) {
-		// finished returning values
-		return;
-	}
-	output.Reference(*data.entries[data.offset]);
-	data.offset++;
-}
-
-void TestVectorTypesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("test_vector_types", {LogicalType::ANY, LogicalType::BOOLEAN},
-	                              TestVectorTypesFunction, TestVectorTypesBind, TestVectorTypesInit));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void BuiltinFunctions::RegisterSQLiteFunctions() {
-	PragmaVersion::RegisterFunction(*this);
-	PragmaFunctionPragma::RegisterFunction(*this);
-	PragmaCollations::RegisterFunction(*this);
-	PragmaTableInfo::RegisterFunction(*this);
-	PragmaStorageInfo::RegisterFunction(*this);
-	PragmaDatabaseSize::RegisterFunction(*this);
-	PragmaDatabaseList::RegisterFunction(*this);
-	PragmaLastProfilingOutput::RegisterFunction(*this);
-	PragmaDetailedProfilingOutput::RegisterFunction(*this);
-
-	DuckDBColumnsFun::RegisterFunction(*this);
-	DuckDBConstraintsFun::RegisterFunction(*this);
-	DuckDBFunctionsFun::RegisterFunction(*this);
-	DuckDBKeywordsFun::RegisterFunction(*this);
-	DuckDBIndexesFun::RegisterFunction(*this);
-	DuckDBSchemasFun::RegisterFunction(*this);
-	DuckDBDependenciesFun::RegisterFunction(*this);
-	DuckDBExtensionsFun::RegisterFunction(*this);
-	DuckDBSequencesFun::RegisterFunction(*this);
-	DuckDBSettingsFun::RegisterFunction(*this);
-	DuckDBTablesFun::RegisterFunction(*this);
-	DuckDBTypesFun::RegisterFunction(*this);
-	DuckDBViewsFun::RegisterFunction(*this);
-	TestAllTypesFun::RegisterFunction(*this);
-	TestVectorTypesFun::RegisterFunction(*this);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Table Scan
-//===--------------------------------------------------------------------===//
-bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
-                                LocalTableFunctionState *local_state, GlobalTableFunctionState *gstate);
-
-struct TableScanLocalState : public LocalTableFunctionState {
-	//! The current position in the scan
-	TableScanState scan_state;
-	vector<column_t> column_ids;
-};
-
-static storage_t GetStorageIndex(TableCatalogEntry &table, column_t column_id) {
-	if (column_id == DConstants::INVALID_INDEX) {
-		return column_id;
-	}
-	auto &col = table.columns[column_id];
-	return col.StorageOid();
-}
-
-struct TableScanGlobalState : public GlobalTableFunctionState {
-	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) {
-		D_ASSERT(bind_data_p);
-		auto &bind_data = (const TableScanBindData &)*bind_data_p;
-		max_threads = bind_data.table->storage->MaxThreads(context);
-	}
-
-	ParallelTableScanState state;
-	mutex lock;
-	idx_t max_threads;
-
-	idx_t MaxThreads() const override {
-		return max_threads;
-	}
-};
-
-static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ExecutionContext &context, TableFunctionInitInput &input,
-                                                              GlobalTableFunctionState *gstate) {
-	auto result = make_unique<TableScanLocalState>();
-	auto &bind_data = (TableScanBindData &)*input.bind_data;
-	result->column_ids = input.column_ids;
-	for (auto &col : result->column_ids) {
-		auto storage_idx = GetStorageIndex(*bind_data.table, col);
-		col = storage_idx;
-	}
-	result->scan_state.table_filters = input.filters;
-	TableScanParallelStateNext(context.client, input.bind_data, result.get(), gstate);
-	return move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
-	D_ASSERT(input.bind_data);
-	auto &bind_data = (const TableScanBindData &)*input.bind_data;
-	auto result = make_unique<TableScanGlobalState>(context, input.bind_data);
-	bind_data.table->storage->InitializeParallelScan(context, result->state);
-	return move(result);
-}
-
-static unique_ptr<BaseStatistics> TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p,
-                                                      column_t column_id) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &transaction = Transaction::GetTransaction(context);
-	if (transaction.storage.Find(bind_data.table->storage.get())) {
-		// we don't emit any statistics for tables that have outstanding transaction-local data
-		return nullptr;
-	}
-	auto storage_idx = GetStorageIndex(*bind_data.table, column_id);
-	return bind_data.table->storage->GetStatistics(context, storage_idx);
-}
-
-static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (TableScanBindData &)*data_p.bind_data;
-	auto &state = (TableScanLocalState &)*data_p.local_state;
-	auto &transaction = Transaction::GetTransaction(context);
-	do {
-		bind_data.table->storage->Scan(transaction, output, state.scan_state, state.column_ids);
-		if (output.size() > 0) {
-			return;
-		}
-		if (!TableScanParallelStateNext(context, data_p.bind_data, data_p.local_state, data_p.global_state)) {
-			return;
-		}
-	} while (true);
-}
-
-bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
-                                LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &parallel_state = (TableScanGlobalState &)*global_state;
-	auto &state = (TableScanLocalState &)*local_state;
-
-	lock_guard<mutex> parallel_lock(parallel_state.lock);
-	return bind_data.table->storage->NextParallelScan(context, parallel_state.state, state.scan_state,
-	                                                  state.column_ids);
-}
-
-double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p,
-                         const GlobalTableFunctionState *gstate) {
-	auto &bind_data = (TableScanBindData &)*bind_data_p;
-	idx_t total_rows = bind_data.table->storage->GetTotalRows();
-	if (total_rows == 0 || total_rows < STANDARD_VECTOR_SIZE) {
-		//! Table is either empty or smaller than a vector size, so it is finished
-		return 100;
-	}
-	auto percentage = double(bind_data.chunk_count * STANDARD_VECTOR_SIZE * 100.0) / total_rows;
-	if (percentage > 100) {
-		//! In case the last chunk has less elements than STANDARD_VECTOR_SIZE, if our percentage is over 100
-		//! It means we finished this table.
-		return 100;
-	}
-	return percentage;
-}
-
-idx_t TableScanGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
-                             LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &state = (TableScanLocalState &)*local_state;
-	if (state.scan_state.row_group_scan_state.row_group) {
-		return state.scan_state.row_group_scan_state.row_group->start;
-	}
-	if (state.scan_state.local_state.max_index > 0) {
-		return bind_data.table->storage->GetTotalRows() + state.scan_state.local_state.chunk_index;
-	}
-	return 0;
-}
-
-void TableScanDependency(unordered_set<CatalogEntry *> &entries, const FunctionData *bind_data_p) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	entries.insert(bind_data.table);
-}
-
-unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &transaction = Transaction::GetTransaction(context);
-	idx_t estimated_cardinality =
-	    bind_data.table->storage->info->cardinality + transaction.storage.AddedRows(bind_data.table->storage.get());
-	return make_unique<NodeStatistics>(bind_data.table->storage->info->cardinality, estimated_cardinality);
-}
-
-//===--------------------------------------------------------------------===//
-// Index Scan
-//===--------------------------------------------------------------------===//
-struct IndexScanGlobalState : public GlobalTableFunctionState {
-	explicit IndexScanGlobalState(data_ptr_t row_id_data) : row_ids(LogicalType::ROW_TYPE, row_id_data) {
-	}
-
-	Vector row_ids;
-	ColumnFetchState fetch_state;
-	LocalScanState local_storage_state;
-	vector<column_t> column_ids;
-	bool finished;
-};
-
-static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (const TableScanBindData &)*input.bind_data;
-	data_ptr_t row_id_data = nullptr;
-	if (!bind_data.result_ids.empty()) {
-		row_id_data = (data_ptr_t)&bind_data.result_ids[0];
-	}
-	auto result = make_unique<IndexScanGlobalState>(row_id_data);
-	auto &transaction = Transaction::GetTransaction(context);
-	result->column_ids = input.column_ids;
-	transaction.storage.InitializeScan(bind_data.table->storage.get(), result->local_storage_state, input.filters);
-
-	result->finished = false;
-	return move(result);
-}
-
-static void IndexScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (const TableScanBindData &)*data_p.bind_data;
-	auto &state = (IndexScanGlobalState &)*data_p.global_state;
-	auto &transaction = Transaction::GetTransaction(context);
-	if (!state.finished) {
-		bind_data.table->storage->Fetch(transaction, output, state.column_ids, state.row_ids,
-		                                bind_data.result_ids.size(), state.fetch_state);
-		state.finished = true;
-	}
-	if (output.size() == 0) {
-		transaction.storage.Scan(state.local_storage_state, state.column_ids, output);
-	}
-}
-
-static void RewriteIndexExpression(Index &index, LogicalGet &get, Expression &expr, bool &rewrite_possible) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)expr;
-		// bound column ref: rewrite to fit in the current set of bound column ids
-		bound_colref.binding.table_index = get.table_index;
-		column_t referenced_column = index.column_ids[bound_colref.binding.column_index];
-		// search for the referenced column in the set of column_ids
-		for (idx_t i = 0; i < get.column_ids.size(); i++) {
-			if (get.column_ids[i] == referenced_column) {
-				bound_colref.binding.column_index = i;
-				return;
-			}
-		}
-		// column id not found in bound columns in the LogicalGet: rewrite not possible
-		rewrite_possible = false;
-	}
-	ExpressionIterator::EnumerateChildren(
-	    expr, [&](Expression &child) { RewriteIndexExpression(index, get, child, rewrite_possible); });
-}
-
-void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
-                                    vector<unique_ptr<Expression>> &filters) {
-	auto &bind_data = (TableScanBindData &)*bind_data_p;
-	auto table = bind_data.table;
-	auto &storage = *table->storage;
-
-	if (bind_data.is_index_scan) {
-		return;
-	}
-	if (filters.empty()) {
-		// no indexes or no filters: skip the pushdown
-		return;
-	}
-	// behold
-	storage.info->indexes.Scan([&](Index &index) {
-		// first rewrite the index expression so the ColumnBindings align with the column bindings of the current table
-		if (index.unbound_expressions.size() > 1) {
-			return false;
-		}
-		auto index_expression = index.unbound_expressions[0]->Copy();
-		bool rewrite_possible = true;
-		RewriteIndexExpression(index, get, *index_expression, rewrite_possible);
-		if (!rewrite_possible) {
-			// could not rewrite!
-			return false;
-		}
-
-		Value low_value, high_value, equal_value;
-		ExpressionType low_comparison_type = ExpressionType::INVALID, high_comparison_type = ExpressionType::INVALID;
-		// try to find a matching index for any of the filter expressions
-		for (auto &filter : filters) {
-			auto expr = filter.get();
-
-			// create a matcher for a comparison with a constant
-			ComparisonExpressionMatcher matcher;
-			// match on a comparison type
-			matcher.expr_type = make_unique<ComparisonExpressionTypeMatcher>();
-			// match on a constant comparison with the indexed expression
-			matcher.matchers.push_back(make_unique<ExpressionEqualityMatcher>(index_expression.get()));
-			matcher.matchers.push_back(make_unique<ConstantExpressionMatcher>());
-
-			matcher.policy = SetMatcher::Policy::UNORDERED;
-
-			vector<Expression *> bindings;
-			if (matcher.Match(expr, bindings)) {
-				// range or equality comparison with constant value
-				// we can use our index here
-				// bindings[0] = the expression
-				// bindings[1] = the index expression
-				// bindings[2] = the constant
-				auto comparison = (BoundComparisonExpression *)bindings[0];
-				D_ASSERT(bindings[0]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-				D_ASSERT(bindings[2]->type == ExpressionType::VALUE_CONSTANT);
-
-				auto constant_value = ((BoundConstantExpression *)bindings[2])->value;
-				auto comparison_type = comparison->type;
-				if (comparison->left->type == ExpressionType::VALUE_CONSTANT) {
-					// the expression is on the right side, we flip them around
-					comparison_type = FlipComparisionExpression(comparison_type);
-				}
-				if (comparison_type == ExpressionType::COMPARE_EQUAL) {
-					// equality value
-					// equality overrides any other bounds so we just break here
-					equal_value = constant_value;
-					break;
-				} else if (comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-				           comparison_type == ExpressionType::COMPARE_GREATERTHAN) {
-					// greater than means this is a lower bound
-					low_value = constant_value;
-					low_comparison_type = comparison_type;
-				} else {
-					// smaller than means this is an upper bound
-					high_value = constant_value;
-					high_comparison_type = comparison_type;
-				}
-			} else if (expr->type == ExpressionType::COMPARE_BETWEEN) {
-				// BETWEEN expression
-				auto &between = (BoundBetweenExpression &)*expr;
-				if (!between.input->Equals(index_expression.get())) {
-					// expression doesn't match the current index expression
-					continue;
-				}
-				if (between.lower->type != ExpressionType::VALUE_CONSTANT ||
-				    between.upper->type != ExpressionType::VALUE_CONSTANT) {
-					// not a constant comparison
-					continue;
-				}
-				low_value = ((BoundConstantExpression &)*between.lower).value;
-				low_comparison_type = between.lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
-				                                              : ExpressionType::COMPARE_GREATERTHAN;
-				high_value = ((BoundConstantExpression &)*between.upper).value;
-				high_comparison_type = between.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
-				                                               : ExpressionType::COMPARE_LESSTHAN;
-				break;
-			}
-		}
-		if (!equal_value.IsNull() || !low_value.IsNull() || !high_value.IsNull()) {
-			// we can scan this index using this predicate: try a scan
-			auto &transaction = Transaction::GetTransaction(context);
-			unique_ptr<IndexScanState> index_state;
-			if (!equal_value.IsNull()) {
-				// equality predicate
-				index_state =
-				    index.InitializeScanSinglePredicate(transaction, equal_value, ExpressionType::COMPARE_EQUAL);
-			} else if (!low_value.IsNull() && !high_value.IsNull()) {
-				// two-sided predicate
-				index_state = index.InitializeScanTwoPredicates(transaction, low_value, low_comparison_type, high_value,
-				                                                high_comparison_type);
-			} else if (!low_value.IsNull()) {
-				// less than predicate
-				index_state = index.InitializeScanSinglePredicate(transaction, low_value, low_comparison_type);
-			} else {
-				D_ASSERT(!high_value.IsNull());
-				index_state = index.InitializeScanSinglePredicate(transaction, high_value, high_comparison_type);
-			}
-			if (index.Scan(transaction, storage, *index_state, STANDARD_VECTOR_SIZE, bind_data.result_ids)) {
-				// use an index scan!
-				bind_data.is_index_scan = true;
-				get.function.init_local = nullptr;
-				get.function.init_global = IndexScanInitGlobal;
-				get.function.function = IndexScanFunction;
-				get.function.table_scan_progress = nullptr;
-				get.function.get_batch_index = nullptr;
-				get.function.filter_pushdown = false;
-			} else {
-				bind_data.result_ids.clear();
-			}
-			return true;
-		}
-		return false;
-	});
-}
-
-string TableScanToString(const FunctionData *bind_data_p) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	string result = bind_data.table->name;
-	return result;
-}
-
-TableFunction TableScanFunction::GetFunction() {
-	TableFunction scan_function("seq_scan", {}, TableScanFunc);
-	scan_function.init_local = TableScanInitLocal;
-	scan_function.init_global = TableScanInitGlobal;
-	scan_function.statistics = TableScanStatistics;
-	scan_function.dependency = TableScanDependency;
-	scan_function.cardinality = TableScanCardinality;
-	scan_function.pushdown_complex_filter = TableScanPushdownComplexFilter;
-	scan_function.to_string = TableScanToString;
-	scan_function.table_scan_progress = TableScanProgress;
-	scan_function.get_batch_index = TableScanGetBatchIndex;
-	scan_function.projection_pushdown = true;
-	scan_function.filter_pushdown = true;
-	return scan_function;
-}
-
-TableCatalogEntry *TableScanFunction::GetTableEntry(const TableFunction &function, const FunctionData *bind_data_p) {
-	if (function.function != TableScanFunc || !bind_data_p) {
-		return nullptr;
-	}
-	auto &bind_data = (TableScanBindData &)*bind_data_p;
-	return bind_data.table;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-struct UnnestBindData : public FunctionData {
-	explicit UnnestBindData(LogicalType input_type_p) : input_type(move(input_type_p)) {
-	}
-
-	LogicalType input_type;
-
-public:
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<UnnestBindData>(input_type);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const UnnestBindData &)other_p;
-		return input_type == other.input_type;
-	}
-};
-
-struct UnnestGlobalState : public GlobalTableFunctionState {
-	UnnestGlobalState() {
-	}
-
-	vector<unique_ptr<Expression>> select_list;
-
-	idx_t MaxThreads() const override {
-		return GlobalTableFunctionState::MAX_THREADS;
-	}
-};
-
-struct UnnestLocalState : public LocalTableFunctionState {
-	UnnestLocalState() {
-	}
-
-	unique_ptr<OperatorState> operator_state;
-};
-
-static unique_ptr<FunctionData> UnnestBind(ClientContext &context, TableFunctionBindInput &input,
-                                           vector<LogicalType> &return_types, vector<string> &names) {
-	if (input.input_table_types.size() != 1 || input.input_table_types[0].id() != LogicalTypeId::LIST) {
-		throw BinderException("UNNEST requires a single list as input");
-	}
-	return_types.push_back(ListType::GetChildType(input.input_table_types[0]));
-	names.push_back(input.input_table_names[0]);
-	return make_unique<UnnestBindData>(input.input_table_types[0]);
-}
-
-static unique_ptr<LocalTableFunctionState> UnnestLocalInit(ExecutionContext &context, TableFunctionInitInput &input,
-                                                           GlobalTableFunctionState *global_state) {
-	auto &gstate = (UnnestGlobalState &)*global_state;
-
-	auto result = make_unique<UnnestLocalState>();
-	result->operator_state = PhysicalUnnest::GetState(context, gstate.select_list);
-	return move(result);
-}
-
-static unique_ptr<GlobalTableFunctionState> UnnestInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (UnnestBindData &)*input.bind_data;
-	auto result = make_unique<UnnestGlobalState>();
-	auto ref = make_unique<BoundReferenceExpression>(bind_data.input_type, 0);
-	auto bound_unnest = make_unique<BoundUnnestExpression>(ListType::GetChildType(bind_data.input_type));
-	bound_unnest->child = move(ref);
-	result->select_list.push_back(move(bound_unnest));
-	return move(result);
-}
-
-static OperatorResultType UnnestFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
-                                         DataChunk &output) {
-	auto &state = (UnnestGlobalState &)*data_p.global_state;
-	auto &lstate = (UnnestLocalState &)*data_p.local_state;
-	return PhysicalUnnest::ExecuteInternal(context, input, output, *lstate.operator_state, state.select_list, false);
-}
-
-void UnnestTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction unnest_function("unnest", {LogicalTypeId::TABLE}, nullptr, UnnestBind, UnnestInit, UnnestLocalInit);
-	unnest_function.in_out_function = UnnestFunction;
-	set.AddFunction(unnest_function);
-}
-
-} // namespace duckdb
-
-
-
-#include <cstdint>
-
-namespace duckdb {
-
-struct PragmaVersionData : public GlobalTableFunctionState {
-	PragmaVersionData() : finished(false) {
-	}
-
-	bool finished;
-};
-
-static unique_ptr<FunctionData> PragmaVersionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("library_version");
-	return_types.emplace_back(LogicalType::VARCHAR);
-	names.emplace_back("source_id");
-	return_types.emplace_back(LogicalType::VARCHAR);
-	return nullptr;
-}
-
-static unique_ptr<GlobalTableFunctionState> PragmaVersionInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaVersionData>();
-}
-
-static void PragmaVersionFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaVersionData &)*data_p.global_state;
-	if (data.finished) {
-		// finished returning values
-		return;
-	}
-	output.SetCardinality(1);
-	output.SetValue(0, 0, DuckDB::LibraryVersion());
-	output.SetValue(1, 0, DuckDB::SourceID());
-	data.finished = true;
-}
-
-void PragmaVersion::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction pragma_version("pragma_version", {}, PragmaVersionFunction);
-	pragma_version.bind = PragmaVersionBind;
-	pragma_version.init_global = PragmaVersionInit;
-	set.AddFunction(pragma_version);
-}
-
-const char *DuckDB::SourceID() {
-	return DUCKDB_SOURCE_ID;
-}
-
-const char *DuckDB::LibraryVersion() {
-	return DUCKDB_VERSION;
-}
-
-string DuckDB::Platform() {
-	string os = "linux";
-#if INTPTR_MAX == INT64_MAX
-	string arch = "amd64";
-#elif INTPTR_MAX == INT32_MAX
-	string arch = "i686";
-#else
-#error Unknown pointer size or missing size macros!
-#endif
-	string postfix = "";
-
-#ifdef _WIN32
-	os = "windows";
-#elif defined(__APPLE__)
-	os = "osx";
-#endif
-#if defined(__aarch64__) || defined(__ARM_ARCH_ISA_A64)
-	arch = "arm64";
-#endif
-
-#if !defined(_GLIBCXX_USE_CXX11_ABI) || _GLIBCXX_USE_CXX11_ABI == 0
-	if (os == "linux") {
-		postfix = "_gcc4";
-	}
-#endif
-
-	return os + "_" + arch + postfix;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-GlobalTableFunctionState::~GlobalTableFunctionState() {
-}
-
-LocalTableFunctionState::~LocalTableFunctionState() {
-}
-
-TableFunctionInfo::~TableFunctionInfo() {
-}
-
-TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
-                             table_function_bind_t bind, table_function_init_global_t init_global,
-                             table_function_init_local_t init_local)
-    : SimpleNamedParameterFunction(move(name), move(arguments)), bind(bind), init_global(init_global),
-      init_local(init_local), function(function), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
-      cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
-      get_batch_index(nullptr), projection_pushdown(false), filter_pushdown(false) {
-}
-
-TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
-                             table_function_bind_t bind, table_function_init_global_t init_global,
-                             table_function_init_local_t init_local)
-    : TableFunction(string(), arguments, function, bind, init_global, init_local) {
-}
-TableFunction::TableFunction()
-    : SimpleNamedParameterFunction("", {}), bind(nullptr), init_global(nullptr), init_local(nullptr), function(nullptr),
-      in_out_function(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
-      pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
-      projection_pushdown(false), filter_pushdown(false) {
-}
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table_macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-//! The SelectStatement of the view
-
-
-
-
-
-namespace duckdb {
-
-TableMacroFunction::TableMacroFunction(unique_ptr<QueryNode> query_node)
-    : MacroFunction(MacroType::TABLE_MACRO), query_node(move(query_node)) {
-}
-
-TableMacroFunction::TableMacroFunction(void) : MacroFunction(MacroType::TABLE_MACRO) {
-}
-
-unique_ptr<MacroFunction> TableMacroFunction::Copy() {
-	auto result = make_unique<TableMacroFunction>();
-	result->query_node = query_node->Copy();
-	this->CopyProperties(*result);
-	return move(result);
-}
-
-string TableMacroFunction::ToSQL(const string &schema, const string &name) {
-	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("TABLE (%s);", query_node->ToString());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-void UDFWrapper::RegisterFunction(string name, vector<LogicalType> args, LogicalType ret_type,
-                                  scalar_function_t udf_function, ClientContext &context, LogicalType varargs) {
-
-	ScalarFunction scalar_function(move(name), move(args), move(ret_type), move(udf_function));
-	scalar_function.varargs = move(varargs);
-	CreateScalarFunctionInfo info(scalar_function);
-	info.schema = DEFAULT_SCHEMA;
-	context.RegisterFunction(&info);
-}
-
-void UDFWrapper::RegisterAggrFunction(AggregateFunction aggr_function, ClientContext &context, LogicalType varargs) {
-	aggr_function.varargs = move(varargs);
-	CreateAggregateFunctionInfo info(move(aggr_function));
-	context.RegisterFunction(&info);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-BaseAppender::BaseAppender(Allocator &allocator) : allocator(allocator), collection(allocator), column(0) {
-}
-
-BaseAppender::BaseAppender(Allocator &allocator, vector<LogicalType> types_p)
-    : allocator(allocator), types(move(types_p)), collection(allocator), column(0) {
-	InitializeChunk();
-}
-
-BaseAppender::~BaseAppender() {
-}
-
-void BaseAppender::Destructor() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	// flush any remaining chunks, but only if we are not cleaning up the appender as part of an exception stack unwind
-	// wrapped in a try/catch because Close() can throw if the table was dropped in the meantime
-	try {
-		Close();
-	} catch (...) {
-	}
-}
-
-InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p)
-    : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes()), context(context_p), table(table_p) {
-}
-
-InternalAppender::~InternalAppender() {
-	Destructor();
-}
-
-Appender::Appender(Connection &con, const string &schema_name, const string &table_name)
-    : BaseAppender(Allocator::DefaultAllocator()), context(con.context) {
-	description = con.TableInfo(schema_name, table_name);
-	if (!description) {
-		// table could not be found
-		throw CatalogException(StringUtil::Format("Table \"%s.%s\" could not be found", schema_name, table_name));
-	}
-	for (auto &column : description->columns) {
-		types.push_back(column.Type());
-	}
-	InitializeChunk();
-}
-
-Appender::Appender(Connection &con, const string &table_name) : Appender(con, DEFAULT_SCHEMA, table_name) {
-}
-
-Appender::~Appender() {
-	Destructor();
-}
-
-void BaseAppender::InitializeChunk() {
-	chunk = make_unique<DataChunk>();
-	chunk->Initialize(allocator, types);
-}
-
-void BaseAppender::BeginRow() {
-}
-
-void BaseAppender::EndRow() {
-	// check that all rows have been appended to
-	if (column != chunk->ColumnCount()) {
-		throw InvalidInputException("Call to EndRow before all rows have been appended to!");
-	}
-	column = 0;
-	chunk->SetCardinality(chunk->size() + 1);
-	if (chunk->size() >= STANDARD_VECTOR_SIZE) {
-		FlushChunk();
-	}
-}
-
-template <class SRC, class DST>
-void BaseAppender::AppendValueInternal(Vector &col, SRC input) {
-	FlatVector::GetData<DST>(col)[chunk->size()] = Cast::Operation<SRC, DST>(input);
-}
-
-template <class T>
-void BaseAppender::AppendValueInternal(T input) {
-	if (column >= types.size()) {
-		throw InvalidInputException("Too many appends for chunk!");
-	}
-	auto &col = chunk->data[column];
-	switch (col.GetType().id()) {
-	case LogicalTypeId::BOOLEAN:
-		AppendValueInternal<T, bool>(col, input);
-		break;
-	case LogicalTypeId::UTINYINT:
-		AppendValueInternal<T, uint8_t>(col, input);
-		break;
-	case LogicalTypeId::TINYINT:
-		AppendValueInternal<T, int8_t>(col, input);
-		break;
-	case LogicalTypeId::USMALLINT:
-		AppendValueInternal<T, uint16_t>(col, input);
-		break;
-	case LogicalTypeId::SMALLINT:
-		AppendValueInternal<T, int16_t>(col, input);
-		break;
-	case LogicalTypeId::UINTEGER:
-		AppendValueInternal<T, uint32_t>(col, input);
-		break;
-	case LogicalTypeId::INTEGER:
-		AppendValueInternal<T, int32_t>(col, input);
-		break;
-	case LogicalTypeId::UBIGINT:
-		AppendValueInternal<T, uint64_t>(col, input);
-		break;
-	case LogicalTypeId::BIGINT:
-		AppendValueInternal<T, int64_t>(col, input);
-		break;
-	case LogicalTypeId::HUGEINT:
-		AppendValueInternal<T, hugeint_t>(col, input);
-		break;
-	case LogicalTypeId::FLOAT:
-		AppendValueInternal<T, float>(col, input);
-		break;
-	case LogicalTypeId::DOUBLE:
-		AppendValueInternal<T, double>(col, input);
-		break;
-	case LogicalTypeId::DECIMAL:
-		switch (col.GetType().InternalType()) {
-		case PhysicalType::INT8:
-			AppendValueInternal<T, int8_t>(col, input);
-			break;
-		case PhysicalType::INT16:
-			AppendValueInternal<T, int16_t>(col, input);
-			break;
-		case PhysicalType::INT32:
-			AppendValueInternal<T, int32_t>(col, input);
-			break;
-		default:
-			AppendValueInternal<T, int64_t>(col, input);
-			break;
-		}
-		break;
-	case LogicalTypeId::DATE:
-		AppendValueInternal<T, date_t>(col, input);
-		break;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		AppendValueInternal<T, timestamp_t>(col, input);
-		break;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		AppendValueInternal<T, dtime_t>(col, input);
-		break;
-	case LogicalTypeId::INTERVAL:
-		AppendValueInternal<T, interval_t>(col, input);
-		break;
-	case LogicalTypeId::VARCHAR:
-		FlatVector::GetData<string_t>(col)[chunk->size()] = StringCast::Operation<T>(input, col);
-		break;
-	default:
-		AppendValue(Value::CreateValue<T>(input));
-		return;
-	}
-	column++;
-}
-
-template <>
-void BaseAppender::Append(bool value) {
-	AppendValueInternal<bool>(value);
-}
-
-template <>
-void BaseAppender::Append(int8_t value) {
-	AppendValueInternal<int8_t>(value);
-}
-
-template <>
-void BaseAppender::Append(int16_t value) {
-	AppendValueInternal<int16_t>(value);
-}
-
-template <>
-void BaseAppender::Append(int32_t value) {
-	AppendValueInternal<int32_t>(value);
-}
-
-template <>
-void BaseAppender::Append(int64_t value) {
-	AppendValueInternal<int64_t>(value);
-}
-
-template <>
-void BaseAppender::Append(hugeint_t value) {
-	AppendValueInternal<hugeint_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uint8_t value) {
-	AppendValueInternal<uint8_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uint16_t value) {
-	AppendValueInternal<uint16_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uint32_t value) {
-	AppendValueInternal<uint32_t>(value);
-}
-
-template <>
-void BaseAppender::Append(uint64_t value) {
-	AppendValueInternal<uint64_t>(value);
-}
-
-template <>
-void BaseAppender::Append(const char *value) {
-	AppendValueInternal<string_t>(string_t(value));
-}
-
-void BaseAppender::Append(const char *value, uint32_t length) {
-	AppendValueInternal<string_t>(string_t(value, length));
-}
-
-template <>
-void BaseAppender::Append(string_t value) {
-	AppendValueInternal<string_t>(value);
-}
-
-template <>
-void BaseAppender::Append(float value) {
-	AppendValueInternal<float>(value);
-}
-
-template <>
-void BaseAppender::Append(double value) {
-	AppendValueInternal<double>(value);
-}
-
-template <>
-void BaseAppender::Append(date_t value) {
-	AppendValueInternal<date_t>(value);
-}
-
-template <>
-void BaseAppender::Append(dtime_t value) {
-	AppendValueInternal<dtime_t>(value);
-}
-
-template <>
-void BaseAppender::Append(timestamp_t value) {
-	AppendValueInternal<timestamp_t>(value);
-}
-
-template <>
-void BaseAppender::Append(interval_t value) {
-	AppendValueInternal<interval_t>(value);
-}
-
-template <>
-void BaseAppender::Append(Value value) { // NOLINT: template shtuff
-	if (column >= chunk->ColumnCount()) {
-		throw InvalidInputException("Too many appends for chunk!");
-	}
-	AppendValue(value);
-}
-
-template <>
-void BaseAppender::Append(std::nullptr_t value) {
-	if (column >= chunk->ColumnCount()) {
-		throw InvalidInputException("Too many appends for chunk!");
-	}
-	auto &col = chunk->data[column++];
-	FlatVector::SetNull(col, chunk->size(), true);
-}
-
-void BaseAppender::AppendValue(const Value &value) {
-	chunk->SetValue(column, chunk->size(), value);
-	column++;
-}
-
-void BaseAppender::AppendDataChunk(DataChunk &chunk) {
-	if (chunk.GetTypes() != types) {
-		throw InvalidInputException("Type mismatch in Append DataChunk and the types required for appender");
-	}
-	collection.Append(chunk);
-	if (collection.ChunkCount() >= FLUSH_COUNT) {
-		Flush();
-	}
-}
-
-void BaseAppender::FlushChunk() {
-	if (chunk->size() == 0) {
-		return;
-	}
-	collection.Append(move(chunk));
-	InitializeChunk();
-	if (collection.ChunkCount() >= FLUSH_COUNT) {
-		Flush();
-	}
-}
-
-void BaseAppender::Flush() {
-	// check that all vectors have the same length before appending
-	if (column != 0) {
-		throw InvalidInputException("Failed to Flush appender: incomplete append to row!");
-	}
-
-	FlushChunk();
-	if (collection.Count() == 0) {
-		return;
-	}
-	FlushInternal(collection);
-
-	collection.Reset();
-	column = 0;
-}
-
-void Appender::FlushInternal(ChunkCollection &collection) {
-	context->Append(*description, collection);
-}
-
-void InternalAppender::FlushInternal(ChunkCollection &collection) {
-	for (auto &chunk : collection.Chunks()) {
-		table.storage->Append(table, context, *chunk);
-	}
-}
-
-void BaseAppender::Close() {
-	if (column == 0 || column == types.size()) {
-		Flush();
-	}
-}
-
-} // namespace duckdb
-
-
-using duckdb::Appender;
-using duckdb::AppenderWrapper;
-using duckdb::Connection;
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::hugeint_t;
-using duckdb::interval_t;
-using duckdb::string_t;
-using duckdb::timestamp_t;
-
-duckdb_state duckdb_appender_create(duckdb_connection connection, const char *schema, const char *table,
-                                    duckdb_appender *out_appender) {
-	Connection *conn = (Connection *)connection;
-
-	if (!connection || !table || !out_appender) {
-		return DuckDBError;
-	}
-	if (schema == nullptr) {
-		schema = DEFAULT_SCHEMA;
-	}
-	auto wrapper = new AppenderWrapper();
-	*out_appender = (duckdb_appender)wrapper;
-	try {
-		wrapper->appender = duckdb::make_unique<Appender>(*conn, schema, table);
-	} catch (std::exception &ex) {
-		wrapper->error = ex.what();
-		return DuckDBError;
-	} catch (...) { // LCOV_EXCL_START
-		wrapper->error = "Unknown create appender error";
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_appender_destroy(duckdb_appender *appender) {
-	if (!appender || !*appender) {
-		return DuckDBError;
-	}
-	duckdb_appender_close(*appender);
-	auto wrapper = (AppenderWrapper *)*appender;
-	if (wrapper) {
-		delete wrapper;
-	}
-	*appender = nullptr;
-	return DuckDBSuccess;
-}
-
-template <class FUN>
-duckdb_state duckdb_appender_run_function(duckdb_appender appender, FUN &&function) {
-	if (!appender) {
-		return DuckDBError;
-	}
-	auto wrapper = (AppenderWrapper *)appender;
-	if (!wrapper->appender) {
-		return DuckDBError;
-	}
-	try {
-		function(*wrapper->appender);
-	} catch (std::exception &ex) {
-		wrapper->error = ex.what();
-		return DuckDBError;
-	} catch (...) { // LCOV_EXCL_START
-		wrapper->error = "Unknown error";
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	return DuckDBSuccess;
-}
-
-const char *duckdb_appender_error(duckdb_appender appender) {
-	if (!appender) {
-		return nullptr;
-	}
-	auto wrapper = (AppenderWrapper *)appender;
-	if (wrapper->error.empty()) {
-		return nullptr;
-	}
-	return wrapper->error.c_str();
-}
-
-duckdb_state duckdb_appender_begin_row(duckdb_appender appender) {
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_appender_end_row(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.EndRow(); });
-}
-
-template <class T>
-duckdb_state duckdb_append_internal(duckdb_appender appender, T value) {
-	if (!appender) {
-		return DuckDBError;
-	}
-	auto *appender_instance = (AppenderWrapper *)appender;
-	try {
-		appender_instance->appender->Append<T>(value);
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_append_bool(duckdb_appender appender, bool value) {
-	return duckdb_append_internal<bool>(appender, value);
-}
-
-duckdb_state duckdb_append_int8(duckdb_appender appender, int8_t value) {
-	return duckdb_append_internal<int8_t>(appender, value);
-}
-
-duckdb_state duckdb_append_int16(duckdb_appender appender, int16_t value) {
-	return duckdb_append_internal<int16_t>(appender, value);
-}
-
-duckdb_state duckdb_append_int32(duckdb_appender appender, int32_t value) {
-	return duckdb_append_internal<int32_t>(appender, value);
-}
-
-duckdb_state duckdb_append_int64(duckdb_appender appender, int64_t value) {
-	return duckdb_append_internal<int64_t>(appender, value);
-}
-
-duckdb_state duckdb_append_hugeint(duckdb_appender appender, duckdb_hugeint value) {
-	hugeint_t internal;
-	internal.lower = value.lower;
-	internal.upper = value.upper;
-	return duckdb_append_internal<hugeint_t>(appender, internal);
-}
-
-duckdb_state duckdb_append_uint8(duckdb_appender appender, uint8_t value) {
-	return duckdb_append_internal<uint8_t>(appender, value);
-}
-
-duckdb_state duckdb_append_uint16(duckdb_appender appender, uint16_t value) {
-	return duckdb_append_internal<uint16_t>(appender, value);
-}
-
-duckdb_state duckdb_append_uint32(duckdb_appender appender, uint32_t value) {
-	return duckdb_append_internal<uint32_t>(appender, value);
-}
-
-duckdb_state duckdb_append_uint64(duckdb_appender appender, uint64_t value) {
-	return duckdb_append_internal<uint64_t>(appender, value);
-}
-
-duckdb_state duckdb_append_float(duckdb_appender appender, float value) {
-	return duckdb_append_internal<float>(appender, value);
-}
-
-duckdb_state duckdb_append_double(duckdb_appender appender, double value) {
-	return duckdb_append_internal<double>(appender, value);
-}
-
-duckdb_state duckdb_append_date(duckdb_appender appender, duckdb_date value) {
-	return duckdb_append_internal<date_t>(appender, date_t(value.days));
-}
-
-duckdb_state duckdb_append_time(duckdb_appender appender, duckdb_time value) {
-	return duckdb_append_internal<dtime_t>(appender, dtime_t(value.micros));
-}
-
-duckdb_state duckdb_append_timestamp(duckdb_appender appender, duckdb_timestamp value) {
-	return duckdb_append_internal<timestamp_t>(appender, timestamp_t(value.micros));
-}
-
-duckdb_state duckdb_append_interval(duckdb_appender appender, duckdb_interval value) {
-	interval_t interval;
-	interval.months = value.months;
-	interval.days = value.days;
-	interval.micros = value.micros;
-	return duckdb_append_internal<interval_t>(appender, interval);
-}
-
-duckdb_state duckdb_append_null(duckdb_appender appender) {
-	return duckdb_append_internal<std::nullptr_t>(appender, nullptr);
-}
-
-duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val) {
-	return duckdb_append_internal<const char *>(appender, val);
-}
-
-duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *val, idx_t length) {
-	return duckdb_append_internal<string_t>(appender, string_t(val, length));
-}
-duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length) {
-	auto value = duckdb::Value::BLOB((duckdb::const_data_ptr_t)data, length);
-	return duckdb_append_internal<duckdb::Value>(appender, value);
-}
-
-duckdb_state duckdb_appender_flush(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.Flush(); });
-}
-
-duckdb_state duckdb_appender_close(duckdb_appender appender) {
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.Close(); });
-}
-
-duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk) {
-	if (!chunk) {
-		return DuckDBError;
-	}
-	auto data_chunk = (duckdb::DataChunk *)chunk;
-	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.AppendDataChunk(*data_chunk); });
-}
-
-
-using duckdb::ArrowResultWrapper;
-using duckdb::Connection;
-using duckdb::DataChunk;
-using duckdb::LogicalType;
-using duckdb::MaterializedQueryResult;
-using duckdb::PreparedStatementWrapper;
-using duckdb::QueryResult;
-using duckdb::QueryResultType;
-
-duckdb_state duckdb_query_arrow(duckdb_connection connection, const char *query, duckdb_arrow *out_result) {
-	Connection *conn = (Connection *)connection;
-	auto wrapper = new ArrowResultWrapper();
-	wrapper->result = conn->Query(query);
-	*out_result = (duckdb_arrow)wrapper;
-	return wrapper->result->success ? DuckDBSuccess : DuckDBError;
-}
-
-duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema *out_schema) {
-	if (!out_schema) {
-		return DuckDBSuccess;
-	}
-	auto wrapper = (ArrowResultWrapper *)result;
-	QueryResult::ToArrowSchema((ArrowSchema *)*out_schema, wrapper->result->types, wrapper->result->names,
-	                           wrapper->timezone_config);
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *out_array) {
-	if (!out_array) {
-		return DuckDBSuccess;
-	}
-	auto wrapper = (ArrowResultWrapper *)result;
-	auto success = wrapper->result->TryFetch(wrapper->current_chunk, wrapper->result->error);
-	if (!success) { // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	if (!wrapper->current_chunk || wrapper->current_chunk->size() == 0) {
-		return DuckDBSuccess;
-	}
-	wrapper->current_chunk->ToArrowArray((ArrowArray *)*out_array);
-	return DuckDBSuccess;
-}
-
-idx_t duckdb_arrow_row_count(duckdb_arrow result) {
-	auto wrapper = (ArrowResultWrapper *)result;
-	return wrapper->result->collection.Count();
-}
-
-idx_t duckdb_arrow_column_count(duckdb_arrow result) {
-	auto wrapper = (ArrowResultWrapper *)result;
-	return wrapper->result->types.size();
-}
-
-idx_t duckdb_arrow_rows_changed(duckdb_arrow result) {
-	auto wrapper = (ArrowResultWrapper *)result;
-	idx_t rows_changed = 0;
-	idx_t row_count = wrapper->result->collection.Count();
-	if (row_count > 0 && wrapper->result->properties.return_type == duckdb::StatementReturnType::CHANGED_ROWS) {
-		auto row_changes = wrapper->result->GetValue(0, 0);
-		if (!row_changes.IsNull() && row_changes.TryCastAs(LogicalType::BIGINT)) {
-			rows_changed = row_changes.GetValue<int64_t>();
-		}
-	}
-	return rows_changed;
-}
-
-const char *duckdb_query_arrow_error(duckdb_arrow result) {
-	auto wrapper = (ArrowResultWrapper *)result;
-	return wrapper->result->error.c_str();
-}
-
-void duckdb_destroy_arrow(duckdb_arrow *result) {
-	if (*result) {
-		auto wrapper = (ArrowResultWrapper *)*result;
-		delete wrapper;
-		*result = nullptr;
-	}
-}
-
-duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement, duckdb_arrow *out_result) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
-	if (!wrapper || !wrapper->statement || !wrapper->statement->success || !out_result) {
-		return DuckDBError;
-	}
-	auto arrow_wrapper = new ArrowResultWrapper();
-	if (wrapper->statement->context->config.set_variables.find("TimeZone") ==
-	    wrapper->statement->context->config.set_variables.end()) {
-		arrow_wrapper->timezone_config = "UTC";
-	} else {
-		arrow_wrapper->timezone_config =
-		    wrapper->statement->context->config.set_variables["TimeZone"].GetValue<std::string>();
-	}
-
-	auto result = wrapper->statement->Execute(wrapper->values, false);
-	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	arrow_wrapper->result = duckdb::unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
-	*out_result = (duckdb_arrow)arrow_wrapper;
-	return arrow_wrapper->result->success ? DuckDBSuccess : DuckDBError;
-}
-
-
-
-
-using duckdb::DBConfig;
-using duckdb::Value;
-
-// config
-duckdb_state duckdb_create_config(duckdb_config *out_config) {
-	if (!out_config) {
-		return DuckDBError;
-	}
-	DBConfig *config;
-	try {
-		config = new DBConfig();
-	} catch (...) { // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	*out_config = (duckdb_config)config;
-	return DuckDBSuccess;
-}
-
-size_t duckdb_config_count() {
-	return DBConfig::GetOptionCount();
-}
-
-duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description) {
-	auto option = DBConfig::GetOptionByIndex(index);
-	if (!option) {
-		return DuckDBError;
-	}
-	if (out_name) {
-		*out_name = option->name;
-	}
-	if (out_description) {
-		*out_description = option->description;
-	}
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_set_config(duckdb_config config, const char *name, const char *option) {
-	if (!config || !name || !option) {
-		return DuckDBError;
-	}
-	auto config_option = DBConfig::GetOptionByName(name);
-	if (!config_option) {
-		return DuckDBError;
-	}
-	try {
-		auto db_config = (DBConfig *)config;
-		db_config->SetOption(*config_option, Value(option));
-	} catch (...) {
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
-}
-
-void duckdb_destroy_config(duckdb_config *config) {
-	if (!config) {
-		return;
-	}
-	if (*config) {
-		auto db_config = (DBConfig *)*config;
-		delete db_config;
-		*config = nullptr;
-	}
-}
-
-
-
-#include <string.h>
-
-duckdb_data_chunk duckdb_create_data_chunk(duckdb_logical_type *ctypes, idx_t column_count) {
-	if (!ctypes) {
-		return nullptr;
-	}
-	duckdb::vector<duckdb::LogicalType> types;
-	for (idx_t i = 0; i < column_count; i++) {
-		auto ltype = (duckdb::LogicalType *)ctypes[i];
-		types.push_back(*ltype);
-	}
-
-	auto result = new duckdb::DataChunk();
-	result->Initialize(duckdb::Allocator::DefaultAllocator(), types);
-	return result;
-}
-
-void duckdb_destroy_data_chunk(duckdb_data_chunk *chunk) {
-	if (chunk && *chunk) {
-		auto dchunk = (duckdb::DataChunk *)*chunk;
-		delete dchunk;
-		*chunk = nullptr;
-	}
-}
-
-void duckdb_data_chunk_reset(duckdb_data_chunk chunk) {
-	if (!chunk) {
-		return;
-	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
-	dchunk->Reset();
-}
-
-idx_t duckdb_data_chunk_get_column_count(duckdb_data_chunk chunk) {
-	if (!chunk) {
-		return 0;
-	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
-	return dchunk->ColumnCount();
-}
-
-duckdb_vector duckdb_data_chunk_get_vector(duckdb_data_chunk chunk, idx_t col_idx) {
-	if (!chunk || col_idx >= duckdb_data_chunk_get_column_count(chunk)) {
-		return nullptr;
-	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
-	return &dchunk->data[col_idx];
-}
-
-idx_t duckdb_data_chunk_get_size(duckdb_data_chunk chunk) {
-	if (!chunk) {
-		return 0;
-	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
-	return dchunk->size();
-}
-
-void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size) {
-	if (!chunk) {
-		return;
-	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
-	dchunk->SetCardinality(size);
-}
-
-duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = (duckdb::Vector *)vector;
-	return new duckdb::LogicalType(v->GetType());
-}
-
-void *duckdb_vector_get_data(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = (duckdb::Vector *)vector;
-	return duckdb::FlatVector::GetData(*v);
-}
-
-uint64_t *duckdb_vector_get_validity(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = (duckdb::Vector *)vector;
-	return duckdb::FlatVector::Validity(*v).GetData();
-}
-
-void duckdb_vector_ensure_validity_writable(duckdb_vector vector) {
-	if (!vector) {
-		return;
-	}
-	auto v = (duckdb::Vector *)vector;
-	auto &validity = duckdb::FlatVector::Validity(*v);
-	validity.EnsureWritable();
-}
-
-void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str) {
-	duckdb_vector_assign_string_element_len(vector, index, str, strlen(str));
-}
-
-void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index, const char *str, idx_t str_len) {
-	if (!vector) {
-		return;
-	}
-	auto v = (duckdb::Vector *)vector;
-	auto data = duckdb::FlatVector::GetData<duckdb::string_t>(*v);
-	data[index] = duckdb::StringVector::AddString(*v, str, str_len);
-}
-
-duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = (duckdb::Vector *)vector;
-	return &duckdb::ListVector::GetEntry(*v);
-}
-
-idx_t duckdb_list_vector_get_size(duckdb_vector vector) {
-	if (!vector) {
-		return 0;
-	}
-	auto v = (duckdb::Vector *)vector;
-	return duckdb::ListVector::GetListSize(*v);
-}
-
-duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index) {
-	if (!vector) {
-		return nullptr;
-	}
-	auto v = (duckdb::Vector *)vector;
-	return duckdb::StructVector::GetEntries(*v)[index].get();
-}
-
-bool duckdb_validity_row_is_valid(uint64_t *validity, idx_t row) {
-	if (!validity) {
-		return true;
-	}
-	idx_t entry_idx = row / 64;
-	idx_t idx_in_entry = row % 64;
-	return validity[entry_idx] & (1 << idx_in_entry);
-}
-
-void duckdb_validity_set_row_validity(uint64_t *validity, idx_t row, bool valid) {
-	if (valid) {
-		duckdb_validity_set_row_valid(validity, row);
-	} else {
-		duckdb_validity_set_row_invalid(validity, row);
-	}
-}
-
-void duckdb_validity_set_row_invalid(uint64_t *validity, idx_t row) {
-	if (!validity) {
-		return;
-	}
-	idx_t entry_idx = row / 64;
-	idx_t idx_in_entry = row % 64;
-	validity[entry_idx] &= ~(1 << idx_in_entry);
-}
-
-void duckdb_validity_set_row_valid(uint64_t *validity, idx_t row) {
-	if (!validity) {
-		return;
-	}
-	idx_t entry_idx = row / 64;
-	idx_t idx_in_entry = row % 64;
-	validity[entry_idx] |= 1 << idx_in_entry;
-}
-
-
-
-
-
-using duckdb::Date;
-using duckdb::Time;
-using duckdb::Timestamp;
-
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::timestamp_t;
-
-duckdb_date_struct duckdb_from_date(duckdb_date date) {
-	int32_t year, month, day;
-	Date::Convert(date_t(date.days), year, month, day);
-
-	duckdb_date_struct result;
-	result.year = year;
-	result.month = month;
-	result.day = day;
-	return result;
-}
-
-duckdb_date duckdb_to_date(duckdb_date_struct date) {
-	duckdb_date result;
-	result.days = Date::FromDate(date.year, date.month, date.day).days;
-	return result;
-}
-
-duckdb_time_struct duckdb_from_time(duckdb_time time) {
-	int32_t hour, minute, second, micros;
-	Time::Convert(dtime_t(time.micros), hour, minute, second, micros);
-
-	duckdb_time_struct result;
-	result.hour = hour;
-	result.min = minute;
-	result.sec = second;
-	result.micros = micros;
-	return result;
-}
-
-duckdb_time duckdb_to_time(duckdb_time_struct time) {
-	duckdb_time result;
-	result.micros = Time::FromTime(time.hour, time.min, time.sec, time.micros).micros;
-	return result;
-}
-
-duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts) {
-	date_t date;
-	dtime_t time;
-	Timestamp::Convert(timestamp_t(ts.micros), date, time);
-
-	duckdb_date ddate;
-	ddate.days = date.days;
-
-	duckdb_time dtime;
-	dtime.micros = time.micros;
-
-	duckdb_timestamp_struct result;
-	result.date = duckdb_from_date(ddate);
-	result.time = duckdb_from_time(dtime);
-	return result;
-}
-
-duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts) {
-	date_t date = date_t(duckdb_to_date(ts.date).days);
-	dtime_t time = dtime_t(duckdb_to_time(ts.time).micros);
-
-	duckdb_timestamp result;
-	result.micros = Timestamp::FromDatetime(date, time).value;
-	return result;
-}
-
-
-using duckdb::Connection;
-using duckdb::DatabaseData;
-using duckdb::DBConfig;
-using duckdb::DuckDB;
-
-duckdb_state duckdb_open_ext(const char *path, duckdb_database *out, duckdb_config config, char **error) {
-	auto wrapper = new DatabaseData();
-	try {
-		auto db_config = (DBConfig *)config;
-		wrapper->database = duckdb::make_unique<DuckDB>(path, db_config);
-	} catch (std::exception &ex) {
-		if (error) {
-			*error = strdup(ex.what());
-		}
-		delete wrapper;
-		return DuckDBError;
-	} catch (...) { // LCOV_EXCL_START
-		if (error) {
-			*error = strdup("Unknown error");
-		}
-		delete wrapper;
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	*out = (duckdb_database)wrapper;
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_open(const char *path, duckdb_database *out) {
-	return duckdb_open_ext(path, out, nullptr, nullptr);
-}
-
-void duckdb_close(duckdb_database *database) {
-	if (database && *database) {
-		auto wrapper = (DatabaseData *)*database;
-		delete wrapper;
-		*database = nullptr;
-	}
-}
-
-duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out) {
-	if (!database || !out) {
-		return DuckDBError;
-	}
-	auto wrapper = (DatabaseData *)database;
-	Connection *connection;
-	try {
-		connection = new Connection(*wrapper->database);
-	} catch (...) { // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	*out = (duckdb_connection)connection;
-	return DuckDBSuccess;
-}
-
-void duckdb_disconnect(duckdb_connection *connection) {
-	if (connection && *connection) {
-		Connection *conn = (Connection *)*connection;
-		delete conn;
-		*connection = nullptr;
-	}
-}
-
-duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out) {
-	Connection *conn = (Connection *)connection;
-	auto result = conn->Query(query);
-	return duckdb_translate_result(move(result), out);
-}
-
-
-void duckdb_destroy_value(duckdb_value *value) {
-	if (value && *value) {
-		auto val = (duckdb::Value *)*value;
-		delete val;
-		*value = nullptr;
-	}
-}
-
-duckdb_value duckdb_create_varchar_length(const char *text, idx_t length) {
-	return (duckdb_value) new duckdb::Value(std::string(text, length));
-}
-
-duckdb_value duckdb_create_varchar(const char *text) {
-	return duckdb_create_varchar_length(text, strlen(text));
-}
-
-duckdb_value duckdb_create_int64(int64_t input) {
-	auto val = duckdb::Value::BIGINT(input);
-	return (duckdb_value) new duckdb::Value(val);
-}
-
-char *duckdb_get_varchar(duckdb_value value) {
-	auto val = (duckdb::Value *)value;
-	auto str_val = val->CastAs(duckdb::LogicalType::VARCHAR);
-	auto &str = duckdb::StringValue::Get(str_val);
-
-	auto result = (char *)malloc(sizeof(char *) * (str.size() + 1));
-	memcpy(result, str.c_str(), str.size());
-	result[str.size()] = '\0';
-	return result;
-}
-
-int64_t duckdb_get_int64(duckdb_value value) {
-	auto val = (duckdb::Value *)value;
-	if (!val->TryCastAs(duckdb::LogicalType::BIGINT)) {
-		return 0;
-	}
-	return duckdb::BigIntValue::Get(*val);
-}
-
-
-namespace duckdb {
-
-LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type) {
-	switch (c_type) {
-	case DUCKDB_TYPE_BOOLEAN:
-		return LogicalTypeId::BOOLEAN;
-	case DUCKDB_TYPE_TINYINT:
-		return LogicalTypeId::TINYINT;
-	case DUCKDB_TYPE_SMALLINT:
-		return LogicalTypeId::SMALLINT;
-	case DUCKDB_TYPE_INTEGER:
-		return LogicalTypeId::INTEGER;
-	case DUCKDB_TYPE_BIGINT:
-		return LogicalTypeId::BIGINT;
-	case DUCKDB_TYPE_UTINYINT:
-		return LogicalTypeId::UTINYINT;
-	case DUCKDB_TYPE_USMALLINT:
-		return LogicalTypeId::USMALLINT;
-	case DUCKDB_TYPE_UINTEGER:
-		return LogicalTypeId::UINTEGER;
-	case DUCKDB_TYPE_UBIGINT:
-		return LogicalTypeId::UBIGINT;
-	case DUCKDB_TYPE_HUGEINT:
-		return LogicalTypeId::HUGEINT;
-	case DUCKDB_TYPE_FLOAT:
-		return LogicalTypeId::FLOAT;
-	case DUCKDB_TYPE_DOUBLE:
-		return LogicalTypeId::DOUBLE;
-	case DUCKDB_TYPE_TIMESTAMP:
-		return LogicalTypeId::TIMESTAMP;
-	case DUCKDB_TYPE_DATE:
-		return LogicalTypeId::DATE;
-	case DUCKDB_TYPE_TIME:
-		return LogicalTypeId::TIME;
-	case DUCKDB_TYPE_VARCHAR:
-		return LogicalTypeId::VARCHAR;
-	case DUCKDB_TYPE_JSON:
-		return LogicalTypeId::JSON;
-	case DUCKDB_TYPE_BLOB:
-		return LogicalTypeId::BLOB;
-	case DUCKDB_TYPE_INTERVAL:
-		return LogicalTypeId::INTERVAL;
-	case DUCKDB_TYPE_TIMESTAMP_S:
-		return LogicalTypeId::TIMESTAMP_SEC;
-	case DUCKDB_TYPE_TIMESTAMP_MS:
-		return LogicalTypeId::TIMESTAMP_MS;
-	case DUCKDB_TYPE_TIMESTAMP_NS:
-		return LogicalTypeId::TIMESTAMP_NS;
-	case DUCKDB_TYPE_UUID:
-		return LogicalTypeId::UUID;
-	default: // LCOV_EXCL_START
-		D_ASSERT(0);
-		return LogicalTypeId::INVALID;
-	} // LCOV_EXCL_STOP
-}
-
-duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
-	switch (sql_type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return DUCKDB_TYPE_BOOLEAN;
-	case LogicalTypeId::TINYINT:
-		return DUCKDB_TYPE_TINYINT;
-	case LogicalTypeId::SMALLINT:
-		return DUCKDB_TYPE_SMALLINT;
-	case LogicalTypeId::INTEGER:
-		return DUCKDB_TYPE_INTEGER;
-	case LogicalTypeId::BIGINT:
-		return DUCKDB_TYPE_BIGINT;
-	case LogicalTypeId::UTINYINT:
-		return DUCKDB_TYPE_UTINYINT;
-	case LogicalTypeId::USMALLINT:
-		return DUCKDB_TYPE_USMALLINT;
-	case LogicalTypeId::UINTEGER:
-		return DUCKDB_TYPE_UINTEGER;
-	case LogicalTypeId::UBIGINT:
-		return DUCKDB_TYPE_UBIGINT;
-	case LogicalTypeId::HUGEINT:
-		return DUCKDB_TYPE_HUGEINT;
-	case LogicalTypeId::FLOAT:
-		return DUCKDB_TYPE_FLOAT;
-	case LogicalTypeId::DOUBLE:
-		return DUCKDB_TYPE_DOUBLE;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return DUCKDB_TYPE_TIMESTAMP;
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return DUCKDB_TYPE_TIMESTAMP_S;
-	case LogicalTypeId::TIMESTAMP_MS:
-		return DUCKDB_TYPE_TIMESTAMP_MS;
-	case LogicalTypeId::TIMESTAMP_NS:
-		return DUCKDB_TYPE_TIMESTAMP_NS;
-	case LogicalTypeId::DATE:
-		return DUCKDB_TYPE_DATE;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		return DUCKDB_TYPE_TIME;
-	case LogicalTypeId::VARCHAR:
-		return DUCKDB_TYPE_VARCHAR;
-	case LogicalTypeId::JSON:
-		return DUCKDB_TYPE_JSON;
-	case LogicalTypeId::BLOB:
-		return DUCKDB_TYPE_BLOB;
-	case LogicalTypeId::INTERVAL:
-		return DUCKDB_TYPE_INTERVAL;
-	case LogicalTypeId::DECIMAL:
-		return DUCKDB_TYPE_DECIMAL;
-	case LogicalTypeId::ENUM:
-		return DUCKDB_TYPE_ENUM;
-	case LogicalTypeId::LIST:
-		return DUCKDB_TYPE_LIST;
-	case LogicalTypeId::STRUCT:
-		return DUCKDB_TYPE_STRUCT;
-	case LogicalTypeId::MAP:
-		return DUCKDB_TYPE_MAP;
-	case LogicalTypeId::UUID:
-		return DUCKDB_TYPE_UUID;
-	default: // LCOV_EXCL_START
-		D_ASSERT(0);
-		return DUCKDB_TYPE_INVALID;
-	} // LCOV_EXCL_STOP
-}
-
-idx_t GetCTypeSize(duckdb_type type) {
-	switch (type) {
-	case DUCKDB_TYPE_BOOLEAN:
-		return sizeof(bool);
-	case DUCKDB_TYPE_TINYINT:
-		return sizeof(int8_t);
-	case DUCKDB_TYPE_SMALLINT:
-		return sizeof(int16_t);
-	case DUCKDB_TYPE_INTEGER:
-		return sizeof(int32_t);
-	case DUCKDB_TYPE_BIGINT:
-		return sizeof(int64_t);
-	case DUCKDB_TYPE_UTINYINT:
-		return sizeof(uint8_t);
-	case DUCKDB_TYPE_USMALLINT:
-		return sizeof(uint16_t);
-	case DUCKDB_TYPE_UINTEGER:
-		return sizeof(uint32_t);
-	case DUCKDB_TYPE_UBIGINT:
-		return sizeof(uint64_t);
-	case DUCKDB_TYPE_HUGEINT:
-	case DUCKDB_TYPE_UUID:
-		return sizeof(duckdb_hugeint);
-	case DUCKDB_TYPE_FLOAT:
-		return sizeof(float);
-	case DUCKDB_TYPE_DOUBLE:
-		return sizeof(double);
-	case DUCKDB_TYPE_DATE:
-		return sizeof(duckdb_date);
-	case DUCKDB_TYPE_TIME:
-		return sizeof(duckdb_time);
-	case DUCKDB_TYPE_TIMESTAMP:
-	case DUCKDB_TYPE_TIMESTAMP_S:
-	case DUCKDB_TYPE_TIMESTAMP_MS:
-	case DUCKDB_TYPE_TIMESTAMP_NS:
-		return sizeof(duckdb_timestamp);
-	case DUCKDB_TYPE_VARCHAR:
-		return sizeof(const char *);
-	case DUCKDB_TYPE_BLOB:
-		return sizeof(duckdb_blob);
-	case DUCKDB_TYPE_INTERVAL:
-		return sizeof(duckdb_interval);
-	case DUCKDB_TYPE_DECIMAL:
-		return sizeof(duckdb_hugeint);
-	default: // LCOV_EXCL_START
-		// unsupported type
-		D_ASSERT(0);
-		return sizeof(const char *);
-	} // LCOV_EXCL_STOP
-}
-
-} // namespace duckdb
-
-void *duckdb_malloc(size_t size) {
-	return malloc(size);
-}
-
-void duckdb_free(void *ptr) {
-	free(ptr);
-}
-
-idx_t duckdb_vector_size() {
-	return STANDARD_VECTOR_SIZE;
-}
-
-
-
-
-
-using duckdb::Hugeint;
-using duckdb::hugeint_t;
-using duckdb::Value;
-
-double duckdb_hugeint_to_double(duckdb_hugeint val) {
-	hugeint_t internal;
-	internal.lower = val.lower;
-	internal.upper = val.upper;
-	return Hugeint::Cast<double>(internal);
-}
-
-duckdb_hugeint duckdb_double_to_hugeint(double val) {
-	hugeint_t internal_result;
-	if (!Value::DoubleIsFinite(val) || !Hugeint::TryConvert<double>(val, internal_result)) {
-		internal_result.lower = 0;
-		internal_result.upper = 0;
-	}
-
-	duckdb_hugeint result;
-	result.lower = internal_result.lower;
-	result.upper = internal_result.upper;
-	return result;
-}
-
-double duckdb_decimal_to_double(duckdb_decimal val) {
-	double result;
-	hugeint_t value;
-	value.lower = val.value.lower;
-	value.upper = val.value.upper;
-	duckdb::TryCastFromDecimal::Operation<hugeint_t, double>(value, result, nullptr, val.width, val.scale);
-	return result;
-}
-
-
-duckdb_logical_type duckdb_create_logical_type(duckdb_type type) {
-	return new duckdb::LogicalType(duckdb::ConvertCTypeToCPP(type));
-}
-
-duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type) {
-	if (!type) {
-		return nullptr;
-	}
-	duckdb::LogicalType *ltype = new duckdb::LogicalType;
-	*ltype = duckdb::LogicalType::LIST(*(duckdb::LogicalType *)type);
-	return ltype;
-}
-
-duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type) {
-	if (!key_type || !value_type) {
-		return nullptr;
-	}
-	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	*mtype = duckdb::LogicalType::MAP(*(duckdb::LogicalType *)key_type, *(duckdb::LogicalType *)value_type);
-	return mtype;
-}
-
-duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale) {
-	return new duckdb::LogicalType(duckdb::LogicalType::DECIMAL(width, scale));
-}
-
-duckdb_type duckdb_get_type_id(duckdb_logical_type type) {
-	if (!type) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto ltype = (duckdb::LogicalType *)type;
-	return duckdb::ConvertCPPTypeToC(*ltype);
-}
-
-void duckdb_destroy_logical_type(duckdb_logical_type *type) {
-	if (type && *type) {
-		auto ltype = (duckdb::LogicalType *)*type;
-		delete ltype;
-		*type = nullptr;
-	}
-}
-
-uint8_t duckdb_decimal_width(duckdb_logical_type type) {
-	if (!type) {
-		return 0;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.id() != duckdb::LogicalTypeId::DECIMAL) {
-		return 0;
-	}
-	return duckdb::DecimalType::GetWidth(ltype);
-}
-
-uint8_t duckdb_decimal_scale(duckdb_logical_type type) {
-	if (!type) {
-		return 0;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.id() != duckdb::LogicalTypeId::DECIMAL) {
-		return 0;
-	}
-	return duckdb::DecimalType::GetScale(ltype);
-}
-
-duckdb_type duckdb_decimal_internal_type(duckdb_logical_type type) {
-	if (!type) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.id() != duckdb::LogicalTypeId::DECIMAL) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	switch (ltype.InternalType()) {
-	case duckdb::PhysicalType::INT16:
-		return DUCKDB_TYPE_SMALLINT;
-	case duckdb::PhysicalType::INT32:
-		return DUCKDB_TYPE_INTEGER;
-	case duckdb::PhysicalType::INT64:
-		return DUCKDB_TYPE_BIGINT;
-	case duckdb::PhysicalType::INT128:
-		return DUCKDB_TYPE_HUGEINT;
-	default:
-		return DUCKDB_TYPE_INVALID;
-	}
-}
-
-duckdb_type duckdb_enum_internal_type(duckdb_logical_type type) {
-	if (!type) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.id() != duckdb::LogicalTypeId::ENUM) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	switch (ltype.InternalType()) {
-	case duckdb::PhysicalType::UINT8:
-		return DUCKDB_TYPE_UTINYINT;
-	case duckdb::PhysicalType::UINT16:
-		return DUCKDB_TYPE_USMALLINT;
-	case duckdb::PhysicalType::UINT32:
-		return DUCKDB_TYPE_UINTEGER;
-	default:
-		return DUCKDB_TYPE_INVALID;
-	}
-}
-
-uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type) {
-	if (!type) {
-		return 0;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.id() != duckdb::LogicalTypeId::ENUM) {
-		return 0;
-	}
-	return duckdb::EnumType::GetSize(ltype);
-}
-
-char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index) {
-	if (!type) {
-		return nullptr;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.id() != duckdb::LogicalTypeId::ENUM) {
-		return nullptr;
-	}
-	auto &vector = duckdb::EnumType::GetValuesInsertOrder(ltype);
-	auto value = vector.GetValue(index);
-	return strdup(duckdb::StringValue::Get(value).c_str());
-}
-
-duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type) {
-	if (!type) {
-		return nullptr;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.id() != duckdb::LogicalTypeId::LIST) {
-		return nullptr;
-	}
-	return new duckdb::LogicalType(duckdb::ListType::GetChildType(ltype));
-}
-
-duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type) {
-	if (!type) {
-		return nullptr;
-	}
-	auto &mtype = *((duckdb::LogicalType *)type);
-	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
-		return nullptr;
-	}
-	return new duckdb::LogicalType(duckdb::MapType::KeyType(mtype));
-}
-
-duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type) {
-	if (!type) {
-		return nullptr;
-	}
-	auto &mtype = *((duckdb::LogicalType *)type);
-	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
-		return nullptr;
-	}
-	return new duckdb::LogicalType(duckdb::MapType::ValueType(mtype));
-}
-
-idx_t duckdb_struct_type_child_count(duckdb_logical_type type) {
-	if (!type) {
-		return 0;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.InternalType() != duckdb::PhysicalType::STRUCT) {
-		return 0;
-	}
-	return duckdb::StructType::GetChildCount(ltype);
-}
-
-char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t index) {
-	if (!type) {
-		return nullptr;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.InternalType() != duckdb::PhysicalType::STRUCT) {
-		return nullptr;
-	}
-	return strdup(duckdb::StructType::GetChildName(ltype, index).c_str());
-}
-
-duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_t index) {
-	if (!type) {
-		return nullptr;
-	}
-	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.InternalType() != duckdb::PhysicalType::STRUCT) {
-		return nullptr;
-	}
-	return new duckdb::LogicalType(duckdb::StructType::GetChildType(ltype, index));
-}
-
-
-
-
-using duckdb::Connection;
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::hugeint_t;
-using duckdb::MaterializedQueryResult;
-using duckdb::PreparedStatementWrapper;
-using duckdb::QueryResultType;
-using duckdb::timestamp_t;
-using duckdb::Value;
-
-duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,
-                            duckdb_prepared_statement *out_prepared_statement) {
-	if (!connection || !query || !out_prepared_statement) {
-		return DuckDBError;
-	}
-	auto wrapper = new PreparedStatementWrapper();
-	Connection *conn = (Connection *)connection;
-	wrapper->statement = conn->Prepare(query);
-	*out_prepared_statement = (duckdb_prepared_statement)wrapper;
-	return wrapper->statement->success ? DuckDBSuccess : DuckDBError;
-}
-
-const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
-	if (!wrapper || !wrapper->statement || wrapper->statement->success) {
-		return nullptr;
-	}
-	return wrapper->statement->error.c_str();
-}
-
-idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
-	if (!wrapper || !wrapper->statement || !wrapper->statement->success) {
-		return 0;
-	}
-	return wrapper->statement->n_param;
-}
-
-duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
-	if (!wrapper || !wrapper->statement || !wrapper->statement->success) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto entry = wrapper->statement->data->value_map.find(param_idx);
-	if (entry == wrapper->statement->data->value_map.end()) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	return ConvertCPPTypeToC(entry->second[0]->type());
-}
-
-static duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, Value val) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
-	if (!wrapper || !wrapper->statement || !wrapper->statement->success) {
-		return DuckDBError;
-	}
-	if (param_idx <= 0 || param_idx > wrapper->statement->n_param) {
-		return DuckDBError;
-	}
-	if (param_idx > wrapper->values.size()) {
-		wrapper->values.resize(param_idx);
-	}
-	wrapper->values[param_idx - 1] = val;
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_bind_boolean(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BOOLEAN(val));
-}
-
-duckdb_state duckdb_bind_int8(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TINYINT(val));
-}
-
-duckdb_state duckdb_bind_int16(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::SMALLINT(val));
-}
-
-duckdb_state duckdb_bind_int32(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::INTEGER(val));
-}
-
-duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BIGINT(val));
-}
-
-duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_hugeint val) {
-	hugeint_t internal;
-	internal.lower = val.lower;
-	internal.upper = val.upper;
-	return duckdb_bind_value(prepared_statement, param_idx, Value::HUGEINT(internal));
-}
-
-duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UTINYINT(val));
-}
-
-duckdb_state duckdb_bind_uint16(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::USMALLINT(val));
-}
-
-duckdb_state duckdb_bind_uint32(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UINTEGER(val));
-}
-
-duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UBIGINT(val));
-}
-
-duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::FLOAT(val));
-}
-
-duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::DOUBLE(val));
-}
-
-duckdb_state duckdb_bind_date(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_date val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::DATE(date_t(val.days)));
-}
-
-duckdb_state duckdb_bind_time(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_time val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TIME(dtime_t(val.micros)));
-}
-
-duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                   duckdb_timestamp val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TIMESTAMP(timestamp_t(val.micros)));
-}
-
-duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_interval val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::INTERVAL(val.months, val.days, val.micros));
-}
-
-duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val) {
-	try {
-		return duckdb_bind_value(prepared_statement, param_idx, Value(val));
-	} catch (...) {
-		return DuckDBError;
-	}
-}
-
-duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val,
-                                        idx_t length) {
-	try {
-		return duckdb_bind_value(prepared_statement, param_idx, Value(std::string(val, length)));
-	} catch (...) {
-		return DuckDBError;
-	}
-}
-
-duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data,
-                              idx_t length) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BLOB((duckdb::const_data_ptr_t)data, length));
-}
-
-duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value());
-}
-
-duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement, duckdb_result *out_result) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
-	if (!wrapper || !wrapper->statement || !wrapper->statement->success) {
-		return DuckDBError;
-	}
-	auto result = wrapper->statement->Execute(wrapper->values, false);
-	return duckdb_translate_result(move(result), out_result);
-}
-
-void duckdb_destroy_prepare(duckdb_prepared_statement *prepared_statement) {
-	if (!prepared_statement) {
-		return;
-	}
-	auto wrapper = (PreparedStatementWrapper *)*prepared_statement;
-	if (wrapper) {
-		delete wrapper;
-	}
-	*prepared_statement = nullptr;
-}
-
-
-
-
-
-
-namespace duckdb {
-
-struct CAPIReplacementScanData : public ReplacementScanData {
-	~CAPIReplacementScanData() {
-		if (delete_callback) {
-			delete_callback(extra_data);
-		}
-	}
-
-	duckdb_replacement_callback_t callback;
-	void *extra_data;
-	duckdb_delete_callback_t delete_callback;
-};
-
-struct CAPIReplacementScanInfo {
-	CAPIReplacementScanInfo(CAPIReplacementScanData *data) : data(data) {
-	}
-
-	CAPIReplacementScanData *data;
-	string function_name;
-	vector<Value> parameters;
-};
-
-unique_ptr<TableFunctionRef> duckdb_capi_replacement_callback(ClientContext &context, const string &table_name,
-                                                              ReplacementScanData *data) {
-	auto &scan_data = (CAPIReplacementScanData &)*data;
-
-	CAPIReplacementScanInfo info(&scan_data);
-	scan_data.callback((duckdb_replacement_scan_info)&info, table_name.c_str(), scan_data.extra_data);
-	if (info.function_name.empty()) {
-		// no function provided: bail-out
-		return nullptr;
-	}
-	auto table_function = make_unique<TableFunctionRef>();
-	vector<unique_ptr<ParsedExpression>> children;
-	for (auto &param : info.parameters) {
-		children.push_back(make_unique<ConstantExpression>(move(param)));
-	}
-	table_function->function = make_unique<FunctionExpression>(info.function_name, move(children));
-	return table_function;
-}
-
-} // namespace duckdb
-
-void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback_t replacement, void *extra_data,
-                                 duckdb_delete_callback_t delete_callback) {
-	if (!db || !replacement) {
-		return;
-	}
-	auto wrapper = (duckdb::DatabaseData *)db;
-	auto scan_info = duckdb::make_unique<duckdb::CAPIReplacementScanData>();
-	scan_info->callback = replacement;
-	scan_info->extra_data = extra_data;
-	scan_info->delete_callback = delete_callback;
-
-	auto &config = duckdb::DBConfig::GetConfig(*wrapper->database->instance);
-	config.replacement_scans.push_back(
-	    duckdb::ReplacementScan(duckdb::duckdb_capi_replacement_callback, move(scan_info)));
-}
-
-void duckdb_replacement_scan_set_function_name(duckdb_replacement_scan_info info_p, const char *function_name) {
-	if (!info_p || !function_name) {
-		return;
-	}
-	auto info = (duckdb::CAPIReplacementScanInfo *)info_p;
-	info->function_name = function_name;
-}
-
-void duckdb_replacement_scan_add_parameter(duckdb_replacement_scan_info info_p, duckdb_value parameter) {
-	if (!info_p || !parameter) {
-		return;
-	}
-	auto info = (duckdb::CAPIReplacementScanInfo *)info_p;
-	auto val = (duckdb::Value *)parameter;
-	info->parameters.push_back(*val);
-}
-
-
-
-namespace duckdb {
-
-template <class T>
-void WriteData(duckdb_column *column, ChunkCollection &source, idx_t col) {
-	idx_t row = 0;
-	auto target = (T *)column->__deprecated_data;
-	for (auto &chunk : source.Chunks()) {
-		auto source = FlatVector::GetData<T>(chunk->data[col]);
-		auto &mask = FlatVector::Validity(chunk->data[col]);
-
-		for (idx_t k = 0; k < chunk->size(); k++, row++) {
-			if (!mask.RowIsValid(k)) {
-				continue;
-			}
-			target[row] = source[k];
-		}
-	}
-}
-
-duckdb_state deprecated_duckdb_translate_column(MaterializedQueryResult &result, duckdb_column *column, idx_t col) {
-	idx_t row_count = result.collection.Count();
-	column->__deprecated_nullmask = (bool *)duckdb_malloc(sizeof(bool) * result.collection.Count());
-	column->__deprecated_data = duckdb_malloc(GetCTypeSize(column->__deprecated_type) * row_count);
-	if (!column->__deprecated_nullmask || !column->__deprecated_data) { // LCOV_EXCL_START
-		// malloc failure
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-
-	// first convert the nullmask
-	idx_t row = 0;
-	for (auto &chunk : result.collection.Chunks()) {
-		for (idx_t k = 0; k < chunk->size(); k++) {
-			column->__deprecated_nullmask[row++] = FlatVector::IsNull(chunk->data[col], k);
-		}
-	}
-	// then write the data
-	switch (result.types[col].id()) {
-	case LogicalTypeId::BOOLEAN:
-		WriteData<bool>(column, result.collection, col);
-		break;
-	case LogicalTypeId::TINYINT:
-		WriteData<int8_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::SMALLINT:
-		WriteData<int16_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::INTEGER:
-		WriteData<int32_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::BIGINT:
-		WriteData<int64_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::UTINYINT:
-		WriteData<uint8_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::USMALLINT:
-		WriteData<uint16_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::UINTEGER:
-		WriteData<uint32_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::UBIGINT:
-		WriteData<uint64_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::FLOAT:
-		WriteData<float>(column, result.collection, col);
-		break;
-	case LogicalTypeId::DOUBLE:
-		WriteData<double>(column, result.collection, col);
-		break;
-	case LogicalTypeId::DATE:
-		WriteData<date_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		WriteData<dtime_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		WriteData<timestamp_t>(column, result.collection, col);
-		break;
-	case LogicalTypeId::VARCHAR: {
-		idx_t row = 0;
-		auto target = (const char **)column->__deprecated_data;
-		for (auto &chunk : result.collection.Chunks()) {
-			auto source = FlatVector::GetData<string_t>(chunk->data[col]);
-			for (idx_t k = 0; k < chunk->size(); k++) {
-				if (!FlatVector::IsNull(chunk->data[col], k)) {
-					target[row] = (char *)duckdb_malloc(source[k].GetSize() + 1);
-					assert(target[row]);
-					memcpy((void *)target[row], source[k].GetDataUnsafe(), source[k].GetSize());
-					auto write_arr = (char *)target[row];
-					write_arr[source[k].GetSize()] = '\0';
-				} else {
-					target[row] = nullptr;
-				}
-				row++;
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::BLOB: {
-		idx_t row = 0;
-		auto target = (duckdb_blob *)column->__deprecated_data;
-		for (auto &chunk : result.collection.Chunks()) {
-			auto source = FlatVector::GetData<string_t>(chunk->data[col]);
-			for (idx_t k = 0; k < chunk->size(); k++) {
-				if (!FlatVector::IsNull(chunk->data[col], k)) {
-					target[row].data = (char *)duckdb_malloc(source[k].GetSize());
-					target[row].size = source[k].GetSize();
-					assert(target[row].data);
-					memcpy((void *)target[row].data, source[k].GetDataUnsafe(), source[k].GetSize());
-				} else {
-					target[row].data = nullptr;
-					target[row].size = 0;
-				}
-				row++;
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_SEC: {
-		idx_t row = 0;
-		auto target = (timestamp_t *)column->__deprecated_data;
-		for (auto &chunk : result.collection.Chunks()) {
-			auto source = FlatVector::GetData<timestamp_t>(chunk->data[col]);
-
-			for (idx_t k = 0; k < chunk->size(); k++) {
-				if (!FlatVector::IsNull(chunk->data[col], k)) {
-					if (result.types[col].id() == LogicalTypeId::TIMESTAMP_NS) {
-						target[row] = Timestamp::FromEpochNanoSeconds(source[k].value);
-					} else if (result.types[col].id() == LogicalTypeId::TIMESTAMP_MS) {
-						target[row] = Timestamp::FromEpochMs(source[k].value);
-					} else {
-						D_ASSERT(result.types[col].id() == LogicalTypeId::TIMESTAMP_SEC);
-						target[row] = Timestamp::FromEpochSeconds(source[k].value);
-					}
-				}
-				row++;
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::HUGEINT: {
-		idx_t row = 0;
-		auto target = (duckdb_hugeint *)column->__deprecated_data;
-		for (auto &chunk : result.collection.Chunks()) {
-			auto source = FlatVector::GetData<hugeint_t>(chunk->data[col]);
-			for (idx_t k = 0; k < chunk->size(); k++) {
-				if (!FlatVector::IsNull(chunk->data[col], k)) {
-					target[row].lower = source[k].lower;
-					target[row].upper = source[k].upper;
-				}
-				row++;
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::INTERVAL: {
-		idx_t row = 0;
-		auto target = (duckdb_interval *)column->__deprecated_data;
-		for (auto &chunk : result.collection.Chunks()) {
-			auto source = FlatVector::GetData<interval_t>(chunk->data[col]);
-			for (idx_t k = 0; k < chunk->size(); k++) {
-				if (!FlatVector::IsNull(chunk->data[col], k)) {
-					target[row].days = source[k].days;
-					target[row].months = source[k].months;
-					target[row].micros = source[k].micros;
-				}
-				row++;
-			}
-		}
-		break;
-	}
-	case LogicalTypeId::DECIMAL: {
-		// get data
-		idx_t row = 0;
-		auto target = (hugeint_t *)column->__deprecated_data;
-		switch (result.types[col].InternalType()) {
-		case PhysicalType::INT16: {
-			for (auto &chunk : result.collection.Chunks()) {
-				auto source = FlatVector::GetData<int16_t>(chunk->data[col]);
-				for (idx_t k = 0; k < chunk->size(); k++) {
-					if (!FlatVector::IsNull(chunk->data[col], k)) {
-						target[row].lower = source[k];
-						target[row].upper = 0;
-					}
-					row++;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT32: {
-			for (auto &chunk : result.collection.Chunks()) {
-				auto source = FlatVector::GetData<int32_t>(chunk->data[col]);
-				for (idx_t k = 0; k < chunk->size(); k++) {
-					if (!FlatVector::IsNull(chunk->data[col], k)) {
-						target[row].lower = source[k];
-						target[row].upper = 0;
-					}
-					row++;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT64: {
-			for (auto &chunk : result.collection.Chunks()) {
-				auto source = FlatVector::GetData<int64_t>(chunk->data[col]);
-				for (idx_t k = 0; k < chunk->size(); k++) {
-					if (!FlatVector::IsNull(chunk->data[col], k)) {
-						target[row].lower = source[k];
-						target[row].upper = 0;
-					}
-					row++;
-				}
-			}
-			break;
-		}
-		case PhysicalType::INT128: {
-			for (auto &chunk : result.collection.Chunks()) {
-				auto source = FlatVector::GetData<hugeint_t>(chunk->data[col]);
-				for (idx_t k = 0; k < chunk->size(); k++) {
-					if (!FlatVector::IsNull(chunk->data[col], k)) {
-						target[row].lower = source[k].lower;
-						target[row].upper = source[k].upper;
-					}
-					row++;
-				}
-			}
-			break;
-		}
-		default:
-			throw std::runtime_error("Unsupported physical type for Decimal" +
-			                         TypeIdToString(result.types[col].InternalType()));
-		}
-		break;
-	}
-	default: // LCOV_EXCL_START
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	return DuckDBSuccess;
-}
-
-duckdb_state duckdb_translate_result(unique_ptr<QueryResult> result_p, duckdb_result *out) {
-	auto &result = *result_p;
-	D_ASSERT(result_p);
-	if (!out) {
-		// no result to write to, only return the status
-		return result.success ? DuckDBSuccess : DuckDBError;
-	}
-
-	memset(out, 0, sizeof(duckdb_result));
-
-	// initialize the result_data object
-	auto result_data = new DuckDBResultData();
-	result_data->result = move(result_p);
-	result_data->result_set_type = CAPIResultSetType::CAPI_RESULT_TYPE_NONE;
-	out->internal_data = result_data;
-
-	if (!result.success) {
-		// write the error message
-		out->__deprecated_error_message = (char *)result.error.c_str();
-		return DuckDBError;
-	}
-	// copy the data
-	// first write the meta data
-	out->__deprecated_column_count = result.ColumnCount();
-	out->__deprecated_rows_changed = 0;
-	return DuckDBSuccess;
-}
-
-bool deprecated_materialize_result(duckdb_result *result) {
-	if (!result) {
-		return false;
-	}
-	auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
-	if (!result_data->result->success) {
-		return false;
-	}
-	if (result_data->result_set_type == CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
-		// already materialized into deprecated result format
-		return true;
-	}
-	if (result_data->result_set_type == CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED) {
-		// already used as a new result set
-		return false;
-	}
-	// materialize as deprecated result set
-	result_data->result_set_type = CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED;
-	auto column_count = result_data->result->ColumnCount();
-	result->__deprecated_columns = (duckdb_column *)duckdb_malloc(sizeof(duckdb_column) * column_count);
-	if (!result->__deprecated_columns) { // LCOV_EXCL_START
-		// malloc failure
-		return DuckDBError;
-	} // LCOV_EXCL_STOP
-	if (result_data->result->type == QueryResultType::STREAM_RESULT) {
-		// if we are dealing with a stream result, convert it to a materialized result first
-		auto &stream_result = (StreamQueryResult &)*result_data->result;
-		result_data->result = stream_result.Materialize();
-	}
-	D_ASSERT(result_data->result->type == QueryResultType::MATERIALIZED_RESULT);
-	auto &materialized = (MaterializedQueryResult &)*result_data->result;
-
-	// convert the result to a materialized result
-	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
-	memset(result->__deprecated_columns, 0, sizeof(duckdb_column) * column_count);
-	for (idx_t i = 0; i < column_count; i++) {
-		result->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result_data->result->types[i]);
-		result->__deprecated_columns[i].__deprecated_name = (char *)result_data->result->names[i].c_str();
-	}
-	result->__deprecated_row_count = materialized.collection.Count();
-	if (result->__deprecated_row_count > 0 &&
-	    materialized.properties.return_type == StatementReturnType::CHANGED_ROWS) {
-		// update total changes
-		auto row_changes = materialized.GetValue(0, 0);
-		if (!row_changes.IsNull() && row_changes.TryCastAs(LogicalType::BIGINT)) {
-			result->__deprecated_rows_changed = row_changes.GetValue<int64_t>();
-		}
-	}
-	// now write the data
-	for (idx_t col = 0; col < column_count; col++) {
-		auto state = deprecated_duckdb_translate_column(materialized, &result->__deprecated_columns[col], col);
-		if (state != DuckDBSuccess) {
-			return false;
-		}
-	}
-	return true;
-}
-
-} // namespace duckdb
-
-static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
-	if (column.__deprecated_data) {
-		if (column.__deprecated_type == DUCKDB_TYPE_VARCHAR) {
-			// varchar, delete individual strings
-			auto data = (char **)column.__deprecated_data;
-			for (idx_t i = 0; i < count; i++) {
-				if (data[i]) {
-					duckdb_free(data[i]);
-				}
-			}
-		} else if (column.__deprecated_type == DUCKDB_TYPE_BLOB) {
-			// blob, delete individual blobs
-			auto data = (duckdb_blob *)column.__deprecated_data;
-			for (idx_t i = 0; i < count; i++) {
-				if (data[i].data) {
-					duckdb_free((void *)data[i].data);
-				}
-			}
-		}
-		duckdb_free(column.__deprecated_data);
-	}
-	if (column.__deprecated_nullmask) {
-		duckdb_free(column.__deprecated_nullmask);
-	}
-}
-
-void duckdb_destroy_result(duckdb_result *result) {
-	if (result->__deprecated_columns) {
-		for (idx_t i = 0; i < result->__deprecated_column_count; i++) {
-			DuckdbDestroyColumn(result->__deprecated_columns[i], result->__deprecated_row_count);
-		}
-		duckdb_free(result->__deprecated_columns);
-	}
-	if (result->internal_data) {
-		auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
-		delete result_data;
-	}
-	memset(result, 0, sizeof(duckdb_result));
-}
-
-const char *duckdb_column_name(duckdb_result *result, idx_t col) {
-	if (!result || col >= duckdb_column_count(result)) {
-		return nullptr;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
-	return result_data.result->names[col].c_str();
-}
-
-duckdb_type duckdb_column_type(duckdb_result *result, idx_t col) {
-	if (!result || col >= duckdb_column_count(result)) {
-		return DUCKDB_TYPE_INVALID;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
-	return duckdb::ConvertCPPTypeToC(result_data.result->types[col]);
-}
-
-duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col) {
-	if (!result || col >= duckdb_column_count(result)) {
-		return nullptr;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
-	return new duckdb::LogicalType(result_data.result->types[col]);
-}
-
-idx_t duckdb_column_count(duckdb_result *result) {
-	if (!result) {
-		return 0;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
-	return result_data.result->ColumnCount();
-}
-
-idx_t duckdb_row_count(duckdb_result *result) {
-	if (!result) {
-		return 0;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
-	return materialized.collection.Count();
-}
-
-idx_t duckdb_rows_changed(duckdb_result *result) {
-	if (!result) {
-		return 0;
-	}
-	if (!duckdb::deprecated_materialize_result(result)) {
-		return 0;
-	}
-	return result->__deprecated_rows_changed;
-}
-
-void *duckdb_column_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->__deprecated_column_count) {
-		return nullptr;
-	}
-	if (!duckdb::deprecated_materialize_result(result)) {
-		return nullptr;
-	}
-	return result->__deprecated_columns[col].__deprecated_data;
-}
-
-bool *duckdb_nullmask_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->__deprecated_column_count) {
-		return nullptr;
-	}
-	if (!duckdb::deprecated_materialize_result(result)) {
-		return nullptr;
-	}
-	return result->__deprecated_columns[col].__deprecated_nullmask;
-}
-
-const char *duckdb_result_error(duckdb_result *result) {
-	if (!result) {
-		return nullptr;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
-	return result_data.result->success ? nullptr : result_data.result->error.c_str();
-}
-
-idx_t duckdb_result_chunk_count(duckdb_result result) {
-	if (!result.internal_data) {
-		return 0;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
-	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
-		return 0;
-	}
-	D_ASSERT(result_data.result->type == duckdb::QueryResultType::MATERIALIZED_RESULT);
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
-	return materialized.collection.ChunkCount();
-}
-
-duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx) {
-	if (!result.internal_data) {
-		return nullptr;
-	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
-	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
-		return nullptr;
-	}
-	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED;
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
-	if (chunk_idx >= materialized.collection.ChunkCount()) {
-		return nullptr;
-	}
-	auto chunk = duckdb::make_unique<duckdb::DataChunk>();
-	chunk->InitializeEmpty(materialized.collection.Types());
-	chunk->Reference(*materialized.collection.Chunks()[chunk_idx]);
-	return chunk.release();
-}
-
-
-
-
-
-
-namespace duckdb {
-
-struct CTableFunctionInfo : public TableFunctionInfo {
-	~CTableFunctionInfo() {
-		if (extra_info && delete_callback) {
-			delete_callback(extra_info);
-		}
-		extra_info = nullptr;
-		delete_callback = nullptr;
-	}
-
-	duckdb_table_function_bind_t bind = nullptr;
-	duckdb_table_function_init_t init = nullptr;
-	duckdb_table_function_init_t local_init = nullptr;
-	duckdb_table_function_t function = nullptr;
-	void *extra_info = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-};
-
-struct CTableBindData : public TableFunctionData {
-	~CTableBindData() {
-		if (bind_data && delete_callback) {
-			delete_callback(bind_data);
-		}
-		bind_data = nullptr;
-		delete_callback = nullptr;
-	}
-
-	CTableFunctionInfo *info = nullptr;
-	void *bind_data = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-};
-
-struct CTableInternalBindInfo {
-	CTableInternalBindInfo(ClientContext &context, TableFunctionBindInput &input, vector<LogicalType> &return_types,
-	                       vector<string> &names, CTableBindData &bind_data, CTableFunctionInfo &function_info)
-	    : context(context), input(input), return_types(return_types), names(names), bind_data(bind_data),
-	      function_info(function_info), success(true) {
-	}
-
-	ClientContext &context;
-	TableFunctionBindInput &input;
-	vector<LogicalType> &return_types;
-	vector<string> &names;
-	CTableBindData &bind_data;
-	CTableFunctionInfo &function_info;
-	bool success;
-	string error;
-};
-
-struct CTableInitData {
-	~CTableInitData() {
-		if (init_data && delete_callback) {
-			delete_callback(init_data);
-		}
-		init_data = nullptr;
-		delete_callback = nullptr;
-	}
-
-	void *init_data = nullptr;
-	duckdb_delete_callback_t delete_callback = nullptr;
-	idx_t max_threads = 1;
-};
-
-struct CTableGlobalInitData : public GlobalTableFunctionState {
-	CTableInitData init_data;
-
-	idx_t MaxThreads() const override {
-		return init_data.max_threads;
-	}
-};
-
-struct CTableLocalInitData : public LocalTableFunctionState {
-	CTableInitData init_data;
-};
-
-struct CTableInternalInitInfo {
-	CTableInternalInitInfo(CTableBindData &bind_data, CTableInitData &init_data, const vector<column_t> &column_ids,
-	                       TableFilterSet *filters)
-	    : bind_data(bind_data), init_data(init_data), column_ids(column_ids), filters(filters), success(true) {
-	}
-
-	CTableBindData &bind_data;
-	CTableInitData &init_data;
-	const vector<column_t> &column_ids;
-	TableFilterSet *filters;
-	bool success;
-	string error;
-};
-
-struct CTableInternalFunctionInfo {
-	CTableInternalFunctionInfo(CTableBindData &bind_data, CTableInitData &init_data, CTableInitData &local_data)
-	    : bind_data(bind_data), init_data(init_data), local_data(local_data), success(true) {
-	}
-
-	CTableBindData &bind_data;
-	CTableInitData &init_data;
-	CTableInitData &local_data;
-	bool success;
-	string error;
-};
-
-unique_ptr<FunctionData> CTableFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                            vector<LogicalType> &return_types, vector<string> &names) {
-	auto info = (CTableFunctionInfo *)input.info;
-	D_ASSERT(info->bind && info->function && info->init);
-	auto result = make_unique<CTableBindData>();
-	CTableInternalBindInfo bind_info(context, input, return_types, names, *result, *info);
-	info->bind(&bind_info);
-	if (!bind_info.success) {
-		throw Exception(bind_info.error);
-	}
-
-	result->info = info;
-	return move(result);
-}
-
-unique_ptr<GlobalTableFunctionState> CTableFunctionInit(ClientContext &context, TableFunctionInitInput &data_p) {
-	auto &bind_data = (CTableBindData &)*data_p.bind_data;
-	auto result = make_unique<CTableGlobalInitData>();
-
-	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
-	bind_data.info->init(&init_info);
-	if (!init_info.success) {
-		throw Exception(init_info.error);
-	}
-	return move(result);
-}
-
-unique_ptr<LocalTableFunctionState> CTableFunctionLocalInit(ExecutionContext &context, TableFunctionInitInput &data_p,
-                                                            GlobalTableFunctionState *gstate) {
-	auto &bind_data = (CTableBindData &)*data_p.bind_data;
-	auto result = make_unique<CTableLocalInitData>();
-	if (!bind_data.info->local_init) {
-		return move(result);
-	}
-
-	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
-	bind_data.info->local_init(&init_info);
-	if (!init_info.success) {
-		throw Exception(init_info.error);
-	}
-	return move(result);
-}
-
-void CTableFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (CTableBindData &)*data_p.bind_data;
-	auto &global_data = (CTableGlobalInitData &)*data_p.global_state;
-	auto &local_data = (CTableLocalInitData &)*data_p.local_state;
-	CTableInternalFunctionInfo function_info(bind_data, global_data.init_data, local_data.init_data);
-	bind_data.info->function(&function_info, &output);
-	if (!function_info.success) {
-		throw Exception(function_info.error);
-	}
-}
-
-} // namespace duckdb
-
-//===--------------------------------------------------------------------===//
-// Table Function
-//===--------------------------------------------------------------------===//
-duckdb_table_function duckdb_create_table_function() {
-	auto function = new duckdb::TableFunction("", {}, duckdb::CTableFunction, duckdb::CTableFunctionBind,
-	                                          duckdb::CTableFunctionInit, duckdb::CTableFunctionLocalInit);
-	function->function_info = duckdb::make_shared<duckdb::CTableFunctionInfo>();
-	return function;
-}
-
-void duckdb_destroy_table_function(duckdb_table_function *function) {
-	if (function && *function) {
-		auto tf = (duckdb::TableFunction *)*function;
-		delete tf;
-		*function = nullptr;
-	}
-}
-
-void duckdb_table_function_set_name(duckdb_table_function function, const char *name) {
-	if (!function || !name) {
-		return;
-	}
-	auto tf = (duckdb::TableFunction *)function;
-	tf->name = name;
-}
-
-void duckdb_table_function_add_parameter(duckdb_table_function function, duckdb_logical_type type) {
-	if (!function || !type) {
-		return;
-	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto logical_type = (duckdb::LogicalType *)type;
-	tf->arguments.push_back(*logical_type);
-}
-
-void duckdb_table_function_set_extra_info(duckdb_table_function function, void *extra_info,
-                                          duckdb_delete_callback_t destroy) {
-	if (!function) {
-		return;
-	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->extra_info = extra_info;
-	info->delete_callback = destroy;
-}
-
-void duckdb_table_function_set_bind(duckdb_table_function function, duckdb_table_function_bind_t bind) {
-	if (!function || !bind) {
-		return;
-	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->bind = bind;
-}
-
-void duckdb_table_function_set_init(duckdb_table_function function, duckdb_table_function_init_t init) {
-	if (!function || !init) {
-		return;
-	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->init = init;
-}
-
-void duckdb_table_function_set_local_init(duckdb_table_function function, duckdb_table_function_init_t init) {
-	if (!function || !init) {
-		return;
-	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->local_init = init;
-}
-
-void duckdb_table_function_set_function(duckdb_table_function table_function, duckdb_table_function_t function) {
-	if (!table_function || !function) {
-		return;
-	}
-	auto tf = (duckdb::TableFunction *)table_function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->function = function;
-}
-
-void duckdb_table_function_supports_projection_pushdown(duckdb_table_function table_function, bool pushdown) {
-	if (!table_function) {
-		return;
-	}
-	auto tf = (duckdb::TableFunction *)table_function;
-	tf->projection_pushdown = pushdown;
-}
-
-duckdb_state duckdb_register_table_function(duckdb_connection connection, duckdb_table_function function) {
-	if (!connection || !function) {
-		return DuckDBError;
-	}
-	auto con = (duckdb::Connection *)connection;
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	if (tf->name.empty() || !info->bind || !info->init || !info->function) {
-		return DuckDBError;
-	}
-	con->context->RunFunctionInTransaction([&]() {
-		auto &catalog = duckdb::Catalog::GetCatalog(*con->context);
-		duckdb::CreateTableFunctionInfo tf_info(*tf);
-
-		// create the function in the catalog
-		catalog.CreateTableFunction(*con->context, &tf_info);
-	});
-	return DuckDBSuccess;
-}
-
-//===--------------------------------------------------------------------===//
-// Bind Interface
-//===--------------------------------------------------------------------===//
-void *duckdb_bind_get_extra_info(duckdb_bind_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	return bind_info->function_info.extra_info;
-}
-
-void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duckdb_logical_type type) {
-	if (!info || !name || !type) {
-		return;
-	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	bind_info->names.push_back(name);
-	bind_info->return_types.push_back(*((duckdb::LogicalType *)type));
-}
-
-idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info) {
-	if (!info) {
-		return 0;
-	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	return bind_info->input.inputs.size();
-}
-
-duckdb_value duckdb_bind_get_parameter(duckdb_bind_info info, idx_t index) {
-	if (!info || index >= duckdb_bind_get_parameter_count(info)) {
-		return nullptr;
-	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	return new duckdb::Value(bind_info->input.inputs[index]);
-}
-
-void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy) {
-	if (!info) {
-		return;
-	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	bind_info->bind_data.bind_data = bind_data;
-	bind_info->bind_data.delete_callback = destroy;
-}
-
-void duckdb_bind_set_error(duckdb_bind_info info, const char *error) {
-	if (!info || !error) {
-		return;
-	}
-	auto function_info = (duckdb::CTableInternalBindInfo *)info;
-	function_info->error = error;
-	function_info->success = false;
-}
-
-//===--------------------------------------------------------------------===//
-// Init Interface
-//===--------------------------------------------------------------------===//
-void *duckdb_init_get_extra_info(duckdb_init_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto init_info = (duckdb::CTableInternalInitInfo *)info;
-	return init_info->bind_data.info->extra_info;
-}
-
-void *duckdb_init_get_bind_data(duckdb_init_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto init_info = (duckdb::CTableInternalInitInfo *)info;
-	return init_info->bind_data.bind_data;
-}
-
-void duckdb_init_set_init_data(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy) {
-	if (!info) {
-		return;
-	}
-	auto init_info = (duckdb::CTableInternalInitInfo *)info;
-	init_info->init_data.init_data = init_data;
-	init_info->init_data.delete_callback = destroy;
-}
-
-void duckdb_init_set_error(duckdb_init_info info, const char *error) {
-	if (!info || !error) {
-		return;
-	}
-	auto function_info = (duckdb::CTableInternalInitInfo *)info;
-	function_info->error = error;
-	function_info->success = false;
-}
-
-idx_t duckdb_init_get_column_count(duckdb_init_info info) {
-	if (!info) {
-		return 0;
-	}
-	auto function_info = (duckdb::CTableInternalInitInfo *)info;
-	return function_info->column_ids.size();
-}
-
-idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index) {
-	if (!info) {
-		return 0;
-	}
-	auto function_info = (duckdb::CTableInternalInitInfo *)info;
-	if (column_index >= function_info->column_ids.size()) {
-		return 0;
-	}
-	return function_info->column_ids[column_index];
-}
-
-void duckdb_init_set_max_threads(duckdb_init_info info, idx_t max_threads) {
-	if (!info) {
-		return;
-	}
-	auto function_info = (duckdb::CTableInternalInitInfo *)info;
-	function_info->init_data.max_threads = max_threads;
-}
-
-//===--------------------------------------------------------------------===//
-// Function Interface
-//===--------------------------------------------------------------------===//
-void *duckdb_function_get_extra_info(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->bind_data.info->extra_info;
-}
-
-void *duckdb_function_get_bind_data(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->bind_data.bind_data;
-}
-
-void *duckdb_function_get_init_data(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->init_data.init_data;
-}
-
-void *duckdb_function_get_local_init_data(duckdb_function_info info) {
-	if (!info) {
-		return nullptr;
-	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->local_data.init_data;
-}
-
-void duckdb_function_set_error(duckdb_function_info info, const char *error) {
-	if (!info || !error) {
-		return;
-	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	function_info->error = error;
-	function_info->success = false;
-}
-
-
-
-using duckdb::DatabaseData;
-
-void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks) {
-	if (!database) {
-		return;
-	}
-	auto wrapper = (DatabaseData *)database;
-	auto &scheduler = duckdb::TaskScheduler::GetScheduler(*wrapper->database->instance);
-	scheduler.ExecuteTasks(max_tasks);
-}
-
-
-
-
-
-
-
-using duckdb::const_data_ptr_t;
-using duckdb::Date;
-using duckdb::date_t;
-using duckdb::dtime_t;
-using duckdb::hugeint_t;
-using duckdb::interval_t;
-using duckdb::LogicalType;
-using duckdb::string;
-using duckdb::string_t;
-using duckdb::Time;
-using duckdb::Timestamp;
-using duckdb::timestamp_t;
-using duckdb::Value;
-using duckdb::Vector;
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Unsafe Fetch (for internal use only)
-//===--------------------------------------------------------------------===//
-template <class T>
-T UnsafeFetch(duckdb_result *result, idx_t col, idx_t row) {
-	D_ASSERT(row < result->__deprecated_row_count);
-	return ((T *)result->__deprecated_columns[col].__deprecated_data)[row];
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Default Value
-//===--------------------------------------------------------------------===//
-struct FetchDefaultValue {
-	template <class T>
-	static T Operation() {
-		return 0;
-	}
-};
-
-template <>
-date_t FetchDefaultValue::Operation() {
-	date_t result;
-	result.days = 0;
-	return result;
-}
-
-template <>
-dtime_t FetchDefaultValue::Operation() {
-	dtime_t result;
-	result.micros = 0;
-	return result;
-}
-
-template <>
-timestamp_t FetchDefaultValue::Operation() {
-	timestamp_t result;
-	result.value = 0;
-	return result;
-}
-
-template <>
-interval_t FetchDefaultValue::Operation() {
-	interval_t result;
-	result.months = 0;
-	result.days = 0;
-	result.micros = 0;
-	return result;
-}
-
-template <>
-char *FetchDefaultValue::Operation() {
-	return nullptr;
-}
-
-template <>
-duckdb_blob FetchDefaultValue::Operation() {
-	duckdb_blob result;
-	result.data = nullptr;
-	result.size = 0;
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// String Casts
-//===--------------------------------------------------------------------===//
-template <class OP>
-struct FromCStringCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input_str, RESULT_TYPE &result) {
-		string_t input(input_str);
-		return OP::template Operation<string_t, RESULT_TYPE>(input, result);
-	}
-};
-
-template <class OP>
-struct ToCStringCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input, RESULT_TYPE &result) {
-		Vector result_vector(LogicalType::VARCHAR, nullptr);
-		auto result_string = OP::template Operation<SOURCE_TYPE>(input, result_vector);
-		auto result_size = result_string.GetSize();
-		auto result_data = result_string.GetDataUnsafe();
-
-		result = (char *)duckdb_malloc(result_size + 1);
-		memcpy(result, result_data, result_size);
-		result[result_size] = '\0';
-		return true;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Blob Casts
-//===--------------------------------------------------------------------===//
-struct FromCBlobCastWrapper {
-	template <class SOURCE_TYPE, class RESULT_TYPE>
-	static bool Operation(SOURCE_TYPE input_str, RESULT_TYPE &result) {
-		return false;
-	}
-};
-
-template <>
-bool FromCBlobCastWrapper::Operation(duckdb_blob input, char *&result) {
-	string_t input_str((const char *)input.data, input.size);
-	return ToCStringCastWrapper<duckdb::CastFromBlob>::template Operation<string_t, char *>(input_str, result);
-}
-
-} // namespace duckdb
-
-using duckdb::FetchDefaultValue;
-using duckdb::FromCBlobCastWrapper;
-using duckdb::FromCStringCastWrapper;
-using duckdb::ToCStringCastWrapper;
-using duckdb::UnsafeFetch;
-
-//===--------------------------------------------------------------------===//
-// Templated Casts
-//===--------------------------------------------------------------------===//
-template <class SOURCE_TYPE, class RESULT_TYPE, class OP>
-RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
-	RESULT_TYPE result_value;
-	try {
-		if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row),
-		                                                      result_value)) {
-			return FetchDefaultValue::Operation<RESULT_TYPE>();
-		}
-	} catch (...) {
-		return FetchDefaultValue::Operation<RESULT_TYPE>();
-	}
-	return result_value;
-}
-
-static bool CanUseDeprecatedFetch(duckdb_result *result, idx_t col, idx_t row) {
-	if (!result) {
-		return false;
-	}
-	if (!duckdb::deprecated_materialize_result(result)) {
-		return false;
-	}
-	if (col >= result->__deprecated_column_count || row >= result->__deprecated_row_count) {
-		return false;
-	}
-	return true;
-}
-
-static bool CanFetchValue(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanUseDeprecatedFetch(result, col, row)) {
-		return false;
-	}
-	if (result->__deprecated_columns[col].__deprecated_nullmask[row]) {
-		return false;
-	}
-	return true;
-}
-
-template <class RESULT_TYPE, class OP = duckdb::TryCast>
-static RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanFetchValue(result, col, row)) {
-		return FetchDefaultValue::Operation<RESULT_TYPE>();
-	}
-	switch (result->__deprecated_columns[col].__deprecated_type) {
-	case DUCKDB_TYPE_BOOLEAN:
-		return TryCastCInternal<bool, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_TINYINT:
-		return TryCastCInternal<int8_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_SMALLINT:
-		return TryCastCInternal<int16_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_INTEGER:
-		return TryCastCInternal<int32_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_BIGINT:
-		return TryCastCInternal<int64_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_UTINYINT:
-		return TryCastCInternal<uint8_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_USMALLINT:
-		return TryCastCInternal<uint16_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_UINTEGER:
-		return TryCastCInternal<uint32_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_UBIGINT:
-		return TryCastCInternal<uint64_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_FLOAT:
-		return TryCastCInternal<float, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_DOUBLE:
-		return TryCastCInternal<double, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_DATE:
-		return TryCastCInternal<date_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_TIME:
-		return TryCastCInternal<dtime_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_TIMESTAMP:
-		return TryCastCInternal<timestamp_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_HUGEINT:
-		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_DECIMAL:
-		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_INTERVAL:
-		return TryCastCInternal<interval_t, RESULT_TYPE, OP>(result, col, row);
-	case DUCKDB_TYPE_VARCHAR:
-		return TryCastCInternal<char *, RESULT_TYPE, FromCStringCastWrapper<OP>>(result, col, row);
-	case DUCKDB_TYPE_BLOB:
-		return TryCastCInternal<duckdb_blob, RESULT_TYPE, FromCBlobCastWrapper>(result, col, row);
-	default: // LCOV_EXCL_START
-		// invalid type for C to C++ conversion
-		D_ASSERT(0);
-		return FetchDefaultValue::Operation<RESULT_TYPE>();
-	} // LCOV_EXCL_STOP
-}
-
-//===--------------------------------------------------------------------===//
-// duckdb_value_ functions
-//===--------------------------------------------------------------------===//
-bool duckdb_value_boolean(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<bool>(result, col, row);
-}
-
-int8_t duckdb_value_int8(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<int8_t>(result, col, row);
-}
-
-int16_t duckdb_value_int16(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<int16_t>(result, col, row);
-}
-
-int32_t duckdb_value_int32(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<int32_t>(result, col, row);
-}
-
-int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<int64_t>(result, col, row);
-}
-
-duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_decimal result_value;
-
-	auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
-	result_data->result->types[col].GetDecimalProperties(result_value.width, result_value.scale);
-
-	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
-	result_value.value.lower = internal_value.lower;
-	result_value.value.upper = internal_value.upper;
-	return result_value;
-}
-
-duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_hugeint result_value;
-	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
-	result_value.lower = internal_value.lower;
-	result_value.upper = internal_value.upper;
-	return result_value;
-}
-
-uint8_t duckdb_value_uint8(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<uint8_t>(result, col, row);
-}
-
-uint16_t duckdb_value_uint16(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<uint16_t>(result, col, row);
-}
-
-uint32_t duckdb_value_uint32(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<uint32_t>(result, col, row);
-}
-
-uint64_t duckdb_value_uint64(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<uint64_t>(result, col, row);
-}
-
-float duckdb_value_float(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<float>(result, col, row);
-}
-
-double duckdb_value_double(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<double>(result, col, row);
-}
-
-duckdb_date duckdb_value_date(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_date result_value;
-	result_value.days = GetInternalCValue<date_t>(result, col, row).days;
-	return result_value;
-}
-
-duckdb_time duckdb_value_time(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_time result_value;
-	result_value.micros = GetInternalCValue<dtime_t>(result, col, row).micros;
-	return result_value;
-}
-
-duckdb_timestamp duckdb_value_timestamp(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_timestamp result_value;
-	result_value.micros = GetInternalCValue<timestamp_t>(result, col, row).value;
-	return result_value;
-}
-
-duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t row) {
-	duckdb_interval result_value;
-	auto ival = GetInternalCValue<interval_t>(result, col, row);
-	result_value.months = ival.months;
-	result_value.days = ival.days;
-	result_value.micros = ival.micros;
-	return result_value;
-}
-
-char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row) {
-	return GetInternalCValue<char *, ToCStringCastWrapper<duckdb::StringCast>>(result, col, row);
-}
-
-char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanFetchValue(result, col, row)) {
-		return nullptr;
-	}
-	if (duckdb_column_type(result, col) != DUCKDB_TYPE_VARCHAR) {
-		return nullptr;
-	}
-	return UnsafeFetch<char *>(result, col, row);
-}
-
-duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row) {
-	if (CanFetchValue(result, col, row) && result->__deprecated_columns[col].__deprecated_type == DUCKDB_TYPE_BLOB) {
-		auto internal_result = UnsafeFetch<duckdb_blob>(result, col, row);
-
-		duckdb_blob result_blob;
-		result_blob.data = malloc(internal_result.size);
-		result_blob.size = internal_result.size;
-		memcpy(result_blob.data, internal_result.data, internal_result.size);
-		return result_blob;
-	}
-	return FetchDefaultValue::Operation<duckdb_blob>();
-}
-
-bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row) {
-	if (!CanUseDeprecatedFetch(result, col, row)) {
-		return false;
-	}
-	return result->__deprecated_columns[col].__deprecated_nullmask[row];
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct ActiveQueryContext {
-	//! The query that is currently being executed
-	string query;
-	//! The currently open result
-	BaseQueryResult *open_result = nullptr;
-	//! Prepared statement data
-	shared_ptr<PreparedStatementData> prepared;
-	//! The query executor
-	unique_ptr<Executor> executor;
-	//! The progress bar
-	unique_ptr<ProgressBar> progress_bar;
-};
-
-ClientContext::ClientContext(shared_ptr<DatabaseInstance> database)
-    : db(move(database)), transaction(db->GetTransactionManager(), *this), interrupted(false),
-      client_data(make_unique<ClientData>(*this)) {
-}
-
-ClientContext::~ClientContext() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	// destroy the client context and rollback if there is an active transaction
-	// but only if we are not destroying this client context as part of an exception stack unwind
-	Destroy();
-}
-
-unique_ptr<ClientContextLock> ClientContext::LockContext() {
-	return make_unique<ClientContextLock>(context_lock);
-}
-
-void ClientContext::Destroy() {
-	auto lock = LockContext();
-	if (transaction.HasActiveTransaction()) {
-		ActiveTransaction().active_query = MAXIMUM_QUERY_ID;
-		if (!transaction.IsAutoCommit()) {
-			transaction.Rollback();
-		}
-	}
-	CleanupInternal(*lock);
-}
-
-unique_ptr<DataChunk> ClientContext::Fetch(ClientContextLock &lock, StreamQueryResult &result) {
-	D_ASSERT(IsActiveResult(lock, &result));
-	D_ASSERT(active_query->executor);
-	return FetchInternal(lock, *active_query->executor, result);
-}
-
-unique_ptr<DataChunk> ClientContext::FetchInternal(ClientContextLock &lock, Executor &executor,
-                                                   BaseQueryResult &result) {
-	bool invalidate_query = true;
-	try {
-		// fetch the chunk and return it
-		auto chunk = executor.FetchChunk();
-		if (!chunk || chunk->size() == 0) {
-			CleanupInternal(lock, &result);
-		}
-		return chunk;
-	} catch (StandardException &ex) {
-		// standard exceptions do not invalidate the current transaction
-		result.error = ex.what();
-		invalidate_query = false;
-	} catch (std::exception &ex) {
-		result.error = ex.what();
-	} catch (...) { // LCOV_EXCL_START
-		result.error = "Unhandled exception in FetchInternal";
-	} // LCOV_EXCL_STOP
-	result.success = false;
-	CleanupInternal(lock, &result, invalidate_query);
-	return nullptr;
-}
-
-void ClientContext::BeginTransactionInternal(ClientContextLock &lock, bool requires_valid_transaction) {
-	// check if we are on AutoCommit. In this case we should start a transaction
-	D_ASSERT(!active_query);
-	if (requires_valid_transaction && transaction.HasActiveTransaction() &&
-	    transaction.ActiveTransaction().IsInvalidated()) {
-		throw Exception("Failed: transaction has been invalidated!");
-	}
-	active_query = make_unique<ActiveQueryContext>();
-	if (transaction.IsAutoCommit()) {
-		transaction.BeginTransaction();
-	}
-}
-
-void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &query) {
-	BeginTransactionInternal(lock, false);
-	LogQueryInternal(lock, query);
-	active_query->query = query;
-	query_progress = -1;
-	ActiveTransaction().active_query = db->GetTransactionManager().GetQueryNumber();
-}
-
-string ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction) {
-	client_data->profiler->EndQuery();
-
-	D_ASSERT(active_query.get());
-	string error;
-	try {
-		if (transaction.HasActiveTransaction()) {
-			// Move the query profiler into the history
-			auto &prev_profilers = client_data->query_profiler_history->GetPrevProfilers();
-			prev_profilers.emplace_back(transaction.ActiveTransaction().active_query, move(client_data->profiler));
-			// Reinitialize the query profiler
-			client_data->profiler = make_shared<QueryProfiler>(*this);
-			// Propagate settings of the saved query into the new profiler.
-			client_data->profiler->Propagate(*prev_profilers.back().second);
-			if (prev_profilers.size() >= client_data->query_profiler_history->GetPrevProfilersSize()) {
-				prev_profilers.pop_front();
-			}
-
-			ActiveTransaction().active_query = MAXIMUM_QUERY_ID;
-			if (transaction.IsAutoCommit()) {
-				if (success) {
-					transaction.Commit();
-				} else {
-					transaction.Rollback();
-				}
-			} else if (invalidate_transaction) {
-				D_ASSERT(!success);
-				ActiveTransaction().Invalidate();
-			}
-		}
-	} catch (std::exception &ex) {
-		error = ex.what();
-	} catch (...) { // LCOV_EXCL_START
-		error = "Unhandled exception!";
-	} // LCOV_EXCL_STOP
-	active_query.reset();
-	query_progress = -1;
-	return error;
-}
-
-void ClientContext::CleanupInternal(ClientContextLock &lock, BaseQueryResult *result, bool invalidate_transaction) {
-	if (!active_query) {
-		// no query currently active
-		return;
-	}
-	if (active_query->executor) {
-		active_query->executor->CancelTasks();
-	}
-	active_query->progress_bar.reset();
-
-	auto error = EndQueryInternal(lock, result ? result->success : false, invalidate_transaction);
-	if (result && result->success) {
-		// if an error occurred while committing report it in the result
-		result->error = error;
-		result->success = error.empty();
-	}
-	D_ASSERT(!active_query);
-}
-
-Executor &ClientContext::GetExecutor() {
-	D_ASSERT(active_query);
-	D_ASSERT(active_query->executor);
-	return *active_query->executor;
-}
-
-const string &ClientContext::GetCurrentQuery() {
-	D_ASSERT(active_query);
-	return active_query->query;
-}
-
-unique_ptr<QueryResult> ClientContext::FetchResultInternal(ClientContextLock &lock, PendingQueryResult &pending) {
-	D_ASSERT(active_query);
-	D_ASSERT(active_query->open_result == &pending);
-	D_ASSERT(active_query->prepared);
-	auto &executor = GetExecutor();
-	auto &prepared = *active_query->prepared;
-	bool create_stream_result = prepared.properties.allow_stream_result && pending.allow_stream_result;
-	if (create_stream_result) {
-		D_ASSERT(!executor.HasResultCollector());
-		active_query->progress_bar.reset();
-		query_progress = -1;
-
-		// successfully compiled SELECT clause, and it is the last statement
-		// return a StreamQueryResult so the client can call Fetch() on it and stream the result
-		auto stream_result = make_unique<StreamQueryResult>(pending.statement_type, pending.properties,
-		                                                    shared_from_this(), pending.types, pending.names);
-		active_query->open_result = stream_result.get();
-		return move(stream_result);
-	}
-	unique_ptr<QueryResult> result;
-	if (executor.HasResultCollector()) {
-		// we have a result collector - fetch the result directly from the result collector
-		result = executor.GetResult();
-		CleanupInternal(lock, result.get(), false);
-	} else {
-		// no result collector - create a materialized result by continuously fetching
-		auto materialized_result = make_unique<MaterializedQueryResult>(
-		    pending.statement_type, pending.properties, pending.types, pending.names, shared_from_this());
-		while (true) {
-			auto chunk = FetchInternal(lock, GetExecutor(), *materialized_result);
-			if (!chunk || chunk->size() == 0) {
-				break;
-			}
-#ifdef DEBUG
-			for (idx_t i = 0; i < chunk->ColumnCount(); i++) {
-				if (pending.types[i].id() == LogicalTypeId::VARCHAR) {
-					chunk->data[i].UTFVerify(chunk->size());
-				}
-			}
-#endif
-			materialized_result->collection.Append(*chunk);
-		}
-		result = move(materialized_result);
-	}
-	return result;
-}
-
-shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query,
-                                                                         unique_ptr<SQLStatement> statement,
-                                                                         vector<Value> *values) {
-	StatementType statement_type = statement->type;
-	auto result = make_shared<PreparedStatementData>(statement_type);
-
-	auto &profiler = QueryProfiler::Get(*this);
-	profiler.StartPhase("planner");
-	Planner planner(*this);
-	if (values) {
-		for (auto &value : *values) {
-			planner.parameter_types.push_back(value.type());
-		}
-	}
-	planner.CreatePlan(move(statement));
-	D_ASSERT(planner.plan);
-	profiler.EndPhase();
-
-	auto plan = move(planner.plan);
-#ifdef DEBUG
-	plan->Verify();
-#endif
-	// extract the result column names from the plan
-	result->properties = planner.properties;
-	result->names = planner.names;
-	result->types = planner.types;
-	result->value_map = move(planner.value_map);
-	result->catalog_version = Transaction::GetTransaction(*this).catalog_version;
-
-	if (config.enable_optimizer) {
-		profiler.StartPhase("optimizer");
-		Optimizer optimizer(*planner.binder, *this);
-		plan = optimizer.Optimize(move(plan));
-		D_ASSERT(plan);
-		profiler.EndPhase();
-
-#ifdef DEBUG
-		plan->Verify();
-#endif
-	}
-
-	profiler.StartPhase("physical_planner");
-	// now convert logical query plan into a physical query plan
-	PhysicalPlanGenerator physical_planner(*this);
-	auto physical_plan = physical_planner.CreatePlan(move(plan));
-	profiler.EndPhase();
-
-#ifdef DEBUG
-	D_ASSERT(!physical_plan->ToString().empty());
-#endif
-	result->plan = move(physical_plan);
-	return result;
-}
-
-double ClientContext::GetProgress() {
-	return query_progress.load();
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientContextLock &lock,
-                                                                       shared_ptr<PreparedStatementData> statement_p,
-                                                                       PendingQueryParameters parameters) {
-	D_ASSERT(active_query);
-	auto &statement = *statement_p;
-	if (ActiveTransaction().IsInvalidated() && statement.properties.requires_valid_transaction) {
-		throw Exception("Current transaction is aborted (please ROLLBACK)");
-	}
-	auto &db_config = DBConfig::GetConfig(*this);
-	if (db_config.access_mode == AccessMode::READ_ONLY && !statement.properties.read_only) {
-		throw Exception(StringUtil::Format("Cannot execute statement of type \"%s\" in read-only mode!",
-		                                   StatementTypeToString(statement.statement_type)));
-	}
-
-	// bind the bound values before execution
-	statement.Bind(parameters.parameters ? *parameters.parameters : vector<Value>());
-
-	active_query->executor = make_unique<Executor>(*this);
-	auto &executor = *active_query->executor;
-	if (config.enable_progress_bar) {
-		active_query->progress_bar = make_unique<ProgressBar>(executor, config.wait_time, config.print_progress_bar);
-		active_query->progress_bar->Start();
-		query_progress = 0;
-	}
-	auto stream_result = parameters.allow_stream_result && statement.properties.allow_stream_result;
-	if (!stream_result && statement.properties.return_type == StatementReturnType::QUERY_RESULT) {
-		unique_ptr<PhysicalResultCollector> collector;
-		auto &config = ClientConfig::GetConfig(*this);
-		auto get_method =
-		    config.result_collector ? config.result_collector : PhysicalResultCollector::GetResultCollector;
-		collector = get_method(*this, statement);
-		D_ASSERT(collector->type == PhysicalOperatorType::RESULT_COLLECTOR);
-		executor.Initialize(move(collector));
-	} else {
-		executor.Initialize(statement.plan.get());
-	}
-	auto types = executor.GetTypes();
-	D_ASSERT(types == statement.types);
-	D_ASSERT(!active_query->open_result);
-
-	auto pending_result = make_unique<PendingQueryResult>(shared_from_this(), *statement_p, move(types), stream_result);
-	active_query->prepared = move(statement_p);
-	active_query->open_result = pending_result.get();
-	return pending_result;
-}
-
-PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &lock, PendingQueryResult &result) {
-	D_ASSERT(active_query);
-	D_ASSERT(active_query->open_result == &result);
-	try {
-		auto result = active_query->executor->ExecuteTask();
-		if (active_query->progress_bar) {
-			active_query->progress_bar->Update(result == PendingExecutionResult::RESULT_READY);
-			query_progress = active_query->progress_bar->GetCurrentPercentage();
-		}
-		return result;
-	} catch (std::exception &ex) {
-		result.error = ex.what();
-	} catch (...) { // LCOV_EXCL_START
-		result.error = "Unhandled exception in ExecuteTaskInternal";
-	} // LCOV_EXCL_STOP
-	EndQueryInternal(lock, false, true);
-	result.success = false;
-	return PendingExecutionResult::EXECUTION_ERROR;
-}
-
-void ClientContext::InitialCleanup(ClientContextLock &lock) {
-	//! Cleanup any open results and reset the interrupted flag
-	CleanupInternal(lock);
-	interrupted = false;
-}
-
-vector<unique_ptr<SQLStatement>> ClientContext::ParseStatements(const string &query) {
-	auto lock = LockContext();
-	return ParseStatementsInternal(*lock, query);
-}
-
-vector<unique_ptr<SQLStatement>> ClientContext::ParseStatementsInternal(ClientContextLock &lock, const string &query) {
-	Parser parser(GetParserOptions());
-	parser.ParseQuery(query);
-
-	PragmaHandler handler(*this);
-	handler.HandlePragmaStatements(lock, parser.statements);
-
-	return move(parser.statements);
-}
-
-void ClientContext::HandlePragmaStatements(vector<unique_ptr<SQLStatement>> &statements) {
-	auto lock = LockContext();
-
-	PragmaHandler handler(*this);
-	handler.HandlePragmaStatements(*lock, statements);
-}
-
-unique_ptr<LogicalOperator> ClientContext::ExtractPlan(const string &query) {
-	auto lock = LockContext();
-
-	auto statements = ParseStatementsInternal(*lock, query);
-	if (statements.size() != 1) {
-		throw Exception("ExtractPlan can only prepare a single statement");
-	}
-
-	unique_ptr<LogicalOperator> plan;
-	RunFunctionInTransactionInternal(*lock, [&]() {
-		Planner planner(*this);
-		planner.CreatePlan(move(statements[0]));
-		D_ASSERT(planner.plan);
-
-		plan = move(planner.plan);
-
-		if (config.enable_optimizer) {
-			Optimizer optimizer(*planner.binder, *this);
-			plan = optimizer.Optimize(move(plan));
-		}
-
-		ColumnBindingResolver resolver;
-		resolver.VisitOperator(*plan);
-
-		plan->ResolveOperatorTypes();
-	});
-	return plan;
-}
-
-unique_ptr<PreparedStatement> ClientContext::PrepareInternal(ClientContextLock &lock,
-                                                             unique_ptr<SQLStatement> statement) {
-	auto n_param = statement->n_param;
-	auto statement_query = statement->query;
-	shared_ptr<PreparedStatementData> prepared_data;
-	auto unbound_statement = statement->Copy();
-	RunFunctionInTransactionInternal(
-	    lock, [&]() { prepared_data = CreatePreparedStatement(lock, statement_query, move(statement)); }, false);
-	prepared_data->unbound_statement = move(unbound_statement);
-	return make_unique<PreparedStatement>(shared_from_this(), move(prepared_data), move(statement_query), n_param);
-}
-
-unique_ptr<PreparedStatement> ClientContext::Prepare(unique_ptr<SQLStatement> statement) {
-	auto lock = LockContext();
-	// prepare the query
-	try {
-		InitialCleanup(*lock);
-		return PrepareInternal(*lock, move(statement));
-	} catch (std::exception &ex) {
-		return make_unique<PreparedStatement>(ex.what());
-	}
-}
-
-unique_ptr<PreparedStatement> ClientContext::Prepare(const string &query) {
-	auto lock = LockContext();
-	// prepare the query
-	try {
-		InitialCleanup(*lock);
-
-		// first parse the query
-		auto statements = ParseStatementsInternal(*lock, query);
-		if (statements.empty()) {
-			throw Exception("No statement to prepare!");
-		}
-		if (statements.size() > 1) {
-			throw Exception("Cannot prepare multiple statements at once!");
-		}
-		return PrepareInternal(*lock, move(statements[0]));
-	} catch (std::exception &ex) {
-		return make_unique<PreparedStatement>(ex.what());
-	}
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
-                                                                           shared_ptr<PreparedStatementData> &prepared,
-                                                                           PendingQueryParameters parameters) {
-	try {
-		InitialCleanup(lock);
-	} catch (std::exception &ex) {
-		return make_unique<PendingQueryResult>(ex.what());
-	}
-	return PendingStatementOrPreparedStatementInternal(lock, query, nullptr, prepared, parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query,
-                                                           shared_ptr<PreparedStatementData> &prepared,
-                                                           PendingQueryParameters parameters) {
-	auto lock = LockContext();
-	return PendingQueryPreparedInternal(*lock, query, prepared, parameters);
-}
-
-unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-                                               PendingQueryParameters parameters) {
-	auto lock = LockContext();
-	auto pending = PendingQueryPreparedInternal(*lock, query, prepared, parameters);
-	if (!pending->success) {
-		return make_unique<MaterializedQueryResult>(pending->error);
-	}
-	return pending->ExecuteInternal(*lock);
-}
-
-unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-                                               vector<Value> &values, bool allow_stream_result) {
-	PendingQueryParameters parameters;
-	parameters.parameters = &values;
-	parameters.allow_stream_result = allow_stream_result;
-	return Execute(query, prepared, parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientContextLock &lock, const string &query,
-                                                                       unique_ptr<SQLStatement> statement,
-                                                                       PendingQueryParameters parameters) {
-	// prepare the query for execution
-	auto prepared = CreatePreparedStatement(lock, query, move(statement));
-	// execute the prepared statement
-	return PendingPreparedStatement(lock, move(prepared), parameters);
-}
-
-unique_ptr<QueryResult> ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query,
-                                                            unique_ptr<SQLStatement> statement,
-                                                            bool allow_stream_result, bool verify) {
-	PendingQueryParameters parameters;
-	parameters.allow_stream_result = allow_stream_result;
-	auto pending = PendingQueryInternal(lock, move(statement), parameters, verify);
-	if (!pending->success) {
-		return make_unique<MaterializedQueryResult>(move(pending->error));
-	}
-	return ExecutePendingQueryInternal(lock, *pending);
-}
-
-bool ClientContext::IsActiveResult(ClientContextLock &lock, BaseQueryResult *result) {
-	if (!active_query) {
-		return false;
-	}
-	return active_query->open_result == result;
-}
-
-static bool IsExplainAnalyze(SQLStatement *statement) {
-	if (!statement) {
-		return false;
-	}
-	if (statement->type != StatementType::EXPLAIN_STATEMENT) {
-		return false;
-	}
-	auto &explain = (ExplainStatement &)*statement;
-	return explain.explain_type == ExplainType::EXPLAIN_ANALYZE;
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatementInternal(
-    ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-    shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters) {
-	// check if we are on AutoCommit. In this case we should start a transaction.
-	if (statement && config.query_verification_enabled) {
-		// query verification is enabled
-		// create a copy of the statement, and use the copy
-		// this way we verify that the copy correctly copies all properties
-		auto copied_statement = statement->Copy();
-		switch (statement->type) {
-		case StatementType::SELECT_STATEMENT: {
-			// in case this is a select query, we verify the original statement
-			string error;
-			try {
-				error = VerifyQuery(lock, query, move(statement));
-			} catch (std::exception &ex) {
-				error = ex.what();
-			}
-			if (!error.empty()) {
-				// error in verifying query
-				return make_unique<PendingQueryResult>(error);
-			}
-			statement = move(copied_statement);
-			break;
-		}
-		case StatementType::INSERT_STATEMENT:
-		case StatementType::DELETE_STATEMENT:
-		case StatementType::UPDATE_STATEMENT: {
-			auto sql = statement->ToString();
-			Parser parser;
-			parser.ParseQuery(sql);
-			statement = move(parser.statements[0]);
-			break;
-		}
-		default:
-			statement = move(copied_statement);
-			break;
-		}
-	}
-	return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatement(
-    ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-    shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters) {
-	unique_ptr<PendingQueryResult> result;
-
-	BeginQueryInternal(lock, query);
-	// start the profiler
-	auto &profiler = QueryProfiler::Get(*this);
-	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
-	bool invalidate_query = true;
-	try {
-		if (statement) {
-			result = PendingStatementInternal(lock, query, move(statement), parameters);
-		} else {
-			auto &catalog = Catalog::GetCatalog(*this);
-			if (prepared->unbound_statement && (catalog.GetCatalogVersion() != prepared->catalog_version ||
-			                                    !prepared->properties.bound_all_parameters)) {
-				// catalog was modified: rebind the statement before execution
-				auto new_prepared =
-				    CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), parameters.parameters);
-				if (prepared->types != new_prepared->types && prepared->properties.bound_all_parameters) {
-					throw BinderException("Rebinding statement after catalog change resulted in change of types");
-				}
-				D_ASSERT(new_prepared->properties.bound_all_parameters);
-				new_prepared->unbound_statement = move(prepared->unbound_statement);
-				prepared = move(new_prepared);
-				prepared->properties.bound_all_parameters = false;
-			}
-			result = PendingPreparedStatement(lock, prepared, parameters);
-		}
-	} catch (StandardException &ex) {
-		// standard exceptions do not invalidate the current transaction
-		result = make_unique<PendingQueryResult>(ex.what());
-		invalidate_query = false;
-	} catch (std::exception &ex) {
-		// other types of exceptions do invalidate the current transaction
-		result = make_unique<PendingQueryResult>(ex.what());
-	}
-	if (!result->success) {
-		// query failed: abort now
-		EndQueryInternal(lock, false, invalidate_query);
-		return result;
-	}
-	D_ASSERT(active_query->open_result == result.get());
-	return result;
-}
-
-void ClientContext::LogQueryInternal(ClientContextLock &, const string &query) {
-	if (!client_data->log_query_writer) {
-#ifdef DUCKDB_FORCE_QUERY_LOG
-		try {
-			string log_path(DUCKDB_FORCE_QUERY_LOG);
-			client_data->log_query_writer =
-			    make_unique<BufferedFileWriter>(FileSystem::GetFileSystem(*this), log_path,
-			                                    BufferedFileWriter::DEFAULT_OPEN_FLAGS, client_data->file_opener.get());
-		} catch (...) {
-			return;
-		}
-#else
-		return;
-#endif
-	}
-	// log query path is set: log the query
-	client_data->log_query_writer->WriteData((const_data_ptr_t)query.c_str(), query.size());
-	client_data->log_query_writer->WriteData((const_data_ptr_t) "\n", 1);
-	client_data->log_query_writer->Flush();
-	client_data->log_query_writer->Sync();
-}
-
-unique_ptr<QueryResult> ClientContext::Query(unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	auto pending_query = PendingQuery(move(statement), allow_stream_result);
-	if (!pending_query->success) {
-		return make_unique<MaterializedQueryResult>(pending_query->error);
-	}
-	return pending_query->Execute();
-}
-
-unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_stream_result) {
-	auto lock = LockContext();
-
-	string error;
-	vector<unique_ptr<SQLStatement>> statements;
-	if (!ParseStatements(*lock, query, statements, error)) {
-		return make_unique<MaterializedQueryResult>(move(error));
-	}
-	if (statements.empty()) {
-		// no statements, return empty successful result
-		StatementProperties properties;
-		vector<LogicalType> types;
-		vector<string> names;
-		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT, properties, move(types),
-		                                            move(names), shared_from_this());
-	}
-
-	unique_ptr<QueryResult> result;
-	QueryResult *last_result = nullptr;
-	for (idx_t i = 0; i < statements.size(); i++) {
-		auto &statement = statements[i];
-		bool is_last_statement = i + 1 == statements.size();
-		PendingQueryParameters parameters;
-		parameters.allow_stream_result = allow_stream_result && is_last_statement;
-		auto pending_query = PendingQueryInternal(*lock, move(statement), parameters);
-		unique_ptr<QueryResult> current_result;
-		if (!pending_query->success) {
-			current_result = make_unique<MaterializedQueryResult>(pending_query->error);
-		} else {
-			current_result = ExecutePendingQueryInternal(*lock, *pending_query);
-		}
-		// now append the result to the list of results
-		if (!last_result) {
-			// first result of the query
-			result = move(current_result);
-			last_result = result.get();
-		} else {
-			// later results; attach to the result chain
-			last_result->next = move(current_result);
-			last_result = last_result->next.get();
-		}
-	}
-	return result;
-}
-
-bool ClientContext::ParseStatements(ClientContextLock &lock, const string &query,
-                                    vector<unique_ptr<SQLStatement>> &result, string &error) {
-	try {
-		InitialCleanup(lock);
-		// parse the query and transform it into a set of statements
-		result = ParseStatementsInternal(lock, query);
-		return true;
-	} catch (std::exception &ex) {
-		error = ex.what();
-		return false;
-	}
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query, bool allow_stream_result) {
-	auto lock = LockContext();
-
-	string error;
-	vector<unique_ptr<SQLStatement>> statements;
-	if (!ParseStatements(*lock, query, statements, error)) {
-		return make_unique<PendingQueryResult>(move(error));
-	}
-	if (statements.size() != 1) {
-		return make_unique<PendingQueryResult>("PendingQuery can only take a single statement");
-	}
-	PendingQueryParameters parameters;
-	parameters.allow_stream_result = allow_stream_result;
-	return PendingQueryInternal(*lock, move(statements[0]), parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStatement> statement,
-                                                           bool allow_stream_result) {
-	auto lock = LockContext();
-	PendingQueryParameters parameters;
-	parameters.allow_stream_result = allow_stream_result;
-	return PendingQueryInternal(*lock, move(statement), parameters);
-}
-
-unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
-                                                                   unique_ptr<SQLStatement> statement,
-                                                                   PendingQueryParameters parameters, bool verify) {
-	auto query = statement->query;
-	shared_ptr<PreparedStatementData> prepared;
-	if (verify) {
-		return PendingStatementOrPreparedStatementInternal(lock, query, move(statement), prepared, parameters);
-	} else {
-		return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, parameters);
-	}
-}
-
-unique_ptr<QueryResult> ClientContext::ExecutePendingQueryInternal(ClientContextLock &lock, PendingQueryResult &query) {
-	return query.ExecuteInternal(lock);
-}
-
-void ClientContext::Interrupt() {
-	interrupted = true;
-}
-
-void ClientContext::EnableProfiling() {
-	auto lock = LockContext();
-	auto &config = ClientConfig::GetConfig(*this);
-	config.enable_profiler = true;
-	config.emit_profiler_output = true;
-}
-
-void ClientContext::DisableProfiling() {
-	auto lock = LockContext();
-	auto &config = ClientConfig::GetConfig(*this);
-	config.enable_profiler = false;
-}
-
-struct VerifyStatement {
-	VerifyStatement(unique_ptr<SelectStatement> statement_p, string statement_name_p, bool require_equality = true,
-	                bool disable_optimizer = false)
-	    : statement(move(statement_p)), statement_name(move(statement_name_p)), require_equality(require_equality),
-	      disable_optimizer(disable_optimizer), select_list(statement->node->GetSelectList()) {
-	}
-
-	unique_ptr<SelectStatement> statement;
-	string statement_name;
-	bool require_equality;
-	bool disable_optimizer;
-	const vector<unique_ptr<ParsedExpression>> &select_list;
-};
-
-string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement) {
-	D_ASSERT(statement->type == StatementType::SELECT_STATEMENT);
-	// aggressive query verification
-
-	// the purpose of this function is to test correctness of otherwise hard to test features:
-	// Copy() of statements and expressions
-	// Serialize()/Deserialize() of expressions
-	// Hash() of expressions
-	// Equality() of statements and expressions
-	// ToString() of statements and expressions
-	// Correctness of plans both with and without optimizers
-
-	vector<VerifyStatement> verify_statements;
-
-	// copy the statement
-	auto select_stmt = (SelectStatement *)statement.get();
-	auto copied_stmt = unique_ptr_cast<SQLStatement, SelectStatement>(select_stmt->Copy());
-	auto unoptimized_stmt = unique_ptr_cast<SQLStatement, SelectStatement>(select_stmt->Copy());
-
-	BufferedSerializer serializer;
-	select_stmt->Serialize(serializer);
-	BufferedDeserializer source(serializer);
-	auto deserialized_stmt = SelectStatement::Deserialize(source);
-
-	auto query_str = select_stmt->ToString();
-	Parser parser;
-	parser.ParseQuery(query_str);
-	D_ASSERT(parser.statements.size() == 1);
-	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
-	auto parsed_statement = move(parser.statements[0]);
-
-	verify_statements.emplace_back(unique_ptr_cast<SQLStatement, SelectStatement>(move(statement)),
-	                               "Original statement");
-	verify_statements.emplace_back(move(copied_stmt), "Copied statement");
-	verify_statements.emplace_back(move(deserialized_stmt), "Deserialized statement");
-	verify_statements.emplace_back(unique_ptr_cast<SQLStatement, SelectStatement>(move(parsed_statement)),
-	                               "Parsed statement", false);
-	verify_statements.emplace_back(unique_ptr_cast<SQLStatement, SelectStatement>(move(unoptimized_stmt)),
-	                               "Unoptimized", true, true);
-
-	// all the statements should be equal
-	for (idx_t i = 1; i < verify_statements.size(); i++) {
-		if (!verify_statements[i].require_equality) {
-			continue;
-		}
-		D_ASSERT(verify_statements[i].statement->Equals(verify_statements[0].statement.get()));
-	}
-
-	// now perform checking on the expressions
-#ifdef DEBUG
-	for (idx_t i = 1; i < verify_statements.size(); i++) {
-		D_ASSERT(verify_statements[i].select_list.size() == verify_statements[0].select_list.size());
-	}
-	auto expr_count = verify_statements[0].select_list.size();
-	auto &orig_expr_list = verify_statements[0].select_list;
-	for (idx_t i = 0; i < expr_count; i++) {
-		// run the ToString, to verify that it doesn't crash
-		auto str = orig_expr_list[i]->ToString();
-		for (idx_t v_idx = 0; v_idx < verify_statements.size(); v_idx++) {
-			if (!verify_statements[v_idx].require_equality && orig_expr_list[i]->HasSubquery()) {
-				continue;
-			}
-			// check that the expressions are equivalent
-			D_ASSERT(orig_expr_list[i]->Equals(verify_statements[v_idx].select_list[i].get()));
-			// check that the hashes are equivalent too
-			D_ASSERT(orig_expr_list[i]->Hash() == verify_statements[v_idx].select_list[i]->Hash());
-
-			verify_statements[v_idx].select_list[i]->Verify();
-		}
-		D_ASSERT(!orig_expr_list[i]->Equals(nullptr));
-
-		if (orig_expr_list[i]->HasSubquery()) {
-			continue;
-		}
-		// ToString round trip
-		auto parsed_list = Parser::ParseExpressionList(str);
-		D_ASSERT(parsed_list.size() == 1);
-		D_ASSERT(parsed_list[0]->Equals(orig_expr_list[i].get()));
-	}
-	// perform additional checking within the expressions
-	for (idx_t outer_idx = 0; outer_idx < orig_expr_list.size(); outer_idx++) {
-		auto hash = orig_expr_list[outer_idx]->Hash();
-		for (idx_t inner_idx = 0; inner_idx < orig_expr_list.size(); inner_idx++) {
-			auto hash2 = orig_expr_list[inner_idx]->Hash();
-			if (hash != hash2) {
-				// if the hashes are not equivalent, the expressions should not be equivalent
-				D_ASSERT(!orig_expr_list[outer_idx]->Equals(orig_expr_list[inner_idx].get()));
-			}
-		}
-	}
-#endif
-
-	// disable profiling if it is enabled
-	auto &config = ClientConfig::GetConfig(*this);
-	bool profiling_is_enabled = config.enable_profiler;
-	if (profiling_is_enabled) {
-		config.enable_profiler = false;
-	}
-
-	// see below
-	auto statement_copy_for_explain = select_stmt->Copy();
-
-	// execute the original statement
-	auto optimizer_enabled = config.enable_optimizer;
-	vector<unique_ptr<MaterializedQueryResult>> results;
-	for (idx_t i = 0; i < verify_statements.size(); i++) {
-		interrupted = false;
-		config.enable_optimizer = !verify_statements[i].disable_optimizer;
-		try {
-			auto result = RunStatementInternal(lock, query, move(verify_statements[i].statement), false, false);
-			results.push_back(unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result)));
-		} catch (std::exception &ex) {
-			results.push_back(make_unique<MaterializedQueryResult>(ex.what()));
-		}
-		interrupted = false;
-	}
-	config.enable_optimizer = optimizer_enabled;
-
-	// check explain, only if q does not already contain EXPLAIN
-	if (results[0]->success) {
-		auto explain_q = "EXPLAIN " + query;
-		auto explain_stmt = make_unique<ExplainStatement>(move(statement_copy_for_explain));
-		try {
-			RunStatementInternal(lock, explain_q, move(explain_stmt), false, false);
-		} catch (std::exception &ex) { // LCOV_EXCL_START
-			interrupted = false;
-			return "EXPLAIN failed but query did not (" + string(ex.what()) + ")";
-		} // LCOV_EXCL_STOP
-	}
-
-	if (profiling_is_enabled) {
-		config.enable_profiler = true;
-	}
-
-	// now compare the results
-	// the results of all runs should be identical
-	for (idx_t i = 1; i < results.size(); i++) {
-		auto name = verify_statements[i].statement_name;
-		if (results[0]->success != results[i]->success) { // LCOV_EXCL_START
-			string result = name + " differs from original result!\n";
-			result += "Original Result:\n" + results[0]->ToString();
-			result += name + ":\n" + results[i]->ToString();
-			return result;
-		}                                                             // LCOV_EXCL_STOP
-		if (!results[0]->collection.Equals(results[i]->collection)) { // LCOV_EXCL_START
-			string result = name + " differs from original result!\n";
-			result += "Original Result:\n" + results[0]->ToString();
-			result += name + ":\n" + results[i]->ToString();
-			return result;
-		} // LCOV_EXCL_STOP
-	}
-
-	return "";
-}
-
-bool ClientContext::UpdateFunctionInfoFromEntry(ScalarFunctionCatalogEntry *existing_function,
-                                                CreateScalarFunctionInfo *new_info) {
-	if (new_info->functions.empty()) {
-		throw InternalException("Registering function without scalar function definitions!");
-	}
-	bool need_rewrite_entry = false;
-	idx_t size_new_func = new_info->functions.size();
-	for (idx_t exist_idx = 0; exist_idx < existing_function->functions.size(); ++exist_idx) {
-		bool can_add = true;
-		for (idx_t new_idx = 0; new_idx < size_new_func; ++new_idx) {
-			if (new_info->functions[new_idx].Equal(existing_function->functions[exist_idx])) {
-				can_add = false;
-				break;
-			}
-		}
-		if (can_add) {
-			new_info->functions.push_back(existing_function->functions[exist_idx]);
-			need_rewrite_entry = true;
-		}
-	}
-	return need_rewrite_entry;
-}
-
-void ClientContext::RegisterFunction(CreateFunctionInfo *info) {
-	RunFunctionInTransaction([&]() {
-		auto &catalog = Catalog::GetCatalog(*this);
-		auto existing_function = (ScalarFunctionCatalogEntry *)catalog.GetEntry(
-		    *this, CatalogType::SCALAR_FUNCTION_ENTRY, info->schema, info->name, true);
-		if (existing_function) {
-			if (UpdateFunctionInfoFromEntry(existing_function, (CreateScalarFunctionInfo *)info)) {
-				// function info was updated from catalog entry, rewrite is needed
-				info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
-			}
-		}
-		// create function
-		catalog.CreateFunction(*this, info);
-	});
-}
-
-void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, const std::function<void(void)> &fun,
-                                                     bool requires_valid_transaction) {
-	if (requires_valid_transaction && transaction.HasActiveTransaction() &&
-	    transaction.ActiveTransaction().IsInvalidated()) {
-		throw Exception("Failed: transaction has been invalidated!");
-	}
-	// check if we are on AutoCommit. In this case we should start a transaction
-	bool require_new_transaction = transaction.IsAutoCommit() && !transaction.HasActiveTransaction();
-	if (require_new_transaction) {
-		D_ASSERT(!active_query);
-		transaction.BeginTransaction();
-	}
-	try {
-		fun();
-	} catch (StandardException &ex) {
-		if (require_new_transaction) {
-			transaction.Rollback();
-		}
-		throw;
-	} catch (std::exception &ex) {
-		if (require_new_transaction) {
-			transaction.Rollback();
-		} else {
-			ActiveTransaction().Invalidate();
-		}
-		throw;
-	}
-	if (require_new_transaction) {
-		transaction.Commit();
-	}
-}
-
-void ClientContext::RunFunctionInTransaction(const std::function<void(void)> &fun, bool requires_valid_transaction) {
-	auto lock = LockContext();
-	RunFunctionInTransactionInternal(*lock, fun, requires_valid_transaction);
-}
-
-unique_ptr<TableDescription> ClientContext::TableInfo(const string &schema_name, const string &table_name) {
-	unique_ptr<TableDescription> result;
-	RunFunctionInTransaction([&]() {
-		// obtain the table info
-		auto &catalog = Catalog::GetCatalog(*this);
-		auto table = catalog.GetEntry<TableCatalogEntry>(*this, schema_name, table_name, true);
-		if (!table) {
-			return;
-		}
-		// write the table info to the result
-		result = make_unique<TableDescription>();
-		result->schema = schema_name;
-		result->table = table_name;
-		for (auto &column : table->columns) {
-			result->columns.emplace_back(column.Name(), column.Type());
-		}
-	});
-	return result;
-}
-
-void ClientContext::Append(TableDescription &description, ChunkCollection &collection) {
-	RunFunctionInTransaction([&]() {
-		auto &catalog = Catalog::GetCatalog(*this);
-		auto table_entry = catalog.GetEntry<TableCatalogEntry>(*this, description.schema, description.table);
-		// verify that the table columns and types match up
-		if (description.columns.size() != table_entry->columns.size()) {
-			throw Exception("Failed to append: table entry has different number of columns!");
-		}
-		for (idx_t i = 0; i < description.columns.size(); i++) {
-			if (description.columns[i].Type() != table_entry->columns[i].Type()) {
-				throw Exception("Failed to append: table entry has different number of columns!");
-			}
-		}
-		for (auto &chunk : collection.Chunks()) {
-			table_entry->storage->Append(*table_entry, *this, *chunk);
-		}
-	});
-}
-
-void ClientContext::TryBindRelation(Relation &relation, vector<ColumnDefinition> &result_columns) {
-#ifdef DEBUG
-	D_ASSERT(!relation.GetAlias().empty());
-	D_ASSERT(!relation.ToString().empty());
-#endif
-	RunFunctionInTransaction([&]() {
-		// bind the expressions
-		auto binder = Binder::CreateBinder(*this);
-		auto result = relation.Bind(*binder);
-		D_ASSERT(result.names.size() == result.types.size());
-		for (idx_t i = 0; i < result.names.size(); i++) {
-			result_columns.emplace_back(result.names[i], result.types[i]);
-		}
-	});
-}
-
-unordered_set<string> ClientContext::GetTableNames(const string &query) {
-	auto lock = LockContext();
-
-	auto statements = ParseStatementsInternal(*lock, query);
-	if (statements.size() != 1) {
-		throw InvalidInputException("Expected a single statement");
-	}
-
-	unordered_set<string> result;
-	RunFunctionInTransactionInternal(*lock, [&]() {
-		// bind the expressions
-		auto binder = Binder::CreateBinder(*this);
-		binder->SetBindingMode(BindingMode::EXTRACT_NAMES);
-		binder->Bind(*statements[0]);
-		result = binder->GetTableNames();
-	});
-	return result;
-}
-
-unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relation) {
-	auto lock = LockContext();
-	InitialCleanup(*lock);
-
-	string query;
-	if (config.query_verification_enabled) {
-		// run the ToString method of any relation we run, mostly to ensure it doesn't crash
-		relation->ToString();
-		relation->GetAlias();
-		if (relation->IsReadOnly()) {
-			// verify read only statements by running a select statement
-			auto select = make_unique<SelectStatement>();
-			select->node = relation->GetQueryNode();
-			RunStatementInternal(*lock, query, move(select), false);
-		}
-	}
-	auto &expected_columns = relation->Columns();
-	auto relation_stmt = make_unique<RelationStatement>(relation);
-
-	unique_ptr<QueryResult> result;
-	result = RunStatementInternal(*lock, query, move(relation_stmt), false);
-	if (!result->success) {
-		return result;
-	}
-	// verify that the result types and result names of the query match the expected result types/names
-	if (result->types.size() == expected_columns.size()) {
-		bool mismatch = false;
-		for (idx_t i = 0; i < result->types.size(); i++) {
-			if (result->types[i] != expected_columns[i].Type() || result->names[i] != expected_columns[i].Name()) {
-				mismatch = true;
-				break;
-			}
-		}
-		if (!mismatch) {
-			// all is as expected: return the result
-			return result;
-		}
-	}
-	// result mismatch
-	string err_str = "Result mismatch in query!\nExpected the following columns: [";
-	for (idx_t i = 0; i < expected_columns.size(); i++) {
-		if (i > 0) {
-			err_str += ", ";
-		}
-		err_str += expected_columns[i].Name() + " " + expected_columns[i].Type().ToString();
-	}
-	err_str += "]\nBut result contained the following: ";
-	for (idx_t i = 0; i < result->types.size(); i++) {
-		err_str += i == 0 ? "[" : ", ";
-		err_str += result->names[i] + " " + result->types[i].ToString();
-	}
-	err_str += "]";
-	return make_unique<MaterializedQueryResult>(err_str);
-}
-
-bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) {
-	// first check the built-in settings
-	auto &db_config = DBConfig::GetConfig(*this);
-	auto option = db_config.GetOptionByName(key);
-	if (option) {
-		result = option->get_setting(*this);
-		return true;
-	}
-
-	// then check the session values
-	const auto &session_config_map = config.set_variables;
-	const auto &global_config_map = db_config.set_variables;
-
-	auto session_value = session_config_map.find(key);
-	bool found_session_value = session_value != session_config_map.end();
-	auto global_value = global_config_map.find(key);
-	bool found_global_value = global_value != global_config_map.end();
-	if (!found_session_value && !found_global_value) {
-		return false;
-	}
-
-	result = found_session_value ? session_value->second : global_value->second;
-	return true;
-}
-
-ParserOptions ClientContext::GetParserOptions() {
-	ParserOptions options;
-	options.preserve_identifier_case = ClientConfig::GetConfig(*this).preserve_identifier_case;
-	options.max_expression_depth = ClientConfig::GetConfig(*this).max_expression_depth;
-	options.extensions = &DBConfig::GetConfig(*this).parser_extensions;
-	return options;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result) {
-	return context.TryGetCurrentSetting(key, result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-ClientData::ClientData(ClientContext &context) : catalog_search_path(make_unique<CatalogSearchPath>(context)) {
-	profiler = make_shared<QueryProfiler>(context);
-	query_profiler_history = make_unique<QueryProfilerHistory>();
-	temporary_objects = make_unique<SchemaCatalogEntry>(&Catalog::GetCatalog(context), TEMP_SCHEMA, true);
-	random_engine = make_unique<RandomEngine>();
-	file_opener = make_unique<ClientContextFileOpener>(context);
-}
-ClientData::~ClientData() {
-}
-
-ClientData &ClientData::Get(ClientContext &context) {
-	return *context.client_data;
-}
-
-RandomEngine &RandomEngine::Get(ClientContext &context) {
-	return *ClientData::Get(context).random_engine;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-#define DUCKDB_GLOBAL(_PARAM)                                                                                          \
-	{ _PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::GetSetting }
-#define DUCKDB_GLOBAL_ALIAS(_ALIAS, _PARAM)                                                                            \
-	{ _ALIAS, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::GetSetting }
-
-#define DUCKDB_LOCAL(_PARAM)                                                                                           \
-	{ _PARAM::Name, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, _PARAM::GetSetting }
-#define DUCKDB_LOCAL_ALIAS(_ALIAS, _PARAM)                                                                             \
-	{ _ALIAS, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, _PARAM::GetSetting }
-
-#define DUCKDB_GLOBAL_LOCAL(_PARAM)                                                                                    \
-	{ _PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal, _PARAM::GetSetting }
-#define DUCKDB_GLOBAL_LOCAL_ALIAS(_ALIAS, _PARAM)                                                                      \
-	{ _ALIAS, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal, _PARAM::GetSetting }
-#define FINAL_SETTING                                                                                                  \
-	{ nullptr, nullptr, LogicalTypeId::INVALID, nullptr, nullptr, nullptr }
-
-static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting),
-                                                 DUCKDB_GLOBAL(CheckpointThresholdSetting),
-                                                 DUCKDB_GLOBAL(DebugCheckpointAbort),
-                                                 DUCKDB_LOCAL(DebugForceExternal),
-                                                 DUCKDB_LOCAL(DebugForceNoCrossProduct),
-                                                 DUCKDB_GLOBAL(DebugManyFreeListBlocks),
-                                                 DUCKDB_GLOBAL(DebugWindowMode),
-                                                 DUCKDB_GLOBAL_LOCAL(DefaultCollationSetting),
-                                                 DUCKDB_GLOBAL(DefaultOrderSetting),
-                                                 DUCKDB_GLOBAL(DefaultNullOrderSetting),
-                                                 DUCKDB_GLOBAL(DisabledOptimizersSetting),
-                                                 DUCKDB_GLOBAL(EnableExternalAccessSetting),
-                                                 DUCKDB_GLOBAL(EnableObjectCacheSetting),
-                                                 DUCKDB_LOCAL(EnableProfilingSetting),
-                                                 DUCKDB_LOCAL(EnableProgressBarSetting),
-                                                 DUCKDB_LOCAL(ExplainOutputSetting),
-                                                 DUCKDB_GLOBAL(ExternalThreadsSetting),
-                                                 DUCKDB_LOCAL(FileSearchPathSetting),
-                                                 DUCKDB_GLOBAL(ForceCompressionSetting),
-                                                 DUCKDB_LOCAL(LogQueryPathSetting),
-                                                 DUCKDB_LOCAL(MaximumExpressionDepthSetting),
-                                                 DUCKDB_GLOBAL(MaximumMemorySetting),
-                                                 DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
-                                                 DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
-                                                 DUCKDB_LOCAL(PerfectHashThresholdSetting),
-                                                 DUCKDB_LOCAL(PreserveIdentifierCase),
-                                                 DUCKDB_GLOBAL(PreserveInsertionOrder),
-                                                 DUCKDB_LOCAL(ProfilerHistorySize),
-                                                 DUCKDB_LOCAL(ProfileOutputSetting),
-                                                 DUCKDB_LOCAL(ProfilingModeSetting),
-                                                 DUCKDB_LOCAL_ALIAS("profiling_output", ProfileOutputSetting),
-                                                 DUCKDB_LOCAL(ProgressBarTimeSetting),
-                                                 DUCKDB_LOCAL(SchemaSetting),
-                                                 DUCKDB_LOCAL(SearchPathSetting),
-                                                 DUCKDB_GLOBAL(TempDirectorySetting),
-                                                 DUCKDB_GLOBAL(ThreadsSetting),
-                                                 DUCKDB_GLOBAL_ALIAS("wal_autocheckpoint", CheckpointThresholdSetting),
-                                                 DUCKDB_GLOBAL_ALIAS("worker_threads", ThreadsSetting),
-                                                 FINAL_SETTING};
-
-vector<ConfigurationOption> DBConfig::GetOptions() {
-	vector<ConfigurationOption> options;
-	for (idx_t index = 0; internal_options[index].name; index++) {
-		options.push_back(internal_options[index]);
-	}
-	return options;
-}
-
-idx_t DBConfig::GetOptionCount() {
-	idx_t count = 0;
-	for (idx_t index = 0; internal_options[index].name; index++) {
-		count++;
-	}
-	return count;
-}
-
-ConfigurationOption *DBConfig::GetOptionByIndex(idx_t target_index) {
-	for (idx_t index = 0; internal_options[index].name; index++) {
-		if (index == target_index) {
-			return internal_options + index;
-		}
-	}
-	return nullptr;
-}
-
-ConfigurationOption *DBConfig::GetOptionByName(const string &name) {
-	auto lname = StringUtil::Lower(name);
-	for (idx_t index = 0; internal_options[index].name; index++) {
-		D_ASSERT(StringUtil::Lower(internal_options[index].name) == string(internal_options[index].name));
-		if (internal_options[index].name == lname) {
-			return internal_options + index;
-		}
-	}
-	return nullptr;
-}
-
-void DBConfig::SetOption(const ConfigurationOption &option, const Value &value) {
-	if (!option.set_global) {
-		throw InternalException("Could not set option \"%s\" as a global option", option.name);
-	}
-	Value input = value.CastAs(option.parameter_type);
-	option.set_global(nullptr, *this, input);
-}
-
-void DBConfig::AddExtensionOption(string name, string description, LogicalType parameter,
-                                  set_option_callback_t function) {
-	extension_parameters.insert(make_pair(move(name), ExtensionOption(move(description), move(parameter), function)));
-}
-
-idx_t DBConfig::ParseMemoryLimit(const string &arg) {
-	if (arg[0] == '-' || arg == "null" || arg == "none") {
-		return DConstants::INVALID_INDEX;
-	}
-	// split based on the number/non-number
-	idx_t idx = 0;
-	while (StringUtil::CharacterIsSpace(arg[idx])) {
-		idx++;
-	}
-	idx_t num_start = idx;
-	while ((arg[idx] >= '0' && arg[idx] <= '9') || arg[idx] == '.' || arg[idx] == 'e' || arg[idx] == 'E' ||
-	       arg[idx] == '-') {
-		idx++;
-	}
-	if (idx == num_start) {
-		throw ParserException("Memory limit must have a number (e.g. SET memory_limit=1GB");
-	}
-	string number = arg.substr(num_start, idx - num_start);
-
-	// try to parse the number
-	double limit = Cast::Operation<string_t, double>(string_t(number));
-
-	// now parse the memory limit unit (e.g. bytes, gb, etc)
-	while (StringUtil::CharacterIsSpace(arg[idx])) {
-		idx++;
-	}
-	idx_t start = idx;
-	while (idx < arg.size() && !StringUtil::CharacterIsSpace(arg[idx])) {
-		idx++;
-	}
-	if (limit < 0) {
-		// limit < 0, set limit to infinite
-		return (idx_t)-1;
-	}
-	string unit = StringUtil::Lower(arg.substr(start, idx - start));
-	idx_t multiplier;
-	if (unit == "byte" || unit == "bytes" || unit == "b") {
-		multiplier = 1;
-	} else if (unit == "kilobyte" || unit == "kilobytes" || unit == "kb" || unit == "k") {
-		multiplier = 1000LL;
-	} else if (unit == "megabyte" || unit == "megabytes" || unit == "mb" || unit == "m") {
-		multiplier = 1000LL * 1000LL;
-	} else if (unit == "gigabyte" || unit == "gigabytes" || unit == "gb" || unit == "g") {
-		multiplier = 1000LL * 1000LL * 1000LL;
-	} else if (unit == "terabyte" || unit == "terabytes" || unit == "tb" || unit == "t") {
-		multiplier = 1000LL * 1000LL * 1000LL * 1000LL;
-	} else {
-		throw ParserException("Unknown unit for memory_limit: %s (expected: b, mb, gb or tb)", unit);
-	}
-	return (idx_t)multiplier * limit;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-Connection::Connection(DatabaseInstance &database) : context(make_shared<ClientContext>(database.shared_from_this())) {
-	ConnectionManager::Get(database).AddConnection(*context);
-#ifdef DEBUG
-	EnableProfiling();
-	context->config.emit_profiler_output = false;
-#endif
-}
-
-Connection::Connection(DuckDB &database) : Connection(*database.instance) {
-}
-
-Connection::~Connection() {
-	ConnectionManager::Get(*context->db).RemoveConnection(*context);
-}
-
-string Connection::GetProfilingInformation(ProfilerPrintFormat format) {
-	auto &profiler = QueryProfiler::Get(*context);
-	if (format == ProfilerPrintFormat::JSON) {
-		return profiler.ToJSON();
-	} else {
-		return profiler.QueryTreeToString();
-	}
-}
-
-void Connection::Interrupt() {
-	context->Interrupt();
-}
-
-void Connection::EnableProfiling() {
-	context->EnableProfiling();
-}
-
-void Connection::DisableProfiling() {
-	context->DisableProfiling();
-}
-
-void Connection::EnableQueryVerification() {
-	ClientConfig::GetConfig(*context).query_verification_enabled = true;
-}
-
-void Connection::DisableQueryVerification() {
-	ClientConfig::GetConfig(*context).query_verification_enabled = false;
-}
-
-void Connection::ForceParallelism() {
-	ClientConfig::GetConfig(*context).verify_parallelism = true;
-}
-
-unique_ptr<QueryResult> Connection::SendQuery(const string &query) {
-	return context->Query(query, true);
-}
-
-unique_ptr<MaterializedQueryResult> Connection::Query(const string &query) {
-	auto result = context->Query(query, false);
-	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
-}
-
-unique_ptr<MaterializedQueryResult> Connection::Query(unique_ptr<SQLStatement> statement) {
-	auto result = context->Query(move(statement), false);
-	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
-}
-
-unique_ptr<PendingQueryResult> Connection::PendingQuery(const string &query, bool allow_stream_result) {
-	return context->PendingQuery(query, allow_stream_result);
-}
-
-unique_ptr<PendingQueryResult> Connection::PendingQuery(unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	return context->PendingQuery(move(statement), allow_stream_result);
-}
-
-unique_ptr<PreparedStatement> Connection::Prepare(const string &query) {
-	return context->Prepare(query);
-}
-
-unique_ptr<PreparedStatement> Connection::Prepare(unique_ptr<SQLStatement> statement) {
-	return context->Prepare(move(statement));
-}
-
-unique_ptr<QueryResult> Connection::QueryParamsRecursive(const string &query, vector<Value> &values) {
-	auto statement = Prepare(query);
-	if (!statement->success) {
-		return make_unique<MaterializedQueryResult>(statement->error);
-	}
-	return statement->Execute(values, false);
-}
-
-unique_ptr<TableDescription> Connection::TableInfo(const string &table_name) {
-	return TableInfo(DEFAULT_SCHEMA, table_name);
-}
-
-unique_ptr<TableDescription> Connection::TableInfo(const string &schema_name, const string &table_name) {
-	return context->TableInfo(schema_name, table_name);
-}
-
-vector<unique_ptr<SQLStatement>> Connection::ExtractStatements(const string &query) {
-	return context->ParseStatements(query);
-}
-
-unique_ptr<LogicalOperator> Connection::ExtractPlan(const string &query) {
-	return context->ExtractPlan(query);
-}
-
-void Connection::Append(TableDescription &description, DataChunk &chunk) {
-	ChunkCollection collection(*context);
-	collection.Append(chunk);
-	Append(description, collection);
-}
-
-void Connection::Append(TableDescription &description, ChunkCollection &collection) {
-	context->Append(description, collection);
-}
-
-shared_ptr<Relation> Connection::Table(const string &table_name) {
-	return Table(DEFAULT_SCHEMA, table_name);
-}
-
-shared_ptr<Relation> Connection::Table(const string &schema_name, const string &table_name) {
-	auto table_info = TableInfo(schema_name, table_name);
-	if (!table_info) {
-		throw Exception("Table does not exist!");
-	}
-	return make_shared<TableRelation>(context, move(table_info));
-}
-
-shared_ptr<Relation> Connection::View(const string &tname) {
-	return View(DEFAULT_SCHEMA, tname);
-}
-
-shared_ptr<Relation> Connection::View(const string &schema_name, const string &table_name) {
-	return make_shared<ViewRelation>(context, schema_name, table_name);
-}
-
-shared_ptr<Relation> Connection::TableFunction(const string &fname) {
-	vector<Value> values;
-	named_parameter_map_t named_parameters;
-	return TableFunction(fname, values, named_parameters);
-}
-
-shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values,
-                                               const named_parameter_map_t &named_parameters) {
-	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters);
-}
-
-shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values) {
-	return make_shared<TableFunctionRelation>(context, fname, values);
-}
-
-shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values) {
-	vector<string> column_names;
-	return Values(values, column_names);
-}
-
-shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values, const vector<string> &column_names,
-                                        const string &alias) {
-	return make_shared<ValueRelation>(context, values, column_names, alias);
-}
-
-shared_ptr<Relation> Connection::Values(const string &values) {
-	vector<string> column_names;
-	return Values(values, column_names);
-}
-
-shared_ptr<Relation> Connection::Values(const string &values, const vector<string> &column_names, const string &alias) {
-	return make_shared<ValueRelation>(context, values, column_names, alias);
-}
-
-shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
-	BufferedCSVReaderOptions options;
-	options.file_path = csv_file;
-	options.auto_detect = true;
-	BufferedCSVReader reader(*context, options);
-	vector<ColumnDefinition> column_list;
-	for (idx_t i = 0; i < reader.sql_types.size(); i++) {
-		column_list.emplace_back(reader.col_names[i], reader.sql_types[i]);
-	}
-	return make_shared<ReadCSVRelation>(context, csv_file, move(column_list), true);
-}
-
-shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<string> &columns) {
-	// parse columns
-	vector<ColumnDefinition> column_list;
-	for (auto &column : columns) {
-		auto col_list = Parser::ParseColumnList(column, context->GetParserOptions());
-		if (col_list.size() != 1) {
-			throw ParserException("Expected a single column definition");
-		}
-		column_list.push_back(move(col_list[0]));
-	}
-	return make_shared<ReadCSVRelation>(context, csv_file, move(column_list));
-}
-
-unordered_set<string> Connection::GetTableNames(const string &query) {
-	return context->GetTableNames(query);
-}
-
-shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const string &alias, const string &error) {
-	return RelationFromQuery(QueryRelation::ParseStatement(*context, query, error), alias);
-}
-
-shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, const string &alias) {
-	return make_shared<QueryRelation>(context, move(select_stmt), alias);
-}
-
-void Connection::BeginTransaction() {
-	auto result = Query("BEGIN TRANSACTION");
-	if (!result->success) {
-		throw Exception(result->error);
-	}
-}
-
-void Connection::Commit() {
-	auto result = Query("COMMIT");
-	if (!result->success) {
-		throw Exception(result->error);
-	}
-}
-
-void Connection::Rollback() {
-	auto result = Query("ROLLBACK");
-	if (!result->success) {
-		throw Exception(result->error);
-	}
-}
-
-void Connection::SetAutoCommit(bool auto_commit) {
-	context->transaction.SetAutoCommit(auto_commit);
-}
-
-bool Connection::IsAutoCommit() {
-	return context->transaction.IsAutoCommit();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-#ifndef DUCKDB_NO_THREADS
-
-#endif
-
-namespace duckdb {
-
-DBConfig::DBConfig() {
-	compression_functions = make_unique<CompressionFunctionSet>();
-}
-
-DBConfig::~DBConfig() {
-}
-
-DatabaseInstance::DatabaseInstance() {
-}
-
-DatabaseInstance::~DatabaseInstance() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-
-	// shutting down: attempt to checkpoint the database
-	// but only if we are not cleaning up as part of an exception unwind
-	try {
-		auto &storage = StorageManager::GetStorageManager(*this);
-		if (!storage.InMemory()) {
-			auto &config = storage.db.config;
-			if (!config.checkpoint_on_shutdown) {
-				return;
-			}
-			storage.CreateCheckpoint(true);
-		}
-	} catch (...) {
-	}
-}
-
-BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) {
-	return *db.GetStorageManager().buffer_manager;
-}
-
-BlockManager &BlockManager::GetBlockManager(DatabaseInstance &db) {
-	return *db.GetStorageManager().block_manager;
-}
-
-BlockManager &BlockManager::GetBlockManager(ClientContext &context) {
-	return BlockManager::GetBlockManager(DatabaseInstance::GetDatabase(context));
-}
-
-DatabaseInstance &DatabaseInstance::GetDatabase(ClientContext &context) {
-	return *context.db;
-}
-
-StorageManager &StorageManager::GetStorageManager(DatabaseInstance &db) {
-	return db.GetStorageManager();
-}
-
-Catalog &Catalog::GetCatalog(DatabaseInstance &db) {
-	return db.GetCatalog();
-}
-
-FileSystem &FileSystem::GetFileSystem(DatabaseInstance &db) {
-	return db.GetFileSystem();
-}
-
-DBConfig &DBConfig::GetConfig(DatabaseInstance &db) {
-	return db.config;
-}
-
-ClientConfig &ClientConfig::GetConfig(ClientContext &context) {
-	return context.config;
-}
-
-TransactionManager &TransactionManager::Get(ClientContext &context) {
-	return TransactionManager::Get(DatabaseInstance::GetDatabase(context));
-}
-
-TransactionManager &TransactionManager::Get(DatabaseInstance &db) {
-	return db.GetTransactionManager();
-}
-
-ConnectionManager &ConnectionManager::Get(DatabaseInstance &db) {
-	return db.GetConnectionManager();
-}
-
-ConnectionManager &ConnectionManager::Get(ClientContext &context) {
-	return ConnectionManager::Get(DatabaseInstance::GetDatabase(context));
-}
-
-void DatabaseInstance::Initialize(const char *path, DBConfig *new_config) {
-	if (new_config) {
-		// user-supplied configuration
-		Configure(*new_config);
-	} else {
-		// default configuration
-		DBConfig config;
-		Configure(config);
-	}
-	if (config.temporary_directory.empty() && path) {
-		// no directory specified: use default temp path
-		config.temporary_directory = string(path) + ".tmp";
-
-		// special treatment for in-memory mode
-		if (strcmp(path, ":memory:") == 0) {
-			config.temporary_directory = ".tmp";
-		}
-	}
-	if (new_config && !new_config->use_temporary_directory) {
-		// temporary directories explicitly disabled
-		config.temporary_directory = string();
-	}
-
-	storage =
-	    make_unique<StorageManager>(*this, path ? string(path) : string(), config.access_mode == AccessMode::READ_ONLY);
-	catalog = make_unique<Catalog>(*this);
-	transaction_manager = make_unique<TransactionManager>(*this);
-	scheduler = make_unique<TaskScheduler>(*this);
-	object_cache = make_unique<ObjectCache>();
-	connection_manager = make_unique<ConnectionManager>();
-
-	// initialize the database
-	storage->Initialize();
-
-	// only increase thread count after storage init because we get races on catalog otherwise
-	scheduler->SetThreads(config.maximum_threads);
-}
-
-DuckDB::DuckDB(const char *path, DBConfig *new_config) : instance(make_shared<DatabaseInstance>()) {
-	instance->Initialize(path, new_config);
-	if (instance->config.load_extensions) {
-		ExtensionHelper::LoadAllExtensions(*this);
-	}
-}
-
-DuckDB::DuckDB(const string &path, DBConfig *config) : DuckDB(path.c_str(), config) {
-}
-
-DuckDB::DuckDB(DatabaseInstance &instance_p) : instance(instance_p.shared_from_this()) {
-}
-
-DuckDB::~DuckDB() {
-}
-
-StorageManager &DatabaseInstance::GetStorageManager() {
-	return *storage;
-}
-
-Catalog &DatabaseInstance::GetCatalog() {
-	return *catalog;
-}
-
-TransactionManager &DatabaseInstance::GetTransactionManager() {
-	return *transaction_manager;
-}
-
-TaskScheduler &DatabaseInstance::GetScheduler() {
-	return *scheduler;
-}
-
-ObjectCache &DatabaseInstance::GetObjectCache() {
-	return *object_cache;
-}
-
-FileSystem &DatabaseInstance::GetFileSystem() {
-	return *config.file_system;
-}
-
-ConnectionManager &DatabaseInstance::GetConnectionManager() {
-	return *connection_manager;
-}
-
-FileSystem &DuckDB::GetFileSystem() {
-	return instance->GetFileSystem();
-}
-
-Allocator &Allocator::Get(ClientContext &context) {
-	return Allocator::Get(*context.db);
-}
-
-Allocator &Allocator::Get(DatabaseInstance &db) {
-	return *db.config.allocator;
-}
-
-void DatabaseInstance::Configure(DBConfig &new_config) {
-	config.access_mode = AccessMode::READ_WRITE;
-	if (new_config.access_mode != AccessMode::UNDEFINED) {
-		config.access_mode = new_config.access_mode;
-	}
-	if (new_config.file_system) {
-		config.file_system = move(new_config.file_system);
-	} else {
-		config.file_system = make_unique<VirtualFileSystem>();
-	}
-	config.maximum_memory = new_config.maximum_memory;
-	if (config.maximum_memory == (idx_t)-1) {
-		auto memory = FileSystem::GetAvailableMemory();
-		if (memory != DConstants::INVALID_INDEX) {
-			config.maximum_memory = memory * 8 / 10;
-		}
-	}
-	if (new_config.maximum_threads == (idx_t)-1) {
-#ifndef DUCKDB_NO_THREADS
-		config.maximum_threads = std::thread::hardware_concurrency();
-#else
-		config.maximum_threads = 1;
-#endif
-	} else {
-		config.maximum_threads = new_config.maximum_threads;
-	}
-	config.external_threads = new_config.external_threads;
-	config.load_extensions = new_config.load_extensions;
-	config.force_compression = new_config.force_compression;
-	config.allocator = move(new_config.allocator);
-	if (!config.allocator) {
-		config.allocator = make_unique<Allocator>();
-	}
-	config.checkpoint_wal_size = new_config.checkpoint_wal_size;
-	config.use_direct_io = new_config.use_direct_io;
-	config.temporary_directory = new_config.temporary_directory;
-	config.collation = new_config.collation;
-	config.default_order_type = new_config.default_order_type;
-	config.default_null_order = new_config.default_null_order;
-	config.enable_external_access = new_config.enable_external_access;
-	config.replacement_scans = move(new_config.replacement_scans);
-	config.initialize_default_database = new_config.initialize_default_database;
-	config.disabled_optimizers = move(new_config.disabled_optimizers);
-	config.parser_extensions = move(new_config.parser_extensions);
-}
-
-DBConfig &DBConfig::GetConfig(ClientContext &context) {
-	return context.db->config;
-}
-
-idx_t DatabaseInstance::NumberOfThreads() {
-	return scheduler->NumberOfThreads();
-}
-
-const unordered_set<std::string> &DatabaseInstance::LoadedExtensions() {
-	return loaded_extensions;
-}
-
-idx_t DuckDB::NumberOfThreads() {
-	return instance->NumberOfThreads();
-}
-
-bool DuckDB::ExtensionIsLoaded(const std::string &name) {
-	return instance->loaded_extensions.find(name) != instance->loaded_extensions.end();
-}
-void DuckDB::SetExtensionLoaded(const std::string &name) {
-	instance->loaded_extensions.insert(name);
-}
-
-string ClientConfig::ExtractTimezoneFromConfig(ClientConfig &config) {
-	if (config.set_variables.find("TimeZone") == config.set_variables.end()) {
-		return "UTC";
-	} else {
-		return config.set_variables["TimeZone"].GetValue<std::string>();
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#if defined(BUILD_ICU_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#define ICU_STATICALLY_LOADED true
-#include "icu-extension.hpp"
-#else
-#define ICU_STATICALLY_LOADED false
-#endif
-
-#if defined(BUILD_PARQUET_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#define PARQUET_STATICALLY_LOADED true
-#include "parquet-extension.hpp"
-#else
-#define PARQUET_STATICALLY_LOADED false
-#endif
-
-#if defined(BUILD_TPCH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#define TPCH_STATICALLY_LOADED true
-#include "tpch-extension.hpp"
-#else
-#define TPCH_STATICALLY_LOADED false
-#endif
-
-#if defined(BUILD_TPCDS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#define TPCDS_STATICALLY_LOADED true
-#include "tpcds-extension.hpp"
-#else
-#define TPCDS_STATICALLY_LOADED false
-#endif
-
-#if defined(BUILD_SUBSTRAIT_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#define SUBSTRAIT_STATICALLY_LOADED true
-#include "substrait-extension.hpp"
-#else
-#define SUBSTRAIT_STATICALLY_LOADED false
-#endif
-
-#if defined(BUILD_FTS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#define FTS_STATICALLY_LOADED true
-#include "fts-extension.hpp"
-#else
-#define FTS_STATICALLY_LOADED false
-#endif
-
-#if defined(BUILD_HTTPFS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#define HTTPFS_STATICALLY_LOADED true
-#include "httpfs-extension.hpp"
-#else
-#define HTTPFS_STATICALLY_LOADED false
-#endif
-
-#if defined(BUILD_VISUALIZER_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#include "visualizer-extension.hpp"
-#endif
-
-#if defined(BUILD_JSON_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#define JSON_STATICALLY_LOADED true
-#include "json-extension.hpp"
-#else
-#define JSON_STATICALLY_LOADED false
-#endif
-
-#if defined(BUILD_EXCEL_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#include "excel-extension.hpp"
-#endif
-
-#if defined(BUILD_SQLSMITH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-#include "sqlsmith-extension.hpp"
-#endif
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Default Extensions
-//===--------------------------------------------------------------------===//
-static DefaultExtension internal_extensions[] = {
-    {"icu", "Adds support for time zones and collations using the ICU library", ICU_STATICALLY_LOADED},
-    {"parquet", "Adds support for reading and writing parquet files", PARQUET_STATICALLY_LOADED},
-    {"tpch", "Adds TPC-H data generation and query support", TPCH_STATICALLY_LOADED},
-    {"tpcds", "Adds TPC-DS data generation and query support", TPCDS_STATICALLY_LOADED},
-    {"substrait", "Adds support for the Substrait integration", SUBSTRAIT_STATICALLY_LOADED},
-    {"fts", "Adds support for Full-Text Search Indexes", FTS_STATICALLY_LOADED},
-    {"httpfs", "Adds support for reading and writing files over a HTTP(S) connection", HTTPFS_STATICALLY_LOADED},
-    {"json", "Adds support for JSON operations", JSON_STATICALLY_LOADED},
-    {"sqlite_scanner", "Adds support for reading SQLite database files", false},
-    {"postgres_scanner", "Adds support for reading from a Postgres database", false},
-    {nullptr, nullptr, false}};
-
-idx_t ExtensionHelper::DefaultExtensionCount() {
-	idx_t index;
-	for (index = 0; internal_extensions[index].name != nullptr; index++) {
-	}
-	return index;
-}
-
-DefaultExtension ExtensionHelper::GetDefaultExtension(idx_t index) {
-	D_ASSERT(index < DefaultExtensionCount());
-	return internal_extensions[index];
-}
-
-//===--------------------------------------------------------------------===//
-// Load Statically Compiled Extension
-//===--------------------------------------------------------------------===//
-void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
-	unordered_set<string> extensions {"parquet",   "icu",        "tpch", "tpcds", "fts",     "httpfs",
-	                                  "substrait", "visualizer", "json", "excel", "sqlsmith"};
-	for (auto &ext : extensions) {
-		LoadExtensionInternal(db, ext, true);
-	}
-}
-
-ExtensionLoadResult ExtensionHelper::LoadExtension(DuckDB &db, const std::string &extension) {
-	return LoadExtensionInternal(db, extension, false);
-}
-
-ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std::string &extension,
-                                                           bool initial_load) {
-#ifdef DUCKDB_TEST_REMOTE_INSTALL
-	if (!initial_load && StringUtil::Contains(DUCKDB_TEST_REMOTE_INSTALL, extension)) {
-		Connection con(db);
-		auto result = con.Query("INSTALL " + extension);
-		if (!result->success) {
-			result->Print();
-			return ExtensionLoadResult::EXTENSION_UNKNOWN;
-		}
-		result = con.Query("LOAD " + extension);
-		if (!result->success) {
-			result->Print();
-			return ExtensionLoadResult::EXTENSION_UNKNOWN;
-		}
-		return ExtensionLoadResult::LOADED_EXTENSION;
-	}
-#endif
-	if (extension == "parquet") {
-#if PARQUET_STATICALLY_LOADED
-		db.LoadExtension<ParquetExtension>();
-#else
-		// parquet extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "icu") {
-#if ICU_STATICALLY_LOADED
-		db.LoadExtension<ICUExtension>();
-#else
-		// icu extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "tpch") {
-#if TPCH_STATICALLY_LOADED
-		db.LoadExtension<TPCHExtension>();
-#else
-		// icu extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "substrait") {
-#if SUBSTRAIT_STATICALLY_LOADED
-
-		db.LoadExtension<SubstraitExtension>();
-#else
-		// substrait extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "tpcds") {
-#if TPCDS_STATICALLY_LOADED
-		db.LoadExtension<TPCDSExtension>();
-#else
-		// icu extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "fts") {
-#if FTS_STATICALLY_LOADED
-		db.LoadExtension<FTSExtension>();
-#else
-		// fts extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "httpfs") {
-#if HTTPFS_STATICALLY_LOADED
-		db.LoadExtension<HTTPFsExtension>();
-#else
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "visualizer") {
-#if defined(BUILD_VISUALIZER_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-		db.LoadExtension<VisualizerExtension>();
-#else
-		// visualizer extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "json") {
-#if JSON_STATICALLY_LOADED
-		db.LoadExtension<JSONExtension>();
-#else
-		// json extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "excel") {
-#if defined(BUILD_EXCEL_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-		db.LoadExtension<EXCELExtension>();
-#else
-		// excel extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else if (extension == "sqlsmith") {
-#if defined(BUILD_SQLSMITH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
-		db.LoadExtension<SQLSmithExtension>();
-#else
-		// excel extension required but not build: skip this test
-		return ExtensionLoadResult::NOT_LOADED;
-#endif
-	} else {
-		// unknown extension
-		return ExtensionLoadResult::EXTENSION_UNKNOWN;
-	}
-	return ExtensionLoadResult::LOADED_EXTENSION;
-}
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-6.cpp b/velox/external/duckdb/duckdb-6.cpp
deleted file mode 100644
index 2fb53a9c0851b..0000000000000
--- a/velox/external/duckdb/duckdb-6.cpp
+++ /dev/null
@@ -1,17112 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-
-
-#ifndef DISABLE_DUCKDB_REMOTE_INSTALL
-
-#endif
-
-
-#include <fstream>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Install Extension
-//===--------------------------------------------------------------------===//
-const vector<string> ExtensionHelper::PathComponents() {
-	return vector<string> {".duckdb", "extensions", DuckDB::SourceID(), DuckDB::Platform()};
-}
-
-string ExtensionHelper::ExtensionDirectory(FileSystem &fs) {
-	string local_path = fs.GetHomeDirectory();
-	if (!fs.DirectoryExists(local_path)) {
-		throw InternalException("Can't find the home directory at " + local_path);
-	}
-	auto path_components = PathComponents();
-	for (auto &path_ele : path_components) {
-		local_path = fs.JoinPath(local_path, path_ele);
-		if (!fs.DirectoryExists(local_path)) {
-			fs.CreateDirectory(local_path);
-		}
-	}
-	return local_path;
-}
-
-void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &extension, bool force_install) {
-	auto &config = DBConfig::GetConfig(db);
-	if (!config.enable_external_access) {
-		throw PermissionException("Installing extensions is disabled through configuration");
-	}
-	auto &fs = FileSystem::GetFileSystem(db);
-
-	string local_path = ExtensionDirectory(fs);
-
-	auto extension_name = fs.ExtractBaseName(extension);
-
-	string local_extension_path = fs.JoinPath(local_path, extension_name + ".duckdb_extension");
-	if (fs.FileExists(local_extension_path) && !force_install) {
-		return;
-	}
-
-	auto uuid = UUID::ToString(UUID::GenerateRandomUUID());
-	string temp_path = local_extension_path + ".tmp-" + uuid;
-	if (fs.FileExists(temp_path)) {
-		fs.RemoveFile(temp_path);
-	}
-	auto is_http_url = StringUtil::Contains(extension, "http://");
-	if (fs.FileExists(extension)) {
-
-		std::ifstream in(extension, std::ios::binary);
-		if (in.bad()) {
-			throw IOException("Failed to read extension from \"%s\"", extension);
-		}
-		std::ofstream out(temp_path, std::ios::binary);
-		out << in.rdbuf();
-		if (out.bad()) {
-			throw IOException("Failed to write extension to \"%s\"", temp_path);
-		}
-		in.close();
-		out.close();
-
-		fs.MoveFile(temp_path, local_extension_path);
-		return;
-	} else if (StringUtil::Contains(extension, "/") && !is_http_url) {
-		throw IOException("Failed to read extension from \"%s\": no such file", extension);
-	}
-
-#ifdef DISABLE_DUCKDB_REMOTE_INSTALL
-	throw BinderException("Remote extension installation is disabled through configuration");
-#else
-	string url_template = "http://extensions.duckdb.org/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
-
-	if (is_http_url) {
-		url_template = extension;
-		extension_name = "";
-	}
-
-	auto url = StringUtil::Replace(url_template, "${REVISION}", DuckDB::SourceID());
-	url = StringUtil::Replace(url, "${PLATFORM}", DuckDB::Platform());
-	url = StringUtil::Replace(url, "${NAME}", extension_name);
-
-	string no_http = StringUtil::Replace(url, "http://", "");
-
-	idx_t next = no_http.find('/', 0);
-	if (next == string::npos) {
-		throw IOException("No slash in URL template");
-	}
-
-	// Push the substring [last, next) on to splits
-	auto hostname_without_http = no_http.substr(0, next);
-	auto url_local_part = no_http.substr(next);
-
-	auto url_base = "http://" + hostname_without_http;
-	duckdb_httplib::Client cli(url_base.c_str());
-
-	duckdb_httplib::Headers headers = {{"User-Agent", StringUtil::Format("DuckDB %s %s %s", DuckDB::LibraryVersion(),
-	                                                                     DuckDB::SourceID(), DuckDB::Platform())}};
-
-	auto res = cli.Get(url_local_part.c_str(), headers);
-	if (!res || res->status != 200) {
-		throw IOException("Failed to download extension %s%s", url_base, url_local_part);
-	}
-	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
-	std::ofstream out(temp_path, std::ios::binary);
-	out.write(decompressed_body.data(), decompressed_body.size());
-	if (out.bad()) {
-		throw IOException("Failed to write extension to %s", temp_path);
-	}
-	out.close();
-	fs.MoveFile(temp_path, local_extension_path);
-#endif
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Load External Extension
-//===--------------------------------------------------------------------===//
-typedef void (*ext_init_fun_t)(DatabaseInstance &);
-typedef const char *(*ext_version_fun_t)(void);
-
-template <class T>
-static T LoadFunctionFromDLL(void *dll, const string &function_name, const string &filename) {
-	auto function = dlsym(dll, function_name.c_str());
-	if (!function) {
-		throw IOException("File \"%s\" did not contain function \"%s\": %s", filename, function_name, GetDLError());
-	}
-	return (T)function;
-}
-
-void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, const string &extension) {
-	auto &config = DBConfig::GetConfig(db);
-	if (!config.enable_external_access) {
-		throw PermissionException("Loading external extensions is disabled through configuration");
-	}
-	auto &fs = FileSystem::GetFileSystem(db);
-	auto filename = fs.ConvertSeparators(extension);
-
-	// shorthand case
-	if (!StringUtil::Contains(extension, ".") && !StringUtil::Contains(extension, fs.PathSeparator())) {
-		string local_path = fs.GetHomeDirectory();
-		auto path_components = PathComponents();
-		for (auto &path_ele : path_components) {
-			local_path = fs.JoinPath(local_path, path_ele);
-		}
-		filename = fs.JoinPath(local_path, extension + ".duckdb_extension");
-	}
-
-	if (!fs.FileExists(filename)) {
-		throw IOException("File \"%s\" not found", filename);
-	}
-	auto lib_hdl = dlopen(filename.c_str(), RTLD_NOW | RTLD_LOCAL);
-	if (!lib_hdl) {
-		throw IOException("File \"%s\" could not be loaded: %s", filename, GetDLError());
-	}
-
-	auto basename = fs.ExtractBaseName(filename);
-	auto init_fun_name = basename + "_init";
-	auto version_fun_name = basename + "_version";
-
-	ext_init_fun_t init_fun;
-	ext_version_fun_t version_fun;
-
-	init_fun = LoadFunctionFromDLL<ext_init_fun_t>(lib_hdl, init_fun_name, filename);
-	version_fun = LoadFunctionFromDLL<ext_version_fun_t>(lib_hdl, version_fun_name, filename);
-
-	std::string engine_version = std::string(DuckDB::LibraryVersion());
-
-	auto version_fun_result = (*version_fun)();
-	if (version_fun_result == nullptr) {
-		throw InvalidInputException("Extension \"%s\" returned a nullptr", filename);
-	}
-	std::string extension_version = std::string(version_fun_result);
-
-	// Trim v's if necessary
-	std::string extension_version_trimmed = extension_version;
-	std::string engine_version_trimmed = engine_version;
-	if (extension_version.length() > 0 && extension_version[0] == 'v') {
-		extension_version_trimmed = extension_version.substr(1);
-	}
-	if (engine_version.length() > 0 && engine_version[0] == 'v') {
-		engine_version_trimmed = engine_version.substr(1);
-	}
-
-	if (extension_version_trimmed != engine_version_trimmed) {
-		throw InvalidInputException("Extension \"%s\" version (%s) does not match DuckDB version (%s)", filename,
-		                            extension_version, engine_version);
-	}
-
-	try {
-		(*init_fun)(db);
-	} catch (std::exception &e) {
-		throw InvalidInputException("Initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"",
-		                            init_fun_name, filename, e.what());
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-Extension::~Extension() {
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-MaterializedQueryResult::MaterializedQueryResult(StatementType statement_type, StatementProperties properties,
-                                                 vector<LogicalType> types, vector<string> names,
-                                                 const shared_ptr<ClientContext> &context_p)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, properties, move(types), move(names)),
-      collection(Allocator::DefaultAllocator()), context(context_p) {
-}
-
-MaterializedQueryResult::MaterializedQueryResult(string error)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, move(error)), collection(Allocator::DefaultAllocator()) {
-}
-
-Value MaterializedQueryResult::GetValue(idx_t column, idx_t index) {
-	auto &data = collection.GetChunkForRow(index).data[column];
-	auto offset_in_chunk = index % STANDARD_VECTOR_SIZE;
-	return data.GetValue(offset_in_chunk);
-}
-
-string MaterializedQueryResult::ToString() {
-	string result;
-	if (success) {
-		result = HeaderToString();
-		result += "[ Rows: " + to_string(collection.Count()) + "]\n";
-		for (idx_t j = 0; j < collection.Count(); j++) {
-			for (idx_t i = 0; i < collection.ColumnCount(); i++) {
-				auto val = collection.GetValue(i, j);
-				result += val.IsNull() ? "NULL" : val.ToString();
-				result += "\t";
-			}
-			result += "\n";
-		}
-		result += "\n";
-	} else {
-		result = error + "\n";
-	}
-	return result;
-}
-
-unique_ptr<DataChunk> MaterializedQueryResult::Fetch() {
-	return FetchRaw();
-}
-
-unique_ptr<DataChunk> MaterializedQueryResult::FetchRaw() {
-	if (!success) {
-		throw InvalidInputException("Attempting to fetch from an unsuccessful query result\nError: %s", error);
-	}
-	return collection.Fetch();
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-PendingQueryResult::PendingQueryResult(shared_ptr<ClientContext> context_p, PreparedStatementData &statement,
-                                       vector<LogicalType> types_p, bool allow_stream_result)
-    : BaseQueryResult(QueryResultType::PENDING_RESULT, statement.statement_type, statement.properties, move(types_p),
-                      statement.names),
-      context(move(context_p)), allow_stream_result(allow_stream_result) {
-}
-
-PendingQueryResult::PendingQueryResult(string error) : BaseQueryResult(QueryResultType::PENDING_RESULT, move(error)) {
-}
-
-PendingQueryResult::~PendingQueryResult() {
-}
-
-unique_ptr<ClientContextLock> PendingQueryResult::LockContext() {
-	if (!context) {
-		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
-		                            error);
-	}
-	return context->LockContext();
-}
-
-void PendingQueryResult::CheckExecutableInternal(ClientContextLock &lock) {
-	bool invalidated = !success || !context;
-	if (!invalidated) {
-		invalidated = !context->IsActiveResult(lock, this);
-	}
-	if (invalidated) {
-		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
-		                            error);
-	}
-}
-
-PendingExecutionResult PendingQueryResult::ExecuteTask() {
-	auto lock = LockContext();
-	return ExecuteTaskInternal(*lock);
-}
-
-PendingExecutionResult PendingQueryResult::ExecuteTaskInternal(ClientContextLock &lock) {
-	CheckExecutableInternal(lock);
-	return context->ExecuteTaskInternal(lock, *this);
-}
-
-unique_ptr<QueryResult> PendingQueryResult::ExecuteInternal(ClientContextLock &lock) {
-	CheckExecutableInternal(lock);
-	while (ExecuteTaskInternal(lock) == PendingExecutionResult::RESULT_NOT_READY) {
-	}
-	if (!success) {
-		return make_unique<MaterializedQueryResult>(error);
-	}
-	auto result = context->FetchResultInternal(lock, *this);
-	Close();
-	return result;
-}
-
-unique_ptr<QueryResult> PendingQueryResult::Execute() {
-	auto lock = LockContext();
-	return ExecuteInternal(*lock);
-}
-
-void PendingQueryResult::Close() {
-	context.reset();
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-PreparedStatement::PreparedStatement(shared_ptr<ClientContext> context, shared_ptr<PreparedStatementData> data_p,
-                                     string query, idx_t n_param)
-    : context(move(context)), data(move(data_p)), query(move(query)), success(true), n_param(n_param) {
-	D_ASSERT(data || !success);
-}
-
-PreparedStatement::PreparedStatement(string error) : context(nullptr), success(false), error(move(error)) {
-}
-
-PreparedStatement::~PreparedStatement() {
-}
-
-idx_t PreparedStatement::ColumnCount() {
-	D_ASSERT(data);
-	return data->types.size();
-}
-
-StatementType PreparedStatement::GetStatementType() {
-	D_ASSERT(data);
-	return data->statement_type;
-}
-
-StatementProperties PreparedStatement::GetStatementProperties() {
-	D_ASSERT(data);
-	return data->properties;
-}
-
-const vector<LogicalType> &PreparedStatement::GetTypes() {
-	D_ASSERT(data);
-	return data->types;
-}
-
-const vector<string> &PreparedStatement::GetNames() {
-	D_ASSERT(data);
-	return data->names;
-}
-
-unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool allow_stream_result) {
-	auto pending = PendingQuery(values, allow_stream_result);
-	if (!pending->success) {
-		return make_unique<MaterializedQueryResult>(pending->error);
-	}
-	return pending->Execute();
-}
-
-unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(vector<Value> &values, bool allow_stream_result) {
-	if (!success) {
-		throw InvalidInputException("Attempting to execute an unsuccessfully prepared statement!");
-	}
-	D_ASSERT(data);
-	PendingQueryParameters parameters;
-	parameters.parameters = &values;
-	parameters.allow_stream_result = allow_stream_result && data->properties.allow_stream_result;
-	auto result = context->PendingQuery(query, data, parameters);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-PreparedStatementData::PreparedStatementData(StatementType type) : statement_type(type) {
-}
-
-PreparedStatementData::~PreparedStatementData() {
-}
-
-void PreparedStatementData::Bind(vector<Value> values) {
-	// set parameters
-	const auto required = properties.parameter_count;
-	D_ASSERT(!unbound_statement || unbound_statement->n_param == properties.parameter_count);
-	if (values.size() != required) {
-		throw BinderException("Parameter/argument count mismatch for prepared statement. Expected %llu, got %llu",
-		                      required, values.size());
-	}
-
-	// bind the required values
-	for (auto &it : value_map) {
-		const idx_t i = it.first - 1;
-		if (i >= values.size()) {
-			throw BinderException("Could not find parameter with index %llu", i + 1);
-		}
-		D_ASSERT(!it.second.empty());
-		if (!values[i].TryCastAs(it.second[0]->type())) {
-			throw BinderException(
-			    "Type mismatch for binding parameter with index %llu, expected type %s but got type %s", i + 1,
-			    it.second[0]->type().ToString().c_str(), values[i].type().ToString().c_str());
-		}
-		for (auto &target : it.second) {
-			*target = values[i];
-		}
-	}
-}
-
-LogicalType PreparedStatementData::GetType(idx_t param_idx) {
-	auto it = value_map.find(param_idx);
-	if (it == value_map.end()) {
-		throw BinderException("Could not find parameter with index %llu", param_idx);
-	}
-	D_ASSERT(!it->second.empty());
-	return it->second[0]->type();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <utility>
-#include <algorithm>
-
-namespace duckdb {
-
-QueryProfiler::QueryProfiler(ClientContext &context_p)
-    : context(context_p), running(false), query_requires_profiling(false), is_explain_analyze(false) {
-}
-
-bool QueryProfiler::IsEnabled() const {
-	return is_explain_analyze ? true : ClientConfig::GetConfig(context).enable_profiler;
-}
-
-bool QueryProfiler::IsDetailedEnabled() const {
-	return is_explain_analyze ? false : ClientConfig::GetConfig(context).enable_detailed_profiling;
-}
-
-ProfilerPrintFormat QueryProfiler::GetPrintFormat() const {
-	return ClientConfig::GetConfig(context).profiler_print_format;
-}
-
-string QueryProfiler::GetSaveLocation() const {
-	return is_explain_analyze ? string() : ClientConfig::GetConfig(context).profiler_save_location;
-}
-
-QueryProfiler &QueryProfiler::Get(ClientContext &context) {
-	return *ClientData::Get(context).profiler;
-}
-
-void QueryProfiler::StartQuery(string query, bool is_explain_analyze) {
-	if (is_explain_analyze) {
-		StartExplainAnalyze();
-	}
-	if (!IsEnabled()) {
-		return;
-	}
-	this->running = true;
-	this->query = move(query);
-	tree_map.clear();
-	root = nullptr;
-	phase_timings.clear();
-	phase_stack.clear();
-
-	main_query.Start();
-}
-
-bool QueryProfiler::OperatorRequiresProfiling(PhysicalOperatorType op_type) {
-	switch (op_type) {
-	case PhysicalOperatorType::ORDER_BY:
-	case PhysicalOperatorType::RESERVOIR_SAMPLE:
-	case PhysicalOperatorType::STREAMING_SAMPLE:
-	case PhysicalOperatorType::LIMIT:
-	case PhysicalOperatorType::LIMIT_PERCENT:
-	case PhysicalOperatorType::STREAMING_LIMIT:
-	case PhysicalOperatorType::TOP_N:
-	case PhysicalOperatorType::WINDOW:
-	case PhysicalOperatorType::UNNEST:
-	case PhysicalOperatorType::SIMPLE_AGGREGATE:
-	case PhysicalOperatorType::HASH_GROUP_BY:
-	case PhysicalOperatorType::FILTER:
-	case PhysicalOperatorType::PROJECTION:
-	case PhysicalOperatorType::COPY_TO_FILE:
-	case PhysicalOperatorType::TABLE_SCAN:
-	case PhysicalOperatorType::CHUNK_SCAN:
-	case PhysicalOperatorType::DELIM_SCAN:
-	case PhysicalOperatorType::EXPRESSION_SCAN:
-	case PhysicalOperatorType::BLOCKWISE_NL_JOIN:
-	case PhysicalOperatorType::NESTED_LOOP_JOIN:
-	case PhysicalOperatorType::HASH_JOIN:
-	case PhysicalOperatorType::CROSS_PRODUCT:
-	case PhysicalOperatorType::PIECEWISE_MERGE_JOIN:
-	case PhysicalOperatorType::IE_JOIN:
-	case PhysicalOperatorType::DELIM_JOIN:
-	case PhysicalOperatorType::UNION:
-	case PhysicalOperatorType::RECURSIVE_CTE:
-	case PhysicalOperatorType::EMPTY_RESULT:
-		return true;
-	default:
-		return false;
-	}
-}
-
-void QueryProfiler::Finalize(TreeNode &node) {
-	for (auto &child : node.children) {
-		Finalize(*child);
-		if (node.type == PhysicalOperatorType::UNION) {
-			node.info.elements += child->info.elements;
-		}
-	}
-}
-
-void QueryProfiler::StartExplainAnalyze() {
-	this->is_explain_analyze = true;
-}
-
-void QueryProfiler::EndQuery() {
-	lock_guard<mutex> guard(flush_lock);
-	if (!IsEnabled() || !running) {
-		return;
-	}
-
-	main_query.End();
-	if (root) {
-		Finalize(*root);
-	}
-	this->running = false;
-	// print or output the query profiling after termination
-	// EXPLAIN ANALYSE should not be outputted by the profiler
-	if (IsEnabled() && !is_explain_analyze) {
-		string query_info = ToString();
-		auto save_location = GetSaveLocation();
-		if (!ClientConfig::GetConfig(context).emit_profiler_output) {
-			// disable output
-		} else if (save_location.empty()) {
-			Printer::Print(query_info);
-			Printer::Print("\n");
-		} else {
-			WriteToFile(save_location.c_str(), query_info);
-		}
-	}
-	this->is_explain_analyze = false;
-}
-string QueryProfiler::ToString() const {
-	const auto format = GetPrintFormat();
-	switch (format) {
-	case ProfilerPrintFormat::QUERY_TREE:
-		return QueryTreeToString();
-	case ProfilerPrintFormat::JSON:
-		return ToJSON();
-	case ProfilerPrintFormat::QUERY_TREE_OPTIMIZER:
-		return QueryTreeToString(true);
-	default:
-		throw InternalException("Unknown ProfilerPrintFormat \"%s\"", format);
-	}
-}
-
-void QueryProfiler::StartPhase(string new_phase) {
-	if (!IsEnabled() || !running) {
-		return;
-	}
-
-	if (!phase_stack.empty()) {
-		// there are active phases
-		phase_profiler.End();
-		// add the timing to all phases prior to this one
-		string prefix = "";
-		for (auto &phase : phase_stack) {
-			phase_timings[phase] += phase_profiler.Elapsed();
-			prefix += phase + " > ";
-		}
-		// when there are previous phases, we prefix the current phase with those phases
-		new_phase = prefix + new_phase;
-	}
-
-	// start a new phase
-	phase_stack.push_back(new_phase);
-	// restart the timer
-	phase_profiler.Start();
-}
-
-void QueryProfiler::EndPhase() {
-	if (!IsEnabled() || !running) {
-		return;
-	}
-	D_ASSERT(phase_stack.size() > 0);
-
-	// end the timer
-	phase_profiler.End();
-	// add the timing to all currently active phases
-	for (auto &phase : phase_stack) {
-		phase_timings[phase] += phase_profiler.Elapsed();
-	}
-	// now remove the last added phase
-	phase_stack.pop_back();
-
-	if (!phase_stack.empty()) {
-		phase_profiler.Start();
-	}
-}
-
-void QueryProfiler::Initialize(PhysicalOperator *root_op) {
-	if (!IsEnabled() || !running) {
-		return;
-	}
-	this->query_requires_profiling = false;
-	this->root = CreateTree(root_op);
-	if (!query_requires_profiling) {
-		// query does not require profiling: disable profiling for this query
-		this->running = false;
-		tree_map.clear();
-		root = nullptr;
-		phase_timings.clear();
-		phase_stack.clear();
-	}
-}
-
-OperatorProfiler::OperatorProfiler(bool enabled_p) : enabled(enabled_p), active_operator(nullptr) {
-}
-
-void OperatorProfiler::StartOperator(const PhysicalOperator *phys_op) {
-	if (!enabled) {
-		return;
-	}
-
-	if (active_operator) {
-		throw InternalException("OperatorProfiler: Attempting to call StartOperator while another operator is active");
-	}
-
-	active_operator = phys_op;
-
-	// start timing for current element
-	op.Start();
-}
-
-void OperatorProfiler::EndOperator(DataChunk *chunk) {
-	if (!enabled) {
-		return;
-	}
-
-	if (!active_operator) {
-		throw InternalException("OperatorProfiler: Attempting to call EndOperator while another operator is active");
-	}
-
-	// finish timing for the current element
-	op.End();
-
-	AddTiming(active_operator, op.Elapsed(), chunk ? chunk->size() : 0);
-	active_operator = nullptr;
-}
-
-void OperatorProfiler::AddTiming(const PhysicalOperator *op, double time, idx_t elements) {
-	if (!enabled) {
-		return;
-	}
-	if (!Value::DoubleIsFinite(time)) {
-		return;
-	}
-	auto entry = timings.find(op);
-	if (entry == timings.end()) {
-		// add new entry
-		timings[op] = OperatorInformation(time, elements);
-	} else {
-		// add to existing entry
-		entry->second.time += time;
-		entry->second.elements += elements;
-	}
-}
-void OperatorProfiler::Flush(const PhysicalOperator *phys_op, ExpressionExecutor *expression_executor,
-                             const string &name, int id) {
-	auto entry = timings.find(phys_op);
-	if (entry == timings.end()) {
-		return;
-	}
-	auto &operator_timing = timings.find(phys_op)->second;
-	if (int(operator_timing.executors_info.size()) <= id) {
-		operator_timing.executors_info.resize(id + 1);
-	}
-	operator_timing.executors_info[id] = make_unique<ExpressionExecutorInfo>(*expression_executor, name, id);
-	operator_timing.name = phys_op->GetName();
-}
-
-void QueryProfiler::Flush(OperatorProfiler &profiler) {
-	lock_guard<mutex> guard(flush_lock);
-	if (!IsEnabled() || !running) {
-		return;
-	}
-	for (auto &node : profiler.timings) {
-		auto entry = tree_map.find(node.first);
-		D_ASSERT(entry != tree_map.end());
-
-		entry->second->info.time += node.second.time;
-		entry->second->info.elements += node.second.elements;
-		if (!IsDetailedEnabled()) {
-			continue;
-		}
-		for (auto &info : node.second.executors_info) {
-			if (!info) {
-				continue;
-			}
-			auto info_id = info->id;
-			if (int(entry->second->info.executors_info.size()) <= info_id) {
-				entry->second->info.executors_info.resize(info_id + 1);
-			}
-			entry->second->info.executors_info[info_id] = move(info);
-		}
-	}
-	profiler.timings.clear();
-}
-
-static string DrawPadded(const string &str, idx_t width) {
-	if (str.size() > width) {
-		return str.substr(0, width);
-	} else {
-		width -= str.size();
-		int half_spaces = width / 2;
-		int extra_left_space = width % 2 != 0 ? 1 : 0;
-		return string(half_spaces + extra_left_space, ' ') + str + string(half_spaces, ' ');
-	}
-}
-
-static string RenderTitleCase(string str) {
-	str = StringUtil::Lower(str);
-	str[0] = toupper(str[0]);
-	for (idx_t i = 0; i < str.size(); i++) {
-		if (str[i] == '_') {
-			str[i] = ' ';
-			if (i + 1 < str.size()) {
-				str[i + 1] = toupper(str[i + 1]);
-			}
-		}
-	}
-	return str;
-}
-
-static string RenderTiming(double timing) {
-	string timing_s;
-	if (timing >= 1) {
-		timing_s = StringUtil::Format("%.2f", timing);
-	} else if (timing >= 0.1) {
-		timing_s = StringUtil::Format("%.3f", timing);
-	} else {
-		timing_s = StringUtil::Format("%.4f", timing);
-	}
-	return timing_s + "s";
-}
-
-string QueryProfiler::QueryTreeToString(bool print_optimizer_output) const {
-	std::stringstream str;
-	QueryTreeToStream(str, print_optimizer_output);
-	return str.str();
-}
-
-void QueryProfiler::QueryTreeToStream(std::ostream &ss, bool print_optimizer_output) const {
-	if (!IsEnabled()) {
-		ss << "Query profiling is disabled. Call "
-		      "Connection::EnableProfiling() to enable profiling!";
-		return;
-	}
-	ss << "┌─────────────────────────────────────┐\n";
-	ss << "│┌───────────────────────────────────┐│\n";
-	ss << "││    Query Profiling Information    ││\n";
-	ss << "│└───────────────────────────────────┘│\n";
-	ss << "└─────────────────────────────────────┘\n";
-	ss << StringUtil::Replace(query, "\n", " ") + "\n";
-	if (query.empty()) {
-		return;
-	}
-
-	constexpr idx_t TOTAL_BOX_WIDTH = 39;
-	ss << "┌─────────────────────────────────────┐\n";
-	ss << "│┌───────────────────────────────────┐│\n";
-	string total_time = "Total Time: " + RenderTiming(main_query.Elapsed());
-	ss << "││" + DrawPadded(total_time, TOTAL_BOX_WIDTH - 4) + "││\n";
-	ss << "│└───────────────────────────────────┘│\n";
-	ss << "└─────────────────────────────────────┘\n";
-	// print phase timings
-	if (print_optimizer_output) {
-		bool has_previous_phase = false;
-		for (const auto &entry : GetOrderedPhaseTimings()) {
-			if (!StringUtil::Contains(entry.first, " > ")) {
-				// primary phase!
-				if (has_previous_phase) {
-					ss << "│└───────────────────────────────────┘│\n";
-					ss << "└─────────────────────────────────────┘\n";
-				}
-				ss << "┌─────────────────────────────────────┐\n";
-				ss << "│" +
-				          DrawPadded(RenderTitleCase(entry.first) + ": " + RenderTiming(entry.second),
-				                     TOTAL_BOX_WIDTH - 2) +
-				          "│\n";
-				ss << "│┌───────────────────────────────────┐│\n";
-				has_previous_phase = true;
-			} else {
-				string entry_name = StringUtil::Split(entry.first, " > ")[1];
-				ss << "││" +
-				          DrawPadded(RenderTitleCase(entry_name) + ": " + RenderTiming(entry.second),
-				                     TOTAL_BOX_WIDTH - 4) +
-				          "││\n";
-			}
-		}
-		if (has_previous_phase) {
-			ss << "│└───────────────────────────────────┘│\n";
-			ss << "└─────────────────────────────────────┘\n";
-		}
-	}
-	// render the main operator tree
-	if (root) {
-		Render(*root, ss);
-	}
-}
-
-static string JSONSanitize(const string &text) {
-	string result;
-	result.reserve(text.size());
-	for (idx_t i = 0; i < text.size(); i++) {
-		switch (text[i]) {
-		case '\b':
-			result += "\\b";
-			break;
-		case '\f':
-			result += "\\f";
-			break;
-		case '\n':
-			result += "\\n";
-			break;
-		case '\r':
-			result += "\\r";
-			break;
-		case '\t':
-			result += "\\t";
-			break;
-		case '"':
-			result += "\\\"";
-			break;
-		case '\\':
-			result += "\\\\";
-			break;
-		default:
-			result += text[i];
-			break;
-		}
-	}
-	return result;
-}
-
-// Print a row
-static void PrintRow(std::ostream &ss, const string &annotation, int id, const string &name, double time,
-                     int sample_counter, int tuple_counter, const string &extra_info, int depth) {
-	ss << string(depth * 3, ' ') << " {\n";
-	ss << string(depth * 3, ' ') << "   \"annotation\": \"" + JSONSanitize(annotation) + "\",\n";
-	ss << string(depth * 3, ' ') << "   \"id\": " + to_string(id) + ",\n";
-	ss << string(depth * 3, ' ') << "   \"name\": \"" + JSONSanitize(name) + "\",\n";
-#if defined(RDTSC)
-	ss << string(depth * 3, ' ') << "   \"timing\": \"NULL\" ,\n";
-	ss << string(depth * 3, ' ') << "   \"cycles_per_tuple\": " + StringUtil::Format("%.4f", time) + ",\n";
-#else
-	ss << string(depth * 3, ' ') << "   \"timing\":" + to_string(time) + ",\n";
-	ss << string(depth * 3, ' ') << "   \"cycles_per_tuple\": \"NULL\" ,\n";
-#endif
-	ss << string(depth * 3, ' ') << "   \"sample_size\": " << to_string(sample_counter) + ",\n";
-	ss << string(depth * 3, ' ') << "   \"input_size\": " << to_string(tuple_counter) + ",\n";
-	ss << string(depth * 3, ' ') << "   \"extra_info\": \"" << JSONSanitize(extra_info) + "\"\n";
-	ss << string(depth * 3, ' ') << " },\n";
-}
-
-static void ExtractFunctions(std::ostream &ss, ExpressionInfo &info, int &fun_id, int depth) {
-	if (info.hasfunction) {
-		D_ASSERT(info.sample_tuples_count != 0);
-		PrintRow(ss, "Function", fun_id++, info.function_name,
-		         int(info.function_time) / double(info.sample_tuples_count), info.sample_tuples_count,
-		         info.tuples_count, "", depth);
-	}
-	if (info.children.empty()) {
-		return;
-	}
-	// extract the children of this node
-	for (auto &child : info.children) {
-		ExtractFunctions(ss, *child, fun_id, depth);
-	}
-}
-
-static void ToJSONRecursive(QueryProfiler::TreeNode &node, std::ostream &ss, int depth = 1) {
-	ss << string(depth * 3, ' ') << " {\n";
-	ss << string(depth * 3, ' ') << "   \"name\": \"" + JSONSanitize(node.name) + "\",\n";
-	ss << string(depth * 3, ' ') << "   \"timing\":" + to_string(node.info.time) + ",\n";
-	ss << string(depth * 3, ' ') << "   \"cardinality\":" + to_string(node.info.elements) + ",\n";
-	ss << string(depth * 3, ' ') << "   \"extra_info\": \"" + JSONSanitize(node.extra_info) + "\",\n";
-	ss << string(depth * 3, ' ') << "   \"timings\": [";
-	int32_t function_counter = 1;
-	int32_t expression_counter = 1;
-	ss << "\n ";
-	for (auto &expr_executor : node.info.executors_info) {
-		// For each Expression tree
-		if (!expr_executor) {
-			continue;
-		}
-		for (auto &expr_timer : expr_executor->roots) {
-			D_ASSERT(expr_timer->sample_tuples_count != 0);
-			PrintRow(ss, "ExpressionRoot", expression_counter++, expr_timer->name,
-			         int(expr_timer->time) / double(expr_timer->sample_tuples_count), expr_timer->sample_tuples_count,
-			         expr_timer->tuples_count, expr_timer->extra_info, depth + 1);
-			// Extract all functions inside the tree
-			ExtractFunctions(ss, *expr_timer->root, function_counter, depth + 1);
-		}
-	}
-	ss.seekp(-2, ss.cur);
-	ss << "\n";
-	ss << string(depth * 3, ' ') << "   ],\n";
-	ss << string(depth * 3, ' ') << "   \"children\": [\n";
-	if (node.children.empty()) {
-		ss << string(depth * 3, ' ') << "   ]\n";
-	} else {
-		for (idx_t i = 0; i < node.children.size(); i++) {
-			if (i > 0) {
-				ss << ",\n";
-			}
-			ToJSONRecursive(*node.children[i], ss, depth + 1);
-		}
-		ss << string(depth * 3, ' ') << "   ]\n";
-	}
-	ss << string(depth * 3, ' ') << " }\n";
-}
-
-string QueryProfiler::ToJSON() const {
-	if (!IsEnabled()) {
-		return "{ \"result\": \"disabled\" }\n";
-	}
-	if (query.empty()) {
-		return "{ \"result\": \"empty\" }\n";
-	}
-	if (!root) {
-		return "{ \"result\": \"error\" }\n";
-	}
-	std::stringstream ss;
-	ss << "{\n";
-	ss << "   \"name\":  \"Query\", \n";
-	ss << "   \"result\": " + to_string(main_query.Elapsed()) + ",\n";
-	ss << "   \"timing\": " + to_string(main_query.Elapsed()) + ",\n";
-	ss << "   \"cardinality\": " + to_string(root->info.elements) + ",\n";
-	// JSON cannot have literal control characters in string literals
-	string extra_info = JSONSanitize(query);
-	ss << "   \"extra-info\": \"" + extra_info + "\", \n";
-	// print the phase timings
-	ss << "   \"timings\": [\n";
-	const auto &ordered_phase_timings = GetOrderedPhaseTimings();
-	for (idx_t i = 0; i < ordered_phase_timings.size(); i++) {
-		if (i > 0) {
-			ss << ",\n";
-		}
-		ss << "   {\n";
-		ss << "   \"annotation\": \"" + ordered_phase_timings[i].first + "\", \n";
-		ss << "   \"timing\": " + to_string(ordered_phase_timings[i].second) + "\n";
-		ss << "   }";
-	}
-	ss << "\n";
-	ss << "   ],\n";
-	// recursively print the physical operator tree
-	ss << "   \"children\": [\n";
-	ToJSONRecursive(*root, ss);
-	ss << "   ]\n";
-	ss << "}";
-	return ss.str();
-}
-
-void QueryProfiler::WriteToFile(const char *path, string &info) const {
-	ofstream out(path);
-	out << info;
-	out.close();
-	// throw an IO exception if it fails to write the file
-	if (out.fail()) {
-		throw IOException(strerror(errno));
-	}
-}
-
-unique_ptr<QueryProfiler::TreeNode> QueryProfiler::CreateTree(PhysicalOperator *root, idx_t depth) {
-	if (OperatorRequiresProfiling(root->type)) {
-		this->query_requires_profiling = true;
-	}
-	auto node = make_unique<QueryProfiler::TreeNode>();
-	node->type = root->type;
-	node->name = root->GetName();
-	node->extra_info = root->ParamsToString();
-	node->depth = depth;
-	tree_map[root] = node.get();
-	auto children = root->GetChildren();
-	for (auto &child : children) {
-		auto child_node = CreateTree(child, depth + 1);
-		node->children.push_back(move(child_node));
-	}
-	return node;
-}
-
-void QueryProfiler::Render(const QueryProfiler::TreeNode &node, std::ostream &ss) const {
-	TreeRenderer renderer;
-	if (IsDetailedEnabled()) {
-		renderer.EnableDetailed();
-	} else {
-		renderer.EnableStandard();
-	}
-	renderer.Render(node, ss);
-}
-
-void QueryProfiler::Print() {
-	Printer::Print(QueryTreeToString());
-}
-
-vector<QueryProfiler::PhaseTimingItem> QueryProfiler::GetOrderedPhaseTimings() const {
-	vector<PhaseTimingItem> result;
-	// first sort the phases alphabetically
-	vector<string> phases;
-	for (auto &entry : phase_timings) {
-		phases.push_back(entry.first);
-	}
-	std::sort(phases.begin(), phases.end());
-	for (const auto &phase : phases) {
-		auto entry = phase_timings.find(phase);
-		D_ASSERT(entry != phase_timings.end());
-		result.emplace_back(entry->first, entry->second);
-	}
-	return result;
-}
-void QueryProfiler::Propagate(QueryProfiler &qp) {
-}
-
-void ExpressionInfo::ExtractExpressionsRecursive(unique_ptr<ExpressionState> &state) {
-	if (state->child_states.empty()) {
-		return;
-	}
-	// extract the children of this node
-	for (auto &child : state->child_states) {
-		auto expr_info = make_unique<ExpressionInfo>();
-		if (child->expr.expression_class == ExpressionClass::BOUND_FUNCTION) {
-			expr_info->hasfunction = true;
-			expr_info->function_name = ((BoundFunctionExpression &)child->expr).function.ToString();
-			expr_info->function_time = child->profiler.time;
-			expr_info->sample_tuples_count = child->profiler.sample_tuples_count;
-			expr_info->tuples_count = child->profiler.tuples_count;
-		}
-		expr_info->ExtractExpressionsRecursive(child);
-		children.push_back(move(expr_info));
-	}
-	return;
-}
-
-ExpressionExecutorInfo::ExpressionExecutorInfo(ExpressionExecutor &executor, const string &name, int id) : id(id) {
-	// Extract Expression Root Information from ExpressionExecutorStats
-	for (auto &state : executor.GetStates()) {
-		roots.push_back(make_unique<ExpressionRootInfo>(*state, name));
-	}
-}
-
-ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string name)
-    : current_count(state.profiler.current_count), sample_count(state.profiler.sample_count),
-      sample_tuples_count(state.profiler.sample_tuples_count), tuples_count(state.profiler.tuples_count),
-      name(state.name), time(state.profiler.time) {
-	// Use the name of expression-tree as extra-info
-	extra_info = move(name);
-	auto expression_info_p = make_unique<ExpressionInfo>();
-	// Maybe root has a function
-	if (state.root_state->expr.expression_class == ExpressionClass::BOUND_FUNCTION) {
-		expression_info_p->hasfunction = true;
-		expression_info_p->function_name = ((BoundFunctionExpression &)state.root_state->expr).function.name;
-		expression_info_p->function_time = state.root_state->profiler.time;
-		expression_info_p->sample_tuples_count = state.root_state->profiler.sample_tuples_count;
-		expression_info_p->tuples_count = state.root_state->profiler.tuples_count;
-	}
-	expression_info_p->ExtractExpressionsRecursive(state.root_state);
-	root = move(expression_info_p);
-}
-} // namespace duckdb
-#include <list>
-
-
-
-
-
-
-namespace duckdb {
-
-BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
-                                 vector<LogicalType> types_p, vector<string> names_p)
-    : type(type), statement_type(statement_type), properties(properties), types(move(types_p)), names(move(names_p)),
-      success(true) {
-	D_ASSERT(types.size() == names.size());
-}
-
-BaseQueryResult::BaseQueryResult(QueryResultType type, string error) : type(type), success(false), error(move(error)) {
-}
-
-BaseQueryResult::~BaseQueryResult() {
-}
-
-bool BaseQueryResult::HasError() {
-	return !success;
-}
-const string &BaseQueryResult::GetError() {
-	return error;
-}
-idx_t BaseQueryResult::ColumnCount() {
-	return types.size();
-}
-
-QueryResult::QueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
-                         vector<LogicalType> types_p, vector<string> names_p)
-    : BaseQueryResult(type, statement_type, properties, move(types_p), move(names_p)) {
-}
-
-QueryResult::QueryResult(QueryResultType type, string error) : BaseQueryResult(type, move(error)) {
-}
-
-QueryResult::~QueryResult() {
-}
-
-unique_ptr<DataChunk> QueryResult::Fetch() {
-	auto chunk = FetchRaw();
-	if (!chunk) {
-		return nullptr;
-	}
-	chunk->Normalify();
-	return chunk;
-}
-
-bool QueryResult::Equals(QueryResult &other) { // LCOV_EXCL_START
-	// first compare the success state of the results
-	if (success != other.success) {
-		return false;
-	}
-	if (!success) {
-		return error == other.error;
-	}
-	// compare names
-	if (names != other.names) {
-		return false;
-	}
-	// compare types
-	if (types != other.types) {
-		return false;
-	}
-	// now compare the actual values
-	// fetch chunks
-	while (true) {
-		auto lchunk = Fetch();
-		auto rchunk = other.Fetch();
-		if (!lchunk && !rchunk) {
-			return true;
-		}
-		if (!lchunk || !rchunk) {
-			return false;
-		}
-		if (lchunk->size() == 0 && rchunk->size() == 0) {
-			return true;
-		}
-		if (lchunk->size() != rchunk->size()) {
-			return false;
-		}
-		D_ASSERT(lchunk->ColumnCount() == rchunk->ColumnCount());
-		for (idx_t col = 0; col < rchunk->ColumnCount(); col++) {
-			for (idx_t row = 0; row < rchunk->size(); row++) {
-				auto lvalue = lchunk->GetValue(col, row);
-				auto rvalue = rchunk->GetValue(col, row);
-				if (lvalue.IsNull() && rvalue.IsNull()) {
-					continue;
-				}
-				if (lvalue != rvalue) {
-					return false;
-				}
-			}
-		}
-	}
-} // LCOV_EXCL_STOP
-
-void QueryResult::Print() {
-	Printer::Print(ToString());
-}
-
-string QueryResult::HeaderToString() {
-	string result;
-	for (auto &name : names) {
-		result += name + "\t";
-	}
-	result += "\n";
-	for (auto &type : types) {
-		result += type.ToString() + "\t";
-	}
-	result += "\n";
-	return result;
-}
-
-struct DuckDBArrowSchemaHolder {
-	// unused in children
-	vector<ArrowSchema> children;
-	// unused in children
-	vector<ArrowSchema *> children_ptrs;
-	//! used for nested structures
-	std::list<std::vector<ArrowSchema>> nested_children;
-	std::list<std::vector<ArrowSchema *>> nested_children_ptr;
-	//! This holds strings created to represent decimal types
-	vector<unique_ptr<char[]>> owned_type_names;
-};
-
-static void ReleaseDuckDBArrowSchema(ArrowSchema *schema) {
-	if (!schema || !schema->release) {
-		return;
-	}
-	schema->release = nullptr;
-	auto holder = static_cast<DuckDBArrowSchemaHolder *>(schema->private_data);
-	delete holder;
-}
-
-void InitializeChild(ArrowSchema &child, const string &name = "") {
-	//! Child is cleaned up by parent
-	child.private_data = nullptr;
-	child.release = ReleaseDuckDBArrowSchema;
-
-	//! Store the child schema
-	child.flags = ARROW_FLAG_NULLABLE;
-	child.name = name.c_str();
-	child.n_children = 0;
-	child.children = nullptr;
-	child.metadata = nullptr;
-	child.dictionary = nullptr;
-}
-void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                    string &config_timezone);
-
-void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                       string &config_timezone) {
-	child.format = "+m";
-	//! Map has one child which is a struct
-	child.n_children = 1;
-	root_holder.nested_children.emplace_back();
-	root_holder.nested_children.back().resize(1);
-	root_holder.nested_children_ptr.emplace_back();
-	root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-	InitializeChild(root_holder.nested_children.back()[0]);
-	child.children = &root_holder.nested_children_ptr.back()[0];
-	child.children[0]->name = "entries";
-	child_list_t<LogicalType> struct_child_types;
-	struct_child_types.push_back(std::make_pair("key", ListType::GetChildType(StructType::GetChildType(type, 0))));
-	struct_child_types.push_back(std::make_pair("value", ListType::GetChildType(StructType::GetChildType(type, 1))));
-	auto struct_type = LogicalType::STRUCT(move(struct_child_types));
-	SetArrowFormat(root_holder, *child.children[0], struct_type, config_timezone);
-}
-
-void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                    string &config_timezone) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		child.format = "b";
-		break;
-	case LogicalTypeId::TINYINT:
-		child.format = "c";
-		break;
-	case LogicalTypeId::SMALLINT:
-		child.format = "s";
-		break;
-	case LogicalTypeId::INTEGER:
-		child.format = "i";
-		break;
-	case LogicalTypeId::BIGINT:
-		child.format = "l";
-		break;
-	case LogicalTypeId::UTINYINT:
-		child.format = "C";
-		break;
-	case LogicalTypeId::USMALLINT:
-		child.format = "S";
-		break;
-	case LogicalTypeId::UINTEGER:
-		child.format = "I";
-		break;
-	case LogicalTypeId::UBIGINT:
-		child.format = "L";
-		break;
-	case LogicalTypeId::FLOAT:
-		child.format = "f";
-		break;
-	case LogicalTypeId::HUGEINT:
-		child.format = "d:38,0";
-		break;
-	case LogicalTypeId::DOUBLE:
-		child.format = "g";
-		break;
-	case LogicalTypeId::UUID:
-	case LogicalTypeId::JSON:
-	case LogicalTypeId::VARCHAR:
-		child.format = "u";
-		break;
-	case LogicalTypeId::DATE:
-		child.format = "tdD";
-		break;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		child.format = "ttu";
-		break;
-	case LogicalTypeId::TIMESTAMP:
-		child.format = "tsu:";
-		break;
-	case LogicalTypeId::TIMESTAMP_TZ: {
-		string format = "tsu:" + config_timezone;
-		unique_ptr<char[]> format_ptr = unique_ptr<char[]>(new char[format.size() + 1]);
-		for (size_t i = 0; i < format.size(); i++) {
-			format_ptr[i] = format[i];
-		}
-		format_ptr[format.size()] = '\0';
-		root_holder.owned_type_names.push_back(move(format_ptr));
-		child.format = root_holder.owned_type_names.back().get();
-		break;
-	}
-	case LogicalTypeId::TIMESTAMP_SEC:
-		child.format = "tss:";
-		break;
-	case LogicalTypeId::TIMESTAMP_NS:
-		child.format = "tsn:";
-		break;
-	case LogicalTypeId::TIMESTAMP_MS:
-		child.format = "tsm:";
-		break;
-	case LogicalTypeId::INTERVAL:
-		child.format = "tDm";
-		break;
-	case LogicalTypeId::DECIMAL: {
-		uint8_t width, scale;
-		type.GetDecimalProperties(width, scale);
-		string format = "d:" + to_string(width) + "," + to_string(scale);
-		unique_ptr<char[]> format_ptr = unique_ptr<char[]>(new char[format.size() + 1]);
-		for (size_t i = 0; i < format.size(); i++) {
-			format_ptr[i] = format[i];
-		}
-		format_ptr[format.size()] = '\0';
-		root_holder.owned_type_names.push_back(move(format_ptr));
-		child.format = root_holder.owned_type_names.back().get();
-		break;
-	}
-	case LogicalTypeId::SQLNULL: {
-		child.format = "n";
-		break;
-	}
-	case LogicalTypeId::BLOB: {
-		child.format = "z";
-		break;
-	}
-	case LogicalTypeId::LIST: {
-		child.format = "+l";
-		child.n_children = 1;
-		root_holder.nested_children.emplace_back();
-		root_holder.nested_children.back().resize(1);
-		root_holder.nested_children_ptr.emplace_back();
-		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-		InitializeChild(root_holder.nested_children.back()[0]);
-		child.children = &root_holder.nested_children_ptr.back()[0];
-		child.children[0]->name = "l";
-		SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), config_timezone);
-		break;
-	}
-	case LogicalTypeId::STRUCT: {
-		child.format = "+s";
-		auto &child_types = StructType::GetChildTypes(type);
-		child.n_children = child_types.size();
-		root_holder.nested_children.emplace_back();
-		root_holder.nested_children.back().resize(child_types.size());
-		root_holder.nested_children_ptr.emplace_back();
-		root_holder.nested_children_ptr.back().resize(child_types.size());
-		for (idx_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
-			root_holder.nested_children_ptr.back()[type_idx] = &root_holder.nested_children.back()[type_idx];
-		}
-		child.children = &root_holder.nested_children_ptr.back()[0];
-		for (size_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
-
-			InitializeChild(*child.children[type_idx]);
-
-			auto &struct_col_name = child_types[type_idx].first;
-			unique_ptr<char[]> name_ptr = unique_ptr<char[]>(new char[struct_col_name.size() + 1]);
-			for (size_t i = 0; i < struct_col_name.size(); i++) {
-				name_ptr[i] = struct_col_name[i];
-			}
-			name_ptr[struct_col_name.size()] = '\0';
-			root_holder.owned_type_names.push_back(move(name_ptr));
-
-			child.children[type_idx]->name = root_holder.owned_type_names.back().get();
-			SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, config_timezone);
-		}
-		break;
-	}
-	case LogicalTypeId::MAP: {
-		SetArrowMapFormat(root_holder, child, type, config_timezone);
-		break;
-	}
-	case LogicalTypeId::ENUM: {
-		// TODO what do we do with pointer enums here?
-		switch (EnumType::GetPhysicalType(type)) {
-		case PhysicalType::UINT8:
-			child.format = "C";
-			break;
-		case PhysicalType::UINT16:
-			child.format = "S";
-			break;
-		case PhysicalType::UINT32:
-			child.format = "I";
-			break;
-		default:
-			throw InternalException("Unsupported Enum Internal Type");
-		}
-		root_holder.nested_children.emplace_back();
-		root_holder.nested_children.back().resize(1);
-		root_holder.nested_children_ptr.emplace_back();
-		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-		InitializeChild(root_holder.nested_children.back()[0]);
-		child.dictionary = root_holder.nested_children_ptr.back()[0];
-		child.dictionary->format = "u";
-		break;
-	}
-	default:
-		throw InternalException("Unsupported Arrow type " + type.ToString());
-	}
-}
-
-void QueryResult::ToArrowSchema(ArrowSchema *out_schema, vector<LogicalType> &types, vector<string> &names,
-                                string &config_timezone) {
-	D_ASSERT(out_schema);
-	D_ASSERT(types.size() == names.size());
-	idx_t column_count = types.size();
-	// Allocate as unique_ptr first to cleanup properly on error
-	auto root_holder = make_unique<DuckDBArrowSchemaHolder>();
-
-	// Allocate the children
-	root_holder->children.resize(column_count);
-	root_holder->children_ptrs.resize(column_count, nullptr);
-	for (size_t i = 0; i < column_count; ++i) {
-		root_holder->children_ptrs[i] = &root_holder->children[i];
-	}
-	out_schema->children = root_holder->children_ptrs.data();
-	out_schema->n_children = column_count;
-
-	// Store the schema
-	out_schema->format = "+s"; // struct apparently
-	out_schema->flags = 0;
-	out_schema->metadata = nullptr;
-	out_schema->name = "duckdb_query_result";
-	out_schema->dictionary = nullptr;
-
-	// Configure all child schemas
-	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-
-		auto &child = root_holder->children[col_idx];
-		InitializeChild(child, names[col_idx]);
-		SetArrowFormat(*root_holder, child, types[col_idx], config_timezone);
-	}
-
-	// Release ownership to caller
-	out_schema->private_data = root_holder.release();
-	out_schema->release = ReleaseDuckDBArrowSchema;
-}
-
-string QueryResult::GetConfigTimezone(QueryResult &query_result) {
-	switch (query_result.type) {
-	case QueryResultType::MATERIALIZED_RESULT: {
-		auto actual_context = ((MaterializedQueryResult &)query_result).context.lock();
-		if (!actual_context) {
-			throw std::runtime_error("This connection is closed");
-		}
-		return ClientConfig::ExtractTimezoneFromConfig(actual_context->config);
-	}
-	case QueryResultType::STREAM_RESULT: {
-		return ClientConfig::ExtractTimezoneFromConfig(((StreamQueryResult &)query_result).context->config);
-	}
-	default:
-		throw std::runtime_error("Can't extract timezone configuration from query type ");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
-                                     vector<unique_ptr<ParsedExpression>> parsed_expressions)
-    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(move(parsed_expressions)),
-      child(move(child_p)) {
-	// bind the expressions
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
-                                     vector<unique_ptr<ParsedExpression>> parsed_expressions,
-                                     vector<unique_ptr<ParsedExpression>> groups_p)
-    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(move(parsed_expressions)),
-      groups(move(groups_p)), child(move(child_p)) {
-	// bind the expressions
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
-	auto child_ptr = child.get();
-	while (child_ptr->InheritsColumnBindings()) {
-		child_ptr = child_ptr->ChildRelation();
-	}
-	unique_ptr<QueryNode> result;
-	if (child_ptr->type == RelationType::JOIN_RELATION) {
-		// child node is a join: push projection into the child query node
-		result = child->GetQueryNode();
-	} else {
-		// child node is not a join: create a new select node and push the child as a table reference
-		auto select = make_unique<SelectNode>();
-		select->from_table = child->GetTableRef();
-		result = move(select);
-	}
-	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = (SelectNode &)*result;
-	if (!groups.empty()) {
-		// explicit groups provided: use standard handling
-		select_node.aggregate_handling = AggregateHandling::STANDARD_HANDLING;
-		select_node.groups.group_expressions.clear();
-		GroupingSet grouping_set;
-		for (idx_t i = 0; i < groups.size(); i++) {
-			select_node.groups.group_expressions.push_back(groups[i]->Copy());
-			grouping_set.insert(i);
-		}
-		select_node.groups.grouping_sets.push_back(move(grouping_set));
-	} else {
-		// no groups provided: automatically figure out groups (if any)
-		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;
-	}
-	select_node.select_list.clear();
-	for (auto &expr : expressions) {
-		select_node.select_list.push_back(expr->Copy());
-	}
-	return result;
-}
-
-string AggregateRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &AggregateRelation::Columns() {
-	return columns;
-}
-
-string AggregateRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Aggregate [";
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (i != 0) {
-			str += ", ";
-		}
-		str += expressions[i]->ToString();
-	}
-	str += "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
-    : Relation(child_p->context, RelationType::CREATE_TABLE_RELATION), child(move(child_p)),
-      schema_name(move(schema_name)), table_name(move(table_name)) {
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-BoundStatement CreateTableRelation::Bind(Binder &binder) {
-	auto select = make_unique<SelectStatement>();
-	select->node = child->GetQueryNode();
-
-	CreateStatement stmt;
-	auto info = make_unique<CreateTableInfo>();
-	info->schema = schema_name;
-	info->table = table_name;
-	info->query = move(select);
-	info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
-	stmt.info = move(info);
-	return binder.Bind((SQLStatement &)stmt);
-}
-
-const vector<ColumnDefinition> &CreateTableRelation::Columns() {
-	return columns;
-}
-
-string CreateTableRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Create Table\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string view_name_p, bool replace_p,
-                                       bool temporary_p)
-    : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(move(child_p)),
-      view_name(move(view_name_p)), replace(replace_p), temporary(temporary_p) {
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-BoundStatement CreateViewRelation::Bind(Binder &binder) {
-	auto select = make_unique<SelectStatement>();
-	select->node = child->GetQueryNode();
-
-	CreateStatement stmt;
-	auto info = make_unique<CreateViewInfo>();
-	info->query = move(select);
-	info->view_name = view_name;
-	info->temporary = temporary;
-	info->schema = "";
-	info->on_conflict = replace ? OnCreateConflict::REPLACE_ON_CONFLICT : OnCreateConflict::ERROR_ON_CONFLICT;
-	stmt.info = move(info);
-	return binder.Bind((SQLStatement &)stmt);
-}
-
-const vector<ColumnDefinition> &CreateViewRelation::Columns() {
-	return columns;
-}
-
-string CreateViewRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Create View\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p)
-    : Relation(left_p->context, RelationType::CROSS_PRODUCT_RELATION), left(move(left_p)), right(move(right_p)) {
-	if (left->context.GetContext() != right->context.GetContext()) {
-		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
-	}
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
-	result->from_table = GetTableRef();
-	return move(result);
-}
-
-unique_ptr<TableRef> CrossProductRelation::GetTableRef() {
-	auto cross_product_ref = make_unique<CrossProductRef>();
-	cross_product_ref->left = left->GetTableRef();
-	cross_product_ref->right = right->GetTableRef();
-	return move(cross_product_ref);
-}
-
-const vector<ColumnDefinition> &CrossProductRelation::Columns() {
-	return this->columns;
-}
-
-string CrossProductRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth);
-	str = "Cross Product";
-	return str + "\n" + left->ToString(depth + 1) + right->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-DeleteRelation::DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition_p,
-                               string schema_name_p, string table_name_p)
-    : Relation(context, RelationType::DELETE_RELATION), condition(move(condition_p)), schema_name(move(schema_name_p)),
-      table_name(move(table_name_p)) {
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-BoundStatement DeleteRelation::Bind(Binder &binder) {
-	auto basetable = make_unique<BaseTableRef>();
-	basetable->schema_name = schema_name;
-	basetable->table_name = table_name;
-
-	DeleteStatement stmt;
-	stmt.condition = condition ? condition->Copy() : nullptr;
-	stmt.table = move(basetable);
-	return binder.Bind((SQLStatement &)stmt);
-}
-
-const vector<ColumnDefinition> &DeleteRelation::Columns() {
-	return columns;
-}
-
-string DeleteRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "DELETE FROM " + table_name;
-	if (condition) {
-		str += " WHERE " + condition->ToString();
-	}
-	return str;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-DistinctRelation::DistinctRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::DISTINCT_RELATION), child(move(child_p)) {
-	vector<ColumnDefinition> dummy_columns;
-	context.GetContext()->TryBindRelation(*this, dummy_columns);
-}
-
-unique_ptr<QueryNode> DistinctRelation::GetQueryNode() {
-	auto child_node = child->GetQueryNode();
-	child_node->modifiers.push_back(make_unique<DistinctModifier>());
-	return child_node;
-}
-
-string DistinctRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &DistinctRelation::Columns() {
-	return child->Columns();
-}
-
-string DistinctRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Distinct\n";
-	return str + child->ToString(depth + 1);
-	;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(move(child_p)) {
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-BoundStatement ExplainRelation::Bind(Binder &binder) {
-	auto select = make_unique<SelectStatement>();
-	select->node = child->GetQueryNode();
-	ExplainStatement explain(move(select));
-	return binder.Bind((SQLStatement &)explain);
-}
-
-const vector<ColumnDefinition> &ExplainRelation::Columns() {
-	return columns;
-}
-
-string ExplainRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Explain\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-FilterRelation::FilterRelation(shared_ptr<Relation> child_p, unique_ptr<ParsedExpression> condition_p)
-    : Relation(child_p->context, RelationType::FILTER_RELATION), condition(move(condition_p)), child(move(child_p)) {
-	vector<ColumnDefinition> dummy_columns;
-	context.GetContext()->TryBindRelation(*this, dummy_columns);
-}
-
-unique_ptr<QueryNode> FilterRelation::GetQueryNode() {
-	auto child_ptr = child.get();
-	while (child_ptr->InheritsColumnBindings()) {
-		child_ptr = child_ptr->ChildRelation();
-	}
-	if (child_ptr->type == RelationType::JOIN_RELATION) {
-		// child node is a join: push filter into WHERE clause of select node
-		auto child_node = child->GetQueryNode();
-		D_ASSERT(child_node->type == QueryNodeType::SELECT_NODE);
-		auto &select_node = (SelectNode &)*child_node;
-		if (!select_node.where_clause) {
-			select_node.where_clause = condition->Copy();
-		} else {
-			select_node.where_clause = make_unique<ConjunctionExpression>(
-			    ExpressionType::CONJUNCTION_AND, move(select_node.where_clause), condition->Copy());
-		}
-		return child_node;
-	} else {
-		auto result = make_unique<SelectNode>();
-		result->select_list.push_back(make_unique<StarExpression>());
-		result->from_table = child->GetTableRef();
-		result->where_clause = condition->Copy();
-		return move(result);
-	}
-}
-
-string FilterRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &FilterRelation::Columns() {
-	return child->Columns();
-}
-
-string FilterRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Filter [" + condition->ToString() + "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-InsertRelation::InsertRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
-    : Relation(child_p->context, RelationType::INSERT_RELATION), child(move(child_p)), schema_name(move(schema_name)),
-      table_name(move(table_name)) {
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-BoundStatement InsertRelation::Bind(Binder &binder) {
-	InsertStatement stmt;
-	auto select = make_unique<SelectStatement>();
-	select->node = child->GetQueryNode();
-
-	stmt.schema = schema_name;
-	stmt.table = table_name;
-	stmt.select_statement = move(select);
-	return binder.Bind((SQLStatement &)stmt);
-}
-
-const vector<ColumnDefinition> &InsertRelation::Columns() {
-	return columns;
-}
-
-string InsertRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Insert\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p,
-                           unique_ptr<ParsedExpression> condition_p, JoinType type)
-    : Relation(left_p->context, RelationType::JOIN_RELATION), left(move(left_p)), right(move(right_p)),
-      condition(move(condition_p)), join_type(type) {
-	if (left->context.GetContext() != right->context.GetContext()) {
-		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
-	}
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, vector<string> using_columns_p,
-                           JoinType type)
-    : Relation(left_p->context, RelationType::JOIN_RELATION), left(move(left_p)), right(move(right_p)),
-      using_columns(move(using_columns_p)), join_type(type) {
-	if (left->context.GetContext() != right->context.GetContext()) {
-		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
-	}
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-unique_ptr<QueryNode> JoinRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
-	result->from_table = GetTableRef();
-	return move(result);
-}
-
-unique_ptr<TableRef> JoinRelation::GetTableRef() {
-	auto join_ref = make_unique<JoinRef>();
-	join_ref->left = left->GetTableRef();
-	join_ref->right = right->GetTableRef();
-	if (condition) {
-		join_ref->condition = condition->Copy();
-	}
-	join_ref->using_columns = using_columns;
-	join_ref->type = join_type;
-	return move(join_ref);
-}
-
-const vector<ColumnDefinition> &JoinRelation::Columns() {
-	return this->columns;
-}
-
-string JoinRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth);
-	str += "Join " + JoinTypeToString(join_type);
-	if (condition) {
-		str += " " + condition->GetName();
-	}
-
-	return str + "\n" + left->ToString(depth + 1) + "\n" + right->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-LimitRelation::LimitRelation(shared_ptr<Relation> child_p, int64_t limit, int64_t offset)
-    : Relation(child_p->context, RelationType::PROJECTION_RELATION), limit(limit), offset(offset),
-      child(move(child_p)) {
-}
-
-unique_ptr<QueryNode> LimitRelation::GetQueryNode() {
-	auto child_node = child->GetQueryNode();
-	auto limit_node = make_unique<LimitModifier>();
-	if (limit >= 0) {
-		limit_node->limit = make_unique<ConstantExpression>(Value::BIGINT(limit));
-	}
-	if (offset > 0) {
-		limit_node->offset = make_unique<ConstantExpression>(Value::BIGINT(offset));
-	}
-
-	child_node->modifiers.push_back(move(limit_node));
-	return child_node;
-}
-
-string LimitRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &LimitRelation::Columns() {
-	return child->Columns();
-}
-
-string LimitRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Limit " + to_string(limit);
-	if (offset > 0) {
-		str += " Offset " + to_string(offset);
-	}
-	str += "\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-OrderRelation::OrderRelation(shared_ptr<Relation> child_p, vector<OrderByNode> orders)
-    : Relation(child_p->context, RelationType::ORDER_RELATION), orders(move(orders)), child(move(child_p)) {
-	// bind the expressions
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-unique_ptr<QueryNode> OrderRelation::GetQueryNode() {
-	auto select = make_unique<SelectNode>();
-	select->from_table = child->GetTableRef();
-	select->select_list.push_back(make_unique<StarExpression>());
-	auto order_node = make_unique<OrderModifier>();
-	for (idx_t i = 0; i < orders.size(); i++) {
-		order_node->orders.emplace_back(orders[i].type, orders[i].null_order, orders[i].expression->Copy());
-	}
-	select->modifiers.push_back(move(order_node));
-	return move(select);
-}
-
-string OrderRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &OrderRelation::Columns() {
-	return columns;
-}
-
-string OrderRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Order [";
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (i != 0) {
-			str += ", ";
-		}
-		str += orders[i].expression->ToString() + (orders[i].type == OrderType::ASCENDING ? " ASC" : " DESC");
-	}
-	str += "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-ProjectionRelation::ProjectionRelation(shared_ptr<Relation> child_p,
-                                       vector<unique_ptr<ParsedExpression>> parsed_expressions, vector<string> aliases)
-    : Relation(child_p->context, RelationType::PROJECTION_RELATION), expressions(move(parsed_expressions)),
-      child(move(child_p)) {
-	if (!aliases.empty()) {
-		if (aliases.size() != expressions.size()) {
-			throw ParserException("Aliases list length must match expression list length!");
-		}
-		for (idx_t i = 0; i < aliases.size(); i++) {
-			expressions[i]->alias = aliases[i];
-		}
-	}
-	// bind the expressions
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-unique_ptr<QueryNode> ProjectionRelation::GetQueryNode() {
-	auto child_ptr = child.get();
-	while (child_ptr->InheritsColumnBindings()) {
-		child_ptr = child_ptr->ChildRelation();
-	}
-	unique_ptr<QueryNode> result;
-	if (child_ptr->type == RelationType::JOIN_RELATION) {
-		// child node is a join: push projection into the child query node
-		result = child->GetQueryNode();
-	} else {
-		// child node is not a join: create a new select node and push the child as a table reference
-		auto select = make_unique<SelectNode>();
-		select->from_table = child->GetTableRef();
-		result = move(select);
-	}
-	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = (SelectNode &)*result;
-	select_node.aggregate_handling = AggregateHandling::NO_AGGREGATES_ALLOWED;
-	select_node.select_list.clear();
-	for (auto &expr : expressions) {
-		select_node.select_list.push_back(expr->Copy());
-	}
-	return result;
-}
-
-string ProjectionRelation::GetAlias() {
-	return child->GetAlias();
-}
-
-const vector<ColumnDefinition> &ProjectionRelation::Columns() {
-	return columns;
-}
-
-string ProjectionRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Projection [";
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (i != 0) {
-			str += ", ";
-		}
-		str += expressions[i]->ToString() + " as " + expressions[i]->alias;
-	}
-	str += "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-QueryRelation::QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt_p,
-                             string alias_p)
-    : Relation(context, RelationType::QUERY_RELATION), select_stmt(move(select_stmt_p)), alias(move(alias_p)) {
-	context->TryBindRelation(*this, this->columns);
-}
-
-QueryRelation::~QueryRelation() {
-}
-
-unique_ptr<SelectStatement> QueryRelation::ParseStatement(ClientContext &context, const string &query,
-                                                          const string &error) {
-	Parser parser(context.GetParserOptions());
-	parser.ParseQuery(query);
-	if (parser.statements.size() != 1) {
-		throw ParserException(error);
-	}
-	if (parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException(error);
-	}
-	return unique_ptr_cast<SQLStatement, SelectStatement>(move(parser.statements[0]));
-}
-
-unique_ptr<SelectStatement> QueryRelation::GetSelectStatement() {
-	return unique_ptr_cast<SQLStatement, SelectStatement>(select_stmt->Copy());
-}
-
-unique_ptr<QueryNode> QueryRelation::GetQueryNode() {
-	auto select = GetSelectStatement();
-	return move(select->node);
-}
-
-unique_ptr<TableRef> QueryRelation::GetTableRef() {
-	auto subquery_ref = make_unique<SubqueryRef>(GetSelectStatement(), GetAlias());
-	return move(subquery_ref);
-}
-
-string QueryRelation::GetAlias() {
-	return alias;
-}
-
-const vector<ColumnDefinition> &QueryRelation::Columns() {
-	return columns;
-}
-
-string QueryRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "Subquery";
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, string csv_file_p,
-                                 vector<ColumnDefinition> columns_p, bool auto_detect, string alias_p)
-    : Relation(context, RelationType::READ_CSV_RELATION), csv_file(move(csv_file_p)), auto_detect(auto_detect),
-      alias(move(alias_p)), columns(move(columns_p)) {
-	if (alias.empty()) {
-		alias = StringUtil::Split(csv_file, ".")[0];
-	}
-}
-
-unique_ptr<QueryNode> ReadCSVRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
-	result->from_table = GetTableRef();
-	return move(result);
-}
-
-unique_ptr<TableRef> ReadCSVRelation::GetTableRef() {
-	auto table_ref = make_unique<TableFunctionRef>();
-	table_ref->alias = alias;
-	vector<unique_ptr<ParsedExpression>> children;
-	// CSV file
-	children.push_back(make_unique<ConstantExpression>(Value(csv_file)));
-	if (!auto_detect) {
-		// parameters
-		child_list_t<Value> column_names;
-		for (idx_t i = 0; i < columns.size(); i++) {
-			column_names.push_back(make_pair(columns[i].Name(), Value(columns[i].Type().ToString())));
-		}
-		auto colnames = make_unique<ConstantExpression>(Value::STRUCT(move(column_names)));
-		children.push_back(make_unique<ComparisonExpression>(
-		    ExpressionType::COMPARE_EQUAL, make_unique<ColumnRefExpression>("columns"), move(colnames)));
-	} else {
-		children.push_back(make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL,
-		                                                     make_unique<ColumnRefExpression>("auto_detect"),
-		                                                     make_unique<ConstantExpression>(Value::BOOLEAN(true))));
-	}
-	table_ref->function = make_unique<FunctionExpression>("read_csv", move(children));
-	return move(table_ref);
-}
-
-string ReadCSVRelation::GetAlias() {
-	return alias;
-}
-
-const vector<ColumnDefinition> &ReadCSVRelation::Columns() {
-	return columns;
-}
-
-string ReadCSVRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "Read CSV [" + csv_file + "]";
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-SetOpRelation::SetOpRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, SetOperationType setop_type_p)
-    : Relation(left_p->context, RelationType::SET_OPERATION_RELATION), left(move(left_p)), right(move(right_p)),
-      setop_type(setop_type_p) {
-	if (left->context.GetContext() != right->context.GetContext()) {
-		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
-	}
-	vector<ColumnDefinition> dummy_columns;
-	context.GetContext()->TryBindRelation(*this, dummy_columns);
-}
-
-unique_ptr<QueryNode> SetOpRelation::GetQueryNode() {
-	auto result = make_unique<SetOperationNode>();
-	if (setop_type == SetOperationType::EXCEPT || setop_type == SetOperationType::INTERSECT) {
-		result->modifiers.push_back(make_unique<DistinctModifier>());
-	}
-	result->left = left->GetQueryNode();
-	result->right = right->GetQueryNode();
-	result->setop_type = setop_type;
-	return move(result);
-}
-
-string SetOpRelation::GetAlias() {
-	return left->GetAlias();
-}
-
-const vector<ColumnDefinition> &SetOpRelation::Columns() {
-	return left->Columns();
-}
-
-string SetOpRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth);
-	switch (setop_type) {
-	case SetOperationType::UNION:
-		str += "Union";
-		break;
-	case SetOperationType::EXCEPT:
-		str += "Except";
-		break;
-	case SetOperationType::INTERSECT:
-		str += "Intersect";
-		break;
-	default:
-		throw InternalException("Unknown setop type");
-	}
-	return str + "\n" + left->ToString(depth + 1) + right->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-SubqueryRelation::SubqueryRelation(shared_ptr<Relation> child_p, string alias_p)
-    : Relation(child_p->context, RelationType::SUBQUERY_RELATION), child(move(child_p)), alias(move(alias_p)) {
-	vector<ColumnDefinition> dummy_columns;
-	context.GetContext()->TryBindRelation(*this, dummy_columns);
-}
-
-unique_ptr<QueryNode> SubqueryRelation::GetQueryNode() {
-	return child->GetQueryNode();
-}
-
-string SubqueryRelation::GetAlias() {
-	return alias;
-}
-
-const vector<ColumnDefinition> &SubqueryRelation::Columns() {
-	return child->Columns();
-}
-
-string SubqueryRelation::ToString(idx_t depth) {
-	return child->ToString(depth);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-TableFunctionRelation::TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name_p,
-                                             vector<Value> parameters_p, named_parameter_map_t named_parameters,
-                                             shared_ptr<Relation> input_relation_p)
-    : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
-      named_parameters(move(named_parameters)), input_relation(move(input_relation_p)) {
-	context->TryBindRelation(*this, this->columns);
-}
-TableFunctionRelation::TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name_p,
-                                             vector<Value> parameters_p,
-
-                                             shared_ptr<Relation> input_relation_p)
-    : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
-      input_relation(move(input_relation_p)) {
-	context->TryBindRelation(*this, this->columns);
-}
-
-unique_ptr<QueryNode> TableFunctionRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
-	result->from_table = GetTableRef();
-	return move(result);
-}
-
-unique_ptr<TableRef> TableFunctionRelation::GetTableRef() {
-	vector<unique_ptr<ParsedExpression>> children;
-	if (input_relation) { // input relation becomes first parameter if present, always
-		auto subquery = make_unique<SubqueryExpression>();
-		subquery->subquery = make_unique<SelectStatement>();
-		subquery->subquery->node = input_relation->GetQueryNode();
-		subquery->subquery_type = SubqueryType::SCALAR;
-		children.push_back(move(subquery));
-	}
-	for (auto &parameter : parameters) {
-		children.push_back(make_unique<ConstantExpression>(parameter));
-	}
-
-	for (auto &parameter : named_parameters) {
-		// Hackity-hack some comparisons with column refs
-		// This is all but pretty, basically the named parameter is the column, the table is empty because that's what
-		// the function binder likes
-		auto column_ref = make_unique<ColumnRefExpression>(parameter.first);
-		auto constant_value = make_unique<ConstantExpression>(parameter.second);
-		auto comparison =
-		    make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, move(column_ref), move(constant_value));
-		children.push_back(move(comparison));
-	}
-
-	auto table_function = make_unique<TableFunctionRef>();
-	auto function = make_unique<FunctionExpression>(name, move(children));
-	table_function->function = move(function);
-	return move(table_function);
-}
-
-string TableFunctionRelation::GetAlias() {
-	return name;
-}
-
-const vector<ColumnDefinition> &TableFunctionRelation::Columns() {
-	return columns;
-}
-
-string TableFunctionRelation::ToString(idx_t depth) {
-	string function_call = name + "(";
-	for (idx_t i = 0; i < parameters.size(); i++) {
-		if (i > 0) {
-			function_call += ", ";
-		}
-		function_call += parameters[i].ToString();
-	}
-	function_call += ")";
-	return RenderWhitespace(depth) + function_call;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-TableRelation::TableRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description)
-    : Relation(context, RelationType::TABLE_RELATION), description(move(description)) {
-}
-
-unique_ptr<QueryNode> TableRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
-	result->from_table = GetTableRef();
-	return move(result);
-}
-
-unique_ptr<TableRef> TableRelation::GetTableRef() {
-	auto table_ref = make_unique<BaseTableRef>();
-	table_ref->schema_name = description->schema;
-	table_ref->table_name = description->table;
-	return move(table_ref);
-}
-
-string TableRelation::GetAlias() {
-	return description->table;
-}
-
-const vector<ColumnDefinition> &TableRelation::Columns() {
-	return description->columns;
-}
-
-string TableRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "Scan Table [" + description->table + "]";
-}
-
-static unique_ptr<ParsedExpression> ParseCondition(ClientContext &context, const string &condition) {
-	if (!condition.empty()) {
-		auto expression_list = Parser::ParseExpressionList(condition, context.GetParserOptions());
-		if (expression_list.size() != 1) {
-			throw ParserException("Expected a single expression as filter condition");
-		}
-		return move(expression_list[0]);
-	} else {
-		return nullptr;
-	}
-}
-
-void TableRelation::Update(const string &update_list, const string &condition) {
-	vector<string> update_columns;
-	vector<unique_ptr<ParsedExpression>> expressions;
-	auto cond = ParseCondition(*context.GetContext(), condition);
-	Parser::ParseUpdateList(update_list, update_columns, expressions, context.GetContext()->GetParserOptions());
-	auto update = make_shared<UpdateRelation>(context, move(cond), description->schema, description->table,
-	                                          move(update_columns), move(expressions));
-	update->Execute();
-}
-
-void TableRelation::Delete(const string &condition) {
-	auto cond = ParseCondition(*context.GetContext(), condition);
-	auto del = make_shared<DeleteRelation>(context, move(cond), description->schema, description->table);
-	del->Execute();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-UpdateRelation::UpdateRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition_p,
-                               string schema_name_p, string table_name_p, vector<string> update_columns_p,
-                               vector<unique_ptr<ParsedExpression>> expressions_p)
-    : Relation(context, RelationType::UPDATE_RELATION), condition(move(condition_p)), schema_name(move(schema_name_p)),
-      table_name(move(table_name_p)), update_columns(move(update_columns_p)), expressions(move(expressions_p)) {
-	D_ASSERT(update_columns.size() == expressions.size());
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-BoundStatement UpdateRelation::Bind(Binder &binder) {
-	auto basetable = make_unique<BaseTableRef>();
-	basetable->schema_name = schema_name;
-	basetable->table_name = table_name;
-
-	UpdateStatement stmt;
-	stmt.condition = condition ? condition->Copy() : nullptr;
-	stmt.table = move(basetable);
-	stmt.columns = update_columns;
-	for (auto &expr : expressions) {
-		stmt.expressions.push_back(expr->Copy());
-	}
-	return binder.Bind((SQLStatement &)stmt);
-}
-
-const vector<ColumnDefinition> &UpdateRelation::Columns() {
-	return columns;
-}
-
-string UpdateRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "UPDATE " + table_name + " SET\n";
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		str += update_columns[i] + " = " + expressions[i]->ToString() + "\n";
-	}
-	if (condition) {
-		str += "WHERE " + condition->ToString() + "\n";
-	}
-	return str;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
-                             vector<string> names_p, string alias_p)
-    : Relation(context, RelationType::VALUE_LIST_RELATION), names(move(names_p)), alias(move(alias_p)) {
-	// create constant expressions for the values
-	for (idx_t row_idx = 0; row_idx < values.size(); row_idx++) {
-		auto &list = values[row_idx];
-		vector<unique_ptr<ParsedExpression>> expressions;
-		for (idx_t col_idx = 0; col_idx < list.size(); col_idx++) {
-			expressions.push_back(make_unique<ConstantExpression>(list[col_idx]));
-		}
-		this->expressions.push_back(move(expressions));
-	}
-	context->TryBindRelation(*this, this->columns);
-}
-
-ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, const string &values_list,
-                             vector<string> names_p, string alias_p)
-    : Relation(context, RelationType::VALUE_LIST_RELATION), names(move(names_p)), alias(move(alias_p)) {
-	this->expressions = Parser::ParseValuesList(values_list, context->GetParserOptions());
-	context->TryBindRelation(*this, this->columns);
-}
-
-unique_ptr<QueryNode> ValueRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
-	result->from_table = GetTableRef();
-	return move(result);
-}
-
-unique_ptr<TableRef> ValueRelation::GetTableRef() {
-	auto table_ref = make_unique<ExpressionListRef>();
-	// set the expected types/names
-	if (columns.empty()) {
-		// no columns yet: only set up names
-		for (idx_t i = 0; i < names.size(); i++) {
-			table_ref->expected_names.push_back(names[i]);
-		}
-	} else {
-		for (idx_t i = 0; i < columns.size(); i++) {
-			table_ref->expected_names.push_back(columns[i].Name());
-			table_ref->expected_types.push_back(columns[i].Type());
-			D_ASSERT(names.size() == 0 || columns[i].Name() == names[i]);
-		}
-	}
-	// copy the expressions
-	for (auto &expr_list : expressions) {
-		vector<unique_ptr<ParsedExpression>> copied_list;
-		copied_list.reserve(expr_list.size());
-		for (auto &expr : expr_list) {
-			copied_list.push_back(expr->Copy());
-		}
-		table_ref->values.push_back(move(copied_list));
-	}
-	table_ref->alias = GetAlias();
-	return move(table_ref);
-}
-
-string ValueRelation::GetAlias() {
-	return alias;
-}
-
-const vector<ColumnDefinition> &ValueRelation::Columns() {
-	return columns;
-}
-
-string ValueRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Values ";
-	for (idx_t row_idx = 0; row_idx < expressions.size(); row_idx++) {
-		auto &list = expressions[row_idx];
-		str += row_idx > 0 ? ", (" : "(";
-		for (idx_t col_idx = 0; col_idx < list.size(); col_idx++) {
-			str += col_idx > 0 ? ", " : "";
-			str += list[col_idx]->ToString();
-		}
-		str += ")";
-	}
-	str += "\n";
-	return str;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-ViewRelation::ViewRelation(const std::shared_ptr<ClientContext> &context, string schema_name_p, string view_name_p)
-    : Relation(context, RelationType::VIEW_RELATION), schema_name(move(schema_name_p)), view_name(move(view_name_p)) {
-	context->TryBindRelation(*this, this->columns);
-}
-
-unique_ptr<QueryNode> ViewRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
-	result->from_table = GetTableRef();
-	return move(result);
-}
-
-unique_ptr<TableRef> ViewRelation::GetTableRef() {
-	auto table_ref = make_unique<BaseTableRef>();
-	table_ref->schema_name = schema_name;
-	table_ref->table_name = view_name;
-	return move(table_ref);
-}
-
-string ViewRelation::GetAlias() {
-	return view_name;
-}
-
-const vector<ColumnDefinition> &ViewRelation::Columns() {
-	return columns;
-}
-
-string ViewRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "View [" + view_name + "]";
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-WriteCSVRelation::WriteCSVRelation(shared_ptr<Relation> child_p, string csv_file_p)
-    : Relation(child_p->context, RelationType::WRITE_CSV_RELATION), child(move(child_p)), csv_file(move(csv_file_p)) {
-	context.GetContext()->TryBindRelation(*this, this->columns);
-}
-
-BoundStatement WriteCSVRelation::Bind(Binder &binder) {
-	CopyStatement copy;
-	copy.select_statement = child->GetQueryNode();
-	auto info = make_unique<CopyInfo>();
-	info->is_from = false;
-	info->file_path = csv_file;
-	info->format = "csv";
-	copy.info = move(info);
-	return binder.Bind((SQLStatement &)copy);
-}
-
-const vector<ColumnDefinition> &WriteCSVRelation::Columns() {
-	return columns;
-}
-
-string WriteCSVRelation::ToString(idx_t depth) {
-	string str = RenderWhitespace(depth) + "Write To CSV [" + csv_file + "]\n";
-	return str + child->ToString(depth + 1);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-shared_ptr<Relation> Relation::Project(const string &select_list) {
-	return Project(select_list, vector<string>());
-}
-
-shared_ptr<Relation> Relation::Project(const string &expression, const string &alias) {
-	return Project(expression, vector<string>({alias}));
-}
-
-shared_ptr<Relation> Relation::Project(const string &select_list, const vector<string> &aliases) {
-	auto expressions = Parser::ParseExpressionList(select_list, context.GetContext()->GetParserOptions());
-	return make_shared<ProjectionRelation>(shared_from_this(), move(expressions), aliases);
-}
-
-shared_ptr<Relation> Relation::Project(const vector<string> &expressions) {
-	vector<string> aliases;
-	return Project(expressions, aliases);
-}
-
-static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientContext &context,
-                                                                       const vector<string> &expressions) {
-	if (expressions.empty()) {
-		throw ParserException("Zero expressions provided");
-	}
-	vector<unique_ptr<ParsedExpression>> result_list;
-	for (auto &expr : expressions) {
-		auto expression_list = Parser::ParseExpressionList(expr, context.GetParserOptions());
-		if (expression_list.size() != 1) {
-			throw ParserException("Expected a single expression in the expression list");
-		}
-		result_list.push_back(move(expression_list[0]));
-	}
-	return result_list;
-}
-
-shared_ptr<Relation> Relation::Project(const vector<string> &expressions, const vector<string> &aliases) {
-	auto result_list = StringListToExpressionList(*context.GetContext(), expressions);
-	return make_shared<ProjectionRelation>(shared_from_this(), move(result_list), aliases);
-}
-
-shared_ptr<Relation> Relation::Filter(const string &expression) {
-	auto expression_list = Parser::ParseExpressionList(expression, context.GetContext()->GetParserOptions());
-	if (expression_list.size() != 1) {
-		throw ParserException("Expected a single expression as filter condition");
-	}
-	return make_shared<FilterRelation>(shared_from_this(), move(expression_list[0]));
-}
-
-shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
-	// if there are multiple expressions, we AND them together
-	auto expression_list = StringListToExpressionList(*context.GetContext(), expressions);
-	D_ASSERT(!expression_list.empty());
-
-	auto expr = move(expression_list[0]);
-	for (idx_t i = 1; i < expression_list.size(); i++) {
-		expr =
-		    make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, move(expr), move(expression_list[i]));
-	}
-	return make_shared<FilterRelation>(shared_from_this(), move(expr));
-}
-
-shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
-	return make_shared<LimitRelation>(shared_from_this(), limit, offset);
-}
-
-shared_ptr<Relation> Relation::Order(const string &expression) {
-	auto order_list = Parser::ParseOrderList(expression, context.GetContext()->GetParserOptions());
-	return make_shared<OrderRelation>(shared_from_this(), move(order_list));
-}
-
-shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
-	if (expressions.empty()) {
-		throw ParserException("Zero ORDER BY expressions provided");
-	}
-	vector<OrderByNode> order_list;
-	for (auto &expression : expressions) {
-		auto inner_list = Parser::ParseOrderList(expression, context.GetContext()->GetParserOptions());
-		if (inner_list.size() != 1) {
-			throw ParserException("Expected a single ORDER BY expression in the expression list");
-		}
-		order_list.push_back(move(inner_list[0]));
-	}
-	return make_shared<OrderRelation>(shared_from_this(), move(order_list));
-}
-
-shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type) {
-	auto expression_list = Parser::ParseExpressionList(condition, context.GetContext()->GetParserOptions());
-	D_ASSERT(!expression_list.empty());
-
-	if (expression_list.size() > 1 || expression_list[0]->type == ExpressionType::COLUMN_REF) {
-		// multiple columns or single column ref: the condition is a USING list
-		vector<string> using_columns;
-		for (auto &expr : expression_list) {
-			if (expr->type != ExpressionType::COLUMN_REF) {
-				throw ParserException("Expected a single expression as join condition");
-			}
-			auto &colref = (ColumnRefExpression &)*expr;
-			if (colref.IsQualified()) {
-				throw ParserException("Expected unqualified column for column in USING clause");
-			}
-			using_columns.push_back(colref.column_names[0]);
-		}
-		return make_shared<JoinRelation>(shared_from_this(), other, move(using_columns), type);
-	} else {
-		// single expression that is not a column reference: use the expression as a join condition
-		return make_shared<JoinRelation>(shared_from_this(), other, move(expression_list[0]), type);
-	}
-}
-
-shared_ptr<Relation> Relation::CrossProduct(const shared_ptr<Relation> &other) {
-	return make_shared<CrossProductRelation>(shared_from_this(), other);
-}
-
-shared_ptr<Relation> Relation::Union(const shared_ptr<Relation> &other) {
-	return make_shared<SetOpRelation>(shared_from_this(), other, SetOperationType::UNION);
-}
-
-shared_ptr<Relation> Relation::Except(const shared_ptr<Relation> &other) {
-	return make_shared<SetOpRelation>(shared_from_this(), other, SetOperationType::EXCEPT);
-}
-
-shared_ptr<Relation> Relation::Intersect(const shared_ptr<Relation> &other) {
-	return make_shared<SetOpRelation>(shared_from_this(), other, SetOperationType::INTERSECT);
-}
-
-shared_ptr<Relation> Relation::Distinct() {
-	return make_shared<DistinctRelation>(shared_from_this());
-}
-
-shared_ptr<Relation> Relation::Alias(const string &alias) {
-	return make_shared<SubqueryRelation>(shared_from_this(), alias);
-}
-
-shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
-	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list));
-}
-
-shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
-	auto groups = Parser::ParseExpressionList(group_list, context.GetContext()->GetParserOptions());
-	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list), move(groups));
-}
-
-shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
-	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
-	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list));
-}
-
-shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
-	auto group_list = StringListToExpressionList(*context.GetContext(), groups);
-	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list), move(group_list));
-}
-
-string Relation::GetAlias() {
-	return "relation";
-}
-
-unique_ptr<TableRef> Relation::GetTableRef() {
-	auto select = make_unique<SelectStatement>();
-	select->node = GetQueryNode();
-	return make_unique<SubqueryRef>(move(select), GetAlias());
-}
-
-unique_ptr<QueryResult> Relation::Execute() {
-	return context.GetContext()->Execute(shared_from_this());
-}
-
-BoundStatement Relation::Bind(Binder &binder) {
-	SelectStatement stmt;
-	stmt.node = GetQueryNode();
-	return binder.Bind((SQLStatement &)stmt);
-}
-
-void Relation::Insert(const string &table_name) {
-	Insert(DEFAULT_SCHEMA, table_name);
-}
-
-void Relation::Insert(const string &schema_name, const string &table_name) {
-	auto insert = make_shared<InsertRelation>(shared_from_this(), schema_name, table_name);
-	auto res = insert->Execute();
-	if (!res->success) {
-		throw Exception("Failed to insert into table '" + table_name + "': " + res->error);
-	}
-}
-
-void Relation::Insert(const vector<vector<Value>> &values) {
-	vector<string> column_names;
-	auto rel = make_shared<ValueRelation>(context.GetContext(), values, move(column_names), "values");
-	rel->Insert(GetAlias());
-}
-
-void Relation::Create(const string &table_name) {
-	Create(DEFAULT_SCHEMA, table_name);
-}
-
-void Relation::Create(const string &schema_name, const string &table_name) {
-	auto create = make_shared<CreateTableRelation>(shared_from_this(), schema_name, table_name);
-	auto res = create->Execute();
-	if (!res->success) {
-		throw Exception("Failed to create table '" + table_name + "': " + res->error);
-	}
-}
-
-void Relation::WriteCSV(const string &csv_file) {
-	auto write_csv = make_shared<WriteCSVRelation>(shared_from_this(), csv_file);
-	auto res = write_csv->Execute();
-	if (!res->success) {
-		throw Exception("Failed to write '" + csv_file + "': " + res->error);
-	}
-}
-
-shared_ptr<Relation> Relation::CreateView(const string &name, bool replace, bool temporary) {
-	auto view = make_shared<CreateViewRelation>(shared_from_this(), name, replace, temporary);
-	auto res = view->Execute();
-	if (!res->success) {
-		throw Exception("Failed to create view '" + name + "': " + res->error);
-	}
-	return shared_from_this();
-}
-
-unique_ptr<QueryResult> Relation::Query(const string &sql) {
-	return context.GetContext()->Query(sql, false);
-}
-
-unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
-	CreateView(name);
-	return Query(sql);
-}
-
-unique_ptr<QueryResult> Relation::Explain() {
-	auto explain = make_shared<ExplainRelation>(shared_from_this());
-	return explain->Execute();
-}
-
-void Relation::Update(const string &update, const string &condition) {
-	throw Exception("UPDATE can only be used on base tables!");
-}
-
-void Relation::Delete(const string &condition) {
-	throw Exception("DELETE can only be used on base tables!");
-}
-
-shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values,
-                                             const named_parameter_map_t &named_parameters) {
-	return make_shared<TableFunctionRelation>(context.GetContext(), fname, values, named_parameters,
-	                                          shared_from_this());
-}
-
-shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values) {
-	return make_shared<TableFunctionRelation>(context.GetContext(), fname, values, shared_from_this());
-}
-
-string Relation::ToString() {
-	string str;
-	str += "---------------------\n";
-	str += "--- Relation Tree ---\n";
-	str += "---------------------\n";
-	str += ToString(0);
-	str += "\n\n";
-	str += "---------------------\n";
-	str += "-- Result Columns  --\n";
-	str += "---------------------\n";
-	auto &cols = Columns();
-	for (idx_t i = 0; i < cols.size(); i++) {
-		str += "- " + cols[i].Name() + " (" + cols[i].Type().ToString() + ")\n";
-	}
-	return str;
-}
-
-// LCOV_EXCL_START
-unique_ptr<QueryNode> Relation::GetQueryNode() {
-	throw InternalException("Cannot create a query node from this node type");
-}
-
-void Relation::Head(idx_t limit) {
-	auto limit_node = Limit(limit);
-	limit_node->Execute()->Print();
-}
-// LCOV_EXCL_STOP
-
-void Relation::Print() {
-	Printer::Print(ToString());
-}
-
-string Relation::RenderWhitespace(idx_t depth) {
-	return string(depth * 2, ' ');
-}
-
-vector<shared_ptr<ExternalDependency>> Relation::GetAllDependencies() {
-	vector<shared_ptr<ExternalDependency>> all_dependencies;
-	Relation *cur = this;
-	while (cur) {
-		if (cur->extra_dependencies) {
-			all_dependencies.push_back(cur->extra_dependencies);
-		}
-		cur = ChildRelation();
-	}
-	return all_dependencies;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Access Mode
-//===--------------------------------------------------------------------===//
-void AccessModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-	if (parameter == "automatic") {
-		config.access_mode = AccessMode::AUTOMATIC;
-	} else if (parameter == "read_only") {
-		config.access_mode = AccessMode::READ_ONLY;
-	} else if (parameter == "read_write") {
-		config.access_mode = AccessMode::READ_WRITE;
-	} else {
-		throw InvalidInputException(
-		    "Unrecognized parameter for option ACCESS_MODE \"%s\". Expected READ_ONLY or READ_WRITE.", parameter);
-	}
-}
-
-Value AccessModeSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	switch (config.access_mode) {
-	case AccessMode::AUTOMATIC:
-		return "automatic";
-	case AccessMode::READ_ONLY:
-		return "read_only";
-	case AccessMode::READ_WRITE:
-		return "read_write";
-	default:
-		throw InternalException("Unknown access mode setting");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Checkpoint Threshold
-//===--------------------------------------------------------------------===//
-void CheckpointThresholdSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	idx_t new_limit = DBConfig::ParseMemoryLimit(input.ToString());
-	config.checkpoint_wal_size = new_limit;
-}
-
-Value CheckpointThresholdSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::BytesToHumanReadableString(config.checkpoint_wal_size));
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Checkpoint Abort
-//===--------------------------------------------------------------------===//
-void DebugCheckpointAbort::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto checkpoint_abort = StringUtil::Lower(input.ToString());
-	if (checkpoint_abort == "none") {
-		config.checkpoint_abort = CheckpointAbort::NO_ABORT;
-	} else if (checkpoint_abort == "before_truncate") {
-		config.checkpoint_abort = CheckpointAbort::DEBUG_ABORT_BEFORE_TRUNCATE;
-	} else if (checkpoint_abort == "before_header") {
-		config.checkpoint_abort = CheckpointAbort::DEBUG_ABORT_BEFORE_HEADER;
-	} else if (checkpoint_abort == "after_free_list_write") {
-		config.checkpoint_abort = CheckpointAbort::DEBUG_ABORT_AFTER_FREE_LIST_WRITE;
-	} else {
-		throw ParserException(
-		    "Unrecognized option for PRAGMA debug_checkpoint_abort, expected none, before_truncate or before_header");
-	}
-}
-
-Value DebugCheckpointAbort::GetSetting(ClientContext &context) {
-	return Value();
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Force External
-//===--------------------------------------------------------------------===//
-void DebugForceExternal::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).force_external = input.GetValue<bool>();
-}
-
-Value DebugForceExternal::GetSetting(ClientContext &context) {
-	return Value::BOOLEAN(ClientConfig::GetConfig(context).force_external);
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Force NoCrossProduct
-//===--------------------------------------------------------------------===//
-void DebugForceNoCrossProduct::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).force_no_cross_product = input.GetValue<bool>();
-}
-
-Value DebugForceNoCrossProduct::GetSetting(ClientContext &context) {
-	return Value::BOOLEAN(ClientConfig::GetConfig(context).force_no_cross_product);
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Many Free List blocks
-//===--------------------------------------------------------------------===//
-void DebugManyFreeListBlocks::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.debug_many_free_list_blocks = input.GetValue<bool>();
-}
-
-Value DebugManyFreeListBlocks::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.debug_many_free_list_blocks);
-}
-
-//===--------------------------------------------------------------------===//
-// Debug Window Mode
-//===--------------------------------------------------------------------===//
-void DebugWindowMode::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto param = StringUtil::Lower(input.ToString());
-	if (param == "window") {
-		config.window_mode = WindowAggregationMode::WINDOW;
-	} else if (param == "combine") {
-		config.window_mode = WindowAggregationMode::COMBINE;
-	} else if (param == "separate") {
-		config.window_mode = WindowAggregationMode::SEPARATE;
-	} else {
-		throw ParserException("Unrecognized option for PRAGMA debug_window_mode, expected window, combine or separate");
-	}
-}
-
-Value DebugWindowMode::GetSetting(ClientContext &context) {
-	return Value();
-}
-
-//===--------------------------------------------------------------------===//
-// Default Collation
-//===--------------------------------------------------------------------===//
-void DefaultCollationSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-	config.collation = parameter;
-}
-
-void DefaultCollationSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = input.ToString();
-	// bind the collation to verify that it exists
-	ExpressionBinder::TestCollation(context, parameter);
-	auto &config = DBConfig::GetConfig(context);
-	config.collation = parameter;
-}
-
-Value DefaultCollationSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(config.collation);
-}
-
-//===--------------------------------------------------------------------===//
-// Default Order
-//===--------------------------------------------------------------------===//
-void DefaultOrderSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-	if (parameter == "ascending" || parameter == "asc") {
-		config.default_order_type = OrderType::ASCENDING;
-	} else if (parameter == "descending" || parameter == "desc") {
-		config.default_order_type = OrderType::DESCENDING;
-	} else {
-		throw InvalidInputException("Unrecognized parameter for option DEFAULT_ORDER \"%s\". Expected ASC or DESC.",
-		                            parameter);
-	}
-}
-
-Value DefaultOrderSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	switch (config.default_order_type) {
-	case OrderType::ASCENDING:
-		return "asc";
-	case OrderType::DESCENDING:
-		return "desc";
-	default:
-		throw InternalException("Unknown order type setting");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Default Null Order
-//===--------------------------------------------------------------------===//
-void DefaultNullOrderSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-
-	if (parameter == "nulls_first" || parameter == "nulls first" || parameter == "null first" || parameter == "first") {
-		config.default_null_order = OrderByNullType::NULLS_FIRST;
-	} else if (parameter == "nulls_last" || parameter == "nulls last" || parameter == "null last" ||
-	           parameter == "last") {
-		config.default_null_order = OrderByNullType::NULLS_LAST;
-	} else {
-		throw ParserException(
-		    "Unrecognized parameter for option NULL_ORDER \"%s\", expected either NULLS FIRST or NULLS LAST",
-		    parameter);
-	}
-}
-
-Value DefaultNullOrderSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	switch (config.default_null_order) {
-	case OrderByNullType::NULLS_FIRST:
-		return "nulls_first";
-	case OrderByNullType::NULLS_LAST:
-		return "nulls_last";
-	default:
-		throw InternalException("Unknown null order setting");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Disabled Optimizer
-//===--------------------------------------------------------------------===//
-void DisabledOptimizersSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto list = StringUtil::Split(input.ToString(), ",");
-	set<OptimizerType> disabled_optimizers;
-	for (auto &entry : list) {
-		auto param = StringUtil::Lower(entry);
-		StringUtil::Trim(param);
-		if (param.empty()) {
-			continue;
-		}
-		disabled_optimizers.insert(OptimizerTypeFromString(param));
-	}
-	config.disabled_optimizers = move(disabled_optimizers);
-}
-
-Value DisabledOptimizersSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	string result;
-	for (auto &optimizer : config.disabled_optimizers) {
-		if (!result.empty()) {
-			result += ",";
-		}
-		result += OptimizerTypeToString(optimizer);
-	}
-	return Value(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Enable External Access
-//===--------------------------------------------------------------------===//
-void EnableExternalAccessSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto new_value = input.GetValue<bool>();
-	if (db && new_value) {
-		throw InvalidInputException("Cannot change enable_external_access setting while database is running");
-	}
-	config.enable_external_access = new_value;
-}
-
-Value EnableExternalAccessSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.enable_external_access);
-}
-
-//===--------------------------------------------------------------------===//
-// Enable Object Cache
-//===--------------------------------------------------------------------===//
-void EnableObjectCacheSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.object_cache_enable = input.GetValue<bool>();
-}
-
-Value EnableObjectCacheSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.object_cache_enable);
-}
-
-//===--------------------------------------------------------------------===//
-// Enable Profiling
-//===--------------------------------------------------------------------===//
-void EnableProfilingSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-
-	auto &config = ClientConfig::GetConfig(context);
-	if (parameter == "json") {
-		config.profiler_print_format = ProfilerPrintFormat::JSON;
-	} else if (parameter == "query_tree") {
-		config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE;
-	} else if (parameter == "query_tree_optimizer") {
-		config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE_OPTIMIZER;
-	} else {
-		throw ParserException(
-		    "Unrecognized print format %s, supported formats: [json, query_tree, query_tree_optimizer]", parameter);
-	}
-	config.enable_profiler = true;
-	config.emit_profiler_output = true;
-}
-
-Value EnableProfilingSetting::GetSetting(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	if (!config.enable_profiler) {
-		return Value();
-	}
-	switch (config.profiler_print_format) {
-	case ProfilerPrintFormat::JSON:
-		return Value("json");
-	case ProfilerPrintFormat::QUERY_TREE:
-		return Value("query_tree");
-	case ProfilerPrintFormat::QUERY_TREE_OPTIMIZER:
-		return Value("query_tree_optimizer");
-	default:
-		throw InternalException("Unsupported profiler print format");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Enable Progress Bar
-//===--------------------------------------------------------------------===//
-void EnableProgressBarSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).enable_progress_bar = input.GetValue<bool>();
-}
-
-Value EnableProgressBarSetting::GetSetting(ClientContext &context) {
-	return Value::BOOLEAN(ClientConfig::GetConfig(context).enable_progress_bar);
-}
-
-//===--------------------------------------------------------------------===//
-// Explain Output
-//===--------------------------------------------------------------------===//
-void ExplainOutputSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-	if (parameter == "all") {
-		ClientConfig::GetConfig(context).explain_output_type = ExplainOutputType::ALL;
-	} else if (parameter == "optimized_only") {
-		ClientConfig::GetConfig(context).explain_output_type = ExplainOutputType::OPTIMIZED_ONLY;
-	} else if (parameter == "physical_only") {
-		ClientConfig::GetConfig(context).explain_output_type = ExplainOutputType::PHYSICAL_ONLY;
-	} else {
-		throw ParserException("Unrecognized output type \"%s\", expected either ALL, OPTIMIZED_ONLY or PHYSICAL_ONLY",
-		                      parameter);
-	}
-}
-
-Value ExplainOutputSetting::GetSetting(ClientContext &context) {
-	switch (ClientConfig::GetConfig(context).explain_output_type) {
-	case ExplainOutputType::ALL:
-		return "all";
-	case ExplainOutputType::OPTIMIZED_ONLY:
-		return "optimized_only";
-	case ExplainOutputType::PHYSICAL_ONLY:
-		return "physical_only";
-	default:
-		throw InternalException("Unrecognized explain output type");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// External Threads Setting
-//===--------------------------------------------------------------------===//
-void ExternalThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.external_threads = input.GetValue<int64_t>();
-}
-
-Value ExternalThreadsSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BIGINT(config.external_threads);
-}
-
-//===--------------------------------------------------------------------===//
-// File Search Path
-//===--------------------------------------------------------------------===//
-void FileSearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = input.ToString();
-	auto &client_data = ClientData::Get(context);
-	client_data.file_search_path = parameter;
-}
-
-Value FileSearchPathSetting::GetSetting(ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	return Value(client_data.file_search_path);
-}
-
-//===--------------------------------------------------------------------===//
-// Force Compression
-//===--------------------------------------------------------------------===//
-void ForceCompressionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	auto compression = StringUtil::Lower(input.ToString());
-	if (compression == "none") {
-		config.force_compression = CompressionType::COMPRESSION_AUTO;
-	} else {
-		auto compression_type = CompressionTypeFromString(compression);
-		if (compression_type == CompressionType::COMPRESSION_AUTO) {
-			throw ParserException("Unrecognized option for PRAGMA force_compression, expected none, uncompressed, rle, "
-			                      "dictionary, pfor, bitpacking or fsst");
-		}
-		config.force_compression = compression_type;
-	}
-}
-
-Value ForceCompressionSetting::GetSetting(ClientContext &context) {
-	return Value();
-}
-
-//===--------------------------------------------------------------------===//
-// Log Query Path
-//===--------------------------------------------------------------------===//
-void LogQueryPathSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &client_data = ClientData::Get(context);
-	auto path = input.ToString();
-	if (path.empty()) {
-		// empty path: clean up query writer
-		client_data.log_query_writer = nullptr;
-	} else {
-		client_data.log_query_writer =
-		    make_unique<BufferedFileWriter>(FileSystem::GetFileSystem(context), path,
-		                                    BufferedFileWriter::DEFAULT_OPEN_FLAGS, client_data.file_opener.get());
-	}
-}
-
-Value LogQueryPathSetting::GetSetting(ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	return client_data.log_query_writer ? Value(client_data.log_query_writer->path) : Value();
-}
-
-//===--------------------------------------------------------------------===//
-// Maximum Expression Depth
-//===--------------------------------------------------------------------===//
-void MaximumExpressionDepthSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).max_expression_depth = input.GetValue<uint64_t>();
-}
-
-Value MaximumExpressionDepthSetting::GetSetting(ClientContext &context) {
-	return Value::UBIGINT(ClientConfig::GetConfig(context).max_expression_depth);
-}
-
-//===--------------------------------------------------------------------===//
-// Maximum Memory
-//===--------------------------------------------------------------------===//
-void MaximumMemorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.maximum_memory = DBConfig::ParseMemoryLimit(input.ToString());
-	if (db) {
-		BufferManager::GetBufferManager(*db).SetLimit(config.maximum_memory);
-	}
-}
-
-Value MaximumMemorySetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value(StringUtil::BytesToHumanReadableString(config.maximum_memory));
-}
-
-//===--------------------------------------------------------------------===//
-// Perfect Hash Threshold
-//===--------------------------------------------------------------------===//
-void PerfectHashThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto bits = input.GetValue<int32_t>();
-	if (bits < 0 || bits > 32) {
-		throw ParserException("Perfect HT threshold out of range: should be within range 0 - 32");
-	}
-	ClientConfig::GetConfig(context).perfect_ht_threshold = bits;
-}
-
-Value PerfectHashThresholdSetting::GetSetting(ClientContext &context) {
-	return Value::BIGINT(ClientConfig::GetConfig(context).perfect_ht_threshold);
-}
-
-//===--------------------------------------------------------------------===//
-// PreserveIdentifierCase
-//===--------------------------------------------------------------------===//
-void PreserveIdentifierCase::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).preserve_identifier_case = input.GetValue<bool>();
-}
-
-Value PreserveIdentifierCase::GetSetting(ClientContext &context) {
-	return Value::BOOLEAN(ClientConfig::GetConfig(context).preserve_identifier_case);
-}
-
-//===--------------------------------------------------------------------===//
-// PreserveInsertionOrder
-//===--------------------------------------------------------------------===//
-void PreserveInsertionOrder::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.preserve_insertion_order = input.GetValue<bool>();
-}
-
-Value PreserveInsertionOrder::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BOOLEAN(config.preserve_insertion_order);
-}
-
-//===--------------------------------------------------------------------===//
-// Profiler History Size
-//===--------------------------------------------------------------------===//
-void ProfilerHistorySize::SetLocal(ClientContext &context, const Value &input) {
-	auto size = input.GetValue<int64_t>();
-	if (size <= 0) {
-		throw ParserException("Size should be >= 0");
-	}
-	auto &client_data = ClientData::Get(context);
-	client_data.query_profiler_history->SetProfilerHistorySize(size);
-}
-
-Value ProfilerHistorySize::GetSetting(ClientContext &context) {
-	return Value();
-}
-
-//===--------------------------------------------------------------------===//
-// Profile Output
-//===--------------------------------------------------------------------===//
-void ProfileOutputSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	auto parameter = input.ToString();
-	config.profiler_save_location = parameter;
-}
-
-Value ProfileOutputSetting::GetSetting(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value(config.profiler_save_location);
-}
-
-//===--------------------------------------------------------------------===//
-// Profiling Mode
-//===--------------------------------------------------------------------===//
-void ProfilingModeSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = StringUtil::Lower(input.ToString());
-	auto &config = ClientConfig::GetConfig(context);
-	if (parameter == "standard") {
-		config.enable_profiler = true;
-		config.enable_detailed_profiling = false;
-		config.emit_profiler_output = true;
-	} else if (parameter == "detailed") {
-		config.enable_profiler = true;
-		config.enable_detailed_profiling = true;
-		config.emit_profiler_output = true;
-	} else {
-		throw ParserException("Unrecognized profiling mode \"%s\", supported formats: [standard, detailed]", parameter);
-	}
-}
-
-Value ProfilingModeSetting::GetSetting(ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	if (!config.enable_profiler) {
-		return Value();
-	}
-	return Value(config.enable_detailed_profiling ? "detailed" : "standard");
-}
-
-//===--------------------------------------------------------------------===//
-// Progress Bar Time
-//===--------------------------------------------------------------------===//
-void ProgressBarTimeSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).wait_time = input.GetValue<int32_t>();
-	ClientConfig::GetConfig(context).enable_progress_bar = true;
-}
-
-Value ProgressBarTimeSetting::GetSetting(ClientContext &context) {
-	return Value::BIGINT(ClientConfig::GetConfig(context).wait_time);
-}
-
-//===--------------------------------------------------------------------===//
-// Schema
-//===--------------------------------------------------------------------===//
-void SchemaSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = input.ToString();
-	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(parameter, true);
-}
-
-Value SchemaSetting::GetSetting(ClientContext &context) {
-	return SearchPathSetting::GetSetting(context);
-}
-
-//===--------------------------------------------------------------------===//
-// Search Path
-//===--------------------------------------------------------------------===//
-void SearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto parameter = input.ToString();
-	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(parameter, false);
-}
-
-Value SearchPathSetting::GetSetting(ClientContext &context) {
-	auto &client_data = ClientData::Get(context);
-	return Value(StringUtil::Join(client_data.catalog_search_path->GetSetPaths(), ","));
-}
-
-//===--------------------------------------------------------------------===//
-// Temp Directory
-//===--------------------------------------------------------------------===//
-void TempDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.temporary_directory = input.ToString();
-	config.use_temporary_directory = !config.temporary_directory.empty();
-	if (db) {
-		auto &buffer_manager = BufferManager::GetBufferManager(*db);
-		buffer_manager.SetTemporaryDirectory(config.temporary_directory);
-	}
-}
-
-Value TempDirectorySetting::GetSetting(ClientContext &context) {
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	return Value(buffer_manager.GetTemporaryDirectory());
-}
-
-//===--------------------------------------------------------------------===//
-// Threads Setting
-//===--------------------------------------------------------------------===//
-void ThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.maximum_threads = input.GetValue<int64_t>();
-	if (db) {
-		TaskScheduler::GetScheduler(*db).SetThreads(config.maximum_threads);
-	}
-}
-
-Value ThreadsSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BIGINT(config.maximum_threads);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-StreamQueryResult::StreamQueryResult(StatementType statement_type, StatementProperties properties,
-                                     shared_ptr<ClientContext> context, vector<LogicalType> types, vector<string> names)
-    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, properties, move(types), move(names)),
-      context(move(context)) {
-}
-
-StreamQueryResult::~StreamQueryResult() {
-}
-
-string StreamQueryResult::ToString() {
-	string result;
-	if (success) {
-		result = HeaderToString();
-		result += "[[STREAM RESULT]]";
-	} else {
-		result = error + "\n";
-	}
-	return result;
-}
-
-unique_ptr<ClientContextLock> StreamQueryResult::LockContext() {
-	if (!context) {
-		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
-		                            error);
-	}
-	return context->LockContext();
-}
-
-void StreamQueryResult::CheckExecutableInternal(ClientContextLock &lock) {
-	if (!IsOpenInternal(lock)) {
-		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
-		                            error);
-	}
-}
-
-unique_ptr<DataChunk> StreamQueryResult::FetchRaw() {
-	unique_ptr<DataChunk> chunk;
-	{
-		auto lock = LockContext();
-		CheckExecutableInternal(*lock);
-		chunk = context->Fetch(*lock, *this);
-	}
-	if (!chunk || chunk->ColumnCount() == 0 || chunk->size() == 0) {
-		Close();
-		return nullptr;
-	}
-	return chunk;
-}
-
-unique_ptr<MaterializedQueryResult> StreamQueryResult::Materialize() {
-	if (!success) {
-		return make_unique<MaterializedQueryResult>(error);
-	}
-	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, types, names, context);
-	while (true) {
-		auto chunk = Fetch();
-		if (!chunk || chunk->size() == 0) {
-			break;
-		}
-		result->collection.Append(*chunk);
-	}
-	if (!success) {
-		return make_unique<MaterializedQueryResult>(error);
-	}
-	return result;
-}
-
-bool StreamQueryResult::IsOpenInternal(ClientContextLock &lock) {
-	bool invalidated = !success || !context;
-	if (!invalidated) {
-		invalidated = !context->IsActiveResult(lock, this);
-	}
-	return !invalidated;
-}
-
-bool StreamQueryResult::IsOpen() {
-	if (!success || !context) {
-		return false;
-	}
-	auto lock = LockContext();
-	return IsOpenInternal(*lock);
-}
-
-void StreamQueryResult::Close() {
-	context.reset();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void ColumnLifetimeAnalyzer::ExtractUnusedColumnBindings(vector<ColumnBinding> bindings,
-                                                         column_binding_set_t &unused_bindings) {
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		if (column_references.find(bindings[i]) == column_references.end()) {
-			unused_bindings.insert(bindings[i]);
-		}
-	}
-}
-
-void ColumnLifetimeAnalyzer::GenerateProjectionMap(vector<ColumnBinding> bindings,
-                                                   column_binding_set_t &unused_bindings,
-                                                   vector<idx_t> &projection_map) {
-	if (unused_bindings.empty()) {
-		return;
-	}
-	// now iterate over the result bindings of the child
-	for (idx_t i = 0; i < bindings.size(); i++) {
-		// if this binding does not belong to the unused bindings, add it to the projection map
-		if (unused_bindings.find(bindings[i]) == unused_bindings.end()) {
-			projection_map.push_back(i);
-		}
-	}
-	if (projection_map.size() == bindings.size()) {
-		projection_map.clear();
-	}
-}
-
-void ColumnLifetimeAnalyzer::StandardVisitOperator(LogicalOperator &op) {
-	LogicalOperatorVisitor::VisitOperatorExpressions(op);
-	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		// visit the duplicate eliminated columns on the LHS, if any
-		auto &delim_join = (LogicalDelimJoin &)op;
-		for (auto &expr : delim_join.duplicate_eliminated_columns) {
-			VisitExpression(&expr);
-		}
-	}
-	LogicalOperatorVisitor::VisitOperatorChildren(op);
-}
-
-void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		// FIXME: groups that are not referenced can be removed from projection
-		// recurse into the children of the aggregate
-		ColumnLifetimeAnalyzer analyzer;
-		analyzer.VisitOperatorExpressions(op);
-		analyzer.VisitOperator(*op.children[0]);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		if (everything_referenced) {
-			break;
-		}
-		auto &comp_join = (LogicalComparisonJoin &)op;
-		if (comp_join.join_type == JoinType::MARK || comp_join.join_type == JoinType::SEMI ||
-		    comp_join.join_type == JoinType::ANTI) {
-			break;
-		}
-		// FIXME for now, we only push into the projection map for equality (hash) joins
-		// FIXME: add projection to LHS as well
-		bool has_equality = false;
-		for (auto &cond : comp_join.conditions) {
-			if (cond.comparison == ExpressionType::COMPARE_EQUAL) {
-				has_equality = true;
-			}
-		}
-		if (!has_equality) {
-			break;
-		}
-		// now, for each of the columns of the RHS, check which columns need to be projected
-		column_binding_set_t unused_bindings;
-		ExtractUnusedColumnBindings(op.children[1]->GetColumnBindings(), unused_bindings);
-
-		// now recurse into the filter and its children
-		StandardVisitOperator(op);
-
-		// then generate the projection map
-		GenerateProjectionMap(op.children[1]->GetColumnBindings(), unused_bindings, comp_join.right_projection_map);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		// for set operations we don't remove anything, just recursively visit the children
-		// FIXME: for UNION we can remove unreferenced columns as long as everything_referenced is false (i.e. we
-		// encounter a UNION node that is not preceded by a DISTINCT)
-		for (auto &child : op.children) {
-			ColumnLifetimeAnalyzer analyzer(true);
-			analyzer.VisitOperator(*child);
-		}
-		return;
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		// then recurse into the children of this projection
-		ColumnLifetimeAnalyzer analyzer;
-		analyzer.VisitOperatorExpressions(op);
-		analyzer.VisitOperator(*op.children[0]);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		// distinct, all projected columns are used for the DISTINCT computation
-		// mark all columns as used and continue to the children
-		// FIXME: DISTINCT with expression list does not implicitly reference everything
-		everything_referenced = true;
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_FILTER: {
-		auto &filter = (LogicalFilter &)op;
-		if (everything_referenced) {
-			break;
-		}
-		// filter, figure out which columns are not needed after the filter
-		column_binding_set_t unused_bindings;
-		ExtractUnusedColumnBindings(op.children[0]->GetColumnBindings(), unused_bindings);
-
-		// now recurse into the filter and its children
-		StandardVisitOperator(op);
-
-		// then generate the projection map
-		GenerateProjectionMap(op.children[0]->GetColumnBindings(), unused_bindings, filter.projection_map);
-		return;
-	}
-	default:
-		break;
-	}
-	StandardVisitOperator(op);
-}
-
-unique_ptr<Expression> ColumnLifetimeAnalyzer::VisitReplace(BoundColumnRefExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	column_references.insert(expr.binding);
-	return nullptr;
-}
-
-unique_ptr<Expression> ColumnLifetimeAnalyzer::VisitReplace(BoundReferenceExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	// BoundReferenceExpression should not be used here yet, they only belong in the physical plan
-	throw InternalException("BoundReferenceExpression should not be used here yet!");
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-void CommonAggregateOptimizer::VisitOperator(LogicalOperator &op) {
-	LogicalOperatorVisitor::VisitOperator(op);
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		ExtractCommonAggregates((LogicalAggregate &)op);
-		break;
-	default:
-		break;
-	}
-}
-
-unique_ptr<Expression> CommonAggregateOptimizer::VisitReplace(BoundColumnRefExpression &expr,
-                                                              unique_ptr<Expression> *expr_ptr) {
-	// check if this column ref points to an aggregate that was remapped; if it does we remap it
-	auto entry = aggregate_map.find(expr.binding);
-	if (entry != aggregate_map.end()) {
-		expr.binding = entry->second;
-	}
-	return nullptr;
-}
-
-void CommonAggregateOptimizer::ExtractCommonAggregates(LogicalAggregate &aggr) {
-	expression_map_t<idx_t> aggregate_remap;
-	idx_t total_erased = 0;
-	for (idx_t i = 0; i < aggr.expressions.size(); i++) {
-		idx_t original_index = i + total_erased;
-		auto entry = aggregate_remap.find(aggr.expressions[i].get());
-		if (entry == aggregate_remap.end()) {
-			// aggregate does not exist yet: add it to the map
-			aggregate_remap[aggr.expressions[i].get()] = i;
-			if (i != original_index) {
-				// this aggregate is not erased, however an agregate BEFORE it has been erased
-				// so we need to remap this aggregaet
-				ColumnBinding original_binding(aggr.aggregate_index, original_index);
-				ColumnBinding new_binding(aggr.aggregate_index, i);
-				aggregate_map[original_binding] = new_binding;
-			}
-		} else {
-			// aggregate already exists! we can remove this entry
-			total_erased++;
-			aggr.expressions.erase(aggr.expressions.begin() + i);
-			i--;
-			// we need to remap any references to this aggregate so they point to the other aggregate
-			ColumnBinding original_binding(aggr.aggregate_index, original_index);
-			ColumnBinding new_binding(aggr.aggregate_index, entry->second);
-			aggregate_map[original_binding] = new_binding;
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The CSENode contains information about a common subexpression; how many times it occurs, and the column index in the
-//! underlying projection
-struct CSENode {
-	idx_t count;
-	idx_t column_index;
-
-	CSENode() : count(1), column_index(DConstants::INVALID_INDEX) {
-	}
-};
-
-//! The CSEReplacementState
-struct CSEReplacementState {
-	//! The projection index of the new projection
-	idx_t projection_index;
-	//! Map of expression -> CSENode
-	expression_map_t<CSENode> expression_count;
-	//! Map of column bindings to column indexes in the projection expression list
-	column_binding_map_t<idx_t> column_map;
-	//! The set of expressions of the resulting projection
-	vector<unique_ptr<Expression>> expressions;
-	//! Cached expressions that are kept around so the expression_map always contains valid expressions
-	vector<unique_ptr<Expression>> cached_expressions;
-};
-
-void CommonSubExpressionOptimizer::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		ExtractCommonSubExpresions(op);
-		break;
-	default:
-		break;
-	}
-	LogicalOperatorVisitor::VisitOperator(op);
-}
-
-void CommonSubExpressionOptimizer::CountExpressions(Expression &expr, CSEReplacementState &state) {
-	// we only consider expressions with children for CSE elimination
-	switch (expr.expression_class) {
-	case ExpressionClass::BOUND_COLUMN_REF:
-	case ExpressionClass::BOUND_CONSTANT:
-	case ExpressionClass::BOUND_PARAMETER:
-	// skip conjunctions and case, since short-circuiting might be incorrectly disabled otherwise
-	case ExpressionClass::BOUND_CONJUNCTION:
-	case ExpressionClass::BOUND_CASE:
-		return;
-	default:
-		break;
-	}
-	if (expr.expression_class != ExpressionClass::BOUND_AGGREGATE && !expr.HasSideEffects()) {
-		// we can't move aggregates to a projection, so we only consider the children of the aggregate
-		auto node = state.expression_count.find(&expr);
-		if (node == state.expression_count.end()) {
-			// first time we encounter this expression, insert this node with [count = 1]
-			state.expression_count[&expr] = CSENode();
-		} else {
-			// we encountered this expression before, increment the occurrence count
-			node->second.count++;
-		}
-	}
-	// recursively count the children
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { CountExpressions(child, state); });
-}
-
-void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression> *expr_ptr, CSEReplacementState &state) {
-	Expression &expr = **expr_ptr;
-	if (expr.expression_class == ExpressionClass::BOUND_COLUMN_REF) {
-		auto &bound_column_ref = (BoundColumnRefExpression &)expr;
-		// bound column ref, check if this one has already been recorded in the expression list
-		auto column_entry = state.column_map.find(bound_column_ref.binding);
-		if (column_entry == state.column_map.end()) {
-			// not there yet: push the expression
-			idx_t new_column_index = state.expressions.size();
-			state.column_map[bound_column_ref.binding] = new_column_index;
-			state.expressions.push_back(make_unique<BoundColumnRefExpression>(
-			    bound_column_ref.alias, bound_column_ref.return_type, bound_column_ref.binding));
-			bound_column_ref.binding = ColumnBinding(state.projection_index, new_column_index);
-		} else {
-			// else: just update the column binding!
-			bound_column_ref.binding = ColumnBinding(state.projection_index, column_entry->second);
-		}
-		return;
-	}
-	// check if this child is eligible for CSE elimination
-	bool can_cse = expr.expression_class != ExpressionClass::BOUND_CONJUNCTION &&
-	               expr.expression_class != ExpressionClass::BOUND_CASE;
-	if (can_cse && state.expression_count.find(&expr) != state.expression_count.end()) {
-		auto &node = state.expression_count[&expr];
-		if (node.count > 1) {
-			// this expression occurs more than once! push it into the projection
-			// check if it has already been pushed into the projection
-			auto alias = expr.alias;
-			auto type = expr.return_type;
-			if (node.column_index == DConstants::INVALID_INDEX) {
-				// has not been pushed yet: push it
-				node.column_index = state.expressions.size();
-				state.expressions.push_back(move(*expr_ptr));
-			} else {
-				state.cached_expressions.push_back(move(*expr_ptr));
-			}
-			// replace the original expression with a bound column ref
-			*expr_ptr = make_unique<BoundColumnRefExpression>(alias, type,
-			                                                  ColumnBinding(state.projection_index, node.column_index));
-			return;
-		}
-	}
-	// this expression only occurs once, we can't perform CSE elimination
-	// look into the children to see if we can replace them
-	ExpressionIterator::EnumerateChildren(expr,
-	                                      [&](unique_ptr<Expression> &child) { PerformCSEReplacement(&child, state); });
-}
-
-void CommonSubExpressionOptimizer::ExtractCommonSubExpresions(LogicalOperator &op) {
-	D_ASSERT(op.children.size() == 1);
-
-	// first we count for each expression with children how many types it occurs
-	CSEReplacementState state;
-	LogicalOperatorVisitor::EnumerateExpressions(
-	    op, [&](unique_ptr<Expression> *child) { CountExpressions(**child, state); });
-	// check if there are any expressions to extract
-	bool perform_replacement = false;
-	for (auto &expr : state.expression_count) {
-		if (expr.second.count > 1) {
-			perform_replacement = true;
-			break;
-		}
-	}
-	if (!perform_replacement) {
-		// no CSEs to extract
-		return;
-	}
-	state.projection_index = binder.GenerateTableIndex();
-	// we found common subexpressions to extract
-	// now we iterate over all the expressions and perform the actual CSE elimination
-	LogicalOperatorVisitor::EnumerateExpressions(
-	    op, [&](unique_ptr<Expression> *child) { PerformCSEReplacement(child, state); });
-	D_ASSERT(state.expressions.size() > 0);
-	// create a projection node as the child of this node
-	auto projection = make_unique<LogicalProjection>(state.projection_index, move(state.expressions));
-	projection->children.push_back(move(op.children[0]));
-	op.children[0] = move(projection);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class DeliminatorPlanUpdater : LogicalOperatorVisitor {
-public:
-	DeliminatorPlanUpdater() {
-	}
-	//! Update the plan after a DelimGet has been removed
-	void VisitOperator(LogicalOperator &op) override;
-	void VisitExpression(unique_ptr<Expression> *expression) override;
-	//! Whether the operator has one or more children of type DELIM_GET
-	bool HasChildDelimGet(LogicalOperator &op);
-	expression_map_t<Expression *> expr_map;
-	column_binding_map_t<bool> projection_map;
-	unique_ptr<LogicalOperator> temp_ptr;
-};
-
-void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
-	VisitOperatorChildren(op);
-	VisitOperatorExpressions(op);
-	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN && !HasChildDelimGet(op)) {
-		auto &delim_join = (LogicalDelimJoin &)op;
-		auto decs = &delim_join.duplicate_eliminated_columns;
-		for (auto &cond : delim_join.conditions) {
-			if (cond.comparison != ExpressionType::COMPARE_EQUAL &&
-			    cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-				continue;
-			}
-			auto &colref = (BoundColumnRefExpression &)*cond.right;
-			if (projection_map.find(colref.binding) != projection_map.end()) {
-				// value on the right is a projection of removed DelimGet
-				for (idx_t i = 0; i < decs->size(); i++) {
-					if (decs->at(i)->Equals(cond.left.get())) {
-						// the value on the left no longer needs to be a duplicate-eliminated column
-						decs->erase(decs->begin() + i);
-						break;
-					}
-				}
-				// whether we applied an IS NOT NULL filter
-				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-			}
-		}
-		// change type if there are no more duplicate-eliminated columns
-		if (decs->empty()) {
-			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
-		}
-	}
-}
-
-void DeliminatorPlanUpdater::VisitExpression(unique_ptr<Expression> *expression) {
-	if (expr_map.find(expression->get()) != expr_map.end()) {
-		*expression = expr_map[expression->get()]->Copy();
-	} else {
-		VisitExpressionChildren(**expression);
-	}
-}
-
-bool DeliminatorPlanUpdater::HasChildDelimGet(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		return true;
-	}
-	for (auto &child : op.children) {
-		if (HasChildDelimGet(*child)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op) {
-	vector<unique_ptr<LogicalOperator> *> candidates;
-	FindCandidates(&op, candidates);
-
-	for (auto candidate : candidates) {
-		DeliminatorPlanUpdater updater;
-		if (RemoveCandidate(candidate, updater)) {
-			updater.VisitOperator(*op);
-		}
-	}
-	return op;
-}
-
-void Deliminator::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
-                                 vector<unique_ptr<LogicalOperator> *> &candidates) {
-	auto op = op_ptr->get();
-	// search children before adding, so the deepest candidates get added first
-	for (auto &child : op->children) {
-		FindCandidates(&child, candidates);
-	}
-	// search for projection/aggregate
-	if (op->type != LogicalOperatorType::LOGICAL_PROJECTION &&
-	    op->type != LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY) {
-		return;
-	}
-	// followed by a join
-	if (op->children[0]->type != LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		return;
-	}
-	auto &join = *op->children[0];
-	// with a DelimGet as a direct child (left or right)
-	if (join.children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET ||
-	    join.children[1]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		candidates.push_back(op_ptr);
-		return;
-	}
-	// or a filter followed by a DelimGet (left)
-	if (join.children[0]->type == LogicalOperatorType::LOGICAL_FILTER &&
-	    join.children[0]->children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		candidates.push_back(op_ptr);
-		return;
-	}
-	// filter followed by a DelimGet (right)
-	if (join.children[1]->type == LogicalOperatorType::LOGICAL_FILTER &&
-	    join.children[1]->children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		candidates.push_back(op_ptr);
-		return;
-	}
-}
-
-static bool OperatorIsDelimGet(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		return true;
-	}
-	if (op.type == LogicalOperatorType::LOGICAL_FILTER &&
-	    op.children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		return true;
-	}
-	return false;
-}
-
-bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *op_ptr, DeliminatorPlanUpdater &updater) {
-	auto &proj_or_agg = **op_ptr;
-	auto &join = (LogicalComparisonJoin &)*proj_or_agg.children[0];
-	if (join.join_type != JoinType::INNER && join.join_type != JoinType::SEMI) {
-		return false;
-	}
-
-	// get the index (left or right) of the DelimGet side of the join
-	idx_t delim_idx = OperatorIsDelimGet(*join.children[0]) ? 0 : 1;
-	D_ASSERT(OperatorIsDelimGet(*join.children[delim_idx]));
-	// get the filter (if any)
-	LogicalFilter *filter = nullptr;
-	if (join.children[delim_idx]->type == LogicalOperatorType::LOGICAL_FILTER) {
-		filter = (LogicalFilter *)join.children[delim_idx].get();
-	}
-	auto &delim_get = (LogicalDelimGet &)*(filter ? filter->children[0].get() : join.children[delim_idx].get());
-	if (join.conditions.size() != delim_get.chunk_types.size()) {
-		// joining with DelimGet adds new information
-		return false;
-	}
-	// check if joining with the DelimGet is redundant, and collect relevant column information
-	vector<Expression *> nulls_are_not_equal_exprs;
-	for (auto &cond : join.conditions) {
-		if (cond.comparison != ExpressionType::COMPARE_EQUAL &&
-		    cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			// non-equality join condition
-			return false;
-		}
-		auto delim_side = delim_idx == 0 ? cond.left.get() : cond.right.get();
-		auto other_side = delim_idx == 0 ? cond.right.get() : cond.left.get();
-		if (delim_side->type != ExpressionType::BOUND_COLUMN_REF) {
-			// non-colref e.g. expression -(4, 1) in 4-i=j where i is from DelimGet
-			// FIXME: might be possible to also eliminate these
-			return false;
-		}
-		updater.expr_map[delim_side] = other_side;
-		if (cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			nulls_are_not_equal_exprs.push_back(other_side);
-		}
-	}
-	// removed DelimGet columns are assigned a new ColumnBinding by Projection/Aggregation, keep track here
-	if (proj_or_agg.type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		for (auto &cb : proj_or_agg.GetColumnBindings()) {
-			updater.projection_map[cb] = true;
-			for (auto &expr : nulls_are_not_equal_exprs) {
-				if (proj_or_agg.expressions[cb.column_index]->Equals(expr)) {
-					updater.projection_map[cb] = false;
-					break;
-				}
-			}
-		}
-	} else {
-		auto &agg = (LogicalAggregate &)proj_or_agg;
-		for (auto &cb : agg.GetColumnBindings()) {
-			updater.projection_map[cb] = true;
-			for (auto &expr : nulls_are_not_equal_exprs) {
-				if ((cb.table_index == agg.group_index && agg.groups[cb.column_index]->Equals(expr)) ||
-				    (cb.table_index == agg.aggregate_index && agg.expressions[cb.column_index]->Equals(expr))) {
-					updater.projection_map[cb] = false;
-					break;
-				}
-			}
-		}
-	}
-	// make a filter if needed
-	if (!nulls_are_not_equal_exprs.empty() || filter != nullptr) {
-		auto filter_op = make_unique<LogicalFilter>();
-		if (!nulls_are_not_equal_exprs.empty()) {
-			// add an IS NOT NULL filter that was implicitly in JoinCondition::null_values_are_equal
-			for (auto &expr : nulls_are_not_equal_exprs) {
-				auto is_not_null_expr =
-				    make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
-				is_not_null_expr->children.push_back(expr->Copy());
-				filter_op->expressions.push_back(move(is_not_null_expr));
-			}
-		}
-		if (filter != nullptr) {
-			for (auto &expr : filter->expressions) {
-				filter_op->expressions.push_back(move(expr));
-			}
-		}
-		filter_op->children.push_back(move(join.children[1 - delim_idx]));
-		join.children[1 - delim_idx] = move(filter_op);
-	}
-	// temporarily save deleted operator so its expressions are still available
-	updater.temp_ptr = move(proj_or_agg.children[0]);
-	// replace the redundant join
-	proj_or_agg.children[0] = move(join.children[1 - delim_idx]);
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> ExpressionHeuristics::Rewrite(unique_ptr<LogicalOperator> op) {
-	VisitOperator(*op);
-	return op;
-}
-
-void ExpressionHeuristics::VisitOperator(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_FILTER) {
-		// reorder all filter expressions
-		if (op.expressions.size() > 1) {
-			ReorderExpressions(op.expressions);
-		}
-	}
-
-	// traverse recursively through the operator tree
-	VisitOperatorChildren(op);
-	VisitOperatorExpressions(op);
-}
-
-unique_ptr<Expression> ExpressionHeuristics::VisitReplace(BoundConjunctionExpression &expr,
-                                                          unique_ptr<Expression> *expr_ptr) {
-	ReorderExpressions(expr.children);
-	return nullptr;
-}
-
-void ExpressionHeuristics::ReorderExpressions(vector<unique_ptr<Expression>> &expressions) {
-
-	struct ExpressionCosts {
-		unique_ptr<Expression> expr;
-		idx_t cost;
-
-		bool operator==(const ExpressionCosts &p) const {
-			return cost == p.cost;
-		}
-		bool operator<(const ExpressionCosts &p) const {
-			return cost < p.cost;
-		}
-	};
-
-	vector<ExpressionCosts> expression_costs;
-	// iterate expressions, get cost for each one
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		idx_t cost = Cost(*expressions[i]);
-		expression_costs.push_back({move(expressions[i]), cost});
-	}
-
-	// sort by cost and put back in place
-	sort(expression_costs.begin(), expression_costs.end());
-	for (idx_t i = 0; i < expression_costs.size(); i++) {
-		expressions[i] = move(expression_costs[i].expr);
-	}
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundBetweenExpression &expr) {
-	return Cost(*expr.input) + Cost(*expr.lower) + Cost(*expr.upper) + 10;
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundCaseExpression &expr) {
-	// CASE WHEN check THEN result_if_true ELSE result_if_false END
-	idx_t case_cost = 0;
-	for (auto &case_check : expr.case_checks) {
-		case_cost += Cost(*case_check.then_expr);
-		case_cost += Cost(*case_check.when_expr);
-	}
-	case_cost += Cost(*expr.else_expr);
-	return case_cost;
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundCastExpression &expr) {
-	// OPERATOR_CAST
-	// determine cast cost by comparing cast_expr.source_type and cast_expr_target_type
-	idx_t cast_cost = 0;
-	if (expr.return_type != expr.source_type()) {
-		// if cast from or to varchar
-		// TODO: we might want to add more cases
-		if (expr.return_type.id() == LogicalTypeId::VARCHAR || expr.source_type().id() == LogicalTypeId::VARCHAR ||
-		    expr.return_type.id() == LogicalTypeId::BLOB || expr.source_type().id() == LogicalTypeId::BLOB) {
-			cast_cost = 200;
-		} else {
-			cast_cost = 5;
-		}
-	}
-	return Cost(*expr.child) + cast_cost;
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundComparisonExpression &expr) {
-	// COMPARE_EQUAL, COMPARE_NOTEQUAL, COMPARE_GREATERTHAN, COMPARE_GREATERTHANOREQUALTO, COMPARE_LESSTHAN,
-	// COMPARE_LESSTHANOREQUALTO
-	return Cost(*expr.left) + 5 + Cost(*expr.right);
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundConjunctionExpression &expr) {
-	// CONJUNCTION_AND, CONJUNCTION_OR
-	idx_t cost = 5;
-	for (auto &child : expr.children) {
-		cost += Cost(*child);
-	}
-	return cost;
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundFunctionExpression &expr) {
-	idx_t cost_children = 0;
-	for (auto &child : expr.children) {
-		cost_children += Cost(*child);
-	}
-
-	auto cost_function = function_costs.find(expr.function.name);
-	if (cost_function != function_costs.end()) {
-		return cost_children + cost_function->second;
-	} else {
-		return cost_children + 1000;
-	}
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(BoundOperatorExpression &expr, ExpressionType &expr_type) {
-	idx_t sum = 0;
-	for (auto &child : expr.children) {
-		sum += Cost(*child);
-	}
-
-	// OPERATOR_IS_NULL, OPERATOR_IS_NOT_NULL
-	if (expr_type == ExpressionType::OPERATOR_IS_NULL || expr_type == ExpressionType::OPERATOR_IS_NOT_NULL) {
-		return sum + 5;
-	} else if (expr_type == ExpressionType::COMPARE_IN || expr_type == ExpressionType::COMPARE_NOT_IN) {
-		// COMPARE_IN, COMPARE_NOT_IN
-		return sum + (expr.children.size() - 1) * 100;
-	} else if (expr_type == ExpressionType::OPERATOR_NOT) {
-		// OPERATOR_NOT
-		return sum + 10; // TODO: evaluate via measured runtimes
-	} else {
-		return sum + 1000;
-	}
-}
-
-idx_t ExpressionHeuristics::ExpressionCost(PhysicalType return_type, idx_t multiplier) {
-	// TODO: ajust values according to benchmark results
-	switch (return_type) {
-	case PhysicalType::VARCHAR:
-		return 5 * multiplier;
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return 2 * multiplier;
-	default:
-		return 1 * multiplier;
-	}
-}
-
-idx_t ExpressionHeuristics::Cost(Expression &expr) {
-	switch (expr.expression_class) {
-	case ExpressionClass::BOUND_CASE: {
-		auto &case_expr = (BoundCaseExpression &)expr;
-		return ExpressionCost(case_expr);
-	}
-	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between_expr = (BoundBetweenExpression &)expr;
-		return ExpressionCost(between_expr);
-	}
-	case ExpressionClass::BOUND_CAST: {
-		auto &cast_expr = (BoundCastExpression &)expr;
-		return ExpressionCost(cast_expr);
-	}
-	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comp_expr = (BoundComparisonExpression &)expr;
-		return ExpressionCost(comp_expr);
-	}
-	case ExpressionClass::BOUND_CONJUNCTION: {
-		auto &conj_expr = (BoundConjunctionExpression &)expr;
-		return ExpressionCost(conj_expr);
-	}
-	case ExpressionClass::BOUND_FUNCTION: {
-		auto &func_expr = (BoundFunctionExpression &)expr;
-		return ExpressionCost(func_expr);
-	}
-	case ExpressionClass::BOUND_OPERATOR: {
-		auto &op_expr = (BoundOperatorExpression &)expr;
-		return ExpressionCost(op_expr, expr.type);
-	}
-	case ExpressionClass::BOUND_COLUMN_REF: {
-		auto &col_expr = (BoundColumnRefExpression &)expr;
-		return ExpressionCost(col_expr.return_type.InternalType(), 8);
-	}
-	case ExpressionClass::BOUND_CONSTANT: {
-		auto &const_expr = (BoundConstantExpression &)expr;
-		return ExpressionCost(const_expr.return_type.InternalType(), 1);
-	}
-	case ExpressionClass::BOUND_PARAMETER: {
-		auto &const_expr = (BoundParameterExpression &)expr;
-		return ExpressionCost(const_expr.return_type.InternalType(), 1);
-	}
-	case ExpressionClass::BOUND_REF: {
-		auto &col_expr = (BoundColumnRefExpression &)expr;
-		return ExpressionCost(col_expr.return_type.InternalType(), 8);
-	}
-	default: {
-		break;
-	}
-	}
-
-	// return a very high value if nothing matches
-	return 1000;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<Expression> ExpressionRewriter::ApplyRules(LogicalOperator &op, const vector<Rule *> &rules,
-                                                      unique_ptr<Expression> expr, bool &changes_made, bool is_root) {
-	for (auto &rule : rules) {
-		vector<Expression *> bindings;
-		if (rule->root->Match(expr.get(), bindings)) {
-			// the rule matches! try to apply it
-			bool rule_made_change = false;
-			auto result = rule->Apply(op, bindings, rule_made_change, is_root);
-			if (result) {
-				changes_made = true;
-				// the base node changed: the rule applied changes
-				// rerun on the new node
-				return ExpressionRewriter::ApplyRules(op, rules, move(result), changes_made);
-			} else if (rule_made_change) {
-				changes_made = true;
-				// the base node didn't change, but changes were made, rerun
-				return expr;
-			}
-			// else nothing changed, continue to the next rule
-			continue;
-		}
-	}
-	// no changes could be made to this node
-	// recursively run on the children of this node
-	ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
-		child = ExpressionRewriter::ApplyRules(op, rules, move(child), changes_made);
-	});
-	return expr;
-}
-
-unique_ptr<Expression> ExpressionRewriter::ConstantOrNull(unique_ptr<Expression> child, Value value) {
-	vector<unique_ptr<Expression>> children;
-	children.push_back(move(child));
-	return ConstantOrNull(move(children), move(value));
-}
-
-unique_ptr<Expression> ExpressionRewriter::ConstantOrNull(vector<unique_ptr<Expression>> children, Value value) {
-	auto type = value.type();
-	return make_unique<BoundFunctionExpression>(type, ConstantOrNull::GetFunction(type), move(children),
-	                                            ConstantOrNull::Bind(move(value)));
-}
-
-void ExpressionRewriter::VisitOperator(LogicalOperator &op) {
-	VisitOperatorChildren(op);
-	this->op = &op;
-
-	to_apply_rules.clear();
-	for (auto &rule : rules) {
-		if (rule->logical_root && !rule->logical_root->Match(op.type)) {
-			// this rule does not apply to this type of LogicalOperator
-			continue;
-		}
-		to_apply_rules.push_back(rule.get());
-	}
-	if (to_apply_rules.empty()) {
-		// no rules to apply on this node
-		return;
-	}
-
-	VisitOperatorExpressions(op);
-
-	// if it is a LogicalFilter, we split up filter conjunctions again
-	if (op.type == LogicalOperatorType::LOGICAL_FILTER) {
-		auto &filter = (LogicalFilter &)op;
-		filter.SplitPredicates();
-	}
-}
-
-void ExpressionRewriter::VisitExpression(unique_ptr<Expression> *expression) {
-	bool changes_made;
-	do {
-		changes_made = false;
-		*expression = ExpressionRewriter::ApplyRules(*op, to_apply_rules, move(*expression), changes_made, true);
-	} while (changes_made);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-using ExpressionValueInformation = FilterCombiner::ExpressionValueInformation;
-
-ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left, ExpressionValueInformation &right);
-
-Expression *FilterCombiner::GetNode(Expression *expr) {
-	auto entry = stored_expressions.find(expr);
-	if (entry != stored_expressions.end()) {
-		// expression already exists: return a reference to the stored expression
-		return entry->second.get();
-	}
-	// expression does not exist yet: create a copy and store it
-	auto copy = expr->Copy();
-	auto pointer_copy = copy.get();
-	D_ASSERT(stored_expressions.find(pointer_copy) == stored_expressions.end());
-	stored_expressions.insert(make_pair(pointer_copy, move(copy)));
-	return pointer_copy;
-}
-
-idx_t FilterCombiner::GetEquivalenceSet(Expression *expr) {
-	D_ASSERT(stored_expressions.find(expr) != stored_expressions.end());
-	D_ASSERT(stored_expressions.find(expr)->second.get() == expr);
-	auto entry = equivalence_set_map.find(expr);
-	if (entry == equivalence_set_map.end()) {
-		idx_t index = set_index++;
-		equivalence_set_map[expr] = index;
-		equivalence_map[index].push_back(expr);
-		constant_values.insert(make_pair(index, vector<ExpressionValueInformation>()));
-		return index;
-	} else {
-		return entry->second;
-	}
-}
-
-FilterResult FilterCombiner::AddConstantComparison(vector<ExpressionValueInformation> &info_list,
-                                                   ExpressionValueInformation info) {
-	for (idx_t i = 0; i < info_list.size(); i++) {
-		auto comparison = CompareValueInformation(info_list[i], info);
-		switch (comparison) {
-		case ValueComparisonResult::PRUNE_LEFT:
-			// prune the entry from the info list
-			info_list.erase(info_list.begin() + i);
-			i--;
-			break;
-		case ValueComparisonResult::PRUNE_RIGHT:
-			// prune the current info
-			return FilterResult::SUCCESS;
-		case ValueComparisonResult::UNSATISFIABLE_CONDITION:
-			// combination of filters is unsatisfiable: prune the entire branch
-			return FilterResult::UNSATISFIABLE;
-		default:
-			// prune nothing, move to the next condition
-			break;
-		}
-	}
-	// finally add the entry to the list
-	info_list.push_back(info);
-	return FilterResult::SUCCESS;
-}
-
-FilterResult FilterCombiner::AddFilter(unique_ptr<Expression> expr) {
-	//	LookUpConjunctions(expr.get());
-	// try to push the filter into the combiner
-	auto result = AddFilter(expr.get());
-	if (result == FilterResult::UNSUPPORTED) {
-		// unsupported filter, push into remaining filters
-		remaining_filters.push_back(move(expr));
-		return FilterResult::SUCCESS;
-	}
-	return result;
-}
-
-void FilterCombiner::GenerateFilters(const std::function<void(unique_ptr<Expression> filter)> &callback) {
-	// first loop over the remaining filters
-	for (auto &filter : remaining_filters) {
-		callback(move(filter));
-	}
-	remaining_filters.clear();
-	// now loop over the equivalence sets
-	for (auto &entry : equivalence_map) {
-		auto equivalence_set = entry.first;
-		auto &entries = entry.second;
-		auto &constant_list = constant_values.find(equivalence_set)->second;
-		// for each entry generate an equality expression comparing to each other
-		for (idx_t i = 0; i < entries.size(); i++) {
-			for (idx_t k = i + 1; k < entries.size(); k++) {
-				auto comparison = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL,
-				                                                         entries[i]->Copy(), entries[k]->Copy());
-				callback(move(comparison));
-			}
-			// for each entry also create a comparison with each constant
-			int lower_index = -1, upper_index = -1;
-			bool lower_inclusive, upper_inclusive;
-			for (idx_t k = 0; k < constant_list.size(); k++) {
-				auto &info = constant_list[k];
-				if (info.comparison_type == ExpressionType::COMPARE_GREATERTHAN ||
-				    info.comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
-					lower_index = k;
-					lower_inclusive = info.comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-				} else if (info.comparison_type == ExpressionType::COMPARE_LESSTHAN ||
-				           info.comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO) {
-					upper_index = k;
-					upper_inclusive = info.comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO;
-				} else {
-					auto constant = make_unique<BoundConstantExpression>(info.constant);
-					auto comparison = make_unique<BoundComparisonExpression>(info.comparison_type, entries[i]->Copy(),
-					                                                         move(constant));
-					callback(move(comparison));
-				}
-			}
-			if (lower_index >= 0 && upper_index >= 0) {
-				// found both lower and upper index, create a BETWEEN expression
-				auto lower_constant = make_unique<BoundConstantExpression>(constant_list[lower_index].constant);
-				auto upper_constant = make_unique<BoundConstantExpression>(constant_list[upper_index].constant);
-				auto between = make_unique<BoundBetweenExpression>(
-				    entries[i]->Copy(), move(lower_constant), move(upper_constant), lower_inclusive, upper_inclusive);
-				callback(move(between));
-			} else if (lower_index >= 0) {
-				// only lower index found, create simple comparison expression
-				auto constant = make_unique<BoundConstantExpression>(constant_list[lower_index].constant);
-				auto comparison = make_unique<BoundComparisonExpression>(constant_list[lower_index].comparison_type,
-				                                                         entries[i]->Copy(), move(constant));
-				callback(move(comparison));
-			} else if (upper_index >= 0) {
-				// only upper index found, create simple comparison expression
-				auto constant = make_unique<BoundConstantExpression>(constant_list[upper_index].constant);
-				auto comparison = make_unique<BoundComparisonExpression>(constant_list[upper_index].comparison_type,
-				                                                         entries[i]->Copy(), move(constant));
-				callback(move(comparison));
-			}
-		}
-	}
-	stored_expressions.clear();
-	equivalence_set_map.clear();
-	constant_values.clear();
-	equivalence_map.clear();
-}
-
-bool FilterCombiner::HasFilters() {
-	bool has_filters = false;
-	GenerateFilters([&](unique_ptr<Expression> child) { has_filters = true; });
-	return has_filters;
-}
-
-// unordered_map<idx_t, std::pair<Value *, Value *>> MergeAnd(unordered_map<idx_t, std::pair<Value *, Value *>> &f_1,
-//                                                            unordered_map<idx_t, std::pair<Value *, Value *>> &f_2) {
-// 	unordered_map<idx_t, std::pair<Value *, Value *>> result;
-// 	for (auto &f : f_1) {
-// 		auto it = f_2.find(f.first);
-// 		if (it == f_2.end()) {
-// 			result[f.first] = f.second;
-// 		} else {
-// 			Value *min = nullptr, *max = nullptr;
-// 			if (it->second.first && f.second.first) {
-// 				if (*f.second.first > *it->second.first) {
-// 					min = f.second.first;
-// 				} else {
-// 					min = it->second.first;
-// 				}
-
-// 			} else if (it->second.first) {
-// 				min = it->second.first;
-// 			} else if (f.second.first) {
-// 				min = f.second.first;
-// 			} else {
-// 				min = nullptr;
-// 			}
-// 			if (it->second.second && f.second.second) {
-// 				if (*f.second.second < *it->second.second) {
-// 					max = f.second.second;
-// 				} else {
-// 					max = it->second.second;
-// 				}
-// 			} else if (it->second.second) {
-// 				max = it->second.second;
-// 			} else if (f.second.second) {
-// 				max = f.second.second;
-// 			} else {
-// 				max = nullptr;
-// 			}
-// 			result[f.first] = {min, max};
-// 			f_2.erase(f.first);
-// 		}
-// 	}
-// 	for (auto &f : f_2) {
-// 		result[f.first] = f.second;
-// 	}
-// 	return result;
-// }
-
-// unordered_map<idx_t, std::pair<Value *, Value *>> MergeOr(unordered_map<idx_t, std::pair<Value *, Value *>> &f_1,
-//                                                           unordered_map<idx_t, std::pair<Value *, Value *>> &f_2) {
-// 	unordered_map<idx_t, std::pair<Value *, Value *>> result;
-// 	for (auto &f : f_1) {
-// 		auto it = f_2.find(f.first);
-// 		if (it != f_2.end()) {
-// 			Value *min = nullptr, *max = nullptr;
-// 			if (it->second.first && f.second.first) {
-// 				if (*f.second.first < *it->second.first) {
-// 					min = f.second.first;
-// 				} else {
-// 					min = it->second.first;
-// 				}
-// 			}
-// 			if (it->second.second && f.second.second) {
-// 				if (*f.second.second > *it->second.second) {
-// 					max = f.second.second;
-// 				} else {
-// 					max = it->second.second;
-// 				}
-// 			}
-// 			result[f.first] = {min, max};
-// 			f_2.erase(f.first);
-// 		}
-// 	}
-// 	return result;
-// }
-
-// unordered_map<idx_t, std::pair<Value *, Value *>>
-// FilterCombiner::FindZonemapChecks(vector<idx_t> &column_ids, unordered_set<idx_t> &not_constants, Expression *filter)
-// { 	unordered_map<idx_t, std::pair<Value *, Value *>> checks; 	switch (filter->type) { 	case
-// ExpressionType::CONJUNCTION_OR: {
-// 		//! For a filter to
-// 		auto &or_exp = (BoundConjunctionExpression &)*filter;
-// 		checks = FindZonemapChecks(column_ids, not_constants, or_exp.children[0].get());
-// 		for (size_t i = 1; i < or_exp.children.size(); ++i) {
-// 			auto child_check = FindZonemapChecks(column_ids, not_constants, or_exp.children[i].get());
-// 			checks = MergeOr(checks, child_check);
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::CONJUNCTION_AND: {
-// 		auto &and_exp = (BoundConjunctionExpression &)*filter;
-// 		checks = FindZonemapChecks(column_ids, not_constants, and_exp.children[0].get());
-// 		for (size_t i = 1; i < and_exp.children.size(); ++i) {
-// 			auto child_check = FindZonemapChecks(column_ids, not_constants, and_exp.children[i].get());
-// 			checks = MergeAnd(checks, child_check);
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::COMPARE_IN: {
-// 		auto &comp_in_exp = (BoundOperatorExpression &)*filter;
-// 		if (comp_in_exp.children[0]->type == ExpressionType::BOUND_COLUMN_REF) {
-// 			Value *min = nullptr, *max = nullptr;
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_in_exp.children[0].get();
-// 			for (size_t i {1}; i < comp_in_exp.children.size(); i++) {
-// 				if (comp_in_exp.children[i]->type != ExpressionType::VALUE_CONSTANT) {
-// 					//! This indicates the column has a comparison that is not with a constant
-// 					not_constants.insert(column_ids[column_ref.binding.column_index]);
-// 					break;
-// 				} else {
-// 					auto &const_value_expr = (BoundConstantExpression &)*comp_in_exp.children[i].get();
-// 					if (const_value_expr.value.IsNull()) {
-// 						return checks;
-// 					}
-// 					if (!min && !max) {
-// 						min = &const_value_expr.value;
-// 						max = min;
-// 					} else {
-// 						if (*min > const_value_expr.value) {
-// 							min = &const_value_expr.value;
-// 						}
-// 						if (*max < const_value_expr.value) {
-// 							max = &const_value_expr.value;
-// 						}
-// 					}
-// 				}
-// 			}
-// 			checks[column_ids[column_ref.binding.column_index]] = {min, max};
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::COMPARE_EQUAL: {
-// 		auto &comp_exp = (BoundComparisonExpression &)*filter;
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.left;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.right;
-// 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value,
-// 			                                                       &constant_value_expr.value};
-// 		}
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.right;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.left;
-// 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value,
-// 			                                                       &constant_value_expr.value};
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::COMPARE_LESSTHAN:
-// 	case ExpressionType::COMPARE_LESSTHANOREQUALTO: {
-// 		auto &comp_exp = (BoundComparisonExpression &)*filter;
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.left;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.right;
-// 			checks[column_ids[column_ref.binding.column_index]] = {nullptr, &constant_value_expr.value};
-// 		}
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.right;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.left;
-// 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value, nullptr};
-// 		}
-// 		return checks;
-// 	}
-// 	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-// 	case ExpressionType::COMPARE_GREATERTHAN: {
-// 		auto &comp_exp = (BoundComparisonExpression &)*filter;
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.left;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.right;
-// 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value, nullptr};
-// 		}
-// 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
-// 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.right;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.left;
-// 			checks[column_ids[column_ref.binding.column_index]] = {nullptr, &constant_value_expr.value};
-// 		}
-// 		return checks;
-// 	}
-// 	default:
-// 		return checks;
-// 	}
-// }
-
-// vector<TableFilter> FilterCombiner::GenerateZonemapChecks(vector<idx_t> &column_ids,
-//                                                           vector<TableFilter> &pushed_filters) {
-// 	vector<TableFilter> zonemap_checks;
-// 	unordered_set<idx_t> not_constants;
-// 	//! We go through the remaining filters and capture their min max
-// 	if (remaining_filters.empty()) {
-// 		return zonemap_checks;
-// 	}
-
-// 	auto checks = FindZonemapChecks(column_ids, not_constants, remaining_filters[0].get());
-// 	for (size_t i = 1; i < remaining_filters.size(); ++i) {
-// 		auto child_check = FindZonemapChecks(column_ids, not_constants, remaining_filters[i].get());
-// 		checks = MergeAnd(checks, child_check);
-// 	}
-// 	//! We construct the equivalent filters
-// 	for (auto not_constant : not_constants) {
-// 		checks.erase(not_constant);
-// 	}
-// 	for (const auto &pushed_filter : pushed_filters) {
-// 		checks.erase(column_ids[pushed_filter.column_index]);
-// 	}
-// 	for (const auto &check : checks) {
-// 		if (check.second.first) {
-// 			zonemap_checks.emplace_back(check.second.first->Copy(), ExpressionType::COMPARE_GREATERTHANOREQUALTO,
-// 			                            check.first);
-// 		}
-// 		if (check.second.second) {
-// 			zonemap_checks.emplace_back(check.second.second->Copy(), ExpressionType::COMPARE_LESSTHANOREQUALTO,
-// 			                            check.first);
-// 		}
-// 	}
-// 	return zonemap_checks;
-// }
-
-TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_ids) {
-	TableFilterSet table_filters;
-	//! First, we figure the filters that have constant expressions that we can push down to the table scan
-	for (auto &constant_value : constant_values) {
-		if (!constant_value.second.empty()) {
-			auto filter_exp = equivalence_map.end();
-			if ((constant_value.second[0].comparison_type == ExpressionType::COMPARE_EQUAL ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_GREATERTHAN ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_LESSTHAN ||
-			     constant_value.second[0].comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO) &&
-			    (TypeIsNumeric(constant_value.second[0].constant.type().InternalType()) ||
-			     constant_value.second[0].constant.type().InternalType() == PhysicalType::VARCHAR ||
-			     constant_value.second[0].constant.type().InternalType() == PhysicalType::BOOL)) {
-				//! Here we check if these filters are column references
-				filter_exp = equivalence_map.find(constant_value.first);
-				if (filter_exp->second.size() == 1 && filter_exp->second[0]->type == ExpressionType::BOUND_COLUMN_REF) {
-					auto filter_col_exp = static_cast<BoundColumnRefExpression *>(filter_exp->second[0]);
-					auto column_index = column_ids[filter_col_exp->binding.column_index];
-					if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-						break;
-					}
-					auto equivalence_set = filter_exp->first;
-					auto &entries = filter_exp->second;
-					auto &constant_list = constant_values.find(equivalence_set)->second;
-					// for each entry generate an equality expression comparing to each other
-					for (idx_t i = 0; i < entries.size(); i++) {
-						// for each entry also create a comparison with each constant
-						for (idx_t k = 0; k < constant_list.size(); k++) {
-							auto constant_filter = make_unique<ConstantFilter>(constant_value.second[k].comparison_type,
-							                                                   constant_value.second[k].constant);
-							table_filters.PushFilter(column_index, move(constant_filter));
-						}
-						table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
-					}
-					equivalence_map.erase(filter_exp);
-				}
-			}
-		}
-	}
-	//! Here we look for LIKE or IN filters
-	for (idx_t rem_fil_idx = 0; rem_fil_idx < remaining_filters.size(); rem_fil_idx++) {
-		auto &remaining_filter = remaining_filters[rem_fil_idx];
-		if (remaining_filter->expression_class == ExpressionClass::BOUND_FUNCTION) {
-			auto &func = (BoundFunctionExpression &)*remaining_filter;
-			if (func.function.name == "prefix" &&
-			    func.children[0]->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-			    func.children[1]->type == ExpressionType::VALUE_CONSTANT) {
-				//! This is a like function.
-				auto &column_ref = (BoundColumnRefExpression &)*func.children[0].get();
-				auto &constant_value_expr = (BoundConstantExpression &)*func.children[1].get();
-				auto like_string = StringValue::Get(constant_value_expr.value);
-				if (like_string.empty()) {
-					continue;
-				}
-				auto column_index = column_ids[column_ref.binding.column_index];
-				//! Here the like must be transformed to a BOUND COMPARISON geq le
-				auto lower_bound =
-				    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(like_string));
-				like_string[like_string.size() - 1]++;
-				auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, Value(like_string));
-				table_filters.PushFilter(column_index, move(lower_bound));
-				table_filters.PushFilter(column_index, move(upper_bound));
-				table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
-			}
-			if (func.function.name == "~~" && func.children[0]->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-			    func.children[1]->type == ExpressionType::VALUE_CONSTANT) {
-				//! This is a like function.
-				auto &column_ref = (BoundColumnRefExpression &)*func.children[0].get();
-				auto &constant_value_expr = (BoundConstantExpression &)*func.children[1].get();
-				auto &like_string = StringValue::Get(constant_value_expr.value);
-				if (like_string[0] == '%' || like_string[0] == '_') {
-					//! We have no prefix so nothing to pushdown
-					break;
-				}
-				string prefix;
-				bool equality = true;
-				for (char const &c : like_string) {
-					if (c == '%' || c == '_') {
-						equality = false;
-						break;
-					}
-					prefix += c;
-				}
-				auto column_index = column_ids[column_ref.binding.column_index];
-				if (equality) {
-					//! Here the like can be transformed to an equality query
-					auto equal_filter = make_unique<ConstantFilter>(ExpressionType::COMPARE_EQUAL, Value(prefix));
-					table_filters.PushFilter(column_index, move(equal_filter));
-					table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
-				} else {
-					//! Here the like must be transformed to a BOUND COMPARISON geq le
-					auto lower_bound =
-					    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(prefix));
-					prefix[prefix.size() - 1]++;
-					auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, Value(prefix));
-					table_filters.PushFilter(column_index, move(lower_bound));
-					table_filters.PushFilter(column_index, move(upper_bound));
-					table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
-				}
-			}
-		} else if (remaining_filter->type == ExpressionType::COMPARE_IN) {
-			auto &func = (BoundOperatorExpression &)*remaining_filter;
-			vector<hugeint_t> in_values;
-			D_ASSERT(func.children.size() > 1);
-			if (func.children[0]->expression_class != ExpressionClass::BOUND_COLUMN_REF) {
-				continue;
-			}
-			auto &column_ref = (BoundColumnRefExpression &)*func.children[0].get();
-			auto column_index = column_ids[column_ref.binding.column_index];
-			if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-				break;
-			}
-			//! check if all children are const expr
-			bool children_constant = true;
-			for (size_t i {1}; i < func.children.size(); i++) {
-				if (func.children[i]->type != ExpressionType::VALUE_CONSTANT) {
-					children_constant = false;
-				}
-			}
-			if (!children_constant) {
-				continue;
-			}
-			auto &fst_const_value_expr = (BoundConstantExpression &)*func.children[1].get();
-			auto &type = fst_const_value_expr.value.type();
-
-			//! Check if values are consecutive, if yes transform them to >= <= (only for integers)
-			// e.g. if we have x IN (1, 2, 3, 4, 5) we transform this into x >= 1 AND x <= 5
-			if (!type.IsIntegral()) {
-				continue;
-			}
-
-			bool can_simplify_in_clause = true;
-			for (idx_t i = 1; i < func.children.size(); i++) {
-				auto &const_value_expr = (BoundConstantExpression &)*func.children[i].get();
-				if (const_value_expr.value.IsNull()) {
-					can_simplify_in_clause = false;
-					break;
-				}
-				in_values.push_back(const_value_expr.value.GetValue<hugeint_t>());
-			}
-			if (!can_simplify_in_clause || in_values.empty()) {
-				continue;
-			}
-
-			sort(in_values.begin(), in_values.end());
-
-			for (idx_t in_val_idx = 1; in_val_idx < in_values.size(); in_val_idx++) {
-				if (in_values[in_val_idx] - in_values[in_val_idx - 1] > 1) {
-					can_simplify_in_clause = false;
-					break;
-				}
-			}
-			if (!can_simplify_in_clause) {
-				continue;
-			}
-			auto lower_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
-			                                               Value::Numeric(type, in_values.front()));
-			auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
-			                                               Value::Numeric(type, in_values.back()));
-			table_filters.PushFilter(column_index, move(lower_bound));
-			table_filters.PushFilter(column_index, move(upper_bound));
-			table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
-
-			remaining_filters.erase(remaining_filters.begin() + rem_fil_idx);
-		}
-	}
-
-	//	GenerateORFilters(table_filters, column_ids);
-
-	return table_filters;
-}
-
-static bool IsGreaterThan(ExpressionType type) {
-	return type == ExpressionType::COMPARE_GREATERTHAN || type == ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-}
-
-static bool IsLessThan(ExpressionType type) {
-	return type == ExpressionType::COMPARE_LESSTHAN || type == ExpressionType::COMPARE_LESSTHANOREQUALTO;
-}
-
-FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
-	auto &comparison = (BoundComparisonExpression &)*expr;
-	if (comparison.type != ExpressionType::COMPARE_LESSTHAN &&
-	    comparison.type != ExpressionType::COMPARE_LESSTHANOREQUALTO &&
-	    comparison.type != ExpressionType::COMPARE_GREATERTHAN &&
-	    comparison.type != ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
-	    comparison.type != ExpressionType::COMPARE_EQUAL && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
-		// only support [>, >=, <, <=, ==] expressions
-		return FilterResult::UNSUPPORTED;
-	}
-	// check if one of the sides is a scalar value
-	bool left_is_scalar = comparison.left->IsFoldable();
-	bool right_is_scalar = comparison.right->IsFoldable();
-	if (left_is_scalar || right_is_scalar) {
-		// comparison with scalar
-		auto node = GetNode(left_is_scalar ? comparison.right.get() : comparison.left.get());
-		idx_t equivalence_set = GetEquivalenceSet(node);
-		auto scalar = left_is_scalar ? comparison.left.get() : comparison.right.get();
-		auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
-		if (constant_value.IsNull()) {
-			// comparisons with null are always null (i.e. will never result in rows)
-			return FilterResult::UNSATISFIABLE;
-		}
-
-		// create the ExpressionValueInformation
-		ExpressionValueInformation info;
-		info.comparison_type = left_is_scalar ? FlipComparisionExpression(comparison.type) : comparison.type;
-		info.constant = constant_value;
-
-		// get the current bucket of constant values
-		D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
-		auto &info_list = constant_values.find(equivalence_set)->second;
-		// check the existing constant comparisons to see if we can do any pruning
-		auto ret = AddConstantComparison(info_list, info);
-
-		auto non_scalar = left_is_scalar ? comparison.right.get() : comparison.left.get();
-		auto transitive_filter = FindTransitiveFilter(non_scalar);
-		if (transitive_filter != nullptr) {
-			// try to add transitive filters
-			if (AddTransitiveFilters((BoundComparisonExpression &)*transitive_filter) == FilterResult::UNSUPPORTED) {
-				// in case of unsuccessful re-add filter into remaining ones
-				remaining_filters.push_back(move(transitive_filter));
-			}
-		}
-		return ret;
-	} else {
-		// comparison between two non-scalars
-		// only handle comparisons for now
-		if (expr->type != ExpressionType::COMPARE_EQUAL) {
-			if (IsGreaterThan(expr->type) || IsLessThan(expr->type)) {
-				return AddTransitiveFilters(comparison);
-			}
-			return FilterResult::UNSUPPORTED;
-		}
-		// get the LHS and RHS nodes
-		auto left_node = GetNode(comparison.left.get());
-		auto right_node = GetNode(comparison.right.get());
-		if (BaseExpression::Equals(left_node, right_node)) {
-			return FilterResult::UNSUPPORTED;
-		}
-		// get the equivalence sets of the LHS and RHS
-		auto left_equivalence_set = GetEquivalenceSet(left_node);
-		auto right_equivalence_set = GetEquivalenceSet(right_node);
-		if (left_equivalence_set == right_equivalence_set) {
-			// this equality filter already exists, prune it
-			return FilterResult::SUCCESS;
-		}
-		// add the right bucket into the left bucket
-		D_ASSERT(equivalence_map.find(left_equivalence_set) != equivalence_map.end());
-		D_ASSERT(equivalence_map.find(right_equivalence_set) != equivalence_map.end());
-
-		auto &left_bucket = equivalence_map.find(left_equivalence_set)->second;
-		auto &right_bucket = equivalence_map.find(right_equivalence_set)->second;
-		for (auto &i : right_bucket) {
-			// rewrite the equivalence set mapping for this node
-			equivalence_set_map[i] = left_equivalence_set;
-			// add the node to the left bucket
-			left_bucket.push_back(i);
-		}
-		// now add all constant values from the right bucket to the left bucket
-		D_ASSERT(constant_values.find(left_equivalence_set) != constant_values.end());
-		D_ASSERT(constant_values.find(right_equivalence_set) != constant_values.end());
-		auto &left_constant_bucket = constant_values.find(left_equivalence_set)->second;
-		auto &right_constant_bucket = constant_values.find(right_equivalence_set)->second;
-		for (auto &i : right_constant_bucket) {
-			if (AddConstantComparison(left_constant_bucket, i) == FilterResult::UNSATISFIABLE) {
-				return FilterResult::UNSATISFIABLE;
-			}
-		}
-	}
-	return FilterResult::SUCCESS;
-}
-
-FilterResult FilterCombiner::AddFilter(Expression *expr) {
-	if (expr->HasParameter()) {
-		return FilterResult::UNSUPPORTED;
-	}
-	if (expr->IsFoldable()) {
-		// scalar condition, evaluate it
-		auto result = ExpressionExecutor::EvaluateScalar(*expr).CastAs(LogicalType::BOOLEAN);
-		// check if the filter passes
-		if (result.IsNull() || !BooleanValue::Get(result)) {
-			// the filter does not pass the scalar test, create an empty result
-			return FilterResult::UNSATISFIABLE;
-		} else {
-			// the filter passes the scalar test, just remove the condition
-			return FilterResult::SUCCESS;
-		}
-	}
-	D_ASSERT(!expr->IsFoldable());
-	if (expr->GetExpressionClass() == ExpressionClass::BOUND_BETWEEN) {
-		auto &comparison = (BoundBetweenExpression &)*expr;
-		//! check if one of the sides is a scalar value
-		bool lower_is_scalar = comparison.lower->IsFoldable();
-		bool upper_is_scalar = comparison.upper->IsFoldable();
-		if (lower_is_scalar || upper_is_scalar) {
-			//! comparison with scalar - break apart
-			auto node = GetNode(comparison.input.get());
-			idx_t equivalence_set = GetEquivalenceSet(node);
-			auto result = FilterResult::UNSATISFIABLE;
-
-			if (lower_is_scalar) {
-				auto scalar = comparison.lower.get();
-				auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
-
-				// create the ExpressionValueInformation
-				ExpressionValueInformation info;
-				if (comparison.lower_inclusive) {
-					info.comparison_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
-				} else {
-					info.comparison_type = ExpressionType::COMPARE_GREATERTHAN;
-				}
-				info.constant = constant_value;
-
-				// get the current bucket of constant values
-				D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
-				auto &info_list = constant_values.find(equivalence_set)->second;
-				// check the existing constant comparisons to see if we can do any pruning
-				result = AddConstantComparison(info_list, info);
-			} else {
-				D_ASSERT(upper_is_scalar);
-				const auto type = comparison.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
-				                                             : ExpressionType::COMPARE_LESSTHAN;
-				auto left = comparison.lower->Copy();
-				auto right = comparison.input->Copy();
-				auto lower_comp = make_unique<BoundComparisonExpression>(type, move(left), move(right));
-				result = AddBoundComparisonFilter(lower_comp.get());
-			}
-
-			//	 Stop if we failed
-			if (result != FilterResult::SUCCESS) {
-				return result;
-			}
-
-			if (upper_is_scalar) {
-				auto scalar = comparison.upper.get();
-				auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
-
-				// create the ExpressionValueInformation
-				ExpressionValueInformation info;
-				if (comparison.upper_inclusive) {
-					info.comparison_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
-				} else {
-					info.comparison_type = ExpressionType::COMPARE_LESSTHAN;
-				}
-				info.constant = constant_value;
-
-				// get the current bucket of constant values
-				D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
-				// check the existing constant comparisons to see if we can do any pruning
-				result = AddConstantComparison(constant_values.find(equivalence_set)->second, info);
-			} else {
-				D_ASSERT(lower_is_scalar);
-				const auto type = comparison.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
-				                                             : ExpressionType::COMPARE_LESSTHAN;
-				auto left = comparison.input->Copy();
-				auto right = comparison.upper->Copy();
-				auto upper_comp = make_unique<BoundComparisonExpression>(type, move(left), move(right));
-				result = AddBoundComparisonFilter(upper_comp.get());
-			}
-
-			return result;
-		}
-	} else if (expr->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-		return AddBoundComparisonFilter(expr);
-	}
-	// only comparisons supported for now
-	return FilterResult::UNSUPPORTED;
-}
-
-/*
- * Create and add new transitive filters from a two non-scalar filter such as j > i, j >= i, j < i, and j <= i
- * It's missing to create another method to add transitive filters from scalar filters, e.g, i > 10
- */
-FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &comparison) {
-	D_ASSERT(IsGreaterThan(comparison.type) || IsLessThan(comparison.type));
-	// get the LHS and RHS nodes
-	Expression *left_node = GetNode(comparison.left.get());
-	Expression *right_node = GetNode(comparison.right.get());
-	// In case with filters like CAST(i) = j and i = 5 we replace the COLUMN_REF i with the constant 5
-	if (right_node->type == ExpressionType::OPERATOR_CAST) {
-		auto &bound_cast_expr = (BoundCastExpression &)*right_node;
-		if (bound_cast_expr.child->type == ExpressionType::BOUND_COLUMN_REF) {
-			auto &col_ref = (BoundColumnRefExpression &)*bound_cast_expr.child;
-			for (auto &stored_exp : stored_expressions) {
-				if (stored_exp.first->type == ExpressionType::BOUND_COLUMN_REF) {
-					auto &st_col_ref = (BoundColumnRefExpression &)*stored_exp.second;
-					if (st_col_ref.binding == col_ref.binding) {
-						bound_cast_expr.child = stored_exp.second->Copy();
-						right_node = GetNode(bound_cast_expr.child.get());
-						break;
-					}
-				}
-			}
-		}
-	}
-
-	if (BaseExpression::Equals(left_node, right_node)) {
-		return FilterResult::UNSUPPORTED;
-	}
-	// get the equivalence sets of the LHS and RHS
-	idx_t left_equivalence_set = GetEquivalenceSet(left_node);
-	idx_t right_equivalence_set = GetEquivalenceSet(right_node);
-	if (left_equivalence_set == right_equivalence_set) {
-		// this equality filter already exists, prune it
-		return FilterResult::SUCCESS;
-	}
-
-	vector<ExpressionValueInformation> &left_constants = constant_values.find(left_equivalence_set)->second;
-	vector<ExpressionValueInformation> &right_constants = constant_values.find(right_equivalence_set)->second;
-	bool is_successful = false;
-	bool is_inserted = false;
-	// read every constant filters already inserted for the right scalar variable
-	// and see if we can create new transitive filters, e.g., there is already a filter i > 10,
-	// suppose that we have now the j >= i, then we can infer a new filter j > 10
-	for (const auto &right_constant : right_constants) {
-		ExpressionValueInformation info;
-		info.constant = right_constant.constant;
-		// there is already an equality filter, e.g., i = 10
-		if (right_constant.comparison_type == ExpressionType::COMPARE_EQUAL) {
-			// create filter j [>, >=, <, <=] 10
-			// suppose the new comparison is j >= i and we have already a filter i = 10,
-			// then we create a new filter j >= 10
-			// and the filter j >= i can be pruned by not adding it into the remaining filters
-			info.comparison_type = comparison.type;
-		} else if ((comparison.type == ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
-		            IsGreaterThan(right_constant.comparison_type)) ||
-		           (comparison.type == ExpressionType::COMPARE_LESSTHANOREQUALTO &&
-		            IsLessThan(right_constant.comparison_type))) {
-			// filters (j >= i AND i [>, >=] 10) OR (j <= i AND i [<, <=] 10)
-			// create filter j [>, >=] 10 and add the filter j [>=, <=] i into the remaining filters
-			info.comparison_type = right_constant.comparison_type; // create filter j [>, >=, <, <=] 10
-			if (!is_inserted) {
-				// Add the filter j >= i in the remaing filters
-				auto filter = make_unique<BoundComparisonExpression>(comparison.type, comparison.left->Copy(),
-				                                                     comparison.right->Copy());
-				remaining_filters.push_back(move(filter));
-				is_inserted = true;
-			}
-		} else if ((comparison.type == ExpressionType::COMPARE_GREATERTHAN &&
-		            IsGreaterThan(right_constant.comparison_type)) ||
-		           (comparison.type == ExpressionType::COMPARE_LESSTHAN &&
-		            IsLessThan(right_constant.comparison_type))) {
-			// filters (j > i AND i [>, >=] 10) OR j < i AND i [<, <=] 10
-			// create filter j [>, <] 10 and add the filter j [>, <] i into the remaining filters
-			// the comparisons j > i and j < i are more restrictive
-			info.comparison_type = comparison.type;
-			if (!is_inserted) {
-				// Add the filter j [>, <] i
-				auto filter = make_unique<BoundComparisonExpression>(comparison.type, comparison.left->Copy(),
-				                                                     comparison.right->Copy());
-				remaining_filters.push_back(move(filter));
-				is_inserted = true;
-			}
-		} else {
-			// we cannot add a new filter
-			continue;
-		}
-		// Add the new filer into the left set
-		if (AddConstantComparison(left_constants, info) == FilterResult::UNSATISFIABLE) {
-			return FilterResult::UNSATISFIABLE;
-		}
-		is_successful = true;
-	}
-	if (is_successful) {
-		// now check for remaining trasitive filters from the left column
-		auto transitive_filter = FindTransitiveFilter(comparison.left.get());
-		if (transitive_filter != nullptr) {
-			// try to add transitive filters
-			if (AddTransitiveFilters((BoundComparisonExpression &)*transitive_filter) == FilterResult::UNSUPPORTED) {
-				// in case of unsuccessful re-add filter into remaining ones
-				remaining_filters.push_back(move(transitive_filter));
-			}
-		}
-		return FilterResult::SUCCESS;
-	}
-
-	return FilterResult::UNSUPPORTED;
-}
-
-/*
- * Find a transitive filter already inserted into the remaining filters
- * Check for a match between the right column of bound comparisons and the expression,
- * then removes the bound comparison from the remaining filters and returns it
- */
-unique_ptr<Expression> FilterCombiner::FindTransitiveFilter(Expression *expr) {
-	// We only check for bound column ref
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		for (idx_t i = 0; i < remaining_filters.size(); i++) {
-			if (remaining_filters[i]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-				auto comparison = (BoundComparisonExpression *)remaining_filters[i].get();
-				if (expr->Equals(comparison->right.get()) && comparison->type != ExpressionType::COMPARE_NOTEQUAL) {
-					auto filter = move(remaining_filters[i]);
-					remaining_filters.erase(remaining_filters.begin() + i);
-					return filter;
-				}
-			}
-		}
-	}
-	return nullptr;
-}
-
-ValueComparisonResult InvertValueComparisonResult(ValueComparisonResult result) {
-	if (result == ValueComparisonResult::PRUNE_RIGHT) {
-		return ValueComparisonResult::PRUNE_LEFT;
-	}
-	if (result == ValueComparisonResult::PRUNE_LEFT) {
-		return ValueComparisonResult::PRUNE_RIGHT;
-	}
-	return result;
-}
-
-ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left, ExpressionValueInformation &right) {
-	if (left.comparison_type == ExpressionType::COMPARE_EQUAL) {
-		// left is COMPARE_EQUAL, we can either
-		// (1) prune the right side or
-		// (2) return UNSATISFIABLE
-		bool prune_right_side = false;
-		switch (right.comparison_type) {
-		case ExpressionType::COMPARE_LESSTHAN:
-			prune_right_side = left.constant < right.constant;
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			prune_right_side = left.constant <= right.constant;
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			prune_right_side = left.constant > right.constant;
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			prune_right_side = left.constant >= right.constant;
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-			prune_right_side = left.constant != right.constant;
-			break;
-		default:
-			D_ASSERT(right.comparison_type == ExpressionType::COMPARE_EQUAL);
-			prune_right_side = left.constant == right.constant;
-			break;
-		}
-		if (prune_right_side) {
-			return ValueComparisonResult::PRUNE_RIGHT;
-		} else {
-			return ValueComparisonResult::UNSATISFIABLE_CONDITION;
-		}
-	} else if (right.comparison_type == ExpressionType::COMPARE_EQUAL) {
-		// right is COMPARE_EQUAL
-		return InvertValueComparisonResult(CompareValueInformation(right, left));
-	} else if (left.comparison_type == ExpressionType::COMPARE_NOTEQUAL) {
-		// left is COMPARE_NOTEQUAL, we can either
-		// (1) prune the left side or
-		// (2) not prune anything
-		bool prune_left_side = false;
-		switch (right.comparison_type) {
-		case ExpressionType::COMPARE_LESSTHAN:
-			prune_left_side = left.constant >= right.constant;
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			prune_left_side = left.constant > right.constant;
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			prune_left_side = left.constant <= right.constant;
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			prune_left_side = left.constant < right.constant;
-			break;
-		default:
-			D_ASSERT(right.comparison_type == ExpressionType::COMPARE_NOTEQUAL);
-			prune_left_side = left.constant == right.constant;
-			break;
-		}
-		if (prune_left_side) {
-			return ValueComparisonResult::PRUNE_LEFT;
-		} else {
-			return ValueComparisonResult::PRUNE_NOTHING;
-		}
-	} else if (right.comparison_type == ExpressionType::COMPARE_NOTEQUAL) {
-		return InvertValueComparisonResult(CompareValueInformation(right, left));
-	} else if (IsGreaterThan(left.comparison_type) && IsGreaterThan(right.comparison_type)) {
-		// both comparisons are [>], we can either
-		// (1) prune the left side or
-		// (2) prune the right side
-		if (left.constant > right.constant) {
-			// left constant is more selective, prune right
-			return ValueComparisonResult::PRUNE_RIGHT;
-		} else if (left.constant < right.constant) {
-			// right constant is more selective, prune left
-			return ValueComparisonResult::PRUNE_LEFT;
-		} else {
-			// constants are equivalent
-			// however we can still have the scenario where one is [>=] and the other is [>]
-			// we want to prune the [>=] because [>] is more selective
-			// if left is [>=] we prune the left, else we prune the right
-			if (left.comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
-				return ValueComparisonResult::PRUNE_LEFT;
-			} else {
-				return ValueComparisonResult::PRUNE_RIGHT;
-			}
-		}
-	} else if (IsLessThan(left.comparison_type) && IsLessThan(right.comparison_type)) {
-		// both comparisons are [<], we can either
-		// (1) prune the left side or
-		// (2) prune the right side
-		if (left.constant < right.constant) {
-			// left constant is more selective, prune right
-			return ValueComparisonResult::PRUNE_RIGHT;
-		} else if (left.constant > right.constant) {
-			// right constant is more selective, prune left
-			return ValueComparisonResult::PRUNE_LEFT;
-		} else {
-			// constants are equivalent
-			// however we can still have the scenario where one is [<=] and the other is [<]
-			// we want to prune the [<=] because [<] is more selective
-			// if left is [<=] we prune the left, else we prune the right
-			if (left.comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO) {
-				return ValueComparisonResult::PRUNE_LEFT;
-			} else {
-				return ValueComparisonResult::PRUNE_RIGHT;
-			}
-		}
-	} else if (IsLessThan(left.comparison_type)) {
-		D_ASSERT(IsGreaterThan(right.comparison_type));
-		// left is [<] and right is [>], in this case we can either
-		// (1) prune nothing or
-		// (2) return UNSATISFIABLE
-		// the SMALLER THAN constant has to be greater than the BIGGER THAN constant
-		if (left.constant >= right.constant) {
-			return ValueComparisonResult::PRUNE_NOTHING;
-		} else {
-			return ValueComparisonResult::UNSATISFIABLE_CONDITION;
-		}
-	} else {
-		// left is [>] and right is [<] or [!=]
-		D_ASSERT(IsLessThan(right.comparison_type) && IsGreaterThan(left.comparison_type));
-		return InvertValueComparisonResult(CompareValueInformation(right, left));
-	}
-}
-//
-// void FilterCombiner::LookUpConjunctions(Expression *expr) {
-//	if (expr->GetExpressionType() == ExpressionType::CONJUNCTION_OR) {
-//		auto root_or_expr = (BoundConjunctionExpression *)expr;
-//		for (const auto &entry : map_col_conjunctions) {
-//			for (const auto &conjs_to_push : entry.second) {
-//				if (conjs_to_push->root_or->Equals(root_or_expr)) {
-//					return;
-//				}
-//			}
-//		}
-//
-//		cur_root_or = root_or_expr;
-//		cur_conjunction = root_or_expr;
-//		cur_colref_to_push = nullptr;
-//		if (!BFSLookUpConjunctions(cur_root_or)) {
-//			if (cur_colref_to_push) {
-//				auto entry = map_col_conjunctions.find(cur_colref_to_push);
-//				auto &vec_conjs_to_push = entry->second;
-//				if (vec_conjs_to_push.size() == 1) {
-//					map_col_conjunctions.erase(entry);
-//					return;
-//				}
-//				vec_conjs_to_push.pop_back();
-//			}
-//		}
-//		return;
-//	}
-//
-//	// Verify if the expression has a column already pushed down by other OR expression
-//	VerifyOrsToPush(*expr);
-//}
-//
-// bool FilterCombiner::BFSLookUpConjunctions(BoundConjunctionExpression *conjunction) {
-//	vector<BoundConjunctionExpression *> conjunctions_to_visit;
-//
-//	for (auto &child : conjunction->children) {
-//		switch (child->GetExpressionClass()) {
-//		case ExpressionClass::BOUND_CONJUNCTION: {
-//			auto child_conjunction = (BoundConjunctionExpression *)child.get();
-//			conjunctions_to_visit.emplace_back(child_conjunction);
-//			break;
-//		}
-//		case ExpressionClass::BOUND_COMPARISON: {
-//			if (!UpdateConjunctionFilter((BoundComparisonExpression *)child.get())) {
-//				return false;
-//			}
-//			break;
-//		}
-//		default: {
-//			return false;
-//		}
-//		}
-//	}
-//
-//	for (auto child_conjunction : conjunctions_to_visit) {
-//		cur_conjunction = child_conjunction;
-//		// traverse child conjuction
-//		if (!BFSLookUpConjunctions(child_conjunction)) {
-//			return false;
-//		}
-//	}
-//	return true;
-//}
-//
-// void FilterCombiner::VerifyOrsToPush(Expression &expr) {
-//	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-//		auto colref = (BoundColumnRefExpression *)&expr;
-//		auto entry = map_col_conjunctions.find(colref);
-//		if (entry == map_col_conjunctions.end()) {
-//			return;
-//		}
-//		map_col_conjunctions.erase(entry);
-//	}
-//	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { VerifyOrsToPush(child); });
-//}
-//
-// bool FilterCombiner::UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr) {
-//	bool left_is_scalar = comparison_expr->left->IsFoldable();
-//	bool right_is_scalar = comparison_expr->right->IsFoldable();
-//
-//	Expression *non_scalar_expr;
-//	if (left_is_scalar || right_is_scalar) {
-//		// only support comparison with scalar
-//		non_scalar_expr = left_is_scalar ? comparison_expr->right.get() : comparison_expr->left.get();
-//
-//		if (non_scalar_expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-//			return UpdateFilterByColumn((BoundColumnRefExpression *)non_scalar_expr, comparison_expr);
-//		}
-//	}
-//
-//	return false;
-//}
-//
-// bool FilterCombiner::UpdateFilterByColumn(BoundColumnRefExpression *column_ref,
-//                                          BoundComparisonExpression *comparison_expr) {
-//	if (cur_colref_to_push == nullptr) {
-//		cur_colref_to_push = column_ref;
-//
-//		auto or_conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
-//		or_conjunction->children.emplace_back(comparison_expr->Copy());
-//
-//		unique_ptr<ConjunctionsToPush> conjs_to_push = make_unique<ConjunctionsToPush>();
-//		conjs_to_push->conjunctions.emplace_back(move(or_conjunction));
-//		conjs_to_push->root_or = cur_root_or;
-//
-//		auto &&vec_col_conjs = map_col_conjunctions[column_ref];
-//		vec_col_conjs.emplace_back(move(conjs_to_push));
-//		vec_colref_insertion_order.emplace_back(column_ref);
-//		return true;
-//	}
-//
-//	auto entry = map_col_conjunctions.find(cur_colref_to_push);
-//	D_ASSERT(entry != map_col_conjunctions.end());
-//	auto &conjunctions_to_push = entry->second.back();
-//
-//	if (!cur_colref_to_push->Equals(column_ref)) {
-//		// check for multiple colunms in the same root OR node
-//		if (cur_root_or == cur_conjunction) {
-//			return false;
-//		}
-//		// found an AND using a different column, we should stop the look up
-//		if (cur_conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-//			return false;
-//		}
-//
-//		// found a different column, AND conditions cannot be preserved anymore
-//		conjunctions_to_push->preserve_and = false;
-//		return true;
-//	}
-//
-//	auto &last_conjunction = conjunctions_to_push->conjunctions.back();
-//	if (cur_conjunction->GetExpressionType() == last_conjunction->GetExpressionType()) {
-//		last_conjunction->children.emplace_back(comparison_expr->Copy());
-//	} else {
-//		auto new_conjunction = make_unique<BoundConjunctionExpression>(cur_conjunction->GetExpressionType());
-//		new_conjunction->children.emplace_back(comparison_expr->Copy());
-//		conjunctions_to_push->conjunctions.emplace_back(move(new_conjunction));
-//	}
-//	return true;
-//}
-//
-// void FilterCombiner::GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids) {
-//	for (const auto colref : vec_colref_insertion_order) {
-//		auto column_index = column_ids[colref->binding.column_index];
-//		if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-//			break;
-//		}
-//
-//		for (const auto &conjunctions_to_push : map_col_conjunctions[colref]) {
-//			// root OR filter to push into the TableFilter
-//			auto root_or_filter = make_unique<ConjunctionOrFilter>();
-//			// variable to hold the last conjuntion filter pointer
-//			// the next filter will be added into it, i.e., we create a chain of conjunction filters
-//			ConjunctionFilter *last_conj_filter = root_or_filter.get();
-//
-//			for (auto &conjunction : conjunctions_to_push->conjunctions) {
-//				if (conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND &&
-//				    conjunctions_to_push->preserve_and) {
-//					GenerateConjunctionFilter<ConjunctionAndFilter>(conjunction.get(), last_conj_filter);
-//				} else {
-//					GenerateConjunctionFilter<ConjunctionOrFilter>(conjunction.get(), last_conj_filter);
-//				}
-//			}
-//			table_filter.PushFilter(column_index, move(root_or_filter));
-//		}
-//	}
-//	map_col_conjunctions.clear();
-//	vec_colref_insertion_order.clear();
-//}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op) {
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return PullupFilter(move(op));
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return PullupProjection(move(op));
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return PullupCrossProduct(move(op));
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return PullupJoin(move(op));
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-		return PullupSetOperation(move(op));
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-	case LogicalOperatorType::LOGICAL_ORDER_BY: {
-		// we can just pull directly through these operations without any rewriting
-		op->children[0] = Rewrite(move(op->children[0]));
-		return op;
-	}
-	default:
-		return FinishPullup(move(op));
-	}
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &join = (LogicalJoin &)*op;
-
-	switch (join.join_type) {
-	case JoinType::INNER:
-		return PullupInnerJoin(move(op));
-	case JoinType::LEFT:
-	case JoinType::ANTI:
-	case JoinType::SEMI: {
-		can_add_column = true;
-		return PullupFromLeft(move(op));
-	}
-	default:
-		// unsupported join type: call children pull up
-		return FinishPullup(move(op));
-	}
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupInnerJoin(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(((LogicalJoin &)*op).join_type == JoinType::INNER);
-	D_ASSERT(op->type != LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	return PullupBothSide(move(op));
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupCrossProduct(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT);
-	return PullupBothSide(move(op));
-}
-
-unique_ptr<LogicalOperator> FilterPullup::GeneratePullupFilter(unique_ptr<LogicalOperator> child,
-                                                               vector<unique_ptr<Expression>> &expressions) {
-	unique_ptr<LogicalFilter> filter = make_unique<LogicalFilter>();
-	for (idx_t i = 0; i < expressions.size(); ++i) {
-		filter->expressions.push_back(move(expressions[i]));
-	}
-	expressions.clear();
-	filter->children.push_back(move(child));
-	return move(filter);
-}
-
-unique_ptr<LogicalOperator> FilterPullup::FinishPullup(unique_ptr<LogicalOperator> op) {
-	// unhandled type, first perform filter pushdown in its children
-	for (idx_t i = 0; i < op->children.size(); i++) {
-		FilterPullup pullup;
-		op->children[i] = pullup.Rewrite(move(op->children[i]));
-	}
-	// now pull up any existing filters
-	if (filters_expr_pullup.empty()) {
-		// no filters to pull up
-		return op;
-	}
-	return GeneratePullupFilter(move(op), filters_expr_pullup);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(!combiner.HasFilters());
-	switch (op->type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return PushdownAggregate(move(op));
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return PushdownFilter(move(op));
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return PushdownCrossProduct(move(op));
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return PushdownJoin(move(op));
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return PushdownProjection(move(op));
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_UNION:
-		return PushdownSetOperation(move(op));
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-	case LogicalOperatorType::LOGICAL_ORDER_BY: {
-		// we can just push directly through these operations without any rewriting
-		op->children[0] = Rewrite(move(op->children[0]));
-		return op;
-	}
-	case LogicalOperatorType::LOGICAL_GET:
-		return PushdownGet(move(op));
-	case LogicalOperatorType::LOGICAL_LIMIT:
-		return PushdownLimit(move(op));
-	default:
-		return FinishPushdown(move(op));
-	}
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &join = (LogicalJoin &)*op;
-	unordered_set<idx_t> left_bindings, right_bindings;
-	LogicalJoin::GetTableReferences(*op->children[0], left_bindings);
-	LogicalJoin::GetTableReferences(*op->children[1], right_bindings);
-
-	switch (join.join_type) {
-	case JoinType::INNER:
-		return PushdownInnerJoin(move(op), left_bindings, right_bindings);
-	case JoinType::LEFT:
-		return PushdownLeftJoin(move(op), left_bindings, right_bindings);
-	case JoinType::MARK:
-		return PushdownMarkJoin(move(op), left_bindings, right_bindings);
-	case JoinType::SINGLE:
-		return PushdownSingleJoin(move(op), left_bindings, right_bindings);
-	default:
-		// unsupported join type: stop pushing down
-		return FinishPushdown(move(op));
-	}
-}
-void FilterPushdown::PushFilters() {
-	for (auto &f : filters) {
-		auto result = combiner.AddFilter(move(f->filter));
-		D_ASSERT(result == FilterResult::SUCCESS);
-		(void)result;
-	}
-	filters.clear();
-}
-
-FilterResult FilterPushdown::AddFilter(unique_ptr<Expression> expr) {
-	PushFilters();
-	// split up the filters by AND predicate
-	vector<unique_ptr<Expression>> expressions;
-	expressions.push_back(move(expr));
-	LogicalFilter::SplitPredicates(expressions);
-	// push the filters into the combiner
-	for (auto &child_expr : expressions) {
-		if (combiner.AddFilter(move(child_expr)) == FilterResult::UNSATISFIABLE) {
-			return FilterResult::UNSATISFIABLE;
-		}
-	}
-	return FilterResult::SUCCESS;
-}
-
-void FilterPushdown::GenerateFilters() {
-	if (!filters.empty()) {
-		D_ASSERT(!combiner.HasFilters());
-		return;
-	}
-	combiner.GenerateFilters([&](unique_ptr<Expression> filter) {
-		auto f = make_unique<Filter>();
-		f->filter = move(filter);
-		f->ExtractBindings();
-		filters.push_back(move(f));
-	});
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
-	// unhandled type, first perform filter pushdown in its children
-	for (auto &child : op->children) {
-		FilterPushdown pushdown(optimizer);
-		child = pushdown.Rewrite(move(child));
-	}
-	// now push any existing filters
-	if (filters.empty()) {
-		// no filters to push
-		return op;
-	}
-	auto filter = make_unique<LogicalFilter>();
-	for (auto &f : filters) {
-		filter->expressions.push_back(move(f->filter));
-	}
-	filter->children.push_back(move(op));
-	return move(filter);
-}
-
-void FilterPushdown::Filter::ExtractBindings() {
-	bindings.clear();
-	LogicalJoin::GetExpressionBindings(*filter, bindings);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> InClauseRewriter::Rewrite(unique_ptr<LogicalOperator> op) {
-	if (op->children.size() == 1) {
-		root = move(op->children[0]);
-		VisitOperatorExpressions(*op);
-		op->children[0] = move(root);
-	}
-
-	for (auto &child : op->children) {
-		child = Rewrite(move(child));
-	}
-	return op;
-}
-
-unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr) {
-	if (expr.type != ExpressionType::COMPARE_IN && expr.type != ExpressionType::COMPARE_NOT_IN) {
-		return nullptr;
-	}
-	D_ASSERT(root);
-	auto in_type = expr.children[0]->return_type;
-	bool is_regular_in = expr.type == ExpressionType::COMPARE_IN;
-	bool all_scalar = true;
-	// IN clause with many children: try to generate a mark join that replaces this IN expression
-	// we can only do this if the expressions in the expression list are scalar
-	for (idx_t i = 1; i < expr.children.size(); i++) {
-		D_ASSERT(expr.children[i]->return_type == in_type);
-		if (!expr.children[i]->IsFoldable()) {
-			// non-scalar expression
-			all_scalar = false;
-		}
-	}
-	if (expr.children.size() == 2) {
-		// only one child
-		// IN: turn into X = 1
-		// NOT IN: turn into X <> 1
-		return make_unique<BoundComparisonExpression>(is_regular_in ? ExpressionType::COMPARE_EQUAL
-		                                                            : ExpressionType::COMPARE_NOTEQUAL,
-		                                              move(expr.children[0]), move(expr.children[1]));
-	}
-	if (expr.children.size() < 6 || !all_scalar) {
-		// low amount of children or not all scalar
-		// IN: turn into (X = 1 OR X = 2 OR X = 3...)
-		// NOT IN: turn into (X <> 1 AND X <> 2 AND X <> 3 ...)
-		auto conjunction = make_unique<BoundConjunctionExpression>(is_regular_in ? ExpressionType::CONJUNCTION_OR
-		                                                                         : ExpressionType::CONJUNCTION_AND);
-		for (idx_t i = 1; i < expr.children.size(); i++) {
-			conjunction->children.push_back(make_unique<BoundComparisonExpression>(
-			    is_regular_in ? ExpressionType::COMPARE_EQUAL : ExpressionType::COMPARE_NOTEQUAL,
-			    expr.children[0]->Copy(), move(expr.children[i])));
-		}
-		return move(conjunction);
-	}
-	// IN clause with many constant children
-	// generate a mark join that replaces this IN expression
-	// first generate a ChunkCollection from the set of expressions
-	vector<LogicalType> types = {in_type};
-	auto collection = make_unique<ChunkCollection>(context);
-	DataChunk chunk;
-	chunk.Initialize(context, types);
-	for (idx_t i = 1; i < expr.children.size(); i++) {
-		// resolve this expression to a constant
-		auto value = ExpressionExecutor::EvaluateScalar(*expr.children[i]);
-		idx_t index = chunk.size();
-		chunk.SetCardinality(chunk.size() + 1);
-		chunk.SetValue(0, index, value);
-		if (chunk.size() == STANDARD_VECTOR_SIZE || i + 1 == expr.children.size()) {
-			// chunk full: append to chunk collection
-			collection->Append(chunk);
-			chunk.Reset();
-		}
-	}
-	// now generate a ChunkGet that scans this collection
-	auto chunk_index = optimizer.binder.GenerateTableIndex();
-	auto chunk_scan = make_unique<LogicalChunkGet>(chunk_index, types, move(collection));
-
-	// then we generate the MARK join with the chunk scan on the RHS
-	auto join = make_unique<LogicalComparisonJoin>(JoinType::MARK);
-	join->mark_index = chunk_index;
-	join->AddChild(move(root));
-	join->AddChild(move(chunk_scan));
-	// create the JOIN condition
-	JoinCondition cond;
-	cond.left = move(expr.children[0]);
-
-	cond.right = make_unique<BoundColumnRefExpression>(in_type, ColumnBinding(chunk_index, 0));
-	cond.comparison = ExpressionType::COMPARE_EQUAL;
-	join->conditions.push_back(move(cond));
-	root = move(join);
-
-	// we replace the original subquery with a BoundColumnRefExpression referring to the mark column
-	unique_ptr<Expression> result =
-	    make_unique<BoundColumnRefExpression>("IN (...)", LogicalType::BOOLEAN, ColumnBinding(chunk_index, 0));
-	if (!is_regular_in) {
-		// NOT IN: invert
-		auto invert = make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_NOT, LogicalType::BOOLEAN);
-		invert->children.push_back(move(result));
-		result = move(invert);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-using JoinRelationTreeNode = JoinRelationSetManager::JoinRelationTreeNode;
-
-// LCOV_EXCL_START
-string JoinRelationSet::ToString() const {
-	string result = "[";
-	result += StringUtil::Join(relations, count, ", ", [](const idx_t &relation) { return to_string(relation); });
-	result += "]";
-	return result;
-}
-// LCOV_EXCL_STOP
-
-//! Returns true if sub is a subset of super
-bool JoinRelationSet::IsSubset(JoinRelationSet *super, JoinRelationSet *sub) {
-	D_ASSERT(sub->count > 0);
-	if (sub->count > super->count) {
-		return false;
-	}
-	idx_t j = 0;
-	for (idx_t i = 0; i < super->count; i++) {
-		if (sub->relations[j] == super->relations[i]) {
-			j++;
-			if (j == sub->count) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-JoinRelationSet *JoinRelationSetManager::GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count) {
-	// now look it up in the tree
-	JoinRelationTreeNode *info = &root;
-	for (idx_t i = 0; i < count; i++) {
-		auto entry = info->children.find(relations[i]);
-		if (entry == info->children.end()) {
-			// node not found, create it
-			auto insert_it = info->children.insert(make_pair(relations[i], make_unique<JoinRelationTreeNode>()));
-			entry = insert_it.first;
-		}
-		// move to the next node
-		info = entry->second.get();
-	}
-	// now check if the JoinRelationSet has already been created
-	if (!info->relation) {
-		// if it hasn't we need to create it
-		info->relation = make_unique<JoinRelationSet>(move(relations), count);
-	}
-	return info->relation.get();
-}
-
-//! Create or get a JoinRelationSet from a single node with the given index
-JoinRelationSet *JoinRelationSetManager::GetJoinRelation(idx_t index) {
-	// create a sorted vector of the relations
-	auto relations = unique_ptr<idx_t[]>(new idx_t[1]);
-	relations[0] = index;
-	idx_t count = 1;
-	return GetJoinRelation(move(relations), count);
-}
-
-JoinRelationSet *JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &bindings) {
-	// create a sorted vector of the relations
-	unique_ptr<idx_t[]> relations = bindings.empty() ? nullptr : unique_ptr<idx_t[]>(new idx_t[bindings.size()]);
-	idx_t count = 0;
-	for (auto &entry : bindings) {
-		relations[count++] = entry;
-	}
-	std::sort(relations.get(), relations.get() + count);
-	return GetJoinRelation(move(relations), count);
-}
-
-JoinRelationSet *JoinRelationSetManager::Union(JoinRelationSet *left, JoinRelationSet *right) {
-	auto relations = unique_ptr<idx_t[]>(new idx_t[left->count + right->count]);
-	idx_t count = 0;
-	// move through the left and right relations, eliminating duplicates
-	idx_t i = 0, j = 0;
-	while (true) {
-		if (i == left->count) {
-			// exhausted left relation, add remaining of right relation
-			for (; j < right->count; j++) {
-				relations[count++] = right->relations[j];
-			}
-			break;
-		} else if (j == right->count) {
-			// exhausted right relation, add remaining of left
-			for (; i < left->count; i++) {
-				relations[count++] = left->relations[i];
-			}
-			break;
-		} else if (left->relations[i] == right->relations[j]) {
-			// equivalent, add only one of the two pairs
-			relations[count++] = left->relations[i];
-			i++;
-			j++;
-		} else if (left->relations[i] < right->relations[j]) {
-			// left is smaller, progress left and add it to the set
-			relations[count++] = left->relations[i];
-			i++;
-		} else {
-			// right is smaller, progress right and add it to the set
-			relations[count++] = right->relations[j];
-			j++;
-		}
-	}
-	return GetJoinRelation(move(relations), count);
-}
-
-// JoinRelationSet *JoinRelationSetManager::Difference(JoinRelationSet *left, JoinRelationSet *right) {
-// 	auto relations = unique_ptr<idx_t[]>(new idx_t[left->count]);
-// 	idx_t count = 0;
-// 	// move through the left and right relations
-// 	idx_t i = 0, j = 0;
-// 	while (true) {
-// 		if (i == left->count) {
-// 			// exhausted left relation, we are done
-// 			break;
-// 		} else if (j == right->count) {
-// 			// exhausted right relation, add remaining of left
-// 			for (; i < left->count; i++) {
-// 				relations[count++] = left->relations[i];
-// 			}
-// 			break;
-// 		} else if (left->relations[i] == right->relations[j]) {
-// 			// equivalent, add nothing
-// 			i++;
-// 			j++;
-// 		} else if (left->relations[i] < right->relations[j]) {
-// 			// left is smaller, progress left and add it to the set
-// 			relations[count++] = left->relations[i];
-// 			i++;
-// 		} else {
-// 			// right is smaller, progress right
-// 			j++;
-// 		}
-// 	}
-// 	return GetJoinRelation(move(relations), count);
-// }
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-using QueryEdge = QueryGraph::QueryEdge;
-
-// LCOV_EXCL_START
-static string QueryEdgeToString(const QueryEdge *info, vector<idx_t> prefix) {
-	string result = "";
-	string source = "[";
-	for (idx_t i = 0; i < prefix.size(); i++) {
-		source += to_string(prefix[i]) + (i < prefix.size() - 1 ? ", " : "");
-	}
-	source += "]";
-	for (auto &entry : info->neighbors) {
-		result += StringUtil::Format("%s -> %s\n", source.c_str(), entry->neighbor->ToString().c_str());
-	}
-	for (auto &entry : info->children) {
-		vector<idx_t> new_prefix = prefix;
-		new_prefix.push_back(entry.first);
-		result += QueryEdgeToString(entry.second.get(), new_prefix);
-	}
-	return result;
-}
-
-string QueryGraph::ToString() const {
-	return QueryEdgeToString(&root, {});
-}
-
-void QueryGraph::Print() {
-	Printer::Print(ToString());
-}
-// LCOV_EXCL_STOP
-
-QueryEdge *QueryGraph::GetQueryEdge(JoinRelationSet *left) {
-	D_ASSERT(left && left->count > 0);
-	// find the EdgeInfo corresponding to the left set
-	QueryEdge *info = &root;
-	for (idx_t i = 0; i < left->count; i++) {
-		auto entry = info->children.find(left->relations[i]);
-		if (entry == info->children.end()) {
-			// node not found, create it
-			auto insert_it = info->children.insert(make_pair(left->relations[i], make_unique<QueryEdge>()));
-			entry = insert_it.first;
-		}
-		// move to the next node
-		info = entry->second.get();
-	}
-	return info;
-}
-
-void QueryGraph::CreateEdge(JoinRelationSet *left, JoinRelationSet *right, FilterInfo *filter_info) {
-	D_ASSERT(left && right && left->count > 0 && right->count > 0);
-	// find the EdgeInfo corresponding to the left set
-	auto info = GetQueryEdge(left);
-	// now insert the edge to the right relation, if it does not exist
-	for (idx_t i = 0; i < info->neighbors.size(); i++) {
-		if (info->neighbors[i]->neighbor == right) {
-			if (filter_info) {
-				// neighbor already exists just add the filter, if we have any
-				info->neighbors[i]->filters.push_back(filter_info);
-			}
-			return;
-		}
-	}
-	// neighbor does not exist, create it
-	auto n = make_unique<NeighborInfo>();
-	if (filter_info) {
-		n->filters.push_back(filter_info);
-	}
-	n->neighbor = right;
-	info->neighbors.push_back(move(n));
-}
-
-void QueryGraph::EnumerateNeighbors(JoinRelationSet *node, const std::function<bool(NeighborInfo *)> &callback) {
-	for (idx_t j = 0; j < node->count; j++) {
-		QueryEdge *info = &root;
-		for (idx_t i = j; i < node->count; i++) {
-			auto entry = info->children.find(node->relations[i]);
-			if (entry == info->children.end()) {
-				// node not found
-				break;
-			}
-			// check if any subset of the other set is in this sets neighbors
-			info = entry->second.get();
-			for (auto &neighbor : info->neighbors) {
-				if (callback(neighbor.get())) {
-					return;
-				}
-			}
-		}
-	}
-}
-
-//! Returns true if a JoinRelationSet is banned by the list of exclusion_set, false otherwise
-static bool JoinRelationSetIsExcluded(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set) {
-	return exclusion_set.find(node->relations[0]) != exclusion_set.end();
-}
-
-vector<idx_t> QueryGraph::GetNeighbors(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set) {
-	unordered_set<idx_t> result;
-	EnumerateNeighbors(node, [&](NeighborInfo *info) -> bool {
-		if (!JoinRelationSetIsExcluded(info->neighbor, exclusion_set)) {
-			// add the smallest node of the neighbor to the set
-			result.insert(info->neighbor->relations[0]);
-		}
-		return false;
-	});
-	vector<idx_t> neighbors;
-	neighbors.insert(neighbors.end(), result.begin(), result.end());
-	return neighbors;
-}
-
-NeighborInfo *QueryGraph::GetConnection(JoinRelationSet *node, JoinRelationSet *other) {
-	NeighborInfo *connection = nullptr;
-	EnumerateNeighbors(node, [&](NeighborInfo *info) -> bool {
-		if (JoinRelationSet::IsSubset(other, info->neighbor)) {
-			connection = info;
-			return true;
-		}
-		return false;
-	});
-	return connection;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-using JoinNode = JoinOrderOptimizer::JoinNode;
-
-//! Returns true if A and B are disjoint, false otherwise
-template <class T>
-static bool Disjoint(unordered_set<T> &a, unordered_set<T> &b) {
-	for (auto &entry : a) {
-		if (b.find(entry) != b.end()) {
-			return false;
-		}
-	}
-	return true;
-}
-
-//! Extract the set of relations referred to inside an expression
-bool JoinOrderOptimizer::ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings) {
-	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expression;
-		D_ASSERT(colref.depth == 0);
-		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
-		// map the base table index to the relation index used by the JoinOrderOptimizer
-		D_ASSERT(relation_mapping.find(colref.binding.table_index) != relation_mapping.end());
-		bindings.insert(relation_mapping[colref.binding.table_index]);
-	}
-	if (expression.type == ExpressionType::BOUND_REF) {
-		// bound expression
-		bindings.clear();
-		return false;
-	}
-	D_ASSERT(expression.type != ExpressionType::SUBQUERY);
-	bool can_reorder = true;
-	ExpressionIterator::EnumerateChildren(expression, [&](Expression &expr) {
-		if (!ExtractBindings(expr, bindings)) {
-			can_reorder = false;
-			return;
-		}
-	});
-	return can_reorder;
-}
-
-static unique_ptr<LogicalOperator> PushFilter(unique_ptr<LogicalOperator> node, unique_ptr<Expression> expr) {
-	// push an expression into a filter
-	// first check if we have any filter to push it into
-	if (node->type != LogicalOperatorType::LOGICAL_FILTER) {
-		// we don't, we need to create one
-		auto filter = make_unique<LogicalFilter>();
-		filter->children.push_back(move(node));
-		node = move(filter);
-	}
-	// push the filter into the LogicalFilter
-	D_ASSERT(node->type == LogicalOperatorType::LOGICAL_FILTER);
-	auto filter = (LogicalFilter *)node.get();
-	filter->expressions.push_back(move(expr));
-	return node;
-}
-
-bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<LogicalOperator *> &filter_operators,
-                                              LogicalOperator *parent) {
-	LogicalOperator *op = &input_op;
-	while (op->children.size() == 1 && (op->type != LogicalOperatorType::LOGICAL_PROJECTION &&
-	                                    op->type != LogicalOperatorType::LOGICAL_EXPRESSION_GET)) {
-		if (op->type == LogicalOperatorType::LOGICAL_FILTER) {
-			// extract join conditions from filter
-			filter_operators.push_back(op);
-		}
-		if (op->type == LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY ||
-		    op->type == LogicalOperatorType::LOGICAL_WINDOW) {
-			// don't push filters through projection or aggregate and group by
-			JoinOrderOptimizer optimizer(context);
-			op->children[0] = optimizer.Optimize(move(op->children[0]));
-			return false;
-		}
-		op = op->children[0].get();
-	}
-	bool non_reorderable_operation = false;
-	if (op->type == LogicalOperatorType::LOGICAL_UNION || op->type == LogicalOperatorType::LOGICAL_EXCEPT ||
-	    op->type == LogicalOperatorType::LOGICAL_INTERSECT || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN ||
-	    op->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
-		// set operation, optimize separately in children
-		non_reorderable_operation = true;
-	}
-
-	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		auto &join = (LogicalComparisonJoin &)*op;
-		if (join.join_type == JoinType::INNER) {
-			// extract join conditions from inner join
-			filter_operators.push_back(op);
-		} else {
-			// non-inner join, not reorderable yet
-			non_reorderable_operation = true;
-			if (join.join_type == JoinType::LEFT && join.right_projection_map.empty()) {
-				// for left joins; if the RHS cardinality is significantly larger than the LHS (2x)
-				// we convert to doing a RIGHT OUTER JOIN
-				// FIXME: for now we don't swap if the right_projection_map is not empty
-				// this can be fixed once we implement the left_projection_map properly...
-				auto lhs_cardinality = join.children[0]->EstimateCardinality(context);
-				auto rhs_cardinality = join.children[1]->EstimateCardinality(context);
-				if (rhs_cardinality > lhs_cardinality * 2) {
-					join.join_type = JoinType::RIGHT;
-					std::swap(join.children[0], join.children[1]);
-					for (auto &cond : join.conditions) {
-						std::swap(cond.left, cond.right);
-						cond.comparison = FlipComparisionExpression(cond.comparison);
-					}
-				}
-			}
-		}
-	}
-	if (non_reorderable_operation) {
-		// we encountered a non-reordable operation (setop or non-inner join)
-		// we do not reorder non-inner joins yet, however we do want to expand the potential join graph around them
-		// non-inner joins are also tricky because we can't freely make conditions through them
-		// e.g. suppose we have (left LEFT OUTER JOIN right WHERE right IS NOT NULL), the join can generate
-		// new NULL values in the right side, so pushing this condition through the join leads to incorrect results
-		// for this reason, we just start a new JoinOptimizer pass in each of the children of the join
-		for (auto &child : op->children) {
-			JoinOrderOptimizer optimizer(context);
-			child = optimizer.Optimize(move(child));
-		}
-		// after this we want to treat this node as one  "end node" (like e.g. a base relation)
-		// however the join refers to multiple base relations
-		// enumerate all base relations obtained from this join and add them to the relation mapping
-		// also, we have to resolve the join conditions for the joins here
-		// get the left and right bindings
-		unordered_set<idx_t> bindings;
-		LogicalJoin::GetTableReferences(*op, bindings);
-		// now create the relation that refers to all these bindings
-		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
-		for (idx_t it : bindings) {
-			relation_mapping[it] = relations.size();
-		}
-		relations.push_back(move(relation));
-		return true;
-	}
-	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	    op->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
-		// inner join or cross product
-		bool can_reorder_left = ExtractJoinRelations(*op->children[0], filter_operators, op);
-		bool can_reorder_right = ExtractJoinRelations(*op->children[1], filter_operators, op);
-		return can_reorder_left && can_reorder_right;
-	} else if (op->type == LogicalOperatorType::LOGICAL_GET) {
-		// base table scan, add to set of relations
-		auto get = (LogicalGet *)op;
-		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
-		relation_mapping[get->table_index] = relations.size();
-		relations.push_back(move(relation));
-		return true;
-	} else if (op->type == LogicalOperatorType::LOGICAL_EXPRESSION_GET) {
-		// base table scan, add to set of relations
-		auto get = (LogicalExpressionGet *)op;
-		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
-		relation_mapping[get->table_index] = relations.size();
-		relations.push_back(move(relation));
-		return true;
-	} else if (op->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
-		// table function call, add to set of relations
-		auto dummy_scan = (LogicalDummyScan *)op;
-		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
-		relation_mapping[dummy_scan->table_index] = relations.size();
-		relations.push_back(move(relation));
-		return true;
-	} else if (op->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		auto proj = (LogicalProjection *)op;
-		// we run the join order optimizer witin the subquery as well
-		JoinOrderOptimizer optimizer(context);
-		op->children[0] = optimizer.Optimize(move(op->children[0]));
-		// projection, add to the set of relations
-		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
-		relation_mapping[proj->table_index] = relations.size();
-		relations.push_back(move(relation));
-		return true;
-	}
-	return false;
-}
-
-//! Update the exclusion set with all entries in the subgraph
-static void UpdateExclusionSet(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set) {
-	for (idx_t i = 0; i < node->count; i++) {
-		exclusion_set.insert(node->relations[i]);
-	}
-}
-
-//! Create a new JoinTree node by joining together two previous JoinTree nodes
-static unique_ptr<JoinNode> CreateJoinTree(JoinRelationSet *set, NeighborInfo *info, JoinNode *left, JoinNode *right) {
-	// for the hash join we want the right side (build side) to have the smallest cardinality
-	// also just a heuristic but for now...
-	// FIXME: we should probably actually benchmark that as well
-	// FIXME: should consider different join algorithms, should we pick a join algorithm here as well? (probably)
-	if (left->cardinality < right->cardinality) {
-		return CreateJoinTree(set, info, right, left);
-	}
-	// the expected cardinality is the max of the child cardinalities
-	// FIXME: we should obviously use better cardinality estimation here
-	// but for now we just assume foreign key joins only
-	idx_t expected_cardinality;
-	if (info->filters.empty()) {
-		// cross product
-		expected_cardinality = left->cardinality * right->cardinality;
-	} else {
-		// normal join, expect foreign key join
-		expected_cardinality = MaxValue(left->cardinality, right->cardinality);
-	}
-	// cost is expected_cardinality plus the cost of the previous plans
-	idx_t cost = expected_cardinality;
-	return make_unique<JoinNode>(set, info, left, right, expected_cardinality, cost);
-}
-
-JoinNode *JoinOrderOptimizer::EmitPair(JoinRelationSet *left, JoinRelationSet *right, NeighborInfo *info) {
-	// get the left and right join plans
-	auto &left_plan = plans[left];
-	auto &right_plan = plans[right];
-	auto new_set = set_manager.Union(left, right);
-	// create the join tree based on combining the two plans
-	auto new_plan = CreateJoinTree(new_set, info, left_plan.get(), right_plan.get());
-	// check if this plan is the optimal plan we found for this set of relations
-	auto entry = plans.find(new_set);
-	if (entry == plans.end() || new_plan->cost < entry->second->cost) {
-		// the plan is the optimal plan, move it into the dynamic programming tree
-		auto result = new_plan.get();
-		plans[new_set] = move(new_plan);
-		return result;
-	}
-	return entry->second.get();
-}
-
-bool JoinOrderOptimizer::TryEmitPair(JoinRelationSet *left, JoinRelationSet *right, NeighborInfo *info) {
-	pairs++;
-	if (pairs >= 2000) {
-		// when the amount of pairs gets too large we exit the dynamic programming and resort to a greedy algorithm
-		// FIXME: simple heuristic currently
-		// at 10K pairs stop searching exactly and switch to heuristic
-		return false;
-	}
-	EmitPair(left, right, info);
-	return true;
-}
-
-bool JoinOrderOptimizer::EmitCSG(JoinRelationSet *node) {
-	if (node->count == relations.size()) {
-		return true;
-	}
-	// create the exclusion set as everything inside the subgraph AND anything with members BELOW it
-	unordered_set<idx_t> exclusion_set;
-	for (idx_t i = 0; i < node->relations[0]; i++) {
-		exclusion_set.insert(i);
-	}
-	UpdateExclusionSet(node, exclusion_set);
-	// find the neighbors given this exclusion set
-	auto neighbors = query_graph.GetNeighbors(node, exclusion_set);
-	if (neighbors.empty()) {
-		return true;
-	}
-	// we iterate over the neighbors ordered by their first node
-	sort(neighbors.begin(), neighbors.end());
-	for (auto neighbor : neighbors) {
-		// since the GetNeighbors only returns the smallest element in a list, the entry might not be connected to
-		// (only!) this neighbor,  hence we have to do a connectedness check before we can emit it
-		auto neighbor_relation = set_manager.GetJoinRelation(neighbor);
-		auto connection = query_graph.GetConnection(node, neighbor_relation);
-		if (connection) {
-			if (!TryEmitPair(node, neighbor_relation, connection)) {
-				return false;
-			}
-		}
-		if (!EnumerateCmpRecursive(node, neighbor_relation, exclusion_set)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool JoinOrderOptimizer::EnumerateCmpRecursive(JoinRelationSet *left, JoinRelationSet *right,
-                                               unordered_set<idx_t> exclusion_set) {
-	// get the neighbors of the second relation under the exclusion set
-	auto neighbors = query_graph.GetNeighbors(right, exclusion_set);
-	if (neighbors.empty()) {
-		return true;
-	}
-	vector<JoinRelationSet *> union_sets;
-	union_sets.resize(neighbors.size());
-	for (idx_t i = 0; i < neighbors.size(); i++) {
-		auto neighbor = set_manager.GetJoinRelation(neighbors[i]);
-		// emit the combinations of this node and its neighbors
-		auto combined_set = set_manager.Union(right, neighbor);
-		if (combined_set->count > right->count && plans.find(combined_set) != plans.end()) {
-			auto connection = query_graph.GetConnection(left, combined_set);
-			if (connection) {
-				if (!TryEmitPair(left, combined_set, connection)) {
-					return false;
-				}
-			}
-		}
-		union_sets[i] = combined_set;
-	}
-	// recursively enumerate the sets
-	unordered_set<idx_t> new_exclusion_set = exclusion_set;
-	for (idx_t i = 0; i < neighbors.size(); i++) {
-		// updated the set of excluded entries with this neighbor
-		new_exclusion_set.insert(neighbors[i]);
-		if (!EnumerateCmpRecursive(left, union_sets[i], new_exclusion_set)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool JoinOrderOptimizer::EnumerateCSGRecursive(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set) {
-	// find neighbors of S under the exlusion set
-	auto neighbors = query_graph.GetNeighbors(node, exclusion_set);
-	if (neighbors.empty()) {
-		return true;
-	}
-	// now first emit the connected subgraphs of the neighbors
-	vector<JoinRelationSet *> union_sets;
-	union_sets.resize(neighbors.size());
-	for (idx_t i = 0; i < neighbors.size(); i++) {
-		auto neighbor = set_manager.GetJoinRelation(neighbors[i]);
-		// emit the combinations of this node and its neighbors
-		auto new_set = set_manager.Union(node, neighbor);
-		if (new_set->count > node->count && plans.find(new_set) != plans.end()) {
-			if (!EmitCSG(new_set)) {
-				return false;
-			}
-		}
-		union_sets[i] = new_set;
-	}
-	// recursively enumerate the sets
-	unordered_set<idx_t> new_exclusion_set = exclusion_set;
-	for (idx_t i = 0; i < neighbors.size(); i++) {
-		// updated the set of excluded entries with this neighbor
-		new_exclusion_set.insert(neighbors[i]);
-		if (!EnumerateCSGRecursive(union_sets[i], new_exclusion_set)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool JoinOrderOptimizer::SolveJoinOrderExactly() {
-	// now we perform the actual dynamic programming to compute the final result
-	// we enumerate over all the possible pairs in the neighborhood
-	for (idx_t i = relations.size(); i > 0; i--) {
-		// for every node in the set, we consider it as the start node once
-		auto start_node = set_manager.GetJoinRelation(i - 1);
-		// emit the start node
-		if (!EmitCSG(start_node)) {
-			return false;
-		}
-		// initialize the set of exclusion_set as all the nodes with a number below this
-		unordered_set<idx_t> exclusion_set;
-		for (idx_t j = 0; j < i - 1; j++) {
-			exclusion_set.insert(j);
-		}
-		// then we recursively search for neighbors that do not belong to the banned entries
-		if (!EnumerateCSGRecursive(start_node, exclusion_set)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void JoinOrderOptimizer::SolveJoinOrderApproximately() {
-	// at this point, we exited the dynamic programming but did not compute the final join order because it took too
-	// long instead, we use a greedy heuristic to obtain a join ordering now we use Greedy Operator Ordering to
-	// construct the result tree first we start out with all the base relations (the to-be-joined relations)
-	vector<JoinRelationSet *> join_relations; // T in the paper
-	for (idx_t i = 0; i < relations.size(); i++) {
-		join_relations.push_back(set_manager.GetJoinRelation(i));
-	}
-	while (join_relations.size() > 1) {
-		// now in every step of the algorithm, we greedily pick the join between the to-be-joined relations that has the
-		// smallest cost. This is O(r^2) per step, and every step will reduce the total amount of relations to-be-joined
-		// by 1, so the total cost is O(r^3) in the amount of relations
-		idx_t best_left = 0, best_right = 0;
-		JoinNode *best_connection = nullptr;
-		for (idx_t i = 0; i < join_relations.size(); i++) {
-			auto left = join_relations[i];
-			for (idx_t j = i + 1; j < join_relations.size(); j++) {
-				auto right = join_relations[j];
-				// check if we can connect these two relations
-				auto connection = query_graph.GetConnection(left, right);
-				if (connection) {
-					// we can! check the cost of this connection
-					auto node = EmitPair(left, right, connection);
-					if (!best_connection || node->cost < best_connection->cost) {
-						// best pair found so far
-						best_connection = node;
-						best_left = i;
-						best_right = j;
-					}
-				}
-			}
-		}
-		if (!best_connection) {
-			// could not find a connection, but we were not done with finding a completed plan
-			// we have to add a cross product; we add it between the two smallest relations
-			JoinNode *smallest_plans[2] = {nullptr};
-			idx_t smallest_index[2];
-			for (idx_t i = 0; i < join_relations.size(); i++) {
-				// get the plan for this relation
-				auto current_plan = plans[join_relations[i]].get();
-				// check if the cardinality is smaller than the smallest two found so far
-				for (idx_t j = 0; j < 2; j++) {
-					if (!smallest_plans[j] || smallest_plans[j]->cardinality > current_plan->cardinality) {
-						smallest_plans[j] = current_plan;
-						smallest_index[j] = i;
-						break;
-					}
-				}
-			}
-			if (!smallest_plans[0] || !smallest_plans[1]) {
-				throw InternalException("Internal error in join order optimizer");
-			}
-			D_ASSERT(smallest_plans[0] && smallest_plans[1]);
-			D_ASSERT(smallest_index[0] != smallest_index[1]);
-			auto left = smallest_plans[0]->set;
-			auto right = smallest_plans[1]->set;
-			// create a cross product edge (i.e. edge with empty filter) between these two sets in the query graph
-			query_graph.CreateEdge(left, right, nullptr);
-			// now emit the pair and continue with the algorithm
-			auto connection = query_graph.GetConnection(left, right);
-			D_ASSERT(connection);
-
-			best_connection = EmitPair(left, right, connection);
-			best_left = smallest_index[0];
-			best_right = smallest_index[1];
-			// the code below assumes best_right > best_left
-			if (best_left > best_right) {
-				std::swap(best_left, best_right);
-			}
-		}
-		// now update the to-be-checked pairs
-		// remove left and right, and add the combination
-
-		// important to erase the biggest element first
-		// if we erase the smallest element first the index of the biggest element changes
-		D_ASSERT(best_right > best_left);
-		join_relations.erase(join_relations.begin() + best_right);
-		join_relations.erase(join_relations.begin() + best_left);
-		join_relations.push_back(best_connection->set);
-	}
-}
-
-void JoinOrderOptimizer::SolveJoinOrder() {
-	// first try to solve the join order exactly
-	if (!SolveJoinOrderExactly()) {
-		// otherwise, if that times out we resort to a greedy algorithm
-		SolveJoinOrderApproximately();
-	}
-}
-
-void JoinOrderOptimizer::GenerateCrossProducts() {
-	// generate a set of cross products to combine the currently available plans into a full join plan
-	// we create edges between every relation with a high cost
-	for (idx_t i = 0; i < relations.size(); i++) {
-		auto left = set_manager.GetJoinRelation(i);
-		for (idx_t j = 0; j < relations.size(); j++) {
-			if (i != j) {
-				auto right = set_manager.GetJoinRelation(j);
-				query_graph.CreateEdge(left, right, nullptr);
-				query_graph.CreateEdge(right, left, nullptr);
-			}
-		}
-	}
-}
-
-static unique_ptr<LogicalOperator> ExtractJoinRelation(SingleJoinRelation &rel) {
-	auto &children = rel.parent->children;
-	for (idx_t i = 0; i < children.size(); i++) {
-		if (children[i].get() == rel.op) {
-			// found it! take ownership of it from the parent
-			auto result = move(children[i]);
-			children.erase(children.begin() + i);
-			return result;
-		}
-	}
-	throw Exception("Could not find relation in parent node (?)");
-}
-
-pair<JoinRelationSet *, unique_ptr<LogicalOperator>>
-JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode *node) {
-	JoinRelationSet *left_node = nullptr, *right_node = nullptr;
-	JoinRelationSet *result_relation;
-	unique_ptr<LogicalOperator> result_operator;
-	if (node->left && node->right) {
-		// generate the left and right children
-		auto left = GenerateJoins(extracted_relations, node->left);
-		auto right = GenerateJoins(extracted_relations, node->right);
-
-		if (node->info->filters.empty()) {
-			// no filters, create a cross product
-			auto join = make_unique<LogicalCrossProduct>();
-			join->children.push_back(move(left.second));
-			join->children.push_back(move(right.second));
-			result_operator = move(join);
-		} else {
-			// we have filters, create a join node
-			auto join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
-			join->children.push_back(move(left.second));
-			join->children.push_back(move(right.second));
-			// set the join conditions from the join node
-			for (auto &f : node->info->filters) {
-				// extract the filter from the operator it originally belonged to
-				D_ASSERT(filters[f->filter_index]);
-				auto condition = move(filters[f->filter_index]);
-				// now create the actual join condition
-				D_ASSERT((JoinRelationSet::IsSubset(left.first, f->left_set) &&
-				          JoinRelationSet::IsSubset(right.first, f->right_set)) ||
-				         (JoinRelationSet::IsSubset(left.first, f->right_set) &&
-				          JoinRelationSet::IsSubset(right.first, f->left_set)));
-				JoinCondition cond;
-				D_ASSERT(condition->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-				auto &comparison = (BoundComparisonExpression &)*condition;
-				// we need to figure out which side is which by looking at the relations available to us
-				bool invert = !JoinRelationSet::IsSubset(left.first, f->left_set);
-				cond.left = !invert ? move(comparison.left) : move(comparison.right);
-				cond.right = !invert ? move(comparison.right) : move(comparison.left);
-				cond.comparison = condition->type;
-
-				if (invert) {
-					// reverse comparison expression if we reverse the order of the children
-					cond.comparison = FlipComparisionExpression(cond.comparison);
-				}
-				join->conditions.push_back(move(cond));
-			}
-			D_ASSERT(!join->conditions.empty());
-			result_operator = move(join);
-		}
-		left_node = left.first;
-		right_node = right.first;
-		result_relation = set_manager.Union(left_node, right_node);
-	} else {
-		// base node, get the entry from the list of extracted relations
-		D_ASSERT(node->set->count == 1);
-		D_ASSERT(extracted_relations[node->set->relations[0]]);
-		result_relation = node->set;
-		result_operator = move(extracted_relations[node->set->relations[0]]);
-	}
-	// check if we should do a pushdown on this node
-	// basically, any remaining filter that is a subset of the current relation will no longer be used in joins
-	// hence we should push it here
-	for (auto &filter_info : filter_infos) {
-		// check if the filter has already been extracted
-		auto info = filter_info.get();
-		if (filters[info->filter_index]) {
-			// now check if the filter is a subset of the current relation
-			// note that infos with an empty relation set are a special case and we do not push them down
-			if (info->set->count > 0 && JoinRelationSet::IsSubset(result_relation, info->set)) {
-				auto filter = move(filters[info->filter_index]);
-				// if it is, we can push the filter
-				// we can push it either into a join or as a filter
-				// check if we are in a join or in a base table
-				if (!left_node || !info->left_set) {
-					// base table or non-comparison expression, push it as a filter
-					result_operator = PushFilter(move(result_operator), move(filter));
-					continue;
-				}
-				// the node below us is a join or cross product and the expression is a comparison
-				// check if the nodes can be split up into left/right
-				bool found_subset = false;
-				bool invert = false;
-				if (JoinRelationSet::IsSubset(left_node, info->left_set) &&
-				    JoinRelationSet::IsSubset(right_node, info->right_set)) {
-					found_subset = true;
-				} else if (JoinRelationSet::IsSubset(right_node, info->left_set) &&
-				           JoinRelationSet::IsSubset(left_node, info->right_set)) {
-					invert = true;
-					found_subset = true;
-				}
-				if (!found_subset) {
-					// could not be split up into left/right
-					result_operator = PushFilter(move(result_operator), move(filter));
-					continue;
-				}
-				// create the join condition
-				JoinCondition cond;
-				D_ASSERT(filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-				auto &comparison = (BoundComparisonExpression &)*filter;
-				// we need to figure out which side is which by looking at the relations available to us
-				cond.left = !invert ? move(comparison.left) : move(comparison.right);
-				cond.right = !invert ? move(comparison.right) : move(comparison.left);
-				cond.comparison = comparison.type;
-				if (invert) {
-					// reverse comparison expression if we reverse the order of the children
-					cond.comparison = FlipComparisionExpression(comparison.type);
-				}
-				// now find the join to push it into
-				auto node = result_operator.get();
-				if (node->type == LogicalOperatorType::LOGICAL_FILTER) {
-					node = node->children[0].get();
-				}
-				if (node->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
-					// turn into comparison join
-					auto comp_join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
-					comp_join->children.push_back(move(node->children[0]));
-					comp_join->children.push_back(move(node->children[1]));
-					comp_join->conditions.push_back(move(cond));
-					if (node == result_operator.get()) {
-						result_operator = move(comp_join);
-					} else {
-						D_ASSERT(result_operator->type == LogicalOperatorType::LOGICAL_FILTER);
-						result_operator->children[0] = move(comp_join);
-					}
-				} else {
-					D_ASSERT(node->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
-					auto &comp_join = (LogicalComparisonJoin &)*node;
-					comp_join.conditions.push_back(move(cond));
-				}
-			}
-		}
-	}
-	return make_pair(result_relation, move(result_operator));
-}
-
-unique_ptr<LogicalOperator> JoinOrderOptimizer::RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode *node) {
-	// now we have to rewrite the plan
-	bool root_is_join = plan->children.size() > 1;
-
-	// first we will extract all relations from the main plan
-	vector<unique_ptr<LogicalOperator>> extracted_relations;
-	for (auto &relation : relations) {
-		extracted_relations.push_back(ExtractJoinRelation(*relation));
-	}
-	// now we generate the actual joins
-	auto join_tree = GenerateJoins(extracted_relations, node);
-	// perform the final pushdown of remaining filters
-	for (auto &filter : filters) {
-		// check if the filter has already been extracted
-		if (filter) {
-			// if not we need to push it
-			join_tree.second = PushFilter(move(join_tree.second), move(filter));
-		}
-	}
-
-	// find the first join in the relation to know where to place this node
-	if (root_is_join) {
-		// first node is the join, return it immediately
-		return move(join_tree.second);
-	}
-	D_ASSERT(plan->children.size() == 1);
-	// have to move up through the relations
-	auto op = plan.get();
-	auto parent = plan.get();
-	while (op->type != LogicalOperatorType::LOGICAL_CROSS_PRODUCT &&
-	       op->type != LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		D_ASSERT(op->children.size() == 1);
-		parent = op;
-		op = op->children[0].get();
-	}
-	// have to replace at this node
-	parent->children[0] = move(join_tree.second);
-	return plan;
-}
-
-// the join ordering is pretty much a straight implementation of the paper "Dynamic Programming Strikes Back" by Guido
-// Moerkotte and Thomas Neumannn, see that paper for additional info/documentation bonus slides:
-// https://db.in.tum.de/teaching/ws1415/queryopt/chapter3.pdf?lang=de
-// FIXME: incorporate cardinality estimation into the plans, possibly by pushing samples?
-unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOperator> plan) {
-	D_ASSERT(filters.empty() && relations.empty()); // assert that the JoinOrderOptimizer has not been used before
-	LogicalOperator *op = plan.get();
-	// now we optimize the current plan
-	// we skip past until we find the first projection, we do this because the HAVING clause inserts a Filter AFTER the
-	// group by and this filter cannot be reordered
-	// extract a list of all relations that have to be joined together
-	// and a list of all conditions that is applied to them
-	vector<LogicalOperator *> filter_operators;
-	if (!ExtractJoinRelations(*op, filter_operators)) {
-		// do not support reordering this type of plan
-		return plan;
-	}
-	if (relations.size() <= 1) {
-		// at most one relation, nothing to reorder
-		return plan;
-	}
-	// now that we know we are going to perform join ordering we actually extract the filters, eliminating duplicate
-	// filters in the process
-	expression_set_t filter_set;
-	for (auto &op : filter_operators) {
-		if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-			auto &join = (LogicalComparisonJoin &)*op;
-			D_ASSERT(join.join_type == JoinType::INNER);
-			D_ASSERT(join.expressions.empty());
-			for (auto &cond : join.conditions) {
-				auto comparison =
-				    make_unique<BoundComparisonExpression>(cond.comparison, move(cond.left), move(cond.right));
-				if (filter_set.find(comparison.get()) == filter_set.end()) {
-					filter_set.insert(comparison.get());
-					filters.push_back(move(comparison));
-				}
-			}
-			join.conditions.clear();
-		} else {
-			for (auto &expression : op->expressions) {
-				if (filter_set.find(expression.get()) == filter_set.end()) {
-					filter_set.insert(expression.get());
-					filters.push_back(move(expression));
-				}
-			}
-			op->expressions.clear();
-		}
-	}
-	// create potential edges from the comparisons
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto &filter = filters[i];
-		auto info = make_unique<FilterInfo>();
-		auto filter_info = info.get();
-		filter_infos.push_back(move(info));
-		// first extract the relation set for the entire filter
-		unordered_set<idx_t> bindings;
-		ExtractBindings(*filter, bindings);
-		filter_info->set = set_manager.GetJoinRelation(bindings);
-		filter_info->filter_index = i;
-		// now check if it can be used as a join predicate
-		if (filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-			auto comparison = (BoundComparisonExpression *)filter.get();
-			// extract the bindings that are required for the left and right side of the comparison
-			unordered_set<idx_t> left_bindings, right_bindings;
-			ExtractBindings(*comparison->left, left_bindings);
-			ExtractBindings(*comparison->right, right_bindings);
-			if (!left_bindings.empty() && !right_bindings.empty()) {
-				// both the left and the right side have bindings
-				// first create the relation sets, if they do not exist
-				filter_info->left_set = set_manager.GetJoinRelation(left_bindings);
-				filter_info->right_set = set_manager.GetJoinRelation(right_bindings);
-				// we can only create a meaningful edge if the sets are not exactly the same
-				if (filter_info->left_set != filter_info->right_set) {
-					// check if the sets are disjoint
-					if (Disjoint(left_bindings, right_bindings)) {
-						// they are disjoint, we only need to create one set of edges in the join graph
-						query_graph.CreateEdge(filter_info->left_set, filter_info->right_set, filter_info);
-						query_graph.CreateEdge(filter_info->right_set, filter_info->left_set, filter_info);
-					} else {
-						continue;
-					}
-					continue;
-				}
-			}
-		}
-	}
-	// now use dynamic programming to figure out the optimal join order
-	// First we initialize each of the single-node plans with themselves and with their cardinalities these are the leaf
-	// nodes of the join tree NOTE: we can just use pointers to JoinRelationSet* here because the GetJoinRelation
-	// function ensures that a unique combination of relations will have a unique JoinRelationSet object.
-	for (idx_t i = 0; i < relations.size(); i++) {
-		auto &rel = *relations[i];
-		auto node = set_manager.GetJoinRelation(i);
-		plans[node] = make_unique<JoinNode>(node, rel.op->EstimateCardinality(context));
-	}
-	// now we perform the actual dynamic programming to compute the final result
-	SolveJoinOrder();
-	// now the optimal join path should have been found
-	// get it from the node
-	unordered_set<idx_t> bindings;
-	for (idx_t i = 0; i < relations.size(); i++) {
-		bindings.insert(i);
-	}
-	auto total_relation = set_manager.GetJoinRelation(bindings);
-	auto final_plan = plans.find(total_relation);
-	if (final_plan == plans.end()) {
-		// could not find the final plan
-		// this should only happen in case the sets are actually disjunct
-		// in this case we need to generate cross product to connect the disjoint sets
-		if (context.config.force_no_cross_product) {
-			throw InternalException("HyperGraph isn't connected");
-		}
-		GenerateCrossProducts();
-		//! solve the join order again
-		SolveJoinOrder();
-		// now we can obtain the final plan!
-		final_plan = plans.find(total_relation);
-		D_ASSERT(final_plan != plans.end());
-	}
-	// now perform the actual reordering
-	return RewritePlan(move(plan), final_plan->second.get());
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-bool ExpressionMatcher::Match(Expression *expr, vector<Expression *> &bindings) {
-	if (type && !type->Match(expr->return_type)) {
-		return false;
-	}
-	if (expr_type && !expr_type->Match(expr->type)) {
-		return false;
-	}
-	if (expr_class != ExpressionClass::INVALID && expr_class != expr->GetExpressionClass()) {
-		return false;
-	}
-	bindings.push_back(expr);
-	return true;
-}
-
-bool ExpressionEqualityMatcher::Match(Expression *expr, vector<Expression *> &bindings) {
-	if (!Expression::Equals(expression, expr)) {
-		return false;
-	}
-	bindings.push_back(expr);
-	return true;
-}
-
-bool CaseExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	return true;
-}
-
-bool ComparisonExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto expr = (BoundComparisonExpression *)expr_p;
-	vector<Expression *> expressions = {expr->left.get(), expr->right.get()};
-	return SetMatcher::Match(matchers, expressions, bindings, policy);
-}
-
-bool CastExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	if (!matcher) {
-		return true;
-	}
-	auto expr = (BoundCastExpression *)expr_p;
-	return matcher->Match(expr->child.get(), bindings);
-}
-
-bool InClauseExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto expr = (BoundOperatorExpression *)expr_p;
-	if (expr->type != ExpressionType::COMPARE_IN || expr->type == ExpressionType::COMPARE_NOT_IN) {
-		return false;
-	}
-	return SetMatcher::Match(matchers, expr->children, bindings, policy);
-}
-
-bool ConjunctionExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto expr = (BoundConjunctionExpression *)expr_p;
-	if (!SetMatcher::Match(matchers, expr->children, bindings, policy)) {
-		return false;
-	}
-	return true;
-}
-
-bool FunctionExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
-	if (!ExpressionMatcher::Match(expr_p, bindings)) {
-		return false;
-	}
-	auto expr = (BoundFunctionExpression *)expr_p;
-	if (!FunctionMatcher::Match(function, expr->function.name)) {
-		return false;
-	}
-	if (!SetMatcher::Match(matchers, expr->children, bindings, policy)) {
-		return false;
-	}
-	return true;
-}
-
-bool FoldableConstantMatcher::Match(Expression *expr, vector<Expression *> &bindings) {
-	// we match on ANY expression that is a scalar expression
-	if (!expr->IsFoldable()) {
-		return false;
-	}
-	bindings.push_back(expr);
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-Optimizer::Optimizer(Binder &binder, ClientContext &context) : context(context), binder(binder), rewriter(context) {
-	rewriter.rules.push_back(make_unique<ConstantFoldingRule>(rewriter));
-	rewriter.rules.push_back(make_unique<DistributivityRule>(rewriter));
-	rewriter.rules.push_back(make_unique<ArithmeticSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_unique<CaseSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_unique<ConjunctionSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_unique<DatePartSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_unique<ComparisonSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_unique<InClauseSimplificationRule>(rewriter));
-	rewriter.rules.push_back(make_unique<EqualOrNullSimplification>(rewriter));
-	rewriter.rules.push_back(make_unique<MoveConstantsRule>(rewriter));
-	rewriter.rules.push_back(make_unique<LikeOptimizationRule>(rewriter));
-	rewriter.rules.push_back(make_unique<RegexOptimizationRule>(rewriter));
-	rewriter.rules.push_back(make_unique<EmptyNeedleRemovalRule>(rewriter));
-	rewriter.rules.push_back(make_unique<EnumComparisonRule>(rewriter));
-
-#ifdef DEBUG
-	for (auto &rule : rewriter.rules) {
-		// root not defined in rule
-		D_ASSERT(rule->root);
-	}
-#endif
-}
-
-void Optimizer::RunOptimizer(OptimizerType type, const std::function<void()> &callback) {
-	auto &config = DBConfig::GetConfig(context);
-	if (config.disabled_optimizers.find(type) != config.disabled_optimizers.end()) {
-		// optimizer is marked as disabled: skip
-		return;
-	}
-	auto &profiler = QueryProfiler::Get(context);
-	profiler.StartPhase(OptimizerTypeToString(type));
-	callback();
-	profiler.EndPhase();
-}
-
-unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan) {
-	// first we perform expression rewrites using the ExpressionRewriter
-	// this does not change the logical plan structure, but only simplifies the expression trees
-	RunOptimizer(OptimizerType::EXPRESSION_REWRITER, [&]() { rewriter.VisitOperator(*plan); });
-
-	// perform filter pullup
-	RunOptimizer(OptimizerType::FILTER_PULLUP, [&]() {
-		FilterPullup filter_pullup;
-		plan = filter_pullup.Rewrite(move(plan));
-	});
-
-	// perform filter pushdown
-	RunOptimizer(OptimizerType::FILTER_PUSHDOWN, [&]() {
-		FilterPushdown filter_pushdown(*this);
-		plan = filter_pushdown.Rewrite(move(plan));
-	});
-
-	RunOptimizer(OptimizerType::REGEX_RANGE, [&]() {
-		RegexRangeFilter regex_opt;
-		plan = regex_opt.Rewrite(move(plan));
-	});
-
-	RunOptimizer(OptimizerType::IN_CLAUSE, [&]() {
-		InClauseRewriter rewriter(context, *this);
-		plan = rewriter.Rewrite(move(plan));
-	});
-
-	// then we perform the join ordering optimization
-	// this also rewrites cross products + filters into joins and performs filter pushdowns
-	RunOptimizer(OptimizerType::JOIN_ORDER, [&]() {
-		JoinOrderOptimizer optimizer(context);
-		plan = optimizer.Optimize(move(plan));
-	});
-
-	// removes any redundant DelimGets/DelimJoins
-	RunOptimizer(OptimizerType::DELIMINATOR, [&]() {
-		Deliminator deliminator;
-		plan = deliminator.Optimize(move(plan));
-	});
-
-	RunOptimizer(OptimizerType::UNUSED_COLUMNS, [&]() {
-		RemoveUnusedColumns unused(binder, context, true);
-		unused.VisitOperator(*plan);
-	});
-
-	// perform statistics propagation
-	RunOptimizer(OptimizerType::STATISTICS_PROPAGATION, [&]() {
-		StatisticsPropagator propagator(context);
-		propagator.PropagateStatistics(plan);
-	});
-
-	// then we extract common subexpressions inside the different operators
-	RunOptimizer(OptimizerType::COMMON_SUBEXPRESSIONS, [&]() {
-		CommonSubExpressionOptimizer cse_optimizer(binder);
-		cse_optimizer.VisitOperator(*plan);
-	});
-
-	RunOptimizer(OptimizerType::COMMON_AGGREGATE, [&]() {
-		CommonAggregateOptimizer common_aggregate;
-		common_aggregate.VisitOperator(*plan);
-	});
-
-	RunOptimizer(OptimizerType::COLUMN_LIFETIME, [&]() {
-		ColumnLifetimeAnalyzer column_lifetime(true);
-		column_lifetime.VisitOperator(*plan);
-	});
-
-	// transform ORDER BY + LIMIT to TopN
-	RunOptimizer(OptimizerType::TOP_N, [&]() {
-		TopN topn;
-		plan = topn.Optimize(move(plan));
-	});
-
-	// apply simple expression heuristics to get an initial reordering
-	RunOptimizer(OptimizerType::REORDER_FILTER, [&]() {
-		ExpressionHeuristics expression_heuristics(*this);
-		plan = expression_heuristics.Rewrite(move(plan));
-	});
-
-	return plan;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPullup::PullupBothSide(unique_ptr<LogicalOperator> op) {
-	FilterPullup left_pullup(true, can_add_column);
-	FilterPullup right_pullup(true, can_add_column);
-	op->children[0] = left_pullup.Rewrite(move(op->children[0]));
-	op->children[1] = right_pullup.Rewrite(move(op->children[1]));
-
-	// merging filter expressions
-	for (idx_t i = 0; i < right_pullup.filters_expr_pullup.size(); ++i) {
-		left_pullup.filters_expr_pullup.push_back(move(right_pullup.filters_expr_pullup[i]));
-	}
-
-	if (!left_pullup.filters_expr_pullup.empty()) {
-		return GeneratePullupFilter(move(op), left_pullup.filters_expr_pullup);
-	}
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPullup::PullupFilter(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_FILTER);
-
-	if (can_pullup) {
-		unique_ptr<LogicalOperator> child = move(op->children[0]);
-		child = Rewrite(move(child));
-		// moving filter's expressions
-		for (idx_t i = 0; i < op->expressions.size(); ++i) {
-			filters_expr_pullup.push_back(move(op->expressions[i]));
-		}
-		return child;
-	}
-	op->children[0] = Rewrite(move(op->children[0]));
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPullup::PullupFromLeft(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_EXCEPT);
-
-	FilterPullup left_pullup(true, can_add_column);
-	FilterPullup right_pullup(false, can_add_column);
-
-	op->children[0] = left_pullup.Rewrite(move(op->children[0]));
-	op->children[1] = right_pullup.Rewrite(move(op->children[1]));
-
-	// check only for filters from the LHS
-	if (!left_pullup.filters_expr_pullup.empty() && right_pullup.filters_expr_pullup.empty()) {
-		return GeneratePullupFilter(move(op), left_pullup.filters_expr_pullup);
-	}
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void RevertFilterPullup(LogicalProjection &proj, vector<unique_ptr<Expression>> &expressions) {
-	unique_ptr<LogicalFilter> filter = make_unique<LogicalFilter>();
-	for (idx_t i = 0; i < expressions.size(); ++i) {
-		filter->expressions.push_back(move(expressions[i]));
-	}
-	expressions.clear();
-	filter->children.push_back(move(proj.children[0]));
-	proj.children[0] = move(filter);
-}
-
-static void ReplaceExpressionBinding(vector<unique_ptr<Expression>> &proj_expressions, Expression &expr,
-                                     idx_t proj_table_idx) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		bool found_proj_col = false;
-		BoundColumnRefExpression &colref = (BoundColumnRefExpression &)expr;
-		// find the corresponding column index in the projection expressions
-		for (idx_t proj_idx = 0; proj_idx < proj_expressions.size(); proj_idx++) {
-			auto proj_expr = proj_expressions[proj_idx].get();
-			if (proj_expr->type == ExpressionType::BOUND_COLUMN_REF) {
-				if (colref.Equals(proj_expr)) {
-					colref.binding.table_index = proj_table_idx;
-					colref.binding.column_index = proj_idx;
-					found_proj_col = true;
-					break;
-				}
-			}
-		}
-		if (!found_proj_col) {
-			// Project a new column
-			auto new_colref = colref.Copy();
-			colref.binding.table_index = proj_table_idx;
-			colref.binding.column_index = proj_expressions.size();
-			proj_expressions.push_back(move(new_colref));
-		}
-	}
-	ExpressionIterator::EnumerateChildren(
-	    expr, [&](Expression &child) { return ReplaceExpressionBinding(proj_expressions, child, proj_table_idx); });
-}
-
-void FilterPullup::ProjectSetOperation(LogicalProjection &proj) {
-	vector<unique_ptr<Expression>> copy_proj_expressions;
-	// copying the project expressions, it's useful whether we should revert the filter pullup
-	for (idx_t i = 0; i < proj.expressions.size(); ++i) {
-		copy_proj_expressions.push_back(proj.expressions[i]->Copy());
-	}
-
-	// Replace filter expression bindings, when need we add new columns into the copied projection expression
-	vector<unique_ptr<Expression>> changed_filter_expressions;
-	for (idx_t i = 0; i < filters_expr_pullup.size(); ++i) {
-		auto copy_filter_expr = filters_expr_pullup[i]->Copy();
-		ReplaceExpressionBinding(copy_proj_expressions, (Expression &)*copy_filter_expr, proj.table_index);
-		changed_filter_expressions.push_back(move(copy_filter_expr));
-	}
-
-	/// Case new columns were added into the projection
-	// we must skip filter pullup because adding new columns to these operators will change the result
-	if (copy_proj_expressions.size() > proj.expressions.size()) {
-		RevertFilterPullup(proj, filters_expr_pullup);
-		return;
-	}
-
-	// now we must replace the filter bindings
-	D_ASSERT(filters_expr_pullup.size() == changed_filter_expressions.size());
-	for (idx_t i = 0; i < filters_expr_pullup.size(); ++i) {
-		filters_expr_pullup[i] = move(changed_filter_expressions[i]);
-	}
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupProjection(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	op->children[0] = Rewrite(move(op->children[0]));
-	if (!filters_expr_pullup.empty()) {
-		auto &proj = (LogicalProjection &)*op;
-		// INTERSECT, EXCEPT, and DISTINCT
-		if (!can_add_column) {
-			// special treatment for operators that cannot add columns, e.g., INTERSECT, EXCEPT, and DISTINCT
-			ProjectSetOperation(proj);
-			return op;
-		}
-
-		for (idx_t i = 0; i < filters_expr_pullup.size(); ++i) {
-			auto &expr = (Expression &)*filters_expr_pullup[i];
-			ReplaceExpressionBinding(proj.expressions, expr, proj.table_index);
-		}
-	}
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-static void ReplaceFilterTableIndex(Expression &expr, LogicalSetOperation &setop) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expr;
-		D_ASSERT(colref.depth == 0);
-
-		colref.binding.table_index = setop.table_index;
-		return;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ReplaceFilterTableIndex(child, setop); });
-}
-
-unique_ptr<LogicalOperator> FilterPullup::PullupSetOperation(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_INTERSECT || op->type == LogicalOperatorType::LOGICAL_EXCEPT);
-	can_add_column = false;
-	can_pullup = true;
-	if (op->type == LogicalOperatorType::LOGICAL_INTERSECT) {
-		op = PullupBothSide(move(op));
-	} else {
-		// EXCEPT only pull ups from LHS
-		op = PullupFromLeft(move(op));
-	}
-	if (op->type == LogicalOperatorType::LOGICAL_FILTER) {
-		auto &filter = (LogicalFilter &)*op;
-		auto &setop = (LogicalSetOperation &)*filter.children[0];
-		for (idx_t i = 0; i < filter.expressions.size(); ++i) {
-			ReplaceFilterTableIndex(*filter.expressions[i], setop);
-		}
-	}
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-static unique_ptr<Expression> ReplaceGroupBindings(LogicalAggregate &proj, unique_ptr<Expression> expr) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)*expr;
-		D_ASSERT(colref.binding.table_index == proj.group_index);
-		D_ASSERT(colref.binding.column_index < proj.groups.size());
-		D_ASSERT(colref.depth == 0);
-		// replace the binding with a copy to the expression at the referenced index
-		return proj.groups[colref.binding.column_index]->Copy();
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceGroupBindings(proj, move(child)); });
-	return expr;
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownAggregate(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY);
-	auto &aggr = (LogicalAggregate &)*op;
-
-	// pushdown into AGGREGATE and GROUP BY
-	// we cannot push expressions that refer to the aggregate
-	FilterPushdown child_pushdown(optimizer);
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto &f = *filters[i];
-		// check if any aggregate or GROUPING functions are in the set
-		if (f.bindings.find(aggr.aggregate_index) == f.bindings.end() &&
-		    f.bindings.find(aggr.groupings_index) == f.bindings.end()) {
-			// no aggregate! we can push this down
-			// rewrite any group bindings within the filter
-			f.filter = ReplaceGroupBindings(aggr, move(f.filter));
-			// add the filter to the child node
-			if (child_pushdown.AddFilter(move(f.filter)) == FilterResult::UNSATISFIABLE) {
-				// filter statically evaluates to false, strip tree
-				return make_unique<LogicalEmptyResult>(move(op));
-			}
-			// erase the filter from here
-			filters.erase(filters.begin() + i);
-			i--;
-		}
-	}
-	child_pushdown.GenerateFilters();
-
-	op->children[0] = child_pushdown.Rewrite(move(op->children[0]));
-	return FinishPushdown(move(op));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT);
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
-	vector<unique_ptr<Expression>> join_conditions;
-	unordered_set<idx_t> left_bindings, right_bindings;
-	if (!filters.empty()) {
-		// check to see into which side we should push the filters
-		// first get the LHS and RHS bindings
-		LogicalJoin::GetTableReferences(*op->children[0], left_bindings);
-		LogicalJoin::GetTableReferences(*op->children[1], right_bindings);
-		// now check the set of filters
-		for (auto &f : filters) {
-			auto side = JoinSide::GetJoinSide(f->bindings, left_bindings, right_bindings);
-			if (side == JoinSide::LEFT) {
-				// bindings match left side: push into left
-				left_pushdown.filters.push_back(move(f));
-			} else if (side == JoinSide::RIGHT) {
-				// bindings match right side: push into right
-				right_pushdown.filters.push_back(move(f));
-			} else {
-				D_ASSERT(side == JoinSide::BOTH);
-				// bindings match both: turn into join condition
-				join_conditions.push_back(move(f->filter));
-			}
-		}
-	}
-
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
-
-	if (!join_conditions.empty()) {
-		// join conditions found: turn into inner join
-		return LogicalComparisonJoin::CreateJoin(JoinType::INNER, move(op->children[0]), move(op->children[1]),
-		                                         left_bindings, right_bindings, join_conditions);
-	} else {
-		// no join conditions found: keep as cross product
-		return op;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownFilter(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_FILTER);
-	auto &filter = (LogicalFilter &)*op;
-	// filter: gather the filters and remove the filter from the set of operations
-	for (auto &expression : filter.expressions) {
-		if (AddFilter(move(expression)) == FilterResult::UNSATISFIABLE) {
-			// filter statically evaluates to false, strip tree
-			return make_unique<LogicalEmptyResult>(move(op));
-		}
-	}
-	GenerateFilters();
-	return Rewrite(move(filter.children[0]));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_GET);
-	auto &get = (LogicalGet &)*op;
-
-	if (get.function.pushdown_complex_filter) {
-		// for the remaining filters, check if we can push any of them into the scan as well
-		vector<unique_ptr<Expression>> expressions;
-		for (auto &filter : filters) {
-			expressions.push_back(move(filter->filter));
-		}
-		filters.clear();
-
-		get.function.pushdown_complex_filter(optimizer.context, get, get.bind_data.get(), expressions);
-
-		if (expressions.empty()) {
-			return op;
-		}
-		// re-generate the filters
-		for (auto &expr : expressions) {
-			auto f = make_unique<Filter>();
-			f->filter = move(expr);
-			f->ExtractBindings();
-			filters.push_back(move(f));
-		}
-	}
-
-	if (!get.table_filters.filters.empty() || !get.function.filter_pushdown) {
-		// the table function does not support filter pushdown: push a LogicalFilter on top
-		return FinishPushdown(move(op));
-	}
-	PushFilters();
-
-	//! We generate the table filters that will be executed during the table scan
-	//! Right now this only executes simple AND filters
-	get.table_filters = combiner.GenerateTableScanFilters(get.column_ids);
-
-	// //! For more complex filters if all filters to a column are constants we generate a min max boundary used to
-	// check
-	// //! the zonemaps.
-	// auto zonemap_checks = combiner.GenerateZonemapChecks(get.column_ids, get.table_filters);
-
-	// for (auto &f : get.table_filters) {
-	// 	f.column_index = get.column_ids[f.column_index];
-	// }
-
-	// //! Use zonemap checks as table filters for pre-processing
-	// for (auto &zonemap_check : zonemap_checks) {
-	// 	if (zonemap_check.column_index != COLUMN_IDENTIFIER_ROW_ID) {
-	// 		get.table_filters.push_back(zonemap_check);
-	// 	}
-	// }
-
-	GenerateFilters();
-
-	//! Now we try to pushdown the remaining filters to perform zonemap checking
-	return FinishPushdown(move(op));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<LogicalOperator> op,
-                                                              unordered_set<idx_t> &left_bindings,
-                                                              unordered_set<idx_t> &right_bindings) {
-	auto &join = (LogicalJoin &)*op;
-	D_ASSERT(join.join_type == JoinType::INNER);
-	D_ASSERT(op->type != LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	// inner join: gather all the conditions of the inner join and add to the filter list
-	if (op->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
-		auto &any_join = (LogicalAnyJoin &)join;
-		// any join: only one filter to add
-		if (AddFilter(move(any_join.condition)) == FilterResult::UNSATISFIABLE) {
-			// filter statically evaluates to false, strip tree
-			return make_unique<LogicalEmptyResult>(move(op));
-		}
-	} else {
-		// comparison join
-		D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
-		auto &comp_join = (LogicalComparisonJoin &)join;
-		// turn the conditions into filters
-		for (auto &i : comp_join.conditions) {
-			auto condition = JoinCondition::CreateExpression(move(i));
-			if (AddFilter(move(condition)) == FilterResult::UNSATISFIABLE) {
-				// filter statically evaluates to false, strip tree
-				return make_unique<LogicalEmptyResult>(move(op));
-			}
-		}
-	}
-	GenerateFilters();
-
-	// turn the inner join into a cross product
-	auto cross_product = make_unique<LogicalCrossProduct>();
-	cross_product->children.push_back(move(op->children[0]));
-	cross_product->children.push_back(move(op->children[1]));
-	// then push down cross product
-	return PushdownCrossProduct(move(cross_product));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-static unique_ptr<Expression> ReplaceColRefWithNull(unique_ptr<Expression> expr, unordered_set<idx_t> &right_bindings) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)*expr;
-		if (right_bindings.find(bound_colref.binding.table_index) != right_bindings.end()) {
-			// bound colref belongs to RHS
-			// replace it with a constant NULL
-			return make_unique<BoundConstantExpression>(Value(expr->return_type));
-		}
-		return expr;
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceColRefWithNull(move(child), right_bindings); });
-	return expr;
-}
-
-static bool FilterRemovesNull(ExpressionRewriter &rewriter, Expression *expr, unordered_set<idx_t> &right_bindings) {
-	// make a copy of the expression
-	auto copy = expr->Copy();
-	// replace all BoundColumnRef expressions frmo the RHS with NULL constants in the copied expression
-	copy = ReplaceColRefWithNull(move(copy), right_bindings);
-
-	// attempt to flatten the expression by running the expression rewriter on it
-	auto filter = make_unique<LogicalFilter>();
-	filter->expressions.push_back(move(copy));
-	rewriter.VisitOperator(*filter);
-
-	// check if all expressions are foldable
-	for (idx_t i = 0; i < filter->expressions.size(); i++) {
-		if (!filter->expressions[i]->IsFoldable()) {
-			return false;
-		}
-		// we flattened the result into a scalar, check if it is FALSE or NULL
-		auto val = ExpressionExecutor::EvaluateScalar(*filter->expressions[i]).CastAs(LogicalType::BOOLEAN);
-		// if the result of the expression with all expressions replaced with NULL is "NULL" or "false"
-		// then any extra entries generated by the LEFT OUTER JOIN will be filtered out!
-		// hence the LEFT OUTER JOIN is equivalent to an inner join
-		if (val.IsNull() || !BooleanValue::Get(val)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalOperator> op,
-                                                             unordered_set<idx_t> &left_bindings,
-                                                             unordered_set<idx_t> &right_bindings) {
-	auto &join = (LogicalJoin &)*op;
-	D_ASSERT(join.join_type == JoinType::LEFT);
-	D_ASSERT(op->type != LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
-	// for a comparison join we create a FilterCombiner that checks if we can push conditions on LHS join conditions
-	// into the RHS of the join
-	FilterCombiner filter_combiner;
-	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		// add all comparison conditions
-		auto &comparison_join = (LogicalComparisonJoin &)*op;
-		for (auto &cond : comparison_join.conditions) {
-			filter_combiner.AddFilter(
-			    make_unique<BoundComparisonExpression>(cond.comparison, cond.left->Copy(), cond.right->Copy()));
-		}
-	}
-	// now check the set of filters
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
-		if (side == JoinSide::LEFT) {
-			// bindings match left side
-			// we can push the filter into the left side
-			if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-				// we MIGHT be able to push it down the RHS as well, but only if it is a comparison that matches the
-				// join predicates we use the FilterCombiner to figure this out add the expression to the FilterCombiner
-				filter_combiner.AddFilter(filters[i]->filter->Copy());
-			}
-			left_pushdown.filters.push_back(move(filters[i]));
-			// erase the filter from the list of filters
-			filters.erase(filters.begin() + i);
-			i--;
-		} else {
-			// bindings match right side or both sides: we cannot directly push it into the right
-			// however, if the filter removes rows with null values from the RHS we can turn the left outer join
-			// in an inner join, and then push down as we would push down an inner join
-			if (FilterRemovesNull(optimizer.rewriter, filters[i]->filter.get(), right_bindings)) {
-				// the filter removes NULL values, turn it into an inner join
-				join.join_type = JoinType::INNER;
-				// now we can do more pushdown
-				// move all filters we added to the left_pushdown back into the filter list
-				for (auto &left_filter : left_pushdown.filters) {
-					filters.push_back(move(left_filter));
-				}
-				// now push down the inner join
-				return PushdownInnerJoin(move(op), left_bindings, right_bindings);
-			}
-		}
-	}
-	// finally we check the FilterCombiner to see if there are any predicates we can push into the RHS
-	// we only added (1) predicates that have JoinSide::BOTH from the conditions, and
-	// (2) predicates that have JoinSide::LEFT from the filters
-	// we check now if this combination generated any new filters that are only on JoinSide::RIGHT
-	// this happens if, e.g. a join condition is (i=a) and there is a filter (i=500), we can then push the filter
-	// (a=500) into the RHS
-	filter_combiner.GenerateFilters([&](unique_ptr<Expression> filter) {
-		if (JoinSide::GetJoinSide(*filter, left_bindings, right_bindings) == JoinSide::RIGHT) {
-			right_pushdown.AddFilter(move(filter));
-		}
-	});
-	right_pushdown.GenerateFilters();
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
-	return FinishPushdown(move(op));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownLimit(unique_ptr<LogicalOperator> op) {
-	auto &limit = (LogicalLimit &)*op;
-
-	if (!limit.limit && limit.limit_val == 0) {
-		return make_unique<LogicalEmptyResult>(move(op));
-	}
-
-	return FinishPushdown(move(op));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalOperator> op,
-                                                             unordered_set<idx_t> &left_bindings,
-                                                             unordered_set<idx_t> &right_bindings) {
-	auto &join = (LogicalJoin &)*op;
-	auto &comp_join = (LogicalComparisonJoin &)*op;
-	D_ASSERT(join.join_type == JoinType::MARK);
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-
-	right_bindings.insert(comp_join.mark_index);
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
-#ifndef NDEBUG
-	bool found_mark_reference = false;
-#endif
-	// now check the set of filters
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
-		if (side == JoinSide::LEFT) {
-			// bindings match left side: push into left
-			left_pushdown.filters.push_back(move(filters[i]));
-			// erase the filter from the list of filters
-			filters.erase(filters.begin() + i);
-			i--;
-		} else if (side == JoinSide::RIGHT) {
-			// there can only be at most one filter referencing the marker
-#ifndef NDEBUG
-			D_ASSERT(!found_mark_reference);
-			found_mark_reference = true;
-#endif
-			// this filter references the marker
-			// we can turn this into a SEMI join if the filter is on only the marker
-			if (filters[i]->filter->type == ExpressionType::BOUND_COLUMN_REF) {
-				// filter just references the marker: turn into semi join
-				join.join_type = JoinType::SEMI;
-				filters.erase(filters.begin() + i);
-				i--;
-				continue;
-			}
-			// if the filter is on NOT(marker) AND the join conditions are all set to "null_values_are_equal" we can
-			// turn this into an ANTI join if all join conditions have null_values_are_equal=true, then the result of
-			// the MARK join is always TRUE or FALSE, and never NULL this happens in the case of a correlated EXISTS
-			// clause
-			if (filters[i]->filter->type == ExpressionType::OPERATOR_NOT) {
-				auto &op_expr = (BoundOperatorExpression &)*filters[i]->filter;
-				if (op_expr.children[0]->type == ExpressionType::BOUND_COLUMN_REF) {
-					// the filter is NOT(marker), check the join conditions
-					bool all_null_values_are_equal = true;
-					for (auto &cond : comp_join.conditions) {
-						if (cond.comparison != ExpressionType::COMPARE_DISTINCT_FROM &&
-						    cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-							all_null_values_are_equal = false;
-							break;
-						}
-					}
-					if (all_null_values_are_equal) {
-						// all null values are equal, convert to ANTI join
-						join.join_type = JoinType::ANTI;
-						filters.erase(filters.begin() + i);
-						i--;
-						continue;
-					}
-				}
-			}
-		}
-	}
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
-	return FinishPushdown(move(op));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-static unique_ptr<Expression> ReplaceProjectionBindings(LogicalProjection &proj, unique_ptr<Expression> expr) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)*expr;
-		D_ASSERT(colref.binding.table_index == proj.table_index);
-		D_ASSERT(colref.binding.column_index < proj.expressions.size());
-		D_ASSERT(colref.depth == 0);
-		// replace the binding with a copy to the expression at the referenced index
-		return proj.expressions[colref.binding.column_index]->Copy();
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceProjectionBindings(proj, move(child)); });
-	return expr;
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownProjection(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	auto &proj = (LogicalProjection &)*op;
-	// push filter through logical projection
-	// all the BoundColumnRefExpressions in the filter should refer to the LogicalProjection
-	// we can rewrite them by replacing those references with the expression of the LogicalProjection node
-	FilterPushdown child_pushdown(optimizer);
-	for (auto &filter : filters) {
-		auto &f = *filter;
-		D_ASSERT(f.bindings.size() <= 1);
-		// rewrite the bindings within this subquery
-		f.filter = ReplaceProjectionBindings(proj, move(f.filter));
-		// add the filter to the child pushdown
-		if (child_pushdown.AddFilter(move(f.filter)) == FilterResult::UNSATISFIABLE) {
-			// filter statically evaluates to false, strip tree
-			return make_unique<LogicalEmptyResult>(move(op));
-		}
-	}
-	child_pushdown.GenerateFilters();
-	// now push into children
-	op->children[0] = child_pushdown.Rewrite(move(op->children[0]));
-	if (op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-		// child returns an empty result: generate an empty result here too
-		return make_unique<LogicalEmptyResult>(move(op));
-	}
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-static void ReplaceSetOpBindings(vector<ColumnBinding> &bindings, Filter &filter, Expression &expr,
-                                 LogicalSetOperation &setop) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expr;
-		D_ASSERT(colref.binding.table_index == setop.table_index);
-		D_ASSERT(colref.depth == 0);
-
-		// rewrite the binding by looking into the bound_tables list of the subquery
-		colref.binding = bindings[colref.binding.column_index];
-		filter.bindings.insert(colref.binding.table_index);
-		return;
-	}
-	ExpressionIterator::EnumerateChildren(
-	    expr, [&](Expression &child) { ReplaceSetOpBindings(bindings, filter, child, setop); });
-}
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_UNION || op->type == LogicalOperatorType::LOGICAL_EXCEPT ||
-	         op->type == LogicalOperatorType::LOGICAL_INTERSECT);
-	auto &setop = (LogicalSetOperation &)*op;
-
-	D_ASSERT(op->children.size() == 2);
-	auto left_bindings = op->children[0]->GetColumnBindings();
-	auto right_bindings = op->children[1]->GetColumnBindings();
-
-	// pushdown into set operation, we can duplicate the condition and pushdown the expressions into both sides
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
-	for (idx_t i = 0; i < filters.size(); i++) {
-		// first create a copy of the filter
-		auto right_filter = make_unique<Filter>();
-		right_filter->filter = filters[i]->filter->Copy();
-
-		// in the original filter, rewrite references to the result of the union into references to the left_index
-		ReplaceSetOpBindings(left_bindings, *filters[i], *filters[i]->filter, setop);
-		// in the copied filter, rewrite references to the result of the union into references to the right_index
-		ReplaceSetOpBindings(right_bindings, *right_filter, *right_filter->filter, setop);
-
-		// extract bindings again
-		filters[i]->ExtractBindings();
-		right_filter->ExtractBindings();
-
-		// move the filters into the child pushdown nodes
-		left_pushdown.filters.push_back(move(filters[i]));
-		right_pushdown.filters.push_back(move(right_filter));
-	}
-
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
-
-	bool left_empty = op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
-	bool right_empty = op->children[1]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
-	if (left_empty && right_empty) {
-		// both empty: return empty result
-		return make_unique<LogicalEmptyResult>(move(op));
-	}
-	if (left_empty) {
-		// left child is empty result
-		switch (op->type) {
-		case LogicalOperatorType::LOGICAL_UNION:
-			if (op->children[1]->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-				// union with empty left side: return right child
-				auto &projection = (LogicalProjection &)*op->children[1];
-				projection.table_index = setop.table_index;
-				return move(op->children[1]);
-			}
-			break;
-		case LogicalOperatorType::LOGICAL_EXCEPT:
-			// except: if left child is empty, return empty result
-		case LogicalOperatorType::LOGICAL_INTERSECT:
-			// intersect: if any child is empty, return empty result itself
-			return make_unique<LogicalEmptyResult>(move(op));
-		default:
-			throw InternalException("Unsupported set operation");
-		}
-	} else if (right_empty) {
-		// right child is empty result
-		switch (op->type) {
-		case LogicalOperatorType::LOGICAL_UNION:
-		case LogicalOperatorType::LOGICAL_EXCEPT:
-			if (op->children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-				// union or except with empty right child: return left child
-				auto &projection = (LogicalProjection &)*op->children[0];
-				projection.table_index = setop.table_index;
-				return move(op->children[0]);
-			}
-			break;
-		case LogicalOperatorType::LOGICAL_INTERSECT:
-			// intersect: if any child is empty, return empty result itself
-			return make_unique<LogicalEmptyResult>(move(op));
-		default:
-			throw InternalException("Unsupported set operation");
-		}
-	}
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-using Filter = FilterPushdown::Filter;
-
-unique_ptr<LogicalOperator> FilterPushdown::PushdownSingleJoin(unique_ptr<LogicalOperator> op,
-                                                               unordered_set<idx_t> &left_bindings,
-                                                               unordered_set<idx_t> &right_bindings) {
-	D_ASSERT(((LogicalJoin &)*op).join_type == JoinType::SINGLE);
-	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
-	// now check the set of filters
-	for (idx_t i = 0; i < filters.size(); i++) {
-		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
-		if (side == JoinSide::LEFT) {
-			// bindings match left side: push into left
-			left_pushdown.filters.push_back(move(filters[i]));
-			// erase the filter from the list of filters
-			filters.erase(filters.begin() + i);
-			i--;
-		}
-	}
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
-	return FinishPushdown(move(op));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator> op) {
-
-	for (idx_t child_idx = 0; child_idx < op->children.size(); child_idx++) {
-		op->children[child_idx] = Rewrite(move(op->children[child_idx]));
-	}
-
-	if (op->type != LogicalOperatorType::LOGICAL_FILTER) {
-		return op;
-	}
-
-	auto new_filter = make_unique<LogicalFilter>();
-
-	for (auto &expr : op->expressions) {
-		if (expr->type == ExpressionType::BOUND_FUNCTION) {
-			auto &func = (BoundFunctionExpression &)*expr.get();
-			if (func.function.name != "regexp_full_match" || func.children.size() != 2) {
-				continue;
-			}
-			auto &info = (RegexpMatchesBindData &)*func.bind_info;
-			if (!info.range_success) {
-				continue;
-			}
-			auto filter_left = make_unique<BoundComparisonExpression>(
-			    ExpressionType::COMPARE_GREATERTHANOREQUALTO, func.children[0]->Copy(),
-			    make_unique<BoundConstantExpression>(
-			        Value::BLOB((const_data_ptr_t)info.range_min.c_str(), info.range_min.size())));
-			auto filter_right = make_unique<BoundComparisonExpression>(
-			    ExpressionType::COMPARE_LESSTHANOREQUALTO, func.children[0]->Copy(),
-			    make_unique<BoundConstantExpression>(
-			        Value::BLOB((const_data_ptr_t)info.range_max.c_str(), info.range_max.size())));
-			auto filter_expr = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-			                                                           move(filter_left), move(filter_right));
-
-			new_filter->expressions.push_back(move(filter_expr));
-		}
-	}
-
-	if (!new_filter->expressions.empty()) {
-		new_filter->children = move(op->children);
-		op->children.clear();
-		op->children.push_back(move(new_filter));
-	}
-
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <map>
-
-namespace duckdb {
-
-void RemoveUnusedColumns::ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding) {
-	auto colrefs = column_references.find(current_binding);
-	if (colrefs != column_references.end()) {
-		for (auto &colref : colrefs->second) {
-			D_ASSERT(colref->binding == current_binding);
-			colref->binding = new_binding;
-		}
-	}
-}
-
-template <class T>
-void RemoveUnusedColumns::ClearUnusedExpressions(vector<T> &list, idx_t table_idx) {
-	idx_t offset = 0;
-	for (idx_t col_idx = 0; col_idx < list.size(); col_idx++) {
-		auto current_binding = ColumnBinding(table_idx, col_idx + offset);
-		auto entry = column_references.find(current_binding);
-		if (entry == column_references.end()) {
-			// this entry is not referred to, erase it from the set of expressions
-			list.erase(list.begin() + col_idx);
-			offset++;
-			col_idx--;
-		} else if (offset > 0) {
-			// column is used but the ColumnBinding has changed because of removed columns
-			ReplaceBinding(current_binding, ColumnBinding(table_idx, col_idx));
-		}
-	}
-}
-
-void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		// aggregate
-		if (!everything_referenced) {
-			// FIXME: groups that are not referenced need to stay -> but they don't need to be scanned and output!
-			auto &aggr = (LogicalAggregate &)op;
-			ClearUnusedExpressions(aggr.expressions, aggr.aggregate_index);
-			if (aggr.expressions.empty() && aggr.groups.empty()) {
-				// removed all expressions from the aggregate: push a COUNT(*)
-				auto count_star_fun = CountStarFun::GetFunction();
-				aggr.expressions.push_back(
-				    AggregateFunction::BindAggregateFunction(context, count_star_fun, {}, nullptr, false));
-			}
-		}
-
-		// then recurse into the children of the aggregate
-		RemoveUnusedColumns remove(binder, context);
-		remove.VisitOperatorExpressions(op);
-		remove.VisitOperator(*op.children[0]);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		if (!everything_referenced) {
-			auto &comp_join = (LogicalComparisonJoin &)op;
-
-			if (comp_join.join_type != JoinType::INNER) {
-				break;
-			}
-			// for inner joins with equality predicates in the form of (X=Y)
-			// we can replace any references to the RHS (Y) to references to the LHS (X)
-			// this reduces the amount of columns we need to extract from the join hash table
-			for (auto &cond : comp_join.conditions) {
-				if (cond.comparison == ExpressionType::COMPARE_EQUAL) {
-					if (cond.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-					    cond.right->expression_class == ExpressionClass::BOUND_COLUMN_REF) {
-						// comparison join between two bound column refs
-						// we can replace any reference to the RHS (build-side) with a reference to the LHS (probe-side)
-						auto &lhs_col = (BoundColumnRefExpression &)*cond.left;
-						auto &rhs_col = (BoundColumnRefExpression &)*cond.right;
-						// if there are any columns that refer to the RHS,
-						auto colrefs = column_references.find(rhs_col.binding);
-						if (colrefs != column_references.end()) {
-							for (auto &entry : colrefs->second) {
-								entry->binding = lhs_col.binding;
-								column_references[lhs_col.binding].push_back(entry);
-							}
-							column_references.erase(rhs_col.binding);
-						}
-					}
-				}
-			}
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		break;
-	case LogicalOperatorType::LOGICAL_UNION:
-		if (!everything_referenced) {
-			// for UNION we can remove unreferenced columns as long as everything_referenced is false (i.e. we
-			// encounter a UNION node that is not preceded by a DISTINCT)
-			// this happens when UNION ALL is used
-			auto &setop = (LogicalSetOperation &)op;
-			vector<idx_t> entries;
-			for (idx_t i = 0; i < setop.column_count; i++) {
-				entries.push_back(i);
-			}
-			ClearUnusedExpressions(entries, setop.table_index);
-			if (entries.size() < setop.column_count) {
-				if (entries.empty()) {
-					// no columns referenced: this happens in the case of a COUNT(*)
-					// extract the first column
-					entries.push_back(0);
-				}
-				// columns were cleared
-				setop.column_count = entries.size();
-
-				for (idx_t child_idx = 0; child_idx < op.children.size(); child_idx++) {
-					RemoveUnusedColumns remove(binder, context, true);
-					auto &child = op.children[child_idx];
-
-					// we push a projection under this child that references the required columns of the union
-					child->ResolveOperatorTypes();
-					auto bindings = child->GetColumnBindings();
-					vector<unique_ptr<Expression>> expressions;
-					expressions.reserve(entries.size());
-					for (auto &column_idx : entries) {
-						expressions.push_back(
-						    make_unique<BoundColumnRefExpression>(child->types[column_idx], bindings[column_idx]));
-					}
-					auto new_projection =
-					    make_unique<LogicalProjection>(binder.GenerateTableIndex(), move(expressions));
-					new_projection->children.push_back(move(child));
-					op.children[child_idx] = move(new_projection);
-
-					remove.VisitOperator(*op.children[child_idx]);
-				}
-				return;
-			}
-		}
-		for (auto &child : op.children) {
-			RemoveUnusedColumns remove(binder, context, true);
-			remove.VisitOperator(*child);
-		}
-		return;
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		// for INTERSECT/EXCEPT operations we can't remove anything, just recursively visit the children
-		for (auto &child : op.children) {
-			RemoveUnusedColumns remove(binder, context, true);
-			remove.VisitOperator(*child);
-		}
-		return;
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		if (!everything_referenced) {
-			auto &proj = (LogicalProjection &)op;
-			ClearUnusedExpressions(proj.expressions, proj.table_index);
-
-			if (proj.expressions.empty()) {
-				// nothing references the projected expressions
-				// this happens in the case of e.g. EXISTS(SELECT * FROM ...)
-				// in this case we only need to project a single constant
-				proj.expressions.push_back(make_unique<BoundConstantExpression>(Value::INTEGER(42)));
-			}
-		}
-		// then recurse into the children of this projection
-		RemoveUnusedColumns remove(binder, context);
-		remove.VisitOperatorExpressions(op);
-		remove.VisitOperator(*op.children[0]);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_INSERT:
-	case LogicalOperatorType::LOGICAL_UPDATE:
-	case LogicalOperatorType::LOGICAL_DELETE: {
-		//! When RETURNING is used, a PROJECTION is the top level operator for INSERTS, UPDATES, and DELETES
-		//! We still need to project all values from these operators so the projection
-		//! on top of them can select from only the table values being inserted.
-		//! TODO: Push down the projections from the returning statement
-		//! TODO: Be careful because you might be adding expressions when a user returns *
-		RemoveUnusedColumns remove(binder, context, true);
-		remove.VisitOperatorExpressions(op);
-		remove.VisitOperator(*op.children[0]);
-		return;
-	}
-	case LogicalOperatorType::LOGICAL_GET:
-		LogicalOperatorVisitor::VisitOperatorExpressions(op);
-		if (!everything_referenced) {
-			auto &get = (LogicalGet &)op;
-			// for every table filter, push a column binding into the column references map to prevent the column from
-			// being projected out
-			for (auto &filter : get.table_filters.filters) {
-				idx_t index = DConstants::INVALID_INDEX;
-				for (idx_t i = 0; i < get.column_ids.size(); i++) {
-					if (get.column_ids[i] == filter.first) {
-						index = i;
-						break;
-					}
-				}
-				if (index == DConstants::INVALID_INDEX) {
-					throw InternalException("Could not find column index for table filter");
-				}
-				ColumnBinding filter_binding(get.table_index, index);
-				if (column_references.find(filter_binding) == column_references.end()) {
-					column_references.insert(make_pair(filter_binding, vector<BoundColumnRefExpression *>()));
-				}
-			}
-			// table scan: figure out which columns are referenced
-			ClearUnusedExpressions(get.column_ids, get.table_index);
-
-			if (get.column_ids.empty()) {
-				// this generally means we are only interested in whether or not anything exists in the table (e.g.
-				// EXISTS(SELECT * FROM tbl)) in this case, we just scan the row identifier column as it means we do not
-				// need to read any of the columns
-				get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-			}
-		}
-		return;
-	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		// distinct, all projected columns are used for the DISTINCT computation
-		// mark all columns as used and continue to the children
-		// FIXME: DISTINCT with expression list does not implicitly reference everything
-		everything_referenced = true;
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE: {
-		everything_referenced = true;
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_CTE_REF: {
-		everything_referenced = true;
-		break;
-	}
-	default:
-		break;
-	}
-	LogicalOperatorVisitor::VisitOperatorExpressions(op);
-	LogicalOperatorVisitor::VisitOperatorChildren(op);
-}
-
-unique_ptr<Expression> RemoveUnusedColumns::VisitReplace(BoundColumnRefExpression &expr,
-                                                         unique_ptr<Expression> *expr_ptr) {
-	// add a column reference
-	column_references[expr.binding].push_back(&expr);
-	return nullptr;
-}
-
-unique_ptr<Expression> RemoveUnusedColumns::VisitReplace(BoundReferenceExpression &expr,
-                                                         unique_ptr<Expression> *expr_ptr) {
-	// BoundReferenceExpression should not be used here yet, they only belong in the physical plan
-	throw InternalException("BoundReferenceExpression should not be used here yet!");
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-ArithmeticSimplificationRule::ArithmeticSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on an OperatorExpression that has a ConstantExpression as child
-	auto op = make_unique<FunctionExpressionMatcher>();
-	op->matchers.push_back(make_unique<ConstantExpressionMatcher>());
-	op->matchers.push_back(make_unique<ExpressionMatcher>());
-	op->policy = SetMatcher::Policy::SOME;
-	// we only match on simple arithmetic expressions (+, -, *, /)
-	op->function = make_unique<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*", "/"});
-	// and only with numeric results
-	op->type = make_unique<IntegerTypeMatcher>();
-	op->matchers[0]->type = make_unique<IntegerTypeMatcher>();
-	op->matchers[1]->type = make_unique<IntegerTypeMatcher>();
-	root = move(op);
-}
-
-unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                           bool &changes_made, bool is_root) {
-	auto root = (BoundFunctionExpression *)bindings[0];
-	auto constant = (BoundConstantExpression *)bindings[1];
-	int constant_child = root->children[0].get() == constant ? 0 : 1;
-	D_ASSERT(root->children.size() == 2);
-	(void)root;
-	// any arithmetic operator involving NULL is always NULL
-	if (constant->value.IsNull()) {
-		return make_unique<BoundConstantExpression>(Value(root->return_type));
-	}
-	auto &func_name = root->function.name;
-	if (func_name == "+") {
-		if (constant->value == 0) {
-			// addition with 0
-			// we can remove the entire operator and replace it with the non-constant child
-			return move(root->children[1 - constant_child]);
-		}
-	} else if (func_name == "-") {
-		if (constant_child == 1 && constant->value == 0) {
-			// subtraction by 0
-			// we can remove the entire operator and replace it with the non-constant child
-			return move(root->children[1 - constant_child]);
-		}
-	} else if (func_name == "*") {
-		if (constant->value == 1) {
-			// multiply with 1, replace with non-constant child
-			return move(root->children[1 - constant_child]);
-		} else if (constant->value == 0) {
-			// multiply by zero: replace with constant or null
-			return ExpressionRewriter::ConstantOrNull(move(root->children[1 - constant_child]),
-			                                          Value::Numeric(root->return_type, 0));
-		}
-	} else {
-		D_ASSERT(func_name == "/");
-		if (constant_child == 1) {
-			if (constant->value == 1) {
-				// divide by 1, replace with non-constant child
-				return move(root->children[1 - constant_child]);
-			} else if (constant->value == 0) {
-				// divide by 0, replace with NULL
-				return make_unique<BoundConstantExpression>(Value(root->return_type));
-			}
-		}
-	}
-	return nullptr;
-}
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-CaseSimplificationRule::CaseSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a CaseExpression that has a ConstantExpression as a check
-	auto op = make_unique<CaseExpressionMatcher>();
-	root = move(op);
-}
-
-unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                     bool &changes_made, bool is_root) {
-	auto root = (BoundCaseExpression *)bindings[0];
-	for (idx_t i = 0; i < root->case_checks.size(); i++) {
-		auto &case_check = root->case_checks[i];
-		if (case_check.when_expr->IsFoldable()) {
-			// the WHEN check is a foldable expression
-			// use an ExpressionExecutor to execute the expression
-			auto constant_value = ExpressionExecutor::EvaluateScalar(*case_check.when_expr);
-
-			// fold based on the constant condition
-			auto condition = constant_value.CastAs(LogicalType::BOOLEAN);
-			if (condition.IsNull() || !BooleanValue::Get(condition)) {
-				// the condition is always false: remove this case check
-				root->case_checks.erase(root->case_checks.begin() + i);
-				i--;
-			} else {
-				// the condition is always true
-				// move the THEN clause to the ELSE of the case
-				root->else_expr = move(case_check.then_expr);
-				// remove this case check and any case checks after this one
-				root->case_checks.erase(root->case_checks.begin() + i, root->case_checks.end());
-				break;
-			}
-		}
-	}
-	if (root->case_checks.empty()) {
-		// no case checks left: return the ELSE expression
-		return move(root->else_expr);
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ComparisonSimplificationRule::ComparisonSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a ComparisonExpression that has a ConstantExpression as a check
-	auto op = make_unique<ComparisonExpressionMatcher>();
-	op->matchers.push_back(make_unique<FoldableConstantMatcher>());
-	op->policy = SetMatcher::Policy::SOME;
-	root = move(op);
-}
-
-unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                           bool &changes_made, bool is_root) {
-	D_ASSERT(bindings[0]->expression_class == ExpressionClass::BOUND_COMPARISON);
-	auto expr = (BoundComparisonExpression *)bindings[0];
-	auto constant_expr = bindings[1];
-	bool column_ref_left = expr->left.get() != constant_expr;
-	auto column_ref_expr = !column_ref_left ? expr->right.get() : expr->left.get();
-	// the constant_expr is a scalar expression that we have to fold
-	// use an ExpressionExecutor to execute the expression
-	D_ASSERT(constant_expr->IsFoldable());
-	Value constant_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(*constant_expr, constant_value)) {
-		return nullptr;
-	}
-	if (constant_value.IsNull() && !(expr->type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
-	                                 expr->type == ExpressionType::COMPARE_DISTINCT_FROM)) {
-		// comparison with constant NULL, return NULL
-		return make_unique<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
-	}
-	if (column_ref_expr->expression_class == ExpressionClass::BOUND_CAST) {
-		//! Here we check if we can apply the expression on the constant side
-		auto cast_expression = (BoundCastExpression *)column_ref_expr;
-		auto target_type = cast_expression->source_type();
-		if (!BoundCastExpression::CastIsInvertible(target_type, cast_expression->return_type)) {
-			return nullptr;
-		}
-		auto new_constant = constant_value.TryCastAs(target_type);
-		if (new_constant) {
-			auto child_expression = move(cast_expression->child);
-			auto new_constant_expr = make_unique<BoundConstantExpression>(constant_value);
-			//! We can cast, now we change our column_ref_expression from an operator cast to a column reference
-			if (column_ref_left) {
-				expr->left = move(child_expression);
-				expr->right = move(new_constant_expr);
-			} else {
-				expr->left = move(new_constant_expr);
-				expr->right = move(child_expression);
-			}
-		}
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ConjunctionSimplificationRule::ConjunctionSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a ComparisonExpression that has a ConstantExpression as a check
-	auto op = make_unique<ConjunctionExpressionMatcher>();
-	op->matchers.push_back(make_unique<FoldableConstantMatcher>());
-	op->policy = SetMatcher::Policy::SOME;
-	root = move(op);
-}
-
-unique_ptr<Expression> ConjunctionSimplificationRule::RemoveExpression(BoundConjunctionExpression &conj,
-                                                                       Expression *expr) {
-	for (idx_t i = 0; i < conj.children.size(); i++) {
-		if (conj.children[i].get() == expr) {
-			// erase the expression
-			conj.children.erase(conj.children.begin() + i);
-			break;
-		}
-	}
-	if (conj.children.size() == 1) {
-		// one expression remaining: simply return that expression and erase the conjunction
-		return move(conj.children[0]);
-	}
-	return nullptr;
-}
-
-unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                            bool &changes_made, bool is_root) {
-	auto conjunction = (BoundConjunctionExpression *)bindings[0];
-	auto constant_expr = bindings[1];
-	// the constant_expr is a scalar expression that we have to fold
-	// use an ExpressionExecutor to execute the expression
-	D_ASSERT(constant_expr->IsFoldable());
-	Value constant_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(*constant_expr, constant_value)) {
-		return nullptr;
-	}
-	constant_value = constant_value.CastAs(LogicalType::BOOLEAN);
-	if (constant_value.IsNull()) {
-		// we can't simplify conjunctions with a constant NULL
-		return nullptr;
-	}
-	if (conjunction->type == ExpressionType::CONJUNCTION_AND) {
-		if (!BooleanValue::Get(constant_value)) {
-			// FALSE in AND, result of expression is false
-			return make_unique<BoundConstantExpression>(Value::BOOLEAN(false));
-		} else {
-			// TRUE in AND, remove the expression from the set
-			return RemoveExpression(*conjunction, constant_expr);
-		}
-	} else {
-		D_ASSERT(conjunction->type == ExpressionType::CONJUNCTION_OR);
-		if (!BooleanValue::Get(constant_value)) {
-			// FALSE in OR, remove the expression from the set
-			return RemoveExpression(*conjunction, constant_expr);
-		} else {
-			// TRUE in OR, result of expression is true
-			return make_unique<BoundConstantExpression>(Value::BOOLEAN(true));
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The ConstantFoldingExpressionMatcher matches on any scalar expression (i.e. Expression::IsFoldable is true)
-class ConstantFoldingExpressionMatcher : public FoldableConstantMatcher {
-public:
-	bool Match(Expression *expr, vector<Expression *> &bindings) override {
-		// we also do not match on ConstantExpressions, because we cannot fold those any further
-		if (expr->type == ExpressionType::VALUE_CONSTANT) {
-			return false;
-		}
-		return FoldableConstantMatcher::Match(expr, bindings);
-	}
-};
-
-ConstantFoldingRule::ConstantFoldingRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	auto op = make_unique<ConstantFoldingExpressionMatcher>();
-	root = move(op);
-}
-
-unique_ptr<Expression> ConstantFoldingRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                  bool &changes_made, bool is_root) {
-	auto root = bindings[0];
-	// the root is a scalar expression that we have to fold
-	D_ASSERT(root->IsFoldable() && root->type != ExpressionType::VALUE_CONSTANT);
-
-	// use an ExpressionExecutor to execute the expression
-	Value result_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(*root, result_value)) {
-		return nullptr;
-	}
-	D_ASSERT(result_value.type().InternalType() == root->return_type.InternalType());
-	// now get the value from the result vector and insert it back into the plan as a constant expression
-	return make_unique<BoundConstantExpression>(result_value);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-DatePartSimplificationRule::DatePartSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	auto func = make_unique<FunctionExpressionMatcher>();
-	func->function = make_unique<SpecificFunctionMatcher>("date_part");
-	func->matchers.push_back(make_unique<ConstantExpressionMatcher>());
-	func->matchers.push_back(make_unique<ExpressionMatcher>());
-	func->policy = SetMatcher::Policy::ORDERED;
-	root = move(func);
-}
-
-unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                         bool &changes_made, bool is_root) {
-	auto &date_part = (BoundFunctionExpression &)*bindings[0];
-	auto &constant_expr = (BoundConstantExpression &)*bindings[1];
-	auto &constant = constant_expr.value;
-
-	if (constant.IsNull()) {
-		// NULL specifier: return constant NULL
-		return make_unique<BoundConstantExpression>(Value(date_part.return_type));
-	}
-	// otherwise check the specifier
-	auto specifier = GetDatePartSpecifier(StringValue::Get(constant));
-	string new_function_name;
-	switch (specifier) {
-	case DatePartSpecifier::YEAR:
-		new_function_name = "year";
-		break;
-	case DatePartSpecifier::MONTH:
-		new_function_name = "month";
-		break;
-	case DatePartSpecifier::DAY:
-		new_function_name = "day";
-		break;
-	case DatePartSpecifier::DECADE:
-		new_function_name = "decade";
-		break;
-	case DatePartSpecifier::CENTURY:
-		new_function_name = "century";
-		break;
-	case DatePartSpecifier::MILLENNIUM:
-		new_function_name = "millennium";
-		break;
-	case DatePartSpecifier::QUARTER:
-		new_function_name = "quarter";
-		break;
-	case DatePartSpecifier::WEEK:
-		new_function_name = "week";
-		break;
-	case DatePartSpecifier::YEARWEEK:
-		new_function_name = "yearweek";
-		break;
-	case DatePartSpecifier::DOW:
-		new_function_name = "dayofweek";
-		break;
-	case DatePartSpecifier::ISODOW:
-		new_function_name = "isodow";
-		break;
-	case DatePartSpecifier::DOY:
-		new_function_name = "dayofyear";
-		break;
-	case DatePartSpecifier::EPOCH:
-		new_function_name = "epoch";
-		break;
-	case DatePartSpecifier::MICROSECONDS:
-		new_function_name = "microsecond";
-		break;
-	case DatePartSpecifier::MILLISECONDS:
-		new_function_name = "millisecond";
-		break;
-	case DatePartSpecifier::SECOND:
-		new_function_name = "second";
-		break;
-	case DatePartSpecifier::MINUTE:
-		new_function_name = "minute";
-		break;
-	case DatePartSpecifier::HOUR:
-		new_function_name = "hour";
-		break;
-	default:
-		return nullptr;
-	}
-	// found a replacement function: bind it
-	vector<unique_ptr<Expression>> children;
-	children.push_back(move(date_part.children[1]));
-
-	string error;
-	auto function = ScalarFunction::BindScalarFunction(rewriter.context, DEFAULT_SCHEMA, new_function_name,
-	                                                   move(children), error, false);
-	if (!function) {
-		throw BinderException(error);
-	}
-	return function;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-DistributivityRule::DistributivityRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// we match on an OR expression within a LogicalFilter node
-	root = make_unique<ExpressionMatcher>();
-	root->expr_type = make_unique<SpecificExpressionTypeMatcher>(ExpressionType::CONJUNCTION_OR);
-}
-
-void DistributivityRule::AddExpressionSet(Expression &expr, expression_set_t &set) {
-	if (expr.type == ExpressionType::CONJUNCTION_AND) {
-		auto &and_expr = (BoundConjunctionExpression &)expr;
-		for (auto &child : and_expr.children) {
-			set.insert(child.get());
-		}
-	} else {
-		set.insert(&expr);
-	}
-}
-
-unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExpression &conj, idx_t idx,
-                                                             Expression &expr) {
-	auto &child = conj.children[idx];
-	unique_ptr<Expression> result;
-	if (child->type == ExpressionType::CONJUNCTION_AND) {
-		// AND, remove expression from the list
-		auto &and_expr = (BoundConjunctionExpression &)*child;
-		for (idx_t i = 0; i < and_expr.children.size(); i++) {
-			if (Expression::Equals(and_expr.children[i].get(), &expr)) {
-				result = move(and_expr.children[i]);
-				and_expr.children.erase(and_expr.children.begin() + i);
-				break;
-			}
-		}
-		if (and_expr.children.size() == 1) {
-			conj.children[idx] = move(and_expr.children[0]);
-		}
-	} else {
-		// not an AND node! remove the entire expression
-		// this happens in the case of e.g. (X AND B) OR X
-		D_ASSERT(Expression::Equals(child.get(), &expr));
-		result = move(child);
-		conj.children[idx] = nullptr;
-	}
-	D_ASSERT(result);
-	return result;
-}
-
-unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                 bool &changes_made, bool is_root) {
-	auto initial_or = (BoundConjunctionExpression *)bindings[0];
-
-	// we want to find expressions that occur in each of the children of the OR
-	// i.e. (X AND A) OR (X AND B) => X occurs in all branches
-	// first, for the initial child, we create an expression set of which expressions occur
-	// this is our initial candidate set (in the example: [X, A])
-	expression_set_t candidate_set;
-	AddExpressionSet(*initial_or->children[0], candidate_set);
-	// now for each of the remaining children, we create a set again and intersect them
-	// in our example: the second set would be [X, B]
-	// the intersection would leave [X]
-	for (idx_t i = 1; i < initial_or->children.size(); i++) {
-		expression_set_t next_set;
-		AddExpressionSet(*initial_or->children[i], next_set);
-		expression_set_t intersect_result;
-		for (auto &expr : candidate_set) {
-			if (next_set.find(expr) != next_set.end()) {
-				intersect_result.insert(expr);
-			}
-		}
-		candidate_set = intersect_result;
-	}
-	if (candidate_set.empty()) {
-		// nothing found: abort
-		return nullptr;
-	}
-	// now for each of the remaining expressions in the candidate set we know that it is contained in all branches of
-	// the OR
-	auto new_root = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-	for (auto &expr : candidate_set) {
-		D_ASSERT(initial_or->children.size() > 0);
-
-		// extract the expression from the first child of the OR
-		auto result = ExtractExpression(*initial_or, 0, (Expression &)*expr);
-		// now for the subsequent expressions, simply remove the expression
-		for (idx_t i = 1; i < initial_or->children.size(); i++) {
-			ExtractExpression(*initial_or, i, *result);
-		}
-		// now we add the expression to the new root
-		new_root->children.push_back(move(result));
-	}
-
-	// check if we completely erased one of the children of the OR
-	// this happens if we have an OR in the form of "X OR (X AND A)"
-	// the left child will be completely empty, as it only contains common expressions
-	// in this case, any other children are not useful:
-	// X OR (X AND A) is the same as "X"
-	// since (1) only tuples that do not qualify "X" will not pass this predicate
-	//   and (2) all tuples that qualify "X" will pass this predicate
-	for (idx_t i = 0; i < initial_or->children.size(); i++) {
-		if (!initial_or->children[i]) {
-			if (new_root->children.size() <= 1) {
-				return move(new_root->children[0]);
-			} else {
-				return move(new_root);
-			}
-		}
-	}
-	// finally we need to add the remaining expressions in the OR to the new root
-	if (initial_or->children.size() == 1) {
-		// one child: skip the OR entirely and only add the single child
-		new_root->children.push_back(move(initial_or->children[0]));
-	} else if (initial_or->children.size() > 1) {
-		// multiple children still remain: push them into a new OR and add that to the new root
-		auto new_or = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
-		for (auto &child : initial_or->children) {
-			new_or->children.push_back(move(child));
-		}
-		new_root->children.push_back(move(new_or));
-	}
-	// finally return the new root
-	if (new_root->children.size() == 1) {
-		return move(new_root->children[0]);
-	}
-	return move(new_root);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-EmptyNeedleRemovalRule::EmptyNeedleRemovalRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a FunctionExpression that has a foldable ConstantExpression
-	auto func = make_unique<FunctionExpressionMatcher>();
-	func->matchers.push_back(make_unique<ExpressionMatcher>());
-	func->matchers.push_back(make_unique<ExpressionMatcher>());
-	func->policy = SetMatcher::Policy::SOME;
-
-	unordered_set<string> functions = {"prefix", "contains", "suffix"};
-	func->function = make_unique<ManyFunctionMatcher>(functions);
-	root = move(func);
-}
-
-unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                     bool &changes_made, bool is_root) {
-	auto root = (BoundFunctionExpression *)bindings[0];
-	D_ASSERT(root->children.size() == 2);
-	(void)root;
-	auto prefix_expr = bindings[2];
-
-	// the constant_expr is a scalar expression that we have to fold
-	if (!prefix_expr->IsFoldable()) {
-		return nullptr;
-	}
-	D_ASSERT(root->return_type.id() == LogicalTypeId::BOOLEAN);
-
-	auto prefix_value = ExpressionExecutor::EvaluateScalar(*prefix_expr);
-
-	if (prefix_value.IsNull()) {
-		return make_unique<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
-	}
-
-	D_ASSERT(prefix_value.type() == prefix_expr->return_type);
-	auto &needle_string = StringValue::Get(prefix_value);
-
-	// PREFIX('xyz', '') is TRUE
-	// PREFIX(NULL, '') is NULL
-	// so rewrite PREFIX(x, '') to TRUE_OR_NULL(x)
-	if (needle_string.empty()) {
-		return ExpressionRewriter::ConstantOrNull(move(root->children[0]), Value::BOOLEAN(true));
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-EnumComparisonRule::EnumComparisonRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a ComparisonExpression that is an Equality and has a VARCHAR and ENUM as its children
-	auto op = make_unique<ComparisonExpressionMatcher>();
-	// Enum requires expression to be root
-	op->expr_type = make_unique<SpecificExpressionTypeMatcher>(ExpressionType::COMPARE_EQUAL);
-	for (idx_t i = 0; i < 2; i++) {
-		auto child = make_unique<CastExpressionMatcher>();
-		child->type = make_unique<TypeMatcherId>(LogicalTypeId::VARCHAR);
-		child->matcher = make_unique<ExpressionMatcher>();
-		child->matcher->type = make_unique<TypeMatcherId>(LogicalTypeId::ENUM);
-		op->matchers.push_back(move(child));
-	}
-	root = move(op);
-}
-
-bool AreMatchesPossible(LogicalType &left, LogicalType &right) {
-	LogicalType *small_enum, *big_enum;
-	if (EnumType::GetSize(left) < EnumType::GetSize(right)) {
-		small_enum = &left;
-		big_enum = &right;
-	} else {
-		small_enum = &right;
-		big_enum = &left;
-	}
-	auto &string_vec = EnumType::GetValuesInsertOrder(*small_enum);
-	auto string_vec_ptr = FlatVector::GetData<string_t>(string_vec);
-	auto size = EnumType::GetSize(*small_enum);
-	for (idx_t i = 0; i < size; i++) {
-		auto key = string_vec_ptr[i].GetString();
-		if (EnumType::GetPos(*big_enum, key) != -1) {
-			return true;
-		}
-	}
-	return false;
-}
-unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                 bool &changes_made, bool is_root) {
-
-	auto root = (BoundComparisonExpression *)bindings[0];
-	auto left_child = (BoundCastExpression *)bindings[1];
-	auto right_child = (BoundCastExpression *)bindings[3];
-
-	if (!AreMatchesPossible(left_child->child->return_type, right_child->child->return_type)) {
-		vector<unique_ptr<Expression>> children;
-		children.push_back(move(root->left));
-		children.push_back(move(root->right));
-		return ExpressionRewriter::ConstantOrNull(move(children), Value::BOOLEAN(false));
-	}
-
-	if (!is_root || op.type != LogicalOperatorType::LOGICAL_FILTER) {
-		return nullptr;
-	}
-
-	auto cast_left_to_right =
-	    make_unique<BoundCastExpression>(move(left_child->child), right_child->child->return_type, true);
-
-	return make_unique<BoundComparisonExpression>(root->type, move(cast_left_to_right), move(right_child->child));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-EqualOrNullSimplification::EqualOrNullSimplification(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on OR conjunction
-	auto op = make_unique<ConjunctionExpressionMatcher>();
-	op->expr_type = make_unique<SpecificExpressionTypeMatcher>(ExpressionType::CONJUNCTION_OR);
-	op->policy = SetMatcher::Policy::SOME;
-
-	// equi comparison on one side
-	auto equal_child = make_unique<ComparisonExpressionMatcher>();
-	equal_child->expr_type = make_unique<SpecificExpressionTypeMatcher>(ExpressionType::COMPARE_EQUAL);
-	equal_child->policy = SetMatcher::Policy::SOME;
-	op->matchers.push_back(move(equal_child));
-
-	// AND conjuction on the other
-	auto and_child = make_unique<ConjunctionExpressionMatcher>();
-	and_child->expr_type = make_unique<SpecificExpressionTypeMatcher>(ExpressionType::CONJUNCTION_AND);
-	and_child->policy = SetMatcher::Policy::SOME;
-
-	// IS NULL tests inside AND
-	auto isnull_child = make_unique<ExpressionMatcher>();
-	isnull_child->expr_type = make_unique<SpecificExpressionTypeMatcher>(ExpressionType::OPERATOR_IS_NULL);
-	// I could try to use std::make_unique for a copy, but it's available from C++14 only
-	auto isnull_child2 = make_unique<ExpressionMatcher>();
-	isnull_child2->expr_type = make_unique<SpecificExpressionTypeMatcher>(ExpressionType::OPERATOR_IS_NULL);
-	and_child->matchers.push_back(move(isnull_child));
-	and_child->matchers.push_back(move(isnull_child2));
-
-	op->matchers.push_back(move(and_child));
-	root = move(op);
-}
-
-// a=b OR (a IS NULL AND b IS NULL) to a IS NOT DISTINCT FROM b
-static unique_ptr<Expression> TryRewriteEqualOrIsNull(const Expression *equal_expr, const Expression *and_expr) {
-	if (equal_expr->type != ExpressionType::COMPARE_EQUAL || and_expr->type != ExpressionType::CONJUNCTION_AND) {
-		return nullptr;
-	}
-
-	const auto equal_cast = (BoundComparisonExpression *)equal_expr;
-	const auto and_cast = (BoundConjunctionExpression *)and_expr;
-
-	if (and_cast->children.size() != 2) {
-		return nullptr;
-	}
-
-	// Make sure on the AND conjuction the relevant conditions appear
-	const auto a_exp = equal_cast->left.get();
-	const auto b_exp = equal_cast->right.get();
-	bool valid = true;
-	bool a_is_null_found = false;
-	bool b_is_null_found = false;
-
-	for (const auto &item : and_cast->children) {
-		const auto next_exp = item.get();
-
-		if (next_exp->type == ExpressionType::OPERATOR_IS_NULL) {
-			const auto next_exp_cast = (BoundOperatorExpression *)next_exp;
-			const auto child = next_exp_cast->children[0].get();
-
-			// Test for equality on both 'a' and 'b' expressions
-			if (Expression::Equals(child, a_exp)) {
-				a_is_null_found = true;
-			} else if (Expression::Equals(child, b_exp)) {
-				b_is_null_found = true;
-			} else {
-				valid = false;
-				break;
-			}
-		} else {
-			valid = false;
-			break;
-		}
-	}
-	if (valid && a_is_null_found && b_is_null_found) {
-		return make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM, move(equal_cast->left),
-		                                              move(equal_cast->right));
-	}
-	return nullptr;
-}
-
-unique_ptr<Expression> EqualOrNullSimplification::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                        bool &changes_made, bool is_root) {
-	const Expression *or_exp = bindings[0];
-
-	if (or_exp->type != ExpressionType::CONJUNCTION_OR) {
-		return nullptr;
-	}
-
-	const auto or_exp_cast = (BoundConjunctionExpression *)or_exp;
-
-	if (or_exp_cast->children.size() != 2) {
-		return nullptr;
-	}
-
-	const auto left_exp = or_exp_cast->children[0].get();
-	const auto right_exp = or_exp_cast->children[1].get();
-	// Test for: a=b OR (a IS NULL AND b IS NULL)
-	auto first_try = TryRewriteEqualOrIsNull(left_exp, right_exp);
-	if (first_try) {
-		return first_try;
-	}
-	// Test for: (a IS NULL AND b IS NULL) OR a=b
-	return TryRewriteEqualOrIsNull(right_exp, left_exp);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-InClauseSimplificationRule::InClauseSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on InClauseExpression that has a ConstantExpression as a check
-	auto op = make_unique<InClauseExpressionMatcher>();
-	op->policy = SetMatcher::Policy::SOME;
-	root = move(op);
-}
-
-unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                         bool &changes_made, bool is_root) {
-	D_ASSERT(bindings[0]->expression_class == ExpressionClass::BOUND_OPERATOR);
-	auto expr = (BoundOperatorExpression *)bindings[0];
-	if (expr->children[0]->expression_class != ExpressionClass::BOUND_CAST) {
-		return nullptr;
-	}
-	auto cast_expression = (BoundCastExpression *)expr->children[0].get();
-	if (cast_expression->child->expression_class != ExpressionClass::BOUND_COLUMN_REF) {
-		return nullptr;
-	}
-	//! Here we check if we can apply the expression on the constant side
-	auto target_type = cast_expression->source_type();
-	if (!BoundCastExpression::CastIsInvertible(cast_expression->return_type, target_type)) {
-		return nullptr;
-	}
-	vector<unique_ptr<BoundConstantExpression>> cast_list;
-	//! First check if we can cast all children
-	for (size_t i = 1; i < expr->children.size(); i++) {
-		if (expr->children[i]->expression_class != ExpressionClass::BOUND_CONSTANT) {
-			return nullptr;
-		}
-		D_ASSERT(expr->children[i]->IsFoldable());
-		auto constant_value = ExpressionExecutor::EvaluateScalar(*expr->children[i]);
-		auto new_constant = constant_value.TryCastAs(target_type);
-		if (!new_constant) {
-			return nullptr;
-		} else {
-			auto new_constant_expr = make_unique<BoundConstantExpression>(constant_value);
-			cast_list.push_back(move(new_constant_expr));
-		}
-	}
-	//! We can cast, so we move the new constant
-	for (size_t i = 1; i < expr->children.size(); i++) {
-		expr->children[i] = move(cast_list[i - 1]);
-
-		//		expr->children[i] = move(new_constant_expr);
-	}
-	//! We can cast the full list, so we move the column
-	expr->children[0] = move(cast_expression->child);
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-LikeOptimizationRule::LikeOptimizationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	// match on a FunctionExpression that has a foldable ConstantExpression
-	auto func = make_unique<FunctionExpressionMatcher>();
-	func->matchers.push_back(make_unique<ExpressionMatcher>());
-	func->matchers.push_back(make_unique<ConstantExpressionMatcher>());
-	func->policy = SetMatcher::Policy::ORDERED;
-	// we match on LIKE ("~~") and NOT LIKE ("!~~")
-	func->function = make_unique<ManyFunctionMatcher>(unordered_set<string> {"!~~", "~~"});
-	root = move(func);
-}
-
-static bool PatternIsConstant(const string &pattern) {
-	for (idx_t i = 0; i < pattern.size(); i++) {
-		if (pattern[i] == '%' || pattern[i] == '_') {
-			return false;
-		}
-	}
-	return true;
-}
-
-static bool PatternIsPrefix(const string &pattern) {
-	idx_t i;
-	for (i = pattern.size(); i > 0; i--) {
-		if (pattern[i - 1] != '%') {
-			break;
-		}
-	}
-	if (i == pattern.size()) {
-		// no trailing %
-		// cannot be a prefix
-		return false;
-	}
-	// continue to look in the string
-	// if there is a % or _ in the string (besides at the very end) this is not a prefix match
-	for (; i > 0; i--) {
-		if (pattern[i - 1] == '%' || pattern[i - 1] == '_') {
-			return false;
-		}
-	}
-	return true;
-}
-
-static bool PatternIsSuffix(const string &pattern) {
-	idx_t i;
-	for (i = 0; i < pattern.size(); i++) {
-		if (pattern[i] != '%') {
-			break;
-		}
-	}
-	if (i == 0) {
-		// no leading %
-		// cannot be a suffix
-		return false;
-	}
-	// continue to look in the string
-	// if there is a % or _ in the string (besides at the beginning) this is not a suffix match
-	for (; i < pattern.size(); i++) {
-		if (pattern[i] == '%' || pattern[i] == '_') {
-			return false;
-		}
-	}
-	return true;
-}
-
-static bool PatternIsContains(const string &pattern) {
-	idx_t start;
-	idx_t end;
-	for (start = 0; start < pattern.size(); start++) {
-		if (pattern[start] != '%') {
-			break;
-		}
-	}
-	for (end = pattern.size(); end > 0; end--) {
-		if (pattern[end - 1] != '%') {
-			break;
-		}
-	}
-	if (start == 0 || end == pattern.size()) {
-		// contains requires both a leading AND a trailing %
-		return false;
-	}
-	// check if there are any other special characters in the string
-	// if there is a % or _ in the string (besides at the beginning/end) this is not a contains match
-	for (idx_t i = start; i < end; i++) {
-		if (pattern[i] == '%' || pattern[i] == '_') {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                   bool &changes_made, bool is_root) {
-	auto root = (BoundFunctionExpression *)bindings[0];
-	auto constant_expr = (BoundConstantExpression *)bindings[2];
-	D_ASSERT(root->children.size() == 2);
-
-	if (constant_expr->value.IsNull()) {
-		return make_unique<BoundConstantExpression>(Value(root->return_type));
-	}
-
-	// the constant_expr is a scalar expression that we have to fold
-	if (!constant_expr->IsFoldable()) {
-		return nullptr;
-	}
-
-	auto constant_value = ExpressionExecutor::EvaluateScalar(*constant_expr);
-	D_ASSERT(constant_value.type() == constant_expr->return_type);
-	auto &patt_str = StringValue::Get(constant_value);
-
-	bool is_not_like = root->function.name == "!~~";
-	if (PatternIsConstant(patt_str)) {
-		// Pattern is constant
-		return make_unique<BoundComparisonExpression>(is_not_like ? ExpressionType::COMPARE_NOTEQUAL
-		                                                          : ExpressionType::COMPARE_EQUAL,
-		                                              move(root->children[0]), move(root->children[1]));
-	} else if (PatternIsPrefix(patt_str)) {
-		// Prefix LIKE pattern : [^%_]*[%]+, ignoring underscore
-		return ApplyRule(root, PrefixFun::GetFunction(), patt_str, is_not_like);
-	} else if (PatternIsSuffix(patt_str)) {
-		// Suffix LIKE pattern: [%]+[^%_]*, ignoring underscore
-		return ApplyRule(root, SuffixFun::GetFunction(), patt_str, is_not_like);
-	} else if (PatternIsContains(patt_str)) {
-		// Contains LIKE pattern: [%]+[^%_]*[%]+, ignoring underscore
-		return ApplyRule(root, ContainsFun::GetFunction(), patt_str, is_not_like);
-	}
-	return nullptr;
-}
-
-unique_ptr<Expression> LikeOptimizationRule::ApplyRule(BoundFunctionExpression *expr, ScalarFunction function,
-                                                       string pattern, bool is_not_like) {
-	// replace LIKE by an optimized function
-	unique_ptr<Expression> result;
-	auto new_function =
-	    make_unique<BoundFunctionExpression>(expr->return_type, move(function), move(expr->children), nullptr);
-
-	// removing "%" from the pattern
-	pattern.erase(std::remove(pattern.begin(), pattern.end(), '%'), pattern.end());
-
-	new_function->children[1] = make_unique<BoundConstantExpression>(Value(move(pattern)));
-
-	result = move(new_function);
-	if (is_not_like) {
-		auto negation = make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_NOT, LogicalType::BOOLEAN);
-		negation->children.push_back(move(result));
-		result = move(negation);
-	}
-
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-MoveConstantsRule::MoveConstantsRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	auto op = make_unique<ComparisonExpressionMatcher>();
-	op->matchers.push_back(make_unique<ConstantExpressionMatcher>());
-	op->policy = SetMatcher::Policy::UNORDERED;
-
-	auto arithmetic = make_unique<FunctionExpressionMatcher>();
-	// we handle multiplication, addition and subtraction because those are "easy"
-	// integer division makes the division case difficult
-	// e.g. [x / 2 = 3] means [x = 6 OR x = 7] because of truncation -> no clean rewrite rules
-	arithmetic->function = make_unique<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*"});
-	// we match only on integral numeric types
-	arithmetic->type = make_unique<IntegerTypeMatcher>();
-	arithmetic->matchers.push_back(make_unique<ConstantExpressionMatcher>());
-	arithmetic->matchers.push_back(make_unique<ExpressionMatcher>());
-	arithmetic->policy = SetMatcher::Policy::SOME;
-	op->matchers.push_back(move(arithmetic));
-	root = move(op);
-}
-
-unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-                                                bool is_root) {
-	auto comparison = (BoundComparisonExpression *)bindings[0];
-	auto outer_constant = (BoundConstantExpression *)bindings[1];
-	auto arithmetic = (BoundFunctionExpression *)bindings[2];
-	auto inner_constant = (BoundConstantExpression *)bindings[3];
-	if (!TypeIsIntegral(arithmetic->return_type.InternalType())) {
-		return nullptr;
-	}
-	if (inner_constant->value.IsNull() || outer_constant->value.IsNull()) {
-		return make_unique<BoundConstantExpression>(Value(comparison->return_type));
-	}
-	auto &constant_type = outer_constant->return_type;
-	hugeint_t outer_value = IntegralValue::Get(outer_constant->value);
-	hugeint_t inner_value = IntegralValue::Get(inner_constant->value);
-
-	idx_t arithmetic_child_index = arithmetic->children[0].get() == inner_constant ? 1 : 0;
-	auto &op_type = arithmetic->function.name;
-	if (op_type == "+") {
-		// [x + 1 COMP 10] OR [1 + x COMP 10]
-		// order does not matter in addition:
-		// simply change right side to 10-1 (outer_constant - inner_constant)
-		if (!Hugeint::SubtractInPlace(outer_value, inner_value)) {
-			return nullptr;
-		}
-		auto result_value = Value::HUGEINT(outer_value);
-		if (!result_value.TryCastAs(constant_type)) {
-			// if the cast is not possible then the comparison is not possible
-			// for example, if we have x + 5 = 3, where x is an unsigned number, we will get x = -2
-			// since this is not possible we can remove the entire branch here
-			return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
-			                                          Value::BOOLEAN(false));
-		}
-		outer_constant->value = move(result_value);
-	} else if (op_type == "-") {
-		// [x - 1 COMP 10] O R [1 - x COMP 10]
-		// order matters in subtraction:
-		if (arithmetic_child_index == 0) {
-			// [x - 1 COMP 10]
-			// change right side to 10+1 (outer_constant + inner_constant)
-			if (!Hugeint::AddInPlace(outer_value, inner_value)) {
-				return nullptr;
-			}
-			auto result_value = Value::HUGEINT(outer_value);
-			if (!result_value.TryCastAs(constant_type)) {
-				// if the cast is not possible then the comparison is not possible
-				return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
-				                                          Value::BOOLEAN(false));
-			}
-			outer_constant->value = move(result_value);
-		} else {
-			// [1 - x COMP 10]
-			// change right side to 1-10=-9
-			if (!Hugeint::SubtractInPlace(inner_value, outer_value)) {
-				return nullptr;
-			}
-			auto result_value = Value::HUGEINT(inner_value);
-			if (!result_value.TryCastAs(constant_type)) {
-				// if the cast is not possible then the comparison is not possible
-				return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
-				                                          Value::BOOLEAN(false));
-			}
-			outer_constant->value = move(result_value);
-			// in this case, we should also flip the comparison
-			// e.g. if we have [4 - x < 2] then we should have [x > 2]
-			comparison->type = FlipComparisionExpression(comparison->type);
-		}
-	} else {
-		D_ASSERT(op_type == "*");
-		// [x * 2 COMP 10] OR [2 * x COMP 10]
-		// order does not matter in multiplication:
-		// change right side to 10/2 (outer_constant / inner_constant)
-		// but ONLY if outer_constant is cleanly divisible by the inner_constant
-		if (inner_value == 0) {
-			// x * 0, the result is either 0 or NULL
-			// we let the arithmetic_simplification rule take care of simplifying this first
-			return nullptr;
-		}
-		if (outer_value % inner_value != 0) {
-			// not cleanly divisible
-			bool is_equality = comparison->type == ExpressionType::COMPARE_EQUAL;
-			bool is_inequality = comparison->type == ExpressionType::COMPARE_NOTEQUAL;
-			if (is_equality || is_inequality) {
-				// we know the values are not equal
-				// the result will be either FALSE or NULL (if COMPARE_EQUAL)
-				// or TRUE or NULL (if COMPARE_NOTEQUAL)
-				return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
-				                                          Value::BOOLEAN(is_inequality));
-			} else {
-				// not cleanly divisible and we are doing > >= < <=, skip the simplification for now
-				return nullptr;
-			}
-		}
-		if (inner_value < 0) {
-			// multiply by negative value, need to flip expression
-			comparison->type = FlipComparisionExpression(comparison->type);
-		}
-		// else divide the RHS by the LHS
-		// we need to do a range check on the cast even though we do a division
-		// because e.g. -128 / -1 = 128, which is out of range
-		auto result_value = Value::HUGEINT(outer_value / inner_value);
-		if (!result_value.TryCastAs(constant_type)) {
-			return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
-			                                          Value::BOOLEAN(false));
-		}
-		outer_constant->value = move(result_value);
-	}
-	// replace left side with x
-	// first extract x from the arithmetic expression
-	auto arithmetic_child = move(arithmetic->children[arithmetic_child_index]);
-	// then place in the comparison
-	if (comparison->left.get() == outer_constant) {
-		comparison->right = move(arithmetic_child);
-	} else {
-		comparison->left = move(arithmetic_child);
-	}
-	changes_made = true;
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-RegexOptimizationRule::RegexOptimizationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
-	auto func = make_unique<FunctionExpressionMatcher>();
-	func->function = make_unique<SpecificFunctionMatcher>("regexp_matches");
-	func->policy = SetMatcher::Policy::ORDERED;
-	func->matchers.push_back(make_unique<ExpressionMatcher>());
-	func->matchers.push_back(make_unique<ConstantExpressionMatcher>());
-	root = move(func);
-}
-
-unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                    bool &changes_made, bool is_root) {
-	auto root = (BoundFunctionExpression *)bindings[0];
-	auto constant_expr = (BoundConstantExpression *)bindings[2];
-	D_ASSERT(root->children.size() == 2);
-
-	if (constant_expr->value.IsNull()) {
-		return make_unique<BoundConstantExpression>(Value(root->return_type));
-	}
-
-	// the constant_expr is a scalar expression that we have to fold
-	if (!constant_expr->IsFoldable()) {
-		return nullptr;
-	}
-
-	auto constant_value = ExpressionExecutor::EvaluateScalar(*constant_expr);
-	D_ASSERT(constant_value.type() == constant_expr->return_type);
-	auto &patt_str = StringValue::Get(constant_value);
-
-	duckdb_re2::RE2 pattern(patt_str);
-	if (!pattern.ok()) {
-		return nullptr; // this should fail somewhere else
-	}
-
-	if (pattern.Regexp()->op() == duckdb_re2::kRegexpLiteralString ||
-	    pattern.Regexp()->op() == duckdb_re2::kRegexpLiteral) {
-		auto contains = make_unique<BoundFunctionExpression>(root->return_type, ContainsFun::GetFunction(),
-		                                                     move(root->children), nullptr);
-
-		contains->children[1] = make_unique<BoundConstantExpression>(Value(patt_str));
-		return move(contains);
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundAggregateExpression &aggr,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	vector<unique_ptr<BaseStatistics>> stats;
-	stats.reserve(aggr.children.size());
-	for (auto &child : aggr.children) {
-		stats.push_back(PropagateExpression(child));
-	}
-	if (!aggr.function.statistics) {
-		return nullptr;
-	}
-	return aggr.function.statistics(context, aggr, aggr.bind_info.get(), stats, node_stats.get());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-bool GetCastType(T signed_range, LogicalType &cast_type) {
-	auto range = static_cast<typename std::make_unsigned<decltype(signed_range)>::type>(signed_range);
-
-	// Check if this range fits in a smaller type
-	if (range < NumericLimits<uint8_t>::Maximum()) {
-		cast_type = LogicalType::UTINYINT;
-	} else if (sizeof(T) > sizeof(uint16_t) && range < NumericLimits<uint16_t>::Maximum()) {
-		cast_type = LogicalType::USMALLINT;
-	} else if (sizeof(T) > sizeof(uint32_t) && range < NumericLimits<uint32_t>::Maximum()) {
-		cast_type = LogicalType::UINTEGER;
-	} else {
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool GetCastType(hugeint_t range, LogicalType &cast_type) {
-	if (range < NumericLimits<uint8_t>().Maximum()) {
-		cast_type = LogicalType::UTINYINT;
-	} else if (range < NumericLimits<uint16_t>().Maximum()) {
-		cast_type = LogicalType::USMALLINT;
-	} else if (range < NumericLimits<uint32_t>().Maximum()) {
-		cast_type = LogicalType::UINTEGER;
-	} else if (range < NumericLimits<uint64_t>().Maximum()) {
-		cast_type = LogicalType::UBIGINT;
-	} else {
-		return false;
-	}
-	return true;
-}
-
-template <class T>
-unique_ptr<Expression> TemplatedCastToSmallestType(unique_ptr<Expression> expr, NumericStatistics &num_stats) {
-	// Compute range
-	if (num_stats.min.IsNull() || num_stats.max.IsNull()) {
-		return expr;
-	}
-
-	auto signed_min_val = num_stats.min.GetValue<T>();
-	auto signed_max_val = num_stats.max.GetValue<T>();
-	if (signed_max_val < signed_min_val) {
-		return expr;
-	}
-
-	// Compute range, cast to unsigned to prevent comparing signed with unsigned
-	T signed_range;
-	if (!TrySubtractOperator::Operation(signed_max_val, signed_min_val, signed_range)) {
-		// overflow in subtraction: cannot do any simplification
-		return expr;
-	}
-
-	// Check if this range fits in a smaller type
-	LogicalType cast_type;
-	if (!GetCastType(signed_range, cast_type)) {
-		return expr;
-	}
-
-	// Create expression to map to a smaller range
-	auto input_type = expr->return_type;
-	auto minimum_expr = make_unique<BoundConstantExpression>(Value::CreateValue(signed_min_val));
-	vector<unique_ptr<Expression>> arguments;
-	arguments.push_back(move(expr));
-	arguments.push_back(move(minimum_expr));
-	auto minus_expr = make_unique<BoundFunctionExpression>(input_type, SubtractFun::GetFunction(input_type, input_type),
-	                                                       move(arguments), nullptr, true);
-
-	// Cast to smaller type
-	return make_unique<BoundCastExpression>(move(minus_expr), cast_type);
-}
-
-unique_ptr<Expression> CastToSmallestType(unique_ptr<Expression> expr, NumericStatistics &num_stats) {
-	auto physical_type = expr->return_type.InternalType();
-	switch (physical_type) {
-	case PhysicalType::UINT8:
-	case PhysicalType::INT8:
-		return expr;
-	case PhysicalType::UINT16:
-		return TemplatedCastToSmallestType<uint16_t>(move(expr), num_stats);
-	case PhysicalType::INT16:
-		return TemplatedCastToSmallestType<int16_t>(move(expr), num_stats);
-	case PhysicalType::UINT32:
-		return TemplatedCastToSmallestType<uint32_t>(move(expr), num_stats);
-	case PhysicalType::INT32:
-		return TemplatedCastToSmallestType<int32_t>(move(expr), num_stats);
-	case PhysicalType::UINT64:
-		return TemplatedCastToSmallestType<uint64_t>(move(expr), num_stats);
-	case PhysicalType::INT64:
-		return TemplatedCastToSmallestType<int64_t>(move(expr), num_stats);
-	case PhysicalType::INT128:
-		return TemplatedCastToSmallestType<hugeint_t>(move(expr), num_stats);
-	default:
-		throw NotImplementedException("Unknown integer type!");
-	}
-}
-
-void StatisticsPropagator::PropagateAndCompress(unique_ptr<Expression> &expr, unique_ptr<BaseStatistics> &stats) {
-	stats = PropagateExpression(expr);
-	if (stats) {
-		if (expr->return_type.IsIntegral()) {
-			expr = CastToSmallestType(move(expr), (NumericStatistics &)*stats);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundBetweenExpression &between,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	// propagate in all the children
-	auto input_stats = PropagateExpression(between.input);
-	auto lower_stats = PropagateExpression(between.lower);
-	auto upper_stats = PropagateExpression(between.upper);
-	if (!input_stats) {
-		return nullptr;
-	}
-	auto lower_comparison = between.LowerComparisonType();
-	auto upper_comparison = between.UpperComparisonType();
-	// propagate the comparisons
-	auto lower_prune = FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	auto upper_prune = FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	if (lower_stats) {
-		lower_prune = PropagateComparison(*input_stats, *lower_stats, lower_comparison);
-	}
-	if (upper_stats) {
-		upper_prune = PropagateComparison(*input_stats, *upper_stats, upper_comparison);
-	}
-	if (lower_prune == FilterPropagateResult::FILTER_ALWAYS_TRUE &&
-	    upper_prune == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-		// both filters are always true: replace the between expression with a constant true
-		*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(true));
-	} else if (lower_prune == FilterPropagateResult::FILTER_ALWAYS_FALSE ||
-	           upper_prune == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-		// either one of the filters is always false: replace the between expression with a constant false
-		*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(false));
-	} else if (lower_prune == FilterPropagateResult::FILTER_FALSE_OR_NULL ||
-	           upper_prune == FilterPropagateResult::FILTER_FALSE_OR_NULL) {
-		// either one of the filters is false or null: replace with a constant or null (false)
-		vector<unique_ptr<Expression>> children;
-		children.push_back(move(between.input));
-		children.push_back(move(between.lower));
-		children.push_back(move(between.upper));
-		*expr_ptr = ExpressionRewriter::ConstantOrNull(move(children), Value::BOOLEAN(false));
-	} else if (lower_prune == FilterPropagateResult::FILTER_TRUE_OR_NULL &&
-	           upper_prune == FilterPropagateResult::FILTER_TRUE_OR_NULL) {
-		// both filters are true or null: replace with a true or null
-		vector<unique_ptr<Expression>> children;
-		children.push_back(move(between.input));
-		children.push_back(move(between.lower));
-		children.push_back(move(between.upper));
-		*expr_ptr = ExpressionRewriter::ConstantOrNull(move(children), Value::BOOLEAN(true));
-	} else if (lower_prune == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-		// lower filter is always true: replace with upper comparison
-		*expr_ptr = make_unique<BoundComparisonExpression>(upper_comparison, move(between.input), move(between.upper));
-	} else if (upper_prune == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-		// upper filter is always true: replace with lower comparison
-		*expr_ptr = make_unique<BoundComparisonExpression>(lower_comparison, move(between.input), move(between.lower));
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundCaseExpression &bound_case,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	// propagate in all the children
-	auto result_stats = PropagateExpression(bound_case.else_expr);
-	for (auto &case_check : bound_case.case_checks) {
-		PropagateExpression(case_check.when_expr);
-		auto then_stats = PropagateExpression(case_check.then_expr);
-		if (!then_stats) {
-			result_stats.reset();
-		} else if (result_stats) {
-			result_stats->Merge(*then_stats);
-		}
-	}
-	return result_stats;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-static unique_ptr<BaseStatistics> StatisticsOperationsNumericNumericCast(const BaseStatistics *input_p,
-                                                                         const LogicalType &target) {
-	auto &input = (NumericStatistics &)*input_p;
-
-	Value min = input.min, max = input.max;
-	if (!min.TryCastAs(target) || !max.TryCastAs(target)) {
-		// overflow in cast: bailout
-		return nullptr;
-	}
-	auto stats = make_unique<NumericStatistics>(target, move(min), move(max), input.stats_type);
-	stats->CopyBase(*input_p);
-	return move(stats);
-}
-
-static unique_ptr<BaseStatistics> StatisticsNumericCastSwitch(const BaseStatistics *input, const LogicalType &target) {
-	switch (target.InternalType()) {
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return StatisticsOperationsNumericNumericCast(input, target);
-	default:
-		return nullptr;
-	}
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundCastExpression &cast,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	auto child_stats = PropagateExpression(cast.child);
-	if (!child_stats) {
-		return nullptr;
-	}
-	unique_ptr<BaseStatistics> result_stats;
-	switch (cast.child->return_type.InternalType()) {
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		result_stats = StatisticsNumericCastSwitch(child_stats.get(), cast.return_type);
-		break;
-	default:
-		return nullptr;
-	}
-	if (cast.try_cast && result_stats) {
-		result_stats->validity_stats = make_unique<ValidityStatistics>(true, true);
-	}
-	return result_stats;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundColumnRefExpression &colref,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	auto stats = statistics_map.find(colref.binding);
-	if (stats == statistics_map.end()) {
-		return nullptr;
-	}
-	return stats->second->Copy();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-FilterPropagateResult StatisticsPropagator::PropagateComparison(BaseStatistics &left, BaseStatistics &right,
-                                                                ExpressionType comparison) {
-	// only handle numerics for now
-	switch (left.type.InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		break;
-	default:
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	auto &lstats = (NumericStatistics &)left;
-	auto &rstats = (NumericStatistics &)right;
-	if (lstats.min.IsNull() || lstats.max.IsNull() || rstats.min.IsNull() || rstats.max.IsNull()) {
-		// no stats available: nothing to prune
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	// the result of the propagation depend on whether or not either side has null values
-	// if there are null values present, we cannot say whether or not
-	bool has_null = lstats.CanHaveNull() || rstats.CanHaveNull();
-	switch (comparison) {
-	case ExpressionType::COMPARE_EQUAL:
-		// l = r, if l.min > r.max or r.min > l.max equality is not possible
-		if (lstats.min > rstats.max || rstats.min > lstats.max) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		} else {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		}
-	case ExpressionType::COMPARE_GREATERTHAN:
-		// l > r
-		if (lstats.min > rstats.max) {
-			// if l.min > r.max, it is always true ONLY if neither side contains nulls
-			return has_null ? FilterPropagateResult::FILTER_TRUE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		// if r.min is bigger or equal to l.max, the filter is always false
-		if (rstats.min >= lstats.max) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// l >= r
-		if (lstats.min >= rstats.max) {
-			// if l.min >= r.max, it is always true ONLY if neither side contains nulls
-			return has_null ? FilterPropagateResult::FILTER_TRUE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		// if r.min > l.max, the filter is always false
-		if (rstats.min > lstats.max) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_LESSTHAN:
-		// l < r
-		if (lstats.max < rstats.min) {
-			// if l.max < r.min, it is always true ONLY if neither side contains nulls
-			return has_null ? FilterPropagateResult::FILTER_TRUE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		// if l.min >= rstats.max, the filter is always false
-		if (lstats.min >= rstats.max) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// l <= r
-		if (lstats.max <= rstats.min) {
-			// if l.max <= r.min, it is always true ONLY if neither side contains nulls
-			return has_null ? FilterPropagateResult::FILTER_TRUE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		// if l.min > rstats.max, the filter is always false
-		if (lstats.min > rstats.max) {
-			return has_null ? FilterPropagateResult::FILTER_FALSE_OR_NULL : FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	default:
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundComparisonExpression &expr,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	auto left_stats = PropagateExpression(expr.left);
-	auto right_stats = PropagateExpression(expr.right);
-	if (!left_stats || !right_stats) {
-		return nullptr;
-	}
-	// propagate the statistics of the comparison operator
-	auto propagate_result = PropagateComparison(*left_stats, *right_stats, expr.type);
-	switch (propagate_result) {
-	case FilterPropagateResult::FILTER_ALWAYS_TRUE:
-		*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(true));
-		return PropagateExpression(*expr_ptr);
-	case FilterPropagateResult::FILTER_ALWAYS_FALSE:
-		*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(false));
-		return PropagateExpression(*expr_ptr);
-	case FilterPropagateResult::FILTER_TRUE_OR_NULL: {
-		vector<unique_ptr<Expression>> children;
-		children.push_back(move(expr.left));
-		children.push_back(move(expr.right));
-		*expr_ptr = ExpressionRewriter::ConstantOrNull(move(children), Value::BOOLEAN(true));
-		return nullptr;
-	}
-	case FilterPropagateResult::FILTER_FALSE_OR_NULL: {
-		vector<unique_ptr<Expression>> children;
-		children.push_back(move(expr.left));
-		children.push_back(move(expr.right));
-		*expr_ptr = ExpressionRewriter::ConstantOrNull(move(children), Value::BOOLEAN(false));
-		return nullptr;
-	}
-	default:
-		// FIXME: we can propagate nulls here, i.e. this expression will have nulls only if left and right has nulls
-		return nullptr;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundConjunctionExpression &expr,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	auto is_and = expr.type == ExpressionType::CONJUNCTION_AND;
-	for (idx_t expr_idx = 0; expr_idx < expr.children.size(); expr_idx++) {
-		auto &child = expr.children[expr_idx];
-		auto stats = PropagateExpression(child);
-		if (!child->IsFoldable()) {
-			continue;
-		}
-		// we have a constant in a conjunction
-		// we (1) either prune the child
-		// or (2) replace the entire conjunction with a constant
-		auto constant = ExpressionExecutor::EvaluateScalar(*child);
-		if (constant.IsNull()) {
-			continue;
-		}
-		auto b = BooleanValue::Get(constant);
-		bool prune_child = false;
-		bool constant_value = true;
-		if (b) {
-			// true
-			if (is_and) {
-				// true in and: prune child
-				prune_child = true;
-			} else {
-				// true in OR: replace with TRUE
-				constant_value = true;
-			}
-		} else {
-			// false
-			if (is_and) {
-				// false in AND: replace with FALSE
-				constant_value = false;
-			} else {
-				// false in OR: prune child
-				prune_child = true;
-			}
-		}
-		if (prune_child) {
-			expr.children.erase(expr.children.begin() + expr_idx);
-			expr_idx--;
-			continue;
-		}
-		*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(constant_value));
-		return PropagateExpression(*expr_ptr);
-	}
-	if (expr.children.empty()) {
-		// if there are no children left, replace the conjunction with TRUE (for AND) or FALSE (for OR)
-		*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(is_and));
-		return PropagateExpression(*expr_ptr);
-	} else if (expr.children.size() == 1) {
-		// if there is one child left, replace the conjunction with that one child
-		*expr_ptr = move(expr.children[0]);
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void UpdateDistinctStats(BaseStatistics &distinct_stats, const Value &input) {
-	Vector v(input);
-	auto &d_stats = (DistinctStatistics &)distinct_stats;
-	d_stats.Update(v, 1);
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::StatisticsFromValue(const Value &input) {
-	switch (input.type().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE: {
-		auto result = make_unique<NumericStatistics>(input.type(), input, input, StatisticsType::GLOBAL_STATS);
-		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
-		UpdateDistinctStats(*result->distinct_stats, input);
-		return move(result);
-	}
-	case PhysicalType::VARCHAR: {
-		auto result = make_unique<StringStatistics>(input.type(), StatisticsType::GLOBAL_STATS);
-		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
-		UpdateDistinctStats(*result->distinct_stats, input);
-		if (!input.IsNull()) {
-			auto &string_value = StringValue::Get(input);
-			result->Update(string_t(string_value));
-		}
-		return move(result);
-	}
-	case PhysicalType::STRUCT: {
-		auto result = make_unique<StructStatistics>(input.type());
-		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
-		if (input.IsNull()) {
-			for (auto &child_stat : result->child_stats) {
-				child_stat.reset();
-			}
-		} else {
-			auto &struct_children = StructValue::GetChildren(input);
-			D_ASSERT(result->child_stats.size() == struct_children.size());
-			for (idx_t i = 0; i < result->child_stats.size(); i++) {
-				result->child_stats[i] = StatisticsFromValue(struct_children[i]);
-			}
-		}
-		return move(result);
-	}
-	case PhysicalType::LIST: {
-		auto result = make_unique<ListStatistics>(input.type());
-		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
-		if (input.IsNull()) {
-			result->child_stats.reset();
-		} else {
-			auto &list_children = ListValue::GetChildren(input);
-			for (auto &child_element : list_children) {
-				auto child_element_stats = StatisticsFromValue(child_element);
-				if (child_element_stats) {
-					result->child_stats->Merge(*child_element_stats);
-				} else {
-					result->child_stats.reset();
-				}
-			}
-		}
-		return move(result);
-	}
-	default:
-		return nullptr;
-	}
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundConstantExpression &constant,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	return StatisticsFromValue(constant.value);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundFunctionExpression &func,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	vector<unique_ptr<BaseStatistics>> stats;
-	stats.reserve(func.children.size());
-	for (idx_t i = 0; i < func.children.size(); i++) {
-		stats.push_back(PropagateExpression(func.children[i]));
-	}
-	if (!func.function.statistics) {
-		return nullptr;
-	}
-	FunctionStatisticsInput input(func, func.bind_info.get(), stats, expr_ptr);
-	return func.function.statistics(context, input);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundOperatorExpression &expr,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	bool all_have_stats = true;
-	vector<unique_ptr<BaseStatistics>> child_stats;
-	child_stats.reserve(expr.children.size());
-	for (auto &child : expr.children) {
-		auto stats = PropagateExpression(child);
-		if (!stats) {
-			all_have_stats = false;
-		}
-		child_stats.push_back(move(stats));
-	}
-	if (!all_have_stats) {
-		return nullptr;
-	}
-	switch (expr.type) {
-	case ExpressionType::OPERATOR_COALESCE:
-		// COALESCE, merge stats of all children
-		for (idx_t i = 0; i < expr.children.size(); i++) {
-			D_ASSERT(child_stats[i]);
-			if (!child_stats[i]->CanHaveNoNull()) {
-				// this child is always NULL, we can remove it from the coalesce
-				// UNLESS there is only one node remaining
-				if (expr.children.size() > 1) {
-					expr.children.erase(expr.children.begin() + i);
-					child_stats.erase(child_stats.begin() + i);
-					i--;
-				}
-			} else if (!child_stats[i]->CanHaveNull()) {
-				// coalesce child cannot have NULL entries
-				// this is the last coalesce node that influences the result
-				// we can erase any children after this node
-				if (i + 1 < expr.children.size()) {
-					expr.children.erase(expr.children.begin() + i + 1, expr.children.end());
-					child_stats.erase(child_stats.begin() + i + 1, child_stats.end());
-				}
-				break;
-			}
-		}
-		D_ASSERT(!expr.children.empty());
-		D_ASSERT(expr.children.size() == child_stats.size());
-		if (expr.children.size() == 1) {
-			// coalesce of one entry: simply return that entry
-			*expr_ptr = move(expr.children[0]);
-		} else {
-			// coalesce of multiple entries
-			// merge the stats
-			for (idx_t i = 1; i < expr.children.size(); i++) {
-				child_stats[0]->Merge(*child_stats[i]);
-			}
-		}
-		return move(child_stats[0]);
-	case ExpressionType::OPERATOR_IS_NULL:
-		if (!child_stats[0]->CanHaveNull()) {
-			// child has no null values: x IS NULL will always be false
-			*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(false));
-			return PropagateExpression(*expr_ptr);
-		}
-		return nullptr;
-	case ExpressionType::OPERATOR_IS_NOT_NULL:
-		if (!child_stats[0]->CanHaveNull()) {
-			// child has no null values: x IS NOT NULL will always be true
-			*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(true));
-			return PropagateExpression(*expr_ptr);
-		}
-		return nullptr;
-	default:
-		return nullptr;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalAggregate &aggr,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// first propagate statistics in the child node
-	node_stats = PropagateStatistics(aggr.children[0]);
-
-	// handle the groups: simply propagate statistics and assign the stats to the group binding
-	aggr.group_stats.resize(aggr.groups.size());
-	for (idx_t group_idx = 0; group_idx < aggr.groups.size(); group_idx++) {
-		auto stats = PropagateExpression(aggr.groups[group_idx]);
-		aggr.group_stats[group_idx] = stats ? stats->Copy() : nullptr;
-		if (!stats) {
-			continue;
-		}
-		if (aggr.grouping_sets.size() > 1) {
-			// aggregates with multiple grouping sets can introduce NULL values to certain groups
-			// FIXME: actually figure out WHICH groups can have null values introduced
-			stats->validity_stats = make_unique<ValidityStatistics>(true, true);
-			continue;
-		}
-		ColumnBinding group_binding(aggr.group_index, group_idx);
-		statistics_map[group_binding] = move(stats);
-	}
-	// propagate statistics in the aggregates
-	for (idx_t aggregate_idx = 0; aggregate_idx < aggr.expressions.size(); aggregate_idx++) {
-		auto stats = PropagateExpression(aggr.expressions[aggregate_idx]);
-		if (!stats) {
-			continue;
-		}
-		ColumnBinding aggregate_binding(aggr.aggregate_index, aggregate_idx);
-		statistics_map[aggregate_binding] = move(stats);
-	}
-	// the max cardinality of an aggregate is the max cardinality of the input (i.e. when every row is a unique group)
-	return move(node_stats);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalCrossProduct &cp,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// first propagate statistics in the child node
-	auto left_stats = PropagateStatistics(cp.children[0]);
-	auto right_stats = PropagateStatistics(cp.children[1]);
-	if (!left_stats || !right_stats) {
-		return nullptr;
-	}
-	MultiplyCardinalities(left_stats, *right_stats);
-	return left_stats;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static bool IsCompareDistinct(ExpressionType type) {
-	return type == ExpressionType::COMPARE_DISTINCT_FROM || type == ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-}
-
-bool StatisticsPropagator::ExpressionIsConstant(Expression &expr, const Value &val) {
-	if (expr.GetExpressionClass() != ExpressionClass::BOUND_CONSTANT) {
-		return false;
-	}
-	auto &bound_constant = (BoundConstantExpression &)expr;
-	D_ASSERT(bound_constant.value.type() == val.type());
-	return Value::NotDistinctFrom(bound_constant.value, val);
-}
-
-bool StatisticsPropagator::ExpressionIsConstantOrNull(Expression &expr, const Value &val) {
-	if (expr.GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) {
-		return false;
-	}
-	auto &bound_function = (BoundFunctionExpression &)expr;
-	return ConstantOrNull::IsConstantOrNull(bound_function, val);
-}
-
-void StatisticsPropagator::SetStatisticsNotNull(ColumnBinding binding) {
-	auto entry = statistics_map.find(binding);
-	if (entry == statistics_map.end()) {
-		return;
-	}
-	entry->second->validity_stats = make_unique<ValidityStatistics>(false);
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &stats, ExpressionType comparison_type,
-                                                  const Value &constant) {
-	// regular comparisons removes all null values
-	if (!IsCompareDistinct(comparison_type)) {
-		stats.validity_stats = make_unique<ValidityStatistics>(false);
-	}
-	if (!stats.type.IsNumeric()) {
-		// don't handle non-numeric columns here (yet)
-		return;
-	}
-	auto &numeric_stats = (NumericStatistics &)stats;
-	if (numeric_stats.min.IsNull() || numeric_stats.max.IsNull()) {
-		// no stats available: skip this
-		return;
-	}
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// X < constant OR X <= constant
-		// max becomes the constant
-		numeric_stats.max = constant;
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// X > constant OR X >= constant
-		// min becomes the constant
-		numeric_stats.min = constant;
-		break;
-	case ExpressionType::COMPARE_EQUAL:
-		// X = constant
-		// both min and max become the constant
-		numeric_stats.min = constant;
-		numeric_stats.max = constant;
-		break;
-	default:
-		break;
-	}
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &lstats, BaseStatistics &rstats,
-                                                  ExpressionType comparison_type) {
-	// regular comparisons removes all null values
-	if (!IsCompareDistinct(comparison_type)) {
-		lstats.validity_stats = make_unique<ValidityStatistics>(false);
-		rstats.validity_stats = make_unique<ValidityStatistics>(false);
-	}
-	D_ASSERT(lstats.type == rstats.type);
-	if (!lstats.type.IsNumeric()) {
-		// don't handle non-numeric columns here (yet)
-		return;
-	}
-	auto &left_stats = (NumericStatistics &)lstats;
-	auto &right_stats = (NumericStatistics &)rstats;
-	if (left_stats.min.IsNull() || left_stats.max.IsNull() || right_stats.min.IsNull() || right_stats.max.IsNull()) {
-		// no stats available: skip this
-		return;
-	}
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// LEFT < RIGHT OR LEFT <= RIGHT
-		// we know that every value of left is smaller (or equal to) every value in right
-		// i.e. if we have left = [-50, 250] and right = [-100, 100]
-
-		// we know that left.max is AT MOST equal to right.max
-		// because any value in left that is BIGGER than right.max will not pass the filter
-		if (left_stats.max > right_stats.max) {
-			left_stats.max = right_stats.max;
-		}
-
-		// we also know that right.min is AT MOST equal to left.min
-		// because any value in right that is SMALLER than left.min will not pass the filter
-		if (right_stats.min < left_stats.min) {
-			right_stats.min = left_stats.min;
-		}
-		// so in our example, the bounds get updated as follows:
-		// left: [-50, 100], right: [-50, 100]
-		break;
-	case ExpressionType::COMPARE_GREATERTHAN:
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// LEFT > RIGHT OR LEFT >= RIGHT
-		// we know that every value of left is bigger (or equal to) every value in right
-		// this is essentially the inverse of the less than (or equal to) scenario
-		if (right_stats.max > left_stats.max) {
-			right_stats.max = left_stats.max;
-		}
-		if (left_stats.min < right_stats.min) {
-			left_stats.min = right_stats.min;
-		}
-		break;
-	case ExpressionType::COMPARE_EQUAL:
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		// LEFT = RIGHT
-		// only the tightest bounds pass
-		// so if we have e.g. left = [-50, 250] and right = [-100, 100]
-		// the tighest bounds are [-50, 100]
-		// select the highest min
-		if (left_stats.min > right_stats.min) {
-			right_stats.min = left_stats.min;
-		} else {
-			left_stats.min = right_stats.min;
-		}
-		// select the lowest max
-		if (left_stats.max < right_stats.max) {
-			right_stats.max = left_stats.max;
-		} else {
-			left_stats.max = right_stats.max;
-		}
-		break;
-	default:
-		break;
-	}
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &right, ExpressionType comparison_type) {
-	// first check if either side is a bound column ref
-	// any column ref involved in a comparison will not be null after the comparison
-	bool compare_distinct = IsCompareDistinct(comparison_type);
-	if (!compare_distinct && left.type == ExpressionType::BOUND_COLUMN_REF) {
-		SetStatisticsNotNull(((BoundColumnRefExpression &)left).binding);
-	}
-	if (!compare_distinct && right.type == ExpressionType::BOUND_COLUMN_REF) {
-		SetStatisticsNotNull(((BoundColumnRefExpression &)right).binding);
-	}
-	// check if this is a comparison between a constant and a column ref
-	BoundConstantExpression *constant = nullptr;
-	BoundColumnRefExpression *columnref = nullptr;
-	if (left.type == ExpressionType::VALUE_CONSTANT && right.type == ExpressionType::BOUND_COLUMN_REF) {
-		constant = (BoundConstantExpression *)&left;
-		columnref = (BoundColumnRefExpression *)&right;
-		comparison_type = FlipComparisionExpression(comparison_type);
-	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::VALUE_CONSTANT) {
-		columnref = (BoundColumnRefExpression *)&left;
-		constant = (BoundConstantExpression *)&right;
-	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::BOUND_COLUMN_REF) {
-		// comparison between two column refs
-		auto &left_column_ref = (BoundColumnRefExpression &)left;
-		auto &right_column_ref = (BoundColumnRefExpression &)right;
-		auto lentry = statistics_map.find(left_column_ref.binding);
-		auto rentry = statistics_map.find(right_column_ref.binding);
-		if (lentry == statistics_map.end() || rentry == statistics_map.end()) {
-			return;
-		}
-		UpdateFilterStatistics(*lentry->second, *rentry->second, comparison_type);
-	} else {
-		// unsupported filter
-		return;
-	}
-	if (constant && columnref) {
-		// comparison between columnref
-		auto entry = statistics_map.find(columnref->binding);
-		if (entry == statistics_map.end()) {
-			return;
-		}
-		UpdateFilterStatistics(*entry->second, comparison_type, constant->value);
-	}
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(Expression &condition) {
-	// in filters, we check for constant comparisons with bound columns
-	// if we find a comparison in the form of e.g. "i=3", we can update our statistics for that column
-	switch (condition.GetExpressionClass()) {
-	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between = (BoundBetweenExpression &)condition;
-		UpdateFilterStatistics(*between.input, *between.lower, between.LowerComparisonType());
-		UpdateFilterStatistics(*between.input, *between.upper, between.UpperComparisonType());
-		break;
-	}
-	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comparison = (BoundComparisonExpression &)condition;
-		UpdateFilterStatistics(*comparison.left, *comparison.right, comparison.type);
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalFilter &filter,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// first propagate to the child
-	node_stats = PropagateStatistics(filter.children[0]);
-	if (filter.children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-		ReplaceWithEmptyResult(*node_ptr);
-		return make_unique<NodeStatistics>(0, 0);
-	}
-
-	// then propagate to each of the expressions
-	for (idx_t i = 0; i < filter.expressions.size(); i++) {
-		auto &condition = filter.expressions[i];
-		PropagateExpression(condition);
-
-		if (ExpressionIsConstant(*condition, Value::BOOLEAN(true))) {
-			// filter is always true; it is useless to execute it
-			// erase this condition
-			filter.expressions.erase(filter.expressions.begin() + i);
-			i--;
-			if (filter.expressions.empty()) {
-				// all conditions have been erased: remove the entire filter
-				*node_ptr = move(filter.children[0]);
-				break;
-			}
-		} else if (ExpressionIsConstant(*condition, Value::BOOLEAN(false)) ||
-		           ExpressionIsConstantOrNull(*condition, Value::BOOLEAN(false))) {
-			// filter is always false or null; this entire filter should be replaced by an empty result block
-			ReplaceWithEmptyResult(*node_ptr);
-			return make_unique<NodeStatistics>(0, 0);
-		} else {
-			// cannot prune this filter: propagate statistics from the filter
-			UpdateFilterStatistics(*condition);
-		}
-	}
-	// the max cardinality of a filter is the cardinality of the input (i.e. no tuples get filtered)
-	return move(node_stats);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-FilterPropagateResult StatisticsPropagator::PropagateTableFilter(BaseStatistics &stats, TableFilter &filter) {
-	return filter.CheckStatistics(stats);
-}
-
-void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFilter &filter) {
-	// FIXME: update stats...
-	switch (filter.filter_type) {
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = (ConjunctionAndFilter &)filter;
-		for (auto &child_filter : conjunction_and.child_filters) {
-			UpdateFilterStatistics(input, *child_filter);
-		}
-		break;
-	}
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (ConstantFilter &)filter;
-		UpdateFilterStatistics(input, constant_filter.comparison_type, constant_filter.constant);
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet &get,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	if (get.function.cardinality) {
-		node_stats = get.function.cardinality(context, get.bind_data.get());
-	}
-	if (!get.function.statistics) {
-		// no column statistics to get
-		return move(node_stats);
-	}
-	for (idx_t i = 0; i < get.column_ids.size(); i++) {
-		auto stats = get.function.statistics(context, get.bind_data.get(), get.column_ids[i]);
-		if (stats) {
-			ColumnBinding binding(get.table_index, i);
-			statistics_map.insert(make_pair(binding, move(stats)));
-		}
-	}
-	// push table filters into the statistics
-	vector<idx_t> column_indexes;
-	column_indexes.reserve(get.table_filters.filters.size());
-	for (auto &kv : get.table_filters.filters) {
-		column_indexes.push_back(kv.first);
-	}
-
-	for (auto &table_filter_column : column_indexes) {
-		idx_t column_index;
-		for (column_index = 0; column_index < get.column_ids.size(); column_index++) {
-			if (get.column_ids[column_index] == table_filter_column) {
-				break;
-			}
-		}
-		D_ASSERT(column_index < get.column_ids.size());
-		D_ASSERT(get.column_ids[column_index] == table_filter_column);
-
-		// find the stats
-		ColumnBinding stats_binding(get.table_index, column_index);
-		auto entry = statistics_map.find(stats_binding);
-		if (entry == statistics_map.end()) {
-			// no stats for this entry
-			continue;
-		}
-		auto &stats = *entry->second;
-
-		// fetch the table filter
-		D_ASSERT(get.table_filters.filters.count(table_filter_column) > 0);
-		auto &filter = get.table_filters.filters[table_filter_column];
-		auto propagate_result = PropagateTableFilter(stats, *filter);
-		switch (propagate_result) {
-		case FilterPropagateResult::FILTER_ALWAYS_TRUE:
-			// filter is always true; it is useless to execute it
-			// erase this condition
-			get.table_filters.filters.erase(table_filter_column);
-			break;
-		case FilterPropagateResult::FILTER_FALSE_OR_NULL:
-		case FilterPropagateResult::FILTER_ALWAYS_FALSE:
-			// filter is always false; this entire filter should be replaced by an empty result block
-			ReplaceWithEmptyResult(*node_ptr);
-			return make_unique<NodeStatistics>(0, 0);
-		default:
-			// general case: filter can be true or false, update this columns' statistics
-			UpdateFilterStatistics(stats, *filter);
-			break;
-		}
-	}
-	return move(node_stats);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, unique_ptr<LogicalOperator> *node_ptr) {
-	for (idx_t i = 0; i < join.conditions.size(); i++) {
-		auto &condition = join.conditions[i];
-		auto stats_left = PropagateExpression(condition.left);
-		auto stats_right = PropagateExpression(condition.right);
-		if (stats_left && stats_right) {
-			if ((condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
-			     condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) &&
-			    stats_left->CanHaveNull() && stats_right->CanHaveNull()) {
-				// null values are equal in this join, and both sides can have null values
-				// nothing to do here
-				continue;
-			}
-			auto prune_result = PropagateComparison(*stats_left, *stats_right, condition.comparison);
-			// Add stats to logical_join for perfect hash join
-			join.join_stats.push_back(move(stats_left));
-			join.join_stats.push_back(move(stats_right));
-			switch (prune_result) {
-			case FilterPropagateResult::FILTER_FALSE_OR_NULL:
-			case FilterPropagateResult::FILTER_ALWAYS_FALSE:
-				// filter is always false or null, none of the join conditions matter
-				switch (join.join_type) {
-				case JoinType::SEMI:
-				case JoinType::INNER:
-					// semi or inner join on false; entire node can be pruned
-					ReplaceWithEmptyResult(*node_ptr);
-					return;
-				case JoinType::ANTI:
-					// anti join: replace entire join with LHS
-					*node_ptr = move(join.children[0]);
-					return;
-				case JoinType::LEFT:
-					// anti/left outer join: replace right side with empty node
-					ReplaceWithEmptyResult(join.children[1]);
-					return;
-				case JoinType::RIGHT:
-					// right outer join: replace left side with empty node
-					ReplaceWithEmptyResult(join.children[0]);
-					return;
-				default:
-					// other join types: can't do much meaningful with this information
-					// full outer join requires both sides anyway; we can skip the execution of the actual join, but eh
-					// mark/single join requires knowing if the rhs has null values or not
-					break;
-				}
-				break;
-			case FilterPropagateResult::FILTER_ALWAYS_TRUE:
-				// filter is always true
-				if (join.conditions.size() > 1) {
-					// there are multiple conditions: erase this condition
-					join.conditions.erase(join.conditions.begin() + i);
-					// remove the corresponding statistics
-					join.join_stats.clear();
-					i--;
-					continue;
-				} else {
-					// this is the only condition and it is always true: all conditions are true
-					switch (join.join_type) {
-					case JoinType::SEMI:
-						// semi join on true: replace entire join with LHS
-						*node_ptr = move(join.children[0]);
-						return;
-					case JoinType::INNER:
-					case JoinType::LEFT:
-					case JoinType::RIGHT:
-					case JoinType::OUTER: {
-						// inner/left/right/full outer join, replace with cross product
-						// since the condition is always true, left/right/outer join are equivalent to inner join here
-						auto cross_product = make_unique<LogicalCrossProduct>();
-						cross_product->children = move(join.children);
-						*node_ptr = move(cross_product);
-						return;
-					}
-					case JoinType::ANTI:
-						// anti join on true: empty result
-						ReplaceWithEmptyResult(*node_ptr);
-						return;
-					default:
-						// we don't handle mark/single join here yet
-						break;
-					}
-				}
-				break;
-			default:
-				break;
-			}
-		}
-		// after we have propagated, we can update the statistics on both sides
-		// note that it is fine to do this now, even if the same column is used again later
-		// e.g. if we have i=j AND i=k, and the stats for j and k are disjoint, we know there are no results
-		// so if we have e.g. i: [0, 100], j: [0, 25], k: [75, 100]
-		// we can set i: [0, 25] after the first comparison, and statically determine that the second comparison is fals
-
-		// note that we can't update statistics the same for all join types
-		// mark and single joins don't filter any tuples -> so there is no propagation possible
-		// anti joins have inverse statistics propagation
-		// (i.e. if we have an anti join on i: [0, 100] and j: [0, 25], the resulting stats are i:[25,100])
-		// for now we don't handle anti joins
-		if (condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
-		    condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			// skip update when null values are equal (for now?)
-			continue;
-		}
-		switch (join.join_type) {
-		case JoinType::INNER:
-		case JoinType::SEMI: {
-			UpdateFilterStatistics(*condition.left, *condition.right, condition.comparison);
-			auto stats_left = PropagateExpression(condition.left);
-			auto stats_right = PropagateExpression(condition.right);
-			// Update join_stats when is already part of the join
-			if (join.join_stats.size() == 2) {
-				join.join_stats[0] = move(stats_left);
-				join.join_stats[1] = move(stats_right);
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-}
-
-void StatisticsPropagator::PropagateStatistics(LogicalAnyJoin &join, unique_ptr<LogicalOperator> *node_ptr) {
-	// propagate the expression into the join condition
-	PropagateExpression(join.condition);
-}
-
-void StatisticsPropagator::MultiplyCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats) {
-	if (!stats->has_estimated_cardinality || !new_stats.has_estimated_cardinality || !stats->has_max_cardinality ||
-	    !new_stats.has_max_cardinality) {
-		stats = nullptr;
-		return;
-	}
-	stats->estimated_cardinality = MaxValue<idx_t>(stats->estimated_cardinality, new_stats.estimated_cardinality);
-	auto new_max = Hugeint::Multiply(stats->max_cardinality, new_stats.max_cardinality);
-	if (new_max < NumericLimits<int64_t>::Maximum()) {
-		int64_t result;
-		if (!Hugeint::TryCast<int64_t>(new_max, result)) {
-			throw InternalException("Overflow in cast in statistics propagation");
-		}
-		D_ASSERT(result >= 0);
-		stats->max_cardinality = idx_t(result);
-	} else {
-		stats = nullptr;
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin &join,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// first propagate through the children of the join
-	node_stats = PropagateStatistics(join.children[0]);
-	for (idx_t child_idx = 1; child_idx < join.children.size(); child_idx++) {
-		auto child_stats = PropagateStatistics(join.children[child_idx]);
-		if (!child_stats) {
-			node_stats = nullptr;
-		} else if (node_stats) {
-			MultiplyCardinalities(node_stats, *child_stats);
-		}
-	}
-
-	auto join_type = join.join_type;
-	// depending on the join type, we might need to alter the statistics
-	// LEFT, FULL, RIGHT OUTER and SINGLE joins can introduce null values
-	// this requires us to alter the statistics after this point in the query plan
-	bool adds_null_on_left = IsRightOuterJoin(join_type);
-	bool adds_null_on_right = IsLeftOuterJoin(join_type) || join_type == JoinType::SINGLE;
-
-	vector<ColumnBinding> left_bindings, right_bindings;
-	if (adds_null_on_left) {
-		left_bindings = join.children[0]->GetColumnBindings();
-	}
-	if (adds_null_on_right) {
-		right_bindings = join.children[1]->GetColumnBindings();
-	}
-
-	// then propagate into the join conditions
-	switch (join.type) {
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		PropagateStatistics((LogicalComparisonJoin &)join, node_ptr);
-		break;
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		PropagateStatistics((LogicalAnyJoin &)join, node_ptr);
-		break;
-	default:
-		break;
-	}
-
-	if (adds_null_on_right) {
-		// left or full outer join: set IsNull() to true for all rhs statistics
-		for (auto &binding : right_bindings) {
-			auto stats = statistics_map.find(binding);
-			if (stats != statistics_map.end()) {
-				stats->second->validity_stats = make_unique<ValidityStatistics>(true);
-			}
-		}
-	}
-	if (adds_null_on_left) {
-		// right or full outer join: set IsNull() to true for all lhs statistics
-		for (auto &binding : left_bindings) {
-			auto stats = statistics_map.find(binding);
-			if (stats != statistics_map.end()) {
-				stats->second->validity_stats = make_unique<ValidityStatistics>(true);
-			}
-		}
-	}
-	return move(node_stats);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalLimit &limit,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// propagate statistics in the child node
-	PropagateStatistics(limit.children[0]);
-	// return the node stats, with as expected cardinality the amount specified in the limit
-	return make_unique<NodeStatistics>(limit.limit_val, limit.limit_val);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalOrder &order,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// first propagate to the child
-	node_stats = PropagateStatistics(order.children[0]);
-
-	// then propagate to each of the order expressions
-	for (auto &bound_order : order.orders) {
-		PropagateAndCompress(bound_order.expression, bound_order.stats);
-	}
-	return move(node_stats);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalProjection &proj,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// first propagate to the child
-	node_stats = PropagateStatistics(proj.children[0]);
-	if (proj.children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-		ReplaceWithEmptyResult(*node_ptr);
-		return move(node_stats);
-	}
-
-	// then propagate to each of the expressions
-	for (idx_t i = 0; i < proj.expressions.size(); i++) {
-		auto stats = PropagateExpression(proj.expressions[i]);
-		if (stats) {
-			ColumnBinding binding(proj.table_index, i);
-			statistics_map.insert(make_pair(binding, move(stats)));
-		}
-	}
-	return move(node_stats);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void StatisticsPropagator::AddCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats) {
-	if (!stats->has_estimated_cardinality || !new_stats.has_estimated_cardinality || !stats->has_max_cardinality ||
-	    !new_stats.has_max_cardinality) {
-		stats = nullptr;
-		return;
-	}
-	stats->estimated_cardinality += new_stats.estimated_cardinality;
-	auto new_max = Hugeint::Add(stats->max_cardinality, new_stats.max_cardinality);
-	if (new_max < NumericLimits<int64_t>::Maximum()) {
-		int64_t result;
-		if (!Hugeint::TryCast<int64_t>(new_max, result)) {
-			throw InternalException("Overflow in cast in statistics propagation");
-		}
-		D_ASSERT(result >= 0);
-		stats->max_cardinality = idx_t(result);
-	} else {
-		stats = nullptr;
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalSetOperation &setop,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// first propagate statistics in the child nodes
-	auto left_stats = PropagateStatistics(setop.children[0]);
-	auto right_stats = PropagateStatistics(setop.children[1]);
-
-	// now fetch the column bindings on both sides
-	auto left_bindings = setop.children[0]->GetColumnBindings();
-	auto right_bindings = setop.children[1]->GetColumnBindings();
-
-	D_ASSERT(left_bindings.size() == right_bindings.size());
-	D_ASSERT(left_bindings.size() == setop.column_count);
-	for (idx_t i = 0; i < setop.column_count; i++) {
-		// for each column binding, we fetch the statistics from both the lhs and the rhs
-		auto left_entry = statistics_map.find(left_bindings[i]);
-		auto right_entry = statistics_map.find(right_bindings[i]);
-		if (left_entry == statistics_map.end() || right_entry == statistics_map.end()) {
-			// no statistics on one of the sides: can't propagate stats
-			continue;
-		}
-		unique_ptr<BaseStatistics> new_stats;
-		switch (setop.type) {
-		case LogicalOperatorType::LOGICAL_UNION:
-			// union: merge the stats of the LHS and RHS together
-			new_stats = left_entry->second->Copy();
-			new_stats->Merge(*right_entry->second);
-			break;
-		case LogicalOperatorType::LOGICAL_EXCEPT:
-			// except: use the stats of the LHS
-			new_stats = left_entry->second->Copy();
-			break;
-		case LogicalOperatorType::LOGICAL_INTERSECT:
-			// intersect: intersect the two stats
-			// FIXME: for now we just use the stats of the LHS, as this is correct
-			// however, the stats can be further refined to the minimal subset of the LHS and RHS
-			new_stats = left_entry->second->Copy();
-			break;
-		default:
-			throw InternalException("Unsupported setop type");
-		}
-		ColumnBinding binding(setop.table_index, i);
-		statistics_map[binding] = move(new_stats);
-	}
-	if (!left_stats || !right_stats) {
-		return nullptr;
-	}
-	if (setop.type == LogicalOperatorType::LOGICAL_UNION) {
-		AddCardinalities(left_stats, *right_stats);
-	}
-	return left_stats;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalWindow &window,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	// first propagate to the child
-	node_stats = PropagateStatistics(window.children[0]);
-
-	// then propagate to each of the order expressions
-	for (auto &window_expr : window.expressions) {
-		auto over_expr = reinterpret_cast<BoundWindowExpression *>(window_expr.get());
-		for (auto &expr : over_expr->partitions) {
-			over_expr->partitions_stats.push_back(PropagateExpression(expr));
-		}
-		for (auto &bound_order : over_expr->orders) {
-			bound_order.stats = PropagateExpression(bound_order.expression);
-		}
-	}
-	return move(node_stats);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-StatisticsPropagator::StatisticsPropagator(ClientContext &context) : context(context) {
-}
-
-void StatisticsPropagator::ReplaceWithEmptyResult(unique_ptr<LogicalOperator> &node) {
-	node = make_unique<LogicalEmptyResult>(move(node));
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateChildren(LogicalOperator &node,
-                                                                   unique_ptr<LogicalOperator> *node_ptr) {
-	for (idx_t child_idx = 0; child_idx < node.children.size(); child_idx++) {
-		PropagateStatistics(node.children[child_idx]);
-	}
-	return nullptr;
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalOperator &node,
-                                                                     unique_ptr<LogicalOperator> *node_ptr) {
-	switch (node.type) {
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return PropagateStatistics((LogicalAggregate &)node, node_ptr);
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return PropagateStatistics((LogicalCrossProduct &)node, node_ptr);
-	case LogicalOperatorType::LOGICAL_FILTER:
-		return PropagateStatistics((LogicalFilter &)node, node_ptr);
-	case LogicalOperatorType::LOGICAL_GET:
-		return PropagateStatistics((LogicalGet &)node, node_ptr);
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return PropagateStatistics((LogicalProjection &)node, node_ptr);
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-	case LogicalOperatorType::LOGICAL_JOIN:
-		return PropagateStatistics((LogicalJoin &)node, node_ptr);
-	case LogicalOperatorType::LOGICAL_UNION:
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		return PropagateStatistics((LogicalSetOperation &)node, node_ptr);
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		return PropagateStatistics((LogicalOrder &)node, node_ptr);
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		return PropagateStatistics((LogicalWindow &)node, node_ptr);
-	default:
-		return PropagateChildren(node, node_ptr);
-	}
-}
-
-unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(unique_ptr<LogicalOperator> &node_ptr) {
-	return PropagateStatistics(*node_ptr, &node_ptr);
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(Expression &expr,
-                                                                     unique_ptr<Expression> *expr_ptr) {
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_AGGREGATE:
-		return PropagateExpression((BoundAggregateExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_BETWEEN:
-		return PropagateExpression((BoundBetweenExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_CASE:
-		return PropagateExpression((BoundCaseExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_CONJUNCTION:
-		return PropagateExpression((BoundConjunctionExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_FUNCTION:
-		return PropagateExpression((BoundFunctionExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_CAST:
-		return PropagateExpression((BoundCastExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_COMPARISON:
-		return PropagateExpression((BoundComparisonExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_CONSTANT:
-		return PropagateExpression((BoundConstantExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_COLUMN_REF:
-		return PropagateExpression((BoundColumnRefExpression &)expr, expr_ptr);
-	case ExpressionClass::BOUND_OPERATOR:
-		return PropagateExpression((BoundOperatorExpression &)expr, expr_ptr);
-	default:
-		break;
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &child) { PropagateExpression(child); });
-	return nullptr;
-}
-
-unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(unique_ptr<Expression> &expr) {
-	auto stats = PropagateExpression(*expr, &expr);
-	if (ClientConfig::GetConfig(context).query_verification_enabled && stats) {
-		expr->verification_stats = stats->Copy();
-	}
-	return stats;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> TopN::Optimize(unique_ptr<LogicalOperator> op) {
-	if (op->type == LogicalOperatorType::LOGICAL_LIMIT &&
-	    op->children[0]->type == LogicalOperatorType::LOGICAL_ORDER_BY) {
-		auto &limit = (LogicalLimit &)*op;
-		auto &order_by = (LogicalOrder &)*(op->children[0]);
-
-		// This optimization doesn't apply when OFFSET is present without LIMIT
-		// Or if offset is not constant
-		if (limit.limit_val != NumericLimits<int64_t>::Maximum() || limit.offset) {
-			auto topn = make_unique<LogicalTopN>(move(order_by.orders), limit.limit_val, limit.offset_val);
-			topn->AddChild(move(order_by.children[0]));
-			op = move(topn);
-		}
-	} else {
-		for (auto &child : op->children) {
-			child = Optimize(move(child));
-		}
-	}
-	return op;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-Event::Event(Executor &executor_p)
-    : executor(executor_p), finished_tasks(0), total_tasks(0), finished_dependencies(0), total_dependencies(0),
-      finished(false) {
-}
-
-void Event::CompleteDependency() {
-	idx_t current_finished = ++finished_dependencies;
-	D_ASSERT(current_finished <= total_dependencies);
-	if (current_finished == total_dependencies) {
-		// all dependencies have been completed: schedule the event
-		D_ASSERT(total_tasks == 0);
-		Schedule();
-		if (total_tasks == 0) {
-			Finish();
-		}
-	}
-}
-
-void Event::Finish() {
-	D_ASSERT(!finished);
-	FinishEvent();
-	finished = true;
-	// finished processing the pipeline, now we can schedule pipelines that depend on this pipeline
-	for (auto &parent_entry : parents) {
-		auto parent = parent_entry.lock();
-		if (!parent) { // LCOV_EXCL_START
-			continue;
-		} // LCOV_EXCL_STOP
-		// mark a dependency as completed for each of the parents
-		parent->CompleteDependency();
-	}
-	FinalizeFinish();
-}
-
-void Event::AddDependency(Event &event) {
-	total_dependencies++;
-	event.parents.push_back(weak_ptr<Event>(shared_from_this()));
-}
-
-void Event::FinishTask() {
-	D_ASSERT(finished_tasks.load() < total_tasks.load());
-	idx_t current_tasks = total_tasks;
-	idx_t current_finished = ++finished_tasks;
-	D_ASSERT(current_finished <= current_tasks);
-	if (current_finished == current_tasks) {
-		Finish();
-	}
-}
-
-void Event::InsertEvent(shared_ptr<Event> replacement_event) {
-	replacement_event->parents = move(parents);
-	replacement_event->AddDependency(*this);
-	executor.AddEvent(move(replacement_event));
-}
-
-void Event::SetTasks(vector<unique_ptr<Task>> tasks) {
-	auto &ts = TaskScheduler::GetScheduler(executor.context);
-	D_ASSERT(total_tasks == 0);
-	D_ASSERT(!tasks.empty());
-	this->total_tasks = tasks.size();
-	for (auto &task : tasks) {
-		ts.ScheduleTask(executor.GetToken(), move(task));
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-Executor::Executor(ClientContext &context) : context(context) {
-}
-
-Executor::~Executor() {
-}
-
-Executor &Executor::Get(ClientContext &context) {
-	return context.GetExecutor();
-}
-
-void Executor::AddEvent(shared_ptr<Event> event) {
-	lock_guard<mutex> elock(executor_lock);
-	events.push_back(move(event));
-}
-
-struct PipelineEventStack {
-	Event *pipeline_event;
-	Event *pipeline_finish_event;
-	Event *pipeline_complete_event;
-};
-
-Pipeline *Executor::ScheduleUnionPipeline(const shared_ptr<Pipeline> &pipeline, const Pipeline *parent,
-                                          event_map_t &event_map, vector<shared_ptr<Event>> &events) {
-	pipeline->Ready();
-
-	D_ASSERT(pipeline);
-	auto pipeline_event = make_shared<PipelineEvent>(pipeline);
-
-	auto parent_stack_entry = event_map.find(parent);
-	D_ASSERT(parent_stack_entry != event_map.end());
-
-	auto &parent_stack = parent_stack_entry->second;
-
-	PipelineEventStack stack;
-	stack.pipeline_event = pipeline_event.get();
-	stack.pipeline_finish_event = parent_stack.pipeline_finish_event;
-	stack.pipeline_complete_event = parent_stack.pipeline_complete_event;
-
-	stack.pipeline_event->AddDependency(*parent_stack.pipeline_event);
-	parent_stack.pipeline_finish_event->AddDependency(*pipeline_event);
-
-	events.push_back(move(pipeline_event));
-	event_map.insert(make_pair(pipeline.get(), stack));
-
-	auto parent_pipeline = pipeline.get();
-
-	auto union_entry = union_pipelines.find(pipeline.get());
-	if (union_entry != union_pipelines.end()) {
-		for (auto &entry : union_entry->second) {
-			parent_pipeline = ScheduleUnionPipeline(entry, parent_pipeline, event_map, events);
-		}
-	}
-
-	return parent_pipeline;
-}
-
-void Executor::ScheduleChildPipeline(Pipeline *parent, const shared_ptr<Pipeline> &pipeline, event_map_t &event_map,
-                                     vector<shared_ptr<Event>> &events) {
-	pipeline->Ready();
-
-	auto child_ptr = pipeline.get();
-	auto dependencies = child_dependencies.find(child_ptr);
-	D_ASSERT(union_pipelines.find(child_ptr) == union_pipelines.end());
-	D_ASSERT(dependencies != child_dependencies.end());
-	// create the pipeline event and the event stack
-	auto pipeline_event = make_shared<PipelineEvent>(pipeline);
-
-	auto parent_entry = event_map.find(parent);
-	PipelineEventStack stack;
-	stack.pipeline_event = pipeline_event.get();
-	stack.pipeline_finish_event = parent_entry->second.pipeline_finish_event;
-	stack.pipeline_complete_event = parent_entry->second.pipeline_complete_event;
-
-	// set up the dependencies for this child pipeline
-	unordered_set<Event *> finish_events;
-	for (auto &dep : dependencies->second) {
-		auto dep_entry = event_map.find(dep);
-		D_ASSERT(dep_entry != event_map.end());
-		D_ASSERT(dep_entry->second.pipeline_event);
-		D_ASSERT(dep_entry->second.pipeline_finish_event);
-
-		auto finish_event = dep_entry->second.pipeline_finish_event;
-		stack.pipeline_event->AddDependency(*dep_entry->second.pipeline_event);
-		if (finish_events.find(finish_event) == finish_events.end()) {
-			finish_event->AddDependency(*stack.pipeline_event);
-			finish_events.insert(finish_event);
-		}
-	}
-
-	events.push_back(move(pipeline_event));
-	event_map.insert(make_pair(child_ptr, stack));
-}
-
-void Executor::SchedulePipeline(const shared_ptr<Pipeline> &pipeline, event_map_t &event_map,
-                                vector<shared_ptr<Event>> &events, bool complete_pipeline) {
-	D_ASSERT(pipeline);
-
-	pipeline->Ready();
-
-	auto pipeline_event = make_shared<PipelineEvent>(pipeline);
-	auto pipeline_finish_event = make_shared<PipelineFinishEvent>(pipeline);
-	auto pipeline_complete_event = make_shared<PipelineCompleteEvent>(pipeline->executor, complete_pipeline);
-
-	PipelineEventStack stack;
-	stack.pipeline_event = pipeline_event.get();
-	stack.pipeline_finish_event = pipeline_finish_event.get();
-	stack.pipeline_complete_event = pipeline_complete_event.get();
-
-	pipeline_finish_event->AddDependency(*pipeline_event);
-	pipeline_complete_event->AddDependency(*pipeline_finish_event);
-
-	events.push_back(move(pipeline_event));
-	events.push_back(move(pipeline_finish_event));
-	events.push_back(move(pipeline_complete_event));
-
-	event_map.insert(make_pair(pipeline.get(), stack));
-
-	auto union_entry = union_pipelines.find(pipeline.get());
-	if (union_entry != union_pipelines.end()) {
-		auto parent_pipeline = pipeline.get();
-		for (auto &entry : union_entry->second) {
-			parent_pipeline = ScheduleUnionPipeline(entry, parent_pipeline, event_map, events);
-		}
-	}
-}
-
-void Executor::ScheduleEventsInternal(const vector<shared_ptr<Pipeline>> &pipelines,
-                                      unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> &child_pipelines,
-                                      vector<shared_ptr<Event>> &events, bool main_schedule) {
-	D_ASSERT(events.empty());
-	// create all the required pipeline events
-	event_map_t event_map;
-	for (auto &pipeline : pipelines) {
-		SchedulePipeline(pipeline, event_map, events, main_schedule);
-	}
-	// schedule child pipelines
-	for (auto &entry : child_pipelines) {
-		// iterate in reverse order
-		// since child entries are added from top to bottom
-		// dependencies are in reverse order (bottom to top)
-		for (idx_t i = entry.second.size(); i > 0; i--) {
-			auto &child_entry = entry.second[i - 1];
-			ScheduleChildPipeline(entry.first, child_entry, event_map, events);
-		}
-	}
-	// set up the dependencies between pipeline events
-	for (auto &entry : event_map) {
-		auto pipeline = entry.first;
-		for (auto &dependency : pipeline->dependencies) {
-			auto dep = dependency.lock();
-			D_ASSERT(dep);
-			auto event_map_entry = event_map.find(dep.get());
-			D_ASSERT(event_map_entry != event_map.end());
-			auto &dep_entry = event_map_entry->second;
-			D_ASSERT(dep_entry.pipeline_complete_event);
-			entry.second.pipeline_event->AddDependency(*dep_entry.pipeline_complete_event);
-		}
-	}
-	// schedule the pipelines that do not have dependencies
-	for (auto &event : events) {
-		if (!event->HasDependencies()) {
-			event->Schedule();
-		}
-	}
-}
-
-void Executor::ScheduleEvents() {
-	ScheduleEventsInternal(pipelines, child_pipelines, events);
-}
-
-void Executor::ReschedulePipelines(const vector<shared_ptr<Pipeline>> &pipelines, vector<shared_ptr<Event>> &events) {
-	unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> child_pipelines;
-	ScheduleEventsInternal(pipelines, child_pipelines, events, false);
-}
-
-void Executor::ExtractPipelines(shared_ptr<Pipeline> &pipeline, vector<shared_ptr<Pipeline>> &result) {
-	pipeline->Ready();
-
-	auto pipeline_ptr = pipeline.get();
-	result.push_back(move(pipeline));
-	auto union_entry = union_pipelines.find(pipeline_ptr);
-	if (union_entry != union_pipelines.end()) {
-		auto &union_pipeline_list = union_entry->second;
-		for (auto &pipeline : union_pipeline_list) {
-			ExtractPipelines(pipeline, result);
-		}
-		union_pipelines.erase(pipeline_ptr);
-	}
-	auto child_entry = child_pipelines.find(pipeline_ptr);
-	if (child_entry != child_pipelines.end()) {
-		for (auto &entry : child_entry->second) {
-			ExtractPipelines(entry, result);
-		}
-		child_pipelines.erase(pipeline_ptr);
-	}
-}
-
-bool Executor::NextExecutor() {
-	if (root_pipeline_idx >= root_pipelines.size()) {
-		return false;
-	}
-	root_executor = make_unique<PipelineExecutor>(context, *root_pipelines[root_pipeline_idx]);
-	root_pipeline_idx++;
-	return true;
-}
-
-void Executor::VerifyPipeline(Pipeline &pipeline) {
-	D_ASSERT(!pipeline.ToString().empty());
-	auto operators = pipeline.GetOperators();
-	for (auto &other_pipeline : pipelines) {
-		auto other_operators = other_pipeline->GetOperators();
-		for (idx_t op_idx = 0; op_idx < operators.size(); op_idx++) {
-			for (idx_t other_idx = 0; other_idx < other_operators.size(); other_idx++) {
-				auto &left = *operators[op_idx];
-				auto &right = *other_operators[other_idx];
-				if (left.Equals(right)) {
-					D_ASSERT(right.Equals(left));
-				} else {
-					D_ASSERT(!right.Equals(left));
-				}
-			}
-		}
-	}
-}
-
-void Executor::VerifyPipelines() {
-#ifdef DEBUG
-	for (auto &pipeline : pipelines) {
-		VerifyPipeline(*pipeline);
-	}
-	for (auto &pipeline : root_pipelines) {
-		VerifyPipeline(*pipeline);
-	}
-#endif
-}
-
-void Executor::Initialize(unique_ptr<PhysicalOperator> physical_plan) {
-	Reset();
-	owned_plan = move(physical_plan);
-	InitializeInternal(owned_plan.get());
-}
-
-void Executor::Initialize(PhysicalOperator *plan) {
-	Reset();
-	InitializeInternal(plan);
-}
-
-void Executor::InitializeInternal(PhysicalOperator *plan) {
-
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-	{
-		lock_guard<mutex> elock(executor_lock);
-		physical_plan = plan;
-
-		this->profiler = ClientData::Get(context).profiler;
-		profiler->Initialize(physical_plan);
-		this->producer = scheduler.CreateProducer();
-
-		auto root_pipeline = make_shared<Pipeline>(*this);
-		root_pipeline->sink = nullptr;
-
-		PipelineBuildState state;
-		physical_plan->BuildPipelines(*this, *root_pipeline, state);
-
-		this->total_pipelines = pipelines.size();
-
-		root_pipeline_idx = 0;
-		ExtractPipelines(root_pipeline, root_pipelines);
-
-		VerifyPipelines();
-
-		ScheduleEvents();
-	}
-}
-
-void Executor::CancelTasks() {
-	task.reset();
-	// we do this by creating weak pointers to all pipelines
-	// then clearing our references to the pipelines
-	// and waiting until all pipelines have been destroyed
-	vector<weak_ptr<Pipeline>> weak_references;
-	{
-		lock_guard<mutex> elock(executor_lock);
-		weak_references.reserve(pipelines.size());
-		for (auto &pipeline : pipelines) {
-			weak_references.push_back(weak_ptr<Pipeline>(pipeline));
-		}
-		for (auto &kv : union_pipelines) {
-			for (auto &pipeline : kv.second) {
-				weak_references.push_back(weak_ptr<Pipeline>(pipeline));
-			}
-		}
-		for (auto &kv : child_pipelines) {
-			for (auto &pipeline : kv.second) {
-				weak_references.push_back(weak_ptr<Pipeline>(pipeline));
-			}
-		}
-		pipelines.clear();
-		union_pipelines.clear();
-		child_pipelines.clear();
-		events.clear();
-	}
-	WorkOnTasks();
-	for (auto &weak_ref : weak_references) {
-		while (true) {
-			auto weak = weak_ref.lock();
-			if (!weak) {
-				break;
-			}
-		}
-	}
-}
-
-void Executor::WorkOnTasks() {
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-
-	unique_ptr<Task> task;
-	while (scheduler.GetTaskFromProducer(*producer, task)) {
-		task->Execute(TaskExecutionMode::PROCESS_ALL);
-		task.reset();
-	}
-}
-
-PendingExecutionResult Executor::ExecuteTask() {
-	if (execution_result != PendingExecutionResult::RESULT_NOT_READY) {
-		return execution_result;
-	}
-	// check if there are any incomplete pipelines
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-	while (completed_pipelines < total_pipelines) {
-		// there are! if we don't already have a task, fetch one
-		if (!task) {
-			scheduler.GetTaskFromProducer(*producer, task);
-		}
-		if (task) {
-			// if we have a task, partially process it
-			auto result = task->Execute(TaskExecutionMode::PROCESS_PARTIAL);
-			if (result != TaskExecutionResult::TASK_NOT_FINISHED) {
-				// if the task is finished, clean it up
-				task.reset();
-			}
-		}
-		if (!HasError()) {
-			// we (partially) processed a task and no exceptions were thrown
-			// give back control to the caller
-			return PendingExecutionResult::RESULT_NOT_READY;
-		}
-		execution_result = PendingExecutionResult::EXECUTION_ERROR;
-
-		// an exception has occurred executing one of the pipelines
-		// we need to cancel all tasks associated with this executor
-		CancelTasks();
-		ThrowException();
-	}
-	D_ASSERT(!task);
-
-	lock_guard<mutex> elock(executor_lock);
-	pipelines.clear();
-	NextExecutor();
-	if (!exceptions.empty()) { // LCOV_EXCL_START
-		// an exception has occurred executing one of the pipelines
-		execution_result = PendingExecutionResult::EXECUTION_ERROR;
-		ThrowExceptionInternal();
-	} // LCOV_EXCL_STOP
-	execution_result = PendingExecutionResult::RESULT_READY;
-	return execution_result;
-}
-
-void Executor::Reset() {
-	lock_guard<mutex> elock(executor_lock);
-	physical_plan = nullptr;
-	owned_plan.reset();
-	root_executor.reset();
-	root_pipelines.clear();
-	root_pipeline_idx = 0;
-	completed_pipelines = 0;
-	total_pipelines = 0;
-	exceptions.clear();
-	pipelines.clear();
-	events.clear();
-	union_pipelines.clear();
-	child_pipelines.clear();
-	child_dependencies.clear();
-	execution_result = PendingExecutionResult::RESULT_NOT_READY;
-}
-
-void Executor::AddChildPipeline(Pipeline *current) {
-	D_ASSERT(!current->operators.empty());
-	// found another operator that is a source
-	// schedule a child pipeline
-	auto child_pipeline = make_shared<Pipeline>(*this);
-	auto child_pipeline_ptr = child_pipeline.get();
-	child_pipeline->sink = current->sink;
-	child_pipeline->operators = current->operators;
-	child_pipeline->source = current->operators.back();
-	D_ASSERT(child_pipeline->source->IsSource());
-	child_pipeline->operators.pop_back();
-
-	vector<Pipeline *> dependencies;
-	dependencies.push_back(current);
-	auto child_entry = child_pipelines.find(current);
-	if (child_entry != child_pipelines.end()) {
-		for (auto &current_child : child_entry->second) {
-			D_ASSERT(child_dependencies.find(current_child.get()) != child_dependencies.end());
-			child_dependencies[current_child.get()].push_back(child_pipeline_ptr);
-		}
-	}
-	D_ASSERT(child_dependencies.find(child_pipeline_ptr) == child_dependencies.end());
-	child_dependencies.insert(make_pair(child_pipeline_ptr, move(dependencies)));
-	child_pipelines[current].push_back(move(child_pipeline));
-}
-
-vector<LogicalType> Executor::GetTypes() {
-	D_ASSERT(physical_plan);
-	return physical_plan->GetTypes();
-}
-
-void Executor::PushError(ExceptionType type, const string &exception) {
-	lock_guard<mutex> elock(executor_lock);
-	// interrupt execution of any other pipelines that belong to this executor
-	context.interrupted = true;
-	// push the exception onto the stack
-	exceptions.emplace_back(type, exception);
-}
-
-bool Executor::HasError() {
-	lock_guard<mutex> elock(executor_lock);
-	return !exceptions.empty();
-}
-
-void Executor::ThrowException() {
-	lock_guard<mutex> elock(executor_lock);
-	ThrowExceptionInternal();
-}
-
-void Executor::ThrowExceptionInternal() { // LCOV_EXCL_START
-	D_ASSERT(!exceptions.empty());
-	auto &entry = exceptions[0];
-	switch (entry.first) {
-	case ExceptionType::TRANSACTION:
-		throw TransactionException(entry.second);
-	case ExceptionType::CATALOG:
-		throw CatalogException(entry.second);
-	case ExceptionType::PARSER:
-		throw ParserException(entry.second);
-	case ExceptionType::BINDER:
-		throw BinderException(entry.second);
-	case ExceptionType::INTERRUPT:
-		throw InterruptException();
-	case ExceptionType::FATAL:
-		throw FatalException(entry.second);
-	case ExceptionType::INTERNAL:
-		throw InternalException(entry.second);
-	case ExceptionType::IO:
-		throw IOException(entry.second);
-	case ExceptionType::CONSTRAINT:
-		throw ConstraintException(entry.second);
-	case ExceptionType::CONVERSION:
-		throw ConversionException(entry.second);
-	default:
-		throw Exception(entry.second);
-	}
-} // LCOV_EXCL_STOP
-
-void Executor::Flush(ThreadContext &tcontext) {
-	profiler->Flush(tcontext.profiler);
-}
-
-bool Executor::GetPipelinesProgress(double &current_progress) { // LCOV_EXCL_START
-	lock_guard<mutex> elock(executor_lock);
-
-	vector<double> progress;
-	vector<idx_t> cardinality;
-	idx_t total_cardinality = 0;
-	for (auto &pipeline : pipelines) {
-		double child_percentage;
-		idx_t child_cardinality;
-		if (!pipeline->GetProgress(child_percentage, child_cardinality)) {
-			return false;
-		}
-		progress.push_back(child_percentage);
-		cardinality.push_back(child_cardinality);
-		total_cardinality += child_cardinality;
-	}
-	current_progress = 0;
-	for (size_t i = 0; i < progress.size(); i++) {
-		current_progress += progress[i] * double(cardinality[i]) / double(total_cardinality);
-	}
-	return true;
-} // LCOV_EXCL_STOP
-
-bool Executor::HasResultCollector() {
-	return physical_plan->type == PhysicalOperatorType::RESULT_COLLECTOR;
-}
-
-unique_ptr<QueryResult> Executor::GetResult() {
-	D_ASSERT(HasResultCollector());
-	auto &result_collector = (PhysicalResultCollector &)*physical_plan;
-	D_ASSERT(result_collector.sink_state);
-	return result_collector.GetResult(*result_collector.sink_state);
-}
-
-unique_ptr<DataChunk> Executor::FetchChunk() {
-	D_ASSERT(physical_plan);
-
-	auto chunk = make_unique<DataChunk>();
-	root_executor->InitializeChunk(*chunk);
-	while (true) {
-		root_executor->ExecutePull(*chunk);
-		if (chunk->size() == 0) {
-			root_executor->PullFinalize();
-			if (NextExecutor()) {
-				continue;
-			}
-			break;
-		} else {
-			break;
-		}
-	}
-	return chunk;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-ExecutorTask::ExecutorTask(Executor &executor_p) : executor(executor_p) {
-}
-
-ExecutorTask::ExecutorTask(ClientContext &context) : ExecutorTask(Executor::Get(context)) {
-}
-
-ExecutorTask::~ExecutorTask() {
-}
-
-TaskExecutionResult ExecutorTask::Execute(TaskExecutionMode mode) {
-	try {
-		return ExecuteTask(mode);
-	} catch (Exception &ex) {
-		executor.PushError(ex.type, ex.what());
-	} catch (std::exception &ex) {
-		executor.PushError(ExceptionType::UNKNOWN_TYPE, ex.what());
-	} catch (...) { // LCOV_EXCL_START
-		executor.PushError(ExceptionType::UNKNOWN_TYPE, "Unknown exception in Finalize!");
-	} // LCOV_EXCL_STOP
-	return TaskExecutionResult::TASK_ERROR;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class PipelineTask : public ExecutorTask {
-	static constexpr const idx_t PARTIAL_CHUNK_COUNT = 50;
-
-public:
-	explicit PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
-	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(move(event_p)) {
-	}
-
-	Pipeline &pipeline;
-	shared_ptr<Event> event;
-	unique_ptr<PipelineExecutor> pipeline_executor;
-
-public:
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		if (!pipeline_executor) {
-			pipeline_executor = make_unique<PipelineExecutor>(pipeline.GetClientContext(), pipeline);
-		}
-		if (mode == TaskExecutionMode::PROCESS_PARTIAL) {
-			bool finished = pipeline_executor->Execute(PARTIAL_CHUNK_COUNT);
-			if (!finished) {
-				return TaskExecutionResult::TASK_NOT_FINISHED;
-			}
-		} else {
-			pipeline_executor->Execute();
-		}
-		event->FinishTask();
-		pipeline_executor.reset();
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-};
-
-Pipeline::Pipeline(Executor &executor_p) : executor(executor_p), ready(false), source(nullptr), sink(nullptr) {
-}
-
-ClientContext &Pipeline::GetClientContext() {
-	return executor.context;
-}
-
-bool Pipeline::GetProgress(double &current_percentage, idx_t &source_cardinality) {
-	D_ASSERT(source);
-
-	auto &client = executor.context;
-	current_percentage = source->GetProgress(client, *source_state);
-	source_cardinality = source->estimated_cardinality;
-	return current_percentage >= 0;
-}
-
-void Pipeline::ScheduleSequentialTask(shared_ptr<Event> &event) {
-	vector<unique_ptr<Task>> tasks;
-	tasks.push_back(make_unique<PipelineTask>(*this, event));
-	event->SetTasks(move(tasks));
-}
-
-bool Pipeline::ScheduleParallel(shared_ptr<Event> &event) {
-	// check if the sink, source and all intermediate operators support parallelism
-	if (!sink->ParallelSink()) {
-		return false;
-	}
-	if (!source->ParallelSource()) {
-		return false;
-	}
-	for (auto &op : operators) {
-		if (!op->ParallelOperator()) {
-			return false;
-		}
-	}
-	if (sink->RequiresBatchIndex()) {
-		if (!source->SupportsBatchIndex()) {
-			throw InternalException(
-			    "Attempting to schedule a pipeline where the sink requires batch index but source does not support it");
-		}
-	}
-	idx_t max_threads = source_state->MaxThreads();
-	return LaunchScanTasks(event, max_threads);
-}
-
-bool Pipeline::IsOrderDependent() const {
-	auto &config = DBConfig::GetConfig(executor.context);
-	if (!config.preserve_insertion_order) {
-		return false;
-	}
-	if (sink && sink->IsOrderDependent()) {
-		return true;
-	}
-	if (source->IsOrderDependent()) {
-		return true;
-	}
-	for (auto &op : operators) {
-		if (op->IsOrderDependent()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-void Pipeline::Schedule(shared_ptr<Event> &event) {
-	D_ASSERT(ready);
-	D_ASSERT(sink);
-	if (!ScheduleParallel(event)) {
-		// could not parallelize this pipeline: push a sequential task instead
-		ScheduleSequentialTask(event);
-	}
-}
-
-bool Pipeline::LaunchScanTasks(shared_ptr<Event> &event, idx_t max_threads) {
-	// split the scan up into parts and schedule the parts
-	auto &scheduler = TaskScheduler::GetScheduler(executor.context);
-	idx_t active_threads = scheduler.NumberOfThreads();
-	if (max_threads > active_threads) {
-		max_threads = active_threads;
-	}
-	if (max_threads <= 1) {
-		// too small to parallelize
-		return false;
-	}
-
-	// launch a task for every thread
-	vector<unique_ptr<Task>> tasks;
-	for (idx_t i = 0; i < max_threads; i++) {
-		tasks.push_back(make_unique<PipelineTask>(*this, event));
-	}
-	event->SetTasks(move(tasks));
-	return true;
-}
-
-void Pipeline::Reset() {
-	if (sink && !sink->sink_state) {
-		sink->sink_state = sink->GetGlobalSinkState(GetClientContext());
-	}
-
-	for (auto &op : operators) {
-		if (op && !op->op_state) {
-			op->op_state = op->GetGlobalOperatorState(GetClientContext());
-		}
-	}
-
-	ResetSource();
-}
-
-void Pipeline::ResetSource() {
-	source_state = source->GetGlobalSourceState(GetClientContext());
-}
-
-void Pipeline::Ready() {
-	if (ready) {
-		return;
-	}
-	ready = true;
-	std::reverse(operators.begin(), operators.end());
-	Reset();
-}
-
-void Pipeline::Finalize(Event &event) {
-	D_ASSERT(ready);
-	try {
-		auto sink_state = sink->Finalize(*this, event, executor.context, *sink->sink_state);
-		sink->sink_state->state = sink_state;
-	} catch (Exception &ex) { // LCOV_EXCL_START
-		executor.PushError(ex.type, ex.what());
-	} catch (std::exception &ex) {
-		executor.PushError(ExceptionType::UNKNOWN_TYPE, ex.what());
-	} catch (...) {
-		executor.PushError(ExceptionType::UNKNOWN_TYPE, "Unknown exception in Finalize!");
-	} // LCOV_EXCL_STOP
-}
-
-void Pipeline::AddDependency(shared_ptr<Pipeline> &pipeline) {
-	D_ASSERT(pipeline);
-	dependencies.push_back(weak_ptr<Pipeline>(pipeline));
-	pipeline->parents.push_back(weak_ptr<Pipeline>(shared_from_this()));
-}
-
-string Pipeline::ToString() const {
-	TreeRenderer renderer;
-	return renderer.ToString(*this);
-}
-
-void Pipeline::Print() const {
-	Printer::Print(ToString());
-}
-
-vector<PhysicalOperator *> Pipeline::GetOperators() const {
-	vector<PhysicalOperator *> result;
-	D_ASSERT(source);
-	result.push_back(source);
-	result.insert(result.end(), operators.begin(), operators.end());
-	if (sink) {
-		result.push_back(sink);
-	}
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// Pipeline Build State
-//===--------------------------------------------------------------------===//
-void PipelineBuildState::SetPipelineSource(Pipeline &pipeline, PhysicalOperator *op) {
-	pipeline.source = op;
-}
-
-void PipelineBuildState::SetPipelineSink(Pipeline &pipeline, PhysicalOperator *op) {
-	pipeline.sink = op;
-	// set the base batch index of this pipeline based on how many other pipelines have this node as their sink
-	pipeline.base_batch_index = BATCH_INCREMENT * sink_pipeline_count[op];
-	// increment the number of nodes that have this pipeline as their sink
-	sink_pipeline_count[op]++;
-}
-
-void PipelineBuildState::AddPipelineOperator(Pipeline &pipeline, PhysicalOperator *op) {
-	pipeline.operators.push_back(op);
-}
-
-void PipelineBuildState::AddPipeline(Executor &executor, shared_ptr<Pipeline> pipeline) {
-	executor.pipelines.push_back(move(pipeline));
-}
-
-PhysicalOperator *PipelineBuildState::GetPipelineSource(Pipeline &pipeline) {
-	return pipeline.source;
-}
-
-PhysicalOperator *PipelineBuildState::GetPipelineSink(Pipeline &pipeline) {
-	return pipeline.sink;
-}
-
-void PipelineBuildState::SetPipelineOperators(Pipeline &pipeline, vector<PhysicalOperator *> operators) {
-	pipeline.operators = move(operators);
-}
-
-void PipelineBuildState::AddChildPipeline(Executor &executor, Pipeline &pipeline) {
-	executor.AddChildPipeline(&pipeline);
-}
-
-unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> &PipelineBuildState::GetUnionPipelines(Executor &executor) {
-	return executor.union_pipelines;
-}
-unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> &PipelineBuildState::GetChildPipelines(Executor &executor) {
-	return executor.child_pipelines;
-}
-unordered_map<Pipeline *, vector<Pipeline *>> &PipelineBuildState::GetChildDependencies(Executor &executor) {
-	return executor.child_dependencies;
-}
-
-vector<PhysicalOperator *> PipelineBuildState::GetPipelineOperators(Pipeline &pipeline) {
-	return pipeline.operators;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-PipelineCompleteEvent::PipelineCompleteEvent(Executor &executor, bool complete_pipeline_p)
-    : Event(executor), complete_pipeline(complete_pipeline_p) {
-}
-
-void PipelineCompleteEvent::Schedule() {
-}
-
-void PipelineCompleteEvent::FinalizeFinish() {
-	if (complete_pipeline) {
-		executor.CompletePipeline();
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-PipelineEvent::PipelineEvent(shared_ptr<Pipeline> pipeline_p)
-    : Event(pipeline_p->executor), pipeline(move(pipeline_p)) {
-}
-
-void PipelineEvent::Schedule() {
-	auto event = shared_from_this();
-	pipeline->Schedule(event);
-	D_ASSERT(total_tasks > 0);
-}
-
-void PipelineEvent::FinishEvent() {
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_p)
-    : pipeline(pipeline_p), thread(context_p), context(context_p, thread) {
-	D_ASSERT(pipeline.source_state);
-	local_source_state = pipeline.source->GetLocalSourceState(context, *pipeline.source_state);
-	if (pipeline.sink) {
-		local_sink_state = pipeline.sink->GetLocalSinkState(context);
-		requires_batch_index = pipeline.sink->RequiresBatchIndex() && pipeline.source->SupportsBatchIndex();
-	}
-	bool can_cache_in_pipeline = pipeline.sink && !pipeline.IsOrderDependent() && !requires_batch_index;
-	intermediate_chunks.reserve(pipeline.operators.size());
-	intermediate_states.reserve(pipeline.operators.size());
-	cached_chunks.resize(pipeline.operators.size());
-	for (idx_t i = 0; i < pipeline.operators.size(); i++) {
-		auto prev_operator = i == 0 ? pipeline.source : pipeline.operators[i - 1];
-		auto current_operator = pipeline.operators[i];
-		auto chunk = make_unique<DataChunk>();
-		chunk->Initialize(Allocator::Get(context.client), prev_operator->GetTypes());
-		intermediate_chunks.push_back(move(chunk));
-		intermediate_states.push_back(current_operator->GetOperatorState(context));
-		if (can_cache_in_pipeline && current_operator->RequiresCache()) {
-			auto &cache_types = current_operator->GetTypes();
-			bool can_cache = true;
-			for (auto &type : cache_types) {
-				if (!CanCacheType(type)) {
-					can_cache = false;
-					break;
-				}
-			}
-			if (!can_cache) {
-				continue;
-			}
-			cached_chunks[i] = make_unique<DataChunk>();
-			cached_chunks[i]->Initialize(Allocator::Get(context.client), current_operator->GetTypes());
-		}
-		if (current_operator->IsSink() && current_operator->sink_state->state == SinkFinalizeType::NO_OUTPUT_POSSIBLE) {
-			// one of the operators has already figured out no output is possible
-			// we can skip executing the pipeline
-			FinishProcessing();
-		}
-	}
-	InitializeChunk(final_chunk);
-}
-
-bool PipelineExecutor::Execute(idx_t max_chunks) {
-	D_ASSERT(pipeline.sink);
-	bool exhausted_source = false;
-	auto &source_chunk = pipeline.operators.empty() ? final_chunk : *intermediate_chunks[0];
-	for (idx_t i = 0; i < max_chunks; i++) {
-		if (IsFinished()) {
-			break;
-		}
-		source_chunk.Reset();
-		FetchFromSource(source_chunk);
-		if (source_chunk.size() == 0) {
-			exhausted_source = true;
-			break;
-		}
-		auto result = ExecutePushInternal(source_chunk);
-		if (result == OperatorResultType::FINISHED) {
-			D_ASSERT(IsFinished());
-			break;
-		}
-	}
-	if (!exhausted_source && !IsFinished()) {
-		return false;
-	}
-	PushFinalize();
-	return true;
-}
-
-void PipelineExecutor::Execute() {
-	Execute(NumericLimits<idx_t>::Maximum());
-}
-
-OperatorResultType PipelineExecutor::ExecutePush(DataChunk &input) { // LCOV_EXCL_START
-	return ExecutePushInternal(input);
-} // LCOV_EXCL_STOP
-
-void PipelineExecutor::FinishProcessing(int32_t operator_idx) {
-	finished_processing_idx = operator_idx < 0 ? NumericLimits<int32_t>::Maximum() : operator_idx;
-	in_process_operators = stack<idx_t>();
-}
-
-bool PipelineExecutor::IsFinished() {
-	return finished_processing_idx >= 0;
-}
-
-OperatorResultType PipelineExecutor::ExecutePushInternal(DataChunk &input, idx_t initial_idx) {
-	D_ASSERT(pipeline.sink);
-	if (input.size() == 0) { // LCOV_EXCL_START
-		return OperatorResultType::NEED_MORE_INPUT;
-	} // LCOV_EXCL_STOP
-	while (true) {
-		OperatorResultType result;
-		if (!pipeline.operators.empty()) {
-			final_chunk.Reset();
-			result = Execute(input, final_chunk, initial_idx);
-			if (result == OperatorResultType::FINISHED) {
-				return OperatorResultType::FINISHED;
-			}
-		} else {
-			result = OperatorResultType::NEED_MORE_INPUT;
-		}
-		auto &sink_chunk = pipeline.operators.empty() ? input : final_chunk;
-		if (sink_chunk.size() > 0) {
-			StartOperator(pipeline.sink);
-			D_ASSERT(pipeline.sink);
-			D_ASSERT(pipeline.sink->sink_state);
-			auto sink_result = pipeline.sink->Sink(context, *pipeline.sink->sink_state, *local_sink_state, sink_chunk);
-			EndOperator(pipeline.sink, nullptr);
-			if (sink_result == SinkResultType::FINISHED) {
-				FinishProcessing();
-				return OperatorResultType::FINISHED;
-			}
-		}
-		if (result == OperatorResultType::NEED_MORE_INPUT) {
-			return OperatorResultType::NEED_MORE_INPUT;
-		}
-	}
-}
-
-void PipelineExecutor::PushFinalize() {
-	if (finalized) {
-		throw InternalException("Calling PushFinalize on a pipeline that has been finalized already");
-	}
-	finalized = true;
-	// flush all caches
-	// note that even if an operator has finished, we might still need to flush caches AFTER that operator
-	// e.g. if we have SOURCE -> LIMIT -> CROSS_PRODUCT -> SINK, if the LIMIT reports no more rows will be passed on
-	// we still need to flush caches from the CROSS_PRODUCT
-	D_ASSERT(in_process_operators.empty());
-	idx_t start_idx = IsFinished() ? idx_t(finished_processing_idx) : 0;
-	for (idx_t i = start_idx; i < cached_chunks.size(); i++) {
-		if (cached_chunks[i] && cached_chunks[i]->size() > 0) {
-			ExecutePushInternal(*cached_chunks[i], i + 1);
-			cached_chunks[i].reset();
-		}
-	}
-	D_ASSERT(local_sink_state);
-	// run the combine for the sink
-	pipeline.sink->Combine(context, *pipeline.sink->sink_state, *local_sink_state);
-
-	// flush all query profiler info
-	for (idx_t i = 0; i < intermediate_states.size(); i++) {
-		intermediate_states[i]->Finalize(pipeline.operators[i], context);
-	}
-	pipeline.executor.Flush(thread);
-	local_sink_state.reset();
-}
-
-bool PipelineExecutor::CanCacheType(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-		return false;
-	case LogicalTypeId::STRUCT: {
-		auto &entries = StructType::GetChildTypes(type);
-		for (auto &entry : entries) {
-			if (!CanCacheType(entry.second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		return true;
-	}
-}
-
-void PipelineExecutor::CacheChunk(DataChunk &current_chunk, idx_t operator_idx) {
-#if STANDARD_VECTOR_SIZE >= 128
-	if (cached_chunks[operator_idx]) {
-		if (current_chunk.size() < CACHE_THRESHOLD) {
-			// we have filtered out a significant amount of tuples
-			// add this chunk to the cache and continue
-			auto &chunk_cache = *cached_chunks[operator_idx];
-			chunk_cache.Append(current_chunk);
-			if (chunk_cache.size() >= (STANDARD_VECTOR_SIZE - CACHE_THRESHOLD)) {
-				// chunk cache full: return it
-				current_chunk.Move(chunk_cache);
-				chunk_cache.Initialize(Allocator::Get(context.client), pipeline.operators[operator_idx]->GetTypes());
-			} else {
-				// chunk cache not full: probe again
-				current_chunk.Reset();
-			}
-		}
-	}
-#endif
-}
-
-void PipelineExecutor::ExecutePull(DataChunk &result) {
-	if (IsFinished()) {
-		return;
-	}
-	auto &executor = pipeline.executor;
-	try {
-		D_ASSERT(!pipeline.sink);
-		auto &source_chunk = pipeline.operators.empty() ? result : *intermediate_chunks[0];
-		while (result.size() == 0) {
-			if (in_process_operators.empty()) {
-				source_chunk.Reset();
-				FetchFromSource(source_chunk);
-				if (source_chunk.size() == 0) {
-					break;
-				}
-			}
-			if (!pipeline.operators.empty()) {
-				auto state = Execute(source_chunk, result);
-				if (state == OperatorResultType::FINISHED) {
-					break;
-				}
-			}
-		}
-	} catch (std::exception &ex) { // LCOV_EXCL_START
-		if (executor.HasError()) {
-			executor.ThrowException();
-		}
-		throw;
-	} catch (...) {
-		if (executor.HasError()) {
-			executor.ThrowException();
-		}
-		throw;
-	} // LCOV_EXCL_STOP
-}
-
-void PipelineExecutor::PullFinalize() {
-	if (finalized) {
-		throw InternalException("Calling PullFinalize on a pipeline that has been finalized already");
-	}
-	finalized = true;
-	pipeline.executor.Flush(thread);
-}
-
-void PipelineExecutor::GoToSource(idx_t &current_idx, idx_t initial_idx) {
-	// we go back to the first operator (the source)
-	current_idx = initial_idx;
-	if (!in_process_operators.empty()) {
-		// ... UNLESS there is an in process operator
-		// if there is an in-process operator, we start executing at the latest one
-		// for example, if we have a join operator that has tuples left, we first need to emit those tuples
-		current_idx = in_process_operators.top();
-		in_process_operators.pop();
-	}
-	D_ASSERT(current_idx >= initial_idx);
-}
-
-OperatorResultType PipelineExecutor::Execute(DataChunk &input, DataChunk &result, idx_t initial_idx) {
-	if (input.size() == 0) { // LCOV_EXCL_START
-		return OperatorResultType::NEED_MORE_INPUT;
-	} // LCOV_EXCL_STOP
-	D_ASSERT(!pipeline.operators.empty());
-
-	idx_t current_idx;
-	GoToSource(current_idx, initial_idx);
-	if (current_idx == initial_idx) {
-		current_idx++;
-	}
-	if (current_idx > pipeline.operators.size()) {
-		result.Reference(input);
-		return OperatorResultType::NEED_MORE_INPUT;
-	}
-	while (true) {
-		if (context.client.interrupted) {
-			throw InterruptException();
-		}
-		// now figure out where to put the chunk
-		// if current_idx is the last possible index (>= operators.size()) we write to the result
-		// otherwise we write to an intermediate chunk
-		auto current_intermediate = current_idx;
-		auto &current_chunk =
-		    current_intermediate >= intermediate_chunks.size() ? result : *intermediate_chunks[current_intermediate];
-		current_chunk.Reset();
-		if (current_idx == initial_idx) {
-			// we went back to the source: we need more input
-			return OperatorResultType::NEED_MORE_INPUT;
-		} else {
-			auto &prev_chunk =
-			    current_intermediate == initial_idx + 1 ? input : *intermediate_chunks[current_intermediate - 1];
-			auto operator_idx = current_idx - 1;
-			auto current_operator = pipeline.operators[operator_idx];
-
-			// if current_idx > source_idx, we pass the previous' operators output through the Execute of the current
-			// operator
-			StartOperator(current_operator);
-			auto result = current_operator->Execute(context, prev_chunk, current_chunk, *current_operator->op_state,
-			                                        *intermediate_states[current_intermediate - 1]);
-			EndOperator(current_operator, &current_chunk);
-			if (result == OperatorResultType::HAVE_MORE_OUTPUT) {
-				// more data remains in this operator
-				// push in-process marker
-				in_process_operators.push(current_idx);
-			} else if (result == OperatorResultType::FINISHED) {
-				D_ASSERT(current_chunk.size() == 0);
-				FinishProcessing(current_idx);
-				return OperatorResultType::FINISHED;
-			}
-			current_chunk.Verify();
-			CacheChunk(current_chunk, operator_idx);
-		}
-
-		if (current_chunk.size() == 0) {
-			// no output from this operator!
-			if (current_idx == initial_idx) {
-				// if we got no output from the scan, we are done
-				break;
-			} else {
-				// if we got no output from an intermediate op
-				// we go back and try to pull data from the source again
-				GoToSource(current_idx, initial_idx);
-				continue;
-			}
-		} else {
-			// we got output! continue to the next operator
-			current_idx++;
-			if (current_idx > pipeline.operators.size()) {
-				// if we got output and are at the last operator, we are finished executing for this output chunk
-				// return the data and push it into the chunk
-				break;
-			}
-		}
-	}
-	return in_process_operators.empty() ? OperatorResultType::NEED_MORE_INPUT : OperatorResultType::HAVE_MORE_OUTPUT;
-}
-
-void PipelineExecutor::FetchFromSource(DataChunk &result) {
-	StartOperator(pipeline.source);
-	pipeline.source->GetData(context, result, *pipeline.source_state, *local_source_state);
-	if (result.size() != 0 && requires_batch_index) {
-		auto next_batch_index =
-		    pipeline.source->GetBatchIndex(context, result, *pipeline.source_state, *local_source_state);
-		next_batch_index += pipeline.base_batch_index;
-		D_ASSERT(local_sink_state->batch_index <= next_batch_index ||
-		         local_sink_state->batch_index == DConstants::INVALID_INDEX);
-		local_sink_state->batch_index = next_batch_index;
-	}
-	EndOperator(pipeline.source, &result);
-}
-
-void PipelineExecutor::InitializeChunk(DataChunk &chunk) {
-	PhysicalOperator *last_op = pipeline.operators.empty() ? pipeline.source : pipeline.operators.back();
-	chunk.Initialize(Allocator::DefaultAllocator(), last_op->GetTypes());
-}
-
-void PipelineExecutor::StartOperator(PhysicalOperator *op) {
-	if (context.client.interrupted) {
-		throw InterruptException();
-	}
-	context.thread.profiler.StartOperator(op);
-}
-
-void PipelineExecutor::EndOperator(PhysicalOperator *op, DataChunk *chunk) {
-	context.thread.profiler.EndOperator(chunk);
-
-	if (chunk) {
-		chunk->Verify();
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-PipelineFinishEvent::PipelineFinishEvent(shared_ptr<Pipeline> pipeline_p)
-    : Event(pipeline_p->executor), pipeline(move(pipeline_p)) {
-}
-
-void PipelineFinishEvent::Schedule() {
-}
-
-void PipelineFinishEvent::FinishEvent() {
-	pipeline->Finalize(*this);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-#ifndef DUCKDB_NO_THREADS
-
-
-
-#else
-#include <queue>
-#endif
-
-namespace duckdb {
-
-struct SchedulerThread {
-#ifndef DUCKDB_NO_THREADS
-	explicit SchedulerThread(unique_ptr<thread> thread_p) : internal_thread(move(thread_p)) {
-	}
-
-	unique_ptr<thread> internal_thread;
-#endif
-};
-
-#ifndef DUCKDB_NO_THREADS
-typedef duckdb_moodycamel::ConcurrentQueue<unique_ptr<Task>> concurrent_queue_t;
-typedef duckdb_moodycamel::LightweightSemaphore lightweight_semaphore_t;
-
-struct ConcurrentQueue {
-	concurrent_queue_t q;
-	lightweight_semaphore_t semaphore;
-
-	void Enqueue(ProducerToken &token, unique_ptr<Task> task);
-	bool DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task);
-};
-
-struct QueueProducerToken {
-	explicit QueueProducerToken(ConcurrentQueue &queue) : queue_token(queue.q) {
-	}
-
-	duckdb_moodycamel::ProducerToken queue_token;
-};
-
-void ConcurrentQueue::Enqueue(ProducerToken &token, unique_ptr<Task> task) {
-	lock_guard<mutex> producer_lock(token.producer_lock);
-	if (q.enqueue(token.token->queue_token, move(task))) {
-		semaphore.signal();
-	} else {
-		throw InternalException("Could not schedule task!");
-	}
-}
-
-bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task) {
-	lock_guard<mutex> producer_lock(token.producer_lock);
-	return q.try_dequeue_from_producer(token.token->queue_token, task);
-}
-
-#else
-struct ConcurrentQueue {
-	std::queue<std::unique_ptr<Task>> q;
-	mutex qlock;
-
-	void Enqueue(ProducerToken &token, unique_ptr<Task> task);
-	bool DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task);
-};
-
-void ConcurrentQueue::Enqueue(ProducerToken &token, unique_ptr<Task> task) {
-	lock_guard<mutex> lock(qlock);
-	q.push(move(task));
-}
-
-bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task) {
-	lock_guard<mutex> lock(qlock);
-	if (q.empty()) {
-		return false;
-	}
-	task = move(q.front());
-	q.pop();
-	return true;
-}
-
-struct QueueProducerToken {
-	QueueProducerToken(ConcurrentQueue &queue) {
-	}
-};
-#endif
-
-ProducerToken::ProducerToken(TaskScheduler &scheduler, unique_ptr<QueueProducerToken> token)
-    : scheduler(scheduler), token(move(token)) {
-}
-
-ProducerToken::~ProducerToken() {
-}
-
-TaskScheduler::TaskScheduler(DatabaseInstance &db) : db(db), queue(make_unique<ConcurrentQueue>()) {
-}
-
-TaskScheduler::~TaskScheduler() {
-#ifndef DUCKDB_NO_THREADS
-	SetThreadsInternal(1);
-#endif
-}
-
-TaskScheduler &TaskScheduler::GetScheduler(ClientContext &context) {
-	return TaskScheduler::GetScheduler(DatabaseInstance::GetDatabase(context));
-}
-
-TaskScheduler &TaskScheduler::GetScheduler(DatabaseInstance &db) {
-	return db.GetScheduler();
-}
-
-unique_ptr<ProducerToken> TaskScheduler::CreateProducer() {
-	auto token = make_unique<QueueProducerToken>(*queue);
-	return make_unique<ProducerToken>(*this, move(token));
-}
-
-void TaskScheduler::ScheduleTask(ProducerToken &token, unique_ptr<Task> task) {
-	// Enqueue a task for the given producer token and signal any sleeping threads
-	queue->Enqueue(token, move(task));
-}
-
-bool TaskScheduler::GetTaskFromProducer(ProducerToken &token, unique_ptr<Task> &task) {
-	return queue->DequeueFromProducer(token, task);
-}
-
-void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
-#ifndef DUCKDB_NO_THREADS
-	unique_ptr<Task> task;
-	// loop until the marker is set to false
-	while (*marker) {
-		// wait for a signal with a timeout; the timeout allows us to periodically check
-		queue->semaphore.wait();
-		if (queue->q.try_dequeue(task)) {
-			task->Execute(TaskExecutionMode::PROCESS_ALL);
-			task.reset();
-		}
-	}
-#else
-	throw NotImplementedException("DuckDB was compiled without threads! Background thread loop is not allowed.");
-#endif
-}
-
-void TaskScheduler::ExecuteTasks(idx_t max_tasks) {
-#ifndef DUCKDB_NO_THREADS
-	unique_ptr<Task> task;
-	for (idx_t i = 0; i < max_tasks; i++) {
-		queue->semaphore.wait(TASK_TIMEOUT_USECS);
-		if (!queue->q.try_dequeue(task)) {
-			return;
-		}
-		try {
-			task->Execute(TaskExecutionMode::PROCESS_ALL);
-			task.reset();
-		} catch (...) {
-			return;
-		}
-	}
-#else
-	throw NotImplementedException("DuckDB was compiled without threads! Background thread loop is not allowed.");
-#endif
-}
-
-#ifndef DUCKDB_NO_THREADS
-static void ThreadExecuteTasks(TaskScheduler *scheduler, atomic<bool> *marker) {
-	scheduler->ExecuteForever(marker);
-}
-#endif
-
-int32_t TaskScheduler::NumberOfThreads() {
-	auto &config = DBConfig::GetConfig(db);
-	return threads.size() + config.external_threads + 1;
-}
-
-void TaskScheduler::SetThreads(int32_t n) {
-#ifndef DUCKDB_NO_THREADS
-	if (n < 1) {
-		throw SyntaxException("Must have at least 1 thread!");
-	}
-	SetThreadsInternal(n);
-#else
-	if (n != 1) {
-		throw NotImplementedException("DuckDB was compiled without threads! Setting threads > 1 is not allowed.");
-	}
-#endif
-}
-
-void TaskScheduler::SetThreadsInternal(int32_t n) {
-#ifndef DUCKDB_NO_THREADS
-	if (threads.size() == idx_t(n - 1)) {
-		return;
-	}
-	idx_t new_thread_count = n - 1;
-	if (threads.size() > new_thread_count) {
-		// we are reducing the number of threads: clear all threads first
-		for (idx_t i = 0; i < threads.size(); i++) {
-			*markers[i] = false;
-		}
-		queue->semaphore.signal(threads.size());
-		// now join the threads to ensure they are fully stopped before erasing them
-		for (idx_t i = 0; i < threads.size(); i++) {
-			threads[i]->internal_thread->join();
-		}
-		// erase the threads/markers
-		threads.clear();
-		markers.clear();
-	}
-	if (threads.size() < new_thread_count) {
-		// we are increasing the number of threads: launch them and run tasks on them
-		idx_t create_new_threads = new_thread_count - threads.size();
-		for (idx_t i = 0; i < create_new_threads; i++) {
-			// launch a thread and assign it a cancellation marker
-			auto marker = unique_ptr<atomic<bool>>(new atomic<bool>(true));
-			auto worker_thread = make_unique<thread>(ThreadExecuteTasks, this, marker.get());
-			auto thread_wrapper = make_unique<SchedulerThread>(move(worker_thread));
-
-			threads.push_back(move(thread_wrapper));
-			markers.push_back(move(marker));
-		}
-	}
-#endif
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-ThreadContext::ThreadContext(ClientContext &context) : profiler(QueryProfiler::Get(context).IsEnabled()) {
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-void BaseExpression::Print() const {
-	Printer::Print(ToString());
-}
-
-string BaseExpression::GetName() const {
-	return !alias.empty() ? alias : ToString();
-}
-
-bool BaseExpression::Equals(const BaseExpression *other) const {
-	if (!other) {
-		return false;
-	}
-	if (this->expression_class != other->expression_class || this->type != other->type) {
-		return false;
-	}
-	return true;
-}
-
-void BaseExpression::Verify() const {
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p) : name(move(name_p)), type(move(type_p)) {
-}
-
-ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p, unique_ptr<ParsedExpression> expression,
-                                   TableColumnType category)
-    : name(move(name_p)), type(move(type_p)), category(category) {
-	switch (category) {
-	case TableColumnType::STANDARD: {
-		default_value = move(expression);
-		break;
-	}
-	case TableColumnType::GENERATED: {
-		generated_expression = move(expression);
-		break;
-	}
-	default: {
-		throw InternalException("Type not implemented for TableColumnType");
-	}
-	}
-}
-
-ColumnDefinition ColumnDefinition::Copy() const {
-	ColumnDefinition copy(name, type);
-	copy.oid = oid;
-	copy.storage_oid = storage_oid;
-	copy.SetDefaultValue(default_value ? default_value->Copy() : nullptr);
-	copy.generated_expression = generated_expression ? generated_expression->Copy() : nullptr;
-	copy.compression_type = compression_type;
-	copy.category = category;
-	return copy;
-}
-
-void ColumnDefinition::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(type);
-	if (Generated()) {
-		writer.WriteOptional(generated_expression);
-	} else {
-		writer.WriteOptional(default_value);
-	}
-	writer.WriteField<TableColumnType>(category);
-	writer.Finalize();
-}
-
-ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto column_name = reader.ReadRequired<string>();
-	auto column_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	auto category = reader.ReadField<TableColumnType>(TableColumnType::STANDARD);
-	reader.Finalize();
-
-	switch (category) {
-	case TableColumnType::STANDARD:
-		return ColumnDefinition(column_name, column_type, move(expression), TableColumnType::STANDARD);
-	case TableColumnType::GENERATED:
-		return ColumnDefinition(column_name, column_type, move(expression), TableColumnType::GENERATED);
-	default:
-		throw NotImplementedException("Type not implemented for TableColumnType");
-	}
-}
-
-const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
-	return default_value;
-}
-
-void ColumnDefinition::SetDefaultValue(unique_ptr<ParsedExpression> default_value) {
-	this->default_value = move(default_value);
-}
-
-const LogicalType &ColumnDefinition::Type() const {
-	return type;
-}
-
-LogicalType &ColumnDefinition::TypeMutable() {
-	return type;
-}
-
-void ColumnDefinition::SetType(const LogicalType &type) {
-	this->type = type;
-}
-
-const string &ColumnDefinition::Name() const {
-	return name;
-}
-
-void ColumnDefinition::SetName(const string &name) {
-	this->name = name;
-}
-
-const duckdb::CompressionType &ColumnDefinition::CompressionType() const {
-	return compression_type;
-}
-
-void ColumnDefinition::SetCompressionType(duckdb::CompressionType compression_type) {
-	this->compression_type = compression_type;
-}
-
-const storage_t &ColumnDefinition::StorageOid() const {
-	return storage_oid;
-}
-
-void ColumnDefinition::SetStorageOid(storage_t storage_oid) {
-	this->storage_oid = storage_oid;
-}
-
-const column_t &ColumnDefinition::Oid() const {
-	return oid;
-}
-
-void ColumnDefinition::SetOid(column_t oid) {
-	this->oid = oid;
-}
-
-const TableColumnType &ColumnDefinition::Category() const {
-	return category;
-}
-
-bool ColumnDefinition::Generated() const {
-	return category == TableColumnType::GENERATED;
-}
-
-//===--------------------------------------------------------------------===//
-// Generated Columns (VIRTUAL)
-//===--------------------------------------------------------------------===//
-
-static void VerifyColumnRefs(ParsedExpression &expr) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = (ColumnRefExpression &)expr;
-		if (column_ref.IsQualified()) {
-			throw ParserException(
-			    "Qualified (tbl.name) column references are not allowed inside of generated column expressions");
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { VerifyColumnRefs((ParsedExpression &)child); });
-}
-
-static void InnerGetListOfDependencies(ParsedExpression &expr, vector<string> &dependencies) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto columnref = (ColumnRefExpression &)expr;
-		auto &name = columnref.GetColumnName();
-		dependencies.push_back(name);
-	}
-	ParsedExpressionIterator::EnumerateChildren(expr, [&](const ParsedExpression &child) {
-		InnerGetListOfDependencies((ParsedExpression &)child, dependencies);
-	});
-}
-
-void ColumnDefinition::GetListOfDependencies(vector<string> &dependencies) const {
-	D_ASSERT(Generated());
-	InnerGetListOfDependencies(*generated_expression, dependencies);
-}
-
-void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> expression) {
-	category = TableColumnType::GENERATED;
-
-	if (expression->HasSubquery()) {
-		throw ParserException("Expression of generated column \"%s\" contains a subquery, which isn't allowed", name);
-	}
-
-	VerifyColumnRefs(*expression);
-	if (type.id() == LogicalTypeId::ANY) {
-		generated_expression = move(expression);
-		return;
-	}
-	// Always wrap the expression in a cast, that way we can always update the cast when we change the type
-	// Except if the type is LogicalType::ANY (no type specified)
-	generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, move(expression));
-}
-
-void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
-	D_ASSERT(Generated());
-	// First time the type is set, add a cast around the expression
-	D_ASSERT(this->type.id() == LogicalTypeId::ANY);
-	generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, move(generated_expression));
-	// Every generated expression should be wrapped in a cast on creation
-	// D_ASSERT(generated_expression->type == ExpressionType::OPERATOR_CAST);
-	// auto &cast_expr = (CastExpression &)*generated_expression;
-	// auto base_expr = move(cast_expr.child);
-	// generated_expression = make_unique_base<ParsedExpression, CastExpression>(type, move(base_expr));
-}
-
-const ParsedExpression &ColumnDefinition::GeneratedExpression() const {
-	D_ASSERT(Generated());
-	return *generated_expression;
-}
-
-ParsedExpression &ColumnDefinition::GeneratedExpressionMutable() {
-	D_ASSERT(Generated());
-	return *generated_expression;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-Constraint::Constraint(ConstraintType type) : type(type) {
-}
-
-Constraint::~Constraint() {
-}
-
-void Constraint::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ConstraintType>(type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<Constraint> Constraint::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<ConstraintType>();
-	unique_ptr<Constraint> result;
-	switch (type) {
-	case ConstraintType::NOT_NULL:
-		result = NotNullConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::CHECK:
-		result = CheckConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::UNIQUE:
-		result = UniqueConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::FOREIGN_KEY:
-		result = ForeignKeyConstraint::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Unrecognized constraint type for serialization");
-	}
-	reader.Finalize();
-	return result;
-}
-
-void Constraint::Print() const {
-	Printer::Print(ToString());
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-CheckConstraint::CheckConstraint(unique_ptr<ParsedExpression> expression)
-    : Constraint(ConstraintType::CHECK), expression(move(expression)) {
-}
-
-string CheckConstraint::ToString() const {
-	return "CHECK(" + expression->ToString() + ")";
-}
-
-unique_ptr<Constraint> CheckConstraint::Copy() const {
-	return make_unique<CheckConstraint>(expression->Copy());
-}
-
-void CheckConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*expression);
-}
-
-unique_ptr<Constraint> CheckConstraint::Deserialize(FieldReader &source) {
-	auto expression = source.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<CheckConstraint>(move(expression));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ForeignKeyConstraint::ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info)
-    : Constraint(ConstraintType::FOREIGN_KEY), pk_columns(move(pk_columns)), fk_columns(move(fk_columns)),
-      info(move(info)) {
-}
-
-string ForeignKeyConstraint::ToString() const {
-	if (info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-		string base = "FOREIGN KEY (";
-
-		for (idx_t i = 0; i < fk_columns.size(); i++) {
-			if (i > 0) {
-				base += ", ";
-			}
-			base += KeywordHelper::WriteOptionallyQuoted(fk_columns[i]);
-		}
-		base += ") REFERENCES ";
-		if (!info.schema.empty()) {
-			base += info.schema;
-			base += ".";
-		}
-		base += info.table;
-		base += "(";
-
-		for (idx_t i = 0; i < pk_columns.size(); i++) {
-			if (i > 0) {
-				base += ", ";
-			}
-			base += KeywordHelper::WriteOptionallyQuoted(pk_columns[i]);
-		}
-		base += ")";
-
-		return base;
-	}
-
-	return "";
-}
-
-unique_ptr<Constraint> ForeignKeyConstraint::Copy() const {
-	return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, info);
-}
-
-void ForeignKeyConstraint::Serialize(FieldWriter &writer) const {
-	D_ASSERT(pk_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(pk_columns);
-	D_ASSERT(fk_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(fk_columns);
-	writer.WriteField<ForeignKeyType>(info.type);
-	writer.WriteString(info.schema);
-	writer.WriteString(info.table);
-	writer.WriteList<idx_t>(info.pk_keys);
-	writer.WriteList<idx_t>(info.fk_keys);
-}
-
-unique_ptr<Constraint> ForeignKeyConstraint::Deserialize(FieldReader &source) {
-	ForeignKeyInfo read_info;
-	auto pk_columns = source.ReadRequiredList<string>();
-	auto fk_columns = source.ReadRequiredList<string>();
-	read_info.type = source.ReadRequired<ForeignKeyType>();
-	read_info.schema = source.ReadRequired<string>();
-	read_info.table = source.ReadRequired<string>();
-	read_info.pk_keys = source.ReadRequiredList<idx_t>();
-	read_info.fk_keys = source.ReadRequiredList<idx_t>();
-
-	// column list parsed constraint
-	return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, move(read_info));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-NotNullConstraint::NotNullConstraint(column_t index) : Constraint(ConstraintType::NOT_NULL), index(index) {
-}
-
-NotNullConstraint::~NotNullConstraint() {
-}
-
-string NotNullConstraint::ToString() const {
-	return "NOT NULL";
-}
-
-unique_ptr<Constraint> NotNullConstraint::Copy() const {
-	return make_unique<NotNullConstraint>(index);
-}
-
-void NotNullConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(index);
-}
-
-unique_ptr<Constraint> NotNullConstraint::Deserialize(FieldReader &source) {
-	auto index = source.ReadRequired<idx_t>();
-	return make_unique_base<Constraint, NotNullConstraint>(index);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-UniqueConstraint::UniqueConstraint(uint64_t index, bool is_primary_key)
-    : Constraint(ConstraintType::UNIQUE), index(index), is_primary_key(is_primary_key) {
-}
-UniqueConstraint::UniqueConstraint(vector<string> columns, bool is_primary_key)
-    : Constraint(ConstraintType::UNIQUE), index(DConstants::INVALID_INDEX), columns(move(columns)),
-      is_primary_key(is_primary_key) {
-}
-
-string UniqueConstraint::ToString() const {
-	string base = is_primary_key ? "PRIMARY KEY(" : "UNIQUE(";
-	for (idx_t i = 0; i < columns.size(); i++) {
-		if (i > 0) {
-			base += ", ";
-		}
-		base += KeywordHelper::WriteOptionallyQuoted(columns[i]);
-	}
-	return base + ")";
-}
-
-unique_ptr<Constraint> UniqueConstraint::Copy() const {
-	if (index == DConstants::INVALID_INDEX) {
-		return make_unique<UniqueConstraint>(columns, is_primary_key);
-	} else {
-		auto result = make_unique<UniqueConstraint>(index, is_primary_key);
-		result->columns = columns;
-		return move(result);
-	}
-}
-
-void UniqueConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteField<bool>(is_primary_key);
-	writer.WriteField<uint64_t>(index);
-	D_ASSERT(columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(columns);
-}
-
-unique_ptr<Constraint> UniqueConstraint::Deserialize(FieldReader &source) {
-	auto is_primary_key = source.ReadRequired<bool>();
-	auto index = source.ReadRequired<uint64_t>();
-	auto columns = source.ReadRequiredList<string>();
-
-	if (index != DConstants::INVALID_INDEX) {
-		// single column parsed constraint
-		auto result = make_unique<UniqueConstraint>(index, is_primary_key);
-		result->columns = move(columns);
-		return move(result);
-	} else {
-		// column list parsed constraint
-		return make_unique<UniqueConstraint>(move(columns), is_primary_key);
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-BetweenExpression::BetweenExpression(unique_ptr<ParsedExpression> input_p, unique_ptr<ParsedExpression> lower_p,
-                                     unique_ptr<ParsedExpression> upper_p)
-    : ParsedExpression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BETWEEN), input(move(input_p)),
-      lower(move(lower_p)), upper(move(upper_p)) {
-}
-
-string BetweenExpression::ToString() const {
-	return ToString<BetweenExpression, ParsedExpression>(*this);
-}
-
-bool BetweenExpression::Equals(const BetweenExpression *a, const BetweenExpression *b) {
-	if (!a->input->Equals(b->input.get())) {
-		return false;
-	}
-	if (!a->lower->Equals(b->lower.get())) {
-		return false;
-	}
-	if (!a->upper->Equals(b->upper.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> BetweenExpression::Copy() const {
-	auto copy = make_unique<BetweenExpression>(input->Copy(), lower->Copy(), upper->Copy());
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void BetweenExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*input);
-	writer.WriteSerializable(*lower);
-	writer.WriteSerializable(*upper);
-}
-
-unique_ptr<ParsedExpression> BetweenExpression::Deserialize(ExpressionType type, FieldReader &source) {
-	auto input = source.ReadRequiredSerializable<ParsedExpression>();
-	auto lower = source.ReadRequiredSerializable<ParsedExpression>();
-	auto upper = source.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<BetweenExpression>(move(input), move(lower), move(upper));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-CaseExpression::CaseExpression() : ParsedExpression(ExpressionType::CASE_EXPR, ExpressionClass::CASE) {
-}
-
-string CaseExpression::ToString() const {
-	return ToString<CaseExpression, ParsedExpression>(*this);
-}
-
-bool CaseExpression::Equals(const CaseExpression *a, const CaseExpression *b) {
-	if (a->case_checks.size() != b->case_checks.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a->case_checks.size(); i++) {
-		if (!a->case_checks[i].when_expr->Equals(b->case_checks[i].when_expr.get())) {
-			return false;
-		}
-		if (!a->case_checks[i].then_expr->Equals(b->case_checks[i].then_expr.get())) {
-			return false;
-		}
-	}
-	if (!a->else_expr->Equals(b->else_expr.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> CaseExpression::Copy() const {
-	auto copy = make_unique<CaseExpression>();
-	copy->CopyProperties(*this);
-	for (auto &check : case_checks) {
-		CaseCheck new_check;
-		new_check.when_expr = check.when_expr->Copy();
-		new_check.then_expr = check.then_expr->Copy();
-		copy->case_checks.push_back(move(new_check));
-	}
-	copy->else_expr = else_expr->Copy();
-	return move(copy);
-}
-
-void CaseExpression::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-	// we write a list of multiple expressions here
-	// in order to write this as a single field we directly use the field writers' internal serializer
-	writer.WriteField<uint32_t>(case_checks.size());
-	for (auto &check : case_checks) {
-		check.when_expr->Serialize(serializer);
-		check.then_expr->Serialize(serializer);
-	}
-	writer.WriteSerializable<ParsedExpression>(*else_expr);
-}
-
-unique_ptr<ParsedExpression> CaseExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto result = make_unique<CaseExpression>();
-	auto &source = reader.GetSource();
-	auto count = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < count; i++) {
-		CaseCheck new_check;
-		new_check.when_expr = ParsedExpression::Deserialize(source);
-		new_check.then_expr = ParsedExpression::Deserialize(source);
-		result->case_checks.push_back(move(new_check));
-	}
-	result->else_expr = reader.ReadRequiredSerializable<ParsedExpression>();
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-CastExpression::CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast_p)
-    : ParsedExpression(ExpressionType::OPERATOR_CAST, ExpressionClass::CAST), cast_type(move(target)),
-      try_cast(try_cast_p) {
-	D_ASSERT(child);
-	this->child = move(child);
-}
-
-string CastExpression::ToString() const {
-	return ToString<CastExpression, ParsedExpression>(*this);
-}
-
-bool CastExpression::Equals(const CastExpression *a, const CastExpression *b) {
-	if (!a->child->Equals(b->child.get())) {
-		return false;
-	}
-	if (a->cast_type != b->cast_type) {
-		return false;
-	}
-	if (a->try_cast != b->try_cast) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> CastExpression::Copy() const {
-	auto copy = make_unique<CastExpression>(cast_type, child->Copy(), try_cast);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void CastExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*child);
-	writer.WriteSerializable(cast_type);
-	writer.WriteField<bool>(try_cast);
-}
-
-unique_ptr<ParsedExpression> CastExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto cast_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto try_cast = reader.ReadRequired<bool>();
-	return make_unique_base<ParsedExpression, CastExpression>(cast_type, move(child), try_cast);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-CollateExpression::CollateExpression(string collation_p, unique_ptr<ParsedExpression> child)
-    : ParsedExpression(ExpressionType::COLLATE, ExpressionClass::COLLATE), collation(move(collation_p)) {
-	D_ASSERT(child);
-	this->child = move(child);
-}
-
-string CollateExpression::ToString() const {
-	return child->ToString() + " COLLATE " + collation;
-}
-
-bool CollateExpression::Equals(const CollateExpression *a, const CollateExpression *b) {
-	if (!a->child->Equals(b->child.get())) {
-		return false;
-	}
-	if (a->collation != b->collation) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> CollateExpression::Copy() const {
-	auto copy = make_unique<CollateExpression>(collation, child->Copy());
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void CollateExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*child);
-	writer.WriteString(collation);
-}
-
-unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto collation = reader.ReadRequired<string>();
-	return make_unique_base<ParsedExpression, CollateExpression>(collation, move(child));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
-    : ColumnRefExpression(table_name.empty() ? vector<string> {move(column_name)}
-                                             : vector<string> {move(table_name), move(column_name)}) {
-}
-
-ColumnRefExpression::ColumnRefExpression(string column_name) : ColumnRefExpression(vector<string> {move(column_name)}) {
-}
-
-ColumnRefExpression::ColumnRefExpression(vector<string> column_names_p)
-    : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF), column_names(move(column_names_p)) {
-#ifdef DEBUG
-	for (auto &col_name : column_names) {
-		D_ASSERT(!col_name.empty());
-	}
-#endif
-}
-
-bool ColumnRefExpression::IsQualified() const {
-	return column_names.size() > 1;
-}
-
-const string &ColumnRefExpression::GetColumnName() const {
-	D_ASSERT(column_names.size() <= 3);
-	return column_names.back();
-}
-
-const string &ColumnRefExpression::GetTableName() const {
-	D_ASSERT(column_names.size() >= 2 && column_names.size() <= 3);
-	return column_names.size() == 3 ? column_names[1] : column_names[0];
-}
-
-string ColumnRefExpression::GetName() const {
-	return !alias.empty() ? alias : column_names.back();
-}
-
-string ColumnRefExpression::ToString() const {
-	string result;
-	for (idx_t i = 0; i < column_names.size(); i++) {
-		if (i > 0) {
-			result += ".";
-		}
-		result += KeywordHelper::WriteOptionallyQuoted(column_names[i]);
-	}
-	return result;
-}
-
-bool ColumnRefExpression::Equals(const ColumnRefExpression *a, const ColumnRefExpression *b) {
-	if (a->column_names.size() != b->column_names.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a->column_names.size(); i++) {
-		auto lcase_a = StringUtil::Lower(a->column_names[i]);
-		auto lcase_b = StringUtil::Lower(b->column_names[i]);
-		if (lcase_a != lcase_b) {
-			return false;
-		}
-	}
-	return true;
-}
-
-hash_t ColumnRefExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	for (auto &column_name : column_names) {
-		auto lcase = StringUtil::Lower(column_name);
-		result = CombineHash(result, duckdb::Hash<const char *>(lcase.c_str()));
-	}
-	return result;
-}
-
-unique_ptr<ParsedExpression> ColumnRefExpression::Copy() const {
-	auto copy = make_unique<ColumnRefExpression>(column_names);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void ColumnRefExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteList<string>(column_names);
-}
-
-unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto column_names = reader.ReadRequiredList<string>();
-	auto expression = make_unique<ColumnRefExpression>(move(column_names));
-	return move(expression);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ComparisonExpression::ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-                                           unique_ptr<ParsedExpression> right)
-    : ParsedExpression(type, ExpressionClass::COMPARISON) {
-	this->left = move(left);
-	this->right = move(right);
-}
-
-string ComparisonExpression::ToString() const {
-	return ToString<ComparisonExpression, ParsedExpression>(*this);
-}
-
-bool ComparisonExpression::Equals(const ComparisonExpression *a, const ComparisonExpression *b) {
-	if (!a->left->Equals(b->left.get())) {
-		return false;
-	}
-	if (!a->right->Equals(b->right.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> ComparisonExpression::Copy() const {
-	auto copy = make_unique<ComparisonExpression>(type, left->Copy(), right->Copy());
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void ComparisonExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-}
-
-unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto left_child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto right_child = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<ComparisonExpression>(type, move(left_child), move(right_child));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-ConjunctionExpression::ConjunctionExpression(ExpressionType type)
-    : ParsedExpression(type, ExpressionClass::CONJUNCTION) {
-}
-
-ConjunctionExpression::ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children)
-    : ParsedExpression(type, ExpressionClass::CONJUNCTION) {
-	for (auto &child : children) {
-		AddExpression(move(child));
-	}
-}
-
-ConjunctionExpression::ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-                                             unique_ptr<ParsedExpression> right)
-    : ParsedExpression(type, ExpressionClass::CONJUNCTION) {
-	AddExpression(move(left));
-	AddExpression(move(right));
-}
-
-void ConjunctionExpression::AddExpression(unique_ptr<ParsedExpression> expr) {
-	if (expr->type == type) {
-		// expr is a conjunction of the same type: merge the expression lists together
-		auto &other = (ConjunctionExpression &)*expr;
-		for (auto &child : other.children) {
-			children.push_back(move(child));
-		}
-	} else {
-		children.push_back(move(expr));
-	}
-}
-
-string ConjunctionExpression::ToString() const {
-	return ToString<ConjunctionExpression, ParsedExpression>(*this);
-}
-
-bool ConjunctionExpression::Equals(const ConjunctionExpression *a, const ConjunctionExpression *b) {
-	return ExpressionUtil::SetEquals(a->children, b->children);
-}
-
-unique_ptr<ParsedExpression> ConjunctionExpression::Copy() const {
-	vector<unique_ptr<ParsedExpression>> copy_children;
-	for (auto &expr : children) {
-		copy_children.push_back(expr->Copy());
-	}
-	auto copy = make_unique<ConjunctionExpression>(type, move(copy_children));
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void ConjunctionExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(children);
-}
-
-unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto result = make_unique<ConjunctionExpression>(type);
-	result->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-ConstantExpression::ConstantExpression(Value val)
-    : ParsedExpression(ExpressionType::VALUE_CONSTANT, ExpressionClass::CONSTANT), value(move(val)) {
-}
-
-string ConstantExpression::ToString() const {
-	return value.ToSQLString();
-}
-
-bool ConstantExpression::Equals(const ConstantExpression *a, const ConstantExpression *b) {
-	return !ValueOperations::DistinctFrom(a->value, b->value);
-}
-
-hash_t ConstantExpression::Hash() const {
-	return ParsedExpression::Hash();
-}
-
-unique_ptr<ParsedExpression> ConstantExpression::Copy() const {
-	auto copy = make_unique<ConstantExpression>(value);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void ConstantExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(value);
-}
-
-unique_ptr<ParsedExpression> ConstantExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	Value value = reader.ReadRequiredSerializable<Value, Value>();
-	return make_unique<ConstantExpression>(move(value));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-DefaultExpression::DefaultExpression() : ParsedExpression(ExpressionType::VALUE_DEFAULT, ExpressionClass::DEFAULT) {
-}
-
-string DefaultExpression::ToString() const {
-	return "DEFAULT";
-}
-
-unique_ptr<ParsedExpression> DefaultExpression::Copy() const {
-	auto copy = make_unique<DefaultExpression>();
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void DefaultExpression::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<ParsedExpression> DefaultExpression::Deserialize(ExpressionType type, FieldReader &source) {
-	return make_unique<DefaultExpression>();
-}
-
-} // namespace duckdb
-
-
-#include <utility>
-
-
-
-
-
-namespace duckdb {
-
-FunctionExpression::FunctionExpression(string schema, const string &function_name,
-                                       vector<unique_ptr<ParsedExpression>> children_p,
-                                       unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys_p,
-                                       bool distinct, bool is_operator, bool export_state_p)
-    : ParsedExpression(ExpressionType::FUNCTION, ExpressionClass::FUNCTION), schema(std::move(schema)),
-      function_name(StringUtil::Lower(function_name)), is_operator(is_operator), children(move(children_p)),
-      distinct(distinct), filter(move(filter)), order_bys(move(order_bys_p)), export_state(export_state_p) {
-	D_ASSERT(!function_name.empty());
-	if (!order_bys) {
-		order_bys = make_unique<OrderModifier>();
-	}
-}
-
-FunctionExpression::FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children_p,
-                                       unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys,
-                                       bool distinct, bool is_operator, bool export_state_p)
-    : FunctionExpression(INVALID_SCHEMA, function_name, move(children_p), move(filter), move(order_bys), distinct,
-                         is_operator, export_state_p) {
-}
-
-string FunctionExpression::ToString() const {
-	return ToString<FunctionExpression, ParsedExpression>(*this, schema, function_name, is_operator, distinct,
-	                                                      filter.get(), order_bys.get(), export_state, true);
-}
-
-bool FunctionExpression::Equals(const FunctionExpression *a, const FunctionExpression *b) {
-	if (a->schema != b->schema || a->function_name != b->function_name || b->distinct != a->distinct) {
-		return false;
-	}
-	if (b->children.size() != a->children.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a->children.size(); i++) {
-		if (!a->children[i]->Equals(b->children[i].get())) {
-			return false;
-		}
-	}
-	if (!BaseExpression::Equals(a->filter.get(), b->filter.get())) {
-		return false;
-	}
-	if (!a->order_bys->Equals(b->order_bys.get())) {
-		return false;
-	}
-	if (a->export_state != b->export_state) {
-		return false;
-	}
-	return true;
-}
-
-hash_t FunctionExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	result = CombineHash(result, duckdb::Hash<const char *>(schema.c_str()));
-	result = CombineHash(result, duckdb::Hash<const char *>(function_name.c_str()));
-	result = CombineHash(result, duckdb::Hash<bool>(distinct));
-	result = CombineHash(result, duckdb::Hash<bool>(export_state));
-	return result;
-}
-
-unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
-	vector<unique_ptr<ParsedExpression>> copy_children;
-	unique_ptr<ParsedExpression> filter_copy;
-	for (auto &child : children) {
-		copy_children.push_back(child->Copy());
-	}
-	if (filter) {
-		filter_copy = filter->Copy();
-	}
-	unique_ptr<OrderModifier> order_copy;
-	if (order_bys) {
-		order_copy.reset(static_cast<OrderModifier *>(order_bys->Copy().release()));
-	}
-
-	auto copy = make_unique<FunctionExpression>(function_name, move(copy_children), move(filter_copy), move(order_copy),
-	                                            distinct, is_operator, export_state);
-	copy->schema = schema;
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void FunctionExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteString(function_name);
-	writer.WriteString(schema);
-	writer.WriteSerializableList(children);
-	writer.WriteOptional(filter);
-	writer.WriteSerializable((ResultModifier &)*order_bys);
-	writer.WriteField<bool>(distinct);
-	writer.WriteField<bool>(is_operator);
-	writer.WriteField<bool>(export_state);
-}
-
-unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto function_name = reader.ReadRequired<string>();
-	auto schema = reader.ReadRequired<string>();
-	auto children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	auto filter = reader.ReadOptional<ParsedExpression>(nullptr);
-	auto order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(reader.ReadRequiredSerializable<ResultModifier>());
-	auto distinct = reader.ReadRequired<bool>();
-	auto is_operator = reader.ReadRequired<bool>();
-	auto export_state = reader.ReadField<bool>(false);
-
-	unique_ptr<FunctionExpression> function;
-	function = make_unique<FunctionExpression>(function_name, move(children), move(filter), move(order_bys), distinct,
-	                                           is_operator, export_state);
-	function->schema = schema;
-	return move(function);
-}
-
-void FunctionExpression::Verify() const {
-	D_ASSERT(!function_name.empty());
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-LambdaExpression::LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> rhs)
-    : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA), lhs(move(lhs)), rhs(move(rhs)) {
-}
-
-string LambdaExpression::ToString() const {
-	return lhs->ToString() + " -> " + rhs->ToString();
-}
-
-bool LambdaExpression::Equals(const LambdaExpression *a, const LambdaExpression *b) {
-	return a->lhs->Equals(b->lhs.get()) && a->rhs->Equals(b->rhs.get());
-}
-
-hash_t LambdaExpression::Hash() const {
-	hash_t result = lhs->Hash();
-	ParsedExpression::Hash();
-	result = CombineHash(result, rhs->Hash());
-	return result;
-}
-
-unique_ptr<ParsedExpression> LambdaExpression::Copy() const {
-	return make_unique<LambdaExpression>(lhs->Copy(), rhs->Copy());
-}
-
-void LambdaExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*lhs);
-	writer.WriteSerializable(*rhs);
-}
-
-unique_ptr<ParsedExpression> LambdaExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto lhs = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto rhs = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<LambdaExpression>(move(lhs), move(rhs));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-OperatorExpression::OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-                                       unique_ptr<ParsedExpression> right)
-    : ParsedExpression(type, ExpressionClass::OPERATOR) {
-	if (left) {
-		children.push_back(move(left));
-	}
-	if (right) {
-		children.push_back(move(right));
-	}
-}
-
-OperatorExpression::OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children)
-    : ParsedExpression(type, ExpressionClass::OPERATOR), children(move(children)) {
-}
-
-string OperatorExpression::ToString() const {
-	return ToString<OperatorExpression, ParsedExpression>(*this);
-}
-
-bool OperatorExpression::Equals(const OperatorExpression *a, const OperatorExpression *b) {
-	if (a->children.size() != b->children.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a->children.size(); i++) {
-		if (!a->children[i]->Equals(b->children[i].get())) {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<ParsedExpression> OperatorExpression::Copy() const {
-	auto copy = make_unique<OperatorExpression>(type);
-	copy->CopyProperties(*this);
-	for (auto &it : children) {
-		copy->children.push_back(it->Copy());
-	}
-	return move(copy);
-}
-
-void OperatorExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(children);
-}
-
-unique_ptr<ParsedExpression> OperatorExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_unique<OperatorExpression>(type);
-	expression->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return move(expression);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-ParameterExpression::ParameterExpression()
-    : ParsedExpression(ExpressionType::VALUE_PARAMETER, ExpressionClass::PARAMETER), parameter_nr(0) {
-}
-
-string ParameterExpression::ToString() const {
-	return "$" + to_string(parameter_nr);
-}
-
-unique_ptr<ParsedExpression> ParameterExpression::Copy() const {
-	auto copy = make_unique<ParameterExpression>();
-	copy->parameter_nr = parameter_nr;
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-hash_t ParameterExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	return CombineHash(duckdb::Hash(parameter_nr), result);
-}
-
-void ParameterExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(parameter_nr);
-}
-
-unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_unique<ParameterExpression>();
-	expression->parameter_nr = reader.ReadRequired<idx_t>();
-	return move(expression);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-PositionalReferenceExpression::PositionalReferenceExpression(idx_t index)
-    : ParsedExpression(ExpressionType::POSITIONAL_REFERENCE, ExpressionClass::POSITIONAL_REFERENCE), index(index) {
-}
-
-string PositionalReferenceExpression::ToString() const {
-	return "#" + to_string(index);
-}
-
-bool PositionalReferenceExpression::Equals(const PositionalReferenceExpression *a,
-                                           const PositionalReferenceExpression *b) {
-	return a->index == b->index;
-}
-
-unique_ptr<ParsedExpression> PositionalReferenceExpression::Copy() const {
-	auto copy = make_unique<PositionalReferenceExpression>(index);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-hash_t PositionalReferenceExpression::Hash() const {
-	hash_t result = ParsedExpression::Hash();
-	return CombineHash(duckdb::Hash(index), result);
-}
-
-void PositionalReferenceExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(index);
-}
-
-unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_unique<PositionalReferenceExpression>(reader.ReadRequired<idx_t>());
-	return move(expression);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-StarExpression::StarExpression(string relation_name_p)
-    : ParsedExpression(ExpressionType::STAR, ExpressionClass::STAR), relation_name(move(relation_name_p)) {
-}
-
-string StarExpression::ToString() const {
-	string result = relation_name.empty() ? "*" : relation_name + ".*";
-	if (!exclude_list.empty()) {
-		result += " EXCLUDE (";
-		bool first_entry = true;
-		for (auto &entry : exclude_list) {
-			if (!first_entry) {
-				result += ", ";
-			}
-			result += entry;
-			first_entry = false;
-		}
-		result += ")";
-	}
-	if (!replace_list.empty()) {
-		result += " REPLACE (";
-		bool first_entry = true;
-		for (auto &entry : replace_list) {
-			if (!first_entry) {
-				result += ", ";
-			}
-			result += entry.second->ToString();
-			result += " AS ";
-			result += entry.first;
-			first_entry = false;
-		}
-		result += ")";
-	}
-	return result;
-}
-
-bool StarExpression::Equals(const StarExpression *a, const StarExpression *b) {
-	if (a->relation_name != b->relation_name || a->exclude_list != b->exclude_list) {
-		return false;
-	}
-	if (a->replace_list.size() != b->replace_list.size()) {
-		return false;
-	}
-	for (auto &entry : a->replace_list) {
-		auto other_entry = b->replace_list.find(entry.first);
-		if (other_entry == b->replace_list.end()) {
-			return false;
-		}
-		if (!entry.second->Equals(other_entry->second.get())) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void StarExpression::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-
-	writer.WriteString(relation_name);
-
-	// in order to write the exclude_list/replace_list as single fields we directly use the field writers' internal
-	// serializer
-	writer.WriteField<uint32_t>(exclude_list.size());
-	for (auto &exclusion : exclude_list) {
-		serializer.WriteString(exclusion);
-	}
-	writer.WriteField<uint32_t>(replace_list.size());
-	for (auto &entry : replace_list) {
-		serializer.WriteString(entry.first);
-		entry.second->Serialize(serializer);
-	}
-}
-
-unique_ptr<ParsedExpression> StarExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto &source = reader.GetSource();
-
-	auto result = make_unique<StarExpression>();
-	result->relation_name = reader.ReadRequired<string>();
-	auto exclusion_count = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < exclusion_count; i++) {
-		result->exclude_list.insert(source.Read<string>());
-	}
-	auto replace_count = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < replace_count; i++) {
-		auto name = source.Read<string>();
-		auto expr = ParsedExpression::Deserialize(source);
-		result->replace_list.insert(make_pair(name, move(expr)));
-	}
-	return move(result);
-}
-
-unique_ptr<ParsedExpression> StarExpression::Copy() const {
-	auto copy = make_unique<StarExpression>(relation_name);
-	copy->exclude_list = exclude_list;
-	for (auto &entry : replace_list) {
-		copy->replace_list[entry.first] = entry.second->Copy();
-	}
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-SubqueryExpression::SubqueryExpression()
-    : ParsedExpression(ExpressionType::SUBQUERY, ExpressionClass::SUBQUERY), subquery_type(SubqueryType::INVALID),
-      comparison_type(ExpressionType::INVALID) {
-}
-
-string SubqueryExpression::ToString() const {
-	switch (subquery_type) {
-	case SubqueryType::ANY:
-		return child->ToString() + " " + ExpressionTypeToOperator(comparison_type) + " ANY(" + subquery->ToString() +
-		       ")";
-	case SubqueryType::EXISTS:
-		return "EXISTS(" + subquery->ToString() + ")";
-	case SubqueryType::NOT_EXISTS:
-		return "NOT EXISTS(" + subquery->ToString() + ")";
-	case SubqueryType::SCALAR:
-		return "(" + subquery->ToString() + ")";
-	default:
-		throw InternalException("Unrecognized type for subquery");
-	}
-}
-
-bool SubqueryExpression::Equals(const SubqueryExpression *a, const SubqueryExpression *b) {
-	if (!a->subquery || !b->subquery) {
-		return false;
-	}
-	if (!BaseExpression::Equals(a->child.get(), b->child.get())) {
-		return false;
-	}
-	return a->comparison_type == b->comparison_type && a->subquery_type == b->subquery_type &&
-	       a->subquery->Equals(b->subquery.get());
-}
-
-unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {
-	auto copy = make_unique<SubqueryExpression>();
-	copy->CopyProperties(*this);
-	copy->subquery = unique_ptr_cast<SQLStatement, SelectStatement>(subquery->Copy());
-	copy->subquery_type = subquery_type;
-	copy->child = child ? child->Copy() : nullptr;
-	copy->comparison_type = comparison_type;
-	return move(copy);
-}
-
-void SubqueryExpression::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-
-	writer.WriteField<SubqueryType>(subquery_type);
-	// FIXME: this shouldn't use a serializer (probably)?
-	subquery->Serialize(serializer);
-	writer.WriteOptional(child);
-	writer.WriteField<ExpressionType>(comparison_type);
-}
-
-unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	// FIXME: this shouldn't use a source
-	auto &source = reader.GetSource();
-
-	auto subquery_type = reader.ReadRequired<SubqueryType>();
-	auto subquery = SelectStatement::Deserialize(source);
-
-	auto expression = make_unique<SubqueryExpression>();
-	expression->subquery_type = subquery_type;
-	expression->subquery = move(subquery);
-	expression->child = reader.ReadOptional<ParsedExpression>(nullptr);
-	expression->comparison_type = reader.ReadRequired<ExpressionType>();
-	return move(expression);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-WindowExpression::WindowExpression(ExpressionType type, string schema, const string &function_name)
-    : ParsedExpression(type, ExpressionClass::WINDOW), schema(move(schema)),
-      function_name(StringUtil::Lower(function_name)), ignore_nulls(false) {
-	switch (type) {
-	case ExpressionType::WINDOW_AGGREGATE:
-	case ExpressionType::WINDOW_ROW_NUMBER:
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_LAST_VALUE:
-	case ExpressionType::WINDOW_NTH_VALUE:
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_RANK_DENSE:
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_CUME_DIST:
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-	case ExpressionType::WINDOW_NTILE:
-		break;
-	default:
-		throw NotImplementedException("Window aggregate type %s not supported", ExpressionTypeToString(type).c_str());
-	}
-}
-
-string WindowExpression::ToString() const {
-	return ToString<WindowExpression, ParsedExpression, OrderByNode>(*this, schema, function_name);
-}
-
-bool WindowExpression::Equals(const WindowExpression *a, const WindowExpression *b) {
-	// check if the child expressions are equivalent
-	if (b->children.size() != a->children.size()) {
-		return false;
-	}
-	if (a->ignore_nulls != b->ignore_nulls) {
-		return false;
-	}
-	for (idx_t i = 0; i < a->children.size(); i++) {
-		if (!a->children[i]->Equals(b->children[i].get())) {
-			return false;
-		}
-	}
-	if (a->start != b->start || a->end != b->end) {
-		return false;
-	}
-	// check if the framing expressions are equivalent
-	if (!BaseExpression::Equals(a->start_expr.get(), b->start_expr.get()) ||
-	    !BaseExpression::Equals(a->end_expr.get(), b->end_expr.get()) ||
-	    !BaseExpression::Equals(a->offset_expr.get(), b->offset_expr.get()) ||
-	    !BaseExpression::Equals(a->default_expr.get(), b->default_expr.get())) {
-		return false;
-	}
-
-	// check if the partitions are equivalent
-	if (a->partitions.size() != b->partitions.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a->partitions.size(); i++) {
-		if (!a->partitions[i]->Equals(b->partitions[i].get())) {
-			return false;
-		}
-	}
-	// check if the orderings are equivalent
-	if (a->orders.size() != b->orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a->orders.size(); i++) {
-		if (a->orders[i].type != b->orders[i].type) {
-			return false;
-		}
-		if (!a->orders[i].expression->Equals(b->orders[i].expression.get())) {
-			return false;
-		}
-	}
-	// check if the filter clauses are equivalent
-	if (!BaseExpression::Equals(a->filter_expr.get(), b->filter_expr.get())) {
-		return false;
-	}
-
-	return true;
-}
-
-unique_ptr<ParsedExpression> WindowExpression::Copy() const {
-	auto new_window = make_unique<WindowExpression>(type, schema, function_name);
-	new_window->CopyProperties(*this);
-
-	for (auto &child : children) {
-		new_window->children.push_back(child->Copy());
-	}
-
-	for (auto &e : partitions) {
-		new_window->partitions.push_back(e->Copy());
-	}
-
-	for (auto &o : orders) {
-		new_window->orders.emplace_back(o.type, o.null_order, o.expression->Copy());
-	}
-
-	new_window->filter_expr = filter_expr ? filter_expr->Copy() : nullptr;
-
-	new_window->start = start;
-	new_window->end = end;
-	new_window->start_expr = start_expr ? start_expr->Copy() : nullptr;
-	new_window->end_expr = end_expr ? end_expr->Copy() : nullptr;
-	new_window->offset_expr = offset_expr ? offset_expr->Copy() : nullptr;
-	new_window->default_expr = default_expr ? default_expr->Copy() : nullptr;
-	new_window->ignore_nulls = ignore_nulls;
-
-	return move(new_window);
-}
-
-void WindowExpression::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-
-	writer.WriteString(function_name);
-	writer.WriteString(schema);
-	writer.WriteSerializableList(children);
-	writer.WriteSerializableList(partitions);
-	// FIXME: should not use serializer here (probably)?
-	D_ASSERT(orders.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteField<uint32_t>((uint32_t)orders.size());
-	for (auto &order : orders) {
-		order.Serialize(serializer);
-	}
-	writer.WriteField<WindowBoundary>(start);
-	writer.WriteField<WindowBoundary>(end);
-
-	writer.WriteOptional(start_expr);
-	writer.WriteOptional(end_expr);
-	writer.WriteOptional(offset_expr);
-	writer.WriteOptional(default_expr);
-	writer.WriteField<bool>(ignore_nulls);
-	writer.WriteOptional(filter_expr);
-}
-
-unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto function_name = reader.ReadRequired<string>();
-	auto schema = reader.ReadRequired<string>();
-	auto expr = make_unique<WindowExpression>(type, schema, function_name);
-	expr->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	expr->partitions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	auto order_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < order_count; i++) {
-		expr->orders.push_back(OrderByNode::Deserialize((source)));
-	}
-	expr->start = reader.ReadRequired<WindowBoundary>();
-	expr->end = reader.ReadRequired<WindowBoundary>();
-
-	expr->start_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->end_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->offset_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->default_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->ignore_nulls = reader.ReadRequired<bool>();
-	expr->filter_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	return move(expr);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-bool ExpressionUtil::ExpressionListEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b) {
-	if (a.size() != b.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < a.size(); i++) {
-		if (!(*a[i] == *b[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-template <class T>
-bool ExpressionUtil::ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b) {
-	if (a.size() != b.size()) {
-		return false;
-	}
-	// we create a map of expression -> count for the left side
-	// we keep the count because the same expression can occur multiple times (e.g. "1 AND 1" is legal)
-	// in this case we track the following value: map["Constant(1)"] = 2
-	expression_map_t<idx_t> map;
-	for (idx_t i = 0; i < a.size(); i++) {
-		map[a[i].get()]++;
-	}
-	// now on the right side we reduce the counts again
-	// if the conjunctions are identical, all the counts will be 0 after the
-	for (auto &expr : b) {
-		auto entry = map.find(expr.get());
-		// first we check if we can find the expression in the map at all
-		if (entry == map.end()) {
-			return false;
-		}
-		// if we found it we check the count; if the count is already 0 we return false
-		// this happens if e.g. the left side contains "1 AND X", and the right side contains "1 AND 1"
-		// "1" is contained in the map, however, the right side contains the expression twice
-		// hence we know the children are not identical in this case because the LHS and RHS have a different count for
-		// the Constant(1) expression
-		if (entry->second == 0) {
-			return false;
-		}
-		entry->second--;
-	}
-	return true;
-}
-
-bool ExpressionUtil::ListEquals(const vector<unique_ptr<ParsedExpression>> &a,
-                                const vector<unique_ptr<ParsedExpression>> &b) {
-	return ExpressionListEquals<ParsedExpression>(a, b);
-}
-
-bool ExpressionUtil::ListEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b) {
-	return ExpressionListEquals<Expression>(a, b);
-}
-
-bool ExpressionUtil::SetEquals(const vector<unique_ptr<ParsedExpression>> &a,
-                               const vector<unique_ptr<ParsedExpression>> &b) {
-	return ExpressionSetEquals<ParsedExpression>(a, b);
-}
-
-bool ExpressionUtil::SetEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b) {
-	return ExpressionSetEquals<Expression>(a, b);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-bool KeywordHelper::IsKeyword(const string &text) {
-	return Parser::IsKeyword(text);
-}
-
-bool KeywordHelper::RequiresQuotes(const string &text) {
-	for (size_t i = 0; i < text.size(); i++) {
-		if (i > 0 && (text[i] >= '0' && text[i] <= '9')) {
-			continue;
-		}
-		if (text[i] >= 'a' && text[i] <= 'z') {
-			continue;
-		}
-		if (text[i] == '_') {
-			continue;
-		}
-		return true;
-	}
-	return IsKeyword(text);
-}
-
-string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote) {
-	if (!RequiresQuotes(text)) {
-		return text;
-	}
-	return string(1, quote) + StringUtil::Replace(text, string(1, quote), string(2, quote)) + string(1, quote);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-AlterInfo::AlterInfo(AlterType type, string schema_p, string name_p)
-    : type(type), schema(move(schema_p)), name(move(name_p)) {
-}
-
-AlterInfo::~AlterInfo() {
-}
-
-void AlterInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<AlterType>(type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<AlterInfo> AlterInfo::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<AlterType>();
-
-	unique_ptr<AlterInfo> result;
-	switch (type) {
-	case AlterType::ALTER_TABLE:
-		result = AlterTableInfo::Deserialize(reader);
-		break;
-	case AlterType::ALTER_VIEW:
-		result = AlterViewInfo::Deserialize(reader);
-		break;
-	default:
-		throw SerializationException("Unknown alter type for deserialization!");
-	}
-	reader.Finalize();
-
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// ChangeOwnershipInfo
-//===--------------------------------------------------------------------===//
-ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_schema_p, string entry_name_p,
-                                         string owner_schema_p, string owner_name_p)
-    : AlterInfo(AlterType::CHANGE_OWNERSHIP, move(entry_schema_p), move(entry_name_p)),
-      entry_catalog_type(entry_catalog_type), owner_schema(move(owner_schema_p)), owner_name(move(owner_name_p)) {
-}
-
-CatalogType ChangeOwnershipInfo::GetCatalogType() const {
-	return entry_catalog_type;
-}
-
-unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
-	return make_unique_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, schema, name, owner_schema, owner_name);
-}
-
-void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
-	throw InternalException("ChangeOwnershipInfo cannot be serialized");
-}
-
-//===--------------------------------------------------------------------===//
-// AlterTableInfo
-//===--------------------------------------------------------------------===//
-AlterTableInfo::AlterTableInfo(AlterTableType type, string schema_p, string table_p)
-    : AlterInfo(AlterType::ALTER_TABLE, move(move(schema_p)), move(table_p)), alter_table_type(type) {
-}
-AlterTableInfo::~AlterTableInfo() {
-}
-
-CatalogType AlterTableInfo::GetCatalogType() const {
-	return CatalogType::TABLE_ENTRY;
-}
-
-void AlterTableInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<AlterTableType>(alter_table_type);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	SerializeAlterTable(writer);
-}
-
-unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
-	auto type = reader.ReadRequired<AlterTableType>();
-	auto schema = reader.ReadRequired<string>();
-	auto table = reader.ReadRequired<string>();
-	unique_ptr<AlterTableInfo> info;
-	switch (type) {
-	case AlterTableType::RENAME_COLUMN:
-		return RenameColumnInfo::Deserialize(reader, schema, table);
-	case AlterTableType::RENAME_TABLE:
-		return RenameTableInfo::Deserialize(reader, schema, table);
-	case AlterTableType::ADD_COLUMN:
-		return AddColumnInfo::Deserialize(reader, schema, table);
-	case AlterTableType::REMOVE_COLUMN:
-		return RemoveColumnInfo::Deserialize(reader, schema, table);
-	case AlterTableType::ALTER_COLUMN_TYPE:
-		return ChangeColumnTypeInfo::Deserialize(reader, schema, table);
-	case AlterTableType::SET_DEFAULT:
-		return SetDefaultInfo::Deserialize(reader, schema, table);
-	case AlterTableType::FOREIGN_KEY_CONSTRAINT:
-		return AlterForeignKeyInfo::Deserialize(reader, schema, table);
-	default:
-		throw SerializationException("Unknown alter table type for deserialization!");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// RenameColumnInfo
-//===--------------------------------------------------------------------===//
-RenameColumnInfo::RenameColumnInfo(string schema_p, string table_p, string old_name_p, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_COLUMN, move(schema_p), move(table_p)), old_name(move(old_name_p)),
-      new_name(move(new_name_p)) {
-}
-RenameColumnInfo::~RenameColumnInfo() {
-}
-
-unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameColumnInfo>(schema, name, old_name, new_name);
-}
-
-void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(old_name);
-	writer.WriteString(new_name);
-}
-
-unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
-	auto old_name = reader.ReadRequired<string>();
-	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameColumnInfo>(move(schema), move(table), old_name, new_name);
-}
-
-//===--------------------------------------------------------------------===//
-// RenameTableInfo
-//===--------------------------------------------------------------------===//
-RenameTableInfo::RenameTableInfo(string schema_p, string table_p, string new_name_p)
-    : AlterTableInfo(AlterTableType::RENAME_TABLE, move(schema_p), move(table_p)), new_table_name(move(new_name_p)) {
-}
-RenameTableInfo::~RenameTableInfo() {
-}
-
-unique_ptr<AlterInfo> RenameTableInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameTableInfo>(schema, name, new_table_name);
-}
-
-void RenameTableInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(new_table_name);
-}
-
-unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, string schema, string table) {
-	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameTableInfo>(move(schema), move(table), new_name);
-}
-
-//===--------------------------------------------------------------------===//
-// AddColumnInfo
-//===--------------------------------------------------------------------===//
-AddColumnInfo::AddColumnInfo(string schema_p, string table_p, ColumnDefinition new_column)
-    : AlterTableInfo(AlterTableType::ADD_COLUMN, move(schema_p), move(table_p)), new_column(move(new_column)) {
-}
-AddColumnInfo::~AddColumnInfo() {
-}
-
-unique_ptr<AlterInfo> AddColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, AddColumnInfo>(schema, name, new_column.Copy());
-}
-
-void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteSerializable(new_column);
-}
-
-unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
-	auto new_column = reader.ReadRequiredSerializable<ColumnDefinition, ColumnDefinition>();
-	return make_unique<AddColumnInfo>(move(schema), move(table), move(new_column));
-}
-
-//===--------------------------------------------------------------------===//
-// RemoveColumnInfo
-//===--------------------------------------------------------------------===//
-RemoveColumnInfo::RemoveColumnInfo(string schema, string table, string removed_column, bool if_exists, bool cascade)
-    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, move(schema), move(table)), removed_column(move(removed_column)),
-      if_exists(if_exists), cascade(cascade) {
-}
-RemoveColumnInfo::~RemoveColumnInfo() {
-}
-
-unique_ptr<AlterInfo> RemoveColumnInfo::Copy() const {
-	return make_unique_base<AlterInfo, RemoveColumnInfo>(schema, name, removed_column, if_exists, cascade);
-}
-
-void RemoveColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(removed_column);
-	writer.WriteField<bool>(if_exists);
-	writer.WriteField<bool>(cascade);
-}
-
-unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
-	auto new_name = reader.ReadRequired<string>();
-	auto if_exists = reader.ReadRequired<bool>();
-	auto cascade = reader.ReadRequired<bool>();
-	return make_unique<RemoveColumnInfo>(move(schema), move(table), new_name, if_exists, cascade);
-}
-
-//===--------------------------------------------------------------------===//
-// ChangeColumnTypeInfo
-//===--------------------------------------------------------------------===//
-ChangeColumnTypeInfo::ChangeColumnTypeInfo(string schema_p, string table_p, string column_name, LogicalType target_type,
-                                           unique_ptr<ParsedExpression> expression)
-    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, move(schema_p), move(table_p)), column_name(move(column_name)),
-      target_type(move(target_type)), expression(move(expression)) {
-}
-ChangeColumnTypeInfo::~ChangeColumnTypeInfo() {
-}
-
-unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
-	return make_unique_base<AlterInfo, ChangeColumnTypeInfo>(schema, name, column_name, target_type,
-	                                                         expression->Copy());
-}
-
-void ChangeColumnTypeInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(column_name);
-	writer.WriteSerializable(target_type);
-	writer.WriteOptional(expression);
-}
-
-unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, string schema, string table) {
-	auto column_name = reader.ReadRequired<string>();
-	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<ChangeColumnTypeInfo>(move(schema), move(table), move(column_name), move(target_type),
-	                                         move(expression));
-}
-
-//===--------------------------------------------------------------------===//
-// SetDefaultInfo
-//===--------------------------------------------------------------------===//
-SetDefaultInfo::SetDefaultInfo(string schema_p, string table_p, string column_name_p,
-                               unique_ptr<ParsedExpression> new_default)
-    : AlterTableInfo(AlterTableType::SET_DEFAULT, move(schema_p), move(table_p)), column_name(move(column_name_p)),
-      expression(move(new_default)) {
-}
-SetDefaultInfo::~SetDefaultInfo() {
-}
-
-unique_ptr<AlterInfo> SetDefaultInfo::Copy() const {
-	return make_unique_base<AlterInfo, SetDefaultInfo>(schema, name, column_name,
-	                                                   expression ? expression->Copy() : nullptr);
-}
-
-void SetDefaultInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(column_name);
-	writer.WriteOptional(expression);
-}
-
-unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, string schema, string table) {
-	auto column_name = reader.ReadRequired<string>();
-	auto new_default = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_unique<SetDefaultInfo>(move(schema), move(table), move(column_name), move(new_default));
-}
-
-//===--------------------------------------------------------------------===//
-// AlterForeignKeyInfo
-//===--------------------------------------------------------------------===//
-AlterForeignKeyInfo::AlterForeignKeyInfo(string schema_p, string table_p, string fk_table, vector<string> pk_columns,
-                                         vector<string> fk_columns, vector<idx_t> pk_keys, vector<idx_t> fk_keys,
-                                         AlterForeignKeyType type_p)
-    : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT, move(schema_p), move(table_p)), fk_table(move(fk_table)),
-      pk_columns(move(pk_columns)), fk_columns(move(fk_columns)), pk_keys(move(pk_keys)), fk_keys(move(fk_keys)),
-      type(type_p) {
-}
-AlterForeignKeyInfo::~AlterForeignKeyInfo() {
-}
-
-unique_ptr<AlterInfo> AlterForeignKeyInfo::Copy() const {
-	return make_unique_base<AlterInfo, AlterForeignKeyInfo>(schema, name, fk_table, pk_columns, fk_columns, pk_keys,
-	                                                        fk_keys, type);
-}
-
-void AlterForeignKeyInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(fk_table);
-	writer.WriteList<string>(pk_columns);
-	writer.WriteList<string>(fk_columns);
-	writer.WriteList<idx_t>(pk_keys);
-	writer.WriteList<idx_t>(fk_keys);
-	writer.WriteField<AlterForeignKeyType>(type);
-}
-
-unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, string schema, string table) {
-	auto fk_table = reader.ReadRequired<string>();
-	auto pk_columns = reader.ReadRequiredList<string>();
-	auto fk_columns = reader.ReadRequiredList<string>();
-	auto pk_keys = reader.ReadRequiredList<idx_t>();
-	auto fk_keys = reader.ReadRequiredList<idx_t>();
-	auto type = reader.ReadRequired<AlterForeignKeyType>();
-	return make_unique<AlterForeignKeyInfo>(move(schema), move(table), move(fk_table), move(pk_columns),
-	                                        move(fk_columns), move(pk_keys), move(fk_keys), type);
-}
-
-//===--------------------------------------------------------------------===//
-// Alter View
-//===--------------------------------------------------------------------===//
-AlterViewInfo::AlterViewInfo(AlterViewType type, string schema_p, string view_p)
-    : AlterInfo(AlterType::ALTER_VIEW, move(schema_p), move(view_p)), alter_view_type(type) {
-}
-AlterViewInfo::~AlterViewInfo() {
-}
-
-CatalogType AlterViewInfo::GetCatalogType() const {
-	return CatalogType::VIEW_ENTRY;
-}
-
-void AlterViewInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<AlterViewType>(alter_view_type);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	SerializeAlterView(writer);
-}
-
-unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
-	auto type = reader.ReadRequired<AlterViewType>();
-	auto schema = reader.ReadRequired<string>();
-	auto view = reader.ReadRequired<string>();
-	unique_ptr<AlterViewInfo> info;
-	switch (type) {
-	case AlterViewType::RENAME_VIEW:
-		return RenameViewInfo::Deserialize(reader, schema, view);
-	default:
-		throw SerializationException("Unknown alter view type for deserialization!");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// RenameViewInfo
-//===--------------------------------------------------------------------===//
-RenameViewInfo::RenameViewInfo(string schema_p, string view_p, string new_name_p)
-    : AlterViewInfo(AlterViewType::RENAME_VIEW, move(schema_p), move(view_p)), new_view_name(move(new_name_p)) {
-}
-RenameViewInfo::~RenameViewInfo() {
-}
-
-unique_ptr<AlterInfo> RenameViewInfo::Copy() const {
-	return make_unique_base<AlterInfo, RenameViewInfo>(schema, name, new_view_name);
-}
-
-void RenameViewInfo::SerializeAlterView(FieldWriter &writer) const {
-	writer.WriteString(new_view_name);
-}
-
-unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, string schema, string view) {
-	auto new_name = reader.ReadRequired<string>();
-	return make_unique<RenameViewInfo>(move(schema), move(view), new_name);
-}
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-string SampleMethodToString(SampleMethod method) {
-	switch (method) {
-	case SampleMethod::SYSTEM_SAMPLE:
-		return "System";
-	case SampleMethod::BERNOULLI_SAMPLE:
-		return "Bernoulli";
-	case SampleMethod::RESERVOIR_SAMPLE:
-		return "Reservoir";
-	default:
-		return "Unknown";
-	}
-}
-
-void SampleOptions::Serialize(Serializer &serializer) {
-	FieldWriter writer(serializer);
-	writer.WriteSerializable(sample_size);
-	writer.WriteField<bool>(is_percentage);
-	writer.WriteField<SampleMethod>(method);
-	writer.WriteField<int64_t>(seed);
-	writer.Finalize();
-}
-
-unique_ptr<SampleOptions> SampleOptions::Deserialize(Deserializer &source) {
-	auto result = make_unique<SampleOptions>();
-
-	FieldReader reader(source);
-	result->sample_size = reader.ReadRequiredSerializable<Value, Value>();
-	result->is_percentage = reader.ReadRequired<bool>();
-	result->method = reader.ReadRequired<SampleMethod>();
-	result->seed = reader.ReadRequired<int64_t>();
-	reader.Finalize();
-
-	return result;
-}
-
-unique_ptr<SampleOptions> SampleOptions::Copy() {
-	auto result = make_unique<SampleOptions>();
-	result->sample_size = sample_size;
-	result->is_percentage = is_percentage;
-	result->method = method;
-	result->seed = seed;
-	return result;
-}
-
-bool SampleOptions::Equals(SampleOptions *a, SampleOptions *b) {
-	if (a == b) {
-		return true;
-	}
-	if (!a || !b) {
-		return false;
-	}
-	if (a->sample_size != b->sample_size || a->is_percentage != b->is_percentage || a->method != b->method ||
-	    a->seed != b->seed) {
-		return false;
-	}
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-bool ParsedExpression::IsAggregate() const {
-	bool is_aggregate = false;
-	ParsedExpressionIterator::EnumerateChildren(
-	    *this, [&](const ParsedExpression &child) { is_aggregate |= child.IsAggregate(); });
-	return is_aggregate;
-}
-
-bool ParsedExpression::IsWindow() const {
-	bool is_window = false;
-	ParsedExpressionIterator::EnumerateChildren(*this,
-	                                            [&](const ParsedExpression &child) { is_window |= child.IsWindow(); });
-	return is_window;
-}
-
-bool ParsedExpression::IsScalar() const {
-	bool is_scalar = true;
-	ParsedExpressionIterator::EnumerateChildren(*this, [&](const ParsedExpression &child) {
-		if (!child.IsScalar()) {
-			is_scalar = false;
-		}
-	});
-	return is_scalar;
-}
-
-bool ParsedExpression::HasParameter() const {
-	bool has_parameter = false;
-	ParsedExpressionIterator::EnumerateChildren(
-	    *this, [&](const ParsedExpression &child) { has_parameter |= child.HasParameter(); });
-	return has_parameter;
-}
-
-bool ParsedExpression::HasSubquery() const {
-	bool has_subquery = false;
-	ParsedExpressionIterator::EnumerateChildren(
-	    *this, [&](const ParsedExpression &child) { has_subquery |= child.HasSubquery(); });
-	return has_subquery;
-}
-
-bool ParsedExpression::Equals(const BaseExpression *other) const {
-	if (!BaseExpression::Equals(other)) {
-		return false;
-	}
-	switch (expression_class) {
-	case ExpressionClass::BETWEEN:
-		return BetweenExpression::Equals((BetweenExpression *)this, (BetweenExpression *)other);
-	case ExpressionClass::CASE:
-		return CaseExpression::Equals((CaseExpression *)this, (CaseExpression *)other);
-	case ExpressionClass::CAST:
-		return CastExpression::Equals((CastExpression *)this, (CastExpression *)other);
-	case ExpressionClass::COLLATE:
-		return CollateExpression::Equals((CollateExpression *)this, (CollateExpression *)other);
-	case ExpressionClass::COLUMN_REF:
-		return ColumnRefExpression::Equals((ColumnRefExpression *)this, (ColumnRefExpression *)other);
-	case ExpressionClass::COMPARISON:
-		return ComparisonExpression::Equals((ComparisonExpression *)this, (ComparisonExpression *)other);
-	case ExpressionClass::CONJUNCTION:
-		return ConjunctionExpression::Equals((ConjunctionExpression *)this, (ConjunctionExpression *)other);
-	case ExpressionClass::CONSTANT:
-		return ConstantExpression::Equals((ConstantExpression *)this, (ConstantExpression *)other);
-	case ExpressionClass::DEFAULT:
-		return true;
-	case ExpressionClass::FUNCTION:
-		return FunctionExpression::Equals((FunctionExpression *)this, (FunctionExpression *)other);
-	case ExpressionClass::LAMBDA:
-		return LambdaExpression::Equals((LambdaExpression *)this, (LambdaExpression *)other);
-	case ExpressionClass::OPERATOR:
-		return OperatorExpression::Equals((OperatorExpression *)this, (OperatorExpression *)other);
-	case ExpressionClass::PARAMETER:
-		return true;
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return PositionalReferenceExpression::Equals((PositionalReferenceExpression *)this,
-		                                             (PositionalReferenceExpression *)other);
-	case ExpressionClass::STAR:
-		return StarExpression::Equals((StarExpression *)this, (StarExpression *)other);
-	case ExpressionClass::SUBQUERY:
-		return SubqueryExpression::Equals((SubqueryExpression *)this, (SubqueryExpression *)other);
-	case ExpressionClass::WINDOW:
-		return WindowExpression::Equals((WindowExpression *)this, (WindowExpression *)other);
-	default:
-		throw SerializationException("Unsupported type for expression comparison!");
-	}
-}
-
-hash_t ParsedExpression::Hash() const {
-	hash_t hash = duckdb::Hash<uint32_t>((uint32_t)type);
-	ParsedExpressionIterator::EnumerateChildren(
-	    *this, [&](const ParsedExpression &child) { hash = CombineHash(child.Hash(), hash); });
-	return hash;
-}
-
-void ParsedExpression::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ExpressionClass>(GetExpressionClass());
-	writer.WriteField<ExpressionType>(type);
-	writer.WriteString(alias);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto expression_class = reader.ReadRequired<ExpressionClass>();
-	auto type = reader.ReadRequired<ExpressionType>();
-	auto alias = reader.ReadRequired<string>();
-	unique_ptr<ParsedExpression> result;
-	switch (expression_class) {
-	case ExpressionClass::BETWEEN:
-		result = BetweenExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CASE:
-		result = CaseExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CAST:
-		result = CastExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COLLATE:
-		result = CollateExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COLUMN_REF:
-		result = ColumnRefExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COMPARISON:
-		result = ComparisonExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CONJUNCTION:
-		result = ConjunctionExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CONSTANT:
-		result = ConstantExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::DEFAULT:
-		result = DefaultExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::FUNCTION:
-		result = FunctionExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::LAMBDA:
-		result = LambdaExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::OPERATOR:
-		result = OperatorExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::PARAMETER:
-		result = ParameterExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		result = PositionalReferenceExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::STAR:
-		result = StarExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::SUBQUERY:
-		result = SubqueryExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::WINDOW:
-		result = WindowExpression::Deserialize(type, reader);
-		break;
-	default:
-		throw SerializationException("Unsupported type for expression deserialization!");
-	}
-	result->alias = alias;
-	reader.Finalize();
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void ParsedExpressionIterator::EnumerateChildren(const ParsedExpression &expression,
-                                                 const std::function<void(const ParsedExpression &child)> &callback) {
-	EnumerateChildren((ParsedExpression &)expression, [&](unique_ptr<ParsedExpression> &child) {
-		D_ASSERT(child);
-		callback(*child);
-	});
-}
-
-void ParsedExpressionIterator::EnumerateChildren(ParsedExpression &expr,
-                                                 const std::function<void(ParsedExpression &child)> &callback) {
-	EnumerateChildren(expr, [&](unique_ptr<ParsedExpression> &child) {
-		D_ASSERT(child);
-		callback(*child);
-	});
-}
-
-void ParsedExpressionIterator::EnumerateChildren(
-    ParsedExpression &expr, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
-	switch (expr.expression_class) {
-	case ExpressionClass::BETWEEN: {
-		auto &cast_expr = (BetweenExpression &)expr;
-		callback(cast_expr.input);
-		callback(cast_expr.lower);
-		callback(cast_expr.upper);
-		break;
-	}
-	case ExpressionClass::CASE: {
-		auto &case_expr = (CaseExpression &)expr;
-		for (auto &check : case_expr.case_checks) {
-			callback(check.when_expr);
-			callback(check.then_expr);
-		}
-		callback(case_expr.else_expr);
-		break;
-	}
-	case ExpressionClass::CAST: {
-		auto &cast_expr = (CastExpression &)expr;
-		callback(cast_expr.child);
-		break;
-	}
-	case ExpressionClass::COLLATE: {
-		auto &cast_expr = (CollateExpression &)expr;
-		callback(cast_expr.child);
-		break;
-	}
-	case ExpressionClass::COMPARISON: {
-		auto &comp_expr = (ComparisonExpression &)expr;
-		callback(comp_expr.left);
-		callback(comp_expr.right);
-		break;
-	}
-	case ExpressionClass::CONJUNCTION: {
-		auto &conj_expr = (ConjunctionExpression &)expr;
-		for (auto &child : conj_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-
-	case ExpressionClass::FUNCTION: {
-		auto &func_expr = (FunctionExpression &)expr;
-		for (auto &child : func_expr.children) {
-			callback(child);
-		}
-		if (func_expr.filter) {
-			callback(func_expr.filter);
-		}
-		if (func_expr.order_bys) {
-			for (auto &order : func_expr.order_bys->orders) {
-				callback(order.expression);
-			}
-		}
-		break;
-	}
-	case ExpressionClass::LAMBDA: {
-		auto &lambda_expr = (LambdaExpression &)expr;
-		callback(lambda_expr.lhs);
-		callback(lambda_expr.rhs);
-		break;
-	}
-	case ExpressionClass::OPERATOR: {
-		auto &op_expr = (OperatorExpression &)expr;
-		for (auto &child : op_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::SUBQUERY: {
-		auto &subquery_expr = (SubqueryExpression &)expr;
-		if (subquery_expr.child) {
-			callback(subquery_expr.child);
-		}
-		break;
-	}
-	case ExpressionClass::WINDOW: {
-		auto &window_expr = (WindowExpression &)expr;
-		for (auto &partition : window_expr.partitions) {
-			callback(partition);
-		}
-		for (auto &order : window_expr.orders) {
-			callback(order.expression);
-		}
-		for (auto &child : window_expr.children) {
-			callback(child);
-		}
-		if (window_expr.filter_expr) {
-			callback(window_expr.filter_expr);
-		}
-		if (window_expr.start_expr) {
-			callback(window_expr.start_expr);
-		}
-		if (window_expr.end_expr) {
-			callback(window_expr.end_expr);
-		}
-		if (window_expr.offset_expr) {
-			callback(window_expr.offset_expr);
-		}
-		if (window_expr.default_expr) {
-			callback(window_expr.default_expr);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_EXPRESSION:
-	case ExpressionClass::COLUMN_REF:
-	case ExpressionClass::CONSTANT:
-	case ExpressionClass::DEFAULT:
-	case ExpressionClass::STAR:
-	case ExpressionClass::PARAMETER:
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		// these node types have no children
-		break;
-	default:
-		// called on non ParsedExpression type!
-		throw NotImplementedException("Unimplemented expression class");
-	}
-}
-
-void ParsedExpressionIterator::EnumerateQueryNodeModifiers(
-    QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
-
-	for (auto &modifier : node.modifiers) {
-		switch (modifier->type) {
-		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &limit_modifier = (LimitModifier &)*modifier;
-			if (limit_modifier.limit) {
-				callback(limit_modifier.limit);
-			}
-			if (limit_modifier.offset) {
-				callback(limit_modifier.offset);
-			}
-		} break;
-
-		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &limit_modifier = (LimitPercentModifier &)*modifier;
-			if (limit_modifier.limit) {
-				callback(limit_modifier.limit);
-			}
-			if (limit_modifier.offset) {
-				callback(limit_modifier.offset);
-			}
-		} break;
-
-		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order_modifier = (OrderModifier &)*modifier;
-			for (auto &order : order_modifier.orders) {
-				callback(order.expression);
-			}
-		} break;
-
-		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct_modifier = (DistinctModifier &)*modifier;
-			for (auto &target : distinct_modifier.distinct_on_targets) {
-				callback(target);
-			}
-		} break;
-
-		// do nothing
-		default:
-			break;
-		}
-	}
-}
-
-void ParsedExpressionIterator::EnumerateTableRefChildren(
-    TableRef &ref, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
-	switch (ref.type) {
-	case TableReferenceType::CROSS_PRODUCT: {
-		auto &cp_ref = (CrossProductRef &)ref;
-		EnumerateTableRefChildren(*cp_ref.left, callback);
-		EnumerateTableRefChildren(*cp_ref.right, callback);
-		break;
-	}
-	case TableReferenceType::EXPRESSION_LIST: {
-		auto &el_ref = (ExpressionListRef &)ref;
-		for (idx_t i = 0; i < el_ref.values.size(); i++) {
-			for (idx_t j = 0; j < el_ref.values[i].size(); j++) {
-				callback(el_ref.values[i][j]);
-			}
-		}
-		break;
-	}
-	case TableReferenceType::JOIN: {
-		auto &j_ref = (JoinRef &)ref;
-		EnumerateTableRefChildren(*j_ref.left, callback);
-		EnumerateTableRefChildren(*j_ref.right, callback);
-		callback(j_ref.condition);
-		break;
-	}
-	case TableReferenceType::SUBQUERY: {
-		auto &sq_ref = (SubqueryRef &)ref;
-		EnumerateQueryNodeChildren(*sq_ref.subquery->node, callback);
-		break;
-	}
-	case TableReferenceType::TABLE_FUNCTION: {
-		auto &tf_ref = (TableFunctionRef &)ref;
-		callback(tf_ref.function);
-		break;
-	}
-	case TableReferenceType::BASE_TABLE:
-	case TableReferenceType::EMPTY:
-		// these TableRefs do not need to be unfolded
-		break;
-	default:
-		throw NotImplementedException("TableRef type not implemented for traversal");
-	}
-}
-
-void ParsedExpressionIterator::EnumerateQueryNodeChildren(
-    QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
-	switch (node.type) {
-	case QueryNodeType::RECURSIVE_CTE_NODE: {
-		auto &rcte_node = (RecursiveCTENode &)node;
-		EnumerateQueryNodeChildren(*rcte_node.left, callback);
-		EnumerateQueryNodeChildren(*rcte_node.right, callback);
-		break;
-	}
-	case QueryNodeType::SELECT_NODE: {
-		auto &sel_node = (SelectNode &)node;
-		for (idx_t i = 0; i < sel_node.select_list.size(); i++) {
-			callback(sel_node.select_list[i]);
-		}
-		for (idx_t i = 0; i < sel_node.groups.group_expressions.size(); i++) {
-			callback(sel_node.groups.group_expressions[i]);
-		}
-		if (sel_node.where_clause) {
-			callback(sel_node.where_clause);
-		}
-		if (sel_node.having) {
-			callback(sel_node.having);
-		}
-		if (sel_node.qualify) {
-			callback(sel_node.qualify);
-		}
-
-		EnumerateTableRefChildren(*sel_node.from_table.get(), callback);
-		break;
-	}
-	case QueryNodeType::SET_OPERATION_NODE: {
-		auto &setop_node = (SetOperationNode &)node;
-		EnumerateQueryNodeChildren(*setop_node.left, callback);
-		EnumerateQueryNodeChildren(*setop_node.right, callback);
-		break;
-	}
-	default:
-		throw NotImplementedException("QueryNode type not implemented for traversal");
-	}
-
-	if (!node.modifiers.empty()) {
-		EnumerateQueryNodeModifiers(node, callback);
-	}
-
-	for (auto &kv : node.cte_map.map) {
-		EnumerateQueryNodeChildren(*kv.second->query->node, callback);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-Parser::Parser(ParserOptions options_p) : options(options_p) {
-}
-
-void Parser::ParseQuery(const string &query) {
-	Transformer transformer(options.max_expression_depth);
-	{
-		PostgresParser::SetPreserveIdentifierCase(options.preserve_identifier_case);
-		PostgresParser parser;
-		parser.Parse(query);
-
-		if (!parser.success) {
-			if (options.extensions) {
-				for (auto &ext : *options.extensions) {
-					D_ASSERT(ext.parse_function);
-					auto result = ext.parse_function(ext.parser_info.get(), query);
-					if (result.type == ParserExtensionResultType::PARSE_SUCCESSFUL) {
-						auto statement = make_unique<ExtensionStatement>(ext, move(result.parse_data));
-						statement->stmt_length = query.size();
-						statement->stmt_location = 0;
-						statements.push_back(move(statement));
-						return;
-					}
-					if (result.type == ParserExtensionResultType::DISPLAY_EXTENSION_ERROR) {
-						throw ParserException(result.error);
-					}
-				}
-			}
-			throw ParserException(QueryErrorContext::Format(query, parser.error_message, parser.error_location - 1));
-		}
-
-		if (!parser.parse_tree) {
-			// empty statement
-			return;
-		}
-
-		// if it succeeded, we transform the Postgres parse tree into a list of
-		// SQLStatements
-		transformer.TransformParseTree(parser.parse_tree, statements);
-	}
-	if (!statements.empty()) {
-		auto &last_statement = statements.back();
-		last_statement->stmt_length = query.size() - last_statement->stmt_location;
-		for (auto &statement : statements) {
-			statement->query = query;
-			if (statement->type == StatementType::CREATE_STATEMENT) {
-				auto &create = (CreateStatement &)*statement;
-				create.info->sql = query.substr(statement->stmt_location, statement->stmt_length);
-			}
-		}
-	}
-}
-
-vector<SimplifiedToken> Parser::Tokenize(const string &query) {
-	auto pg_tokens = PostgresParser::Tokenize(query);
-	vector<SimplifiedToken> result;
-	result.reserve(pg_tokens.size());
-	for (auto &pg_token : pg_tokens) {
-		SimplifiedToken token;
-		switch (pg_token.type) {
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_IDENTIFIER:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_IDENTIFIER;
-			break;
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_NUMERIC_CONSTANT:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_NUMERIC_CONSTANT;
-			break;
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_STRING_CONSTANT:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_STRING_CONSTANT;
-			break;
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_OPERATOR:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_OPERATOR;
-			break;
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_KEYWORD:
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_KEYWORD;
-			break;
-		// comments are not supported by our tokenizer right now
-		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_COMMENT: // LCOV_EXCL_START
-			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_COMMENT;
-			break;
-		default:
-			throw InternalException("Unrecognized token category");
-		} // LCOV_EXCL_STOP
-		token.start = pg_token.start;
-		result.push_back(token);
-	}
-	return result;
-}
-
-bool Parser::IsKeyword(const string &text) {
-	return PostgresParser::IsKeyword(text);
-}
-
-vector<ParserKeyword> Parser::KeywordList() {
-	auto keywords = PostgresParser::KeywordList();
-	vector<ParserKeyword> result;
-	for (auto &kw : keywords) {
-		ParserKeyword res;
-		res.name = kw.text;
-		switch (kw.category) {
-		case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_RESERVED:
-			res.category = KeywordCategory::KEYWORD_RESERVED;
-			break;
-		case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_UNRESERVED:
-			res.category = KeywordCategory::KEYWORD_UNRESERVED;
-			break;
-		case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_TYPE_FUNC:
-			res.category = KeywordCategory::KEYWORD_TYPE_FUNC;
-			break;
-		case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_COL_NAME:
-			res.category = KeywordCategory::KEYWORD_COL_NAME;
-			break;
-		default:
-			throw InternalException("Unrecognized keyword category");
-		}
-		result.push_back(res);
-	}
-	return result;
-}
-
-vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &select_list, ParserOptions options) {
-	// construct a mock query prefixed with SELECT
-	string mock_query = "SELECT " + select_list;
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the statements
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException("Expected a single SELECT statement");
-	}
-	auto &select = (SelectStatement &)*parser.statements[0];
-	if (select.node->type != QueryNodeType::SELECT_NODE) {
-		throw ParserException("Expected a single SELECT node");
-	}
-	auto &select_node = (SelectNode &)*select.node;
-	return move(select_node.select_list);
-}
-
-vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOptions options) {
-	// construct a mock query
-	string mock_query = "SELECT * FROM tbl ORDER BY " + select_list;
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the statements
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException("Expected a single SELECT statement");
-	}
-	auto &select = (SelectStatement &)*parser.statements[0];
-	if (select.node->type != QueryNodeType::SELECT_NODE) {
-		throw InternalException("Expected a single SELECT node");
-	}
-	auto &select_node = (SelectNode &)*select.node;
-	if (select_node.modifiers.empty() || select_node.modifiers[0]->type != ResultModifierType::ORDER_MODIFIER ||
-	    select_node.modifiers.size() != 1) {
-		throw InternalException("Expected a single ORDER clause");
-	}
-	auto &order = (OrderModifier &)*select_node.modifiers[0];
-	return move(order.orders);
-}
-
-void Parser::ParseUpdateList(const string &update_list, vector<string> &update_columns,
-                             vector<unique_ptr<ParsedExpression>> &expressions, ParserOptions options) {
-	// construct a mock query
-	string mock_query = "UPDATE tbl SET " + update_list;
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the statements
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::UPDATE_STATEMENT) {
-		throw ParserException("Expected a single UPDATE statement");
-	}
-	auto &update = (UpdateStatement &)*parser.statements[0];
-	update_columns = move(update.columns);
-	expressions = move(update.expressions);
-}
-
-vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const string &value_list, ParserOptions options) {
-	// construct a mock query
-	string mock_query = "VALUES " + value_list;
-	// parse the query
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	// check the statements
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException("Expected a single SELECT statement");
-	}
-	auto &select = (SelectStatement &)*parser.statements[0];
-	if (select.node->type != QueryNodeType::SELECT_NODE) {
-		throw ParserException("Expected a single SELECT node");
-	}
-	auto &select_node = (SelectNode &)*select.node;
-	if (!select_node.from_table || select_node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
-		throw InternalException("Expected a single VALUES statement");
-	}
-	auto &values_list = (ExpressionListRef &)*select_node.from_table;
-	return move(values_list.values);
-}
-
-vector<ColumnDefinition> Parser::ParseColumnList(const string &column_list, ParserOptions options) {
-	string mock_query = "CREATE TABLE blabla (" + column_list + ")";
-	Parser parser(options);
-	parser.ParseQuery(mock_query);
-	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
-		throw ParserException("Expected a single CREATE statement");
-	}
-	auto &create = (CreateStatement &)*parser.statements[0];
-	if (create.info->type != CatalogType::TABLE_ENTRY) {
-		throw InternalException("Expected a single CREATE TABLE statement");
-	}
-	auto &info = ((CreateTableInfo &)*create.info);
-	return move(info.columns);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-string QueryErrorContext::Format(const string &query, const string &error_message, int error_loc) {
-	if (error_loc < 0 || size_t(error_loc) >= query.size()) {
-		// no location in query provided
-		return error_message;
-	}
-	idx_t error_location = idx_t(error_loc);
-	// count the line numbers until the error location
-	// and set the start position as the first character of that line
-	idx_t start_pos = 0;
-	idx_t line_number = 1;
-	for (idx_t i = 0; i < error_location; i++) {
-		if (StringUtil::CharacterIsNewline(query[i])) {
-			line_number++;
-			start_pos = i + 1;
-		}
-	}
-	// now find either the next newline token after the query, or find the end of string
-	// this is the initial end position
-	idx_t end_pos = query.size();
-	for (idx_t i = error_location; i < query.size(); i++) {
-		if (StringUtil::CharacterIsNewline(query[i])) {
-			end_pos = i;
-			break;
-		}
-	}
-	// now start scanning from the start pos
-	// we want to figure out the start and end pos of what we are going to render
-	// we want to render at most 80 characters in total, with the error_location located in the middle
-	const char *buf = query.c_str() + start_pos;
-	idx_t len = end_pos - start_pos;
-	vector<idx_t> render_widths;
-	vector<idx_t> positions;
-	if (Utf8Proc::IsValid(buf, len)) {
-		// for unicode awareness, we traverse the graphemes of the current line and keep track of their render widths
-		// and of their position in the string
-		for (idx_t cpos = 0; cpos < len;) {
-			auto char_render_width = Utf8Proc::RenderWidth(buf, len, cpos);
-			positions.push_back(cpos);
-			render_widths.push_back(char_render_width);
-			cpos = Utf8Proc::NextGraphemeCluster(buf, len, cpos);
-		}
-	} else { // LCOV_EXCL_START
-		// invalid utf-8, we can't do much at this point
-		// we just assume every character is a character, and every character has a render width of 1
-		for (idx_t cpos = 0; cpos < len; cpos++) {
-			positions.push_back(cpos);
-			render_widths.push_back(1);
-		}
-	} // LCOV_EXCL_STOP
-	// now we want to find the (unicode aware) start and end position
-	idx_t epos = 0;
-	// start by finding the error location inside the array
-	for (idx_t i = 0; i < positions.size(); i++) {
-		if (positions[i] >= (error_location - start_pos)) {
-			epos = i;
-			break;
-		}
-	}
-	bool truncate_beginning = false;
-	bool truncate_end = false;
-	idx_t spos = 0;
-	// now we iterate backwards from the error location
-	// we show max 40 render width before the error location
-	idx_t current_render_width = 0;
-	for (idx_t i = epos; i > 0; i--) {
-		current_render_width += render_widths[i];
-		if (current_render_width >= 40) {
-			truncate_beginning = true;
-			start_pos = positions[i];
-			spos = i;
-			break;
-		}
-	}
-	// now do the same, but going forward
-	current_render_width = 0;
-	for (idx_t i = epos; i < positions.size(); i++) {
-		current_render_width += render_widths[i];
-		if (current_render_width >= 40) {
-			truncate_end = true;
-			end_pos = positions[i];
-			break;
-		}
-	}
-	string line_indicator = "LINE " + to_string(line_number) + ": ";
-	string begin_trunc = truncate_beginning ? "..." : "";
-	string end_trunc = truncate_end ? "..." : "";
-
-	// get the render width of the error indicator (i.e. how many spaces we need to insert before the ^)
-	idx_t error_render_width = 0;
-	for (idx_t i = spos; i < epos; i++) {
-		error_render_width += render_widths[i];
-	}
-	error_render_width += line_indicator.size() + begin_trunc.size();
-
-	// now first print the error message plus the current line (or a subset of the line)
-	string result = error_message;
-	result += "\n" + line_indicator + begin_trunc + query.substr(start_pos, end_pos - start_pos) + end_trunc;
-	// print an arrow pointing at the error location
-	result += "\n" + string(error_render_width, ' ') + "^";
-	return result;
-}
-
-string QueryErrorContext::FormatErrorRecursive(const string &msg, vector<ExceptionFormatValue> &values) {
-	string error_message = values.empty() ? msg : ExceptionFormatValue::Format(msg, values);
-	if (!statement || query_location >= statement->query.size()) {
-		// no statement provided or query location out of range
-		return error_message;
-	}
-	return Format(statement->query, error_message, query_location);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-string RecursiveCTENode::ToString() const {
-	string result;
-	result += "(" + left->ToString() + ")";
-	result += " UNION ";
-	if (union_all) {
-		result += " ALL ";
-	}
-	result += "(" + right->ToString() + ")";
-	return result;
-}
-
-bool RecursiveCTENode::Equals(const QueryNode *other_p) const {
-	if (!QueryNode::Equals(other_p)) {
-		return false;
-	}
-	if (this == other_p) {
-		return true;
-	}
-	auto other = (RecursiveCTENode *)other_p;
-
-	if (other->union_all != union_all) {
-		return false;
-	}
-	if (!left->Equals(other->left.get())) {
-		return false;
-	}
-	if (!right->Equals(other->right.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<QueryNode> RecursiveCTENode::Copy() const {
-	auto result = make_unique<RecursiveCTENode>();
-	result->ctename = ctename;
-	result->union_all = union_all;
-	result->left = left->Copy();
-	result->right = right->Copy();
-	result->aliases = aliases;
-	this->CopyProperties(*result);
-	return move(result);
-}
-
-void RecursiveCTENode::Serialize(FieldWriter &writer) const {
-	writer.WriteString(ctename);
-	writer.WriteField<bool>(union_all);
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-	writer.WriteList<string>(aliases);
-}
-
-unique_ptr<QueryNode> RecursiveCTENode::Deserialize(FieldReader &reader) {
-	auto result = make_unique<RecursiveCTENode>();
-	result->ctename = reader.ReadRequired<string>();
-	result->union_all = reader.ReadRequired<bool>();
-	result->left = reader.ReadRequiredSerializable<QueryNode>();
-	result->right = reader.ReadRequiredSerializable<QueryNode>();
-	result->aliases = reader.ReadRequiredList<string>();
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-SelectNode::SelectNode()
-    : QueryNode(QueryNodeType::SELECT_NODE), aggregate_handling(AggregateHandling::STANDARD_HANDLING) {
-}
-
-string SelectNode::ToString() const {
-	string result;
-	result = cte_map.ToString();
-	result += "SELECT ";
-
-	// search for a distinct modifier
-	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
-		if (modifiers[modifier_idx]->type == ResultModifierType::DISTINCT_MODIFIER) {
-			auto &distinct_modifier = (DistinctModifier &)*modifiers[modifier_idx];
-			result += "DISTINCT ";
-			if (!distinct_modifier.distinct_on_targets.empty()) {
-				result += "ON (";
-				for (idx_t k = 0; k < distinct_modifier.distinct_on_targets.size(); k++) {
-					if (k > 0) {
-						result += ", ";
-					}
-					result += distinct_modifier.distinct_on_targets[k]->ToString();
-				}
-				result += ") ";
-			}
-		}
-	}
-	for (idx_t i = 0; i < select_list.size(); i++) {
-		if (i > 0) {
-			result += ", ";
-		}
-		result += select_list[i]->ToString();
-		if (!select_list[i]->alias.empty()) {
-			result += " AS " + KeywordHelper::WriteOptionallyQuoted(select_list[i]->alias);
-		}
-	}
-	if (from_table && from_table->type != TableReferenceType::EMPTY) {
-		result += " FROM " + from_table->ToString();
-	}
-	if (where_clause) {
-		result += " WHERE " + where_clause->ToString();
-	}
-	if (!groups.grouping_sets.empty()) {
-		result += " GROUP BY ";
-		// if we are dealing with multiple grouping sets, we have to add a few additional brackets
-		bool grouping_sets = groups.grouping_sets.size() > 1;
-		if (grouping_sets) {
-			result += "GROUPING SETS (";
-		}
-		for (idx_t i = 0; i < groups.grouping_sets.size(); i++) {
-			auto &grouping_set = groups.grouping_sets[i];
-			if (i > 0) {
-				result += ",";
-			}
-			if (grouping_set.empty()) {
-				result += "()";
-				continue;
-			}
-			if (grouping_sets) {
-				result += "(";
-			}
-			bool first = true;
-			for (auto &grp : grouping_set) {
-				if (!first) {
-					result += ", ";
-				}
-				result += groups.group_expressions[grp]->ToString();
-				first = false;
-			}
-			if (grouping_sets) {
-				result += ")";
-			}
-		}
-		if (grouping_sets) {
-			result += ")";
-		}
-	} else if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
-		result += " GROUP BY ALL";
-	}
-	if (having) {
-		result += " HAVING " + having->ToString();
-	}
-	if (qualify) {
-		result += " QUALIFY " + qualify->ToString();
-	}
-	if (sample) {
-		result += " USING SAMPLE ";
-		result += sample->sample_size.ToString();
-		if (sample->is_percentage) {
-			result += "%";
-		}
-		result += " (" + SampleMethodToString(sample->method);
-		if (sample->seed >= 0) {
-			result += ", " + std::to_string(sample->seed);
-		}
-		result += ")";
-	}
-	return result + ResultModifiersToString();
-}
-
-bool SelectNode::Equals(const QueryNode *other_p) const {
-	if (!QueryNode::Equals(other_p)) {
-		return false;
-	}
-	if (this == other_p) {
-		return true;
-	}
-	auto other = (SelectNode *)other_p;
-
-	// SELECT
-	if (!ExpressionUtil::ListEquals(select_list, other->select_list)) {
-		return false;
-	}
-	// FROM
-	if (from_table) {
-		// we have a FROM clause, compare to the other one
-		if (!from_table->Equals(other->from_table.get())) {
-			return false;
-		}
-	} else if (other->from_table) {
-		// we don't have a FROM clause, if the other statement has one they are
-		// not equal
-		return false;
-	}
-	// WHERE
-	if (!BaseExpression::Equals(where_clause.get(), other->where_clause.get())) {
-		return false;
-	}
-	// GROUP BY
-	if (!ExpressionUtil::ListEquals(groups.group_expressions, other->groups.group_expressions)) {
-		return false;
-	}
-	if (groups.grouping_sets != other->groups.grouping_sets) {
-		return false;
-	}
-	if (!SampleOptions::Equals(sample.get(), other->sample.get())) {
-		return false;
-	}
-	// HAVING
-	if (!BaseExpression::Equals(having.get(), other->having.get())) {
-		return false;
-	}
-	// QUALIFY
-	if (!BaseExpression::Equals(qualify.get(), other->qualify.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<QueryNode> SelectNode::Copy() const {
-	auto result = make_unique<SelectNode>();
-	for (auto &child : select_list) {
-		result->select_list.push_back(child->Copy());
-	}
-	result->from_table = from_table ? from_table->Copy() : nullptr;
-	result->where_clause = where_clause ? where_clause->Copy() : nullptr;
-	// groups
-	for (auto &group : groups.group_expressions) {
-		result->groups.group_expressions.push_back(group->Copy());
-	}
-	result->groups.grouping_sets = groups.grouping_sets;
-	result->aggregate_handling = aggregate_handling;
-	result->having = having ? having->Copy() : nullptr;
-	result->qualify = qualify ? qualify->Copy() : nullptr;
-	result->sample = sample ? sample->Copy() : nullptr;
-	this->CopyProperties(*result);
-	return move(result);
-}
-
-void SelectNode::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(select_list);
-	writer.WriteOptional(from_table);
-	writer.WriteOptional(where_clause);
-	writer.WriteSerializableList(groups.group_expressions);
-	writer.WriteField<uint32_t>(groups.grouping_sets.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &grouping_set : groups.grouping_sets) {
-		serializer.Write<idx_t>(grouping_set.size());
-		for (auto &idx : grouping_set) {
-			serializer.Write<idx_t>(idx);
-		}
-	}
-	writer.WriteField<AggregateHandling>(aggregate_handling);
-	writer.WriteOptional(having);
-	writer.WriteOptional(sample);
-	writer.WriteOptional(qualify);
-}
-
-unique_ptr<QueryNode> SelectNode::Deserialize(FieldReader &reader) {
-	auto result = make_unique<SelectNode>();
-	result->select_list = reader.ReadRequiredSerializableList<ParsedExpression>();
-	result->from_table = reader.ReadOptional<TableRef>(nullptr);
-	result->where_clause = reader.ReadOptional<ParsedExpression>(nullptr);
-	result->groups.group_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	auto grouping_set_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t set_idx = 0; set_idx < grouping_set_count; set_idx++) {
-		auto set_entries = source.Read<idx_t>();
-		GroupingSet grouping_set;
-		for (idx_t i = 0; i < set_entries; i++) {
-			grouping_set.insert(source.Read<idx_t>());
-		}
-		result->groups.grouping_sets.push_back(grouping_set);
-	}
-	result->aggregate_handling = reader.ReadRequired<AggregateHandling>();
-	result->having = reader.ReadOptional<ParsedExpression>(nullptr);
-	result->sample = reader.ReadOptional<SampleOptions>(nullptr);
-	result->qualify = reader.ReadOptional<ParsedExpression>(nullptr);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-string SetOperationNode::ToString() const {
-	string result;
-	result = cte_map.ToString();
-	result += "(" + left->ToString() + ") ";
-	bool is_distinct = false;
-	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
-		if (modifiers[modifier_idx]->type == ResultModifierType::DISTINCT_MODIFIER) {
-			is_distinct = true;
-			break;
-		}
-	}
-
-	switch (setop_type) {
-	case SetOperationType::UNION:
-		result += is_distinct ? "UNION" : "UNION ALL";
-		break;
-	case SetOperationType::EXCEPT:
-		D_ASSERT(is_distinct);
-		result += "EXCEPT";
-		break;
-	case SetOperationType::INTERSECT:
-		D_ASSERT(is_distinct);
-		result += "INTERSECT";
-		break;
-	default:
-		throw InternalException("Unsupported set operation type");
-	}
-	result += " (" + right->ToString() + ")";
-	return result + ResultModifiersToString();
-}
-
-bool SetOperationNode::Equals(const QueryNode *other_p) const {
-	if (!QueryNode::Equals(other_p)) {
-		return false;
-	}
-	if (this == other_p) {
-		return true;
-	}
-	auto other = (SetOperationNode *)other_p;
-	if (setop_type != other->setop_type) {
-		return false;
-	}
-	if (!left->Equals(other->left.get())) {
-		return false;
-	}
-	if (!right->Equals(other->right.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<QueryNode> SetOperationNode::Copy() const {
-	auto result = make_unique<SetOperationNode>();
-	result->setop_type = setop_type;
-	result->left = left->Copy();
-	result->right = right->Copy();
-	this->CopyProperties(*result);
-	return move(result);
-}
-
-void SetOperationNode::Serialize(FieldWriter &writer) const {
-	writer.WriteField<SetOperationType>(setop_type);
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-}
-
-unique_ptr<QueryNode> SetOperationNode::Deserialize(FieldReader &reader) {
-	auto result = make_unique<SetOperationNode>();
-	result->setop_type = reader.ReadRequired<SetOperationType>();
-	result->left = reader.ReadRequiredSerializable<QueryNode>();
-	result->right = reader.ReadRequiredSerializable<QueryNode>();
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-CommonTableExpressionMap::CommonTableExpressionMap() {
-}
-
-CommonTableExpressionMap CommonTableExpressionMap::Copy() const {
-	CommonTableExpressionMap res;
-	for (auto &kv : this->map) {
-		auto kv_info = make_unique<CommonTableExpressionInfo>();
-		for (auto &al : kv.second->aliases) {
-			kv_info->aliases.push_back(al);
-		}
-		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
-		res.map[kv.first] = move(kv_info);
-	}
-	return res;
-}
-
-string CommonTableExpressionMap::ToString() const {
-	if (map.empty()) {
-		return string();
-	}
-	// check if there are any recursive CTEs
-	bool has_recursive = false;
-	for (auto &kv : map) {
-		if (kv.second->query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
-			has_recursive = true;
-			break;
-		}
-	}
-	string result = "WITH ";
-	if (has_recursive) {
-		result += "RECURSIVE ";
-	}
-	bool first_cte = true;
-	for (auto &kv : map) {
-		if (!first_cte) {
-			result += ", ";
-		}
-		auto &cte = *kv.second;
-		result += KeywordHelper::WriteOptionallyQuoted(kv.first);
-		if (!cte.aliases.empty()) {
-			result += " (";
-			for (idx_t k = 0; k < cte.aliases.size(); k++) {
-				if (k > 0) {
-					result += ", ";
-				}
-				result += KeywordHelper::WriteOptionallyQuoted(cte.aliases[k]);
-			}
-			result += ")";
-		}
-		result += " AS (";
-		result += cte.query->ToString();
-		result += ")";
-		first_cte = false;
-	}
-	return result;
-}
-
-string QueryNode::ResultModifiersToString() const {
-	string result;
-	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
-		auto &modifier = *modifiers[modifier_idx];
-		if (modifier.type == ResultModifierType::ORDER_MODIFIER) {
-			auto &order_modifier = (OrderModifier &)modifier;
-			result += " ORDER BY ";
-			for (idx_t k = 0; k < order_modifier.orders.size(); k++) {
-				if (k > 0) {
-					result += ", ";
-				}
-				result += order_modifier.orders[k].ToString();
-			}
-		} else if (modifier.type == ResultModifierType::LIMIT_MODIFIER) {
-			auto &limit_modifier = (LimitModifier &)modifier;
-			if (limit_modifier.limit) {
-				result += " LIMIT " + limit_modifier.limit->ToString();
-			}
-			if (limit_modifier.offset) {
-				result += " OFFSET " + limit_modifier.offset->ToString();
-			}
-		} else if (modifier.type == ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-			auto &limit_p_modifier = (LimitPercentModifier &)modifier;
-			if (limit_p_modifier.limit) {
-				result += " LIMIT " + limit_p_modifier.limit->ToString() + " %";
-			}
-			if (limit_p_modifier.offset) {
-				result += " OFFSET " + limit_p_modifier.offset->ToString();
-			}
-		}
-	}
-	return result;
-}
-
-bool QueryNode::Equals(const QueryNode *other) const {
-	if (!other) {
-		return false;
-	}
-	if (this == other) {
-		return true;
-	}
-	if (other->type != this->type) {
-		return false;
-	}
-	if (modifiers.size() != other->modifiers.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < modifiers.size(); i++) {
-		if (!modifiers[i]->Equals(other->modifiers[i].get())) {
-			return false;
-		}
-	}
-	// WITH clauses (CTEs)
-	if (cte_map.map.size() != other->cte_map.map.size()) {
-		return false;
-	}
-	for (auto &entry : cte_map.map) {
-		auto other_entry = other->cte_map.map.find(entry.first);
-		if (other_entry == other->cte_map.map.end()) {
-			return false;
-		}
-		if (entry.second->aliases != other_entry->second->aliases) {
-			return false;
-		}
-		if (!entry.second->query->Equals(other_entry->second->query.get())) {
-			return false;
-		}
-	}
-	return other->type == type;
-}
-
-void QueryNode::CopyProperties(QueryNode &other) const {
-	for (auto &modifier : modifiers) {
-		other.modifiers.push_back(modifier->Copy());
-	}
-	for (auto &kv : cte_map.map) {
-		auto kv_info = make_unique<CommonTableExpressionInfo>();
-		for (auto &al : kv.second->aliases) {
-			kv_info->aliases.push_back(al);
-		}
-		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
-		other.cte_map.map[kv.first] = move(kv_info);
-	}
-}
-
-void QueryNode::Serialize(Serializer &main_serializer) const {
-	FieldWriter writer(main_serializer);
-	writer.WriteField<QueryNodeType>(type);
-	writer.WriteSerializableList(modifiers);
-	// cte_map
-	writer.WriteField<uint32_t>((uint32_t)cte_map.map.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &cte : cte_map.map) {
-		serializer.WriteString(cte.first);
-		serializer.WriteStringVector(cte.second->aliases);
-		cte.second->query->Serialize(serializer);
-	}
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
-	FieldReader reader(main_source);
-
-	auto type = reader.ReadRequired<QueryNodeType>();
-	auto modifiers = reader.ReadRequiredSerializableList<ResultModifier>();
-	// cte_map
-	auto cte_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	unordered_map<string, unique_ptr<CommonTableExpressionInfo>> new_map;
-	for (idx_t i = 0; i < cte_count; i++) {
-		auto name = source.Read<string>();
-		auto info = make_unique<CommonTableExpressionInfo>();
-		source.ReadStringVector(info->aliases);
-		info->query = SelectStatement::Deserialize(source);
-		new_map[name] = move(info);
-	}
-	unique_ptr<QueryNode> result;
-	switch (type) {
-	case QueryNodeType::SELECT_NODE:
-		result = SelectNode::Deserialize(reader);
-		break;
-	case QueryNodeType::SET_OPERATION_NODE:
-		result = SetOperationNode::Deserialize(reader);
-		break;
-	case QueryNodeType::RECURSIVE_CTE_NODE:
-		result = RecursiveCTENode::Deserialize(reader);
-		break;
-	default:
-		throw SerializationException("Could not deserialize Query Node: unknown type!");
-	}
-	result->modifiers = move(modifiers);
-	result->cte_map.map = move(new_map);
-	reader.Finalize();
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-bool ResultModifier::Equals(const ResultModifier *other) const {
-	if (!other) {
-		return false;
-	}
-	return type == other->type;
-}
-
-void ResultModifier::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ResultModifierType>(type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<ResultModifierType>();
-
-	unique_ptr<ResultModifier> result;
-	switch (type) {
-	case ResultModifierType::LIMIT_MODIFIER:
-		result = LimitModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::ORDER_MODIFIER:
-		result = OrderModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::DISTINCT_MODIFIER:
-		result = DistinctModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-		result = LimitPercentModifier::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Unrecognized ResultModifierType for Deserialization");
-	}
-	reader.Finalize();
-	return result;
-}
-
-bool LimitModifier::Equals(const ResultModifier *other_p) const {
-	if (!ResultModifier::Equals(other_p)) {
-		return false;
-	}
-	auto &other = (LimitModifier &)*other_p;
-	if (!BaseExpression::Equals(limit.get(), other.limit.get())) {
-		return false;
-	}
-	if (!BaseExpression::Equals(offset.get(), other.offset.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ResultModifier> LimitModifier::Copy() const {
-	auto copy = make_unique<LimitModifier>();
-	if (limit) {
-		copy->limit = limit->Copy();
-	}
-	if (offset) {
-		copy->offset = offset->Copy();
-	}
-	return move(copy);
-}
-
-void LimitModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(limit);
-	writer.WriteOptional(offset);
-}
-
-unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_unique<LimitModifier>();
-	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
-	mod->offset = reader.ReadOptional<ParsedExpression>(nullptr);
-	return move(mod);
-}
-
-bool DistinctModifier::Equals(const ResultModifier *other_p) const {
-	if (!ResultModifier::Equals(other_p)) {
-		return false;
-	}
-	auto &other = (DistinctModifier &)*other_p;
-	if (!ExpressionUtil::ListEquals(distinct_on_targets, other.distinct_on_targets)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ResultModifier> DistinctModifier::Copy() const {
-	auto copy = make_unique<DistinctModifier>();
-	for (auto &expr : distinct_on_targets) {
-		copy->distinct_on_targets.push_back(expr->Copy());
-	}
-	return move(copy);
-}
-
-void DistinctModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(distinct_on_targets);
-}
-
-unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_unique<DistinctModifier>();
-	mod->distinct_on_targets = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return move(mod);
-}
-
-bool OrderModifier::Equals(const ResultModifier *other_p) const {
-	if (!ResultModifier::Equals(other_p)) {
-		return false;
-	}
-	auto &other = (OrderModifier &)*other_p;
-	if (orders.size() != other.orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (orders[i].type != other.orders[i].type) {
-			return false;
-		}
-		if (!BaseExpression::Equals(orders[i].expression.get(), other.orders[i].expression.get())) {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<ResultModifier> OrderModifier::Copy() const {
-	auto copy = make_unique<OrderModifier>();
-	for (auto &order : orders) {
-		copy->orders.emplace_back(order.type, order.null_order, order.expression->Copy());
-	}
-	return move(copy);
-}
-
-string OrderByNode::ToString() const {
-	auto str = expression->ToString();
-	switch (type) {
-	case OrderType::ASCENDING:
-		str += " ASC";
-		break;
-	case OrderType::DESCENDING:
-		str += " DESC";
-		break;
-	default:
-		break;
-	}
-
-	switch (null_order) {
-	case OrderByNullType::NULLS_FIRST:
-		str += " NULLS FIRST";
-		break;
-	case OrderByNullType::NULLS_LAST:
-		str += " NULLS LAST";
-		break;
-	default:
-		break;
-	}
-	return str;
-}
-
-void OrderByNode::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<OrderType>(type);
-	writer.WriteField<OrderByNullType>(null_order);
-	writer.WriteSerializable(*expression);
-	writer.Finalize();
-}
-
-OrderByNode OrderByNode::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<OrderType>();
-	auto null_order = reader.ReadRequired<OrderByNullType>();
-	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
-	reader.Finalize();
-	return OrderByNode(type, null_order, move(expression));
-}
-
-void OrderModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(orders);
-}
-
-unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_unique<OrderModifier>();
-	mod->orders = reader.ReadRequiredSerializableList<OrderByNode, OrderByNode>();
-	return move(mod);
-}
-
-bool LimitPercentModifier::Equals(const ResultModifier *other_p) const {
-	if (!ResultModifier::Equals(other_p)) {
-		return false;
-	}
-	auto &other = (LimitPercentModifier &)*other_p;
-	if (!BaseExpression::Equals(limit.get(), other.limit.get())) {
-		return false;
-	}
-	if (!BaseExpression::Equals(offset.get(), other.offset.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<ResultModifier> LimitPercentModifier::Copy() const {
-	auto copy = make_unique<LimitPercentModifier>();
-	if (limit) {
-		copy->limit = limit->Copy();
-	}
-	if (offset) {
-		copy->offset = offset->Copy();
-	}
-	return move(copy);
-}
-
-void LimitPercentModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(limit);
-	writer.WriteOptional(offset);
-}
-
-unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_unique<LimitPercentModifier>();
-	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
-	mod->offset = reader.ReadOptional<ParsedExpression>(nullptr);
-	return move(mod);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-AlterStatement::AlterStatement() : SQLStatement(StatementType::ALTER_STATEMENT) {
-}
-
-AlterStatement::AlterStatement(const AlterStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> AlterStatement::Copy() const {
-	return unique_ptr<AlterStatement>(new AlterStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-CallStatement::CallStatement() : SQLStatement(StatementType::CALL_STATEMENT) {
-}
-
-CallStatement::CallStatement(const CallStatement &other) : SQLStatement(other), function(other.function->Copy()) {
-}
-
-unique_ptr<SQLStatement> CallStatement::Copy() const {
-	return unique_ptr<CallStatement>(new CallStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-CopyStatement::CopyStatement() : SQLStatement(StatementType::COPY_STATEMENT), info(make_unique<CopyInfo>()) {
-}
-
-CopyStatement::CopyStatement(const CopyStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-	if (other.select_statement) {
-		select_statement = other.select_statement->Copy();
-	}
-}
-
-unique_ptr<SQLStatement> CopyStatement::Copy() const {
-	return unique_ptr<CopyStatement>(new CopyStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-CreateStatement::CreateStatement() : SQLStatement(StatementType::CREATE_STATEMENT) {
-}
-
-CreateStatement::CreateStatement(const CreateStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> CreateStatement::Copy() const {
-	return unique_ptr<CreateStatement>(new CreateStatement(*this));
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-DeleteStatement::DeleteStatement() : SQLStatement(StatementType::DELETE_STATEMENT) {
-}
-
-DeleteStatement::DeleteStatement(const DeleteStatement &other) : SQLStatement(other), table(other.table->Copy()) {
-	if (other.condition) {
-		condition = other.condition->Copy();
-	}
-	for (const auto &using_clause : other.using_clauses) {
-		using_clauses.push_back(using_clause->Copy());
-	}
-	cte_map = other.cte_map.Copy();
-}
-
-string DeleteStatement::ToString() const {
-	string result;
-	result = cte_map.ToString();
-	result += "DELETE FROM ";
-	result += table->ToString();
-	if (!using_clauses.empty()) {
-		result += " USING ";
-		for (idx_t i = 0; i < using_clauses.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += using_clauses[i]->ToString();
-		}
-	}
-	if (condition) {
-		result += " WHERE " + condition->ToString();
-	}
-
-	if (!returning_list.empty()) {
-		result += " RETURNING ";
-		for (idx_t i = 0; i < returning_list.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += returning_list[i]->ToString();
-		}
-	}
-	return result;
-}
-
-unique_ptr<SQLStatement> DeleteStatement::Copy() const {
-	return unique_ptr<DeleteStatement>(new DeleteStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-DropStatement::DropStatement() : SQLStatement(StatementType::DROP_STATEMENT), info(make_unique<DropInfo>()) {
-}
-
-DropStatement::DropStatement(const DropStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> DropStatement::Copy() const {
-	return unique_ptr<DropStatement>(new DropStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ExecuteStatement::ExecuteStatement() : SQLStatement(StatementType::EXECUTE_STATEMENT) {
-}
-
-ExecuteStatement::ExecuteStatement(const ExecuteStatement &other) : SQLStatement(other), name(other.name) {
-	for (const auto &value : other.values) {
-		values.push_back(value->Copy());
-	}
-}
-
-unique_ptr<SQLStatement> ExecuteStatement::Copy() const {
-	return unique_ptr<ExecuteStatement>(new ExecuteStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ExplainStatement::ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type)
-    : SQLStatement(StatementType::EXPLAIN_STATEMENT), stmt(move(stmt)), explain_type(explain_type) {
-}
-
-ExplainStatement::ExplainStatement(const ExplainStatement &other)
-    : SQLStatement(other), stmt(other.stmt->Copy()), explain_type(other.explain_type) {
-}
-
-unique_ptr<SQLStatement> ExplainStatement::Copy() const {
-	return unique_ptr<ExplainStatement>(new ExplainStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ExportStatement::ExportStatement(unique_ptr<CopyInfo> info)
-    : SQLStatement(StatementType::EXPORT_STATEMENT), info(move(info)) {
-}
-
-ExportStatement::ExportStatement(const ExportStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> ExportStatement::Copy() const {
-	return unique_ptr<ExportStatement>(new ExportStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ExtensionStatement::ExtensionStatement(ParserExtension extension_p, unique_ptr<ParserExtensionParseData> parse_data_p)
-    : SQLStatement(StatementType::EXTENSION_STATEMENT), extension(move(extension_p)), parse_data(move(parse_data_p)) {
-}
-
-unique_ptr<SQLStatement> ExtensionStatement::Copy() const {
-	return make_unique<ExtensionStatement>(extension, parse_data->Copy());
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-InsertStatement::InsertStatement() : SQLStatement(StatementType::INSERT_STATEMENT), schema(DEFAULT_SCHEMA) {
-}
-
-InsertStatement::InsertStatement(const InsertStatement &other)
-    : SQLStatement(other),
-      select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(other.select_statement->Copy())),
-      columns(other.columns), table(other.table), schema(other.schema) {
-	cte_map = other.cte_map.Copy();
-}
-
-string InsertStatement::ToString() const {
-	string result;
-	result = cte_map.ToString();
-	result += "INSERT INTO ";
-	if (!schema.empty()) {
-		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
-	}
-	result += KeywordHelper::WriteOptionallyQuoted(table);
-	if (!columns.empty()) {
-		result += " (";
-		for (idx_t i = 0; i < columns.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += KeywordHelper::WriteOptionallyQuoted(columns[i]);
-		}
-		result += " )";
-	}
-	result += " ";
-	auto values_list = GetValuesList();
-	if (values_list) {
-		values_list->alias = string();
-		result += values_list->ToString();
-	} else {
-		result += select_statement->ToString();
-	}
-	if (!returning_list.empty()) {
-		result += " RETURNING ";
-		for (idx_t i = 0; i < returning_list.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += returning_list[i]->ToString();
-		}
-	}
-	return result;
-}
-
-unique_ptr<SQLStatement> InsertStatement::Copy() const {
-	return unique_ptr<InsertStatement>(new InsertStatement(*this));
-}
-
-ExpressionListRef *InsertStatement::GetValuesList() const {
-	if (select_statement->node->type != QueryNodeType::SELECT_NODE) {
-		return nullptr;
-	}
-	auto &node = (SelectNode &)*select_statement->node;
-	if (node.where_clause || node.qualify || node.having) {
-		return nullptr;
-	}
-	if (!node.cte_map.map.empty()) {
-		return nullptr;
-	}
-	if (!node.groups.grouping_sets.empty()) {
-		return nullptr;
-	}
-	if (node.aggregate_handling != AggregateHandling::STANDARD_HANDLING) {
-		return nullptr;
-	}
-	if (node.select_list.size() != 1 || node.select_list[0]->type != ExpressionType::STAR) {
-		return nullptr;
-	}
-	if (!node.from_table || node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
-		return nullptr;
-	}
-	return (ExpressionListRef *)node.from_table.get();
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-LoadStatement::LoadStatement() : SQLStatement(StatementType::LOAD_STATEMENT) {
-}
-
-LoadStatement::LoadStatement(const LoadStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> LoadStatement::Copy() const {
-	return unique_ptr<LoadStatement>(new LoadStatement(*this));
-}
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-7.cpp b/velox/external/duckdb/duckdb-7.cpp
deleted file mode 100644
index 35a1fea2b6dff..0000000000000
--- a/velox/external/duckdb/duckdb-7.cpp
+++ /dev/null
@@ -1,16982 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-namespace duckdb {
-
-PragmaStatement::PragmaStatement() : SQLStatement(StatementType::PRAGMA_STATEMENT), info(make_unique<PragmaInfo>()) {
-}
-
-PragmaStatement::PragmaStatement(const PragmaStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> PragmaStatement::Copy() const {
-	return unique_ptr<PragmaStatement>(new PragmaStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-PrepareStatement::PrepareStatement() : SQLStatement(StatementType::PREPARE_STATEMENT), statement(nullptr), name("") {
-}
-
-PrepareStatement::PrepareStatement(const PrepareStatement &other)
-    : SQLStatement(other), statement(other.statement->Copy()), name(other.name) {
-}
-
-unique_ptr<SQLStatement> PrepareStatement::Copy() const {
-	return unique_ptr<PrepareStatement>(new PrepareStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-RelationStatement::RelationStatement(shared_ptr<Relation> relation)
-    : SQLStatement(StatementType::RELATION_STATEMENT), relation(move(relation)) {
-}
-
-unique_ptr<SQLStatement> RelationStatement::Copy() const {
-	return unique_ptr<RelationStatement>(new RelationStatement(*this));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-SelectStatement::SelectStatement(const SelectStatement &other) : SQLStatement(other), node(other.node->Copy()) {
-}
-
-unique_ptr<SQLStatement> SelectStatement::Copy() const {
-	return unique_ptr<SelectStatement>(new SelectStatement(*this));
-}
-
-void SelectStatement::Serialize(Serializer &serializer) const {
-	node->Serialize(serializer);
-}
-
-unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &source) {
-	auto result = make_unique<SelectStatement>();
-	result->node = QueryNode::Deserialize(source);
-	return result;
-}
-
-bool SelectStatement::Equals(const SQLStatement *other_p) const {
-	if (type != other_p->type) {
-		return false;
-	}
-	auto other = (SelectStatement *)other_p;
-	return node->Equals(other->node.get());
-}
-
-string SelectStatement::ToString() const {
-	return node->ToString();
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-SetStatement::SetStatement(std::string name_p, Value value_p, SetScope scope_p)
-    : SQLStatement(StatementType::SET_STATEMENT), name(move(name_p)), value(move(value_p)), scope(scope_p) {
-}
-
-unique_ptr<SQLStatement> SetStatement::Copy() const {
-	return unique_ptr<SetStatement>(new SetStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ShowStatement::ShowStatement() : SQLStatement(StatementType::SHOW_STATEMENT), info(make_unique<ShowSelectInfo>()) {
-}
-
-ShowStatement::ShowStatement(const ShowStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> ShowStatement::Copy() const {
-	return unique_ptr<ShowStatement>(new ShowStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-TransactionStatement::TransactionStatement(TransactionType type)
-    : SQLStatement(StatementType::TRANSACTION_STATEMENT), info(make_unique<TransactionInfo>(type)) {
-}
-
-TransactionStatement::TransactionStatement(const TransactionStatement &other)
-    : SQLStatement(other), info(make_unique<TransactionInfo>(other.info->type)) {
-}
-
-unique_ptr<SQLStatement> TransactionStatement::Copy() const {
-	return unique_ptr<TransactionStatement>(new TransactionStatement(*this));
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-UpdateStatement::UpdateStatement() : SQLStatement(StatementType::UPDATE_STATEMENT) {
-}
-
-UpdateStatement::UpdateStatement(const UpdateStatement &other)
-    : SQLStatement(other), table(other.table->Copy()), columns(other.columns) {
-	if (other.condition) {
-		condition = other.condition->Copy();
-	}
-	if (other.from_table) {
-		from_table = other.from_table->Copy();
-	}
-	for (auto &expr : other.expressions) {
-		expressions.emplace_back(expr->Copy());
-	}
-	cte_map = other.cte_map.Copy();
-}
-
-string UpdateStatement::ToString() const {
-	string result;
-	result = cte_map.ToString();
-	result += "UPDATE ";
-	result += table->ToString();
-	result += " SET ";
-	D_ASSERT(columns.size() == expressions.size());
-	for (idx_t i = 0; i < columns.size(); i++) {
-		if (i > 0) {
-			result += ", ";
-		}
-		result += KeywordHelper::WriteOptionallyQuoted(columns[i]);
-		result += "=";
-		result += expressions[i]->ToString();
-	}
-	if (from_table) {
-		result += " FROM " + from_table->ToString();
-	}
-	if (condition) {
-		result += " WHERE " + condition->ToString();
-	}
-	if (!returning_list.empty()) {
-		result += " RETURNING ";
-		for (idx_t i = 0; i < returning_list.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += returning_list[i]->ToString();
-		}
-	}
-	return result;
-}
-
-unique_ptr<SQLStatement> UpdateStatement::Copy() const {
-	return unique_ptr<UpdateStatement>(new UpdateStatement(*this));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-VacuumStatement::VacuumStatement() : SQLStatement(StatementType::VACUUM_STATEMENT) {
-}
-
-unique_ptr<SQLStatement> VacuumStatement::Copy() const {
-	return unique_ptr<VacuumStatement>(new VacuumStatement(*this));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-string BaseTableRef::ToString() const {
-	string schema = schema_name.empty() ? "" : KeywordHelper::WriteOptionallyQuoted(schema_name) + ".";
-	string result = schema + KeywordHelper::WriteOptionallyQuoted(table_name);
-	return BaseToString(result, column_name_alias);
-}
-
-bool BaseTableRef::Equals(const TableRef *other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BaseTableRef *)other_p;
-	return other->schema_name == schema_name && other->table_name == table_name &&
-	       column_name_alias == other->column_name_alias;
-}
-
-void BaseTableRef::Serialize(FieldWriter &writer) const {
-	writer.WriteString(schema_name);
-	writer.WriteString(table_name);
-	writer.WriteList<string>(column_name_alias);
-}
-
-unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
-	auto result = make_unique<BaseTableRef>();
-
-	result->schema_name = reader.ReadRequired<string>();
-	result->table_name = reader.ReadRequired<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-
-	return move(result);
-}
-
-unique_ptr<TableRef> BaseTableRef::Copy() {
-	auto copy = make_unique<BaseTableRef>();
-
-	copy->schema_name = schema_name;
-	copy->table_name = table_name;
-	copy->column_name_alias = column_name_alias;
-	CopyProperties(*copy);
-
-	return move(copy);
-}
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-string CrossProductRef::ToString() const {
-	return left->ToString() + ", " + right->ToString();
-}
-
-bool CrossProductRef::Equals(const TableRef *other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto other = (CrossProductRef *)other_p;
-	return left->Equals(other->left.get()) && right->Equals(other->right.get());
-}
-
-unique_ptr<TableRef> CrossProductRef::Copy() {
-	auto copy = make_unique<CrossProductRef>();
-	copy->left = left->Copy();
-	copy->right = right->Copy();
-	copy->alias = alias;
-	return move(copy);
-}
-
-void CrossProductRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-}
-
-unique_ptr<TableRef> CrossProductRef::Deserialize(FieldReader &reader) {
-	auto result = make_unique<CrossProductRef>();
-
-	result->left = reader.ReadRequiredSerializable<TableRef>();
-	result->right = reader.ReadRequiredSerializable<TableRef>();
-	D_ASSERT(result->left);
-	D_ASSERT(result->right);
-
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-string EmptyTableRef::ToString() const {
-	return "";
-}
-
-bool EmptyTableRef::Equals(const TableRef *other) const {
-	return TableRef::Equals(other);
-}
-
-unique_ptr<TableRef> EmptyTableRef::Copy() {
-	return make_unique<EmptyTableRef>();
-}
-
-void EmptyTableRef::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<TableRef> EmptyTableRef::Deserialize(FieldReader &reader) {
-	return make_unique<EmptyTableRef>();
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-string ExpressionListRef::ToString() const {
-	D_ASSERT(!values.empty());
-	string result = "(VALUES ";
-	for (idx_t row_idx = 0; row_idx < values.size(); row_idx++) {
-		if (row_idx > 0) {
-			result += ", ";
-		}
-		auto &row = values[row_idx];
-		result += "(";
-		for (idx_t col_idx = 0; col_idx < row.size(); col_idx++) {
-			if (col_idx > 0) {
-				result += ", ";
-			}
-			result += row[col_idx]->ToString();
-		}
-		result += ")";
-	}
-	result += ")";
-	return BaseToString(result, expected_names);
-}
-
-bool ExpressionListRef::Equals(const TableRef *other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto other = (ExpressionListRef *)other_p;
-	if (values.size() != other->values.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < values.size(); i++) {
-		if (values[i].size() != other->values[i].size()) {
-			return false;
-		}
-		for (idx_t j = 0; j < values[i].size(); j++) {
-			if (!values[i][j]->Equals(other->values[i][j].get())) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-unique_ptr<TableRef> ExpressionListRef::Copy() {
-	// value list
-	auto result = make_unique<ExpressionListRef>();
-	for (auto &val_list : values) {
-		vector<unique_ptr<ParsedExpression>> new_val_list;
-		new_val_list.reserve(val_list.size());
-		for (auto &val : val_list) {
-			new_val_list.push_back(val->Copy());
-		}
-		result->values.push_back(move(new_val_list));
-	}
-	result->expected_names = expected_names;
-	result->expected_types = expected_types;
-	CopyProperties(*result);
-	return move(result);
-}
-
-void ExpressionListRef::Serialize(FieldWriter &writer) const {
-	writer.WriteList<string>(expected_names);
-	writer.WriteRegularSerializableList<LogicalType>(expected_types);
-	auto &serializer = writer.GetSerializer();
-	writer.WriteField<uint32_t>(values.size());
-	for (idx_t i = 0; i < values.size(); i++) {
-		serializer.WriteList(values[i]);
-	}
-}
-
-unique_ptr<TableRef> ExpressionListRef::Deserialize(FieldReader &reader) {
-	auto result = make_unique<ExpressionListRef>();
-	// value list
-	result->expected_names = reader.ReadRequiredList<string>();
-	result->expected_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	idx_t value_list_size = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < value_list_size; i++) {
-		vector<unique_ptr<ParsedExpression>> value_list;
-		source.ReadList<ParsedExpression>(value_list);
-		result->values.push_back(move(value_list));
-	}
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-string JoinRef::ToString() const {
-	string result;
-	result = left->ToString() + " ";
-	if (is_natural) {
-		result += "NATURAL ";
-	}
-	result += JoinTypeToString(type) + " JOIN ";
-	result += right->ToString();
-	if (condition) {
-		D_ASSERT(using_columns.empty());
-		result += " ON (";
-		result += condition->ToString();
-		result += ")";
-	} else if (!using_columns.empty()) {
-		result += " USING (";
-		for (idx_t i = 0; i < using_columns.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += using_columns[i];
-		}
-		result += ")";
-	}
-	return result;
-}
-
-bool JoinRef::Equals(const TableRef *other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto other = (JoinRef *)other_p;
-	if (using_columns.size() != other->using_columns.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < using_columns.size(); i++) {
-		if (using_columns[i] != other->using_columns[i]) {
-			return false;
-		}
-	}
-	return left->Equals(other->left.get()) && right->Equals(other->right.get()) &&
-	       BaseExpression::Equals(condition.get(), other->condition.get()) && type == other->type;
-}
-
-unique_ptr<TableRef> JoinRef::Copy() {
-	auto copy = make_unique<JoinRef>();
-	copy->left = left->Copy();
-	copy->right = right->Copy();
-	if (condition) {
-		copy->condition = condition->Copy();
-	}
-	copy->type = type;
-	copy->is_natural = is_natural;
-	copy->alias = alias;
-	copy->using_columns = using_columns;
-	return move(copy);
-}
-
-void JoinRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-	writer.WriteOptional(condition);
-	writer.WriteField<JoinType>(type);
-	writer.WriteField<bool>(is_natural);
-	writer.WriteList<string>(using_columns);
-}
-
-unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
-	auto result = make_unique<JoinRef>();
-	result->left = reader.ReadRequiredSerializable<TableRef>();
-	result->right = reader.ReadRequiredSerializable<TableRef>();
-	result->condition = reader.ReadOptional<ParsedExpression>(nullptr);
-	result->type = reader.ReadRequired<JoinType>();
-	result->is_natural = reader.ReadRequired<bool>();
-	result->using_columns = reader.ReadRequiredList<string>();
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-string SubqueryRef::ToString() const {
-	string result = "(" + subquery->ToString() + ")";
-	return BaseToString(result, column_name_alias);
-}
-
-SubqueryRef::SubqueryRef(unique_ptr<SelectStatement> subquery_p, string alias_p)
-    : TableRef(TableReferenceType::SUBQUERY), subquery(move(subquery_p)) {
-	this->alias = move(alias_p);
-}
-
-bool SubqueryRef::Equals(const TableRef *other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto other = (SubqueryRef *)other_p;
-	return subquery->Equals(other->subquery.get());
-}
-
-unique_ptr<TableRef> SubqueryRef::Copy() {
-	auto copy = make_unique<SubqueryRef>(unique_ptr_cast<SQLStatement, SelectStatement>(subquery->Copy()), alias);
-	copy->column_name_alias = column_name_alias;
-	CopyProperties(*copy);
-	return move(copy);
-}
-
-void SubqueryRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*subquery);
-	writer.WriteList<string>(column_name_alias);
-}
-
-unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
-	auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
-	auto result = make_unique<SubqueryRef>(move(subquery));
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-TableFunctionRef::TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTION) {
-}
-
-string TableFunctionRef::ToString() const {
-	return BaseToString(function->ToString(), column_name_alias);
-}
-
-bool TableFunctionRef::Equals(const TableRef *other_p) const {
-	if (!TableRef::Equals(other_p)) {
-		return false;
-	}
-	auto other = (TableFunctionRef *)other_p;
-	return function->Equals(other->function.get());
-}
-
-void TableFunctionRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*function);
-	writer.WriteString(alias);
-	writer.WriteList<string>(column_name_alias);
-}
-
-unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
-	auto result = make_unique<TableFunctionRef>();
-	result->function = reader.ReadRequiredSerializable<ParsedExpression>();
-	result->alias = reader.ReadRequired<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	return move(result);
-}
-
-unique_ptr<TableRef> TableFunctionRef::Copy() {
-	auto copy = make_unique<TableFunctionRef>();
-
-	copy->function = function->Copy();
-	copy->column_name_alias = column_name_alias;
-	CopyProperties(*copy);
-
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-string TableRef::BaseToString(string result) const {
-	vector<string> column_name_alias;
-	return BaseToString(move(result), column_name_alias);
-}
-
-string TableRef::BaseToString(string result, const vector<string> &column_name_alias) const {
-	if (!alias.empty()) {
-		result += " AS " + KeywordHelper::WriteOptionallyQuoted(alias);
-	}
-	if (!column_name_alias.empty()) {
-		D_ASSERT(!alias.empty());
-		result += "(";
-		for (idx_t i = 0; i < column_name_alias.size(); i++) {
-			if (i > 0) {
-				result += ", ";
-			}
-			result += KeywordHelper::WriteOptionallyQuoted(column_name_alias[i]);
-		}
-		result += ")";
-	}
-	if (sample) {
-		result += " TABLESAMPLE " + SampleMethodToString(sample->method);
-		result += "(" + sample->sample_size.ToString() + " " + string(sample->is_percentage ? "PERCENT" : "ROWS") + ")";
-		if (sample->seed >= 0) {
-			result += "REPEATABLE (" + to_string(sample->seed) + ")";
-		}
-	}
-
-	return result;
-}
-
-bool TableRef::Equals(const TableRef *other) const {
-	return other && type == other->type && alias == other->alias &&
-	       SampleOptions::Equals(sample.get(), other->sample.get());
-}
-
-void TableRef::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<TableReferenceType>(type);
-	writer.WriteString(alias);
-	writer.WriteOptional(sample);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-
-	auto type = reader.ReadRequired<TableReferenceType>();
-	auto alias = reader.ReadRequired<string>();
-	auto sample = reader.ReadOptional<SampleOptions>(nullptr);
-	unique_ptr<TableRef> result;
-	switch (type) {
-	case TableReferenceType::BASE_TABLE:
-		result = BaseTableRef::Deserialize(reader);
-		break;
-	case TableReferenceType::CROSS_PRODUCT:
-		result = CrossProductRef::Deserialize(reader);
-		break;
-	case TableReferenceType::JOIN:
-		result = JoinRef::Deserialize(reader);
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::Deserialize(reader);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::Deserialize(reader);
-		break;
-	case TableReferenceType::EMPTY:
-		result = EmptyTableRef::Deserialize(reader);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::Deserialize(reader);
-		break;
-	case TableReferenceType::CTE:
-	case TableReferenceType::INVALID:
-		throw InternalException("Unsupported type for TableRef::Deserialize");
-	}
-	reader.Finalize();
-
-	result->alias = alias;
-	result->sample = move(sample);
-	return result;
-}
-
-void TableRef::CopyProperties(TableRef &target) const {
-	D_ASSERT(type == target.type);
-	target.alias = alias;
-	target.query_location = query_location;
-	target.sample = sample ? sample->Copy() : nullptr;
-}
-
-void TableRef::Print() {
-	Printer::Print(ToString());
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell) {
-	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
-	switch (constraint->contype) {
-	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
-	case duckdb_libpgquery::PG_CONSTR_PRIMARY: {
-		bool is_primary_key = constraint->contype == duckdb_libpgquery::PG_CONSTR_PRIMARY;
-		vector<string> columns;
-		for (auto kc = constraint->keys->head; kc; kc = kc->next) {
-			columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-		}
-		return make_unique<UniqueConstraint>(columns, is_primary_key);
-	}
-	case duckdb_libpgquery::PG_CONSTR_CHECK: {
-		auto expression = TransformExpression(constraint->raw_expr);
-		if (expression->HasSubquery()) {
-			throw ParserException("subqueries prohibited in CHECK constraints");
-		}
-		return make_unique<CheckConstraint>(TransformExpression(constraint->raw_expr));
-	}
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		if (constraint->pktable->schemaname) {
-			fk_info.schema = constraint->pktable->schemaname;
-		} else {
-			fk_info.schema = "";
-		}
-		fk_info.table = constraint->pktable->relname;
-		vector<string> pk_columns, fk_columns;
-		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
-			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-		}
-		if (constraint->pk_attrs) {
-			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-			}
-		}
-		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		if (fk_columns.empty()) {
-			throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
-		}
-		return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, move(fk_info));
-	}
-	default:
-		throw NotImplementedException("Constraint type not handled yet!");
-	}
-}
-
-unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell, ColumnDefinition &column,
-                                                        idx_t index) {
-	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
-	D_ASSERT(constraint);
-	switch (constraint->contype) {
-	case duckdb_libpgquery::PG_CONSTR_NOTNULL:
-		return make_unique<NotNullConstraint>(index);
-	case duckdb_libpgquery::PG_CONSTR_CHECK:
-		return TransformConstraint(cell);
-	case duckdb_libpgquery::PG_CONSTR_PRIMARY:
-		return make_unique<UniqueConstraint>(index, true);
-	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
-		return make_unique<UniqueConstraint>(index, false);
-	case duckdb_libpgquery::PG_CONSTR_NULL:
-		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_GENERATED_VIRTUAL: {
-		if (column.DefaultValue()) {
-			throw InvalidInputException("DEFAULT constraint on GENERATED column \"%s\" is not allowed", column.Name());
-		}
-		column.SetGeneratedExpression(TransformExpression(constraint->raw_expr));
-		return nullptr;
-	}
-	case duckdb_libpgquery::PG_CONSTR_GENERATED_STORED:
-		throw InvalidInputException("Can not create a STORED generated column!");
-	case duckdb_libpgquery::PG_CONSTR_DEFAULT:
-		column.SetDefaultValue(TransformExpression(constraint->raw_expr));
-		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_COMPRESSION:
-		column.SetCompressionType(CompressionTypeFromString(constraint->compression_name));
-		if (column.CompressionType() == CompressionType::COMPRESSION_AUTO) {
-			throw ParserException("Unrecognized option for column compression, expected none, uncompressed, rle, "
-			                      "dictionary, pfor, bitpacking or fsst");
-		}
-		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		if (constraint->pktable->schemaname) {
-			fk_info.schema = constraint->pktable->schemaname;
-		} else {
-			fk_info.schema = "";
-		}
-		fk_info.table = constraint->pktable->relname;
-		vector<string> pk_columns, fk_columns;
-
-		fk_columns.emplace_back(column.Name().c_str());
-		if (constraint->pk_attrs) {
-			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-			}
-		}
-		if (pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		return make_unique<ForeignKeyConstraint>(pk_columns, fk_columns, move(fk_info));
-	}
-	default:
-		throw NotImplementedException("Constraint not implemented!");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery::PGAIndirection *indirection_node) {
-	// transform the source expression
-	unique_ptr<ParsedExpression> result;
-	result = TransformExpression(indirection_node->arg);
-
-	// now go over the indices
-	// note that a single indirection node can contain multiple indices
-	// this happens for e.g. more complex accesses (e.g. (foo).field1[42])
-	idx_t list_size = 0;
-	for (auto node = indirection_node->indirection->head; node != nullptr; node = node->next) {
-		auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-		D_ASSERT(target);
-
-		switch (target->type) {
-		case duckdb_libpgquery::T_PGAIndices: {
-			// index access (either slice or extract)
-			auto index = (duckdb_libpgquery::PGAIndices *)target;
-			vector<unique_ptr<ParsedExpression>> children;
-			children.push_back(move(result));
-			if (index->is_slice) {
-				// slice
-				children.push_back(!index->lidx ? make_unique<ConstantExpression>(Value())
-				                                : TransformExpression(index->lidx));
-				children.push_back(!index->uidx ? make_unique<ConstantExpression>(Value())
-				                                : TransformExpression(index->uidx));
-				result = make_unique<OperatorExpression>(ExpressionType::ARRAY_SLICE, move(children));
-			} else {
-				// array access
-				D_ASSERT(!index->lidx);
-				D_ASSERT(index->uidx);
-				children.push_back(TransformExpression(index->uidx));
-				result = make_unique<OperatorExpression>(ExpressionType::ARRAY_EXTRACT, move(children));
-			}
-			break;
-		}
-		case duckdb_libpgquery::T_PGString: {
-			auto val = (duckdb_libpgquery::PGValue *)target;
-			vector<unique_ptr<ParsedExpression>> children;
-			children.push_back(move(result));
-			children.push_back(TransformValue(*val));
-			result = make_unique<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, move(children));
-			break;
-		}
-		default:
-			throw NotImplementedException("Unimplemented subscript type");
-		}
-		list_size++;
-		StackCheck(list_size);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::PGBoolExpr *root) {
-	unique_ptr<ParsedExpression> result;
-	for (auto node = root->args->head; node != nullptr; node = node->next) {
-		auto next = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value));
-
-		switch (root->boolop) {
-		case duckdb_libpgquery::PG_AND_EXPR: {
-			if (!result) {
-				result = move(next);
-			} else {
-				result = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, move(result), move(next));
-			}
-			break;
-		}
-		case duckdb_libpgquery::PG_OR_EXPR: {
-			if (!result) {
-				result = move(next);
-			} else {
-				result = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_OR, move(result), move(next));
-			}
-			break;
-		}
-		case duckdb_libpgquery::PG_NOT_EXPR: {
-			if (next->type == ExpressionType::COMPARE_IN) {
-				// convert COMPARE_IN to COMPARE_NOT_IN
-				next->type = ExpressionType::COMPARE_NOT_IN;
-				result = move(next);
-			} else if (next->type >= ExpressionType::COMPARE_EQUAL &&
-			           next->type <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
-				// NOT on a comparison: we can negate the comparison
-				// e.g. NOT(x > y) is equivalent to x <= y
-				next->type = NegateComparisionExpression(next->type);
-				result = move(next);
-			} else {
-				result = make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, move(next));
-			}
-			break;
-		}
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCaseExpr *root) {
-	D_ASSERT(root);
-
-	auto case_node = make_unique<CaseExpression>();
-	for (auto cell = root->args->head; cell != nullptr; cell = cell->next) {
-		CaseCheck case_check;
-
-		auto w = reinterpret_cast<duckdb_libpgquery::PGCaseWhen *>(cell->data.ptr_value);
-		auto test_raw = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->expr));
-		unique_ptr<ParsedExpression> test;
-		auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
-		if (arg) {
-			case_check.when_expr =
-			    make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, move(arg), move(test_raw));
-		} else {
-			case_check.when_expr = move(test_raw);
-		}
-		case_check.then_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->result));
-		case_node->case_checks.push_back(move(case_check));
-	}
-
-	if (root->defresult) {
-		case_node->else_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->defresult));
-	} else {
-		case_node->else_expr = make_unique<ConstantExpression>(Value(LogicalType::SQLNULL));
-	}
-	return move(case_node);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformTypeCast(duckdb_libpgquery::PGTypeCast *root) {
-	D_ASSERT(root);
-
-	// get the type to cast to
-	auto type_name = root->typeName;
-	LogicalType target_type = TransformTypeName(type_name);
-
-	// check for a constant BLOB value, then return ConstantExpression with BLOB
-	if (!root->tryCast && target_type == LogicalType::BLOB && root->arg->type == duckdb_libpgquery::T_PGAConst) {
-		auto c = reinterpret_cast<duckdb_libpgquery::PGAConst *>(root->arg);
-		if (c->val.type == duckdb_libpgquery::T_PGString) {
-			return make_unique<ConstantExpression>(Value::BLOB(string(c->val.val.str)));
-		}
-	}
-	// transform the expression node
-	auto expression = TransformExpression(root->arg);
-	bool try_cast = root->tryCast;
-
-	// now create a cast operation
-	return make_unique<CastExpression>(target_type, move(expression), try_cast);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-// COALESCE(a,b,c) returns the first argument that is NOT NULL, so
-// rewrite into CASE(a IS NOT NULL, a, CASE(b IS NOT NULL, b, c))
-unique_ptr<ParsedExpression> Transformer::TransformCoalesce(duckdb_libpgquery::PGAExpr *root) {
-	D_ASSERT(root);
-
-	auto coalesce_args = reinterpret_cast<duckdb_libpgquery::PGList *>(root->lexpr);
-	D_ASSERT(coalesce_args->length > 0); // parser ensures this already
-
-	auto coalesce_op = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-	for (auto cell = coalesce_args->head; cell; cell = cell->next) {
-		// get the value of the COALESCE
-		auto value_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value));
-		coalesce_op->children.push_back(move(value_expr));
-	}
-	return move(coalesce_op);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgquery::PGNode *node) {
-	auto star = (duckdb_libpgquery::PGAStar *)node;
-	auto result = make_unique<StarExpression>(star->relation ? star->relation : string());
-	if (star->except_list) {
-		for (auto head = star->except_list->head; head; head = head->next) {
-			auto value = (duckdb_libpgquery::PGValue *)head->data.ptr_value;
-			D_ASSERT(value->type == duckdb_libpgquery::T_PGString);
-			string exclude_entry = value->val.str;
-			if (result->exclude_list.find(exclude_entry) != result->exclude_list.end()) {
-				throw ParserException("Duplicate entry \"%s\" in EXCLUDE list", exclude_entry);
-			}
-			result->exclude_list.insert(move(exclude_entry));
-		}
-	}
-	if (star->replace_list) {
-		for (auto head = star->replace_list->head; head; head = head->next) {
-			auto list = (duckdb_libpgquery::PGList *)head->data.ptr_value;
-			D_ASSERT(list->length == 2);
-			auto replace_expression = TransformExpression((duckdb_libpgquery::PGNode *)list->head->data.ptr_value);
-			auto value = (duckdb_libpgquery::PGValue *)list->tail->data.ptr_value;
-			D_ASSERT(value->type == duckdb_libpgquery::T_PGString);
-			string exclude_entry = value->val.str;
-			if (result->replace_list.find(exclude_entry) != result->replace_list.end()) {
-				throw ParserException("Duplicate entry \"%s\" in REPLACE list", exclude_entry);
-			}
-			if (result->exclude_list.find(exclude_entry) != result->exclude_list.end()) {
-				throw ParserException("Column \"%s\" cannot occur in both EXCEPT and REPLACE list", exclude_entry);
-			}
-			result->replace_list.insert(make_pair(move(exclude_entry), move(replace_expression)));
-		}
-	}
-	return move(result);
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::PGColumnRef *root) {
-	auto fields = root->fields;
-	auto head_node = (duckdb_libpgquery::PGNode *)fields->head->data.ptr_value;
-	switch (head_node->type) {
-	case duckdb_libpgquery::T_PGString: {
-		if (fields->length < 1) {
-			throw InternalException("Unexpected field length");
-		}
-		vector<string> column_names;
-		for (auto node = fields->head; node; node = node->next) {
-			column_names.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
-		}
-		auto colref = make_unique<ColumnRefExpression>(move(column_names));
-		colref->query_location = root->location;
-		return move(colref);
-	}
-	case duckdb_libpgquery::T_PGAStar: {
-		return TransformStarExpression(head_node);
-	}
-	default:
-		throw NotImplementedException("ColumnRef not implemented!");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PGValue val) {
-	switch (val.type) {
-	case duckdb_libpgquery::T_PGInteger:
-		D_ASSERT(val.val.ival <= NumericLimits<int32_t>::Maximum());
-		return make_unique<ConstantExpression>(Value::INTEGER((int32_t)val.val.ival));
-	case duckdb_libpgquery::T_PGBitString: // FIXME: this should actually convert to BLOB
-	case duckdb_libpgquery::T_PGString:
-		return make_unique<ConstantExpression>(Value(string(val.val.str)));
-	case duckdb_libpgquery::T_PGFloat: {
-		string_t str_val(val.val.str);
-		bool try_cast_as_integer = true;
-		bool try_cast_as_decimal = true;
-		int decimal_position = -1;
-		for (idx_t i = 0; i < str_val.GetSize(); i++) {
-			if (val.val.str[i] == '.') {
-				// decimal point: cast as either decimal or double
-				try_cast_as_integer = false;
-				decimal_position = i;
-			}
-			if (val.val.str[i] == 'e' || val.val.str[i] == 'E') {
-				// found exponent, cast as double
-				try_cast_as_integer = false;
-				try_cast_as_decimal = false;
-			}
-		}
-		if (try_cast_as_integer) {
-			int64_t bigint_value;
-			// try to cast as bigint first
-			if (TryCast::Operation<string_t, int64_t>(str_val, bigint_value)) {
-				// successfully cast to bigint: bigint value
-				return make_unique<ConstantExpression>(Value::BIGINT(bigint_value));
-			}
-			hugeint_t hugeint_value;
-			// if that is not successful; try to cast as hugeint
-			if (TryCast::Operation<string_t, hugeint_t>(str_val, hugeint_value)) {
-				// successfully cast to bigint: bigint value
-				return make_unique<ConstantExpression>(Value::HUGEINT(hugeint_value));
-			}
-		}
-		idx_t decimal_offset = val.val.str[0] == '-' ? 3 : 2;
-		if (try_cast_as_decimal && decimal_position >= 0 &&
-		    str_val.GetSize() < Decimal::MAX_WIDTH_DECIMAL + decimal_offset) {
-			// figure out the width/scale based on the decimal position
-			auto width = uint8_t(str_val.GetSize() - 1);
-			auto scale = uint8_t(width - decimal_position);
-			if (val.val.str[0] == '-') {
-				width--;
-			}
-			if (width <= Decimal::MAX_WIDTH_DECIMAL) {
-				// we can cast the value as a decimal
-				Value val = Value(str_val);
-				val = val.CastAs(LogicalType::DECIMAL(width, scale));
-				return make_unique<ConstantExpression>(move(val));
-			}
-		}
-		// if there is a decimal or the value is too big to cast as either hugeint or bigint
-		double dbl_value = Cast::Operation<string_t, double>(str_val);
-		return make_unique<ConstantExpression>(Value::DOUBLE(dbl_value));
-	}
-	case duckdb_libpgquery::T_PGNull:
-		return make_unique<ConstantExpression>(Value(LogicalType::SQLNULL));
-	default:
-		throw NotImplementedException("Value not implemented!");
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::PGAConst *c) {
-	return TransformValue(c->val);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformResTarget(duckdb_libpgquery::PGResTarget *root) {
-	D_ASSERT(root);
-
-	auto expr = TransformExpression(root->val);
-	if (!expr) {
-		return nullptr;
-	}
-	if (root->name) {
-		expr->alias = string(root->name);
-	}
-	return expr;
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr *root) {
-	D_ASSERT(root);
-
-	auto expr = TransformExpression((duckdb_libpgquery::PGNode *)root->arg);
-	if (root->name) {
-		expr->alias = string(root->name);
-	}
-	return expr;
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery::PGNode *node) {
-	if (!node) {
-		return nullptr;
-	}
-
-	auto stack_checker = StackCheck();
-
-	switch (node->type) {
-	case duckdb_libpgquery::T_PGColumnRef:
-		return TransformColumnRef(reinterpret_cast<duckdb_libpgquery::PGColumnRef *>(node));
-	case duckdb_libpgquery::T_PGAConst:
-		return TransformConstant(reinterpret_cast<duckdb_libpgquery::PGAConst *>(node));
-	case duckdb_libpgquery::T_PGAExpr:
-		return TransformAExpr(reinterpret_cast<duckdb_libpgquery::PGAExpr *>(node));
-	case duckdb_libpgquery::T_PGFuncCall:
-		return TransformFuncCall(reinterpret_cast<duckdb_libpgquery::PGFuncCall *>(node));
-	case duckdb_libpgquery::T_PGBoolExpr:
-		return TransformBoolExpr(reinterpret_cast<duckdb_libpgquery::PGBoolExpr *>(node));
-	case duckdb_libpgquery::T_PGTypeCast:
-		return TransformTypeCast(reinterpret_cast<duckdb_libpgquery::PGTypeCast *>(node));
-	case duckdb_libpgquery::T_PGCaseExpr:
-		return TransformCase(reinterpret_cast<duckdb_libpgquery::PGCaseExpr *>(node));
-	case duckdb_libpgquery::T_PGSubLink:
-		return TransformSubquery(reinterpret_cast<duckdb_libpgquery::PGSubLink *>(node));
-	case duckdb_libpgquery::T_PGCoalesceExpr:
-		return TransformCoalesce(reinterpret_cast<duckdb_libpgquery::PGAExpr *>(node));
-	case duckdb_libpgquery::T_PGNullTest:
-		return TransformNullTest(reinterpret_cast<duckdb_libpgquery::PGNullTest *>(node));
-	case duckdb_libpgquery::T_PGResTarget:
-		return TransformResTarget(reinterpret_cast<duckdb_libpgquery::PGResTarget *>(node));
-	case duckdb_libpgquery::T_PGParamRef:
-		return TransformParamRef(reinterpret_cast<duckdb_libpgquery::PGParamRef *>(node));
-	case duckdb_libpgquery::T_PGNamedArgExpr:
-		return TransformNamedArg(reinterpret_cast<duckdb_libpgquery::PGNamedArgExpr *>(node));
-	case duckdb_libpgquery::T_PGSQLValueFunction:
-		return TransformSQLValueFunction(reinterpret_cast<duckdb_libpgquery::PGSQLValueFunction *>(node));
-	case duckdb_libpgquery::T_PGSetToDefault:
-		return make_unique<DefaultExpression>();
-	case duckdb_libpgquery::T_PGCollateClause:
-		return TransformCollateExpr(reinterpret_cast<duckdb_libpgquery::PGCollateClause *>(node));
-	case duckdb_libpgquery::T_PGIntervalConstant:
-		return TransformInterval(reinterpret_cast<duckdb_libpgquery::PGIntervalConstant *>(node));
-	case duckdb_libpgquery::T_PGLambdaFunction:
-		return TransformLambda(reinterpret_cast<duckdb_libpgquery::PGLambdaFunction *>(node));
-	case duckdb_libpgquery::T_PGAIndirection:
-		return TransformArrayAccess(reinterpret_cast<duckdb_libpgquery::PGAIndirection *>(node));
-	case duckdb_libpgquery::T_PGPositionalReference:
-		return TransformPositionalReference(reinterpret_cast<duckdb_libpgquery::PGPositionalReference *>(node));
-	case duckdb_libpgquery::T_PGGroupingFunc:
-		return TransformGroupingFunction(reinterpret_cast<duckdb_libpgquery::PGGroupingFunc *>(node));
-	case duckdb_libpgquery::T_PGAStar:
-		return TransformStarExpression(node);
-	default:
-		throw NotImplementedException("Expr of type %d not implemented\n", (int)node->type);
-	}
-}
-
-void Transformer::TransformExpressionList(duckdb_libpgquery::PGList &list,
-                                          vector<unique_ptr<ParsedExpression>> &result) {
-	for (auto node = list.head; node != nullptr; node = node->next) {
-		auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-		D_ASSERT(target);
-
-		auto expr = TransformExpression(target);
-		D_ASSERT(expr);
-
-		result.push_back(move(expr));
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static ExpressionType WindowToExpressionType(string &fun_name) {
-	if (fun_name == "rank") {
-		return ExpressionType::WINDOW_RANK;
-	} else if (fun_name == "rank_dense" || fun_name == "dense_rank") {
-		return ExpressionType::WINDOW_RANK_DENSE;
-	} else if (fun_name == "percent_rank") {
-		return ExpressionType::WINDOW_PERCENT_RANK;
-	} else if (fun_name == "row_number") {
-		return ExpressionType::WINDOW_ROW_NUMBER;
-	} else if (fun_name == "first_value" || fun_name == "first") {
-		return ExpressionType::WINDOW_FIRST_VALUE;
-	} else if (fun_name == "last_value" || fun_name == "last") {
-		return ExpressionType::WINDOW_LAST_VALUE;
-	} else if (fun_name == "nth_value" || fun_name == "last") {
-		return ExpressionType::WINDOW_NTH_VALUE;
-	} else if (fun_name == "cume_dist") {
-		return ExpressionType::WINDOW_CUME_DIST;
-	} else if (fun_name == "lead") {
-		return ExpressionType::WINDOW_LEAD;
-	} else if (fun_name == "lag") {
-		return ExpressionType::WINDOW_LAG;
-	} else if (fun_name == "ntile") {
-		return ExpressionType::WINDOW_NTILE;
-	}
-
-	return ExpressionType::WINDOW_AGGREGATE;
-}
-
-void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
-	D_ASSERT(window_spec);
-	D_ASSERT(expr);
-
-	// next: partitioning/ordering expressions
-	if (window_spec->partitionClause) {
-		TransformExpressionList(*window_spec->partitionClause, expr->partitions);
-	}
-	TransformOrderBy(window_spec->orderClause, expr->orders);
-}
-
-void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
-	D_ASSERT(window_spec);
-	D_ASSERT(expr);
-
-	// finally: specifics of bounds
-	expr->start_expr = TransformExpression(window_spec->startOffset);
-	expr->end_expr = TransformExpression(window_spec->endOffset);
-
-	if ((window_spec->frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING) ||
-	    (window_spec->frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)) {
-		throw InternalException(
-		    "Window frames starting with unbounded following or ending in unbounded preceding make no sense");
-	}
-
-	const bool rangeMode = (window_spec->frameOptions & FRAMEOPTION_RANGE) != 0;
-	if (window_spec->frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
-		expr->start = WindowBoundary::UNBOUNDED_PRECEDING;
-	} else if (window_spec->frameOptions & FRAMEOPTION_START_VALUE_PRECEDING) {
-		expr->start = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
-	} else if (window_spec->frameOptions & FRAMEOPTION_START_VALUE_FOLLOWING) {
-		expr->start = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
-	} else if (window_spec->frameOptions & FRAMEOPTION_START_CURRENT_ROW) {
-		expr->start = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
-	}
-
-	if (window_spec->frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
-		expr->end = WindowBoundary::UNBOUNDED_FOLLOWING;
-	} else if (window_spec->frameOptions & FRAMEOPTION_END_VALUE_PRECEDING) {
-		expr->end = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
-	} else if (window_spec->frameOptions & FRAMEOPTION_END_VALUE_FOLLOWING) {
-		expr->end = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
-	} else if (window_spec->frameOptions & FRAMEOPTION_END_CURRENT_ROW) {
-		expr->end = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
-	}
-
-	D_ASSERT(expr->start != WindowBoundary::INVALID && expr->end != WindowBoundary::INVALID);
-	if (((window_spec->frameOptions & (FRAMEOPTION_START_VALUE_PRECEDING | FRAMEOPTION_START_VALUE_FOLLOWING)) &&
-	     !expr->start_expr) ||
-	    ((window_spec->frameOptions & (FRAMEOPTION_END_VALUE_PRECEDING | FRAMEOPTION_END_VALUE_FOLLOWING)) &&
-	     !expr->end_expr)) {
-		throw InternalException("Failed to transform window boundary expression");
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall *root) {
-	auto name = root->funcname;
-	string schema, function_name;
-	if (name->length == 2) {
-		// schema + name
-		schema = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
-		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->next->data.ptr_value)->val.str;
-	} else {
-		// unqualified name
-		schema = INVALID_SCHEMA;
-		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
-	}
-
-	auto lowercase_name = StringUtil::Lower(function_name);
-
-	if (root->over) {
-		const auto win_fun_type = WindowToExpressionType(lowercase_name);
-		if (win_fun_type == ExpressionType::INVALID) {
-			throw InternalException("Unknown/unsupported window function");
-		}
-
-		if (root->agg_distinct) {
-			throw ParserException("DISTINCT is not implemented for window functions!");
-		}
-
-		if (root->agg_order) {
-			throw ParserException("ORDER BY is not implemented for window functions!");
-		}
-
-		if (win_fun_type != ExpressionType::WINDOW_AGGREGATE && root->agg_filter) {
-			throw ParserException("FILTER is not implemented for non-aggregate window functions!");
-		}
-		if (root->export_state) {
-			throw ParserException("EXPORT_STATE is not supported for window functions!");
-		}
-
-		if (win_fun_type == ExpressionType::WINDOW_AGGREGATE && root->agg_ignore_nulls) {
-			throw ParserException("IGNORE NULLS is not supported for windowed aggregates");
-		}
-
-		auto expr = make_unique<WindowExpression>(win_fun_type, schema, lowercase_name);
-		expr->ignore_nulls = root->agg_ignore_nulls;
-
-		if (root->agg_filter) {
-			auto filter_expr = TransformExpression(root->agg_filter);
-			expr->filter_expr = move(filter_expr);
-		}
-
-		if (root->args) {
-			vector<unique_ptr<ParsedExpression>> function_list;
-			TransformExpressionList(*root->args, function_list);
-
-			if (win_fun_type == ExpressionType::WINDOW_AGGREGATE) {
-				for (auto &child : function_list) {
-					expr->children.push_back(move(child));
-				}
-			} else {
-				if (!function_list.empty()) {
-					expr->children.push_back(move(function_list[0]));
-				}
-				if (win_fun_type == ExpressionType::WINDOW_LEAD || win_fun_type == ExpressionType::WINDOW_LAG) {
-					if (function_list.size() > 1) {
-						expr->offset_expr = move(function_list[1]);
-					}
-					if (function_list.size() > 2) {
-						expr->default_expr = move(function_list[2]);
-					}
-					if (function_list.size() > 3) {
-						throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-					}
-				} else if (win_fun_type == ExpressionType::WINDOW_NTH_VALUE) {
-					if (function_list.size() > 1) {
-						expr->children.push_back(move(function_list[1]));
-					}
-					if (function_list.size() > 2) {
-						throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-					}
-				} else {
-					if (function_list.size() > 1) {
-						throw ParserException("Incorrect number of parameters for function %s", lowercase_name);
-					}
-				}
-			}
-		}
-		auto window_spec = reinterpret_cast<duckdb_libpgquery::PGWindowDef *>(root->over);
-		if (window_spec->name) {
-			auto it = window_clauses.find(StringUtil::Lower(string(window_spec->name)));
-			if (it == window_clauses.end()) {
-				throw ParserException("window \"%s\" does not exist", window_spec->name);
-			}
-			window_spec = it->second;
-			D_ASSERT(window_spec);
-		}
-		auto window_ref = window_spec;
-		if (window_ref->refname) {
-			auto it = window_clauses.find(StringUtil::Lower(string(window_spec->refname)));
-			if (it == window_clauses.end()) {
-				throw ParserException("window \"%s\" does not exist", window_spec->refname);
-			}
-			window_ref = it->second;
-			D_ASSERT(window_ref);
-		}
-		TransformWindowDef(window_ref, expr.get());
-		TransformWindowFrame(window_spec, expr.get());
-		expr->query_location = root->location;
-		return move(expr);
-	}
-
-	if (root->agg_ignore_nulls) {
-		throw ParserException("IGNORE NULLS is not supported for non-window functions");
-	}
-
-	//  TransformExpressionList??
-	vector<unique_ptr<ParsedExpression>> children;
-	if (root->args != nullptr) {
-		for (auto node = root->args->head; node != nullptr; node = node->next) {
-			auto child_expr = TransformExpression((duckdb_libpgquery::PGNode *)node->data.ptr_value);
-			children.push_back(move(child_expr));
-		}
-	}
-	unique_ptr<ParsedExpression> filter_expr;
-	if (root->agg_filter) {
-		filter_expr = TransformExpression(root->agg_filter);
-	}
-
-	auto order_bys = make_unique<OrderModifier>();
-	TransformOrderBy(root->agg_order, order_bys->orders);
-
-	// Ordered aggregates can be either WITHIN GROUP or after the function arguments
-	if (root->agg_within_group) {
-		//	https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE
-		//  Since we implement "ordered aggregates" without sorting,
-		//  we map all the ones we support to the corresponding aggregate function.
-		if (order_bys->orders.size() != 1) {
-			throw ParserException("Cannot use multiple ORDER BY clauses with WITHIN GROUP");
-		}
-		if (lowercase_name == "percentile_cont") {
-			if (children.size() != 1) {
-				throw ParserException("Wrong number of arguments for PERCENTILE_CONT");
-			}
-			lowercase_name = "quantile_cont";
-		} else if (lowercase_name == "percentile_disc") {
-			if (children.size() != 1) {
-				throw ParserException("Wrong number of arguments for PERCENTILE_DISC");
-			}
-			lowercase_name = "quantile_disc";
-		} else if (lowercase_name == "mode") {
-			if (!children.empty()) {
-				throw ParserException("Wrong number of arguments for MODE");
-			}
-			lowercase_name = "mode";
-		} else {
-			throw ParserException("Unknown ordered aggregate \"%s\".", function_name);
-		}
-	}
-
-	// star gets eaten in the parser
-	if (lowercase_name == "count" && children.empty()) {
-		lowercase_name = "count_star";
-	}
-
-	if (lowercase_name == "if") {
-		if (children.size() != 3) {
-			throw ParserException("Wrong number of arguments to IF.");
-		}
-		auto expr = make_unique<CaseExpression>();
-		CaseCheck check;
-		check.when_expr = move(children[0]);
-		check.then_expr = move(children[1]);
-		expr->case_checks.push_back(move(check));
-		expr->else_expr = move(children[2]);
-		return move(expr);
-	} else if (lowercase_name == "construct_array") {
-		auto construct_array = make_unique<OperatorExpression>(ExpressionType::ARRAY_CONSTRUCTOR);
-		construct_array->children = move(children);
-		return move(construct_array);
-	} else if (lowercase_name == "ifnull") {
-		if (children.size() != 2) {
-			throw ParserException("Wrong number of arguments to IFNULL.");
-		}
-
-		//  Two-argument COALESCE
-		auto coalesce_op = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-		coalesce_op->children.push_back(move(children[0]));
-		coalesce_op->children.push_back(move(children[1]));
-		return move(coalesce_op);
-	}
-
-	auto function = make_unique<FunctionExpression>(schema, lowercase_name.c_str(), move(children), move(filter_expr),
-	                                                move(order_bys), root->agg_distinct, false, root->export_state);
-	function->query_location = root->location;
-
-	return move(function);
-}
-
-static string SQLValueOpToString(duckdb_libpgquery::PGSQLValueFunctionOp op) {
-	switch (op) {
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_DATE:
-		return "current_date";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_TIME:
-		return "get_current_time";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_TIME_N:
-		return "current_time_n";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_TIMESTAMP:
-		return "get_current_timestamp";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_TIMESTAMP_N:
-		return "current_timestamp_n";
-	case duckdb_libpgquery::PG_SVFOP_LOCALTIME:
-		return "current_localtime";
-	case duckdb_libpgquery::PG_SVFOP_LOCALTIME_N:
-		return "current_localtime_n";
-	case duckdb_libpgquery::PG_SVFOP_LOCALTIMESTAMP:
-		return "current_localtimestamp";
-	case duckdb_libpgquery::PG_SVFOP_LOCALTIMESTAMP_N:
-		return "current_localtimestamp_n";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_ROLE:
-		return "current_role";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_USER:
-		return "current_user";
-	case duckdb_libpgquery::PG_SVFOP_USER:
-		return "user";
-	case duckdb_libpgquery::PG_SVFOP_SESSION_USER:
-		return "session_user";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_CATALOG:
-		return "current_catalog";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_SCHEMA:
-		return "current_schema";
-	default:
-		throw InternalException("Could not find named SQL value function specification " + to_string((int)op));
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction *node) {
-	D_ASSERT(node);
-	vector<unique_ptr<ParsedExpression>> children;
-	auto fname = SQLValueOpToString(node->op);
-	return make_unique<FunctionExpression>(DEFAULT_SCHEMA, fname, move(children));
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc *n) {
-	auto op = make_unique<OperatorExpression>(ExpressionType::GROUPING_FUNCTION);
-	for (auto node = n->args->head; node; node = node->next) {
-		auto n = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
-		op->children.push_back(TransformExpression(n));
-	}
-	op->query_location = n->location;
-	return move(op);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::PGIntervalConstant *node) {
-	// handle post-fix notation of INTERVAL
-
-	// three scenarios
-	// interval (expr) year
-	// interval 'string' year
-	// interval int year
-	unique_ptr<ParsedExpression> expr;
-	switch (node->val_type) {
-	case duckdb_libpgquery::T_PGAExpr:
-		expr = TransformExpression(node->eval);
-		break;
-	case duckdb_libpgquery::T_PGString:
-		expr = make_unique<ConstantExpression>(Value(node->sval));
-		break;
-	case duckdb_libpgquery::T_PGInteger:
-		expr = make_unique<ConstantExpression>(Value(node->ival));
-		break;
-	default:
-		throw InternalException("Unsupported interval transformation");
-	}
-
-	if (!node->typmods) {
-		return make_unique<CastExpression>(LogicalType::INTERVAL, move(expr));
-	}
-
-	int32_t mask = ((duckdb_libpgquery::PGAConst *)node->typmods->head->data.ptr_value)->val.val.ival;
-	// these seemingly random constants are from datetime.hpp
-	// they are copied here to avoid having to include this header
-	// the bitshift is from the function INTERVAL_MASK in the parser
-	constexpr int32_t MONTH_MASK = 1 << 1;
-	constexpr int32_t YEAR_MASK = 1 << 2;
-	constexpr int32_t DAY_MASK = 1 << 3;
-	constexpr int32_t HOUR_MASK = 1 << 10;
-	constexpr int32_t MINUTE_MASK = 1 << 11;
-	constexpr int32_t SECOND_MASK = 1 << 12;
-	constexpr int32_t MILLISECOND_MASK = 1 << 13;
-	constexpr int32_t MICROSECOND_MASK = 1 << 14;
-
-	// we need to check certain combinations
-	// because certain interval masks (e.g. INTERVAL '10' HOURS TO DAYS) set multiple bits
-	// for now we don't support all of the combined ones
-	// (we might add support if someone complains about it)
-
-	string fname;
-	LogicalType target_type;
-	if (mask & YEAR_MASK && mask & MONTH_MASK) {
-		// DAY TO HOUR
-		throw ParserException("YEAR TO MONTH is not supported");
-	} else if (mask & DAY_MASK && mask & HOUR_MASK) {
-		// DAY TO HOUR
-		throw ParserException("DAY TO HOUR is not supported");
-	} else if (mask & DAY_MASK && mask & MINUTE_MASK) {
-		// DAY TO MINUTE
-		throw ParserException("DAY TO MINUTE is not supported");
-	} else if (mask & DAY_MASK && mask & SECOND_MASK) {
-		// DAY TO SECOND
-		throw ParserException("DAY TO SECOND is not supported");
-	} else if (mask & HOUR_MASK && mask & MINUTE_MASK) {
-		// DAY TO SECOND
-		throw ParserException("HOUR TO MINUTE is not supported");
-	} else if (mask & HOUR_MASK && mask & SECOND_MASK) {
-		// DAY TO SECOND
-		throw ParserException("HOUR TO SECOND is not supported");
-	} else if (mask & MINUTE_MASK && mask & SECOND_MASK) {
-		// DAY TO SECOND
-		throw ParserException("MINUTE TO SECOND is not supported");
-	} else if (mask & YEAR_MASK) {
-		// YEAR
-		fname = "to_years";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & MONTH_MASK) {
-		// MONTH
-		fname = "to_months";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & DAY_MASK) {
-		// DAY
-		fname = "to_days";
-		target_type = LogicalType::INTEGER;
-	} else if (mask & HOUR_MASK) {
-		// HOUR
-		fname = "to_hours";
-		target_type = LogicalType::BIGINT;
-	} else if (mask & MINUTE_MASK) {
-		// MINUTE
-		fname = "to_minutes";
-		target_type = LogicalType::BIGINT;
-	} else if (mask & SECOND_MASK) {
-		// SECOND
-		fname = "to_seconds";
-		target_type = LogicalType::BIGINT;
-	} else if (mask & MILLISECOND_MASK) {
-		// MILLISECOND
-		fname = "to_milliseconds";
-		target_type = LogicalType::BIGINT;
-	} else if (mask & MICROSECOND_MASK) {
-		// SECOND
-		fname = "to_microseconds";
-		target_type = LogicalType::BIGINT;
-	} else {
-		throw InternalException("Unsupported interval post-fix");
-	}
-	// first push a cast to the target type
-	expr = make_unique<CastExpression>(target_type, move(expr));
-	// now push the operation
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(move(expr));
-	return make_unique<FunctionExpression>(fname, move(children));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformNullTest(duckdb_libpgquery::PGNullTest *root) {
-	D_ASSERT(root);
-	auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
-	if (root->argisrow) {
-		throw NotImplementedException("IS NULL argisrow");
-	}
-	ExpressionType expr_type = (root->nulltesttype == duckdb_libpgquery::PG_IS_NULL)
-	                               ? ExpressionType::OPERATOR_IS_NULL
-	                               : ExpressionType::OPERATOR_IS_NOT_NULL;
-
-	return unique_ptr<ParsedExpression>(new OperatorExpression(expr_type, move(arg)));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGLambdaFunction *node) {
-	if (!node->lhs) {
-		throw ParserException("Lambda function must have parameters");
-	}
-	auto lhs = TransformExpression(node->lhs);
-	auto rhs = TransformExpression(node->rhs);
-	return make_unique<LambdaExpression>(move(lhs), move(rhs));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformUnaryOperator(const string &op, unique_ptr<ParsedExpression> child) {
-	const auto schema = DEFAULT_SCHEMA;
-
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(move(child));
-
-	// built-in operator function
-	auto result = make_unique<FunctionExpression>(schema, op, move(children));
-	result->is_operator = true;
-	return move(result);
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &op, unique_ptr<ParsedExpression> left,
-                                                                  unique_ptr<ParsedExpression> right) {
-	const auto schema = DEFAULT_SCHEMA;
-
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(move(left));
-	children.push_back(move(right));
-
-	if (op == "~" || op == "!~") {
-		// rewrite 'asdf' SIMILAR TO '.*sd.*' into regexp_full_match('asdf', '.*sd.*')
-		bool invert_similar = op == "!~";
-
-		auto result = make_unique<FunctionExpression>(schema, "regexp_full_match", move(children));
-		if (invert_similar) {
-			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, move(result));
-		} else {
-			return move(result);
-		}
-	} else {
-		auto target_type = OperatorToExpressionType(op);
-		if (target_type != ExpressionType::INVALID) {
-			// built-in comparison operator
-			return make_unique<ComparisonExpression>(target_type, move(children[0]), move(children[1]));
-		}
-		// not a special operator: convert to a function expression
-		auto result = make_unique<FunctionExpression>(schema, op, move(children));
-		result->is_operator = true;
-		return move(result);
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgquery::PGAExpr *root) {
-	D_ASSERT(root);
-	auto name = string((reinterpret_cast<duckdb_libpgquery::PGValue *>(root->name->head->data.ptr_value))->val.str);
-
-	switch (root->kind) {
-	case duckdb_libpgquery::PG_AEXPR_OP_ALL:
-	case duckdb_libpgquery::PG_AEXPR_OP_ANY: {
-		// left=ANY(right)
-		// we turn this into left=ANY((SELECT UNNEST(right)))
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
-
-		auto subquery_expr = make_unique<SubqueryExpression>();
-		auto select_statement = make_unique<SelectStatement>();
-		auto select_node = make_unique<SelectNode>();
-		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(move(right_expr));
-
-		select_node->select_list.push_back(make_unique<FunctionExpression>("UNNEST", move(children)));
-		select_node->from_table = make_unique<EmptyTableRef>();
-		select_statement->node = move(select_node);
-		subquery_expr->subquery = move(select_statement);
-		subquery_expr->subquery_type = SubqueryType::ANY;
-		subquery_expr->child = move(left_expr);
-		subquery_expr->comparison_type = OperatorToExpressionType(name);
-		subquery_expr->query_location = root->location;
-
-		if (root->kind == duckdb_libpgquery::PG_AEXPR_OP_ALL) {
-			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
-			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
-			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisionExpression(subquery_expr->comparison_type);
-			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, move(subquery_expr));
-		}
-		return move(subquery_expr);
-	}
-	case duckdb_libpgquery::PG_AEXPR_IN: {
-		auto left_expr = TransformExpression(root->lexpr);
-		ExpressionType operator_type;
-		// this looks very odd, but seems to be the way to find out its NOT IN
-		if (name == "<>") {
-			// NOT IN
-			operator_type = ExpressionType::COMPARE_NOT_IN;
-		} else {
-			// IN
-			operator_type = ExpressionType::COMPARE_IN;
-		}
-		auto result = make_unique<OperatorExpression>(operator_type, move(left_expr));
-		result->query_location = root->location;
-		TransformExpressionList(*((duckdb_libpgquery::PGList *)root->rexpr), result->children);
-		return move(result);
-	}
-	// rewrite NULLIF(a, b) into CASE WHEN a=b THEN NULL ELSE a END
-	case duckdb_libpgquery::PG_AEXPR_NULLIF: {
-		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(TransformExpression(root->lexpr));
-		children.push_back(TransformExpression(root->rexpr));
-		return make_unique<FunctionExpression>("nullif", move(children));
-	}
-	// rewrite (NOT) X BETWEEN A AND B into (NOT) AND(GREATERTHANOREQUALTO(X,
-	// A), LESSTHANOREQUALTO(X, B))
-	case duckdb_libpgquery::PG_AEXPR_BETWEEN:
-	case duckdb_libpgquery::PG_AEXPR_NOT_BETWEEN: {
-		auto between_args = reinterpret_cast<duckdb_libpgquery::PGList *>(root->rexpr);
-		if (between_args->length != 2 || !between_args->head->data.ptr_value || !between_args->tail->data.ptr_value) {
-			throw InternalException("(NOT) BETWEEN needs two args");
-		}
-
-		auto input = TransformExpression(root->lexpr);
-		auto between_left =
-		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->head->data.ptr_value));
-		auto between_right =
-		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->tail->data.ptr_value));
-
-		auto compare_between = make_unique<BetweenExpression>(move(input), move(between_left), move(between_right));
-		if (root->kind == duckdb_libpgquery::PG_AEXPR_BETWEEN) {
-			return move(compare_between);
-		} else {
-			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, move(compare_between));
-		}
-	}
-	// rewrite SIMILAR TO into regexp_full_match('asdf', '.*sd.*')
-	case duckdb_libpgquery::PG_AEXPR_SIMILAR: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
-
-		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(move(left_expr));
-
-		auto &similar_func = reinterpret_cast<FunctionExpression &>(*right_expr);
-		D_ASSERT(similar_func.function_name == "similar_escape");
-		D_ASSERT(similar_func.children.size() == 2);
-		if (similar_func.children[1]->type != ExpressionType::VALUE_CONSTANT) {
-			throw NotImplementedException("Custom escape in SIMILAR TO");
-		}
-		auto &constant = (ConstantExpression &)*similar_func.children[1];
-		if (!constant.value.IsNull()) {
-			throw NotImplementedException("Custom escape in SIMILAR TO");
-		}
-		// take the child of the similar_func
-		children.push_back(move(similar_func.children[0]));
-
-		// this looks very odd, but seems to be the way to find out its NOT IN
-		bool invert_similar = false;
-		if (name == "!~") {
-			// NOT SIMILAR TO
-			invert_similar = true;
-		}
-		const auto schema = DEFAULT_SCHEMA;
-		const auto regex_function = "regexp_full_match";
-		auto result = make_unique<FunctionExpression>(schema, regex_function, move(children));
-
-		if (invert_similar) {
-			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, move(result));
-		} else {
-			return move(result);
-		}
-	}
-	case duckdb_libpgquery::PG_AEXPR_NOT_DISTINCT: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
-		return make_unique<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM, move(left_expr),
-		                                         move(right_expr));
-	}
-	case duckdb_libpgquery::PG_AEXPR_DISTINCT: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
-		return make_unique<ComparisonExpression>(ExpressionType::COMPARE_DISTINCT_FROM, move(left_expr),
-		                                         move(right_expr));
-	}
-
-	default:
-		break;
-	}
-	auto left_expr = TransformExpression(root->lexpr);
-	auto right_expr = TransformExpression(root->rexpr);
-
-	if (!left_expr) {
-		// prefix operator
-		return TransformUnaryOperator(name, move(right_expr));
-	} else if (!right_expr) {
-		// postfix operator, only ! is currently supported
-		return TransformUnaryOperator(name + "__postfix", move(left_expr));
-	} else {
-		return TransformBinaryOperator(name, move(left_expr), move(right_expr));
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr *root) {
-	auto result = TransformAExprInternal(root);
-	if (result) {
-		result->query_location = root->location;
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef *node) {
-	D_ASSERT(node);
-	auto expr = make_unique<ParameterExpression>();
-	if (node->number < 0) {
-		throw ParserException("Parameter numbers cannot be negative");
-	}
-	if (node->number == 0) {
-		expr->parameter_nr = ParamCount() + 1;
-	} else {
-		expr->parameter_nr = node->number;
-	}
-	SetParamCount(MaxValue<idx_t>(ParamCount(), expr->parameter_nr));
-	return move(expr);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_libpgquery::PGPositionalReference *node) {
-	if (node->position <= 0) {
-		throw ParserException("Positional reference node needs to be >= 1");
-	}
-	auto result = make_unique<PositionalReferenceExpression>(node->position);
-	result->query_location = node->location;
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink *root) {
-	D_ASSERT(root);
-	auto subquery_expr = make_unique<SubqueryExpression>();
-
-	subquery_expr->subquery = TransformSelect(root->subselect);
-	D_ASSERT(subquery_expr->subquery);
-	D_ASSERT(subquery_expr->subquery->node->GetSelectList().size() > 0);
-
-	switch (root->subLinkType) {
-	case duckdb_libpgquery::PG_EXISTS_SUBLINK: {
-		subquery_expr->subquery_type = SubqueryType::EXISTS;
-		break;
-	}
-	case duckdb_libpgquery::PG_ANY_SUBLINK:
-	case duckdb_libpgquery::PG_ALL_SUBLINK: {
-		// comparison with ANY() or ALL()
-		subquery_expr->subquery_type = SubqueryType::ANY;
-		subquery_expr->child = TransformExpression(root->testexpr);
-		// get the operator name
-		if (!root->operName) {
-			// simple IN
-			subquery_expr->comparison_type = ExpressionType::COMPARE_EQUAL;
-		} else {
-			auto operator_name =
-			    string((reinterpret_cast<duckdb_libpgquery::PGValue *>(root->operName->head->data.ptr_value))->val.str);
-			subquery_expr->comparison_type = OperatorToExpressionType(operator_name);
-		}
-		if (subquery_expr->comparison_type != ExpressionType::COMPARE_EQUAL &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_NOTEQUAL &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_GREATERTHAN &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_LESSTHAN &&
-		    subquery_expr->comparison_type != ExpressionType::COMPARE_LESSTHANOREQUALTO) {
-			throw ParserException("ANY and ALL operators require one of =,<>,>,<,>=,<= comparisons!");
-		}
-		if (root->subLinkType == duckdb_libpgquery::PG_ALL_SUBLINK) {
-			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
-			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
-			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisionExpression(subquery_expr->comparison_type);
-			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, move(subquery_expr));
-		}
-		break;
-	}
-	case duckdb_libpgquery::PG_EXPR_SUBLINK: {
-		// return a single scalar value from the subquery
-		// no child expression to compare to
-		subquery_expr->subquery_type = SubqueryType::SCALAR;
-		break;
-	}
-	default:
-		throw NotImplementedException("Subquery of type %d not implemented\n", (int)root->subLinkType);
-	}
-	subquery_expr->query_location = root->location;
-	return move(subquery_expr);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-std::string Transformer::NodetypeToString(duckdb_libpgquery::PGNodeTag type) { // LCOV_EXCL_START
-	switch (type) {
-	case duckdb_libpgquery::T_PGInvalid:
-		return "T_Invalid";
-	case duckdb_libpgquery::T_PGIndexInfo:
-		return "T_IndexInfo";
-	case duckdb_libpgquery::T_PGExprContext:
-		return "T_ExprContext";
-	case duckdb_libpgquery::T_PGProjectionInfo:
-		return "T_ProjectionInfo";
-	case duckdb_libpgquery::T_PGJunkFilter:
-		return "T_JunkFilter";
-	case duckdb_libpgquery::T_PGResultRelInfo:
-		return "T_ResultRelInfo";
-	case duckdb_libpgquery::T_PGEState:
-		return "T_EState";
-	case duckdb_libpgquery::T_PGTupleTableSlot:
-		return "T_TupleTableSlot";
-	case duckdb_libpgquery::T_PGPlan:
-		return "T_Plan";
-	case duckdb_libpgquery::T_PGResult:
-		return "T_Result";
-	case duckdb_libpgquery::T_PGProjectSet:
-		return "T_ProjectSet";
-	case duckdb_libpgquery::T_PGModifyTable:
-		return "T_ModifyTable";
-	case duckdb_libpgquery::T_PGAppend:
-		return "T_Append";
-	case duckdb_libpgquery::T_PGMergeAppend:
-		return "T_MergeAppend";
-	case duckdb_libpgquery::T_PGRecursiveUnion:
-		return "T_RecursiveUnion";
-	case duckdb_libpgquery::T_PGBitmapAnd:
-		return "T_BitmapAnd";
-	case duckdb_libpgquery::T_PGBitmapOr:
-		return "T_BitmapOr";
-	case duckdb_libpgquery::T_PGScan:
-		return "T_Scan";
-	case duckdb_libpgquery::T_PGSeqScan:
-		return "T_SeqScan";
-	case duckdb_libpgquery::T_PGSampleScan:
-		return "T_SampleScan";
-	case duckdb_libpgquery::T_PGIndexScan:
-		return "T_IndexScan";
-	case duckdb_libpgquery::T_PGIndexOnlyScan:
-		return "T_IndexOnlyScan";
-	case duckdb_libpgquery::T_PGBitmapIndexScan:
-		return "T_BitmapIndexScan";
-	case duckdb_libpgquery::T_PGBitmapHeapScan:
-		return "T_BitmapHeapScan";
-	case duckdb_libpgquery::T_PGTidScan:
-		return "T_TidScan";
-	case duckdb_libpgquery::T_PGSubqueryScan:
-		return "T_SubqueryScan";
-	case duckdb_libpgquery::T_PGFunctionScan:
-		return "T_FunctionScan";
-	case duckdb_libpgquery::T_PGValuesScan:
-		return "T_ValuesScan";
-	case duckdb_libpgquery::T_PGTableFuncScan:
-		return "T_TableFuncScan";
-	case duckdb_libpgquery::T_PGCteScan:
-		return "T_CteScan";
-	case duckdb_libpgquery::T_PGNamedTuplestoreScan:
-		return "T_NamedTuplestoreScan";
-	case duckdb_libpgquery::T_PGWorkTableScan:
-		return "T_WorkTableScan";
-	case duckdb_libpgquery::T_PGForeignScan:
-		return "T_ForeignScan";
-	case duckdb_libpgquery::T_PGCustomScan:
-		return "T_CustomScan";
-	case duckdb_libpgquery::T_PGJoin:
-		return "T_Join";
-	case duckdb_libpgquery::T_PGNestLoop:
-		return "T_NestLoop";
-	case duckdb_libpgquery::T_PGMergeJoin:
-		return "T_MergeJoin";
-	case duckdb_libpgquery::T_PGHashJoin:
-		return "T_HashJoin";
-	case duckdb_libpgquery::T_PGMaterial:
-		return "T_Material";
-	case duckdb_libpgquery::T_PGSort:
-		return "T_Sort";
-	case duckdb_libpgquery::T_PGGroup:
-		return "T_Group";
-	case duckdb_libpgquery::T_PGAgg:
-		return "T_Agg";
-	case duckdb_libpgquery::T_PGWindowAgg:
-		return "T_WindowAgg";
-	case duckdb_libpgquery::T_PGUnique:
-		return "T_Unique";
-	case duckdb_libpgquery::T_PGGather:
-		return "T_Gather";
-	case duckdb_libpgquery::T_PGGatherMerge:
-		return "T_GatherMerge";
-	case duckdb_libpgquery::T_PGHash:
-		return "T_Hash";
-	case duckdb_libpgquery::T_PGSetOp:
-		return "T_SetOp";
-	case duckdb_libpgquery::T_PGLockRows:
-		return "T_LockRows";
-	case duckdb_libpgquery::T_PGLimit:
-		return "T_Limit";
-	case duckdb_libpgquery::T_PGNestLoopParam:
-		return "T_NestLoopParam";
-	case duckdb_libpgquery::T_PGPlanRowMark:
-		return "T_PlanRowMark";
-	case duckdb_libpgquery::T_PGPlanInvalItem:
-		return "T_PlanInvalItem";
-	case duckdb_libpgquery::T_PGPlanState:
-		return "T_PlanState";
-	case duckdb_libpgquery::T_PGResultState:
-		return "T_ResultState";
-	case duckdb_libpgquery::T_PGProjectSetState:
-		return "T_ProjectSetState";
-	case duckdb_libpgquery::T_PGModifyTableState:
-		return "T_ModifyTableState";
-	case duckdb_libpgquery::T_PGAppendState:
-		return "T_AppendState";
-	case duckdb_libpgquery::T_PGMergeAppendState:
-		return "T_MergeAppendState";
-	case duckdb_libpgquery::T_PGRecursiveUnionState:
-		return "T_RecursiveUnionState";
-	case duckdb_libpgquery::T_PGBitmapAndState:
-		return "T_BitmapAndState";
-	case duckdb_libpgquery::T_PGBitmapOrState:
-		return "T_BitmapOrState";
-	case duckdb_libpgquery::T_PGScanState:
-		return "T_ScanState";
-	case duckdb_libpgquery::T_PGSeqScanState:
-		return "T_SeqScanState";
-	case duckdb_libpgquery::T_PGSampleScanState:
-		return "T_SampleScanState";
-	case duckdb_libpgquery::T_PGIndexScanState:
-		return "T_IndexScanState";
-	case duckdb_libpgquery::T_PGIndexOnlyScanState:
-		return "T_IndexOnlyScanState";
-	case duckdb_libpgquery::T_PGBitmapIndexScanState:
-		return "T_BitmapIndexScanState";
-	case duckdb_libpgquery::T_PGBitmapHeapScanState:
-		return "T_BitmapHeapScanState";
-	case duckdb_libpgquery::T_PGTidScanState:
-		return "T_TidScanState";
-	case duckdb_libpgquery::T_PGSubqueryScanState:
-		return "T_SubqueryScanState";
-	case duckdb_libpgquery::T_PGFunctionScanState:
-		return "T_FunctionScanState";
-	case duckdb_libpgquery::T_PGTableFuncScanState:
-		return "T_TableFuncScanState";
-	case duckdb_libpgquery::T_PGValuesScanState:
-		return "T_ValuesScanState";
-	case duckdb_libpgquery::T_PGCteScanState:
-		return "T_CteScanState";
-	case duckdb_libpgquery::T_PGNamedTuplestoreScanState:
-		return "T_NamedTuplestoreScanState";
-	case duckdb_libpgquery::T_PGWorkTableScanState:
-		return "T_WorkTableScanState";
-	case duckdb_libpgquery::T_PGForeignScanState:
-		return "T_ForeignScanState";
-	case duckdb_libpgquery::T_PGCustomScanState:
-		return "T_CustomScanState";
-	case duckdb_libpgquery::T_PGJoinState:
-		return "T_JoinState";
-	case duckdb_libpgquery::T_PGNestLoopState:
-		return "T_NestLoopState";
-	case duckdb_libpgquery::T_PGMergeJoinState:
-		return "T_MergeJoinState";
-	case duckdb_libpgquery::T_PGHashJoinState:
-		return "T_HashJoinState";
-	case duckdb_libpgquery::T_PGMaterialState:
-		return "T_MaterialState";
-	case duckdb_libpgquery::T_PGSortState:
-		return "T_SortState";
-	case duckdb_libpgquery::T_PGGroupState:
-		return "T_GroupState";
-	case duckdb_libpgquery::T_PGAggState:
-		return "T_AggState";
-	case duckdb_libpgquery::T_PGWindowAggState:
-		return "T_WindowAggState";
-	case duckdb_libpgquery::T_PGUniqueState:
-		return "T_UniqueState";
-	case duckdb_libpgquery::T_PGGatherState:
-		return "T_GatherState";
-	case duckdb_libpgquery::T_PGGatherMergeState:
-		return "T_GatherMergeState";
-	case duckdb_libpgquery::T_PGHashState:
-		return "T_HashState";
-	case duckdb_libpgquery::T_PGSetOpState:
-		return "T_SetOpState";
-	case duckdb_libpgquery::T_PGLockRowsState:
-		return "T_LockRowsState";
-	case duckdb_libpgquery::T_PGLimitState:
-		return "T_LimitState";
-	case duckdb_libpgquery::T_PGAlias:
-		return "T_Alias";
-	case duckdb_libpgquery::T_PGRangeVar:
-		return "T_RangeVar";
-	case duckdb_libpgquery::T_PGTableFunc:
-		return "T_TableFunc";
-	case duckdb_libpgquery::T_PGExpr:
-		return "T_Expr";
-	case duckdb_libpgquery::T_PGVar:
-		return "T_Var";
-	case duckdb_libpgquery::T_PGConst:
-		return "T_Const";
-	case duckdb_libpgquery::T_PGParam:
-		return "T_Param";
-	case duckdb_libpgquery::T_PGAggref:
-		return "T_Aggref";
-	case duckdb_libpgquery::T_PGGroupingFunc:
-		return "T_GroupingFunc";
-	case duckdb_libpgquery::T_PGWindowFunc:
-		return "T_WindowFunc";
-	case duckdb_libpgquery::T_PGArrayRef:
-		return "T_ArrayRef";
-	case duckdb_libpgquery::T_PGFuncExpr:
-		return "T_FuncExpr";
-	case duckdb_libpgquery::T_PGNamedArgExpr:
-		return "T_NamedArgExpr";
-	case duckdb_libpgquery::T_PGOpExpr:
-		return "T_OpExpr";
-	case duckdb_libpgquery::T_PGDistinctExpr:
-		return "T_DistinctExpr";
-	case duckdb_libpgquery::T_PGNullIfExpr:
-		return "T_NullIfExpr";
-	case duckdb_libpgquery::T_PGScalarArrayOpExpr:
-		return "T_ScalarArrayOpExpr";
-	case duckdb_libpgquery::T_PGBoolExpr:
-		return "T_BoolExpr";
-	case duckdb_libpgquery::T_PGSubLink:
-		return "T_SubLink";
-	case duckdb_libpgquery::T_PGSubPlan:
-		return "T_SubPlan";
-	case duckdb_libpgquery::T_PGAlternativeSubPlan:
-		return "T_AlternativeSubPlan";
-	case duckdb_libpgquery::T_PGFieldSelect:
-		return "T_FieldSelect";
-	case duckdb_libpgquery::T_PGFieldStore:
-		return "T_FieldStore";
-	case duckdb_libpgquery::T_PGRelabelType:
-		return "T_RelabelType";
-	case duckdb_libpgquery::T_PGCoerceViaIO:
-		return "T_CoerceViaIO";
-	case duckdb_libpgquery::T_PGArrayCoerceExpr:
-		return "T_ArrayCoerceExpr";
-	case duckdb_libpgquery::T_PGConvertRowtypeExpr:
-		return "T_ConvertRowtypeExpr";
-	case duckdb_libpgquery::T_PGCollateExpr:
-		return "T_CollateExpr";
-	case duckdb_libpgquery::T_PGCaseExpr:
-		return "T_CaseExpr";
-	case duckdb_libpgquery::T_PGCaseWhen:
-		return "T_CaseWhen";
-	case duckdb_libpgquery::T_PGCaseTestExpr:
-		return "T_CaseTestExpr";
-	case duckdb_libpgquery::T_PGArrayExpr:
-		return "T_ArrayExpr";
-	case duckdb_libpgquery::T_PGRowExpr:
-		return "T_RowExpr";
-	case duckdb_libpgquery::T_PGRowCompareExpr:
-		return "T_RowCompareExpr";
-	case duckdb_libpgquery::T_PGCoalesceExpr:
-		return "T_CoalesceExpr";
-	case duckdb_libpgquery::T_PGMinMaxExpr:
-		return "T_MinMaxExpr";
-	case duckdb_libpgquery::T_PGSQLValueFunction:
-		return "T_SQLValueFunction";
-	case duckdb_libpgquery::T_PGXmlExpr:
-		return "T_XmlExpr";
-	case duckdb_libpgquery::T_PGNullTest:
-		return "T_NullTest";
-	case duckdb_libpgquery::T_PGBooleanTest:
-		return "T_BooleanTest";
-	case duckdb_libpgquery::T_PGCoerceToDomain:
-		return "T_CoerceToDomain";
-	case duckdb_libpgquery::T_PGCoerceToDomainValue:
-		return "T_CoerceToDomainValue";
-	case duckdb_libpgquery::T_PGSetToDefault:
-		return "T_SetToDefault";
-	case duckdb_libpgquery::T_PGCurrentOfExpr:
-		return "T_CurrentOfExpr";
-	case duckdb_libpgquery::T_PGNextValueExpr:
-		return "T_NextValueExpr";
-	case duckdb_libpgquery::T_PGInferenceElem:
-		return "T_InferenceElem";
-	case duckdb_libpgquery::T_PGTargetEntry:
-		return "T_TargetEntry";
-	case duckdb_libpgquery::T_PGRangeTblRef:
-		return "T_RangeTblRef";
-	case duckdb_libpgquery::T_PGJoinExpr:
-		return "T_JoinExpr";
-	case duckdb_libpgquery::T_PGFromExpr:
-		return "T_FromExpr";
-	case duckdb_libpgquery::T_PGOnConflictExpr:
-		return "T_OnConflictExpr";
-	case duckdb_libpgquery::T_PGIntoClause:
-		return "T_IntoClause";
-	case duckdb_libpgquery::T_PGExprState:
-		return "T_ExprState";
-	case duckdb_libpgquery::T_PGAggrefExprState:
-		return "T_AggrefExprState";
-	case duckdb_libpgquery::T_PGWindowFuncExprState:
-		return "T_WindowFuncExprState";
-	case duckdb_libpgquery::T_PGSetExprState:
-		return "T_SetExprState";
-	case duckdb_libpgquery::T_PGSubPlanState:
-		return "T_SubPlanState";
-	case duckdb_libpgquery::T_PGAlternativeSubPlanState:
-		return "T_AlternativeSubPlanState";
-	case duckdb_libpgquery::T_PGDomainConstraintState:
-		return "T_DomainConstraintState";
-	case duckdb_libpgquery::T_PGPlannerInfo:
-		return "T_PlannerInfo";
-	case duckdb_libpgquery::T_PGPlannerGlobal:
-		return "T_PlannerGlobal";
-	case duckdb_libpgquery::T_PGRelOptInfo:
-		return "T_RelOptInfo";
-	case duckdb_libpgquery::T_PGIndexOptInfo:
-		return "T_IndexOptInfo";
-	case duckdb_libpgquery::T_PGForeignKeyOptInfo:
-		return "T_ForeignKeyOptInfo";
-	case duckdb_libpgquery::T_PGParamPathInfo:
-		return "T_ParamPathInfo";
-	case duckdb_libpgquery::T_PGPath:
-		return "T_Path";
-	case duckdb_libpgquery::T_PGIndexPath:
-		return "T_IndexPath";
-	case duckdb_libpgquery::T_PGBitmapHeapPath:
-		return "T_BitmapHeapPath";
-	case duckdb_libpgquery::T_PGBitmapAndPath:
-		return "T_BitmapAndPath";
-	case duckdb_libpgquery::T_PGBitmapOrPath:
-		return "T_BitmapOrPath";
-	case duckdb_libpgquery::T_PGTidPath:
-		return "T_TidPath";
-	case duckdb_libpgquery::T_PGSubqueryScanPath:
-		return "T_SubqueryScanPath";
-	case duckdb_libpgquery::T_PGForeignPath:
-		return "T_ForeignPath";
-	case duckdb_libpgquery::T_PGCustomPath:
-		return "T_CustomPath";
-	case duckdb_libpgquery::T_PGNestPath:
-		return "T_NestPath";
-	case duckdb_libpgquery::T_PGMergePath:
-		return "T_MergePath";
-	case duckdb_libpgquery::T_PGHashPath:
-		return "T_HashPath";
-	case duckdb_libpgquery::T_PGAppendPath:
-		return "T_AppendPath";
-	case duckdb_libpgquery::T_PGMergeAppendPath:
-		return "T_MergeAppendPath";
-	case duckdb_libpgquery::T_PGResultPath:
-		return "T_ResultPath";
-	case duckdb_libpgquery::T_PGMaterialPath:
-		return "T_MaterialPath";
-	case duckdb_libpgquery::T_PGUniquePath:
-		return "T_UniquePath";
-	case duckdb_libpgquery::T_PGGatherPath:
-		return "T_GatherPath";
-	case duckdb_libpgquery::T_PGGatherMergePath:
-		return "T_GatherMergePath";
-	case duckdb_libpgquery::T_PGProjectionPath:
-		return "T_ProjectionPath";
-	case duckdb_libpgquery::T_PGProjectSetPath:
-		return "T_ProjectSetPath";
-	case duckdb_libpgquery::T_PGSortPath:
-		return "T_SortPath";
-	case duckdb_libpgquery::T_PGGroupPath:
-		return "T_GroupPath";
-	case duckdb_libpgquery::T_PGUpperUniquePath:
-		return "T_UpperUniquePath";
-	case duckdb_libpgquery::T_PGAggPath:
-		return "T_AggPath";
-	case duckdb_libpgquery::T_PGGroupingSetsPath:
-		return "T_GroupingSetsPath";
-	case duckdb_libpgquery::T_PGMinMaxAggPath:
-		return "T_MinMaxAggPath";
-	case duckdb_libpgquery::T_PGWindowAggPath:
-		return "T_WindowAggPath";
-	case duckdb_libpgquery::T_PGSetOpPath:
-		return "T_SetOpPath";
-	case duckdb_libpgquery::T_PGRecursiveUnionPath:
-		return "T_RecursiveUnionPath";
-	case duckdb_libpgquery::T_PGLockRowsPath:
-		return "T_LockRowsPath";
-	case duckdb_libpgquery::T_PGModifyTablePath:
-		return "T_ModifyTablePath";
-	case duckdb_libpgquery::T_PGLimitPath:
-		return "T_LimitPath";
-	case duckdb_libpgquery::T_PGEquivalenceClass:
-		return "T_EquivalenceClass";
-	case duckdb_libpgquery::T_PGEquivalenceMember:
-		return "T_EquivalenceMember";
-	case duckdb_libpgquery::T_PGPathKey:
-		return "T_PathKey";
-	case duckdb_libpgquery::T_PGPathTarget:
-		return "T_PathTarget";
-	case duckdb_libpgquery::T_PGRestrictInfo:
-		return "T_RestrictInfo";
-	case duckdb_libpgquery::T_PGPlaceHolderVar:
-		return "T_PlaceHolderVar";
-	case duckdb_libpgquery::T_PGSpecialJoinInfo:
-		return "T_SpecialJoinInfo";
-	case duckdb_libpgquery::T_PGAppendRelInfo:
-		return "T_AppendRelInfo";
-	case duckdb_libpgquery::T_PGPartitionedChildRelInfo:
-		return "T_PartitionedChildRelInfo";
-	case duckdb_libpgquery::T_PGPlaceHolderInfo:
-		return "T_PlaceHolderInfo";
-	case duckdb_libpgquery::T_PGMinMaxAggInfo:
-		return "T_MinMaxAggInfo";
-	case duckdb_libpgquery::T_PGPlannerParamItem:
-		return "T_PlannerParamItem";
-	case duckdb_libpgquery::T_PGRollupData:
-		return "T_RollupData";
-	case duckdb_libpgquery::T_PGGroupingSetData:
-		return "T_GroupingSetData";
-	case duckdb_libpgquery::T_PGStatisticExtInfo:
-		return "T_StatisticExtInfo";
-	case duckdb_libpgquery::T_PGMemoryContext:
-		return "T_MemoryContext";
-	case duckdb_libpgquery::T_PGAllocSetContext:
-		return "T_AllocSetContext";
-	case duckdb_libpgquery::T_PGSlabContext:
-		return "T_SlabContext";
-	case duckdb_libpgquery::T_PGValue:
-		return "T_Value";
-	case duckdb_libpgquery::T_PGInteger:
-		return "T_Integer";
-	case duckdb_libpgquery::T_PGFloat:
-		return "T_Float";
-	case duckdb_libpgquery::T_PGString:
-		return "T_String";
-	case duckdb_libpgquery::T_PGBitString:
-		return "T_BitString";
-	case duckdb_libpgquery::T_PGNull:
-		return "T_Null";
-	case duckdb_libpgquery::T_PGList:
-		return "T_List";
-	case duckdb_libpgquery::T_PGIntList:
-		return "T_IntList";
-	case duckdb_libpgquery::T_PGOidList:
-		return "T_OidList";
-	case duckdb_libpgquery::T_PGExtensibleNode:
-		return "T_ExtensibleNode";
-	case duckdb_libpgquery::T_PGRawStmt:
-		return "T_RawStmt";
-	case duckdb_libpgquery::T_PGQuery:
-		return "T_Query";
-	case duckdb_libpgquery::T_PGPlannedStmt:
-		return "T_PlannedStmt";
-	case duckdb_libpgquery::T_PGInsertStmt:
-		return "T_InsertStmt";
-	case duckdb_libpgquery::T_PGDeleteStmt:
-		return "T_DeleteStmt";
-	case duckdb_libpgquery::T_PGUpdateStmt:
-		return "T_UpdateStmt";
-	case duckdb_libpgquery::T_PGSelectStmt:
-		return "T_SelectStmt";
-	case duckdb_libpgquery::T_PGAlterTableStmt:
-		return "T_AlterTableStmt";
-	case duckdb_libpgquery::T_PGAlterTableCmd:
-		return "T_AlterTableCmd";
-	case duckdb_libpgquery::T_PGAlterDomainStmt:
-		return "T_AlterDomainStmt";
-	case duckdb_libpgquery::T_PGSetOperationStmt:
-		return "T_SetOperationStmt";
-	case duckdb_libpgquery::T_PGGrantStmt:
-		return "T_GrantStmt";
-	case duckdb_libpgquery::T_PGGrantRoleStmt:
-		return "T_GrantRoleStmt";
-	case duckdb_libpgquery::T_PGAlterDefaultPrivilegesStmt:
-		return "T_AlterDefaultPrivilegesStmt";
-	case duckdb_libpgquery::T_PGClosePortalStmt:
-		return "T_ClosePortalStmt";
-	case duckdb_libpgquery::T_PGClusterStmt:
-		return "T_ClusterStmt";
-	case duckdb_libpgquery::T_PGCopyStmt:
-		return "T_CopyStmt";
-	case duckdb_libpgquery::T_PGCreateStmt:
-		return "T_CreateStmt";
-	case duckdb_libpgquery::T_PGDefineStmt:
-		return "T_DefineStmt";
-	case duckdb_libpgquery::T_PGDropStmt:
-		return "T_DropStmt";
-	case duckdb_libpgquery::T_PGTruncateStmt:
-		return "T_TruncateStmt";
-	case duckdb_libpgquery::T_PGCommentStmt:
-		return "T_CommentStmt";
-	case duckdb_libpgquery::T_PGFetchStmt:
-		return "T_FetchStmt";
-	case duckdb_libpgquery::T_PGIndexStmt:
-		return "T_IndexStmt";
-	case duckdb_libpgquery::T_PGCreateFunctionStmt:
-		return "T_CreateFunctionStmt";
-	case duckdb_libpgquery::T_PGAlterFunctionStmt:
-		return "T_AlterFunctionStmt";
-	case duckdb_libpgquery::T_PGDoStmt:
-		return "T_DoStmt";
-	case duckdb_libpgquery::T_PGRenameStmt:
-		return "T_RenameStmt";
-	case duckdb_libpgquery::T_PGRuleStmt:
-		return "T_RuleStmt";
-	case duckdb_libpgquery::T_PGNotifyStmt:
-		return "T_NotifyStmt";
-	case duckdb_libpgquery::T_PGListenStmt:
-		return "T_ListenStmt";
-	case duckdb_libpgquery::T_PGUnlistenStmt:
-		return "T_UnlistenStmt";
-	case duckdb_libpgquery::T_PGTransactionStmt:
-		return "T_TransactionStmt";
-	case duckdb_libpgquery::T_PGViewStmt:
-		return "T_ViewStmt";
-	case duckdb_libpgquery::T_PGLoadStmt:
-		return "T_LoadStmt";
-	case duckdb_libpgquery::T_PGCreateDomainStmt:
-		return "T_CreateDomainStmt";
-	case duckdb_libpgquery::T_PGCreatedbStmt:
-		return "T_CreatedbStmt";
-	case duckdb_libpgquery::T_PGDropdbStmt:
-		return "T_DropdbStmt";
-	case duckdb_libpgquery::T_PGVacuumStmt:
-		return "T_VacuumStmt";
-	case duckdb_libpgquery::T_PGExplainStmt:
-		return "T_ExplainStmt";
-	case duckdb_libpgquery::T_PGCreateTableAsStmt:
-		return "T_CreateTableAsStmt";
-	case duckdb_libpgquery::T_PGCreateSeqStmt:
-		return "T_CreateSeqStmt";
-	case duckdb_libpgquery::T_PGAlterSeqStmt:
-		return "T_AlterSeqStmt";
-	case duckdb_libpgquery::T_PGVariableSetStmt:
-		return "T_VariableSetStmt";
-	case duckdb_libpgquery::T_PGVariableShowStmt:
-		return "T_VariableShowStmt";
-	case duckdb_libpgquery::T_PGVariableShowSelectStmt:
-		return "T_VariableShowSelectStmt";
-	case duckdb_libpgquery::T_PGDiscardStmt:
-		return "T_DiscardStmt";
-	case duckdb_libpgquery::T_PGCreateTrigStmt:
-		return "T_CreateTrigStmt";
-	case duckdb_libpgquery::T_PGCreatePLangStmt:
-		return "T_CreatePLangStmt";
-	case duckdb_libpgquery::T_PGCreateRoleStmt:
-		return "T_CreateRoleStmt";
-	case duckdb_libpgquery::T_PGAlterRoleStmt:
-		return "T_AlterRoleStmt";
-	case duckdb_libpgquery::T_PGDropRoleStmt:
-		return "T_DropRoleStmt";
-	case duckdb_libpgquery::T_PGLockStmt:
-		return "T_LockStmt";
-	case duckdb_libpgquery::T_PGConstraintsSetStmt:
-		return "T_ConstraintsSetStmt";
-	case duckdb_libpgquery::T_PGReindexStmt:
-		return "T_ReindexStmt";
-	case duckdb_libpgquery::T_PGCheckPointStmt:
-		return "T_CheckPointStmt";
-	case duckdb_libpgquery::T_PGCreateSchemaStmt:
-		return "T_CreateSchemaStmt";
-	case duckdb_libpgquery::T_PGAlterDatabaseStmt:
-		return "T_AlterDatabaseStmt";
-	case duckdb_libpgquery::T_PGAlterDatabaseSetStmt:
-		return "T_AlterDatabaseSetStmt";
-	case duckdb_libpgquery::T_PGAlterRoleSetStmt:
-		return "T_AlterRoleSetStmt";
-	case duckdb_libpgquery::T_PGCreateConversionStmt:
-		return "T_CreateConversionStmt";
-	case duckdb_libpgquery::T_PGCreateCastStmt:
-		return "T_CreateCastStmt";
-	case duckdb_libpgquery::T_PGCreateOpClassStmt:
-		return "T_CreateOpClassStmt";
-	case duckdb_libpgquery::T_PGCreateOpFamilyStmt:
-		return "T_CreateOpFamilyStmt";
-	case duckdb_libpgquery::T_PGAlterOpFamilyStmt:
-		return "T_AlterOpFamilyStmt";
-	case duckdb_libpgquery::T_PGPrepareStmt:
-		return "T_PrepareStmt";
-	case duckdb_libpgquery::T_PGExecuteStmt:
-		return "T_ExecuteStmt";
-	case duckdb_libpgquery::T_PGCallStmt:
-		return "T_CallStmt";
-	case duckdb_libpgquery::T_PGDeallocateStmt:
-		return "T_DeallocateStmt";
-	case duckdb_libpgquery::T_PGDeclareCursorStmt:
-		return "T_DeclareCursorStmt";
-	case duckdb_libpgquery::T_PGCreateTableSpaceStmt:
-		return "T_CreateTableSpaceStmt";
-	case duckdb_libpgquery::T_PGDropTableSpaceStmt:
-		return "T_DropTableSpaceStmt";
-	case duckdb_libpgquery::T_PGAlterObjectDependsStmt:
-		return "T_AlterObjectDependsStmt";
-	case duckdb_libpgquery::T_PGAlterObjectSchemaStmt:
-		return "T_AlterObjectSchemaStmt";
-	case duckdb_libpgquery::T_PGAlterOwnerStmt:
-		return "T_AlterOwnerStmt";
-	case duckdb_libpgquery::T_PGAlterOperatorStmt:
-		return "T_AlterOperatorStmt";
-	case duckdb_libpgquery::T_PGDropOwnedStmt:
-		return "T_DropOwnedStmt";
-	case duckdb_libpgquery::T_PGReassignOwnedStmt:
-		return "T_ReassignOwnedStmt";
-	case duckdb_libpgquery::T_PGCompositeTypeStmt:
-		return "T_CompositeTypeStmt";
-	case duckdb_libpgquery::T_PGCreateTypeStmt:
-		return "T_CreateTypeStmt";
-	case duckdb_libpgquery::T_PGCreateRangeStmt:
-		return "T_CreateRangeStmt";
-	case duckdb_libpgquery::T_PGAlterEnumStmt:
-		return "T_AlterEnumStmt";
-	case duckdb_libpgquery::T_PGAlterTSDictionaryStmt:
-		return "T_AlterTSDictionaryStmt";
-	case duckdb_libpgquery::T_PGAlterTSConfigurationStmt:
-		return "T_AlterTSConfigurationStmt";
-	case duckdb_libpgquery::T_PGCreateFdwStmt:
-		return "T_CreateFdwStmt";
-	case duckdb_libpgquery::T_PGAlterFdwStmt:
-		return "T_AlterFdwStmt";
-	case duckdb_libpgquery::T_PGCreateForeignServerStmt:
-		return "T_CreateForeignServerStmt";
-	case duckdb_libpgquery::T_PGAlterForeignServerStmt:
-		return "T_AlterForeignServerStmt";
-	case duckdb_libpgquery::T_PGCreateUserMappingStmt:
-		return "T_CreateUserMappingStmt";
-	case duckdb_libpgquery::T_PGAlterUserMappingStmt:
-		return "T_AlterUserMappingStmt";
-	case duckdb_libpgquery::T_PGDropUserMappingStmt:
-		return "T_DropUserMappingStmt";
-	case duckdb_libpgquery::T_PGAlterTableSpaceOptionsStmt:
-		return "T_AlterTableSpaceOptionsStmt";
-	case duckdb_libpgquery::T_PGAlterTableMoveAllStmt:
-		return "T_AlterTableMoveAllStmt";
-	case duckdb_libpgquery::T_PGSecLabelStmt:
-		return "T_SecLabelStmt";
-	case duckdb_libpgquery::T_PGCreateForeignTableStmt:
-		return "T_CreateForeignTableStmt";
-	case duckdb_libpgquery::T_PGImportForeignSchemaStmt:
-		return "T_ImportForeignSchemaStmt";
-	case duckdb_libpgquery::T_PGCreateExtensionStmt:
-		return "T_CreateExtensionStmt";
-	case duckdb_libpgquery::T_PGAlterExtensionStmt:
-		return "T_AlterExtensionStmt";
-	case duckdb_libpgquery::T_PGAlterExtensionContentsStmt:
-		return "T_AlterExtensionContentsStmt";
-	case duckdb_libpgquery::T_PGCreateEventTrigStmt:
-		return "T_CreateEventTrigStmt";
-	case duckdb_libpgquery::T_PGAlterEventTrigStmt:
-		return "T_AlterEventTrigStmt";
-	case duckdb_libpgquery::T_PGRefreshMatViewStmt:
-		return "T_RefreshMatViewStmt";
-	case duckdb_libpgquery::T_PGReplicaIdentityStmt:
-		return "T_ReplicaIdentityStmt";
-	case duckdb_libpgquery::T_PGAlterSystemStmt:
-		return "T_AlterSystemStmt";
-	case duckdb_libpgquery::T_PGCreatePolicyStmt:
-		return "T_CreatePolicyStmt";
-	case duckdb_libpgquery::T_PGAlterPolicyStmt:
-		return "T_AlterPolicyStmt";
-	case duckdb_libpgquery::T_PGCreateTransformStmt:
-		return "T_CreateTransformStmt";
-	case duckdb_libpgquery::T_PGCreateAmStmt:
-		return "T_CreateAmStmt";
-	case duckdb_libpgquery::T_PGCreatePublicationStmt:
-		return "T_CreatePublicationStmt";
-	case duckdb_libpgquery::T_PGAlterPublicationStmt:
-		return "T_AlterPublicationStmt";
-	case duckdb_libpgquery::T_PGCreateSubscriptionStmt:
-		return "T_CreateSubscriptionStmt";
-	case duckdb_libpgquery::T_PGAlterSubscriptionStmt:
-		return "T_AlterSubscriptionStmt";
-	case duckdb_libpgquery::T_PGDropSubscriptionStmt:
-		return "T_DropSubscriptionStmt";
-	case duckdb_libpgquery::T_PGCreateStatsStmt:
-		return "T_CreateStatsStmt";
-	case duckdb_libpgquery::T_PGAlterCollationStmt:
-		return "T_AlterCollationStmt";
-	case duckdb_libpgquery::T_PGAExpr:
-		return "TAExpr";
-	case duckdb_libpgquery::T_PGColumnRef:
-		return "T_ColumnRef";
-	case duckdb_libpgquery::T_PGParamRef:
-		return "T_ParamRef";
-	case duckdb_libpgquery::T_PGAConst:
-		return "TAConst";
-	case duckdb_libpgquery::T_PGFuncCall:
-		return "T_FuncCall";
-	case duckdb_libpgquery::T_PGAStar:
-		return "TAStar";
-	case duckdb_libpgquery::T_PGAIndices:
-		return "TAIndices";
-	case duckdb_libpgquery::T_PGAIndirection:
-		return "TAIndirection";
-	case duckdb_libpgquery::T_PGAArrayExpr:
-		return "TAArrayExpr";
-	case duckdb_libpgquery::T_PGResTarget:
-		return "T_ResTarget";
-	case duckdb_libpgquery::T_PGMultiAssignRef:
-		return "T_MultiAssignRef";
-	case duckdb_libpgquery::T_PGTypeCast:
-		return "T_TypeCast";
-	case duckdb_libpgquery::T_PGCollateClause:
-		return "T_CollateClause";
-	case duckdb_libpgquery::T_PGSortBy:
-		return "T_SortBy";
-	case duckdb_libpgquery::T_PGWindowDef:
-		return "T_WindowDef";
-	case duckdb_libpgquery::T_PGRangeSubselect:
-		return "T_RangeSubselect";
-	case duckdb_libpgquery::T_PGRangeFunction:
-		return "T_RangeFunction";
-	case duckdb_libpgquery::T_PGRangeTableSample:
-		return "T_RangeTableSample";
-	case duckdb_libpgquery::T_PGRangeTableFunc:
-		return "T_RangeTableFunc";
-	case duckdb_libpgquery::T_PGRangeTableFuncCol:
-		return "T_RangeTableFuncCol";
-	case duckdb_libpgquery::T_PGTypeName:
-		return "T_TypeName";
-	case duckdb_libpgquery::T_PGColumnDef:
-		return "T_ColumnDef";
-	case duckdb_libpgquery::T_PGIndexElem:
-		return "T_IndexElem";
-	case duckdb_libpgquery::T_PGConstraint:
-		return "T_Constraint";
-	case duckdb_libpgquery::T_PGDefElem:
-		return "T_DefElem";
-	case duckdb_libpgquery::T_PGRangeTblEntry:
-		return "T_RangeTblEntry";
-	case duckdb_libpgquery::T_PGRangeTblFunction:
-		return "T_RangeTblFunction";
-	case duckdb_libpgquery::T_PGTableSampleClause:
-		return "T_TableSampleClause";
-	case duckdb_libpgquery::T_PGWithCheckOption:
-		return "T_WithCheckOption";
-	case duckdb_libpgquery::T_PGSortGroupClause:
-		return "T_SortGroupClause";
-	case duckdb_libpgquery::T_PGGroupingSet:
-		return "T_GroupingSet";
-	case duckdb_libpgquery::T_PGWindowClause:
-		return "T_WindowClause";
-	case duckdb_libpgquery::T_PGObjectWithArgs:
-		return "T_ObjectWithArgs";
-	case duckdb_libpgquery::T_PGAccessPriv:
-		return "T_AccessPriv";
-	case duckdb_libpgquery::T_PGCreateOpClassItem:
-		return "T_CreateOpClassItem";
-	case duckdb_libpgquery::T_PGTableLikeClause:
-		return "T_TableLikeClause";
-	case duckdb_libpgquery::T_PGFunctionParameter:
-		return "T_FunctionParameter";
-	case duckdb_libpgquery::T_PGLockingClause:
-		return "T_LockingClause";
-	case duckdb_libpgquery::T_PGRowMarkClause:
-		return "T_RowMarkClause";
-	case duckdb_libpgquery::T_PGXmlSerialize:
-		return "T_XmlSerialize";
-	case duckdb_libpgquery::T_PGWithClause:
-		return "T_WithClause";
-	case duckdb_libpgquery::T_PGInferClause:
-		return "T_InferClause";
-	case duckdb_libpgquery::T_PGOnConflictClause:
-		return "T_OnConflictClause";
-	case duckdb_libpgquery::T_PGCommonTableExpr:
-		return "T_CommonTableExpr";
-	case duckdb_libpgquery::T_PGRoleSpec:
-		return "T_RoleSpec";
-	case duckdb_libpgquery::T_PGTriggerTransition:
-		return "T_TriggerTransition";
-	case duckdb_libpgquery::T_PGPartitionElem:
-		return "T_PartitionElem";
-	case duckdb_libpgquery::T_PGPartitionSpec:
-		return "T_PartitionSpec";
-	case duckdb_libpgquery::T_PGPartitionBoundSpec:
-		return "T_PartitionBoundSpec";
-	case duckdb_libpgquery::T_PGPartitionRangeDatum:
-		return "T_PartitionRangeDatum";
-	case duckdb_libpgquery::T_PGPartitionCmd:
-		return "T_PartitionCmd";
-	case duckdb_libpgquery::T_PGIdentifySystemCmd:
-		return "T_IdentifySystemCmd";
-	case duckdb_libpgquery::T_PGBaseBackupCmd:
-		return "T_BaseBackupCmd";
-	case duckdb_libpgquery::T_PGCreateReplicationSlotCmd:
-		return "T_CreateReplicationSlotCmd";
-	case duckdb_libpgquery::T_PGDropReplicationSlotCmd:
-		return "T_DropReplicationSlotCmd";
-	case duckdb_libpgquery::T_PGStartReplicationCmd:
-		return "T_StartReplicationCmd";
-	case duckdb_libpgquery::T_PGTimeLineHistoryCmd:
-		return "T_TimeLineHistoryCmd";
-	case duckdb_libpgquery::T_PGSQLCmd:
-		return "T_SQLCmd";
-	case duckdb_libpgquery::T_PGTriggerData:
-		return "T_TriggerData";
-	case duckdb_libpgquery::T_PGEventTriggerData:
-		return "T_EventTriggerData";
-	case duckdb_libpgquery::T_PGReturnSetInfo:
-		return "T_ReturnSetInfo";
-	case duckdb_libpgquery::T_PGWindowObjectData:
-		return "T_WindowObjectData";
-	case duckdb_libpgquery::T_PGTIDBitmap:
-		return "T_TIDBitmap";
-	case duckdb_libpgquery::T_PGInlineCodeBlock:
-		return "T_InlineCodeBlock";
-	case duckdb_libpgquery::T_PGFdwRoutine:
-		return "T_FdwRoutine";
-	case duckdb_libpgquery::T_PGIndexAmRoutine:
-		return "T_IndexAmRoutine";
-	case duckdb_libpgquery::T_PGTsmRoutine:
-		return "T_TsmRoutine";
-	case duckdb_libpgquery::T_PGForeignKeyCacheInfo:
-		return "T_ForeignKeyCacheInfo";
-	default:
-		return "(UNKNOWN)";
-	}
-} // LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-string Transformer::TransformAlias(duckdb_libpgquery::PGAlias *root, vector<string> &column_name_alias) {
-	if (!root) {
-		return "";
-	}
-	if (root->colnames) {
-		for (auto node = root->colnames->head; node != nullptr; node = node->next) {
-			column_name_alias.emplace_back(
-			    reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
-		}
-	}
-	return root->aliasname;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause, CommonTableExpressionMap &cte_map) {
-	// TODO: might need to update in case of future lawsuit
-	D_ASSERT(de_with_clause);
-
-	D_ASSERT(de_with_clause->ctes);
-	for (auto cte_ele = de_with_clause->ctes->head; cte_ele != nullptr; cte_ele = cte_ele->next) {
-		auto info = make_unique<CommonTableExpressionInfo>();
-
-		auto cte = reinterpret_cast<duckdb_libpgquery::PGCommonTableExpr *>(cte_ele->data.ptr_value);
-		if (cte->aliascolnames) {
-			for (auto node = cte->aliascolnames->head; node != nullptr; node = node->next) {
-				info->aliases.emplace_back(
-				    reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
-			}
-		}
-		// lets throw some errors on unsupported features early
-		if (cte->ctecolnames) {
-			throw NotImplementedException("Column name setting not supported in CTEs");
-		}
-		if (cte->ctecoltypes) {
-			throw NotImplementedException("Column type setting not supported in CTEs");
-		}
-		if (cte->ctecoltypmods) {
-			throw NotImplementedException("Column type modification not supported in CTEs");
-		}
-		if (cte->ctecolcollations) {
-			throw NotImplementedException("CTE collations not supported");
-		}
-		// we need a query
-		if (!cte->ctequery || cte->ctequery->type != duckdb_libpgquery::T_PGSelectStmt) {
-			throw InternalException("A CTE needs a SELECT");
-		}
-
-		// CTE transformation can either result in inlining for non recursive CTEs, or in recursive CTE bindings
-		// otherwise.
-		if (cte->cterecursive || de_with_clause->recursive) {
-			info->query = TransformRecursiveCTE(cte, *info);
-		} else {
-			info->query = TransformSelect(cte->ctequery);
-		}
-		D_ASSERT(info->query);
-		auto cte_name = string(cte->ctename);
-
-		auto it = cte_map.map.find(cte_name);
-		if (it != cte_map.map.end()) {
-			// can't have two CTEs with same name
-			throw ParserException("Duplicate CTE name \"%s\"", cte_name);
-		}
-		cte_map.map[cte_name] = move(info);
-	}
-}
-
-unique_ptr<SelectStatement> Transformer::TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr *cte,
-                                                               CommonTableExpressionInfo &info) {
-	auto stmt = (duckdb_libpgquery::PGSelectStmt *)cte->ctequery;
-
-	unique_ptr<SelectStatement> select;
-	switch (stmt->op) {
-	case duckdb_libpgquery::PG_SETOP_UNION:
-	case duckdb_libpgquery::PG_SETOP_EXCEPT:
-	case duckdb_libpgquery::PG_SETOP_INTERSECT: {
-		select = make_unique<SelectStatement>();
-		select->node = make_unique_base<QueryNode, RecursiveCTENode>();
-		auto result = (RecursiveCTENode *)select->node.get();
-		result->ctename = string(cte->ctename);
-		result->union_all = stmt->all;
-		result->left = TransformSelectNode(stmt->larg);
-		result->right = TransformSelectNode(stmt->rarg);
-		result->aliases = info.aliases;
-
-		D_ASSERT(result->left);
-		D_ASSERT(result->right);
-
-		if (stmt->op != duckdb_libpgquery::PG_SETOP_UNION) {
-			throw ParserException("Unsupported setop type for recursive CTE: only UNION or UNION ALL are supported");
-		}
-		break;
-	}
-	default:
-		// This CTE is not recursive. Fallback to regular query transformation.
-		return TransformSelect(cte->ctequery);
-	}
-
-	if (stmt->limitCount || stmt->limitOffset) {
-		throw ParserException("LIMIT or OFFSET in a recursive query is not allowed");
-	}
-	if (stmt->sortClause) {
-		throw ParserException("ORDER BY in a recursive query is not allowed");
-	}
-	return select;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-static void CheckGroupingSetMax(idx_t count) {
-	static constexpr const idx_t MAX_GROUPING_SETS = 65535;
-	if (count > MAX_GROUPING_SETS) {
-		throw ParserException("Maximum grouping set count of %d exceeded", MAX_GROUPING_SETS);
-	}
-}
-
-static void CheckGroupingSetCubes(idx_t current_count, idx_t cube_count) {
-	idx_t combinations = 1;
-	for (idx_t i = 0; i < cube_count; i++) {
-		combinations *= 2;
-		CheckGroupingSetMax(current_count + combinations);
-	}
-}
-
-struct GroupingExpressionMap {
-	expression_map_t<idx_t> map;
-};
-
-static GroupingSet VectorToGroupingSet(vector<idx_t> &indexes) {
-	GroupingSet result;
-	for (idx_t i = 0; i < indexes.size(); i++) {
-		result.insert(indexes[i]);
-	}
-	return result;
-}
-
-static void MergeGroupingSet(GroupingSet &result, GroupingSet &other) {
-	CheckGroupingSetMax(result.size() + other.size());
-	result.insert(other.begin(), other.end());
-}
-
-void Transformer::AddGroupByExpression(unique_ptr<ParsedExpression> expression, GroupingExpressionMap &map,
-                                       GroupByNode &result, vector<idx_t> &result_set) {
-	if (expression->type == ExpressionType::FUNCTION) {
-		auto &func = (FunctionExpression &)*expression;
-		if (func.function_name == "row") {
-			for (auto &child : func.children) {
-				AddGroupByExpression(move(child), map, result, result_set);
-			}
-			return;
-		}
-	}
-	auto entry = map.map.find(expression.get());
-	idx_t result_idx;
-	if (entry == map.map.end()) {
-		result_idx = result.group_expressions.size();
-		map.map[expression.get()] = result_idx;
-		result.group_expressions.push_back(move(expression));
-	} else {
-		result_idx = entry->second;
-	}
-	result_set.push_back(result_idx);
-}
-
-static void AddCubeSets(const GroupingSet &current_set, vector<GroupingSet> &result_set,
-                        vector<GroupingSet> &result_sets, idx_t start_idx = 0) {
-	CheckGroupingSetMax(result_sets.size());
-	result_sets.push_back(current_set);
-	for (idx_t k = start_idx; k < result_set.size(); k++) {
-		auto child_set = current_set;
-		MergeGroupingSet(child_set, result_set[k]);
-		AddCubeSets(child_set, result_set, result_sets, k + 1);
-	}
-}
-
-void Transformer::TransformGroupByExpression(duckdb_libpgquery::PGNode *n, GroupingExpressionMap &map,
-                                             GroupByNode &result, vector<idx_t> &indexes) {
-	auto expression = TransformExpression(n);
-	AddGroupByExpression(move(expression), map, result, indexes);
-}
-
-// If one GROUPING SETS clause is nested inside another,
-// the effect is the same as if all the elements of the inner clause had been written directly in the outer clause.
-void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode *n, GroupingExpressionMap &map, SelectNode &result,
-                                       vector<GroupingSet> &result_sets) {
-	if (n->type == duckdb_libpgquery::T_PGGroupingSet) {
-		auto grouping_set = (duckdb_libpgquery::PGGroupingSet *)n;
-		switch (grouping_set->kind) {
-		case duckdb_libpgquery::GROUPING_SET_EMPTY:
-			result_sets.emplace_back();
-			break;
-		case duckdb_libpgquery::GROUPING_SET_ALL: {
-			result.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;
-			break;
-		}
-		case duckdb_libpgquery::GROUPING_SET_SETS: {
-			for (auto node = grouping_set->content->head; node; node = node->next) {
-				auto pg_node = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
-				TransformGroupByNode(pg_node, map, result, result_sets);
-			}
-			break;
-		}
-		case duckdb_libpgquery::GROUPING_SET_ROLLUP: {
-			vector<GroupingSet> rollup_sets;
-			for (auto node = grouping_set->content->head; node; node = node->next) {
-				auto pg_node = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
-				vector<idx_t> rollup_set;
-				TransformGroupByExpression(pg_node, map, result.groups, rollup_set);
-				rollup_sets.push_back(VectorToGroupingSet(rollup_set));
-			}
-			// generate the subsets of the rollup set and add them to the grouping sets
-			GroupingSet current_set;
-			result_sets.push_back(current_set);
-			for (idx_t i = 0; i < rollup_sets.size(); i++) {
-				MergeGroupingSet(current_set, rollup_sets[i]);
-				result_sets.push_back(current_set);
-			}
-			break;
-		}
-		case duckdb_libpgquery::GROUPING_SET_CUBE: {
-			vector<GroupingSet> cube_sets;
-			for (auto node = grouping_set->content->head; node; node = node->next) {
-				auto pg_node = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
-				vector<idx_t> cube_set;
-				TransformGroupByExpression(pg_node, map, result.groups, cube_set);
-				cube_sets.push_back(VectorToGroupingSet(cube_set));
-			}
-			// generate the subsets of the rollup set and add them to the grouping sets
-			CheckGroupingSetCubes(result_sets.size(), cube_sets.size());
-
-			GroupingSet current_set;
-			AddCubeSets(current_set, cube_sets, result_sets, 0);
-			break;
-		}
-		default:
-			throw InternalException("Unsupported GROUPING SET type %d", grouping_set->kind);
-		}
-	} else {
-		vector<idx_t> indexes;
-		TransformGroupByExpression(n, map, result.groups, indexes);
-		result_sets.push_back(VectorToGroupingSet(indexes));
-	}
-}
-
-// If multiple grouping items are specified in a single GROUP BY clause,
-// then the final list of grouping sets is the cross product of the individual items.
-bool Transformer::TransformGroupBy(duckdb_libpgquery::PGList *group, SelectNode &select_node) {
-	if (!group) {
-		return false;
-	}
-	auto &result = select_node.groups;
-	GroupingExpressionMap map;
-	for (auto node = group->head; node != nullptr; node = node->next) {
-		auto n = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-		vector<GroupingSet> result_sets;
-		TransformGroupByNode(n, map, select_node, result_sets);
-		CheckGroupingSetMax(result_sets.size());
-		if (result.grouping_sets.empty()) {
-			// no grouping sets yet: use the current set of grouping sets
-			result.grouping_sets = move(result_sets);
-		} else {
-			// compute the cross product
-			vector<GroupingSet> new_sets;
-			idx_t grouping_set_count = result.grouping_sets.size() * result_sets.size();
-			CheckGroupingSetMax(grouping_set_count);
-			new_sets.reserve(grouping_set_count);
-			for (idx_t current_idx = 0; current_idx < result.grouping_sets.size(); current_idx++) {
-				auto &current_set = result.grouping_sets[current_idx];
-				for (idx_t new_idx = 0; new_idx < result_sets.size(); new_idx++) {
-					auto &new_set = result_sets[new_idx];
-					GroupingSet set;
-					set.insert(current_set.begin(), current_set.end());
-					set.insert(new_set.begin(), new_set.end());
-					new_sets.push_back(move(set));
-				}
-			}
-			result.grouping_sets = move(new_sets);
-		}
-	}
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-bool Transformer::TransformOrderBy(duckdb_libpgquery::PGList *order, vector<OrderByNode> &result) {
-	if (!order) {
-		return false;
-	}
-
-	for (auto node = order->head; node != nullptr; node = node->next) {
-		auto temp = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-		if (temp->type == duckdb_libpgquery::T_PGSortBy) {
-			OrderType type;
-			OrderByNullType null_order;
-			auto sort = reinterpret_cast<duckdb_libpgquery::PGSortBy *>(temp);
-			auto target = sort->node;
-			if (sort->sortby_dir == duckdb_libpgquery::PG_SORTBY_DEFAULT) {
-				type = OrderType::ORDER_DEFAULT;
-			} else if (sort->sortby_dir == duckdb_libpgquery::PG_SORTBY_ASC) {
-				type = OrderType::ASCENDING;
-			} else if (sort->sortby_dir == duckdb_libpgquery::PG_SORTBY_DESC) {
-				type = OrderType::DESCENDING;
-			} else {
-				throw NotImplementedException("Unimplemented order by type");
-			}
-			if (sort->sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_DEFAULT) {
-				null_order = OrderByNullType::ORDER_DEFAULT;
-			} else if (sort->sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_FIRST) {
-				null_order = OrderByNullType::NULLS_FIRST;
-			} else if (sort->sortby_nulls == duckdb_libpgquery::PG_SORTBY_NULLS_LAST) {
-				null_order = OrderByNullType::NULLS_LAST;
-			} else {
-				throw NotImplementedException("Unimplemented order by type");
-			}
-			auto order_expression = TransformExpression(target);
-			result.emplace_back(type, null_order, move(order_expression));
-		} else {
-			throw NotImplementedException("ORDER BY list member type %d\n", temp->type);
-		}
-	}
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-static SampleMethod GetSampleMethod(const string &method) {
-	auto lmethod = StringUtil::Lower(method);
-	if (lmethod == "system") {
-		return SampleMethod::SYSTEM_SAMPLE;
-	} else if (lmethod == "bernoulli") {
-		return SampleMethod::BERNOULLI_SAMPLE;
-	} else if (lmethod == "reservoir") {
-		return SampleMethod::RESERVOIR_SAMPLE;
-	} else {
-		throw ParserException("Unrecognized sampling method %s, expected system, bernoulli or reservoir", method);
-	}
-}
-
-unique_ptr<SampleOptions> Transformer::TransformSampleOptions(duckdb_libpgquery::PGNode *options) {
-	if (!options) {
-		return nullptr;
-	}
-	auto result = make_unique<SampleOptions>();
-	auto &sample_options = (duckdb_libpgquery::PGSampleOptions &)*options;
-	auto &sample_size = (duckdb_libpgquery::PGSampleSize &)*sample_options.sample_size;
-	auto sample_value = TransformValue(sample_size.sample_size)->value;
-	result->is_percentage = sample_size.is_percentage;
-	if (sample_size.is_percentage) {
-		// sample size is given in sample_size: use system sampling
-		auto percentage = sample_value.GetValue<double>();
-		if (percentage < 0 || percentage > 100) {
-			throw ParserException("Sample sample_size %llf out of range, must be between 0 and 100", percentage);
-		}
-		result->sample_size = Value::DOUBLE(percentage);
-		result->method = SampleMethod::SYSTEM_SAMPLE;
-	} else {
-		// sample size is given in rows: use reservoir sampling
-		auto rows = sample_value.GetValue<int64_t>();
-		if (rows < 0) {
-			throw ParserException("Sample rows %lld out of range, must be bigger than or equal to 0", rows);
-		}
-		result->sample_size = Value::BIGINT(rows);
-		result->method = SampleMethod::RESERVOIR_SAMPLE;
-	}
-	if (sample_options.method) {
-		result->method = GetSampleMethod(sample_options.method);
-	}
-	result->seed = sample_options.seed == 0 ? -1 : sample_options.seed;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_name) {
-	if (!type_name || type_name->type != duckdb_libpgquery::T_PGTypeName) {
-		throw ParserException("Expected a type");
-	}
-	auto stack_checker = StackCheck();
-
-	auto name = (reinterpret_cast<duckdb_libpgquery::PGValue *>(type_name->names->tail->data.ptr_value)->val.str);
-	// transform it to the SQL type
-	LogicalTypeId base_type = TransformStringToLogicalTypeId(name);
-
-	LogicalType result_type;
-	if (base_type == LogicalTypeId::STRUCT) {
-		if (!type_name->typmods || type_name->typmods->length == 0) {
-			throw ParserException("Struct needs a name and entries");
-		}
-		child_list_t<LogicalType> children;
-		unordered_set<string> name_collision_set;
-
-		for (auto node = type_name->typmods->head; node; node = node->next) {
-			auto &type_val = *((duckdb_libpgquery::PGList *)node->data.ptr_value);
-			if (type_val.length != 2) {
-				throw ParserException("Struct entry needs an entry name and a type name");
-			}
-
-			auto entry_name_node = (duckdb_libpgquery::PGValue *)(type_val.head->data.ptr_value);
-			D_ASSERT(entry_name_node->type == duckdb_libpgquery::T_PGString);
-			auto entry_type_node = (duckdb_libpgquery::PGValue *)(type_val.tail->data.ptr_value);
-			D_ASSERT(entry_type_node->type == duckdb_libpgquery::T_PGTypeName);
-
-			auto entry_name = string(entry_name_node->val.str);
-			D_ASSERT(!entry_name.empty());
-
-			if (name_collision_set.find(entry_name) != name_collision_set.end()) {
-				throw ParserException("Duplicate struct entry name \"%s\"", entry_name);
-			}
-			name_collision_set.insert(entry_name);
-
-			auto entry_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)entry_type_node);
-			children.push_back(make_pair(entry_name, entry_type));
-		}
-		D_ASSERT(!children.empty());
-		result_type = LogicalType::STRUCT(move(children));
-	} else if (base_type == LogicalTypeId::MAP) {
-		//! We transform MAP<TYPE_KEY, TYPE_VALUE> to STRUCT<LIST<key: TYPE_KEY>, LIST<value: TYPE_VALUE>>
-
-		if (!type_name->typmods || type_name->typmods->length != 2) {
-			throw ParserException("Map type needs exactly two entries, key and value type");
-		}
-		child_list_t<LogicalType> children;
-		auto key_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)type_name->typmods->head->data.ptr_value);
-		auto value_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)type_name->typmods->tail->data.ptr_value);
-
-		children.push_back({"key", LogicalType::LIST(key_type)});
-		children.push_back({"value", LogicalType::LIST(value_type)});
-
-		D_ASSERT(children.size() == 2);
-
-		result_type = LogicalType::MAP(move(children));
-	} else {
-		int8_t width, scale;
-		if (base_type == LogicalTypeId::DECIMAL) {
-			// default decimal width/scale
-			width = 18;
-			scale = 3;
-		} else {
-			width = 0;
-			scale = 0;
-		}
-		// check any modifiers
-		int modifier_idx = 0;
-		if (type_name->typmods) {
-			for (auto node = type_name->typmods->head; node; node = node->next) {
-				auto &const_val = *((duckdb_libpgquery::PGAConst *)node->data.ptr_value);
-				if (const_val.type != duckdb_libpgquery::T_PGAConst ||
-				    const_val.val.type != duckdb_libpgquery::T_PGInteger) {
-					throw ParserException("Expected an integer constant as type modifier");
-				}
-				if (const_val.val.val.ival < 0) {
-					throw ParserException("Negative modifier not supported");
-				}
-				if (modifier_idx == 0) {
-					width = const_val.val.val.ival;
-				} else if (modifier_idx == 1) {
-					scale = const_val.val.val.ival;
-				} else {
-					throw ParserException("A maximum of two modifiers is supported");
-				}
-				modifier_idx++;
-			}
-		}
-		switch (base_type) {
-		case LogicalTypeId::VARCHAR:
-			if (modifier_idx > 1) {
-				throw ParserException("VARCHAR only supports a single modifier");
-			}
-			// FIXME: create CHECK constraint based on varchar width
-			width = 0;
-			result_type = LogicalType::VARCHAR;
-			break;
-		case LogicalTypeId::DECIMAL:
-			if (modifier_idx == 1) {
-				// only width is provided: set scale to 0
-				scale = 0;
-			}
-			if (width <= 0 || width > Decimal::MAX_WIDTH_DECIMAL) {
-				throw ParserException("Width must be between 1 and %d!", (int)Decimal::MAX_WIDTH_DECIMAL);
-			}
-			if (scale > width) {
-				throw ParserException("Scale cannot be bigger than width");
-			}
-			result_type = LogicalType::DECIMAL(width, scale);
-			break;
-		case LogicalTypeId::INTERVAL:
-			if (modifier_idx > 1) {
-				throw ParserException("INTERVAL only supports a single modifier");
-			}
-			width = 0;
-			result_type = LogicalType::INTERVAL;
-			break;
-		case LogicalTypeId::USER: {
-			string user_type_name {name};
-			result_type = LogicalType::USER(user_type_name);
-			break;
-		}
-		default:
-			if (modifier_idx > 0) {
-				throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
-			}
-			result_type = LogicalType(base_type);
-			break;
-		}
-	}
-	if (type_name->arrayBounds) {
-		// array bounds: turn the type into a list
-		idx_t extra_stack = 0;
-		for (auto cell = type_name->arrayBounds->head; cell != nullptr; cell = cell->next) {
-			result_type = LogicalType::LIST(move(result_type));
-			StackCheck(extra_stack++);
-		}
-	}
-	return result_type;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGAlterSeqStmt *>(node);
-	D_ASSERT(stmt);
-	auto result = make_unique<AlterStatement>();
-
-	auto qname = TransformQualifiedName(stmt->sequence);
-	auto sequence_schema = qname.schema;
-	auto sequence_name = qname.name;
-
-	if (!stmt->options) {
-		throw InternalException("Expected an argument for ALTER SEQUENCE.");
-	}
-
-	duckdb_libpgquery::PGListCell *cell = nullptr;
-	for_each_cell(cell, stmt->options->head) {
-		auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
-		string opt_name = string(def_elem->defname);
-
-		if (opt_name == "owned_by") {
-			auto val = (duckdb_libpgquery::PGValue *)def_elem->arg;
-			if (!val) {
-				throw InternalException("Expected an argument for option %s", opt_name);
-			}
-			D_ASSERT(val);
-			if (val->type != duckdb_libpgquery::T_PGList) {
-				throw InternalException("Expected a string argument for option %s", opt_name);
-			}
-			auto opt_values = vector<string>();
-
-			auto opt_value_list = (duckdb_libpgquery::PGList *)(val);
-			for (auto c = opt_value_list->head; c != nullptr; c = lnext(c)) {
-				auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
-				opt_values.emplace_back(target->name);
-			}
-			D_ASSERT(!opt_values.empty());
-			string owner_schema = "";
-			string owner_name = "";
-			if (opt_values.size() == 2) {
-				owner_schema = opt_values[0];
-				owner_name = opt_values[1];
-			} else if (opt_values.size() == 1) {
-				owner_schema = DEFAULT_SCHEMA;
-				owner_name = opt_values[0];
-			} else {
-				throw InternalException("Wrong argument for %s. Expected either <schema>.<name> or <name>", opt_name);
-			}
-			auto info = make_unique<ChangeOwnershipInfo>(CatalogType::SEQUENCE_ENTRY, sequence_schema, sequence_name,
-			                                             owner_schema, owner_name);
-			result->info = move(info);
-		} else {
-			throw NotImplementedException("ALTER SEQUENCE option not supported yet!");
-		}
-	}
-	return result;
-}
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGAlterTableStmt *>(node);
-	D_ASSERT(stmt);
-	D_ASSERT(stmt->relation);
-
-	auto result = make_unique<AlterStatement>();
-
-	auto qname = TransformQualifiedName(stmt->relation);
-
-	// first we check the type of ALTER
-	for (auto c = stmt->cmds->head; c != nullptr; c = c->next) {
-		auto command = reinterpret_cast<duckdb_libpgquery::PGAlterTableCmd *>(lfirst(c));
-		// TODO: Include more options for command->subtype
-		switch (command->subtype) {
-		case duckdb_libpgquery::PG_AT_AddColumn: {
-			auto cdef = (duckdb_libpgquery::PGColumnDef *)command->def;
-			if (cdef->category == duckdb_libpgquery::COL_GENERATED) {
-				throw ParserException("Adding generated columns after table creation is not supported yet");
-			}
-			auto centry = TransformColumnDefinition(cdef);
-
-			if (cdef->constraints) {
-				for (auto constr = cdef->constraints->head; constr != nullptr; constr = constr->next) {
-					auto constraint = TransformConstraint(constr, centry, 0);
-					if (!constraint) {
-						continue;
-					}
-					throw ParserException("Adding columns with constraints not yet supported");
-				}
-			}
-			result->info = make_unique<AddColumnInfo>(qname.schema, qname.name, move(centry));
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_DropColumn: {
-			bool cascade = command->behavior == duckdb_libpgquery::PG_DROP_CASCADE;
-			result->info =
-			    make_unique<RemoveColumnInfo>(qname.schema, qname.name, command->name, command->missing_ok, cascade);
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_ColumnDefault: {
-			auto expr = TransformExpression(command->def);
-			result->info = make_unique<SetDefaultInfo>(qname.schema, qname.name, command->name, move(expr));
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_AlterColumnType: {
-			auto cdef = (duckdb_libpgquery::PGColumnDef *)command->def;
-			auto column_definition = TransformColumnDefinition(cdef);
-
-			unique_ptr<ParsedExpression> expr;
-			if (cdef->raw_default) {
-				expr = TransformExpression(cdef->raw_default);
-			} else {
-				auto colref = make_unique<ColumnRefExpression>(command->name);
-				expr = make_unique<CastExpression>(column_definition.Type(), move(colref));
-			}
-			result->info = make_unique<ChangeColumnTypeInfo>(qname.schema, qname.name, command->name,
-			                                                 column_definition.Type(), move(expr));
-			break;
-		}
-		case duckdb_libpgquery::PG_AT_DropConstraint:
-		case duckdb_libpgquery::PG_AT_DropNotNull:
-		default:
-			throw NotImplementedException("ALTER TABLE option not supported yet!");
-		}
-	}
-
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<CallStatement> Transformer::TransformCall(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCallStmt *>(node);
-	D_ASSERT(stmt);
-
-	auto result = make_unique<CallStatement>();
-	result->function = TransformFuncCall((duckdb_libpgquery::PGFuncCall *)stmt->func);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<SQLStatement> Transformer::TransformCheckpoint(duckdb_libpgquery::PGNode *node) {
-	auto checkpoint = (duckdb_libpgquery::PGCheckPointStmt *)node;
-
-	vector<unique_ptr<ParsedExpression>> children;
-	// transform into "CALL checkpoint()" or "CALL force_checkpoint()"
-	auto result = make_unique<CallStatement>();
-	result->function =
-	    make_unique<FunctionExpression>(checkpoint->force ? "force_checkpoint" : "checkpoint", move(children));
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-void Transformer::TransformCopyOptions(CopyInfo &info, duckdb_libpgquery::PGList *options) {
-	if (!options) {
-		return;
-	}
-	duckdb_libpgquery::PGListCell *cell = nullptr;
-
-	// iterate over each option
-	for_each_cell(cell, options->head) {
-		auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
-		if (StringUtil::Lower(def_elem->defname) == "format") {
-			// format specifier: interpret this option
-			auto *format_val = (duckdb_libpgquery::PGValue *)(def_elem->arg);
-			if (!format_val || format_val->type != duckdb_libpgquery::T_PGString) {
-				throw ParserException("Unsupported parameter type for FORMAT: expected e.g. FORMAT 'csv', 'parquet'");
-			}
-			info.format = StringUtil::Lower(format_val->val.str);
-			continue;
-		}
-		// otherwise
-		if (info.options.find(def_elem->defname) != info.options.end()) {
-			throw ParserException("Unexpected duplicate option \"%s\"", def_elem->defname);
-		}
-		if (!def_elem->arg) {
-			info.options[def_elem->defname] = vector<Value>();
-			continue;
-		}
-		switch (def_elem->arg->type) {
-		case duckdb_libpgquery::T_PGList: {
-			auto column_list = (duckdb_libpgquery::PGList *)(def_elem->arg);
-			for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-				auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
-				info.options[def_elem->defname].push_back(Value(target->name));
-			}
-			break;
-		}
-		case duckdb_libpgquery::T_PGAStar:
-			info.options[def_elem->defname].push_back(Value("*"));
-			break;
-		default:
-			info.options[def_elem->defname].push_back(
-			    TransformValue(*((duckdb_libpgquery::PGValue *)def_elem->arg))->value);
-			break;
-		}
-	}
-}
-
-unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCopyStmt *>(node);
-	D_ASSERT(stmt);
-	auto result = make_unique<CopyStatement>();
-	auto &info = *result->info;
-
-	// get file_path and is_from
-	info.is_from = stmt->is_from;
-	if (!stmt->filename) {
-		// stdin/stdout
-		info.file_path = info.is_from ? "/dev/stdin" : "/dev/stdout";
-	} else {
-		// copy to a file
-		info.file_path = stmt->filename;
-	}
-	if (StringUtil::EndsWith(info.file_path, ".parquet")) {
-		info.format = "parquet";
-	} else {
-		info.format = "csv";
-	}
-
-	// get select_list
-	if (stmt->attlist) {
-		for (auto n = stmt->attlist->head; n != nullptr; n = n->next) {
-			auto target = reinterpret_cast<duckdb_libpgquery::PGResTarget *>(n->data.ptr_value);
-			if (target->name) {
-				info.select_list.emplace_back(target->name);
-			}
-		}
-	}
-
-	if (stmt->relation) {
-		auto ref = TransformRangeVar(stmt->relation);
-		auto &table = *reinterpret_cast<BaseTableRef *>(ref.get());
-		info.table = table.table_name;
-		info.schema = table.schema_name;
-	} else {
-		result->select_statement = TransformSelectNode((duckdb_libpgquery::PGSelectStmt *)stmt->query);
-	}
-
-	// handle the different options of the COPY statement
-	TransformCopyOptions(info, stmt->options);
-
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node);
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGCreateFunctionStmt);
-
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateFunctionStmt *>(node);
-	D_ASSERT(stmt);
-	D_ASSERT(stmt->function || stmt->query);
-
-	auto result = make_unique<CreateStatement>();
-	auto qname = TransformQualifiedName(stmt->name);
-
-	unique_ptr<MacroFunction> macro_func;
-	;
-
-	// function can be null here
-	if (stmt->function) {
-		auto expression = TransformExpression(stmt->function);
-		macro_func = make_unique<ScalarMacroFunction>(move(expression));
-	} else if (stmt->query) {
-		auto query_node = TransformSelect(stmt->query, true)->node->Copy();
-		macro_func = make_unique<TableMacroFunction>(move(query_node));
-	}
-
-	auto info =
-	    make_unique<CreateMacroInfo>((stmt->function ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY));
-	info->schema = qname.schema;
-	info->name = qname.name;
-
-	switch (stmt->relpersistence) {
-	case duckdb_libpgquery::PG_RELPERSISTENCE_TEMP:
-		info->temporary = true;
-		break;
-	case duckdb_libpgquery::PG_RELPERSISTENCE_UNLOGGED:
-		throw ParserException("Unlogged flag not supported for macros: '%s'", qname.name);
-		break;
-	case duckdb_libpgquery::RELPERSISTENCE_PERMANENT:
-		info->temporary = false;
-		break;
-	}
-
-	if (stmt->params) {
-		vector<unique_ptr<ParsedExpression>> parameters;
-		TransformExpressionList(*stmt->params, parameters);
-		for (auto &param : parameters) {
-			if (param->type == ExpressionType::VALUE_CONSTANT) {
-				// parameters with default value (must have an alias)
-				if (param->alias.empty()) {
-					throw ParserException("Invalid parameter: '%s'", param->ToString());
-				}
-				if (macro_func->default_parameters.find(param->alias) != macro_func->default_parameters.end()) {
-					throw ParserException("Duplicate default parameter: '%s'", param->alias);
-				}
-				macro_func->default_parameters[param->alias] = move(param);
-			} else if (param->GetExpressionClass() == ExpressionClass::COLUMN_REF) {
-				// positional parameters
-				if (!macro_func->default_parameters.empty()) {
-					throw ParserException("Positional parameters cannot come after parameters with a default value!");
-				}
-				macro_func->parameters.push_back(move(param));
-			} else {
-				throw ParserException("Invalid parameter: '%s'", param->ToString());
-			}
-		}
-	}
-
-	info->function = move(macro_func);
-	result->info = move(info);
-
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-static IndexType StringToIndexType(const string &str) {
-	string upper_str = StringUtil::Upper(str);
-	if (upper_str == "INVALID") {
-		return IndexType::INVALID;
-	} else if (upper_str == "ART") {
-		return IndexType::ART;
-	} else {
-		throw ConversionException("No IndexType conversion from string '%s'", upper_str);
-	}
-	return IndexType::INVALID;
-}
-
-unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGIndexStmt *>(node);
-	D_ASSERT(stmt);
-	auto result = make_unique<CreateStatement>();
-	auto info = make_unique<CreateIndexInfo>();
-
-	info->unique = stmt->unique;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
-
-	for (auto cell = stmt->indexParams->head; cell != nullptr; cell = cell->next) {
-		auto index_element = (duckdb_libpgquery::PGIndexElem *)cell->data.ptr_value;
-		if (index_element->collation) {
-			throw NotImplementedException("Index with collation not supported yet!");
-		}
-		if (index_element->opclass) {
-			throw NotImplementedException("Index with opclass not supported yet!");
-		}
-
-		if (index_element->name) {
-			// create a column reference expression
-			info->expressions.push_back(make_unique<ColumnRefExpression>(index_element->name, stmt->relation->relname));
-		} else {
-			// parse the index expression
-			D_ASSERT(index_element->expr);
-			info->expressions.push_back(TransformExpression(index_element->expr));
-		}
-	}
-
-	info->index_type = StringToIndexType(string(stmt->accessMethod));
-	auto tableref = make_unique<BaseTableRef>();
-	tableref->table_name = stmt->relation->relname;
-	if (stmt->relation->schemaname) {
-		tableref->schema_name = stmt->relation->schemaname;
-	}
-	info->table = move(tableref);
-	if (stmt->idxname) {
-		info->index_name = stmt->idxname;
-	} else {
-		throw NotImplementedException("Index wout a name not supported yet!");
-	}
-	result->info = move(info);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateSchema(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateSchemaStmt *>(node);
-	D_ASSERT(stmt);
-	auto result = make_unique<CreateStatement>();
-	auto info = make_unique<CreateSchemaInfo>();
-
-	D_ASSERT(stmt->schemaname);
-	info->schema = stmt->schemaname;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
-
-	if (stmt->schemaElts) {
-		// schema elements
-		for (auto cell = stmt->schemaElts->head; cell != nullptr; cell = cell->next) {
-			auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value);
-			switch (node->type) {
-			case duckdb_libpgquery::T_PGCreateStmt:
-			case duckdb_libpgquery::T_PGViewStmt:
-			default:
-				throw NotImplementedException("Schema element not supported yet!");
-			}
-		}
-	}
-	result->info = move(info);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateSeqStmt *>(node);
-
-	auto result = make_unique<CreateStatement>();
-	auto info = make_unique<CreateSequenceInfo>();
-
-	auto qname = TransformQualifiedName(stmt->sequence);
-	info->schema = qname.schema;
-	info->name = qname.name;
-
-	if (stmt->options) {
-		duckdb_libpgquery::PGListCell *cell = nullptr;
-		for_each_cell(cell, stmt->options->head) {
-			auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
-			string opt_name = string(def_elem->defname);
-
-			auto val = (duckdb_libpgquery::PGValue *)def_elem->arg;
-			if (def_elem->defaction == duckdb_libpgquery::PG_DEFELEM_UNSPEC && !val) { // e.g. NO MINVALUE
-				continue;
-			}
-			D_ASSERT(val);
-			int64_t opt_value;
-			if (val->type == duckdb_libpgquery::T_PGInteger) {
-				opt_value = val->val.ival;
-			} else if (val->type == duckdb_libpgquery::T_PGFloat) {
-				if (!TryCast::Operation<string_t, int64_t>(string_t(val->val.str), opt_value, true)) {
-					throw ParserException("Expected an integer argument for option %s", opt_name);
-				}
-			} else {
-				throw ParserException("Expected an integer argument for option %s", opt_name);
-			}
-			if (opt_name == "increment") {
-				info->increment = opt_value;
-				if (info->increment == 0) {
-					throw ParserException("Increment must not be zero");
-				}
-				if (info->increment < 0) {
-					info->start_value = info->max_value = -1;
-					info->min_value = NumericLimits<int64_t>::Minimum();
-				} else {
-					info->start_value = info->min_value = 1;
-					info->max_value = NumericLimits<int64_t>::Maximum();
-				}
-			} else if (opt_name == "minvalue") {
-				info->min_value = opt_value;
-				if (info->increment > 0) {
-					info->start_value = info->min_value;
-				}
-			} else if (opt_name == "maxvalue") {
-				info->max_value = opt_value;
-				if (info->increment < 0) {
-					info->start_value = info->max_value;
-				}
-			} else if (opt_name == "start") {
-				info->start_value = opt_value;
-			} else if (opt_name == "cycle") {
-				info->cycle = opt_value > 0;
-			} else {
-				throw ParserException("Unrecognized option \"%s\" for CREATE SEQUENCE", opt_name);
-			}
-		}
-	}
-	info->temporary = !stmt->sequence->relpersistence;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
-	if (info->max_value <= info->min_value) {
-		throw ParserException("MINVALUE (%lld) must be less than MAXVALUE (%lld)", info->min_value, info->max_value);
-	}
-	if (info->start_value < info->min_value) {
-		throw ParserException("START value (%lld) cannot be less than MINVALUE (%lld)", info->start_value,
-		                      info->min_value);
-	}
-	if (info->start_value > info->max_value) {
-		throw ParserException("START value (%lld) cannot be greater than MAXVALUE (%lld)", info->start_value,
-		                      info->max_value);
-	}
-	result->info = move(info);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-string Transformer::TransformCollation(duckdb_libpgquery::PGCollateClause *collate) {
-	if (!collate) {
-		return string();
-	}
-	string collation;
-	for (auto c = collate->collname->head; c != nullptr; c = lnext(c)) {
-		auto pgvalue = (duckdb_libpgquery::PGValue *)c->data.ptr_value;
-		if (pgvalue->type != duckdb_libpgquery::T_PGString) {
-			throw ParserException("Expected a string as collation type!");
-		}
-		auto collation_argument = string(pgvalue->val.str);
-		if (collation.empty()) {
-			collation = collation_argument;
-		} else {
-			collation += "." + collation_argument;
-		}
-	}
-	return collation;
-}
-
-OnCreateConflict Transformer::TransformOnConflict(duckdb_libpgquery::PGOnCreateConflict conflict) {
-	switch (conflict) {
-	case duckdb_libpgquery::PG_ERROR_ON_CONFLICT:
-		return OnCreateConflict::ERROR_ON_CONFLICT;
-	case duckdb_libpgquery::PG_IGNORE_ON_CONFLICT:
-		return OnCreateConflict::IGNORE_ON_CONFLICT;
-	case duckdb_libpgquery::PG_REPLACE_ON_CONFLICT:
-		return OnCreateConflict::REPLACE_ON_CONFLICT;
-	default:
-		throw InternalException("Unrecognized OnConflict type");
-	}
-}
-
-unique_ptr<ParsedExpression> Transformer::TransformCollateExpr(duckdb_libpgquery::PGCollateClause *collate) {
-	auto child = TransformExpression(collate->arg);
-	auto collation = TransformCollation(collate);
-	return make_unique<CollateExpression>(collation, move(child));
-}
-
-ColumnDefinition Transformer::TransformColumnDefinition(duckdb_libpgquery::PGColumnDef *cdef) {
-	string colname;
-	if (cdef->colname) {
-		colname = cdef->colname;
-	}
-	bool optional_type = cdef->category == duckdb_libpgquery::COL_GENERATED;
-	LogicalType target_type = (optional_type && !cdef->typeName) ? LogicalType::ANY : TransformTypeName(cdef->typeName);
-	if (cdef->collClause) {
-		if (cdef->category == duckdb_libpgquery::COL_GENERATED) {
-			throw ParserException("Collations are not supported on generated columns");
-		}
-		if (target_type.id() != LogicalTypeId::VARCHAR) {
-			throw ParserException("Only VARCHAR columns can have collations!");
-		}
-		target_type = LogicalType::VARCHAR_COLLATION(TransformCollation(cdef->collClause));
-	}
-
-	return ColumnDefinition(colname, target_type);
-}
-
-unique_ptr<CreateStatement> Transformer::TransformCreateTable(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateStmt *>(node);
-	D_ASSERT(stmt);
-	auto result = make_unique<CreateStatement>();
-	auto info = make_unique<CreateTableInfo>();
-
-	if (stmt->inhRelations) {
-		throw NotImplementedException("inherited relations not implemented");
-	}
-	D_ASSERT(stmt->relation);
-
-	info->schema = INVALID_SCHEMA;
-	if (stmt->relation->schemaname) {
-		info->schema = stmt->relation->schemaname;
-	}
-	info->table = stmt->relation->relname;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
-	info->temporary =
-	    stmt->relation->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;
-
-	if (info->temporary && stmt->oncommit != duckdb_libpgquery::PGOnCommitAction::PG_ONCOMMIT_PRESERVE_ROWS &&
-	    stmt->oncommit != duckdb_libpgquery::PGOnCommitAction::PG_ONCOMMIT_NOOP) {
-		throw NotImplementedException("Only ON COMMIT PRESERVE ROWS is supported");
-	}
-	if (!stmt->tableElts) {
-		throw ParserException("Table must have at least one column!");
-	}
-
-	idx_t column_count = 0;
-	for (auto c = stmt->tableElts->head; c != nullptr; c = lnext(c)) {
-		auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(c->data.ptr_value);
-		switch (node->type) {
-		case duckdb_libpgquery::T_PGColumnDef: {
-			auto cdef = (duckdb_libpgquery::PGColumnDef *)c->data.ptr_value;
-			auto centry = TransformColumnDefinition(cdef);
-			if (cdef->constraints) {
-				for (auto constr = cdef->constraints->head; constr != nullptr; constr = constr->next) {
-					auto constraint = TransformConstraint(constr, centry, info->columns.size());
-					if (constraint) {
-						info->constraints.push_back(move(constraint));
-					}
-				}
-			}
-			info->columns.push_back(move(centry));
-			column_count++;
-			break;
-		}
-		case duckdb_libpgquery::T_PGConstraint: {
-			info->constraints.push_back(TransformConstraint(c));
-			break;
-		}
-		default:
-			throw NotImplementedException("ColumnDef type not handled yet");
-		}
-	}
-
-	if (!column_count) {
-		throw ParserException("Table must have at least one column!");
-	}
-
-	result->info = move(info);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateTableAs(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateTableAsStmt *>(node);
-	D_ASSERT(stmt);
-	if (stmt->relkind == duckdb_libpgquery::PG_OBJECT_MATVIEW) {
-		throw NotImplementedException("Materialized view not implemented");
-	}
-	if (stmt->is_select_into || stmt->into->colNames || stmt->into->options) {
-		throw NotImplementedException("Unimplemented features for CREATE TABLE as");
-	}
-	auto qname = TransformQualifiedName(stmt->into->rel);
-	if (stmt->query->type != duckdb_libpgquery::T_PGSelectStmt) {
-		throw ParserException("CREATE TABLE AS requires a SELECT clause");
-	}
-	auto query = TransformSelect(stmt->query, false);
-
-	auto result = make_unique<CreateStatement>();
-	auto info = make_unique<CreateTableInfo>();
-	info->schema = qname.schema;
-	info->table = qname.name;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
-	info->temporary =
-	    stmt->into->rel->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;
-	info->query = move(query);
-	result->info = move(info);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list) {
-	vector<string> result;
-	if (!column_list) {
-		return result;
-	}
-	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-		auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
-		result.emplace_back(target->name);
-	}
-	return result;
-}
-
-Vector ReadPgListToVector(duckdb_libpgquery::PGList *column_list, idx_t &size) {
-	if (!column_list) {
-		Vector result(LogicalType::VARCHAR);
-		return result;
-	}
-	// First we discover the size of this list
-	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-		size++;
-	}
-
-	Vector result(LogicalType::VARCHAR, size);
-	auto result_ptr = FlatVector::GetData<string_t>(result);
-
-	size = 0;
-	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-		auto &type_val = *((duckdb_libpgquery::PGAConst *)c->data.ptr_value);
-		auto entry_value_node = (duckdb_libpgquery::PGValue)(type_val.val);
-		if (entry_value_node.type != duckdb_libpgquery::T_PGString) {
-			throw ParserException("Expected a string constant as value");
-		}
-
-		auto entry_value = string(entry_value_node.val.str);
-		D_ASSERT(!entry_value.empty());
-		result_ptr[size++] = StringVector::AddStringOrBlob(result, entry_value);
-	}
-	return result;
-}
-
-unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateTypeStmt *>(node);
-	D_ASSERT(stmt);
-	auto result = make_unique<CreateStatement>();
-	auto info = make_unique<CreateTypeInfo>();
-	info->name = ReadPgListToString(stmt->typeName)[0];
-	switch (stmt->kind) {
-	case duckdb_libpgquery::PG_NEWTYPE_ENUM: {
-		info->internal = false;
-		idx_t size = 0;
-		auto ordered_array = ReadPgListToVector(stmt->vals, size);
-		info->type = LogicalType::ENUM(info->name, ordered_array, size);
-	} break;
-
-	case duckdb_libpgquery::PG_NEWTYPE_ALIAS: {
-		LogicalType target_type = TransformTypeName(stmt->ofType);
-		target_type.SetAlias(info->name);
-		info->type = target_type;
-	} break;
-
-	default:
-		throw InternalException("Unknown kind of new type");
-	}
-
-	result->info = move(info);
-	return result;
-}
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node);
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGViewStmt);
-
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGViewStmt *>(node);
-	D_ASSERT(stmt);
-	D_ASSERT(stmt->view);
-
-	auto result = make_unique<CreateStatement>();
-	auto info = make_unique<CreateViewInfo>();
-
-	if (stmt->view->schemaname) {
-		info->schema = stmt->view->schemaname;
-	}
-	info->view_name = stmt->view->relname;
-	info->temporary = !stmt->view->relpersistence;
-	if (info->temporary) {
-		info->schema = TEMP_SCHEMA;
-	}
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
-
-	info->query = TransformSelect(stmt->query, false);
-
-	if (stmt->aliases && stmt->aliases->length > 0) {
-		for (auto c = stmt->aliases->head; c != nullptr; c = lnext(c)) {
-			auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(c->data.ptr_value);
-			switch (node->type) {
-			case duckdb_libpgquery::T_PGString: {
-				auto val = (duckdb_libpgquery::PGValue *)node;
-				info->aliases.emplace_back(val->val.str);
-				break;
-			}
-			default:
-				throw NotImplementedException("View projection type");
-			}
-		}
-		if (info->aliases.empty()) {
-			throw ParserException("Need at least one column name in CREATE VIEW projection list");
-		}
-	}
-
-	if (stmt->options && stmt->options->length > 0) {
-		throw NotImplementedException("VIEW options");
-	}
-
-	if (stmt->withCheckOption != duckdb_libpgquery::PGViewCheckOption::PG_NO_CHECK_OPTION) {
-		throw NotImplementedException("VIEW CHECK options");
-	}
-	result->info = move(info);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDeleteStmt *>(node);
-	D_ASSERT(stmt);
-	auto result = make_unique<DeleteStatement>();
-	if (stmt->withClause) {
-		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
-	}
-
-	result->condition = TransformExpression(stmt->whereClause);
-	result->table = TransformRangeVar(stmt->relation);
-	if (result->table->type != TableReferenceType::BASE_TABLE) {
-		throw Exception("Can only delete from base tables!");
-	}
-	if (stmt->usingClause) {
-		for (auto n = stmt->usingClause->head; n != nullptr; n = n->next) {
-			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(n->data.ptr_value);
-			auto using_entry = TransformTableRefNode(target);
-			result->using_clauses.push_back(move(using_entry));
-		}
-	}
-
-	if (stmt->returningList) {
-		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGNode *node) {
-	auto stmt = (duckdb_libpgquery::PGDropStmt *)(node);
-	auto result = make_unique<DropStatement>();
-	auto &info = *result->info.get();
-	D_ASSERT(stmt);
-	if (stmt->objects->length != 1) {
-		throw NotImplementedException("Can only drop one object at a time");
-	}
-	switch (stmt->removeType) {
-	case duckdb_libpgquery::PG_OBJECT_TABLE:
-		info.type = CatalogType::TABLE_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_SCHEMA:
-		info.type = CatalogType::SCHEMA_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_INDEX:
-		info.type = CatalogType::INDEX_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_VIEW:
-		info.type = CatalogType::VIEW_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_SEQUENCE:
-		info.type = CatalogType::SEQUENCE_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_FUNCTION:
-		info.type = CatalogType::MACRO_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_TABLE_MACRO:
-		info.type = CatalogType::TABLE_MACRO_ENTRY;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_TYPE:
-		info.type = CatalogType::TYPE_ENTRY;
-		break;
-	default:
-		throw NotImplementedException("Cannot drop this type yet");
-	}
-
-	switch (stmt->removeType) {
-	case duckdb_libpgquery::PG_OBJECT_SCHEMA:
-		info.name = ((duckdb_libpgquery::PGValue *)stmt->objects->head->data.ptr_value)->val.str;
-		break;
-	case duckdb_libpgquery::PG_OBJECT_TYPE: {
-		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects;
-		auto target = (duckdb_libpgquery::PGTypeName *)(view_list->head->data.ptr_value);
-		info.name = (reinterpret_cast<duckdb_libpgquery::PGValue *>(target->names->tail->data.ptr_value)->val.str);
-		break;
-	}
-	default: {
-		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects->head->data.ptr_value;
-		if (view_list->length == 2) {
-			info.schema = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
-			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->next->data.ptr_value)->val.str;
-		} else {
-			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
-		}
-		break;
-	}
-	}
-	info.cascade = stmt->behavior == duckdb_libpgquery::PGDropBehavior::PG_DROP_CASCADE;
-	info.if_exists = stmt->missing_ok;
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<ExplainStatement> Transformer::TransformExplain(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGExplainStmt *>(node);
-	D_ASSERT(stmt);
-	auto explain_type = ExplainType::EXPLAIN_STANDARD;
-	if (stmt->options) {
-		for (auto n = stmt->options->head; n; n = n->next) {
-			auto def_elem = ((duckdb_libpgquery::PGDefElem *)n->data.ptr_value)->defname;
-			string elem(def_elem);
-			if (elem == "analyze") {
-				explain_type = ExplainType::EXPLAIN_ANALYZE;
-			} else {
-				throw NotImplementedException("Unimplemented explain type: %s", elem);
-			}
-		}
-	}
-	return make_unique<ExplainStatement>(TransformStatement(stmt->query), explain_type);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<ExportStatement> Transformer::TransformExport(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGExportStmt *>(node);
-	auto info = make_unique<CopyInfo>();
-	info->file_path = stmt->filename;
-	info->format = "csv";
-	info->is_from = false;
-	// handle export options
-	TransformCopyOptions(*info, stmt->options);
-
-	return make_unique<ExportStatement>(move(info));
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<PragmaStatement> Transformer::TransformImport(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGImportStmt *>(node);
-	auto result = make_unique<PragmaStatement>();
-	result->info->name = "import_database";
-	result->info->parameters.emplace_back(stmt->filename);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformValuesList(duckdb_libpgquery::PGList *list) {
-	auto result = make_unique<ExpressionListRef>();
-	for (auto value_list = list->head; value_list != nullptr; value_list = value_list->next) {
-		auto target = (duckdb_libpgquery::PGList *)(value_list->data.ptr_value);
-
-		vector<unique_ptr<ParsedExpression>> insert_values;
-		TransformExpressionList(*target, insert_values);
-		if (!result->values.empty()) {
-			if (result->values[0].size() != insert_values.size()) {
-				throw ParserException("VALUES lists must all be the same length");
-			}
-		}
-		result->values.push_back(move(insert_values));
-	}
-	result->alias = "valueslist";
-	return move(result);
-}
-
-unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGInsertStmt *>(node);
-	D_ASSERT(stmt);
-	if (stmt->onConflictClause && stmt->onConflictClause->action != duckdb_libpgquery::PG_ONCONFLICT_NONE) {
-		throw ParserException("ON CONFLICT IGNORE/UPDATE clauses are not supported");
-	}
-	if (!stmt->selectStmt) {
-		throw ParserException("DEFAULT VALUES clause is not supported!");
-	}
-
-	auto result = make_unique<InsertStatement>();
-	if (stmt->withClause) {
-		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
-	}
-
-	// first check if there are any columns specified
-	if (stmt->cols) {
-		for (auto c = stmt->cols->head; c != nullptr; c = lnext(c)) {
-			auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
-			result->columns.emplace_back(target->name);
-		}
-	}
-
-	// Grab and transform the returning columns from the parser.
-	if (stmt->returningList) {
-		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
-	}
-	result->select_statement = TransformSelect(stmt->selectStmt, false);
-
-	auto qname = TransformQualifiedName(stmt->relation);
-	result->table = qname.name;
-	result->schema = qname.schema;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<LoadStatement> Transformer::TransformLoad(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGLoadStmt);
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGLoadStmt *>(node);
-
-	auto load_stmt = make_unique<LoadStatement>();
-	auto load_info = make_unique<LoadInfo>();
-	load_info->filename = std::string(stmt->filename);
-	switch (stmt->load_type) {
-	case duckdb_libpgquery::PG_LOAD_TYPE_LOAD:
-		load_info->load_type = LoadType::LOAD;
-		break;
-	case duckdb_libpgquery::PG_LOAD_TYPE_INSTALL:
-		load_info->load_type = LoadType::INSTALL;
-		break;
-	case duckdb_libpgquery::PG_LOAD_TYPE_FORCE_INSTALL:
-		load_info->load_type = LoadType::FORCE_INSTALL;
-		break;
-	}
-	load_stmt->info = move(load_info);
-	return load_stmt;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGPragmaStmt *>(node);
-
-	auto result = make_unique<PragmaStatement>();
-	auto &info = *result->info;
-
-	info.name = stmt->name;
-	// parse the arguments, if any
-	if (stmt->args) {
-		for (auto cell = stmt->args->head; cell != nullptr; cell = cell->next) {
-			auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value);
-			auto expr = TransformExpression(node);
-
-			if (expr->type == ExpressionType::COMPARE_EQUAL) {
-				auto &comp = (ComparisonExpression &)*expr;
-				if (comp.right->type != ExpressionType::VALUE_CONSTANT) {
-					throw ParserException("Named parameter requires a constant on the RHS");
-				}
-				if (comp.left->type != ExpressionType::COLUMN_REF) {
-					throw ParserException("Named parameter requires a column reference on the LHS");
-				}
-				auto &columnref = (ColumnRefExpression &)*comp.left;
-				auto &constant = (ConstantExpression &)*comp.right;
-				info.named_parameters[columnref.GetName()] = constant.value;
-			} else if (node->type == duckdb_libpgquery::T_PGAConst) {
-				auto constant = TransformConstant((duckdb_libpgquery::PGAConst *)node);
-				info.parameters.push_back(((ConstantExpression &)*constant).value);
-			} else {
-				info.parameters.emplace_back(expr->ToString());
-			}
-		}
-	}
-	// now parse the pragma type
-	switch (stmt->kind) {
-	case duckdb_libpgquery::PG_PRAGMA_TYPE_NOTHING: {
-		if (!info.parameters.empty() || !info.named_parameters.empty()) {
-			throw InternalException("PRAGMA statement that is not a call or assignment cannot contain parameters");
-		}
-		break;
-	case duckdb_libpgquery::PG_PRAGMA_TYPE_ASSIGNMENT:
-		if (info.parameters.size() != 1) {
-			throw InternalException("PRAGMA statement with assignment should contain exactly one parameter");
-		}
-		if (!info.named_parameters.empty()) {
-			throw InternalException("PRAGMA statement with assignment cannot have named parameters");
-		}
-		// SQLite does not distinguish between:
-		// "PRAGMA table_info='integers'"
-		// "PRAGMA table_info('integers')"
-		// for compatibility, any pragmas that match the SQLite ones are parsed as calls
-		case_insensitive_set_t sqlite_compat_pragmas {"table_info"};
-		if (sqlite_compat_pragmas.find(info.name) != sqlite_compat_pragmas.end()) {
-			break;
-		}
-		auto set_statement = make_unique<SetStatement>(info.name, info.parameters[0], SetScope::AUTOMATIC);
-		return move(set_statement);
-	}
-	case duckdb_libpgquery::PG_PRAGMA_TYPE_CALL:
-		break;
-	default:
-		throw InternalException("Unknown pragma type");
-	}
-
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<PrepareStatement> Transformer::TransformPrepare(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGPrepareStmt *>(node);
-	D_ASSERT(stmt);
-
-	if (stmt->argtypes && stmt->argtypes->length > 0) {
-		throw NotImplementedException("Prepared statement argument types are not supported, use CAST");
-	}
-
-	auto result = make_unique<PrepareStatement>();
-	result->name = string(stmt->name);
-	result->statement = TransformStatement(stmt->query);
-	SetParamCount(0);
-
-	return result;
-}
-
-unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGExecuteStmt *>(node);
-	D_ASSERT(stmt);
-
-	auto result = make_unique<ExecuteStatement>();
-	result->name = string(stmt->name);
-
-	if (stmt->params) {
-		TransformExpressionList(*stmt->params, result->values);
-	}
-	for (auto &expr : result->values) {
-		if (!expr->IsScalar()) {
-			throw Exception("Only scalar parameters or NULL supported for EXECUTE");
-		}
-	}
-	return result;
-}
-
-unique_ptr<DropStatement> Transformer::TransformDeallocate(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDeallocateStmt *>(node);
-	D_ASSERT(stmt);
-	if (!stmt->name) {
-		throw ParserException("DEALLOCATE requires a name");
-	}
-
-	auto result = make_unique<DropStatement>();
-	result->info->type = CatalogType::PREPARED_STATEMENT;
-	result->info->name = string(stmt->name);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGRenameStmt *>(node);
-	D_ASSERT(stmt);
-	D_ASSERT(stmt->relation);
-
-	unique_ptr<AlterInfo> info;
-
-	// first we check the type of ALTER
-	switch (stmt->renameType) {
-	case duckdb_libpgquery::PG_OBJECT_COLUMN: {
-		// change column name
-
-		// get the table and schema
-		string schema = INVALID_SCHEMA;
-		string table;
-		D_ASSERT(stmt->relation->relname);
-		if (stmt->relation->relname) {
-			table = stmt->relation->relname;
-		}
-		if (stmt->relation->schemaname) {
-			schema = stmt->relation->schemaname;
-		}
-		// get the old name and the new name
-		string old_name = stmt->subname;
-		string new_name = stmt->newname;
-		info = make_unique<RenameColumnInfo>(schema, table, old_name, new_name);
-		break;
-	}
-	case duckdb_libpgquery::PG_OBJECT_TABLE: {
-		// change table name
-
-		// get the table and schema
-		string schema = DEFAULT_SCHEMA;
-		string table;
-		D_ASSERT(stmt->relation->relname);
-		if (stmt->relation->relname) {
-			table = stmt->relation->relname;
-		}
-		if (stmt->relation->schemaname) {
-			schema = stmt->relation->schemaname;
-		}
-		string new_name = stmt->newname;
-		info = make_unique<RenameTableInfo>(schema, table, new_name);
-		break;
-	}
-
-	case duckdb_libpgquery::PG_OBJECT_VIEW: {
-		// change view name
-
-		// get the view and schema
-		string schema = DEFAULT_SCHEMA;
-		string view;
-		D_ASSERT(stmt->relation->relname);
-		if (stmt->relation->relname) {
-			view = stmt->relation->relname;
-		}
-		if (stmt->relation->schemaname) {
-			schema = stmt->relation->schemaname;
-		}
-		string new_name = stmt->newname;
-		info = make_unique<RenameViewInfo>(schema, view, new_name);
-		break;
-	}
-	case duckdb_libpgquery::PG_OBJECT_DATABASE:
-	default:
-		throw NotImplementedException("Schema element not supported yet!");
-	}
-	D_ASSERT(info);
-
-	auto result = make_unique<AlterStatement>();
-	result->info = move(info);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<SelectStatement> Transformer::TransformSelect(duckdb_libpgquery::PGNode *node, bool is_select) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(node);
-	auto result = make_unique<SelectStatement>();
-
-	// Both Insert/Create Table As uses this.
-	if (is_select) {
-		if (stmt->intoClause) {
-			throw ParserException("SELECT INTO not supported!");
-		}
-		if (stmt->lockingClause) {
-			throw ParserException("SELECT locking clause is not supported!");
-		}
-	}
-
-	result->node = TransformSelectNode(stmt);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSelectStmt *stmt) {
-	D_ASSERT(stmt->type == duckdb_libpgquery::T_PGSelectStmt);
-	auto stack_checker = StackCheck();
-
-	unique_ptr<QueryNode> node;
-
-	switch (stmt->op) {
-	case duckdb_libpgquery::PG_SETOP_NONE: {
-		node = make_unique<SelectNode>();
-		auto result = (SelectNode *)node.get();
-		if (stmt->withClause) {
-			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
-		}
-		if (stmt->windowClause) {
-			for (auto window_ele = stmt->windowClause->head; window_ele != nullptr; window_ele = window_ele->next) {
-				auto window_def = reinterpret_cast<duckdb_libpgquery::PGWindowDef *>(window_ele->data.ptr_value);
-				D_ASSERT(window_def);
-				D_ASSERT(window_def->name);
-				auto window_name = StringUtil::Lower(string(window_def->name));
-
-				auto it = window_clauses.find(window_name);
-				if (it != window_clauses.end()) {
-					throw ParserException("window \"%s\" is already defined", window_name);
-				}
-				window_clauses[window_name] = window_def;
-			}
-		}
-
-		// checks distinct clause
-		if (stmt->distinctClause != nullptr) {
-			auto modifier = make_unique<DistinctModifier>();
-			// checks distinct on clause
-			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(stmt->distinctClause->head->data.ptr_value);
-			if (target) {
-				//  add the columns defined in the ON clause to the select list
-				TransformExpressionList(*stmt->distinctClause, modifier->distinct_on_targets);
-			}
-			result->modifiers.push_back(move(modifier));
-		}
-
-		// do this early so the value lists also have a `FROM`
-		if (stmt->valuesLists) {
-			// VALUES list, create an ExpressionList
-			D_ASSERT(!stmt->fromClause);
-			result->from_table = TransformValuesList(stmt->valuesLists);
-			result->select_list.push_back(make_unique<StarExpression>());
-		} else {
-			if (!stmt->targetList) {
-				throw ParserException("SELECT clause without selection list");
-			}
-			// select list
-			TransformExpressionList(*stmt->targetList, result->select_list);
-			result->from_table = TransformFrom(stmt->fromClause);
-		}
-
-		// where
-		result->where_clause = TransformExpression(stmt->whereClause);
-		// group by
-		TransformGroupBy(stmt->groupClause, *result);
-		// having
-		result->having = TransformExpression(stmt->havingClause);
-		// qualify
-		result->qualify = TransformExpression(stmt->qualifyClause);
-		// sample
-		result->sample = TransformSampleOptions(stmt->sampleOptions);
-		break;
-	}
-	case duckdb_libpgquery::PG_SETOP_UNION:
-	case duckdb_libpgquery::PG_SETOP_EXCEPT:
-	case duckdb_libpgquery::PG_SETOP_INTERSECT: {
-		node = make_unique<SetOperationNode>();
-		auto result = (SetOperationNode *)node.get();
-		if (stmt->withClause) {
-			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
-		}
-		result->left = TransformSelectNode(stmt->larg);
-		result->right = TransformSelectNode(stmt->rarg);
-		if (!result->left || !result->right) {
-			throw Exception("Failed to transform setop children.");
-		}
-
-		bool select_distinct = true;
-		switch (stmt->op) {
-		case duckdb_libpgquery::PG_SETOP_UNION:
-			select_distinct = !stmt->all;
-			result->setop_type = SetOperationType::UNION;
-			break;
-		case duckdb_libpgquery::PG_SETOP_EXCEPT:
-			result->setop_type = SetOperationType::EXCEPT;
-			break;
-		case duckdb_libpgquery::PG_SETOP_INTERSECT:
-			result->setop_type = SetOperationType::INTERSECT;
-			break;
-		default:
-			throw Exception("Unexpected setop type");
-		}
-		if (select_distinct) {
-			result->modifiers.push_back(make_unique<DistinctModifier>());
-		}
-		if (stmt->sampleOptions) {
-			throw ParserException("SAMPLE clause is only allowed in regular SELECT statements");
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Statement type %d not implemented!", stmt->op);
-	}
-	// transform the common properties
-	// both the set operations and the regular select can have an ORDER BY/LIMIT attached to them
-	vector<OrderByNode> orders;
-	TransformOrderBy(stmt->sortClause, orders);
-	if (!orders.empty()) {
-		auto order_modifier = make_unique<OrderModifier>();
-		order_modifier->orders = move(orders);
-		node->modifiers.push_back(move(order_modifier));
-	}
-	if (stmt->limitCount || stmt->limitOffset) {
-		if (stmt->limitCount && stmt->limitCount->type == duckdb_libpgquery::T_PGLimitPercent) {
-			auto limit_percent_modifier = make_unique<LimitPercentModifier>();
-			auto expr_node = reinterpret_cast<duckdb_libpgquery::PGLimitPercent *>(stmt->limitCount)->limit_percent;
-			limit_percent_modifier->limit = TransformExpression(expr_node);
-			if (stmt->limitOffset) {
-				limit_percent_modifier->offset = TransformExpression(stmt->limitOffset);
-			}
-			node->modifiers.push_back(move(limit_percent_modifier));
-		} else {
-			auto limit_modifier = make_unique<LimitModifier>();
-			if (stmt->limitCount) {
-				limit_modifier->limit = TransformExpression(stmt->limitCount);
-			}
-			if (stmt->limitOffset) {
-				limit_modifier->offset = TransformExpression(stmt->limitOffset);
-			}
-			node->modifiers.push_back(move(limit_modifier));
-		}
-	}
-	return node;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-namespace {
-
-SetScope ToSetScope(duckdb_libpgquery::VariableSetScope pg_scope) {
-	switch (pg_scope) {
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL:
-		return SetScope::LOCAL;
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_SESSION:
-		return SetScope::SESSION;
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_GLOBAL:
-		return SetScope::GLOBAL;
-	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_DEFAULT:
-		return SetScope::AUTOMATIC;
-	default:
-		throw InternalException("Unexpected pg_scope: %d", pg_scope);
-	}
-}
-
-} // namespace
-
-unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGVariableSetStmt);
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableSetStmt *>(node);
-
-	if (stmt->kind != duckdb_libpgquery::VariableSetKind::VAR_SET_VALUE) {
-		throw ParserException("Can only SET a variable to a value");
-	}
-
-	if (stmt->scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
-		throw NotImplementedException("SET LOCAL is not implemented.");
-	}
-
-	auto name = std::string(stmt->name);
-	D_ASSERT(!name.empty()); // parser protect us!
-	if (stmt->args->length != 1) {
-		throw ParserException("SET needs a single scalar value parameter");
-	}
-	D_ASSERT(stmt->args->head && stmt->args->head->data.ptr_value);
-	D_ASSERT(((duckdb_libpgquery::PGNode *)stmt->args->head->data.ptr_value)->type == duckdb_libpgquery::T_PGAConst);
-
-	auto value = TransformValue(((duckdb_libpgquery::PGAConst *)stmt->args->head->data.ptr_value)->val)->value;
-
-	return make_unique<SetStatement>(name, value, ToSetScope(stmt->scope));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<SQLStatement> Transformer::TransformShow(duckdb_libpgquery::PGNode *node) {
-	// we transform SHOW x into PRAGMA SHOW('x')
-
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableShowStmt *>(node);
-	if (stmt->is_summary) {
-		auto result = make_unique<ShowStatement>();
-		auto &info = *result->info;
-		info.is_summary = stmt->is_summary;
-
-		auto select = make_unique<SelectNode>();
-		select->select_list.push_back(make_unique<StarExpression>());
-		auto basetable = make_unique<BaseTableRef>();
-		basetable->table_name = stmt->name;
-		select->from_table = move(basetable);
-
-		info.query = move(select);
-		return move(result);
-	}
-
-	auto result = make_unique<PragmaStatement>();
-	auto &info = *result->info;
-
-	string name = stmt->name;
-	if (name == "tables") {
-		// show all tables
-		info.name = "show_tables";
-	} else if (name == "__show_tables_expanded") {
-		info.name = "show_tables_expanded";
-	} else {
-		// show one specific table
-		info.name = "show";
-		info.parameters.emplace_back(stmt->name);
-	}
-
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ShowStatement> Transformer::TransformShowSelect(duckdb_libpgquery::PGNode *node) {
-	// we capture the select statement of SHOW
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableShowSelectStmt *>(node);
-	auto select_stmt = reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(stmt->stmt);
-
-	auto result = make_unique<ShowStatement>();
-	auto &info = *result->info;
-	info.is_summary = stmt->is_summary;
-
-	info.query = TransformSelectNode(select_stmt);
-
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<TransactionStatement> Transformer::TransformTransaction(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGTransactionStmt *>(node);
-	D_ASSERT(stmt);
-	switch (stmt->kind) {
-	case duckdb_libpgquery::PG_TRANS_STMT_BEGIN:
-	case duckdb_libpgquery::PG_TRANS_STMT_START:
-		return make_unique<TransactionStatement>(TransactionType::BEGIN_TRANSACTION);
-	case duckdb_libpgquery::PG_TRANS_STMT_COMMIT:
-		return make_unique<TransactionStatement>(TransactionType::COMMIT);
-	case duckdb_libpgquery::PG_TRANS_STMT_ROLLBACK:
-		return make_unique<TransactionStatement>(TransactionType::ROLLBACK);
-	default:
-		throw NotImplementedException("Transaction type %d not implemented yet", stmt->kind);
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGUpdateStmt *>(node);
-	D_ASSERT(stmt);
-
-	auto result = make_unique<UpdateStatement>();
-	if (stmt->withClause) {
-		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
-	}
-
-	result->table = TransformRangeVar(stmt->relation);
-	if (stmt->fromClause) {
-		result->from_table = TransformFrom(stmt->fromClause);
-	}
-
-	auto root = stmt->targetList;
-	for (auto cell = root->head; cell != nullptr; cell = cell->next) {
-		auto target = (duckdb_libpgquery::PGResTarget *)(cell->data.ptr_value);
-		result->columns.emplace_back(target->name);
-		result->expressions.push_back(TransformExpression(target->val));
-	}
-
-	// Grab and transform the returning columns from the parser.
-	if (stmt->returningList) {
-		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
-	}
-
-	result->condition = TransformExpression(stmt->whereClause);
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<VacuumStatement> Transformer::TransformVacuum(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVacuumStmt *>(node);
-	D_ASSERT(stmt);
-	(void)stmt;
-	auto result = make_unique<VacuumStatement>();
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformRangeVar(duckdb_libpgquery::PGRangeVar *root) {
-	auto result = make_unique<BaseTableRef>();
-
-	result->alias = TransformAlias(root->alias, result->column_name_alias);
-	if (root->relname) {
-		result->table_name = root->relname;
-	}
-	if (root->schemaname) {
-		result->schema_name = root->schemaname;
-	}
-	if (root->sample) {
-		result->sample = TransformSampleOptions(root->sample);
-	}
-	result->query_location = root->location;
-	return move(result);
-}
-
-QualifiedName Transformer::TransformQualifiedName(duckdb_libpgquery::PGRangeVar *root) {
-	QualifiedName qname;
-	if (root->relname) {
-		qname.name = root->relname;
-	} else {
-		qname.name = string();
-	}
-	if (root->schemaname) {
-		qname.schema = root->schemaname;
-	} else {
-		qname.schema = INVALID_SCHEMA;
-	}
-	return qname;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root) {
-	if (!root) {
-		return make_unique<EmptyTableRef>();
-	}
-
-	if (root->length > 1) {
-		// Cross Product
-		auto result = make_unique<CrossProductRef>();
-		CrossProductRef *cur_root = result.get();
-		idx_t list_size = 0;
-		for (auto node = root->head; node != nullptr; node = node->next) {
-			auto n = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-			unique_ptr<TableRef> next = TransformTableRefNode(n);
-			if (!cur_root->left) {
-				cur_root->left = move(next);
-			} else if (!cur_root->right) {
-				cur_root->right = move(next);
-			} else {
-				auto old_res = move(result);
-				result = make_unique<CrossProductRef>();
-				result->left = move(old_res);
-				result->right = move(next);
-				cur_root = result.get();
-			}
-			list_size++;
-			StackCheck(list_size);
-		}
-		return move(result);
-	}
-
-	auto n = reinterpret_cast<duckdb_libpgquery::PGNode *>(root->head->data.ptr_value);
-	return TransformTableRefNode(n);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *root) {
-	auto result = make_unique<JoinRef>();
-	switch (root->jointype) {
-	case duckdb_libpgquery::PG_JOIN_INNER: {
-		result->type = JoinType::INNER;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_LEFT: {
-		result->type = JoinType::LEFT;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_FULL: {
-		result->type = JoinType::OUTER;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_RIGHT: {
-		result->type = JoinType::RIGHT;
-		break;
-	}
-	case duckdb_libpgquery::PG_JOIN_SEMI: {
-		result->type = JoinType::SEMI;
-		break;
-	}
-	default: {
-		throw NotImplementedException("Join type %d not supported\n", root->jointype);
-	}
-	}
-
-	// Check the type of left arg and right arg before transform
-	result->left = TransformTableRefNode(root->larg);
-	result->right = TransformTableRefNode(root->rarg);
-	result->is_natural = root->isNatural;
-	result->query_location = root->location;
-
-	if (root->usingClause && root->usingClause->length > 0) {
-		// usingClause is a list of strings
-		for (auto node = root->usingClause->head; node != nullptr; node = node->next) {
-			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-			D_ASSERT(target->type == duckdb_libpgquery::T_PGString);
-			auto column_name = string(reinterpret_cast<duckdb_libpgquery::PGValue *>(target)->val.str);
-			result->using_columns.push_back(column_name);
-		}
-		return move(result);
-	}
-
-	if (!root->quals && result->using_columns.empty() && !result->is_natural) { // CROSS PRODUCT
-		auto cross = make_unique<CrossProductRef>();
-		cross->left = move(result->left);
-		cross->right = move(result->right);
-		return move(cross);
-	}
-	result->condition = TransformExpression(root->quals);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect *root) {
-	Transformer subquery_transformer(this);
-	auto subquery = subquery_transformer.TransformSelect(root->subquery);
-	if (!subquery) {
-		return nullptr;
-	}
-	auto result = make_unique<SubqueryRef>(move(subquery));
-	result->alias = TransformAlias(root->alias, result->column_name_alias);
-	if (root->sample) {
-		result->sample = TransformSampleOptions(root->sample);
-	}
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRangeFunction *root) {
-	if (root->lateral) {
-		throw NotImplementedException("LATERAL not implemented");
-	}
-	if (root->ordinality) {
-		throw NotImplementedException("WITH ORDINALITY not implemented");
-	}
-	if (root->is_rowsfrom) {
-		throw NotImplementedException("ROWS FROM() not implemented");
-	}
-	if (root->functions->length != 1) {
-		throw NotImplementedException("Need exactly one function");
-	}
-	auto function_sublist = (duckdb_libpgquery::PGList *)root->functions->head->data.ptr_value;
-	D_ASSERT(function_sublist->length == 2);
-	auto call_tree = (duckdb_libpgquery::PGNode *)function_sublist->head->data.ptr_value;
-	auto coldef = function_sublist->head->next->data.ptr_value;
-
-	if (coldef) {
-		throw NotImplementedException("Explicit column definition not supported yet");
-	}
-	// transform the function call
-	auto result = make_unique<TableFunctionRef>();
-	switch (call_tree->type) {
-	case duckdb_libpgquery::T_PGFuncCall: {
-		auto func_call = (duckdb_libpgquery::PGFuncCall *)call_tree;
-		result->function = TransformFuncCall(func_call);
-		result->query_location = func_call->location;
-		break;
-	}
-	case duckdb_libpgquery::T_PGSQLValueFunction:
-		result->function = TransformSQLValueFunction((duckdb_libpgquery::PGSQLValueFunction *)call_tree);
-		break;
-	default:
-		throw ParserException("Not a function call or value function");
-	}
-	result->alias = TransformAlias(root->alias, result->column_name_alias);
-	if (root->sample) {
-		result->sample = TransformSampleOptions(root->sample);
-	}
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNode *n) {
-	auto stack_checker = StackCheck();
-
-	switch (n->type) {
-	case duckdb_libpgquery::T_PGRangeVar:
-		return TransformRangeVar(reinterpret_cast<duckdb_libpgquery::PGRangeVar *>(n));
-	case duckdb_libpgquery::T_PGJoinExpr:
-		return TransformJoin(reinterpret_cast<duckdb_libpgquery::PGJoinExpr *>(n));
-	case duckdb_libpgquery::T_PGRangeSubselect:
-		return TransformRangeSubselect(reinterpret_cast<duckdb_libpgquery::PGRangeSubselect *>(n));
-	case duckdb_libpgquery::T_PGRangeFunction:
-		return TransformRangeFunction(reinterpret_cast<duckdb_libpgquery::PGRangeFunction *>(n));
-	default:
-		throw NotImplementedException("From Type %d not supported", n->type);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-StackChecker::StackChecker(Transformer &transformer_p, idx_t stack_usage_p)
-    : transformer(transformer_p), stack_usage(stack_usage_p) {
-	transformer.stack_depth += stack_usage;
-}
-
-StackChecker::~StackChecker() {
-	transformer.stack_depth -= stack_usage;
-}
-
-StackChecker::StackChecker(StackChecker &&other) noexcept
-    : transformer(other.transformer), stack_usage(other.stack_usage) {
-	other.stack_usage = 0;
-}
-
-Transformer::Transformer(idx_t max_expression_depth_p)
-    : parent(nullptr), max_expression_depth(max_expression_depth_p), stack_depth(DConstants::INVALID_INDEX) {
-}
-
-Transformer::Transformer(Transformer *parent)
-    : parent(parent), max_expression_depth(parent->max_expression_depth), stack_depth(DConstants::INVALID_INDEX) {
-}
-
-bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements) {
-	InitializeStackCheck();
-	for (auto entry = tree->head; entry != nullptr; entry = entry->next) {
-		SetParamCount(0);
-		auto stmt = TransformStatement((duckdb_libpgquery::PGNode *)entry->data.ptr_value);
-		D_ASSERT(stmt);
-		stmt->n_param = ParamCount();
-		statements.push_back(move(stmt));
-	}
-	return true;
-}
-
-void Transformer::InitializeStackCheck() {
-	stack_depth = 0;
-}
-
-StackChecker Transformer::StackCheck(idx_t extra_stack) {
-	auto node = this;
-	while (node->parent) {
-		node = node->parent;
-	}
-	D_ASSERT(node->stack_depth != DConstants::INVALID_INDEX);
-	if (node->stack_depth + extra_stack >= max_expression_depth) {
-		throw ParserException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
-		                      "increase the maximum expression depth.",
-		                      max_expression_depth);
-	}
-	return StackChecker(*node, extra_stack);
-}
-
-unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode *stmt) {
-	auto result = TransformStatementInternal(stmt);
-	result->n_param = ParamCount();
-	return result;
-}
-
-unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode *stmt) {
-	switch (stmt->type) {
-	case duckdb_libpgquery::T_PGRawStmt: {
-		auto raw_stmt = (duckdb_libpgquery::PGRawStmt *)stmt;
-		auto result = TransformStatement(raw_stmt->stmt);
-		if (result) {
-			result->stmt_location = raw_stmt->stmt_location;
-			result->stmt_length = raw_stmt->stmt_len;
-		}
-		return result;
-	}
-	case duckdb_libpgquery::T_PGSelectStmt:
-		return TransformSelect(stmt);
-	case duckdb_libpgquery::T_PGCreateStmt:
-		return TransformCreateTable(stmt);
-	case duckdb_libpgquery::T_PGCreateSchemaStmt:
-		return TransformCreateSchema(stmt);
-	case duckdb_libpgquery::T_PGViewStmt:
-		return TransformCreateView(stmt);
-	case duckdb_libpgquery::T_PGCreateSeqStmt:
-		return TransformCreateSequence(stmt);
-	case duckdb_libpgquery::T_PGCreateFunctionStmt:
-		return TransformCreateFunction(stmt);
-	case duckdb_libpgquery::T_PGDropStmt:
-		return TransformDrop(stmt);
-	case duckdb_libpgquery::T_PGInsertStmt:
-		return TransformInsert(stmt);
-	case duckdb_libpgquery::T_PGCopyStmt:
-		return TransformCopy(stmt);
-	case duckdb_libpgquery::T_PGTransactionStmt:
-		return TransformTransaction(stmt);
-	case duckdb_libpgquery::T_PGDeleteStmt:
-		return TransformDelete(stmt);
-	case duckdb_libpgquery::T_PGUpdateStmt:
-		return TransformUpdate(stmt);
-	case duckdb_libpgquery::T_PGIndexStmt:
-		return TransformCreateIndex(stmt);
-	case duckdb_libpgquery::T_PGAlterTableStmt:
-		return TransformAlter(stmt);
-	case duckdb_libpgquery::T_PGRenameStmt:
-		return TransformRename(stmt);
-	case duckdb_libpgquery::T_PGPrepareStmt:
-		return TransformPrepare(stmt);
-	case duckdb_libpgquery::T_PGExecuteStmt:
-		return TransformExecute(stmt);
-	case duckdb_libpgquery::T_PGDeallocateStmt:
-		return TransformDeallocate(stmt);
-	case duckdb_libpgquery::T_PGCreateTableAsStmt:
-		return TransformCreateTableAs(stmt);
-	case duckdb_libpgquery::T_PGPragmaStmt:
-		return TransformPragma(stmt);
-	case duckdb_libpgquery::T_PGExportStmt:
-		return TransformExport(stmt);
-	case duckdb_libpgquery::T_PGImportStmt:
-		return TransformImport(stmt);
-	case duckdb_libpgquery::T_PGExplainStmt:
-		return TransformExplain(stmt);
-	case duckdb_libpgquery::T_PGVacuumStmt:
-		return TransformVacuum(stmt);
-	case duckdb_libpgquery::T_PGVariableShowStmt:
-		return TransformShow(stmt);
-	case duckdb_libpgquery::T_PGVariableShowSelectStmt:
-		return TransformShowSelect(stmt);
-	case duckdb_libpgquery::T_PGCallStmt:
-		return TransformCall(stmt);
-	case duckdb_libpgquery::T_PGVariableSetStmt:
-		return TransformSet(stmt);
-	case duckdb_libpgquery::T_PGCheckPointStmt:
-		return TransformCheckpoint(stmt);
-	case duckdb_libpgquery::T_PGLoadStmt:
-		return TransformLoad(stmt);
-	case duckdb_libpgquery::T_PGCreateTypeStmt:
-		return TransformCreateType(stmt);
-	case duckdb_libpgquery::T_PGAlterSeqStmt:
-		return TransformAlterSequence(stmt);
-	default:
-		throw NotImplementedException(NodetypeToString(stmt->type));
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-string BindContext::GetMatchingBinding(const string &column_name) {
-	string result;
-	for (auto &kv : bindings) {
-		auto binding = kv.second.get();
-		auto is_using_binding = GetUsingBinding(column_name, kv.first);
-		if (is_using_binding) {
-			continue;
-		}
-		if (binding->HasMatchingBinding(column_name)) {
-			if (!result.empty() || is_using_binding) {
-				throw BinderException("Ambiguous reference to column name \"%s\" (use: \"%s.%s\" "
-				                      "or \"%s.%s\")",
-				                      column_name, result, column_name, kv.first, column_name);
-			}
-			result = kv.first;
-		}
-	}
-	return result;
-}
-
-vector<string> BindContext::GetSimilarBindings(const string &column_name) {
-	vector<pair<string, idx_t>> scores;
-	for (auto &kv : bindings) {
-		auto binding = kv.second.get();
-		for (auto &name : binding->names) {
-			idx_t distance = StringUtil::LevenshteinDistance(name, column_name);
-			scores.emplace_back(binding->alias + "." + name, distance);
-		}
-	}
-	return StringUtil::TopNStrings(scores);
-}
-
-void BindContext::AddUsingBinding(const string &column_name, UsingColumnSet *set) {
-	using_columns[column_name].insert(set);
-}
-
-void BindContext::AddUsingBindingSet(unique_ptr<UsingColumnSet> set) {
-	using_column_sets.push_back(move(set));
-}
-
-bool BindContext::FindUsingBinding(const string &column_name, unordered_set<UsingColumnSet *> **out) {
-	auto entry = using_columns.find(column_name);
-	if (entry != using_columns.end()) {
-		*out = &entry->second;
-		return true;
-	}
-	return false;
-}
-
-UsingColumnSet *BindContext::GetUsingBinding(const string &column_name) {
-	unordered_set<UsingColumnSet *> *using_bindings;
-	if (!FindUsingBinding(column_name, &using_bindings)) {
-		return nullptr;
-	}
-	if (using_bindings->size() > 1) {
-		string error = "Ambiguous column reference: column \"" + column_name + "\" can refer to either:\n";
-		for (auto &using_set : *using_bindings) {
-			string result_bindings;
-			for (auto &binding : using_set->bindings) {
-				if (result_bindings.empty()) {
-					result_bindings = "[";
-				} else {
-					result_bindings += ", ";
-				}
-				result_bindings += binding;
-				result_bindings += ".";
-				result_bindings += GetActualColumnName(binding, column_name);
-			}
-			error += result_bindings + "]";
-		}
-		throw BinderException(error);
-	}
-	for (auto &using_set : *using_bindings) {
-		return using_set;
-	}
-	throw InternalException("Using binding found but no entries");
-}
-
-UsingColumnSet *BindContext::GetUsingBinding(const string &column_name, const string &binding_name) {
-	if (binding_name.empty()) {
-		throw InternalException("GetUsingBinding: expected non-empty binding_name");
-	}
-	unordered_set<UsingColumnSet *> *using_bindings;
-	if (!FindUsingBinding(column_name, &using_bindings)) {
-		return nullptr;
-	}
-	for (auto &using_set : *using_bindings) {
-		auto &bindings = using_set->bindings;
-		if (bindings.find(binding_name) != bindings.end()) {
-			return using_set;
-		}
-	}
-	return nullptr;
-}
-
-void BindContext::RemoveUsingBinding(const string &column_name, UsingColumnSet *set) {
-	if (!set) {
-		return;
-	}
-	auto entry = using_columns.find(column_name);
-	if (entry == using_columns.end()) {
-		throw InternalException("Attempting to remove using binding that is not there");
-	}
-	auto &bindings = entry->second;
-	if (bindings.find(set) != bindings.end()) {
-		bindings.erase(set);
-	}
-	if (bindings.empty()) {
-		using_columns.erase(column_name);
-	}
-}
-
-void BindContext::TransferUsingBinding(BindContext &current_context, UsingColumnSet *current_set,
-                                       UsingColumnSet *new_set, const string &binding, const string &using_column) {
-	AddUsingBinding(using_column, new_set);
-	current_context.RemoveUsingBinding(using_column, current_set);
-}
-
-string BindContext::GetActualColumnName(const string &binding_name, const string &column_name) {
-	string error;
-	auto binding = GetBinding(binding_name, error);
-	if (!binding) {
-		throw InternalException("No binding with name \"%s\"", binding_name);
-	}
-	column_t binding_index;
-	if (!binding->TryGetBindingIndex(column_name, binding_index)) { // LCOV_EXCL_START
-		throw InternalException("Binding with name \"%s\" does not have a column named \"%s\"", binding_name,
-		                        column_name);
-	} // LCOV_EXCL_STOP
-	return binding->names[binding_index];
-}
-
-unordered_set<string> BindContext::GetMatchingBindings(const string &column_name) {
-	unordered_set<string> result;
-	for (auto &kv : bindings) {
-		auto binding = kv.second.get();
-		if (binding->HasMatchingBinding(column_name)) {
-			result.insert(kv.first);
-		}
-	}
-	return result;
-}
-
-unique_ptr<ParsedExpression> BindContext::ExpandGeneratedColumn(const string &table_name, const string &column_name) {
-	string error_message;
-
-	auto binding = GetBinding(table_name, error_message);
-	D_ASSERT(binding);
-	auto &table_binding = *(TableBinding *)binding;
-	return table_binding.ExpandGeneratedColumn(column_name);
-}
-
-unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &table_name, const string &column_name) {
-	string schema_name;
-	return CreateColumnReference(schema_name, table_name, column_name);
-}
-
-static bool ColumnIsGenerated(Binding *binding, column_t index) {
-	if (binding->binding_type != BindingType::TABLE) {
-		return false;
-	}
-	auto table_binding = (TableBinding *)binding;
-	auto catalog_entry = table_binding->GetStandardEntry();
-	if (!catalog_entry) {
-		return false;
-	}
-	if (index == COLUMN_IDENTIFIER_ROW_ID) {
-		return false;
-	}
-	D_ASSERT(catalog_entry->type == CatalogType::TABLE_ENTRY);
-	auto table_entry = (TableCatalogEntry *)catalog_entry;
-	D_ASSERT(table_entry->columns.size() >= index);
-	return table_entry->columns[index].Generated();
-}
-
-unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &schema_name, const string &table_name,
-                                                                const string &column_name) {
-	string error_message;
-	vector<string> names;
-	if (!schema_name.empty()) {
-		names.push_back(schema_name);
-	}
-	names.push_back(table_name);
-	names.push_back(column_name);
-
-	auto result = make_unique<ColumnRefExpression>(move(names));
-	auto binding = GetBinding(table_name, error_message);
-	if (!binding) {
-		return move(result);
-	}
-	auto column_index = binding->GetBindingIndex(column_name);
-	if (ColumnIsGenerated(binding, column_index)) {
-		return ExpandGeneratedColumn(table_name, column_name);
-	} else if (column_index < binding->names.size() && binding->names[column_index] != column_name) {
-		// because of case insensitivity in the binder we rename the column to the original name
-		// as it appears in the binding itself
-		result->alias = binding->names[column_index];
-	}
-	return move(result);
-}
-
-Binding *BindContext::GetCTEBinding(const string &ctename) {
-	auto match = cte_bindings.find(ctename);
-	if (match == cte_bindings.end()) {
-		return nullptr;
-	}
-	return match->second.get();
-}
-
-Binding *BindContext::GetBinding(const string &name, string &out_error) {
-	auto match = bindings.find(name);
-	if (match == bindings.end()) {
-		// alias not found in this BindContext
-		vector<string> candidates;
-		for (auto &kv : bindings) {
-			candidates.push_back(kv.first);
-		}
-		string candidate_str =
-		    StringUtil::CandidatesMessage(StringUtil::TopNLevenshtein(candidates, name), "Candidate tables");
-		out_error = StringUtil::Format("Referenced table \"%s\" not found!%s", name, candidate_str);
-		return nullptr;
-	}
-	return match->second.get();
-}
-
-BindResult BindContext::BindColumn(ColumnRefExpression &colref, idx_t depth) {
-	if (!colref.IsQualified()) {
-		throw InternalException("Could not bind alias \"%s\"!", colref.GetColumnName());
-	}
-
-	string error;
-	auto binding = GetBinding(colref.GetTableName(), error);
-	if (!binding) {
-		return BindResult(error);
-	}
-	return binding->Bind(colref, depth);
-}
-
-string BindContext::BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name) {
-	idx_t total_columns = 0;
-	idx_t current_position = ref.index - 1;
-	for (auto &entry : bindings_list) {
-		idx_t entry_column_count = entry.second->names.size();
-		if (ref.index == 0) {
-			// this is a row id
-			table_name = entry.first;
-			column_name = "rowid";
-			return string();
-		}
-		if (current_position < entry_column_count) {
-			table_name = entry.first;
-			column_name = entry.second->names[current_position];
-			return string();
-		} else {
-			total_columns += entry_column_count;
-			current_position -= entry_column_count;
-		}
-	}
-	return StringUtil::Format("Positional reference %d out of range (total %d columns)", ref.index, total_columns);
-}
-
-BindResult BindContext::BindColumn(PositionalReferenceExpression &ref, idx_t depth) {
-	string table_name, column_name;
-
-	string error = BindColumn(ref, table_name, column_name);
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	auto column_ref = make_unique<ColumnRefExpression>(column_name, table_name);
-	return BindColumn(*column_ref, depth);
-}
-
-bool BindContext::CheckExclusionList(StarExpression &expr, Binding *binding, const string &column_name,
-                                     vector<unique_ptr<ParsedExpression>> &new_select_list,
-                                     case_insensitive_set_t &excluded_columns) {
-	if (expr.exclude_list.find(column_name) != expr.exclude_list.end()) {
-		excluded_columns.insert(column_name);
-		return true;
-	}
-	auto entry = expr.replace_list.find(column_name);
-	if (entry != expr.replace_list.end()) {
-		auto new_entry = entry->second->Copy();
-		new_entry->alias = entry->first;
-		excluded_columns.insert(entry->first);
-		new_select_list.push_back(move(new_entry));
-		return true;
-	}
-	return false;
-}
-
-void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
-                                               vector<unique_ptr<ParsedExpression>> &new_select_list) {
-	if (bindings_list.empty()) {
-		throw BinderException("SELECT * expression without FROM clause!");
-	}
-	case_insensitive_set_t excluded_columns;
-	if (expr.relation_name.empty()) {
-		// SELECT * case
-		// bind all expressions of each table in-order
-		unordered_set<UsingColumnSet *> handled_using_columns;
-		for (auto &entry : bindings_list) {
-			auto binding = entry.second;
-			for (auto &column_name : binding->names) {
-				if (CheckExclusionList(expr, binding, column_name, new_select_list, excluded_columns)) {
-					continue;
-				}
-				// check if this column is a USING column
-				auto using_binding = GetUsingBinding(column_name, binding->alias);
-				if (using_binding) {
-					// it is!
-					// check if we have already emitted the using column
-					if (handled_using_columns.find(using_binding) != handled_using_columns.end()) {
-						// we have! bail out
-						continue;
-					}
-					// we have not! output the using column
-					if (using_binding->primary_binding.empty()) {
-						// no primary binding: output a coalesce
-						auto coalesce = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-						for (auto &child_binding : using_binding->bindings) {
-							coalesce->children.push_back(make_unique<ColumnRefExpression>(column_name, child_binding));
-						}
-						coalesce->alias = column_name;
-						new_select_list.push_back(move(coalesce));
-					} else {
-						// primary binding: output the qualified column ref
-						new_select_list.push_back(
-						    make_unique<ColumnRefExpression>(column_name, using_binding->primary_binding));
-					}
-					handled_using_columns.insert(using_binding);
-					continue;
-				}
-				new_select_list.push_back(make_unique<ColumnRefExpression>(column_name, binding->alias));
-			}
-		}
-	} else {
-		// SELECT tbl.* case
-		string error;
-		auto binding = GetBinding(expr.relation_name, error);
-		if (!binding) {
-			throw BinderException(error);
-		}
-		for (auto &column_name : binding->names) {
-			if (CheckExclusionList(expr, binding, column_name, new_select_list, excluded_columns)) {
-				continue;
-			}
-			new_select_list.push_back(make_unique<ColumnRefExpression>(column_name, binding->alias));
-		}
-	}
-	for (auto &excluded : expr.exclude_list) {
-		if (excluded_columns.find(excluded) == excluded_columns.end()) {
-			throw BinderException("Column \"%s\" in EXCLUDE list not found in %s", excluded,
-			                      expr.relation_name.empty() ? "FROM clause" : expr.relation_name.c_str());
-		}
-	}
-	for (auto &entry : expr.replace_list) {
-		if (excluded_columns.find(entry.first) == excluded_columns.end()) {
-			throw BinderException("Column \"%s\" in REPLACE list not found in %s", entry.first,
-			                      expr.relation_name.empty() ? "FROM clause" : expr.relation_name.c_str());
-		}
-	}
-}
-
-void BindContext::AddBinding(const string &alias, unique_ptr<Binding> binding) {
-	if (bindings.find(alias) != bindings.end()) {
-		throw BinderException("Duplicate alias \"%s\" in query!", alias);
-	}
-	bindings_list.emplace_back(alias, binding.get());
-	bindings[alias] = move(binding);
-}
-
-void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
-                               const vector<LogicalType> &types, LogicalGet &get) {
-	AddBinding(alias, make_unique<TableBinding>(alias, types, names, get, index, true));
-}
-
-void BindContext::AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
-                                   const vector<LogicalType> &types, LogicalGet &get) {
-	AddBinding(alias, make_unique<TableBinding>(alias, types, names, get, index));
-}
-
-static string AddColumnNameToBinding(const string &base_name, case_insensitive_set_t &current_names) {
-	idx_t index = 1;
-	string name = base_name;
-	while (current_names.find(name) != current_names.end()) {
-		name = base_name + ":" + to_string(index++);
-	}
-	current_names.insert(name);
-	return name;
-}
-
-vector<string> BindContext::AliasColumnNames(const string &table_name, const vector<string> &names,
-                                             const vector<string> &column_aliases) {
-	vector<string> result;
-	if (column_aliases.size() > names.size()) {
-		throw BinderException("table \"%s\" has %lld columns available but %lld columns specified", table_name,
-		                      names.size(), column_aliases.size());
-	}
-	case_insensitive_set_t current_names;
-	// use any provided column aliases first
-	for (idx_t i = 0; i < column_aliases.size(); i++) {
-		result.push_back(AddColumnNameToBinding(column_aliases[i], current_names));
-	}
-	// if not enough aliases were provided, use the default names for remaining columns
-	for (idx_t i = column_aliases.size(); i < names.size(); i++) {
-		result.push_back(AddColumnNameToBinding(names[i], current_names));
-	}
-	return result;
-}
-
-void BindContext::AddSubquery(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery) {
-	auto names = AliasColumnNames(alias, subquery.names, ref.column_name_alias);
-	AddGenericBinding(index, alias, names, subquery.types);
-}
-
-void BindContext::AddEntryBinding(idx_t index, const string &alias, const vector<string> &names,
-                                  const vector<LogicalType> &types, StandardEntry *entry) {
-	D_ASSERT(entry);
-	AddBinding(alias, make_unique<EntryBinding>(alias, types, names, index, *entry));
-}
-
-void BindContext::AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery,
-                          ViewCatalogEntry *view) {
-	auto names = AliasColumnNames(alias, subquery.names, ref.column_name_alias);
-	AddEntryBinding(index, alias, names, subquery.types, (StandardEntry *)view);
-}
-
-void BindContext::AddSubquery(idx_t index, const string &alias, TableFunctionRef &ref, BoundQueryNode &subquery) {
-	auto names = AliasColumnNames(alias, subquery.names, ref.column_name_alias);
-	AddGenericBinding(index, alias, names, subquery.types);
-}
-
-void BindContext::AddGenericBinding(idx_t index, const string &alias, const vector<string> &names,
-                                    const vector<LogicalType> &types) {
-	AddBinding(alias, make_unique<Binding>(BindingType::BASE, alias, types, names, index));
-}
-
-void BindContext::AddCTEBinding(idx_t index, const string &alias, const vector<string> &names,
-                                const vector<LogicalType> &types) {
-	auto binding = make_shared<Binding>(BindingType::BASE, alias, types, names, index);
-
-	if (cte_bindings.find(alias) != cte_bindings.end()) {
-		throw BinderException("Duplicate alias \"%s\" in query!", alias);
-	}
-	cte_bindings[alias] = move(binding);
-	cte_references[alias] = std::make_shared<idx_t>(0);
-}
-
-void BindContext::AddContext(BindContext other) {
-	for (auto &binding : other.bindings) {
-		if (bindings.find(binding.first) != bindings.end()) {
-			throw BinderException("Duplicate alias \"%s\" in query!", binding.first);
-		}
-		bindings[binding.first] = move(binding.second);
-	}
-	for (auto &binding : other.bindings_list) {
-		bindings_list.push_back(move(binding));
-	}
-	for (auto &entry : other.using_columns) {
-		for (auto &alias : entry.second) {
-#ifdef DEBUG
-			for (auto &other_alias : using_columns[entry.first]) {
-				for (auto &col : alias->bindings) {
-					D_ASSERT(other_alias->bindings.find(col) == other_alias->bindings.end());
-				}
-			}
-#endif
-			using_columns[entry.first].insert(alias);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void InvertPercentileFractions(unique_ptr<ParsedExpression> &fractions) {
-	D_ASSERT(fractions.get());
-	D_ASSERT(fractions->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = (BoundExpression &)*fractions;
-
-	if (!bound.expr->IsFoldable()) {
-		return;
-	}
-
-	Value value = ExpressionExecutor::EvaluateScalar(*bound.expr);
-	if (value.type().id() == LogicalTypeId::LIST) {
-		vector<Value> values;
-		for (const auto &element_val : ListValue::GetChildren(value)) {
-			values.push_back(Value::DOUBLE(1 - element_val.GetValue<double>()));
-		}
-		bound.expr = make_unique<BoundConstantExpression>(Value::LIST(values));
-	} else {
-		bound.expr = make_unique<BoundConstantExpression>(Value::DOUBLE(1 - value.GetValue<double>()));
-	}
-}
-
-BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
-	// first bind the child of the aggregate expression (if any)
-	this->bound_aggregate = true;
-	unique_ptr<Expression> bound_filter;
-	AggregateBinder aggregate_binder(binder, context);
-	string error, filter_error;
-
-	// Now we bind the filter (if any)
-	if (aggr.filter) {
-		aggregate_binder.BindChild(aggr.filter, 0, error);
-	}
-
-	// Handle ordered-set aggregates by moving the single ORDER BY expression to the front of the children.
-	//	https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE
-	bool ordered_set_agg = false;
-	bool invert_fractions = false;
-	if (aggr.order_bys && aggr.order_bys->orders.size() == 1) {
-		const auto &func_name = aggr.function_name;
-		ordered_set_agg = (func_name == "quantile_cont" || func_name == "quantile_disc" || func_name == "mode");
-
-		if (ordered_set_agg) {
-			auto &config = DBConfig::GetConfig(context);
-			const auto &order = aggr.order_bys->orders[0];
-			const auto sense = (order.type == OrderType::ORDER_DEFAULT) ? config.default_order_type : order.type;
-			invert_fractions = (sense == OrderType::DESCENDING);
-		}
-	}
-
-	for (auto &child : aggr.children) {
-		aggregate_binder.BindChild(child, 0, error);
-		// We have to invert the fractions for PERCENTILE_XXXX DESC
-		if (invert_fractions) {
-			InvertPercentileFractions(child);
-		}
-	}
-
-	// Bind the ORDER BYs, if any
-	if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
-		for (auto &order : aggr.order_bys->orders) {
-			aggregate_binder.BindChild(order.expression, 0, error);
-		}
-	}
-
-	if (!error.empty()) {
-		// failed to bind child
-		if (aggregate_binder.HasBoundColumns()) {
-			for (idx_t i = 0; i < aggr.children.size(); i++) {
-				// however, we bound columns!
-				// that means this aggregation belongs to this node
-				// check if we have to resolve any errors by binding with parent binders
-				bool success = aggregate_binder.BindCorrelatedColumns(aggr.children[i]);
-				// if there is still an error after this, we could not successfully bind the aggregate
-				if (!success) {
-					throw BinderException(error);
-				}
-				auto &bound_expr = (BoundExpression &)*aggr.children[i];
-				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
-			}
-			if (aggr.filter) {
-				bool success = aggregate_binder.BindCorrelatedColumns(aggr.filter);
-				// if there is still an error after this, we could not successfully bind the aggregate
-				if (!success) {
-					throw BinderException(error);
-				}
-				auto &bound_expr = (BoundExpression &)*aggr.filter;
-				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
-			}
-			if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
-				for (auto &order : aggr.order_bys->orders) {
-					bool success = aggregate_binder.BindCorrelatedColumns(order.expression);
-					if (!success) {
-						throw BinderException(error);
-					}
-					auto &bound_expr = (BoundExpression &)*order.expression;
-					ExtractCorrelatedExpressions(binder, *bound_expr.expr);
-				}
-			}
-		} else {
-			// we didn't bind columns, try again in children
-			return BindResult(error);
-		}
-	}
-	if (!filter_error.empty()) {
-		return BindResult(filter_error);
-	}
-
-	if (aggr.filter) {
-		auto &child = (BoundExpression &)*aggr.filter;
-		bound_filter = move(child.expr);
-	}
-	// all children bound successfully
-	// extract the children and types
-	vector<LogicalType> types;
-	vector<LogicalType> arguments;
-	vector<unique_ptr<Expression>> children;
-
-	if (ordered_set_agg) {
-		for (auto &order : aggr.order_bys->orders) {
-			auto &child = (BoundExpression &)*order.expression;
-			types.push_back(child.expr->return_type);
-			arguments.push_back(child.expr->return_type);
-			children.push_back(move(child.expr));
-		}
-		aggr.order_bys->orders.clear();
-	}
-
-	for (idx_t i = 0; i < aggr.children.size(); i++) {
-		auto &child = (BoundExpression &)*aggr.children[i];
-		types.push_back(child.expr->return_type);
-		arguments.push_back(child.expr->return_type);
-		children.push_back(move(child.expr));
-	}
-
-	// bind the aggregate
-	bool cast_parameters;
-	idx_t best_function = Function::BindFunction(func->name, func->functions, types, error, cast_parameters);
-	if (best_function == DConstants::INVALID_INDEX) {
-		throw BinderException(binder.FormatError(aggr, error));
-	}
-	// found a matching function!
-	auto &bound_function = func->functions[best_function];
-
-	// Bind any sort columns, unless the aggregate is order-insensitive
-	auto order_bys = make_unique<BoundOrderModifier>();
-	if (!aggr.order_bys->orders.empty()) {
-		auto &config = DBConfig::GetConfig(context);
-		for (auto &order : aggr.order_bys->orders) {
-			auto &order_expr = (BoundExpression &)*order.expression;
-			const auto sense = (order.type == OrderType::ORDER_DEFAULT) ? config.default_order_type : order.type;
-			const auto null_order =
-			    (order.null_order == OrderByNullType::ORDER_DEFAULT) ? config.default_null_order : order.null_order;
-			order_bys->orders.emplace_back(BoundOrderByNode(sense, null_order, move(order_expr.expr)));
-		}
-	}
-
-	auto aggregate = AggregateFunction::BindAggregateFunction(
-	    context, bound_function, move(children), move(bound_filter), aggr.distinct, move(order_bys), cast_parameters);
-	if (aggr.export_state) {
-		aggregate = ExportAggregateFunction::Bind(move(aggregate));
-	}
-
-	// check for all the aggregates if this aggregate already exists
-	idx_t aggr_index;
-	auto entry = node.aggregate_map.find(aggregate.get());
-	if (entry == node.aggregate_map.end()) {
-		// new aggregate: insert into aggregate list
-		aggr_index = node.aggregates.size();
-		node.aggregate_map.insert(make_pair(aggregate.get(), aggr_index));
-		node.aggregates.push_back(move(aggregate));
-	} else {
-		// duplicate aggregate: simplify refer to this aggregate
-		aggr_index = entry->second;
-	}
-
-	// now create a column reference referring to the aggregate
-	auto colref = make_unique<BoundColumnRefExpression>(
-	    aggr.alias.empty() ? node.aggregates[aggr_index]->ToString() : aggr.alias,
-	    node.aggregates[aggr_index]->return_type, ColumnBinding(node.aggregate_index, aggr_index), depth);
-	// move the aggregate expression into the set of bound aggregates
-	return BindResult(move(colref));
-}
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth) {
-	// first try to bind the children of the case expression
-	string error;
-	BindChild(expr.input, depth, error);
-	BindChild(expr.lower, depth, error);
-	BindChild(expr.upper, depth, error);
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	// the children have been successfully resolved
-	auto &input = (BoundExpression &)*expr.input;
-	auto &lower = (BoundExpression &)*expr.lower;
-	auto &upper = (BoundExpression &)*expr.upper;
-
-	auto input_sql_type = input.expr->return_type;
-	auto lower_sql_type = lower.expr->return_type;
-	auto upper_sql_type = upper.expr->return_type;
-
-	// cast the input types to the same type
-	// now obtain the result type of the input types
-	auto input_type = BoundComparisonExpression::BindComparison(input_sql_type, lower_sql_type);
-	input_type = BoundComparisonExpression::BindComparison(input_type, upper_sql_type);
-	// add casts (if necessary)
-	input.expr = BoundCastExpression::AddCastToType(move(input.expr), input_type);
-	lower.expr = BoundCastExpression::AddCastToType(move(lower.expr), input_type);
-	upper.expr = BoundCastExpression::AddCastToType(move(upper.expr), input_type);
-	if (input_type.id() == LogicalTypeId::VARCHAR) {
-		// handle collation
-		auto collation = StringType::GetCollation(input_type);
-		input.expr = PushCollation(context, move(input.expr), collation, false);
-		lower.expr = PushCollation(context, move(lower.expr), collation, false);
-		upper.expr = PushCollation(context, move(upper.expr), collation, false);
-	}
-	if (!input.expr->HasSideEffects() && !input.expr->HasParameter() && !input.expr->HasSubquery()) {
-		// the expression does not have side effects and can be copied: create two comparisons
-		// the reason we do this is that individual comparisons are easier to handle in optimizers
-		// if both comparisons remain they will be folded together again into a single BETWEEN in the optimizer
-		auto left_compare = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
-		                                                           input.expr->Copy(), move(lower.expr));
-		auto right_compare = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
-		                                                            move(input.expr), move(upper.expr));
-		return BindResult(make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, move(left_compare),
-		                                                          move(right_compare)));
-	} else {
-		// expression has side effects: we cannot duplicate it
-		// create a bound_between directly
-		return BindResult(
-		    make_unique<BoundBetweenExpression>(move(input.expr), move(lower.expr), move(upper.expr), true, true));
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(CaseExpression &expr, idx_t depth) {
-	// first try to bind the children of the case expression
-	string error;
-	for (auto &check : expr.case_checks) {
-		BindChild(check.when_expr, depth, error);
-		BindChild(check.then_expr, depth, error);
-	}
-	BindChild(expr.else_expr, depth, error);
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	// the children have been successfully resolved
-	// figure out the result type of the CASE expression
-	auto return_type = ((BoundExpression &)*expr.else_expr).expr->return_type;
-	for (auto &check : expr.case_checks) {
-		auto &then_expr = (BoundExpression &)*check.then_expr;
-		return_type = LogicalType::MaxLogicalType(return_type, then_expr.expr->return_type);
-	}
-
-	// bind all the individual components of the CASE statement
-	auto result = make_unique<BoundCaseExpression>(return_type);
-	for (idx_t i = 0; i < expr.case_checks.size(); i++) {
-		auto &check = expr.case_checks[i];
-		auto &when_expr = (BoundExpression &)*check.when_expr;
-		auto &then_expr = (BoundExpression &)*check.then_expr;
-		BoundCaseCheck result_check;
-		result_check.when_expr = BoundCastExpression::AddCastToType(move(when_expr.expr), LogicalType::BOOLEAN);
-		result_check.then_expr = BoundCastExpression::AddCastToType(move(then_expr.expr), return_type);
-		result->case_checks.push_back(move(result_check));
-	}
-	auto &else_expr = (BoundExpression &)*expr.else_expr;
-	result->else_expr = BoundCastExpression::AddCastToType(move(else_expr.expr), return_type);
-	return BindResult(move(result));
-}
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
-	// first try to bind the child of the cast expression
-	string error = Bind(&expr.child, depth);
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	// FIXME: We can also implement 'hello'::schema.custom_type; and pass by the schema down here.
-	// Right now just considering its DEFAULT_SCHEMA always
-	Binder::BindLogicalType(context, expr.cast_type, DEFAULT_SCHEMA);
-	// the children have been successfully resolved
-	auto &child = (BoundExpression &)*expr.child;
-	if (expr.try_cast) {
-		if (child.expr->return_type == expr.cast_type) {
-			// no cast required: type matches
-			return BindResult(move(child.expr));
-		}
-		child.expr = make_unique<BoundCastExpression>(move(child.expr), expr.cast_type, true);
-	} else {
-		if (child.expr->type == ExpressionType::VALUE_PARAMETER) {
-			auto &parameter = (BoundParameterExpression &)*child.expr;
-			// parameter: move types into the parameter expression itself
-			parameter.return_type = expr.cast_type;
-		} else {
-			// otherwise add a cast to the target type
-			child.expr = BoundCastExpression::AddCastToType(move(child.expr), expr.cast_type);
-		}
-	}
-	return BindResult(move(child.expr));
-}
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth) {
-	// first try to bind the child of the cast expression
-	string error = Bind(&expr.child, depth);
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	auto &child = (BoundExpression &)*expr.child;
-	if (child.expr->return_type.id() != LogicalTypeId::VARCHAR) {
-		throw BinderException("collations are only supported for type varchar");
-	}
-	child.expr->return_type = LogicalType::VARCHAR_COLLATION(expr.collation);
-	return BindResult(move(child.expr));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &column_name, string &error_message) {
-	auto using_binding = binder.bind_context.GetUsingBinding(column_name);
-	if (using_binding) {
-		// we are referencing a USING column
-		// check if we can refer to one of the base columns directly
-		unique_ptr<Expression> expression;
-		if (!using_binding->primary_binding.empty()) {
-			// we can! just assign the table name and re-bind
-			return make_unique<ColumnRefExpression>(column_name, using_binding->primary_binding);
-		} else {
-			// // we cannot! we need to bind this as a coalesce between all the relevant columns
-			auto coalesce = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-			for (auto &entry : using_binding->bindings) {
-				coalesce->children.push_back(make_unique<ColumnRefExpression>(column_name, entry));
-			}
-			return move(coalesce);
-		}
-	}
-	// no table name: find a binding that contains this
-	if (binder.macro_binding != nullptr && binder.macro_binding->HasMatchingBinding(column_name)) {
-		// priority to macro parameter bindings TODO: throw a warning when this name conflicts
-		D_ASSERT(!binder.macro_binding->alias.empty());
-		return make_unique<ColumnRefExpression>(column_name, binder.macro_binding->alias);
-	} else {
-		// see if it's a column
-		string table_name = binder.bind_context.GetMatchingBinding(column_name);
-		if (!table_name.empty()) {
-			return binder.bind_context.CreateColumnReference(table_name, column_name);
-		}
-		// it's not, find candidates and error
-		auto similar_bindings = binder.bind_context.GetSimilarBindings(column_name);
-		string candidate_str = StringUtil::CandidatesMessage(similar_bindings, "Candidate bindings");
-		error_message =
-		    StringUtil::Format("Referenced column \"%s\" not found in FROM clause!%s", column_name, candidate_str);
-		return nullptr;
-	}
-}
-
-void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr) {
-	switch (expr->type) {
-	case ExpressionType::COLUMN_REF: {
-		auto &colref = (ColumnRefExpression &)*expr;
-		string error_message;
-		auto new_expr = QualifyColumnName(colref, error_message);
-		if (new_expr) {
-			if (!expr->alias.empty()) {
-				new_expr->alias = expr->alias;
-			}
-			expr = move(new_expr);
-		}
-		break;
-	}
-	case ExpressionType::POSITIONAL_REFERENCE: {
-		auto &ref = (PositionalReferenceExpression &)*expr;
-		if (ref.alias.empty()) {
-			string table_name, column_name;
-			auto error = binder.bind_context.BindColumn(ref, table_name, column_name);
-			if (error.empty()) {
-				ref.alias = column_name;
-			}
-		}
-		break;
-	}
-	default:
-		break;
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyColumnNames(child); });
-}
-
-void ExpressionBinder::QualifyColumnNames(Binder &binder, unique_ptr<ParsedExpression> &expr) {
-	WhereBinder where_binder(binder, binder.context);
-	where_binder.QualifyColumnNames(expr);
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::CreateStructExtract(unique_ptr<ParsedExpression> base,
-                                                                   string field_name) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(move(base));
-	children.push_back(make_unique_base<ParsedExpression, ConstantExpression>(Value(move(field_name))));
-	auto extract_fun = make_unique<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, move(children));
-	return move(extract_fun);
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::CreateStructPack(ColumnRefExpression &colref) {
-	D_ASSERT(colref.column_names.size() <= 2);
-	string error_message;
-	auto &table_name = colref.column_names.back();
-	auto binding = binder.bind_context.GetBinding(table_name, error_message);
-	if (!binding) {
-		return nullptr;
-	}
-	if (colref.column_names.size() == 2) {
-		// "schema_name.table_name"
-		auto catalog_entry = binding->GetStandardEntry();
-		if (!catalog_entry) {
-			return nullptr;
-		}
-		auto &schema_name = colref.column_names[0];
-		if (catalog_entry->schema->name != schema_name || catalog_entry->name != table_name) {
-			return nullptr;
-		}
-	}
-	// We found the table, now create the struct_pack expression
-	vector<unique_ptr<ParsedExpression>> child_exprs;
-	for (const auto &column_name : binding->names) {
-		child_exprs.push_back(make_unique<ColumnRefExpression>(column_name, table_name));
-	}
-	return make_unique<FunctionExpression>("struct_pack", move(child_exprs));
-}
-
-unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpression &colref, string &error_message) {
-	idx_t column_parts = colref.column_names.size();
-	// column names can have an arbitrary amount of dots
-	// here is how the resolution works:
-	if (column_parts == 1) {
-		// no dots (i.e. "part1")
-		// -> part1 refers to a column
-		// check if we can qualify the column name with the table name
-		auto qualified_colref = QualifyColumnName(colref.GetColumnName(), error_message);
-		if (qualified_colref) {
-			// we could: return it
-			return qualified_colref;
-		}
-		// we could not! Try creating an implicit struct_pack
-		return CreateStructPack(colref);
-	} else if (column_parts == 2) {
-		// one dot (i.e. "part1.part2")
-		// EITHER:
-		// -> part1 is a table, part2 is a column
-		// -> part1 is a column, part2 is a property of that column (i.e. struct_extract)
-
-		// first check if part1 is a table, and part2 is a standard column
-		if (binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], error_message)) {
-			// it is! return the colref directly
-			return binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1]);
-		} else {
-			// otherwise check if we can turn this into a struct extract
-			auto new_colref = make_unique<ColumnRefExpression>(colref.column_names[0]);
-			string other_error;
-			auto qualified_colref = QualifyColumnName(colref.column_names[0], other_error);
-			if (qualified_colref) {
-				// we could: create a struct extract
-				return CreateStructExtract(move(qualified_colref), colref.column_names[1]);
-			}
-			// we could not! Try creating an implicit struct_pack
-			return CreateStructPack(colref);
-		}
-	} else {
-		// two or more dots (i.e. "part1.part2.part3.part4...")
-		// -> part1 is a schema, part2 is a table, part3 is a column name, part4 and beyond are struct fields
-		// -> part1 is a table, part2 is a column name, part3 and beyond are struct fields
-		// -> part1 is a column, part2 and beyond are struct fields
-
-		// we always prefer the most top-level view
-		// i.e. in case of multiple resolution options, we resolve in order:
-		// -> 1. resolve "part1" as a schema
-		// -> 2. resolve "part1" as a table
-		// -> 3. resolve "part1" as a column
-
-		unique_ptr<ParsedExpression> result_expr;
-		idx_t struct_extract_start;
-		// first check if part1 is a schema
-		if (binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], colref.column_names[2],
-		                              error_message)) {
-			// it is! the column reference is "schema.table.column"
-			// any additional fields are turned into struct_extract calls
-			result_expr = binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1],
-			                                                        colref.column_names[2]);
-			struct_extract_start = 3;
-		} else if (binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], error_message)) {
-			// part1 is a table
-			// the column reference is "table.column"
-			// any additional fields are turned into struct_extract calls
-			result_expr = binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1]);
-			struct_extract_start = 2;
-		} else {
-			// part1 could be a column
-			string col_error;
-			result_expr = QualifyColumnName(colref.column_names[0], col_error);
-			if (!result_expr) {
-				// it is not! return the error
-				return nullptr;
-			}
-			// it is! add the struct extract calls
-			struct_extract_start = 1;
-		}
-		for (idx_t i = struct_extract_start; i < colref.column_names.size(); i++) {
-			result_expr = CreateStructExtract(move(result_expr), colref.column_names[i]);
-		}
-		return result_expr;
-	}
-}
-
-BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t depth) {
-	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		return BindResult(make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
-	}
-	string error_message;
-	auto expr = QualifyColumnName(colref_p, error_message);
-	if (!expr) {
-		return BindResult(binder.FormatError(colref_p, error_message));
-	}
-	//! Generated column returns generated expression
-	if (expr->type != ExpressionType::COLUMN_REF) {
-		return BindExpression(&expr, depth);
-	}
-	auto &colref = (ColumnRefExpression &)*expr;
-	D_ASSERT(colref.IsQualified());
-	auto &table_name = colref.GetTableName();
-
-	// individual column reference
-	// resolve to either a base table or a subquery expression
-	// if it was a macro parameter, let macro_binding bind it to the argument
-	BindResult result;
-	if (binder.macro_binding && table_name == binder.macro_binding->alias) {
-		result = binder.macro_binding->Bind(colref, depth);
-	} else {
-		result = binder.bind_context.BindColumn(colref, depth);
-	}
-	if (!result.HasError()) {
-		BoundColumnReferenceInfo ref;
-		ref.name = colref.column_names.back();
-		ref.query_location = colref.query_location;
-		bound_columns.push_back(move(ref));
-	} else {
-		result.error = binder.FormatError(colref_p, result.error);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<Expression> ExpressionBinder::PushCollation(ClientContext &context, unique_ptr<Expression> source,
-                                                       const string &collation_p, bool equality_only) {
-	// replace default collation with system collation
-	string collation;
-	if (collation_p.empty()) {
-		collation = DBConfig::GetConfig(context).collation;
-	} else {
-		collation = collation_p;
-	}
-	collation = StringUtil::Lower(collation);
-	// bind the collation
-	if (collation.empty() || collation == "binary" || collation == "c" || collation == "posix") {
-		// binary collation: just skip
-		return source;
-	}
-	auto &catalog = Catalog::GetCatalog(context);
-	auto splits = StringUtil::Split(StringUtil::Lower(collation), ".");
-	vector<CollateCatalogEntry *> entries;
-	for (auto &collation_argument : splits) {
-		auto collation_entry = catalog.GetEntry<CollateCatalogEntry>(context, DEFAULT_SCHEMA, collation_argument);
-		if (collation_entry->combinable) {
-			entries.insert(entries.begin(), collation_entry);
-		} else {
-			if (!entries.empty() && !entries.back()->combinable) {
-				throw BinderException("Cannot combine collation types \"%s\" and \"%s\"", entries.back()->name,
-				                      collation_entry->name);
-			}
-			entries.push_back(collation_entry);
-		}
-	}
-	for (auto &collation_entry : entries) {
-		if (equality_only && collation_entry->not_required_for_equality) {
-			continue;
-		}
-		vector<unique_ptr<Expression>> children;
-		children.push_back(move(source));
-		auto function = ScalarFunction::BindScalarFunction(context, collation_entry->function, move(children));
-		source = move(function);
-	}
-	return source;
-}
-
-void ExpressionBinder::TestCollation(ClientContext &context, const string &collation) {
-	PushCollation(context, make_unique<BoundConstantExpression>(Value("")), collation);
-}
-
-LogicalType BoundComparisonExpression::BindComparison(LogicalType left_type, LogicalType right_type) {
-	auto result_type = LogicalType::MaxLogicalType(left_type, right_type);
-	switch (result_type.id()) {
-	case LogicalTypeId::DECIMAL: {
-		// result is a decimal: we need the maximum width and the maximum scale over width
-		vector<LogicalType> argument_types = {left_type, right_type};
-		uint8_t max_width = 0, max_scale = 0, max_width_over_scale = 0;
-		for (idx_t i = 0; i < argument_types.size(); i++) {
-			uint8_t width, scale;
-			auto can_convert = argument_types[i].GetDecimalProperties(width, scale);
-			if (!can_convert) {
-				return result_type;
-			}
-			max_width = MaxValue<uint8_t>(width, max_width);
-			max_scale = MaxValue<uint8_t>(scale, max_scale);
-			max_width_over_scale = MaxValue<uint8_t>(width - scale, max_width_over_scale);
-		}
-		max_width = MaxValue<uint8_t>(max_scale + max_width_over_scale, max_width);
-		if (max_width > Decimal::MAX_WIDTH_DECIMAL) {
-			// target width does not fit in decimal: truncate the scale (if possible) to try and make it fit
-			max_width = Decimal::MAX_WIDTH_DECIMAL;
-		}
-		return LogicalType::DECIMAL(max_width, max_scale);
-	}
-	case LogicalTypeId::VARCHAR:
-		// for comparison with strings, we prefer to bind to the numeric types
-		if (left_type.IsNumeric() || left_type.id() == LogicalTypeId::BOOLEAN) {
-			return left_type;
-		} else if (right_type.IsNumeric() || right_type.id() == LogicalTypeId::BOOLEAN) {
-			return right_type;
-		} else {
-			// else: check if collations are compatible
-			auto left_collation = StringType::GetCollation(left_type);
-			auto right_collation = StringType::GetCollation(right_type);
-			if (!left_collation.empty() && !right_collation.empty() && left_collation != right_collation) {
-				throw BinderException("Cannot combine types with different collation!");
-			}
-		}
-		return result_type;
-	default:
-		return result_type;
-	}
-}
-
-BindResult ExpressionBinder::BindExpression(ComparisonExpression &expr, idx_t depth) {
-	// first try to bind the children of the case expression
-	string error;
-	BindChild(expr.left, depth, error);
-	BindChild(expr.right, depth, error);
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	// the children have been successfully resolved
-	auto &left = (BoundExpression &)*expr.left;
-	auto &right = (BoundExpression &)*expr.right;
-	auto left_sql_type = left.expr->return_type;
-	auto right_sql_type = right.expr->return_type;
-	// cast the input types to the same type
-	// now obtain the result type of the input types
-	auto input_type = BoundComparisonExpression::BindComparison(left_sql_type, right_sql_type);
-	// add casts (if necessary)
-	left.expr = BoundCastExpression::AddCastToType(move(left.expr), input_type, input_type.id() == LogicalTypeId::ENUM);
-	right.expr =
-	    BoundCastExpression::AddCastToType(move(right.expr), input_type, input_type.id() == LogicalTypeId::ENUM);
-
-	if (input_type.id() == LogicalTypeId::VARCHAR) {
-		// handle collation
-		auto collation = StringType::GetCollation(input_type);
-		left.expr = PushCollation(context, move(left.expr), collation, expr.type == ExpressionType::COMPARE_EQUAL);
-		right.expr = PushCollation(context, move(right.expr), collation, expr.type == ExpressionType::COMPARE_EQUAL);
-	}
-	// now create the bound comparison expression
-	return BindResult(make_unique<BoundComparisonExpression>(expr.type, move(left.expr), move(right.expr)));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(ConjunctionExpression &expr, idx_t depth) {
-	// first try to bind the children of the case expression
-	string error;
-	for (idx_t i = 0; i < expr.children.size(); i++) {
-		BindChild(expr.children[i], depth, error);
-	}
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	// the children have been successfully resolved
-	// cast the input types to boolean (if necessary)
-	// and construct the bound conjunction expression
-	auto result = make_unique<BoundConjunctionExpression>(expr.type);
-	for (auto &child_expr : expr.children) {
-		auto &child = (BoundExpression &)*child_expr;
-		result->children.push_back(BoundCastExpression::AddCastToType(move(child.expr), LogicalType::BOOLEAN));
-	}
-	// now create the bound conjunction expression
-	return BindResult(move(result));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(ConstantExpression &expr, idx_t depth) {
-	return BindResult(make_unique<BoundConstantExpression>(expr.value));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t depth,
-                                            unique_ptr<ParsedExpression> *expr_ptr) {
-	// lookup the function in the catalog
-	QueryErrorContext error_context(binder.root_statement, function.query_location);
-
-	if (function.function_name == "unnest" || function.function_name == "unlist") {
-		// special case, not in catalog
-		// TODO make sure someone does not create such a function OR
-		// have unnest live in catalog, too
-		return BindUnnest(function, depth);
-	}
-	auto &catalog = Catalog::GetCatalog(context);
-	auto func = catalog.GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.schema, function.function_name,
-	                             false, error_context);
-	switch (func->type) {
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-		// scalar function
-		return BindFunction(function, (ScalarFunctionCatalogEntry *)func, depth);
-	case CatalogType::MACRO_ENTRY:
-		// macro function
-		return BindMacro(function, (ScalarMacroCatalogEntry *)func, depth, expr_ptr);
-	default:
-		// aggregate function
-		return BindAggregate(function, (AggregateFunctionCatalogEntry *)func, depth);
-	}
-}
-
-BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFunctionCatalogEntry *func, idx_t depth) {
-	// bind the children of the function expression
-	string error;
-	for (idx_t i = 0; i < function.children.size(); i++) {
-		BindChild(function.children[i], depth, error);
-	}
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		return BindResult(make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
-	}
-
-	// all children bound successfully
-	// extract the children and types
-	vector<unique_ptr<Expression>> children;
-	for (idx_t i = 0; i < function.children.size(); i++) {
-		auto &child = (BoundExpression &)*function.children[i];
-		D_ASSERT(child.expr);
-		children.push_back(move(child.expr));
-	}
-	unique_ptr<Expression> result =
-	    ScalarFunction::BindScalarFunction(context, *func, move(children), error, function.is_operator, &binder);
-	if (!result) {
-		throw BinderException(binder.FormatError(function, error));
-	}
-	return BindResult(move(result));
-}
-
-BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function,
-                                           idx_t depth) {
-	return BindResult(binder.FormatError(expr, UnsupportedAggregateMessage()));
-}
-
-BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth) {
-	return BindResult(binder.FormatError(expr, UnsupportedUnnestMessage()));
-}
-
-string ExpressionBinder::UnsupportedAggregateMessage() {
-	return "Aggregate functions are not supported here";
-}
-
-string ExpressionBinder::UnsupportedUnnestMessage() {
-	return "UNNEST not supported here";
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-// static string ExtractColumnFromLambda(ParsedExpression &expr) {
-//	if (expr.type != ExpressionType::COLUMN_REF) {
-//		throw ParserException("Lambda parameter must be a column name");
-//	}
-//	auto &colref = (ColumnRefExpression &)expr;
-//	if (colref.IsQualified()) {
-//		throw ParserException("Lambda parameter must be an unqualified name (e.g. 'x', not 'a.x')");
-//	}
-//	return colref.column_names[0];
-// }
-
-BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth) {
-	string error;
-
-	// FIXME: decide from the context whether this is actually a LambdaExpression
-	//  If it is, bind it as a lambda here
-	// // set up the lambda capture
-	// FIXME: need to get the type from the list for binding
-	// lambda_capture = expr.capture_name;
-	// // bind the child
-	// BindChild(expr.expression, depth, error);
-	// // clear the lambda capture
-	// lambda_capture = "";
-	// if (!error.empty()) {
-	// 	return BindResult(error);
-	// }
-	// expr.Print();
-	OperatorExpression arrow_expr(ExpressionType::ARROW, move(expr.lhs), move(expr.rhs));
-	return ExpressionBinder::BindExpression(arrow_expr, depth);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr) {
-	switch (expr->GetExpressionClass()) {
-	case ExpressionClass::COLUMN_REF: {
-		// if expr is a parameter, replace it with its argument
-		auto &colref = (ColumnRefExpression &)*expr;
-		bool bind_macro_parameter = false;
-		if (colref.IsQualified()) {
-			bind_macro_parameter = colref.GetTableName() == MacroBinding::MACRO_NAME;
-		} else {
-			bind_macro_parameter = macro_binding->HasMatchingBinding(colref.GetColumnName());
-		}
-		if (bind_macro_parameter) {
-			D_ASSERT(macro_binding->HasMatchingBinding(colref.GetColumnName()));
-			expr = macro_binding->ParamToArg(colref);
-		}
-		return;
-	}
-	case ExpressionClass::SUBQUERY: {
-		// replacing parameters within a subquery is slightly different
-		auto &sq = ((SubqueryExpression &)*expr).subquery;
-		ParsedExpressionIterator::EnumerateQueryNodeChildren(
-		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
-		break;
-	}
-	default: // fall through
-		break;
-	}
-	// unfold child expressions
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
-}
-
-BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry *macro_func, idx_t depth,
-                                       unique_ptr<ParsedExpression> *expr) {
-
-	// recast function so we can access the scalar member function->expression
-	auto &macro_def = (ScalarMacroFunction &)*macro_func->function;
-
-	// validate the arguments and separate positional and default arguments
-	vector<unique_ptr<ParsedExpression>> positionals;
-	unordered_map<string, unique_ptr<ParsedExpression>> defaults;
-
-	string error =
-	    MacroFunction::ValidateArguments(*macro_func->function, macro_func->name, function, positionals, defaults);
-	if (!error.empty()) {
-		return BindResult(binder.FormatError(*expr->get(), error));
-	}
-
-	// create a MacroBinding to bind this macro's parameters to its arguments
-	vector<LogicalType> types;
-	vector<string> names;
-	// positional parameters
-	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
-		types.emplace_back(LogicalType::SQLNULL);
-		auto &param = (ColumnRefExpression &)*macro_def.parameters[i];
-		names.push_back(param.GetColumnName());
-	}
-	// default parameters
-	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		types.emplace_back(LogicalType::SQLNULL);
-		names.push_back(it->first);
-		// now push the defaults into the positionals
-		positionals.push_back(move(defaults[it->first]));
-	}
-	auto new_macro_binding = make_unique<MacroBinding>(types, names, macro_func->name);
-	new_macro_binding->arguments = move(positionals);
-	macro_binding = new_macro_binding.get();
-
-	// replace current expression with stored macro expression, and replace params
-	*expr = macro_def.expression->Copy();
-	ReplaceMacroParametersRecursive(*expr);
-
-	// bind the unfolded macro
-	return BindExpression(expr, depth);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-static LogicalType ResolveNotType(OperatorExpression &op, vector<BoundExpression *> &children) {
-	// NOT expression, cast child to BOOLEAN
-	D_ASSERT(children.size() == 1);
-	children[0]->expr = BoundCastExpression::AddCastToType(move(children[0]->expr), LogicalType::BOOLEAN);
-	return LogicalType(LogicalTypeId::BOOLEAN);
-}
-
-static LogicalType ResolveInType(OperatorExpression &op, vector<BoundExpression *> &children) {
-	if (children.empty()) {
-		throw InternalException("IN requires at least a single child node");
-	}
-	// get the maximum type from the children
-	LogicalType max_type = children[0]->expr->return_type;
-	for (idx_t i = 1; i < children.size(); i++) {
-		max_type = LogicalType::MaxLogicalType(max_type, children[i]->expr->return_type);
-	}
-
-	// cast all children to the same type
-	for (idx_t i = 0; i < children.size(); i++) {
-		children[i]->expr = BoundCastExpression::AddCastToType(move(children[i]->expr), max_type);
-	}
-	// (NOT) IN always returns a boolean
-	return LogicalType::BOOLEAN;
-}
-
-static LogicalType ResolveOperatorType(OperatorExpression &op, vector<BoundExpression *> &children) {
-	switch (op.type) {
-	case ExpressionType::OPERATOR_IS_NULL:
-	case ExpressionType::OPERATOR_IS_NOT_NULL:
-		// IS (NOT) NULL always returns a boolean, and does not cast its children
-		return LogicalType::BOOLEAN;
-	case ExpressionType::COMPARE_IN:
-	case ExpressionType::COMPARE_NOT_IN:
-		return ResolveInType(op, children);
-	case ExpressionType::OPERATOR_COALESCE: {
-		ResolveInType(op, children);
-		return children[0]->expr->return_type;
-	}
-	case ExpressionType::OPERATOR_NOT:
-		return ResolveNotType(op, children);
-	default:
-		throw InternalException("Unrecognized expression type for ResolveOperatorType");
-	}
-}
-
-BindResult ExpressionBinder::BindGroupingFunction(OperatorExpression &op, idx_t depth) {
-	return BindResult("GROUPING function is not supported here");
-}
-
-BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth) {
-	if (op.type == ExpressionType::GROUPING_FUNCTION) {
-		return BindGroupingFunction(op, depth);
-	}
-	// bind the children of the operator expression
-	string error;
-	for (idx_t i = 0; i < op.children.size(); i++) {
-		BindChild(op.children[i], depth, error);
-	}
-	if (!error.empty()) {
-		return BindResult(error);
-	}
-	// all children bound successfully
-	string function_name;
-	switch (op.type) {
-	case ExpressionType::ARRAY_EXTRACT: {
-		D_ASSERT(op.children[0]->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &b_exp = (BoundExpression &)*op.children[0];
-		if (b_exp.expr->return_type.id() == LogicalTypeId::MAP) {
-			function_name = "map_extract";
-		} else {
-			function_name = "array_extract";
-		}
-		break;
-	}
-	case ExpressionType::ARRAY_SLICE:
-		function_name = "array_slice";
-		break;
-	case ExpressionType::STRUCT_EXTRACT: {
-		D_ASSERT(op.children.size() == 2);
-		D_ASSERT(op.children[0]->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		D_ASSERT(op.children[1]->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &extract_exp = (BoundExpression &)*op.children[0];
-		auto &name_exp = (BoundExpression &)*op.children[1];
-		if (extract_exp.expr->return_type.id() != LogicalTypeId::STRUCT &&
-		    extract_exp.expr->return_type.id() != LogicalTypeId::SQLNULL) {
-			return BindResult(
-			    StringUtil::Format("Cannot extract field %s from expression \"%s\" because it is not a struct",
-			                       name_exp.ToString(), extract_exp.ToString()));
-		}
-		function_name = "struct_extract";
-		break;
-	}
-	case ExpressionType::ARRAY_CONSTRUCTOR:
-		function_name = "list_value";
-		break;
-	case ExpressionType::ARROW:
-		function_name = "json_extract";
-		break;
-	default:
-		break;
-	}
-	if (!function_name.empty()) {
-		auto function = make_unique<FunctionExpression>(function_name, move(op.children));
-		return BindExpression(*function, depth, nullptr);
-	}
-
-	vector<BoundExpression *> children;
-	for (idx_t i = 0; i < op.children.size(); i++) {
-		D_ASSERT(op.children[i]->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		children.push_back((BoundExpression *)op.children[i].get());
-	}
-	// now resolve the types
-	LogicalType result_type = ResolveOperatorType(op, children);
-	if (op.type == ExpressionType::OPERATOR_COALESCE) {
-		if (children.empty()) {
-			throw BinderException("COALESCE needs at least one child");
-		}
-		if (children.size() == 1) {
-			return BindResult(move(children[0]->expr));
-		}
-	}
-
-	auto result = make_unique<BoundOperatorExpression>(op.type, result_type);
-	for (auto &child : children) {
-		result->children.push_back(move(child->expr));
-	}
-	return BindResult(move(result));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t depth) {
-	D_ASSERT(expr.parameter_nr > 0);
-	auto bound_parameter = make_unique<BoundParameterExpression>(expr.parameter_nr);
-	if (!binder.parameters) {
-		throw std::runtime_error("Unexpected prepared parameter. This type of statement can't be prepared!");
-	}
-	binder.parameters->push_back(bound_parameter.get());
-	if (binder.parameter_types && expr.parameter_nr <= binder.parameter_types->size()) {
-		bound_parameter->return_type = (*binder.parameter_types)[expr.parameter_nr - 1];
-	}
-	return BindResult(move(bound_parameter));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BindResult ExpressionBinder::BindExpression(PositionalReferenceExpression &ref, idx_t depth) {
-	if (depth != 0) {
-		return BindResult("Positional reference expression could not be bound");
-	}
-	return binder.bind_context.BindColumn(ref, depth);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundSubqueryNode : public QueryNode {
-public:
-	BoundSubqueryNode(shared_ptr<Binder> subquery_binder, unique_ptr<BoundQueryNode> bound_node,
-	                  unique_ptr<SelectStatement> subquery)
-	    : QueryNode(QueryNodeType::BOUND_SUBQUERY_NODE), subquery_binder(move(subquery_binder)),
-	      bound_node(move(bound_node)), subquery(move(subquery)) {
-	}
-
-	shared_ptr<Binder> subquery_binder;
-	unique_ptr<BoundQueryNode> bound_node;
-	unique_ptr<SelectStatement> subquery;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		throw InternalException("Cannot get select list of bound subquery node");
-	}
-
-	string ToString() const override {
-		throw InternalException("Cannot ToString bound subquery node");
-	}
-	unique_ptr<QueryNode> Copy() const override {
-		throw InternalException("Cannot copy bound subquery node");
-	}
-	void Serialize(FieldWriter &writer) const override {
-		throw InternalException("Cannot serialize bound subquery node");
-	}
-};
-
-BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t depth) {
-	if (expr.subquery->node->type != QueryNodeType::BOUND_SUBQUERY_NODE) {
-		D_ASSERT(depth == 0);
-		// first bind the actual subquery in a new binder
-		auto subquery_binder = Binder::CreateBinder(context, &binder);
-		subquery_binder->can_contain_nulls = true;
-		auto bound_node = subquery_binder->BindNode(*expr.subquery->node);
-		// check the correlated columns of the subquery for correlated columns with depth > 1
-		for (idx_t i = 0; i < subquery_binder->correlated_columns.size(); i++) {
-			CorrelatedColumnInfo corr = subquery_binder->correlated_columns[i];
-			if (corr.depth > 1) {
-				// depth > 1, the column references the query ABOVE the current one
-				// add to the set of correlated columns for THIS query
-				corr.depth -= 1;
-				binder.AddCorrelatedColumn(corr);
-			}
-		}
-		if (expr.subquery_type != SubqueryType::EXISTS && bound_node->types.size() > 1) {
-			throw BinderException(binder.FormatError(
-			    expr, StringUtil::Format("Subquery returns %zu columns - expected 1", bound_node->types.size())));
-		}
-		auto prior_subquery = move(expr.subquery);
-		expr.subquery = make_unique<SelectStatement>();
-		expr.subquery->node =
-		    make_unique<BoundSubqueryNode>(move(subquery_binder), move(bound_node), move(prior_subquery));
-	}
-	// now bind the child node of the subquery
-	if (expr.child) {
-		// first bind the children of the subquery, if any
-		string error = Bind(&expr.child, depth);
-		if (!error.empty()) {
-			return BindResult(error);
-		}
-	}
-	// both binding the child and binding the subquery was successful
-	D_ASSERT(expr.subquery->node->type == QueryNodeType::BOUND_SUBQUERY_NODE);
-	auto bound_subquery = (BoundSubqueryNode *)expr.subquery->node.get();
-	auto child = (BoundExpression *)expr.child.get();
-	auto subquery_binder = move(bound_subquery->subquery_binder);
-	auto bound_node = move(bound_subquery->bound_node);
-	LogicalType return_type =
-	    expr.subquery_type == SubqueryType::SCALAR ? bound_node->types[0] : LogicalType(LogicalTypeId::BOOLEAN);
-	if (return_type.id() == LogicalTypeId::UNKNOWN) {
-		return_type = LogicalType::SQLNULL;
-	}
-
-	auto result = make_unique<BoundSubqueryExpression>(return_type);
-	if (expr.subquery_type == SubqueryType::ANY) {
-		// ANY comparison
-		// cast child and subquery child to equivalent types
-		D_ASSERT(bound_node->types.size() == 1);
-		auto compare_type = LogicalType::MaxLogicalType(child->expr->return_type, bound_node->types[0]);
-		child->expr = BoundCastExpression::AddCastToType(move(child->expr), compare_type);
-		result->child_type = bound_node->types[0];
-		result->child_target = compare_type;
-	}
-	result->binder = move(subquery_binder);
-	result->subquery = move(bound_node);
-	result->subquery_type = expr.subquery_type;
-	result->child = child ? move(child->expr) : nullptr;
-	result->comparison_type = expr.comparison_type;
-
-	return BindResult(move(result));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth) {
-	// bind the children of the function expression
-	string error;
-	if (function.children.size() != 1) {
-		return BindResult(binder.FormatError(function, "Unnest() needs exactly one child expressions"));
-	}
-	BindChild(function.children[0], depth, error);
-	if (!error.empty()) {
-		// failed to bind
-		// try to bind correlated columns manually
-		if (!BindCorrelatedColumns(function.children[0])) {
-			return BindResult(error);
-		}
-		auto bound_expr = (BoundExpression *)function.children[0].get();
-		ExtractCorrelatedExpressions(binder, *bound_expr->expr);
-	}
-	auto &child = (BoundExpression &)*function.children[0];
-	auto &child_type = child.expr->return_type;
-
-	if (child_type.id() != LogicalTypeId::LIST && child_type.id() != LogicalTypeId::SQLNULL) {
-		return BindResult(binder.FormatError(function, "Unnest() can only be applied to lists and NULL"));
-	}
-
-	if (depth > 0) {
-		throw BinderException(binder.FormatError(function, "Unnest() for correlated expressions is not supported yet"));
-	}
-
-	auto return_type = LogicalType(LogicalTypeId::SQLNULL);
-	if (child_type.id() == LogicalTypeId::LIST) {
-		return_type = ListType::GetChildType(child_type);
-	}
-
-	auto result = make_unique<BoundUnnestExpression>(return_type);
-	result->child = move(child.expr);
-
-	auto unnest_index = node.unnests.size();
-	node.unnests.push_back(move(result));
-
-	// TODO what if we have multiple unnests in the same projection list? ignore for now
-
-	// now create a column reference referring to the unnest
-	auto colref = make_unique<BoundColumnRefExpression>(
-	    function.alias.empty() ? node.unnests[unnest_index]->ToString() : function.alias, return_type,
-	    ColumnBinding(node.unnest_index, unnest_index), depth);
-
-	return BindResult(move(colref));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static LogicalType ResolveWindowExpressionType(ExpressionType window_type, const vector<LogicalType> &child_types) {
-
-	idx_t param_count;
-	switch (window_type) {
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_RANK_DENSE:
-	case ExpressionType::WINDOW_ROW_NUMBER:
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_CUME_DIST:
-		param_count = 0;
-		break;
-	case ExpressionType::WINDOW_NTILE:
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_LAST_VALUE:
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-		param_count = 1;
-		break;
-	case ExpressionType::WINDOW_NTH_VALUE:
-		param_count = 2;
-		break;
-	default:
-		throw InternalException("Unrecognized window expression type " + ExpressionTypeToString(window_type));
-	}
-	if (child_types.size() != param_count) {
-		throw BinderException("%s needs %d parameter%s, got %d", ExpressionTypeToString(window_type), param_count,
-		                      param_count == 1 ? "" : "s", child_types.size());
-	}
-	switch (window_type) {
-	case ExpressionType::WINDOW_PERCENT_RANK:
-	case ExpressionType::WINDOW_CUME_DIST:
-		return LogicalType(LogicalTypeId::DOUBLE);
-	case ExpressionType::WINDOW_ROW_NUMBER:
-	case ExpressionType::WINDOW_RANK:
-	case ExpressionType::WINDOW_RANK_DENSE:
-	case ExpressionType::WINDOW_NTILE:
-		return LogicalType::BIGINT;
-	case ExpressionType::WINDOW_NTH_VALUE:
-	case ExpressionType::WINDOW_FIRST_VALUE:
-	case ExpressionType::WINDOW_LAST_VALUE:
-	case ExpressionType::WINDOW_LEAD:
-	case ExpressionType::WINDOW_LAG:
-		return child_types[0];
-	default:
-		throw InternalException("Unrecognized window expression type " + ExpressionTypeToString(window_type));
-	}
-}
-
-static inline OrderType ResolveOrderType(const DBConfig &config, OrderType type) {
-	return (type == OrderType::ORDER_DEFAULT) ? config.default_order_type : type;
-}
-
-static inline OrderByNullType ResolveNullOrder(const DBConfig &config, OrderByNullType null_order) {
-	return (null_order == OrderByNullType::ORDER_DEFAULT) ? config.default_null_order : null_order;
-}
-
-static unique_ptr<Expression> GetExpression(unique_ptr<ParsedExpression> &expr) {
-	if (!expr) {
-		return nullptr;
-	}
-	D_ASSERT(expr.get());
-	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	return move(((BoundExpression &)*expr).expr);
-}
-
-static unique_ptr<Expression> CastWindowExpression(unique_ptr<ParsedExpression> &expr, const LogicalType &type) {
-	if (!expr) {
-		return nullptr;
-	}
-	D_ASSERT(expr.get());
-	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-
-	auto &bound = (BoundExpression &)*expr;
-	bound.expr = BoundCastExpression::AddCastToType(move(bound.expr), type);
-
-	return move(bound.expr);
-}
-
-static LogicalType BindRangeExpression(ClientContext &context, const string &name, unique_ptr<ParsedExpression> &expr,
-                                       unique_ptr<ParsedExpression> &order_expr) {
-
-	vector<unique_ptr<Expression>> children;
-
-	D_ASSERT(order_expr.get());
-	D_ASSERT(order_expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound_order = (BoundExpression &)*order_expr;
-	children.emplace_back(bound_order.expr->Copy());
-
-	D_ASSERT(expr.get());
-	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = (BoundExpression &)*expr;
-	children.emplace_back(move(bound.expr));
-
-	string error;
-	auto function = ScalarFunction::BindScalarFunction(context, DEFAULT_SCHEMA, name, move(children), error, true);
-	if (!function) {
-		throw BinderException(error);
-	}
-	bound.expr = move(function);
-	return bound.expr->return_type;
-}
-
-BindResult SelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
-	auto name = window.GetName();
-
-	QueryErrorContext error_context(binder.root_statement, window.query_location);
-	if (inside_window) {
-		throw BinderException(error_context.FormatError("window function calls cannot be nested"));
-	}
-	if (depth > 0) {
-		throw BinderException(error_context.FormatError("correlated columns in window functions not supported"));
-	}
-	// If we have range expressions, then only one order by clause is allowed.
-	if ((window.start == WindowBoundary::EXPR_PRECEDING_RANGE || window.start == WindowBoundary::EXPR_FOLLOWING_RANGE ||
-	     window.end == WindowBoundary::EXPR_PRECEDING_RANGE || window.end == WindowBoundary::EXPR_FOLLOWING_RANGE) &&
-	    window.orders.size() != 1) {
-		throw BinderException(error_context.FormatError("RANGE frames must have only one ORDER BY expression"));
-	}
-	// bind inside the children of the window function
-	// we set the inside_window flag to true to prevent binding nested window functions
-	this->inside_window = true;
-	string error;
-	for (auto &child : window.children) {
-		BindChild(child, depth, error);
-	}
-	for (auto &child : window.partitions) {
-		BindChild(child, depth, error);
-	}
-	for (auto &order : window.orders) {
-		BindChild(order.expression, depth, error);
-	}
-	BindChild(window.filter_expr, depth, error);
-	BindChild(window.start_expr, depth, error);
-	BindChild(window.end_expr, depth, error);
-	BindChild(window.offset_expr, depth, error);
-	BindChild(window.default_expr, depth, error);
-
-	this->inside_window = false;
-	if (!error.empty()) {
-		// failed to bind children of window function
-		return BindResult(error);
-	}
-	// successfully bound all children: create bound window function
-	vector<LogicalType> types;
-	vector<unique_ptr<Expression>> children;
-	for (auto &child : window.children) {
-		D_ASSERT(child.get());
-		D_ASSERT(child->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &bound = (BoundExpression &)*child;
-		// Add casts for positional arguments
-		const auto argno = children.size();
-		switch (window.type) {
-		case ExpressionType::WINDOW_NTILE:
-			// ntile(bigint)
-			if (argno == 0) {
-				bound.expr = BoundCastExpression::AddCastToType(move(bound.expr), LogicalType::BIGINT);
-			}
-			break;
-		case ExpressionType::WINDOW_NTH_VALUE:
-			// nth_value(<expr>, index)
-			if (argno == 1) {
-				bound.expr = BoundCastExpression::AddCastToType(move(bound.expr), LogicalType::BIGINT);
-			}
-		default:
-			break;
-		}
-		types.push_back(bound.expr->return_type);
-		children.push_back(move(bound.expr));
-	}
-	//  Determine the function type.
-	LogicalType sql_type;
-	unique_ptr<AggregateFunction> aggregate;
-	unique_ptr<FunctionData> bind_info;
-	if (window.type == ExpressionType::WINDOW_AGGREGATE) {
-		//  Look up the aggregate function in the catalog
-		auto func =
-		    (AggregateFunctionCatalogEntry *)Catalog::GetCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(
-		        context, window.schema, window.function_name, false, error_context);
-		D_ASSERT(func->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
-
-		// bind the aggregate
-		string error;
-		auto best_function = Function::BindFunction(func->name, func->functions, types, error);
-		if (best_function == DConstants::INVALID_INDEX) {
-			throw BinderException(binder.FormatError(window, error));
-		}
-		// found a matching function! bind it as an aggregate
-		auto &bound_function = func->functions[best_function];
-		auto bound_aggregate = AggregateFunction::BindAggregateFunction(context, bound_function, move(children));
-		// create the aggregate
-		aggregate = make_unique<AggregateFunction>(bound_aggregate->function);
-		bind_info = move(bound_aggregate->bind_info);
-		children = move(bound_aggregate->children);
-		sql_type = bound_aggregate->return_type;
-	} else {
-		// fetch the child of the non-aggregate window function (if any)
-		sql_type = ResolveWindowExpressionType(window.type, types);
-	}
-	auto result = make_unique<BoundWindowExpression>(window.type, sql_type, move(aggregate), move(bind_info));
-	result->children = move(children);
-	for (auto &child : window.partitions) {
-		result->partitions.push_back(GetExpression(child));
-	}
-	result->ignore_nulls = window.ignore_nulls;
-
-	// Convert RANGE boundary expressions to ORDER +/- expressions.
-	// Note that PRECEEDING and FOLLOWING refer to the sequential order in the frame,
-	// not the natural ordering of the type. This means that the offset arithmetic must be reversed
-	// for ORDER BY DESC.
-	auto &config = DBConfig::GetConfig(context);
-	auto range_sense = OrderType::INVALID;
-	LogicalType start_type = LogicalType::BIGINT;
-	if (window.start == WindowBoundary::EXPR_PRECEDING_RANGE) {
-		D_ASSERT(window.orders.size() == 1);
-		range_sense = ResolveOrderType(config, window.orders[0].type);
-		const auto name = (range_sense == OrderType::ASCENDING) ? "-" : "+";
-		start_type = BindRangeExpression(context, name, window.start_expr, window.orders[0].expression);
-	} else if (window.start == WindowBoundary::EXPR_FOLLOWING_RANGE) {
-		D_ASSERT(window.orders.size() == 1);
-		range_sense = ResolveOrderType(config, window.orders[0].type);
-		const auto name = (range_sense == OrderType::ASCENDING) ? "+" : "-";
-		start_type = BindRangeExpression(context, name, window.start_expr, window.orders[0].expression);
-	}
-
-	LogicalType end_type = LogicalType::BIGINT;
-	if (window.end == WindowBoundary::EXPR_PRECEDING_RANGE) {
-		D_ASSERT(window.orders.size() == 1);
-		range_sense = ResolveOrderType(config, window.orders[0].type);
-		const auto name = (range_sense == OrderType::ASCENDING) ? "-" : "+";
-		end_type = BindRangeExpression(context, name, window.end_expr, window.orders[0].expression);
-	} else if (window.end == WindowBoundary::EXPR_FOLLOWING_RANGE) {
-		D_ASSERT(window.orders.size() == 1);
-		range_sense = ResolveOrderType(config, window.orders[0].type);
-		const auto name = (range_sense == OrderType::ASCENDING) ? "+" : "-";
-		end_type = BindRangeExpression(context, name, window.end_expr, window.orders[0].expression);
-	}
-
-	// Cast ORDER and boundary expressions to the same type
-	if (range_sense != OrderType::INVALID) {
-		D_ASSERT(window.orders.size() == 1);
-
-		auto &order_expr = window.orders[0].expression;
-		D_ASSERT(order_expr.get());
-		D_ASSERT(order_expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &bound_order = (BoundExpression &)*order_expr;
-		auto order_type = bound_order.expr->return_type;
-		if (window.start_expr) {
-			order_type = LogicalType::MaxLogicalType(order_type, start_type);
-		}
-		if (window.end_expr) {
-			order_type = LogicalType::MaxLogicalType(order_type, end_type);
-		}
-
-		// Cast all three to match
-		bound_order.expr = BoundCastExpression::AddCastToType(move(bound_order.expr), order_type);
-		start_type = end_type = order_type;
-	}
-
-	for (auto &order : window.orders) {
-		auto type = ResolveOrderType(config, order.type);
-		auto null_order = ResolveNullOrder(config, order.null_order);
-		auto expression = GetExpression(order.expression);
-		result->orders.emplace_back(type, null_order, move(expression));
-	}
-
-	result->filter_expr = CastWindowExpression(window.filter_expr, LogicalType::BOOLEAN);
-
-	result->start_expr = CastWindowExpression(window.start_expr, start_type);
-	result->end_expr = CastWindowExpression(window.end_expr, end_type);
-	result->offset_expr = CastWindowExpression(window.offset_expr, LogicalType::BIGINT);
-	result->default_expr = CastWindowExpression(window.default_expr, result->return_type);
-	result->start = window.start;
-	result->end = window.end;
-
-	// create a BoundColumnRef that references this entry
-	auto colref = make_unique<BoundColumnRefExpression>(move(name), result->return_type,
-	                                                    ColumnBinding(node.window_index, node.windows.size()), depth);
-	// move the WINDOW expression into the set of bound windows
-	node.windows.push_back(move(result));
-	return BindResult(move(colref));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BoundQueryNode> Binder::BindNode(RecursiveCTENode &statement) {
-	auto result = make_unique<BoundRecursiveCTENode>();
-
-	// first recursively visit the recursive CTE operations
-	// the left side is visited first and is added to the BindContext of the right side
-	D_ASSERT(statement.left);
-	D_ASSERT(statement.right);
-
-	result->ctename = statement.ctename;
-	result->union_all = statement.union_all;
-	result->setop_index = GenerateTableIndex();
-
-	result->left_binder = Binder::CreateBinder(context, this);
-	result->left = result->left_binder->BindNode(*statement.left);
-
-	// the result types of the CTE are the types of the LHS
-	result->types = result->left->types;
-	// names are picked from the LHS, unless aliases are explicitly specified
-	result->names = result->left->names;
-	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
-		result->names[i] = statement.aliases[i];
-	}
-
-	// This allows the right side to reference the CTE recursively
-	bind_context.AddGenericBinding(result->setop_index, statement.ctename, result->names, result->types);
-
-	result->right_binder = Binder::CreateBinder(context, this);
-
-	// Add bindings of left side to temporary CTE bindings context
-	result->right_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, result->names,
-	                                                 result->types);
-	result->right = result->right_binder->BindNode(*statement.right);
-
-	// move the correlated expressions from the child binders to this binder
-	MoveCorrelatedExpressions(*result->left_binder);
-	MoveCorrelatedExpressions(*result->right_binder);
-
-	// now both sides have been bound we can resolve types
-	if (result->left->types.size() != result->right->types.size()) {
-		throw BinderException("Set operations can only apply to expressions with the "
-		                      "same number of result columns");
-	}
-
-	if (!statement.modifiers.empty()) {
-		throw NotImplementedException("FIXME: bind modifiers in recursive CTE");
-	}
-
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr) {
-	// we treat the Distinct list as a order by
-	auto bound_expr = order_binder.Bind(move(expr));
-	if (!bound_expr) {
-		// DISTINCT ON non-integer constant
-		// remove the expression from the DISTINCT ON list
-		return nullptr;
-	}
-	D_ASSERT(bound_expr->type == ExpressionType::BOUND_COLUMN_REF);
-	return bound_expr;
-}
-
-unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, OrderBinder &order_binder,
-                                             unique_ptr<ParsedExpression> delimiter, const LogicalType &type,
-                                             Value &delimiter_value) {
-	auto new_binder = Binder::CreateBinder(context, this, true);
-	if (delimiter->HasSubquery()) {
-		return order_binder.CreateExtraReference(move(delimiter));
-	}
-	ExpressionBinder expr_binder(*new_binder, context);
-	expr_binder.target_type = type;
-	auto expr = expr_binder.Bind(delimiter);
-	if (expr->IsFoldable()) {
-		//! this is a constant
-		delimiter_value = ExpressionExecutor::EvaluateScalar(*expr).CastAs(type);
-		return nullptr;
-	}
-	return expr;
-}
-
-unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod) {
-	auto result = make_unique<BoundLimitModifier>();
-	if (limit_mod.limit) {
-		Value val;
-		result->limit = BindDelimiter(context, order_binder, move(limit_mod.limit), LogicalType::BIGINT, val);
-		if (!result->limit) {
-			result->limit_val = val.GetValue<int64_t>();
-			if (result->limit_val < 0) {
-				throw BinderException("LIMIT cannot be negative");
-			}
-		}
-	}
-	if (limit_mod.offset) {
-		Value val;
-		result->offset = BindDelimiter(context, order_binder, move(limit_mod.offset), LogicalType::BIGINT, val);
-		if (!result->offset) {
-			result->offset_val = val.GetValue<int64_t>();
-			if (result->offset_val < 0) {
-				throw BinderException("OFFSET cannot be negative");
-			}
-		}
-	}
-	return move(result);
-}
-
-unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod) {
-	auto result = make_unique<BoundLimitPercentModifier>();
-	if (limit_mod.limit) {
-		Value val;
-		result->limit = BindDelimiter(context, order_binder, move(limit_mod.limit), LogicalType::DOUBLE, val);
-		if (!result->limit) {
-			result->limit_percent = val.GetValue<double>();
-			if (result->limit_percent < 0.0) {
-				throw Exception("Limit percentage can't be negative value");
-			}
-		}
-	}
-	if (limit_mod.offset) {
-		Value val;
-		result->offset = BindDelimiter(context, order_binder, move(limit_mod.offset), LogicalType::BIGINT, val);
-		if (!result->offset) {
-			result->offset_val = val.GetValue<int64_t>();
-		}
-	}
-	return move(result);
-}
-
-void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result) {
-	for (auto &mod : statement.modifiers) {
-		unique_ptr<BoundResultModifier> bound_modifier;
-		switch (mod->type) {
-		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct = (DistinctModifier &)*mod;
-			auto bound_distinct = make_unique<BoundDistinctModifier>();
-			if (distinct.distinct_on_targets.empty()) {
-				for (idx_t i = 0; i < result.names.size(); i++) {
-					distinct.distinct_on_targets.push_back(make_unique<ConstantExpression>(Value::INTEGER(1 + i)));
-				}
-			}
-			for (auto &distinct_on_target : distinct.distinct_on_targets) {
-				auto expr = BindOrderExpression(order_binder, move(distinct_on_target));
-				if (!expr) {
-					continue;
-				}
-				bound_distinct->target_distincts.push_back(move(expr));
-			}
-			bound_modifier = move(bound_distinct);
-			break;
-		}
-		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order = (OrderModifier &)*mod;
-			auto bound_order = make_unique<BoundOrderModifier>();
-			auto &config = DBConfig::GetConfig(context);
-			D_ASSERT(!order.orders.empty());
-			if (order.orders[0].expression->type == ExpressionType::STAR) {
-				// ORDER BY ALL
-				// replace the order list with the maximum order by count
-				D_ASSERT(order.orders.size() == 1);
-				auto order_type = order.orders[0].type;
-				auto null_order = order.orders[0].null_order;
-
-				vector<OrderByNode> new_orders;
-				for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
-					new_orders.emplace_back(order_type, null_order,
-					                        make_unique<ConstantExpression>(Value::INTEGER(i + 1)));
-				}
-				order.orders = move(new_orders);
-			}
-			for (auto &order_node : order.orders) {
-				auto order_expression = BindOrderExpression(order_binder, move(order_node.expression));
-				if (!order_expression) {
-					continue;
-				}
-				auto type = order_node.type == OrderType::ORDER_DEFAULT ? config.default_order_type : order_node.type;
-				auto null_order = order_node.null_order == OrderByNullType::ORDER_DEFAULT ? config.default_null_order
-				                                                                          : order_node.null_order;
-				bound_order->orders.emplace_back(type, null_order, move(order_expression));
-			}
-			if (!bound_order->orders.empty()) {
-				bound_modifier = move(bound_order);
-			}
-			break;
-		}
-		case ResultModifierType::LIMIT_MODIFIER:
-			bound_modifier = BindLimit(order_binder, (LimitModifier &)*mod);
-			break;
-		case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-			bound_modifier = BindLimitPercent(order_binder, (LimitPercentModifier &)*mod);
-			break;
-		default:
-			throw Exception("Unsupported result modifier");
-		}
-		if (bound_modifier) {
-			result.modifiers.push_back(move(bound_modifier));
-		}
-	}
-}
-
-static void AssignReturnType(unique_ptr<Expression> &expr, const vector<LogicalType> &sql_types,
-                             idx_t projection_index) {
-	if (!expr) {
-		return;
-	}
-	if (expr->type != ExpressionType::BOUND_COLUMN_REF) {
-		return;
-	}
-	auto &bound_colref = (BoundColumnRefExpression &)*expr;
-	bound_colref.return_type = sql_types[bound_colref.binding.column_index];
-}
-
-void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType> &sql_types, idx_t projection_index) {
-	for (auto &bound_mod : result.modifiers) {
-		switch (bound_mod->type) {
-		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct = (BoundDistinctModifier &)*bound_mod;
-			if (distinct.target_distincts.empty()) {
-				// DISTINCT without a target: push references to the standard select list
-				for (idx_t i = 0; i < sql_types.size(); i++) {
-					distinct.target_distincts.push_back(
-					    make_unique<BoundColumnRefExpression>(sql_types[i], ColumnBinding(projection_index, i)));
-				}
-			} else {
-				// DISTINCT with target list: set types
-				for (auto &expr : distinct.target_distincts) {
-					D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
-					auto &bound_colref = (BoundColumnRefExpression &)*expr;
-					if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
-						throw BinderException("Ambiguous name in DISTINCT ON!");
-					}
-					D_ASSERT(bound_colref.binding.column_index < sql_types.size());
-					bound_colref.return_type = sql_types[bound_colref.binding.column_index];
-				}
-			}
-			for (auto &target_distinct : distinct.target_distincts) {
-				auto &bound_colref = (BoundColumnRefExpression &)*target_distinct;
-				auto sql_type = sql_types[bound_colref.binding.column_index];
-				if (sql_type.id() == LogicalTypeId::VARCHAR) {
-					target_distinct = ExpressionBinder::PushCollation(context, move(target_distinct),
-					                                                  StringType::GetCollation(sql_type), true);
-				}
-			}
-			break;
-		}
-		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &limit = (BoundLimitModifier &)*bound_mod;
-			AssignReturnType(limit.limit, sql_types, projection_index);
-			AssignReturnType(limit.offset, sql_types, projection_index);
-			break;
-		}
-		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &limit = (BoundLimitPercentModifier &)*bound_mod;
-			AssignReturnType(limit.limit, sql_types, projection_index);
-			AssignReturnType(limit.offset, sql_types, projection_index);
-			break;
-		}
-		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order = (BoundOrderModifier &)*bound_mod;
-			for (auto &order_node : order.orders) {
-				auto &expr = order_node.expression;
-				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
-				auto &bound_colref = (BoundColumnRefExpression &)*expr;
-				if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
-					throw BinderException("Ambiguous name in ORDER BY!");
-				}
-				D_ASSERT(bound_colref.binding.column_index < sql_types.size());
-				auto sql_type = sql_types[bound_colref.binding.column_index];
-				bound_colref.return_type = sql_types[bound_colref.binding.column_index];
-				if (sql_type.id() == LogicalTypeId::VARCHAR) {
-					order_node.expression = ExpressionBinder::PushCollation(context, move(order_node.expression),
-					                                                        StringType::GetCollation(sql_type));
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-}
-
-unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
-	auto result = make_unique<BoundSelectNode>();
-	result->projection_index = GenerateTableIndex();
-	result->group_index = GenerateTableIndex();
-	result->aggregate_index = GenerateTableIndex();
-	result->groupings_index = GenerateTableIndex();
-	result->window_index = GenerateTableIndex();
-	result->unnest_index = GenerateTableIndex();
-	result->prune_index = GenerateTableIndex();
-
-	// first bind the FROM table statement
-	result->from_table = Bind(*statement.from_table);
-
-	// bind the sample clause
-	if (statement.sample) {
-		result->sample_options = move(statement.sample);
-	}
-
-	// visit the select list and expand any "*" statements
-	vector<unique_ptr<ParsedExpression>> new_select_list;
-	for (auto &select_element : statement.select_list) {
-		if (select_element->GetExpressionType() == ExpressionType::STAR) {
-			// * statement, expand to all columns from the FROM clause
-			bind_context.GenerateAllColumnExpressions((StarExpression &)*select_element, new_select_list);
-		} else {
-			// regular statement, add it to the list
-			new_select_list.push_back(move(select_element));
-		}
-	}
-	if (new_select_list.empty()) {
-		throw BinderException("SELECT list is empty after resolving * expressions!");
-	}
-	statement.select_list = move(new_select_list);
-
-	// create a mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
-	case_insensitive_map_t<idx_t> alias_map;
-	expression_map_t<idx_t> projection_map;
-	for (idx_t i = 0; i < statement.select_list.size(); i++) {
-		auto &expr = statement.select_list[i];
-		result->names.push_back(expr->GetName());
-		ExpressionBinder::QualifyColumnNames(*this, expr);
-		if (!expr->alias.empty()) {
-			alias_map[expr->alias] = i;
-			result->names[i] = expr->alias;
-		}
-		projection_map[expr.get()] = i;
-		result->original_expressions.push_back(expr->Copy());
-	}
-	result->column_count = statement.select_list.size();
-
-	// first visit the WHERE clause
-	// the WHERE clause happens before the GROUP BY, PROJECTION or HAVING clauses
-	if (statement.where_clause) {
-		ColumnAliasBinder alias_binder(*result, alias_map);
-		WhereBinder where_binder(*this, context, &alias_binder);
-		unique_ptr<ParsedExpression> condition = move(statement.where_clause);
-		result->where_clause = where_binder.Bind(condition);
-	}
-
-	// now bind all the result modifiers; including DISTINCT and ORDER BY targets
-	OrderBinder order_binder({this}, result->projection_index, statement, alias_map, projection_map);
-	BindModifiers(order_binder, statement, *result);
-
-	vector<unique_ptr<ParsedExpression>> unbound_groups;
-	BoundGroupInformation info;
-	auto &group_expressions = statement.groups.group_expressions;
-	if (!group_expressions.empty()) {
-		// the statement has a GROUP BY clause, bind it
-		unbound_groups.resize(group_expressions.size());
-		GroupBinder group_binder(*this, context, statement, result->group_index, alias_map, info.alias_map);
-		for (idx_t i = 0; i < group_expressions.size(); i++) {
-
-			// we keep a copy of the unbound expression;
-			// we keep the unbound copy around to check for group references in the SELECT and HAVING clause
-			// the reason we want the unbound copy is because we want to figure out whether an expression
-			// is a group reference BEFORE binding in the SELECT/HAVING binder
-			group_binder.unbound_expression = group_expressions[i]->Copy();
-			group_binder.bind_index = i;
-
-			// bind the groups
-			LogicalType group_type;
-			auto bound_expr = group_binder.Bind(group_expressions[i], &group_type);
-			D_ASSERT(bound_expr->return_type.id() != LogicalTypeId::INVALID);
-
-			// push a potential collation, if necessary
-			bound_expr =
-			    ExpressionBinder::PushCollation(context, move(bound_expr), StringType::GetCollation(group_type), true);
-			result->groups.group_expressions.push_back(move(bound_expr));
-
-			// in the unbound expression we DO bind the table names of any ColumnRefs
-			// we do this to make sure that "table.a" and "a" are treated the same
-			// if we wouldn't do this then (SELECT test.a FROM test GROUP BY a) would not work because "test.a" <> "a"
-			// hence we convert "a" -> "test.a" in the unbound expression
-			unbound_groups[i] = move(group_binder.unbound_expression);
-			ExpressionBinder::QualifyColumnNames(*this, unbound_groups[i]);
-			info.map[unbound_groups[i].get()] = i;
-		}
-	}
-	result->groups.grouping_sets = move(statement.groups.grouping_sets);
-
-	// bind the HAVING clause, if any
-	if (statement.having) {
-		HavingBinder having_binder(*this, context, *result, info, alias_map);
-		ExpressionBinder::QualifyColumnNames(*this, statement.having);
-		result->having = having_binder.Bind(statement.having);
-	}
-
-	// bind the QUALIFY clause, if any
-	if (statement.qualify) {
-		QualifyBinder qualify_binder(*this, context, *result, info, alias_map);
-		ExpressionBinder::QualifyColumnNames(*this, statement.qualify);
-		result->qualify = qualify_binder.Bind(statement.qualify);
-	}
-
-	// after that, we bind to the SELECT list
-	SelectBinder select_binder(*this, context, *result, info);
-	vector<LogicalType> internal_sql_types;
-	for (idx_t i = 0; i < statement.select_list.size(); i++) {
-		LogicalType result_type;
-		auto expr = select_binder.Bind(statement.select_list[i], &result_type);
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && select_binder.HasBoundColumns()) {
-			if (select_binder.BoundAggregates()) {
-				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
-			}
-			// we are forcing aggregates, and the node has columns bound
-			// this entry becomes a group
-			auto group_ref = make_unique<BoundColumnRefExpression>(
-			    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
-			result->groups.group_expressions.push_back(move(expr));
-			expr = move(group_ref);
-		}
-		result->select_list.push_back(move(expr));
-		if (i < result->column_count) {
-			result->types.push_back(result_type);
-		}
-		internal_sql_types.push_back(result_type);
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
-			select_binder.ResetBindings();
-		}
-	}
-	result->need_prune = result->select_list.size() > result->column_count;
-
-	// in the normal select binder, we bind columns as if there is no aggregation
-	// i.e. in the query [SELECT i, SUM(i) FROM integers;] the "i" will be bound as a normal column
-	// since we have an aggregation, we need to either (1) throw an error, or (2) wrap the column in a FIRST() aggregate
-	// we choose the former one [CONTROVERSIAL: this is the PostgreSQL behavior]
-	if (!result->groups.group_expressions.empty() || !result->aggregates.empty() || statement.having ||
-	    !result->groups.grouping_sets.empty()) {
-		if (statement.aggregate_handling == AggregateHandling::NO_AGGREGATES_ALLOWED) {
-			throw BinderException("Aggregates cannot be present in a Project relation!");
-		} else if (statement.aggregate_handling == AggregateHandling::STANDARD_HANDLING) {
-			if (select_binder.HasBoundColumns()) {
-				auto &bound_columns = select_binder.GetBoundColumns();
-				throw BinderException(
-				    FormatError(bound_columns[0].query_location,
-				                "column \"%s\" must appear in the GROUP BY clause or be used in an aggregate function",
-				                bound_columns[0].name));
-			}
-		}
-	}
-
-	// QUALIFY clause requires at least one window function to be specified in at least one of the SELECT column list or
-	// the filter predicate of the QUALIFY clause
-	if (statement.qualify && result->windows.empty()) {
-		throw BinderException("at least one window function must appear in the SELECT column or QUALIFY clause");
-	}
-
-	// now that the SELECT list is bound, we set the types of DISTINCT/ORDER BY expressions
-	BindModifierTypes(*result, internal_sql_types, result->projection_index);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &aliases,
-                          expression_map_t<idx_t> &expressions) {
-	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
-		// setop, recurse
-		auto &setop = (BoundSetOperationNode &)node;
-		GatherAliases(*setop.left, aliases, expressions);
-		GatherAliases(*setop.right, aliases, expressions);
-	} else {
-		// query node
-		D_ASSERT(node.type == QueryNodeType::SELECT_NODE);
-		auto &select = (BoundSelectNode &)node;
-		// fill the alias lists
-		for (idx_t i = 0; i < select.names.size(); i++) {
-			auto &name = select.names[i];
-			auto &expr = select.original_expressions[i];
-			// first check if the alias is already in there
-			auto entry = aliases.find(name);
-			if (entry != aliases.end()) {
-				// the alias already exists
-				// check if there is a conflict
-				if (entry->second != i) {
-					// there is a conflict
-					// we place "-1" in the aliases map at this location
-					// "-1" signifies that there is an ambiguous reference
-					aliases[name] = DConstants::INVALID_INDEX;
-				}
-			} else {
-				// the alias is not in there yet, just assign it
-				aliases[name] = i;
-			}
-			// now check if the node is already in the set of expressions
-			auto expr_entry = expressions.find(expr.get());
-			if (expr_entry != expressions.end()) {
-				// the node is in there
-				// repeat the same as with the alias: if there is an ambiguity we insert "-1"
-				if (expr_entry->second != i) {
-					expressions[expr.get()] = DConstants::INVALID_INDEX;
-				}
-			} else {
-				// not in there yet, just place it in there
-				expressions[expr.get()] = i;
-			}
-		}
-	}
-}
-
-unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
-	auto result = make_unique<BoundSetOperationNode>();
-	result->setop_type = statement.setop_type;
-
-	// first recursively visit the set operations
-	// both the left and right sides have an independent BindContext and Binder
-	D_ASSERT(statement.left);
-	D_ASSERT(statement.right);
-
-	result->setop_index = GenerateTableIndex();
-
-	result->left_binder = Binder::CreateBinder(context, this);
-	result->left_binder->can_contain_nulls = true;
-	result->left = result->left_binder->BindNode(*statement.left);
-
-	result->right_binder = Binder::CreateBinder(context, this);
-	result->right_binder->can_contain_nulls = true;
-	result->right = result->right_binder->BindNode(*statement.right);
-
-	if (!statement.modifiers.empty()) {
-		// handle the ORDER BY/DISTINCT clauses
-
-		// we recursively visit the children of this node to extract aliases and expressions that can be referenced in
-		// the ORDER BY
-		case_insensitive_map_t<idx_t> alias_map;
-		expression_map_t<idx_t> expression_map;
-		GatherAliases(*result, alias_map, expression_map);
-
-		// now we perform the actual resolution of the ORDER BY/DISTINCT expressions
-		OrderBinder order_binder({result->left_binder.get(), result->right_binder.get()}, result->setop_index,
-		                         alias_map, expression_map, statement.left->GetSelectList().size());
-		BindModifiers(order_binder, statement, *result);
-	}
-
-	result->names = result->left->names;
-
-	// move the correlated expressions from the child binders to this binder
-	MoveCorrelatedExpressions(*result->left_binder);
-	MoveCorrelatedExpressions(*result->right_binder);
-
-	// now both sides have been bound we can resolve types
-	if (result->left->types.size() != result->right->types.size()) {
-		throw BinderException("Set operations can only apply to expressions with the "
-		                      "same number of result columns");
-	}
-
-	// figure out the types of the setop result by picking the max of both
-	for (idx_t i = 0; i < result->left->types.size(); i++) {
-		auto result_type = LogicalType::MaxLogicalType(result->left->types[i], result->right->types[i]);
-		if (!can_contain_nulls) {
-			if (ExpressionBinder::ContainsNullType(result_type)) {
-				result_type = ExpressionBinder::ExchangeNullType(result_type);
-			}
-		}
-		result->types.push_back(result_type);
-	}
-
-	// finally bind the types of the ORDER/DISTINCT clause expressions
-	BindModifierTypes(*result, result->types, result->setop_index);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func,
-                                             idx_t depth) {
-
-	auto &macro_def = (TableMacroFunction &)*macro_func->function;
-	auto node = macro_def.query_node->Copy();
-
-	// auto &macro_def = *macro_func->function;
-
-	// validate the arguments and separate positional and default arguments
-	vector<unique_ptr<ParsedExpression>> positionals;
-	unordered_map<string, unique_ptr<ParsedExpression>> defaults;
-	string error =
-	    MacroFunction::ValidateArguments(*macro_func->function, macro_func->name, function, positionals, defaults);
-	if (!error.empty()) {
-		// cannot use error below as binder rnot in scope
-		// return BindResult(binder. FormatError(*expr->get(), error));
-		throw BinderException(FormatError(function, error));
-	}
-
-	// create a MacroBinding to bind this macro's parameters to its arguments
-	vector<LogicalType> types;
-	vector<string> names;
-	// positional parameters
-	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
-		types.emplace_back(LogicalType::SQLNULL);
-		auto &param = (ColumnRefExpression &)*macro_def.parameters[i];
-		names.push_back(param.GetColumnName());
-	}
-	// default parameters
-	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		types.emplace_back(LogicalType::SQLNULL);
-		names.push_back(it->first);
-		// now push the defaults into the positionals
-		positionals.push_back(move(defaults[it->first]));
-	}
-	auto new_macro_binding = make_unique<MacroBinding>(types, names, macro_func->name);
-	new_macro_binding->arguments = move(positionals);
-
-	// We need an EXpressionBinder So that we can call ExpressionBinder::ReplaceMacroParametersRecursive()
-	auto eb = ExpressionBinder(*this, this->context);
-
-	eb.macro_binding = new_macro_binding.get();
-
-	/* Does it all goes throu every expression in a selectstmt  */
-	ParsedExpressionIterator::EnumerateQueryNodeChildren(
-	    *node, [&](unique_ptr<ParsedExpression> &child) { eb.ReplaceMacroParametersRecursive(child); });
-
-	return node;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_ptr<LogicalOperator> root) {
-	D_ASSERT(root);
-	for (auto &mod : node.modifiers) {
-		switch (mod->type) {
-		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &bound = (BoundDistinctModifier &)*mod;
-			auto distinct = make_unique<LogicalDistinct>(move(bound.target_distincts));
-			distinct->AddChild(move(root));
-			root = move(distinct);
-			break;
-		}
-		case ResultModifierType::ORDER_MODIFIER: {
-			auto &bound = (BoundOrderModifier &)*mod;
-			auto order = make_unique<LogicalOrder>(move(bound.orders));
-			order->AddChild(move(root));
-			root = move(order);
-			break;
-		}
-		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &bound = (BoundLimitModifier &)*mod;
-			auto limit =
-			    make_unique<LogicalLimit>(bound.limit_val, bound.offset_val, move(bound.limit), move(bound.offset));
-			limit->AddChild(move(root));
-			root = move(limit);
-			break;
-		}
-		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &bound = (BoundLimitPercentModifier &)*mod;
-			auto limit = make_unique<LogicalLimitPercent>(bound.limit_percent, bound.offset_val, move(bound.limit),
-			                                              move(bound.offset));
-			limit->AddChild(move(root));
-			root = move(limit);
-			break;
-		}
-		default:
-			throw BinderException("Unimplemented modifier type!");
-		}
-	}
-	return root;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
-	// Generate the logical plan for the left and right sides of the set operation
-	node.left_binder->plan_subquery = plan_subquery;
-	node.right_binder->plan_subquery = plan_subquery;
-
-	auto left_node = node.left_binder->CreatePlan(*node.left);
-	auto right_node = node.right_binder->CreatePlan(*node.right);
-
-	// check if there are any unplanned subqueries left in either child
-	has_unplanned_subqueries =
-	    node.left_binder->has_unplanned_subqueries || node.right_binder->has_unplanned_subqueries;
-
-	// for both the left and right sides, cast them to the same types
-	left_node = CastLogicalOperatorToTypes(node.left->types, node.types, move(left_node));
-	right_node = CastLogicalOperatorToTypes(node.right->types, node.types, move(right_node));
-
-	if (!node.right_binder->bind_context.cte_references[node.ctename] ||
-	    *node.right_binder->bind_context.cte_references[node.ctename] == 0) {
-		auto root = make_unique<LogicalSetOperation>(node.setop_index, node.types.size(), move(left_node),
-		                                             move(right_node), LogicalOperatorType::LOGICAL_UNION);
-		return VisitQueryNode(node, move(root));
-	}
-	auto root = make_unique<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all, move(left_node),
-	                                             move(right_node), LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
-
-	return VisitQueryNode(node, move(root));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root) {
-	PlanSubqueries(&condition, &root);
-	auto filter = make_unique<LogicalFilter>(move(condition));
-	filter->AddChild(move(root));
-	return move(filter);
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
-	unique_ptr<LogicalOperator> root;
-	D_ASSERT(statement.from_table);
-	root = CreatePlan(*statement.from_table);
-	D_ASSERT(root);
-
-	// plan the sample clause
-	if (statement.sample_options) {
-		root = make_unique<LogicalSample>(move(statement.sample_options), move(root));
-	}
-
-	if (statement.where_clause) {
-		root = PlanFilter(move(statement.where_clause), move(root));
-	}
-
-	if (!statement.aggregates.empty() || !statement.groups.group_expressions.empty()) {
-		if (!statement.groups.group_expressions.empty()) {
-			// visit the groups
-			for (auto &group : statement.groups.group_expressions) {
-				PlanSubqueries(&group, &root);
-			}
-		}
-		// now visit all aggregate expressions
-		for (auto &expr : statement.aggregates) {
-			PlanSubqueries(&expr, &root);
-		}
-		// finally create the aggregate node with the group_index and aggregate_index as obtained from the binder
-		auto aggregate =
-		    make_unique<LogicalAggregate>(statement.group_index, statement.aggregate_index, move(statement.aggregates));
-		aggregate->groups = move(statement.groups.group_expressions);
-		aggregate->groupings_index = statement.groupings_index;
-		aggregate->grouping_sets = move(statement.groups.grouping_sets);
-		aggregate->grouping_functions = move(statement.grouping_functions);
-
-		aggregate->AddChild(move(root));
-		root = move(aggregate);
-	} else if (!statement.groups.grouping_sets.empty()) {
-		// edge case: we have grouping sets but no groups or aggregates
-		// this can only happen if we have e.g. select 1 from tbl group by ();
-		// just output a dummy scan
-		root = make_unique_base<LogicalOperator, LogicalDummyScan>(statement.group_index);
-	}
-
-	if (statement.having) {
-		PlanSubqueries(&statement.having, &root);
-		auto having = make_unique<LogicalFilter>(move(statement.having));
-
-		having->AddChild(move(root));
-		root = move(having);
-	}
-
-	if (!statement.windows.empty()) {
-		auto win = make_unique<LogicalWindow>(statement.window_index);
-		win->expressions = move(statement.windows);
-		// visit the window expressions
-		for (auto &expr : win->expressions) {
-			PlanSubqueries(&expr, &root);
-		}
-		D_ASSERT(!win->expressions.empty());
-		win->AddChild(move(root));
-		root = move(win);
-	}
-
-	if (statement.qualify) {
-		PlanSubqueries(&statement.qualify, &root);
-		auto qualify = make_unique<LogicalFilter>(move(statement.qualify));
-
-		qualify->AddChild(move(root));
-		root = move(qualify);
-	}
-
-	if (!statement.unnests.empty()) {
-		auto unnest = make_unique<LogicalUnnest>(statement.unnest_index);
-		unnest->expressions = move(statement.unnests);
-		// visit the unnest expressions
-		for (auto &expr : unnest->expressions) {
-			PlanSubqueries(&expr, &root);
-		}
-		D_ASSERT(!unnest->expressions.empty());
-		unnest->AddChild(move(root));
-		root = move(unnest);
-	}
-
-	for (auto &expr : statement.select_list) {
-		PlanSubqueries(&expr, &root);
-	}
-
-	// create the projection
-	auto proj = make_unique<LogicalProjection>(statement.projection_index, move(statement.select_list));
-	auto &projection = *proj;
-	proj->AddChild(move(root));
-	root = move(proj);
-
-	// finish the plan by handling the elements of the QueryNode
-	root = VisitQueryNode(statement, move(root));
-
-	// add a prune node if necessary
-	if (statement.need_prune) {
-		D_ASSERT(root);
-		vector<unique_ptr<Expression>> prune_expressions;
-		for (idx_t i = 0; i < statement.column_count; i++) {
-			prune_expressions.push_back(make_unique<BoundColumnRefExpression>(
-			    projection.expressions[i]->return_type, ColumnBinding(statement.projection_index, i)));
-		}
-		auto prune = make_unique<LogicalProjection>(statement.prune_index, move(prune_expressions));
-		prune->AddChild(move(root));
-		root = move(prune);
-	}
-	return root;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalType> &source_types,
-                                                               vector<LogicalType> &target_types,
-                                                               unique_ptr<LogicalOperator> op) {
-	D_ASSERT(op);
-	// first check if we even need to cast
-	D_ASSERT(source_types.size() == target_types.size());
-	if (source_types == target_types) {
-		// source and target types are equal: don't need to cast
-		return op;
-	}
-	// otherwise add casts
-	auto node = op.get();
-	if (node->type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		// "node" is a projection; we can just do the casts in there
-		D_ASSERT(node->expressions.size() == source_types.size());
-		// add the casts to the selection list
-		for (idx_t i = 0; i < target_types.size(); i++) {
-			if (source_types[i] != target_types[i]) {
-				// differing types, have to add a cast
-				string alias = node->expressions[i]->alias;
-				node->expressions[i] = make_unique<BoundCastExpression>(move(node->expressions[i]), target_types[i]);
-				node->expressions[i]->alias = alias;
-			}
-		}
-		return op;
-	} else {
-		// found a non-projection operator
-		// push a new projection containing the casts
-
-		// fetch the set of column bindings
-		auto setop_columns = op->GetColumnBindings();
-		D_ASSERT(setop_columns.size() == source_types.size());
-
-		// now generate the expression list
-		vector<unique_ptr<Expression>> select_list;
-		for (idx_t i = 0; i < target_types.size(); i++) {
-			unique_ptr<Expression> result = make_unique<BoundColumnRefExpression>(source_types[i], setop_columns[i]);
-			if (source_types[i] != target_types[i]) {
-				// add a cast only if the source and target types are not equivalent
-				result = make_unique<BoundCastExpression>(move(result), target_types[i]);
-			}
-			select_list.push_back(move(result));
-		}
-		auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(select_list));
-		projection->children.push_back(move(op));
-		return move(projection);
-	}
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
-	// Generate the logical plan for the left and right sides of the set operation
-	node.left_binder->plan_subquery = plan_subquery;
-	node.right_binder->plan_subquery = plan_subquery;
-
-	auto left_node = node.left_binder->CreatePlan(*node.left);
-	auto right_node = node.right_binder->CreatePlan(*node.right);
-
-	// check if there are any unplanned subqueries left in either child
-	has_unplanned_subqueries =
-	    node.left_binder->has_unplanned_subqueries || node.right_binder->has_unplanned_subqueries;
-
-	// for both the left and right sides, cast them to the same types
-	left_node = CastLogicalOperatorToTypes(node.left->types, node.types, move(left_node));
-	right_node = CastLogicalOperatorToTypes(node.right->types, node.types, move(right_node));
-
-	// create actual logical ops for setops
-	LogicalOperatorType logical_type;
-	switch (node.setop_type) {
-	case SetOperationType::UNION:
-		logical_type = LogicalOperatorType::LOGICAL_UNION;
-		break;
-	case SetOperationType::EXCEPT:
-		logical_type = LogicalOperatorType::LOGICAL_EXCEPT;
-		break;
-	default:
-		D_ASSERT(node.setop_type == SetOperationType::INTERSECT);
-		logical_type = LogicalOperatorType::LOGICAL_INTERSECT;
-		break;
-	}
-	auto root = make_unique<LogicalSetOperation>(node.setop_index, node.types.size(), move(left_node), move(right_node),
-	                                             logical_type);
-
-	return VisitQueryNode(node, move(root));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubqueryExpression &expr,
-                                                       unique_ptr<LogicalOperator> &root,
-                                                       unique_ptr<LogicalOperator> plan) {
-	D_ASSERT(!expr.IsCorrelated());
-	switch (expr.subquery_type) {
-	case SubqueryType::EXISTS: {
-		// uncorrelated EXISTS
-		// we only care about existence, hence we push a LIMIT 1 operator
-		auto limit = make_unique<LogicalLimit>(1, 0, nullptr, nullptr);
-		limit->AddChild(move(plan));
-		plan = move(limit);
-
-		// now we push a COUNT(*) aggregate onto the limit, this will be either 0 or 1 (EXISTS or NOT EXISTS)
-		auto count_star_fun = CountStarFun::GetFunction();
-		auto count_star = AggregateFunction::BindAggregateFunction(binder.context, count_star_fun, {}, nullptr, false);
-		auto idx_type = count_star->return_type;
-		vector<unique_ptr<Expression>> aggregate_list;
-		aggregate_list.push_back(move(count_star));
-		auto aggregate_index = binder.GenerateTableIndex();
-		auto aggregate =
-		    make_unique<LogicalAggregate>(binder.GenerateTableIndex(), aggregate_index, move(aggregate_list));
-		aggregate->AddChild(move(plan));
-		plan = move(aggregate);
-
-		// now we push a projection with a comparison to 1
-		auto left_child = make_unique<BoundColumnRefExpression>(idx_type, ColumnBinding(aggregate_index, 0));
-		auto right_child = make_unique<BoundConstantExpression>(Value::Numeric(idx_type, 1));
-		auto comparison =
-		    make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL, move(left_child), move(right_child));
-
-		vector<unique_ptr<Expression>> projection_list;
-		projection_list.push_back(move(comparison));
-		auto projection_index = binder.GenerateTableIndex();
-		auto projection = make_unique<LogicalProjection>(projection_index, move(projection_list));
-		projection->AddChild(move(plan));
-		plan = move(projection);
-
-		// we add it to the main query by adding a cross product
-		// FIXME: should use something else besides cross product as we always add only one scalar constant
-		auto cross_product = make_unique<LogicalCrossProduct>();
-		cross_product->AddChild(move(root));
-		cross_product->AddChild(move(plan));
-		root = move(cross_product);
-
-		// we replace the original subquery with a ColumnRefExpression referring to the result of the projection (either
-		// TRUE or FALSE)
-		return make_unique<BoundColumnRefExpression>(expr.GetName(), LogicalType::BOOLEAN,
-		                                             ColumnBinding(projection_index, 0));
-	}
-	case SubqueryType::SCALAR: {
-		// uncorrelated scalar, we want to return the first entry
-		// figure out the table index of the bound table of the entry which we want to return
-		auto bindings = plan->GetColumnBindings();
-		D_ASSERT(bindings.size() == 1);
-		idx_t table_idx = bindings[0].table_index;
-
-		// in the uncorrelated case we are only interested in the first result of the query
-		// hence we simply push a LIMIT 1 to get the first row of the subquery
-		auto limit = make_unique<LogicalLimit>(1, 0, nullptr, nullptr);
-		limit->AddChild(move(plan));
-		plan = move(limit);
-
-		// we push an aggregate that returns the FIRST element
-		vector<unique_ptr<Expression>> expressions;
-		auto bound = make_unique<BoundColumnRefExpression>(expr.return_type, ColumnBinding(table_idx, 0));
-		vector<unique_ptr<Expression>> first_children;
-		first_children.push_back(move(bound));
-		auto first_agg = AggregateFunction::BindAggregateFunction(
-		    binder.context, FirstFun::GetFunction(expr.return_type), move(first_children), nullptr, false);
-
-		expressions.push_back(move(first_agg));
-		auto aggr_index = binder.GenerateTableIndex();
-		auto aggr = make_unique<LogicalAggregate>(binder.GenerateTableIndex(), aggr_index, move(expressions));
-		aggr->AddChild(move(plan));
-		plan = move(aggr);
-
-		// in the uncorrelated case, we add the value to the main query through a cross product
-		// FIXME: should use something else besides cross product as we always add only one scalar constant and cross
-		// product is not optimized for this.
-		D_ASSERT(root);
-		auto cross_product = make_unique<LogicalCrossProduct>();
-		cross_product->AddChild(move(root));
-		cross_product->AddChild(move(plan));
-		root = move(cross_product);
-
-		// we replace the original subquery with a BoundColumnRefExpression referring to the first result of the
-		// aggregation
-		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(aggr_index, 0));
-	}
-	default: {
-		D_ASSERT(expr.subquery_type == SubqueryType::ANY);
-		// we generate a MARK join that results in either (TRUE, FALSE or NULL)
-		// subquery has NULL values -> result is (TRUE or NULL)
-		// subquery has no NULL values -> result is (TRUE, FALSE or NULL [if input is NULL])
-		// fetch the column bindings
-		auto plan_columns = plan->GetColumnBindings();
-
-		// then we generate the MARK join with the subquery
-		idx_t mark_index = binder.GenerateTableIndex();
-		auto join = make_unique<LogicalComparisonJoin>(JoinType::MARK);
-		join->mark_index = mark_index;
-		join->AddChild(move(root));
-		join->AddChild(move(plan));
-		// create the JOIN condition
-		JoinCondition cond;
-		cond.left = move(expr.child);
-		cond.right = BoundCastExpression::AddCastToType(
-		    make_unique<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
-		cond.comparison = expr.comparison_type;
-		join->conditions.push_back(move(cond));
-		root = move(join);
-
-		// we replace the original subquery with a BoundColumnRefExpression referring to the mark column
-		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
-	}
-	}
-}
-
-static unique_ptr<LogicalDelimJoin> CreateDuplicateEliminatedJoin(vector<CorrelatedColumnInfo> &correlated_columns,
-                                                                  JoinType join_type,
-                                                                  unique_ptr<LogicalOperator> original_plan,
-                                                                  bool perform_delim) {
-	auto delim_join = make_unique<LogicalDelimJoin>(join_type);
-	if (!perform_delim) {
-		// if we are not performing a delim join, we push a row_number() OVER() window operator on the LHS
-		// and perform all duplicate elimination on that row number instead
-		D_ASSERT(correlated_columns[0].type.id() == LogicalTypeId::BIGINT);
-		auto window = make_unique<LogicalWindow>(correlated_columns[0].binding.table_index);
-		auto row_number = make_unique<BoundWindowExpression>(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT,
-		                                                     nullptr, nullptr);
-		row_number->start = WindowBoundary::UNBOUNDED_PRECEDING;
-		row_number->end = WindowBoundary::CURRENT_ROW_ROWS;
-		row_number->alias = "delim_index";
-		window->expressions.push_back(move(row_number));
-		window->AddChild(move(original_plan));
-		original_plan = move(window);
-	}
-	delim_join->AddChild(move(original_plan));
-	for (idx_t i = 0; i < correlated_columns.size(); i++) {
-		auto &col = correlated_columns[i];
-		delim_join->duplicate_eliminated_columns.push_back(
-		    make_unique<BoundColumnRefExpression>(col.type, col.binding));
-		delim_join->delim_types.push_back(col.type);
-	}
-	return delim_join;
-}
-
-static void CreateDelimJoinConditions(LogicalDelimJoin &delim_join, vector<CorrelatedColumnInfo> &correlated_columns,
-                                      vector<ColumnBinding> bindings, idx_t base_offset, bool perform_delim) {
-	auto col_count = perform_delim ? correlated_columns.size() : 1;
-	for (idx_t i = 0; i < col_count; i++) {
-		auto &col = correlated_columns[i];
-		JoinCondition cond;
-		cond.left = make_unique<BoundColumnRefExpression>(col.name, col.type, col.binding);
-		cond.right = make_unique<BoundColumnRefExpression>(col.name, col.type, bindings[base_offset + i]);
-		cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-		delim_join.conditions.push_back(move(cond));
-	}
-}
-
-static bool PerformDelimOnType(const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::LIST) {
-		return false;
-	}
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		for (auto &entry : StructType::GetChildTypes(type)) {
-			if (!PerformDelimOnType(entry.second)) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-static bool PerformDuplicateElimination(Binder &binder, vector<CorrelatedColumnInfo> &correlated_columns) {
-	if (!ClientConfig::GetConfig(binder.context).enable_optimizer) {
-		// if optimizations are disabled we always do a delim join
-		return true;
-	}
-	bool perform_delim = true;
-	for (auto &col : correlated_columns) {
-		if (!PerformDelimOnType(col.type)) {
-			perform_delim = false;
-			break;
-		}
-	}
-	if (perform_delim) {
-		return true;
-	}
-	auto binding = ColumnBinding(binder.GenerateTableIndex(), 0);
-	auto type = LogicalType::BIGINT;
-	auto name = "delim_index";
-	CorrelatedColumnInfo info(binding, type, name, 0);
-	correlated_columns.insert(correlated_columns.begin(), move(info));
-	return false;
-}
-
-static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubqueryExpression &expr,
-                                                     unique_ptr<LogicalOperator> &root,
-                                                     unique_ptr<LogicalOperator> plan) {
-	auto &correlated_columns = expr.binder->correlated_columns;
-	// FIXME: there should be a way of disabling decorrelation for ANY queries as well, but not for now...
-	bool perform_delim =
-	    expr.subquery_type == SubqueryType::ANY ? true : PerformDuplicateElimination(binder, correlated_columns);
-	D_ASSERT(expr.IsCorrelated());
-	// correlated subquery
-	// for a more in-depth explanation of this code, read the paper "Unnesting Arbitrary Subqueries"
-	// we handle three types of correlated subqueries: Scalar, EXISTS and ANY
-	// all three cases are very similar with some minor changes (mainly the type of join performed at the end)
-	switch (expr.subquery_type) {
-	case SubqueryType::SCALAR: {
-		// correlated SCALAR query
-		// first push a DUPLICATE ELIMINATED join
-		// a duplicate eliminated join creates a duplicate eliminated copy of the LHS
-		// and pushes it into any DUPLICATE_ELIMINATED SCAN operators on the RHS
-
-		// in the SCALAR case, we create a SINGLE join (because we are only interested in obtaining the value)
-		// NULL values are equal in this join because we join on the correlated columns ONLY
-		// and e.g. in the query: SELECT (SELECT 42 FROM integers WHERE i1.i IS NULL LIMIT 1) FROM integers i1;
-		// the input value NULL will generate the value 42, and we need to join NULL on the LHS with NULL on the RHS
-		// the left side is the original plan
-		// this is the side that will be duplicate eliminated and pushed into the RHS
-		auto delim_join =
-		    CreateDuplicateEliminatedJoin(correlated_columns, JoinType::SINGLE, move(root), perform_delim);
-
-		// the right side initially is a DEPENDENT join between the duplicate eliminated scan and the subquery
-		// HOWEVER: we do not explicitly create the dependent join
-		// instead, we eliminate the dependent join by pushing it down into the right side of the plan
-		FlattenDependentJoins flatten(binder, correlated_columns, perform_delim);
-
-		// first we check which logical operators have correlated expressions in the first place
-		flatten.DetectCorrelatedExpressions(plan.get());
-		// now we push the dependent join down
-		auto dependent_join = flatten.PushDownDependentJoin(move(plan));
-
-		// now the dependent join is fully eliminated
-		// we only need to create the join conditions between the LHS and the RHS
-		// fetch the set of columns
-		auto plan_columns = dependent_join->GetColumnBindings();
-
-		// now create the join conditions
-		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-		delim_join->AddChild(move(dependent_join));
-		root = move(delim_join);
-		// finally push the BoundColumnRefExpression referring to the data element returned by the join
-		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type,
-		                                             plan_columns[flatten.data_offset]);
-	}
-	case SubqueryType::EXISTS: {
-		// correlated EXISTS query
-		// this query is similar to the correlated SCALAR query, except we use a MARK join here
-		idx_t mark_index = binder.GenerateTableIndex();
-		auto delim_join = CreateDuplicateEliminatedJoin(correlated_columns, JoinType::MARK, move(root), perform_delim);
-		delim_join->mark_index = mark_index;
-		// RHS
-		FlattenDependentJoins flatten(binder, correlated_columns, perform_delim);
-		flatten.DetectCorrelatedExpressions(plan.get());
-		auto dependent_join = flatten.PushDownDependentJoin(move(plan));
-
-		// fetch the set of columns
-		auto plan_columns = dependent_join->GetColumnBindings();
-
-		// now we create the join conditions between the dependent join and the original table
-		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-		delim_join->AddChild(move(dependent_join));
-		root = move(delim_join);
-		// finally push the BoundColumnRefExpression referring to the marker
-		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
-	}
-	default: {
-		D_ASSERT(expr.subquery_type == SubqueryType::ANY);
-		// correlated ANY query
-		// this query is similar to the correlated SCALAR query
-		// however, in this case we push a correlated MARK join
-		// note that in this join null values are NOT equal for ALL columns, but ONLY for the correlated columns
-		// the correlated mark join handles this case by itself
-		// as the MARK join has one extra join condition (the original condition, of the ANY expression, e.g.
-		// [i=ANY(...)])
-		idx_t mark_index = binder.GenerateTableIndex();
-		auto delim_join = CreateDuplicateEliminatedJoin(correlated_columns, JoinType::MARK, move(root), perform_delim);
-		delim_join->mark_index = mark_index;
-		// RHS
-		FlattenDependentJoins flatten(binder, correlated_columns, true);
-		flatten.DetectCorrelatedExpressions(plan.get());
-		auto dependent_join = flatten.PushDownDependentJoin(move(plan));
-
-		// fetch the columns
-		auto plan_columns = dependent_join->GetColumnBindings();
-
-		// now we create the join conditions between the dependent join and the original table
-		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-		// add the actual condition based on the ANY/ALL predicate
-		JoinCondition compare_cond;
-		compare_cond.left = move(expr.child);
-		compare_cond.right = BoundCastExpression::AddCastToType(
-		    make_unique<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
-		compare_cond.comparison = expr.comparison_type;
-		delim_join->conditions.push_back(move(compare_cond));
-
-		delim_join->AddChild(move(dependent_join));
-		root = move(delim_join);
-		// finally push the BoundColumnRefExpression referring to the marker
-		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
-	}
-	}
-}
-
-class RecursiveSubqueryPlanner : public LogicalOperatorVisitor {
-public:
-	explicit RecursiveSubqueryPlanner(Binder &binder) : binder(binder) {
-	}
-	void VisitOperator(LogicalOperator &op) override {
-		if (!op.children.empty()) {
-			root = move(op.children[0]);
-			D_ASSERT(root);
-			VisitOperatorExpressions(op);
-			op.children[0] = move(root);
-			for (idx_t i = 0; i < op.children.size(); i++) {
-				D_ASSERT(op.children[i]);
-				VisitOperator(*op.children[i]);
-			}
-		}
-	}
-
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		return binder.PlanSubquery(expr, root);
-	}
-
-private:
-	unique_ptr<LogicalOperator> root;
-	Binder &binder;
-};
-
-unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, unique_ptr<LogicalOperator> &root) {
-	D_ASSERT(root);
-	// first we translate the QueryNode of the subquery into a logical plan
-	// note that we do not plan nested subqueries yet
-	auto sub_binder = Binder::CreateBinder(context);
-	sub_binder->plan_subquery = false;
-	auto subquery_root = sub_binder->CreatePlan(*expr.subquery);
-	D_ASSERT(subquery_root);
-
-	// now we actually flatten the subquery
-	auto plan = move(subquery_root);
-	unique_ptr<Expression> result_expression;
-	if (!expr.IsCorrelated()) {
-		result_expression = PlanUncorrelatedSubquery(*this, expr, root, move(plan));
-	} else {
-		result_expression = PlanCorrelatedSubquery(*this, expr, root, move(plan));
-	}
-	// finally, we recursively plan the nested subqueries (if there are any)
-	if (sub_binder->has_unplanned_subqueries) {
-		RecursiveSubqueryPlanner plan(*this);
-		plan.VisitOperator(*root);
-	}
-	return result_expression;
-}
-
-void Binder::PlanSubqueries(unique_ptr<Expression> *expr_ptr, unique_ptr<LogicalOperator> *root) {
-	if (!*expr_ptr) {
-		return;
-	}
-	auto &expr = **expr_ptr;
-
-	// first visit the children of the node, if any
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(&expr, root); });
-
-	// check if this is a subquery node
-	if (expr.expression_class == ExpressionClass::BOUND_SUBQUERY) {
-		auto &subquery = (BoundSubqueryExpression &)expr;
-		// subquery node! plan it
-		if (subquery.IsCorrelated() && !plan_subquery) {
-			// detected a nested correlated subquery
-			// we don't plan it yet here, we are currently planning a subquery
-			// nested subqueries will only be planned AFTER the current subquery has been flattened entirely
-			has_unplanned_subqueries = true;
-			return;
-		}
-		*expr_ptr = PlanSubquery(subquery, *root);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(CallStatement &stmt) {
-	BoundStatement result;
-
-	TableFunctionRef ref;
-	ref.function = move(stmt.function);
-
-	auto bound_func = Bind(ref);
-	auto &bound_table_func = (BoundTableFunction &)*bound_func;
-	auto &get = (LogicalGet &)*bound_table_func.get;
-	D_ASSERT(get.returned_types.size() > 0);
-	for (idx_t i = 0; i < get.returned_types.size(); i++) {
-		get.column_ids.push_back(i);
-	}
-
-	result.types = get.returned_types;
-	result.names = get.names;
-	result.plan = CreatePlan(*bound_func);
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
-	// COPY TO a file
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.enable_external_access) {
-		throw PermissionException("COPY TO is disabled by configuration");
-	}
-	BoundStatement result;
-	result.types = {LogicalType::BIGINT};
-	result.names = {"Count"};
-
-	// bind the select statement
-	auto select_node = Bind(*stmt.select_statement);
-
-	// lookup the format in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_to_bind) {
-		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
-	}
-	bool use_tmp_file = true;
-	for (auto &option : stmt.info->options) {
-		auto loption = StringUtil::Lower(option.first);
-		if (loption == "use_tmp_file") {
-			use_tmp_file = option.second[0].CastAs(LogicalType::BOOLEAN).GetValue<bool>();
-			stmt.info->options.erase(option.first);
-			break;
-		}
-	}
-	auto function_data =
-	    copy_function->function.copy_to_bind(context, *stmt.info, select_node.names, select_node.types);
-	// now create the copy information
-	auto copy = make_unique<LogicalCopyToFile>(copy_function->function, move(function_data));
-	copy->file_path = stmt.info->file_path;
-	copy->use_tmp_file = use_tmp_file;
-	copy->is_file_and_exists = config.file_system->FileExists(copy->file_path);
-
-	copy->AddChild(move(select_node.plan));
-
-	result.plan = move(copy);
-
-	return result;
-}
-
-BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.enable_external_access) {
-		throw PermissionException("COPY FROM is disabled by configuration");
-	}
-	BoundStatement result;
-	result.types = {LogicalType::BIGINT};
-	result.names = {"Count"};
-
-	D_ASSERT(!stmt.info->table.empty());
-	// COPY FROM a file
-	// generate an insert statement for the the to-be-inserted table
-	InsertStatement insert;
-	insert.table = stmt.info->table;
-	insert.schema = stmt.info->schema;
-	insert.columns = stmt.info->select_list;
-
-	// bind the insert statement to the base table
-	auto insert_statement = Bind(insert);
-	D_ASSERT(insert_statement.plan->type == LogicalOperatorType::LOGICAL_INSERT);
-
-	auto &bound_insert = (LogicalInsert &)*insert_statement.plan;
-
-	// lookup the format in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_from_bind) {
-		throw NotImplementedException("COPY FROM is not supported for FORMAT \"%s\"", stmt.info->format);
-	}
-	// lookup the table to copy into
-	auto table = Catalog::GetCatalog(context).GetEntry<TableCatalogEntry>(context, stmt.info->schema, stmt.info->table);
-	vector<string> expected_names;
-	if (!bound_insert.column_index_map.empty()) {
-		expected_names.resize(bound_insert.expected_types.size());
-		for (idx_t i = 0; i < table->columns.size(); i++) {
-			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
-				expected_names[bound_insert.column_index_map[i]] = table->columns[i].Name();
-			}
-		}
-	} else {
-		expected_names.reserve(bound_insert.expected_types.size());
-		for (idx_t i = 0; i < table->columns.size(); i++) {
-			expected_names.push_back(table->columns[i].Name());
-		}
-	}
-
-	auto function_data =
-	    copy_function->function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
-	auto get = make_unique<LogicalGet>(0, copy_function->function.copy_from_function, move(function_data),
-	                                   bound_insert.expected_types, expected_names);
-	for (idx_t i = 0; i < bound_insert.expected_types.size(); i++) {
-		get->column_ids.push_back(i);
-	}
-	insert_statement.plan->children.push_back(move(get));
-	result.plan = move(insert_statement.plan);
-	return result;
-}
-
-BoundStatement Binder::Bind(CopyStatement &stmt) {
-	if (!stmt.info->is_from && !stmt.select_statement) {
-		// copy table into file without a query
-		// generate SELECT * FROM table;
-		auto ref = make_unique<BaseTableRef>();
-		ref->schema_name = stmt.info->schema;
-		ref->table_name = stmt.info->table;
-
-		auto statement = make_unique<SelectNode>();
-		statement->from_table = move(ref);
-		if (!stmt.info->select_list.empty()) {
-			for (auto &name : stmt.info->select_list) {
-				statement->select_list.push_back(make_unique<ColumnRefExpression>(name));
-			}
-		} else {
-			statement->select_list.push_back(make_unique<StarExpression>());
-		}
-		stmt.select_statement = move(statement);
-	}
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::CHANGED_ROWS;
-	if (stmt.info->is_from) {
-		return BindCopyFrom(stmt);
-	} else {
-		return BindCopyTo(stmt);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
-	if (info.schema.empty()) {
-		info.schema = info.temporary ? TEMP_SCHEMA : ClientData::Get(context).catalog_search_path->GetDefault();
-	}
-
-	if (!info.temporary) {
-		// non-temporary create: not read only
-		if (info.schema == TEMP_SCHEMA) {
-			throw ParserException("Only TEMPORARY table names can use the \"temp\" schema");
-		}
-		properties.read_only = false;
-	} else {
-		if (info.schema != TEMP_SCHEMA) {
-			throw ParserException("TEMPORARY table names can *only* use the \"%s\" schema", TEMP_SCHEMA);
-		}
-	}
-	// fetch the schema in which we want to create the object
-	auto schema_obj = Catalog::GetCatalog(context).GetSchema(context, info.schema);
-	D_ASSERT(schema_obj->type == CatalogType::SCHEMA_ENTRY);
-	info.schema = schema_obj->name;
-	return schema_obj;
-}
-
-void Binder::BindCreateViewInfo(CreateViewInfo &base) {
-	// bind the view as if it were a query so we can catch errors
-	// note that we bind the original, and replace the original with a copy
-	auto view_binder = Binder::CreateBinder(context);
-	view_binder->can_contain_nulls = true;
-
-	auto copy = base.query->Copy();
-	auto query_node = view_binder->Bind(*base.query);
-	base.query = unique_ptr_cast<SQLStatement, SelectStatement>(move(copy));
-	if (base.aliases.size() > query_node.names.size()) {
-		throw BinderException("More VIEW aliases than columns in query result");
-	}
-	// fill up the aliases with the remaining names of the bound query
-	for (idx_t i = base.aliases.size(); i < query_node.names.size(); i++) {
-		base.aliases.push_back(query_node.names[i]);
-	}
-	base.types = query_node.types;
-}
-
-SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
-	auto &base = (CreateMacroInfo &)info;
-	auto &scalar_function = (ScalarMacroFunction &)*base.function;
-
-	if (scalar_function.expression->HasParameter()) {
-		throw BinderException("Parameter expressions within macro's are not supported!");
-	}
-
-	// create macro binding in order to bind the function
-	vector<LogicalType> dummy_types;
-	vector<string> dummy_names;
-	// positional parameters
-	for (idx_t i = 0; i < base.function->parameters.size(); i++) {
-		auto param = (ColumnRefExpression &)*base.function->parameters[i];
-		if (param.IsQualified()) {
-			throw BinderException("Invalid parameter name '%s': must be unqualified", param.ToString());
-		}
-		dummy_types.emplace_back(LogicalType::SQLNULL);
-		dummy_names.push_back(param.GetColumnName());
-	}
-	// default parameters
-	for (auto it = base.function->default_parameters.begin(); it != base.function->default_parameters.end(); it++) {
-		auto &val = (ConstantExpression &)*it->second;
-		dummy_types.push_back(val.value.type());
-		dummy_names.push_back(it->first);
-	}
-	auto this_macro_binding = make_unique<MacroBinding>(dummy_types, dummy_names, base.name);
-	macro_binding = this_macro_binding.get();
-	ExpressionBinder::QualifyColumnNames(*this, scalar_function.expression);
-
-	// create a copy of the expression because we do not want to alter the original
-	auto expression = scalar_function.expression->Copy();
-
-	// bind it to verify the function was defined correctly
-	string error;
-	auto sel_node = make_unique<BoundSelectNode>();
-	auto group_info = make_unique<BoundGroupInformation>();
-	SelectBinder binder(*this, context, *sel_node, *group_info);
-	error = binder.Bind(&expression, 0, false);
-
-	if (!error.empty()) {
-		throw BinderException(error);
-	}
-
-	return BindSchema(info);
-}
-
-void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const string &schema) {
-	if (type.id() == LogicalTypeId::LIST) {
-		auto child_type = ListType::GetChildType(type);
-		BindLogicalType(context, child_type, schema);
-		type = LogicalType::LIST(child_type);
-	} else if (type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::MAP) {
-		auto child_types = StructType::GetChildTypes(type);
-		for (auto &child_type : child_types) {
-			BindLogicalType(context, child_type.second, schema);
-		}
-		// Generate new Struct/Map Type
-		if (type.id() == LogicalTypeId::STRUCT) {
-			type = LogicalType::STRUCT(child_types);
-		} else {
-			type = LogicalType::MAP(child_types);
-		}
-	} else if (type.id() == LogicalTypeId::USER) {
-		auto &catalog = Catalog::GetCatalog(context);
-		type = catalog.GetType(context, schema, UserType::GetTypeName(type));
-	} else if (type.id() == LogicalTypeId::ENUM) {
-		auto &enum_type_name = EnumType::GetTypeName(type);
-		auto enum_type_catalog = (TypeCatalogEntry *)context.db->GetCatalog().GetEntry(context, CatalogType::TYPE_ENTRY,
-		                                                                               schema, enum_type_name, true);
-		LogicalType::SetCatalog(type, enum_type_catalog);
-	}
-}
-
-static void FindMatchingPrimaryKeyColumns(vector<unique_ptr<Constraint>> &constraints, ForeignKeyConstraint &fk) {
-	if (!fk.pk_columns.empty()) {
-		return;
-	}
-	// find the matching primary key constraint
-	for (auto &constr : constraints) {
-		if (constr->type != ConstraintType::UNIQUE) {
-			continue;
-		}
-		auto &unique = (UniqueConstraint &)*constr;
-		if (!unique.is_primary_key) {
-			continue;
-		}
-		idx_t column_count;
-		if (unique.index != DConstants::INVALID_INDEX) {
-			fk.info.pk_keys.push_back(unique.index);
-			column_count = 1;
-		} else {
-			fk.pk_columns = unique.columns;
-			column_count = unique.columns.size();
-		}
-		if (column_count != fk.fk_columns.size()) {
-			throw BinderException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		return;
-	}
-	throw BinderException("there is no primary key for referenced table \"%s\"", fk.info.table);
-}
-
-void ExpressionContainsGeneratedColumn(const ParsedExpression &expr, const unordered_set<string> &gcols,
-                                       bool &contains_gcol) {
-	if (contains_gcol) {
-		return;
-	}
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = (ColumnRefExpression &)expr;
-		auto &name = column_ref.GetColumnName();
-		if (gcols.count(name)) {
-			contains_gcol = true;
-			return;
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { ExpressionContainsGeneratedColumn(child, gcols, contains_gcol); });
-}
-
-static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info) {
-	unordered_set<string> generated_columns;
-	for (auto &col : table_info.columns) {
-		if (!col.Generated()) {
-			continue;
-		}
-		generated_columns.insert(col.Name());
-	}
-	if (generated_columns.empty()) {
-		return false;
-	}
-
-	for (auto &constr : table_info.constraints) {
-		switch (constr->type) {
-		case ConstraintType::CHECK: {
-			auto &constraint = (CheckConstraint &)*constr;
-			auto &expr = constraint.expression;
-			bool contains_generated_column = false;
-			ExpressionContainsGeneratedColumn(*expr, generated_columns, contains_generated_column);
-			if (contains_generated_column) {
-				return true;
-			}
-			break;
-		}
-		case ConstraintType::NOT_NULL: {
-			auto &constraint = (NotNullConstraint &)*constr;
-			auto index = constraint.index;
-			if (table_info.columns[index].Generated()) {
-				return true;
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			auto &constraint = (UniqueConstraint &)*constr;
-			auto index = constraint.index;
-			if (index == DConstants::INVALID_INDEX) {
-				for (auto &col : constraint.columns) {
-					if (generated_columns.count(col)) {
-						return true;
-					}
-				}
-			} else {
-				if (table_info.columns[index].Generated()) {
-					return true;
-				}
-			}
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			// If it contained a generated column, an exception would have been thrown inside AddDataTableIndex earlier
-			break;
-		}
-		default: {
-			throw NotImplementedException("ConstraintType not implemented");
-		}
-		}
-	}
-	return false;
-}
-
-BoundStatement Binder::Bind(CreateStatement &stmt) {
-	BoundStatement result;
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-	properties.return_type = StatementReturnType::NOTHING;
-
-	auto catalog_type = stmt.info->type;
-	switch (catalog_type) {
-	case CatalogType::SCHEMA_ENTRY:
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA, move(stmt.info));
-		break;
-	case CatalogType::VIEW_ENTRY: {
-		auto &base = (CreateViewInfo &)*stmt.info;
-		// bind the schema
-		auto schema = BindSchema(*stmt.info);
-		BindCreateViewInfo(base);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, move(stmt.info), schema);
-		break;
-	}
-	case CatalogType::SEQUENCE_ENTRY: {
-		auto schema = BindSchema(*stmt.info);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, move(stmt.info), schema);
-		break;
-	}
-	case CatalogType::TABLE_MACRO_ENTRY: {
-		auto schema = BindSchema(*stmt.info);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, move(stmt.info), schema);
-		break;
-	}
-	case CatalogType::MACRO_ENTRY: {
-		auto schema = BindCreateFunctionInfo(*stmt.info);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, move(stmt.info), schema);
-		break;
-	}
-	case CatalogType::INDEX_ENTRY: {
-		auto &base = (CreateIndexInfo &)*stmt.info;
-		// visit the table reference
-		auto bound_table = Bind(*base.table);
-		if (bound_table->type != TableReferenceType::BASE_TABLE) {
-			throw BinderException("Can only delete from base table!");
-		}
-		auto &table_binding = (BoundBaseTableRef &)*bound_table;
-		auto table = table_binding.table;
-		// bind the index expressions
-		vector<unique_ptr<Expression>> expressions;
-		IndexBinder binder(*this, context);
-		for (auto &expr : base.expressions) {
-			expressions.push_back(binder.Bind(expr));
-		}
-
-		auto plan = CreatePlan(*bound_table);
-		if (plan->type != LogicalOperatorType::LOGICAL_GET) {
-			throw BinderException("Cannot create index on a view!");
-		}
-		auto &get = (LogicalGet &)*plan;
-		for (auto &column_id : get.column_ids) {
-			if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
-				throw BinderException("Cannot create an index on the rowid!");
-			}
-		}
-		// this gives us a logical table scan
-		// we take the required columns from here
-		// create the logical operator
-		result.plan = make_unique<LogicalCreateIndex>(*table, get.column_ids, move(expressions),
-		                                              unique_ptr_cast<CreateInfo, CreateIndexInfo>(move(stmt.info)));
-		break;
-	}
-	case CatalogType::TABLE_ENTRY: {
-		// If there is a foreign key constraint, resolve primary key column's index from primary key column's name
-		auto &create_info = (CreateTableInfo &)*stmt.info;
-		auto &catalog = Catalog::GetCatalog(context);
-		// We first check if there are any user types, if yes we check to which custom types they refer.
-		unordered_set<SchemaCatalogEntry *> fk_schemas;
-		for (idx_t i = 0; i < create_info.constraints.size(); i++) {
-			auto &cond = create_info.constraints[i];
-			if (cond->type != ConstraintType::FOREIGN_KEY) {
-				continue;
-			}
-			auto &fk = (ForeignKeyConstraint &)*cond;
-			if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				continue;
-			}
-			D_ASSERT(fk.info.pk_keys.empty());
-			if (create_info.table == fk.info.table) {
-				fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE;
-				FindMatchingPrimaryKeyColumns(create_info.constraints, fk);
-			} else {
-				// have to resolve referenced table
-				auto pk_table_entry_ptr = catalog.GetEntry<TableCatalogEntry>(context, fk.info.schema, fk.info.table);
-				fk_schemas.insert(pk_table_entry_ptr->schema);
-				D_ASSERT(fk.info.pk_keys.empty());
-				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->constraints, fk);
-				for (auto &keyname : fk.pk_columns) {
-					auto entry = pk_table_entry_ptr->name_map.find(keyname);
-					if (entry == pk_table_entry_ptr->name_map.end()) {
-						throw BinderException("column \"%s\" named in key does not exist", keyname);
-					}
-					auto column_index = entry->second;
-					auto &column = pk_table_entry_ptr->columns[column_index];
-					fk.info.pk_keys.push_back(column.StorageOid());
-				}
-				auto index = pk_table_entry_ptr->storage->info->indexes.FindForeignKeyIndex(
-				    fk.info.pk_keys, ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE);
-				if (!index) {
-					auto fk_column_names = StringUtil::Join(fk.pk_columns, ",");
-					throw BinderException("Failed to create foreign key on %s(%s): no UNIQUE or PRIMARY KEY constraint "
-					                      "present on these columns",
-					                      pk_table_entry_ptr->name, fk_column_names);
-				}
-			}
-		}
-		if (AnyConstraintReferencesGeneratedColumn(create_info)) {
-			throw BinderException("Constraints on generated columns are not supported yet");
-		}
-		auto bound_info = BindCreateTableInfo(move(stmt.info));
-		auto root = move(bound_info->query);
-
-		for (auto &fk_schema : fk_schemas) {
-			if (fk_schema != bound_info->schema) {
-				throw BinderException("Creating foreign keys across different schemas is not supported");
-			}
-		}
-
-		// create the logical operator
-		auto &schema = bound_info->schema;
-		auto create_table = make_unique<LogicalCreateTable>(schema, move(bound_info));
-		if (root) {
-			// CREATE TABLE AS
-			properties.return_type = StatementReturnType::CHANGED_ROWS;
-			create_table->children.push_back(move(root));
-		}
-		result.plan = move(create_table);
-		break;
-	}
-	case CatalogType::TYPE_ENTRY: {
-		auto schema = BindSchema(*stmt.info);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, move(stmt.info), schema);
-		break;
-	}
-	default:
-		throw Exception("Unrecognized type!");
-	}
-	properties.allow_stream_result = false;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-static void CreateColumnMap(BoundCreateTableInfo &info, bool allow_duplicate_names) {
-	auto &base = (CreateTableInfo &)*info.base;
-
-	idx_t storage_idx = 0;
-	for (uint64_t oid = 0; oid < base.columns.size(); oid++) {
-		auto &col = base.columns[oid];
-		if (allow_duplicate_names) {
-			idx_t index = 1;
-			string base_name = col.Name();
-			while (info.name_map.find(col.Name()) != info.name_map.end()) {
-				col.SetName(base_name + ":" + to_string(index++));
-			}
-		} else {
-			if (info.name_map.find(col.Name()) != info.name_map.end()) {
-				throw CatalogException("Column with name %s already exists!", col.Name());
-			}
-		}
-
-		info.name_map[col.Name()] = oid;
-		col.SetOid(oid);
-		if (col.Generated()) {
-			continue;
-		}
-		col.SetStorageOid(storage_idx++);
-	}
-}
-
-static void CreateColumnDependencyManager(BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
-	D_ASSERT(!info.name_map.empty());
-
-	for (auto &col : base.columns) {
-		if (!col.Generated()) {
-			continue;
-		}
-		info.column_dependency_manager.AddGeneratedColumn(col, info.name_map);
-	}
-}
-
-static void BindCheckConstraint(Binder &binder, BoundCreateTableInfo &info, const unique_ptr<Constraint> &cond) {
-	auto &base = (CreateTableInfo &)*info.base;
-
-	auto bound_constraint = make_unique<BoundCheckConstraint>();
-	// check constraint: bind the expression
-	CheckBinder check_binder(binder, binder.context, base.table, base.columns, bound_constraint->bound_columns);
-	auto &check = (CheckConstraint &)*cond;
-	// create a copy of the unbound expression because the binding destroys the constraint
-	auto unbound_expression = check.expression->Copy();
-	// now bind the constraint and create a new BoundCheckConstraint
-	bound_constraint->expression = check_binder.Bind(check.expression);
-	info.bound_constraints.push_back(move(bound_constraint));
-	// move the unbound constraint back into the original check expression
-	check.expression = move(unbound_expression);
-}
-
-static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
-
-	bool has_primary_key = false;
-	vector<idx_t> primary_keys;
-	for (idx_t i = 0; i < base.constraints.size(); i++) {
-		auto &cond = base.constraints[i];
-		switch (cond->type) {
-		case ConstraintType::CHECK: {
-			BindCheckConstraint(binder, info, cond);
-			break;
-		}
-		case ConstraintType::NOT_NULL: {
-			auto &not_null = (NotNullConstraint &)*cond;
-			auto &col = base.columns[not_null.index];
-			info.bound_constraints.push_back(make_unique<BoundNotNullConstraint>(col.StorageOid()));
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			auto &unique = (UniqueConstraint &)*cond;
-			// have to resolve columns of the unique constraint
-			vector<idx_t> keys;
-			unordered_set<idx_t> key_set;
-			if (unique.index != DConstants::INVALID_INDEX) {
-				D_ASSERT(unique.index < base.columns.size());
-				// unique constraint is given by single index
-				unique.columns.push_back(base.columns[unique.index].Name());
-				keys.push_back(unique.index);
-				key_set.insert(unique.index);
-			} else {
-				// unique constraint is given by list of names
-				// have to resolve names
-				D_ASSERT(!unique.columns.empty());
-				for (auto &keyname : unique.columns) {
-					auto entry = info.name_map.find(keyname);
-					if (entry == info.name_map.end()) {
-						throw ParserException("column \"%s\" named in key does not exist", keyname);
-					}
-					auto &column_index = entry->second;
-					if (key_set.find(column_index) != key_set.end()) {
-						throw ParserException("column \"%s\" appears twice in "
-						                      "primary key constraint",
-						                      keyname);
-					}
-					keys.push_back(column_index);
-					key_set.insert(column_index);
-				}
-			}
-
-			if (unique.is_primary_key) {
-				// we can only have one primary key per table
-				if (has_primary_key) {
-					throw ParserException("table \"%s\" has more than one primary key", base.table);
-				}
-				has_primary_key = true;
-				primary_keys = keys;
-			}
-			info.bound_constraints.push_back(
-			    make_unique<BoundUniqueConstraint>(move(keys), move(key_set), unique.is_primary_key));
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto &fk = (ForeignKeyConstraint &)*cond;
-			D_ASSERT((fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE && !fk.info.pk_keys.empty()) ||
-			         (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && !fk.info.pk_keys.empty()) ||
-			         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
-			if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE && fk.info.pk_keys.empty()) {
-				for (auto &keyname : fk.pk_columns) {
-					auto entry = info.name_map.find(keyname);
-					if (entry == info.name_map.end()) {
-						throw BinderException("column \"%s\" named in key does not exist", keyname);
-					}
-					auto column_index = entry->second;
-					fk.info.pk_keys.push_back(column_index);
-				}
-			}
-			if (fk.info.fk_keys.empty()) {
-				for (auto &keyname : fk.fk_columns) {
-					auto entry = info.name_map.find(keyname);
-					if (entry == info.name_map.end()) {
-						throw BinderException("column \"%s\" named in key does not exist", keyname);
-					}
-					auto column_index = entry->second;
-					fk.info.fk_keys.push_back(column_index);
-				}
-			}
-			unordered_set<idx_t> fk_key_set, pk_key_set;
-			for (idx_t i = 0; i < fk.info.pk_keys.size(); i++) {
-				pk_key_set.insert(fk.info.pk_keys[i]);
-			}
-			for (idx_t i = 0; i < fk.info.fk_keys.size(); i++) {
-				fk_key_set.insert(fk.info.fk_keys[i]);
-			}
-			info.bound_constraints.push_back(make_unique<BoundForeignKeyConstraint>(fk.info, pk_key_set, fk_key_set));
-			break;
-		}
-		default:
-			throw NotImplementedException("unrecognized constraint type in bind");
-		}
-	}
-	if (has_primary_key) {
-		// if there is a primary key index, also create a NOT NULL constraint for each of the columns
-		for (auto &column_index : primary_keys) {
-			auto &column = base.columns[column_index];
-			base.constraints.push_back(make_unique<NotNullConstraint>(column_index));
-			info.bound_constraints.push_back(make_unique<BoundNotNullConstraint>(column.StorageOid()));
-		}
-	}
-}
-
-void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
-
-	vector<string> names;
-	vector<LogicalType> types;
-
-	D_ASSERT(base.type == CatalogType::TABLE_ENTRY);
-	for (idx_t i = 0; i < base.columns.size(); i++) {
-		auto &col = base.columns[i];
-		names.push_back(col.Name());
-		types.push_back(col.Type());
-	}
-	auto table_index = GenerateTableIndex();
-
-	// Create a new binder because we dont need (or want) these bindings in this scope
-	auto binder = Binder::CreateBinder(context);
-	binder->bind_context.AddGenericBinding(table_index, base.table, names, types);
-	auto expr_binder = ExpressionBinder(*binder, context);
-	string ignore;
-	auto table_binding = binder->bind_context.GetBinding(base.table, ignore);
-	D_ASSERT(table_binding && ignore.empty());
-
-	auto bind_order = info.column_dependency_manager.GetBindOrder(base.columns);
-	unordered_set<column_t> bound_indices;
-
-	while (!bind_order.empty()) {
-		auto i = bind_order.top();
-		bind_order.pop();
-		auto &col = base.columns[i];
-
-		//! Already bound this previously
-		//! This can not be optimized out of the GetBindOrder function
-		//! These occurrences happen because we need to make sure that ALL dependencies of a column are resolved before
-		//! it gets resolved
-		if (bound_indices.count(i)) {
-			continue;
-		}
-		D_ASSERT(col.Generated());
-		auto expression = col.GeneratedExpression().Copy();
-
-		auto bound_expression = expr_binder.Bind(expression);
-		D_ASSERT(bound_expression);
-		D_ASSERT(!bound_expression->HasSubquery());
-		if (col.Type().id() == LogicalTypeId::ANY) {
-			// Do this before changing the type, so we know it's the first time the type is set
-			col.ChangeGeneratedExpressionType(bound_expression->return_type);
-			col.SetType(bound_expression->return_type);
-
-			// Update the type in the binding, for future expansions
-			string ignore;
-			table_binding->types[i] = col.Type();
-		}
-		bound_indices.insert(i);
-	}
-}
-
-void Binder::BindDefaultValues(vector<ColumnDefinition> &columns, vector<unique_ptr<Expression>> &bound_defaults) {
-	for (idx_t i = 0; i < columns.size(); i++) {
-		unique_ptr<Expression> bound_default;
-		if (columns[i].DefaultValue()) {
-			// we bind a copy of the DEFAULT value because binding is destructive
-			// and we want to keep the original expression around for serialization
-			auto default_copy = columns[i].DefaultValue()->Copy();
-			ConstantBinder default_binder(*this, context, "DEFAULT value");
-			default_binder.target_type = columns[i].Type();
-			bound_default = default_binder.Bind(default_copy);
-		} else {
-			// no default value specified: push a default value of constant null
-			bound_default = make_unique<BoundConstantExpression>(Value(columns[i].Type()));
-		}
-		bound_defaults.push_back(move(bound_default));
-	}
-}
-
-unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info) {
-	auto &base = (CreateTableInfo &)*info;
-
-	auto result = make_unique<BoundCreateTableInfo>(move(info));
-	result->schema = BindSchema(*result->base);
-	if (base.query) {
-		// construct the result object
-		auto query_obj = Bind(*base.query);
-		result->query = move(query_obj.plan);
-
-		// construct the set of columns based on the names and types of the query
-		auto &names = query_obj.names;
-		auto &sql_types = query_obj.types;
-		D_ASSERT(names.size() == sql_types.size());
-		for (idx_t i = 0; i < names.size(); i++) {
-			base.columns.emplace_back(names[i], sql_types[i]);
-		}
-		// create the name map for the statement
-		CreateColumnMap(*result, true);
-		CreateColumnDependencyManager(*result);
-		// bind the generated column expressions
-		BindGeneratedColumns(*result);
-	} else {
-		// create the name map for the statement
-		CreateColumnMap(*result, false);
-		CreateColumnDependencyManager(*result);
-		// bind the generated column expressions
-		BindGeneratedColumns(*result);
-		// bind any constraints
-		BindConstraints(*this, *result);
-		// bind the default values
-		BindDefaultValues(base.columns, result->bound_defaults);
-	}
-
-	// bind collations to detect any unsupported collation errors
-	for (auto &column : base.columns) {
-		if (column.Generated()) {
-			continue;
-		}
-		if (column.Type().id() == LogicalTypeId::VARCHAR) {
-			ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
-		}
-		BindLogicalType(context, column.TypeMutable());
-		// We add a catalog dependency
-		auto type_dependency = LogicalType::GetCatalog(column.Type());
-		if (type_dependency) {
-			// Only if the USER comes from a create type
-			result->dependencies.insert(type_dependency);
-		}
-	}
-	properties.allow_stream_result = false;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(DeleteStatement &stmt) {
-	BoundStatement result;
-
-	// visit the table reference
-	auto bound_table = Bind(*stmt.table);
-	if (bound_table->type != TableReferenceType::BASE_TABLE) {
-		throw BinderException("Can only delete from base table!");
-	}
-	auto &table_binding = (BoundBaseTableRef &)*bound_table;
-	auto table = table_binding.table;
-
-	auto root = CreatePlan(*bound_table);
-	auto &get = (LogicalGet &)*root;
-	D_ASSERT(root->type == LogicalOperatorType::LOGICAL_GET);
-
-	if (!table->temporary) {
-		// delete from persistent table: not read only!
-		properties.read_only = false;
-	}
-
-	// Add CTEs as bindable
-	AddCTEMap(stmt.cte_map);
-
-	// plan any tables from the various using clauses
-	if (!stmt.using_clauses.empty()) {
-		unique_ptr<LogicalOperator> child_operator;
-		for (auto &using_clause : stmt.using_clauses) {
-			// bind the using clause
-			auto bound_node = Bind(*using_clause);
-			auto op = CreatePlan(*bound_node);
-			if (child_operator) {
-				// already bound a child: create a cross product to unify the two
-				auto cross_product = make_unique<LogicalCrossProduct>();
-				cross_product->children.push_back(move(child_operator));
-				cross_product->children.push_back(move(op));
-				child_operator = move(cross_product);
-			} else {
-				child_operator = move(op);
-			}
-		}
-		if (child_operator) {
-			auto cross_product = make_unique<LogicalCrossProduct>();
-			cross_product->children.push_back(move(root));
-			cross_product->children.push_back(move(child_operator));
-			root = move(cross_product);
-		}
-	}
-
-	// project any additional columns required for the condition
-	unique_ptr<Expression> condition;
-	if (stmt.condition) {
-		WhereBinder binder(*this, context);
-		condition = binder.Bind(stmt.condition);
-
-		PlanSubqueries(&condition, &root);
-		auto filter = make_unique<LogicalFilter>(move(condition));
-		filter->AddChild(move(root));
-		root = move(filter);
-	}
-	// create the delete node
-	auto del = make_unique<LogicalDelete>(table);
-	del->AddChild(move(root));
-
-	// set up the delete expression
-	del->expressions.push_back(make_unique<BoundColumnRefExpression>(
-	    LogicalType::ROW_TYPE, ColumnBinding(get.table_index, get.column_ids.size())));
-	get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-
-	if (!stmt.returning_list.empty()) {
-		del->return_chunk = true;
-
-		auto update_table_index = GenerateTableIndex();
-		del->table_index = update_table_index;
-
-		unique_ptr<LogicalOperator> del_as_logicaloperator = move(del);
-		return BindReturning(move(stmt.returning_list), table, update_table_index, move(del_as_logicaloperator),
-		                     move(result));
-	} else {
-		result.plan = move(del);
-		result.names = {"Count"};
-		result.types = {LogicalType::BIGINT};
-		properties.allow_stream_result = false;
-		properties.return_type = StatementReturnType::CHANGED_ROWS;
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(DropStatement &stmt) {
-	BoundStatement result;
-
-	switch (stmt.info->type) {
-	case CatalogType::PREPARED_STATEMENT:
-		// dropping prepared statements is always possible
-		// it also does not require a valid transaction
-		properties.requires_valid_transaction = false;
-		break;
-	case CatalogType::SCHEMA_ENTRY:
-		// dropping a schema is never read-only because there are no temporary schemas
-		properties.read_only = false;
-		break;
-	case CatalogType::VIEW_ENTRY:
-	case CatalogType::SEQUENCE_ENTRY:
-	case CatalogType::MACRO_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-	case CatalogType::INDEX_ENTRY:
-	case CatalogType::TABLE_ENTRY:
-	case CatalogType::TYPE_ENTRY: {
-		auto entry = (StandardEntry *)Catalog::GetCatalog(context).GetEntry(context, stmt.info->type, stmt.info->schema,
-		                                                                    stmt.info->name, true);
-		if (!entry) {
-			break;
-		}
-		if (!entry->temporary) {
-			// we can only drop temporary tables in read-only mode
-			properties.read_only = false;
-		}
-		stmt.info->schema = entry->schema->name;
-		break;
-	}
-	default:
-		throw BinderException("Unknown catalog type for drop statement!");
-	}
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_DROP, move(stmt.info));
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(ExplainStatement &stmt) {
-	BoundStatement result;
-
-	// bind the underlying statement
-	auto plan = Bind(*stmt.stmt);
-	// get the unoptimized logical plan, and create the explain statement
-	auto logical_plan_unopt = plan.plan->ToString();
-	auto explain = make_unique<LogicalExplain>(move(plan.plan), stmt.explain_type);
-	explain->logical_plan_unopt = logical_plan_unopt;
-
-	result.plan = move(explain);
-	result.names = {"explain_key", "explain_value"};
-	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR};
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-//! Sanitizes a string to have only low case chars and underscores
-string SanitizeExportIdentifier(const string &str) {
-	// Copy the original string to result
-	string result(str);
-
-	for (idx_t i = 0; i < str.length(); ++i) {
-		auto c = str[i];
-		if (c >= 'a' && c <= 'z') {
-			// If it is lower case just continue
-			continue;
-		}
-
-		if (c >= 'A' && c <= 'Z') {
-			// To lowercase
-			result[i] = tolower(c);
-		} else {
-			// Substitute to underscore
-			result[i] = '_';
-		}
-	}
-
-	return result;
-}
-
-bool IsExistMainKeyTable(string &table_name, vector<TableCatalogEntry *> &unordered) {
-	for (idx_t i = 0; i < unordered.size(); i++) {
-		if (unordered[i]->name == table_name) {
-			return true;
-		}
-	}
-	return false;
-}
-
-void ScanForeignKeyTable(vector<TableCatalogEntry *> &ordered, vector<TableCatalogEntry *> &unordered,
-                         bool move_only_pk_table) {
-	for (auto i = unordered.begin(); i != unordered.end();) {
-		auto table_entry = *i;
-		bool move_to_ordered = true;
-		for (idx_t j = 0; j < table_entry->constraints.size(); j++) {
-			auto &cond = table_entry->constraints[j];
-			if (cond->type == ConstraintType::FOREIGN_KEY) {
-				auto &fk = (ForeignKeyConstraint &)*cond;
-				if ((move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) ||
-				    (!move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE &&
-				     IsExistMainKeyTable(fk.info.table, unordered))) {
-					move_to_ordered = false;
-					break;
-				}
-			}
-		}
-		if (move_to_ordered) {
-			ordered.push_back(table_entry);
-			i = unordered.erase(i);
-		} else {
-			i++;
-		}
-	}
-}
-
-void ReorderTableEntries(vector<TableCatalogEntry *> &tables) {
-	vector<TableCatalogEntry *> ordered;
-	vector<TableCatalogEntry *> unordered = tables;
-	ScanForeignKeyTable(ordered, unordered, true);
-	while (!unordered.empty()) {
-		ScanForeignKeyTable(ordered, unordered, false);
-	}
-	tables = ordered;
-}
-
-BoundStatement Binder::Bind(ExportStatement &stmt) {
-	// COPY TO a file
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.enable_external_access) {
-		throw PermissionException("COPY TO is disabled through configuration");
-	}
-	BoundStatement result;
-	result.types = {LogicalType::BOOLEAN};
-	result.names = {"Success"};
-
-	// lookup the format in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_to_bind) {
-		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
-	}
-
-	// gather a list of all the tables
-	vector<TableCatalogEntry *> tables;
-	auto schemas = catalog.schemas->GetEntries<SchemaCatalogEntry>(context);
-	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-			if (entry->type == CatalogType::TABLE_ENTRY) {
-				tables.push_back((TableCatalogEntry *)entry);
-			}
-		});
-	}
-
-	// reorder tables because of foreign key constraint
-	ReorderTableEntries(tables);
-
-	// now generate the COPY statements for each of the tables
-	auto &fs = FileSystem::GetFileSystem(context);
-	unique_ptr<LogicalOperator> child_operator;
-
-	BoundExportData exported_tables;
-
-	unordered_set<string> table_name_index;
-	for (auto &table : tables) {
-		auto info = make_unique<CopyInfo>();
-		// we copy the options supplied to the EXPORT
-		info->format = stmt.info->format;
-		info->options = stmt.info->options;
-		// set up the file name for the COPY TO
-
-		auto exported_data = ExportedTableData();
-		idx_t id = 0;
-		while (true) {
-			string id_suffix = id == 0 ? string() : "_" + to_string(id);
-			if (table->schema->name == DEFAULT_SCHEMA) {
-				info->file_path = fs.JoinPath(stmt.info->file_path,
-				                              StringUtil::Format("%s%s.%s", SanitizeExportIdentifier(table->name),
-				                                                 id_suffix, copy_function->function.extension));
-			} else {
-				info->file_path =
-				    fs.JoinPath(stmt.info->file_path,
-				                StringUtil::Format("%s_%s%s.%s", SanitizeExportIdentifier(table->schema->name),
-				                                   SanitizeExportIdentifier(table->name), id_suffix,
-				                                   copy_function->function.extension));
-			}
-			if (table_name_index.find(info->file_path) == table_name_index.end()) {
-				// this name was not yet taken: take it
-				table_name_index.insert(info->file_path);
-				break;
-			}
-			id++;
-		}
-		info->is_from = false;
-		info->schema = table->schema->name;
-		info->table = table->name;
-
-		exported_data.table_name = info->table;
-		exported_data.schema_name = info->schema;
-		exported_data.file_path = info->file_path;
-
-		ExportedTableInfo table_info;
-		table_info.entry = table;
-		table_info.table_data = exported_data;
-		exported_tables.data.push_back(table_info);
-		id++;
-
-		// generate the copy statement and bind it
-		CopyStatement copy_stmt;
-		copy_stmt.info = move(info);
-
-		auto copy_binder = Binder::CreateBinder(context);
-		auto bound_statement = copy_binder->Bind(copy_stmt);
-		if (child_operator) {
-			// use UNION ALL to combine the individual copy statements into a single node
-			auto copy_union =
-			    make_unique<LogicalSetOperation>(GenerateTableIndex(), 1, move(child_operator),
-			                                     move(bound_statement.plan), LogicalOperatorType::LOGICAL_UNION);
-			child_operator = move(copy_union);
-		} else {
-			child_operator = move(bound_statement.plan);
-		}
-	}
-
-	// try to create the directory, if it doesn't exist yet
-	// a bit hacky to do it here, but we need to create the directory BEFORE the copy statements run
-	if (!fs.DirectoryExists(stmt.info->file_path)) {
-		fs.CreateDirectory(stmt.info->file_path);
-	}
-
-	// create the export node
-	auto export_node = make_unique<LogicalExport>(copy_function->function, move(stmt.info), exported_tables);
-
-	if (child_operator) {
-		export_node->children.push_back(move(child_operator));
-	}
-
-	result.plan = move(export_node);
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(ExtensionStatement &stmt) {
-	BoundStatement result;
-
-	// perform the planning of the function
-	D_ASSERT(stmt.extension.plan_function);
-	auto parse_result = stmt.extension.plan_function(stmt.extension.parser_info.get(), context, move(stmt.parse_data));
-
-	properties.read_only = parse_result.read_only;
-	properties.requires_valid_transaction = parse_result.requires_valid_transaction;
-	properties.return_type = parse_result.return_type;
-
-	// create the plan as a scan of the given table function
-	result.plan = BindTableFunction(parse_result.function, move(parse_result.parameters));
-	D_ASSERT(result.plan->type == LogicalOperatorType::LOGICAL_GET);
-	auto &get = (LogicalGet &)*result.plan;
-	result.names = get.names;
-	result.types = get.returned_types;
-	get.column_ids.clear();
-	for (idx_t i = 0; i < get.returned_types.size(); i++) {
-		get.column_ids.push_back(i);
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static void CheckInsertColumnCountMismatch(int64_t expected_columns, int64_t result_columns, bool columns_provided,
-                                           const char *tname) {
-	if (result_columns != expected_columns) {
-		string msg = StringUtil::Format(!columns_provided ? "table %s has %lld columns but %lld values were supplied"
-		                                                  : "Column name/value mismatch for insert on %s: "
-		                                                    "expected %lld columns but %lld values were supplied",
-		                                tname, expected_columns, result_columns);
-		throw BinderException(msg);
-	}
-}
-
-BoundStatement Binder::Bind(InsertStatement &stmt) {
-	BoundStatement result;
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-
-	auto table = Catalog::GetCatalog(context).GetEntry<TableCatalogEntry>(context, stmt.schema, stmt.table);
-	D_ASSERT(table);
-	if (!table->temporary) {
-		// inserting into a non-temporary table: alters underlying database
-		properties.read_only = false;
-	}
-
-	auto insert = make_unique<LogicalInsert>(table);
-
-	// Add CTEs as bindable
-	AddCTEMap(stmt.cte_map);
-
-	idx_t generated_column_count = 0;
-	vector<idx_t> named_column_map;
-	if (!stmt.columns.empty()) {
-		// insertion statement specifies column list
-
-		// create a mapping of (list index) -> (column index)
-		case_insensitive_map_t<idx_t> column_name_map;
-		for (idx_t i = 0; i < stmt.columns.size(); i++) {
-			column_name_map[stmt.columns[i]] = i;
-			auto entry = table->name_map.find(stmt.columns[i]);
-			if (entry == table->name_map.end()) {
-				throw BinderException("Column %s not found in table %s", stmt.columns[i], table->name);
-			}
-			auto column_index = entry->second;
-			if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-				throw BinderException("Cannot explicitly insert values into rowid column");
-			}
-			if (table->columns[column_index].Generated()) {
-				throw BinderException("Cannot insert into a generated column");
-			}
-			insert->expected_types.push_back(table->columns[column_index].Type());
-			named_column_map.push_back(column_index);
-		}
-		for (idx_t i = 0; i < table->columns.size(); i++) {
-			auto &col = table->columns[i];
-			if (col.Generated()) {
-				generated_column_count++;
-			}
-			auto entry = column_name_map.find(col.Name());
-			if (entry == column_name_map.end()) {
-				// column not specified, set index to DConstants::INVALID_INDEX
-				insert->column_index_map.push_back(DConstants::INVALID_INDEX);
-			} else {
-				// column was specified, set to the index
-				insert->column_index_map.push_back(entry->second);
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < table->columns.size(); i++) {
-			auto &col = table->columns[i];
-			if (col.Generated()) {
-				generated_column_count++;
-				continue;
-			}
-			named_column_map.push_back(i);
-			insert->expected_types.push_back(table->columns[i].Type());
-		}
-	}
-
-	// bind the default values
-	BindDefaultValues(table->columns, insert->bound_defaults);
-	if (!stmt.select_statement) {
-		result.plan = move(insert);
-		return result;
-	}
-
-	// Exclude the generated columns from this amount
-	idx_t expected_columns =
-	    stmt.columns.empty() ? (table->columns.size() - generated_column_count) : stmt.columns.size();
-
-	// special case: check if we are inserting from a VALUES statement
-	auto values_list = stmt.GetValuesList();
-	if (values_list) {
-		auto &expr_list = (ExpressionListRef &)*values_list;
-		expr_list.expected_types.resize(expected_columns);
-		expr_list.expected_names.resize(expected_columns);
-
-		D_ASSERT(expr_list.values.size() > 0);
-		CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(),
-		                               table->name.c_str());
-
-		// VALUES list!
-		for (idx_t col_idx = 0; col_idx < expected_columns; col_idx++) {
-			idx_t table_col_idx = named_column_map[col_idx];
-			D_ASSERT(table_col_idx < table->columns.size());
-
-			// set the expected types as the types for the INSERT statement
-			auto &column = table->columns[table_col_idx];
-			expr_list.expected_types[col_idx] = column.Type();
-			expr_list.expected_names[col_idx] = column.Name();
-
-			// now replace any DEFAULT values with the corresponding default expression
-			for (idx_t list_idx = 0; list_idx < expr_list.values.size(); list_idx++) {
-				if (expr_list.values[list_idx][col_idx]->type == ExpressionType::VALUE_DEFAULT) {
-					// DEFAULT value! replace the entry
-					if (column.DefaultValue()) {
-						expr_list.values[list_idx][col_idx] = column.DefaultValue()->Copy();
-					} else {
-						expr_list.values[list_idx][col_idx] = make_unique<ConstantExpression>(Value(column.Type()));
-					}
-				}
-			}
-		}
-	}
-
-	// parse select statement and add to logical plan
-	auto root_select = Bind(*stmt.select_statement);
-	CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
-	                               table->name.c_str());
-
-	auto root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, move(root_select.plan));
-
-	insert->AddChild(move(root));
-
-	if (!stmt.returning_list.empty()) {
-		insert->return_chunk = true;
-		result.types.clear();
-		result.names.clear();
-		auto insert_table_index = GenerateTableIndex();
-		insert->table_index = insert_table_index;
-		unique_ptr<LogicalOperator> index_as_logicaloperator = move(insert);
-
-		return BindReturning(move(stmt.returning_list), table, insert_table_index, move(index_as_logicaloperator),
-		                     move(result));
-	} else {
-		D_ASSERT(result.types.size() == result.names.size());
-		result.plan = move(insert);
-		properties.allow_stream_result = false;
-		properties.return_type = StatementReturnType::CHANGED_ROWS;
-		return result;
-	}
-}
-
-} // namespace duckdb
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(LoadStatement &stmt) {
-	BoundStatement result;
-	result.types = {LogicalType::BOOLEAN};
-	result.names = {"Success"};
-
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_LOAD, move(stmt.info));
-	properties.allow_stream_result = false;
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(PragmaStatement &stmt) {
-	auto &catalog = Catalog::GetCatalog(context);
-	// bind the pragma function
-	auto entry = catalog.GetEntry<PragmaFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->name, false);
-	string error;
-	idx_t bound_idx = Function::BindFunction(entry->name, entry->functions, *stmt.info, error);
-	if (bound_idx == DConstants::INVALID_INDEX) {
-		throw BinderException(FormatError(stmt.stmt_location, error));
-	}
-	auto &bound_function = entry->functions[bound_idx];
-	if (!bound_function.function) {
-		throw BinderException("PRAGMA function does not have a function specified");
-	}
-
-	// bind and check named params
-	QueryErrorContext error_context(root_statement, stmt.stmt_location);
-	BindNamedParameters(bound_function.named_parameters, stmt.info->named_parameters, error_context,
-	                    bound_function.name);
-
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_unique<LogicalPragma>(bound_function, *stmt.info);
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(RelationStatement &stmt) {
-	return stmt.relation->Bind(*this);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(SelectStatement &stmt) {
-	properties.allow_stream_result = true;
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return Bind(*stmt.node);
-}
-
-} // namespace duckdb
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(SetStatement &stmt) {
-	BoundStatement result;
-	result.types = {LogicalType::BOOLEAN};
-	result.names = {"Success"};
-
-	result.plan = make_unique<LogicalSet>(stmt.name, stmt.value, stmt.scope);
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(ShowStatement &stmt) {
-	BoundStatement result;
-
-	if (stmt.info->is_summary) {
-		return BindSummarize(stmt);
-	}
-	auto plan = Bind(*stmt.info->query);
-	stmt.info->types = plan.types;
-	stmt.info->aliases = plan.names;
-
-	auto show = make_unique<LogicalShow>(move(plan.plan));
-	show->types_select = plan.types;
-	show->aliases = plan.names;
-
-	result.plan = move(show);
-
-	result.names = {"column_name", "column_type", "null", "key", "default", "extra"};
-	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,
-	                LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-//! This file contains the binder definitions for statements that do not need to be bound at all and only require a
-//! straightforward conversion
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(AlterStatement &stmt) {
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	Catalog &catalog = Catalog::GetCatalog(context);
-	auto entry = catalog.GetEntry(context, stmt.info->GetCatalogType(), stmt.info->schema, stmt.info->name, true);
-	if (entry && !entry->temporary) {
-		// we can only alter temporary tables/views in read-only mode
-		properties.read_only = false;
-	}
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, move(stmt.info));
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-BoundStatement Binder::Bind(TransactionStatement &stmt) {
-	// transaction statements do not require a valid transaction
-	properties.requires_valid_transaction = false;
-
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_TRANSACTION, move(stmt.info));
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static unique_ptr<ParsedExpression> SummarizeWrapUnnest(vector<unique_ptr<ParsedExpression>> &children,
-                                                        const string &alias) {
-	auto list_function = make_unique<FunctionExpression>("list_value", move(children));
-	vector<unique_ptr<ParsedExpression>> unnest_children;
-	unnest_children.push_back(move(list_function));
-	auto unnest_function = make_unique<FunctionExpression>("unnest", move(unnest_children));
-	unnest_function->alias = alias;
-	return move(unnest_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_unique<ColumnRefExpression>(move(column_name)));
-	auto aggregate_function = make_unique<FunctionExpression>(aggregate, move(children));
-	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, move(aggregate_function));
-	return move(cast_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name,
-                                                             const Value &modifier) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_unique<ColumnRefExpression>(move(column_name)));
-	children.push_back(make_unique<ConstantExpression>(modifier));
-	auto aggregate_function = make_unique<FunctionExpression>(aggregate, move(children));
-	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, move(aggregate_function));
-	return move(cast_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateCountStar() {
-	vector<unique_ptr<ParsedExpression>> children;
-	auto aggregate_function = make_unique<FunctionExpression>("count_star", move(children));
-	return move(aggregate_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateBinaryFunction(const string &op, unique_ptr<ParsedExpression> left,
-                                                                  unique_ptr<ParsedExpression> right) {
-	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(move(left));
-	children.push_back(move(right));
-	auto binary_function = make_unique<FunctionExpression>(op, move(children));
-	return move(binary_function);
-}
-
-static unique_ptr<ParsedExpression> SummarizeCreateNullPercentage(string column_name) {
-	auto count_star = make_unique<CastExpression>(LogicalType::DOUBLE, SummarizeCreateCountStar());
-	auto count = make_unique<CastExpression>(LogicalType::DOUBLE, SummarizeCreateAggregate("count", move(column_name)));
-	auto null_percentage = SummarizeCreateBinaryFunction("/", move(count), move(count_star));
-	auto negate_x =
-	    SummarizeCreateBinaryFunction("-", make_unique<ConstantExpression>(Value::DOUBLE(1)), move(null_percentage));
-	auto percentage_x =
-	    SummarizeCreateBinaryFunction("*", move(negate_x), make_unique<ConstantExpression>(Value::DOUBLE(100)));
-	auto round_x =
-	    SummarizeCreateBinaryFunction("round", move(percentage_x), make_unique<ConstantExpression>(Value::INTEGER(2)));
-	auto concat_x = SummarizeCreateBinaryFunction("concat", move(round_x), make_unique<ConstantExpression>(Value("%")));
-
-	return concat_x;
-}
-
-BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
-	auto query_copy = stmt.info->query->Copy();
-
-	// we bind the plan once in a child-node to figure out the column names and column types
-	auto child_binder = Binder::CreateBinder(context);
-	auto plan = child_binder->Bind(*stmt.info->query);
-	D_ASSERT(plan.types.size() == plan.names.size());
-	vector<unique_ptr<ParsedExpression>> name_children;
-	vector<unique_ptr<ParsedExpression>> type_children;
-	vector<unique_ptr<ParsedExpression>> min_children;
-	vector<unique_ptr<ParsedExpression>> max_children;
-	vector<unique_ptr<ParsedExpression>> unique_children;
-	vector<unique_ptr<ParsedExpression>> avg_children;
-	vector<unique_ptr<ParsedExpression>> std_children;
-	vector<unique_ptr<ParsedExpression>> q25_children;
-	vector<unique_ptr<ParsedExpression>> q50_children;
-	vector<unique_ptr<ParsedExpression>> q75_children;
-	vector<unique_ptr<ParsedExpression>> count_children;
-	vector<unique_ptr<ParsedExpression>> null_percentage_children;
-	auto select = make_unique<SelectStatement>();
-	select->node = move(query_copy);
-	for (idx_t i = 0; i < plan.names.size(); i++) {
-		name_children.push_back(make_unique<ConstantExpression>(Value(plan.names[i])));
-		type_children.push_back(make_unique<ConstantExpression>(Value(plan.types[i].ToString())));
-		min_children.push_back(SummarizeCreateAggregate("min", plan.names[i]));
-		max_children.push_back(SummarizeCreateAggregate("max", plan.names[i]));
-		unique_children.push_back(SummarizeCreateAggregate("approx_count_distinct", plan.names[i]));
-		if (plan.types[i].IsNumeric()) {
-			avg_children.push_back(SummarizeCreateAggregate("avg", plan.names[i]));
-			std_children.push_back(SummarizeCreateAggregate("stddev", plan.names[i]));
-			q25_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.25)));
-			q50_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.50)));
-			q75_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.75)));
-		} else {
-			avg_children.push_back(make_unique<ConstantExpression>(Value()));
-			std_children.push_back(make_unique<ConstantExpression>(Value()));
-			q25_children.push_back(make_unique<ConstantExpression>(Value()));
-			q50_children.push_back(make_unique<ConstantExpression>(Value()));
-			q75_children.push_back(make_unique<ConstantExpression>(Value()));
-		}
-		count_children.push_back(SummarizeCreateCountStar());
-		null_percentage_children.push_back(SummarizeCreateNullPercentage(plan.names[i]));
-	}
-	auto subquery_ref = make_unique<SubqueryRef>(move(select), "summarize_tbl");
-	subquery_ref->column_name_alias = plan.names;
-
-	auto select_node = make_unique<SelectNode>();
-	select_node->select_list.push_back(SummarizeWrapUnnest(name_children, "column_name"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(type_children, "column_type"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(min_children, "min"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(max_children, "max"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(unique_children, "approx_unique"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(avg_children, "avg"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(std_children, "std"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(q25_children, "q25"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(q50_children, "q50"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(q75_children, "q75"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(count_children, "count"));
-	select_node->select_list.push_back(SummarizeWrapUnnest(null_percentage_children, "null_percentage"));
-	select_node->from_table = move(subquery_ref);
-
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return Bind(*select_node);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
-                             unordered_set<column_t> &bound_columns) {
-	if (bound_columns.size() <= 1) {
-		return;
-	}
-	idx_t found_column_count = 0;
-	unordered_set<idx_t> found_columns;
-	for (idx_t i = 0; i < update.columns.size(); i++) {
-		if (bound_columns.find(update.columns[i]) != bound_columns.end()) {
-			// this column is referenced in the CHECK constraint
-			found_column_count++;
-			found_columns.insert(update.columns[i]);
-		}
-	}
-	if (found_column_count > 0 && found_column_count != bound_columns.size()) {
-		// columns in this CHECK constraint were referenced, but not all were part of the UPDATE
-		// add them to the scan and update set
-		for (auto &check_column_id : bound_columns) {
-			if (found_columns.find(check_column_id) != found_columns.end()) {
-				// column is already projected
-				continue;
-			}
-			// column is not projected yet: project it by adding the clause "i=i" to the set of updated columns
-			auto &column = table.columns[check_column_id];
-			update.expressions.push_back(make_unique<BoundColumnRefExpression>(
-			    column.Type(), ColumnBinding(proj.table_index, proj.expressions.size())));
-			proj.expressions.push_back(make_unique<BoundColumnRefExpression>(
-			    column.Type(), ColumnBinding(get.table_index, get.column_ids.size())));
-			get.column_ids.push_back(check_column_id);
-			update.columns.push_back(check_column_id);
-		}
-	}
-}
-
-static bool TypeSupportsRegularUpdate(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-		// lists and maps don't support updates directly
-		return false;
-	case LogicalTypeId::STRUCT: {
-		auto &child_types = StructType::GetChildTypes(type);
-		for (auto &entry : child_types) {
-			if (!TypeSupportsRegularUpdate(entry.second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		return true;
-	}
-}
-
-static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj,
-                                  LogicalUpdate &update) {
-	// check the constraints and indexes of the table to see if we need to project any additional columns
-	// we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
-	// suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint
-	// if we are only updating one of the two columns we add the other one to the UPDATE set
-	// with a "useless" update (i.e. i=i) so we can verify that the CHECK constraint is not violated
-	for (auto &constraint : table.bound_constraints) {
-		if (constraint->type == ConstraintType::CHECK) {
-			auto &check = *reinterpret_cast<BoundCheckConstraint *>(constraint.get());
-			// check constraint! check if we need to add any extra columns to the UPDATE clause
-			BindExtraColumns(table, get, proj, update, check.bound_columns);
-		}
-	}
-	// for index updates we always turn any update into an insert and a delete
-	// we thus need all the columns to be available, hence we check if the update touches any index columns
-	// If the returning keyword is used, we need access to the whole row in case the user requests it.
-	// Therefore switch the update to a delete and insert.
-	update.update_is_del_and_insert = false;
-	table.storage->info->indexes.Scan([&](Index &index) {
-		if (index.IndexIsUpdated(update.columns)) {
-			update.update_is_del_and_insert = true;
-			return true;
-		}
-		return false;
-	});
-
-	// we also convert any updates on LIST columns into delete + insert
-	for (auto &col : update.columns) {
-		if (!TypeSupportsRegularUpdate(table.columns[col].Type())) {
-			update.update_is_del_and_insert = true;
-			break;
-		}
-	}
-
-	if (update.update_is_del_and_insert || update.return_chunk) {
-		// the update updates a column required by an index or requires returning the updated rows,
-		// push projections for all columns
-		unordered_set<column_t> all_columns;
-		for (idx_t i = 0; i < table.storage->column_definitions.size(); i++) {
-			all_columns.insert(i);
-		}
-		BindExtraColumns(table, get, proj, update, all_columns);
-	}
-}
-
-BoundStatement Binder::Bind(UpdateStatement &stmt) {
-	BoundStatement result;
-	unique_ptr<LogicalOperator> root;
-	LogicalGet *get;
-
-	// visit the table reference
-	auto bound_table = Bind(*stmt.table);
-	if (bound_table->type != TableReferenceType::BASE_TABLE) {
-		throw BinderException("Can only update base table!");
-	}
-	auto &table_binding = (BoundBaseTableRef &)*bound_table;
-	auto table = table_binding.table;
-
-	// Add CTEs as bindable
-	AddCTEMap(stmt.cte_map);
-
-	if (stmt.from_table) {
-		BoundCrossProductRef bound_crossproduct;
-		bound_crossproduct.left = move(bound_table);
-		bound_crossproduct.right = Bind(*stmt.from_table);
-		root = CreatePlan(bound_crossproduct);
-		get = (LogicalGet *)root->children[0].get();
-	} else {
-		root = CreatePlan(*bound_table);
-		get = (LogicalGet *)root.get();
-	}
-
-	if (!table->temporary) {
-		// update of persistent table: not read only!
-		properties.read_only = false;
-	}
-	auto update = make_unique<LogicalUpdate>(table);
-
-	// set return_chunk boolean early because it needs uses update_is_del_and_insert logic
-	if (!stmt.returning_list.empty()) {
-		update->return_chunk = true;
-	}
-	// bind the default values
-	BindDefaultValues(table->columns, update->bound_defaults);
-
-	// project any additional columns required for the condition/expressions
-	if (stmt.condition) {
-		WhereBinder binder(*this, context);
-		auto condition = binder.Bind(stmt.condition);
-
-		PlanSubqueries(&condition, &root);
-		auto filter = make_unique<LogicalFilter>(move(condition));
-		filter->AddChild(move(root));
-		root = move(filter);
-	}
-
-	D_ASSERT(stmt.columns.size() == stmt.expressions.size());
-
-	auto proj_index = GenerateTableIndex();
-	vector<unique_ptr<Expression>> projection_expressions;
-
-	for (idx_t i = 0; i < stmt.columns.size(); i++) {
-		auto &colname = stmt.columns[i];
-		auto &expr = stmt.expressions[i];
-		if (!table->ColumnExists(colname)) {
-			throw BinderException("Referenced update column %s not found in table!", colname);
-		}
-		auto &column = table->GetColumn(colname);
-		if (column.Generated()) {
-			throw BinderException("Cant update column \"%s\" because it is a generated column!", column.Name());
-		}
-		if (std::find(update->columns.begin(), update->columns.end(), column.Oid()) != update->columns.end()) {
-			throw BinderException("Multiple assignments to same column \"%s\"", colname);
-		}
-		update->columns.push_back(column.Oid());
-
-		if (expr->type == ExpressionType::VALUE_DEFAULT) {
-			update->expressions.push_back(make_unique<BoundDefaultExpression>(column.Type()));
-		} else {
-			UpdateBinder binder(*this, context);
-			binder.target_type = column.Type();
-			auto bound_expr = binder.Bind(expr);
-			PlanSubqueries(&bound_expr, &root);
-
-			update->expressions.push_back(make_unique<BoundColumnRefExpression>(
-			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
-			projection_expressions.push_back(move(bound_expr));
-		}
-	}
-
-	// now create the projection
-	auto proj = make_unique<LogicalProjection>(proj_index, move(projection_expressions));
-	proj->AddChild(move(root));
-
-	// bind any extra columns necessary for CHECK constraints or indexes
-	BindUpdateConstraints(*table, *get, *proj, *update);
-
-	// finally add the row id column to the projection list
-	proj->expressions.push_back(make_unique<BoundColumnRefExpression>(
-	    LogicalType::ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));
-	get->column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-
-	// set the projection as child of the update node and finalize the result
-	update->AddChild(move(proj));
-
-	if (!stmt.returning_list.empty()) {
-		auto update_table_index = GenerateTableIndex();
-		update->table_index = update_table_index;
-		unique_ptr<LogicalOperator> update_as_logicaloperator = move(update);
-
-		return BindReturning(move(stmt.returning_list), table, update_table_index, move(update_as_logicaloperator),
-		                     move(result));
-
-	} else {
-		update->table_index = 0;
-		result.names = {"Count"};
-		result.types = {LogicalType::BIGINT};
-		result.plan = move(update);
-		properties.allow_stream_result = false;
-		properties.return_type = StatementReturnType::CHANGED_ROWS;
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(VacuumStatement &stmt) {
-	BoundStatement result;
-	result.names = {"Success"};
-	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_VACUUM, move(stmt.info));
-	properties.return_type = StatementReturnType::NOTHING;
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
-	QueryErrorContext error_context(root_statement, ref.query_location);
-	// CTEs and views are also referred to using BaseTableRefs, hence need to distinguish here
-	// check if the table name refers to a CTE
-	auto cte = FindCTE(ref.table_name, ref.table_name == alias);
-	if (cte) {
-		// Check if there is a CTE binding in the BindContext
-		auto ctebinding = bind_context.GetCTEBinding(ref.table_name);
-		if (!ctebinding) {
-			if (CTEIsAlreadyBound(cte)) {
-				throw BinderException("Circular reference to CTE \"%s\", use WITH RECURSIVE to use recursive CTEs",
-				                      ref.table_name);
-			}
-			// Move CTE to subquery and bind recursively
-			SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(cte->query->Copy()));
-			subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
-			subquery.column_name_alias = cte->aliases;
-			for (idx_t i = 0; i < ref.column_name_alias.size(); i++) {
-				if (i < subquery.column_name_alias.size()) {
-					subquery.column_name_alias[i] = ref.column_name_alias[i];
-				} else {
-					subquery.column_name_alias.push_back(ref.column_name_alias[i]);
-				}
-			}
-			return Bind(subquery, cte);
-		} else {
-			// There is a CTE binding in the BindContext.
-			// This can only be the case if there is a recursive CTE present.
-			auto index = GenerateTableIndex();
-			auto result = make_unique<BoundCTERef>(index, ctebinding->index);
-			auto b = ctebinding;
-			auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
-			auto names = BindContext::AliasColumnNames(alias, b->names, ref.column_name_alias);
-
-			bind_context.AddGenericBinding(index, alias, names, b->types);
-			// Update references to CTE
-			auto cteref = bind_context.cte_references[ref.table_name];
-			(*cteref)++;
-
-			result->types = b->types;
-			result->bound_columns = move(names);
-			return move(result);
-		}
-	}
-	// not a CTE
-	// extract a table or view from the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto table_or_view =
-	    catalog.GetEntry(context, CatalogType::TABLE_ENTRY, ref.schema_name, ref.table_name, true, error_context);
-	if (!table_or_view) {
-		auto table_name = ref.schema_name.empty() ? ref.table_name : (ref.schema_name + "." + ref.table_name);
-		// table could not be found: try to bind a replacement scan
-		auto &config = DBConfig::GetConfig(context);
-		for (auto &scan : config.replacement_scans) {
-			auto replacement_function = scan.function(context, table_name, scan.data.get());
-			if (replacement_function) {
-				replacement_function->alias = ref.alias.empty() ? ref.table_name : ref.alias;
-				replacement_function->column_name_alias = ref.column_name_alias;
-				return Bind(*replacement_function);
-			}
-		}
-		// we still didn't find the table
-		if (GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-			// if we are in EXTRACT_NAMES, we create a dummy table ref
-			AddTableName(table_name);
-
-			// add a bind context entry
-			auto table_index = GenerateTableIndex();
-			auto alias = ref.alias.empty() ? table_name : ref.alias;
-			vector<LogicalType> types {LogicalType::INTEGER};
-			vector<string> names {"__dummy_col" + to_string(table_index)};
-			bind_context.AddGenericBinding(table_index, alias, names, types);
-			return make_unique_base<BoundTableRef, BoundEmptyTableRef>(table_index);
-		}
-		// could not find an alternative: bind again to get the error
-		table_or_view = Catalog::GetCatalog(context).GetEntry(context, CatalogType::TABLE_ENTRY, ref.schema_name,
-		                                                      ref.table_name, false, error_context);
-	}
-	switch (table_or_view->type) {
-	case CatalogType::TABLE_ENTRY: {
-		// base table: create the BoundBaseTableRef node
-		auto table_index = GenerateTableIndex();
-		auto table = (TableCatalogEntry *)table_or_view;
-
-		auto scan_function = TableScanFunction::GetFunction();
-		auto bind_data = make_unique<TableScanBindData>(table);
-		auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
-		// TODO: bundle the type and name vector in a struct (e.g PackedColumnMetadata)
-		vector<LogicalType> table_types;
-		vector<string> table_names;
-		vector<TableColumnType> table_categories;
-
-		vector<LogicalType> return_types;
-		vector<string> return_names;
-		for (auto &col : table->columns) {
-			table_types.push_back(col.Type());
-			table_names.push_back(col.Name());
-			return_types.push_back(col.Type());
-			return_names.push_back(col.Name());
-		}
-		table_names = BindContext::AliasColumnNames(alias, table_names, ref.column_name_alias);
-
-		auto logical_get = make_unique<LogicalGet>(table_index, scan_function, move(bind_data), move(return_types),
-		                                           move(return_names));
-		bind_context.AddBaseTable(table_index, alias, table_names, table_types, *logical_get);
-		return make_unique_base<BoundTableRef, BoundBaseTableRef>(table, move(logical_get));
-	}
-	case CatalogType::VIEW_ENTRY: {
-		// the node is a view: get the query that the view represents
-		auto view_catalog_entry = (ViewCatalogEntry *)table_or_view;
-		// We need to use a new binder for the view that doesn't reference any CTEs
-		// defined for this binder so there are no collisions between the CTEs defined
-		// for the view and for the current query
-		bool inherit_ctes = false;
-		auto view_binder = Binder::CreateBinder(context, this, inherit_ctes);
-		view_binder->can_contain_nulls = true;
-		SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(view_catalog_entry->query->Copy()));
-		subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
-		subquery.column_name_alias =
-		    BindContext::AliasColumnNames(subquery.alias, view_catalog_entry->aliases, ref.column_name_alias);
-		// bind the child subquery
-		view_binder->AddBoundView(view_catalog_entry);
-		auto bound_child = view_binder->Bind(subquery);
-
-		D_ASSERT(bound_child->type == TableReferenceType::SUBQUERY);
-		// verify that the types and names match up with the expected types and names
-		auto &bound_subquery = (BoundSubqueryRef &)*bound_child;
-		if (bound_subquery.subquery->types != view_catalog_entry->types) {
-			throw BinderException("Contents of view were altered: types don't match!");
-		}
-		bind_context.AddView(bound_subquery.subquery->GetRootIndex(), subquery.alias, subquery,
-		                     *bound_subquery.subquery, view_catalog_entry);
-		return bound_child;
-	}
-	default:
-		throw InternalException("Catalog entry type");
-	}
-}
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(CrossProductRef &ref) {
-	auto result = make_unique<BoundCrossProductRef>();
-	result->left_binder = Binder::CreateBinder(context, this);
-	result->right_binder = Binder::CreateBinder(context, this);
-	auto &left_binder = *result->left_binder;
-	auto &right_binder = *result->right_binder;
-
-	result->left = left_binder.Bind(*ref.left);
-	result->right = right_binder.Bind(*ref.right);
-
-	bind_context.AddContext(move(left_binder.bind_context));
-	bind_context.AddContext(move(right_binder.bind_context));
-	MoveCorrelatedExpressions(left_binder);
-	MoveCorrelatedExpressions(right_binder);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(EmptyTableRef &ref) {
-	return make_unique<BoundEmptyTableRef>(GenerateTableIndex());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(ExpressionListRef &expr) {
-	auto result = make_unique<BoundExpressionListRef>();
-	result->types = expr.expected_types;
-	result->names = expr.expected_names;
-	// bind value list
-	InsertBinder binder(*this, context);
-	binder.target_type = LogicalType(LogicalTypeId::INVALID);
-	for (idx_t list_idx = 0; list_idx < expr.values.size(); list_idx++) {
-		auto &expression_list = expr.values[list_idx];
-		if (result->names.empty()) {
-			// no names provided, generate them
-			for (idx_t val_idx = 0; val_idx < expression_list.size(); val_idx++) {
-				result->names.push_back("col" + to_string(val_idx));
-			}
-		}
-
-		vector<unique_ptr<Expression>> list;
-		for (idx_t val_idx = 0; val_idx < expression_list.size(); val_idx++) {
-			if (!result->types.empty()) {
-				D_ASSERT(result->types.size() == expression_list.size());
-				binder.target_type = result->types[val_idx];
-			}
-			auto expr = binder.Bind(expression_list[val_idx]);
-			list.push_back(move(expr));
-		}
-		result->values.push_back(move(list));
-	}
-	if (result->types.empty() && !expr.values.empty()) {
-		// there are no types specified
-		// we have to figure out the result types
-		// for each column, we iterate over all of the expressions and select the max logical type
-		// we initialize all types to SQLNULL
-		result->types.resize(expr.values[0].size(), LogicalType::SQLNULL);
-		// now loop over the lists and select the max logical type
-		for (idx_t list_idx = 0; list_idx < result->values.size(); list_idx++) {
-			auto &list = result->values[list_idx];
-			for (idx_t val_idx = 0; val_idx < list.size(); val_idx++) {
-				result->types[val_idx] =
-				    LogicalType::MaxLogicalType(result->types[val_idx], list[val_idx]->return_type);
-			}
-		}
-		// finally do another loop over the expressions and add casts where required
-		for (idx_t list_idx = 0; list_idx < result->values.size(); list_idx++) {
-			auto &list = result->values[list_idx];
-			for (idx_t val_idx = 0; val_idx < list.size(); val_idx++) {
-				list[val_idx] = BoundCastExpression::AddCastToType(move(list[val_idx]), result->types[val_idx]);
-			}
-		}
-	}
-	result->bind_index = GenerateTableIndex();
-	bind_context.AddGenericBinding(result->bind_index, expr.alias, result->names, result->types);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static unique_ptr<ParsedExpression> BindColumn(Binder &binder, ClientContext &context, const string &alias,
-                                               const string &column_name) {
-	auto expr = make_unique_base<ParsedExpression, ColumnRefExpression>(column_name, alias);
-	ExpressionBinder expr_binder(binder, context);
-	auto result = expr_binder.Bind(expr);
-	return make_unique<BoundExpression>(move(result));
-}
-
-static unique_ptr<ParsedExpression> AddCondition(ClientContext &context, Binder &left_binder, Binder &right_binder,
-                                                 const string &left_alias, const string &right_alias,
-                                                 const string &column_name) {
-	ExpressionBinder expr_binder(left_binder, context);
-	auto left = BindColumn(left_binder, context, left_alias, column_name);
-	auto right = BindColumn(right_binder, context, right_alias, column_name);
-	return make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, move(left), move(right));
-}
-
-bool Binder::TryFindBinding(const string &using_column, const string &join_side, string &result) {
-	// for each using column, get the matching binding
-	auto bindings = bind_context.GetMatchingBindings(using_column);
-	if (bindings.empty()) {
-		return false;
-	}
-	// find the join binding
-	for (auto &binding : bindings) {
-		if (!result.empty()) {
-			string error = "Column name \"";
-			error += using_column;
-			error += "\" is ambiguous: it exists more than once on ";
-			error += join_side;
-			error += " side of join.\nCandidates:";
-			for (auto &binding : bindings) {
-				error += "\n\t";
-				error += binding;
-				error += ".";
-				error += bind_context.GetActualColumnName(binding, using_column);
-			}
-			throw BinderException(error);
-		} else {
-			result = binding;
-		}
-	}
-	return true;
-}
-
-string Binder::FindBinding(const string &using_column, const string &join_side) {
-	string result;
-	if (!TryFindBinding(using_column, join_side, result)) {
-		throw BinderException("Column \"%s\" does not exist on %s side of join!", using_column, join_side);
-	}
-	return result;
-}
-
-static void AddUsingBindings(UsingColumnSet &set, UsingColumnSet *input_set, const string &input_binding) {
-	if (input_set) {
-		for (auto &entry : input_set->bindings) {
-			set.bindings.insert(entry);
-		}
-	} else {
-		set.bindings.insert(input_binding);
-	}
-}
-
-static void SetPrimaryBinding(UsingColumnSet &set, JoinType join_type, const string &left_binding,
-                              const string &right_binding) {
-	switch (join_type) {
-	case JoinType::LEFT:
-	case JoinType::INNER:
-	case JoinType::SEMI:
-	case JoinType::ANTI:
-		set.primary_binding = left_binding;
-		break;
-	case JoinType::RIGHT:
-		set.primary_binding = right_binding;
-		break;
-	default:
-		break;
-	}
-}
-
-string Binder::RetrieveUsingBinding(Binder &current_binder, UsingColumnSet *current_set, const string &using_column,
-                                    const string &join_side, UsingColumnSet *new_set) {
-	string binding;
-	if (!current_set) {
-		binding = current_binder.FindBinding(using_column, join_side);
-	} else {
-		binding = current_set->primary_binding;
-	}
-	return binding;
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
-	auto result = make_unique<BoundJoinRef>();
-	result->left_binder = Binder::CreateBinder(context, this);
-	result->right_binder = Binder::CreateBinder(context, this);
-	auto &left_binder = *result->left_binder;
-	auto &right_binder = *result->right_binder;
-
-	result->type = ref.type;
-	result->left = left_binder.Bind(*ref.left);
-	result->right = right_binder.Bind(*ref.right);
-
-	vector<unique_ptr<ParsedExpression>> extra_conditions;
-	vector<string> extra_using_columns;
-	if (ref.is_natural) {
-		// natural join, figure out which column names are present in both sides of the join
-		// first bind the left hand side and get a list of all the tables and column names
-		case_insensitive_set_t lhs_columns;
-		auto &lhs_binding_list = left_binder.bind_context.GetBindingsList();
-		for (auto &binding : lhs_binding_list) {
-			for (auto &column_name : binding.second->names) {
-				lhs_columns.insert(column_name);
-			}
-		}
-		// now bind the rhs
-		for (auto &column_name : lhs_columns) {
-			auto right_using_binding = right_binder.bind_context.GetUsingBinding(column_name);
-
-			string right_binding;
-			// loop over the set of lhs columns, and figure out if there is a table in the rhs with the same name
-			if (!right_using_binding) {
-				if (!right_binder.TryFindBinding(column_name, "right", right_binding)) {
-					// no match found for this column on the rhs: skip
-					continue;
-				}
-			}
-			extra_using_columns.push_back(column_name);
-		}
-		if (extra_using_columns.empty()) {
-			// no matching bindings found in natural join: throw an exception
-			string error_msg = "No columns found to join on in NATURAL JOIN.\n";
-			error_msg += "Use CROSS JOIN if you intended for this to be a cross-product.";
-			// gather all left/right candidates
-			string left_candidates, right_candidates;
-			auto &rhs_binding_list = right_binder.bind_context.GetBindingsList();
-			for (auto &binding : lhs_binding_list) {
-				for (auto &column_name : binding.second->names) {
-					if (!left_candidates.empty()) {
-						left_candidates += ", ";
-					}
-					left_candidates += binding.first + "." + column_name;
-				}
-			}
-			for (auto &binding : rhs_binding_list) {
-				for (auto &column_name : binding.second->names) {
-					if (!right_candidates.empty()) {
-						right_candidates += ", ";
-					}
-					right_candidates += binding.first + "." + column_name;
-				}
-			}
-			error_msg += "\n   Left candidates: " + left_candidates;
-			error_msg += "\n   Right candidates: " + right_candidates;
-			throw BinderException(FormatError(ref, error_msg));
-		}
-	} else if (!ref.using_columns.empty()) {
-		// USING columns
-		D_ASSERT(!result->condition);
-		extra_using_columns = ref.using_columns;
-	}
-	if (!extra_using_columns.empty()) {
-		vector<UsingColumnSet *> left_using_bindings;
-		vector<UsingColumnSet *> right_using_bindings;
-		for (idx_t i = 0; i < extra_using_columns.size(); i++) {
-			auto &using_column = extra_using_columns[i];
-			// we check if there is ALREADY a using column of the same name in the left and right set
-			// this can happen if we chain USING clauses
-			// e.g. x JOIN y USING (c) JOIN z USING (c)
-			auto left_using_binding = left_binder.bind_context.GetUsingBinding(using_column);
-			auto right_using_binding = right_binder.bind_context.GetUsingBinding(using_column);
-			if (!left_using_binding) {
-				left_binder.bind_context.GetMatchingBinding(using_column);
-			}
-			if (!right_using_binding) {
-				right_binder.bind_context.GetMatchingBinding(using_column);
-			}
-			left_using_bindings.push_back(left_using_binding);
-			right_using_bindings.push_back(right_using_binding);
-		}
-
-		for (idx_t i = 0; i < extra_using_columns.size(); i++) {
-			auto &using_column = extra_using_columns[i];
-			string left_binding;
-			string right_binding;
-
-			auto set = make_unique<UsingColumnSet>();
-			auto left_using_binding = left_using_bindings[i];
-			auto right_using_binding = right_using_bindings[i];
-			left_binding = RetrieveUsingBinding(left_binder, left_using_binding, using_column, "left", set.get());
-			right_binding = RetrieveUsingBinding(right_binder, right_using_binding, using_column, "right", set.get());
-
-			extra_conditions.push_back(
-			    AddCondition(context, left_binder, right_binder, left_binding, right_binding, using_column));
-
-			AddUsingBindings(*set, left_using_binding, left_binding);
-			AddUsingBindings(*set, right_using_binding, right_binding);
-			SetPrimaryBinding(*set, ref.type, left_binding, right_binding);
-			bind_context.TransferUsingBinding(left_binder.bind_context, left_using_binding, set.get(), left_binding,
-			                                  using_column);
-			bind_context.TransferUsingBinding(right_binder.bind_context, right_using_binding, set.get(), right_binding,
-			                                  using_column);
-			AddUsingBindingSet(move(set));
-		}
-	}
-
-	bind_context.AddContext(move(left_binder.bind_context));
-	bind_context.AddContext(move(right_binder.bind_context));
-	MoveCorrelatedExpressions(left_binder);
-	MoveCorrelatedExpressions(right_binder);
-	for (auto &condition : extra_conditions) {
-		if (ref.condition) {
-			ref.condition = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, move(ref.condition),
-			                                                   move(condition));
-		} else {
-			ref.condition = move(condition);
-		}
-	}
-	if (ref.condition) {
-		WhereBinder binder(*this, context);
-		result->condition = binder.Bind(ref.condition);
-	}
-	D_ASSERT(result->condition);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-void Binder::BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
-                                 QueryErrorContext &error_context, string &func_name) {
-	for (auto &kv : values) {
-		auto entry = types.find(kv.first);
-		if (entry == types.end()) {
-			// create a list of named parameters for the error
-			string named_params;
-			for (auto &kv : types) {
-				named_params += "    ";
-				named_params += kv.first;
-				named_params += " ";
-				named_params += kv.second.ToString();
-				named_params += "\n";
-			}
-			string error_msg;
-			if (named_params.empty()) {
-				error_msg = "Function does not accept any named parameters.";
-			} else {
-				error_msg = "Candidates: " + named_params;
-			}
-			throw BinderException(error_context.FormatError("Invalid named parameter \"%s\" for function %s\n%s",
-			                                                kv.first, func_name, error_msg));
-		}
-		if (entry->second.id() != LogicalTypeId::ANY) {
-			kv.second = kv.second.CastAs(entry->second);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, CommonTableExpressionInfo *cte) {
-	auto binder = Binder::CreateBinder(context, this);
-	binder->can_contain_nulls = true;
-	if (cte) {
-		binder->bound_ctes.insert(cte);
-	}
-	binder->alias = ref.alias.empty() ? "unnamed_subquery" : ref.alias;
-	auto subquery = binder->BindNode(*ref.subquery->node);
-	idx_t bind_index = subquery->GetRootIndex();
-	string alias;
-	if (ref.alias.empty()) {
-		alias = "unnamed_subquery" + to_string(bind_index);
-	} else {
-		alias = ref.alias;
-	}
-	auto result = make_unique<BoundSubqueryRef>(move(binder), move(subquery));
-	bind_context.AddSubquery(bind_index, alias, ref, *result->subquery);
-	MoveCorrelatedExpressions(*result->binder);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static bool IsTableInTableOutFunction(TableFunctionCatalogEntry &table_function) {
-	return table_function.functions.size() == 1 && table_function.functions[0].arguments.size() == 1 &&
-	       table_function.functions[0].arguments[0].id() == LogicalTypeId::TABLE;
-}
-
-bool Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
-                                         unique_ptr<BoundSubqueryRef> &subquery, string &error) {
-	auto binder = Binder::CreateBinder(this->context, this, true);
-	if (expressions.size() == 1 && expressions[0]->type == ExpressionType::SUBQUERY) {
-		// general case: argument is a subquery, bind it as part of the node
-		auto &se = (SubqueryExpression &)*expressions[0];
-		auto node = binder->BindNode(*se.subquery->node);
-		subquery = make_unique<BoundSubqueryRef>(move(binder), move(node));
-		return true;
-	}
-	// special case: non-subquery parameter to table-in table-out function
-	// generate a subquery and bind that (i.e. UNNEST([1,2,3]) becomes UNNEST((SELECT [1,2,3]))
-	auto select_node = make_unique<SelectNode>();
-	select_node->select_list = move(expressions);
-	select_node->from_table = make_unique<EmptyTableRef>();
-	auto node = binder->BindNode(*select_node);
-	subquery = make_unique<BoundSubqueryRef>(move(binder), move(node));
-	return true;
-}
-
-bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
-                                         vector<unique_ptr<ParsedExpression>> &expressions,
-                                         vector<LogicalType> &arguments, vector<Value> &parameters,
-                                         named_parameter_map_t &named_parameters,
-                                         unique_ptr<BoundSubqueryRef> &subquery, string &error) {
-	if (IsTableInTableOutFunction(table_function)) {
-		// special case binding for table-in table-out function
-		arguments.emplace_back(LogicalTypeId::TABLE);
-		return BindTableInTableOutFunction(expressions, subquery, error);
-	}
-	bool seen_subquery = false;
-	for (auto &child : expressions) {
-		string parameter_name;
-
-		// hack to make named parameters work
-		if (child->type == ExpressionType::COMPARE_EQUAL) {
-			// comparison, check if the LHS is a columnref
-			auto &comp = (ComparisonExpression &)*child;
-			if (comp.left->type == ExpressionType::COLUMN_REF) {
-				auto &colref = (ColumnRefExpression &)*comp.left;
-				if (!colref.IsQualified()) {
-					parameter_name = colref.GetColumnName();
-					child = move(comp.right);
-				}
-			}
-		}
-		if (child->type == ExpressionType::SUBQUERY) {
-			if (seen_subquery) {
-				error = "Table function can have at most one subquery parameter ";
-				return false;
-			}
-			auto binder = Binder::CreateBinder(this->context, this, true);
-			auto &se = (SubqueryExpression &)*child;
-			auto node = binder->BindNode(*se.subquery->node);
-			subquery = make_unique<BoundSubqueryRef>(move(binder), move(node));
-			seen_subquery = true;
-			arguments.emplace_back(LogicalTypeId::TABLE);
-			continue;
-		}
-
-		ConstantBinder binder(*this, context, "TABLE FUNCTION parameter");
-		LogicalType sql_type;
-		auto expr = binder.Bind(child, &sql_type);
-		if (!expr->IsFoldable()) {
-			error = "Table function requires a constant parameter";
-			return false;
-		}
-		auto constant = ExpressionExecutor::EvaluateScalar(*expr);
-		if (parameter_name.empty()) {
-			// unnamed parameter
-			if (!named_parameters.empty()) {
-				error = "Unnamed parameters cannot come after named parameters";
-				return false;
-			}
-			arguments.emplace_back(sql_type);
-			parameters.emplace_back(move(constant));
-		} else {
-			named_parameters[parameter_name] = move(constant);
-		}
-	}
-	return true;
-}
-
-unique_ptr<LogicalOperator>
-Binder::BindTableFunctionInternal(TableFunction &table_function, const string &function_name, vector<Value> parameters,
-                                  named_parameter_map_t named_parameters, vector<LogicalType> input_table_types,
-                                  vector<string> input_table_names, const vector<string> &column_name_alias,
-                                  unique_ptr<ExternalDependency> external_dependency) {
-	auto bind_index = GenerateTableIndex();
-	// perform the binding
-	unique_ptr<FunctionData> bind_data;
-	vector<LogicalType> return_types;
-	vector<string> return_names;
-	if (table_function.bind) {
-		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
-		                                  table_function.function_info.get());
-		bind_data = table_function.bind(context, bind_input, return_types, return_names);
-		if (table_function.name == "pandas_scan" || table_function.name == "arrow_scan") {
-			auto arrow_bind = (PyTableFunctionData *)bind_data.get();
-			arrow_bind->external_dependency = move(external_dependency);
-		}
-	}
-	if (return_types.size() != return_names.size()) {
-		throw InternalException(
-		    "Failed to bind \"%s\": Table function return_types and return_names must be of the same size",
-		    table_function.name);
-	}
-	if (return_types.empty()) {
-		throw InternalException("Failed to bind \"%s\": Table function must return at least one column",
-		                        table_function.name);
-	}
-	// overwrite the names with any supplied aliases
-	for (idx_t i = 0; i < column_name_alias.size() && i < return_names.size(); i++) {
-		return_names[i] = column_name_alias[i];
-	}
-	for (idx_t i = 0; i < return_names.size(); i++) {
-		if (return_names[i].empty()) {
-			return_names[i] = "C" + to_string(i);
-		}
-	}
-	auto get = make_unique<LogicalGet>(bind_index, table_function, move(bind_data), return_types, return_names);
-	// now add the table function to the bind context so its columns can be bound
-	bind_context.AddTableFunction(bind_index, function_name, return_names, return_types, *get);
-	return move(get);
-}
-
-unique_ptr<LogicalOperator> Binder::BindTableFunction(TableFunction &function, vector<Value> parameters) {
-	named_parameter_map_t named_parameters;
-	vector<LogicalType> input_table_types;
-	vector<string> input_table_names;
-	vector<string> column_name_aliases;
-	return BindTableFunctionInternal(function, function.name, move(parameters), move(named_parameters),
-	                                 move(input_table_types), move(input_table_names), column_name_aliases, nullptr);
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
-	QueryErrorContext error_context(root_statement, ref.query_location);
-
-	D_ASSERT(ref.function->type == ExpressionType::FUNCTION);
-	auto fexpr = (FunctionExpression *)ref.function.get();
-
-	TableFunctionCatalogEntry *function = nullptr;
-
-	// fetch the function from the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-
-	auto func_catalog = catalog.GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr->schema,
-	                                     fexpr->function_name, false, error_context);
-
-	if (func_catalog->type == CatalogType::TABLE_FUNCTION_ENTRY) {
-		function = (TableFunctionCatalogEntry *)func_catalog;
-	} else if (func_catalog->type == CatalogType::TABLE_MACRO_ENTRY) {
-		auto macro_func = (TableMacroCatalogEntry *)func_catalog;
-		auto query_node = BindTableMacro(*fexpr, macro_func, 0);
-		D_ASSERT(query_node);
-
-		auto binder = Binder::CreateBinder(context, this);
-		binder->can_contain_nulls = true;
-
-		binder->alias = ref.alias.empty() ? "unnamed_query" : ref.alias;
-		auto query = binder->BindNode(*query_node);
-
-		idx_t bind_index = query->GetRootIndex();
-		// string alias;
-		string alias = (ref.alias.empty() ? "unnamed_query" + to_string(bind_index) : ref.alias);
-
-		auto result = make_unique<BoundSubqueryRef>(move(binder), move(query));
-		// remember ref here is TableFunctionRef and NOT base class
-		bind_context.AddSubquery(bind_index, alias, ref, *result->subquery);
-		MoveCorrelatedExpressions(*result->binder);
-		return move(result);
-	}
-
-	// evaluate the input parameters to the function
-	vector<LogicalType> arguments;
-	vector<Value> parameters;
-	named_parameter_map_t named_parameters;
-	unique_ptr<BoundSubqueryRef> subquery;
-	string error;
-	if (!BindTableFunctionParameters(*function, fexpr->children, arguments, parameters, named_parameters, subquery,
-	                                 error)) {
-		throw BinderException(FormatError(ref, error));
-	}
-
-	// select the function based on the input parameters
-	idx_t best_function_idx = Function::BindFunction(function->name, function->functions, arguments, error);
-	if (best_function_idx == DConstants::INVALID_INDEX) {
-		throw BinderException(FormatError(ref, error));
-	}
-	auto &table_function = function->functions[best_function_idx];
-
-	// now check the named parameters
-	BindNamedParameters(table_function.named_parameters, named_parameters, error_context, table_function.name);
-
-	// cast the parameters to the type of the function
-	for (idx_t i = 0; i < arguments.size(); i++) {
-		if (table_function.arguments[i] != LogicalType::ANY && table_function.arguments[i] != LogicalType::TABLE &&
-		    table_function.arguments[i] != LogicalType::POINTER &&
-		    table_function.arguments[i].id() != LogicalTypeId::LIST) {
-			parameters[i] = parameters[i].CastAs(table_function.arguments[i]);
-		}
-	}
-
-	vector<LogicalType> input_table_types;
-	vector<string> input_table_names;
-
-	if (subquery) {
-		input_table_types = subquery->subquery->types;
-		input_table_names = subquery->subquery->names;
-	}
-	auto get = BindTableFunctionInternal(table_function, ref.alias.empty() ? fexpr->function_name : ref.alias,
-	                                     move(parameters), move(named_parameters), move(input_table_types),
-	                                     move(input_table_names), ref.column_name_alias, move(ref.external_dependency));
-	if (subquery) {
-		get->children.push_back(Binder::CreatePlan(*subquery));
-	}
-
-	return make_unique_base<BoundTableRef, BoundTableFunction>(move(get));
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundBaseTableRef &ref) {
-	return move(ref.get);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCrossProductRef &expr) {
-	auto cross_product = make_unique<LogicalCrossProduct>();
-
-	auto left = CreatePlan(*expr.left);
-	auto right = CreatePlan(*expr.right);
-
-	cross_product->AddChild(move(left));
-	cross_product->AddChild(move(right));
-
-	return move(cross_product);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTERef &ref) {
-	auto index = ref.bind_index;
-
-	vector<LogicalType> types;
-	for (auto &type : ref.types) {
-		types.push_back(type);
-	}
-
-	return make_unique<LogicalCTERef>(index, ref.cte_index, types, ref.bound_columns);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundEmptyTableRef &ref) {
-	return make_unique<LogicalDummyScan>(ref.bind_index);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundExpressionListRef &ref) {
-	auto root = make_unique_base<LogicalOperator, LogicalDummyScan>(0);
-	// values list, first plan any subqueries in the list
-	for (auto &expr_list : ref.values) {
-		for (auto &expr : expr_list) {
-			PlanSubqueries(&expr, &root);
-		}
-	}
-	// now create a LogicalExpressionGet from the set of expressions
-	// fetch the types
-	vector<LogicalType> types;
-	for (auto &expr : ref.values[0]) {
-		types.push_back(expr->return_type);
-	}
-	auto expr_get = make_unique<LogicalExpressionGet>(ref.bind_index, types, move(ref.values));
-	expr_get->AddChild(move(root));
-	return move(expr_get);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Create a JoinCondition from a comparison
-static bool CreateJoinCondition(Expression &expr, unordered_set<idx_t> &left_bindings,
-                                unordered_set<idx_t> &right_bindings, vector<JoinCondition> &conditions) {
-	// comparison
-	auto &comparison = (BoundComparisonExpression &)expr;
-	auto left_side = JoinSide::GetJoinSide(*comparison.left, left_bindings, right_bindings);
-	auto right_side = JoinSide::GetJoinSide(*comparison.right, left_bindings, right_bindings);
-	if (left_side != JoinSide::BOTH && right_side != JoinSide::BOTH) {
-		// join condition can be divided in a left/right side
-		JoinCondition condition;
-		condition.comparison = expr.type;
-		auto left = move(comparison.left);
-		auto right = move(comparison.right);
-		if (left_side == JoinSide::RIGHT) {
-			// left = right, right = left, flip the comparison symbol and reverse sides
-			swap(left, right);
-			condition.comparison = FlipComparisionExpression(expr.type);
-		}
-		condition.left = move(left);
-		condition.right = move(right);
-		conditions.push_back(move(condition));
-		return true;
-	}
-	return false;
-}
-
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, unique_ptr<LogicalOperator> left_child,
-                                                              unique_ptr<LogicalOperator> right_child,
-                                                              unordered_set<idx_t> &left_bindings,
-                                                              unordered_set<idx_t> &right_bindings,
-                                                              vector<unique_ptr<Expression>> &expressions) {
-	vector<JoinCondition> conditions;
-	vector<unique_ptr<Expression>> arbitrary_expressions;
-	// first check if we can create
-	for (auto &expr : expressions) {
-		auto total_side = JoinSide::GetJoinSide(*expr, left_bindings, right_bindings);
-		if (total_side != JoinSide::BOTH) {
-			// join condition does not reference both sides, add it as filter under the join
-			if (type == JoinType::LEFT && total_side == JoinSide::RIGHT) {
-				// filter is on RHS and the join is a LEFT OUTER join, we can push it in the right child
-				if (right_child->type != LogicalOperatorType::LOGICAL_FILTER) {
-					// not a filter yet, push a new empty filter
-					auto filter = make_unique<LogicalFilter>();
-					filter->AddChild(move(right_child));
-					right_child = move(filter);
-				}
-				// push the expression into the filter
-				auto &filter = (LogicalFilter &)*right_child;
-				filter.expressions.push_back(move(expr));
-				continue;
-			}
-		} else if ((expr->type >= ExpressionType::COMPARE_EQUAL &&
-		            expr->type <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) ||
-		           expr->type == ExpressionType::COMPARE_DISTINCT_FROM ||
-		           expr->type == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			// comparison, check if we can create a comparison JoinCondition
-			if (CreateJoinCondition(*expr, left_bindings, right_bindings, conditions)) {
-				// successfully created the join condition
-				continue;
-			}
-		}
-		arbitrary_expressions.push_back(move(expr));
-	}
-	bool need_to_consider_arbitrary_expressions = true;
-	if (type == JoinType::INNER) {
-		// for inner joins we can push arbitrary expressions as a filter
-		// here we prefer to create a comparison join if possible
-		// that way we can use the much faster hash join to process the main join
-		// rather than doing a nested loop join to handle arbitrary expressions
-
-		// for left and full outer joins we HAVE to process all join conditions
-		// because pushing a filter will lead to an incorrect result, as non-matching tuples cannot be filtered out
-		need_to_consider_arbitrary_expressions = false;
-	}
-	if ((need_to_consider_arbitrary_expressions && !arbitrary_expressions.empty()) || conditions.empty()) {
-		if (arbitrary_expressions.empty()) {
-			// all conditions were pushed down, add TRUE predicate
-			arbitrary_expressions.push_back(make_unique<BoundConstantExpression>(Value::BOOLEAN(true)));
-		}
-		for (auto &condition : conditions) {
-			arbitrary_expressions.push_back(JoinCondition::CreateExpression(move(condition)));
-		}
-		// if we get here we could not create any JoinConditions
-		// turn this into an arbitrary expression join
-		auto any_join = make_unique<LogicalAnyJoin>(type);
-		// create the condition
-		any_join->children.push_back(move(left_child));
-		any_join->children.push_back(move(right_child));
-		// AND all the arbitrary expressions together
-		// do the same with any remaining conditions
-		any_join->condition = move(arbitrary_expressions[0]);
-		for (idx_t i = 1; i < arbitrary_expressions.size(); i++) {
-			any_join->condition = make_unique<BoundConjunctionExpression>(
-			    ExpressionType::CONJUNCTION_AND, move(any_join->condition), move(arbitrary_expressions[i]));
-		}
-		return move(any_join);
-	} else {
-		// we successfully converted expressions into JoinConditions
-		// create a LogicalComparisonJoin
-		auto comp_join = make_unique<LogicalComparisonJoin>(type);
-		comp_join->conditions = move(conditions);
-		comp_join->children.push_back(move(left_child));
-		comp_join->children.push_back(move(right_child));
-		if (!arbitrary_expressions.empty()) {
-			// we have some arbitrary expressions as well
-			// add them to a filter
-			auto filter = make_unique<LogicalFilter>();
-			for (auto &expr : arbitrary_expressions) {
-				filter->expressions.push_back(move(expr));
-			}
-			LogicalFilter::SplitPredicates(filter->expressions);
-			filter->children.push_back(move(comp_join));
-			return move(filter);
-		}
-		return move(comp_join);
-	}
-}
-
-static bool HasCorrelatedColumns(Expression &expression) {
-	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expression;
-		if (colref.depth > 0) {
-			return true;
-		}
-	}
-	bool has_correlated_columns = false;
-	ExpressionIterator::EnumerateChildren(expression, [&](Expression &child) {
-		if (HasCorrelatedColumns(child)) {
-			has_correlated_columns = true;
-		}
-	});
-	return has_correlated_columns;
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
-	auto left = CreatePlan(*ref.left);
-	auto right = CreatePlan(*ref.right);
-	if (ref.type == JoinType::RIGHT && ClientConfig::GetConfig(context).enable_optimizer) {
-		// we turn any right outer joins into left outer joins for optimization purposes
-		// they are the same but with sides flipped, so treating them the same simplifies life
-		ref.type = JoinType::LEFT;
-		std::swap(left, right);
-	}
-	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition))) {
-		// inner join, generate a cross product + filter
-		// this will be later turned into a proper join by the join order optimizer
-		auto cross_product = make_unique<LogicalCrossProduct>();
-
-		cross_product->AddChild(move(left));
-		cross_product->AddChild(move(right));
-
-		unique_ptr<LogicalOperator> root = move(cross_product);
-
-		auto filter = make_unique<LogicalFilter>(move(ref.condition));
-		// visit the expressions in the filter
-		for (auto &expression : filter->expressions) {
-			PlanSubqueries(&expression, &root);
-		}
-		filter->AddChild(move(root));
-		return move(filter);
-	}
-
-	// split the expressions by the AND clause
-	vector<unique_ptr<Expression>> expressions;
-	expressions.push_back(move(ref.condition));
-	LogicalFilter::SplitPredicates(expressions);
-
-	// find the table bindings on the LHS and RHS of the join
-	unordered_set<idx_t> left_bindings, right_bindings;
-	LogicalJoin::GetTableReferences(*left, left_bindings);
-	LogicalJoin::GetTableReferences(*right, right_bindings);
-	// now create the join operator from the set of join conditions
-	auto result = LogicalComparisonJoin::CreateJoin(ref.type, move(left), move(right), left_bindings, right_bindings,
-	                                                expressions);
-
-	LogicalOperator *join;
-	if (result->type == LogicalOperatorType::LOGICAL_FILTER) {
-		join = result->children[0].get();
-	} else {
-		join = result.get();
-	}
-	for (auto &child : join->children) {
-		if (child->type == LogicalOperatorType::LOGICAL_FILTER) {
-			auto &filter = (LogicalFilter &)*child;
-			for (auto &expr : filter.expressions) {
-				PlanSubqueries(&expr, &filter.children[0]);
-			}
-		}
-	}
-
-	// we visit the expressions depending on the type of join
-	if (join->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		// comparison join
-		// in this join we visit the expressions on the LHS with the LHS as root node
-		// and the expressions on the RHS with the RHS as root node
-		auto &comp_join = (LogicalComparisonJoin &)*join;
-		for (idx_t i = 0; i < comp_join.conditions.size(); i++) {
-			PlanSubqueries(&comp_join.conditions[i].left, &comp_join.children[0]);
-			PlanSubqueries(&comp_join.conditions[i].right, &comp_join.children[1]);
-		}
-	} else if (join->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
-		auto &any_join = (LogicalAnyJoin &)*join;
-		// for the any join we just visit the condition
-		if (any_join.condition->HasSubquery()) {
-			throw NotImplementedException("Cannot perform non-inner join on subquery!");
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSubqueryRef &ref) {
-	// generate the logical plan for the subquery
-	// this happens separately from the current LogicalPlan generation
-	ref.binder->plan_subquery = plan_subquery;
-	auto subquery = ref.binder->CreatePlan(*ref.subquery);
-	if (ref.binder->has_unplanned_subqueries) {
-		has_unplanned_subqueries = true;
-	}
-	return subquery;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
-	return move(ref.get);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, Binder *parent, bool inherit_ctes) {
-	return make_shared<Binder>(true, context, parent ? parent->shared_from_this() : nullptr, inherit_ctes);
-}
-
-Binder::Binder(bool, ClientContext &context, shared_ptr<Binder> parent_p, bool inherit_ctes_p)
-    : context(context), parent(move(parent_p)), bound_tables(0), inherit_ctes(inherit_ctes_p) {
-	parameters = nullptr;
-	parameter_types = nullptr;
-	if (parent) {
-		// We have to inherit macro parameter bindings from the parent binder, if there is a parent.
-		macro_binding = parent->macro_binding;
-		if (inherit_ctes) {
-			// We have to inherit CTE bindings from the parent bind_context, if there is a parent.
-			bind_context.SetCTEBindings(parent->bind_context.GetCTEBindings());
-			bind_context.cte_references = parent->bind_context.cte_references;
-			parameters = parent->parameters;
-			parameter_types = parent->parameter_types;
-		}
-	}
-}
-
-BoundStatement Binder::Bind(SQLStatement &statement) {
-	root_statement = &statement;
-	switch (statement.type) {
-	case StatementType::SELECT_STATEMENT:
-		return Bind((SelectStatement &)statement);
-	case StatementType::INSERT_STATEMENT:
-		return Bind((InsertStatement &)statement);
-	case StatementType::COPY_STATEMENT:
-		return Bind((CopyStatement &)statement);
-	case StatementType::DELETE_STATEMENT:
-		return Bind((DeleteStatement &)statement);
-	case StatementType::UPDATE_STATEMENT:
-		return Bind((UpdateStatement &)statement);
-	case StatementType::RELATION_STATEMENT:
-		return Bind((RelationStatement &)statement);
-	case StatementType::CREATE_STATEMENT:
-		return Bind((CreateStatement &)statement);
-	case StatementType::DROP_STATEMENT:
-		return Bind((DropStatement &)statement);
-	case StatementType::ALTER_STATEMENT:
-		return Bind((AlterStatement &)statement);
-	case StatementType::TRANSACTION_STATEMENT:
-		return Bind((TransactionStatement &)statement);
-	case StatementType::PRAGMA_STATEMENT:
-		return Bind((PragmaStatement &)statement);
-	case StatementType::EXPLAIN_STATEMENT:
-		return Bind((ExplainStatement &)statement);
-	case StatementType::VACUUM_STATEMENT:
-		return Bind((VacuumStatement &)statement);
-	case StatementType::SHOW_STATEMENT:
-		return Bind((ShowStatement &)statement);
-	case StatementType::CALL_STATEMENT:
-		return Bind((CallStatement &)statement);
-	case StatementType::EXPORT_STATEMENT:
-		return Bind((ExportStatement &)statement);
-	case StatementType::SET_STATEMENT:
-		return Bind((SetStatement &)statement);
-	case StatementType::LOAD_STATEMENT:
-		return Bind((LoadStatement &)statement);
-	case StatementType::EXTENSION_STATEMENT:
-		return Bind((ExtensionStatement &)statement);
-	default: // LCOV_EXCL_START
-		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
-		                              StatementTypeToString(statement.type));
-	} // LCOV_EXCL_STOP
-}
-
-void Binder::AddCTEMap(CommonTableExpressionMap &cte_map) {
-	for (auto &cte_it : cte_map.map) {
-		AddCTE(cte_it.first, cte_it.second.get());
-	}
-}
-
-unique_ptr<BoundQueryNode> Binder::BindNode(QueryNode &node) {
-	// first we visit the set of CTEs and add them to the bind context
-	AddCTEMap(node.cte_map);
-	// now we bind the node
-	unique_ptr<BoundQueryNode> result;
-	switch (node.type) {
-	case QueryNodeType::SELECT_NODE:
-		result = BindNode((SelectNode &)node);
-		break;
-	case QueryNodeType::RECURSIVE_CTE_NODE:
-		result = BindNode((RecursiveCTENode &)node);
-		break;
-	default:
-		D_ASSERT(node.type == QueryNodeType::SET_OPERATION_NODE);
-		result = BindNode((SetOperationNode &)node);
-		break;
-	}
-	return result;
-}
-
-BoundStatement Binder::Bind(QueryNode &node) {
-	auto bound_node = BindNode(node);
-
-	BoundStatement result;
-	result.names = bound_node->names;
-	result.types = bound_node->types;
-
-	// and plan it
-	result.plan = CreatePlan(*bound_node);
-	return result;
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundQueryNode &node) {
-	switch (node.type) {
-	case QueryNodeType::SELECT_NODE:
-		return CreatePlan((BoundSelectNode &)node);
-	case QueryNodeType::SET_OPERATION_NODE:
-		return CreatePlan((BoundSetOperationNode &)node);
-	case QueryNodeType::RECURSIVE_CTE_NODE:
-		return CreatePlan((BoundRecursiveCTENode &)node);
-	default:
-		throw InternalException("Unsupported bound query node type");
-	}
-}
-
-unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
-	unique_ptr<BoundTableRef> result;
-	switch (ref.type) {
-	case TableReferenceType::BASE_TABLE:
-		result = Bind((BaseTableRef &)ref);
-		break;
-	case TableReferenceType::CROSS_PRODUCT:
-		result = Bind((CrossProductRef &)ref);
-		break;
-	case TableReferenceType::JOIN:
-		result = Bind((JoinRef &)ref);
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = Bind((SubqueryRef &)ref);
-		break;
-	case TableReferenceType::EMPTY:
-		result = Bind((EmptyTableRef &)ref);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = Bind((TableFunctionRef &)ref);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = Bind((ExpressionListRef &)ref);
-		break;
-	default:
-		throw InternalException("Unknown table ref type");
-	}
-	result->sample = move(ref.sample);
-	return result;
-}
-
-unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
-	unique_ptr<LogicalOperator> root;
-	switch (ref.type) {
-	case TableReferenceType::BASE_TABLE:
-		root = CreatePlan((BoundBaseTableRef &)ref);
-		break;
-	case TableReferenceType::SUBQUERY:
-		root = CreatePlan((BoundSubqueryRef &)ref);
-		break;
-	case TableReferenceType::JOIN:
-		root = CreatePlan((BoundJoinRef &)ref);
-		break;
-	case TableReferenceType::CROSS_PRODUCT:
-		root = CreatePlan((BoundCrossProductRef &)ref);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		root = CreatePlan((BoundTableFunction &)ref);
-		break;
-	case TableReferenceType::EMPTY:
-		root = CreatePlan((BoundEmptyTableRef &)ref);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		root = CreatePlan((BoundExpressionListRef &)ref);
-		break;
-	case TableReferenceType::CTE:
-		root = CreatePlan((BoundCTERef &)ref);
-		break;
-	default:
-		throw InternalException("Unsupported bound table ref type type");
-	}
-	// plan the sample clause
-	if (ref.sample) {
-		root = make_unique<LogicalSample>(move(ref.sample), move(root));
-	}
-	return root;
-}
-
-void Binder::AddCTE(const string &name, CommonTableExpressionInfo *info) {
-	D_ASSERT(info);
-	D_ASSERT(!name.empty());
-	auto entry = CTE_bindings.find(name);
-	if (entry != CTE_bindings.end()) {
-		throw InternalException("Duplicate CTE \"%s\" in query!", name);
-	}
-	CTE_bindings[name] = info;
-}
-
-CommonTableExpressionInfo *Binder::FindCTE(const string &name, bool skip) {
-	auto entry = CTE_bindings.find(name);
-	if (entry != CTE_bindings.end()) {
-		if (!skip || entry->second->query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
-			return entry->second;
-		}
-	}
-	if (parent && inherit_ctes) {
-		return parent->FindCTE(name, name == alias);
-	}
-	return nullptr;
-}
-
-bool Binder::CTEIsAlreadyBound(CommonTableExpressionInfo *cte) {
-	if (bound_ctes.find(cte) != bound_ctes.end()) {
-		return true;
-	}
-	if (parent && inherit_ctes) {
-		return parent->CTEIsAlreadyBound(cte);
-	}
-	return false;
-}
-
-void Binder::AddBoundView(ViewCatalogEntry *view) {
-	// check if the view is already bound
-	auto current = this;
-	while (current) {
-		if (current->bound_views.find(view) != current->bound_views.end()) {
-			throw BinderException("infinite recursion detected: attempting to recursively bind view \"%s\"",
-			                      view->name);
-		}
-		current = current->parent.get();
-	}
-	bound_views.insert(view);
-}
-
-idx_t Binder::GenerateTableIndex() {
-	if (parent) {
-		return parent->GenerateTableIndex();
-	}
-	return bound_tables++;
-}
-
-void Binder::PushExpressionBinder(ExpressionBinder *binder) {
-	GetActiveBinders().push_back(binder);
-}
-
-void Binder::PopExpressionBinder() {
-	D_ASSERT(HasActiveBinder());
-	GetActiveBinders().pop_back();
-}
-
-void Binder::SetActiveBinder(ExpressionBinder *binder) {
-	D_ASSERT(HasActiveBinder());
-	GetActiveBinders().back() = binder;
-}
-
-ExpressionBinder *Binder::GetActiveBinder() {
-	return GetActiveBinders().back();
-}
-
-bool Binder::HasActiveBinder() {
-	return !GetActiveBinders().empty();
-}
-
-vector<ExpressionBinder *> &Binder::GetActiveBinders() {
-	if (parent) {
-		return parent->GetActiveBinders();
-	}
-	return active_binders;
-}
-
-void Binder::AddUsingBindingSet(unique_ptr<UsingColumnSet> set) {
-	if (parent) {
-		parent->AddUsingBindingSet(move(set));
-		return;
-	}
-	bind_context.AddUsingBindingSet(move(set));
-}
-
-void Binder::MoveCorrelatedExpressions(Binder &other) {
-	MergeCorrelatedColumns(other.correlated_columns);
-	other.correlated_columns.clear();
-}
-
-void Binder::MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other) {
-	for (idx_t i = 0; i < other.size(); i++) {
-		AddCorrelatedColumn(other[i]);
-	}
-}
-
-void Binder::AddCorrelatedColumn(const CorrelatedColumnInfo &info) {
-	// we only add correlated columns to the list if they are not already there
-	if (std::find(correlated_columns.begin(), correlated_columns.end(), info) == correlated_columns.end()) {
-		correlated_columns.push_back(info);
-	}
-}
-
-bool Binder::HasMatchingBinding(const string &table_name, const string &column_name, string &error_message) {
-	string empty_schema;
-	return HasMatchingBinding(empty_schema, table_name, column_name, error_message);
-}
-
-bool Binder::HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
-                                string &error_message) {
-	Binding *binding;
-	if (macro_binding && table_name == macro_binding->alias) {
-		binding = macro_binding;
-	} else {
-		binding = bind_context.GetBinding(table_name, error_message);
-	}
-	if (!binding) {
-		return false;
-	}
-	if (!schema_name.empty()) {
-		auto catalog_entry = binding->GetStandardEntry();
-		if (!catalog_entry) {
-			return false;
-		}
-		if (catalog_entry->schema->name != schema_name || catalog_entry->name != table_name) {
-			return false;
-		}
-	}
-	bool binding_found;
-	binding_found = binding->HasMatchingBinding(column_name);
-	if (!binding_found) {
-		error_message = binding->ColumnNotFoundError(column_name);
-	}
-	return binding_found;
-}
-
-void Binder::SetBindingMode(BindingMode mode) {
-	if (parent) {
-		parent->SetBindingMode(mode);
-	}
-	this->mode = mode;
-}
-
-BindingMode Binder::GetBindingMode() {
-	if (parent) {
-		return parent->GetBindingMode();
-	}
-	return mode;
-}
-
-void Binder::AddTableName(string table_name) {
-	if (parent) {
-		parent->AddTableName(move(table_name));
-		return;
-	}
-	table_names.insert(move(table_name));
-}
-
-const unordered_set<string> &Binder::GetTableNames() {
-	if (parent) {
-		return parent->GetTableNames();
-	}
-	return table_names;
-}
-
-void Binder::RemoveParameters(vector<unique_ptr<Expression>> &expressions) {
-	for (auto &expr : expressions) {
-		if (!expr->HasParameter()) {
-			continue;
-		}
-		ExpressionIterator::EnumerateExpression(expr, [&](Expression &child) {
-			for (auto param_it = parameters->begin(); param_it != parameters->end(); param_it++) {
-				if (expr->Equals(*param_it)) {
-					parameters->erase(param_it);
-					break;
-				}
-			}
-		});
-	}
-}
-
-string Binder::FormatError(ParsedExpression &expr_context, const string &message) {
-	return FormatError(expr_context.query_location, message);
-}
-
-string Binder::FormatError(TableRef &ref_context, const string &message) {
-	return FormatError(ref_context.query_location, message);
-}
-
-string Binder::FormatErrorRecursive(idx_t query_location, const string &message, vector<ExceptionFormatValue> &values) {
-	QueryErrorContext context(root_statement, query_location);
-	return context.FormatErrorRecursive(message, values);
-}
-
-BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
-                                     idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
-                                     BoundStatement result) {
-
-	vector<LogicalType> types;
-	vector<std::string> names;
-
-	auto binder = Binder::CreateBinder(context);
-
-	for (auto &col : table->columns) {
-		names.push_back(col.Name());
-		types.push_back(col.Type());
-	}
-
-	binder->bind_context.AddGenericBinding(update_table_index, table->name, names, types);
-	ReturningBinder returning_binder(*binder, context);
-
-	vector<unique_ptr<Expression>> projection_expressions;
-	LogicalType result_type;
-	for (auto &returning_expr : returning_list) {
-		auto expr_type = returning_expr->GetExpressionType();
-		if (expr_type == ExpressionType::STAR) {
-			auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
-			binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr, generated_star_list);
-
-			for (auto &star_column : generated_star_list) {
-				auto star_expr = returning_binder.Bind(star_column, &result_type);
-				result.types.push_back(result_type);
-				result.names.push_back(star_expr->GetName());
-				projection_expressions.push_back(move(star_expr));
-			}
-		} else {
-			auto expr = returning_binder.Bind(returning_expr, &result_type);
-			result.names.push_back(expr->GetName());
-			result.types.push_back(result_type);
-			projection_expressions.push_back(move(expr));
-		}
-	}
-
-	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(projection_expressions));
-	projection->AddChild(move(child_operator));
-	D_ASSERT(result.types.size() == result.names.size());
-	result.plan = move(projection);
-	properties.allow_stream_result = true;
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-BoundResultModifier::BoundResultModifier(ResultModifierType type) : type(type) {
-}
-
-BoundResultModifier::~BoundResultModifier() {
-}
-
-BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression)
-    : type(type), null_order(null_order), expression(move(expression)) {
-}
-BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression,
-                                   unique_ptr<BaseStatistics> stats)
-    : type(type), null_order(null_order), expression(move(expression)), stats(move(stats)) {
-}
-
-BoundOrderByNode BoundOrderByNode::Copy() const {
-	if (stats) {
-		return BoundOrderByNode(type, null_order, expression->Copy(), stats->Copy());
-	} else {
-		return BoundOrderByNode(type, null_order, expression->Copy());
-	}
-}
-
-string BoundOrderByNode::ToString() const {
-	auto str = expression->ToString();
-	switch (type) {
-	case OrderType::ASCENDING:
-		str += " ASC";
-		break;
-	case OrderType::DESCENDING:
-		str += " DESC";
-		break;
-	default:
-		break;
-	}
-
-	switch (null_order) {
-	case OrderByNullType::NULLS_FIRST:
-		str += " NULLS FIRST";
-		break;
-	case OrderByNullType::NULLS_LAST:
-		str += " NULLS LAST";
-		break;
-	default:
-		break;
-	}
-	return str;
-}
-
-BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
-}
-
-BoundOrderModifier::BoundOrderModifier() : BoundResultModifier(ResultModifierType::ORDER_MODIFIER) {
-}
-
-BoundDistinctModifier::BoundDistinctModifier() : BoundResultModifier(ResultModifierType::DISTINCT_MODIFIER) {
-}
-
-BoundLimitPercentModifier::BoundLimitPercentModifier()
-    : BoundResultModifier(ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-BoundAggregateExpression::BoundAggregateExpression(AggregateFunction function, vector<unique_ptr<Expression>> children,
-                                                   unique_ptr<Expression> filter, unique_ptr<FunctionData> bind_info,
-                                                   bool distinct)
-    : Expression(ExpressionType::BOUND_AGGREGATE, ExpressionClass::BOUND_AGGREGATE, function.return_type),
-      function(move(function)), children(move(children)), bind_info(move(bind_info)), distinct(distinct),
-      filter(move(filter)) {
-	D_ASSERT(!function.name.empty());
-}
-
-string BoundAggregateExpression::ToString() const {
-	return FunctionExpression::ToString<BoundAggregateExpression, Expression>(*this, string(), function.name, false,
-	                                                                          distinct, filter.get());
-}
-
-hash_t BoundAggregateExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	result = CombineHash(result, function.Hash());
-	result = CombineHash(result, duckdb::Hash(distinct));
-	return result;
-}
-
-bool BoundAggregateExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundAggregateExpression *)other_p;
-	if (other->distinct != distinct) {
-		return false;
-	}
-	if (other->function != function) {
-		return false;
-	}
-	if (children.size() != other->children.size()) {
-		return false;
-	}
-	if (!Expression::Equals(other->filter.get(), filter.get())) {
-		return false;
-	}
-	for (idx_t i = 0; i < children.size(); i++) {
-		if (!Expression::Equals(children[i].get(), other->children[i].get())) {
-			return false;
-		}
-	}
-	if (!FunctionData::Equals(bind_info.get(), other->bind_info.get())) {
-		return false;
-	}
-	return true;
-}
-
-bool BoundAggregateExpression::PropagatesNullValues() const {
-	return !function.propagates_null_values ? false : Expression::PropagatesNullValues();
-}
-
-unique_ptr<Expression> BoundAggregateExpression::Copy() {
-	vector<unique_ptr<Expression>> new_children;
-	for (auto &child : children) {
-		new_children.push_back(child->Copy());
-	}
-	auto new_bind_info = bind_info ? bind_info->Copy() : nullptr;
-	auto new_filter = filter ? filter->Copy() : nullptr;
-	auto copy = make_unique<BoundAggregateExpression>(function, move(new_children), move(new_filter),
-	                                                  move(new_bind_info), distinct);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-BoundBetweenExpression::BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower,
-                                               unique_ptr<Expression> upper, bool lower_inclusive, bool upper_inclusive)
-    : Expression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BOUND_BETWEEN, LogicalType::BOOLEAN),
-      input(move(input)), lower(move(lower)), upper(move(upper)), lower_inclusive(lower_inclusive),
-      upper_inclusive(upper_inclusive) {
-}
-
-string BoundBetweenExpression::ToString() const {
-	return BetweenExpression::ToString<BoundBetweenExpression, Expression>(*this);
-}
-
-bool BoundBetweenExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundBetweenExpression *)other_p;
-	if (!Expression::Equals(input.get(), other->input.get())) {
-		return false;
-	}
-	if (!Expression::Equals(lower.get(), other->lower.get())) {
-		return false;
-	}
-	if (!Expression::Equals(upper.get(), other->upper.get())) {
-		return false;
-	}
-	return lower_inclusive == other->lower_inclusive && upper_inclusive == other->upper_inclusive;
-}
-
-unique_ptr<Expression> BoundBetweenExpression::Copy() {
-	auto copy = make_unique<BoundBetweenExpression>(input->Copy(), lower->Copy(), upper->Copy(), lower_inclusive,
-	                                                upper_inclusive);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-BoundCaseExpression::BoundCaseExpression(LogicalType type)
-    : Expression(ExpressionType::CASE_EXPR, ExpressionClass::BOUND_CASE, move(type)) {
-}
-
-BoundCaseExpression::BoundCaseExpression(unique_ptr<Expression> when_expr, unique_ptr<Expression> then_expr,
-                                         unique_ptr<Expression> else_expr_p)
-    : Expression(ExpressionType::CASE_EXPR, ExpressionClass::BOUND_CASE, then_expr->return_type),
-      else_expr(move(else_expr_p)) {
-	BoundCaseCheck check;
-	check.when_expr = move(when_expr);
-	check.then_expr = move(then_expr);
-	case_checks.push_back(move(check));
-}
-
-string BoundCaseExpression::ToString() const {
-	return CaseExpression::ToString<BoundCaseExpression, Expression>(*this);
-}
-
-bool BoundCaseExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto &other = (BoundCaseExpression &)*other_p;
-	if (case_checks.size() != other.case_checks.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < case_checks.size(); i++) {
-		if (!Expression::Equals(case_checks[i].when_expr.get(), other.case_checks[i].when_expr.get())) {
-			return false;
-		}
-		if (!Expression::Equals(case_checks[i].then_expr.get(), other.case_checks[i].then_expr.get())) {
-			return false;
-		}
-	}
-	if (!Expression::Equals(else_expr.get(), other.else_expr.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundCaseExpression::Copy() {
-	auto new_case = make_unique<BoundCaseExpression>(return_type);
-	for (auto &check : case_checks) {
-		BoundCaseCheck new_check;
-		new_check.when_expr = check.when_expr->Copy();
-		new_check.then_expr = check.then_expr->Copy();
-		new_case->case_checks.push_back(move(new_check));
-	}
-	new_case->else_expr = else_expr->Copy();
-
-	new_case->CopyProperties(*this);
-	return move(new_case);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundCastExpression::BoundCastExpression(unique_ptr<Expression> child_p, LogicalType target_type_p, bool try_cast_p)
-    : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, move(target_type_p)), child(move(child_p)),
-      try_cast(try_cast_p) {
-}
-
-unique_ptr<Expression> BoundCastExpression::AddCastToType(unique_ptr<Expression> expr, const LogicalType &target_type,
-                                                          bool try_cast) {
-	D_ASSERT(expr);
-	if (expr->expression_class == ExpressionClass::BOUND_PARAMETER) {
-		auto &parameter = (BoundParameterExpression &)*expr;
-		parameter.return_type = target_type;
-	} else if (expr->expression_class == ExpressionClass::BOUND_DEFAULT) {
-		auto &def = (BoundDefaultExpression &)*expr;
-		def.return_type = target_type;
-	} else if (expr->return_type != target_type) {
-		auto &expr_type = expr->return_type;
-		if (target_type.id() == LogicalTypeId::LIST && expr_type.id() == LogicalTypeId::LIST) {
-			auto &target_list = ListType::GetChildType(target_type);
-			auto &expr_list = ListType::GetChildType(expr_type);
-			if (target_list.id() == LogicalTypeId::ANY || expr_list == target_list) {
-				return expr;
-			}
-		}
-		return make_unique<BoundCastExpression>(move(expr), target_type, try_cast);
-	}
-	return expr;
-}
-
-bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type) {
-	if (source_type.id() == LogicalTypeId::BOOLEAN || target_type.id() == LogicalTypeId::BOOLEAN) {
-		return false;
-	}
-	if (source_type.id() == LogicalTypeId::FLOAT || target_type.id() == LogicalTypeId::FLOAT) {
-		return false;
-	}
-	if (source_type.id() == LogicalTypeId::DOUBLE || target_type.id() == LogicalTypeId::DOUBLE) {
-		return false;
-	}
-	if (source_type.id() == LogicalTypeId::DECIMAL || target_type.id() == LogicalTypeId::DECIMAL) {
-		uint8_t source_width, target_width;
-		uint8_t source_scale, target_scale;
-		// cast to or from decimal
-		// cast is only invertible if the cast is strictly widening
-		if (!source_type.GetDecimalProperties(source_width, source_scale)) {
-			return false;
-		}
-		if (!target_type.GetDecimalProperties(target_width, target_scale)) {
-			return false;
-		}
-		if (target_scale < source_scale) {
-			return false;
-		}
-		return true;
-	}
-	if (source_type.id() == LogicalTypeId::TIMESTAMP || source_type.id() == LogicalTypeId::TIMESTAMP_TZ) {
-		switch (target_type.id()) {
-		case LogicalTypeId::DATE:
-		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIME_TZ:
-			return false;
-		default:
-			break;
-		}
-	}
-	if (source_type.id() == LogicalTypeId::VARCHAR) {
-		switch (target_type.id()) {
-		case LogicalTypeId::DATE:
-		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIME_TZ:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			return true;
-		default:
-			return false;
-		}
-	}
-	if (target_type.id() == LogicalTypeId::VARCHAR) {
-		switch (source_type.id()) {
-		case LogicalTypeId::DATE:
-		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIME_TZ:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			return true;
-		default:
-			return false;
-		}
-	}
-	return true;
-}
-
-string BoundCastExpression::ToString() const {
-	return (try_cast ? "TRY_CAST(" : "CAST(") + child->GetName() + " AS " + return_type.ToString() + ")";
-}
-
-bool BoundCastExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundCastExpression *)other_p;
-	if (!Expression::Equals(child.get(), other->child.get())) {
-		return false;
-	}
-	if (try_cast != other->try_cast) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundCastExpression::Copy() {
-	auto copy = make_unique<BoundCastExpression>(child->Copy(), return_type, try_cast);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-BoundColumnRefExpression::BoundColumnRefExpression(string alias_p, LogicalType type, ColumnBinding binding, idx_t depth)
-    : Expression(ExpressionType::BOUND_COLUMN_REF, ExpressionClass::BOUND_COLUMN_REF, move(type)), binding(binding),
-      depth(depth) {
-	this->alias = move(alias_p);
-}
-
-BoundColumnRefExpression::BoundColumnRefExpression(LogicalType type, ColumnBinding binding, idx_t depth)
-    : BoundColumnRefExpression(string(), move(type), binding, depth) {
-}
-
-unique_ptr<Expression> BoundColumnRefExpression::Copy() {
-	return make_unique<BoundColumnRefExpression>(alias, return_type, binding, depth);
-}
-
-hash_t BoundColumnRefExpression::Hash() const {
-	auto result = Expression::Hash();
-	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.column_index));
-	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.table_index));
-	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
-}
-
-bool BoundColumnRefExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundColumnRefExpression *)other_p;
-	return other->binding == binding && other->depth == depth;
-}
-
-string BoundColumnRefExpression::ToString() const {
-	if (!alias.empty()) {
-		return alias;
-	}
-	return "#[" + to_string(binding.table_index) + "." + to_string(binding.column_index) + "]";
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-BoundComparisonExpression::BoundComparisonExpression(ExpressionType type, unique_ptr<Expression> left,
-                                                     unique_ptr<Expression> right)
-    : Expression(type, ExpressionClass::BOUND_COMPARISON, LogicalType::BOOLEAN), left(move(left)), right(move(right)) {
-}
-
-string BoundComparisonExpression::ToString() const {
-	return ComparisonExpression::ToString<BoundComparisonExpression, Expression>(*this);
-}
-
-bool BoundComparisonExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundComparisonExpression *)other_p;
-	if (!Expression::Equals(left.get(), other->left.get())) {
-		return false;
-	}
-	if (!Expression::Equals(right.get(), other->right.get())) {
-		return false;
-	}
-
-	return true;
-}
-
-unique_ptr<Expression> BoundComparisonExpression::Copy() {
-	auto copy = make_unique<BoundComparisonExpression>(type, left->Copy(), right->Copy());
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundConjunctionExpression::BoundConjunctionExpression(ExpressionType type)
-    : Expression(type, ExpressionClass::BOUND_CONJUNCTION, LogicalType::BOOLEAN) {
-}
-
-BoundConjunctionExpression::BoundConjunctionExpression(ExpressionType type, unique_ptr<Expression> left,
-                                                       unique_ptr<Expression> right)
-    : BoundConjunctionExpression(type) {
-	children.push_back(move(left));
-	children.push_back(move(right));
-}
-
-string BoundConjunctionExpression::ToString() const {
-	return ConjunctionExpression::ToString<BoundConjunctionExpression, Expression>(*this);
-}
-
-bool BoundConjunctionExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundConjunctionExpression *)other_p;
-	return ExpressionUtil::SetEquals(children, other->children);
-}
-
-bool BoundConjunctionExpression::PropagatesNullValues() const {
-	return false;
-}
-
-unique_ptr<Expression> BoundConjunctionExpression::Copy() {
-	auto copy = make_unique<BoundConjunctionExpression>(type);
-	for (auto &expr : children) {
-		copy->children.push_back(expr->Copy());
-	}
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-BoundConstantExpression::BoundConstantExpression(Value value_p)
-    : Expression(ExpressionType::VALUE_CONSTANT, ExpressionClass::BOUND_CONSTANT, value_p.type()),
-      value(move(value_p)) {
-}
-
-string BoundConstantExpression::ToString() const {
-	return value.ToSQLString();
-}
-
-bool BoundConstantExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundConstantExpression *)other_p;
-	return !ValueOperations::DistinctFrom(value, other->value);
-}
-
-hash_t BoundConstantExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	return CombineHash(value.Hash(), result);
-}
-
-unique_ptr<Expression> BoundConstantExpression::Copy() {
-	auto copy = make_unique<BoundConstantExpression>(value);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-BoundFunctionExpression::BoundFunctionExpression(LogicalType return_type, ScalarFunction bound_function,
-                                                 vector<unique_ptr<Expression>> arguments,
-                                                 unique_ptr<FunctionData> bind_info, bool is_operator)
-    : Expression(ExpressionType::BOUND_FUNCTION, ExpressionClass::BOUND_FUNCTION, move(return_type)),
-      function(move(bound_function)), children(move(arguments)), bind_info(move(bind_info)), is_operator(is_operator) {
-	D_ASSERT(!function.name.empty());
-}
-
-bool BoundFunctionExpression::HasSideEffects() const {
-	return function.has_side_effects ? true : Expression::HasSideEffects();
-}
-
-bool BoundFunctionExpression::IsFoldable() const {
-	// functions with side effects cannot be folded: they have to be executed once for every row
-	return function.has_side_effects ? false : Expression::IsFoldable();
-}
-
-string BoundFunctionExpression::ToString() const {
-	return FunctionExpression::ToString<BoundFunctionExpression, Expression>(*this, string(), function.name,
-	                                                                         is_operator);
-}
-bool BoundFunctionExpression::PropagatesNullValues() const {
-	return !function.propagates_null_values ? false : Expression::PropagatesNullValues();
-}
-
-hash_t BoundFunctionExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	return CombineHash(result, function.Hash());
-}
-
-bool BoundFunctionExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundFunctionExpression *)other_p;
-	if (other->function != function) {
-		return false;
-	}
-	if (!ExpressionUtil::ListEquals(children, other->children)) {
-		return false;
-	}
-	if (!FunctionData::Equals(bind_info.get(), other->bind_info.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundFunctionExpression::Copy() {
-	vector<unique_ptr<Expression>> new_children;
-	for (auto &child : children) {
-		new_children.push_back(child->Copy());
-	}
-	unique_ptr<FunctionData> new_bind_info = bind_info ? bind_info->Copy() : nullptr;
-
-	auto copy = make_unique<BoundFunctionExpression>(return_type, function, move(new_children), move(new_bind_info),
-	                                                 is_operator);
-	copy->CopyProperties(*this);
-	return move(copy);
-}
-
-void BoundFunctionExpression::Verify() const {
-	D_ASSERT(!function.name.empty());
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-BoundOperatorExpression::BoundOperatorExpression(ExpressionType type, LogicalType return_type)
-    : Expression(type, ExpressionClass::BOUND_OPERATOR, move(return_type)) {
-}
-
-string BoundOperatorExpression::ToString() const {
-	return OperatorExpression::ToString<BoundOperatorExpression, Expression>(*this);
-}
-
-bool BoundOperatorExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundOperatorExpression *)other_p;
-	if (!ExpressionUtil::ListEquals(children, other->children)) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundOperatorExpression::Copy() {
-	auto copy = make_unique<BoundOperatorExpression>(type, return_type);
-	copy->CopyProperties(*this);
-	for (auto &child : children) {
-		copy->children.push_back(child->Copy());
-	}
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundParameterExpression::BoundParameterExpression(idx_t parameter_nr)
-    : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER,
-                 LogicalType(LogicalTypeId::UNKNOWN)),
-      parameter_nr(parameter_nr), value(nullptr) {
-}
-
-bool BoundParameterExpression::IsScalar() const {
-	return true;
-}
-bool BoundParameterExpression::HasParameter() const {
-	return true;
-}
-bool BoundParameterExpression::IsFoldable() const {
-	return false;
-}
-
-string BoundParameterExpression::ToString() const {
-	return to_string(parameter_nr);
-}
-
-bool BoundParameterExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundParameterExpression *)other_p;
-	return parameter_nr == other->parameter_nr;
-}
-
-hash_t BoundParameterExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	result = CombineHash(duckdb::Hash(parameter_nr), result);
-	return result;
-}
-
-unique_ptr<Expression> BoundParameterExpression::Copy() {
-	auto result = make_unique<BoundParameterExpression>(parameter_nr);
-	result->value = value;
-	result->return_type = return_type;
-	result->CopyProperties(*this);
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-BoundReferenceExpression::BoundReferenceExpression(string alias, LogicalType type, idx_t index)
-    : Expression(ExpressionType::BOUND_REF, ExpressionClass::BOUND_REF, move(type)), index(index) {
-	this->alias = move(alias);
-}
-BoundReferenceExpression::BoundReferenceExpression(LogicalType type, idx_t index)
-    : BoundReferenceExpression(string(), move(type), index) {
-}
-
-string BoundReferenceExpression::ToString() const {
-	if (!alias.empty()) {
-		return alias;
-	}
-	return "#" + to_string(index);
-}
-
-bool BoundReferenceExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundReferenceExpression *)other_p;
-	return other->index == index;
-}
-
-hash_t BoundReferenceExpression::Hash() const {
-	return CombineHash(Expression::Hash(), duckdb::Hash<idx_t>(index));
-}
-
-unique_ptr<Expression> BoundReferenceExpression::Copy() {
-	return make_unique<BoundReferenceExpression>(alias, return_type, index);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-BoundSubqueryExpression::BoundSubqueryExpression(LogicalType return_type)
-    : Expression(ExpressionType::SUBQUERY, ExpressionClass::BOUND_SUBQUERY, move(return_type)) {
-}
-
-string BoundSubqueryExpression::ToString() const {
-	return "SUBQUERY";
-}
-
-bool BoundSubqueryExpression::Equals(const BaseExpression *other_p) const {
-	// equality between bound subqueries not implemented currently
-	return false;
-}
-
-unique_ptr<Expression> BoundSubqueryExpression::Copy() {
-	throw SerializationException("Cannot copy BoundSubqueryExpression");
-}
-
-bool BoundSubqueryExpression::PropagatesNullValues() const {
-	// TODO this can be optimized further by checking the actual subquery node
-	return false;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-BoundUnnestExpression::BoundUnnestExpression(LogicalType return_type)
-    : Expression(ExpressionType::BOUND_UNNEST, ExpressionClass::BOUND_UNNEST, move(return_type)) {
-}
-
-bool BoundUnnestExpression::IsFoldable() const {
-	return false;
-}
-
-string BoundUnnestExpression::ToString() const {
-	return "UNNEST(" + child->ToString() + ")";
-}
-
-hash_t BoundUnnestExpression::Hash() const {
-	hash_t result = Expression::Hash();
-	return CombineHash(result, duckdb::Hash("unnest"));
-}
-
-bool BoundUnnestExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundUnnestExpression *)other_p;
-	if (!Expression::Equals(child.get(), other->child.get())) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundUnnestExpression::Copy() {
-	auto copy = make_unique<BoundUnnestExpression>(return_type);
-	copy->child = child->Copy();
-	return move(copy);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-BoundWindowExpression::BoundWindowExpression(ExpressionType type, LogicalType return_type,
-                                             unique_ptr<AggregateFunction> aggregate,
-                                             unique_ptr<FunctionData> bind_info)
-    : Expression(type, ExpressionClass::BOUND_WINDOW, move(return_type)), aggregate(move(aggregate)),
-      bind_info(move(bind_info)), ignore_nulls(false) {
-}
-
-string BoundWindowExpression::ToString() const {
-	string function_name = aggregate.get() ? aggregate->name : ExpressionTypeToString(type);
-	return WindowExpression::ToString<BoundWindowExpression, Expression, BoundOrderByNode>(*this, string(),
-	                                                                                       function_name);
-}
-
-bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
-	if (!Expression::Equals(other_p)) {
-		return false;
-	}
-	auto other = (BoundWindowExpression *)other_p;
-
-	if (ignore_nulls != other->ignore_nulls) {
-		return false;
-	}
-	if (start != other->start || end != other->end) {
-		return false;
-	}
-	// check if the child expressions are equivalent
-	if (other->children.size() != children.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < children.size(); i++) {
-		if (!Expression::Equals(children[i].get(), other->children[i].get())) {
-			return false;
-		}
-	}
-	// check if the filter expressions are equivalent
-	if (!Expression::Equals(filter_expr.get(), other->filter_expr.get())) {
-		return false;
-	}
-
-	// check if the framing expressions are equivalent
-	if (!Expression::Equals(start_expr.get(), other->start_expr.get()) ||
-	    !Expression::Equals(end_expr.get(), other->end_expr.get()) ||
-	    !Expression::Equals(offset_expr.get(), other->offset_expr.get()) ||
-	    !Expression::Equals(default_expr.get(), other->default_expr.get())) {
-		return false;
-	}
-
-	return KeysAreCompatible(other);
-}
-
-bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression *other) const {
-	// check if the partitions are equivalent
-	if (partitions.size() != other->partitions.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < partitions.size(); i++) {
-		if (!Expression::Equals(partitions[i].get(), other->partitions[i].get())) {
-			return false;
-		}
-	}
-	// check if the orderings are equivalent
-	if (orders.size() != other->orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < orders.size(); i++) {
-		if (orders[i].type != other->orders[i].type) {
-			return false;
-		}
-		if (!BaseExpression::Equals((BaseExpression *)orders[i].expression.get(),
-		                            (BaseExpression *)other->orders[i].expression.get())) {
-			return false;
-		}
-	}
-	return true;
-}
-
-unique_ptr<Expression> BoundWindowExpression::Copy() {
-	auto new_window = make_unique<BoundWindowExpression>(type, return_type, nullptr, nullptr);
-	new_window->CopyProperties(*this);
-
-	if (aggregate) {
-		new_window->aggregate = make_unique<AggregateFunction>(*aggregate);
-	}
-	if (bind_info) {
-		new_window->bind_info = bind_info->Copy();
-	}
-	for (auto &child : children) {
-		new_window->children.push_back(child->Copy());
-	}
-	for (auto &e : partitions) {
-		new_window->partitions.push_back(e->Copy());
-	}
-	for (auto &ps : partitions_stats) {
-		if (ps) {
-			new_window->partitions_stats.push_back(ps->Copy());
-		} else {
-			new_window->partitions_stats.push_back(nullptr);
-		}
-	}
-	for (auto &o : orders) {
-		new_window->orders.emplace_back(o.type, o.null_order, o.expression->Copy());
-	}
-
-	new_window->filter_expr = filter_expr ? filter_expr->Copy() : nullptr;
-
-	new_window->start = start;
-	new_window->end = end;
-	new_window->start_expr = start_expr ? start_expr->Copy() : nullptr;
-	new_window->end_expr = end_expr ? end_expr->Copy() : nullptr;
-	new_window->offset_expr = offset_expr ? offset_expr->Copy() : nullptr;
-	new_window->default_expr = default_expr ? default_expr->Copy() : nullptr;
-	new_window->ignore_nulls = ignore_nulls;
-
-	return move(new_window);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-Expression::Expression(ExpressionType type, ExpressionClass expression_class, LogicalType return_type)
-    : BaseExpression(type, expression_class), return_type(move(return_type)) {
-}
-
-Expression::~Expression() {
-}
-
-bool Expression::IsAggregate() const {
-	bool is_aggregate = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) { is_aggregate |= child.IsAggregate(); });
-	return is_aggregate;
-}
-
-bool Expression::IsWindow() const {
-	bool is_window = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) { is_window |= child.IsWindow(); });
-	return is_window;
-}
-
-bool Expression::IsScalar() const {
-	bool is_scalar = true;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (!child.IsScalar()) {
-			is_scalar = false;
-		}
-	});
-	return is_scalar;
-}
-
-bool Expression::HasSideEffects() const {
-	bool has_side_effects = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (child.HasSideEffects()) {
-			has_side_effects = true;
-		}
-	});
-	return has_side_effects;
-}
-
-bool Expression::PropagatesNullValues() const {
-	if (type == ExpressionType::OPERATOR_IS_NULL || type == ExpressionType::OPERATOR_IS_NOT_NULL ||
-	    type == ExpressionType::COMPARE_NOT_DISTINCT_FROM || type == ExpressionType::COMPARE_DISTINCT_FROM ||
-	    type == ExpressionType::CONJUNCTION_OR || type == ExpressionType::CONJUNCTION_AND) {
-		return false;
-	}
-	bool propagate_null_values = true;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (!child.PropagatesNullValues()) {
-			propagate_null_values = false;
-		}
-	});
-	return propagate_null_values;
-}
-
-bool Expression::IsFoldable() const {
-	bool is_foldable = true;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
-		if (!child.IsFoldable()) {
-			is_foldable = false;
-		}
-	});
-	return is_foldable;
-}
-
-bool Expression::HasParameter() const {
-	bool has_parameter = false;
-	ExpressionIterator::EnumerateChildren(*this,
-	                                      [&](const Expression &child) { has_parameter |= child.HasParameter(); });
-	return has_parameter;
-}
-
-bool Expression::HasSubquery() const {
-	bool has_subquery = false;
-	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) { has_subquery |= child.HasSubquery(); });
-	return has_subquery;
-}
-
-hash_t Expression::Hash() const {
-	hash_t hash = duckdb::Hash<uint32_t>((uint32_t)type);
-	hash = CombineHash(hash, return_type.Hash());
-	ExpressionIterator::EnumerateChildren(*this,
-	                                      [&](const Expression &child) { hash = CombineHash(child.Hash(), hash); });
-	return hash;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-AggregateBinder::AggregateBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context, true) {
-}
-
-BindResult AggregateBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.expression_class) {
-	case ExpressionClass::WINDOW:
-		throw ParserException("aggregate function calls cannot contain window function calls");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string AggregateBinder::UnsupportedAggregateMessage() {
-	return "aggregate function calls cannot be nested";
-}
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-AlterBinder::AlterBinder(Binder &binder, ClientContext &context, TableCatalogEntry &table,
-                         vector<column_t> &bound_columns, LogicalType target_type)
-    : ExpressionBinder(binder, context), table(table), bound_columns(bound_columns) {
-	this->target_type = move(target_type);
-}
-
-BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::WINDOW:
-		return BindResult("window functions are not allowed in alter statement");
-	case ExpressionClass::SUBQUERY:
-		return BindResult("cannot use subquery in alter statement");
-	case ExpressionClass::COLUMN_REF:
-		return BindColumn((ColumnRefExpression &)expr);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string AlterBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in alter statement";
-}
-
-BindResult AlterBinder::BindColumn(ColumnRefExpression &colref) {
-	if (colref.column_names.size() > 1) {
-		return BindQualifiedColumnName(colref, table.name);
-	}
-	auto idx = table.GetColumnIndex(colref.column_names[0], true);
-	if (idx == DConstants::INVALID_INDEX) {
-		throw BinderException("Table does not contain column %s referenced in alter statement!",
-		                      colref.column_names[0]);
-	}
-	bound_columns.push_back(idx);
-	return BindResult(make_unique<BoundReferenceExpression>(table.columns[idx].Type(), bound_columns.size() - 1));
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-CheckBinder::CheckBinder(Binder &binder, ClientContext &context, string table_p, vector<ColumnDefinition> &columns,
-                         unordered_set<column_t> &bound_columns)
-    : ExpressionBinder(binder, context), table(move(table_p)), columns(columns), bound_columns(bound_columns) {
-	target_type = LogicalType::INTEGER;
-}
-
-BindResult CheckBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::WINDOW:
-		return BindResult("window functions are not allowed in check constraints");
-	case ExpressionClass::SUBQUERY:
-		return BindResult("cannot use subquery in check constraint");
-	case ExpressionClass::COLUMN_REF:
-		return BindCheckColumn((ColumnRefExpression &)expr);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string CheckBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in check constraints";
-}
-
-BindResult ExpressionBinder::BindQualifiedColumnName(ColumnRefExpression &colref, const string &table_name) {
-	idx_t struct_start = 0;
-	if (colref.column_names[0] == table_name) {
-		struct_start++;
-	}
-	auto result = make_unique_base<ParsedExpression, ColumnRefExpression>(colref.column_names.back());
-	for (idx_t i = struct_start; i + 1 < colref.column_names.size(); i++) {
-		result = CreateStructExtract(move(result), colref.column_names[i]);
-	}
-	return BindExpression(&result, 0);
-}
-
-BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
-	if (colref.column_names.size() > 1) {
-		return BindQualifiedColumnName(colref, table);
-	}
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto &col = columns[i];
-		if (colref.column_names[0] == col.Name()) {
-			if (col.Generated()) {
-				auto bound_expression = col.GeneratedExpression().Copy();
-				return BindExpression(&bound_expression, 0, false);
-			}
-			bound_columns.insert(i);
-			D_ASSERT(col.StorageOid() != DConstants::INVALID_INDEX);
-			return BindResult(make_unique<BoundReferenceExpression>(col.Type(), col.StorageOid()));
-		}
-	}
-	throw BinderException("Table does not contain column %s referenced in check constraint!", colref.column_names[0]);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map)
-    : node(node), alias_map(alias_map), in_alias(false) {
-}
-
-BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
-                                        bool root_expression) {
-	if (expr.IsQualified()) {
-		return BindResult(StringUtil::Format("Alias %s cannot be qualified.", expr.ToString()));
-	}
-
-	auto alias_entry = alias_map.find(expr.column_names[0]);
-	if (alias_entry == alias_map.end()) {
-		return BindResult(StringUtil::Format("Alias %s is not found.", expr.ToString()));
-	}
-
-	// found an alias: bind the alias expression
-	D_ASSERT(!in_alias);
-	auto expression = node.original_expressions[alias_entry->second]->Copy();
-	in_alias = true;
-	auto result = enclosing_binder.BindExpression(&expression, depth, root_expression);
-	in_alias = false;
-	return result;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string clause)
-    : ExpressionBinder(binder, context), clause(move(clause)) {
-}
-
-BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::COLUMN_REF:
-		return BindResult(clause + " cannot contain column names");
-	case ExpressionClass::SUBQUERY:
-		return BindResult(clause + " cannot contain subqueries");
-	case ExpressionClass::DEFAULT:
-		return BindResult(clause + " cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindResult(clause + " cannot contain window functions!");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string ConstantBinder::UnsupportedAggregateMessage() {
-	return clause + "cannot contain aggregates!";
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-GroupBinder::GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-                         case_insensitive_map_t<idx_t> &alias_map, case_insensitive_map_t<idx_t> &group_alias_map)
-    : ExpressionBinder(binder, context), node(node), alias_map(alias_map), group_alias_map(group_alias_map),
-      group_index(group_index) {
-}
-
-BindResult GroupBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	if (root_expression && depth == 0) {
-		switch (expr.expression_class) {
-		case ExpressionClass::COLUMN_REF:
-			return BindColumnRef((ColumnRefExpression &)expr);
-		case ExpressionClass::CONSTANT:
-			return BindConstant((ConstantExpression &)expr);
-		default:
-			break;
-		}
-	}
-	switch (expr.expression_class) {
-	case ExpressionClass::DEFAULT:
-		return BindResult("GROUP BY clause cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindResult("GROUP BY clause cannot contain window functions!");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string GroupBinder::UnsupportedAggregateMessage() {
-	return "GROUP BY clause cannot contain aggregates!";
-}
-
-BindResult GroupBinder::BindSelectRef(idx_t entry) {
-	if (used_aliases.find(entry) != used_aliases.end()) {
-		// the alias has already been bound to before!
-		// this happens if we group on the same alias twice
-		// e.g. GROUP BY k, k or GROUP BY 1, 1
-		// in this case, we can just replace the grouping with a constant since the second grouping has no effect
-		// (the constant grouping will be optimized out later)
-		return BindResult(make_unique<BoundConstantExpression>(Value::INTEGER(42)));
-	}
-	if (entry >= node.select_list.size()) {
-		throw BinderException("GROUP BY term out of range - should be between 1 and %d", (int)node.select_list.size());
-	}
-	// we replace the root expression, also replace the unbound expression
-	unbound_expression = node.select_list[entry]->Copy();
-	// move the expression that this refers to here and bind it
-	auto select_entry = move(node.select_list[entry]);
-	auto binding = Bind(select_entry, nullptr, false);
-	// now replace the original expression in the select list with a reference to this group
-	group_alias_map[to_string(entry)] = bind_index;
-	node.select_list[entry] = make_unique<ColumnRefExpression>(to_string(entry));
-	// insert into the set of used aliases
-	used_aliases.insert(entry);
-	return BindResult(move(binding));
-}
-
-BindResult GroupBinder::BindConstant(ConstantExpression &constant) {
-	// constant as root expression
-	if (!constant.value.type().IsIntegral()) {
-		// non-integral expression, we just leave the constant here.
-		return ExpressionBinder::BindExpression(constant, 0);
-	}
-	// INTEGER constant: we use the integer as an index into the select list (e.g. GROUP BY 1)
-	auto index = (idx_t)constant.value.GetValue<int64_t>();
-	return BindSelectRef(index - 1);
-}
-
-BindResult GroupBinder::BindColumnRef(ColumnRefExpression &colref) {
-	// columns in GROUP BY clauses:
-	// FIRST refer to the original tables, and
-	// THEN if no match is found refer to aliases in the SELECT list
-	// THEN if no match is found, refer to outer queries
-
-	// first try to bind to the base columns (original tables)
-	auto result = ExpressionBinder::BindExpression(colref, 0);
-	if (result.HasError()) {
-		if (colref.IsQualified()) {
-			// explicit table name: not an alias reference
-			return result;
-		}
-		// failed to bind the column and the node is the root expression with depth = 0
-		// check if refers to an alias in the select clause
-		auto alias_name = colref.column_names[0];
-		auto entry = alias_map.find(alias_name);
-		if (entry == alias_map.end()) {
-			// no matching alias found
-			return result;
-		}
-		result = BindResult(BindSelectRef(entry->second));
-		if (!result.HasError()) {
-			group_alias_map[alias_name] = bind_index;
-		}
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-                           case_insensitive_map_t<idx_t> &alias_map)
-    : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
-	target_type = LogicalType(LogicalTypeId::BOOLEAN);
-}
-
-BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (ColumnRefExpression &)**expr_ptr;
-	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
-	if (!alias_result.HasError()) {
-		return alias_result;
-	}
-
-	return BindResult(StringUtil::Format(
-	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));
-}
-
-BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	// check if the expression binds to one of the groups
-	auto group_index = TryBindGroup(expr, depth);
-	if (group_index != DConstants::INVALID_INDEX) {
-		return BindGroup(expr, depth, group_index);
-	}
-	switch (expr.expression_class) {
-	case ExpressionClass::WINDOW:
-		return BindResult("HAVING clause cannot contain window functions!");
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth, root_expression);
-	default:
-		return duckdb::SelectBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-IndexBinder::IndexBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
-}
-
-BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.expression_class) {
-	case ExpressionClass::WINDOW:
-		return BindResult("window functions are not allowed in index expressions");
-	case ExpressionClass::SUBQUERY:
-		return BindResult("cannot use subquery in index expressions");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string IndexBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in index expressions";
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-InsertBinder::InsertBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
-}
-
-BindResult InsertBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::DEFAULT:
-		return BindResult("DEFAULT is not allowed here!");
-	case ExpressionClass::WINDOW:
-		return BindResult("INSERT statement cannot contain window functions!");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string InsertBinder::UnsupportedAggregateMessage() {
-	return "INSERT statement cannot contain aggregates!";
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
-                         expression_map_t<idx_t> &projection_map, idx_t max_count)
-    : binders(move(binders)), projection_index(projection_index), max_count(max_count), extra_list(nullptr),
-      alias_map(alias_map), projection_map(projection_map) {
-}
-OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-                         case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map)
-    : binders(move(binders)), projection_index(projection_index), alias_map(alias_map), projection_map(projection_map) {
-	this->max_count = node.select_list.size();
-	this->extra_list = &node.select_list;
-}
-
-unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &expr, idx_t index) {
-	string alias;
-	if (extra_list && index < extra_list->size()) {
-		alias = extra_list->at(index)->ToString();
-	} else {
-		alias = expr.GetName();
-	}
-	return make_unique<BoundColumnRefExpression>(move(alias), LogicalType::INVALID,
-	                                             ColumnBinding(projection_index, index));
-}
-
-unique_ptr<Expression> OrderBinder::CreateExtraReference(unique_ptr<ParsedExpression> expr) {
-	auto result = CreateProjectionReference(*expr, extra_list->size());
-	extra_list->push_back(move(expr));
-	return result;
-}
-
-unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
-	// in the ORDER BY clause we do not bind children
-	// we bind ONLY to the select list
-	// if there is no matching entry in the SELECT list already, we add the expression to the SELECT list and refer the
-	// new expression the new entry will then be bound later during the binding of the SELECT list we also don't do type
-	// resolution here: this only happens after the SELECT list has been bound
-	switch (expr->expression_class) {
-	case ExpressionClass::CONSTANT: {
-		// ORDER BY constant
-		// is the ORDER BY expression a constant integer? (e.g. ORDER BY 1)
-		auto &constant = (ConstantExpression &)*expr;
-		// ORDER BY a constant
-		if (!constant.value.type().IsIntegral()) {
-			// non-integral expression, we just leave the constant here.
-			// ORDER BY <constant> has no effect
-			// CONTROVERSIAL: maybe we should throw an error
-			return nullptr;
-		}
-		// INTEGER constant: we use the integer as an index into the select list (e.g. ORDER BY 1)
-		auto index = (idx_t)constant.value.GetValue<int64_t>();
-		if (index < 1 || index > max_count) {
-			throw BinderException("ORDER term out of range - should be between 1 and %lld", (idx_t)max_count);
-		}
-		return CreateProjectionReference(*expr, index - 1);
-	}
-	case ExpressionClass::COLUMN_REF: {
-		// COLUMN REF expression
-		// check if we can bind it to an alias in the select list
-		auto &colref = (ColumnRefExpression &)*expr;
-		// if there is an explicit table name we can't bind to an alias
-		if (colref.IsQualified()) {
-			break;
-		}
-		// check the alias list
-		auto entry = alias_map.find(colref.column_names[0]);
-		if (entry != alias_map.end()) {
-			// it does! point it to that entry
-			return CreateProjectionReference(*expr, entry->second);
-		}
-		break;
-	}
-	case ExpressionClass::POSITIONAL_REFERENCE: {
-		auto &posref = (PositionalReferenceExpression &)*expr;
-		return CreateProjectionReference(*expr, posref.index - 1);
-	}
-	default:
-		break;
-	}
-	// general case
-	// first bind the table names of this entry
-	for (auto &binder : binders) {
-		ExpressionBinder::QualifyColumnNames(*binder, expr);
-	}
-	// first check if the ORDER BY clause already points to an entry in the projection list
-	auto entry = projection_map.find(expr.get());
-	if (entry != projection_map.end()) {
-		if (entry->second == DConstants::INVALID_INDEX) {
-			throw BinderException("Ambiguous reference to column");
-		}
-		// there is a matching entry in the projection list
-		// just point to that entry
-		return CreateProjectionReference(*expr, entry->second);
-	}
-	if (!extra_list) {
-		// no extra list specified: we cannot push an extra ORDER BY clause
-		throw BinderException("Could not ORDER BY column \"%s\": add the expression/function to every SELECT, or move "
-		                      "the UNION into a FROM clause.",
-		                      expr->ToString());
-	}
-	// otherwise we need to push the ORDER BY entry into the select list
-	return CreateExtraReference(move(expr));
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-                             case_insensitive_map_t<idx_t> &alias_map)
-    : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
-	target_type = LogicalType(LogicalTypeId::BOOLEAN);
-}
-
-BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (ColumnRefExpression &)**expr_ptr;
-	auto result = duckdb::SelectBinder::BindExpression(expr_ptr, depth);
-	if (!result.HasError()) {
-		return result;
-	}
-
-	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
-	if (!alias_result.HasError()) {
-		return alias_result;
-	}
-
-	return BindResult(StringUtil::Format("Referenced column %s not found in FROM clause and can't find in alias map.",
-	                                     expr.ToString()));
-}
-
-BindResult QualifyBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	// check if the expression binds to one of the groups
-	auto group_index = TryBindGroup(expr, depth);
-	if (group_index != DConstants::INVALID_INDEX) {
-		return BindGroup(expr, depth, group_index);
-	}
-	switch (expr.expression_class) {
-	case ExpressionClass::WINDOW:
-		return BindWindow((WindowExpression &)expr, depth);
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth, root_expression);
-	default:
-		return duckdb::SelectBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-RelationBinder::RelationBinder(Binder &binder, ClientContext &context, string op)
-    : ExpressionBinder(binder, context), op(move(op)) {
-}
-
-BindResult RelationBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.expression_class) {
-	case ExpressionClass::AGGREGATE:
-		return BindResult("aggregate functions are not allowed in " + op);
-	case ExpressionClass::DEFAULT:
-		return BindResult(op + " cannot contain DEFAULT clause");
-	case ExpressionClass::SUBQUERY:
-		return BindResult("subqueries are not allowed in " + op);
-	case ExpressionClass::WINDOW:
-		return BindResult("window functions are not allowed in " + op);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string RelationBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in " + op;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-ReturningBinder::ReturningBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
-}
-
-BindResult ReturningBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::SUBQUERY:
-		return BindResult("SUBQUERY is not supported in returning statements");
-	case ExpressionClass::BOUND_SUBQUERY:
-		return BindResult("BOUND SUBQUERY is not supported in returning statements");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-SelectBinder::SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info)
-    : ExpressionBinder(binder, context), inside_window(false), node(node), info(info) {
-}
-
-BindResult SelectBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	// check if the expression binds to one of the groups
-	auto group_index = TryBindGroup(expr, depth);
-	if (group_index != DConstants::INVALID_INDEX) {
-		return BindGroup(expr, depth, group_index);
-	}
-	switch (expr.expression_class) {
-	case ExpressionClass::DEFAULT:
-		return BindResult("SELECT clause cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindWindow((WindowExpression &)expr, depth);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-idx_t SelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
-	// first check the group alias map, if expr is a ColumnRefExpression
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
-		if (!colref.IsQualified()) {
-			auto alias_entry = info.alias_map.find(colref.column_names[0]);
-			if (alias_entry != info.alias_map.end()) {
-				// found entry!
-				return alias_entry->second;
-			}
-		}
-	}
-	// no alias reference found
-	// check the list of group columns for a match
-	auto entry = info.map.find(&expr);
-	if (entry != info.map.end()) {
-		return entry->second;
-	}
-#ifdef DEBUG
-	for (auto entry : info.map) {
-		D_ASSERT(!entry.first->Equals(&expr));
-		D_ASSERT(!expr.Equals(entry.first));
-	}
-#endif
-	return DConstants::INVALID_INDEX;
-}
-
-BindResult SelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t depth) {
-	if (op.children.empty()) {
-		throw InternalException("GROUPING requires at least one child");
-	}
-	if (node.groups.group_expressions.empty()) {
-		return BindResult(binder.FormatError(op, "GROUPING statement cannot be used without groups"));
-	}
-	if (op.children.size() >= 64) {
-		return BindResult(binder.FormatError(op, "GROUPING statement cannot have more than 64 groups"));
-	}
-	vector<idx_t> group_indexes;
-	group_indexes.reserve(op.children.size());
-	for (auto &child : op.children) {
-		ExpressionBinder::QualifyColumnNames(binder, child);
-		auto idx = TryBindGroup(*child, depth);
-		if (idx == DConstants::INVALID_INDEX) {
-			return BindResult(binder.FormatError(
-			    op, StringUtil::Format("GROUPING child \"%s\" must be a grouping column", child->GetName())));
-		}
-		group_indexes.push_back(idx);
-	}
-	auto col_idx = node.grouping_functions.size();
-	node.grouping_functions.push_back(move(group_indexes));
-	return BindResult(make_unique<BoundColumnRefExpression>(op.GetName(), LogicalType::BIGINT,
-	                                                        ColumnBinding(node.groupings_index, col_idx), depth));
-}
-
-BindResult SelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index) {
-	auto &group = node.groups.group_expressions[group_index];
-	return BindResult(make_unique<BoundColumnRefExpression>(expr.GetName(), group->return_type,
-	                                                        ColumnBinding(node.group_index, group_index), depth));
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-UpdateBinder::UpdateBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
-}
-
-BindResult UpdateBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.expression_class) {
-	case ExpressionClass::WINDOW:
-		return BindResult("window functions are not allowed in UPDATE");
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string UpdateBinder::UnsupportedAggregateMessage() {
-	return "aggregate functions are not allowed in UPDATE";
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-WhereBinder::WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder)
-    : ExpressionBinder(binder, context), column_alias_binder(column_alias_binder) {
-	target_type = LogicalType(LogicalTypeId::BOOLEAN);
-}
-
-BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (ColumnRefExpression &)**expr_ptr;
-	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
-	if (!result.HasError() || !column_alias_binder) {
-		return result;
-	}
-
-	BindResult alias_result = column_alias_binder->BindAlias(*this, expr, depth, root_expression);
-	// This code path cannot be exercised at thispoint. #1547 might change that.
-	if (!alias_result.HasError()) {
-		return alias_result;
-	}
-
-	return result;
-}
-
-BindResult WhereBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::DEFAULT:
-		return BindResult("WHERE clause cannot contain DEFAULT clause");
-	case ExpressionClass::WINDOW:
-		return BindResult("WHERE clause cannot contain window functions!");
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth, root_expression);
-	default:
-		return ExpressionBinder::BindExpression(expr_ptr, depth);
-	}
-}
-
-string WhereBinder::UnsupportedAggregateMessage() {
-	return "WHERE clause cannot contain aggregates!";
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-ExpressionBinder::ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder)
-    : binder(binder), context(context), stored_binder(nullptr) {
-	if (replace_binder) {
-		stored_binder = binder.GetActiveBinder();
-		binder.SetActiveBinder(this);
-	} else {
-		binder.PushExpressionBinder(this);
-	}
-}
-
-ExpressionBinder::~ExpressionBinder() {
-	if (binder.HasActiveBinder()) {
-		if (stored_binder) {
-			binder.SetActiveBinder(stored_binder);
-		} else {
-			binder.PopExpressionBinder();
-		}
-	}
-}
-
-BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression) {
-	auto &expr_ref = **expr;
-	switch (expr_ref.expression_class) {
-	case ExpressionClass::BETWEEN:
-		return BindExpression((BetweenExpression &)expr_ref, depth);
-	case ExpressionClass::CASE:
-		return BindExpression((CaseExpression &)expr_ref, depth);
-	case ExpressionClass::CAST:
-		return BindExpression((CastExpression &)expr_ref, depth);
-	case ExpressionClass::COLLATE:
-		return BindExpression((CollateExpression &)expr_ref, depth);
-	case ExpressionClass::COLUMN_REF:
-		return BindExpression((ColumnRefExpression &)expr_ref, depth);
-	case ExpressionClass::COMPARISON:
-		return BindExpression((ComparisonExpression &)expr_ref, depth);
-	case ExpressionClass::CONJUNCTION:
-		return BindExpression((ConjunctionExpression &)expr_ref, depth);
-	case ExpressionClass::CONSTANT:
-		return BindExpression((ConstantExpression &)expr_ref, depth);
-	case ExpressionClass::FUNCTION:
-		// binding function expression has extra parameter needed for macro's
-		return BindExpression((FunctionExpression &)expr_ref, depth, expr);
-	case ExpressionClass::LAMBDA:
-		return BindExpression((LambdaExpression &)expr_ref, depth);
-	case ExpressionClass::OPERATOR:
-		return BindExpression((OperatorExpression &)expr_ref, depth);
-	case ExpressionClass::SUBQUERY:
-		return BindExpression((SubqueryExpression &)expr_ref, depth);
-	case ExpressionClass::PARAMETER:
-		return BindExpression((ParameterExpression &)expr_ref, depth);
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return BindExpression((PositionalReferenceExpression &)expr_ref, depth);
-	default:
-		throw NotImplementedException("Unimplemented expression class");
-	}
-}
-
-bool ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr) {
-	// try to bind in one of the outer queries, if the binding error occurred in a subquery
-	auto &active_binders = binder.GetActiveBinders();
-	// make a copy of the set of binders, so we can restore it later
-	auto binders = active_binders;
-	active_binders.pop_back();
-	idx_t depth = 1;
-	bool success = false;
-	while (!active_binders.empty()) {
-		auto &next_binder = active_binders.back();
-		ExpressionBinder::QualifyColumnNames(next_binder->binder, expr);
-		auto bind_result = next_binder->Bind(&expr, depth);
-		if (bind_result.empty()) {
-			success = true;
-			break;
-		}
-		depth++;
-		active_binders.pop_back();
-	}
-	active_binders = binders;
-	return success;
-}
-
-void ExpressionBinder::BindChild(unique_ptr<ParsedExpression> &expr, idx_t depth, string &error) {
-	if (expr) {
-		string bind_error = Bind(&expr, depth);
-		if (error.empty()) {
-			error = bind_error;
-		}
-	}
-}
-
-void ExpressionBinder::ExtractCorrelatedExpressions(Binder &binder, Expression &expr) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)expr;
-		if (bound_colref.depth > 0) {
-			binder.AddCorrelatedColumn(CorrelatedColumnInfo(bound_colref));
-		}
-	}
-	ExpressionIterator::EnumerateChildren(expr,
-	                                      [&](Expression &child) { ExtractCorrelatedExpressions(binder, child); });
-}
-
-bool ExpressionBinder::ContainsType(const LogicalType &type, LogicalTypeId target) {
-	if (type.id() == target) {
-		return true;
-	}
-	switch (type.id()) {
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::MAP: {
-		auto child_count = StructType::GetChildCount(type);
-		for (idx_t i = 0; i < child_count; i++) {
-			if (ContainsType(StructType::GetChildType(type, i), target)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	case LogicalTypeId::LIST:
-		return ContainsType(ListType::GetChildType(type), target);
-	default:
-		return false;
-	}
-}
-
-LogicalType ExpressionBinder::ExchangeType(const LogicalType &type, LogicalTypeId target, LogicalType new_type) {
-	if (type.id() == target) {
-		return new_type;
-	}
-	switch (type.id()) {
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::MAP: {
-		// we make a copy of the child types of the struct here
-		auto child_types = StructType::GetChildTypes(type);
-		for (auto &child_type : child_types) {
-			child_type.second = ExchangeType(child_type.second, target, new_type);
-		}
-		return type.id() == LogicalTypeId::MAP ? LogicalType::MAP(move(child_types))
-		                                       : LogicalType::STRUCT(move(child_types));
-	}
-	case LogicalTypeId::LIST:
-		return LogicalType::LIST(ExchangeType(ListType::GetChildType(type), target, new_type));
-	default:
-		return type;
-	}
-}
-
-bool ExpressionBinder::ContainsNullType(const LogicalType &type) {
-	return ContainsType(type, LogicalTypeId::SQLNULL);
-}
-
-LogicalType ExpressionBinder::ExchangeNullType(const LogicalType &type) {
-	return ExchangeType(type, LogicalTypeId::SQLNULL, LogicalType::INTEGER);
-}
-
-unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr, LogicalType *result_type,
-                                              bool root_expression) {
-	// bind the main expression
-	auto error_msg = Bind(&expr, 0, root_expression);
-	if (!error_msg.empty()) {
-		// failed to bind: try to bind correlated columns in the expression (if any)
-		bool success = BindCorrelatedColumns(expr);
-		if (!success) {
-			throw BinderException(error_msg);
-		}
-		auto bound_expr = (BoundExpression *)expr.get();
-		ExtractCorrelatedExpressions(binder, *bound_expr->expr);
-	}
-	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto bound_expr = (BoundExpression *)expr.get();
-	unique_ptr<Expression> result = move(bound_expr->expr);
-	if (target_type.id() != LogicalTypeId::INVALID) {
-		// the binder has a specific target type: add a cast to that type
-		result = BoundCastExpression::AddCastToType(move(result), target_type);
-	} else {
-		if (!binder.can_contain_nulls) {
-			// SQL NULL type is only used internally in the binder
-			// cast to INTEGER if we encounter it outside of the binder
-			if (ContainsNullType(result->return_type)) {
-				auto result_type = ExchangeNullType(result->return_type);
-				result = BoundCastExpression::AddCastToType(move(result), result_type);
-			}
-		}
-	}
-	if (result_type) {
-		*result_type = result->return_type;
-	}
-	return result;
-}
-
-string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression) {
-	// bind the node, but only if it has not been bound yet
-	auto &expression = **expr;
-	auto alias = expression.alias;
-	if (expression.GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION) {
-		// already bound, don't bind it again
-		return string();
-	}
-	// bind the expression
-	BindResult result = BindExpression(expr, depth, root_expression);
-	if (result.HasError()) {
-		return result.error;
-	}
-	// successfully bound: replace the node with a BoundExpression
-	*expr = make_unique<BoundExpression>(move(result.expression));
-	auto be = (BoundExpression *)expr->get();
-	D_ASSERT(be);
-	be->alias = alias;
-	if (!alias.empty()) {
-		be->expr->alias = alias;
-	}
-	return string();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void ExpressionIterator::EnumerateChildren(const Expression &expr,
-                                           const std::function<void(const Expression &child)> &callback) {
-	EnumerateChildren((Expression &)expr, [&](unique_ptr<Expression> &child) { callback(*child); });
-}
-
-void ExpressionIterator::EnumerateChildren(Expression &expr, const std::function<void(Expression &child)> &callback) {
-	EnumerateChildren(expr, [&](unique_ptr<Expression> &child) { callback(*child); });
-}
-
-void ExpressionIterator::EnumerateChildren(Expression &expr,
-                                           const std::function<void(unique_ptr<Expression> &child)> &callback) {
-	switch (expr.expression_class) {
-	case ExpressionClass::BOUND_AGGREGATE: {
-		auto &aggr_expr = (BoundAggregateExpression &)expr;
-		for (auto &child : aggr_expr.children) {
-			callback(child);
-		}
-		if (aggr_expr.filter) {
-			callback(aggr_expr.filter);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between_expr = (BoundBetweenExpression &)expr;
-		callback(between_expr.input);
-		callback(between_expr.lower);
-		callback(between_expr.upper);
-		break;
-	}
-	case ExpressionClass::BOUND_CASE: {
-		auto &case_expr = (BoundCaseExpression &)expr;
-		for (auto &case_check : case_expr.case_checks) {
-			callback(case_check.when_expr);
-			callback(case_check.then_expr);
-		}
-		callback(case_expr.else_expr);
-		break;
-	}
-	case ExpressionClass::BOUND_CAST: {
-		auto &cast_expr = (BoundCastExpression &)expr;
-		callback(cast_expr.child);
-		break;
-	}
-	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comp_expr = (BoundComparisonExpression &)expr;
-		callback(comp_expr.left);
-		callback(comp_expr.right);
-		break;
-	}
-	case ExpressionClass::BOUND_CONJUNCTION: {
-		auto &conj_expr = (BoundConjunctionExpression &)expr;
-		for (auto &child : conj_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_FUNCTION: {
-		auto &func_expr = (BoundFunctionExpression &)expr;
-		for (auto &child : func_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_OPERATOR: {
-		auto &op_expr = (BoundOperatorExpression &)expr;
-		for (auto &child : op_expr.children) {
-			callback(child);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_SUBQUERY: {
-		auto &subquery_expr = (BoundSubqueryExpression &)expr;
-		if (subquery_expr.child) {
-			callback(subquery_expr.child);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_WINDOW: {
-		auto &window_expr = (BoundWindowExpression &)expr;
-		for (auto &partition : window_expr.partitions) {
-			callback(partition);
-		}
-		for (auto &order : window_expr.orders) {
-			callback(order.expression);
-		}
-		for (auto &child : window_expr.children) {
-			callback(child);
-		}
-		if (window_expr.filter_expr) {
-			callback(window_expr.filter_expr);
-		}
-		if (window_expr.start_expr) {
-			callback(window_expr.start_expr);
-		}
-		if (window_expr.end_expr) {
-			callback(window_expr.end_expr);
-		}
-		if (window_expr.offset_expr) {
-			callback(window_expr.offset_expr);
-		}
-		if (window_expr.default_expr) {
-			callback(window_expr.default_expr);
-		}
-		break;
-	}
-	case ExpressionClass::BOUND_UNNEST: {
-		auto &unnest_expr = (BoundUnnestExpression &)expr;
-		callback(unnest_expr.child);
-		break;
-	}
-	case ExpressionClass::BOUND_COLUMN_REF:
-	case ExpressionClass::BOUND_CONSTANT:
-	case ExpressionClass::BOUND_DEFAULT:
-	case ExpressionClass::BOUND_PARAMETER:
-	case ExpressionClass::BOUND_REF:
-		// these node types have no children
-		break;
-	default:
-		throw InternalException("ExpressionIterator used on unbound expression");
-	}
-}
-
-void ExpressionIterator::EnumerateExpression(unique_ptr<Expression> &expr,
-                                             const std::function<void(Expression &child)> &callback) {
-	if (!expr) {
-		return;
-	}
-	callback(*expr);
-	ExpressionIterator::EnumerateChildren(*expr,
-	                                      [&](unique_ptr<Expression> &child) { EnumerateExpression(child, callback); });
-}
-
-void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
-                                                   const std::function<void(Expression &child)> &callback) {
-	switch (ref.type) {
-	case TableReferenceType::CROSS_PRODUCT: {
-		auto &bound_crossproduct = (BoundCrossProductRef &)ref;
-		EnumerateTableRefChildren(*bound_crossproduct.left, callback);
-		EnumerateTableRefChildren(*bound_crossproduct.right, callback);
-		break;
-	}
-	case TableReferenceType::EXPRESSION_LIST: {
-		auto &bound_expr_list = (BoundExpressionListRef &)ref;
-		for (auto &expr_list : bound_expr_list.values) {
-			for (auto &expr : expr_list) {
-				EnumerateExpression(expr, callback);
-			}
-		}
-		break;
-	}
-	case TableReferenceType::JOIN: {
-		auto &bound_join = (BoundJoinRef &)ref;
-		EnumerateExpression(bound_join.condition, callback);
-		EnumerateTableRefChildren(*bound_join.left, callback);
-		EnumerateTableRefChildren(*bound_join.right, callback);
-		break;
-	}
-	case TableReferenceType::SUBQUERY: {
-		auto &bound_subquery = (BoundSubqueryRef &)ref;
-		EnumerateQueryNodeChildren(*bound_subquery.subquery, callback);
-		break;
-	}
-	case TableReferenceType::TABLE_FUNCTION:
-	case TableReferenceType::EMPTY:
-	case TableReferenceType::BASE_TABLE:
-	case TableReferenceType::CTE:
-		break;
-	default:
-		throw NotImplementedException("Unimplemented table reference type in ExpressionIterator");
-	}
-}
-
-void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
-                                                    const std::function<void(Expression &child)> &callback) {
-	switch (node.type) {
-	case QueryNodeType::SET_OPERATION_NODE: {
-		auto &bound_setop = (BoundSetOperationNode &)node;
-		EnumerateQueryNodeChildren(*bound_setop.left, callback);
-		EnumerateQueryNodeChildren(*bound_setop.right, callback);
-		break;
-	}
-	case QueryNodeType::RECURSIVE_CTE_NODE: {
-		auto &cte_node = (BoundRecursiveCTENode &)node;
-		EnumerateQueryNodeChildren(*cte_node.left, callback);
-		EnumerateQueryNodeChildren(*cte_node.right, callback);
-		break;
-	}
-	case QueryNodeType::SELECT_NODE: {
-		auto &bound_select = (BoundSelectNode &)node;
-		for (idx_t i = 0; i < bound_select.select_list.size(); i++) {
-			EnumerateExpression(bound_select.select_list[i], callback);
-		}
-		EnumerateExpression(bound_select.where_clause, callback);
-		for (idx_t i = 0; i < bound_select.groups.group_expressions.size(); i++) {
-			EnumerateExpression(bound_select.groups.group_expressions[i], callback);
-		}
-		EnumerateExpression(bound_select.having, callback);
-		for (idx_t i = 0; i < bound_select.aggregates.size(); i++) {
-			EnumerateExpression(bound_select.aggregates[i], callback);
-		}
-		for (idx_t i = 0; i < bound_select.unnests.size(); i++) {
-			EnumerateExpression(bound_select.unnests[i], callback);
-		}
-		for (idx_t i = 0; i < bound_select.windows.size(); i++) {
-			EnumerateExpression(bound_select.windows[i], callback);
-		}
-		if (bound_select.from_table) {
-			EnumerateTableRefChildren(*bound_select.from_table, callback);
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Unimplemented query node in ExpressionIterator");
-	}
-	for (idx_t i = 0; i < node.modifiers.size(); i++) {
-		switch (node.modifiers[i]->type) {
-		case ResultModifierType::DISTINCT_MODIFIER:
-			for (auto &expr : ((BoundDistinctModifier &)*node.modifiers[i]).target_distincts) {
-				EnumerateExpression(expr, callback);
-			}
-			break;
-		case ResultModifierType::ORDER_MODIFIER:
-			for (auto &order : ((BoundOrderModifier &)*node.modifiers[i]).orders) {
-				EnumerateExpression(order.expression, callback);
-			}
-			break;
-		default:
-			break;
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ConjunctionOrFilter::ConjunctionOrFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_OR) {
-}
-
-FilterPropagateResult ConjunctionOrFilter::CheckStatistics(BaseStatistics &stats) {
-	// the OR filter is true if ANY of the children is true
-	D_ASSERT(!child_filters.empty());
-	for (auto &filter : child_filters) {
-		auto prune_result = filter->CheckStatistics(stats);
-		if (prune_result == FilterPropagateResult::NO_PRUNING_POSSIBLE) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-	}
-	return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-}
-
-string ConjunctionOrFilter::ToString(const string &column_name) {
-	string result;
-	for (idx_t i = 0; i < child_filters.size(); i++) {
-		if (i > 0) {
-			result += " OR ";
-		}
-		result += child_filters[i]->ToString(column_name);
-	}
-	return result;
-}
-
-bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
-	if (!ConjunctionFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = (ConjunctionOrFilter &)other_p;
-	if (other.child_filters.size() != child_filters.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < other.child_filters.size(); i++) {
-		if (!child_filters[i]->Equals(*other.child_filters[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-ConjunctionAndFilter::ConjunctionAndFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_AND) {
-}
-
-FilterPropagateResult ConjunctionAndFilter::CheckStatistics(BaseStatistics &stats) {
-	// the AND filter is true if ALL of the children is true
-	D_ASSERT(!child_filters.empty());
-	auto result = FilterPropagateResult::FILTER_ALWAYS_TRUE;
-	for (auto &filter : child_filters) {
-		auto prune_result = filter->CheckStatistics(stats);
-		if (prune_result == FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		} else if (prune_result != result) {
-			result = FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		}
-	}
-	return result;
-}
-
-string ConjunctionAndFilter::ToString(const string &column_name) {
-	string result;
-	for (idx_t i = 0; i < child_filters.size(); i++) {
-		if (i > 0) {
-			result += " AND ";
-		}
-		result += child_filters[i]->ToString(column_name);
-	}
-	return result;
-}
-
-bool ConjunctionAndFilter::Equals(const TableFilter &other_p) const {
-	if (!ConjunctionFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = (ConjunctionAndFilter &)other_p;
-	if (other.child_filters.size() != child_filters.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < other.child_filters.size(); i++) {
-		if (!child_filters[i]->Equals(*other.child_filters[i])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-ConstantFilter::ConstantFilter(ExpressionType comparison_type_p, Value constant_p)
-    : TableFilter(TableFilterType::CONSTANT_COMPARISON), comparison_type(comparison_type_p),
-      constant(move(constant_p)) {
-}
-
-FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {
-	D_ASSERT(constant.type().id() == stats.type.id());
-	switch (constant.type().InternalType()) {
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return ((NumericStatistics &)stats).CheckZonemap(comparison_type, constant);
-	case PhysicalType::VARCHAR:
-		return ((StringStatistics &)stats).CheckZonemap(comparison_type, constant.ToString());
-	default:
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-}
-
-string ConstantFilter::ToString(const string &column_name) {
-	return column_name + ExpressionTypeToOperator(comparison_type) + constant.ToString();
-}
-
-bool ConstantFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
-		return false;
-	}
-	auto &other = (ConstantFilter &)other_p;
-	return other.comparison_type == comparison_type && other.constant == constant;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-IsNullFilter::IsNullFilter() : TableFilter(TableFilterType::IS_NULL) {
-}
-
-FilterPropagateResult IsNullFilter::CheckStatistics(BaseStatistics &stats) {
-	if (!stats.CanHaveNull()) {
-		// no null values are possible: always false
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	}
-	if (!stats.CanHaveNoNull()) {
-		// no non-null values are possible: always true
-		return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-	}
-	return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-}
-
-string IsNullFilter::ToString(const string &column_name) {
-	return column_name + "IS NULL";
-}
-
-IsNotNullFilter::IsNotNullFilter() : TableFilter(TableFilterType::IS_NOT_NULL) {
-}
-
-FilterPropagateResult IsNotNullFilter::CheckStatistics(BaseStatistics &stats) {
-	if (!stats.CanHaveNoNull()) {
-		// no non-null values are possible: always false
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	}
-	if (!stats.CanHaveNull()) {
-		// no null values are possible: always true
-		return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-	}
-	return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-}
-
-string IsNotNullFilter::ToString(const string &column_name) {
-	return column_name + " IS NOT NULL";
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-unique_ptr<Expression> JoinCondition::CreateExpression(JoinCondition cond) {
-	auto bound_comparison = make_unique<BoundComparisonExpression>(cond.comparison, move(cond.left), move(cond.right));
-	return move(bound_comparison);
-}
-
-unique_ptr<Expression> JoinCondition::CreateExpression(vector<JoinCondition> conditions) {
-	unique_ptr<Expression> result;
-	for (auto &cond : conditions) {
-		auto expr = CreateExpression(move(cond));
-		if (!result) {
-			result = move(expr);
-		} else {
-			auto conj =
-			    make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, move(expr), move(result));
-			result = move(conj);
-		}
-	}
-	return result;
-}
-
-JoinSide JoinSide::CombineJoinSide(JoinSide left, JoinSide right) {
-	if (left == JoinSide::NONE) {
-		return right;
-	}
-	if (right == JoinSide::NONE) {
-		return left;
-	}
-	if (left != right) {
-		return JoinSide::BOTH;
-	}
-	return left;
-}
-
-JoinSide JoinSide::GetJoinSide(idx_t table_binding, unordered_set<idx_t> &left_bindings,
-                               unordered_set<idx_t> &right_bindings) {
-	if (left_bindings.find(table_binding) != left_bindings.end()) {
-		// column references table on left side
-		D_ASSERT(right_bindings.find(table_binding) == right_bindings.end());
-		return JoinSide::LEFT;
-	} else {
-		// column references table on right side
-		D_ASSERT(right_bindings.find(table_binding) != right_bindings.end());
-		return JoinSide::RIGHT;
-	}
-}
-
-JoinSide JoinSide::GetJoinSide(Expression &expression, unordered_set<idx_t> &left_bindings,
-                               unordered_set<idx_t> &right_bindings) {
-	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expression;
-		if (colref.depth > 0) {
-			throw Exception("Non-inner join on correlated columns not supported");
-		}
-		return GetJoinSide(colref.binding.table_index, left_bindings, right_bindings);
-	}
-	D_ASSERT(expression.type != ExpressionType::BOUND_REF);
-	if (expression.type == ExpressionType::SUBQUERY) {
-		D_ASSERT(expression.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY);
-		auto &subquery = (BoundSubqueryExpression &)expression;
-		JoinSide side = JoinSide::NONE;
-		if (subquery.child) {
-			side = GetJoinSide(*subquery.child, left_bindings, right_bindings);
-		}
-		// correlated subquery, check the side of each of correlated columns in the subquery
-		for (auto &corr : subquery.binder->correlated_columns) {
-			if (corr.depth > 1) {
-				// correlated column has depth > 1
-				// it does not refer to any table in the current set of bindings
-				return JoinSide::BOTH;
-			}
-			auto correlated_side = GetJoinSide(corr.binding.table_index, left_bindings, right_bindings);
-			side = CombineJoinSide(side, correlated_side);
-		}
-		return side;
-	}
-	JoinSide join_side = JoinSide::NONE;
-	ExpressionIterator::EnumerateChildren(expression, [&](Expression &child) {
-		auto child_side = GetJoinSide(child, left_bindings, right_bindings);
-		join_side = CombineJoinSide(child_side, join_side);
-	});
-	return join_side;
-}
-
-JoinSide JoinSide::GetJoinSide(const unordered_set<idx_t> &bindings, unordered_set<idx_t> &left_bindings,
-                               unordered_set<idx_t> &right_bindings) {
-	JoinSide side = JoinSide::NONE;
-	for (auto binding : bindings) {
-		side = CombineJoinSide(side, GetJoinSide(binding, left_bindings, right_bindings));
-	}
-	return side;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-LogicalOperator::LogicalOperator(LogicalOperatorType type) : type(type) {
-}
-
-LogicalOperator::LogicalOperator(LogicalOperatorType type, vector<unique_ptr<Expression>> expressions)
-    : type(type), expressions(move(expressions)) {
-}
-
-LogicalOperator::~LogicalOperator() {
-}
-
-vector<ColumnBinding> LogicalOperator::GetColumnBindings() {
-	return {ColumnBinding(0, 0)};
-}
-
-string LogicalOperator::GetName() const {
-	return LogicalOperatorToString(type);
-}
-
-string LogicalOperator::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (i > 0) {
-			result += "\n";
-		}
-		result += expressions[i]->GetName();
-	}
-	return result;
-}
-
-void LogicalOperator::ResolveOperatorTypes() {
-	// if (types.size() > 0) {
-	// 	// types already resolved for this node
-	// 	return;
-	// }
-	types.clear();
-	// first resolve child types
-	for (auto &child : children) {
-		child->ResolveOperatorTypes();
-	}
-	// now resolve the types for this operator
-	ResolveTypes();
-	D_ASSERT(types.size() == GetColumnBindings().size());
-}
-
-vector<ColumnBinding> LogicalOperator::GenerateColumnBindings(idx_t table_idx, idx_t column_count) {
-	vector<ColumnBinding> result;
-	for (idx_t i = 0; i < column_count; i++) {
-		result.emplace_back(table_idx, i);
-	}
-	return result;
-}
-
-vector<LogicalType> LogicalOperator::MapTypes(const vector<LogicalType> &types, const vector<idx_t> &projection_map) {
-	if (projection_map.empty()) {
-		return types;
-	} else {
-		vector<LogicalType> result_types;
-		result_types.reserve(projection_map.size());
-		for (auto index : projection_map) {
-			result_types.push_back(types[index]);
-		}
-		return result_types;
-	}
-}
-
-vector<ColumnBinding> LogicalOperator::MapBindings(const vector<ColumnBinding> &bindings,
-                                                   const vector<idx_t> &projection_map) {
-	if (projection_map.empty()) {
-		return bindings;
-	} else {
-		vector<ColumnBinding> result_bindings;
-		result_bindings.reserve(projection_map.size());
-		for (auto index : projection_map) {
-			result_bindings.push_back(bindings[index]);
-		}
-		return result_bindings;
-	}
-}
-
-string LogicalOperator::ToString() const {
-	TreeRenderer renderer;
-	return renderer.ToString(*this);
-}
-
-void LogicalOperator::Verify() {
-#ifdef DEBUG
-	// verify expressions
-	for (idx_t expr_idx = 0; expr_idx < expressions.size(); expr_idx++) {
-		auto str = expressions[expr_idx]->ToString();
-		// verify that we can (correctly) copy this expression
-		auto copy = expressions[expr_idx]->Copy();
-		auto original_hash = expressions[expr_idx]->Hash();
-		auto copy_hash = copy->Hash();
-		// copy should be identical to original
-		D_ASSERT(expressions[expr_idx]->ToString() == copy->ToString());
-		D_ASSERT(original_hash == copy_hash);
-		D_ASSERT(Expression::Equals(expressions[expr_idx].get(), copy.get()));
-
-		D_ASSERT(!Expression::Equals(expressions[expr_idx].get(), nullptr));
-		for (idx_t other_idx = 0; other_idx < expr_idx; other_idx++) {
-			// comparison with other expressions
-			auto other_hash = expressions[other_idx]->Hash();
-			bool expr_equal = Expression::Equals(expressions[expr_idx].get(), expressions[other_idx].get());
-			if (original_hash != other_hash) {
-				// if the hashes are not equal the expressions should not be equal either
-				D_ASSERT(!expr_equal);
-			}
-		}
-		D_ASSERT(!str.empty());
-	}
-	D_ASSERT(!ToString().empty());
-	for (auto &child : children) {
-		child->Verify();
-	}
-#endif
-}
-
-void LogicalOperator::AddChild(unique_ptr<LogicalOperator> child) {
-	D_ASSERT(child);
-	children.push_back(move(child));
-}
-
-idx_t LogicalOperator::EstimateCardinality(ClientContext &context) {
-	// simple estimator, just take the max of the children
-	idx_t max_cardinality = 0;
-	for (auto &child : children) {
-		max_cardinality = MaxValue(child->EstimateCardinality(context), max_cardinality);
-	}
-	return max_cardinality;
-}
-
-void LogicalOperator::Print() {
-	Printer::Print(ToString());
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-void LogicalOperatorVisitor::VisitOperator(LogicalOperator &op) {
-	VisitOperatorChildren(op);
-	VisitOperatorExpressions(op);
-}
-
-void LogicalOperatorVisitor::VisitOperatorChildren(LogicalOperator &op) {
-	for (auto &child : op.children) {
-		VisitOperator(*child);
-	}
-}
-
-void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
-                                                  const std::function<void(unique_ptr<Expression> *child)> &callback) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
-		auto &get = (LogicalExpressionGet &)op;
-		for (auto &expr_list : get.expressions) {
-			for (auto &expr : expr_list) {
-				callback(&expr);
-			}
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ORDER_BY: {
-		auto &order = (LogicalOrder &)op;
-		for (auto &node : order.orders) {
-			callback(&node.expression);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_TOP_N: {
-		auto &order = (LogicalTopN &)op;
-		for (auto &node : order.orders) {
-			callback(&node.expression);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		auto &distinct = (LogicalDistinct &)op;
-		for (auto &target : distinct.distinct_targets) {
-			callback(&target);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-			auto &delim_join = (LogicalDelimJoin &)op;
-			for (auto &expr : delim_join.duplicate_eliminated_columns) {
-				callback(&expr);
-			}
-		}
-		auto &join = (LogicalComparisonJoin &)op;
-		for (auto &cond : join.conditions) {
-			callback(&cond.left);
-			callback(&cond.right);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		auto &join = (LogicalAnyJoin &)op;
-		callback(&join.condition);
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_LIMIT: {
-		auto &limit = (LogicalLimit &)op;
-		if (limit.limit) {
-			callback(&limit.limit);
-		}
-		if (limit.offset) {
-			callback(&limit.offset);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: {
-		auto &limit = (LogicalLimitPercent &)op;
-		if (limit.limit) {
-			callback(&limit.limit);
-		}
-		if (limit.offset) {
-			callback(&limit.offset);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		auto &aggr = (LogicalAggregate &)op;
-		for (auto &group : aggr.groups) {
-			callback(&group);
-		}
-		break;
-	}
-	default:
-		break;
-	}
-	for (auto &expression : op.expressions) {
-		callback(&expression);
-	}
-}
-
-void LogicalOperatorVisitor::VisitOperatorExpressions(LogicalOperator &op) {
-	LogicalOperatorVisitor::EnumerateExpressions(op, [&](unique_ptr<Expression> *child) { VisitExpression(child); });
-}
-
-void LogicalOperatorVisitor::VisitExpression(unique_ptr<Expression> *expression) {
-	auto &expr = **expression;
-	unique_ptr<Expression> result;
-	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::BOUND_AGGREGATE:
-		result = VisitReplace((BoundAggregateExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_BETWEEN:
-		result = VisitReplace((BoundBetweenExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_CASE:
-		result = VisitReplace((BoundCaseExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_CAST:
-		result = VisitReplace((BoundCastExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_COLUMN_REF:
-		result = VisitReplace((BoundColumnRefExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_COMPARISON:
-		result = VisitReplace((BoundComparisonExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_CONJUNCTION:
-		result = VisitReplace((BoundConjunctionExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_CONSTANT:
-		result = VisitReplace((BoundConstantExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_FUNCTION:
-		result = VisitReplace((BoundFunctionExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_SUBQUERY:
-		result = VisitReplace((BoundSubqueryExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_OPERATOR:
-		result = VisitReplace((BoundOperatorExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_PARAMETER:
-		result = VisitReplace((BoundParameterExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_REF:
-		result = VisitReplace((BoundReferenceExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_DEFAULT:
-		result = VisitReplace((BoundDefaultExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_WINDOW:
-		result = VisitReplace((BoundWindowExpression &)expr, expression);
-		break;
-	case ExpressionClass::BOUND_UNNEST:
-		result = VisitReplace((BoundUnnestExpression &)expr, expression);
-		break;
-	default:
-		throw InternalException("Unrecognized expression type in logical operator visitor");
-	}
-	if (result) {
-		*expression = move(result);
-	} else {
-		// visit the children of this node
-		VisitExpressionChildren(expr);
-	}
-}
-
-void LogicalOperatorVisitor::VisitExpressionChildren(Expression &expr) {
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { VisitExpression(&expr); });
-}
-
-// these are all default methods that can be overriden
-// we don't care about coverage here
-// LCOV_EXCL_START
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundAggregateExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundBetweenExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundCaseExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundCastExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundColumnRefExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundComparisonExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundConjunctionExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundConstantExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundDefaultExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundFunctionExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundOperatorExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundParameterExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundReferenceExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundSubqueryExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundWindowExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-unique_ptr<Expression> LogicalOperatorVisitor::VisitReplace(BoundUnnestExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	return nullptr;
-}
-
-// LCOV_EXCL_STOP
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-LogicalAggregate::LogicalAggregate(idx_t group_index, idx_t aggregate_index, vector<unique_ptr<Expression>> select_list)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY, move(select_list)), group_index(group_index),
-      aggregate_index(aggregate_index), groupings_index(DConstants::INVALID_INDEX) {
-}
-
-void LogicalAggregate::ResolveTypes() {
-	D_ASSERT(groupings_index != DConstants::INVALID_INDEX || grouping_functions.empty());
-	for (auto &expr : groups) {
-		types.push_back(expr->return_type);
-	}
-	// get the chunk types from the projection list
-	for (auto &expr : expressions) {
-		types.push_back(expr->return_type);
-	}
-	for (idx_t i = 0; i < grouping_functions.size(); i++) {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-}
-
-vector<ColumnBinding> LogicalAggregate::GetColumnBindings() {
-	D_ASSERT(groupings_index != DConstants::INVALID_INDEX || grouping_functions.empty());
-	vector<ColumnBinding> result;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		result.emplace_back(group_index, i);
-	}
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		result.emplace_back(aggregate_index, i);
-	}
-	for (idx_t i = 0; i < grouping_functions.size(); i++) {
-		result.emplace_back(groupings_index, i);
-	}
-	return result;
-}
-
-string LogicalAggregate::ParamsToString() const {
-	string result;
-	for (idx_t i = 0; i < groups.size(); i++) {
-		if (i > 0) {
-			result += "\n";
-		}
-		result += groups[i]->GetName();
-	}
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (i > 0 || !groups.empty()) {
-			result += "\n";
-		}
-		result += expressions[i]->GetName();
-	}
-	return result;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-LogicalAnyJoin::LogicalAnyJoin(JoinType type) : LogicalJoin(type, LogicalOperatorType::LOGICAL_ANY_JOIN) {
-}
-
-string LogicalAnyJoin::ParamsToString() const {
-	return condition->ToString();
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-LogicalComparisonJoin::LogicalComparisonJoin(JoinType join_type, LogicalOperatorType logical_type)
-    : LogicalJoin(join_type, logical_type) {
-}
-
-string LogicalComparisonJoin::ParamsToString() const {
-	string result = JoinTypeToString(join_type);
-	for (auto &condition : conditions) {
-		result += "\n";
-		auto expr = make_unique<BoundComparisonExpression>(condition.comparison, condition.left->Copy(),
-		                                                   condition.right->Copy());
-		result += expr->ToString();
-	}
-
-	return result;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-LogicalCrossProduct::LogicalCrossProduct() : LogicalOperator(LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
-}
-
-vector<ColumnBinding> LogicalCrossProduct::GetColumnBindings() {
-	auto left_bindings = children[0]->GetColumnBindings();
-	auto right_bindings = children[1]->GetColumnBindings();
-	left_bindings.insert(left_bindings.end(), right_bindings.begin(), right_bindings.end());
-	return left_bindings;
-}
-
-void LogicalCrossProduct::ResolveTypes() {
-	types.insert(types.end(), children[0]->types.begin(), children[0]->types.end());
-	types.insert(types.end(), children[1]->types.begin(), children[1]->types.end());
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-string LogicalDistinct::ParamsToString() const {
-	string result = LogicalOperator::ParamsToString();
-	if (!distinct_targets.empty()) {
-		result += StringUtil::Join(distinct_targets, distinct_targets.size(), "\n",
-		                           [](const unique_ptr<Expression> &child) { return child->GetName(); });
-	}
-
-	return result;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-LogicalEmptyResult::LogicalEmptyResult(unique_ptr<LogicalOperator> op)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
-
-	this->bindings = op->GetColumnBindings();
-
-	op->ResolveOperatorTypes();
-	this->return_types = op->types;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-LogicalFilter::LogicalFilter(unique_ptr<Expression> expression) : LogicalOperator(LogicalOperatorType::LOGICAL_FILTER) {
-	expressions.push_back(move(expression));
-	SplitPredicates(expressions);
-}
-
-LogicalFilter::LogicalFilter() : LogicalOperator(LogicalOperatorType::LOGICAL_FILTER) {
-}
-
-void LogicalFilter::ResolveTypes() {
-	types = MapTypes(children[0]->types, projection_map);
-}
-
-vector<ColumnBinding> LogicalFilter::GetColumnBindings() {
-	return MapBindings(children[0]->GetColumnBindings(), projection_map);
-}
-
-// Split the predicates separated by AND statements
-// These are the predicates that are safe to push down because all of them MUST
-// be true
-bool LogicalFilter::SplitPredicates(vector<unique_ptr<Expression>> &expressions) {
-	bool found_conjunction = false;
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		if (expressions[i]->type == ExpressionType::CONJUNCTION_AND) {
-			auto &conjunction = (BoundConjunctionExpression &)*expressions[i];
-			found_conjunction = true;
-			// AND expression, append the other children
-			for (idx_t k = 1; k < conjunction.children.size(); k++) {
-				expressions.push_back(move(conjunction.children[k]));
-			}
-			// replace this expression with the first child of the conjunction
-			expressions[i] = move(conjunction.children[0]);
-			// we move back by one so the right child is checked again
-			// in case it is an AND expression as well
-			i--;
-		}
-	}
-	return found_conjunction;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
-                       vector<LogicalType> returned_types, vector<string> returned_names)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_GET), table_index(table_index), function(move(function)),
-      bind_data(move(bind_data)), returned_types(move(returned_types)), names(move(returned_names)) {
-}
-
-string LogicalGet::GetName() const {
-	return StringUtil::Upper(function.name);
-}
-
-TableCatalogEntry *LogicalGet::GetTable() const {
-	return TableScanFunction::GetTableEntry(function, bind_data.get());
-}
-
-string LogicalGet::ParamsToString() const {
-	string result;
-	for (auto &kv : table_filters.filters) {
-		auto &column_index = kv.first;
-		auto &filter = kv.second;
-		if (column_index < names.size()) {
-			result += filter->ToString(names[column_index]);
-		}
-		result += "\n";
-	}
-	if (!function.to_string) {
-		return string();
-	}
-	return function.to_string(bind_data.get());
-}
-
-vector<ColumnBinding> LogicalGet::GetColumnBindings() {
-	if (column_ids.empty()) {
-		return {ColumnBinding(table_index, 0)};
-	}
-	vector<ColumnBinding> result;
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		result.emplace_back(table_index, i);
-	}
-	return result;
-}
-
-void LogicalGet::ResolveTypes() {
-	if (column_ids.empty()) {
-		column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-	}
-	for (auto &index : column_ids) {
-		if (index == COLUMN_IDENTIFIER_ROW_ID) {
-			types.emplace_back(LogicalType::ROW_TYPE);
-		} else {
-			types.push_back(returned_types[index]);
-		}
-	}
-}
-
-idx_t LogicalGet::EstimateCardinality(ClientContext &context) {
-	if (function.cardinality) {
-		auto node_stats = function.cardinality(context, bind_data.get());
-		if (node_stats && node_stats->has_estimated_cardinality) {
-			return node_stats->estimated_cardinality;
-		}
-	}
-	return 1;
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-LogicalJoin::LogicalJoin(JoinType join_type, LogicalOperatorType logical_type)
-    : LogicalOperator(logical_type), join_type(join_type) {
-}
-
-vector<ColumnBinding> LogicalJoin::GetColumnBindings() {
-	auto left_bindings = MapBindings(children[0]->GetColumnBindings(), left_projection_map);
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		// for SEMI and ANTI join we only project the left hand side
-		return left_bindings;
-	}
-	if (join_type == JoinType::MARK) {
-		// for MARK join we project the left hand side plus the MARK column
-		left_bindings.emplace_back(mark_index, 0);
-		return left_bindings;
-	}
-	// for other join types we project both the LHS and the RHS
-	auto right_bindings = MapBindings(children[1]->GetColumnBindings(), right_projection_map);
-	left_bindings.insert(left_bindings.end(), right_bindings.begin(), right_bindings.end());
-	return left_bindings;
-}
-
-void LogicalJoin::ResolveTypes() {
-	types = MapTypes(children[0]->types, left_projection_map);
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		// for SEMI and ANTI join we only project the left hand side
-		return;
-	}
-	if (join_type == JoinType::MARK) {
-		// for MARK join we project the left hand side, plus a BOOLEAN column indicating the MARK
-		types.emplace_back(LogicalType::BOOLEAN);
-		return;
-	}
-	// for any other join we project both sides
-	auto right_types = MapTypes(children[1]->types, right_projection_map);
-	types.insert(types.end(), right_types.begin(), right_types.end());
-}
-
-void LogicalJoin::GetTableReferences(LogicalOperator &op, unordered_set<idx_t> &bindings) {
-	auto column_bindings = op.GetColumnBindings();
-	for (auto binding : column_bindings) {
-		bindings.insert(binding.table_index);
-	}
-}
-
-void LogicalJoin::GetExpressionBindings(Expression &expr, unordered_set<idx_t> &bindings) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expr;
-		D_ASSERT(colref.depth == 0);
-		bindings.insert(colref.binding.table_index);
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { GetExpressionBindings(child, bindings); });
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-LogicalLimit::LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr<Expression> limit,
-                           unique_ptr<Expression> offset)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(limit_val), offset_val(offset_val),
-      limit(move(limit)), offset(move(offset)) {
-}
-
-vector<ColumnBinding> LogicalLimit::GetColumnBindings() {
-	return children[0]->GetColumnBindings();
-}
-
-idx_t LogicalLimit::EstimateCardinality(ClientContext &context) {
-	auto child_cardinality = children[0]->EstimateCardinality(context);
-	if (limit_val >= 0 && idx_t(limit_val) < child_cardinality) {
-		child_cardinality = limit_val;
-	}
-	return child_cardinality;
-}
-
-void LogicalLimit::ResolveTypes() {
-	types = children[0]->types;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-LogicalProjection::LogicalProjection(idx_t table_index, vector<unique_ptr<Expression>> select_list)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_PROJECTION, move(select_list)), table_index(table_index) {
-}
-
-vector<ColumnBinding> LogicalProjection::GetColumnBindings() {
-	return GenerateColumnBindings(table_index, expressions.size());
-}
-
-void LogicalProjection::ResolveTypes() {
-	for (auto &expr : expressions) {
-		types.push_back(expr->return_type);
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-LogicalSample::LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(move(sample_options_p)) {
-	children.push_back(move(child));
-}
-
-vector<ColumnBinding> LogicalSample::GetColumnBindings() {
-	return children[0]->GetColumnBindings();
-}
-
-idx_t LogicalSample::EstimateCardinality(ClientContext &context) {
-	auto child_cardinality = children[0]->EstimateCardinality(context);
-	if (sample_options->is_percentage) {
-		return idx_t(child_cardinality * sample_options->sample_size.GetValue<double>());
-	} else {
-		auto sample_size = sample_options->sample_size.GetValue<uint64_t>();
-		if (sample_size < child_cardinality) {
-			return sample_size;
-		}
-	}
-	return child_cardinality;
-}
-
-void LogicalSample::ResolveTypes() {
-	types = children[0]->types;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-vector<ColumnBinding> LogicalUnnest::GetColumnBindings() {
-	auto child_bindings = children[0]->GetColumnBindings();
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		child_bindings.emplace_back(unnest_index, i);
-	}
-	return child_bindings;
-}
-
-void LogicalUnnest::ResolveTypes() {
-	types.insert(types.end(), children[0]->types.begin(), children[0]->types.end());
-	for (auto &expr : expressions) {
-		types.push_back(expr->return_type);
-	}
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-vector<ColumnBinding> LogicalWindow::GetColumnBindings() {
-	auto child_bindings = children[0]->GetColumnBindings();
-	for (idx_t i = 0; i < expressions.size(); i++) {
-		child_bindings.emplace_back(window_index, i);
-	}
-	return child_bindings;
-}
-
-void LogicalWindow::ResolveTypes() {
-	types.insert(types.end(), children[0]->types.begin(), children[0]->types.end());
-	for (auto &expr : expressions) {
-		types.push_back(expr->return_type);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-Planner::Planner(ClientContext &context) : binder(Binder::CreateBinder(context)), context(context) {
-}
-
-void Planner::CreatePlan(SQLStatement &statement) {
-	auto &profiler = QueryProfiler::Get(context);
-	auto parameter_count = statement.n_param;
-
-	vector<BoundParameterExpression *> bound_parameters;
-
-	// first bind the tables and columns to the catalog
-	profiler.StartPhase("binder");
-	binder->parameters = &bound_parameters;
-	binder->parameter_types = &parameter_types;
-	auto bound_statement = binder->Bind(statement);
-	profiler.EndPhase();
-
-	this->properties = binder->properties;
-	this->properties.parameter_count = parameter_count;
-	this->names = bound_statement.names;
-	this->types = bound_statement.types;
-	this->plan = move(bound_statement.plan);
-	properties.bound_all_parameters = true;
-
-	// set up a map of parameter number -> value entries
-	for (auto &expr : bound_parameters) {
-		// check if the type of the parameter could be resolved
-		if (expr->return_type.id() == LogicalTypeId::INVALID || expr->return_type.id() == LogicalTypeId::UNKNOWN) {
-			properties.bound_all_parameters = false;
-			continue;
-		}
-		auto value = make_unique<Value>(expr->return_type);
-		expr->value = value.get();
-		// check if the parameter number has been used before
-		auto entry = value_map.find(expr->parameter_nr);
-		if (entry == value_map.end()) {
-			// not used before, create vector
-			value_map[expr->parameter_nr] = vector<unique_ptr<Value>>();
-		} else if (entry->second.back()->type() != value->type()) {
-			// used before, but types are inconsistent
-			throw BinderException(
-			    "Inconsistent types found for parameter with index %llu, current type %s, new type %s",
-			    expr->parameter_nr, entry->second.back()->type().ToString(), value->type().ToString());
-		}
-		value_map[expr->parameter_nr].push_back(move(value));
-	}
-}
-
-shared_ptr<PreparedStatementData> Planner::PrepareSQLStatement(unique_ptr<SQLStatement> statement) {
-	auto copied_statement = statement->Copy();
-	// create a plan of the underlying statement
-	CreatePlan(move(statement));
-	// now create the logical prepare
-	auto prepared_data = make_shared<PreparedStatementData>(copied_statement->type);
-	prepared_data->unbound_statement = move(copied_statement);
-	prepared_data->names = names;
-	prepared_data->types = types;
-	prepared_data->value_map = move(value_map);
-	prepared_data->properties = properties;
-	prepared_data->catalog_version = Transaction::GetTransaction(context).catalog_version;
-	return prepared_data;
-}
-
-void Planner::PlanExecute(unique_ptr<SQLStatement> statement) {
-	auto &stmt = (ExecuteStatement &)*statement;
-	auto parameter_count = stmt.n_param;
-
-	// bind the prepared statement
-	auto &client_data = ClientData::Get(context);
-
-	auto entry = client_data.prepared_statements.find(stmt.name);
-	if (entry == client_data.prepared_statements.end()) {
-		throw BinderException("Prepared statement \"%s\" does not exist", stmt.name);
-	}
-
-	// check if we need to rebind the prepared statement
-	// this happens if the catalog changes, since in this case e.g. tables we relied on may have been deleted
-	auto prepared = entry->second;
-	auto &catalog = Catalog::GetCatalog(context);
-	bool rebound = false;
-
-	// bind any supplied parameters
-	vector<Value> bind_values;
-	for (idx_t i = 0; i < stmt.values.size(); i++) {
-		ConstantBinder cbinder(*binder, context, "EXECUTE statement");
-		auto bound_expr = cbinder.Bind(stmt.values[i]);
-
-		Value value = ExpressionExecutor::EvaluateScalar(*bound_expr);
-		bind_values.push_back(move(value));
-	}
-	bool all_bound = prepared->properties.bound_all_parameters;
-	if (catalog.GetCatalogVersion() != entry->second->catalog_version || !all_bound) {
-		// catalog was modified or statement does not have clear types: rebind the statement before running the execute
-		for (auto &value : bind_values) {
-			parameter_types.push_back(value.type());
-		}
-		prepared = PrepareSQLStatement(entry->second->unbound_statement->Copy());
-		if (all_bound && prepared->types != entry->second->types) {
-			throw BinderException("Rebinding statement \"%s\" after catalog change resulted in change of types",
-			                      stmt.name);
-		}
-		D_ASSERT(prepared->properties.bound_all_parameters);
-		rebound = true;
-	}
-	// copy the properties of the prepared statement into the planner
-	this->properties = prepared->properties;
-	this->properties.parameter_count = parameter_count;
-	this->names = prepared->names;
-	this->types = prepared->types;
-
-	// add casts to the prepared statement parameters as required
-	for (idx_t i = 0; i < bind_values.size(); i++) {
-		if (prepared->value_map.count(i + 1) == 0) {
-			continue;
-		}
-		bind_values[i] = bind_values[i].CastAs(prepared->GetType(i + 1));
-	}
-
-	prepared->Bind(move(bind_values));
-	if (rebound) {
-		auto execute_plan = make_unique<LogicalExecute>(move(prepared));
-		execute_plan->children.push_back(move(plan));
-		this->plan = move(execute_plan);
-		return;
-	}
-
-	this->plan = make_unique<LogicalExecute>(move(prepared));
-}
-
-void Planner::PlanPrepare(unique_ptr<SQLStatement> statement) {
-	auto &stmt = (PrepareStatement &)*statement;
-	auto prepared_data = PrepareSQLStatement(move(stmt.statement));
-
-	auto prepare = make_unique<LogicalPrepare>(stmt.name, move(prepared_data), move(plan));
-	// we can prepare in read-only mode: prepared statements are not written to the catalog
-	properties.read_only = true;
-	// we can always prepare, even if the transaction has been invalidated
-	// this is required because most clients ALWAYS invoke prepared statements
-	properties.requires_valid_transaction = false;
-	properties.allow_stream_result = false;
-	properties.bound_all_parameters = true;
-	properties.parameter_count = 0;
-	properties.return_type = StatementReturnType::NOTHING;
-	this->names = {"Success"};
-	this->types = {LogicalType::BOOLEAN};
-	this->plan = move(prepare);
-}
-
-void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
-	D_ASSERT(statement);
-	switch (statement->type) {
-	case StatementType::SELECT_STATEMENT:
-	case StatementType::INSERT_STATEMENT:
-	case StatementType::COPY_STATEMENT:
-	case StatementType::DELETE_STATEMENT:
-	case StatementType::UPDATE_STATEMENT:
-	case StatementType::CREATE_STATEMENT:
-	case StatementType::DROP_STATEMENT:
-	case StatementType::ALTER_STATEMENT:
-	case StatementType::TRANSACTION_STATEMENT:
-	case StatementType::EXPLAIN_STATEMENT:
-	case StatementType::VACUUM_STATEMENT:
-	case StatementType::RELATION_STATEMENT:
-	case StatementType::CALL_STATEMENT:
-	case StatementType::EXPORT_STATEMENT:
-	case StatementType::PRAGMA_STATEMENT:
-	case StatementType::SHOW_STATEMENT:
-	case StatementType::SET_STATEMENT:
-	case StatementType::LOAD_STATEMENT:
-	case StatementType::EXTENSION_STATEMENT:
-		CreatePlan(*statement);
-		break;
-	case StatementType::EXECUTE_STATEMENT:
-		PlanExecute(move(statement));
-		break;
-	case StatementType::PREPARE_STATEMENT:
-		PlanPrepare(move(statement));
-		break;
-	default:
-		throw NotImplementedException("Cannot plan statement of type %s!", StatementTypeToString(statement->type));
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-PragmaHandler::PragmaHandler(ClientContext &context) : context(context) {
-}
-
-void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatement>> &statements) {
-	vector<unique_ptr<SQLStatement>> new_statements;
-	for (idx_t i = 0; i < statements.size(); i++) {
-		if (statements[i]->type == StatementType::PRAGMA_STATEMENT) {
-			// PRAGMA statement: check if we need to replace it by a new set of statements
-			PragmaHandler handler(context);
-			auto new_query = handler.HandlePragma(statements[i].get()); //*((PragmaStatement &)*statements[i]).info
-			if (!new_query.empty()) {
-				// this PRAGMA statement gets replaced by a new query string
-				// push the new query string through the parser again and add it to the transformer
-				Parser parser(context.GetParserOptions());
-				parser.ParseQuery(new_query);
-				// insert the new statements and remove the old statement
-				// FIXME: off by one here maybe?
-				for (idx_t j = 0; j < parser.statements.size(); j++) {
-					new_statements.push_back(move(parser.statements[j]));
-				}
-				continue;
-			}
-		}
-		new_statements.push_back(move(statements[i]));
-	}
-	statements = move(new_statements);
-}
-
-void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<unique_ptr<SQLStatement>> &statements) {
-	// first check if there are any pragma statements
-	bool found_pragma = false;
-	for (idx_t i = 0; i < statements.size(); i++) {
-		if (statements[i]->type == StatementType::PRAGMA_STATEMENT) {
-			found_pragma = true;
-			break;
-		}
-	}
-	if (!found_pragma) {
-		// no pragmas: skip this step
-		return;
-	}
-	context.RunFunctionInTransactionInternal(lock, [&]() { HandlePragmaStatementsInternal(statements); });
-}
-
-string PragmaHandler::HandlePragma(SQLStatement *statement) { // PragmaInfo &info
-	auto info = *((PragmaStatement &)*statement).info;
-	auto entry =
-	    Catalog::GetCatalog(context).GetEntry<PragmaFunctionCatalogEntry>(context, DEFAULT_SCHEMA, info.name, false);
-	string error;
-	idx_t bound_idx = Function::BindFunction(entry->name, entry->functions, info, error);
-	if (bound_idx == DConstants::INVALID_INDEX) {
-		throw BinderException(error);
-	}
-	auto &bound_function = entry->functions[bound_idx];
-	if (bound_function.query) {
-		QueryErrorContext error_context(statement, statement->stmt_location);
-		Binder::BindNamedParameters(bound_function.named_parameters, info.named_parameters, error_context,
-		                            bound_function.name);
-		FunctionParameters parameters {info.parameters, info.named_parameters};
-		return bound_function.query(context, parameters);
-	}
-	return string();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated,
-                                             bool perform_delim, bool any_join)
-    : binder(binder), correlated_columns(correlated), perform_delim(perform_delim), any_join(any_join) {
-	for (idx_t i = 0; i < correlated_columns.size(); i++) {
-		auto &col = correlated_columns[i];
-		correlated_map[col.binding] = i;
-		delim_types.push_back(col.type);
-	}
-}
-
-bool FlattenDependentJoins::DetectCorrelatedExpressions(LogicalOperator *op) {
-	D_ASSERT(op);
-	// check if this entry has correlated expressions
-	HasCorrelatedExpressions visitor(correlated_columns);
-	visitor.VisitOperator(*op);
-	bool has_correlation = visitor.has_correlated_expressions;
-	// now visit the children of this entry and check if they have correlated expressions
-	for (auto &child : op->children) {
-		// we OR the property with its children such that has_correlation is true if either
-		// (1) this node has a correlated expression or
-		// (2) one of its children has a correlated expression
-		if (DetectCorrelatedExpressions(child.get())) {
-			has_correlation = true;
-		}
-	}
-	// set the entry in the map
-	has_correlated_expressions[op] = has_correlation;
-	return has_correlation;
-}
-
-unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoin(unique_ptr<LogicalOperator> plan) {
-	bool propagate_null_values = true;
-	auto result = PushDownDependentJoinInternal(move(plan), propagate_null_values);
-	if (!replacement_map.empty()) {
-		// check if we have to replace any COUNT aggregates into "CASE WHEN X IS NULL THEN 0 ELSE COUNT END"
-		RewriteCountAggregates aggr(replacement_map);
-		aggr.VisitOperator(*result);
-	}
-	return result;
-}
-
-bool SubqueryDependentFilter(Expression *expr) {
-	if (expr->expression_class == ExpressionClass::BOUND_CONJUNCTION &&
-	    expr->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		auto bound_conjuction = (BoundConjunctionExpression *)expr;
-		for (auto &child : bound_conjuction->children) {
-			if (SubqueryDependentFilter(child.get())) {
-				return true;
-			}
-		}
-	}
-	if (expr->expression_class == ExpressionClass::BOUND_SUBQUERY) {
-		return true;
-	}
-	return false;
-}
-unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal(unique_ptr<LogicalOperator> plan,
-                                                                                 bool &parent_propagate_null_values) {
-	// first check if the logical operator has correlated expressions
-	auto entry = has_correlated_expressions.find(plan.get());
-	D_ASSERT(entry != has_correlated_expressions.end());
-	if (!entry->second) {
-		// we reached a node without correlated expressions
-		// we can eliminate the dependent join now and create a simple cross product
-		auto cross_product = make_unique<LogicalCrossProduct>();
-		// now create the duplicate eliminated scan for this node
-		auto delim_index = binder.GenerateTableIndex();
-		this->base_binding = ColumnBinding(delim_index, 0);
-		auto delim_scan = make_unique<LogicalDelimGet>(delim_index, delim_types);
-		cross_product->children.push_back(move(delim_scan));
-		cross_product->children.push_back(move(plan));
-		return move(cross_product);
-	}
-	switch (plan->type) {
-	case LogicalOperatorType::LOGICAL_UNNEST:
-	case LogicalOperatorType::LOGICAL_FILTER: {
-		// filter
-		// first we flatten the dependent join in the child of the filter
-		for (auto &expr : plan->expressions) {
-			any_join |= SubqueryDependentFilter(expr.get());
-		}
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
-		rewriter.VisitOperator(*plan);
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		// projection
-		// first we flatten the dependent join in the child of the projection
-		for (auto &expr : plan->expressions) {
-			parent_propagate_null_values &= expr->PropagatesNullValues();
-		}
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
-		rewriter.VisitOperator(*plan);
-		// now we add all the columns of the delim_scan to the projection list
-		auto proj = (LogicalProjection *)plan.get();
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			auto &col = correlated_columns[i];
-			auto colref = make_unique<BoundColumnRefExpression>(
-			    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			plan->expressions.push_back(move(colref));
-		}
-
-		base_binding.table_index = proj->table_index;
-		this->delim_offset = base_binding.column_index = plan->expressions.size() - correlated_columns.size();
-		this->data_offset = 0;
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		auto &aggr = (LogicalAggregate &)*plan;
-		// aggregate and group by
-		// first we flatten the dependent join in the child of the projection
-		for (auto &expr : plan->expressions) {
-			parent_propagate_null_values &= expr->PropagatesNullValues();
-		}
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
-		rewriter.VisitOperator(*plan);
-		// now we add all the columns of the delim_scan to the grouping operators AND the projection list
-		idx_t delim_table_index;
-		idx_t delim_column_offset;
-		idx_t delim_data_offset;
-		auto new_group_count = perform_delim ? correlated_columns.size() : 1;
-		for (idx_t i = 0; i < new_group_count; i++) {
-			auto &col = correlated_columns[i];
-			auto colref = make_unique<BoundColumnRefExpression>(
-			    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			for (auto &set : aggr.grouping_sets) {
-				set.insert(aggr.groups.size());
-			}
-			aggr.groups.push_back(move(colref));
-		}
-		if (!perform_delim) {
-			// if we are not performing the duplicate elimination, we have only added the row_id column to the grouping
-			// operators in this case, we push a FIRST aggregate for each of the remaining expressions
-			delim_table_index = aggr.aggregate_index;
-			delim_column_offset = aggr.expressions.size();
-			delim_data_offset = aggr.groups.size();
-			for (idx_t i = 0; i < correlated_columns.size(); i++) {
-				auto &col = correlated_columns[i];
-				auto first_aggregate = FirstFun::GetFunction(col.type);
-				auto colref = make_unique<BoundColumnRefExpression>(
-				    col.name, col.type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-				vector<unique_ptr<Expression>> aggr_children;
-				aggr_children.push_back(move(colref));
-				auto first_fun = make_unique<BoundAggregateExpression>(move(first_aggregate), move(aggr_children),
-				                                                       nullptr, nullptr, false);
-				aggr.expressions.push_back(move(first_fun));
-			}
-		} else {
-			delim_table_index = aggr.group_index;
-			delim_column_offset = aggr.groups.size() - correlated_columns.size();
-			delim_data_offset = aggr.groups.size();
-		}
-		if (aggr.groups.size() == new_group_count) {
-			// we have to perform a LEFT OUTER JOIN between the result of this aggregate and the delim scan
-			// FIXME: this does not always have to be a LEFT OUTER JOIN, depending on whether aggr.expressions return
-			// NULL or a value
-			unique_ptr<LogicalComparisonJoin> join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
-			for (auto &aggr_exp : aggr.expressions) {
-				auto b_aggr_exp = (BoundAggregateExpression *)aggr_exp.get();
-				if (!b_aggr_exp->PropagatesNullValues() || any_join || !parent_propagate_null_values) {
-					join = make_unique<LogicalComparisonJoin>(JoinType::LEFT);
-					break;
-				}
-			}
-			auto left_index = binder.GenerateTableIndex();
-			auto delim_scan = make_unique<LogicalDelimGet>(left_index, delim_types);
-			join->children.push_back(move(delim_scan));
-			join->children.push_back(move(plan));
-			for (idx_t i = 0; i < new_group_count; i++) {
-				auto &col = correlated_columns[i];
-				JoinCondition cond;
-				cond.left = make_unique<BoundColumnRefExpression>(col.name, col.type, ColumnBinding(left_index, i));
-				cond.right = make_unique<BoundColumnRefExpression>(
-				    correlated_columns[i].type, ColumnBinding(delim_table_index, delim_column_offset + i));
-				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-				join->conditions.push_back(move(cond));
-			}
-			// for any COUNT aggregate we replace references to the column with: CASE WHEN COUNT(*) IS NULL THEN 0
-			// ELSE COUNT(*) END
-			for (idx_t i = 0; i < aggr.expressions.size(); i++) {
-				D_ASSERT(aggr.expressions[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-				auto bound = (BoundAggregateExpression *)&*aggr.expressions[i];
-				vector<LogicalType> arguments;
-				if (bound->function == CountFun::GetFunction() || bound->function == CountStarFun::GetFunction()) {
-					// have to replace this ColumnBinding with the CASE expression
-					replacement_map[ColumnBinding(aggr.aggregate_index, i)] = i;
-				}
-			}
-			// now we update the delim_index
-			base_binding.table_index = left_index;
-			this->delim_offset = base_binding.column_index = 0;
-			this->data_offset = 0;
-			return move(join);
-		} else {
-			// update the delim_index
-			base_binding.table_index = delim_table_index;
-			this->delim_offset = base_binding.column_index = delim_column_offset;
-			this->data_offset = delim_data_offset;
-			return plan;
-		}
-	}
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
-		// cross product
-		// push into both sides of the plan
-		bool left_has_correlation = has_correlated_expressions.find(plan->children[0].get())->second;
-		bool right_has_correlation = has_correlated_expressions.find(plan->children[1].get())->second;
-		if (!right_has_correlation) {
-			// only left has correlation: push into left
-			plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-			return plan;
-		}
-		if (!left_has_correlation) {
-			// only right has correlation: push into right
-			plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
-			return plan;
-		}
-		// both sides have correlation
-		// turn into an inner join
-		auto join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-		auto left_binding = this->base_binding;
-		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
-		// add the correlated columns to the join conditions
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			JoinCondition cond;
-			cond.left = make_unique<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(left_binding.table_index, left_binding.column_index + i));
-			cond.right = make_unique<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-			join->conditions.push_back(move(cond));
-		}
-		join->children.push_back(move(plan->children[0]));
-		join->children.push_back(move(plan->children[1]));
-		return move(join);
-	}
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = (LogicalJoin &)*plan;
-		D_ASSERT(plan->children.size() == 2);
-		// check the correlated expressions in the children of the join
-		bool left_has_correlation = has_correlated_expressions.find(plan->children[0].get())->second;
-		bool right_has_correlation = has_correlated_expressions.find(plan->children[1].get())->second;
-
-		if (join.join_type == JoinType::INNER) {
-			// inner join
-			if (!right_has_correlation) {
-				// only left has correlation: push into left
-				plan->children[0] =
-				    PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-				return plan;
-			}
-			if (!left_has_correlation) {
-				// only right has correlation: push into right
-				plan->children[1] =
-				    PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
-				return plan;
-			}
-		} else if (join.join_type == JoinType::LEFT) {
-			// left outer join
-			if (!right_has_correlation) {
-				// only left has correlation: push into left
-				plan->children[0] =
-				    PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-				return plan;
-			}
-		} else if (join.join_type == JoinType::RIGHT) {
-			// left outer join
-			if (!left_has_correlation) {
-				// only right has correlation: push into right
-				plan->children[1] =
-				    PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
-				return plan;
-			}
-		} else if (join.join_type == JoinType::MARK) {
-			if (right_has_correlation) {
-				throw Exception("MARK join with correlation in RHS not supported");
-			}
-			// push the child into the LHS
-			plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-			// rewrite expressions in the join conditions
-			RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
-			rewriter.VisitOperator(*plan);
-			return plan;
-		} else {
-			throw Exception("Unsupported join type for flattening correlated subquery");
-		}
-		// both sides have correlation
-		// push into both sides
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-		auto left_binding = this->base_binding;
-		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
-		auto right_binding = this->base_binding;
-		// NOTE: for OUTER JOINS it matters what the BASE BINDING is after the join
-		// for the LEFT OUTER JOIN, we want the LEFT side to be the base binding after we push
-		// because the RIGHT binding might contain NULL values
-		if (join.join_type == JoinType::LEFT) {
-			this->base_binding = left_binding;
-		} else if (join.join_type == JoinType::RIGHT) {
-			this->base_binding = right_binding;
-		}
-		// add the correlated columns to the join conditions
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			auto left = make_unique<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(left_binding.table_index, left_binding.column_index + i));
-			auto right = make_unique<BoundColumnRefExpression>(
-			    correlated_columns[i].type, ColumnBinding(right_binding.table_index, right_binding.column_index + i));
-
-			if (join.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-				JoinCondition cond;
-				cond.left = move(left);
-				cond.right = move(right);
-				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-
-				auto &comparison_join = (LogicalComparisonJoin &)join;
-				comparison_join.conditions.push_back(move(cond));
-			} else {
-				auto &any_join = (LogicalAnyJoin &)join;
-				auto comparison = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
-				                                                         move(left), move(right));
-				auto conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-				                                                           move(comparison), move(any_join.condition));
-				any_join.condition = move(conjunction);
-			}
-		}
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(right_binding, correlated_map);
-		rewriter.VisitOperator(*plan);
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_LIMIT: {
-		auto &limit = (LogicalLimit &)*plan;
-		if (limit.offset_val > 0) {
-			throw ParserException("OFFSET not supported in correlated subquery");
-		}
-		if (limit.limit) {
-			throw ParserException("Non-constant limit not supported in correlated subquery");
-		}
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-		if (limit.limit_val == 0) {
-			// limit = 0 means we return zero columns here
-			return plan;
-		} else {
-			// limit > 0 does nothing
-			return move(plan->children[0]);
-		}
-	}
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: {
-		throw ParserException("Limit percent operator not supported in correlated subquery");
-	}
-	case LogicalOperatorType::LOGICAL_WINDOW: {
-		auto &window = (LogicalWindow &)*plan;
-		// push into children
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-		// add the correlated columns to the PARTITION BY clauses in the Window
-		for (auto &expr : window.expressions) {
-			D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-			auto &w = (BoundWindowExpression &)*expr;
-			for (idx_t i = 0; i < correlated_columns.size(); i++) {
-				w.partitions.push_back(make_unique<BoundColumnRefExpression>(
-				    correlated_columns[i].type,
-				    ColumnBinding(base_binding.table_index, base_binding.column_index + i)));
-			}
-		}
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_UNION: {
-		auto &setop = (LogicalSetOperation &)*plan;
-		// set operator, push into both children
-		plan->children[0] = PushDownDependentJoin(move(plan->children[0]));
-		plan->children[1] = PushDownDependentJoin(move(plan->children[1]));
-		// we have to refer to the setop index now
-		base_binding.table_index = setop.table_index;
-		base_binding.column_index = setop.column_count;
-		setop.column_count += correlated_columns.size();
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		plan->children[0] = PushDownDependentJoin(move(plan->children[0]));
-		return plan;
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
-		// expression get
-		// first we flatten the dependent join in the child
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
-		// then we replace any correlated expressions with the corresponding entry in the correlated_map
-		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
-		rewriter.VisitOperator(*plan);
-		// now we add all the correlated columns to each of the expressions of the expression scan
-		auto expr_get = (LogicalExpressionGet *)plan.get();
-		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			for (auto &expr_list : expr_get->expressions) {
-				auto colref = make_unique<BoundColumnRefExpression>(
-				    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-				expr_list.push_back(move(colref));
-			}
-			expr_get->expr_types.push_back(correlated_columns[i].type);
-		}
-
-		base_binding.table_index = expr_get->table_index;
-		this->delim_offset = base_binding.column_index = expr_get->expr_types.size() - correlated_columns.size();
-		this->data_offset = 0;
-		return plan;
-	}
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		throw ParserException("ORDER BY not supported in correlated subquery");
-	default:
-		throw InternalException("Logical operator type \"%s\" for dependent join", LogicalOperatorToString(plan->type));
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-HasCorrelatedExpressions::HasCorrelatedExpressions(const vector<CorrelatedColumnInfo> &correlated)
-    : has_correlated_expressions(false), correlated_columns(correlated) {
-}
-
-void HasCorrelatedExpressions::VisitOperator(LogicalOperator &op) {
-	//! The HasCorrelatedExpressions does not recursively visit logical operators, it only visits the current one
-	VisitOperatorExpressions(op);
-}
-
-unique_ptr<Expression> HasCorrelatedExpressions::VisitReplace(BoundColumnRefExpression &expr,
-                                                              unique_ptr<Expression> *expr_ptr) {
-	if (expr.depth == 0) {
-		return nullptr;
-	}
-	// correlated column reference
-	D_ASSERT(expr.depth == 1);
-	has_correlated_expressions = true;
-	return nullptr;
-}
-
-unique_ptr<Expression> HasCorrelatedExpressions::VisitReplace(BoundSubqueryExpression &expr,
-                                                              unique_ptr<Expression> *expr_ptr) {
-	if (!expr.IsCorrelated()) {
-		return nullptr;
-	}
-	// check if the subquery contains any of the correlated expressions that we are concerned about in this node
-	for (idx_t i = 0; i < correlated_columns.size(); i++) {
-		if (std::find(expr.binder->correlated_columns.begin(), expr.binder->correlated_columns.end(),
-		              correlated_columns[i]) != expr.binder->correlated_columns.end()) {
-			has_correlated_expressions = true;
-			break;
-		}
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-RewriteCorrelatedExpressions::RewriteCorrelatedExpressions(ColumnBinding base_binding,
-                                                           column_binding_map_t<idx_t> &correlated_map)
-    : base_binding(base_binding), correlated_map(correlated_map) {
-}
-
-void RewriteCorrelatedExpressions::VisitOperator(LogicalOperator &op) {
-	VisitOperatorExpressions(op);
-}
-
-unique_ptr<Expression> RewriteCorrelatedExpressions::VisitReplace(BoundColumnRefExpression &expr,
-                                                                  unique_ptr<Expression> *expr_ptr) {
-	if (expr.depth == 0) {
-		return nullptr;
-	}
-	// correlated column reference
-	// replace with the entry referring to the duplicate eliminated scan
-	// if this assertion occurs it generally means the correlated expressions were not propagated correctly
-	// through different binders
-	D_ASSERT(expr.depth == 1);
-	auto entry = correlated_map.find(expr.binding);
-	D_ASSERT(entry != correlated_map.end());
-
-	expr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
-	expr.depth = 0;
-	return nullptr;
-}
-
-unique_ptr<Expression> RewriteCorrelatedExpressions::VisitReplace(BoundSubqueryExpression &expr,
-                                                                  unique_ptr<Expression> *expr_ptr) {
-	if (!expr.IsCorrelated()) {
-		return nullptr;
-	}
-	// subquery detected within this subquery
-	// recursively rewrite it using the RewriteCorrelatedRecursive class
-	RewriteCorrelatedRecursive rewrite(expr, base_binding, correlated_map);
-	rewrite.RewriteCorrelatedSubquery(expr);
-	return nullptr;
-}
-
-RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedRecursive(
-    BoundSubqueryExpression &parent, ColumnBinding base_binding, column_binding_map_t<idx_t> &correlated_map)
-    : parent(parent), base_binding(base_binding), correlated_map(correlated_map) {
-}
-
-void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedSubquery(
-    BoundSubqueryExpression &expr) {
-	// rewrite the binding in the correlated list of the subquery)
-	for (auto &corr : expr.binder->correlated_columns) {
-		auto entry = correlated_map.find(corr.binding);
-		if (entry != correlated_map.end()) {
-			corr.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
-		}
-	}
-	// now rewrite any correlated BoundColumnRef expressions inside the subquery
-	ExpressionIterator::EnumerateQueryNodeChildren(*expr.subquery,
-	                                               [&](Expression &child) { RewriteCorrelatedExpressions(child); });
-}
-
-void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedExpressions(Expression &child) {
-	if (child.type == ExpressionType::BOUND_COLUMN_REF) {
-		// bound column reference
-		auto &bound_colref = (BoundColumnRefExpression &)child;
-		if (bound_colref.depth == 0) {
-			// not a correlated column, ignore
-			return;
-		}
-		// correlated column
-		// check the correlated map
-		auto entry = correlated_map.find(bound_colref.binding);
-		if (entry != correlated_map.end()) {
-			// we found the column in the correlated map!
-			// update the binding and reduce the depth by 1
-			bound_colref.binding = ColumnBinding(base_binding.table_index, base_binding.column_index + entry->second);
-			bound_colref.depth--;
-		}
-	} else if (child.type == ExpressionType::SUBQUERY) {
-		// we encountered another subquery: rewrite recursively
-		D_ASSERT(child.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY);
-		auto &bound_subquery = (BoundSubqueryExpression &)child;
-		RewriteCorrelatedRecursive rewrite(bound_subquery, base_binding, correlated_map);
-		rewrite.RewriteCorrelatedSubquery(bound_subquery);
-	}
-}
-
-RewriteCountAggregates::RewriteCountAggregates(column_binding_map_t<idx_t> &replacement_map)
-    : replacement_map(replacement_map) {
-}
-
-unique_ptr<Expression> RewriteCountAggregates::VisitReplace(BoundColumnRefExpression &expr,
-                                                            unique_ptr<Expression> *expr_ptr) {
-	auto entry = replacement_map.find(expr.binding);
-	if (entry != replacement_map.end()) {
-		// reference to a COUNT(*) aggregate
-		// replace this with CASE WHEN COUNT(*) IS NULL THEN 0 ELSE COUNT(*) END
-		auto is_null = make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NULL, LogicalType::BOOLEAN);
-		is_null->children.push_back(expr.Copy());
-		auto check = move(is_null);
-		auto result_if_true = make_unique<BoundConstantExpression>(Value::Numeric(expr.return_type, 0));
-		auto result_if_false = move(*expr_ptr);
-		return make_unique<BoundCaseExpression>(move(check), move(result_if_true), move(result_if_false));
-	}
-	return nullptr;
-}
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-8.cpp b/velox/external/duckdb/duckdb-8.cpp
deleted file mode 100644
index 780ee3895f3ce..0000000000000
--- a/velox/external/duckdb/duckdb-8.cpp
+++ /dev/null
@@ -1,15113 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-Binding::Binding(BindingType binding_type, const string &alias, vector<LogicalType> coltypes, vector<string> colnames,
-                 idx_t index)
-    : binding_type(binding_type), alias(alias), index(index), types(move(coltypes)), names(move(colnames)) {
-	D_ASSERT(types.size() == names.size());
-	for (idx_t i = 0; i < names.size(); i++) {
-		auto &name = names[i];
-		D_ASSERT(!name.empty());
-		if (name_map.find(name) != name_map.end()) {
-			throw BinderException("table \"%s\" has duplicate column name \"%s\"", alias, name);
-		}
-		name_map[name] = i;
-	}
-}
-
-bool Binding::TryGetBindingIndex(const string &column_name, column_t &result) {
-	auto entry = name_map.find(column_name);
-	if (entry == name_map.end()) {
-		return false;
-	}
-	auto column_info = entry->second;
-	result = column_info;
-	return true;
-}
-
-column_t Binding::GetBindingIndex(const string &column_name) {
-	column_t result;
-	if (!TryGetBindingIndex(column_name, result)) {
-		throw InternalException("Binding index for column \"%s\" not found", column_name);
-	}
-	return result;
-}
-
-bool Binding::HasMatchingBinding(const string &column_name) {
-	column_t result;
-	return TryGetBindingIndex(column_name, result);
-}
-
-string Binding::ColumnNotFoundError(const string &column_name) const {
-	return StringUtil::Format("Values list \"%s\" does not have a column named \"%s\"", alias, column_name);
-}
-
-BindResult Binding::Bind(ColumnRefExpression &colref, idx_t depth) {
-	column_t column_index;
-	bool success = false;
-	success = TryGetBindingIndex(colref.GetColumnName(), column_index);
-	if (!success) {
-		return BindResult(ColumnNotFoundError(colref.GetColumnName()));
-	}
-	ColumnBinding binding;
-	binding.table_index = index;
-	binding.column_index = column_index;
-	LogicalType sql_type = types[column_index];
-	if (colref.alias.empty()) {
-		colref.alias = names[column_index];
-	}
-	return BindResult(make_unique<BoundColumnRefExpression>(colref.GetName(), sql_type, binding, depth));
-}
-
-StandardEntry *Binding::GetStandardEntry() {
-	return nullptr;
-}
-
-EntryBinding::EntryBinding(const string &alias, vector<LogicalType> types_p, vector<string> names_p, idx_t index,
-                           StandardEntry &entry)
-    : Binding(BindingType::CATALOG_ENTRY, alias, move(types_p), move(names_p), index), entry(entry) {
-}
-
-StandardEntry *EntryBinding::GetStandardEntry() {
-	return &this->entry;
-}
-
-TableBinding::TableBinding(const string &alias, vector<LogicalType> types_p, vector<string> names_p, LogicalGet &get,
-                           idx_t index, bool add_row_id)
-    : Binding(BindingType::TABLE, alias, move(types_p), move(names_p), index), get(get) {
-	if (add_row_id) {
-		if (name_map.find("rowid") == name_map.end()) {
-			name_map["rowid"] = COLUMN_IDENTIFIER_ROW_ID;
-		}
-	}
-}
-
-static void BakeTableName(ParsedExpression &expr, const string &table_name) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
-		D_ASSERT(!colref.IsQualified());
-		auto &col_names = colref.column_names;
-		col_names.insert(col_names.begin(), table_name);
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { BakeTableName((ParsedExpression &)child, table_name); });
-}
-
-unique_ptr<ParsedExpression> TableBinding::ExpandGeneratedColumn(const string &column_name) {
-	auto catalog_entry = GetStandardEntry();
-	D_ASSERT(catalog_entry); // Should only be called on a TableBinding
-
-	D_ASSERT(catalog_entry->type == CatalogType::TABLE_ENTRY);
-	auto table_entry = (TableCatalogEntry *)catalog_entry;
-
-	// Get the index of the generated column
-	auto column_index = GetBindingIndex(column_name);
-	D_ASSERT(table_entry->columns[column_index].Generated());
-	// Get a copy of the generated column
-	auto expression = table_entry->columns[column_index].GeneratedExpression().Copy();
-	BakeTableName(*expression, alias);
-	return (expression);
-}
-
-BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
-	auto &column_name = colref.GetColumnName();
-	column_t column_index;
-	bool success = false;
-	success = TryGetBindingIndex(column_name, column_index);
-	if (!success) {
-		return BindResult(ColumnNotFoundError(column_name));
-	}
-#ifdef DEBUG
-	auto entry = GetStandardEntry();
-	if (entry) {
-		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
-		auto table_entry = (TableCatalogEntry *)entry;
-		//! Either there is no table, or the columns category has to be standard
-		if (column_index != COLUMN_IDENTIFIER_ROW_ID) {
-			D_ASSERT(table_entry->columns[column_index].Category() == TableColumnType::STANDARD);
-		}
-	}
-#endif /* DEBUG */
-	// fetch the type of the column
-	LogicalType col_type;
-	if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-		// row id: BIGINT type
-		col_type = LogicalType::BIGINT;
-	} else {
-		// normal column: fetch type from base column
-		col_type = types[column_index];
-		if (colref.alias.empty()) {
-			colref.alias = names[column_index];
-		}
-	}
-
-	auto &column_ids = get.column_ids;
-	// check if the entry already exists in the column list for the table
-	ColumnBinding binding;
-
-	binding.column_index = column_ids.size();
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		if (column_ids[i] == column_index) {
-			binding.column_index = i;
-			break;
-		}
-	}
-	if (binding.column_index == column_ids.size()) {
-		// column binding not found: add it to the list of bindings
-		column_ids.push_back(column_index);
-	}
-	binding.table_index = index;
-	return BindResult(make_unique<BoundColumnRefExpression>(colref.GetName(), col_type, binding, depth));
-}
-
-StandardEntry *TableBinding::GetStandardEntry() {
-	return get.GetTable();
-}
-
-string TableBinding::ColumnNotFoundError(const string &column_name) const {
-	return StringUtil::Format("Table \"%s\" does not have a column named \"%s\"", alias, column_name);
-}
-
-MacroBinding::MacroBinding(vector<LogicalType> types_p, vector<string> names_p, string macro_name_p)
-    : Binding(BindingType::MACRO, MacroBinding::MACRO_NAME, move(types_p), move(names_p), -1),
-      macro_name(move(macro_name_p)) {
-}
-
-BindResult MacroBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
-	column_t column_index;
-	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
-		throw InternalException("Column %s not found in macro", colref.GetColumnName());
-	}
-	ColumnBinding binding;
-	binding.table_index = index;
-	binding.column_index = column_index;
-
-	// we are binding a parameter to create the macro, no arguments are supplied
-	return BindResult(make_unique<BoundColumnRefExpression>(colref.GetName(), types[column_index], binding, depth));
-}
-
-unique_ptr<ParsedExpression> MacroBinding::ParamToArg(ColumnRefExpression &colref) {
-	column_t column_index;
-	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
-		throw InternalException("Column %s not found in macro", colref.GetColumnName());
-	}
-	auto arg = arguments[column_index]->Copy();
-	arg->alias = colref.alias;
-	return arg;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-void TableFilterSet::PushFilter(idx_t column_index, unique_ptr<TableFilter> filter) {
-	auto entry = filters.find(column_index);
-	if (entry == filters.end()) {
-		// no filter yet: push the filter directly
-		filters[column_index] = move(filter);
-	} else {
-		// there is already a filter: AND it together
-		if (entry->second->filter_type == TableFilterType::CONJUNCTION_AND) {
-			auto &and_filter = (ConjunctionAndFilter &)*entry->second;
-			and_filter.child_filters.push_back(move(filter));
-		} else {
-			auto and_filter = make_unique<ConjunctionAndFilter>();
-			and_filter->child_filters.push_back(move(entry->second));
-			and_filter->child_filters.push_back(move(filter));
-			filters[column_index] = move(and_filter);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-ArenaChunk::ArenaChunk(Allocator &allocator, idx_t size) : current_position(0), maximum_size(size), prev(nullptr) {
-	D_ASSERT(size > 0);
-	data = allocator.Allocate(size);
-}
-ArenaChunk::~ArenaChunk() {
-	if (next) {
-		auto current_next = move(next);
-		while (current_next) {
-			current_next = move(current_next->next);
-		}
-	}
-}
-
-ArenaAllocator::ArenaAllocator(Allocator &allocator, idx_t initial_capacity) : allocator(allocator) {
-	head = nullptr;
-	tail = nullptr;
-	current_capacity = initial_capacity;
-}
-
-ArenaAllocator::~ArenaAllocator() {
-}
-
-data_ptr_t ArenaAllocator::Allocate(idx_t len) {
-	D_ASSERT(!head || head->current_position <= head->maximum_size);
-	if (!head || head->current_position + len > head->maximum_size) {
-		do {
-			current_capacity *= 2;
-		} while (current_capacity < len);
-		auto new_chunk = make_unique<ArenaChunk>(allocator, current_capacity);
-		if (head) {
-			head->prev = new_chunk.get();
-			new_chunk->next = move(head);
-		} else {
-			tail = new_chunk.get();
-		}
-		head = move(new_chunk);
-	}
-	D_ASSERT(head->current_position + len <= head->maximum_size);
-	auto result = head->data->get() + head->current_position;
-	head->current_position += len;
-	return result;
-}
-
-void ArenaAllocator::Destroy() {
-	head = nullptr;
-	tail = nullptr;
-	current_capacity = ARENA_ALLOCATOR_INITIAL_CAPACITY;
-}
-
-void ArenaAllocator::Move(ArenaAllocator &other) {
-	D_ASSERT(!other.head);
-	other.tail = tail;
-	other.head = move(head);
-	other.current_capacity = current_capacity;
-	Destroy();
-}
-
-ArenaChunk *ArenaAllocator::GetHead() {
-	return head.get();
-}
-
-ArenaChunk *ArenaAllocator::GetTail() {
-	return tail;
-}
-
-bool ArenaAllocator::IsEmpty() {
-	return head == nullptr;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-Block::Block(Allocator &allocator, block_id_t id)
-    : FileBuffer(allocator, FileBufferType::BLOCK, Storage::BLOCK_ALLOC_SIZE), id(id) {
-}
-
-Block::Block(FileBuffer &source, block_id_t id) : FileBuffer(source, FileBufferType::BLOCK), id(id) {
-	D_ASSERT(GetMallocedSize() == Storage::BLOCK_ALLOC_SIZE);
-	D_ASSERT(size == Storage::BLOCK_SIZE);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-BufferHandle::BufferHandle() : handle(nullptr), node(nullptr) {
-}
-
-BufferHandle::BufferHandle(shared_ptr<BlockHandle> handle, FileBuffer *node) : handle(move(handle)), node(node) {
-}
-
-BufferHandle::BufferHandle(BufferHandle &&other) noexcept {
-	std::swap(node, other.node);
-	std::swap(handle, other.handle);
-}
-
-BufferHandle &BufferHandle::operator=(BufferHandle &&other) noexcept {
-	std::swap(node, other.node);
-	std::swap(handle, other.handle);
-	return *this;
-}
-
-BufferHandle::~BufferHandle() {
-	Destroy();
-}
-
-bool BufferHandle::IsValid() const {
-	return node != nullptr;
-}
-
-data_ptr_t BufferHandle::Ptr() const {
-	D_ASSERT(IsValid());
-	return node->buffer;
-}
-
-data_ptr_t BufferHandle::Ptr() {
-	D_ASSERT(IsValid());
-	return node->buffer;
-}
-
-block_id_t BufferHandle::GetBlockId() const {
-	D_ASSERT(handle);
-	return handle->BlockId();
-}
-
-void BufferHandle::Destroy() {
-	if (!handle) {
-		return;
-	}
-	auto &buffer_manager = BufferManager::GetBufferManager(handle->db);
-	buffer_manager.Unpin(handle);
-	handle.reset();
-	node = nullptr;
-}
-
-FileBuffer &BufferHandle::GetFileBuffer() {
-	D_ASSERT(node);
-	return *node;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ManagedBuffer::ManagedBuffer(DatabaseInstance &db, idx_t size, bool can_destroy, block_id_t id)
-    : FileBuffer(Allocator::Get(db), FileBufferType::MANAGED_BUFFER, size), db(db), can_destroy(can_destroy), id(id) {
-	D_ASSERT(id >= MAXIMUM_BLOCK);
-	D_ASSERT(size >= Storage::BLOCK_SIZE);
-}
-
-ManagedBuffer::ManagedBuffer(DatabaseInstance &db, FileBuffer &source, bool can_destroy, block_id_t id)
-    : FileBuffer(source, FileBufferType::MANAGED_BUFFER), db(db), can_destroy(can_destroy), id(id) {
-	D_ASSERT(id >= MAXIMUM_BLOCK);
-	D_ASSERT(size >= Storage::BLOCK_SIZE);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct BufferAllocatorData : PrivateAllocatorData {
-	explicit BufferAllocatorData(BufferManager &manager) : manager(manager) {
-	}
-
-	BufferManager &manager;
-};
-
-BlockHandle::BlockHandle(DatabaseInstance &db, block_id_t block_id_p)
-    : db(db), readers(0), block_id(block_id_p), buffer(nullptr), eviction_timestamp(0), can_destroy(false) {
-	eviction_timestamp = 0;
-	state = BlockState::BLOCK_UNLOADED;
-	memory_usage = Storage::BLOCK_ALLOC_SIZE;
-}
-
-BlockHandle::BlockHandle(DatabaseInstance &db, block_id_t block_id_p, unique_ptr<FileBuffer> buffer_p,
-                         bool can_destroy_p, idx_t block_size)
-    : db(db), readers(0), block_id(block_id_p), eviction_timestamp(0), can_destroy(can_destroy_p) {
-	D_ASSERT(block_size >= Storage::BLOCK_SIZE);
-	buffer = move(buffer_p);
-	state = BlockState::BLOCK_LOADED;
-	memory_usage = block_size + Storage::BLOCK_HEADER_SIZE;
-}
-
-BlockHandle::~BlockHandle() {
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	// no references remain to this block: erase
-	if (state == BlockState::BLOCK_LOADED) {
-		// the block is still loaded in memory: erase it
-		buffer.reset();
-		buffer_manager.current_memory -= memory_usage;
-	}
-	buffer_manager.UnregisterBlock(block_id, can_destroy);
-}
-
-unique_ptr<Block> AllocateBlock(Allocator &allocator, unique_ptr<FileBuffer> reusable_buffer, block_id_t block_id) {
-	if (reusable_buffer) {
-		// re-usable buffer: re-use it
-		if (reusable_buffer->type == FileBufferType::BLOCK) {
-			// we can reuse the buffer entirely
-			auto &block = (Block &)*reusable_buffer;
-			block.id = block_id;
-			return unique_ptr_cast<FileBuffer, Block>(move(reusable_buffer));
-		}
-		auto block = make_unique<Block>(*reusable_buffer, block_id);
-		reusable_buffer.reset();
-		return block;
-	} else {
-		// no re-usable buffer: allocate a new block
-		return make_unique<Block>(allocator, block_id);
-	}
-}
-
-unique_ptr<ManagedBuffer> AllocateManagedBuffer(DatabaseInstance &db, unique_ptr<FileBuffer> reusable_buffer,
-                                                idx_t size, bool can_destroy, block_id_t id) {
-	if (reusable_buffer) {
-		// re-usable buffer: re-use it
-		if (reusable_buffer->type == FileBufferType::MANAGED_BUFFER) {
-			// we can reuse the buffer entirely
-			auto &managed = (ManagedBuffer &)*reusable_buffer;
-			managed.id = id;
-			managed.can_destroy = can_destroy;
-			return unique_ptr_cast<FileBuffer, ManagedBuffer>(move(reusable_buffer));
-		}
-		auto buffer = make_unique<ManagedBuffer>(db, *reusable_buffer, can_destroy, id);
-		reusable_buffer.reset();
-		return buffer;
-	} else {
-		// no re-usable buffer: allocate a new buffer
-		return make_unique<ManagedBuffer>(db, size, can_destroy, id);
-	}
-}
-
-BufferHandle BlockHandle::Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileBuffer> reusable_buffer) {
-	if (handle->state == BlockState::BLOCK_LOADED) {
-		// already loaded
-		D_ASSERT(handle->buffer);
-		return BufferHandle(handle, handle->buffer.get());
-	}
-
-	auto &buffer_manager = BufferManager::GetBufferManager(handle->db);
-	auto &block_manager = BlockManager::GetBlockManager(handle->db);
-	if (handle->block_id < MAXIMUM_BLOCK) {
-		auto block = AllocateBlock(Allocator::Get(handle->db), move(reusable_buffer), handle->block_id);
-		block_manager.Read(*block);
-		handle->buffer = move(block);
-	} else {
-		if (handle->can_destroy) {
-			return BufferHandle();
-		} else {
-			handle->buffer = buffer_manager.ReadTemporaryBuffer(handle->block_id, move(reusable_buffer));
-		}
-	}
-	handle->state = BlockState::BLOCK_LOADED;
-	return BufferHandle(handle, handle->buffer.get());
-}
-
-unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	if (state == BlockState::BLOCK_UNLOADED) {
-		// already unloaded: nothing to do
-		return nullptr;
-	}
-	D_ASSERT(CanUnload());
-	D_ASSERT(memory_usage >= Storage::BLOCK_ALLOC_SIZE);
-
-	if (block_id >= MAXIMUM_BLOCK && !can_destroy) {
-		// temporary block that cannot be destroyed: write to temporary file
-		buffer_manager.WriteTemporaryBuffer((ManagedBuffer &)*buffer);
-	}
-	buffer_manager.current_memory -= memory_usage;
-	state = BlockState::BLOCK_UNLOADED;
-	return move(buffer);
-}
-
-void BlockHandle::Unload() {
-	auto block = UnloadAndTakeBlock();
-	block.reset();
-}
-
-bool BlockHandle::CanUnload() {
-	if (state == BlockState::BLOCK_UNLOADED) {
-		// already unloaded
-		return false;
-	}
-	if (readers > 0) {
-		// there are active readers
-		return false;
-	}
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	if (block_id >= MAXIMUM_BLOCK && !can_destroy && buffer_manager.temp_directory.empty()) {
-		// in order to unload this block we need to write it to a temporary buffer
-		// however, no temporary directory is specified!
-		// hence we cannot unload the block
-		return false;
-	}
-	return true;
-}
-
-struct BufferEvictionNode {
-	BufferEvictionNode() {
-	}
-	BufferEvictionNode(weak_ptr<BlockHandle> handle_p, idx_t timestamp_p)
-	    : handle(move(handle_p)), timestamp(timestamp_p) {
-		D_ASSERT(!handle.expired());
-	}
-
-	weak_ptr<BlockHandle> handle;
-	idx_t timestamp;
-
-	bool CanUnload(BlockHandle &handle_p) {
-		if (timestamp != handle_p.eviction_timestamp) {
-			// handle was used in between
-			return false;
-		}
-		return handle_p.CanUnload();
-	}
-
-	shared_ptr<BlockHandle> TryGetBlockHandle() {
-		auto handle_p = handle.lock();
-		if (!handle_p) {
-			// BlockHandle has been destroyed
-			return nullptr;
-		}
-		if (!CanUnload(*handle_p)) {
-			// handle was used in between
-			return nullptr;
-		}
-		// this is the latest node in the queue with this handle
-		return handle_p;
-	}
-};
-
-typedef duckdb_moodycamel::ConcurrentQueue<BufferEvictionNode> eviction_queue_t;
-
-struct EvictionQueue {
-	eviction_queue_t q;
-};
-
-class TemporaryFileManager;
-
-class TemporaryDirectoryHandle {
-public:
-	TemporaryDirectoryHandle(DatabaseInstance &db, string path_p);
-	~TemporaryDirectoryHandle();
-
-	TemporaryFileManager &GetTempFile();
-
-private:
-	DatabaseInstance &db;
-	string temp_directory;
-	unique_ptr<TemporaryFileManager> temp_file;
-};
-
-void BufferManager::SetTemporaryDirectory(string new_dir) {
-	if (temp_directory_handle) {
-		throw NotImplementedException("Cannot switch temporary directory after the current one has been used");
-	}
-	this->temp_directory = move(new_dir);
-}
-
-BufferManager::BufferManager(DatabaseInstance &db, string tmp, idx_t maximum_memory)
-    : db(db), current_memory(0), maximum_memory(maximum_memory), temp_directory(move(tmp)),
-      queue(make_unique<EvictionQueue>()), temporary_id(MAXIMUM_BLOCK),
-      buffer_allocator(BufferAllocatorAllocate, BufferAllocatorFree, BufferAllocatorRealloc,
-                       make_unique<BufferAllocatorData>(*this)) {
-}
-
-BufferManager::~BufferManager() {
-}
-
-shared_ptr<BlockHandle> BufferManager::RegisterBlock(block_id_t block_id) {
-	lock_guard<mutex> lock(blocks_lock);
-	// check if the block already exists
-	auto entry = blocks.find(block_id);
-	if (entry != blocks.end()) {
-		// already exists: check if it hasn't expired yet
-		auto existing_ptr = entry->second.lock();
-		if (existing_ptr) {
-			//! it hasn't! return it
-			return existing_ptr;
-		}
-	}
-	// create a new block pointer for this block
-	auto result = make_shared<BlockHandle>(db, block_id);
-	// register the block pointer in the set of blocks as a weak pointer
-	blocks[block_id] = weak_ptr<BlockHandle>(result);
-	return result;
-}
-
-shared_ptr<BlockHandle> BufferManager::ConvertToPersistent(BlockManager &block_manager, block_id_t block_id,
-                                                           shared_ptr<BlockHandle> old_block) {
-
-	// pin the old block to ensure we have it loaded in memory
-	auto old_handle = Pin(old_block);
-	D_ASSERT(old_block->state == BlockState::BLOCK_LOADED);
-	D_ASSERT(old_block->buffer);
-
-	// register a block with the new block id
-	auto new_block = RegisterBlock(block_id);
-	D_ASSERT(new_block->state == BlockState::BLOCK_UNLOADED);
-	D_ASSERT(new_block->readers == 0);
-
-	// move the data from the old block into data for the new block
-	new_block->state = BlockState::BLOCK_LOADED;
-	new_block->buffer = make_unique<Block>(*old_block->buffer, block_id);
-
-	// clear the old buffer and unload it
-	old_block->buffer.reset();
-	old_block->state = BlockState::BLOCK_UNLOADED;
-	old_block->memory_usage = 0;
-	old_handle.Destroy();
-	old_block.reset();
-
-	// persist the new block to disk
-	block_manager.Write(*new_block->buffer, block_id);
-
-	AddToEvictionQueue(new_block);
-
-	return new_block;
-}
-
-shared_ptr<BlockHandle> BufferManager::RegisterMemory(idx_t block_size, bool can_destroy) {
-	auto alloc_size = block_size + Storage::BLOCK_HEADER_SIZE;
-	// first evict blocks until we have enough memory to store this buffer
-	unique_ptr<FileBuffer> reusable_buffer;
-	if (!EvictBlocks(alloc_size, maximum_memory, &reusable_buffer)) {
-		throw OutOfMemoryException("could not allocate block of %lld bytes%s", alloc_size, InMemoryWarning());
-	}
-
-	auto temp_id = ++temporary_id;
-	auto buffer = AllocateManagedBuffer(db, move(reusable_buffer), block_size, can_destroy, temp_id);
-
-	// create a new block pointer for this block
-	return make_shared<BlockHandle>(db, temp_id, move(buffer), can_destroy, block_size);
-}
-
-BufferHandle BufferManager::Allocate(idx_t block_size) {
-	auto block = RegisterMemory(block_size, true);
-	return Pin(block);
-}
-
-void BufferManager::ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) {
-	D_ASSERT(block_size >= Storage::BLOCK_SIZE);
-	lock_guard<mutex> lock(handle->lock);
-	D_ASSERT(handle->state == BlockState::BLOCK_LOADED);
-	auto alloc_size = block_size + Storage::BLOCK_HEADER_SIZE;
-	int64_t required_memory = alloc_size - handle->memory_usage;
-	if (required_memory == 0) {
-		return;
-	} else if (required_memory > 0) {
-		// evict blocks until we have space to resize this block
-		if (!EvictBlocks(required_memory, maximum_memory)) {
-			throw OutOfMemoryException("failed to resize block from %lld to %lld%s", handle->memory_usage, alloc_size,
-			                           InMemoryWarning());
-		}
-	} else {
-		// no need to evict blocks
-		current_memory -= idx_t(-required_memory);
-	}
-
-	// resize and adjust current memory
-	handle->buffer->Resize(block_size);
-	handle->memory_usage = alloc_size;
-}
-
-BufferHandle BufferManager::Pin(shared_ptr<BlockHandle> &handle) {
-	idx_t required_memory;
-	{
-		// lock the block
-		lock_guard<mutex> lock(handle->lock);
-		// check if the block is already loaded
-		if (handle->state == BlockState::BLOCK_LOADED) {
-			// the block is loaded, increment the reader count and return a pointer to the handle
-			handle->readers++;
-			return handle->Load(handle);
-		}
-		required_memory = handle->memory_usage;
-	}
-	// evict blocks until we have space for the current block
-	unique_ptr<FileBuffer> reusable_buffer;
-	if (!EvictBlocks(required_memory, maximum_memory, &reusable_buffer)) {
-		throw OutOfMemoryException("failed to pin block of size %lld%s", required_memory, InMemoryWarning());
-	}
-	// lock the handle again and repeat the check (in case anybody loaded in the mean time)
-	lock_guard<mutex> lock(handle->lock);
-	// check if the block is already loaded
-	if (handle->state == BlockState::BLOCK_LOADED) {
-		// the block is loaded, increment the reader count and return a pointer to the handle
-		handle->readers++;
-		current_memory -= required_memory;
-		return handle->Load(handle);
-	}
-	// now we can actually load the current block
-	D_ASSERT(handle->readers == 0);
-	handle->readers = 1;
-	return handle->Load(handle, move(reusable_buffer));
-}
-
-void BufferManager::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
-	D_ASSERT(handle->readers == 0);
-	handle->eviction_timestamp++;
-	PurgeQueue();
-	queue->q.enqueue(BufferEvictionNode(weak_ptr<BlockHandle>(handle), handle->eviction_timestamp));
-}
-
-void BufferManager::Unpin(shared_ptr<BlockHandle> &handle) {
-	lock_guard<mutex> lock(handle->lock);
-	D_ASSERT(handle->readers > 0);
-	handle->readers--;
-	if (handle->readers == 0) {
-		AddToEvictionQueue(handle);
-	}
-}
-
-bool BufferManager::EvictBlocks(idx_t extra_memory, idx_t memory_limit, unique_ptr<FileBuffer> *buffer) {
-	PurgeQueue();
-
-	BufferEvictionNode node;
-	current_memory += extra_memory;
-	while (current_memory > memory_limit) {
-		// get a block to unpin from the queue
-		if (!queue->q.try_dequeue(node)) {
-			current_memory -= extra_memory;
-			return false;
-		}
-		// get a reference to the underlying block pointer
-		auto handle = node.TryGetBlockHandle();
-		if (!handle) {
-			continue;
-		}
-		// we might be able to free this block: grab the mutex and check if we can free it
-		lock_guard<mutex> lock(handle->lock);
-		if (!node.CanUnload(*handle)) {
-			// something changed in the mean-time, bail out
-			continue;
-		}
-		// hooray, we can unload the block
-		if (buffer && handle->buffer->AllocSize() == extra_memory) {
-			// we can actually re-use the memory directly!
-			*buffer = handle->UnloadAndTakeBlock();
-			return true;
-		} else {
-			// release the memory and mark the block as unloaded
-			handle->Unload();
-		}
-	}
-	return true;
-}
-
-void BufferManager::PurgeQueue() {
-	BufferEvictionNode node;
-	while (true) {
-		if (!queue->q.try_dequeue(node)) {
-			break;
-		}
-		auto handle = node.TryGetBlockHandle();
-		if (!handle) {
-			continue;
-		} else {
-			queue->q.enqueue(move(node));
-			break;
-		}
-	}
-}
-
-void BufferManager::UnregisterBlock(block_id_t block_id, bool can_destroy) {
-	if (block_id >= MAXIMUM_BLOCK) {
-		// in-memory buffer: destroy the buffer
-		if (!can_destroy) {
-			// buffer could have been offloaded to disk: remove the file
-			DeleteTemporaryFile(block_id);
-		}
-	} else {
-		lock_guard<mutex> lock(blocks_lock);
-		// on-disk block: erase from list of blocks in manager
-		blocks.erase(block_id);
-	}
-}
-void BufferManager::SetLimit(idx_t limit) {
-	lock_guard<mutex> l_lock(limit_lock);
-	// try to evict until the limit is reached
-	if (!EvictBlocks(0, limit)) {
-		throw OutOfMemoryException(
-		    "Failed to change memory limit to %lld: could not free up enough memory for the new limit%s", limit,
-		    InMemoryWarning());
-	}
-	idx_t old_limit = maximum_memory;
-	// set the global maximum memory to the new limit if successful
-	maximum_memory = limit;
-	// evict again
-	if (!EvictBlocks(0, limit)) {
-		// failed: go back to old limit
-		maximum_memory = old_limit;
-		throw OutOfMemoryException(
-		    "Failed to change memory limit to %lld: could not free up enough memory for the new limit%s", limit,
-		    InMemoryWarning());
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Temporary File Management
-//===--------------------------------------------------------------------===//
-unique_ptr<ManagedBuffer> ReadTemporaryBufferInternal(DatabaseInstance &db, FileHandle &handle, idx_t position,
-                                                      idx_t size, block_id_t id,
-                                                      unique_ptr<FileBuffer> reusable_buffer) {
-	auto buffer = AllocateManagedBuffer(db, move(reusable_buffer), size, false, id);
-	buffer->Read(handle, position);
-	return buffer;
-}
-
-struct TemporaryFileIndex {
-	explicit TemporaryFileIndex(idx_t file_index = DConstants::INVALID_INDEX,
-	                            idx_t block_index = DConstants::INVALID_INDEX)
-	    : file_index(file_index), block_index(block_index) {
-	}
-
-	idx_t file_index;
-	idx_t block_index;
-
-public:
-	bool IsValid() {
-		return block_index != DConstants::INVALID_INDEX;
-	}
-};
-
-struct BlockIndexManager {
-	BlockIndexManager() : max_index(0) {
-	}
-
-public:
-	//! Obtains a new block index from the index manager
-	idx_t GetNewBlockIndex() {
-		auto index = GetNewBlockIndexInternal();
-		indexes_in_use.insert(index);
-		return index;
-	}
-
-	//! Removes an index from the block manager
-	//! Returns true if the max_index has been altered
-	bool RemoveIndex(idx_t index) {
-		// remove this block from the set of blocks
-		indexes_in_use.erase(index);
-		free_indexes.insert(index);
-		// check if we can truncate the file
-
-		// get the max_index in use right now
-		auto max_index_in_use = indexes_in_use.empty() ? 0 : *indexes_in_use.rbegin();
-		if (max_index_in_use < max_index) {
-			// max index in use is lower than the max_index
-			// reduce the max_index
-			max_index = max_index_in_use + 1;
-			// we can remove any free_indexes that are larger than the current max_index
-			while (!free_indexes.empty()) {
-				auto max_entry = *free_indexes.rbegin();
-				if (max_entry < max_index) {
-					break;
-				}
-				free_indexes.erase(max_entry);
-			}
-			return true;
-		}
-		return false;
-	}
-
-	idx_t GetMaxIndex() {
-		return max_index;
-	}
-
-	bool HasFreeBlocks() {
-		return !free_indexes.empty();
-	}
-
-private:
-	idx_t GetNewBlockIndexInternal() {
-		if (free_indexes.empty()) {
-			return max_index++;
-		}
-		auto entry = free_indexes.begin();
-		auto index = *entry;
-		free_indexes.erase(entry);
-		return index;
-	}
-
-	idx_t max_index;
-	set<idx_t> free_indexes;
-	set<idx_t> indexes_in_use;
-};
-
-class TemporaryFileHandle {
-	constexpr static idx_t MAX_ALLOWED_INDEX = 4000;
-
-public:
-	TemporaryFileHandle(DatabaseInstance &db, const string &temp_directory, idx_t index)
-	    : db(db), file_index(index), path(FileSystem::GetFileSystem(db).JoinPath(
-	                                     temp_directory, "duckdb_temp_storage-" + to_string(index) + ".tmp")) {
-	}
-
-public:
-	struct TemporaryFileLock {
-		explicit TemporaryFileLock(mutex &mutex) : lock(mutex) {
-		}
-
-		lock_guard<mutex> lock;
-	};
-
-public:
-	TemporaryFileIndex TryGetBlockIndex() {
-		TemporaryFileLock lock(file_lock);
-		if (index_manager.GetMaxIndex() >= MAX_ALLOWED_INDEX && index_manager.HasFreeBlocks()) {
-			// file is at capacity
-			return TemporaryFileIndex();
-		}
-		// open the file handle if it does not yet exist
-		CreateFileIfNotExists(lock);
-		// fetch a new block index to write to
-		auto block_index = index_manager.GetNewBlockIndex();
-		return TemporaryFileIndex(file_index, block_index);
-	}
-
-	void WriteTemporaryFile(ManagedBuffer &buffer, TemporaryFileIndex index) {
-		D_ASSERT(buffer.size == Storage::BLOCK_SIZE);
-		buffer.Write(*handle, GetPositionInFile(index.block_index));
-	}
-
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, idx_t block_index,
-	                                           unique_ptr<FileBuffer> reusable_buffer) {
-		auto buffer = ReadTemporaryBufferInternal(db, *handle, GetPositionInFile(block_index), Storage::BLOCK_SIZE, id,
-		                                          move(reusable_buffer));
-		{
-			// remove the block (and potentially truncate the temp file)
-			TemporaryFileLock lock(file_lock);
-			D_ASSERT(handle);
-			RemoveTempBlockIndex(lock, block_index);
-		}
-		return move(buffer);
-	}
-
-	bool DeleteIfEmpty() {
-		TemporaryFileLock lock(file_lock);
-		if (index_manager.GetMaxIndex() > 0) {
-			// there are still blocks in this file
-			return false;
-		}
-		// the file is empty: delete it
-		handle.reset();
-		auto &fs = FileSystem::GetFileSystem(db);
-		fs.RemoveFile(path);
-		return true;
-	}
-
-private:
-	void CreateFileIfNotExists(TemporaryFileLock &) {
-		if (handle) {
-			return;
-		}
-		auto &fs = FileSystem::GetFileSystem(db);
-		handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_WRITE |
-		                               FileFlags::FILE_FLAGS_FILE_CREATE);
-	}
-
-	void RemoveTempBlockIndex(TemporaryFileLock &, idx_t index) {
-		// remove the block index from the index manager
-		if (index_manager.RemoveIndex(index)) {
-			// the max_index that is currently in use has decreased
-			// as a result we can truncate the file
-			auto max_index = index_manager.GetMaxIndex();
-			auto &fs = FileSystem::GetFileSystem(db);
-			fs.Truncate(*handle, GetPositionInFile(max_index + 1));
-		}
-	}
-
-	idx_t GetPositionInFile(idx_t index) {
-		return index * Storage::BLOCK_ALLOC_SIZE;
-	}
-
-private:
-	DatabaseInstance &db;
-	unique_ptr<FileHandle> handle;
-	idx_t file_index;
-	string path;
-	mutex file_lock;
-	BlockIndexManager index_manager;
-};
-
-class TemporaryFileManager {
-public:
-	TemporaryFileManager(DatabaseInstance &db, const string &temp_directory_p)
-	    : db(db), temp_directory(temp_directory_p) {
-	}
-
-public:
-	struct TemporaryManagerLock {
-		explicit TemporaryManagerLock(mutex &mutex) : lock(mutex) {
-		}
-
-		lock_guard<mutex> lock;
-	};
-
-	void WriteTemporaryBuffer(ManagedBuffer &buffer) {
-		D_ASSERT(buffer.size == Storage::BLOCK_SIZE);
-		TemporaryFileIndex index;
-		TemporaryFileHandle *handle = nullptr;
-
-		{
-			TemporaryManagerLock lock(manager_lock);
-			// first check if we can write to an open existing file
-			for (auto &entry : files) {
-				auto &temp_file = entry.second;
-				index = temp_file->TryGetBlockIndex();
-				if (index.IsValid()) {
-					handle = entry.second.get();
-					break;
-				}
-			}
-			if (!handle) {
-				// no existing handle to write to; we need to create & open a new file
-				auto new_file_index = index_manager.GetNewBlockIndex();
-				auto new_file = make_unique<TemporaryFileHandle>(db, temp_directory, new_file_index);
-				handle = new_file.get();
-				files[new_file_index] = move(new_file);
-
-				index = handle->TryGetBlockIndex();
-			}
-			D_ASSERT(used_blocks.find(buffer.id) == used_blocks.end());
-			used_blocks[buffer.id] = index;
-		}
-		D_ASSERT(handle);
-		D_ASSERT(index.IsValid());
-		handle->WriteTemporaryFile(buffer, index);
-	}
-
-	bool HasTemporaryBuffer(block_id_t block_id) {
-		lock_guard<mutex> lock(manager_lock);
-		return used_blocks.find(block_id) != used_blocks.end();
-	}
-
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> reusable_buffer) {
-		TemporaryFileIndex index;
-		TemporaryFileHandle *handle;
-		{
-			TemporaryManagerLock lock(manager_lock);
-			index = GetTempBlockIndex(lock, id);
-			handle = GetFileHandle(lock, index.file_index);
-		}
-		auto buffer = handle->ReadTemporaryBuffer(id, index.block_index, move(reusable_buffer));
-		{
-			// remove the block (and potentially erase the temp file)
-			TemporaryManagerLock lock(manager_lock);
-			EraseUsedBlock(lock, id, handle, index.file_index);
-		}
-		return buffer;
-	}
-
-	void DeleteTemporaryBuffer(block_id_t id) {
-		TemporaryManagerLock lock(manager_lock);
-		auto index = GetTempBlockIndex(lock, id);
-		auto handle = GetFileHandle(lock, index.file_index);
-		EraseUsedBlock(lock, id, handle, index.file_index);
-	}
-
-private:
-	void EraseUsedBlock(TemporaryManagerLock &lock, block_id_t id, TemporaryFileHandle *handle, idx_t file_index) {
-		used_blocks.erase(id);
-		if (handle->DeleteIfEmpty()) {
-			EraseFileHandle(lock, file_index);
-		}
-	}
-
-	TemporaryFileHandle *GetFileHandle(TemporaryManagerLock &, idx_t index) {
-		return files[index].get();
-	}
-
-	TemporaryFileIndex GetTempBlockIndex(TemporaryManagerLock &, block_id_t id) {
-		D_ASSERT(used_blocks.find(id) != used_blocks.end());
-		return used_blocks[id];
-	}
-
-	void EraseFileHandle(TemporaryManagerLock &, idx_t file_index) {
-		files.erase(file_index);
-		index_manager.RemoveIndex(file_index);
-	}
-
-private:
-	DatabaseInstance &db;
-	mutex manager_lock;
-	//! The temporary directory
-	string temp_directory;
-	//! The set of active temporary file handles
-	unordered_map<idx_t, unique_ptr<TemporaryFileHandle>> files;
-	//! map of block_id -> temporary file position
-	unordered_map<block_id_t, TemporaryFileIndex> used_blocks;
-	//! Manager of in-use temporary file indexes
-	BlockIndexManager index_manager;
-};
-
-TemporaryDirectoryHandle::TemporaryDirectoryHandle(DatabaseInstance &db, string path_p)
-    : db(db), temp_directory(move(path_p)), temp_file(make_unique<TemporaryFileManager>(db, temp_directory)) {
-	auto &fs = FileSystem::GetFileSystem(db);
-	if (!temp_directory.empty()) {
-		fs.CreateDirectory(temp_directory);
-	}
-}
-TemporaryDirectoryHandle::~TemporaryDirectoryHandle() {
-	// first release any temporary files
-	temp_file.reset();
-	// then delete the temporary file directory
-	auto &fs = FileSystem::GetFileSystem(db);
-	if (!temp_directory.empty()) {
-		fs.RemoveDirectory(temp_directory);
-	}
-}
-
-TemporaryFileManager &TemporaryDirectoryHandle::GetTempFile() {
-	return *temp_file;
-}
-
-string BufferManager::GetTemporaryPath(block_id_t id) {
-	auto &fs = FileSystem::GetFileSystem(db);
-	return fs.JoinPath(temp_directory, to_string(id) + ".block");
-}
-
-void BufferManager::RequireTemporaryDirectory() {
-	if (temp_directory.empty()) {
-		throw Exception(
-		    "Out-of-memory: cannot write buffer because no temporary directory is specified!\nTo enable "
-		    "temporary buffer eviction set a temporary directory using PRAGMA temp_directory='/path/to/tmp.tmp'");
-	}
-	lock_guard<mutex> temp_handle_guard(temp_handle_lock);
-	if (!temp_directory_handle) {
-		// temp directory has not been created yet: initialize it
-		temp_directory_handle = make_unique<TemporaryDirectoryHandle>(db, temp_directory);
-	}
-}
-
-void BufferManager::WriteTemporaryBuffer(ManagedBuffer &buffer) {
-	RequireTemporaryDirectory();
-	if (buffer.size == Storage::BLOCK_SIZE) {
-		temp_directory_handle->GetTempFile().WriteTemporaryBuffer(buffer);
-		return;
-	}
-
-	D_ASSERT(buffer.size > Storage::BLOCK_SIZE);
-	// get the path to write to
-	auto path = GetTemporaryPath(buffer.id);
-	// create the file and write the size followed by the buffer contents
-	auto &fs = FileSystem::GetFileSystem(db);
-	auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE);
-	handle->Write(&buffer.size, sizeof(idx_t), 0);
-	buffer.Write(*handle, sizeof(idx_t));
-}
-
-unique_ptr<FileBuffer> BufferManager::ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> reusable_buffer) {
-	D_ASSERT(!temp_directory.empty());
-	D_ASSERT(temp_directory_handle.get());
-	if (temp_directory_handle->GetTempFile().HasTemporaryBuffer(id)) {
-		return temp_directory_handle->GetTempFile().ReadTemporaryBuffer(id, move(reusable_buffer));
-	}
-	idx_t block_size;
-	// open the temporary file and read the size
-	auto path = GetTemporaryPath(id);
-	auto &fs = FileSystem::GetFileSystem(db);
-	auto handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ);
-	handle->Read(&block_size, sizeof(idx_t), 0);
-
-	// now allocate a buffer of this size and read the data into that buffer
-	auto buffer = ReadTemporaryBufferInternal(db, *handle, sizeof(idx_t), block_size, id, move(reusable_buffer));
-
-	handle.reset();
-	DeleteTemporaryFile(id);
-	return move(buffer);
-}
-
-void BufferManager::DeleteTemporaryFile(block_id_t id) {
-	if (temp_directory.empty()) {
-		// no temporary directory specified: nothing to delete
-		return;
-	}
-	{
-		lock_guard<mutex> temp_handle_guard(temp_handle_lock);
-		if (!temp_directory_handle) {
-			// temporary directory was not initialized yet: nothing to delete
-			return;
-		}
-	}
-	// check if we should delete the file from the shared pool of files, or from the general file system
-	if (temp_directory_handle->GetTempFile().HasTemporaryBuffer(id)) {
-		temp_directory_handle->GetTempFile().DeleteTemporaryBuffer(id);
-		return;
-	}
-	auto &fs = FileSystem::GetFileSystem(db);
-	auto path = GetTemporaryPath(id);
-	if (fs.FileExists(path)) {
-		fs.RemoveFile(path);
-	}
-}
-
-string BufferManager::InMemoryWarning() {
-	if (!temp_directory.empty()) {
-		return "";
-	}
-	return "\nDatabase is launched in in-memory mode and no temporary directory is specified."
-	       "\nUnused blocks cannot be offloaded to disk."
-	       "\n\nLaunch the database with a persistent storage back-end"
-	       "\nOr set PRAGMA temp_directory='/path/to/tmp.tmp'";
-}
-
-//===--------------------------------------------------------------------===//
-// Buffer Allocator
-//===--------------------------------------------------------------------===//
-data_ptr_t BufferManager::BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size) {
-	auto &data = (BufferAllocatorData &)*private_data;
-	if (!data.manager.EvictBlocks(size, data.manager.maximum_memory)) {
-		throw OutOfMemoryException("failed to allocate data of size %lld%s", size, data.manager.InMemoryWarning());
-	}
-	return Allocator::Get(data.manager.db).AllocateData(size);
-}
-
-void BufferManager::BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
-	auto &data = (BufferAllocatorData &)*private_data;
-	data.manager.current_memory -= size;
-	return Allocator::Get(data.manager.db).FreeData(pointer, size);
-}
-
-data_ptr_t BufferManager::BufferAllocatorRealloc(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-                                                 idx_t size) {
-	auto &data = (BufferAllocatorData &)*private_data;
-	data.manager.current_memory -= old_size;
-	data.manager.current_memory += size;
-	return Allocator::Get(data.manager.db).ReallocateData(pointer, old_size, size);
-}
-
-Allocator &BufferAllocator::Get(ClientContext &context) {
-	auto &manager = BufferManager::GetBufferManager(context);
-	return manager.GetBufferAllocator();
-}
-
-Allocator &BufferManager::GetBufferAllocator() {
-	return buffer_allocator;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-TableDataReader::TableDataReader(MetaBlockReader &reader, BoundCreateTableInfo &info) : reader(reader), info(info) {
-	info.data = make_unique<PersistentTableData>(info.Base().columns.size());
-}
-
-void TableDataReader::ReadTableData() {
-	auto &columns = info.Base().columns;
-	D_ASSERT(columns.size() > 0);
-
-	// deserialize the total table statistics
-	info.data->column_stats.reserve(columns.size());
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto &col = columns[i];
-		// Have to use 'Generated()' here, storage_oid is uninitialized here
-		if (col.Generated()) {
-			continue;
-		}
-		info.data->column_stats.push_back(BaseStatistics::Deserialize(reader, columns[i].Type()));
-	}
-
-	// deserialize each of the individual row groups
-	auto row_group_count = reader.Read<uint64_t>();
-	info.data->row_groups.reserve(row_group_count);
-	for (idx_t i = 0; i < row_group_count; i++) {
-		auto row_group_pointer = RowGroup::Deserialize(reader, columns);
-		info.data->row_groups.push_back(move(row_group_pointer));
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-TableDataWriter::TableDataWriter(DatabaseInstance &, CheckpointManager &checkpoint_manager, TableCatalogEntry &table,
-                                 MetaBlockWriter &meta_writer)
-    : checkpoint_manager(checkpoint_manager), table(table), meta_writer(meta_writer) {
-}
-
-TableDataWriter::~TableDataWriter() {
-}
-
-BlockPointer TableDataWriter::WriteTableData() {
-	// start scanning the table and append the data to the uncompressed segments
-	return table.storage->Checkpoint(*this);
-}
-
-CompressionType TableDataWriter::GetColumnCompressionType(idx_t i) {
-	return table.columns[i].CompressionType();
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-WriteOverflowStringsToDisk::WriteOverflowStringsToDisk(DatabaseInstance &db)
-    : db(db), block_id(INVALID_BLOCK), offset(0) {
-}
-
-WriteOverflowStringsToDisk::~WriteOverflowStringsToDisk() {
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	if (offset > 0) {
-		block_manager.Write(handle.GetFileBuffer(), block_id);
-	}
-}
-
-void WriteOverflowStringsToDisk::WriteString(string_t string, block_id_t &result_block, int32_t &result_offset) {
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	if (!handle.IsValid()) {
-		handle = buffer_manager.Allocate(Storage::BLOCK_SIZE);
-	}
-	// first write the length of the string
-	if (block_id == INVALID_BLOCK || offset + 2 * sizeof(uint32_t) >= STRING_SPACE) {
-		AllocateNewBlock(block_manager.GetFreeBlockId());
-	}
-	result_block = block_id;
-	result_offset = offset;
-
-	// GZIP the string
-	auto uncompressed_size = string.GetSize();
-	MiniZStream s;
-	size_t compressed_size = 0;
-	compressed_size = s.MaxCompressedLength(uncompressed_size);
-	auto compressed_buf = unique_ptr<data_t[]>(new data_t[compressed_size]);
-	s.Compress((const char *)string.GetDataUnsafe(), uncompressed_size, (char *)compressed_buf.get(), &compressed_size);
-	string_t compressed_string((const char *)compressed_buf.get(), compressed_size);
-
-	// store sizes
-	auto data_ptr = handle.Ptr();
-	Store<uint32_t>(compressed_size, data_ptr + offset);
-	Store<uint32_t>(uncompressed_size, data_ptr + offset + sizeof(uint32_t));
-
-	// now write the remainder of the string
-	offset += 2 * sizeof(uint32_t);
-	auto strptr = compressed_string.GetDataUnsafe();
-	uint32_t remaining = compressed_size;
-	while (remaining > 0) {
-		uint32_t to_write = MinValue<uint32_t>(remaining, STRING_SPACE - offset);
-		if (to_write > 0) {
-			memcpy(data_ptr + offset, strptr, to_write);
-
-			remaining -= to_write;
-			offset += to_write;
-			strptr += to_write;
-		}
-		if (remaining > 0) {
-			// there is still remaining stuff to write
-			// first get the new block id and write it to the end of the previous block
-			auto new_block_id = block_manager.GetFreeBlockId();
-			Store<block_id_t>(new_block_id, data_ptr + offset);
-			// now write the current block to disk and allocate a new block
-			AllocateNewBlock(new_block_id);
-		}
-	}
-}
-
-void WriteOverflowStringsToDisk::AllocateNewBlock(block_id_t new_block_id) {
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	if (block_id != INVALID_BLOCK) {
-		// there is an old block, write it first
-		block_manager.Write(handle.GetFileBuffer(), block_id);
-	}
-	offset = 0;
-	block_id = new_block_id;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void ReorderTableEntries(vector<TableCatalogEntry *> &tables);
-
-CheckpointManager::CheckpointManager(DatabaseInstance &db) : db(db) {
-}
-
-void CheckpointManager::CreateCheckpoint() {
-	auto &config = DBConfig::GetConfig(db);
-	auto &storage_manager = StorageManager::GetStorageManager(db);
-	if (storage_manager.InMemory()) {
-		return;
-	}
-	// assert that the checkpoint manager hasn't been used before
-	D_ASSERT(!metadata_writer);
-
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	block_manager.StartCheckpoint();
-
-	//! Set up the writers for the checkpoints
-	metadata_writer = make_unique<MetaBlockWriter>(db);
-	tabledata_writer = make_unique<MetaBlockWriter>(db);
-
-	// get the id of the first meta block
-	block_id_t meta_block = metadata_writer->block->id;
-
-	vector<SchemaCatalogEntry *> schemas;
-	// we scan the set of committed schemas
-	auto &catalog = Catalog::GetCatalog(db);
-	catalog.schemas->Scan([&](CatalogEntry *entry) { schemas.push_back((SchemaCatalogEntry *)entry); });
-	// write the actual data into the database
-	// write the amount of schemas
-	metadata_writer->Write<uint32_t>(schemas.size());
-	for (auto &schema : schemas) {
-		WriteSchema(*schema);
-	}
-	FlushPartialSegments();
-	// flush the meta data to disk
-	metadata_writer->Flush();
-	tabledata_writer->Flush();
-
-	// write a checkpoint flag to the WAL
-	// this protects against the rare event that the database crashes AFTER writing the file, but BEFORE truncating the
-	// WAL we write an entry CHECKPOINT "meta_block_id" into the WAL upon loading, if we see there is an entry
-	// CHECKPOINT "meta_block_id", and the id MATCHES the head idin the file we know that the database was successfully
-	// checkpointed, so we know that we should avoid replaying the WAL to avoid duplicating data
-	auto wal = storage_manager.GetWriteAheadLog();
-	wal->WriteCheckpoint(meta_block);
-	wal->Flush();
-
-	if (config.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_BEFORE_HEADER) {
-		throw IOException("Checkpoint aborted before header write because of PRAGMA checkpoint_abort flag");
-	}
-
-	// finally write the updated header
-	DatabaseHeader header;
-	header.meta_block = meta_block;
-	block_manager.WriteHeader(header);
-
-	if (config.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_BEFORE_TRUNCATE) {
-		throw IOException("Checkpoint aborted before truncate because of PRAGMA checkpoint_abort flag");
-	}
-
-	// truncate the WAL
-	wal->Truncate(0);
-
-	// mark all blocks written as part of the metadata as modified
-	for (auto &block_id : metadata_writer->written_blocks) {
-		block_manager.MarkBlockAsModified(block_id);
-	}
-	for (auto &block_id : tabledata_writer->written_blocks) {
-		block_manager.MarkBlockAsModified(block_id);
-	}
-}
-
-void CheckpointManager::LoadFromStorage() {
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	block_id_t meta_block = block_manager.GetMetaBlock();
-	if (meta_block < 0) {
-		// storage is empty
-		return;
-	}
-
-	Connection con(db);
-	con.BeginTransaction();
-	// create the MetaBlockReader to read from the storage
-	MetaBlockReader reader(db, meta_block);
-	uint32_t schema_count = reader.Read<uint32_t>();
-	for (uint32_t i = 0; i < schema_count; i++) {
-		ReadSchema(*con.context, reader);
-	}
-	con.Commit();
-}
-
-//===--------------------------------------------------------------------===//
-// Schema
-//===--------------------------------------------------------------------===//
-void CheckpointManager::WriteSchema(SchemaCatalogEntry &schema) {
-	// write the schema data
-	schema.Serialize(*metadata_writer);
-	// then, we fetch the tables/views/sequences information
-	vector<TableCatalogEntry *> tables;
-	vector<ViewCatalogEntry *> views;
-	schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
-			return;
-		}
-		if (entry->type == CatalogType::TABLE_ENTRY) {
-			tables.push_back((TableCatalogEntry *)entry);
-		} else if (entry->type == CatalogType::VIEW_ENTRY) {
-			views.push_back((ViewCatalogEntry *)entry);
-		} else {
-			throw NotImplementedException("Catalog type for entries");
-		}
-	});
-	vector<SequenceCatalogEntry *> sequences;
-	schema.Scan(CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
-			return;
-		}
-		sequences.push_back((SequenceCatalogEntry *)entry);
-	});
-
-	vector<TypeCatalogEntry *> custom_types;
-	schema.Scan(CatalogType::TYPE_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
-			return;
-		}
-		custom_types.push_back((TypeCatalogEntry *)entry);
-	});
-
-	vector<ScalarMacroCatalogEntry *> macros;
-	schema.Scan(CatalogType::SCALAR_FUNCTION_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
-			return;
-		}
-		if (entry->type == CatalogType::MACRO_ENTRY) {
-			macros.push_back((ScalarMacroCatalogEntry *)entry);
-		}
-	});
-
-	vector<TableMacroCatalogEntry *> table_macros;
-	schema.Scan(CatalogType::TABLE_FUNCTION_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
-			return;
-		}
-		if (entry->type == CatalogType::TABLE_MACRO_ENTRY) {
-			table_macros.push_back((TableMacroCatalogEntry *)entry);
-		}
-	});
-
-	FieldWriter writer(*metadata_writer);
-	writer.WriteField<uint32_t>(custom_types.size());
-	writer.WriteField<uint32_t>(sequences.size());
-	writer.WriteField<uint32_t>(tables.size());
-	writer.WriteField<uint32_t>(views.size());
-	writer.WriteField<uint32_t>(macros.size());
-	writer.WriteField<uint32_t>(table_macros.size());
-	writer.Finalize();
-
-	// write the custom_types
-	for (auto &custom_type : custom_types) {
-		WriteType(*custom_type);
-	}
-
-	// write the sequences
-	for (auto &seq : sequences) {
-		WriteSequence(*seq);
-	}
-	// reorder tables because of foreign key constraint
-	ReorderTableEntries(tables);
-	// now write the tables
-	for (auto &table : tables) {
-		WriteTable(*table);
-	}
-	// now write the views
-	for (auto &view : views) {
-		WriteView(*view);
-	}
-
-	// finally write the macro's
-	for (auto &macro : macros) {
-		WriteMacro(*macro);
-	}
-
-	// finally write the macro's
-	for (auto &macro : table_macros) {
-		WriteTableMacro(*macro);
-	}
-}
-
-void CheckpointManager::ReadSchema(ClientContext &context, MetaBlockReader &reader) {
-	auto &catalog = Catalog::GetCatalog(db);
-
-	// read the schema and create it in the catalog
-	auto info = SchemaCatalogEntry::Deserialize(reader);
-	// we set create conflict to ignore to ignore the failure of recreating the main schema
-	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	catalog.CreateSchema(context, info.get());
-
-	// first read all the counts
-	FieldReader field_reader(reader);
-	uint32_t enum_count = field_reader.ReadRequired<uint32_t>();
-	uint32_t seq_count = field_reader.ReadRequired<uint32_t>();
-	uint32_t table_count = field_reader.ReadRequired<uint32_t>();
-	uint32_t view_count = field_reader.ReadRequired<uint32_t>();
-	uint32_t macro_count = field_reader.ReadRequired<uint32_t>();
-	uint32_t table_macro_count = field_reader.ReadRequired<uint32_t>();
-	field_reader.Finalize();
-
-	// now read the enums
-	for (uint32_t i = 0; i < enum_count; i++) {
-		ReadType(context, reader);
-	}
-
-	// read the sequences
-	for (uint32_t i = 0; i < seq_count; i++) {
-		ReadSequence(context, reader);
-	}
-	// read the table count and recreate the tables
-	for (uint32_t i = 0; i < table_count; i++) {
-		ReadTable(context, reader);
-	}
-	// now read the views
-	for (uint32_t i = 0; i < view_count; i++) {
-		ReadView(context, reader);
-	}
-
-	// finally read the macro's
-	for (uint32_t i = 0; i < macro_count; i++) {
-		ReadMacro(context, reader);
-	}
-
-	for (uint32_t i = 0; i < table_macro_count; i++) {
-		ReadTableMacro(context, reader);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Views
-//===--------------------------------------------------------------------===//
-void CheckpointManager::WriteView(ViewCatalogEntry &view) {
-	view.Serialize(*metadata_writer);
-}
-
-void CheckpointManager::ReadView(ClientContext &context, MetaBlockReader &reader) {
-	auto info = ViewCatalogEntry::Deserialize(reader);
-
-	auto &catalog = Catalog::GetCatalog(db);
-	catalog.CreateView(context, info.get());
-}
-
-//===--------------------------------------------------------------------===//
-// Sequences
-//===--------------------------------------------------------------------===//
-void CheckpointManager::WriteSequence(SequenceCatalogEntry &seq) {
-	seq.Serialize(*metadata_writer);
-}
-
-void CheckpointManager::ReadSequence(ClientContext &context, MetaBlockReader &reader) {
-	auto info = SequenceCatalogEntry::Deserialize(reader);
-
-	auto &catalog = Catalog::GetCatalog(db);
-	catalog.CreateSequence(context, info.get());
-}
-
-//===--------------------------------------------------------------------===//
-// Custom Types
-//===--------------------------------------------------------------------===//
-void CheckpointManager::WriteType(TypeCatalogEntry &table) {
-	table.Serialize(*metadata_writer);
-}
-
-void CheckpointManager::ReadType(ClientContext &context, MetaBlockReader &reader) {
-	auto info = TypeCatalogEntry::Deserialize(reader);
-
-	auto &catalog = Catalog::GetCatalog(db);
-	catalog.CreateType(context, info.get());
-}
-
-//===--------------------------------------------------------------------===//
-// Macro's
-//===--------------------------------------------------------------------===//
-void CheckpointManager::WriteMacro(ScalarMacroCatalogEntry &macro) {
-	macro.Serialize(*metadata_writer);
-}
-
-void CheckpointManager::ReadMacro(ClientContext &context, MetaBlockReader &reader) {
-	auto info = ScalarMacroCatalogEntry::Deserialize(reader);
-	auto &catalog = Catalog::GetCatalog(db);
-	catalog.CreateFunction(context, info.get());
-}
-
-void CheckpointManager::WriteTableMacro(TableMacroCatalogEntry &macro) {
-	macro.Serialize(*metadata_writer);
-}
-
-void CheckpointManager::ReadTableMacro(ClientContext &context, MetaBlockReader &reader) {
-	auto info = TableMacroCatalogEntry::Deserialize(reader);
-	auto &catalog = Catalog::GetCatalog(db);
-	catalog.CreateFunction(context, info.get());
-}
-
-//===--------------------------------------------------------------------===//
-// Table Metadata
-//===--------------------------------------------------------------------===//
-void CheckpointManager::WriteTable(TableCatalogEntry &table) {
-	// write the table meta data
-	table.Serialize(*metadata_writer);
-	// now we need to write the table data
-	TableDataWriter writer(db, *this, table, *tabledata_writer);
-	auto pointer = writer.WriteTableData();
-
-	//! write the block pointer for the table info
-	metadata_writer->Write<block_id_t>(pointer.block_id);
-	metadata_writer->Write<uint64_t>(pointer.offset);
-}
-
-void CheckpointManager::ReadTable(ClientContext &context, MetaBlockReader &reader) {
-	// deserialize the table meta data
-	auto info = TableCatalogEntry::Deserialize(reader);
-	// bind the info
-	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindCreateTableInfo(move(info));
-
-	// now read the actual table data and place it into the create table info
-	auto block_id = reader.Read<block_id_t>();
-	auto offset = reader.Read<uint64_t>();
-	MetaBlockReader table_data_reader(db, block_id);
-	table_data_reader.offset = offset;
-	TableDataReader data_reader(table_data_reader, *bound_info);
-	data_reader.ReadTableData();
-
-	// finally create the table in the catalog
-	auto &catalog = Catalog::GetCatalog(db);
-	catalog.CreateTable(context, bound_info.get());
-}
-
-//===--------------------------------------------------------------------===//
-// Partial Blocks
-//===--------------------------------------------------------------------===//
-bool CheckpointManager::GetPartialBlock(ColumnSegment *segment, idx_t segment_size, block_id_t &block_id,
-                                        uint32_t &offset_in_block, PartialBlock *&partial_block_ptr,
-                                        unique_ptr<PartialBlock> &owned_partial_block) {
-	auto entry = partially_filled_blocks.lower_bound(segment_size);
-	if (entry == partially_filled_blocks.end()) {
-		return false;
-	}
-	// found a partially filled block! fill in the info
-	auto partial_block = move(entry->second);
-	partial_block_ptr = partial_block.get();
-	block_id = partial_block->block_id;
-	offset_in_block = Storage::BLOCK_SIZE - entry->first;
-	partially_filled_blocks.erase(entry);
-	PartialColumnSegment partial_segment;
-	partial_segment.segment = segment;
-	partial_segment.offset_in_block = offset_in_block;
-	partial_block->segments.push_back(partial_segment);
-
-	D_ASSERT(offset_in_block > 0);
-	D_ASSERT(ValueIsAligned(offset_in_block));
-
-	// check if the block is STILL partially filled after adding the segment_size
-	auto new_size = AlignValue(offset_in_block + segment_size);
-	if (new_size <= CheckpointManager::PARTIAL_BLOCK_THRESHOLD) {
-		// the block is still partially filled: add it to the partially_filled_blocks list
-		auto new_space_left = Storage::BLOCK_SIZE - new_size;
-		partially_filled_blocks.insert(make_pair(new_space_left, move(partial_block)));
-		// should not write the block yet: perhaps more columns will be added
-	} else {
-		// we are done with this block after the current write: write it to disk
-		owned_partial_block = move(partial_block);
-	}
-	return true;
-}
-
-void CheckpointManager::RegisterPartialBlock(ColumnSegment *segment, idx_t segment_size, block_id_t block_id) {
-	D_ASSERT(segment_size <= CheckpointManager::PARTIAL_BLOCK_THRESHOLD);
-	auto partial_block = make_unique<PartialBlock>();
-	partial_block->block_id = block_id;
-	partial_block->block = segment->block;
-
-	PartialColumnSegment partial_segment;
-	partial_segment.segment = segment;
-	partial_segment.offset_in_block = 0;
-	partial_block->segments.push_back(partial_segment);
-	auto space_left = Storage::BLOCK_SIZE - AlignValue(segment_size);
-	partially_filled_blocks.insert(make_pair(space_left, move(partial_block)));
-}
-
-void CheckpointManager::FlushPartialSegments() {
-	for (auto &entry : partially_filled_blocks) {
-		entry.second->FlushToDisk(db);
-	}
-}
-
-void PartialBlock::FlushToDisk(DatabaseInstance &db) {
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	auto &block_manager = BlockManager::GetBlockManager(db);
-
-	// the data for the block might already exists in-memory of our block
-	// instead of copying the data we alter some metadata so the buffer points to an on-disk block
-	block = buffer_manager.ConvertToPersistent(block_manager, block_id, move(block));
-
-	// now set this block as the block for all segments
-	for (auto &seg : segments) {
-		seg.segment->ConvertToPersistent(block, block_id, seg.offset_in_block);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-// Note that optimizations in scanning only work if this value is equal to STANDARD_VECTOR_SIZE, however we keep them
-// separated to prevent the code from break on lower vector sizes
-static constexpr const idx_t BITPACKING_WIDTH_GROUP_SIZE = 1024;
-
-struct EmptyBitpackingWriter {
-	template <class T>
-	static void Operation(T *values, bool *validity, bitpacking_width_t width, idx_t count, void *data_ptr) {
-	}
-};
-
-template <class T>
-struct BitpackingState {
-public:
-	BitpackingState() : compression_buffer_idx(0), total_size(0), data_ptr(nullptr) {
-	}
-
-	T compression_buffer[BITPACKING_WIDTH_GROUP_SIZE];
-	bool compression_buffer_validity[BITPACKING_WIDTH_GROUP_SIZE];
-	idx_t compression_buffer_idx;
-	idx_t total_size;
-	void *data_ptr;
-
-public:
-	template <class OP>
-	void Flush() {
-		bitpacking_width_t width = BitpackingPrimitives::MinimumBitWidth<T>(compression_buffer, compression_buffer_idx);
-		OP::Operation(compression_buffer, compression_buffer_validity, width, compression_buffer_idx, data_ptr);
-		total_size += (BITPACKING_WIDTH_GROUP_SIZE * width) / 8 + sizeof(bitpacking_width_t);
-		compression_buffer_idx = 0;
-	}
-
-	template <class OP = EmptyBitpackingWriter>
-	void Update(T *data, ValidityMask &validity, idx_t idx) {
-
-		if (validity.RowIsValid(idx)) {
-			compression_buffer_validity[compression_buffer_idx] = true;
-			compression_buffer[compression_buffer_idx++] = data[idx];
-		} else {
-			// We write zero for easy bitwidth analysis of the compression buffer later
-			compression_buffer_validity[compression_buffer_idx] = false;
-			compression_buffer[compression_buffer_idx++] = 0;
-		}
-
-		if (compression_buffer_idx == BITPACKING_WIDTH_GROUP_SIZE) {
-			// Calculate bitpacking width;
-			Flush<OP>();
-		}
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-template <class T>
-struct BitpackingAnalyzeState : public AnalyzeState {
-	BitpackingState<T> state;
-};
-
-template <class T>
-unique_ptr<AnalyzeState> BitpackingInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	return make_unique<BitpackingAnalyzeState<T>>();
-}
-
-template <class T>
-bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &analyze_state = (BitpackingAnalyzeState<T> &)state;
-	VectorData vdata;
-	input.Orrify(count, vdata);
-
-	auto data = (T *)vdata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		analyze_state.state.template Update<EmptyBitpackingWriter>(data, vdata.validity, idx);
-	}
-
-	return true;
-}
-
-template <class T>
-idx_t BitpackingFinalAnalyze(AnalyzeState &state) {
-	auto &bitpacking_state = (BitpackingAnalyzeState<T> &)state;
-	bitpacking_state.state.template Flush<EmptyBitpackingWriter>();
-	return bitpacking_state.state.total_size;
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-template <class T>
-struct BitpackingCompressState : public CompressionState {
-public:
-	explicit BitpackingCompressState(ColumnDataCheckpointer &checkpointer) : checkpointer(checkpointer) {
-		auto &db = checkpointer.GetDatabase();
-		auto &type = checkpointer.GetType();
-		auto &config = DBConfig::GetConfig(db);
-		function = config.GetCompressionFunction(CompressionType::COMPRESSION_BITPACKING, type.InternalType());
-		CreateEmptySegment(checkpointer.GetRowGroup().start);
-
-		state.data_ptr = (void *)this;
-	}
-
-	ColumnDataCheckpointer &checkpointer;
-	CompressionFunction *function;
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle handle;
-
-	// Ptr to next free spot in segment;
-	data_ptr_t data_ptr;
-	// Ptr to next free spot for storing bitwidths (growing downwards).
-	data_ptr_t width_ptr;
-
-	BitpackingState<T> state;
-
-public:
-	struct BitpackingWriter {
-		template <class VALUE_TYPE>
-		static void Operation(VALUE_TYPE *values, bool *validity, bitpacking_width_t width, idx_t count,
-		                      void *data_ptr) {
-			auto state = (BitpackingCompressState<T> *)data_ptr;
-
-			if (state->RemainingSize() < (width * BITPACKING_WIDTH_GROUP_SIZE) / 8 + sizeof(bitpacking_width_t)) {
-				// Segment is full
-				auto row_start = state->current_segment->start + state->current_segment->count;
-				state->FlushSegment();
-				state->CreateEmptySegment(row_start);
-			}
-
-			for (idx_t i = 0; i < count; i++) {
-				if (validity[i]) {
-					NumericStatistics::Update<T>(state->current_segment->stats, values[i]);
-				}
-			}
-
-			state->WriteValues(values, width, count);
-		}
-	};
-
-	// Space remaining between the width_ptr growing down and data ptr growing up
-	idx_t RemainingSize() {
-		return width_ptr - data_ptr;
-	}
-
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpointer.GetDatabase();
-		auto &type = checkpointer.GetType();
-		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
-		compressed_segment->function = function;
-		current_segment = move(compressed_segment);
-		auto &buffer_manager = BufferManager::GetBufferManager(db);
-		handle = buffer_manager.Pin(current_segment->block);
-
-		data_ptr = handle.Ptr() + current_segment->GetBlockOffset() + BitpackingPrimitives::BITPACKING_HEADER_SIZE;
-		width_ptr = handle.Ptr() + current_segment->GetBlockOffset() + Storage::BLOCK_SIZE - sizeof(bitpacking_width_t);
-	}
-
-	void Append(VectorData &vdata, idx_t count) {
-		// TODO Optimization: avoid use of compression buffer if we can compress straight to result vector
-		auto data = (T *)vdata.data;
-
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = vdata.sel->get_index(i);
-			state.template Update<BitpackingCompressState<T>::BitpackingWriter>(data, vdata.validity, idx);
-		}
-	}
-
-	void WriteValues(T *values, bitpacking_width_t width, idx_t count) {
-		// TODO we can optimize this by stopping early if count < BITPACKING_WIDTH_GROUP_SIZE
-		BitpackingPrimitives::PackBuffer<T, false>(data_ptr, values, count, width);
-		data_ptr += (BITPACKING_WIDTH_GROUP_SIZE * width) / 8;
-
-		Store<bitpacking_width_t>(width, width_ptr);
-		width_ptr -= sizeof(bitpacking_width_t);
-
-		current_segment->count += count;
-	}
-
-	void FlushSegment() {
-		auto &state = checkpointer.GetCheckpointState();
-		auto dataptr = handle.Ptr();
-
-		// Compact the segment by moving the widths next to the data.
-		idx_t minimal_widths_offset = AlignValue(data_ptr - dataptr);
-		idx_t widths_size = dataptr + Storage::BLOCK_SIZE - width_ptr - 1;
-		idx_t total_segment_size = minimal_widths_offset + widths_size;
-		memmove(dataptr + minimal_widths_offset, width_ptr + 1, widths_size);
-
-		// Store the offset of the first width (which is at the highest address).
-		Store<idx_t>(minimal_widths_offset + widths_size - 1, dataptr);
-		handle.Destroy();
-
-		state.FlushSegment(move(current_segment), total_segment_size);
-	}
-
-	void Finalize() {
-		state.template Flush<BitpackingCompressState<T>::BitpackingWriter>();
-		FlushSegment();
-		current_segment.reset();
-	}
-};
-
-template <class T>
-unique_ptr<CompressionState> BitpackingInitCompression(ColumnDataCheckpointer &checkpointer,
-                                                       unique_ptr<AnalyzeState> state) {
-	return make_unique<BitpackingCompressState<T>>(checkpointer);
-}
-
-template <class T>
-void BitpackingCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = (BitpackingCompressState<T> &)state_p;
-	VectorData vdata;
-	scan_vector.Orrify(count, vdata);
-	state.Append(vdata, count);
-}
-
-template <class T>
-void BitpackingFinalizeCompress(CompressionState &state_p) {
-	auto &state = (BitpackingCompressState<T> &)state_p;
-	state.Finalize();
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-template <class T>
-struct BitpackingScanState : public SegmentScanState {
-public:
-	explicit BitpackingScanState(ColumnSegment &segment) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		handle = buffer_manager.Pin(segment.block);
-		auto dataptr = handle.Ptr();
-		current_width_group_ptr = dataptr + segment.GetBlockOffset() + BitpackingPrimitives::BITPACKING_HEADER_SIZE;
-
-		// load offset to bitpacking widths pointer
-		auto bitpacking_widths_offset = Load<idx_t>(dataptr + segment.GetBlockOffset());
-		bitpacking_width_ptr = dataptr + segment.GetBlockOffset() + bitpacking_widths_offset;
-
-		// load the bitwidth of the first vector
-		LoadCurrentBitWidth();
-	}
-
-	BufferHandle handle;
-
-	void (*decompress_function)(data_ptr_t, data_ptr_t, bitpacking_width_t, bool skip_sign_extension);
-	T decompression_buffer[BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE];
-
-	idx_t position_in_group = 0;
-	data_ptr_t current_width_group_ptr;
-	data_ptr_t bitpacking_width_ptr;
-	bitpacking_width_t current_width;
-
-public:
-	void LoadCurrentBitWidth() {
-		D_ASSERT(bitpacking_width_ptr > handle.Ptr() && bitpacking_width_ptr < handle.Ptr() + Storage::BLOCK_SIZE);
-		current_width = Load<bitpacking_width_t>(bitpacking_width_ptr);
-		LoadDecompressFunction();
-	}
-
-	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		while (skip_count > 0) {
-			if (position_in_group + skip_count < BITPACKING_WIDTH_GROUP_SIZE) {
-				// We're not leaving this bitpacking group, we can perform all skips.
-				position_in_group += skip_count;
-				break;
-			} else {
-				// The skip crosses the current bitpacking group, we skip the remainder of this group.
-				auto skipping = BITPACKING_WIDTH_GROUP_SIZE - position_in_group;
-				position_in_group = 0;
-				current_width_group_ptr += (current_width * BITPACKING_WIDTH_GROUP_SIZE) / 8;
-
-				// Update width pointer and load new width
-				bitpacking_width_ptr -= sizeof(bitpacking_width_t);
-				LoadCurrentBitWidth();
-
-				skip_count -= skipping;
-			}
-		}
-	}
-
-	void LoadDecompressFunction() {
-		decompress_function = &BitpackingPrimitives::UnPackBlock<T>;
-	}
-};
-
-template <class T>
-unique_ptr<SegmentScanState> BitpackingInitScan(ColumnSegment &segment) {
-	auto result = make_unique<BitpackingScanState<T>>(segment);
-	return move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                           idx_t result_offset) {
-	auto &scan_state = (BitpackingScanState<T> &)*state.scan_state;
-
-	T *result_data = FlatVector::GetData<T>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-
-	// Fast path for when no compression was used, we can do a single memcopy
-	if (STANDARD_VECTOR_SIZE == BITPACKING_WIDTH_GROUP_SIZE) {
-		if (scan_state.current_width == sizeof(T) * 8 && scan_count <= BITPACKING_WIDTH_GROUP_SIZE &&
-		    scan_state.position_in_group == 0) {
-
-			memcpy(result_data + result_offset, scan_state.current_width_group_ptr, scan_count * sizeof(T));
-			scan_state.current_width_group_ptr += scan_count * sizeof(T);
-			scan_state.bitpacking_width_ptr -= sizeof(bitpacking_width_t);
-			scan_state.LoadCurrentBitWidth();
-			return;
-		}
-	}
-
-	// Determine if we can skip sign extension during compression
-	auto &nstats = (NumericStatistics &)*segment.stats.statistics;
-	bool skip_sign_extend = std::is_signed<T>::value && nstats.min >= 0;
-
-	idx_t scanned = 0;
-
-	while (scanned < scan_count) {
-		// Exhausted this width group, move pointers to next group and load bitwidth for next group.
-		if (scan_state.position_in_group >= BITPACKING_WIDTH_GROUP_SIZE) {
-			scan_state.position_in_group = 0;
-			scan_state.bitpacking_width_ptr -= sizeof(bitpacking_width_t);
-			scan_state.current_width_group_ptr += (scan_state.current_width * BITPACKING_WIDTH_GROUP_SIZE) / 8;
-			scan_state.LoadCurrentBitWidth();
-		}
-
-		idx_t offset_in_compression_group =
-		    scan_state.position_in_group % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-		idx_t to_scan = MinValue<idx_t>(scan_count - scanned, BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE -
-		                                                          offset_in_compression_group);
-
-		// Calculate start of compression algorithm group
-		data_ptr_t current_position_ptr =
-		    scan_state.current_width_group_ptr + scan_state.position_in_group * scan_state.current_width / 8;
-		data_ptr_t decompression_group_start_pointer =
-		    current_position_ptr - offset_in_compression_group * scan_state.current_width / 8;
-
-		T *current_result_ptr = result_data + result_offset + scanned;
-
-		if (to_scan == BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE && offset_in_compression_group == 0) {
-			// Decompress directly into result vector
-			scan_state.decompress_function((data_ptr_t)current_result_ptr, decompression_group_start_pointer,
-			                               scan_state.current_width, skip_sign_extend);
-		} else {
-			// Decompress compression algorithm to buffer
-			scan_state.decompress_function((data_ptr_t)scan_state.decompression_buffer,
-			                               decompression_group_start_pointer, scan_state.current_width,
-			                               skip_sign_extend);
-
-			memcpy(current_result_ptr, scan_state.decompression_buffer + offset_in_compression_group,
-			       to_scan * sizeof(T));
-		}
-
-		scanned += to_scan;
-		scan_state.position_in_group += to_scan;
-	}
-}
-
-template <class T>
-void BitpackingScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	BitpackingScanPartial<T>(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-template <class T>
-void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                        idx_t result_idx) {
-	BitpackingScanState<T> scan_state(segment);
-	scan_state.Skip(segment, row_id);
-	auto result_data = FlatVector::GetData<T>(result);
-	T *current_result_ptr = result_data + result_idx;
-
-	// TODO clean up, is reused in partialscan
-	idx_t offset_in_compression_group =
-	    scan_state.position_in_group % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-	data_ptr_t decompression_group_start_pointer =
-	    scan_state.current_width_group_ptr +
-	    (scan_state.position_in_group - offset_in_compression_group) * scan_state.current_width / 8;
-
-	auto &nstats = (NumericStatistics &)*segment.stats.statistics;
-	bool skip_sign_extend = std::is_signed<T>::value && nstats.min >= 0;
-
-	scan_state.decompress_function((data_ptr_t)scan_state.decompression_buffer, decompression_group_start_pointer,
-	                               scan_state.current_width, skip_sign_extend);
-
-	*current_result_ptr = *(T *)(scan_state.decompression_buffer + offset_in_compression_group);
-}
-template <class T>
-void BitpackingSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = (BitpackingScanState<T> &)*state.scan_state;
-	scan_state.Skip(segment, skip_count);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-template <class T>
-CompressionFunction GetBitpackingFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_BITPACKING, data_type, BitpackingInitAnalyze<T>,
-	                           BitpackingAnalyze<T>, BitpackingFinalAnalyze<T>, BitpackingInitCompression<T>,
-	                           BitpackingCompress<T>, BitpackingFinalizeCompress<T>, BitpackingInitScan<T>,
-	                           BitpackingScan<T>, BitpackingScanPartial<T>, BitpackingFetchRow<T>, BitpackingSkip<T>);
-}
-
-CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return GetBitpackingFunction<int8_t>(type);
-	case PhysicalType::INT16:
-		return GetBitpackingFunction<int16_t>(type);
-	case PhysicalType::INT32:
-		return GetBitpackingFunction<int32_t>(type);
-	case PhysicalType::INT64:
-		return GetBitpackingFunction<int64_t>(type);
-	case PhysicalType::UINT8:
-		return GetBitpackingFunction<uint8_t>(type);
-	case PhysicalType::UINT16:
-		return GetBitpackingFunction<uint16_t>(type);
-	case PhysicalType::UINT32:
-		return GetBitpackingFunction<uint32_t>(type);
-	case PhysicalType::UINT64:
-		return GetBitpackingFunction<uint64_t>(type);
-	default:
-		throw InternalException("Unsupported type for Bitpacking");
-	}
-}
-
-bool BitpackingFun::TypeIsSupported(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct StringHash {
-	std::size_t operator()(const string_t &k) const {
-		return Hash(k);
-	}
-};
-
-struct StringEquality {
-	bool operator()(const string_t &a, const string_t &b) const {
-		return Equals::Operation(a, b);
-	}
-};
-
-template <typename T>
-using string_map_t = unordered_map<string_t, T, StringHash, StringEquality>;
-
-using string_set_t = unordered_set<string_t, StringHash, StringEquality>;
-
-// Abstract class for keeping compression state either for compression or size analysis
-class DictionaryCompressionState : public CompressionState {
-public:
-	bool UpdateState(Vector &scan_vector, idx_t count) {
-		VectorData vdata;
-		scan_vector.Orrify(count, vdata);
-		auto data = (string_t *)vdata.data;
-		Verify();
-
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = vdata.sel->get_index(i);
-			size_t string_size = 0;
-			bool new_string = false;
-			auto row_is_valid = vdata.validity.RowIsValid(idx);
-
-			if (row_is_valid) {
-				string_size = data[idx].GetSize();
-				if (string_size >= StringUncompressed::STRING_BLOCK_LIMIT) {
-					// Big strings not implemented for dictionary compression
-					return false;
-				}
-				new_string = !LookupString(data[idx]);
-			}
-
-			bool fits = HasEnoughSpace(new_string, string_size);
-			if (!fits) {
-				Flush();
-				new_string = true;
-				D_ASSERT(HasEnoughSpace(new_string, string_size));
-			}
-
-			if (!row_is_valid) {
-				AddNull();
-			} else if (new_string) {
-				AddNewString(data[idx]);
-			} else {
-				AddLastLookup();
-			}
-
-			Verify();
-		}
-
-		return true;
-	}
-
-protected:
-	// Should verify the State
-	virtual void Verify() = 0;
-	// Performs a lookup of str, storing the result internally
-	virtual bool LookupString(string_t str) = 0;
-	// Add the most recently looked up str to compression state
-	virtual void AddLastLookup() = 0;
-	// Add string to the state that is known to not be seen yet
-	virtual void AddNewString(string_t str) = 0;
-	// Add a null value to the compression state
-	virtual void AddNull() = 0;
-	// Check if we have enough space to add a string
-	virtual bool HasEnoughSpace(bool new_string, size_t string_size) = 0;
-	// Flush the segment to disk if compressing or reset the counters if analyzing
-	virtual void Flush(bool final = false) = 0;
-};
-
-typedef struct {
-	uint32_t dict_size;
-	uint32_t dict_end;
-	uint32_t index_buffer_offset;
-	uint32_t index_buffer_count;
-	uint32_t bitpacking_width;
-} dictionary_compression_header_t;
-
-struct DictionaryCompressionStorage {
-	static constexpr float MINIMUM_COMPRESSION_RATIO = 1.2;
-	static constexpr uint16_t DICTIONARY_HEADER_SIZE = sizeof(dictionary_compression_header_t);
-	static constexpr size_t COMPACTION_FLUSH_LIMIT = (size_t)Storage::BLOCK_SIZE / 5 * 4;
-
-	static unique_ptr<AnalyzeState> StringInitAnalyze(ColumnData &col_data, PhysicalType type);
-	static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count);
-	static idx_t StringFinalAnalyze(AnalyzeState &state_p);
-
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointer &checkpointer,
-	                                                    unique_ptr<AnalyzeState> state);
-	static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count);
-	static void FinalizeCompress(CompressionState &state_p);
-
-	static unique_ptr<SegmentScanState> StringInitScan(ColumnSegment &segment);
-	template <bool ALLOW_DICT_VECTORS>
-	static void StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-	                              idx_t result_offset);
-	static void StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result);
-	static void StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-	                           idx_t result_idx);
-
-	static bool HasEnoughSpace(idx_t current_count, idx_t index_count, idx_t dict_size,
-	                           bitpacking_width_t packing_width);
-	static idx_t RequiredSpace(idx_t current_count, idx_t index_count, idx_t dict_size,
-	                           bitpacking_width_t packing_width);
-
-	static StringDictionaryContainer GetDictionary(ColumnSegment &segment, BufferHandle &handle);
-	static void SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer container);
-	static string_t FetchStringFromDict(ColumnSegment &segment, StringDictionaryContainer dict, data_ptr_t baseptr,
-	                                    int32_t dict_offset, uint16_t string_len);
-	static uint16_t GetStringLength(uint32_t *index_buffer_ptr, sel_t index);
-};
-
-// Dictionary compression uses a combination of bitpacking and a dictionary to compress string segments. The data is
-// stored across three buffers: the index buffer, the selection buffer and the dictionary. Firstly the Index buffer
-// contains the offsets into the dictionary which are also used to determine the string lengths. Each value in the
-// dictionary gets a single unique index in the index buffer. Secondly, the selection buffer maps the tuples to an index
-// in the index buffer. The selection buffer is compressed with bitpacking. Finally, the dictionary contains simply all
-// the unique strings without lenghts or null termination as we can deduce the lengths from the index buffer. The
-// addition of the selection buffer is done for two reasons: firstly, to allow the scan to emit dictionary vectors by
-// scanning the whole dictionary at once and then scanning the selection buffer for each emitted vector. Secondly, it
-// allows for efficient bitpacking compression as the selection values should remain relatively small.
-struct DictionaryCompressionCompressState : public DictionaryCompressionState {
-	explicit DictionaryCompressionCompressState(ColumnDataCheckpointer &checkpointer) : checkpointer(checkpointer) {
-		auto &db = checkpointer.GetDatabase();
-		auto &config = DBConfig::GetConfig(db);
-		function = config.GetCompressionFunction(CompressionType::COMPRESSION_DICTIONARY, PhysicalType::VARCHAR);
-		CreateEmptySegment(checkpointer.GetRowGroup().start);
-	}
-
-	ColumnDataCheckpointer &checkpointer;
-	CompressionFunction *function;
-
-	// State regarding current segment
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle current_handle;
-	StringDictionaryContainer current_dictionary;
-	data_ptr_t current_end_ptr;
-
-	// Buffers and map for current segment
-	StringHeap heap;
-	string_map_t<uint32_t> current_string_map;
-	std::vector<uint32_t> index_buffer;
-	std::vector<uint32_t> selection_buffer;
-
-	bitpacking_width_t current_width = 0;
-	bitpacking_width_t next_width = 0;
-
-	// Result of latest LookupString call
-	uint32_t latest_lookup_result;
-
-public:
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpointer.GetDatabase();
-		auto &type = checkpointer.GetType();
-		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
-		current_segment = move(compressed_segment);
-
-		current_segment->function = function;
-
-		// Reset the buffers and string map
-		current_string_map.clear();
-		index_buffer.clear();
-		index_buffer.push_back(0); // Reserve index 0 for null strings
-		selection_buffer.clear();
-
-		current_width = 0;
-		next_width = 0;
-
-		// Reset the pointers into the current segment
-		auto &buffer_manager = BufferManager::GetBufferManager(current_segment->db);
-		current_handle = buffer_manager.Pin(current_segment->block);
-		current_dictionary = DictionaryCompressionStorage::GetDictionary(*current_segment, current_handle);
-		current_end_ptr = current_handle.Ptr() + current_dictionary.end;
-	}
-
-	void Verify() override {
-		current_dictionary.Verify();
-		D_ASSERT(current_segment->count == selection_buffer.size());
-		D_ASSERT(DictionaryCompressionStorage::HasEnoughSpace(current_segment->count.load(), index_buffer.size(),
-		                                                      current_dictionary.size, current_width));
-		D_ASSERT(current_dictionary.end == Storage::BLOCK_SIZE);
-		D_ASSERT(index_buffer.size() == current_string_map.size() + 1); // +1 is for null value
-	}
-
-	bool LookupString(string_t str) override {
-		auto search = current_string_map.find(str);
-		auto has_result = search != current_string_map.end();
-
-		if (has_result) {
-			latest_lookup_result = search->second;
-		}
-		return has_result;
-	}
-
-	void AddNewString(string_t str) override {
-		UncompressedStringStorage::UpdateStringStats(current_segment->stats, str);
-
-		// Copy string to dict
-		current_dictionary.size += str.GetSize();
-		auto dict_pos = current_end_ptr - current_dictionary.size;
-		memcpy(dict_pos, str.GetDataUnsafe(), str.GetSize());
-		current_dictionary.Verify();
-		D_ASSERT(current_dictionary.end == Storage::BLOCK_SIZE);
-
-		// Update buffers and map
-		index_buffer.push_back(current_dictionary.size);
-		selection_buffer.push_back(index_buffer.size() - 1);
-		if (str.IsInlined()) {
-			current_string_map.insert({str, index_buffer.size() - 1});
-		} else {
-			current_string_map.insert({heap.AddBlob(str), index_buffer.size() - 1});
-		}
-		DictionaryCompressionStorage::SetDictionary(*current_segment, current_handle, current_dictionary);
-
-		current_width = next_width;
-		current_segment->count++;
-	}
-
-	void AddNull() override {
-		selection_buffer.push_back(0);
-		current_segment->count++;
-	}
-
-	void AddLastLookup() override {
-		selection_buffer.push_back(latest_lookup_result);
-		current_segment->count++;
-	}
-
-	bool HasEnoughSpace(bool new_string, size_t string_size) override {
-		if (new_string) {
-			next_width = BitpackingPrimitives::MinimumBitWidth(index_buffer.size() - 1 + new_string);
-			return DictionaryCompressionStorage::HasEnoughSpace(current_segment->count.load() + 1,
-			                                                    index_buffer.size() + 1,
-			                                                    current_dictionary.size + string_size, next_width);
-		} else {
-			return DictionaryCompressionStorage::HasEnoughSpace(current_segment->count.load() + 1, index_buffer.size(),
-			                                                    current_dictionary.size, current_width);
-		}
-	}
-
-	void Flush(bool final = false) override {
-		auto next_start = current_segment->start + current_segment->count;
-
-		auto segment_size = Finalize();
-		auto &state = checkpointer.GetCheckpointState();
-		state.FlushSegment(move(current_segment), segment_size);
-
-		if (!final) {
-			CreateEmptySegment(next_start);
-		}
-	}
-
-	idx_t Finalize() {
-		auto &buffer_manager = BufferManager::GetBufferManager(current_segment->db);
-		auto handle = buffer_manager.Pin(current_segment->block);
-		D_ASSERT(current_dictionary.end == Storage::BLOCK_SIZE);
-
-		// calculate sizes
-		auto compressed_selection_buffer_size =
-		    BitpackingPrimitives::GetRequiredSize<sel_t>(current_segment->count, current_width);
-		auto index_buffer_size = index_buffer.size() * sizeof(uint32_t);
-		auto total_size = DictionaryCompressionStorage::DICTIONARY_HEADER_SIZE + compressed_selection_buffer_size +
-		                  index_buffer_size + current_dictionary.size;
-
-		// calculate ptr and offsets
-		auto base_ptr = handle.Ptr();
-		auto header_ptr = (dictionary_compression_header_t *)base_ptr;
-		auto compressed_selection_buffer_offset = DictionaryCompressionStorage::DICTIONARY_HEADER_SIZE;
-		auto index_buffer_offset = compressed_selection_buffer_offset + compressed_selection_buffer_size;
-
-		// Write compressed selection buffer
-		BitpackingPrimitives::PackBuffer<sel_t, false>(base_ptr + compressed_selection_buffer_offset,
-		                                               (sel_t *)(selection_buffer.data()), current_segment->count,
-		                                               current_width);
-
-		// Write the index buffer
-		memcpy(base_ptr + index_buffer_offset, index_buffer.data(), index_buffer_size);
-
-		// Store sizes and offsets in segment header
-		Store<uint32_t>(index_buffer_offset, (data_ptr_t)&header_ptr->index_buffer_offset);
-		Store<uint32_t>(index_buffer.size(), (data_ptr_t)&header_ptr->index_buffer_count);
-		Store<uint32_t>((uint32_t)current_width, (data_ptr_t)&header_ptr->bitpacking_width);
-
-		D_ASSERT(current_width == BitpackingPrimitives::MinimumBitWidth(index_buffer.size() - 1));
-		D_ASSERT(DictionaryCompressionStorage::HasEnoughSpace(current_segment->count, index_buffer.size(),
-		                                                      current_dictionary.size, current_width));
-		D_ASSERT((uint64_t)*max_element(std::begin(selection_buffer), std::end(selection_buffer)) ==
-		         index_buffer.size() - 1);
-
-		if (total_size >= DictionaryCompressionStorage::COMPACTION_FLUSH_LIMIT) {
-			// the block is full enough, don't bother moving around the dictionary
-			return Storage::BLOCK_SIZE;
-		}
-		// the block has space left: figure out how much space we can save
-		auto move_amount = Storage::BLOCK_SIZE - total_size;
-		// move the dictionary so it lines up exactly with the offsets
-		auto new_dictionary_offset = index_buffer_offset + index_buffer_size;
-		memmove(base_ptr + new_dictionary_offset, base_ptr + current_dictionary.end - current_dictionary.size,
-		        current_dictionary.size);
-		current_dictionary.end -= move_amount;
-		D_ASSERT(current_dictionary.end == total_size);
-		// write the new dictionary (with the updated "end")
-		DictionaryCompressionStorage::SetDictionary(*current_segment, handle, current_dictionary);
-		return total_size;
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct DictionaryAnalyzeState : public DictionaryCompressionState {
-	DictionaryAnalyzeState()
-	    : segment_count(0), current_tuple_count(0), current_unique_count(0), current_dict_size(0), current_width(0),
-	      next_width(0) {
-	}
-
-	size_t segment_count;
-	idx_t current_tuple_count;
-	idx_t current_unique_count;
-	size_t current_dict_size;
-	StringHeap heap;
-	string_set_t current_set;
-	bitpacking_width_t current_width;
-	bitpacking_width_t next_width;
-
-	bool LookupString(string_t str) override {
-		return current_set.count(str);
-	}
-
-	void AddNewString(string_t str) override {
-		current_tuple_count++;
-		current_unique_count++;
-		current_dict_size += str.GetSize();
-		if (str.IsInlined()) {
-			current_set.insert(str);
-		} else {
-			current_set.insert(heap.AddBlob(str));
-		}
-		current_width = next_width;
-	}
-
-	void AddLastLookup() override {
-		current_tuple_count++;
-	}
-
-	void AddNull() override {
-		current_tuple_count++;
-	}
-
-	bool HasEnoughSpace(bool new_string, size_t string_size) override {
-		if (new_string) {
-			next_width =
-			    BitpackingPrimitives::MinimumBitWidth(current_unique_count + 2); // 1 for null, one for new string
-			return DictionaryCompressionStorage::HasEnoughSpace(current_tuple_count + 1, current_unique_count + 1,
-			                                                    current_dict_size + string_size, next_width);
-		} else {
-			return DictionaryCompressionStorage::HasEnoughSpace(current_tuple_count + 1, current_unique_count,
-			                                                    current_dict_size, current_width);
-		}
-	}
-
-	void Flush(bool final = false) override {
-		segment_count++;
-		current_tuple_count = 0;
-		current_unique_count = 0;
-		current_dict_size = 0;
-		current_set.clear();
-	}
-	void Verify() override {};
-};
-
-struct DictionaryCompressionAnalyzeState : public AnalyzeState {
-	DictionaryCompressionAnalyzeState() : analyze_state(make_unique<DictionaryAnalyzeState>()) {
-	}
-
-	unique_ptr<DictionaryAnalyzeState> analyze_state;
-};
-
-unique_ptr<AnalyzeState> DictionaryCompressionStorage::StringInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	return make_unique<DictionaryCompressionAnalyzeState>();
-}
-
-bool DictionaryCompressionStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = (DictionaryCompressionAnalyzeState &)state_p;
-	return state.analyze_state->UpdateState(input, count);
-}
-
-idx_t DictionaryCompressionStorage::StringFinalAnalyze(AnalyzeState &state_p) {
-	auto &analyze_state = (DictionaryCompressionAnalyzeState &)state_p;
-	auto &state = *analyze_state.analyze_state;
-
-	auto width = BitpackingPrimitives::MinimumBitWidth(state.current_unique_count + 1);
-	auto req_space =
-	    RequiredSpace(state.current_tuple_count, state.current_unique_count, state.current_dict_size, width);
-
-	return MINIMUM_COMPRESSION_RATIO * (state.segment_count * Storage::BLOCK_SIZE + req_space);
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-unique_ptr<CompressionState> DictionaryCompressionStorage::InitCompression(ColumnDataCheckpointer &checkpointer,
-                                                                           unique_ptr<AnalyzeState> state) {
-	return make_unique<DictionaryCompressionCompressState>(checkpointer);
-}
-
-void DictionaryCompressionStorage::Compress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = (DictionaryCompressionCompressState &)state_p;
-	state.UpdateState(scan_vector, count);
-}
-
-void DictionaryCompressionStorage::FinalizeCompress(CompressionState &state_p) {
-	auto &state = (DictionaryCompressionCompressState &)state_p;
-	state.Flush(true);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-struct CompressedStringScanState : public StringScanState {
-	BufferHandle handle;
-	buffer_ptr<Vector> dictionary;
-	bitpacking_width_t current_width;
-	buffer_ptr<SelectionVector> sel_vec;
-	idx_t sel_vec_size = 0;
-};
-
-unique_ptr<SegmentScanState> DictionaryCompressionStorage::StringInitScan(ColumnSegment &segment) {
-	auto state = make_unique<CompressedStringScanState>();
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	state->handle = buffer_manager.Pin(segment.block);
-
-	auto baseptr = state->handle.Ptr() + segment.GetBlockOffset();
-
-	// Load header values
-	auto dict = DictionaryCompressionStorage::GetDictionary(segment, state->handle);
-	auto header_ptr = (dictionary_compression_header_t *)baseptr;
-	auto index_buffer_offset = Load<uint32_t>((data_ptr_t)&header_ptr->index_buffer_offset);
-	auto index_buffer_count = Load<uint32_t>((data_ptr_t)&header_ptr->index_buffer_count);
-	state->current_width = (bitpacking_width_t)(Load<uint32_t>((data_ptr_t)&header_ptr->bitpacking_width));
-
-	auto index_buffer_ptr = (uint32_t *)(baseptr + index_buffer_offset);
-
-	state->dictionary = make_buffer<Vector>(segment.type, index_buffer_count);
-	auto dict_child_data = FlatVector::GetData<string_t>(*(state->dictionary));
-
-	for (uint32_t i = 0; i < index_buffer_count; i++) {
-		// NOTE: the passing of dict_child_vector, will not be used, its for big strings
-		uint16_t str_len = GetStringLength(index_buffer_ptr, i);
-		dict_child_data[i] = FetchStringFromDict(segment, dict, baseptr, index_buffer_ptr[i], str_len);
-	}
-
-	return move(state);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <bool ALLOW_DICT_VECTORS>
-void DictionaryCompressionStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                                     Vector &result, idx_t result_offset) {
-	// clear any previously locked buffers and get the primary buffer handle
-	auto &scan_state = (CompressedStringScanState &)*state.scan_state;
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto baseptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto dict = DictionaryCompressionStorage::GetDictionary(segment, scan_state.handle);
-
-	auto header_ptr = (dictionary_compression_header_t *)baseptr;
-	auto index_buffer_offset = Load<uint32_t>((data_ptr_t)&header_ptr->index_buffer_offset);
-	auto index_buffer_ptr = (uint32_t *)(baseptr + index_buffer_offset);
-
-	auto base_data = (data_ptr_t)(baseptr + DICTIONARY_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<string_t>(result);
-
-	if (!ALLOW_DICT_VECTORS || scan_count != STANDARD_VECTOR_SIZE ||
-	    start % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE != 0) {
-		// Emit regular vector
-
-		// Handling non-bitpacking-group-aligned start values;
-		idx_t start_offset = start % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-		// We will scan in blocks of BITPACKING_ALGORITHM_GROUP_SIZE, so we may scan some extra values.
-		idx_t decompress_count = BitpackingPrimitives::RoundUpToAlgorithmGroupSize(scan_count + start_offset);
-
-		// Create a decompression buffer of sufficient size if we don't already have one.
-		if (!scan_state.sel_vec || scan_state.sel_vec_size < decompress_count) {
-			scan_state.sel_vec_size = decompress_count;
-			scan_state.sel_vec = make_buffer<SelectionVector>(decompress_count);
-		}
-
-		data_ptr_t src = &base_data[((start - start_offset) * scan_state.current_width) / 8];
-		sel_t *sel_vec_ptr = scan_state.sel_vec->data();
-
-		BitpackingPrimitives::UnPackBuffer<sel_t>((data_ptr_t)sel_vec_ptr, src, decompress_count,
-		                                          scan_state.current_width);
-
-		for (idx_t i = 0; i < scan_count; i++) {
-			// Lookup dict offset in index buffer
-			auto string_number = scan_state.sel_vec->get_index(i + start_offset);
-			auto dict_offset = index_buffer_ptr[string_number];
-			uint16_t str_len = GetStringLength(index_buffer_ptr, string_number);
-			result_data[result_offset + i] = FetchStringFromDict(segment, dict, baseptr, dict_offset, str_len);
-		}
-
-	} else {
-		D_ASSERT(start % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE == 0);
-		D_ASSERT(scan_count == STANDARD_VECTOR_SIZE);
-		D_ASSERT(result_offset == 0);
-
-		idx_t decompress_count = BitpackingPrimitives::RoundUpToAlgorithmGroupSize(scan_count);
-
-		// Create a selection vector of sufficient size if we don't already have one.
-		if (!scan_state.sel_vec || scan_state.sel_vec_size < decompress_count) {
-			scan_state.sel_vec_size = decompress_count;
-			scan_state.sel_vec = make_buffer<SelectionVector>(decompress_count);
-		}
-
-		// Scanning 1024 values, emitting a dict vector
-		data_ptr_t dst = (data_ptr_t)(scan_state.sel_vec->data());
-		data_ptr_t src = (data_ptr_t)&base_data[(start * scan_state.current_width) / 8];
-
-		BitpackingPrimitives::UnPackBuffer<sel_t>(dst, src, scan_count, scan_state.current_width);
-
-		result.Slice(*(scan_state.dictionary), *scan_state.sel_vec, scan_count);
-	}
-}
-
-void DictionaryCompressionStorage::StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                              Vector &result) {
-	StringScanPartial<true>(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void DictionaryCompressionStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id,
-                                                  Vector &result, idx_t result_idx) {
-	// fetch a single row from the string segment
-	// first pin the main buffer if it is not already pinned
-	auto &handle = state.GetOrInsertHandle(segment);
-
-	auto baseptr = handle.Ptr() + segment.GetBlockOffset();
-	auto header_ptr = (dictionary_compression_header_t *)baseptr;
-	auto dict = DictionaryCompressionStorage::GetDictionary(segment, handle);
-	auto index_buffer_offset = Load<uint32_t>((data_ptr_t)&header_ptr->index_buffer_offset);
-	auto width = (bitpacking_width_t)(Load<uint32_t>((data_ptr_t)&header_ptr->bitpacking_width));
-	auto index_buffer_ptr = (uint32_t *)(baseptr + index_buffer_offset);
-	auto base_data = (data_ptr_t)(baseptr + DICTIONARY_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<string_t>(result);
-
-	// Handling non-bitpacking-group-aligned start values;
-	idx_t start_offset = row_id % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-	// Decompress part of selection buffer we need for this value.
-	sel_t decompression_buffer[BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE];
-	data_ptr_t src = (data_ptr_t)&base_data[((row_id - start_offset) * width) / 8];
-	BitpackingPrimitives::UnPackBuffer<sel_t>((data_ptr_t)decompression_buffer, src,
-	                                          BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE, width);
-
-	auto selection_value = decompression_buffer[start_offset];
-	auto dict_offset = index_buffer_ptr[selection_value];
-	uint16_t str_len = GetStringLength(index_buffer_ptr, selection_value);
-
-	result_data[result_idx] = FetchStringFromDict(segment, dict, baseptr, dict_offset, str_len);
-}
-
-//===--------------------------------------------------------------------===//
-// Helper Functions
-//===--------------------------------------------------------------------===//
-bool DictionaryCompressionStorage::HasEnoughSpace(idx_t current_count, idx_t index_count, idx_t dict_size,
-                                                  bitpacking_width_t packing_width) {
-	return RequiredSpace(current_count, index_count, dict_size, packing_width) <= Storage::BLOCK_SIZE;
-}
-
-idx_t DictionaryCompressionStorage::RequiredSpace(idx_t current_count, idx_t index_count, idx_t dict_size,
-                                                  bitpacking_width_t packing_width) {
-	idx_t base_space = DICTIONARY_HEADER_SIZE + dict_size;
-	idx_t string_number_space = BitpackingPrimitives::GetRequiredSize<sel_t>(current_count, packing_width);
-	idx_t index_space = index_count * sizeof(uint32_t);
-
-	idx_t used_space = base_space + index_space + string_number_space;
-
-	return used_space;
-}
-
-StringDictionaryContainer DictionaryCompressionStorage::GetDictionary(ColumnSegment &segment, BufferHandle &handle) {
-	auto header_ptr = (dictionary_compression_header_t *)(handle.Ptr() + segment.GetBlockOffset());
-	StringDictionaryContainer container;
-	container.size = Load<uint32_t>((data_ptr_t)&header_ptr->dict_size);
-	container.end = Load<uint32_t>((data_ptr_t)&header_ptr->dict_end);
-	return container;
-}
-
-void DictionaryCompressionStorage::SetDictionary(ColumnSegment &segment, BufferHandle &handle,
-                                                 StringDictionaryContainer container) {
-	auto header_ptr = (dictionary_compression_header_t *)(handle.Ptr() + segment.GetBlockOffset());
-	Store<uint32_t>(container.size, (data_ptr_t)&header_ptr->dict_size);
-	Store<uint32_t>(container.end, (data_ptr_t)&header_ptr->dict_end);
-}
-
-string_t DictionaryCompressionStorage::FetchStringFromDict(ColumnSegment &segment, StringDictionaryContainer dict,
-                                                           data_ptr_t baseptr, int32_t dict_offset,
-                                                           uint16_t string_len) {
-	D_ASSERT(dict_offset >= 0 && dict_offset <= Storage::BLOCK_SIZE);
-
-	if (dict_offset == 0) {
-		return string_t(nullptr, 0);
-	}
-	// normal string: read string from this block
-	auto dict_end = baseptr + dict.end;
-	auto dict_pos = dict_end - dict_offset;
-
-	auto str_ptr = (char *)(dict_pos);
-	return string_t(str_ptr, string_len);
-}
-
-uint16_t DictionaryCompressionStorage::GetStringLength(uint32_t *index_buffer_ptr, sel_t index) {
-	if (index == 0) {
-		return 0;
-	} else {
-		return index_buffer_ptr[index] - index_buffer_ptr[index - 1];
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction DictionaryCompressionFun::GetFunction(PhysicalType data_type) {
-	return CompressionFunction(
-	    CompressionType::COMPRESSION_DICTIONARY, data_type, DictionaryCompressionStorage ::StringInitAnalyze,
-	    DictionaryCompressionStorage::StringAnalyze, DictionaryCompressionStorage::StringFinalAnalyze,
-	    DictionaryCompressionStorage::InitCompression, DictionaryCompressionStorage::Compress,
-	    DictionaryCompressionStorage::FinalizeCompress, DictionaryCompressionStorage::StringInitScan,
-	    DictionaryCompressionStorage::StringScan, DictionaryCompressionStorage::StringScanPartial<false>,
-	    DictionaryCompressionStorage::StringFetchRow, UncompressedFunctions::EmptySkip);
-}
-
-bool DictionaryCompressionFun::TypeIsSupported(PhysicalType type) {
-	return type == PhysicalType::VARCHAR;
-}
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct FixedSizeAnalyzeState : public AnalyzeState {
-	FixedSizeAnalyzeState() : count(0) {
-	}
-
-	idx_t count;
-};
-
-unique_ptr<AnalyzeState> FixedSizeInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	return make_unique<FixedSizeAnalyzeState>();
-}
-
-bool FixedSizeAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = (FixedSizeAnalyzeState &)state_p;
-	state.count += count;
-	return true;
-}
-
-template <class T>
-idx_t FixedSizeFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = (FixedSizeAnalyzeState &)state_p;
-	return sizeof(T) * state.count;
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-UncompressedCompressState::UncompressedCompressState(ColumnDataCheckpointer &checkpointer)
-    : checkpointer(checkpointer) {
-	CreateEmptySegment(checkpointer.GetRowGroup().start);
-}
-
-void UncompressedCompressState::CreateEmptySegment(idx_t row_start) {
-	auto &db = checkpointer.GetDatabase();
-	auto &type = checkpointer.GetType();
-	auto compressed_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
-	if (type.InternalType() == PhysicalType::VARCHAR) {
-		auto &state = (UncompressedStringSegmentState &)*compressed_segment->GetSegmentState();
-		state.overflow_writer = make_unique<WriteOverflowStringsToDisk>(db);
-	}
-	current_segment = move(compressed_segment);
-}
-
-void UncompressedCompressState::FlushSegment(idx_t segment_size) {
-	auto &state = checkpointer.GetCheckpointState();
-	state.FlushSegment(move(current_segment), segment_size);
-}
-
-void UncompressedCompressState::Finalize(idx_t segment_size) {
-	FlushSegment(segment_size);
-	current_segment.reset();
-}
-
-unique_ptr<CompressionState> UncompressedFunctions::InitCompression(ColumnDataCheckpointer &checkpointer,
-                                                                    unique_ptr<AnalyzeState> state) {
-	return make_unique<UncompressedCompressState>(checkpointer);
-}
-
-void UncompressedFunctions::Compress(CompressionState &state_p, Vector &data, idx_t count) {
-	auto &state = (UncompressedCompressState &)state_p;
-	VectorData vdata;
-	data.Orrify(count, vdata);
-
-	ColumnAppendState append_state;
-	idx_t offset = 0;
-	while (count > 0) {
-		idx_t appended = state.current_segment->Append(append_state, vdata, offset, count);
-		if (appended == count) {
-			// appended everything: finished
-			return;
-		}
-		auto next_start = state.current_segment->start + state.current_segment->count;
-		// the segment is full: flush it to disk
-		state.FlushSegment(state.current_segment->FinalizeAppend());
-
-		// now create a new segment and continue appending
-		state.CreateEmptySegment(next_start);
-		offset += appended;
-		count -= appended;
-	}
-}
-
-void UncompressedFunctions::FinalizeCompress(CompressionState &state_p) {
-	auto &state = (UncompressedCompressState &)state_p;
-	state.Finalize(state.current_segment->FinalizeAppend());
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-struct FixedSizeScanState : public SegmentScanState {
-	BufferHandle handle;
-};
-
-unique_ptr<SegmentScanState> FixedSizeInitScan(ColumnSegment &segment) {
-	auto result = make_unique<FixedSizeScanState>();
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	result->handle = buffer_manager.Pin(segment.block);
-	return move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void FixedSizeScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                          idx_t result_offset) {
-	auto &scan_state = (FixedSizeScanState &)*state.scan_state;
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto source_data = data + start * sizeof(T);
-
-	// copy the data from the base table
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	memcpy(FlatVector::GetData(result) + result_offset * sizeof(T), source_data, scan_count * sizeof(T));
-}
-
-template <class T>
-void FixedSizeScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	auto &scan_state = (FixedSizeScanState &)*state.scan_state;
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto source_data = data + start * sizeof(T);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	if (std::is_same<T, list_entry_t>()) {
-		// list columns are modified in-place during the scans to correct the offsets
-		// so we can't do a zero-copy there
-		memcpy(FlatVector::GetData(result), source_data, scan_count * sizeof(T));
-	} else {
-		FlatVector::SetData(result, source_data);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-template <class T>
-void FixedSizeFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                       idx_t result_idx) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-
-	// first fetch the data from the base table
-	auto data_ptr = handle.Ptr() + segment.GetBlockOffset() + row_id * sizeof(T);
-
-	memcpy(FlatVector::GetData(result) + result_idx * sizeof(T), data_ptr, sizeof(T));
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-template <class T>
-static void AppendLoop(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, VectorData &adata,
-                       idx_t offset, idx_t count) {
-	auto sdata = (T *)adata.data;
-	auto tdata = (T *)target;
-	if (!adata.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = adata.sel->get_index(offset + i);
-			auto target_idx = target_offset + i;
-			bool is_null = !adata.validity.RowIsValid(source_idx);
-			if (!is_null) {
-				NumericStatistics::Update<T>(stats, sdata[source_idx]);
-				tdata[target_idx] = sdata[source_idx];
-			} else {
-				// we insert a NullValue<T> in the null gap for debuggability
-				// this value should never be used or read anywhere
-				tdata[target_idx] = NullValue<T>();
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = adata.sel->get_index(offset + i);
-			auto target_idx = target_offset + i;
-			NumericStatistics::Update<T>(stats, sdata[source_idx]);
-			tdata[target_idx] = sdata[source_idx];
-		}
-	}
-}
-
-template <>
-void AppendLoop<list_entry_t>(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, VectorData &adata,
-                              idx_t offset, idx_t count) {
-	auto sdata = (list_entry_t *)adata.data;
-	auto tdata = (list_entry_t *)target;
-	for (idx_t i = 0; i < count; i++) {
-		auto source_idx = adata.sel->get_index(offset + i);
-		auto target_idx = target_offset + i;
-		tdata[target_idx] = sdata[source_idx];
-	}
-}
-
-template <class T>
-idx_t FixedSizeAppend(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset, idx_t count) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	D_ASSERT(segment.GetBlockOffset() == 0);
-
-	auto target_ptr = handle.Ptr();
-	idx_t max_tuple_count = Storage::BLOCK_SIZE / sizeof(T);
-	idx_t copy_count = MinValue<idx_t>(count, max_tuple_count - segment.count);
-
-	AppendLoop<T>(stats, target_ptr, segment.count, data, offset, copy_count);
-	segment.count += copy_count;
-	return copy_count;
-}
-
-template <class T>
-idx_t FixedSizeFinalizeAppend(ColumnSegment &segment, SegmentStatistics &stats) {
-	return segment.count * sizeof(T);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-template <class T>
-CompressionFunction FixedSizeGetFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED, data_type, FixedSizeInitAnalyze,
-	                           FixedSizeAnalyze, FixedSizeFinalAnalyze<T>, UncompressedFunctions::InitCompression,
-	                           UncompressedFunctions::Compress, UncompressedFunctions::FinalizeCompress,
-	                           FixedSizeInitScan, FixedSizeScan<T>, FixedSizeScanPartial<T>, FixedSizeFetchRow<T>,
-	                           UncompressedFunctions::EmptySkip, nullptr, FixedSizeAppend<T>,
-	                           FixedSizeFinalizeAppend<T>, nullptr);
-}
-
-CompressionFunction FixedSizeUncompressed::GetFunction(PhysicalType data_type) {
-	switch (data_type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return FixedSizeGetFunction<int8_t>(data_type);
-	case PhysicalType::INT16:
-		return FixedSizeGetFunction<int16_t>(data_type);
-	case PhysicalType::INT32:
-		return FixedSizeGetFunction<int32_t>(data_type);
-	case PhysicalType::INT64:
-		return FixedSizeGetFunction<int64_t>(data_type);
-	case PhysicalType::UINT8:
-		return FixedSizeGetFunction<uint8_t>(data_type);
-	case PhysicalType::UINT16:
-		return FixedSizeGetFunction<uint16_t>(data_type);
-	case PhysicalType::UINT32:
-		return FixedSizeGetFunction<uint32_t>(data_type);
-	case PhysicalType::UINT64:
-		return FixedSizeGetFunction<uint64_t>(data_type);
-	case PhysicalType::INT128:
-		return FixedSizeGetFunction<hugeint_t>(data_type);
-	case PhysicalType::FLOAT:
-		return FixedSizeGetFunction<float>(data_type);
-	case PhysicalType::DOUBLE:
-		return FixedSizeGetFunction<double>(data_type);
-	case PhysicalType::INTERVAL:
-		return FixedSizeGetFunction<interval_t>(data_type);
-	case PhysicalType::LIST:
-		return FixedSizeGetFunction<list_entry_t>(data_type);
-	default:
-		throw InternalException("Unsupported type for FixedSizeUncompressed::GetFunction");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-unique_ptr<SegmentScanState> ConstantInitScan(ColumnSegment &segment) {
-	return nullptr;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-void ConstantScanFunctionValidity(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	auto &validity = (ValidityStatistics &)*segment.stats.statistics;
-	if (validity.has_null) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ConstantVector::SetNull(result, true);
-	}
-}
-
-template <class T>
-void ConstantScanFunction(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	auto &nstats = (NumericStatistics &)*segment.stats.statistics;
-
-	auto data = FlatVector::GetData<T>(result);
-	data[0] = nstats.min.GetValueUnsafe<T>();
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan Partial
-//===--------------------------------------------------------------------===//
-void ConstantFillFunctionValidity(ColumnSegment &segment, Vector &result, idx_t start_idx, idx_t count) {
-	auto &validity = (ValidityStatistics &)*segment.stats.statistics;
-	if (validity.has_null) {
-		auto &mask = FlatVector::Validity(result);
-		for (idx_t i = 0; i < count; i++) {
-			mask.SetInvalid(start_idx + i);
-		}
-	}
-}
-
-template <class T>
-void ConstantFillFunction(ColumnSegment &segment, Vector &result, idx_t start_idx, idx_t count) {
-	auto &nstats = (NumericStatistics &)*segment.stats.statistics;
-
-	auto data = FlatVector::GetData<T>(result);
-	auto constant_value = nstats.min.GetValueUnsafe<T>();
-	for (idx_t i = 0; i < count; i++) {
-		data[start_idx + i] = constant_value;
-	}
-}
-
-void ConstantScanPartialValidity(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                                 idx_t result_offset) {
-	ConstantFillFunctionValidity(segment, result, result_offset, scan_count);
-}
-
-template <class T>
-void ConstantScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                         idx_t result_offset) {
-	ConstantFillFunction<T>(segment, result, result_offset, scan_count);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void ConstantFetchRowValidity(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                              idx_t result_idx) {
-	ConstantFillFunctionValidity(segment, result, result_idx, 1);
-}
-
-template <class T>
-void ConstantFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	ConstantFillFunction<T>(segment, result, result_idx, 1);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction ConstantGetFunctionValidity(PhysicalType data_type) {
-	D_ASSERT(data_type == PhysicalType::BIT);
-	return CompressionFunction(CompressionType::COMPRESSION_CONSTANT, data_type, nullptr, nullptr, nullptr, nullptr,
-	                           nullptr, nullptr, ConstantInitScan, ConstantScanFunctionValidity,
-	                           ConstantScanPartialValidity, ConstantFetchRowValidity, UncompressedFunctions::EmptySkip);
-}
-
-template <class T>
-CompressionFunction ConstantGetFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_CONSTANT, data_type, nullptr, nullptr, nullptr, nullptr,
-	                           nullptr, nullptr, ConstantInitScan, ConstantScanFunction<T>, ConstantScanPartial<T>,
-	                           ConstantFetchRow<T>, UncompressedFunctions::EmptySkip);
-}
-
-CompressionFunction ConstantFun::GetFunction(PhysicalType data_type) {
-	switch (data_type) {
-	case PhysicalType::BIT:
-		return ConstantGetFunctionValidity(data_type);
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return ConstantGetFunction<int8_t>(data_type);
-	case PhysicalType::INT16:
-		return ConstantGetFunction<int16_t>(data_type);
-	case PhysicalType::INT32:
-		return ConstantGetFunction<int32_t>(data_type);
-	case PhysicalType::INT64:
-		return ConstantGetFunction<int64_t>(data_type);
-	case PhysicalType::UINT8:
-		return ConstantGetFunction<uint8_t>(data_type);
-	case PhysicalType::UINT16:
-		return ConstantGetFunction<uint16_t>(data_type);
-	case PhysicalType::UINT32:
-		return ConstantGetFunction<uint32_t>(data_type);
-	case PhysicalType::UINT64:
-		return ConstantGetFunction<uint64_t>(data_type);
-	case PhysicalType::INT128:
-		return ConstantGetFunction<hugeint_t>(data_type);
-	case PhysicalType::FLOAT:
-		return ConstantGetFunction<float>(data_type);
-	case PhysicalType::DOUBLE:
-		return ConstantGetFunction<double>(data_type);
-	default:
-		throw InternalException("Unsupported type for ConstantUncompressed::GetFunction");
-	}
-}
-
-bool ConstantFun::TypeIsSupported(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return true;
-	default:
-		throw InternalException("Unsupported type for constant function");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-using rle_count_t = uint16_t;
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct EmptyRLEWriter {
-	template <class VALUE_TYPE>
-	static void Operation(VALUE_TYPE value, rle_count_t count, void *dataptr, bool is_null) {
-	}
-};
-
-template <class T>
-struct RLEState {
-	RLEState() : seen_count(0), last_value(NullValue<T>()), last_seen_count(0), dataptr(nullptr) {
-	}
-
-	idx_t seen_count;
-	T last_value;
-	rle_count_t last_seen_count;
-	void *dataptr;
-	bool all_null = true;
-
-public:
-	template <class OP>
-	void Flush() {
-		OP::template Operation<T>(last_value, last_seen_count, dataptr, all_null);
-	}
-
-	template <class OP = EmptyRLEWriter>
-	void Update(T *data, ValidityMask &validity, idx_t idx) {
-		if (validity.RowIsValid(idx)) {
-			all_null = false;
-			if (seen_count == 0) {
-				// no value seen yet
-				// assign the current value, and set the seen_count to 1
-				// note that we increment last_seen_count rather than setting it to 1
-				// this is intentional: this is the first VALID value we see
-				// but it might not be the first value in case of nulls!
-				last_value = data[idx];
-				seen_count = 1;
-				last_seen_count++;
-			} else if (last_value == data[idx]) {
-				// the last value is identical to this value: increment the last_seen_count
-				last_seen_count++;
-			} else {
-				// the values are different
-				// issue the callback on the last value
-				Flush<OP>();
-
-				// increment the seen_count and put the new value into the RLE slot
-				last_value = data[idx];
-				seen_count++;
-				last_seen_count = 1;
-			}
-		} else {
-			// NULL value: we merely increment the last_seen_count
-			last_seen_count++;
-		}
-		if (last_seen_count == NumericLimits<rle_count_t>::Maximum()) {
-			// we have seen the same value so many times in a row we are at the limit of what fits in our count
-			// write away the value and move to the next value
-			Flush<OP>();
-			last_seen_count = 0;
-			seen_count++;
-		}
-	}
-};
-
-template <class T>
-struct RLEAnalyzeState : public AnalyzeState {
-	RLEAnalyzeState() {
-	}
-
-	RLEState<T> state;
-};
-
-template <class T>
-unique_ptr<AnalyzeState> RLEInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	return make_unique<RLEAnalyzeState<T>>();
-}
-
-template <class T>
-bool RLEAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &rle_state = (RLEAnalyzeState<T> &)state;
-	VectorData vdata;
-	input.Orrify(count, vdata);
-
-	auto data = (T *)vdata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		rle_state.state.Update(data, vdata.validity, idx);
-	}
-	return true;
-}
-
-template <class T>
-idx_t RLEFinalAnalyze(AnalyzeState &state) {
-	auto &rle_state = (RLEAnalyzeState<T> &)state;
-	return (sizeof(rle_count_t) + sizeof(T)) * rle_state.state.seen_count;
-}
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-struct RLEConstants {
-	static constexpr const idx_t RLE_HEADER_SIZE = sizeof(uint64_t);
-};
-
-template <class T>
-struct RLECompressState : public CompressionState {
-	struct RLEWriter {
-		template <class VALUE_TYPE>
-		static void Operation(VALUE_TYPE value, rle_count_t count, void *dataptr, bool is_null) {
-			auto state = (RLECompressState<T> *)dataptr;
-			state->WriteValue(value, count, is_null);
-		}
-	};
-
-	static idx_t MaxRLECount() {
-		auto entry_size = sizeof(T) + sizeof(rle_count_t);
-		auto entry_count = (Storage::BLOCK_SIZE - RLEConstants::RLE_HEADER_SIZE) / entry_size;
-		auto max_vector_count = entry_count / STANDARD_VECTOR_SIZE;
-		return max_vector_count * STANDARD_VECTOR_SIZE;
-	}
-
-	explicit RLECompressState(ColumnDataCheckpointer &checkpointer_p) : checkpointer(checkpointer_p) {
-		auto &db = checkpointer.GetDatabase();
-		auto &type = checkpointer.GetType();
-		auto &config = DBConfig::GetConfig(db);
-		function = config.GetCompressionFunction(CompressionType::COMPRESSION_RLE, type.InternalType());
-		CreateEmptySegment(checkpointer.GetRowGroup().start);
-
-		state.dataptr = (void *)this;
-		max_rle_count = MaxRLECount();
-	}
-
-	void CreateEmptySegment(idx_t row_start) {
-		auto &db = checkpointer.GetDatabase();
-		auto &type = checkpointer.GetType();
-		auto column_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
-		column_segment->function = function;
-		current_segment = move(column_segment);
-		auto &buffer_manager = BufferManager::GetBufferManager(db);
-		handle = buffer_manager.Pin(current_segment->block);
-	}
-
-	void Append(VectorData &vdata, idx_t count) {
-		auto data = (T *)vdata.data;
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = vdata.sel->get_index(i);
-			state.template Update<RLECompressState<T>::RLEWriter>(data, vdata.validity, idx);
-		}
-	}
-
-	void WriteValue(T value, rle_count_t count, bool is_null) {
-		// write the RLE entry
-		auto handle_ptr = handle.Ptr() + RLEConstants::RLE_HEADER_SIZE;
-		auto data_pointer = (T *)handle_ptr;
-		auto index_pointer = (rle_count_t *)(handle_ptr + max_rle_count * sizeof(T));
-		data_pointer[entry_count] = value;
-		index_pointer[entry_count] = count;
-		entry_count++;
-
-		// update meta data
-		if (!is_null) {
-			NumericStatistics::Update<T>(current_segment->stats, value);
-		}
-		current_segment->count += count;
-
-		if (entry_count == max_rle_count) {
-			// we have finished writing this segment: flush it and create a new segment
-			auto row_start = current_segment->start + current_segment->count;
-			FlushSegment();
-			CreateEmptySegment(row_start);
-			entry_count = 0;
-		}
-	}
-
-	void FlushSegment() {
-		// flush the segment
-		// we compact the segment by moving the counts so they are directly next to the values
-		idx_t counts_size = sizeof(rle_count_t) * entry_count;
-		idx_t original_rle_offset = RLEConstants::RLE_HEADER_SIZE + max_rle_count * sizeof(T);
-		idx_t minimal_rle_offset = AlignValue(RLEConstants::RLE_HEADER_SIZE + sizeof(T) * entry_count);
-		idx_t total_segment_size = minimal_rle_offset + counts_size;
-		auto data_ptr = handle.Ptr();
-		memmove(data_ptr + minimal_rle_offset, data_ptr + original_rle_offset, counts_size);
-		// store the final RLE offset within the segment
-		Store<uint64_t>(minimal_rle_offset, data_ptr);
-		handle.Destroy();
-
-		auto &state = checkpointer.GetCheckpointState();
-		state.FlushSegment(move(current_segment), total_segment_size);
-	}
-
-	void Finalize() {
-		state.template Flush<RLECompressState<T>::RLEWriter>();
-
-		FlushSegment();
-		current_segment.reset();
-	}
-
-	ColumnDataCheckpointer &checkpointer;
-	CompressionFunction *function;
-	unique_ptr<ColumnSegment> current_segment;
-	BufferHandle handle;
-
-	RLEState<T> state;
-	idx_t entry_count = 0;
-	idx_t max_rle_count;
-};
-
-template <class T>
-unique_ptr<CompressionState> RLEInitCompression(ColumnDataCheckpointer &checkpointer, unique_ptr<AnalyzeState> state) {
-	return make_unique<RLECompressState<T>>(checkpointer);
-}
-
-template <class T>
-void RLECompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = (RLECompressState<T> &)state_p;
-	VectorData vdata;
-	scan_vector.Orrify(count, vdata);
-
-	state.Append(vdata, count);
-}
-
-template <class T>
-void RLEFinalizeCompress(CompressionState &state_p) {
-	auto &state = (RLECompressState<T> &)state_p;
-	state.Finalize();
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-template <class T>
-struct RLEScanState : public SegmentScanState {
-	explicit RLEScanState(ColumnSegment &segment) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		handle = buffer_manager.Pin(segment.block);
-		entry_pos = 0;
-		position_in_entry = 0;
-		rle_count_offset = Load<uint64_t>(handle.Ptr() + segment.GetBlockOffset());
-		D_ASSERT(rle_count_offset <= Storage::BLOCK_SIZE);
-	}
-
-	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		auto data = handle.Ptr() + segment.GetBlockOffset();
-		auto index_pointer = (rle_count_t *)(data + rle_count_offset);
-
-		for (idx_t i = 0; i < skip_count; i++) {
-			// assign the current value
-			position_in_entry++;
-			if (position_in_entry >= index_pointer[entry_pos]) {
-				// handled all entries in this RLE value
-				// move to the next entry
-				entry_pos++;
-				position_in_entry = 0;
-			}
-		}
-	}
-
-	BufferHandle handle;
-	uint32_t rle_offset;
-	idx_t entry_pos;
-	idx_t position_in_entry;
-	uint32_t rle_count_offset;
-};
-
-template <class T>
-unique_ptr<SegmentScanState> RLEInitScan(ColumnSegment &segment) {
-	auto result = make_unique<RLEScanState<T>>(segment);
-	return move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-template <class T>
-void RLESkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = (RLEScanState<T> &)*state.scan_state;
-	scan_state.Skip(segment, skip_count);
-}
-
-template <class T>
-void RLEScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                    idx_t result_offset) {
-	auto &scan_state = (RLEScanState<T> &)*state.scan_state;
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = (T *)(data + RLEConstants::RLE_HEADER_SIZE);
-	auto index_pointer = (rle_count_t *)(data + scan_state.rle_count_offset);
-
-	auto result_data = FlatVector::GetData<T>(result);
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	for (idx_t i = 0; i < scan_count; i++) {
-		// assign the current value
-		result_data[result_offset + i] = data_pointer[scan_state.entry_pos];
-		scan_state.position_in_entry++;
-		if (scan_state.position_in_entry >= index_pointer[scan_state.entry_pos]) {
-			// handled all entries in this RLE value
-			// move to the next entry
-			scan_state.entry_pos++;
-			scan_state.position_in_entry = 0;
-		}
-	}
-}
-
-template <class T>
-void RLEScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	// FIXME: emit constant vector if repetition of single value is >= scan_count
-	RLEScanPartial<T>(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-template <class T>
-void RLEFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	RLEScanState<T> scan_state(segment);
-	scan_state.Skip(segment, row_id);
-
-	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = (T *)(data + RLEConstants::RLE_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<T>(result);
-	result_data[result_idx] = data_pointer[scan_state.entry_pos];
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-template <class T>
-CompressionFunction GetRLEFunction(PhysicalType data_type) {
-	return CompressionFunction(CompressionType::COMPRESSION_RLE, data_type, RLEInitAnalyze<T>, RLEAnalyze<T>,
-	                           RLEFinalAnalyze<T>, RLEInitCompression<T>, RLECompress<T>, RLEFinalizeCompress<T>,
-	                           RLEInitScan<T>, RLEScan<T>, RLEScanPartial<T>, RLEFetchRow<T>, RLESkip<T>);
-}
-
-CompressionFunction RLEFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return GetRLEFunction<int8_t>(type);
-	case PhysicalType::INT16:
-		return GetRLEFunction<int16_t>(type);
-	case PhysicalType::INT32:
-		return GetRLEFunction<int32_t>(type);
-	case PhysicalType::INT64:
-		return GetRLEFunction<int64_t>(type);
-	case PhysicalType::INT128:
-		return GetRLEFunction<hugeint_t>(type);
-	case PhysicalType::UINT8:
-		return GetRLEFunction<uint8_t>(type);
-	case PhysicalType::UINT16:
-		return GetRLEFunction<uint16_t>(type);
-	case PhysicalType::UINT32:
-		return GetRLEFunction<uint32_t>(type);
-	case PhysicalType::UINT64:
-		return GetRLEFunction<uint64_t>(type);
-	case PhysicalType::FLOAT:
-		return GetRLEFunction<float>(type);
-	case PhysicalType::DOUBLE:
-		return GetRLEFunction<double>(type);
-	default:
-		throw InternalException("Unsupported type for RLE");
-	}
-}
-
-bool RLEFun::TypeIsSupported(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Storage Class
-//===--------------------------------------------------------------------===//
-UncompressedStringSegmentState::~UncompressedStringSegmentState() {
-	while (head) {
-		// prevent deep recursion here
-		head = move(head->next);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct StringAnalyzeState : public AnalyzeState {
-	StringAnalyzeState() : count(0), total_string_size(0), overflow_strings(0) {
-	}
-
-	idx_t count;
-	idx_t total_string_size;
-	idx_t overflow_strings;
-};
-
-unique_ptr<AnalyzeState> UncompressedStringStorage::StringInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	return make_unique<StringAnalyzeState>();
-}
-
-bool UncompressedStringStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = (StringAnalyzeState &)state_p;
-	VectorData vdata;
-	input.Orrify(count, vdata);
-
-	state.count += count;
-	auto data = (string_t *)vdata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (vdata.validity.RowIsValid(idx)) {
-			auto string_size = data[idx].GetSize();
-			state.total_string_size += string_size;
-			if (string_size >= StringUncompressed::STRING_BLOCK_LIMIT) {
-				state.overflow_strings++;
-			}
-		}
-	}
-	return true;
-}
-
-idx_t UncompressedStringStorage::StringFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = (StringAnalyzeState &)state_p;
-	return state.count * sizeof(int32_t) + state.total_string_size + state.overflow_strings * BIG_STRING_MARKER_SIZE;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-unique_ptr<SegmentScanState> UncompressedStringStorage::StringInitScan(ColumnSegment &segment) {
-	auto result = make_unique<StringScanState>();
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	result->handle = buffer_manager.Pin(segment.block);
-	return move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-void UncompressedStringStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                                  Vector &result, idx_t result_offset) {
-	// clear any previously locked buffers and get the primary buffer handle
-	auto &scan_state = (StringScanState &)*state.scan_state;
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	auto baseptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto dict = GetDictionary(segment, scan_state.handle);
-	auto base_data = (int32_t *)(baseptr + DICTIONARY_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<string_t>(result);
-
-	int32_t previous_offset = start > 0 ? base_data[start - 1] : 0;
-
-	for (idx_t i = 0; i < scan_count; i++) {
-		// std::abs used since offsets can be negative to indicate big strings
-		uint32_t string_length = std::abs(base_data[start + i]) - std::abs(previous_offset);
-		result_data[result_offset + i] =
-		    FetchStringFromDict(segment, dict, result, baseptr, base_data[start + i], string_length);
-		previous_offset = base_data[start + i];
-	}
-}
-
-void UncompressedStringStorage::StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                           Vector &result) {
-	StringScanPartial(segment, state, scan_count, result, 0);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-BufferHandle &ColumnFetchState::GetOrInsertHandle(ColumnSegment &segment) {
-	auto primary_id = segment.block->BlockId();
-
-	auto entry = handles.find(primary_id);
-	if (entry == handles.end()) {
-		// not pinned yet: pin it
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		auto handle = buffer_manager.Pin(segment.block);
-		auto entry = handles.insert(make_pair(primary_id, move(handle)));
-		return entry.first->second;
-	} else {
-		// already pinned: use the pinned handle
-		return entry->second;
-	}
-}
-
-void UncompressedStringStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id,
-                                               Vector &result, idx_t result_idx) {
-	// fetch a single row from the string segment
-	// first pin the main buffer if it is not already pinned
-	auto &handle = state.GetOrInsertHandle(segment);
-
-	auto baseptr = handle.Ptr() + segment.GetBlockOffset();
-	auto dict = GetDictionary(segment, handle);
-	auto base_data = (int32_t *)(baseptr + DICTIONARY_HEADER_SIZE);
-	auto result_data = FlatVector::GetData<string_t>(result);
-
-	auto dict_offset = base_data[row_id];
-	uint32_t string_length;
-	if ((idx_t)row_id == 0) {
-		// edge case where this is the first string in the dict
-		string_length = std::abs(dict_offset);
-	} else {
-		string_length = std::abs(dict_offset) - std::abs(base_data[row_id - 1]);
-	}
-	result_data[result_idx] = FetchStringFromDict(segment, dict, result, baseptr, dict_offset, string_length);
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-unique_ptr<CompressedSegmentState> UncompressedStringStorage::StringInitSegment(ColumnSegment &segment,
-                                                                                block_id_t block_id) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	if (block_id == INVALID_BLOCK) {
-		auto handle = buffer_manager.Pin(segment.block);
-		StringDictionaryContainer dictionary;
-		dictionary.size = 0;
-		dictionary.end = Storage::BLOCK_SIZE;
-		SetDictionary(segment, handle, dictionary);
-	}
-	return make_unique<UncompressedStringSegmentState>();
-}
-
-idx_t UncompressedStringStorage::FinalizeAppend(ColumnSegment &segment, SegmentStatistics &stats) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	auto dict = GetDictionary(segment, handle);
-	D_ASSERT(dict.end == Storage::BLOCK_SIZE);
-	// compute the total size required to store this segment
-	auto offset_size = DICTIONARY_HEADER_SIZE + segment.count * sizeof(int32_t);
-	auto total_size = offset_size + dict.size;
-	if (total_size >= COMPACTION_FLUSH_LIMIT) {
-		// the block is full enough, don't bother moving around the dictionary
-		return Storage::BLOCK_SIZE;
-	}
-	// the block has space left: figure out how much space we can save
-	auto move_amount = Storage::BLOCK_SIZE - total_size;
-	// move the dictionary so it lines up exactly with the offsets
-	auto dataptr = handle.Ptr();
-	memmove(dataptr + offset_size, dataptr + dict.end - dict.size, dict.size);
-	dict.end -= move_amount;
-	D_ASSERT(dict.end == total_size);
-	// write the new dictionary (with the updated "end")
-	SetDictionary(segment, handle, dict);
-	return total_size;
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction StringUncompressed::GetFunction(PhysicalType data_type) {
-	D_ASSERT(data_type == PhysicalType::VARCHAR);
-	return CompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED, data_type,
-	                           UncompressedStringStorage::StringInitAnalyze, UncompressedStringStorage::StringAnalyze,
-	                           UncompressedStringStorage::StringFinalAnalyze, UncompressedFunctions::InitCompression,
-	                           UncompressedFunctions::Compress, UncompressedFunctions::FinalizeCompress,
-	                           UncompressedStringStorage::StringInitScan, UncompressedStringStorage::StringScan,
-	                           UncompressedStringStorage::StringScanPartial, UncompressedStringStorage::StringFetchRow,
-	                           UncompressedFunctions::EmptySkip, UncompressedStringStorage::StringInitSegment,
-	                           UncompressedStringStorage::StringAppend, UncompressedStringStorage::FinalizeAppend);
-}
-
-//===--------------------------------------------------------------------===//
-// Helper Functions
-//===--------------------------------------------------------------------===//
-void UncompressedStringStorage::SetDictionary(ColumnSegment &segment, BufferHandle &handle,
-                                              StringDictionaryContainer container) {
-	auto startptr = handle.Ptr() + segment.GetBlockOffset();
-	Store<uint32_t>(container.size, startptr);
-	Store<uint32_t>(container.end, startptr + sizeof(uint32_t));
-}
-
-StringDictionaryContainer UncompressedStringStorage::GetDictionary(ColumnSegment &segment, BufferHandle &handle) {
-	auto startptr = handle.Ptr() + segment.GetBlockOffset();
-	StringDictionaryContainer container;
-	container.size = Load<uint32_t>(startptr);
-	container.end = Load<uint32_t>(startptr + sizeof(uint32_t));
-	return container;
-}
-
-idx_t UncompressedStringStorage::RemainingSpace(ColumnSegment &segment, BufferHandle &handle) {
-	auto dictionary = GetDictionary(segment, handle);
-	D_ASSERT(dictionary.end == Storage::BLOCK_SIZE);
-	idx_t used_space = dictionary.size + segment.count * sizeof(int32_t) + DICTIONARY_HEADER_SIZE;
-	D_ASSERT(Storage::BLOCK_SIZE >= used_space);
-	return Storage::BLOCK_SIZE - used_space;
-}
-
-void UncompressedStringStorage::WriteString(ColumnSegment &segment, string_t string, block_id_t &result_block,
-                                            int32_t &result_offset) {
-	auto &state = (UncompressedStringSegmentState &)*segment.GetSegmentState();
-	if (state.overflow_writer) {
-		// overflow writer is set: write string there
-		state.overflow_writer->WriteString(string, result_block, result_offset);
-	} else {
-		// default overflow behavior: use in-memory buffer to store the overflow string
-		WriteStringMemory(segment, string, result_block, result_offset);
-	}
-}
-
-void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string_t string, block_id_t &result_block,
-                                                  int32_t &result_offset) {
-	uint32_t total_length = string.GetSize() + sizeof(uint32_t);
-	shared_ptr<BlockHandle> block;
-	BufferHandle handle;
-
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto &state = (UncompressedStringSegmentState &)*segment.GetSegmentState();
-	// check if the string fits in the current block
-	if (!state.head || state.head->offset + total_length >= state.head->size) {
-		// string does not fit, allocate space for it
-		// create a new string block
-		idx_t alloc_size = MaxValue<idx_t>(total_length, Storage::BLOCK_SIZE);
-		auto new_block = make_unique<StringBlock>();
-		new_block->offset = 0;
-		new_block->size = alloc_size;
-		// allocate an in-memory buffer for it
-		block = buffer_manager.RegisterMemory(alloc_size, false);
-		handle = buffer_manager.Pin(block);
-		state.overflow_blocks[block->BlockId()] = new_block.get();
-		new_block->block = move(block);
-		new_block->next = move(state.head);
-		state.head = move(new_block);
-	} else {
-		// string fits, copy it into the current block
-		handle = buffer_manager.Pin(state.head->block);
-	}
-
-	result_block = state.head->block->BlockId();
-	result_offset = state.head->offset;
-
-	// copy the string and the length there
-	auto ptr = handle.Ptr() + state.head->offset;
-	Store<uint32_t>(string.GetSize(), ptr);
-	ptr += sizeof(uint32_t);
-	memcpy(ptr, string.GetDataUnsafe(), string.GetSize());
-	state.head->offset += total_length;
-}
-
-string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, Vector &result, block_id_t block,
-                                                       int32_t offset) {
-	D_ASSERT(block != INVALID_BLOCK);
-	D_ASSERT(offset < Storage::BLOCK_SIZE);
-
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto &state = (UncompressedStringSegmentState &)*segment.GetSegmentState();
-	if (block < MAXIMUM_BLOCK) {
-		// read the overflow string from disk
-		// pin the initial handle and read the length
-		auto block_handle = buffer_manager.RegisterBlock(block);
-		auto handle = buffer_manager.Pin(block_handle);
-
-		// read header
-		uint32_t compressed_size = Load<uint32_t>(handle.Ptr() + offset);
-		uint32_t uncompressed_size = Load<uint32_t>(handle.Ptr() + offset + sizeof(uint32_t));
-		uint32_t remaining = compressed_size;
-		offset += 2 * sizeof(uint32_t);
-
-		data_ptr_t decompression_ptr;
-		std::unique_ptr<data_t[]> decompression_buffer;
-
-		// If string is in single block we decompress straight from it, else we copy first
-		if (remaining <= Storage::BLOCK_SIZE - sizeof(block_id_t) - offset) {
-			decompression_ptr = handle.Ptr() + offset;
-		} else {
-			decompression_buffer = std::unique_ptr<data_t[]>(new data_t[compressed_size]);
-			auto target_ptr = decompression_buffer.get();
-
-			// now append the string to the single buffer
-			while (remaining > 0) {
-				idx_t to_write = MinValue<idx_t>(remaining, Storage::BLOCK_SIZE - sizeof(block_id_t) - offset);
-				memcpy(target_ptr, handle.Ptr() + offset, to_write);
-
-				remaining -= to_write;
-				offset += to_write;
-				target_ptr += to_write;
-				if (remaining > 0) {
-					// read the next block
-					block_id_t next_block = Load<block_id_t>(handle.Ptr() + offset);
-					block_handle = buffer_manager.RegisterBlock(next_block);
-					handle = buffer_manager.Pin(block_handle);
-					offset = 0;
-				}
-			}
-			decompression_ptr = decompression_buffer.get();
-		}
-
-		// overflow strings on disk are gzipped, decompress here
-		auto decompressed_target_handle =
-		    buffer_manager.Allocate(MaxValue<idx_t>(Storage::BLOCK_SIZE, uncompressed_size));
-		auto decompressed_target_ptr = decompressed_target_handle.Ptr();
-		MiniZStream s;
-		s.Decompress((const char *)decompression_ptr, compressed_size, (char *)decompressed_target_ptr,
-		             uncompressed_size);
-
-		auto final_buffer = decompressed_target_handle.Ptr();
-		StringVector::AddHandle(result, move(decompressed_target_handle));
-		return ReadString(final_buffer, 0, uncompressed_size);
-	} else {
-		// read the overflow string from memory
-		// first pin the handle, if it is not pinned yet
-		auto entry = state.overflow_blocks.find(block);
-		D_ASSERT(entry != state.overflow_blocks.end());
-		auto handle = buffer_manager.Pin(entry->second->block);
-		auto final_buffer = handle.Ptr();
-		StringVector::AddHandle(result, move(handle));
-		return ReadStringWithLength(final_buffer, offset);
-	}
-}
-
-string_t UncompressedStringStorage::ReadString(data_ptr_t target, int32_t offset, uint32_t string_length) {
-	auto ptr = target + offset;
-	auto str_ptr = (char *)(ptr);
-	return string_t(str_ptr, string_length);
-}
-
-string_t UncompressedStringStorage::ReadStringWithLength(data_ptr_t target, int32_t offset) {
-	auto ptr = target + offset;
-	auto str_length = Load<uint32_t>(ptr);
-	auto str_ptr = (char *)(ptr + sizeof(uint32_t));
-	return string_t(str_ptr, str_length);
-}
-
-void UncompressedStringStorage::WriteStringMarker(data_ptr_t target, block_id_t block_id, int32_t offset) {
-	memcpy(target, &block_id, sizeof(block_id_t));
-	target += sizeof(block_id_t);
-	memcpy(target, &offset, sizeof(int32_t));
-}
-
-void UncompressedStringStorage::ReadStringMarker(data_ptr_t target, block_id_t &block_id, int32_t &offset) {
-	memcpy(&block_id, target, sizeof(block_id_t));
-	target += sizeof(block_id_t);
-	memcpy(&offset, target, sizeof(int32_t));
-}
-
-string_location_t UncompressedStringStorage::FetchStringLocation(StringDictionaryContainer dict, data_ptr_t baseptr,
-                                                                 int32_t dict_offset) {
-	D_ASSERT(dict_offset >= -1 * Storage::BLOCK_SIZE && dict_offset <= Storage::BLOCK_SIZE);
-	if (dict_offset < 0) {
-		string_location_t result;
-		ReadStringMarker(baseptr + dict.end - (-1 * dict_offset), result.block_id, result.offset);
-		return result;
-	} else {
-		return string_location_t(INVALID_BLOCK, dict_offset);
-	}
-}
-
-string_t UncompressedStringStorage::FetchStringFromDict(ColumnSegment &segment, StringDictionaryContainer dict,
-                                                        Vector &result, data_ptr_t baseptr, int32_t dict_offset,
-                                                        uint32_t string_length) {
-	// fetch base data
-	D_ASSERT(dict_offset <= Storage::BLOCK_SIZE);
-	string_location_t location = FetchStringLocation(dict, baseptr, dict_offset);
-	return FetchString(segment, dict, result, baseptr, location, string_length);
-}
-
-string_t UncompressedStringStorage::FetchString(ColumnSegment &segment, StringDictionaryContainer dict, Vector &result,
-                                                data_ptr_t baseptr, string_location_t location,
-                                                uint32_t string_length) {
-	if (location.block_id != INVALID_BLOCK) {
-		// big string marker: read from separate block
-		return ReadOverflowString(segment, result, location.block_id, location.offset);
-	} else {
-		if (location.offset == 0) {
-			return string_t(nullptr, 0);
-		}
-		// normal string: read string from this block
-		auto dict_end = baseptr + dict.end;
-		auto dict_pos = dict_end - location.offset;
-
-		auto str_ptr = (char *)(dict_pos);
-		return string_t(str_ptr, string_length);
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-CompressionFunction UncompressedFun::GetFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::INT128:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-	case PhysicalType::LIST:
-	case PhysicalType::INTERVAL:
-		return FixedSizeUncompressed::GetFunction(type);
-	case PhysicalType::BIT:
-		return ValidityUncompressed::GetFunction(type);
-	case PhysicalType::VARCHAR:
-		return StringUncompressed::GetFunction(type);
-	default:
-		throw InternalException("Unsupported type for Uncompressed");
-	}
-}
-
-bool UncompressedFun::TypeIsSupported(PhysicalType type) {
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Mask constants
-//===--------------------------------------------------------------------===//
-// LOWER_MASKS contains masks with all the lower bits set until a specific value
-// LOWER_MASKS[0] has the 0 lowest bits set, i.e.:
-// 0b0000000000000000000000000000000000000000000000000000000000000000,
-// LOWER_MASKS[10] has the 10 lowest bits set, i.e.:
-// 0b0000000000000000000000000000000000000000000000000000000111111111,
-// etc...
-// 0b0000000000000000000000000000000000000001111111111111111111111111,
-// ...
-// 0b0000000000000000000001111111111111111111111111111111111111111111,
-// until LOWER_MASKS[64], which has all bits set:
-// 0b1111111111111111111111111111111111111111111111111111111111111111
-// generated with this python snippet:
-// for i in range(65):
-//   print(hex(int((64 - i) * '0' + i * '1', 2)) + ",")
-const validity_t ValidityUncompressed::LOWER_MASKS[] = {0x0,
-                                                        0x1,
-                                                        0x3,
-                                                        0x7,
-                                                        0xf,
-                                                        0x1f,
-                                                        0x3f,
-                                                        0x7f,
-                                                        0xff,
-                                                        0x1ff,
-                                                        0x3ff,
-                                                        0x7ff,
-                                                        0xfff,
-                                                        0x1fff,
-                                                        0x3fff,
-                                                        0x7fff,
-                                                        0xffff,
-                                                        0x1ffff,
-                                                        0x3ffff,
-                                                        0x7ffff,
-                                                        0xfffff,
-                                                        0x1fffff,
-                                                        0x3fffff,
-                                                        0x7fffff,
-                                                        0xffffff,
-                                                        0x1ffffff,
-                                                        0x3ffffff,
-                                                        0x7ffffff,
-                                                        0xfffffff,
-                                                        0x1fffffff,
-                                                        0x3fffffff,
-                                                        0x7fffffff,
-                                                        0xffffffff,
-                                                        0x1ffffffff,
-                                                        0x3ffffffff,
-                                                        0x7ffffffff,
-                                                        0xfffffffff,
-                                                        0x1fffffffff,
-                                                        0x3fffffffff,
-                                                        0x7fffffffff,
-                                                        0xffffffffff,
-                                                        0x1ffffffffff,
-                                                        0x3ffffffffff,
-                                                        0x7ffffffffff,
-                                                        0xfffffffffff,
-                                                        0x1fffffffffff,
-                                                        0x3fffffffffff,
-                                                        0x7fffffffffff,
-                                                        0xffffffffffff,
-                                                        0x1ffffffffffff,
-                                                        0x3ffffffffffff,
-                                                        0x7ffffffffffff,
-                                                        0xfffffffffffff,
-                                                        0x1fffffffffffff,
-                                                        0x3fffffffffffff,
-                                                        0x7fffffffffffff,
-                                                        0xffffffffffffff,
-                                                        0x1ffffffffffffff,
-                                                        0x3ffffffffffffff,
-                                                        0x7ffffffffffffff,
-                                                        0xfffffffffffffff,
-                                                        0x1fffffffffffffff,
-                                                        0x3fffffffffffffff,
-                                                        0x7fffffffffffffff,
-                                                        0xffffffffffffffff};
-
-// UPPER_MASKS contains masks with all the highest bits set until a specific value
-// UPPER_MASKS[0] has the 0 highest bits set, i.e.:
-// 0b0000000000000000000000000000000000000000000000000000000000000000,
-// UPPER_MASKS[10] has the 10 highest bits set, i.e.:
-// 0b1111111111110000000000000000000000000000000000000000000000000000,
-// etc...
-// 0b1111111111111111111111110000000000000000000000000000000000000000,
-// ...
-// 0b1111111111111111111111111111111111111110000000000000000000000000,
-// until UPPER_MASKS[64], which has all bits set:
-// 0b1111111111111111111111111111111111111111111111111111111111111111
-// generated with this python snippet:
-// for i in range(65):
-//   print(hex(int(i * '1' + (64 - i) * '0', 2)) + ",")
-const validity_t ValidityUncompressed::UPPER_MASKS[] = {0x0,
-                                                        0x8000000000000000,
-                                                        0xc000000000000000,
-                                                        0xe000000000000000,
-                                                        0xf000000000000000,
-                                                        0xf800000000000000,
-                                                        0xfc00000000000000,
-                                                        0xfe00000000000000,
-                                                        0xff00000000000000,
-                                                        0xff80000000000000,
-                                                        0xffc0000000000000,
-                                                        0xffe0000000000000,
-                                                        0xfff0000000000000,
-                                                        0xfff8000000000000,
-                                                        0xfffc000000000000,
-                                                        0xfffe000000000000,
-                                                        0xffff000000000000,
-                                                        0xffff800000000000,
-                                                        0xffffc00000000000,
-                                                        0xffffe00000000000,
-                                                        0xfffff00000000000,
-                                                        0xfffff80000000000,
-                                                        0xfffffc0000000000,
-                                                        0xfffffe0000000000,
-                                                        0xffffff0000000000,
-                                                        0xffffff8000000000,
-                                                        0xffffffc000000000,
-                                                        0xffffffe000000000,
-                                                        0xfffffff000000000,
-                                                        0xfffffff800000000,
-                                                        0xfffffffc00000000,
-                                                        0xfffffffe00000000,
-                                                        0xffffffff00000000,
-                                                        0xffffffff80000000,
-                                                        0xffffffffc0000000,
-                                                        0xffffffffe0000000,
-                                                        0xfffffffff0000000,
-                                                        0xfffffffff8000000,
-                                                        0xfffffffffc000000,
-                                                        0xfffffffffe000000,
-                                                        0xffffffffff000000,
-                                                        0xffffffffff800000,
-                                                        0xffffffffffc00000,
-                                                        0xffffffffffe00000,
-                                                        0xfffffffffff00000,
-                                                        0xfffffffffff80000,
-                                                        0xfffffffffffc0000,
-                                                        0xfffffffffffe0000,
-                                                        0xffffffffffff0000,
-                                                        0xffffffffffff8000,
-                                                        0xffffffffffffc000,
-                                                        0xffffffffffffe000,
-                                                        0xfffffffffffff000,
-                                                        0xfffffffffffff800,
-                                                        0xfffffffffffffc00,
-                                                        0xfffffffffffffe00,
-                                                        0xffffffffffffff00,
-                                                        0xffffffffffffff80,
-                                                        0xffffffffffffffc0,
-                                                        0xffffffffffffffe0,
-                                                        0xfffffffffffffff0,
-                                                        0xfffffffffffffff8,
-                                                        0xfffffffffffffffc,
-                                                        0xfffffffffffffffe,
-                                                        0xffffffffffffffff};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-struct ValidityAnalyzeState : public AnalyzeState {
-	ValidityAnalyzeState() : count(0) {
-	}
-
-	idx_t count;
-};
-
-unique_ptr<AnalyzeState> ValidityInitAnalyze(ColumnData &col_data, PhysicalType type) {
-	return make_unique<ValidityAnalyzeState>();
-}
-
-bool ValidityAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = (ValidityAnalyzeState &)state_p;
-	state.count += count;
-	return true;
-}
-
-idx_t ValidityFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = (ValidityAnalyzeState &)state_p;
-	return (state.count + 7) / 8;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-struct ValidityScanState : public SegmentScanState {
-	BufferHandle handle;
-};
-
-unique_ptr<SegmentScanState> ValidityInitScan(ColumnSegment &segment) {
-	auto result = make_unique<ValidityScanState>();
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	result->handle = buffer_manager.Pin(segment.block);
-	return move(result);
-}
-
-//===--------------------------------------------------------------------===//
-// Scan base data
-//===--------------------------------------------------------------------===//
-void ValidityScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-                         idx_t result_offset) {
-	auto start = segment.GetRelativeIndex(state.row_index);
-
-	static_assert(sizeof(validity_t) == sizeof(uint64_t), "validity_t should be 64-bit");
-	auto &scan_state = (ValidityScanState &)*state.scan_state;
-
-	auto &result_mask = FlatVector::Validity(result);
-	auto buffer_ptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto input_data = (validity_t *)buffer_ptr;
-
-#ifdef DEBUG
-	// this method relies on all the bits we are going to write to being set to valid
-	for (idx_t i = 0; i < scan_count; i++) {
-		D_ASSERT(result_mask.RowIsValid(result_offset + i));
-	}
-#endif
-#if STANDARD_VECTOR_SIZE < 128
-	// fallback for tiny vector sizes
-	// the bitwise ops we use below don't work if the vector size is too small
-	ValidityMask source_mask(input_data);
-	for (idx_t i = 0; i < scan_count; i++) {
-		if (!source_mask.RowIsValid(start + i)) {
-			if (result_mask.AllValid()) {
-				result_mask.Initialize(MaxValue<idx_t>(STANDARD_VECTOR_SIZE, result_offset + scan_count));
-			}
-			result_mask.SetInvalid(result_offset + i);
-		}
-	}
-#else
-	// the code below does what the fallback code above states, but using bitwise ops:
-	auto result_data = (validity_t *)result_mask.GetData();
-
-	// set up the initial positions
-	// we need to find the validity_entry to modify, together with the bit-index WITHIN the validity entry
-	idx_t result_entry = result_offset / ValidityMask::BITS_PER_VALUE;
-	idx_t result_idx = result_offset - result_entry * ValidityMask::BITS_PER_VALUE;
-
-	// same for the input: find the validity_entry we are pulling from, together with the bit-index WITHIN that entry
-	idx_t input_entry = start / ValidityMask::BITS_PER_VALUE;
-	idx_t input_idx = start - input_entry * ValidityMask::BITS_PER_VALUE;
-
-	// now start the bit games
-	idx_t pos = 0;
-	while (pos < scan_count) {
-		// these are the current validity entries we are dealing with
-		idx_t current_result_idx = result_entry;
-		idx_t offset;
-		validity_t input_mask = input_data[input_entry];
-
-		// construct the mask to AND together with the result
-		if (result_idx < input_idx) {
-			// we have to shift the input RIGHT if the result_idx is smaller than the input_idx
-			auto shift_amount = input_idx - result_idx;
-			D_ASSERT(shift_amount > 0 && shift_amount <= ValidityMask::BITS_PER_VALUE);
-
-			input_mask = input_mask >> shift_amount;
-
-			// now the upper "shift_amount" bits are set to 0
-			// we need them to be set to 1
-			// otherwise the subsequent bitwise & will modify values outside of the range of values we want to alter
-			input_mask |= ValidityUncompressed::UPPER_MASKS[shift_amount];
-
-			// after this, we move to the next input_entry
-			offset = ValidityMask::BITS_PER_VALUE - input_idx;
-			input_entry++;
-			input_idx = 0;
-			result_idx += offset;
-		} else if (result_idx > input_idx) {
-			// we have to shift the input LEFT if the result_idx is bigger than the input_idx
-			auto shift_amount = result_idx - input_idx;
-			D_ASSERT(shift_amount > 0 && shift_amount <= ValidityMask::BITS_PER_VALUE);
-
-			// to avoid overflows, we set the upper "shift_amount" values to 0 first
-			input_mask = (input_mask & ~ValidityUncompressed::UPPER_MASKS[shift_amount]) << shift_amount;
-
-			// now the lower "shift_amount" bits are set to 0
-			// we need them to be set to 1
-			// otherwise the subsequent bitwise & will modify values outside of the range of values we want to alter
-			input_mask |= ValidityUncompressed::LOWER_MASKS[shift_amount];
-
-			// after this, we move to the next result_entry
-			offset = ValidityMask::BITS_PER_VALUE - result_idx;
-			result_entry++;
-			result_idx = 0;
-			input_idx += offset;
-		} else {
-			// if the input_idx is equal to result_idx they are already aligned
-			// we just move to the next entry for both after this
-			offset = ValidityMask::BITS_PER_VALUE - result_idx;
-			input_entry++;
-			result_entry++;
-			result_idx = input_idx = 0;
-		}
-		// now we need to check if we should include the ENTIRE mask
-		// OR if we need to mask from the right side
-		pos += offset;
-		if (pos > scan_count) {
-			// we need to set any bits that are past the scan_count on the right-side to 1
-			// this is required so we don't influence any bits that are not part of the scan
-			input_mask |= ValidityUncompressed::UPPER_MASKS[pos - scan_count];
-		}
-		// now finally we can merge the input mask with the result mask
-		if (input_mask != ValidityMask::ValidityBuffer::MAX_ENTRY) {
-			if (!result_data) {
-				result_mask.Initialize(MaxValue<idx_t>(STANDARD_VECTOR_SIZE, result_offset + scan_count));
-				result_data = (validity_t *)result_mask.GetData();
-			}
-			result_data[current_result_idx] &= input_mask;
-		}
-	}
-#endif
-
-#ifdef DEBUG
-	// verify that we actually accomplished the bitwise ops equivalent that we wanted to do
-	ValidityMask input_mask(input_data);
-	for (idx_t i = 0; i < scan_count; i++) {
-		D_ASSERT(result_mask.RowIsValid(result_offset + i) == input_mask.RowIsValid(start + i));
-	}
-#endif
-}
-
-void ValidityScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	result.Normalify(scan_count);
-
-	auto start = segment.GetRelativeIndex(state.row_index);
-	if (start % ValidityMask::BITS_PER_VALUE == 0) {
-		auto &scan_state = (ValidityScanState &)*state.scan_state;
-
-		// aligned scan: no need to do anything fancy
-		// note: this is only an optimization which avoids having to do messy bitshifting in the common case
-		// it is not required for correctness
-		auto &result_mask = FlatVector::Validity(result);
-		auto buffer_ptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
-		auto input_data = (validity_t *)buffer_ptr;
-		auto result_data = (validity_t *)result_mask.GetData();
-		idx_t start_offset = start / ValidityMask::BITS_PER_VALUE;
-		idx_t entry_scan_count = (scan_count + ValidityMask::BITS_PER_VALUE - 1) / ValidityMask::BITS_PER_VALUE;
-		for (idx_t i = 0; i < entry_scan_count; i++) {
-			auto input_entry = input_data[start_offset + i];
-			if (!result_data && input_entry == ValidityMask::ValidityBuffer::MAX_ENTRY) {
-				continue;
-			}
-			if (!result_data) {
-				result_mask.Initialize(MaxValue<idx_t>(STANDARD_VECTOR_SIZE, scan_count));
-				result_data = (validity_t *)result_mask.GetData();
-			}
-			result_data[i] = input_entry;
-		}
-	} else {
-		// unaligned scan: fall back to scan_partial which does bitshift tricks
-		ValidityScanPartial(segment, state, scan_count, result, 0);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void ValidityFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	D_ASSERT(row_id >= 0 && row_id < row_t(segment.count));
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	auto dataptr = handle.Ptr() + segment.GetBlockOffset();
-	ValidityMask mask((validity_t *)dataptr);
-	auto &result_mask = FlatVector::Validity(result);
-	if (!mask.RowIsValidUnsafe(row_id)) {
-		result_mask.SetInvalid(result_idx);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-unique_ptr<CompressedSegmentState> ValidityInitSegment(ColumnSegment &segment, block_id_t block_id) {
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	if (block_id == INVALID_BLOCK) {
-		auto handle = buffer_manager.Pin(segment.block);
-		memset(handle.Ptr(), 0xFF, Storage::BLOCK_SIZE);
-	}
-	return nullptr;
-}
-
-idx_t ValidityAppend(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset, idx_t vcount) {
-	D_ASSERT(segment.GetBlockOffset() == 0);
-	auto &validity_stats = (ValidityStatistics &)*stats.statistics;
-
-	auto max_tuples = Storage::BLOCK_SIZE / ValidityMask::STANDARD_MASK_SIZE * STANDARD_VECTOR_SIZE;
-	idx_t append_count = MinValue<idx_t>(vcount, max_tuples - segment.count);
-	if (data.validity.AllValid()) {
-		// no null values: skip append
-		segment.count += append_count;
-		validity_stats.has_no_null = true;
-		return append_count;
-	}
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-
-	ValidityMask mask((validity_t *)handle.Ptr());
-	for (idx_t i = 0; i < append_count; i++) {
-		auto idx = data.sel->get_index(offset + i);
-		if (!data.validity.RowIsValidUnsafe(idx)) {
-			mask.SetInvalidUnsafe(segment.count + i);
-			validity_stats.has_null = true;
-		} else {
-			validity_stats.has_no_null = true;
-		}
-	}
-	segment.count += append_count;
-	return append_count;
-}
-
-idx_t ValidityFinalizeAppend(ColumnSegment &segment, SegmentStatistics &stats) {
-	return ((segment.count + STANDARD_VECTOR_SIZE - 1) / STANDARD_VECTOR_SIZE) * ValidityMask::STANDARD_MASK_SIZE;
-}
-
-void ValidityRevertAppend(ColumnSegment &segment, idx_t start_row) {
-	idx_t start_bit = start_row - segment.start;
-
-	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto handle = buffer_manager.Pin(segment.block);
-	idx_t revert_start;
-	if (start_bit % 8 != 0) {
-		// handle sub-bit stuff (yay)
-		idx_t byte_pos = start_bit / 8;
-		idx_t bit_start = byte_pos * 8;
-		idx_t bit_end = (byte_pos + 1) * 8;
-		ValidityMask mask((validity_t *)handle.Ptr() + byte_pos);
-		for (idx_t i = start_bit; i < bit_end; i++) {
-			mask.SetValid(i - bit_start);
-		}
-		revert_start = bit_end / 8;
-	} else {
-		revert_start = start_bit / 8;
-	}
-	// for the rest, we just memset
-	memset(handle.Ptr() + revert_start, 0xFF, Storage::BLOCK_SIZE - revert_start);
-}
-
-//===--------------------------------------------------------------------===//
-// Get Function
-//===--------------------------------------------------------------------===//
-CompressionFunction ValidityUncompressed::GetFunction(PhysicalType data_type) {
-	D_ASSERT(data_type == PhysicalType::BIT);
-	return CompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED, data_type, ValidityInitAnalyze,
-	                           ValidityAnalyze, ValidityFinalAnalyze, UncompressedFunctions::InitCompression,
-	                           UncompressedFunctions::Compress, UncompressedFunctions::FinalizeCompress,
-	                           ValidityInitScan, ValidityScan, ValidityScanPartial, ValidityFetchRow,
-	                           UncompressedFunctions::EmptySkip, ValidityInitSegment, ValidityAppend,
-	                           ValidityFinalizeAppend, ValidityRevertAppend);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-DataTable::DataTable(DatabaseInstance &db, const string &schema, const string &table,
-                     vector<ColumnDefinition> column_definitions_p, unique_ptr<PersistentTableData> data)
-    : info(make_shared<DataTableInfo>(db, schema, table)), column_definitions(move(column_definitions_p)), db(db),
-      total_rows(0), is_root(true) {
-	// initialize the table with the existing data from disk, if any
-	this->row_groups = make_shared<SegmentTree>();
-	auto types = GetTypes();
-	if (data && !data->row_groups.empty()) {
-		for (auto &row_group_pointer : data->row_groups) {
-			auto new_row_group = make_unique<RowGroup>(db, *info, types, row_group_pointer);
-			auto row_group_count = new_row_group->start + new_row_group->count;
-			if (row_group_count > total_rows) {
-				total_rows = row_group_count;
-			}
-			row_groups->AppendSegment(move(new_row_group));
-		}
-		column_stats.reserve(data->column_stats.size());
-		for (auto &stats : data->column_stats) {
-			column_stats.push_back(make_shared<ColumnStatistics>(move(stats)));
-		}
-		if (column_stats.size() != types.size()) { // LCOV_EXCL_START
-			throw IOException("Table statistics column count is not aligned with table column count. Corrupt file?");
-		} // LCOV_EXCL_STOP
-	}
-	if (column_stats.empty()) {
-		D_ASSERT(total_rows == 0);
-
-		AppendRowGroup(0);
-		for (auto &type : types) {
-			column_stats.push_back(ColumnStatistics::CreateEmptyStats(type));
-		}
-	} else {
-		D_ASSERT(column_stats.size() == types.size());
-		D_ASSERT(row_groups->GetRootSegment() != nullptr);
-	}
-}
-
-void DataTable::AppendRowGroup(idx_t start_row) {
-	auto types = GetTypes();
-	auto new_row_group = make_unique<RowGroup>(db, *info, start_row, 0);
-	new_row_group->InitializeEmpty(types);
-	row_groups->AppendSegment(move(new_row_group));
-}
-
-DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression *default_value)
-    : info(parent.info), db(parent.db), total_rows(parent.total_rows.load()), is_root(true) {
-	for (auto &column_def : parent.column_definitions) {
-		column_definitions.emplace_back(column_def.Copy());
-	}
-	// prevent any new tuples from being added to the parent
-	lock_guard<mutex> parent_lock(parent.append_lock);
-	// add the new column to this DataTable
-	auto new_column_type = new_column.Type();
-	auto new_column_idx = parent.column_definitions.size();
-
-	// set up the statistics
-	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
-		column_stats.push_back(parent.column_stats[i]);
-	}
-	column_stats.push_back(ColumnStatistics::CreateEmptyStats(new_column_type));
-
-	// add the column definitions from this DataTable
-	column_definitions.emplace_back(new_column.Copy());
-
-	auto &transaction = Transaction::GetTransaction(context);
-
-	ExpressionExecutor executor(Allocator::Get(context));
-	DataChunk dummy_chunk;
-	Vector result(new_column_type);
-	if (!default_value) {
-		FlatVector::Validity(result).SetAllInvalid(STANDARD_VECTOR_SIZE);
-	} else {
-		executor.AddExpression(*default_value);
-	}
-
-	// fill the column with its DEFAULT value, or NULL if none is specified
-	auto new_stats = make_unique<SegmentStatistics>(new_column.Type());
-	this->row_groups = make_shared<SegmentTree>();
-	auto current_row_group = (RowGroup *)parent.row_groups->GetRootSegment();
-	while (current_row_group) {
-		auto new_row_group = current_row_group->AddColumn(context, new_column, executor, default_value, result);
-		// merge in the statistics
-		column_stats[new_column_idx]->stats->Merge(*new_row_group->GetStatistics(new_column_idx));
-
-		row_groups->AppendSegment(move(new_row_group));
-		current_row_group = (RowGroup *)current_row_group->next.get();
-	}
-
-	// also add this column to client local storage
-	transaction.storage.AddColumn(&parent, this, new_column, default_value);
-
-	// this table replaces the previous table, hence the parent is no longer the root DataTable
-	parent.is_root = false;
-}
-
-DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t removed_column)
-    : info(parent.info), db(parent.db), total_rows(parent.total_rows.load()), is_root(true) {
-	// prevent any new tuples from being added to the parent
-	lock_guard<mutex> parent_lock(parent.append_lock);
-
-	for (auto &column_def : parent.column_definitions) {
-		column_definitions.emplace_back(column_def.Copy());
-	}
-	// first check if there are any indexes that exist that point to the removed column
-	info->indexes.Scan([&](Index &index) {
-		for (auto &column_id : index.column_ids) {
-			if (column_id == removed_column) {
-				throw CatalogException("Cannot drop this column: an index depends on it!");
-			} else if (column_id > removed_column) {
-				throw CatalogException("Cannot drop this column: an index depends on a column after it!");
-			}
-		}
-		return false;
-	});
-
-	// erase the stats from this DataTable
-	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
-		if (i != removed_column) {
-			column_stats.push_back(parent.column_stats[i]);
-		}
-	}
-
-	// erase the column definitions from this DataTable
-	D_ASSERT(removed_column < column_definitions.size());
-	column_definitions.erase(column_definitions.begin() + removed_column);
-
-	storage_t storage_idx = 0;
-	for (idx_t i = 0; i < column_definitions.size(); i++) {
-		auto &col = column_definitions[i];
-		col.SetOid(i);
-		if (col.Generated()) {
-			continue;
-		}
-		col.SetStorageOid(storage_idx++);
-	}
-
-	// alter the row_groups and remove the column from each of them
-	this->row_groups = make_shared<SegmentTree>();
-	auto current_row_group = (RowGroup *)parent.row_groups->GetRootSegment();
-	while (current_row_group) {
-		auto new_row_group = current_row_group->RemoveColumn(removed_column);
-		row_groups->AppendSegment(move(new_row_group));
-		current_row_group = (RowGroup *)current_row_group->next.get();
-	}
-
-	// this table replaces the previous table, hence the parent is no longer the root DataTable
-	parent.is_root = false;
-}
-
-DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t changed_idx, const LogicalType &target_type,
-                     vector<column_t> bound_columns, Expression &cast_expr)
-    : info(parent.info), db(parent.db), total_rows(parent.total_rows.load()), is_root(true) {
-	// prevent any tuples from being added to the parent
-	lock_guard<mutex> lock(append_lock);
-	for (auto &column_def : parent.column_definitions) {
-		column_definitions.emplace_back(column_def.Copy());
-	}
-	// first check if there are any indexes that exist that point to the changed column
-	info->indexes.Scan([&](Index &index) {
-		for (auto &column_id : index.column_ids) {
-			if (column_id == changed_idx) {
-				throw CatalogException("Cannot change the type of this column: an index depends on it!");
-			}
-		}
-		return false;
-	});
-
-	// change the type in this DataTable
-	column_definitions[changed_idx].SetType(target_type);
-
-	// set up the statistics for the table
-	// the column that had its type changed will have the new statistics computed during conversion
-	for (idx_t i = 0; i < column_definitions.size(); i++) {
-		if (i == changed_idx) {
-			column_stats.push_back(ColumnStatistics::CreateEmptyStats(column_definitions[i].Type()));
-		} else {
-			column_stats.push_back(parent.column_stats[i]);
-		}
-	}
-
-	// scan the original table, and fill the new column with the transformed value
-	auto &transaction = Transaction::GetTransaction(context);
-
-	vector<LogicalType> scan_types;
-	for (idx_t i = 0; i < bound_columns.size(); i++) {
-		if (bound_columns[i] == COLUMN_IDENTIFIER_ROW_ID) {
-			scan_types.emplace_back(LogicalType::ROW_TYPE);
-		} else {
-			scan_types.push_back(parent.column_definitions[bound_columns[i]].Type());
-		}
-	}
-	auto &allocator = Allocator::Get(context);
-	DataChunk scan_chunk;
-	scan_chunk.Initialize(allocator, scan_types);
-
-	ExpressionExecutor executor(allocator);
-	executor.AddExpression(cast_expr);
-
-	TableScanState scan_state;
-	scan_state.column_ids = bound_columns;
-	scan_state.max_row = total_rows;
-
-	// now alter the type of the column within all of the row_groups individually
-	this->row_groups = make_shared<SegmentTree>();
-	auto current_row_group = (RowGroup *)parent.row_groups->GetRootSegment();
-	while (current_row_group) {
-		auto new_row_group =
-		    current_row_group->AlterType(context, target_type, changed_idx, executor, scan_state, scan_chunk);
-		column_stats[changed_idx]->stats->Merge(*new_row_group->GetStatistics(changed_idx));
-		row_groups->AppendSegment(move(new_row_group));
-		current_row_group = (RowGroup *)current_row_group->next.get();
-	}
-
-	transaction.storage.ChangeType(&parent, this, changed_idx, target_type, bound_columns, cast_expr);
-
-	// this table replaces the previous table, hence the parent is no longer the root DataTable
-	parent.is_root = false;
-}
-
-vector<LogicalType> DataTable::GetTypes() {
-	vector<LogicalType> types;
-	for (auto &it : column_definitions) {
-		types.push_back(it.Type());
-	}
-	return types;
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-void DataTable::InitializeScan(TableScanState &state, const vector<column_t> &column_ids,
-                               TableFilterSet *table_filters) {
-	// initialize a column scan state for each column
-	// initialize the chunk scan state
-	auto row_group = (RowGroup *)row_groups->GetRootSegment();
-	state.column_ids = column_ids;
-	state.max_row = total_rows;
-	state.table_filters = table_filters;
-	if (table_filters) {
-		D_ASSERT(!table_filters->filters.empty());
-		state.adaptive_filter = make_unique<AdaptiveFilter>(table_filters);
-	}
-	while (row_group && !row_group->InitializeScan(state.row_group_scan_state)) {
-		row_group = (RowGroup *)row_group->next.get();
-	}
-}
-
-void DataTable::InitializeScan(Transaction &transaction, TableScanState &state, const vector<column_t> &column_ids,
-                               TableFilterSet *table_filters) {
-	InitializeScan(state, column_ids, table_filters);
-	transaction.storage.InitializeScan(this, state.local_state, table_filters);
-}
-
-void DataTable::InitializeScanWithOffset(TableScanState &state, const vector<column_t> &column_ids, idx_t start_row,
-                                         idx_t end_row) {
-
-	auto row_group = (RowGroup *)row_groups->GetSegment(start_row);
-	state.column_ids = column_ids;
-	state.max_row = end_row;
-	state.table_filters = nullptr;
-	idx_t start_vector = (start_row - row_group->start) / STANDARD_VECTOR_SIZE;
-	if (!row_group->InitializeScanWithOffset(state.row_group_scan_state, start_vector)) {
-		throw InternalException("Failed to initialize row group scan with offset");
-	}
-}
-
-bool DataTable::InitializeScanInRowGroup(TableScanState &state, const vector<column_t> &column_ids,
-                                         TableFilterSet *table_filters, RowGroup *row_group, idx_t vector_index,
-                                         idx_t max_row) {
-	state.column_ids = column_ids;
-	state.max_row = max_row;
-	state.table_filters = table_filters;
-	if (table_filters) {
-		D_ASSERT(!table_filters->filters.empty());
-		state.adaptive_filter = make_unique<AdaptiveFilter>(table_filters);
-	}
-	return row_group->InitializeScanWithOffset(state.row_group_scan_state, vector_index);
-}
-
-idx_t DataTable::MaxThreads(ClientContext &context) {
-	idx_t parallel_scan_vector_count = RowGroup::ROW_GROUP_VECTOR_COUNT;
-	if (ClientConfig::GetConfig(context).verify_parallelism) {
-		parallel_scan_vector_count = 1;
-	}
-	idx_t parallel_scan_tuple_count = STANDARD_VECTOR_SIZE * parallel_scan_vector_count;
-
-	return total_rows / parallel_scan_tuple_count + 1;
-}
-
-void DataTable::InitializeParallelScan(ClientContext &context, ParallelTableScanState &state) {
-	state.current_row_group = (RowGroup *)row_groups->GetRootSegment();
-	state.transaction_local_data = false;
-	// figure out the max row we can scan for both the regular and the transaction-local storage
-	state.max_row = total_rows;
-	state.vector_index = 0;
-	state.local_state.max_index = 0;
-	auto &transaction = Transaction::GetTransaction(context);
-	transaction.storage.InitializeScan(this, state.local_state, nullptr);
-}
-
-bool DataTable::NextParallelScan(ClientContext &context, ParallelTableScanState &state, TableScanState &scan_state,
-                                 const vector<column_t> &column_ids) {
-	while (state.current_row_group) {
-		idx_t vector_index;
-		idx_t max_row;
-		if (ClientConfig::GetConfig(context).verify_parallelism) {
-			vector_index = state.vector_index;
-			max_row = state.current_row_group->start +
-			          MinValue<idx_t>(state.current_row_group->count,
-			                          STANDARD_VECTOR_SIZE * state.vector_index + STANDARD_VECTOR_SIZE);
-			D_ASSERT(vector_index * STANDARD_VECTOR_SIZE < state.current_row_group->count);
-		} else {
-			vector_index = 0;
-			max_row = state.current_row_group->start + state.current_row_group->count;
-		}
-		max_row = MinValue<idx_t>(max_row, state.max_row);
-		bool need_to_scan;
-		if (state.current_row_group->count == 0) {
-			need_to_scan = false;
-		} else {
-			need_to_scan = InitializeScanInRowGroup(scan_state, column_ids, scan_state.table_filters,
-			                                        state.current_row_group, vector_index, max_row);
-		}
-		if (ClientConfig::GetConfig(context).verify_parallelism) {
-			state.vector_index++;
-			if (state.vector_index * STANDARD_VECTOR_SIZE >= state.current_row_group->count) {
-				state.current_row_group = (RowGroup *)state.current_row_group->next.get();
-				state.vector_index = 0;
-			}
-		} else {
-			state.current_row_group = (RowGroup *)state.current_row_group->next.get();
-		}
-		if (!need_to_scan) {
-			// filters allow us to skip this row group: move to the next row group
-			continue;
-		}
-		return true;
-	}
-	if (!state.transaction_local_data) {
-		auto &transaction = Transaction::GetTransaction(context);
-		// create a task for scanning the local data
-		scan_state.row_group_scan_state.max_row = 0;
-		scan_state.max_row = 0;
-		transaction.storage.InitializeScan(this, scan_state.local_state, scan_state.table_filters);
-		scan_state.local_state.max_index = state.local_state.max_index;
-		scan_state.local_state.last_chunk_count = state.local_state.last_chunk_count;
-		state.transaction_local_data = true;
-		return true;
-	} else {
-		// finished all scans: no more scans remaining
-		return false;
-	}
-}
-
-void DataTable::Scan(Transaction &transaction, DataChunk &result, TableScanState &state, vector<column_t> &column_ids) {
-	// scan the persistent segments
-	if (ScanBaseTable(transaction, result, state)) {
-		D_ASSERT(result.size() > 0);
-		return;
-	}
-
-	// scan the transaction-local segments
-	transaction.storage.Scan(state.local_state, column_ids, result);
-}
-
-bool DataTable::ScanBaseTable(Transaction &transaction, DataChunk &result, TableScanState &state) {
-	auto current_row_group = state.row_group_scan_state.row_group;
-	while (current_row_group) {
-		current_row_group->Scan(transaction, state.row_group_scan_state, result);
-		if (result.size() > 0) {
-			return true;
-		} else {
-			do {
-				current_row_group = state.row_group_scan_state.row_group = (RowGroup *)current_row_group->next.get();
-				if (current_row_group) {
-					bool scan_row_group = current_row_group->InitializeScan(state.row_group_scan_state);
-					if (scan_row_group) {
-						// skip this row group
-						break;
-					}
-				}
-			} while (current_row_group);
-		}
-	}
-	return false;
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void DataTable::Fetch(Transaction &transaction, DataChunk &result, const vector<column_t> &column_ids,
-                      Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state) {
-	// figure out which row_group to fetch from
-	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
-	idx_t count = 0;
-	for (idx_t i = 0; i < fetch_count; i++) {
-		auto row_id = row_ids[i];
-		auto row_group = (RowGroup *)row_groups->GetSegment(row_id);
-		if (!row_group->Fetch(transaction, row_id - row_group->start)) {
-			continue;
-		}
-		row_group->FetchRow(transaction, state, column_ids, row_id, result, count);
-		count++;
-	}
-	result.SetCardinality(count);
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-static void VerifyNotNullConstraint(TableCatalogEntry &table, Vector &vector, idx_t count, const string &col_name) {
-	if (VectorOperations::HasNull(vector, count)) {
-		throw ConstraintException("NOT NULL constraint failed: %s.%s", table.name, col_name);
-	}
-}
-
-// To avoid throwing an error at SELECT, instead this moves the error detection to INSERT
-static void VerifyGeneratedExpressionSuccess(TableCatalogEntry &table, DataChunk &chunk, Expression &expr,
-                                             column_t index) {
-	auto &col = table.columns[index];
-	D_ASSERT(col.Generated());
-	ExpressionExecutor executor(Allocator::DefaultAllocator(), expr);
-	Vector result(col.Type());
-	try {
-		executor.ExecuteExpression(chunk, result);
-	} catch (std::exception &ex) {
-		throw ConstraintException("Incorrect %s value for generated column \"%s\"", col.Type().ToString(), col.Name());
-	}
-}
-
-static void VerifyCheckConstraint(TableCatalogEntry &table, Expression &expr, DataChunk &chunk) {
-	ExpressionExecutor executor(Allocator::DefaultAllocator(), expr);
-	Vector result(LogicalType::INTEGER);
-	try {
-		executor.ExecuteExpression(chunk, result);
-	} catch (std::exception &ex) {
-		throw ConstraintException("CHECK constraint failed: %s (Error: %s)", table.name, ex.what());
-	} catch (...) { // LCOV_EXCL_START
-		throw ConstraintException("CHECK constraint failed: %s (Unknown Error)", table.name);
-	} // LCOV_EXCL_STOP
-	VectorData vdata;
-	result.Orrify(chunk.size(), vdata);
-
-	auto dataptr = (int32_t *)vdata.data;
-	for (idx_t i = 0; i < chunk.size(); i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (vdata.validity.RowIsValid(idx) && dataptr[idx] == 0) {
-			throw ConstraintException("CHECK constraint failed: %s", table.name);
-		}
-	}
-}
-
-static bool IsForeignKeyIndex(const vector<idx_t> &fk_keys, Index &index, ForeignKeyType fk_type) {
-	if (fk_type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE ? !index.IsUnique() : !index.IsForeign()) {
-		return false;
-	}
-	if (fk_keys.size() != index.column_ids.size()) {
-		return false;
-	}
-	for (auto &fk_key : fk_keys) {
-		bool is_found = false;
-		for (auto &index_key : index.column_ids) {
-			if (fk_key == index_key) {
-				is_found = true;
-				break;
-			}
-		}
-		if (!is_found) {
-			return false;
-		}
-	}
-	return true;
-}
-
-Index *TableIndexList::FindForeignKeyIndex(const vector<idx_t> &fk_keys, ForeignKeyType fk_type) {
-	Index *result = nullptr;
-	Scan([&](Index &index) {
-		if (IsForeignKeyIndex(fk_keys, index, fk_type)) {
-			result = &index;
-		}
-		return false;
-	});
-	return result;
-}
-
-static void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context, DataChunk &chunk,
-                                       bool is_append) {
-	const vector<idx_t> *src_keys_ptr = &bfk.info.fk_keys;
-	const vector<idx_t> *dst_keys_ptr = &bfk.info.pk_keys;
-	if (!is_append) {
-		src_keys_ptr = &bfk.info.pk_keys;
-		dst_keys_ptr = &bfk.info.fk_keys;
-	}
-
-	auto table_entry_ptr =
-	    Catalog::GetCatalog(context).GetEntry<TableCatalogEntry>(context, bfk.info.schema, bfk.info.table);
-	if (table_entry_ptr == nullptr) {
-		throw InternalException("Can't find table \"%s\" in foreign key constraint", bfk.info.table);
-	}
-
-	// make the data chunk to check
-	vector<LogicalType> types;
-	for (idx_t i = 0; i < table_entry_ptr->columns.size(); i++) {
-		types.emplace_back(table_entry_ptr->columns[i].Type());
-	}
-	DataChunk dst_chunk;
-	dst_chunk.InitializeEmpty(types);
-	for (idx_t i = 0; i < src_keys_ptr->size(); i++) {
-		dst_chunk.data[(*dst_keys_ptr)[i]].Reference(chunk.data[(*src_keys_ptr)[i]]);
-	}
-	dst_chunk.SetCardinality(chunk.size());
-	auto data_table = table_entry_ptr->storage.get();
-
-	idx_t count = dst_chunk.size();
-	if (count <= 0) {
-		return;
-	}
-
-	// we need to look at the error messages concurrently in data table's index and transaction local storage's index
-	vector<string> err_msgs, tran_err_msgs;
-	err_msgs.resize(count);
-	tran_err_msgs.resize(count);
-
-	auto fk_type = is_append ? ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE : ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-	// check whether or not the chunk can be inserted or deleted into the referenced table' storage
-	auto index = data_table->info->indexes.FindForeignKeyIndex(*dst_keys_ptr, fk_type);
-	if (!index) {
-		throw InternalException("Internal Foreign Key error: could not find index to verify...");
-	}
-	if (is_append) {
-		index->VerifyAppendForeignKey(dst_chunk, err_msgs.data());
-	} else {
-		index->VerifyDeleteForeignKey(dst_chunk, err_msgs.data());
-	}
-	// check whether or not the chunk can be inserted or deleted into the referenced table' transaction local storage
-	auto &transaction = Transaction::GetTransaction(context);
-	bool transaction_check = transaction.storage.Find(data_table);
-	if (transaction_check) {
-		vector<unique_ptr<Index>> &transact_index_vec = transaction.storage.GetIndexes(data_table);
-		for (idx_t i = 0; i < transact_index_vec.size(); i++) {
-			if (IsForeignKeyIndex(*dst_keys_ptr, *transact_index_vec[i], fk_type)) {
-				if (is_append) {
-					transact_index_vec[i]->VerifyAppendForeignKey(dst_chunk, tran_err_msgs.data());
-				} else {
-					transact_index_vec[i]->VerifyDeleteForeignKey(dst_chunk, tran_err_msgs.data());
-				}
-			}
-		}
-	}
-
-	// we need to look at the error messages concurrently in data table's index and transaction local storage's index
-	for (idx_t i = 0; i < count; i++) {
-		if (!transaction_check) {
-			// if there is no transaction-local data we only need to check if there is an error message in the main
-			// index
-			if (!err_msgs[i].empty()) {
-				throw ConstraintException(err_msgs[i]);
-			} else {
-				continue;
-			}
-		}
-		if (is_append) {
-			// if we are appending we need to check to ensure the foreign key exists in either the transaction-local
-			// storage or the main table
-			if (!err_msgs[i].empty() && !tran_err_msgs[i].empty()) {
-				throw ConstraintException(err_msgs[i]);
-			} else {
-				continue;
-			}
-		}
-		// if we are deleting we need to ensure the foreign key DOES NOT exist in EITHER the transaction-local storage
-		// OR the main table
-		if (!err_msgs[i].empty() || !tran_err_msgs[i].empty()) {
-			string &err_msg = err_msgs[i];
-			if (err_msg.empty()) {
-				err_msg = tran_err_msgs[i];
-			}
-			throw ConstraintException(err_msg);
-		}
-	}
-}
-
-static void VerifyAppendForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-                                             DataChunk &chunk) {
-	VerifyForeignKeyConstraint(bfk, context, chunk, true);
-}
-
-static void VerifyDeleteForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context,
-                                             DataChunk &chunk) {
-	VerifyForeignKeyConstraint(bfk, context, chunk, false);
-}
-
-void DataTable::VerifyAppendConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk) {
-	auto binder = Binder::CreateBinder(context);
-	auto bound_columns = unordered_set<column_t>();
-	CheckBinder generated_check_binder(*binder, context, table.name, table.columns, bound_columns);
-	for (idx_t i = 0; i < table.columns.size(); i++) {
-		auto &col = table.columns[i];
-		if (!col.Generated()) {
-			continue;
-		}
-		D_ASSERT(col.Type().id() != LogicalTypeId::ANY);
-		generated_check_binder.target_type = col.Type();
-		auto to_be_bound_expression = col.GeneratedExpression().Copy();
-		auto bound_expression = generated_check_binder.Bind(to_be_bound_expression);
-		VerifyGeneratedExpressionSuccess(table, chunk, *bound_expression, i);
-	}
-	for (idx_t i = 0; i < table.bound_constraints.size(); i++) {
-		auto &base_constraint = table.constraints[i];
-		auto &constraint = table.bound_constraints[i];
-		switch (base_constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &not_null = *reinterpret_cast<BoundNotNullConstraint *>(constraint.get());
-			VerifyNotNullConstraint(table, chunk.data[not_null.index], chunk.size(),
-			                        table.columns[not_null.index].Name());
-			break;
-		}
-		case ConstraintType::CHECK: {
-			auto &check = *reinterpret_cast<BoundCheckConstraint *>(constraint.get());
-			VerifyCheckConstraint(table, *check.expression, chunk);
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			//! check whether or not the chunk can be inserted into the indexes
-			info->indexes.Scan([&](Index &index) {
-				index.VerifyAppend(chunk);
-				return false;
-			});
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = *reinterpret_cast<BoundForeignKeyConstraint *>(constraint.get());
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
-			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				VerifyAppendForeignKeyConstraint(bfk, context, chunk);
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("Constraint type not implemented!");
-		}
-	}
-}
-
-void DataTable::Append(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk) {
-	if (chunk.size() == 0) {
-		return;
-	}
-	// FIXME: could be an assertion instead?
-	if (chunk.ColumnCount() != table.StandardColumnCount()) {
-		throw InternalException("Mismatch in column count for append");
-	}
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: adding entries to a table that has been altered!");
-	}
-
-	chunk.Verify();
-
-	// verify any constraints on the new chunk
-	VerifyAppendConstraints(table, context, chunk);
-
-	// append to the transaction local data
-	auto &transaction = Transaction::GetTransaction(context);
-	transaction.storage.Append(this, chunk);
-}
-
-void DataTable::InitializeAppend(Transaction &transaction, TableAppendState &state, idx_t append_count) {
-	// obtain the append lock for this table
-	state.append_lock = unique_lock<mutex>(append_lock);
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: adding entries to a table that has been altered!");
-	}
-	state.row_start = total_rows;
-	state.current_row = state.row_start;
-	state.remaining_append_count = append_count;
-
-	// start writing to the row_groups
-	lock_guard<mutex> row_group_lock(row_groups->node_lock);
-	auto last_row_group = (RowGroup *)row_groups->GetLastSegment();
-	D_ASSERT(total_rows == last_row_group->start + last_row_group->count);
-	last_row_group->InitializeAppend(transaction, state.row_group_append_state, state.remaining_append_count);
-	total_rows += append_count;
-}
-
-void DataTable::Append(Transaction &transaction, DataChunk &chunk, TableAppendState &state) {
-	D_ASSERT(is_root);
-	D_ASSERT(chunk.ColumnCount() == column_definitions.size());
-	chunk.Verify();
-
-	idx_t append_count = chunk.size();
-	idx_t remaining = chunk.size();
-	while (true) {
-		auto current_row_group = state.row_group_append_state.row_group;
-		// check how much we can fit into the current row_group
-		idx_t append_count =
-		    MinValue<idx_t>(remaining, RowGroup::ROW_GROUP_SIZE - state.row_group_append_state.offset_in_row_group);
-		if (append_count > 0) {
-			current_row_group->Append(state.row_group_append_state, chunk, append_count);
-			// merge the stats
-			lock_guard<mutex> stats_guard(stats_lock);
-			for (idx_t i = 0; i < column_definitions.size(); i++) {
-				current_row_group->MergeIntoStatistics(i, *column_stats[i]->stats);
-			}
-		}
-		state.remaining_append_count -= append_count;
-		remaining -= append_count;
-		if (remaining > 0) {
-			// we expect max 1 iteration of this loop (i.e. a single chunk should never overflow more than one
-			// row_group)
-			D_ASSERT(chunk.size() == remaining + append_count);
-			// slice the input chunk
-			if (remaining < chunk.size()) {
-				SelectionVector sel(STANDARD_VECTOR_SIZE);
-				for (idx_t i = 0; i < remaining; i++) {
-					sel.set_index(i, append_count + i);
-				}
-				chunk.Slice(sel, remaining);
-			}
-			// append a new row_group
-			AppendRowGroup(current_row_group->start + current_row_group->count);
-			// set up the append state for this row_group
-			lock_guard<mutex> row_group_lock(row_groups->node_lock);
-			auto last_row_group = (RowGroup *)row_groups->GetLastSegment();
-			last_row_group->InitializeAppend(transaction, state.row_group_append_state, state.remaining_append_count);
-			continue;
-		} else {
-			break;
-		}
-	}
-	state.current_row += append_count;
-	for (idx_t col_idx = 0; col_idx < column_stats.size(); col_idx++) {
-		auto type = chunk.data[col_idx].GetType().InternalType();
-		if (type == PhysicalType::LIST || type == PhysicalType::STRUCT) {
-			continue;
-		}
-		column_stats[col_idx]->stats->UpdateDistinctStatistics(chunk.data[col_idx], chunk.size());
-	}
-}
-
-void DataTable::ScanTableSegment(idx_t row_start, idx_t count, const std::function<void(DataChunk &chunk)> &function) {
-	idx_t end = row_start + count;
-
-	vector<column_t> column_ids;
-	vector<LogicalType> types;
-	for (idx_t i = 0; i < this->column_definitions.size(); i++) {
-		auto &col = this->column_definitions[i];
-		column_ids.push_back(i);
-		types.push_back(col.Type());
-	}
-	DataChunk chunk;
-	chunk.Initialize(Allocator::Get(db), types);
-
-	CreateIndexScanState state;
-
-	idx_t row_start_aligned = row_start / STANDARD_VECTOR_SIZE * STANDARD_VECTOR_SIZE;
-	InitializeScanWithOffset(state, column_ids, row_start_aligned, row_start + count);
-
-	idx_t current_row = row_start_aligned;
-	while (current_row < end) {
-		ScanCreateIndex(state, chunk, TableScanType::TABLE_SCAN_COMMITTED_ROWS);
-		if (chunk.size() == 0) {
-			break;
-		}
-		idx_t end_row = current_row + chunk.size();
-		// figure out if we need to write the entire chunk or just part of it
-		idx_t chunk_start = MaxValue<idx_t>(current_row, row_start);
-		idx_t chunk_end = MinValue<idx_t>(end_row, end);
-		D_ASSERT(chunk_start < chunk_end);
-		idx_t chunk_count = chunk_end - chunk_start;
-		if (chunk_count != chunk.size()) {
-			// need to slice the chunk before insert
-			auto start_in_chunk = chunk_start % STANDARD_VECTOR_SIZE;
-			SelectionVector sel(start_in_chunk, chunk_count);
-			chunk.Slice(sel, chunk_count);
-			chunk.Verify();
-		}
-		function(chunk);
-		chunk.Reset();
-		current_row = end_row;
-	}
-}
-
-void DataTable::WriteToLog(WriteAheadLog &log, idx_t row_start, idx_t count) {
-	if (log.skip_writing) {
-		return;
-	}
-	log.WriteSetTable(info->schema, info->table);
-	ScanTableSegment(row_start, count, [&](DataChunk &chunk) { log.WriteInsert(chunk); });
-}
-
-void DataTable::CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count) {
-	lock_guard<mutex> lock(append_lock);
-
-	auto row_group = (RowGroup *)row_groups->GetSegment(row_start);
-	idx_t current_row = row_start;
-	idx_t remaining = count;
-	while (true) {
-		idx_t start_in_row_group = current_row - row_group->start;
-		idx_t append_count = MinValue<idx_t>(row_group->count - start_in_row_group, remaining);
-
-		row_group->CommitAppend(commit_id, start_in_row_group, append_count);
-
-		current_row += append_count;
-		remaining -= append_count;
-		if (remaining == 0) {
-			break;
-		}
-		row_group = (RowGroup *)row_group->next.get();
-	}
-	info->cardinality += count;
-}
-
-void DataTable::RevertAppendInternal(idx_t start_row, idx_t count) {
-	if (count == 0) {
-		// nothing to revert!
-		return;
-	}
-	if (total_rows != start_row + count) {
-		// interleaved append: don't do anything
-		// in this case the rows will stay as "inserted by transaction X", but will never be committed
-		// they will never be used by any other transaction and will essentially leave a gap
-		// this situation is rare, and as such we don't care about optimizing it (yet?)
-		// it only happens if C1 appends a lot of data -> C2 appends a lot of data -> C1 rolls back
-		return;
-	}
-	// adjust the cardinality
-	info->cardinality = start_row;
-	total_rows = start_row;
-	D_ASSERT(is_root);
-	// revert appends made to row_groups
-	lock_guard<mutex> tree_lock(row_groups->node_lock);
-	// find the segment index that the current row belongs to
-	idx_t segment_index = row_groups->GetSegmentIndex(start_row);
-	auto segment = row_groups->nodes[segment_index].node;
-	auto &info = (RowGroup &)*segment;
-
-	// remove any segments AFTER this segment: they should be deleted entirely
-	if (segment_index < row_groups->nodes.size() - 1) {
-		row_groups->nodes.erase(row_groups->nodes.begin() + segment_index + 1, row_groups->nodes.end());
-	}
-	info.next = nullptr;
-	info.RevertAppend(start_row);
-}
-
-void DataTable::RevertAppend(idx_t start_row, idx_t count) {
-	lock_guard<mutex> lock(append_lock);
-
-	if (!info->indexes.Empty()) {
-		idx_t current_row_base = start_row;
-		row_t row_data[STANDARD_VECTOR_SIZE];
-		Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_data);
-		ScanTableSegment(start_row, count, [&](DataChunk &chunk) {
-			for (idx_t i = 0; i < chunk.size(); i++) {
-				row_data[i] = current_row_base + i;
-			}
-			info->indexes.Scan([&](Index &index) {
-				index.Delete(chunk, row_identifiers);
-				return false;
-			});
-			current_row_base += chunk.size();
-		});
-	}
-	RevertAppendInternal(start_row, count);
-}
-
-//===--------------------------------------------------------------------===//
-// Indexes
-//===--------------------------------------------------------------------===//
-bool DataTable::AppendToIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start) {
-	D_ASSERT(is_root);
-	if (info->indexes.Empty()) {
-		return true;
-	}
-	// first generate the vector of row identifiers
-	Vector row_identifiers(LogicalType::ROW_TYPE);
-	VectorOperations::GenerateSequence(row_identifiers, chunk.size(), row_start, 1);
-
-	vector<Index *> already_appended;
-	bool append_failed = false;
-	// now append the entries to the indices
-	info->indexes.Scan([&](Index &index) {
-		if (!index.Append(chunk, row_identifiers)) {
-			append_failed = true;
-			return true;
-		}
-		already_appended.push_back(&index);
-		return false;
-	});
-
-	if (append_failed) {
-		// constraint violation!
-		// remove any appended entries from previous indexes (if any)
-
-		for (auto *index : already_appended) {
-			index->Delete(chunk, row_identifiers);
-		}
-
-		return false;
-	}
-	return true;
-}
-
-void DataTable::RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start) {
-	D_ASSERT(is_root);
-	if (info->indexes.Empty()) {
-		return;
-	}
-	// first generate the vector of row identifiers
-	Vector row_identifiers(LogicalType::ROW_TYPE);
-	VectorOperations::GenerateSequence(row_identifiers, chunk.size(), row_start, 1);
-
-	// now remove the entries from the indices
-	RemoveFromIndexes(state, chunk, row_identifiers);
-}
-
-void DataTable::RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, Vector &row_identifiers) {
-	D_ASSERT(is_root);
-	info->indexes.Scan([&](Index &index) {
-		index.Delete(chunk, row_identifiers);
-		return false;
-	});
-}
-
-void DataTable::RemoveFromIndexes(Vector &row_identifiers, idx_t count) {
-	D_ASSERT(is_root);
-	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
-
-	// figure out which row_group to fetch from
-	auto row_group = (RowGroup *)row_groups->GetSegment(row_ids[0]);
-	auto row_group_vector_idx = (row_ids[0] - row_group->start) / STANDARD_VECTOR_SIZE;
-	auto base_row_id = row_group_vector_idx * STANDARD_VECTOR_SIZE + row_group->start;
-
-	// create a selection vector from the row_ids
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < count; i++) {
-		auto row_in_vector = row_ids[i] - base_row_id;
-		D_ASSERT(row_in_vector < STANDARD_VECTOR_SIZE);
-		sel.set_index(i, row_in_vector);
-	}
-
-	// now fetch the columns from that row_group
-	// FIXME: we do not need to fetch all columns, only the columns required by the indices!
-	TableScanState state;
-	state.max_row = total_rows;
-	auto types = GetTypes();
-	for (idx_t i = 0; i < types.size(); i++) {
-		state.column_ids.push_back(i);
-	}
-	DataChunk result;
-	result.Initialize(Allocator::Get(db), types);
-
-	row_group->InitializeScanWithOffset(state.row_group_scan_state, row_group_vector_idx);
-	row_group->ScanCommitted(state.row_group_scan_state, result,
-	                         TableScanType::TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES);
-	result.Slice(sel, count);
-
-	info->indexes.Scan([&](Index &index) {
-		index.Delete(result, row_identifiers);
-		return false;
-	});
-}
-
-void DataTable::VerifyDeleteConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk) {
-	for (auto &constraint : table.bound_constraints) {
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL:
-		case ConstraintType::CHECK:
-		case ConstraintType::UNIQUE:
-			break;
-		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = *reinterpret_cast<BoundForeignKeyConstraint *>(constraint.get());
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE ||
-			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				VerifyDeleteForeignKeyConstraint(bfk, context, chunk);
-			}
-			break;
-		}
-		default:
-			throw NotImplementedException("Constraint type not implemented!");
-		}
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Delete
-//===--------------------------------------------------------------------===//
-idx_t DataTable::Delete(TableCatalogEntry &table, ClientContext &context, Vector &row_identifiers, idx_t count) {
-	D_ASSERT(row_identifiers.GetType().InternalType() == ROW_TYPE);
-	if (count == 0) {
-		return 0;
-	}
-
-	auto &transaction = Transaction::GetTransaction(context);
-
-	row_identifiers.Normalify(count);
-	auto ids = FlatVector::GetData<row_t>(row_identifiers);
-	auto first_id = ids[0];
-
-	// verify any constraints on the delete rows
-	DataChunk verify_chunk;
-	if (first_id >= MAX_ROW_ID) {
-		transaction.storage.FetchChunk(this, row_identifiers, count, verify_chunk);
-	} else {
-		ColumnFetchState fetch_state;
-		vector<column_t> col_ids;
-		vector<LogicalType> types;
-		for (idx_t i = 0; i < column_definitions.size(); i++) {
-			col_ids.push_back(column_definitions[i].StorageOid());
-			types.emplace_back(column_definitions[i].Type());
-		}
-		verify_chunk.Initialize(Allocator::Get(context), types);
-		Fetch(transaction, verify_chunk, col_ids, row_identifiers, count, fetch_state);
-	}
-	VerifyDeleteConstraints(table, context, verify_chunk);
-
-	if (first_id >= MAX_ROW_ID) {
-		// deletion is in transaction-local storage: push delete into local chunk collection
-		return transaction.storage.Delete(this, row_identifiers, count);
-	} else {
-		idx_t delete_count = 0;
-		// delete is in the row groups
-		// we need to figure out for each id to which row group it belongs
-		// usually all (or many) ids belong to the same row group
-		// we iterate over the ids and check for every id if it belongs to the same row group as their predecessor
-		idx_t pos = 0;
-		do {
-			idx_t start = pos;
-			auto row_group = (RowGroup *)row_groups->GetSegment(ids[pos]);
-			for (pos++; pos < count; pos++) {
-				D_ASSERT(ids[pos] >= 0);
-				// check if this id still belongs to this row group
-				if (idx_t(ids[pos]) < row_group->start) {
-					// id is before row_group start -> it does not
-					break;
-				}
-				if (idx_t(ids[pos]) >= row_group->start + row_group->count) {
-					// id is after row group end -> it does not
-					break;
-				}
-			}
-			delete_count += row_group->Delete(transaction, this, ids + start, pos - start);
-		} while (pos < count);
-		return delete_count;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Update
-//===--------------------------------------------------------------------===//
-static void CreateMockChunk(vector<LogicalType> &types, const vector<column_t> &column_ids, DataChunk &chunk,
-                            DataChunk &mock_chunk) {
-	// construct a mock DataChunk
-	mock_chunk.InitializeEmpty(types);
-	for (column_t i = 0; i < column_ids.size(); i++) {
-		mock_chunk.data[column_ids[i]].Reference(chunk.data[i]);
-	}
-	mock_chunk.SetCardinality(chunk.size());
-}
-
-static bool CreateMockChunk(TableCatalogEntry &table, const vector<column_t> &column_ids,
-                            unordered_set<column_t> &desired_column_ids, DataChunk &chunk, DataChunk &mock_chunk) {
-	idx_t found_columns = 0;
-	// check whether the desired columns are present in the UPDATE clause
-	for (column_t i = 0; i < column_ids.size(); i++) {
-		if (desired_column_ids.find(column_ids[i]) != desired_column_ids.end()) {
-			found_columns++;
-		}
-	}
-	if (found_columns == 0) {
-		// no columns were found: no need to check the constraint again
-		return false;
-	}
-	if (found_columns != desired_column_ids.size()) {
-		// FIXME: not all columns in UPDATE clause are present!
-		// this should not be triggered at all as the binder should add these columns
-		throw InternalException("Not all columns required for the CHECK constraint are present in the UPDATED chunk!");
-	}
-	// construct a mock DataChunk
-	auto types = table.GetTypes();
-	CreateMockChunk(types, column_ids, chunk, mock_chunk);
-	return true;
-}
-
-void DataTable::VerifyUpdateConstraints(TableCatalogEntry &table, DataChunk &chunk,
-                                        const vector<column_t> &column_ids) {
-	for (auto &constraint : table.bound_constraints) {
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &not_null = *reinterpret_cast<BoundNotNullConstraint *>(constraint.get());
-			// check if the constraint is in the list of column_ids
-			for (idx_t i = 0; i < column_ids.size(); i++) {
-				if (column_ids[i] == not_null.index) {
-					// found the column id: check the data in
-					VerifyNotNullConstraint(table, chunk.data[i], chunk.size(), table.columns[not_null.index].Name());
-					break;
-				}
-			}
-			break;
-		}
-		case ConstraintType::CHECK: {
-			auto &check = *reinterpret_cast<BoundCheckConstraint *>(constraint.get());
-
-			DataChunk mock_chunk;
-			if (CreateMockChunk(table, column_ids, check.bound_columns, chunk, mock_chunk)) {
-				VerifyCheckConstraint(table, *check.expression, mock_chunk);
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE:
-		case ConstraintType::FOREIGN_KEY:
-			break;
-		default:
-			throw NotImplementedException("Constraint type not implemented!");
-		}
-	}
-	// update should not be called for indexed columns!
-	// instead update should have been rewritten to delete + update on higher layer
-#ifdef DEBUG
-	info->indexes.Scan([&](Index &index) {
-		D_ASSERT(!index.IndexIsUpdated(column_ids));
-		return false;
-	});
-
-#endif
-}
-
-void DataTable::Update(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
-                       const vector<column_t> &column_ids, DataChunk &updates) {
-	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-
-	auto count = updates.size();
-	updates.Verify();
-	if (count == 0) {
-		return;
-	}
-
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: cannot update a table that has been altered!");
-	}
-
-	// first verify that no constraints are violated
-	VerifyUpdateConstraints(table, updates, column_ids);
-
-	// now perform the actual update
-	auto &transaction = Transaction::GetTransaction(context);
-
-	updates.Normalify();
-	row_ids.Normalify(count);
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-	auto first_id = FlatVector::GetValue<row_t>(row_ids, 0);
-	if (first_id >= MAX_ROW_ID) {
-		// update is in transaction-local storage: push update into local storage
-		transaction.storage.Update(this, row_ids, column_ids, updates);
-		return;
-	}
-
-	// update is in the row groups
-	// we need to figure out for each id to which row group it belongs
-	// usually all (or many) ids belong to the same row group
-	// we iterate over the ids and check for every id if it belongs to the same row group as their predecessor
-	idx_t pos = 0;
-	do {
-		idx_t start = pos;
-		auto row_group = (RowGroup *)row_groups->GetSegment(ids[pos]);
-		row_t base_id =
-		    row_group->start + ((ids[pos] - row_group->start) / STANDARD_VECTOR_SIZE * STANDARD_VECTOR_SIZE);
-		for (pos++; pos < count; pos++) {
-			D_ASSERT(ids[pos] >= 0);
-			// check if this id still belongs to this vector
-			if (ids[pos] < base_id) {
-				// id is before vector start -> it does not
-				break;
-			}
-			if (ids[pos] >= base_id + STANDARD_VECTOR_SIZE) {
-				// id is after vector end -> it does not
-				break;
-			}
-		}
-		row_group->Update(transaction, updates, ids, start, pos - start, column_ids);
-
-		lock_guard<mutex> stats_guard(stats_lock);
-		for (idx_t i = 0; i < column_ids.size(); i++) {
-			auto column_id = column_ids[i];
-			column_stats[column_id]->stats->Merge(*row_group->GetStatistics(column_id));
-		}
-	} while (pos < count);
-}
-
-void DataTable::UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
-                             const vector<column_t> &column_path, DataChunk &updates) {
-	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-	D_ASSERT(updates.ColumnCount() == 1);
-	updates.Verify();
-	if (updates.size() == 0) {
-		return;
-	}
-
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: cannot update a table that has been altered!");
-	}
-
-	// now perform the actual update
-	auto &transaction = Transaction::GetTransaction(context);
-
-	updates.Normalify();
-	row_ids.Normalify(updates.size());
-	auto first_id = FlatVector::GetValue<row_t>(row_ids, 0);
-	if (first_id >= MAX_ROW_ID) {
-		throw NotImplementedException("Cannot update a column-path on transaction local data");
-	}
-	// find the row_group this id belongs to
-	auto primary_column_idx = column_path[0];
-	auto row_group = (RowGroup *)row_groups->GetSegment(first_id);
-	row_group->UpdateColumn(transaction, updates, row_ids, column_path);
-
-	lock_guard<mutex> stats_guard(stats_lock);
-	column_stats[primary_column_idx]->stats->Merge(*row_group->GetStatistics(primary_column_idx));
-}
-
-//===--------------------------------------------------------------------===//
-// Create Index Scan
-//===--------------------------------------------------------------------===//
-void DataTable::InitializeCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids) {
-	// we grab the append lock to make sure nothing is appended until AFTER we finish the index scan
-	state.append_lock = std::unique_lock<mutex>(append_lock);
-	state.delete_lock = std::unique_lock<mutex>(row_groups->node_lock);
-
-	InitializeScan(state, column_ids);
-}
-
-bool DataTable::ScanCreateIndex(CreateIndexScanState &state, DataChunk &result, TableScanType type) {
-	auto current_row_group = state.row_group_scan_state.row_group;
-	while (current_row_group) {
-		current_row_group->ScanCommitted(state.row_group_scan_state, result, type);
-		if (result.size() > 0) {
-			return true;
-		} else {
-			current_row_group = state.row_group_scan_state.row_group = (RowGroup *)current_row_group->next.get();
-			if (current_row_group) {
-				current_row_group->InitializeScan(state.row_group_scan_state);
-			}
-		}
-	}
-	return false;
-}
-
-void DataTable::AddIndex(unique_ptr<Index> index, const vector<unique_ptr<Expression>> &expressions) {
-	auto &allocator = Allocator::Get(db);
-
-	DataChunk result;
-	result.Initialize(allocator, index->logical_types);
-
-	DataChunk intermediate;
-	vector<LogicalType> intermediate_types;
-	auto column_ids = index->column_ids;
-	column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-	for (auto &id : index->column_ids) {
-		auto &col = column_definitions[id];
-		intermediate_types.push_back(col.Type());
-	}
-	intermediate_types.emplace_back(LogicalType::ROW_TYPE);
-	intermediate.Initialize(allocator, intermediate_types);
-
-	// initialize an index scan
-	CreateIndexScanState state;
-	InitializeCreateIndexScan(state, column_ids);
-
-	if (!is_root) {
-		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
-	}
-
-	// now start incrementally building the index
-	{
-		IndexLock lock;
-		index->InitializeLock(lock);
-		ExpressionExecutor executor(allocator, expressions);
-		while (true) {
-			intermediate.Reset();
-			// scan a new chunk from the table to index
-			ScanCreateIndex(state, intermediate, TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED);
-			if (intermediate.size() == 0) {
-				// finished scanning for index creation
-				// release all locks
-				break;
-			}
-			// resolve the expressions for this chunk
-			executor.Execute(intermediate, result);
-
-			// insert into the index
-			if (!index->Insert(lock, result, intermediate.data[intermediate.ColumnCount() - 1])) {
-				throw ConstraintException(
-				    "Cant create unique index, table contains duplicate data on indexed column(s)");
-			}
-		}
-	}
-	info->indexes.AddIndex(move(index));
-}
-
-unique_ptr<BaseStatistics> DataTable::GetStatistics(ClientContext &context, column_t column_id) {
-	if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
-		return nullptr;
-	}
-	lock_guard<mutex> stats_guard(stats_lock);
-	return column_stats[column_id]->stats->Copy();
-}
-
-//===--------------------------------------------------------------------===//
-// Checkpoint
-//===--------------------------------------------------------------------===//
-BlockPointer DataTable::Checkpoint(TableDataWriter &writer) {
-	// checkpoint each individual row group
-	// FIXME: we might want to combine adjacent row groups in case they have had deletions...
-	vector<unique_ptr<BaseStatistics>> global_stats;
-	for (idx_t i = 0; i < column_definitions.size(); i++) {
-		global_stats.push_back(column_stats[i]->stats->Copy());
-	}
-
-	auto row_group = (RowGroup *)row_groups->GetRootSegment();
-	vector<RowGroupPointer> row_group_pointers;
-	while (row_group) {
-		auto pointer = row_group->Checkpoint(writer, global_stats);
-		row_group_pointers.push_back(move(pointer));
-		row_group = (RowGroup *)row_group->next.get();
-	}
-	// store the current position in the metadata writer
-	// this is where the row groups for this table start
-	auto &meta_writer = writer.GetMetaWriter();
-	auto pointer = meta_writer.GetBlockPointer();
-
-	for (auto &stats : global_stats) {
-		stats->Serialize(meta_writer);
-	}
-	// now start writing the row group pointers to disk
-	meta_writer.Write<uint64_t>(row_group_pointers.size());
-	for (auto &row_group_pointer : row_group_pointers) {
-		RowGroup::Serialize(row_group_pointer, meta_writer);
-	}
-	return pointer;
-}
-
-void DataTable::CommitDropColumn(idx_t index) {
-	auto segment = (RowGroup *)row_groups->GetRootSegment();
-	while (segment) {
-		segment->CommitDropColumn(index);
-		segment = (RowGroup *)segment->next.get();
-	}
-}
-
-idx_t DataTable::GetTotalRows() {
-	return total_rows;
-}
-
-void DataTable::CommitDropTable() {
-	// commit a drop of this table: mark all blocks as modified so they can be reclaimed later on
-	auto segment = (RowGroup *)row_groups->GetRootSegment();
-	while (segment) {
-		segment->CommitDrop();
-		segment = (RowGroup *)segment->next.get();
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// GetStorageInfo
-//===--------------------------------------------------------------------===//
-vector<vector<Value>> DataTable::GetStorageInfo() {
-	vector<vector<Value>> result;
-
-	auto row_group = (RowGroup *)row_groups->GetRootSegment();
-	idx_t row_group_index = 0;
-	while (row_group) {
-		row_group->GetStorageInfo(row_group_index, result);
-		row_group_index++;
-
-		row_group = (RowGroup *)row_group->next.get();
-	}
-
-	return result;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-Index::Index(IndexType type, const vector<column_t> &column_ids_p,
-             const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type_p)
-    : type(type), column_ids(column_ids_p), constraint_type(constraint_type_p),
-      executor(Allocator::DefaultAllocator()) {
-	for (auto &expr : unbound_expressions) {
-		types.push_back(expr->return_type.InternalType());
-		logical_types.push_back(expr->return_type);
-		auto unbound_expression = expr->Copy();
-		bound_expressions.push_back(BindExpression(unbound_expression->Copy()));
-		this->unbound_expressions.emplace_back(move(unbound_expression));
-	}
-	for (auto &bound_expr : bound_expressions) {
-		executor.AddExpression(*bound_expr);
-	}
-	for (auto column_id : column_ids) {
-		column_id_set.insert(column_id);
-	}
-}
-
-void Index::InitializeLock(IndexLock &state) {
-	state.index_lock = unique_lock<mutex>(lock);
-}
-
-bool Index::Append(DataChunk &entries, Vector &row_identifiers) {
-	IndexLock state;
-	InitializeLock(state);
-	return Append(state, entries, row_identifiers);
-}
-
-void Index::Delete(DataChunk &entries, Vector &row_identifiers) {
-	IndexLock state;
-	InitializeLock(state);
-	Delete(state, entries, row_identifiers);
-}
-
-void Index::ExecuteExpressions(DataChunk &input, DataChunk &result) {
-	executor.Execute(input, result);
-}
-
-unique_ptr<Expression> Index::BindExpression(unique_ptr<Expression> expr) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)*expr;
-		return make_unique<BoundReferenceExpression>(expr->return_type, column_ids[bound_colref.binding.column_index]);
-	}
-	ExpressionIterator::EnumerateChildren(*expr,
-	                                      [&](unique_ptr<Expression> &expr) { expr = BindExpression(move(expr)); });
-	return expr;
-}
-
-bool Index::IndexIsUpdated(const vector<column_t> &column_ids) const {
-	for (auto &column : column_ids) {
-		if (column_id_set.find(column) != column_id_set.end()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-LocalTableStorage::LocalTableStorage(DataTable &table)
-    : table(table), allocator(Allocator::Get(table.db)), collection(allocator), active_scans(0) {
-	Clear();
-}
-
-LocalTableStorage::~LocalTableStorage() {
-}
-
-void LocalTableStorage::InitializeScan(LocalScanState &state, TableFilterSet *table_filters) {
-	state.table_filters = table_filters;
-	state.chunk_index = 0;
-	if (collection.ChunkCount() == 0) {
-		// nothing to scan
-		state.max_index = 0;
-		state.last_chunk_count = 0;
-		return;
-	}
-	state.SetStorage(shared_from_this());
-
-	state.max_index = collection.ChunkCount() - 1;
-	state.last_chunk_count = collection.Chunks().back()->size();
-}
-
-idx_t LocalTableStorage::EstimatedSize() {
-	idx_t appended_rows = collection.Count() - deleted_rows;
-	if (appended_rows == 0) {
-		return 0;
-	}
-	idx_t row_size = 0;
-	for (auto &type : collection.Types()) {
-		row_size += GetTypeIdSize(type.InternalType());
-	}
-	return appended_rows * row_size;
-}
-
-LocalScanState::~LocalScanState() {
-	SetStorage(nullptr);
-}
-
-void LocalScanState::SetStorage(shared_ptr<LocalTableStorage> new_storage) {
-	if (storage) {
-		D_ASSERT(storage->active_scans > 0);
-		storage->active_scans--;
-	}
-	storage = move(new_storage);
-	if (storage) {
-		storage->active_scans++;
-	}
-}
-
-void LocalTableStorage::Clear() {
-	collection.Reset();
-	deleted_entries.clear();
-	indexes.clear();
-	deleted_rows = 0;
-	table.info->indexes.Scan([&](Index &index) {
-		D_ASSERT(index.type == IndexType::ART);
-		auto &art = (ART &)index;
-		if (art.constraint_type != IndexConstraintType::NONE) {
-			// unique index: create a local ART index that maintains the same unique constraint
-			vector<unique_ptr<Expression>> unbound_expressions;
-			for (auto &expr : art.unbound_expressions) {
-				unbound_expressions.push_back(expr->Copy());
-			}
-			indexes.push_back(make_unique<ART>(art.column_ids, move(unbound_expressions), art.constraint_type));
-		}
-		return false;
-	});
-}
-
-void LocalStorage::InitializeScan(DataTable *table, LocalScanState &state, TableFilterSet *table_filters) {
-	auto entry = table_storage.find(table);
-	if (entry == table_storage.end()) {
-		// no local storage for table: set scan to nullptr
-		state.SetStorage(nullptr);
-		return;
-	}
-	auto storage = entry->second.get();
-	storage->InitializeScan(state, table_filters);
-}
-
-void LocalStorage::Scan(LocalScanState &state, const vector<column_t> &column_ids, DataChunk &result) {
-	auto storage = state.GetStorage();
-	if (!storage || state.chunk_index > state.max_index) {
-		// nothing left to scan
-		result.Reset();
-		return;
-	}
-	auto &chunk = storage->collection.GetChunk(state.chunk_index);
-	idx_t chunk_count = state.chunk_index == state.max_index ? state.last_chunk_count : chunk.size();
-	idx_t count = chunk_count;
-
-	// first create a selection vector from the deleted entries (if any)
-	SelectionVector valid_sel(STANDARD_VECTOR_SIZE);
-	auto entry = storage->deleted_entries.find(state.chunk_index);
-	if (entry != storage->deleted_entries.end()) {
-		// deleted entries! create a selection vector
-		auto deleted = entry->second.get();
-		idx_t new_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			if (!deleted[i]) {
-				valid_sel.set_index(new_count++, i);
-			}
-		}
-		if (new_count == 0 && count > 0) {
-			// all entries in this chunk were deleted: continue to next chunk
-			state.chunk_index++;
-			Scan(state, column_ids, result);
-			return;
-		}
-		count = new_count;
-	}
-
-	SelectionVector sel;
-	if (count != chunk_count) {
-		sel.Initialize(valid_sel);
-	} else {
-		sel.Initialize(nullptr);
-	}
-	// now scan the vectors of the chunk
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto id = column_ids[i];
-		if (id == COLUMN_IDENTIFIER_ROW_ID) {
-			// row identifier: return a sequence of rowids starting from MAX_ROW_ID plus the row offset in the chunk
-			result.data[i].Sequence(MAX_ROW_ID + state.chunk_index * STANDARD_VECTOR_SIZE, 1);
-		} else {
-			result.data[i].Reference(chunk.data[id]);
-		}
-		idx_t approved_tuple_count = count;
-		if (state.table_filters) {
-			auto column_filters = state.table_filters->filters.find(i);
-			if (column_filters != state.table_filters->filters.end()) {
-				//! We have filters to apply here
-				auto &mask = FlatVector::Validity(result.data[i]);
-				ColumnSegment::FilterSelection(sel, result.data[i], *column_filters->second, approved_tuple_count,
-				                               mask);
-				count = approved_tuple_count;
-			}
-		}
-	}
-	if (count == 0) {
-		// all entries in this chunk were filtered:: Continue on next chunk
-		state.chunk_index++;
-		Scan(state, column_ids, result);
-		return;
-	}
-	if (count == chunk_count) {
-		result.SetCardinality(count);
-	} else {
-		result.Slice(sel, count);
-	}
-	state.chunk_index++;
-}
-
-void LocalStorage::Append(DataTable *table, DataChunk &chunk) {
-	auto entry = table_storage.find(table);
-	LocalTableStorage *storage;
-	if (entry == table_storage.end()) {
-		auto new_storage = make_shared<LocalTableStorage>(*table);
-		storage = new_storage.get();
-		table_storage.insert(make_pair(table, move(new_storage)));
-	} else {
-		storage = entry->second.get();
-	}
-	// append to unique indices (if any)
-	if (!storage->indexes.empty()) {
-		idx_t base_id = MAX_ROW_ID + storage->collection.Count();
-
-		// first generate the vector of row identifiers
-		Vector row_ids(LogicalType::ROW_TYPE);
-		VectorOperations::GenerateSequence(row_ids, chunk.size(), base_id, 1);
-
-		// now append the entries to the indices
-		for (auto &index : storage->indexes) {
-			if (!index->Append(chunk, row_ids)) {
-				throw ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicated key");
-			}
-		}
-	}
-	//! Append to the chunk
-	storage->collection.Append(chunk);
-	if (storage->active_scans == 0 && storage->collection.Count() >= RowGroup::ROW_GROUP_SIZE * 2) {
-		// flush to base storage
-		Flush(*table, *storage);
-	}
-}
-
-LocalTableStorage *LocalStorage::GetStorage(DataTable *table) {
-	auto entry = table_storage.find(table);
-	D_ASSERT(entry != table_storage.end());
-	return entry->second.get();
-}
-
-idx_t LocalStorage::EstimatedSize() {
-	idx_t estimated_size = 0;
-	for (auto &storage : table_storage) {
-		estimated_size += storage.second->EstimatedSize();
-	}
-	return estimated_size;
-}
-
-static idx_t GetChunk(Vector &row_ids) {
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-	auto first_id = ids[0] - MAX_ROW_ID;
-
-	return first_id / STANDARD_VECTOR_SIZE;
-}
-
-idx_t LocalStorage::Delete(DataTable *table, Vector &row_ids, idx_t count) {
-	auto storage = GetStorage(table);
-	// figure out the chunk from which these row ids came
-	idx_t chunk_idx = GetChunk(row_ids);
-	D_ASSERT(chunk_idx < storage->collection.ChunkCount());
-
-	// delete from unique indices (if any)
-	if (!storage->indexes.empty()) {
-		// Index::Delete assumes that ALL rows are being deleted, so
-		// Slice out the rows that are being deleted from the storage Chunk
-		auto &chunk = storage->collection.GetChunk(chunk_idx);
-
-		VectorData row_ids_data;
-		row_ids.Orrify(count, row_ids_data);
-		auto row_identifiers = (const row_t *)row_ids_data.data;
-		SelectionVector sel(count);
-		for (idx_t i = 0; i < count; ++i) {
-			const auto idx = row_ids_data.sel->get_index(i);
-			sel.set_index(i, row_identifiers[idx] - MAX_ROW_ID);
-		}
-
-		DataChunk deleted;
-		deleted.InitializeEmpty(chunk.GetTypes());
-		deleted.Slice(chunk, sel, count);
-		for (auto &index : storage->indexes) {
-			index->Delete(deleted, row_ids);
-		}
-	}
-
-	// get a pointer to the deleted entries for this chunk
-	bool *deleted;
-	auto entry = storage->deleted_entries.find(chunk_idx);
-	if (entry == storage->deleted_entries.end()) {
-		// nothing deleted yet, add the deleted entries
-		auto del_entries = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
-		memset(del_entries.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
-		deleted = del_entries.get();
-		storage->deleted_entries.insert(make_pair(chunk_idx, move(del_entries)));
-	} else {
-		deleted = entry->second.get();
-	}
-
-	// now actually mark the entries as deleted in the deleted vector
-	idx_t base_index = MAX_ROW_ID + chunk_idx * STANDARD_VECTOR_SIZE;
-
-	idx_t deleted_count = 0;
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-	for (idx_t i = 0; i < count; i++) {
-		auto id = ids[i] - base_index;
-		if (!deleted[id]) {
-			deleted_count++;
-		}
-		deleted[id] = true;
-	}
-	storage->deleted_rows += deleted_count;
-	return deleted_count;
-}
-
-template <class T>
-static void TemplatedUpdateLoop(Vector &data_vector, Vector &update_vector, Vector &row_ids, idx_t count,
-                                idx_t base_index) {
-	VectorData udata;
-	update_vector.Orrify(count, udata);
-
-	auto target = FlatVector::GetData<T>(data_vector);
-	auto &mask = FlatVector::Validity(data_vector);
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-	auto updates = (T *)udata.data;
-
-	for (idx_t i = 0; i < count; i++) {
-		auto uidx = udata.sel->get_index(i);
-
-		auto id = ids[i] - base_index;
-		target[id] = updates[uidx];
-		mask.Set(id, udata.validity.RowIsValid(uidx));
-	}
-}
-
-static void UpdateChunk(Vector &data, Vector &updates, Vector &row_ids, idx_t count, idx_t base_index) {
-	D_ASSERT(data.GetType() == updates.GetType());
-	D_ASSERT(row_ids.GetType() == LogicalType::ROW_TYPE);
-
-	switch (data.GetType().InternalType()) {
-	case PhysicalType::INT8:
-		TemplatedUpdateLoop<int8_t>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedUpdateLoop<uint8_t>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::INT16:
-		TemplatedUpdateLoop<int16_t>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedUpdateLoop<uint16_t>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::INT32:
-		TemplatedUpdateLoop<int32_t>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedUpdateLoop<uint32_t>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::INT64:
-		TemplatedUpdateLoop<int64_t>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedUpdateLoop<uint64_t>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedUpdateLoop<float>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedUpdateLoop<double>(data, updates, row_ids, count, base_index);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedUpdateLoop<string_t>(data, updates, row_ids, count, base_index);
-		break;
-	default:
-		throw Exception("Unsupported type for in-place update: " + TypeIdToString(data.GetType().InternalType()));
-	}
-}
-
-void LocalStorage::Update(DataTable *table, Vector &row_ids, const vector<column_t> &column_ids, DataChunk &data) {
-	auto storage = GetStorage(table);
-	// figure out the chunk from which these row ids came
-	idx_t chunk_idx = GetChunk(row_ids);
-	D_ASSERT(chunk_idx < storage->collection.ChunkCount());
-
-	idx_t base_index = MAX_ROW_ID + chunk_idx * STANDARD_VECTOR_SIZE;
-
-	// now perform the actual update
-	auto &chunk = storage->collection.GetChunk(chunk_idx);
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto col_idx = column_ids[i];
-		UpdateChunk(chunk.data[col_idx], data.data[i], row_ids, data.size(), base_index);
-	}
-}
-
-template <class T>
-bool LocalStorage::ScanTableStorage(DataTable &table, LocalTableStorage &storage, T &&fun) {
-	vector<column_t> column_ids;
-	column_ids.reserve(table.column_definitions.size());
-	for (idx_t i = 0; i < table.column_definitions.size(); i++) {
-		column_ids.push_back(i);
-	}
-
-	DataChunk chunk;
-	chunk.Initialize(storage.allocator, table.GetTypes());
-
-	// initialize the scan
-	LocalScanState state;
-	storage.InitializeScan(state);
-
-	while (true) {
-		Scan(state, column_ids, chunk);
-		if (chunk.size() == 0) {
-			return true;
-		}
-		if (!fun(chunk)) {
-			return false;
-		}
-	}
-}
-
-void LocalStorage::Flush(DataTable &table, LocalTableStorage &storage) {
-	if (storage.collection.Count() <= storage.deleted_rows) {
-		return;
-	}
-	idx_t append_count = storage.collection.Count() - storage.deleted_rows;
-	TableAppendState append_state;
-	table.InitializeAppend(transaction, append_state, append_count);
-
-	bool constraint_violated = false;
-	ScanTableStorage(table, storage, [&](DataChunk &chunk) -> bool {
-		// append this chunk to the indexes of the table
-		if (!table.AppendToIndexes(append_state, chunk, append_state.current_row)) {
-			constraint_violated = true;
-			return false;
-		}
-		// append to base table
-		table.Append(transaction, chunk, append_state);
-		return true;
-	});
-	if (constraint_violated) {
-		// need to revert the append
-		row_t current_row = append_state.row_start;
-		// remove the data from the indexes, if there are any indexes
-		ScanTableStorage(table, storage, [&](DataChunk &chunk) -> bool {
-			// append this chunk to the indexes of the table
-			table.RemoveFromIndexes(append_state, chunk, current_row);
-
-			current_row += chunk.size();
-			if (current_row >= append_state.current_row) {
-				// finished deleting all rows from the index: abort now
-				return false;
-			}
-			return true;
-		});
-		table.RevertAppendInternal(append_state.row_start, append_count);
-		storage.Clear();
-		throw ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicated key");
-	}
-	storage.Clear();
-	transaction.PushAppend(&table, append_state.row_start, append_count);
-}
-
-void LocalStorage::Commit(LocalStorage::CommitState &commit_state, Transaction &transaction, WriteAheadLog *log,
-                          transaction_t commit_id) {
-	// commit local storage, iterate over all entries in the table storage map
-	for (auto &entry : table_storage) {
-		auto table = entry.first;
-		auto storage = entry.second.get();
-		Flush(*table, *storage);
-	}
-	// finished commit: clear local storage
-	table_storage.clear();
-}
-
-void LocalStorage::AddColumn(DataTable *old_dt, DataTable *new_dt, ColumnDefinition &new_column,
-                             Expression *default_value) {
-	// check if there are any pending appends for the old version of the table
-	auto entry = table_storage.find(old_dt);
-	if (entry == table_storage.end()) {
-		return;
-	}
-	// take over the storage from the old entry
-	auto new_storage = move(entry->second);
-
-	// now add the new column filled with the default value to all chunks
-	const auto &new_column_type = new_column.Type();
-	auto &allocator = Allocator::DefaultAllocator();
-	ExpressionExecutor executor(allocator);
-	DataChunk dummy_chunk;
-	if (default_value) {
-		executor.AddExpression(*default_value);
-	}
-
-	new_storage->collection.Types().push_back(new_column_type);
-	for (idx_t chunk_idx = 0; chunk_idx < new_storage->collection.ChunkCount(); chunk_idx++) {
-		auto &chunk = new_storage->collection.GetChunk(chunk_idx);
-		Vector result(new_column_type);
-		if (default_value) {
-			dummy_chunk.SetCardinality(chunk.size());
-			executor.ExecuteExpression(dummy_chunk, result);
-		} else {
-			FlatVector::Validity(result).SetAllInvalid(chunk.size());
-		}
-		result.Normalify(chunk.size());
-		chunk.data.push_back(move(result));
-	}
-
-	table_storage.erase(entry);
-	table_storage[new_dt] = move(new_storage);
-}
-
-void LocalStorage::ChangeType(DataTable *old_dt, DataTable *new_dt, idx_t changed_idx, const LogicalType &target_type,
-                              const vector<column_t> &bound_columns, Expression &cast_expr) {
-	// check if there are any pending appends for the old version of the table
-	auto entry = table_storage.find(old_dt);
-	if (entry == table_storage.end()) {
-		return;
-	}
-	throw NotImplementedException("FIXME: ALTER TYPE with transaction local data not currently supported");
-}
-
-void LocalStorage::FetchChunk(DataTable *table, Vector &row_ids, idx_t count, DataChunk &dst_chunk) {
-	auto storage = GetStorage(table);
-	idx_t chunk_idx = GetChunk(row_ids);
-	auto &chunk = storage->collection.GetChunk(chunk_idx);
-
-	VectorData row_ids_data;
-	row_ids.Orrify(count, row_ids_data);
-	auto row_identifiers = (const row_t *)row_ids_data.data;
-	SelectionVector sel(count);
-	for (idx_t i = 0; i < count; ++i) {
-		const auto idx = row_ids_data.sel->get_index(i);
-		sel.set_index(i, row_identifiers[idx] - MAX_ROW_ID);
-	}
-
-	dst_chunk.InitializeEmpty(chunk.GetTypes());
-	dst_chunk.Slice(chunk, sel, count);
-}
-
-vector<unique_ptr<Index>> &LocalStorage::GetIndexes(DataTable *table) {
-	auto storage = GetStorage(table);
-
-	return storage->indexes;
-}
-
-} // namespace duckdb
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-MetaBlockReader::MetaBlockReader(DatabaseInstance &db, block_id_t block_id) : db(db), offset(0), next_block(-1) {
-	ReadNewBlock(block_id);
-}
-
-MetaBlockReader::~MetaBlockReader() {
-}
-
-void MetaBlockReader::ReadData(data_ptr_t buffer, idx_t read_size) {
-	while (offset + read_size > handle.GetFileBuffer().size) {
-		// cannot read entire entry from block
-		// first read what we can from this block
-		idx_t to_read = handle.GetFileBuffer().size - offset;
-		if (to_read > 0) {
-			memcpy(buffer, handle.Ptr() + offset, to_read);
-			read_size -= to_read;
-			buffer += to_read;
-		}
-		// then move to the next block
-		ReadNewBlock(next_block);
-	}
-	// we have enough left in this block to read from the buffer
-	memcpy(buffer, handle.Ptr() + offset, read_size);
-	offset += read_size;
-}
-
-void MetaBlockReader::ReadNewBlock(block_id_t id) {
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-
-	block_manager.MarkBlockAsModified(id);
-	block = buffer_manager.RegisterBlock(id);
-	handle = buffer_manager.Pin(block);
-
-	next_block = Load<block_id_t>(handle.Ptr());
-	D_ASSERT(next_block >= -1);
-	offset = sizeof(block_id_t);
-}
-
-} // namespace duckdb
-
-
-#include <cstring>
-
-namespace duckdb {
-
-MetaBlockWriter::MetaBlockWriter(DatabaseInstance &db, block_id_t initial_block_id) : db(db) {
-	if (initial_block_id == INVALID_BLOCK) {
-		initial_block_id = GetNextBlockId();
-	}
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	block = block_manager.CreateBlock(initial_block_id);
-	Store<block_id_t>(-1, block->buffer);
-	offset = sizeof(block_id_t);
-}
-
-MetaBlockWriter::~MetaBlockWriter() {
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	try {
-		Flush();
-	} catch (...) {
-	}
-}
-
-block_id_t MetaBlockWriter::GetNextBlockId() {
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	return block_manager.GetFreeBlockId();
-}
-
-BlockPointer MetaBlockWriter::GetBlockPointer() {
-	BlockPointer pointer;
-	pointer.block_id = block->id;
-	pointer.offset = offset;
-	return pointer;
-}
-
-void MetaBlockWriter::Flush() {
-	written_blocks.insert(block->id);
-	if (offset > sizeof(block_id_t)) {
-		auto &block_manager = BlockManager::GetBlockManager(db);
-		block_manager.Write(*block);
-		offset = sizeof(block_id_t);
-	}
-}
-
-void MetaBlockWriter::WriteData(const_data_ptr_t buffer, idx_t write_size) {
-	while (offset + write_size > block->size) {
-		// we need to make a new block
-		// first copy what we can
-		D_ASSERT(offset <= block->size);
-		idx_t copy_amount = block->size - offset;
-		if (copy_amount > 0) {
-			memcpy(block->buffer + offset, buffer, copy_amount);
-			buffer += copy_amount;
-			offset += copy_amount;
-			write_size -= copy_amount;
-		}
-		// now we need to get a new block id
-		block_id_t new_block_id = GetNextBlockId();
-		// write the block id of the new block to the start of the current block
-		Store<block_id_t>(new_block_id, block->buffer);
-		// first flush the old block
-		Flush();
-		// now update the block id of the lbock
-		block->id = new_block_id;
-		Store<block_id_t>(-1, block->buffer);
-	}
-	memcpy(block->buffer + offset, buffer, write_size);
-	offset += write_size;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
-#include <cstring>
-
-namespace duckdb {
-
-const char MainHeader::MAGIC_BYTES[] = "DUCK";
-
-void MainHeader::Serialize(Serializer &ser) {
-	ser.WriteData((data_ptr_t)MAGIC_BYTES, MAGIC_BYTE_SIZE);
-	ser.Write<uint64_t>(version_number);
-	FieldWriter writer(ser);
-	for (idx_t i = 0; i < FLAG_COUNT; i++) {
-		writer.WriteField<uint64_t>(flags[i]);
-	}
-	writer.Finalize();
-}
-
-void MainHeader::CheckMagicBytes(FileHandle &handle) {
-	data_t magic_bytes[MAGIC_BYTE_SIZE];
-	if (handle.GetFileSize() < MainHeader::MAGIC_BYTE_SIZE + MainHeader::MAGIC_BYTE_OFFSET) {
-		throw IOException("The file is not a valid DuckDB database file!");
-	}
-	handle.Read(magic_bytes, MainHeader::MAGIC_BYTE_SIZE, MainHeader::MAGIC_BYTE_OFFSET);
-	if (memcmp(magic_bytes, MainHeader::MAGIC_BYTES, MainHeader::MAGIC_BYTE_SIZE) != 0) {
-		throw IOException("The file is not a valid DuckDB database file!");
-	}
-}
-
-MainHeader MainHeader::Deserialize(Deserializer &source) {
-	data_t magic_bytes[MAGIC_BYTE_SIZE];
-	MainHeader header;
-	source.ReadData(magic_bytes, MainHeader::MAGIC_BYTE_SIZE);
-	if (memcmp(magic_bytes, MainHeader::MAGIC_BYTES, MainHeader::MAGIC_BYTE_SIZE) != 0) {
-		throw IOException("The file is not a valid DuckDB database file!");
-	}
-	header.version_number = source.Read<uint64_t>();
-	// read the flags
-	FieldReader reader(source);
-	for (idx_t i = 0; i < FLAG_COUNT; i++) {
-		header.flags[i] = reader.ReadRequired<uint64_t>();
-	}
-	reader.Finalize();
-	return header;
-}
-
-void DatabaseHeader::Serialize(Serializer &ser) {
-	ser.Write<uint64_t>(iteration);
-	ser.Write<block_id_t>(meta_block);
-	ser.Write<block_id_t>(free_list);
-	ser.Write<uint64_t>(block_count);
-}
-
-DatabaseHeader DatabaseHeader::Deserialize(Deserializer &source) {
-	DatabaseHeader header;
-	header.iteration = source.Read<uint64_t>();
-	header.meta_block = source.Read<block_id_t>();
-	header.free_list = source.Read<block_id_t>();
-	header.block_count = source.Read<uint64_t>();
-	return header;
-}
-
-template <class T>
-void SerializeHeaderStructure(T header, data_ptr_t ptr) {
-	BufferedSerializer ser(ptr, Storage::FILE_HEADER_SIZE);
-	header.Serialize(ser);
-}
-
-template <class T>
-T DeserializeHeaderStructure(data_ptr_t ptr) {
-	BufferedDeserializer source(ptr, Storage::FILE_HEADER_SIZE);
-	return T::Deserialize(source);
-}
-
-SingleFileBlockManager::SingleFileBlockManager(DatabaseInstance &db, string path_p, bool read_only, bool create_new,
-                                               bool use_direct_io)
-    : db(db), path(move(path_p)),
-      header_buffer(Allocator::Get(db), FileBufferType::MANAGED_BUFFER, Storage::FILE_HEADER_SIZE), iteration_count(0),
-      read_only(read_only), use_direct_io(use_direct_io) {
-	uint8_t flags;
-	FileLockType lock;
-	if (read_only) {
-		D_ASSERT(!create_new);
-		flags = FileFlags::FILE_FLAGS_READ;
-		lock = FileLockType::READ_LOCK;
-	} else {
-		flags = FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_READ;
-		lock = FileLockType::WRITE_LOCK;
-		if (create_new) {
-			flags |= FileFlags::FILE_FLAGS_FILE_CREATE;
-		}
-	}
-	if (use_direct_io) {
-		flags |= FileFlags::FILE_FLAGS_DIRECT_IO;
-	}
-	// open the RDBMS handle
-	auto &fs = FileSystem::GetFileSystem(db);
-	handle = fs.OpenFile(path, flags, lock);
-	if (create_new) {
-		// if we create a new file, we fill the metadata of the file
-		// first fill in the new header
-		header_buffer.Clear();
-
-		MainHeader main_header;
-		main_header.version_number = VERSION_NUMBER;
-		memset(main_header.flags, 0, sizeof(uint64_t) * 4);
-
-		SerializeHeaderStructure<MainHeader>(main_header, header_buffer.buffer);
-		// now write the header to the file
-		header_buffer.ChecksumAndWrite(*handle, 0);
-		header_buffer.Clear();
-
-		// write the database headers
-		// initialize meta_block and free_list to INVALID_BLOCK because the database file does not contain any actual
-		// content yet
-		DatabaseHeader h1, h2;
-		// header 1
-		h1.iteration = 0;
-		h1.meta_block = INVALID_BLOCK;
-		h1.free_list = INVALID_BLOCK;
-		h1.block_count = 0;
-		SerializeHeaderStructure<DatabaseHeader>(h1, header_buffer.buffer);
-		header_buffer.ChecksumAndWrite(*handle, Storage::FILE_HEADER_SIZE);
-		// header 2
-		h2.iteration = 0;
-		h2.meta_block = INVALID_BLOCK;
-		h2.free_list = INVALID_BLOCK;
-		h2.block_count = 0;
-		SerializeHeaderStructure<DatabaseHeader>(h2, header_buffer.buffer);
-		header_buffer.ChecksumAndWrite(*handle, Storage::FILE_HEADER_SIZE * 2);
-		// ensure that writing to disk is completed before returning
-		handle->Sync();
-		// we start with h2 as active_header, this way our initial write will be in h1
-		iteration_count = 0;
-		active_header = 1;
-		max_block = 0;
-	} else {
-		MainHeader::CheckMagicBytes(*handle);
-		// otherwise, we check the metadata of the file
-		header_buffer.ReadAndChecksum(*handle, 0);
-		MainHeader header = DeserializeHeaderStructure<MainHeader>(header_buffer.buffer);
-		// check the version number
-		if (header.version_number != VERSION_NUMBER) {
-			throw IOException(
-			    "Trying to read a database file with version number %lld, but we can only read version %lld.\n"
-			    "The database file was created with an %s version of DuckDB.\n\n"
-			    "The storage of DuckDB is not yet stable; newer versions of DuckDB cannot read old database files and "
-			    "vice versa.\n"
-			    "The storage will be stabilized when version 1.0 releases.\n\n"
-			    "For now, we recommend that you load the database file in a supported version of DuckDB, and use the "
-			    "EXPORT DATABASE command "
-			    "followed by IMPORT DATABASE on the current version of DuckDB.",
-			    header.version_number, VERSION_NUMBER, VERSION_NUMBER > header.version_number ? "older" : "newer");
-		}
-
-		// read the database headers from disk
-		DatabaseHeader h1, h2;
-		header_buffer.ReadAndChecksum(*handle, Storage::FILE_HEADER_SIZE);
-		h1 = DeserializeHeaderStructure<DatabaseHeader>(header_buffer.buffer);
-		header_buffer.ReadAndChecksum(*handle, Storage::FILE_HEADER_SIZE * 2);
-		h2 = DeserializeHeaderStructure<DatabaseHeader>(header_buffer.buffer);
-		// check the header with the highest iteration count
-		if (h1.iteration > h2.iteration) {
-			// h1 is active header
-			active_header = 0;
-			Initialize(h1);
-		} else {
-			// h2 is active header
-			active_header = 1;
-			Initialize(h2);
-		}
-	}
-}
-
-void SingleFileBlockManager::Initialize(DatabaseHeader &header) {
-	free_list_id = header.free_list;
-	meta_block = header.meta_block;
-	iteration_count = header.iteration;
-	max_block = header.block_count;
-}
-
-void SingleFileBlockManager::LoadFreeList() {
-	if (read_only) {
-		// no need to load free list for read only db
-		return;
-	}
-	if (free_list_id == INVALID_BLOCK) {
-		// no free list
-		return;
-	}
-	MetaBlockReader reader(db, free_list_id);
-	auto free_list_count = reader.Read<uint64_t>();
-	free_list.clear();
-	for (idx_t i = 0; i < free_list_count; i++) {
-		free_list.insert(reader.Read<block_id_t>());
-	}
-	auto multi_use_blocks_count = reader.Read<uint64_t>();
-	multi_use_blocks.clear();
-	for (idx_t i = 0; i < multi_use_blocks_count; i++) {
-		auto block_id = reader.Read<block_id_t>();
-		auto usage_count = reader.Read<uint32_t>();
-		multi_use_blocks[block_id] = usage_count;
-	}
-}
-
-void SingleFileBlockManager::StartCheckpoint() {
-}
-
-bool SingleFileBlockManager::IsRootBlock(block_id_t root) {
-	return root == meta_block;
-}
-
-block_id_t SingleFileBlockManager::GetFreeBlockId() {
-	block_id_t block;
-	if (!free_list.empty()) {
-		// free list is non empty
-		// take an entry from the free list
-		block = *free_list.begin();
-		// erase the entry from the free list again
-		free_list.erase(free_list.begin());
-	} else {
-		block = max_block++;
-	}
-	return block;
-}
-
-void SingleFileBlockManager::MarkBlockAsModified(block_id_t block_id) {
-	D_ASSERT(block_id >= 0);
-
-	// check if the block is a multi-use block
-	auto entry = multi_use_blocks.find(block_id);
-	if (entry != multi_use_blocks.end()) {
-		// it is! reduce the reference count of the block
-		entry->second--;
-		// check the reference count: is the block still a multi-use block?
-		if (entry->second <= 1) {
-			// no longer a multi-use block!
-			multi_use_blocks.erase(entry);
-		}
-		return;
-	}
-	modified_blocks.insert(block_id);
-}
-
-void SingleFileBlockManager::IncreaseBlockReferenceCount(block_id_t block_id) {
-	D_ASSERT(free_list.find(block_id) == free_list.end());
-	auto entry = multi_use_blocks.find(block_id);
-	if (entry != multi_use_blocks.end()) {
-		entry->second++;
-	} else {
-		multi_use_blocks[block_id] = 2;
-	}
-}
-
-block_id_t SingleFileBlockManager::GetMetaBlock() {
-	return meta_block;
-}
-
-unique_ptr<Block> SingleFileBlockManager::CreateBlock(block_id_t block_id) {
-	return make_unique<Block>(Allocator::Get(db), block_id);
-}
-
-void SingleFileBlockManager::Read(Block &block) {
-	D_ASSERT(block.id >= 0);
-	D_ASSERT(std::find(free_list.begin(), free_list.end(), block.id) == free_list.end());
-	block.ReadAndChecksum(*handle, BLOCK_START + block.id * Storage::BLOCK_ALLOC_SIZE);
-}
-
-void SingleFileBlockManager::Write(FileBuffer &buffer, block_id_t block_id) {
-	D_ASSERT(block_id >= 0);
-	buffer.ChecksumAndWrite(*handle, BLOCK_START + block_id * Storage::BLOCK_ALLOC_SIZE);
-}
-
-vector<block_id_t> SingleFileBlockManager::GetFreeListBlocks() {
-	vector<block_id_t> free_list_blocks;
-
-	if (!free_list.empty() || !multi_use_blocks.empty() || !modified_blocks.empty()) {
-		// there are blocks in the free list or multi_use_blocks
-		// figure out how many blocks we need to write these to the file
-		auto free_list_size = sizeof(uint64_t) + sizeof(block_id_t) * (free_list.size() + modified_blocks.size());
-		auto multi_use_blocks_size =
-		    sizeof(uint64_t) + (sizeof(block_id_t) + sizeof(uint32_t)) * multi_use_blocks.size();
-		auto total_size = free_list_size + multi_use_blocks_size;
-		// because of potential alignment issues and needing to store a next pointer in a block we subtract
-		// a bit from the max block size
-		auto space_in_block = Storage::BLOCK_SIZE - 4 * sizeof(block_id_t);
-		auto total_blocks = (total_size + space_in_block - 1) / space_in_block;
-		auto &config = DBConfig::GetConfig(db);
-		if (config.debug_many_free_list_blocks) {
-			total_blocks++;
-		}
-		D_ASSERT(total_size > 0);
-		D_ASSERT(total_blocks > 0);
-
-		// reserve the blocks that we are going to write
-		// since these blocks are no longer free we cannot just include them in the free list!
-		for (idx_t i = 0; i < total_blocks; i++) {
-			auto block_id = GetFreeBlockId();
-			free_list_blocks.push_back(block_id);
-		}
-	}
-
-	return free_list_blocks;
-}
-
-class FreeListBlockWriter : public MetaBlockWriter {
-public:
-	FreeListBlockWriter(DatabaseInstance &db_p, vector<block_id_t> &free_list_blocks_p)
-	    : MetaBlockWriter(db_p, free_list_blocks_p[0]), free_list_blocks(free_list_blocks_p), index(1) {
-	}
-
-	vector<block_id_t> &free_list_blocks;
-	idx_t index;
-
-protected:
-	block_id_t GetNextBlockId() override {
-		if (index >= free_list_blocks.size()) {
-			throw InternalException(
-			    "Free List Block Writer ran out of blocks, this means not enough blocks were allocated up front");
-		}
-		return free_list_blocks[index++];
-	}
-};
-
-void SingleFileBlockManager::WriteHeader(DatabaseHeader header) {
-	// set the iteration count
-	header.iteration = ++iteration_count;
-
-	vector<block_id_t> free_list_blocks = GetFreeListBlocks();
-
-	// now handle the free list
-	// add all modified blocks to the free list: they can now be written to again
-	for (auto &block : modified_blocks) {
-		free_list.insert(block);
-	}
-	modified_blocks.clear();
-
-	if (!free_list_blocks.empty()) {
-		// there are blocks to write, either in the free_list or in the modified_blocks
-		// we write these blocks specifically to the free_list_blocks
-		// a normal MetaBlockWriter will fetch blocks to use from the free_list
-		// but since we are WRITING the free_list, this behavior is sub-optimal
-
-		FreeListBlockWriter writer(db, free_list_blocks);
-
-		D_ASSERT(writer.block->id == free_list_blocks[0]);
-		header.free_list = writer.block->id;
-		for (auto &block_id : free_list_blocks) {
-			modified_blocks.insert(block_id);
-		}
-
-		writer.Write<uint64_t>(free_list.size());
-		for (auto &block_id : free_list) {
-			writer.Write<block_id_t>(block_id);
-		}
-		writer.Write<uint64_t>(multi_use_blocks.size());
-		for (auto &entry : multi_use_blocks) {
-			writer.Write<block_id_t>(entry.first);
-			writer.Write<uint32_t>(entry.second);
-		}
-		writer.Flush();
-	} else {
-		// no blocks in the free list
-		header.free_list = INVALID_BLOCK;
-	}
-	header.block_count = max_block;
-
-	auto &config = DBConfig::GetConfig(db);
-	if (config.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_AFTER_FREE_LIST_WRITE) {
-		throw IOException("Checkpoint aborted after free list write because of PRAGMA checkpoint_abort flag");
-	}
-
-	if (!use_direct_io) {
-		// if we are not using Direct IO we need to fsync BEFORE we write the header to ensure that all the previous
-		// blocks are written as well
-		handle->Sync();
-	}
-	// set the header inside the buffer
-	header_buffer.Clear();
-	Store<DatabaseHeader>(header, header_buffer.buffer);
-	// now write the header to the file, active_header determines whether we write to h1 or h2
-	// note that if active_header is h1 we write to h2, and vice versa
-	header_buffer.ChecksumAndWrite(*handle,
-	                               active_header == 1 ? Storage::FILE_HEADER_SIZE : Storage::FILE_HEADER_SIZE * 2);
-	// switch active header to the other header
-	active_header = 1 - active_header;
-	//! Ensure the header write ends up on disk
-	handle->Sync();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-BaseStatistics::BaseStatistics(LogicalType type, StatisticsType stats_type) : type(move(type)), stats_type(stats_type) {
-}
-
-BaseStatistics::~BaseStatistics() {
-}
-
-void BaseStatistics::InitializeBase() {
-	validity_stats = make_unique<ValidityStatistics>(false);
-	if (stats_type == GLOBAL_STATS) {
-		distinct_stats = make_unique<DistinctStatistics>();
-	}
-}
-
-bool BaseStatistics::CanHaveNull() const {
-	if (!validity_stats) {
-		// we don't know
-		// solid maybe
-		return true;
-	}
-	return ((ValidityStatistics &)*validity_stats).has_null;
-}
-
-bool BaseStatistics::CanHaveNoNull() const {
-	if (!validity_stats) {
-		// we don't know
-		// solid maybe
-		return true;
-	}
-	return ((ValidityStatistics &)*validity_stats).has_no_null;
-}
-
-void BaseStatistics::UpdateDistinctStatistics(Vector &v, idx_t count) {
-	if (!distinct_stats) {
-		return;
-	}
-	auto &d_stats = (DistinctStatistics &)*distinct_stats;
-	d_stats.Update(v, count);
-}
-
-void MergeInternal(unique_ptr<BaseStatistics> &orig, const unique_ptr<BaseStatistics> &other) {
-	if (other) {
-		if (orig) {
-			orig->Merge(*other);
-		} else {
-			orig = other->Copy();
-		}
-	}
-}
-
-void BaseStatistics::Merge(const BaseStatistics &other) {
-	D_ASSERT(type == other.type);
-	MergeInternal(validity_stats, other.validity_stats);
-	if (stats_type == GLOBAL_STATS) {
-		MergeInternal(distinct_stats, other.distinct_stats);
-	}
-}
-
-unique_ptr<BaseStatistics> BaseStatistics::CreateEmpty(LogicalType type, StatisticsType stats_type) {
-	unique_ptr<BaseStatistics> result;
-	switch (type.InternalType()) {
-	case PhysicalType::BIT:
-		return make_unique<ValidityStatistics>(false, false);
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		result = make_unique<NumericStatistics>(move(type), stats_type);
-		break;
-	case PhysicalType::VARCHAR:
-		result = make_unique<StringStatistics>(move(type), stats_type);
-		break;
-	case PhysicalType::STRUCT:
-		result = make_unique<StructStatistics>(move(type));
-		break;
-	case PhysicalType::LIST:
-		result = make_unique<ListStatistics>(move(type));
-		break;
-	case PhysicalType::INTERVAL:
-	default:
-		result = make_unique<BaseStatistics>(move(type), stats_type);
-	}
-	result->InitializeBase();
-	return result;
-}
-
-unique_ptr<BaseStatistics> BaseStatistics::Copy() const {
-	auto result = make_unique<BaseStatistics>(type, stats_type);
-	result->CopyBase(*this);
-	return result;
-}
-
-void BaseStatistics::CopyBase(const BaseStatistics &orig) {
-	if (orig.validity_stats) {
-		validity_stats = orig.validity_stats->Copy();
-	}
-	if (orig.distinct_stats) {
-		distinct_stats = orig.distinct_stats->Copy();
-	}
-}
-
-void BaseStatistics::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	ValidityStatistics(CanHaveNull(), CanHaveNoNull()).Serialize(writer);
-	Serialize(writer);
-	auto ptype = type.InternalType();
-	if (ptype != PhysicalType::BIT) {
-		writer.WriteField<StatisticsType>(stats_type);
-		writer.WriteOptional<BaseStatistics>(distinct_stats);
-	}
-	writer.Finalize();
-}
-
-void BaseStatistics::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<BaseStatistics> BaseStatistics::Deserialize(Deserializer &source, LogicalType type) {
-	FieldReader reader(source);
-	auto validity_stats = ValidityStatistics::Deserialize(reader);
-	unique_ptr<BaseStatistics> result;
-	auto ptype = type.InternalType();
-	switch (ptype) {
-	case PhysicalType::BIT:
-		result = ValidityStatistics::Deserialize(reader);
-		break;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		result = NumericStatistics::Deserialize(reader, move(type));
-		break;
-	case PhysicalType::VARCHAR:
-		result = StringStatistics::Deserialize(reader, move(type));
-		break;
-	case PhysicalType::STRUCT:
-		result = StructStatistics::Deserialize(reader, move(type));
-		break;
-	case PhysicalType::LIST:
-		result = ListStatistics::Deserialize(reader, move(type));
-		break;
-	case PhysicalType::INTERVAL:
-		result = make_unique<BaseStatistics>(move(type), StatisticsType::LOCAL_STATS);
-		break;
-	default:
-		throw InternalException("Unimplemented type for statistics deserialization");
-	}
-
-	if (ptype != PhysicalType::BIT) {
-		result->validity_stats = move(validity_stats);
-		result->stats_type = reader.ReadField<StatisticsType>(StatisticsType::LOCAL_STATS);
-		result->distinct_stats = reader.ReadOptional<DistinctStatistics>(nullptr);
-	}
-
-	reader.Finalize();
-	return result;
-}
-
-string BaseStatistics::ToString() const {
-	return StringUtil::Format("%s%s", validity_stats ? validity_stats->ToString() : "",
-	                          distinct_stats ? distinct_stats->ToString() : "");
-}
-
-void BaseStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	D_ASSERT(vector.GetType() == this->type);
-	if (validity_stats) {
-		validity_stats->Verify(vector, sel, count);
-	}
-}
-
-void BaseStatistics::Verify(Vector &vector, idx_t count) const {
-	auto sel = FlatVector::IncrementalSelectionVector();
-	Verify(vector, *sel, count);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-ColumnStatistics::ColumnStatistics(unique_ptr<BaseStatistics> stats_p) : stats(move(stats_p)) {
-}
-
-shared_ptr<ColumnStatistics> ColumnStatistics::CreateEmptyStats(const LogicalType &type) {
-	auto col_stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
-	return make_shared<ColumnStatistics>(move(col_stats));
-}
-
-} // namespace duckdb
-
-
-
-
-
-#include <math.h>
-
-namespace duckdb {
-
-DistinctStatistics::DistinctStatistics()
-    : BaseStatistics(LogicalType::INVALID, StatisticsType::LOCAL_STATS), log(make_unique<HyperLogLog>()),
-      sample_count(0), total_count(0) {
-}
-
-DistinctStatistics::DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count)
-    : BaseStatistics(LogicalType::INVALID, StatisticsType::LOCAL_STATS), log(move(log)), sample_count(sample_count),
-      total_count(total_count) {
-}
-
-unique_ptr<BaseStatistics> DistinctStatistics::Copy() const {
-	return make_unique<DistinctStatistics>(log->Copy(), sample_count, total_count);
-}
-
-void DistinctStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-	auto &other = (const DistinctStatistics &)other_p;
-	log->Merge(*other.log);
-	sample_count += other.sample_count;
-	total_count += other.total_count;
-}
-
-void DistinctStatistics::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-void DistinctStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(sample_count);
-	writer.WriteField<idx_t>(total_count);
-	log->Serialize(writer);
-}
-
-unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto result = Deserialize(reader);
-	reader.Finalize();
-	return result;
-}
-
-unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(FieldReader &reader) {
-	auto sample_count = reader.ReadRequired<idx_t>();
-	auto total_count = reader.ReadRequired<idx_t>();
-	return make_unique<DistinctStatistics>(HyperLogLog::Deserialize(reader), sample_count, total_count);
-}
-
-void DistinctStatistics::Update(Vector &v, idx_t count) {
-	VectorData vdata;
-	v.Orrify(count, vdata);
-	Update(vdata, v.GetType(), count);
-}
-
-void DistinctStatistics::Update(VectorData &vdata, const LogicalType &type, idx_t count) {
-	if (count == 0) {
-		return;
-	}
-	total_count += count;
-	count = MinValue<idx_t>(idx_t(SAMPLE_RATE * MaxValue<idx_t>(STANDARD_VECTOR_SIZE, count)), count);
-	sample_count += count;
-
-	uint64_t indices[STANDARD_VECTOR_SIZE];
-	uint8_t counts[STANDARD_VECTOR_SIZE];
-
-	HyperLogLog::ProcessEntries(vdata, type, indices, counts, count);
-	log->AddToLog(vdata, count, indices, counts);
-}
-
-string DistinctStatistics::ToString() const {
-	return StringUtil::Format("[Approx Unique: %s]", to_string(GetCount()));
-}
-
-idx_t DistinctStatistics::GetCount() const {
-	if (sample_count == 0 || total_count == 0) {
-		return 0;
-	}
-
-	double u = MinValue<idx_t>(log->Count(), sample_count);
-	double s = sample_count;
-	double n = total_count;
-
-	// Assume this proportion of the the sampled values occurred only once
-	double u1 = pow(u / s, 2) * u;
-
-	// Estimate total uniques using Good Turing Estimation
-	idx_t estimate = u + u1 / s * (n - s);
-	return MinValue<idx_t>(estimate, total_count);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-ListStatistics::ListStatistics(LogicalType type_p) : BaseStatistics(move(type_p), StatisticsType::LOCAL_STATS) {
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	InitializeBase();
-	auto &child_type = ListType::GetChildType(type);
-	child_stats = BaseStatistics::CreateEmpty(child_type, StatisticsType::LOCAL_STATS);
-}
-
-void ListStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-
-	auto &other = (const ListStatistics &)other_p;
-	if (child_stats && other.child_stats) {
-		child_stats->Merge(*other.child_stats);
-	} else {
-		child_stats.reset();
-	}
-}
-
-// LCOV_EXCL_START
-FilterPropagateResult ListStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
-	throw InternalException("List zonemaps are not supported yet");
-}
-// LCOV_EXCL_STOP
-
-unique_ptr<BaseStatistics> ListStatistics::Copy() const {
-	auto result = make_unique<ListStatistics>(type);
-	result->CopyBase(*this);
-
-	result->child_stats = child_stats ? child_stats->Copy() : nullptr;
-	return move(result);
-}
-
-void ListStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*child_stats);
-}
-
-unique_ptr<BaseStatistics> ListStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	auto result = make_unique<ListStatistics>(move(type));
-	auto &child_type = ListType::GetChildType(result->type);
-	result->child_stats = reader.ReadRequiredSerializable<BaseStatistics>(child_type);
-	return move(result);
-}
-
-string ListStatistics::ToString() const {
-	return StringUtil::Format("[%s]%s", child_stats ? child_stats->ToString() : "No Stats", BaseStatistics::ToString());
-}
-
-void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	BaseStatistics::Verify(vector, sel, count);
-
-	if (child_stats) {
-		auto &child_entry = ListVector::GetEntry(vector);
-		VectorData vdata;
-		vector.Orrify(count, vdata);
-
-		auto list_data = (list_entry_t *)vdata.data;
-		idx_t total_list_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto index = vdata.sel->get_index(idx);
-			auto list = list_data[index];
-			if (vdata.validity.RowIsValid(index)) {
-				for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-					total_list_count++;
-				}
-			}
-		}
-		SelectionVector list_sel(total_list_count);
-		idx_t list_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto index = vdata.sel->get_index(idx);
-			auto list = list_data[index];
-			if (vdata.validity.RowIsValid(index)) {
-				for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-					list_sel.set_index(list_count++, list.offset + list_idx);
-				}
-			}
-		}
-
-		child_stats->Verify(child_entry, list_sel, list_count);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-template <>
-void NumericStatistics::Update<interval_t>(SegmentStatistics &stats, interval_t new_value) {
-}
-
-template <>
-void NumericStatistics::Update<list_entry_t>(SegmentStatistics &stats, list_entry_t new_value) {
-}
-
-NumericStatistics::NumericStatistics(LogicalType type_p, StatisticsType stats_type)
-    : BaseStatistics(move(type_p), stats_type) {
-	InitializeBase();
-	min = Value::MaximumValue(type);
-	max = Value::MinimumValue(type);
-}
-
-NumericStatistics::NumericStatistics(LogicalType type_p, Value min_p, Value max_p, StatisticsType stats_type)
-    : BaseStatistics(move(type_p), stats_type), min(move(min_p)), max(move(max_p)) {
-	InitializeBase();
-}
-
-void NumericStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-	auto &other = (const NumericStatistics &)other_p;
-	if (other.min.IsNull() || min.IsNull()) {
-		min = Value(type);
-	} else if (other.min < min) {
-		min = other.min;
-	}
-	if (other.max.IsNull() || max.IsNull()) {
-		max = Value(type);
-	} else if (other.max > max) {
-		max = other.max;
-	}
-}
-
-FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
-	if (constant.IsNull()) {
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	}
-	if (min.IsNull() || max.IsNull()) {
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		if (constant == min && constant == max) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (constant >= min && constant <= max) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_NOTEQUAL:
-		if (constant < min || constant > max) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min == max && min == constant) {
-			// corner case of a cluster with one numeric equal to the target constant
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// X >= C
-		// this can be true only if max(X) >= C
-		// if min(X) >= C, then this is always true
-		if (min >= constant) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (max >= constant) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_GREATERTHAN:
-		// X > C
-		// this can be true only if max(X) > C
-		// if min(X) > C, then this is always true
-		if (min > constant) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (max > constant) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// X <= C
-		// this can be true only if min(X) <= C
-		// if max(X) <= C, then this is always true
-		if (max <= constant) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min <= constant) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHAN:
-		// X < C
-		// this can be true only if min(X) < C
-		// if max(X) < C, then this is always true
-		if (max < constant) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min < constant) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	default:
-		throw InternalException("Expression type in zonemap check not implemented");
-	}
-}
-
-unique_ptr<BaseStatistics> NumericStatistics::Copy() const {
-	auto result = make_unique<NumericStatistics>(type, min, max, stats_type);
-	result->CopyBase(*this);
-	return move(result);
-}
-
-bool NumericStatistics::IsConstant() const {
-	return max <= min;
-}
-
-void NumericStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(min);
-	writer.WriteSerializable(max);
-}
-
-unique_ptr<BaseStatistics> NumericStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	auto min = reader.ReadRequiredSerializable<Value, Value>();
-	auto max = reader.ReadRequiredSerializable<Value, Value>();
-	return make_unique_base<BaseStatistics, NumericStatistics>(move(type), min, max, StatisticsType::LOCAL_STATS);
-}
-
-string NumericStatistics::ToString() const {
-	return StringUtil::Format("[Min: %s, Max: %s]%s", min.ToString(), max.ToString(), BaseStatistics::ToString());
-}
-
-template <class T>
-void NumericStatistics::TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	VectorData vdata;
-	vector.Orrify(count, vdata);
-
-	auto data = (T *)vdata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		if (!vdata.validity.RowIsValid(index)) {
-			continue;
-		}
-		if (!min.IsNull() && LessThan::Operation(data[index], min.GetValueUnsafe<T>())) { // LCOV_EXCL_START
-			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
-			                        ToString(), vector.ToString(count));
-		} // LCOV_EXCL_STOP
-		if (!max.IsNull() && GreaterThan::Operation(data[index], max.GetValueUnsafe<T>())) {
-			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
-			                        ToString(), vector.ToString(count));
-		}
-	}
-}
-
-void NumericStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	BaseStatistics::Verify(vector, sel, count);
-
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		break;
-	case PhysicalType::INT8:
-		TemplatedVerify<int8_t>(vector, sel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedVerify<int16_t>(vector, sel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedVerify<int32_t>(vector, sel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedVerify<int64_t>(vector, sel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedVerify<uint8_t>(vector, sel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedVerify<uint16_t>(vector, sel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedVerify<uint32_t>(vector, sel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedVerify<uint64_t>(vector, sel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedVerify<hugeint_t>(vector, sel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedVerify<float>(vector, sel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedVerify<double>(vector, sel, count);
-		break;
-	default:
-		throw InternalException("Unsupported type %s for numeric statistics verify", type.ToString());
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-SegmentStatistics::SegmentStatistics(LogicalType type) : type(move(type)) {
-	Reset();
-}
-
-SegmentStatistics::SegmentStatistics(LogicalType type, unique_ptr<BaseStatistics> stats)
-    : type(move(type)), statistics(move(stats)) {
-	if (!statistics) {
-		Reset();
-	}
-}
-
-void SegmentStatistics::Reset() {
-	statistics = BaseStatistics::CreateEmpty(type, StatisticsType::LOCAL_STATS);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-StringStatistics::StringStatistics(LogicalType type_p, StatisticsType stats_type)
-    : BaseStatistics(move(type_p), stats_type) {
-	InitializeBase();
-	for (idx_t i = 0; i < MAX_STRING_MINMAX_SIZE; i++) {
-		min[i] = 0xFF;
-		max[i] = 0;
-	}
-	max_string_length = 0;
-	has_unicode = false;
-	has_overflow_strings = false;
-}
-
-unique_ptr<BaseStatistics> StringStatistics::Copy() const {
-	auto result = make_unique<StringStatistics>(type, stats_type);
-	result->CopyBase(*this);
-
-	memcpy(result->min, min, MAX_STRING_MINMAX_SIZE);
-	memcpy(result->max, max, MAX_STRING_MINMAX_SIZE);
-	result->has_unicode = has_unicode;
-	result->max_string_length = max_string_length;
-	return move(result);
-}
-
-void StringStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteBlob(min, MAX_STRING_MINMAX_SIZE);
-	writer.WriteBlob(max, MAX_STRING_MINMAX_SIZE);
-	writer.WriteField<bool>(has_unicode);
-	writer.WriteField<uint32_t>(max_string_length);
-	writer.WriteField<bool>(has_overflow_strings);
-}
-
-unique_ptr<BaseStatistics> StringStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	auto stats = make_unique<StringStatistics>(move(type), StatisticsType::LOCAL_STATS);
-	reader.ReadBlob(stats->min, MAX_STRING_MINMAX_SIZE);
-	reader.ReadBlob(stats->max, MAX_STRING_MINMAX_SIZE);
-	stats->has_unicode = reader.ReadRequired<bool>();
-	stats->max_string_length = reader.ReadRequired<uint32_t>();
-	stats->has_overflow_strings = reader.ReadRequired<bool>();
-	return move(stats);
-}
-
-static int StringValueComparison(const_data_ptr_t data, idx_t len, const_data_ptr_t comparison) {
-	D_ASSERT(len <= StringStatistics::MAX_STRING_MINMAX_SIZE);
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] < comparison[i]) {
-			return -1;
-		} else if (data[i] > comparison[i]) {
-			return 1;
-		}
-	}
-	return 0;
-}
-
-static void ConstructValue(const_data_ptr_t data, idx_t size, data_t target[]) {
-	idx_t value_size =
-	    size > StringStatistics::MAX_STRING_MINMAX_SIZE ? StringStatistics::MAX_STRING_MINMAX_SIZE : size;
-	memcpy(target, data, value_size);
-	for (idx_t i = value_size; i < StringStatistics::MAX_STRING_MINMAX_SIZE; i++) {
-		target[i] = '\0';
-	}
-}
-
-void StringStatistics::Update(const string_t &value) {
-	auto data = (const_data_ptr_t)value.GetDataUnsafe();
-	auto size = value.GetSize();
-
-	//! we can only fit 8 bytes, so we might need to trim our string
-	// construct the value
-	data_t target[MAX_STRING_MINMAX_SIZE];
-	ConstructValue(data, size, target);
-
-	// update the min and max
-	if (StringValueComparison(target, MAX_STRING_MINMAX_SIZE, min) < 0) {
-		memcpy(min, target, MAX_STRING_MINMAX_SIZE);
-	}
-	if (StringValueComparison(target, MAX_STRING_MINMAX_SIZE, max) > 0) {
-		memcpy(max, target, MAX_STRING_MINMAX_SIZE);
-	}
-	if (size > max_string_length) {
-		max_string_length = size;
-	}
-	if (type.id() == LogicalTypeId::VARCHAR && !has_unicode) {
-		auto unicode = Utf8Proc::Analyze((const char *)data, size);
-		if (unicode == UnicodeType::UNICODE) {
-			has_unicode = true;
-		} else if (unicode == UnicodeType::INVALID) {
-			throw InternalException("Invalid unicode detected in segment statistics update!");
-		}
-	}
-}
-
-void StringStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-	auto &other = (const StringStatistics &)other_p;
-	if (StringValueComparison(other.min, MAX_STRING_MINMAX_SIZE, min) < 0) {
-		memcpy(min, other.min, MAX_STRING_MINMAX_SIZE);
-	}
-	if (StringValueComparison(other.max, MAX_STRING_MINMAX_SIZE, max) > 0) {
-		memcpy(max, other.max, MAX_STRING_MINMAX_SIZE);
-	}
-	has_unicode = has_unicode || other.has_unicode;
-	max_string_length = MaxValue<uint32_t>(max_string_length, other.max_string_length);
-	has_overflow_strings = has_overflow_strings || other.has_overflow_strings;
-}
-
-FilterPropagateResult StringStatistics::CheckZonemap(ExpressionType comparison_type, const string &constant) const {
-	auto data = (const_data_ptr_t)constant.c_str();
-	auto size = constant.size();
-
-	idx_t value_size = size > MAX_STRING_MINMAX_SIZE ? MAX_STRING_MINMAX_SIZE : size;
-	int min_comp = StringValueComparison(data, value_size, min);
-	int max_comp = StringValueComparison(data, value_size, max);
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		if (min_comp >= 0 && max_comp <= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_NOTEQUAL:
-		if (min_comp < 0 || max_comp > 0) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-	case ExpressionType::COMPARE_GREATERTHAN:
-		if (max_comp <= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		if (min_comp >= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	default:
-		throw InternalException("Expression type not implemented for string statistics zone map");
-	}
-}
-
-static idx_t GetValidMinMaxSubstring(const_data_ptr_t data) {
-	for (idx_t i = 0; i < StringStatistics::MAX_STRING_MINMAX_SIZE; i++) {
-		if (data[i] == '\0') {
-			return i;
-		}
-		if ((data[i] & 0x80) != 0) {
-			return i;
-		}
-	}
-	return StringStatistics::MAX_STRING_MINMAX_SIZE;
-}
-
-string StringStatistics::ToString() const {
-	idx_t min_len = GetValidMinMaxSubstring(min);
-	idx_t max_len = GetValidMinMaxSubstring(max);
-	return StringUtil::Format("[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %lld]%s",
-	                          string((const char *)min, min_len), string((const char *)max, max_len),
-	                          has_unicode ? "true" : "false", max_string_length, BaseStatistics::ToString());
-}
-
-void StringStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	BaseStatistics::Verify(vector, sel, count);
-
-	string_t min_string((const char *)min, MAX_STRING_MINMAX_SIZE);
-	string_t max_string((const char *)max, MAX_STRING_MINMAX_SIZE);
-
-	VectorData vdata;
-	vector.Orrify(count, vdata);
-	auto data = (string_t *)vdata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		if (!vdata.validity.RowIsValid(index)) {
-			continue;
-		}
-		auto value = data[index];
-		auto data = value.GetDataUnsafe();
-		auto len = value.GetSize();
-		// LCOV_EXCL_START
-		if (len > max_string_length) {
-			throw InternalException(
-			    "Statistics mismatch: string value exceeds maximum string length.\nStatistics: %s\nVector: %s",
-			    ToString(), vector.ToString(count));
-		}
-		if (type.id() == LogicalTypeId::VARCHAR && !has_unicode) {
-			auto unicode = Utf8Proc::Analyze(data, len);
-			if (unicode == UnicodeType::UNICODE) {
-				throw InternalException("Statistics mismatch: string value contains unicode, but statistics says it "
-				                        "shouldn't.\nStatistics: %s\nVector: %s",
-				                        ToString(), vector.ToString(count));
-			} else if (unicode == UnicodeType::INVALID) {
-				throw InternalException("Invalid unicode detected in vector: %s", vector.ToString(count));
-			}
-		}
-		if (StringValueComparison((const_data_ptr_t)data, MinValue<idx_t>(len, MAX_STRING_MINMAX_SIZE), min) < 0) {
-			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
-			                        ToString(), vector.ToString(count));
-		}
-		if (StringValueComparison((const_data_ptr_t)data, MinValue<idx_t>(len, MAX_STRING_MINMAX_SIZE), max) > 0) {
-			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
-			                        ToString(), vector.ToString(count));
-		}
-		// LCOV_EXCL_STOP
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-StructStatistics::StructStatistics(LogicalType type_p) : BaseStatistics(move(type_p), StatisticsType::LOCAL_STATS) {
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-	InitializeBase();
-
-	auto &child_types = StructType::GetChildTypes(type);
-	child_stats.resize(child_types.size());
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		child_stats[i] = BaseStatistics::CreateEmpty(child_types[i].second, StatisticsType::LOCAL_STATS);
-	}
-}
-
-void StructStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-
-	auto &other = (const StructStatistics &)other_p;
-	D_ASSERT(other.child_stats.size() == child_stats.size());
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		if (child_stats[i] && other.child_stats[i]) {
-			child_stats[i]->Merge(*other.child_stats[i]);
-		} else {
-			child_stats[i].reset();
-		}
-	}
-}
-
-// LCOV_EXCL_START
-FilterPropagateResult StructStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
-	throw InternalException("Struct zonemaps are not supported yet");
-}
-// LCOV_EXCL_STOP
-
-unique_ptr<BaseStatistics> StructStatistics::Copy() const {
-	auto result = make_unique<StructStatistics>(type);
-	result->CopyBase(*this);
-
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		result->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
-	}
-	return move(result);
-}
-
-void StructStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteField<uint32_t>(child_stats.size());
-	auto &serializer = writer.GetSerializer();
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		serializer.Write<bool>(child_stats[i] ? true : false);
-		if (child_stats[i]) {
-			child_stats[i]->Serialize(serializer);
-		}
-	}
-}
-
-unique_ptr<BaseStatistics> StructStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-	auto result = make_unique<StructStatistics>(move(type));
-	auto &child_types = StructType::GetChildTypes(result->type);
-
-	auto child_type_count = reader.ReadRequired<uint32_t>();
-	if (child_types.size() != child_type_count) {
-		throw InternalException("Struct stats deserialization failure: child count does not match type count!");
-	}
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		auto has_child = source.Read<bool>();
-		if (has_child) {
-			result->child_stats[i] = BaseStatistics::Deserialize(source, child_types[i].second);
-		} else {
-			result->child_stats[i].reset();
-		}
-	}
-	return move(result);
-}
-
-string StructStatistics::ToString() const {
-	string result;
-	result += " {";
-	auto &child_types = StructType::GetChildTypes(type);
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		if (i > 0) {
-			result += ", ";
-		}
-		result += child_types[i].first + ": " + (child_stats[i] ? child_stats[i]->ToString() : "No Stats");
-	}
-	result += "}";
-	result += BaseStatistics::ToString();
-	return result;
-}
-
-void StructStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	BaseStatistics::Verify(vector, sel, count);
-
-	auto &child_entries = StructVector::GetEntries(vector);
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		if (child_stats[i]) {
-			child_stats[i]->Verify(*child_entries[i], sel, count);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-ValidityStatistics::ValidityStatistics(bool has_null, bool has_no_null)
-    : BaseStatistics(LogicalType(LogicalTypeId::VALIDITY), StatisticsType::LOCAL_STATS), has_null(has_null),
-      has_no_null(has_no_null) {
-}
-
-unique_ptr<BaseStatistics> ValidityStatistics::Combine(const unique_ptr<BaseStatistics> &lstats,
-                                                       const unique_ptr<BaseStatistics> &rstats) {
-	if (!lstats && !rstats) {
-		return nullptr;
-	} else if (!lstats) {
-		return rstats->Copy();
-	} else if (!rstats) {
-		return lstats->Copy();
-	} else {
-		auto &l = (ValidityStatistics &)*lstats;
-		auto &r = (ValidityStatistics &)*rstats;
-		return make_unique<ValidityStatistics>(l.has_null || r.has_null, l.has_no_null || r.has_no_null);
-	}
-}
-
-bool ValidityStatistics::IsConstant() const {
-	if (!has_null) {
-		return true;
-	}
-	if (!has_no_null) {
-		return true;
-	}
-	return false;
-}
-
-void ValidityStatistics::Merge(const BaseStatistics &other_p) {
-	auto &other = (ValidityStatistics &)other_p;
-	has_null = has_null || other.has_null;
-	has_no_null = has_no_null || other.has_no_null;
-}
-
-unique_ptr<BaseStatistics> ValidityStatistics::Copy() const {
-	return make_unique<ValidityStatistics>(has_null, has_no_null);
-}
-
-void ValidityStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteField<bool>(has_null);
-	writer.WriteField<bool>(has_no_null);
-}
-
-unique_ptr<ValidityStatistics> ValidityStatistics::Deserialize(FieldReader &reader) {
-	bool has_null = reader.ReadRequired<bool>();
-	bool has_no_null = reader.ReadRequired<bool>();
-	return make_unique<ValidityStatistics>(has_null, has_no_null);
-}
-
-void ValidityStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	if (has_null && has_no_null) {
-		// nothing to verify
-		return;
-	}
-	VectorData vdata;
-	vector.Orrify(count, vdata);
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		bool row_is_valid = vdata.validity.RowIsValid(index);
-		if (row_is_valid && !has_no_null) {
-			throw InternalException(
-			    "Statistics mismatch: vector labeled as having only NULL values, but vector contains valid values: %s",
-			    vector.ToString(count));
-		}
-		if (!row_is_valid && !has_null) {
-			throw InternalException(
-			    "Statistics mismatch: vector labeled as not having NULL values, but vector contains null values: %s",
-			    vector.ToString(count));
-		}
-	}
-}
-
-string ValidityStatistics::ToString() const {
-	auto has_n = has_null ? "true" : "false";
-	auto has_n_n = has_no_null ? "true" : "false";
-	return StringUtil::Format("[Has Null: %s, Has No Null: %s]", has_n, has_n_n);
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-const uint64_t VERSION_NUMBER = 35;
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-StorageLockKey::StorageLockKey(StorageLock &lock, StorageLockType type) : lock(lock), type(type) {
-}
-
-StorageLockKey::~StorageLockKey() {
-	if (type == StorageLockType::EXCLUSIVE) {
-		lock.ReleaseExclusiveLock();
-	} else {
-		D_ASSERT(type == StorageLockType::SHARED);
-		lock.ReleaseSharedLock();
-	}
-}
-
-StorageLock::StorageLock() : read_count(0) {
-}
-
-unique_ptr<StorageLockKey> StorageLock::GetExclusiveLock() {
-	exclusive_lock.lock();
-	while (read_count != 0) {
-	}
-	return make_unique<StorageLockKey>(*this, StorageLockType::EXCLUSIVE);
-}
-
-unique_ptr<StorageLockKey> StorageLock::GetSharedLock() {
-	exclusive_lock.lock();
-	read_count++;
-	exclusive_lock.unlock();
-	return make_unique<StorageLockKey>(*this, StorageLockType::SHARED);
-}
-
-void StorageLock::ReleaseExclusiveLock() {
-	exclusive_lock.unlock();
-}
-
-void StorageLock::ReleaseSharedLock() {
-	read_count--;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-StorageManager::StorageManager(DatabaseInstance &db, string path, bool read_only)
-    : db(db), path(move(path)), wal(db), read_only(read_only) {
-}
-
-StorageManager::~StorageManager() {
-}
-
-StorageManager &StorageManager::GetStorageManager(ClientContext &context) {
-	return StorageManager::GetStorageManager(*context.db);
-}
-
-BufferManager &BufferManager::GetBufferManager(ClientContext &context) {
-	return BufferManager::GetBufferManager(*context.db);
-}
-
-ObjectCache &ObjectCache::GetObjectCache(ClientContext &context) {
-	return context.db->GetObjectCache();
-}
-
-bool ObjectCache::ObjectCacheEnabled(ClientContext &context) {
-	return context.db->config.object_cache_enable;
-}
-
-bool StorageManager::InMemory() {
-	return path.empty() || path == ":memory:";
-}
-
-void StorageManager::Initialize() {
-	bool in_memory = InMemory();
-	if (in_memory && read_only) {
-		throw CatalogException("Cannot launch in-memory database in read-only mode!");
-	}
-	auto &config = DBConfig::GetConfig(db);
-	auto &catalog = Catalog::GetCatalog(db);
-	buffer_manager = make_unique<BufferManager>(db, config.temporary_directory, config.maximum_memory);
-
-	// first initialize the base system catalogs
-	// these are never written to the WAL
-	Connection con(db);
-	con.BeginTransaction();
-
-	// create the default schema
-	CreateSchemaInfo info;
-	info.schema = DEFAULT_SCHEMA;
-	info.internal = true;
-	catalog.CreateSchema(*con.context, &info);
-
-	if (config.initialize_default_database) {
-		// initialize default functions
-		BuiltinFunctions builtin(*con.context, catalog);
-		builtin.Initialize();
-	}
-
-	// commit transactions
-	con.Commit();
-
-	if (!in_memory) {
-		// create or load the database from disk, if not in-memory mode
-		LoadDatabase();
-	} else {
-		block_manager = make_unique<InMemoryBlockManager>();
-	}
-}
-
-void StorageManager::LoadDatabase() {
-	string wal_path = path + ".wal";
-	auto &fs = db.GetFileSystem();
-	auto &config = db.config;
-	bool truncate_wal = false;
-	// first check if the database exists
-	if (!fs.FileExists(path)) {
-		if (read_only) {
-			throw CatalogException("Cannot open database \"%s\" in read-only mode: database does not exist", path);
-		}
-		// check if the WAL exists
-		if (fs.FileExists(wal_path)) {
-			// WAL file exists but database file does not
-			// remove the WAL
-			fs.RemoveFile(wal_path);
-		}
-		// initialize the block manager while creating a new db file
-		block_manager = make_unique<SingleFileBlockManager>(db, path, read_only, true, config.use_direct_io);
-	} else {
-		// initialize the block manager while loading the current db file
-		auto sf_bm = make_unique<SingleFileBlockManager>(db, path, read_only, false, config.use_direct_io);
-		auto sf = sf_bm.get();
-		block_manager = move(sf_bm);
-		sf->LoadFreeList();
-
-		//! Load from storage
-		CheckpointManager checkpointer(db);
-		checkpointer.LoadFromStorage();
-		// check if the WAL file exists
-		if (fs.FileExists(wal_path)) {
-			// replay the WAL
-			truncate_wal = WriteAheadLog::Replay(db, wal_path);
-		}
-	}
-	// initialize the WAL file
-	if (!read_only) {
-		wal.Initialize(wal_path);
-		if (truncate_wal) {
-			wal.Truncate(0);
-		}
-	}
-}
-
-void StorageManager::CreateCheckpoint(bool delete_wal, bool force_checkpoint) {
-	if (InMemory() || read_only || !wal.initialized) {
-		return;
-	}
-	if (wal.GetWALSize() > 0 || db.config.force_checkpoint || force_checkpoint) {
-		// we only need to checkpoint if there is anything in the WAL
-		CheckpointManager checkpointer(db);
-		checkpointer.CreateCheckpoint();
-	}
-	if (delete_wal) {
-		wal.Delete();
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct TransactionVersionOperator {
-	static bool UseInsertedVersion(transaction_t start_time, transaction_t transaction_id, transaction_t id) {
-		return id < start_time || id == transaction_id;
-	}
-
-	static bool UseDeletedVersion(transaction_t start_time, transaction_t transaction_id, transaction_t id) {
-		return !UseInsertedVersion(start_time, transaction_id, id);
-	}
-};
-
-struct CommittedVersionOperator {
-	static bool UseInsertedVersion(transaction_t start_time, transaction_t transaction_id, transaction_t id) {
-		return true;
-	}
-
-	static bool UseDeletedVersion(transaction_t min_start_time, transaction_t min_transaction_id, transaction_t id) {
-		return (id >= min_start_time && id < TRANSACTION_ID_START) || (id >= min_transaction_id);
-	}
-};
-
-static bool UseVersion(Transaction &transaction, transaction_t id) {
-	return TransactionVersionOperator::UseInsertedVersion(transaction.start_time, transaction.transaction_id, id);
-}
-
-unique_ptr<ChunkInfo> ChunkInfo::Deserialize(Deserializer &source) {
-	auto type = source.Read<ChunkInfoType>();
-	switch (type) {
-	case ChunkInfoType::EMPTY_INFO:
-		return nullptr;
-	case ChunkInfoType::CONSTANT_INFO:
-		return ChunkConstantInfo::Deserialize(source);
-	case ChunkInfoType::VECTOR_INFO:
-		return ChunkVectorInfo::Deserialize(source);
-	default:
-		throw SerializationException("Could not deserialize Chunk Info Type: unrecognized type");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Constant info
-//===--------------------------------------------------------------------===//
-ChunkConstantInfo::ChunkConstantInfo(idx_t start)
-    : ChunkInfo(start, ChunkInfoType::CONSTANT_INFO), insert_id(0), delete_id(NOT_DELETED_ID) {
-}
-
-template <class OP>
-idx_t ChunkConstantInfo::TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id,
-                                               SelectionVector &sel_vector, idx_t max_count) {
-	if (OP::UseInsertedVersion(start_time, transaction_id, insert_id) &&
-	    OP::UseDeletedVersion(start_time, transaction_id, delete_id)) {
-		return max_count;
-	}
-	return 0;
-}
-
-idx_t ChunkConstantInfo::GetSelVector(Transaction &transaction, SelectionVector &sel_vector, idx_t max_count) {
-	return TemplatedGetSelVector<TransactionVersionOperator>(transaction.start_time, transaction.transaction_id,
-	                                                         sel_vector, max_count);
-}
-
-idx_t ChunkConstantInfo::GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-                                               SelectionVector &sel_vector, idx_t max_count) {
-	return TemplatedGetSelVector<CommittedVersionOperator>(min_start_id, min_transaction_id, sel_vector, max_count);
-}
-
-bool ChunkConstantInfo::Fetch(Transaction &transaction, row_t row) {
-	return UseVersion(transaction, insert_id) && !UseVersion(transaction, delete_id);
-}
-
-void ChunkConstantInfo::CommitAppend(transaction_t commit_id, idx_t start, idx_t end) {
-	D_ASSERT(start == 0 && end == STANDARD_VECTOR_SIZE);
-	insert_id = commit_id;
-}
-
-void ChunkConstantInfo::Serialize(Serializer &serializer) {
-	// we only need to write this node if any tuple deletions have been committed
-	bool is_deleted = insert_id >= TRANSACTION_ID_START || delete_id < TRANSACTION_ID_START;
-	if (!is_deleted) {
-		serializer.Write<ChunkInfoType>(ChunkInfoType::EMPTY_INFO);
-		return;
-	}
-	serializer.Write<ChunkInfoType>(type);
-	serializer.Write<idx_t>(start);
-}
-
-unique_ptr<ChunkInfo> ChunkConstantInfo::Deserialize(Deserializer &source) {
-	auto start = source.Read<idx_t>();
-
-	auto info = make_unique<ChunkConstantInfo>(start);
-	info->insert_id = 0;
-	info->delete_id = 0;
-	return move(info);
-}
-
-//===--------------------------------------------------------------------===//
-// Vector info
-//===--------------------------------------------------------------------===//
-ChunkVectorInfo::ChunkVectorInfo(idx_t start)
-    : ChunkInfo(start, ChunkInfoType::VECTOR_INFO), insert_id(0), same_inserted_id(true), any_deleted(false) {
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-		inserted[i] = 0;
-		deleted[i] = NOT_DELETED_ID;
-	}
-}
-
-template <class OP>
-idx_t ChunkVectorInfo::TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id,
-                                             SelectionVector &sel_vector, idx_t max_count) {
-	idx_t count = 0;
-	if (same_inserted_id && !any_deleted) {
-		// all tuples have the same inserted id: and no tuples were deleted
-		if (OP::UseInsertedVersion(start_time, transaction_id, insert_id)) {
-			return max_count;
-		} else {
-			return 0;
-		}
-	} else if (same_inserted_id) {
-		if (!OP::UseInsertedVersion(start_time, transaction_id, insert_id)) {
-			return 0;
-		}
-		// have to check deleted flag
-		for (idx_t i = 0; i < max_count; i++) {
-			if (OP::UseDeletedVersion(start_time, transaction_id, deleted[i])) {
-				sel_vector.set_index(count++, i);
-			}
-		}
-	} else if (!any_deleted) {
-		// have to check inserted flag
-		for (idx_t i = 0; i < max_count; i++) {
-			if (OP::UseInsertedVersion(start_time, transaction_id, inserted[i])) {
-				sel_vector.set_index(count++, i);
-			}
-		}
-	} else {
-		// have to check both flags
-		for (idx_t i = 0; i < max_count; i++) {
-			if (OP::UseInsertedVersion(start_time, transaction_id, inserted[i]) &&
-			    OP::UseDeletedVersion(start_time, transaction_id, deleted[i])) {
-				sel_vector.set_index(count++, i);
-			}
-		}
-	}
-	return count;
-}
-
-idx_t ChunkVectorInfo::GetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-                                    idx_t max_count) {
-	return TemplatedGetSelVector<TransactionVersionOperator>(start_time, transaction_id, sel_vector, max_count);
-}
-
-idx_t ChunkVectorInfo::GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-                                             SelectionVector &sel_vector, idx_t max_count) {
-	return TemplatedGetSelVector<CommittedVersionOperator>(min_start_id, min_transaction_id, sel_vector, max_count);
-}
-
-idx_t ChunkVectorInfo::GetSelVector(Transaction &transaction, SelectionVector &sel_vector, idx_t max_count) {
-	return GetSelVector(transaction.start_time, transaction.transaction_id, sel_vector, max_count);
-}
-
-bool ChunkVectorInfo::Fetch(Transaction &transaction, row_t row) {
-	return UseVersion(transaction, inserted[row]) && !UseVersion(transaction, deleted[row]);
-}
-
-idx_t ChunkVectorInfo::Delete(Transaction &transaction, row_t rows[], idx_t count) {
-	any_deleted = true;
-
-	idx_t deleted_tuples = 0;
-	for (idx_t i = 0; i < count; i++) {
-		if (deleted[rows[i]] == transaction.transaction_id) {
-			continue;
-		}
-		// first check the chunk for conflicts
-		if (deleted[rows[i]] != NOT_DELETED_ID) {
-			// tuple was already deleted by another transaction
-			throw TransactionException("Conflict on tuple deletion!");
-		}
-		if (inserted[rows[i]] >= TRANSACTION_ID_START) {
-			throw TransactionException("Deleting non-committed tuples is not supported (for now...)");
-		}
-		// after verifying that there are no conflicts we mark the tuple as deleted
-		deleted[rows[i]] = transaction.transaction_id;
-		deleted_tuples++;
-	}
-	return deleted_tuples;
-}
-
-void ChunkVectorInfo::CommitDelete(transaction_t commit_id, row_t rows[], idx_t count) {
-	for (idx_t i = 0; i < count; i++) {
-		deleted[rows[i]] = commit_id;
-	}
-}
-
-void ChunkVectorInfo::Append(idx_t start, idx_t end, transaction_t commit_id) {
-	if (start == 0) {
-		insert_id = commit_id;
-	} else if (insert_id != commit_id) {
-		same_inserted_id = false;
-		insert_id = NOT_DELETED_ID;
-	}
-	for (idx_t i = start; i < end; i++) {
-		inserted[i] = commit_id;
-	}
-}
-
-void ChunkVectorInfo::CommitAppend(transaction_t commit_id, idx_t start, idx_t end) {
-	if (same_inserted_id) {
-		insert_id = commit_id;
-	}
-	for (idx_t i = start; i < end; i++) {
-		inserted[i] = commit_id;
-	}
-}
-
-void ChunkVectorInfo::Serialize(Serializer &serializer) {
-	SelectionVector sel(STANDARD_VECTOR_SIZE);
-	transaction_t start_time = TRANSACTION_ID_START - 1;
-	transaction_t transaction_id = DConstants::INVALID_INDEX;
-	idx_t count = GetSelVector(start_time, transaction_id, sel, STANDARD_VECTOR_SIZE);
-	if (count == STANDARD_VECTOR_SIZE) {
-		// nothing is deleted: skip writing anything
-		serializer.Write<ChunkInfoType>(ChunkInfoType::EMPTY_INFO);
-		return;
-	}
-	if (count == 0) {
-		// everything is deleted: write a constant vector
-		serializer.Write<ChunkInfoType>(ChunkInfoType::CONSTANT_INFO);
-		serializer.Write<idx_t>(start);
-		return;
-	}
-	// write a boolean vector
-	serializer.Write<ChunkInfoType>(ChunkInfoType::VECTOR_INFO);
-	serializer.Write<idx_t>(start);
-	bool deleted_tuples[STANDARD_VECTOR_SIZE];
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-		deleted_tuples[i] = true;
-	}
-	for (idx_t i = 0; i < count; i++) {
-		deleted_tuples[sel.get_index(i)] = false;
-	}
-	serializer.WriteData((data_ptr_t)deleted_tuples, sizeof(bool) * STANDARD_VECTOR_SIZE);
-}
-
-unique_ptr<ChunkInfo> ChunkVectorInfo::Deserialize(Deserializer &source) {
-	auto start = source.Read<idx_t>();
-
-	auto result = make_unique<ChunkVectorInfo>(start);
-	result->any_deleted = true;
-	bool deleted_tuples[STANDARD_VECTOR_SIZE];
-	source.ReadData((data_ptr_t)deleted_tuples, sizeof(bool) * STANDARD_VECTOR_SIZE);
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-		if (deleted_tuples[i]) {
-			result->deleted[i] = 0;
-		}
-	}
-	return move(result);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-ColumnCheckpointState::ColumnCheckpointState(RowGroup &row_group, ColumnData &column_data, TableDataWriter &writer)
-    : row_group(row_group), column_data(column_data), writer(writer) {
-}
-
-ColumnCheckpointState::~ColumnCheckpointState() {
-}
-
-unique_ptr<BaseStatistics> ColumnCheckpointState::GetStatistics() {
-	D_ASSERT(global_stats);
-	return move(global_stats);
-}
-
-void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, idx_t segment_size) {
-	D_ASSERT(segment_size <= Storage::BLOCK_SIZE);
-	auto tuple_count = segment->count.load();
-	if (tuple_count == 0) { // LCOV_EXCL_START
-		return;
-	} // LCOV_EXCL_STOP
-
-	// merge the segment stats into the global stats
-	global_stats->Merge(*segment->stats.statistics);
-
-	// get the buffer of the segment and pin it
-	auto &db = column_data.GetDatabase();
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	auto &block_manager = BlockManager::GetBlockManager(db);
-	auto &checkpoint_manager = writer.GetCheckpointManager();
-
-	bool block_is_constant = segment->stats.statistics->IsConstant();
-
-	block_id_t block_id = INVALID_BLOCK;
-	uint32_t offset_in_block = 0;
-	bool need_to_write = true;
-	PartialBlock *partial_block = nullptr;
-	unique_ptr<PartialBlock> owned_partial_block;
-	if (!block_is_constant) {
-		// non-constant block
-		// if the block is less than 80% full, we consider it a "partial block"
-		// which means we will try to fit it with other blocks
-		if (segment_size <= CheckpointManager::PARTIAL_BLOCK_THRESHOLD) {
-			// the block is a partial block
-			// check if there is a partial block available we can write to
-			if (checkpoint_manager.GetPartialBlock(segment.get(), segment_size, block_id, offset_in_block,
-			                                       partial_block, owned_partial_block)) {
-				//! there is! increase the reference count of this block
-				block_manager.IncreaseBlockReferenceCount(block_id);
-			} else {
-				// there isn't: generate a new block for this segment
-				block_id = block_manager.GetFreeBlockId();
-				offset_in_block = 0;
-				need_to_write = false;
-				// now register this block as a partial block
-				checkpoint_manager.RegisterPartialBlock(segment.get(), segment_size, block_id);
-			}
-		} else {
-			// full block: get a free block to write to
-			block_id = block_manager.GetFreeBlockId();
-			offset_in_block = 0;
-		}
-	} else {
-		// constant block: no need to write anything to disk besides the stats
-		// set up the compression function to constant
-		auto &config = DBConfig::GetConfig(db);
-		segment->function =
-		    config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, segment->type.InternalType());
-	}
-
-	// construct the data pointer
-	DataPointer data_pointer;
-	data_pointer.block_pointer.block_id = block_id;
-	data_pointer.block_pointer.offset = offset_in_block;
-	data_pointer.row_start = row_group.start;
-	if (!data_pointers.empty()) {
-		auto &last_pointer = data_pointers.back();
-		data_pointer.row_start = last_pointer.row_start + last_pointer.tuple_count;
-	}
-	data_pointer.tuple_count = tuple_count;
-	data_pointer.compression_type = segment->function->type;
-	data_pointer.statistics = segment->stats.statistics->Copy();
-
-	if (need_to_write) {
-		if (partial_block) {
-			// pin the current block
-			auto old_handle = buffer_manager.Pin(segment->block);
-			// pin the new block
-			auto new_handle = buffer_manager.Pin(partial_block->block);
-			// memcpy the contents of the old block to the new block
-			memcpy(new_handle.Ptr() + offset_in_block, old_handle.Ptr(), segment_size);
-		} else {
-			// convert the segment into a persistent segment that points to this block
-			segment->ConvertToPersistent(block_id);
-		}
-	}
-	if (owned_partial_block) {
-		// the partial block has become full: write it to disk
-		owned_partial_block->FlushToDisk(db);
-	}
-
-	// append the segment to the new segment tree
-	new_tree.AppendSegment(move(segment));
-	data_pointers.push_back(move(data_pointer));
-}
-
-void ColumnCheckpointState::FlushToDisk() {
-	auto &meta_writer = writer.GetMetaWriter();
-
-	meta_writer.Write<idx_t>(data_pointers.size());
-	// then write the data pointers themselves
-	for (idx_t k = 0; k < data_pointers.size(); k++) {
-		auto &data_pointer = data_pointers[k];
-		meta_writer.Write<idx_t>(data_pointer.row_start);
-		meta_writer.Write<idx_t>(data_pointer.tuple_count);
-		meta_writer.Write<block_id_t>(data_pointer.block_pointer.block_id);
-		meta_writer.Write<uint32_t>(data_pointer.block_pointer.offset);
-		meta_writer.Write<CompressionType>(data_pointer.compression_type);
-		data_pointer.statistics->Serialize(meta_writer);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-ColumnData::ColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type, ColumnData *parent)
-    : info(info), column_index(column_index), start(start_row), type(move(type)), parent(parent) {
-}
-
-ColumnData::~ColumnData() {
-}
-
-DatabaseInstance &ColumnData::GetDatabase() const {
-	return info.db;
-}
-
-DataTableInfo &ColumnData::GetTableInfo() const {
-	return info;
-}
-
-const LogicalType &ColumnData::RootType() const {
-	if (parent) {
-		return parent->RootType();
-	}
-	return type;
-}
-
-idx_t ColumnData::GetMaxEntry() {
-	auto last_segment = data.GetLastSegment();
-	return last_segment ? last_segment->start + last_segment->count : start;
-}
-
-void ColumnData::InitializeScan(ColumnScanState &state) {
-	state.current = (ColumnSegment *)data.GetRootSegment();
-	state.row_index = state.current ? state.current->start : 0;
-	state.internal_index = state.row_index;
-	state.initialized = false;
-}
-
-void ColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	state.current = (ColumnSegment *)data.GetSegment(row_idx);
-	state.row_index = row_idx;
-	state.internal_index = state.current->start;
-	state.initialized = false;
-}
-
-idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remaining) {
-	if (!state.initialized) {
-		D_ASSERT(state.current);
-		state.current->InitializeScan(state);
-		state.internal_index = state.current->start;
-		state.initialized = true;
-	}
-	D_ASSERT(state.internal_index <= state.row_index);
-	if (state.internal_index < state.row_index) {
-		state.current->Skip(state);
-	}
-	D_ASSERT(state.current->type == type);
-	idx_t initial_remaining = remaining;
-	while (remaining > 0) {
-		D_ASSERT(state.row_index >= state.current->start &&
-		         state.row_index <= state.current->start + state.current->count);
-		idx_t scan_count = MinValue<idx_t>(remaining, state.current->start + state.current->count - state.row_index);
-		idx_t result_offset = initial_remaining - remaining;
-		state.current->Scan(state, scan_count, result, result_offset, scan_count == initial_remaining);
-
-		state.row_index += scan_count;
-		remaining -= scan_count;
-		if (remaining > 0) {
-			if (!state.current->next) {
-				break;
-			}
-			state.current = (ColumnSegment *)state.current->next.get();
-			state.current->InitializeScan(state);
-			state.segment_checked = false;
-			D_ASSERT(state.row_index >= state.current->start &&
-			         state.row_index <= state.current->start + state.current->count);
-		}
-	}
-	state.internal_index = state.row_index;
-	return initial_remaining - remaining;
-}
-
-template <bool SCAN_COMMITTED, bool ALLOW_UPDATES>
-idx_t ColumnData::ScanVector(Transaction *transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
-	auto scan_count = ScanVector(state, result, STANDARD_VECTOR_SIZE);
-
-	lock_guard<mutex> update_guard(update_lock);
-	if (updates) {
-		if (!ALLOW_UPDATES && updates->HasUncommittedUpdates(vector_index)) {
-			throw TransactionException("Cannot create index with outstanding updates");
-		}
-		result.Normalify(scan_count);
-		if (SCAN_COMMITTED) {
-			updates->FetchCommitted(vector_index, result);
-		} else {
-			D_ASSERT(transaction);
-			updates->FetchUpdates(*transaction, vector_index, result);
-		}
-	}
-	return scan_count;
-}
-
-template idx_t ColumnData::ScanVector<false, false>(Transaction *transaction, idx_t vector_index,
-                                                    ColumnScanState &state, Vector &result);
-template idx_t ColumnData::ScanVector<true, false>(Transaction *transaction, idx_t vector_index, ColumnScanState &state,
-                                                   Vector &result);
-template idx_t ColumnData::ScanVector<false, true>(Transaction *transaction, idx_t vector_index, ColumnScanState &state,
-                                                   Vector &result);
-template idx_t ColumnData::ScanVector<true, true>(Transaction *transaction, idx_t vector_index, ColumnScanState &state,
-                                                  Vector &result);
-
-idx_t ColumnData::Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
-	return ScanVector<false, true>(&transaction, vector_index, state, result);
-}
-
-idx_t ColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) {
-	if (allow_updates) {
-		return ScanVector<true, true>(nullptr, vector_index, state, result);
-	} else {
-		return ScanVector<true, false>(nullptr, vector_index, state, result);
-	}
-}
-
-void ColumnData::ScanCommittedRange(idx_t row_group_start, idx_t offset_in_row_group, idx_t count, Vector &result) {
-	ColumnScanState child_state;
-	InitializeScanWithOffset(child_state, row_group_start + offset_in_row_group);
-	auto scan_count = ScanVector(child_state, result, count);
-	if (updates) {
-		result.Normalify(scan_count);
-		updates->FetchCommittedRange(offset_in_row_group, count, result);
-	}
-}
-
-idx_t ColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) {
-	if (count == 0) {
-		return 0;
-	}
-	// ScanCount can only be used if there are no updates
-	D_ASSERT(!updates);
-	return ScanVector(state, result, count);
-}
-
-void ColumnData::Select(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                        SelectionVector &sel, idx_t &count, const TableFilter &filter) {
-	idx_t scan_count = Scan(transaction, vector_index, state, result);
-	result.Normalify(scan_count);
-	ColumnSegment::FilterSelection(sel, result, filter, count, FlatVector::Validity(result));
-}
-
-void ColumnData::FilterScan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                            SelectionVector &sel, idx_t count) {
-	Scan(transaction, vector_index, state, result);
-	result.Slice(sel, count);
-}
-
-void ColumnData::FilterScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, SelectionVector &sel,
-                                     idx_t count, bool allow_updates) {
-	ScanCommitted(vector_index, state, result, allow_updates);
-	result.Slice(sel, count);
-}
-
-void ColumnData::Skip(ColumnScanState &state, idx_t count) {
-	state.Next(count);
-}
-
-void ColumnScanState::NextInternal(idx_t count) {
-	if (!current) {
-		//! There is no column segment
-		return;
-	}
-	row_index += count;
-	while (row_index >= current->start + current->count) {
-		current = (ColumnSegment *)current->next.get();
-		initialized = false;
-		segment_checked = false;
-		if (!current) {
-			break;
-		}
-	}
-	D_ASSERT(!current || (row_index >= current->start && row_index < current->start + current->count));
-}
-
-void ColumnScanState::Next(idx_t count) {
-	NextInternal(count);
-	for (auto &child_state : child_states) {
-		child_state.Next(count);
-	}
-}
-
-void ColumnScanState::NextVector() {
-	Next(STANDARD_VECTOR_SIZE);
-}
-
-void ColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) {
-	VectorData vdata;
-	vector.Orrify(count, vdata);
-	AppendData(stats, state, vdata, count);
-}
-
-void ColumnData::InitializeAppend(ColumnAppendState &state) {
-	lock_guard<mutex> tree_lock(data.node_lock);
-	if (data.nodes.empty()) {
-		// no segments yet, append an empty segment
-		AppendTransientSegment(start);
-	}
-	auto segment = (ColumnSegment *)data.GetLastSegment();
-	if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
-		// no transient segments yet
-		auto total_rows = segment->start + segment->count;
-		AppendTransientSegment(total_rows);
-		state.current = (ColumnSegment *)data.GetLastSegment();
-	} else {
-		state.current = (ColumnSegment *)segment;
-	}
-
-	D_ASSERT(state.current->segment_type == ColumnSegmentType::TRANSIENT);
-	state.current->InitializeAppend(state);
-}
-
-void ColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, VectorData &vdata, idx_t count) {
-	idx_t offset = 0;
-	while (true) {
-		// append the data from the vector
-		idx_t copied_elements = state.current->Append(state, vdata, offset, count);
-		stats.Merge(*state.current->stats.statistics);
-		if (copied_elements == count) {
-			// finished copying everything
-			break;
-		}
-
-		// we couldn't fit everything we wanted in the current column segment, create a new one
-		{
-			lock_guard<mutex> tree_lock(data.node_lock);
-			AppendTransientSegment(state.current->start + state.current->count);
-			state.current = (ColumnSegment *)data.GetLastSegment();
-			state.current->InitializeAppend(state);
-		}
-		offset += copied_elements;
-		count -= copied_elements;
-	}
-}
-
-void ColumnData::RevertAppend(row_t start_row) {
-	lock_guard<mutex> tree_lock(data.node_lock);
-	// check if this row is in the segment tree at all
-	if (idx_t(start_row) >= data.nodes.back().row_start + data.nodes.back().node->count) {
-		// the start row is equal to the final portion of the column data: nothing was ever appended here
-		D_ASSERT(idx_t(start_row) == data.nodes.back().row_start + data.nodes.back().node->count);
-		return;
-	}
-	// find the segment index that the current row belongs to
-	idx_t segment_index = data.GetSegmentIndex(start_row);
-	auto segment = data.nodes[segment_index].node;
-	auto &transient = (ColumnSegment &)*segment;
-	D_ASSERT(transient.segment_type == ColumnSegmentType::TRANSIENT);
-
-	// remove any segments AFTER this segment: they should be deleted entirely
-	if (segment_index < data.nodes.size() - 1) {
-		data.nodes.erase(data.nodes.begin() + segment_index + 1, data.nodes.end());
-	}
-	segment->next = nullptr;
-	transient.RevertAppend(start_row);
-}
-
-idx_t ColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	D_ASSERT(row_id >= 0);
-	D_ASSERT(idx_t(row_id) >= start);
-	// perform the fetch within the segment
-	state.row_index = start + ((row_id - start) / STANDARD_VECTOR_SIZE * STANDARD_VECTOR_SIZE);
-	state.current = (ColumnSegment *)data.GetSegment(state.row_index);
-	state.internal_index = state.current->start;
-	return ScanVector(state, result, STANDARD_VECTOR_SIZE);
-}
-
-void ColumnData::FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                          idx_t result_idx) {
-	auto segment = (ColumnSegment *)data.GetSegment(row_id);
-
-	// now perform the fetch within the segment
-	segment->FetchRow(state, row_id, result, result_idx);
-	// merge any updates made to this row
-	lock_guard<mutex> update_guard(update_lock);
-	if (updates) {
-		updates->FetchRow(transaction, row_id, result, result_idx);
-	}
-}
-
-void ColumnData::Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                        idx_t update_count) {
-	lock_guard<mutex> update_guard(update_lock);
-	if (!updates) {
-		updates = make_unique<UpdateSegment>(*this);
-	}
-	Vector base_vector(type);
-	ColumnScanState state;
-	auto fetch_count = Fetch(state, row_ids[0], base_vector);
-
-	base_vector.Normalify(fetch_count);
-	updates->Update(transaction, column_index, update_vector, row_ids, update_count, base_vector);
-}
-
-void ColumnData::UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
-                              row_t *row_ids, idx_t update_count, idx_t depth) {
-	// this method should only be called at the end of the path in the base column case
-	D_ASSERT(depth >= column_path.size());
-	ColumnData::Update(transaction, column_path[0], update_vector, row_ids, update_count);
-}
-
-unique_ptr<BaseStatistics> ColumnData::GetUpdateStatistics() {
-	lock_guard<mutex> update_guard(update_lock);
-	return updates ? updates->GetStatistics() : nullptr;
-}
-
-void ColumnData::AppendTransientSegment(idx_t start_row) {
-	auto new_segment = ColumnSegment::CreateTransientSegment(GetDatabase(), type, start_row);
-	data.AppendSegment(move(new_segment));
-}
-
-void ColumnData::CommitDropColumn() {
-	auto &block_manager = BlockManager::GetBlockManager(GetDatabase());
-	auto segment = (ColumnSegment *)data.GetRootSegment();
-	while (segment) {
-		if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
-			auto block_id = segment->GetBlockId();
-			if (block_id != INVALID_BLOCK) {
-				block_manager.MarkBlockAsModified(block_id);
-			}
-		}
-		segment = (ColumnSegment *)segment->next.get();
-	}
-}
-
-unique_ptr<ColumnCheckpointState> ColumnData::CreateCheckpointState(RowGroup &row_group, TableDataWriter &writer) {
-	return make_unique<ColumnCheckpointState>(row_group, *this, writer);
-}
-
-void ColumnData::CheckpointScan(ColumnSegment *segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
-                                Vector &scan_vector) {
-	segment->Scan(state, count, scan_vector, 0, true);
-	if (updates) {
-		scan_vector.Normalify(count);
-		updates->FetchCommittedRange(state.row_index - row_group_start, count, scan_vector);
-	}
-}
-
-unique_ptr<ColumnCheckpointState> ColumnData::Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-                                                         ColumnCheckpointInfo &checkpoint_info) {
-	// scan the segments of the column data
-	// set up the checkpoint state
-	auto checkpoint_state = CreateCheckpointState(row_group, writer);
-	checkpoint_state->global_stats = BaseStatistics::CreateEmpty(type, StatisticsType::LOCAL_STATS);
-
-	if (!data.root_node) {
-		// empty table: flush the empty list
-		return checkpoint_state;
-	}
-	lock_guard<mutex> update_guard(update_lock);
-
-	ColumnDataCheckpointer checkpointer(*this, row_group, *checkpoint_state, checkpoint_info);
-	checkpointer.Checkpoint(move(data.root_node));
-
-	// replace the old tree with the new one
-	data.Replace(checkpoint_state->new_tree);
-
-	return checkpoint_state;
-}
-
-void ColumnData::DeserializeColumn(Deserializer &source) {
-	// load the data pointers for the column
-	idx_t data_pointer_count = source.Read<idx_t>();
-	for (idx_t data_ptr = 0; data_ptr < data_pointer_count; data_ptr++) {
-		// read the data pointer
-		DataPointer data_pointer;
-		data_pointer.row_start = source.Read<idx_t>();
-		data_pointer.tuple_count = source.Read<idx_t>();
-		data_pointer.block_pointer.block_id = source.Read<block_id_t>();
-		data_pointer.block_pointer.offset = source.Read<uint32_t>();
-		data_pointer.compression_type = source.Read<CompressionType>();
-		data_pointer.statistics = BaseStatistics::Deserialize(source, type);
-
-		// create a persistent segment
-		auto segment = ColumnSegment::CreatePersistentSegment(
-		    GetDatabase(), data_pointer.block_pointer.block_id, data_pointer.block_pointer.offset, type,
-		    data_pointer.row_start, data_pointer.tuple_count, data_pointer.compression_type,
-		    move(data_pointer.statistics));
-		data.AppendSegment(move(segment));
-	}
-}
-
-shared_ptr<ColumnData> ColumnData::Deserialize(DataTableInfo &info, idx_t column_index, idx_t start_row,
-                                               Deserializer &source, const LogicalType &type, ColumnData *parent) {
-	auto entry = ColumnData::CreateColumn(info, column_index, start_row, type, parent);
-	entry->DeserializeColumn(source);
-	return entry;
-}
-
-void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) {
-	D_ASSERT(!col_path.empty());
-
-	// convert the column path to a string
-	string col_path_str = "[";
-	for (idx_t i = 0; i < col_path.size(); i++) {
-		if (i > 0) {
-			col_path_str += ", ";
-		}
-		col_path_str += to_string(col_path[i]);
-	}
-	col_path_str += "]";
-
-	// iterate over the segments
-	idx_t segment_idx = 0;
-	auto segment = (ColumnSegment *)data.GetRootSegment();
-	while (segment) {
-		vector<Value> column_info;
-		// row_group_id
-		column_info.push_back(Value::BIGINT(row_group_index));
-		// column_id
-		column_info.push_back(Value::BIGINT(col_path[0]));
-		// column_path
-		column_info.emplace_back(col_path_str);
-		// segment_id
-		column_info.push_back(Value::BIGINT(segment_idx));
-		// segment_type
-		column_info.emplace_back(type.ToString());
-		// start
-		column_info.push_back(Value::BIGINT(segment->start));
-		// count
-		column_info.push_back(Value::BIGINT(segment->count));
-		// compression
-		column_info.emplace_back(CompressionTypeToString(segment->function->type));
-		// stats
-		column_info.emplace_back(segment->stats.statistics ? segment->stats.statistics->ToString()
-		                                                   : string("No Stats"));
-		// has_updates
-		column_info.push_back(Value::BOOLEAN(updates ? true : false));
-		// persistent
-		// block_id
-		// block_offset
-		if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
-			column_info.push_back(Value::BOOLEAN(true));
-			column_info.push_back(Value::BIGINT(segment->GetBlockId()));
-			column_info.push_back(Value::BIGINT(segment->GetBlockOffset()));
-		} else {
-			column_info.push_back(Value::BOOLEAN(false));
-			column_info.emplace_back();
-			column_info.emplace_back();
-		}
-
-		result.push_back(move(column_info));
-
-		segment_idx++;
-		segment = (ColumnSegment *)segment->next.get();
-	}
-}
-
-void ColumnData::Verify(RowGroup &parent) {
-#ifdef DEBUG
-	D_ASSERT(this->start == parent.start);
-	auto root = data.GetRootSegment();
-	if (root) {
-		D_ASSERT(root != nullptr);
-		D_ASSERT(root->start == this->start);
-		idx_t prev_end = root->start;
-		while (root) {
-			D_ASSERT(prev_end == root->start);
-			prev_end = root->start + root->count;
-			if (!root->next) {
-				D_ASSERT(prev_end == parent.start + parent.count);
-			}
-			root = root->next.get();
-		}
-	} else {
-		if (type.InternalType() != PhysicalType::STRUCT) {
-			D_ASSERT(parent.count == 0);
-		}
-	}
-#endif
-}
-
-template <class RET, class OP>
-static RET CreateColumnInternal(DataTableInfo &info, idx_t column_index, idx_t start_row, const LogicalType &type,
-                                ColumnData *parent) {
-	if (type.InternalType() == PhysicalType::STRUCT) {
-		return OP::template Create<StructColumnData>(info, column_index, start_row, type, parent);
-	} else if (type.InternalType() == PhysicalType::LIST) {
-		return OP::template Create<ListColumnData>(info, column_index, start_row, type, parent);
-	} else if (type.id() == LogicalTypeId::VALIDITY) {
-		return OP::template Create<ValidityColumnData>(info, column_index, start_row, parent);
-	}
-	return OP::template Create<StandardColumnData>(info, column_index, start_row, type, parent);
-}
-
-shared_ptr<ColumnData> ColumnData::CreateColumn(DataTableInfo &info, idx_t column_index, idx_t start_row,
-                                                const LogicalType &type, ColumnData *parent) {
-	return CreateColumnInternal<shared_ptr<ColumnData>, SharedConstructor>(info, column_index, start_row, type, parent);
-}
-
-unique_ptr<ColumnData> ColumnData::CreateColumnUnique(DataTableInfo &info, idx_t column_index, idx_t start_row,
-                                                      const LogicalType &type, ColumnData *parent) {
-	return CreateColumnInternal<unique_ptr<ColumnData>, UniqueConstructor>(info, column_index, start_row, type, parent);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-ColumnDataCheckpointer::ColumnDataCheckpointer(ColumnData &col_data_p, RowGroup &row_group_p,
-                                               ColumnCheckpointState &state_p, ColumnCheckpointInfo &checkpoint_info_p)
-    : col_data(col_data_p), row_group(row_group_p), state(state_p),
-      is_validity(GetType().id() == LogicalTypeId::VALIDITY),
-      intermediate(is_validity ? LogicalType::BOOLEAN : GetType(), true, is_validity),
-      checkpoint_info(checkpoint_info_p) {
-	auto &config = DBConfig::GetConfig(GetDatabase());
-	compression_functions = config.GetCompressionFunctions(GetType().InternalType());
-}
-
-DatabaseInstance &ColumnDataCheckpointer::GetDatabase() {
-	return col_data.GetDatabase();
-}
-
-const LogicalType &ColumnDataCheckpointer::GetType() const {
-	return col_data.type;
-}
-
-ColumnData &ColumnDataCheckpointer::GetColumnData() {
-	return col_data;
-}
-
-RowGroup &ColumnDataCheckpointer::GetRowGroup() {
-	return row_group;
-}
-
-ColumnCheckpointState &ColumnDataCheckpointer::GetCheckpointState() {
-	return state;
-}
-
-void ColumnDataCheckpointer::ScanSegments(const std::function<void(Vector &, idx_t)> &callback) {
-	Vector scan_vector(intermediate.GetType(), nullptr);
-	for (auto segment = (ColumnSegment *)owned_segment.get(); segment; segment = (ColumnSegment *)segment->next.get()) {
-		ColumnScanState scan_state;
-		scan_state.current = segment;
-		segment->InitializeScan(scan_state);
-
-		for (idx_t base_row_index = 0; base_row_index < segment->count; base_row_index += STANDARD_VECTOR_SIZE) {
-			scan_vector.Reference(intermediate);
-
-			idx_t count = MinValue<idx_t>(segment->count - base_row_index, STANDARD_VECTOR_SIZE);
-			scan_state.row_index = segment->start + base_row_index;
-
-			col_data.CheckpointScan(segment, scan_state, row_group.start, count, scan_vector);
-
-			callback(scan_vector, count);
-		}
-	}
-}
-
-void ForceCompression(vector<CompressionFunction *> &compression_functions, CompressionType compression_type) {
-	// On of the force_compression flags has been set
-	// check if this compression method is available
-	bool found = false;
-	for (idx_t i = 0; i < compression_functions.size(); i++) {
-		if (compression_functions[i]->type == compression_type) {
-			found = true;
-			break;
-		}
-	}
-	if (found) {
-		// the force_compression method is available
-		// clear all other compression methods
-		for (idx_t i = 0; i < compression_functions.size(); i++) {
-			if (compression_functions[i]->type != compression_type) {
-				compression_functions[i] = nullptr;
-			}
-		}
-	}
-}
-
-unique_ptr<AnalyzeState> ColumnDataCheckpointer::DetectBestCompressionMethod(idx_t &compression_idx) {
-	D_ASSERT(!compression_functions.empty());
-	auto &config = DBConfig::GetConfig(GetDatabase());
-
-	auto compression_type = checkpoint_info.compression_type;
-	if (compression_type != CompressionType::COMPRESSION_AUTO) {
-		ForceCompression(compression_functions, compression_type);
-	}
-	if (compression_type == CompressionType::COMPRESSION_AUTO &&
-	    config.force_compression != CompressionType::COMPRESSION_AUTO) {
-		ForceCompression(compression_functions, config.force_compression);
-	}
-	// set up the analyze states for each compression method
-	vector<unique_ptr<AnalyzeState>> analyze_states;
-	analyze_states.reserve(compression_functions.size());
-	for (idx_t i = 0; i < compression_functions.size(); i++) {
-		if (!compression_functions[i]) {
-			analyze_states.push_back(nullptr);
-			continue;
-		}
-		analyze_states.push_back(compression_functions[i]->init_analyze(col_data, col_data.type.InternalType()));
-	}
-
-	// scan over all the segments and run the analyze step
-	ScanSegments([&](Vector &scan_vector, idx_t count) {
-		for (idx_t i = 0; i < compression_functions.size(); i++) {
-			if (!compression_functions[i]) {
-				continue;
-			}
-			auto success = compression_functions[i]->analyze(*analyze_states[i], scan_vector, count);
-			if (!success) {
-				// could not use this compression function on this data set
-				// erase it
-				compression_functions[i] = nullptr;
-				analyze_states[i].reset();
-			}
-		}
-	});
-
-	// now that we have passed over all the data, we need to figure out the best method
-	// we do this using the final_analyze method
-	unique_ptr<AnalyzeState> state;
-	compression_idx = DConstants::INVALID_INDEX;
-	idx_t best_score = NumericLimits<idx_t>::Maximum();
-	for (idx_t i = 0; i < compression_functions.size(); i++) {
-		if (!compression_functions[i]) {
-			continue;
-		}
-		auto score = compression_functions[i]->final_analyze(*analyze_states[i]);
-		if (score < best_score) {
-			compression_idx = i;
-			best_score = score;
-			state = move(analyze_states[i]);
-		}
-	}
-	return state;
-}
-
-void ColumnDataCheckpointer::WriteToDisk() {
-	// there were changes or transient segments
-	// we need to rewrite the column segments to disk
-
-	// first we check the current segments
-	// if there are any persistent segments, we will mark their old block ids as modified
-	// since the segments will be rewritten their old on disk data is no longer required
-	auto &block_manager = BlockManager::GetBlockManager(GetDatabase());
-	for (auto segment = (ColumnSegment *)owned_segment.get(); segment; segment = (ColumnSegment *)segment->next.get()) {
-		if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
-			// persistent segment has updates: mark it as modified and rewrite the block with the merged updates
-			auto block_id = segment->GetBlockId();
-			if (block_id != INVALID_BLOCK) {
-				block_manager.MarkBlockAsModified(block_id);
-			}
-		}
-	}
-
-	// now we need to write our segment
-	// we will first run an analyze step that determines which compression function to use
-	idx_t compression_idx;
-	auto analyze_state = DetectBestCompressionMethod(compression_idx);
-
-	if (!analyze_state) {
-		throw InternalException("No suitable compression/storage method found to store column");
-	}
-
-	// now that we have analyzed the compression functions we can start writing to disk
-	auto best_function = compression_functions[compression_idx];
-	auto compress_state = best_function->init_compression(*this, move(analyze_state));
-	ScanSegments(
-	    [&](Vector &scan_vector, idx_t count) { best_function->compress(*compress_state, scan_vector, count); });
-	best_function->compress_finalize(*compress_state);
-
-	owned_segment.reset();
-}
-
-bool ColumnDataCheckpointer::HasChanges() {
-	for (auto segment = (ColumnSegment *)owned_segment.get(); segment; segment = (ColumnSegment *)segment->next.get()) {
-		if (segment->segment_type == ColumnSegmentType::TRANSIENT) {
-			// transient segment: always need to write to disk
-			return true;
-		} else {
-			// persistent segment; check if there were any updates or deletions in this segment
-			idx_t start_row_idx = segment->start - row_group.start;
-			idx_t end_row_idx = start_row_idx + segment->count;
-			if (col_data.updates && col_data.updates->HasUpdates(start_row_idx, end_row_idx)) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-void ColumnDataCheckpointer::WritePersistentSegments() {
-	// all segments are persistent and there are no updates
-	// we only need to write the metadata
-	auto segment = (ColumnSegment *)owned_segment.get();
-	while (segment) {
-		auto next_segment = move(segment->next);
-
-		D_ASSERT(segment->segment_type == ColumnSegmentType::PERSISTENT);
-
-		// set up the data pointer directly using the data from the persistent segment
-		DataPointer pointer;
-		pointer.block_pointer.block_id = segment->GetBlockId();
-		pointer.block_pointer.offset = segment->GetBlockOffset();
-		pointer.row_start = segment->start;
-		pointer.tuple_count = segment->count;
-		pointer.compression_type = segment->function->type;
-		pointer.statistics = segment->stats.statistics->Copy();
-
-		// merge the persistent stats into the global column stats
-		state.global_stats->Merge(*segment->stats.statistics);
-
-		// directly append the current segment to the new tree
-		state.new_tree.AppendSegment(move(owned_segment));
-
-		state.data_pointers.push_back(move(pointer));
-
-		// move to the next segment in the list
-		owned_segment = move(next_segment);
-		segment = (ColumnSegment *)owned_segment.get();
-	}
-}
-
-void ColumnDataCheckpointer::Checkpoint(unique_ptr<SegmentBase> segment) {
-	D_ASSERT(!owned_segment);
-	this->owned_segment = move(segment);
-	// first check if any of the segments have changes
-	if (!HasChanges()) {
-		// no changes: only need to write the metadata for this column
-		WritePersistentSegments();
-	} else {
-		// there are changes: rewrite the set of columns
-		WriteToDisk();
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstance &db, block_id_t block_id,
-                                                                 idx_t offset, const LogicalType &type, idx_t start,
-                                                                 idx_t count, CompressionType compression_type,
-                                                                 unique_ptr<BaseStatistics> statistics) {
-	auto &config = DBConfig::GetConfig(db);
-	CompressionFunction *function;
-	if (block_id == INVALID_BLOCK) {
-		function = config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, type.InternalType());
-	} else {
-		function = config.GetCompressionFunction(compression_type, type.InternalType());
-	}
-	return make_unique<ColumnSegment>(db, type, ColumnSegmentType::PERSISTENT, start, count, function, move(statistics),
-	                                  block_id, offset);
-}
-
-unique_ptr<ColumnSegment> ColumnSegment::CreateTransientSegment(DatabaseInstance &db, const LogicalType &type,
-                                                                idx_t start) {
-	auto &config = DBConfig::GetConfig(db);
-	auto function = config.GetCompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED, type.InternalType());
-	return make_unique<ColumnSegment>(db, type, ColumnSegmentType::TRANSIENT, start, 0, function, nullptr,
-	                                  INVALID_BLOCK, 0);
-}
-
-ColumnSegment::ColumnSegment(DatabaseInstance &db, LogicalType type_p, ColumnSegmentType segment_type, idx_t start,
-                             idx_t count, CompressionFunction *function_p, unique_ptr<BaseStatistics> statistics,
-                             block_id_t block_id_p, idx_t offset_p)
-    : SegmentBase(start, count), db(db), type(move(type_p)), type_size(GetTypeIdSize(type.InternalType())),
-      segment_type(segment_type), function(function_p), stats(type, move(statistics)), block_id(block_id_p),
-      offset(offset_p) {
-	D_ASSERT(function);
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
-	if (block_id == INVALID_BLOCK) {
-		// no block id specified
-		// there are two cases here:
-		// transient: allocate a buffer for the uncompressed segment
-		// persistent: constant segment, no need to allocate anything
-		if (segment_type == ColumnSegmentType::TRANSIENT) {
-			this->block = buffer_manager.RegisterMemory(Storage::BLOCK_SIZE, false);
-		}
-	} else {
-		D_ASSERT(segment_type == ColumnSegmentType::PERSISTENT);
-		this->block = buffer_manager.RegisterBlock(block_id);
-	}
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
-	}
-}
-
-ColumnSegment::~ColumnSegment() {
-}
-
-//===--------------------------------------------------------------------===//
-// Scan
-//===--------------------------------------------------------------------===//
-void ColumnSegment::InitializeScan(ColumnScanState &state) {
-	state.scan_state = function->init_scan(*this);
-}
-
-void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset,
-                         bool entire_vector) {
-	if (entire_vector) {
-		D_ASSERT(result_offset == 0);
-		Scan(state, scan_count, result);
-	} else {
-		D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-		ScanPartial(state, scan_count, result, result_offset);
-		D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	}
-}
-
-void ColumnSegment::Skip(ColumnScanState &state) {
-	function->skip(*this, state, state.row_index - state.internal_index);
-	state.internal_index = state.row_index;
-}
-
-void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &result) {
-	function->scan_vector(*this, state, scan_count, result);
-}
-
-void ColumnSegment::ScanPartial(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset) {
-	function->scan_partial(*this, state, scan_count, result, result_offset);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch
-//===--------------------------------------------------------------------===//
-void ColumnSegment::FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	function->fetch_row(*this, state, row_id - this->start, result, result_idx);
-}
-
-void ColumnSegment::InitializeAppend(ColumnAppendState &state) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-}
-
-//===--------------------------------------------------------------------===//
-// Append
-//===--------------------------------------------------------------------===//
-idx_t ColumnSegment::Append(ColumnAppendState &state, VectorData &append_data, idx_t offset, idx_t count) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function->append) {
-		throw InternalException("Attempting to append to a segment without append method");
-	}
-	return function->append(*this, stats, append_data, offset, count);
-}
-
-idx_t ColumnSegment::FinalizeAppend() {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function->finalize_append) {
-		throw InternalException("Attempting to call FinalizeAppend on a segment without a finalize_append method");
-	}
-	return function->finalize_append(*this, stats);
-}
-
-void ColumnSegment::RevertAppend(idx_t start_row) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (function->revert_append) {
-		function->revert_append(*this, start_row);
-	}
-	this->count = start_row - this->start;
-}
-
-//===--------------------------------------------------------------------===//
-// Convert To Persistent
-//===--------------------------------------------------------------------===//
-void ColumnSegment::ConvertToPersistent(block_id_t block_id_p) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	segment_type = ColumnSegmentType::PERSISTENT;
-	block_id = block_id_p;
-	offset = 0;
-
-	if (block_id == INVALID_BLOCK) {
-		// constant block: reset the block buffer
-		block.reset();
-	} else {
-		// non-constant block: write the block to disk
-		auto &buffer_manager = BufferManager::GetBufferManager(db);
-		auto &block_manager = BlockManager::GetBlockManager(db);
-
-		// the data for the block already exists in-memory of our block
-		// instead of copying the data we alter some metadata so the buffer points to an on-disk block
-		block = buffer_manager.ConvertToPersistent(block_manager, block_id, move(block));
-	}
-
-	segment_state.reset();
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
-	}
-}
-
-void ColumnSegment::ConvertToPersistent(shared_ptr<BlockHandle> block_p, block_id_t block_id_p, uint32_t offset_p) {
-	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	segment_type = ColumnSegmentType::PERSISTENT;
-	block_id = block_id_p;
-	offset = offset_p;
-	block = move(block_p);
-
-	segment_state.reset();
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Filter Selection
-//===--------------------------------------------------------------------===//
-template <class T, class OP, bool HAS_NULL>
-static idx_t TemplatedFilterSelection(T *vec, T *predicate, SelectionVector &sel, idx_t approved_tuple_count,
-                                      ValidityMask &mask, SelectionVector &result_sel) {
-	idx_t result_count = 0;
-	for (idx_t i = 0; i < approved_tuple_count; i++) {
-		auto idx = sel.get_index(i);
-		if ((!HAS_NULL || mask.RowIsValid(idx)) && OP::Operation(vec[idx], *predicate)) {
-			result_sel.set_index(result_count++, idx);
-		}
-	}
-	return result_count;
-}
-
-template <class T>
-static void FilterSelectionSwitch(T *vec, T *predicate, SelectionVector &sel, idx_t &approved_tuple_count,
-                                  ExpressionType comparison_type, ValidityMask &mask) {
-	SelectionVector new_sel(approved_tuple_count);
-	// the inplace loops take the result as the last parameter
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL: {
-		if (mask.AllValid()) {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, Equals, false>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		} else {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, Equals, true>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_NOTEQUAL: {
-		if (mask.AllValid()) {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, NotEquals, false>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		} else {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, NotEquals, true>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_LESSTHAN: {
-		if (mask.AllValid()) {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, LessThan, false>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		} else {
-			approved_tuple_count =
-			    TemplatedFilterSelection<T, LessThan, true>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_GREATERTHAN: {
-		if (mask.AllValid()) {
-			approved_tuple_count = TemplatedFilterSelection<T, GreaterThan, false>(vec, predicate, sel,
-			                                                                       approved_tuple_count, mask, new_sel);
-		} else {
-			approved_tuple_count = TemplatedFilterSelection<T, GreaterThan, true>(vec, predicate, sel,
-			                                                                      approved_tuple_count, mask, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO: {
-		if (mask.AllValid()) {
-			approved_tuple_count = TemplatedFilterSelection<T, LessThanEquals, false>(
-			    vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		} else {
-			approved_tuple_count = TemplatedFilterSelection<T, LessThanEquals, true>(
-			    vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		}
-		break;
-	}
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO: {
-		if (mask.AllValid()) {
-			approved_tuple_count = TemplatedFilterSelection<T, GreaterThanEquals, false>(
-			    vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		} else {
-			approved_tuple_count = TemplatedFilterSelection<T, GreaterThanEquals, true>(
-			    vec, predicate, sel, approved_tuple_count, mask, new_sel);
-		}
-		break;
-	}
-	default:
-		throw NotImplementedException("Unknown comparison type for filter pushed down to table!");
-	}
-	sel.Initialize(new_sel);
-}
-
-template <bool IS_NULL>
-static idx_t TemplatedNullSelection(SelectionVector &sel, idx_t approved_tuple_count, ValidityMask &mask) {
-	if (mask.AllValid()) {
-		// no NULL values
-		if (IS_NULL) {
-			return 0;
-		} else {
-			return approved_tuple_count;
-		}
-	} else {
-		SelectionVector result_sel(approved_tuple_count);
-		idx_t result_count = 0;
-		for (idx_t i = 0; i < approved_tuple_count; i++) {
-			auto idx = sel.get_index(i);
-			if (mask.RowIsValid(idx) != IS_NULL) {
-				result_sel.set_index(result_count++, idx);
-			}
-		}
-		sel.Initialize(result_sel);
-		return result_count;
-	}
-}
-
-idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
-                                     idx_t &approved_tuple_count, ValidityMask &mask) {
-	switch (filter.filter_type) {
-	case TableFilterType::CONJUNCTION_OR: {
-		// similar to the CONJUNCTION_AND, but we need to take care of the SelectionVectors (OR all of them)
-		idx_t count_total = 0;
-		SelectionVector result_sel(approved_tuple_count);
-		auto &conjunction_or = (ConjunctionOrFilter &)filter;
-		for (auto &child_filter : conjunction_or.child_filters) {
-			SelectionVector temp_sel;
-			temp_sel.Initialize(sel);
-			idx_t temp_tuple_count = approved_tuple_count;
-			idx_t temp_count = FilterSelection(temp_sel, result, *child_filter, temp_tuple_count, mask);
-			// tuples passed, move them into the actual result vector
-			for (idx_t i = 0; i < temp_count; i++) {
-				auto new_idx = temp_sel.get_index(i);
-				bool is_new_idx = true;
-				for (idx_t res_idx = 0; res_idx < count_total; res_idx++) {
-					if (result_sel.get_index(res_idx) == new_idx) {
-						is_new_idx = false;
-						break;
-					}
-				}
-				if (is_new_idx) {
-					result_sel.set_index(count_total++, new_idx);
-				}
-			}
-		}
-		sel.Initialize(result_sel);
-		approved_tuple_count = count_total;
-		return approved_tuple_count;
-	}
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = (ConjunctionAndFilter &)filter;
-		for (auto &child_filter : conjunction_and.child_filters) {
-			FilterSelection(sel, result, *child_filter, approved_tuple_count, mask);
-		}
-		return approved_tuple_count;
-	}
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (ConstantFilter &)filter;
-		// the inplace loops take the result as the last parameter
-		switch (result.GetType().InternalType()) {
-		case PhysicalType::UINT8: {
-			auto result_flat = FlatVector::GetData<uint8_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<uint8_t>(predicate_vector);
-			FilterSelectionSwitch<uint8_t>(result_flat, predicate, sel, approved_tuple_count,
-			                               constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::UINT16: {
-			auto result_flat = FlatVector::GetData<uint16_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<uint16_t>(predicate_vector);
-			FilterSelectionSwitch<uint16_t>(result_flat, predicate, sel, approved_tuple_count,
-			                                constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::UINT32: {
-			auto result_flat = FlatVector::GetData<uint32_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<uint32_t>(predicate_vector);
-			FilterSelectionSwitch<uint32_t>(result_flat, predicate, sel, approved_tuple_count,
-			                                constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::UINT64: {
-			auto result_flat = FlatVector::GetData<uint64_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<uint64_t>(predicate_vector);
-			FilterSelectionSwitch<uint64_t>(result_flat, predicate, sel, approved_tuple_count,
-			                                constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::INT8: {
-			auto result_flat = FlatVector::GetData<int8_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<int8_t>(predicate_vector);
-			FilterSelectionSwitch<int8_t>(result_flat, predicate, sel, approved_tuple_count,
-			                              constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::INT16: {
-			auto result_flat = FlatVector::GetData<int16_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<int16_t>(predicate_vector);
-			FilterSelectionSwitch<int16_t>(result_flat, predicate, sel, approved_tuple_count,
-			                               constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::INT32: {
-			auto result_flat = FlatVector::GetData<int32_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<int32_t>(predicate_vector);
-			FilterSelectionSwitch<int32_t>(result_flat, predicate, sel, approved_tuple_count,
-			                               constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::INT64: {
-			auto result_flat = FlatVector::GetData<int64_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<int64_t>(predicate_vector);
-			FilterSelectionSwitch<int64_t>(result_flat, predicate, sel, approved_tuple_count,
-			                               constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::INT128: {
-			auto result_flat = FlatVector::GetData<hugeint_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<hugeint_t>(predicate_vector);
-			FilterSelectionSwitch<hugeint_t>(result_flat, predicate, sel, approved_tuple_count,
-			                                 constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::FLOAT: {
-			auto result_flat = FlatVector::GetData<float>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<float>(predicate_vector);
-			FilterSelectionSwitch<float>(result_flat, predicate, sel, approved_tuple_count,
-			                             constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::DOUBLE: {
-			auto result_flat = FlatVector::GetData<double>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<double>(predicate_vector);
-			FilterSelectionSwitch<double>(result_flat, predicate, sel, approved_tuple_count,
-			                              constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::VARCHAR: {
-			auto result_flat = FlatVector::GetData<string_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<string_t>(predicate_vector);
-			FilterSelectionSwitch<string_t>(result_flat, predicate, sel, approved_tuple_count,
-			                                constant_filter.comparison_type, mask);
-			break;
-		}
-		case PhysicalType::BOOL: {
-			auto result_flat = FlatVector::GetData<bool>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<bool>(predicate_vector);
-			FilterSelectionSwitch<bool>(result_flat, predicate, sel, approved_tuple_count,
-			                            constant_filter.comparison_type, mask);
-			break;
-		}
-		default:
-			throw InvalidTypeException(result.GetType(), "Invalid type for filter pushed down to table comparison");
-		}
-		return approved_tuple_count;
-	}
-	case TableFilterType::IS_NULL:
-		return TemplatedNullSelection<true>(sel, approved_tuple_count, mask);
-	case TableFilterType::IS_NOT_NULL:
-		return TemplatedNullSelection<false>(sel, approved_tuple_count, mask);
-	default:
-		throw InternalException("FIXME: unsupported type for filter selection");
-	}
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-ListColumnData::ListColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type_p,
-                               ColumnData *parent)
-    : ColumnData(info, column_index, start_row, move(type_p), parent), validity(info, 0, start_row, this) {
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	auto &child_type = ListType::GetChildType(type);
-	// the child column, with column index 1 (0 is the validity mask)
-	child_column = ColumnData::CreateColumnUnique(info, 1, start_row, child_type, this);
-}
-
-bool ListColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
-	// table filters are not supported yet for list columns
-	return false;
-}
-
-void ListColumnData::InitializeScan(ColumnScanState &state) {
-	ColumnData::InitializeScan(state);
-
-	// initialize the validity segment
-	ColumnScanState validity_state;
-	validity.InitializeScan(validity_state);
-	state.child_states.push_back(move(validity_state));
-
-	// initialize the child scan
-	ColumnScanState child_state;
-	child_column->InitializeScan(child_state);
-	state.child_states.push_back(move(child_state));
-}
-
-list_entry_t ListColumnData::FetchListEntry(idx_t row_idx) {
-	auto segment = (ColumnSegment *)data.GetSegment(row_idx);
-	ColumnFetchState fetch_state;
-	Vector result(type, 1);
-	segment->FetchRow(fetch_state, row_idx, result, 0);
-
-	// initialize the child scan with the required offset
-	auto list_data = FlatVector::GetData<list_entry_t>(result);
-	return list_data[0];
-}
-
-void ListColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	if (row_idx == 0) {
-		InitializeScan(state);
-		return;
-	}
-	ColumnData::InitializeScanWithOffset(state, row_idx);
-
-	// initialize the validity segment
-	ColumnScanState validity_state;
-	validity.InitializeScanWithOffset(validity_state, row_idx);
-	state.child_states.push_back(move(validity_state));
-
-	// we need to read the list at position row_idx to get the correct row offset of the child
-	auto list_entry = FetchListEntry(row_idx);
-	auto child_offset = list_entry.offset;
-
-	D_ASSERT(child_offset <= child_column->GetMaxEntry());
-	ColumnScanState child_state;
-	if (child_offset < child_column->GetMaxEntry()) {
-		child_column->InitializeScanWithOffset(child_state, child_offset);
-	}
-	state.child_states.push_back(move(child_state));
-}
-
-idx_t ListColumnData::Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
-	return ScanCount(state, result, STANDARD_VECTOR_SIZE);
-}
-
-idx_t ListColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) {
-	return ScanCount(state, result, STANDARD_VECTOR_SIZE);
-}
-
-idx_t ListColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) {
-	if (count == 0) {
-		return 0;
-	}
-	// updates not supported for lists
-	D_ASSERT(!updates);
-
-	idx_t scan_count = ScanVector(state, result, count);
-	D_ASSERT(scan_count > 0);
-	validity.ScanCount(state.child_states[0], result, count);
-
-	auto data = FlatVector::GetData<list_entry_t>(result);
-	auto first_entry = data[0];
-	auto last_entry = data[scan_count - 1];
-
-#ifdef DEBUG
-	for (idx_t i = 1; i < scan_count; i++) {
-		D_ASSERT(data[i].offset == data[i - 1].offset + data[i - 1].length);
-	}
-#endif
-	// shift all offsets so they are 0 at the first entry
-	for (idx_t i = 0; i < scan_count; i++) {
-		data[i].offset -= first_entry.offset;
-	}
-
-	D_ASSERT(last_entry.offset >= first_entry.offset);
-	idx_t child_scan_count = last_entry.offset + last_entry.length - first_entry.offset;
-	ListVector::Reserve(result, child_scan_count);
-
-	if (child_scan_count > 0) {
-		auto &child_entry = ListVector::GetEntry(result);
-		D_ASSERT(child_entry.GetType().InternalType() == PhysicalType::STRUCT ||
-		         state.child_states[1].row_index + child_scan_count <= child_column->GetMaxEntry());
-		child_column->ScanCount(state.child_states[1], child_entry, child_scan_count);
-	}
-
-	ListVector::SetListSize(result, child_scan_count);
-	return scan_count;
-}
-
-void ListColumnData::Skip(ColumnScanState &state, idx_t count) {
-	// skip inside the validity segment
-	validity.Skip(state.child_states[0], count);
-
-	// we need to read the list entries/offsets to figure out how much to skip
-	// note that we only need to read the first and last entry
-	// however, let's just read all "count" entries for now
-	auto data = unique_ptr<list_entry_t[]>(new list_entry_t[count]);
-	Vector result(type, (data_ptr_t)data.get());
-	idx_t scan_count = ScanVector(state, result, count);
-	if (scan_count == 0) {
-		return;
-	}
-
-	auto &first_entry = data[0];
-	auto &last_entry = data[scan_count - 1];
-	idx_t child_scan_count = last_entry.offset + last_entry.length - first_entry.offset;
-
-	// skip the child state forward by the child_scan_count
-	child_column->Skip(state.child_states[1], child_scan_count);
-}
-
-void ListColumnData::InitializeAppend(ColumnAppendState &state) {
-	// initialize the list offset append
-	ColumnData::InitializeAppend(state);
-
-	// initialize the validity append
-	ColumnAppendState validity_append_state;
-	validity.InitializeAppend(validity_append_state);
-	state.child_appends.push_back(move(validity_append_state));
-
-	// initialize the child column append
-	ColumnAppendState child_append_state;
-	child_column->InitializeAppend(child_append_state);
-	state.child_appends.push_back(move(child_append_state));
-}
-
-void ListColumnData::Append(BaseStatistics &stats_p, ColumnAppendState &state, Vector &vector, idx_t count) {
-	D_ASSERT(count > 0);
-	auto &stats = (ListStatistics &)stats_p;
-
-	vector.Normalify(count);
-	auto &list_validity = FlatVector::Validity(vector);
-
-	// construct the list_entry_t entries to append to the column data
-	auto input_offsets = FlatVector::GetData<list_entry_t>(vector);
-	auto start_offset = child_column->GetMaxEntry();
-	idx_t child_count = 0;
-
-	auto append_offsets = unique_ptr<list_entry_t[]>(new list_entry_t[count]);
-	for (idx_t i = 0; i < count; i++) {
-		if (list_validity.RowIsValid(i)) {
-			append_offsets[i].offset = start_offset + input_offsets[i].offset;
-			append_offsets[i].length = input_offsets[i].length;
-			child_count += input_offsets[i].length;
-		} else {
-			if (i > 0) {
-				append_offsets[i].offset = append_offsets[i - 1].offset + append_offsets[i - 1].length;
-			} else {
-				append_offsets[i].offset = start_offset;
-			}
-			append_offsets[i].length = 0;
-		}
-	}
-#ifdef DEBUG
-	D_ASSERT(append_offsets[0].offset == start_offset);
-	for (idx_t i = 1; i < count; i++) {
-		D_ASSERT(append_offsets[i].offset == append_offsets[i - 1].offset + append_offsets[i - 1].length);
-	}
-	D_ASSERT(append_offsets[count - 1].offset + append_offsets[count - 1].length - append_offsets[0].offset ==
-	         child_count);
-#endif
-
-	VectorData vdata;
-	vdata.validity = list_validity;
-	vdata.sel = FlatVector::IncrementalSelectionVector();
-	vdata.data = (data_ptr_t)append_offsets.get();
-
-	// append the list offsets
-	ColumnData::AppendData(stats, state, vdata, count);
-	// append the validity data
-	validity.AppendData(*stats.validity_stats, state.child_appends[0], vdata, count);
-	// append the child vector
-	if (child_count > 0) {
-		auto &child_vector = ListVector::GetEntry(vector);
-		child_column->Append(*stats.child_stats, state.child_appends[1], child_vector, child_count);
-	}
-}
-
-void ListColumnData::RevertAppend(row_t start_row) {
-	ColumnData::RevertAppend(start_row);
-	validity.RevertAppend(start_row);
-	auto column_count = GetMaxEntry();
-	if (column_count > start) {
-		// revert append in the child column
-		auto list_entry = FetchListEntry(column_count - 1);
-		child_column->RevertAppend(list_entry.offset + list_entry.length);
-	}
-}
-
-idx_t ListColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	throw NotImplementedException("List Fetch");
-}
-
-void ListColumnData::Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                            idx_t update_count) {
-	throw NotImplementedException("List Update is not supported.");
-}
-
-void ListColumnData::UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
-                                  row_t *row_ids, idx_t update_count, idx_t depth) {
-	throw NotImplementedException("List Update Column is not supported");
-}
-
-unique_ptr<BaseStatistics> ListColumnData::GetUpdateStatistics() {
-	return nullptr;
-}
-
-void ListColumnData::FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                              idx_t result_idx) {
-	// insert any child states that are required
-	// we need two (validity & list child)
-	// note that we need a scan state for the child vector
-	// this is because we will (potentially) fetch more than one tuple from the list child
-	if (state.child_states.empty()) {
-		auto child_state = make_unique<ColumnFetchState>();
-		state.child_states.push_back(move(child_state));
-	}
-	// fetch the list_entry_t and the validity mask for that list
-	auto segment = (ColumnSegment *)data.GetSegment(row_id);
-
-	// now perform the fetch within the segment
-	segment->FetchRow(state, row_id, result, result_idx);
-	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
-
-	auto &validity = FlatVector::Validity(result);
-	auto list_data = FlatVector::GetData<list_entry_t>(result);
-	auto &list_entry = list_data[result_idx];
-	auto original_offset = list_entry.offset;
-	// set the list entry offset to the size of the current list
-	list_entry.offset = ListVector::GetListSize(result);
-	if (!validity.RowIsValid(result_idx)) {
-		// the list is NULL! no need to fetch the child
-		D_ASSERT(list_entry.length == 0);
-		return;
-	}
-
-	// now we need to read from the child all the elements between [offset...length]
-	auto child_scan_count = list_entry.length;
-	if (child_scan_count > 0) {
-		auto child_state = make_unique<ColumnScanState>();
-		auto &child_type = ListType::GetChildType(result.GetType());
-		Vector child_scan(child_type, child_scan_count);
-		// seek the scan towards the specified position and read [length] entries
-		child_column->InitializeScanWithOffset(*child_state, original_offset);
-		D_ASSERT(child_type.InternalType() == PhysicalType::STRUCT ||
-		         child_state->row_index + child_scan_count <= child_column->GetMaxEntry());
-		child_column->ScanCount(*child_state, child_scan, child_scan_count);
-
-		ListVector::Append(result, child_scan, child_scan_count);
-	}
-}
-
-void ListColumnData::CommitDropColumn() {
-	validity.CommitDropColumn();
-	child_column->CommitDropColumn();
-}
-
-struct ListColumnCheckpointState : public ColumnCheckpointState {
-	ListColumnCheckpointState(RowGroup &row_group, ColumnData &column_data, TableDataWriter &writer)
-	    : ColumnCheckpointState(row_group, column_data, writer) {
-		global_stats = make_unique<ListStatistics>(column_data.type);
-	}
-
-	unique_ptr<ColumnCheckpointState> validity_state;
-	unique_ptr<ColumnCheckpointState> child_state;
-
-public:
-	unique_ptr<BaseStatistics> GetStatistics() override {
-		auto stats = global_stats->Copy();
-		auto &list_stats = (ListStatistics &)*stats;
-		stats->validity_stats = validity_state->GetStatistics();
-		list_stats.child_stats = child_state->GetStatistics();
-		return stats;
-	}
-
-	void FlushToDisk() override {
-		ColumnCheckpointState::FlushToDisk();
-		validity_state->FlushToDisk();
-		child_state->FlushToDisk();
-	}
-};
-
-unique_ptr<ColumnCheckpointState> ListColumnData::CreateCheckpointState(RowGroup &row_group, TableDataWriter &writer) {
-	return make_unique<ListColumnCheckpointState>(row_group, *this, writer);
-}
-
-unique_ptr<ColumnCheckpointState> ListColumnData::Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-                                                             ColumnCheckpointInfo &checkpoint_info) {
-	auto validity_state = validity.Checkpoint(row_group, writer, checkpoint_info);
-	auto base_state = ColumnData::Checkpoint(row_group, writer, checkpoint_info);
-	auto child_state = child_column->Checkpoint(row_group, writer, checkpoint_info);
-
-	auto &checkpoint_state = (ListColumnCheckpointState &)*base_state;
-	checkpoint_state.validity_state = move(validity_state);
-	checkpoint_state.child_state = move(child_state);
-	return base_state;
-}
-
-void ListColumnData::DeserializeColumn(Deserializer &source) {
-	ColumnData::DeserializeColumn(source);
-	validity.DeserializeColumn(source);
-	child_column->DeserializeColumn(source);
-}
-
-void ListColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) {
-	col_path.push_back(0);
-	validity.GetStorageInfo(row_group_index, col_path, result);
-	col_path.back() = 1;
-	child_column->GetStorageInfo(row_group_index, col_path, result);
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-PersistentTableData::PersistentTableData(idx_t column_count) {
-}
-
-PersistentTableData::~PersistentTableData() {
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-constexpr const idx_t RowGroup::ROW_GROUP_VECTOR_COUNT;
-constexpr const idx_t RowGroup::ROW_GROUP_SIZE;
-
-RowGroup::RowGroup(DatabaseInstance &db, DataTableInfo &table_info, idx_t start, idx_t count)
-    : SegmentBase(start, count), db(db), table_info(table_info) {
-
-	Verify();
-}
-
-RowGroup::RowGroup(DatabaseInstance &db, DataTableInfo &table_info, const vector<LogicalType> &types,
-                   RowGroupPointer &pointer)
-    : SegmentBase(pointer.row_start, pointer.tuple_count), db(db), table_info(table_info) {
-	// deserialize the columns
-	if (pointer.data_pointers.size() != types.size()) {
-		throw IOException("Row group column count is unaligned with table column count. Corrupt file?");
-	}
-	for (idx_t i = 0; i < pointer.data_pointers.size(); i++) {
-		auto &block_pointer = pointer.data_pointers[i];
-		MetaBlockReader column_data_reader(db, block_pointer.block_id);
-		column_data_reader.offset = block_pointer.offset;
-		this->columns.push_back(ColumnData::Deserialize(table_info, i, start, column_data_reader, types[i], nullptr));
-	}
-
-	// set up the statistics
-	for (auto &stats : pointer.statistics) {
-		auto stats_type = stats->type;
-		this->stats.push_back(make_shared<SegmentStatistics>(stats_type, move(stats)));
-	}
-	this->version_info = move(pointer.versions);
-
-	Verify();
-}
-
-RowGroup::~RowGroup() {
-}
-
-void RowGroup::InitializeEmpty(const vector<LogicalType> &types) {
-	// set up the segment trees for the column segments
-	for (idx_t i = 0; i < types.size(); i++) {
-		auto column_data = ColumnData::CreateColumn(GetTableInfo(), i, start, types[i]);
-		stats.push_back(make_shared<SegmentStatistics>(types[i]));
-		columns.push_back(move(column_data));
-	}
-}
-
-bool RowGroup::InitializeScanWithOffset(RowGroupScanState &state, idx_t vector_offset) {
-	auto &column_ids = state.parent.column_ids;
-	if (state.parent.table_filters) {
-		if (!CheckZonemap(*state.parent.table_filters, column_ids)) {
-			return false;
-		}
-	}
-
-	state.row_group = this;
-	state.vector_index = vector_offset;
-	state.max_row =
-	    this->start > state.parent.max_row ? 0 : MinValue<idx_t>(this->count, state.parent.max_row - this->start);
-	state.column_scans = unique_ptr<ColumnScanState[]>(new ColumnScanState[column_ids.size()]);
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto column = column_ids[i];
-		if (column != COLUMN_IDENTIFIER_ROW_ID) {
-			columns[column]->InitializeScanWithOffset(state.column_scans[i],
-			                                          start + vector_offset * STANDARD_VECTOR_SIZE);
-		} else {
-			state.column_scans[i].current = nullptr;
-		}
-	}
-	return true;
-}
-
-bool RowGroup::InitializeScan(RowGroupScanState &state) {
-	auto &column_ids = state.parent.column_ids;
-	if (state.parent.table_filters) {
-		if (!CheckZonemap(*state.parent.table_filters, column_ids)) {
-			return false;
-		}
-	}
-	state.row_group = this;
-	state.vector_index = 0;
-	state.max_row =
-	    this->start > state.parent.max_row ? 0 : MinValue<idx_t>(this->count, state.parent.max_row - this->start);
-	state.column_scans = unique_ptr<ColumnScanState[]>(new ColumnScanState[column_ids.size()]);
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto column = column_ids[i];
-		if (column != COLUMN_IDENTIFIER_ROW_ID) {
-			columns[column]->InitializeScan(state.column_scans[i]);
-		} else {
-			state.column_scans[i].current = nullptr;
-		}
-	}
-	return true;
-}
-
-unique_ptr<RowGroup> RowGroup::AlterType(ClientContext &context, const LogicalType &target_type, idx_t changed_idx,
-                                         ExpressionExecutor &executor, TableScanState &scan_state,
-                                         DataChunk &scan_chunk) {
-	Verify();
-
-	// construct a new column data for this type
-	auto column_data = ColumnData::CreateColumn(GetTableInfo(), changed_idx, start, target_type);
-
-	ColumnAppendState append_state;
-	column_data->InitializeAppend(append_state);
-
-	// scan the original table, and fill the new column with the transformed value
-	InitializeScan(scan_state.row_group_scan_state);
-
-	Vector append_vector(target_type);
-	auto altered_col_stats = make_shared<SegmentStatistics>(target_type);
-	while (true) {
-		// scan the table
-		scan_chunk.Reset();
-		ScanCommitted(scan_state.row_group_scan_state, scan_chunk, TableScanType::TABLE_SCAN_COMMITTED_ROWS);
-		if (scan_chunk.size() == 0) {
-			break;
-		}
-		// execute the expression
-		executor.ExecuteExpression(scan_chunk, append_vector);
-		column_data->Append(*altered_col_stats->statistics, append_state, append_vector, scan_chunk.size());
-	}
-
-	// set up the row_group based on this row_group
-	auto row_group = make_unique<RowGroup>(db, table_info, this->start, this->count);
-	row_group->version_info = version_info;
-	for (idx_t i = 0; i < columns.size(); i++) {
-		if (i == changed_idx) {
-			// this is the altered column: use the new column
-			row_group->columns.push_back(move(column_data));
-			row_group->stats.push_back(move(altered_col_stats));
-		} else {
-			// this column was not altered: use the data directly
-			row_group->columns.push_back(columns[i]);
-			row_group->stats.push_back(stats[i]);
-		}
-	}
-	row_group->Verify();
-	return row_group;
-}
-
-unique_ptr<RowGroup> RowGroup::AddColumn(ClientContext &context, ColumnDefinition &new_column,
-                                         ExpressionExecutor &executor, Expression *default_value, Vector &result) {
-	Verify();
-
-	// construct a new column data for the new column
-	auto added_column = ColumnData::CreateColumn(GetTableInfo(), columns.size(), start, new_column.Type());
-	auto added_col_stats = make_shared<SegmentStatistics>(
-	    new_column.Type(), BaseStatistics::CreateEmpty(new_column.Type(), StatisticsType::LOCAL_STATS));
-
-	idx_t rows_to_write = this->count;
-	if (rows_to_write > 0) {
-		DataChunk dummy_chunk;
-
-		ColumnAppendState state;
-		added_column->InitializeAppend(state);
-		for (idx_t i = 0; i < rows_to_write; i += STANDARD_VECTOR_SIZE) {
-			idx_t rows_in_this_vector = MinValue<idx_t>(rows_to_write - i, STANDARD_VECTOR_SIZE);
-			if (default_value) {
-				dummy_chunk.SetCardinality(rows_in_this_vector);
-				executor.ExecuteExpression(dummy_chunk, result);
-			}
-			added_column->Append(*added_col_stats->statistics, state, result, rows_in_this_vector);
-		}
-	}
-
-	// set up the row_group based on this row_group
-	auto row_group = make_unique<RowGroup>(db, table_info, this->start, this->count);
-	row_group->version_info = version_info;
-	row_group->columns = columns;
-	row_group->stats = stats;
-	// now add the new column
-	row_group->columns.push_back(move(added_column));
-	row_group->stats.push_back(move(added_col_stats));
-
-	row_group->Verify();
-	return row_group;
-}
-
-unique_ptr<RowGroup> RowGroup::RemoveColumn(idx_t removed_column) {
-	Verify();
-
-	D_ASSERT(removed_column < columns.size());
-
-	auto row_group = make_unique<RowGroup>(db, table_info, this->start, this->count);
-	row_group->version_info = version_info;
-	row_group->columns = columns;
-	row_group->stats = stats;
-	// now remove the column
-	row_group->columns.erase(row_group->columns.begin() + removed_column);
-	row_group->stats.erase(row_group->stats.begin() + removed_column);
-
-	row_group->Verify();
-	return row_group;
-}
-
-void RowGroup::CommitDrop() {
-	for (idx_t column_idx = 0; column_idx < columns.size(); column_idx++) {
-		CommitDropColumn(column_idx);
-	}
-}
-
-void RowGroup::CommitDropColumn(idx_t column_idx) {
-	D_ASSERT(column_idx < columns.size());
-	columns[column_idx]->CommitDropColumn();
-}
-
-void RowGroup::NextVector(RowGroupScanState &state) {
-	state.vector_index++;
-	for (idx_t i = 0; i < state.parent.column_ids.size(); i++) {
-		auto column = state.parent.column_ids[i];
-		if (column == COLUMN_IDENTIFIER_ROW_ID) {
-			continue;
-		}
-		D_ASSERT(column < columns.size());
-		columns[column]->Skip(state.column_scans[i]);
-	}
-}
-
-bool RowGroup::CheckZonemap(TableFilterSet &filters, const vector<column_t> &column_ids) {
-	for (auto &entry : filters.filters) {
-		auto column_index = entry.first;
-		auto &filter = entry.second;
-		auto base_column_index = column_ids[column_index];
-
-		auto propagate_result = filter->CheckStatistics(*stats[base_column_index]->statistics);
-		if (propagate_result == FilterPropagateResult::FILTER_ALWAYS_FALSE ||
-		    propagate_result == FilterPropagateResult::FILTER_FALSE_OR_NULL) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool RowGroup::CheckZonemapSegments(RowGroupScanState &state) {
-	if (!state.parent.table_filters) {
-		return true;
-	}
-	auto &column_ids = state.parent.column_ids;
-	for (auto &entry : state.parent.table_filters->filters) {
-		D_ASSERT(entry.first < column_ids.size());
-		auto column_idx = entry.first;
-		auto base_column_idx = column_ids[column_idx];
-		bool read_segment = columns[base_column_idx]->CheckZonemap(state.column_scans[column_idx], *entry.second);
-		if (!read_segment) {
-			idx_t target_row =
-			    state.column_scans[column_idx].current->start + state.column_scans[column_idx].current->count;
-			D_ASSERT(target_row >= this->start);
-			D_ASSERT(target_row <= this->start + this->count);
-			idx_t target_vector_index = (target_row - this->start) / STANDARD_VECTOR_SIZE;
-			if (state.vector_index == target_vector_index) {
-				// we can't skip any full vectors because this segment contains less than a full vector
-				// for now we just bail-out
-				// FIXME: we could check if we can ALSO skip the next segments, in which case skipping a full vector
-				// might be possible
-				// we don't care that much though, since a single segment that fits less than a full vector is
-				// exceedingly rare
-				return true;
-			}
-			while (state.vector_index < target_vector_index) {
-				NextVector(state);
-			}
-			return false;
-		}
-	}
-
-	return true;
-}
-
-template <TableScanType TYPE>
-void RowGroup::TemplatedScan(Transaction *transaction, RowGroupScanState &state, DataChunk &result) {
-	const bool ALLOW_UPDATES = TYPE != TableScanType::TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES &&
-	                           TYPE != TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED;
-	auto &table_filters = state.parent.table_filters;
-	auto &column_ids = state.parent.column_ids;
-	auto &adaptive_filter = state.parent.adaptive_filter;
-	while (true) {
-		if (state.vector_index * STANDARD_VECTOR_SIZE >= state.max_row) {
-			// exceeded the amount of rows to scan
-			return;
-		}
-		idx_t current_row = state.vector_index * STANDARD_VECTOR_SIZE;
-		auto max_count = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.max_row - current_row);
-
-		//! first check the zonemap if we have to scan this partition
-		if (!CheckZonemapSegments(state)) {
-			continue;
-		}
-		// second, scan the version chunk manager to figure out which tuples to load for this transaction
-		idx_t count;
-		SelectionVector valid_sel(STANDARD_VECTOR_SIZE);
-		if (TYPE == TableScanType::TABLE_SCAN_REGULAR) {
-			D_ASSERT(transaction);
-			count = state.row_group->GetSelVector(*transaction, state.vector_index, valid_sel, max_count);
-			if (count == 0) {
-				// nothing to scan for this vector, skip the entire vector
-				NextVector(state);
-				continue;
-			}
-		} else if (TYPE == TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED) {
-			auto &transaction_manager = TransactionManager::Get(db);
-			auto lowest_active_start = transaction_manager.LowestActiveStart();
-			auto lowest_active_id = transaction_manager.LowestActiveId();
-
-			count = state.row_group->GetCommittedSelVector(lowest_active_start, lowest_active_id, state.vector_index,
-			                                               valid_sel, max_count);
-			if (count == 0) {
-				// nothing to scan for this vector, skip the entire vector
-				NextVector(state);
-				continue;
-			}
-		} else {
-			count = max_count;
-		}
-		if (count == max_count && !table_filters) {
-			// scan all vectors completely: full scan without deletions or table filters
-			for (idx_t i = 0; i < column_ids.size(); i++) {
-				auto column = column_ids[i];
-				if (column == COLUMN_IDENTIFIER_ROW_ID) {
-					// scan row id
-					D_ASSERT(result.data[i].GetType().InternalType() == ROW_TYPE);
-					result.data[i].Sequence(this->start + current_row, 1);
-				} else {
-					if (TYPE != TableScanType::TABLE_SCAN_REGULAR) {
-						columns[column]->ScanCommitted(state.vector_index, state.column_scans[i], result.data[i],
-						                               ALLOW_UPDATES);
-					} else {
-						D_ASSERT(transaction);
-						columns[column]->Scan(*transaction, state.vector_index, state.column_scans[i], result.data[i]);
-					}
-				}
-			}
-		} else {
-			// partial scan: we have deletions or table filters
-			idx_t approved_tuple_count = count;
-			SelectionVector sel;
-			if (count != max_count) {
-				sel.Initialize(valid_sel);
-			} else {
-				sel.Initialize(nullptr);
-			}
-			//! first, we scan the columns with filters, fetch their data and generate a selection vector.
-			//! get runtime statistics
-			auto start_time = high_resolution_clock::now();
-			if (table_filters) {
-				D_ASSERT(ALLOW_UPDATES);
-				for (idx_t i = 0; i < table_filters->filters.size(); i++) {
-					auto tf_idx = adaptive_filter->permutation[i];
-					auto col_idx = column_ids[tf_idx];
-					columns[col_idx]->Select(*transaction, state.vector_index, state.column_scans[tf_idx],
-					                         result.data[tf_idx], sel, approved_tuple_count,
-					                         *table_filters->filters[tf_idx]);
-				}
-				for (auto &table_filter : table_filters->filters) {
-					result.data[table_filter.first].Slice(sel, approved_tuple_count);
-				}
-			}
-			if (approved_tuple_count == 0) {
-				// all rows were filtered out by the table filters
-				// skip this vector in all the scans that were not scanned yet
-				D_ASSERT(table_filters);
-				result.Reset();
-				for (idx_t i = 0; i < column_ids.size(); i++) {
-					auto col_idx = column_ids[i];
-					if (col_idx == COLUMN_IDENTIFIER_ROW_ID) {
-						continue;
-					}
-					if (table_filters->filters.find(i) == table_filters->filters.end()) {
-						columns[col_idx]->Skip(state.column_scans[i]);
-					}
-				}
-				state.vector_index++;
-				continue;
-			}
-			//! Now we use the selection vector to fetch data for the other columns.
-			for (idx_t i = 0; i < column_ids.size(); i++) {
-				if (!table_filters || table_filters->filters.find(i) == table_filters->filters.end()) {
-					auto column = column_ids[i];
-					if (column == COLUMN_IDENTIFIER_ROW_ID) {
-						D_ASSERT(result.data[i].GetType().InternalType() == PhysicalType::INT64);
-						result.data[i].SetVectorType(VectorType::FLAT_VECTOR);
-						auto result_data = (int64_t *)FlatVector::GetData(result.data[i]);
-						for (size_t sel_idx = 0; sel_idx < approved_tuple_count; sel_idx++) {
-							result_data[sel_idx] = this->start + current_row + sel.get_index(sel_idx);
-						}
-					} else {
-						if (TYPE == TableScanType::TABLE_SCAN_REGULAR) {
-							D_ASSERT(transaction);
-							columns[column]->FilterScan(*transaction, state.vector_index, state.column_scans[i],
-							                            result.data[i], sel, approved_tuple_count);
-						} else {
-							D_ASSERT(!transaction);
-							columns[column]->FilterScanCommitted(state.vector_index, state.column_scans[i],
-							                                     result.data[i], sel, approved_tuple_count,
-							                                     ALLOW_UPDATES);
-						}
-					}
-				}
-			}
-			auto end_time = high_resolution_clock::now();
-			if (adaptive_filter && table_filters->filters.size() > 1) {
-				adaptive_filter->AdaptRuntimeStatistics(duration_cast<duration<double>>(end_time - start_time).count());
-			}
-			D_ASSERT(approved_tuple_count > 0);
-			count = approved_tuple_count;
-		}
-		result.SetCardinality(count);
-		state.vector_index++;
-		break;
-	}
-}
-
-void RowGroup::Scan(Transaction &transaction, RowGroupScanState &state, DataChunk &result) {
-	TemplatedScan<TableScanType::TABLE_SCAN_REGULAR>(&transaction, state, result);
-}
-
-void RowGroup::ScanCommitted(RowGroupScanState &state, DataChunk &result, TableScanType type) {
-	switch (type) {
-	case TableScanType::TABLE_SCAN_COMMITTED_ROWS:
-		TemplatedScan<TableScanType::TABLE_SCAN_COMMITTED_ROWS>(nullptr, state, result);
-		break;
-	case TableScanType::TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES:
-		TemplatedScan<TableScanType::TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES>(nullptr, state, result);
-		break;
-	case TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED:
-		TemplatedScan<TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED>(nullptr, state, result);
-		break;
-	default:
-		throw InternalException("Unrecognized table scan type");
-	}
-}
-
-ChunkInfo *RowGroup::GetChunkInfo(idx_t vector_idx) {
-	if (!version_info) {
-		return nullptr;
-	}
-	return version_info->info[vector_idx].get();
-}
-
-idx_t RowGroup::GetSelVector(Transaction &transaction, idx_t vector_idx, SelectionVector &sel_vector, idx_t max_count) {
-	lock_guard<mutex> lock(row_group_lock);
-
-	auto info = GetChunkInfo(vector_idx);
-	if (!info) {
-		return max_count;
-	}
-	return info->GetSelVector(transaction, sel_vector, max_count);
-}
-
-idx_t RowGroup::GetCommittedSelVector(transaction_t start_time, transaction_t transaction_id, idx_t vector_idx,
-                                      SelectionVector &sel_vector, idx_t max_count) {
-	lock_guard<mutex> lock(row_group_lock);
-
-	auto info = GetChunkInfo(vector_idx);
-	if (!info) {
-		return max_count;
-	}
-	return info->GetCommittedSelVector(start_time, transaction_id, sel_vector, max_count);
-}
-
-bool RowGroup::Fetch(Transaction &transaction, idx_t row) {
-	D_ASSERT(row < this->count);
-	lock_guard<mutex> lock(row_group_lock);
-
-	idx_t vector_index = row / STANDARD_VECTOR_SIZE;
-	auto info = GetChunkInfo(vector_index);
-	if (!info) {
-		return true;
-	}
-	return info->Fetch(transaction, row - vector_index * STANDARD_VECTOR_SIZE);
-}
-
-void RowGroup::FetchRow(Transaction &transaction, ColumnFetchState &state, const vector<column_t> &column_ids,
-                        row_t row_id, DataChunk &result, idx_t result_idx) {
-	for (idx_t col_idx = 0; col_idx < column_ids.size(); col_idx++) {
-		auto column = column_ids[col_idx];
-		if (column == COLUMN_IDENTIFIER_ROW_ID) {
-			// row id column: fill in the row ids
-			D_ASSERT(result.data[col_idx].GetType().InternalType() == PhysicalType::INT64);
-			result.data[col_idx].SetVectorType(VectorType::FLAT_VECTOR);
-			auto data = FlatVector::GetData<row_t>(result.data[col_idx]);
-			data[result_idx] = row_id;
-		} else {
-			// regular column: fetch data from the base column
-			columns[column]->FetchRow(transaction, state, row_id, result.data[col_idx], result_idx);
-		}
-	}
-}
-
-void RowGroup::AppendVersionInfo(Transaction &transaction, idx_t row_group_start, idx_t count,
-                                 transaction_t commit_id) {
-	idx_t row_group_end = row_group_start + count;
-	lock_guard<mutex> lock(row_group_lock);
-
-	this->count += count;
-	D_ASSERT(this->count <= RowGroup::ROW_GROUP_SIZE);
-
-	// create the version_info if it doesn't exist yet
-	if (!version_info) {
-		version_info = make_unique<VersionNode>();
-	}
-	idx_t start_vector_idx = row_group_start / STANDARD_VECTOR_SIZE;
-	idx_t end_vector_idx = (row_group_end - 1) / STANDARD_VECTOR_SIZE;
-	for (idx_t vector_idx = start_vector_idx; vector_idx <= end_vector_idx; vector_idx++) {
-		idx_t start = vector_idx == start_vector_idx ? row_group_start - start_vector_idx * STANDARD_VECTOR_SIZE : 0;
-		idx_t end =
-		    vector_idx == end_vector_idx ? row_group_end - end_vector_idx * STANDARD_VECTOR_SIZE : STANDARD_VECTOR_SIZE;
-		if (start == 0 && end == STANDARD_VECTOR_SIZE) {
-			// entire vector is encapsulated by append: append a single constant
-			auto constant_info = make_unique<ChunkConstantInfo>(this->start + vector_idx * STANDARD_VECTOR_SIZE);
-			constant_info->insert_id = commit_id;
-			constant_info->delete_id = NOT_DELETED_ID;
-			version_info->info[vector_idx] = move(constant_info);
-		} else {
-			// part of a vector is encapsulated: append to that part
-			ChunkVectorInfo *info;
-			if (!version_info->info[vector_idx]) {
-				// first time appending to this vector: create new info
-				auto insert_info = make_unique<ChunkVectorInfo>(this->start + vector_idx * STANDARD_VECTOR_SIZE);
-				info = insert_info.get();
-				version_info->info[vector_idx] = move(insert_info);
-			} else {
-				D_ASSERT(version_info->info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
-				// use existing vector
-				info = (ChunkVectorInfo *)version_info->info[vector_idx].get();
-			}
-			info->Append(start, end, commit_id);
-		}
-	}
-}
-
-void RowGroup::CommitAppend(transaction_t commit_id, idx_t row_group_start, idx_t count) {
-	D_ASSERT(version_info.get());
-	idx_t row_group_end = row_group_start + count;
-	lock_guard<mutex> lock(row_group_lock);
-
-	idx_t start_vector_idx = row_group_start / STANDARD_VECTOR_SIZE;
-	idx_t end_vector_idx = (row_group_end - 1) / STANDARD_VECTOR_SIZE;
-	for (idx_t vector_idx = start_vector_idx; vector_idx <= end_vector_idx; vector_idx++) {
-		idx_t start = vector_idx == start_vector_idx ? row_group_start - start_vector_idx * STANDARD_VECTOR_SIZE : 0;
-		idx_t end =
-		    vector_idx == end_vector_idx ? row_group_end - end_vector_idx * STANDARD_VECTOR_SIZE : STANDARD_VECTOR_SIZE;
-
-		auto info = version_info->info[vector_idx].get();
-		info->CommitAppend(commit_id, start, end);
-	}
-}
-
-void RowGroup::RevertAppend(idx_t row_group_start) {
-	if (!version_info) {
-		return;
-	}
-	idx_t start_row = row_group_start - this->start;
-	idx_t start_vector_idx = (start_row + (STANDARD_VECTOR_SIZE - 1)) / STANDARD_VECTOR_SIZE;
-	for (idx_t vector_idx = start_vector_idx; vector_idx < RowGroup::ROW_GROUP_VECTOR_COUNT; vector_idx++) {
-		version_info->info[vector_idx].reset();
-	}
-	for (auto &column : columns) {
-		column->RevertAppend(row_group_start);
-	}
-	this->count = MinValue<idx_t>(row_group_start - this->start, this->count);
-	Verify();
-}
-
-void RowGroup::InitializeAppend(Transaction &transaction, RowGroupAppendState &append_state,
-                                idx_t remaining_append_count) {
-	append_state.row_group = this;
-	append_state.offset_in_row_group = this->count;
-	// for each column, initialize the append state
-	append_state.states = unique_ptr<ColumnAppendState[]>(new ColumnAppendState[columns.size()]);
-	for (idx_t i = 0; i < columns.size(); i++) {
-		columns[i]->InitializeAppend(append_state.states[i]);
-	}
-	// append the version info for this row_group
-	idx_t append_count = MinValue<idx_t>(remaining_append_count, RowGroup::ROW_GROUP_SIZE - this->count);
-	AppendVersionInfo(transaction, this->count, append_count, transaction.transaction_id);
-}
-
-void RowGroup::Append(RowGroupAppendState &state, DataChunk &chunk, idx_t append_count) {
-	// append to the current row_group
-	for (idx_t i = 0; i < columns.size(); i++) {
-		columns[i]->Append(*stats[i]->statistics, state.states[i], chunk.data[i], append_count);
-	}
-	state.offset_in_row_group += append_count;
-}
-
-void RowGroup::Update(Transaction &transaction, DataChunk &update_chunk, row_t *ids, idx_t offset, idx_t count,
-                      const vector<column_t> &column_ids) {
-#ifdef DEBUG
-	for (size_t i = offset; i < offset + count; i++) {
-		D_ASSERT(ids[i] >= row_t(this->start) && ids[i] < row_t(this->start + this->count));
-	}
-#endif
-	for (idx_t i = 0; i < column_ids.size(); i++) {
-		auto column = column_ids[i];
-		D_ASSERT(column != COLUMN_IDENTIFIER_ROW_ID);
-		D_ASSERT(columns[column]->type.id() == update_chunk.data[i].GetType().id());
-		if (offset > 0) {
-			Vector sliced_vector(update_chunk.data[i], offset);
-			sliced_vector.Normalify(count);
-			columns[column]->Update(transaction, column, sliced_vector, ids + offset, count);
-		} else {
-			columns[column]->Update(transaction, column, update_chunk.data[i], ids, count);
-		}
-		MergeStatistics(column, *columns[column]->GetUpdateStatistics());
-	}
-}
-
-void RowGroup::UpdateColumn(Transaction &transaction, DataChunk &updates, Vector &row_ids,
-                            const vector<column_t> &column_path) {
-	D_ASSERT(updates.ColumnCount() == 1);
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-
-	auto primary_column_idx = column_path[0];
-	D_ASSERT(primary_column_idx != COLUMN_IDENTIFIER_ROW_ID);
-	D_ASSERT(primary_column_idx < columns.size());
-	columns[primary_column_idx]->UpdateColumn(transaction, column_path, updates.data[0], ids, updates.size(), 1);
-	MergeStatistics(primary_column_idx, *columns[primary_column_idx]->GetUpdateStatistics());
-}
-
-unique_ptr<BaseStatistics> RowGroup::GetStatistics(idx_t column_idx) {
-	D_ASSERT(column_idx < stats.size());
-
-	lock_guard<mutex> slock(stats_lock);
-	return stats[column_idx]->statistics->Copy();
-}
-
-void RowGroup::MergeStatistics(idx_t column_idx, const BaseStatistics &other) {
-	D_ASSERT(column_idx < stats.size());
-
-	lock_guard<mutex> slock(stats_lock);
-	stats[column_idx]->statistics->Merge(other);
-}
-
-void RowGroup::MergeIntoStatistics(idx_t column_idx, BaseStatistics &other) {
-	D_ASSERT(column_idx < stats.size());
-
-	lock_guard<mutex> slock(stats_lock);
-	other.Merge(*stats[column_idx]->statistics);
-}
-
-RowGroupPointer RowGroup::Checkpoint(TableDataWriter &writer, vector<unique_ptr<BaseStatistics>> &global_stats) {
-	RowGroupPointer row_group_pointer;
-	vector<unique_ptr<ColumnCheckpointState>> states;
-	states.reserve(columns.size());
-
-	// checkpoint the individual columns of the row group
-	for (idx_t column_idx = 0; column_idx < columns.size(); column_idx++) {
-		auto &column = columns[column_idx];
-		ColumnCheckpointInfo checkpoint_info {writer.GetColumnCompressionType(column_idx)};
-		auto checkpoint_state = column->Checkpoint(*this, writer, checkpoint_info);
-		D_ASSERT(checkpoint_state);
-
-		auto stats = checkpoint_state->GetStatistics();
-		D_ASSERT(stats);
-
-		global_stats[column_idx]->Merge(*stats);
-		row_group_pointer.statistics.push_back(move(stats));
-		states.push_back(move(checkpoint_state));
-	}
-
-	// construct the row group pointer and write the column meta data to disk
-	D_ASSERT(states.size() == columns.size());
-	row_group_pointer.row_start = start;
-	row_group_pointer.tuple_count = count;
-	for (auto &state : states) {
-		// get the current position of the meta data writer
-		auto &meta_writer = writer.GetMetaWriter();
-		auto pointer = meta_writer.GetBlockPointer();
-
-		// store the stats and the data pointers in the row group pointers
-		row_group_pointer.data_pointers.push_back(pointer);
-
-		// now flush the actual column data to disk
-		state->FlushToDisk();
-	}
-	row_group_pointer.versions = version_info;
-	Verify();
-	return row_group_pointer;
-}
-
-void RowGroup::CheckpointDeletes(VersionNode *versions, Serializer &serializer) {
-	if (!versions) {
-		// no version information: write nothing
-		serializer.Write<idx_t>(0);
-		return;
-	}
-	// first count how many ChunkInfo's we need to deserialize
-	idx_t chunk_info_count = 0;
-	for (idx_t vector_idx = 0; vector_idx < RowGroup::ROW_GROUP_VECTOR_COUNT; vector_idx++) {
-		auto chunk_info = versions->info[vector_idx].get();
-		if (!chunk_info) {
-			continue;
-		}
-		chunk_info_count++;
-	}
-	// now serialize the actual version information
-	serializer.Write<idx_t>(chunk_info_count);
-	for (idx_t vector_idx = 0; vector_idx < RowGroup::ROW_GROUP_VECTOR_COUNT; vector_idx++) {
-		auto chunk_info = versions->info[vector_idx].get();
-		if (!chunk_info) {
-			continue;
-		}
-		serializer.Write<idx_t>(vector_idx);
-		chunk_info->Serialize(serializer);
-	}
-}
-
-shared_ptr<VersionNode> RowGroup::DeserializeDeletes(Deserializer &source) {
-	auto chunk_count = source.Read<idx_t>();
-	if (chunk_count == 0) {
-		// no deletes
-		return nullptr;
-	}
-	auto version_info = make_shared<VersionNode>();
-	for (idx_t i = 0; i < chunk_count; i++) {
-		idx_t vector_index = source.Read<idx_t>();
-		if (vector_index >= RowGroup::ROW_GROUP_VECTOR_COUNT) {
-			throw Exception("In DeserializeDeletes, vector_index is out of range for the row group. Corrupted file?");
-		}
-		version_info->info[vector_index] = ChunkInfo::Deserialize(source);
-	}
-	return version_info;
-}
-
-void RowGroup::Serialize(RowGroupPointer &pointer, Serializer &main_serializer) {
-	FieldWriter writer(main_serializer);
-	writer.WriteField<uint64_t>(pointer.row_start);
-	writer.WriteField<uint64_t>(pointer.tuple_count);
-	auto &serializer = writer.GetSerializer();
-	for (auto &stats : pointer.statistics) {
-		stats->Serialize(serializer);
-	}
-	for (auto &data_pointer : pointer.data_pointers) {
-		serializer.Write<block_id_t>(data_pointer.block_id);
-		serializer.Write<uint64_t>(data_pointer.offset);
-	}
-	CheckpointDeletes(pointer.versions.get(), serializer);
-	writer.Finalize();
-}
-
-RowGroupPointer RowGroup::Deserialize(Deserializer &main_source, const vector<ColumnDefinition> &columns) {
-	RowGroupPointer result;
-
-	FieldReader reader(main_source);
-	result.row_start = reader.ReadRequired<uint64_t>();
-	result.tuple_count = reader.ReadRequired<uint64_t>();
-
-	result.data_pointers.reserve(columns.size());
-	result.statistics.reserve(columns.size());
-
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto &col = columns[i];
-		if (col.Generated()) {
-			continue;
-		}
-		auto stats = BaseStatistics::Deserialize(source, columns[i].Type());
-		result.statistics.push_back(move(stats));
-	}
-	for (idx_t i = 0; i < columns.size(); i++) {
-		auto &col = columns[i];
-		if (col.Generated()) {
-			continue;
-		}
-		BlockPointer pointer;
-		pointer.block_id = source.Read<block_id_t>();
-		pointer.offset = source.Read<uint64_t>();
-		result.data_pointers.push_back(pointer);
-	}
-	result.versions = DeserializeDeletes(source);
-
-	reader.Finalize();
-	return result;
-}
-
-//===--------------------------------------------------------------------===//
-// GetStorageInfo
-//===--------------------------------------------------------------------===//
-void RowGroup::GetStorageInfo(idx_t row_group_index, vector<vector<Value>> &result) {
-	for (idx_t col_idx = 0; col_idx < columns.size(); col_idx++) {
-		columns[col_idx]->GetStorageInfo(row_group_index, {col_idx}, result);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Version Delete Information
-//===--------------------------------------------------------------------===//
-class VersionDeleteState {
-public:
-	VersionDeleteState(RowGroup &info, Transaction &transaction, DataTable *table, idx_t base_row)
-	    : info(info), transaction(transaction), table(table), current_info(nullptr),
-	      current_chunk(DConstants::INVALID_INDEX), count(0), base_row(base_row), delete_count(0) {
-	}
-
-	RowGroup &info;
-	Transaction &transaction;
-	DataTable *table;
-	ChunkVectorInfo *current_info;
-	idx_t current_chunk;
-	row_t rows[STANDARD_VECTOR_SIZE];
-	idx_t count;
-	idx_t base_row;
-	idx_t chunk_row;
-	idx_t delete_count;
-
-public:
-	void Delete(row_t row_id);
-	void Flush();
-};
-
-idx_t RowGroup::Delete(Transaction &transaction, DataTable *table, row_t *ids, idx_t count) {
-	lock_guard<mutex> lock(row_group_lock);
-	VersionDeleteState del_state(*this, transaction, table, this->start);
-
-	// obtain a write lock
-	for (idx_t i = 0; i < count; i++) {
-		D_ASSERT(ids[i] >= 0);
-		D_ASSERT(idx_t(ids[i]) >= this->start && idx_t(ids[i]) < this->start + this->count);
-		del_state.Delete(ids[i] - this->start);
-	}
-	del_state.Flush();
-	return del_state.delete_count;
-}
-
-void RowGroup::Verify() {
-#ifdef DEBUG
-	for (auto &column : columns) {
-		column->Verify(*this);
-	}
-#endif
-}
-
-void VersionDeleteState::Delete(row_t row_id) {
-	D_ASSERT(row_id >= 0);
-	idx_t vector_idx = row_id / STANDARD_VECTOR_SIZE;
-	idx_t idx_in_vector = row_id - vector_idx * STANDARD_VECTOR_SIZE;
-	if (current_chunk != vector_idx) {
-		Flush();
-
-		if (!info.version_info) {
-			info.version_info = make_unique<VersionNode>();
-		}
-
-		if (!info.version_info->info[vector_idx]) {
-			// no info yet: create it
-			info.version_info->info[vector_idx] =
-			    make_unique<ChunkVectorInfo>(info.start + vector_idx * STANDARD_VECTOR_SIZE);
-		} else if (info.version_info->info[vector_idx]->type == ChunkInfoType::CONSTANT_INFO) {
-			auto &constant = (ChunkConstantInfo &)*info.version_info->info[vector_idx];
-			// info exists but it's a constant info: convert to a vector info
-			auto new_info = make_unique<ChunkVectorInfo>(info.start + vector_idx * STANDARD_VECTOR_SIZE);
-			new_info->insert_id = constant.insert_id.load();
-			for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
-				new_info->inserted[i] = constant.insert_id.load();
-			}
-			info.version_info->info[vector_idx] = move(new_info);
-		}
-		D_ASSERT(info.version_info->info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
-		current_info = (ChunkVectorInfo *)info.version_info->info[vector_idx].get();
-		current_chunk = vector_idx;
-		chunk_row = vector_idx * STANDARD_VECTOR_SIZE;
-	}
-	rows[count++] = idx_in_vector;
-}
-
-void VersionDeleteState::Flush() {
-	if (count == 0) {
-		return;
-	}
-	// delete in the current info
-	delete_count += current_info->Delete(transaction, rows, count);
-	// now push the delete into the undo buffer
-	transaction.PushDelete(table, current_info, rows, count, base_row + chunk_row);
-	count = 0;
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-SegmentBase *SegmentTree::GetRootSegment() {
-	return root_node.get();
-}
-
-SegmentBase *SegmentTree::GetLastSegment() {
-	return nodes.empty() ? nullptr : nodes.back().node;
-}
-
-SegmentBase *SegmentTree::GetSegment(idx_t row_number) {
-	lock_guard<mutex> tree_lock(node_lock);
-	return nodes[GetSegmentIndex(row_number)].node;
-}
-
-idx_t SegmentTree::GetSegmentIndex(idx_t row_number) {
-	D_ASSERT(!nodes.empty());
-	D_ASSERT(row_number >= nodes[0].row_start);
-	D_ASSERT(row_number < nodes.back().row_start + nodes.back().node->count);
-	idx_t lower = 0;
-	idx_t upper = nodes.size() - 1;
-	// binary search to find the node
-	while (lower <= upper) {
-		idx_t index = (lower + upper) / 2;
-		D_ASSERT(index < nodes.size());
-		auto &entry = nodes[index];
-		D_ASSERT(entry.row_start == entry.node->start);
-		if (row_number < entry.row_start) {
-			upper = index - 1;
-		} else if (row_number >= entry.row_start + entry.node->count) {
-			lower = index + 1;
-		} else {
-			return index;
-		}
-	}
-	throw InternalException("Could not find node in column segment tree!");
-}
-
-void SegmentTree::AppendSegment(unique_ptr<SegmentBase> segment) {
-	D_ASSERT(segment);
-	// add the node to the list of nodes
-	SegmentNode node;
-	node.row_start = segment->start;
-	node.node = segment.get();
-	nodes.push_back(node);
-
-	if (nodes.size() > 1) {
-		// add the node as the next pointer of the last node
-		D_ASSERT(!nodes[nodes.size() - 2].node->next);
-		nodes[nodes.size() - 2].node->next = move(segment);
-	} else {
-		root_node = move(segment);
-	}
-}
-
-void SegmentTree::Replace(SegmentTree &other) {
-	root_node = move(other.root_node);
-	nodes = move(other.nodes);
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-namespace duckdb {
-
-StandardColumnData::StandardColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type,
-                                       ColumnData *parent)
-    : ColumnData(info, column_index, start_row, move(type), parent), validity(info, 0, start_row, this) {
-}
-
-bool StandardColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
-	if (!state.segment_checked) {
-		if (!state.current) {
-			return true;
-		}
-		state.segment_checked = true;
-		auto prune_result = filter.CheckStatistics(*state.current->stats.statistics);
-		if (prune_result != FilterPropagateResult::FILTER_ALWAYS_FALSE) {
-			return true;
-		}
-		if (updates) {
-			auto update_stats = updates->GetStatistics();
-			prune_result = filter.CheckStatistics(*update_stats);
-			return prune_result != FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		} else {
-			return false;
-		}
-	} else {
-		return true;
-	}
-}
-
-void StandardColumnData::InitializeScan(ColumnScanState &state) {
-	ColumnData::InitializeScan(state);
-
-	// initialize the validity segment
-	ColumnScanState child_state;
-	validity.InitializeScan(child_state);
-	state.child_states.push_back(move(child_state));
-}
-
-void StandardColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	ColumnData::InitializeScanWithOffset(state, row_idx);
-
-	// initialize the validity segment
-	ColumnScanState child_state;
-	validity.InitializeScanWithOffset(child_state, row_idx);
-	state.child_states.push_back(move(child_state));
-}
-
-idx_t StandardColumnData::Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
-	D_ASSERT(state.row_index == state.child_states[0].row_index);
-	auto scan_count = ColumnData::Scan(transaction, vector_index, state, result);
-	validity.Scan(transaction, vector_index, state.child_states[0], result);
-	return scan_count;
-}
-
-idx_t StandardColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result,
-                                        bool allow_updates) {
-	D_ASSERT(state.row_index == state.child_states[0].row_index);
-	auto scan_count = ColumnData::ScanCommitted(vector_index, state, result, allow_updates);
-	validity.ScanCommitted(vector_index, state.child_states[0], result, allow_updates);
-	return scan_count;
-}
-
-idx_t StandardColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) {
-	auto scan_count = ColumnData::ScanCount(state, result, count);
-	validity.ScanCount(state.child_states[0], result, count);
-	return scan_count;
-}
-
-void StandardColumnData::InitializeAppend(ColumnAppendState &state) {
-	ColumnData::InitializeAppend(state);
-
-	ColumnAppendState child_append;
-	validity.InitializeAppend(child_append);
-	state.child_appends.push_back(move(child_append));
-}
-
-void StandardColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, VectorData &vdata, idx_t count) {
-	ColumnData::AppendData(stats, state, vdata, count);
-
-	validity.AppendData(*stats.validity_stats, state.child_appends[0], vdata, count);
-}
-
-void StandardColumnData::RevertAppend(row_t start_row) {
-	ColumnData::RevertAppend(start_row);
-
-	validity.RevertAppend(start_row);
-}
-
-idx_t StandardColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	// fetch validity mask
-	if (state.child_states.empty()) {
-		ColumnScanState child_state;
-		state.child_states.push_back(move(child_state));
-	}
-	auto scan_count = ColumnData::Fetch(state, row_id, result);
-	validity.Fetch(state.child_states[0], row_id, result);
-	return scan_count;
-}
-
-void StandardColumnData::Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                                idx_t update_count) {
-	ColumnData::Update(transaction, column_index, update_vector, row_ids, update_count);
-	validity.Update(transaction, column_index, update_vector, row_ids, update_count);
-}
-
-void StandardColumnData::UpdateColumn(Transaction &transaction, const vector<column_t> &column_path,
-                                      Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
-	if (depth >= column_path.size()) {
-		// update this column
-		ColumnData::Update(transaction, column_path[0], update_vector, row_ids, update_count);
-	} else {
-		// update the child column (i.e. the validity column)
-		validity.UpdateColumn(transaction, column_path, update_vector, row_ids, update_count, depth + 1);
-	}
-}
-
-unique_ptr<BaseStatistics> StandardColumnData::GetUpdateStatistics() {
-	auto stats = updates ? updates->GetStatistics() : nullptr;
-	auto validity_stats = validity.GetUpdateStatistics();
-	if (!stats && !validity_stats) {
-		return nullptr;
-	}
-	if (!stats) {
-		stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
-	}
-	stats->validity_stats = move(validity_stats);
-	return stats;
-}
-
-void StandardColumnData::FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                                  idx_t result_idx) {
-	// find the segment the row belongs to
-	if (state.child_states.empty()) {
-		auto child_state = make_unique<ColumnFetchState>();
-		state.child_states.push_back(move(child_state));
-	}
-	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
-	ColumnData::FetchRow(transaction, state, row_id, result, result_idx);
-}
-
-void StandardColumnData::CommitDropColumn() {
-	ColumnData::CommitDropColumn();
-	validity.CommitDropColumn();
-}
-
-struct StandardColumnCheckpointState : public ColumnCheckpointState {
-	StandardColumnCheckpointState(RowGroup &row_group, ColumnData &column_data, TableDataWriter &writer)
-	    : ColumnCheckpointState(row_group, column_data, writer) {
-	}
-
-	unique_ptr<ColumnCheckpointState> validity_state;
-
-public:
-	unique_ptr<BaseStatistics> GetStatistics() override {
-		D_ASSERT(global_stats);
-		global_stats->validity_stats = validity_state->GetStatistics();
-		return move(global_stats);
-	}
-
-	void FlushToDisk() override {
-		ColumnCheckpointState::FlushToDisk();
-		validity_state->FlushToDisk();
-	}
-};
-
-unique_ptr<ColumnCheckpointState> StandardColumnData::CreateCheckpointState(RowGroup &row_group,
-                                                                            TableDataWriter &writer) {
-	return make_unique<StandardColumnCheckpointState>(row_group, *this, writer);
-}
-
-unique_ptr<ColumnCheckpointState> StandardColumnData::Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-                                                                 ColumnCheckpointInfo &checkpoint_info) {
-	auto validity_state = validity.Checkpoint(row_group, writer, checkpoint_info);
-	auto base_state = ColumnData::Checkpoint(row_group, writer, checkpoint_info);
-	auto &checkpoint_state = (StandardColumnCheckpointState &)*base_state;
-	checkpoint_state.validity_state = move(validity_state);
-	return base_state;
-}
-
-void StandardColumnData::CheckpointScan(ColumnSegment *segment, ColumnScanState &state, idx_t row_group_start,
-                                        idx_t count, Vector &scan_vector) {
-	ColumnData::CheckpointScan(segment, state, row_group_start, count, scan_vector);
-
-	idx_t offset_in_row_group = state.row_index - row_group_start;
-	validity.ScanCommittedRange(row_group_start, offset_in_row_group, count, scan_vector);
-}
-
-void StandardColumnData::DeserializeColumn(Deserializer &source) {
-	ColumnData::DeserializeColumn(source);
-	validity.DeserializeColumn(source);
-}
-
-void StandardColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) {
-	ColumnData::GetStorageInfo(row_group_index, col_path, result);
-	col_path.push_back(0);
-	validity.GetStorageInfo(row_group_index, move(col_path), result);
-}
-
-void StandardColumnData::Verify(RowGroup &parent) {
-#ifdef DEBUG
-	ColumnData::Verify(parent);
-	validity.Verify(parent);
-#endif
-}
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-StructColumnData::StructColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type_p,
-                                   ColumnData *parent)
-    : ColumnData(info, column_index, start_row, move(type_p), parent), validity(info, 0, start_row, this) {
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-	auto &child_types = StructType::GetChildTypes(type);
-	D_ASSERT(child_types.size() > 0);
-	// the sub column index, starting at 1 (0 is the validity mask)
-	idx_t sub_column_index = 1;
-	for (auto &child_type : child_types) {
-		sub_columns.push_back(
-		    ColumnData::CreateColumnUnique(info, sub_column_index, start_row, child_type.second, this));
-		sub_column_index++;
-	}
-}
-
-bool StructColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
-	// table filters are not supported yet for struct columns
-	return false;
-}
-
-idx_t StructColumnData::GetMaxEntry() {
-	return sub_columns[0]->GetMaxEntry();
-}
-
-void StructColumnData::InitializeScan(ColumnScanState &state) {
-	D_ASSERT(state.child_states.empty());
-
-	state.row_index = 0;
-	state.current = nullptr;
-
-	// initialize the validity segment
-	ColumnScanState validity_state;
-	validity.InitializeScan(validity_state);
-	state.child_states.push_back(move(validity_state));
-
-	// initialize the sub-columns
-	for (auto &sub_column : sub_columns) {
-		ColumnScanState child_state;
-		sub_column->InitializeScan(child_state);
-		state.child_states.push_back(move(child_state));
-	}
-}
-
-void StructColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	D_ASSERT(state.child_states.empty());
-
-	state.row_index = row_idx;
-	state.current = nullptr;
-
-	// initialize the validity segment
-	ColumnScanState validity_state;
-	validity.InitializeScanWithOffset(validity_state, row_idx);
-	state.child_states.push_back(move(validity_state));
-
-	// initialize the sub-columns
-	for (auto &sub_column : sub_columns) {
-		ColumnScanState child_state;
-		sub_column->InitializeScanWithOffset(child_state, row_idx);
-		state.child_states.push_back(move(child_state));
-	}
-}
-
-idx_t StructColumnData::Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
-	auto scan_count = validity.Scan(transaction, vector_index, state.child_states[0], result);
-	auto &child_entries = StructVector::GetEntries(result);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		sub_columns[i]->Scan(transaction, vector_index, state.child_states[i + 1], *child_entries[i]);
-	}
-	return scan_count;
-}
-
-idx_t StructColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) {
-	auto scan_count = validity.ScanCommitted(vector_index, state.child_states[0], result, allow_updates);
-	auto &child_entries = StructVector::GetEntries(result);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		sub_columns[i]->ScanCommitted(vector_index, state.child_states[i + 1], *child_entries[i], allow_updates);
-	}
-	return scan_count;
-}
-
-idx_t StructColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count) {
-	auto scan_count = validity.ScanCount(state.child_states[0], result, count);
-	auto &child_entries = StructVector::GetEntries(result);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		sub_columns[i]->ScanCount(state.child_states[i + 1], *child_entries[i], count);
-	}
-	return scan_count;
-}
-
-void StructColumnData::InitializeAppend(ColumnAppendState &state) {
-	ColumnAppendState validity_append;
-	validity.InitializeAppend(validity_append);
-	state.child_appends.push_back(move(validity_append));
-
-	for (auto &sub_column : sub_columns) {
-		ColumnAppendState child_append;
-		sub_column->InitializeAppend(child_append);
-		state.child_appends.push_back(move(child_append));
-	}
-}
-
-void StructColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) {
-	vector.Normalify(count);
-
-	// append the null values
-	validity.Append(*stats.validity_stats, state.child_appends[0], vector, count);
-
-	auto &struct_validity = FlatVector::Validity(vector);
-
-	auto &struct_stats = (StructStatistics &)stats;
-	auto &child_entries = StructVector::GetEntries(vector);
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		if (!struct_validity.AllValid()) {
-			// we set the child entries of the struct to NULL
-			// for any values in which the struct itself is NULL
-			child_entries[i]->Normalify(count);
-
-			auto &child_validity = FlatVector::Validity(*child_entries[i]);
-			child_validity.Combine(struct_validity, count);
-		}
-		sub_columns[i]->Append(*struct_stats.child_stats[i], state.child_appends[i + 1], *child_entries[i], count);
-	}
-}
-
-void StructColumnData::RevertAppend(row_t start_row) {
-	validity.RevertAppend(start_row);
-	for (auto &sub_column : sub_columns) {
-		sub_column->RevertAppend(start_row);
-	}
-}
-
-idx_t StructColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
-	// fetch validity mask
-	auto &child_entries = StructVector::GetEntries(result);
-	// insert any child states that are required
-	for (idx_t i = state.child_states.size(); i < child_entries.size() + 1; i++) {
-		ColumnScanState child_state;
-		state.child_states.push_back(move(child_state));
-	}
-	// fetch the validity state
-	idx_t scan_count = validity.Fetch(state.child_states[0], row_id, result);
-	// fetch the sub-column states
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Fetch(state.child_states[i + 1], row_id, *child_entries[i]);
-	}
-	return scan_count;
-}
-
-void StructColumnData::Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                              idx_t update_count) {
-	validity.Update(transaction, column_index, update_vector, row_ids, update_count);
-	auto &child_entries = StructVector::GetEntries(update_vector);
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Update(transaction, column_index, *child_entries[i], row_ids, update_count);
-	}
-}
-
-void StructColumnData::UpdateColumn(Transaction &transaction, const vector<column_t> &column_path,
-                                    Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
-	// we can never DIRECTLY update a struct column
-	if (depth >= column_path.size()) {
-		throw InternalException("Attempting to directly update a struct column - this should not be possible");
-	}
-	auto update_column = column_path[depth];
-	if (update_column == 0) {
-		// update the validity column
-		validity.UpdateColumn(transaction, column_path, update_vector, row_ids, update_count, depth + 1);
-	} else {
-		if (update_column > sub_columns.size()) {
-			throw InternalException("Update column_path out of range");
-		}
-		sub_columns[update_column - 1]->UpdateColumn(transaction, column_path, update_vector, row_ids, update_count,
-		                                             depth + 1);
-	}
-}
-
-unique_ptr<BaseStatistics> StructColumnData::GetUpdateStatistics() {
-	// check if any child column has updates
-	auto stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
-	auto &struct_stats = (StructStatistics &)*stats;
-	stats->validity_stats = validity.GetUpdateStatistics();
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		auto child_stats = sub_columns[i]->GetUpdateStatistics();
-		if (child_stats) {
-			struct_stats.child_stats[i] = move(child_stats);
-		}
-	}
-	return stats;
-}
-
-void StructColumnData::FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-                                idx_t result_idx) {
-	// fetch validity mask
-	auto &child_entries = StructVector::GetEntries(result);
-	// insert any child states that are required
-	for (idx_t i = state.child_states.size(); i < child_entries.size() + 1; i++) {
-		auto child_state = make_unique<ColumnFetchState>();
-		state.child_states.push_back(move(child_state));
-	}
-	// fetch the validity state
-	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
-	// fetch the sub-column states
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->FetchRow(transaction, *state.child_states[i + 1], row_id, *child_entries[i], result_idx);
-	}
-}
-
-void StructColumnData::CommitDropColumn() {
-	validity.CommitDropColumn();
-	for (auto &sub_column : sub_columns) {
-		sub_column->CommitDropColumn();
-	}
-}
-
-struct StructColumnCheckpointState : public ColumnCheckpointState {
-	StructColumnCheckpointState(RowGroup &row_group, ColumnData &column_data, TableDataWriter &writer)
-	    : ColumnCheckpointState(row_group, column_data, writer) {
-		global_stats = make_unique<StructStatistics>(column_data.type);
-	}
-
-	unique_ptr<ColumnCheckpointState> validity_state;
-	vector<unique_ptr<ColumnCheckpointState>> child_states;
-
-public:
-	unique_ptr<BaseStatistics> GetStatistics() override {
-		auto stats = make_unique<StructStatistics>(column_data.type);
-		D_ASSERT(stats->child_stats.size() == child_states.size());
-		stats->validity_stats = validity_state->GetStatistics();
-		for (idx_t i = 0; i < child_states.size(); i++) {
-			stats->child_stats[i] = child_states[i]->GetStatistics();
-			D_ASSERT(stats->child_stats[i]);
-		}
-		return move(stats);
-	}
-
-	void FlushToDisk() override {
-		validity_state->FlushToDisk();
-		for (auto &state : child_states) {
-			state->FlushToDisk();
-		}
-	}
-};
-
-unique_ptr<ColumnCheckpointState> StructColumnData::CreateCheckpointState(RowGroup &row_group,
-                                                                          TableDataWriter &writer) {
-	return make_unique<StructColumnCheckpointState>(row_group, *this, writer);
-}
-
-unique_ptr<ColumnCheckpointState> StructColumnData::Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-                                                               ColumnCheckpointInfo &checkpoint_info) {
-	auto checkpoint_state = make_unique<StructColumnCheckpointState>(row_group, *this, writer);
-	checkpoint_state->validity_state = validity.Checkpoint(row_group, writer, checkpoint_info);
-	for (auto &sub_column : sub_columns) {
-		checkpoint_state->child_states.push_back(sub_column->Checkpoint(row_group, writer, checkpoint_info));
-	}
-	return move(checkpoint_state);
-}
-
-void StructColumnData::DeserializeColumn(Deserializer &source) {
-	validity.DeserializeColumn(source);
-	for (auto &sub_column : sub_columns) {
-		sub_column->DeserializeColumn(source);
-	}
-}
-
-void StructColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) {
-	col_path.push_back(0);
-	validity.GetStorageInfo(row_group_index, col_path, result);
-	for (idx_t i = 0; i < sub_columns.size(); i++) {
-		col_path.back() = i + 1;
-		sub_columns[i]->GetStorageInfo(row_group_index, col_path, result);
-	}
-}
-
-void StructColumnData::Verify(RowGroup &parent) {
-#ifdef DEBUG
-	ColumnData::Verify(parent);
-	validity.Verify(parent);
-	for (auto &sub_column : sub_columns) {
-		sub_column->Verify(parent);
-	}
-#endif
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-static UpdateSegment::initialize_update_function_t GetInitializeUpdateFunction(PhysicalType type);
-static UpdateSegment::fetch_update_function_t GetFetchUpdateFunction(PhysicalType type);
-static UpdateSegment::fetch_committed_function_t GetFetchCommittedFunction(PhysicalType type);
-static UpdateSegment::fetch_committed_range_function_t GetFetchCommittedRangeFunction(PhysicalType type);
-
-static UpdateSegment::merge_update_function_t GetMergeUpdateFunction(PhysicalType type);
-static UpdateSegment::rollback_update_function_t GetRollbackUpdateFunction(PhysicalType type);
-static UpdateSegment::statistics_update_function_t GetStatisticsUpdateFunction(PhysicalType type);
-static UpdateSegment::fetch_row_function_t GetFetchRowFunction(PhysicalType type);
-
-UpdateSegment::UpdateSegment(ColumnData &column_data) : column_data(column_data), stats(column_data.type) {
-	auto physical_type = column_data.type.InternalType();
-
-	this->type_size = GetTypeIdSize(physical_type);
-
-	this->initialize_update_function = GetInitializeUpdateFunction(physical_type);
-	this->fetch_update_function = GetFetchUpdateFunction(physical_type);
-	this->fetch_committed_function = GetFetchCommittedFunction(physical_type);
-	this->fetch_committed_range = GetFetchCommittedRangeFunction(physical_type);
-	this->fetch_row_function = GetFetchRowFunction(physical_type);
-	this->merge_update_function = GetMergeUpdateFunction(physical_type);
-	this->rollback_update_function = GetRollbackUpdateFunction(physical_type);
-	this->statistics_update_function = GetStatisticsUpdateFunction(physical_type);
-}
-
-UpdateSegment::~UpdateSegment() {
-}
-
-void UpdateSegment::ClearUpdates() {
-	stats.Reset();
-	root.reset();
-	heap.Destroy();
-}
-
-//===--------------------------------------------------------------------===//
-// Update Info Helpers
-//===--------------------------------------------------------------------===//
-Value UpdateInfo::GetValue(idx_t index) {
-	auto &type = segment->column_data.type;
-
-	switch (type.id()) {
-	case LogicalTypeId::VALIDITY:
-		return Value::BOOLEAN(((bool *)tuple_data)[index]);
-	case LogicalTypeId::INTEGER:
-		return Value::INTEGER(((int32_t *)tuple_data)[index]);
-	default:
-		throw NotImplementedException("Unimplemented type for UpdateInfo::GetValue");
-	}
-}
-
-void UpdateInfo::Print() {
-	Printer::Print(ToString());
-}
-
-string UpdateInfo::ToString() {
-	auto &type = segment->column_data.type;
-	string result = "Update Info [" + type.ToString() + ", Count: " + to_string(N) +
-	                ", Transaction Id: " + to_string(version_number) + "]\n";
-	for (idx_t i = 0; i < N; i++) {
-		result += to_string(tuples[i]) + ": " + GetValue(i).ToString() + "\n";
-	}
-	if (next) {
-		result += "\nChild Segment: " + next->ToString();
-	}
-	return result;
-}
-
-void UpdateInfo::Verify() {
-#ifdef DEBUG
-	for (idx_t i = 1; i < N; i++) {
-		D_ASSERT(tuples[i] > tuples[i - 1] && tuples[i] < STANDARD_VECTOR_SIZE);
-	}
-#endif
-}
-
-//===--------------------------------------------------------------------===//
-// Update Fetch
-//===--------------------------------------------------------------------===//
-static void MergeValidityInfo(UpdateInfo *current, ValidityMask &result_mask) {
-	auto info_data = (bool *)current->tuple_data;
-	for (idx_t i = 0; i < current->N; i++) {
-		result_mask.Set(current->tuples[i], info_data[i]);
-	}
-}
-
-static void UpdateMergeValidity(transaction_t start_time, transaction_t transaction_id, UpdateInfo *info,
-                                Vector &result) {
-	auto &result_mask = FlatVector::Validity(result);
-	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id,
-	                                  [&](UpdateInfo *current) { MergeValidityInfo(current, result_mask); });
-}
-
-template <class T>
-static void MergeUpdateInfo(UpdateInfo *current, T *result_data) {
-	auto info_data = (T *)current->tuple_data;
-	if (current->N == STANDARD_VECTOR_SIZE) {
-		// special case: update touches ALL tuples of this vector
-		// in this case we can just memcpy the data
-		// since the layout of the update info is guaranteed to be [0, 1, 2, 3, ...]
-		memcpy(result_data, info_data, sizeof(T) * current->N);
-	} else {
-		for (idx_t i = 0; i < current->N; i++) {
-			result_data[current->tuples[i]] = info_data[i];
-		}
-	}
-}
-
-template <class T>
-static void UpdateMergeFetch(transaction_t start_time, transaction_t transaction_id, UpdateInfo *info, Vector &result) {
-	auto result_data = FlatVector::GetData<T>(result);
-	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id,
-	                                  [&](UpdateInfo *current) { MergeUpdateInfo<T>(current, result_data); });
-}
-
-static UpdateSegment::fetch_update_function_t GetFetchUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return UpdateMergeValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return UpdateMergeFetch<int8_t>;
-	case PhysicalType::INT16:
-		return UpdateMergeFetch<int16_t>;
-	case PhysicalType::INT32:
-		return UpdateMergeFetch<int32_t>;
-	case PhysicalType::INT64:
-		return UpdateMergeFetch<int64_t>;
-	case PhysicalType::UINT8:
-		return UpdateMergeFetch<uint8_t>;
-	case PhysicalType::UINT16:
-		return UpdateMergeFetch<uint16_t>;
-	case PhysicalType::UINT32:
-		return UpdateMergeFetch<uint32_t>;
-	case PhysicalType::UINT64:
-		return UpdateMergeFetch<uint64_t>;
-	case PhysicalType::INT128:
-		return UpdateMergeFetch<hugeint_t>;
-	case PhysicalType::FLOAT:
-		return UpdateMergeFetch<float>;
-	case PhysicalType::DOUBLE:
-		return UpdateMergeFetch<double>;
-	case PhysicalType::INTERVAL:
-		return UpdateMergeFetch<interval_t>;
-	case PhysicalType::VARCHAR:
-		return UpdateMergeFetch<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment");
-	}
-}
-
-void UpdateSegment::FetchUpdates(Transaction &transaction, idx_t vector_index, Vector &result) {
-	auto lock_handle = lock.GetSharedLock();
-	if (!root) {
-		return;
-	}
-	if (!root->info[vector_index]) {
-		return;
-	}
-	// FIXME: normalify if this is not the case... need to pass in count?
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	fetch_update_function(transaction.start_time, transaction.transaction_id, root->info[vector_index]->info.get(),
-	                      result);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Committed
-//===--------------------------------------------------------------------===//
-static void FetchCommittedValidity(UpdateInfo *info, Vector &result) {
-	auto &result_mask = FlatVector::Validity(result);
-	MergeValidityInfo(info, result_mask);
-}
-
-template <class T>
-static void TemplatedFetchCommitted(UpdateInfo *info, Vector &result) {
-	auto result_data = FlatVector::GetData<T>(result);
-	MergeUpdateInfo<T>(info, result_data);
-}
-
-static UpdateSegment::fetch_committed_function_t GetFetchCommittedFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return FetchCommittedValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedFetchCommitted<int8_t>;
-	case PhysicalType::INT16:
-		return TemplatedFetchCommitted<int16_t>;
-	case PhysicalType::INT32:
-		return TemplatedFetchCommitted<int32_t>;
-	case PhysicalType::INT64:
-		return TemplatedFetchCommitted<int64_t>;
-	case PhysicalType::UINT8:
-		return TemplatedFetchCommitted<uint8_t>;
-	case PhysicalType::UINT16:
-		return TemplatedFetchCommitted<uint16_t>;
-	case PhysicalType::UINT32:
-		return TemplatedFetchCommitted<uint32_t>;
-	case PhysicalType::UINT64:
-		return TemplatedFetchCommitted<uint64_t>;
-	case PhysicalType::INT128:
-		return TemplatedFetchCommitted<hugeint_t>;
-	case PhysicalType::FLOAT:
-		return TemplatedFetchCommitted<float>;
-	case PhysicalType::DOUBLE:
-		return TemplatedFetchCommitted<double>;
-	case PhysicalType::INTERVAL:
-		return TemplatedFetchCommitted<interval_t>;
-	case PhysicalType::VARCHAR:
-		return TemplatedFetchCommitted<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment");
-	}
-}
-
-void UpdateSegment::FetchCommitted(idx_t vector_index, Vector &result) {
-	auto lock_handle = lock.GetSharedLock();
-
-	if (!root) {
-		return;
-	}
-	if (!root->info[vector_index]) {
-		return;
-	}
-	// FIXME: normalify if this is not the case... need to pass in count?
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	fetch_committed_function(root->info[vector_index]->info.get(), result);
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Range
-//===--------------------------------------------------------------------===//
-static void MergeUpdateInfoRangeValidity(UpdateInfo *current, idx_t start, idx_t end, idx_t result_offset,
-                                         ValidityMask &result_mask) {
-	auto info_data = (bool *)current->tuple_data;
-	for (idx_t i = 0; i < current->N; i++) {
-		auto tuple_idx = current->tuples[i];
-		if (tuple_idx < start) {
-			continue;
-		} else if (tuple_idx >= end) {
-			break;
-		}
-		auto result_idx = result_offset + tuple_idx - start;
-		result_mask.Set(result_idx, info_data[i]);
-	}
-}
-
-static void FetchCommittedRangeValidity(UpdateInfo *info, idx_t start, idx_t end, idx_t result_offset, Vector &result) {
-	auto &result_mask = FlatVector::Validity(result);
-	MergeUpdateInfoRangeValidity(info, start, end, result_offset, result_mask);
-}
-
-template <class T>
-static void MergeUpdateInfoRange(UpdateInfo *current, idx_t start, idx_t end, idx_t result_offset, T *result_data) {
-	auto info_data = (T *)current->tuple_data;
-	for (idx_t i = 0; i < current->N; i++) {
-		auto tuple_idx = current->tuples[i];
-		if (tuple_idx < start) {
-			continue;
-		} else if (tuple_idx >= end) {
-			break;
-		}
-		auto result_idx = result_offset + tuple_idx - start;
-		result_data[result_idx] = info_data[i];
-	}
-}
-
-template <class T>
-static void TemplatedFetchCommittedRange(UpdateInfo *info, idx_t start, idx_t end, idx_t result_offset,
-                                         Vector &result) {
-	auto result_data = FlatVector::GetData<T>(result);
-	MergeUpdateInfoRange<T>(info, start, end, result_offset, result_data);
-}
-
-static UpdateSegment::fetch_committed_range_function_t GetFetchCommittedRangeFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return FetchCommittedRangeValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedFetchCommittedRange<int8_t>;
-	case PhysicalType::INT16:
-		return TemplatedFetchCommittedRange<int16_t>;
-	case PhysicalType::INT32:
-		return TemplatedFetchCommittedRange<int32_t>;
-	case PhysicalType::INT64:
-		return TemplatedFetchCommittedRange<int64_t>;
-	case PhysicalType::UINT8:
-		return TemplatedFetchCommittedRange<uint8_t>;
-	case PhysicalType::UINT16:
-		return TemplatedFetchCommittedRange<uint16_t>;
-	case PhysicalType::UINT32:
-		return TemplatedFetchCommittedRange<uint32_t>;
-	case PhysicalType::UINT64:
-		return TemplatedFetchCommittedRange<uint64_t>;
-	case PhysicalType::INT128:
-		return TemplatedFetchCommittedRange<hugeint_t>;
-	case PhysicalType::FLOAT:
-		return TemplatedFetchCommittedRange<float>;
-	case PhysicalType::DOUBLE:
-		return TemplatedFetchCommittedRange<double>;
-	case PhysicalType::INTERVAL:
-		return TemplatedFetchCommittedRange<interval_t>;
-	case PhysicalType::VARCHAR:
-		return TemplatedFetchCommittedRange<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment");
-	}
-}
-
-void UpdateSegment::FetchCommittedRange(idx_t start_row, idx_t count, Vector &result) {
-	D_ASSERT(count > 0);
-	if (!root) {
-		return;
-	}
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-
-	idx_t end_row = start_row + count;
-	idx_t start_vector = start_row / STANDARD_VECTOR_SIZE;
-	idx_t end_vector = (end_row - 1) / STANDARD_VECTOR_SIZE;
-	D_ASSERT(start_vector <= end_vector);
-	D_ASSERT(end_vector < RowGroup::ROW_GROUP_VECTOR_COUNT);
-
-	for (idx_t vector_idx = start_vector; vector_idx <= end_vector; vector_idx++) {
-		if (!root->info[vector_idx]) {
-			continue;
-		}
-		idx_t start_in_vector = vector_idx == start_vector ? start_row - start_vector * STANDARD_VECTOR_SIZE : 0;
-		idx_t end_in_vector =
-		    vector_idx == end_vector ? end_row - end_vector * STANDARD_VECTOR_SIZE : STANDARD_VECTOR_SIZE;
-		D_ASSERT(start_in_vector < end_in_vector);
-		D_ASSERT(end_in_vector > 0 && end_in_vector <= STANDARD_VECTOR_SIZE);
-		idx_t result_offset = ((vector_idx * STANDARD_VECTOR_SIZE) + start_in_vector) - start_row;
-		fetch_committed_range(root->info[vector_idx]->info.get(), start_in_vector, end_in_vector, result_offset,
-		                      result);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Fetch Row
-//===--------------------------------------------------------------------===//
-static void FetchRowValidity(transaction_t start_time, transaction_t transaction_id, UpdateInfo *info, idx_t row_idx,
-                             Vector &result, idx_t result_idx) {
-	auto &result_mask = FlatVector::Validity(result);
-	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id, [&](UpdateInfo *current) {
-		auto info_data = (bool *)current->tuple_data;
-		// FIXME: we could do a binary search in here
-		for (idx_t i = 0; i < current->N; i++) {
-			if (current->tuples[i] == row_idx) {
-				result_mask.Set(result_idx, info_data[i]);
-				break;
-			} else if (current->tuples[i] > row_idx) {
-				break;
-			}
-		}
-	});
-}
-
-template <class T>
-static void TemplatedFetchRow(transaction_t start_time, transaction_t transaction_id, UpdateInfo *info, idx_t row_idx,
-                              Vector &result, idx_t result_idx) {
-	auto result_data = FlatVector::GetData<T>(result);
-	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id, [&](UpdateInfo *current) {
-		auto info_data = (T *)current->tuple_data;
-		// FIXME: we could do a binary search in here
-		for (idx_t i = 0; i < current->N; i++) {
-			if (current->tuples[i] == row_idx) {
-				result_data[result_idx] = info_data[i];
-				break;
-			} else if (current->tuples[i] > row_idx) {
-				break;
-			}
-		}
-	});
-}
-
-static UpdateSegment::fetch_row_function_t GetFetchRowFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return FetchRowValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedFetchRow<int8_t>;
-	case PhysicalType::INT16:
-		return TemplatedFetchRow<int16_t>;
-	case PhysicalType::INT32:
-		return TemplatedFetchRow<int32_t>;
-	case PhysicalType::INT64:
-		return TemplatedFetchRow<int64_t>;
-	case PhysicalType::UINT8:
-		return TemplatedFetchRow<uint8_t>;
-	case PhysicalType::UINT16:
-		return TemplatedFetchRow<uint16_t>;
-	case PhysicalType::UINT32:
-		return TemplatedFetchRow<uint32_t>;
-	case PhysicalType::UINT64:
-		return TemplatedFetchRow<uint64_t>;
-	case PhysicalType::INT128:
-		return TemplatedFetchRow<hugeint_t>;
-	case PhysicalType::FLOAT:
-		return TemplatedFetchRow<float>;
-	case PhysicalType::DOUBLE:
-		return TemplatedFetchRow<double>;
-	case PhysicalType::INTERVAL:
-		return TemplatedFetchRow<interval_t>;
-	case PhysicalType::VARCHAR:
-		return TemplatedFetchRow<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment fetch row");
-	}
-}
-
-void UpdateSegment::FetchRow(Transaction &transaction, idx_t row_id, Vector &result, idx_t result_idx) {
-	if (!root) {
-		return;
-	}
-	idx_t vector_index = (row_id - column_data.start) / STANDARD_VECTOR_SIZE;
-	if (!root->info[vector_index]) {
-		return;
-	}
-	idx_t row_in_vector = row_id - vector_index * STANDARD_VECTOR_SIZE;
-	fetch_row_function(transaction.start_time, transaction.transaction_id, root->info[vector_index]->info.get(),
-	                   row_in_vector, result, result_idx);
-}
-
-//===--------------------------------------------------------------------===//
-// Rollback update
-//===--------------------------------------------------------------------===//
-template <class T>
-static void RollbackUpdate(UpdateInfo *base_info, UpdateInfo *rollback_info) {
-	auto base_data = (T *)base_info->tuple_data;
-	auto rollback_data = (T *)rollback_info->tuple_data;
-	idx_t base_offset = 0;
-	for (idx_t i = 0; i < rollback_info->N; i++) {
-		auto id = rollback_info->tuples[i];
-		while (base_info->tuples[base_offset] < id) {
-			base_offset++;
-			D_ASSERT(base_offset < base_info->N);
-		}
-		base_data[base_offset] = rollback_data[i];
-	}
-}
-
-static UpdateSegment::rollback_update_function_t GetRollbackUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return RollbackUpdate<bool>;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return RollbackUpdate<int8_t>;
-	case PhysicalType::INT16:
-		return RollbackUpdate<int16_t>;
-	case PhysicalType::INT32:
-		return RollbackUpdate<int32_t>;
-	case PhysicalType::INT64:
-		return RollbackUpdate<int64_t>;
-	case PhysicalType::UINT8:
-		return RollbackUpdate<uint8_t>;
-	case PhysicalType::UINT16:
-		return RollbackUpdate<uint16_t>;
-	case PhysicalType::UINT32:
-		return RollbackUpdate<uint32_t>;
-	case PhysicalType::UINT64:
-		return RollbackUpdate<uint64_t>;
-	case PhysicalType::INT128:
-		return RollbackUpdate<hugeint_t>;
-	case PhysicalType::FLOAT:
-		return RollbackUpdate<float>;
-	case PhysicalType::DOUBLE:
-		return RollbackUpdate<double>;
-	case PhysicalType::INTERVAL:
-		return RollbackUpdate<interval_t>;
-	case PhysicalType::VARCHAR:
-		return RollbackUpdate<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for uncompressed segment");
-	}
-}
-
-void UpdateSegment::RollbackUpdate(UpdateInfo *info) {
-	// obtain an exclusive lock
-	auto lock_handle = lock.GetExclusiveLock();
-
-	// move the data from the UpdateInfo back into the base info
-	D_ASSERT(root->info[info->vector_index]);
-	rollback_update_function(root->info[info->vector_index]->info.get(), info);
-
-	// clean up the update chain
-	CleanupUpdateInternal(*lock_handle, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Cleanup Update
-//===--------------------------------------------------------------------===//
-void UpdateSegment::CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo *info) {
-	D_ASSERT(info->prev);
-	auto prev = info->prev;
-	prev->next = info->next;
-	if (prev->next) {
-		prev->next->prev = prev;
-	}
-}
-
-void UpdateSegment::CleanupUpdate(UpdateInfo *info) {
-	// obtain an exclusive lock
-	auto lock_handle = lock.GetExclusiveLock();
-	CleanupUpdateInternal(*lock_handle, info);
-}
-
-//===--------------------------------------------------------------------===//
-// Check for conflicts in update
-//===--------------------------------------------------------------------===//
-static void CheckForConflicts(UpdateInfo *info, Transaction &transaction, row_t *ids, const SelectionVector &sel,
-                              idx_t count, row_t offset, UpdateInfo *&node) {
-	if (!info) {
-		return;
-	}
-	if (info->version_number == transaction.transaction_id) {
-		// this UpdateInfo belongs to the current transaction, set it in the node
-		node = info;
-	} else if (info->version_number > transaction.start_time) {
-		// potential conflict, check that tuple ids do not conflict
-		// as both ids and info->tuples are sorted, this is similar to a merge join
-		idx_t i = 0, j = 0;
-		while (true) {
-			auto id = ids[sel.get_index(i)] - offset;
-			if (id == info->tuples[j]) {
-				throw TransactionException("Conflict on update!");
-			} else if (id < info->tuples[j]) {
-				// id < the current tuple in info, move to next id
-				i++;
-				if (i == count) {
-					break;
-				}
-			} else {
-				// id > the current tuple, move to next tuple in info
-				j++;
-				if (j == info->N) {
-					break;
-				}
-			}
-		}
-	}
-	CheckForConflicts(info->next, transaction, ids, sel, count, offset, node);
-}
-
-//===--------------------------------------------------------------------===//
-// Initialize update info
-//===--------------------------------------------------------------------===//
-void UpdateSegment::InitializeUpdateInfo(UpdateInfo &info, row_t *ids, const SelectionVector &sel, idx_t count,
-                                         idx_t vector_index, idx_t vector_offset) {
-	info.segment = this;
-	info.vector_index = vector_index;
-	info.prev = nullptr;
-	info.next = nullptr;
-
-	// set up the tuple ids
-	info.N = count;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto id = ids[idx];
-		D_ASSERT(idx_t(id) >= vector_offset && idx_t(id) < vector_offset + STANDARD_VECTOR_SIZE);
-		info.tuples[i] = id - vector_offset;
-	};
-}
-
-static void InitializeUpdateValidity(UpdateInfo *base_info, Vector &base_data, UpdateInfo *update_info, Vector &update,
-                                     const SelectionVector &sel) {
-	auto &update_mask = FlatVector::Validity(update);
-	auto tuple_data = (bool *)update_info->tuple_data;
-
-	if (!update_mask.AllValid()) {
-		for (idx_t i = 0; i < update_info->N; i++) {
-			auto idx = sel.get_index(i);
-			tuple_data[i] = update_mask.RowIsValidUnsafe(idx);
-		}
-	} else {
-		for (idx_t i = 0; i < update_info->N; i++) {
-			tuple_data[i] = true;
-		}
-	}
-
-	auto &base_mask = FlatVector::Validity(base_data);
-	auto base_tuple_data = (bool *)base_info->tuple_data;
-	if (!base_mask.AllValid()) {
-		for (idx_t i = 0; i < base_info->N; i++) {
-			base_tuple_data[i] = base_mask.RowIsValidUnsafe(base_info->tuples[i]);
-		}
-	} else {
-		for (idx_t i = 0; i < base_info->N; i++) {
-			base_tuple_data[i] = true;
-		}
-	}
-}
-
-struct UpdateSelectElement {
-	template <class T>
-	static T Operation(UpdateSegment *segment, T element) {
-		return element;
-	}
-};
-
-template <>
-string_t UpdateSelectElement::Operation(UpdateSegment *segment, string_t element) {
-	return element.IsInlined() ? element : segment->GetStringHeap().AddString(element);
-}
-
-template <class T>
-static void InitializeUpdateData(UpdateInfo *base_info, Vector &base_data, UpdateInfo *update_info, Vector &update,
-                                 const SelectionVector &sel) {
-	auto update_data = FlatVector::GetData<T>(update);
-	auto tuple_data = (T *)update_info->tuple_data;
-
-	for (idx_t i = 0; i < update_info->N; i++) {
-		auto idx = sel.get_index(i);
-		tuple_data[i] = update_data[idx];
-	}
-
-	auto base_array_data = FlatVector::GetData<T>(base_data);
-	auto base_tuple_data = (T *)base_info->tuple_data;
-	for (idx_t i = 0; i < base_info->N; i++) {
-		base_tuple_data[i] =
-		    UpdateSelectElement::Operation<T>(base_info->segment, base_array_data[base_info->tuples[i]]);
-	}
-}
-
-static UpdateSegment::initialize_update_function_t GetInitializeUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return InitializeUpdateValidity;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return InitializeUpdateData<int8_t>;
-	case PhysicalType::INT16:
-		return InitializeUpdateData<int16_t>;
-	case PhysicalType::INT32:
-		return InitializeUpdateData<int32_t>;
-	case PhysicalType::INT64:
-		return InitializeUpdateData<int64_t>;
-	case PhysicalType::UINT8:
-		return InitializeUpdateData<uint8_t>;
-	case PhysicalType::UINT16:
-		return InitializeUpdateData<uint16_t>;
-	case PhysicalType::UINT32:
-		return InitializeUpdateData<uint32_t>;
-	case PhysicalType::UINT64:
-		return InitializeUpdateData<uint64_t>;
-	case PhysicalType::INT128:
-		return InitializeUpdateData<hugeint_t>;
-	case PhysicalType::FLOAT:
-		return InitializeUpdateData<float>;
-	case PhysicalType::DOUBLE:
-		return InitializeUpdateData<double>;
-	case PhysicalType::INTERVAL:
-		return InitializeUpdateData<interval_t>;
-	case PhysicalType::VARCHAR:
-		return InitializeUpdateData<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for update segment");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Merge update info
-//===--------------------------------------------------------------------===//
-template <class F1, class F2, class F3>
-static idx_t MergeLoop(row_t a[], sel_t b[], idx_t acount, idx_t bcount, idx_t aoffset, F1 merge, F2 pick_a, F3 pick_b,
-                       const SelectionVector &asel) {
-	idx_t aidx = 0, bidx = 0;
-	idx_t count = 0;
-	while (aidx < acount && bidx < bcount) {
-		auto a_index = asel.get_index(aidx);
-		auto a_id = a[a_index] - aoffset;
-		auto b_id = b[bidx];
-		if (a_id == b_id) {
-			merge(a_id, a_index, bidx, count);
-			aidx++;
-			bidx++;
-			count++;
-		} else if (a_id < b_id) {
-			pick_a(a_id, a_index, count);
-			aidx++;
-			count++;
-		} else {
-			pick_b(b_id, bidx, count);
-			bidx++;
-			count++;
-		}
-	}
-	for (; aidx < acount; aidx++) {
-		auto a_index = asel.get_index(aidx);
-		pick_a(a[a_index] - aoffset, a_index, count);
-		count++;
-	}
-	for (; bidx < bcount; bidx++) {
-		pick_b(b[bidx], bidx, count);
-		count++;
-	}
-	return count;
-}
-
-struct ExtractStandardEntry {
-	template <class T, class V>
-	static T Extract(V *data, idx_t entry) {
-		return data[entry];
-	}
-};
-
-struct ExtractValidityEntry {
-	template <class T, class V>
-	static T Extract(V *data, idx_t entry) {
-		return data->RowIsValid(entry);
-	}
-};
-
-template <class T, class V, class OP = ExtractStandardEntry>
-static void MergeUpdateLoopInternal(UpdateInfo *base_info, V *base_table_data, UpdateInfo *update_info,
-                                    V *update_vector_data, row_t *ids, idx_t count, const SelectionVector &sel) {
-	auto base_id = base_info->segment->column_data.start + base_info->vector_index * STANDARD_VECTOR_SIZE;
-#ifdef DEBUG
-	// all of these should be sorted, otherwise the below algorithm does not work
-	for (idx_t i = 1; i < count; i++) {
-		auto prev_idx = sel.get_index(i - 1);
-		auto idx = sel.get_index(i);
-		D_ASSERT(ids[idx] > ids[prev_idx] && ids[idx] >= row_t(base_id) &&
-		         ids[idx] < row_t(base_id + STANDARD_VECTOR_SIZE));
-	}
-#endif
-
-	// we have a new batch of updates (update, ids, count)
-	// we already have existing updates (base_info)
-	// and potentially, this transaction already has updates present (update_info)
-	// we need to merge these all together so that the latest updates get merged into base_info
-	// and the "old" values (fetched from EITHER base_info OR from base_data) get placed into update_info
-	auto base_info_data = (T *)base_info->tuple_data;
-	auto update_info_data = (T *)update_info->tuple_data;
-
-	// we first do the merging of the old values
-	// what we are trying to do here is update the "update_info" of this transaction with all the old data we require
-	// this means we need to merge (1) any previously updated values (stored in update_info->tuples)
-	// together with (2)
-	// to simplify this, we create new arrays here
-	// we memcpy these over afterwards
-	T result_values[STANDARD_VECTOR_SIZE];
-	sel_t result_ids[STANDARD_VECTOR_SIZE];
-
-	idx_t base_info_offset = 0;
-	idx_t update_info_offset = 0;
-	idx_t result_offset = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		// we have to merge the info for "ids[i]"
-		auto update_id = ids[idx] - base_id;
-
-		while (update_info_offset < update_info->N && update_info->tuples[update_info_offset] < update_id) {
-			// old id comes before the current id: write it
-			result_values[result_offset] = update_info_data[update_info_offset];
-			result_ids[result_offset++] = update_info->tuples[update_info_offset];
-			update_info_offset++;
-		}
-		// write the new id
-		if (update_info_offset < update_info->N && update_info->tuples[update_info_offset] == update_id) {
-			// we have an id that is equivalent in the current update info: write the update info
-			result_values[result_offset] = update_info_data[update_info_offset];
-			result_ids[result_offset++] = update_info->tuples[update_info_offset];
-			update_info_offset++;
-			continue;
-		}
-
-		/// now check if we have the current update_id in the base_info, or if we should fetch it from the base data
-		while (base_info_offset < base_info->N && base_info->tuples[base_info_offset] < update_id) {
-			base_info_offset++;
-		}
-		if (base_info_offset < base_info->N && base_info->tuples[base_info_offset] == update_id) {
-			// it is! we have to move the tuple from base_info->ids[base_info_offset] to update_info
-			result_values[result_offset] = base_info_data[base_info_offset];
-		} else {
-			// it is not! we have to move base_table_data[update_id] to update_info
-			result_values[result_offset] = UpdateSelectElement::Operation<T>(
-			    base_info->segment, OP::template Extract<T, V>(base_table_data, update_id));
-		}
-		result_ids[result_offset++] = update_id;
-	}
-	// write any remaining entries from the old updates
-	while (update_info_offset < update_info->N) {
-		result_values[result_offset] = update_info_data[update_info_offset];
-		result_ids[result_offset++] = update_info->tuples[update_info_offset];
-		update_info_offset++;
-	}
-	// now copy them back
-	update_info->N = result_offset;
-	memcpy(update_info_data, result_values, result_offset * sizeof(T));
-	memcpy(update_info->tuples, result_ids, result_offset * sizeof(sel_t));
-
-	// now we merge the new values into the base_info
-	result_offset = 0;
-	auto pick_new = [&](idx_t id, idx_t aidx, idx_t count) {
-		result_values[result_offset] = OP::template Extract<T, V>(update_vector_data, aidx);
-		result_ids[result_offset] = id;
-		result_offset++;
-	};
-	auto pick_old = [&](idx_t id, idx_t bidx, idx_t count) {
-		result_values[result_offset] = base_info_data[bidx];
-		result_ids[result_offset] = id;
-		result_offset++;
-	};
-	// now we perform a merge of the new ids with the old ids
-	auto merge = [&](idx_t id, idx_t aidx, idx_t bidx, idx_t count) {
-		pick_new(id, aidx, count);
-	};
-	MergeLoop(ids, base_info->tuples, count, base_info->N, base_id, merge, pick_new, pick_old, sel);
-
-	base_info->N = result_offset;
-	memcpy(base_info_data, result_values, result_offset * sizeof(T));
-	memcpy(base_info->tuples, result_ids, result_offset * sizeof(sel_t));
-}
-
-static void MergeValidityLoop(UpdateInfo *base_info, Vector &base_data, UpdateInfo *update_info, Vector &update,
-                              row_t *ids, idx_t count, const SelectionVector &sel) {
-	auto &base_validity = FlatVector::Validity(base_data);
-	auto &update_validity = FlatVector::Validity(update);
-	MergeUpdateLoopInternal<bool, ValidityMask, ExtractValidityEntry>(base_info, &base_validity, update_info,
-	                                                                  &update_validity, ids, count, sel);
-}
-
-template <class T>
-static void MergeUpdateLoop(UpdateInfo *base_info, Vector &base_data, UpdateInfo *update_info, Vector &update,
-                            row_t *ids, idx_t count, const SelectionVector &sel) {
-	auto base_table_data = FlatVector::GetData<T>(base_data);
-	auto update_vector_data = FlatVector::GetData<T>(update);
-	MergeUpdateLoopInternal<T, T>(base_info, base_table_data, update_info, update_vector_data, ids, count, sel);
-}
-
-static UpdateSegment::merge_update_function_t GetMergeUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return MergeValidityLoop;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return MergeUpdateLoop<int8_t>;
-	case PhysicalType::INT16:
-		return MergeUpdateLoop<int16_t>;
-	case PhysicalType::INT32:
-		return MergeUpdateLoop<int32_t>;
-	case PhysicalType::INT64:
-		return MergeUpdateLoop<int64_t>;
-	case PhysicalType::UINT8:
-		return MergeUpdateLoop<uint8_t>;
-	case PhysicalType::UINT16:
-		return MergeUpdateLoop<uint16_t>;
-	case PhysicalType::UINT32:
-		return MergeUpdateLoop<uint32_t>;
-	case PhysicalType::UINT64:
-		return MergeUpdateLoop<uint64_t>;
-	case PhysicalType::INT128:
-		return MergeUpdateLoop<hugeint_t>;
-	case PhysicalType::FLOAT:
-		return MergeUpdateLoop<float>;
-	case PhysicalType::DOUBLE:
-		return MergeUpdateLoop<double>;
-	case PhysicalType::INTERVAL:
-		return MergeUpdateLoop<interval_t>;
-	case PhysicalType::VARCHAR:
-		return MergeUpdateLoop<string_t>;
-	default:
-		throw NotImplementedException("Unimplemented type for uncompressed segment");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Update statistics
-//===--------------------------------------------------------------------===//
-unique_ptr<BaseStatistics> UpdateSegment::GetStatistics() {
-	lock_guard<mutex> stats_guard(stats_lock);
-	return stats.statistics->Copy();
-}
-
-idx_t UpdateValidityStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
-                               SelectionVector &sel) {
-	auto &mask = FlatVector::Validity(update);
-	auto &validity = (ValidityStatistics &)*stats.statistics;
-	if (!mask.AllValid() && !validity.has_null) {
-		for (idx_t i = 0; i < count; i++) {
-			if (!mask.RowIsValid(i)) {
-				validity.has_null = true;
-				break;
-			}
-		}
-	}
-	sel.Initialize(nullptr);
-	return count;
-}
-
-template <class T>
-idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
-                                       SelectionVector &sel) {
-	auto update_data = FlatVector::GetData<T>(update);
-	auto &mask = FlatVector::Validity(update);
-
-	if (mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			NumericStatistics::Update<T>(stats, update_data[i]);
-		}
-		sel.Initialize(nullptr);
-		return count;
-	} else {
-		idx_t not_null_count = 0;
-		sel.Initialize(STANDARD_VECTOR_SIZE);
-		for (idx_t i = 0; i < count; i++) {
-			if (mask.RowIsValid(i)) {
-				sel.set_index(not_null_count++, i);
-				NumericStatistics::Update<T>(stats, update_data[i]);
-			}
-		}
-		return not_null_count;
-	}
-}
-
-idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
-                             SelectionVector &sel) {
-	auto update_data = FlatVector::GetData<string_t>(update);
-	auto &mask = FlatVector::Validity(update);
-	if (mask.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			((StringStatistics &)*stats.statistics).Update(update_data[i]);
-			if (!update_data[i].IsInlined()) {
-				update_data[i] = segment->GetStringHeap().AddString(update_data[i]);
-			}
-		}
-		sel.Initialize(nullptr);
-		return count;
-	} else {
-		idx_t not_null_count = 0;
-		sel.Initialize(STANDARD_VECTOR_SIZE);
-		for (idx_t i = 0; i < count; i++) {
-			if (mask.RowIsValid(i)) {
-				sel.set_index(not_null_count++, i);
-				((StringStatistics &)*stats.statistics).Update(update_data[i]);
-				if (!update_data[i].IsInlined()) {
-					update_data[i] = segment->GetStringHeap().AddString(update_data[i]);
-				}
-			}
-		}
-		return not_null_count;
-	}
-}
-
-UpdateSegment::statistics_update_function_t GetStatisticsUpdateFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::BIT:
-		return UpdateValidityStatistics;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedUpdateNumericStatistics<int8_t>;
-	case PhysicalType::INT16:
-		return TemplatedUpdateNumericStatistics<int16_t>;
-	case PhysicalType::INT32:
-		return TemplatedUpdateNumericStatistics<int32_t>;
-	case PhysicalType::INT64:
-		return TemplatedUpdateNumericStatistics<int64_t>;
-	case PhysicalType::UINT8:
-		return TemplatedUpdateNumericStatistics<uint8_t>;
-	case PhysicalType::UINT16:
-		return TemplatedUpdateNumericStatistics<uint16_t>;
-	case PhysicalType::UINT32:
-		return TemplatedUpdateNumericStatistics<uint32_t>;
-	case PhysicalType::UINT64:
-		return TemplatedUpdateNumericStatistics<uint64_t>;
-	case PhysicalType::INT128:
-		return TemplatedUpdateNumericStatistics<hugeint_t>;
-	case PhysicalType::FLOAT:
-		return TemplatedUpdateNumericStatistics<float>;
-	case PhysicalType::DOUBLE:
-		return TemplatedUpdateNumericStatistics<double>;
-	case PhysicalType::INTERVAL:
-		return TemplatedUpdateNumericStatistics<interval_t>;
-	case PhysicalType::VARCHAR:
-		return UpdateStringStatistics;
-	default:
-		throw NotImplementedException("Unimplemented type for uncompressed segment");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Update
-//===--------------------------------------------------------------------===//
-static idx_t SortSelectionVector(SelectionVector &sel, idx_t count, row_t *ids) {
-	D_ASSERT(count > 0);
-
-	bool is_sorted = true;
-	for (idx_t i = 1; i < count; i++) {
-		auto prev_idx = sel.get_index(i - 1);
-		auto idx = sel.get_index(i);
-		if (ids[idx] <= ids[prev_idx]) {
-			is_sorted = false;
-			break;
-		}
-	}
-	if (is_sorted) {
-		// already sorted: bailout
-		return count;
-	}
-	// not sorted: need to sort the selection vector
-	SelectionVector sorted_sel(count);
-	for (idx_t i = 0; i < count; i++) {
-		sorted_sel.set_index(i, sel.get_index(i));
-	}
-	std::sort(sorted_sel.data(), sorted_sel.data() + count, [&](sel_t l, sel_t r) { return ids[l] < ids[r]; });
-	// eliminate any duplicates
-	idx_t pos = 1;
-	for (idx_t i = 1; i < count; i++) {
-		auto prev_idx = sorted_sel.get_index(i - 1);
-		auto idx = sorted_sel.get_index(i);
-		D_ASSERT(ids[idx] >= ids[prev_idx]);
-		if (ids[prev_idx] != ids[idx]) {
-			sorted_sel.set_index(pos++, idx);
-		}
-	}
-#ifdef DEBUG
-	for (idx_t i = 1; i < pos; i++) {
-		auto prev_idx = sorted_sel.get_index(i - 1);
-		auto idx = sorted_sel.get_index(i);
-		D_ASSERT(ids[idx] > ids[prev_idx]);
-	}
-#endif
-
-	sel.Initialize(sorted_sel);
-	D_ASSERT(pos > 0);
-	return pos;
-}
-
-void UpdateSegment::Update(Transaction &transaction, idx_t column_index, Vector &update, row_t *ids, idx_t count,
-                           Vector &base_data) {
-	// obtain an exclusive lock
-	auto write_lock = lock.GetExclusiveLock();
-
-	update.Normalify(count);
-
-	// update statistics
-	SelectionVector sel;
-	{
-		lock_guard<mutex> stats_guard(stats_lock);
-		count = statistics_update_function(this, stats, update, count, sel);
-	}
-	if (count == 0) {
-		return;
-	}
-
-	// subsequent algorithms used by the update require row ids to be (1) sorted, and (2) unique
-	// this is usually the case for "standard" queries (e.g. UPDATE tbl SET x=bla WHERE cond)
-	// however, for more exotic queries involving e.g. cross products/joins this might not be the case
-	// hence we explicitly check here if the ids are sorted and, if not, sort + duplicate eliminate them
-	count = SortSelectionVector(sel, count, ids);
-	D_ASSERT(count > 0);
-
-	// create the versions for this segment, if there are none yet
-	if (!root) {
-		root = make_unique<UpdateNode>();
-	}
-
-	// get the vector index based on the first id
-	// we assert that all updates must be part of the same vector
-	auto first_id = ids[sel.get_index(0)];
-	idx_t vector_index = (first_id - column_data.start) / STANDARD_VECTOR_SIZE;
-	idx_t vector_offset = column_data.start + vector_index * STANDARD_VECTOR_SIZE;
-
-	D_ASSERT(idx_t(first_id) >= column_data.start);
-	D_ASSERT(vector_index < RowGroup::ROW_GROUP_VECTOR_COUNT);
-
-	// first check the version chain
-	UpdateInfo *node = nullptr;
-
-	if (root->info[vector_index]) {
-		// there is already a version here, check if there are any conflicts and search for the node that belongs to
-		// this transaction in the version chain
-		auto base_info = root->info[vector_index]->info.get();
-		CheckForConflicts(base_info->next, transaction, ids, sel, count, vector_offset, node);
-
-		// there are no conflicts
-		// first, check if this thread has already done any updates
-		auto node = base_info->next;
-		while (node) {
-			if (node->version_number == transaction.transaction_id) {
-				// it has! use this node
-				break;
-			}
-			node = node->next;
-		}
-		if (!node) {
-			// no updates made yet by this transaction: initially the update info to empty
-			node = transaction.CreateUpdateInfo(type_size, count);
-			node->segment = this;
-			node->vector_index = vector_index;
-			node->N = 0;
-			node->column_index = column_index;
-
-			// insert the new node into the chain
-			node->next = base_info->next;
-			if (node->next) {
-				node->next->prev = node;
-			}
-			node->prev = base_info;
-			base_info->next = node;
-		}
-		base_info->Verify();
-		node->Verify();
-
-		// now we are going to perform the merge
-		merge_update_function(base_info, base_data, node, update, ids, count, sel);
-
-		base_info->Verify();
-		node->Verify();
-	} else {
-		// there is no version info yet: create the top level update info and fill it with the updates
-		auto result = make_unique<UpdateNodeData>();
-
-		result->info = make_unique<UpdateInfo>();
-		result->tuples = unique_ptr<sel_t[]>(new sel_t[STANDARD_VECTOR_SIZE]);
-		result->tuple_data = unique_ptr<data_t[]>(new data_t[STANDARD_VECTOR_SIZE * type_size]);
-		result->info->tuples = result->tuples.get();
-		result->info->tuple_data = result->tuple_data.get();
-		result->info->version_number = TRANSACTION_ID_START - 1;
-		result->info->column_index = column_index;
-		InitializeUpdateInfo(*result->info, ids, sel, count, vector_index, vector_offset);
-
-		// now create the transaction level update info in the undo log
-		auto transaction_node = transaction.CreateUpdateInfo(type_size, count);
-		InitializeUpdateInfo(*transaction_node, ids, sel, count, vector_index, vector_offset);
-
-		// we write the updates in the
-		initialize_update_function(transaction_node, base_data, result->info.get(), update, sel);
-
-		result->info->next = transaction_node;
-		result->info->prev = nullptr;
-		transaction_node->next = nullptr;
-		transaction_node->prev = result->info.get();
-		transaction_node->column_index = column_index;
-
-		transaction_node->Verify();
-		result->info->Verify();
-
-		root->info[vector_index] = move(result);
-	}
-}
-
-bool UpdateSegment::HasUpdates() const {
-	return root.get() != nullptr;
-}
-
-bool UpdateSegment::HasUpdates(idx_t vector_index) const {
-	if (!HasUpdates()) {
-		return false;
-	}
-	return root->info[vector_index].get();
-}
-
-bool UpdateSegment::HasUncommittedUpdates(idx_t vector_index) {
-	if (!HasUpdates(vector_index)) {
-		return false;
-	}
-	auto read_lock = lock.GetSharedLock();
-	auto entry = root->info[vector_index].get();
-	if (entry->info->next) {
-		return true;
-	}
-	return false;
-}
-
-bool UpdateSegment::HasUpdates(idx_t start_row_index, idx_t end_row_index) {
-	if (!HasUpdates()) {
-		return false;
-	}
-	auto read_lock = lock.GetSharedLock();
-	idx_t base_vector_index = start_row_index / STANDARD_VECTOR_SIZE;
-	idx_t end_vector_index = end_row_index / STANDARD_VECTOR_SIZE;
-	for (idx_t i = base_vector_index; i <= end_vector_index; i++) {
-		if (root->info[i]) {
-			return true;
-		}
-	}
-	return false;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-ValidityColumnData::ValidityColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, ColumnData *parent)
-    : ColumnData(info, column_index, start_row, LogicalType(LogicalTypeId::VALIDITY), parent) {
-}
-
-bool ValidityColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
-	return true;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class ReplayState {
-public:
-	ReplayState(DatabaseInstance &db, ClientContext &context, Deserializer &source)
-	    : db(db), context(context), source(source), current_table(nullptr), deserialize_only(false),
-	      checkpoint_id(INVALID_BLOCK) {
-	}
-
-	DatabaseInstance &db;
-	ClientContext &context;
-	Deserializer &source;
-	TableCatalogEntry *current_table;
-	bool deserialize_only;
-	block_id_t checkpoint_id;
-
-public:
-	void ReplayEntry(WALType entry_type);
-
-private:
-	void ReplayCreateTable();
-	void ReplayDropTable();
-	void ReplayAlter();
-
-	void ReplayCreateView();
-	void ReplayDropView();
-
-	void ReplayCreateSchema();
-	void ReplayDropSchema();
-
-	void ReplayCreateType();
-	void ReplayDropType();
-
-	void ReplayCreateSequence();
-	void ReplayDropSequence();
-	void ReplaySequenceValue();
-
-	void ReplayCreateMacro();
-	void ReplayDropMacro();
-
-	void ReplayCreateTableMacro();
-	void ReplayDropTableMacro();
-
-	void ReplayUseTable();
-	void ReplayInsert();
-	void ReplayDelete();
-	void ReplayUpdate();
-	void ReplayCheckpoint();
-};
-
-bool WriteAheadLog::Replay(DatabaseInstance &database, string &path) {
-	auto initial_reader = make_unique<BufferedFileReader>(database.GetFileSystem(), path.c_str());
-	if (initial_reader->Finished()) {
-		// WAL is empty
-		return false;
-	}
-	Connection con(database);
-	con.BeginTransaction();
-
-	// first deserialize the WAL to look for a checkpoint flag
-	// if there is a checkpoint flag, we might have already flushed the contents of the WAL to disk
-	ReplayState checkpoint_state(database, *con.context, *initial_reader);
-	checkpoint_state.deserialize_only = true;
-	try {
-		while (true) {
-			// read the current entry
-			WALType entry_type = initial_reader->Read<WALType>();
-			if (entry_type == WALType::WAL_FLUSH) {
-				// check if the file is exhausted
-				if (initial_reader->Finished()) {
-					// we finished reading the file: break
-					break;
-				}
-			} else {
-				// replay the entry
-				checkpoint_state.ReplayEntry(entry_type);
-			}
-		}
-	} catch (std::exception &ex) { // LCOV_EXCL_START
-		Printer::Print(StringUtil::Format("Exception in WAL playback during initial read: %s\n", ex.what()));
-		return false;
-	} catch (...) {
-		Printer::Print("Unknown Exception in WAL playback during initial read");
-		return false;
-	} // LCOV_EXCL_STOP
-	initial_reader.reset();
-	if (checkpoint_state.checkpoint_id != INVALID_BLOCK) {
-		// there is a checkpoint flag: check if we need to deserialize the WAL
-		auto &manager = BlockManager::GetBlockManager(database);
-		if (manager.IsRootBlock(checkpoint_state.checkpoint_id)) {
-			// the contents of the WAL have already been checkpointed
-			// we can safely truncate the WAL and ignore its contents
-			return true;
-		}
-	}
-
-	// we need to recover from the WAL: actually set up the replay state
-	BufferedFileReader reader(database.GetFileSystem(), path.c_str());
-	ReplayState state(database, *con.context, reader);
-
-	// replay the WAL
-	// note that everything is wrapped inside a try/catch block here
-	// there can be errors in WAL replay because of a corrupt WAL file
-	// in this case we should throw a warning but startup anyway
-	try {
-		while (true) {
-			// read the current entry
-			WALType entry_type = reader.Read<WALType>();
-			if (entry_type == WALType::WAL_FLUSH) {
-				// flush: commit the current transaction
-				con.Commit();
-				// check if the file is exhausted
-				if (reader.Finished()) {
-					// we finished reading the file: break
-					break;
-				}
-				// otherwise we keep on reading
-				con.BeginTransaction();
-			} else {
-				// replay the entry
-				state.ReplayEntry(entry_type);
-			}
-		}
-	} catch (std::exception &ex) { // LCOV_EXCL_START
-		// FIXME: this should report a proper warning in the connection
-		Printer::Print(StringUtil::Format("Exception in WAL playback: %s\n", ex.what()));
-		// exception thrown in WAL replay: rollback
-		con.Rollback();
-	} catch (...) {
-		Printer::Print("Unknown Exception in WAL playback: %s\n");
-		// exception thrown in WAL replay: rollback
-		con.Rollback();
-	} // LCOV_EXCL_STOP
-	return false;
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Entries
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayEntry(WALType entry_type) {
-	switch (entry_type) {
-	case WALType::CREATE_TABLE:
-		ReplayCreateTable();
-		break;
-	case WALType::DROP_TABLE:
-		ReplayDropTable();
-		break;
-	case WALType::ALTER_INFO:
-		ReplayAlter();
-		break;
-	case WALType::CREATE_VIEW:
-		ReplayCreateView();
-		break;
-	case WALType::DROP_VIEW:
-		ReplayDropView();
-		break;
-	case WALType::CREATE_SCHEMA:
-		ReplayCreateSchema();
-		break;
-	case WALType::DROP_SCHEMA:
-		ReplayDropSchema();
-		break;
-	case WALType::CREATE_SEQUENCE:
-		ReplayCreateSequence();
-		break;
-	case WALType::DROP_SEQUENCE:
-		ReplayDropSequence();
-		break;
-	case WALType::SEQUENCE_VALUE:
-		ReplaySequenceValue();
-		break;
-	case WALType::CREATE_MACRO:
-		ReplayCreateMacro();
-		break;
-	case WALType::DROP_MACRO:
-		ReplayDropMacro();
-		break;
-	case WALType::CREATE_TABLE_MACRO:
-		ReplayCreateTableMacro();
-		break;
-	case WALType::DROP_TABLE_MACRO:
-		ReplayDropTableMacro();
-		break;
-	case WALType::USE_TABLE:
-		ReplayUseTable();
-		break;
-	case WALType::INSERT_TUPLE:
-		ReplayInsert();
-		break;
-	case WALType::DELETE_TUPLE:
-		ReplayDelete();
-		break;
-	case WALType::UPDATE_TUPLE:
-		ReplayUpdate();
-		break;
-	case WALType::CHECKPOINT:
-		ReplayCheckpoint();
-		break;
-	case WALType::CREATE_TYPE:
-		ReplayCreateType();
-		break;
-	case WALType::DROP_TYPE:
-		ReplayDropType();
-		break;
-
-	default:
-		throw InternalException("Invalid WAL entry type!");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Table
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayCreateTable() {
-	auto info = TableCatalogEntry::Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-
-	// bind the constraints to the table again
-	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindCreateTableInfo(move(info));
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateTable(context, bound_info.get());
-}
-
-void ReplayState::ReplayDropTable() {
-	DropInfo info;
-
-	info.type = CatalogType::TABLE_ENTRY;
-	info.schema = source.Read<string>();
-	info.name = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.DropEntry(context, &info);
-}
-
-void ReplayState::ReplayAlter() {
-	auto info = AlterInfo::Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.Alter(context, info.get());
-}
-
-//===--------------------------------------------------------------------===//
-// Replay View
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayCreateView() {
-	auto entry = ViewCatalogEntry::Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateView(context, entry.get());
-}
-
-void ReplayState::ReplayDropView() {
-	DropInfo info;
-	info.type = CatalogType::VIEW_ENTRY;
-	info.schema = source.Read<string>();
-	info.name = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.DropEntry(context, &info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Schema
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayCreateSchema() {
-	CreateSchemaInfo info;
-	info.schema = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateSchema(context, &info);
-}
-
-void ReplayState::ReplayDropSchema() {
-	DropInfo info;
-
-	info.type = CatalogType::SCHEMA_ENTRY;
-	info.name = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.DropEntry(context, &info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Custom Type
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayCreateType() {
-	auto info = TypeCatalogEntry::Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateType(context, info.get());
-}
-
-void ReplayState::ReplayDropType() {
-	DropInfo info;
-
-	info.type = CatalogType::TYPE_ENTRY;
-	info.schema = source.Read<string>();
-	info.name = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.DropEntry(context, &info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Sequence
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayCreateSequence() {
-	auto entry = SequenceCatalogEntry::Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateSequence(context, entry.get());
-}
-
-void ReplayState::ReplayDropSequence() {
-	DropInfo info;
-	info.type = CatalogType::SEQUENCE_ENTRY;
-	info.schema = source.Read<string>();
-	info.name = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.DropEntry(context, &info);
-}
-
-void ReplayState::ReplaySequenceValue() {
-	auto schema = source.Read<string>();
-	auto name = source.Read<string>();
-	auto usage_count = source.Read<uint64_t>();
-	auto counter = source.Read<int64_t>();
-	if (deserialize_only) {
-		return;
-	}
-
-	// fetch the sequence from the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto seq = catalog.GetEntry<SequenceCatalogEntry>(context, schema, name);
-	if (usage_count > seq->usage_count) {
-		seq->usage_count = usage_count;
-		seq->counter = counter;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Macro
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayCreateMacro() {
-	auto entry = ScalarMacroCatalogEntry::Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateFunction(context, entry.get());
-}
-
-void ReplayState::ReplayDropMacro() {
-	DropInfo info;
-	info.type = CatalogType::MACRO_ENTRY;
-	info.schema = source.Read<string>();
-	info.name = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.DropEntry(context, &info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Table Macro
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayCreateTableMacro() {
-	auto entry = TableMacroCatalogEntry::Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateFunction(context, entry.get());
-}
-
-void ReplayState::ReplayDropTableMacro() {
-	DropInfo info;
-	info.type = CatalogType::TABLE_MACRO_ENTRY;
-	info.schema = source.Read<string>();
-	info.name = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.DropEntry(context, &info);
-}
-
-//===--------------------------------------------------------------------===//
-// Replay Data
-//===--------------------------------------------------------------------===//
-void ReplayState::ReplayUseTable() {
-	auto schema_name = source.Read<string>();
-	auto table_name = source.Read<string>();
-	if (deserialize_only) {
-		return;
-	}
-	auto &catalog = Catalog::GetCatalog(context);
-	current_table = catalog.GetEntry<TableCatalogEntry>(context, schema_name, table_name);
-}
-
-void ReplayState::ReplayInsert() {
-	DataChunk chunk;
-	chunk.Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-	if (!current_table) {
-		throw Exception("Corrupt WAL: insert without table");
-	}
-
-	// append to the current table
-	current_table->storage->Append(*current_table, context, chunk);
-}
-
-void ReplayState::ReplayDelete() {
-	DataChunk chunk;
-	chunk.Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-	if (!current_table) {
-		throw InternalException("Corrupt WAL: delete without table");
-	}
-
-	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
-	row_t row_ids[1];
-	Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_ids);
-
-	auto source_ids = FlatVector::GetData<row_t>(chunk.data[0]);
-	// delete the tuples from the current table
-	for (idx_t i = 0; i < chunk.size(); i++) {
-		row_ids[0] = source_ids[i];
-		current_table->storage->Delete(*current_table, context, row_identifiers, 1);
-	}
-}
-
-void ReplayState::ReplayUpdate() {
-	vector<column_t> column_path;
-	auto column_index_count = source.Read<idx_t>();
-	column_path.reserve(column_index_count);
-	for (idx_t i = 0; i < column_index_count; i++) {
-		column_path.push_back(source.Read<column_t>());
-	}
-	DataChunk chunk;
-	chunk.Deserialize(source);
-	if (deserialize_only) {
-		return;
-	}
-	if (!current_table) {
-		throw InternalException("Corrupt WAL: update without table");
-	}
-
-	if (column_path[0] >= current_table->columns.size()) {
-		throw InternalException("Corrupt WAL: column index for update out of bounds");
-	}
-
-	// remove the row id vector from the chunk
-	auto row_ids = move(chunk.data.back());
-	chunk.data.pop_back();
-
-	// now perform the update
-	current_table->storage->UpdateColumn(*current_table, context, row_ids, column_path, chunk);
-}
-
-void ReplayState::ReplayCheckpoint() {
-	checkpoint_id = source.Read<block_id_t>();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-WriteAheadLog::WriteAheadLog(DatabaseInstance &database) : initialized(false), skip_writing(false), database(database) {
-}
-
-void WriteAheadLog::Initialize(string &path) {
-	wal_path = path;
-	writer = make_unique<BufferedFileWriter>(database.GetFileSystem(), path.c_str(),
-	                                         FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE |
-	                                             FileFlags::FILE_FLAGS_APPEND);
-	initialized = true;
-}
-
-int64_t WriteAheadLog::GetWALSize() {
-	D_ASSERT(writer);
-	return writer->GetFileSize();
-}
-
-idx_t WriteAheadLog::GetTotalWritten() {
-	D_ASSERT(writer);
-	return writer->GetTotalWritten();
-}
-
-void WriteAheadLog::Truncate(int64_t size) {
-	writer->Truncate(size);
-}
-
-void WriteAheadLog::Delete() {
-	if (!initialized) {
-		return;
-	}
-	initialized = false;
-	writer.reset();
-
-	auto &fs = FileSystem::GetFileSystem(database);
-	fs.RemoveFile(wal_path);
-}
-
-//===--------------------------------------------------------------------===//
-// Write Entries
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCheckpoint(block_id_t meta_block) {
-	writer->Write<WALType>(WALType::CHECKPOINT);
-	writer->Write<block_id_t>(meta_block);
-}
-
-//===--------------------------------------------------------------------===//
-// CREATE TABLE
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateTable(TableCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::CREATE_TABLE);
-	entry->Serialize(*writer);
-}
-
-//===--------------------------------------------------------------------===//
-// DROP TABLE
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteDropTable(TableCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::DROP_TABLE);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
-}
-
-//===--------------------------------------------------------------------===//
-// CREATE SCHEMA
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateSchema(SchemaCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::CREATE_SCHEMA);
-	writer->WriteString(entry->name);
-}
-
-//===--------------------------------------------------------------------===//
-// SEQUENCES
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateSequence(SequenceCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::CREATE_SEQUENCE);
-	entry->Serialize(*writer);
-}
-
-void WriteAheadLog::WriteDropSequence(SequenceCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::DROP_SEQUENCE);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
-}
-
-void WriteAheadLog::WriteSequenceValue(SequenceCatalogEntry *entry, SequenceValue val) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::SEQUENCE_VALUE);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
-	writer->Write<uint64_t>(val.usage_count);
-	writer->Write<int64_t>(val.counter);
-}
-
-//===--------------------------------------------------------------------===//
-// MACRO'S
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateMacro(ScalarMacroCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::CREATE_MACRO);
-	entry->Serialize(*writer);
-}
-
-void WriteAheadLog::WriteDropMacro(ScalarMacroCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::DROP_MACRO);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
-}
-
-void WriteAheadLog::WriteCreateTableMacro(TableMacroCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::CREATE_TABLE_MACRO);
-	entry->Serialize(*writer);
-}
-
-void WriteAheadLog::WriteDropTableMacro(TableMacroCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::DROP_TABLE_MACRO);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
-}
-
-//===--------------------------------------------------------------------===//
-// Custom Types
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateType(TypeCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::CREATE_TYPE);
-	entry->Serialize(*writer);
-}
-
-void WriteAheadLog::WriteDropType(TypeCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::DROP_TYPE);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
-}
-
-//===--------------------------------------------------------------------===//
-// VIEWS
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateView(ViewCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::CREATE_VIEW);
-	entry->Serialize(*writer);
-}
-
-void WriteAheadLog::WriteDropView(ViewCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::DROP_VIEW);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
-}
-
-//===--------------------------------------------------------------------===//
-// DROP SCHEMA
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteDropSchema(SchemaCatalogEntry *entry) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::DROP_SCHEMA);
-	writer->WriteString(entry->name);
-}
-
-//===--------------------------------------------------------------------===//
-// DATA
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteSetTable(string &schema, string &table) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::USE_TABLE);
-	writer->WriteString(schema);
-	writer->WriteString(table);
-}
-
-void WriteAheadLog::WriteInsert(DataChunk &chunk) {
-	if (skip_writing) {
-		return;
-	}
-	D_ASSERT(chunk.size() > 0);
-	chunk.Verify();
-
-	writer->Write<WALType>(WALType::INSERT_TUPLE);
-	chunk.Serialize(*writer);
-}
-
-void WriteAheadLog::WriteDelete(DataChunk &chunk) {
-	if (skip_writing) {
-		return;
-	}
-	D_ASSERT(chunk.size() > 0);
-	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
-	chunk.Verify();
-
-	writer->Write<WALType>(WALType::DELETE_TUPLE);
-	chunk.Serialize(*writer);
-}
-
-void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column_indexes) {
-	if (skip_writing) {
-		return;
-	}
-	D_ASSERT(chunk.size() > 0);
-	D_ASSERT(chunk.ColumnCount() == 2);
-	D_ASSERT(chunk.data[1].GetType().id() == LogicalType::ROW_TYPE);
-	chunk.Verify();
-
-	writer->Write<WALType>(WALType::UPDATE_TUPLE);
-	writer->Write<idx_t>(column_indexes.size());
-	for (auto &col_idx : column_indexes) {
-		writer->Write<column_t>(col_idx);
-	}
-	chunk.Serialize(*writer);
-}
-
-//===--------------------------------------------------------------------===//
-// Write ALTER Statement
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteAlter(AlterInfo &info) {
-	if (skip_writing) {
-		return;
-	}
-	writer->Write<WALType>(WALType::ALTER_INFO);
-	info.Serialize(*writer);
-}
-
-//===--------------------------------------------------------------------===//
-// FLUSH
-//===--------------------------------------------------------------------===//
-void WriteAheadLog::Flush() {
-	if (skip_writing) {
-		return;
-	}
-	// write an empty entry
-	writer->Write<WALType>(WALType::WAL_FLUSH);
-	// flushes all changes made to the WAL to disk
-	writer->Sync();
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-CleanupState::CleanupState() : current_table(nullptr), count(0) {
-}
-
-CleanupState::~CleanupState() {
-	Flush();
-}
-
-void CleanupState::CleanupEntry(UndoFlags type, data_ptr_t data) {
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		auto catalog_entry = Load<CatalogEntry *>(data);
-		D_ASSERT(catalog_entry);
-		D_ASSERT(catalog_entry->set);
-		catalog_entry->set->CleanupEntry(catalog_entry);
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		auto info = (DeleteInfo *)data;
-		CleanupDelete(info);
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		auto info = (UpdateInfo *)data;
-		CleanupUpdate(info);
-		break;
-	}
-	default:
-		break;
-	}
-}
-
-void CleanupState::CleanupUpdate(UpdateInfo *info) {
-	// remove the update info from the update chain
-	// first obtain an exclusive lock on the segment
-	info->segment->CleanupUpdate(info);
-}
-
-void CleanupState::CleanupDelete(DeleteInfo *info) {
-	auto version_table = info->table;
-	version_table->info->cardinality -= info->count;
-	if (version_table->info->indexes.Empty()) {
-		// this table has no indexes: no cleanup to be done
-		return;
-	}
-	if (current_table != version_table) {
-		// table for this entry differs from previous table: flush and switch to the new table
-		Flush();
-		current_table = version_table;
-	}
-	count = 0;
-	for (idx_t i = 0; i < info->count; i++) {
-		row_numbers[count++] = info->vinfo->start + info->rows[i];
-	}
-	Flush();
-}
-
-void CleanupState::Flush() {
-	if (count == 0) {
-		return;
-	}
-
-	// set up the row identifiers vector
-	Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_numbers);
-
-	// delete the tuples from all the indexes
-	current_table->RemoveFromIndexes(row_identifiers, count);
-
-	count = 0;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-CommitState::CommitState(transaction_t commit_id, WriteAheadLog *log)
-    : log(log), commit_id(commit_id), current_table_info(nullptr) {
-}
-
-void CommitState::SwitchTable(DataTableInfo *table_info, UndoFlags new_op) {
-	if (current_table_info != table_info) {
-		// write the current table to the log
-		log->WriteSetTable(table_info->schema, table_info->table);
-		current_table_info = table_info;
-	}
-}
-
-void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
-	if (entry->temporary || entry->parent->temporary) {
-		return;
-	}
-	D_ASSERT(log);
-	// look at the type of the parent entry
-	auto parent = entry->parent;
-	switch (parent->type) {
-	case CatalogType::TABLE_ENTRY:
-		if (entry->type == CatalogType::TABLE_ENTRY) {
-			auto table_entry = (TableCatalogEntry *)entry;
-			// ALTER TABLE statement, read the extra data after the entry
-			auto extra_data_size = Load<idx_t>(dataptr);
-			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
-			// deserialize it
-			BufferedDeserializer source(extra_data, extra_data_size);
-			auto info = AlterInfo::Deserialize(source);
-			// write the alter table in the log
-			table_entry->CommitAlter(*info);
-			log->WriteAlter(*info);
-		} else {
-			// CREATE TABLE statement
-			log->WriteCreateTable((TableCatalogEntry *)parent);
-		}
-		break;
-	case CatalogType::SCHEMA_ENTRY:
-		if (entry->type == CatalogType::SCHEMA_ENTRY) {
-			// ALTER TABLE statement, skip it
-			return;
-		}
-		log->WriteCreateSchema((SchemaCatalogEntry *)parent);
-		break;
-	case CatalogType::VIEW_ENTRY:
-		if (entry->type == CatalogType::VIEW_ENTRY) {
-			// ALTER TABLE statement, read the extra data after the entry
-			auto extra_data_size = Load<idx_t>(dataptr);
-			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
-			// deserialize it
-			BufferedDeserializer source(extra_data, extra_data_size);
-			auto info = AlterInfo::Deserialize(source);
-			// write the alter table in the log
-			log->WriteAlter(*info);
-		} else {
-			log->WriteCreateView((ViewCatalogEntry *)parent);
-		}
-		break;
-	case CatalogType::SEQUENCE_ENTRY:
-		log->WriteCreateSequence((SequenceCatalogEntry *)parent);
-		break;
-	case CatalogType::MACRO_ENTRY:
-		log->WriteCreateMacro((ScalarMacroCatalogEntry *)parent);
-		break;
-	case CatalogType::TABLE_MACRO_ENTRY:
-		log->WriteCreateTableMacro((TableMacroCatalogEntry *)parent);
-		break;
-
-	case CatalogType::TYPE_ENTRY:
-		log->WriteCreateType((TypeCatalogEntry *)parent);
-		break;
-	case CatalogType::DELETED_ENTRY:
-		switch (entry->type) {
-		case CatalogType::TABLE_ENTRY: {
-			auto table_entry = (TableCatalogEntry *)entry;
-			table_entry->CommitDrop();
-			log->WriteDropTable(table_entry);
-			break;
-		}
-		case CatalogType::SCHEMA_ENTRY:
-			log->WriteDropSchema((SchemaCatalogEntry *)entry);
-			break;
-		case CatalogType::VIEW_ENTRY:
-			log->WriteDropView((ViewCatalogEntry *)entry);
-			break;
-		case CatalogType::SEQUENCE_ENTRY:
-			log->WriteDropSequence((SequenceCatalogEntry *)entry);
-			break;
-		case CatalogType::MACRO_ENTRY:
-			log->WriteDropMacro((ScalarMacroCatalogEntry *)entry);
-			break;
-		case CatalogType::TABLE_MACRO_ENTRY:
-			log->WriteDropTableMacro((TableMacroCatalogEntry *)entry);
-			break;
-		case CatalogType::TYPE_ENTRY:
-			log->WriteDropType((TypeCatalogEntry *)entry);
-			break;
-		case CatalogType::INDEX_ENTRY:
-		case CatalogType::PREPARED_STATEMENT:
-		case CatalogType::SCALAR_FUNCTION_ENTRY:
-			// do nothing, indexes/prepared statements/functions aren't persisted to disk
-			break;
-		default:
-			throw InternalException("Don't know how to drop this type!");
-		}
-		break;
-	case CatalogType::INDEX_ENTRY:
-	case CatalogType::PREPARED_STATEMENT:
-	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
-	case CatalogType::TABLE_FUNCTION_ENTRY:
-	case CatalogType::COPY_FUNCTION_ENTRY:
-	case CatalogType::PRAGMA_FUNCTION_ENTRY:
-	case CatalogType::COLLATION_ENTRY:
-		// do nothing, these entries are not persisted to disk
-		break;
-	default:
-		throw InternalException("UndoBuffer - don't know how to write this entry to the WAL");
-	}
-}
-
-void CommitState::WriteDelete(DeleteInfo *info) {
-	D_ASSERT(log);
-	// switch to the current table, if necessary
-	SwitchTable(info->table->info.get(), UndoFlags::DELETE_TUPLE);
-
-	if (!delete_chunk) {
-		delete_chunk = make_unique<DataChunk>();
-		vector<LogicalType> delete_types = {LogicalType::ROW_TYPE};
-		delete_chunk->Initialize(Allocator::DefaultAllocator(), delete_types);
-	}
-	auto rows = FlatVector::GetData<row_t>(delete_chunk->data[0]);
-	for (idx_t i = 0; i < info->count; i++) {
-		rows[i] = info->base_row + info->rows[i];
-	}
-	delete_chunk->SetCardinality(info->count);
-	log->WriteDelete(*delete_chunk);
-}
-
-void CommitState::WriteUpdate(UpdateInfo *info) {
-	D_ASSERT(log);
-	// switch to the current table, if necessary
-	auto &column_data = info->segment->column_data;
-	auto &table_info = column_data.GetTableInfo();
-
-	SwitchTable(&table_info, UndoFlags::UPDATE_TUPLE);
-
-	// initialize the update chunk
-	vector<LogicalType> update_types;
-	if (column_data.type.id() == LogicalTypeId::VALIDITY) {
-		update_types.emplace_back(LogicalType::BOOLEAN);
-	} else {
-		update_types.push_back(column_data.type);
-	}
-	update_types.emplace_back(LogicalType::ROW_TYPE);
-
-	update_chunk = make_unique<DataChunk>();
-	update_chunk->Initialize(Allocator::DefaultAllocator(), update_types);
-
-	// fetch the updated values from the base segment
-	info->segment->FetchCommitted(info->vector_index, update_chunk->data[0]);
-
-	// write the row ids into the chunk
-	auto row_ids = FlatVector::GetData<row_t>(update_chunk->data[1]);
-	idx_t start = column_data.start + info->vector_index * STANDARD_VECTOR_SIZE;
-	for (idx_t i = 0; i < info->N; i++) {
-		row_ids[info->tuples[i]] = start + info->tuples[i];
-	}
-	if (column_data.type.id() == LogicalTypeId::VALIDITY) {
-		// zero-initialize the booleans
-		// FIXME: this is only required because of NullValue<T> in Vector::Serialize...
-		auto booleans = FlatVector::GetData<bool>(update_chunk->data[0]);
-		for (idx_t i = 0; i < info->N; i++) {
-			auto idx = info->tuples[i];
-			booleans[idx] = false;
-		}
-	}
-	SelectionVector sel(info->tuples);
-	update_chunk->Slice(sel, info->N);
-
-	// construct the column index path
-	vector<column_t> column_indexes;
-	auto column_data_ptr = &column_data;
-	while (column_data_ptr->parent) {
-		column_indexes.push_back(column_data_ptr->column_index);
-		column_data_ptr = column_data_ptr->parent;
-	}
-	column_indexes.push_back(info->column_index);
-	std::reverse(column_indexes.begin(), column_indexes.end());
-
-	log->WriteUpdate(*update_chunk, column_indexes);
-}
-
-template <bool HAS_LOG>
-void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		// set the commit timestamp of the catalog entry to the given id
-		auto catalog_entry = Load<CatalogEntry *>(data);
-		D_ASSERT(catalog_entry->parent);
-		catalog_entry->set->UpdateTimestamp(catalog_entry->parent, commit_id);
-		if (catalog_entry->name != catalog_entry->parent->name) {
-			catalog_entry->set->UpdateTimestamp(catalog_entry, commit_id);
-		}
-		if (HAS_LOG) {
-			// push the catalog update to the WAL
-			WriteCatalogEntry(catalog_entry, data + sizeof(CatalogEntry *));
-		}
-		break;
-	}
-	case UndoFlags::INSERT_TUPLE: {
-		// append:
-		auto info = (AppendInfo *)data;
-		if (HAS_LOG && !info->table->info->IsTemporary()) {
-			info->table->WriteToLog(*log, info->start_row, info->count);
-		}
-		// mark the tuples as committed
-		info->table->CommitAppend(commit_id, info->start_row, info->count);
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		// deletion:
-		auto info = (DeleteInfo *)data;
-		if (HAS_LOG && !info->table->info->IsTemporary()) {
-			WriteDelete(info);
-		}
-		// mark the tuples as committed
-		info->vinfo->CommitDelete(commit_id, info->rows, info->count);
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		// update:
-		auto info = (UpdateInfo *)data;
-		if (HAS_LOG && !info->segment->column_data.GetTableInfo().IsTemporary()) {
-			WriteUpdate(info);
-		}
-		info->version_number = commit_id;
-		break;
-	}
-	default:
-		throw InternalException("UndoBuffer - don't know how to commit this type!");
-	}
-}
-
-void CommitState::RevertCommit(UndoFlags type, data_ptr_t data) {
-	transaction_t transaction_id = commit_id;
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		// set the commit timestamp of the catalog entry to the given id
-		auto catalog_entry = Load<CatalogEntry *>(data);
-		D_ASSERT(catalog_entry->parent);
-		catalog_entry->set->UpdateTimestamp(catalog_entry->parent, transaction_id);
-		if (catalog_entry->name != catalog_entry->parent->name) {
-			catalog_entry->set->UpdateTimestamp(catalog_entry, transaction_id);
-		}
-		break;
-	}
-	case UndoFlags::INSERT_TUPLE: {
-		auto info = (AppendInfo *)data;
-		// revert this append
-		info->table->RevertAppend(info->start_row, info->count);
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		// deletion:
-		auto info = (DeleteInfo *)data;
-		info->table->info->cardinality += info->count;
-		// revert the commit by writing the (uncommitted) transaction_id back into the version info
-		info->vinfo->CommitDelete(transaction_id, info->rows, info->count);
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		// update:
-		auto info = (UpdateInfo *)data;
-		info->version_number = transaction_id;
-		break;
-	}
-	default:
-		throw InternalException("UndoBuffer - don't know how to revert commit of this type!");
-	}
-}
-
-template void CommitState::CommitEntry<true>(UndoFlags type, data_ptr_t data);
-template void CommitState::CommitEntry<false>(UndoFlags type, data_ptr_t data);
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
-	switch (type) {
-	case UndoFlags::CATALOG_ENTRY: {
-		// undo this catalog entry
-		auto catalog_entry = Load<CatalogEntry *>(data);
-		D_ASSERT(catalog_entry->set);
-		catalog_entry->set->Undo(catalog_entry);
-		break;
-	}
-	case UndoFlags::INSERT_TUPLE: {
-		auto info = (AppendInfo *)data;
-		// revert the append in the base table
-		info->table->RevertAppend(info->start_row, info->count);
-		break;
-	}
-	case UndoFlags::DELETE_TUPLE: {
-		auto info = (DeleteInfo *)data;
-		// reset the deleted flag on rollback
-		info->vinfo->CommitDelete(NOT_DELETED_ID, info->rows, info->count);
-		break;
-	}
-	case UndoFlags::UPDATE_TUPLE: {
-		auto info = (UpdateInfo *)data;
-		info->segment->RollbackUpdate(info);
-		break;
-	}
-	default: // LCOV_EXCL_START
-		D_ASSERT(type == UndoFlags::EMPTY_ENTRY);
-		break;
-	} // LCOV_EXCL_STOP
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-Transaction::Transaction(weak_ptr<ClientContext> context_p, transaction_t start_time, transaction_t transaction_id,
-                         timestamp_t start_timestamp, idx_t catalog_version)
-    : context(move(context_p)), start_time(start_time), transaction_id(transaction_id), commit_id(0),
-      highest_active_query(0), active_query(MAXIMUM_QUERY_ID), start_timestamp(start_timestamp),
-      catalog_version(catalog_version), storage(*this), is_invalidated(false), undo_buffer(context.lock()) {
-}
-
-Transaction &Transaction::GetTransaction(ClientContext &context) {
-	return context.ActiveTransaction();
-}
-
-void Transaction::PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data, idx_t extra_data_size) {
-	idx_t alloc_size = sizeof(CatalogEntry *);
-	if (extra_data_size > 0) {
-		alloc_size += extra_data_size + sizeof(idx_t);
-	}
-	auto baseptr = undo_buffer.CreateEntry(UndoFlags::CATALOG_ENTRY, alloc_size);
-	// store the pointer to the catalog entry
-	Store<CatalogEntry *>(entry, baseptr);
-	if (extra_data_size > 0) {
-		// copy the extra data behind the catalog entry pointer (if any)
-		baseptr += sizeof(CatalogEntry *);
-		// first store the extra data size
-		Store<idx_t>(extra_data_size, baseptr);
-		baseptr += sizeof(idx_t);
-		// then copy over the actual data
-		memcpy(baseptr, extra_data, extra_data_size);
-	}
-}
-
-void Transaction::PushDelete(DataTable *table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
-	auto delete_info =
-	    (DeleteInfo *)undo_buffer.CreateEntry(UndoFlags::DELETE_TUPLE, sizeof(DeleteInfo) + sizeof(row_t) * count);
-	delete_info->vinfo = vinfo;
-	delete_info->table = table;
-	delete_info->count = count;
-	delete_info->base_row = base_row;
-	memcpy(delete_info->rows, rows, sizeof(row_t) * count);
-}
-
-void Transaction::PushAppend(DataTable *table, idx_t start_row, idx_t row_count) {
-	auto append_info = (AppendInfo *)undo_buffer.CreateEntry(UndoFlags::INSERT_TUPLE, sizeof(AppendInfo));
-	append_info->table = table;
-	append_info->start_row = start_row;
-	append_info->count = row_count;
-}
-
-UpdateInfo *Transaction::CreateUpdateInfo(idx_t type_size, idx_t entries) {
-	auto update_info = (UpdateInfo *)undo_buffer.CreateEntry(
-	    UndoFlags::UPDATE_TUPLE, sizeof(UpdateInfo) + (sizeof(sel_t) + type_size) * STANDARD_VECTOR_SIZE);
-	update_info->max = STANDARD_VECTOR_SIZE;
-	update_info->tuples = (sel_t *)(((data_ptr_t)update_info) + sizeof(UpdateInfo));
-	update_info->tuple_data = ((data_ptr_t)update_info) + sizeof(UpdateInfo) + sizeof(sel_t) * update_info->max;
-	update_info->version_number = transaction_id;
-	return update_info;
-}
-
-bool Transaction::ChangesMade() {
-	return undo_buffer.ChangesMade() || storage.ChangesMade();
-}
-
-bool Transaction::AutomaticCheckpoint(DatabaseInstance &db) {
-	auto &config = DBConfig::GetConfig(db);
-	auto &storage_manager = StorageManager::GetStorageManager(db);
-	auto log = storage_manager.GetWriteAheadLog();
-	if (!log) {
-		return false;
-	}
-
-	auto initial_size = log->GetWALSize();
-	idx_t expected_wal_size = initial_size + storage.EstimatedSize() + undo_buffer.EstimatedSize();
-	return expected_wal_size > config.checkpoint_wal_size;
-}
-
-string Transaction::Commit(DatabaseInstance &db, transaction_t commit_id, bool checkpoint) noexcept {
-	this->commit_id = commit_id;
-	auto &storage_manager = StorageManager::GetStorageManager(db);
-	auto log = storage_manager.GetWriteAheadLog();
-
-	UndoBuffer::IteratorState iterator_state;
-	LocalStorage::CommitState commit_state;
-	idx_t initial_wal_size = 0;
-	idx_t initial_written = 0;
-	if (log) {
-		auto initial_size = log->GetWALSize();
-		initial_written = log->GetTotalWritten();
-		initial_wal_size = initial_size < 0 ? 0 : idx_t(initial_size);
-	} else {
-		D_ASSERT(!checkpoint);
-	}
-	try {
-		if (checkpoint) {
-			// check if we are checkpointing after this commit
-			// if we are checkpointing, we don't need to write anything to the WAL
-			// this saves us a lot of unnecessary writes to disk in the case of large commits
-			log->skip_writing = true;
-		}
-		storage.Commit(commit_state, *this, log, commit_id);
-		undo_buffer.Commit(iterator_state, log, commit_id);
-		if (log) {
-			// commit any sequences that were used to the WAL
-			for (auto &entry : sequence_usage) {
-				log->WriteSequenceValue(entry.first, entry.second);
-			}
-			// flush the WAL if any changes were made
-			if (log->GetTotalWritten() > initial_written) {
-				D_ASSERT(!checkpoint);
-				D_ASSERT(!log->skip_writing);
-				log->Flush();
-			}
-			log->skip_writing = false;
-		}
-		return string();
-	} catch (std::exception &ex) {
-		undo_buffer.RevertCommit(iterator_state, transaction_id);
-		if (log) {
-			log->skip_writing = false;
-			if (log->GetTotalWritten() > initial_written) {
-				// remove any entries written into the WAL by truncating it
-				log->Truncate(initial_wal_size);
-			}
-		}
-		D_ASSERT(!log || !log->skip_writing);
-		return ex.what();
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-TransactionContext::~TransactionContext() {
-	if (current_transaction) {
-		try {
-			Rollback();
-		} catch (...) {
-		}
-	}
-}
-
-void TransactionContext::BeginTransaction() {
-	if (current_transaction) {
-		throw TransactionException("cannot start a transaction within a transaction");
-	}
-	current_transaction = transaction_manager.StartTransaction(context);
-}
-
-void TransactionContext::Commit() {
-	if (!current_transaction) {
-		throw TransactionException("failed to commit: no transaction active");
-	}
-	auto transaction = current_transaction;
-	SetAutoCommit(true);
-	current_transaction = nullptr;
-	string error = transaction_manager.CommitTransaction(context, transaction);
-	if (!error.empty()) {
-		throw TransactionException("Failed to commit: %s", error);
-	}
-}
-
-void TransactionContext::SetAutoCommit(bool value) {
-	auto_commit = value;
-	if (!auto_commit && !current_transaction) {
-		BeginTransaction();
-	}
-}
-
-void TransactionContext::Rollback() {
-	if (!current_transaction) {
-		throw TransactionException("failed to rollback: no transaction active");
-	}
-	auto transaction = current_transaction;
-	ClearTransaction();
-	transaction_manager.RollbackTransaction(transaction);
-}
-
-void TransactionContext::ClearTransaction() {
-	SetAutoCommit(true);
-	current_transaction = nullptr;
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CheckpointLock {
-	explicit CheckpointLock(TransactionManager &manager) : manager(manager), is_locked(false) {
-	}
-	~CheckpointLock() {
-		Unlock();
-	}
-
-	TransactionManager &manager;
-	bool is_locked;
-
-	void Lock() {
-		D_ASSERT(!manager.thread_is_checkpointing);
-		manager.thread_is_checkpointing = true;
-		is_locked = true;
-	}
-	void Unlock() {
-		if (!is_locked) {
-			return;
-		}
-		D_ASSERT(manager.thread_is_checkpointing);
-		manager.thread_is_checkpointing = false;
-		is_locked = false;
-	}
-};
-
-TransactionManager::TransactionManager(DatabaseInstance &db) : db(db), thread_is_checkpointing(false) {
-	// start timestamp starts at zero
-	current_start_timestamp = 0;
-	// transaction ID starts very high:
-	// it should be much higher than the current start timestamp
-	// if transaction_id < start_timestamp for any set of active transactions
-	// uncommited data could be read by
-	current_transaction_id = TRANSACTION_ID_START;
-	// the current active query id
-	current_query_number = 1;
-	lowest_active_id = TRANSACTION_ID_START;
-	lowest_active_start = MAX_TRANSACTION_ID;
-}
-
-TransactionManager::~TransactionManager() {
-}
-
-Transaction *TransactionManager::StartTransaction(ClientContext &context) {
-	// obtain the transaction lock during this function
-	lock_guard<mutex> lock(transaction_lock);
-	if (current_start_timestamp >= TRANSACTION_ID_START) { // LCOV_EXCL_START
-		throw InternalException("Cannot start more transactions, ran out of "
-		                        "transaction identifiers!");
-	} // LCOV_EXCL_STOP
-
-	// obtain the start time and transaction ID of this transaction
-	transaction_t start_time = current_start_timestamp++;
-	transaction_t transaction_id = current_transaction_id++;
-	timestamp_t start_timestamp = Timestamp::GetCurrentTimestamp();
-	if (active_transactions.empty()) {
-		lowest_active_start = start_time;
-		lowest_active_id = transaction_id;
-	}
-
-	// create the actual transaction
-	auto &catalog = Catalog::GetCatalog(db);
-	auto transaction = make_unique<Transaction>(weak_ptr<ClientContext>(context.shared_from_this()), start_time,
-	                                            transaction_id, start_timestamp, catalog.GetCatalogVersion());
-	auto transaction_ptr = transaction.get();
-
-	// store it in the set of active transactions
-	active_transactions.push_back(move(transaction));
-	return transaction_ptr;
-}
-
-struct ClientLockWrapper {
-	ClientLockWrapper(mutex &client_lock, shared_ptr<ClientContext> connection)
-	    : connection(move(connection)), connection_lock(make_unique<lock_guard<mutex>>(client_lock)) {
-	}
-
-	shared_ptr<ClientContext> connection;
-	unique_ptr<lock_guard<mutex>> connection_lock;
-};
-
-void TransactionManager::LockClients(vector<ClientLockWrapper> &client_locks, ClientContext &context) {
-	auto &connection_manager = ConnectionManager::Get(context);
-	client_locks.emplace_back(connection_manager.connections_lock, nullptr);
-	auto connection_list = connection_manager.GetConnectionList();
-	for (auto &con : connection_list) {
-		if (con.get() == &context) {
-			continue;
-		}
-		auto &context_lock = con->context_lock;
-		client_locks.emplace_back(context_lock, move(con));
-	}
-}
-
-void TransactionManager::Checkpoint(ClientContext &context, bool force) {
-	auto &storage_manager = StorageManager::GetStorageManager(db);
-	if (storage_manager.InMemory()) {
-		return;
-	}
-
-	// first check if no other thread is checkpointing right now
-	auto lock = make_unique<lock_guard<mutex>>(transaction_lock);
-	if (thread_is_checkpointing) {
-		throw TransactionException("Cannot CHECKPOINT: another thread is checkpointing right now");
-	}
-	CheckpointLock checkpoint_lock(*this);
-	checkpoint_lock.Lock();
-	lock.reset();
-
-	// lock all the clients AND the connection manager now
-	// this ensures no new queries can be started, and no new connections to the database can be made
-	// to avoid deadlock we release the transaction lock while locking the clients
-	vector<ClientLockWrapper> client_locks;
-	LockClients(client_locks, context);
-
-	lock = make_unique<lock_guard<mutex>>(transaction_lock);
-	auto current = &Transaction::GetTransaction(context);
-	if (current->ChangesMade()) {
-		throw TransactionException("Cannot CHECKPOINT: the current transaction has transaction local changes");
-	}
-	if (!force) {
-		if (!CanCheckpoint(current)) {
-			throw TransactionException("Cannot CHECKPOINT: there are other transactions. Use FORCE CHECKPOINT to abort "
-			                           "the other transactions and force a checkpoint");
-		}
-	} else {
-		if (!CanCheckpoint(current)) {
-			for (size_t i = 0; i < active_transactions.size(); i++) {
-				auto &transaction = active_transactions[i];
-				// rollback the transaction
-				transaction->Rollback();
-				auto transaction_context = transaction->context.lock();
-
-				// remove the transaction id from the list of active transactions
-				// potentially resulting in garbage collection
-				RemoveTransaction(transaction.get());
-				if (transaction_context) {
-					transaction_context->transaction.ClearTransaction();
-				}
-				i--;
-			}
-			D_ASSERT(CanCheckpoint(nullptr));
-		}
-	}
-	auto &storage = StorageManager::GetStorageManager(context);
-	storage.CreateCheckpoint();
-}
-
-bool TransactionManager::CanCheckpoint(Transaction *current) {
-	auto &storage_manager = StorageManager::GetStorageManager(db);
-	if (storage_manager.InMemory()) {
-		return false;
-	}
-	if (!recently_committed_transactions.empty() || !old_transactions.empty()) {
-		return false;
-	}
-	for (auto &transaction : active_transactions) {
-		if (transaction.get() != current) {
-			return false;
-		}
-	}
-	return true;
-}
-
-string TransactionManager::CommitTransaction(ClientContext &context, Transaction *transaction) {
-	vector<ClientLockWrapper> client_locks;
-	auto lock = make_unique<lock_guard<mutex>>(transaction_lock);
-	CheckpointLock checkpoint_lock(*this);
-	// check if we can checkpoint
-	bool checkpoint = thread_is_checkpointing ? false : CanCheckpoint(transaction);
-	if (checkpoint) {
-		if (transaction->AutomaticCheckpoint(db)) {
-			checkpoint_lock.Lock();
-			// we might be able to checkpoint: lock all clients
-			// to avoid deadlock we release the transaction lock while locking the clients
-			lock.reset();
-
-			LockClients(client_locks, context);
-
-			lock = make_unique<lock_guard<mutex>>(transaction_lock);
-			checkpoint = CanCheckpoint(transaction);
-			if (!checkpoint) {
-				checkpoint_lock.Unlock();
-				client_locks.clear();
-			}
-		} else {
-			checkpoint = false;
-		}
-	}
-	// obtain a commit id for the transaction
-	transaction_t commit_id = current_start_timestamp++;
-	// commit the UndoBuffer of the transaction
-	string error = transaction->Commit(db, commit_id, checkpoint);
-	if (!error.empty()) {
-		// commit unsuccessful: rollback the transaction instead
-		checkpoint = false;
-		transaction->commit_id = 0;
-		transaction->Rollback();
-	}
-	if (!checkpoint) {
-		// we won't checkpoint after all: unlock the clients again
-		checkpoint_lock.Unlock();
-		client_locks.clear();
-	}
-
-	// commit successful: remove the transaction id from the list of active transactions
-	// potentially resulting in garbage collection
-	RemoveTransaction(transaction);
-	// now perform a checkpoint if (1) we are able to checkpoint, and (2) the WAL has reached sufficient size to
-	// checkpoint
-	if (checkpoint) {
-		// checkpoint the database to disk
-		auto &storage_manager = StorageManager::GetStorageManager(db);
-		storage_manager.CreateCheckpoint(false, true);
-	}
-	return error;
-}
-
-void TransactionManager::RollbackTransaction(Transaction *transaction) {
-	// obtain the transaction lock during this function
-	lock_guard<mutex> lock(transaction_lock);
-
-	// rollback the transaction
-	transaction->Rollback();
-
-	// remove the transaction id from the list of active transactions
-	// potentially resulting in garbage collection
-	RemoveTransaction(transaction);
-}
-
-void TransactionManager::RemoveTransaction(Transaction *transaction) noexcept {
-	// remove the transaction from the list of active transactions
-	idx_t t_index = active_transactions.size();
-	// check for the lowest and highest start time in the list of transactions
-	transaction_t lowest_start_time = TRANSACTION_ID_START;
-	transaction_t lowest_transaction_id = MAX_TRANSACTION_ID;
-	transaction_t lowest_active_query = MAXIMUM_QUERY_ID;
-	for (idx_t i = 0; i < active_transactions.size(); i++) {
-		if (active_transactions[i].get() == transaction) {
-			t_index = i;
-		} else {
-			transaction_t active_query = active_transactions[i]->active_query;
-			lowest_start_time = MinValue(lowest_start_time, active_transactions[i]->start_time);
-			lowest_active_query = MinValue(lowest_active_query, active_query);
-			lowest_transaction_id = MinValue(lowest_transaction_id, active_transactions[i]->transaction_id);
-		}
-	}
-	lowest_active_start = lowest_start_time;
-	lowest_active_id = lowest_transaction_id;
-
-	transaction_t lowest_stored_query = lowest_start_time;
-	D_ASSERT(t_index != active_transactions.size());
-	auto current_transaction = move(active_transactions[t_index]);
-	if (transaction->commit_id != 0) {
-		// the transaction was committed, add it to the list of recently
-		// committed transactions
-		recently_committed_transactions.push_back(move(current_transaction));
-	} else {
-		// the transaction was aborted, but we might still need its information
-		// add it to the set of transactions awaiting GC
-		current_transaction->highest_active_query = current_query_number;
-		old_transactions.push_back(move(current_transaction));
-	}
-	// remove the transaction from the set of currently active transactions
-	active_transactions.erase(active_transactions.begin() + t_index);
-	// traverse the recently_committed transactions to see if we can remove any
-	idx_t i = 0;
-	for (; i < recently_committed_transactions.size(); i++) {
-		D_ASSERT(recently_committed_transactions[i]);
-		lowest_stored_query = MinValue(recently_committed_transactions[i]->start_time, lowest_stored_query);
-		if (recently_committed_transactions[i]->commit_id < lowest_start_time) {
-			// changes made BEFORE this transaction are no longer relevant
-			// we can cleanup the undo buffer
-
-			// HOWEVER: any currently running QUERY can still be using
-			// the version information after the cleanup!
-
-			// if we remove the UndoBuffer immediately, we have a race
-			// condition
-
-			// we can only safely do the actual memory cleanup when all the
-			// currently active queries have finished running! (actually,
-			// when all the currently active scans have finished running...)
-			recently_committed_transactions[i]->Cleanup();
-			// store the current highest active query
-			recently_committed_transactions[i]->highest_active_query = current_query_number;
-			// move it to the list of transactions awaiting GC
-			old_transactions.push_back(move(recently_committed_transactions[i]));
-		} else {
-			// recently_committed_transactions is ordered on commit_id
-			// implicitly thus if the current one is bigger than
-			// lowest_start_time any subsequent ones are also bigger
-			break;
-		}
-	}
-	if (i > 0) {
-		// we garbage collected transactions: remove them from the list
-		recently_committed_transactions.erase(recently_committed_transactions.begin(),
-		                                      recently_committed_transactions.begin() + i);
-	}
-	// check if we can free the memory of any old transactions
-	i = active_transactions.empty() ? old_transactions.size() : 0;
-	for (; i < old_transactions.size(); i++) {
-		D_ASSERT(old_transactions[i]);
-		D_ASSERT(old_transactions[i]->highest_active_query > 0);
-		if (old_transactions[i]->highest_active_query >= lowest_active_query) {
-			// there is still a query running that could be using
-			// this transactions' data
-			break;
-		}
-	}
-	if (i > 0) {
-		// we garbage collected transactions: remove them from the list
-		old_transactions.erase(old_transactions.begin(), old_transactions.begin() + i);
-	}
-	// check if we can free the memory of any old catalog sets
-	for (i = 0; i < old_catalog_sets.size(); i++) {
-		D_ASSERT(old_catalog_sets[i].highest_active_query > 0);
-		if (old_catalog_sets[i].highest_active_query >= lowest_stored_query) {
-			// there is still a query running that could be using
-			// this catalog sets' data
-			break;
-		}
-	}
-	if (i > 0) {
-		// we garbage collected catalog sets: remove them from the list
-		old_catalog_sets.erase(old_catalog_sets.begin(), old_catalog_sets.begin() + i);
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <unordered_map>
-
-namespace duckdb {
-constexpr uint32_t UNDO_ENTRY_HEADER_SIZE = sizeof(UndoFlags) + sizeof(uint32_t);
-
-UndoBuffer::UndoBuffer(const shared_ptr<ClientContext> &context) : allocator(BufferAllocator::Get(*context)) {
-	D_ASSERT(context);
-}
-
-data_ptr_t UndoBuffer::CreateEntry(UndoFlags type, idx_t len) {
-	D_ASSERT(len <= NumericLimits<uint32_t>::Maximum());
-	len = AlignValue(len);
-	idx_t needed_space = len + UNDO_ENTRY_HEADER_SIZE;
-	auto data = allocator.Allocate(needed_space);
-	Store<UndoFlags>(type, data);
-	data += sizeof(UndoFlags);
-	Store<uint32_t>(len, data);
-	data += sizeof(uint32_t);
-	return data;
-}
-
-template <class T>
-void UndoBuffer::IterateEntries(UndoBuffer::IteratorState &state, T &&callback) {
-	// iterate in insertion order: start with the tail
-	state.current = allocator.GetTail();
-	while (state.current) {
-		state.start = state.current->data->get();
-		state.end = state.start + state.current->current_position;
-		while (state.start < state.end) {
-			UndoFlags type = Load<UndoFlags>(state.start);
-			state.start += sizeof(UndoFlags);
-
-			uint32_t len = Load<uint32_t>(state.start);
-			state.start += sizeof(uint32_t);
-			callback(type, state.start);
-			state.start += len;
-		}
-		state.current = state.current->prev;
-	}
-}
-
-template <class T>
-void UndoBuffer::IterateEntries(UndoBuffer::IteratorState &state, UndoBuffer::IteratorState &end_state, T &&callback) {
-	// iterate in insertion order: start with the tail
-	state.current = allocator.GetTail();
-	while (state.current) {
-		state.start = state.current->data->get();
-		state.end =
-		    state.current == end_state.current ? end_state.start : state.start + state.current->current_position;
-		while (state.start < state.end) {
-			auto type = Load<UndoFlags>(state.start);
-			state.start += sizeof(UndoFlags);
-			auto len = Load<uint32_t>(state.start);
-			state.start += sizeof(uint32_t);
-			callback(type, state.start);
-			state.start += len;
-		}
-		if (state.current == end_state.current) {
-			// finished executing until the current end state
-			return;
-		}
-		state.current = state.current->prev;
-	}
-}
-
-template <class T>
-void UndoBuffer::ReverseIterateEntries(T &&callback) {
-	// iterate in reverse insertion order: start with the head
-	auto current = allocator.GetHead();
-	while (current) {
-		data_ptr_t start = current->data->get();
-		data_ptr_t end = start + current->current_position;
-		// create a vector with all nodes in this chunk
-		vector<pair<UndoFlags, data_ptr_t>> nodes;
-		while (start < end) {
-			auto type = Load<UndoFlags>(start);
-			start += sizeof(UndoFlags);
-			auto len = Load<uint32_t>(start);
-			start += sizeof(uint32_t);
-			nodes.emplace_back(type, start);
-			start += len;
-		}
-		// iterate over it in reverse order
-		for (idx_t i = nodes.size(); i > 0; i--) {
-			callback(nodes[i - 1].first, nodes[i - 1].second);
-		}
-		current = current->next.get();
-	}
-}
-
-bool UndoBuffer::ChangesMade() {
-	return !allocator.IsEmpty();
-}
-
-idx_t UndoBuffer::EstimatedSize() {
-	idx_t estimated_size = 0;
-	auto node = allocator.GetHead();
-	while (node) {
-		estimated_size += node->current_position;
-		node = node->next.get();
-	}
-	return estimated_size;
-}
-
-void UndoBuffer::Cleanup() {
-	// garbage collect everything in the Undo Chunk
-	// this should only happen if
-	//  (1) the transaction this UndoBuffer belongs to has successfully
-	//  committed
-	//      (on Rollback the Rollback() function should be called, that clears
-	//      the chunks)
-	//  (2) there is no active transaction with start_id < commit_id of this
-	//  transaction
-	CleanupState state;
-	UndoBuffer::IteratorState iterator_state;
-	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CleanupEntry(type, data); });
-}
-
-void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, WriteAheadLog *log, transaction_t commit_id) {
-	CommitState state(commit_id, log);
-	if (log) {
-		// commit WITH write ahead log
-		IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry<true>(type, data); });
-	} else {
-		// commit WITHOUT write ahead log
-		IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry<false>(type, data); });
-	}
-}
-
-void UndoBuffer::RevertCommit(UndoBuffer::IteratorState &end_state, transaction_t transaction_id) {
-	CommitState state(transaction_id, nullptr);
-	UndoBuffer::IteratorState start_state;
-	IterateEntries(start_state, end_state, [&](UndoFlags type, data_ptr_t data) { state.RevertCommit(type, data); });
-}
-
-void UndoBuffer::Rollback() noexcept {
-	// rollback needs to be performed in reverse
-	RollbackState state;
-	ReverseIterateEntries([&](UndoFlags type, data_ptr_t data) { state.RollbackEntry(type, data); });
-}
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-fastpforlib.cpp b/velox/external/duckdb/duckdb-fastpforlib.cpp
deleted file mode 100644
index 6aa2b6480ff27..0000000000000
--- a/velox/external/duckdb/duckdb-fastpforlib.cpp
+++ /dev/null
@@ -1,1300 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #12
-// See the end of this file for a list
-
-
-
-#include <cstdint>
-#include <type_traits>
-
-namespace duckdb_fastpforlib {
-namespace internal {
-
-// Used for uint8_t, uint16_t and uint32_t
-template <uint8_t DELTA, uint8_t SHR, class TYPE, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
-typename std::enable_if<(DELTA + SHR) < TYPE_SIZE>::type unpack_single_out(const TYPE *__restrict in,
-                                                                           TYPE *__restrict out) {
-	*out = ((*in) >> SHR) % (1 << DELTA);
-}
-
-// Used for uint8_t, uint16_t and uint32_t
-template <uint8_t DELTA, uint8_t SHR, class TYPE, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
-typename std::enable_if<(DELTA + SHR) >= TYPE_SIZE>::type unpack_single_out(const TYPE *__restrict &in,
-                                                                            TYPE *__restrict out) {
-	*out = (*in) >> SHR;
-	++in;
-
-	static const TYPE NEXT_SHR = SHR + DELTA - TYPE_SIZE;
-	*out |= ((*in) % (1U << NEXT_SHR)) << (TYPE_SIZE - SHR);
-}
-
-template <uint8_t DELTA, uint8_t SHR>
-typename std::enable_if<(DELTA + SHR) < 32>::type unpack_single_out(const uint32_t *__restrict in,
-                                                                    uint64_t *__restrict out) {
-	*out = ((static_cast<uint64_t>(*in)) >> SHR) % (1ULL << DELTA);
-}
-
-template <uint8_t DELTA, uint8_t SHR>
-typename std::enable_if<(DELTA + SHR) >= 32 && (DELTA + SHR) < 64>::type
-unpack_single_out(const uint32_t *__restrict &in, uint64_t *__restrict out) {
-	*out = static_cast<uint64_t>(*in) >> SHR;
-	++in;
-	if (DELTA + SHR > 32) {
-		static const uint8_t NEXT_SHR = SHR + DELTA - 32;
-		*out |= static_cast<uint64_t>((*in) % (1U << NEXT_SHR)) << (32 - SHR);
-	}
-}
-
-template <uint8_t DELTA, uint8_t SHR>
-typename std::enable_if<(DELTA + SHR) >= 64>::type unpack_single_out(const uint32_t *__restrict &in,
-                                                                     uint64_t *__restrict out) {
-	*out = static_cast<uint64_t>(*in) >> SHR;
-	++in;
-
-	*out |= static_cast<uint64_t>(*in) << (32 - SHR);
-	++in;
-
-	if (DELTA + SHR > 64) {
-		static const uint8_t NEXT_SHR = DELTA + SHR - 64;
-		*out |= static_cast<uint64_t>((*in) % (1U << NEXT_SHR)) << (64 - SHR);
-	}
-}
-
-// Used for uint8_t, uint16_t and uint32_t
-template <class TYPE, uint16_t DELTA, uint16_t SHL, TYPE MASK, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
-    typename std::enable_if < DELTA + SHL<TYPE_SIZE>::type pack_single_in(const TYPE in, TYPE *__restrict out) {
-	if (SHL == 0) {
-		*out = in & MASK;
-	} else {
-		*out |= (in & MASK) << SHL;
-	}
-}
-
-// Used for uint8_t, uint16_t and uint32_t
-template <class TYPE, uint16_t DELTA, uint16_t SHL, TYPE MASK, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
-typename std::enable_if<DELTA + SHL >= TYPE_SIZE>::type pack_single_in(const TYPE in, TYPE *__restrict &out) {
-	*out |= in << SHL;
-	++out;
-
-	if (DELTA + SHL > TYPE_SIZE) {
-		*out = (in & MASK) >> (TYPE_SIZE - SHL);
-	}
-}
-
-template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
-    typename std::enable_if < DELTA + SHL<32>::type pack_single_in64(const uint64_t in, uint32_t *__restrict out) {
-	if (SHL == 0) {
-		*out = static_cast<uint32_t>(in & MASK);
-	} else {
-		*out |= (in & MASK) << SHL;
-	}
-}
-template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
-        typename std::enable_if < DELTA + SHL >= 32 &&
-    DELTA + SHL<64>::type pack_single_in64(const uint64_t in, uint32_t *__restrict &out) {
-	if (SHL == 0) {
-		*out = static_cast<uint32_t>(in & MASK);
-	} else {
-		*out |= (in & MASK) << SHL;
-	}
-
-	++out;
-
-	if (DELTA + SHL > 32) {
-		*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
-	}
-}
-template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
-typename std::enable_if<DELTA + SHL >= 64>::type pack_single_in64(const uint64_t in, uint32_t *__restrict &out) {
-	*out |= in << SHL;
-	++out;
-
-	*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
-	++out;
-
-	if (DELTA + SHL > 64) {
-		*out = (in & MASK) >> (64 - SHL);
-	}
-}
-template <uint16_t DELTA, uint16_t OINDEX = 0>
-struct Unroller8 {
-	static void Unpack(const uint8_t *__restrict &in, uint8_t *__restrict out) {
-		unpack_single_out<DELTA, (DELTA * OINDEX) % 8>(in, out + OINDEX);
-
-		Unroller8<DELTA, OINDEX + 1>::Unpack(in, out);
-	}
-
-	static void Pack(const uint8_t *__restrict in, uint8_t *__restrict out) {
-		pack_single_in<uint8_t, DELTA, (DELTA * OINDEX) % 8, (1U << DELTA) - 1>(in[OINDEX], out);
-
-		Unroller8<DELTA, OINDEX + 1>::Pack(in, out);
-	}
-
-};\
-template <uint16_t DELTA>
-struct Unroller8<DELTA, 7> {
-	enum { SHIFT = (DELTA * 7) % 8 };
-
-	static void Unpack(const uint8_t *__restrict in, uint8_t *__restrict out) {
-		out[7] = (*in) >> SHIFT;
-	}
-
-	static void Pack(const uint8_t *__restrict in, uint8_t *__restrict out) {
-		*out |= (in[7] << SHIFT);
-	}
-};
-
-template <uint16_t DELTA, uint16_t OINDEX = 0>
-struct Unroller16 {
-	static void Unpack(const uint16_t *__restrict &in, uint16_t *__restrict out) {
-		unpack_single_out<DELTA, (DELTA * OINDEX) % 16>(in, out + OINDEX);
-
-		Unroller16<DELTA, OINDEX + 1>::Unpack(in, out);
-	}
-
-	static void Pack(const uint16_t *__restrict in, uint16_t *__restrict out) {
-		pack_single_in<uint16_t, DELTA, (DELTA * OINDEX) % 16, (1U << DELTA) - 1>(in[OINDEX], out);
-
-		Unroller16<DELTA, OINDEX + 1>::Pack(in, out);
-	}
-
-};
-
-template <uint16_t DELTA>
-struct Unroller16<DELTA, 15> {
-	enum { SHIFT = (DELTA * 15) % 16 };
-
-	static void Unpack(const uint16_t *__restrict in, uint16_t *__restrict out) {
-		out[15] = (*in) >> SHIFT;
-	}
-
-	static void Pack(const uint16_t *__restrict in, uint16_t *__restrict out) {
-		*out |= (in[15] << SHIFT);
-	}
-};
-
-template <uint16_t DELTA, uint16_t OINDEX = 0>
-struct Unroller {
-	static void Unpack(const uint32_t *__restrict &in, uint32_t *__restrict out) {
-		unpack_single_out<DELTA, (DELTA * OINDEX) % 32>(in, out + OINDEX);
-
-		Unroller<DELTA, OINDEX + 1>::Unpack(in, out);
-	}
-
-	static void Unpack(const uint32_t *__restrict &in, uint64_t *__restrict out) {
-		unpack_single_out<DELTA, (DELTA * OINDEX) % 32>(in, out + OINDEX);
-
-		Unroller<DELTA, OINDEX + 1>::Unpack(in, out);
-	}
-
-	static void Pack(const uint32_t *__restrict in, uint32_t *__restrict out) {
-		pack_single_in<uint32_t, DELTA, (DELTA * OINDEX) % 32, (1U << DELTA) - 1>(in[OINDEX], out);
-
-		Unroller<DELTA, OINDEX + 1>::Pack(in, out);
-	}
-
-	static void Pack(const uint64_t *__restrict in, uint32_t *__restrict out) {
-		pack_single_in64<DELTA, (DELTA * OINDEX) % 32, (1ULL << DELTA) - 1>(in[OINDEX], out);
-
-		Unroller<DELTA, OINDEX + 1>::Pack(in, out);
-	}
-};
-
-template <uint16_t DELTA>
-struct Unroller<DELTA, 31> {
-	enum { SHIFT = (DELTA * 31) % 32 };
-
-	static void Unpack(const uint32_t *__restrict in, uint32_t *__restrict out) {
-		out[31] = (*in) >> SHIFT;
-	}
-
-	static void Unpack(const uint32_t *__restrict in, uint64_t *__restrict out) {
-		out[31] = (*in) >> SHIFT;
-		if (DELTA > 32) {
-			++in;
-			out[31] |= static_cast<uint64_t>(*in) << (32 - SHIFT);
-		}
-	}
-
-	static void Pack(const uint32_t *__restrict in, uint32_t *__restrict out) {
-		*out |= (in[31] << SHIFT);
-	}
-
-	static void Pack(const uint64_t *__restrict in, uint32_t *__restrict out) {
-		*out |= (in[31] << SHIFT);
-		if (DELTA > 32) {
-			++out;
-			*out = static_cast<uint32_t>(in[31] >> (32 - SHIFT));
-		}
-	}
-};
-
-// Special cases
-void __fastunpack0(const uint8_t *__restrict, uint8_t *__restrict out) {
-	for (uint8_t i = 0; i < 8; ++i)
-		*(out++) = 0;
-}
-
-void __fastunpack0(const uint16_t *__restrict, uint16_t *__restrict out) {
-	for (uint16_t i = 0; i < 16; ++i)
-		*(out++) = 0;
-}
-
-void __fastunpack0(const uint32_t *__restrict, uint32_t *__restrict out) {
-	for (uint32_t i = 0; i < 32; ++i)
-		*(out++) = 0;
-}
-
-void __fastunpack0(const uint32_t *__restrict, uint64_t *__restrict out) {
-	for (uint32_t i = 0; i < 32; ++i)
-		*(out++) = 0;
-}
-
-void __fastpack0(const uint8_t *__restrict, uint8_t *__restrict) {
-}
-void __fastpack0(const uint16_t *__restrict, uint16_t *__restrict) {
-}
-void __fastpack0(const uint32_t *__restrict, uint32_t *__restrict) {
-}
-void __fastpack0(const uint64_t *__restrict, uint32_t *__restrict) {
-}
-
-// fastunpack for 8 bits
-void __fastunpack1(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<1>::Unpack(in, out);
-}
-
-void __fastunpack2(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<2>::Unpack(in, out);
-}
-
-void __fastunpack3(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<3>::Unpack(in, out);
-}
-
-void __fastunpack4(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	for (uint8_t outer = 0; outer < 4; ++outer) {
-		for (uint8_t inwordpointer = 0; inwordpointer < 8; inwordpointer += 4)
-			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
-		++in;
-	}
-}
-
-void __fastunpack5(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<5>::Unpack(in, out);
-}
-
-void __fastunpack6(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<6>::Unpack(in, out);
-}
-
-void __fastunpack7(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<7>::Unpack(in, out);
-}
-
-void __fastunpack8(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	for (int k = 0; k < 8; ++k)
-		out[k] = in[k];
-}
-
-
-// fastunpack for 16 bits
-void __fastunpack1(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<1>::Unpack(in, out);
-}
-
-void __fastunpack2(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<2>::Unpack(in, out);
-}
-
-void __fastunpack3(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<3>::Unpack(in, out);
-}
-
-void __fastunpack4(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	for (uint16_t outer = 0; outer < 4; ++outer) {
-		for (uint16_t inwordpointer = 0; inwordpointer < 16; inwordpointer += 4)
-			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
-		++in;
-	}
-}
-
-void __fastunpack5(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<5>::Unpack(in, out);
-}
-
-void __fastunpack6(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<6>::Unpack(in, out);
-}
-
-void __fastunpack7(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<7>::Unpack(in, out);
-}
-
-void __fastunpack8(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	for (uint16_t outer = 0; outer < 8; ++outer) {
-		for (uint16_t inwordpointer = 0; inwordpointer < 16; inwordpointer += 8)
-			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
-		++in;
-	}
-}
-
-void __fastunpack9(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<9>::Unpack(in, out);
-}
-
-void __fastunpack10(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<10>::Unpack(in, out);
-}
-
-void __fastunpack11(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<11>::Unpack(in, out);
-}
-
-void __fastunpack12(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<12>::Unpack(in, out);
-}
-
-void __fastunpack13(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<13>::Unpack(in, out);
-}
-
-void __fastunpack14(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<14>::Unpack(in, out);
-}
-
-void __fastunpack15(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<15>::Unpack(in, out);
-}
-
-void __fastunpack16(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	for (int k = 0; k < 16; ++k)
-		out[k] = in[k];
-}
-
-// fastunpack for 32 bits
-void __fastunpack1(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<1>::Unpack(in, out);
-}
-
-void __fastunpack2(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<2>::Unpack(in, out);
-}
-
-void __fastunpack3(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<3>::Unpack(in, out);
-}
-
-void __fastunpack4(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	for (uint32_t outer = 0; outer < 4; ++outer) {
-		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
-			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
-		++in;
-	}
-}
-
-void __fastunpack5(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<5>::Unpack(in, out);
-}
-
-void __fastunpack6(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<6>::Unpack(in, out);
-}
-
-void __fastunpack7(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<7>::Unpack(in, out);
-}
-
-void __fastunpack8(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	for (uint32_t outer = 0; outer < 8; ++outer) {
-		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 8)
-			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
-		++in;
-	}
-}
-
-void __fastunpack9(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<9>::Unpack(in, out);
-}
-
-void __fastunpack10(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<10>::Unpack(in, out);
-}
-
-void __fastunpack11(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<11>::Unpack(in, out);
-}
-
-void __fastunpack12(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<12>::Unpack(in, out);
-}
-
-void __fastunpack13(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<13>::Unpack(in, out);
-}
-
-void __fastunpack14(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<14>::Unpack(in, out);
-}
-
-void __fastunpack15(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<15>::Unpack(in, out);
-}
-
-void __fastunpack16(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	for (uint32_t outer = 0; outer < 16; ++outer) {
-		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
-			*(out++) = ((*in) >> inwordpointer) % (1U << 16);
-		++in;
-	}
-}
-
-void __fastunpack17(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<17>::Unpack(in, out);
-}
-
-void __fastunpack18(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<18>::Unpack(in, out);
-}
-
-void __fastunpack19(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<19>::Unpack(in, out);
-}
-
-void __fastunpack20(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<20>::Unpack(in, out);
-}
-
-void __fastunpack21(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<21>::Unpack(in, out);
-}
-
-void __fastunpack22(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<22>::Unpack(in, out);
-}
-
-void __fastunpack23(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<23>::Unpack(in, out);
-}
-
-void __fastunpack24(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<24>::Unpack(in, out);
-}
-
-void __fastunpack25(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<25>::Unpack(in, out);
-}
-
-void __fastunpack26(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<26>::Unpack(in, out);
-}
-
-void __fastunpack27(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<27>::Unpack(in, out);
-}
-
-void __fastunpack28(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<28>::Unpack(in, out);
-}
-
-void __fastunpack29(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<29>::Unpack(in, out);
-}
-
-void __fastunpack30(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<30>::Unpack(in, out);
-}
-
-void __fastunpack31(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<31>::Unpack(in, out);
-}
-
-void __fastunpack32(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	for (int k = 0; k < 32; ++k)
-		out[k] = in[k];
-}
-
-// fastupack for 64 bits
-void __fastunpack1(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<1>::Unpack(in, out);
-}
-
-void __fastunpack2(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<2>::Unpack(in, out);
-}
-
-void __fastunpack3(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<3>::Unpack(in, out);
-}
-
-void __fastunpack4(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	for (uint32_t outer = 0; outer < 4; ++outer) {
-		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
-			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
-		++in;
-	}
-}
-
-void __fastunpack5(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<5>::Unpack(in, out);
-}
-
-void __fastunpack6(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<6>::Unpack(in, out);
-}
-
-void __fastunpack7(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<7>::Unpack(in, out);
-}
-
-void __fastunpack8(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	for (uint32_t outer = 0; outer < 8; ++outer) {
-		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 8) {
-			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
-		}
-		++in;
-	}
-}
-
-void __fastunpack9(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<9>::Unpack(in, out);
-}
-
-void __fastunpack10(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<10>::Unpack(in, out);
-}
-
-void __fastunpack11(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<11>::Unpack(in, out);
-}
-
-void __fastunpack12(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<12>::Unpack(in, out);
-}
-
-void __fastunpack13(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<13>::Unpack(in, out);
-}
-
-void __fastunpack14(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<14>::Unpack(in, out);
-}
-
-void __fastunpack15(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<15>::Unpack(in, out);
-}
-
-void __fastunpack16(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	for (uint32_t outer = 0; outer < 16; ++outer) {
-		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
-			*(out++) = ((*in) >> inwordpointer) % (1U << 16);
-		++in;
-	}
-}
-
-void __fastunpack17(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<17>::Unpack(in, out);
-}
-
-void __fastunpack18(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<18>::Unpack(in, out);
-}
-
-void __fastunpack19(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<19>::Unpack(in, out);
-}
-
-void __fastunpack20(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<20>::Unpack(in, out);
-}
-
-void __fastunpack21(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<21>::Unpack(in, out);
-}
-
-void __fastunpack22(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<22>::Unpack(in, out);
-}
-
-void __fastunpack23(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<23>::Unpack(in, out);
-}
-
-void __fastunpack24(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<24>::Unpack(in, out);
-}
-
-void __fastunpack25(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<25>::Unpack(in, out);
-}
-
-void __fastunpack26(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<26>::Unpack(in, out);
-}
-
-void __fastunpack27(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<27>::Unpack(in, out);
-}
-
-void __fastunpack28(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<28>::Unpack(in, out);
-}
-
-void __fastunpack29(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<29>::Unpack(in, out);
-}
-
-void __fastunpack30(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<30>::Unpack(in, out);
-}
-
-void __fastunpack31(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<31>::Unpack(in, out);
-}
-
-void __fastunpack32(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	for (int k = 0; k < 32; ++k)
-		out[k] = in[k];
-}
-
-void __fastunpack33(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<33>::Unpack(in, out);
-}
-
-void __fastunpack34(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<34>::Unpack(in, out);
-}
-
-void __fastunpack35(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<35>::Unpack(in, out);
-}
-
-void __fastunpack36(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<36>::Unpack(in, out);
-}
-
-void __fastunpack37(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<37>::Unpack(in, out);
-}
-
-void __fastunpack38(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<38>::Unpack(in, out);
-}
-
-void __fastunpack39(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<39>::Unpack(in, out);
-}
-
-void __fastunpack40(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<40>::Unpack(in, out);
-}
-
-void __fastunpack41(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<41>::Unpack(in, out);
-}
-
-void __fastunpack42(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<42>::Unpack(in, out);
-}
-
-void __fastunpack43(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<43>::Unpack(in, out);
-}
-
-void __fastunpack44(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<44>::Unpack(in, out);
-}
-
-void __fastunpack45(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<45>::Unpack(in, out);
-}
-
-void __fastunpack46(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<46>::Unpack(in, out);
-}
-
-void __fastunpack47(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<47>::Unpack(in, out);
-}
-
-void __fastunpack48(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<48>::Unpack(in, out);
-}
-
-void __fastunpack49(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<49>::Unpack(in, out);
-}
-
-void __fastunpack50(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<50>::Unpack(in, out);
-}
-
-void __fastunpack51(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<51>::Unpack(in, out);
-}
-
-void __fastunpack52(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<52>::Unpack(in, out);
-}
-
-void __fastunpack53(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<53>::Unpack(in, out);
-}
-
-void __fastunpack54(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<54>::Unpack(in, out);
-}
-
-void __fastunpack55(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<55>::Unpack(in, out);
-}
-
-void __fastunpack56(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<56>::Unpack(in, out);
-}
-
-void __fastunpack57(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<57>::Unpack(in, out);
-}
-
-void __fastunpack58(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<58>::Unpack(in, out);
-}
-
-void __fastunpack59(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<59>::Unpack(in, out);
-}
-
-void __fastunpack60(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<60>::Unpack(in, out);
-}
-
-void __fastunpack61(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<61>::Unpack(in, out);
-}
-
-void __fastunpack62(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<62>::Unpack(in, out);
-}
-
-void __fastunpack63(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	Unroller<63>::Unpack(in, out);
-}
-
-void __fastunpack64(const uint32_t *__restrict in, uint64_t *__restrict out) {
-	for (int k = 0; k < 32; ++k) {
-		out[k] = in[k * 2];
-		out[k] |= static_cast<uint64_t>(in[k * 2 + 1]) << 32;
-	}
-}
-
-// fastpack for 8 bits
-
-void __fastpack1(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<1>::Pack(in, out);
-}
-
-void __fastpack2(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<2>::Pack(in, out);
-}
-
-void __fastpack3(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<3>::Pack(in, out);
-}
-
-void __fastpack4(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<4>::Pack(in, out);
-}
-
-void __fastpack5(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<5>::Pack(in, out);
-}
-
-void __fastpack6(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<6>::Pack(in, out);
-}
-
-void __fastpack7(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	Unroller8<7>::Pack(in, out);
-}
-
-void __fastpack8(const uint8_t *__restrict in, uint8_t *__restrict out) {
-	for (int k = 0; k < 8; ++k)
-		out[k] = in[k];
-}
-
-// fastpack for 16 bits
-
-void __fastpack1(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<1>::Pack(in, out);
-}
-
-void __fastpack2(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<2>::Pack(in, out);
-}
-
-void __fastpack3(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<3>::Pack(in, out);
-}
-
-void __fastpack4(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<4>::Pack(in, out);
-}
-
-void __fastpack5(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<5>::Pack(in, out);
-}
-
-void __fastpack6(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<6>::Pack(in, out);
-}
-
-void __fastpack7(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<7>::Pack(in, out);
-}
-
-void __fastpack8(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<8>::Pack(in, out);
-}
-
-void __fastpack9(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<9>::Pack(in, out);
-}
-
-void __fastpack10(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<10>::Pack(in, out);
-}
-
-void __fastpack11(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<11>::Pack(in, out);
-}
-
-void __fastpack12(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<12>::Pack(in, out);
-}
-
-void __fastpack13(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<13>::Pack(in, out);
-}
-
-void __fastpack14(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<14>::Pack(in, out);
-}
-
-void __fastpack15(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	Unroller16<15>::Pack(in, out);
-}
-
-void __fastpack16(const uint16_t *__restrict in, uint16_t *__restrict out) {
-	for (int k = 0; k < 16; ++k)
-		out[k] = in[k];
-}
-
-
-// fastpack for 32 bits
-
-void __fastpack1(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<1>::Pack(in, out);
-}
-
-void __fastpack2(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<2>::Pack(in, out);
-}
-
-void __fastpack3(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<3>::Pack(in, out);
-}
-
-void __fastpack4(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<4>::Pack(in, out);
-}
-
-void __fastpack5(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<5>::Pack(in, out);
-}
-
-void __fastpack6(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<6>::Pack(in, out);
-}
-
-void __fastpack7(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<7>::Pack(in, out);
-}
-
-void __fastpack8(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<8>::Pack(in, out);
-}
-
-void __fastpack9(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<9>::Pack(in, out);
-}
-
-void __fastpack10(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<10>::Pack(in, out);
-}
-
-void __fastpack11(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<11>::Pack(in, out);
-}
-
-void __fastpack12(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<12>::Pack(in, out);
-}
-
-void __fastpack13(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<13>::Pack(in, out);
-}
-
-void __fastpack14(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<14>::Pack(in, out);
-}
-
-void __fastpack15(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<15>::Pack(in, out);
-}
-
-void __fastpack16(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<16>::Pack(in, out);
-}
-
-void __fastpack17(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<17>::Pack(in, out);
-}
-
-void __fastpack18(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<18>::Pack(in, out);
-}
-
-void __fastpack19(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<19>::Pack(in, out);
-}
-
-void __fastpack20(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<20>::Pack(in, out);
-}
-
-void __fastpack21(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<21>::Pack(in, out);
-}
-
-void __fastpack22(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<22>::Pack(in, out);
-}
-
-void __fastpack23(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<23>::Pack(in, out);
-}
-
-void __fastpack24(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<24>::Pack(in, out);
-}
-
-void __fastpack25(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<25>::Pack(in, out);
-}
-
-void __fastpack26(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<26>::Pack(in, out);
-}
-
-void __fastpack27(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<27>::Pack(in, out);
-}
-
-void __fastpack28(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<28>::Pack(in, out);
-}
-
-void __fastpack29(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<29>::Pack(in, out);
-}
-
-void __fastpack30(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<30>::Pack(in, out);
-}
-
-void __fastpack31(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<31>::Pack(in, out);
-}
-
-void __fastpack32(const uint32_t *__restrict in, uint32_t *__restrict out) {
-	for (int k = 0; k < 32; ++k)
-		out[k] = in[k];
-}
-
-// fastpack for 64 bits
-
-void __fastpack1(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<1>::Pack(in, out);
-}
-
-void __fastpack2(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<2>::Pack(in, out);
-}
-
-void __fastpack3(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<3>::Pack(in, out);
-}
-
-void __fastpack4(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<4>::Pack(in, out);
-}
-
-void __fastpack5(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<5>::Pack(in, out);
-}
-
-void __fastpack6(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<6>::Pack(in, out);
-}
-
-void __fastpack7(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<7>::Pack(in, out);
-}
-
-void __fastpack8(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<8>::Pack(in, out);
-}
-
-void __fastpack9(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<9>::Pack(in, out);
-}
-
-void __fastpack10(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<10>::Pack(in, out);
-}
-
-void __fastpack11(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<11>::Pack(in, out);
-}
-
-void __fastpack12(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<12>::Pack(in, out);
-}
-
-void __fastpack13(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<13>::Pack(in, out);
-}
-
-void __fastpack14(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<14>::Pack(in, out);
-}
-
-void __fastpack15(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<15>::Pack(in, out);
-}
-
-void __fastpack16(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<16>::Pack(in, out);
-}
-
-void __fastpack17(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<17>::Pack(in, out);
-}
-
-void __fastpack18(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<18>::Pack(in, out);
-}
-
-void __fastpack19(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<19>::Pack(in, out);
-}
-
-void __fastpack20(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<20>::Pack(in, out);
-}
-
-void __fastpack21(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<21>::Pack(in, out);
-}
-
-void __fastpack22(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<22>::Pack(in, out);
-}
-
-void __fastpack23(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<23>::Pack(in, out);
-}
-
-void __fastpack24(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<24>::Pack(in, out);
-}
-
-void __fastpack25(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<25>::Pack(in, out);
-}
-
-void __fastpack26(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<26>::Pack(in, out);
-}
-
-void __fastpack27(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<27>::Pack(in, out);
-}
-
-void __fastpack28(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<28>::Pack(in, out);
-}
-
-void __fastpack29(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<29>::Pack(in, out);
-}
-
-void __fastpack30(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<30>::Pack(in, out);
-}
-
-void __fastpack31(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<31>::Pack(in, out);
-}
-
-void __fastpack32(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	for (int k = 0; k < 32; ++k) {
-		out[k] = static_cast<uint32_t>(in[k]);
-	}
-}
-
-void __fastpack33(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<33>::Pack(in, out);
-}
-
-void __fastpack34(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<34>::Pack(in, out);
-}
-
-void __fastpack35(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<35>::Pack(in, out);
-}
-
-void __fastpack36(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<36>::Pack(in, out);
-}
-
-void __fastpack37(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<37>::Pack(in, out);
-}
-
-void __fastpack38(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<38>::Pack(in, out);
-}
-
-void __fastpack39(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<39>::Pack(in, out);
-}
-
-void __fastpack40(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<40>::Pack(in, out);
-}
-
-void __fastpack41(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<41>::Pack(in, out);
-}
-
-void __fastpack42(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<42>::Pack(in, out);
-}
-
-void __fastpack43(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<43>::Pack(in, out);
-}
-
-void __fastpack44(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<44>::Pack(in, out);
-}
-
-void __fastpack45(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<45>::Pack(in, out);
-}
-
-void __fastpack46(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<46>::Pack(in, out);
-}
-
-void __fastpack47(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<47>::Pack(in, out);
-}
-
-void __fastpack48(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<48>::Pack(in, out);
-}
-
-void __fastpack49(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<49>::Pack(in, out);
-}
-
-void __fastpack50(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<50>::Pack(in, out);
-}
-
-void __fastpack51(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<51>::Pack(in, out);
-}
-
-void __fastpack52(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<52>::Pack(in, out);
-}
-
-void __fastpack53(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<53>::Pack(in, out);
-}
-
-void __fastpack54(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<54>::Pack(in, out);
-}
-
-void __fastpack55(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<55>::Pack(in, out);
-}
-
-void __fastpack56(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<56>::Pack(in, out);
-}
-
-void __fastpack57(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<57>::Pack(in, out);
-}
-
-void __fastpack58(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<58>::Pack(in, out);
-}
-
-void __fastpack59(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<59>::Pack(in, out);
-}
-
-void __fastpack60(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<60>::Pack(in, out);
-}
-
-void __fastpack61(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<61>::Pack(in, out);
-}
-
-void __fastpack62(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<62>::Pack(in, out);
-}
-
-void __fastpack63(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	Unroller<63>::Pack(in, out);
-}
-
-void __fastpack64(const uint64_t *__restrict in, uint32_t *__restrict out) {
-	for (int i = 0; i < 32; ++i) {
-		out[2 * i] = static_cast<uint32_t>(in[i]);
-		out[2 * i + 1] = in[i] >> 32;
-	}
-}
-} // namespace internal
-} // namespace duckdb_fastpforlib
-
-
-// LICENSE_CHANGE_END
diff --git a/velox/external/duckdb/duckdb-fastpforlib.hpp b/velox/external/duckdb/duckdb-fastpforlib.hpp
deleted file mode 100644
index 8569cb4368f08..0000000000000
--- a/velox/external/duckdb/duckdb-fastpforlib.hpp
+++ /dev/null
@@ -1,1160 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-// This file was copied from external/duckdb/duckdb-internal.hpp to avoid
-// compilation failure to include that file. This file is for benchmarking use
-// only.
-#include <cinttypes>
-#include <stdexcept>
-
-namespace duckdb_fastpforlib {
-namespace internal {
-
-// Unpacks 8 uint8_t values
-void __fastunpack0(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastunpack1(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastunpack2(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastunpack3(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastunpack4(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastunpack5(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastunpack6(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastunpack7(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastunpack8(const uint8_t* __restrict in, uint8_t* __restrict out);
-
-// Unpacks 16 uint16_t values
-void __fastunpack0(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack1(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack2(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack3(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack4(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack5(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack6(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack7(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack8(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack9(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack10(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack11(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack12(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack13(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack14(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack15(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastunpack16(const uint16_t* __restrict in, uint16_t* __restrict out);
-
-// Unpacks 32 uint32_t values
-void __fastunpack0(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack1(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack2(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack3(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack4(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack5(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack6(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack7(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack8(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack9(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack10(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack11(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack12(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack13(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack14(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack15(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack16(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack17(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack18(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack19(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack20(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack21(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack22(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack23(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack24(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack25(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack26(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack27(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack28(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack29(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack30(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack31(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastunpack32(const uint32_t* __restrict in, uint32_t* __restrict out);
-
-// Unpacks 32 uint64_t values
-void __fastunpack0(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack1(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack2(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack3(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack4(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack5(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack6(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack7(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack8(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack9(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack10(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack11(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack12(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack13(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack14(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack15(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack16(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack17(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack18(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack19(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack20(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack21(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack22(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack23(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack24(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack25(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack26(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack27(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack28(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack29(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack30(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack31(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack32(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack33(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack34(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack35(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack36(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack37(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack38(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack39(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack40(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack41(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack42(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack43(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack44(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack45(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack46(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack47(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack48(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack49(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack50(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack51(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack52(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack53(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack54(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack55(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack56(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack57(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack58(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack59(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack60(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack61(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack62(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack63(const uint32_t* __restrict in, uint64_t* __restrict out);
-void __fastunpack64(const uint32_t* __restrict in, uint64_t* __restrict out);
-
-// Packs 8 int8_t values
-void __fastpack0(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastpack1(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastpack2(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastpack3(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastpack4(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastpack5(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastpack6(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastpack7(const uint8_t* __restrict in, uint8_t* __restrict out);
-void __fastpack8(const uint8_t* __restrict in, uint8_t* __restrict out);
-
-// Packs 16 int16_t values
-void __fastpack0(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack1(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack2(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack3(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack4(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack5(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack6(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack7(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack8(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack9(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack10(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack11(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack12(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack13(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack14(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack15(const uint16_t* __restrict in, uint16_t* __restrict out);
-void __fastpack16(const uint16_t* __restrict in, uint16_t* __restrict out);
-
-// Packs 32 int32_t values
-void __fastpack0(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack1(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack2(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack3(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack4(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack5(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack6(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack7(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack8(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack9(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack10(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack11(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack12(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack13(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack14(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack15(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack16(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack17(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack18(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack19(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack20(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack21(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack22(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack23(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack24(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack25(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack26(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack27(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack28(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack29(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack30(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack31(const uint32_t* __restrict in, uint32_t* __restrict out);
-void __fastpack32(const uint32_t* __restrict in, uint32_t* __restrict out);
-
-// Packs 32 int64_t values
-void __fastpack0(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack1(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack2(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack3(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack4(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack5(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack6(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack7(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack8(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack9(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack10(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack11(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack12(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack13(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack14(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack15(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack16(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack17(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack18(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack19(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack20(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack21(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack22(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack23(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack24(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack25(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack26(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack27(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack28(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack29(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack30(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack31(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack32(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack33(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack34(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack35(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack36(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack37(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack38(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack39(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack40(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack41(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack42(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack43(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack44(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack45(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack46(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack47(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack48(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack49(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack50(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack51(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack52(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack53(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack54(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack55(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack56(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack57(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack58(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack59(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack60(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack61(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack62(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack63(const uint64_t* __restrict in, uint32_t* __restrict out);
-void __fastpack64(const uint64_t* __restrict in, uint32_t* __restrict out);
-
-// Note that this only packs 8 values
-inline void fastunpack_quarter(
-    const uint8_t* __restrict in,
-    uint8_t* __restrict out,
-    const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-    case 0:
-      __fastunpack0(in, out);
-      break;
-    case 1:
-      internal::__fastunpack1(in, out);
-      break;
-    case 2:
-      internal::__fastunpack2(in, out);
-      break;
-    case 3:
-      internal::__fastunpack3(in, out);
-      break;
-    case 4:
-      internal::__fastunpack4(in, out);
-      break;
-    case 5:
-      internal::__fastunpack5(in, out);
-      break;
-    case 6:
-      internal::__fastunpack6(in, out);
-      break;
-    case 7:
-      internal::__fastunpack7(in, out);
-      break;
-    case 8:
-      internal::__fastunpack8(in, out);
-      break;
-    default:
-      throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-// Note that this only packs 8 values
-inline void fastpack_quarter(
-    const uint8_t* __restrict in,
-    uint8_t* __restrict out,
-    const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-    case 0:
-      internal::__fastpack0(in, out);
-      break;
-    case 1:
-      internal::__fastpack1(in, out);
-      break;
-    case 2:
-      internal::__fastpack2(in, out);
-      break;
-    case 3:
-      internal::__fastpack3(in, out);
-      break;
-    case 4:
-      internal::__fastpack4(in, out);
-      break;
-    case 5:
-      internal::__fastpack5(in, out);
-      break;
-    case 6:
-      internal::__fastpack6(in, out);
-      break;
-    case 7:
-      internal::__fastpack7(in, out);
-      break;
-    case 8:
-      internal::__fastpack8(in, out);
-      break;
-    default:
-      throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-// Note that this only packs 16 values
-inline void fastunpack_half(
-    const uint16_t* __restrict in,
-    uint16_t* __restrict out,
-    const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-    case 0:
-      internal::__fastunpack0(in, out);
-      break;
-    case 1:
-      internal::__fastunpack1(in, out);
-      break;
-    case 2:
-      internal::__fastunpack2(in, out);
-      break;
-    case 3:
-      internal::__fastunpack3(in, out);
-      break;
-    case 4:
-      internal::__fastunpack4(in, out);
-      break;
-    case 5:
-      internal::__fastunpack5(in, out);
-      break;
-    case 6:
-      internal::__fastunpack6(in, out);
-      break;
-    case 7:
-      internal::__fastunpack7(in, out);
-      break;
-    case 8:
-      internal::__fastunpack8(in, out);
-      break;
-    case 9:
-      internal::__fastunpack9(in, out);
-      break;
-    case 10:
-      internal::__fastunpack10(in, out);
-      break;
-    case 11:
-      internal::__fastunpack11(in, out);
-      break;
-    case 12:
-      internal::__fastunpack12(in, out);
-      break;
-    case 13:
-      internal::__fastunpack13(in, out);
-      break;
-    case 14:
-      internal::__fastunpack14(in, out);
-      break;
-    case 15:
-      internal::__fastunpack15(in, out);
-      break;
-    case 16:
-      internal::__fastunpack16(in, out);
-      break;
-    default:
-      throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-// Note that this only packs 16 values
-inline void fastpack_half(
-    const uint16_t* __restrict in,
-    uint16_t* __restrict out,
-    const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-    case 0:
-      internal::__fastpack0(in, out);
-      break;
-    case 1:
-      internal::__fastpack1(in, out);
-      break;
-    case 2:
-      internal::__fastpack2(in, out);
-      break;
-    case 3:
-      internal::__fastpack3(in, out);
-      break;
-    case 4:
-      internal::__fastpack4(in, out);
-      break;
-    case 5:
-      internal::__fastpack5(in, out);
-      break;
-    case 6:
-      internal::__fastpack6(in, out);
-      break;
-    case 7:
-      internal::__fastpack7(in, out);
-      break;
-    case 8:
-      internal::__fastpack8(in, out);
-      break;
-    case 9:
-      internal::__fastpack9(in, out);
-      break;
-    case 10:
-      internal::__fastpack10(in, out);
-      break;
-    case 11:
-      internal::__fastpack11(in, out);
-      break;
-    case 12:
-      internal::__fastpack12(in, out);
-      break;
-    case 13:
-      internal::__fastpack13(in, out);
-      break;
-    case 14:
-      internal::__fastpack14(in, out);
-      break;
-    case 15:
-      internal::__fastpack15(in, out);
-      break;
-    case 16:
-      internal::__fastpack16(in, out);
-      break;
-    default:
-      throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-} // namespace internal
-
-inline void fastunpack(
-    const uint8_t* __restrict in,
-    uint8_t* __restrict out,
-    const uint32_t bit) {
-  for (uint8_t i = 0; i < 4; i++) {
-    internal::fastunpack_quarter(in + (i * bit), out + (i * 8), bit);
-  }
-}
-
-inline void fastunpack(
-    const uint16_t* __restrict in,
-    uint16_t* __restrict out,
-    const uint32_t bit) {
-  internal::fastunpack_half(in, out, bit);
-  internal::fastunpack_half(in + bit, out + 16, bit);
-}
-
-inline void fastunpack(
-    const uint32_t* __restrict in,
-    uint32_t* __restrict out,
-    const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-    case 0:
-      internal::__fastunpack0(in, out);
-      break;
-    case 1:
-      internal::__fastunpack1(in, out);
-      break;
-    case 2:
-      internal::__fastunpack2(in, out);
-      break;
-    case 3:
-      internal::__fastunpack3(in, out);
-      break;
-    case 4:
-      internal::__fastunpack4(in, out);
-      break;
-    case 5:
-      internal::__fastunpack5(in, out);
-      break;
-    case 6:
-      internal::__fastunpack6(in, out);
-      break;
-    case 7:
-      internal::__fastunpack7(in, out);
-      break;
-    case 8:
-      internal::__fastunpack8(in, out);
-      break;
-    case 9:
-      internal::__fastunpack9(in, out);
-      break;
-    case 10:
-      internal::__fastunpack10(in, out);
-      break;
-    case 11:
-      internal::__fastunpack11(in, out);
-      break;
-    case 12:
-      internal::__fastunpack12(in, out);
-      break;
-    case 13:
-      internal::__fastunpack13(in, out);
-      break;
-    case 14:
-      internal::__fastunpack14(in, out);
-      break;
-    case 15:
-      internal::__fastunpack15(in, out);
-      break;
-    case 16:
-      internal::__fastunpack16(in, out);
-      break;
-    case 17:
-      internal::__fastunpack17(in, out);
-      break;
-    case 18:
-      internal::__fastunpack18(in, out);
-      break;
-    case 19:
-      internal::__fastunpack19(in, out);
-      break;
-    case 20:
-      internal::__fastunpack20(in, out);
-      break;
-    case 21:
-      internal::__fastunpack21(in, out);
-      break;
-    case 22:
-      internal::__fastunpack22(in, out);
-      break;
-    case 23:
-      internal::__fastunpack23(in, out);
-      break;
-    case 24:
-      internal::__fastunpack24(in, out);
-      break;
-    case 25:
-      internal::__fastunpack25(in, out);
-      break;
-    case 26:
-      internal::__fastunpack26(in, out);
-      break;
-    case 27:
-      internal::__fastunpack27(in, out);
-      break;
-    case 28:
-      internal::__fastunpack28(in, out);
-      break;
-    case 29:
-      internal::__fastunpack29(in, out);
-      break;
-    case 30:
-      internal::__fastunpack30(in, out);
-      break;
-    case 31:
-      internal::__fastunpack31(in, out);
-      break;
-    case 32:
-      internal::__fastunpack32(in, out);
-      break;
-    default:
-      throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-inline void fastunpack(
-    const uint32_t* __restrict in,
-    uint64_t* __restrict out,
-    const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-    case 0:
-      internal::__fastunpack0(in, out);
-      break;
-    case 1:
-      internal::__fastunpack1(in, out);
-      break;
-    case 2:
-      internal::__fastunpack2(in, out);
-      break;
-    case 3:
-      internal::__fastunpack3(in, out);
-      break;
-    case 4:
-      internal::__fastunpack4(in, out);
-      break;
-    case 5:
-      internal::__fastunpack5(in, out);
-      break;
-    case 6:
-      internal::__fastunpack6(in, out);
-      break;
-    case 7:
-      internal::__fastunpack7(in, out);
-      break;
-    case 8:
-      internal::__fastunpack8(in, out);
-      break;
-    case 9:
-      internal::__fastunpack9(in, out);
-      break;
-    case 10:
-      internal::__fastunpack10(in, out);
-      break;
-    case 11:
-      internal::__fastunpack11(in, out);
-      break;
-    case 12:
-      internal::__fastunpack12(in, out);
-      break;
-    case 13:
-      internal::__fastunpack13(in, out);
-      break;
-    case 14:
-      internal::__fastunpack14(in, out);
-      break;
-    case 15:
-      internal::__fastunpack15(in, out);
-      break;
-    case 16:
-      internal::__fastunpack16(in, out);
-      break;
-    case 17:
-      internal::__fastunpack17(in, out);
-      break;
-    case 18:
-      internal::__fastunpack18(in, out);
-      break;
-    case 19:
-      internal::__fastunpack19(in, out);
-      break;
-    case 20:
-      internal::__fastunpack20(in, out);
-      break;
-    case 21:
-      internal::__fastunpack21(in, out);
-      break;
-    case 22:
-      internal::__fastunpack22(in, out);
-      break;
-    case 23:
-      internal::__fastunpack23(in, out);
-      break;
-    case 24:
-      internal::__fastunpack24(in, out);
-      break;
-    case 25:
-      internal::__fastunpack25(in, out);
-      break;
-    case 26:
-      internal::__fastunpack26(in, out);
-      break;
-    case 27:
-      internal::__fastunpack27(in, out);
-      break;
-    case 28:
-      internal::__fastunpack28(in, out);
-      break;
-    case 29:
-      internal::__fastunpack29(in, out);
-      break;
-    case 30:
-      internal::__fastunpack30(in, out);
-      break;
-    case 31:
-      internal::__fastunpack31(in, out);
-      break;
-    case 32:
-      internal::__fastunpack32(in, out);
-      break;
-    case 33:
-      internal::__fastunpack33(in, out);
-      break;
-    case 34:
-      internal::__fastunpack34(in, out);
-      break;
-    case 35:
-      internal::__fastunpack35(in, out);
-      break;
-    case 36:
-      internal::__fastunpack36(in, out);
-      break;
-    case 37:
-      internal::__fastunpack37(in, out);
-      break;
-    case 38:
-      internal::__fastunpack38(in, out);
-      break;
-    case 39:
-      internal::__fastunpack39(in, out);
-      break;
-    case 40:
-      internal::__fastunpack40(in, out);
-      break;
-    case 41:
-      internal::__fastunpack41(in, out);
-      break;
-    case 42:
-      internal::__fastunpack42(in, out);
-      break;
-    case 43:
-      internal::__fastunpack43(in, out);
-      break;
-    case 44:
-      internal::__fastunpack44(in, out);
-      break;
-    case 45:
-      internal::__fastunpack45(in, out);
-      break;
-    case 46:
-      internal::__fastunpack46(in, out);
-      break;
-    case 47:
-      internal::__fastunpack47(in, out);
-      break;
-    case 48:
-      internal::__fastunpack48(in, out);
-      break;
-    case 49:
-      internal::__fastunpack49(in, out);
-      break;
-    case 50:
-      internal::__fastunpack50(in, out);
-      break;
-    case 51:
-      internal::__fastunpack51(in, out);
-      break;
-    case 52:
-      internal::__fastunpack52(in, out);
-      break;
-    case 53:
-      internal::__fastunpack53(in, out);
-      break;
-    case 54:
-      internal::__fastunpack54(in, out);
-      break;
-    case 55:
-      internal::__fastunpack55(in, out);
-      break;
-    case 56:
-      internal::__fastunpack56(in, out);
-      break;
-    case 57:
-      internal::__fastunpack57(in, out);
-      break;
-    case 58:
-      internal::__fastunpack58(in, out);
-      break;
-    case 59:
-      internal::__fastunpack59(in, out);
-      break;
-    case 60:
-      internal::__fastunpack60(in, out);
-      break;
-    case 61:
-      internal::__fastunpack61(in, out);
-      break;
-    case 62:
-      internal::__fastunpack62(in, out);
-      break;
-    case 63:
-      internal::__fastunpack63(in, out);
-      break;
-    case 64:
-      internal::__fastunpack64(in, out);
-      break;
-    default:
-      throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-inline void fastpack(
-    const uint8_t* __restrict in,
-    uint8_t* __restrict out,
-    const uint32_t bit) {
-  for (uint8_t i = 0; i < 4; i++) {
-    internal::fastpack_quarter(in + (i * 8), out + (i * bit), bit);
-  }
-}
-
-inline void fastpack(
-    const uint16_t* __restrict in,
-    uint16_t* __restrict out,
-    const uint32_t bit) {
-  internal::fastpack_half(in, out, bit);
-  internal::fastpack_half(in + 16, out + bit, bit);
-}
-
-inline void fastpack(
-    const uint32_t* __restrict in,
-    uint32_t* __restrict out,
-    const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-    case 0:
-      internal::__fastpack0(in, out);
-      break;
-    case 1:
-      internal::__fastpack1(in, out);
-      break;
-    case 2:
-      internal::__fastpack2(in, out);
-      break;
-    case 3:
-      internal::__fastpack3(in, out);
-      break;
-    case 4:
-      internal::__fastpack4(in, out);
-      break;
-    case 5:
-      internal::__fastpack5(in, out);
-      break;
-    case 6:
-      internal::__fastpack6(in, out);
-      break;
-    case 7:
-      internal::__fastpack7(in, out);
-      break;
-    case 8:
-      internal::__fastpack8(in, out);
-      break;
-    case 9:
-      internal::__fastpack9(in, out);
-      break;
-    case 10:
-      internal::__fastpack10(in, out);
-      break;
-    case 11:
-      internal::__fastpack11(in, out);
-      break;
-    case 12:
-      internal::__fastpack12(in, out);
-      break;
-    case 13:
-      internal::__fastpack13(in, out);
-      break;
-    case 14:
-      internal::__fastpack14(in, out);
-      break;
-    case 15:
-      internal::__fastpack15(in, out);
-      break;
-    case 16:
-      internal::__fastpack16(in, out);
-      break;
-    case 17:
-      internal::__fastpack17(in, out);
-      break;
-    case 18:
-      internal::__fastpack18(in, out);
-      break;
-    case 19:
-      internal::__fastpack19(in, out);
-      break;
-    case 20:
-      internal::__fastpack20(in, out);
-      break;
-    case 21:
-      internal::__fastpack21(in, out);
-      break;
-    case 22:
-      internal::__fastpack22(in, out);
-      break;
-    case 23:
-      internal::__fastpack23(in, out);
-      break;
-    case 24:
-      internal::__fastpack24(in, out);
-      break;
-    case 25:
-      internal::__fastpack25(in, out);
-      break;
-    case 26:
-      internal::__fastpack26(in, out);
-      break;
-    case 27:
-      internal::__fastpack27(in, out);
-      break;
-    case 28:
-      internal::__fastpack28(in, out);
-      break;
-    case 29:
-      internal::__fastpack29(in, out);
-      break;
-    case 30:
-      internal::__fastpack30(in, out);
-      break;
-    case 31:
-      internal::__fastpack31(in, out);
-      break;
-    case 32:
-      internal::__fastpack32(in, out);
-      break;
-    default:
-      throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-inline void fastpack(
-    const uint64_t* __restrict in,
-    uint32_t* __restrict out,
-    const uint32_t bit) {
-  switch (bit) {
-    case 0:
-      internal::__fastpack0(in, out);
-      break;
-    case 1:
-      internal::__fastpack1(in, out);
-      break;
-    case 2:
-      internal::__fastpack2(in, out);
-      break;
-    case 3:
-      internal::__fastpack3(in, out);
-      break;
-    case 4:
-      internal::__fastpack4(in, out);
-      break;
-    case 5:
-      internal::__fastpack5(in, out);
-      break;
-    case 6:
-      internal::__fastpack6(in, out);
-      break;
-    case 7:
-      internal::__fastpack7(in, out);
-      break;
-    case 8:
-      internal::__fastpack8(in, out);
-      break;
-    case 9:
-      internal::__fastpack9(in, out);
-      break;
-    case 10:
-      internal::__fastpack10(in, out);
-      break;
-    case 11:
-      internal::__fastpack11(in, out);
-      break;
-    case 12:
-      internal::__fastpack12(in, out);
-      break;
-    case 13:
-      internal::__fastpack13(in, out);
-      break;
-    case 14:
-      internal::__fastpack14(in, out);
-      break;
-    case 15:
-      internal::__fastpack15(in, out);
-      break;
-    case 16:
-      internal::__fastpack16(in, out);
-      break;
-    case 17:
-      internal::__fastpack17(in, out);
-      break;
-    case 18:
-      internal::__fastpack18(in, out);
-      break;
-    case 19:
-      internal::__fastpack19(in, out);
-      break;
-    case 20:
-      internal::__fastpack20(in, out);
-      break;
-    case 21:
-      internal::__fastpack21(in, out);
-      break;
-    case 22:
-      internal::__fastpack22(in, out);
-      break;
-    case 23:
-      internal::__fastpack23(in, out);
-      break;
-    case 24:
-      internal::__fastpack24(in, out);
-      break;
-    case 25:
-      internal::__fastpack25(in, out);
-      break;
-    case 26:
-      internal::__fastpack26(in, out);
-      break;
-    case 27:
-      internal::__fastpack27(in, out);
-      break;
-    case 28:
-      internal::__fastpack28(in, out);
-      break;
-    case 29:
-      internal::__fastpack29(in, out);
-      break;
-    case 30:
-      internal::__fastpack30(in, out);
-      break;
-    case 31:
-      internal::__fastpack31(in, out);
-      break;
-    case 32:
-      internal::__fastpack32(in, out);
-      break;
-    case 33:
-      internal::__fastpack33(in, out);
-      break;
-    case 34:
-      internal::__fastpack34(in, out);
-      break;
-    case 35:
-      internal::__fastpack35(in, out);
-      break;
-    case 36:
-      internal::__fastpack36(in, out);
-      break;
-    case 37:
-      internal::__fastpack37(in, out);
-      break;
-    case 38:
-      internal::__fastpack38(in, out);
-      break;
-    case 39:
-      internal::__fastpack39(in, out);
-      break;
-    case 40:
-      internal::__fastpack40(in, out);
-      break;
-    case 41:
-      internal::__fastpack41(in, out);
-      break;
-    case 42:
-      internal::__fastpack42(in, out);
-      break;
-    case 43:
-      internal::__fastpack43(in, out);
-      break;
-    case 44:
-      internal::__fastpack44(in, out);
-      break;
-    case 45:
-      internal::__fastpack45(in, out);
-      break;
-    case 46:
-      internal::__fastpack46(in, out);
-      break;
-    case 47:
-      internal::__fastpack47(in, out);
-      break;
-    case 48:
-      internal::__fastpack48(in, out);
-      break;
-    case 49:
-      internal::__fastpack49(in, out);
-      break;
-    case 50:
-      internal::__fastpack50(in, out);
-      break;
-    case 51:
-      internal::__fastpack51(in, out);
-      break;
-    case 52:
-      internal::__fastpack52(in, out);
-      break;
-    case 53:
-      internal::__fastpack53(in, out);
-      break;
-    case 54:
-      internal::__fastpack54(in, out);
-      break;
-    case 55:
-      internal::__fastpack55(in, out);
-      break;
-    case 56:
-      internal::__fastpack56(in, out);
-      break;
-    case 57:
-      internal::__fastpack57(in, out);
-      break;
-    case 58:
-      internal::__fastpack58(in, out);
-      break;
-    case 59:
-      internal::__fastpack59(in, out);
-      break;
-    case 60:
-      internal::__fastpack60(in, out);
-      break;
-    case 61:
-      internal::__fastpack61(in, out);
-      break;
-    case 62:
-      internal::__fastpack62(in, out);
-      break;
-    case 63:
-      internal::__fastpack63(in, out);
-      break;
-    case 64:
-      internal::__fastpack64(in, out);
-      break;
-    default:
-      throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-} // namespace duckdb_fastpforlib::internal
diff --git a/velox/external/duckdb/duckdb-fmt.cpp b/velox/external/duckdb/duckdb-fmt.cpp
deleted file mode 100644
index 6a26beb497e35..0000000000000
--- a/velox/external/duckdb/duckdb-fmt.cpp
+++ /dev/null
@@ -1,1417 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
-// See the end of this file for a list
-
-// Formatting library for C++
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
-// See the end of this file for a list
-
-// Formatting library for C++ - implementation
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_FORMAT_INL_H_
-#define FMT_FORMAT_INL_H_
-
-
-
-#include <cassert>
-#include <cctype>
-#include <climits>
-#include <cmath>
-#include <cstdarg>
-#include <cstring>  // for std::memmove
-#include <cwchar>
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-#  include <locale>
-#endif
-
-#if FMT_EXCEPTIONS
-#  define FMT_TRY try
-#  define FMT_CATCH(x) catch (x)
-#else
-#  define FMT_TRY if (true)
-#  define FMT_CATCH(x) if (false)
-#endif
-
-#ifdef _MSC_VER
-#  pragma warning(push)
-#  pragma warning(disable : 4702)  // unreachable code
-#endif
-
-// Dummy implementations of strerror_r and strerror_s called if corresponding
-// system functions are not available.
-inline duckdb_fmt::internal::null<> strerror_r(int, char*, ...) { return {}; }
-inline duckdb_fmt::internal::null<> strerror_s(char*, std::size_t, ...) { return {}; }
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-#ifndef _MSC_VER
-#  define FMT_SNPRINTF snprintf
-#else  // _MSC_VER
-inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
-  va_end(args);
-  return result;
-}
-#  define FMT_SNPRINTF fmt_snprintf
-#endif  // _MSC_VER
-
-using format_func = void (*)(internal::buffer<char>&, int, string_view);
-
-// A portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-//   0      - success
-//   ERANGE - buffer is not large enough to store the error message
-//   other  - failure
-// Buffer should be at least of size 1.
-FMT_FUNC int safe_strerror(int error_code, char*& buffer,
-                           std::size_t buffer_size) FMT_NOEXCEPT {
-  FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
-
-  class dispatcher {
-   private:
-    int error_code_;
-    char*& buffer_;
-    std::size_t buffer_size_;
-
-    // A noop assignment operator to avoid bogus warnings.
-    void operator=(const dispatcher&) {}
-
-    // Handle the result of XSI-compliant version of strerror_r.
-    int handle(int result) {
-      // glibc versions before 2.13 return result in errno.
-      return result == -1 ? errno : result;
-    }
-
-    // Handle the result of GNU-specific version of strerror_r.
-    int handle(char* message) {
-      // If the buffer is full then the message is probably truncated.
-      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
-        return ERANGE;
-      buffer_ = message;
-      return 0;
-    }
-
-    // Handle the case when strerror_r is not available.
-    int handle(internal::null<>) {
-      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
-    }
-
-    // Fallback to strerror_s when strerror_r is not available.
-    int fallback(int result) {
-      // If the buffer is full then the message is probably truncated.
-      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
-                                                                : result;
-    }
-
-#if !FMT_MSC_VER
-    // Fallback to strerror if strerror_r and strerror_s are not available.
-    int fallback(internal::null<>) {
-      errno = 0;
-      buffer_ = strerror(error_code_);
-      return errno;
-    }
-#endif
-
-   public:
-    dispatcher(int err_code, char*& buf, std::size_t buf_size)
-        : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-
-    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
-  };
-  return dispatcher(error_code, buffer, buffer_size).run();
-}
-
-FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_code,
-                                string_view message) FMT_NOEXCEPT {
-  // Report error code making sure that the output fits into
-  // inline_buffer_size to avoid dynamic memory allocation and potential
-  // bad_alloc.
-  out.resize(0);
-  static const char SEP[] = ": ";
-  static const char ERROR_STR[] = "error ";
-  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
-  if (internal::is_negative(error_code)) {
-    abs_value = 0 - abs_value;
-    ++error_code_size;
-  }
-  error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
-  internal::writer w(out);
-  if (message.size() <= inline_buffer_size - error_code_size) {
-    w.write(message);
-    w.write(SEP);
-  }
-  w.write(ERROR_STR);
-  w.write(error_code);
-  assert(out.size() <= inline_buffer_size);
-}
-
-FMT_FUNC void report_error(format_func func, int error_code,
-                           string_view message) FMT_NOEXCEPT {
-  memory_buffer full_message;
-  func(full_message, error_code, message);
-  /*// R does not allow us to have a reference to stderr even if we are not using it
-  // Don't use fwrite_fully because the latter may throw.
-  (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
-  std::fputc('\n', stderr);
-  */
-}
-}  // namespace internal
-
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-namespace internal {
-
-template <typename Locale>
-locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-}
-
-template <typename Locale> Locale locale_ref::get() const {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
-}
-
-template <typename Char> FMT_FUNC std::string grouping_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).grouping();
-}
-template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .thousands_sep();
-}
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .decimal_point();
-}
-}  // namespace internal
-#else
-template <typename Char>
-FMT_FUNC std::string internal::grouping_impl(locale_ref) {
-  return "\03";
-}
-template <typename Char>
-FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
-  return FMT_STATIC_THOUSANDS_SEPARATOR;
-}
-template <typename Char>
-FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
-  return '.';
-}
-#endif
-
-namespace internal {
-
-template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) {
-  // fallback_uintptr is always stored in little endian.
-  int i = static_cast<int>(sizeof(void*)) - 1;
-  while (i > 0 && n.value[i] == 0) --i;
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
-}
-
-template <typename T>
-const char basic_data<T>::digits[] =
-    "0001020304050607080910111213141516171819"
-    "2021222324252627282930313233343536373839"
-    "4041424344454647484950515253545556575859"
-    "6061626364656667686970717273747576777879"
-    "8081828384858687888990919293949596979899";
-
-template <typename T>
-const char basic_data<T>::hex_digits[] = "0123456789abcdef";
-
-#define FMT_POWERS_OF_10(factor)                                             \
-  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
-      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
-      (factor)*1000000000
-
-template <typename T>
-const uint64_t basic_data<T>::powers_of_10_64[] = {
-    1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
-    10000000000000000000ULL};
-
-template <typename T>
-const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
-                                                           FMT_POWERS_OF_10(1)};
-
-template <typename T>
-const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
-    0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
-    10000000000000000000ULL};
-
-// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
-// These are generated by support/compute-powers.py.
-template <typename T>
-const uint64_t basic_data<T>::pow10_significands[] = {
-    0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
-    0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
-    0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
-    0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-    0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
-    0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
-    0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
-    0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-    0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
-    0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
-    0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
-    0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-    0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
-    0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
-    0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
-    0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-    0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
-    0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
-    0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
-    0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
-    0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
-    0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
-    0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
-    0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
-    0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
-    0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
-    0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
-    0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
-    0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
-};
-
-// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
-// to significands above.
-template <typename T>
-const int16_t basic_data<T>::pow10_exponents[] = {
-    -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
-    -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
-    -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
-    -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
-    -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
-    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
-    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
-    827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
-
-template <typename T>
-const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
-template <typename T>
-const char basic_data<T>::background_color[] = "\x1b[48;2;";
-template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
-template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
-template <typename T> const char basic_data<T>::signs[] = {0, '-', '+', ' '};
-
-template <typename T> struct bits {
-  static FMT_CONSTEXPR_DECL const int value =
-      static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
-};
-
-class fp;
-template <int SHIFT = 0> fp normalize(fp value);
-
-// Lower (upper) boundary is a value half way between a floating-point value
-// and its predecessor (successor). Boundaries have the same exponent as the
-// value so only significands are stored.
-struct boundaries {
-  uint64_t lower;
-  uint64_t upper;
-};
-
-// A handmade floating-point number f * pow(2, e).
-class fp {
- private:
-  using significand_type = uint64_t;
-
-  // All sizes are in bits.
-  // Subtract 1 to account for an implicit most significant bit in the
-  // normalized form.
-  static FMT_CONSTEXPR_DECL const int double_significand_size =
-      std::numeric_limits<double>::digits - 1;
-  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
-      1ULL << double_significand_size;
-
- public:
-  significand_type f;
-  int e;
-
-  static FMT_CONSTEXPR_DECL const int significand_size =
-      bits<significand_type>::value;
-
-  fp() : f(0), e(0) {}
-  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
-
-  // Constructs fp from an IEEE754 double. It is a template to prevent compile
-  // errors on platforms where double is not IEEE754.
-  template <typename Double> explicit fp(Double d) { assign(d); }
-
-  // Normalizes the value converted from double and multiplied by (1 << SHIFT).
-  template <int SHIFT> friend fp normalize(fp value) {
-    // Handle subnormals.
-    const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
-    while ((value.f & shifted_implicit_bit) == 0) {
-      value.f <<= 1;
-      --value.e;
-    }
-    // Subtract 1 to account for hidden bit.
-    const auto offset =
-        fp::significand_size - fp::double_significand_size - SHIFT - 1;
-    value.f <<= offset;
-    value.e -= offset;
-    return value;
-  }
-
-  // Assigns d to this and return true iff predecessor is closer than successor.
-  template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
-  bool assign(Double d) {
-    // Assume double is in the format [sign][exponent][significand].
-    using limits = std::numeric_limits<Double>;
-    const int exponent_size =
-        bits<Double>::value - double_significand_size - 1;  // -1 for sign
-    const uint64_t significand_mask = implicit_bit - 1;
-    const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
-    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
-    auto u = bit_cast<uint64_t>(d);
-    f = u & significand_mask;
-    auto biased_e = (u & exponent_mask) >> double_significand_size;
-    // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
-    // the smallest normalized number (biased_e > 1).
-    bool is_predecessor_closer = f == 0 && biased_e > 1;
-    if (biased_e != 0)
-      f += implicit_bit;
-    else
-      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
-    return is_predecessor_closer;
-  }
-
-  template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
-  bool assign(Double) {
-    *this = fp();
-    return false;
-  }
-
-  // Assigns d to this together with computing lower and upper boundaries,
-  // where a boundary is a value half way between the number and its predecessor
-  // (lower) or successor (upper). The upper boundary is normalized and lower
-  // has the same exponent but may be not normalized.
-  template <typename Double> boundaries assign_with_boundaries(Double d) {
-    bool is_lower_closer = assign(d);
-    fp lower =
-        is_lower_closer ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
-    // 1 in normalize accounts for the exponent shift above.
-    fp upper = normalize<1>(fp((f << 1) + 1, e - 1));
-    lower.f <<= lower.e - upper.e;
-    return boundaries{lower.f, upper.f};
-  }
-
-  template <typename Double> boundaries assign_float_with_boundaries(Double d) {
-    assign(d);
-    constexpr int min_normal_e = std::numeric_limits<float>::min_exponent -
-                                 std::numeric_limits<double>::digits;
-    significand_type half_ulp = 1 << (std::numeric_limits<double>::digits -
-                                      std::numeric_limits<float>::digits - 1);
-    if (min_normal_e > e) half_ulp <<= min_normal_e - e;
-    fp upper = normalize<0>(fp(f + half_ulp, e));
-    fp lower = fp(
-        f - (half_ulp >> ((f == implicit_bit && e > min_normal_e) ? 1 : 0)), e);
-    lower.f <<= lower.e - upper.e;
-    return boundaries{lower.f, upper.f};
-  }
-};
-
-inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
-
-// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
-inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
-#if FMT_USE_INT128
-  auto product = static_cast<__uint128_t>(lhs) * rhs;
-  auto f = static_cast<uint64_t>(product >> 64);
-  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
-#else
-  // Multiply 32-bit parts of significands.
-  uint64_t mask = (1ULL << 32) - 1;
-  uint64_t a = lhs >> 32, b = lhs & mask;
-  uint64_t c = rhs >> 32, d = rhs & mask;
-  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
-  // Compute mid 64-bit of result and round.
-  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
-  return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
-#endif
-}
-
-inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }
-
-// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
-// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
-FMT_FUNC fp get_cached_power(int min_exponent, int& pow10_exponent) {
-  const uint64_t one_over_log2_10 = 0x4d104d42;  // round(pow(2, 32) / log2(10))
-  int index = static_cast<int>(
-      static_cast<int64_t>(
-          (min_exponent + fp::significand_size - 1) * one_over_log2_10 +
-          ((uint64_t(1) << 32) - 1)  // ceil
-          ) >>
-      32  // arithmetic shift
-  );
-  // Decimal exponent of the first (smallest) cached power of 10.
-  const int first_dec_exp = -348;
-  // Difference between 2 consecutive decimal exponents in cached powers of 10.
-  const int dec_exp_step = 8;
-  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
-  pow10_exponent = first_dec_exp + index * dec_exp_step;
-  return {data::pow10_significands[index], data::pow10_exponents[index]};
-}
-
-// A simple accumulator to hold the sums of terms in bigint::square if uint128_t
-// is not available.
-struct accumulator {
-  uint64_t lower;
-  uint64_t upper;
-
-  accumulator() : lower(0), upper(0) {}
-  explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }
-
-  void operator+=(uint64_t n) {
-    lower += n;
-    if (lower < n) ++upper;
-  }
-  void operator>>=(int shift) {
-    assert(shift == 32);
-    (void)shift;
-    lower = (upper << 32) | (lower >> 32);
-    upper >>= 32;
-  }
-};
-
-class bigint {
- private:
-  // A bigint is stored as an array of bigits (big digits), with bigit at index
-  // 0 being the least significant one.
-  using bigit = uint32_t;
-  using double_bigit = uint64_t;
-  enum { bigits_capacity = 32 };
-  basic_memory_buffer<bigit, bigits_capacity> bigits_;
-  int exp_;
-
-  static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
-
-  friend struct formatter<bigint>;
-
-  void subtract_bigits(int index, bigit other, bigit& borrow) {
-    auto result = static_cast<double_bigit>(bigits_[index]) - other - borrow;
-    bigits_[index] = static_cast<bigit>(result);
-    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
-  }
-
-  void remove_leading_zeros() {
-    int num_bigits = static_cast<int>(bigits_.size()) - 1;
-    while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits;
-    bigits_.resize(num_bigits + 1);
-  }
-
-  // Computes *this -= other assuming aligned bigints and *this >= other.
-  void subtract_aligned(const bigint& other) {
-    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
-    FMT_ASSERT(compare(*this, other) >= 0, "");
-    bigit borrow = 0;
-    int i = other.exp_ - exp_;
-    for (int j = 0, n = static_cast<int>(other.bigits_.size()); j != n;
-         ++i, ++j) {
-      subtract_bigits(i, other.bigits_[j], borrow);
-    }
-    while (borrow > 0) subtract_bigits(i, 0, borrow);
-    remove_leading_zeros();
-  }
-
-  void multiply(uint32_t value) {
-    const double_bigit wide_value = value;
-    bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      double_bigit result = bigits_[i] * wide_value + carry;
-      bigits_[i] = static_cast<bigit>(result);
-      carry = static_cast<bigit>(result >> bigit_bits);
-    }
-    if (carry != 0) bigits_.push_back(carry);
-  }
-
-  void multiply(uint64_t value) {
-    const bigit mask = ~bigit(0);
-    const double_bigit lower = value & mask;
-    const double_bigit upper = value >> bigit_bits;
-    double_bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      double_bigit result = bigits_[i] * lower + (carry & mask);
-      carry =
-          bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
-      bigits_[i] = static_cast<bigit>(result);
-    }
-    while (carry != 0) {
-      bigits_.push_back(carry & mask);
-      carry >>= bigit_bits;
-    }
-  }
-
- public:
-  bigint() : exp_(0) {}
-  explicit bigint(uint64_t n) { assign(n); }
-  ~bigint() { assert(bigits_.capacity() <= bigits_capacity); }
-
-  bigint(const bigint&) = delete;
-  void operator=(const bigint&) = delete;
-
-  void assign(const bigint& other) {
-    bigits_.resize(other.bigits_.size());
-    auto data = other.bigits_.data();
-    std::copy(data, data + other.bigits_.size(), bigits_.data());
-    exp_ = other.exp_;
-  }
-
-  void assign(uint64_t n) {
-    int num_bigits = 0;
-    do {
-      bigits_[num_bigits++] = n & ~bigit(0);
-      n >>= bigit_bits;
-    } while (n != 0);
-    bigits_.resize(num_bigits);
-    exp_ = 0;
-  }
-
-  int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }
-
-  bigint& operator<<=(int shift) {
-    assert(shift >= 0);
-    exp_ += shift / bigit_bits;
-    shift %= bigit_bits;
-    if (shift == 0) return *this;
-    bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      bigit c = bigits_[i] >> (bigit_bits - shift);
-      bigits_[i] = (bigits_[i] << shift) + carry;
-      carry = c;
-    }
-    if (carry != 0) bigits_.push_back(carry);
-    return *this;
-  }
-
-  template <typename Int> bigint& operator*=(Int value) {
-    FMT_ASSERT(value > 0, "");
-    multiply(uint32_or_64_or_128_t<Int>(value));
-    return *this;
-  }
-
-  friend int compare(const bigint& lhs, const bigint& rhs) {
-    int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
-    if (num_lhs_bigits != num_rhs_bigits)
-      return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
-    int i = static_cast<int>(lhs.bigits_.size()) - 1;
-    int j = static_cast<int>(rhs.bigits_.size()) - 1;
-    int end = i - j;
-    if (end < 0) end = 0;
-    for (; i >= end; --i, --j) {
-      bigit lhs_bigit = lhs.bigits_[i], rhs_bigit = rhs.bigits_[j];
-      if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
-    }
-    if (i != j) return i > j ? 1 : -1;
-    return 0;
-  }
-
-  // Returns compare(lhs1 + lhs2, rhs).
-  friend int add_compare(const bigint& lhs1, const bigint& lhs2,
-                         const bigint& rhs) {
-    int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
-    int num_rhs_bigits = rhs.num_bigits();
-    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
-    if (max_lhs_bigits > num_rhs_bigits) return 1;
-    auto get_bigit = [](const bigint& n, int i) -> bigit {
-      return i >= n.exp_ && i < n.num_bigits() ? n.bigits_[i - n.exp_] : 0;
-    };
-    double_bigit borrow = 0;
-    int min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
-    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
-      double_bigit sum =
-          static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
-      bigit rhs_bigit = get_bigit(rhs, i);
-      if (sum > rhs_bigit + borrow) return 1;
-      borrow = rhs_bigit + borrow - sum;
-      if (borrow > 1) return -1;
-      borrow <<= bigit_bits;
-    }
-    return borrow != 0 ? -1 : 0;
-  }
-
-  // Assigns pow(10, exp) to this bigint.
-  void assign_pow10(int exp) {
-    assert(exp >= 0);
-    if (exp == 0) return assign(1);
-    // Find the top bit.
-    int bitmask = 1;
-    while (exp >= bitmask) bitmask <<= 1;
-    bitmask >>= 1;
-    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
-    // repeated squaring and multiplication.
-    assign(5);
-    bitmask >>= 1;
-    while (bitmask != 0) {
-      square();
-      if ((exp & bitmask) != 0) *this *= 5;
-      bitmask >>= 1;
-    }
-    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
-  }
-
-  void square() {
-    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
-    int num_bigits = static_cast<int>(bigits_.size());
-    int num_result_bigits = 2 * num_bigits;
-    bigits_.resize(num_result_bigits);
-    using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
-    auto sum = accumulator_t();
-    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
-      // Compute bigit at position bigit_index of the result by adding
-      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
-      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
-        // Most terms are multiplied twice which can be optimized in the future.
-        sum += static_cast<double_bigit>(n[i]) * n[j];
-      }
-      bigits_[bigit_index] = static_cast<bigit>(sum);
-      sum >>= bits<bigit>::value;  // Compute the carry.
-    }
-    // Do the same for the top half.
-    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
-         ++bigit_index) {
-      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
-        sum += static_cast<double_bigit>(n[i++]) * n[j--];
-      bigits_[bigit_index] = static_cast<bigit>(sum);
-      sum >>= bits<bigit>::value;
-    }
-    --num_result_bigits;
-    remove_leading_zeros();
-    exp_ *= 2;
-  }
-
-  // Divides this bignum by divisor, assigning the remainder to this and
-  // returning the quotient.
-  int divmod_assign(const bigint& divisor) {
-    FMT_ASSERT(this != &divisor, "");
-    if (compare(*this, divisor) < 0) return 0;
-    int num_bigits = static_cast<int>(bigits_.size());
-    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1] != 0, "");
-    int exp_difference = exp_ - divisor.exp_;
-    if (exp_difference > 0) {
-      // Align bigints by adding trailing zeros to simplify subtraction.
-      bigits_.resize(num_bigits + exp_difference);
-      for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
-        bigits_[j] = bigits_[i];
-      std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
-      exp_ -= exp_difference;
-    }
-    int quotient = 0;
-    do {
-      subtract_aligned(divisor);
-      ++quotient;
-    } while (compare(*this, divisor) >= 0);
-    return quotient;
-  }
-};
-
-enum round_direction { unknown, up, down };
-
-// Given the divisor (normally a power of 10), the remainder = v % divisor for
-// some number v and the error, returns whether v should be rounded up, down, or
-// whether the rounding direction can't be determined due to error.
-// error should be less than divisor / 2.
-inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
-                                           uint64_t error) {
-  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
-  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
-  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
-  // Round down if (remainder + error) * 2 <= divisor.
-  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
-    return down;
-  // Round up if (remainder - error) * 2 >= divisor.
-  if (remainder >= error &&
-      remainder - error >= divisor - (remainder - error)) {
-    return up;
-  }
-  return unknown;
-}
-
-namespace digits {
-enum result {
-  more,  // Generate more digits.
-  done,  // Done generating digits.
-  error  // Digit generation cancelled due to an error.
-};
-}
-
-// Generates output using the Grisu digit-gen algorithm.
-// error: the size of the region (lower, upper) outside of which numbers
-// definitely do not round to value (Delta in Grisu3).
-template <typename Handler>
-FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
-                                                  int& exp, Handler& handler) {
-  const fp one(1ULL << -value.e, value.e);
-  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
-  // zero because it contains a product of two 64-bit numbers with MSB set (due
-  // to normalization) - 1, shifted right by at most 60 bits.
-  auto integral = static_cast<uint32_t>(value.f >> -one.e);
-  FMT_ASSERT(integral != 0, "");
-  FMT_ASSERT(integral == value.f >> -one.e, "");
-  // The fractional part of scaled value (p2 in Grisu) c = value % one.
-  uint64_t fractional = value.f & (one.f - 1);
-  exp = count_digits(integral);  // kappa in Grisu.
-  // Divide by 10 to prevent overflow.
-  auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,
-                                 value.f / 10, error * 10, exp);
-  if (result != digits::more) return result;
-  // Generate digits for the integral part. This can produce up to 10 digits.
-  do {
-    uint32_t digit = 0;
-    auto divmod_integral = [&](uint32_t divisor) {
-      digit = integral / divisor;
-      integral %= divisor;
-    };
-    // This optimization by Milo Yip reduces the number of integer divisions by
-    // one per iteration.
-    switch (exp) {
-    case 10:
-      divmod_integral(1000000000);
-      break;
-    case 9:
-      divmod_integral(100000000);
-      break;
-    case 8:
-      divmod_integral(10000000);
-      break;
-    case 7:
-      divmod_integral(1000000);
-      break;
-    case 6:
-      divmod_integral(100000);
-      break;
-    case 5:
-      divmod_integral(10000);
-      break;
-    case 4:
-      divmod_integral(1000);
-      break;
-    case 3:
-      divmod_integral(100);
-      break;
-    case 2:
-      divmod_integral(10);
-      break;
-    case 1:
-      digit = integral;
-      integral = 0;
-      break;
-    default:
-      FMT_ASSERT(false, "invalid number of digits");
-    }
-    --exp;
-    uint64_t remainder =
-        (static_cast<uint64_t>(integral) << -one.e) + fractional;
-    result = handler.on_digit(static_cast<char>('0' + digit),
-                              data::powers_of_10_64[exp] << -one.e, remainder,
-                              error, exp, true);
-    if (result != digits::more) return result;
-  } while (exp > 0);
-  // Generate digits for the fractional part.
-  for (;;) {
-    fractional *= 10;
-    error *= 10;
-    char digit =
-        static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
-    fractional &= one.f - 1;
-    --exp;
-    result = handler.on_digit(digit, one.f, fractional, error, exp, false);
-    if (result != digits::more) return result;
-  }
-}
-
-// The fixed precision digit handler.
-struct fixed_handler {
-  char* buf;
-  int size;
-  int precision;
-  int exp10;
-  bool fixed;
-
-  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
-                          int& exp) {
-    // Non-fixed formats require at least one digit and no precision adjustment.
-    if (!fixed) return digits::more;
-    // Adjust fixed precision by exponent because it is relative to decimal
-    // point.
-    precision += exp + exp10;
-    // Check if precision is satisfied just by leading zeros, e.g.
-    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
-    if (precision > 0) return digits::more;
-    if (precision < 0) return digits::done;
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir == unknown) return digits::error;
-    buf[size++] = dir == up ? '1' : '0';
-    return digits::done;
-  }
-
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int, bool integral) {
-    FMT_ASSERT(remainder < divisor, "");
-    buf[size++] = digit;
-    if (size < precision) return digits::more;
-    if (!integral) {
-      // Check if error * 2 < divisor with overflow prevention.
-      // The check is not needed for the integral part because error = 1
-      // and divisor > (1 << 32) there.
-      if (error >= divisor || error >= divisor - error) return digits::error;
-    } else {
-      FMT_ASSERT(error == 1 && divisor > 2, "");
-    }
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir != up) return dir == down ? digits::done : digits::error;
-    ++buf[size - 1];
-    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
-      buf[i] = '0';
-      ++buf[i - 1];
-    }
-    if (buf[0] > '9') {
-      buf[0] = '1';
-      buf[size++] = '0';
-    }
-    return digits::done;
-  }
-};
-
-// The shortest representation digit handler.
-struct grisu_shortest_handler {
-  char* buf;
-  int size;
-  // Distance between scaled value and upper bound (wp_W in Grisu3).
-  uint64_t diff;
-
-  digits::result on_start(uint64_t, uint64_t, uint64_t, int&) {
-    return digits::more;
-  }
-
-  // Decrement the generated number approaching value from above.
-  void round(uint64_t d, uint64_t divisor, uint64_t& remainder,
-             uint64_t error) {
-    while (
-        remainder < d && error - remainder >= divisor &&
-        (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
-      --buf[size - 1];
-      remainder += divisor;
-    }
-  }
-
-  // Implements Grisu's round_weed.
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int exp, bool integral) {
-    buf[size++] = digit;
-    if (remainder >= error) return digits::more;
-    uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
-    uint64_t up = (diff - 1) * unit;  // wp_Wup
-    round(up, divisor, remainder, error);
-    uint64_t down = (diff + 1) * unit;  // wp_Wdown
-    if (remainder < down && error - remainder >= divisor &&
-        (remainder + divisor < down ||
-         down - remainder > remainder + divisor - down)) {
-      return digits::error;
-    }
-    return 2 * unit <= remainder && remainder <= error - 4 * unit
-               ? digits::done
-               : digits::error;
-  }
-};
-
-// Formats value using a variation of the Fixed-Precision Positive
-// Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
-// https://fmt.dev/p372-steele.pdf.
-template <typename Double>
-void fallback_format(Double d, buffer<char>& buf, int& exp10) {
-  bigint numerator;    // 2 * R in (FPP)^2.
-  bigint denominator;  // 2 * S in (FPP)^2.
-  // lower and upper are differences between value and corresponding boundaries.
-  bigint lower;             // (M^- in (FPP)^2).
-  bigint upper_store;       // upper's value if different from lower.
-  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
-  fp value;
-  // Shift numerator and denominator by an extra bit or two (if lower boundary
-  // is closer) to make lower and upper integers. This eliminates multiplication
-  // by 2 during later computations.
-  // TODO: handle float
-  int shift = value.assign(d) ? 2 : 1;
-  uint64_t significand = value.f << shift;
-  if (value.e >= 0) {
-    numerator.assign(significand);
-    numerator <<= value.e;
-    lower.assign(1);
-    lower <<= value.e;
-    if (shift != 1) {
-      upper_store.assign(1);
-      upper_store <<= value.e + 1;
-      upper = &upper_store;
-    }
-    denominator.assign_pow10(exp10);
-    denominator <<= 1;
-  } else if (exp10 < 0) {
-    numerator.assign_pow10(-exp10);
-    lower.assign(numerator);
-    if (shift != 1) {
-      upper_store.assign(numerator);
-      upper_store <<= 1;
-      upper = &upper_store;
-    }
-    numerator *= significand;
-    denominator.assign(1);
-    denominator <<= shift - value.e;
-  } else {
-    numerator.assign(significand);
-    denominator.assign_pow10(exp10);
-    denominator <<= shift - value.e;
-    lower.assign(1);
-    if (shift != 1) {
-      upper_store.assign(1ULL << 1);
-      upper = &upper_store;
-    }
-  }
-  if (!upper) upper = &lower;
-  // Invariant: value == (numerator / denominator) * pow(10, exp10).
-  bool even = (value.f & 1) == 0;
-  int num_digits = 0;
-  char* data = buf.data();
-  for (;;) {
-    int digit = numerator.divmod_assign(denominator);
-    bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
-    // numerator + upper >[=] pow10:
-    bool high = add_compare(numerator, *upper, denominator) + even > 0;
-    data[num_digits++] = static_cast<char>('0' + digit);
-    if (low || high) {
-      if (!low) {
-        ++data[num_digits - 1];
-      } else if (high) {
-        int result = add_compare(numerator, numerator, denominator);
-        // Round half to even.
-        if (result > 0 || (result == 0 && (digit % 2) != 0))
-          ++data[num_digits - 1];
-      }
-      buf.resize(num_digits);
-      exp10 -= num_digits - 1;
-      return;
-    }
-    numerator *= 10;
-    lower *= 10;
-    if (upper != &lower) *upper *= 10;
-  }
-}
-
-// Formats value using the Grisu algorithm
-// (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf)
-// if T is a IEEE754 binary32 or binary64 and snprintf otherwise.
-template <typename T>
-int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
-  static_assert(!std::is_same<T, float>(), "");
-  FMT_ASSERT(value >= 0, "value is negative");
-
-  const bool fixed = specs.format == float_format::fixed;
-  if (value <= 0) {  // <= instead of == to silence a warning.
-    if (precision <= 0 || !fixed) {
-      buf.push_back('0');
-      return 0;
-    }
-    buf.resize(to_unsigned(precision));
-    std::uninitialized_fill_n(buf.data(), precision, '0');
-    return -precision;
-  }
-
-  if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);
-
-  int exp = 0;
-  const int min_exp = -60;  // alpha in Grisu.
-  int cached_exp10 = 0;     // K in Grisu.
-  if (precision != -1) {
-    if (precision > 17) return snprintf_float(value, precision, specs, buf);
-    fp normalized = normalize(fp(value));
-    const auto cached_pow = get_cached_power(
-        min_exp - (normalized.e + fp::significand_size), cached_exp10);
-    normalized = normalized * cached_pow;
-    fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
-    if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error)
-      return snprintf_float(value, precision, specs, buf);
-    int num_digits = handler.size;
-    if (!fixed) {
-      // Remove trailing zeros.
-      while (num_digits > 0 && buf[num_digits - 1] == '0') {
-        --num_digits;
-        ++exp;
-      }
-    }
-    buf.resize(to_unsigned(num_digits));
-  } else {
-    fp fp_value;
-    auto boundaries = specs.binary32
-                          ? fp_value.assign_float_with_boundaries(value)
-                          : fp_value.assign_with_boundaries(value);
-    fp_value = normalize(fp_value);
-    // Find a cached power of 10 such that multiplying value by it will bring
-    // the exponent in the range [min_exp, -32].
-    const fp cached_pow = get_cached_power(
-        min_exp - (fp_value.e + fp::significand_size), cached_exp10);
-    // Multiply value and boundaries by the cached power of 10.
-    fp_value = fp_value * cached_pow;
-    boundaries.lower = multiply(boundaries.lower, cached_pow.f);
-    boundaries.upper = multiply(boundaries.upper, cached_pow.f);
-    assert(min_exp <= fp_value.e && fp_value.e <= -32);
-    --boundaries.lower;  // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
-    ++boundaries.upper;  // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
-    // Numbers outside of (lower, upper) definitely do not round to value.
-    grisu_shortest_handler handler{buf.data(), 0,
-                                   boundaries.upper - fp_value.f};
-    auto result =
-        grisu_gen_digits(fp(boundaries.upper, fp_value.e),
-                         boundaries.upper - boundaries.lower, exp, handler);
-    if (result == digits::error) {
-      exp += handler.size - cached_exp10 - 1;
-      fallback_format(value, buf, exp);
-      return exp;
-    }
-    buf.resize(to_unsigned(handler.size));
-  }
-  return exp - cached_exp10;
-}
-
-template <typename T>
-int snprintf_float(T value, int precision, float_specs specs,
-                   buffer<char>& buf) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
-  static_assert(!std::is_same<T, float>(), "");
-
-  // Subtract 1 to account for the difference in precision since we use %e for
-  // both general and exponent format.
-  if (specs.format == float_format::general ||
-      specs.format == float_format::exp)
-    precision = (precision >= 0 ? precision : 6) - 1;
-
-  // Build the format string.
-  enum { max_format_size = 7 };  // Ths longest format is "%#.*Le".
-  char format[max_format_size];
-  char* format_ptr = format;
-  *format_ptr++ = '%';
-  if (specs.trailing_zeros) *format_ptr++ = '#';
-  if (precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
-  if (std::is_same<T, long double>()) *format_ptr++ = 'L';
-  *format_ptr++ = specs.format != float_format::hex
-                      ? (specs.format == float_format::fixed ? 'f' : 'e')
-                      : (specs.upper ? 'A' : 'a');
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  auto offset = buf.size();
-  for (;;) {
-    auto begin = buf.data() + offset;
-    auto capacity = buf.capacity() - offset;
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    if (precision > 100000)
-      throw std::runtime_error(
-          "fuzz mode - avoid large allocation inside snprintf");
-#endif
-    // Suppress the warning about a nonliteral format string.
-    auto snprintf_ptr = FMT_SNPRINTF;
-    int result = precision >= 0
-                     ? snprintf_ptr(begin, capacity, format, precision, value)
-                     : snprintf_ptr(begin, capacity, format, value);
-    if (result < 0) {
-      buf.reserve(buf.capacity() + 1);  // The buffer will grow exponentially.
-      continue;
-    }
-    unsigned size = to_unsigned(result);
-    // Size equal to capacity means that the last character was truncated.
-    if (size >= capacity) {
-      buf.reserve(size + offset + 1);  // Add 1 for the terminating '\0'.
-      continue;
-    }
-    auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
-    if (specs.format == float_format::fixed) {
-      if (precision == 0) {
-        buf.resize(size);
-        return 0;
-      }
-      // Find and remove the decimal point.
-      auto end = begin + size, p = end;
-      do {
-        --p;
-      } while (is_digit(*p));
-      int fraction_size = static_cast<int>(end - p - 1);
-      std::memmove(p, p + 1, fraction_size);
-      buf.resize(size - 1);
-      return -fraction_size;
-    }
-    if (specs.format == float_format::hex) {
-      buf.resize(size + offset);
-      return 0;
-    }
-    // Find and parse the exponent.
-    auto end = begin + size, exp_pos = end;
-    do {
-      --exp_pos;
-    } while (*exp_pos != 'e');
-    char sign = exp_pos[1];
-    assert(sign == '+' || sign == '-');
-    int exp = 0;
-    auto p = exp_pos + 2;  // Skip 'e' and sign.
-    do {
-      assert(is_digit(*p));
-      exp = exp * 10 + (*p++ - '0');
-    } while (p != end);
-    if (sign == '-') exp = -exp;
-    int fraction_size = 0;
-    if (exp_pos != begin + 1) {
-      // Remove trailing zeros.
-      auto fraction_end = exp_pos - 1;
-      while (*fraction_end == '0') --fraction_end;
-      // Move the fractional part left to get rid of the decimal point.
-      fraction_size = static_cast<int>(fraction_end - begin - 1);
-      std::memmove(begin + 1, begin + 2, fraction_size);
-    }
-    buf.resize(fraction_size + offset + 1);
-    return exp - fraction_size;
-  }
-}
-}  // namespace internal
-
-template <> struct formatter<internal::bigint> {
-  format_parse_context::iterator parse(format_parse_context& ctx) {
-    return ctx.begin();
-  }
-
-  format_context::iterator format(const internal::bigint& n,
-                                  format_context& ctx) {
-    auto out = ctx.out();
-    bool first = true;
-    for (auto i = n.bigits_.size(); i > 0; --i) {
-      auto value = n.bigits_[i - 1];
-      if (first) {
-        out = format_to(out, "{:x}", value);
-        first = false;
-        continue;
-      }
-      out = format_to(out, "{:08x}", value);
-    }
-    if (n.exp_ > 0)
-      out = format_to(out, "p{}", n.exp_ * internal::bigint::bigit_bits);
-    return out;
-  }
-};
-
-FMT_FUNC void internal::error_handler::on_error(const char* message) {
-  FMT_THROW(duckdb::Exception(message));
-}
-
-FMT_END_NAMESPACE
-
-#ifdef _MSC_VER
-#  pragma warning(pop)
-#endif
-
-#endif  // FMT_FORMAT_INL_H_
-
-
-// LICENSE_CHANGE_END
-
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-template <typename T>
-int format_float(char* buf, std::size_t size, const char* format, int precision,
-                 T value) {
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  if (precision > 100000)
-    throw std::runtime_error(
-        "fuzz mode - avoid large allocation inside snprintf");
-#endif
-  // Suppress the warning about nonliteral format string.
-  auto snprintf_ptr = FMT_SNPRINTF;
-  return precision < 0 ? snprintf_ptr(buf, size, format, value)
-                       : snprintf_ptr(buf, size, format, precision, value);
-}
-struct sprintf_specs {
-  int precision;
-  char type;
-  bool alt : 1;
-
-  template <typename Char>
-  constexpr sprintf_specs(basic_format_specs<Char> specs)
-      : precision(specs.precision), type(specs.type), alt(specs.alt) {}
-
-  constexpr bool has_precision() const { return precision >= 0; }
-};
-
-// This is deprecated and is kept only to preserve ABI compatibility.
-template <typename Double>
-char* sprintf_format(Double value, internal::buffer<char>& buf,
-                     sprintf_specs specs) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buf.capacity() != 0, "empty buffer");
-
-  // Build format string.
-  enum { max_format_size = 10 };  // longest format: %#-*.*Lg
-  char format[max_format_size];
-  char* format_ptr = format;
-  *format_ptr++ = '%';
-  if (specs.alt || !specs.type) *format_ptr++ = '#';
-  if (specs.precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
-  if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';
-
-  char type = specs.type;
-
-  if (type == '%')
-    type = 'f';
-  else if (type == 0 || type == 'n')
-    type = 'g';
-#if FMT_MSC_VER
-  if (type == 'F') {
-    // MSVC's printf doesn't support 'F'.
-    type = 'f';
-  }
-#endif
-  *format_ptr++ = type;
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  char* start = nullptr;
-  char* decimal_point_pos = nullptr;
-  for (;;) {
-    std::size_t buffer_size = buf.capacity();
-    start = &buf[0];
-    int result =
-        format_float(start, buffer_size, format, specs.precision, value);
-    if (result >= 0) {
-      unsigned n = internal::to_unsigned(result);
-      if (n < buf.capacity()) {
-        // Find the decimal point.
-        auto p = buf.data(), end = p + n;
-        if (*p == '+' || *p == '-') ++p;
-        if (specs.type != 'a' && specs.type != 'A') {
-          while (p < end && *p >= '0' && *p <= '9') ++p;
-          if (p < end && *p != 'e' && *p != 'E') {
-            decimal_point_pos = p;
-            if (!specs.type) {
-              // Keep only one trailing zero after the decimal point.
-              ++p;
-              if (*p == '0') ++p;
-              while (p != end && *p >= '1' && *p <= '9') ++p;
-              char* where = p;
-              while (p != end && *p == '0') ++p;
-              if (p == end || *p < '0' || *p > '9') {
-                if (p != end) std::memmove(where, p, to_unsigned(end - p));
-                n -= static_cast<unsigned>(p - where);
-              }
-            }
-          }
-        }
-        buf.resize(n);
-        break;  // The buffer is large enough - continue with formatting.
-      }
-      buf.reserve(n + 1);
-    } else {
-      // If result is negative we ask to increase the capacity by at least 1,
-      // but as std::vector, the buffer grows exponentially.
-      buf.reserve(buf.capacity() + 1);
-    }
-  }
-  return decimal_point_pos;
-}
-}  // namespace internal
-
-template FMT_API char* internal::sprintf_format(double, internal::buffer<char>&,
-                                                sprintf_specs);
-template FMT_API char* internal::sprintf_format(long double,
-                                                internal::buffer<char>&,
-                                                sprintf_specs);
-
-template struct FMT_API internal::basic_data<void>;
-
-// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
-int (*instantiate_format_float)(double, int, internal::float_specs,
-                                internal::buffer<char>&) =
-    internal::format_float;
-
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-template FMT_API internal::locale_ref::locale_ref(const std::locale& loc);
-template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
-#endif
-
-// Explicit instantiations for char.
-
-template FMT_API std::string internal::grouping_impl<char>(locale_ref);
-template FMT_API char internal::thousands_sep_impl(locale_ref);
-template FMT_API char internal::decimal_point_impl(locale_ref);
-
-template FMT_API void internal::buffer<char>::append(const char*, const char*);
-
-template FMT_API void internal::arg_map<format_context>::init(
-    const basic_format_args<format_context>& args);
-
-template FMT_API std::string internal::vformat<char>(
-    string_view, basic_format_args<format_context>);
-
-template FMT_API format_context::iterator internal::vformat_to(
-    internal::buffer<char>&, string_view, basic_format_args<format_context>);
-
-template FMT_API int internal::snprintf_float(double, int,
-                                              internal::float_specs,
-                                              internal::buffer<char>&);
-template FMT_API int internal::snprintf_float(long double, int,
-                                              internal::float_specs,
-                                              internal::buffer<char>&);
-template FMT_API int internal::format_float(double, int, internal::float_specs,
-                                            internal::buffer<char>&);
-template FMT_API int internal::format_float(long double, int,
-                                            internal::float_specs,
-                                            internal::buffer<char>&);
-
-// Explicit instantiations for wchar_t.
-
-template FMT_API std::string internal::grouping_impl<wchar_t>(locale_ref);
-template FMT_API wchar_t internal::thousands_sep_impl(locale_ref);
-template FMT_API wchar_t internal::decimal_point_impl(locale_ref);
-
-template FMT_API void internal::buffer<wchar_t>::append(const wchar_t*,
-                                                        const wchar_t*);
-
-template FMT_API std::wstring internal::vformat<wchar_t>(
-    wstring_view, basic_format_args<wformat_context>);
-FMT_END_NAMESPACE
-
-
-// LICENSE_CHANGE_END
diff --git a/velox/external/duckdb/duckdb-hyperloglog.cpp b/velox/external/duckdb/duckdb-hyperloglog.cpp
deleted file mode 100644
index e7bacf1e70ec9..0000000000000
--- a/velox/external/duckdb/duckdb-hyperloglog.cpp
+++ /dev/null
@@ -1,2718 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
-// See the end of this file for a list
-
-/* hyperloglog.c - Redis HyperLogLog probabilistic cardinality approximation.
- * This file implements the algorithm and the exported Redis commands.
- *
- * Copyright (c) 2014, Salvatore Sanfilippo <antirez at gmail dot com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
-// See the end of this file for a list
-
-/* SDSLib 2.0 -- A C dynamic strings library
- *
- * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2015, Oran Agra
- * Copyright (c) 2015, Redis Labs, Inc
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __SDS_H
-#define __SDS_H
-
-
-#ifdef _MSC_VER
-#define __attribute__(A)
-#define ssize_t int64_t
-#endif
-
-#define SDS_MAX_PREALLOC (1024*1024)
-
-#include <sys/types.h>
-#include <stdarg.h>
-#include <stdint.h>
-
-namespace duckdb_hll {
-
-
-typedef char *sds;
-
-/* Note: sdshdr5 is never used, we just access the flags byte directly.
- * However is here to document the layout of type 5 SDS strings. */
-struct __attribute__ ((__packed__)) sdshdr5 {
-    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
-    char buf[1];
-};
-struct __attribute__ ((__packed__)) sdshdr8 {
-    uint8_t len; /* used */
-    uint8_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[1];
-};
-struct __attribute__ ((__packed__)) sdshdr16 {
-    uint16_t len; /* used */
-    uint16_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[1];
-};
-struct __attribute__ ((__packed__)) sdshdr32 {
-    uint32_t len; /* used */
-    uint32_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[1];
-};
-struct __attribute__ ((__packed__)) sdshdr64 {
-    uint64_t len; /* used */
-    uint64_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[1];
-};
-
-#define SDS_TYPE_5  0
-#define SDS_TYPE_8  1
-#define SDS_TYPE_16 2
-#define SDS_TYPE_32 3
-#define SDS_TYPE_64 4
-#define SDS_TYPE_MASK 7
-#define SDS_TYPE_BITS 3
-#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T)));
-#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
-#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
-
-static inline size_t sdslen(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return SDS_TYPE_5_LEN(flags);
-        case SDS_TYPE_8:
-            return SDS_HDR(8,s)->len;
-        case SDS_TYPE_16:
-            return SDS_HDR(16,s)->len;
-        case SDS_TYPE_32:
-            return SDS_HDR(32,s)->len;
-        case SDS_TYPE_64:
-            return SDS_HDR(64,s)->len;
-    }
-    return 0;
-}
-
-static inline size_t sdsavail(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5: {
-            return 0;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            return sh->alloc - sh->len;
-        }
-    }
-    return 0;
-}
-
-static inline void sdssetlen(sds s, size_t newlen) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            {
-                unsigned char *fp = ((unsigned char*)s)-1;
-                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
-            }
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->len = newlen;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->len = newlen;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->len = newlen;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->len = newlen;
-            break;
-    }
-}
-
-static inline void sdsinclen(sds s, size_t inc) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            {
-                unsigned char *fp = ((unsigned char*)s)-1;
-                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
-                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
-            }
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->len += inc;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->len += inc;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->len += inc;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->len += inc;
-            break;
-    }
-}
-
-/* sdsalloc() = sdsavail() + sdslen() */
-static inline size_t sdsalloc(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return SDS_TYPE_5_LEN(flags);
-        case SDS_TYPE_8:
-            return SDS_HDR(8,s)->alloc;
-        case SDS_TYPE_16:
-            return SDS_HDR(16,s)->alloc;
-        case SDS_TYPE_32:
-            return SDS_HDR(32,s)->alloc;
-        case SDS_TYPE_64:
-            return SDS_HDR(64,s)->alloc;
-    }
-    return 0;
-}
-
-static inline void sdssetalloc(sds s, size_t newlen) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            /* Nothing to do, this type has no total allocation info. */
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->alloc = newlen;
-            break;
-    }
-}
-
-sds sdsnewlen(const void *init, size_t initlen);
-sds sdsnew(const char *init);
-sds sdsempty(void);
-sds sdsdup(const sds s);
-void sdsfree(sds s);
-sds sdsgrowzero(sds s, size_t len);
-sds sdscatlen(sds s, const void *t, size_t len);
-sds sdscat(sds s, const char *t);
-sds sdscatsds(sds s, const sds t);
-sds sdscpylen(sds s, const char *t, size_t len);
-sds sdscpy(sds s, const char *t);
-
-sds sdscatvprintf(sds s, const char *fmt, va_list ap);
-#ifdef __GNUC__
-sds sdscatprintf(sds s, const char *fmt, ...)
-    __attribute__((format(printf, 2, 3)));
-#else
-sds sdscatprintf(sds s, const char *fmt, ...);
-#endif
-
-sds sdscatfmt(sds s, char const *fmt, ...);
-sds sdstrim(sds s, const char *cset);
-void sdsrange(sds s, ssize_t start, ssize_t end);
-void sdsupdatelen(sds s);
-void sdsclear(sds s);
-int sdscmp(const sds s1, const sds s2);
-sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count);
-void sdsfreesplitres(sds *tokens, int count);
-void sdstolower(sds s);
-void sdstoupper(sds s);
-sds sdsfromlonglong(long long value);
-sds sdscatrepr(sds s, const char *p, size_t len);
-sds *sdssplitargs(const char *line, int *argc);
-sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
-sds sdsjoin(char **argv, int argc, char *sep);
-sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
-
-/* Low level functions exposed to the user API */
-sds sdsMakeRoomFor(sds s, size_t addlen);
-void sdsIncrLen(sds s, ssize_t incr);
-sds sdsRemoveFreeSpace(sds s);
-size_t sdsAllocSize(sds s);
-void *sdsAllocPtr(sds s);
-
-/* Export the allocator used by SDS to the program using SDS.
- * Sometimes the program SDS is linked to, may use a different set of
- * allocators, but may want to allocate or free things that SDS will
- * respectively free or allocate. */
-void *sds_malloc(size_t size);
-void *sds_realloc(void *ptr, size_t size);
-void sds_free(void *ptr);
-
-#ifdef REDIS_TEST
-int sdsTest(int argc, char *argv[]);
-#endif
-}
-
-
-#endif
-
-// LICENSE_CHANGE_END
-
-
-#include <assert.h>
-#include <stdint.h>
-#include <math.h>
-#include <stddef.h>
-#include <string.h>
-#include <stdlib.h>
-
-
-
-namespace duckdb_hll {
-
-#define HLL_SPARSE_MAX_BYTES 3000
-
-/* The Redis HyperLogLog implementation is based on the following ideas:
- *
- * * The use of a 64 bit hash function as proposed in [1], in order to don't
- *   limited to cardinalities up to 10^9, at the cost of just 1 additional
- *   bit per register.
- * * The use of 16384 6-bit registers for a great level of accuracy, using
- *   a total of 12k per key.
- * * The use of the Redis string data type. No new type is introduced.
- * * No attempt is made to compress the data structure as in [1]. Also the
- *   algorithm used is the original HyperLogLog Algorithm as in [2], with
- *   the only difference that a 64 bit hash function is used, so no correction
- *   is performed for values near 2^32 as in [1].
- *
- * [1] Heule, Nunkesser, Hall: HyperLogLog in Practice: Algorithmic
- *     Engineering of a State of The Art Cardinality Estimation Algorithm.
- *
- * [2] P. Flajolet, Éric Fusy, O. Gandouet, and F. Meunier. Hyperloglog: The
- *     analysis of a near-optimal cardinality estimation algorithm.
- *
- * Redis uses two representations:
- *
- * 1) A "dense" representation where every entry is represented by
- *    a 6-bit integer.
- * 2) A "sparse" representation using run length compression suitable
- *    for representing HyperLogLogs with many registers set to 0 in
- *    a memory efficient way.
- *
- *
- * HLL header
- * ===
- *
- * Both the dense and sparse representation have a 16 byte header as follows:
- *
- * +------+---+-----+----------+
- * | HYLL | E | N/U | Cardin.  |
- * +------+---+-----+----------+
- *
- * The first 4 bytes are a magic string set to the bytes "HYLL".
- * "E" is one byte encoding, currently set to HLL_DENSE or
- * HLL_SPARSE. N/U are three not used bytes.
- *
- * The "Cardin." field is a 64 bit integer stored in little endian format
- * with the latest cardinality computed that can be reused if the data
- * structure was not modified since the last computation (this is useful
- * because there are high probabilities that HLLADD operations don't
- * modify the actual data structure and hence the approximated cardinality).
- *
- * When the most significant bit in the most significant byte of the cached
- * cardinality is set, it means that the data structure was modified and
- * we can't reuse the cached value that must be recomputed.
- *
- * Dense representation
- * ===
- *
- * The dense representation used by Redis is the following:
- *
- * +--------+--------+--------+------//      //--+
- * |11000000|22221111|33333322|55444444 ....     |
- * +--------+--------+--------+------//      //--+
- *
- * The 6 bits counters are encoded one after the other starting from the
- * LSB to the MSB, and using the next bytes as needed.
- *
- * Sparse representation
- * ===
- *
- * The sparse representation encodes registers using a run length
- * encoding composed of three opcodes, two using one byte, and one using
- * of two bytes. The opcodes are called ZERO, XZERO and VAL.
- *
- * ZERO opcode is represented as 00xxxxxx. The 6-bit integer represented
- * by the six bits 'xxxxxx', plus 1, means that there are N registers set
- * to 0. This opcode can represent from 1 to 64 contiguous registers set
- * to the value of 0.
- *
- * XZERO opcode is represented by two bytes 01xxxxxx yyyyyyyy. The 14-bit
- * integer represented by the bits 'xxxxxx' as most significant bits and
- * 'yyyyyyyy' as least significant bits, plus 1, means that there are N
- * registers set to 0. This opcode can represent from 0 to 16384 contiguous
- * registers set to the value of 0.
- *
- * VAL opcode is represented as 1vvvvvxx. It contains a 5-bit integer
- * representing the value of a register, and a 2-bit integer representing
- * the number of contiguous registers set to that value 'vvvvv'.
- * To obtain the value and run length, the integers vvvvv and xx must be
- * incremented by one. This opcode can represent values from 1 to 32,
- * repeated from 1 to 4 times.
- *
- * The sparse representation can't represent registers with a value greater
- * than 32, however it is very unlikely that we find such a register in an
- * HLL with a cardinality where the sparse representation is still more
- * memory efficient than the dense representation. When this happens the
- * HLL is converted to the dense representation.
- *
- * The sparse representation is purely positional. For example a sparse
- * representation of an empty HLL is just: XZERO:16384.
- *
- * An HLL having only 3 non-zero registers at position 1000, 1020, 1021
- * respectively set to 2, 3, 3, is represented by the following three
- * opcodes:
- *
- * XZERO:1000 (Registers 0-999 are set to 0)
- * VAL:2,1    (1 register set to value 2, that is register 1000)
- * ZERO:19    (Registers 1001-1019 set to 0)
- * VAL:3,2    (2 registers set to value 3, that is registers 1020,1021)
- * XZERO:15362 (Registers 1022-16383 set to 0)
- *
- * In the example the sparse representation used just 7 bytes instead
- * of 12k in order to represent the HLL registers. In general for low
- * cardinality there is a big win in terms of space efficiency, traded
- * with CPU time since the sparse representation is slower to access:
- *
- * The following table shows average cardinality vs bytes used, 100
- * samples per cardinality (when the set was not representable because
- * of registers with too big value, the dense representation size was used
- * as a sample).
- *
- * 100 267
- * 200 485
- * 300 678
- * 400 859
- * 500 1033
- * 600 1205
- * 700 1375
- * 800 1544
- * 900 1713
- * 1000 1882
- * 2000 3480
- * 3000 4879
- * 4000 6089
- * 5000 7138
- * 6000 8042
- * 7000 8823
- * 8000 9500
- * 9000 10088
- * 10000 10591
- *
- * The dense representation uses 12288 bytes, so there is a big win up to
- * a cardinality of ~2000-3000. For bigger cardinalities the constant times
- * involved in updating the sparse representation is not justified by the
- * memory savings. The exact maximum length of the sparse representation
- * when this implementation switches to the dense representation is
- * configured via the define server.hll_sparse_max_bytes.
- */
-
-struct hllhdr {
-    char magic[4];      /* "HYLL" */
-    uint8_t encoding;   /* HLL_DENSE or HLL_SPARSE. */
-    uint8_t notused[3]; /* Reserved for future use, must be zero. */
-    uint8_t card[8];    /* Cached cardinality, little endian. */
-    uint8_t registers[1]; /* Data bytes. */
-};
-
-/* The cached cardinality MSB is used to signal validity of the cached value. */
-#define HLL_INVALIDATE_CACHE(hdr) (hdr)->card[7] |= (1<<7)
-#define HLL_VALID_CACHE(hdr) (((hdr)->card[7] & (1<<7)) == 0)
-
-#define HLL_P 12 /* The greater is P, the smaller the error. */
-#define HLL_Q (64-HLL_P) /* The number of bits of the hash value used for
-                            determining the number of leading zeros. */
-#define HLL_REGISTERS (1<<HLL_P) /* With P=14, 16384 registers. */
-#define HLL_P_MASK (HLL_REGISTERS-1) /* Mask to index register. */
-#define HLL_BITS 6 /* Enough to count up to 63 leading zeroes. */
-#define HLL_REGISTER_MAX ((1<<HLL_BITS)-1)
-#define HLL_HDR_SIZE sizeof(struct hllhdr)
-#define HLL_DENSE_SIZE (HLL_HDR_SIZE+((HLL_REGISTERS*HLL_BITS+7)/8))
-#define HLL_DENSE 0 /* Dense encoding. */
-#define HLL_SPARSE 1 /* Sparse encoding. */
-#define HLL_RAW 255 /* Only used internally, never exposed. */
-#define HLL_MAX_ENCODING 1
-
-/* =========================== Low level bit macros ========================= */
-
-/* Macros to access the dense representation.
- *
- * We need to get and set 6 bit counters in an array of 8 bit bytes.
- * We use macros to make sure the code is inlined since speed is critical
- * especially in order to compute the approximated cardinality in
- * HLLCOUNT where we need to access all the registers at once.
- * For the same reason we also want to avoid conditionals in this code path.
- *
- * +--------+--------+--------+------//
- * |11000000|22221111|33333322|55444444
- * +--------+--------+--------+------//
- *
- * Note: in the above representation the most significant bit (MSB)
- * of every byte is on the left. We start using bits from the LSB to MSB,
- * and so forth passing to the next byte.
- *
- * Example, we want to access to counter at pos = 1 ("111111" in the
- * illustration above).
- *
- * The index of the first byte b0 containing our data is:
- *
- *  b0 = 6 * pos / 8 = 0
- *
- *   +--------+
- *   |11000000|  <- Our byte at b0
- *   +--------+
- *
- * The position of the first bit (counting from the LSB = 0) in the byte
- * is given by:
- *
- *  fb = 6 * pos % 8 -> 6
- *
- * Right shift b0 of 'fb' bits.
- *
- *   +--------+
- *   |11000000|  <- Initial value of b0
- *   |00000011|  <- After right shift of 6 pos.
- *   +--------+
- *
- * Left shift b1 of bits 8-fb bits (2 bits)
- *
- *   +--------+
- *   |22221111|  <- Initial value of b1
- *   |22111100|  <- After left shift of 2 bits.
- *   +--------+
- *
- * OR the two bits, and finally AND with 111111 (63 in decimal) to
- * clean the higher order bits we are not interested in:
- *
- *   +--------+
- *   |00000011|  <- b0 right shifted
- *   |22111100|  <- b1 left shifted
- *   |22111111|  <- b0 OR b1
- *   |  111111|  <- (b0 OR b1) AND 63, our value.
- *   +--------+
- *
- * We can try with a different example, like pos = 0. In this case
- * the 6-bit counter is actually contained in a single byte.
- *
- *  b0 = 6 * pos / 8 = 0
- *
- *   +--------+
- *   |11000000|  <- Our byte at b0
- *   +--------+
- *
- *  fb = 6 * pos % 8 = 0
- *
- *  So we right shift of 0 bits (no shift in practice) and
- *  left shift the next byte of 8 bits, even if we don't use it,
- *  but this has the effect of clearing the bits so the result
- *  will not be affacted after the OR.
- *
- * -------------------------------------------------------------------------
- *
- * Setting the register is a bit more complex, let's assume that 'val'
- * is the value we want to set, already in the right range.
- *
- * We need two steps, in one we need to clear the bits, and in the other
- * we need to bitwise-OR the new bits.
- *
- * Let's try with 'pos' = 1, so our first byte at 'b' is 0,
- *
- * "fb" is 6 in this case.
- *
- *   +--------+
- *   |11000000|  <- Our byte at b0
- *   +--------+
- *
- * To create a AND-mask to clear the bits about this position, we just
- * initialize the mask with the value 63, left shift it of "fs" bits,
- * and finally invert the result.
- *
- *   +--------+
- *   |00111111|  <- "mask" starts at 63
- *   |11000000|  <- "mask" after left shift of "ls" bits.
- *   |00111111|  <- "mask" after invert.
- *   +--------+
- *
- * Now we can bitwise-AND the byte at "b" with the mask, and bitwise-OR
- * it with "val" left-shifted of "ls" bits to set the new bits.
- *
- * Now let's focus on the next byte b1:
- *
- *   +--------+
- *   |22221111|  <- Initial value of b1
- *   +--------+
- *
- * To build the AND mask we start again with the 63 value, right shift
- * it by 8-fb bits, and invert it.
- *
- *   +--------+
- *   |00111111|  <- "mask" set at 2&6-1
- *   |00001111|  <- "mask" after the right shift by 8-fb = 2 bits
- *   |11110000|  <- "mask" after bitwise not.
- *   +--------+
- *
- * Now we can mask it with b+1 to clear the old bits, and bitwise-OR
- * with "val" left-shifted by "rs" bits to set the new value.
- */
-
-/* Note: if we access the last counter, we will also access the b+1 byte
- * that is out of the array, but sds strings always have an implicit null
- * term, so the byte exists, and we can skip the conditional (or the need
- * to allocate 1 byte more explicitly). */
-
-/* Store the value of the register at position 'regnum' into variable 'target'.
- * 'p' is an array of unsigned bytes. */
-#define HLL_DENSE_GET_REGISTER(target,p,regnum) do { \
-    uint8_t *_p = (uint8_t*) p; \
-    unsigned long _byte = regnum*HLL_BITS/8; \
-    unsigned long _fb = regnum*HLL_BITS&7; \
-    unsigned long _fb8 = 8 - _fb; \
-    unsigned long b0 = _p[_byte]; \
-    unsigned long b1 = _p[_byte+1]; \
-    target = ((b0 >> _fb) | (b1 << _fb8)) & HLL_REGISTER_MAX; \
-} while(0)
-
-/* Set the value of the register at position 'regnum' to 'val'.
- * 'p' is an array of unsigned bytes. */
-#define HLL_DENSE_SET_REGISTER(p,regnum,val) do { \
-    uint8_t *_p = (uint8_t*) p; \
-    unsigned long _byte = regnum*HLL_BITS/8; \
-    unsigned long _fb = regnum*HLL_BITS&7; \
-    unsigned long _fb8 = 8 - _fb; \
-    unsigned long _v = val; \
-    _p[_byte] &= ~(HLL_REGISTER_MAX << _fb); \
-    _p[_byte] |= _v << _fb; \
-    _p[_byte+1] &= ~(HLL_REGISTER_MAX >> _fb8); \
-    _p[_byte+1] |= _v >> _fb8; \
-} while(0)
-
-/* Macros to access the sparse representation.
- * The macros parameter is expected to be an uint8_t pointer. */
-#define HLL_SPARSE_XZERO_BIT 0x40 /* 01xxxxxx */
-#define HLL_SPARSE_VAL_BIT 0x80 /* 1vvvvvxx */
-#define HLL_SPARSE_IS_ZERO(p) (((*(p)) & 0xc0) == 0) /* 00xxxxxx */
-#define HLL_SPARSE_IS_XZERO(p) (((*(p)) & 0xc0) == HLL_SPARSE_XZERO_BIT)
-#define HLL_SPARSE_IS_VAL(p) ((*(p)) & HLL_SPARSE_VAL_BIT)
-#define HLL_SPARSE_ZERO_LEN(p) (((*(p)) & 0x3f)+1)
-#define HLL_SPARSE_XZERO_LEN(p) (((((*(p)) & 0x3f) << 8) | (*((p)+1)))+1)
-#define HLL_SPARSE_VAL_VALUE(p) ((((*(p)) >> 2) & 0x1f)+1)
-#define HLL_SPARSE_VAL_LEN(p) (((*(p)) & 0x3)+1)
-#define HLL_SPARSE_VAL_MAX_VALUE 32
-#define HLL_SPARSE_VAL_MAX_LEN 4
-#define HLL_SPARSE_ZERO_MAX_LEN 64
-#define HLL_SPARSE_XZERO_MAX_LEN 16384
-#define HLL_SPARSE_VAL_SET(p,val,len) do { \
-    *(p) = (((val)-1)<<2|((len)-1))|HLL_SPARSE_VAL_BIT; \
-} while(0)
-#define HLL_SPARSE_ZERO_SET(p,len) do { \
-    *(p) = (len)-1; \
-} while(0)
-#define HLL_SPARSE_XZERO_SET(p,len) do { \
-    int _l = (len)-1; \
-    *(p) = (_l>>8) | HLL_SPARSE_XZERO_BIT; \
-    *((p)+1) = (_l&0xff); \
-} while(0)
-#define HLL_ALPHA_INF 0.721347520444481703680 /* constant for 0.5/ln(2) */
-
-/* ========================= HyperLogLog algorithm  ========================= */
-
-/* Our hash function is MurmurHash2, 64 bit version.
- * It was modified for Redis in order to provide the same result in
- * big and little endian archs (endian neutral). */
-uint64_t MurmurHash64A (const void * key, int len, unsigned int seed) {
-    const uint64_t m = 0xc6a4a7935bd1e995;
-    const int r = 47;
-    uint64_t h = seed ^ (len * m);
-    const uint8_t *data = (const uint8_t *)key;
-    const uint8_t *end = data + (len-(len&7));
-
-    while(data != end) {
-        uint64_t k;
-
-#if (BYTE_ORDER == LITTLE_ENDIAN)
-    #ifdef USE_ALIGNED_ACCESS
-        memcpy(&k,data,sizeof(uint64_t));
-    #else
-        k = *((uint64_t*)data);
-    #endif
-#else
-        k = (uint64_t) data[0];
-        k |= (uint64_t) data[1] << 8;
-        k |= (uint64_t) data[2] << 16;
-        k |= (uint64_t) data[3] << 24;
-        k |= (uint64_t) data[4] << 32;
-        k |= (uint64_t) data[5] << 40;
-        k |= (uint64_t) data[6] << 48;
-        k |= (uint64_t) data[7] << 56;
-#endif
-
-        k *= m;
-        k ^= k >> r;
-        k *= m;
-        h ^= k;
-        h *= m;
-        data += 8;
-    }
-
-    switch(len & 7) {
-    case 7: h ^= (uint64_t)data[6] << 48; /* fall-thru */
-    case 6: h ^= (uint64_t)data[5] << 40; /* fall-thru */
-    case 5: h ^= (uint64_t)data[4] << 32; /* fall-thru */
-    case 4: h ^= (uint64_t)data[3] << 24; /* fall-thru */
-    case 3: h ^= (uint64_t)data[2] << 16; /* fall-thru */
-    case 2: h ^= (uint64_t)data[1] << 8; /* fall-thru */
-    case 1: h ^= (uint64_t)data[0];
-            h *= m; /* fall-thru */
-    };
-
-    h ^= h >> r;
-    h *= m;
-    h ^= h >> r;
-    return h;
-}
-
-/* Given a string element to add to the HyperLogLog, returns the length
- * of the pattern 000..1 of the element hash. As a side effect 'regp' is
- * set to the register index this element hashes to. */
-int hllPatLen(unsigned char *ele, size_t elesize, long *regp) {
-    uint64_t hash, bit, index;
-    int count;
-
-    /* Count the number of zeroes starting from bit HLL_REGISTERS
-     * (that is a power of two corresponding to the first bit we don't use
-     * as index). The max run can be 64-P+1 = Q+1 bits.
-     *
-     * Note that the final "1" ending the sequence of zeroes must be
-     * included in the count, so if we find "001" the count is 3, and
-     * the smallest count possible is no zeroes at all, just a 1 bit
-     * at the first position, that is a count of 1.
-     *
-     * This may sound like inefficient, but actually in the average case
-     * there are high probabilities to find a 1 after a few iterations. */
-    hash = MurmurHash64A(ele,elesize,0xadc83b19ULL);
-    index = hash & HLL_P_MASK; /* Register index. */
-    hash >>= HLL_P; /* Remove bits used to address the register. */
-    hash |= ((uint64_t)1<<HLL_Q); /* Make sure the loop terminates
-                                     and count will be <= Q+1. */
-    bit = 1;
-    count = 1; /* Initialized to 1 since we count the "00000...1" pattern. */
-    while((hash & bit) == 0) {
-        count++;
-        bit <<= 1;
-    }
-    *regp = (int) index;
-    return count;
-}
-
-/* ================== Dense representation implementation  ================== */
-
-/* Low level function to set the dense HLL register at 'index' to the
- * specified value if the current value is smaller than 'count'.
- *
- * 'registers' is expected to have room for HLL_REGISTERS plus an
- * additional byte on the right. This requirement is met by sds strings
- * automatically since they are implicitly null terminated.
- *
- * The function always succeed, however if as a result of the operation
- * the approximated cardinality changed, 1 is returned. Otherwise 0
- * is returned. */
-static inline int hllDenseSet(uint8_t *registers, long index, uint8_t count) {
-    uint8_t oldcount;
-
-    HLL_DENSE_GET_REGISTER(oldcount,registers,index);
-    if (count > oldcount) {
-        HLL_DENSE_SET_REGISTER(registers,index,count);
-        return 1;
-    } else {
-        return 0;
-    }
-}
-
-/* "Add" the element in the dense hyperloglog data structure.
- * Actually nothing is added, but the max 0 pattern counter of the subset
- * the element belongs to is incremented if needed.
- *
- * This is just a wrapper to hllDenseSet(), performing the hashing of the
- * element in order to retrieve the index and zero-run count. */
-int hllDenseAdd(uint8_t *registers, unsigned char *ele, size_t elesize) {
-    long index;
-    uint8_t count = hllPatLen(ele,elesize,&index);
-    /* Update the register if this element produced a longer run of zeroes. */
-    return hllDenseSet(registers,index,count);
-}
-
-/* Compute the register histogram in the dense representation. */
-void hllDenseRegHisto(uint8_t *registers, int* reghisto) {
-    int j;
-
-    /* Redis default is to use 16384 registers 6 bits each. The code works
-     * with other values by modifying the defines, but for our target value
-     * we take a faster path with unrolled loops. */
-    if (HLL_REGISTERS == 16384 && HLL_BITS == 6) {
-        uint8_t *r = registers;
-        unsigned long r0, r1, r2, r3, r4, r5, r6, r7, r8, r9,
-                      r10, r11, r12, r13, r14, r15;
-        for (j = 0; j < 1024; j++) {
-            /* Handle 16 registers per iteration. */
-            r0 = r[0] & 63;
-            r1 = (r[0] >> 6 | r[1] << 2) & 63;
-            r2 = (r[1] >> 4 | r[2] << 4) & 63;
-            r3 = (r[2] >> 2) & 63;
-            r4 = r[3] & 63;
-            r5 = (r[3] >> 6 | r[4] << 2) & 63;
-            r6 = (r[4] >> 4 | r[5] << 4) & 63;
-            r7 = (r[5] >> 2) & 63;
-            r8 = r[6] & 63;
-            r9 = (r[6] >> 6 | r[7] << 2) & 63;
-            r10 = (r[7] >> 4 | r[8] << 4) & 63;
-            r11 = (r[8] >> 2) & 63;
-            r12 = r[9] & 63;
-            r13 = (r[9] >> 6 | r[10] << 2) & 63;
-            r14 = (r[10] >> 4 | r[11] << 4) & 63;
-            r15 = (r[11] >> 2) & 63;
-
-            reghisto[r0]++;
-            reghisto[r1]++;
-            reghisto[r2]++;
-            reghisto[r3]++;
-            reghisto[r4]++;
-            reghisto[r5]++;
-            reghisto[r6]++;
-            reghisto[r7]++;
-            reghisto[r8]++;
-            reghisto[r9]++;
-            reghisto[r10]++;
-            reghisto[r11]++;
-            reghisto[r12]++;
-            reghisto[r13]++;
-            reghisto[r14]++;
-            reghisto[r15]++;
-
-            r += 12;
-        }
-    } else {
-        for(j = 0; j < HLL_REGISTERS; j++) {
-            unsigned long reg;
-            HLL_DENSE_GET_REGISTER(reg,registers,j);
-            reghisto[reg]++;
-        }
-    }
-}
-
-/* ================== Sparse representation implementation  ================= */
-
-/* Convert the HLL with sparse representation given as input in its dense
- * representation. Both representations are represented by SDS strings, and
- * the input representation is freed as a side effect.
- *
- * The function returns C_OK if the sparse representation was valid,
- * otherwise C_ERR is returned if the representation was corrupted. */
-int hllSparseToDense(robj *o) {
-    sds sparse = (sds) o->ptr, dense;
-    struct hllhdr *hdr, *oldhdr = (struct hllhdr*)sparse;
-    int idx = 0, runlen, regval;
-    uint8_t *p = (uint8_t*)sparse, *end = p+sdslen(sparse);
-
-    /* If the representation is already the right one return ASAP. */
-    hdr = (struct hllhdr*) sparse;
-    if (hdr->encoding == HLL_DENSE) return HLL_C_OK;
-
-    /* Create a string of the right size filled with zero bytes.
-     * Note that the cached cardinality is set to 0 as a side effect
-     * that is exactly the cardinality of an empty HLL. */
-    dense = sdsnewlen(NULL,HLL_DENSE_SIZE);
-    hdr = (struct hllhdr*) dense;
-    *hdr = *oldhdr; /* This will copy the magic and cached cardinality. */
-    hdr->encoding = HLL_DENSE;
-
-    /* Now read the sparse representation and set non-zero registers
-     * accordingly. */
-    p += HLL_HDR_SIZE;
-    while(p < end) {
-        if (HLL_SPARSE_IS_ZERO(p)) {
-            runlen = HLL_SPARSE_ZERO_LEN(p);
-            idx += runlen;
-            p++;
-        } else if (HLL_SPARSE_IS_XZERO(p)) {
-            runlen = HLL_SPARSE_XZERO_LEN(p);
-            idx += runlen;
-            p += 2;
-        } else {
-            runlen = HLL_SPARSE_VAL_LEN(p);
-            regval = HLL_SPARSE_VAL_VALUE(p);
-            while(runlen--) {
-                HLL_DENSE_SET_REGISTER(hdr->registers + 1,idx,regval);
-                idx++;
-            }
-            p++;
-        }
-    }
-
-    /* If the sparse representation was valid, we expect to find idx
-     * set to HLL_REGISTERS. */
-    if (idx != HLL_REGISTERS) {
-        sdsfree(dense);
-        return HLL_C_ERR;
-    }
-
-    /* Free the old representation and set the new one. */
-    sdsfree((sds) o->ptr);
-    o->ptr = dense;
-    return HLL_C_OK;
-}
-
-/* Low level function to set the sparse HLL register at 'index' to the
- * specified value if the current value is smaller than 'count'.
- *
- * The object 'o' is the String object holding the HLL. The function requires
- * a reference to the object in order to be able to enlarge the string if
- * needed.
- *
- * On success, the function returns 1 if the cardinality changed, or 0
- * if the register for this element was not updated.
- * On error (if the representation is invalid) -1 is returned.
- *
- * As a side effect the function may promote the HLL representation from
- * sparse to dense: this happens when a register requires to be set to a value
- * not representable with the sparse representation, or when the resulting
- * size would be greater than server.hll_sparse_max_bytes. */
-int hllSparseSet(robj *o, long index, uint8_t count) {
-    struct hllhdr *hdr;
-    uint8_t oldcount, *sparse, *end, *p, *prev, *next;
-    long first, span;
-    long is_zero = 0, is_xzero = 0, is_val = 0, runlen = 0;
-    uint8_t seq[5], *n;
-    int last;
-    int len;
-    int seqlen;
-    int oldlen;
-    int deltalen;
-
-    /* If the count is too big to be representable by the sparse representation
-     * switch to dense representation. */
-    if (count > HLL_SPARSE_VAL_MAX_VALUE) goto promote;
-
-    /* When updating a sparse representation, sometimes we may need to
-     * enlarge the buffer for up to 3 bytes in the worst case (XZERO split
-     * into XZERO-VAL-XZERO). Make sure there is enough space right now
-     * so that the pointers we take during the execution of the function
-     * will be valid all the time. */
-    o->ptr = (sds) sdsMakeRoomFor((sds) o->ptr,3);
-
-    /* Step 1: we need to locate the opcode we need to modify to check
-     * if a value update is actually needed. */
-    sparse = p = ((uint8_t*)o->ptr) + HLL_HDR_SIZE;
-    end = p + sdslen((sds) o->ptr) - HLL_HDR_SIZE;
-
-    first = 0;
-    prev = NULL; /* Points to previous opcode at the end of the loop. */
-    next = NULL; /* Points to the next opcode at the end of the loop. */
-    span = 0;
-    while(p < end) {
-        long oplen;
-
-        /* Set span to the number of registers covered by this opcode.
-         *
-         * This is the most performance critical loop of the sparse
-         * representation. Sorting the conditionals from the most to the
-         * least frequent opcode in many-bytes sparse HLLs is faster. */
-        oplen = 1;
-        if (HLL_SPARSE_IS_ZERO(p)) {
-            span = HLL_SPARSE_ZERO_LEN(p);
-        } else if (HLL_SPARSE_IS_VAL(p)) {
-            span = HLL_SPARSE_VAL_LEN(p);
-        } else { /* XZERO. */
-            span = HLL_SPARSE_XZERO_LEN(p);
-            oplen = 2;
-        }
-        /* Break if this opcode covers the register as 'index'. */
-        if (index <= first+span-1) break;
-        prev = p;
-        p += oplen;
-        first += span;
-    }
-    if (span == 0) return -1; /* Invalid format. */
-
-    next = HLL_SPARSE_IS_XZERO(p) ? p+2 : p+1;
-    if (next >= end) next = NULL;
-
-    /* Cache current opcode type to avoid using the macro again and
-     * again for something that will not change.
-     * Also cache the run-length of the opcode. */
-    if (HLL_SPARSE_IS_ZERO(p)) {
-        is_zero = 1;
-        runlen = HLL_SPARSE_ZERO_LEN(p);
-    } else if (HLL_SPARSE_IS_XZERO(p)) {
-        is_xzero = 1;
-        runlen = HLL_SPARSE_XZERO_LEN(p);
-    } else {
-        is_val = 1;
-        runlen = HLL_SPARSE_VAL_LEN(p);
-    }
-
-    /* Step 2: After the loop:
-     *
-     * 'first' stores to the index of the first register covered
-     *  by the current opcode, which is pointed by 'p'.
-     *
-     * 'next' ad 'prev' store respectively the next and previous opcode,
-     *  or NULL if the opcode at 'p' is respectively the last or first.
-     *
-     * 'span' is set to the number of registers covered by the current
-     *  opcode.
-     *
-     * There are different cases in order to update the data structure
-     * in place without generating it from scratch:
-     *
-     * A) If it is a VAL opcode already set to a value >= our 'count'
-     *    no update is needed, regardless of the VAL run-length field.
-     *    In this case PFADD returns 0 since no changes are performed.
-     *
-     * B) If it is a VAL opcode with len = 1 (representing only our
-     *    register) and the value is less than 'count', we just update it
-     *    since this is a trivial case. */
-    if (is_val) {
-        oldcount = HLL_SPARSE_VAL_VALUE(p);
-        /* Case A. */
-        if (oldcount >= count) return 0;
-
-        /* Case B. */
-        if (runlen == 1) {
-            HLL_SPARSE_VAL_SET(p,count,1);
-            goto updated;
-        }
-    }
-
-    /* C) Another trivial to handle case is a ZERO opcode with a len of 1.
-     * We can just replace it with a VAL opcode with our value and len of 1. */
-    if (is_zero && runlen == 1) {
-        HLL_SPARSE_VAL_SET(p,count,1);
-        goto updated;
-    }
-
-    /* D) General case.
-     *
-     * The other cases are more complex: our register requires to be updated
-     * and is either currently represented by a VAL opcode with len > 1,
-     * by a ZERO opcode with len > 1, or by an XZERO opcode.
-     *
-     * In those cases the original opcode must be split into multiple
-     * opcodes. The worst case is an XZERO split in the middle resuling into
-     * XZERO - VAL - XZERO, so the resulting sequence max length is
-     * 5 bytes.
-     *
-     * We perform the split writing the new sequence into the 'new' buffer
-     * with 'newlen' as length. Later the new sequence is inserted in place
-     * of the old one, possibly moving what is on the right a few bytes
-     * if the new sequence is longer than the older one. */
-    n = seq;
-    last = first+span-1; /* Last register covered by the sequence. */
-
-    if (is_zero || is_xzero) {
-        /* Handle splitting of ZERO / XZERO. */
-        if (index != first) {
-            len = index-first;
-            if (len > HLL_SPARSE_ZERO_MAX_LEN) {
-                HLL_SPARSE_XZERO_SET(n,len);
-                n += 2;
-            } else {
-                HLL_SPARSE_ZERO_SET(n,len);
-                n++;
-            }
-        }
-        HLL_SPARSE_VAL_SET(n,count,1);
-        n++;
-        if (index != last) {
-            len = last-index;
-            if (len > HLL_SPARSE_ZERO_MAX_LEN) {
-                HLL_SPARSE_XZERO_SET(n,len);
-                n += 2;
-            } else {
-                HLL_SPARSE_ZERO_SET(n,len);
-                n++;
-            }
-        }
-    } else {
-        /* Handle splitting of VAL. */
-        int curval = HLL_SPARSE_VAL_VALUE(p);
-
-        if (index != first) {
-            len = index-first;
-            HLL_SPARSE_VAL_SET(n,curval,len);
-            n++;
-        }
-        HLL_SPARSE_VAL_SET(n,count,1);
-        n++;
-        if (index != last) {
-            len = last-index;
-            HLL_SPARSE_VAL_SET(n,curval,len);
-            n++;
-        }
-    }
-
-    /* Step 3: substitute the new sequence with the old one.
-     *
-     * Note that we already allocated space on the sds string
-     * calling sdsMakeRoomFor(). */
-     seqlen = n-seq;
-     oldlen = is_xzero ? 2 : 1;
-     deltalen = seqlen-oldlen;
-
-     if (deltalen > 0 &&
-         sdslen((sds) o->ptr)+deltalen > HLL_SPARSE_MAX_BYTES) goto promote;
-     if (deltalen && next) memmove(next+deltalen,next,end-next);
-     sdsIncrLen((sds) o->ptr,deltalen);
-     memcpy(p,seq,seqlen);
-     end += deltalen;
-
-updated: {
-    /* Step 4: Merge adjacent values if possible.
-     *
-     * The representation was updated, however the resulting representation
-     * may not be optimal: adjacent VAL opcodes can sometimes be merged into
-     * a single one. */
-    p = prev ? prev : sparse;
-    int scanlen = 5; /* Scan up to 5 upcodes starting from prev. */
-    while (p < end && scanlen--) {
-        if (HLL_SPARSE_IS_XZERO(p)) {
-            p += 2;
-            continue;
-        } else if (HLL_SPARSE_IS_ZERO(p)) {
-            p++;
-            continue;
-        }
-        /* We need two adjacent VAL opcodes to try a merge, having
-         * the same value, and a len that fits the VAL opcode max len. */
-        if (p+1 < end && HLL_SPARSE_IS_VAL(p+1)) {
-            int v1 = HLL_SPARSE_VAL_VALUE(p);
-            int v2 = HLL_SPARSE_VAL_VALUE(p+1);
-            if (v1 == v2) {
-                int len = HLL_SPARSE_VAL_LEN(p)+HLL_SPARSE_VAL_LEN(p+1);
-                if (len <= HLL_SPARSE_VAL_MAX_LEN) {
-                    HLL_SPARSE_VAL_SET(p+1,v1,len);
-                    memmove(p,p+1,end-p);
-                    sdsIncrLen((sds) o->ptr,-1);
-                    end--;
-                    /* After a merge we reiterate without incrementing 'p'
-                     * in order to try to merge the just merged value with
-                     * a value on its right. */
-                    continue;
-                }
-            }
-        }
-        p++;
-    }
-
-    /* Invalidate the cached cardinality. */
-    hdr = (struct hllhdr *) o->ptr;
-    HLL_INVALIDATE_CACHE(hdr);
-    return 1;
-}
-promote: /* Promote to dense representation. */
-    if (hllSparseToDense(o) == HLL_C_ERR) return -1; /* Corrupted HLL. */
-    hdr = (struct hllhdr *) o->ptr;
-
-    /* We need to call hllDenseAdd() to perform the operation after the
-     * conversion. However the result must be 1, since if we need to
-     * convert from sparse to dense a register requires to be updated.
-     *
-     * Note that this in turn means that PFADD will make sure the command
-     * is propagated to slaves / AOF, so if there is a sparse -> dense
-     * conversion, it will be performed in all the slaves as well. */
-    int dense_retval = hllDenseSet(hdr->registers + 1,index,count);
-    assert(dense_retval == 1);
-    return dense_retval;
-}
-
-/* "Add" the element in the sparse hyperloglog data structure.
- * Actually nothing is added, but the max 0 pattern counter of the subset
- * the element belongs to is incremented if needed.
- *
- * This function is actually a wrapper for hllSparseSet(), it only performs
- * the hashshing of the elmenet to obtain the index and zeros run length. */
-int hllSparseAdd(robj *o, unsigned char *ele, size_t elesize) {
-    long index;
-    uint8_t count = hllPatLen(ele,elesize,&index);
-    /* Update the register if this element produced a longer run of zeroes. */
-    return hllSparseSet(o,index,count);
-}
-
-/* Compute the register histogram in the sparse representation. */
-void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* reghisto) {
-    int idx = 0, runlen, regval;
-    uint8_t *end = sparse+sparselen, *p = sparse;
-
-    while(p < end) {
-        if (HLL_SPARSE_IS_ZERO(p)) {
-            runlen = HLL_SPARSE_ZERO_LEN(p);
-            idx += runlen;
-            reghisto[0] += runlen;
-            p++;
-        } else if (HLL_SPARSE_IS_XZERO(p)) {
-            runlen = HLL_SPARSE_XZERO_LEN(p);
-            idx += runlen;
-            reghisto[0] += runlen;
-            p += 2;
-        } else {
-            runlen = HLL_SPARSE_VAL_LEN(p);
-            regval = HLL_SPARSE_VAL_VALUE(p);
-            idx += runlen;
-            reghisto[regval] += runlen;
-            p++;
-        }
-    }
-    if (idx != HLL_REGISTERS && invalid) *invalid = 1;
-}
-
-/* ========================= HyperLogLog Count ==============================
- * This is the core of the algorithm where the approximated count is computed.
- * The function uses the lower level hllDenseRegHisto() and hllSparseRegHisto()
- * functions as helpers to compute histogram of register values part of the
- * computation, which is representation-specific, while all the rest is common. */
-
-/* Implements the register histogram calculation for uint8_t data type
- * which is only used internally as speedup for PFCOUNT with multiple keys. */
-void hllRawRegHisto(uint8_t *registers, int* reghisto) {
-    uint64_t *word = (uint64_t*) registers;
-    uint8_t *bytes;
-    int j;
-
-    for (j = 0; j < HLL_REGISTERS/8; j++) {
-        if (*word == 0) {
-            reghisto[0] += 8;
-        } else {
-            bytes = (uint8_t*) word;
-            reghisto[bytes[0]]++;
-            reghisto[bytes[1]]++;
-            reghisto[bytes[2]]++;
-            reghisto[bytes[3]]++;
-            reghisto[bytes[4]]++;
-            reghisto[bytes[5]]++;
-            reghisto[bytes[6]]++;
-            reghisto[bytes[7]]++;
-        }
-        word++;
-    }
-}
-
-// somehow this is missing on some platforms
-#ifndef INFINITY
-// from math.h
-#define INFINITY 1e50f
-#endif
-
-
-/* Helper function sigma as defined in
- * "New cardinality estimation algorithms for HyperLogLog sketches"
- * Otmar Ertl, arXiv:1702.01284 */
-double hllSigma(double x) {
-    if (x == 1.) return INFINITY;
-    double zPrime;
-    double y = 1;
-    double z = x;
-    do {
-        x *= x;
-        zPrime = z;
-        z += x * y;
-        y += y;
-    } while(zPrime != z);
-    return z;
-}
-
-/* Helper function tau as defined in
- * "New cardinality estimation algorithms for HyperLogLog sketches"
- * Otmar Ertl, arXiv:1702.01284 */
-double hllTau(double x) {
-    if (x == 0. || x == 1.) return 0.;
-    double zPrime;
-    double y = 1.0;
-    double z = 1 - x;
-    do {
-        x = sqrt(x);
-        zPrime = z;
-        y *= 0.5;
-        z -= pow(1 - x, 2)*y;
-    } while(zPrime != z);
-    return z / 3;
-}
-
-/* Return the approximated cardinality of the set based on the harmonic
- * mean of the registers values. 'hdr' points to the start of the SDS
- * representing the String object holding the HLL representation.
- *
- * If the sparse representation of the HLL object is not valid, the integer
- * pointed by 'invalid' is set to non-zero, otherwise it is left untouched.
- *
- * hllCount() supports a special internal-only encoding of HLL_RAW, that
- * is, hdr->registers will point to an uint8_t array of HLL_REGISTERS element.
- * This is useful in order to speedup PFCOUNT when called against multiple
- * keys (no need to work with 6-bit integers encoding). */
-uint64_t hllCount(struct hllhdr *hdr, int *invalid) {
-    double m = HLL_REGISTERS;
-    double E;
-    int j;
-    int reghisto[HLL_Q+2] = {0};
-
-    /* Compute register histogram */
-    if (hdr->encoding == HLL_DENSE) {
-        hllDenseRegHisto(hdr->registers + 1,reghisto);
-    } else if (hdr->encoding == HLL_SPARSE) {
-        hllSparseRegHisto(hdr->registers + 1,
-                         sdslen((sds)hdr)-HLL_HDR_SIZE,invalid,reghisto);
-    } else if (hdr->encoding == HLL_RAW) {
-        hllRawRegHisto(hdr->registers + 1,reghisto);
-    } else {
-		*invalid = 1;
-		return 0;
-        //serverPanic("Unknown HyperLogLog encoding in hllCount()");
-    }
-
-    /* Estimate cardinality form register histogram. See:
-     * "New cardinality estimation algorithms for HyperLogLog sketches"
-     * Otmar Ertl, arXiv:1702.01284 */
-    double z = m * hllTau((m-reghisto[HLL_Q+1])/(double)m);
-    for (j = HLL_Q; j >= 1; --j) {
-        z += reghisto[j];
-        z *= 0.5;
-    }
-    z += m * hllSigma(reghisto[0]/(double)m);
-    E = llroundl(HLL_ALPHA_INF*m*m/z);
-
-    return (uint64_t) E;
-}
-
-/* Call hllDenseAdd() or hllSparseAdd() according to the HLL encoding. */
-int hll_add(robj *o, unsigned char *ele, size_t elesize) {
-    struct hllhdr *hdr = (struct hllhdr *) o->ptr;
-    switch(hdr->encoding) {
-    case HLL_DENSE: return hllDenseAdd(hdr->registers + 1,ele,elesize);
-    case HLL_SPARSE: return hllSparseAdd(o,ele,elesize);
-    default: return -1; /* Invalid representation. */
-    }
-}
-
-/* Merge by computing MAX(registers[i],hll[i]) the HyperLogLog 'hll'
- * with an array of uint8_t HLL_REGISTERS registers pointed by 'max'.
- *
- * The hll object must be already validated via isHLLObjectOrReply()
- * or in some other way.
- *
- * If the HyperLogLog is sparse and is found to be invalid, C_ERR
- * is returned, otherwise the function always succeeds. */
-int hllMerge(uint8_t *max, robj *hll) {
-    struct hllhdr *hdr = (struct hllhdr *) hll->ptr;
-    int i;
-
-    if (hdr->encoding == HLL_DENSE) {
-        uint8_t val;
-
-        for (i = 0; i < HLL_REGISTERS; i++) {
-            HLL_DENSE_GET_REGISTER(val,hdr->registers + 1,i);
-            if (val > max[i]) max[i] = val;
-        }
-    } else {
-        uint8_t *p = (uint8_t *) hll->ptr, *end = p + sdslen((sds) hll->ptr);
-        long runlen, regval;
-
-        p += HLL_HDR_SIZE;
-        i = 0;
-        while(p < end) {
-            if (HLL_SPARSE_IS_ZERO(p)) {
-                runlen = HLL_SPARSE_ZERO_LEN(p);
-                i += runlen;
-                p++;
-            } else if (HLL_SPARSE_IS_XZERO(p)) {
-                runlen = HLL_SPARSE_XZERO_LEN(p);
-                i += runlen;
-                p += 2;
-            } else {
-                runlen = HLL_SPARSE_VAL_LEN(p);
-                regval = HLL_SPARSE_VAL_VALUE(p);
-                while(runlen--) {
-                    if (regval > max[i]) max[i] = regval;
-                    i++;
-                }
-                p++;
-            }
-        }
-        if (i != HLL_REGISTERS) return HLL_C_ERR;
-    }
-    return HLL_C_OK;
-}
-
-/* ========================== robj creation ========================== */
-robj *createObject(void *ptr) {
-	robj *result = (robj*) malloc(sizeof(robj));
-	result->ptr = ptr;
-	return result;
-}
-
-void destroyObject(robj *obj) {
-	free(obj);
-}
-
-/* ========================== HyperLogLog commands ========================== */
-
-/* Create an HLL object. We always create the HLL using sparse encoding.
- * This will be upgraded to the dense representation as needed. */
-robj *hll_create(void) {
-    robj *o;
-    struct hllhdr *hdr;
-    sds s;
-    uint8_t *p;
-    int sparselen = HLL_HDR_SIZE +
-                    (((HLL_REGISTERS+(HLL_SPARSE_XZERO_MAX_LEN-1)) /
-                     HLL_SPARSE_XZERO_MAX_LEN)*2);
-    int aux;
-
-    /* Populate the sparse representation with as many XZERO opcodes as
-     * needed to represent all the registers. */
-    aux = HLL_REGISTERS;
-    s = sdsnewlen(NULL,sparselen);
-    p = (uint8_t*)s + HLL_HDR_SIZE;
-    while(aux) {
-        int xzero = HLL_SPARSE_XZERO_MAX_LEN;
-        if (xzero > aux) xzero = aux;
-        HLL_SPARSE_XZERO_SET(p,xzero);
-        p += 2;
-        aux -= xzero;
-    }
-    assert((p-(uint8_t*)s) == sparselen);
-
-    /* Create the actual object. */
-    o = createObject(s);
-    hdr = (struct hllhdr *) o->ptr;
-    memcpy(hdr->magic,"HYLL",4);
-    hdr->encoding = HLL_SPARSE;
-    return o;
-}
-
-void hll_destroy(robj *obj) {
-	if (!obj) {
-		return;
-	}
-	sdsfree((sds) obj->ptr);
-	destroyObject(obj);
-}
-
-
-
-int hll_count(robj *o, size_t *result) {
-	int invalid = 0;
-	*result = hllCount((struct hllhdr*) o->ptr, &invalid);
-	return invalid == 0 ? HLL_C_OK : HLL_C_ERR;
-}
-
-robj *hll_merge(robj **hlls, size_t hll_count) {
-    uint8_t max[HLL_REGISTERS];
-    struct hllhdr *hdr;
-    size_t j;
-	 /* Use dense representation as target? */
-    int use_dense = 0;
-
-    /* Compute an HLL with M[i] = MAX(M[i]_j).
-     * We store the maximum into the max array of registers. We'll write
-     * it to the target variable later. */
-    memset(max, 0, sizeof(max));
-    for (j = 0; j < hll_count; j++) {
-        /* Check type and size. */
-        robj *o = hlls[j];
-        if (o == NULL) continue; /* Assume empty HLL for non existing var. */
-
-        /* If at least one involved HLL is dense, use the dense representation
-         * as target ASAP to save time and avoid the conversion step. */
-        hdr = (struct hllhdr *) o->ptr;
-        if (hdr->encoding == HLL_DENSE) use_dense = 1;
-
-        /* Merge with this HLL with our 'max' HHL by setting max[i]
-         * to MAX(max[i],hll[i]). */
-        if (hllMerge(max, o) == HLL_C_ERR) {
-            return NULL;
-        }
-    }
-
-    /* Create the destination key's value. */
-    robj *result = hll_create();
-	if (!result) {
-		return NULL;
-	}
-
-    /* Convert the destination object to dense representation if at least
-     * one of the inputs was dense. */
-    if (use_dense && hllSparseToDense(result) == HLL_C_ERR) {
-		hll_destroy(result);
-        return NULL;
-    }
-
-    /* Write the resulting HLL to the destination HLL registers and
-     * invalidate the cached value. */
-    for (j = 0; j < HLL_REGISTERS; j++) {
-        if (max[j] == 0) continue;
-        hdr = (struct hllhdr *) result->ptr;
-        switch(hdr->encoding) {
-        case HLL_DENSE: hllDenseSet(hdr->registers + 1,j,max[j]); break;
-        case HLL_SPARSE: hllSparseSet(result,j,max[j]); break;
-        }
-    }
-	return result;
-}
-
-uint64_t get_size() {
-	return HLL_DENSE_SIZE;
-}
-
-}
-
-namespace duckdb {
-
-static inline int AddToLog(void *log, const uint64_t &index, const uint8_t &count) {
-	auto o = (duckdb_hll::robj *)log;
-	duckdb_hll::hllhdr *hdr = (duckdb_hll::hllhdr *)o->ptr;
-	D_ASSERT(hdr->encoding == HLL_DENSE);
-	return duckdb_hll::hllDenseSet(hdr->registers + 1, index, count);
-}
-
-void AddToLogsInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
-                       const SelectionVector *log_sel) {
-	// 'logs' is an array of pointers to AggregateStates
-	// AggregateStates have a pointer to a HyperLogLog object
-	// HyperLogLog objects have a pointer to a 'robj', which we need
-	for (idx_t i = 0; i < count; i++) {
-		auto log = logs[log_sel->get_index(i)];
-		if (log && vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
-			AddToLog(**log, indices[i], counts[i]);
-		}
-	}
-}
-
-void AddToSingleLogInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log) {
-	const auto o = (duckdb_hll::robj *)log;
-	duckdb_hll::hllhdr *hdr = (duckdb_hll::hllhdr *)o->ptr;
-	D_ASSERT(hdr->encoding == HLL_DENSE);
-
-	const auto registers = hdr->registers + 1;
-	for (idx_t i = 0; i < count; i++) {
-		if (vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
-			duckdb_hll::hllDenseSet(registers, indices[i], counts[i]);
-		}
-	}
-}
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
-// See the end of this file for a list
-
-/* SDSLib 2.0 -- A C dynamic strings library
- *
- * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2015, Oran Agra
- * Copyright (c) 2015, Redis Labs, Inc
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <assert.h>
-#include <limits.h>
-
-
-namespace duckdb_hll {
-
-static inline int sdsHdrSize(char type) {
-    switch(type&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return sizeof(struct sdshdr5);
-        case SDS_TYPE_8:
-            return sizeof(struct sdshdr8);
-        case SDS_TYPE_16:
-            return sizeof(struct sdshdr16);
-        case SDS_TYPE_32:
-            return sizeof(struct sdshdr32);
-        case SDS_TYPE_64:
-            return sizeof(struct sdshdr64);
-    }
-    return 0;
-}
-
-static inline char sdsReqType(size_t string_size) {
-    if (string_size < 1<<5)
-        return SDS_TYPE_5;
-    if (string_size < 1<<8)
-        return SDS_TYPE_8;
-    if (string_size < 1<<16)
-        return SDS_TYPE_16;
-#if (LONG_MAX == LLONG_MAX)
-    if (string_size < 1ll<<32)
-        return SDS_TYPE_32;
-    return SDS_TYPE_64;
-#else
-    return SDS_TYPE_32;
-#endif
-}
-
-/* Create a new sds string with the content specified by the 'init' pointer
- * and 'initlen'.
- * If NULL is used for 'init' the string is initialized with zero bytes.
- * If SDS_NOINIT is used, the buffer is left uninitialized;
- *
- * The string is always null-termined (all the sds strings are, always) so
- * even if you create an sds string with:
- *
- * mystring = sdsnewlen("abc",3);
- *
- * You can print the string with printf() as there is an implicit \0 at the
- * end of the string. However the string is binary safe and can contain
- * \0 characters in the middle, as the length is stored in the sds header. */
-sds sdsnewlen(const void *init, size_t initlen) {
-    void *sh;
-    sds s;
-    char type = sdsReqType(initlen);
-    /* Empty strings are usually created in order to append. Use type 8
-     * since type 5 is not good at this. */
-    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
-    int hdrlen = sdsHdrSize(type);
-    unsigned char *fp; /* flags pointer. */
-
-    sh = malloc(hdrlen+initlen+1);
-    if (!init)
-        memset(sh, 0, hdrlen+initlen+1);
-    if (sh == NULL) return NULL;
-    s = (char*)sh+hdrlen;
-    fp = ((unsigned char*)s)-1;
-    switch(type) {
-        case SDS_TYPE_5: {
-            *fp = type | (initlen << SDS_TYPE_BITS);
-            break;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-    }
-    if (initlen && init)
-        memcpy(s, init, initlen);
-    s[initlen] = '\0';
-    return s;
-}
-
-/* Create an empty (zero length) sds string. Even in this case the string
- * always has an implicit null term. */
-sds sdsempty(void) {
-    return sdsnewlen("",0);
-}
-
-/* Create a new sds string starting from a null terminated C string. */
-sds sdsnew(const char *init) {
-    size_t initlen = (init == NULL) ? 0 : strlen(init);
-    return sdsnewlen(init, initlen);
-}
-
-/* Duplicate an sds string. */
-sds sdsdup(const sds s) {
-    return sdsnewlen(s, sdslen(s));
-}
-
-/* Free an sds string. No operation is performed if 's' is NULL. */
-void sdsfree(sds s) {
-    if (s == NULL) return;
-    free((char*)s-sdsHdrSize(s[-1]));
-}
-
-/* Set the sds string length to the length as obtained with strlen(), so
- * considering as content only up to the first null term character.
- *
- * This function is useful when the sds string is hacked manually in some
- * way, like in the following example:
- *
- * s = sdsnew("foobar");
- * s[2] = '\0';
- * sdsupdatelen(s);
- * printf("%d\n", sdslen(s));
- *
- * The output will be "2", but if we comment out the call to sdsupdatelen()
- * the output will be "6" as the string was modified but the logical length
- * remains 6 bytes. */
-void sdsupdatelen(sds s) {
-    size_t reallen = strlen(s);
-    sdssetlen(s, reallen);
-}
-
-/* Modify an sds string in-place to make it empty (zero length).
- * However all the existing buffer is not discarded but set as free space
- * so that next append operations will not require allocations up to the
- * number of bytes previously available. */
-void sdsclear(sds s) {
-    sdssetlen(s, 0);
-    s[0] = '\0';
-}
-
-/* Enlarge the free space at the end of the sds string so that the caller
- * is sure that after calling this function can overwrite up to addlen
- * bytes after the end of the string, plus one more byte for nul term.
- *
- * Note: this does not change the *length* of the sds string as returned
- * by sdslen(), but only the free buffer space we have. */
-sds sdsMakeRoomFor(sds s, size_t addlen) {
-    void *sh, *newsh;
-    size_t avail = sdsavail(s);
-    size_t len, newlen;
-    char type, oldtype = s[-1] & SDS_TYPE_MASK;
-    int hdrlen;
-
-    /* Return ASAP if there is enough space left. */
-    if (avail >= addlen) return s;
-
-    len = sdslen(s);
-    sh = (char*)s-sdsHdrSize(oldtype);
-    newlen = (len+addlen);
-    if (newlen < SDS_MAX_PREALLOC)
-        newlen *= 2;
-    else
-        newlen += SDS_MAX_PREALLOC;
-
-    type = sdsReqType(newlen);
-
-    /* Don't use type 5: the user is appending to the string and type 5 is
-     * not able to remember empty space, so sdsMakeRoomFor() must be called
-     * at every appending operation. */
-    if (type == SDS_TYPE_5) type = SDS_TYPE_8;
-
-    hdrlen = sdsHdrSize(type);
-    if (oldtype==type) {
-        newsh = realloc(sh, hdrlen+newlen+1);
-        if (newsh == NULL) return NULL;
-        s = (char*)newsh+hdrlen;
-    } else {
-        /* Since the header size changes, need to move the string forward,
-         * and can't use realloc */
-        newsh = malloc(hdrlen+newlen+1);
-        if (newsh == NULL) return NULL;
-        memcpy((char*)newsh+hdrlen, s, len+1);
-        free(sh);
-        s = (char*)newsh+hdrlen;
-        s[-1] = type;
-        sdssetlen(s, len);
-    }
-    sdssetalloc(s, newlen);
-    return s;
-}
-
-/* Reallocate the sds string so that it has no free space at the end. The
- * contained string remains not altered, but next concatenation operations
- * will require a reallocation.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdsRemoveFreeSpace(sds s) {
-    void *sh, *newsh;
-    char type, oldtype = s[-1] & SDS_TYPE_MASK;
-    int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
-    size_t len = sdslen(s);
-    sh = (char*)s-oldhdrlen;
-
-    /* Check what would be the minimum SDS header that is just good enough to
-     * fit this string. */
-    type = sdsReqType(len);
-    hdrlen = sdsHdrSize(type);
-
-    /* If the type is the same, or at least a large enough type is still
-     * required, we just realloc(), letting the allocator to do the copy
-     * only if really needed. Otherwise if the change is huge, we manually
-     * reallocate the string to use the different header type. */
-    if (oldtype==type || type > SDS_TYPE_8) {
-        newsh = realloc(sh, oldhdrlen+len+1);
-        if (newsh == NULL) return NULL;
-        s = (char*)newsh+oldhdrlen;
-    } else {
-        newsh = malloc(hdrlen+len+1);
-        if (newsh == NULL) return NULL;
-        memcpy((char*)newsh+hdrlen, s, len+1);
-        free(sh);
-        s = (char*)newsh+hdrlen;
-        s[-1] = type;
-        sdssetlen(s, len);
-    }
-    sdssetalloc(s, len);
-    return s;
-}
-
-/* Return the total size of the allocation of the specified sds string,
- * including:
- * 1) The sds header before the pointer.
- * 2) The string.
- * 3) The free buffer at the end if any.
- * 4) The implicit null term.
- */
-size_t sdsAllocSize(sds s) {
-    size_t alloc = sdsalloc(s);
-    return sdsHdrSize(s[-1])+alloc+1;
-}
-
-/* Return the pointer of the actual SDS allocation (normally SDS strings
- * are referenced by the start of the string buffer). */
-void *sdsAllocPtr(sds s) {
-    return (void*) (s-sdsHdrSize(s[-1]));
-}
-
-/* Increment the sds length and decrements the left free space at the
- * end of the string according to 'incr'. Also set the null term
- * in the new end of the string.
- *
- * This function is used in order to fix the string length after the
- * user calls sdsMakeRoomFor(), writes something after the end of
- * the current string, and finally needs to set the new length.
- *
- * Note: it is possible to use a negative increment in order to
- * right-trim the string.
- *
- * Usage example:
- *
- * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the
- * following schema, to cat bytes coming from the kernel to the end of an
- * sds string without copying into an intermediate buffer:
- *
- * oldlen = sdslen(s);
- * s = sdsMakeRoomFor(s, BUFFER_SIZE);
- * nread = read(fd, s+oldlen, BUFFER_SIZE);
- * ... check for nread <= 0 and handle it ...
- * sdsIncrLen(s, nread);
- */
-void sdsIncrLen(sds s, ssize_t incr) {
-    unsigned char flags = s[-1];
-    size_t len;
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5: {
-            unsigned char *fp = ((unsigned char*)s)-1;
-            unsigned char oldlen = SDS_TYPE_5_LEN(flags);
-            assert((incr > 0 && oldlen+incr < 32) || (incr < 0 && oldlen >= (unsigned int)(-incr)));
-            *fp = SDS_TYPE_5 | ((oldlen+incr) << SDS_TYPE_BITS);
-            len = oldlen+incr;
-            break;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= (unsigned int)incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= (uint64_t)incr) || (incr < 0 && sh->len >= (uint64_t)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        default: len = 0; /* Just to avoid compilation warnings. */
-    }
-    s[len] = '\0';
-}
-
-/* Grow the sds to have the specified length. Bytes that were not part of
- * the original length of the sds will be set to zero.
- *
- * if the specified length is smaller than the current length, no operation
- * is performed. */
-sds sdsgrowzero(sds s, size_t len) {
-    size_t curlen = sdslen(s);
-
-    if (len <= curlen) return s;
-    s = sdsMakeRoomFor(s,len-curlen);
-    if (s == NULL) return NULL;
-
-    /* Make sure added region doesn't contain garbage */
-    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
-    sdssetlen(s, len);
-    return s;
-}
-
-/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the
- * end of the specified sds string 's'.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatlen(sds s, const void *t, size_t len) {
-    size_t curlen = sdslen(s);
-
-    s = sdsMakeRoomFor(s,len);
-    if (s == NULL) return NULL;
-    memcpy(s+curlen, t, len);
-    sdssetlen(s, curlen+len);
-    s[curlen+len] = '\0';
-    return s;
-}
-
-/* Append the specified null termianted C string to the sds string 's'.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscat(sds s, const char *t) {
-    return sdscatlen(s, t, strlen(t));
-}
-
-/* Append the specified sds 't' to the existing sds 's'.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatsds(sds s, const sds t) {
-    return sdscatlen(s, t, sdslen(t));
-}
-
-/* Destructively modify the sds string 's' to hold the specified binary
- * safe string pointed by 't' of length 'len' bytes. */
-sds sdscpylen(sds s, const char *t, size_t len) {
-    if (sdsalloc(s) < len) {
-        s = sdsMakeRoomFor(s,len-sdslen(s));
-        if (s == NULL) return NULL;
-    }
-    memcpy(s, t, len);
-    s[len] = '\0';
-    sdssetlen(s, len);
-    return s;
-}
-
-/* Like sdscpylen() but 't' must be a null-termined string so that the length
- * of the string is obtained with strlen(). */
-sds sdscpy(sds s, const char *t) {
-    return sdscpylen(s, t, strlen(t));
-}
-
-/* Helper for sdscatlonglong() doing the actual number -> string
- * conversion. 's' must point to a string with room for at least
- * SDS_LLSTR_SIZE bytes.
- *
- * The function returns the length of the null-terminated string
- * representation stored at 's'. */
-#define SDS_LLSTR_SIZE 21
-int sdsll2str(char *s, long long value) {
-    char *p, aux;
-    unsigned long long v;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    v = (value < 0) ? -value : value;
-    p = s;
-    do {
-        *p++ = '0'+(v%10);
-        v /= 10;
-    } while(v);
-    if (value < 0) *p++ = '-';
-
-    /* Compute length and add null term. */
-    l = p-s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while(s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
-    }
-    return l;
-}
-
-/* Identical sdsll2str(), but for unsigned long long type. */
-int sdsull2str(char *s, unsigned long long v) {
-    char *p, aux;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    p = s;
-    do {
-        *p++ = '0'+(v%10);
-        v /= 10;
-    } while(v);
-
-    /* Compute length and add null term. */
-    l = p-s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while(s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
-    }
-    return l;
-}
-
-/* Create an sds string from a long long value. It is much faster than:
- *
- * sdscatprintf(sdsempty(),"%lld\n", value);
- */
-sds sdsfromlonglong(long long value) {
-    char buf[SDS_LLSTR_SIZE];
-    int len = sdsll2str(buf,value);
-
-    return sdsnewlen(buf,len);
-}
-
-/* Like sdscatprintf() but gets va_list instead of being variadic. */
-sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
-    va_list cpy;
-    char staticbuf[1024], *buf = staticbuf, *t;
-    size_t buflen = strlen(fmt)*2;
-
-    /* We try to start using a static buffer for speed.
-     * If not possible we revert to heap allocation. */
-    if (buflen > sizeof(staticbuf)) {
-        buf = (char*) malloc(buflen);
-        if (buf == NULL) return NULL;
-    } else {
-        buflen = sizeof(staticbuf);
-    }
-
-    /* Try with buffers two times bigger every time we fail to
-     * fit the string in the current buffer size. */
-    while(1) {
-        buf[buflen-2] = '\0';
-        va_copy(cpy,ap);
-        vsnprintf(buf, buflen, fmt, cpy);
-        va_end(cpy);
-        if (buf[buflen-2] != '\0') {
-            if (buf != staticbuf) free(buf);
-            buflen *= 2;
-            buf = (char*) malloc(buflen);
-            if (buf == NULL) return NULL;
-            continue;
-        }
-        break;
-    }
-
-    /* Finally concat the obtained string to the SDS string and return it. */
-    t = sdscat(s, buf);
-    if (buf != staticbuf) free(buf);
-    return t;
-}
-
-/* Append to the sds string 's' a string obtained using printf-alike format
- * specifier.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call.
- *
- * Example:
- *
- * s = sdsnew("Sum is: ");
- * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b).
- *
- * Often you need to create a string from scratch with the printf-alike
- * format. When this is the need, just use sdsempty() as the target string:
- *
- * s = sdscatprintf(sdsempty(), "... your format ...", args);
- */
-sds sdscatprintf(sds s, const char *fmt, ...) {
-    va_list ap;
-    char *t;
-    va_start(ap, fmt);
-    t = sdscatvprintf(s,fmt,ap);
-    va_end(ap);
-    return t;
-}
-
-/* This function is similar to sdscatprintf, but much faster as it does
- * not rely on sprintf() family functions implemented by the libc that
- * are often very slow. Moreover directly handling the sds string as
- * new data is concatenated provides a performance improvement.
- *
- * However this function only handles an incompatible subset of printf-alike
- * format specifiers:
- *
- * %s - C String
- * %S - SDS string
- * %i - signed int
- * %I - 64 bit signed integer (long long, int64_t)
- * %u - unsigned int
- * %U - 64 bit unsigned integer (unsigned long long, uint64_t)
- * %% - Verbatim "%" character.
- */
-sds sdscatfmt(sds s, char const *fmt, ...) {
-    size_t initlen = sdslen(s);
-    const char *f = fmt;
-    long i;
-    va_list ap;
-
-    va_start(ap,fmt);
-    f = fmt;    /* Next format specifier byte to process. */
-    i = initlen; /* Position of the next byte to write to dest str. */
-    while(*f) {
-        char next, *str;
-        size_t l;
-        long long num;
-        unsigned long long unum;
-
-        /* Make sure there is always space for at least 1 char. */
-        if (sdsavail(s)==0) {
-            s = sdsMakeRoomFor(s,1);
-        }
-
-        switch(*f) {
-        case '%':
-            next = *(f+1);
-            f++;
-            switch(next) {
-            case 's':
-            case 'S':
-                str = va_arg(ap,char*);
-                l = (next == 's') ? strlen(str) : sdslen(str);
-                if (sdsavail(s) < l) {
-                    s = sdsMakeRoomFor(s,l);
-                }
-                memcpy(s+i,str,l);
-                sdsinclen(s,l);
-                i += l;
-                break;
-            case 'i':
-            case 'I':
-                if (next == 'i')
-                    num = va_arg(ap,int);
-                else
-                    num = va_arg(ap,long long);
-                {
-                    char buf[SDS_LLSTR_SIZE];
-                    l = sdsll2str(buf,num);
-                    if (sdsavail(s) < l) {
-                        s = sdsMakeRoomFor(s,l);
-                    }
-                    memcpy(s+i,buf,l);
-                    sdsinclen(s,l);
-                    i += l;
-                }
-                break;
-            case 'u':
-            case 'U':
-                if (next == 'u')
-                    unum = va_arg(ap,unsigned int);
-                else
-                    unum = va_arg(ap,unsigned long long);
-                {
-                    char buf[SDS_LLSTR_SIZE];
-                    l = sdsull2str(buf,unum);
-                    if (sdsavail(s) < l) {
-                        s = sdsMakeRoomFor(s,l);
-                    }
-                    memcpy(s+i,buf,l);
-                    sdsinclen(s,l);
-                    i += l;
-                }
-                break;
-            default: /* Handle %% and generally %<unknown>. */
-                s[i++] = next;
-                sdsinclen(s,1);
-                break;
-            }
-            break;
-        default:
-            s[i++] = *f;
-            sdsinclen(s,1);
-            break;
-        }
-        f++;
-    }
-    va_end(ap);
-
-    /* Add null-term */
-    s[i] = '\0';
-    return s;
-}
-
-/* Remove the part of the string from left and from right composed just of
- * contiguous characters found in 'cset', that is a null terminted C string.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call.
- *
- * Example:
- *
- * s = sdsnew("AA...AA.a.aa.aHelloWorld     :::");
- * s = sdstrim(s,"Aa. :");
- * printf("%s\n", s);
- *
- * Output will be just "Hello World".
- */
-sds sdstrim(sds s, const char *cset) {
-    char *start, *end, *sp, *ep;
-    size_t len;
-
-    sp = start = s;
-    ep = end = s+sdslen(s)-1;
-    while(sp <= end && strchr(cset, *sp)) sp++;
-    while(ep > sp && strchr(cset, *ep)) ep--;
-    len = (sp > ep) ? 0 : ((ep-sp)+1);
-    if (s != sp) memmove(s, sp, len);
-    s[len] = '\0';
-    sdssetlen(s,len);
-    return s;
-}
-
-/* Turn the string into a smaller (or equal) string containing only the
- * substring specified by the 'start' and 'end' indexes.
- *
- * start and end can be negative, where -1 means the last character of the
- * string, -2 the penultimate character, and so forth.
- *
- * The interval is inclusive, so the start and end characters will be part
- * of the resulting string.
- *
- * The string is modified in-place.
- *
- * Example:
- *
- * s = sdsnew("Hello World");
- * sdsrange(s,1,-1); => "ello World"
- */
-void sdsrange(sds s, ssize_t start, ssize_t end) {
-    size_t newlen, len = sdslen(s);
-
-    if (len == 0) return;
-    if (start < 0) {
-        start = len+start;
-        if (start < 0) start = 0;
-    }
-    if (end < 0) {
-        end = len+end;
-        if (end < 0) end = 0;
-    }
-    newlen = (start > end) ? 0 : (end-start)+1;
-    if (newlen != 0) {
-        if (start >= (ssize_t)len) {
-            newlen = 0;
-        } else if (end >= (ssize_t)len) {
-            end = len-1;
-            newlen = (start > end) ? 0 : (end-start)+1;
-        }
-    } else {
-        start = 0;
-    }
-    if (start && newlen) memmove(s, s+start, newlen);
-    s[newlen] = 0;
-    sdssetlen(s,newlen);
-}
-
-/* Apply tolower() to every character of the sds string 's'. */
-void sdstolower(sds s) {
-    size_t len = sdslen(s), j;
-
-    for (j = 0; j < len; j++) s[j] = tolower(s[j]);
-}
-
-/* Apply toupper() to every character of the sds string 's'. */
-void sdstoupper(sds s) {
-    size_t len = sdslen(s), j;
-
-    for (j = 0; j < len; j++) s[j] = toupper(s[j]);
-}
-
-/* Compare two sds strings s1 and s2 with memcmp().
- *
- * Return value:
- *
- *     positive if s1 > s2.
- *     negative if s1 < s2.
- *     0 if s1 and s2 are exactly the same binary string.
- *
- * If two strings share exactly the same prefix, but one of the two has
- * additional characters, the longer string is considered to be greater than
- * the smaller one. */
-int sdscmp(const sds s1, const sds s2) {
-    size_t l1, l2, minlen;
-    int cmp;
-
-    l1 = sdslen(s1);
-    l2 = sdslen(s2);
-    minlen = (l1 < l2) ? l1 : l2;
-    cmp = memcmp(s1,s2,minlen);
-    if (cmp == 0) return l1>l2? 1: (l1<l2? -1: 0);
-    return cmp;
-}
-
-/* Split 's' with separator in 'sep'. An array
- * of sds strings is returned. *count will be set
- * by reference to the number of tokens returned.
- *
- * On out of memory, zero length string, zero length
- * separator, NULL is returned.
- *
- * Note that 'sep' is able to split a string using
- * a multi-character separator. For example
- * sdssplit("foo_-_bar","_-_"); will return two
- * elements "foo" and "bar".
- *
- * This version of the function is binary-safe but
- * requires length arguments. sdssplit() is just the
- * same function but for zero-terminated strings.
- */
-sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count) {
-    int elements = 0, slots = 5;
-    long start = 0, j;
-    sds *tokens;
-
-    if (seplen < 1 || len < 0) return NULL;
-
-    tokens = (sds*) malloc(sizeof(sds)*slots);
-    if (tokens == NULL) return NULL;
-
-    if (len == 0) {
-        *count = 0;
-        return tokens;
-    }
-    for (j = 0; j < (len-(seplen-1)); j++) {
-        /* make sure there is room for the next element and the final one */
-        if (slots < elements+2) {
-            sds *newtokens;
-
-            slots *= 2;
-            newtokens = (sds*) realloc(tokens,sizeof(sds)*slots);
-            if (newtokens == NULL) goto cleanup;
-            tokens = newtokens;
-        }
-        /* search the separator */
-        if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {
-            tokens[elements] = sdsnewlen(s+start,j-start);
-            if (tokens[elements] == NULL) goto cleanup;
-            elements++;
-            start = j+seplen;
-            j = j+seplen-1; /* skip the separator */
-        }
-    }
-    /* Add the final element. We are sure there is room in the tokens array. */
-    tokens[elements] = sdsnewlen(s+start,len-start);
-    if (tokens[elements] == NULL) goto cleanup;
-    elements++;
-    *count = elements;
-    return tokens;
-
-cleanup:
-    {
-        int i;
-        for (i = 0; i < elements; i++) sdsfree(tokens[i]);
-        free(tokens);
-        *count = 0;
-        return NULL;
-    }
-}
-
-/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */
-void sdsfreesplitres(sds *tokens, int count) {
-    if (!tokens) return;
-    while(count--)
-        sdsfree(tokens[count]);
-    free(tokens);
-}
-
-/* Append to the sds string "s" an escaped string representation where
- * all the non-printable characters (tested with isprint()) are turned into
- * escapes in the form "\n\r\a...." or "\x<hex-number>".
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatrepr(sds s, const char *p, size_t len) {
-    s = sdscatlen(s,"\"",1);
-    while(len--) {
-        switch(*p) {
-        case '\\':
-        case '"':
-            s = sdscatprintf(s,"\\%c",*p);
-            break;
-        case '\n': s = sdscatlen(s,"\\n",2); break;
-        case '\r': s = sdscatlen(s,"\\r",2); break;
-        case '\t': s = sdscatlen(s,"\\t",2); break;
-        case '\a': s = sdscatlen(s,"\\a",2); break;
-        case '\b': s = sdscatlen(s,"\\b",2); break;
-        default:
-            if (isprint(*p))
-                s = sdscatprintf(s,"%c",*p);
-            else
-                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
-            break;
-        }
-        p++;
-    }
-    return sdscatlen(s,"\"",1);
-}
-
-/* Helper function for sdssplitargs() that returns non zero if 'c'
- * is a valid hex digit. */
-int is_hex_digit(char c) {
-    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
-           (c >= 'A' && c <= 'F');
-}
-
-/* Helper function for sdssplitargs() that converts a hex digit into an
- * integer from 0 to 15 */
-int hex_digit_to_int(char c) {
-    switch(c) {
-    case '0': return 0;
-    case '1': return 1;
-    case '2': return 2;
-    case '3': return 3;
-    case '4': return 4;
-    case '5': return 5;
-    case '6': return 6;
-    case '7': return 7;
-    case '8': return 8;
-    case '9': return 9;
-    case 'a': case 'A': return 10;
-    case 'b': case 'B': return 11;
-    case 'c': case 'C': return 12;
-    case 'd': case 'D': return 13;
-    case 'e': case 'E': return 14;
-    case 'f': case 'F': return 15;
-    default: return 0;
-    }
-}
-
-/* Split a line into arguments, where every argument can be in the
- * following programming-language REPL-alike form:
- *
- * foo bar "newline are supported\n" and "\xff\x00otherstuff"
- *
- * The number of arguments is stored into *argc, and an array
- * of sds is returned.
- *
- * The caller should free the resulting array of sds strings with
- * sdsfreesplitres().
- *
- * Note that sdscatrepr() is able to convert back a string into
- * a quoted string in the same format sdssplitargs() is able to parse.
- *
- * The function returns the allocated tokens on success, even when the
- * input string is empty, or NULL if the input contains unbalanced
- * quotes or closed quotes followed by non space characters
- * as in: "foo"bar or "foo'
- */
-sds *sdssplitargs(const char *line, int *argc) {
-    const char *p = line;
-    char *current = NULL;
-    char **vector = NULL;
-
-    *argc = 0;
-    while(1) {
-        /* skip blanks */
-        while(*p && isspace(*p)) p++;
-        if (*p) {
-            /* get a token */
-            int inq=0;  /* set to 1 if we are in "quotes" */
-            int insq=0; /* set to 1 if we are in 'single quotes' */
-            int done=0;
-
-            if (current == NULL) current = sdsempty();
-            while(!done) {
-                if (inq) {
-                    if (*p == '\\' && *(p+1) == 'x' &&
-                                             is_hex_digit(*(p+2)) &&
-                                             is_hex_digit(*(p+3)))
-                    {
-                        unsigned char byte;
-
-                        byte = (hex_digit_to_int(*(p+2))*16)+
-                                hex_digit_to_int(*(p+3));
-                        current = sdscatlen(current,(char*)&byte,1);
-                        p += 3;
-                    } else if (*p == '\\' && *(p+1)) {
-                        char c;
-
-                        p++;
-                        switch(*p) {
-                        case 'n': c = '\n'; break;
-                        case 'r': c = '\r'; break;
-                        case 't': c = '\t'; break;
-                        case 'b': c = '\b'; break;
-                        case 'a': c = '\a'; break;
-                        default: c = *p; break;
-                        }
-                        current = sdscatlen(current,&c,1);
-                    } else if (*p == '"') {
-                        /* closing quote must be followed by a space or
-                         * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
-                        done=1;
-                    } else if (!*p) {
-                        /* unterminated quotes */
-                        goto err;
-                    } else {
-                        current = sdscatlen(current,p,1);
-                    }
-                } else if (insq) {
-                    if (*p == '\\' && *(p+1) == '\'') {
-                        p++;
-                        current = sdscatlen(current,"'",1);
-                    } else if (*p == '\'') {
-                        /* closing quote must be followed by a space or
-                         * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
-                        done=1;
-                    } else if (!*p) {
-                        /* unterminated quotes */
-                        goto err;
-                    } else {
-                        current = sdscatlen(current,p,1);
-                    }
-                } else {
-                    switch(*p) {
-                    case ' ':
-                    case '\n':
-                    case '\r':
-                    case '\t':
-                    case '\0':
-                        done=1;
-                        break;
-                    case '"':
-                        inq=1;
-                        break;
-                    case '\'':
-                        insq=1;
-                        break;
-                    default:
-                        current = sdscatlen(current,p,1);
-                        break;
-                    }
-                }
-                if (*p) p++;
-            }
-            /* add the token to the vector */
-            vector = (char**) realloc(vector,((*argc)+1)*sizeof(char*));
-            vector[*argc] = current;
-            (*argc)++;
-            current = NULL;
-        } else {
-            /* Even on empty input string return something not NULL. */
-            if (vector == NULL) vector = (char**) malloc(sizeof(void*));
-            return vector;
-        }
-    }
-
-err:
-    while((*argc)--)
-        sdsfree(vector[*argc]);
-    free(vector);
-    if (current) sdsfree(current);
-    *argc = 0;
-    return NULL;
-}
-
-/* Modify the string substituting all the occurrences of the set of
- * characters specified in the 'from' string to the corresponding character
- * in the 'to' array.
- *
- * For instance: sdsmapchars(mystring, "ho", "01", 2)
- * will have the effect of turning the string "hello" into "0ell1".
- *
- * The function returns the sds string pointer, that is always the same
- * as the input pointer since no resize is needed. */
-sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) {
-    size_t j, i, l = sdslen(s);
-
-    for (j = 0; j < l; j++) {
-        for (i = 0; i < setlen; i++) {
-            if (s[j] == from[i]) {
-                s[j] = to[i];
-                break;
-            }
-        }
-    }
-    return s;
-}
-
-/* Join an array of C strings using the specified separator (also a C string).
- * Returns the result as an sds string. */
-sds sdsjoin(char **argv, int argc, char *sep) {
-    sds join = sdsempty();
-    int j;
-
-    for (j = 0; j < argc; j++) {
-        join = sdscat(join, argv[j]);
-        if (j != argc-1) join = sdscat(join,sep);
-    }
-    return join;
-}
-
-/* Like sdsjoin, but joins an array of SDS strings. */
-sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) {
-    sds join = sdsempty();
-    int j;
-
-    for (j = 0; j < argc; j++) {
-        join = sdscatsds(join, argv[j]);
-        if (j != argc-1) join = sdscatlen(join,sep,seplen);
-    }
-    return join;
-}
-
-/* Wrappers to the allocators used by SDS. Note that SDS will actually
- * just use the macros defined into sdsalloc.h in order to avoid to pay
- * the overhead of function calls. Here we define these wrappers only for
- * the programs SDS is linked to, if they want to touch the SDS internals
- * even if they use a different allocator. */
-void *sdmalloc(size_t size) { return malloc(size); }
-void *sdrealloc(void *ptr, size_t size) { return realloc(ptr,size); }
-void sdfree(void *ptr) { free(ptr); }
-
-}
-
-// LICENSE_CHANGE_END
diff --git a/velox/external/duckdb/duckdb-internal.hpp b/velox/external/duckdb/duckdb-internal.hpp
deleted file mode 100644
index 6d1cbbf5b2702..0000000000000
--- a/velox/external/duckdb/duckdb-internal.hpp
+++ /dev/null
@@ -1,59771 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_search_path.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <functional>
-
-
-
-
-
-namespace duckdb {
-
-class ClientContext;
-
-//! The schema search path, in order by which entries are searched if no schema entry is provided
-class CatalogSearchPath {
-public:
-	DUCKDB_API explicit CatalogSearchPath(ClientContext &client_p);
-	CatalogSearchPath(const CatalogSearchPath &other) = delete;
-
-	DUCKDB_API void Set(const string &new_value, bool is_set_schema);
-	DUCKDB_API const vector<string> &Get();
-	DUCKDB_API const vector<string> &GetSetPaths() {
-		return set_paths;
-	}
-	DUCKDB_API const string &GetDefault();
-	DUCKDB_API const string &GetOrDefault(const string &name);
-
-private:
-	static vector<string> ParsePaths(const string &value);
-
-	void SetPaths(vector<string> new_paths);
-
-private:
-	ClientContext &context;
-	vector<string> paths;
-	//! Only the paths that were explicitly set (minus the always included paths)
-	vector<string> set_paths;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! An aggregate function in the catalog
-class AggregateFunctionCatalogEntry : public StandardEntry {
-public:
-	AggregateFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateAggregateFunctionInfo *info)
-	    : StandardEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, schema, catalog, info->name),
-	      functions(info->functions.functions) {
-	}
-
-	//! The aggregate functions
-	vector<AggregateFunction> functions;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/collate_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! A collation catalog entry
-class CollateCatalogEntry : public StandardEntry {
-public:
-	CollateCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateCollationInfo *info)
-	    : StandardEntry(CatalogType::COLLATION_ENTRY, schema, catalog, info->name), function(info->function),
-	      combinable(info->combinable), not_required_for_equality(info->not_required_for_equality) {
-	}
-
-	//! The collation function to push in case collation is required
-	ScalarFunction function;
-	//! Whether or not the collation can be combined with other collations.
-	bool combinable;
-	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
-	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
-	//! speeds up processing.
-	bool not_required_for_equality;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class Catalog;
-struct CreateCopyFunctionInfo;
-
-//! A table function in the catalog
-class CopyFunctionCatalogEntry : public StandardEntry {
-public:
-	CopyFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateCopyFunctionInfo *info);
-
-	//! The copy function
-	CopyFunction function;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/index_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct DataTableInfo;
-class Index;
-
-//! An index catalog entry
-class IndexCatalogEntry : public StandardEntry {
-public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	IndexCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info);
-	~IndexCatalogEntry() override;
-
-	Index *index;
-	shared_ptr<DataTableInfo> info;
-	string sql;
-
-public:
-	string ToSQL() override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/macro_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/macro_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! A macro function in the catalog
-class MacroCatalogEntry : public StandardEntry {
-public:
-	MacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
-	//! The macro function
-	unique_ptr<MacroFunction> function;
-
-public:
-	//! Serialize the meta information
-	virtual void Serialize(Serializer &serializer) = 0;
-
-	string ToSQL() override {
-		return function->ToSQL(schema->name, name);
-	}
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//! A macro function in the catalog
-class ScalarMacroCatalogEntry : public MacroCatalogEntry {
-public:
-	ScalarMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
-
-public:
-	//! Serialize the meta information of the ScalarMacroCatalogEntry
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes to a CreateMacroInfo
-	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class Catalog;
-struct CreatePragmaFunctionInfo;
-
-//! A table function in the catalog
-class PragmaFunctionCatalogEntry : public StandardEntry {
-public:
-	PragmaFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreatePragmaFunctionInfo *info);
-
-	//! The pragma functions
-	vector<PragmaFunction> functions;
-};
-} // namespace duckdb
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/view_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class DataTable;
-struct CreateViewInfo;
-
-//! A view catalog entry
-class ViewCatalogEntry : public StandardEntry {
-public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	ViewCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateViewInfo *info);
-
-	//! The query of the view
-	unique_ptr<SelectStatement> query;
-	//! The SQL query (if any)
-	string sql;
-	//! The set of aliases associated with the view
-	vector<string> aliases;
-	//! The returned types of the view
-	vector<LogicalType> types;
-
-public:
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
-
-	//! Serialize the meta information of the ViewCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &source);
-
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
-
-	string ToSQL() override;
-
-private:
-	void Initialize(CreateViewInfo *info);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_schemas.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class DefaultSchemaGenerator : public DefaultGenerator {
-public:
-	explicit DefaultSchemaGenerator(Catalog &catalog);
-
-public:
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/dependency_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/dependency.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class CatalogEntry;
-
-enum class DependencyType {
-	DEPENDENCY_REGULAR = 0,
-	DEPENDENCY_AUTOMATIC = 1,
-	DEPENDENCY_OWNS = 2,
-	DEPENDENCY_OWNED_BY = 3
-};
-
-struct Dependency {
-	Dependency(CatalogEntry *entry, DependencyType dependency_type = DependencyType::DEPENDENCY_REGULAR)
-	    : // NOLINT: Allow implicit conversion from `CatalogEntry`
-	      entry(entry), dependency_type(dependency_type) {
-	}
-
-	//! The catalog entry this depends on
-	CatalogEntry *entry;
-	//! The type of dependency
-	DependencyType dependency_type;
-};
-
-struct DependencyHashFunction {
-	uint64_t operator()(const Dependency &a) const {
-		std::hash<void *> hash_func;
-		return hash_func((void *)a.entry);
-	}
-};
-
-struct DependencyEquality {
-	bool operator()(const Dependency &a, const Dependency &b) const {
-		return a.entry == b.entry;
-	}
-};
-
-using dependency_set_t = unordered_set<Dependency, DependencyHashFunction, DependencyEquality>;
-
-} // namespace duckdb
-
-
-#include <functional>
-
-namespace duckdb {
-class Catalog;
-class ClientContext;
-
-//! The DependencyManager is in charge of managing dependencies between catalog entries
-class DependencyManager {
-	friend class CatalogSet;
-
-public:
-	explicit DependencyManager(Catalog &catalog);
-
-	//! Erase the object from the DependencyManager; this should only happen when the object itself is destroyed
-	void EraseObject(CatalogEntry *object);
-
-	//! Scans all dependencies, returning pairs of (object, dependent)
-	void Scan(const std::function<void(CatalogEntry *, CatalogEntry *, DependencyType)> &callback);
-
-	void AddOwnership(ClientContext &context, CatalogEntry *owner, CatalogEntry *entry);
-
-private:
-	Catalog &catalog;
-	//! Map of objects that DEPEND on [object], i.e. [object] can only be deleted when all entries in the dependency map
-	//! are deleted.
-	unordered_map<CatalogEntry *, dependency_set_t> dependents_map;
-	//! Map of objects that the source object DEPENDS on, i.e. when any of the entries in the vector perform a CASCADE
-	//! drop then [object] is deleted as well
-	unordered_map<CatalogEntry *, unordered_set<CatalogEntry *>> dependencies_map;
-
-private:
-	void AddObject(ClientContext &context, CatalogEntry *object, unordered_set<CatalogEntry *> &dependencies);
-	void DropObject(ClientContext &context, CatalogEntry *object, bool cascade);
-	void AlterObject(ClientContext &context, CatalogEntry *old_obj, CatalogEntry *new_obj);
-	void EraseObjectInternal(CatalogEntry *object);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/type_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-
-//! A type catalog entry
-class TypeCatalogEntry : public StandardEntry {
-public:
-	//! Create a TypeCatalogEntry and initialize storage for it
-	TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info);
-
-	LogicalType user_type;
-
-public:
-	//! Serialize the meta information of the TypeCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
-	//! Deserializes to a TypeCatalogEntry
-	static unique_ptr<CreateTypeInfo> Deserialize(Deserializer &source);
-
-	string ToSQL() override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class BufferedFileWriter;
-class ClientContext;
-class CatalogSearchPath;
-class FileOpener;
-class QueryProfiler;
-class QueryProfilerHistory;
-class PreparedStatementData;
-class SchemaCatalogEntry;
-struct RandomEngine;
-
-struct ClientData {
-	ClientData(ClientContext &context);
-	~ClientData();
-
-	//! Query profiler
-	shared_ptr<QueryProfiler> profiler;
-	//! QueryProfiler History
-	unique_ptr<QueryProfilerHistory> query_profiler_history;
-
-	//! The set of temporary objects that belong to this client
-	unique_ptr<SchemaCatalogEntry> temporary_objects;
-	//! The set of bound prepared statements that belong to this client
-	unordered_map<string, shared_ptr<PreparedStatementData>> prepared_statements;
-
-	//! The writer used to log queries (if logging is enabled)
-	unique_ptr<BufferedFileWriter> log_query_writer;
-	//! The random generator used by random(). Its seed value can be set by setseed().
-	unique_ptr<RandomEngine> random_engine;
-
-	//! The catalog search path
-	const unique_ptr<CatalogSearchPath> catalog_search_path;
-
-	//! The file opener of the client context
-	unique_ptr<FileOpener> file_opener;
-
-	//! The file search path
-	string file_search_path;
-
-public:
-	DUCKDB_API static ClientData &Get(ClientContext &context);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_types.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-class DefaultTypeGenerator : public DefaultGenerator {
-public:
-	DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry *schema);
-
-	SchemaCatalogEntry *schema;
-
-public:
-	DUCKDB_API static LogicalTypeId GetDefaultType(const string &name);
-
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/macro_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! A macro function in the catalog
-class TableMacroCatalogEntry : public MacroCatalogEntry {
-public:
-	TableMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
-
-public:
-	//! Serialize the meta information of the ScalarMacroCatalogEntry
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes to a CreateMacroInfo
-	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/field_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-#include <type_traits>
-
-namespace duckdb {
-class BufferedSerializer;
-
-class FieldWriter {
-public:
-	FieldWriter(Serializer &serializer);
-	~FieldWriter();
-
-public:
-	template <class T>
-	void WriteField(const T &element) {
-		static_assert(std::is_trivially_destructible<T>(), "WriteField object must be trivially destructible");
-
-		AddField();
-		WriteData((const_data_ptr_t)&element, sizeof(T));
-	}
-
-	//! Write a string with a length prefix
-	void WriteString(const string &val) {
-		WriteStringLen((const_data_ptr_t)val.c_str(), val.size());
-	}
-	void WriteStringLen(const_data_ptr_t val, idx_t len) {
-		AddField();
-		Write<uint32_t>((uint32_t)len);
-		if (len > 0) {
-			WriteData(val, len);
-		}
-	}
-	void WriteBlob(const_data_ptr_t val, idx_t len) {
-		AddField();
-		if (len > 0) {
-			WriteData(val, len);
-		}
-	}
-
-	template <class T, class CONTAINER_TYPE = vector<T>>
-	void WriteList(const CONTAINER_TYPE &elements) {
-		AddField();
-		Write<uint32_t>(elements.size());
-		for (auto &element : elements) {
-			Write<T>(element);
-		}
-	}
-
-	template <class T>
-	void WriteSerializable(const T &element) {
-		AddField();
-		element.Serialize(*buffer);
-	}
-
-	template <class T>
-	void WriteSerializableList(const vector<unique_ptr<T>> &elements) {
-		AddField();
-		Write<uint32_t>(elements.size());
-		for (idx_t i = 0; i < elements.size(); i++) {
-			elements[i]->Serialize(*buffer);
-		}
-	}
-
-	template <class T>
-	void WriteRegularSerializableList(const vector<T> &elements) {
-		AddField();
-		Write<uint32_t>(elements.size());
-		for (idx_t i = 0; i < elements.size(); i++) {
-			elements[i].Serialize(*buffer);
-		}
-	}
-
-	template <class T>
-	void WriteOptional(const unique_ptr<T> &element) {
-		AddField();
-		Write<bool>(element ? true : false);
-		if (element) {
-			element->Serialize(*buffer);
-		}
-	}
-
-	// Called after all fields have been written. Should always be called.
-	void Finalize();
-
-	Serializer &GetSerializer() {
-		return *buffer;
-	}
-
-private:
-	void AddField() {
-		field_count++;
-	}
-
-	template <class T>
-	void Write(const T &element) {
-		WriteData((const_data_ptr_t)&element, sizeof(T));
-	}
-
-	void WriteData(const_data_ptr_t buffer, idx_t write_size);
-
-private:
-	Serializer &serializer;
-	unique_ptr<BufferedSerializer> buffer;
-	idx_t field_count;
-	bool finalized;
-};
-
-template <>
-void FieldWriter::Write(const string &val);
-
-class FieldDeserializer : public Deserializer {
-public:
-	FieldDeserializer(Deserializer &root);
-
-public:
-	void ReadData(data_ptr_t buffer, idx_t read_size) override;
-
-	void SetRemainingData(idx_t remaining_data);
-	idx_t RemainingData();
-
-private:
-	Deserializer &root;
-	idx_t remaining_data;
-};
-
-class FieldReader {
-public:
-	FieldReader(Deserializer &source);
-	~FieldReader();
-
-public:
-	template <class T>
-	T ReadRequired() {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read a required field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		return source.Read<T>();
-	}
-
-	template <class T>
-	T ReadField(T default_value) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			return default_value;
-		}
-		// field is there, read the actual value
-		AddField();
-		return source.Read<T>();
-	}
-
-	template <class T>
-	vector<T> ReadRequiredList() {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read a required field, but field is missing");
-		}
-		AddField();
-		auto result_count = source.Read<uint32_t>();
-		vector<T> result;
-		for (idx_t i = 0; i < result_count; i++) {
-			result.push_back(source.Read<T>());
-		}
-		return result;
-	}
-
-	template <class T>
-	unique_ptr<T> ReadOptional(unique_ptr<T> default_value) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			return default_value;
-		}
-		// field is there, read the actual value
-		AddField();
-		return source.template ReadOptional<T>();
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			return default_value;
-		}
-		// field is there, read the actual value
-		AddField();
-		return T::Deserialize(source);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&...args) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			return default_value;
-		}
-		// field is there, read the actual value
-		AddField();
-		return T::Deserialize(source, std::forward<ARGS>(args)...);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>>
-	RETURN_TYPE ReadRequiredSerializable() {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			throw SerializationException("Attempting to read mandatory field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		return T::Deserialize(source);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadRequiredSerializable(ARGS &&...args) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			throw SerializationException("Attempting to read mandatory field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		return T::Deserialize(source, std::forward<ARGS>(args)...);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>>
-	vector<RETURN_TYPE> ReadRequiredSerializableList() {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			throw SerializationException("Attempting to read mandatory field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		auto result_count = source.Read<uint32_t>();
-
-		vector<RETURN_TYPE> result;
-		for (idx_t i = 0; i < result_count; i++) {
-			result.push_back(T::Deserialize(source));
-		}
-		return result;
-	}
-	void ReadBlob(data_ptr_t result, idx_t read_size) {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read a required field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		source.ReadData(result, read_size);
-	}
-
-	//! Called after all fields have been read. Should always be called.
-	void Finalize();
-
-	Deserializer &GetSource() {
-		return source;
-	}
-
-private:
-	void AddField() {
-		field_count++;
-	}
-
-private:
-	FieldDeserializer source;
-	idx_t field_count;
-	idx_t max_field_count;
-	idx_t total_size;
-	bool finalized;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar_macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-//! The SelectStatement of the view
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class ScalarMacroFunction : public MacroFunction {
-public:
-	ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
-
-	ScalarMacroFunction(void);
-	//! The macro expression
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	unique_ptr<MacroFunction> Copy() override;
-
-	string ToSQL(const string &schema, const string &name) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table_macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class TableMacroFunction : public MacroFunction {
-public:
-	TableMacroFunction(unique_ptr<QueryNode> query_node);
-	TableMacroFunction(void);
-
-	//! The main query node
-	unique_ptr<QueryNode> query_node;
-
-public:
-	unique_ptr<MacroFunction> Copy() override;
-
-	string ToSQL(const string &schema, const string &name) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-struct DefaultMacro {
-	const char *schema;
-	const char *name;
-	const char *parameters[8];
-	const char *macro;
-};
-
-class DefaultFunctionGenerator : public DefaultGenerator {
-public:
-	DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry *schema);
-
-	SchemaCatalogEntry *schema;
-
-	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalMacroInfo(DefaultMacro &default_macro);
-	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(DefaultMacro &default_macro);
-
-public:
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-
-private:
-	static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(DefaultMacro &default_macro,
-	                                                                unique_ptr<MacroFunction> function);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_views.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-class DefaultViewGenerator : public DefaultGenerator {
-public:
-	DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry *schema);
-
-	SchemaCatalogEntry *schema;
-
-public:
-	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
-	vector<string> GetDefaultEntries() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/constraints/bound_foreign_key_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundForeignKeyConstraint : public BoundConstraint {
-public:
-	BoundForeignKeyConstraint(ForeignKeyInfo info_p, unordered_set<idx_t> pk_key_set_p,
-	                          unordered_set<idx_t> fk_key_set_p)
-	    : BoundConstraint(ConstraintType::FOREIGN_KEY), info(move(info_p)), pk_key_set(move(pk_key_set_p)),
-	      fk_key_set(move(fk_key_set_p)) {
-#ifdef DEBUG
-		D_ASSERT(info.pk_keys.size() == pk_key_set.size());
-		for (auto &key : info.pk_keys) {
-			D_ASSERT(pk_key_set.find(key) != pk_key_set.end());
-		}
-		D_ASSERT(info.fk_keys.size() == fk_key_set.size());
-		for (auto &key : info.fk_keys) {
-			D_ASSERT(fk_key_set.find(key) != fk_key_set.end());
-		}
-#endif
-	}
-
-	ForeignKeyInfo info;
-	//! The same keys but stored as an unordered set
-	unordered_set<idx_t> pk_key_set;
-	//! The same keys but stored as an unordered set
-	unordered_set<idx_t> fk_key_set;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/foreign_key_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class ForeignKeyConstraint : public Constraint {
-public:
-	DUCKDB_API ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info);
-
-	//! The set of main key table's columns
-	vector<string> pk_columns;
-	//! The set of foreign key table's columns
-	vector<string> fk_columns;
-	ForeignKeyInfo info;
-
-public:
-	DUCKDB_API string ToString() const override;
-
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-
-	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a ParsedConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/algorithm.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <algorithm>
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/check_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The CheckConstraint contains an expression that must evaluate to TRUE for
-//! every row in a table
-class CheckConstraint : public Constraint {
-public:
-	DUCKDB_API explicit CheckConstraint(unique_ptr<ParsedExpression> expression);
-
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	DUCKDB_API string ToString() const override;
-
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-
-	DUCKDB_API void Serialize(FieldWriter &writer) const override;
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/unique_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class UniqueConstraint : public Constraint {
-public:
-	DUCKDB_API UniqueConstraint(uint64_t index, bool is_primary_key);
-	DUCKDB_API UniqueConstraint(vector<string> columns, bool is_primary_key);
-
-	//! The index of the column for which this constraint holds. Only used when the constraint relates to a single
-	//! column, equal to DConstants::INVALID_INDEX if not used
-	uint64_t index;
-	//! The set of columns for which this constraint holds by name. Only used when the index field is not used.
-	vector<string> columns;
-	//! Whether or not this is a PRIMARY KEY constraint, or a UNIQUE constraint.
-	bool is_primary_key;
-
-public:
-	DUCKDB_API string ToString() const override;
-
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-
-	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a ParsedConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/constraints/bound_not_null_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BoundNotNullConstraint : public BoundConstraint {
-public:
-	explicit BoundNotNullConstraint(column_t index) : BoundConstraint(ConstraintType::NOT_NULL), index(index) {
-	}
-
-	//! Column index this constraint pertains to
-	storage_t index;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/constraints/bound_unique_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundUniqueConstraint : public BoundConstraint {
-public:
-	BoundUniqueConstraint(vector<idx_t> keys, unordered_set<idx_t> key_set, bool is_primary_key)
-	    : BoundConstraint(ConstraintType::UNIQUE), keys(move(keys)), key_set(move(key_set)),
-	      is_primary_key(is_primary_key) {
-#ifdef DEBUG
-		D_ASSERT(keys.size() == key_set.size());
-		for (auto &key : keys) {
-			D_ASSERT(key_set.find(key) != key_set.end());
-		}
-#endif
-	}
-
-	//! The keys that define the unique constraint
-	vector<idx_t> keys;
-	//! The same keys but stored as an unordered set
-	unordered_set<idx_t> key_set;
-	//! Whether or not the unique constraint is a primary key
-	bool is_primary_key;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/constraints/bound_check_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The CheckConstraint contains an expression that must evaluate to TRUE for
-//! every row in a table
-class BoundCheckConstraint : public BoundConstraint {
-public:
-	BoundCheckConstraint() : BoundConstraint(ConstraintType::CHECK) {
-	}
-
-	//! The expression
-	unique_ptr<Expression> expression;
-	//! The columns used by the CHECK constraint
-	unordered_set<column_t> bound_columns;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/write_ahead_log.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/wal_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class WALType : uint8_t {
-	INVALID = 0,
-	// -----------------------------
-	// Catalog
-	// -----------------------------
-	CREATE_TABLE = 1,
-	DROP_TABLE = 2,
-
-	CREATE_SCHEMA = 3,
-	DROP_SCHEMA = 4,
-
-	CREATE_VIEW = 5,
-	DROP_VIEW = 6,
-
-	CREATE_SEQUENCE = 8,
-	DROP_SEQUENCE = 9,
-	SEQUENCE_VALUE = 10,
-
-	CREATE_MACRO = 11,
-	DROP_MACRO = 12,
-
-	CREATE_TYPE = 13,
-	DROP_TYPE = 14,
-
-	ALTER_INFO = 20,
-
-	CREATE_TABLE_MACRO = 21,
-	DROP_TABLE_MACRO = 22,
-
-	// -----------------------------
-	// Data
-	// -----------------------------
-	USE_TABLE = 25,
-	INSERT_TUPLE = 26,
-	DELETE_TUPLE = 27,
-	UPDATE_TUPLE = 28,
-	// -----------------------------
-	// Flush
-	// -----------------------------
-	CHECKPOINT = 99,
-	WAL_FLUSH = 100
-};
-}
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct AlterInfo;
-
-class BufferedSerializer;
-class Catalog;
-class DatabaseInstance;
-class SchemaCatalogEntry;
-class SequenceCatalogEntry;
-class ScalarMacroCatalogEntry;
-class ViewCatalogEntry;
-class TypeCatalogEntry;
-class TableCatalogEntry;
-class Transaction;
-class TransactionManager;
-
-//! The WriteAheadLog (WAL) is a log that is used to provide durability. Prior
-//! to committing a transaction it writes the changes the transaction made to
-//! the database to the log, which can then be replayed upon startup in case the
-//! server crashes or is shut down.
-class WriteAheadLog {
-public:
-	explicit WriteAheadLog(DatabaseInstance &database);
-
-	//! Whether or not the WAL has been initialized
-	bool initialized;
-	//! Skip writing to the WAL
-	bool skip_writing;
-
-public:
-	//! Replay the WAL
-	static bool Replay(DatabaseInstance &database, string &path);
-
-	//! Initialize the WAL in the specified directory
-	void Initialize(string &path);
-	//! Returns the current size of the WAL in bytes
-	int64_t GetWALSize();
-	//! Gets the total bytes written to the WAL since startup
-	idx_t GetTotalWritten();
-
-	void WriteCreateTable(TableCatalogEntry *entry);
-	void WriteDropTable(TableCatalogEntry *entry);
-
-	void WriteCreateSchema(SchemaCatalogEntry *entry);
-	void WriteDropSchema(SchemaCatalogEntry *entry);
-
-	void WriteCreateView(ViewCatalogEntry *entry);
-	void WriteDropView(ViewCatalogEntry *entry);
-
-	void WriteCreateSequence(SequenceCatalogEntry *entry);
-	void WriteDropSequence(SequenceCatalogEntry *entry);
-	void WriteSequenceValue(SequenceCatalogEntry *entry, SequenceValue val);
-
-	void WriteCreateMacro(ScalarMacroCatalogEntry *entry);
-	void WriteDropMacro(ScalarMacroCatalogEntry *entry);
-
-	void WriteCreateTableMacro(TableMacroCatalogEntry *entry);
-	void WriteDropTableMacro(TableMacroCatalogEntry *entry);
-
-	void WriteCreateType(TypeCatalogEntry *entry);
-	void WriteDropType(TypeCatalogEntry *entry);
-	//! Sets the table used for subsequent insert/delete/update commands
-	void WriteSetTable(string &schema, string &table);
-
-	void WriteAlter(AlterInfo &info);
-
-	void WriteInsert(DataChunk &chunk);
-	void WriteDelete(DataChunk &chunk);
-	//! Write a single (sub-) column update to the WAL. Chunk must be a pair of (COL, ROW_ID).
-	//! The column_path vector is a *path* towards a column within the table
-	//! i.e. if we have a table with a single column S STRUCT(A INT, B INT)
-	//! and we update the validity mask of "S.B"
-	//! the column path is:
-	//! 0 (first column of table)
-	//! -> 1 (second subcolumn of struct)
-	//! -> 0 (first subcolumn of INT)
-	void WriteUpdate(DataChunk &chunk, const vector<column_t> &column_path);
-
-	//! Truncate the WAL to a previous size, and clear anything currently set in the writer
-	void Truncate(int64_t size);
-	//! Delete the WAL file on disk. The WAL should not be used after this point.
-	void Delete();
-	void Flush();
-
-	void WriteCheckpoint(block_id_t meta_block);
-
-private:
-	DatabaseInstance &database;
-	unique_ptr<BufferedFileWriter> writer;
-	string wal_path;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class BlockManager;
-class Catalog;
-class DatabaseInstance;
-class TransactionManager;
-class TableCatalogEntry;
-
-//! StorageManager is responsible for managing the physical storage of the
-//! database on disk
-class StorageManager {
-public:
-	StorageManager(DatabaseInstance &db, string path, bool read_only);
-	~StorageManager();
-
-	//! The BlockManager to read/store meta information and data in blocks
-	unique_ptr<BlockManager> block_manager;
-	//! The BufferManager of the database
-	unique_ptr<BufferManager> buffer_manager;
-	//! The database this storagemanager belongs to
-	DatabaseInstance &db;
-
-public:
-	static StorageManager &GetStorageManager(ClientContext &context);
-	static StorageManager &GetStorageManager(DatabaseInstance &db);
-
-	//! Initialize a database or load an existing database from the given path
-	void Initialize();
-	//! Get the WAL of the StorageManager, returns nullptr if in-memory
-	WriteAheadLog *GetWriteAheadLog() {
-		return wal.initialized ? &wal : nullptr;
-	}
-
-	DatabaseInstance &GetDatabase() {
-		return db;
-	}
-
-	void CreateCheckpoint(bool delete_wal = false, bool force_checkpoint = false);
-
-	string GetDBPath() {
-		return path;
-	}
-	bool InMemory();
-
-private:
-	//! Load the database from a directory
-	void LoadDatabase();
-
-	//! The path of the database
-	string path;
-	//! The WriteAheadLog of the storage manager
-	WriteAheadLog wal;
-
-	//! Whether or not the database is opened in read-only mode
-	bool read_only;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/art.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/art_key.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/bit_operations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-#include <cfloat>
-#include <cstring> // strlen() on Solaris
-#include <limits.h>
-
-namespace duckdb {
-
-#define BSWAP16(x) ((uint16_t)((((uint16_t)(x)&0xff00) >> 8) | (((uint16_t)(x)&0x00ff) << 8)))
-
-#define BSWAP32(x)                                                                                                     \
-	((uint32_t)((((uint32_t)(x)&0xff000000) >> 24) | (((uint32_t)(x)&0x00ff0000) >> 8) |                               \
-	            (((uint32_t)(x)&0x0000ff00) << 8) | (((uint32_t)(x)&0x000000ff) << 24)))
-
-#define BSWAP64(x)                                                                                                     \
-	((uint64_t)((((uint64_t)(x)&0xff00000000000000ull) >> 56) | (((uint64_t)(x)&0x00ff000000000000ull) >> 40) |        \
-	            (((uint64_t)(x)&0x0000ff0000000000ull) >> 24) | (((uint64_t)(x)&0x000000ff00000000ull) >> 8) |         \
-	            (((uint64_t)(x)&0x00000000ff000000ull) << 8) | (((uint64_t)(x)&0x0000000000ff0000ull) << 24) |         \
-	            (((uint64_t)(x)&0x000000000000ff00ull) << 40) | (((uint64_t)(x)&0x00000000000000ffull) << 56)))
-
-struct Radix {
-public:
-	static inline bool IsLittleEndian() {
-		int n = 1;
-		if (*(char *)&n == 1) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	template <class T>
-	static inline void EncodeData(data_ptr_t dataptr, T value, bool is_little_endian) {
-		throw NotImplementedException("Cannot create data from this type");
-	}
-
-	static inline void EncodeStringDataPrefix(data_ptr_t dataptr, string_t value, idx_t prefix_len) {
-		auto len = value.GetSize();
-		memcpy(dataptr, value.GetDataUnsafe(), MinValue(len, prefix_len));
-		if (len < prefix_len) {
-			memset(dataptr + len, '\0', prefix_len - len);
-		}
-	}
-
-	static inline uint8_t FlipSign(uint8_t key_byte) {
-		return key_byte ^ 128;
-	}
-
-	static inline uint32_t EncodeFloat(float x) {
-		uint64_t buff;
-
-		//! zero
-		if (x == 0) {
-			buff = 0;
-			buff |= (1u << 31);
-			return buff;
-		}
-		// nan
-		if (Value::IsNan(x)) {
-			return UINT_MAX;
-		}
-		//! infinity
-		if (x > FLT_MAX) {
-			return UINT_MAX - 1;
-		}
-		//! -infinity
-		if (x < -FLT_MAX) {
-			return 0;
-		}
-		buff = Load<uint32_t>((const_data_ptr_t)&x);
-		if ((buff & (1u << 31)) == 0) { //! +0 and positive numbers
-			buff |= (1u << 31);
-		} else {          //! negative numbers
-			buff = ~buff; //! complement 1
-		}
-
-		return buff;
-	}
-
-	static inline uint64_t EncodeDouble(double x) {
-		uint64_t buff;
-		//! zero
-		if (x == 0) {
-			buff = 0;
-			buff += (1ull << 63);
-			return buff;
-		}
-		// nan
-		if (Value::IsNan(x)) {
-			return ULLONG_MAX;
-		}
-		//! infinity
-		if (x > DBL_MAX) {
-			return ULLONG_MAX - 1;
-		}
-		//! -infinity
-		if (x < -DBL_MAX) {
-			return 0;
-		}
-		buff = Load<uint64_t>((const_data_ptr_t)&x);
-		if (buff < (1ull << 63)) { //! +0 and positive numbers
-			buff += (1ull << 63);
-		} else {          //! negative numbers
-			buff = ~buff; //! complement 1
-		}
-		return buff;
-	}
-};
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, bool value, bool is_little_endian) {
-	Store<uint8_t>(value ? 1 : 0, dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, int8_t value, bool is_little_endian) {
-	Store<uint8_t>(value, dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, int16_t value, bool is_little_endian) {
-	Store<uint16_t>(is_little_endian ? BSWAP16(value) : value, dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, int32_t value, bool is_little_endian) {
-	Store<uint32_t>(is_little_endian ? BSWAP32(value) : value, dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, int64_t value, bool is_little_endian) {
-	Store<uint64_t>(is_little_endian ? BSWAP64(value) : value, dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uint8_t value, bool is_little_endian) {
-	Store<uint8_t>(value, dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uint16_t value, bool is_little_endian) {
-	Store<uint16_t>(is_little_endian ? BSWAP16(value) : value, dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uint32_t value, bool is_little_endian) {
-	Store<uint32_t>(is_little_endian ? BSWAP32(value) : value, dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, uint64_t value, bool is_little_endian) {
-	Store<uint64_t>(is_little_endian ? BSWAP64(value) : value, dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, hugeint_t value, bool is_little_endian) {
-	EncodeData<int64_t>(dataptr, value.upper, is_little_endian);
-	EncodeData<uint64_t>(dataptr + sizeof(value.upper), value.lower, is_little_endian);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, float value, bool is_little_endian) {
-	uint32_t converted_value = EncodeFloat(value);
-	Store<uint32_t>(is_little_endian ? BSWAP32(converted_value) : converted_value, dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, double value, bool is_little_endian) {
-	uint64_t converted_value = EncodeDouble(value);
-	Store<uint64_t>(is_little_endian ? BSWAP64(converted_value) : converted_value, dataptr);
-}
-
-template <>
-inline void Radix::EncodeData(data_ptr_t dataptr, interval_t value, bool is_little_endian) {
-	EncodeData<int32_t>(dataptr, value.months, is_little_endian);
-	dataptr += sizeof(value.months);
-	EncodeData<int32_t>(dataptr, value.days, is_little_endian);
-	dataptr += sizeof(value.days);
-	EncodeData<int64_t>(dataptr, value.micros, is_little_endian);
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-class Key {
-public:
-	Key(unique_ptr<data_t[]> data, idx_t len);
-
-	idx_t len;
-	unique_ptr<data_t[]> data;
-
-public:
-	template <class T>
-	static inline unique_ptr<Key> CreateKey(T element, bool is_little_endian) {
-		auto data = Key::CreateData<T>(element, is_little_endian);
-		return make_unique<Key>(move(data), sizeof(element));
-	}
-
-	template <class T>
-	static inline unique_ptr<Key> CreateKey(const Value &element, bool is_little_endian) {
-		return CreateKey(element.GetValueUnsafe<T>(), is_little_endian);
-	}
-
-public:
-	data_t &operator[](std::size_t i) {
-		return data[i];
-	}
-	const data_t &operator[](std::size_t i) const {
-		return data[i];
-	}
-	bool operator>(const Key &k) const;
-	bool operator<(const Key &k) const;
-	bool operator>=(const Key &k) const;
-	bool operator==(const Key &k) const;
-
-private:
-	template <class T>
-	static inline unique_ptr<data_t[]> CreateData(T value, bool is_little_endian) {
-		auto data = unique_ptr<data_t[]>(new data_t[sizeof(value)]);
-		Radix::EncodeData<T>(data.get(), value, is_little_endian);
-		return data;
-	}
-};
-
-template <>
-unique_ptr<Key> Key::CreateKey(string_t value, bool is_little_endian);
-template <>
-unique_ptr<Key> Key::CreateKey(const char *value, bool is_little_endian);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/leaf.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-enum class NodeType : uint8_t { N4 = 0, N16 = 1, N48 = 2, N256 = 3, NLeaf = 4 };
-
-class ART;
-
-class Node {
-public:
-	static const uint8_t EMPTY_MARKER = 48;
-
-public:
-	Node(ART &art, NodeType type, size_t compressed_prefix_size);
-	virtual ~Node() {
-	}
-
-	//! length of the compressed path (prefix)
-	uint32_t prefix_length;
-	//! number of non-null children
-	uint16_t count;
-	//! node type
-	NodeType type;
-	//! compressed path (prefix)
-	unique_ptr<uint8_t[]> prefix;
-
-public:
-	//! Get the position of a child corresponding exactly to the specific byte, returns DConstants::INVALID_INDEX if not
-	//! exists
-	virtual idx_t GetChildPos(uint8_t k) {
-		return DConstants::INVALID_INDEX;
-	}
-	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
-	//! if there are no children matching the criteria
-	virtual idx_t GetChildGreaterEqual(uint8_t k, bool &equal) {
-		throw InternalException("Unimplemented GetChildGreaterEqual for ARTNode");
-	}
-	//! Get the position of the biggest element in node
-	virtual idx_t GetMin();
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position. if pos ==
-	//! DConstants::INVALID_INDEX, then the first valid position in the node will be returned.
-	virtual idx_t GetNextPos(idx_t pos) {
-		return DConstants::INVALID_INDEX;
-	}
-	//! Get the child at the specified position in the node. pos should be between [0, count). Throws an assertion if
-	//! the element is not found.
-	virtual unique_ptr<Node> *GetChild(idx_t pos);
-
-	//! Compare the key with the prefix of the node, return the number matching bytes
-	static uint32_t PrefixMismatch(ART &art, Node *node, Key &key, uint64_t depth);
-	//! Insert leaf into inner node
-	static void InsertLeaf(ART &art, unique_ptr<Node> &node, uint8_t key, unique_ptr<Node> &new_node);
-	//! Erase entry from node
-	static void Erase(ART &art, unique_ptr<Node> &node, idx_t pos);
-
-protected:
-	//! Copies the prefix from the source to the destination node
-	static void CopyPrefix(ART &art, Node *src, Node *dst);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class Leaf : public Node {
-public:
-	Leaf(ART &art, unique_ptr<Key> value, row_t row_id);
-
-	unique_ptr<Key> value;
-	idx_t capacity;
-	idx_t num_elements;
-
-	row_t GetRowId(idx_t index) {
-		return row_ids[index];
-	}
-
-public:
-	void Insert(row_t row_id);
-	void Remove(row_t row_id);
-
-private:
-	unique_ptr<row_t[]> row_ids;
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node4.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-namespace duckdb {
-
-class Node4 : public Node {
-public:
-	Node4(ART &art, size_t compression_length);
-
-	uint8_t key[4];
-	unique_ptr<Node> child[4];
-
-public:
-	//! Get position of a byte, returns -1 if not exists
-	idx_t GetChildPos(uint8_t k) override;
-	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
-	//! if there are no children matching the criteria
-	idx_t GetChildGreaterEqual(uint8_t k, bool &equal) override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPos(idx_t pos) override;
-	//! Get Node4 Child
-	unique_ptr<Node> *GetChild(idx_t pos) override;
-
-	idx_t GetMin() override;
-
-	//! Insert Leaf to the Node4
-	static void Insert(ART &art, unique_ptr<Node> &node, uint8_t key_byte, unique_ptr<Node> &child);
-	//! Remove Leaf from Node4
-	static void Erase(ART &art, unique_ptr<Node> &node, int pos);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node16.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-namespace duckdb {
-
-class Node16 : public Node {
-public:
-	Node16(ART &art, size_t compression_lengthh);
-
-	uint8_t key[16];
-	unique_ptr<Node> child[16];
-
-public:
-	//! Get position of a byte, returns -1 if not exists
-	idx_t GetChildPos(uint8_t k) override;
-	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
-	//! if there are no children matching the criteria
-	idx_t GetChildGreaterEqual(uint8_t k, bool &equal) override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPos(idx_t pos) override;
-	//! Get Node16 Child
-	unique_ptr<Node> *GetChild(idx_t pos) override;
-
-	idx_t GetMin() override;
-
-	//! Insert node into Node16
-	static void Insert(ART &art, unique_ptr<Node> &node, uint8_t key_byte, unique_ptr<Node> &child);
-	//! Shrink to node 4
-	static void Erase(ART &art, unique_ptr<Node> &node, int pos);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node48.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-namespace duckdb {
-
-class Node48 : public Node {
-public:
-	Node48(ART &art, size_t compression_length);
-
-	uint8_t child_index[256];
-	unique_ptr<Node> child[48];
-
-public:
-	//! Get position of a byte, returns -1 if not exists
-	idx_t GetChildPos(uint8_t k) override;
-	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
-	//! if there are no children matching the criteria
-	idx_t GetChildGreaterEqual(uint8_t k, bool &equal) override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPos(idx_t pos) override;
-	//! Get Node48 Child
-	unique_ptr<Node> *GetChild(idx_t pos) override;
-
-	idx_t GetMin() override;
-
-	//! Insert node in Node48
-	static void Insert(ART &art, unique_ptr<Node> &node, uint8_t key_byte, unique_ptr<Node> &child);
-
-	//! Shrink to node 16
-	static void Erase(ART &art, unique_ptr<Node> &node, int pos);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/node256.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-namespace duckdb {
-
-class Node256 : public Node {
-public:
-	Node256(ART &art, size_t compression_length);
-
-	unique_ptr<Node> child[256];
-
-public:
-	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
-	idx_t GetChildPos(uint8_t k) override;
-	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
-	//! if there are no children matching the criteria
-	idx_t GetChildGreaterEqual(uint8_t k, bool &equal) override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPos(idx_t pos) override;
-	//! Get Node256 Child
-	unique_ptr<Node> *GetChild(idx_t pos) override;
-
-	idx_t GetMin() override;
-
-	//! Insert node From Node256
-	static void Insert(ART &art, unique_ptr<Node> &node, uint8_t key_byte, unique_ptr<Node> &child);
-
-	//! Shrink to node 48
-	static void Erase(ART &art, unique_ptr<Node> &node, int pos);
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-struct IteratorEntry {
-	IteratorEntry() {
-	}
-	IteratorEntry(Node *node, idx_t pos) : node(node), pos(pos) {
-	}
-
-	Node *node = nullptr;
-	idx_t pos = 0;
-};
-
-struct Iterator {
-	//! The current Leaf Node, valid if depth>0
-	Leaf *node = nullptr;
-	//! The current depth
-	int32_t depth = 0;
-	//! Stack, the size is determined at runtime
-	vector<IteratorEntry> stack;
-
-	bool start = false;
-
-	void SetEntry(idx_t depth, IteratorEntry entry);
-};
-
-struct ARTIndexScanState : public IndexScanState {
-	ARTIndexScanState() : checked(false), result_index(0) {
-	}
-
-	Value values[2];
-	ExpressionType expressions[2];
-	bool checked;
-	vector<row_t> result_ids;
-	Iterator iterator;
-	//! Stores the current leaf
-	Leaf *cur_leaf = nullptr;
-	//! Offset to leaf
-	idx_t result_index = 0;
-};
-
-enum VerifyExistenceType : uint8_t {
-	APPEND = 0,    // for purpose to append into table
-	APPEND_FK = 1, // for purpose to append into table has foreign key
-	DELETE_FK = 2  // for purpose to delete from table related to foreign key
-};
-
-class ART : public Index {
-public:
-	ART(const vector<column_t> &column_ids, const vector<unique_ptr<Expression>> &unbound_expressions,
-	    IndexConstraintType constraint_type);
-	~ART() override;
-
-	//! Root of the tree
-	unique_ptr<Node> tree;
-	//! True if machine is little endian
-	bool is_little_endian;
-
-public:
-	//! Initialize a scan on the index with the given expression and column ids
-	//! to fetch from the base table for a single predicate
-	unique_ptr<IndexScanState> InitializeScanSinglePredicate(Transaction &transaction, Value value,
-	                                                         ExpressionType expressionType) override;
-
-	//! Initialize a scan on the index with the given expression and column ids
-	//! to fetch from the base table for two predicates
-	unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, Value low_value,
-	                                                       ExpressionType low_expression_type, Value high_value,
-	                                                       ExpressionType high_expression_type) override;
-
-	//! Perform a lookup on the index
-	bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
-	          vector<row_t> &result_ids) override;
-	//! Append entries to the index
-	bool Append(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
-	//! Verify that data can be appended to the index
-	void VerifyAppend(DataChunk &chunk) override;
-	//! Verify that data can be appended to the index for foreign key constraint
-	void VerifyAppendForeignKey(DataChunk &chunk, string *err_msg_ptr) override;
-	//! Verify that data can be delete from the index for foreign key constraint
-	void VerifyDeleteForeignKey(DataChunk &chunk, string *err_msg_ptr) override;
-	//! Delete entries in the index
-	void Delete(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
-	//! Insert data into the index.
-	bool Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override;
-
-	bool SearchEqual(ARTIndexScanState *state, idx_t max_count, vector<row_t> &result_ids);
-	//! Search Equal used for Joins that do not need to fetch data
-	void SearchEqualJoinNoFetch(Value &equal_value, idx_t &result_size);
-
-private:
-	//! Insert a row id into a leaf node
-	bool InsertToLeaf(Leaf &leaf, row_t row_id);
-	//! Insert the leaf value into the tree
-	bool Insert(unique_ptr<Node> &node, unique_ptr<Key> key, unsigned depth, row_t row_id);
-
-	//! Erase element from leaf (if leaf has more than one value) or eliminate the leaf itself
-	void Erase(unique_ptr<Node> &node, Key &key, unsigned depth, row_t row_id);
-
-	//! Check if the key of the leaf is equal to the searched key
-	bool LeafMatches(Node *node, Key &key, unsigned depth);
-
-	//! Find the node with a matching key, optimistic version
-	Node *Lookup(unique_ptr<Node> &node, Key &key, unsigned depth);
-
-	//! Find the first node that is bigger (or equal to) a specific key
-	bool Bound(unique_ptr<Node> &node, Key &key, Iterator &iterator, bool inclusive);
-
-	//! Gets next node for range queries
-	bool IteratorNext(Iterator &iter);
-
-	bool SearchGreater(ARTIndexScanState *state, bool inclusive, idx_t max_count, vector<row_t> &result_ids);
-	bool SearchLess(ARTIndexScanState *state, bool inclusive, idx_t max_count, vector<row_t> &result_ids);
-	bool SearchCloseRange(ARTIndexScanState *state, bool left_inclusive, bool right_inclusive, idx_t max_count,
-	                      vector<row_t> &result_ids);
-
-private:
-	template <bool HAS_BOUND, bool INCLUSIVE>
-	bool IteratorScan(ARTIndexScanState *state, Iterator *it, Key *upper_bound, idx_t max_count,
-	                  vector<row_t> &result_ids);
-
-	void GenerateKeys(DataChunk &input, vector<unique_ptr<Key>> &keys);
-
-	void VerifyExistence(DataChunk &chunk, VerifyExistenceType verify_type, string *err_msg_ptr = NULL);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_expression_iterator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-class ParsedExpressionIterator {
-public:
-	static void EnumerateChildren(const ParsedExpression &expression,
-	                              const std::function<void(const ParsedExpression &child)> &callback);
-	static void EnumerateChildren(ParsedExpression &expr, const std::function<void(ParsedExpression &child)> &callback);
-	static void EnumerateChildren(ParsedExpression &expr,
-	                              const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-
-	static void EnumerateTableRefChildren(TableRef &ref,
-	                                      const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-	static void EnumerateQueryNodeChildren(QueryNode &node,
-	                                       const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-
-	static void EnumerateQueryNodeModifiers(QueryNode &node,
-	                                        const std::function<void(unique_ptr<ParsedExpression> &child)> &callback);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/alter_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class TableCatalogEntry;
-
-//! The ALTER binder is responsible for binding an expression within alter statements
-class AlterBinder : public ExpressionBinder {
-public:
-	AlterBinder(Binder &binder, ClientContext &context, TableCatalogEntry &table, vector<column_t> &bound_columns,
-	            LogicalType target_type);
-
-	TableCatalogEntry &table;
-	vector<column_t> &bound_columns;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	BindResult BindColumn(ColumnRefExpression &expr);
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/transaction_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class ClientContext;
-class Catalog;
-struct ClientLockWrapper;
-class DatabaseInstance;
-class Transaction;
-
-struct StoredCatalogSet {
-	//! Stored catalog set
-	unique_ptr<CatalogSet> stored_set;
-	//! The highest active query number when the catalog set was stored; used for cleaning up
-	transaction_t highest_active_query;
-};
-
-//! The Transaction Manager is responsible for creating and managing
-//! transactions
-class TransactionManager {
-	friend struct CheckpointLock;
-
-public:
-	explicit TransactionManager(DatabaseInstance &db);
-	~TransactionManager();
-
-	//! Start a new transaction
-	Transaction *StartTransaction(ClientContext &context);
-	//! Commit the given transaction
-	string CommitTransaction(ClientContext &context, Transaction *transaction);
-	//! Rollback the given transaction
-	void RollbackTransaction(Transaction *transaction);
-
-	transaction_t GetQueryNumber() {
-		return current_query_number++;
-	}
-	transaction_t LowestActiveId() {
-		return lowest_active_id;
-	}
-	transaction_t LowestActiveStart() {
-		return lowest_active_start;
-	}
-
-	void Checkpoint(ClientContext &context, bool force = false);
-
-	static TransactionManager &Get(ClientContext &context);
-	static TransactionManager &Get(DatabaseInstance &db);
-
-private:
-	bool CanCheckpoint(Transaction *current = nullptr);
-	//! Remove the given transaction from the list of active transactions
-	void RemoveTransaction(Transaction *transaction) noexcept;
-	void LockClients(vector<ClientLockWrapper> &client_locks, ClientContext &context);
-
-	//! The database instance
-	DatabaseInstance &db;
-	//! The current query number
-	atomic<transaction_t> current_query_number;
-	//! The current start timestamp used by transactions
-	transaction_t current_start_timestamp;
-	//! The current transaction ID used by transactions
-	transaction_t current_transaction_id;
-	//! The lowest active transaction id
-	atomic<transaction_t> lowest_active_id;
-	//! The lowest active transaction timestamp
-	atomic<transaction_t> lowest_active_start;
-	//! Set of currently running transactions
-	vector<unique_ptr<Transaction>> active_transactions;
-	//! Set of recently committed transactions
-	vector<unique_ptr<Transaction>> recently_committed_transactions;
-	//! Transactions awaiting GC
-	vector<unique_ptr<Transaction>> old_transactions;
-	//! Catalog sets
-	vector<StoredCatalogSet> old_catalog_sets;
-	//! The lock used for transaction operations
-	mutex transaction_lock;
-
-	bool thread_is_checkpointing;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/result_arrow_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ResultArrowArrayStreamWrapper {
-public:
-	explicit ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result, idx_t batch_size);
-	ArrowArrayStream stream;
-	unique_ptr<QueryResult> result;
-	std::string last_error;
-	idx_t batch_size;
-	vector<LogicalType> column_types;
-	vector<string> column_names;
-	string timezone_config;
-
-private:
-	static int MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out);
-	static int MyStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *out);
-	static void MyStreamRelease(struct ArrowArrayStream *stream);
-	static const char *MyStreamGetLastError(struct ArrowArrayStream *stream);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/checksum.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! Compute a checksum over a buffer of size size
-uint64_t Checksum(uint8_t *buffer, size_t size);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/crypto/md5.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class MD5Context {
-public:
-	static constexpr idx_t MD5_HASH_LENGTH_BINARY = 16;
-	static constexpr idx_t MD5_HASH_LENGTH_TEXT = 32;
-
-public:
-	MD5Context();
-
-	void Add(const_data_ptr_t data, idx_t len) {
-		MD5Update(data, len);
-	}
-	void Add(const char *data);
-	void Add(string_t string) {
-		MD5Update((const_data_ptr_t)string.GetDataUnsafe(), string.GetSize());
-	}
-	void Add(const string &data) {
-		MD5Update((const_data_ptr_t)data.c_str(), data.size());
-	}
-
-	//! Write the 16-byte (binary) digest to the specified location
-	void Finish(data_ptr_t out_digest);
-	//! Write the 32-character digest (in hexadecimal format) to the specified location
-	void FinishHex(char *out_digest);
-	//! Returns the 32-character digest (in hexadecimal format) as a string
-	string FinishHex();
-
-private:
-	void MD5Update(const_data_ptr_t data, idx_t len);
-	static void DigestToBase16(const_data_ptr_t digest, char *zBuf);
-
-	uint32_t buf[4];
-	uint32_t bits[2];
-	unsigned char in[64];
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
-// See the end of this file for a list
-
-/*
- Formatting library for C++
-
- Copyright (c) 2012 - present, Victor Zverovich
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
- --- Optional exception to the license ---
-
- As an exception, if, as a result of your compiling your source code, portions
- of this Software are embedded into a machine-executable object form of such
- source code, you may redistribute such embedded portions in such object form
- without including the above copyright and permission notices.
- */
-
-#ifndef FMT_FORMAT_H_
-#define FMT_FORMAT_H_
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
-// See the end of this file for a list
-
-// Formatting library for C++ - the core API
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_CORE_H_
-#define FMT_CORE_H_
-
-#include <cstdio>  // std::FILE
-#include <cstring>
-#include <iterator>
-#include <string>
-#include <type_traits>
-
-// The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 60102
-
-#ifdef __has_feature
-#  define FMT_HAS_FEATURE(x) __has_feature(x)
-#else
-#  define FMT_HAS_FEATURE(x) 0
-#endif
-
-#if defined(__has_include) && !defined(__INTELLISENSE__) && \
-    !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
-#  define FMT_HAS_INCLUDE(x) __has_include(x)
-#else
-#  define FMT_HAS_INCLUDE(x) 0
-#endif
-
-#ifdef __has_cpp_attribute
-#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__)
-#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#else
-#  define FMT_GCC_VERSION 0
-#endif
-
-#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
-#else
-#  define FMT_HAS_GXX_CXX11 0
-#endif
-
-#ifdef __NVCC__
-#  define FMT_NVCC __NVCC__
-#else
-#  define FMT_NVCC 0
-#endif
-
-#ifdef _MSC_VER
-#  define FMT_MSC_VER _MSC_VER
-#else
-#  define FMT_MSC_VER 0
-#endif
-
-// Check if relaxed C++14 constexpr is supported.
-// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
-#ifndef FMT_USE_CONSTEXPR
-#  define FMT_USE_CONSTEXPR                                           \
-    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
-     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
-        !FMT_NVCC
-#endif
-#if FMT_USE_CONSTEXPR
-#  define FMT_CONSTEXPR constexpr
-#  define FMT_CONSTEXPR_DECL constexpr
-#else
-#  define FMT_CONSTEXPR inline
-#  define FMT_CONSTEXPR_DECL
-#endif
-
-#ifndef FMT_OVERRIDE
-#  if FMT_HAS_FEATURE(cxx_override) || \
-      (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
-#    define FMT_OVERRIDE override
-#  else
-#    define FMT_OVERRIDE
-#  endif
-#endif
-
-// Check if exceptions are disabled.
-#ifndef FMT_EXCEPTIONS
-#  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
-      FMT_MSC_VER && !_HAS_EXCEPTIONS
-#    define FMT_EXCEPTIONS 0
-#  else
-#    define FMT_EXCEPTIONS 1
-#  endif
-#endif
-
-// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
-#ifndef FMT_USE_NOEXCEPT
-#  define FMT_USE_NOEXCEPT 0
-#endif
-
-#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
-    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
-#  define FMT_DETECTED_NOEXCEPT noexcept
-#  define FMT_HAS_CXX11_NOEXCEPT 1
-#else
-#  define FMT_DETECTED_NOEXCEPT throw()
-#  define FMT_HAS_CXX11_NOEXCEPT 0
-#endif
-
-#ifndef FMT_NOEXCEPT
-#  if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
-#    define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
-#  else
-#    define FMT_NOEXCEPT
-#  endif
-#endif
-
-// [[noreturn]] is disabled on MSVC because of bogus unreachable code warnings.
-#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER
-#  define FMT_NORETURN [[noreturn]]
-#else
-#  define FMT_NORETURN
-#endif
-
-#ifndef FMT_DEPRECATED
-#  if (FMT_HAS_CPP_ATTRIBUTE(deprecated) && __cplusplus >= 201402L) || \
-      FMT_MSC_VER >= 1900
-#    define FMT_DEPRECATED [[deprecated]]
-#  else
-#    if defined(__GNUC__) || defined(__clang__)
-#      define FMT_DEPRECATED __attribute__((deprecated))
-#    elif FMT_MSC_VER
-#      define FMT_DEPRECATED __declspec(deprecated)
-#    else
-#      define FMT_DEPRECATED /* deprecated */
-#    endif
-#  endif
-#endif
-
-// Workaround broken [[deprecated]] in the Intel compiler and NVCC.
-#if defined(__INTEL_COMPILER) || FMT_NVCC
-#  define FMT_DEPRECATED_ALIAS
-#else
-#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
-#endif
-
-#ifndef FMT_BEGIN_NAMESPACE
-#  if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
-      FMT_MSC_VER >= 1900
-#    define FMT_INLINE_NAMESPACE inline namespace
-#    define FMT_END_NAMESPACE \
-      }                       \
-      }
-#  else
-#    define FMT_INLINE_NAMESPACE namespace
-#    define FMT_END_NAMESPACE \
-      }                       \
-      using namespace v6;     \
-      }
-#  endif
-#  define FMT_BEGIN_NAMESPACE \
-    namespace duckdb_fmt {           \
-    FMT_INLINE_NAMESPACE v6 {
-#endif
-
-#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-#  ifdef FMT_EXPORT
-#    define FMT_API __declspec(dllexport)
-#  elif defined(FMT_SHARED)
-#    define FMT_API __declspec(dllimport)
-#    define FMT_EXTERN_TEMPLATE_API FMT_API
-#  endif
-#endif
-#ifndef FMT_API
-#  define FMT_API
-#endif
-#ifndef FMT_EXTERN_TEMPLATE_API
-#  define FMT_EXTERN_TEMPLATE_API
-#endif
-
-#ifndef FMT_HEADER_ONLY
-#  define FMT_EXTERN extern
-#else
-#  define FMT_EXTERN
-#endif
-
-// libc++ supports string_view in pre-c++17.
-#if (FMT_HAS_INCLUDE(<string_view>) &&                       \
-     (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
-    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
-#  include <string_view>
-#  define FMT_USE_STRING_VIEW
-#elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L
-#  include <experimental/string_view>
-#  define FMT_USE_EXPERIMENTAL_STRING_VIEW
-#endif
-
-FMT_BEGIN_NAMESPACE
-
-// Implementations of enable_if_t and other types for pre-C++14 systems.
-template <bool B, class T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-template <bool B, class T, class F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-template <bool B> using bool_constant = std::integral_constant<bool, B>;
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-template <typename T>
-using remove_const_t = typename std::remove_const<T>::type;
-template <typename T>
-using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
-
-struct monostate {};
-
-// An enable_if helper to be used in template parameters which results in much
-// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
-// to workaround a bug in MSVC 2019 (see #1140 and #1186).
-#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
-
-namespace internal {
-
-// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
-template <typename... Ts> struct void_t_impl { using type = void; };
-
-#ifndef FMT_ASSERT
-#define FMT_ASSERT(condition, message)
-#endif
-
-#if defined(FMT_USE_STRING_VIEW)
-template <typename Char> using std_string_view = std::basic_string_view<Char>;
-#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
-template <typename Char>
-using std_string_view = std::experimental::basic_string_view<Char>;
-#else
-template <typename T> struct std_string_view {};
-#endif
-
-#ifdef FMT_USE_INT128
-// Do nothing.
-#elif defined(__SIZEOF_INT128__)
-#  define FMT_USE_INT128 1
-using int128_t = __int128_t;
-using uint128_t = __uint128_t;
-#else
-#  define FMT_USE_INT128 0
-#endif
-#if !FMT_USE_INT128
-struct int128_t {};
-struct uint128_t {};
-#endif
-
-// Casts a nonnegative integer to unsigned.
-template <typename Int>
-FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
-  FMT_ASSERT(value >= 0, "negative value");
-  return static_cast<typename std::make_unsigned<Int>::type>(value);
-}
-}  // namespace internal
-
-template <typename... Ts>
-using void_t = typename internal::void_t_impl<Ts...>::type;
-
-/**
-  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
-  subset of the API. ``fmt::basic_string_view`` is used for format strings even
-  if ``std::string_view`` is available to prevent issues when a library is
-  compiled with a different ``-std`` option than the client code (which is not
-  recommended).
- */
-template <typename Char> class basic_string_view {
- private:
-  const Char* data_;
-  size_t size_;
-
- public:
-  using char_type = Char;
-  using iterator = const Char*;
-
-  FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}
-
-  /** Constructs a string reference object from a C string and a size. */
-  FMT_CONSTEXPR basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT
-      : data_(s),
-        size_(count) {}
-
-  /**
-    \rst
-    Constructs a string reference object from a C string computing
-    the size with ``std::char_traits<Char>::length``.
-    \endrst
-   */
-  basic_string_view(const Char* s)
-      : data_(s), size_(std::char_traits<Char>::length(s)) {}
-
-  /** Constructs a string reference from a ``std::basic_string`` object. */
-  template <typename Traits, typename Alloc>
-  FMT_CONSTEXPR basic_string_view(
-      const std::basic_string<Char, Traits, Alloc>& s) FMT_NOEXCEPT
-      : data_(s.data()),
-        size_(s.size()) {}
-
-  template <
-      typename S,
-      FMT_ENABLE_IF(std::is_same<S, internal::std_string_view<Char>>::value)>
-  FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),
-                                                      size_(s.size()) {}
-
-  /** Returns a pointer to the string data. */
-  FMT_CONSTEXPR const Char* data() const { return data_; }
-
-  /** Returns the string size. */
-  FMT_CONSTEXPR size_t size() const { return size_; }
-
-  FMT_CONSTEXPR iterator begin() const { return data_; }
-  FMT_CONSTEXPR iterator end() const { return data_ + size_; }
-
-  FMT_CONSTEXPR const Char& operator[](size_t pos) const { return data_[pos]; }
-
-  FMT_CONSTEXPR void remove_prefix(size_t n) {
-    data_ += n;
-    size_ -= n;
-  }
-
-  // Lexicographically compare this string reference to other.
-  int compare(basic_string_view other) const {
-    size_t str_size = size_ < other.size_ ? size_ : other.size_;
-    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
-    if (result == 0)
-      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-    return result;
-  }
-
-  friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) == 0;
-  }
-  friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) != 0;
-  }
-  friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) < 0;
-  }
-  friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) <= 0;
-  }
-  friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) > 0;
-  }
-  friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) >= 0;
-  }
-};
-
-using string_view = basic_string_view<char>;
-using wstring_view = basic_string_view<wchar_t>;
-
-#ifndef __cpp_char8_t
-// A UTF-8 code unit type.
-enum char8_t : unsigned char {};
-#endif
-
-/** Specifies if ``T`` is a character type. Can be specialized by users. */
-template <typename T> struct is_char : std::false_type {};
-template <> struct is_char<char> : std::true_type {};
-template <> struct is_char<wchar_t> : std::true_type {};
-template <> struct is_char<char8_t> : std::true_type {};
-template <> struct is_char<char16_t> : std::true_type {};
-template <> struct is_char<char32_t> : std::true_type {};
-
-/**
-  \rst
-  Returns a string view of `s`. In order to add custom string type support to
-  {fmt} provide an overload of `to_string_view` for it in the same namespace as
-  the type for the argument-dependent lookup to work.
-
-  **Example**::
-
-    namespace my_ns {
-    inline string_view to_string_view(const my_string& s) {
-      return {s.data(), s.length()};
-    }
-    }
-    std::string message = fmt::format(my_string("The answer is {}"), 42);
-  \endrst
- */
-template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
-inline basic_string_view<Char> to_string_view(const Char* s) {
-  return s;
-}
-
-template <typename Char, typename Traits, typename Alloc>
-inline basic_string_view<Char> to_string_view(
-    const std::basic_string<Char, Traits, Alloc>& s) {
-  return s;
-}
-
-template <typename Char>
-inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
-  return s;
-}
-
-template <typename Char,
-          FMT_ENABLE_IF(!std::is_empty<internal::std_string_view<Char>>::value)>
-inline basic_string_view<Char> to_string_view(
-    internal::std_string_view<Char> s) {
-  return s;
-}
-
-// A base class for compile-time strings. It is defined in the fmt namespace to
-// make formatting functions visible via ADL, e.g. format(fmt("{}"), 42).
-struct compile_string {};
-
-template <typename S>
-struct is_compile_string : std::is_base_of<compile_string, S> {};
-
-template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
-  return s;
-}
-
-namespace internal {
-void to_string_view(...);
-using duckdb_fmt::v6::to_string_view;
-
-// Specifies whether S is a string type convertible to fmt::basic_string_view.
-// It should be a constexpr function but MSVC 2017 fails to compile it in
-// enable_if and MSVC 2015 fails to compile it as an alias template.
-template <typename S>
-struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
-};
-
-template <typename S, typename = void> struct char_t_impl {};
-template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
-  using result = decltype(to_string_view(std::declval<S>()));
-  using type = typename result::char_type;
-};
-
-struct error_handler {
-  FMT_CONSTEXPR error_handler() = default;
-  FMT_CONSTEXPR error_handler(const error_handler&) = default;
-
-  // This function is intentionally not constexpr to give a compile-time error.
-  FMT_NORETURN FMT_API void on_error(const char* message);
-};
-}  // namespace internal
-
-/** String's character type. */
-template <typename S> using char_t = typename internal::char_t_impl<S>::type;
-
-/**
-  \rst
-  Parsing context consisting of a format string range being parsed and an
-  argument counter for automatic indexing.
-
-  You can use one of the following type aliases for common character types:
-
-  +-----------------------+-------------------------------------+
-  | Type                  | Definition                          |
-  +=======================+=====================================+
-  | format_parse_context  | basic_format_parse_context<char>    |
-  +-----------------------+-------------------------------------+
-  | wformat_parse_context | basic_format_parse_context<wchar_t> |
-  +-----------------------+-------------------------------------+
-  \endrst
- */
-template <typename Char, typename ErrorHandler = internal::error_handler>
-class basic_format_parse_context : private ErrorHandler {
- private:
-  basic_string_view<Char> format_str_;
-  int next_arg_id_;
-
- public:
-  using char_type = Char;
-  using iterator = typename basic_string_view<Char>::iterator;
-
-  explicit FMT_CONSTEXPR basic_format_parse_context(
-      basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
-      : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
-
-  /**
-    Returns an iterator to the beginning of the format string range being
-    parsed.
-   */
-  FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT {
-    return format_str_.begin();
-  }
-
-  /**
-    Returns an iterator past the end of the format string range being parsed.
-   */
-  FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); }
-
-  /** Advances the begin iterator to ``it``. */
-  FMT_CONSTEXPR void advance_to(iterator it) {
-    format_str_.remove_prefix(internal::to_unsigned(it - begin()));
-  }
-
-  /**
-    Reports an error if using the manual argument indexing; otherwise returns
-    the next argument index and switches to the automatic indexing.
-   */
-  FMT_CONSTEXPR int next_arg_id() {
-    if (next_arg_id_ >= 0) return next_arg_id_++;
-    on_error("cannot switch from manual to automatic argument indexing");
-    return 0;
-  }
-
-  /**
-    Reports an error if using the automatic argument indexing; otherwise
-    switches to the manual indexing.
-   */
-  FMT_CONSTEXPR void check_arg_id(int) {
-    if (next_arg_id_ > 0)
-      on_error("cannot switch from automatic to manual argument indexing");
-    else
-      next_arg_id_ = -1;
-  }
-
-  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    ErrorHandler::on_error(message);
-  }
-
-  FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
-};
-
-using format_parse_context = basic_format_parse_context<char>;
-using wformat_parse_context = basic_format_parse_context<wchar_t>;
-
-template <typename Char, typename ErrorHandler = internal::error_handler>
-using basic_parse_context FMT_DEPRECATED_ALIAS =
-    basic_format_parse_context<Char, ErrorHandler>;
-using parse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<char>;
-using wparse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<wchar_t>;
-
-template <typename Context> class basic_format_arg;
-template <typename Context> class basic_format_args;
-
-// A formatter for objects of type T.
-template <typename T, typename Char = char, typename Enable = void>
-struct formatter {
-  // A deleted default constructor indicates a disabled formatter.
-  formatter() = delete;
-};
-
-template <typename T, typename Char, typename Enable = void>
-struct FMT_DEPRECATED convert_to_int
-    : bool_constant<!std::is_arithmetic<T>::value &&
-                    std::is_convertible<T, int>::value> {};
-
-// Specifies if T has an enabled formatter specialization. A type can be
-// formattable even if it doesn't have a formatter e.g. via a conversion.
-template <typename T, typename Context>
-using has_formatter =
-    std::is_constructible<typename Context::template formatter_type<T>>;
-
-namespace internal {
-
-/** A contiguous memory buffer with an optional growing ability. */
-template <typename T> class buffer {
- private:
-  T* ptr_;
-  std::size_t size_;
-  std::size_t capacity_;
-
- protected:
-  // Don't initialize ptr_ since it is not accessed to save a few cycles.
-  buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
-
-  buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT
-      : ptr_(p),
-        size_(sz),
-        capacity_(cap) {}
-
-  /** Sets the buffer data and capacity. */
-  void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
-    ptr_ = buf_data;
-    capacity_ = buf_capacity;
-  }
-
-  /** Increases the buffer capacity to hold at least *capacity* elements. */
-  virtual void grow(std::size_t capacity) = 0;
-
- public:
-  using value_type = T;
-  using const_reference = const T&;
-
-  buffer(const buffer&) = delete;
-  void operator=(const buffer&) = delete;
-  virtual ~buffer() = default;
-
-  T* begin() FMT_NOEXCEPT { return ptr_; }
-  T* end() FMT_NOEXCEPT { return ptr_ + size_; }
-
-  /** Returns the size of this buffer. */
-  std::size_t size() const FMT_NOEXCEPT { return size_; }
-
-  /** Returns the capacity of this buffer. */
-  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
-
-  /** Returns a pointer to the buffer data. */
-  T* data() FMT_NOEXCEPT { return ptr_; }
-
-  /** Returns a pointer to the buffer data. */
-  const T* data() const FMT_NOEXCEPT { return ptr_; }
-
-  /**
-    Resizes the buffer. If T is a POD type new elements may not be initialized.
-   */
-  void resize(std::size_t new_size) {
-    reserve(new_size);
-    size_ = new_size;
-  }
-
-  /** Clears this buffer. */
-  void clear() { size_ = 0; }
-
-  /** Reserves space to store at least *capacity* elements. */
-  void reserve(std::size_t new_capacity) {
-    if (new_capacity > capacity_) grow(new_capacity);
-  }
-
-  void push_back(const T& value) {
-    reserve(size_ + 1);
-    ptr_[size_++] = value;
-  }
-
-  /** Appends data to the end of the buffer. */
-  template <typename U> void append(const U* begin, const U* end);
-
-  T& operator[](std::size_t index) { return ptr_[index]; }
-  const T& operator[](std::size_t index) const { return ptr_[index]; }
-};
-
-// A container-backed buffer.
-template <typename Container>
-class container_buffer : public buffer<typename Container::value_type> {
- private:
-  Container& container_;
-
- protected:
-  void grow(std::size_t capacity) FMT_OVERRIDE {
-    container_.resize(capacity);
-    this->set(&container_[0], capacity);
-  }
-
- public:
-  explicit container_buffer(Container& c)
-      : buffer<typename Container::value_type>(c.size()), container_(c) {}
-};
-
-// Extracts a reference to the container from back_insert_iterator.
-template <typename Container>
-inline Container& get_container(std::back_insert_iterator<Container> it) {
-  using bi_iterator = std::back_insert_iterator<Container>;
-  struct accessor : bi_iterator {
-    accessor(bi_iterator iter) : bi_iterator(iter) {}
-    using bi_iterator::container;
-  };
-  return *accessor(it).container;
-}
-
-template <typename T, typename Char = char, typename Enable = void>
-struct fallback_formatter {
-  fallback_formatter() = delete;
-};
-
-// Specifies if T has an enabled fallback_formatter specialization.
-template <typename T, typename Context>
-using has_fallback_formatter =
-    std::is_constructible<fallback_formatter<T, typename Context::char_type>>;
-
-template <typename Char> struct named_arg_base;
-template <typename T, typename Char> struct named_arg;
-
-enum type {
-  none_type,
-  named_arg_type,
-  // Integer types should go first,
-  int_type,
-  uint_type,
-  long_long_type,
-  ulong_long_type,
-  int128_type,
-  uint128_type,
-  bool_type,
-  char_type,
-  last_integer_type = char_type,
-  // followed by floating-point types.
-  float_type,
-  double_type,
-  long_double_type,
-  last_numeric_type = long_double_type,
-  cstring_type,
-  string_type,
-  pointer_type,
-  custom_type
-};
-
-// Maps core type T to the corresponding type enum constant.
-template <typename T, typename Char>
-struct type_constant : std::integral_constant<type, custom_type> {};
-
-#define FMT_TYPE_CONSTANT(Type, constant) \
-  template <typename Char>                \
-  struct type_constant<Type, Char> : std::integral_constant<type, constant> {}
-
-FMT_TYPE_CONSTANT(const named_arg_base<Char>&, named_arg_type);
-FMT_TYPE_CONSTANT(int, int_type);
-FMT_TYPE_CONSTANT(unsigned, uint_type);
-FMT_TYPE_CONSTANT(long long, long_long_type);
-FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
-FMT_TYPE_CONSTANT(int128_t, int128_type);
-FMT_TYPE_CONSTANT(uint128_t, uint128_type);
-FMT_TYPE_CONSTANT(bool, bool_type);
-FMT_TYPE_CONSTANT(Char, char_type);
-FMT_TYPE_CONSTANT(float, float_type);
-FMT_TYPE_CONSTANT(double, double_type);
-FMT_TYPE_CONSTANT(long double, long_double_type);
-FMT_TYPE_CONSTANT(const Char*, cstring_type);
-FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
-FMT_TYPE_CONSTANT(const void*, pointer_type);
-
-FMT_CONSTEXPR bool is_integral_type(type t) {
-  FMT_ASSERT(t != named_arg_type, "invalid argument type");
-  return t > none_type && t <= last_integer_type;
-}
-
-FMT_CONSTEXPR bool is_arithmetic_type(type t) {
-  FMT_ASSERT(t != named_arg_type, "invalid argument type");
-  return t > none_type && t <= last_numeric_type;
-}
-
-template <typename Char> struct string_value {
-  const Char* data;
-  std::size_t size;
-};
-
-template <typename Context> struct custom_value {
-  using parse_context = basic_format_parse_context<typename Context::char_type>;
-  const void* value;
-  void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
-};
-
-// A formatting argument value.
-template <typename Context> class value {
- public:
-  using char_type = typename Context::char_type;
-
-  union {
-    int int_value;
-    unsigned uint_value;
-    long long long_long_value;
-    unsigned long long ulong_long_value;
-    int128_t int128_value;
-    uint128_t uint128_value;
-    bool bool_value;
-    char_type char_value;
-    float float_value;
-    double double_value;
-    long double long_double_value;
-    const void* pointer;
-    string_value<char_type> string;
-    custom_value<Context> custom;
-    const named_arg_base<char_type>* named_arg;
-  };
-
-  FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
-  FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}
-  value(long long val) : long_long_value(val) {}
-  value(unsigned long long val) : ulong_long_value(val) {}
-  value(int128_t val) : int128_value(val) {}
-  value(uint128_t val) : uint128_value(val) {}
-  value(float val) : float_value(val) {}
-  value(double val) : double_value(val) {}
-  value(long double val) : long_double_value(val) {}
-  value(bool val) : bool_value(val) {}
-  value(char_type val) : char_value(val) {}
-  value(const char_type* val) { string.data = val; }
-  value(basic_string_view<char_type> val) {
-    string.data = val.data();
-    string.size = val.size();
-  }
-  value(const void* val) : pointer(val) {}
-
-  template <typename T> value(const T& val) {
-    custom.value = &val;
-    // Get the formatter type through the context to allow different contexts
-    // have different extension points, e.g. `formatter<T>` for `format` and
-    // `printf_formatter<T>` for `printf`.
-    custom.format = format_custom_arg<
-        T, conditional_t<has_formatter<T, Context>::value,
-                         typename Context::template formatter_type<T>,
-                         fallback_formatter<T, char_type>>>;
-  }
-
-  value(const named_arg_base<char_type>& val) { named_arg = &val; }
-
- private:
-  // Formats an argument of a custom type, such as a user-defined class.
-  template <typename T, typename Formatter>
-  static void format_custom_arg(
-      const void* arg, basic_format_parse_context<char_type>& parse_ctx,
-      Context& ctx) {
-    Formatter f;
-    parse_ctx.advance_to(f.parse(parse_ctx));
-    ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
-  }
-};
-
-template <typename Context, typename T>
-FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value);
-
-// To minimize the number of types we need to deal with, long is translated
-// either to int or to long long depending on its size.
-enum { long_short = sizeof(long) == sizeof(int) };
-using long_type = conditional_t<long_short, int, long long>;
-using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
-
-// Maps formatting arguments to core types.
-template <typename Context> struct arg_mapper {
-  using char_type = typename Context::char_type;
-
-  FMT_CONSTEXPR int map(signed char val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
-  FMT_CONSTEXPR int map(short val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
-  FMT_CONSTEXPR int map(int val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
-  FMT_CONSTEXPR long_type map(long val) { return val; }
-  FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; }
-  FMT_CONSTEXPR long long map(long long val) { return val; }
-  FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
-  FMT_CONSTEXPR int128_t map(int128_t val) { return val; }
-  FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; }
-  FMT_CONSTEXPR bool map(bool val) { return val; }
-
-  template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
-  FMT_CONSTEXPR char_type map(T val) {
-    static_assert(
-        std::is_same<T, char>::value || std::is_same<T, char_type>::value,
-        "mixing character types is disallowed");
-    return val;
-  }
-
-  FMT_CONSTEXPR float map(float val) { return val; }
-  FMT_CONSTEXPR double map(double val) { return val; }
-  FMT_CONSTEXPR long double map(long double val) { return val; }
-
-  FMT_CONSTEXPR const char_type* map(char_type* val) { return val; }
-  FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; }
-  template <typename T, FMT_ENABLE_IF(is_string<T>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
-    static_assert(std::is_same<char_type, char_t<T>>::value,
-                  "mixing character types is disallowed");
-    return to_string_view(val);
-  }
-  template <typename T,
-            FMT_ENABLE_IF(
-                std::is_constructible<basic_string_view<char_type>, T>::value &&
-                !is_string<T>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
-    return basic_string_view<char_type>(val);
-  }
-  template <
-      typename T,
-      FMT_ENABLE_IF(
-          std::is_constructible<std_string_view<char_type>, T>::value &&
-          !std::is_constructible<basic_string_view<char_type>, T>::value &&
-          !is_string<T>::value && !has_formatter<T, Context>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
-    return std_string_view<char_type>(val);
-  }
-  FMT_CONSTEXPR const char* map(const signed char* val) {
-    static_assert(std::is_same<char_type, char>::value, "invalid string type");
-    return reinterpret_cast<const char*>(val);
-  }
-  FMT_CONSTEXPR const char* map(const unsigned char* val) {
-    static_assert(std::is_same<char_type, char>::value, "invalid string type");
-    return reinterpret_cast<const char*>(val);
-  }
-
-  FMT_CONSTEXPR const void* map(void* val) { return val; }
-  FMT_CONSTEXPR const void* map(const void* val) { return val; }
-  FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; }
-  template <typename T> FMT_CONSTEXPR int map(const T*) {
-    // Formatting of arbitrary pointers is disallowed. If you want to output
-    // a pointer cast it to "void *" or "const void *". In particular, this
-    // forbids formatting of "[const] volatile char *" which is printed as bool
-    // by iostreams.
-    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
-    return 0;
-  }
-
-  template <typename T,
-            FMT_ENABLE_IF(std::is_enum<T>::value &&
-                          !has_formatter<T, Context>::value &&
-                          !has_fallback_formatter<T, Context>::value)>
-  FMT_CONSTEXPR auto map(const T& val) -> decltype(
-      map(static_cast<typename std::underlying_type<T>::type>(val))) {
-    return map(static_cast<typename std::underlying_type<T>::type>(val));
-  }
-  template <
-      typename T,
-      FMT_ENABLE_IF(
-          !is_string<T>::value && !is_char<T>::value &&
-          !std::is_constructible<basic_string_view<char_type>, T>::value &&
-          (has_formatter<T, Context>::value ||
-           (has_fallback_formatter<T, Context>::value &&
-            !std::is_constructible<std_string_view<char_type>, T>::value)))>
-  FMT_CONSTEXPR const T& map(const T& val) {
-    return val;
-  }
-
-  template <typename T>
-  FMT_CONSTEXPR const named_arg_base<char_type>& map(
-      const named_arg<T, char_type>& val) {
-    auto arg = make_arg<Context>(val.value);
-    std::memcpy(val.data, &arg, sizeof(arg));
-    return val;
-  }
-};
-
-// A type constant after applying arg_mapper<Context>.
-template <typename T, typename Context>
-using mapped_type_constant =
-    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
-                  typename Context::char_type>;
-
-enum { packed_arg_bits = 5 };
-// Maximum number of arguments with packed types.
-enum { max_packed_args = 63 / packed_arg_bits };
-enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
-
-template <typename Context> class arg_map;
-}  // namespace internal
-
-// A formatting argument. It is a trivially copyable/constructible type to
-// allow storage in basic_memory_buffer.
-template <typename Context> class basic_format_arg {
- private:
-  internal::value<Context> value_;
-  internal::type type_;
-
-  template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(
-      const T& value);
-
-  template <typename Visitor, typename Ctx>
-  friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
-                                             const basic_format_arg<Ctx>& arg)
-      -> decltype(vis(0));
-
-  friend class basic_format_args<Context>;
-  friend class internal::arg_map<Context>;
-
-  using char_type = typename Context::char_type;
-
- public:
-  class handle {
-   public:
-    explicit handle(internal::custom_value<Context> custom) : custom_(custom) {}
-
-    void format(basic_format_parse_context<char_type>& parse_ctx,
-                Context& ctx) const {
-      custom_.format(custom_.value, parse_ctx, ctx);
-    }
-
-   private:
-    internal::custom_value<Context> custom_;
-  };
-
-  FMT_CONSTEXPR basic_format_arg() : type_(internal::none_type) {}
-
-  FMT_CONSTEXPR explicit operator bool() const FMT_NOEXCEPT {
-    return type_ != internal::none_type;
-  }
-
-  internal::type type() const { return type_; }
-
-  bool is_integral() const { return internal::is_integral_type(type_); }
-  bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }
-};
-
-/**
-  \rst
-  Visits an argument dispatching to the appropriate visit method based on
-  the argument type. For example, if the argument type is ``double`` then
-  ``vis(value)`` will be called with the value of type ``double``.
-  \endrst
- */
-template <typename Visitor, typename Context>
-FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
-                                    const basic_format_arg<Context>& arg)
-    -> decltype(vis(0)) {
-  using char_type = typename Context::char_type;
-  switch (arg.type_) {
-  case internal::none_type:
-    break;
-  case internal::named_arg_type:
-    FMT_ASSERT(false, "invalid argument type");
-    break;
-  case internal::int_type:
-    return vis(arg.value_.int_value);
-  case internal::uint_type:
-    return vis(arg.value_.uint_value);
-  case internal::long_long_type:
-    return vis(arg.value_.long_long_value);
-  case internal::ulong_long_type:
-    return vis(arg.value_.ulong_long_value);
-#if FMT_USE_INT128
-  case internal::int128_type:
-    return vis(arg.value_.int128_value);
-  case internal::uint128_type:
-    return vis(arg.value_.uint128_value);
-#else
-  case internal::int128_type:
-  case internal::uint128_type:
-    break;
-#endif
-  case internal::bool_type:
-    return vis(arg.value_.bool_value);
-  case internal::char_type:
-    return vis(arg.value_.char_value);
-  case internal::float_type:
-    return vis(arg.value_.float_value);
-  case internal::double_type:
-    return vis(arg.value_.double_value);
-  case internal::long_double_type:
-    return vis(arg.value_.long_double_value);
-  case internal::cstring_type:
-    return vis(arg.value_.string.data);
-  case internal::string_type:
-    return vis(basic_string_view<char_type>(arg.value_.string.data,
-                                            arg.value_.string.size));
-  case internal::pointer_type:
-    return vis(arg.value_.pointer);
-  case internal::custom_type:
-    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
-  }
-  return vis(monostate());
-}
-
-namespace internal {
-// A map from argument names to their values for named arguments.
-template <typename Context> class arg_map {
- private:
-  using char_type = typename Context::char_type;
-
-  struct entry {
-    basic_string_view<char_type> name;
-    basic_format_arg<Context> arg;
-  };
-
-  entry* map_;
-  unsigned size_;
-
-  void push_back(value<Context> val) {
-    const auto& named = *val.named_arg;
-    map_[size_] = {named.name, named.template deserialize<Context>()};
-    ++size_;
-  }
-
- public:
-  arg_map(const arg_map&) = delete;
-  void operator=(const arg_map&) = delete;
-  arg_map() : map_(nullptr), size_(0) {}
-  void init(const basic_format_args<Context>& args);
-  ~arg_map() { delete[] map_; }
-
-  basic_format_arg<Context> find(basic_string_view<char_type> name) const {
-    // The list is unsorted, so just return the first matching name.
-    for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
-      if (it->name == name) return it->arg;
-    }
-    return {};
-  }
-};
-
-// A type-erased reference to an std::locale to avoid heavy <locale> include.
-class locale_ref {
- private:
-  const void* locale_;  // A type-erased pointer to std::locale.
-
- public:
-  locale_ref() : locale_(nullptr) {}
-  template <typename Locale> explicit locale_ref(const Locale& loc);
-
-  explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }
-
-  template <typename Locale> Locale get() const;
-};
-
-template <typename> constexpr unsigned long long encode_types() { return 0; }
-
-template <typename Context, typename Arg, typename... Args>
-constexpr unsigned long long encode_types() {
-  return mapped_type_constant<Arg, Context>::value |
-         (encode_types<Context, Args...>() << packed_arg_bits);
-}
-
-template <typename Context, typename T>
-FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value) {
-  basic_format_arg<Context> arg;
-  arg.type_ = mapped_type_constant<T, Context>::value;
-  arg.value_ = arg_mapper<Context>().map(value);
-  return arg;
-}
-
-template <bool IS_PACKED, typename Context, typename T,
-          FMT_ENABLE_IF(IS_PACKED)>
-inline value<Context> make_arg(const T& val) {
-  return arg_mapper<Context>().map(val);
-}
-
-template <bool IS_PACKED, typename Context, typename T,
-          FMT_ENABLE_IF(!IS_PACKED)>
-inline basic_format_arg<Context> make_arg(const T& value) {
-  return make_arg<Context>(value);
-}
-}  // namespace internal
-
-// Formatting context.
-template <typename OutputIt, typename Char> class basic_format_context {
- public:
-  /** The character type for the output. */
-  using char_type = Char;
-
- private:
-  OutputIt out_;
-  basic_format_args<basic_format_context> args_;
-  internal::arg_map<basic_format_context> map_;
-  internal::locale_ref loc_;
-
- public:
-  using iterator = OutputIt;
-  using format_arg = basic_format_arg<basic_format_context>;
-  template <typename T> using formatter_type = formatter<T, char_type>;
-
-  basic_format_context(const basic_format_context&) = delete;
-  void operator=(const basic_format_context&) = delete;
-  /**
-   Constructs a ``basic_format_context`` object. References to the arguments are
-   stored in the object so make sure they have appropriate lifetimes.
-   */
-  basic_format_context(OutputIt out,
-                       basic_format_args<basic_format_context> ctx_args,
-                       internal::locale_ref loc = internal::locale_ref())
-      : out_(out), args_(ctx_args), loc_(loc) {}
-
-  format_arg arg(int id) const { return args_.get(id); }
-
-  // Checks if manual indexing is used and returns the argument with the
-  // specified name.
-  format_arg arg(basic_string_view<char_type> name);
-
-  internal::error_handler error_handler() { return {}; }
-  void on_error(const char* message) { error_handler().on_error(message); }
-
-  // Returns an iterator to the beginning of the output range.
-  iterator out() { return out_; }
-
-  // Advances the begin iterator to ``it``.
-  void advance_to(iterator it) { out_ = it; }
-
-  internal::locale_ref locale() { return loc_; }
-};
-
-template <typename Char>
-using buffer_context =
-    basic_format_context<std::back_insert_iterator<internal::buffer<Char>>,
-                         Char>;
-using format_context = buffer_context<char>;
-using wformat_context = buffer_context<wchar_t>;
-
-/**
-  \rst
-  An array of references to arguments. It can be implicitly converted into
-  `~fmt::basic_format_args` for passing into type-erased formatting functions
-  such as `~fmt::vformat`.
-  \endrst
- */
-template <typename Context, typename... Args> class format_arg_store {
- private:
-  static const size_t num_args = sizeof...(Args);
-  static const bool is_packed = num_args < internal::max_packed_args;
-
-  using value_type = conditional_t<is_packed, internal::value<Context>,
-                                   basic_format_arg<Context>>;
-
-  // If the arguments are not packed, add one more element to mark the end.
-  value_type data_[num_args + (num_args == 0 ? 1 : 0)];
-
-  friend class basic_format_args<Context>;
-
- public:
-  static constexpr unsigned long long types =
-      is_packed ? internal::encode_types<Context, Args...>()
-                : internal::is_unpacked_bit | num_args;
-
-  format_arg_store(const Args&... args)
-      : data_{internal::make_arg<is_packed, Context>(args)...} {}
-};
-
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::format_args`. `Context`
-  can be omitted in which case it defaults to `~fmt::context`.
-  See `~fmt::arg` for lifetime considerations.
-  \endrst
- */
-template <typename Context = format_context, typename... Args>
-inline format_arg_store<Context, Args...> make_format_args(
-    const Args&... args) {
-  return {args...};
-}
-
-/** Formatting arguments. */
-template <typename Context> class basic_format_args {
- public:
-  using size_type = int;
-  using format_arg = basic_format_arg<Context>;
-
- private:
-  // To reduce compiled code size per formatting function call, types of first
-  // max_packed_args arguments are passed in the types_ field.
-  unsigned long long types_;
-  union {
-    // If the number of arguments is less than max_packed_args, the argument
-    // values are stored in values_, otherwise they are stored in args_.
-    // This is done to reduce compiled code size as storing larger objects
-    // may require more code (at least on x86-64) even if the same amount of
-    // data is actually copied to stack. It saves ~10% on the bloat test.
-    const internal::value<Context>* values_;
-    const format_arg* args_;
-  };
-
-  bool is_packed() const { return (types_ & internal::is_unpacked_bit) == 0; }
-
-  internal::type type(int index) const {
-    int shift = index * internal::packed_arg_bits;
-    unsigned int mask = (1 << internal::packed_arg_bits) - 1;
-    return static_cast<internal::type>((types_ >> shift) & mask);
-  }
-
-  friend class internal::arg_map<Context>;
-
-  void set_data(const internal::value<Context>* values) { values_ = values; }
-  void set_data(const format_arg* args) { args_ = args; }
-
-  format_arg do_get(int index) const {
-    format_arg arg;
-    if (!is_packed()) {
-      auto num_args = max_size();
-      if (index < num_args) arg = args_[index];
-      return arg;
-    }
-    if (index > internal::max_packed_args) return arg;
-    arg.type_ = type(index);
-    if (arg.type_ == internal::none_type) return arg;
-    internal::value<Context>& val = arg.value_;
-    val = values_[index];
-    return arg;
-  }
-
- public:
-  basic_format_args() : types_(0) {}
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
-   \endrst
-   */
-  template <typename... Args>
-  basic_format_args(const format_arg_store<Context, Args...>& store)
-      : types_(store.types) {
-    set_data(store.data_);
-  }
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from a dynamic set of arguments.
-   \endrst
-   */
-  basic_format_args(const format_arg* args, int count)
-      : types_(internal::is_unpacked_bit | internal::to_unsigned(count)) {
-    set_data(args);
-  }
-
-  /** Returns the argument at specified index. */
-  format_arg get(int index) const {
-    format_arg arg = do_get(index);
-    if (arg.type_ == internal::named_arg_type)
-      arg = arg.value_.named_arg->template deserialize<Context>();
-    return arg;
-  }
-
-  int max_size() const {
-    unsigned long long max_packed = internal::max_packed_args;
-    return static_cast<int>(is_packed() ? max_packed
-                                        : types_ & ~internal::is_unpacked_bit);
-  }
-};
-
-/** An alias to ``basic_format_args<context>``. */
-// It is a separate type rather than an alias to make symbols readable.
-struct format_args : basic_format_args<format_context> {
-  template <typename... Args>
-  format_args(Args&&... args)
-      : basic_format_args<format_context>(std::forward<Args>(args)...) {}
-};
-struct wformat_args : basic_format_args<wformat_context> {
-  template <typename... Args>
-  wformat_args(Args&&... args)
-      : basic_format_args<wformat_context>(std::forward<Args>(args)...) {}
-};
-
-template <typename Container> struct is_contiguous : std::false_type {};
-
-template <typename Char>
-struct is_contiguous<std::basic_string<Char>> : std::true_type {};
-
-template <typename Char>
-struct is_contiguous<internal::buffer<Char>> : std::true_type {};
-
-namespace internal {
-
-template <typename OutputIt>
-struct is_contiguous_back_insert_iterator : std::false_type {};
-template <typename Container>
-struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
-    : is_contiguous<Container> {};
-
-template <typename Char> struct named_arg_base {
-  basic_string_view<Char> name;
-
-  // Serialized value<context>.
-  mutable char data[sizeof(basic_format_arg<buffer_context<Char>>)];
-
-  named_arg_base(basic_string_view<Char> nm) : name(nm) {}
-
-  template <typename Context> basic_format_arg<Context> deserialize() const {
-    basic_format_arg<Context> arg;
-    std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
-    return arg;
-  }
-};
-
-template <typename T, typename Char> struct named_arg : named_arg_base<Char> {
-  const T& value;
-
-  named_arg(basic_string_view<Char> name, const T& val)
-      : named_arg_base<Char>(name), value(val) {}
-};
-
-template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
-inline void check_format_string(const S&) {
-#if defined(FMT_ENFORCE_COMPILE_STRING)
-  static_assert(is_compile_string<S>::value,
-                "FMT_ENFORCE_COMPILE_STRING requires all format strings to "
-                "utilize FMT_STRING() or fmt().");
-#endif
-}
-template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-void check_format_string(S);
-
-struct view {};
-template <bool...> struct bool_pack;
-template <bool... Args>
-using all_true =
-    std::is_same<bool_pack<Args..., true>, bool_pack<true, Args...>>;
-
-template <typename... Args, typename S, typename Char = char_t<S>>
-inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
-make_args_checked(const S& format_str,
-                  const remove_reference_t<Args>&... args) {
-  static_assert(all_true<(!std::is_base_of<view, remove_reference_t<Args>>() ||
-                          !std::is_reference<Args>())...>::value,
-                "passing views as lvalues is disallowed");
-  check_format_string<remove_const_t<remove_reference_t<Args>>...>(format_str);
-  return {args...};
-}
-
-template <typename Char>
-std::basic_string<Char> vformat(basic_string_view<Char> format_str,
-                                basic_format_args<buffer_context<Char>> args);
-
-template <typename Char>
-typename buffer_context<Char>::iterator vformat_to(
-    buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args);
-}  // namespace internal
-
-/**
-  \rst
-  Returns a named argument to be used in a formatting function.
-
-  The named argument holds a reference and does not extend the lifetime
-  of its arguments.
-  Consequently, a dangling reference can accidentally be created.
-  The user should take care to only pass this function temporaries when
-  the named argument is itself a temporary, as per the following example.
-
-  **Example**::
-
-    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
-  \endrst
- */
-template <typename S, typename T, typename Char = char_t<S>>
-inline internal::named_arg<T, Char> arg(const S& name, const T& arg) {
-  static_assert(internal::is_string<S>::value, "");
-  return {name, arg};
-}
-
-// Disable nested named arguments, e.g. ``arg("a", arg("b", 42))``.
-template <typename S, typename T, typename Char>
-void arg(S, internal::named_arg<T, Char>) = delete;
-
-/** Formats a string and writes the output to ``out``. */
-// GCC 8 and earlier cannot handle std::back_insert_iterator<Container> with
-// vformat_to<ArgFormatter>(...) overload, so SFINAE on iterator type instead.
-template <typename OutputIt, typename S, typename Char = char_t<S>,
-          FMT_ENABLE_IF(
-              internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
-OutputIt vformat_to(OutputIt out, const S& format_str,
-                    basic_format_args<buffer_context<Char>> args) {
-  using container = remove_reference_t<decltype(internal::get_container(out))>;
-  internal::container_buffer<container> buf((internal::get_container(out)));
-  internal::vformat_to(buf, to_string_view(format_str), args);
-  return out;
-}
-
-template <typename Container, typename S, typename... Args,
-          FMT_ENABLE_IF(
-              is_contiguous<Container>::value&& internal::is_string<S>::value)>
-inline std::back_insert_iterator<Container> format_to(
-    std::back_insert_iterator<Container> out, const S& format_str,
-    Args&&... args) {
-  return vformat_to(
-      out, to_string_view(format_str),
-      {internal::make_args_checked<Args...>(format_str, args...)});
-}
-
-template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vformat(
-    const S& format_str, basic_format_args<buffer_context<Char>> args) {
-  return internal::vformat(to_string_view(format_str), args);
-}
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    #include <fmt/core.h>
-    std::string message = fmt::format("The answer is {}", 42);
-  \endrst
-*/
-// Pass char_t as a default template parameter instead of using
-// std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline std::basic_string<Char> format(const S& format_str, Args&&... args) {
-  return internal::vformat(
-      to_string_view(format_str),
-      {internal::make_args_checked<Args...>(format_str, args...)});
-}
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_CORE_H_
-
-
-// LICENSE_CHANGE_END
-
-
-#include <algorithm>
-#include <cerrno>
-#include <cmath>
-#include <cstdint>
-#include <limits>
-#include <memory>
-#include <stdexcept>
-
-#ifdef __clang__
-#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
-#else
-#  define FMT_CLANG_VERSION 0
-#endif
-
-#ifdef __INTEL_COMPILER
-#  define FMT_ICC_VERSION __INTEL_COMPILER
-#elif defined(__ICL)
-#  define FMT_ICC_VERSION __ICL
-#else
-#  define FMT_ICC_VERSION 0
-#endif
-
-#ifdef __NVCC__
-#  define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
-#else
-#  define FMT_CUDA_VERSION 0
-#endif
-
-#ifdef __has_builtin
-#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
-#else
-#  define FMT_HAS_BUILTIN(x) 0
-#endif
-
-#if FMT_HAS_CPP_ATTRIBUTE(fallthrough) && \
-    (__cplusplus >= 201703 || FMT_GCC_VERSION != 0)
-#  define FMT_FALLTHROUGH [[fallthrough]]
-#else
-#  define FMT_FALLTHROUGH
-#endif
-
-#ifndef FMT_THROW
-#  if FMT_EXCEPTIONS
-#    if FMT_MSC_VER
-FMT_BEGIN_NAMESPACE
-namespace internal {
-template <typename Exception> inline void do_throw(const Exception& x) {
-  // Silence unreachable code warnings in MSVC because these are nearly
-  // impossible to fix in a generic code.
-  volatile bool b = true;
-  if (b) throw x;
-}
-}  // namespace internal
-FMT_END_NAMESPACE
-#      define FMT_THROW(x) internal::do_throw(x)
-#    else
-#      define FMT_THROW(x) throw x
-#    endif
-#  else
-#    define FMT_THROW(x)              \
-      do {                            \
-        static_cast<void>(sizeof(x)); \
-        FMT_ASSERT(false, "");        \
-      } while (false)
-#  endif
-#endif
-
-#ifndef FMT_USE_USER_DEFINED_LITERALS
-// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.
-#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 ||      \
-       FMT_MSC_VER >= 1900) &&                                              \
-      (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \
-       FMT_CUDA_VERSION >= 700)
-#    define FMT_USE_USER_DEFINED_LITERALS 1
-#  else
-#    define FMT_USE_USER_DEFINED_LITERALS 0
-#  endif
-#endif
-
-#ifndef FMT_USE_UDL_TEMPLATE
-#define FMT_USE_UDL_TEMPLATE 0
-#endif
-
-// __builtin_clz is broken in clang with Microsoft CodeGen:
-// https://github.com/fmtlib/fmt/issues/519
-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
-#endif
-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
-#endif
-
-// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
-// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
-// MSVC intrinsics if the clz and clzll builtins are not available.
-#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
-#  include <intrin.h>  // _BitScanReverse, _BitScanReverse64
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
-#  ifndef __clang__
-#    pragma intrinsic(_BitScanReverse)
-#  endif
-inline uint32_t clz(uint32_t x) {
-  unsigned long r = 0;
-  _BitScanReverse(&r, x);
-
-  FMT_ASSERT(x != 0, "");
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-#  pragma warning(suppress : 6102)
-  return 31 - r;
-}
-#  define FMT_BUILTIN_CLZ(n) internal::clz(n)
-
-#  if defined(_WIN64) && !defined(__clang__)
-#    pragma intrinsic(_BitScanReverse64)
-#  endif
-
-inline uint32_t clzll(uint64_t x) {
-  unsigned long r = 0;
-#  ifdef _WIN64
-  _BitScanReverse64(&r, x);
-#  else
-  // Scan the high 32 bits.
-  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 - (r + 32);
-
-  // Scan the low 32 bits.
-  _BitScanReverse(&r, static_cast<uint32_t>(x));
-#  endif
-
-  FMT_ASSERT(x != 0, "");
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-#  pragma warning(suppress : 6102)
-  return 63 - r;
-}
-#  define FMT_BUILTIN_CLZLL(n) internal::clzll(n)
-}  // namespace internal
-FMT_END_NAMESPACE
-#endif
-
-// Enable the deprecated numeric alignment.
-#ifndef FMT_NUMERIC_ALIGN
-#  define FMT_NUMERIC_ALIGN 1
-#endif
-
-// Enable the deprecated percent specifier.
-#ifndef FMT_DEPRECATED_PERCENT
-#  define FMT_DEPRECATED_PERCENT 0
-#endif
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-// A helper function to suppress bogus "conditional expression is constant"
-// warnings.
-template <typename T> inline T const_check(T value) { return value; }
-
-// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have
-// undefined behavior (e.g. due to type aliasing).
-// Example: uint64_t d = bit_cast<uint64_t>(2.718);
-template <typename Dest, typename Source>
-inline Dest bit_cast(const Source& source) {
-  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
-  Dest dest;
-  std::memcpy(&dest, &source, sizeof(dest));
-  return dest;
-}
-
-inline bool is_big_endian() {
-  auto u = 1u;
-  struct bytes {
-    char data[sizeof(u)];
-  };
-  return bit_cast<bytes>(u).data[0] == 0;
-}
-
-// A fallback implementation of uintptr_t for systems that lack it.
-struct fallback_uintptr {
-  unsigned char value[sizeof(void*)];
-
-  fallback_uintptr() = default;
-  explicit fallback_uintptr(const void* p) {
-    *this = bit_cast<fallback_uintptr>(p);
-    if (is_big_endian()) {
-      for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
-        std::swap(value[i], value[j]);
-    }
-  }
-};
-#ifdef UINTPTR_MAX
-using uintptr_t = ::uintptr_t;
-inline uintptr_t to_uintptr(const void* p) { return bit_cast<uintptr_t>(p); }
-#else
-using uintptr_t = fallback_uintptr;
-inline fallback_uintptr to_uintptr(const void* p) {
-  return fallback_uintptr(p);
-}
-#endif
-
-// Returns the largest possible value for type T. Same as
-// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
-template <typename T> constexpr T max_value() {
-  return (std::numeric_limits<T>::max)();
-}
-template <typename T> constexpr int num_bits() {
-  return std::numeric_limits<T>::digits;
-}
-template <> constexpr int num_bits<fallback_uintptr>() {
-  return static_cast<int>(sizeof(void*) *
-                          std::numeric_limits<unsigned char>::digits);
-}
-
-// An approximation of iterator_t for pre-C++20 systems.
-template <typename T>
-using iterator_t = decltype(std::begin(std::declval<T&>()));
-
-// Detect the iterator category of *any* given type in a SFINAE-friendly way.
-// Unfortunately, older implementations of std::iterator_traits are not safe
-// for use in a SFINAE-context.
-template <typename It, typename Enable = void>
-struct iterator_category : std::false_type {};
-
-template <typename T> struct iterator_category<T*> {
-  using type = std::random_access_iterator_tag;
-};
-
-template <typename It>
-struct iterator_category<It, void_t<typename It::iterator_category>> {
-  using type = typename It::iterator_category;
-};
-
-// Detect if *any* given type models the OutputIterator concept.
-template <typename It> class is_output_iterator {
-  // Check for mutability because all iterator categories derived from
-  // std::input_iterator_tag *may* also meet the requirements of an
-  // OutputIterator, thereby falling into the category of 'mutable iterators'
-  // [iterator.requirements.general] clause 4. The compiler reveals this
-  // property only at the point of *actually dereferencing* the iterator!
-  template <typename U>
-  static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
-  template <typename U> static char& test(std::output_iterator_tag);
-  template <typename U> static const char& test(...);
-
-  using type = decltype(test<It>(typename iterator_category<It>::type{}));
-
- public:
-  static const bool value = !std::is_const<remove_reference_t<type>>::value;
-};
-
-// A workaround for std::string not having mutable data() until C++17.
-template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
-  return &s[0];
-}
-template <typename Container>
-inline typename Container::value_type* get_data(Container& c) {
-  return c.data();
-}
-
-#ifdef _SECURE_SCL
-// Make a checked iterator to avoid MSVC warnings.
-template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
-template <typename T> checked_ptr<T> make_checked(T* p, std::size_t size) {
-  return {p, size};
-}
-#else
-template <typename T> using checked_ptr = T*;
-template <typename T> inline T* make_checked(T* p, std::size_t) { return p; }
-#endif
-
-template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
-inline checked_ptr<typename Container::value_type> reserve(
-    std::back_insert_iterator<Container>& it, std::size_t n) {
-  Container& c = get_container(it);
-  std::size_t size = c.size();
-  c.resize(size + n);
-  return make_checked(get_data(c) + size, n);
-}
-
-template <typename Iterator>
-inline Iterator& reserve(Iterator& it, std::size_t) {
-  return it;
-}
-
-// An output iterator that counts the number of objects written to it and
-// discards them.
-class counting_iterator {
- private:
-  std::size_t count_;
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = std::ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
-
-  struct value_type {
-    template <typename T> void operator=(const T&) {}
-  };
-
-  counting_iterator() : count_(0) {}
-
-  std::size_t count() const { return count_; }
-
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
-  }
-
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  value_type operator*() const { return {}; }
-};
-
-template <typename OutputIt> class truncating_iterator_base {
- protected:
-  OutputIt out_;
-  std::size_t limit_;
-  std::size_t count_;
-
-  truncating_iterator_base(OutputIt out, std::size_t limit)
-      : out_(out), limit_(limit), count_(0) {}
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = void;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type =
-      truncating_iterator_base;  // Mark iterator as checked.
-
-  OutputIt base() const { return out_; }
-  std::size_t count() const { return count_; }
-};
-
-// An output iterator that truncates the output and counts the number of objects
-// written to it.
-template <typename OutputIt,
-          typename Enable = typename std::is_void<
-              typename std::iterator_traits<OutputIt>::value_type>::type>
-class truncating_iterator;
-
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::false_type>
-    : public truncating_iterator_base<OutputIt> {
-  using traits = std::iterator_traits<OutputIt>;
-
-  mutable typename traits::value_type blackhole_;
-
- public:
-  using value_type = typename traits::value_type;
-
-  truncating_iterator(OutputIt out, std::size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
-
-  truncating_iterator& operator++() {
-    if (this->count_++ < this->limit_) ++this->out_;
-    return *this;
-  }
-
-  truncating_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  value_type& operator*() const {
-    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
-  }
-};
-
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::true_type>
-    : public truncating_iterator_base<OutputIt> {
- public:
-  using value_type = typename OutputIt::container_type::value_type;
-
-  truncating_iterator(OutputIt out, std::size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
-
-  truncating_iterator& operator=(value_type val) {
-    if (this->count_++ < this->limit_) this->out_ = val;
-    return *this;
-  }
-
-  truncating_iterator& operator++() { return *this; }
-  truncating_iterator& operator++(int) { return *this; }
-  truncating_iterator& operator*() { return *this; }
-};
-
-// A range with the specified output iterator and value type.
-template <typename OutputIt, typename T = typename OutputIt::value_type>
-class output_range {
- private:
-  OutputIt it_;
-
- public:
-  using value_type = T;
-  using iterator = OutputIt;
-  struct sentinel {};
-
-  explicit output_range(OutputIt it) : it_(it) {}
-  OutputIt begin() const { return it_; }
-  sentinel end() const { return {}; }  // Sentinel is not used yet.
-};
-
-template <typename Char>
-inline size_t count_code_points(basic_string_view<Char> s) {
-  return s.size();
-}
-
-// Counts the number of code points in a UTF-8 string.
-inline size_t count_code_points(basic_string_view<char8_t> s) {
-  const char8_t* data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
-  }
-  return num_code_points;
-}
-
-template <typename Char>
-inline size_t code_point_index(basic_string_view<Char> s, size_t n) {
-  size_t size = s.size();
-  return n < size ? n : size;
-}
-
-// Calculates the index of the nth code point in a UTF-8 string.
-inline size_t code_point_index(basic_string_view<char8_t> s, size_t n) {
-  const char8_t* data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) {
-      return i;
-    }
-  }
-  return s.size();
-}
-
-inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
-
-template <typename InputIt, typename OutChar>
-using needs_conversion = bool_constant<
-    std::is_same<typename std::iterator_traits<InputIt>::value_type,
-                 char>::value &&
-    std::is_same<OutChar, char8_t>::value>;
-
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::copy(begin, end, it);
-}
-
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::transform(begin, end, it, to_char8_t);
-}
-
-#ifndef FMT_USE_GRISU
-#  define FMT_USE_GRISU 1
-#endif
-
-template <typename T> constexpr bool use_grisu() {
-  return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
-         sizeof(T) <= sizeof(double);
-}
-
-template <typename T>
-template <typename U>
-void buffer<T>::append(const U* begin, const U* end) {
-  std::size_t new_size = size_ + to_unsigned(end - begin);
-  reserve(new_size);
-  std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);
-  size_ = new_size;
-}
-}  // namespace internal
-
-// A range with an iterator appending to a buffer.
-template <typename T>
-class buffer_range : public internal::output_range<
-                         std::back_insert_iterator<internal::buffer<T>>, T> {
- public:
-  using iterator = std::back_insert_iterator<internal::buffer<T>>;
-  using internal::output_range<iterator, T>::output_range;
-  buffer_range(internal::buffer<T>& buf)
-      : internal::output_range<iterator, T>(std::back_inserter(buf)) {}
-};
-
-// A UTF-8 string view.
-class u8string_view : public basic_string_view<char8_t> {
- public:
-  u8string_view(const char* s)
-      : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s)) {}
-  u8string_view(const char* s, size_t count) FMT_NOEXCEPT
-      : basic_string_view<char8_t>(reinterpret_cast<const char8_t*>(s), count) {
-  }
-};
-
-#if FMT_USE_USER_DEFINED_LITERALS
-inline namespace literals {
-inline u8string_view operator"" _u(const char* s, std::size_t n) {
-  return {s, n};
-}
-}  // namespace literals
-#endif
-
-// The number of characters to store in the basic_memory_buffer object itself
-// to avoid dynamic memory allocation.
-enum { inline_buffer_size = 500 };
-
-/**
-  \rst
-  A dynamically growing memory buffer for trivially copyable/constructible types
-  with the first ``SIZE`` elements stored in the object itself.
-
-  You can use one of the following type aliases for common character types:
-
-  +----------------+------------------------------+
-  | Type           | Definition                   |
-  +================+==============================+
-  | memory_buffer  | basic_memory_buffer<char>    |
-  +----------------+------------------------------+
-  | wmemory_buffer | basic_memory_buffer<wchar_t> |
-  +----------------+------------------------------+
-
-  **Example**::
-
-     fmt::memory_buffer out;
-     format_to(out, "The answer is {}.", 42);
-
-  This will append the following output to the ``out`` object:
-
-  .. code-block:: none
-
-     The answer is 42.
-
-  The output can be converted to an ``std::string`` with ``to_string(out)``.
-  \endrst
- */
-template <typename T, std::size_t SIZE = inline_buffer_size,
-          typename Allocator = std::allocator<T>>
-class basic_memory_buffer : private Allocator, public internal::buffer<T> {
- private:
-  T store_[SIZE];
-
-  // Deallocate memory allocated by the buffer.
-  void deallocate() {
-    T* data = this->data();
-    if (data != store_) Allocator::deallocate(data, this->capacity());
-  }
-
- protected:
-  void grow(std::size_t size) FMT_OVERRIDE;
-
- public:
-  using value_type = T;
-  using const_reference = const T&;
-
-  explicit basic_memory_buffer(const Allocator& alloc = Allocator())
-      : Allocator(alloc) {
-    this->set(store_, SIZE);
-  }
-  ~basic_memory_buffer() FMT_OVERRIDE { deallocate(); }
-
- private:
-  // Move data from other to this buffer.
-  void move(basic_memory_buffer& other) {
-    Allocator &this_alloc = *this, &other_alloc = other;
-    this_alloc = std::move(other_alloc);
-    T* data = other.data();
-    std::size_t size = other.size(), capacity = other.capacity();
-    if (data == other.store_) {
-      this->set(store_, capacity);
-      std::uninitialized_copy(other.store_, other.store_ + size,
-                              internal::make_checked(store_, capacity));
-    } else {
-      this->set(data, capacity);
-      // Set pointer to the inline array so that delete is not called
-      // when deallocating.
-      other.set(other.store_, 0);
-    }
-    this->resize(size);
-  }
-
- public:
-  /**
-    \rst
-    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
-    of the other object to it.
-    \endrst
-   */
-  basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }
-
-  /**
-    \rst
-    Moves the content of the other ``basic_memory_buffer`` object to this one.
-    \endrst
-   */
-  basic_memory_buffer& operator=(basic_memory_buffer&& other) FMT_NOEXCEPT {
-    FMT_ASSERT(this != &other, "");
-    deallocate();
-    move(other);
-    return *this;
-  }
-
-  // Returns a copy of the allocator associated with this buffer.
-  Allocator get_allocator() const { return *this; }
-};
-
-template <typename T, std::size_t SIZE, typename Allocator>
-void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  if (size > 1000) throw std::runtime_error("fuzz mode - won't grow that much");
-#endif
-  std::size_t old_capacity = this->capacity();
-  std::size_t new_capacity = old_capacity + old_capacity / 2;
-  if (size > new_capacity) new_capacity = size;
-  T* old_data = this->data();
-  T* new_data = std::allocator_traits<Allocator>::allocate(*this, new_capacity);
-  // The following code doesn't throw, so the raw pointer above doesn't leak.
-  std::uninitialized_copy(old_data, old_data + this->size(),
-                          internal::make_checked(new_data, new_capacity));
-  this->set(new_data, new_capacity);
-  // deallocate must not throw according to the standard, but even if it does,
-  // the buffer already uses the new storage and will deallocate it in
-  // destructor.
-  if (old_data != store_) Allocator::deallocate(old_data, old_capacity);
-}
-
-using memory_buffer = basic_memory_buffer<char>;
-using wmemory_buffer = basic_memory_buffer<wchar_t>;
-
-namespace internal {
-
-// Returns true if value is negative, false otherwise.
-// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
-template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
-FMT_CONSTEXPR bool is_negative(T value) {
-  return value < 0;
-}
-template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
-FMT_CONSTEXPR bool is_negative(T) {
-  return false;
-}
-
-// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
-// represent all values of T.
-template <typename T>
-using uint32_or_64_or_128_t = conditional_t<
-    std::numeric_limits<T>::digits <= 32, uint32_t,
-    conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;
-
-// Static data is placed in this class template for the header-only config.
-template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
-  static const uint64_t powers_of_10_64[];
-  static const uint32_t zero_or_powers_of_10_32[];
-  static const uint64_t zero_or_powers_of_10_64[];
-  static const uint64_t pow10_significands[];
-  static const int16_t pow10_exponents[];
-  static const char digits[];
-  static const char hex_digits[];
-  static const char foreground_color[];
-  static const char background_color[];
-  static const char reset_color[5];
-  static const wchar_t wreset_color[5];
-  static const char signs[];
-};
-
-FMT_EXTERN template struct basic_data<void>;
-
-// This is a struct rather than an alias to avoid shadowing warnings in gcc.
-struct data : basic_data<> {};
-
-#ifdef FMT_BUILTIN_CLZLL
-// Returns the number of decimal digits in n. Leading zeros are not counted
-// except for n == 0 in which case count_digits returns 1.
-inline int count_digits(uint64_t n) {
-  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
-  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
-  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-  return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
-}
-#else
-// Fallback version of count_digits used when __builtin_clz is not available.
-inline int count_digits(uint64_t n) {
-  int count = 1;
-  for (;;) {
-    // Integer division is slow so do it for a group of four digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    if (n < 10000) return count + 3;
-    n /= 10000u;
-    count += 4;
-  }
-}
-#endif
-
-#if FMT_USE_INT128
-inline int count_digits(uint128_t n) {
-  int count = 1;
-  for (;;) {
-    // Integer division is slow so do it for a group of four digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    if (n < 10000) return count + 3;
-    n /= 10000U;
-    count += 4;
-  }
-}
-#endif
-
-// Counts the number of digits in n. BITS = log2(radix).
-template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
-  int num_digits = 0;
-  do {
-    ++num_digits;
-  } while ((n >>= BITS) != 0);
-  return num_digits;
-}
-
-template <> int count_digits<4>(internal::fallback_uintptr n);
-
-#if FMT_GCC_VERSION || FMT_CLANG_VERSION
-#  define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
-#else
-#  define FMT_ALWAYS_INLINE
-#endif
-
-#ifdef FMT_BUILTIN_CLZ
-// Optional version of count_digits for better performance on 32-bit platforms.
-inline int count_digits(uint32_t n) {
-  int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
-  return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
-}
-#endif
-
-template <typename Char> FMT_API std::string grouping_impl(locale_ref loc);
-template <typename Char> inline std::string grouping(locale_ref loc) {
-  return grouping_impl<char>(loc);
-}
-template <> inline std::string grouping<wchar_t>(locale_ref loc) {
-  return grouping_impl<wchar_t>(loc);
-}
-
-template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
-template <typename Char> inline Char thousands_sep(locale_ref loc) {
-  return Char(thousands_sep_impl<char>(loc));
-}
-template <> inline wchar_t thousands_sep(locale_ref loc) {
-  return thousands_sep_impl<wchar_t>(loc);
-}
-
-template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
-template <typename Char> inline Char decimal_point(locale_ref loc) {
-  return Char(decimal_point_impl<char>(loc));
-}
-template <> inline wchar_t decimal_point(locale_ref loc) {
-  return decimal_point_impl<wchar_t>(loc);
-}
-
-// Formats a decimal unsigned integer value writing into buffer.
-// add_thousands_sep is called after writing each char to add a thousands
-// separator if necessary.
-template <typename UInt, typename Char, typename F>
-inline Char* format_decimal(Char* buffer, UInt value, int num_digits,
-                            F add_thousands_sep) {
-  FMT_ASSERT(num_digits >= 0, "invalid digit count");
-  buffer += num_digits;
-  Char* end = buffer;
-  while (value >= 100) {
-    // Integer division is slow so do it for a group of two digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    auto index = static_cast<unsigned>((value % 100) * 2);
-    value /= 100;
-    *--buffer = static_cast<Char>(data::digits[index + 1]);
-    add_thousands_sep(buffer);
-    *--buffer = static_cast<Char>(data::digits[index]);
-    add_thousands_sep(buffer);
-  }
-  if (value < 10) {
-    *--buffer = static_cast<Char>('0' + value);
-    return end;
-  }
-  auto index = static_cast<unsigned>(value * 2);
-  *--buffer = static_cast<Char>(data::digits[index + 1]);
-  add_thousands_sep(buffer);
-  *--buffer = static_cast<Char>(data::digits[index]);
-  return end;
-}
-
-template <typename Int> constexpr int digits10() noexcept {
-  return std::numeric_limits<Int>::digits10;
-}
-template <> constexpr int digits10<int128_t>() noexcept { return 38; }
-template <> constexpr int digits10<uint128_t>() noexcept { return 38; }
-
-template <typename Char, typename UInt, typename Iterator, typename F>
-inline Iterator format_decimal(Iterator out, UInt value, int num_digits,
-                               F add_thousands_sep) {
-  FMT_ASSERT(num_digits >= 0, "invalid digit count");
-  // Buffer should be large enough to hold all digits (<= digits10 + 1).
-  enum { max_size = digits10<UInt>() + 1 };
-  Char buffer[2 * max_size];
-  auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
-  return internal::copy_str<Char>(buffer, end, out);
-}
-
-template <typename Char, typename It, typename UInt>
-inline It format_decimal(It out, UInt value, int num_digits) {
-  return format_decimal<Char>(out, value, num_digits, [](Char*) {});
-}
-
-template <unsigned BASE_BITS, typename Char, typename UInt>
-inline Char* format_uint(Char* buffer, UInt value, int num_digits,
-                         bool upper = false) {
-  buffer += num_digits;
-  Char* end = buffer;
-  do {
-    const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
-    unsigned digit = (value & ((1 << BASE_BITS) - 1));
-    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
-                                                : digits[digit]);
-  } while ((value >>= BASE_BITS) != 0);
-  return end;
-}
-
-template <unsigned BASE_BITS, typename Char>
-Char* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits,
-                  bool = false) {
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  int start = (num_digits + char_digits - 1) / char_digits - 1;
-  if (int start_digits = num_digits % char_digits) {
-    unsigned value = n.value[start--];
-    buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
-  }
-  for (; start >= 0; --start) {
-    unsigned value = n.value[start];
-    buffer += char_digits;
-    auto p = buffer;
-    for (int i = 0; i < char_digits; ++i) {
-      unsigned digit = (value & ((1 << BASE_BITS) - 1));
-      *--p = static_cast<Char>(data::hex_digits[digit]);
-      value >>= BASE_BITS;
-    }
-  }
-  return buffer;
-}
-
-template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
-inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
-  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
-  char buffer[num_bits<UInt>() / BASE_BITS + 1];
-  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-  return internal::copy_str<Char>(buffer, buffer + num_digits, out);
-}
-
-template <typename T = void> struct null {};
-
-// Workaround an array initialization issue in gcc 4.8.
-template <typename Char> struct fill_t {
- private:
-  Char data_[6];
-
- public:
-  FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
-  FMT_CONSTEXPR const Char& operator[](size_t index) const {
-    return data_[index];
-  }
-
-  static FMT_CONSTEXPR fill_t<Char> make() {
-    auto fill = fill_t<Char>();
-    fill[0] = Char(' ');
-    return fill;
-  }
-};
-}  // namespace internal
-
-// We cannot use enum classes as bit fields because of a gcc bug
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
-namespace align {
-enum type { none, left, right, center, numeric };
-}
-using align_t = align::type;
-
-namespace sign {
-enum type { none, minus, plus, space };
-}
-using sign_t = sign::type;
-
-// Format specifiers for built-in and string types.
-template <typename Char> struct basic_format_specs {
-  int width;
-  int precision;
-  char type;
-  align_t align : 4;
-  sign_t sign : 3;
-  bool alt : 1;  // Alternate form ('#').
-  internal::fill_t<Char> fill;
-
-  constexpr basic_format_specs()
-      : width(0),
-        precision(-1),
-        type(0),
-        align(align::none),
-        sign(sign::none),
-        alt(false),
-        fill(internal::fill_t<Char>::make()) {}
-};
-
-using format_specs = basic_format_specs<char>;
-
-namespace internal {
-
-// A floating-point presentation format.
-enum class float_format : unsigned char {
-  general,  // General: exponent notation or fixed point based on magnitude.
-  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
-  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
-  hex
-};
-
-struct float_specs {
-  int precision;
-  float_format format : 8;
-  sign_t sign : 8;
-  bool upper : 1;
-  bool locale : 1;
-  bool percent : 1;
-  bool binary32 : 1;
-  bool use_grisu : 1;
-  bool trailing_zeros : 1;
-};
-
-// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
-template <typename Char, typename It> It write_exponent(int exp, It it) {
-  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
-  if (exp < 0) {
-    *it++ = static_cast<Char>('-');
-    exp = -exp;
-  } else {
-    *it++ = static_cast<Char>('+');
-  }
-  if (exp >= 100) {
-    const char* top = data::digits + (exp / 100) * 2;
-    if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
-    *it++ = static_cast<Char>(top[1]);
-    exp %= 100;
-  }
-  const char* d = data::digits + exp * 2;
-  *it++ = static_cast<Char>(d[0]);
-  *it++ = static_cast<Char>(d[1]);
-  return it;
-}
-
-template <typename Char> class float_writer {
- private:
-  // The number is given as v = digits_ * pow(10, exp_).
-  const char* digits_;
-  int num_digits_;
-  int exp_;
-  size_t size_;
-  float_specs specs_;
-  Char decimal_point_;
-
-  template <typename It> It prettify(It it) const {
-    // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
-    int full_exp = num_digits_ + exp_;
-    if (specs_.format == float_format::exp) {
-      // Insert a decimal point after the first digit and add an exponent.
-      *it++ = static_cast<Char>(*digits_);
-      int num_zeros = specs_.precision - num_digits_;
-      bool trailing_zeros = num_zeros > 0 && specs_.trailing_zeros;
-      if (num_digits_ > 1 || trailing_zeros) *it++ = decimal_point_;
-      it = copy_str<Char>(digits_ + 1, digits_ + num_digits_, it);
-      if (trailing_zeros)
-        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-      *it++ = static_cast<Char>(specs_.upper ? 'E' : 'e');
-      return write_exponent<Char>(full_exp - 1, it);
-    }
-    if (num_digits_ <= full_exp) {
-      // 1234e7 -> 12340000000[.0+]
-      it = copy_str<Char>(digits_, digits_ + num_digits_, it);
-      it = std::fill_n(it, full_exp - num_digits_, static_cast<Char>('0'));
-      if (specs_.trailing_zeros) {
-        *it++ = decimal_point_;
-        int num_zeros = specs_.precision - full_exp;
-        if (num_zeros <= 0) {
-          if (specs_.format != float_format::fixed)
-            *it++ = static_cast<Char>('0');
-          return it;
-        }
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-        if (num_zeros > 1000)
-          throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
-#endif
-        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-      }
-    } else if (full_exp > 0) {
-      // 1234e-2 -> 12.34[0+]
-      it = copy_str<Char>(digits_, digits_ + full_exp, it);
-      if (!specs_.trailing_zeros) {
-        // Remove trailing zeros.
-        int num_digits = num_digits_;
-        while (num_digits > full_exp && digits_[num_digits - 1] == '0')
-          --num_digits;
-        if (num_digits != full_exp) *it++ = decimal_point_;
-        return copy_str<Char>(digits_ + full_exp, digits_ + num_digits, it);
-      }
-      *it++ = decimal_point_;
-      it = copy_str<Char>(digits_ + full_exp, digits_ + num_digits_, it);
-      if (specs_.precision > num_digits_) {
-        // Add trailing zeros.
-        int num_zeros = specs_.precision - num_digits_;
-        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-      }
-    } else {
-      // 1234e-6 -> 0.001234
-      *it++ = static_cast<Char>('0');
-      int num_zeros = -full_exp;
-      if (specs_.precision >= 0 && specs_.precision < num_zeros)
-        num_zeros = specs_.precision;
-      int num_digits = num_digits_;
-      if (!specs_.trailing_zeros)
-        while (num_digits > 0 && digits_[num_digits - 1] == '0') --num_digits;
-      if (num_zeros != 0 || num_digits != 0) {
-        *it++ = decimal_point_;
-        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
-        it = copy_str<Char>(digits_, digits_ + num_digits, it);
-      }
-    }
-    return it;
-  }
-
- public:
-  float_writer(const char* digits, int num_digits, int exp, float_specs specs,
-               Char decimal_point)
-      : digits_(digits),
-        num_digits_(num_digits),
-        exp_(exp),
-        specs_(specs),
-        decimal_point_(decimal_point) {
-    int full_exp = num_digits + exp - 1;
-    int precision = specs.precision > 0 ? specs.precision : 16;
-    if (specs_.format == float_format::general &&
-        !(full_exp >= -4 && full_exp < precision)) {
-      specs_.format = float_format::exp;
-    }
-    size_ = prettify(counting_iterator()).count();
-    size_ += specs.sign ? 1 : 0;
-  }
-
-  size_t size() const { return size_; }
-  size_t width() const { return size(); }
-
-  template <typename It> void operator()(It&& it) {
-    if (specs_.sign) *it++ = static_cast<Char>(data::signs[specs_.sign]);
-    it = prettify(it);
-  }
-};
-
-template <typename T>
-int format_float(T value, int precision, float_specs specs, buffer<char>& buf);
-
-// Formats a floating-point number with snprintf.
-template <typename T>
-int snprintf_float(T value, int precision, float_specs specs,
-                   buffer<char>& buf);
-
-template <typename T> T promote_float(T value) { return value; }
-inline double promote_float(float value) { return value; }
-
-template <typename Handler>
-FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
-  switch (spec) {
-  case 0:
-  case 'd':
-    handler.on_dec();
-    break;
-  case 'x':
-  case 'X':
-    handler.on_hex();
-    break;
-  case 'b':
-  case 'B':
-    handler.on_bin();
-    break;
-  case 'o':
-    handler.on_oct();
-    break;
-  case 'n':
-    handler.on_num();
-    break;
-  default:
-    handler.on_error();
-  }
-}
-
-template <typename ErrorHandler = error_handler, typename Char>
-FMT_CONSTEXPR float_specs parse_float_type_spec(
-    const basic_format_specs<Char>& specs, ErrorHandler&& eh = {}) {
-  auto result = float_specs();
-  result.trailing_zeros = specs.alt;
-  switch (specs.type) {
-  case 0:
-    result.format = float_format::general;
-    result.trailing_zeros |= specs.precision != 0;
-    break;
-  case 'G':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'g':
-    result.format = float_format::general;
-    break;
-  case 'E':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'e':
-    result.format = float_format::exp;
-    result.trailing_zeros |= specs.precision != 0;
-    break;
-  case 'F':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'f':
-    result.format = float_format::fixed;
-    result.trailing_zeros |= specs.precision != 0;
-    break;
-#if FMT_DEPRECATED_PERCENT
-  case '%':
-    result.format = float_format::fixed;
-    result.percent = true;
-    break;
-#endif
-  case 'A':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'a':
-    result.format = float_format::hex;
-    break;
-  case 'n':
-    result.locale = true;
-    break;
-  default:
-    eh.on_error("invalid type specifier");
-    break;
-  }
-  return result;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
-                                     Handler&& handler) {
-  if (!specs) return handler.on_char();
-  if (specs->type && specs->type != 'c') return handler.on_int();
-  if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
-    handler.on_error("invalid format specifier for char");
-  handler.on_char();
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
-  if (spec == 0 || spec == 's')
-    handler.on_string();
-  else if (spec == 'p')
-    handler.on_pointer();
-  else
-    handler.on_error("invalid type specifier");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
-}
-
-template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_dec() {}
-  FMT_CONSTEXPR void on_hex() {}
-  FMT_CONSTEXPR void on_bin() {}
-  FMT_CONSTEXPR void on_oct() {}
-  FMT_CONSTEXPR void on_num() {}
-
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
-  }
-};
-
-template <typename ErrorHandler>
-class char_specs_checker : public ErrorHandler {
- private:
-  char type_;
-
- public:
-  FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)
-      : ErrorHandler(eh), type_(type) {}
-
-  FMT_CONSTEXPR void on_int() {
-    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
-  }
-  FMT_CONSTEXPR void on_char() {}
-};
-
-template <typename ErrorHandler>
-class cstring_type_checker : public ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
-      : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_string() {}
-  FMT_CONSTEXPR void on_pointer() {}
-};
-
-template <typename Context>
-void arg_map<Context>::init(const basic_format_args<Context>& args) {
-  if (map_) return;
-  map_ = new entry[internal::to_unsigned(args.max_size())];
-  if (args.is_packed()) {
-    for (int i = 0;; ++i) {
-      internal::type arg_type = args.type(i);
-      if (arg_type == internal::none_type) return;
-      if (arg_type == internal::named_arg_type) push_back(args.values_[i]);
-    }
-  }
-  for (int i = 0, n = args.max_size(); i < n; ++i) {
-    auto type = args.args_[i].type_;
-    if (type == internal::named_arg_type) push_back(args.args_[i].value_);
-  }
-}
-
-template <typename Char> struct nonfinite_writer {
-  sign_t sign;
-  const char* str;
-  static constexpr size_t str_size = 3;
-
-  size_t size() const { return str_size + (sign ? 1 : 0); }
-  size_t width() const { return size(); }
-
-  template <typename It> void operator()(It&& it) const {
-    if (sign) *it++ = static_cast<Char>(data::signs[sign]);
-    it = copy_str<Char>(str, str + str_size, it);
-  }
-};
-
-// This template provides operations for formatting and writing data into a
-// character range.
-template <typename Range> class basic_writer {
- public:
-  using char_type = typename Range::value_type;
-  using iterator = typename Range::iterator;
-  using format_specs = basic_format_specs<char_type>;
-
- private:
-  iterator out_;  // Output iterator.
-  locale_ref locale_;
-
-  // Attempts to reserve space for n extra characters in the output range.
-  // Returns a pointer to the reserved range or a reference to out_.
-  auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
-    return internal::reserve(out_, n);
-  }
-
-  template <typename F> struct padded_int_writer {
-    size_t size_;
-    string_view prefix;
-    char_type fill;
-    std::size_t padding;
-    F f;
-
-    size_t size() const { return size_; }
-    size_t width() const { return size_; }
-
-    template <typename It> void operator()(It&& it) const {
-      if (prefix.size() != 0)
-        it = copy_str<char_type>(prefix.begin(), prefix.end(), it);
-      it = std::fill_n(it, padding, fill);
-      f(it);
-    }
-  };
-
-  // Writes an integer in the format
-  //   <left-padding><prefix><numeric-padding><digits><right-padding>
-  // where <digits> are written by f(it).
-  template <typename F>
-  void write_int(int num_digits, string_view prefix, format_specs specs, F f) {
-    std::size_t size = prefix.size() + to_unsigned(num_digits);
-    char_type fill = specs.fill[0];
-    std::size_t padding = 0;
-    if (specs.align == align::numeric) {
-      auto unsiged_width = to_unsigned(specs.width);
-      if (unsiged_width > size) {
-        padding = unsiged_width - size;
-        size = unsiged_width;
-      }
-    } else if (specs.precision > num_digits) {
-      size = prefix.size() + to_unsigned(specs.precision);
-      padding = to_unsigned(specs.precision - num_digits);
-      fill = static_cast<char_type>('0');
-    }
-    if (specs.align == align::none) specs.align = align::right;
-    write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
-  }
-
-  // Writes a decimal integer.
-  template <typename Int> void write_decimal(Int value) {
-    auto abs_value = static_cast<uint32_or_64_or_128_t<Int>>(value);
-    bool negative = is_negative(value);
-    // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
-    if (negative) abs_value = ~abs_value + 1;
-    int num_digits = count_digits(abs_value);
-    auto&& it = reserve((negative ? 1 : 0) + static_cast<size_t>(num_digits));
-    if (negative) *it++ = static_cast<char_type>('-');
-    it = format_decimal<char_type>(it, abs_value, num_digits);
-  }
-
-  // The handle_int_type_spec handler that writes an integer.
-  template <typename Int, typename Specs> struct int_writer {
-    using unsigned_type = uint32_or_64_or_128_t<Int>;
-
-    basic_writer<Range>& writer;
-    const Specs& specs;
-    unsigned_type abs_value;
-    char prefix[4];
-    unsigned prefix_size;
-
-    string_view get_prefix() const { return string_view(prefix, prefix_size); }
-
-    int_writer(basic_writer<Range>& w, Int value, const Specs& s)
-        : writer(w),
-          specs(s),
-          abs_value(static_cast<unsigned_type>(value)),
-          prefix_size(0) {
-      if (is_negative(value)) {
-        prefix[0] = '-';
-        ++prefix_size;
-        abs_value = 0 - abs_value;
-      } else if (specs.sign != sign::none && specs.sign != sign::minus) {
-        prefix[0] = specs.sign == sign::plus ? '+' : ' ';
-        ++prefix_size;
-      }
-    }
-
-    struct dec_writer {
-      unsigned_type abs_value;
-      int num_digits;
-
-      template <typename It> void operator()(It&& it) const {
-        it = internal::format_decimal<char_type>(it, abs_value, num_digits);
-      }
-    };
-
-    void on_dec() {
-      int num_digits = count_digits(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       dec_writer{abs_value, num_digits});
-    }
-
-    struct hex_writer {
-      int_writer& self;
-      int num_digits;
-
-      template <typename It> void operator()(It&& it) const {
-        it = format_uint<4, char_type>(it, self.abs_value, num_digits,
-                                       self.specs.type != 'x');
-      }
-    };
-
-    void on_hex() {
-      if (specs.alt) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = specs.type;
-      }
-      int num_digits = count_digits<4>(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       hex_writer{*this, num_digits});
-    }
-
-    template <int BITS> struct bin_writer {
-      unsigned_type abs_value;
-      int num_digits;
-
-      template <typename It> void operator()(It&& it) const {
-        it = format_uint<BITS, char_type>(it, abs_value, num_digits);
-      }
-    };
-
-    void on_bin() {
-      if (specs.alt) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = static_cast<char>(specs.type);
-      }
-      int num_digits = count_digits<1>(abs_value);
-      writer.write_int(num_digits, get_prefix(), specs,
-                       bin_writer<1>{abs_value, num_digits});
-    }
-
-    void on_oct() {
-      int num_digits = count_digits<3>(abs_value);
-      if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
-        // Octal prefix '0' is counted as a digit, so only add it if precision
-        // is not greater than the number of digits.
-        prefix[prefix_size++] = '0';
-      }
-      writer.write_int(num_digits, get_prefix(), specs,
-                       bin_writer<3>{abs_value, num_digits});
-    }
-
-    enum { sep_size = 1 };
-
-    struct num_writer {
-      unsigned_type abs_value;
-      int size;
-      const std::string& groups;
-      char_type sep;
-
-      template <typename It> void operator()(It&& it) const {
-        basic_string_view<char_type> s(&sep, sep_size);
-        // Index of a decimal digit with the least significant digit having
-        // index 0.
-        int digit_index = 0;
-        std::string::const_iterator group = groups.cbegin();
-        it = format_decimal<char_type>(
-            it, abs_value, size,
-            [this, s, &group, &digit_index](char_type*& buffer) {
-              if (*group <= 0 || ++digit_index % *group != 0 ||
-                  *group == max_value<char>())
-                return;
-              if (group + 1 != groups.cend()) {
-                digit_index = 0;
-                ++group;
-              }
-              buffer -= s.size();
-              std::uninitialized_copy(s.data(), s.data() + s.size(),
-                                      make_checked(buffer, s.size()));
-            });
-      }
-    };
-
-    void on_num() {
-      std::string groups = grouping<char_type>(writer.locale_);
-      if (groups.empty()) return on_dec();
-      auto sep = thousands_sep<char_type>(writer.locale_);
-      if (!sep) return on_dec();
-      int num_digits = count_digits(abs_value);
-      int size = num_digits;
-      std::string::const_iterator group = groups.cbegin();
-      while (group != groups.cend() && num_digits > *group && *group > 0 &&
-             *group != max_value<char>()) {
-        size += sep_size;
-        num_digits -= *group;
-        ++group;
-      }
-      if (group == groups.cend())
-        size += sep_size * ((num_digits - 1) / groups.back());
-      writer.write_int(size, get_prefix(), specs,
-                       num_writer{abs_value, size, groups, sep});
-    }
-
-    FMT_NORETURN void on_error() {
-      FMT_THROW(duckdb::Exception("invalid type specifier"));
-    }
-  };
-
-  template <typename Char> struct str_writer {
-    const Char* s;
-    size_t size_;
-
-    size_t size() const { return size_; }
-    size_t width() const {
-      return count_code_points(basic_string_view<Char>(s, size_));
-    }
-
-    template <typename It> void operator()(It&& it) const {
-      it = copy_str<char_type>(s, s + size_, it);
-    }
-  };
-
-  template <typename UIntPtr> struct pointer_writer {
-    UIntPtr value;
-    int num_digits;
-
-    size_t size() const { return to_unsigned(num_digits) + 2; }
-    size_t width() const { return size(); }
-
-    template <typename It> void operator()(It&& it) const {
-      *it++ = static_cast<char_type>('0');
-      *it++ = static_cast<char_type>('x');
-      it = format_uint<4, char_type>(it, value, num_digits);
-    }
-  };
-
- public:
-  explicit basic_writer(Range out, locale_ref loc = locale_ref())
-      : out_(out.begin()), locale_(loc) {}
-
-  iterator out() const { return out_; }
-
-  // Writes a value in the format
-  //   <left-padding><value><right-padding>
-  // where <value> is written by f(it).
-  template <typename F> void write_padded(const format_specs& specs, F&& f) {
-    // User-perceived width (in code points).
-    unsigned width = to_unsigned(specs.width);
-    size_t size = f.size();  // The number of code units.
-    size_t num_code_points = width != 0 ? f.width() : size;
-    if (width <= num_code_points) return f(reserve(size));
-    auto&& it = reserve(width + (size - num_code_points));
-    char_type fill = specs.fill[0];
-    std::size_t padding = width - num_code_points;
-    if (specs.align == align::right) {
-      it = std::fill_n(it, padding, fill);
-      f(it);
-    } else if (specs.align == align::center) {
-      std::size_t left_padding = padding / 2;
-      it = std::fill_n(it, left_padding, fill);
-      f(it);
-      it = std::fill_n(it, padding - left_padding, fill);
-    } else {
-      f(it);
-      it = std::fill_n(it, padding, fill);
-    }
-  }
-
-  void write(int value) { write_decimal(value); }
-  void write(long value) { write_decimal(value); }
-  void write(long long value) { write_decimal(value); }
-
-  void write(unsigned value) { write_decimal(value); }
-  void write(unsigned long value) { write_decimal(value); }
-  void write(unsigned long long value) { write_decimal(value); }
-
-#if FMT_USE_INT128
-  void write(int128_t value) { write_decimal(value); }
-  void write(uint128_t value) { write_decimal(value); }
-#endif
-
-  template <typename T, typename Spec>
-  void write_int(T value, const Spec& spec) {
-    handle_int_type_spec(spec.type, int_writer<T, Spec>(*this, value, spec));
-  }
-
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  void write(T value, format_specs specs = {}) {
-    float_specs fspecs = parse_float_type_spec(specs);
-    fspecs.sign = specs.sign;
-    if (std::signbit(value)) {  // value < 0 is false for NaN so use signbit.
-      fspecs.sign = sign::minus;
-      value = -value;
-    } else if (fspecs.sign == sign::minus) {
-      fspecs.sign = sign::none;
-    }
-
-    if (!std::isfinite(value)) {
-      auto str = std::isinf(value) ? (fspecs.upper ? "INF" : "inf")
-                                   : (fspecs.upper ? "NAN" : "nan");
-      return write_padded(specs, nonfinite_writer<char_type>{fspecs.sign, str});
-    }
-
-    if (specs.align == align::none) {
-      specs.align = align::right;
-    } else if (specs.align == align::numeric) {
-      if (fspecs.sign) {
-        auto&& it = reserve(1);
-        *it++ = static_cast<char_type>(data::signs[fspecs.sign]);
-        fspecs.sign = sign::none;
-        if (specs.width != 0) --specs.width;
-      }
-      specs.align = align::right;
-    }
-
-    memory_buffer buffer;
-    if (fspecs.format == float_format::hex) {
-      if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
-      snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
-      write_padded(specs, str_writer<char>{buffer.data(), buffer.size()});
-      return;
-    }
-    int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
-    if (fspecs.format == float_format::exp) ++precision;
-    if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
-    fspecs.use_grisu = use_grisu<T>();
-    if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) value *= 100;
-    int exp = format_float(promote_float(value), precision, fspecs, buffer);
-    if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) {
-      buffer.push_back('%');
-      --exp;  // Adjust decimal place position.
-    }
-    fspecs.precision = precision;
-    char_type point = fspecs.locale ? decimal_point<char_type>(locale_)
-                                    : static_cast<char_type>('.');
-    write_padded(specs, float_writer<char_type>(buffer.data(),
-                                                static_cast<int>(buffer.size()),
-                                                exp, fspecs, point));
-  }
-
-  void write(char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
-
-  template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
-  void write(Char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
-
-  void write(string_view value) {
-    auto&& it = reserve(value.size());
-    it = copy_str<char_type>(value.begin(), value.end(), it);
-  }
-  void write(wstring_view value) {
-    static_assert(std::is_same<char_type, wchar_t>::value, "");
-    auto&& it = reserve(value.size());
-    it = std::copy(value.begin(), value.end(), it);
-  }
-
-  template <typename Char>
-  void write(const Char* s, std::size_t size, const format_specs& specs) {
-    write_padded(specs, str_writer<Char>{s, size});
-  }
-
-  template <typename Char>
-  void write(basic_string_view<Char> s, const format_specs& specs = {}) {
-    const Char* data = s.data();
-    std::size_t size = s.size();
-    if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
-      size = code_point_index(s, to_unsigned(specs.precision));
-    write(data, size, specs);
-  }
-
-  template <typename UIntPtr>
-  void write_pointer(UIntPtr value, const format_specs* specs) {
-    int num_digits = count_digits<4>(value);
-    auto pw = pointer_writer<UIntPtr>{value, num_digits};
-    if (!specs) return pw(reserve(to_unsigned(num_digits) + 2));
-    format_specs specs_copy = *specs;
-    if (specs_copy.align == align::none) specs_copy.align = align::right;
-    write_padded(specs_copy, pw);
-  }
-};
-
-using writer = basic_writer<buffer_range<char>>;
-
-template <typename T> struct is_integral : std::is_integral<T> {};
-template <> struct is_integral<int128_t> : std::true_type {};
-template <> struct is_integral<uint128_t> : std::true_type {};
-
-template <typename Range, typename ErrorHandler = internal::error_handler>
-class arg_formatter_base {
- public:
-  using char_type = typename Range::value_type;
-  using iterator = typename Range::iterator;
-  using format_specs = basic_format_specs<char_type>;
-
- private:
-  using writer_type = basic_writer<Range>;
-  writer_type writer_;
-  format_specs* specs_;
-
-  struct char_writer {
-    char_type value;
-
-    size_t size() const { return 1; }
-    size_t width() const { return 1; }
-
-    template <typename It> void operator()(It&& it) const { *it++ = value; }
-  };
-
-  void write_char(char_type value) {
-    if (specs_)
-      writer_.write_padded(*specs_, char_writer{value});
-    else
-      writer_.write(value);
-  }
-
-  void write_pointer(const void* p) {
-    writer_.write_pointer(internal::to_uintptr(p), specs_);
-  }
-
- protected:
-  writer_type& writer() { return writer_; }
-  FMT_DEPRECATED format_specs* spec() { return specs_; }
-  format_specs* specs() { return specs_; }
-  iterator out() { return writer_.out(); }
-
-  void write(bool value) {
-    string_view sv(value ? "true" : "false");
-    specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
-  }
-
-  void write(const char_type* value) {
-    if (!value) {
-      FMT_THROW(duckdb::Exception("string pointer is null"));
-    } else {
-      auto length = std::char_traits<char_type>::length(value);
-      basic_string_view<char_type> sv(value, length);
-      specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
-    }
-  }
-
- public:
-  arg_formatter_base(Range r, format_specs* s, locale_ref loc)
-      : writer_(r, loc), specs_(s) {}
-
-  iterator operator()(monostate) {
-    FMT_ASSERT(false, "invalid argument type");
-    return out();
-  }
-
-  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
-  iterator operator()(T value) {
-    if (specs_)
-      writer_.write_int(value, *specs_);
-    else
-      writer_.write(value);
-    return out();
-  }
-
-  iterator operator()(char_type value) {
-    internal::handle_char_specs(
-        specs_, char_spec_handler(*this, static_cast<char_type>(value)));
-    return out();
-  }
-
-  iterator operator()(bool value) {
-    if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
-    write(value != 0);
-    return out();
-  }
-
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
-    writer_.write(value, specs_ ? *specs_ : format_specs());
-    return out();
-  }
-
-  struct char_spec_handler : ErrorHandler {
-    arg_formatter_base& formatter;
-    char_type value;
-
-    char_spec_handler(arg_formatter_base& f, char_type val)
-        : formatter(f), value(val) {}
-
-    void on_int() {
-      if (formatter.specs_)
-        formatter.writer_.write_int(value, *formatter.specs_);
-      else
-        formatter.writer_.write(value);
-    }
-    void on_char() { formatter.write_char(value); }
-  };
-
-  struct cstring_spec_handler : internal::error_handler {
-    arg_formatter_base& formatter;
-    const char_type* value;
-
-    cstring_spec_handler(arg_formatter_base& f, const char_type* val)
-        : formatter(f), value(val) {}
-
-    void on_string() { formatter.write(value); }
-    void on_pointer() { formatter.write_pointer(value); }
-  };
-
-  iterator operator()(const char_type* value) {
-    if (!specs_) return write(value), out();
-    internal::handle_cstring_type_spec(specs_->type,
-                                       cstring_spec_handler(*this, value));
-    return out();
-  }
-
-  iterator operator()(basic_string_view<char_type> value) {
-    if (specs_) {
-      internal::check_string_type_spec(specs_->type, internal::error_handler());
-      writer_.write(value, *specs_);
-    } else {
-      writer_.write(value);
-    }
-    return out();
-  }
-
-  iterator operator()(const void* value) {
-    if (specs_)
-      check_pointer_type_spec(specs_->type, internal::error_handler());
-    write_pointer(value);
-    return out();
-  }
-};
-
-template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-}
-
-// Parses the range [begin, end) as an unsigned integer. This function assumes
-// that the range is non-empty and the first character is a digit.
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
-                                        ErrorHandler&& eh) {
-  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
-  if (*begin == '0') {
-    ++begin;
-    return 0;
-  }
-  unsigned value = 0;
-  // Convert to unsigned to prevent a warning.
-  constexpr unsigned max_int = max_value<int>();
-  unsigned big = max_int / 10;
-  do {
-    // Check for overflow.
-    if (value > big) {
-      value = max_int + 1;
-      break;
-    }
-    value = value * 10 + unsigned(*begin - '0');
-    ++begin;
-  } while (begin != end && '0' <= *begin && *begin <= '9');
-  if (value > max_int) eh.on_error("number is too big");
-  return static_cast<int>(value);
-}
-
-template <typename Context> class custom_formatter {
- private:
-  using char_type = typename Context::char_type;
-
-  basic_format_parse_context<char_type>& parse_ctx_;
-  Context& ctx_;
-
- public:
-  explicit custom_formatter(basic_format_parse_context<char_type>& parse_ctx,
-                            Context& ctx)
-      : parse_ctx_(parse_ctx), ctx_(ctx) {}
-
-  bool operator()(typename basic_format_arg<Context>::handle h) const {
-    h.format(parse_ctx_, ctx_);
-    return true;
-  }
-
-  template <typename T> bool operator()(T) const { return false; }
-};
-
-template <typename T>
-using is_integer =
-    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
-                  !std::is_same<T, char>::value &&
-                  !std::is_same<T, wchar_t>::value>;
-
-template <typename ErrorHandler> class width_checker {
- public:
-  explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
-
-  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
-    if (is_negative(value)) handler_.on_error("negative width");
-    return static_cast<unsigned long long>(value);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
-    handler_.on_error("width is not integer");
-    return 0;
-  }
-
- private:
-  ErrorHandler& handler_;
-};
-
-template <typename ErrorHandler> class precision_checker {
- public:
-  explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
-
-  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
-    if (is_negative(value)) handler_.on_error("negative precision");
-    return static_cast<unsigned long long>(value);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
-    handler_.on_error("precision is not integer");
-    return 0;
-  }
-
- private:
-  ErrorHandler& handler_;
-};
-
-// A format specifier handler that sets fields in basic_format_specs.
-template <typename Char> class specs_setter {
- public:
-  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
-      : specs_(specs) {}
-
-  FMT_CONSTEXPR specs_setter(const specs_setter& other)
-      : specs_(other.specs_) {}
-
-  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
-  FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill[0] = fill; }
-  FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
-  FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
-  FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
-  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
-
-  FMT_CONSTEXPR void on_zero() {
-    specs_.align = align::numeric;
-    specs_.fill[0] = Char('0');
-  }
-
-  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
-  FMT_CONSTEXPR void on_precision(int precision) {
-    specs_.precision = precision;
-  }
-  FMT_CONSTEXPR void end_precision() {}
-
-  FMT_CONSTEXPR void on_type(Char type) {
-    specs_.type = static_cast<char>(type);
-  }
-
- protected:
-  basic_format_specs<Char>& specs_;
-};
-
-template <typename ErrorHandler> class numeric_specs_checker {
- public:
-  FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)
-      : error_handler_(eh), arg_type_(arg_type) {}
-
-  FMT_CONSTEXPR void require_numeric_argument() {
-    if (!is_arithmetic_type(arg_type_))
-      error_handler_.on_error("format specifier requires numeric argument");
-  }
-
-  FMT_CONSTEXPR void check_sign() {
-    require_numeric_argument();
-    if (is_integral_type(arg_type_) && arg_type_ != int_type &&
-        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
-      error_handler_.on_error("format specifier requires signed argument");
-    }
-  }
-
-  FMT_CONSTEXPR void check_precision() {
-    if (is_integral_type(arg_type_) || arg_type_ == internal::pointer_type)
-      error_handler_.on_error("precision not allowed for this argument type");
-  }
-
- private:
-  ErrorHandler& error_handler_;
-  internal::type arg_type_;
-};
-
-// A format specifier handler that checks if specifiers are consistent with the
-// argument type.
-template <typename Handler> class specs_checker : public Handler {
- public:
-  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
-      : Handler(handler), checker_(*this, arg_type) {}
-
-  FMT_CONSTEXPR specs_checker(const specs_checker& other)
-      : Handler(other), checker_(*this, other.arg_type_) {}
-
-  FMT_CONSTEXPR void on_align(align_t align) {
-    if (align == align::numeric) checker_.require_numeric_argument();
-    Handler::on_align(align);
-  }
-
-  FMT_CONSTEXPR void on_plus() {
-    checker_.check_sign();
-    Handler::on_plus();
-  }
-
-  FMT_CONSTEXPR void on_minus() {
-    checker_.check_sign();
-    Handler::on_minus();
-  }
-
-  FMT_CONSTEXPR void on_space() {
-    checker_.check_sign();
-    Handler::on_space();
-  }
-
-  FMT_CONSTEXPR void on_hash() {
-    checker_.require_numeric_argument();
-    Handler::on_hash();
-  }
-
-  FMT_CONSTEXPR void on_zero() {
-    checker_.require_numeric_argument();
-    Handler::on_zero();
-  }
-
-  FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
-
- private:
-  numeric_specs_checker<Handler> checker_;
-};
-
-template <template <typename> class Handler, typename FormatArg,
-          typename ErrorHandler>
-FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
-  unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
-  if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
-  return static_cast<int>(value);
-}
-
-struct auto_id {};
-
-template <typename Context>
-FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, int id) {
-  auto arg = ctx.arg(id);
-  if (!arg) ctx.on_error("argument index out of range");
-  return arg;
-}
-
-// The standard format specifier handler with checking.
-template <typename ParseContext, typename Context>
-class specs_handler : public specs_setter<typename Context::char_type> {
- public:
-  using char_type = typename Context::char_type;
-
-  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
-                              ParseContext& parse_ctx, Context& ctx)
-      : specs_setter<char_type>(specs),
-        parse_context_(parse_ctx),
-        context_(ctx) {}
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    this->specs_.width = get_dynamic_spec<width_checker>(
-        get_arg(arg_id), context_.error_handler());
-  }
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    this->specs_.precision = get_dynamic_spec<precision_checker>(
-        get_arg(arg_id), context_.error_handler());
-  }
-
-  void on_error(const char* message) { context_.on_error(message); }
-
- private:
-  // This is only needed for compatibility with gcc 4.4.
-  using format_arg = typename Context::format_arg;
-
-  FMT_CONSTEXPR format_arg get_arg(auto_id) {
-    return internal::get_arg(context_, parse_context_.next_arg_id());
-  }
-
-  FMT_CONSTEXPR format_arg get_arg(int arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return internal::get_arg(context_, arg_id);
-  }
-
-  FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return context_.arg(arg_id);
-  }
-
-  ParseContext& parse_context_;
-  Context& context_;
-};
-
-enum class arg_id_kind { none, index, name };
-
-// An argument reference.
-template <typename Char> struct arg_ref {
-  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
-  FMT_CONSTEXPR explicit arg_ref(int index)
-      : kind(arg_id_kind::index), val(index) {}
-  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
-      : kind(arg_id_kind::name), val(name) {}
-
-  FMT_CONSTEXPR arg_ref& operator=(int idx) {
-    kind = arg_id_kind::index;
-    val.index = idx;
-    return *this;
-  }
-
-  arg_id_kind kind;
-  union value {
-    FMT_CONSTEXPR value(int id = 0) : index{id} {}
-    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
-
-    int index;
-    basic_string_view<Char> name;
-  } val;
-};
-
-// Format specifiers with width and precision resolved at formatting rather
-// than parsing time to allow re-using the same parsed specifiers with
-// different sets of arguments (precompilation of format strings).
-template <typename Char>
-struct dynamic_format_specs : basic_format_specs<Char> {
-  arg_ref<Char> width_ref;
-  arg_ref<Char> precision_ref;
-};
-
-// Format spec handler that saves references to arguments representing dynamic
-// width and precision to be resolved at formatting time.
-template <typename ParseContext>
-class dynamic_specs_handler
-    : public specs_setter<typename ParseContext::char_type> {
- public:
-  using char_type = typename ParseContext::char_type;
-
-  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
-                                      ParseContext& ctx)
-      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
-
-  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
-      : specs_setter<char_type>(other),
-        specs_(other.specs_),
-        context_(other.context_) {}
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    specs_.width_ref = make_arg_ref(arg_id);
-  }
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    specs_.precision_ref = make_arg_ref(arg_id);
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    context_.on_error(message);
-  }
-
- private:
-  using arg_ref_type = arg_ref<char_type>;
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
-    context_.check_arg_id(arg_id);
-    return arg_ref_type(arg_id);
-  }
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
-    return arg_ref_type(context_.next_arg_id());
-  }
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
-    context_.check_arg_id(arg_id);
-    basic_string_view<char_type> format_str(
-        context_.begin(), to_unsigned(context_.end() - context_.begin()));
-    return arg_ref_type(arg_id);
-  }
-
-  dynamic_format_specs<char_type>& specs_;
-  ParseContext& context_;
-};
-
-template <typename Char, typename IDHandler>
-FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
-                                       IDHandler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  Char c = *begin;
-  if (c == '}' || c == ':') {
-    handler();
-    return begin;
-  }
-  if (c >= '0' && c <= '9') {
-    int index = parse_nonnegative_int(begin, end, handler);
-    if (begin == end || (*begin != '}' && *begin != ':'))
-      handler.on_error("invalid format string");
-    else
-      handler(index);
-    return begin;
-  }
-  if (!is_name_start(c)) {
-    handler.on_error("invalid format string");
-    return begin;
-  }
-  auto it = begin;
-  do {
-    ++it;
-  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
-  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
-  return it;
-}
-
-// Adapts SpecHandler to IDHandler API for dynamic width.
-template <typename SpecHandler, typename Char> struct width_adapter {
-  explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}
-
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_width(id);
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
-
-  SpecHandler& handler;
-};
-
-// Adapts SpecHandler to IDHandler API for dynamic precision.
-template <typename SpecHandler, typename Char> struct precision_adapter {
-  explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}
-
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_precision(id);
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
-
-  SpecHandler& handler;
-};
-
-// Parses fill and alignment.
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  auto align = align::none;
-  int i = 0;
-  if (begin + 1 != end) ++i;
-  do {
-    switch (static_cast<char>(begin[i])) {
-    case '<':
-      align = align::left;
-      break;
-    case '>':
-      align = align::right;
-      break;
-#if FMT_NUMERIC_ALIGN
-    case '=':
-      align = align::numeric;
-      break;
-#endif
-    case '^':
-      align = align::center;
-      break;
-    }
-    if (align != align::none) {
-      if (i > 0) {
-        auto c = *begin;
-        if (c == '{')
-          return handler.on_error("invalid fill character '{'"), begin;
-        begin += 2;
-        handler.on_fill(c);
-      } else
-        ++begin;
-      handler.on_align(align);
-      break;
-    }
-  } while (i-- > 0);
-  return begin;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  if ('0' <= *begin && *begin <= '9') {
-    handler.on_width(parse_nonnegative_int(begin, end, handler));
-  } else if (*begin == '{') {
-    ++begin;
-    if (begin != end)
-      begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
-    if (begin == end || *begin != '}')
-      return handler.on_error("invalid format string"), begin;
-    ++begin;
-  }
-  return begin;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
-                                          Handler&& handler) {
-  ++begin;
-  auto c = begin != end ? *begin : Char();
-  if ('0' <= c && c <= '9') {
-    handler.on_precision(parse_nonnegative_int(begin, end, handler));
-  } else if (c == '{') {
-    ++begin;
-    if (begin != end) {
-      begin =
-          parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
-    }
-    if (begin == end || *begin++ != '}')
-      return handler.on_error("invalid format string"), begin;
-  } else {
-    return handler.on_error("missing precision specifier"), begin;
-  }
-  handler.end_precision();
-  return begin;
-}
-
-// Parses standard format specifiers and sends notifications about parsed
-// components to handler.
-template <typename Char, typename SpecHandler>
-FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
-                                             SpecHandler&& handler) {
-  if (begin == end || *begin == '}') return begin;
-
-  begin = parse_align(begin, end, handler);
-  if (begin == end) return begin;
-
-  // Parse sign.
-  switch (static_cast<char>(*begin)) {
-  case '+':
-    handler.on_plus();
-    ++begin;
-    break;
-  case '-':
-    handler.on_minus();
-    ++begin;
-    break;
-  case ' ':
-    handler.on_space();
-    ++begin;
-    break;
-  }
-  if (begin == end) return begin;
-
-  if (*begin == '#') {
-    handler.on_hash();
-    if (++begin == end) return begin;
-  }
-
-  // Parse zero flag.
-  if (*begin == '0') {
-    handler.on_zero();
-    if (++begin == end) return begin;
-  }
-
-  begin = parse_width(begin, end, handler);
-  if (begin == end) return begin;
-
-  // Parse precision.
-  if (*begin == '.') {
-    begin = parse_precision(begin, end, handler);
-  }
-
-  // Parse type.
-  if (begin != end && *begin != '}') handler.on_type(*begin++);
-  return begin;
-}
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr& out) {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline bool find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) {
-  out = static_cast<const char*>(
-      std::memchr(first, value, internal::to_unsigned(last - first)));
-  return out != nullptr;
-}
-
-template <typename Handler, typename Char> struct id_adapter {
-  FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_arg_id(id);
-  }
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
-  Handler& handler;
-};
-
-template <bool IS_CONSTEXPR, typename Char, typename Handler>
-FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str,
-                                       Handler&& handler) {
-  struct pfs_writer {
-    FMT_CONSTEXPR void operator()(const Char* begin, const Char* end) {
-      if (begin == end) return;
-      for (;;) {
-        const Char* p = nullptr;
-        if (!find<IS_CONSTEXPR>(begin, end, '}', p))
-          return handler_.on_text(begin, end);
-        ++p;
-        if (p == end || *p != '}')
-          return handler_.on_error("unmatched '}' in format string");
-        handler_.on_text(begin, p);
-        begin = p + 1;
-      }
-    }
-    Handler& handler_;
-  } write{handler};
-  auto begin = format_str.data();
-  auto end = begin + format_str.size();
-  while (begin != end) {
-    // Doing two passes with memchr (one for '{' and another for '}') is up to
-    // 2.5x faster than the naive one-pass implementation on big format strings.
-    const Char* p = begin;
-    if (*begin != '{' && !find<IS_CONSTEXPR>(begin, end, '{', p))
-      return write(begin, end);
-    write(begin, p);
-    ++p;
-    if (p == end) return handler.on_error("invalid format string");
-    if (static_cast<char>(*p) == '}') {
-      handler.on_arg_id();
-      handler.on_replacement_field(p);
-    } else if (*p == '{') {
-      handler.on_text(p, p + 1);
-    } else {
-      p = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
-      Char c = p != end ? *p : Char();
-      if (c == '}') {
-        handler.on_replacement_field(p);
-      } else if (c == ':') {
-        p = handler.on_format_specs(p + 1, end);
-        if (p == end || *p != '}')
-          return handler.on_error("unknown format specifier");
-      } else {
-        return handler.on_error("missing '}' in format string");
-      }
-    }
-    begin = p + 1;
-  }
-}
-
-template <typename T, typename ParseContext>
-FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
-    ParseContext& ctx) {
-  using char_type = typename ParseContext::char_type;
-  using context = buffer_context<char_type>;
-  using mapped_type =
-      conditional_t<internal::mapped_type_constant<T, context>::value !=
-                        internal::custom_type,
-                    decltype(arg_mapper<context>().map(std::declval<T>())), T>;
-  auto f = conditional_t<has_formatter<mapped_type, context>::value,
-                         formatter<mapped_type, char_type>,
-                         internal::fallback_formatter<T, char_type>>();
-  return f.parse(ctx);
-}
-
-template <typename Char, typename ErrorHandler, typename... Args>
-class format_string_checker {
- public:
-  explicit FMT_CONSTEXPR format_string_checker(
-      basic_string_view<Char> format_str, ErrorHandler eh)
-      : arg_id_(-1),
-        context_(format_str, eh),
-        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
-
-  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
-
-  FMT_CONSTEXPR void on_arg_id() {
-    arg_id_ = context_.next_arg_id();
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(int id) {
-    arg_id_ = id;
-    context_.check_arg_id(id);
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
-    on_error("compile-time checks don't support named arguments");
-  }
-
-  FMT_CONSTEXPR void on_replacement_field(const Char*) {}
-
-  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
-    advance_to(context_, begin);
-    return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    context_.on_error(message);
-  }
-
- private:
-  using parse_context_type = basic_format_parse_context<Char, ErrorHandler>;
-  enum { num_args = sizeof...(Args) };
-
-  FMT_CONSTEXPR void check_arg_id() {
-    if (arg_id_ >= num_args) context_.on_error("argument index out of range");
-  }
-
-  // Format specifier parsing function.
-  using parse_func = const Char* (*)(parse_context_type&);
-
-  int arg_id_;
-  parse_context_type context_;
-  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
-};
-
-template <typename Char, typename ErrorHandler, typename... Args>
-FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
-                                          ErrorHandler eh = ErrorHandler()) {
-  format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
-  parse_format_string<true>(s, checker);
-  return true;
-}
-
-template <typename... Args, typename S,
-          enable_if_t<(is_compile_string<S>::value), int>>
-void check_format_string(S format_str) {
-  FMT_CONSTEXPR_DECL bool invalid_format =
-      internal::do_check_format_string<typename S::char_type,
-                                       internal::error_handler, Args...>(
-          to_string_view(format_str));
-  (void)invalid_format;
-}
-
-template <template <typename> class Handler, typename Context>
-void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref,
-                         Context& ctx) {
-  switch (ref.kind) {
-  case arg_id_kind::none:
-    break;
-  case arg_id_kind::index:
-    value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.index),
-                                                ctx.error_handler());
-    break;
-  case arg_id_kind::name:
-    value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.name),
-                                                ctx.error_handler());
-    break;
-  }
-}
-}  // namespace internal
-
-template <typename Range>
-using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
-using writer FMT_DEPRECATED_ALIAS = internal::writer;
-using wwriter FMT_DEPRECATED_ALIAS =
-    internal::basic_writer<buffer_range<wchar_t>>;
-
-/** The default argument formatter. */
-template <typename Range>
-class arg_formatter : public internal::arg_formatter_base<Range> {
- private:
-  using char_type = typename Range::value_type;
-  using base = internal::arg_formatter_base<Range>;
-  using context_type = basic_format_context<typename base::iterator, char_type>;
-
-  context_type& ctx_;
-  basic_format_parse_context<char_type>* parse_ctx_;
-
- public:
-  using range = Range;
-  using iterator = typename base::iterator;
-  using format_specs = typename base::format_specs;
-
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *ctx* is a reference to the formatting context,
-    *specs* contains format specifier information for standard argument types.
-    \endrst
-   */
-  explicit arg_formatter(
-      context_type& ctx,
-      basic_format_parse_context<char_type>* parse_ctx = nullptr,
-      format_specs* specs = nullptr)
-      : base(Range(ctx.out()), specs, ctx.locale()),
-        ctx_(ctx),
-        parse_ctx_(parse_ctx) {}
-
-  using base::operator();
-
-  /** Formats an argument of a user-defined type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    handle.format(*parse_ctx_, ctx_);
-    return ctx_.out();
-  }
-};
-
-/** Fast integer formatter. */
-class format_int {
- private:
-  // Buffer should be large enough to hold all digits (digits10 + 1),
-  // a sign and a null character.
-  enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
-  mutable char buffer_[buffer_size];
-  char* str_;
-
-  // Formats value in reverse and returns a pointer to the beginning.
-  char* format_decimal(unsigned long long value) {
-    char* ptr = buffer_ + (buffer_size - 1);  // Parens to workaround MSVC bug.
-    while (value >= 100) {
-      // Integer division is slow so do it for a group of two digits instead
-      // of for every digit. The idea comes from the talk by Alexandrescu
-      // "Three Optimization Tips for C++". See speed-test for a comparison.
-      auto index = static_cast<unsigned>((value % 100) * 2);
-      value /= 100;
-      *--ptr = internal::data::digits[index + 1];
-      *--ptr = internal::data::digits[index];
-    }
-    if (value < 10) {
-      *--ptr = static_cast<char>('0' + value);
-      return ptr;
-    }
-    auto index = static_cast<unsigned>(value * 2);
-    *--ptr = internal::data::digits[index + 1];
-    *--ptr = internal::data::digits[index];
-    return ptr;
-  }
-
-  void format_signed(long long value) {
-    auto abs_value = static_cast<unsigned long long>(value);
-    bool negative = value < 0;
-    if (negative) abs_value = 0 - abs_value;
-    str_ = format_decimal(abs_value);
-    if (negative) *--str_ = '-';
-  }
-
- public:
-  explicit format_int(int value) { format_signed(value); }
-  explicit format_int(long value) { format_signed(value); }
-  explicit format_int(long long value) { format_signed(value); }
-  explicit format_int(unsigned value) : str_(format_decimal(value)) {}
-  explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
-  explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}
-
-  /** Returns the number of characters written to the output buffer. */
-  std::size_t size() const {
-    return internal::to_unsigned(buffer_ - str_ + buffer_size - 1);
-  }
-
-  /**
-    Returns a pointer to the output buffer content. No terminating null
-    character is appended.
-   */
-  const char* data() const { return str_; }
-
-  /**
-    Returns a pointer to the output buffer content with terminating null
-    character appended.
-   */
-  const char* c_str() const {
-    buffer_[buffer_size - 1] = '\0';
-    return str_;
-  }
-
-  /**
-    \rst
-    Returns the content of the output buffer as an ``std::string``.
-    \endrst
-   */
-  std::string str() const { return std::string(str_, size()); }
-};
-
-// A formatter specialization for the core types corresponding to internal::type
-// constants.
-template <typename T, typename Char>
-struct formatter<T, Char,
-                 enable_if_t<internal::type_constant<T, Char>::value !=
-                             internal::custom_type>> {
-  FMT_CONSTEXPR formatter() = default;
-
-  // Parses format specifiers stopping either at the end of the range or at the
-  // terminating '}'.
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    using handler_type = internal::dynamic_specs_handler<ParseContext>;
-    auto type = internal::type_constant<T, Char>::value;
-    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
-                                                  type);
-    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
-    auto eh = ctx.error_handler();
-    switch (type) {
-    case internal::none_type:
-    case internal::named_arg_type:
-      FMT_ASSERT(false, "invalid argument type");
-      break;
-    case internal::int_type:
-    case internal::uint_type:
-    case internal::long_long_type:
-    case internal::ulong_long_type:
-    case internal::int128_type:
-    case internal::uint128_type:
-    case internal::bool_type:
-      handle_int_type_spec(specs_.type,
-                           internal::int_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::char_type:
-      handle_char_specs(
-          &specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
-      break;
-    case internal::float_type:
-    case internal::double_type:
-    case internal::long_double_type:
-      internal::parse_float_type_spec(specs_, eh);
-      break;
-    case internal::cstring_type:
-      internal::handle_cstring_type_spec(
-          specs_.type, internal::cstring_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::string_type:
-      internal::check_string_type_spec(specs_.type, eh);
-      break;
-    case internal::pointer_type:
-      internal::check_pointer_type_spec(specs_.type, eh);
-      break;
-    case internal::custom_type:
-      // Custom format specifiers should be checked in parse functions of
-      // formatter specializations.
-      break;
-    }
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) const -> decltype(ctx.out()) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs_.width, specs_.width_ref, ctx);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-    using range_type =
-        internal::output_range<typename FormatContext::iterator,
-                               typename FormatContext::char_type>;
-    return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
-                            internal::make_arg<FormatContext>(val));
-  }
-
- private:
-  internal::dynamic_format_specs<Char> specs_;
-};
-
-#define FMT_FORMAT_AS(Type, Base)                                             \
-  template <typename Char>                                                    \
-  struct formatter<Type, Char> : formatter<Base, Char> {                      \
-    template <typename FormatContext>                                         \
-    auto format(const Type& val, FormatContext& ctx) const -> decltype(ctx.out()) { \
-      return formatter<Base, Char>::format(val, ctx);                         \
-    }                                                                         \
-  }
-
-FMT_FORMAT_AS(signed char, int);
-FMT_FORMAT_AS(unsigned char, unsigned);
-FMT_FORMAT_AS(short, int);
-FMT_FORMAT_AS(unsigned short, unsigned);
-FMT_FORMAT_AS(long, long long);
-FMT_FORMAT_AS(unsigned long, unsigned long long);
-FMT_FORMAT_AS(Char*, const Char*);
-FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
-FMT_FORMAT_AS(std::nullptr_t, const void*);
-FMT_FORMAT_AS(internal::std_string_view<Char>, basic_string_view<Char>);
-
-template <typename Char>
-struct formatter<void*, Char> : formatter<const void*, Char> {
-  template <typename FormatContext>
-  auto format(void* val, FormatContext& ctx) const -> decltype(ctx.out()) {
-    return formatter<const void*, Char>::format(val, ctx);
-  }
-};
-
-template <typename Char, size_t N>
-struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
-  template <typename FormatContext>
-  auto format(const Char* val, FormatContext& ctx) const -> decltype(ctx.out()) {
-    return formatter<basic_string_view<Char>, Char>::format(val, ctx);
-  }
-};
-
-// A formatter for types known only at run time such as variant alternatives.
-//
-// Usage:
-//   using variant = std::variant<int, std::string>;
-//   template <>
-//   struct formatter<variant>: dynamic_formatter<> {
-//     void format(buffer &buf, const variant &v, context &ctx) {
-//       visit([&](const auto &val) { format(buf, val, ctx); }, v);
-//     }
-//   };
-template <typename Char = char> class dynamic_formatter {
- private:
-  struct null_handler : internal::error_handler {
-    void on_align(align_t) {}
-    void on_plus() {}
-    void on_minus() {}
-    void on_space() {}
-    void on_hash() {}
-  };
-
- public:
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    format_str_ = ctx.begin();
-    // Checks are deferred to formatting time when the argument type is known.
-    internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
-    return parse_format_specs(ctx.begin(), ctx.end(), handler);
-  }
-
-  template <typename T, typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) const -> decltype(ctx.out()) {
-    handle_specs(ctx);
-    internal::specs_checker<null_handler> checker(
-        null_handler(),
-        internal::mapped_type_constant<T, FormatContext>::value);
-    checker.on_align(specs_.align);
-    switch (specs_.sign) {
-    case sign::none:
-      break;
-    case sign::plus:
-      checker.on_plus();
-      break;
-    case sign::minus:
-      checker.on_minus();
-      break;
-    case sign::space:
-      checker.on_space();
-      break;
-    }
-    if (specs_.alt) checker.on_hash();
-    if (specs_.precision >= 0) checker.end_precision();
-    using range = internal::output_range<typename FormatContext::iterator,
-                                         typename FormatContext::char_type>;
-    visit_format_arg(arg_formatter<range>(ctx, nullptr, &specs_),
-                     internal::make_arg<FormatContext>(val));
-    return ctx.out();
-  }
-
- private:
-  template <typename Context> void handle_specs(Context& ctx) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-        specs_.width, specs_.width_ref, ctx);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-  }
-
-  internal::dynamic_format_specs<Char> specs_;
-  const Char* format_str_;
-};
-
-template <typename Range, typename Char>
-typename basic_format_context<Range, Char>::format_arg
-basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
-  map_.init(args_);
-  format_arg arg = map_.find(name);
-  if (arg.type() == internal::none_type) this->on_error("argument not found");
-  return arg;
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void advance_to(
-    basic_format_parse_context<Char, ErrorHandler>& ctx, const Char* p) {
-  ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
-}
-
-template <typename ArgFormatter, typename Char, typename Context>
-struct format_handler : internal::error_handler {
-  using range = typename ArgFormatter::range;
-
-  format_handler(range r, basic_string_view<Char> str,
-                 basic_format_args<Context> format_args,
-                 internal::locale_ref loc)
-      : parse_context(str), context(r.begin(), format_args, loc) {}
-
-  void on_text(const Char* begin, const Char* end) {
-    auto size = internal::to_unsigned(end - begin);
-    auto out = context.out();
-    auto&& it = internal::reserve(out, size);
-    it = std::copy_n(begin, size, it);
-    context.advance_to(out);
-  }
-
-  void get_arg(int id) { arg = internal::get_arg(context, id); }
-
-  void on_arg_id() { get_arg(parse_context.next_arg_id()); }
-  void on_arg_id(int id) {
-    parse_context.check_arg_id(id);
-    get_arg(id);
-  }
-  void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }
-
-  void on_replacement_field(const Char* p) {
-    advance_to(parse_context, p);
-    context.advance_to(
-        visit_format_arg(ArgFormatter(context, &parse_context), arg));
-  }
-
-  const Char* on_format_specs(const Char* begin, const Char* end) {
-    advance_to(parse_context, begin);
-    internal::custom_formatter<Context> f(parse_context, context);
-    if (visit_format_arg(f, arg)) return parse_context.begin();
-    basic_format_specs<Char> specs;
-    using internal::specs_handler;
-    using parse_context_t = basic_format_parse_context<Char>;
-    internal::specs_checker<specs_handler<parse_context_t, Context>> handler(
-        specs_handler<parse_context_t, Context>(specs, parse_context, context),
-        arg.type());
-    begin = parse_format_specs(begin, end, handler);
-    if (begin == end || *begin != '}') on_error("missing '}' in format string");
-    advance_to(parse_context, begin);
-    context.advance_to(
-        visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
-    return begin;
-  }
-
-  basic_format_parse_context<Char> parse_context;
-  Context context;
-  basic_format_arg<Context> arg;
-};
-
-/** Formats arguments and writes the output to the range. */
-template <typename ArgFormatter, typename Char, typename Context>
-typename Context::iterator vformat_to(
-    typename ArgFormatter::range out, basic_string_view<Char> format_str,
-    basic_format_args<Context> args,
-    internal::locale_ref loc = internal::locale_ref()) {
-  format_handler<ArgFormatter, Char, Context> h(out, format_str, args, loc);
-  internal::parse_format_string<false>(format_str, h);
-  return h.context.out();
-}
-
-// Casts ``p`` to ``const void*`` for pointer formatting.
-// Example:
-//   auto s = format("{}", ptr(p));
-template <typename T> inline const void* ptr(const T* p) { return p; }
-template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
-  return p.get();
-}
-template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
-  return p.get();
-}
-
-template <typename It, typename Char> struct arg_join : internal::view {
-  It begin;
-  It end;
-  basic_string_view<Char> sep;
-
-  arg_join(It b, It e, basic_string_view<Char> s) : begin(b), end(e), sep(s) {}
-};
-
-template <typename It, typename Char>
-struct formatter<arg_join<It, Char>, Char>
-    : formatter<typename std::iterator_traits<It>::value_type, Char> {
-  template <typename FormatContext>
-  auto format(const arg_join<It, Char>& value, FormatContext& ctx)
-      -> decltype(ctx.out()) {
-    using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
-    auto it = value.begin;
-    auto out = ctx.out();
-    if (it != value.end) {
-      out = base::format(*it++, ctx);
-      while (it != value.end) {
-        out = std::copy(value.sep.begin(), value.sep.end(), out);
-        ctx.advance_to(out);
-        out = base::format(*it++, ctx);
-      }
-    }
-    return out;
-  }
-};
-
-/**
-  Returns an object that formats the iterator range `[begin, end)` with elements
-  separated by `sep`.
- */
-template <typename It>
-arg_join<It, char> join(It begin, It end, string_view sep) {
-  return {begin, end, sep};
-}
-
-template <typename It>
-arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
-  return {begin, end, sep};
-}
-
-/**
-  \rst
-  Returns an object that formats `range` with elements separated by `sep`.
-
-  **Example**::
-
-    std::vector<int> v = {1, 2, 3};
-    fmt::print("{}", fmt::join(v, ", "));
-    // Output: "1, 2, 3"
-  \endrst
- */
-template <typename Range>
-arg_join<internal::iterator_t<const Range>, char> join(const Range& range,
-                                                       string_view sep) {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-template <typename Range>
-arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
-                                                          wstring_view sep) {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-/**
-  \rst
-  Converts *value* to ``std::string`` using the default format for type *T*.
-  It doesn't support user-defined types with custom formatters.
-
-  **Example**::
-
-    #include <fmt/format.h>
-
-    std::string answer = fmt::to_string(42);
-  \endrst
- */
-template <typename T> inline std::string to_string(const T& value) {
-  return format("{}", value);
-}
-
-/**
-  Converts *value* to ``std::wstring`` using the default format for type *T*.
- */
-template <typename T> inline std::wstring to_wstring(const T& value) {
-  return format(L"{}", value);
-}
-
-template <typename Char, std::size_t SIZE>
-std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
-  return std::basic_string<Char>(buf.data(), buf.size());
-}
-
-template <typename Char>
-typename buffer_context<Char>::iterator internal::vformat_to(
-    internal::buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args) {
-  using range = buffer_range<Char>;
-  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
-                                          args);
-}
-
-template <typename S, typename Char = char_t<S>,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline typename buffer_context<Char>::iterator vformat_to(
-    internal::buffer<Char>& buf, const S& format_str,
-    basic_format_args<buffer_context<Char>> args) {
-  return internal::vformat_to(buf, to_string_view(format_str), args);
-}
-
-template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline typename buffer_context<Char>::iterator format_to(
-    basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
-  internal::check_format_string<Args...>(format_str);
-  using context = buffer_context<Char>;
-  return internal::vformat_to(buf, to_string_view(format_str),
-                              {make_format_args<context>(args...)});
-}
-
-template <typename OutputIt, typename Char = char>
-using format_context_t = basic_format_context<OutputIt, Char>;
-
-template <typename OutputIt, typename Char = char>
-using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
-
-template <typename S, typename OutputIt, typename... Args,
-          FMT_ENABLE_IF(
-              internal::is_output_iterator<OutputIt>::value &&
-              !internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
-inline OutputIt vformat_to(OutputIt out, const S& format_str,
-                           format_args_t<OutputIt, char_t<S>> args) {
-  using range = internal::output_range<OutputIt, char_t<S>>;
-  return vformat_to<arg_formatter<range>>(range(out),
-                                          to_string_view(format_str), args);
-}
-
-/**
- \rst
- Formats arguments, writes the result to the output iterator ``out`` and returns
- the iterator past the end of the output range.
-
- **Example**::
-
-   std::vector<char> out;
-   fmt::format_to(std::back_inserter(out), "{}", 42);
- \endrst
- */
-template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(
-              internal::is_output_iterator<OutputIt>::value &&
-              !internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
-              internal::is_string<S>::value)>
-inline OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
-  internal::check_format_string<Args...>(format_str);
-  using context = format_context_t<OutputIt, char_t<S>>;
-  return vformat_to(out, to_string_view(format_str),
-                    {make_format_args<context>(args...)});
-}
-
-template <typename OutputIt> struct format_to_n_result {
-  /** Iterator past the end of the output range. */
-  OutputIt out;
-  /** Total (not truncated) output size. */
-  std::size_t size;
-};
-
-template <typename OutputIt, typename Char = typename OutputIt::value_type>
-using format_to_n_context =
-    format_context_t<internal::truncating_iterator<OutputIt>, Char>;
-
-template <typename OutputIt, typename Char = typename OutputIt::value_type>
-using format_to_n_args = basic_format_args<format_to_n_context<OutputIt, Char>>;
-
-template <typename OutputIt, typename Char, typename... Args>
-inline format_arg_store<format_to_n_context<OutputIt, Char>, Args...>
-make_format_to_n_args(const Args&... args) {
-  return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(
-      args...);
-}
-
-template <typename OutputIt, typename Char, typename... Args,
-          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> vformat_to_n(
-    OutputIt out, std::size_t n, basic_string_view<Char> format_str,
-    format_to_n_args<OutputIt, Char> args) {
-  auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n),
-                       format_str, args);
-  return {it.base(), it.count()};
-}
-
-/**
- \rst
- Formats arguments, writes up to ``n`` characters of the result to the output
- iterator ``out`` and returns the total output size and the iterator past the
- end of the output range.
- \endrst
- */
-template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value&&
-                            internal::is_output_iterator<OutputIt>::value)>
-inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
-                                                const S& format_str,
-                                                const Args&... args) {
-  internal::check_format_string<Args...>(format_str);
-  using context = format_to_n_context<OutputIt, char_t<S>>;
-  return vformat_to_n(out, n, to_string_view(format_str),
-                      {make_format_args<context>(args...)});
-}
-
-template <typename Char>
-inline std::basic_string<Char> internal::vformat(
-    basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  internal::vformat_to(buffer, format_str, args);
-  return to_string(buffer);
-}
-
-/**
-  Returns the number of characters in the output of
-  ``format(format_str, args...)``.
- */
-template <typename... Args>
-inline std::size_t formatted_size(string_view format_str, const Args&... args) {
-  return format_to(internal::counting_iterator(), format_str, args...).count();
-}
-
-#if FMT_USE_USER_DEFINED_LITERALS
-namespace internal {
-
-#  if FMT_USE_UDL_TEMPLATE
-template <typename Char, Char... CHARS> class udl_formatter {
- public:
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
-    FMT_CONSTEXPR_DECL bool invalid_format =
-        do_check_format_string<Char, error_handler, remove_cvref_t<Args>...>(
-            basic_string_view<Char>(s, sizeof...(CHARS)));
-    (void)invalid_format;
-    return format(s, std::forward<Args>(args)...);
-  }
-};
-#  else
-template <typename Char> struct udl_formatter {
-  basic_string_view<Char> str;
-
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    return format(str, std::forward<Args>(args)...);
-  }
-};
-#  endif  // FMT_USE_UDL_TEMPLATE
-
-template <typename Char> struct udl_arg {
-  basic_string_view<Char> str;
-
-  template <typename T> named_arg<T, Char> operator=(T&& value) const {
-    return {str, std::forward<T>(value)};
-  }
-};
-
-}  // namespace internal
-
-inline namespace literals {
-#  if FMT_USE_UDL_TEMPLATE
-template <typename Char, Char... CHARS>
-FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
-  return {};
-}
-#  else
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::format`.
-
-  **Example**::
-
-    using namespace fmt::literals;
-    std::string message = "The answer is {}"_format(42);
-  \endrst
- */
-FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char* s,
-                                                               std::size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
-    const wchar_t* s, std::size_t n) {
-  return {{s, n}};
-}
-#  endif  // FMT_USE_UDL_TEMPLATE
-
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::arg`.
-
-  **Example**::
-
-    using namespace fmt::literals;
-    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-  \endrst
- */
-FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char* s,
-                                                    std::size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s,
-                                                       std::size_t n) {
-  return {{s, n}};
-}
-}  // namespace literals
-#endif  // FMT_USE_USER_DEFINED_LITERALS
-FMT_END_NAMESPACE
-
-#define FMT_STRING_IMPL(s, ...)                                         \
-  [] {                                                                  \
-    struct str : duckdb_fmt::compile_string {                                  \
-      using char_type = typename std::remove_cv<std::remove_pointer<    \
-          typename std::decay<decltype(s)>::type>::type>::type;         \
-      __VA_ARGS__ FMT_CONSTEXPR                                         \
-      operator duckdb_fmt::basic_string_view<char_type>() const {              \
-        return {s, sizeof(s) / sizeof(char_type) - 1};                  \
-      }                                                                 \
-    } result;                                                           \
-    /* Suppress Qt Creator warning about unused operator. */            \
-    (void)static_cast<duckdb_fmt::basic_string_view<typename str::char_type>>( \
-        result);                                                        \
-    return result;                                                      \
-  }()
-
-/**
-  \rst
-  Constructs a compile-time format string.
-
-  **Example**::
-
-    // A compile-time error because 'd' is an invalid specifier for strings.
-    std::string s = format(FMT_STRING("{:d}"), "foo");
-  \endrst
- */
-#define FMT_STRING(s) FMT_STRING_IMPL(s, )
-
-#if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
-#  define fmt(s) FMT_STRING_IMPL(s, [[deprecated]])
-#endif
-
-#ifdef FMT_HEADER_ONLY
-#  define FMT_FUNC inline
-// #  include "format-inl.h"
-#else
-#  define FMT_FUNC
-#endif
-
-#endif  // FMT_FORMAT_H_
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
-// See the end of this file for a list
-
-// Formatting library for C++ - legacy printf implementation
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_PRINTF_H_
-#define FMT_PRINTF_H_
-
-#include <algorithm>  // std::max
-#include <limits>     // std::numeric_limits
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
-// See the end of this file for a list
-
-// Formatting library for C++ - std::ostream support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_OSTREAM_H_
-#define FMT_OSTREAM_H_
-
-#include <ostream>
-
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-template <class Char> class formatbuf : public std::basic_streambuf<Char> {
- private:
-  using int_type = typename std::basic_streambuf<Char>::int_type;
-  using traits_type = typename std::basic_streambuf<Char>::traits_type;
-
-  buffer<Char>& buffer_;
-
- public:
-  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
-
- protected:
-  // The put-area is actually always empty. This makes the implementation
-  // simpler and has the advantage that the streambuf and the buffer are always
-  // in sync and sputc never writes into uninitialized memory. The obvious
-  // disadvantage is that each call to sputc always results in a (virtual) call
-  // to overflow. There is no disadvantage here for sputn since this always
-  // results in a call to xsputn.
-
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<Char>(ch));
-    return ch;
-  }
-
-  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
-    buffer_.append(s, s + count);
-    return count;
-  }
-};
-
-template <typename Char> struct test_stream : std::basic_ostream<Char> {
- private:
-  // Hide all operator<< from std::basic_ostream<Char>.
-  void_t<> operator<<(null<>);
-  void_t<> operator<<(const Char*);
-
-  template <typename T, FMT_ENABLE_IF(std::is_convertible<T, int>::value &&
-                                      !std::is_enum<T>::value)>
-  void_t<> operator<<(T);
-};
-
-// Checks if T has a user-defined operator<< (e.g. not a member of
-// std::ostream).
-template <typename T, typename Char> class is_streamable {
- private:
-  template <typename U>
-  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
-                                              << std::declval<U>()),
-                                     void_t<>>::value>
-  test(int);
-
-  template <typename> static std::false_type test(...);
-
-  using result = decltype(test<T>(0));
-
- public:
-  static const bool value = result::value;
-};
-
-// Write the content of buf to os.
-template <typename Char>
-void write(std::basic_ostream<Char>& os, buffer<Char>& buf) {
-  const Char* buf_data = buf.data();
-  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
-  unsigned_streamsize size = buf.size();
-  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
-  do {
-    unsigned_streamsize n = size <= max_size ? size : max_size;
-    os.write(buf_data, static_cast<std::streamsize>(n));
-    buf_data += n;
-    size -= n;
-  } while (size != 0);
-}
-
-template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value,
-                  locale_ref loc = locale_ref()) {
-  formatbuf<Char> format_buf(buf);
-  std::basic_ostream<Char> output(&format_buf);
-  if (loc) output.imbue(loc.get<std::locale>());
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  output << value;
-  buf.resize(buf.size());
-}
-
-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
-    : formatter<basic_string_view<Char>, Char> {
-  template <typename Context>
-  auto format(const T& value, Context& ctx) -> decltype(ctx.out()) {
-    basic_memory_buffer<Char> buffer;
-    format_value(buffer, value, ctx.locale());
-    basic_string_view<Char> str(buffer.data(), buffer.size());
-    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
-  }
-};
-}  // namespace internal
-
-template <typename Char>
-void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
-            basic_format_args<buffer_context<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  internal::vformat_to(buffer, format_str, args);
-  internal::write(os, buffer);
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::print(cerr, "Don't {}!", "panic");
-  \endrst
- */
-template <typename S, typename... Args,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
-  vprint(os, to_string_view(format_str),
-         {internal::make_args_checked<Args...>(format_str, args...)});
-}
-FMT_END_NAMESPACE
-
-#endif  // FMT_OSTREAM_H_
-
-
-// LICENSE_CHANGE_END
-
-
-#ifdef min
-#undef min
-#endif
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned> struct int_checker {
-  template <typename T> static bool fits_in_int(T value) {
-    unsigned max = max_value<int>();
-    return value <= max;
-  }
-  static bool fits_in_int(bool) { return true; }
-};
-
-template <> struct int_checker<true> {
-  template <typename T> static bool fits_in_int(T value) {
-    return value >= std::numeric_limits<int>::min() &&
-           value <= max_value<int>();
-  }
-  static bool fits_in_int(int) { return true; }
-};
-
-class printf_precision_handler {
- public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  int operator()(T value) {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(duckdb::Exception("number is too big"));
-    return (std::max)(static_cast<int>(value), 0);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  int operator()(T) {
-    FMT_THROW(duckdb::Exception("precision is not integer"));
-    return 0;
-  }
-};
-
-// An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int {
- public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  bool operator()(T value) {
-    return value == 0;
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  bool operator()(T) {
-    return false;
-  }
-};
-
-template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
-
-template <> struct make_unsigned_or_bool<bool> { using type = bool; };
-
-template <typename T, typename Context> class arg_converter {
- private:
-  using char_type = typename Context::char_type;
-
-  basic_format_arg<Context>& arg_;
-  char_type type_;
-
- public:
-  arg_converter(basic_format_arg<Context>& arg, char_type type)
-      : arg_(arg), type_(type) {}
-
-  void operator()(bool value) {
-    if (type_ != 's') operator()<bool>(value);
-  }
-
-  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
-  void operator()(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
-    if (const_check(sizeof(target_type) <= sizeof(int))) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_ = internal::make_arg<Context>(
-            static_cast<int>(static_cast<target_type>(value)));
-      } else {
-        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-        arg_ = internal::make_arg<Context>(
-            static_cast<unsigned>(static_cast<unsigned_type>(value)));
-      }
-    } else {
-      if (is_signed) {
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        arg_ = internal::make_arg<Context>(static_cast<long long>(value));
-      } else {
-        arg_ = internal::make_arg<Context>(
-            static_cast<typename make_unsigned_or_bool<U>::type>(value));
-      }
-    }
-  }
-
-  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
-  void operator()(U) {}  // No conversion needed for non-integral types.
-};
-
-// Converts an integer argument to T for printf, if T is an integral type.
-// If T is void, the argument is converted to corresponding signed or unsigned
-// type depending on the type specifier: 'd' and 'i' - signed, other -
-// unsigned).
-template <typename T, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
-}
-
-// Converts an integer argument to char for printf.
-template <typename Context> class char_converter {
- private:
-  basic_format_arg<Context>& arg_;
-
- public:
-  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
-
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  void operator()(T value) {
-    arg_ = internal::make_arg<Context>(
-        static_cast<typename Context::char_type>(value));
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  void operator()(T) {}  // No conversion needed for non-integral types.
-};
-
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-template <typename Char> class printf_width_handler {
- private:
-  using format_specs = basic_format_specs<Char>;
-
-  format_specs& specs_;
-
- public:
-  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
-
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  unsigned operator()(T value) {
-    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
-    if (internal::is_negative(value)) {
-      specs_.align = align::left;
-      width = 0 - width;
-    }
-    unsigned int_max = max_value<int>();
-    if (width > int_max) FMT_THROW(duckdb::Exception("number is too big"));
-    return static_cast<unsigned>(width);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  unsigned operator()(T) {
-    FMT_THROW(duckdb::Exception("width is not integer"));
-    return 0;
-  }
-};
-
-template <typename Char, typename Context>
-void printf(buffer<Char>& buf, basic_string_view<Char> format,
-            basic_format_args<Context> args) {
-  Context(std::back_inserter(buf), format, args).format();
-}
-
-template <typename OutputIt, typename Char, typename Context>
-internal::truncating_iterator<OutputIt> printf(
-    internal::truncating_iterator<OutputIt> it, basic_string_view<Char> format,
-    basic_format_args<Context> args) {
-  return Context(it, format, args).format();
-}
-}  // namespace internal
-
-using internal::printf;  // For printing into memory_buffer.
-
-template <typename Range> class printf_arg_formatter;
-
-template <typename OutputIt, typename Char> class basic_printf_context;
-
-/**
-  \rst
-  The ``printf`` argument formatter.
-  \endrst
- */
-template <typename Range>
-class printf_arg_formatter : public internal::arg_formatter_base<Range> {
- public:
-  using iterator = typename Range::iterator;
-
- private:
-  using char_type = typename Range::value_type;
-  using base = internal::arg_formatter_base<Range>;
-  using context_type = basic_printf_context<iterator, char_type>;
-
-  context_type& context_;
-
-  void write_null_pointer(char) {
-    this->specs()->type = 0;
-    this->write("(nil)");
-  }
-
-  void write_null_pointer(wchar_t) {
-    this->specs()->type = 0;
-    this->write(L"(nil)");
-  }
-
- public:
-  using format_specs = typename base::format_specs;
-
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *buffer* is a reference to the output buffer and *specs* contains format
-    specifier information for standard argument types.
-    \endrst
-   */
-  printf_arg_formatter(iterator iter, format_specs& specs, context_type& ctx)
-      : base(Range(iter), &specs, internal::locale_ref()), context_(ctx) {}
-
-  template <typename T, FMT_ENABLE_IF(duckdb_fmt::internal::is_integral<T>::value)>
-  iterator operator()(T value) {
-    // MSVC2013 fails to compile separate overloads for bool and char_type so
-    // use std::is_same instead.
-    if (std::is_same<T, bool>::value) {
-      format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type != 's') return base::operator()(value ? 1 : 0);
-      fmt_specs.type = 0;
-      this->write(value != 0);
-    } else if (std::is_same<T, char_type>::value) {
-      format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type && fmt_specs.type != 'c')
-        return (*this)(static_cast<int>(value));
-      fmt_specs.sign = sign::none;
-      fmt_specs.alt = false;
-      fmt_specs.align = align::right;
-      return base::operator()(value);
-    } else {
-      return base::operator()(value);
-    }
-    return this->out();
-  }
-
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
-    return base::operator()(value);
-  }
-
-  /** Formats a null-terminated C string. */
-  iterator operator()(const char* value) {
-    if (value)
-      base::operator()(value);
-    else if (this->specs()->type == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write("(null)");
-    return this->out();
-  }
-
-  /** Formats a null-terminated wide C string. */
-  iterator operator()(const wchar_t* value) {
-    if (value)
-      base::operator()(value);
-    else if (this->specs()->type == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write(L"(null)");
-    return this->out();
-  }
-
-  iterator operator()(basic_string_view<char_type> value) {
-    return base::operator()(value);
-  }
-
-  iterator operator()(monostate value) { return base::operator()(value); }
-
-  /** Formats a pointer. */
-  iterator operator()(const void* value) {
-    if (value) return base::operator()(value);
-    this->specs()->type = 0;
-    write_null_pointer(char_type());
-    return this->out();
-  }
-
-  /** Formats an argument of a custom (user-defined) type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    handle.format(context_.parse_context(), context_);
-    return this->out();
-  }
-};
-
-template <typename T> struct printf_formatter {
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
-    internal::format_value(internal::get_container(ctx.out()), value);
-    return ctx.out();
-  }
-};
-
-/** This template formats data and writes the output to a writer. */
-template <typename OutputIt, typename Char> class basic_printf_context {
- public:
-  /** The character type for the output. */
-  using char_type = Char;
-  using format_arg = basic_format_arg<basic_printf_context>;
-  template <typename T> using formatter_type = printf_formatter<T>;
-
- private:
-  using format_specs = basic_format_specs<char_type>;
-
-  OutputIt out_;
-  basic_format_args<basic_printf_context> args_;
-  basic_format_parse_context<Char> parse_ctx_;
-
-  static void parse_flags(format_specs& specs, const Char*& it,
-                          const Char* end);
-
-  // Returns the argument with specified index or, if arg_index is -1, the next
-  // argument.
-  format_arg get_arg(int arg_index = -1);
-
-  // Parses argument index, flags and width and returns the argument index.
-  int parse_header(const Char*& it, const Char* end, format_specs& specs);
-
- public:
-  /**
-   \rst
-   Constructs a ``printf_context`` object. References to the arguments and
-   the writer are stored in the context object so make sure they have
-   appropriate lifetimes.
-   \endrst
-   */
-  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
-                       basic_format_args<basic_printf_context> args)
-      : out_(out), args_(args), parse_ctx_(format_str) {}
-
-  OutputIt out() { return out_; }
-  void advance_to(OutputIt it) { out_ = it; }
-
-  format_arg arg(int id) const { return args_.get(id); }
-
-  basic_format_parse_context<Char>& parse_context() { return parse_ctx_; }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    parse_ctx_.on_error(message);
-  }
-
-  /** Formats stored arguments and writes the output to the range. */
-  template <typename ArgFormatter = printf_arg_formatter<buffer_range<Char>>>
-  OutputIt format();
-};
-
-template <typename OutputIt, typename Char>
-void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
-                                                       const Char*& it,
-                                                       const Char* end) {
-  for (; it != end; ++it) {
-    switch (*it) {
-    case '-':
-      specs.align = align::left;
-      break;
-    case '+':
-      specs.sign = sign::plus;
-      break;
-    case '0':
-      specs.fill[0] = '0';
-      break;
-    case ' ':
-      specs.sign = sign::space;
-      break;
-    case '#':
-      specs.alt = true;
-      break;
-    default:
-      return;
-    }
-  }
-}
-
-template <typename OutputIt, typename Char>
-typename basic_printf_context<OutputIt, Char>::format_arg
-basic_printf_context<OutputIt, Char>::get_arg(int arg_index) {
-  if (arg_index < 0)
-    arg_index = parse_ctx_.next_arg_id();
-  else
-    parse_ctx_.check_arg_id(--arg_index);
-  return internal::get_arg(*this, arg_index);
-}
-
-template <typename OutputIt, typename Char>
-int basic_printf_context<OutputIt, Char>::parse_header(
-    const Char*& it, const Char* end, format_specs& specs) {
-  int arg_index = -1;
-  char_type c = *it;
-  if (c >= '0' && c <= '9') {
-    // Parse an argument index (if followed by '$') or a width possibly
-    // preceded with '0' flag(s).
-    internal::error_handler eh;
-    int value = parse_nonnegative_int(it, end, eh);
-    if (it != end && *it == '$') {  // value is an argument index
-      ++it;
-      arg_index = value;
-    } else {
-      if (c == '0') specs.fill[0] = '0';
-      if (value != 0) {
-        // Nonzero value means that we parsed width and don't need to
-        // parse it or flags again, so return now.
-        specs.width = value;
-        return arg_index;
-      }
-    }
-  }
-  parse_flags(specs, it, end);
-  // Parse width.
-  if (it != end) {
-    if (*it >= '0' && *it <= '9') {
-      internal::error_handler eh;
-      specs.width = parse_nonnegative_int(it, end, eh);
-    } else if (*it == '*') {
-      ++it;
-      specs.width = static_cast<int>(visit_format_arg(
-          internal::printf_width_handler<char_type>(specs), get_arg()));
-    }
-  }
-  return arg_index;
-}
-
-template <typename OutputIt, typename Char>
-template <typename ArgFormatter>
-OutputIt basic_printf_context<OutputIt, Char>::format() {
-  auto out = this->out();
-  const Char* start = parse_ctx_.begin();
-  const Char* end = parse_ctx_.end();
-  auto it = start;
-  while (it != end) {
-    char_type c = *it++;
-    if (c != '%') continue;
-    if (it != end && *it == c) {
-      out = std::copy(start, it, out);
-      start = ++it;
-      continue;
-    }
-    out = std::copy(start, it - 1, out);
-
-    format_specs specs;
-    specs.align = align::right;
-
-    // Parse argument index, flags and width.
-    int arg_index = parse_header(it, end, specs);
-    if (arg_index == 0) on_error("argument index out of range");
-
-    // Parse precision.
-    if (it != end && *it == '.') {
-      ++it;
-      c = it != end ? *it : 0;
-      if ('0' <= c && c <= '9') {
-        internal::error_handler eh;
-        specs.precision = parse_nonnegative_int(it, end, eh);
-      } else if (c == '*') {
-        ++it;
-        specs.precision =
-            static_cast<int>(visit_format_arg(internal::printf_precision_handler(), get_arg()));
-      } else {
-        specs.precision = 0;
-      }
-    }
-
-    format_arg arg = get_arg(arg_index);
-    if (specs.alt && visit_format_arg(internal::is_zero_int(), arg))
-      specs.alt = false;
-    if (specs.fill[0] == '0') {
-      if (arg.is_arithmetic())
-        specs.align = align::numeric;
-      else
-        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types.
-    }
-
-    // Parse length and convert the argument to the required type.
-    c = it != end ? *it++ : 0;
-    char_type t = it != end ? *it : 0;
-    using internal::convert_arg;
-    switch (c) {
-    case 'h':
-      if (t == 'h') {
-        ++it;
-        t = it != end ? *it : 0;
-        convert_arg<signed char>(arg, t);
-      } else {
-        convert_arg<short>(arg, t);
-      }
-      break;
-    case 'l':
-      if (t == 'l') {
-        ++it;
-        t = it != end ? *it : 0;
-        convert_arg<long long>(arg, t);
-      } else {
-        convert_arg<long>(arg, t);
-      }
-      break;
-    case 'j':
-      convert_arg<intmax_t>(arg, t);
-      break;
-    case 'z':
-      convert_arg<std::size_t>(arg, t);
-      break;
-    case 't':
-      convert_arg<std::ptrdiff_t>(arg, t);
-      break;
-    case 'L':
-      // printf produces garbage when 'L' is omitted for long double, no
-      // need to do the same.
-      break;
-    default:
-      --it;
-      convert_arg<void>(arg, c);
-    }
-
-    // Parse type.
-    if (it == end) FMT_THROW(duckdb::Exception("invalid format string"));
-    specs.type = static_cast<char>(*it++);
-    if (arg.is_integral()) {
-      // Normalize type.
-      switch (specs.type) {
-      case 'i':
-      case 'u':
-        specs.type = 'd';
-        break;
-      case 'c':
-        visit_format_arg(internal::char_converter<basic_printf_context>(arg),
-                         arg);
-        break;
-      }
-    }
-
-    start = it;
-
-    // Format argument.
-    visit_format_arg(ArgFormatter(out, specs, *this), arg);
-  }
-  return std::copy(start, it, out);
-}
-
-template <typename Char>
-using basic_printf_context_t =
-    basic_printf_context<std::back_insert_iterator<internal::buffer<Char>>,
-                         Char>;
-
-using printf_context = basic_printf_context_t<char>;
-using wprintf_context = basic_printf_context_t<wchar_t>;
-
-using printf_args = basic_format_args<printf_context>;
-using wprintf_args = basic_format_args<wprintf_context>;
-
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::printf_args`.
-  \endrst
- */
-template <typename... Args>
-inline format_arg_store<printf_context, Args...> make_printf_args(
-    const Args&... args) {
-  return {args...};
-}
-
-/**
-  \rst
-  Constructs an `~fmt::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmt::wprintf_args`.
-  \endrst
- */
-template <typename... Args>
-inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
-    const Args&... args) {
-  return {args...};
-}
-
-template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vsprintf(
-    const S& format, basic_format_args<basic_printf_context_t<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  return to_string(buffer);
-}
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    std::string message = fmt::sprintf("The answer is %d", 42);
-  \endrst
-*/
-template <typename S, typename... Args,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline std::basic_string<Char> sprintf(const S& format, const Args&... args) {
-  using context = basic_printf_context_t<Char>;
-  return vsprintf(to_string_view(format), {make_format_args<context>(args...)});
-}
-
-template <typename S, typename Char = char_t<S>>
-inline int vfprintf(std::FILE* f, const S& format,
-                    basic_format_args<basic_printf_context_t<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  std::size_t size = buffer.size();
-  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
-             ? -1
-             : static_cast<int>(size);
-}
-
-/**
-  \rst
-  Prints formatted data to the file *f*.
-
-  **Example**::
-
-    fmt::fprintf(stderr, "Don't %s!", "panic");
-  \endrst
- */
-template <typename S, typename... Args,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline int fprintf(std::FILE* f, const S& format, const Args&... args) {
-  using context = basic_printf_context_t<Char>;
-  return vfprintf(f, to_string_view(format),
-                  {make_format_args<context>(args...)});
-}
-
-template <typename S, typename Char = char_t<S>>
-inline int vprintf(const S& format,
-                   basic_format_args<basic_printf_context_t<Char>> args) {
-  return vfprintf(stdout, to_string_view(format), args);
-}
-
-/**
-  \rst
-  Prints formatted data to ``stdout``.
-
-  **Example**::
-
-    fmt::printf("Elapsed time: %.2f seconds", 1.23);
-  \endrst
- */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline int printf(const S& format_str, const Args&... args) {
-  using context = basic_printf_context_t<char_t<S>>;
-  return vprintf(to_string_view(format_str),
-                 {make_format_args<context>(args...)});
-}
-
-template <typename S, typename Char = char_t<S>>
-inline int vfprintf(std::basic_ostream<Char>& os, const S& format,
-                    basic_format_args<basic_printf_context_t<Char>> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, to_string_view(format), args);
-  internal::write(os, buffer);
-  return static_cast<int>(buffer.size());
-}
-
-/** Formats arguments and writes the output to the range. */
-template <typename ArgFormatter, typename Char,
-          typename Context =
-              basic_printf_context<typename ArgFormatter::iterator, Char>>
-typename ArgFormatter::iterator vprintf(internal::buffer<Char>& out,
-                                        basic_string_view<Char> format_str,
-                                        basic_format_args<Context> args) {
-  typename ArgFormatter::iterator iter(out);
-  Context(iter, format_str, args).template format<ArgFormatter>();
-  return iter;
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::fprintf(cerr, "Don't %s!", "panic");
-  \endrst
- */
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline int fprintf(std::basic_ostream<Char>& os, const S& format_str,
-                   const Args&... args) {
-  using context = basic_printf_context_t<Char>;
-  return vfprintf(os, to_string_view(format_str),
-                  {make_format_args<context>(args...)});
-}
-FMT_END_NAMESPACE
-
-#endif  // FMT_PRINTF_H_
-
-
-// LICENSE_CHANGE_END
-
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-
-#ifndef _WINSOCKAPI_
-#define _WINSOCKAPI_
-#endif
-
-#include <windows.h>
-
-#undef CreateDirectory
-#undef MoveFile
-#undef RemoveDirectory
-
-#endif
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/string_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
-// See the end of this file for a list
-
-/*
- * Copyright (c) 2014-2019 Steven G. Johnson, Jiahao Chen, Peter Colberg, Tony Kelman, Scott P. Jones, and other contributors.
- * Copyright (c) 2009 Public Software Group e. V., Berlin, Germany
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-
-/**
- * @mainpage
- *
- * utf8proc is a free/open-source (MIT/expat licensed) C library
- * providing Unicode normalization, case-folding, and other operations
- * for strings in the UTF-8 encoding, supporting up-to-date Unicode versions.
- * See the utf8proc home page (http://julialang.org/utf8proc/)
- * for downloads and other information, or the source code on github
- * (https://github.com/JuliaLang/utf8proc).
- *
- * For the utf8proc API documentation, see: @ref utf8proc.h
- *
- * The features of utf8proc include:
- *
- * - Transformation of strings (@ref utf8proc_map) to:
- *    - decompose (@ref UTF8PROC_DECOMPOSE) or compose (@ref UTF8PROC_COMPOSE) Unicode combining characters (http://en.wikipedia.org/wiki/Combining_character)
- *    - canonicalize Unicode compatibility characters (@ref UTF8PROC_COMPAT)
- *    - strip "ignorable" (@ref UTF8PROC_IGNORE) characters, control characters (@ref UTF8PROC_STRIPCC), or combining characters such as accents (@ref UTF8PROC_STRIPMARK)
- *    - case-folding (@ref UTF8PROC_CASEFOLD)
- * - Unicode normalization: @ref utf8proc_NFD, @ref utf8proc_NFC, @ref utf8proc_NFKD, @ref utf8proc_NFKC
- * - Detecting grapheme boundaries (@ref utf8proc_grapheme_break and @ref UTF8PROC_CHARBOUND)
- * - Character-width computation: @ref utf8proc_charwidth
- * - Classification of characters by Unicode category: @ref utf8proc_category and @ref utf8proc_category_string
- * - Encode (@ref utf8proc_encode_char) and decode (@ref utf8proc_iterate) Unicode codepoints to/from UTF-8.
- */
-
-/** @file */
-
-#ifndef UTF8PROC_H
-#define UTF8PROC_H
-
-// DuckDB change:
-#define UTF8PROC_STATIC
-
-/** @name API version
- *
- * The utf8proc API version MAJOR.MINOR.PATCH, following
- * semantic-versioning rules (http://semver.org) based on API
- * compatibility.
- *
- * This is also returned at runtime by @ref utf8proc_version; however, the
- * runtime version may append a string like "-dev" to the version number
- * for prerelease versions.
- *
- * @note The shared-library version number in the Makefile
- *       (and CMakeLists.txt, and MANIFEST) may be different,
- *       being based on ABI compatibility rather than API compatibility.
- */
-/** @{ */
-/** The MAJOR version number (increased when backwards API compatibility is broken). */
-#define UTF8PROC_VERSION_MAJOR 2
-/** The MINOR version number (increased when new functionality is added in a backwards-compatible manner). */
-#define UTF8PROC_VERSION_MINOR 4
-/** The PATCH version (increased for fixes that do not change the API). */
-#define UTF8PROC_VERSION_PATCH 0
-/** @} */
-
-#include <stdlib.h>
-
-#if defined(_MSC_VER) && _MSC_VER < 1800
-// MSVC prior to 2013 lacked stdbool.h and inttypes.h
-typedef signed char utf8proc_int8_t;
-typedef unsigned char utf8proc_uint8_t;
-typedef short utf8proc_int16_t;
-typedef unsigned short utf8proc_uint16_t;
-typedef int utf8proc_int32_t;
-typedef unsigned int utf8proc_uint32_t;
-#  ifdef _WIN64
-typedef __int64 utf8proc_ssize_t;
-typedef unsigned __int64 utf8proc_size_t;
-#  else
-typedef int utf8proc_ssize_t;
-typedef unsigned int utf8proc_size_t;
-#  endif
-#  ifndef __cplusplus
-// emulate C99 bool
-typedef unsigned char utf8proc_bool;
-#    ifndef __bool_true_false_are_defined
-#      define false 0
-#      define true 1
-#      define __bool_true_false_are_defined 1
-#    endif
-#  else
-typedef bool utf8proc_bool;
-#  endif
-#else
-#  include <stddef.h>
-#  include <stdbool.h>
-#  include <inttypes.h>
-#endif
-#include <limits.h>
-
-#define UTF8PROC_DLLEXPORT
-// #ifdef UTF8PROC_STATIC
-// #  define UTF8PROC_DLLEXPORT
-// #else
-// #  ifdef _WIN32
-// #    ifdef UTF8PROC_EXPORTS
-// #      define UTF8PROC_DLLEXPORT __declspec(dllexport)
-// #    else
-// #      define UTF8PROC_DLLEXPORT __declspec(dllimport)
-// #    endif
-// #  elif __GNUC__ >= 4
-// #    define UTF8PROC_DLLEXPORT __attribute__ ((visibility("default")))
-// #  else
-// #    define UTF8PROC_DLLEXPORT
-// #  endif
-// #endif
-
-namespace duckdb {
-
-typedef int8_t utf8proc_int8_t;
-typedef uint8_t utf8proc_uint8_t;
-typedef int16_t utf8proc_int16_t;
-typedef uint16_t utf8proc_uint16_t;
-typedef int32_t utf8proc_int32_t;
-typedef uint32_t utf8proc_uint32_t;
-typedef size_t utf8proc_size_t;
-typedef ptrdiff_t utf8proc_ssize_t;
-typedef bool utf8proc_bool;
-
-//#ifdef __cplusplus
-//extern "C" {
-//#endif
-
-/**
- * Option flags used by several functions in the library.
- */
-typedef enum {
-  /** The given UTF-8 input is NULL terminated. */
-  UTF8PROC_NULLTERM  = (1<<0),
-  /** Unicode Versioning Stability has to be respected. */
-  UTF8PROC_STABLE    = (1<<1),
-  /** Compatibility decomposition (i.e. formatting information is lost). */
-  UTF8PROC_COMPAT    = (1<<2),
-  /** Return a result with decomposed characters. */
-  UTF8PROC_COMPOSE   = (1<<3),
-  /** Return a result with decomposed characters. */
-  UTF8PROC_DECOMPOSE = (1<<4),
-  /** Strip "default ignorable characters" such as SOFT-HYPHEN or ZERO-WIDTH-SPACE. */
-  UTF8PROC_IGNORE    = (1<<5),
-  /** Return an error, if the input contains unassigned codepoints. */
-  UTF8PROC_REJECTNA  = (1<<6),
-  /**
-   * Indicating that NLF-sequences (LF, CRLF, CR, NEL) are representing a
-   * line break, and should be converted to the codepoint for line
-   * separation (LS).
-   */
-  UTF8PROC_NLF2LS    = (1<<7),
-  /**
-   * Indicating that NLF-sequences are representing a paragraph break, and
-   * should be converted to the codepoint for paragraph separation
-   * (PS).
-   */
-  UTF8PROC_NLF2PS    = (1<<8),
-  /** Indicating that the meaning of NLF-sequences is unknown. */
-  UTF8PROC_NLF2LF    = (UTF8PROC_NLF2LS | UTF8PROC_NLF2PS),
-  /** Strips and/or convers control characters.
-   *
-   * NLF-sequences are transformed into space, except if one of the
-   * NLF2LS/PS/LF options is given. HorizontalTab (HT) and FormFeed (FF)
-   * are treated as a NLF-sequence in this case.  All other control
-   * characters are simply removed.
-   */
-  UTF8PROC_STRIPCC   = (1<<9),
-  /**
-   * Performs unicode case folding, to be able to do a case-insensitive
-   * string comparison.
-   */
-  UTF8PROC_CASEFOLD  = (1<<10),
-  /**
-   * Inserts 0xFF bytes at the beginning of each sequence which is
-   * representing a single grapheme cluster (see UAX#29).
-   */
-  UTF8PROC_CHARBOUND = (1<<11),
-  /** Lumps certain characters together.
-   *
-   * E.g. HYPHEN U+2010 and MINUS U+2212 to ASCII "-". See lump.md for details.
-   *
-   * If NLF2LF is set, this includes a transformation of paragraph and
-   * line separators to ASCII line-feed (LF).
-   */
-  UTF8PROC_LUMP      = (1<<12),
-  /** Strips all character markings.
-   *
-   * This includes non-spacing, spacing and enclosing (i.e. accents).
-   * @note This option works only with @ref UTF8PROC_COMPOSE or
-   *       @ref UTF8PROC_DECOMPOSE
-   */
-  UTF8PROC_STRIPMARK = (1<<13),
-  /**
-   * Strip unassigned codepoints.
-   */
-  UTF8PROC_STRIPNA    = (1<<14),
-} utf8proc_option_t;
-
-/** @name Error codes
- * Error codes being returned by almost all functions.
- */
-/** @{ */
-/** Memory could not be allocated. */
-#define UTF8PROC_ERROR_NOMEM -1
-/** The given string is too long to be processed. */
-#define UTF8PROC_ERROR_OVERFLOW -2
-/** The given string is not a legal UTF-8 string. */
-#define UTF8PROC_ERROR_INVALIDUTF8 -3
-/** The @ref UTF8PROC_REJECTNA flag was set and an unassigned codepoint was found. */
-#define UTF8PROC_ERROR_NOTASSIGNED -4
-/** Invalid options have been used. */
-#define UTF8PROC_ERROR_INVALIDOPTS -5
-/** @} */
-
-/* @name Types */
-
-/** Holds the value of a property. */
-typedef utf8proc_int16_t utf8proc_propval_t;
-
-/** Struct containing information about a codepoint. */
-typedef struct utf8proc_property_struct {
-  /**
-   * Unicode category.
-   * @see utf8proc_category_t.
-   */
-  utf8proc_propval_t category;
-  utf8proc_propval_t combining_class;
-  /**
-   * Bidirectional class.
-   * @see utf8proc_bidi_class_t.
-   */
-  utf8proc_propval_t bidi_class;
-  /**
-   * @anchor Decomposition type.
-   * @see utf8proc_decomp_type_t.
-   */
-  utf8proc_propval_t decomp_type;
-  utf8proc_uint16_t decomp_seqindex;
-  utf8proc_uint16_t casefold_seqindex;
-  utf8proc_uint16_t uppercase_seqindex;
-  utf8proc_uint16_t lowercase_seqindex;
-  utf8proc_uint16_t titlecase_seqindex;
-  utf8proc_uint16_t comb_index;
-  unsigned bidi_mirrored:1;
-  unsigned comp_exclusion:1;
-  /**
-   * Can this codepoint be ignored?
-   *
-   * Used by @ref utf8proc_decompose_char when @ref UTF8PROC_IGNORE is
-   * passed as an option.
-   */
-  unsigned ignorable:1;
-  unsigned control_boundary:1;
-  /** The width of the codepoint. */
-  unsigned charwidth:2;
-  unsigned pad:2;
-  /**
-   * Boundclass.
-   * @see utf8proc_boundclass_t.
-   */
-  unsigned boundclass:8;
-} utf8proc_property_t;
-
-/** Unicode categories. */
-typedef enum {
-  UTF8PROC_CATEGORY_CN  = 0, /**< Other, not assigned */
-  UTF8PROC_CATEGORY_LU  = 1, /**< Letter, uppercase */
-  UTF8PROC_CATEGORY_LL  = 2, /**< Letter, lowercase */
-  UTF8PROC_CATEGORY_LT  = 3, /**< Letter, titlecase */
-  UTF8PROC_CATEGORY_LM  = 4, /**< Letter, modifier */
-  UTF8PROC_CATEGORY_LO  = 5, /**< Letter, other */
-  UTF8PROC_CATEGORY_MN  = 6, /**< Mark, nonspacing */
-  UTF8PROC_CATEGORY_MC  = 7, /**< Mark, spacing combining */
-  UTF8PROC_CATEGORY_ME  = 8, /**< Mark, enclosing */
-  UTF8PROC_CATEGORY_ND  = 9, /**< Number, decimal digit */
-  UTF8PROC_CATEGORY_NL = 10, /**< Number, letter */
-  UTF8PROC_CATEGORY_NO = 11, /**< Number, other */
-  UTF8PROC_CATEGORY_PC = 12, /**< Punctuation, connector */
-  UTF8PROC_CATEGORY_PD = 13, /**< Punctuation, dash */
-  UTF8PROC_CATEGORY_PS = 14, /**< Punctuation, open */
-  UTF8PROC_CATEGORY_PE = 15, /**< Punctuation, close */
-  UTF8PROC_CATEGORY_PI = 16, /**< Punctuation, initial quote */
-  UTF8PROC_CATEGORY_PF = 17, /**< Punctuation, final quote */
-  UTF8PROC_CATEGORY_PO = 18, /**< Punctuation, other */
-  UTF8PROC_CATEGORY_SM = 19, /**< Symbol, math */
-  UTF8PROC_CATEGORY_SC = 20, /**< Symbol, currency */
-  UTF8PROC_CATEGORY_SK = 21, /**< Symbol, modifier */
-  UTF8PROC_CATEGORY_SO = 22, /**< Symbol, other */
-  UTF8PROC_CATEGORY_ZS = 23, /**< Separator, space */
-  UTF8PROC_CATEGORY_ZL = 24, /**< Separator, line */
-  UTF8PROC_CATEGORY_ZP = 25, /**< Separator, paragraph */
-  UTF8PROC_CATEGORY_CC = 26, /**< Other, control */
-  UTF8PROC_CATEGORY_CF = 27, /**< Other, format */
-  UTF8PROC_CATEGORY_CS = 28, /**< Other, surrogate */
-  UTF8PROC_CATEGORY_CO = 29, /**< Other, private use */
-} utf8proc_category_t;
-
-/** Bidirectional character classes. */
-typedef enum {
-  UTF8PROC_BIDI_CLASS_L     = 1, /**< Left-to-Right */
-  UTF8PROC_BIDI_CLASS_LRE   = 2, /**< Left-to-Right Embedding */
-  UTF8PROC_BIDI_CLASS_LRO   = 3, /**< Left-to-Right Override */
-  UTF8PROC_BIDI_CLASS_R     = 4, /**< Right-to-Left */
-  UTF8PROC_BIDI_CLASS_AL    = 5, /**< Right-to-Left Arabic */
-  UTF8PROC_BIDI_CLASS_RLE   = 6, /**< Right-to-Left Embedding */
-  UTF8PROC_BIDI_CLASS_RLO   = 7, /**< Right-to-Left Override */
-  UTF8PROC_BIDI_CLASS_PDF   = 8, /**< Pop Directional Format */
-  UTF8PROC_BIDI_CLASS_EN    = 9, /**< European Number */
-  UTF8PROC_BIDI_CLASS_ES   = 10, /**< European Separator */
-  UTF8PROC_BIDI_CLASS_ET   = 11, /**< European Number Terminator */
-  UTF8PROC_BIDI_CLASS_AN   = 12, /**< Arabic Number */
-  UTF8PROC_BIDI_CLASS_CS   = 13, /**< Common Number Separator */
-  UTF8PROC_BIDI_CLASS_NSM  = 14, /**< Nonspacing Mark */
-  UTF8PROC_BIDI_CLASS_BN   = 15, /**< Boundary Neutral */
-  UTF8PROC_BIDI_CLASS_B    = 16, /**< Paragraph Separator */
-  UTF8PROC_BIDI_CLASS_S    = 17, /**< Segment Separator */
-  UTF8PROC_BIDI_CLASS_WS   = 18, /**< Whitespace */
-  UTF8PROC_BIDI_CLASS_ON   = 19, /**< Other Neutrals */
-  UTF8PROC_BIDI_CLASS_LRI  = 20, /**< Left-to-Right Isolate */
-  UTF8PROC_BIDI_CLASS_RLI  = 21, /**< Right-to-Left Isolate */
-  UTF8PROC_BIDI_CLASS_FSI  = 22, /**< First Strong Isolate */
-  UTF8PROC_BIDI_CLASS_PDI  = 23, /**< Pop Directional Isolate */
-} utf8proc_bidi_class_t;
-
-/** Decomposition type. */
-typedef enum {
-  UTF8PROC_DECOMP_TYPE_FONT      = 1, /**< Font */
-  UTF8PROC_DECOMP_TYPE_NOBREAK   = 2, /**< Nobreak */
-  UTF8PROC_DECOMP_TYPE_INITIAL   = 3, /**< Initial */
-  UTF8PROC_DECOMP_TYPE_MEDIAL    = 4, /**< Medial */
-  UTF8PROC_DECOMP_TYPE_FINAL     = 5, /**< Final */
-  UTF8PROC_DECOMP_TYPE_ISOLATED  = 6, /**< Isolated */
-  UTF8PROC_DECOMP_TYPE_CIRCLE    = 7, /**< Circle */
-  UTF8PROC_DECOMP_TYPE_SUPER     = 8, /**< Super */
-  UTF8PROC_DECOMP_TYPE_SUB       = 9, /**< Sub */
-  UTF8PROC_DECOMP_TYPE_VERTICAL = 10, /**< Vertical */
-  UTF8PROC_DECOMP_TYPE_WIDE     = 11, /**< Wide */
-  UTF8PROC_DECOMP_TYPE_NARROW   = 12, /**< Narrow */
-  UTF8PROC_DECOMP_TYPE_SMALL    = 13, /**< Small */
-  UTF8PROC_DECOMP_TYPE_SQUARE   = 14, /**< Square */
-  UTF8PROC_DECOMP_TYPE_FRACTION = 15, /**< Fraction */
-  UTF8PROC_DECOMP_TYPE_COMPAT   = 16, /**< Compat */
-} utf8proc_decomp_type_t;
-
-/** Boundclass property. (TR29) */
-typedef enum {
-  UTF8PROC_BOUNDCLASS_START              =  0, /**< Start */
-  UTF8PROC_BOUNDCLASS_OTHER              =  1, /**< Other */
-  UTF8PROC_BOUNDCLASS_CR                 =  2, /**< Cr */
-  UTF8PROC_BOUNDCLASS_LF                 =  3, /**< Lf */
-  UTF8PROC_BOUNDCLASS_CONTROL            =  4, /**< Control */
-  UTF8PROC_BOUNDCLASS_EXTEND             =  5, /**< Extend */
-  UTF8PROC_BOUNDCLASS_L                  =  6, /**< L */
-  UTF8PROC_BOUNDCLASS_V                  =  7, /**< V */
-  UTF8PROC_BOUNDCLASS_T                  =  8, /**< T */
-  UTF8PROC_BOUNDCLASS_LV                 =  9, /**< Lv */
-  UTF8PROC_BOUNDCLASS_LVT                = 10, /**< Lvt */
-  UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR = 11, /**< Regional indicator */
-  UTF8PROC_BOUNDCLASS_SPACINGMARK        = 12, /**< Spacingmark */
-  UTF8PROC_BOUNDCLASS_PREPEND            = 13, /**< Prepend */
-  UTF8PROC_BOUNDCLASS_ZWJ                = 14, /**< Zero Width Joiner */
-
-  /* the following are no longer used in Unicode 11, but we keep
-     the constants here for backward compatibility */
-  UTF8PROC_BOUNDCLASS_E_BASE             = 15, /**< Emoji Base */
-  UTF8PROC_BOUNDCLASS_E_MODIFIER         = 16, /**< Emoji Modifier */
-  UTF8PROC_BOUNDCLASS_GLUE_AFTER_ZWJ     = 17, /**< Glue_After_ZWJ */
-  UTF8PROC_BOUNDCLASS_E_BASE_GAZ         = 18, /**< E_BASE + GLUE_AFTER_ZJW */
-
-  /* the Extended_Pictographic property is used in the Unicode 11
-     grapheme-boundary rules, so we store it in the boundclass field */
-  UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC = 19,
-  UTF8PROC_BOUNDCLASS_E_ZWG = 20, /* UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC + ZWJ */
-} utf8proc_boundclass_t;
-
-/**
- * Function pointer type passed to @ref utf8proc_map_custom and
- * @ref utf8proc_decompose_custom, which is used to specify a user-defined
- * mapping of codepoints to be applied in conjunction with other mappings.
- */
-typedef utf8proc_int32_t (*utf8proc_custom_func)(utf8proc_int32_t codepoint, void *data);
-
-/**
- * Array containing the byte lengths of a UTF-8 encoded codepoint based
- * on the first byte.
- */
-// UTF8PROC_DLLEXPORT extern const utf8proc_int8_t utf8proc_utf8class[256];
-
-/**
- * Returns the utf8proc API version as a string MAJOR.MINOR.PATCH
- * (http://semver.org format), possibly with a "-dev" suffix for
- * development versions.
- */
-UTF8PROC_DLLEXPORT const char *utf8proc_version(void);
-
-/**
- * Returns the utf8proc supported Unicode version as a string MAJOR.MINOR.PATCH.
- */
-UTF8PROC_DLLEXPORT const char *utf8proc_unicode_version(void);
-
-/**
- * Returns an informative error string for the given utf8proc error code
- * (e.g. the error codes returned by @ref utf8proc_map).
- */
-UTF8PROC_DLLEXPORT const char *utf8proc_errmsg(utf8proc_ssize_t errcode);
-
-/**
- * Reads a single codepoint from the UTF-8 sequence being pointed to by `str`.
- * The maximum number of bytes read is `strlen`, unless `strlen` is
- * negative (in which case up to 4 bytes are read).
- *
- * If a valid codepoint could be read, it is stored in the variable
- * pointed to by `codepoint_ref`, otherwise that variable will be set to -1.
- * In case of success, the number of bytes read is returned; otherwise, a
- * negative error code is returned.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_iterate(const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_int32_t *codepoint_ref);
-
-/**
- * Check if a codepoint is valid (regardless of whether it has been
- * assigned a value by the current Unicode standard).
- *
- * @return 1 if the given `codepoint` is valid and otherwise return 0.
- */
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_codepoint_valid(utf8proc_int32_t codepoint);
-
-/**
- * Encodes the codepoint as an UTF-8 string in the byte array pointed
- * to by `dst`. This array must be at least 4 bytes long.
- *
- * In case of success the number of bytes written is returned, and
- * otherwise 0 is returned.
- *
- * This function does not check whether `codepoint` is valid Unicode.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_encode_char(utf8proc_int32_t codepoint, utf8proc_uint8_t *dst);
-
-/**
- * Look up the properties for a given codepoint.
- *
- * @param codepoint The Unicode codepoint.
- *
- * @returns
- * A pointer to a (constant) struct containing information about
- * the codepoint.
- * @par
- * If the codepoint is unassigned or invalid, a pointer to a special struct is
- * returned in which `category` is 0 (@ref UTF8PROC_CATEGORY_CN).
- */
-UTF8PROC_DLLEXPORT const utf8proc_property_t *utf8proc_get_property(utf8proc_int32_t codepoint);
-
-/** Decompose a codepoint into an array of codepoints.
- *
- * @param codepoint the codepoint.
- * @param dst the destination buffer.
- * @param bufsize the size of the destination buffer.
- * @param options one or more of the following flags:
- * - @ref UTF8PROC_REJECTNA  - return an error `codepoint` is unassigned
- * - @ref UTF8PROC_IGNORE    - strip "default ignorable" codepoints
- * - @ref UTF8PROC_CASEFOLD  - apply Unicode casefolding
- * - @ref UTF8PROC_COMPAT    - replace certain codepoints with their
- *                             compatibility decomposition
- * - @ref UTF8PROC_CHARBOUND - insert 0xFF bytes before each grapheme cluster
- * - @ref UTF8PROC_LUMP      - lump certain different codepoints together
- * - @ref UTF8PROC_STRIPMARK - remove all character marks
- * - @ref UTF8PROC_STRIPNA   - remove unassigned codepoints
- * @param last_boundclass
- * Pointer to an integer variable containing
- * the previous codepoint's boundary class if the @ref UTF8PROC_CHARBOUND
- * option is used.  Otherwise, this parameter is ignored.
- *
- * @return
- * In case of success, the number of codepoints written is returned; in case
- * of an error, a negative error code is returned (@ref utf8proc_errmsg).
- * @par
- * If the number of written codepoints would be bigger than `bufsize`, the
- * required buffer size is returned, while the buffer will be overwritten with
- * undefined data.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_char(
-  utf8proc_int32_t codepoint, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize,
-  utf8proc_option_t options, int *last_boundclass
-);
-
-/**
- * The same as @ref utf8proc_decompose_char, but acts on a whole UTF-8
- * string and orders the decomposed sequences correctly.
- *
- * If the @ref UTF8PROC_NULLTERM flag in `options` is set, processing
- * will be stopped, when a NULL byte is encounted, otherwise `strlen`
- * bytes are processed.  The result (in the form of 32-bit unicode
- * codepoints) is written into the buffer being pointed to by
- * `buffer` (which must contain at least `bufsize` entries).  In case of
- * success, the number of codepoints written is returned; in case of an
- * error, a negative error code is returned (@ref utf8proc_errmsg).
- * See @ref utf8proc_decompose_custom to supply additional transformations.
- *
- * If the number of written codepoints would be bigger than `bufsize`, the
- * required buffer size is returned, while the buffer will be overwritten with
- * undefined data.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen,
-  utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options
-);
-
-/**
- * The same as @ref utf8proc_decompose, but also takes a `custom_func` mapping function
- * that is called on each codepoint in `str` before any other transformations
- * (along with a `custom_data` pointer that is passed through to `custom_func`).
- * The `custom_func` argument is ignored if it is `NULL`.  See also @ref utf8proc_map_custom.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen,
-  utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options,
-  utf8proc_custom_func custom_func, void *custom_data
-);
-
-/**
- * Normalizes the sequence of `length` codepoints pointed to by `buffer`
- * in-place (i.e., the result is also stored in `buffer`).
- *
- * @param buffer the (native-endian UTF-32) unicode codepoints to re-encode.
- * @param length the length (in codepoints) of the buffer.
- * @param options a bitwise or (`|`) of one or more of the following flags:
- * - @ref UTF8PROC_NLF2LS  - convert LF, CRLF, CR and NEL into LS
- * - @ref UTF8PROC_NLF2PS  - convert LF, CRLF, CR and NEL into PS
- * - @ref UTF8PROC_NLF2LF  - convert LF, CRLF, CR and NEL into LF
- * - @ref UTF8PROC_STRIPCC - strip or convert all non-affected control characters
- * - @ref UTF8PROC_COMPOSE - try to combine decomposed codepoints into composite
- *                           codepoints
- * - @ref UTF8PROC_STABLE  - prohibit combining characters that would violate
- *                           the unicode versioning stability
- *
- * @return
- * In case of success, the length (in codepoints) of the normalized UTF-32 string is
- * returned; otherwise, a negative error code is returned (@ref utf8proc_errmsg).
- *
- * @warning The entries of the array pointed to by `str` have to be in the
- *          range `0x0000` to `0x10FFFF`. Otherwise, the program might crash!
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_normalize_utf32(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options);
-
-/**
- * Reencodes the sequence of `length` codepoints pointed to by `buffer`
- * UTF-8 data in-place (i.e., the result is also stored in `buffer`).
- * Can optionally normalize the UTF-32 sequence prior to UTF-8 conversion.
- *
- * @param buffer the (native-endian UTF-32) unicode codepoints to re-encode.
- * @param length the length (in codepoints) of the buffer.
- * @param options a bitwise or (`|`) of one or more of the following flags:
- * - @ref UTF8PROC_NLF2LS  - convert LF, CRLF, CR and NEL into LS
- * - @ref UTF8PROC_NLF2PS  - convert LF, CRLF, CR and NEL into PS
- * - @ref UTF8PROC_NLF2LF  - convert LF, CRLF, CR and NEL into LF
- * - @ref UTF8PROC_STRIPCC - strip or convert all non-affected control characters
- * - @ref UTF8PROC_COMPOSE - try to combine decomposed codepoints into composite
- *                           codepoints
- * - @ref UTF8PROC_STABLE  - prohibit combining characters that would violate
- *                           the unicode versioning stability
- * - @ref UTF8PROC_CHARBOUND - insert 0xFF bytes before each grapheme cluster
- *
- * @return
- * In case of success, the length (in bytes) of the resulting nul-terminated
- * UTF-8 string is returned; otherwise, a negative error code is returned
- * (@ref utf8proc_errmsg).
- *
- * @warning The amount of free space pointed to by `buffer` must
- *          exceed the amount of the input data by one byte, and the
- *          entries of the array pointed to by `str` have to be in the
- *          range `0x0000` to `0x10FFFF`. Otherwise, the program might crash!
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_reencode(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options);
-
-/**
- * Given a pair of consecutive codepoints, return whether a grapheme break is
- * permitted between them (as defined by the extended grapheme clusters in UAX#29).
- *
- * @param codepoint1 The first codepoint.
- * @param codepoint2 The second codepoint, occurring consecutively after `codepoint1`.
- * @param state Beginning with Version 29 (Unicode 9.0.0), this algorithm requires
- *              state to break graphemes. This state can be passed in as a pointer
- *              in the `state` argument and should initially be set to 0. If the
- *              state is not passed in (i.e. a null pointer is passed), UAX#29 rules
- *              GB10/12/13 which require this state will not be applied, essentially
- *              matching the rules in Unicode 8.0.0.
- *
- * @warning If the state parameter is used, `utf8proc_grapheme_break_stateful` must
- *          be called IN ORDER on ALL potential breaks in a string.  However, it
- *          is safe to reset the state to zero after a grapheme break.
- */
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break_stateful(
-    utf8proc_int32_t codepoint1, utf8proc_int32_t codepoint2, utf8proc_int32_t *state);
-
-/**
- * Same as @ref utf8proc_grapheme_break_stateful, except without support for the
- * Unicode 9 additions to the algorithm. Supported for legacy reasons.
- */
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break(
-    utf8proc_int32_t codepoint1, utf8proc_int32_t codepoint2);
-
-//! Returns the current UTF8 codepoint in a UTF8 string. Assumes the string is valid UTF8.
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_codepoint(const char *u_input, int &sz);
-UTF8PROC_DLLEXPORT utf8proc_bool grapheme_break_extended(int lbc, int tbc, utf8proc_int32_t *state);
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_codepoint(const char *u_input, int &sz);
-UTF8PROC_DLLEXPORT bool utf8proc_codepoint_to_utf8(int cp, int &sz, char *c);
-UTF8PROC_DLLEXPORT int utf8proc_codepoint_length(int cp);
-UTF8PROC_DLLEXPORT size_t utf8proc_next_grapheme(const char *s, size_t len, size_t cpos);
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_remove_accents(const utf8proc_uint8_t *str, utf8proc_ssize_t len);
-template<class T>
-void utf8proc_grapheme_callback(const char *s, size_t len, T &&fun) {
-	int sz;
-	int boundclass = UTF8PROC_BOUNDCLASS_START;
-	int initial = utf8proc_get_property(utf8proc_codepoint(s, sz))->boundclass;
-	grapheme_break_extended(boundclass, initial, &boundclass);
-	size_t start = 0;
-	size_t cpos = 0;
-	while(true) {
-		cpos += sz;
-		if (cpos >= len) {
-			fun(start, cpos);
-			return;
-		}
-		int next = utf8proc_get_property(utf8proc_codepoint(s + cpos, sz))->boundclass;
-		if (grapheme_break_extended(boundclass, next, &boundclass)) {
-			if (!fun(start, cpos)) {
-				return;
-			}
-			start = cpos;
-		}
-	}
-}
-
-/**
- * Given a codepoint `c`, return the codepoint of the corresponding
- * lower-case character, if any; otherwise (if there is no lower-case
- * variant, or if `c` is not a valid codepoint) return `c`.
- */
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_tolower(utf8proc_int32_t c);
-
-/**
- * Given a codepoint `c`, return the codepoint of the corresponding
- * upper-case character, if any; otherwise (if there is no upper-case
- * variant, or if `c` is not a valid codepoint) return `c`.
- */
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_toupper(utf8proc_int32_t c);
-
-/**
- * Given a codepoint `c`, return the codepoint of the corresponding
- * title-case character, if any; otherwise (if there is no title-case
- * variant, or if `c` is not a valid codepoint) return `c`.
- */
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_totitle(utf8proc_int32_t c);
-
-/**
- * Given a codepoint, return a character width analogous to `wcwidth(codepoint)`,
- * except that a width of 0 is returned for non-printable codepoints
- * instead of -1 as in `wcwidth`.
- *
- * @note
- * If you want to check for particular types of non-printable characters,
- * (analogous to `isprint` or `iscntrl`), use @ref utf8proc_category. */
-    UTF8PROC_DLLEXPORT int utf8proc_charwidth(utf8proc_int32_t codepoint);
-
-/**
- * Return the Unicode category for the codepoint (one of the
- * @ref utf8proc_category_t constants.)
- */
-UTF8PROC_DLLEXPORT utf8proc_category_t utf8proc_category(utf8proc_int32_t codepoint);
-
-/**
- * Return the two-letter (nul-terminated) Unicode category string for
- * the codepoint (e.g. `"Lu"` or `"Co"`).
- */
-UTF8PROC_DLLEXPORT const char *utf8proc_category_string(utf8proc_int32_t codepoint);
-
-/**
- * Maps the given UTF-8 string pointed to by `str` to a new UTF-8
- * string, allocated dynamically by `malloc` and returned via `dstptr`.
- *
- * If the @ref UTF8PROC_NULLTERM flag in the `options` field is set,
- * the length is determined by a NULL terminator, otherwise the
- * parameter `strlen` is evaluated to determine the string length, but
- * in any case the result will be NULL terminated (though it might
- * contain NULL characters with the string if `str` contained NULL
- * characters). Other flags in the `options` field are passed to the
- * functions defined above, and regarded as described.  See also
- * @ref utf8proc_map_custom to supply a custom codepoint transformation.
- *
- * In case of success the length of the new string is returned,
- * otherwise a negative error code is returned.
- *
- * @note The memory of the new UTF-8 string will have been allocated
- * with `malloc`, and should therefore be deallocated with `free`.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options
-);
-
-/**
- * Like @ref utf8proc_map, but also takes a `custom_func` mapping function
- * that is called on each codepoint in `str` before any other transformations
- * (along with a `custom_data` pointer that is passed through to `custom_func`).
- * The `custom_func` argument is ignored if it is `NULL`.
- */
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map_custom(
-  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options,
-  utf8proc_custom_func custom_func, void *custom_data
-);
-
-/** @name Unicode normalization
- *
- * Returns a pointer to newly allocated memory of a NFD, NFC, NFKD, NFKC or
- * NFKC_Casefold normalized version of the null-terminated string `str`.  These
- * are shortcuts to calling @ref utf8proc_map with @ref UTF8PROC_NULLTERM
- * combined with @ref UTF8PROC_STABLE and flags indicating the normalization.
- */
-/** @{ */
-/** NFD normalization (@ref UTF8PROC_DECOMPOSE). */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str, utf8proc_ssize_t len);
-/** NFC normalization (@ref UTF8PROC_COMPOSE). */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str, utf8proc_ssize_t len);
-/** NFKD normalization (@ref UTF8PROC_DECOMPOSE and @ref UTF8PROC_COMPAT). */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str, utf8proc_ssize_t len);
-/** NFKC normalization (@ref UTF8PROC_COMPOSE and @ref UTF8PROC_COMPAT). */
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str, utf8proc_ssize_t len);
-/**
- * NFKC_Casefold normalization (@ref UTF8PROC_COMPOSE and @ref UTF8PROC_COMPAT
- * and @ref UTF8PROC_CASEFOLD and @ref UTF8PROC_IGNORE).
- **/
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8_t *str, utf8proc_ssize_t len);
-/** @} */
-
-//#ifdef __cplusplus
-//}
-//#endif
-}
-#endif
-
-
-// LICENSE_CHANGE_END
-
-
-namespace re2 {
-class RE2;
-}
-
-namespace duckdb {
-
-struct ReverseFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LowerFun {
-	static uint8_t ascii_to_lower_map[];
-
-	//! Returns the length of the result string obtained from lowercasing the given input (in bytes)
-	static idx_t LowerLength(const char *input_data, idx_t input_length);
-	//! Lowercases the string to the target output location, result_data must have space for at least LowerLength bytes
-	static void LowerCase(const char *input_data, idx_t input_length, char *result_data);
-
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct UpperFun {
-	static uint8_t ascii_to_upper_map[];
-
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StripAccentsFun {
-	static bool IsAscii(const char *input, idx_t n);
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ConcatFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ConcatWSFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LengthFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-	template <class TA, class TR>
-	static inline TR Length(TA input) {
-		auto input_data = input.GetDataUnsafe();
-		auto input_length = input.GetSize();
-		for (idx_t i = 0; i < input_length; i++) {
-			if (input_data[i] & 0x80) {
-				int64_t length = 0;
-				// non-ascii character: use grapheme iterator on remainder of string
-				utf8proc_grapheme_callback(input_data, input_length, [&](size_t start, size_t end) {
-					length++;
-					return true;
-				});
-				return length;
-			}
-		}
-		return input_length;
-	}
-};
-
-struct LikeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-	DUCKDB_API static bool Glob(const char *s, idx_t slen, const char *pattern, idx_t plen);
-};
-
-struct LikeEscapeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LpadFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LeftFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MD5Fun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct NFCNormalizeFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RightFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegexpFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SubstringFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-	static string_t SubstringScalarFunction(Vector &result, string_t input, int64_t offset, int64_t length);
-};
-
-struct PrintfFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct InstrFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PrefixFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RepeatFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ReplaceFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RpadFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SuffixFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct TrimFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ContainsFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-	static idx_t Find(const string_t &haystack, const string_t &needle);
-	static idx_t Find(const unsigned char *haystack, idx_t haystack_size, const unsigned char *needle,
-	                  idx_t needle_size);
-};
-
-struct UnicodeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StringSplitFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ASCII {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CHR {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MismatchesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LevenshteinFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct JaccardFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/gzip_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class GZipFileSystem : public CompressedFileSystem {
-	// 32 KB
-	static constexpr const idx_t BUFFER_SIZE = 1 << 15;
-
-public:
-	unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) override;
-
-	std::string GetName() const override {
-		return "GZipFileSystem";
-	}
-
-	//! Verifies that a buffer contains a valid GZIP header
-	static void VerifyGZIPHeader(uint8_t gzip_hdr[], idx_t read_count);
-	//! Consumes a byte stream as a gzip string, returning the decompressed string
-	static string UncompressGZIPString(const string &in);
-
-	unique_ptr<StreamWrapper> CreateStream() override;
-	idx_t InBufferSize() override;
-	idx_t OutBufferSize() override;
-};
-
-static constexpr const uint8_t GZIP_COMPRESSION_DEFLATE = 0x08;
-
-static constexpr const uint8_t GZIP_FLAG_ASCII = 0x1;
-static constexpr const uint8_t GZIP_FLAG_MULTIPART = 0x2;
-static constexpr const uint8_t GZIP_FLAG_EXTRA = 0x4;
-static constexpr const uint8_t GZIP_FLAG_NAME = 0x8;
-static constexpr const uint8_t GZIP_FLAG_COMMENT = 0x10;
-static constexpr const uint8_t GZIP_FLAG_ENCRYPT = 0x20;
-
-static constexpr const uint8_t GZIP_HEADER_MINSIZE = 10;
-
-static constexpr const unsigned char GZIP_FLAG_UNSUPPORTED =
-    GZIP_FLAG_ASCII | GZIP_FLAG_MULTIPART | GZIP_FLAG_EXTRA | GZIP_FLAG_COMMENT | GZIP_FLAG_ENCRYPT;
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
-// See the end of this file for a list
-
-/* miniz.c 2.0.8 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
-   See "unlicense" statement at the end of this file.
-   Rich Geldreich <richgel99@gmail.com>, last updated Oct. 13, 2013
-   Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951: http://www.ietf.org/rfc/rfc1951.txt
-
-   Most API's defined in miniz.c are optional. For example, to disable the archive related functions just define
-   MINIZ_NO_ARCHIVE_APIS, or to get rid of all stdio usage define MINIZ_NO_STDIO (see the list below for more macros).
-
-   * Low-level Deflate/Inflate implementation notes:
-
-     Compression: Use the "tdefl" API's. The compressor supports raw, static, and dynamic blocks, lazy or
-     greedy parsing, match length filtering, RLE-only, and Huffman-only streams. It performs and compresses
-     approximately as well as zlib.
-
-     Decompression: Use the "tinfl" API's. The entire decompressor is implemented as a single function
-     coroutine: see tinfl_decompress(). It supports decompression into a 32KB (or larger power of 2) wrapping buffer, or into a memory
-     block large enough to hold the entire file.
-
-     The low-level tdefl/tinfl API's do not make any use of dynamic memory allocation.
-
-   * zlib-style API notes:
-
-     miniz.c implements a fairly large subset of zlib. There's enough functionality present for it to be a drop-in
-     zlib replacement in many apps:
-        The z_stream struct, optional memory allocation callbacks
-        deflateInit/deflateInit2/deflate/deflateReset/deflateEnd/deflateBound
-        inflateInit/inflateInit2/inflate/inflateEnd
-        compress, compress2, compressBound, uncompress
-        CRC-32, Adler-32 - Using modern, minimal code size, CPU cache friendly routines.
-        Supports raw deflate streams or standard zlib streams with adler-32 checking.
-
-     Limitations:
-      The callback API's are not implemented yet. No support for gzip headers or zlib static dictionaries.
-      I've tried to closely emulate zlib's various flavors of stream flushing and return status codes, but
-      there are no guarantees that miniz.c pulls this off perfectly.
-
-   * PNG writing: See the tdefl_write_image_to_png_file_in_memory() function, originally written by
-     Alex Evans. Supports 1-4 bytes/pixel images.
-
-   * ZIP archive API notes:
-
-     The ZIP archive API's where designed with simplicity and efficiency in mind, with just enough abstraction to
-     get the job done with minimal fuss. There are simple API's to retrieve file information, read files from
-     existing archives, create new archives, append new files to existing archives, or clone archive data from
-     one archive to another. It supports archives located in memory or the heap, on disk (using stdio.h),
-     or you can specify custom file read/write callbacks.
-
-     - Archive reading: Just call this function to read a single file from a disk archive:
-
-      void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name,
-        size_t *pSize, mz_uint zip_flags);
-
-     For more complex cases, use the "mz_zip_reader" functions. Upon opening an archive, the entire central
-     directory is located and read as-is into memory, and subsequent file access only occurs when reading individual files.
-
-     - Archives file scanning: The simple way is to use this function to scan a loaded archive for a specific file:
-
-     int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
-
-     The locate operation can optionally check file comments too, which (as one example) can be used to identify
-     multiple versions of the same file in an archive. This function uses a simple linear search through the central
-     directory, so it's not very fast.
-
-     Alternately, you can iterate through all the files in an archive (using mz_zip_reader_get_num_files()) and
-     retrieve detailed info on each file by calling mz_zip_reader_file_stat().
-
-     - Archive creation: Use the "mz_zip_writer" functions. The ZIP writer immediately writes compressed file data
-     to disk and builds an exact image of the central directory in memory. The central directory image is written
-     all at once at the end of the archive file when the archive is finalized.
-
-     The archive writer can optionally align each file's local header and file data to any power of 2 alignment,
-     which can be useful when the archive will be read from optical media. Also, the writer supports placing
-     arbitrary data blobs at the very beginning of ZIP archives. Archives written using either feature are still
-     readable by any ZIP tool.
-
-     - Archive appending: The simple way to add a single file to an archive is to call this function:
-
-      mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name,
-        const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
-
-     The archive will be created if it doesn't already exist, otherwise it'll be appended to.
-     Note the appending is done in-place and is not an atomic operation, so if something goes wrong
-     during the operation it's possible the archive could be left without a central directory (although the local
-     file headers and file data will be fine, so the archive will be recoverable).
-
-     For more complex archive modification scenarios:
-     1. The safest way is to use a mz_zip_reader to read the existing archive, cloning only those bits you want to
-     preserve into a new archive using using the mz_zip_writer_add_from_zip_reader() function (which compiles the
-     compressed file data as-is). When you're done, delete the old archive and rename the newly written archive, and
-     you're done. This is safe but requires a bunch of temporary disk space or heap memory.
-
-     2. Or, you can convert an mz_zip_reader in-place to an mz_zip_writer using mz_zip_writer_init_from_reader(),
-     append new files as needed, then finalize the archive which will write an updated central directory to the
-     original archive. (This is basically what mz_zip_add_mem_to_archive_file_in_place() does.) There's a
-     possibility that the archive's central directory could be lost with this method if anything goes wrong, though.
-
-     - ZIP archive support limitations:
-     No zip64 or spanning support. Extraction functions can only handle unencrypted, stored or deflated files.
-     Requires streams capable of seeking.
-
-   * This is a header file library, like stb_image.c. To get only a header file, either cut and paste the
-     below header, or create miniz.h, #define MINIZ_HEADER_FILE_ONLY, and then include miniz.c from it.
-
-   * Important: For best perf. be sure to customize the below macros for your target platform:
-     #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
-     #define MINIZ_LITTLE_ENDIAN 1
-     #define MINIZ_HAS_64BIT_REGISTERS 1
-
-   * On platforms using glibc, Be sure to "#define _LARGEFILE64_SOURCE 1" before including miniz.c to ensure miniz
-     uses the 64-bit variants: fopen64(), stat64(), etc. Otherwise you won't be able to process large files
-     (i.e. 32-bit stat() fails for me on files > 0x7FFFFFFF bytes).
-*/
-
-
-
-
-
-/* Defines to completely disable specific portions of miniz.c:
-   If all macros here are defined the only functionality remaining will be CRC-32, adler-32, tinfl, and tdefl. */
-
-/* Define MINIZ_NO_STDIO to disable all usage and any functions which rely on stdio for file I/O. */
-#define MINIZ_NO_STDIO
-
-/* If MINIZ_NO_TIME is specified then the ZIP archive functions will not be able to get the current time, or */
-/* get/set file times, and the C run-time funcs that get/set times won't be called. */
-/* The current downside is the times written to your archives will be from 1979. */
-#define MINIZ_NO_TIME
-
-/* Define MINIZ_NO_ARCHIVE_APIS to disable all ZIP archive API's. */
-/* #define MINIZ_NO_ARCHIVE_APIS */
-
-/* Define MINIZ_NO_ARCHIVE_WRITING_APIS to disable all writing related ZIP archive API's. */
-/* #define MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-/* Define MINIZ_NO_ZLIB_APIS to remove all ZLIB-style compression/decompression API's. */
-/*#define MINIZ_NO_ZLIB_APIS */
-
-/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAME to disable zlib names, to prevent conflicts against stock zlib. */
-#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES
-
-/* Define MINIZ_NO_MALLOC to disable all calls to malloc, free, and realloc.
-   Note if MINIZ_NO_MALLOC is defined then the user must always provide custom user alloc/free/realloc
-   callbacks to the zlib and archive API's, and a few stand-alone helper API's which don't provide custom user
-   functions (such as tdefl_compress_mem_to_heap() and tinfl_decompress_mem_to_heap()) won't work. */
-/*#define MINIZ_NO_MALLOC */
-
-#if defined(__TINYC__) && (defined(__linux) || defined(__linux__))
-/* TODO: Work around "error: include file 'sys\utime.h' when compiling with tcc on Linux */
-#define MINIZ_NO_TIME
-#endif
-
-#include <stddef.h>
-
-
-
-#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_ARCHIVE_APIS)
-#include <time.h>
-#endif
-
-#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__i386) || defined(__i486__) || defined(__i486) || defined(i386) || defined(__ia64__) || defined(__x86_64__)
-/* MINIZ_X86_OR_X64_CPU is only used to help set the below macros. */
-#define MINIZ_X86_OR_X64_CPU 1
-#else
-#define MINIZ_X86_OR_X64_CPU 0
-#endif
-
-#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU
-/* Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian. */
-#define MINIZ_LITTLE_ENDIAN 1
-#else
-#define MINIZ_LITTLE_ENDIAN 0
-#endif
-
-#if MINIZ_X86_OR_X64_CPU
-/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses. */
-#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0 // always 0 because alignment
-#else
-#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
-#endif
-
-#if defined(_M_X64) || defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__) || defined(__ia64__) || defined(__x86_64__)
-/* Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are reasonably fast (and don't involve compiler generated calls to helper functions). */
-#define MINIZ_HAS_64BIT_REGISTERS 1
-#else
-#define MINIZ_HAS_64BIT_REGISTERS 0
-#endif
-
-namespace duckdb_miniz {
-
-/* ------------------- zlib-style API Definitions. */
-
-/* For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits! */
-typedef unsigned long mz_ulong;
-
-/* mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap. */
-void mz_free(void *p);
-
-#define MZ_ADLER32_INIT (1)
-/* mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL. */
-mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);
-
-#define MZ_CRC32_INIT (0)
-/* mz_crc32() returns the initial CRC-32 value to use when called with ptr==NULL. */
-mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);
-
-/* Compression strategies. */
-enum { MZ_DEFAULT_STRATEGY = 0, MZ_FILTERED = 1, MZ_HUFFMAN_ONLY = 2, MZ_RLE = 3, MZ_FIXED = 4 };
-
-/* Method */
-#define MZ_DEFLATED 8
-
-/* Heap allocation callbacks.
-Note that mz_alloc_func parameter types purpsosely differ from zlib's: items/size is size_t, not unsigned long. */
-typedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size);
-typedef void (*mz_free_func)(void *opaque, void *address);
-typedef void *(*mz_realloc_func)(void *opaque, void *address, size_t items, size_t size);
-
-/* Compression levels: 0-9 are the standard zlib-style levels, 10 is best possible compression (not zlib compatible, and may be very slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL. */
-enum {
-	MZ_NO_COMPRESSION = 0,
-	MZ_BEST_SPEED = 1,
-	MZ_BEST_COMPRESSION = 9,
-	MZ_UBER_COMPRESSION = 10,
-	MZ_DEFAULT_LEVEL = 6,
-	MZ_DEFAULT_COMPRESSION = -1
-};
-
-#define MZ_VERSION "10.0.3"
-#define MZ_VERNUM 0xA030
-#define MZ_VER_MAJOR 10
-#define MZ_VER_MINOR 0
-#define MZ_VER_REVISION 3
-#define MZ_VER_SUBREVISION 0
-
-#ifndef MINIZ_NO_ZLIB_APIS
-
-/* Flush values. For typical usage you only need MZ_NO_FLUSH and MZ_FINISH. The other values are for advanced use (refer to the zlib docs). */
-enum { MZ_NO_FLUSH = 0, MZ_PARTIAL_FLUSH = 1, MZ_SYNC_FLUSH = 2, MZ_FULL_FLUSH = 3, MZ_FINISH = 4, MZ_BLOCK = 5 };
-
-/* Return status codes. MZ_PARAM_ERROR is non-standard. */
-enum {
-	MZ_OK = 0,
-	MZ_STREAM_END = 1,
-	MZ_NEED_DICT = 2,
-	MZ_ERRNO = -1,
-	MZ_STREAM_ERROR = -2,
-	MZ_DATA_ERROR = -3,
-	MZ_MEM_ERROR = -4,
-	MZ_BUF_ERROR = -5,
-	MZ_VERSION_ERROR = -6,
-	MZ_PARAM_ERROR = -10000
-};
-
-/* Window bits */
-#define MZ_DEFAULT_WINDOW_BITS 15
-
-struct mz_internal_state;
-
-/* Compression/decompression stream struct. */
-typedef struct mz_stream_s {
-	const unsigned char *next_in; /* pointer to next byte to read */
-	unsigned int avail_in;        /* number of bytes available at next_in */
-	mz_ulong total_in;            /* total number of bytes consumed so far */
-
-	unsigned char *next_out; /* pointer to next byte to write */
-	unsigned int avail_out;  /* number of bytes that can be written to next_out */
-	mz_ulong total_out;      /* total number of bytes produced so far */
-
-	char *msg;                       /* error msg (unused) */
-	struct mz_internal_state *state; /* internal state, allocated by zalloc/zfree */
-
-	mz_alloc_func zalloc; /* optional heap allocation function (defaults to malloc) */
-	mz_free_func zfree;   /* optional heap free function (defaults to free) */
-	void *opaque;         /* heap alloc function user pointer */
-
-	int data_type;     /* data_type (unused) */
-	mz_ulong adler;    /* adler32 of the source or uncompressed data */
-	mz_ulong reserved; /* not used */
-} mz_stream;
-
-typedef mz_stream *mz_streamp;
-
-/* Returns the version string of miniz.c. */
-const char *mz_version(void);
-
-/* mz_deflateInit() initializes a compressor with default options: */
-/* Parameters: */
-/*  pStream must point to an initialized mz_stream struct. */
-/*  level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION]. */
-/*  level 1 enables a specially optimized compression function that's been optimized purely for performance, not ratio.
- */
-/*  (This special func. is currently only enabled when MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.) */
-/* Return values: */
-/*  MZ_OK on success. */
-/*  MZ_STREAM_ERROR if the stream is bogus. */
-/*  MZ_PARAM_ERROR if the input parameters are bogus. */
-/*  MZ_MEM_ERROR on out of memory. */
-int mz_deflateInit(mz_streamp pStream, int level);
-
-/* mz_deflateInit2() is like mz_deflate(), except with more control: */
-/* Additional parameters: */
-/*   method must be MZ_DEFLATED */
-/*   window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer) */
-/*   mem_level must be between [1, 9] (it's checked but ignored by miniz.c) */
-int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
-
-/* Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2(). */
-int mz_deflateReset(mz_streamp pStream);
-
-/* mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible.
- */
-/* Parameters: */
-/*   pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members. */
-/*   flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or MZ_FINISH. */
-/* Return values: */
-/*   MZ_OK on success (when flushing, or if more input is needed but not available, and/or there's more output to be written but the output buffer is full). */
-/*   MZ_STREAM_END if all input has been consumed and all output bytes have been written. Don't call mz_deflate() on the stream anymore. */
-/*   MZ_STREAM_ERROR if the stream is bogus. */
-/*   MZ_PARAM_ERROR if one of the parameters is invalid. */
-/*   MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.) */
-int mz_deflate(mz_streamp pStream, int flush);
-
-/* mz_deflateEnd() deinitializes a compressor: */
-/* Return values: */
-/*  MZ_OK on success. */
-/*  MZ_STREAM_ERROR if the stream is bogus. */
-int mz_deflateEnd(mz_streamp pStream);
-
-/* mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH. */
-mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);
-
-/* Single-call compression functions mz_compress() and mz_compress2(): */
-/* Returns MZ_OK on success, or one of the error codes from mz_deflate() on failure. */
-int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
-int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len,
-                 int level);
-
-/* mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress(). */
-mz_ulong mz_compressBound(mz_ulong source_len);
-
-/* Initializes a decompressor. */
-int mz_inflateInit(mz_streamp pStream);
-
-/* mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer: */
-/* window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate). */
-int mz_inflateInit2(mz_streamp pStream, int window_bits);
-
-/* Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible. */
-/* Parameters: */
-/*   pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members. */
-/*   flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH. */
-/*   On the first call, if flush is MZ_FINISH it's assumed the input and output buffers are both sized large enough to decompress the entire stream in a single call (this is slightly faster). */
-/*   MZ_FINISH implies that there are no more source bytes available beside what's already in the input buffer, and that the output buffer is large enough to hold the rest of the decompressed data. */
-/* Return values: */
-/*   MZ_OK on success. Either more input is needed but not available, and/or there's more output to be written but the output buffer is full. */
-/*   MZ_STREAM_END if all needed input has been consumed and all output bytes have been written. For zlib streams, the adler-32 of the decompressed data has also been verified. */
-/*   MZ_STREAM_ERROR if the stream is bogus. */
-/*   MZ_DATA_ERROR if the deflate stream is invalid. */
-/*   MZ_PARAM_ERROR if one of the parameters is invalid. */
-/*   MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again */
-/*   with more input data, or with more room in the output buffer (except when using single call decompression, described above). */
-int mz_inflate(mz_streamp pStream, int flush);
-
-/* Deinitializes a decompressor. */
-int mz_inflateEnd(mz_streamp pStream);
-
-/* Single-call decompression. */
-/* Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure. */
-int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
-
-/* Returns a string description of the specified error code, or NULL if the error code is invalid. */
-const char *mz_error(int err);
-
-/* Redefine zlib-compatible names to miniz equivalents, so miniz.c can be used as a drop-in replacement for the subset of zlib that miniz.c supports. */
-/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAMES to disable zlib-compatibility if you use zlib in the same project. */
-#ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES
-typedef unsigned char Byte;
-typedef unsigned int uInt;
-typedef mz_ulong uLong;
-typedef Byte Bytef;
-typedef uInt uIntf;
-typedef char charf;
-typedef int intf;
-typedef void *voidpf;
-typedef uLong uLongf;
-typedef void *voidp;
-typedef void *const voidpc;
-#define Z_NULL 0
-#define Z_NO_FLUSH MZ_NO_FLUSH
-#define Z_PARTIAL_FLUSH MZ_PARTIAL_FLUSH
-#define Z_SYNC_FLUSH MZ_SYNC_FLUSH
-#define Z_FULL_FLUSH MZ_FULL_FLUSH
-#define Z_FINISH MZ_FINISH
-#define Z_BLOCK MZ_BLOCK
-#define Z_OK MZ_OK
-#define Z_STREAM_END MZ_STREAM_END
-#define Z_NEED_DICT MZ_NEED_DICT
-#define Z_ERRNO MZ_ERRNO
-#define Z_STREAM_ERROR MZ_STREAM_ERROR
-#define Z_DATA_ERROR MZ_DATA_ERROR
-#define Z_MEM_ERROR MZ_MEM_ERROR
-#define Z_BUF_ERROR MZ_BUF_ERROR
-#define Z_VERSION_ERROR MZ_VERSION_ERROR
-#define Z_PARAM_ERROR MZ_PARAM_ERROR
-#define Z_NO_COMPRESSION MZ_NO_COMPRESSION
-#define Z_BEST_SPEED MZ_BEST_SPEED
-#define Z_BEST_COMPRESSION MZ_BEST_COMPRESSION
-#define Z_DEFAULT_COMPRESSION MZ_DEFAULT_COMPRESSION
-#define Z_DEFAULT_STRATEGY MZ_DEFAULT_STRATEGY
-#define Z_FILTERED MZ_FILTERED
-#define Z_HUFFMAN_ONLY MZ_HUFFMAN_ONLY
-#define Z_RLE MZ_RLE
-#define Z_FIXED MZ_FIXED
-#define Z_DEFLATED MZ_DEFLATED
-#define Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS
-#define alloc_func mz_alloc_func
-#define free_func mz_free_func
-#define internal_state mz_internal_state
-#define z_stream mz_stream
-#define deflateInit mz_deflateInit
-#define deflateInit2 mz_deflateInit2
-#define deflateReset mz_deflateReset
-#define deflate mz_deflate
-#define deflateEnd mz_deflateEnd
-#define deflateBound mz_deflateBound
-#define compress mz_compress
-#define compress2 mz_compress2
-#define compressBound mz_compressBound
-#define inflateInit mz_inflateInit
-#define inflateInit2 mz_inflateInit2
-#define inflate mz_inflate
-#define inflateEnd mz_inflateEnd
-#define uncompress mz_uncompress
-#define crc32 mz_crc32
-#define adler32 mz_adler32
-#define MAX_WBITS 15
-#define MAX_MEM_LEVEL 9
-#define zError mz_error
-#define ZLIB_VERSION MZ_VERSION
-#define ZLIB_VERNUM MZ_VERNUM
-#define ZLIB_VER_MAJOR MZ_VER_MAJOR
-#define ZLIB_VER_MINOR MZ_VER_MINOR
-#define ZLIB_VER_REVISION MZ_VER_REVISION
-#define ZLIB_VER_SUBREVISION MZ_VER_SUBREVISION
-#define zlibVersion mz_version
-#define zlib_version mz_version()
-#endif /* #ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES */
-
-#endif /* MINIZ_NO_ZLIB_APIS */
-
-}
-
-
-#include <assert.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-namespace duckdb_miniz {
-
-/* ------------------- Types and macros */
-typedef unsigned char mz_uint8;
-typedef signed short mz_int16;
-typedef unsigned short mz_uint16;
-typedef unsigned int mz_uint32;
-typedef unsigned int mz_uint;
-typedef int64_t mz_int64;
-typedef uint64_t mz_uint64;
-typedef int mz_bool;
-
-#define MZ_FALSE (0)
-#define MZ_TRUE (1)
-
-/* Works around MSVC's spammy "warning C4127: conditional expression is constant" message. */
-#ifdef _MSC_VER
-#define MZ_MACRO_END while (0, 0)
-#else
-#define MZ_MACRO_END while (0)
-#endif
-
-#ifdef MINIZ_NO_STDIO
-#define MZ_FILE void *
-#else
-#include <stdio.h>
-#define MZ_FILE FILE
-#endif /* #ifdef MINIZ_NO_STDIO */
-
-#ifdef MINIZ_NO_TIME
-typedef struct mz_dummy_time_t_tag
-{
-    int m_dummy;
-} mz_dummy_time_t;
-#define MZ_TIME_T mz_dummy_time_t
-#else
-#define MZ_TIME_T time_t
-#endif
-
-#define MZ_ASSERT(x) assert(x)
-
-#ifdef MINIZ_NO_MALLOC
-#define MZ_MALLOC(x) NULL
-#define MZ_FREE(x) (void)x, ((void)0)
-#define MZ_REALLOC(p, x) NULL
-#else
-#define MZ_MALLOC(x) malloc(x)
-#define MZ_FREE(x) free(x)
-#define MZ_REALLOC(p, x) realloc(p, x)
-#endif
-
-#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
-#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
-#define MZ_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj))
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
-#define MZ_READ_LE16(p) *((const mz_uint16 *)(p))
-#define MZ_READ_LE32(p) *((const mz_uint32 *)(p))
-#else
-#define MZ_READ_LE16(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
-#define MZ_READ_LE32(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
-#endif
-
-#define MZ_READ_LE64(p) (((mz_uint64)MZ_READ_LE32(p)) | (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) << 32U))
-
-#ifdef _MSC_VER
-#define MZ_FORCEINLINE __forceinline
-#elif defined(__GNUC__)
-#define MZ_FORCEINLINE __inline__ __attribute__((__always_inline__))
-#else
-#define MZ_FORCEINLINE inline
-#endif
-
-extern void *miniz_def_alloc_func(void *opaque, size_t items, size_t size);
-extern void miniz_def_free_func(void *opaque, void *address);
-extern void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size);
-
-#define MZ_UINT16_MAX (0xFFFFU)
-#define MZ_UINT32_MAX (0xFFFFFFFFU)
-
-
-
-
-
-/* ------------------- Low-level Compression API Definitions */
-
-/* Set TDEFL_LESS_MEMORY to 1 to use less memory (compression will be slightly slower, and raw/dynamic blocks will be output more frequently). */
-#define TDEFL_LESS_MEMORY 0
-
-/* tdefl_init() compression flags logically OR'd together (low 12 bits contain the max. number of probes per dictionary search): */
-/* TDEFL_DEFAULT_MAX_PROBES: The compressor defaults to 128 dictionary probes per dictionary search. 0=Huffman only, 1=Huffman+LZ (fastest/crap compression), 4095=Huffman+LZ (slowest/best compression). */
-enum
-{
-    TDEFL_HUFFMAN_ONLY = 0,
-    TDEFL_DEFAULT_MAX_PROBES = 128,
-    TDEFL_MAX_PROBES_MASK = 0xFFF
-};
-
-/* TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before the deflate data, and the Adler-32 of the source data at the end. Otherwise, you'll get raw deflate data. */
-/* TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even when not writing zlib headers). */
-/* TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more efficient lazy parsing. */
-/* TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's initialization time to the minimum, but the output may vary from run to run given the same input (depending on the contents of memory). */
-/* TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1) */
-/* TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled. */
-/* TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables. */
-/* TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks. */
-/* The low 12 bits are reserved to control the max # of hash probes per dictionary lookup (see TDEFL_MAX_PROBES_MASK). */
-enum
-{
-    TDEFL_WRITE_ZLIB_HEADER = 0x01000,
-    TDEFL_COMPUTE_ADLER32 = 0x02000,
-    TDEFL_GREEDY_PARSING_FLAG = 0x04000,
-    TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000,
-    TDEFL_RLE_MATCHES = 0x10000,
-    TDEFL_FILTER_MATCHES = 0x20000,
-    TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000,
-    TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000
-};
-
-/* High level compression functions: */
-/* tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc(). */
-/* On entry: */
-/*  pSrc_buf, src_buf_len: Pointer and size of source block to compress. */
-/*  flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression. */
-/* On return: */
-/*  Function returns a pointer to the compressed data, or NULL on failure. */
-/*  *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data. */
-/*  The caller must free() the returned block when it's no longer needed. */
-void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
-
-/* tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory. */
-/* Returns 0 on failure. */
-size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
-
-/* Compresses an image to a compressed PNG file in memory. */
-/* On entry: */
-/*  pImage, w, h, and num_chans describe the image to compress. num_chans may be 1, 2, 3, or 4. */
-/*  The image pitch in bytes per scanline will be w*num_chans. The leftmost pixel on the top scanline is stored first in memory. */
-/*  level may range from [0,10], use MZ_NO_COMPRESSION, MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc. or a decent default is MZ_DEFAULT_LEVEL */
-/*  If flip is true, the image will be flipped on the Y axis (useful for OpenGL apps). */
-/* On return: */
-/*  Function returns a pointer to the compressed data, or NULL on failure. */
-/*  *pLen_out will be set to the size of the PNG image file. */
-/*  The caller must mz_free() the returned heap block (which will typically be larger than *pLen_out) when it's no longer needed. */
-void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip);
-void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out);
-
-/* Output stream interface. The compressor uses this interface to write compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time. */
-typedef mz_bool (*tdefl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);
-
-/* tdefl_compress_mem_to_output() compresses a block to an output stream. The above helpers use this function internally. */
-mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
-
-enum
-{
-    TDEFL_MAX_HUFF_TABLES = 3,
-    TDEFL_MAX_HUFF_SYMBOLS_0 = 288,
-    TDEFL_MAX_HUFF_SYMBOLS_1 = 32,
-    TDEFL_MAX_HUFF_SYMBOLS_2 = 19,
-    TDEFL_LZ_DICT_SIZE = 32768,
-    TDEFL_LZ_DICT_SIZE_MASK = TDEFL_LZ_DICT_SIZE - 1,
-    TDEFL_MIN_MATCH_LEN = 3,
-    TDEFL_MAX_MATCH_LEN = 258
-};
-
-/* TDEFL_OUT_BUF_SIZE MUST be large enough to hold a single entire compressed output block (using static/fixed Huffman codes). */
-#if TDEFL_LESS_MEMORY
-enum
-{
-    TDEFL_LZ_CODE_BUF_SIZE = 24 * 1024,
-    TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13) / 10,
-    TDEFL_MAX_HUFF_SYMBOLS = 288,
-    TDEFL_LZ_HASH_BITS = 12,
-    TDEFL_LEVEL1_HASH_SIZE_MASK = 4095,
-    TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3,
-    TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS
-};
-#else
-enum
-{
-    TDEFL_LZ_CODE_BUF_SIZE = 64 * 1024,
-    TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13) / 10,
-    TDEFL_MAX_HUFF_SYMBOLS = 288,
-    TDEFL_LZ_HASH_BITS = 15,
-    TDEFL_LEVEL1_HASH_SIZE_MASK = 4095,
-    TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3,
-    TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS
-};
-#endif
-
-/* The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions. */
-typedef enum {
-    TDEFL_STATUS_BAD_PARAM = -2,
-    TDEFL_STATUS_PUT_BUF_FAILED = -1,
-    TDEFL_STATUS_OKAY = 0,
-    TDEFL_STATUS_DONE = 1
-} tdefl_status;
-
-/* Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums */
-typedef enum {
-    TDEFL_NO_FLUSH = 0,
-    TDEFL_SYNC_FLUSH = 2,
-    TDEFL_FULL_FLUSH = 3,
-    TDEFL_FINISH = 4
-} tdefl_flush;
-
-/* tdefl's compression state structure. */
-typedef struct
-{
-    tdefl_put_buf_func_ptr m_pPut_buf_func;
-    void *m_pPut_buf_user;
-    mz_uint m_flags, m_max_probes[2];
-    int m_greedy_parsing;
-    mz_uint m_adler32, m_lookahead_pos, m_lookahead_size, m_dict_size;
-    mz_uint8 *m_pLZ_code_buf, *m_pLZ_flags, *m_pOutput_buf, *m_pOutput_buf_end;
-    mz_uint m_num_flags_left, m_total_lz_bytes, m_lz_code_buf_dict_pos, m_bits_in, m_bit_buffer;
-    mz_uint m_saved_match_dist, m_saved_match_len, m_saved_lit, m_output_flush_ofs, m_output_flush_remaining, m_finished, m_block_index, m_wants_to_finish;
-    tdefl_status m_prev_return_status;
-    const void *m_pIn_buf;
-    void *m_pOut_buf;
-    size_t *m_pIn_buf_size, *m_pOut_buf_size;
-    tdefl_flush m_flush;
-    const mz_uint8 *m_pSrc;
-    size_t m_src_buf_left, m_out_buf_ofs;
-    mz_uint8 m_dict[TDEFL_LZ_DICT_SIZE + TDEFL_MAX_MATCH_LEN - 1];
-    mz_uint16 m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
-    mz_uint16 m_huff_codes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
-    mz_uint8 m_huff_code_sizes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS];
-    mz_uint8 m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE];
-    mz_uint16 m_next[TDEFL_LZ_DICT_SIZE];
-    mz_uint16 m_hash[TDEFL_LZ_HASH_SIZE];
-    mz_uint8 m_output_buf[TDEFL_OUT_BUF_SIZE];
-} tdefl_compressor;
-
-/* Initializes the compressor. */
-/* There is no corresponding deinit() function because the tdefl API's do not dynamically allocate memory. */
-/* pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression. */
-/* If pBut_buf_func is NULL the user should always call the tdefl_compress() API. */
-/* flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.) */
-tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
-
-/* Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible. */
-tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);
-
-/* tdefl_compress_buffer() is only usable when the tdefl_init() is called with a non-NULL tdefl_put_buf_func_ptr. */
-/* tdefl_compress_buffer() always consumes the entire input buffer. */
-tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);
-
-tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d);
-mz_uint32 tdefl_get_adler32(tdefl_compressor *d);
-
-/* Create tdefl_compress() flags given zlib-style compression parameters. */
-/* level may range from [0,10] (where 10 is absolute max compression, but may be much slower on some files) */
-/* window_bits may be -15 (raw deflate) or 15 (zlib) */
-/* strategy may be either MZ_DEFAULT_STRATEGY, MZ_FILTERED, MZ_HUFFMAN_ONLY, MZ_RLE, or MZ_FIXED */
-mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy);
-
-/* Allocate the tdefl_compressor structure in C so that */
-/* non-C language bindings to tdefl_ API don't need to worry about */
-/* structure size and allocation mechanism. */
-tdefl_compressor *tdefl_compressor_alloc();
-void tdefl_compressor_free(tdefl_compressor *pComp);
-
-
-
-
-/* ------------------- Low-level Decompression API Definitions */
-
-
-/* Decompression flags used by tinfl_decompress(). */
-/* TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the input is a raw deflate stream. */
-/* TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available beyond the end of the supplied input buffer. If clear, the input buffer contains all remaining input. */
-/* TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large enough to hold the entire decompressed stream. If clear, the output buffer is at least the size of the dictionary (typically 32KB). */
-/* TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the decompressed bytes. */
-enum
-{
-    TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
-    TINFL_FLAG_HAS_MORE_INPUT = 2,
-    TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
-    TINFL_FLAG_COMPUTE_ADLER32 = 8
-};
-
-/* High level decompression functions: */
-/* tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc(). */
-/* On entry: */
-/*  pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress. */
-/* On return: */
-/*  Function returns a pointer to the decompressed data, or NULL on failure. */
-/*  *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data. */
-/*  The caller must call mz_free() on the returned block when it's no longer needed. */
-void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
-
-/* tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory. */
-/* Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success. */
-#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))
-size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
-
-/* tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer. */
-/* Returns 1 on success or 0 on failure. */
-typedef int (*tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);
-int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
-
-struct tinfl_decompressor_tag;
-typedef struct tinfl_decompressor_tag tinfl_decompressor;
-
-/* Allocate the tinfl_decompressor structure in C so that */
-/* non-C language bindings to tinfl_ API don't need to worry about */
-/* structure size and allocation mechanism. */
-
-tinfl_decompressor *tinfl_decompressor_alloc();
-void tinfl_decompressor_free(tinfl_decompressor *pDecomp);
-
-/* Max size of LZ dictionary. */
-#define TINFL_LZ_DICT_SIZE 32768
-
-/* Return status. */
-typedef enum {
-    /* This flags indicates the inflator needs 1 or more input bytes to make forward progress, but the caller is indicating that no more are available. The compressed data */
-    /* is probably corrupted. If you call the inflator again with more bytes it'll try to continue processing the input but this is a BAD sign (either the data is corrupted or you called it incorrectly). */
-    /* If you call it again with no input you'll just get TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS again. */
-    TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS = -4,
-
-    /* This flag indicates that one or more of the input parameters was obviously bogus. (You can try calling it again, but if you get this error the calling code is wrong.) */
-    TINFL_STATUS_BAD_PARAM = -3,
-
-    /* This flags indicate the inflator is finished but the adler32 check of the uncompressed data didn't match. If you call it again it'll return TINFL_STATUS_DONE. */
-    TINFL_STATUS_ADLER32_MISMATCH = -2,
-
-    /* This flags indicate the inflator has somehow failed (bad code, corrupted input, etc.). If you call it again without resetting via tinfl_init() it it'll just keep on returning the same status failure code. */
-    TINFL_STATUS_FAILED = -1,
-
-    /* Any status code less than TINFL_STATUS_DONE must indicate a failure. */
-
-    /* This flag indicates the inflator has returned every byte of uncompressed data that it can, has consumed every byte that it needed, has successfully reached the end of the deflate stream, and */
-    /* if zlib headers and adler32 checking enabled that it has successfully checked the uncompressed data's adler32. If you call it again you'll just get TINFL_STATUS_DONE over and over again. */
-    TINFL_STATUS_DONE = 0,
-
-    /* This flag indicates the inflator MUST have more input data (even 1 byte) before it can make any more forward progress, or you need to clear the TINFL_FLAG_HAS_MORE_INPUT */
-    /* flag on the next call if you don't have any more source data. If the source data was somehow corrupted it's also possible (but unlikely) for the inflator to keep on demanding input to */
-    /* proceed, so be sure to properly set the TINFL_FLAG_HAS_MORE_INPUT flag. */
-    TINFL_STATUS_NEEDS_MORE_INPUT = 1,
-
-    /* This flag indicates the inflator definitely has 1 or more bytes of uncompressed data available, but it cannot write this data into the output buffer. */
-    /* Note if the source compressed data was corrupted it's possible for the inflator to return a lot of uncompressed data to the caller. I've been assuming you know how much uncompressed data to expect */
-    /* (either exact or worst case) and will stop calling the inflator and fail after receiving too much. In pure streaming scenarios where you have no idea how many bytes to expect this may not be possible */
-    /* so I may need to add some code to address this. */
-    TINFL_STATUS_HAS_MORE_OUTPUT = 2
-} tinfl_status;
-
-/* Initializes the decompressor to its initial state. */
-#define tinfl_init(r)     \
-    do                    \
-    {                     \
-        (r)->m_state = 0; \
-    }                     \
-    MZ_MACRO_END
-#define tinfl_get_adler32(r) (r)->m_check_adler32
-
-/* Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability. */
-/* This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output. */
-tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);
-
-/* Internal/private bits follow. */
-enum
-{
-    TINFL_MAX_HUFF_TABLES = 3,
-    TINFL_MAX_HUFF_SYMBOLS_0 = 288,
-    TINFL_MAX_HUFF_SYMBOLS_1 = 32,
-    TINFL_MAX_HUFF_SYMBOLS_2 = 19,
-    TINFL_FAST_LOOKUP_BITS = 10,
-    TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS
-};
-
-typedef struct
-{
-    mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0];
-    mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
-} tinfl_huff_table;
-
-#if MINIZ_HAS_64BIT_REGISTERS
-#define TINFL_USE_64BIT_BITBUF 1
-#else
-#define TINFL_USE_64BIT_BITBUF 0
-#endif
-
-#if TINFL_USE_64BIT_BITBUF
-typedef mz_uint64 tinfl_bit_buf_t;
-#define TINFL_BITBUF_SIZE (64)
-#else
-typedef mz_uint32 tinfl_bit_buf_t;
-#define TINFL_BITBUF_SIZE (32)
-#endif
-
-struct tinfl_decompressor_tag
-{
-    mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES];
-    tinfl_bit_buf_t m_bit_buf;
-    size_t m_dist_from_out_buf_start;
-    tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES];
-    mz_uint8 m_raw_header[4], m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137];
-};
-
-
-
-
-
-
-/* ------------------- ZIP archive reading/writing */
-
-#ifndef MINIZ_NO_ARCHIVE_APIS
-
-
-enum
-{
-    /* Note: These enums can be reduced as needed to save memory or stack space - they are pretty conservative. */
-    MZ_ZIP_MAX_IO_BUF_SIZE = 64 * 1024,
-    MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE = 512,
-    MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE = 512
-};
-
-typedef struct
-{
-    /* Central directory file index. */
-    mz_uint32 m_file_index;
-
-    /* Byte offset of this entry in the archive's central directory. Note we currently only support up to UINT_MAX or less bytes in the central dir. */
-    mz_uint64 m_central_dir_ofs;
-
-    /* These fields are copied directly from the zip's central dir. */
-    mz_uint16 m_version_made_by;
-    mz_uint16 m_version_needed;
-    mz_uint16 m_bit_flag;
-    mz_uint16 m_method;
-
-#ifndef MINIZ_NO_TIME
-    MZ_TIME_T m_time;
-#endif
-
-    /* CRC-32 of uncompressed data. */
-    mz_uint32 m_crc32;
-
-    /* File's compressed size. */
-    mz_uint64 m_comp_size;
-
-    /* File's uncompressed size. Note, I've seen some old archives where directory entries had 512 bytes for their uncompressed sizes, but when you try to unpack them you actually get 0 bytes. */
-    mz_uint64 m_uncomp_size;
-
-    /* Zip internal and external file attributes. */
-    mz_uint16 m_internal_attr;
-    mz_uint32 m_external_attr;
-
-    /* Entry's local header file offset in bytes. */
-    mz_uint64 m_local_header_ofs;
-
-    /* Size of comment in bytes. */
-    mz_uint32 m_comment_size;
-
-    /* MZ_TRUE if the entry appears to be a directory. */
-    mz_bool m_is_directory;
-
-    /* MZ_TRUE if the entry uses encryption/strong encryption (which miniz_zip doesn't support) */
-    mz_bool m_is_encrypted;
-
-    /* MZ_TRUE if the file is not encrypted, a patch file, and if it uses a compression method we support. */
-    mz_bool m_is_supported;
-
-    /* Filename. If string ends in '/' it's a subdirectory entry. */
-    /* Guaranteed to be zero terminated, may be truncated to fit. */
-    char m_filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE];
-
-    /* Comment field. */
-    /* Guaranteed to be zero terminated, may be truncated to fit. */
-    char m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE];
-
-} mz_zip_archive_file_stat;
-
-typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n);
-typedef size_t (*mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n);
-typedef mz_bool (*mz_file_needs_keepalive)(void *pOpaque);
-
-struct mz_zip_internal_state_tag;
-typedef struct mz_zip_internal_state_tag mz_zip_internal_state;
-
-typedef enum {
-    MZ_ZIP_MODE_INVALID = 0,
-    MZ_ZIP_MODE_READING = 1,
-    MZ_ZIP_MODE_WRITING = 2,
-    MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3
-} mz_zip_mode;
-
-typedef enum {
-    MZ_ZIP_FLAG_CASE_SENSITIVE = 0x0100,
-    MZ_ZIP_FLAG_IGNORE_PATH = 0x0200,
-    MZ_ZIP_FLAG_COMPRESSED_DATA = 0x0400,
-    MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY = 0x0800,
-    MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG = 0x1000, /* if enabled, mz_zip_reader_locate_file() will be called on each file as its validated to ensure the func finds the file in the central dir (intended for testing) */
-    MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = 0x2000,     /* validate the local headers, but don't decompress the entire file and check the crc32 */
-    MZ_ZIP_FLAG_WRITE_ZIP64 = 0x4000,               /* always use the zip64 file format, instead of the original zip file format with automatic switch to zip64. Use as flags parameter with mz_zip_writer_init*_v2 */
-    MZ_ZIP_FLAG_WRITE_ALLOW_READING = 0x8000,
-    MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000
-} mz_zip_flags;
-
-typedef enum {
-    MZ_ZIP_TYPE_INVALID = 0,
-    MZ_ZIP_TYPE_USER,
-    MZ_ZIP_TYPE_MEMORY,
-    MZ_ZIP_TYPE_HEAP,
-    MZ_ZIP_TYPE_FILE,
-    MZ_ZIP_TYPE_CFILE,
-    MZ_ZIP_TOTAL_TYPES
-} mz_zip_type;
-
-/* miniz error codes. Be sure to update mz_zip_get_error_string() if you add or modify this enum. */
-typedef enum {
-    MZ_ZIP_NO_ERROR = 0,
-    MZ_ZIP_UNDEFINED_ERROR,
-    MZ_ZIP_TOO_MANY_FILES,
-    MZ_ZIP_FILE_TOO_LARGE,
-    MZ_ZIP_UNSUPPORTED_METHOD,
-    MZ_ZIP_UNSUPPORTED_ENCRYPTION,
-    MZ_ZIP_UNSUPPORTED_FEATURE,
-    MZ_ZIP_FAILED_FINDING_CENTRAL_DIR,
-    MZ_ZIP_NOT_AN_ARCHIVE,
-    MZ_ZIP_INVALID_HEADER_OR_CORRUPTED,
-    MZ_ZIP_UNSUPPORTED_MULTIDISK,
-    MZ_ZIP_DECOMPRESSION_FAILED,
-    MZ_ZIP_COMPRESSION_FAILED,
-    MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE,
-    MZ_ZIP_CRC_CHECK_FAILED,
-    MZ_ZIP_UNSUPPORTED_CDIR_SIZE,
-    MZ_ZIP_ALLOC_FAILED,
-    MZ_ZIP_FILE_OPEN_FAILED,
-    MZ_ZIP_FILE_CREATE_FAILED,
-    MZ_ZIP_FILE_WRITE_FAILED,
-    MZ_ZIP_FILE_READ_FAILED,
-    MZ_ZIP_FILE_CLOSE_FAILED,
-    MZ_ZIP_FILE_SEEK_FAILED,
-    MZ_ZIP_FILE_STAT_FAILED,
-    MZ_ZIP_INVALID_PARAMETER,
-    MZ_ZIP_INVALID_FILENAME,
-    MZ_ZIP_BUF_TOO_SMALL,
-    MZ_ZIP_INTERNAL_ERROR,
-    MZ_ZIP_FILE_NOT_FOUND,
-    MZ_ZIP_ARCHIVE_TOO_LARGE,
-    MZ_ZIP_VALIDATION_FAILED,
-    MZ_ZIP_WRITE_CALLBACK_FAILED,
-    MZ_ZIP_TOTAL_ERRORS
-} mz_zip_error;
-
-typedef struct
-{
-    mz_uint64 m_archive_size;
-    mz_uint64 m_central_directory_file_ofs;
-
-    /* We only support up to UINT32_MAX files in zip64 mode. */
-    mz_uint32 m_total_files;
-    mz_zip_mode m_zip_mode;
-    mz_zip_type m_zip_type;
-    mz_zip_error m_last_error;
-
-    mz_uint64 m_file_offset_alignment;
-
-    mz_alloc_func m_pAlloc;
-    mz_free_func m_pFree;
-    mz_realloc_func m_pRealloc;
-    void *m_pAlloc_opaque;
-
-    mz_file_read_func m_pRead;
-    mz_file_write_func m_pWrite;
-    mz_file_needs_keepalive m_pNeeds_keepalive;
-    void *m_pIO_opaque;
-
-    mz_zip_internal_state *m_pState;
-
-} mz_zip_archive;
-
-typedef struct
-{
-    mz_zip_archive *pZip;
-    mz_uint flags;
-
-    int status;
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-    mz_uint file_crc32;
-#endif
-    mz_uint64 read_buf_size, read_buf_ofs, read_buf_avail, comp_remaining, out_buf_ofs, cur_file_ofs;
-    mz_zip_archive_file_stat file_stat;
-    void *pRead_buf;
-    void *pWrite_buf;
-
-    size_t out_blk_remain;
-
-    tinfl_decompressor inflator;
-
-} mz_zip_reader_extract_iter_state;
-
-/* -------- ZIP reading */
-
-/* Inits a ZIP archive reader. */
-/* These functions read and validate the archive's central directory. */
-mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags);
-
-mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags);
-
-#ifndef MINIZ_NO_STDIO
-/* Read a archive from a disk file. */
-/* file_start_ofs is the file offset where the archive actually begins, or 0. */
-/* actual_archive_size is the true total size of the archive, which may be smaller than the file's actual size on disk. If zero the entire file is treated as the archive. */
-mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags);
-mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size);
-
-/* Read an archive from an already opened FILE, beginning at the current file position. */
-/* The archive is assumed to be archive_size bytes long. If archive_size is < 0, then the entire rest of the file is assumed to contain the archive. */
-/* The FILE will NOT be closed when mz_zip_reader_end() is called. */
-mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags);
-#endif
-
-/* Ends archive reading, freeing all allocations, and closing the input archive file if mz_zip_reader_init_file() was used. */
-mz_bool mz_zip_reader_end(mz_zip_archive *pZip);
-
-/* -------- ZIP reading or writing */
-
-/* Clears a mz_zip_archive struct to all zeros. */
-/* Important: This must be done before passing the struct to any mz_zip functions. */
-void mz_zip_zero_struct(mz_zip_archive *pZip);
-
-mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip);
-mz_zip_type mz_zip_get_type(mz_zip_archive *pZip);
-
-/* Returns the total number of files in the archive. */
-mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip);
-
-mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip);
-mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip);
-MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip);
-
-/* Reads n bytes of raw archive data, starting at file offset file_ofs, to pBuf. */
-size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n);
-
-/* All mz_zip funcs set the m_last_error field in the mz_zip_archive struct. These functions retrieve/manipulate this field. */
-/* Note that the m_last_error functionality is not thread safe. */
-mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num);
-mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip);
-mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip);
-mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip);
-const char *mz_zip_get_error_string(mz_zip_error mz_err);
-
-/* MZ_TRUE if the archive file entry is a directory entry. */
-mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index);
-
-/* MZ_TRUE if the file is encrypted/strong encrypted. */
-mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index);
-
-/* MZ_TRUE if the compression method is supported, and the file is not encrypted, and the file is not a compressed patch file. */
-mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index);
-
-/* Retrieves the filename of an archive file entry. */
-/* Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename. */
-mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size);
-
-/* Attempts to locates a file in the archive's central directory. */
-/* Valid flags: MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_IGNORE_PATH */
-/* Returns -1 if the file cannot be found. */
-int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
-int mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *file_index);
-
-/* Returns detailed information about an archive file entry. */
-mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat);
-
-/* MZ_TRUE if the file is in zip64 format. */
-/* A file is considered zip64 if it contained a zip64 end of central directory marker, or if it contained any zip64 extended file information fields in the central directory. */
-mz_bool mz_zip_is_zip64(mz_zip_archive *pZip);
-
-/* Returns the total central directory size in bytes. */
-/* The current max supported size is <= MZ_UINT32_MAX. */
-size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip);
-
-/* Extracts a archive file to a memory buffer using no memory allocation. */
-/* There must be at least enough room on the stack to store the inflator's state (~34KB or so). */
-mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
-mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
-
-/* Extracts a archive file to a memory buffer. */
-mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags);
-
-/* Extracts a archive file to a dynamically allocated heap buffer. */
-/* The memory will be allocated via the mz_zip_archive's alloc/realloc functions. */
-/* Returns NULL and sets the last error on failure. */
-void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags);
-void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags);
-
-/* Extracts a archive file using a callback function to output the file's data. */
-mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
-
-/* Extract a file iteratively */
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
-size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size);
-mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState);
-
-#ifndef MINIZ_NO_STDIO
-/* Extracts a archive file to a disk file and sets its last accessed and modified times. */
-/* This function only extracts files, not archive directory records. */
-mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags);
-
-/* Extracts a archive file starting at the current position in the destination FILE stream. */
-mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *File, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags);
-#endif
-
-#if 0
-/* TODO */
-	typedef void *mz_zip_streaming_extract_state_ptr;
-	mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-	uint64_t mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	uint64_t mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, uint64_t new_ofs);
-	size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size);
-	mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-#endif
-
-/* This function compares the archive's local headers, the optional local zip64 extended information block, and the optional descriptor following the compressed data vs. the data in the central directory. */
-/* It also validates that each file can be successfully uncompressed unless the MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY is specified. */
-mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-
-/* Validates an entire archive by calling mz_zip_validate_file() on each file. */
-mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags);
-
-/* Misc utils/helpers, valid for ZIP reading or writing */
-mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr);
-mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr);
-
-/* Universal end function - calls either mz_zip_reader_end() or mz_zip_writer_end(). */
-mz_bool mz_zip_end(mz_zip_archive *pZip);
-
-/* -------- ZIP writing */
-
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-
-/* Inits a ZIP archive writer. */
-/*Set pZip->m_pWrite (and pZip->m_pIO_opaque) before calling mz_zip_writer_init or mz_zip_writer_init_v2*/
-/*The output is streamable, i.e. file_ofs in mz_file_write_func always increases only by n*/
-mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size);
-mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags);
-
-mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size);
-mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags);
-
-#ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning);
-mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags);
-mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags);
-#endif
-
-/* Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive. */
-/* For archives opened using mz_zip_reader_init_file, pFilename must be the archive's filename so it can be reopened for writing. If the file can't be reopened, mz_zip_reader_end() will be called. */
-/* For archives opened using mz_zip_reader_init_mem, the memory block must be growable using the realloc callback (which defaults to realloc unless you've overridden it). */
-/* Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL. */
-/* Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before */
-/* the archive is finalized the file's central directory will be hosed. */
-mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename);
-mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
-
-/* Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive. */
-/* To add a directory entry, call this method with an archive name ending in a forwardslash with an empty buffer. */
-/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags);
-
-/* Like mz_zip_writer_add_mem(), except you can specify a file comment field, and optionally supply the function with already compressed data. */
-/* uncomp_size/uncomp_crc32 are only used if the MZ_ZIP_FLAG_COMPRESSED_DATA flag is specified. */
-mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32);
-
-mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                    mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
-                                    const char *user_extra_data_central, mz_uint user_extra_data_central_len);
-
-#ifndef MINIZ_NO_STDIO
-/* Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive. */
-/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
-
-/* Like mz_zip_writer_add_file(), except the file data is read from the specified FILE stream. */
-mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 size_to_add,
-                                const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
-                                const char *user_extra_data_central, mz_uint user_extra_data_central_len);
-#endif
-
-/* Adds a file to an archive by fully cloning the data from another archive. */
-/* This function fully clones the source file's compressed data (no recompression), along with its full filename, extra data (it may add or modify the zip64 local header extra data field), and the optional descriptor following the compressed data. */
-mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index);
-
-/* Finalizes the archive by writing the central directory records followed by the end of central directory record. */
-/* After an archive is finalized, the only valid call on the mz_zip_archive struct is mz_zip_writer_end(). */
-/* An archive must be manually finalized by calling this function for it to be valid. */
-mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip);
-
-/* Finalizes a heap archive, returning a poiner to the heap block and its size. */
-/* The heap block will be allocated using the mz_zip_archive's alloc/realloc callbacks. */
-mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize);
-
-/* Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used. */
-/* Note for the archive to be valid, it *must* have been finalized before ending (this function will not do it for you). */
-mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
-
-/* -------- Misc. high-level helper functions: */
-
-/* mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) appends a memory blob to a ZIP archive. */
-/* Note this is NOT a fully safe operation. If it crashes or dies in some way your archive can be left in a screwed up state (without a central directory). */
-/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-/* TODO: Perhaps add an option to leave the existing central dir in place in case the add dies? We could then truncate the file (so the old central dir would be at the end) if something goes wrong. */
-mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
-mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr);
-
-/* Reads a single file from an archive into a heap block. */
-/* If pComment is not NULL, only the file with the specified comment will be extracted. */
-/* Returns NULL on failure. */
-void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags);
-void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr);
-
-#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-
-
-#endif /* MINIZ_NO_ARCHIVE_APIS */
-
-} // namespace duckdb_miniz
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
-// See the end of this file for a list
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// miniz_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-#include <string>
-#include <stdexcept>
-
-namespace duckdb {
-
-enum class MiniZStreamType {
-	MINIZ_TYPE_NONE,
-	MINIZ_TYPE_INFLATE,
-	MINIZ_TYPE_DEFLATE
-};
-
-struct MiniZStream {
-	static constexpr uint8_t GZIP_HEADER_MINSIZE = 10;
-	static constexpr uint8_t GZIP_FOOTER_SIZE = 8;
-	static constexpr uint8_t GZIP_COMPRESSION_DEFLATE = 0x08;
-	static constexpr unsigned char GZIP_FLAG_UNSUPPORTED = 0x1 | 0x2 | 0x4 | 0x10 | 0x20;
-
-public:
-	MiniZStream() : type(MiniZStreamType::MINIZ_TYPE_NONE) {
-		memset(&stream, 0, sizeof(duckdb_miniz::mz_stream));
-	}
-	~MiniZStream() {
-		switch(type) {
-		case MiniZStreamType::MINIZ_TYPE_INFLATE:
-			duckdb_miniz::mz_inflateEnd(&stream);
-			break;
-		case MiniZStreamType::MINIZ_TYPE_DEFLATE:
-			duckdb_miniz::mz_deflateEnd(&stream);
-			break;
-		default:
-			break;
-		}
-	}
-	void FormatException(std::string error_msg) {
-		throw std::runtime_error(error_msg);
-	}
-	void FormatException(const char *error_msg, int mz_ret) {
-		auto err = duckdb_miniz::mz_error(mz_ret);
-		FormatException(error_msg + std::string(": ") + (err ? err : "Unknown error code"));
-	}
-	void Decompress(const char *compressed_data, size_t compressed_size, char *out_data, size_t out_size) {
-		auto mz_ret = mz_inflateInit2(&stream, -MZ_DEFAULT_WINDOW_BITS);
-		if (mz_ret != duckdb_miniz::MZ_OK) {
-			FormatException("Failed to initialize miniz", mz_ret);
-		}
-		type = MiniZStreamType::MINIZ_TYPE_INFLATE;
-
-		if (compressed_size < GZIP_HEADER_MINSIZE) {
-			FormatException("Failed to decompress GZIP block: compressed size is less than gzip header size");
-		}
-		auto gzip_hdr = (const unsigned char *)compressed_data;
-		if (gzip_hdr[0] != 0x1F || gzip_hdr[1] != 0x8B || gzip_hdr[2] != GZIP_COMPRESSION_DEFLATE ||
-		    gzip_hdr[3] & GZIP_FLAG_UNSUPPORTED) {
-			FormatException("Input is invalid/unsupported GZIP stream");
-		}
-
-		stream.next_in = (const unsigned char *)compressed_data + GZIP_HEADER_MINSIZE;
-		stream.avail_in = compressed_size - GZIP_HEADER_MINSIZE;
-		stream.next_out = (unsigned char *)out_data;
-		stream.avail_out = out_size;
-
-		mz_ret = mz_inflate(&stream, duckdb_miniz::MZ_FINISH);
-		if (mz_ret != duckdb_miniz::MZ_OK && mz_ret != duckdb_miniz::MZ_STREAM_END) {
-			FormatException("Failed to decompress GZIP block", mz_ret);
-		}
-	}
-	size_t MaxCompressedLength(size_t input_size) {
-		return duckdb_miniz::mz_compressBound(input_size) + GZIP_HEADER_MINSIZE + GZIP_FOOTER_SIZE;
-	}
-	static void InitializeGZIPHeader(unsigned char *gzip_header) {
-		memset(gzip_header, 0, GZIP_HEADER_MINSIZE);
-		gzip_header[0] = 0x1F;
-		gzip_header[1] = 0x8B;
-		gzip_header[2] = GZIP_COMPRESSION_DEFLATE;
-		gzip_header[3] = 0;
-		gzip_header[4] = 0;
-		gzip_header[5] = 0;
-		gzip_header[6] = 0;
-		gzip_header[7] = 0;
-		gzip_header[8] = 0;
-		gzip_header[9] = 0xFF;
-	}
-
-	static void InitializeGZIPFooter(unsigned char *gzip_footer, duckdb_miniz::mz_ulong crc, idx_t uncompressed_size) {
-		gzip_footer[0] = crc & 0xFF;
-		gzip_footer[1] = (crc >> 8) & 0xFF;
-		gzip_footer[2] = (crc >> 16) & 0xFF;
-		gzip_footer[3] = (crc >> 24) & 0xFF;
-		gzip_footer[4] = uncompressed_size & 0xFF;
-		gzip_footer[5] = (uncompressed_size >> 8) & 0xFF;
-		gzip_footer[6] = (uncompressed_size >> 16) & 0xFF;
-		gzip_footer[7] = (uncompressed_size >> 24) & 0xFF;
-	}
-
-	void Compress(const char *uncompressed_data, size_t uncompressed_size, char *out_data, size_t *out_size) {
-		auto mz_ret = mz_deflateInit2(&stream, duckdb_miniz::MZ_DEFAULT_LEVEL, MZ_DEFLATED, -MZ_DEFAULT_WINDOW_BITS, 1, 0);
-		if (mz_ret != duckdb_miniz::MZ_OK) {
-			FormatException("Failed to initialize miniz", mz_ret);
-		}
-		type = MiniZStreamType::MINIZ_TYPE_DEFLATE;
-
-		auto gzip_header = (unsigned char*) out_data;
-		InitializeGZIPHeader(gzip_header);
-
-		auto gzip_body = gzip_header + GZIP_HEADER_MINSIZE;
-
-		stream.next_in = (const unsigned char*) uncompressed_data;
-		stream.avail_in = uncompressed_size;
-		stream.next_out = gzip_body;
-		stream.avail_out = *out_size - GZIP_HEADER_MINSIZE;
-
-		mz_ret = mz_deflate(&stream, duckdb_miniz::MZ_FINISH);
-		if (mz_ret != duckdb_miniz::MZ_OK && mz_ret != duckdb_miniz::MZ_STREAM_END) {
-			FormatException("Failed to compress GZIP block", mz_ret);
-		}
-		auto gzip_footer = gzip_body + stream.total_out;
-		auto crc = duckdb_miniz::mz_crc32(MZ_CRC32_INIT, (const unsigned char*) uncompressed_data, uncompressed_size);
-		InitializeGZIPFooter(gzip_footer, crc, uncompressed_size);
-
-		*out_size = stream.total_out + GZIP_HEADER_MINSIZE + GZIP_FOOTER_SIZE;
-	}
-
-private:
-	duckdb_miniz::mz_stream stream;
-	MiniZStreamType type;
-};
-
-}
-
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/local_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class LocalFileSystem : public FileSystem {
-public:
-	unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags, FileLockType lock = FileLockType::NO_LOCK,
-	                                FileCompressionType compression = FileCompressionType::UNCOMPRESSED,
-	                                FileOpener *opener = nullptr) override;
-
-	//! Read exactly nr_bytes from the specified location in the file. Fails if nr_bytes could not be read. This is
-	//! equivalent to calling SetFilePointer(location) followed by calling Read().
-	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
-	//! Write exactly nr_bytes to the specified location in the file. Fails if nr_bytes could not be read. This is
-	//! equivalent to calling SetFilePointer(location) followed by calling Write().
-	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
-	//! Read nr_bytes from the specified file into the buffer, moving the file pointer forward by nr_bytes. Returns the
-	//! amount of bytes read.
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-
-	//! Returns the file size of a file handle, returns -1 on error
-	int64_t GetFileSize(FileHandle &handle) override;
-	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	time_t GetLastModifiedTime(FileHandle &handle) override;
-	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	FileType GetFileType(FileHandle &handle) override;
-	//! Truncate a file to a maximum size of new_size, new_size should be smaller than or equal to the current size of
-	//! the file
-	void Truncate(FileHandle &handle, int64_t new_size) override;
-
-	//! Check if a directory exists
-	bool DirectoryExists(const string &directory) override;
-	//! Create a directory if it does not exist
-	void CreateDirectory(const string &directory) override;
-	//! Recursively remove a directory and all files in it
-	void RemoveDirectory(const string &directory) override;
-	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
-	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) override;
-	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
-	//! properties
-	void MoveFile(const string &source, const string &target) override;
-	//! Check if a file exists
-	bool FileExists(const string &filename) override;
-
-	//! Check if path is a pipe
-	bool IsPipe(const string &filename) override;
-	//! Remove a file from disk
-	void RemoveFile(const string &filename) override;
-	//! Sync a file handle to disk
-	void FileSync(FileHandle &handle) override;
-
-	//! Runs a glob on the file system, returning a list of matching files
-	vector<string> Glob(const string &path, FileOpener *opener = nullptr) override;
-
-	bool CanHandleFile(const string &fpath) override {
-		//! Whether or not a sub-system can handle a specific file path
-		return false;
-	}
-
-	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
-	void Seek(FileHandle &handle, idx_t location) override;
-	//! Return the current seek posiiton in the file.
-	idx_t SeekPosition(FileHandle &handle) override;
-
-	//! Whether or not we can seek into the file
-	bool CanSeek() override;
-	//! Whether or not the FS handles plain files on disk. This is relevant for certain optimizations, as random reads
-	//! in a file on-disk are much cheaper than e.g. random reads in a file over the network
-	bool OnDiskFile(FileHandle &handle) override;
-
-	std::string GetName() const override {
-		return "LocalFileSystem";
-	}
-
-	//! Returns the last Win32 error, in string format. Returns an empty string if there is no error, or on non-Windows
-	//! systems.
-	static std::string GetLastErrorAsString();
-
-private:
-	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
-	void SetFilePointer(FileHandle &handle, idx_t location);
-	idx_t GetFilePointer(FileHandle &handle);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/file_opener.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class Value;
-
-//! Abstract type that provide client-specific context to FileSystem.
-class FileOpener {
-public:
-	virtual ~FileOpener() {};
-
-	virtual bool TryGetCurrentSetting(const string &key, Value &result) = 0;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/windows_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-#ifdef DUCKDB_WINDOWS
-class WindowsUtil {
-public:
-	//! Windows helper functions
-	static std::wstring UTF8ToUnicode(const char *input);
-	static string UnicodeToUTF8(LPCWSTR input);
-	static string UTF8ToMBCS(const char *input, bool use_ansi = false);
-};
-#endif
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/cast_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/convert_to_string.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct ConvertToString {
-	template <class SRC>
-	static inline string Operation(SRC input) {
-		throw InternalException("Unrecognized type for ConvertToString %s", GetTypeId<SRC>());
-	}
-};
-
-template <>
-string ConvertToString::Operation(bool input);
-template <>
-string ConvertToString::Operation(int8_t input);
-template <>
-string ConvertToString::Operation(int16_t input);
-template <>
-string ConvertToString::Operation(int32_t input);
-template <>
-string ConvertToString::Operation(int64_t input);
-template <>
-string ConvertToString::Operation(uint8_t input);
-template <>
-string ConvertToString::Operation(uint16_t input);
-template <>
-string ConvertToString::Operation(uint32_t input);
-template <>
-string ConvertToString::Operation(uint64_t input);
-template <>
-string ConvertToString::Operation(hugeint_t input);
-template <>
-string ConvertToString::Operation(float input);
-template <>
-string ConvertToString::Operation(double input);
-template <>
-string ConvertToString::Operation(interval_t input);
-template <>
-string ConvertToString::Operation(date_t input);
-template <>
-string ConvertToString::Operation(dtime_t input);
-template <>
-string ConvertToString::Operation(timestamp_t input);
-template <>
-string ConvertToString::Operation(string_t input);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/null_value.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-#include <limits>
-#include <cstring>
-#include <cmath>
-
-namespace duckdb {
-
-//! Placeholder to insert in Vectors or to use for hashing NULLs
-template <class T>
-inline T NullValue() {
-	return std::numeric_limits<T>::min();
-}
-
-constexpr const char str_nil[2] = {'\200', '\0'};
-
-template <>
-inline const char *NullValue() {
-	D_ASSERT(str_nil[0] == '\200' && str_nil[1] == '\0');
-	return str_nil;
-}
-
-template <>
-inline string_t NullValue() {
-	return string_t(NullValue<const char *>());
-}
-
-template <>
-inline char *NullValue() {
-	return (char *)NullValue<const char *>();
-}
-
-template <>
-inline string NullValue() {
-	return string(NullValue<const char *>());
-}
-
-template <>
-inline interval_t NullValue() {
-	interval_t null_value;
-	null_value.days = NullValue<int32_t>();
-	null_value.months = NullValue<int32_t>();
-	null_value.micros = NullValue<int64_t>();
-	return null_value;
-}
-
-template <>
-inline hugeint_t NullValue() {
-	hugeint_t min;
-	min.lower = 0;
-	min.upper = std::numeric_limits<int64_t>::min();
-	return min;
-}
-
-template <>
-inline float NullValue() {
-	return NAN;
-}
-
-template <>
-inline double NullValue() {
-	return NAN;
-}
-
-} // namespace duckdb
-
-
-namespace duckdb {
-struct ValidityMask;
-class Vector;
-
-struct TryCast {
-	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId<SRC>(), GetTypeId<DST>());
-	}
-};
-
-struct TryCastErrorMessage {
-	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, string *error_message, bool strict = false) {
-		throw NotImplementedException("Unimplemented type for cast (%s -> %s)", GetTypeId<SRC>(), GetTypeId<DST>());
-	}
-};
-
-template <class SRC, class DST>
-static string CastExceptionText(SRC input) {
-	if (std::is_same<SRC, string_t>()) {
-		return "Could not convert string '" + ConvertToString::Operation<SRC>(input) + "' to " +
-		       TypeIdToString(GetTypeId<DST>());
-	}
-	if (TypeIsNumber<SRC>() && TypeIsNumber<DST>()) {
-		return "Type " + TypeIdToString(GetTypeId<SRC>()) + " with value " + ConvertToString::Operation<SRC>(input) +
-		       " can't be cast because the value is out of range for the destination type " +
-		       TypeIdToString(GetTypeId<DST>());
-	}
-	return "Type " + TypeIdToString(GetTypeId<SRC>()) + " with value " + ConvertToString::Operation<SRC>(input) +
-	       " can't be cast to the destination type " + TypeIdToString(GetTypeId<DST>());
-}
-
-struct Cast {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		DST result;
-		if (!TryCast::Operation(input, result)) {
-			throw InvalidInputException(CastExceptionText<SRC, DST>(input));
-		}
-		return result;
-	}
-};
-
-struct HandleCastError {
-	static void AssignError(string error_message, string *error_message_ptr) {
-		if (!error_message_ptr) {
-			throw ConversionException(error_message);
-		}
-		if (error_message_ptr->empty()) {
-			*error_message_ptr = error_message;
-		}
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Cast bool -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(bool input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast int8_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int8_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast int16_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int16_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast int32_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int32_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast int64_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(int64_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast hugeint_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(hugeint_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uint8_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint8_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uint16_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint16_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uint32_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint32_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast uint64_t -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(uint64_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast float -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(float input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(float input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Cast double -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(double input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(double input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// String -> Numeric Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, bool &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, int8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, int16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, int32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, int64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uint8_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uint16_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uint32_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, uint64_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, hugeint_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, float &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, double &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Date Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(date_t input, date_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(date_t input, timestamp_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Time Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(dtime_t input, dtime_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Timestamp Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, date_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, dtime_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(timestamp_t input, timestamp_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Interval Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCast::Operation(interval_t input, interval_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// String -> Date Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, date_t &result, string *error_message, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, date_t &result, bool strict);
-template <>
-date_t Cast::Operation(string_t input);
-//===--------------------------------------------------------------------===//
-// String -> Time Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, string *error_message, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, dtime_t &result, bool strict);
-template <>
-dtime_t Cast::Operation(string_t input);
-//===--------------------------------------------------------------------===//
-// String -> Timestamp Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, string *error_message, bool strict);
-template <>
-DUCKDB_API bool TryCast::Operation(string_t input, timestamp_t &result, bool strict);
-template <>
-timestamp_t Cast::Operation(string_t input);
-//===--------------------------------------------------------------------===//
-// String -> Interval Casts
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, interval_t &result, string *error_message, bool strict);
-
-//===--------------------------------------------------------------------===//
-// string -> Non-Standard Timestamps
-//===--------------------------------------------------------------------===//
-struct TryCastToTimestampNS {
-	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		throw InternalException("Unsupported type for try cast to timestamp (ns)");
-	}
-};
-
-struct TryCastToTimestampMS {
-	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		throw InternalException("Unsupported type for try cast to timestamp (ms)");
-	}
-};
-
-struct TryCastToTimestampSec {
-	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		throw InternalException("Unsupported type for try cast to timestamp (s)");
-	}
-};
-
-template <>
-DUCKDB_API bool TryCastToTimestampNS::Operation(string_t input, timestamp_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool strict);
-
-template <>
-DUCKDB_API bool TryCastToTimestampNS::Operation(date_t input, timestamp_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool strict);
-template <>
-DUCKDB_API bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool strict);
-
-//===--------------------------------------------------------------------===//
-// Non-Standard Timestamps -> string/standard timestamp
-//===--------------------------------------------------------------------===//
-
-struct CastFromTimestampNS {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastFromTimestampMS {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastFromTimestampSec {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampUsToMs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampUsToNs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampUsToSec {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampMsToUs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampNsToUs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-struct CastTimestampSecToUs {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		throw duckdb::NotImplementedException("Cast to timestamp could not be performed!");
-	}
-};
-
-template <>
-duckdb::timestamp_t CastTimestampUsToMs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampUsToNs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampUsToSec::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampMsToUs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampNsToUs::Operation(duckdb::timestamp_t input);
-template <>
-duckdb::timestamp_t CastTimestampSecToUs::Operation(duckdb::timestamp_t input);
-
-template <>
-duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_t input, Vector &result);
-template <>
-duckdb::string_t CastFromTimestampMS::Operation(duckdb::timestamp_t input, Vector &result);
-template <>
-duckdb::string_t CastFromTimestampSec::Operation(duckdb::timestamp_t input, Vector &result);
-
-//===--------------------------------------------------------------------===//
-// Blobs
-//===--------------------------------------------------------------------===//
-struct CastFromBlob {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast from blob could not be performed!");
-	}
-};
-template <>
-duckdb::string_t CastFromBlob::Operation(duckdb::string_t input, Vector &vector);
-
-struct TryCastToBlob {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
-	                             bool strict = false) {
-		throw InternalException("Unsupported type for try cast to blob");
-	}
-};
-
-template <>
-bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
-                              bool strict);
-
-//===--------------------------------------------------------------------===//
-// UUID
-//===--------------------------------------------------------------------===//
-struct CastFromUUID {
-	template <class SRC>
-	static inline string_t Operation(SRC input, Vector &result) {
-		throw duckdb::NotImplementedException("Cast from uuid could not be performed!");
-	}
-};
-template <>
-duckdb::string_t CastFromUUID::Operation(duckdb::hugeint_t input, Vector &vector);
-
-struct TryCastToUUID {
-	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
-	                                        bool strict = false) {
-		throw InternalException("Unsupported type for try cast to uuid");
-	}
-};
-
-template <>
-DUCKDB_API bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector,
-                                         string *error_message, bool strict);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/string_cast.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! StringCast
-class Vector;
-
-struct StringCast {
-	template <class SRC>
-	DUCKDB_API static inline string_t Operation(SRC input, Vector &result) {
-		throw NotImplementedException("Unimplemented type for string cast!");
-	}
-};
-
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(bool input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(int8_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(int16_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(int32_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(int64_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uint8_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uint16_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uint32_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(uint64_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(hugeint_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(float input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(double input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(interval_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(duckdb::string_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(date_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(dtime_t input, Vector &result);
-template <>
-DUCKDB_API duckdb::string_t StringCast::Operation(timestamp_t input, Vector &result);
-
-//! Temporary casting for Time Zone types. TODO: turn casting into functions.
-struct StringCastTZ {
-	template <typename SRC>
-	static inline string_t Operation(SRC input, Vector &vector) {
-		return StringCast::Operation(input, vector);
-	}
-};
-
-template <>
-duckdb::string_t StringCastTZ::Operation(date_t input, Vector &result);
-template <>
-duckdb::string_t StringCastTZ::Operation(dtime_t input, Vector &result);
-template <>
-duckdb::string_t StringCastTZ::Operation(timestamp_t input, Vector &result);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/numeric_cast.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-#include <cmath>
-
-namespace duckdb {
-
-template <class SRC, class DST>
-static bool TryCastWithOverflowCheck(SRC value, DST &result) {
-	if (!Value::IsFinite<SRC>(value)) {
-		return false;
-	}
-	if (NumericLimits<SRC>::IsSigned() != NumericLimits<DST>::IsSigned()) {
-		if (NumericLimits<SRC>::IsSigned()) {
-			// signed to unsigned conversion
-			if (NumericLimits<SRC>::Digits() > NumericLimits<DST>::Digits()) {
-				if (value < 0 || value > (SRC)NumericLimits<DST>::Maximum()) {
-					return false;
-				}
-			} else {
-				if (value < 0) {
-					return false;
-				}
-			}
-			result = (DST)value;
-			return true;
-		} else {
-			// unsigned to signed conversion
-			if (NumericLimits<SRC>::Digits() >= NumericLimits<DST>::Digits()) {
-				if (value <= (SRC)NumericLimits<DST>::Maximum()) {
-					result = (DST)value;
-					return true;
-				}
-				return false;
-			} else {
-				result = (DST)value;
-				return true;
-			}
-		}
-	} else {
-		// same sign conversion
-		if (NumericLimits<DST>::Digits() >= NumericLimits<SRC>::Digits()) {
-			result = (DST)value;
-			return true;
-		} else {
-			if (value < SRC(NumericLimits<DST>::Minimum()) || value > SRC(NumericLimits<DST>::Maximum())) {
-				return false;
-			}
-			result = (DST)value;
-			return true;
-		}
-	}
-}
-
-template <class SRC, class T>
-bool TryCastWithOverflowCheckFloat(SRC value, T &result, SRC min, SRC max) {
-	if (!Value::IsFinite<SRC>(value)) {
-		return false;
-	}
-	if (!(value >= min && value < max)) {
-		return false;
-	}
-	// PG FLOAT => INT casts use statistical rounding.
-	result = std::nearbyint(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, int8_t &result) {
-	return TryCastWithOverflowCheckFloat<float, int8_t>(value, result, -128.0f, 128.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, int16_t &result) {
-	return TryCastWithOverflowCheckFloat<float, int16_t>(value, result, -32768.0f, 32768.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, int32_t &result) {
-	return TryCastWithOverflowCheckFloat<float, int32_t>(value, result, -2147483648.0f, 2147483648.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, int64_t &result) {
-	return TryCastWithOverflowCheckFloat<float, int64_t>(value, result, -9223372036854775808.0f,
-	                                                     9223372036854775808.0f);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, int8_t &result) {
-	return TryCastWithOverflowCheckFloat<double, int8_t>(value, result, -128.0, 128.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, int16_t &result) {
-	return TryCastWithOverflowCheckFloat<double, int16_t>(value, result, -32768.0, 32768.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, int32_t &result) {
-	return TryCastWithOverflowCheckFloat<double, int32_t>(value, result, -2147483648.0, 2147483648.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, int64_t &result) {
-	return TryCastWithOverflowCheckFloat<double, int64_t>(value, result, -9223372036854775808.0, 9223372036854775808.0);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float input, float &result) {
-	result = input;
-	return true;
-}
-template <>
-bool TryCastWithOverflowCheck(float input, double &result) {
-	result = double(input);
-	return true;
-}
-template <>
-bool TryCastWithOverflowCheck(double input, double &result) {
-	result = input;
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(double input, float &result) {
-	if (!Value::IsFinite(input)) {
-		result = float(input);
-		return true;
-	}
-	auto res = float(input);
-	if (!Value::FloatIsFinite(input)) {
-		return false;
-	}
-	result = res;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Numeric -> bool
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(bool value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(int8_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(int16_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(int32_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(int64_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint8_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint16_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint32_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint64_t value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, bool &result) {
-	result = bool(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t input, bool &result) {
-	result = input.upper != 0 || input.lower != 0;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast bool -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(bool value, int8_t &result) {
-	result = int8_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, int16_t &result) {
-	result = int16_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, int32_t &result) {
-	result = int32_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, int64_t &result) {
-	result = int64_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, uint8_t &result) {
-	result = uint8_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, uint16_t &result) {
-	result = uint16_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, uint32_t &result) {
-	result = uint32_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, uint64_t &result) {
-	result = uint64_t(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, float &result) {
-	result = float(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool value, double &result) {
-	result = double(value);
-	return true;
-}
-
-template <>
-bool TryCastWithOverflowCheck(bool input, hugeint_t &result) {
-	result.upper = 0;
-	result.lower = input ? 1 : 0;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Numeric -> hugeint
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(int8_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int16_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int32_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(int64_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint8_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint16_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint32_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(uint64_t value, hugeint_t &result) {
-	return Hugeint::TryConvert(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(float value, hugeint_t &result) {
-	return Hugeint::TryConvert(std::nearbyintf(value), result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(double value, hugeint_t &result) {
-	return Hugeint::TryConvert(std::nearbyint(value), result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, hugeint_t &result) {
-	result = value;
-	return true;
-}
-
-//===--------------------------------------------------------------------===//
-// Cast Hugeint -> Numeric
-//===--------------------------------------------------------------------===//
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, int8_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, int16_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, int32_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, int64_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uint8_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uint16_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uint32_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, uint64_t &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, float &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-template <>
-bool TryCastWithOverflowCheck(hugeint_t value, double &result) {
-	return Hugeint::TryCast(value, result);
-}
-
-struct NumericTryCast {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, bool strict = false) {
-		return TryCastWithOverflowCheck(input, result);
-	}
-};
-
-struct NumericCast {
-	template <class SRC, class DST>
-	static inline DST Operation(SRC input) {
-		DST result;
-		if (!NumericTryCast::Operation(input, result)) {
-			throw InvalidInputException(CastExceptionText<SRC, DST>(input));
-		}
-		return result;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/decimal_cast_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Decimal Casts
-//===--------------------------------------------------------------------===//
-struct TryCastToDecimal {
-	template <class SRC, class DST>
-	DUCKDB_API static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width,
-	                                        uint8_t scale) {
-		throw NotImplementedException("Unimplemented type for TryCastToDecimal!");
-	}
-};
-
-struct TryCastFromDecimal {
-	template <class SRC, class DST>
-	static inline bool Operation(SRC input, DST &result, string *error_message, uint8_t width, uint8_t scale) {
-		throw NotImplementedException("Unimplemented type for TryCastFromDecimal!");
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> bool
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(bool input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(bool input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(bool input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(bool input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, bool &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, bool &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, bool &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, bool &result, string *error_message, uint8_t width, uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> int8_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int8_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int8_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int8_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> int16_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> int32_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> int64_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, int64_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> hugeint_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uint8_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint8_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint8_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint8_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint8_t &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint8_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uint16_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint16_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint16_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uint32_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint32_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint32_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> uint64_t
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(uint64_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, uint64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, uint64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, uint64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, uint64_t &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> float
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(float input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(float input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(float input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(float input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, float &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, float &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, float &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, float &result, string *error_message, uint8_t width, uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal <-> double
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(double input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(double input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(double input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(double input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-template <>
-bool TryCastFromDecimal::Operation(int16_t input, double &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int32_t input, double &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(int64_t input, double &result, string *error_message, uint8_t width, uint8_t scale);
-template <>
-bool TryCastFromDecimal::Operation(hugeint_t input, double &result, string *error_message, uint8_t width,
-                                   uint8_t scale);
-
-//===--------------------------------------------------------------------===//
-// Cast Decimal -> VARCHAR
-//===--------------------------------------------------------------------===//
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int16_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int32_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(string_t input, int64_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-template <>
-DUCKDB_API bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, string *error_message, uint8_t width,
-                                            uint8_t scale);
-
-struct StringCastFromDecimal {
-	template <class SRC>
-	static inline string_t Operation(SRC input, uint8_t width, uint8_t scale, Vector &result) {
-		throw NotImplementedException("Unimplemented type for string cast!");
-	}
-};
-
-template <>
-string_t StringCastFromDecimal::Operation(int16_t input, uint8_t width, uint8_t scale, Vector &result);
-template <>
-string_t StringCastFromDecimal::Operation(int32_t input, uint8_t width, uint8_t scale, Vector &result);
-template <>
-string_t StringCastFromDecimal::Operation(int64_t input, uint8_t width, uint8_t scale, Vector &result);
-template <>
-string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_t scale, Vector &result);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/multiply.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct MultiplyOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left * right;
-	}
-};
-
-template <>
-float MultiplyOperator::Operation(float left, float right);
-template <>
-double MultiplyOperator::Operation(double left, double right);
-template <>
-interval_t MultiplyOperator::Operation(interval_t left, int64_t right);
-template <>
-interval_t MultiplyOperator::Operation(int64_t left, interval_t right);
-
-struct TryMultiplyOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryMultiplyOperator");
-	}
-};
-
-template <>
-bool TryMultiplyOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-
-template <>
-bool TryMultiplyOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TryMultiplyOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryMultiplyOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-DUCKDB_API bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result);
-
-struct MultiplyOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryMultiplyOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in multiplication of %s (%d * %d)!", TypeIdToString(GetTypeId<TA>()),
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-struct TryDecimalMultiply {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalMultiply");
-	}
-};
-
-template <>
-bool TryDecimalMultiply::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalMultiply::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalMultiply::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalMultiply::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalMultiplyOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalMultiply::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in multiplication of DECIMAL(18) (%d * %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalMultiplyOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/cast_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! NumericHelper is a static class that holds helper functions for integers/doubles
-class NumericHelper {
-public:
-	static const int64_t POWERS_OF_TEN[20];
-	static const double DOUBLE_POWERS_OF_TEN[40];
-
-public:
-	template <class T>
-	static int UnsignedLength(T value);
-	template <class SIGNED, class UNSIGNED>
-	static int SignedLength(SIGNED value) {
-		int sign = -(value < 0);
-		UNSIGNED unsigned_value = (value ^ sign) - sign;
-		return UnsignedLength(unsigned_value) - sign;
-	}
-
-	// Formats value in reverse and returns a pointer to the beginning.
-	template <class T>
-	static char *FormatUnsigned(T value, char *ptr) {
-		while (value >= 100) {
-			// Integer division is slow so do it for a group of two digits instead
-			// of for every digit. The idea comes from the talk by Alexandrescu
-			// "Three Optimization Tips for C++".
-			auto index = static_cast<unsigned>((value % 100) * 2);
-			value /= 100;
-			*--ptr = duckdb_fmt::internal::data::digits[index + 1];
-			*--ptr = duckdb_fmt::internal::data::digits[index];
-		}
-		if (value < 10) {
-			*--ptr = static_cast<char>('0' + value);
-			return ptr;
-		}
-		auto index = static_cast<unsigned>(value * 2);
-		*--ptr = duckdb_fmt::internal::data::digits[index + 1];
-		*--ptr = duckdb_fmt::internal::data::digits[index];
-		return ptr;
-	}
-
-	template <class SIGNED, class UNSIGNED>
-	static string_t FormatSigned(SIGNED value, Vector &vector) {
-		int sign = -(value < 0);
-		UNSIGNED unsigned_value = UNSIGNED(value ^ sign) - sign;
-		int length = UnsignedLength<UNSIGNED>(unsigned_value) - sign;
-		string_t result = StringVector::EmptyString(vector, length);
-		auto dataptr = result.GetDataWriteable();
-		auto endptr = dataptr + length;
-		endptr = FormatUnsigned(unsigned_value, endptr);
-		if (sign) {
-			*--endptr = '-';
-		}
-		result.Finalize();
-		return result;
-	}
-
-	template <class T>
-	static std::string ToString(T value) {
-		return std::to_string(value);
-	}
-};
-
-template <>
-int NumericHelper::UnsignedLength(uint8_t value);
-template <>
-int NumericHelper::UnsignedLength(uint16_t value);
-template <>
-int NumericHelper::UnsignedLength(uint32_t value);
-template <>
-int NumericHelper::UnsignedLength(uint64_t value);
-
-template <>
-std::string NumericHelper::ToString(hugeint_t value);
-
-struct DecimalToString {
-	template <class SIGNED, class UNSIGNED>
-	static int DecimalLength(SIGNED value, uint8_t scale) {
-		if (scale == 0) {
-			// scale is 0: regular number
-			return NumericHelper::SignedLength<SIGNED, UNSIGNED>(value);
-		}
-		// length is max of either:
-		// scale + 2 OR
-		// integer length + 1
-		// scale + 2 happens when the number is in the range of (-1, 1)
-		// in that case we print "0.XXX", which is the scale, plus "0." (2 chars)
-		// integer length + 1 happens when the number is outside of that range
-		// in that case we print the integer number, but with one extra character ('.')
-		return MaxValue(scale + 2 + (value < 0 ? 1 : 0), NumericHelper::SignedLength<SIGNED, UNSIGNED>(value) + 1);
-	}
-
-	template <class SIGNED, class UNSIGNED>
-	static void FormatDecimal(SIGNED value, uint8_t scale, char *dst, idx_t len) {
-		char *end = dst + len;
-		if (value < 0) {
-			value = -value;
-			*dst = '-';
-		}
-		if (scale == 0) {
-			NumericHelper::FormatUnsigned<UNSIGNED>(value, end);
-			return;
-		}
-		// we write two numbers:
-		// the numbers BEFORE the decimal (major)
-		// and the numbers AFTER the decimal (minor)
-		UNSIGNED minor = value % (UNSIGNED)NumericHelper::POWERS_OF_TEN[scale];
-		UNSIGNED major = value / (UNSIGNED)NumericHelper::POWERS_OF_TEN[scale];
-		// write the number after the decimal
-		dst = NumericHelper::FormatUnsigned<UNSIGNED>(minor, end);
-		// (optionally) pad with zeros and add the decimal point
-		while (dst > (end - scale)) {
-			*--dst = '0';
-		}
-		*--dst = '.';
-		// now write the part before the decimal
-		dst = NumericHelper::FormatUnsigned<UNSIGNED>(major, dst);
-	}
-
-	template <class SIGNED, class UNSIGNED>
-	static string_t Format(SIGNED value, uint8_t scale, Vector &vector) {
-		int len = DecimalLength<SIGNED, UNSIGNED>(value, scale);
-		string_t result = StringVector::EmptyString(vector, len);
-		FormatDecimal<SIGNED, UNSIGNED>(value, scale, result.GetDataWriteable(), len);
-		result.Finalize();
-		return result;
-	}
-};
-
-struct HugeintToStringCast {
-	static int UnsignedLength(hugeint_t value) {
-		D_ASSERT(value.upper >= 0);
-		if (value.upper == 0) {
-			return NumericHelper::UnsignedLength<uint64_t>(value.lower);
-		}
-		// search the length using the POWERS_OF_TEN array
-		// the length has to be between [17] and [38], because the hugeint is bigger than 2^63
-		// we use the same approach as above, but split a bit more because comparisons for hugeints are more expensive
-		if (value >= Hugeint::POWERS_OF_TEN[27]) {
-			// [27..38]
-			if (value >= Hugeint::POWERS_OF_TEN[32]) {
-				if (value >= Hugeint::POWERS_OF_TEN[36]) {
-					int length = 37;
-					length += value >= Hugeint::POWERS_OF_TEN[37];
-					length += value >= Hugeint::POWERS_OF_TEN[38];
-					return length;
-				} else {
-					int length = 33;
-					length += value >= Hugeint::POWERS_OF_TEN[33];
-					length += value >= Hugeint::POWERS_OF_TEN[34];
-					length += value >= Hugeint::POWERS_OF_TEN[35];
-					return length;
-				}
-			} else {
-				if (value >= Hugeint::POWERS_OF_TEN[30]) {
-					int length = 31;
-					length += value >= Hugeint::POWERS_OF_TEN[31];
-					length += value >= Hugeint::POWERS_OF_TEN[32];
-					return length;
-				} else {
-					int length = 28;
-					length += value >= Hugeint::POWERS_OF_TEN[28];
-					length += value >= Hugeint::POWERS_OF_TEN[29];
-					return length;
-				}
-			}
-		} else {
-			// [17..27]
-			if (value >= Hugeint::POWERS_OF_TEN[22]) {
-				// [22..27]
-				if (value >= Hugeint::POWERS_OF_TEN[25]) {
-					int length = 26;
-					length += value >= Hugeint::POWERS_OF_TEN[26];
-					return length;
-				} else {
-					int length = 23;
-					length += value >= Hugeint::POWERS_OF_TEN[23];
-					length += value >= Hugeint::POWERS_OF_TEN[24];
-					return length;
-				}
-			} else {
-				// [17..22]
-				if (value >= Hugeint::POWERS_OF_TEN[20]) {
-					int length = 21;
-					length += value >= Hugeint::POWERS_OF_TEN[21];
-					return length;
-				} else {
-					int length = 18;
-					length += value >= Hugeint::POWERS_OF_TEN[18];
-					length += value >= Hugeint::POWERS_OF_TEN[19];
-					return length;
-				}
-			}
-		}
-	}
-
-	// Formats value in reverse and returns a pointer to the beginning.
-	static char *FormatUnsigned(hugeint_t value, char *ptr) {
-		while (value.upper > 0) {
-			// while integer division is slow, hugeint division is MEGA slow
-			// we want to avoid doing as many divisions as possible
-			// for that reason we start off doing a division by a large power of ten that uint64_t can hold
-			// (100000000000000000) - this is the third largest
-			// the reason we don't use the largest is because that can result in an overflow inside the division
-			// function
-			uint64_t remainder;
-			value = Hugeint::DivModPositive(value, 100000000000000000ULL, remainder);
-
-			auto startptr = ptr;
-			// now we format the remainder: note that we need to pad with zero's in case
-			// the remainder is small (i.e. less than 10000000000000000)
-			ptr = NumericHelper::FormatUnsigned<uint64_t>(remainder, ptr);
-
-			int format_length = startptr - ptr;
-			// pad with zero
-			for (int i = format_length; i < 17; i++) {
-				*--ptr = '0';
-			}
-		}
-		// once the value falls in the range of a uint64_t, fallback to formatting as uint64_t to avoid hugeint division
-		return NumericHelper::FormatUnsigned<uint64_t>(value.lower, ptr);
-	}
-
-	static string_t FormatSigned(hugeint_t value, Vector &vector) {
-		int negative = value.upper < 0;
-		if (negative) {
-			Hugeint::NegateInPlace(value);
-		}
-		int length = UnsignedLength(value) + negative;
-		string_t result = StringVector::EmptyString(vector, length);
-		auto dataptr = result.GetDataWriteable();
-		auto endptr = dataptr + length;
-		if (value.upper == 0) {
-			// small value: format as uint64_t
-			endptr = NumericHelper::FormatUnsigned<uint64_t>(value.lower, endptr);
-		} else {
-			endptr = FormatUnsigned(value, endptr);
-		}
-		if (negative) {
-			*--endptr = '-';
-		}
-		D_ASSERT(endptr == dataptr);
-		result.Finalize();
-		return result;
-	}
-
-	static int DecimalLength(hugeint_t value, uint8_t scale) {
-		int negative;
-		if (value.upper < 0) {
-			Hugeint::NegateInPlace(value);
-			negative = 1;
-		} else {
-			negative = 0;
-		}
-		if (scale == 0) {
-			// scale is 0: regular number
-			return UnsignedLength(value) + negative;
-		}
-		// length is max of either:
-		// scale + 2 OR
-		// integer length + 1
-		// scale + 2 happens when the number is in the range of (-1, 1)
-		// in that case we print "0.XXX", which is the scale, plus "0." (2 chars)
-		// integer length + 1 happens when the number is outside of that range
-		// in that case we print the integer number, but with one extra character ('.')
-		return MaxValue(scale + 2, UnsignedLength(value) + 1) + negative;
-	}
-
-	static void FormatDecimal(hugeint_t value, uint8_t scale, char *dst, int len) {
-		auto endptr = dst + len;
-
-		int negative = value.upper < 0;
-		if (negative) {
-			Hugeint::NegateInPlace(value);
-			*dst = '-';
-			dst++;
-		}
-		if (scale == 0) {
-			// with scale=0 we format the number as a regular number
-			FormatUnsigned(value, endptr);
-			return;
-		}
-
-		// we write two numbers:
-		// the numbers BEFORE the decimal (major)
-		// and the numbers AFTER the decimal (minor)
-		hugeint_t minor;
-		hugeint_t major = Hugeint::DivMod(value, Hugeint::POWERS_OF_TEN[scale], minor);
-
-		// write the number after the decimal
-		dst = FormatUnsigned(minor, endptr);
-		// (optionally) pad with zeros and add the decimal point
-		while (dst > (endptr - scale)) {
-			*--dst = '0';
-		}
-		*--dst = '.';
-		// now write the part before the decimal
-		dst = FormatUnsigned(major, dst);
-	}
-
-	static string_t FormatDecimal(hugeint_t value, uint8_t scale, Vector &vector) {
-		int length = DecimalLength(value, scale);
-		string_t result = StringVector::EmptyString(vector, length);
-
-		auto dst = result.GetDataWriteable();
-
-		FormatDecimal(value, scale, dst, length);
-
-		result.Finalize();
-		return result;
-	}
-};
-
-struct DateToStringCast {
-	static idx_t Length(int32_t date[], idx_t &year_length, bool &add_bc) {
-		// format is YYYY-MM-DD with optional (BC) at the end
-		// regular length is 10
-		idx_t length = 6;
-		year_length = 4;
-		add_bc = false;
-		if (date[0] <= 0) {
-			// add (BC) suffix
-			length += 5;
-			date[0] = -date[0] + 1;
-			add_bc = true;
-		}
-
-		// potentially add extra characters depending on length of year
-		year_length += date[0] >= 10000;
-		year_length += date[0] >= 100000;
-		year_length += date[0] >= 1000000;
-		year_length += date[0] >= 10000000;
-		length += year_length;
-		return length;
-	}
-
-	static void Format(char *data, int32_t date[], idx_t year_length, bool add_bc) {
-		// now we write the string, first write the year
-		auto endptr = data + year_length;
-		endptr = NumericHelper::FormatUnsigned(date[0], endptr);
-		// add optional leading zeros
-		while (endptr > data) {
-			*--endptr = '0';
-		}
-		// now write the month and day
-		auto ptr = data + year_length;
-		for (int i = 1; i <= 2; i++) {
-			ptr[0] = '-';
-			if (date[i] < 10) {
-				ptr[1] = '0';
-				ptr[2] = '0' + date[i];
-			} else {
-				auto index = static_cast<unsigned>(date[i] * 2);
-				ptr[1] = duckdb_fmt::internal::data::digits[index];
-				ptr[2] = duckdb_fmt::internal::data::digits[index + 1];
-			}
-			ptr += 3;
-		}
-		// optionally add BC to the end of the date
-		if (add_bc) {
-			memcpy(ptr, " (BC)", 5);
-		}
-	}
-};
-
-struct TimeToStringCast {
-	//! Format microseconds to a buffer of length 6. Returns the number of trailing zeros
-	static int32_t FormatMicros(uint32_t microseconds, char micro_buffer[]) {
-		char *endptr = micro_buffer + 6;
-		endptr = NumericHelper::FormatUnsigned<uint32_t>(microseconds, endptr);
-		while (endptr > micro_buffer) {
-			*--endptr = '0';
-		}
-		idx_t trailing_zeros = 0;
-		for (idx_t i = 5; i > 0; i--) {
-			if (micro_buffer[i] != '0') {
-				break;
-			}
-			trailing_zeros++;
-		}
-		return trailing_zeros;
-	}
-
-	static idx_t Length(int32_t time[], char micro_buffer[]) {
-		// format is HH:MM:DD.MS
-		// microseconds come after the time with a period separator
-		idx_t length;
-		if (time[3] == 0) {
-			// no microseconds
-			// format is HH:MM:DD
-			length = 8;
-		} else {
-			length = 15;
-			// for microseconds, we truncate any trailing zeros (i.e. "90000" becomes ".9")
-			// first write the microseconds to the microsecond buffer
-			// we write backwards and pad with zeros to the left
-			// now we figure out how many digits we need to include by looking backwards
-			// and checking how many zeros we encounter
-			length -= FormatMicros(time[3], micro_buffer);
-		}
-		return length;
-	}
-
-	static void FormatTwoDigits(char *ptr, int32_t value) {
-		D_ASSERT(value >= 0 && value <= 99);
-		if (value < 10) {
-			ptr[0] = '0';
-			ptr[1] = '0' + value;
-		} else {
-			auto index = static_cast<unsigned>(value * 2);
-			ptr[0] = duckdb_fmt::internal::data::digits[index];
-			ptr[1] = duckdb_fmt::internal::data::digits[index + 1];
-		}
-	}
-
-	static void Format(char *data, idx_t length, int32_t time[], char micro_buffer[]) {
-		// first write hour, month and day
-		auto ptr = data;
-		ptr[2] = ':';
-		ptr[5] = ':';
-		for (int i = 0; i <= 2; i++) {
-			FormatTwoDigits(ptr, time[i]);
-			ptr += 3;
-		}
-		if (length > 8) {
-			// write the micro seconds at the end
-			data[8] = '.';
-			memcpy(data + 9, micro_buffer, length - 9);
-		}
-	}
-};
-
-struct IntervalToStringCast {
-	static void FormatSignedNumber(int64_t value, char buffer[], idx_t &length) {
-		int sign = -(value < 0);
-		uint64_t unsigned_value = (value ^ sign) - sign;
-		length += NumericHelper::UnsignedLength<uint64_t>(unsigned_value) - sign;
-		auto endptr = buffer + length;
-		endptr = NumericHelper::FormatUnsigned<uint64_t>(unsigned_value, endptr);
-		if (sign) {
-			*--endptr = '-';
-		}
-	}
-
-	static void FormatTwoDigits(int64_t value, char buffer[], idx_t &length) {
-		TimeToStringCast::FormatTwoDigits(buffer + length, value);
-		length += 2;
-	}
-
-	static void FormatIntervalValue(int32_t value, char buffer[], idx_t &length, const char *name, idx_t name_len) {
-		if (value == 0) {
-			return;
-		}
-		if (length != 0) {
-			// space if there is already something in the buffer
-			buffer[length++] = ' ';
-		}
-		FormatSignedNumber(value, buffer, length);
-		// append the name together with a potential "s" (for plurals)
-		memcpy(buffer + length, name, name_len);
-		length += name_len;
-		if (value != 1) {
-			buffer[length++] = 's';
-		}
-	}
-
-	//! Formats an interval to a buffer, the buffer should be >=70 characters
-	//! years: 17 characters (max value: "-2147483647 years")
-	//! months: 9 (max value: "12 months")
-	//! days: 16 characters (max value: "-2147483647 days")
-	//! time: 24 characters (max value: -2562047788:00:00.123456)
-	//! spaces between all characters (+3 characters)
-	//! Total: 70 characters
-	//! Returns the length of the interval
-	static idx_t Format(interval_t interval, char buffer[]) {
-		idx_t length = 0;
-		if (interval.months != 0) {
-			int32_t years = interval.months / 12;
-			int32_t months = interval.months - years * 12;
-			// format the years and months
-			FormatIntervalValue(years, buffer, length, " year", 5);
-			FormatIntervalValue(months, buffer, length, " month", 6);
-		}
-		if (interval.days != 0) {
-			// format the days
-			FormatIntervalValue(interval.days, buffer, length, " day", 4);
-		}
-		if (interval.micros != 0) {
-			if (length != 0) {
-				// space if there is already something in the buffer
-				buffer[length++] = ' ';
-			}
-			int64_t micros = interval.micros;
-			if (micros < 0) {
-				// negative time: append negative sign
-				buffer[length++] = '-';
-				micros = -micros;
-			}
-			int64_t hour = micros / Interval::MICROS_PER_HOUR;
-			micros -= hour * Interval::MICROS_PER_HOUR;
-			int64_t min = micros / Interval::MICROS_PER_MINUTE;
-			micros -= min * Interval::MICROS_PER_MINUTE;
-			int64_t sec = micros / Interval::MICROS_PER_SEC;
-			micros -= sec * Interval::MICROS_PER_SEC;
-
-			if (hour < 10) {
-				buffer[length++] = '0';
-			}
-			FormatSignedNumber(hour, buffer, length);
-			buffer[length++] = ':';
-			FormatTwoDigits(min, buffer, length);
-			buffer[length++] = ':';
-			FormatTwoDigits(sec, buffer, length);
-			if (micros != 0) {
-				buffer[length++] = '.';
-				auto trailing_zeros = TimeToStringCast::FormatMicros(micros, buffer + length);
-				length += 6 - trailing_zeros;
-			}
-		} else if (length == 0) {
-			// empty interval: default to 00:00:00
-			memcpy(buffer, "00:00:00", 8);
-			return 8;
-		}
-		return length;
-	}
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
-// See the end of this file for a list
-
-// duckdb_fast_float by Daniel Lemire
-// duckdb_fast_float by João Paulo Magalhaes
-
-
-// with contributions from Eugene Golushkov
-// with contributions from Maksim Kita
-// with contributions from Marcin Wojdyr
-// with contributions from Neal Richardson
-// with contributions from Tim Paine
-// with contributions from Fabio Pellacini
-
-
-// Permission is hereby granted, free of charge, to any
-// person obtaining a copy of this software and associated
-// documentation files (the "Software"), to deal in the
-// Software without restriction, including without
-// limitation the rights to use, copy, modify, merge,
-// publish, distribute, sublicense, and/or sell copies of
-// the Software, and to permit persons to whom the Software
-// is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice
-// shall be included in all copies or substantial portions
-// of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-// DEALINGS IN THE SOFTWARE.
-
-
-#ifndef FASTFLOAT_FAST_FLOAT_H
-#define FASTFLOAT_FAST_FLOAT_H
-
-#include <system_error>
-
-namespace duckdb_fast_float {
-enum chars_format {
-    scientific = 1<<0,
-    fixed = 1<<2,
-    hex = 1<<3,
-    general = fixed | scientific
-};
-
-
-struct from_chars_result {
-  const char *ptr;
-  std::errc ec;
-};
-
-/**
- * This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting
- * a locale-indepent format equivalent to what is used by std::strtod in the default ("C") locale.
- * The resulting floating-point value is the closest floating-point values (using either float or double),
- * using the "round to even" convention for values that would otherwise fall right in-between two values.
- * That is, we provide exact parsing according to the IEEE standard.
- *
- * Given a successful parse, the pointer (`ptr`) in the returned value is set to point right after the
- * parsed number, and the `value` referenced is set to the parsed value. In case of error, the returned
- * `ec` contains a representative error, otherwise the default (`std::errc()`) value is stored.
- *
- * The implementation does not throw and does not allocate memory (e.g., with `new` or `malloc`).
- *
- * Like the C++17 standard, the `duckdb_fast_float::from_chars` functions take an optional last argument of
- * the type `duckdb_fast_float::chars_format`. It is a bitset value: we check whether
- * `fmt & duckdb_fast_float::chars_format::fixed` and `fmt & duckdb_fast_float::chars_format::scientific` are set
- * to determine whether we allowe the fixed point and scientific notation respectively.
- * The default is  `duckdb_fast_float::chars_format::general` which allows both `fixed` and `scientific`.
- */
-template<typename T>
-from_chars_result from_chars(const char *first, const char *last,
-                             T &value, chars_format fmt = chars_format::general)  noexcept;
-
-}
-#endif // FASTFLOAT_FAST_FLOAT_H
-
-#ifndef FASTFLOAT_FLOAT_COMMON_H
-#define FASTFLOAT_FLOAT_COMMON_H
-
-#include <cfloat>
-#include <cstdint>
-#include <cassert>
-
-#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)   \
-       || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \
-       || defined(__MINGW64__)                                          \
-       || defined(__s390x__)                                            \
-       || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) \
-       || defined(__EMSCRIPTEN__))
-#define FASTFLOAT_64BIT
-#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86)   \
-     || defined(__arm__) || defined(_M_ARM)                   \
-     || defined(__MINGW32__))
-#define FASTFLOAT_32BIT
-#else
-  // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow.
-  // We can never tell the register width, but the SIZE_MAX is a good approximation.
-  // UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max portability.
-  #if SIZE_MAX == 0xffff
-    #error Unknown platform (16-bit, unsupported)
-  #elif SIZE_MAX == 0xffffffff
-    #define FASTFLOAT_32BIT
-  #elif SIZE_MAX == 0xffffffffffffffff
-    #define FASTFLOAT_64BIT
-  #else
-    #error Unknown platform (not 32-bit, not 64-bit?)
-  #endif
-#endif
-
-#if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__))
-#include <intrin.h>
-#endif
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#define FASTFLOAT_VISUAL_STUDIO 1
-#endif
-
-#ifdef _WIN32
-#define FASTFLOAT_IS_BIG_ENDIAN 0
-#else
-#if defined(__APPLE__) || defined(__FreeBSD__)
-#include <machine/endian.h>
-#elif defined(sun) || defined(__sun)
-#include <sys/byteorder.h>
-#else
-#include <endian.h>
-#endif
-#
-#ifndef __BYTE_ORDER__
-// safe choice
-#define FASTFLOAT_IS_BIG_ENDIAN 0
-#endif
-#
-#ifndef __ORDER_LITTLE_ENDIAN__
-// safe choice
-#define FASTFLOAT_IS_BIG_ENDIAN 0
-#endif
-#
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define FASTFLOAT_IS_BIG_ENDIAN 0
-#else
-#define FASTFLOAT_IS_BIG_ENDIAN 1
-#endif
-#endif
-
-#ifdef FASTFLOAT_VISUAL_STUDIO
-#define fastfloat_really_inline __forceinline
-#else
-#define fastfloat_really_inline inline __attribute__((always_inline))
-#endif
-
-namespace duckdb_fast_float {
-
-// Compares two ASCII strings in a case insensitive manner.
-inline bool fastfloat_strncasecmp(const char *input1, const char *input2,
-                                  size_t length) {
-  char running_diff{0};
-  for (size_t i = 0; i < length; i++) {
-    running_diff |= (input1[i] ^ input2[i]);
-  }
-  return (running_diff == 0) || (running_diff == 32);
-}
-
-#ifndef FLT_EVAL_METHOD
-#error "FLT_EVAL_METHOD should be defined, please include cfloat."
-#endif
-
-namespace {
-constexpr uint32_t max_digits = 768;
-constexpr uint32_t max_digit_without_overflow = 19;
-constexpr int32_t decimal_point_range = 2047;
-} // namespace
-
-struct value128 {
-  uint64_t low;
-  uint64_t high;
-  value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
-  value128() : low(0), high(0) {}
-};
-
-/* result might be undefined when input_num is zero */
-fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
-  assert(input_num > 0);
-#ifdef FASTFLOAT_VISUAL_STUDIO
-  #if defined(_M_X64) || defined(_M_ARM64)
-  unsigned long leading_zero = 0;
-  // Search the mask data from most significant bit (MSB)
-  // to least significant bit (LSB) for a set bit (1).
-  _BitScanReverse64(&leading_zero, input_num);
-  return (int)(63 - leading_zero);
-  #else
-  int last_bit = 0;
-  if(input_num & uint64_t(0xffffffff00000000)) input_num >>= 32, last_bit |= 32;
-  if(input_num & uint64_t(        0xffff0000)) input_num >>= 16, last_bit |= 16;
-  if(input_num & uint64_t(            0xff00)) input_num >>=  8, last_bit |=  8;
-  if(input_num & uint64_t(              0xf0)) input_num >>=  4, last_bit |=  4;
-  if(input_num & uint64_t(               0xc)) input_num >>=  2, last_bit |=  2;
-  if(input_num & uint64_t(               0x2)) input_num >>=  1, last_bit |=  1;
-  return 63 - last_bit;
-  #endif
-#else
-  return __builtin_clzll(input_num);
-#endif
-}
-
-#ifdef FASTFLOAT_32BIT
-
-// slow emulation routine for 32-bit
-fastfloat_really_inline uint64_t emulu(uint32_t x, uint32_t y) {
-    return x * (uint64_t)y;
-}
-
-// slow emulation routine for 32-bit
-#if !defined(__MINGW64__)
-fastfloat_really_inline uint64_t _umul128(uint64_t ab, uint64_t cd,
-                                          uint64_t *hi) {
-  uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
-  uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
-  uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
-  uint64_t adbc_carry = !!(adbc < ad);
-  uint64_t lo = bd + (adbc << 32);
-  *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
-        (adbc_carry << 32) + !!(lo < bd);
-  return lo;
-}
-#endif // !__MINGW64__
-
-#endif // FASTFLOAT_32BIT
-
-
-// compute 64-bit a*b
-fastfloat_really_inline value128 full_multiplication(uint64_t a,
-                                                     uint64_t b) {
-  value128 answer;
-#ifdef _M_ARM64
-  // ARM64 has native support for 64-bit multiplications, no need to emulate
-  answer.high = __umulh(a, b);
-  answer.low = a * b;
-#elif defined(FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__))
-  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
-#elif defined(FASTFLOAT_64BIT)
-  __uint128_t r = ((__uint128_t)a) * b;
-  answer.low = uint64_t(r);
-  answer.high = uint64_t(r >> 64);
-#else
-  #error Not implemented
-#endif
-  return answer;
-}
-
-
-struct adjusted_mantissa {
-  uint64_t mantissa{0};
-  int power2{0}; // a negative value indicates an invalid result
-  adjusted_mantissa() = default;
-  bool operator==(const adjusted_mantissa &o) const {
-    return mantissa == o.mantissa && power2 == o.power2;
-  }
-  bool operator!=(const adjusted_mantissa &o) const {
-    return mantissa != o.mantissa || power2 != o.power2;
-  }
-};
-
-struct decimal {
-  uint32_t num_digits{0};
-  int32_t decimal_point{0};
-  bool negative{false};
-  bool truncated{false};
-  uint8_t digits[max_digits];
-  decimal() = default;
-  // Copies are not allowed since this is a fat object.
-  decimal(const decimal &) = delete;
-  // Copies are not allowed since this is a fat object.
-  decimal &operator=(const decimal &) = delete;
-  // Moves are allowed:
-  decimal(decimal &&) = default;
-  decimal &operator=(decimal &&other) = default;
-};
-
-constexpr static double powers_of_ten_double[] = {
-    1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
-    1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
-constexpr static float powers_of_ten_float[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
-                                                1e6, 1e7, 1e8, 1e9, 1e10};
-
-template <typename T> struct binary_format {
-  static inline constexpr int mantissa_explicit_bits();
-  static inline constexpr int minimum_exponent();
-  static inline constexpr int infinite_power();
-  static inline constexpr int sign_index();
-  static inline constexpr int min_exponent_fast_path();
-  static inline constexpr int max_exponent_fast_path();
-  static inline constexpr int max_exponent_round_to_even();
-  static inline constexpr int min_exponent_round_to_even();
-  static inline constexpr uint64_t max_mantissa_fast_path();
-  static inline constexpr int largest_power_of_ten();
-  static inline constexpr int smallest_power_of_ten();
-  static inline constexpr T exact_power_of_ten(int64_t power);
-};
-
-template <> inline constexpr int binary_format<double>::mantissa_explicit_bits() {
-  return 52;
-}
-template <> inline constexpr int binary_format<float>::mantissa_explicit_bits() {
-  return 23;
-}
-
-template <> inline constexpr int binary_format<double>::max_exponent_round_to_even() {
-  return 23;
-}
-
-template <> inline constexpr int binary_format<float>::max_exponent_round_to_even() {
-  return 10;
-}
-
-template <> inline constexpr int binary_format<double>::min_exponent_round_to_even() {
-  return -4;
-}
-
-template <> inline constexpr int binary_format<float>::min_exponent_round_to_even() {
-  return -17;
-}
-
-template <> inline constexpr int binary_format<double>::minimum_exponent() {
-  return -1023;
-}
-template <> inline constexpr int binary_format<float>::minimum_exponent() {
-  return -127;
-}
-
-template <> inline constexpr int binary_format<double>::infinite_power() {
-  return 0x7FF;
-}
-template <> inline constexpr int binary_format<float>::infinite_power() {
-  return 0xFF;
-}
-
-template <> inline constexpr int binary_format<double>::sign_index() { return 63; }
-template <> inline constexpr int binary_format<float>::sign_index() { return 31; }
-
-template <> inline constexpr int binary_format<double>::min_exponent_fast_path() {
-#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
-  return 0;
-#else
-  return -22;
-#endif
-}
-template <> inline constexpr int binary_format<float>::min_exponent_fast_path() {
-#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
-  return 0;
-#else
-  return -10;
-#endif
-}
-
-template <> inline constexpr int binary_format<double>::max_exponent_fast_path() {
-  return 22;
-}
-template <> inline constexpr int binary_format<float>::max_exponent_fast_path() {
-  return 10;
-}
-
-template <> inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
-  return uint64_t(2) << mantissa_explicit_bits();
-}
-template <> inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
-  return uint64_t(2) << mantissa_explicit_bits();
-}
-
-template <>
-inline constexpr double binary_format<double>::exact_power_of_ten(int64_t power) {
-  return powers_of_ten_double[power];
-}
-template <>
-inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
-
-  return powers_of_ten_float[power];
-}
-
-
-template <>
-inline constexpr int binary_format<double>::largest_power_of_ten() {
-  return 308;
-}
-template <>
-inline constexpr int binary_format<float>::largest_power_of_ten() {
-  return 38;
-}
-
-template <>
-inline constexpr int binary_format<double>::smallest_power_of_ten() {
-  return -342;
-}
-template <>
-inline constexpr int binary_format<float>::smallest_power_of_ten() {
-  return -65;
-}
-
-} // namespace duckdb_fast_float
-
-// for convenience:
-template<class OStream>
-inline OStream& operator<<(OStream &out, const duckdb_fast_float::decimal &d) {
-  out << "0.";
-  for (size_t i = 0; i < d.num_digits; i++) {
-    out << int32_t(d.digits[i]);
-  }
-  out << " * 10 ** " << d.decimal_point;
-  return out;
-}
-
-#endif
-
-
-#ifndef FASTFLOAT_ASCII_NUMBER_H
-#define FASTFLOAT_ASCII_NUMBER_H
-
-#include <cstdio>
-#include <cctype>
-#include <cstdint>
-#include <cstring>
-
-
-namespace duckdb_fast_float {
-
-// Next function can be micro-optimized, but compilers are entirely
-// able to optimize it well.
-fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
-
-fastfloat_really_inline uint64_t byteswap(uint64_t val) {
-  return (val & 0xFF00000000000000) >> 56
-    | (val & 0x00FF000000000000) >> 40
-    | (val & 0x0000FF0000000000) >> 24
-    | (val & 0x000000FF00000000) >> 8
-    | (val & 0x00000000FF000000) << 8
-    | (val & 0x0000000000FF0000) << 24
-    | (val & 0x000000000000FF00) << 40
-    | (val & 0x00000000000000FF) << 56;
-}
-
-fastfloat_really_inline uint64_t read_u64(const char *chars) {
-  uint64_t val;
-  ::memcpy(&val, chars, sizeof(uint64_t));
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-  // Need to read as-if the number was in little-endian order.
-  val = byteswap(val);
-#endif
-  return val;
-}
-
-fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-  // Need to read as-if the number was in little-endian order.
-  val = byteswap(val);
-#endif
-  ::memcpy(chars, &val, sizeof(uint64_t));
-}
-
-// credit  @aqrit
-fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
-  const uint64_t mask = 0x000000FF000000FF;
-  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
-  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
-  val -= 0x3030303030303030;
-  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
-  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
-  return uint32_t(val);
-}
-
-fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
-  return parse_eight_digits_unrolled(read_u64(chars));
-}
-
-// credit @aqrit
-fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
-  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
-     0x8080808080808080));
-}
-
-fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
-  return is_made_of_eight_digits_fast(read_u64(chars));
-}
-
-struct parsed_number_string {
-  int64_t exponent;
-  uint64_t mantissa;
-  const char *lastmatch;
-  bool negative;
-  bool valid;
-  bool too_many_digits;
-};
-
-
-// Assuming that you use no more than 19 digits, this will
-// parse an ASCII string.
-fastfloat_really_inline
-parsed_number_string parse_number_string(const char *p, const char *pend, chars_format fmt) noexcept {
-  parsed_number_string answer;
-  answer.valid = false;
-  answer.too_many_digits = false;
-  answer.negative = (*p == '-');
-  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
-    ++p;
-    if (p == pend) {
-      return answer;
-    }
-    if (!is_integer(*p) && (*p != '.')) { // a  sign must be followed by an integer or the dot
-      return answer;
-    }
-  }
-  const char *const start_digits = p;
-
-  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
-
-  while ((p != pend) && is_integer(*p)) {
-    // a multiplication by 10 is cheaper than an arbitrary integer
-    // multiplication
-    i = 10 * i +
-        uint64_t(*p - '0'); // might overflow, we will handle the overflow later
-    ++p;
-  }
-  const char *const end_of_integer_part = p;
-  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
-  int64_t exponent = 0;
-  if ((p != pend) && (*p == '.')) {
-    ++p;
-  // Fast approach only tested under little endian systems
-  if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-    i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-    p += 8;
-    if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-      p += 8;
-    }
-  }
-    while ((p != pend) && is_integer(*p)) {
-      uint8_t digit = uint8_t(*p - '0');
-      ++p;
-      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
-    }
-    exponent = end_of_integer_part + 1 - p;
-    digit_count -= exponent;
-  }
-  // we must have encountered at least one integer!
-  if (digit_count == 0) {
-    return answer;
-  }
-  int64_t exp_number = 0;            // explicit exponential part
-  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
-    const char * location_of_e = p;
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
-      ++p;
-    }
-    if ((p == pend) || !is_integer(*p)) {
-      if(!(fmt & chars_format::fixed)) {
-        // We are in error.
-        return answer;
-      }
-      // Otherwise, we will be ignoring the 'e'.
-      p = location_of_e;
-    } else {
-      while ((p != pend) && is_integer(*p)) {
-        uint8_t digit = uint8_t(*p - '0');
-        if (exp_number < 0x10000) {
-          exp_number = 10 * exp_number + digit;
-        }
-        ++p;
-      }
-      if(neg_exp) { exp_number = - exp_number; }
-      exponent += exp_number;
-    }
-  } else {
-    // If it scientific and not fixed, we have to bail out.
-    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
-  }
-  answer.lastmatch = p;
-  answer.valid = true;
-
-  // If we frequently had to deal with long strings of digits,
-  // we could extend our code by using a 128-bit integer instead
-  // of a 64-bit integer. However, this is uncommon.
-  //
-  // We can deal with up to 19 digits.
-  if (digit_count > 19) { // this is uncommon
-    // It is possible that the integer had an overflow.
-    // We have to handle the case where we have 0.0000somenumber.
-    // We need to be mindful of the case where we only have zeroes...
-    // E.g., 0.000000000...000.
-    const char *start = start_digits;
-    while ((start != pend) && (*start == '0' || *start == '.')) {
-      if(*start == '0') { digit_count --; }
-      start++;
-    }
-    if (digit_count > 19) {
-      answer.too_many_digits = true;
-      // Let us start again, this time, avoiding overflows.
-      i = 0;
-      p = start_digits;
-      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
-      while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
-        i = i * 10 + uint64_t(*p - '0');
-        ++p;
-      }
-      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
-        exponent = end_of_integer_part - p + exp_number;
-      } else { // We have a value with a fractional component.
-          p++; // skip the '.'
-          const char *first_after_period = p;
-          while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
-            i = i * 10 + uint64_t(*p - '0');
-            ++p;
-          }
-          exponent = first_after_period - p + exp_number;
-      }
-      // We have now corrected both exponent and i, to a truncated value
-    }
-  }
-  answer.exponent = exponent;
-  answer.mantissa = i;
-  return answer;
-}
-
-
-// This should always succeed since it follows a call to parse_number_string
-// This function could be optimized. In particular, we could stop after 19 digits
-// and try to bail out. Furthermore, we should be able to recover the computed
-// exponent from the pass in parse_number_string.
-fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) noexcept {
-  decimal answer;
-  answer.num_digits = 0;
-  answer.decimal_point = 0;
-  answer.truncated = false;
-  answer.negative = (*p == '-');
-  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
-    ++p;
-  }
-  // skip leading zeroes
-  while ((p != pend) && (*p == '0')) {
-    ++p;
-  }
-  while ((p != pend) && is_integer(*p)) {
-    if (answer.num_digits < max_digits) {
-      answer.digits[answer.num_digits] = uint8_t(*p - '0');
-    }
-    answer.num_digits++;
-    ++p;
-  }
-  if ((p != pend) && (*p == '.')) {
-    ++p;
-    const char *first_after_period = p;
-    // if we have not yet encountered a zero, we have to skip it as well
-    if(answer.num_digits == 0) {
-      // skip zeros
-      while ((p != pend) && (*p == '0')) {
-       ++p;
-      }
-    }
-    // We expect that this loop will often take the bulk of the running time
-    // because when a value has lots of digits, these digits often
-    while ((p + 8 <= pend) && (answer.num_digits + 8 < max_digits)) {
-      uint64_t val = read_u64(p);
-      if(! is_made_of_eight_digits_fast(val)) { break; }
-      // We have eight digits, process them in one go!
-      val -= 0x3030303030303030;
-      write_u64(answer.digits + answer.num_digits, val);
-      answer.num_digits += 8;
-      p += 8;
-    }
-    while ((p != pend) && is_integer(*p)) {
-      if (answer.num_digits < max_digits) {
-        answer.digits[answer.num_digits] = uint8_t(*p - '0');
-      }
-      answer.num_digits++;
-      ++p;
-    }
-    answer.decimal_point = int32_t(first_after_period - p);
-  }
-  // We want num_digits to be the number of significant digits, excluding
-  // leading *and* trailing zeros! Otherwise the truncated flag later is
-  // going to be misleading.
-  if(answer.num_digits > 0) {
-    // We potentially need the answer.num_digits > 0 guard because we
-    // prune leading zeros. So with answer.num_digits > 0, we know that
-    // we have at least one non-zero digit.
-    const char *preverse = p - 1;
-    int32_t trailing_zeros = 0;
-    while ((*preverse == '0') || (*preverse == '.')) {
-      if(*preverse == '0') { trailing_zeros++; };
-      --preverse;
-    }
-    answer.decimal_point += int32_t(answer.num_digits);
-    answer.num_digits -= uint32_t(trailing_zeros);
-  }
-  if(answer.num_digits > max_digits) {
-    answer.truncated = true;
-    answer.num_digits = max_digits;
-  }
-  if ((p != pend) && (('e' == *p) || ('E' == *p))) {
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
-      ++p;
-    }
-    int32_t exp_number = 0; // exponential part
-    while ((p != pend) && is_integer(*p)) {
-      uint8_t digit = uint8_t(*p - '0');
-      if (exp_number < 0x10000) {
-        exp_number = 10 * exp_number + digit;
-      }
-      ++p;
-    }
-    answer.decimal_point += (neg_exp ? -exp_number : exp_number);
-  }
-  // In very rare cases, we may have fewer than 19 digits, we want to be able to reliably
-  // assume that all digits up to max_digit_without_overflow have been initialized.
-  for(uint32_t i = answer.num_digits; i < max_digit_without_overflow; i++) { answer.digits[i] = 0; }
-
-  return answer;
-}
-} // namespace duckdb_fast_float
-
-#endif
-
-
-#ifndef FASTFLOAT_FAST_TABLE_H
-#define FASTFLOAT_FAST_TABLE_H
-#include <cstdint>
-
-namespace duckdb_fast_float {
-
-/**
- * When mapping numbers from decimal to binary,
- * we go from w * 10^q to m * 2^p but we have
- * 10^q = 5^q * 2^q, so effectively
- * we are trying to match
- * w * 2^q * 5^q to m * 2^p. Thus the powers of two
- * are not a concern since they can be represented
- * exactly using the binary notation, only the powers of five
- * affect the binary significand.
- */
-
-/**
- * The smallest non-zero float (binary64) is 2^−1074.
- * We take as input numbers of the form w x 10^q where w < 2^64.
- * We have that w * 10^-343  <  2^(64-344) 5^-343 < 2^-1076.
- * However, we have that
- * (2^64-1) * 10^-342 =  (2^64-1) * 2^-342 * 5^-342 > 2^−1074.
- * Thus it is possible for a number of the form w * 10^-342 where
- * w is a 64-bit value to be a non-zero floating-point number.
- *********
- * Any number of form w * 10^309 where w>= 1 is going to be
- * infinite in binary64 so we never need to worry about powers
- * of 5 greater than 308.
- */
-template <class unused = void>
-struct powers_template {
-
-constexpr static int smallest_power_of_five = binary_format<double>::smallest_power_of_ten();
-constexpr static int largest_power_of_five = binary_format<double>::largest_power_of_ten();
-constexpr static int number_of_entries = 2 * (largest_power_of_five - smallest_power_of_five + 1);
-// Powers of five from 5^-342 all the way to 5^308 rounded toward one.
-static const uint64_t power_of_five_128[number_of_entries];
-};
-
-template <class unused>
-const uint64_t powers_template<unused>::power_of_five_128[number_of_entries] = {
-        0xeef453d6923bd65a,0x113faa2906a13b3f,
-        0x9558b4661b6565f8,0x4ac7ca59a424c507,
-        0xbaaee17fa23ebf76,0x5d79bcf00d2df649,
-        0xe95a99df8ace6f53,0xf4d82c2c107973dc,
-        0x91d8a02bb6c10594,0x79071b9b8a4be869,
-        0xb64ec836a47146f9,0x9748e2826cdee284,
-        0xe3e27a444d8d98b7,0xfd1b1b2308169b25,
-        0x8e6d8c6ab0787f72,0xfe30f0f5e50e20f7,
-        0xb208ef855c969f4f,0xbdbd2d335e51a935,
-        0xde8b2b66b3bc4723,0xad2c788035e61382,
-        0x8b16fb203055ac76,0x4c3bcb5021afcc31,
-        0xaddcb9e83c6b1793,0xdf4abe242a1bbf3d,
-        0xd953e8624b85dd78,0xd71d6dad34a2af0d,
-        0x87d4713d6f33aa6b,0x8672648c40e5ad68,
-        0xa9c98d8ccb009506,0x680efdaf511f18c2,
-        0xd43bf0effdc0ba48,0x212bd1b2566def2,
-        0x84a57695fe98746d,0x14bb630f7604b57,
-        0xa5ced43b7e3e9188,0x419ea3bd35385e2d,
-        0xcf42894a5dce35ea,0x52064cac828675b9,
-        0x818995ce7aa0e1b2,0x7343efebd1940993,
-        0xa1ebfb4219491a1f,0x1014ebe6c5f90bf8,
-        0xca66fa129f9b60a6,0xd41a26e077774ef6,
-        0xfd00b897478238d0,0x8920b098955522b4,
-        0x9e20735e8cb16382,0x55b46e5f5d5535b0,
-        0xc5a890362fddbc62,0xeb2189f734aa831d,
-        0xf712b443bbd52b7b,0xa5e9ec7501d523e4,
-        0x9a6bb0aa55653b2d,0x47b233c92125366e,
-        0xc1069cd4eabe89f8,0x999ec0bb696e840a,
-        0xf148440a256e2c76,0xc00670ea43ca250d,
-        0x96cd2a865764dbca,0x380406926a5e5728,
-        0xbc807527ed3e12bc,0xc605083704f5ecf2,
-        0xeba09271e88d976b,0xf7864a44c633682e,
-        0x93445b8731587ea3,0x7ab3ee6afbe0211d,
-        0xb8157268fdae9e4c,0x5960ea05bad82964,
-        0xe61acf033d1a45df,0x6fb92487298e33bd,
-        0x8fd0c16206306bab,0xa5d3b6d479f8e056,
-        0xb3c4f1ba87bc8696,0x8f48a4899877186c,
-        0xe0b62e2929aba83c,0x331acdabfe94de87,
-        0x8c71dcd9ba0b4925,0x9ff0c08b7f1d0b14,
-        0xaf8e5410288e1b6f,0x7ecf0ae5ee44dd9,
-        0xdb71e91432b1a24a,0xc9e82cd9f69d6150,
-        0x892731ac9faf056e,0xbe311c083a225cd2,
-        0xab70fe17c79ac6ca,0x6dbd630a48aaf406,
-        0xd64d3d9db981787d,0x92cbbccdad5b108,
-        0x85f0468293f0eb4e,0x25bbf56008c58ea5,
-        0xa76c582338ed2621,0xaf2af2b80af6f24e,
-        0xd1476e2c07286faa,0x1af5af660db4aee1,
-        0x82cca4db847945ca,0x50d98d9fc890ed4d,
-        0xa37fce126597973c,0xe50ff107bab528a0,
-        0xcc5fc196fefd7d0c,0x1e53ed49a96272c8,
-        0xff77b1fcbebcdc4f,0x25e8e89c13bb0f7a,
-        0x9faacf3df73609b1,0x77b191618c54e9ac,
-        0xc795830d75038c1d,0xd59df5b9ef6a2417,
-        0xf97ae3d0d2446f25,0x4b0573286b44ad1d,
-        0x9becce62836ac577,0x4ee367f9430aec32,
-        0xc2e801fb244576d5,0x229c41f793cda73f,
-        0xf3a20279ed56d48a,0x6b43527578c1110f,
-        0x9845418c345644d6,0x830a13896b78aaa9,
-        0xbe5691ef416bd60c,0x23cc986bc656d553,
-        0xedec366b11c6cb8f,0x2cbfbe86b7ec8aa8,
-        0x94b3a202eb1c3f39,0x7bf7d71432f3d6a9,
-        0xb9e08a83a5e34f07,0xdaf5ccd93fb0cc53,
-        0xe858ad248f5c22c9,0xd1b3400f8f9cff68,
-        0x91376c36d99995be,0x23100809b9c21fa1,
-        0xb58547448ffffb2d,0xabd40a0c2832a78a,
-        0xe2e69915b3fff9f9,0x16c90c8f323f516c,
-        0x8dd01fad907ffc3b,0xae3da7d97f6792e3,
-        0xb1442798f49ffb4a,0x99cd11cfdf41779c,
-        0xdd95317f31c7fa1d,0x40405643d711d583,
-        0x8a7d3eef7f1cfc52,0x482835ea666b2572,
-        0xad1c8eab5ee43b66,0xda3243650005eecf,
-        0xd863b256369d4a40,0x90bed43e40076a82,
-        0x873e4f75e2224e68,0x5a7744a6e804a291,
-        0xa90de3535aaae202,0x711515d0a205cb36,
-        0xd3515c2831559a83,0xd5a5b44ca873e03,
-        0x8412d9991ed58091,0xe858790afe9486c2,
-        0xa5178fff668ae0b6,0x626e974dbe39a872,
-        0xce5d73ff402d98e3,0xfb0a3d212dc8128f,
-        0x80fa687f881c7f8e,0x7ce66634bc9d0b99,
-        0xa139029f6a239f72,0x1c1fffc1ebc44e80,
-        0xc987434744ac874e,0xa327ffb266b56220,
-        0xfbe9141915d7a922,0x4bf1ff9f0062baa8,
-        0x9d71ac8fada6c9b5,0x6f773fc3603db4a9,
-        0xc4ce17b399107c22,0xcb550fb4384d21d3,
-        0xf6019da07f549b2b,0x7e2a53a146606a48,
-        0x99c102844f94e0fb,0x2eda7444cbfc426d,
-        0xc0314325637a1939,0xfa911155fefb5308,
-        0xf03d93eebc589f88,0x793555ab7eba27ca,
-        0x96267c7535b763b5,0x4bc1558b2f3458de,
-        0xbbb01b9283253ca2,0x9eb1aaedfb016f16,
-        0xea9c227723ee8bcb,0x465e15a979c1cadc,
-        0x92a1958a7675175f,0xbfacd89ec191ec9,
-        0xb749faed14125d36,0xcef980ec671f667b,
-        0xe51c79a85916f484,0x82b7e12780e7401a,
-        0x8f31cc0937ae58d2,0xd1b2ecb8b0908810,
-        0xb2fe3f0b8599ef07,0x861fa7e6dcb4aa15,
-        0xdfbdcece67006ac9,0x67a791e093e1d49a,
-        0x8bd6a141006042bd,0xe0c8bb2c5c6d24e0,
-        0xaecc49914078536d,0x58fae9f773886e18,
-        0xda7f5bf590966848,0xaf39a475506a899e,
-        0x888f99797a5e012d,0x6d8406c952429603,
-        0xaab37fd7d8f58178,0xc8e5087ba6d33b83,
-        0xd5605fcdcf32e1d6,0xfb1e4a9a90880a64,
-        0x855c3be0a17fcd26,0x5cf2eea09a55067f,
-        0xa6b34ad8c9dfc06f,0xf42faa48c0ea481e,
-        0xd0601d8efc57b08b,0xf13b94daf124da26,
-        0x823c12795db6ce57,0x76c53d08d6b70858,
-        0xa2cb1717b52481ed,0x54768c4b0c64ca6e,
-        0xcb7ddcdda26da268,0xa9942f5dcf7dfd09,
-        0xfe5d54150b090b02,0xd3f93b35435d7c4c,
-        0x9efa548d26e5a6e1,0xc47bc5014a1a6daf,
-        0xc6b8e9b0709f109a,0x359ab6419ca1091b,
-        0xf867241c8cc6d4c0,0xc30163d203c94b62,
-        0x9b407691d7fc44f8,0x79e0de63425dcf1d,
-        0xc21094364dfb5636,0x985915fc12f542e4,
-        0xf294b943e17a2bc4,0x3e6f5b7b17b2939d,
-        0x979cf3ca6cec5b5a,0xa705992ceecf9c42,
-        0xbd8430bd08277231,0x50c6ff782a838353,
-        0xece53cec4a314ebd,0xa4f8bf5635246428,
-        0x940f4613ae5ed136,0x871b7795e136be99,
-        0xb913179899f68584,0x28e2557b59846e3f,
-        0xe757dd7ec07426e5,0x331aeada2fe589cf,
-        0x9096ea6f3848984f,0x3ff0d2c85def7621,
-        0xb4bca50b065abe63,0xfed077a756b53a9,
-        0xe1ebce4dc7f16dfb,0xd3e8495912c62894,
-        0x8d3360f09cf6e4bd,0x64712dd7abbbd95c,
-        0xb080392cc4349dec,0xbd8d794d96aacfb3,
-        0xdca04777f541c567,0xecf0d7a0fc5583a0,
-        0x89e42caaf9491b60,0xf41686c49db57244,
-        0xac5d37d5b79b6239,0x311c2875c522ced5,
-        0xd77485cb25823ac7,0x7d633293366b828b,
-        0x86a8d39ef77164bc,0xae5dff9c02033197,
-        0xa8530886b54dbdeb,0xd9f57f830283fdfc,
-        0xd267caa862a12d66,0xd072df63c324fd7b,
-        0x8380dea93da4bc60,0x4247cb9e59f71e6d,
-        0xa46116538d0deb78,0x52d9be85f074e608,
-        0xcd795be870516656,0x67902e276c921f8b,
-        0x806bd9714632dff6,0xba1cd8a3db53b6,
-        0xa086cfcd97bf97f3,0x80e8a40eccd228a4,
-        0xc8a883c0fdaf7df0,0x6122cd128006b2cd,
-        0xfad2a4b13d1b5d6c,0x796b805720085f81,
-        0x9cc3a6eec6311a63,0xcbe3303674053bb0,
-        0xc3f490aa77bd60fc,0xbedbfc4411068a9c,
-        0xf4f1b4d515acb93b,0xee92fb5515482d44,
-        0x991711052d8bf3c5,0x751bdd152d4d1c4a,
-        0xbf5cd54678eef0b6,0xd262d45a78a0635d,
-        0xef340a98172aace4,0x86fb897116c87c34,
-        0x9580869f0e7aac0e,0xd45d35e6ae3d4da0,
-        0xbae0a846d2195712,0x8974836059cca109,
-        0xe998d258869facd7,0x2bd1a438703fc94b,
-        0x91ff83775423cc06,0x7b6306a34627ddcf,
-        0xb67f6455292cbf08,0x1a3bc84c17b1d542,
-        0xe41f3d6a7377eeca,0x20caba5f1d9e4a93,
-        0x8e938662882af53e,0x547eb47b7282ee9c,
-        0xb23867fb2a35b28d,0xe99e619a4f23aa43,
-        0xdec681f9f4c31f31,0x6405fa00e2ec94d4,
-        0x8b3c113c38f9f37e,0xde83bc408dd3dd04,
-        0xae0b158b4738705e,0x9624ab50b148d445,
-        0xd98ddaee19068c76,0x3badd624dd9b0957,
-        0x87f8a8d4cfa417c9,0xe54ca5d70a80e5d6,
-        0xa9f6d30a038d1dbc,0x5e9fcf4ccd211f4c,
-        0xd47487cc8470652b,0x7647c3200069671f,
-        0x84c8d4dfd2c63f3b,0x29ecd9f40041e073,
-        0xa5fb0a17c777cf09,0xf468107100525890,
-        0xcf79cc9db955c2cc,0x7182148d4066eeb4,
-        0x81ac1fe293d599bf,0xc6f14cd848405530,
-        0xa21727db38cb002f,0xb8ada00e5a506a7c,
-        0xca9cf1d206fdc03b,0xa6d90811f0e4851c,
-        0xfd442e4688bd304a,0x908f4a166d1da663,
-        0x9e4a9cec15763e2e,0x9a598e4e043287fe,
-        0xc5dd44271ad3cdba,0x40eff1e1853f29fd,
-        0xf7549530e188c128,0xd12bee59e68ef47c,
-        0x9a94dd3e8cf578b9,0x82bb74f8301958ce,
-        0xc13a148e3032d6e7,0xe36a52363c1faf01,
-        0xf18899b1bc3f8ca1,0xdc44e6c3cb279ac1,
-        0x96f5600f15a7b7e5,0x29ab103a5ef8c0b9,
-        0xbcb2b812db11a5de,0x7415d448f6b6f0e7,
-        0xebdf661791d60f56,0x111b495b3464ad21,
-        0x936b9fcebb25c995,0xcab10dd900beec34,
-        0xb84687c269ef3bfb,0x3d5d514f40eea742,
-        0xe65829b3046b0afa,0xcb4a5a3112a5112,
-        0x8ff71a0fe2c2e6dc,0x47f0e785eaba72ab,
-        0xb3f4e093db73a093,0x59ed216765690f56,
-        0xe0f218b8d25088b8,0x306869c13ec3532c,
-        0x8c974f7383725573,0x1e414218c73a13fb,
-        0xafbd2350644eeacf,0xe5d1929ef90898fa,
-        0xdbac6c247d62a583,0xdf45f746b74abf39,
-        0x894bc396ce5da772,0x6b8bba8c328eb783,
-        0xab9eb47c81f5114f,0x66ea92f3f326564,
-        0xd686619ba27255a2,0xc80a537b0efefebd,
-        0x8613fd0145877585,0xbd06742ce95f5f36,
-        0xa798fc4196e952e7,0x2c48113823b73704,
-        0xd17f3b51fca3a7a0,0xf75a15862ca504c5,
-        0x82ef85133de648c4,0x9a984d73dbe722fb,
-        0xa3ab66580d5fdaf5,0xc13e60d0d2e0ebba,
-        0xcc963fee10b7d1b3,0x318df905079926a8,
-        0xffbbcfe994e5c61f,0xfdf17746497f7052,
-        0x9fd561f1fd0f9bd3,0xfeb6ea8bedefa633,
-        0xc7caba6e7c5382c8,0xfe64a52ee96b8fc0,
-        0xf9bd690a1b68637b,0x3dfdce7aa3c673b0,
-        0x9c1661a651213e2d,0x6bea10ca65c084e,
-        0xc31bfa0fe5698db8,0x486e494fcff30a62,
-        0xf3e2f893dec3f126,0x5a89dba3c3efccfa,
-        0x986ddb5c6b3a76b7,0xf89629465a75e01c,
-        0xbe89523386091465,0xf6bbb397f1135823,
-        0xee2ba6c0678b597f,0x746aa07ded582e2c,
-        0x94db483840b717ef,0xa8c2a44eb4571cdc,
-        0xba121a4650e4ddeb,0x92f34d62616ce413,
-        0xe896a0d7e51e1566,0x77b020baf9c81d17,
-        0x915e2486ef32cd60,0xace1474dc1d122e,
-        0xb5b5ada8aaff80b8,0xd819992132456ba,
-        0xe3231912d5bf60e6,0x10e1fff697ed6c69,
-        0x8df5efabc5979c8f,0xca8d3ffa1ef463c1,
-        0xb1736b96b6fd83b3,0xbd308ff8a6b17cb2,
-        0xddd0467c64bce4a0,0xac7cb3f6d05ddbde,
-        0x8aa22c0dbef60ee4,0x6bcdf07a423aa96b,
-        0xad4ab7112eb3929d,0x86c16c98d2c953c6,
-        0xd89d64d57a607744,0xe871c7bf077ba8b7,
-        0x87625f056c7c4a8b,0x11471cd764ad4972,
-        0xa93af6c6c79b5d2d,0xd598e40d3dd89bcf,
-        0xd389b47879823479,0x4aff1d108d4ec2c3,
-        0x843610cb4bf160cb,0xcedf722a585139ba,
-        0xa54394fe1eedb8fe,0xc2974eb4ee658828,
-        0xce947a3da6a9273e,0x733d226229feea32,
-        0x811ccc668829b887,0x806357d5a3f525f,
-        0xa163ff802a3426a8,0xca07c2dcb0cf26f7,
-        0xc9bcff6034c13052,0xfc89b393dd02f0b5,
-        0xfc2c3f3841f17c67,0xbbac2078d443ace2,
-        0x9d9ba7832936edc0,0xd54b944b84aa4c0d,
-        0xc5029163f384a931,0xa9e795e65d4df11,
-        0xf64335bcf065d37d,0x4d4617b5ff4a16d5,
-        0x99ea0196163fa42e,0x504bced1bf8e4e45,
-        0xc06481fb9bcf8d39,0xe45ec2862f71e1d6,
-        0xf07da27a82c37088,0x5d767327bb4e5a4c,
-        0x964e858c91ba2655,0x3a6a07f8d510f86f,
-        0xbbe226efb628afea,0x890489f70a55368b,
-        0xeadab0aba3b2dbe5,0x2b45ac74ccea842e,
-        0x92c8ae6b464fc96f,0x3b0b8bc90012929d,
-        0xb77ada0617e3bbcb,0x9ce6ebb40173744,
-        0xe55990879ddcaabd,0xcc420a6a101d0515,
-        0x8f57fa54c2a9eab6,0x9fa946824a12232d,
-        0xb32df8e9f3546564,0x47939822dc96abf9,
-        0xdff9772470297ebd,0x59787e2b93bc56f7,
-        0x8bfbea76c619ef36,0x57eb4edb3c55b65a,
-        0xaefae51477a06b03,0xede622920b6b23f1,
-        0xdab99e59958885c4,0xe95fab368e45eced,
-        0x88b402f7fd75539b,0x11dbcb0218ebb414,
-        0xaae103b5fcd2a881,0xd652bdc29f26a119,
-        0xd59944a37c0752a2,0x4be76d3346f0495f,
-        0x857fcae62d8493a5,0x6f70a4400c562ddb,
-        0xa6dfbd9fb8e5b88e,0xcb4ccd500f6bb952,
-        0xd097ad07a71f26b2,0x7e2000a41346a7a7,
-        0x825ecc24c873782f,0x8ed400668c0c28c8,
-        0xa2f67f2dfa90563b,0x728900802f0f32fa,
-        0xcbb41ef979346bca,0x4f2b40a03ad2ffb9,
-        0xfea126b7d78186bc,0xe2f610c84987bfa8,
-        0x9f24b832e6b0f436,0xdd9ca7d2df4d7c9,
-        0xc6ede63fa05d3143,0x91503d1c79720dbb,
-        0xf8a95fcf88747d94,0x75a44c6397ce912a,
-        0x9b69dbe1b548ce7c,0xc986afbe3ee11aba,
-        0xc24452da229b021b,0xfbe85badce996168,
-        0xf2d56790ab41c2a2,0xfae27299423fb9c3,
-        0x97c560ba6b0919a5,0xdccd879fc967d41a,
-        0xbdb6b8e905cb600f,0x5400e987bbc1c920,
-        0xed246723473e3813,0x290123e9aab23b68,
-        0x9436c0760c86e30b,0xf9a0b6720aaf6521,
-        0xb94470938fa89bce,0xf808e40e8d5b3e69,
-        0xe7958cb87392c2c2,0xb60b1d1230b20e04,
-        0x90bd77f3483bb9b9,0xb1c6f22b5e6f48c2,
-        0xb4ecd5f01a4aa828,0x1e38aeb6360b1af3,
-        0xe2280b6c20dd5232,0x25c6da63c38de1b0,
-        0x8d590723948a535f,0x579c487e5a38ad0e,
-        0xb0af48ec79ace837,0x2d835a9df0c6d851,
-        0xdcdb1b2798182244,0xf8e431456cf88e65,
-        0x8a08f0f8bf0f156b,0x1b8e9ecb641b58ff,
-        0xac8b2d36eed2dac5,0xe272467e3d222f3f,
-        0xd7adf884aa879177,0x5b0ed81dcc6abb0f,
-        0x86ccbb52ea94baea,0x98e947129fc2b4e9,
-        0xa87fea27a539e9a5,0x3f2398d747b36224,
-        0xd29fe4b18e88640e,0x8eec7f0d19a03aad,
-        0x83a3eeeef9153e89,0x1953cf68300424ac,
-        0xa48ceaaab75a8e2b,0x5fa8c3423c052dd7,
-        0xcdb02555653131b6,0x3792f412cb06794d,
-        0x808e17555f3ebf11,0xe2bbd88bbee40bd0,
-        0xa0b19d2ab70e6ed6,0x5b6aceaeae9d0ec4,
-        0xc8de047564d20a8b,0xf245825a5a445275,
-        0xfb158592be068d2e,0xeed6e2f0f0d56712,
-        0x9ced737bb6c4183d,0x55464dd69685606b,
-        0xc428d05aa4751e4c,0xaa97e14c3c26b886,
-        0xf53304714d9265df,0xd53dd99f4b3066a8,
-        0x993fe2c6d07b7fab,0xe546a8038efe4029,
-        0xbf8fdb78849a5f96,0xde98520472bdd033,
-        0xef73d256a5c0f77c,0x963e66858f6d4440,
-        0x95a8637627989aad,0xdde7001379a44aa8,
-        0xbb127c53b17ec159,0x5560c018580d5d52,
-        0xe9d71b689dde71af,0xaab8f01e6e10b4a6,
-        0x9226712162ab070d,0xcab3961304ca70e8,
-        0xb6b00d69bb55c8d1,0x3d607b97c5fd0d22,
-        0xe45c10c42a2b3b05,0x8cb89a7db77c506a,
-        0x8eb98a7a9a5b04e3,0x77f3608e92adb242,
-        0xb267ed1940f1c61c,0x55f038b237591ed3,
-        0xdf01e85f912e37a3,0x6b6c46dec52f6688,
-        0x8b61313bbabce2c6,0x2323ac4b3b3da015,
-        0xae397d8aa96c1b77,0xabec975e0a0d081a,
-        0xd9c7dced53c72255,0x96e7bd358c904a21,
-        0x881cea14545c7575,0x7e50d64177da2e54,
-        0xaa242499697392d2,0xdde50bd1d5d0b9e9,
-        0xd4ad2dbfc3d07787,0x955e4ec64b44e864,
-        0x84ec3c97da624ab4,0xbd5af13bef0b113e,
-        0xa6274bbdd0fadd61,0xecb1ad8aeacdd58e,
-        0xcfb11ead453994ba,0x67de18eda5814af2,
-        0x81ceb32c4b43fcf4,0x80eacf948770ced7,
-        0xa2425ff75e14fc31,0xa1258379a94d028d,
-        0xcad2f7f5359a3b3e,0x96ee45813a04330,
-        0xfd87b5f28300ca0d,0x8bca9d6e188853fc,
-        0x9e74d1b791e07e48,0x775ea264cf55347e,
-        0xc612062576589dda,0x95364afe032a819e,
-        0xf79687aed3eec551,0x3a83ddbd83f52205,
-        0x9abe14cd44753b52,0xc4926a9672793543,
-        0xc16d9a0095928a27,0x75b7053c0f178294,
-        0xf1c90080baf72cb1,0x5324c68b12dd6339,
-        0x971da05074da7bee,0xd3f6fc16ebca5e04,
-        0xbce5086492111aea,0x88f4bb1ca6bcf585,
-        0xec1e4a7db69561a5,0x2b31e9e3d06c32e6,
-        0x9392ee8e921d5d07,0x3aff322e62439fd0,
-        0xb877aa3236a4b449,0x9befeb9fad487c3,
-        0xe69594bec44de15b,0x4c2ebe687989a9b4,
-        0x901d7cf73ab0acd9,0xf9d37014bf60a11,
-        0xb424dc35095cd80f,0x538484c19ef38c95,
-        0xe12e13424bb40e13,0x2865a5f206b06fba,
-        0x8cbccc096f5088cb,0xf93f87b7442e45d4,
-        0xafebff0bcb24aafe,0xf78f69a51539d749,
-        0xdbe6fecebdedd5be,0xb573440e5a884d1c,
-        0x89705f4136b4a597,0x31680a88f8953031,
-        0xabcc77118461cefc,0xfdc20d2b36ba7c3e,
-        0xd6bf94d5e57a42bc,0x3d32907604691b4d,
-        0x8637bd05af6c69b5,0xa63f9a49c2c1b110,
-        0xa7c5ac471b478423,0xfcf80dc33721d54,
-        0xd1b71758e219652b,0xd3c36113404ea4a9,
-        0x83126e978d4fdf3b,0x645a1cac083126ea,
-        0xa3d70a3d70a3d70a,0x3d70a3d70a3d70a4,
-        0xcccccccccccccccc,0xcccccccccccccccd,
-        0x8000000000000000,0x0,
-        0xa000000000000000,0x0,
-        0xc800000000000000,0x0,
-        0xfa00000000000000,0x0,
-        0x9c40000000000000,0x0,
-        0xc350000000000000,0x0,
-        0xf424000000000000,0x0,
-        0x9896800000000000,0x0,
-        0xbebc200000000000,0x0,
-        0xee6b280000000000,0x0,
-        0x9502f90000000000,0x0,
-        0xba43b74000000000,0x0,
-        0xe8d4a51000000000,0x0,
-        0x9184e72a00000000,0x0,
-        0xb5e620f480000000,0x0,
-        0xe35fa931a0000000,0x0,
-        0x8e1bc9bf04000000,0x0,
-        0xb1a2bc2ec5000000,0x0,
-        0xde0b6b3a76400000,0x0,
-        0x8ac7230489e80000,0x0,
-        0xad78ebc5ac620000,0x0,
-        0xd8d726b7177a8000,0x0,
-        0x878678326eac9000,0x0,
-        0xa968163f0a57b400,0x0,
-        0xd3c21bcecceda100,0x0,
-        0x84595161401484a0,0x0,
-        0xa56fa5b99019a5c8,0x0,
-        0xcecb8f27f4200f3a,0x0,
-        0x813f3978f8940984,0x4000000000000000,
-        0xa18f07d736b90be5,0x5000000000000000,
-        0xc9f2c9cd04674ede,0xa400000000000000,
-        0xfc6f7c4045812296,0x4d00000000000000,
-        0x9dc5ada82b70b59d,0xf020000000000000,
-        0xc5371912364ce305,0x6c28000000000000,
-        0xf684df56c3e01bc6,0xc732000000000000,
-        0x9a130b963a6c115c,0x3c7f400000000000,
-        0xc097ce7bc90715b3,0x4b9f100000000000,
-        0xf0bdc21abb48db20,0x1e86d40000000000,
-        0x96769950b50d88f4,0x1314448000000000,
-        0xbc143fa4e250eb31,0x17d955a000000000,
-        0xeb194f8e1ae525fd,0x5dcfab0800000000,
-        0x92efd1b8d0cf37be,0x5aa1cae500000000,
-        0xb7abc627050305ad,0xf14a3d9e40000000,
-        0xe596b7b0c643c719,0x6d9ccd05d0000000,
-        0x8f7e32ce7bea5c6f,0xe4820023a2000000,
-        0xb35dbf821ae4f38b,0xdda2802c8a800000,
-        0xe0352f62a19e306e,0xd50b2037ad200000,
-        0x8c213d9da502de45,0x4526f422cc340000,
-        0xaf298d050e4395d6,0x9670b12b7f410000,
-        0xdaf3f04651d47b4c,0x3c0cdd765f114000,
-        0x88d8762bf324cd0f,0xa5880a69fb6ac800,
-        0xab0e93b6efee0053,0x8eea0d047a457a00,
-        0xd5d238a4abe98068,0x72a4904598d6d880,
-        0x85a36366eb71f041,0x47a6da2b7f864750,
-        0xa70c3c40a64e6c51,0x999090b65f67d924,
-        0xd0cf4b50cfe20765,0xfff4b4e3f741cf6d,
-        0x82818f1281ed449f,0xbff8f10e7a8921a4,
-        0xa321f2d7226895c7,0xaff72d52192b6a0d,
-        0xcbea6f8ceb02bb39,0x9bf4f8a69f764490,
-        0xfee50b7025c36a08,0x2f236d04753d5b4,
-        0x9f4f2726179a2245,0x1d762422c946590,
-        0xc722f0ef9d80aad6,0x424d3ad2b7b97ef5,
-        0xf8ebad2b84e0d58b,0xd2e0898765a7deb2,
-        0x9b934c3b330c8577,0x63cc55f49f88eb2f,
-        0xc2781f49ffcfa6d5,0x3cbf6b71c76b25fb,
-        0xf316271c7fc3908a,0x8bef464e3945ef7a,
-        0x97edd871cfda3a56,0x97758bf0e3cbb5ac,
-        0xbde94e8e43d0c8ec,0x3d52eeed1cbea317,
-        0xed63a231d4c4fb27,0x4ca7aaa863ee4bdd,
-        0x945e455f24fb1cf8,0x8fe8caa93e74ef6a,
-        0xb975d6b6ee39e436,0xb3e2fd538e122b44,
-        0xe7d34c64a9c85d44,0x60dbbca87196b616,
-        0x90e40fbeea1d3a4a,0xbc8955e946fe31cd,
-        0xb51d13aea4a488dd,0x6babab6398bdbe41,
-        0xe264589a4dcdab14,0xc696963c7eed2dd1,
-        0x8d7eb76070a08aec,0xfc1e1de5cf543ca2,
-        0xb0de65388cc8ada8,0x3b25a55f43294bcb,
-        0xdd15fe86affad912,0x49ef0eb713f39ebe,
-        0x8a2dbf142dfcc7ab,0x6e3569326c784337,
-        0xacb92ed9397bf996,0x49c2c37f07965404,
-        0xd7e77a8f87daf7fb,0xdc33745ec97be906,
-        0x86f0ac99b4e8dafd,0x69a028bb3ded71a3,
-        0xa8acd7c0222311bc,0xc40832ea0d68ce0c,
-        0xd2d80db02aabd62b,0xf50a3fa490c30190,
-        0x83c7088e1aab65db,0x792667c6da79e0fa,
-        0xa4b8cab1a1563f52,0x577001b891185938,
-        0xcde6fd5e09abcf26,0xed4c0226b55e6f86,
-        0x80b05e5ac60b6178,0x544f8158315b05b4,
-        0xa0dc75f1778e39d6,0x696361ae3db1c721,
-        0xc913936dd571c84c,0x3bc3a19cd1e38e9,
-        0xfb5878494ace3a5f,0x4ab48a04065c723,
-        0x9d174b2dcec0e47b,0x62eb0d64283f9c76,
-        0xc45d1df942711d9a,0x3ba5d0bd324f8394,
-        0xf5746577930d6500,0xca8f44ec7ee36479,
-        0x9968bf6abbe85f20,0x7e998b13cf4e1ecb,
-        0xbfc2ef456ae276e8,0x9e3fedd8c321a67e,
-        0xefb3ab16c59b14a2,0xc5cfe94ef3ea101e,
-        0x95d04aee3b80ece5,0xbba1f1d158724a12,
-        0xbb445da9ca61281f,0x2a8a6e45ae8edc97,
-        0xea1575143cf97226,0xf52d09d71a3293bd,
-        0x924d692ca61be758,0x593c2626705f9c56,
-        0xb6e0c377cfa2e12e,0x6f8b2fb00c77836c,
-        0xe498f455c38b997a,0xb6dfb9c0f956447,
-        0x8edf98b59a373fec,0x4724bd4189bd5eac,
-        0xb2977ee300c50fe7,0x58edec91ec2cb657,
-        0xdf3d5e9bc0f653e1,0x2f2967b66737e3ed,
-        0x8b865b215899f46c,0xbd79e0d20082ee74,
-        0xae67f1e9aec07187,0xecd8590680a3aa11,
-        0xda01ee641a708de9,0xe80e6f4820cc9495,
-        0x884134fe908658b2,0x3109058d147fdcdd,
-        0xaa51823e34a7eede,0xbd4b46f0599fd415,
-        0xd4e5e2cdc1d1ea96,0x6c9e18ac7007c91a,
-        0x850fadc09923329e,0x3e2cf6bc604ddb0,
-        0xa6539930bf6bff45,0x84db8346b786151c,
-        0xcfe87f7cef46ff16,0xe612641865679a63,
-        0x81f14fae158c5f6e,0x4fcb7e8f3f60c07e,
-        0xa26da3999aef7749,0xe3be5e330f38f09d,
-        0xcb090c8001ab551c,0x5cadf5bfd3072cc5,
-        0xfdcb4fa002162a63,0x73d9732fc7c8f7f6,
-        0x9e9f11c4014dda7e,0x2867e7fddcdd9afa,
-        0xc646d63501a1511d,0xb281e1fd541501b8,
-        0xf7d88bc24209a565,0x1f225a7ca91a4226,
-        0x9ae757596946075f,0x3375788de9b06958,
-        0xc1a12d2fc3978937,0x52d6b1641c83ae,
-        0xf209787bb47d6b84,0xc0678c5dbd23a49a,
-        0x9745eb4d50ce6332,0xf840b7ba963646e0,
-        0xbd176620a501fbff,0xb650e5a93bc3d898,
-        0xec5d3fa8ce427aff,0xa3e51f138ab4cebe,
-        0x93ba47c980e98cdf,0xc66f336c36b10137,
-        0xb8a8d9bbe123f017,0xb80b0047445d4184,
-        0xe6d3102ad96cec1d,0xa60dc059157491e5,
-        0x9043ea1ac7e41392,0x87c89837ad68db2f,
-        0xb454e4a179dd1877,0x29babe4598c311fb,
-        0xe16a1dc9d8545e94,0xf4296dd6fef3d67a,
-        0x8ce2529e2734bb1d,0x1899e4a65f58660c,
-        0xb01ae745b101e9e4,0x5ec05dcff72e7f8f,
-        0xdc21a1171d42645d,0x76707543f4fa1f73,
-        0x899504ae72497eba,0x6a06494a791c53a8,
-        0xabfa45da0edbde69,0x487db9d17636892,
-        0xd6f8d7509292d603,0x45a9d2845d3c42b6,
-        0x865b86925b9bc5c2,0xb8a2392ba45a9b2,
-        0xa7f26836f282b732,0x8e6cac7768d7141e,
-        0xd1ef0244af2364ff,0x3207d795430cd926,
-        0x8335616aed761f1f,0x7f44e6bd49e807b8,
-        0xa402b9c5a8d3a6e7,0x5f16206c9c6209a6,
-        0xcd036837130890a1,0x36dba887c37a8c0f,
-        0x802221226be55a64,0xc2494954da2c9789,
-        0xa02aa96b06deb0fd,0xf2db9baa10b7bd6c,
-        0xc83553c5c8965d3d,0x6f92829494e5acc7,
-        0xfa42a8b73abbf48c,0xcb772339ba1f17f9,
-        0x9c69a97284b578d7,0xff2a760414536efb,
-        0xc38413cf25e2d70d,0xfef5138519684aba,
-        0xf46518c2ef5b8cd1,0x7eb258665fc25d69,
-        0x98bf2f79d5993802,0xef2f773ffbd97a61,
-        0xbeeefb584aff8603,0xaafb550ffacfd8fa,
-        0xeeaaba2e5dbf6784,0x95ba2a53f983cf38,
-        0x952ab45cfa97a0b2,0xdd945a747bf26183,
-        0xba756174393d88df,0x94f971119aeef9e4,
-        0xe912b9d1478ceb17,0x7a37cd5601aab85d,
-        0x91abb422ccb812ee,0xac62e055c10ab33a,
-        0xb616a12b7fe617aa,0x577b986b314d6009,
-        0xe39c49765fdf9d94,0xed5a7e85fda0b80b,
-        0x8e41ade9fbebc27d,0x14588f13be847307,
-        0xb1d219647ae6b31c,0x596eb2d8ae258fc8,
-        0xde469fbd99a05fe3,0x6fca5f8ed9aef3bb,
-        0x8aec23d680043bee,0x25de7bb9480d5854,
-        0xada72ccc20054ae9,0xaf561aa79a10ae6a,
-        0xd910f7ff28069da4,0x1b2ba1518094da04,
-        0x87aa9aff79042286,0x90fb44d2f05d0842,
-        0xa99541bf57452b28,0x353a1607ac744a53,
-        0xd3fa922f2d1675f2,0x42889b8997915ce8,
-        0x847c9b5d7c2e09b7,0x69956135febada11,
-        0xa59bc234db398c25,0x43fab9837e699095,
-        0xcf02b2c21207ef2e,0x94f967e45e03f4bb,
-        0x8161afb94b44f57d,0x1d1be0eebac278f5,
-        0xa1ba1ba79e1632dc,0x6462d92a69731732,
-        0xca28a291859bbf93,0x7d7b8f7503cfdcfe,
-        0xfcb2cb35e702af78,0x5cda735244c3d43e,
-        0x9defbf01b061adab,0x3a0888136afa64a7,
-        0xc56baec21c7a1916,0x88aaa1845b8fdd0,
-        0xf6c69a72a3989f5b,0x8aad549e57273d45,
-        0x9a3c2087a63f6399,0x36ac54e2f678864b,
-        0xc0cb28a98fcf3c7f,0x84576a1bb416a7dd,
-        0xf0fdf2d3f3c30b9f,0x656d44a2a11c51d5,
-        0x969eb7c47859e743,0x9f644ae5a4b1b325,
-        0xbc4665b596706114,0x873d5d9f0dde1fee,
-        0xeb57ff22fc0c7959,0xa90cb506d155a7ea,
-        0x9316ff75dd87cbd8,0x9a7f12442d588f2,
-        0xb7dcbf5354e9bece,0xc11ed6d538aeb2f,
-        0xe5d3ef282a242e81,0x8f1668c8a86da5fa,
-        0x8fa475791a569d10,0xf96e017d694487bc,
-        0xb38d92d760ec4455,0x37c981dcc395a9ac,
-        0xe070f78d3927556a,0x85bbe253f47b1417,
-        0x8c469ab843b89562,0x93956d7478ccec8e,
-        0xaf58416654a6babb,0x387ac8d1970027b2,
-        0xdb2e51bfe9d0696a,0x6997b05fcc0319e,
-        0x88fcf317f22241e2,0x441fece3bdf81f03,
-        0xab3c2fddeeaad25a,0xd527e81cad7626c3,
-        0xd60b3bd56a5586f1,0x8a71e223d8d3b074,
-        0x85c7056562757456,0xf6872d5667844e49,
-        0xa738c6bebb12d16c,0xb428f8ac016561db,
-        0xd106f86e69d785c7,0xe13336d701beba52,
-        0x82a45b450226b39c,0xecc0024661173473,
-        0xa34d721642b06084,0x27f002d7f95d0190,
-        0xcc20ce9bd35c78a5,0x31ec038df7b441f4,
-        0xff290242c83396ce,0x7e67047175a15271,
-        0x9f79a169bd203e41,0xf0062c6e984d386,
-        0xc75809c42c684dd1,0x52c07b78a3e60868,
-        0xf92e0c3537826145,0xa7709a56ccdf8a82,
-        0x9bbcc7a142b17ccb,0x88a66076400bb691,
-        0xc2abf989935ddbfe,0x6acff893d00ea435,
-        0xf356f7ebf83552fe,0x583f6b8c4124d43,
-        0x98165af37b2153de,0xc3727a337a8b704a,
-        0xbe1bf1b059e9a8d6,0x744f18c0592e4c5c,
-        0xeda2ee1c7064130c,0x1162def06f79df73,
-        0x9485d4d1c63e8be7,0x8addcb5645ac2ba8,
-        0xb9a74a0637ce2ee1,0x6d953e2bd7173692,
-        0xe8111c87c5c1ba99,0xc8fa8db6ccdd0437,
-        0x910ab1d4db9914a0,0x1d9c9892400a22a2,
-        0xb54d5e4a127f59c8,0x2503beb6d00cab4b,
-        0xe2a0b5dc971f303a,0x2e44ae64840fd61d,
-        0x8da471a9de737e24,0x5ceaecfed289e5d2,
-        0xb10d8e1456105dad,0x7425a83e872c5f47,
-        0xdd50f1996b947518,0xd12f124e28f77719,
-        0x8a5296ffe33cc92f,0x82bd6b70d99aaa6f,
-        0xace73cbfdc0bfb7b,0x636cc64d1001550b,
-        0xd8210befd30efa5a,0x3c47f7e05401aa4e,
-        0x8714a775e3e95c78,0x65acfaec34810a71,
-        0xa8d9d1535ce3b396,0x7f1839a741a14d0d,
-        0xd31045a8341ca07c,0x1ede48111209a050,
-        0x83ea2b892091e44d,0x934aed0aab460432,
-        0xa4e4b66b68b65d60,0xf81da84d5617853f,
-        0xce1de40642e3f4b9,0x36251260ab9d668e,
-        0x80d2ae83e9ce78f3,0xc1d72b7c6b426019,
-        0xa1075a24e4421730,0xb24cf65b8612f81f,
-        0xc94930ae1d529cfc,0xdee033f26797b627,
-        0xfb9b7cd9a4a7443c,0x169840ef017da3b1,
-        0x9d412e0806e88aa5,0x8e1f289560ee864e,
-        0xc491798a08a2ad4e,0xf1a6f2bab92a27e2,
-        0xf5b5d7ec8acb58a2,0xae10af696774b1db,
-        0x9991a6f3d6bf1765,0xacca6da1e0a8ef29,
-        0xbff610b0cc6edd3f,0x17fd090a58d32af3,
-        0xeff394dcff8a948e,0xddfc4b4cef07f5b0,
-        0x95f83d0a1fb69cd9,0x4abdaf101564f98e,
-        0xbb764c4ca7a4440f,0x9d6d1ad41abe37f1,
-        0xea53df5fd18d5513,0x84c86189216dc5ed,
-        0x92746b9be2f8552c,0x32fd3cf5b4e49bb4,
-        0xb7118682dbb66a77,0x3fbc8c33221dc2a1,
-        0xe4d5e82392a40515,0xfabaf3feaa5334a,
-        0x8f05b1163ba6832d,0x29cb4d87f2a7400e,
-        0xb2c71d5bca9023f8,0x743e20e9ef511012,
-        0xdf78e4b2bd342cf6,0x914da9246b255416,
-        0x8bab8eefb6409c1a,0x1ad089b6c2f7548e,
-        0xae9672aba3d0c320,0xa184ac2473b529b1,
-        0xda3c0f568cc4f3e8,0xc9e5d72d90a2741e,
-        0x8865899617fb1871,0x7e2fa67c7a658892,
-        0xaa7eebfb9df9de8d,0xddbb901b98feeab7,
-        0xd51ea6fa85785631,0x552a74227f3ea565,
-        0x8533285c936b35de,0xd53a88958f87275f,
-        0xa67ff273b8460356,0x8a892abaf368f137,
-        0xd01fef10a657842c,0x2d2b7569b0432d85,
-        0x8213f56a67f6b29b,0x9c3b29620e29fc73,
-        0xa298f2c501f45f42,0x8349f3ba91b47b8f,
-        0xcb3f2f7642717713,0x241c70a936219a73,
-        0xfe0efb53d30dd4d7,0xed238cd383aa0110,
-        0x9ec95d1463e8a506,0xf4363804324a40aa,
-        0xc67bb4597ce2ce48,0xb143c6053edcd0d5,
-        0xf81aa16fdc1b81da,0xdd94b7868e94050a,
-        0x9b10a4e5e9913128,0xca7cf2b4191c8326,
-        0xc1d4ce1f63f57d72,0xfd1c2f611f63a3f0,
-        0xf24a01a73cf2dccf,0xbc633b39673c8cec,
-        0x976e41088617ca01,0xd5be0503e085d813,
-        0xbd49d14aa79dbc82,0x4b2d8644d8a74e18,
-        0xec9c459d51852ba2,0xddf8e7d60ed1219e,
-        0x93e1ab8252f33b45,0xcabb90e5c942b503,
-        0xb8da1662e7b00a17,0x3d6a751f3b936243,
-        0xe7109bfba19c0c9d,0xcc512670a783ad4,
-        0x906a617d450187e2,0x27fb2b80668b24c5,
-        0xb484f9dc9641e9da,0xb1f9f660802dedf6,
-        0xe1a63853bbd26451,0x5e7873f8a0396973,
-        0x8d07e33455637eb2,0xdb0b487b6423e1e8,
-        0xb049dc016abc5e5f,0x91ce1a9a3d2cda62,
-        0xdc5c5301c56b75f7,0x7641a140cc7810fb,
-        0x89b9b3e11b6329ba,0xa9e904c87fcb0a9d,
-        0xac2820d9623bf429,0x546345fa9fbdcd44,
-        0xd732290fbacaf133,0xa97c177947ad4095,
-        0x867f59a9d4bed6c0,0x49ed8eabcccc485d,
-        0xa81f301449ee8c70,0x5c68f256bfff5a74,
-        0xd226fc195c6a2f8c,0x73832eec6fff3111,
-        0x83585d8fd9c25db7,0xc831fd53c5ff7eab,
-        0xa42e74f3d032f525,0xba3e7ca8b77f5e55,
-        0xcd3a1230c43fb26f,0x28ce1bd2e55f35eb,
-        0x80444b5e7aa7cf85,0x7980d163cf5b81b3,
-        0xa0555e361951c366,0xd7e105bcc332621f,
-        0xc86ab5c39fa63440,0x8dd9472bf3fefaa7,
-        0xfa856334878fc150,0xb14f98f6f0feb951,
-        0x9c935e00d4b9d8d2,0x6ed1bf9a569f33d3,
-        0xc3b8358109e84f07,0xa862f80ec4700c8,
-        0xf4a642e14c6262c8,0xcd27bb612758c0fa,
-        0x98e7e9cccfbd7dbd,0x8038d51cb897789c,
-        0xbf21e44003acdd2c,0xe0470a63e6bd56c3,
-        0xeeea5d5004981478,0x1858ccfce06cac74,
-        0x95527a5202df0ccb,0xf37801e0c43ebc8,
-        0xbaa718e68396cffd,0xd30560258f54e6ba,
-        0xe950df20247c83fd,0x47c6b82ef32a2069,
-        0x91d28b7416cdd27e,0x4cdc331d57fa5441,
-        0xb6472e511c81471d,0xe0133fe4adf8e952,
-        0xe3d8f9e563a198e5,0x58180fddd97723a6,
-        0x8e679c2f5e44ff8f,0x570f09eaa7ea7648,};
-using powers = powers_template<>;
-
-}
-
-#endif
-
-#ifndef FASTFLOAT_DECIMAL_TO_BINARY_H
-#define FASTFLOAT_DECIMAL_TO_BINARY_H
-
-#include <cfloat>
-#include <cinttypes>
-#include <cmath>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-
-namespace duckdb_fast_float {
-
-// This will compute or rather approximate w * 5**q and return a pair of 64-bit words approximating
-// the result, with the "high" part corresponding to the most significant bits and the
-// low part corresponding to the least significant bits.
-//
-template <int bit_precision>
-fastfloat_really_inline
-value128 compute_product_approximation(int64_t q, uint64_t w) {
-  const int index = 2 * int(q - powers::smallest_power_of_five);
-  // For small values of q, e.g., q in [0,27], the answer is always exact because
-  // The line value128 firstproduct = full_multiplication(w, power_of_five_128[index]);
-  // gives the exact answer.
-  value128 firstproduct = full_multiplication(w, powers::power_of_five_128[index]);
-  static_assert((bit_precision >= 0) && (bit_precision <= 64), " precision should  be in (0,64]");
-  constexpr uint64_t precision_mask = (bit_precision < 64) ?
-               (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
-               : uint64_t(0xFFFFFFFFFFFFFFFF);
-  if((firstproduct.high & precision_mask) == precision_mask) { // could further guard with  (lower + w < lower)
-    // regarding the second product, we only need secondproduct.high, but our expectation is that the compiler will optimize this extra work away if needed.
-    value128 secondproduct = full_multiplication(w, powers::power_of_five_128[index + 1]);
-    firstproduct.low += secondproduct.high;
-    if(secondproduct.high > firstproduct.low) {
-      firstproduct.high++;
-    }
-  }
-  return firstproduct;
-}
-
-namespace detail {
-/**
- * For q in (0,350), we have that
- *  f = (((152170 + 65536) * q ) >> 16);
- * is equal to
- *   floor(p) + q
- * where
- *   p = log(5**q)/log(2) = q * log(5)/log(2)
- *
- * For negative values of q in (-400,0), we have that
- *  f = (((152170 + 65536) * q ) >> 16);
- * is equal to
- *   -ceil(p) + q
- * where
- *   p = log(5**-q)/log(2) = -q * log(5)/log(2)
- */
-  fastfloat_really_inline int power(int q)  noexcept  {
-    return (((152170 + 65536) * q) >> 16) + 63;
-  }
-} // namespace detail
-
-
-// w * 10 ** q
-// The returned value should be a valid ieee64 number that simply need to be packed.
-// However, in some very rare cases, the computation will fail. In such cases, we
-// return an adjusted_mantissa with a negative power of 2: the caller should recompute
-// in such cases.
-template <typename binary>
-fastfloat_really_inline
-adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
-  adjusted_mantissa answer;
-  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
-    answer.power2 = 0;
-    answer.mantissa = 0;
-    // result should be zero
-    return answer;
-  }
-  if (q > binary::largest_power_of_ten()) {
-    // we want to get infinity:
-    answer.power2 = binary::infinite_power();
-    answer.mantissa = 0;
-    return answer;
-  }
-  // At this point in time q is in [powers::smallest_power_of_five, powers::largest_power_of_five].
-
-  // We want the most significant bit of i to be 1. Shift if needed.
-  int lz = leading_zeroes(w);
-  w <<= lz;
-
-  // The required precision is binary::mantissa_explicit_bits() + 3 because
-  // 1. We need the implicit bit
-  // 2. We need an extra bit for rounding purposes
-  // 3. We might lose a bit due to the "upperbit" routine (result too small, requiring a shift)
-
-  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
-  if(product.low == 0xFFFFFFFFFFFFFFFF) { //  could guard it further
-    // In some very rare cases, this could happen, in which case we might need a more accurate
-    // computation that what we can provide cheaply. This is very, very unlikely.
-    //
-    const bool inside_safe_exponent = (q >= -27) && (q <= 55); // always good because 5**q <2**128 when q>=0,
-    // and otherwise, for q<0, we have 5**-q<2**64 and the 128-bit reciprocal allows for exact computation.
-    if(!inside_safe_exponent) {
-      answer.power2 = -1; // This (a negative value) indicates an error condition.
-      return answer;
-    }
-  }
-  // The "compute_product_approximation" function can be slightly slower than a branchless approach:
-  // value128 product = compute_product(q, w);
-  // but in practice, we can win big with the compute_product_approximation if its additional branch
-  // is easily predicted. Which is best is data specific.
-  int upperbit = int(product.high >> 63);
-
-  answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
-
-  answer.power2 = int(detail::power(int(q)) + upperbit - lz - binary::minimum_exponent());
-  if (answer.power2 <= 0) { // we have a subnormal?
-    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
-    if(-answer.power2 + 1 >= 64) { // if we have more than 64 bits below the minimum exponent, you have a zero for sure.
-      answer.power2 = 0;
-      answer.mantissa = 0;
-      // result should be zero
-      return answer;
-    }
-    // next line is safe because -answer.power2 + 1 < 64
-    answer.mantissa >>= -answer.power2 + 1;
-    // Thankfully, we can't have both "round-to-even" and subnormals because
-    // "round-to-even" only occurs for powers close to 0.
-    answer.mantissa += (answer.mantissa & 1); // round up
-    answer.mantissa >>= 1;
-    // There is a weird scenario where we don't have a subnormal but just.
-    // Suppose we start with 2.2250738585072013e-308, we end up
-    // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
-    // whereas 0x40000000000000 x 2^-1023-53  is normal. Now, we need to round
-    // up 0x3fffffffffffff x 2^-1023-53  and once we do, we are no longer
-    // subnormal, but we can only know this after rounding.
-    // So we only declare a subnormal if we are smaller than the threshold.
-    answer.power2 = (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ? 0 : 1;
-    return answer;
-  }
-
-  // usually, we round *up*, but if we fall right in between and and we have an
-  // even basis, we need to round down
-  // We are only concerned with the cases where 5**q fits in single 64-bit word.
-  if ((product.low <= 1) &&  (q >= binary::min_exponent_round_to_even()) && (q <= binary::max_exponent_round_to_even()) &&
-      ((answer.mantissa & 3) == 1) ) { // we may fall between two floats!
-    // To be in-between two floats we need that in doing
-    //   answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
-    // ... we dropped out only zeroes. But if this happened, then we can go back!!!
-    if((answer.mantissa  << (upperbit + 64 - binary::mantissa_explicit_bits() - 3)) ==  product.high) {
-      answer.mantissa &= ~uint64_t(1);          // flip it so that we do not round up
-    }
-  }
-
-  answer.mantissa += (answer.mantissa & 1); // round up
-  answer.mantissa >>= 1;
-  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
-    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
-    answer.power2++; // undo previous addition
-  }
-
-  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
-  if (answer.power2 >= binary::infinite_power()) { // infinity
-    answer.power2 = binary::infinite_power();
-    answer.mantissa = 0;
-  }
-  return answer;
-}
-
-
-} // namespace duckdb_fast_float
-
-#endif
-
-
-#ifndef FASTFLOAT_ASCII_NUMBER_H
-#define FASTFLOAT_ASCII_NUMBER_H
-
-#include <cstdio>
-#include <cctype>
-#include <cstdint>
-#include <cstring>
-
-
-namespace duckdb_fast_float {
-
-// Next function can be micro-optimized, but compilers are entirely
-// able to optimize it well.
-fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
-
-fastfloat_really_inline uint64_t byteswap(uint64_t val) {
-  return (val & 0xFF00000000000000) >> 56
-    | (val & 0x00FF000000000000) >> 40
-    | (val & 0x0000FF0000000000) >> 24
-    | (val & 0x000000FF00000000) >> 8
-    | (val & 0x00000000FF000000) << 8
-    | (val & 0x0000000000FF0000) << 24
-    | (val & 0x000000000000FF00) << 40
-    | (val & 0x00000000000000FF) << 56;
-}
-
-fastfloat_really_inline uint64_t read_u64(const char *chars) {
-  uint64_t val;
-  ::memcpy(&val, chars, sizeof(uint64_t));
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-  // Need to read as-if the number was in little-endian order.
-  val = byteswap(val);
-#endif
-  return val;
-}
-
-fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-  // Need to read as-if the number was in little-endian order.
-  val = byteswap(val);
-#endif
-  ::memcpy(chars, &val, sizeof(uint64_t));
-}
-
-// credit  @aqrit
-fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
-  const uint64_t mask = 0x000000FF000000FF;
-  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
-  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
-  val -= 0x3030303030303030;
-  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
-  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
-  return uint32_t(val);
-}
-
-fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
-  return parse_eight_digits_unrolled(read_u64(chars));
-}
-
-// credit @aqrit
-fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
-  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
-     0x8080808080808080));
-}
-
-fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
-  return is_made_of_eight_digits_fast(read_u64(chars));
-}
-
-struct parsed_number_string {
-  int64_t exponent;
-  uint64_t mantissa;
-  const char *lastmatch;
-  bool negative;
-  bool valid;
-  bool too_many_digits;
-};
-
-
-// Assuming that you use no more than 19 digits, this will
-// parse an ASCII string.
-fastfloat_really_inline
-parsed_number_string parse_number_string(const char *p, const char *pend, chars_format fmt) noexcept {
-  parsed_number_string answer;
-  answer.valid = false;
-  answer.too_many_digits = false;
-  answer.negative = (*p == '-');
-  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
-    ++p;
-    if (p == pend) {
-      return answer;
-    }
-    if (!is_integer(*p) && (*p != '.')) { // a  sign must be followed by an integer or the dot
-      return answer;
-    }
-  }
-  const char *const start_digits = p;
-
-  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
-
-  while ((p != pend) && is_integer(*p)) {
-    // a multiplication by 10 is cheaper than an arbitrary integer
-    // multiplication
-    i = 10 * i +
-        uint64_t(*p - '0'); // might overflow, we will handle the overflow later
-    ++p;
-  }
-  const char *const end_of_integer_part = p;
-  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
-  int64_t exponent = 0;
-  if ((p != pend) && (*p == '.')) {
-    ++p;
-  // Fast approach only tested under little endian systems
-  if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-    i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-    p += 8;
-    if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-      p += 8;
-    }
-  }
-    while ((p != pend) && is_integer(*p)) {
-      uint8_t digit = uint8_t(*p - '0');
-      ++p;
-      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
-    }
-    exponent = end_of_integer_part + 1 - p;
-    digit_count -= exponent;
-  }
-  // we must have encountered at least one integer!
-  if (digit_count == 0) {
-    return answer;
-  }
-  int64_t exp_number = 0;            // explicit exponential part
-  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
-    const char * location_of_e = p;
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
-      ++p;
-    }
-    if ((p == pend) || !is_integer(*p)) {
-      if(!(fmt & chars_format::fixed)) {
-        // We are in error.
-        return answer;
-      }
-      // Otherwise, we will be ignoring the 'e'.
-      p = location_of_e;
-    } else {
-      while ((p != pend) && is_integer(*p)) {
-        uint8_t digit = uint8_t(*p - '0');
-        if (exp_number < 0x10000) {
-          exp_number = 10 * exp_number + digit;
-        }
-        ++p;
-      }
-      if(neg_exp) { exp_number = - exp_number; }
-      exponent += exp_number;
-    }
-  } else {
-    // If it scientific and not fixed, we have to bail out.
-    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
-  }
-  answer.lastmatch = p;
-  answer.valid = true;
-
-  // If we frequently had to deal with long strings of digits,
-  // we could extend our code by using a 128-bit integer instead
-  // of a 64-bit integer. However, this is uncommon.
-  //
-  // We can deal with up to 19 digits.
-  if (digit_count > 19) { // this is uncommon
-    // It is possible that the integer had an overflow.
-    // We have to handle the case where we have 0.0000somenumber.
-    // We need to be mindful of the case where we only have zeroes...
-    // E.g., 0.000000000...000.
-    const char *start = start_digits;
-    while ((start != pend) && (*start == '0' || *start == '.')) {
-      if(*start == '0') { digit_count --; }
-      start++;
-    }
-    if (digit_count > 19) {
-      answer.too_many_digits = true;
-      // Let us start again, this time, avoiding overflows.
-      i = 0;
-      p = start_digits;
-      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
-      while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
-        i = i * 10 + uint64_t(*p - '0');
-        ++p;
-      }
-      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
-        exponent = end_of_integer_part - p + exp_number;
-      } else { // We have a value with a fractional component.
-          p++; // skip the '.'
-          const char *first_after_period = p;
-          while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
-            i = i * 10 + uint64_t(*p - '0');
-            ++p;
-          }
-          exponent = first_after_period - p + exp_number;
-      }
-      // We have now corrected both exponent and i, to a truncated value
-    }
-  }
-  answer.exponent = exponent;
-  answer.mantissa = i;
-  return answer;
-}
-
-
-// This should always succeed since it follows a call to parse_number_string
-// This function could be optimized. In particular, we could stop after 19 digits
-// and try to bail out. Furthermore, we should be able to recover the computed
-// exponent from the pass in parse_number_string.
-fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) noexcept {
-  decimal answer;
-  answer.num_digits = 0;
-  answer.decimal_point = 0;
-  answer.truncated = false;
-  answer.negative = (*p == '-');
-  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
-    ++p;
-  }
-  // skip leading zeroes
-  while ((p != pend) && (*p == '0')) {
-    ++p;
-  }
-  while ((p != pend) && is_integer(*p)) {
-    if (answer.num_digits < max_digits) {
-      answer.digits[answer.num_digits] = uint8_t(*p - '0');
-    }
-    answer.num_digits++;
-    ++p;
-  }
-  if ((p != pend) && (*p == '.')) {
-    ++p;
-    const char *first_after_period = p;
-    // if we have not yet encountered a zero, we have to skip it as well
-    if(answer.num_digits == 0) {
-      // skip zeros
-      while ((p != pend) && (*p == '0')) {
-       ++p;
-      }
-    }
-    // We expect that this loop will often take the bulk of the running time
-    // because when a value has lots of digits, these digits often
-    while ((p + 8 <= pend) && (answer.num_digits + 8 < max_digits)) {
-      uint64_t val = read_u64(p);
-      if(! is_made_of_eight_digits_fast(val)) { break; }
-      // We have eight digits, process them in one go!
-      val -= 0x3030303030303030;
-      write_u64(answer.digits + answer.num_digits, val);
-      answer.num_digits += 8;
-      p += 8;
-    }
-    while ((p != pend) && is_integer(*p)) {
-      if (answer.num_digits < max_digits) {
-        answer.digits[answer.num_digits] = uint8_t(*p - '0');
-      }
-      answer.num_digits++;
-      ++p;
-    }
-    answer.decimal_point = int32_t(first_after_period - p);
-  }
-  // We want num_digits to be the number of significant digits, excluding
-  // leading *and* trailing zeros! Otherwise the truncated flag later is
-  // going to be misleading.
-  if(answer.num_digits > 0) {
-    // We potentially need the answer.num_digits > 0 guard because we
-    // prune leading zeros. So with answer.num_digits > 0, we know that
-    // we have at least one non-zero digit.
-    const char *preverse = p - 1;
-    int32_t trailing_zeros = 0;
-    while ((*preverse == '0') || (*preverse == '.')) {
-      if(*preverse == '0') { trailing_zeros++; };
-      --preverse;
-    }
-    answer.decimal_point += int32_t(answer.num_digits);
-    answer.num_digits -= uint32_t(trailing_zeros);
-  }
-  if(answer.num_digits > max_digits) {
-    answer.truncated = true;
-    answer.num_digits = max_digits;
-  }
-  if ((p != pend) && (('e' == *p) || ('E' == *p))) {
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
-      ++p;
-    }
-    int32_t exp_number = 0; // exponential part
-    while ((p != pend) && is_integer(*p)) {
-      uint8_t digit = uint8_t(*p - '0');
-      if (exp_number < 0x10000) {
-        exp_number = 10 * exp_number + digit;
-      }
-      ++p;
-    }
-    answer.decimal_point += (neg_exp ? -exp_number : exp_number);
-  }
-  // In very rare cases, we may have fewer than 19 digits, we want to be able to reliably
-  // assume that all digits up to max_digit_without_overflow have been initialized.
-  for(uint32_t i = answer.num_digits; i < max_digit_without_overflow; i++) { answer.digits[i] = 0; }
-
-  return answer;
-}
-} // namespace duckdb_fast_float
-
-#endif
-
-
-#ifndef FASTFLOAT_GENERIC_DECIMAL_TO_BINARY_H
-#define FASTFLOAT_GENERIC_DECIMAL_TO_BINARY_H
-
-/**
- * This code is meant to handle the case where we have more than 19 digits.
- *
- * It is based on work by Nigel Tao (at https://github.com/google/wuffs/)
- * who credits Ken Thompson for the design (via a reference to the Go source
- * code).
- *
- * Rob Pike suggested that this algorithm be called "Simple Decimal Conversion".
- *
- * It is probably not very fast but it is a fallback that should almost never
- * be used in real life. Though it is not fast, it is "easily" understood and debugged.
- **/
-#include <cstdint>
-
-namespace duckdb_fast_float {
-
-namespace detail {
-
-// remove all final zeroes
-inline void trim(decimal &h) {
-  while ((h.num_digits > 0) && (h.digits[h.num_digits - 1] == 0)) {
-    h.num_digits--;
-  }
-}
-
-
-
-inline uint32_t number_of_digits_decimal_left_shift(const decimal &h, uint32_t shift) {
-  shift &= 63;
-  const static uint16_t number_of_digits_decimal_left_shift_table[65] = {
-    0x0000, 0x0800, 0x0801, 0x0803, 0x1006, 0x1009, 0x100D, 0x1812, 0x1817,
-    0x181D, 0x2024, 0x202B, 0x2033, 0x203C, 0x2846, 0x2850, 0x285B, 0x3067,
-    0x3073, 0x3080, 0x388E, 0x389C, 0x38AB, 0x38BB, 0x40CC, 0x40DD, 0x40EF,
-    0x4902, 0x4915, 0x4929, 0x513E, 0x5153, 0x5169, 0x5180, 0x5998, 0x59B0,
-    0x59C9, 0x61E3, 0x61FD, 0x6218, 0x6A34, 0x6A50, 0x6A6D, 0x6A8B, 0x72AA,
-    0x72C9, 0x72E9, 0x7B0A, 0x7B2B, 0x7B4D, 0x8370, 0x8393, 0x83B7, 0x83DC,
-    0x8C02, 0x8C28, 0x8C4F, 0x9477, 0x949F, 0x94C8, 0x9CF2, 0x051C, 0x051C,
-    0x051C, 0x051C,
-  };
-  uint32_t x_a = number_of_digits_decimal_left_shift_table[shift];
-  uint32_t x_b = number_of_digits_decimal_left_shift_table[shift + 1];
-  uint32_t num_new_digits = x_a >> 11;
-  uint32_t pow5_a = 0x7FF & x_a;
-  uint32_t pow5_b = 0x7FF & x_b;
-  const static uint8_t
-    number_of_digits_decimal_left_shift_table_powers_of_5[0x051C] = {
-        5, 2, 5, 1, 2, 5, 6, 2, 5, 3, 1, 2, 5, 1, 5, 6, 2, 5, 7, 8, 1, 2, 5, 3,
-        9, 0, 6, 2, 5, 1, 9, 5, 3, 1, 2, 5, 9, 7, 6, 5, 6, 2, 5, 4, 8, 8, 2, 8,
-        1, 2, 5, 2, 4, 4, 1, 4, 0, 6, 2, 5, 1, 2, 2, 0, 7, 0, 3, 1, 2, 5, 6, 1,
-        0, 3, 5, 1, 5, 6, 2, 5, 3, 0, 5, 1, 7, 5, 7, 8, 1, 2, 5, 1, 5, 2, 5, 8,
-        7, 8, 9, 0, 6, 2, 5, 7, 6, 2, 9, 3, 9, 4, 5, 3, 1, 2, 5, 3, 8, 1, 4, 6,
-        9, 7, 2, 6, 5, 6, 2, 5, 1, 9, 0, 7, 3, 4, 8, 6, 3, 2, 8, 1, 2, 5, 9, 5,
-        3, 6, 7, 4, 3, 1, 6, 4, 0, 6, 2, 5, 4, 7, 6, 8, 3, 7, 1, 5, 8, 2, 0, 3,
-        1, 2, 5, 2, 3, 8, 4, 1, 8, 5, 7, 9, 1, 0, 1, 5, 6, 2, 5, 1, 1, 9, 2, 0,
-        9, 2, 8, 9, 5, 5, 0, 7, 8, 1, 2, 5, 5, 9, 6, 0, 4, 6, 4, 4, 7, 7, 5, 3,
-        9, 0, 6, 2, 5, 2, 9, 8, 0, 2, 3, 2, 2, 3, 8, 7, 6, 9, 5, 3, 1, 2, 5, 1,
-        4, 9, 0, 1, 1, 6, 1, 1, 9, 3, 8, 4, 7, 6, 5, 6, 2, 5, 7, 4, 5, 0, 5, 8,
-        0, 5, 9, 6, 9, 2, 3, 8, 2, 8, 1, 2, 5, 3, 7, 2, 5, 2, 9, 0, 2, 9, 8, 4,
-        6, 1, 9, 1, 4, 0, 6, 2, 5, 1, 8, 6, 2, 6, 4, 5, 1, 4, 9, 2, 3, 0, 9, 5,
-        7, 0, 3, 1, 2, 5, 9, 3, 1, 3, 2, 2, 5, 7, 4, 6, 1, 5, 4, 7, 8, 5, 1, 5,
-        6, 2, 5, 4, 6, 5, 6, 6, 1, 2, 8, 7, 3, 0, 7, 7, 3, 9, 2, 5, 7, 8, 1, 2,
-        5, 2, 3, 2, 8, 3, 0, 6, 4, 3, 6, 5, 3, 8, 6, 9, 6, 2, 8, 9, 0, 6, 2, 5,
-        1, 1, 6, 4, 1, 5, 3, 2, 1, 8, 2, 6, 9, 3, 4, 8, 1, 4, 4, 5, 3, 1, 2, 5,
-        5, 8, 2, 0, 7, 6, 6, 0, 9, 1, 3, 4, 6, 7, 4, 0, 7, 2, 2, 6, 5, 6, 2, 5,
-        2, 9, 1, 0, 3, 8, 3, 0, 4, 5, 6, 7, 3, 3, 7, 0, 3, 6, 1, 3, 2, 8, 1, 2,
-        5, 1, 4, 5, 5, 1, 9, 1, 5, 2, 2, 8, 3, 6, 6, 8, 5, 1, 8, 0, 6, 6, 4, 0,
-        6, 2, 5, 7, 2, 7, 5, 9, 5, 7, 6, 1, 4, 1, 8, 3, 4, 2, 5, 9, 0, 3, 3, 2,
-        0, 3, 1, 2, 5, 3, 6, 3, 7, 9, 7, 8, 8, 0, 7, 0, 9, 1, 7, 1, 2, 9, 5, 1,
-        6, 6, 0, 1, 5, 6, 2, 5, 1, 8, 1, 8, 9, 8, 9, 4, 0, 3, 5, 4, 5, 8, 5, 6,
-        4, 7, 5, 8, 3, 0, 0, 7, 8, 1, 2, 5, 9, 0, 9, 4, 9, 4, 7, 0, 1, 7, 7, 2,
-        9, 2, 8, 2, 3, 7, 9, 1, 5, 0, 3, 9, 0, 6, 2, 5, 4, 5, 4, 7, 4, 7, 3, 5,
-        0, 8, 8, 6, 4, 6, 4, 1, 1, 8, 9, 5, 7, 5, 1, 9, 5, 3, 1, 2, 5, 2, 2, 7,
-        3, 7, 3, 6, 7, 5, 4, 4, 3, 2, 3, 2, 0, 5, 9, 4, 7, 8, 7, 5, 9, 7, 6, 5,
-        6, 2, 5, 1, 1, 3, 6, 8, 6, 8, 3, 7, 7, 2, 1, 6, 1, 6, 0, 2, 9, 7, 3, 9,
-        3, 7, 9, 8, 8, 2, 8, 1, 2, 5, 5, 6, 8, 4, 3, 4, 1, 8, 8, 6, 0, 8, 0, 8,
-        0, 1, 4, 8, 6, 9, 6, 8, 9, 9, 4, 1, 4, 0, 6, 2, 5, 2, 8, 4, 2, 1, 7, 0,
-        9, 4, 3, 0, 4, 0, 4, 0, 0, 7, 4, 3, 4, 8, 4, 4, 9, 7, 0, 7, 0, 3, 1, 2,
-        5, 1, 4, 2, 1, 0, 8, 5, 4, 7, 1, 5, 2, 0, 2, 0, 0, 3, 7, 1, 7, 4, 2, 2,
-        4, 8, 5, 3, 5, 1, 5, 6, 2, 5, 7, 1, 0, 5, 4, 2, 7, 3, 5, 7, 6, 0, 1, 0,
-        0, 1, 8, 5, 8, 7, 1, 1, 2, 4, 2, 6, 7, 5, 7, 8, 1, 2, 5, 3, 5, 5, 2, 7,
-        1, 3, 6, 7, 8, 8, 0, 0, 5, 0, 0, 9, 2, 9, 3, 5, 5, 6, 2, 1, 3, 3, 7, 8,
-        9, 0, 6, 2, 5, 1, 7, 7, 6, 3, 5, 6, 8, 3, 9, 4, 0, 0, 2, 5, 0, 4, 6, 4,
-        6, 7, 7, 8, 1, 0, 6, 6, 8, 9, 4, 5, 3, 1, 2, 5, 8, 8, 8, 1, 7, 8, 4, 1,
-        9, 7, 0, 0, 1, 2, 5, 2, 3, 2, 3, 3, 8, 9, 0, 5, 3, 3, 4, 4, 7, 2, 6, 5,
-        6, 2, 5, 4, 4, 4, 0, 8, 9, 2, 0, 9, 8, 5, 0, 0, 6, 2, 6, 1, 6, 1, 6, 9,
-        4, 5, 2, 6, 6, 7, 2, 3, 6, 3, 2, 8, 1, 2, 5, 2, 2, 2, 0, 4, 4, 6, 0, 4,
-        9, 2, 5, 0, 3, 1, 3, 0, 8, 0, 8, 4, 7, 2, 6, 3, 3, 3, 6, 1, 8, 1, 6, 4,
-        0, 6, 2, 5, 1, 1, 1, 0, 2, 2, 3, 0, 2, 4, 6, 2, 5, 1, 5, 6, 5, 4, 0, 4,
-        2, 3, 6, 3, 1, 6, 6, 8, 0, 9, 0, 8, 2, 0, 3, 1, 2, 5, 5, 5, 5, 1, 1, 1,
-        5, 1, 2, 3, 1, 2, 5, 7, 8, 2, 7, 0, 2, 1, 1, 8, 1, 5, 8, 3, 4, 0, 4, 5,
-        4, 1, 0, 1, 5, 6, 2, 5, 2, 7, 7, 5, 5, 5, 7, 5, 6, 1, 5, 6, 2, 8, 9, 1,
-        3, 5, 1, 0, 5, 9, 0, 7, 9, 1, 7, 0, 2, 2, 7, 0, 5, 0, 7, 8, 1, 2, 5, 1,
-        3, 8, 7, 7, 7, 8, 7, 8, 0, 7, 8, 1, 4, 4, 5, 6, 7, 5, 5, 2, 9, 5, 3, 9,
-        5, 8, 5, 1, 1, 3, 5, 2, 5, 3, 9, 0, 6, 2, 5, 6, 9, 3, 8, 8, 9, 3, 9, 0,
-        3, 9, 0, 7, 2, 2, 8, 3, 7, 7, 6, 4, 7, 6, 9, 7, 9, 2, 5, 5, 6, 7, 6, 2,
-        6, 9, 5, 3, 1, 2, 5, 3, 4, 6, 9, 4, 4, 6, 9, 5, 1, 9, 5, 3, 6, 1, 4, 1,
-        8, 8, 8, 2, 3, 8, 4, 8, 9, 6, 2, 7, 8, 3, 8, 1, 3, 4, 7, 6, 5, 6, 2, 5,
-        1, 7, 3, 4, 7, 2, 3, 4, 7, 5, 9, 7, 6, 8, 0, 7, 0, 9, 4, 4, 1, 1, 9, 2,
-        4, 4, 8, 1, 3, 9, 1, 9, 0, 6, 7, 3, 8, 2, 8, 1, 2, 5, 8, 6, 7, 3, 6, 1,
-        7, 3, 7, 9, 8, 8, 4, 0, 3, 5, 4, 7, 2, 0, 5, 9, 6, 2, 2, 4, 0, 6, 9, 5,
-        9, 5, 3, 3, 6, 9, 1, 4, 0, 6, 2, 5,
-  };
-  const uint8_t *pow5 =
-      &number_of_digits_decimal_left_shift_table_powers_of_5[pow5_a];
-  uint32_t i = 0;
-  uint32_t n = pow5_b - pow5_a;
-  for (; i < n; i++) {
-    if (i >= h.num_digits) {
-      return num_new_digits - 1;
-    } else if (h.digits[i] == pow5[i]) {
-      continue;
-    } else if (h.digits[i] < pow5[i]) {
-      return num_new_digits - 1;
-    } else {
-      return num_new_digits;
-    }
-  }
-  return num_new_digits;
-}
-
-inline uint64_t round(decimal &h) {
-  if ((h.num_digits == 0) || (h.decimal_point < 0)) {
-    return 0;
-  } else if (h.decimal_point > 18) {
-    return UINT64_MAX;
-  }
-  // at this point, we know that h.decimal_point >= 0
-  uint32_t dp = uint32_t(h.decimal_point);
-  uint64_t n = 0;
-  for (uint32_t i = 0; i < dp; i++) {
-    n = (10 * n) + ((i < h.num_digits) ? h.digits[i] : 0);
-  }
-  bool round_up = false;
-  if (dp < h.num_digits) {
-    round_up = h.digits[dp] >= 5; // normally, we round up
-    // but we may need to round to even!
-    if ((h.digits[dp] == 5) && (dp + 1 == h.num_digits)) {
-      round_up = h.truncated || ((dp > 0) && (1 & h.digits[dp - 1]));
-    }
-  }
-  if (round_up) {
-    n++;
-  }
-  return n;
-}
-
-// computes h * 2^-shift
-inline void decimal_left_shift(decimal &h, uint32_t shift) {
-  if (h.num_digits == 0) {
-    return;
-  }
-  uint32_t num_new_digits = number_of_digits_decimal_left_shift(h, shift);
-  int32_t read_index = int32_t(h.num_digits - 1);
-  uint32_t write_index = h.num_digits - 1 + num_new_digits;
-  uint64_t n = 0;
-
-  while (read_index >= 0) {
-    n += uint64_t(h.digits[read_index]) << shift;
-    uint64_t quotient = n / 10;
-    uint64_t remainder = n - (10 * quotient);
-    if (write_index < max_digits) {
-      h.digits[write_index] = uint8_t(remainder);
-    } else if (remainder > 0) {
-      h.truncated = true;
-    }
-    n = quotient;
-    write_index--;
-    read_index--;
-  }
-  while (n > 0) {
-    uint64_t quotient = n / 10;
-    uint64_t remainder = n - (10 * quotient);
-    if (write_index < max_digits) {
-      h.digits[write_index] = uint8_t(remainder);
-    } else if (remainder > 0) {
-      h.truncated = true;
-    }
-    n = quotient;
-    write_index--;
-  }
-  h.num_digits += num_new_digits;
-  if (h.num_digits > max_digits) {
-    h.num_digits = max_digits;
-  }
-  h.decimal_point += int32_t(num_new_digits);
-  trim(h);
-}
-
-// computes h * 2^shift
-inline void decimal_right_shift(decimal &h, uint32_t shift) {
-  uint32_t read_index = 0;
-  uint32_t write_index = 0;
-
-  uint64_t n = 0;
-
-  while ((n >> shift) == 0) {
-    if (read_index < h.num_digits) {
-      n = (10 * n) + h.digits[read_index++];
-    } else if (n == 0) {
-      return;
-    } else {
-      while ((n >> shift) == 0) {
-        n = 10 * n;
-        read_index++;
-      }
-      break;
-    }
-  }
-  h.decimal_point -= int32_t(read_index - 1);
-  if (h.decimal_point < -decimal_point_range) { // it is zero
-    h.num_digits = 0;
-    h.decimal_point = 0;
-    h.negative = false;
-    h.truncated = false;
-    return;
-  }
-  uint64_t mask = (uint64_t(1) << shift) - 1;
-  while (read_index < h.num_digits) {
-    uint8_t new_digit = uint8_t(n >> shift);
-    n = (10 * (n & mask)) + h.digits[read_index++];
-    h.digits[write_index++] = new_digit;
-  }
-  while (n > 0) {
-    uint8_t new_digit = uint8_t(n >> shift);
-    n = 10 * (n & mask);
-    if (write_index < max_digits) {
-      h.digits[write_index++] = new_digit;
-    } else if (new_digit > 0) {
-      h.truncated = true;
-    }
-  }
-  h.num_digits = write_index;
-  trim(h);
-}
-
-} // namespace detail
-
-template <typename binary>
-adjusted_mantissa compute_float(decimal &d) {
-  adjusted_mantissa answer;
-  if (d.num_digits == 0) {
-    // should be zero
-    answer.power2 = 0;
-    answer.mantissa = 0;
-    return answer;
-  }
-  // At this point, going further, we can assume that d.num_digits > 0.
-  //
-  // We want to guard against excessive decimal point values because
-  // they can result in long running times. Indeed, we do
-  // shifts by at most 60 bits. We have that log(10**400)/log(2**60) ~= 22
-  // which is fine, but log(10**299995)/log(2**60) ~= 16609 which is not
-  // fine (runs for a long time).
-  //
-  if(d.decimal_point < -324) {
-    // We have something smaller than 1e-324 which is always zero
-    // in binary64 and binary32.
-    // It should be zero.
-    answer.power2 = 0;
-    answer.mantissa = 0;
-    return answer;
-  } else if(d.decimal_point >= 310) {
-    // We have something at least as large as 0.1e310 which is
-    // always infinite.
-    answer.power2 = binary::infinite_power();
-    answer.mantissa = 0;
-    return answer;
-  }
-  static const uint32_t max_shift = 60;
-  static const uint32_t num_powers = 19;
-  static const uint8_t decimal_powers[19] = {
-      0,  3,  6,  9,  13, 16, 19, 23, 26, 29, //
-      33, 36, 39, 43, 46, 49, 53, 56, 59,     //
-  };
-  int32_t exp2 = 0;
-  while (d.decimal_point > 0) {
-    uint32_t n = uint32_t(d.decimal_point);
-    uint32_t shift = (n < num_powers) ? decimal_powers[n] : max_shift;
-    detail::decimal_right_shift(d, shift);
-    if (d.decimal_point < -decimal_point_range) {
-      // should be zero
-      answer.power2 = 0;
-      answer.mantissa = 0;
-      return answer;
-    }
-    exp2 += int32_t(shift);
-  }
-  // We shift left toward [1/2 ... 1].
-  while (d.decimal_point <= 0) {
-    uint32_t shift;
-    if (d.decimal_point == 0) {
-      if (d.digits[0] >= 5) {
-        break;
-      }
-      shift = (d.digits[0] < 2) ? 2 : 1;
-    } else {
-      uint32_t n = uint32_t(-d.decimal_point);
-      shift = (n < num_powers) ? decimal_powers[n] : max_shift;
-    }
-    detail::decimal_left_shift(d, shift);
-    if (d.decimal_point > decimal_point_range) {
-      // we want to get infinity:
-      answer.power2 = binary::infinite_power();
-      answer.mantissa = 0;
-      return answer;
-    }
-    exp2 -= int32_t(shift);
-  }
-  // We are now in the range [1/2 ... 1] but the binary format uses [1 ... 2].
-  exp2--;
-  constexpr int32_t minimum_exponent = binary::minimum_exponent();
-  while ((minimum_exponent + 1) > exp2) {
-    uint32_t n = uint32_t((minimum_exponent + 1) - exp2);
-    if (n > max_shift) {
-      n = max_shift;
-    }
-    detail::decimal_right_shift(d, n);
-    exp2 += int32_t(n);
-  }
-  if ((exp2 - minimum_exponent) >= binary::infinite_power()) {
-    answer.power2 = binary::infinite_power();
-    answer.mantissa = 0;
-    return answer;
-  }
-
-  const int mantissa_size_in_bits = binary::mantissa_explicit_bits() + 1;
-  detail::decimal_left_shift(d, mantissa_size_in_bits);
-
-  uint64_t mantissa = detail::round(d);
-  // It is possible that we have an overflow, in which case we need
-  // to shift back.
-  if(mantissa >= (uint64_t(1) << mantissa_size_in_bits)) {
-    detail::decimal_right_shift(d, 1);
-    exp2 += 1;
-    mantissa = detail::round(d);
-    if ((exp2 - minimum_exponent) >= binary::infinite_power()) {
-      answer.power2 = binary::infinite_power();
-      answer.mantissa = 0;
-      return answer;
-    }
-  }
-  answer.power2 = exp2  - binary::minimum_exponent();
-  if(mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) { answer.power2--; }
-  answer.mantissa = mantissa & ((uint64_t(1) << binary::mantissa_explicit_bits()) - 1);
-  return answer;
-}
-
-template <typename binary>
-adjusted_mantissa parse_long_mantissa(const char *first, const char* last) {
-    decimal d = parse_decimal(first, last);
-    return compute_float<binary>(d);
-}
-
-} // namespace duckdb_fast_float
-#endif
-
-
-#ifndef FASTFLOAT_PARSE_NUMBER_H
-#define FASTFLOAT_PARSE_NUMBER_H
-
-#include <cassert>
-#include <cmath>
-#include <cstring>
-#include <limits>
-#include <system_error>
-
-namespace duckdb_fast_float {
-
-
-namespace detail {
-/**
- * Special case +inf, -inf, nan, infinity, -infinity.
- * The case comparisons could be made much faster given that we know that the
- * strings a null-free and fixed.
- **/
-template <typename T>
-from_chars_result parse_infnan(const char *first, const char *last, T &value)  noexcept  {
-  from_chars_result answer;
-  answer.ptr = first;
-  answer.ec = std::errc(); // be optimistic
-  bool minusSign = false;
-  if (*first == '-') { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here
-      minusSign = true;
-      ++first;
-  }
-  if (last - first >= 3) {
-    if (fastfloat_strncasecmp(first, "nan", 3)) {
-      answer.ptr = (first += 3);
-      value = minusSign ? -std::numeric_limits<T>::quiet_NaN() : std::numeric_limits<T>::quiet_NaN();
-      // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7, C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan).
-      if(first != last && *first == '(') {
-        for(const char* ptr = first + 1; ptr != last; ++ptr) {
-          if (*ptr == ')') {
-            answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
-            break;
-          }
-          else if(!(('a' <= *ptr && *ptr <= 'z') || ('A' <= *ptr && *ptr <= 'Z') || ('0' <= *ptr && *ptr <= '9') || *ptr == '_'))
-            break; // forbidden char, not nan(n-char-seq-opt)
-        }
-      }
-      return answer;
-    }
-    if (fastfloat_strncasecmp(first, "inf", 3)) {
-      if ((last - first >= 8) && fastfloat_strncasecmp(first + 3, "inity", 5)) {
-        answer.ptr = first + 8;
-      } else {
-        answer.ptr = first + 3;
-      }
-      value = minusSign ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::infinity();
-      return answer;
-    }
-  }
-  answer.ec = std::errc::invalid_argument;
-  return answer;
-}
-
-template<typename T>
-fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &value) {
-  uint64_t word = am.mantissa;
-  word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
-  word = negative
-  ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-   if (std::is_same<T, float>::value) {
-     ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
-   } else {
-     ::memcpy(&value, &word, sizeof(T));
-   }
-#else
-   // For little-endian systems:
-   ::memcpy(&value, &word, sizeof(T));
-#endif
-}
-
-} // namespace detail
-
-
-
-template<typename T>
-from_chars_result from_chars(const char *first, const char *last,
-                             T &value, chars_format fmt /*= chars_format::general*/)  noexcept  {
-  static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
-
-
-  from_chars_result answer;
-  if (first == last) {
-    answer.ec = std::errc::invalid_argument;
-    answer.ptr = first;
-    return answer;
-  }
-  parsed_number_string pns = parse_number_string(first, last, fmt);
-  if (!pns.valid) {
-    return detail::parse_infnan(first, last, value);
-  }
-  answer.ec = std::errc(); // be optimistic
-  answer.ptr = pns.lastmatch;
-  // Next is Clinger's fast path.
-  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent && pns.exponent <= binary_format<T>::max_exponent_fast_path() && pns.mantissa <=binary_format<T>::max_mantissa_fast_path() && !pns.too_many_digits) {
-    value = T(pns.mantissa);
-    if (pns.exponent < 0) { value = value / binary_format<T>::exact_power_of_ten(-pns.exponent); }
-    else { value = value * binary_format<T>::exact_power_of_ten(pns.exponent); }
-    if (pns.negative) { value = -value; }
-    return answer;
-  }
-  adjusted_mantissa am = compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
-  if(pns.too_many_digits) {
-    if(am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
-      am.power2 = -1; // value is invalid.
-    }
-  }
-  // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
-  // then we need to go the long way around again. This is very uncommon.
-  if(am.power2 < 0) { am = parse_long_mantissa<binary_format<T>>(first,last); }
-  detail::to_float(pns.negative, am, value);
-  return answer;
-}
-
-} // namespace duckdb_fast_float
-
-#endif
-
-
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/pipe_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class PipeFileSystem : public FileSystem {
-public:
-	static unique_ptr<FileHandle> OpenPipe(unique_ptr<FileHandle> handle);
-
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-
-	int64_t GetFileSize(FileHandle &handle) override;
-
-	void Reset(FileHandle &handle) override;
-	bool OnDiskFile(FileHandle &handle) override {
-		return false;
-	};
-	bool CanSeek() override {
-		return false;
-	}
-	void FileSync(FileHandle &handle) override;
-
-	std::string GetName() const override {
-		return "PipeFileSystem";
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/random_engine.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-#include <random>
-
-namespace duckdb {
-class ClientContext;
-struct RandomState;
-
-struct RandomEngine {
-	RandomEngine(int64_t seed = -1);
-	~RandomEngine();
-
-public:
-	//! Generate a random number between min and max
-	double NextRandom(double min, double max);
-
-	//! Generate a random number between 0 and 1
-	double NextRandom();
-	uint32_t NextRandomInteger();
-
-	void SetSeed(uint32_t seed);
-
-	static RandomEngine &Get(ClientContext &context);
-
-private:
-	unique_ptr<RandomState> random_state;
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #5
-// See the end of this file for a list
-
-/*
- * PCG Random Number Generation for C++
- *
- * Copyright 2014-2019 Melissa O'Neill <oneill@pcg-random.org>,
- *                     and the PCG Project contributors.
- *
- * SPDX-License-Identifier: (Apache-2.0 OR MIT)
- *
- * Licensed under the Apache License, Version 2.0 (provided in
- * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
- * or under the MIT license (provided in LICENSE-MIT.txt and at
- * http://opensource.org/licenses/MIT), at your option. This file may not
- * be copied, modified, or distributed except according to those terms.
- *
- * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
- * express or implied.  See your chosen license for details.
- *
- * For additional information about the PCG random number generation scheme,
- * visit http://www.pcg-random.org/.
- */
-
-/*
- * This code provides the reference implementation of the PCG family of
- * random number generators.  The code is complex because it implements
- *
- *      - several members of the PCG family, specifically members corresponding
- *        to the output functions:
- *             - XSH RR         (good for 64-bit state, 32-bit output)
- *             - XSH RS         (good for 64-bit state, 32-bit output)
- *             - XSL RR         (good for 128-bit state, 64-bit output)
- *             - RXS M XS       (statistically most powerful generator)
- *             - XSL RR RR      (good for 128-bit state, 128-bit output)
- *             - and RXS, RXS M, XSH, XSL       (mostly for testing)
- *      - at potentially *arbitrary* bit sizes
- *      - with four different techniques for random streams (MCG, one-stream
- *        LCG, settable-stream LCG, unique-stream LCG)
- *      - and the extended generation schemes allowing arbitrary periods
- *      - with all features of C++11 random number generation (and more),
- *        some of which are somewhat painful, including
- *            - initializing with a SeedSequence which writes 32-bit values
- *              to memory, even though the state of the generator may not
- *              use 32-bit values (it might use smaller or larger integers)
- *            - I/O for RNGs and a prescribed format, which needs to handle
- *              the issue that 8-bit and 128-bit integers don't have working
- *              I/O routines (e.g., normally 8-bit = char, not integer)
- *            - equality and inequality for RNGs
- *      - and a number of convenience typedefs to mask all the complexity
- *
- * The code employes a fairly heavy level of abstraction, and has to deal
- * with various C++ minutia.  If you're looking to learn about how the PCG
- * scheme works, you're probably best of starting with one of the other
- * codebases (see www.pcg-random.org).  But if you're curious about the
- * constants for the various output functions used in those other, simpler,
- * codebases, this code shows how they are calculated.
- *
- * On the positive side, at least there are convenience typedefs so that you
- * can say
- *
- *      pcg32 myRNG;
- *
- * rather than:
- *
- *      pcg_detail::engine<
- *          uint32_t,                                           // Output Type
- *          uint64_t,                                           // State Type
- *          pcg_detail::xsh_rr_mixin<uint32_t, uint64_t>, true, // Output Func
- *          pcg_detail::specific_stream<uint64_t>,              // Stream Kind
- *          pcg_detail::default_multiplier<uint64_t>            // LCG Mult
- *      > myRNG;
- *
- */
-
-#ifndef PCG_RAND_HPP_INCLUDED
-#define PCG_RAND_HPP_INCLUDED 1
-
-#include <algorithm>
-#include <cinttypes>
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <cassert>
-#include <limits>
-#include <iostream>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-#include <locale>
-#include <new>
-#include <stdexcept>
-
-#ifdef _MSC_VER
-    #pragma warning(disable:4146)
-#endif
-
-#ifdef _MSC_VER
-    #define PCG_ALWAYS_INLINE __forceinline
-#elif __GNUC__
-    #define PCG_ALWAYS_INLINE __attribute__((always_inline))
-#else
-    #define PCG_ALWAYS_INLINE inline
-#endif
-
-#ifdef min
-#undef min
-#endif
-
-#ifdef max
-#undef max
-#endif
-
-/*
- * The pcg_extras namespace contains some support code that is likley to
- * be useful for a variety of RNGs, including:
- *      - 128-bit int support for platforms where it isn't available natively
- *      - bit twiddling operations
- *      - I/O of 128-bit and 8-bit integers
- *      - Handling the evilness of SeedSeq
- *      - Support for efficiently producing random numbers less than a given
- *        bound
- */
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #5
-// See the end of this file for a list
-
-/*
- * PCG Random Number Generation for C++
- *
- * Copyright 2014-2017 Melissa O'Neill <oneill@pcg-random.org>,
- *                     and the PCG Project contributors.
- *
- * SPDX-License-Identifier: (Apache-2.0 OR MIT)
- *
- * Licensed under the Apache License, Version 2.0 (provided in
- * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
- * or under the MIT license (provided in LICENSE-MIT.txt and at
- * http://opensource.org/licenses/MIT), at your option. This file may not
- * be copied, modified, or distributed except according to those terms.
- *
- * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
- * express or implied.  See your chosen license for details.
- *
- * For additional information about the PCG random number generation scheme,
- * visit http://www.pcg-random.org/.
- */
-
-/*
- * This file provides support code that is useful for random-number generation
- * but not specific to the PCG generation scheme, including:
- *      - 128-bit int support for platforms where it isn't available natively
- *      - bit twiddling operations
- *      - I/O of 128-bit and 8-bit integers
- *      - Handling the evilness of SeedSeq
- *      - Support for efficiently producing random numbers less than a given
- *        bound
- */
-
-#ifndef PCG_EXTRAS_HPP_INCLUDED
-#define PCG_EXTRAS_HPP_INCLUDED 1
-
-#include <cinttypes>
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <cassert>
-#include <limits>
-#include <iostream>
-#include <type_traits>
-#include <utility>
-#include <locale>
-#include <iterator>
-
-#ifdef __GNUC__
-    #include <cxxabi.h>
-#endif
-
-/*
- * Abstractions for compiler-specific directives
- */
-
-#ifdef __GNUC__
-    #define PCG_NOINLINE __attribute__((noinline))
-#else
-    #define PCG_NOINLINE
-#endif
-
-/*
- * Some members of the PCG library use 128-bit math.  When compiling on 64-bit
- * platforms, both GCC and Clang provide 128-bit integer types that are ideal
- * for the job.
- *
- * On 32-bit platforms (or with other compilers), we fall back to a C++
- * class that provides 128-bit unsigned integers instead.  It may seem
- * like we're reinventing the wheel here, because libraries already exist
- * that support large integers, but most existing libraries provide a very
- * generic multiprecision code, but here we're operating at a fixed size.
- * Also, most other libraries are fairly heavyweight.  So we use a direct
- * implementation.  Sadly, it's much slower than hand-coded assembly or
- * direct CPU support.
- *
- */
-#if __SIZEOF_INT128__
-    namespace pcg_extras {
-        typedef __uint128_t pcg128_t;
-    }
-    #define PCG_128BIT_CONSTANT(high,low) \
-            ((pcg_extras::pcg128_t(high) << 64) + low)
-#else
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #5
-// See the end of this file for a list
-
-/*
- * PCG Random Number Generation for C++
- *
- * Copyright 2014-2017 Melissa O'Neill <oneill@pcg-random.org>,
- *                     and the PCG Project contributors.
- *
- * SPDX-License-Identifier: (Apache-2.0 OR MIT)
- *
- * Licensed under the Apache License, Version 2.0 (provided in
- * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
- * or under the MIT license (provided in LICENSE-MIT.txt and at
- * http://opensource.org/licenses/MIT), at your option. This file may not
- * be copied, modified, or distributed except according to those terms.
- *
- * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
- * express or implied.  See your chosen license for details.
- *
- * For additional information about the PCG random number generation scheme,
- * visit http://www.pcg-random.org/.
- */
-
-/*
- * This code provides a a C++ class that can provide 128-bit (or higher)
- * integers.  To produce 2K-bit integers, it uses two K-bit integers,
- * placed in a union that allowes the code to also see them as four K/2 bit
- * integers (and access them either directly name, or by index).
- *
- * It may seem like we're reinventing the wheel here, because several
- * libraries already exist that support large integers, but most existing
- * libraries provide a very generic multiprecision code, but here we're
- * operating at a fixed size.  Also, most other libraries are fairly
- * heavyweight.  So we use a direct implementation.  Sadly, it's much slower
- * than hand-coded assembly or direct CPU support.
- */
-
-#ifndef PCG_UINT128_HPP_INCLUDED
-#define PCG_UINT128_HPP_INCLUDED 1
-
-#include <cstdint>
-#include <cstdio>
-#include <cassert>
-#include <climits>
-#include <utility>
-#include <initializer_list>
-#include <type_traits>
-
-#if defined(_MSC_VER)  // Use MSVC++ intrinsics
-#include <intrin.h>
-#endif
-
-/*
- * We want to lay the type out the same way that a native type would be laid
- * out, which means we must know the machine's endian, at compile time.
- * This ugliness attempts to do so.
- */
-
-#ifndef PCG_LITTLE_ENDIAN
-    #if defined(__BYTE_ORDER__)
-        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-            #define PCG_LITTLE_ENDIAN 1
-        #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-            #define PCG_LITTLE_ENDIAN 0
-        #else
-            #error __BYTE_ORDER__ does not match a standard endian, pick a side
-        #endif
-    #elif __LITTLE_ENDIAN__ || _LITTLE_ENDIAN
-        #define PCG_LITTLE_ENDIAN 1
-    #elif __BIG_ENDIAN__ || _BIG_ENDIAN
-        #define PCG_LITTLE_ENDIAN 0
-    #elif __x86_64 || __x86_64__ || _M_X64 || __i386 || __i386__ || _M_IX86
-        #define PCG_LITTLE_ENDIAN 1
-    #elif __powerpc__ || __POWERPC__ || __ppc__ || __PPC__ \
-          || __m68k__ || __mc68000__
-        #define PCG_LITTLE_ENDIAN 0
-    #else
-        #error Unable to determine target endianness
-    #endif
-#endif
-
-namespace pcg_extras {
-
-// Recent versions of GCC have intrinsics we can use to quickly calculate
-// the number of leading and trailing zeros in a number.  If possible, we
-// use them, otherwise we fall back to old-fashioned bit twiddling to figure
-// them out.
-
-#ifndef PCG_BITCOUNT_T
-    typedef uint8_t bitcount_t;
-#else
-    typedef PCG_BITCOUNT_T bitcount_t;
-#endif
-
-/*
- * Provide some useful helper functions
- *      * flog2                 floor(log2(x))
- *      * trailingzeros         number of trailing zero bits
- */
-
-#if defined(__GNUC__)   // Any GNU-compatible compiler supporting C++11 has
-                        // some useful intrinsics we can use.
-
-inline bitcount_t flog2(uint32_t v)
-{
-    return 31 - __builtin_clz(v);
-}
-
-inline bitcount_t trailingzeros(uint32_t v)
-{
-    return __builtin_ctz(v);
-}
-
-inline bitcount_t flog2(uint64_t v)
-{
-#if UINT64_MAX == ULONG_MAX
-    return 63 - __builtin_clzl(v);
-#elif UINT64_MAX == ULLONG_MAX
-    return 63 - __builtin_clzll(v);
-#else
-    #error Cannot find a function for uint64_t
-#endif
-}
-
-inline bitcount_t trailingzeros(uint64_t v)
-{
-#if UINT64_MAX == ULONG_MAX
-    return __builtin_ctzl(v);
-#elif UINT64_MAX == ULLONG_MAX
-    return __builtin_ctzll(v);
-#else
-    #error Cannot find a function for uint64_t
-#endif
-}
-
-#elif defined(_MSC_VER)  // Use MSVC++ intrinsics
-
-#pragma intrinsic(_BitScanReverse, _BitScanForward)
-#if defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)
-#pragma intrinsic(_BitScanReverse64, _BitScanForward64)
-#endif
-
-inline bitcount_t flog2(uint32_t v)
-{
-    unsigned long i;
-    _BitScanReverse(&i, v);
-    return bitcount_t(i);
-}
-
-inline bitcount_t trailingzeros(uint32_t v)
-{
-    unsigned long i;
-    _BitScanForward(&i, v);
-    return bitcount_t(i);
-}
-
-inline bitcount_t flog2(uint64_t v)
-{
-#if defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)
-    unsigned long i;
-    _BitScanReverse64(&i, v);
-    return bitcount_t(i);
-#else
-    // 32-bit x86
-    uint32_t high = v >> 32;
-    uint32_t low  = uint32_t(v);
-    return high ? 32+flog2(high) : flog2(low);
-#endif
-}
-
-inline bitcount_t trailingzeros(uint64_t v)
-{
-#if defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)
-    unsigned long i;
-    _BitScanForward64(&i, v);
-    return bitcount_t(i);
-#else
-    // 32-bit x86
-    uint32_t high = v >> 32;
-    uint32_t low  = uint32_t(v);
-    return low ? trailingzeros(low) : trailingzeros(high)+32;
-#endif
-}
-
-#else                   // Otherwise, we fall back to bit twiddling
-                        // implementations
-
-inline bitcount_t flog2(uint32_t v)
-{
-    // Based on code by Eric Cole and Mark Dickinson, which appears at
-    // https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn
-
-    static const uint8_t multiplyDeBruijnBitPos[32] = {
-      0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
-      8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
-    };
-
-    v |= v >> 1; // first round down to one less than a power of 2
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-
-    return multiplyDeBruijnBitPos[(uint32_t)(v * 0x07C4ACDDU) >> 27];
-}
-
-inline bitcount_t trailingzeros(uint32_t v)
-{
-    static const uint8_t multiplyDeBruijnBitPos[32] = {
-      0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
-      31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
-    };
-
-    return multiplyDeBruijnBitPos[((uint32_t)((v & -v) * 0x077CB531U)) >> 27];
-}
-
-inline bitcount_t flog2(uint64_t v)
-{
-    uint32_t high = v >> 32;
-    uint32_t low  = uint32_t(v);
-
-    return high ? 32+flog2(high) : flog2(low);
-}
-
-inline bitcount_t trailingzeros(uint64_t v)
-{
-    uint32_t high = v >> 32;
-    uint32_t low  = uint32_t(v);
-
-    return low ? trailingzeros(low) : trailingzeros(high)+32;
-}
-
-#endif
-
-inline bitcount_t flog2(uint8_t v)
-{
-    return flog2(uint32_t(v));
-}
-
-inline bitcount_t flog2(uint16_t v)
-{
-    return flog2(uint32_t(v));
-}
-
-#if __SIZEOF_INT128__
-inline bitcount_t flog2(__uint128_t v)
-{
-    uint64_t high = uint64_t(v >> 64);
-    uint64_t low  = uint64_t(v);
-
-    return high ? 64+flog2(high) : flog2(low);
-}
-#endif
-
-inline bitcount_t trailingzeros(uint8_t v)
-{
-    return trailingzeros(uint32_t(v));
-}
-
-inline bitcount_t trailingzeros(uint16_t v)
-{
-    return trailingzeros(uint32_t(v));
-}
-
-#if __SIZEOF_INT128__
-inline bitcount_t trailingzeros(__uint128_t v)
-{
-    uint64_t high = uint64_t(v >> 64);
-    uint64_t low  = uint64_t(v);
-    return low ? trailingzeros(low) : trailingzeros(high)+64;
-}
-#endif
-
-template <typename UInt>
-inline bitcount_t clog2(UInt v)
-{
-    return flog2(v) + ((v & (-v)) != v);
-}
-
-template <typename UInt>
-inline UInt addwithcarry(UInt x, UInt y, bool carryin, bool* carryout)
-{
-    UInt half_result = y + carryin;
-    UInt result = x + half_result;
-    *carryout = (half_result < y) || (result < x);
-    return result;
-}
-
-template <typename UInt>
-inline UInt subwithcarry(UInt x, UInt y, bool carryin, bool* carryout)
-{
-    UInt half_result = y + carryin;
-    UInt result = x - half_result;
-    *carryout = (half_result < y) || (result > x);
-    return result;
-}
-
-
-template <typename UInt, typename UIntX2>
-class uint_x4 {
-// private:
-    static constexpr unsigned int UINT_BITS = sizeof(UInt) * CHAR_BIT;
-public:
-    union {
-#if PCG_LITTLE_ENDIAN
-        struct {
-            UInt v0, v1, v2, v3;
-        } w;
-        struct {
-            UIntX2 v01, v23;
-        } d;
-#else
-        struct {
-            UInt v3, v2, v1, v0;
-        } w;
-        struct {
-            UIntX2 v23, v01;
-        } d;
-#endif
-        // For the array access versions, the code that uses the array
-        // must handle endian itself.  Yuck.
-        UInt wa[4];
-        UIntX2 da[2];
-    };
-
-public:
-    uint_x4() = default;
-
-    constexpr uint_x4(UInt v3, UInt v2, UInt v1, UInt v0)
-#if PCG_LITTLE_ENDIAN
-       : w{v0, v1, v2, v3}
-#else
-       : w{v3, v2, v1, v0}
-#endif
-    {
-        // Nothing (else) to do
-    }
-
-    constexpr uint_x4(UIntX2 v23, UIntX2 v01)
-#if PCG_LITTLE_ENDIAN
-       : d{v01,v23}
-#else
-       : d{v23,v01}
-#endif
-    {
-        // Nothing (else) to do
-    }
-
-    constexpr uint_x4(UIntX2 v01)
-#if PCG_LITTLE_ENDIAN
-       : d{v01, UIntX2(0)}
-#else
-       : d{UIntX2(0),v01}
-#endif
-    {
-        // Nothing (else) to do
-    }
-
-    template<class Integral,
-             typename std::enable_if<(std::is_integral<Integral>::value
-                                      && sizeof(Integral) <= sizeof(UIntX2))
-                                    >::type* = nullptr>
-    constexpr uint_x4(Integral v01)
-#if PCG_LITTLE_ENDIAN
-       : d{UIntX2(v01), UIntX2(0)}
-#else
-       : d{UIntX2(0), UIntX2(v01)}
-#endif
-    {
-        // Nothing (else) to do
-    }
-
-    explicit constexpr operator UIntX2() const
-    {
-        return d.v01;
-    }
-
-    template<class Integral,
-             typename std::enable_if<(std::is_integral<Integral>::value
-                                      && sizeof(Integral) <= sizeof(UIntX2))
-                                    >::type* = nullptr>
-    explicit constexpr operator Integral() const
-    {
-        return Integral(d.v01);
-    }
-
-    explicit constexpr operator bool() const
-    {
-        return d.v01 || d.v23;
-    }
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator*(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator*(const uint_x4<U,V>&, V);
-
-    template<typename U, typename V>
-    friend std::pair< uint_x4<U,V>,uint_x4<U,V> >
-        divmod(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator+(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator-(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator<<(const uint_x4<U,V>&, const bitcount_t shift);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator>>(const uint_x4<U,V>&, const bitcount_t shift);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator&(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator|(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator^(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator==(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator!=(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator<(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator<=(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator>(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bool operator>=(const uint_x4<U,V>&, const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator~(const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend uint_x4<U,V> operator-(const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bitcount_t flog2(const uint_x4<U,V>&);
-
-    template<typename U, typename V>
-    friend bitcount_t trailingzeros(const uint_x4<U,V>&);
-
-    uint_x4& operator*=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this * rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator*=(UIntX2 rhs)
-    {
-        uint_x4 result = *this * rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator/=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this / rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator%=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this % rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator+=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this + rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator-=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this - rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator&=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this & rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator|=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this | rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator^=(const uint_x4& rhs)
-    {
-        uint_x4 result = *this ^ rhs;
-        return *this = result;
-    }
-
-    uint_x4& operator>>=(bitcount_t shift)
-    {
-        uint_x4 result = *this >> shift;
-        return *this = result;
-    }
-
-    uint_x4& operator<<=(bitcount_t shift)
-    {
-        uint_x4 result = *this << shift;
-        return *this = result;
-    }
-
-};
-
-template<typename U, typename V>
-bitcount_t flog2(const uint_x4<U,V>& v)
-{
-#if PCG_LITTLE_ENDIAN
-    for (uint8_t i = 4; i !=0; /* dec in loop */) {
-        --i;
-#else
-    for (uint8_t i = 0; i < 4; ++i) {
-#endif
-        if (v.wa[i] == 0)
-             continue;
-        return flog2(v.wa[i]) + uint_x4<U,V>::UINT_BITS*i;
-    }
-    abort();
-}
-
-template<typename U, typename V>
-bitcount_t trailingzeros(const uint_x4<U,V>& v)
-{
-#if PCG_LITTLE_ENDIAN
-    for (uint8_t i = 0; i < 4; ++i) {
-#else
-    for (uint8_t i = 4; i !=0; /* dec in loop */) {
-        --i;
-#endif
-        if (v.wa[i] != 0)
-            return trailingzeros(v.wa[i]) + uint_x4<U,V>::UINT_BITS*i;
-    }
-    return uint_x4<U,V>::UINT_BITS*4;
-}
-
-template <typename UInt, typename UIntX2>
-std::pair< uint_x4<UInt,UIntX2>, uint_x4<UInt,UIntX2> >
-    divmod(const uint_x4<UInt,UIntX2>& orig_dividend,
-           const uint_x4<UInt,UIntX2>& divisor)
-{
-    // If the dividend is less than the divisor, the answer is always zero.
-    // This takes care of boundary cases like 0/x (which would otherwise be
-    // problematic because we can't take the log of zero.  (The boundary case
-    // of division by zero is undefined.)
-    if (orig_dividend < divisor)
-        return { uint_x4<UInt,UIntX2>(UIntX2(0)), orig_dividend };
-
-    auto dividend = orig_dividend;
-
-    auto log2_divisor  = flog2(divisor);
-    auto log2_dividend = flog2(dividend);
-    // assert(log2_dividend >= log2_divisor);
-    bitcount_t logdiff = log2_dividend - log2_divisor;
-
-    constexpr uint_x4<UInt,UIntX2> ONE(UIntX2(1));
-    if (logdiff == 0)
-        return { ONE, dividend - divisor };
-
-    // Now we change the log difference to
-    //  floor(log2(divisor)) - ceil(log2(dividend))
-    // to ensure that we *underestimate* the result.
-    logdiff -= 1;
-
-    uint_x4<UInt,UIntX2> quotient(UIntX2(0));
-
-    auto qfactor = ONE << logdiff;
-    auto factor  = divisor << logdiff;
-
-    do {
-        dividend -= factor;
-        quotient += qfactor;
-        while (dividend < factor) {
-            factor  >>= 1;
-            qfactor >>= 1;
-        }
-    } while (dividend >= divisor);
-
-    return { quotient, dividend };
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator/(const uint_x4<UInt,UIntX2>& dividend,
-                               const uint_x4<UInt,UIntX2>& divisor)
-{
-    return divmod(dividend, divisor).first;
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator%(const uint_x4<UInt,UIntX2>& dividend,
-                               const uint_x4<UInt,UIntX2>& divisor)
-{
-    return divmod(dividend, divisor).second;
-}
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator*(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    constexpr auto UINT_BITS = uint_x4<UInt,UIntX2>::UINT_BITS;
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-    bool carryin = false;
-    bool carryout;
-    UIntX2 a0b0 = UIntX2(a.w.v0) * UIntX2(b.w.v0);
-    r.w.v0 = UInt(a0b0);
-    r.w.v1 = UInt(a0b0 >> UINT_BITS);
-
-    UIntX2 a1b0 = UIntX2(a.w.v1) * UIntX2(b.w.v0);
-    r.w.v2 = UInt(a1b0 >> UINT_BITS);
-    r.w.v1 = addwithcarry(r.w.v1, UInt(a1b0), carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    UIntX2 a0b1 = UIntX2(a.w.v0) * UIntX2(b.w.v1);
-    carryin = false;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(a0b1 >> UINT_BITS), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    carryin = false;
-    r.w.v1 = addwithcarry(r.w.v1, UInt(a0b1), carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    UIntX2 a1b1 = UIntX2(a.w.v1) * UIntX2(b.w.v1);
-    carryin = false;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(a1b1), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(a1b1 >> UINT_BITS), carryin, &carryout);
-
-    r.d.v23 += a.d.v01 * b.d.v23 + a.d.v23 * b.d.v01;
-
-    return r;
-}
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator*(const uint_x4<UInt,UIntX2>& a,
-                               UIntX2 b01)
-{
-    constexpr auto UINT_BITS = uint_x4<UInt,UIntX2>::UINT_BITS;
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-    bool carryin = false;
-    bool carryout;
-    UIntX2 a0b0 = UIntX2(a.w.v0) * UIntX2(UInt(b01));
-    r.w.v0 = UInt(a0b0);
-    r.w.v1 = UInt(a0b0 >> UINT_BITS);
-
-    UIntX2 a1b0 = UIntX2(a.w.v1) * UIntX2(UInt(b01));
-    r.w.v2 = UInt(a1b0 >> UINT_BITS);
-    r.w.v1 = addwithcarry(r.w.v1, UInt(a1b0), carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    UIntX2 a0b1 = UIntX2(a.w.v0) * UIntX2(b01 >> UINT_BITS);
-    carryin = false;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(a0b1 >> UINT_BITS), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    carryin = false;
-    r.w.v1 = addwithcarry(r.w.v1, UInt(a0b1), carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
-
-    UIntX2 a1b1 = UIntX2(a.w.v1) * UIntX2(b01 >> UINT_BITS);
-    carryin = false;
-    r.w.v2 = addwithcarry(r.w.v2, UInt(a1b1), carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(r.w.v3, UInt(a1b1 >> UINT_BITS), carryin, &carryout);
-
-    r.d.v23 += a.d.v23 * b01;
-
-    return r;
-}
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator+(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-
-    bool carryin = false;
-    bool carryout;
-    r.w.v0 = addwithcarry(a.w.v0, b.w.v0, carryin, &carryout);
-    carryin = carryout;
-    r.w.v1 = addwithcarry(a.w.v1, b.w.v1, carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = addwithcarry(a.w.v2, b.w.v2, carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = addwithcarry(a.w.v3, b.w.v3, carryin, &carryout);
-
-    return r;
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator-(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-
-    bool carryin = false;
-    bool carryout;
-    r.w.v0 = subwithcarry(a.w.v0, b.w.v0, carryin, &carryout);
-    carryin = carryout;
-    r.w.v1 = subwithcarry(a.w.v1, b.w.v1, carryin, &carryout);
-    carryin = carryout;
-    r.w.v2 = subwithcarry(a.w.v2, b.w.v2, carryin, &carryout);
-    carryin = carryout;
-    r.w.v3 = subwithcarry(a.w.v3, b.w.v3, carryin, &carryout);
-
-    return r;
-}
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator&(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    return uint_x4<UInt,UIntX2>(a.d.v23 & b.d.v23, a.d.v01 & b.d.v01);
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator|(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    return uint_x4<UInt,UIntX2>(a.d.v23 | b.d.v23, a.d.v01 | b.d.v01);
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator^(const uint_x4<UInt,UIntX2>& a,
-                               const uint_x4<UInt,UIntX2>& b)
-{
-    return uint_x4<UInt,UIntX2>(a.d.v23 ^ b.d.v23, a.d.v01 ^ b.d.v01);
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator~(const uint_x4<UInt,UIntX2>& v)
-{
-    return uint_x4<UInt,UIntX2>(~v.d.v23, ~v.d.v01);
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator-(const uint_x4<UInt,UIntX2>& v)
-{
-    return uint_x4<UInt,UIntX2>(0UL,0UL) - v;
-}
-
-template <typename UInt, typename UIntX2>
-bool operator==(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return (a.d.v01 == b.d.v01) && (a.d.v23 == b.d.v23);
-}
-
-template <typename UInt, typename UIntX2>
-bool operator!=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return !operator==(a,b);
-}
-
-
-template <typename UInt, typename UIntX2>
-bool operator<(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return (a.d.v23 < b.d.v23)
-           || ((a.d.v23 == b.d.v23) && (a.d.v01 < b.d.v01));
-}
-
-template <typename UInt, typename UIntX2>
-bool operator>(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return operator<(b,a);
-}
-
-template <typename UInt, typename UIntX2>
-bool operator<=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return !(operator<(b,a));
-}
-
-template <typename UInt, typename UIntX2>
-bool operator>=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
-{
-    return !(operator<(a,b));
-}
-
-
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator<<(const uint_x4<UInt,UIntX2>& v,
-                                const bitcount_t shift)
-{
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-    const bitcount_t bits    = uint_x4<UInt,UIntX2>::UINT_BITS;
-    const bitcount_t bitmask = bits - 1;
-    const bitcount_t shiftdiv = shift / bits;
-    const bitcount_t shiftmod = shift & bitmask;
-
-    if (shiftmod) {
-        UInt carryover = 0;
-#if PCG_LITTLE_ENDIAN
-        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
-#else
-        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
-            --out, --in;
-#endif
-            r.wa[out] = (v.wa[in] << shiftmod) | carryover;
-            carryover = (v.wa[in] >> (bits - shiftmod));
-        }
-    } else {
-#if PCG_LITTLE_ENDIAN
-        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
-#else
-        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
-            --out, --in;
-#endif
-            r.wa[out] = v.wa[in];
-        }
-    }
-
-    return r;
-}
-
-template <typename UInt, typename UIntX2>
-uint_x4<UInt,UIntX2> operator>>(const uint_x4<UInt,UIntX2>& v,
-                                const bitcount_t shift)
-{
-    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
-    const bitcount_t bits    = uint_x4<UInt,UIntX2>::UINT_BITS;
-    const bitcount_t bitmask = bits - 1;
-    const bitcount_t shiftdiv = shift / bits;
-    const bitcount_t shiftmod = shift & bitmask;
-
-    if (shiftmod) {
-        UInt carryover = 0;
-#if PCG_LITTLE_ENDIAN
-        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
-            --out, --in;
-#else
-        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
-#endif
-            r.wa[out] = (v.wa[in] >> shiftmod) | carryover;
-            carryover = (v.wa[in] << (bits - shiftmod));
-        }
-    } else {
-#if PCG_LITTLE_ENDIAN
-        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
-            --out, --in;
-#else
-        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
-#endif
-            r.wa[out] = v.wa[in];
-        }
-    }
-
-    return r;
-}
-
-} // namespace pcg_extras
-
-#endif // PCG_UINT128_HPP_INCLUDED
-
-// LICENSE_CHANGE_END
-
-    namespace pcg_extras {
-        typedef pcg_extras::uint_x4<uint32_t,uint64_t> pcg128_t;
-    }
-    #define PCG_128BIT_CONSTANT(high,low) \
-            pcg_extras::pcg128_t(high,low)
-    #define PCG_EMULATED_128BIT_MATH 1
-#endif
-
-
-namespace pcg_extras {
-
-/*
- * We often need to represent a "number of bits".  When used normally, these
- * numbers are never greater than 128, so an unsigned char is plenty.
- * If you're using a nonstandard generator of a larger size, you can set
- * PCG_BITCOUNT_T to have it define it as a larger size.  (Some compilers
- * might produce faster code if you set it to an unsigned int.)
- */
-
-#ifndef PCG_BITCOUNT_T
-    typedef uint8_t bitcount_t;
-#else
-    typedef PCG_BITCOUNT_T bitcount_t;
-#endif
-
-/*
- * C++ requires us to be able to serialize RNG state by printing or reading
- * it from a stream.  Because we use 128-bit ints, we also need to be able
- * ot print them, so here is code to do so.
- *
- * This code provides enough functionality to print 128-bit ints in decimal
- * and zero-padded in hex.  It's not a full-featured implementation.
- */
-
-template <typename CharT, typename Traits>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits>& out, pcg128_t value)
-{
-    auto desired_base = out.flags() & out.basefield;
-    bool want_hex = desired_base == out.hex;
-
-    if (want_hex) {
-        uint64_t highpart = uint64_t(value >> 64);
-        uint64_t lowpart  = uint64_t(value);
-        auto desired_width = out.width();
-        if (desired_width > 16) {
-            out.width(desired_width - 16);
-        }
-        if (highpart != 0 || desired_width > 16)
-            out << highpart;
-        CharT oldfill = '\0';
-        if (highpart != 0) {
-            out.width(16);
-            oldfill = out.fill('0');
-        }
-        auto oldflags = out.setf(decltype(desired_base){}, out.showbase);
-        out << lowpart;
-        out.setf(oldflags);
-        if (highpart != 0) {
-            out.fill(oldfill);
-        }
-        return out;
-    }
-    constexpr size_t MAX_CHARS_128BIT = 40;
-
-    char buffer[MAX_CHARS_128BIT];
-    char* pos = buffer+sizeof(buffer);
-    *(--pos) = '\0';
-    constexpr auto BASE = pcg128_t(10ULL);
-    do {
-        auto div = value / BASE;
-        auto mod = uint32_t(value - (div * BASE));
-        *(--pos) = '0' + char(mod);
-        value = div;
-    } while(value != pcg128_t(0ULL));
-    return out << pos;
-}
-
-template <typename CharT, typename Traits>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits>& in, pcg128_t& value)
-{
-    typename std::basic_istream<CharT,Traits>::sentry s(in);
-
-    if (!s)
-         return in;
-
-    constexpr auto BASE = pcg128_t(10ULL);
-    pcg128_t current(0ULL);
-    bool did_nothing = true;
-    bool overflow = false;
-    for(;;) {
-        CharT wide_ch = in.get();
-        if (!in.good())
-            break;
-        auto ch = in.narrow(wide_ch, '\0');
-        if (ch < '0' || ch > '9') {
-            in.unget();
-            break;
-        }
-        did_nothing = false;
-        pcg128_t digit(uint32_t(ch - '0'));
-        pcg128_t timesbase = current*BASE;
-        overflow = overflow || timesbase < current;
-        current = timesbase + digit;
-        overflow = overflow || current < digit;
-    }
-
-    if (did_nothing || overflow) {
-        in.setstate(std::ios::failbit);
-        if (overflow)
-            current = ~pcg128_t(0ULL);
-    }
-
-    value = current;
-
-    return in;
-}
-
-/*
- * Likewise, if people use tiny rngs, we'll be serializing uint8_t.
- * If we just used the provided IO operators, they'd read/write chars,
- * not ints, so we need to define our own.  We *can* redefine this operator
- * here because we're in our own namespace.
- */
-
-template <typename CharT, typename Traits>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits>&out, uint8_t value)
-{
-    return out << uint32_t(value);
-}
-
-template <typename CharT, typename Traits>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits>& in, uint8_t& target)
-{
-    uint32_t value = 0xdecea5edU;
-    in >> value;
-    if (!in && value == 0xdecea5edU)
-        return in;
-    if (value > uint8_t(~0)) {
-        in.setstate(std::ios::failbit);
-        value = ~0U;
-    }
-    target = uint8_t(value);
-    return in;
-}
-
-/* Unfortunately, the above functions don't get found in preference to the
- * built in ones, so we create some more specific overloads that will.
- * Ugh.
- */
-
-inline std::ostream& operator<<(std::ostream& out, uint8_t value)
-{
-    return pcg_extras::operator<< <char>(out, value);
-}
-
-inline std::istream& operator>>(std::istream& in, uint8_t& value)
-{
-    return pcg_extras::operator>> <char>(in, value);
-}
-
-
-
-/*
- * Useful bitwise operations.
- */
-
-/*
- * XorShifts are invertable, but they are someting of a pain to invert.
- * This function backs them out.  It's used by the whacky "inside out"
- * generator defined later.
- */
-
-template <typename itype>
-inline itype unxorshift(itype x, bitcount_t bits, bitcount_t shift)
-{
-    if (2*shift >= bits) {
-        return x ^ (x >> shift);
-    }
-    itype lowmask1 = (itype(1U) << (bits - shift*2)) - 1;
-    itype highmask1 = ~lowmask1;
-    itype top1 = x;
-    itype bottom1 = x & lowmask1;
-    top1 ^= top1 >> shift;
-    top1 &= highmask1;
-    x = top1 | bottom1;
-    itype lowmask2 = (itype(1U) << (bits - shift)) - 1;
-    itype bottom2 = x & lowmask2;
-    bottom2 = unxorshift(bottom2, bits - shift, shift);
-    bottom2 &= lowmask1;
-    return top1 | bottom2;
-}
-
-/*
- * Rotate left and right.
- *
- * In ideal world, compilers would spot idiomatic rotate code and convert it
- * to a rotate instruction.  Of course, opinions vary on what the correct
- * idiom is and how to spot it.  For clang, sometimes it generates better
- * (but still crappy) code if you define PCG_USE_ZEROCHECK_ROTATE_IDIOM.
- */
-
-template <typename itype>
-inline itype rotl(itype value, bitcount_t rot)
-{
-    constexpr bitcount_t bits = sizeof(itype) * 8;
-    constexpr bitcount_t mask = bits - 1;
-#if PCG_USE_ZEROCHECK_ROTATE_IDIOM
-    return rot ? (value << rot) | (value >> (bits - rot)) : value;
-#else
-    return (value << rot) | (value >> ((- rot) & mask));
-#endif
-}
-
-template <typename itype>
-inline itype rotr(itype value, bitcount_t rot)
-{
-    constexpr bitcount_t bits = sizeof(itype) * 8;
-    constexpr bitcount_t mask = bits - 1;
-#if PCG_USE_ZEROCHECK_ROTATE_IDIOM
-    return rot ? (value >> rot) | (value << (bits - rot)) : value;
-#else
-    return (value >> rot) | (value << ((- rot) & mask));
-#endif
-}
-
-/* Unfortunately, both Clang and GCC sometimes perform poorly when it comes
- * to properly recognizing idiomatic rotate code, so for we also provide
- * assembler directives (enabled with PCG_USE_INLINE_ASM).  Boo, hiss.
- * (I hope that these compilers get better so that this code can die.)
- *
- * These overloads will be preferred over the general template code above.
- */
-#if PCG_USE_INLINE_ASM && __GNUC__ && (__x86_64__  || __i386__)
-
-inline uint8_t rotr(uint8_t value, bitcount_t rot)
-{
-    asm ("rorb   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
-    return value;
-}
-
-inline uint16_t rotr(uint16_t value, bitcount_t rot)
-{
-    asm ("rorw   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
-    return value;
-}
-
-inline uint32_t rotr(uint32_t value, bitcount_t rot)
-{
-    asm ("rorl   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
-    return value;
-}
-
-#if __x86_64__
-inline uint64_t rotr(uint64_t value, bitcount_t rot)
-{
-    asm ("rorq   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
-    return value;
-}
-#endif // __x86_64__
-
-#elif defined(_MSC_VER)
-  // Use MSVC++ bit rotation intrinsics
-
-#pragma intrinsic(_rotr, _rotr64, _rotr8, _rotr16)
-
-inline uint8_t rotr(uint8_t value, bitcount_t rot)
-{
-    return _rotr8(value, rot);
-}
-
-inline uint16_t rotr(uint16_t value, bitcount_t rot)
-{
-    return _rotr16(value, rot);
-}
-
-inline uint32_t rotr(uint32_t value, bitcount_t rot)
-{
-    return _rotr(value, rot);
-}
-
-inline uint64_t rotr(uint64_t value, bitcount_t rot)
-{
-    return _rotr64(value, rot);
-}
-
-#endif // PCG_USE_INLINE_ASM
-
-
-/*
- * The C++ SeedSeq concept (modelled by seed_seq) can fill an array of
- * 32-bit integers with seed data, but sometimes we want to produce
- * larger or smaller integers.
- *
- * The following code handles this annoyance.
- *
- * uneven_copy will copy an array of 32-bit ints to an array of larger or
- * smaller ints (actually, the code is general it only needing forward
- * iterators).  The copy is identical to the one that would be performed if
- * we just did memcpy on a standard little-endian machine, but works
- * regardless of the endian of the machine (or the weirdness of the ints
- * involved).
- *
- * generate_to initializes an array of integers using a SeedSeq
- * object.  It is given the size as a static constant at compile time and
- * tries to avoid memory allocation.  If we're filling in 32-bit constants
- * we just do it directly.  If we need a separate buffer and it's small,
- * we allocate it on the stack.  Otherwise, we fall back to heap allocation.
- * Ugh.
- *
- * generate_one produces a single value of some integral type using a
- * SeedSeq object.
- */
-
- /* uneven_copy helper, case where destination ints are less than 32 bit. */
-
-template<class SrcIter, class DestIter>
-SrcIter uneven_copy_impl(
-    SrcIter src_first, DestIter dest_first, DestIter dest_last,
-    std::true_type)
-{
-    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-
-    constexpr bitcount_t SRC_SIZE  = sizeof(src_t);
-    constexpr bitcount_t DEST_SIZE = sizeof(dest_t);
-    constexpr bitcount_t DEST_BITS = DEST_SIZE * 8;
-    constexpr bitcount_t SCALE     = SRC_SIZE / DEST_SIZE;
-
-    size_t count = 0;
-    src_t value = 0;
-
-    while (dest_first != dest_last) {
-        if ((count++ % SCALE) == 0)
-            value = *src_first++;       // Get more bits
-        else
-            value >>= DEST_BITS;        // Move down bits
-
-        *dest_first++ = dest_t(value);  // Truncates, ignores high bits.
-    }
-    return src_first;
-}
-
- /* uneven_copy helper, case where destination ints are more than 32 bit. */
-
-template<class SrcIter, class DestIter>
-SrcIter uneven_copy_impl(
-    SrcIter src_first, DestIter dest_first, DestIter dest_last,
-    std::false_type)
-{
-    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-
-    constexpr auto SRC_SIZE  = sizeof(src_t);
-    constexpr auto SRC_BITS  = SRC_SIZE * 8;
-    constexpr auto DEST_SIZE = sizeof(dest_t);
-    constexpr auto SCALE     = (DEST_SIZE+SRC_SIZE-1) / SRC_SIZE;
-
-    while (dest_first != dest_last) {
-        dest_t value(0UL);
-        unsigned int shift = 0;
-
-        for (size_t i = 0; i < SCALE; ++i) {
-            value |= dest_t(*src_first++) << shift;
-            shift += SRC_BITS;
-        }
-
-        *dest_first++ = value;
-    }
-    return src_first;
-}
-
-/* uneven_copy, call the right code for larger vs. smaller */
-
-template<class SrcIter, class DestIter>
-inline SrcIter uneven_copy(SrcIter src_first,
-                           DestIter dest_first, DestIter dest_last)
-{
-    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-
-    constexpr bool DEST_IS_SMALLER = sizeof(dest_t) < sizeof(src_t);
-
-    return uneven_copy_impl(src_first, dest_first, dest_last,
-                            std::integral_constant<bool, DEST_IS_SMALLER>{});
-}
-
-/* generate_to, fill in a fixed-size array of integral type using a SeedSeq
- * (actually works for any random-access iterator)
- */
-
-template <size_t size, typename SeedSeq, typename DestIter>
-inline void generate_to_impl(SeedSeq&& generator, DestIter dest,
-                             std::true_type)
-{
-    generator.generate(dest, dest+size);
-}
-
-template <size_t size, typename SeedSeq, typename DestIter>
-void generate_to_impl(SeedSeq&& generator, DestIter dest,
-                      std::false_type)
-{
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-    constexpr auto DEST_SIZE = sizeof(dest_t);
-    constexpr auto GEN_SIZE  = sizeof(uint32_t);
-
-    constexpr bool GEN_IS_SMALLER = GEN_SIZE < DEST_SIZE;
-    constexpr size_t FROM_ELEMS =
-        GEN_IS_SMALLER
-            ? size * ((DEST_SIZE+GEN_SIZE-1) / GEN_SIZE)
-            : (size + (GEN_SIZE / DEST_SIZE) - 1)
-                / ((GEN_SIZE / DEST_SIZE) + GEN_IS_SMALLER);
-                        //  this odd code ^^^^^^^^^^^^^^^^^ is work-around for
-                        //  a bug: http://llvm.org/bugs/show_bug.cgi?id=21287
-
-    if (FROM_ELEMS <= 1024) {
-        uint32_t buffer[FROM_ELEMS];
-        generator.generate(buffer, buffer+FROM_ELEMS);
-        uneven_copy(buffer, dest, dest+size);
-    } else {
-        uint32_t* buffer = static_cast<uint32_t*>(malloc(GEN_SIZE * FROM_ELEMS));
-        generator.generate(buffer, buffer+FROM_ELEMS);
-        uneven_copy(buffer, dest, dest+size);
-        free(static_cast<void*>(buffer));
-    }
-}
-
-template <size_t size, typename SeedSeq, typename DestIter>
-inline void generate_to(SeedSeq&& generator, DestIter dest)
-{
-    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
-    constexpr bool IS_32BIT = sizeof(dest_t) == sizeof(uint32_t);
-
-    generate_to_impl<size>(std::forward<SeedSeq>(generator), dest,
-                           std::integral_constant<bool, IS_32BIT>{});
-}
-
-/* generate_one, produce a value of integral type using a SeedSeq
- * (optionally, we can have it produce more than one and pick which one
- * we want)
- */
-
-template <typename UInt, size_t i = 0UL, size_t N = i+1UL, typename SeedSeq>
-inline UInt generate_one(SeedSeq&& generator)
-{
-    UInt result[N];
-    generate_to<N>(std::forward<SeedSeq>(generator), result);
-    return result[i];
-}
-
-template <typename RngType>
-auto bounded_rand(RngType& rng, typename RngType::result_type upper_bound)
-        -> typename RngType::result_type
-{
-    typedef typename RngType::result_type rtype;
-    rtype threshold = (RngType::max() - RngType::min() + rtype(1) - upper_bound)
-                    % upper_bound;
-    for (;;) {
-        rtype r = rng() - RngType::min();
-        if (r >= threshold)
-            return r % upper_bound;
-    }
-}
-
-template <typename Iter, typename RandType>
-void shuffle(Iter from, Iter to, RandType&& rng)
-{
-    typedef typename std::iterator_traits<Iter>::difference_type delta_t;
-    typedef typename std::remove_reference<RandType>::type::result_type result_t;
-    auto count = to - from;
-    while (count > 1) {
-        delta_t chosen = delta_t(bounded_rand(rng, result_t(count)));
-        --count;
-        --to;
-        using std::swap;
-        swap(*(from + chosen), *to);
-    }
-}
-
-/*
- * Although std::seed_seq is useful, it isn't everything.  Often we want to
- * initialize a random-number generator some other way, such as from a random
- * device.
- *
- * Technically, it does not meet the requirements of a SeedSequence because
- * it lacks some of the rarely-used member functions (some of which would
- * be impossible to provide).  However the C++ standard is quite specific
- * that actual engines only called the generate method, so it ought not to be
- * a problem in practice.
- */
-
-template <typename RngType>
-class seed_seq_from {
-private:
-    RngType rng_;
-
-    typedef uint_least32_t result_type;
-
-public:
-    template<typename... Args>
-    seed_seq_from(Args&&... args) :
-        rng_(std::forward<Args>(args)...)
-    {
-        // Nothing (else) to do...
-    }
-
-    template<typename Iter>
-    void generate(Iter start, Iter finish)
-    {
-        for (auto i = start; i != finish; ++i)
-            *i = result_type(rng_());
-    }
-
-    constexpr size_t size() const
-    {
-        return (sizeof(typename RngType::result_type) > sizeof(result_type)
-                && RngType::max() > ~size_t(0UL))
-             ? ~size_t(0UL)
-             : size_t(RngType::max());
-    }
-};
-
-/*
- * Sometimes you might want a distinct seed based on when the program
- * was compiled.  That way, a particular instance of the program will
- * behave the same way, but when recompiled it'll produce a different
- * value.
- */
-
-template <typename IntType>
-struct static_arbitrary_seed {
-private:
-    static constexpr IntType fnv(IntType hash, const char* pos) {
-        return *pos == '\0'
-             ? hash
-             : fnv((hash * IntType(16777619U)) ^ *pos, (pos+1));
-    }
-
-public:
-    static constexpr IntType value = fnv(IntType(2166136261U ^ sizeof(IntType)),
-                        __DATE__ __TIME__ __FILE__);
-};
-
-// Sometimes, when debugging or testing, it's handy to be able print the name
-// of a (in human-readable form).  This code allows the idiom:
-//
-//      cout << printable_typename<my_foo_type_t>()
-//
-// to print out my_foo_type_t (or its concrete type if it is a synonym)
-
-#if __cpp_rtti || __GXX_RTTI
-
-template <typename T>
-struct printable_typename {};
-
-template <typename T>
-std::ostream& operator<<(std::ostream& out, printable_typename<T>) {
-    const char *implementation_typename = typeid(T).name();
-#ifdef __GNUC__
-    int status;
-    char* pretty_name =
-        abi::__cxa_demangle(implementation_typename, nullptr, nullptr, &status);
-    if (status == 0)
-        out << pretty_name;
-    free(static_cast<void*>(pretty_name));
-    if (status == 0)
-        return out;
-#endif
-    out << implementation_typename;
-    return out;
-}
-
-#endif  // __cpp_rtti || __GXX_RTTI
-
-} // namespace pcg_extras
-
-#endif // PCG_EXTRAS_HPP_INCLUDED
-
-// LICENSE_CHANGE_END
-
-
-namespace pcg_detail {
-
-using namespace pcg_extras;
-
-/*
- * The LCG generators need some constants to function.  This code lets you
- * look up the constant by *type*.  For example
- *
- *      default_multiplier<uint32_t>::multiplier()
- *
- * gives you the default multipler for 32-bit integers.  We use the name
- * of the constant and not a generic word like value to allow these classes
- * to be used as mixins.
- */
-
-template <typename T>
-struct default_multiplier {
-    // Not defined for an arbitrary type
-};
-
-template <typename T>
-struct default_increment {
-    // Not defined for an arbitrary type
-};
-
-#define PCG_DEFINE_CONSTANT(type, what, kind, constant) \
-        template <>                                     \
-        struct what ## _ ## kind<type> {                \
-            static constexpr type kind() {              \
-                return constant;                        \
-            }                                           \
-        };
-
-PCG_DEFINE_CONSTANT(uint8_t,  default, multiplier, 141U)
-PCG_DEFINE_CONSTANT(uint8_t,  default, increment,  77U)
-
-PCG_DEFINE_CONSTANT(uint16_t, default, multiplier, 12829U)
-PCG_DEFINE_CONSTANT(uint16_t, default, increment,  47989U)
-
-PCG_DEFINE_CONSTANT(uint32_t, default, multiplier, 747796405U)
-PCG_DEFINE_CONSTANT(uint32_t, default, increment,  2891336453U)
-
-PCG_DEFINE_CONSTANT(uint64_t, default, multiplier, 6364136223846793005ULL)
-PCG_DEFINE_CONSTANT(uint64_t, default, increment,  1442695040888963407ULL)
-
-PCG_DEFINE_CONSTANT(pcg128_t, default, multiplier,
-        PCG_128BIT_CONSTANT(2549297995355413924ULL,4865540595714422341ULL))
-PCG_DEFINE_CONSTANT(pcg128_t, default, increment,
-        PCG_128BIT_CONSTANT(6364136223846793005ULL,1442695040888963407ULL))
-
-/* Alternative (cheaper) multipliers for 128-bit */
-
-template <typename T>
-struct cheap_multiplier : public default_multiplier<T> {
-    // For most types just use the default.
-};
-
-template <>
-struct cheap_multiplier<pcg128_t> {
-    static constexpr uint64_t multiplier() {
-        return 0xda942042e4dd58b5ULL;
-    }
-};
-
-
-/*
- * Each PCG generator is available in four variants, based on how it applies
- * the additive constant for its underlying LCG; the variations are:
- *
- *     single stream   - all instances use the same fixed constant, thus
- *                       the RNG always somewhere in same sequence
- *     mcg             - adds zero, resulting in a single stream and reduced
- *                       period
- *     specific stream - the constant can be changed at any time, selecting
- *                       a different random sequence
- *     unique stream   - the constant is based on the memory address of the
- *                       object, thus every RNG has its own unique sequence
- *
- * This variation is provided though mixin classes which define a function
- * value called increment() that returns the nesessary additive constant.
- */
-
-
-
-/*
- * unique stream
- */
-
-
-template <typename itype>
-class unique_stream {
-protected:
-    static constexpr bool is_mcg = false;
-
-    // Is never called, but is provided for symmetry with specific_stream
-    void set_stream(...)
-    {
-        abort();
-    }
-
-public:
-    typedef itype state_type;
-
-    constexpr itype increment() const {
-        return itype(reinterpret_cast<uintptr_t>(this) | 1);
-    }
-
-    constexpr itype stream() const
-    {
-         return increment() >> 1;
-    }
-
-    static constexpr bool can_specify_stream = false;
-
-    static constexpr size_t streams_pow2()
-    {
-        return (sizeof(itype) < sizeof(size_t) ? sizeof(itype)
-                                               : sizeof(size_t))*8 - 1u;
-    }
-
-protected:
-    constexpr unique_stream() = default;
-};
-
-
-/*
- * no stream (mcg)
- */
-
-template <typename itype>
-class no_stream {
-protected:
-    static constexpr bool is_mcg = true;
-
-    // Is never called, but is provided for symmetry with specific_stream
-    void set_stream(...)
-    {
-        abort();
-    }
-
-public:
-    typedef itype state_type;
-
-    static constexpr itype increment() {
-        return 0;
-    }
-
-    static constexpr bool can_specify_stream = false;
-
-    static constexpr size_t streams_pow2()
-    {
-        return 0u;
-    }
-
-protected:
-    constexpr no_stream() = default;
-};
-
-
-/*
- * single stream/sequence (oneseq)
- */
-
-template <typename itype>
-class oneseq_stream : public default_increment<itype> {
-protected:
-    static constexpr bool is_mcg = false;
-
-    // Is never called, but is provided for symmetry with specific_stream
-    void set_stream(...)
-    {
-        abort();
-    }
-
-public:
-    typedef itype state_type;
-
-    static constexpr itype stream()
-    {
-         return default_increment<itype>::increment() >> 1;
-    }
-
-    static constexpr bool can_specify_stream = false;
-
-    static constexpr size_t streams_pow2()
-    {
-        return 0u;
-    }
-
-protected:
-    constexpr oneseq_stream() = default;
-};
-
-
-/*
- * specific stream
- */
-
-template <typename itype>
-class specific_stream {
-protected:
-    static constexpr bool is_mcg = false;
-
-    itype inc_ = default_increment<itype>::increment();
-
-public:
-    typedef itype state_type;
-    typedef itype stream_state;
-
-    constexpr itype increment() const {
-        return inc_;
-    }
-
-    itype stream()
-    {
-         return inc_ >> 1;
-    }
-
-    void set_stream(itype specific_seq)
-    {
-         inc_ = (specific_seq << 1) | 1;
-    }
-
-    static constexpr bool can_specify_stream = true;
-
-    static constexpr size_t streams_pow2()
-    {
-        return (sizeof(itype)*8) - 1u;
-    }
-
-protected:
-    specific_stream() = default;
-
-    specific_stream(itype specific_seq)
-        : inc_(itype(specific_seq << 1) | itype(1U))
-    {
-        // Nothing (else) to do.
-    }
-};
-
-
-/*
- * This is where it all comes together.  This function joins together three
- * mixin classes which define
- *    - the LCG additive constant (the stream)
- *    - the LCG multiplier
- *    - the output function
- * in addition, we specify the type of the LCG state, and the result type,
- * and whether to use the pre-advance version of the state for the output
- * (increasing instruction-level parallelism) or the post-advance version
- * (reducing register pressure).
- *
- * Given the high level of parameterization, the code has to use some
- * template-metaprogramming tricks to handle some of the suble variations
- * involved.
- */
-
-template <typename xtype, typename itype,
-          typename output_mixin,
-          bool output_previous = true,
-          typename stream_mixin = oneseq_stream<itype>,
-          typename multiplier_mixin = default_multiplier<itype> >
-class engine : protected output_mixin,
-               public stream_mixin,
-               protected multiplier_mixin {
-protected:
-    itype state_;
-
-    struct can_specify_stream_tag {};
-    struct no_specifiable_stream_tag {};
-
-    using stream_mixin::increment;
-    using multiplier_mixin::multiplier;
-
-public:
-    typedef xtype result_type;
-    typedef itype state_type;
-
-    static constexpr size_t period_pow2()
-    {
-        return sizeof(state_type)*8 - 2*stream_mixin::is_mcg;
-    }
-
-    // It would be nice to use std::numeric_limits for these, but
-    // we can't be sure that it'd be defined for the 128-bit types.
-
-    static constexpr result_type min()
-    {
-        return result_type(0UL);
-    }
-
-    static constexpr result_type max()
-    {
-        return result_type(~result_type(0UL));
-    }
-
-protected:
-    itype bump(itype state)
-    {
-        return state * multiplier() + increment();
-    }
-
-    itype base_generate()
-    {
-        return state_ = bump(state_);
-    }
-
-    itype base_generate0()
-    {
-        itype old_state = state_;
-        state_ = bump(state_);
-        return old_state;
-    }
-
-public:
-    result_type operator()()
-    {
-        if (output_previous)
-            return this->output(base_generate0());
-        else
-            return this->output(base_generate());
-    }
-
-    result_type operator()(result_type upper_bound)
-    {
-        return bounded_rand(*this, upper_bound);
-    }
-
-protected:
-    static itype advance(itype state, itype delta,
-                         itype cur_mult, itype cur_plus);
-
-    static itype distance(itype cur_state, itype newstate, itype cur_mult,
-                          itype cur_plus, itype mask = ~itype(0U));
-
-    itype distance(itype newstate, itype mask = itype(~itype(0U))) const
-    {
-        return distance(state_, newstate, multiplier(), increment(), mask);
-    }
-
-public:
-    void advance(itype delta)
-    {
-        state_ = advance(state_, delta, this->multiplier(), this->increment());
-    }
-
-    void backstep(itype delta)
-    {
-        advance(-delta);
-    }
-
-    void discard(itype delta)
-    {
-        advance(delta);
-    }
-
-    bool wrapped()
-    {
-        if (stream_mixin::is_mcg) {
-            // For MCGs, the low order two bits never change. In this
-            // implementation, we keep them fixed at 3 to make this test
-            // easier.
-            return state_ == 3;
-        } else {
-            return state_ == 0;
-        }
-    }
-
-    engine(itype state = itype(0xcafef00dd15ea5e5ULL))
-        : state_(this->is_mcg ? state|state_type(3U)
-                              : bump(state + this->increment()))
-    {
-        // Nothing else to do.
-    }
-
-    // This function may or may not exist.  It thus has to be a template
-    // to use SFINAE; users don't have to worry about its template-ness.
-
-    template <typename sm = stream_mixin>
-    engine(itype state, typename sm::stream_state stream_seed)
-        : stream_mixin(stream_seed),
-          state_(this->is_mcg ? state|state_type(3U)
-                              : bump(state + this->increment()))
-    {
-        // Nothing else to do.
-    }
-
-    template<typename SeedSeq>
-    engine(SeedSeq&& seedSeq, typename std::enable_if<
-                  !stream_mixin::can_specify_stream
-               && !std::is_convertible<SeedSeq, itype>::value
-               && !std::is_convertible<SeedSeq, engine>::value,
-               no_specifiable_stream_tag>::type = {})
-        : engine(generate_one<itype>(std::forward<SeedSeq>(seedSeq)))
-    {
-        // Nothing else to do.
-    }
-
-    template<typename SeedSeq>
-    engine(SeedSeq&& seedSeq, typename std::enable_if<
-                   stream_mixin::can_specify_stream
-               && !std::is_convertible<SeedSeq, itype>::value
-               && !std::is_convertible<SeedSeq, engine>::value,
-        can_specify_stream_tag>::type = {})
-        : engine(generate_one<itype,1,2>(seedSeq),
-                 generate_one<itype,0,2>(seedSeq))
-    {
-        // Nothing else to do.
-    }
-
-
-    template<typename... Args>
-    void seed(Args&&... args)
-    {
-        new (this) engine(std::forward<Args>(args)...);
-    }
-
-    template <typename xtype1, typename itype1,
-              typename output_mixin1, bool output_previous1,
-              typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-              typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-    friend bool operator==(const engine<xtype1,itype1,
-                                     output_mixin1,output_previous1,
-                                     stream_mixin_lhs, multiplier_mixin_lhs>&,
-                           const engine<xtype1,itype1,
-                                     output_mixin1,output_previous1,
-                                     stream_mixin_rhs, multiplier_mixin_rhs>&);
-
-    template <typename xtype1, typename itype1,
-              typename output_mixin1, bool output_previous1,
-              typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-              typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-    friend itype1 operator-(const engine<xtype1,itype1,
-                                     output_mixin1,output_previous1,
-                                     stream_mixin_lhs, multiplier_mixin_lhs>&,
-                            const engine<xtype1,itype1,
-                                     output_mixin1,output_previous1,
-                                     stream_mixin_rhs, multiplier_mixin_rhs>&);
-
-    template <typename CharT, typename Traits,
-              typename xtype1, typename itype1,
-              typename output_mixin1, bool output_previous1,
-              typename stream_mixin1, typename multiplier_mixin1>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& out,
-               const engine<xtype1,itype1,
-                              output_mixin1,output_previous1,
-                              stream_mixin1, multiplier_mixin1>&);
-
-    template <typename CharT, typename Traits,
-              typename xtype1, typename itype1,
-              typename output_mixin1, bool output_previous1,
-              typename stream_mixin1, typename multiplier_mixin1>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& in,
-               engine<xtype1, itype1,
-                        output_mixin1, output_previous1,
-                        stream_mixin1, multiplier_mixin1>& rng);
-};
-
-template <typename CharT, typename Traits,
-          typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin, typename multiplier_mixin>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits>& out,
-           const engine<xtype,itype,
-                          output_mixin,output_previous,
-                          stream_mixin, multiplier_mixin>& rng)
-{
-    using pcg_extras::operator<<;
-
-    auto orig_flags = out.flags(std::ios_base::dec | std::ios_base::left);
-    auto space = out.widen(' ');
-    auto orig_fill = out.fill();
-
-    out << rng.multiplier() << space
-        << rng.increment() << space
-        << rng.state_;
-
-    out.flags(orig_flags);
-    out.fill(orig_fill);
-    return out;
-}
-
-
-template <typename CharT, typename Traits,
-          typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin, typename multiplier_mixin>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits>& in,
-           engine<xtype,itype,
-                    output_mixin,output_previous,
-                    stream_mixin, multiplier_mixin>& rng)
-{
-    using pcg_extras::operator>>;
-
-    auto orig_flags = in.flags(std::ios_base::dec | std::ios_base::skipws);
-
-    itype multiplier, increment, state;
-    in >> multiplier >> increment >> state;
-
-    if (!in.fail()) {
-        bool good = true;
-        if (multiplier != rng.multiplier()) {
-           good = false;
-        } else if (rng.can_specify_stream) {
-           rng.set_stream(increment >> 1);
-        } else if (increment != rng.increment()) {
-           good = false;
-        }
-        if (good) {
-            rng.state_ = state;
-        } else {
-            in.clear(std::ios::failbit);
-        }
-    }
-
-    in.flags(orig_flags);
-    return in;
-}
-
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin, typename multiplier_mixin>
-itype engine<xtype,itype,output_mixin,output_previous,stream_mixin,
-             multiplier_mixin>::advance(
-    itype state, itype delta, itype cur_mult, itype cur_plus)
-{
-    // The method used here is based on Brown, "Random Number Generation
-    // with Arbitrary Stride,", Transactions of the American Nuclear
-    // Society (Nov. 1994).  The algorithm is very similar to fast
-    // exponentiation.
-    //
-    // Even though delta is an unsigned integer, we can pass a
-    // signed integer to go backwards, it just goes "the long way round".
-
-    constexpr itype ZERO = 0u;  // itype may be a non-trivial types, so
-    constexpr itype ONE  = 1u;  // we define some ugly constants.
-    itype acc_mult = 1;
-    itype acc_plus = 0;
-    while (delta > ZERO) {
-       if (delta & ONE) {
-          acc_mult *= cur_mult;
-          acc_plus = acc_plus*cur_mult + cur_plus;
-       }
-       cur_plus = (cur_mult+ONE)*cur_plus;
-       cur_mult *= cur_mult;
-       delta >>= 1;
-    }
-    return acc_mult * state + acc_plus;
-}
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin, typename multiplier_mixin>
-itype engine<xtype,itype,output_mixin,output_previous,stream_mixin,
-               multiplier_mixin>::distance(
-    itype cur_state, itype newstate, itype cur_mult, itype cur_plus, itype mask)
-{
-    constexpr itype ONE  = 1u;  // itype could be weird, so use constant
-    bool is_mcg = cur_plus == itype(0);
-    itype the_bit = is_mcg ? itype(4u) : itype(1u);
-    itype distance = 0u;
-    while ((cur_state & mask) != (newstate & mask)) {
-       if ((cur_state & the_bit) != (newstate & the_bit)) {
-           cur_state = cur_state * cur_mult + cur_plus;
-           distance |= the_bit;
-       }
-       assert((cur_state & the_bit) == (newstate & the_bit));
-       the_bit <<= 1;
-       cur_plus = (cur_mult+ONE)*cur_plus;
-       cur_mult *= cur_mult;
-    }
-    return is_mcg ? distance >> 2 : distance;
-}
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-itype operator-(const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
-               const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
-{
-    static_assert(
-        std::is_same<stream_mixin_lhs, stream_mixin_rhs>::value &&
-            std::is_same<multiplier_mixin_lhs, multiplier_mixin_rhs>::value,
-        "Incomparable generators");
-    if (lhs.increment() == rhs.increment()) {
-       return rhs.distance(lhs.state_);
-    } else  {
-       constexpr itype ONE = 1u;
-       itype lhs_diff = lhs.increment() + (lhs.multiplier()-ONE) * lhs.state_;
-       itype rhs_diff = rhs.increment() + (rhs.multiplier()-ONE) * rhs.state_;
-       if ((lhs_diff & itype(3u)) != (rhs_diff & itype(3u))) {
-           rhs_diff = -rhs_diff;
-       }
-       return rhs.distance(rhs_diff, lhs_diff, rhs.multiplier(), itype(0u));
-    }
-}
-
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-bool operator==(const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
-                const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
-{
-    return    (lhs.multiplier() == rhs.multiplier())
-           && (lhs.increment()  == rhs.increment())
-           && (lhs.state_       == rhs.state_);
-}
-
-template <typename xtype, typename itype,
-          typename output_mixin, bool output_previous,
-          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
-          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
-inline bool operator!=(const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
-                       const engine<xtype,itype,
-                               output_mixin,output_previous,
-                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
-{
-    return !operator==(lhs,rhs);
-}
-
-
-template <typename xtype, typename itype,
-         template<typename XT,typename IT> class output_mixin,
-         bool output_previous = (sizeof(itype) <= 8),
-         template<typename IT> class multiplier_mixin = default_multiplier>
-using oneseq_base  = engine<xtype, itype,
-                        output_mixin<xtype, itype>, output_previous,
-                        oneseq_stream<itype>,
-                        multiplier_mixin<itype> >;
-
-template <typename xtype, typename itype,
-         template<typename XT,typename IT> class output_mixin,
-         bool output_previous = (sizeof(itype) <= 8),
-         template<typename IT> class multiplier_mixin = default_multiplier>
-using unique_base = engine<xtype, itype,
-                         output_mixin<xtype, itype>, output_previous,
-                         unique_stream<itype>,
-                         multiplier_mixin<itype> >;
-
-template <typename xtype, typename itype,
-         template<typename XT,typename IT> class output_mixin,
-         bool output_previous = (sizeof(itype) <= 8),
-         template<typename IT> class multiplier_mixin = default_multiplier>
-using setseq_base = engine<xtype, itype,
-                         output_mixin<xtype, itype>, output_previous,
-                         specific_stream<itype>,
-                         multiplier_mixin<itype> >;
-
-template <typename xtype, typename itype,
-         template<typename XT,typename IT> class output_mixin,
-         bool output_previous = (sizeof(itype) <= 8),
-         template<typename IT> class multiplier_mixin = default_multiplier>
-using mcg_base = engine<xtype, itype,
-                      output_mixin<xtype, itype>, output_previous,
-                      no_stream<itype>,
-                      multiplier_mixin<itype> >;
-
-/*
- * OUTPUT FUNCTIONS.
- *
- * These are the core of the PCG generation scheme.  They specify how to
- * turn the base LCG's internal state into the output value of the final
- * generator.
- *
- * They're implemented as mixin classes.
- *
- * All of the classes have code that is written to allow it to be applied
- * at *arbitrary* bit sizes, although in practice they'll only be used at
- * standard sizes supported by C++.
- */
-
-/*
- * XSH RS -- high xorshift, followed by a random shift
- *
- * Fast.  A good performer.
- */
-
-template <typename xtype, typename itype>
-struct xsh_rs_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t sparebits   = bits - xtypebits;
-        constexpr bitcount_t opbits =
-                              sparebits-5 >= 64 ? 5
-                            : sparebits-4 >= 32 ? 4
-                            : sparebits-3 >= 16 ? 3
-                            : sparebits-2 >= 4  ? 2
-                            : sparebits-1 >= 1  ? 1
-                            :                     0;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        constexpr bitcount_t maxrandshift  = mask;
-        constexpr bitcount_t topspare     = opbits;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift     = topspare + (xtypebits+maxrandshift)/2;
-        bitcount_t rshift =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
-        internal ^= internal >> xshift;
-        xtype result = xtype(internal >> (bottomspare - maxrandshift + rshift));
-        return result;
-    }
-};
-
-/*
- * XSH RR -- high xorshift, followed by a random rotate
- *
- * Fast.  A good performer.  Slightly better statistically than XSH RS.
- */
-
-template <typename xtype, typename itype>
-struct xsh_rr_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype)*8);
-        constexpr bitcount_t sparebits   = bits - xtypebits;
-        constexpr bitcount_t wantedopbits =
-                              xtypebits >= 128 ? 7
-                            : xtypebits >=  64 ? 6
-                            : xtypebits >=  32 ? 5
-                            : xtypebits >=  16 ? 4
-                            :                    3;
-        constexpr bitcount_t opbits =
-                              sparebits >= wantedopbits ? wantedopbits
-                                                        : sparebits;
-        constexpr bitcount_t amplifier = wantedopbits - opbits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        constexpr bitcount_t topspare    = opbits;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift      = (topspare + xtypebits)/2;
-        bitcount_t rot = opbits ? bitcount_t(internal >> (bits - opbits)) & mask
-                                : 0;
-        bitcount_t amprot = (rot << amplifier) & mask;
-        internal ^= internal >> xshift;
-        xtype result = xtype(internal >> bottomspare);
-        result = rotr(result, amprot);
-        return result;
-    }
-};
-
-/*
- * RXS -- random xorshift
- */
-
-template <typename xtype, typename itype>
-struct rxs_mixin {
-static xtype output_rxs(itype internal)
-    {
-        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype)*8);
-        constexpr bitcount_t shift       = bits - xtypebits;
-        constexpr bitcount_t extrashift  = (xtypebits - shift)/2;
-        bitcount_t rshift = shift > 64+8 ? (internal >> (bits - 6)) & 63
-                       : shift > 32+4 ? (internal >> (bits - 5)) & 31
-                       : shift > 16+2 ? (internal >> (bits - 4)) & 15
-                       : shift >  8+1 ? (internal >> (bits - 3)) & 7
-                       : shift >  4+1 ? (internal >> (bits - 2)) & 3
-                       : shift >  2+1 ? (internal >> (bits - 1)) & 1
-                       :              0;
-        internal ^= internal >> (shift + extrashift - rshift);
-        xtype result = internal >> rshift;
-        return result;
-    }
-};
-
-/*
- * RXS M XS -- random xorshift, mcg multiply, fixed xorshift
- *
- * The most statistically powerful generator, but all those steps
- * make it slower than some of the others.  We give it the rottenest jobs.
- *
- * Because it's usually used in contexts where the state type and the
- * result type are the same, it is a permutation and is thus invertable.
- * We thus provide a function to invert it.  This function is used to
- * for the "inside out" generator used by the extended generator.
- */
-
-/* Defined type-based concepts for the multiplication step.  They're actually
- * all derived by truncating the 128-bit, which was computed to be a good
- * "universal" constant.
- */
-
-template <typename T>
-struct mcg_multiplier {
-    // Not defined for an arbitrary type
-};
-
-template <typename T>
-struct mcg_unmultiplier {
-    // Not defined for an arbitrary type
-};
-
-PCG_DEFINE_CONSTANT(uint8_t,  mcg, multiplier,   217U)
-PCG_DEFINE_CONSTANT(uint8_t,  mcg, unmultiplier, 105U)
-
-PCG_DEFINE_CONSTANT(uint16_t, mcg, multiplier,   62169U)
-PCG_DEFINE_CONSTANT(uint16_t, mcg, unmultiplier, 28009U)
-
-PCG_DEFINE_CONSTANT(uint32_t, mcg, multiplier,   277803737U)
-PCG_DEFINE_CONSTANT(uint32_t, mcg, unmultiplier, 2897767785U)
-
-PCG_DEFINE_CONSTANT(uint64_t, mcg, multiplier,   12605985483714917081ULL)
-PCG_DEFINE_CONSTANT(uint64_t, mcg, unmultiplier, 15009553638781119849ULL)
-
-PCG_DEFINE_CONSTANT(pcg128_t, mcg, multiplier,
-        PCG_128BIT_CONSTANT(17766728186571221404ULL, 12605985483714917081ULL))
-PCG_DEFINE_CONSTANT(pcg128_t, mcg, unmultiplier,
-        PCG_128BIT_CONSTANT(14422606686972528997ULL, 15009553638781119849ULL))
-
-
-template <typename xtype, typename itype>
-struct rxs_m_xs_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t opbits = xtypebits >= 128 ? 6
-                                 : xtypebits >=  64 ? 5
-                                 : xtypebits >=  32 ? 4
-                                 : xtypebits >=  16 ? 3
-                                 :                    2;
-        constexpr bitcount_t shift = bits - xtypebits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        bitcount_t rshift =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
-        internal ^= internal >> (opbits + rshift);
-        internal *= mcg_multiplier<itype>::multiplier();
-        xtype result = internal >> shift;
-        result ^= result >> ((2U*xtypebits+2U)/3U);
-        return result;
-    }
-
-    static itype unoutput(itype internal)
-    {
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t opbits = bits >= 128 ? 6
-                                 : bits >=  64 ? 5
-                                 : bits >=  32 ? 4
-                                 : bits >=  16 ? 3
-                                 :               2;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-
-        internal = unxorshift(internal, bits, (2U*bits+2U)/3U);
-
-        internal *= mcg_unmultiplier<itype>::unmultiplier();
-
-        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
-        internal = unxorshift(internal, bits, opbits + rshift);
-
-        return internal;
-    }
-};
-
-
-/*
- * RXS M -- random xorshift, mcg multiply
- */
-
-template <typename xtype, typename itype>
-struct rxs_m_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t opbits = xtypebits >= 128 ? 6
-                                 : xtypebits >=  64 ? 5
-                                 : xtypebits >=  32 ? 4
-                                 : xtypebits >=  16 ? 3
-                                 :                    2;
-        constexpr bitcount_t shift = bits - xtypebits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
-        internal ^= internal >> (opbits + rshift);
-        internal *= mcg_multiplier<itype>::multiplier();
-        xtype result = internal >> shift;
-        return result;
-    }
-};
-
-
-/*
- * DXSM -- double xorshift multiply
- *
- * This is a new, more powerful output permutation (added in 2019).  It's
- * a more comprehensive scrambling than RXS M, but runs faster on 128-bit
- * types.  Although primarily intended for use at large sizes, also works
- * at smaller sizes as well.
- *
- * This permutation is similar to xorshift multiply hash functions, except
- * that one of the multipliers is the LCG multiplier (to avoid needing to
- * have a second constant) and the other is based on the low-order bits.
- * This latter aspect means that the scrambling applied to the high bits
- * depends on the low bits, and makes it (to my eye) impractical to back
- * out the permutation without having the low-order bits.
- */
-
-template <typename xtype, typename itype>
-struct dxsm_mixin {
-    inline xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t itypebits = bitcount_t(sizeof(itype) * 8);
-        static_assert(xtypebits <= itypebits/2,
-                      "Output type must be half the size of the state type.");
-
-        xtype hi = xtype(internal >> (itypebits - xtypebits));
-        xtype lo = xtype(internal);
-
-        lo |= 1;
-        hi ^= hi >> (xtypebits/2);
-	hi *= xtype(cheap_multiplier<itype>::multiplier());
-	hi ^= hi >> (3*(xtypebits/4));
-	hi *= lo;
-	return hi;
-    }
-};
-
-
-/*
- * XSL RR -- fixed xorshift (to low bits), random rotate
- *
- * Useful for 128-bit types that are split across two CPU registers.
- */
-
-template <typename xtype, typename itype>
-struct xsl_rr_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t sparebits = bits - xtypebits;
-        constexpr bitcount_t wantedopbits = xtypebits >= 128 ? 7
-                                       : xtypebits >=  64 ? 6
-                                       : xtypebits >=  32 ? 5
-                                       : xtypebits >=  16 ? 4
-                                       :                    3;
-        constexpr bitcount_t opbits = sparebits >= wantedopbits ? wantedopbits
-                                                             : sparebits;
-        constexpr bitcount_t amplifier = wantedopbits - opbits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        constexpr bitcount_t topspare = sparebits;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
-
-        bitcount_t rot =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
-        bitcount_t amprot = (rot << amplifier) & mask;
-        internal ^= internal >> xshift;
-        xtype result = xtype(internal >> bottomspare);
-        result = rotr(result, amprot);
-        return result;
-    }
-};
-
-
-/*
- * XSL RR RR -- fixed xorshift (to low bits), random rotate (both parts)
- *
- * Useful for 128-bit types that are split across two CPU registers.
- * If you really want an invertable 128-bit RNG, I guess this is the one.
- */
-
-template <typename T> struct halfsize_trait {};
-template <> struct halfsize_trait<pcg128_t>  { typedef uint64_t type; };
-template <> struct halfsize_trait<uint64_t>  { typedef uint32_t type; };
-template <> struct halfsize_trait<uint32_t>  { typedef uint16_t type; };
-template <> struct halfsize_trait<uint16_t>  { typedef uint8_t type;  };
-
-template <typename xtype, typename itype>
-struct xsl_rr_rr_mixin {
-    typedef typename halfsize_trait<itype>::type htype;
-
-    static itype output(itype internal)
-    {
-        constexpr bitcount_t htypebits = bitcount_t(sizeof(htype) * 8);
-        constexpr bitcount_t bits      = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t sparebits = bits - htypebits;
-        constexpr bitcount_t wantedopbits = htypebits >= 128 ? 7
-                                       : htypebits >=  64 ? 6
-                                       : htypebits >=  32 ? 5
-                                       : htypebits >=  16 ? 4
-                                       :                    3;
-        constexpr bitcount_t opbits = sparebits >= wantedopbits ? wantedopbits
-                                                                : sparebits;
-        constexpr bitcount_t amplifier = wantedopbits - opbits;
-        constexpr bitcount_t mask = (1 << opbits) - 1;
-        constexpr bitcount_t topspare = sparebits;
-        constexpr bitcount_t xshift = (topspare + htypebits) / 2;
-
-        bitcount_t rot =
-            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
-        bitcount_t amprot = (rot << amplifier) & mask;
-        internal ^= internal >> xshift;
-        htype lowbits = htype(internal);
-        lowbits = rotr(lowbits, amprot);
-        htype highbits = htype(internal >> topspare);
-        bitcount_t rot2 = lowbits & mask;
-        bitcount_t amprot2 = (rot2 << amplifier) & mask;
-        highbits = rotr(highbits, amprot2);
-        return (itype(highbits) << topspare) ^ itype(lowbits);
-    }
-};
-
-
-/*
- * XSH -- fixed xorshift (to high bits)
- *
- * You shouldn't use this at 64-bits or less.
- */
-
-template <typename xtype, typename itype>
-struct xsh_mixin {
-    static xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t sparebits = bits - xtypebits;
-        constexpr bitcount_t topspare = 0;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
-
-        internal ^= internal >> xshift;
-        xtype result = internal >> bottomspare;
-        return result;
-    }
-};
-
-/*
- * XSL -- fixed xorshift (to low bits)
- *
- * You shouldn't use this at 64-bits or less.
- */
-
-template <typename xtype, typename itype>
-struct xsl_mixin {
-    inline xtype output(itype internal)
-    {
-        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
-        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
-        constexpr bitcount_t sparebits = bits - xtypebits;
-        constexpr bitcount_t topspare = sparebits;
-        constexpr bitcount_t bottomspare = sparebits - topspare;
-        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
-
-        internal ^= internal >> xshift;
-        xtype result = internal >> bottomspare;
-        return result;
-    }
-};
-
-
-/* ---- End of Output Functions ---- */
-
-
-template <typename baseclass>
-struct inside_out : private baseclass {
-    inside_out() = delete;
-
-    typedef typename baseclass::result_type result_type;
-    typedef typename baseclass::state_type  state_type;
-    static_assert(sizeof(result_type) == sizeof(state_type),
-                  "Require a RNG whose output function is a permutation");
-
-    static bool external_step(result_type& randval, size_t i)
-    {
-        state_type state = baseclass::unoutput(randval);
-        state = state * baseclass::multiplier() + baseclass::increment()
-                + state_type(i*2);
-        result_type result = baseclass::output(state);
-        randval = result;
-        state_type zero =
-            baseclass::is_mcg ? state & state_type(3U) : state_type(0U);
-        return result == zero;
-    }
-
-    static bool external_advance(result_type& randval, size_t i,
-                                 result_type delta, bool forwards = true)
-    {
-        state_type state = baseclass::unoutput(randval);
-        state_type mult  = baseclass::multiplier();
-        state_type inc   = baseclass::increment() + state_type(i*2);
-        state_type zero =
-            baseclass::is_mcg ? state & state_type(3U) : state_type(0U);
-        state_type dist_to_zero = baseclass::distance(state, zero, mult, inc);
-        bool crosses_zero =
-            forwards ? dist_to_zero <= delta
-                     : (-dist_to_zero) <= delta;
-        if (!forwards)
-            delta = -delta;
-        state = baseclass::advance(state, delta, mult, inc);
-        randval = baseclass::output(state);
-        return crosses_zero;
-    }
-};
-
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, typename baseclass, typename extvalclass, bool kdd = true>
-class pcg_extended : public baseclass {
-public:
-    typedef typename baseclass::state_type  state_type;
-    typedef typename baseclass::result_type result_type;
-    typedef inside_out<extvalclass> insideout;
-
-private:
-    static constexpr bitcount_t rtypebits = sizeof(result_type)*8;
-    static constexpr bitcount_t stypebits = sizeof(state_type)*8;
-
-    static constexpr bitcount_t tick_limit_pow2 = 64U;
-
-    static constexpr size_t table_size  = 1UL << table_pow2;
-    static constexpr size_t table_shift = stypebits - table_pow2;
-    static constexpr state_type table_mask =
-        (state_type(1U) << table_pow2) - state_type(1U);
-
-    static constexpr bool   may_tick  =
-        (advance_pow2 < stypebits) && (advance_pow2 < tick_limit_pow2);
-    static constexpr size_t tick_shift = stypebits - advance_pow2;
-    static constexpr state_type tick_mask  =
-        may_tick ? state_type(
-                       (uint64_t(1) << (advance_pow2*may_tick)) - 1)
-                                        // ^-- stupidity to appease GCC warnings
-                 : ~state_type(0U);
-
-    static constexpr bool may_tock = stypebits < tick_limit_pow2;
-
-    result_type data_[table_size];
-
-    PCG_NOINLINE void advance_table();
-
-    PCG_NOINLINE void advance_table(state_type delta, bool isForwards = true);
-
-    result_type& get_extended_value()
-    {
-        state_type state = this->state_;
-        if (kdd && baseclass::is_mcg) {
-            // The low order bits of an MCG are constant, so drop them.
-            state >>= 2;
-        }
-        size_t index       = kdd ? state &  table_mask
-                                 : state >> table_shift;
-
-        if (may_tick) {
-            bool tick = kdd ? (state & tick_mask) == state_type(0u)
-                            : (state >> tick_shift) == state_type(0u);
-            if (tick)
-                    advance_table();
-        }
-        if (may_tock) {
-            bool tock = state == state_type(0u);
-            if (tock)
-                advance_table();
-        }
-        return data_[index];
-    }
-
-public:
-    static constexpr size_t period_pow2()
-    {
-        return baseclass::period_pow2() + table_size*extvalclass::period_pow2();
-    }
-
-    PCG_ALWAYS_INLINE result_type operator()()
-    {
-        result_type rhs = get_extended_value();
-        result_type lhs = this->baseclass::operator()();
-        return lhs ^ rhs;
-    }
-
-    result_type operator()(result_type upper_bound)
-    {
-        return bounded_rand(*this, upper_bound);
-    }
-
-    void set(result_type wanted)
-    {
-        result_type& rhs = get_extended_value();
-        result_type lhs = this->baseclass::operator()();
-        rhs = lhs ^ wanted;
-    }
-
-    void advance(state_type distance, bool forwards = true);
-
-    void backstep(state_type distance)
-    {
-        advance(distance, false);
-    }
-
-    pcg_extended(const result_type* data)
-        : baseclass()
-    {
-        datainit(data);
-    }
-
-    pcg_extended(const result_type* data, state_type seed)
-        : baseclass(seed)
-    {
-        datainit(data);
-    }
-
-    // This function may or may not exist.  It thus has to be a template
-    // to use SFINAE; users don't have to worry about its template-ness.
-
-    template <typename bc = baseclass>
-    pcg_extended(const result_type* data, state_type seed,
-            typename bc::stream_state stream_seed)
-        : baseclass(seed, stream_seed)
-    {
-        datainit(data);
-    }
-
-    pcg_extended()
-        : baseclass()
-    {
-        selfinit();
-    }
-
-    pcg_extended(state_type seed)
-        : baseclass(seed)
-    {
-        selfinit();
-    }
-
-    // This function may or may not exist.  It thus has to be a template
-    // to use SFINAE; users don't have to worry about its template-ness.
-
-    template <typename bc = baseclass>
-    pcg_extended(state_type seed, typename bc::stream_state stream_seed)
-        : baseclass(seed, stream_seed)
-    {
-        selfinit();
-    }
-
-private:
-    void selfinit();
-    void datainit(const result_type* data);
-
-public:
-
-    template<typename SeedSeq, typename = typename std::enable_if<
-           !std::is_convertible<SeedSeq, result_type>::value
-        && !std::is_convertible<SeedSeq, pcg_extended>::value>::type>
-    pcg_extended(SeedSeq&& seedSeq)
-        : baseclass(seedSeq)
-    {
-        generate_to<table_size>(seedSeq, data_);
-    }
-
-    template<typename... Args>
-    void seed(Args&&... args)
-    {
-        new (this) pcg_extended(std::forward<Args>(args)...);
-    }
-
-    template <bitcount_t table_pow2_, bitcount_t advance_pow2_,
-              typename baseclass_, typename extvalclass_, bool kdd_>
-    friend bool operator==(const pcg_extended<table_pow2_, advance_pow2_,
-                                              baseclass_, extvalclass_, kdd_>&,
-                           const pcg_extended<table_pow2_, advance_pow2_,
-                                              baseclass_, extvalclass_, kdd_>&);
-
-    template <typename CharT, typename Traits,
-              bitcount_t table_pow2_, bitcount_t advance_pow2_,
-              typename baseclass_, typename extvalclass_, bool kdd_>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& out,
-               const pcg_extended<table_pow2_, advance_pow2_,
-                              baseclass_, extvalclass_, kdd_>&);
-
-    template <typename CharT, typename Traits,
-              bitcount_t table_pow2_, bitcount_t advance_pow2_,
-              typename baseclass_, typename extvalclass_, bool kdd_>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& in,
-               pcg_extended<table_pow2_, advance_pow2_,
-                        baseclass_, extvalclass_, kdd_>&);
-
-};
-
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::datainit(
-         const result_type* data)
-{
-    for (size_t i = 0; i < table_size; ++i)
-        data_[i] = data[i];
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::selfinit()
-{
-    // We need to fill the extended table with something, and we have
-    // very little provided data, so we use the base generator to
-    // produce values.  Although not ideal (use a seed sequence, folks!),
-    // unexpected correlations are mitigated by
-    //      - using XOR differences rather than the number directly
-    //      - the way the table is accessed, its values *won't* be accessed
-    //        in the same order the were written.
-    //      - any strange correlations would only be apparent if we
-    //        were to backstep the generator so that the base generator
-    //        was generating the same values again
-    result_type lhs = baseclass::operator()();
-    result_type rhs = baseclass::operator()();
-    result_type xdiff = lhs - rhs;
-    for (size_t i = 0; i < table_size; ++i) {
-        data_[i] = baseclass::operator()() ^ xdiff;
-    }
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-bool operator==(const pcg_extended<table_pow2, advance_pow2,
-                               baseclass, extvalclass, kdd>& lhs,
-                const pcg_extended<table_pow2, advance_pow2,
-                               baseclass, extvalclass, kdd>& rhs)
-{
-    auto& base_lhs = static_cast<const baseclass&>(lhs);
-    auto& base_rhs = static_cast<const baseclass&>(rhs);
-    return base_lhs == base_rhs
-        && std::equal(
-               std::begin(lhs.data_), std::end(lhs.data_),
-               std::begin(rhs.data_)
-           );
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-inline bool operator!=(const pcg_extended<table_pow2, advance_pow2,
-                                      baseclass, extvalclass, kdd>& lhs,
-                       const pcg_extended<table_pow2, advance_pow2,
-                                      baseclass, extvalclass, kdd>& rhs)
-{
-    return !operator==(lhs, rhs);
-}
-
-template <typename CharT, typename Traits,
-          bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits>& out,
-           const pcg_extended<table_pow2, advance_pow2,
-                          baseclass, extvalclass, kdd>& rng)
-{
-    auto orig_flags = out.flags(std::ios_base::dec | std::ios_base::left);
-    auto space = out.widen(' ');
-    auto orig_fill = out.fill();
-
-    out << rng.multiplier() << space
-        << rng.increment() << space
-        << rng.state_;
-
-    for (const auto& datum : rng.data_)
-        out << space << datum;
-
-    out.flags(orig_flags);
-    out.fill(orig_fill);
-    return out;
-}
-
-template <typename CharT, typename Traits,
-          bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits>& in,
-           pcg_extended<table_pow2, advance_pow2,
-                    baseclass, extvalclass, kdd>& rng)
-{
-    pcg_extended<table_pow2, advance_pow2, baseclass, extvalclass> new_rng;
-    auto& base_rng = static_cast<baseclass&>(new_rng);
-    in >> base_rng;
-
-    if (in.fail())
-        return in;
-
-    auto orig_flags = in.flags(std::ios_base::dec | std::ios_base::skipws);
-
-    for (auto& datum : new_rng.data_) {
-        in >> datum;
-        if (in.fail())
-            goto bail;
-    }
-
-    rng = new_rng;
-
-bail:
-    in.flags(orig_flags);
-    return in;
-}
-
-
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void
-pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance_table()
-{
-    bool carry = false;
-    for (size_t i = 0; i < table_size; ++i) {
-        if (carry) {
-            carry = insideout::external_step(data_[i],i+1);
-        }
-        bool carry2 = insideout::external_step(data_[i],i+1);
-        carry = carry || carry2;
-    }
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void
-pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance_table(
-        state_type delta, bool isForwards)
-{
-    typedef typename baseclass::state_type   base_state_t;
-    typedef typename extvalclass::state_type ext_state_t;
-    constexpr bitcount_t basebits = sizeof(base_state_t)*8;
-    constexpr bitcount_t extbits  = sizeof(ext_state_t)*8;
-    static_assert(basebits <= extbits || advance_pow2 > 0,
-                  "Current implementation might overflow its carry");
-
-    base_state_t carry = 0;
-    for (size_t i = 0; i < table_size; ++i) {
-        base_state_t total_delta = carry + delta;
-        ext_state_t  trunc_delta = ext_state_t(total_delta);
-        if (basebits > extbits) {
-            carry = total_delta >> extbits;
-        } else {
-            carry = 0;
-        }
-        carry +=
-            insideout::external_advance(data_[i],i+1, trunc_delta, isForwards);
-    }
-}
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename baseclass, typename extvalclass, bool kdd>
-void pcg_extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance(
-    state_type distance, bool forwards)
-{
-    static_assert(kdd,
-        "Efficient advance is too hard for non-kdd extension. "
-        "For a weak advance, cast to base class");
-    state_type zero =
-        baseclass::is_mcg ? this->state_ & state_type(3U) : state_type(0U);
-    if (may_tick) {
-        state_type ticks = distance >> (advance_pow2*may_tick);
-                                        // ^-- stupidity to appease GCC
-                                        // warnings
-        state_type adv_mask =
-            baseclass::is_mcg ? tick_mask << 2 : tick_mask;
-        state_type next_advance_distance = this->distance(zero, adv_mask);
-        if (!forwards)
-            next_advance_distance = (-next_advance_distance) & tick_mask;
-        if (next_advance_distance < (distance & tick_mask)) {
-            ++ticks;
-        }
-        if (ticks)
-            advance_table(ticks, forwards);
-    }
-    if (forwards) {
-        if (may_tock && this->distance(zero) <= distance)
-            advance_table();
-        baseclass::advance(distance);
-    } else {
-        if (may_tock && -(this->distance(zero)) <= distance)
-            advance_table(state_type(1U), false);
-        baseclass::advance(-distance);
-    }
-}
-
-} // namespace pcg_detail
-
-namespace pcg_engines {
-
-using namespace pcg_detail;
-
-/* Predefined types for XSH RS */
-
-typedef oneseq_base<uint8_t,  uint16_t, xsh_rs_mixin>  oneseq_xsh_rs_16_8;
-typedef oneseq_base<uint16_t, uint32_t, xsh_rs_mixin>  oneseq_xsh_rs_32_16;
-typedef oneseq_base<uint32_t, uint64_t, xsh_rs_mixin>  oneseq_xsh_rs_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, xsh_rs_mixin>  oneseq_xsh_rs_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, xsh_rs_mixin, true, cheap_multiplier>
-                                                       cm_oneseq_xsh_rs_128_64;
-
-typedef unique_base<uint8_t,  uint16_t, xsh_rs_mixin>  unique_xsh_rs_16_8;
-typedef unique_base<uint16_t, uint32_t, xsh_rs_mixin>  unique_xsh_rs_32_16;
-typedef unique_base<uint32_t, uint64_t, xsh_rs_mixin>  unique_xsh_rs_64_32;
-typedef unique_base<uint64_t, pcg128_t, xsh_rs_mixin>  unique_xsh_rs_128_64;
-typedef unique_base<uint64_t, pcg128_t, xsh_rs_mixin, true, cheap_multiplier>
-                                                       cm_unique_xsh_rs_128_64;
-
-typedef setseq_base<uint8_t,  uint16_t, xsh_rs_mixin>  setseq_xsh_rs_16_8;
-typedef setseq_base<uint16_t, uint32_t, xsh_rs_mixin>  setseq_xsh_rs_32_16;
-typedef setseq_base<uint32_t, uint64_t, xsh_rs_mixin>  setseq_xsh_rs_64_32;
-typedef setseq_base<uint64_t, pcg128_t, xsh_rs_mixin>  setseq_xsh_rs_128_64;
-typedef setseq_base<uint64_t, pcg128_t, xsh_rs_mixin, true, cheap_multiplier>
-                                                       cm_setseq_xsh_rs_128_64;
-
-typedef mcg_base<uint8_t,  uint16_t, xsh_rs_mixin>  mcg_xsh_rs_16_8;
-typedef mcg_base<uint16_t, uint32_t, xsh_rs_mixin>  mcg_xsh_rs_32_16;
-typedef mcg_base<uint32_t, uint64_t, xsh_rs_mixin>  mcg_xsh_rs_64_32;
-typedef mcg_base<uint64_t, pcg128_t, xsh_rs_mixin>  mcg_xsh_rs_128_64;
-typedef mcg_base<uint64_t, pcg128_t, xsh_rs_mixin, true, cheap_multiplier>
-                                                    cm_mcg_xsh_rs_128_64;
-
-/* Predefined types for XSH RR */
-
-typedef oneseq_base<uint8_t,  uint16_t, xsh_rr_mixin>  oneseq_xsh_rr_16_8;
-typedef oneseq_base<uint16_t, uint32_t, xsh_rr_mixin>  oneseq_xsh_rr_32_16;
-typedef oneseq_base<uint32_t, uint64_t, xsh_rr_mixin>  oneseq_xsh_rr_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, xsh_rr_mixin>  oneseq_xsh_rr_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, xsh_rr_mixin, true, cheap_multiplier>
-                                                       cm_oneseq_xsh_rr_128_64;
-
-typedef unique_base<uint8_t,  uint16_t, xsh_rr_mixin>  unique_xsh_rr_16_8;
-typedef unique_base<uint16_t, uint32_t, xsh_rr_mixin>  unique_xsh_rr_32_16;
-typedef unique_base<uint32_t, uint64_t, xsh_rr_mixin>  unique_xsh_rr_64_32;
-typedef unique_base<uint64_t, pcg128_t, xsh_rr_mixin>  unique_xsh_rr_128_64;
-typedef unique_base<uint64_t, pcg128_t, xsh_rr_mixin, true, cheap_multiplier>
-                                                       cm_unique_xsh_rr_128_64;
-
-typedef setseq_base<uint8_t,  uint16_t, xsh_rr_mixin>  setseq_xsh_rr_16_8;
-typedef setseq_base<uint16_t, uint32_t, xsh_rr_mixin>  setseq_xsh_rr_32_16;
-typedef setseq_base<uint32_t, uint64_t, xsh_rr_mixin>  setseq_xsh_rr_64_32;
-typedef setseq_base<uint64_t, pcg128_t, xsh_rr_mixin>  setseq_xsh_rr_128_64;
-typedef setseq_base<uint64_t, pcg128_t, xsh_rr_mixin, true, cheap_multiplier>
-                                                       cm_setseq_xsh_rr_128_64;
-
-typedef mcg_base<uint8_t,  uint16_t, xsh_rr_mixin>  mcg_xsh_rr_16_8;
-typedef mcg_base<uint16_t, uint32_t, xsh_rr_mixin>  mcg_xsh_rr_32_16;
-typedef mcg_base<uint32_t, uint64_t, xsh_rr_mixin>  mcg_xsh_rr_64_32;
-typedef mcg_base<uint64_t, pcg128_t, xsh_rr_mixin>  mcg_xsh_rr_128_64;
-typedef mcg_base<uint64_t, pcg128_t, xsh_rr_mixin, true, cheap_multiplier>
-                                                    cm_mcg_xsh_rr_128_64;
-
-
-/* Predefined types for RXS M XS */
-
-typedef oneseq_base<uint8_t,  uint8_t, rxs_m_xs_mixin>   oneseq_rxs_m_xs_8_8;
-typedef oneseq_base<uint16_t, uint16_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_16_16;
-typedef oneseq_base<uint32_t, uint32_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_32_32;
-typedef oneseq_base<uint64_t, uint64_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_64_64;
-typedef oneseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin>
-                                                        oneseq_rxs_m_xs_128_128;
-typedef oneseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin, true, cheap_multiplier>
-                                                     cm_oneseq_rxs_m_xs_128_128;
-
-typedef unique_base<uint8_t,  uint8_t, rxs_m_xs_mixin>  unique_rxs_m_xs_8_8;
-typedef unique_base<uint16_t, uint16_t, rxs_m_xs_mixin> unique_rxs_m_xs_16_16;
-typedef unique_base<uint32_t, uint32_t, rxs_m_xs_mixin> unique_rxs_m_xs_32_32;
-typedef unique_base<uint64_t, uint64_t, rxs_m_xs_mixin> unique_rxs_m_xs_64_64;
-typedef unique_base<pcg128_t, pcg128_t, rxs_m_xs_mixin> unique_rxs_m_xs_128_128;
-typedef unique_base<pcg128_t, pcg128_t, rxs_m_xs_mixin, true, cheap_multiplier>
-                                                     cm_unique_rxs_m_xs_128_128;
-
-typedef setseq_base<uint8_t,  uint8_t, rxs_m_xs_mixin>  setseq_rxs_m_xs_8_8;
-typedef setseq_base<uint16_t, uint16_t, rxs_m_xs_mixin> setseq_rxs_m_xs_16_16;
-typedef setseq_base<uint32_t, uint32_t, rxs_m_xs_mixin> setseq_rxs_m_xs_32_32;
-typedef setseq_base<uint64_t, uint64_t, rxs_m_xs_mixin> setseq_rxs_m_xs_64_64;
-typedef setseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin> setseq_rxs_m_xs_128_128;
-typedef setseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin, true, cheap_multiplier>
-                                                     cm_setseq_rxs_m_xs_128_128;
-
-                // MCG versions don't make sense here, so aren't defined.
-
-/* Predefined types for RXS M */
-
-typedef oneseq_base<uint8_t,  uint16_t, rxs_m_mixin>  oneseq_rxs_m_16_8;
-typedef oneseq_base<uint16_t, uint32_t, rxs_m_mixin>  oneseq_rxs_m_32_16;
-typedef oneseq_base<uint32_t, uint64_t, rxs_m_mixin>  oneseq_rxs_m_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, rxs_m_mixin>  oneseq_rxs_m_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, rxs_m_mixin, true, cheap_multiplier>
-                                                      cm_oneseq_rxs_m_128_64;
-
-typedef unique_base<uint8_t,  uint16_t, rxs_m_mixin>  unique_rxs_m_16_8;
-typedef unique_base<uint16_t, uint32_t, rxs_m_mixin>  unique_rxs_m_32_16;
-typedef unique_base<uint32_t, uint64_t, rxs_m_mixin>  unique_rxs_m_64_32;
-typedef unique_base<uint64_t, pcg128_t, rxs_m_mixin>  unique_rxs_m_128_64;
-typedef unique_base<uint64_t, pcg128_t, rxs_m_mixin, true, cheap_multiplier>
-                                                      cm_unique_rxs_m_128_64;
-
-typedef setseq_base<uint8_t,  uint16_t, rxs_m_mixin>  setseq_rxs_m_16_8;
-typedef setseq_base<uint16_t, uint32_t, rxs_m_mixin>  setseq_rxs_m_32_16;
-typedef setseq_base<uint32_t, uint64_t, rxs_m_mixin>  setseq_rxs_m_64_32;
-typedef setseq_base<uint64_t, pcg128_t, rxs_m_mixin>  setseq_rxs_m_128_64;
-typedef setseq_base<uint64_t, pcg128_t, rxs_m_mixin, true, cheap_multiplier>
-                                                      cm_setseq_rxs_m_128_64;
-
-typedef mcg_base<uint8_t,  uint16_t, rxs_m_mixin>  mcg_rxs_m_16_8;
-typedef mcg_base<uint16_t, uint32_t, rxs_m_mixin>  mcg_rxs_m_32_16;
-typedef mcg_base<uint32_t, uint64_t, rxs_m_mixin>  mcg_rxs_m_64_32;
-typedef mcg_base<uint64_t, pcg128_t, rxs_m_mixin>  mcg_rxs_m_128_64;
-typedef mcg_base<uint64_t, pcg128_t, rxs_m_mixin, true, cheap_multiplier>
-                                                   cm_mcg_rxs_m_128_64;
-
-/* Predefined types for DXSM */
-
-typedef oneseq_base<uint8_t,  uint16_t, dxsm_mixin>  oneseq_dxsm_16_8;
-typedef oneseq_base<uint16_t, uint32_t, dxsm_mixin>  oneseq_dxsm_32_16;
-typedef oneseq_base<uint32_t, uint64_t, dxsm_mixin>  oneseq_dxsm_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, dxsm_mixin>  oneseq_dxsm_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, dxsm_mixin, true, cheap_multiplier>
-                                                     cm_oneseq_dxsm_128_64;
-
-typedef unique_base<uint8_t,  uint16_t, dxsm_mixin>  unique_dxsm_16_8;
-typedef unique_base<uint16_t, uint32_t, dxsm_mixin>  unique_dxsm_32_16;
-typedef unique_base<uint32_t, uint64_t, dxsm_mixin>  unique_dxsm_64_32;
-typedef unique_base<uint64_t, pcg128_t, dxsm_mixin>  unique_dxsm_128_64;
-typedef unique_base<uint64_t, pcg128_t, dxsm_mixin, true, cheap_multiplier>
-                                                     cm_unique_dxsm_128_64;
-
-typedef setseq_base<uint8_t,  uint16_t, dxsm_mixin>  setseq_dxsm_16_8;
-typedef setseq_base<uint16_t, uint32_t, dxsm_mixin>  setseq_dxsm_32_16;
-typedef setseq_base<uint32_t, uint64_t, dxsm_mixin>  setseq_dxsm_64_32;
-typedef setseq_base<uint64_t, pcg128_t, dxsm_mixin>  setseq_dxsm_128_64;
-typedef setseq_base<uint64_t, pcg128_t, dxsm_mixin, true, cheap_multiplier>
-                                                     cm_setseq_dxsm_128_64;
-
-typedef mcg_base<uint8_t,  uint16_t, dxsm_mixin>  mcg_dxsm_16_8;
-typedef mcg_base<uint16_t, uint32_t, dxsm_mixin>  mcg_dxsm_32_16;
-typedef mcg_base<uint32_t, uint64_t, dxsm_mixin>  mcg_dxsm_64_32;
-typedef mcg_base<uint64_t, pcg128_t, dxsm_mixin>  mcg_dxsm_128_64;
-typedef mcg_base<uint64_t, pcg128_t, dxsm_mixin, true, cheap_multiplier>
-                                                  cm_mcg_dxsm_128_64;
-
-/* Predefined types for XSL RR (only defined for "large" types) */
-
-typedef oneseq_base<uint32_t, uint64_t, xsl_rr_mixin>  oneseq_xsl_rr_64_32;
-typedef oneseq_base<uint64_t, pcg128_t, xsl_rr_mixin>  oneseq_xsl_rr_128_64;
-typedef oneseq_base<uint64_t, pcg128_t, xsl_rr_mixin, true, cheap_multiplier>
-                                                       cm_oneseq_xsl_rr_128_64;
-
-typedef unique_base<uint32_t, uint64_t, xsl_rr_mixin>  unique_xsl_rr_64_32;
-typedef unique_base<uint64_t, pcg128_t, xsl_rr_mixin>  unique_xsl_rr_128_64;
-typedef unique_base<uint64_t, pcg128_t, xsl_rr_mixin, true, cheap_multiplier>
-                                                       cm_unique_xsl_rr_128_64;
-
-typedef setseq_base<uint32_t, uint64_t, xsl_rr_mixin>  setseq_xsl_rr_64_32;
-typedef setseq_base<uint64_t, pcg128_t, xsl_rr_mixin>  setseq_xsl_rr_128_64;
-typedef setseq_base<uint64_t, pcg128_t, xsl_rr_mixin, true, cheap_multiplier>
-                                                       cm_setseq_xsl_rr_128_64;
-
-typedef mcg_base<uint32_t, uint64_t, xsl_rr_mixin>  mcg_xsl_rr_64_32;
-typedef mcg_base<uint64_t, pcg128_t, xsl_rr_mixin>  mcg_xsl_rr_128_64;
-typedef mcg_base<uint64_t, pcg128_t, xsl_rr_mixin, true, cheap_multiplier>
-                                                    cm_mcg_xsl_rr_128_64;
-
-
-/* Predefined types for XSL RR RR (only defined for "large" types) */
-
-typedef oneseq_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
-    oneseq_xsl_rr_rr_64_64;
-typedef oneseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
-    oneseq_xsl_rr_rr_128_128;
-typedef oneseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin, true, cheap_multiplier>
-    cm_oneseq_xsl_rr_rr_128_128;
-
-typedef unique_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
-    unique_xsl_rr_rr_64_64;
-typedef unique_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
-    unique_xsl_rr_rr_128_128;
-typedef unique_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin, true, cheap_multiplier>
-    cm_unique_xsl_rr_rr_128_128;
-
-typedef setseq_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
-    setseq_xsl_rr_rr_64_64;
-typedef setseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
-    setseq_xsl_rr_rr_128_128;
-typedef setseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin, true, cheap_multiplier>
-    cm_setseq_xsl_rr_rr_128_128;
-
-                // MCG versions don't make sense here, so aren't defined.
-
-/* Extended generators */
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename BaseRNG, bool kdd = true>
-using ext_std8 = pcg_extended<table_pow2, advance_pow2, BaseRNG,
-                          oneseq_rxs_m_xs_8_8, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename BaseRNG, bool kdd = true>
-using ext_std16 = pcg_extended<table_pow2, advance_pow2, BaseRNG,
-                           oneseq_rxs_m_xs_16_16, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename BaseRNG, bool kdd = true>
-using ext_std32 = pcg_extended<table_pow2, advance_pow2, BaseRNG,
-                           oneseq_rxs_m_xs_32_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2,
-          typename BaseRNG, bool kdd = true>
-using ext_std64 = pcg_extended<table_pow2, advance_pow2, BaseRNG,
-                           oneseq_rxs_m_xs_64_64, kdd>;
-
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_oneseq_rxs_m_xs_32_32 =
-          ext_std32<table_pow2, advance_pow2, oneseq_rxs_m_xs_32_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_mcg_xsh_rs_64_32 =
-          ext_std32<table_pow2, advance_pow2, mcg_xsh_rs_64_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_oneseq_xsh_rs_64_32 =
-          ext_std32<table_pow2, advance_pow2, oneseq_xsh_rs_64_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_setseq_xsh_rr_64_32 =
-          ext_std32<table_pow2, advance_pow2, setseq_xsh_rr_64_32, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_mcg_xsl_rr_128_64 =
-          ext_std64<table_pow2, advance_pow2, mcg_xsl_rr_128_64, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_oneseq_xsl_rr_128_64 =
-          ext_std64<table_pow2, advance_pow2, oneseq_xsl_rr_128_64, kdd>;
-
-template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
-using ext_setseq_xsl_rr_128_64 =
-          ext_std64<table_pow2, advance_pow2, setseq_xsl_rr_128_64, kdd>;
-
-} // namespace pcg_engines
-
-typedef pcg_engines::setseq_xsh_rr_64_32        pcg32;
-typedef pcg_engines::oneseq_xsh_rr_64_32        pcg32_oneseq;
-typedef pcg_engines::unique_xsh_rr_64_32        pcg32_unique;
-typedef pcg_engines::mcg_xsh_rs_64_32           pcg32_fast;
-
-typedef pcg_engines::setseq_xsl_rr_128_64       pcg64;
-typedef pcg_engines::oneseq_xsl_rr_128_64       pcg64_oneseq;
-typedef pcg_engines::unique_xsl_rr_128_64       pcg64_unique;
-typedef pcg_engines::mcg_xsl_rr_128_64          pcg64_fast;
-
-typedef pcg_engines::setseq_rxs_m_xs_8_8        pcg8_once_insecure;
-typedef pcg_engines::setseq_rxs_m_xs_16_16      pcg16_once_insecure;
-typedef pcg_engines::setseq_rxs_m_xs_32_32      pcg32_once_insecure;
-typedef pcg_engines::setseq_rxs_m_xs_64_64      pcg64_once_insecure;
-typedef pcg_engines::setseq_xsl_rr_rr_128_128   pcg128_once_insecure;
-
-typedef pcg_engines::oneseq_rxs_m_xs_8_8        pcg8_oneseq_once_insecure;
-typedef pcg_engines::oneseq_rxs_m_xs_16_16      pcg16_oneseq_once_insecure;
-typedef pcg_engines::oneseq_rxs_m_xs_32_32      pcg32_oneseq_once_insecure;
-typedef pcg_engines::oneseq_rxs_m_xs_64_64      pcg64_oneseq_once_insecure;
-typedef pcg_engines::oneseq_xsl_rr_rr_128_128   pcg128_oneseq_once_insecure;
-
-
-// These two extended RNGs provide two-dimensionally equidistributed
-// 32-bit generators.  pcg32_k2_fast occupies the same space as pcg64,
-// and can be called twice to generate 64 bits, but does not required
-// 128-bit math; on 32-bit systems, it's faster than pcg64 as well.
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<1,16,true>     pcg32_k2;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<1,32,true>     pcg32_k2_fast;
-
-// These eight extended RNGs have about as much state as arc4random
-//
-//  - the k variants are k-dimensionally equidistributed
-//  - the c variants offer better crypographic security
-//
-// (just how good the cryptographic security is is an open question)
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,true>     pcg32_k64;
-typedef pcg_engines::ext_mcg_xsh_rs_64_32<6,32,true>        pcg32_k64_oneseq;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,true>     pcg32_k64_fast;
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,false>    pcg32_c64;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,false>    pcg32_c64_oneseq;
-typedef pcg_engines::ext_mcg_xsh_rs_64_32<6,32,false>       pcg32_c64_fast;
-
-typedef pcg_engines::ext_setseq_xsl_rr_128_64<5,16,true>    pcg64_k32;
-typedef pcg_engines::ext_oneseq_xsl_rr_128_64<5,128,true>   pcg64_k32_oneseq;
-typedef pcg_engines::ext_mcg_xsl_rr_128_64<5,128,true>      pcg64_k32_fast;
-
-typedef pcg_engines::ext_setseq_xsl_rr_128_64<5,16,false>   pcg64_c32;
-typedef pcg_engines::ext_oneseq_xsl_rr_128_64<5,128,false>  pcg64_c32_oneseq;
-typedef pcg_engines::ext_mcg_xsl_rr_128_64<5,128,false>     pcg64_c32_fast;
-
-// These eight extended RNGs have more state than the Mersenne twister
-//
-//  - the k variants are k-dimensionally equidistributed
-//  - the c variants offer better crypographic security
-//
-// (just how good the cryptographic security is is an open question)
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<10,16,true>    pcg32_k1024;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<10,32,true>    pcg32_k1024_fast;
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<10,16,false>   pcg32_c1024;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<10,32,false>   pcg32_c1024_fast;
-
-typedef pcg_engines::ext_setseq_xsl_rr_128_64<10,16,true>   pcg64_k1024;
-typedef pcg_engines::ext_oneseq_xsl_rr_128_64<10,128,true>  pcg64_k1024_fast;
-
-typedef pcg_engines::ext_setseq_xsl_rr_128_64<10,16,false>  pcg64_c1024;
-typedef pcg_engines::ext_oneseq_xsl_rr_128_64<10,128,false> pcg64_c1024_fast;
-
-// These generators have an insanely huge period (2^524352), and is suitable
-// for silly party tricks, such as dumping out 64 KB ZIP files at an arbitrary
-// point in the future.   [Actually, over the full period of the generator, it
-// will produce every 64 KB ZIP file 2^64 times!]
-
-typedef pcg_engines::ext_setseq_xsh_rr_64_32<14,16,true>    pcg32_k16384;
-typedef pcg_engines::ext_oneseq_xsh_rs_64_32<14,32,true>    pcg32_k16384_fast;
-
-#ifdef _MSC_VER
-    #pragma warning(default:4146)
-#endif
-
-#endif // PCG_RAND_HPP_INCLUDED
-
-
-// LICENSE_CHANGE_END
-// RE2 compatibility layer with std::regex
-
-
-
-
-#include <vector>
-#include <string>
-#include <stdexcept>
-
-namespace duckdb_re2 {
-class RE2;
-
-enum class RegexOptions : uint8_t { NONE, CASE_INSENSITIVE };
-
-class Regex {
-public:
-	DUCKDB_API Regex(const std::string &pattern, RegexOptions options = RegexOptions::NONE);
-	DUCKDB_API Regex(const char *pattern, RegexOptions options = RegexOptions::NONE) : Regex(std::string(pattern)) {
-	}
-	const duckdb_re2::RE2 &GetRegex() const {
-		return *regex;
-	}
-
-private:
-	std::shared_ptr<duckdb_re2::RE2> regex;
-};
-
-struct GroupMatch {
-	std::string text;
-	uint32_t position;
-
-	const std::string &str() const {
-		return text;
-	}
-	operator std::string() const {
-		return text;
-	}
-};
-
-struct Match {
-	std::vector<GroupMatch> groups;
-
-	GroupMatch &GetGroup(uint64_t index) {
-		if (index >= groups.size()) {
-			throw std::runtime_error("RE2: Match index is out of range");
-		}
-		return groups[index];
-	}
-
-	std::string str(uint64_t index) {
-		return GetGroup(index).text;
-	}
-
-	uint64_t position(uint64_t index) {
-		return GetGroup(index).position;
-	}
-
-	uint64_t length(uint64_t index) {
-		return GetGroup(index).text.size();
-	}
-
-	GroupMatch &operator[](uint64_t i) {
-		return GetGroup(i);
-	}
-};
-
-DUCKDB_API bool RegexSearch(const std::string &input, Match &match, const Regex &regex);
-DUCKDB_API bool RegexMatch(const std::string &input, Match &match, const Regex &regex);
-DUCKDB_API bool RegexMatch(const char *start, const char *end, Match &match, const Regex &regex);
-DUCKDB_API bool RegexMatch(const std::string &input, const Regex &regex);
-DUCKDB_API std::vector<Match> RegexFindAll(const std::string &input, const Regex &regex);
-
-} // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2003-2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_RE2_H_
-#define RE2_RE2_H_
-
-// C++ interface to the re2 regular-expression library.
-// RE2 supports Perl-style regular expressions (with extensions like
-// \d, \w, \s, ...).
-//
-// -----------------------------------------------------------------------
-// REGEXP SYNTAX:
-//
-// This module uses the re2 library and hence supports
-// its syntax for regular expressions, which is similar to Perl's with
-// some of the more complicated things thrown away.  In particular,
-// backreferences and generalized assertions are not available, nor is \Z.
-//
-// See https://github.com/google/re2/wiki/Syntax for the syntax
-// supported by RE2, and a comparison with PCRE and PERL regexps.
-//
-// For those not familiar with Perl's regular expressions,
-// here are some examples of the most commonly used extensions:
-//
-//   "hello (\\w+) world"  -- \w matches a "word" character
-//   "version (\\d+)"      -- \d matches a digit
-//   "hello\\s+world"      -- \s matches any whitespace character
-//   "\\b(\\w+)\\b"        -- \b matches non-empty string at word boundary
-//   "(?i)hello"           -- (?i) turns on case-insensitive matching
-//   "/\\*(.*?)\\*/"       -- .*? matches . minimum no. of times possible
-//
-// -----------------------------------------------------------------------
-// MATCHING INTERFACE:
-//
-// The "FullMatch" operation checks that supplied text matches a
-// supplied pattern exactly.
-//
-// Example: successful match
-//    CHECK(RE2::FullMatch("hello", "h.*o"));
-//
-// Example: unsuccessful match (requires full match):
-//    CHECK(!RE2::FullMatch("hello", "e"));
-//
-// -----------------------------------------------------------------------
-// UTF-8 AND THE MATCHING INTERFACE:
-//
-// By default, the pattern and input text are interpreted as UTF-8.
-// The RE2::Latin1 option causes them to be interpreted as Latin-1.
-//
-// Example:
-//    CHECK(RE2::FullMatch(utf8_string, RE2(utf8_pattern)));
-//    CHECK(RE2::FullMatch(latin1_string, RE2(latin1_pattern, RE2::Latin1)));
-//
-// -----------------------------------------------------------------------
-// MATCHING WITH SUBSTRING EXTRACTION:
-//
-// You can supply extra pointer arguments to extract matched substrings.
-// On match failure, none of the pointees will have been modified.
-// On match success, the substrings will be converted (as necessary) and
-// their values will be assigned to their pointees until all conversions
-// have succeeded or one conversion has failed.
-// On conversion failure, the pointees will be in an indeterminate state
-// because the caller has no way of knowing which conversion failed.
-// However, conversion cannot fail for types like string and StringPiece
-// that do not inspect the substring contents. Hence, in the common case
-// where all of the pointees are of such types, failure is always due to
-// match failure and thus none of the pointees will have been modified.
-//
-// Example: extracts "ruby" into "s" and 1234 into "i"
-//    int i;
-//    std::string s;
-//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s, &i));
-//
-// Example: fails because string cannot be stored in integer
-//    CHECK(!RE2::FullMatch("ruby", "(.*)", &i));
-//
-// Example: fails because there aren't enough sub-patterns
-//    CHECK(!RE2::FullMatch("ruby:1234", "\\w+:\\d+", &s));
-//
-// Example: does not try to extract any extra sub-patterns
-//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s));
-//
-// Example: does not try to extract into NULL
-//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", NULL, &i));
-//
-// Example: integer overflow causes failure
-//    CHECK(!RE2::FullMatch("ruby:1234567891234", "\\w+:(\\d+)", &i));
-//
-// NOTE(rsc): Asking for substrings slows successful matches quite a bit.
-// This may get a little faster in the future, but right now is slower
-// than PCRE.  On the other hand, failed matches run *very* fast (faster
-// than PCRE), as do matches without substring extraction.
-//
-// -----------------------------------------------------------------------
-// PARTIAL MATCHES
-//
-// You can use the "PartialMatch" operation when you want the pattern
-// to match any substring of the text.
-//
-// Example: simple search for a string:
-//      CHECK(RE2::PartialMatch("hello", "ell"));
-//
-// Example: find first number in a string
-//      int number;
-//      CHECK(RE2::PartialMatch("x*100 + 20", "(\\d+)", &number));
-//      CHECK_EQ(number, 100);
-//
-// -----------------------------------------------------------------------
-// PRE-COMPILED REGULAR EXPRESSIONS
-//
-// RE2 makes it easy to use any string as a regular expression, without
-// requiring a separate compilation step.
-//
-// If speed is of the essence, you can create a pre-compiled "RE2"
-// object from the pattern and use it multiple times.  If you do so,
-// you can typically parse text faster than with sscanf.
-//
-// Example: precompile pattern for faster matching:
-//    RE2 pattern("h.*o");
-//    while (ReadLine(&str)) {
-//      if (RE2::FullMatch(str, pattern)) ...;
-//    }
-//
-// -----------------------------------------------------------------------
-// SCANNING TEXT INCREMENTALLY
-//
-// The "Consume" operation may be useful if you want to repeatedly
-// match regular expressions at the front of a string and skip over
-// them as they match.  This requires use of the "StringPiece" type,
-// which represents a sub-range of a real string.
-//
-// Example: read lines of the form "var = value" from a string.
-//      std::string contents = ...;     // Fill string somehow
-//      StringPiece input(contents);    // Wrap a StringPiece around it
-//
-//      std::string var;
-//      int value;
-//      while (RE2::Consume(&input, "(\\w+) = (\\d+)\n", &var, &value)) {
-//        ...;
-//      }
-//
-// Each successful call to "Consume" will set "var/value", and also
-// advance "input" so it points past the matched text.  Note that if the
-// regular expression matches an empty string, input will advance
-// by 0 bytes.  If the regular expression being used might match
-// an empty string, the loop body must check for this case and either
-// advance the string or break out of the loop.
-//
-// The "FindAndConsume" operation is similar to "Consume" but does not
-// anchor your match at the beginning of the string.  For example, you
-// could extract all words from a string by repeatedly calling
-//     RE2::FindAndConsume(&input, "(\\w+)", &word)
-//
-// -----------------------------------------------------------------------
-// USING VARIABLE NUMBER OF ARGUMENTS
-//
-// The above operations require you to know the number of arguments
-// when you write the code.  This is not always possible or easy (for
-// example, the regular expression may be calculated at run time).
-// You can use the "N" version of the operations when the number of
-// match arguments are determined at run time.
-//
-// Example:
-//   const RE2::Arg* args[10];
-//   int n;
-//   // ... populate args with pointers to RE2::Arg values ...
-//   // ... set n to the number of RE2::Arg objects ...
-//   bool match = RE2::FullMatchN(input, pattern, args, n);
-//
-// The last statement is equivalent to
-//
-//   bool match = RE2::FullMatch(input, pattern,
-//                               *args[0], *args[1], ..., *args[n - 1]);
-//
-// -----------------------------------------------------------------------
-// PARSING HEX/OCTAL/C-RADIX NUMBERS
-//
-// By default, if you pass a pointer to a numeric value, the
-// corresponding text is interpreted as a base-10 number.  You can
-// instead wrap the pointer with a call to one of the operators Hex(),
-// Octal(), or CRadix() to interpret the text in another base.  The
-// CRadix operator interprets C-style "0" (base-8) and "0x" (base-16)
-// prefixes, but defaults to base-10.
-//
-// Example:
-//   int a, b, c, d;
-//   CHECK(RE2::FullMatch("100 40 0100 0x40", "(.*) (.*) (.*) (.*)",
-//         RE2::Octal(&a), RE2::Hex(&b), RE2::CRadix(&c), RE2::CRadix(&d));
-// will leave 64 in a, b, c, and d.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <algorithm>
-#include <map>
-#include <mutex>
-#include <string>
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2001-2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_STRINGPIECE_H_
-#define RE2_STRINGPIECE_H_
-
-#ifdef min
-#undef min
-#endif
-
-// A string-like object that points to a sized piece of memory.
-//
-// Functions or methods may use const StringPiece& parameters to accept either
-// a "const char*" or a "string" value that will be implicitly converted to
-// a StringPiece.  The implicit conversion means that it is often appropriate
-// to include this .h file in other files rather than forward-declaring
-// StringPiece as would be appropriate for most other Google classes.
-//
-// Systematic usage of StringPiece is encouraged as it will reduce unnecessary
-// conversions from "const char*" to "string" and back again.
-//
-//
-// Arghh!  I wish C++ literals were "string".
-
-// Doing this simplifies the logic below.
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-
-#include <stddef.h>
-#include <string.h>
-#include <algorithm>
-#include <iosfwd>
-#include <iterator>
-#include <string>
-#if __has_include(<string_view>) && __cplusplus >= 201703L
-#include <string_view>
-#endif
-
-namespace duckdb_re2 {
-
-class StringPiece {
- public:
-  typedef std::char_traits<char> traits_type;
-  typedef char value_type;
-  typedef char* pointer;
-  typedef const char* const_pointer;
-  typedef char& reference;
-  typedef const char& const_reference;
-  typedef const char* const_iterator;
-  typedef const_iterator iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef const_reverse_iterator reverse_iterator;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-  static const size_type npos = static_cast<size_type>(-1);
-
-  // We provide non-explicit singleton constructors so users can pass
-  // in a "const char*" or a "string" wherever a "StringPiece" is
-  // expected.
-  StringPiece()
-      : data_(NULL), size_(0) {}
-#if __has_include(<string_view>) && __cplusplus >= 201703L
-  StringPiece(const std::string_view& str)
-      : data_(str.data()), size_(str.size()) {}
-#endif
-  StringPiece(const std::string& str)
-      : data_(str.data()), size_(str.size()) {}
-  StringPiece(const char* str)
-      : data_(str), size_(str == NULL ? 0 : strlen(str)) {}
-  StringPiece(const char* str, size_type len)
-      : data_(str), size_(len) {}
-
-  const_iterator begin() const { return data_; }
-  const_iterator end() const { return data_ + size_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(data_ + size_);
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(data_);
-  }
-
-  size_type size() const { return size_; }
-  size_type length() const { return size_; }
-  bool empty() const { return size_ == 0; }
-
-  const_reference operator[](size_type i) const { return data_[i]; }
-  const_pointer data() const { return data_; }
-
-  void remove_prefix(size_type n) {
-    data_ += n;
-    size_ -= n;
-  }
-
-  void remove_suffix(size_type n) {
-    size_ -= n;
-  }
-
-  void set(const char* str) {
-    data_ = str;
-    size_ = str == NULL ? 0 : strlen(str);
-  }
-
-  void set(const char* str, size_type len) {
-    data_ = str;
-    size_ = len;
-  }
-
-  // Converts to `std::basic_string`.
-  template <typename A>
-  explicit operator std::basic_string<char, traits_type, A>() const {
-    if (!data_) return {};
-    return std::basic_string<char, traits_type, A>(data_, size_);
-  }
-
-  std::string as_string() const {
-    return std::string(data_, size_);
-  }
-
-  // We also define ToString() here, since many other string-like
-  // interfaces name the routine that converts to a C++ string
-  // "ToString", and it's confusing to have the method that does that
-  // for a StringPiece be called "as_string()".  We also leave the
-  // "as_string()" method defined here for existing code.
-  std::string ToString() const {
-    return std::string(data_, size_);
-  }
-
-  void CopyToString(std::string* target) const {
-    target->assign(data_, size_);
-  }
-
-  void AppendToString(std::string* target) const {
-    target->append(data_, size_);
-  }
-
-  size_type copy(char* buf, size_type n, size_type pos = 0) const;
-  StringPiece substr(size_type pos = 0, size_type n = npos) const;
-
-  int compare(const StringPiece& x) const {
-    size_type min_size = std::min(size(), x.size());
-    if (min_size > 0) {
-      int r = memcmp(data(), x.data(), min_size);
-      if (r < 0) return -1;
-      if (r > 0) return 1;
-    }
-    if (size() < x.size()) return -1;
-    if (size() > x.size()) return 1;
-    return 0;
-  }
-
-  // Does "this" start with "x"?
-  bool starts_with(const StringPiece& x) const {
-    return x.empty() ||
-           (size() >= x.size() && memcmp(data(), x.data(), x.size()) == 0);
-  }
-
-  // Does "this" end with "x"?
-  bool ends_with(const StringPiece& x) const {
-    return x.empty() ||
-           (size() >= x.size() &&
-            memcmp(data() + (size() - x.size()), x.data(), x.size()) == 0);
-  }
-
-  bool contains(const StringPiece& s) const {
-    return find(s) != npos;
-  }
-
-  size_type find(const StringPiece& s, size_type pos = 0) const;
-  size_type find(char c, size_type pos = 0) const;
-  size_type rfind(const StringPiece& s, size_type pos = npos) const;
-  size_type rfind(char c, size_type pos = npos) const;
-
- private:
-  const_pointer data_;
-  size_type size_;
-};
-
-inline bool operator==(const StringPiece& x, const StringPiece& y) {
-  StringPiece::size_type len = x.size();
-  if (len != y.size()) return false;
-  return x.data() == y.data() || len == 0 ||
-         memcmp(x.data(), y.data(), len) == 0;
-}
-
-inline bool operator!=(const StringPiece& x, const StringPiece& y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece& x, const StringPiece& y) {
-  StringPiece::size_type min_size = std::min(x.size(), y.size());
-  int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
-  return (r < 0) || (r == 0 && x.size() < y.size());
-}
-
-inline bool operator>(const StringPiece& x, const StringPiece& y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece& x, const StringPiece& y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece& x, const StringPiece& y) {
-  return !(x < y);
-}
-
-// Allow StringPiece to be logged.
-std::ostream& operator<<(std::ostream& o, const StringPiece& p);
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_STRINGPIECE_H_
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_re2 {
-class Prog;
-class Regexp;
-}  // namespace duckdb_re2
-
-namespace duckdb_re2 {
-
-// Interface for regular expression matching.  Also corresponds to a
-// pre-compiled regular expression.  An "RE2" object is safe for
-// concurrent use by multiple threads.
-class RE2 {
- public:
-  // We convert user-passed pointers into special Arg objects
-  class Arg;
-  class Options;
-
-  // Defined in set.h.
-  class Set;
-
-  enum ErrorCode {
-    NoError = 0,
-
-    // Unexpected error
-    ErrorInternal,
-
-    // Parse errors
-    ErrorBadEscape,          // bad escape sequence
-    ErrorBadCharClass,       // bad character class
-    ErrorBadCharRange,       // bad character class range
-    ErrorMissingBracket,     // missing closing ]
-    ErrorMissingParen,       // missing closing )
-    ErrorTrailingBackslash,  // trailing \ at end of regexp
-    ErrorRepeatArgument,     // repeat argument missing, e.g. "*"
-    ErrorRepeatSize,         // bad repetition argument
-    ErrorRepeatOp,           // bad repetition operator
-    ErrorBadPerlOp,          // bad perl operator
-    ErrorBadUTF8,            // invalid UTF-8 in regexp
-    ErrorBadNamedCapture,    // bad named capture group
-    ErrorPatternTooLarge     // pattern too large (compile failed)
-  };
-
-  // Predefined common options.
-  // If you need more complicated things, instantiate
-  // an Option class, possibly passing one of these to
-  // the Option constructor, change the settings, and pass that
-  // Option class to the RE2 constructor.
-  enum CannedOptions {
-    DefaultOptions = 0,
-    Latin1, // treat input as Latin-1 (default UTF-8)
-    POSIX, // POSIX syntax, leftmost-longest match
-    Quiet // do not log about regexp parse errors
-  };
-
-  // Need to have the const char* and const std::string& forms for implicit
-  // conversions when passing string literals to FullMatch and PartialMatch.
-  // Otherwise the StringPiece form would be sufficient.
-#ifndef SWIG
-  RE2(const char* pattern);
-  RE2(const std::string& pattern);
-#endif
-  RE2(const StringPiece& pattern);
-  RE2(const StringPiece& pattern, const Options& options);
-  ~RE2();
-
-  // Returns whether RE2 was created properly.
-  bool ok() const { return error_code() == NoError; }
-
-  // The string specification for this RE2.  E.g.
-  //   RE2 re("ab*c?d+");
-  //   re.pattern();    // "ab*c?d+"
-  const std::string& pattern() const { return pattern_; }
-
-  // If RE2 could not be created properly, returns an error string.
-  // Else returns the empty string.
-  const std::string& error() const { return *error_; }
-
-  // If RE2 could not be created properly, returns an error code.
-  // Else returns RE2::NoError (== 0).
-  ErrorCode error_code() const { return error_code_; }
-
-  // If RE2 could not be created properly, returns the offending
-  // portion of the regexp.
-  const std::string& error_arg() const { return error_arg_; }
-
-  // Returns the program size, a very approximate measure of a regexp's "cost".
-  // Larger numbers are more expensive than smaller numbers.
-  int ProgramSize() const;
-  int ReverseProgramSize() const;
-
-  // EXPERIMENTAL! SUBJECT TO CHANGE!
-  // Outputs the program fanout as a histogram bucketed by powers of 2.
-  // Returns the number of the largest non-empty bucket.
-  int ProgramFanout(std::map<int, int>* histogram) const;
-  int ReverseProgramFanout(std::map<int, int>* histogram) const;
-
-  // Returns the underlying Regexp; not for general use.
-  // Returns entire_regexp_ so that callers don't need
-  // to know about prefix_ and prefix_foldcase_.
-  duckdb_re2::Regexp* Regexp() const { return entire_regexp_; }
-
-  /***** The array-based matching interface ******/
-
-  // The functions here have names ending in 'N' and are used to implement
-  // the functions whose names are the prefix before the 'N'. It is sometimes
-  // useful to invoke them directly, but the syntax is awkward, so the 'N'-less
-  // versions should be preferred.
-  static bool FullMatchN(const StringPiece& text, const RE2& re,
-                         const Arg* const args[], int n);
-  static bool PartialMatchN(const StringPiece& text, const RE2& re,
-                            const Arg* const args[], int n);
-  static bool ConsumeN(StringPiece* input, const RE2& re,
-                       const Arg* const args[], int n);
-  static bool FindAndConsumeN(StringPiece* input, const RE2& re,
-                              const Arg* const args[], int n);
-
-#ifndef SWIG
- private:
-  template <typename F, typename SP>
-  static inline bool Apply(F f, SP sp, const RE2& re) {
-    return f(sp, re, NULL, 0);
-  }
-
-  template <typename F, typename SP, typename... A>
-  static inline bool Apply(F f, SP sp, const RE2& re, const A&... a) {
-    const Arg* const args[] = {&a...};
-    const int n = sizeof...(a);
-    return f(sp, re, args, n);
-  }
-
- public:
-  // In order to allow FullMatch() et al. to be called with a varying number
-  // of arguments of varying types, we use two layers of variadic templates.
-  // The first layer constructs the temporary Arg objects. The second layer
-  // (above) constructs the array of pointers to the temporary Arg objects.
-
-  /***** The useful part: the matching interface *****/
-
-  // Matches "text" against "re".  If pointer arguments are
-  // supplied, copies matched sub-patterns into them.
-  //
-  // You can pass in a "const char*" or a "std::string" for "text".
-  // You can pass in a "const char*" or a "std::string" or a "RE2" for "re".
-  //
-  // The provided pointer arguments can be pointers to any scalar numeric
-  // type, or one of:
-  //    std::string     (matched piece is copied to string)
-  //    StringPiece     (StringPiece is mutated to point to matched piece)
-  //    T               (where "bool T::ParseFrom(const char*, size_t)" exists)
-  //    (void*)NULL     (the corresponding matched sub-pattern is not copied)
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "text" matches "re" exactly
-  //   b. The number of matched sub-patterns is >= number of supplied pointers
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, "i"th captured sub-pattern is
-  //      ignored.
-  //
-  // CAVEAT: An optional sub-pattern that does not exist in the
-  // matched string is assigned the empty string.  Therefore, the
-  // following will return false (because the empty string is not a
-  // valid number):
-  //    int number;
-  //    RE2::FullMatch("abc", "[a-z]+(\\d+)?", &number);
-  template <typename... A>
-  static bool FullMatch(const StringPiece& text, const RE2& re, A&&... a) {
-    return Apply(FullMatchN, text, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Exactly like FullMatch(), except that "re" is allowed to match
-  // a substring of "text".
-  template <typename... A>
-  static bool PartialMatch(const StringPiece& text, const RE2& re, A&&... a) {
-    return Apply(PartialMatchN, text, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like FullMatch() and PartialMatch(), except that "re" has to match
-  // a prefix of the text, and "input" is advanced past the matched
-  // text.  Note: "input" is modified iff this routine returns true
-  // and "re" matched a non-empty substring of "text".
-  template <typename... A>
-  static bool Consume(StringPiece* input, const RE2& re, A&&... a) {
-    return Apply(ConsumeN, input, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like Consume(), but does not anchor the match at the beginning of
-  // the text.  That is, "re" need not start its match at the beginning
-  // of "input".  For example, "FindAndConsume(s, "(\\w+)", &word)" finds
-  // the next word in "s" and stores it in "word".
-  template <typename... A>
-  static bool FindAndConsume(StringPiece* input, const RE2& re, A&&... a) {
-    return Apply(FindAndConsumeN, input, re, Arg(std::forward<A>(a))...);
-  }
-#endif
-
-  // Replace the first match of "re" in "str" with "rewrite".
-  // Within "rewrite", backslash-escaped digits (\1 to \9) can be
-  // used to insert text matching corresponding parenthesized group
-  // from the pattern.  \0 in "rewrite" refers to the entire matching
-  // text.  E.g.,
-  //
-  //   std::string s = "yabba dabba doo";
-  //   CHECK(RE2::Replace(&s, "b+", "d"));
-  //
-  // will leave "s" containing "yada dabba doo"
-  //
-  // Returns true if the pattern matches and a replacement occurs,
-  // false otherwise.
-  static bool Replace(std::string* str,
-                      const RE2& re,
-                      const StringPiece& rewrite);
-
-  // Like Replace(), except replaces successive non-overlapping occurrences
-  // of the pattern in the string with the rewrite. E.g.
-  //
-  //   std::string s = "yabba dabba doo";
-  //   CHECK(RE2::GlobalReplace(&s, "b+", "d"));
-  //
-  // will leave "s" containing "yada dada doo"
-  // Replacements are not subject to re-matching.
-  //
-  // Because GlobalReplace only replaces non-overlapping matches,
-  // replacing "ana" within "banana" makes only one replacement, not two.
-  //
-  // Returns the number of replacements made.
-  static int GlobalReplace(std::string* str,
-                           const RE2& re,
-                           const StringPiece& rewrite);
-
-  // Like Replace, except that if the pattern matches, "rewrite"
-  // is copied into "out" with substitutions.  The non-matching
-  // portions of "text" are ignored.
-  //
-  // Returns true iff a match occurred and the extraction happened
-  // successfully;  if no match occurs, the string is left unaffected.
-  //
-  // REQUIRES: "text" must not alias any part of "*out".
-  static bool Extract(const StringPiece& text,
-                      const RE2& re,
-                      const StringPiece& rewrite,
-                      std::string* out);
-
-  // Escapes all potentially meaningful regexp characters in
-  // 'unquoted'.  The returned string, used as a regular expression,
-  // will exactly match the original string.  For example,
-  //           1.5-2.0?
-  // may become:
-  //           1\.5\-2\.0\?
-  static std::string QuoteMeta(const StringPiece& unquoted);
-
-  // Computes range for any strings matching regexp. The min and max can in
-  // some cases be arbitrarily precise, so the caller gets to specify the
-  // maximum desired length of string returned.
-  //
-  // Assuming PossibleMatchRange(&min, &max, N) returns successfully, any
-  // string s that is an anchored match for this regexp satisfies
-  //   min <= s && s <= max.
-  //
-  // Note that PossibleMatchRange() will only consider the first copy of an
-  // infinitely repeated element (i.e., any regexp element followed by a '*' or
-  // '+' operator). Regexps with "{N}" constructions are not affected, as those
-  // do not compile down to infinite repetitions.
-  //
-  // Returns true on success, false on error.
-  bool PossibleMatchRange(std::string* min, std::string* max,
-                          int maxlen) const;
-
-  // Generic matching interface
-
-  // Type of match.
-  enum Anchor {
-    UNANCHORED,         // No anchoring
-    ANCHOR_START,       // Anchor at start only
-    ANCHOR_BOTH         // Anchor at start and end
-  };
-
-  // Return the number of capturing subpatterns, or -1 if the
-  // regexp wasn't valid on construction.  The overall match ($0)
-  // does not count: if the regexp is "(a)(b)", returns 2.
-  int NumberOfCapturingGroups() const { return num_captures_; }
-
-  // Return a map from names to capturing indices.
-  // The map records the index of the leftmost group
-  // with the given name.
-  // Only valid until the re is deleted.
-  const std::map<std::string, int>& NamedCapturingGroups() const;
-
-  // Return a map from capturing indices to names.
-  // The map has no entries for unnamed groups.
-  // Only valid until the re is deleted.
-  const std::map<int, std::string>& CapturingGroupNames() const;
-
-  // General matching routine.
-  // Match against text starting at offset startpos
-  // and stopping the search at offset endpos.
-  // Returns true if match found, false if not.
-  // On a successful match, fills in submatch[] (up to nsubmatch entries)
-  // with information about submatches.
-  // I.e. matching RE2("(foo)|(bar)baz") on "barbazbla" will return true, with
-  // submatch[0] = "barbaz", submatch[1].data() = NULL, submatch[2] = "bar",
-  // submatch[3].data() = NULL, ..., up to submatch[nsubmatch-1].data() = NULL.
-  // Caveat: submatch[] may be clobbered even on match failure.
-  //
-  // Don't ask for more match information than you will use:
-  // runs much faster with nsubmatch == 1 than nsubmatch > 1, and
-  // runs even faster if nsubmatch == 0.
-  // Doesn't make sense to use nsubmatch > 1 + NumberOfCapturingGroups(),
-  // but will be handled correctly.
-  //
-  // Passing text == StringPiece(NULL, 0) will be handled like any other
-  // empty string, but note that on return, it will not be possible to tell
-  // whether submatch i matched the empty string or did not match:
-  // either way, submatch[i].data() == NULL.
-  bool Match(const StringPiece& text,
-             size_t startpos,
-             size_t endpos,
-             Anchor re_anchor,
-             StringPiece* submatch,
-             int nsubmatch) const;
-
-  // Check that the given rewrite string is suitable for use with this
-  // regular expression.  It checks that:
-  //   * The regular expression has enough parenthesized subexpressions
-  //     to satisfy all of the \N tokens in rewrite
-  //   * The rewrite string doesn't have any syntax errors.  E.g.,
-  //     '\' followed by anything other than a digit or '\'.
-  // A true return value guarantees that Replace() and Extract() won't
-  // fail because of a bad rewrite string.
-  bool CheckRewriteString(const StringPiece& rewrite,
-                          std::string* error) const;
-
-  // Returns the maximum submatch needed for the rewrite to be done by
-  // Replace(). E.g. if rewrite == "foo \\2,\\1", returns 2.
-  static int MaxSubmatch(const StringPiece& rewrite);
-
-  // Append the "rewrite" string, with backslash subsitutions from "vec",
-  // to string "out".
-  // Returns true on success.  This method can fail because of a malformed
-  // rewrite string.  CheckRewriteString guarantees that the rewrite will
-  // be sucessful.
-  bool Rewrite(std::string* out,
-               const StringPiece& rewrite,
-               const StringPiece* vec,
-               int veclen) const;
-
-  // Constructor options
-  class Options {
-   public:
-    // The options are (defaults in parentheses):
-    //
-    //   utf8             (true)  text and pattern are UTF-8; otherwise Latin-1
-    //   posix_syntax     (false) restrict regexps to POSIX egrep syntax
-    //   longest_match    (false) search for longest match, not first match
-    //   log_errors       (true)  log syntax and execution errors to ERROR
-    //   max_mem          (see below)  approx. max memory footprint of RE2
-    //   literal          (false) interpret string as literal, not regexp
-    //   never_nl         (false) never match \n, even if it is in regexp
-    //   dot_nl           (false) dot matches everything including new line
-    //   never_capture    (false) parse all parens as non-capturing
-    //   case_sensitive   (true)  match is case-sensitive (regexp can override
-    //                              with (?i) unless in posix_syntax mode)
-    //
-    // The following options are only consulted when posix_syntax == true.
-    // When posix_syntax == false, these features are always enabled and
-    // cannot be turned off; to perform multi-line matching in that case,
-    // begin the regexp with (?m).
-    //   perl_classes     (false) allow Perl's \d \s \w \D \S \W
-    //   word_boundary    (false) allow Perl's \b \B (word boundary and not)
-    //   one_line         (false) ^ and $ only match beginning and end of text
-    //
-    // The max_mem option controls how much memory can be used
-    // to hold the compiled form of the regexp (the Prog) and
-    // its cached DFA graphs.  Code Search placed limits on the number
-    // of Prog instructions and DFA states: 10,000 for both.
-    // In RE2, those limits would translate to about 240 KB per Prog
-    // and perhaps 2.5 MB per DFA (DFA state sizes vary by regexp; RE2 does a
-    // better job of keeping them small than Code Search did).
-    // Each RE2 has two Progs (one forward, one reverse), and each Prog
-    // can have two DFAs (one first match, one longest match).
-    // That makes 4 DFAs:
-    //
-    //   forward, first-match    - used for UNANCHORED or ANCHOR_START searches
-    //                               if opt.longest_match() == false
-    //   forward, longest-match  - used for all ANCHOR_BOTH searches,
-    //                               and the other two kinds if
-    //                               opt.longest_match() == true
-    //   reverse, first-match    - never used
-    //   reverse, longest-match  - used as second phase for unanchored searches
-    //
-    // The RE2 memory budget is statically divided between the two
-    // Progs and then the DFAs: two thirds to the forward Prog
-    // and one third to the reverse Prog.  The forward Prog gives half
-    // of what it has left over to each of its DFAs.  The reverse Prog
-    // gives it all to its longest-match DFA.
-    //
-    // Once a DFA fills its budget, it flushes its cache and starts over.
-    // If this happens too often, RE2 falls back on the NFA implementation.
-
-    // For now, make the default budget something close to Code Search.
-    static const int kDefaultMaxMem = 8<<20;
-
-    enum Encoding {
-      EncodingUTF8 = 1,
-      EncodingLatin1
-    };
-
-    Options() :
-      encoding_(EncodingUTF8),
-      posix_syntax_(false),
-      longest_match_(false),
-      log_errors_(true),
-      max_mem_(kDefaultMaxMem),
-      literal_(false),
-      never_nl_(false),
-      dot_nl_(false),
-      never_capture_(false),
-      case_sensitive_(true),
-      perl_classes_(false),
-      word_boundary_(false),
-      one_line_(false) {
-    }
-
-    /*implicit*/ Options(CannedOptions);
-
-    Encoding encoding() const { return encoding_; }
-    void set_encoding(Encoding encoding) { encoding_ = encoding; }
-
-    // Legacy interface to encoding.
-    // TODO(rsc): Remove once clients have been converted.
-    bool utf8() const { return encoding_ == EncodingUTF8; }
-    void set_utf8(bool b) {
-      if (b) {
-        encoding_ = EncodingUTF8;
-      } else {
-        encoding_ = EncodingLatin1;
-      }
-    }
-
-    bool posix_syntax() const { return posix_syntax_; }
-    void set_posix_syntax(bool b) { posix_syntax_ = b; }
-
-    bool longest_match() const { return longest_match_; }
-    void set_longest_match(bool b) { longest_match_ = b; }
-
-    bool log_errors() const { return log_errors_; }
-    void set_log_errors(bool b) { log_errors_ = b; }
-
-    int64_t max_mem() const { return max_mem_; }
-    void set_max_mem(int64_t m) { max_mem_ = m; }
-
-    bool literal() const { return literal_; }
-    void set_literal(bool b) { literal_ = b; }
-
-    bool never_nl() const { return never_nl_; }
-    void set_never_nl(bool b) { never_nl_ = b; }
-
-    bool dot_nl() const { return dot_nl_; }
-    void set_dot_nl(bool b) { dot_nl_ = b; }
-
-    bool never_capture() const { return never_capture_; }
-    void set_never_capture(bool b) { never_capture_ = b; }
-
-    bool case_sensitive() const { return case_sensitive_; }
-    void set_case_sensitive(bool b) { case_sensitive_ = b; }
-
-    bool perl_classes() const { return perl_classes_; }
-    void set_perl_classes(bool b) { perl_classes_ = b; }
-
-    bool word_boundary() const { return word_boundary_; }
-    void set_word_boundary(bool b) { word_boundary_ = b; }
-
-    bool one_line() const { return one_line_; }
-    void set_one_line(bool b) { one_line_ = b; }
-
-    void Copy(const Options& src) {
-      *this = src;
-    }
-
-    int ParseFlags() const;
-
-   private:
-    Encoding encoding_;
-    bool posix_syntax_;
-    bool longest_match_;
-    bool log_errors_;
-    int64_t max_mem_;
-    bool literal_;
-    bool never_nl_;
-    bool dot_nl_;
-    bool never_capture_;
-    bool case_sensitive_;
-    bool perl_classes_;
-    bool word_boundary_;
-    bool one_line_;
-  };
-
-  // Returns the options set in the constructor.
-  const Options& options() const { return options_; }
-
-  // Argument converters; see below.
-  static inline Arg CRadix(short* x);
-  static inline Arg CRadix(unsigned short* x);
-  static inline Arg CRadix(int* x);
-  static inline Arg CRadix(unsigned int* x);
-  static inline Arg CRadix(long* x);
-  static inline Arg CRadix(unsigned long* x);
-  static inline Arg CRadix(long long* x);
-  static inline Arg CRadix(unsigned long long* x);
-
-  static inline Arg Hex(short* x);
-  static inline Arg Hex(unsigned short* x);
-  static inline Arg Hex(int* x);
-  static inline Arg Hex(unsigned int* x);
-  static inline Arg Hex(long* x);
-  static inline Arg Hex(unsigned long* x);
-  static inline Arg Hex(long long* x);
-  static inline Arg Hex(unsigned long long* x);
-
-  static inline Arg Octal(short* x);
-  static inline Arg Octal(unsigned short* x);
-  static inline Arg Octal(int* x);
-  static inline Arg Octal(unsigned int* x);
-  static inline Arg Octal(long* x);
-  static inline Arg Octal(unsigned long* x);
-  static inline Arg Octal(long long* x);
-  static inline Arg Octal(unsigned long long* x);
-
- private:
-  void Init(const StringPiece& pattern, const Options& options);
-
-  bool DoMatch(const StringPiece& text,
-               Anchor re_anchor,
-               size_t* consumed,
-               const Arg* const args[],
-               int n) const;
-
-  duckdb_re2::Prog* ReverseProg() const;
-
-  std::string   pattern_;          // string regular expression
-  Options       options_;          // option flags
-  std::string   prefix_;           // required prefix (before regexp_)
-  bool          prefix_foldcase_;  // prefix is ASCII case-insensitive
-  duckdb_re2::Regexp*  entire_regexp_;    // parsed regular expression
-  duckdb_re2::Regexp*  suffix_regexp_;    // parsed regular expression, prefix removed
-  duckdb_re2::Prog*    prog_;             // compiled program for regexp
-  int           num_captures_;     // Number of capturing groups
-  bool          is_one_pass_;      // can use prog_->SearchOnePass?
-
-  mutable duckdb_re2::Prog*          rprog_;    // reverse program for regexp
-  mutable const std::string*  error_;    // Error indicator
-                                         // (or points to empty string)
-  mutable ErrorCode      error_code_;    // Error code
-  mutable std::string    error_arg_;     // Fragment of regexp showing error
-
-  // Map from capture names to indices
-  mutable const std::map<std::string, int>* named_groups_;
-
-  // Map from capture indices to names
-  mutable const std::map<int, std::string>* group_names_;
-
-  // Onces for lazy computations.
-  mutable std::once_flag rprog_once_;
-  mutable std::once_flag named_groups_once_;
-  mutable std::once_flag group_names_once_;
-
-  RE2(const RE2&) = delete;
-  RE2& operator=(const RE2&) = delete;
-};
-
-/***** Implementation details *****/
-
-// Hex/Octal/Binary?
-
-// Special class for parsing into objects that define a ParseFrom() method
-template <class T>
-class _RE2_MatchObject {
- public:
-  static inline bool Parse(const char* str, size_t n, void* dest) {
-    if (dest == NULL) return true;
-    T* object = reinterpret_cast<T*>(dest);
-    return object->ParseFrom(str, n);
-  }
-};
-
-class RE2::Arg {
- public:
-  // Empty constructor so we can declare arrays of RE2::Arg
-  Arg();
-
-  // Constructor specially designed for NULL arguments
-  Arg(void*);
-  Arg(std::nullptr_t);
-
-  typedef bool (*Parser)(const char* str, size_t n, void* dest);
-
-// Type-specific parsers
-#define MAKE_PARSER(type, name)            \
-  Arg(type* p) : arg_(p), parser_(name) {} \
-  Arg(type* p, Parser parser) : arg_(p), parser_(parser) {}
-
-  MAKE_PARSER(char,               parse_char)
-  MAKE_PARSER(signed char,        parse_schar)
-  MAKE_PARSER(unsigned char,      parse_uchar)
-  MAKE_PARSER(float,              parse_float)
-  MAKE_PARSER(double,             parse_double)
-  MAKE_PARSER(std::string,        parse_string)
-  MAKE_PARSER(StringPiece,        parse_stringpiece)
-
-  MAKE_PARSER(short,              parse_short)
-  MAKE_PARSER(unsigned short,     parse_ushort)
-  MAKE_PARSER(int,                parse_int)
-  MAKE_PARSER(unsigned int,       parse_uint)
-  MAKE_PARSER(long,               parse_long)
-  MAKE_PARSER(unsigned long,      parse_ulong)
-  MAKE_PARSER(long long,          parse_longlong)
-  MAKE_PARSER(unsigned long long, parse_ulonglong)
-
-#undef MAKE_PARSER
-
-  // Generic constructor templates
-  template <class T> Arg(T* p)
-      : arg_(p), parser_(_RE2_MatchObject<T>::Parse) { }
-  template <class T> Arg(T* p, Parser parser)
-      : arg_(p), parser_(parser) { }
-
-  // Parse the data
-  bool Parse(const char* str, size_t n) const;
-
- private:
-  void*         arg_;
-  Parser        parser_;
-
-  static bool parse_null          (const char* str, size_t n, void* dest);
-  static bool parse_char          (const char* str, size_t n, void* dest);
-  static bool parse_schar         (const char* str, size_t n, void* dest);
-  static bool parse_uchar         (const char* str, size_t n, void* dest);
-  static bool parse_float         (const char* str, size_t n, void* dest);
-  static bool parse_double        (const char* str, size_t n, void* dest);
-  static bool parse_string        (const char* str, size_t n, void* dest);
-  static bool parse_stringpiece   (const char* str, size_t n, void* dest);
-
-#define DECLARE_INTEGER_PARSER(name)                                       \
- private:                                                                  \
-  static bool parse_##name(const char* str, size_t n, void* dest);         \
-  static bool parse_##name##_radix(const char* str, size_t n, void* dest,  \
-                                   int radix);                             \
-                                                                           \
- public:                                                                   \
-  static bool parse_##name##_hex(const char* str, size_t n, void* dest);   \
-  static bool parse_##name##_octal(const char* str, size_t n, void* dest); \
-  static bool parse_##name##_cradix(const char* str, size_t n, void* dest);
-
-  DECLARE_INTEGER_PARSER(short)
-  DECLARE_INTEGER_PARSER(ushort)
-  DECLARE_INTEGER_PARSER(int)
-  DECLARE_INTEGER_PARSER(uint)
-  DECLARE_INTEGER_PARSER(long)
-  DECLARE_INTEGER_PARSER(ulong)
-  DECLARE_INTEGER_PARSER(longlong)
-  DECLARE_INTEGER_PARSER(ulonglong)
-
-#undef DECLARE_INTEGER_PARSER
-
-};
-
-inline RE2::Arg::Arg() : arg_(NULL), parser_(parse_null) { }
-inline RE2::Arg::Arg(void* p) : arg_(p), parser_(parse_null) { }
-inline RE2::Arg::Arg(std::nullptr_t p) : arg_(p), parser_(parse_null) { }
-
-inline bool RE2::Arg::Parse(const char* str, size_t n) const {
-  return (*parser_)(str, n, arg_);
-}
-
-// This part of the parser, appropriate only for ints, deals with bases
-#define MAKE_INTEGER_PARSER(type, name)                    \
-  inline RE2::Arg RE2::Hex(type* ptr) {                    \
-    return RE2::Arg(ptr, RE2::Arg::parse_##name##_hex);    \
-  }                                                        \
-  inline RE2::Arg RE2::Octal(type* ptr) {                  \
-    return RE2::Arg(ptr, RE2::Arg::parse_##name##_octal);  \
-  }                                                        \
-  inline RE2::Arg RE2::CRadix(type* ptr) {                 \
-    return RE2::Arg(ptr, RE2::Arg::parse_##name##_cradix); \
-  }
-
-MAKE_INTEGER_PARSER(short,              short)
-MAKE_INTEGER_PARSER(unsigned short,     ushort)
-MAKE_INTEGER_PARSER(int,                int)
-MAKE_INTEGER_PARSER(unsigned int,       uint)
-MAKE_INTEGER_PARSER(long,               long)
-MAKE_INTEGER_PARSER(unsigned long,      ulong)
-MAKE_INTEGER_PARSER(long long,          longlong)
-MAKE_INTEGER_PARSER(unsigned long long, ulonglong)
-
-#undef MAKE_INTEGER_PARSER
-
-#ifndef SWIG
-
-
-// Helper for writing global or static RE2s safely.
-// Write
-//     static LazyRE2 re = {".*"};
-// and then use *re instead of writing
-//     static RE2 re(".*");
-// The former is more careful about multithreaded
-// situations than the latter.
-//
-// N.B. This class never deletes the RE2 object that
-// it constructs: that's a feature, so that it can be used
-// for global and function static variables.
-class LazyRE2 {
- private:
-  struct NoArg {};
-
- public:
-  typedef RE2 element_type;  // support std::pointer_traits
-
-  // Constructor omitted to preserve braced initialization in C++98.
-
-  // Pretend to be a pointer to Type (never NULL due to on-demand creation):
-  RE2& operator*() const { return *get(); }
-  RE2* operator->() const { return get(); }
-
-  // Named accessor/initializer:
-  RE2* get() const {
-    std::call_once(once_, &LazyRE2::Init, this);
-    return ptr_;
-  }
-
-  // All data fields must be public to support {"foo"} initialization.
-  const char* pattern_;
-  RE2::CannedOptions options_;
-  NoArg barrier_against_excess_initializers_;
-
-  mutable RE2* ptr_;
-  mutable std::once_flag once_;
-
- private:
-  static void Init(const LazyRE2* lazy_re2) {
-    lazy_re2->ptr_ = new RE2(lazy_re2->pattern_, lazy_re2->options_);
-  }
-
-  void operator=(const LazyRE2&);  // disallowed
-};
-#endif  // SWIG
-
-}  // namespace duckdb_re2
-
-using duckdb_re2::RE2;
-using duckdb_re2::LazyRE2;
-
-#endif  // RE2_RE2_H_
-
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/row_operations/row_operations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct AggregateObject;
-struct AggregateFilterData;
-class DataChunk;
-class RowLayout;
-class RowDataCollection;
-struct SelectionVector;
-class StringHeap;
-class Vector;
-struct VectorData;
-
-// RowOperations contains a set of operations that operate on data using a RowLayout
-struct RowOperations {
-	//===--------------------------------------------------------------------===//
-	// Aggregation Operators
-	//===--------------------------------------------------------------------===//
-	//! initialize - unaligned addresses
-	static void InitializeStates(RowLayout &layout, Vector &addresses, const SelectionVector &sel, idx_t count);
-	//! destructor - unaligned addresses, updated
-	static void DestroyStates(RowLayout &layout, Vector &addresses, idx_t count);
-	//! update - aligned addresses
-	static void UpdateStates(AggregateObject &aggr, Vector &addresses, DataChunk &payload, idx_t arg_idx, idx_t count);
-	//! filtered update - aligned addresses
-	static void UpdateFilteredStates(AggregateFilterData &filter_data, AggregateObject &aggr, Vector &addresses,
-	                                 DataChunk &payload, idx_t arg_idx);
-	//! combine - unaligned addresses, updated
-	static void CombineStates(RowLayout &layout, Vector &sources, Vector &targets, idx_t count);
-	//! finalize - unaligned addresses, updated
-	static void FinalizeStates(RowLayout &layout, Vector &addresses, DataChunk &result, idx_t aggr_idx);
-
-	//===--------------------------------------------------------------------===//
-	// Read/Write Operators
-	//===--------------------------------------------------------------------===//
-	//! Scatter group data to the rows. Initialises the ValidityMask.
-	static void Scatter(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
-	                    RowDataCollection &string_heap, const SelectionVector &sel, idx_t count);
-	//! Gather a single column.
-	static void Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
-	                   const idx_t count, const idx_t col_offset, const idx_t col_no, const idx_t build_size = 0);
-	//! Full Scan an entire columns
-	static void FullScanColumn(const RowLayout &layout, Vector &rows, Vector &col, idx_t count, idx_t col_idx);
-
-	//===--------------------------------------------------------------------===//
-	// Comparison Operators
-	//===--------------------------------------------------------------------===//
-	//! Compare a block of key data against the row values to produce an updated selection that matches
-	//! and a second (optional) selection of non-matching values.
-	//! Returns the number of matches remaining in the selection.
-	using Predicates = vector<ExpressionType>;
-
-	static idx_t Match(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
-	                   const Predicates &predicates, SelectionVector &sel, idx_t count, SelectionVector *no_match,
-	                   idx_t &no_match_count);
-
-	//===--------------------------------------------------------------------===//
-	// Heap Operators
-	//===--------------------------------------------------------------------===//
-	//! Compute the entry sizes of a vector with variable size type (used before building heap buffer space).
-	static void ComputeEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-	                              const SelectionVector &sel, idx_t offset = 0);
-	//! Compute the entry sizes of vector data with variable size type (used before building heap buffer space).
-	static void ComputeEntrySizes(Vector &v, VectorData &vdata, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-	                              const SelectionVector &sel, idx_t offset = 0);
-	//! Scatter vector with variable size type to the heap.
-	static void HeapScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_idx,
-	                        data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset = 0);
-	//! Scatter vector data with variable size type to the heap.
-	static void HeapScatterVData(VectorData &vdata, PhysicalType type, const SelectionVector &sel, idx_t ser_count,
-	                             idx_t col_idx, data_ptr_t *key_locations, data_ptr_t *validitymask_locations,
-	                             idx_t offset = 0);
-	//! Gather a single column with variable size type from the heap.
-	static void HeapGather(Vector &v, const idx_t &vcount, const SelectionVector &sel, const idx_t &col_idx,
-	                       data_ptr_t key_locations[], data_ptr_t validitymask_locations[]);
-
-	//===--------------------------------------------------------------------===//
-	// Sorting Operators
-	//===--------------------------------------------------------------------===//
-	//! Scatter vector data to the rows in radix-sortable format.
-	static void RadixScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
-	                         data_ptr_t key_locations[], bool desc, bool has_null, bool nulls_first, idx_t prefix_len,
-	                         idx_t width, idx_t offset = 0);
-
-	//===--------------------------------------------------------------------===//
-	// Out-of-Core Operators
-	//===--------------------------------------------------------------------===//
-	//! Swizzles blob pointers to offset within heap row
-	static void SwizzleColumns(const RowLayout &layout, const data_ptr_t base_row_ptr, const idx_t count);
-	//! Swizzles the base pointer of each row to offset within heap block
-	static void SwizzleHeapPointer(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
-	                               const idx_t count);
-	//! Unswizzles all offsets back to pointers
-	static void UnswizzlePointers(const RowLayout &layout, const data_ptr_t base_row_ptr,
-	                              const data_ptr_t base_heap_ptr, const idx_t count);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_layout.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/aggregate_object.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundAggregateExpression;
-
-struct AggregateObject {
-	AggregateObject(AggregateFunction function, FunctionData *bind_data, idx_t child_count, idx_t payload_size,
-	                bool distinct, PhysicalType return_type, Expression *filter = nullptr);
-	AggregateObject(BoundAggregateExpression *aggr);
-
-	AggregateFunction function;
-	FunctionData *bind_data;
-	idx_t child_count;
-	idx_t payload_size;
-	bool distinct;
-	PhysicalType return_type;
-	Expression *filter = nullptr;
-
-	static vector<AggregateObject> CreateAggregateObjects(const vector<BoundAggregateExpression *> &bindings);
-};
-
-struct AggregateFilterData {
-	AggregateFilterData(Allocator &allocator, Expression &filter_expr, const vector<LogicalType> &payload_types);
-
-	idx_t ApplyFilter(DataChunk &payload);
-
-	ExpressionExecutor filter_executor;
-	DataChunk filtered_payload;
-	SelectionVector true_sel;
-};
-
-struct AggregateFilterDataSet {
-	AggregateFilterDataSet();
-
-	vector<unique_ptr<AggregateFilterData>> filter_data;
-
-public:
-	void Initialize(Allocator &allocator, const vector<AggregateObject> &aggregates,
-	                const vector<LogicalType> &payload_types);
-
-	AggregateFilterData &GetFilterData(idx_t aggr_idx);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class RowLayout {
-public:
-	using Aggregates = vector<AggregateObject>;
-	using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-	//! Creates an empty RowLayout
-	RowLayout();
-
-public:
-	//! Initializes the RowLayout with the specified types and aggregates to an empty RowLayout
-	void Initialize(vector<LogicalType> types_p, Aggregates aggregates_p, bool align = true);
-	//! Initializes the RowLayout with the specified types to an empty RowLayout
-	void Initialize(vector<LogicalType> types, bool align = true);
-	//! Initializes the RowLayout with the specified aggregates to an empty RowLayout
-	void Initialize(Aggregates aggregates_p, bool align = true);
-	//! Returns the number of data columns
-	inline idx_t ColumnCount() const {
-		return types.size();
-	}
-	//! Returns a list of the column types for this data chunk
-	inline const vector<LogicalType> &GetTypes() const {
-		return types;
-	}
-	//! Returns the number of aggregates
-	inline idx_t AggregateCount() const {
-		return aggregates.size();
-	}
-	//! Returns a list of the aggregates for this data chunk
-	inline Aggregates &GetAggregates() {
-		return aggregates;
-	}
-	//! Returns the total width required for each row, including padding
-	inline idx_t GetRowWidth() const {
-		return row_width;
-	}
-	//! Returns the offset to the start of the data
-	inline idx_t GetDataOffset() const {
-		return flag_width;
-	}
-	//! Returns the total width required for the data, including padding
-	inline idx_t GetDataWidth() const {
-		return data_width;
-	}
-	//! Returns the offset to the start of the aggregates
-	inline idx_t GetAggrOffset() const {
-		return flag_width + data_width;
-	}
-	//! Returns the total width required for the aggregates, including padding
-	inline idx_t GetAggrWidth() const {
-		return aggr_width;
-	}
-	//! Returns the column offsets into each row
-	inline const vector<idx_t> &GetOffsets() const {
-		return offsets;
-	}
-	//! Returns whether all columns in this layout are constant size
-	inline bool AllConstant() const {
-		return all_constant;
-	}
-	inline idx_t GetHeapPointerOffset() const {
-		return heap_pointer_offset;
-	}
-
-private:
-	//! The types of the data columns
-	vector<LogicalType> types;
-	//! The aggregate functions
-	Aggregates aggregates;
-	//! The width of the validity header
-	idx_t flag_width;
-	//! The width of the data portion
-	idx_t data_width;
-	//! The width of the aggregate state portion
-	idx_t aggr_width;
-	//! The width of the entire row
-	idx_t row_width;
-	//! The offsets to the columns and aggregate data in each row
-	vector<idx_t> offsets;
-	//! Whether all columns in this layout are constant size
-	bool all_constant;
-	//! Offset to the pointer to the heap for each row
-	idx_t heap_pointer_offset;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/constant_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-namespace duckdb {
-
-struct PickLeft {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return left;
-	}
-};
-
-struct PickRight {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return right;
-	}
-};
-
-struct NOP {
-	template <class T>
-	static inline T Operation(T left) {
-		return left;
-	}
-};
-
-struct ConstantZero {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return 0;
-	}
-};
-
-struct ConstantOne {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return 1;
-	}
-};
-
-struct AddOne {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return right + 1;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/row_data_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct RowDataBlock {
-	RowDataBlock(BufferManager &buffer_manager, idx_t capacity, idx_t entry_size)
-	    : capacity(capacity), entry_size(entry_size), count(0), byte_offset(0) {
-		block = buffer_manager.RegisterMemory(capacity * entry_size, false);
-	}
-	//! The buffer block handle
-	shared_ptr<BlockHandle> block;
-	//! Capacity (number of entries) and entry size that fit in this block
-	idx_t capacity;
-	const idx_t entry_size;
-	//! Number of entries currently in this block
-	idx_t count;
-	//! Write offset (if variable size entries)
-	idx_t byte_offset;
-};
-
-struct BlockAppendEntry {
-	BlockAppendEntry(data_ptr_t baseptr, idx_t count) : baseptr(baseptr), count(count) {
-	}
-	data_ptr_t baseptr;
-	idx_t count;
-};
-
-class RowDataCollection {
-public:
-	RowDataCollection(BufferManager &buffer_manager, idx_t block_capacity, idx_t entry_size, bool keep_pinned = false);
-
-	//! BufferManager
-	BufferManager &buffer_manager;
-	//! The total number of stored entries
-	idx_t count;
-	//! The number of entries per block
-	idx_t block_capacity;
-	//! Size of entries in the blocks
-	idx_t entry_size;
-	//! The blocks holding the main data
-	vector<RowDataBlock> blocks;
-	//! The blocks that this collection currently has pinned
-	vector<BufferHandle> pinned_blocks;
-
-public:
-	idx_t AppendToBlock(RowDataBlock &block, BufferHandle &handle, vector<BlockAppendEntry> &append_entries,
-	                    idx_t remaining, idx_t entry_sizes[]);
-	vector<BufferHandle> Build(idx_t added_count, data_ptr_t key_locations[], idx_t entry_sizes[],
-	                           const SelectionVector *sel = FlatVector::IncrementalSelectionVector());
-
-	void Merge(RowDataCollection &other);
-
-	//! The size (in bytes) of this RowDataCollection if it were stored in a single block
-	idx_t SizeInBytes() const {
-		idx_t bytes = 0;
-		if (entry_size == 1) {
-			for (auto &block : blocks) {
-				bytes += block.byte_offset;
-			}
-		} else {
-			bytes = count * entry_size;
-		}
-		return MaxValue(bytes, (idx_t)Storage::BLOCK_SIZE);
-	}
-
-private:
-	mutex rdc_lock;
-
-	//! Whether the blocks should stay pinned (necessary for e.g. a heap)
-	const bool keep_pinned;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/buffered_deserializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class BufferedDeserializer : public Deserializer {
-public:
-	BufferedDeserializer(data_ptr_t ptr, idx_t data_size);
-	explicit BufferedDeserializer(BufferedSerializer &serializer);
-
-	data_ptr_t ptr;
-	data_ptr_t endptr;
-
-public:
-	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/buffered_file_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BufferedFileReader : public Deserializer {
-public:
-	BufferedFileReader(FileSystem &fs, const char *path, FileOpener *opener = nullptr);
-
-	FileSystem &fs;
-	unique_ptr<data_t[]> data;
-	idx_t offset;
-	idx_t read_data;
-	unique_ptr<FileHandle> handle;
-
-public:
-	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
-	//! Returns true if the reader has finished reading the entire file
-	bool Finished();
-
-	idx_t FileSize() {
-		return file_size;
-	}
-
-private:
-	idx_t file_size;
-	idx_t total_read;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/sort/comparators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct SortLayout;
-struct SBScanState;
-
-using ValidityBytes = RowLayout::ValidityBytes;
-
-struct Comparators {
-public:
-	//! Whether a tie between two blobs can be broken
-	static bool TieIsBreakable(const idx_t &col_idx, const data_ptr_t row_ptr, const RowLayout &row_layout);
-	//! Compares the tuples that a being read from in the 'left' and 'right blocks during merge sort
-	//! (only in case we cannot simply 'memcmp' - if there are blob columns)
-	static int CompareTuple(const SBScanState &left, const SBScanState &right, const data_ptr_t &l_ptr,
-	                        const data_ptr_t &r_ptr, const SortLayout &sort_layout, const bool &external_sort);
-	//! Compare two blob values
-	static int CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, const LogicalType &type);
-
-private:
-	//! Compares two blob values that were initially tied by their prefix
-	static int BreakBlobTie(const idx_t &tie_col, const SBScanState &left, const SBScanState &right,
-	                        const SortLayout &sort_layout, const bool &external);
-	//! Compare two fixed-size values
-	template <class T>
-	static int TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_t &right_ptr);
-
-	//! Compare two values at the pointers (can be recursive if nested type)
-	static int CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type);
-	//! Compares two fixed-size values at the given pointers
-	template <class T>
-	static int TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr);
-	//! Compares two string values at the given pointers
-	static int CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr);
-	//! Compares two struct values at the given pointers (recursive)
-	static int CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-	                                   const child_list_t<LogicalType> &types);
-	//! Compare two list values at the pointers (can be recursive if nested type)
-	static int CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type);
-	//! Compares a list of fixed-size values
-	template <class T>
-	static int TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const ValidityBytes &left_validity,
-	                                    const ValidityBytes &right_validity, const idx_t &count);
-
-	//! Unwizzles an offset into a pointer
-	static void UnswizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type);
-	//! Swizzles a pointer into an offset
-	static void SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type);
-};
-
-} // namespace duckdb
-//                         DuckDB
-//
-// duckdb/common/fast_mem.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-template <size_t SIZE>
-static inline void MemcpyFixed(void *dest, const void *src) {
-	memcpy(dest, src, SIZE);
-}
-
-template <size_t SIZE>
-static inline int MemcmpFixed(const void *str1, const void *str2) {
-	return memcmp(str1, str2, SIZE);
-}
-
-namespace duckdb {
-
-//! This templated memcpy is significantly faster than std::memcpy,
-//! but only when you are calling memcpy with a const size in a loop.
-//! For instance `while (<cond>) { memcpy(<dest>, <src>, const_size); ... }`
-static inline void FastMemcpy(void *dest, const void *src, const size_t size) {
-	// LCOV_EXCL_START
-	switch (size) {
-	case 0:
-		return;
-	case 1:
-		return MemcpyFixed<1>(dest, src);
-	case 2:
-		return MemcpyFixed<2>(dest, src);
-	case 3:
-		return MemcpyFixed<3>(dest, src);
-	case 4:
-		return MemcpyFixed<4>(dest, src);
-	case 5:
-		return MemcpyFixed<5>(dest, src);
-	case 6:
-		return MemcpyFixed<6>(dest, src);
-	case 7:
-		return MemcpyFixed<7>(dest, src);
-	case 8:
-		return MemcpyFixed<8>(dest, src);
-	case 9:
-		return MemcpyFixed<9>(dest, src);
-	case 10:
-		return MemcpyFixed<10>(dest, src);
-	case 11:
-		return MemcpyFixed<11>(dest, src);
-	case 12:
-		return MemcpyFixed<12>(dest, src);
-	case 13:
-		return MemcpyFixed<13>(dest, src);
-	case 14:
-		return MemcpyFixed<14>(dest, src);
-	case 15:
-		return MemcpyFixed<15>(dest, src);
-	case 16:
-		return MemcpyFixed<16>(dest, src);
-	case 17:
-		return MemcpyFixed<17>(dest, src);
-	case 18:
-		return MemcpyFixed<18>(dest, src);
-	case 19:
-		return MemcpyFixed<19>(dest, src);
-	case 20:
-		return MemcpyFixed<20>(dest, src);
-	case 21:
-		return MemcpyFixed<21>(dest, src);
-	case 22:
-		return MemcpyFixed<22>(dest, src);
-	case 23:
-		return MemcpyFixed<23>(dest, src);
-	case 24:
-		return MemcpyFixed<24>(dest, src);
-	case 25:
-		return MemcpyFixed<25>(dest, src);
-	case 26:
-		return MemcpyFixed<26>(dest, src);
-	case 27:
-		return MemcpyFixed<27>(dest, src);
-	case 28:
-		return MemcpyFixed<28>(dest, src);
-	case 29:
-		return MemcpyFixed<29>(dest, src);
-	case 30:
-		return MemcpyFixed<30>(dest, src);
-	case 31:
-		return MemcpyFixed<31>(dest, src);
-	case 32:
-		return MemcpyFixed<32>(dest, src);
-	case 33:
-		return MemcpyFixed<33>(dest, src);
-	case 34:
-		return MemcpyFixed<34>(dest, src);
-	case 35:
-		return MemcpyFixed<35>(dest, src);
-	case 36:
-		return MemcpyFixed<36>(dest, src);
-	case 37:
-		return MemcpyFixed<37>(dest, src);
-	case 38:
-		return MemcpyFixed<38>(dest, src);
-	case 39:
-		return MemcpyFixed<39>(dest, src);
-	case 40:
-		return MemcpyFixed<40>(dest, src);
-	case 41:
-		return MemcpyFixed<41>(dest, src);
-	case 42:
-		return MemcpyFixed<42>(dest, src);
-	case 43:
-		return MemcpyFixed<43>(dest, src);
-	case 44:
-		return MemcpyFixed<44>(dest, src);
-	case 45:
-		return MemcpyFixed<45>(dest, src);
-	case 46:
-		return MemcpyFixed<46>(dest, src);
-	case 47:
-		return MemcpyFixed<47>(dest, src);
-	case 48:
-		return MemcpyFixed<48>(dest, src);
-	case 49:
-		return MemcpyFixed<49>(dest, src);
-	case 50:
-		return MemcpyFixed<50>(dest, src);
-	case 51:
-		return MemcpyFixed<51>(dest, src);
-	case 52:
-		return MemcpyFixed<52>(dest, src);
-	case 53:
-		return MemcpyFixed<53>(dest, src);
-	case 54:
-		return MemcpyFixed<54>(dest, src);
-	case 55:
-		return MemcpyFixed<55>(dest, src);
-	case 56:
-		return MemcpyFixed<56>(dest, src);
-	case 57:
-		return MemcpyFixed<57>(dest, src);
-	case 58:
-		return MemcpyFixed<58>(dest, src);
-	case 59:
-		return MemcpyFixed<59>(dest, src);
-	case 60:
-		return MemcpyFixed<60>(dest, src);
-	case 61:
-		return MemcpyFixed<61>(dest, src);
-	case 62:
-		return MemcpyFixed<62>(dest, src);
-	case 63:
-		return MemcpyFixed<63>(dest, src);
-	case 64:
-		return MemcpyFixed<64>(dest, src);
-	case 65:
-		return MemcpyFixed<65>(dest, src);
-	case 66:
-		return MemcpyFixed<66>(dest, src);
-	case 67:
-		return MemcpyFixed<67>(dest, src);
-	case 68:
-		return MemcpyFixed<68>(dest, src);
-	case 69:
-		return MemcpyFixed<69>(dest, src);
-	case 70:
-		return MemcpyFixed<70>(dest, src);
-	case 71:
-		return MemcpyFixed<71>(dest, src);
-	case 72:
-		return MemcpyFixed<72>(dest, src);
-	case 73:
-		return MemcpyFixed<73>(dest, src);
-	case 74:
-		return MemcpyFixed<74>(dest, src);
-	case 75:
-		return MemcpyFixed<75>(dest, src);
-	case 76:
-		return MemcpyFixed<76>(dest, src);
-	case 77:
-		return MemcpyFixed<77>(dest, src);
-	case 78:
-		return MemcpyFixed<78>(dest, src);
-	case 79:
-		return MemcpyFixed<79>(dest, src);
-	case 80:
-		return MemcpyFixed<80>(dest, src);
-	case 81:
-		return MemcpyFixed<81>(dest, src);
-	case 82:
-		return MemcpyFixed<82>(dest, src);
-	case 83:
-		return MemcpyFixed<83>(dest, src);
-	case 84:
-		return MemcpyFixed<84>(dest, src);
-	case 85:
-		return MemcpyFixed<85>(dest, src);
-	case 86:
-		return MemcpyFixed<86>(dest, src);
-	case 87:
-		return MemcpyFixed<87>(dest, src);
-	case 88:
-		return MemcpyFixed<88>(dest, src);
-	case 89:
-		return MemcpyFixed<89>(dest, src);
-	case 90:
-		return MemcpyFixed<90>(dest, src);
-	case 91:
-		return MemcpyFixed<91>(dest, src);
-	case 92:
-		return MemcpyFixed<92>(dest, src);
-	case 93:
-		return MemcpyFixed<93>(dest, src);
-	case 94:
-		return MemcpyFixed<94>(dest, src);
-	case 95:
-		return MemcpyFixed<95>(dest, src);
-	case 96:
-		return MemcpyFixed<96>(dest, src);
-	case 97:
-		return MemcpyFixed<97>(dest, src);
-	case 98:
-		return MemcpyFixed<98>(dest, src);
-	case 99:
-		return MemcpyFixed<99>(dest, src);
-	case 100:
-		return MemcpyFixed<100>(dest, src);
-	case 101:
-		return MemcpyFixed<101>(dest, src);
-	case 102:
-		return MemcpyFixed<102>(dest, src);
-	case 103:
-		return MemcpyFixed<103>(dest, src);
-	case 104:
-		return MemcpyFixed<104>(dest, src);
-	case 105:
-		return MemcpyFixed<105>(dest, src);
-	case 106:
-		return MemcpyFixed<106>(dest, src);
-	case 107:
-		return MemcpyFixed<107>(dest, src);
-	case 108:
-		return MemcpyFixed<108>(dest, src);
-	case 109:
-		return MemcpyFixed<109>(dest, src);
-	case 110:
-		return MemcpyFixed<110>(dest, src);
-	case 111:
-		return MemcpyFixed<111>(dest, src);
-	case 112:
-		return MemcpyFixed<112>(dest, src);
-	case 113:
-		return MemcpyFixed<113>(dest, src);
-	case 114:
-		return MemcpyFixed<114>(dest, src);
-	case 115:
-		return MemcpyFixed<115>(dest, src);
-	case 116:
-		return MemcpyFixed<116>(dest, src);
-	case 117:
-		return MemcpyFixed<117>(dest, src);
-	case 118:
-		return MemcpyFixed<118>(dest, src);
-	case 119:
-		return MemcpyFixed<119>(dest, src);
-	case 120:
-		return MemcpyFixed<120>(dest, src);
-	case 121:
-		return MemcpyFixed<121>(dest, src);
-	case 122:
-		return MemcpyFixed<122>(dest, src);
-	case 123:
-		return MemcpyFixed<123>(dest, src);
-	case 124:
-		return MemcpyFixed<124>(dest, src);
-	case 125:
-		return MemcpyFixed<125>(dest, src);
-	case 126:
-		return MemcpyFixed<126>(dest, src);
-	case 127:
-		return MemcpyFixed<127>(dest, src);
-	case 128:
-		return MemcpyFixed<128>(dest, src);
-	case 129:
-		return MemcpyFixed<129>(dest, src);
-	case 130:
-		return MemcpyFixed<130>(dest, src);
-	case 131:
-		return MemcpyFixed<131>(dest, src);
-	case 132:
-		return MemcpyFixed<132>(dest, src);
-	case 133:
-		return MemcpyFixed<133>(dest, src);
-	case 134:
-		return MemcpyFixed<134>(dest, src);
-	case 135:
-		return MemcpyFixed<135>(dest, src);
-	case 136:
-		return MemcpyFixed<136>(dest, src);
-	case 137:
-		return MemcpyFixed<137>(dest, src);
-	case 138:
-		return MemcpyFixed<138>(dest, src);
-	case 139:
-		return MemcpyFixed<139>(dest, src);
-	case 140:
-		return MemcpyFixed<140>(dest, src);
-	case 141:
-		return MemcpyFixed<141>(dest, src);
-	case 142:
-		return MemcpyFixed<142>(dest, src);
-	case 143:
-		return MemcpyFixed<143>(dest, src);
-	case 144:
-		return MemcpyFixed<144>(dest, src);
-	case 145:
-		return MemcpyFixed<145>(dest, src);
-	case 146:
-		return MemcpyFixed<146>(dest, src);
-	case 147:
-		return MemcpyFixed<147>(dest, src);
-	case 148:
-		return MemcpyFixed<148>(dest, src);
-	case 149:
-		return MemcpyFixed<149>(dest, src);
-	case 150:
-		return MemcpyFixed<150>(dest, src);
-	case 151:
-		return MemcpyFixed<151>(dest, src);
-	case 152:
-		return MemcpyFixed<152>(dest, src);
-	case 153:
-		return MemcpyFixed<153>(dest, src);
-	case 154:
-		return MemcpyFixed<154>(dest, src);
-	case 155:
-		return MemcpyFixed<155>(dest, src);
-	case 156:
-		return MemcpyFixed<156>(dest, src);
-	case 157:
-		return MemcpyFixed<157>(dest, src);
-	case 158:
-		return MemcpyFixed<158>(dest, src);
-	case 159:
-		return MemcpyFixed<159>(dest, src);
-	case 160:
-		return MemcpyFixed<160>(dest, src);
-	case 161:
-		return MemcpyFixed<161>(dest, src);
-	case 162:
-		return MemcpyFixed<162>(dest, src);
-	case 163:
-		return MemcpyFixed<163>(dest, src);
-	case 164:
-		return MemcpyFixed<164>(dest, src);
-	case 165:
-		return MemcpyFixed<165>(dest, src);
-	case 166:
-		return MemcpyFixed<166>(dest, src);
-	case 167:
-		return MemcpyFixed<167>(dest, src);
-	case 168:
-		return MemcpyFixed<168>(dest, src);
-	case 169:
-		return MemcpyFixed<169>(dest, src);
-	case 170:
-		return MemcpyFixed<170>(dest, src);
-	case 171:
-		return MemcpyFixed<171>(dest, src);
-	case 172:
-		return MemcpyFixed<172>(dest, src);
-	case 173:
-		return MemcpyFixed<173>(dest, src);
-	case 174:
-		return MemcpyFixed<174>(dest, src);
-	case 175:
-		return MemcpyFixed<175>(dest, src);
-	case 176:
-		return MemcpyFixed<176>(dest, src);
-	case 177:
-		return MemcpyFixed<177>(dest, src);
-	case 178:
-		return MemcpyFixed<178>(dest, src);
-	case 179:
-		return MemcpyFixed<179>(dest, src);
-	case 180:
-		return MemcpyFixed<180>(dest, src);
-	case 181:
-		return MemcpyFixed<181>(dest, src);
-	case 182:
-		return MemcpyFixed<182>(dest, src);
-	case 183:
-		return MemcpyFixed<183>(dest, src);
-	case 184:
-		return MemcpyFixed<184>(dest, src);
-	case 185:
-		return MemcpyFixed<185>(dest, src);
-	case 186:
-		return MemcpyFixed<186>(dest, src);
-	case 187:
-		return MemcpyFixed<187>(dest, src);
-	case 188:
-		return MemcpyFixed<188>(dest, src);
-	case 189:
-		return MemcpyFixed<189>(dest, src);
-	case 190:
-		return MemcpyFixed<190>(dest, src);
-	case 191:
-		return MemcpyFixed<191>(dest, src);
-	case 192:
-		return MemcpyFixed<192>(dest, src);
-	case 193:
-		return MemcpyFixed<193>(dest, src);
-	case 194:
-		return MemcpyFixed<194>(dest, src);
-	case 195:
-		return MemcpyFixed<195>(dest, src);
-	case 196:
-		return MemcpyFixed<196>(dest, src);
-	case 197:
-		return MemcpyFixed<197>(dest, src);
-	case 198:
-		return MemcpyFixed<198>(dest, src);
-	case 199:
-		return MemcpyFixed<199>(dest, src);
-	case 200:
-		return MemcpyFixed<200>(dest, src);
-	case 201:
-		return MemcpyFixed<201>(dest, src);
-	case 202:
-		return MemcpyFixed<202>(dest, src);
-	case 203:
-		return MemcpyFixed<203>(dest, src);
-	case 204:
-		return MemcpyFixed<204>(dest, src);
-	case 205:
-		return MemcpyFixed<205>(dest, src);
-	case 206:
-		return MemcpyFixed<206>(dest, src);
-	case 207:
-		return MemcpyFixed<207>(dest, src);
-	case 208:
-		return MemcpyFixed<208>(dest, src);
-	case 209:
-		return MemcpyFixed<209>(dest, src);
-	case 210:
-		return MemcpyFixed<210>(dest, src);
-	case 211:
-		return MemcpyFixed<211>(dest, src);
-	case 212:
-		return MemcpyFixed<212>(dest, src);
-	case 213:
-		return MemcpyFixed<213>(dest, src);
-	case 214:
-		return MemcpyFixed<214>(dest, src);
-	case 215:
-		return MemcpyFixed<215>(dest, src);
-	case 216:
-		return MemcpyFixed<216>(dest, src);
-	case 217:
-		return MemcpyFixed<217>(dest, src);
-	case 218:
-		return MemcpyFixed<218>(dest, src);
-	case 219:
-		return MemcpyFixed<219>(dest, src);
-	case 220:
-		return MemcpyFixed<220>(dest, src);
-	case 221:
-		return MemcpyFixed<221>(dest, src);
-	case 222:
-		return MemcpyFixed<222>(dest, src);
-	case 223:
-		return MemcpyFixed<223>(dest, src);
-	case 224:
-		return MemcpyFixed<224>(dest, src);
-	case 225:
-		return MemcpyFixed<225>(dest, src);
-	case 226:
-		return MemcpyFixed<226>(dest, src);
-	case 227:
-		return MemcpyFixed<227>(dest, src);
-	case 228:
-		return MemcpyFixed<228>(dest, src);
-	case 229:
-		return MemcpyFixed<229>(dest, src);
-	case 230:
-		return MemcpyFixed<230>(dest, src);
-	case 231:
-		return MemcpyFixed<231>(dest, src);
-	case 232:
-		return MemcpyFixed<232>(dest, src);
-	case 233:
-		return MemcpyFixed<233>(dest, src);
-	case 234:
-		return MemcpyFixed<234>(dest, src);
-	case 235:
-		return MemcpyFixed<235>(dest, src);
-	case 236:
-		return MemcpyFixed<236>(dest, src);
-	case 237:
-		return MemcpyFixed<237>(dest, src);
-	case 238:
-		return MemcpyFixed<238>(dest, src);
-	case 239:
-		return MemcpyFixed<239>(dest, src);
-	case 240:
-		return MemcpyFixed<240>(dest, src);
-	case 241:
-		return MemcpyFixed<241>(dest, src);
-	case 242:
-		return MemcpyFixed<242>(dest, src);
-	case 243:
-		return MemcpyFixed<243>(dest, src);
-	case 244:
-		return MemcpyFixed<244>(dest, src);
-	case 245:
-		return MemcpyFixed<245>(dest, src);
-	case 246:
-		return MemcpyFixed<246>(dest, src);
-	case 247:
-		return MemcpyFixed<247>(dest, src);
-	case 248:
-		return MemcpyFixed<248>(dest, src);
-	case 249:
-		return MemcpyFixed<249>(dest, src);
-	case 250:
-		return MemcpyFixed<250>(dest, src);
-	case 251:
-		return MemcpyFixed<251>(dest, src);
-	case 252:
-		return MemcpyFixed<252>(dest, src);
-	case 253:
-		return MemcpyFixed<253>(dest, src);
-	case 254:
-		return MemcpyFixed<254>(dest, src);
-	case 255:
-		return MemcpyFixed<255>(dest, src);
-	case 256:
-		return MemcpyFixed<256>(dest, src);
-	default:
-		memcpy(dest, src, size);
-	}
-	// LCOV_EXCL_STOP
-}
-
-//! This templated memcmp is significantly faster than std::memcmp,
-//! but only when you are calling memcmp with a const size in a loop.
-//! For instance `while (<cond>) { memcmp(<str1>, <str2>, const_size); ... }`
-static inline int FastMemcmp(const void *str1, const void *str2, const size_t size) {
-	// LCOV_EXCL_START
-	switch (size) {
-	case 0:
-		return 0;
-	case 1:
-		return MemcmpFixed<1>(str1, str2);
-	case 2:
-		return MemcmpFixed<2>(str1, str2);
-	case 3:
-		return MemcmpFixed<3>(str1, str2);
-	case 4:
-		return MemcmpFixed<4>(str1, str2);
-	case 5:
-		return MemcmpFixed<5>(str1, str2);
-	case 6:
-		return MemcmpFixed<6>(str1, str2);
-	case 7:
-		return MemcmpFixed<7>(str1, str2);
-	case 8:
-		return MemcmpFixed<8>(str1, str2);
-	case 9:
-		return MemcmpFixed<9>(str1, str2);
-	case 10:
-		return MemcmpFixed<10>(str1, str2);
-	case 11:
-		return MemcmpFixed<11>(str1, str2);
-	case 12:
-		return MemcmpFixed<12>(str1, str2);
-	case 13:
-		return MemcmpFixed<13>(str1, str2);
-	case 14:
-		return MemcmpFixed<14>(str1, str2);
-	case 15:
-		return MemcmpFixed<15>(str1, str2);
-	case 16:
-		return MemcmpFixed<16>(str1, str2);
-	case 17:
-		return MemcmpFixed<17>(str1, str2);
-	case 18:
-		return MemcmpFixed<18>(str1, str2);
-	case 19:
-		return MemcmpFixed<19>(str1, str2);
-	case 20:
-		return MemcmpFixed<20>(str1, str2);
-	case 21:
-		return MemcmpFixed<21>(str1, str2);
-	case 22:
-		return MemcmpFixed<22>(str1, str2);
-	case 23:
-		return MemcmpFixed<23>(str1, str2);
-	case 24:
-		return MemcmpFixed<24>(str1, str2);
-	case 25:
-		return MemcmpFixed<25>(str1, str2);
-	case 26:
-		return MemcmpFixed<26>(str1, str2);
-	case 27:
-		return MemcmpFixed<27>(str1, str2);
-	case 28:
-		return MemcmpFixed<28>(str1, str2);
-	case 29:
-		return MemcmpFixed<29>(str1, str2);
-	case 30:
-		return MemcmpFixed<30>(str1, str2);
-	case 31:
-		return MemcmpFixed<31>(str1, str2);
-	case 32:
-		return MemcmpFixed<32>(str1, str2);
-	case 33:
-		return MemcmpFixed<33>(str1, str2);
-	case 34:
-		return MemcmpFixed<34>(str1, str2);
-	case 35:
-		return MemcmpFixed<35>(str1, str2);
-	case 36:
-		return MemcmpFixed<36>(str1, str2);
-	case 37:
-		return MemcmpFixed<37>(str1, str2);
-	case 38:
-		return MemcmpFixed<38>(str1, str2);
-	case 39:
-		return MemcmpFixed<39>(str1, str2);
-	case 40:
-		return MemcmpFixed<40>(str1, str2);
-	case 41:
-		return MemcmpFixed<41>(str1, str2);
-	case 42:
-		return MemcmpFixed<42>(str1, str2);
-	case 43:
-		return MemcmpFixed<43>(str1, str2);
-	case 44:
-		return MemcmpFixed<44>(str1, str2);
-	case 45:
-		return MemcmpFixed<45>(str1, str2);
-	case 46:
-		return MemcmpFixed<46>(str1, str2);
-	case 47:
-		return MemcmpFixed<47>(str1, str2);
-	case 48:
-		return MemcmpFixed<48>(str1, str2);
-	case 49:
-		return MemcmpFixed<49>(str1, str2);
-	case 50:
-		return MemcmpFixed<50>(str1, str2);
-	case 51:
-		return MemcmpFixed<51>(str1, str2);
-	case 52:
-		return MemcmpFixed<52>(str1, str2);
-	case 53:
-		return MemcmpFixed<53>(str1, str2);
-	case 54:
-		return MemcmpFixed<54>(str1, str2);
-	case 55:
-		return MemcmpFixed<55>(str1, str2);
-	case 56:
-		return MemcmpFixed<56>(str1, str2);
-	case 57:
-		return MemcmpFixed<57>(str1, str2);
-	case 58:
-		return MemcmpFixed<58>(str1, str2);
-	case 59:
-		return MemcmpFixed<59>(str1, str2);
-	case 60:
-		return MemcmpFixed<60>(str1, str2);
-	case 61:
-		return MemcmpFixed<61>(str1, str2);
-	case 62:
-		return MemcmpFixed<62>(str1, str2);
-	case 63:
-		return MemcmpFixed<63>(str1, str2);
-	case 64:
-		return MemcmpFixed<64>(str1, str2);
-	default:
-		return memcmp(str1, str2, size);
-	}
-	// LCOV_EXCL_STOP
-}
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/sort/sort.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/sort/sorted_block.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BufferManager;
-struct RowDataBlock;
-struct SortLayout;
-struct GlobalSortState;
-
-enum class SortedDataType { BLOB, PAYLOAD };
-
-//! Object that holds sorted rows, and an accompanying heap if there are blobs
-struct SortedData {
-public:
-	SortedData(SortedDataType type, const RowLayout &layout, BufferManager &buffer_manager, GlobalSortState &state);
-	//! Number of rows that this object holds
-	idx_t Count();
-	//! Initialize new block to write to
-	void CreateBlock();
-	//! Create a slice that holds the rows between the start and end indices
-	unique_ptr<SortedData> CreateSlice(idx_t start_block_index, idx_t end_block_index, idx_t end_entry_index);
-	//! Unswizzles all
-	void Unswizzle();
-
-public:
-	const SortedDataType type;
-	//! Layout of this data
-	const RowLayout layout;
-	//! Data and heap blocks
-	vector<RowDataBlock> data_blocks;
-	vector<RowDataBlock> heap_blocks;
-	//! Whether the pointers in this sorted data are swizzled
-	bool swizzled;
-
-private:
-	//! The buffer manager
-	BufferManager &buffer_manager;
-	//! The global state
-	GlobalSortState &state;
-};
-
-//! Block that holds sorted rows: radix, blob and payload data
-struct SortedBlock {
-public:
-	SortedBlock(BufferManager &buffer_manager, GlobalSortState &gstate);
-	//! Number of rows that this object holds
-	idx_t Count() const;
-	//! Initialize this block to write data to
-	void InitializeWrite();
-	//! Init new block to write to
-	void CreateBlock();
-	//! Fill this sorted block by appending the blocks held by a vector of sorted blocks
-	void AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blocks);
-	//! Locate the block and entry index of a row in this block,
-	//! given an index between 0 and the total number of rows in this block
-	void GlobalToLocalIndex(const idx_t &global_idx, idx_t &local_block_index, idx_t &local_entry_index);
-	//! Create a slice that holds the rows between the start and end indices
-	unique_ptr<SortedBlock> CreateSlice(const idx_t start, const idx_t end, idx_t &entry_idx);
-
-	//! Size (in bytes) of the heap of this block
-	idx_t HeapSize() const;
-	//! Total size (in bytes) of this block
-	idx_t SizeInBytes() const;
-
-public:
-	//! Radix/memcmp sortable data
-	vector<RowDataBlock> radix_sorting_data;
-	//! Variable sized sorting data
-	unique_ptr<SortedData> blob_sorting_data;
-	//! Payload data
-	unique_ptr<SortedData> payload_data;
-
-private:
-	//! Buffer manager, global state, and sorting layout constants
-	BufferManager &buffer_manager;
-	GlobalSortState &state;
-	const SortLayout &sort_layout;
-	const RowLayout &payload_layout;
-};
-
-//! State used to scan a SortedBlock e.g. during merge sort
-struct SBScanState {
-public:
-	SBScanState(BufferManager &buffer_manager, GlobalSortState &state);
-
-	void PinRadix(idx_t block_idx_to);
-	void PinData(SortedData &sd);
-
-	data_ptr_t RadixPtr() const;
-	data_ptr_t DataPtr(SortedData &sd) const;
-	data_ptr_t HeapPtr(SortedData &sd) const;
-	data_ptr_t BaseHeapPtr(SortedData &sd) const;
-
-	idx_t Remaining() const;
-
-	void SetIndices(idx_t block_idx_to, idx_t entry_idx_to);
-
-public:
-	BufferManager &buffer_manager;
-	const SortLayout &sort_layout;
-	GlobalSortState &state;
-
-	SortedBlock *sb;
-
-	idx_t block_idx;
-	idx_t entry_idx;
-
-	BufferHandle radix_handle;
-
-	BufferHandle blob_sorting_data_handle;
-	BufferHandle blob_sorting_heap_handle;
-
-	BufferHandle payload_data_handle;
-	BufferHandle payload_heap_handle;
-};
-
-//! Used to scan the data into DataChunks after sorting
-struct PayloadScanner {
-public:
-	PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state, bool flush = true);
-	explicit PayloadScanner(GlobalSortState &global_sort_state, bool flush = true);
-
-	//! Scan a single block
-	PayloadScanner(GlobalSortState &global_sort_state, idx_t block_idx);
-
-	//! The type layout of the payload
-	inline const vector<LogicalType> &GetPayloadTypes() const {
-		return sorted_data.layout.GetTypes();
-	}
-
-	//! The number of rows scanned so far
-	inline idx_t Scanned() const {
-		return total_scanned;
-	}
-
-	//! The number of remaining rows
-	inline idx_t Remaining() const {
-		return total_count - total_scanned;
-	}
-
-	//! Scans the next data chunk from the sorted data
-	void Scan(DataChunk &chunk);
-
-private:
-	//! The sorted data being scanned
-	SortedData &sorted_data;
-	//! Read state
-	SBScanState read_state;
-	//! The total count of sorted_data
-	const idx_t total_count;
-	//! The global sort state
-	GlobalSortState &global_sort_state;
-	//! Addresses used to gather from the sorted data
-	Vector addresses = Vector(LogicalType::POINTER);
-	//! The number of rows scanned so far
-	idx_t total_scanned;
-	//! Whether to flush the blocks after scanning
-	const bool flush;
-};
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-class RowLayout;
-struct LocalSortState;
-
-struct SortConstants {
-	static constexpr idx_t VALUES_PER_RADIX = 256;
-	static constexpr idx_t MSD_RADIX_LOCATIONS = VALUES_PER_RADIX + 1;
-	static constexpr idx_t INSERTION_SORT_THRESHOLD = 24;
-	static constexpr idx_t MSD_RADIX_SORT_SIZE_THRESHOLD = 4;
-};
-
-struct SortLayout {
-public:
-	explicit SortLayout(const vector<BoundOrderByNode> &orders);
-
-public:
-	idx_t column_count;
-	vector<OrderType> order_types;
-	vector<OrderByNullType> order_by_null_types;
-	vector<LogicalType> logical_types;
-
-	bool all_constant;
-	vector<bool> constant_size;
-	vector<idx_t> column_sizes;
-	vector<idx_t> prefix_lengths;
-	vector<BaseStatistics *> stats;
-	vector<bool> has_null;
-
-	idx_t comparison_size;
-	idx_t entry_size;
-
-	RowLayout blob_layout;
-	unordered_map<idx_t, idx_t> sorting_to_blob_col;
-};
-
-struct GlobalSortState {
-public:
-	GlobalSortState(BufferManager &buffer_manager, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout);
-
-	//! Add local state sorted data to this global state
-	void AddLocalState(LocalSortState &local_sort_state);
-	//! Prepares the GlobalSortState for the merge sort phase (after completing radix sort phase)
-	void PrepareMergePhase();
-	//! Initializes the global sort state for another round of merging
-	void InitializeMergeRound();
-	//! Completes the cascaded merge sort round.
-	//! Pass true if you wish to use the radix data for further comparisons.
-	void CompleteMergeRound(bool keep_radix_data = false);
-	//! Print the sorted data to the console.
-	void Print();
-
-public:
-	//! The lock for updating the order global state
-	mutex lock;
-	//! The buffer manager
-	BufferManager &buffer_manager;
-
-	//! Sorting and payload layouts
-	const SortLayout sort_layout;
-	const RowLayout payload_layout;
-
-	//! Sorted data
-	vector<unique_ptr<SortedBlock>> sorted_blocks;
-	vector<vector<unique_ptr<SortedBlock>>> sorted_blocks_temp;
-	unique_ptr<SortedBlock> odd_one_out;
-
-	//! Pinned heap data (if sorting in memory)
-	vector<RowDataBlock> heap_blocks;
-	vector<BufferHandle> pinned_blocks;
-
-	//! Capacity (number of rows) used to initialize blocks
-	idx_t block_capacity;
-	//! Whether we are doing an external sort
-	bool external;
-
-	//! Progress in merge path stage
-	idx_t pair_idx;
-	idx_t num_pairs;
-	idx_t l_start;
-	idx_t r_start;
-};
-
-struct LocalSortState {
-public:
-	LocalSortState();
-
-	//! Initialize the layouts and RowDataCollections
-	void Initialize(GlobalSortState &global_sort_state, BufferManager &buffer_manager_p);
-	//! Sink one DataChunk into the local sort state
-	void SinkChunk(DataChunk &sort, DataChunk &payload);
-	//! Size of accumulated data in bytes
-	idx_t SizeInBytes() const;
-	//! Sort the data accumulated so far
-	void Sort(GlobalSortState &global_sort_state, bool reorder_heap);
-
-private:
-	//! Concatenate the blocks held by a RowDataCollection into a single block
-	RowDataBlock ConcatenateBlocks(RowDataCollection &row_data);
-	//! Sorts the data in the newly created SortedBlock
-	void SortInMemory();
-	//! Re-order the local state after sorting
-	void ReOrder(GlobalSortState &gstate, bool reorder_heap);
-	//! Re-order a SortedData object after sorting
-	void ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataCollection &heap, GlobalSortState &gstate,
-	             bool reorder_heap);
-
-public:
-	//! Whether this local state has been initialized
-	bool initialized;
-	//! The buffer manager
-	BufferManager *buffer_manager;
-	//! The sorting and payload layouts
-	const SortLayout *sort_layout;
-	const RowLayout *payload_layout;
-	//! Radix/memcmp sortable data
-	unique_ptr<RowDataCollection> radix_sorting_data;
-	//! Variable sized sorting data and accompanying heap
-	unique_ptr<RowDataCollection> blob_sorting_data;
-	unique_ptr<RowDataCollection> blob_sorting_heap;
-	//! Payload data and accompanying heap
-	unique_ptr<RowDataCollection> payload_data;
-	unique_ptr<RowDataCollection> payload_heap;
-	//! Sorted data
-	vector<unique_ptr<SortedBlock>> sorted_blocks;
-
-private:
-	//! Selection vector and addresses for scattering the data to rows
-	const SelectionVector &sel_ptr = *FlatVector::IncrementalSelectionVector();
-	Vector addresses = Vector(LogicalType::POINTER);
-};
-
-struct MergeSorter {
-public:
-	MergeSorter(GlobalSortState &state, BufferManager &buffer_manager);
-
-	//! Finds and merges partitions until the current cascaded merge round is finished
-	void PerformInMergeRound();
-
-private:
-	//! The global sorting state
-	GlobalSortState &state;
-	//! The sorting and payload layouts
-	BufferManager &buffer_manager;
-	const SortLayout &sort_layout;
-
-	//! The left and right reader
-	unique_ptr<SBScanState> left;
-	unique_ptr<SBScanState> right;
-
-	//! Input and output blocks
-	unique_ptr<SortedBlock> left_input;
-	unique_ptr<SortedBlock> right_input;
-	SortedBlock *result;
-
-private:
-	//! Computes the left and right block that will be merged next (Merge Path partition)
-	void GetNextPartition();
-	//! Finds the boundary of the next partition using binary search
-	void GetIntersection(const idx_t diagonal, idx_t &l_idx, idx_t &r_idx);
-	//! Compare values within SortedBlocks using a global index
-	int CompareUsingGlobalIndex(SBScanState &l, SBScanState &r, const idx_t l_idx, const idx_t r_idx);
-
-	//! Finds the next partition and merges it
-	void MergePartition();
-
-	//! Computes how the next 'count' tuples should be merged by setting the 'left_smaller' array
-	void ComputeMerge(const idx_t &count, bool left_smaller[]);
-
-	//! Merges the radix sorting blocks according to the 'left_smaller' array
-	void MergeRadix(const idx_t &count, const bool left_smaller[]);
-	//! Merges SortedData according to the 'left_smaller' array
-	void MergeData(SortedData &result_data, SortedData &l_data, SortedData &r_data, const idx_t &count,
-	               const bool left_smaller[], idx_t next_entry_sizes[], bool reset_indices);
-	//! Merges constant size rows according to the 'left_smaller' array
-	void MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &l_count, data_ptr_t &r_ptr, idx_t &r_entry_idx,
-	               const idx_t &r_count, RowDataBlock *target_block, data_ptr_t &target_ptr, const idx_t &entry_size,
-	               const bool left_smaller[], idx_t &copied, const idx_t &count);
-	//! Flushes constant size rows into the result
-	void FlushRows(data_ptr_t &source_ptr, idx_t &source_entry_idx, const idx_t &source_count,
-	               RowDataBlock *target_block, data_ptr_t &target_ptr, const idx_t &entry_size, idx_t &copied,
-	               const idx_t &count);
-	//! Flushes blob rows and accompanying heap
-	void FlushBlobs(const RowLayout &layout, const idx_t &source_count, data_ptr_t &source_data_ptr,
-	                idx_t &source_entry_idx, data_ptr_t &source_heap_ptr, RowDataBlock *target_data_block,
-	                data_ptr_t &target_data_ptr, RowDataBlock *target_heap_block, BufferHandle &target_heap_handle,
-	                data_ptr_t &target_heap_ptr, idx_t &copied, const idx_t &count);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/tree_renderer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/query_profiler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-
-#include <stack>
-
-
-
-namespace duckdb {
-class ClientContext;
-class ExpressionExecutor;
-class PhysicalOperator;
-class SQLStatement;
-
-//! The ExpressionInfo keeps information related to an expression
-struct ExpressionInfo {
-	explicit ExpressionInfo() : hasfunction(false) {
-	}
-	// A vector of children
-	vector<unique_ptr<ExpressionInfo>> children;
-	// Extract ExpressionInformation from a given expression state
-	void ExtractExpressionsRecursive(unique_ptr<ExpressionState> &state);
-
-	//! Whether or not expression has function
-	bool hasfunction;
-	//! The function Name
-	string function_name;
-	//! The function time
-	uint64_t function_time = 0;
-	//! Count the number of ALL tuples
-	uint64_t tuples_count = 0;
-	//! Count the number of tuples sampled
-	uint64_t sample_tuples_count = 0;
-};
-
-//! The ExpressionRootInfo keeps information related to the root of an expression tree
-struct ExpressionRootInfo {
-	ExpressionRootInfo(ExpressionExecutorState &executor, string name);
-
-	//! Count the number of time the executor called
-	uint64_t total_count = 0;
-	//! Count the number of time the executor called since last sampling
-	uint64_t current_count = 0;
-	//! Count the number of samples
-	uint64_t sample_count = 0;
-	//! Count the number of tuples in all samples
-	uint64_t sample_tuples_count = 0;
-	//! Count the number of tuples processed by this executor
-	uint64_t tuples_count = 0;
-	//! A vector which contain the pointer to root of each expression tree
-	unique_ptr<ExpressionInfo> root;
-	//! Name
-	string name;
-	//! Elapsed time
-	double time;
-	//! Extra Info
-	string extra_info;
-};
-
-struct ExpressionExecutorInfo {
-	explicit ExpressionExecutorInfo() {};
-	explicit ExpressionExecutorInfo(ExpressionExecutor &executor, const string &name, int id);
-
-	//! A vector which contain the pointer to all ExpressionRootInfo
-	vector<unique_ptr<ExpressionRootInfo>> roots;
-	//! Id, it will be used as index for executors_info vector
-	int id;
-};
-
-struct OperatorInformation {
-	explicit OperatorInformation(double time_ = 0, idx_t elements_ = 0) : time(time_), elements(elements_) {
-	}
-
-	double time = 0;
-	idx_t elements = 0;
-	string name;
-	//! A vector of Expression Executor Info
-	vector<unique_ptr<ExpressionExecutorInfo>> executors_info;
-};
-
-//! The OperatorProfiler measures timings of individual operators
-class OperatorProfiler {
-	friend class QueryProfiler;
-
-public:
-	DUCKDB_API explicit OperatorProfiler(bool enabled);
-
-	DUCKDB_API void StartOperator(const PhysicalOperator *phys_op);
-	DUCKDB_API void EndOperator(DataChunk *chunk);
-	DUCKDB_API void Flush(const PhysicalOperator *phys_op, ExpressionExecutor *expression_executor, const string &name,
-	                      int id);
-
-	~OperatorProfiler() {
-	}
-
-private:
-	void AddTiming(const PhysicalOperator *op, double time, idx_t elements);
-
-	//! Whether or not the profiler is enabled
-	bool enabled;
-	//! The timer used to time the execution time of the individual Physical Operators
-	Profiler op;
-	//! The stack of Physical Operators that are currently active
-	const PhysicalOperator *active_operator;
-	//! A mapping of physical operators to recorded timings
-	unordered_map<const PhysicalOperator *, OperatorInformation> timings;
-};
-
-//! The QueryProfiler can be used to measure timings of queries
-class QueryProfiler {
-public:
-	DUCKDB_API QueryProfiler(ClientContext &context);
-
-public:
-	struct TreeNode {
-		PhysicalOperatorType type;
-		string name;
-		string extra_info;
-		OperatorInformation info;
-		vector<unique_ptr<TreeNode>> children;
-		idx_t depth = 0;
-	};
-
-	// Propagate save_location, enabled, detailed_enabled and automatic_print_format.
-	void Propagate(QueryProfiler &qp);
-
-	using TreeMap = unordered_map<const PhysicalOperator *, TreeNode *>;
-
-private:
-	unique_ptr<TreeNode> CreateTree(PhysicalOperator *root, idx_t depth = 0);
-	void Render(const TreeNode &node, std::ostream &str) const;
-
-public:
-	DUCKDB_API bool IsEnabled() const;
-	DUCKDB_API bool IsDetailedEnabled() const;
-	DUCKDB_API ProfilerPrintFormat GetPrintFormat() const;
-	DUCKDB_API string GetSaveLocation() const;
-
-	DUCKDB_API static QueryProfiler &Get(ClientContext &context);
-
-	DUCKDB_API void StartQuery(string query, bool is_explain_analyze = false);
-	DUCKDB_API void EndQuery();
-
-	DUCKDB_API void StartExplainAnalyze();
-
-	//! Adds the timings gathered by an OperatorProfiler to this query profiler
-	DUCKDB_API void Flush(OperatorProfiler &profiler);
-
-	DUCKDB_API void StartPhase(string phase);
-	DUCKDB_API void EndPhase();
-
-	DUCKDB_API void Initialize(PhysicalOperator *root);
-
-	DUCKDB_API string QueryTreeToString(bool print_optimizer_output = false) const;
-	DUCKDB_API void QueryTreeToStream(std::ostream &str, bool print_optimizer_output = false) const;
-	DUCKDB_API void Print();
-
-	//! return the printed as a string. Unlike ToString, which is always formatted as a string,
-	//! the return value is formatted based on the current print format (see GetPrintFormat()).
-	DUCKDB_API string ToString() const;
-
-	DUCKDB_API string ToJSON() const;
-	DUCKDB_API void WriteToFile(const char *path, string &info) const;
-
-	idx_t OperatorSize() {
-		return tree_map.size();
-	}
-
-	void Finalize(TreeNode &node);
-
-private:
-	ClientContext &context;
-
-	//! Whether or not the query profiler is running
-	bool running;
-	//! The lock used for flushing information from a thread into the global query profiler
-	mutex flush_lock;
-
-	//! Whether or not the query requires profiling
-	bool query_requires_profiling;
-
-	//! The root of the query tree
-	unique_ptr<TreeNode> root;
-	//! The query string
-	string query;
-	//! The timer used to time the execution time of the entire query
-	Profiler main_query;
-	//! A map of a Physical Operator pointer to a tree node
-	TreeMap tree_map;
-	//! Whether or not we are running as part of a explain_analyze query
-	bool is_explain_analyze;
-
-public:
-	const TreeMap &GetTreeMap() const {
-		return tree_map;
-	}
-
-private:
-	//! The timer used to time the individual phases of the planning process
-	Profiler phase_profiler;
-	//! A mapping of the phase names to the timings
-	using PhaseTimingStorage = unordered_map<string, double>;
-	PhaseTimingStorage phase_timings;
-	using PhaseTimingItem = PhaseTimingStorage::value_type;
-	//! The stack of currently active phases
-	vector<string> phase_stack;
-
-private:
-	vector<PhaseTimingItem> GetOrderedPhaseTimings() const;
-
-	//! Check whether or not an operator type requires query profiling. If none of the ops in a query require profiling
-	//! no profiling information is output.
-	bool OperatorRequiresProfiling(PhysicalOperatorType op_type);
-};
-
-//! The QueryProfilerHistory can be used to access the profiler of previous queries
-class QueryProfilerHistory {
-private:
-	//! Previous Query profilers
-	deque<pair<transaction_t, shared_ptr<QueryProfiler>>> prev_profilers;
-	//! Previous Query profilers size
-	uint64_t prev_profilers_size = 20;
-
-public:
-	deque<pair<transaction_t, shared_ptr<QueryProfiler>>> &GetPrevProfilers() {
-		return prev_profilers;
-	}
-	QueryProfilerHistory() {
-	}
-
-	void SetPrevProfilersSize(uint64_t prevProfilersSize) {
-		prev_profilers_size = prevProfilersSize;
-	}
-	uint64_t GetPrevProfilersSize() const {
-		return prev_profilers_size;
-	}
-
-public:
-	void SetProfilerHistorySize(uint64_t size) {
-		this->prev_profilers_size = size;
-	}
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-class LogicalOperator;
-class PhysicalOperator;
-class Pipeline;
-struct PipelineRenderNode;
-
-struct RenderTreeNode {
-	string name;
-	string extra_text;
-};
-
-struct RenderTree {
-	RenderTree(idx_t width, idx_t height);
-
-	unique_ptr<unique_ptr<RenderTreeNode>[]> nodes;
-	idx_t width;
-	idx_t height;
-
-public:
-	RenderTreeNode *GetNode(idx_t x, idx_t y);
-	void SetNode(idx_t x, idx_t y, unique_ptr<RenderTreeNode> node);
-	bool HasNode(idx_t x, idx_t y);
-
-	idx_t GetPosition(idx_t x, idx_t y);
-};
-
-struct TreeRendererConfig {
-	void enable_detailed() {
-		MAX_EXTRA_LINES = 1000;
-		detailed = true;
-	}
-
-	void enable_standard() {
-		MAX_EXTRA_LINES = 30;
-		detailed = false;
-	}
-
-	idx_t MAXIMUM_RENDER_WIDTH = 240;
-	idx_t NODE_RENDER_WIDTH = 29;
-	idx_t MINIMUM_RENDER_WIDTH = 15;
-	idx_t MAX_EXTRA_LINES = 30;
-	bool detailed = false;
-
-#ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *LTCORNER = "\342\224\214"; // "┌";
-	const char *RTCORNER = "\342\224\220"; // "┐";
-	const char *LDCORNER = "\342\224\224"; // "└";
-	const char *RDCORNER = "\342\224\230"; // "┘";
-
-	const char *MIDDLE = "\342\224\274";  // "┼";
-	const char *TMIDDLE = "\342\224\254"; // "┬";
-	const char *LMIDDLE = "\342\224\234"; // "├";
-	const char *RMIDDLE = "\342\224\244"; // "┤";
-	const char *DMIDDLE = "\342\224\264"; // "┴";
-
-	const char *VERTICAL = "\342\224\202";   // "│";
-	const char *HORIZONTAL = "\342\224\200"; // "─";
-#else
-	// ASCII version
-	const char *LTCORNER = "<";
-	const char *RTCORNER = ">";
-	const char *LDCORNER = "<";
-	const char *RDCORNER = ">";
-
-	const char *MIDDLE = "+";
-	const char *TMIDDLE = "+";
-	const char *LMIDDLE = "+";
-	const char *RMIDDLE = "+";
-	const char *DMIDDLE = "+";
-
-	const char *VERTICAL = "|";
-	const char *HORIZONTAL = "-";
-#endif
-};
-
-class TreeRenderer {
-public:
-	explicit TreeRenderer(TreeRendererConfig config_p = TreeRendererConfig()) : config(move(config_p)) {
-	}
-
-	string ToString(const LogicalOperator &op);
-	string ToString(const PhysicalOperator &op);
-	string ToString(const QueryProfiler::TreeNode &op);
-	string ToString(const Pipeline &op);
-
-	void Render(const LogicalOperator &op, std::ostream &ss);
-	void Render(const PhysicalOperator &op, std::ostream &ss);
-	void Render(const QueryProfiler::TreeNode &op, std::ostream &ss);
-	void Render(const Pipeline &op, std::ostream &ss);
-
-	void ToStream(RenderTree &root, std::ostream &ss);
-
-	void EnableDetailed() {
-		config.enable_detailed();
-	}
-	void EnableStandard() {
-		config.enable_standard();
-	}
-
-private:
-	unique_ptr<RenderTree> CreateTree(const LogicalOperator &op);
-	unique_ptr<RenderTree> CreateTree(const PhysicalOperator &op);
-	unique_ptr<RenderTree> CreateTree(const QueryProfiler::TreeNode &op);
-	unique_ptr<RenderTree> CreateTree(const Pipeline &op);
-
-	string ExtraInfoSeparator();
-	unique_ptr<RenderTreeNode> CreateRenderNode(string name, string extra_info);
-	unique_ptr<RenderTreeNode> CreateNode(const LogicalOperator &op);
-	unique_ptr<RenderTreeNode> CreateNode(const PhysicalOperator &op);
-	unique_ptr<RenderTreeNode> CreateNode(const QueryProfiler::TreeNode &op);
-	unique_ptr<RenderTreeNode> CreateNode(const PipelineRenderNode &op);
-
-private:
-	//! The configuration used for rendering
-	TreeRendererConfig config;
-
-private:
-	void RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y);
-	void RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y);
-	void RenderBottomLayer(RenderTree &root, std::ostream &ss, idx_t y);
-
-	bool CanSplitOnThisChar(char l);
-	bool IsPadding(char l);
-	string RemovePadding(string l);
-	void SplitUpExtraInfo(const string &extra_info, vector<string> &result);
-	void SplitStringBuffer(const string &source, vector<string> &result);
-
-	template <class T>
-	idx_t CreateRenderTreeRecursive(RenderTree &result, const T &op, idx_t x, idx_t y);
-
-	template <class T>
-	unique_ptr<RenderTree> CreateRenderTree(const T &op);
-	string ExtractExpressionsRecursive(ExpressionInfo &states);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_delim_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class PhysicalHashAggregate;
-
-//! PhysicalDelimJoin represents a join where the LHS will be duplicate eliminated and pushed into a
-//! PhysicalChunkCollectionScan in the RHS.
-class PhysicalDelimJoin : public PhysicalOperator {
-public:
-	PhysicalDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-	                  vector<PhysicalOperator *> delim_scans, idx_t estimated_cardinality);
-
-	unique_ptr<PhysicalOperator> join;
-	unique_ptr<PhysicalHashAggregate> distinct;
-	vector<PhysicalOperator *> delim_scans;
-
-public:
-	vector<PhysicalOperator *> GetChildren() const override;
-
-public:
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	string ParamsToString() const override;
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/group_by_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-using GroupingSet = set<idx_t>;
-
-class GroupByNode {
-public:
-	//! The total set of all group expressions
-	vector<unique_ptr<ParsedExpression>> group_expressions;
-	//! The different grouping sets as they map to the group expressions
-	vector<GroupingSet> grouping_sets;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/radix_partitioned_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/partitionable_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/aggregate_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/base_aggregate_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class BufferManager;
-
-class BaseAggregateHashTable {
-public:
-	BaseAggregateHashTable(Allocator &allocator, const vector<AggregateObject> &aggregates,
-	                       BufferManager &buffer_manager, vector<LogicalType> payload_types);
-	virtual ~BaseAggregateHashTable() {
-	}
-
-protected:
-	Allocator &allocator;
-	BufferManager &buffer_manager;
-	//! A helper for managing offsets into the data buffers
-	RowLayout layout;
-	//! The types of the payload columns stored in the hashtable
-	vector<LogicalType> payload_types;
-	//! Intermediate structures and data for aggregate filters
-	AggregateFilterDataSet filter_set;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class BlockHandle;
-class BufferHandle;
-class RowDataCollection;
-
-struct FlushMoveState;
-
-//! GroupedAggregateHashTable is a linear probing HT that is used for computing
-//! aggregates
-/*!
-    GroupedAggregateHashTable is a HT that is used for computing aggregates. It takes
-   as input the set of groups and the types of the aggregates to compute and
-   stores them in the HT. It uses linear probing for collision resolution.
-*/
-
-// two part hash table
-// hashes and payload
-// hashes layout:
-// [SALT][PAGE_NR][PAGE_OFFSET]
-// [SALT] are the high bits of the hash value, e.g. 16 for 64 bit hashes
-// [PAGE_NR] is the buffer managed payload page index
-// [PAGE_OFFSET] is the logical entry offset into said payload page
-
-// NOTE: PAGE_NR and PAGE_OFFSET are reversed for 64 bit HTs because struct packing
-
-// payload layout
-// [VALIDITY][GROUPS][HASH][PADDING][PAYLOAD]
-// [VALIDITY] is the validity bits of the data columns (including the HASH)
-// [GROUPS] is the group data, could be multiple values, fixed size, strings are elsewhere
-// [HASH] is the hash data of the groups
-// [PADDING] is gunk data to align payload properly
-// [PAYLOAD] is the payload (i.e. the aggregate states)
-struct aggr_ht_entry_64 {
-	uint16_t salt;
-	uint16_t page_offset;
-	uint32_t page_nr; // this has to come last because alignment
-};
-
-struct aggr_ht_entry_32 {
-	uint8_t salt;
-	uint8_t page_nr;
-	uint16_t page_offset;
-};
-
-enum HtEntryType { HT_WIDTH_32, HT_WIDTH_64 };
-
-class GroupedAggregateHashTable : public BaseAggregateHashTable {
-public:
-	//! The hash table load factor, when a resize is triggered
-	constexpr static float LOAD_FACTOR = 1.5;
-	constexpr static uint8_t HASH_WIDTH = sizeof(hash_t);
-
-public:
-	GroupedAggregateHashTable(Allocator &allocator, BufferManager &buffer_manager, vector<LogicalType> group_types,
-	                          vector<LogicalType> payload_types, const vector<BoundAggregateExpression *> &aggregates,
-	                          HtEntryType entry_type = HtEntryType::HT_WIDTH_64);
-	GroupedAggregateHashTable(Allocator &allocator, BufferManager &buffer_manager, vector<LogicalType> group_types,
-	                          vector<LogicalType> payload_types, vector<AggregateObject> aggregates,
-	                          HtEntryType entry_type = HtEntryType::HT_WIDTH_64);
-	GroupedAggregateHashTable(Allocator &allocator, BufferManager &buffer_manager, vector<LogicalType> group_types);
-	~GroupedAggregateHashTable() override;
-
-	//! The stringheap of the AggregateHashTable
-	unique_ptr<RowDataCollection> string_heap;
-
-public:
-	//! Add the given data to the HT, computing the aggregates grouped by the
-	//! data in the group chunk. When resize = true, aggregates will not be
-	//! computed but instead just assigned.
-	idx_t AddChunk(DataChunk &groups, DataChunk &payload);
-	idx_t AddChunk(DataChunk &groups, Vector &group_hashes, DataChunk &payload);
-
-	//! Scan the HT starting from the scan_position until the result and group
-	//! chunks are filled. scan_position will be updated by this function.
-	//! Returns the amount of elements found.
-	idx_t Scan(idx_t &scan_position, DataChunk &result);
-
-	//! Fetch the aggregates for specific groups from the HT and place them in the result
-	void FetchAggregates(DataChunk &groups, DataChunk &result);
-
-	//! Finds or creates groups in the hashtable using the specified group keys. The addresses vector will be filled
-	//! with pointers to the groups in the hash table, and the new_groups selection vector will point to the newly
-	//! created groups. The return value is the amount of newly created groups.
-	idx_t FindOrCreateGroups(DataChunk &groups, Vector &group_hashes, Vector &addresses_out,
-	                         SelectionVector &new_groups_out);
-	idx_t FindOrCreateGroups(DataChunk &groups, Vector &addresses_out, SelectionVector &new_groups_out);
-	void FindOrCreateGroups(DataChunk &groups, Vector &addresses_out);
-
-	//! Executes the filter(if any) and update the aggregates
-	void Combine(GroupedAggregateHashTable &other);
-
-	idx_t Size() {
-		return entries;
-	}
-
-	idx_t MaxCapacity();
-
-	void Partition(vector<GroupedAggregateHashTable *> &partition_hts, hash_t mask, idx_t shift);
-
-	void Finalize();
-
-private:
-	HtEntryType entry_type;
-
-	//! The total tuple size
-	idx_t tuple_size;
-	//! The amount of tuples that fit in a single block
-	idx_t tuples_per_block;
-	//! The capacity of the HT. This can be increased using
-	//! GroupedAggregateHashTable::Resize
-	idx_t capacity;
-	//! The amount of entries stored in the HT currently
-	idx_t entries;
-	//! The data of the HT
-	vector<BufferHandle> payload_hds;
-	vector<data_ptr_t> payload_hds_ptrs;
-
-	//! The hashes of the HT
-	BufferHandle hashes_hdl;
-	data_ptr_t hashes_hdl_ptr;
-	data_ptr_t hashes_end_ptr; // of hashes
-	idx_t hash_offset;         // Offset into the layout of the hash column
-
-	hash_t hash_prefix_shift;
-	idx_t payload_page_offset;
-
-	//! Bitmask for getting relevant bits from the hashes to determine the position
-	hash_t bitmask;
-
-	vector<unique_ptr<GroupedAggregateHashTable>> distinct_hashes;
-
-	bool is_finalized;
-
-	// some stuff from FindOrCreateGroupsInternal() to avoid allocation there
-	Vector ht_offsets;
-	Vector hash_salts;
-	SelectionVector group_compare_vector;
-	SelectionVector no_match_vector;
-	SelectionVector empty_vector;
-	vector<ExpressionType> predicates;
-
-private:
-	GroupedAggregateHashTable(const GroupedAggregateHashTable &) = delete;
-
-	//! Resize the HT to the specified size. Must be larger than the current
-	//! size.
-	void Destroy();
-
-	void Verify();
-
-	void FlushMove(FlushMoveState &state, Vector &source_addresses, Vector &source_hashes, idx_t count);
-	void NewBlock();
-
-	template <class ENTRY>
-	void VerifyInternal();
-	template <class ENTRY>
-	void Resize(idx_t size);
-	template <class ENTRY>
-	idx_t FindOrCreateGroupsInternal(DataChunk &groups, Vector &group_hashes, Vector &addresses,
-	                                 SelectionVector &new_groups);
-
-	template <class FUNC = std::function<void(idx_t, idx_t, data_ptr_t)>>
-	void PayloadApply(FUNC fun);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct RadixPartitionInfo {
-	explicit RadixPartitionInfo(idx_t _n_partitions_upper_bound);
-	const idx_t n_partitions;
-	const idx_t radix_bits;
-	const hash_t radix_mask;
-	constexpr static idx_t RADIX_SHIFT = 40;
-};
-
-typedef vector<unique_ptr<GroupedAggregateHashTable>> HashTableList;
-
-class PartitionableHashTable {
-public:
-	PartitionableHashTable(Allocator &allocator, BufferManager &buffer_manager_p, RadixPartitionInfo &partition_info_p,
-	                       vector<LogicalType> group_types_p, vector<LogicalType> payload_types_p,
-	                       vector<BoundAggregateExpression *> bindings_p);
-
-	idx_t AddChunk(DataChunk &groups, DataChunk &payload, bool do_partition);
-	void Partition();
-	bool IsPartitioned();
-
-	HashTableList GetPartition(idx_t partition);
-	HashTableList GetUnpartitioned();
-
-	void Finalize();
-
-private:
-	Allocator &allocator;
-	BufferManager &buffer_manager;
-	vector<LogicalType> group_types;
-	vector<LogicalType> payload_types;
-	vector<BoundAggregateExpression *> bindings;
-
-	bool is_partitioned;
-	RadixPartitionInfo &partition_info;
-	vector<SelectionVector> sel_vectors;
-	vector<idx_t> sel_vector_sizes;
-	DataChunk group_subset, payload_subset;
-	Vector hashes, hashes_subset;
-
-	HashTableList unpartitioned_hts;
-	unordered_map<hash_t, HashTableList> radix_partitioned_hts;
-
-private:
-	idx_t ListAddChunk(HashTableList &list, DataChunk &groups, Vector &group_hashes, DataChunk &payload);
-};
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-class BufferManager;
-class Executor;
-class PhysicalHashAggregate;
-class Pipeline;
-class Task;
-
-class RadixPartitionedHashTable {
-public:
-	RadixPartitionedHashTable(GroupingSet &grouping_set, const PhysicalHashAggregate &op);
-
-	GroupingSet &grouping_set;
-	vector<idx_t> null_groups;
-	const PhysicalHashAggregate &op;
-
-	vector<LogicalType> group_types;
-	//! how many groups can we have in the operator before we switch to radix partitioning
-	idx_t radix_limit;
-
-	//! The GROUPING values that belong to this hash table
-	vector<Value> grouping_values;
-
-public:
-	//! Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const;
-
-	void Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate, DataChunk &input,
-	          DataChunk &aggregate_input_chunk) const;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
-	bool Finalize(ClientContext &context, GlobalSinkState &gstate_p) const;
-
-	void ScheduleTasks(Executor &executor, const shared_ptr<Event> &event, GlobalSinkState &state,
-	                   vector<unique_ptr<Task>> &tasks) const;
-
-	//! Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSinkState &sink_state,
-	             GlobalSourceState &gstate_p) const;
-
-	static void SetMultiScan(GlobalSinkState &state);
-	bool ForceSingleHT(GlobalSinkState &state) const;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class ClientContext;
-class BufferManager;
-
-//! PhysicalHashAggregate is an group-by and aggregate implementation that uses
-//! a hash table to perform the grouping
-class PhysicalHashAggregate : public PhysicalOperator {
-public:
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                      idx_t estimated_cardinality, PhysicalOperatorType type = PhysicalOperatorType::HASH_GROUP_BY);
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                      vector<unique_ptr<Expression>> groups, idx_t estimated_cardinality,
-	                      PhysicalOperatorType type = PhysicalOperatorType::HASH_GROUP_BY);
-	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                      vector<unique_ptr<Expression>> groups, vector<GroupingSet> grouping_sets,
-	                      vector<vector<idx_t>> grouping_functions, idx_t estimated_cardinality,
-	                      PhysicalOperatorType type = PhysicalOperatorType::HASH_GROUP_BY);
-
-	//! The groups
-	vector<unique_ptr<Expression>> groups;
-	//! The grouping sets
-	vector<GroupingSet> grouping_sets;
-	//! The aggregates that have to be computed
-	vector<unique_ptr<Expression>> aggregates;
-	//! The set of GROUPING functions
-	vector<vector<idx_t>> grouping_functions;
-
-	//! Whether or not any aggregation is DISTINCT
-	bool any_distinct;
-
-	//! The group types
-	vector<LogicalType> group_types;
-	//! The payload types
-	vector<LogicalType> payload_types;
-	//! The aggregate return types
-	vector<LogicalType> aggregate_return_types;
-
-	//! The radix partitioned hash tables (one per grouping set)
-	vector<RadixPartitionedHashTable> radix_tables;
-
-	//! Pointers to the aggregates
-	vector<BoundAggregateExpression *> bindings;
-
-	unordered_map<Expression *, size_t> filter_indexes;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	string ParamsToString() const override;
-	//! Toggle multi-scan capability on a hash table, which prevents the scan of the aggregate from being destructive
-	//! If this is not toggled the GetData method will destroy the hash table as it is scanning it
-	static void SetMultiScan(GlobalSinkState &state);
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
-// See the end of this file for a list
-
-
-
-#include <string>
-#include <cassert>
-#include <cstring>
-
-namespace duckdb {
-
-enum class UnicodeType { INVALID, ASCII, UNICODE };
-enum class UnicodeInvalidReason { BYTE_MISMATCH, NULL_BYTE };
-
-class Utf8Proc {
-public:
-	//! Distinguishes ASCII, Valid UTF8 and Invalid UTF8 strings
-	static UnicodeType Analyze(const char *s, size_t len, UnicodeInvalidReason *invalid_reason = nullptr, size_t *invalid_pos = nullptr);
-	//! Performs UTF NFC normalization of string, return value needs to be free'd
-	static char* Normalize(const char* s, size_t len);
-	//! Returns whether or not the UTF8 string is valid
-	static bool IsValid(const char *s, size_t len);
-	//! Returns the position (in bytes) of the next grapheme cluster
-	static size_t NextGraphemeCluster(const char *s, size_t len, size_t pos);
-	//! Returns the position (in bytes) of the previous grapheme cluster
-	static size_t PreviousGraphemeCluster(const char *s, size_t len, size_t pos);
-
-	//! Transform a codepoint to utf8 and writes it to "c", sets "sz" to the size of the codepoint
-	static bool CodepointToUtf8(int cp, int &sz, char *c);
-	//! Returns the codepoint length in bytes when encoded in UTF8
-	static int CodepointLength(int cp);
-	//! Transform a UTF8 string to a codepoint; returns the codepoint and writes the length of the codepoint (in UTF8) to sz
-	static int32_t UTF8ToCodepoint(const char *c, int &sz);
-	static size_t RenderWidth(const char *s, size_t len, size_t pos);
-
-};
-
-}
-
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/batched_chunk_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct BatchedChunkScanState {
-	map<idx_t, unique_ptr<ChunkCollection>>::iterator iterator;
-	idx_t chunk_index;
-};
-
-//!  A BatchedChunkCollection holds a number of data entries that are partitioned by batch index
-//! Scans over a BatchedChunkCollection are ordered by batch index
-class BatchedChunkCollection {
-public:
-	DUCKDB_API BatchedChunkCollection(Allocator &allocator);
-
-	//! Appends a datachunk with the given batch index to the batched collection
-	DUCKDB_API void Append(DataChunk &input, idx_t batch_index);
-
-	//! Merge the other batched chunk collection into this batched collection
-	DUCKDB_API void Merge(BatchedChunkCollection &other);
-
-	//! Initialize a scan over the batched chunk collection
-	DUCKDB_API void InitializeScan(BatchedChunkScanState &state);
-
-	//! Scan a chunk from the batched chunk collection, in-order of batch index
-	DUCKDB_API void Scan(BatchedChunkScanState &state, DataChunk &output);
-
-	DUCKDB_API string ToString() const;
-	DUCKDB_API void Print() const;
-
-private:
-	Allocator &allocator;
-	//! The data of the batched chunk collection - a set of batch_index -> ChunkCollection pointers
-	map<idx_t, unique_ptr<ChunkCollection>> data;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/value_operations/value_operations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct ValueOperations {
-	//===--------------------------------------------------------------------===//
-	// Comparison Operations
-	//===--------------------------------------------------------------------===//
-	// A == B
-	static bool Equals(const Value &left, const Value &right);
-	// A != B
-	static bool NotEquals(const Value &left, const Value &right);
-	// A > B
-	static bool GreaterThan(const Value &left, const Value &right);
-	// A >= B
-	static bool GreaterThanEquals(const Value &left, const Value &right);
-	// A < B
-	static bool LessThan(const Value &left, const Value &right);
-	// A <= B
-	static bool LessThanEquals(const Value &left, const Value &right);
-	//===--------------------------------------------------------------------===//
-	// Distinction Operations
-	//===--------------------------------------------------------------------===//
-	// A == B, NULLs equal
-	static bool NotDistinctFrom(const Value &left, const Value &right);
-	// A != B, NULLs equal
-	static bool DistinctFrom(const Value &left, const Value &right);
-	// A > B, NULLs last
-	static bool DistinctGreaterThan(const Value &left, const Value &right);
-	// A >= B, NULLs last
-	static bool DistinctGreaterThanEquals(const Value &left, const Value &right);
-	// A < B, NULLs last
-	static bool DistinctLessThan(const Value &left, const Value &right);
-	// A <= B, NULLs last
-	static bool DistinctLessThanEquals(const Value &left, const Value &right);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/array.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <array>
-
-namespace duckdb {
-using std::array;
-}
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/sel_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Selection vector cache used for caching vector slices
-struct SelCache {
-	unordered_map<sel_t *, buffer_ptr<VectorBuffer>> cache;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/arrow_aux_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct ArrowAuxiliaryData : VectorAuxiliaryData {
-	explicit ArrowAuxiliaryData(shared_ptr<ArrowArrayWrapper> arrow_array_p)
-	    : VectorAuxiliaryData(VectorAuxiliaryDataType::ARROW_AUXILIARY), arrow_array(std::move(arrow_array_p)) {
-	}
-	~ArrowAuxiliaryData() override {
-	}
-
-	shared_ptr<ArrowArrayWrapper> arrow_array;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/hyperloglog.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
-// See the end of this file for a list
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// third_party/hyperloglog/hyperloglog.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <stdint.h>
-#include <string.h>
-
-namespace duckdb_hll {
-
-/* Error codes */
-#define HLL_C_OK  0
-#define HLL_C_ERR -1
-
-typedef struct {
-	void *ptr;
-} robj;
-
-//! Create a new empty HyperLogLog object
-robj *hll_create(void);
-//! Convert hll from sparse to dense
-int hllSparseToDense(robj *o);
-//! Destroy the specified HyperLogLog object
-void hll_destroy(robj *obj);
-//! Add an element with the specified amount of bytes to the HyperLogLog. Returns C_ERR on failure, otherwise returns 0
-//! if the cardinality did not change, and 1 otherwise.
-int hll_add(robj *o, unsigned char *ele, size_t elesize);
-//! Returns the estimated amount of unique elements seen by the HyperLogLog. Returns C_OK on success, or C_ERR on
-//! failure.
-int hll_count(robj *o, size_t *result);
-//! Merge hll_count HyperLogLog objects into a single one. Returns NULL on failure, or the new HLL object on success.
-robj *hll_merge(robj **hlls, size_t hll_count);
-//! Get size (in bytes) of the HLL
-uint64_t get_size();
-
-uint64_t MurmurHash64A(const void *key, int len, unsigned int seed);
-
-} // namespace duckdb_hll
-
-namespace duckdb {
-
-void AddToLogsInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
-                       const SelectionVector *log_sel);
-
-void AddToSingleLogInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log);
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb {
-
-enum class HLLStorageType { UNCOMPRESSED = 1 };
-
-class FieldWriter;
-class FieldReader;
-
-//! The HyperLogLog class holds a HyperLogLog counter for approximate cardinality counting
-class HyperLogLog {
-public:
-	HyperLogLog();
-	~HyperLogLog();
-	// implicit copying of HyperLogLog is not allowed
-	HyperLogLog(const HyperLogLog &) = delete;
-
-	//! Adds an element of the specified size to the HyperLogLog counter
-	void Add(data_ptr_t element, idx_t size);
-	//! Return the count of this HyperLogLog counter
-	idx_t Count() const;
-	//! Merge this HyperLogLog counter with another counter to create a new one
-	unique_ptr<HyperLogLog> Merge(HyperLogLog &other);
-	HyperLogLog *MergePointer(HyperLogLog &other);
-	//! Merge a set of HyperLogLogs to create one big one
-	static unique_ptr<HyperLogLog> Merge(HyperLogLog logs[], idx_t count);
-	//! Get the size (in bytes) of a HLL
-	static idx_t GetSize();
-	//! Get pointer to the HLL
-	data_ptr_t GetPtr() const;
-	//! Get copy of the HLL
-	unique_ptr<HyperLogLog> Copy();
-	//! (De)Serialize the HLL
-	void Serialize(FieldWriter &writer) const;
-	static unique_ptr<HyperLogLog> Deserialize(FieldReader &reader);
-
-public:
-	//! Compute HLL hashes over vdata, and store them in 'hashes'
-	//! Then, compute register indices and prefix lengths, and also store them in 'hashes' as a pair of uint32_t
-	static void ProcessEntries(VectorData &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
-	                           idx_t count);
-	//! Add the indices and counts to the logs
-	static void AddToLogs(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], HyperLogLog **logs[],
-	                      const SelectionVector *log_sel);
-	//! Add the indices and counts to THIS log
-	void AddToLog(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[]);
-
-private:
-	explicit HyperLogLog(void *hll);
-
-	void *hll;
-	mutex lock;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/date_part_specifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class DatePartSpecifier : uint8_t {
-	YEAR,
-	MONTH,
-	DAY,
-	DECADE,
-	CENTURY,
-	MILLENNIUM,
-	MICROSECONDS,
-	MILLISECONDS,
-	SECOND,
-	MINUTE,
-	HOUR,
-	EPOCH,
-	DOW,
-	ISODOW,
-	WEEK,
-	ISOYEAR,
-	QUARTER,
-	DOY,
-	YEARWEEK,
-	ERA,
-	TIMEZONE,
-	TIMEZONE_HOUR,
-	TIMEZONE_MINUTE
-};
-
-DUCKDB_API bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
-DUCKDB_API DatePartSpecifier GetDatePartSpecifier(const string &specifier);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/add.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct AddOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left + right;
-	}
-};
-
-template <>
-float AddOperator::Operation(float left, float right);
-template <>
-double AddOperator::Operation(double left, double right);
-template <>
-date_t AddOperator::Operation(date_t left, int32_t right);
-template <>
-date_t AddOperator::Operation(int32_t left, date_t right);
-template <>
-timestamp_t AddOperator::Operation(date_t left, dtime_t right);
-template <>
-timestamp_t AddOperator::Operation(dtime_t left, date_t right);
-template <>
-interval_t AddOperator::Operation(interval_t left, interval_t right);
-template <>
-date_t AddOperator::Operation(date_t left, interval_t right);
-template <>
-date_t AddOperator::Operation(interval_t left, date_t right);
-template <>
-timestamp_t AddOperator::Operation(timestamp_t left, interval_t right);
-template <>
-timestamp_t AddOperator::Operation(interval_t left, timestamp_t right);
-
-struct TryAddOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryAddOperator");
-	}
-};
-
-template <>
-bool TryAddOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TryAddOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TryAddOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TryAddOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-
-template <>
-bool TryAddOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TryAddOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryAddOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-DUCKDB_API bool TryAddOperator::Operation(int64_t left, int64_t right, int64_t &result);
-
-struct AddOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryAddOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in addition of %s (%d + %d)!", TypeIdToString(GetTypeId<TA>()), left,
-			                          right);
-		}
-		return result;
-	}
-};
-
-struct TryDecimalAdd {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalAdd");
-	}
-};
-
-template <>
-bool TryDecimalAdd::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalAdd::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalAdd::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalAdd::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalAddOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalAdd::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in addition of DECIMAL(18) (%d + %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalAddOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-struct AddTimeOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right);
-};
-
-template <>
-dtime_t AddTimeOperator::Operation(dtime_t left, interval_t right);
-template <>
-dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/subtract.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct SubtractOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left - right;
-	}
-};
-
-template <>
-float SubtractOperator::Operation(float left, float right);
-template <>
-double SubtractOperator::Operation(double left, double right);
-template <>
-interval_t SubtractOperator::Operation(interval_t left, interval_t right);
-template <>
-int64_t SubtractOperator::Operation(date_t left, date_t right);
-template <>
-date_t SubtractOperator::Operation(date_t left, int32_t right);
-template <>
-date_t SubtractOperator::Operation(date_t left, interval_t right);
-template <>
-timestamp_t SubtractOperator::Operation(timestamp_t left, interval_t right);
-template <>
-interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right);
-
-struct TrySubtractOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TrySubtractOperator");
-	}
-};
-
-template <>
-bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-
-template <>
-bool TrySubtractOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TrySubtractOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TrySubtractOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TrySubtractOperator::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct SubtractOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TrySubtractOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in subtraction of %s (%d - %d)!", TypeIdToString(GetTypeId<TA>()), left,
-			                          right);
-		}
-		return result;
-	}
-};
-
-struct TryDecimalSubtract {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalSubtract");
-	}
-};
-
-template <>
-bool TryDecimalSubtract::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalSubtract::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalSubtract::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalSubtract::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalSubtractOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalSubtract::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in subtract of DECIMAL(18) (%d - %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalSubtractOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-struct SubtractTimeOperator {
-	template <class TA, class TB, class TR>
-	static TR Operation(TA left, TB right);
-};
-
-template <>
-dtime_t SubtractTimeOperator::Operation(dtime_t left, interval_t right);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/aggregate_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-
-
-namespace duckdb {
-
-struct Min {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return LessThan::Operation(left, right) ? left : right;
-	}
-};
-
-struct Max {
-	template <class T>
-	static inline T Operation(T left, T right) {
-		return GreaterThan::Operation(left, right) ? left : right;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/numeric_binary_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-#include <cmath>
-
-namespace duckdb {
-
-struct DivideOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		D_ASSERT(right != 0); // this should be checked before!
-		return left / right;
-	}
-};
-
-struct ModuloOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		D_ASSERT(right != 0);
-		return left % right;
-	}
-};
-
-template <>
-float DivideOperator::Operation(float left, float right);
-template <>
-double DivideOperator::Operation(double left, double right);
-template <>
-hugeint_t DivideOperator::Operation(hugeint_t left, hugeint_t right);
-template <>
-interval_t DivideOperator::Operation(interval_t left, int64_t right);
-
-template <>
-float ModuloOperator::Operation(float left, float right);
-template <>
-double ModuloOperator::Operation(double left, double right);
-template <>
-hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/nested_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-enum class MapInvalidReason : uint8_t { VALID, NULL_KEY_LIST, NULL_KEY, DUPLICATE_KEY };
-
-struct VariableReturnBindData : public FunctionData {
-	LogicalType stype;
-
-	explicit VariableReturnBindData(const LogicalType &stype_p) : stype(stype_p) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<VariableReturnBindData>(stype);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const VariableReturnBindData &)other_p;
-		return stype == other.stype;
-	}
-};
-
-template <class T, class MAP_TYPE = map<T, idx_t>>
-struct HistogramAggState {
-	MAP_TYPE *hist;
-};
-
-struct ArraySliceFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StructPackFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StructInsertFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListValueFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListRangeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapExtractFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListExtractFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListConcatFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListContainsFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListFlattenFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListPositionFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListAggregateFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListDistinctFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListUniqueFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListSortFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CardinalityFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StructExtractFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-MapInvalidReason CheckMapValidity(Vector &map, idx_t count,
-                                  const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/likely.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#if __GNUC__
-#define DUCKDB_BUILTIN_EXPECT(cond, expected_value) (__builtin_expect(cond, expected_value))
-#else
-#define DUCKDB_BUILTIN_EXPECT(cond, expected_value) (cond)
-#endif
-
-#define DUCKDB_LIKELY(...)   DUCKDB_BUILTIN_EXPECT((__VA_ARGS__), 1)
-#define DUCKDB_UNLIKELY(...) DUCKDB_BUILTIN_EXPECT((__VA_ARGS__), 0)
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/decimal_cast.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/general_cast.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct HandleVectorCastError {
-	template <class RESULT_TYPE>
-	static RESULT_TYPE Operation(string error_message, ValidityMask &mask, idx_t idx, string *error_message_ptr,
-	                             bool &all_converted) {
-		HandleCastError::AssignError(error_message, error_message_ptr);
-		all_converted = false;
-		mask.SetInvalid(idx);
-		return NullValue<RESULT_TYPE>();
-	}
-};
-
-static string UnimplementedCastMessage(const LogicalType &source_type, const LogicalType &target_type) {
-	return StringUtil::Format("Unimplemented type for cast (%s -> %s)", source_type.ToString(), target_type.ToString());
-}
-
-// NULL cast only works if all values in source are NULL, otherwise an unimplemented cast exception is thrown
-static bool TryVectorNullCast(Vector &source, Vector &result, idx_t count, string *error_message) {
-	bool success = true;
-	if (VectorOperations::HasNotNull(source, count)) {
-		HandleCastError::AssignError(UnimplementedCastMessage(source.GetType(), result.GetType()), error_message);
-		success = false;
-	}
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	ConstantVector::SetNull(result, true);
-	return success;
-}
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct VectorDecimalCastData {
-	VectorDecimalCastData(string *error_message_p, uint8_t width_p, uint8_t scale_p)
-	    : error_message(error_message_p), width(width_p), scale(scale_p) {
-	}
-
-	string *error_message;
-	uint8_t width;
-	uint8_t scale;
-	bool all_converted = true;
-};
-
-template <class OP>
-struct VectorDecimalCastOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (VectorDecimalCastData *)dataptr;
-		RESULT_TYPE result_value;
-		if (!OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, result_value, data->error_message, data->width,
-		                                                     data->scale)) {
-			return HandleVectorCastError::Operation<RESULT_TYPE>("Failed to cast decimal value", mask, idx,
-			                                                     data->error_message, data->all_converted);
-		}
-		return result_value;
-	}
-};
-
-template <class SRC, class T, class OP>
-bool TemplatedVectorDecimalCast(Vector &source, Vector &result, idx_t count, string *error_message, uint8_t width,
-                                uint8_t scale) {
-	VectorDecimalCastData input(error_message, width, scale);
-	UnaryExecutor::GenericExecute<SRC, T, VectorDecimalCastOperator<OP>>(source, result, count, (void *)&input,
-	                                                                     error_message);
-	return input.all_converted;
-}
-
-template <class T>
-static bool ToDecimalCast(Vector &source, Vector &result, idx_t count, string *error_message) {
-	auto &result_type = result.GetType();
-	auto width = DecimalType::GetWidth(result_type);
-	auto scale = DecimalType::GetScale(result_type);
-	switch (result_type.InternalType()) {
-	case PhysicalType::INT16:
-		return TemplatedVectorDecimalCast<T, int16_t, TryCastToDecimal>(source, result, count, error_message, width,
-		                                                                scale);
-	case PhysicalType::INT32:
-		return TemplatedVectorDecimalCast<T, int32_t, TryCastToDecimal>(source, result, count, error_message, width,
-		                                                                scale);
-	case PhysicalType::INT64:
-		return TemplatedVectorDecimalCast<T, int64_t, TryCastToDecimal>(source, result, count, error_message, width,
-		                                                                scale);
-	case PhysicalType::INT128:
-		return TemplatedVectorDecimalCast<T, hugeint_t, TryCastToDecimal>(source, result, count, error_message, width,
-		                                                                  scale);
-	default:
-		throw InternalException("Unimplemented internal type for decimal");
-	}
-}
-
-template <class T>
-static bool FromDecimalCast(Vector &source, Vector &result, idx_t count, string *error_message) {
-	auto &source_type = source.GetType();
-	auto width = DecimalType::GetWidth(source_type);
-	auto scale = DecimalType::GetScale(source_type);
-	switch (source_type.InternalType()) {
-	case PhysicalType::INT16:
-		return TemplatedVectorDecimalCast<int16_t, T, TryCastFromDecimal>(source, result, count, error_message, width,
-		                                                                  scale);
-	case PhysicalType::INT32:
-		return TemplatedVectorDecimalCast<int32_t, T, TryCastFromDecimal>(source, result, count, error_message, width,
-		                                                                  scale);
-	case PhysicalType::INT64:
-		return TemplatedVectorDecimalCast<int64_t, T, TryCastFromDecimal>(source, result, count, error_message, width,
-		                                                                  scale);
-	case PhysicalType::INT128:
-		return TemplatedVectorDecimalCast<hugeint_t, T, TryCastFromDecimal>(source, result, count, error_message, width,
-		                                                                    scale);
-	default:
-		throw InternalException("Unimplemented internal type for decimal");
-	}
-}
-
-template <class LIMIT_TYPE, class FACTOR_TYPE = LIMIT_TYPE>
-struct DecimalScaleInput {
-	DecimalScaleInput(Vector &result_p, FACTOR_TYPE factor_p) : result(result_p), factor(factor_p) {
-	}
-	DecimalScaleInput(Vector &result_p, LIMIT_TYPE limit_p, FACTOR_TYPE factor_p, string *error_message_p,
-	                  uint8_t source_scale_p)
-	    : result(result_p), limit(limit_p), factor(factor_p), error_message(error_message_p),
-	      source_scale(source_scale_p) {
-	}
-
-	Vector &result;
-	LIMIT_TYPE limit;
-	FACTOR_TYPE factor;
-	bool all_converted = true;
-	string *error_message;
-	uint8_t source_scale;
-};
-
-struct DecimalScaleUpOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (DecimalScaleInput<INPUT_TYPE, RESULT_TYPE> *)dataptr;
-		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input) * data->factor;
-	}
-};
-
-struct DecimalScaleUpCheckOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (DecimalScaleInput<INPUT_TYPE, RESULT_TYPE> *)dataptr;
-		if (input >= data->limit || input <= -data->limit) {
-			auto error =
-			    StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
-			                       Decimal::ToString(input, data->source_scale), data->result.GetType().ToString());
-			return HandleVectorCastError::Operation<RESULT_TYPE>(move(error), mask, idx, data->error_message,
-			                                                     data->all_converted);
-		}
-		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input) * data->factor;
-	}
-};
-
-template <class SOURCE, class DEST, class POWERS_SOURCE, class POWERS_DEST>
-bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, string *error_message) {
-	auto source_scale = DecimalType::GetScale(source.GetType());
-	auto source_width = DecimalType::GetWidth(source.GetType());
-	auto result_scale = DecimalType::GetScale(result.GetType());
-	auto result_width = DecimalType::GetWidth(result.GetType());
-	D_ASSERT(result_scale >= source_scale);
-	idx_t scale_difference = result_scale - source_scale;
-	DEST multiply_factor = POWERS_DEST::POWERS_OF_TEN[scale_difference];
-	idx_t target_width = result_width - scale_difference;
-	if (source_width < target_width) {
-		DecimalScaleInput<SOURCE, DEST> input(result, multiply_factor);
-		// type will always fit: no need to check limit
-		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleUpOperator>(source, result, count, &input);
-		return true;
-	} else {
-		// type might not fit: check limit
-		auto limit = POWERS_SOURCE::POWERS_OF_TEN[target_width];
-		DecimalScaleInput<SOURCE, DEST> input(result, limit, multiply_factor, error_message, source_scale);
-		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleUpCheckOperator>(source, result, count, &input,
-		                                                                         error_message);
-		return input.all_converted;
-	}
-}
-
-struct DecimalScaleDownOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (DecimalScaleInput<INPUT_TYPE> *)dataptr;
-		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input / data->factor);
-	}
-};
-
-struct DecimalScaleDownCheckOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (DecimalScaleInput<INPUT_TYPE> *)dataptr;
-		if (input >= data->limit || input <= -data->limit) {
-			auto error =
-			    StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
-			                       Decimal::ToString(input, data->source_scale), data->result.GetType().ToString());
-			return HandleVectorCastError::Operation<RESULT_TYPE>(move(error), mask, idx, data->error_message,
-			                                                     data->all_converted);
-		}
-		return Cast::Operation<INPUT_TYPE, RESULT_TYPE>(input / data->factor);
-	}
-};
-
-template <class SOURCE, class DEST, class POWERS_SOURCE>
-bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, string *error_message) {
-	auto source_scale = DecimalType::GetScale(source.GetType());
-	auto source_width = DecimalType::GetWidth(source.GetType());
-	auto result_scale = DecimalType::GetScale(result.GetType());
-	auto result_width = DecimalType::GetWidth(result.GetType());
-	D_ASSERT(result_scale < source_scale);
-	idx_t scale_difference = source_scale - result_scale;
-	idx_t target_width = result_width + scale_difference;
-	SOURCE divide_factor = POWERS_SOURCE::POWERS_OF_TEN[scale_difference];
-	if (source_width < target_width) {
-		DecimalScaleInput<SOURCE> input(result, divide_factor);
-		// type will always fit: no need to check limit
-		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleDownOperator>(source, result, count, &input);
-		return true;
-	} else {
-		// type might not fit: check limit
-		auto limit = POWERS_SOURCE::POWERS_OF_TEN[target_width];
-		DecimalScaleInput<SOURCE> input(result, limit, divide_factor, error_message, source_scale);
-		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleDownCheckOperator>(source, result, count, &input,
-		                                                                           error_message);
-		return input.all_converted;
-	}
-}
-
-template <class SOURCE, class POWERS_SOURCE>
-static bool DecimalDecimalCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	auto source_scale = DecimalType::GetScale(source.GetType());
-	auto result_scale = DecimalType::GetScale(result.GetType());
-	source.GetType().Verify();
-	result.GetType().Verify();
-
-	// we need to either multiply or divide by the difference in scales
-	if (result_scale >= source_scale) {
-		// multiply
-		switch (result.GetType().InternalType()) {
-		case PhysicalType::INT16:
-			return TemplatedDecimalScaleUp<SOURCE, int16_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              error_message);
-		case PhysicalType::INT32:
-			return TemplatedDecimalScaleUp<SOURCE, int32_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              error_message);
-		case PhysicalType::INT64:
-			return TemplatedDecimalScaleUp<SOURCE, int64_t, POWERS_SOURCE, NumericHelper>(source, result, count,
-			                                                                              error_message);
-		case PhysicalType::INT128:
-			return TemplatedDecimalScaleUp<SOURCE, hugeint_t, POWERS_SOURCE, Hugeint>(source, result, count,
-			                                                                          error_message);
-		default:
-			throw NotImplementedException("Unimplemented internal type for decimal");
-		}
-	} else {
-		// divide
-		switch (result.GetType().InternalType()) {
-		case PhysicalType::INT16:
-			return TemplatedDecimalScaleDown<SOURCE, int16_t, POWERS_SOURCE>(source, result, count, error_message);
-		case PhysicalType::INT32:
-			return TemplatedDecimalScaleDown<SOURCE, int32_t, POWERS_SOURCE>(source, result, count, error_message);
-		case PhysicalType::INT64:
-			return TemplatedDecimalScaleDown<SOURCE, int64_t, POWERS_SOURCE>(source, result, count, error_message);
-		case PhysicalType::INT128:
-			return TemplatedDecimalScaleDown<SOURCE, hugeint_t, POWERS_SOURCE>(source, result, count, error_message);
-		default:
-			throw NotImplementedException("Unimplemented internal type for decimal");
-		}
-	}
-}
-
-struct DecimalCastInput {
-	DecimalCastInput(Vector &result_p, uint8_t width_p, uint8_t scale_p)
-	    : result(result_p), width(width_p), scale(scale_p) {
-	}
-
-	Vector &result;
-	uint8_t width;
-	uint8_t scale;
-};
-
-struct StringCastFromDecimalOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (DecimalCastInput *)dataptr;
-		return StringCastFromDecimal::Operation<INPUT_TYPE>(input, data->width, data->scale, data->result);
-	}
-};
-
-static bool DecimalCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
-	// now switch on the result type
-	switch (result.GetType().id()) {
-	case LogicalTypeId::BOOLEAN:
-		return FromDecimalCast<bool>(source, result, count, error_message);
-	case LogicalTypeId::TINYINT:
-		return FromDecimalCast<int8_t>(source, result, count, error_message);
-	case LogicalTypeId::SMALLINT:
-		return FromDecimalCast<int16_t>(source, result, count, error_message);
-	case LogicalTypeId::INTEGER:
-		return FromDecimalCast<int32_t>(source, result, count, error_message);
-	case LogicalTypeId::BIGINT:
-		return FromDecimalCast<int64_t>(source, result, count, error_message);
-	case LogicalTypeId::UTINYINT:
-		return FromDecimalCast<uint8_t>(source, result, count, error_message);
-	case LogicalTypeId::USMALLINT:
-		return FromDecimalCast<uint16_t>(source, result, count, error_message);
-	case LogicalTypeId::UINTEGER:
-		return FromDecimalCast<uint32_t>(source, result, count, error_message);
-	case LogicalTypeId::UBIGINT:
-		return FromDecimalCast<uint64_t>(source, result, count, error_message);
-	case LogicalTypeId::HUGEINT:
-		return FromDecimalCast<hugeint_t>(source, result, count, error_message);
-	case LogicalTypeId::DECIMAL: {
-		// decimal to decimal cast
-		// first we need to figure out the source and target internal types
-		switch (source.GetType().InternalType()) {
-		case PhysicalType::INT16:
-			return DecimalDecimalCastSwitch<int16_t, NumericHelper>(source, result, count, error_message);
-		case PhysicalType::INT32:
-			return DecimalDecimalCastSwitch<int32_t, NumericHelper>(source, result, count, error_message);
-		case PhysicalType::INT64:
-			return DecimalDecimalCastSwitch<int64_t, NumericHelper>(source, result, count, error_message);
-		case PhysicalType::INT128:
-			return DecimalDecimalCastSwitch<hugeint_t, Hugeint>(source, result, count, error_message);
-		default:
-			throw NotImplementedException("Unimplemented internal type for decimal in decimal_decimal cast");
-		}
-		break;
-	}
-	case LogicalTypeId::FLOAT:
-		return FromDecimalCast<float>(source, result, count, error_message);
-	case LogicalTypeId::DOUBLE:
-		return FromDecimalCast<double>(source, result, count, error_message);
-	case LogicalTypeId::VARCHAR: {
-		auto &source_type = source.GetType();
-		auto width = DecimalType::GetWidth(source_type);
-		auto scale = DecimalType::GetScale(source_type);
-		DecimalCastInput input(result, width, scale);
-		switch (source_type.InternalType()) {
-		case PhysicalType::INT16:
-			UnaryExecutor::GenericExecute<int16_t, string_t, StringCastFromDecimalOperator>(source, result, count,
-			                                                                                (void *)&input);
-			break;
-		case PhysicalType::INT32:
-			UnaryExecutor::GenericExecute<int32_t, string_t, StringCastFromDecimalOperator>(source, result, count,
-			                                                                                (void *)&input);
-			break;
-		case PhysicalType::INT64:
-			UnaryExecutor::GenericExecute<int64_t, string_t, StringCastFromDecimalOperator>(source, result, count,
-			                                                                                (void *)&input);
-			break;
-		case PhysicalType::INT128:
-			UnaryExecutor::GenericExecute<hugeint_t, string_t, StringCastFromDecimalOperator>(source, result, count,
-			                                                                                  (void *)&input);
-			break;
-		default:
-			throw InternalException("Unimplemented internal decimal type");
-		}
-		return true;
-	}
-	default:
-		return TryVectorNullCast(source, result, count, error_message);
-	}
-}
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/virtual_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-// bunch of wrappers to allow registering protocol handlers
-class VirtualFileSystem : public FileSystem {
-public:
-	VirtualFileSystem();
-
-	unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags, FileLockType lock = FileLockType::NO_LOCK,
-	                                FileCompressionType compression = FileCompressionType::UNCOMPRESSED,
-	                                FileOpener *opener = nullptr) override;
-
-	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
-		handle.file_system.Read(handle, buffer, nr_bytes, location);
-	};
-
-	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
-		handle.file_system.Write(handle, buffer, nr_bytes, location);
-	}
-
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
-		return handle.file_system.Read(handle, buffer, nr_bytes);
-	}
-
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
-		return handle.file_system.Write(handle, buffer, nr_bytes);
-	}
-
-	int64_t GetFileSize(FileHandle &handle) override {
-		return handle.file_system.GetFileSize(handle);
-	}
-	time_t GetLastModifiedTime(FileHandle &handle) override {
-		return handle.file_system.GetLastModifiedTime(handle);
-	}
-	FileType GetFileType(FileHandle &handle) override {
-		return handle.file_system.GetFileType(handle);
-	}
-
-	void Truncate(FileHandle &handle, int64_t new_size) override {
-		handle.file_system.Truncate(handle, new_size);
-	}
-
-	void FileSync(FileHandle &handle) override {
-		handle.file_system.FileSync(handle);
-	}
-
-	// need to look up correct fs for this
-	bool DirectoryExists(const string &directory) override {
-		return FindFileSystem(directory)->DirectoryExists(directory);
-	}
-	void CreateDirectory(const string &directory) override {
-		FindFileSystem(directory)->CreateDirectory(directory);
-	}
-
-	void RemoveDirectory(const string &directory) override {
-		FindFileSystem(directory)->RemoveDirectory(directory);
-	}
-
-	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback) override {
-		return FindFileSystem(directory)->ListFiles(directory, callback);
-	}
-
-	void MoveFile(const string &source, const string &target) override {
-		FindFileSystem(source)->MoveFile(source, target);
-	}
-
-	bool FileExists(const string &filename) override {
-		return FindFileSystem(filename)->FileExists(filename);
-	}
-
-	bool IsPipe(const string &filename) override {
-		return FindFileSystem(filename)->IsPipe(filename);
-	}
-	virtual void RemoveFile(const string &filename) override {
-		FindFileSystem(filename)->RemoveFile(filename);
-	}
-
-	virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
-		return FindFileSystem(path)->Glob(path, opener);
-	}
-
-	void RegisterSubSystem(unique_ptr<FileSystem> fs) override {
-		sub_systems.push_back(move(fs));
-	}
-
-	void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) override {
-		compressed_fs[compression_type] = move(fs);
-	}
-
-	std::string GetName() const override {
-		return "VirtualFileSystem";
-	}
-
-private:
-	FileSystem *FindFileSystem(const string &path) {
-		for (auto &sub_system : sub_systems) {
-			if (sub_system->CanHandleFile(path)) {
-				return sub_system.get();
-			}
-		}
-		return default_fs.get();
-	}
-
-private:
-	vector<unique_ptr<FileSystem>> sub_systems;
-	map<FileCompressionType, unique_ptr<FileSystem>> compressed_fs;
-	const unique_ptr<FileSystem> default_fs;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/column_binding_resolver.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/column_binding_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct ColumnBindingHashFunction {
-	uint64_t operator()(const ColumnBinding &a) const {
-		return CombineHash(Hash<idx_t>(a.table_index), Hash<idx_t>(a.column_index));
-	}
-};
-
-struct ColumnBindingEquality {
-	bool operator()(const ColumnBinding &a, const ColumnBinding &b) const {
-		return a == b;
-	}
-};
-
-template <typename T>
-using column_binding_map_t = unordered_map<ColumnBinding, T, ColumnBindingHashFunction, ColumnBindingEquality>;
-
-using column_binding_set_t = unordered_set<ColumnBinding, ColumnBindingHashFunction, ColumnBindingEquality>;
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//! The ColumnBindingResolver resolves ColumnBindings into base tables
-//! (table_index, column_index) into physical indices into the DataChunks that
-//! are used within the execution engine
-class ColumnBindingResolver : public LogicalOperatorVisitor {
-public:
-	ColumnBindingResolver();
-
-	void VisitOperator(LogicalOperator &op) override;
-
-protected:
-	vector<ColumnBinding> bindings;
-
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_comparison_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/joinside.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! JoinCondition represents a left-right comparison join condition
-struct JoinCondition {
-public:
-	JoinCondition() {
-	}
-
-	//! Turns the JoinCondition into an expression; note that this destroys the JoinCondition as the expression inherits
-	//! the left/right expressions
-	static unique_ptr<Expression> CreateExpression(JoinCondition cond);
-	static unique_ptr<Expression> CreateExpression(vector<JoinCondition> conditions);
-
-public:
-	unique_ptr<Expression> left;
-	unique_ptr<Expression> right;
-	ExpressionType comparison;
-};
-
-class JoinSide {
-public:
-	enum JoinValue : uint8_t { NONE, LEFT, RIGHT, BOTH };
-
-	JoinSide() = default;
-	constexpr JoinSide(JoinValue val) : value(val) { // NOLINT: Allow implicit conversion from `join_value`
-	}
-
-	bool operator==(JoinSide a) const {
-		return value == a.value;
-	}
-	bool operator!=(JoinSide a) const {
-		return value != a.value;
-	}
-
-	static JoinSide CombineJoinSide(JoinSide left, JoinSide right);
-	static JoinSide GetJoinSide(idx_t table_binding, unordered_set<idx_t> &left_bindings,
-	                            unordered_set<uint64_t> &right_bindings);
-	static JoinSide GetJoinSide(Expression &expression, unordered_set<idx_t> &left_bindings,
-	                            unordered_set<idx_t> &right_bindings);
-	static JoinSide GetJoinSide(const unordered_set<idx_t> &bindings, unordered_set<idx_t> &left_bindings,
-	                            unordered_set<idx_t> &right_bindings);
-
-private:
-	JoinValue value;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalJoin represents a join between two relations
-class LogicalJoin : public LogicalOperator {
-public:
-	explicit LogicalJoin(JoinType type, LogicalOperatorType logical_type = LogicalOperatorType::LOGICAL_JOIN);
-
-	// Gets the set of table references that are reachable from this node
-	static void GetTableReferences(LogicalOperator &op, unordered_set<idx_t> &bindings);
-	static void GetExpressionBindings(Expression &expr, unordered_set<idx_t> &bindings);
-
-	//! The type of the join (INNER, OUTER, etc...)
-	JoinType join_type;
-	//! Table index used to refer to the MARK column (in case of a MARK join)
-	idx_t mark_index;
-	//! The columns of the LHS that are output by the join
-	vector<idx_t> left_projection_map;
-	//! The columns of the RHS that are output by the join
-	vector<idx_t> right_projection_map;
-	//! Join Keys statistics (optional)
-	vector<unique_ptr<BaseStatistics>> join_stats;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-protected:
-	void ResolveTypes() override;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//! LogicalComparisonJoin represents a join that involves comparisons between the LHS and RHS
-class LogicalComparisonJoin : public LogicalJoin {
-public:
-	explicit LogicalComparisonJoin(JoinType type,
-	                               LogicalOperatorType logical_type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
-
-	//! The conditions of the join
-	vector<JoinCondition> conditions;
-	//! Used for duplicate-eliminated joins
-	vector<LogicalType> delim_types;
-
-public:
-	string ParamsToString() const override;
-
-public:
-	static unique_ptr<LogicalOperator> CreateJoin(JoinType type, unique_ptr<LogicalOperator> left_child,
-	                                              unique_ptr<LogicalOperator> right_child,
-	                                              unordered_set<idx_t> &left_bindings,
-	                                              unordered_set<idx_t> &right_bindings,
-	                                              vector<unique_ptr<Expression>> &expressions);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_create_index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class LogicalCreateIndex : public LogicalOperator {
-public:
-	LogicalCreateIndex(TableCatalogEntry &table, vector<column_t> column_ids,
-	                   vector<unique_ptr<Expression>> expressions, unique_ptr<CreateIndexInfo> info)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), table(table), column_ids(column_ids),
-	      info(std::move(info)) {
-		for (auto &expr : expressions) {
-			this->unbound_expressions.push_back(expr->Copy());
-		}
-		this->expressions = move(expressions);
-	}
-
-	//! The table to create the index for
-	TableCatalogEntry &table;
-	//! Column IDs needed for index creation
-	vector<column_t> column_ids;
-	// Info for index creation
-	unique_ptr<CreateIndexInfo> info;
-	//! Unbound expressions to be used in the optimizer
-	vector<unique_ptr<Expression>> unbound_expressions;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_delim_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalDelimJoin represents a special "duplicate eliminated" join. This join type is only used for subquery
-//! flattening, and involves performing duplicate elimination on the LEFT side which is then pushed into the RIGHT side.
-class LogicalDelimJoin : public LogicalComparisonJoin {
-public:
-	explicit LogicalDelimJoin(JoinType type) : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-	}
-
-	//! The set of columns that will be duplicate eliminated from the LHS and pushed into the RHS
-	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/join_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-class BufferManager;
-class BufferHandle;
-
-struct JoinHTScanState {
-	JoinHTScanState() : position(0), block_position(0) {
-	}
-
-	idx_t position;
-	idx_t block_position;
-	mutex lock;
-};
-
-//! JoinHashTable is a linear probing HT that is used for computing joins
-/*!
-   The JoinHashTable concatenates incoming chunks inside a linked list of
-   data ptrs. The storage looks like this internally.
-   [SERIALIZED ROW][NEXT POINTER]
-   [SERIALIZED ROW][NEXT POINTER]
-   There is a separate hash map of pointers that point into this table.
-   This is what is used to resolve the hashes.
-   [POINTER]
-   [POINTER]
-   [POINTER]
-   The pointers are either NULL
-*/
-class JoinHashTable {
-public:
-	using ValidityBytes = TemplatedValidityMask<uint8_t>;
-
-	//! Scan structure that can be used to resume scans, as a single probe can
-	//! return 1024*N values (where N is the size of the HT). This is
-	//! returned by the JoinHashTable::Scan function and can be used to resume a
-	//! probe.
-	struct ScanStructure {
-		unique_ptr<VectorData[]> key_data;
-		Vector pointers;
-		idx_t count;
-		SelectionVector sel_vector;
-		// whether or not the given tuple has found a match
-		unique_ptr<bool[]> found_match;
-		JoinHashTable &ht;
-		bool finished;
-
-		explicit ScanStructure(JoinHashTable &ht);
-		//! Get the next batch of data from the scan structure
-		void Next(DataChunk &keys, DataChunk &left, DataChunk &result);
-
-	private:
-		//! Next operator for the inner join
-		void NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the semi join
-		void NextSemiJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the anti join
-		void NextAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the left outer join
-		void NextLeftJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the mark join
-		void NextMarkJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-		//! Next operator for the single join
-		void NextSingleJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-
-		//! Scan the hashtable for matches of the specified keys, setting the found_match[] array to true or false
-		//! for every tuple
-		void ScanKeyMatches(DataChunk &keys);
-		template <bool MATCH>
-		void NextSemiOrAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
-
-		void ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &child, DataChunk &result);
-
-		idx_t ScanInnerJoin(DataChunk &keys, SelectionVector &result_vector);
-
-		idx_t ResolvePredicates(DataChunk &keys, SelectionVector &match_sel);
-		idx_t ResolvePredicates(DataChunk &keys, SelectionVector &match_sel, SelectionVector &no_match_sel);
-
-	public:
-		void AdvancePointers();
-		void AdvancePointers(const SelectionVector &sel, idx_t sel_count);
-		void GatherResult(Vector &result, const SelectionVector &result_vector, const SelectionVector &sel_vector,
-		                  const idx_t count, const idx_t col_idx);
-		void GatherResult(Vector &result, const SelectionVector &sel_vector, const idx_t count, const idx_t col_idx);
-		idx_t ResolvePredicates(DataChunk &keys, SelectionVector &match_sel, SelectionVector *no_match_sel);
-	};
-
-private:
-public:
-	JoinHashTable(BufferManager &buffer_manager, const vector<JoinCondition> &conditions,
-	              vector<LogicalType> build_types, JoinType type);
-	~JoinHashTable();
-
-	//! Add the given data to the HT
-	void Build(DataChunk &keys, DataChunk &input);
-	//! Finalize the build of the HT, constructing the actual hash table and making the HT ready for probing.
-	//! Finalize must be called before any call to Probe, and after Finalize is called Build should no longer be
-	//! ever called.
-	void Finalize();
-	//! Probe the HT with the given input chunk, resulting in the given result
-	unique_ptr<ScanStructure> Probe(DataChunk &keys);
-	//! Scan the HT to construct the final full outer join result after
-	void ScanFullOuter(DataChunk &result, JoinHTScanState &state);
-	//! Fill the pointer with all the addresses from the hashtable for full scan
-	idx_t FillWithHTOffsets(data_ptr_t *key_locations, JoinHTScanState &state);
-
-	idx_t Count() {
-		return block_collection->count;
-	}
-
-	//! BufferManager
-	BufferManager &buffer_manager;
-	//! The types of the keys used in equality comparison
-	vector<LogicalType> equality_types;
-	//! The types of the keys
-	vector<LogicalType> condition_types;
-	//! The types of all conditions
-	vector<LogicalType> build_types;
-	//! The comparison predicates
-	vector<ExpressionType> predicates;
-	//! Data column layout
-	RowLayout layout;
-	//! The size of an entry as stored in the HashTable
-	idx_t entry_size;
-	//! The total tuple size
-	idx_t tuple_size;
-	//! Next pointer offset in tuple
-	idx_t pointer_offset;
-	//! A constant false column for initialising right outer joins
-	Vector vfound;
-	//! The join type of the HT
-	JoinType join_type;
-	//! Whether or not the HT has been finalized
-	bool finalized;
-	//! Whether or not any of the key elements contain NULL
-	bool has_null;
-	//! Bitmask for getting relevant bits from the hashes to determine the position
-	uint64_t bitmask;
-
-	struct {
-		mutex mj_lock;
-		//! The types of the duplicate eliminated columns, only used in correlated MARK JOIN for flattening
-		//! ANY()/ALL() expressions
-		vector<LogicalType> correlated_types;
-		//! The aggregate expression nodes used by the HT
-		vector<unique_ptr<Expression>> correlated_aggregates;
-		//! The HT that holds the group counts for every correlated column
-		unique_ptr<GroupedAggregateHashTable> correlated_counts;
-		//! Group chunk used for aggregating into correlated_counts
-		DataChunk group_chunk;
-		//! Payload chunk used for aggregating into correlated_counts
-		DataChunk correlated_payload;
-		//! Result chunk used for aggregating into correlated_counts
-		DataChunk result_chunk;
-	} correlated_mark_join_info;
-
-private:
-	void Hash(DataChunk &keys, const SelectionVector &sel, idx_t count, Vector &hashes);
-
-	//! Apply a bitmask to the hashes
-	void ApplyBitmask(Vector &hashes, idx_t count);
-	void ApplyBitmask(Vector &hashes, const SelectionVector &sel, idx_t count, Vector &pointers);
-
-private:
-	//! Insert the given set of locations into the HT with the given set of
-	//! hashes. Caller should hold lock in parallel HT.
-	void InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[]);
-
-	idx_t PrepareKeys(DataChunk &keys, unique_ptr<VectorData[]> &key_data, const SelectionVector *&current_sel,
-	                  SelectionVector &sel, bool build_side);
-
-	//! The RowDataCollection holding the main data of the hash table
-	unique_ptr<RowDataCollection> block_collection;
-	//! The stringheap of the JoinHashTable
-	unique_ptr<RowDataCollection> string_heap;
-	//! Pinned handles, these are pinned during finalization only
-	vector<BufferHandle> pinned_handles;
-	//! The hash map of the HT, created after finalization
-	BufferHandle hash_map;
-	//! Whether or not NULL values are considered equal in each of the comparisons
-	vector<bool> null_values_are_equal;
-
-	//! Copying not allowed
-	JoinHashTable(const JoinHashTable &) = delete;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/nested_loop_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct NestedLoopJoinInner {
-	static idx_t Perform(idx_t &ltuple, idx_t &rtuple, DataChunk &left_conditions, DataChunk &right_conditions,
-	                     SelectionVector &lvector, SelectionVector &rvector, const vector<JoinCondition> &conditions);
-};
-
-struct NestedLoopJoinMark {
-	static void Perform(DataChunk &left, ChunkCollection &right, bool found_match[],
-	                    const vector<JoinCondition> &conditions);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Executor;
-class Task;
-
-class Event : public std::enable_shared_from_this<Event> {
-public:
-	Event(Executor &executor);
-	virtual ~Event() = default;
-
-public:
-	virtual void Schedule() = 0;
-	//! Called right after the event is finished
-	virtual void FinishEvent() {
-	}
-	//! Called after the event is entirely finished
-	virtual void FinalizeFinish() {
-	}
-
-	void FinishTask();
-	void Finish();
-
-	void AddDependency(Event &event);
-	bool HasDependencies() {
-		return total_dependencies != 0;
-	}
-	void CompleteDependency();
-
-	void SetTasks(vector<unique_ptr<Task>> tasks);
-
-	void InsertEvent(shared_ptr<Event> replacement_event);
-
-	bool IsFinished() {
-		return finished;
-	}
-
-protected:
-	Executor &executor;
-	//! The current threads working on the event
-	atomic<idx_t> finished_tasks;
-	//! The maximum amount of threads that can work on the event
-	atomic<idx_t> total_tasks;
-
-	//! The amount of completed dependencies
-	//! The event can only be started after the dependencies have finished executing
-	atomic<idx_t> finished_dependencies;
-	//! The total amount of dependencies
-	idx_t total_dependencies;
-
-	//! The events that depend on this event to run
-	vector<weak_ptr<Event>> parents;
-
-	//! Whether or not the event is finished executing
-	atomic<bool> finished;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class PerfectAggregateHashTable;
-
-//! PhysicalPerfectHashAggregate performs a group-by and aggregation using a perfect hash table
-class PhysicalPerfectHashAggregate : public PhysicalOperator {
-public:
-	PhysicalPerfectHashAggregate(ClientContext &context, vector<LogicalType> types,
-	                             vector<unique_ptr<Expression>> aggregates, vector<unique_ptr<Expression>> groups,
-	                             vector<unique_ptr<BaseStatistics>> group_stats, vector<idx_t> required_bits,
-	                             idx_t estimated_cardinality);
-
-	//! The groups
-	vector<unique_ptr<Expression>> groups;
-	//! The aggregates that have to be computed
-	vector<unique_ptr<Expression>> aggregates;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	string ParamsToString() const override;
-
-	//! Create a perfect aggregate hash table for this node
-	unique_ptr<PerfectAggregateHashTable> CreateHT(Allocator &allocator, ClientContext &context) const;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	//! The group types
-	vector<LogicalType> group_types;
-	//! The payload types
-	vector<LogicalType> payload_types;
-	//! The aggregates to be computed
-	vector<AggregateObject> aggregate_objects;
-	//! The minimum value of each of the groups
-	vector<Value> group_minima;
-	//! The number of bits we need to completely cover each of the groups
-	vector<idx_t> required_bits;
-
-	unordered_map<Expression *, size_t> filter_indexes;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/perfect_aggregate_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class PerfectAggregateHashTable : public BaseAggregateHashTable {
-public:
-	PerfectAggregateHashTable(Allocator &allocator, BufferManager &buffer_manager,
-	                          const vector<LogicalType> &group_types, vector<LogicalType> payload_types_p,
-	                          vector<AggregateObject> aggregate_objects, vector<Value> group_minima,
-	                          vector<idx_t> required_bits);
-	~PerfectAggregateHashTable() override;
-
-public:
-	//! Add the given data to the HT
-	void AddChunk(DataChunk &groups, DataChunk &payload);
-
-	//! Combines the target perfect aggregate HT into this one
-	void Combine(PerfectAggregateHashTable &other);
-
-	//! Scan the HT starting from the scan_position
-	void Scan(idx_t &scan_position, DataChunk &result);
-
-protected:
-	Vector addresses;
-	//! The required bits per group
-	vector<idx_t> required_bits;
-	//! The total required bits for the HT (this determines the max capacity)
-	idx_t total_required_bits;
-	//! The total amount of groups
-	idx_t total_groups;
-	//! The tuple size
-	idx_t tuple_size;
-	//! The number of grouping columns
-	idx_t grouping_columns;
-
-	// The actual pointer to the data
-	data_ptr_t data;
-	//! The owned data of the HT
-	unique_ptr<data_t[]> owned_data;
-	//! Information on whether or not a specific group has any entries
-	unique_ptr<bool[]> group_is_set;
-
-	//! The minimum values for each of the group columns
-	vector<Value> group_minima;
-
-	//! Reused selection vector
-	SelectionVector sel;
-
-private:
-	//! Destroy the perfect aggregate HT (called automatically by the destructor)
-	void Destroy();
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_simple_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalSimpleAggregate is an aggregate operator that can only perform aggregates (1) without any groups, (2)
-//! without any DISTINCT aggregates, and (3) when all aggregates are combineable
-class PhysicalSimpleAggregate : public PhysicalOperator {
-public:
-	PhysicalSimpleAggregate(vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
-	                        idx_t estimated_cardinality);
-
-	//! The aggregates that have to be computed
-	vector<unique_ptr<Expression>> aggregates;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	string ParamsToString() const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/thread_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-
-//! The ThreadContext holds thread-local info for parallel usage
-class ThreadContext {
-public:
-	explicit ThreadContext(ClientContext &context);
-
-	//! The operator profiler for the individual thread context
-	OperatorProfiler profiler;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_window.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalStreamingWindow implements streaming window functions (i.e. with an empty OVER clause)
-class PhysicalStreamingWindow : public PhysicalOperator {
-public:
-	PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-	                        idx_t estimated_cardinality,
-	                        PhysicalOperatorType type = PhysicalOperatorType::STREAMING_WINDOW);
-
-	//! The projection list of the WINDOW statement
-	vector<unique_ptr<Expression>> select_list;
-
-public:
-	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	string ParamsToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/aggregate/physical_window.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalWindow implements window functions
-//! It assumes that all functions have a common partitioning and ordering
-class PhysicalWindow : public PhysicalOperator {
-public:
-	PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality,
-	               PhysicalOperatorType type = PhysicalOperatorType::WINDOW);
-
-	//! The projection list of the WINDOW statement (may contain aggregates)
-	vector<unique_ptr<Expression>> select_list;
-
-public:
-	// Source interface
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	idx_t MaxThreads(ClientContext &context);
-
-	string ParamsToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/window_segment_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class WindowSegmentTree {
-public:
-	using FrameBounds = std::pair<idx_t, idx_t>;
-
-	WindowSegmentTree(AggregateFunction &aggregate, FunctionData *bind_info, const LogicalType &result_type,
-	                  ChunkCollection *input, const ValidityMask &filter_mask, WindowAggregationMode mode);
-	~WindowSegmentTree();
-
-	//! First row contains the result.
-	void Compute(Vector &result, idx_t rid, idx_t start, idx_t end);
-
-private:
-	void ConstructTree();
-	void ExtractFrame(idx_t begin, idx_t end);
-	void WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end);
-	void AggregateInit();
-	void AggegateFinal(Vector &result, idx_t rid);
-
-	//! Use the window API, if available
-	inline bool UseWindowAPI() const {
-		return mode < WindowAggregationMode::COMBINE;
-	}
-	//! Use the combine API, if available
-	inline bool UseCombineAPI() const {
-		return mode < WindowAggregationMode::SEPARATE;
-	}
-
-	//! The aggregate that the window function is computed over
-	AggregateFunction aggregate;
-	//! The bind info of the aggregate
-	FunctionData *bind_info;
-	//! The result type of the window function
-	LogicalType result_type;
-
-	//! Data pointer that contains a single state, used for intermediate window segment aggregation
-	vector<data_t> state;
-	//! Input data chunk, used for intermediate window segment aggregation
-	DataChunk inputs;
-	//! The filtered rows in inputs.
-	SelectionVector filter_sel;
-	//! A vector of pointers to "state", used for intermediate window segment aggregation
-	Vector statep;
-	//! The frame boundaries, used for the window functions
-	FrameBounds frame;
-	//! The active data in the inputs. Used for the window functions
-	FrameBounds active;
-	//! Reused result state container for the window functions
-	Vector statev;
-
-	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
-	unique_ptr<data_t[]> levels_flat_native;
-	//! For each level, the starting location in the levels_flat_native array
-	vector<idx_t> levels_flat_start;
-
-	//! The total number of internal nodes of the tree, stored in levels_flat_native
-	idx_t internal_nodes;
-
-	//! The (sorted) input chunk collection on which the tree is built
-	ChunkCollection *input_ref;
-
-	//! The filtered rows in input_ref.
-	const ValidityMask &filter_mask;
-
-	//! Use the window API, if available
-	WindowAggregationMode mode;
-
-	// TREE_FANOUT needs to cleanly divide STANDARD_VECTOR_SIZE
-	static constexpr idx_t TREE_FANOUT = 64;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/filter/physical_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalFilter represents a filter operator. It removes non-matching tuples
-//! from the result. Note that it does not physically change the data, it only
-//! adds a selection vector to the chunk.
-class PhysicalFilter : public PhysicalOperator {
-public:
-	PhysicalFilter(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality);
-
-	//! The filter expression
-	unique_ptr<Expression> expression;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-	bool RequiresCache() const override {
-		return true;
-	}
-
-	string ParamsToString() const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_batch_collector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_result_collector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class PreparedStatementData;
-
-//! PhysicalResultCollector is an abstract class that is used to generate the final result of a query
-class PhysicalResultCollector : public PhysicalOperator {
-public:
-	PhysicalResultCollector(PreparedStatementData &data);
-
-	StatementType statement_type;
-	StatementProperties properties;
-	PhysicalOperator *plan;
-	vector<string> names;
-
-public:
-	static unique_ptr<PhysicalResultCollector> GetResultCollector(ClientContext &context, PreparedStatementData &data);
-
-public:
-	//! The final method used to fetch the query result from this operator
-	virtual unique_ptr<QueryResult> GetResult(GlobalSinkState &state) = 0;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-public:
-	vector<PhysicalOperator *> GetChildren() const override;
-
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class PhysicalBatchCollector : public PhysicalResultCollector {
-public:
-	PhysicalBatchCollector(PreparedStatementData &data);
-
-public:
-	unique_ptr<QueryResult> GetResult(GlobalSinkState &state) override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool RequiresBatchIndex() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_execute.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/prepared_statement_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-class CatalogEntry;
-class PhysicalOperator;
-class SQLStatement;
-
-class PreparedStatementData {
-public:
-	DUCKDB_API explicit PreparedStatementData(StatementType type);
-	DUCKDB_API ~PreparedStatementData();
-
-	StatementType statement_type;
-	//! The unbound SQL statement that was prepared
-	unique_ptr<SQLStatement> unbound_statement;
-	//! The fully prepared physical plan of the prepared statement
-	unique_ptr<PhysicalOperator> plan;
-	//! The map of parameter index to the actual value entry
-	unordered_map<idx_t, vector<unique_ptr<Value>>> value_map;
-
-	//! The result names of the transaction
-	vector<string> names;
-	//! The result types of the transaction
-	vector<LogicalType> types;
-
-	//! The statement properties
-	StatementProperties properties;
-
-	//! The catalog version of when the prepared statement was bound
-	//! If this version is lower than the current catalog version, we have to rebind the prepared statement
-	idx_t catalog_version;
-
-public:
-	//! Bind a set of values to the prepared statement data
-	DUCKDB_API void Bind(vector<Value> values);
-	//! Get the expected SQL Type of the bound parameter
-	DUCKDB_API LogicalType GetType(idx_t param_index);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class PhysicalExecute : public PhysicalOperator {
-public:
-	explicit PhysicalExecute(PhysicalOperator *plan);
-
-	PhysicalOperator *plan;
-	unique_ptr<PhysicalOperator> owned_plan;
-	shared_ptr<PreparedStatementData> prepared;
-
-public:
-	vector<PhysicalOperator *> GetChildren() const override;
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_explain_analyze.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class PhysicalExplainAnalyze : public PhysicalOperator {
-public:
-	PhysicalExplainAnalyze(vector<LogicalType> types)
-	    : PhysicalOperator(PhysicalOperatorType::EXPLAIN_ANALYZE, move(types), 1) {
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink Interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_limit.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhyisicalLimit represents the LIMIT operator
-class PhysicalLimit : public PhysicalOperator {
-public:
-	PhysicalLimit(vector<LogicalType> types, idx_t limit, idx_t offset, unique_ptr<Expression> limit_expression,
-	              unique_ptr<Expression> offset_expression, idx_t estimated_cardinality);
-
-	idx_t limit_value;
-	idx_t offset_value;
-	unique_ptr<Expression> limit_expression;
-	unique_ptr<Expression> offset_expression;
-
-public:
-	bool IsOrderDependent() const override {
-		return true;
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink Interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	bool RequiresBatchIndex() const override {
-		return true;
-	}
-
-public:
-	static bool ComputeOffset(ExecutionContext &context, DataChunk &input, idx_t &limit, idx_t &offset,
-	                          idx_t current_offset, idx_t &max_element, Expression *limit_expression,
-	                          Expression *offset_expression);
-	static bool HandleOffset(DataChunk &input, idx_t &current_offset, idx_t offset, idx_t limit);
-	static Value GetDelimiter(ExecutionContext &context, DataChunk &input, Expression *expr);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_streaming_limit.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class PhysicalStreamingLimit : public PhysicalOperator {
-public:
-	PhysicalStreamingLimit(vector<LogicalType> types, idx_t limit, idx_t offset,
-	                       unique_ptr<Expression> limit_expression, unique_ptr<Expression> offset_expression,
-	                       idx_t estimated_cardinality, bool parallel);
-
-	idx_t limit_value;
-	idx_t offset_value;
-	unique_ptr<Expression> limit_expression;
-	unique_ptr<Expression> offset_expression;
-	bool parallel;
-
-public:
-	// Operator interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool IsOrderDependent() const override;
-	bool ParallelOperator() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_limit_percent.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhyisicalLimitPercent represents the LIMIT PERCENT operator
-class PhysicalLimitPercent : public PhysicalOperator {
-public:
-	PhysicalLimitPercent(vector<LogicalType> types, double limit_percent, idx_t offset,
-	                     unique_ptr<Expression> limit_expression, unique_ptr<Expression> offset_expression,
-	                     idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::LIMIT_PERCENT, move(types), estimated_cardinality),
-	      limit_percent(limit_percent), offset_value(offset), limit_expression(move(limit_expression)),
-	      offset_expression(move(offset_expression)) {
-	}
-
-	double limit_percent;
-	idx_t offset_value;
-	unique_ptr<Expression> limit_expression;
-	unique_ptr<Expression> offset_expression;
-
-public:
-	bool IsOrderDependent() const override {
-		return true;
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_vacuum.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalVacuum represents an etension LOAD operation
-class PhysicalLoad : public PhysicalOperator {
-public:
-	explicit PhysicalLoad(unique_ptr<LoadInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::LOAD, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<LoadInfo> info;
-
-public:
-	// Source interface
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/extension_helper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <string>
-
-
-namespace duckdb {
-class DuckDB;
-
-enum class ExtensionLoadResult : uint8_t { LOADED_EXTENSION = 0, EXTENSION_UNKNOWN = 1, NOT_LOADED = 2 };
-
-struct DefaultExtension {
-	const char *name;
-	const char *description;
-	bool statically_loaded;
-};
-
-class ExtensionHelper {
-public:
-	static void LoadAllExtensions(DuckDB &db);
-
-	static ExtensionLoadResult LoadExtension(DuckDB &db, const std::string &extension);
-
-	static void InstallExtension(DatabaseInstance &db, const string &extension, bool force_install);
-	static void LoadExternalExtension(DatabaseInstance &db, const string &extension);
-
-	static string ExtensionDirectory(FileSystem &fs);
-
-	static idx_t DefaultExtensionCount();
-	static DefaultExtension GetDefaultExtension(idx_t index);
-
-private:
-	static const vector<string> PathComponents();
-
-private:
-	static ExtensionLoadResult LoadExtensionInternal(DuckDB &db, const std::string &extension, bool initial_load);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_materialized_collector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class PhysicalMaterializedCollector : public PhysicalResultCollector {
-public:
-	PhysicalMaterializedCollector(PreparedStatementData &data, bool parallel);
-
-	bool parallel;
-
-public:
-	unique_ptr<QueryResult> GetResult(GlobalSinkState &state) override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool ParallelSink() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_pragma.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalPragma represents the PRAGMA operator
-class PhysicalPragma : public PhysicalOperator {
-public:
-	PhysicalPragma(PragmaFunction function_p, PragmaInfo info_p, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::PRAGMA, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      function(move(function_p)), info(move(info_p)) {
-	}
-
-	//! The pragma function to call
-	PragmaFunction function;
-	//! The context of the call
-	PragmaInfo info;
-
-public:
-	// Source interface
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_prepare.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class PhysicalPrepare : public PhysicalOperator {
-public:
-	PhysicalPrepare(string name, shared_ptr<PreparedStatementData> prepared, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::PREPARE, {LogicalType::BOOLEAN}, estimated_cardinality), name(name),
-	      prepared(move(prepared)) {
-	}
-
-	string name;
-	shared_ptr<PreparedStatementData> prepared;
-
-public:
-	// Source interface
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_reservoir_sample.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalReservoirSample represents a sample taken using reservoir sampling, which is a blocking sampling method
-class PhysicalReservoirSample : public PhysicalOperator {
-public:
-	PhysicalReservoirSample(vector<LogicalType> types, unique_ptr<SampleOptions> options, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::RESERVOIR_SAMPLE, move(types), estimated_cardinality),
-	      options(move(options)) {
-	}
-
-	unique_ptr<SampleOptions> options;
-
-public:
-	// Source interface
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	string ParamsToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/reservoir_sample.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class BaseReservoirSampling {
-public:
-	explicit BaseReservoirSampling(int64_t seed);
-	BaseReservoirSampling();
-
-	void InitializeReservoir(idx_t cur_size, idx_t sample_size);
-
-	void SetNextEntry();
-
-	void ReplaceElement();
-
-	//! The random generator
-	RandomEngine random;
-	//! Priority queue of [random element, index] for each of the elements in the sample
-	std::priority_queue<std::pair<double, idx_t>> reservoir_weights;
-	//! The next element to sample
-	idx_t next_index;
-	//! The reservoir threshold of the current min entry
-	double min_threshold;
-	//! The reservoir index of the current min entry
-	idx_t min_entry;
-	//! The current count towards next index (i.e. we will replace an entry in next_index - current_count tuples)
-	idx_t current_count;
-};
-
-class BlockingSample {
-public:
-	explicit BlockingSample(int64_t seed) : base_reservoir_sample(seed), random(base_reservoir_sample.random) {
-	}
-	virtual ~BlockingSample() {
-	}
-
-	//! Add a chunk of data to the sample
-	virtual void AddToReservoir(DataChunk &input) = 0;
-
-	//! Fetches a chunk from the sample. Note that this method is destructive and should only be used after the
-	// sample is completely built.
-	virtual unique_ptr<DataChunk> GetChunk() = 0;
-
-protected:
-	//! The reservoir sampling
-	BaseReservoirSampling base_reservoir_sample;
-	RandomEngine &random;
-};
-
-//! The reservoir sample class maintains a streaming sample of fixed size "sample_count"
-class ReservoirSample : public BlockingSample {
-public:
-	ReservoirSample(Allocator &allocator, idx_t sample_count, int64_t seed);
-
-	//! Add a chunk of data to the sample
-	void AddToReservoir(DataChunk &input) override;
-
-	//! Fetches a chunk from the sample. Note that this method is destructive and should only be used after the
-	//! sample is completely built.
-	unique_ptr<DataChunk> GetChunk() override;
-
-private:
-	//! Replace a single element of the input
-	void ReplaceElement(DataChunk &input, idx_t index_in_chunk);
-
-	//! Fills the reservoir up until sample_count entries, returns how many entries are still required
-	idx_t FillReservoir(DataChunk &input);
-
-private:
-	//! The size of the reservoir sample
-	idx_t sample_count;
-	//! The current reservoir
-	ChunkCollection reservoir;
-};
-
-//! The reservoir sample sample_size class maintains a streaming sample of variable size
-class ReservoirSamplePercentage : public BlockingSample {
-	constexpr static idx_t RESERVOIR_THRESHOLD = 100000;
-
-public:
-	ReservoirSamplePercentage(Allocator &allocator, double percentage, int64_t seed);
-
-	//! Add a chunk of data to the sample
-	void AddToReservoir(DataChunk &input) override;
-
-	//! Fetches a chunk from the sample. Note that this method is destructive and should only be used after the
-	//! sample is completely built.
-	unique_ptr<DataChunk> GetChunk() override;
-
-private:
-	void Finalize();
-
-private:
-	Allocator &allocator;
-	//! The sample_size to sample
-	double sample_percentage;
-	//! The fixed sample size of the sub-reservoirs
-	idx_t reservoir_sample_size;
-	//! The current sample
-	unique_ptr<ReservoirSample> current_sample;
-	//! The set of finished samples of the reservoir sample
-	vector<unique_ptr<ReservoirSample>> finished_samples;
-	//! The amount of tuples that have been processed so far
-	idx_t current_count = 0;
-	//! Whether or not the stream is finalized. The stream is automatically finalized on the first call to GetChunk();
-	bool is_finalized;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalSet represents a SET operation (e.g. SET a = 42)
-class PhysicalSet : public PhysicalOperator {
-public:
-	PhysicalSet(const std::string &name_p, Value value_p, SetScope scope_p, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::SET, {LogicalType::BOOLEAN}, estimated_cardinality), name(name_p),
-	      value(value_p), scope(scope_p) {
-	}
-
-public:
-	// Source interface
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	const std::string name;
-	const Value value;
-	const SetScope scope;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_streaming_sample.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalStreamingSample represents a streaming sample using either system or bernoulli sampling
-class PhysicalStreamingSample : public PhysicalOperator {
-public:
-	PhysicalStreamingSample(vector<LogicalType> types, SampleMethod method, double percentage, int64_t seed,
-	                        idx_t estimated_cardinality);
-
-	SampleMethod method;
-	double percentage;
-	int64_t seed;
-
-public:
-	// Operator interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	string ParamsToString() const override;
-
-private:
-	void SystemSample(DataChunk &input, DataChunk &result, OperatorState &state) const;
-	void BernoulliSample(DataChunk &input, DataChunk &result, OperatorState &state) const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_transaction.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalTransaction represents a transaction operator (e.g. BEGIN or COMMIT)
-class PhysicalTransaction : public PhysicalOperator {
-public:
-	explicit PhysicalTransaction(unique_ptr<TransactionInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::TRANSACTION, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<TransactionInfo> info;
-
-public:
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/helper/physical_vacuum.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalVacuum represents a VACUUM operation (e.g. VACUUM or ANALYZE)
-class PhysicalVacuum : public PhysicalOperator {
-public:
-	explicit PhysicalVacuum(unique_ptr<VacuumInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::VACUUM, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<VacuumInfo> info;
-
-public:
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/perfect_hash_join_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class PhysicalHashJoinState;
-class HashJoinGlobalState;
-class PhysicalHashJoin;
-
-struct PerfectHashJoinStats {
-	Value build_min;
-	Value build_max;
-	Value probe_min;
-	Value probe_max;
-	bool is_build_small = false;
-	bool is_build_dense = false;
-	bool is_probe_in_domain = false;
-	idx_t build_range = 0;
-	idx_t estimated_cardinality = 0;
-};
-
-//! PhysicalHashJoin represents a hash loop join between two tables
-class PerfectHashJoinExecutor {
-	using PerfectHashTable = std::vector<Vector>;
-
-public:
-	explicit PerfectHashJoinExecutor(const PhysicalHashJoin &join, JoinHashTable &ht, PerfectHashJoinStats pjoin_stats);
-
-public:
-	bool CanDoPerfectHashJoin();
-
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context);
-	OperatorResultType ProbePerfectHashTable(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                         OperatorState &state);
-	bool BuildPerfectHashTable(LogicalType &type);
-
-private:
-	void FillSelectionVectorSwitchProbe(Vector &source, SelectionVector &build_sel_vec, SelectionVector &probe_sel_vec,
-	                                    idx_t count, idx_t &probe_sel_count);
-	template <typename T>
-	void TemplatedFillSelectionVectorProbe(Vector &source, SelectionVector &build_sel_vec,
-	                                       SelectionVector &probe_sel_vec, idx_t count, idx_t &prob_sel_count);
-
-	bool FillSelectionVectorSwitchBuild(Vector &source, SelectionVector &sel_vec, SelectionVector &seq_sel_vec,
-	                                    idx_t count);
-	template <typename T>
-	bool TemplatedFillSelectionVectorBuild(Vector &source, SelectionVector &sel_vec, SelectionVector &seq_sel_vec,
-	                                       idx_t count);
-	bool FullScanHashTable(JoinHTScanState &state, LogicalType &key_type);
-
-private:
-	const PhysicalHashJoin &join;
-	JoinHashTable &ht;
-	//! Columnar perfect hash table
-	PerfectHashTable perfect_hash_table;
-	//! Build and probe statistics
-	PerfectHashJoinStats perfect_join_statistics;
-	//! Stores the occurences of each value in the build side
-	unique_ptr<bool[]> bitmap_build_idx;
-	//! Stores the number of unique keys in the build side
-	idx_t unique_keys = 0;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_hash_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_comparison_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalJoin represents the base class of the join operators
-class PhysicalJoin : public PhysicalOperator {
-public:
-	PhysicalJoin(LogicalOperator &op, PhysicalOperatorType type, JoinType join_type, idx_t estimated_cardinality);
-
-	JoinType join_type;
-
-public:
-	bool EmptyResultIfRHSIsEmpty() const;
-
-	static void ConstructSemiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]);
-	static void ConstructAntiJoinResult(DataChunk &left, DataChunk &result, bool found_match[]);
-	static void ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &left, DataChunk &result, bool found_match[],
-	                                    bool has_null);
-	static void ConstructLeftJoinResult(DataChunk &left, DataChunk &result, bool found_match[]);
-
-public:
-	static void BuildJoinPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state,
-	                               PhysicalOperator &op);
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-	vector<const PhysicalOperator *> GetSources() const override;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class ChunkCollection;
-
-//! PhysicalJoin represents the base class of the join operators
-class PhysicalComparisonJoin : public PhysicalJoin {
-public:
-	PhysicalComparisonJoin(LogicalOperator &op, PhysicalOperatorType type, vector<JoinCondition> cond,
-	                       JoinType join_type, idx_t estimated_cardinality);
-
-	vector<JoinCondition> conditions;
-
-public:
-	string ParamsToString() const override;
-
-	//! Construct the join result of a join with an empty RHS
-	static void ConstructEmptyJoinResult(JoinType type, bool has_null, DataChunk &input, DataChunk &result);
-	//! Construct the remainder of a Full Outer Join based on which tuples in the RHS found no match
-	static void ConstructFullOuterJoinResult(bool *found_match, ChunkCollection &input, DataChunk &result,
-	                                         idx_t &scan_position);
-};
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-//! PhysicalHashJoin represents a hash loop join between two tables
-class PhysicalHashJoin : public PhysicalComparisonJoin {
-public:
-	PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                 vector<JoinCondition> cond, JoinType join_type, const vector<idx_t> &left_projection_map,
-	                 const vector<idx_t> &right_projection_map, vector<LogicalType> delim_types,
-	                 idx_t estimated_cardinality, PerfectHashJoinStats perfect_join_stats);
-	PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                 vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality,
-	                 PerfectHashJoinStats join_state);
-
-	vector<idx_t> right_projection_map;
-	//! The types of the keys
-	vector<LogicalType> condition_types;
-	//! The types of all conditions
-	vector<LogicalType> build_types;
-	//! Duplicate eliminated types; only used for delim_joins (i.e. correlated subqueries)
-	vector<LogicalType> delim_types;
-	// used in perfect hash join
-	PerfectHashJoinStats perfect_join_statistics;
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	bool RequiresCache() const override {
-		return true;
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-	bool IsSource() const override {
-		return IsRightOuterJoin(join_type);
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_blockwise_nl_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalBlockwiseNLJoin represents a nested loop join between two tables on arbitrary expressions. This is different
-//! from the PhysicalNestedLoopJoin in that it does not require expressions to be comparisons between the LHS and the
-//! RHS.
-class PhysicalBlockwiseNLJoin : public PhysicalJoin {
-public:
-	PhysicalBlockwiseNLJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                        unique_ptr<Expression> condition, JoinType join_type, idx_t estimated_cardinality);
-
-	unique_ptr<Expression> condition;
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	bool RequiresCache() const override {
-		return true;
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-	bool IsSource() const override {
-		return IsRightOuterJoin(join_type);
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	string ParamsToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_cross_product.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-//! PhysicalCrossProduct represents a cross product between two tables
-class PhysicalCrossProduct : public PhysicalOperator {
-public:
-	PhysicalCrossProduct(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
-	                     unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality);
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	bool RequiresCache() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-	vector<const PhysicalOperator *> GetSources() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_chunk_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! The PhysicalChunkCollectionScan scans a Chunk Collection
-class PhysicalChunkScan : public PhysicalOperator {
-public:
-	PhysicalChunkScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality)
-	    : PhysicalOperator(op_type, move(types), estimated_cardinality), collection(nullptr) {
-	}
-
-	// the chunk collection to scan
-	ChunkCollection *collection;
-	//! Owned chunk collection, if any
-	unique_ptr<ChunkCollection> owned_collection;
-
-public:
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/set/physical_recursive_cte.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class Pipeline;
-class RecursiveCTEState;
-
-class PhysicalRecursiveCTE : public PhysicalOperator {
-public:
-	PhysicalRecursiveCTE(vector<LogicalType> types, bool union_all, unique_ptr<PhysicalOperator> top,
-	                     unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality);
-	~PhysicalRecursiveCTE() override;
-
-	bool union_all;
-	std::shared_ptr<ChunkCollection> working_table;
-	vector<shared_ptr<Pipeline>> pipelines;
-
-public:
-	// Source interface
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-
-	vector<const PhysicalOperator *> GetSources() const override;
-
-private:
-	//! Probe Hash Table and eliminate duplicate rows
-	idx_t ProbeHT(DataChunk &chunk, RecursiveCTEState &state) const;
-
-	void ExecuteRecursivePipelines(ExecutionContext &context) const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/distributive_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct BitAndFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitOrFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitXorFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CountStarFun {
-	static AggregateFunction GetFunction();
-
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CountFun {
-	static AggregateFunction GetFunction();
-
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BoolAndFun {
-	static AggregateFunction GetFunction();
-
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BoolOrFun {
-	static AggregateFunction GetFunction();
-
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ProductFun {
-	static AggregateFunction GetFunction();
-
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ApproxCountDistinctFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ArgMinFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ArgMaxFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct FirstFun {
-	static AggregateFunction GetFunction(const LogicalType &type);
-
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MaxFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MinFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MaxByFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MinByFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SumFun {
-	static AggregateFunction GetSumAggregate(PhysicalType type);
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SkewFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct KurtosisFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct EntropyFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StringAggFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct GlobalSortState;
-
-//! PhysicalRangeJoin represents one or more inequality range join predicates between
-//! two tables
-class PhysicalRangeJoin : public PhysicalComparisonJoin {
-public:
-	class LocalSortedTable {
-	public:
-		LocalSortedTable(Allocator &allocator, const PhysicalRangeJoin &op, const idx_t child);
-
-		void Sink(DataChunk &input, GlobalSortState &global_sort_state);
-
-		inline void Sort(GlobalSortState &global_sort_state) {
-			local_sort_state.Sort(global_sort_state, true);
-		}
-
-		//! The hosting operator
-		const PhysicalRangeJoin &op;
-		//! The local sort state
-		LocalSortState local_sort_state;
-		//! Local copy of the sorting expression executor
-		ExpressionExecutor executor;
-		//! Holds a vector of incoming sorting columns
-		DataChunk keys;
-		//! The number of NULL values
-		idx_t has_null;
-		//! The total number of rows
-		idx_t count;
-
-	private:
-		// Merge the NULLs of all non-DISTINCT predicates into the primary so they sort to the end.
-		idx_t MergeNulls(const vector<JoinCondition> &conditions);
-	};
-
-	class GlobalSortedTable {
-	public:
-		GlobalSortedTable(ClientContext &context, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout);
-
-		inline idx_t Count() const {
-			return count;
-		}
-
-		inline idx_t BlockCount() const {
-			if (global_sort_state.sorted_blocks.empty()) {
-				return 0;
-			}
-			D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
-			return global_sort_state.sorted_blocks[0]->radix_sorting_data.size();
-		}
-
-		inline idx_t BlockSize(idx_t i) const {
-			return global_sort_state.sorted_blocks[0]->radix_sorting_data[i].count;
-		}
-
-		void Combine(LocalSortedTable &ltable);
-		void IntializeMatches();
-		void Print();
-
-		//! Starts the sorting process.
-		void Finalize(Pipeline &pipeline, Event &event);
-		//! Schedules tasks to merge sort the current child's data during a Finalize phase
-		void ScheduleMergeTasks(Pipeline &pipeline, Event &event);
-
-		GlobalSortState global_sort_state;
-		//! Whether or not the RHS has NULL values
-		atomic<idx_t> has_null;
-		//! The total number of rows in the RHS
-		atomic<idx_t> count;
-		//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
-		unique_ptr<bool[]> found_match;
-		//! Memory usage per thread
-		idx_t memory_per_thread;
-	};
-
-public:
-	PhysicalRangeJoin(LogicalOperator &op, PhysicalOperatorType type, unique_ptr<PhysicalOperator> left,
-	                  unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-	                  idx_t estimated_cardinality);
-
-public:
-	// Gather the result values and slice the payload columns to those values.
-	static void SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
-	                               const SelectionVector &result, const idx_t result_count, const idx_t left_cols = 0);
-	// Apply a tail condition to the current selection
-	static idx_t SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
-	                            const SelectionVector *sel, idx_t count, SelectionVector *true_sel);
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//! PhysicalIEJoin represents a two inequality range join between
-//! two tables
-class PhysicalIEJoin : public PhysicalRangeJoin {
-public:
-	PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	               vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);
-
-	vector<LogicalType> join_key_types;
-	vector<vector<BoundOrderByNode>> lhs_orders;
-	vector<vector<BoundOrderByNode>> rhs_orders;
-
-public:
-	// Operator Interface
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-public:
-	// Source interface
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-
-private:
-	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
-	void ResolveComplexJoin(ExecutionContext &context, DataChunk &result, LocalSourceState &state) const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_index_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalIndexJoin represents an index join between two tables
-class PhysicalIndexJoin : public PhysicalOperator {
-public:
-	PhysicalIndexJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                  vector<JoinCondition> cond, JoinType join_type, const vector<idx_t> &left_projection_map,
-	                  vector<idx_t> right_projection_map, vector<column_t> column_ids, Index *index, bool lhs_first,
-	                  idx_t estimated_cardinality);
-
-	//! Columns from RHS used in the query
-	vector<column_t> column_ids;
-	//! Columns to be fetched
-	vector<column_t> fetch_ids;
-	//! Types of fetch columns
-	vector<LogicalType> fetch_types;
-	//! Columns indexed by index
-	unordered_set<column_t> index_ids;
-	//! Projected ids from LHS
-	vector<column_t> left_projection_map;
-	//! Projected ids from RHS
-	vector<column_t> right_projection_map;
-	//! The types of the keys
-	vector<LogicalType> condition_types;
-	//! The types of all conditions
-	vector<LogicalType> build_types;
-	//! Index used for join
-	Index *index;
-
-	vector<JoinCondition> conditions;
-
-	JoinType join_type;
-	//! In case we swap rhs with lhs we need to output columns related to rhs first.
-	bool lhs_first = true;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	bool RequiresCache() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-	vector<const PhysicalOperator *> GetSources() const override;
-
-private:
-	void GetRHSMatches(ExecutionContext &context, DataChunk &input, OperatorState &state_p) const;
-	//! Fills result chunk
-	void Output(ExecutionContext &context, DataChunk &input, DataChunk &chunk, OperatorState &state_p) const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_table_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a scan of a base table
-class PhysicalTableScan : public PhysicalOperator {
-public:
-	PhysicalTableScan(vector<LogicalType> types, TableFunction function, unique_ptr<FunctionData> bind_data,
-	                  vector<column_t> column_ids, vector<string> names, unique_ptr<TableFilterSet> table_filters,
-	                  idx_t estimated_cardinality);
-
-	//! The table function
-	TableFunction function;
-	//! Bind data of the function
-	unique_ptr<FunctionData> bind_data;
-	//! The projected-out column ids
-	vector<column_t> column_ids;
-	//! The names of the columns
-	vector<string> names;
-	//! The table filters
-	unique_ptr<TableFilterSet> table_filters;
-
-public:
-	string GetName() const override;
-	string ParamsToString() const override;
-
-	bool Equals(const PhysicalOperator &other) const override;
-
-public:
-	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                 GlobalSourceState &gstate) const override;
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-	idx_t GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	                    LocalSourceState &lstate) const override;
-
-	bool ParallelSource() const override {
-		return true;
-	}
-
-	bool SupportsBatchIndex() const override {
-		return function.get_batch_index != nullptr;
-	}
-
-	double GetProgress(ClientContext &context, GlobalSourceState &gstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/table_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class TableCatalogEntry;
-
-struct TableScanBindData : public TableFunctionData {
-	explicit TableScanBindData(TableCatalogEntry *table) : table(table), is_index_scan(false), chunk_count(0) {
-	}
-
-	//! The table to scan
-	TableCatalogEntry *table;
-
-	//! Whether or not the table scan is an index scan
-	bool is_index_scan;
-	//! The row ids to fetch (in case of an index scan)
-	vector<row_t> result_ids;
-
-	//! How many chunks we already scanned
-	atomic<idx_t> chunk_count;
-
-public:
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const TableScanBindData &)other_p;
-		return other.table == table && result_ids == other.result_ids;
-	}
-};
-
-//! The table scan function represents a sequential scan over one of DuckDB's base tables.
-struct TableScanFunction {
-	static TableFunction GetFunction();
-	static TableCatalogEntry *GetTableEntry(const TableFunction &function, const FunctionData *bind_data);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_nested_loop_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-idx_t nested_loop_join(ExpressionType op, Vector &left, Vector &right, idx_t &lpos, idx_t &rpos, sel_t lvector[],
-                       sel_t rvector[]);
-idx_t nested_loop_comparison(ExpressionType op, Vector &left, Vector &right, sel_t lvector[], sel_t rvector[],
-                             idx_t count);
-
-//! PhysicalNestedLoopJoin represents a nested loop join between two tables
-class PhysicalNestedLoopJoin : public PhysicalComparisonJoin {
-public:
-	PhysicalNestedLoopJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
-	                       vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	bool RequiresCache() const override {
-		return true;
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-	bool IsSource() const override {
-		return IsRightOuterJoin(join_type);
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	static bool IsSupported(const vector<JoinCondition> &conditions);
-
-private:
-	// resolve joins that output max N elements (SEMI, ANTI, MARK)
-	void ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk, OperatorState &state) const;
-	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
-	OperatorResultType ResolveComplexJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                      OperatorState &state) const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class MergeJoinGlobalState;
-
-//! PhysicalPiecewiseMergeJoin represents a piecewise merge loop join between
-//! two tables
-class PhysicalPiecewiseMergeJoin : public PhysicalRangeJoin {
-public:
-	PhysicalPiecewiseMergeJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
-	                           unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
-	                           idx_t estimated_cardinality);
-
-	vector<LogicalType> join_key_types;
-	vector<BoundOrderByNode> lhs_orders;
-	vector<BoundOrderByNode> rhs_orders;
-
-public:
-	// Operator Interface
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	bool RequiresCache() const override {
-		return true;
-	}
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-	bool IsSource() const override {
-		return IsRightOuterJoin(join_type);
-	}
-	bool ParallelSource() const override {
-		return true;
-	}
-
-public:
-	// Sink Interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-private:
-	// resolve joins that output max N elements (SEMI, ANTI, MARK)
-	void ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk, OperatorState &state) const;
-	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
-	OperatorResultType ResolveComplexJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                      OperatorState &state) const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/order/physical_order.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class OrderGlobalState;
-
-//! Physically re-orders the input data
-class PhysicalOrder : public PhysicalOperator {
-public:
-	PhysicalOrder(vector<LogicalType> types, vector<BoundOrderByNode> orders, idx_t estimated_cardinality);
-
-	//! Input data
-	vector<BoundOrderByNode> orders;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	string ParamsToString() const override;
-
-	//! Schedules tasks to merge the data during the Finalize phase
-	static void ScheduleMergeTasks(Pipeline &pipeline, Event &event, OrderGlobalState &state);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/order/physical_top_n.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a physical ordering of the data. Note that this will not change
-//! the data but only add a selection vector.
-class PhysicalTopN : public PhysicalOperator {
-public:
-	PhysicalTopN(vector<LogicalType> types, vector<BoundOrderByNode> orders, idx_t limit, idx_t offset,
-	             idx_t estimated_cardinality);
-
-	vector<BoundOrderByNode> orders;
-	idx_t limit;
-	idx_t offset;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-
-	string ParamsToString() const override;
-
-private:
-	unique_ptr<idx_t[]> ComputeTopN(ChunkCollection &big_data, idx_t &heap_size);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_copy_to_file.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Copy the contents of a query into a table
-class PhysicalCopyToFile : public PhysicalOperator {
-public:
-	PhysicalCopyToFile(vector<LogicalType> types, CopyFunction function, unique_ptr<FunctionData> bind_data,
-	                   idx_t estimated_cardinality);
-
-	CopyFunction function;
-	unique_ptr<FunctionData> bind_data;
-	string file_path;
-	bool use_tmp_file;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
-	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_delete.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class DataTable;
-
-//! Physically delete data from a table
-class PhysicalDelete : public PhysicalOperator {
-public:
-	PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, idx_t row_id_index,
-	               idx_t estimated_cardinality, bool return_chunk)
-	    : PhysicalOperator(PhysicalOperatorType::DELETE_OPERATOR, move(types), estimated_cardinality),
-	      tableref(tableref), table(table), row_id_index(row_id_index), return_chunk(return_chunk) {
-	}
-
-	TableCatalogEntry &tableref;
-	DataTable &table;
-	idx_t row_id_index;
-	bool return_chunk;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_export.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <utility>
-
-
-
-
-
-
-namespace duckdb {
-//! Parse a file from disk using a specified copy function and return the set of chunks retrieved from the file
-class PhysicalExport : public PhysicalOperator {
-public:
-	PhysicalExport(vector<LogicalType> types, CopyFunction function, unique_ptr<CopyInfo> info,
-	               idx_t estimated_cardinality, BoundExportData exported_tables)
-	    : PhysicalOperator(PhysicalOperatorType::EXPORT, move(types), estimated_cardinality),
-	      function(std::move(function)), info(move(info)), exported_tables(move(exported_tables)) {
-	}
-
-	//! The copy function to use to read the file
-	CopyFunction function;
-	//! The binding info containing the set of options for reading the file
-	unique_ptr<CopyInfo> info;
-	//! The table info for each table that will be exported
-	BoundExportData exported_tables;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-
-	bool ParallelSink() const override {
-		return true;
-	}
-	bool IsSink() const override {
-		return true;
-	}
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-	vector<const PhysicalOperator *> GetSources() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_insert.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Physically insert a set of data into a table
-class PhysicalInsert : public PhysicalOperator {
-public:
-	PhysicalInsert(vector<LogicalType> types, TableCatalogEntry *table, vector<idx_t> column_index_map,
-	               vector<unique_ptr<Expression>> bound_defaults, idx_t estimated_cardinality, bool return_chunk);
-
-	//! The map from insert column index to table column index
-	vector<idx_t> column_index_map;
-	//! The table to insert into
-	TableCatalogEntry *table;
-	//! The default expressions of the columns for which no value is provided
-	vector<unique_ptr<Expression>> bound_defaults;
-	//! If the returning statement is present, return the whole chunk
-	bool return_chunk;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-
-	bool ParallelSink() const override {
-		return false;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/physical_update.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class DataTable;
-
-//! Physically update data in a table
-class PhysicalUpdate : public PhysicalOperator {
-public:
-	PhysicalUpdate(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, vector<column_t> columns,
-	               vector<unique_ptr<Expression>> expressions, vector<unique_ptr<Expression>> bound_defaults,
-	               idx_t estimated_cardinality, bool return_chunk)
-	    : PhysicalOperator(PhysicalOperatorType::UPDATE, move(types), estimated_cardinality), tableref(tableref),
-	      table(table), columns(std::move(columns)), expressions(move(expressions)),
-	      bound_defaults(move(bound_defaults)), return_chunk(return_chunk) {
-	}
-
-	TableCatalogEntry &tableref;
-	DataTable &table;
-	vector<column_t> columns;
-	vector<unique_ptr<Expression>> expressions;
-	vector<unique_ptr<Expression>> bound_defaults;
-	bool update_is_del_and_insert;
-	//! If the returning statement is present, return the whole chunk
-	bool return_chunk;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	// Sink interface
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/projection/physical_projection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class PhysicalProjection : public PhysicalOperator {
-public:
-	PhysicalProjection(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-	                   idx_t estimated_cardinality);
-
-	vector<unique_ptr<Expression>> select_list;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-	string ParamsToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/projection/physical_unnest.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalWindow implements window functions
-class PhysicalTableInOutFunction : public PhysicalOperator {
-public:
-	PhysicalTableInOutFunction(vector<LogicalType> types, TableFunction function_p,
-	                           unique_ptr<FunctionData> bind_data_p, vector<column_t> column_ids_p,
-	                           idx_t estimated_cardinality);
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-private:
-	//! The table function
-	TableFunction function;
-	//! Bind data of the function
-	unique_ptr<FunctionData> bind_data;
-
-	vector<column_t> column_ids;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/projection/physical_unnest.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalWindow implements window functions
-class PhysicalUnnest : public PhysicalOperator {
-public:
-	PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality,
-	               PhysicalOperatorType type = PhysicalOperatorType::UNNEST);
-
-	//! The projection list of the UNNEST
-	vector<unique_ptr<Expression>> select_list;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-public:
-	static unique_ptr<OperatorState> GetState(ExecutionContext &context,
-	                                          const vector<unique_ptr<Expression>> &select_list);
-	static OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                          OperatorState &state, const vector<unique_ptr<Expression>> &select_list,
-	                                          bool include_input = true);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_dummy_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class PhysicalDummyScan : public PhysicalOperator {
-public:
-	explicit PhysicalDummyScan(vector<LogicalType> types, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::DUMMY_SCAN, move(types), estimated_cardinality) {
-	}
-
-public:
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_empty_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class PhysicalEmptyResult : public PhysicalOperator {
-public:
-	explicit PhysicalEmptyResult(vector<LogicalType> types, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::EMPTY_RESULT, move(types), estimated_cardinality) {
-	}
-
-public:
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/scan/physical_expression_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The PhysicalExpressionScan scans a set of expressions
-class PhysicalExpressionScan : public PhysicalOperator {
-public:
-	PhysicalExpressionScan(vector<LogicalType> types, vector<vector<unique_ptr<Expression>>> expressions,
-	                       idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::EXPRESSION_SCAN, move(types), estimated_cardinality),
-	      expressions(move(expressions)) {
-	}
-
-	//! The set of expressions to scan
-	vector<vector<unique_ptr<Expression>>> expressions;
-
-public:
-	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const override;
-	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                           GlobalOperatorState &gstate, OperatorState &state) const override;
-
-	bool ParallelOperator() const override {
-		return true;
-	}
-
-public:
-	bool IsFoldable() const;
-	void EvaluateExpression(Allocator &allocator, idx_t expression_idx, DataChunk *child_chunk,
-	                        DataChunk &result) const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_alter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalAlter represents an ALTER TABLE command
-class PhysicalAlter : public PhysicalOperator {
-public:
-	explicit PhysicalAlter(unique_ptr<AlterInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::ALTER, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<AlterInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalCreateFunction represents a CREATE FUNCTION command
-class PhysicalCreateFunction : public PhysicalOperator {
-public:
-	explicit PhysicalCreateFunction(unique_ptr<CreateMacroInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_MACRO, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<CreateMacroInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-#include <fstream>
-
-namespace duckdb {
-
-//! Physically CREATE INDEX statement
-class PhysicalCreateIndex : public PhysicalOperator {
-public:
-	PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table, vector<column_t> column_ids,
-	                    vector<unique_ptr<Expression>> expressions, unique_ptr<CreateIndexInfo> info,
-	                    vector<unique_ptr<Expression>> unbinded_expressions, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality), table(table),
-	      column_ids(column_ids), expressions(move(expressions)), info(std::move(info)),
-	      unbound_expressions(move(unbinded_expressions)) {
-	}
-
-	//! The table to create the index for
-	TableCatalogEntry &table;
-	//! The list of column IDs required for the index
-	vector<column_t> column_ids;
-	//! Set of expressions to index by
-	vector<unique_ptr<Expression>> expressions;
-	//! Info for index creation
-	unique_ptr<CreateIndexInfo> info;
-	//! Unbinded expressions to be used in the optimizer
-	vector<unique_ptr<Expression>> unbound_expressions;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_schema.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalCreateSchema represents a CREATE SCHEMA command
-class PhysicalCreateSchema : public PhysicalOperator {
-public:
-	explicit PhysicalCreateSchema(unique_ptr<CreateSchemaInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_SCHEMA, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<CreateSchemaInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_sequence.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalCreateSequence represents a CREATE SEQUENCE command
-class PhysicalCreateSequence : public PhysicalOperator {
-public:
-	explicit PhysicalCreateSequence(unique_ptr<CreateSequenceInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_SEQUENCE, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<CreateSequenceInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_table.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Physically CREATE TABLE statement
-class PhysicalCreateTable : public PhysicalOperator {
-public:
-	PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info,
-	                    idx_t estimated_cardinality);
-
-	//! Schema to insert to
-	SchemaCatalogEntry *schema;
-	//! Table name to create
-	unique_ptr<BoundCreateTableInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_table_as.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Physically CREATE TABLE AS statement
-class PhysicalCreateTableAs : public PhysicalOperator {
-public:
-	PhysicalCreateTableAs(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info,
-	                      idx_t estimated_cardinality);
-
-	//! Schema to insert to
-	SchemaCatalogEntry *schema;
-	//! Table name to create
-	unique_ptr<BoundCreateTableInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-
-public:
-	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
-
-	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-	                    DataChunk &input) const override;
-
-	bool IsSink() const override {
-		return true;
-	}
-	bool ParallelSink() const override {
-		return true;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalCreateType represents a CREATE TYPE command
-class PhysicalCreateType : public PhysicalOperator {
-public:
-	explicit PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality);
-
-	unique_ptr<CreateTypeInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_create_view.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalCreateView represents a CREATE VIEW command
-class PhysicalCreateView : public PhysicalOperator {
-public:
-	explicit PhysicalCreateView(unique_ptr<CreateViewInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_VIEW, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<CreateViewInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/schema/physical_drop.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! PhysicalDrop represents a DROP [...] command
-class PhysicalDrop : public PhysicalOperator {
-public:
-	explicit PhysicalDrop(unique_ptr<DropInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::DROP, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
-	}
-
-	unique_ptr<DropInfo> info;
-
-public:
-	// Source interface
-	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
-	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	             LocalSourceState &lstate) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/set/physical_union.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class PhysicalUnion : public PhysicalOperator {
-public:
-	PhysicalUnion(vector<LogicalType> types, unique_ptr<PhysicalOperator> top, unique_ptr<PhysicalOperator> bottom,
-	              idx_t estimated_cardinality);
-
-public:
-	void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state) override;
-	vector<const PhysicalOperator *> GetSources() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/physical_plan_generator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_limit_percent.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalLimitPercent represents a LIMIT PERCENT clause
-class LogicalLimitPercent : public LogicalOperator {
-public:
-	LogicalLimitPercent(double limit_percent, int64_t offset_val, unique_ptr<Expression> limit,
-	                    unique_ptr<Expression> offset)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT_PERCENT), limit_percent(limit_percent),
-	      offset_val(offset_val), limit(move(limit)), offset(move(offset)) {
-	}
-
-	//! Limit percent and offset values in case they are constants, used in optimizations.
-	double limit_percent;
-	int64_t offset_val;
-	//! The maximum amount of elements to emit
-	unique_ptr<Expression> limit;
-	//! The offset from the start to begin emitting elements
-	unique_ptr<Expression> offset;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-
-//! The physical plan generator generates a physical execution plan from a
-//! logical query plan
-class PhysicalPlanGenerator {
-public:
-	explicit PhysicalPlanGenerator(ClientContext &context) : context(context) {
-	}
-
-	unordered_set<CatalogEntry *> dependencies;
-	//! Recursive CTEs require at least one ChunkScan, referencing the working_table.
-	//! This data structure is used to establish it.
-	unordered_map<idx_t, std::shared_ptr<ChunkCollection>> rec_ctes;
-
-public:
-	//! Creates a plan from the logical operator. This involves resolving column bindings and generating physical
-	//! operator nodes.
-	unique_ptr<PhysicalOperator> CreatePlan(unique_ptr<LogicalOperator> logical);
-
-protected:
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalOperator &op);
-
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalAggregate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalAnyJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalChunkGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalComparisonJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateTable &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateIndex &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCrossProduct &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelete &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDistinct &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDummyScan &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalEmptyResult &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExpressionGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExport &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalFilter &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalLimit &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalLimitPercent &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalOrder &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalTopN &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalProjection &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalInsert &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCopyToFile &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExplain &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSetOperation &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalUpdate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalPrepare &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalWindow &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExecute &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalPragma &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSample &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalShow &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSimple &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalUnnest &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalRecursiveCTE &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCTERef &op);
-
-	unique_ptr<PhysicalOperator> CreateDistinctOn(unique_ptr<PhysicalOperator> child,
-	                                              vector<unique_ptr<Expression>> distinct_targets);
-
-	unique_ptr<PhysicalOperator> ExtractAggregateExpressions(unique_ptr<PhysicalOperator> child,
-	                                                         vector<unique_ptr<Expression>> &expressions,
-	                                                         vector<unique_ptr<Expression>> &groups);
-
-private:
-	ClientContext &context;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_aggregate.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalAggregate represents an aggregate operation with (optional) GROUP BY
-//! operator.
-class LogicalAggregate : public LogicalOperator {
-public:
-	LogicalAggregate(idx_t group_index, idx_t aggregate_index, vector<unique_ptr<Expression>> select_list);
-
-	//! The table index for the groups of the LogicalAggregate
-	idx_t group_index;
-	//! The table index for the aggregates of the LogicalAggregate
-	idx_t aggregate_index;
-	//! The table index for the GROUPING function calls of the LogicalAggregate
-	idx_t groupings_index;
-	//! The set of groups (optional).
-	vector<unique_ptr<Expression>> groups;
-	//! The set of grouping sets (optional).
-	vector<GroupingSet> grouping_sets;
-	//! The list of grouping function calls (optional)
-	vector<vector<idx_t>> grouping_functions;
-	//! Group statistics (optional)
-	vector<unique_ptr<BaseStatistics>> group_stats;
-
-public:
-	string ParamsToString() const override;
-
-	vector<ColumnBinding> GetColumnBindings() override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_any_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalAnyJoin represents a join with an arbitrary expression as JoinCondition
-class LogicalAnyJoin : public LogicalJoin {
-public:
-	explicit LogicalAnyJoin(JoinType type);
-
-	//! The JoinCondition on which this join is performed
-	unique_ptr<Expression> condition;
-
-public:
-	string ParamsToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_chunk_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalChunkGet represents a scan operation from a ChunkCollection
-class LogicalChunkGet : public LogicalOperator {
-public:
-	LogicalChunkGet(idx_t table_index, vector<LogicalType> types, unique_ptr<ChunkCollection> collection)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index),
-	      collection(move(collection)) {
-		D_ASSERT(types.size() > 0);
-		chunk_types = types;
-	}
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The types of the chunk
-	vector<LogicalType> chunk_types;
-	//! The chunk collection to scan
-	unique_ptr<ChunkCollection> collection;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, chunk_types.size());
-	}
-
-protected:
-	void ResolveTypes() override {
-		// types are resolved in the constructor
-		this->types = chunk_types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_iterator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-class BoundQueryNode;
-class BoundTableRef;
-
-class ExpressionIterator {
-public:
-	static void EnumerateChildren(const Expression &expression,
-	                              const std::function<void(const Expression &child)> &callback);
-	static void EnumerateChildren(Expression &expression, const std::function<void(Expression &child)> &callback);
-	static void EnumerateChildren(Expression &expression,
-	                              const std::function<void(unique_ptr<Expression> &child)> &callback);
-
-	static void EnumerateExpression(unique_ptr<Expression> &expr,
-	                                const std::function<void(Expression &child)> &callback);
-
-	static void EnumerateTableRefChildren(BoundTableRef &ref, const std::function<void(Expression &child)> &callback);
-	static void EnumerateQueryNodeChildren(BoundQueryNode &node,
-	                                       const std::function<void(Expression &child)> &callback);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_copy_to_file.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class LogicalCopyToFile : public LogicalOperator {
-public:
-	LogicalCopyToFile(CopyFunction function, unique_ptr<FunctionData> bind_data)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_COPY_TO_FILE), function(function), bind_data(move(bind_data)) {
-	}
-	CopyFunction function;
-	unique_ptr<FunctionData> bind_data;
-	std::string file_path;
-	bool use_tmp_file;
-	bool is_file_and_exists;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_create.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalCreate represents a CREATE operator
-class LogicalCreate : public LogicalOperator {
-public:
-	LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema = nullptr)
-	    : LogicalOperator(type), schema(schema), info(move(info)) {
-	}
-
-	SchemaCatalogEntry *schema;
-	unique_ptr<CreateInfo> info;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_create_table.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class LogicalCreateTable : public LogicalOperator {
-public:
-	LogicalCreateTable(SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(move(info)) {
-	}
-
-	//! Schema to insert to
-	SchemaCatalogEntry *schema;
-	//! Create Table information
-	unique_ptr<BoundCreateTableInfo> info;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_cross_product.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalCrossProduct represents a cross product between two relations
-class LogicalCrossProduct : public LogicalOperator {
-public:
-	LogicalCrossProduct();
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_delete.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class LogicalDelete : public LogicalOperator {
-public:
-	explicit LogicalDelete(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table), table_index(0), return_chunk(false) {
-	}
-
-	TableCatalogEntry *table;
-	idx_t table_index;
-	bool return_chunk;
-
-protected:
-	vector<ColumnBinding> GetColumnBindings() override {
-		if (return_chunk) {
-			return GenerateColumnBindings(table_index, table->columns.size());
-		}
-		return {ColumnBinding(0, 0)};
-	}
-
-	void ResolveTypes() override {
-		if (return_chunk) {
-			types = table->GetTypes();
-		} else {
-			types.emplace_back(LogicalType::BIGINT);
-		}
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_delim_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalDelimGet represents a duplicate eliminated scan belonging to a DelimJoin
-class LogicalDelimGet : public LogicalOperator {
-public:
-	LogicalDelimGet(idx_t table_index, vector<LogicalType> types)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELIM_GET), table_index(table_index) {
-		D_ASSERT(types.size() > 0);
-		chunk_types = types;
-	}
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The types of the chunk
-	vector<LogicalType> chunk_types;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, chunk_types.size());
-	}
-
-protected:
-	void ResolveTypes() override {
-		// types are resolved in the constructor
-		this->types = chunk_types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_distinct.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalDistinct filters duplicate entries from its child operator
-class LogicalDistinct : public LogicalOperator {
-public:
-	LogicalDistinct() : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT) {
-	}
-	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_targets(move(targets)) {
-	}
-	//! The set of distinct targets (optional).
-	vector<unique_ptr<Expression>> distinct_targets;
-
-public:
-	string ParamsToString() const override;
-
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_dummy_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalDummyScan represents a dummy scan returning a single row
-class LogicalDummyScan : public LogicalOperator {
-public:
-	explicit LogicalDummyScan(idx_t table_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DUMMY_SCAN), table_index(table_index) {
-	}
-
-	idx_t table_index;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return {ColumnBinding(table_index, 0)};
-	}
-
-	idx_t EstimateCardinality(ClientContext &context) override {
-		return 1;
-	}
-
-protected:
-	void ResolveTypes() override {
-		if (types.size() == 0) {
-			types.emplace_back(LogicalType::INTEGER);
-		}
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_empty_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalEmptyResult returns an empty result. This is created by the optimizer if it can reason that ceratin parts of
-//! the tree will always return an empty result.
-class LogicalEmptyResult : public LogicalOperator {
-public:
-	explicit LogicalEmptyResult(unique_ptr<LogicalOperator> op);
-
-	//! The set of return types of the empty result
-	vector<LogicalType> return_types;
-	//! The columns that would be bound at this location (if the subtree was not optimized away)
-	vector<ColumnBinding> bindings;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return bindings;
-	}
-
-protected:
-	void ResolveTypes() override {
-		this->types = return_types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_execute.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class LogicalExecute : public LogicalOperator {
-public:
-	explicit LogicalExecute(shared_ptr<PreparedStatementData> prepared_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXECUTE), prepared(move(prepared_p)) {
-		D_ASSERT(prepared);
-		types = prepared->types;
-	}
-
-	shared_ptr<PreparedStatementData> prepared;
-
-protected:
-	void ResolveTypes() override {
-		// already resolved
-	}
-	vector<ColumnBinding> GetColumnBindings() override {
-		vector<ColumnBinding> bindings;
-		for (idx_t i = 0; i < types.size(); i++) {
-			bindings.push_back(ColumnBinding(0, i));
-		}
-		return bindings;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_explain.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/explain_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-enum class ExplainType : uint8_t { EXPLAIN_STANDARD, EXPLAIN_ANALYZE };
-
-class ExplainStatement : public SQLStatement {
-public:
-	explicit ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type = ExplainType::EXPLAIN_STANDARD);
-
-	unique_ptr<SQLStatement> stmt;
-	ExplainType explain_type;
-
-protected:
-	ExplainStatement(const ExplainStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class LogicalExplain : public LogicalOperator {
-public:
-	LogicalExplain(unique_ptr<LogicalOperator> plan, ExplainType explain_type)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type) {
-		children.push_back(move(plan));
-	}
-
-	ExplainType explain_type;
-	string physical_plan;
-	string logical_plan_unopt;
-	string logical_plan_opt;
-
-protected:
-	void ResolveTypes() override {
-		types = {LogicalType::VARCHAR, LogicalType::VARCHAR};
-	}
-	vector<ColumnBinding> GetColumnBindings() override {
-		return {ColumnBinding(0, 0), ColumnBinding(0, 1)};
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_export.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class LogicalExport : public LogicalOperator {
-public:
-	LogicalExport(CopyFunction function, unique_ptr<CopyInfo> copy_info, BoundExportData exported_tables)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT), function(function), copy_info(move(copy_info)),
-	      exported_tables(move(exported_tables)) {
-	}
-	CopyFunction function;
-	unique_ptr<CopyInfo> copy_info;
-	BoundExportData exported_tables;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_expression_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalExpressionGet represents a scan operation over a set of to-be-executed expressions
-class LogicalExpressionGet : public LogicalOperator {
-public:
-	LogicalExpressionGet(idx_t table_index, vector<LogicalType> types,
-	                     vector<vector<unique_ptr<Expression>>> expressions)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPRESSION_GET), table_index(table_index), expr_types(types),
-	      expressions(move(expressions)) {
-	}
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The types of the expressions
-	vector<LogicalType> expr_types;
-	//! The set of expressions
-	vector<vector<unique_ptr<Expression>>> expressions;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, expr_types.size());
-	}
-
-protected:
-	void ResolveTypes() override {
-		// types are resolved in the constructor
-		this->types = expr_types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/expression_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/expression_type_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-//! The ExpressionTypeMatcher class contains a set of matchers that can be used to pattern match ExpressionTypes
-class ExpressionTypeMatcher {
-public:
-	virtual ~ExpressionTypeMatcher() {
-	}
-
-	virtual bool Match(ExpressionType type) = 0;
-};
-
-//! The SpecificExpressionTypeMatcher class matches a single specified Expression type
-class SpecificExpressionTypeMatcher : public ExpressionTypeMatcher {
-public:
-	explicit SpecificExpressionTypeMatcher(ExpressionType type) : type(type) {
-	}
-
-	bool Match(ExpressionType type) override {
-		return type == this->type;
-	}
-
-private:
-	ExpressionType type;
-};
-
-//! The ManyExpressionTypeMatcher class matches a set of ExpressionTypes
-class ManyExpressionTypeMatcher : public ExpressionTypeMatcher {
-public:
-	explicit ManyExpressionTypeMatcher(vector<ExpressionType> types) : types(move(types)) {
-	}
-
-	bool Match(ExpressionType type) override {
-		return std::find(types.begin(), types.end(), type) != types.end();
-	}
-
-private:
-	vector<ExpressionType> types;
-};
-
-//! The ComparisonExpressionTypeMatcher class matches a comparison expression
-class ComparisonExpressionTypeMatcher : public ExpressionTypeMatcher {
-public:
-	bool Match(ExpressionType type) override {
-		return type == ExpressionType::COMPARE_EQUAL || type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-		       type == ExpressionType::COMPARE_LESSTHANOREQUALTO || type == ExpressionType::COMPARE_LESSTHAN ||
-		       type == ExpressionType::COMPARE_GREATERTHAN;
-	}
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/set_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class SetMatcher {
-public:
-	//! The policy used by the SetMatcher
-	enum class Policy {
-		//! All entries have to be matched, and the matches have to be ordered
-		ORDERED,
-		//! All entries have to be matched, but the order of the matches does not matter
-		UNORDERED,
-		//! Only some entries have to be matched, the order of the matches does not matter
-		SOME,
-		//! Not initialized
-		INVALID
-	};
-
-	/* The double {{}} in the intializer for excluded_entries is intentional, workaround for bug in gcc-4.9 */
-	template <class T, class MATCHER>
-	static bool MatchRecursive(vector<unique_ptr<MATCHER>> &matchers, vector<T *> &entries, vector<T *> &bindings,
-	                           unordered_set<idx_t> excluded_entries, idx_t m_idx = 0) {
-		if (m_idx == matchers.size()) {
-			// matched all matchers!
-			return true;
-		}
-		// try to find a match for the current matcher (m_idx)
-		idx_t previous_binding_count = bindings.size();
-		for (idx_t e_idx = 0; e_idx < entries.size(); e_idx++) {
-			// first check if this entry has already been matched
-			if (excluded_entries.find(e_idx) != excluded_entries.end()) {
-				// it has been matched: skip this entry
-				continue;
-			}
-			// otherwise check if the current matcher matches this entry
-			if (matchers[m_idx]->Match(entries[e_idx], bindings)) {
-				// m_idx matches e_idx!
-				// check if we can find a complete match for this path
-				// first add e_idx to the new set of excluded entries
-				unordered_set<idx_t> new_excluded_entries;
-				new_excluded_entries = excluded_entries;
-				new_excluded_entries.insert(e_idx);
-				// then match the next matcher in the set
-				if (MatchRecursive(matchers, entries, bindings, new_excluded_entries, m_idx + 1)) {
-					// we found a match for this path! success
-					return true;
-				} else {
-					// we did not find a match! remove any bindings we added in the call to Match()
-					bindings.erase(bindings.begin() + previous_binding_count, bindings.end());
-				}
-			}
-		}
-		return false;
-	}
-
-	template <class T, class MATCHER>
-	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<T *> &entries, vector<T *> &bindings,
-	                  Policy policy) {
-		if (policy == Policy::ORDERED) {
-			// ordered policy, count has to match
-			if (matchers.size() != entries.size()) {
-				return false;
-			}
-			// now entries have to match in order
-			for (idx_t i = 0; i < matchers.size(); i++) {
-				if (!matchers[i]->Match(entries[i], bindings)) {
-					return false;
-				}
-			}
-			return true;
-		} else {
-			if (policy == Policy::UNORDERED && matchers.size() != entries.size()) {
-				// unordered policy, count does not match: no match
-				return false;
-			} else if (policy == Policy::SOME && matchers.size() > entries.size()) {
-				// some policy, every matcher has to match a unique entry
-				// this is not possible if there are more matchers than entries
-				return false;
-			}
-			// now perform the actual matching
-			// every matcher has to match a UNIQUE entry
-			// we perform this matching in a recursive way
-			unordered_set<idx_t> excluded_entries;
-			if (!MatchRecursive(matchers, entries, bindings, excluded_entries)) {
-				return false;
-			}
-			return true;
-		}
-	}
-
-	template <class T, class MATCHER>
-	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<unique_ptr<T>> &entries, vector<T *> &bindings,
-	                  Policy policy) {
-		// convert vector of unique_ptr to vector of normal pointers
-		vector<T *> ptr_entries;
-		for (auto &entry : entries) {
-			ptr_entries.push_back(entry.get());
-		}
-		// then just call the normal match function
-		return Match(matchers, ptr_entries, bindings, policy);
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/type_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The TypeMatcher class contains a set of matchers that can be used to pattern match TypeIds for Rules
-class TypeMatcher {
-public:
-	virtual ~TypeMatcher() {
-	}
-
-	virtual bool Match(const LogicalType &type) = 0;
-};
-
-//! The SpecificTypeMatcher class matches only a single specified type
-class SpecificTypeMatcher : public TypeMatcher {
-public:
-	explicit SpecificTypeMatcher(LogicalType type) : type(type) {
-	}
-
-	bool Match(const LogicalType &type_p) override {
-		return type_p == this->type;
-	}
-
-private:
-	LogicalType type;
-};
-
-//! The NumericTypeMatcher class matches any numeric type (DECIMAL, INTEGER, etc...)
-class NumericTypeMatcher : public TypeMatcher {
-public:
-	bool Match(const LogicalType &type) override {
-		return type.IsNumeric();
-	}
-};
-
-//! The IntegerTypeMatcher class matches only integer types (INTEGER, SMALLINT, TINYINT, BIGINT)
-class IntegerTypeMatcher : public TypeMatcher {
-public:
-	bool Match(const LogicalType &type) override {
-		return type.IsIntegral();
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/function_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-//! The FunctionMatcher class contains a set of matchers that can be used to pattern match specific functions
-class FunctionMatcher {
-public:
-	virtual ~FunctionMatcher() {
-	}
-
-	virtual bool Match(string &name) = 0;
-
-	static bool Match(unique_ptr<FunctionMatcher> &matcher, string &name) {
-		if (!matcher) {
-			return true;
-		}
-		return matcher->Match(name);
-	}
-};
-
-//! The SpecificFunctionMatcher class matches a single specified function name
-class SpecificFunctionMatcher : public FunctionMatcher {
-public:
-	explicit SpecificFunctionMatcher(string name) : name(move(name)) {
-	}
-
-	bool Match(string &name) override {
-		return name == this->name;
-	}
-
-private:
-	string name;
-};
-
-//! The ManyFunctionMatcher class matches a set of functions
-class ManyFunctionMatcher : public FunctionMatcher {
-public:
-	explicit ManyFunctionMatcher(unordered_set<string> names) : names(move(names)) {
-	}
-
-	bool Match(string &name) override {
-		return names.find(name) != names.end();
-	}
-
-private:
-	unordered_set<string> names;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//! The ExpressionMatcher class contains a set of matchers that can be used to pattern match Expressions
-class ExpressionMatcher {
-public:
-	explicit ExpressionMatcher(ExpressionClass type = ExpressionClass::INVALID) : expr_class(type) {
-	}
-	virtual ~ExpressionMatcher() {
-	}
-
-	//! Checks if the given expression matches this ExpressionMatcher. If it does, the expression is appended to the
-	//! bindings list and true is returned. Otherwise, false is returned.
-	virtual bool Match(Expression *expr, vector<Expression *> &bindings);
-
-	//! The ExpressionClass of the to-be-matched expression. ExpressionClass::INVALID for ANY.
-	ExpressionClass expr_class;
-	//! Matcher for the ExpressionType of the operator (nullptr for ANY)
-	unique_ptr<ExpressionTypeMatcher> expr_type;
-	//! Matcher for the return_type of the expression (nullptr for ANY)
-	unique_ptr<TypeMatcher> type;
-};
-
-//! The ExpressionEqualityMatcher matches on equality with another (given) expression
-class ExpressionEqualityMatcher : public ExpressionMatcher {
-public:
-	explicit ExpressionEqualityMatcher(Expression *expr)
-	    : ExpressionMatcher(ExpressionClass::INVALID), expression(expr) {
-	}
-
-	bool Match(Expression *expr, vector<Expression *> &bindings) override;
-
-private:
-	Expression *expression;
-};
-
-class ConstantExpressionMatcher : public ExpressionMatcher {
-public:
-	ConstantExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CONSTANT) {
-	}
-};
-
-class CaseExpressionMatcher : public ExpressionMatcher {
-public:
-	CaseExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CASE) {
-	}
-
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
-};
-
-class ComparisonExpressionMatcher : public ExpressionMatcher {
-public:
-	ComparisonExpressionMatcher()
-	    : ExpressionMatcher(ExpressionClass::BOUND_COMPARISON), policy(SetMatcher::Policy::INVALID) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
-};
-
-class CastExpressionMatcher : public ExpressionMatcher {
-public:
-	CastExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CAST) {
-	}
-	//! The matcher for the child expressions
-	unique_ptr<ExpressionMatcher> matcher;
-
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
-};
-
-class InClauseExpressionMatcher : public ExpressionMatcher {
-public:
-	InClauseExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_OPERATOR) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
-};
-
-class ConjunctionExpressionMatcher : public ExpressionMatcher {
-public:
-	ConjunctionExpressionMatcher()
-	    : ExpressionMatcher(ExpressionClass::BOUND_CONJUNCTION), policy(SetMatcher::Policy::INVALID) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
-};
-
-class FunctionExpressionMatcher : public ExpressionMatcher {
-public:
-	FunctionExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_FUNCTION) {
-	}
-	//! The matchers for the child expressions
-	vector<unique_ptr<ExpressionMatcher>> matchers;
-	//! The set matcher matching policy to use
-	SetMatcher::Policy policy;
-	//! The function name to match
-	unique_ptr<FunctionMatcher> function;
-
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
-};
-
-//! The FoldableConstant matcher matches any expression that is foldable into a constant by the ExpressionExecutor (i.e.
-//! scalar but not aggregate/window/parameter)
-class FoldableConstantMatcher : public ExpressionMatcher {
-public:
-	FoldableConstantMatcher() : ExpressionMatcher(ExpressionClass::INVALID) {
-	}
-
-	bool Match(Expression *expr, vector<Expression *> &bindings) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalFilter represents a filter operation (e.g. WHERE or HAVING clause)
-class LogicalFilter : public LogicalOperator {
-public:
-	explicit LogicalFilter(unique_ptr<Expression> expression);
-	LogicalFilter();
-
-	vector<idx_t> projection_map;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	bool SplitPredicates() {
-		return SplitPredicates(expressions);
-	}
-	//! Splits up the predicates of the LogicalFilter into a set of predicates
-	//! separated by AND Returns whether or not any splits were made
-	static bool SplitPredicates(vector<unique_ptr<Expression>> &expressions);
-
-protected:
-	void ResolveTypes() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_get.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalGet represents a scan operation from a data source
-class LogicalGet : public LogicalOperator {
-public:
-	LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
-	           vector<LogicalType> returned_types, vector<string> returned_names);
-
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! The function that is called
-	TableFunction function;
-	//! The bind data of the function
-	unique_ptr<FunctionData> bind_data;
-	//! The types of ALL columns that can be returned by the table function
-	vector<LogicalType> returned_types;
-	//! The names of ALL columns that can be returned by the table function
-	vector<string> names;
-	//! Bound column IDs
-	vector<column_t> column_ids;
-	//! Filters pushed down for table scan
-	TableFilterSet table_filters;
-
-	string GetName() const override;
-	string ParamsToString() const override;
-	//! Returns the underlying table that is being scanned, or nullptr if there is none
-	TableCatalogEntry *GetTable() const;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_insert.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalInsert represents an insertion of data into a base table
-class LogicalInsert : public LogicalOperator {
-public:
-	explicit LogicalInsert(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT), table(table), table_index(0), return_chunk(false) {
-	}
-
-	vector<vector<unique_ptr<Expression>>> insert_values;
-	//! The insertion map ([table_index -> index in result, or DConstants::INVALID_INDEX if not specified])
-	vector<idx_t> column_index_map;
-	//! The expected types for the INSERT statement (obtained from the column types)
-	vector<LogicalType> expected_types;
-	//! The base table to insert into
-	TableCatalogEntry *table;
-	idx_t table_index;
-	//! if returning option is used, return actual chunk to projection
-	bool return_chunk;
-	//! The default statements used by the table
-	vector<unique_ptr<Expression>> bound_defaults;
-
-protected:
-	vector<ColumnBinding> GetColumnBindings() override {
-		if (return_chunk) {
-			return GenerateColumnBindings(table_index, table->columns.size());
-		}
-		return {ColumnBinding(0, 0)};
-	}
-
-	void ResolveTypes() override {
-		if (return_chunk) {
-			types = table->GetTypes();
-		} else {
-			types.emplace_back(LogicalType::BIGINT);
-		}
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_limit.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalLimit represents a LIMIT clause
-class LogicalLimit : public LogicalOperator {
-public:
-	LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr<Expression> limit, unique_ptr<Expression> offset);
-
-	//! Limit and offset values in case they are constants, used in optimizations.
-	int64_t limit_val;
-	int64_t offset_val;
-	//! The maximum amount of elements to emit
-	unique_ptr<Expression> limit;
-	//! The offset from the start to begin emitting elements
-	unique_ptr<Expression> offset;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_order.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalOrder represents an ORDER BY clause, sorting the data
-class LogicalOrder : public LogicalOperator {
-public:
-	explicit LogicalOrder(vector<BoundOrderByNode> orders)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(move(orders)) {
-	}
-
-	vector<BoundOrderByNode> orders;
-
-	string ParamsToString() const override {
-		string result;
-		for (idx_t i = 0; i < orders.size(); i++) {
-			if (i > 0) {
-				result += "\n";
-			}
-			result += orders[i].expression->GetName();
-		}
-		return result;
-	}
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_pragma.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalSimple represents a simple logical operator that only passes on the parse info
-class LogicalPragma : public LogicalOperator {
-public:
-	LogicalPragma(PragmaFunction function_p, PragmaInfo info_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_PRAGMA), function(move(function_p)), info(move(info_p)) {
-	}
-
-	//! The pragma function to call
-	PragmaFunction function;
-	//! The context of the call
-	PragmaInfo info;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_prepare.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class TableCatalogEntry;
-
-class LogicalPrepare : public LogicalOperator {
-public:
-	LogicalPrepare(string name, shared_ptr<PreparedStatementData> prepared, unique_ptr<LogicalOperator> logical_plan)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_PREPARE), name(name), prepared(move(prepared)) {
-		children.push_back(move(logical_plan));
-	}
-
-	string name;
-	shared_ptr<PreparedStatementData> prepared;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_projection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalProjection represents the projection list in a SELECT clause
-class LogicalProjection : public LogicalOperator {
-public:
-	LogicalProjection(idx_t table_index, vector<unique_ptr<Expression>> select_list);
-
-	idx_t table_index;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_recursive_cte.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class LogicalRecursiveCTE : public LogicalOperator {
-public:
-	LogicalRecursiveCTE(idx_t table_index, idx_t column_count, bool union_all, unique_ptr<LogicalOperator> top,
-	                    unique_ptr<LogicalOperator> bottom, LogicalOperatorType type)
-	    : LogicalOperator(type), union_all(union_all), table_index(table_index), column_count(column_count) {
-		D_ASSERT(type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
-		children.push_back(move(top));
-		children.push_back(move(bottom));
-	}
-
-	bool union_all;
-	idx_t table_index;
-	idx_t column_count;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, column_count);
-	}
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_cteref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalChunkGet represents a scan operation from a ChunkCollection
-class LogicalCTERef : public LogicalOperator {
-public:
-	LogicalCTERef(idx_t table_index, idx_t cte_index, vector<LogicalType> types, vector<string> colnames)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CTE_REF), table_index(table_index), cte_index(cte_index) {
-		D_ASSERT(types.size() > 0);
-		chunk_types = types;
-		bound_columns = colnames;
-	}
-
-	vector<string> bound_columns;
-	//! The table index in the current bind context
-	idx_t table_index;
-	//! CTE index
-	idx_t cte_index;
-	//! The types of the chunk
-	vector<LogicalType> chunk_types;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, chunk_types.size());
-	}
-
-protected:
-	void ResolveTypes() override {
-		// types are resolved in the constructor
-		this->types = chunk_types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_sample.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalSample represents a SAMPLE clause
-class LogicalSample : public LogicalOperator {
-public:
-	LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child);
-
-	//! The sample options
-	unique_ptr<SampleOptions> sample_options;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-	idx_t EstimateCardinality(ClientContext &context) override;
-
-protected:
-	void ResolveTypes() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class LogicalSet : public LogicalOperator {
-public:
-	LogicalSet(std::string name_p, Value value_p, SetScope scope_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_SET), name(name_p), value(value_p), scope(scope_p) {
-	}
-
-	std::string name;
-	Value value;
-	SetScope scope;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_set_operation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class LogicalSetOperation : public LogicalOperator {
-public:
-	LogicalSetOperation(idx_t table_index, idx_t column_count, unique_ptr<LogicalOperator> top,
-	                    unique_ptr<LogicalOperator> bottom, LogicalOperatorType type)
-	    : LogicalOperator(type), table_index(table_index), column_count(column_count) {
-		D_ASSERT(type == LogicalOperatorType::LOGICAL_UNION || type == LogicalOperatorType::LOGICAL_EXCEPT ||
-		         type == LogicalOperatorType::LOGICAL_INTERSECT);
-		children.push_back(move(top));
-		children.push_back(move(bottom));
-	}
-
-	idx_t table_index;
-	idx_t column_count;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return GenerateColumnBindings(table_index, column_count);
-	}
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_show.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class LogicalShow : public LogicalOperator {
-public:
-	explicit LogicalShow(unique_ptr<LogicalOperator> plan) : LogicalOperator(LogicalOperatorType::LOGICAL_SHOW) {
-		children.push_back(move(plan));
-	}
-
-	vector<LogicalType> types_select;
-	vector<string> aliases;
-
-protected:
-	void ResolveTypes() override {
-		types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,
-		         LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
-	}
-	vector<ColumnBinding> GetColumnBindings() override {
-		return {ColumnBinding(0, 0), ColumnBinding(0, 1), ColumnBinding(0, 2),
-		        ColumnBinding(0, 3), ColumnBinding(0, 4), ColumnBinding(0, 5)};
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_simple.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalSimple represents a simple logical operator that only passes on the parse info
-class LogicalSimple : public LogicalOperator {
-public:
-	LogicalSimple(LogicalOperatorType type, unique_ptr<ParseInfo> info) : LogicalOperator(type), info(move(info)) {
-	}
-
-	unique_ptr<ParseInfo> info;
-
-protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BOOLEAN);
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_top_n.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalTopN represents a comibination of ORDER BY and LIMIT clause, using Min/Max Heap
-class LogicalTopN : public LogicalOperator {
-public:
-	LogicalTopN(vector<BoundOrderByNode> orders, int64_t limit, int64_t offset)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_TOP_N), orders(move(orders)), limit(limit), offset(offset) {
-	}
-
-	vector<BoundOrderByNode> orders;
-	//! The maximum amount of elements to emit
-	int64_t limit;
-	//! The offset from the start to begin emitting elements
-	int64_t offset;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_unnest.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalAggregate represents an aggregate operation with (optional) GROUP BY
-//! operator.
-class LogicalUnnest : public LogicalOperator {
-public:
-	explicit LogicalUnnest(idx_t unnest_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_UNNEST), unnest_index(unnest_index) {
-	}
-
-	idx_t unnest_index;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_update.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class LogicalUpdate : public LogicalOperator {
-public:
-	explicit LogicalUpdate(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
-	}
-
-	//! The base table to update
-	TableCatalogEntry *table;
-	//! table catalog index
-	idx_t table_index;
-	//! if returning option is used, return the update chunk
-	bool return_chunk;
-	vector<column_t> columns;
-	vector<unique_ptr<Expression>> bound_defaults;
-	bool update_is_del_and_insert;
-
-protected:
-	vector<ColumnBinding> GetColumnBindings() override {
-		if (return_chunk) {
-			return GenerateColumnBindings(table_index, table->columns.size());
-		}
-		return {ColumnBinding(0, 0)};
-	}
-
-	void ResolveTypes() override {
-		if (return_chunk) {
-			types = table->GetTypes();
-		} else {
-			types.emplace_back(LogicalType::BIGINT);
-		}
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_window.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalAggregate represents an aggregate operation with (optional) GROUP BY
-//! operator.
-class LogicalWindow : public LogicalOperator {
-public:
-	explicit LogicalWindow(idx_t window_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_WINDOW), window_index(window_index) {
-	}
-
-	idx_t window_index;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override;
-
-protected:
-	void ResolveTypes() override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/algebraic_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct AvgFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CovarSampFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CovarPopFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct Corr {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StdDevSampFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StdDevPopFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct VarPopFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct VarSampFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct VarianceFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StandardErrorOfTheMeanFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/sum_helpers.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-static inline void KahanAddInternal(double input, double &summed, double &err) {
-	double diff = input - err;
-	double newval = summed + diff;
-	err = (newval - summed) - diff;
-	summed = newval;
-}
-
-template <class T>
-struct SumState {
-	bool isset;
-	T value;
-
-	void Initialize() {
-		this->isset = false;
-	}
-
-	void Combine(const SumState<T> &other) {
-		this->isset = other.isset || this->isset;
-		this->value += other.value;
-	}
-};
-
-struct KahanSumState {
-	bool isset;
-	double value;
-	double err;
-
-	void Initialize() {
-		this->isset = false;
-		this->err = 0.0;
-	}
-
-	void Combine(const KahanSumState &other) {
-		this->isset = other.isset || this->isset;
-		KahanAddInternal(other.value, this->value, this->err);
-		KahanAddInternal(other.err, this->value, this->err);
-	}
-};
-
-struct RegularAdd {
-	template <class STATE, class T>
-	static void AddNumber(STATE &state, T input) {
-		state.value += input;
-	}
-
-	template <class STATE, class T>
-	static void AddConstant(STATE &state, T input, idx_t count) {
-		state.value += input * count;
-	}
-};
-
-struct KahanAdd {
-	template <class STATE, class T>
-	static void AddNumber(STATE &state, T input) {
-		KahanAddInternal(input, state.value, state.err);
-	}
-
-	template <class STATE, class T>
-	static void AddConstant(STATE &state, T input, idx_t count) {
-		KahanAddInternal(input * count, state.value, state.err);
-	}
-};
-
-struct HugeintAdd {
-	static void AddValue(hugeint_t &result, uint64_t value, int positive) {
-		// integer summation taken from Tim Gubner et al. - Efficient Query Processing
-		// with Optimistically Compressed Hash Tables & Strings in the USSR
-
-		// add the value to the lower part of the hugeint
-		result.lower += value;
-		// now handle overflows
-		int overflow = result.lower < value;
-		// we consider two situations:
-		// (1) input[idx] is positive, and current value is lower than value: overflow
-		// (2) input[idx] is negative, and current value is higher than value: underflow
-		if (!(overflow ^ positive)) {
-			// in the case of an overflow or underflow we either increment or decrement the upper base
-			// positive: +1, negative: -1
-			result.upper += -1 + 2 * positive;
-		}
-	}
-
-	template <class STATE, class T>
-	static void AddNumber(STATE &state, T input) {
-		AddValue(state.value, uint64_t(input), input >= 0);
-	}
-
-	template <class STATE, class T>
-	static void AddConstant(STATE &state, T input, idx_t count) {
-		// add a constant X number of times
-		// fast path: check if value * count fits into a uint64_t
-		// note that we check if value * VECTOR_SIZE fits in a uint64_t to avoid having to actually do a division
-		// this is still a pretty high number (18014398509481984) so most positive numbers will fit
-		if (input >= 0 && uint64_t(input) < (NumericLimits<uint64_t>::Maximum() / STANDARD_VECTOR_SIZE)) {
-			// if it does just multiply it and add the value
-			uint64_t value = uint64_t(input) * count;
-			AddValue(state.value, value, 1);
-		} else {
-			// if it doesn't fit we have two choices
-			// either we loop over count and add the values individually
-			// or we convert to a hugeint and multiply the hugeint
-			// the problem is that hugeint multiplication is expensive
-			// hence we switch here: with a low count we do the loop
-			// with a high count we do the hugeint multiplication
-			if (count < 8) {
-				for (idx_t i = 0; i < count; i++) {
-					AddValue(state.value, uint64_t(input), input >= 0);
-				}
-			} else {
-				hugeint_t addition = hugeint_t(input) * count;
-				state.value += addition;
-			}
-		}
-	}
-};
-
-template <class STATEOP, class ADDOP>
-struct BaseSumOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->value = 0;
-		STATEOP::template Initialize<STATE>(state);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		STATEOP::template Combine<STATE>(source, target, aggr_input_data);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		STATEOP::template AddValues<STATE>(state, 1);
-		ADDOP::template AddNumber<STATE, INPUT_TYPE>(*state, input[idx]);
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		STATEOP::template AddValues<STATE>(state, count);
-		ADDOP::template AddConstant<STATE, INPUT_TYPE>(*state, *input, count);
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/algebraic/covar.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct CovarState {
-	uint64_t count;
-	double meanx;
-	double meany;
-	double co_moment;
-};
-
-struct CovarOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->count = 0;
-		state->meanx = 0;
-		state->meany = 0;
-		state->co_moment = 0;
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		// update running mean and d^2
-		const uint64_t n = ++(state->count);
-
-		const auto x = x_data[xidx];
-		const double dx = (x - state->meanx);
-		const double meanx = state->meanx + dx / n;
-
-		const auto y = y_data[yidx];
-		const double dy = (y - state->meany);
-		const double meany = state->meany + dy / n;
-
-		const double C = state->co_moment + dx * (y - meany);
-
-		state->meanx = meanx;
-		state->meany = meany;
-		state->co_moment = C;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (target->count == 0) {
-			*target = source;
-		} else if (source.count > 0) {
-			const auto count = target->count + source.count;
-			const auto meanx = (source.count * source.meanx + target->count * target->meanx) / count;
-			const auto meany = (source.count * source.meany + target->count * target->meany) / count;
-
-			//  Schubert and Gertz SSDBM 2018, equation 21
-			const auto deltax = target->meanx - source.meanx;
-			const auto deltay = target->meany - source.meany;
-			target->co_moment =
-			    source.co_moment + target->co_moment + deltax * deltay * source.count * target->count / count;
-			target->meanx = meanx;
-			target->meany = meany;
-			target->count = count;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct CovarPopOperation : public CovarOperation {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->co_moment / state->count;
-		}
-	}
-};
-
-struct CovarSampOperation : public CovarOperation {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if ((state->count) < 2) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->co_moment / (state->count - 1);
-		}
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/algebraic/stddev.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-#include <ctgmath>
-
-namespace duckdb {
-
-struct StddevState {
-	uint64_t count;  //  n
-	double mean;     //  M1
-	double dsquared; //  M2
-};
-
-// Streaming approximate standard deviation using Welford's
-// method, DOI: 10.2307/1266577
-struct STDDevBaseOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->count = 0;
-		state->mean = 0;
-		state->dsquared = 0;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input_data, ValidityMask &mask, idx_t idx) {
-		// update running mean and d^2
-		state->count++;
-		const double input = input_data[idx];
-		const double mean_differential = (input - state->mean) / state->count;
-		const double new_mean = state->mean + mean_differential;
-		const double dsquared_increment = (input - new_mean) * (input - state->mean);
-		const double new_dsquared = state->dsquared + dsquared_increment;
-
-		state->mean = new_mean;
-		state->dsquared = new_dsquared;
-	}
-
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input_data,
-	                              ValidityMask &mask, idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input_data, mask, 0);
-		}
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (target->count == 0) {
-			*target = source;
-		} else if (source.count > 0) {
-			const auto count = target->count + source.count;
-			const auto mean = (source.count * source.mean + target->count * target->mean) / count;
-			const auto delta = source.mean - target->mean;
-			target->dsquared =
-			    source.dsquared + target->dsquared + delta * delta * source.count * target->count / count;
-			target->mean = mean;
-			target->count = count;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-struct VarSampOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count <= 1) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->dsquared / (state->count - 1);
-			if (!Value::DoubleIsFinite(target[idx])) {
-				throw OutOfRangeException("VARSAMP is out of range!");
-			}
-		}
-	}
-};
-
-struct VarPopOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->count > 1 ? (state->dsquared / state->count) : 0;
-			if (!Value::DoubleIsFinite(target[idx])) {
-				throw OutOfRangeException("VARPOP is out of range!");
-			}
-		}
-	}
-};
-
-struct STDDevSampOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count <= 1) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = sqrt(state->dsquared / (state->count - 1));
-			if (!Value::DoubleIsFinite(target[idx])) {
-				throw OutOfRangeException("STDDEV_SAMP is out of range!");
-			}
-		}
-	}
-};
-
-struct STDDevPopOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = state->count > 1 ? sqrt(state->dsquared / state->count) : 0;
-			if (!Value::DoubleIsFinite(target[idx])) {
-				throw OutOfRangeException("STDDEV_POP is out of range!");
-			}
-		}
-	}
-};
-
-struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			target[idx] = sqrt(state->dsquared / state->count) / sqrt((state->count));
-			if (!Value::DoubleIsFinite(target[idx])) {
-				throw OutOfRangeException("SEM is out of range!");
-			}
-		}
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/algebraic/corr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CorrState {
-	CovarState cov_pop;
-	StddevState dev_pop_x;
-	StddevState dev_pop_y;
-};
-
-// Returns the correlation coefficient for non-null pairs in a group.
-// CORR(y, x) = COVAR_POP(y, x) / (STDDEV_POP(x) * STDDEV_POP(y))
-struct CorrOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
-		STDDevBaseOperation::Initialize<StddevState>(&state->dev_pop_x);
-		STDDevBaseOperation::Initialize<StddevState>(&state->dev_pop_y);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, aggr_input_data, x_data, y_data,
-		                                                          amask, bmask, xidx, yidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->dev_pop_x, aggr_input_data, x_data, amask,
-		                                                        xidx);
-		STDDevBaseOperation::Operation<B_TYPE, StddevState, OP>(&state->dev_pop_y, aggr_input_data, y_data, bmask,
-		                                                        yidx);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.dev_pop_x, &target->dev_pop_x, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.dev_pop_y, &target->dev_pop_y, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->cov_pop.count == 0 || state->dev_pop_x.count == 0 || state->dev_pop_y.count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			auto cov = state->cov_pop.co_moment / state->cov_pop.count;
-			auto std_x = state->dev_pop_x.count > 1 ? sqrt(state->dev_pop_x.dsquared / state->dev_pop_x.count) : 0;
-			if (!Value::DoubleIsFinite(std_x)) {
-				throw OutOfRangeException("STDDEV_POP for X is out of range!");
-			}
-			auto std_y = state->dev_pop_y.count > 1 ? sqrt(state->dev_pop_y.dsquared / state->dev_pop_y.count) : 0;
-			if (!Value::DoubleIsFinite(std_y)) {
-				throw OutOfRangeException("STDDEV_POP for Y is out of range!");
-			}
-			if (std_x * std_y == 0) {
-				mask.SetInvalid(idx);
-				return;
-			}
-			target[idx] = cov / (std_x * std_y);
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/holistic_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct QuantileFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ModeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ApproximateQuantileFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ReservoirQuantileFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #8
-// See the end of this file for a list
-
-/*
- * Licensed to Derrick R. Burns under one or more
- * contributor license agreements.  See the NOTICES file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-
-#include <algorithm>
-#include <cfloat>
-#include <cmath>
-#include <queue>
-#include <utility>
-#include <vector>
-
-#ifdef min
-#undef min
-#endif
-
-#ifdef max
-#undef max
-#endif
-
-
-namespace duckdb_tdigest {
-
-using Value = double;
-using Weight = double;
-using Index = size_t;
-
-const size_t kHighWater = 40000;
-const double pi = 3.14159265358979323846;
-class Centroid {
-public:
-	Centroid() : Centroid(0.0, 0.0) {
-	}
-
-	Centroid(Value mean, Weight weight) : mean_(mean), weight_(weight) {
-	}
-
-	inline Value mean() const noexcept {
-		return mean_;
-	}
-
-	inline Weight weight() const noexcept {
-		return weight_;
-	}
-
-	inline void add(const Centroid &c) {
-		//    CHECK_GT(c.weight_, 0);
-		if (weight_ != 0.0) {
-			weight_ += c.weight_;
-			mean_ += c.weight_ * (c.mean_ - mean_) / weight_;
-		} else {
-			weight_ = c.weight_;
-			mean_ = c.mean_;
-		}
-	}
-
-private:
-	Value mean_ = 0;
-	Weight weight_ = 0;
-};
-
-struct CentroidList {
-	explicit CentroidList(const std::vector<Centroid> &s) : iter(s.cbegin()), end(s.cend()) {
-	}
-	std::vector<Centroid>::const_iterator iter;
-	std::vector<Centroid>::const_iterator end;
-
-	bool advance() {
-		return ++iter != end;
-	}
-};
-
-class CentroidListComparator {
-public:
-	CentroidListComparator() {
-	}
-
-	bool operator()(const CentroidList &left, const CentroidList &right) const {
-		return left.iter->mean() > right.iter->mean();
-	}
-};
-
-using CentroidListQueue = std::priority_queue<CentroidList, std::vector<CentroidList>, CentroidListComparator>;
-
-struct CentroidComparator {
-	bool operator()(const Centroid &a, const Centroid &b) const {
-		return a.mean() < b.mean();
-	}
-};
-
-class TDigest {
-	class TDigestComparator {
-	public:
-		TDigestComparator() {
-		}
-
-		bool operator()(const TDigest *left, const TDigest *right) const {
-			return left->totalSize() > right->totalSize();
-		}
-	};
-
-	using TDigestQueue = std::priority_queue<const TDigest *, std::vector<const TDigest *>, TDigestComparator>;
-
-public:
-	TDigest() : TDigest(1000) {
-	}
-
-	explicit TDigest(Value compression) : TDigest(compression, 0) {
-	}
-
-	TDigest(Value compression, Index bufferSize) : TDigest(compression, bufferSize, 0) {
-	}
-
-	TDigest(Value compression, Index unmergedSize, Index mergedSize)
-	    : compression_(compression), maxProcessed_(processedSize(mergedSize, compression)),
-	      maxUnprocessed_(unprocessedSize(unmergedSize, compression)) {
-		processed_.reserve(maxProcessed_);
-		unprocessed_.reserve(maxUnprocessed_ + 1);
-	}
-
-	TDigest(std::vector<Centroid> &&processed, std::vector<Centroid> &&unprocessed, Value compression,
-	        Index unmergedSize, Index mergedSize)
-	    : TDigest(compression, unmergedSize, mergedSize) {
-		processed_ = std::move(processed);
-		unprocessed_ = std::move(unprocessed);
-
-		processedWeight_ = weight(processed_);
-		unprocessedWeight_ = weight(unprocessed_);
-		if (!processed_.empty()) {
-			min_ = std::min(min_, processed_[0].mean());
-			max_ = std::max(max_, (processed_.cend() - 1)->mean());
-		}
-		updateCumulative();
-	}
-
-	static Weight weight(std::vector<Centroid> &centroids) noexcept {
-		Weight w = 0.0;
-		for (auto centroid : centroids) {
-			w += centroid.weight();
-		}
-		return w;
-	}
-
-	TDigest &operator=(TDigest &&o) {
-		compression_ = o.compression_;
-		maxProcessed_ = o.maxProcessed_;
-		maxUnprocessed_ = o.maxUnprocessed_;
-		processedWeight_ = o.processedWeight_;
-		unprocessedWeight_ = o.unprocessedWeight_;
-		processed_ = std::move(o.processed_);
-		unprocessed_ = std::move(o.unprocessed_);
-		cumulative_ = std::move(o.cumulative_);
-		min_ = o.min_;
-		max_ = o.max_;
-		return *this;
-	}
-
-	TDigest(TDigest &&o)
-	    : TDigest(std::move(o.processed_), std::move(o.unprocessed_), o.compression_, o.maxUnprocessed_,
-	              o.maxProcessed_) {
-	}
-
-	static inline Index processedSize(Index size, Value compression) noexcept {
-		return (size == 0) ? static_cast<Index>(2 * std::ceil(compression)) : size;
-	}
-
-	static inline Index unprocessedSize(Index size, Value compression) noexcept {
-		return (size == 0) ? static_cast<Index>(8 * std::ceil(compression)) : size;
-	}
-
-	// merge in another t-digest
-	inline void merge(const TDigest *other) {
-		std::vector<const TDigest *> others {other};
-		add(others.cbegin(), others.cend());
-	}
-
-	const std::vector<Centroid> &processed() const {
-		return processed_;
-	}
-
-	const std::vector<Centroid> &unprocessed() const {
-		return unprocessed_;
-	}
-
-	Index maxUnprocessed() const {
-		return maxUnprocessed_;
-	}
-
-	Index maxProcessed() const {
-		return maxProcessed_;
-	}
-
-	inline void add(std::vector<const TDigest *> digests) {
-		add(digests.cbegin(), digests.cend());
-	}
-
-	// merge in a vector of tdigests in the most efficient manner possible
-	// in constant space
-	// works for any value of kHighWater
-	void add(std::vector<const TDigest *>::const_iterator iter, std::vector<const TDigest *>::const_iterator end) {
-		if (iter != end) {
-			auto size = std::distance(iter, end);
-			TDigestQueue pq(TDigestComparator {});
-			for (; iter != end; iter++) {
-				pq.push((*iter));
-			}
-			std::vector<const TDigest *> batch;
-			batch.reserve(size);
-
-			size_t totalSize = 0;
-			while (!pq.empty()) {
-				auto td = pq.top();
-				batch.push_back(td);
-				pq.pop();
-				totalSize += td->totalSize();
-				if (totalSize >= kHighWater || pq.empty()) {
-					mergeProcessed(batch);
-					mergeUnprocessed(batch);
-					processIfNecessary();
-					batch.clear();
-					totalSize = 0;
-				}
-			}
-			updateCumulative();
-		}
-	}
-
-	Weight processedWeight() const {
-		return processedWeight_;
-	}
-
-	Weight unprocessedWeight() const {
-		return unprocessedWeight_;
-	}
-
-	bool haveUnprocessed() const {
-		return unprocessed_.size() > 0;
-	}
-
-	size_t totalSize() const {
-		return processed_.size() + unprocessed_.size();
-	}
-
-	long totalWeight() const {
-		return static_cast<long>(processedWeight_ + unprocessedWeight_);
-	}
-
-	// return the cdf on the t-digest
-	Value cdf(Value x) {
-		if (haveUnprocessed() || isDirty()) {
-			process();
-		}
-		return cdfProcessed(x);
-	}
-
-	bool isDirty() {
-		return processed_.size() > maxProcessed_ || unprocessed_.size() > maxUnprocessed_;
-	}
-
-	// return the cdf on the processed values
-	Value cdfProcessed(Value x) const {
-		if (processed_.empty()) {
-			// no data to examin_e
-
-			return 0.0;
-		} else if (processed_.size() == 1) {
-			// exactly one centroid, should have max_==min_
-			auto width = max_ - min_;
-			if (x < min_) {
-				return 0.0;
-			} else if (x > max_) {
-				return 1.0;
-			} else if (x - min_ <= width) {
-				// min_ and max_ are too close together to do any viable interpolation
-				return 0.5;
-			} else {
-				// interpolate if somehow we have weight > 0 and max_ != min_
-				return (x - min_) / (max_ - min_);
-			}
-		} else {
-			auto n = processed_.size();
-			if (x <= min_) {
-				return 0;
-			}
-
-			if (x >= max_) {
-				return 1;
-			}
-
-			// check for the left tail
-			if (x <= mean(0)) {
-
-				// note that this is different than mean(0) > min_ ... this guarantees interpolation works
-				if (mean(0) - min_ > 0) {
-					return (x - min_) / (mean(0) - min_) * weight(0) / processedWeight_ / 2.0;
-				} else {
-					return 0;
-				}
-			}
-
-			// and the right tail
-			if (x >= mean(n - 1)) {
-				if (max_ - mean(n - 1) > 0) {
-					return 1.0 - (max_ - x) / (max_ - mean(n - 1)) * weight(n - 1) / processedWeight_ / 2.0;
-				} else {
-					return 1;
-				}
-			}
-
-			CentroidComparator cc;
-			auto iter = std::upper_bound(processed_.cbegin(), processed_.cend(), Centroid(x, 0), cc);
-
-			auto i = std::distance(processed_.cbegin(), iter);
-			auto z1 = x - (iter - 1)->mean();
-			auto z2 = (iter)->mean() - x;
-			return weightedAverage(cumulative_[i - 1], z2, cumulative_[i], z1) / processedWeight_;
-		}
-	}
-
-	// this returns a quantile on the t-digest
-	Value quantile(Value q) {
-		if (haveUnprocessed() || isDirty()) {
-			process();
-		}
-		return quantileProcessed(q);
-	}
-
-	// this returns a quantile on the currently processed values without changing the t-digest
-	// the value will not represent the unprocessed values
-	Value quantileProcessed(Value q) const {
-		if (q < 0 || q > 1) {
-			return NAN;
-		}
-
-		if (processed_.size() == 0) {
-			// no sorted means no data, no way to get a quantile
-			return NAN;
-		} else if (processed_.size() == 1) {
-			// with one data point, all quantiles lead to Rome
-
-			return mean(0);
-		}
-
-		// we know that there are at least two sorted now
-		auto n = processed_.size();
-
-		// if values were stored in a sorted array, index would be the offset we are Weighterested in
-		const auto index = q * processedWeight_;
-
-		// at the boundaries, we return min_ or max_
-		if (index <= weight(0) / 2.0) {
-			return min_ + 2.0 * index / weight(0) * (mean(0) - min_);
-		}
-
-		auto iter = std::lower_bound(cumulative_.cbegin(), cumulative_.cend(), index);
-
-		if (iter + 1 != cumulative_.cend()) {
-			auto i = std::distance(cumulative_.cbegin(), iter);
-			auto z1 = index - *(iter - 1);
-			auto z2 = *(iter)-index;
-			// LOG(INFO) << "z2 " << z2 << " index " << index << " z1 " << z1;
-			return weightedAverage(mean(i - 1), z2, mean(i), z1);
-		}
-		auto z1 = index - processedWeight_ - weight(n - 1) / 2.0;
-		auto z2 = weight(n - 1) / 2 - z1;
-		return weightedAverage(mean(n - 1), z1, max_, z2);
-	}
-
-	Value compression() const {
-		return compression_;
-	}
-
-	void add(Value x) {
-		add(x, 1);
-	}
-
-	inline void compress() {
-		process();
-	}
-
-	// add a single centroid to the unprocessed vector, processing previously unprocessed sorted if our limit has
-	// been reached.
-	inline bool add(Value x, Weight w) {
-		if (std::isnan(x)) {
-			return false;
-		}
-		unprocessed_.push_back(Centroid(x, w));
-		unprocessedWeight_ += w;
-		processIfNecessary();
-		return true;
-	}
-
-	inline void add(std::vector<Centroid>::const_iterator iter, std::vector<Centroid>::const_iterator end) {
-		while (iter != end) {
-			const size_t diff = std::distance(iter, end);
-			const size_t room = maxUnprocessed_ - unprocessed_.size();
-			auto mid = iter + std::min(diff, room);
-			while (iter != mid) {
-				unprocessed_.push_back(*(iter++));
-			}
-			if (unprocessed_.size() >= maxUnprocessed_) {
-				process();
-			}
-		}
-	}
-
-private:
-	Value compression_;
-
-	Value min_ = std::numeric_limits<Value>::max();
-
-	Value max_ = std::numeric_limits<Value>::min();
-
-	Index maxProcessed_;
-
-	Index maxUnprocessed_;
-
-	Value processedWeight_ = 0.0;
-
-	Value unprocessedWeight_ = 0.0;
-
-	std::vector<Centroid> processed_;
-
-	std::vector<Centroid> unprocessed_;
-
-	std::vector<Weight> cumulative_;
-
-	// return mean of i-th centroid
-	inline Value mean(int i) const noexcept {
-		return processed_[i].mean();
-	}
-
-	// return weight of i-th centroid
-	inline Weight weight(int i) const noexcept {
-		return processed_[i].weight();
-	}
-
-	// append all unprocessed centroids into current unprocessed vector
-	void mergeUnprocessed(const std::vector<const TDigest *> &tdigests) {
-		if (tdigests.size() == 0) {
-			return;
-		}
-
-		size_t total = unprocessed_.size();
-		for (auto &td : tdigests) {
-			total += td->unprocessed_.size();
-		}
-
-		unprocessed_.reserve(total);
-		for (auto &td : tdigests) {
-			unprocessed_.insert(unprocessed_.end(), td->unprocessed_.cbegin(), td->unprocessed_.cend());
-			unprocessedWeight_ += td->unprocessedWeight_;
-		}
-	}
-
-	// merge all processed centroids together into a single sorted vector
-	void mergeProcessed(const std::vector<const TDigest *> &tdigests) {
-		if (tdigests.size() == 0) {
-			return;
-		}
-
-		size_t total = 0;
-		CentroidListQueue pq(CentroidListComparator {});
-		for (auto &td : tdigests) {
-			auto &sorted = td->processed_;
-			auto size = sorted.size();
-			if (size > 0) {
-				pq.push(CentroidList(sorted));
-				total += size;
-				processedWeight_ += td->processedWeight_;
-			}
-		}
-		if (total == 0) {
-			return;
-		}
-
-		if (processed_.size() > 0) {
-			pq.push(CentroidList(processed_));
-			total += processed_.size();
-		}
-
-		std::vector<Centroid> sorted;
-		sorted.reserve(total);
-
-		while (!pq.empty()) {
-			auto best = pq.top();
-			pq.pop();
-			sorted.push_back(*(best.iter));
-			if (best.advance()) {
-				pq.push(best);
-			}
-		}
-		processed_ = std::move(sorted);
-		if (processed_.size() > 0) {
-			min_ = std::min(min_, processed_[0].mean());
-			max_ = std::max(max_, (processed_.cend() - 1)->mean());
-		}
-	}
-
-	inline void processIfNecessary() {
-		if (isDirty()) {
-			process();
-		}
-	}
-
-	void updateCumulative() {
-		const auto n = processed_.size();
-		cumulative_.clear();
-		cumulative_.reserve(n + 1);
-		auto previous = 0.0;
-		for (Index i = 0; i < n; i++) {
-			auto current = weight(i);
-			auto halfCurrent = current / 2.0;
-			cumulative_.push_back(previous + halfCurrent);
-			previous = previous + current;
-		}
-		cumulative_.push_back(previous);
-	}
-
-	// merges unprocessed_ centroids and processed_ centroids together and processes them
-	// when complete, unprocessed_ will be empty and processed_ will have at most maxProcessed_ centroids
-	inline void process() {
-		CentroidComparator cc;
-		std::sort(unprocessed_.begin(), unprocessed_.end(), cc);
-		auto count = unprocessed_.size();
-		unprocessed_.insert(unprocessed_.end(), processed_.cbegin(), processed_.cend());
-		std::inplace_merge(unprocessed_.begin(), unprocessed_.begin() + count, unprocessed_.end(), cc);
-
-		processedWeight_ += unprocessedWeight_;
-		unprocessedWeight_ = 0;
-		processed_.clear();
-
-		processed_.push_back(unprocessed_[0]);
-		Weight wSoFar = unprocessed_[0].weight();
-		Weight wLimit = processedWeight_ * integratedQ(1.0);
-
-		auto end = unprocessed_.end();
-		for (auto iter = unprocessed_.cbegin() + 1; iter < end; iter++) {
-			auto &centroid = *iter;
-			Weight projectedW = wSoFar + centroid.weight();
-			if (projectedW <= wLimit) {
-				wSoFar = projectedW;
-				(processed_.end() - 1)->add(centroid);
-			} else {
-				auto k1 = integratedLocation(wSoFar / processedWeight_);
-				wLimit = processedWeight_ * integratedQ(k1 + 1.0);
-				wSoFar += centroid.weight();
-				processed_.emplace_back(centroid);
-			}
-		}
-		unprocessed_.clear();
-		min_ = std::min(min_, processed_[0].mean());
-		max_ = std::max(max_, (processed_.cend() - 1)->mean());
-		updateCumulative();
-	}
-
-	inline int checkWeights() {
-		return checkWeights(processed_, processedWeight_);
-	}
-
-	size_t checkWeights(const std::vector<Centroid> &sorted, Value total) {
-		size_t badWeight = 0;
-		auto k1 = 0.0;
-		auto q = 0.0;
-		for (auto iter = sorted.cbegin(); iter != sorted.cend(); iter++) {
-			auto w = iter->weight();
-			auto dq = w / total;
-			auto k2 = integratedLocation(q + dq);
-			if (k2 - k1 > 1 && w != 1) {
-				badWeight++;
-			}
-			if (k2 - k1 > 1.5 && w != 1) {
-				badWeight++;
-			}
-			q += dq;
-			k1 = k2;
-		}
-
-		return badWeight;
-	}
-
-	/**
-	 * Converts a quantile into a centroid scale value.  The centroid scale is nomin_ally
-	 * the number k of the centroid that a quantile point q should belong to.  Due to
-	 * round-offs, however, we can't align things perfectly without splitting points
-	 * and sorted.  We don't want to do that, so we have to allow for offsets.
-	 * In the end, the criterion is that any quantile range that spans a centroid
-	 * scale range more than one should be split across more than one centroid if
-	 * possible.  This won't be possible if the quantile range refers to a single point
-	 * or an already existing centroid.
-	 * <p/>
-	 * This mapping is steep near q=0 or q=1 so each centroid there will correspond to
-	 * less q range.  Near q=0.5, the mapping is flatter so that sorted there will
-	 * represent a larger chunk of quantiles.
-	 *
-	 * @param q The quantile scale value to be mapped.
-	 * @return The centroid scale value corresponding to q.
-	 */
-	inline Value integratedLocation(Value q) const {
-		return compression_ * (std::asin(2.0 * q - 1.0) + pi / 2) / pi;
-	}
-
-	inline Value integratedQ(Value k) const {
-		return (std::sin(std::min(k, compression_) * pi / compression_ - pi / 2) + 1) / 2;
-	}
-
-	/**
-	 * Same as {@link #weightedAverageSorted(Value, Value, Value, Value)} but flips
-	 * the order of the variables if <code>x2</code> is greater than
-	 * <code>x1</code>.
-	 */
-	static Value weightedAverage(Value x1, Value w1, Value x2, Value w2) {
-		return (x1 <= x2) ? weightedAverageSorted(x1, w1, x2, w2) : weightedAverageSorted(x2, w2, x1, w1);
-	}
-
-	/**
-	 * Compute the weighted average between <code>x1</code> with a weight of
-	 * <code>w1</code> and <code>x2</code> with a weight of <code>w2</code>.
-	 * This expects <code>x1</code> to be less than or equal to <code>x2</code>
-	 * and is guaranteed to return a number between <code>x1</code> and
-	 * <code>x2</code>.
-	 */
-	static Value weightedAverageSorted(Value x1, Value w1, Value x2, Value w2) {
-		const Value x = (x1 * w1 + x2 * w2) / (w1 + w2);
-		return std::max(x1, std::min(x, x2));
-	}
-
-	static Value interpolate(Value x, Value x0, Value x1) {
-		return (x - x0) / (x1 - x0);
-	}
-
-	/**
-	 * Computes an interpolated value of a quantile that is between two sorted.
-	 *
-	 * Index is the quantile desired multiplied by the total number of samples - 1.
-	 *
-	 * @param index              Denormalized quantile desired
-	 * @param previousIndex      The denormalized quantile corresponding to the center of the previous centroid.
-	 * @param nextIndex          The denormalized quantile corresponding to the center of the following centroid.
-	 * @param previousMean       The mean of the previous centroid.
-	 * @param nextMean           The mean of the following centroid.
-	 * @return  The interpolated mean.
-	 */
-	static Value quantile(Value index, Value previousIndex, Value nextIndex, Value previousMean, Value nextMean) {
-		const auto delta = nextIndex - previousIndex;
-		const auto previousWeight = (nextIndex - index) / delta;
-		const auto nextWeight = (index - previousIndex) / delta;
-		return previousMean * previousWeight + nextMean * nextWeight;
-	}
-};
-
-} // namespace tdigest
-
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/abs.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct AbsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return input < 0 ? -input : input;
-	}
-};
-
-template <>
-inline hugeint_t AbsOperator::Operation(hugeint_t input) {
-	const hugeint_t zero(0);
-	return (input < zero) ? -input : input;
-}
-
-struct TryAbsOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return AbsOperator::Operation<TA, TR>(input);
-	}
-};
-
-template <>
-inline int8_t TryAbsOperator::Operation(int8_t input) {
-	if (input == NumericLimits<int8_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%d)", input);
-	}
-	return input < 0 ? -input : input;
-}
-
-template <>
-inline int16_t TryAbsOperator::Operation(int16_t input) {
-	if (input == NumericLimits<int16_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%d)", input);
-	}
-	return input < 0 ? -input : input;
-}
-
-template <>
-inline int32_t TryAbsOperator::Operation(int32_t input) {
-	if (input == NumericLimits<int32_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%d)", input);
-	}
-	return input < 0 ? -input : input;
-}
-
-template <>
-inline int64_t TryAbsOperator::Operation(int64_t input) {
-	if (input == NumericLimits<int64_t>::Minimum()) {
-		throw OutOfRangeException("Overflow on abs(%d)", input);
-	}
-	return input < 0 ? -input : input;
-}
-
-template <>
-inline dtime_t TryAbsOperator::Operation(dtime_t input) {
-	return dtime_t(TryAbsOperator::Operation<int64_t, int64_t>(input.micros));
-}
-
-template <>
-inline interval_t TryAbsOperator::Operation(interval_t input) {
-	return {TryAbsOperator::Operation<int32_t, int32_t>(input.months),
-	        TryAbsOperator::Operation<int32_t, int32_t>(input.days),
-	        TryAbsOperator::Operation<int64_t, int64_t>(input.micros)};
-}
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/nested_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct ListFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-struct HistogramFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-	static AggregateFunction GetHistogramUnorderedMap(LogicalType &type);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/regression_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-struct RegrAvgxFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegrAvgyFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegrCountFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegrSlopeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegrR2Fun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegrSXXFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegrSYYFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegrSXYFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegrInterceptFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate/regression/regr_count.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct RegrCountFunction {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		*state = 0;
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		*target += source;
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		target[idx] = *state;
-	}
-	static bool IgnoreNull() {
-		return true;
-	}
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		*state += 1;
-	}
-};
-
-} // namespace duckdb
-// REGR_SLOPE(y, x)
-// Returns the slope of the linear regression line for non-null pairs in a group.
-// It is computed for non-null pairs using the following formula:
-// COVAR_POP(x,y) / VAR_POP(x)
-
-//! Input : Any numeric type
-//! Output : Double
-
-
-
-
-
-namespace duckdb {
-
-struct RegrSlopeState {
-	CovarState cov_pop;
-	StddevState var_pop;
-};
-
-struct RegrSlopeOperation {
-	template <class STATE>
-	static void Initialize(STATE *state) {
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop);
-	}
-
-	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, aggr_input_data, y_data, x_data,
-		                                                          bmask, amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, y_data, bmask, yidx);
-	}
-
-	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, aggr_input_data);
-	}
-
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->cov_pop.count == 0 || state->var_pop.count == 0) {
-			mask.SetInvalid(idx);
-		} else {
-			auto cov = state->cov_pop.co_moment / state->cov_pop.count;
-			auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
-			if (!Value::DoubleIsFinite(var_pop)) {
-				throw OutOfRangeException("VARPOP is out of range!");
-			}
-			if (var_pop == 0) {
-				mask.SetInvalid(idx);
-				return;
-			}
-			target[idx] = cov / var_pop;
-		}
-	}
-
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/cast_rules.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-//! Contains a list of rules for casting
-class CastRules {
-public:
-	//! Returns the cost of performing an implicit cost from "from" to "to", or -1 if an implicit cast is not possible
-	static int64_t ImplicitCast(const LogicalType &from, const LogicalType &to);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/compression/compression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct ConstantFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
-};
-
-struct UncompressedFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
-};
-
-struct RLEFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
-};
-
-struct BitpackingFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
-};
-
-struct DictionaryCompressionFun {
-	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/pragma/pragma_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct PragmaQueries {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaFunctions {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/blob_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct Base64Fun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct EncodeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/date_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct AgeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DateDiffFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DatePartFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DateSubFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DateTruncFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CurrentTimeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CurrentDateFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CurrentTimestampFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct EpochFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MakeDateFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StrfTimeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StrpTimeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ToIntervalFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/senary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-struct SenaryExecutor {
-	static const size_t NCOLS = 6;
-
-	template <class TA, class TB, class TC, class TD, class TE, class TF, class TR,
-	          class FUN = std::function<TR(TA, TB, TC, TD, TE, TF)>>
-	static void Execute(DataChunk &input, Vector &result, FUN fun) {
-		D_ASSERT(input.ColumnCount() >= NCOLS);
-		const auto count = input.size();
-
-		bool all_constant = true;
-		bool any_null = false;
-		for (const auto &v : input.data) {
-			if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-				if (ConstantVector::IsNull(v)) {
-					any_null = true;
-				}
-			} else {
-				all_constant = false;
-				break;
-			}
-		}
-
-		if (all_constant) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			if (any_null) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				auto adata = ConstantVector::GetData<TA>(input.data[0]);
-				auto bdata = ConstantVector::GetData<TB>(input.data[1]);
-				auto cdata = ConstantVector::GetData<TC>(input.data[2]);
-				auto ddata = ConstantVector::GetData<TD>(input.data[3]);
-				auto edata = ConstantVector::GetData<TE>(input.data[4]);
-				auto fdata = ConstantVector::GetData<TF>(input.data[5]);
-				auto result_data = ConstantVector::GetData<TR>(result);
-				result_data[0] = fun(*adata, *bdata, *cdata, *ddata, *edata, *fdata);
-			}
-		} else {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto result_data = FlatVector::GetData<TR>(result);
-			auto &result_validity = FlatVector::Validity(result);
-
-			bool all_valid = true;
-			vector<VectorData> vdata(NCOLS);
-			for (size_t c = 0; c < NCOLS; ++c) {
-				input.data[c].Orrify(count, vdata[c]);
-				all_valid = all_valid && vdata[c].validity.AllValid();
-			}
-
-			auto adata = (const TA *)(vdata[0].data);
-			auto bdata = (const TB *)(vdata[1].data);
-			auto cdata = (const TC *)(vdata[2].data);
-			auto ddata = (const TD *)(vdata[3].data);
-			auto edata = (const TE *)(vdata[4].data);
-			auto fdata = (const TF *)(vdata[5].data);
-
-			vector<idx_t> idx(NCOLS);
-			if (all_valid) {
-				for (idx_t r = 0; r < count; ++r) {
-					for (size_t c = 0; c < NCOLS; ++c) {
-						idx[c] = vdata[c].sel->get_index(r);
-					}
-					result_data[r] =
-					    fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]], fdata[idx[5]]);
-				}
-			} else {
-				for (idx_t r = 0; r < count; ++r) {
-					all_valid = true;
-					for (size_t c = 0; c < NCOLS; ++c) {
-						idx[c] = vdata[c].sel->get_index(r);
-						if (!vdata[c].validity.RowIsValid(idx[c])) {
-							result_validity.SetInvalid(r);
-							all_valid = false;
-							break;
-						}
-					}
-					if (all_valid) {
-						result_data[r] = fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]],
-						                     fdata[idx[5]]);
-					}
-				}
-			}
-		}
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/enum_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct EnumFirst {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct EnumLast {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct EnumRange {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct EnumRangeBoundary {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/generic_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class BoundFunctionExpression;
-
-struct AliasFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct HashFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LeastFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct GreatestFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StatsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct TypeOfFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ConstantOrNull {
-	static ScalarFunction GetFunction(LogicalType return_type);
-	static unique_ptr<FunctionData> Bind(Value value);
-	static bool IsConstantOrNull(BoundFunctionExpression &expr, const Value &val);
-};
-
-struct CurrentSettingFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SystemFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ExportAggregateFunctionBindData : public FunctionData {
-	unique_ptr<BoundAggregateExpression> aggregate;
-	explicit ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p);
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-};
-
-struct ExportAggregateFunction {
-	static unique_ptr<BoundAggregateExpression> Bind(unique_ptr<BoundAggregateExpression> child_aggregate);
-	static ScalarFunction GetCombine();
-	static ScalarFunction GetFinalize();
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/list_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Value;
-
-class ListStatistics : public BaseStatistics {
-public:
-	explicit ListStatistics(LogicalType type);
-
-	unique_ptr<BaseStatistics> child_stats;
-
-public:
-	void Merge(const BaseStatistics &other) override;
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-	void Serialize(FieldWriter &serializer) const override;
-	static unique_ptr<BaseStatistics> Deserialize(FieldReader &source, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	string ToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct ValueHashFunction {
-	uint64_t operator()(const Value &value) const {
-		return (uint64_t)value.Hash();
-	}
-};
-
-struct ValueEquality {
-	bool operator()(const Value &a, const Value &b) const {
-		return Value::NotDistinctFrom(a, b);
-	}
-};
-
-template <typename T>
-using value_map_t = unordered_map<Value, T, ValueHashFunction, ValueEquality>;
-
-using value_set_t = unordered_set<Value, ValueHashFunction, ValueEquality>;
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/math_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct AbsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SignFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CeilFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct FloorFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RoundFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DegreesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RadiansFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RandomFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SetseedFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CbrtFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ExpFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct Log2Fun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct Log10Fun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LnFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PowFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SqrtFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PiFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitCountFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct GammaFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LogGammaFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct FactorialFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct NextAfterFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct EvenFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct IsNanFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct IsInfiniteFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct IsFiniteFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/trigonometric_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct SinFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CosFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct TanFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct AsinFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct AcosFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct AtanFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CotFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct Atan2Fun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/uuid_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct UUIDFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct AddFun {
-	static ScalarFunction GetFunction(const LogicalType &type);
-	static ScalarFunction GetFunction(const LogicalType &left_type, const LogicalType &right_type);
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SubtractFun {
-	static ScalarFunction GetFunction(const LogicalType &type);
-	static ScalarFunction GetFunction(const LogicalType &left_type, const LogicalType &right_type);
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MultiplyFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DivideFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ModFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LeftShiftFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RightShiftFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitwiseAndFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitwiseOrFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitwiseXorFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitwiseNotFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/sequence_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct NextvalFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CurrvalFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/regexp.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct RegexpMatchesBindData : public FunctionData {
-	RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string);
-	~RegexpMatchesBindData() override;
-
-	duckdb_re2::RE2::Options options;
-	string constant_string;
-	bool constant_pattern;
-	string range_min;
-	string range_max;
-	bool range_success;
-
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-};
-
-struct RegexpReplaceBindData : public FunctionData {
-	duckdb_re2::RE2::Options options;
-	bool global_replace;
-
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-};
-
-struct RegexpExtractBindData : public FunctionData {
-	RegexpExtractBindData(bool constant_pattern, const string &pattern, const string &group_string_p);
-
-	const bool constant_pattern;
-	const string constant_string;
-
-	const string group_string;
-	const duckdb_re2::StringPiece rewrite;
-
-	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/struct_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Value;
-
-class StructStatistics : public BaseStatistics {
-public:
-	explicit StructStatistics(LogicalType type);
-
-	vector<unique_ptr<BaseStatistics>> child_stats;
-
-public:
-	void Merge(const BaseStatistics &other) override;
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	string ToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/arrow.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/thread.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <thread>
-
-namespace duckdb {
-using std::thread;
-}
-
-
-
-namespace duckdb {
-//===--------------------------------------------------------------------===//
-// Arrow Variable Size Types
-//===--------------------------------------------------------------------===//
-enum class ArrowVariableSizeType : uint8_t { FIXED_SIZE = 0, NORMAL = 1, SUPER_SIZE = 2 };
-
-//===--------------------------------------------------------------------===//
-// Arrow Time/Date Types
-//===--------------------------------------------------------------------===//
-enum class ArrowDateTimeType : uint8_t {
-	MILLISECONDS = 0,
-	MICROSECONDS = 1,
-	NANOSECONDS = 2,
-	SECONDS = 3,
-	DAYS = 4,
-	MONTHS = 5
-};
-
-struct ArrowConvertData {
-	ArrowConvertData(LogicalType type) : dictionary_type(type) {};
-	ArrowConvertData() {};
-	//! Hold type of dictionary
-	LogicalType dictionary_type;
-	//! If its a variable size type (e.g., strings, blobs, lists) holds which type it is
-	vector<pair<ArrowVariableSizeType, idx_t>> variable_sz_type;
-	//! If this is a date/time holds its precision
-	vector<ArrowDateTimeType> date_time_precision;
-};
-
-typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(
-    uintptr_t stream_factory_ptr, pair<unordered_map<idx_t, string>, vector<string>> &project_columns,
-    TableFilterSet *filters);
-typedef void (*stream_factory_get_schema_t)(uintptr_t stream_factory_ptr, ArrowSchemaWrapper &schema);
-
-struct ArrowScanFunctionData : public PyTableFunctionData {
-	ArrowScanFunctionData(idx_t rows_per_thread_p, stream_factory_produce_t scanner_producer_p,
-	                      uintptr_t stream_factory_ptr_p)
-	    : lines_read(0), rows_per_thread(rows_per_thread_p), stream_factory_ptr(stream_factory_ptr_p),
-	      scanner_producer(scanner_producer_p), number_of_rows(0) {
-	}
-	//! This holds the original list type (col_idx, [ArrowListType,size])
-	unordered_map<idx_t, unique_ptr<ArrowConvertData>> arrow_convert_data;
-	atomic<idx_t> lines_read;
-	ArrowSchemaWrapper schema_root;
-	idx_t rows_per_thread;
-	//! Pointer to the scanner factory
-	uintptr_t stream_factory_ptr;
-	//! Pointer to the scanner factory produce
-	stream_factory_produce_t scanner_producer;
-	//! Number of rows (Used in cardinality and progress bar)
-	int64_t number_of_rows;
-};
-
-struct ArrowScanLocalState : public LocalTableFunctionState {
-	explicit ArrowScanLocalState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(move(current_chunk)) {
-	}
-
-	unique_ptr<ArrowArrayStreamWrapper> stream;
-	shared_ptr<ArrowArrayWrapper> chunk;
-	idx_t chunk_offset = 0;
-	vector<column_t> column_ids;
-	//! Store child vectors for Arrow Dictionary Vectors (col-idx,vector)
-	unordered_map<idx_t, unique_ptr<Vector>> arrow_dictionary_vectors;
-	TableFilterSet *filters = nullptr;
-};
-
-struct ArrowScanGlobalState : public GlobalTableFunctionState {
-	unique_ptr<ArrowArrayStreamWrapper> stream;
-	mutex main_mutex;
-	bool ready = false;
-	idx_t max_threads = 1;
-
-	idx_t MaxThreads() const override {
-		return max_threads;
-	}
-};
-
-struct ArrowTableFunction {
-public:
-	static void RegisterFunction(BuiltinFunctions &set);
-
-private:
-	//! Binds an arrow table
-	static unique_ptr<FunctionData> ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
-	                                              vector<LogicalType> &return_types, vector<string> &names);
-	//! Actual conversion from Arrow to DuckDB
-	static void ArrowToDuckDB(ArrowScanLocalState &scan_state,
-	                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
-	                          DataChunk &output, idx_t start);
-
-	//! Initialize Global State
-	static unique_ptr<GlobalTableFunctionState> ArrowScanInitGlobal(ClientContext &context,
-	                                                                TableFunctionInitInput &input);
-
-	//! Initialize Local State
-	static unique_ptr<LocalTableFunctionState> ArrowScanInitLocal(ExecutionContext &context,
-	                                                              TableFunctionInitInput &input,
-	                                                              GlobalTableFunctionState *global_state);
-
-	//! Scan Function
-	static void ArrowScanFunction(ClientContext &context, TableFunctionInput &data, DataChunk &output);
-
-	//! Defines Maximum Number of Threads
-	static idx_t ArrowScanMaxThreads(ClientContext &context, const FunctionData *bind_data);
-
-	//! -----Utility Functions:-----
-	//! Gets Arrow Table's Cardinality
-	static unique_ptr<NodeStatistics> ArrowScanCardinality(ClientContext &context, const FunctionData *bind_data);
-	//! Gets the progress on the table scan, used for Progress Bars
-	static double ArrowProgress(ClientContext &context, const FunctionData *bind_data,
-	                            const GlobalTableFunctionState *global_state);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/range.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct CheckpointFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct GlobTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RangeTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RepeatTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct UnnestTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/read_csv.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct BaseCSVData : public TableFunctionData {
-	//! The file path of the CSV file to read or write
-	vector<string> files;
-	//! The CSV reader options
-	BufferedCSVReaderOptions options;
-
-	void Finalize();
-};
-
-struct WriteCSVData : public BaseCSVData {
-	WriteCSVData(string file_path, vector<LogicalType> sql_types, vector<string> names) : sql_types(move(sql_types)) {
-		files.push_back(move(file_path));
-		options.names = move(names);
-	}
-
-	//! The SQL types to write
-	vector<LogicalType> sql_types;
-	//! The newline string to write
-	string newline = "\n";
-	//! Whether or not we are writing a simple CSV (delimiter, quote and escape are all 1 byte in length)
-	bool is_simple;
-	//! The size of the CSV file (in bytes) that we buffer before we flush it to disk
-	idx_t flush_size = 4096 * 8;
-};
-
-struct ReadCSVData : public BaseCSVData {
-	//! The expected SQL types to read
-	vector<LogicalType> sql_types;
-	//! The initial reader (if any): this is used when automatic detection is used during binding.
-	//! In this case, the CSV reader is already created and might as well be re-used.
-	unique_ptr<BufferedCSVReader> initial_reader;
-};
-
-struct CSVCopyFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ReadCSVTableFunction {
-	static TableFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/system_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct PragmaCollations {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaFunctionPragma {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaTableInfo {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaStorageInfo {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaLastProfilingOutput {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaDetailedProfilingOutput {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaVersion {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaDatabaseList {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct PragmaDatabaseSize {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBSchemasFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBColumnsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBConstraintsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBDependenciesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBExtensionsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBFunctionsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBKeywordsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBIndexesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBSequencesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBSettingsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBTablesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBTypesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DuckDBViewsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct TestType {
-	TestType(LogicalType type_p, string name_p)
-	    : type(move(type_p)), name(move(name_p)), min_value(Value::MinimumValue(type)),
-	      max_value(Value::MaximumValue(type)) {
-	}
-	TestType(LogicalType type_p, string name_p, Value min, Value max)
-	    : type(move(type_p)), name(move(name_p)), min_value(move(min)), max_value(move(max)) {
-	}
-
-	LogicalType type;
-	string name;
-	Value min_value;
-	Value max_value;
-};
-
-struct TestAllTypesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-	static vector<TestType> GetTestTypes();
-};
-
-struct TestVectorTypesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table/summary.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct SummaryTableFunction {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node/select_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/aggregate_handling.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===----
-enum class AggregateHandling : uint8_t {
-	STANDARD_HANDLING,     // standard handling as in the SELECT clause
-	NO_AGGREGATES_ALLOWED, // no aggregates allowed: any aggregates in this node will result in an error
-	FORCE_AGGREGATES       // force aggregates: any non-aggregate select list entry will become a GROUP
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//! SelectNode represents a standard SELECT statement
-class SelectNode : public QueryNode {
-public:
-	SelectNode();
-
-	//! The projection list
-	vector<unique_ptr<ParsedExpression>> select_list;
-	//! The FROM clause
-	unique_ptr<TableRef> from_table;
-	//! The WHERE clause
-	unique_ptr<ParsedExpression> where_clause;
-	//! list of groups
-	GroupByNode groups;
-	//! HAVING clause
-	unique_ptr<ParsedExpression> having;
-	//! QUALIFY clause
-	unique_ptr<ParsedExpression> qualify;
-	//! Aggregate handling during binding
-	AggregateHandling aggregate_handling;
-	//! The SAMPLE clause
-	unique_ptr<SampleOptions> sample;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		return select_list;
-	}
-
-public:
-	//! Convert the query node to a string
-	string ToString() const override;
-
-	bool Equals(const QueryNode *other) const override;
-	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() const override;
-
-	//! Serializes a QueryNode to a stand-alone binary blob
-	void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a blob back into a QueryNode
-	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/capi_internal.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-#include <cstring>
-#include <cassert>
-
-#ifdef _WIN32
-#ifndef strdup
-#define strdup _strdup
-#endif
-#endif
-
-namespace duckdb {
-
-struct DatabaseData {
-	unique_ptr<DuckDB> database;
-};
-
-struct PreparedStatementWrapper {
-	unique_ptr<PreparedStatement> statement;
-	vector<Value> values;
-};
-
-struct ArrowResultWrapper {
-	unique_ptr<MaterializedQueryResult> result;
-	unique_ptr<DataChunk> current_chunk;
-	string timezone_config;
-};
-
-struct AppenderWrapper {
-	unique_ptr<Appender> appender;
-	string error;
-};
-
-enum class CAPIResultSetType : uint8_t {
-	CAPI_RESULT_TYPE_NONE = 0,
-	CAPI_RESULT_TYPE_MATERIALIZED,
-	CAPI_RESULT_TYPE_DEPRECATED
-};
-
-struct DuckDBResultData {
-	//! The underlying query result
-	unique_ptr<QueryResult> result;
-	// Results can only use either the new API or the old API, not a mix of the two
-	// They start off as "none" and switch to one or the other when an API method is used
-	CAPIResultSetType result_set_type;
-};
-
-duckdb_type ConvertCPPTypeToC(const LogicalType &type);
-LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type);
-idx_t GetCTypeSize(duckdb_type type);
-duckdb_state duckdb_translate_result(unique_ptr<QueryResult> result, duckdb_result *out);
-bool deprecated_materialize_result(duckdb_result *result);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_context_file_opener.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ClientContext;
-
-//! ClientContext-specific FileOpener implemenation.
-//! This object is owned by ClientContext and never outlives it.
-class ClientContextFileOpener : public FileOpener {
-public:
-	explicit ClientContextFileOpener(ClientContext &context_p) : context(context_p) {
-	}
-
-	bool TryGetCurrentSetting(const string &key, Value &result) override;
-
-private:
-	ClientContext &context;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/expression_rewriter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/logical_operator_matcher.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The LogicalOperatorMatcher class contains a set of matchers that can be used to match LogicalOperators
-class LogicalOperatorMatcher {
-public:
-	virtual ~LogicalOperatorMatcher() {
-	}
-
-	virtual bool Match(LogicalOperatorType type) = 0;
-};
-
-//! The SpecificLogicalTypeMatcher class matches only a single specified LogicalOperatorType
-class SpecificLogicalTypeMatcher : public LogicalOperatorMatcher {
-public:
-	explicit SpecificLogicalTypeMatcher(LogicalOperatorType type) : type(type) {
-	}
-
-	bool Match(LogicalOperatorType type) override {
-		return type == this->type;
-	}
-
-private:
-	LogicalOperatorType type;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class ExpressionRewriter;
-
-class Rule {
-public:
-	explicit Rule(ExpressionRewriter &rewriter) : rewriter(rewriter) {
-	}
-	virtual ~Rule() {
-	}
-
-	//! The expression rewriter this rule belongs to
-	ExpressionRewriter &rewriter;
-	//! The root
-	unique_ptr<LogicalOperatorMatcher> logical_root;
-	//! The expression matcher of the rule
-	unique_ptr<ExpressionMatcher> root;
-
-	virtual unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &fixed_point,
-	                                     bool is_root) = 0;
-};
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-class ClientContext;
-
-//! The ExpressionRewriter performs a set of fixed rewrite rules on the expressions that occur in a SQL statement
-class ExpressionRewriter : public LogicalOperatorVisitor {
-public:
-	explicit ExpressionRewriter(ClientContext &context) : context(context) {
-	}
-
-public:
-	//! The set of rules as known by the Expression Rewriter
-	vector<unique_ptr<Rule>> rules;
-
-	ClientContext &context;
-
-public:
-	void VisitOperator(LogicalOperator &op) override;
-	void VisitExpression(unique_ptr<Expression> *expression) override;
-
-	// Generates either a constant_or_null(child) expression
-	static unique_ptr<Expression> ConstantOrNull(unique_ptr<Expression> child, Value value);
-	static unique_ptr<Expression> ConstantOrNull(vector<unique_ptr<Expression>> children, Value value);
-
-private:
-	//! Apply a set of rules to a specific expression
-	static unique_ptr<Expression> ApplyRules(LogicalOperator &op, const vector<Rule *> &rules,
-	                                         unique_ptr<Expression> expr, bool &changes_made, bool is_root = false);
-
-	LogicalOperator *op;
-	vector<Rule *> to_apply_rules;
-};
-
-} // namespace duckdb
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-class Binder;
-
-class Optimizer {
-public:
-	Optimizer(Binder &binder, ClientContext &context);
-
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
-
-	ClientContext &context;
-	Binder &binder;
-	ExpressionRewriter rewriter;
-
-private:
-	void RunOptimizer(OptimizerType type, const std::function<void()> &callback);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/drop_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class DropStatement : public SQLStatement {
-public:
-	DropStatement();
-
-	unique_ptr<DropInfo> info;
-
-protected:
-	DropStatement(const DropStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/planner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class PreparedStatementData;
-
-//! The planner creates a logical query plan from the parsed SQL statements
-//! using the Binder and LogicalPlanGenerator.
-class Planner {
-public:
-	explicit Planner(ClientContext &context);
-
-	void CreatePlan(unique_ptr<SQLStatement> statement);
-
-	unique_ptr<LogicalOperator> plan;
-	vector<string> names;
-	vector<LogicalType> types;
-	unordered_map<idx_t, vector<unique_ptr<Value>>> value_map;
-	vector<LogicalType> parameter_types;
-
-	shared_ptr<Binder> binder;
-	ClientContext &context;
-
-	StatementProperties properties;
-
-private:
-	void CreatePlan(SQLStatement &statement);
-	shared_ptr<PreparedStatementData> PrepareSQLStatement(unique_ptr<SQLStatement> statement);
-	void PlanPrepare(unique_ptr<SQLStatement> statement);
-	void PlanExecute(unique_ptr<SQLStatement> statement);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/relation_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class RelationStatement : public SQLStatement {
-public:
-	explicit RelationStatement(shared_ptr<Relation> relation);
-
-	shared_ptr<Relation> relation;
-
-protected:
-	RelationStatement(const RelationStatement &other) = default;
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/pragma_handler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/pragma_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class PragmaStatement : public SQLStatement {
-public:
-	PragmaStatement();
-
-	unique_ptr<PragmaInfo> info;
-
-protected:
-	PragmaStatement(const PragmaStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class ClientContext;
-class ClientContextLock;
-class SQLStatement;
-struct PragmaInfo;
-
-//! Pragma handler is responsible for converting certain pragma statements into new queries
-class PragmaHandler {
-public:
-	explicit PragmaHandler(ClientContext &context);
-
-	void HandlePragmaStatements(ClientContextLock &lock, vector<unique_ptr<SQLStatement>> &statements);
-
-private:
-	ClientContext &context;
-
-private:
-	//! Handles a pragma statement, (potentially) returning a new statement to replace the current one
-	string HandlePragma(SQLStatement *statement);
-
-	void HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatement>> &statements);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/settings.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class DatabaseInstance;
-struct DBConfig;
-
-struct AccessModeSetting {
-	static constexpr const char *Name = "access_mode";
-	static constexpr const char *Description = "Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct CheckpointThresholdSetting {
-	static constexpr const char *Name = "checkpoint_threshold";
-	static constexpr const char *Description =
-	    "The WAL size threshold at which to automatically trigger a checkpoint (e.g. 1GB)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DebugCheckpointAbort {
-	static constexpr const char *Name = "debug_checkpoint_abort";
-	static constexpr const char *Description =
-	    "DEBUG SETTING: trigger an abort while checkpointing for testing purposes";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DebugForceExternal {
-	static constexpr const char *Name = "debug_force_external";
-	static constexpr const char *Description =
-	    "DEBUG SETTING: force out-of-core computation for operators that support it, used for testing";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DebugForceNoCrossProduct {
-	static constexpr const char *Name = "debug_force_no_cross_product";
-	static constexpr const char *Description =
-	    "DEBUG SETTING: Force disable cross product generation when hyper graph isn't connected, used for testing";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DebugManyFreeListBlocks {
-	static constexpr const char *Name = "debug_many_free_list_blocks";
-	static constexpr const char *Description = "DEBUG SETTING: add additional blocks to the free list";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DebugWindowMode {
-	static constexpr const char *Name = "debug_window_mode";
-	static constexpr const char *Description = "DEBUG SETTING: switch window mode to use";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DefaultCollationSetting {
-	static constexpr const char *Name = "default_collation";
-	static constexpr const char *Description = "The collation setting used when none is specified";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DefaultOrderSetting {
-	static constexpr const char *Name = "default_order";
-	static constexpr const char *Description = "The order type used when none is specified (ASC or DESC)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DefaultNullOrderSetting {
-	static constexpr const char *Name = "default_null_order";
-	static constexpr const char *Description = "Null ordering used when none is specified (NULLS_FIRST or NULLS_LAST)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct DisabledOptimizersSetting {
-	static constexpr const char *Name = "disabled_optimizers";
-	static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct EnableExternalAccessSetting {
-	static constexpr const char *Name = "enable_external_access";
-	static constexpr const char *Description =
-	    "Allow the database to access external state (through e.g. loading/installing modules, COPY TO/FROM, CSV "
-	    "readers, pandas replacement scans, etc)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct EnableObjectCacheSetting {
-	static constexpr const char *Name = "enable_object_cache";
-	static constexpr const char *Description = "Whether or not object cache is used to cache e.g. Parquet metadata";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct EnableProfilingSetting {
-	static constexpr const char *Name = "enable_profiling";
-	static constexpr const char *Description =
-	    "Enables profiling, and sets the output format (JSON, QUERY_TREE, QUERY_TREE_OPTIMIZER)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct EnableProgressBarSetting {
-	static constexpr const char *Name = "enable_progress_bar";
-	static constexpr const char *Description =
-	    "Enables the progress bar, printing progress to the terminal for long queries";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct ExplainOutputSetting {
-	static constexpr const char *Name = "explain_output";
-	static constexpr const char *Description = "Output of EXPLAIN statements (ALL, OPTIMIZED_ONLY, PHYSICAL_ONLY)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct ExternalThreadsSetting {
-	static constexpr const char *Name = "external_threads";
-	static constexpr const char *Description = "The number of external threads that work on DuckDB tasks.";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct FileSearchPathSetting {
-	static constexpr const char *Name = "file_search_path";
-	static constexpr const char *Description = "A comma separated list of directories to search for input files";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct ForceCompressionSetting {
-	static constexpr const char *Name = "force_compression";
-	static constexpr const char *Description = "DEBUG SETTING: forces a specific compression method to be used";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct LogQueryPathSetting {
-	static constexpr const char *Name = "log_query_path";
-	static constexpr const char *Description =
-	    "Specifies the path to which queries should be logged (default: empty string, queries are not logged)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct MaximumExpressionDepthSetting {
-	static constexpr const char *Name = "max_expression_depth";
-	static constexpr const char *Description =
-	    "The maximum expression depth limit in the parser. WARNING: increasing this setting and using very deep "
-	    "expressions might lead to stack overflow errors.";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct MaximumMemorySetting {
-	static constexpr const char *Name = "max_memory";
-	static constexpr const char *Description = "The maximum memory of the system (e.g. 1GB)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct PerfectHashThresholdSetting {
-	static constexpr const char *Name = "perfect_ht_threshold";
-	static constexpr const char *Description = "Threshold in bytes for when to use a perfect hash table (default: 12)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct PreserveIdentifierCase {
-	static constexpr const char *Name = "preserve_identifier_case";
-	static constexpr const char *Description =
-	    "Whether or not to preserve the identifier case, instead of always lowercasing all non-quoted identifiers";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct PreserveInsertionOrder {
-	static constexpr const char *Name = "preserve_insertion_order";
-	static constexpr const char *Description =
-	    "Whether or not to preserve insertion order. If set to false the system is allowed to re-order any results "
-	    "that do not contain ORDER BY clauses.";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct ProfilerHistorySize {
-	static constexpr const char *Name = "profiler_history_size";
-	static constexpr const char *Description = "Sets the profiler history size";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct ProfileOutputSetting {
-	static constexpr const char *Name = "profile_output";
-	static constexpr const char *Description =
-	    "The file to which profile output should be saved, or empty to print to the terminal";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct ProfilingModeSetting {
-	static constexpr const char *Name = "profiling_mode";
-	static constexpr const char *Description = "The profiling mode (STANDARD or DETAILED)";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct ProgressBarTimeSetting {
-	static constexpr const char *Name = "progress_bar_time";
-	static constexpr const char *Description =
-	    "Sets the time (in milliseconds) how long a query needs to take before we start printing a progress bar";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct SchemaSetting {
-	static constexpr const char *Name = "schema";
-	static constexpr const char *Description =
-	    "Sets the default search schema. Equivalent to setting search_path to a single value.";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct SearchPathSetting {
-	static constexpr const char *Name = "search_path";
-	static constexpr const char *Description =
-	    "Sets the default search search path as a comma-separated list of values";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetLocal(ClientContext &context, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct TempDirectorySetting {
-	static constexpr const char *Name = "temp_directory";
-	static constexpr const char *Description = "Set the directory to which to write temp files";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-struct ThreadsSetting {
-	static constexpr const char *Name = "threads";
-	static constexpr const char *Description = "The number of total threads used by the system.";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static Value GetSetting(ClientContext &context);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/query_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class SelectStatement;
-
-class QueryRelation : public Relation {
-public:
-	QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt, string alias);
-	~QueryRelation();
-
-	unique_ptr<SelectStatement> select_stmt;
-	string alias;
-	vector<ColumnDefinition> columns;
-
-public:
-	static unique_ptr<SelectStatement> ParseStatement(ClientContext &context, const string &query, const string &error);
-	unique_ptr<QueryNode> GetQueryNode() override;
-	unique_ptr<TableRef> GetTableRef() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-private:
-	unique_ptr<SelectStatement> GetSelectStatement();
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/read_csv_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ReadCSVRelation : public Relation {
-public:
-	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, string csv_file, vector<ColumnDefinition> columns,
-	                bool auto_detect = false, string alias = string());
-
-	string csv_file;
-	bool auto_detect;
-	string alias;
-	vector<ColumnDefinition> columns;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-	unique_ptr<TableRef> GetTableRef() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/table_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class TableRelation : public Relation {
-public:
-	TableRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description);
-
-	unique_ptr<TableDescription> description;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-	unique_ptr<TableRef> GetTableRef() override;
-
-	void Update(const string &update, const string &condition = string()) override;
-	void Delete(const string &condition = string()) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/table_function_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class TableFunctionRelation : public Relation {
-public:
-	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
-	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr);
-
-	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
-	                      shared_ptr<Relation> input_relation_p = nullptr);
-
-	string name;
-	vector<Value> parameters;
-	named_parameter_map_t named_parameters;
-	vector<ColumnDefinition> columns;
-	shared_ptr<Relation> input_relation;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-	unique_ptr<TableRef> GetTableRef() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/value_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class ValueRelation : public Relation {
-public:
-	ValueRelation(const std::shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
-	              vector<string> names, string alias = "values");
-	ValueRelation(const std::shared_ptr<ClientContext> &context, const string &values, vector<string> names,
-	              string alias = "values");
-
-	vector<vector<unique_ptr<ParsedExpression>>> expressions;
-	vector<string> names;
-	vector<ColumnDefinition> columns;
-	string alias;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-	unique_ptr<TableRef> GetTableRef() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/view_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ViewRelation : public Relation {
-public:
-	ViewRelation(const std::shared_ptr<ClientContext> &context, string schema_name, string view_name);
-
-	string schema_name;
-	string view_name;
-	vector<ColumnDefinition> columns;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-	unique_ptr<TableRef> GetTableRef() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/connection_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class DatabaseInstance;
-
-class ConnectionManager {
-public:
-	ConnectionManager() {
-	}
-
-	void AddConnection(ClientContext &context) {
-		lock_guard<mutex> lock(connections_lock);
-		connections.insert(make_pair(&context, weak_ptr<ClientContext>(context.shared_from_this())));
-	}
-
-	void RemoveConnection(ClientContext &context) {
-		lock_guard<mutex> lock(connections_lock);
-		connections.erase(&context);
-	}
-
-	vector<shared_ptr<ClientContext>> GetConnectionList() {
-		vector<shared_ptr<ClientContext>> result;
-		for (auto &it : connections) {
-			auto connection = it.second.lock();
-			if (!connection) {
-				connections.erase(it.first);
-				continue;
-			} else {
-				result.push_back(move(connection));
-			}
-		}
-
-		return result;
-	}
-
-	static ConnectionManager &Get(DatabaseInstance &db);
-	static ConnectionManager &Get(ClientContext &context);
-
-public:
-	mutex connections_lock;
-	unordered_map<ClientContext *, weak_ptr<ClientContext>> connections;
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
-// See the end of this file for a list
-
-// taken from: https://github.com/yhirose/cpp-httplib/blob/v0.10.2/httplib.h
-// Note: some modifications are made to file
-
-
-//
-//  httplib.hpp
-//
-//  Copyright (c) 2021 Yuji Hirose. All rights reserved.
-//  MIT License
-//
-
-#ifndef CPPHTTPLIB_HTTPLIB_H
-#define CPPHTTPLIB_HTTPLIB_H
-
-/*
- * Configuration
- */
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-#define CPPHTTPLIB_NAMESPACE duckdb_httplib_openssl
-#else
-#define CPPHTTPLIB_NAMESPACE duckdb_httplib
-#endif
-
-#ifndef CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND
-#define CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_KEEPALIVE_MAX_COUNT
-#define CPPHTTPLIB_KEEPALIVE_MAX_COUNT 5
-#endif
-
-#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND
-#define CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND 300
-#endif
-
-#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND
-#define CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_READ_TIMEOUT_SECOND
-#define CPPHTTPLIB_READ_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_READ_TIMEOUT_USECOND
-#define CPPHTTPLIB_READ_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_WRITE_TIMEOUT_SECOND
-#define CPPHTTPLIB_WRITE_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_WRITE_TIMEOUT_USECOND
-#define CPPHTTPLIB_WRITE_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_IDLE_INTERVAL_SECOND
-#define CPPHTTPLIB_IDLE_INTERVAL_SECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_IDLE_INTERVAL_USECOND
-#ifdef _WIN32
-#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 10000
-#else
-#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 0
-#endif
-#endif
-
-#ifndef CPPHTTPLIB_REQUEST_URI_MAX_LENGTH
-#define CPPHTTPLIB_REQUEST_URI_MAX_LENGTH 8192
-#endif
-
-#ifndef CPPHTTPLIB_HEADER_MAX_LENGTH
-#define CPPHTTPLIB_HEADER_MAX_LENGTH 8192
-#endif
-
-#ifndef CPPHTTPLIB_REDIRECT_MAX_COUNT
-#define CPPHTTPLIB_REDIRECT_MAX_COUNT 20
-#endif
-
-#ifndef CPPHTTPLIB_PAYLOAD_MAX_LENGTH
-#define CPPHTTPLIB_PAYLOAD_MAX_LENGTH ((std::numeric_limits<size_t>::max)())
-#endif
-
-#ifndef CPPHTTPLIB_TCP_NODELAY
-#define CPPHTTPLIB_TCP_NODELAY false
-#endif
-
-#ifndef CPPHTTPLIB_RECV_BUFSIZ
-#define CPPHTTPLIB_RECV_BUFSIZ size_t(4096u)
-#endif
-
-#ifndef CPPHTTPLIB_COMPRESSION_BUFSIZ
-#define CPPHTTPLIB_COMPRESSION_BUFSIZ size_t(16384u)
-#endif
-
-#ifndef CPPHTTPLIB_THREAD_POOL_COUNT
-#define CPPHTTPLIB_THREAD_POOL_COUNT                                           \
-  ((std::max)(8u, std::thread::hardware_concurrency() > 0                      \
-                      ? std::thread::hardware_concurrency() - 1                \
-                      : 0))
-#endif
-
-#ifndef CPPHTTPLIB_RECV_FLAGS
-#define CPPHTTPLIB_RECV_FLAGS 0
-#endif
-
-#ifndef CPPHTTPLIB_SEND_FLAGS
-#define CPPHTTPLIB_SEND_FLAGS 0
-#endif
-
-#ifndef CPPHTTPLIB_LISTEN_BACKLOG
-#define CPPHTTPLIB_LISTEN_BACKLOG 5
-#endif
-
-/*
- * Headers
- */
-
-#ifdef _WIN32
-#ifndef _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_WARNINGS
-#endif //_CRT_SECURE_NO_WARNINGS
-
-#ifndef _CRT_NONSTDC_NO_DEPRECATE
-#define _CRT_NONSTDC_NO_DEPRECATE
-#endif //_CRT_NONSTDC_NO_DEPRECATE
-
-#if defined(_MSC_VER)
-#ifdef _WIN64
-using ssize_t = __int64;
-#else
-using ssize_t = int;
-#endif
-
-#if _MSC_VER < 1900
-#define snprintf _snprintf_s
-#endif
-#endif // _MSC_VER
-
-#ifndef S_ISREG
-#define S_ISREG(m) (((m)&S_IFREG) == S_IFREG)
-#endif // S_ISREG
-
-#ifndef S_ISDIR
-#define S_ISDIR(m) (((m)&S_IFDIR) == S_IFDIR)
-#endif // S_ISDIR
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif // NOMINMAX
-
-#include <io.h>
-#ifdef _WINSOCKAPI_
-#undef _WINSOCKAPI_
-#endif
-#include <winsock2.h>
-
-#include <wincrypt.h>
-#include <ws2tcpip.h>
-
-#ifndef WSA_FLAG_NO_HANDLE_INHERIT
-#define WSA_FLAG_NO_HANDLE_INHERIT 0x80
-#endif
-
-#ifdef _MSC_VER
-#pragma comment(lib, "ws2_32.lib")
-#pragma comment(lib, "crypt32.lib")
-#pragma comment(lib, "cryptui.lib")
-#endif
-
-#ifndef strcasecmp
-#define strcasecmp _stricmp
-#endif // strcasecmp
-
-using socket_t = SOCKET;
-#ifdef CPPHTTPLIB_USE_POLL
-#define poll(fds, nfds, timeout) WSAPoll(fds, nfds, timeout)
-#endif
-
-#else // not _WIN32
-
-#include <arpa/inet.h>
-#include <cstring>
-#include <ifaddrs.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#ifdef __linux__
-#include <resolv.h>
-#endif
-#include <netinet/tcp.h>
-#ifdef CPPHTTPLIB_USE_POLL
-#include <poll.h>
-#endif
-#include <csignal>
-#include <pthread.h>
-#include <sys/select.h>
-#include <sys/socket.h>
-#include <unistd.h>
-
-using socket_t = int;
-#ifndef INVALID_SOCKET
-#define INVALID_SOCKET (-1)
-#endif
-#endif //_WIN32
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <cassert>
-#include <cctype>
-#include <climits>
-#include <condition_variable>
-#include <errno.h>
-#include <fcntl.h>
-#include <fstream>
-#include <functional>
-#include <iomanip>
-#include <iostream>
-#include <list>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <random>
-#include <set>
-#include <sstream>
-#include <string>
-#include <sys/stat.h>
-#include <thread>
-
-
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-// these are defined in wincrypt.h and it breaks compilation if BoringSSL is
-// used
-#ifdef _WIN32
-#undef X509_NAME
-#undef X509_CERT_PAIR
-#undef X509_EXTENSIONS
-#undef PKCS7_SIGNER_INFO
-#endif
-
-#include <openssl/err.h>
-#include <openssl/md5.h>
-#include <openssl/ssl.h>
-#include <openssl/x509v3.h>
-
-#if defined(_WIN32) && defined(OPENSSL_USE_APPLINK)
-#include <openssl/applink.c>
-#endif
-
-#include <iostream>
-#include <sstream>
-
-// Disabled OpenSSL version check for CI
-//#if OPENSSL_VERSION_NUMBER < 0x1010100fL
-//#error Sorry, OpenSSL versions prior to 1.1.1 are not supported
-//#endif
-
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
-#include <openssl/crypto.h>
-inline const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *asn1) {
-	return M_ASN1_STRING_data(asn1);
-}
-#endif
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-#include <zlib.h>
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-#include <brotli/decode.h>
-#include <brotli/encode.h>
-#endif
-
-/*
- * Declaration
- */
-namespace CPPHTTPLIB_NAMESPACE {
-
-namespace detail {
-
-/*
- * Backport std::make_unique from C++14.
- *
- * NOTE: This code came up with the following stackoverflow post:
- * https://stackoverflow.com/questions/10149840/c-arrays-and-make-unique
- *
- */
-
-template <class T, class... Args>
-typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
-make_unique(Args &&...args) {
-	return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-template <class T>
-typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
-make_unique(std::size_t n) {
-	typedef typename std::remove_extent<T>::type RT;
-	return std::unique_ptr<T>(new RT[n]);
-}
-
-struct ci {
-	bool operator()(const std::string &s1, const std::string &s2) const {
-		return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(),
-		                                    s2.end(),
-		                                    [](unsigned char c1, unsigned char c2) {
-			                                    return ::tolower(c1) < ::tolower(c2);
-		                                    });
-	}
-};
-
-} // namespace detail
-
-using Headers = std::multimap<std::string, std::string, detail::ci>;
-
-using Params = std::multimap<std::string, std::string>;
-using Match = duckdb_re2::Match;
-using Regex = duckdb_re2::Regex;
-
-using Progress = std::function<bool(uint64_t current, uint64_t total)>;
-
-struct Response;
-using ResponseHandler = std::function<bool(const Response &response)>;
-
-struct MultipartFormData {
-	std::string name;
-	std::string content;
-	std::string filename;
-	std::string content_type;
-};
-using MultipartFormDataItems = std::vector<MultipartFormData>;
-using MultipartFormDataMap = std::multimap<std::string, MultipartFormData>;
-
-class DataSink {
-public:
-	DataSink() : os(&sb_), sb_(*this) {}
-
-	DataSink(const DataSink &) = delete;
-	DataSink &operator=(const DataSink &) = delete;
-	DataSink(DataSink &&) = delete;
-	DataSink &operator=(DataSink &&) = delete;
-
-	std::function<bool(const char *data, size_t data_len)> write;
-	std::function<void()> done;
-	std::function<bool()> is_writable;
-	std::ostream os;
-
-private:
-	class data_sink_streambuf : public std::streambuf {
-	public:
-		explicit data_sink_streambuf(DataSink &sink) : sink_(sink) {}
-
-	protected:
-		std::streamsize xsputn(const char *s, std::streamsize n) {
-			sink_.write(s, static_cast<size_t>(n));
-			return n;
-		}
-
-	private:
-		DataSink &sink_;
-	};
-
-	data_sink_streambuf sb_;
-};
-
-using ContentProvider =
-    std::function<bool(size_t offset, size_t length, DataSink &sink)>;
-
-using ContentProviderWithoutLength =
-    std::function<bool(size_t offset, DataSink &sink)>;
-
-using ContentProviderResourceReleaser = std::function<void(bool success)>;
-
-using ContentReceiverWithProgress =
-    std::function<bool(const char *data, size_t data_length, uint64_t offset,
-                       uint64_t total_length)>;
-
-using ContentReceiver =
-    std::function<bool(const char *data, size_t data_length)>;
-
-using MultipartContentHeader =
-    std::function<bool(const MultipartFormData &file)>;
-
-class ContentReader {
-public:
-	using Reader = std::function<bool(ContentReceiver receiver)>;
-	using MultipartReader = std::function<bool(MultipartContentHeader header,
-	                                           ContentReceiver receiver)>;
-
-	ContentReader(Reader reader, MultipartReader multipart_reader)
-	    : reader_(std::move(reader)),
-	      multipart_reader_(std::move(multipart_reader)) {}
-
-	bool operator()(MultipartContentHeader header,
-	                ContentReceiver receiver) const {
-		return multipart_reader_(std::move(header), std::move(receiver));
-	}
-
-	bool operator()(ContentReceiver receiver) const {
-		return reader_(std::move(receiver));
-	}
-
-	Reader reader_;
-	MultipartReader multipart_reader_;
-};
-
-using Range = std::pair<ssize_t, ssize_t>;
-using Ranges = std::vector<Range>;
-
-struct Request {
-	std::string method;
-	std::string path;
-	Headers headers;
-	std::string body;
-
-	std::string remote_addr;
-	int remote_port = -1;
-
-	// for server
-	std::string version;
-	std::string target;
-	Params params;
-	MultipartFormDataMap files;
-	Ranges ranges;
-	Match matches;
-
-	// for client
-	ResponseHandler response_handler;
-	ContentReceiverWithProgress content_receiver;
-	Progress progress;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	const SSL *ssl = nullptr;
-#endif
-
-	bool has_header(const char *key) const;
-	std::string get_header_value(const char *key, size_t id = 0) const;
-	template <typename T>
-	T get_header_value(const char *key, size_t id = 0) const;
-	size_t get_header_value_count(const char *key) const;
-	void set_header(const char *key, const char *val);
-	void set_header(const char *key, const std::string &val);
-
-	bool has_param(const char *key) const;
-	std::string get_param_value(const char *key, size_t id = 0) const;
-	size_t get_param_value_count(const char *key) const;
-
-	bool is_multipart_form_data() const;
-
-	bool has_file(const char *key) const;
-	MultipartFormData get_file_value(const char *key) const;
-
-	// private members...
-	size_t redirect_count_ = CPPHTTPLIB_REDIRECT_MAX_COUNT;
-	size_t content_length_ = 0;
-	ContentProvider content_provider_;
-	bool is_chunked_content_provider_ = false;
-	size_t authorization_count_ = 0;
-};
-
-struct Response {
-	std::string version;
-	int status = -1;
-	std::string reason;
-	Headers headers;
-	std::string body;
-	std::string location; // Redirect location
-
-	bool has_header(const char *key) const;
-	std::string get_header_value(const char *key, size_t id = 0) const;
-	template <typename T>
-	T get_header_value(const char *key, size_t id = 0) const;
-	size_t get_header_value_count(const char *key) const;
-	void set_header(const char *key, const char *val);
-	void set_header(const char *key, const std::string &val);
-
-	void set_redirect(const char *url, int status = 302);
-	void set_redirect(const std::string &url, int status = 302);
-	void set_content(const char *s, size_t n, const char *content_type);
-	void set_content(const std::string &s, const char *content_type);
-
-	void set_content_provider(
-	    size_t length, const char *content_type, ContentProvider provider,
-	    ContentProviderResourceReleaser resource_releaser = nullptr);
-
-	void set_content_provider(
-	    const char *content_type, ContentProviderWithoutLength provider,
-	    ContentProviderResourceReleaser resource_releaser = nullptr);
-
-	void set_chunked_content_provider(
-	    const char *content_type, ContentProviderWithoutLength provider,
-	    ContentProviderResourceReleaser resource_releaser = nullptr);
-
-	Response() = default;
-	Response(const Response &) = default;
-	Response &operator=(const Response &) = default;
-	Response(Response &&) = default;
-	Response &operator=(Response &&) = default;
-	~Response() {
-		if (content_provider_resource_releaser_) {
-			content_provider_resource_releaser_(content_provider_success_);
-		}
-	}
-
-	// private members...
-	size_t content_length_ = 0;
-	ContentProvider content_provider_;
-	ContentProviderResourceReleaser content_provider_resource_releaser_;
-	bool is_chunked_content_provider_ = false;
-	bool content_provider_success_ = false;
-};
-
-class Stream {
-public:
-	virtual ~Stream() = default;
-
-	virtual bool is_readable() const = 0;
-	virtual bool is_writable() const = 0;
-
-	virtual ssize_t read(char *ptr, size_t size) = 0;
-	virtual ssize_t write(const char *ptr, size_t size) = 0;
-	virtual void get_remote_ip_and_port(std::string &ip, int &port) const = 0;
-	virtual socket_t socket() const = 0;
-
-	template <typename... Args>
-	ssize_t write_format(const char *fmt, const Args &...args);
-	ssize_t write(const char *ptr);
-	ssize_t write(const std::string &s);
-};
-
-class TaskQueue {
-public:
-	TaskQueue() = default;
-	virtual ~TaskQueue() = default;
-
-	virtual void enqueue(std::function<void()> fn) = 0;
-	virtual void shutdown() = 0;
-
-	virtual void on_idle() {}
-};
-
-class ThreadPool : public TaskQueue {
-public:
-	explicit ThreadPool(size_t n) : shutdown_(false) {
-		while (n) {
-			threads_.emplace_back(worker(*this));
-			n--;
-		}
-	}
-
-	ThreadPool(const ThreadPool &) = delete;
-	~ThreadPool() override = default;
-
-	void enqueue(std::function<void()> fn) override {
-		std::unique_lock<std::mutex> lock(mutex_);
-		jobs_.push_back(std::move(fn));
-		cond_.notify_one();
-	}
-
-	void shutdown() override {
-		// Stop all worker threads...
-		{
-			std::unique_lock<std::mutex> lock(mutex_);
-			shutdown_ = true;
-		}
-
-		cond_.notify_all();
-
-		// Join...
-		for (auto &t : threads_) {
-			t.join();
-		}
-	}
-
-private:
-	struct worker {
-		explicit worker(ThreadPool &pool) : pool_(pool) {}
-
-		void operator()() {
-			for (;;) {
-				std::function<void()> fn;
-				{
-					std::unique_lock<std::mutex> lock(pool_.mutex_);
-
-					pool_.cond_.wait(
-					    lock, [&] { return !pool_.jobs_.empty() || pool_.shutdown_; });
-
-					if (pool_.shutdown_ && pool_.jobs_.empty()) { break; }
-
-					fn = pool_.jobs_.front();
-					pool_.jobs_.pop_front();
-				}
-
-				assert(true == static_cast<bool>(fn));
-				fn();
-			}
-		}
-
-		ThreadPool &pool_;
-	};
-	friend struct worker;
-
-	std::vector<std::thread> threads_;
-	std::list<std::function<void()>> jobs_;
-
-	bool shutdown_;
-
-	std::condition_variable cond_;
-	std::mutex mutex_;
-};
-
-using Logger = std::function<void(const Request &, const Response &)>;
-
-using SocketOptions = std::function<void(socket_t sock)>;
-
-void default_socket_options(socket_t sock);
-
-class Server {
-public:
-	using Handler = std::function<void(const Request &, Response &)>;
-
-	using ExceptionHandler =
-	    std::function<void(const Request &, Response &, std::exception &e)>;
-
-	enum class HandlerResponse {
-		Handled,
-		Unhandled,
-	};
-	using HandlerWithResponse =
-	    std::function<HandlerResponse(const Request &, Response &)>;
-
-	using HandlerWithContentReader = std::function<void(
-	    const Request &, Response &, const ContentReader &content_reader)>;
-
-	using Expect100ContinueHandler =
-	    std::function<int(const Request &, Response &)>;
-
-	Server();
-
-	virtual ~Server();
-
-	virtual bool is_valid() const;
-
-	Server &Get(const std::string &pattern, Handler handler);
-	Server &Post(const std::string &pattern, Handler handler);
-	Server &Post(const std::string &pattern, HandlerWithContentReader handler);
-	Server &Put(const std::string &pattern, Handler handler);
-	Server &Put(const std::string &pattern, HandlerWithContentReader handler);
-	Server &Patch(const std::string &pattern, Handler handler);
-	Server &Patch(const std::string &pattern, HandlerWithContentReader handler);
-	Server &Delete(const std::string &pattern, Handler handler);
-	Server &Delete(const std::string &pattern, HandlerWithContentReader handler);
-	Server &Options(const std::string &pattern, Handler handler);
-
-	bool set_base_dir(const std::string &dir,
-	                  const std::string &mount_point = std::string());
-	bool set_mount_point(const std::string &mount_point, const std::string &dir,
-	                     Headers headers = Headers());
-	bool remove_mount_point(const std::string &mount_point);
-	Server &set_file_extension_and_mimetype_mapping(const char *ext,
-	                                                const char *mime);
-	Server &set_file_request_handler(Handler handler);
-
-	Server &set_error_handler(HandlerWithResponse handler);
-	Server &set_error_handler(Handler handler);
-	Server &set_exception_handler(ExceptionHandler handler);
-	Server &set_pre_routing_handler(HandlerWithResponse handler);
-	Server &set_post_routing_handler(Handler handler);
-
-	Server &set_expect_100_continue_handler(Expect100ContinueHandler handler);
-	Server &set_logger(Logger logger);
-
-	Server &set_address_family(int family);
-	Server &set_tcp_nodelay(bool on);
-	Server &set_socket_options(SocketOptions socket_options);
-
-	Server &set_default_headers(Headers headers);
-
-	Server &set_keep_alive_max_count(size_t count);
-	Server &set_keep_alive_timeout(time_t sec);
-
-	Server &set_read_timeout(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	Server &set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-	Server &set_write_timeout(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	Server &set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-	Server &set_idle_interval(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	Server &set_idle_interval(const std::chrono::duration<Rep, Period> &duration);
-
-	Server &set_payload_max_length(size_t length);
-
-	bool bind_to_port(const char *host, int port, int socket_flags = 0);
-	int bind_to_any_port(const char *host, int socket_flags = 0);
-	bool listen_after_bind();
-
-	bool listen(const char *host, int port, int socket_flags = 0);
-
-	bool is_running() const;
-	void stop();
-
-	std::function<TaskQueue *(void)> new_task_queue;
-
-protected:
-	bool process_request(Stream &strm, bool close_connection,
-	                     bool &connection_closed,
-	                     const std::function<void(Request &)> &setup_request);
-
-	std::atomic<socket_t> svr_sock_;
-	size_t keep_alive_max_count_ = CPPHTTPLIB_KEEPALIVE_MAX_COUNT;
-	time_t keep_alive_timeout_sec_ = CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND;
-	time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND;
-	time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND;
-	time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND;
-	time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND;
-	time_t idle_interval_sec_ = CPPHTTPLIB_IDLE_INTERVAL_SECOND;
-	time_t idle_interval_usec_ = CPPHTTPLIB_IDLE_INTERVAL_USECOND;
-	size_t payload_max_length_ = CPPHTTPLIB_PAYLOAD_MAX_LENGTH;
-
-private:
-	using Handlers = std::vector<std::pair<Regex, Handler>>;
-	using HandlersForContentReader =
-	    std::vector<std::pair<Regex, HandlerWithContentReader>>;
-
-	socket_t create_server_socket(const char *host, int port, int socket_flags,
-	                              SocketOptions socket_options) const;
-	int bind_internal(const char *host, int port, int socket_flags);
-	bool listen_internal();
-
-	bool routing(Request &req, Response &res, Stream &strm);
-	bool handle_file_request(const Request &req, Response &res,
-	                         bool head = false);
-	bool dispatch_request(Request &req, Response &res, const Handlers &handlers);
-	bool
-	dispatch_request_for_content_reader(Request &req, Response &res,
-	                                    ContentReader content_reader,
-	                                    const HandlersForContentReader &handlers);
-
-	bool parse_request_line(const char *s, Request &req);
-	void apply_ranges(const Request &req, Response &res,
-	                  std::string &content_type, std::string &boundary);
-	bool write_response(Stream &strm, bool close_connection, const Request &req,
-	                    Response &res);
-	bool write_response_with_content(Stream &strm, bool close_connection,
-	                                 const Request &req, Response &res);
-	bool write_response_core(Stream &strm, bool close_connection,
-	                         const Request &req, Response &res,
-	                         bool need_apply_ranges);
-	bool write_content_with_provider(Stream &strm, const Request &req,
-	                                 Response &res, const std::string &boundary,
-	                                 const std::string &content_type);
-	bool read_content(Stream &strm, Request &req, Response &res);
-	bool
-	read_content_with_content_receiver(Stream &strm, Request &req, Response &res,
-	                                   ContentReceiver receiver,
-	                                   MultipartContentHeader multipart_header,
-	                                   ContentReceiver multipart_receiver);
-	bool read_content_core(Stream &strm, Request &req, Response &res,
-	                       ContentReceiver receiver,
-	                       MultipartContentHeader mulitpart_header,
-	                       ContentReceiver multipart_receiver);
-
-	virtual bool process_and_close_socket(socket_t sock);
-
-	struct MountPointEntry {
-		std::string mount_point;
-		std::string base_dir;
-		Headers headers;
-	};
-	std::vector<MountPointEntry> base_dirs_;
-
-	std::atomic<bool> is_running_;
-	std::map<std::string, std::string> file_extension_and_mimetype_map_;
-	Handler file_request_handler_;
-	Handlers get_handlers_;
-	Handlers post_handlers_;
-	HandlersForContentReader post_handlers_for_content_reader_;
-	Handlers put_handlers_;
-	HandlersForContentReader put_handlers_for_content_reader_;
-	Handlers patch_handlers_;
-	HandlersForContentReader patch_handlers_for_content_reader_;
-	Handlers delete_handlers_;
-	HandlersForContentReader delete_handlers_for_content_reader_;
-	Handlers options_handlers_;
-	HandlerWithResponse error_handler_;
-	ExceptionHandler exception_handler_;
-	HandlerWithResponse pre_routing_handler_;
-	Handler post_routing_handler_;
-	Logger logger_;
-	Expect100ContinueHandler expect_100_continue_handler_;
-
-	int address_family_ = AF_UNSPEC;
-	bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY;
-	SocketOptions socket_options_ = default_socket_options;
-
-	Headers default_headers_;
-};
-
-enum class Error {
-	Success = 0,
-	Unknown,
-	Connection,
-	BindIPAddress,
-	Read,
-	Write,
-	ExceedRedirectCount,
-	Canceled,
-	SSLConnection,
-	SSLLoadingCerts,
-	SSLServerVerification,
-	UnsupportedMultipartBoundaryChars,
-	Compression,
-	ConnectionTimeout,
-};
-
-std::string to_string(const Error error);
-
-std::ostream &operator<<(std::ostream &os, const Error &obj);
-
-class Result {
-public:
-	Result(std::unique_ptr<Response> &&res, Error err,
-	       Headers &&request_headers = Headers{})
-	    : res_(std::move(res)), err_(err),
-	      request_headers_(std::move(request_headers)) {}
-	// Response
-	operator bool() const { return res_ != nullptr; }
-	bool operator==(std::nullptr_t) const { return res_ == nullptr; }
-	bool operator!=(std::nullptr_t) const { return res_ != nullptr; }
-	const Response &value() const { return *res_; }
-	Response &value() { return *res_; }
-	const Response &operator*() const { return *res_; }
-	Response &operator*() { return *res_; }
-	const Response *operator->() const { return res_.get(); }
-	Response *operator->() { return res_.get(); }
-
-	// Error
-	Error error() const { return err_; }
-
-	// Request Headers
-	bool has_request_header(const char *key) const;
-	std::string get_request_header_value(const char *key, size_t id = 0) const;
-	template <typename T>
-	T get_request_header_value(const char *key, size_t id = 0) const;
-	size_t get_request_header_value_count(const char *key) const;
-
-private:
-	std::unique_ptr<Response> res_;
-	Error err_;
-	Headers request_headers_;
-};
-
-class ClientImpl {
-public:
-	explicit ClientImpl(const std::string &host);
-
-	explicit ClientImpl(const std::string &host, int port);
-
-	explicit ClientImpl(const std::string &host, int port,
-	                    const std::string &client_cert_path,
-	                    const std::string &client_key_path);
-
-	virtual ~ClientImpl();
-
-	virtual bool is_valid() const;
-
-	Result Get(const char *path);
-	Result Get(const char *path, const Headers &headers);
-	Result Get(const char *path, Progress progress);
-	Result Get(const char *path, const Headers &headers, Progress progress);
-	Result Get(const char *path, ContentReceiver content_receiver);
-	Result Get(const char *path, const Headers &headers,
-	           ContentReceiver content_receiver);
-	Result Get(const char *path, ContentReceiver content_receiver,
-	           Progress progress);
-	Result Get(const char *path, const Headers &headers,
-	           ContentReceiver content_receiver, Progress progress);
-	Result Get(const char *path, ResponseHandler response_handler,
-	           ContentReceiver content_receiver);
-	Result Get(const char *path, const Headers &headers,
-	           ResponseHandler response_handler,
-	           ContentReceiver content_receiver);
-	Result Get(const char *path, ResponseHandler response_handler,
-	           ContentReceiver content_receiver, Progress progress);
-	Result Get(const char *path, const Headers &headers,
-	           ResponseHandler response_handler, ContentReceiver content_receiver,
-	           Progress progress);
-
-	Result Get(const char *path, const Params &params, const Headers &headers,
-	           Progress progress = nullptr);
-	Result Get(const char *path, const Params &params, const Headers &headers,
-	           ContentReceiver content_receiver, Progress progress = nullptr);
-	Result Get(const char *path, const Params &params, const Headers &headers,
-	           ResponseHandler response_handler, ContentReceiver content_receiver,
-	           Progress progress = nullptr);
-
-	Result Head(const char *path);
-	Result Head(const char *path, const Headers &headers);
-
-	Result Post(const char *path);
-	Result Post(const char *path, const char *body, size_t content_length,
-	            const char *content_type);
-	Result Post(const char *path, const Headers &headers, const char *body,
-	            size_t content_length, const char *content_type);
-	Result Post(const char *path, const std::string &body,
-	            const char *content_type);
-	Result Post(const char *path, const Headers &headers, const std::string &body,
-	            const char *content_type);
-	Result Post(const char *path, size_t content_length,
-	            ContentProvider content_provider, const char *content_type);
-	Result Post(const char *path, ContentProviderWithoutLength content_provider,
-	            const char *content_type);
-	Result Post(const char *path, const Headers &headers, size_t content_length,
-	            ContentProvider content_provider, const char *content_type);
-	Result Post(const char *path, const Headers &headers,
-	            ContentProviderWithoutLength content_provider,
-	            const char *content_type);
-	Result Post(const char *path, const Params &params);
-	Result Post(const char *path, const Headers &headers, const Params &params);
-	Result Post(const char *path, const MultipartFormDataItems &items);
-	Result Post(const char *path, const Headers &headers,
-	            const MultipartFormDataItems &items);
-	Result Post(const char *path, const Headers &headers,
-	            const MultipartFormDataItems &items, const std::string &boundary);
-
-	Result Put(const char *path);
-	Result Put(const char *path, const char *body, size_t content_length,
-	           const char *content_type);
-	Result Put(const char *path, const Headers &headers, const char *body,
-	           size_t content_length, const char *content_type);
-	Result Put(const char *path, const std::string &body,
-	           const char *content_type);
-	Result Put(const char *path, const Headers &headers, const std::string &body,
-	           const char *content_type);
-	Result Put(const char *path, size_t content_length,
-	           ContentProvider content_provider, const char *content_type);
-	Result Put(const char *path, ContentProviderWithoutLength content_provider,
-	           const char *content_type);
-	Result Put(const char *path, const Headers &headers, size_t content_length,
-	           ContentProvider content_provider, const char *content_type);
-	Result Put(const char *path, const Headers &headers,
-	           ContentProviderWithoutLength content_provider,
-	           const char *content_type);
-	Result Put(const char *path, const Params &params);
-	Result Put(const char *path, const Headers &headers, const Params &params);
-
-	Result Patch(const char *path);
-	Result Patch(const char *path, const char *body, size_t content_length,
-	             const char *content_type);
-	Result Patch(const char *path, const Headers &headers, const char *body,
-	             size_t content_length, const char *content_type);
-	Result Patch(const char *path, const std::string &body,
-	             const char *content_type);
-	Result Patch(const char *path, const Headers &headers,
-	             const std::string &body, const char *content_type);
-	Result Patch(const char *path, size_t content_length,
-	             ContentProvider content_provider, const char *content_type);
-	Result Patch(const char *path, ContentProviderWithoutLength content_provider,
-	             const char *content_type);
-	Result Patch(const char *path, const Headers &headers, size_t content_length,
-	             ContentProvider content_provider, const char *content_type);
-	Result Patch(const char *path, const Headers &headers,
-	             ContentProviderWithoutLength content_provider,
-	             const char *content_type);
-
-	Result Delete(const char *path);
-	Result Delete(const char *path, const Headers &headers);
-	Result Delete(const char *path, const char *body, size_t content_length,
-	              const char *content_type);
-	Result Delete(const char *path, const Headers &headers, const char *body,
-	              size_t content_length, const char *content_type);
-	Result Delete(const char *path, const std::string &body,
-	              const char *content_type);
-	Result Delete(const char *path, const Headers &headers,
-	              const std::string &body, const char *content_type);
-
-	Result Options(const char *path);
-	Result Options(const char *path, const Headers &headers);
-
-	bool send(Request &req, Response &res, Error &error);
-	Result send(const Request &req);
-
-	size_t is_socket_open() const;
-
-	void stop();
-
-	void set_hostname_addr_map(const std::map<std::string, std::string> addr_map);
-
-	void set_default_headers(Headers headers);
-
-	void set_address_family(int family);
-	void set_tcp_nodelay(bool on);
-	void set_socket_options(SocketOptions socket_options);
-
-	void set_connection_timeout(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	void
-	set_connection_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-	void set_read_timeout(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	void set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-	void set_write_timeout(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	void set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-	void set_basic_auth(const char *username, const char *password);
-	void set_bearer_token_auth(const char *token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	void set_digest_auth(const char *username, const char *password);
-#endif
-
-	void set_keep_alive(bool on);
-	void set_follow_location(bool on);
-
-	void set_url_encode(bool on);
-
-	void set_compress(bool on);
-
-	void set_decompress(bool on);
-
-	void set_interface(const char *intf);
-
-	void set_proxy(const char *host, int port);
-	void set_proxy_basic_auth(const char *username, const char *password);
-	void set_proxy_bearer_token_auth(const char *token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	void set_proxy_digest_auth(const char *username, const char *password);
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	void set_ca_cert_path(const char *ca_cert_file_path,
-	                      const char *ca_cert_dir_path = nullptr);
-	void set_ca_cert_store(X509_STORE *ca_cert_store);
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	void enable_server_certificate_verification(bool enabled);
-#endif
-
-	void set_logger(Logger logger);
-
-protected:
-	struct Socket {
-		socket_t sock = INVALID_SOCKET;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-		SSL *ssl = nullptr;
-#endif
-
-		bool is_open() const { return sock != INVALID_SOCKET; }
-	};
-
-	Result send_(Request &&req);
-
-	virtual bool create_and_connect_socket(Socket &socket, Error &error);
-
-	// All of:
-	//   shutdown_ssl
-	//   shutdown_socket
-	//   close_socket
-	// should ONLY be called when socket_mutex_ is locked.
-	// Also, shutdown_ssl and close_socket should also NOT be called concurrently
-	// with a DIFFERENT thread sending requests using that socket.
-	virtual void shutdown_ssl(Socket &socket, bool shutdown_gracefully);
-	void shutdown_socket(Socket &socket);
-	void close_socket(Socket &socket);
-
-	bool process_request(Stream &strm, Request &req, Response &res,
-	                     bool close_connection, Error &error);
-
-	bool write_content_with_provider(Stream &strm, const Request &req,
-	                                 Error &error);
-
-	void copy_settings(const ClientImpl &rhs);
-
-	// Socket endoint information
-	const std::string host_;
-	const int port_;
-	const std::string host_and_port_;
-
-	// Current open socket
-	Socket socket_;
-	mutable std::mutex socket_mutex_;
-	std::recursive_mutex request_mutex_;
-
-	// These are all protected under socket_mutex
-	size_t socket_requests_in_flight_ = 0;
-	std::thread::id socket_requests_are_from_thread_ = std::thread::id();
-	bool socket_should_be_closed_when_request_is_done_ = false;
-
-	// Hostname-IP map
-	std::map<std::string, std::string> addr_map_;
-
-	// Default headers
-	Headers default_headers_;
-
-	// Settings
-	std::string client_cert_path_;
-	std::string client_key_path_;
-
-	time_t connection_timeout_sec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND;
-	time_t connection_timeout_usec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND;
-	time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND;
-	time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND;
-	time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND;
-	time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND;
-
-	std::string basic_auth_username_;
-	std::string basic_auth_password_;
-	std::string bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	std::string digest_auth_username_;
-	std::string digest_auth_password_;
-#endif
-
-	bool keep_alive_ = false;
-	bool follow_location_ = false;
-
-	bool url_encode_ = true;
-
-	int address_family_ = AF_UNSPEC;
-	bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY;
-	SocketOptions socket_options_ = nullptr;
-
-	bool compress_ = false;
-	bool decompress_ = true;
-
-	std::string interface_;
-
-	std::string proxy_host_;
-	int proxy_port_ = -1;
-
-	std::string proxy_basic_auth_username_;
-	std::string proxy_basic_auth_password_;
-	std::string proxy_bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	std::string proxy_digest_auth_username_;
-	std::string proxy_digest_auth_password_;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	std::string ca_cert_file_path_;
-	std::string ca_cert_dir_path_;
-
-	X509_STORE *ca_cert_store_ = nullptr;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	bool server_certificate_verification_ = true;
-#endif
-
-	Logger logger_;
-
-private:
-	socket_t create_client_socket(Error &error) const;
-	bool read_response_line(Stream &strm, const Request &req, Response &res);
-	bool write_request(Stream &strm, Request &req, bool close_connection,
-	                   Error &error);
-	bool redirect(Request &req, Response &res, Error &error);
-	bool handle_request(Stream &strm, Request &req, Response &res,
-	                    bool close_connection, Error &error);
-	std::unique_ptr<Response> send_with_content_provider(
-	    Request &req,
-	    // const char *method, const char *path, const Headers &headers,
-	    const char *body, size_t content_length, ContentProvider content_provider,
-	    ContentProviderWithoutLength content_provider_without_length,
-	    const char *content_type, Error &error);
-	Result send_with_content_provider(
-	    const char *method, const char *path, const Headers &headers,
-	    const char *body, size_t content_length, ContentProvider content_provider,
-	    ContentProviderWithoutLength content_provider_without_length,
-	    const char *content_type);
-
-	std::string adjust_host_string(const std::string &host) const;
-
-	virtual bool process_socket(const Socket &socket,
-	                            std::function<bool(Stream &strm)> callback);
-	virtual bool is_ssl() const;
-};
-
-class Client {
-public:
-	// Universal interface
-	explicit Client(const std::string &scheme_host_port);
-
-	explicit Client(const std::string &scheme_host_port,
-	                const std::string &client_cert_path,
-	                const std::string &client_key_path);
-
-	// HTTP only interface
-	explicit Client(const std::string &host, int port);
-
-	explicit Client(const std::string &host, int port,
-	                const std::string &client_cert_path,
-	                const std::string &client_key_path);
-
-	Client(Client &&) = default;
-
-	~Client();
-
-	bool is_valid() const;
-
-	Result Get(const char *path);
-	Result Get(const char *path, const Headers &headers);
-	Result Get(const char *path, Progress progress);
-	Result Get(const char *path, const Headers &headers, Progress progress);
-	Result Get(const char *path, ContentReceiver content_receiver);
-	Result Get(const char *path, const Headers &headers,
-	           ContentReceiver content_receiver);
-	Result Get(const char *path, ContentReceiver content_receiver,
-	           Progress progress);
-	Result Get(const char *path, const Headers &headers,
-	           ContentReceiver content_receiver, Progress progress);
-	Result Get(const char *path, ResponseHandler response_handler,
-	           ContentReceiver content_receiver);
-	Result Get(const char *path, const Headers &headers,
-	           ResponseHandler response_handler,
-	           ContentReceiver content_receiver);
-	Result Get(const char *path, const Headers &headers,
-	           ResponseHandler response_handler, ContentReceiver content_receiver,
-	           Progress progress);
-	Result Get(const char *path, ResponseHandler response_handler,
-	           ContentReceiver content_receiver, Progress progress);
-
-	Result Get(const char *path, const Params &params, const Headers &headers,
-	           Progress progress = nullptr);
-	Result Get(const char *path, const Params &params, const Headers &headers,
-	           ContentReceiver content_receiver, Progress progress = nullptr);
-	Result Get(const char *path, const Params &params, const Headers &headers,
-	           ResponseHandler response_handler, ContentReceiver content_receiver,
-	           Progress progress = nullptr);
-
-	Result Head(const char *path);
-	Result Head(const char *path, const Headers &headers);
-
-	Result Post(const char *path);
-	Result Post(const char *path, const char *body, size_t content_length,
-	            const char *content_type);
-	Result Post(const char *path, const Headers &headers, const char *body,
-	            size_t content_length, const char *content_type);
-	Result Post(const char *path, const std::string &body,
-	            const char *content_type);
-	Result Post(const char *path, const Headers &headers, const std::string &body,
-	            const char *content_type);
-	Result Post(const char *path, size_t content_length,
-	            ContentProvider content_provider, const char *content_type);
-	Result Post(const char *path, ContentProviderWithoutLength content_provider,
-	            const char *content_type);
-	Result Post(const char *path, const Headers &headers, size_t content_length,
-	            ContentProvider content_provider, const char *content_type);
-	Result Post(const char *path, const Headers &headers,
-	            ContentProviderWithoutLength content_provider,
-	            const char *content_type);
-	Result Post(const char *path, const Params &params);
-	Result Post(const char *path, const Headers &headers, const Params &params);
-	Result Post(const char *path, const MultipartFormDataItems &items);
-	Result Post(const char *path, const Headers &headers,
-	            const MultipartFormDataItems &items);
-	Result Post(const char *path, const Headers &headers,
-	            const MultipartFormDataItems &items, const std::string &boundary);
-	Result Put(const char *path);
-	Result Put(const char *path, const char *body, size_t content_length,
-	           const char *content_type);
-	Result Put(const char *path, const Headers &headers, const char *body,
-	           size_t content_length, const char *content_type);
-	Result Put(const char *path, const std::string &body,
-	           const char *content_type);
-	Result Put(const char *path, const Headers &headers, const std::string &body,
-	           const char *content_type);
-	Result Put(const char *path, size_t content_length,
-	           ContentProvider content_provider, const char *content_type);
-	Result Put(const char *path, ContentProviderWithoutLength content_provider,
-	           const char *content_type);
-	Result Put(const char *path, const Headers &headers, size_t content_length,
-	           ContentProvider content_provider, const char *content_type);
-	Result Put(const char *path, const Headers &headers,
-	           ContentProviderWithoutLength content_provider,
-	           const char *content_type);
-	Result Put(const char *path, const Params &params);
-	Result Put(const char *path, const Headers &headers, const Params &params);
-	Result Patch(const char *path);
-	Result Patch(const char *path, const char *body, size_t content_length,
-	             const char *content_type);
-	Result Patch(const char *path, const Headers &headers, const char *body,
-	             size_t content_length, const char *content_type);
-	Result Patch(const char *path, const std::string &body,
-	             const char *content_type);
-	Result Patch(const char *path, const Headers &headers,
-	             const std::string &body, const char *content_type);
-	Result Patch(const char *path, size_t content_length,
-	             ContentProvider content_provider, const char *content_type);
-	Result Patch(const char *path, ContentProviderWithoutLength content_provider,
-	             const char *content_type);
-	Result Patch(const char *path, const Headers &headers, size_t content_length,
-	             ContentProvider content_provider, const char *content_type);
-	Result Patch(const char *path, const Headers &headers,
-	             ContentProviderWithoutLength content_provider,
-	             const char *content_type);
-
-	Result Delete(const char *path);
-	Result Delete(const char *path, const Headers &headers);
-	Result Delete(const char *path, const char *body, size_t content_length,
-	              const char *content_type);
-	Result Delete(const char *path, const Headers &headers, const char *body,
-	              size_t content_length, const char *content_type);
-	Result Delete(const char *path, const std::string &body,
-	              const char *content_type);
-	Result Delete(const char *path, const Headers &headers,
-	              const std::string &body, const char *content_type);
-
-	Result Options(const char *path);
-	Result Options(const char *path, const Headers &headers);
-
-	bool send(Request &req, Response &res, Error &error);
-	Result send(const Request &req);
-
-	size_t is_socket_open() const;
-
-	void stop();
-
-	void set_hostname_addr_map(const std::map<std::string, std::string> addr_map);
-
-	void set_default_headers(Headers headers);
-
-	void set_address_family(int family);
-	void set_tcp_nodelay(bool on);
-	void set_socket_options(SocketOptions socket_options);
-
-	void set_connection_timeout(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	void
-	set_connection_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-	void set_read_timeout(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	void set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-	void set_write_timeout(time_t sec, time_t usec = 0);
-	template <class Rep, class Period>
-	void set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
-	void set_basic_auth(const char *username, const char *password);
-	void set_bearer_token_auth(const char *token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	void set_digest_auth(const char *username, const char *password);
-#endif
-
-	void set_keep_alive(bool on);
-	void set_follow_location(bool on);
-
-	void set_url_encode(bool on);
-
-	void set_compress(bool on);
-
-	void set_decompress(bool on);
-
-	void set_interface(const char *intf);
-
-	void set_proxy(const char *host, int port);
-	void set_proxy_basic_auth(const char *username, const char *password);
-	void set_proxy_bearer_token_auth(const char *token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	void set_proxy_digest_auth(const char *username, const char *password);
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	void enable_server_certificate_verification(bool enabled);
-#endif
-
-	void set_logger(Logger logger);
-
-	// SSL
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	void set_ca_cert_path(const char *ca_cert_file_path,
-	                      const char *ca_cert_dir_path = nullptr);
-
-	void set_ca_cert_store(X509_STORE *ca_cert_store);
-
-	long get_openssl_verify_result() const;
-
-	SSL_CTX *ssl_context() const;
-#endif
-
-private:
-	std::unique_ptr<ClientImpl> cli_;
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	bool is_ssl_ = false;
-#endif
-};
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-class SSLServer : public Server {
-public:
-	SSLServer(const char *cert_path, const char *private_key_path,
-	          const char *client_ca_cert_file_path = nullptr,
-	          const char *client_ca_cert_dir_path = nullptr);
-
-	SSLServer(X509 *cert, EVP_PKEY *private_key,
-	          X509_STORE *client_ca_cert_store = nullptr);
-
-	SSLServer(
-	    const std::function<bool(SSL_CTX &ssl_ctx)> &setup_ssl_ctx_callback);
-
-	~SSLServer() override;
-
-	bool is_valid() const override;
-
-	SSL_CTX *ssl_context() const;
-
-private:
-	bool process_and_close_socket(socket_t sock) override;
-
-	SSL_CTX *ctx_;
-	std::mutex ctx_mutex_;
-};
-
-class SSLClient : public ClientImpl {
-public:
-	explicit SSLClient(const std::string &host);
-
-	explicit SSLClient(const std::string &host, int port);
-
-	explicit SSLClient(const std::string &host, int port,
-	                   const std::string &client_cert_path,
-	                   const std::string &client_key_path);
-
-	explicit SSLClient(const std::string &host, int port, X509 *client_cert,
-	                   EVP_PKEY *client_key);
-
-	~SSLClient() override;
-
-	bool is_valid() const override;
-
-	void set_ca_cert_store(X509_STORE *ca_cert_store);
-
-	long get_openssl_verify_result() const;
-
-	SSL_CTX *ssl_context() const;
-
-private:
-	bool create_and_connect_socket(Socket &socket, Error &error) override;
-	void shutdown_ssl(Socket &socket, bool shutdown_gracefully) override;
-	void shutdown_ssl_impl(Socket &socket, bool shutdown_socket);
-
-	bool process_socket(const Socket &socket,
-	                    std::function<bool(Stream &strm)> callback) override;
-	bool is_ssl() const override;
-
-	bool connect_with_proxy(Socket &sock, Response &res, bool &success,
-	                        Error &error);
-	bool initialize_ssl(Socket &socket, Error &error);
-
-	bool load_certs();
-
-	bool verify_host(X509 *server_cert) const;
-	bool verify_host_with_subject_alt_name(X509 *server_cert) const;
-	bool verify_host_with_common_name(X509 *server_cert) const;
-	bool check_host_name(const char *pattern, size_t pattern_len) const;
-
-	SSL_CTX *ctx_;
-	std::mutex ctx_mutex_;
-	std::once_flag initialize_cert_;
-
-	std::vector<std::string> host_components_;
-
-	long verify_result_ = 0;
-
-	friend class ClientImpl;
-};
-#endif
-
-/*
- * Implementation of template methods.
- */
-
-namespace detail {
-
-template <typename T, typename U>
-inline void duration_to_sec_and_usec(const T &duration, U callback) {
-	auto sec = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
-	auto usec = std::chrono::duration_cast<std::chrono::microseconds>(
-	                duration - std::chrono::seconds(sec))
-	                .count();
-	callback(sec, usec);
-}
-
-template <typename T>
-inline T get_header_value(const Headers & /*headers*/, const char * /*key*/,
-                          size_t /*id*/ = 0, uint64_t /*def*/ = 0) {}
-
-template <>
-inline uint64_t get_header_value<uint64_t>(const Headers &headers,
-                                           const char *key, size_t id,
-                                           uint64_t def) {
-	auto rng = headers.equal_range(key);
-	auto it = rng.first;
-	std::advance(it, static_cast<ssize_t>(id));
-	if (it != rng.second) {
-		return std::strtoull(it->second.data(), nullptr, 10);
-	}
-	return def;
-}
-
-} // namespace detail
-
-template <typename T>
-inline T Request::get_header_value(const char *key, size_t id) const {
-	return detail::get_header_value<T>(headers, key, id, 0);
-}
-
-template <typename T>
-inline T Response::get_header_value(const char *key, size_t id) const {
-	return detail::get_header_value<T>(headers, key, id, 0);
-}
-
-template <typename... Args>
-inline ssize_t Stream::write_format(const char *fmt, const Args &...args) {
-	const auto bufsiz = 2048;
-	std::array<char, bufsiz> buf{};
-
-#if defined(_MSC_VER) && _MSC_VER < 1900
-	auto sn = _snprintf_s(buf.data(), bufsiz, _TRUNCATE, fmt, args...);
-#else
-	auto sn = snprintf(buf.data(), buf.size() - 1, fmt, args...);
-#endif
-	if (sn <= 0) { return sn; }
-
-	auto n = static_cast<size_t>(sn);
-
-	if (n >= buf.size() - 1) {
-		std::vector<char> glowable_buf(buf.size());
-
-		while (n >= glowable_buf.size() - 1) {
-			glowable_buf.resize(glowable_buf.size() * 2);
-#if defined(_MSC_VER) && _MSC_VER < 1900
-			n = static_cast<size_t>(_snprintf_s(&glowable_buf[0], glowable_buf.size(),
-			                                    glowable_buf.size() - 1, fmt,
-			                                    args...));
-#else
-			n = static_cast<size_t>(
-			    snprintf(&glowable_buf[0], glowable_buf.size() - 1, fmt, args...));
-#endif
-		}
-		return write(&glowable_buf[0], n);
-	} else {
-		return write(buf.data(), n);
-	}
-}
-
-inline void default_socket_options(socket_t sock) {
-	int yes = 1;
-#ifdef _WIN32
-	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char *>(&yes),
-	           sizeof(yes));
-	setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
-	           reinterpret_cast<char *>(&yes), sizeof(yes));
-#else
-#ifdef SO_REUSEPORT
-	setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, reinterpret_cast<void *>(&yes),
-	           sizeof(yes));
-#else
-	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<void *>(&yes),
-	           sizeof(yes));
-#endif
-#endif
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_read_timeout(const std::chrono::duration<Rep, Period> &duration) {
-	detail::duration_to_sec_and_usec(
-	    duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); });
-	return *this;
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_write_timeout(const std::chrono::duration<Rep, Period> &duration) {
-	detail::duration_to_sec_and_usec(
-	    duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); });
-	return *this;
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_idle_interval(const std::chrono::duration<Rep, Period> &duration) {
-	detail::duration_to_sec_and_usec(
-	    duration, [&](time_t sec, time_t usec) { set_idle_interval(sec, usec); });
-	return *this;
-}
-
-inline std::string to_string(const Error error) {
-	switch (error) {
-	case Error::Success: return "Success";
-	case Error::Connection: return "Connection";
-	case Error::BindIPAddress: return "BindIPAddress";
-	case Error::Read: return "Read";
-	case Error::Write: return "Write";
-	case Error::ExceedRedirectCount: return "ExceedRedirectCount";
-	case Error::Canceled: return "Canceled";
-	case Error::SSLConnection: return "SSLConnection";
-	case Error::SSLLoadingCerts: return "SSLLoadingCerts";
-	case Error::SSLServerVerification: return "SSLServerVerification";
-	case Error::UnsupportedMultipartBoundaryChars:
-		return "UnsupportedMultipartBoundaryChars";
-	case Error::Compression: return "Compression";
-	case Error::ConnectionTimeout: return "ConnectionTimeout";
-	case Error::Unknown: return "Unknown";
-	default: break;
-	}
-
-	return "Invalid";
-}
-
-inline std::ostream &operator<<(std::ostream &os, const Error &obj) {
-	os << to_string(obj);
-	os << " (" << static_cast<std::underlying_type<Error>::type>(obj) << ')';
-	return os;
-}
-
-template <typename T>
-inline T Result::get_request_header_value(const char *key, size_t id) const {
-	return detail::get_header_value<T>(request_headers_, key, id, 0);
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_connection_timeout(
-    const std::chrono::duration<Rep, Period> &duration) {
-	detail::duration_to_sec_and_usec(duration, [&](time_t sec, time_t usec) {
-		set_connection_timeout(sec, usec);
-	});
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_read_timeout(
-    const std::chrono::duration<Rep, Period> &duration) {
-	detail::duration_to_sec_and_usec(
-	    duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); });
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_write_timeout(
-    const std::chrono::duration<Rep, Period> &duration) {
-	detail::duration_to_sec_and_usec(
-	    duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); });
-}
-
-template <class Rep, class Period>
-inline void Client::set_connection_timeout(
-    const std::chrono::duration<Rep, Period> &duration) {
-	cli_->set_connection_timeout(duration);
-}
-
-template <class Rep, class Period>
-inline void
-Client::set_read_timeout(const std::chrono::duration<Rep, Period> &duration) {
-	cli_->set_read_timeout(duration);
-}
-
-template <class Rep, class Period>
-inline void
-Client::set_write_timeout(const std::chrono::duration<Rep, Period> &duration) {
-	cli_->set_write_timeout(duration);
-}
-
-/*
- * Forward declarations and types that will be part of the .h file if split into
- * .h + .cc.
- */
-
-std::string hosted_at(const char *hostname);
-
-void hosted_at(const char *hostname, std::vector<std::string> &addrs);
-
-std::string append_query_params(const char *path, const Params &params);
-
-std::pair<std::string, std::string> make_range_header(Ranges ranges);
-
-std::pair<std::string, std::string>
-make_basic_authentication_header(const std::string &username,
-                                 const std::string &password,
-                                 bool is_proxy = false);
-
-namespace detail {
-
-std::string encode_query_param(const std::string &value);
-
-std::string decode_url(const std::string &s, bool convert_plus_to_space);
-
-void read_file(const std::string &path, std::string &out);
-
-std::string trim_copy(const std::string &s);
-
-void split(const char *b, const char *e, char d,
-           std::function<void(const char *, const char *)> fn);
-
-bool process_client_socket(socket_t sock, time_t read_timeout_sec,
-                           time_t read_timeout_usec, time_t write_timeout_sec,
-                           time_t write_timeout_usec,
-                           std::function<bool(Stream &)> callback);
-
-socket_t create_client_socket(
-    const char *host, const char *ip, int port, int address_family,
-    bool tcp_nodelay, SocketOptions socket_options,
-    time_t connection_timeout_sec, time_t connection_timeout_usec,
-    time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
-    time_t write_timeout_usec, const std::string &intf, Error &error);
-
-const char *get_header_value(const Headers &headers, const char *key,
-                             size_t id = 0, const char *def = nullptr);
-
-std::string params_to_query_str(const Params &params);
-
-void parse_query_text(const std::string &s, Params &params);
-
-bool parse_range_header(const std::string &s, Ranges &ranges);
-
-int close_socket(socket_t sock);
-
-ssize_t send_socket(socket_t sock, const void *ptr, size_t size, int flags);
-
-ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags);
-
-enum class EncodingType { None = 0, Gzip, Brotli };
-
-EncodingType encoding_type(const Request &req, const Response &res);
-
-class BufferStream : public Stream {
-public:
-	BufferStream() = default;
-	~BufferStream() override = default;
-
-	bool is_readable() const override;
-	bool is_writable() const override;
-	ssize_t read(char *ptr, size_t size) override;
-	ssize_t write(const char *ptr, size_t size) override;
-	void get_remote_ip_and_port(std::string &ip, int &port) const override;
-	socket_t socket() const override;
-
-	const std::string &get_buffer() const;
-
-private:
-	std::string buffer;
-	size_t position = 0;
-};
-
-class compressor {
-public:
-	virtual ~compressor() = default;
-
-	typedef std::function<bool(const char *data, size_t data_len)> Callback;
-	virtual bool compress(const char *data, size_t data_length, bool last,
-	                      Callback callback) = 0;
-};
-
-class decompressor {
-public:
-	virtual ~decompressor() = default;
-
-	virtual bool is_valid() const = 0;
-
-	typedef std::function<bool(const char *data, size_t data_len)> Callback;
-	virtual bool decompress(const char *data, size_t data_length,
-	                        Callback callback) = 0;
-};
-
-class nocompressor : public compressor {
-public:
-	virtual ~nocompressor() = default;
-
-	bool compress(const char *data, size_t data_length, bool /*last*/,
-	              Callback callback) override;
-};
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-class gzip_compressor : public compressor {
-public:
-	gzip_compressor();
-	~gzip_compressor();
-
-	bool compress(const char *data, size_t data_length, bool last,
-	              Callback callback) override;
-
-private:
-	bool is_valid_ = false;
-	z_stream strm_;
-};
-
-class gzip_decompressor : public decompressor {
-public:
-	gzip_decompressor();
-	~gzip_decompressor();
-
-	bool is_valid() const override;
-
-	bool decompress(const char *data, size_t data_length,
-	                Callback callback) override;
-
-private:
-	bool is_valid_ = false;
-	z_stream strm_;
-};
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-class brotli_compressor : public compressor {
-public:
-	brotli_compressor();
-	~brotli_compressor();
-
-	bool compress(const char *data, size_t data_length, bool last,
-	              Callback callback) override;
-
-private:
-	BrotliEncoderState *state_ = nullptr;
-};
-
-class brotli_decompressor : public decompressor {
-public:
-	brotli_decompressor();
-	~brotli_decompressor();
-
-	bool is_valid() const override;
-
-	bool decompress(const char *data, size_t data_length,
-	                Callback callback) override;
-
-private:
-	BrotliDecoderResult decoder_r;
-	BrotliDecoderState *decoder_s = nullptr;
-};
-#endif
-
-// NOTE: until the read size reaches `fixed_buffer_size`, use `fixed_buffer`
-// to store data. The call can set memory on stack for performance.
-class stream_line_reader {
-public:
-	stream_line_reader(Stream &strm, char *fixed_buffer,
-	                   size_t fixed_buffer_size);
-	const char *ptr() const;
-	size_t size() const;
-	bool end_with_crlf() const;
-	bool getline();
-
-private:
-	void append(char c);
-
-	Stream &strm_;
-	char *fixed_buffer_;
-	const size_t fixed_buffer_size_;
-	size_t fixed_buffer_used_size_ = 0;
-	std::string glowable_buffer_;
-};
-
-} // namespace detail
-
-// ----------------------------------------------------------------------------
-
-/*
- * Implementation that will be part of the .cc file if split into .h + .cc.
- */
-
-namespace detail {
-
-inline bool is_hex(char c, int &v) {
-	if (0x20 <= c && isdigit(c)) {
-		v = c - '0';
-		return true;
-	} else if ('A' <= c && c <= 'F') {
-		v = c - 'A' + 10;
-		return true;
-	} else if ('a' <= c && c <= 'f') {
-		v = c - 'a' + 10;
-		return true;
-	}
-	return false;
-}
-
-inline bool from_hex_to_i(const std::string &s, size_t i, size_t cnt,
-                          int &val) {
-	if (i >= s.size()) { return false; }
-
-	val = 0;
-	for (; cnt; i++, cnt--) {
-		if (!s[i]) { return false; }
-		int v = 0;
-		if (is_hex(s[i], v)) {
-			val = val * 16 + v;
-		} else {
-			return false;
-		}
-	}
-	return true;
-}
-
-inline std::string from_i_to_hex(size_t n) {
-	const char *charset = "0123456789abcdef";
-	std::string ret;
-	do {
-		ret = charset[n & 15] + ret;
-		n >>= 4;
-	} while (n > 0);
-	return ret;
-}
-
-inline size_t to_utf8(int code, char *buff) {
-	if (code < 0x0080) {
-		buff[0] = (code & 0x7F);
-		return 1;
-	} else if (code < 0x0800) {
-		buff[0] = static_cast<char>(0xC0 | ((code >> 6) & 0x1F));
-		buff[1] = static_cast<char>(0x80 | (code & 0x3F));
-		return 2;
-	} else if (code < 0xD800) {
-		buff[0] = static_cast<char>(0xE0 | ((code >> 12) & 0xF));
-		buff[1] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
-		buff[2] = static_cast<char>(0x80 | (code & 0x3F));
-		return 3;
-	} else if (code < 0xE000) { // D800 - DFFF is invalid...
-		return 0;
-	} else if (code < 0x10000) {
-		buff[0] = static_cast<char>(0xE0 | ((code >> 12) & 0xF));
-		buff[1] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
-		buff[2] = static_cast<char>(0x80 | (code & 0x3F));
-		return 3;
-	} else if (code < 0x110000) {
-		buff[0] = static_cast<char>(0xF0 | ((code >> 18) & 0x7));
-		buff[1] = static_cast<char>(0x80 | ((code >> 12) & 0x3F));
-		buff[2] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
-		buff[3] = static_cast<char>(0x80 | (code & 0x3F));
-		return 4;
-	}
-
-	// NOTREACHED
-	return 0;
-}
-
-// NOTE: This code came up with the following stackoverflow post:
-// https://stackoverflow.com/questions/180947/base64-decode-snippet-in-c
-inline std::string base64_encode(const std::string &in) {
-	static const auto lookup =
-	    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-	std::string out;
-	out.reserve(in.size());
-
-	int val = 0;
-	int valb = -6;
-
-	for (auto c : in) {
-		val = (val << 8) + static_cast<uint8_t>(c);
-		valb += 8;
-		while (valb >= 0) {
-			out.push_back(lookup[(val >> valb) & 0x3F]);
-			valb -= 6;
-		}
-	}
-
-	if (valb > -6) { out.push_back(lookup[((val << 8) >> (valb + 8)) & 0x3F]); }
-
-	while (out.size() % 4) {
-		out.push_back('=');
-	}
-
-	return out;
-}
-
-inline bool is_file(const std::string &path) {
-#ifdef _WIN32
-	return _access_s(path.c_str(), 0) == 0;
-#else
-	struct stat st;
-	return stat(path.c_str(), &st) >= 0 && S_ISREG(st.st_mode);
-#endif
-}
-
-inline bool is_dir(const std::string &path) {
-	struct stat st;
-	return stat(path.c_str(), &st) >= 0 && S_ISDIR(st.st_mode);
-}
-
-inline bool is_valid_path(const std::string &path) {
-	size_t level = 0;
-	size_t i = 0;
-
-	// Skip slash
-	while (i < path.size() && path[i] == '/') {
-		i++;
-	}
-
-	while (i < path.size()) {
-		// Read component
-		auto beg = i;
-		while (i < path.size() && path[i] != '/') {
-			i++;
-		}
-
-		auto len = i - beg;
-		assert(len > 0);
-
-		if (!path.compare(beg, len, ".")) {
-			;
-		} else if (!path.compare(beg, len, "..")) {
-			if (level == 0) { return false; }
-			level--;
-		} else {
-			level++;
-		}
-
-		// Skip slash
-		while (i < path.size() && path[i] == '/') {
-			i++;
-		}
-	}
-
-	return true;
-}
-
-inline std::string encode_query_param(const std::string &value) {
-	std::ostringstream escaped;
-	escaped.fill('0');
-	escaped << std::hex;
-
-	for (auto c : value) {
-		if (std::isalnum(static_cast<uint8_t>(c)) || c == '-' || c == '_' ||
-		    c == '.' || c == '!' || c == '~' || c == '*' || c == '\'' || c == '(' ||
-		    c == ')') {
-			escaped << c;
-		} else {
-			escaped << std::uppercase;
-			escaped << '%' << std::setw(2)
-			        << static_cast<int>(static_cast<unsigned char>(c));
-			escaped << std::nouppercase;
-		}
-	}
-
-	return escaped.str();
-}
-
-inline std::string encode_url(const std::string &s) {
-	std::string result;
-	result.reserve(s.size());
-
-	for (size_t i = 0; s[i]; i++) {
-		switch (s[i]) {
-		case ' ': result += "%20"; break;
-//		case '+': result += "%2B"; break;
-		case '\r': result += "%0D"; break;
-		case '\n': result += "%0A"; break;
-		case '\'': result += "%27"; break;
-		case ',': result += "%2C"; break;
-		// case ':': result += "%3A"; break; // ok? probably...
-		case ';': result += "%3B"; break;
-		default:
-			auto c = static_cast<uint8_t>(s[i]);
-			if (c >= 0x80) {
-				result += '%';
-				char hex[4];
-				auto len = snprintf(hex, sizeof(hex) - 1, "%02X", c);
-				assert(len == 2);
-				result.append(hex, static_cast<size_t>(len));
-			} else {
-				result += s[i];
-			}
-			break;
-		}
-	}
-
-	return result;
-}
-
-inline std::string decode_url(const std::string &s,
-                              bool convert_plus_to_space) {
-	std::string result;
-
-	for (size_t i = 0; i < s.size(); i++) {
-		if (s[i] == '%' && i + 1 < s.size()) {
-			if (s[i + 1] == 'u') {
-				int val = 0;
-				if (from_hex_to_i(s, i + 2, 4, val)) {
-					// 4 digits Unicode codes
-					char buff[4];
-					size_t len = to_utf8(val, buff);
-					if (len > 0) { result.append(buff, len); }
-					i += 5; // 'u0000'
-				} else {
-					result += s[i];
-				}
-			} else {
-				int val = 0;
-				if (from_hex_to_i(s, i + 1, 2, val)) {
-					// 2 digits hex codes
-					if (static_cast<char>(val) == '+'){
-						// We don't decode +
-						result += "%2B";
-					} else {
-						result += static_cast<char>(val);
-					}
-					i += 2; // '00'
-				} else {
-					result += s[i];
-				}
-			}
-		} else if (convert_plus_to_space && s[i] == '+') {
-			result += ' ';
-		} else {
-			result += s[i];
-		}
-	}
-
-	return result;
-}
-
-inline void read_file(const std::string &path, std::string &out) {
-	std::ifstream fs(path, std::ios_base::binary);
-	fs.seekg(0, std::ios_base::end);
-	auto size = fs.tellg();
-	fs.seekg(0);
-	out.resize(static_cast<size_t>(size));
-	fs.read(&out[0], static_cast<std::streamsize>(size));
-}
-
-inline std::string file_extension(const std::string &path) {
-	Match m;
-	static Regex re("\\.([a-zA-Z0-9]+)$");
-	if (duckdb_re2::RegexSearch(path, m, re)) { return m.str(1); }
-	return std::string();
-}
-
-inline bool is_space_or_tab(char c) { return c == ' ' || c == '\t'; }
-
-inline std::pair<size_t, size_t> trim(const char *b, const char *e, size_t left,
-                                      size_t right) {
-	while (b + left < e && is_space_or_tab(b[left])) {
-		left++;
-	}
-	while (right > 0 && is_space_or_tab(b[right - 1])) {
-		right--;
-	}
-	return std::make_pair(left, right);
-}
-
-inline std::string trim_copy(const std::string &s) {
-	auto r = trim(s.data(), s.data() + s.size(), 0, s.size());
-	return s.substr(r.first, r.second - r.first);
-}
-
-inline void split(const char *b, const char *e, char d,
-                  std::function<void(const char *, const char *)> fn) {
-	size_t i = 0;
-	size_t beg = 0;
-
-	while (e ? (b + i < e) : (b[i] != '\0')) {
-		if (b[i] == d) {
-			auto r = trim(b, e, beg, i);
-			if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
-			beg = i + 1;
-		}
-		i++;
-	}
-
-	if (i) {
-		auto r = trim(b, e, beg, i);
-		if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
-	}
-}
-
-inline stream_line_reader::stream_line_reader(Stream &strm, char *fixed_buffer,
-                                              size_t fixed_buffer_size)
-    : strm_(strm), fixed_buffer_(fixed_buffer),
-      fixed_buffer_size_(fixed_buffer_size) {}
-
-inline const char *stream_line_reader::ptr() const {
-	if (glowable_buffer_.empty()) {
-		return fixed_buffer_;
-	} else {
-		return glowable_buffer_.data();
-	}
-}
-
-inline size_t stream_line_reader::size() const {
-	if (glowable_buffer_.empty()) {
-		return fixed_buffer_used_size_;
-	} else {
-		return glowable_buffer_.size();
-	}
-}
-
-inline bool stream_line_reader::end_with_crlf() const {
-	auto end = ptr() + size();
-	return size() >= 2 && end[-2] == '\r' && end[-1] == '\n';
-}
-
-inline bool stream_line_reader::getline() {
-	fixed_buffer_used_size_ = 0;
-	glowable_buffer_.clear();
-
-	for (size_t i = 0;; i++) {
-		char byte;
-		auto n = strm_.read(&byte, 1);
-
-		if (n < 0) {
-			return false;
-		} else if (n == 0) {
-			if (i == 0) {
-				return false;
-			} else {
-				break;
-			}
-		}
-
-		append(byte);
-
-		if (byte == '\n') { break; }
-	}
-
-	return true;
-}
-
-inline void stream_line_reader::append(char c) {
-	if (fixed_buffer_used_size_ < fixed_buffer_size_ - 1) {
-		fixed_buffer_[fixed_buffer_used_size_++] = c;
-		fixed_buffer_[fixed_buffer_used_size_] = '\0';
-	} else {
-		if (glowable_buffer_.empty()) {
-			assert(fixed_buffer_[fixed_buffer_used_size_] == '\0');
-			glowable_buffer_.assign(fixed_buffer_, fixed_buffer_used_size_);
-		}
-		glowable_buffer_ += c;
-	}
-}
-
-inline int close_socket(socket_t sock) {
-#ifdef _WIN32
-	return closesocket(sock);
-#else
-	return close(sock);
-#endif
-}
-
-template <typename T> inline ssize_t handle_EINTR(T fn) {
-	ssize_t res = false;
-	while (true) {
-		res = fn();
-		if (res < 0 && errno == EINTR) { continue; }
-		break;
-	}
-	return res;
-}
-
-inline ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags) {
-	return handle_EINTR([&]() {
-		return recv(sock,
-#ifdef _WIN32
-		            static_cast<char *>(ptr), static_cast<int>(size),
-#else
-		            ptr, size,
-#endif
-		            flags);
-	});
-}
-
-inline ssize_t send_socket(socket_t sock, const void *ptr, size_t size,
-                           int flags) {
-	return handle_EINTR([&]() {
-		return send(sock,
-#ifdef _WIN32
-		            static_cast<const char *>(ptr), static_cast<int>(size),
-#else
-		            ptr, size,
-#endif
-		            flags);
-	});
-}
-
-inline ssize_t select_read(socket_t sock, time_t sec, time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
-	struct pollfd pfd_read;
-	pfd_read.fd = sock;
-	pfd_read.events = POLLIN;
-
-	auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
-	return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-#else
-#ifndef _WIN32
-	if (sock >= FD_SETSIZE) { return 1; }
-#endif
-
-	fd_set fds;
-	FD_ZERO(&fds);
-	FD_SET(sock, &fds);
-
-	timeval tv;
-	tv.tv_sec = static_cast<long>(sec);
-	tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
-	return handle_EINTR([&]() {
-		return select(static_cast<int>(sock + 1), &fds, nullptr, nullptr, &tv);
-	});
-#endif
-}
-
-inline ssize_t select_write(socket_t sock, time_t sec, time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
-	struct pollfd pfd_read;
-	pfd_read.fd = sock;
-	pfd_read.events = POLLOUT;
-
-	auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
-	return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-#else
-#ifndef _WIN32
-	if (sock >= FD_SETSIZE) { return 1; }
-#endif
-
-	fd_set fds;
-	FD_ZERO(&fds);
-	FD_SET(sock, &fds);
-
-	timeval tv;
-	tv.tv_sec = static_cast<long>(sec);
-	tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
-	return handle_EINTR([&]() {
-		return select(static_cast<int>(sock + 1), nullptr, &fds, nullptr, &tv);
-	});
-#endif
-}
-
-inline Error wait_until_socket_is_ready(socket_t sock, time_t sec, time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
-	struct pollfd pfd_read;
-	pfd_read.fd = sock;
-	pfd_read.events = POLLIN | POLLOUT;
-
-	auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
-	auto poll_res = handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-
-	if (poll_res == 0) {
-		return Error::ConnectionTimeout;
-	}
-
-	if (poll_res > 0 && pfd_read.revents & (POLLIN | POLLOUT)) {
-		int error = 0;
-		socklen_t len = sizeof(error);
-		auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR,
-		                      reinterpret_cast<char *>(&error), &len);
-		auto successful = res >= 0 && !error;
-		return successful ? Error::Success : Error::Connection;
-	}
-
-	return Error::Connection;
-#else
-#ifndef _WIN32
-	if (sock >= FD_SETSIZE) { return Error::Connection; }
-#endif
-
-	fd_set fdsr;
-	FD_ZERO(&fdsr);
-	FD_SET(sock, &fdsr);
-
-	auto fdsw = fdsr;
-	auto fdse = fdsr;
-
-	timeval tv;
-	tv.tv_sec = static_cast<long>(sec);
-	tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
-	auto ret = handle_EINTR([&]() {
-		return select(static_cast<int>(sock + 1), &fdsr, &fdsw, &fdse, &tv);
-	});
-
-	if (ret == 0) {
-		return Error::ConnectionTimeout;
-	}
-
-	if (ret > 0 && (FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) {
-		int error = 0;
-		socklen_t len = sizeof(error);
-		auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR,
-		                      reinterpret_cast<char *>(&error), &len);
-		auto successful = res >= 0 && !error;
-		return successful ? Error::Success : Error::Connection;
-	}
-	return Error::Connection;
-#endif
-}
-
-inline bool is_socket_alive(socket_t sock) {
-	const auto val = detail::select_read(sock, 0, 0);
-	if (val == 0) {
-		return true;
-	} else if (val < 0 && errno == EBADF) {
-		return false;
-	}
-	char buf[1];
-	return detail::read_socket(sock, &buf[0], sizeof(buf), MSG_PEEK) > 0;
-}
-
-class SocketStream : public Stream {
-public:
-	SocketStream(socket_t sock, time_t read_timeout_sec, time_t read_timeout_usec,
-	             time_t write_timeout_sec, time_t write_timeout_usec);
-	~SocketStream() override;
-
-	bool is_readable() const override;
-	bool is_writable() const override;
-	ssize_t read(char *ptr, size_t size) override;
-	ssize_t write(const char *ptr, size_t size) override;
-	void get_remote_ip_and_port(std::string &ip, int &port) const override;
-	socket_t socket() const override;
-
-private:
-	socket_t sock_;
-	time_t read_timeout_sec_;
-	time_t read_timeout_usec_;
-	time_t write_timeout_sec_;
-	time_t write_timeout_usec_;
-
-	std::vector<char> read_buff_;
-	size_t read_buff_off_ = 0;
-	size_t read_buff_content_size_ = 0;
-
-	static const size_t read_buff_size_ = 1024 * 4;
-};
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-class SSLSocketStream : public Stream {
-public:
-	SSLSocketStream(socket_t sock, SSL *ssl, time_t read_timeout_sec,
-	                time_t read_timeout_usec, time_t write_timeout_sec,
-	                time_t write_timeout_usec);
-	~SSLSocketStream() override;
-
-	bool is_readable() const override;
-	bool is_writable() const override;
-	ssize_t read(char *ptr, size_t size) override;
-	ssize_t write(const char *ptr, size_t size) override;
-	void get_remote_ip_and_port(std::string &ip, int &port) const override;
-	socket_t socket() const override;
-
-private:
-	socket_t sock_;
-	SSL *ssl_;
-	time_t read_timeout_sec_;
-	time_t read_timeout_usec_;
-	time_t write_timeout_sec_;
-	time_t write_timeout_usec_;
-};
-#endif
-
-inline bool keep_alive(socket_t sock, time_t keep_alive_timeout_sec) {
-	using namespace std::chrono;
-	auto start = steady_clock::now();
-	while (true) {
-		auto val = select_read(sock, 0, 10000);
-		if (val < 0) {
-			return false;
-		} else if (val == 0) {
-			auto current = steady_clock::now();
-			auto duration = duration_cast<milliseconds>(current - start);
-			auto timeout = keep_alive_timeout_sec * 1000;
-			if (duration.count() > timeout) { return false; }
-			std::this_thread::sleep_for(std::chrono::milliseconds(1));
-		} else {
-			return true;
-		}
-	}
-}
-
-template <typename T>
-inline bool
-process_server_socket_core(const std::atomic<socket_t> &svr_sock, socket_t sock,
-                           size_t keep_alive_max_count,
-                           time_t keep_alive_timeout_sec, T callback) {
-	assert(keep_alive_max_count > 0);
-	auto ret = false;
-	auto count = keep_alive_max_count;
-	while (svr_sock != INVALID_SOCKET && count > 0 &&
-	       keep_alive(sock, keep_alive_timeout_sec)) {
-		auto close_connection = count == 1;
-		auto connection_closed = false;
-		ret = callback(close_connection, connection_closed);
-		if (!ret || connection_closed) { break; }
-		count--;
-	}
-	return ret;
-}
-
-template <typename T>
-inline bool
-process_server_socket(const std::atomic<socket_t> &svr_sock, socket_t sock,
-                      size_t keep_alive_max_count,
-                      time_t keep_alive_timeout_sec, time_t read_timeout_sec,
-                      time_t read_timeout_usec, time_t write_timeout_sec,
-                      time_t write_timeout_usec, T callback) {
-	return process_server_socket_core(
-	    svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec,
-	    [&](bool close_connection, bool &connection_closed) {
-		    SocketStream strm(sock, read_timeout_sec, read_timeout_usec,
-		                      write_timeout_sec, write_timeout_usec);
-		    return callback(strm, close_connection, connection_closed);
-	    });
-}
-
-inline bool process_client_socket(socket_t sock, time_t read_timeout_sec,
-                                  time_t read_timeout_usec,
-                                  time_t write_timeout_sec,
-                                  time_t write_timeout_usec,
-                                  std::function<bool(Stream &)> callback) {
-	SocketStream strm(sock, read_timeout_sec, read_timeout_usec,
-	                  write_timeout_sec, write_timeout_usec);
-	return callback(strm);
-}
-
-inline int shutdown_socket(socket_t sock) {
-#ifdef _WIN32
-	return shutdown(sock, SD_BOTH);
-#else
-	return shutdown(sock, SHUT_RDWR);
-#endif
-}
-
-template <typename BindOrConnect>
-socket_t create_socket(const char *host, const char *ip, int port,
-                       int address_family, int socket_flags, bool tcp_nodelay,
-                       SocketOptions socket_options,
-                       BindOrConnect bind_or_connect) {
-	// Get address info
-	const char *node = nullptr;
-	struct addrinfo hints;
-	struct addrinfo *result;
-
-	memset(&hints, 0, sizeof(struct addrinfo));
-	hints.ai_socktype = SOCK_STREAM;
-	hints.ai_protocol = 0;
-
-	if (ip[0] != '\0') {
-		node = ip;
-		// Ask getaddrinfo to convert IP in c-string to address
-		hints.ai_family = AF_UNSPEC;
-		hints.ai_flags = AI_NUMERICHOST;
-	} else {
-		node = host;
-		hints.ai_family = address_family;
-		hints.ai_flags = socket_flags;
-	}
-
-	auto service = std::to_string(port);
-
-	if (getaddrinfo(node, service.c_str(), &hints, &result)) {
-#if defined __linux__ && !defined __ANDROID__
-		res_init();
-#endif
-		return INVALID_SOCKET;
-	}
-
-	for (auto rp = result; rp; rp = rp->ai_next) {
-		// Create a socket
-#ifdef _WIN32
-		auto sock =
-		    WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol, nullptr, 0,
-		               WSA_FLAG_NO_HANDLE_INHERIT | WSA_FLAG_OVERLAPPED);
-		/**
-     * Since the WSA_FLAG_NO_HANDLE_INHERIT is only supported on Windows 7 SP1
-     * and above the socket creation fails on older Windows Systems.
-     *
-     * Let's try to create a socket the old way in this case.
-     *
-     * Reference:
-     * https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketa
-     *
-     * WSA_FLAG_NO_HANDLE_INHERIT:
-     * This flag is supported on Windows 7 with SP1, Windows Server 2008 R2 with
-     * SP1, and later
-     *
-		 */
-		if (sock == INVALID_SOCKET) {
-			sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-		}
-#else
-		auto sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-#endif
-		if (sock == INVALID_SOCKET) { continue; }
-
-#ifndef _WIN32
-		if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1) { continue; }
-#endif
-
-		if (tcp_nodelay) {
-			int yes = 1;
-			setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&yes),
-			           sizeof(yes));
-		}
-
-		if (socket_options) { socket_options(sock); }
-
-		if (rp->ai_family == AF_INET6) {
-			int no = 0;
-			setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<char *>(&no),
-			           sizeof(no));
-		}
-
-		// bind or connect
-		if (bind_or_connect(sock, *rp)) {
-			freeaddrinfo(result);
-			return sock;
-		}
-
-		close_socket(sock);
-	}
-
-	freeaddrinfo(result);
-	return INVALID_SOCKET;
-}
-
-inline void set_nonblocking(socket_t sock, bool nonblocking) {
-#ifdef _WIN32
-	auto flags = nonblocking ? 1UL : 0UL;
-	ioctlsocket(sock, FIONBIO, &flags);
-#else
-	auto flags = fcntl(sock, F_GETFL, 0);
-	fcntl(sock, F_SETFL,
-	      nonblocking ? (flags | O_NONBLOCK) : (flags & (~O_NONBLOCK)));
-#endif
-}
-
-inline bool is_connection_error() {
-#ifdef _WIN32
-	return WSAGetLastError() != WSAEWOULDBLOCK;
-#else
-	return errno != EINPROGRESS;
-#endif
-}
-
-inline bool bind_ip_address(socket_t sock, const char *host) {
-	struct addrinfo hints;
-	struct addrinfo *result;
-
-	memset(&hints, 0, sizeof(struct addrinfo));
-	hints.ai_family = AF_UNSPEC;
-	hints.ai_socktype = SOCK_STREAM;
-	hints.ai_protocol = 0;
-
-	if (getaddrinfo(host, "0", &hints, &result)) { return false; }
-
-	auto ret = false;
-	for (auto rp = result; rp; rp = rp->ai_next) {
-		const auto &ai = *rp;
-		if (!::bind(sock, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen))) {
-			ret = true;
-			break;
-		}
-	}
-
-	freeaddrinfo(result);
-	return ret;
-}
-
-#if !defined _WIN32 && !defined ANDROID
-#define USE_IF2IP
-#endif
-
-#ifdef USE_IF2IP
-inline std::string if2ip(const std::string &ifn) {
-	struct ifaddrs *ifap;
-	getifaddrs(&ifap);
-	for (auto ifa = ifap; ifa; ifa = ifa->ifa_next) {
-		if (ifa->ifa_addr && ifn == ifa->ifa_name) {
-			if (ifa->ifa_addr->sa_family == AF_INET) {
-				auto sa = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr);
-				char buf[INET_ADDRSTRLEN];
-				if (inet_ntop(AF_INET, &sa->sin_addr, buf, INET_ADDRSTRLEN)) {
-					freeifaddrs(ifap);
-					return std::string(buf, INET_ADDRSTRLEN);
-				}
-			}
-		}
-	}
-	freeifaddrs(ifap);
-	return std::string();
-}
-#endif
-
-inline socket_t create_client_socket(
-    const char *host, const char *ip, int port, int address_family,
-    bool tcp_nodelay, SocketOptions socket_options,
-    time_t connection_timeout_sec, time_t connection_timeout_usec,
-    time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
-    time_t write_timeout_usec, const std::string &intf, Error &error) {
-	auto sock = create_socket(
-	    host, ip, port, address_family, 0, tcp_nodelay, std::move(socket_options),
-	    [&](socket_t sock2, struct addrinfo &ai) -> bool {
-		    if (!intf.empty()) {
-#ifdef USE_IF2IP
-			    auto ip = if2ip(intf);
-			    if (ip.empty()) { ip = intf; }
-			    if (!bind_ip_address(sock2, ip.c_str())) {
-				    error = Error::BindIPAddress;
-				    return false;
-			    }
-#endif
-		    }
-
-		    set_nonblocking(sock2, true);
-
-		    auto ret =
-		        ::connect(sock2, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen));
-
-		    if (ret < 0) {
-			    if (is_connection_error()) {
-				    error = Error::Connection;
-				    return false;
-			    }
-			    error = wait_until_socket_is_ready(sock2, connection_timeout_sec,
-			                                       connection_timeout_usec);
-			    if (error != Error::Success) {
-				    return false;
-			    }
-		    }
-
-		    set_nonblocking(sock2, false);
-
-		    {
-#ifdef _WIN32
-			    auto timeout = static_cast<uint32_t>(read_timeout_sec * 1000 +
-			                                         read_timeout_usec / 1000);
-			    setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout,
-			               sizeof(timeout));
-#else
-			    timeval tv;
-			    tv.tv_sec = static_cast<long>(read_timeout_sec);
-			    tv.tv_usec = static_cast<decltype(tv.tv_usec)>(read_timeout_usec);
-			    setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));
-#endif
-		    }
-		    {
-
-#ifdef _WIN32
-			    auto timeout = static_cast<uint32_t>(write_timeout_sec * 1000 +
-			                                         write_timeout_usec / 1000);
-			    setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout,
-			               sizeof(timeout));
-#else
-			    timeval tv;
-			    tv.tv_sec = static_cast<long>(write_timeout_sec);
-			    tv.tv_usec = static_cast<decltype(tv.tv_usec)>(write_timeout_usec);
-			    setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv));
-#endif
-		    }
-
-		    error = Error::Success;
-		    return true;
-	    });
-
-	if (sock != INVALID_SOCKET) {
-		error = Error::Success;
-	} else {
-		if (error == Error::Success) { error = Error::Connection; }
-	}
-
-	return sock;
-}
-
-inline bool get_remote_ip_and_port(const struct sockaddr_storage &addr,
-                                   socklen_t addr_len, std::string &ip,
-                                   int &port) {
-	if (addr.ss_family == AF_INET) {
-		port = ntohs(reinterpret_cast<const struct sockaddr_in *>(&addr)->sin_port);
-	} else if (addr.ss_family == AF_INET6) {
-		port =
-		    ntohs(reinterpret_cast<const struct sockaddr_in6 *>(&addr)->sin6_port);
-	} else {
-		return false;
-	}
-
-	std::array<char, NI_MAXHOST> ipstr{};
-	if (getnameinfo(reinterpret_cast<const struct sockaddr *>(&addr), addr_len,
-	                ipstr.data(), static_cast<socklen_t>(ipstr.size()), nullptr,
-	                0, NI_NUMERICHOST)) {
-		return false;
-	}
-
-	ip = ipstr.data();
-	return true;
-}
-
-inline void get_remote_ip_and_port(socket_t sock, std::string &ip, int &port) {
-	struct sockaddr_storage addr;
-	socklen_t addr_len = sizeof(addr);
-
-	if (!getpeername(sock, reinterpret_cast<struct sockaddr *>(&addr),
-	                 &addr_len)) {
-		get_remote_ip_and_port(addr, addr_len, ip, port);
-	}
-}
-
-inline constexpr unsigned int str2tag_core(const char *s, size_t l,
-                                           unsigned int h) {
-	return (l == 0) ? h
-	                : str2tag_core(s + 1, l - 1,
-	                               (h * 33) ^ static_cast<unsigned char>(*s));
-}
-
-inline unsigned int str2tag(const std::string &s) {
-	return str2tag_core(s.data(), s.size(), 0);
-}
-
-namespace udl {
-
-inline constexpr unsigned int operator"" _t(const char *s, size_t l) {
-	return str2tag_core(s, l, 0);
-}
-
-} // namespace udl
-
-inline const char *
-find_content_type(const std::string &path,
-                  const std::map<std::string, std::string> &user_data) {
-	auto ext = file_extension(path);
-
-	auto it = user_data.find(ext);
-	if (it != user_data.end()) { return it->second.c_str(); }
-
-	using udl::operator"" _t;
-
-	switch (str2tag(ext)) {
-	default: return nullptr;
-	case "css"_t: return "text/css";
-	case "csv"_t: return "text/csv";
-	case "txt"_t: return "text/plain";
-	case "vtt"_t: return "text/vtt";
-	case "htm"_t:
-	case "html"_t: return "text/html";
-
-	case "apng"_t: return "image/apng";
-	case "avif"_t: return "image/avif";
-	case "bmp"_t: return "image/bmp";
-	case "gif"_t: return "image/gif";
-	case "png"_t: return "image/png";
-	case "svg"_t: return "image/svg+xml";
-	case "webp"_t: return "image/webp";
-	case "ico"_t: return "image/x-icon";
-	case "tif"_t: return "image/tiff";
-	case "tiff"_t: return "image/tiff";
-	case "jpg"_t:
-	case "jpeg"_t: return "image/jpeg";
-
-	case "mp4"_t: return "video/mp4";
-	case "mpeg"_t: return "video/mpeg";
-	case "webm"_t: return "video/webm";
-
-	case "mp3"_t: return "audio/mp3";
-	case "mpga"_t: return "audio/mpeg";
-	case "weba"_t: return "audio/webm";
-	case "wav"_t: return "audio/wave";
-
-	case "otf"_t: return "font/otf";
-	case "ttf"_t: return "font/ttf";
-	case "woff"_t: return "font/woff";
-	case "woff2"_t: return "font/woff2";
-
-	case "7z"_t: return "application/x-7z-compressed";
-	case "atom"_t: return "application/atom+xml";
-	case "pdf"_t: return "application/pdf";
-	case "js"_t:
-	case "mjs"_t: return "application/javascript";
-	case "json"_t: return "application/json";
-	case "rss"_t: return "application/rss+xml";
-	case "tar"_t: return "application/x-tar";
-	case "xht"_t:
-	case "xhtml"_t: return "application/xhtml+xml";
-	case "xslt"_t: return "application/xslt+xml";
-	case "xml"_t: return "application/xml";
-	case "gz"_t: return "application/gzip";
-	case "zip"_t: return "application/zip";
-	case "wasm"_t: return "application/wasm";
-	}
-}
-
-inline const char *status_message(int status) {
-	switch (status) {
-	case 100: return "Continue";
-	case 101: return "Switching Protocol";
-	case 102: return "Processing";
-	case 103: return "Early Hints";
-	case 200: return "OK";
-	case 201: return "Created";
-	case 202: return "Accepted";
-	case 203: return "Non-Authoritative Information";
-	case 204: return "No Content";
-	case 205: return "Reset Content";
-	case 206: return "Partial Content";
-	case 207: return "Multi-Status";
-	case 208: return "Already Reported";
-	case 226: return "IM Used";
-	case 300: return "Multiple Choice";
-	case 301: return "Moved Permanently";
-	case 302: return "Found";
-	case 303: return "See Other";
-	case 304: return "Not Modified";
-	case 305: return "Use Proxy";
-	case 306: return "unused";
-	case 307: return "Temporary Redirect";
-	case 308: return "Permanent Redirect";
-	case 400: return "Bad Request";
-	case 401: return "Unauthorized";
-	case 402: return "Payment Required";
-	case 403: return "Forbidden";
-	case 404: return "Not Found";
-	case 405: return "Method Not Allowed";
-	case 406: return "Not Acceptable";
-	case 407: return "Proxy Authentication Required";
-	case 408: return "Request Timeout";
-	case 409: return "Conflict";
-	case 410: return "Gone";
-	case 411: return "Length Required";
-	case 412: return "Precondition Failed";
-	case 413: return "Payload Too Large";
-	case 414: return "URI Too Long";
-	case 415: return "Unsupported Media Type";
-	case 416: return "Range Not Satisfiable";
-	case 417: return "Expectation Failed";
-	case 418: return "I'm a teapot";
-	case 421: return "Misdirected Request";
-	case 422: return "Unprocessable Entity";
-	case 423: return "Locked";
-	case 424: return "Failed Dependency";
-	case 425: return "Too Early";
-	case 426: return "Upgrade Required";
-	case 428: return "Precondition Required";
-	case 429: return "Too Many Requests";
-	case 431: return "Request Header Fields Too Large";
-	case 451: return "Unavailable For Legal Reasons";
-	case 501: return "Not Implemented";
-	case 502: return "Bad Gateway";
-	case 503: return "Service Unavailable";
-	case 504: return "Gateway Timeout";
-	case 505: return "HTTP Version Not Supported";
-	case 506: return "Variant Also Negotiates";
-	case 507: return "Insufficient Storage";
-	case 508: return "Loop Detected";
-	case 510: return "Not Extended";
-	case 511: return "Network Authentication Required";
-
-	default:
-	case 500: return "Internal Server Error";
-	}
-}
-
-inline bool can_compress_content_type(const std::string &content_type) {
-	return (!content_type.rfind("text/", 0) &&
-	        content_type != "text/event-stream") ||
-	       content_type == "image/svg+xml" ||
-	       content_type == "application/javascript" ||
-	       content_type == "application/json" ||
-	       content_type == "application/xml" ||
-	       content_type == "application/protobuf" ||
-	       content_type == "application/xhtml+xml";
-}
-
-inline EncodingType encoding_type(const Request &req, const Response &res) {
-	auto ret =
-	    detail::can_compress_content_type(res.get_header_value("Content-Type"));
-	if (!ret) { return EncodingType::None; }
-
-	const auto &s = req.get_header_value("Accept-Encoding");
-	(void)(s);
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-	// TODO: 'Accept-Encoding' has br, not br;q=0
-	ret = s.find("br") != std::string::npos;
-	if (ret) { return EncodingType::Brotli; }
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-	// TODO: 'Accept-Encoding' has gzip, not gzip;q=0
-	ret = s.find("gzip") != std::string::npos;
-	if (ret) { return EncodingType::Gzip; }
-#endif
-
-	return EncodingType::None;
-}
-
-inline bool nocompressor::compress(const char *data, size_t data_length,
-                                   bool /*last*/, Callback callback) {
-	if (!data_length) { return true; }
-	return callback(data, data_length);
-}
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-inline gzip_compressor::gzip_compressor() {
-	std::memset(&strm_, 0, sizeof(strm_));
-	strm_.zalloc = Z_NULL;
-	strm_.zfree = Z_NULL;
-	strm_.opaque = Z_NULL;
-
-	is_valid_ = deflateInit2(&strm_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8,
-	                         Z_DEFAULT_STRATEGY) == Z_OK;
-}
-
-inline gzip_compressor::~gzip_compressor() { deflateEnd(&strm_); }
-
-inline bool gzip_compressor::compress(const char *data, size_t data_length,
-                                      bool last, Callback callback) {
-	assert(is_valid_);
-
-	do {
-		constexpr size_t max_avail_in =
-		    (std::numeric_limits<decltype(strm_.avail_in)>::max)();
-
-		strm_.avail_in = static_cast<decltype(strm_.avail_in)>(
-		    (std::min)(data_length, max_avail_in));
-		strm_.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
-
-		data_length -= strm_.avail_in;
-		data += strm_.avail_in;
-
-		auto flush = (last && data_length == 0) ? Z_FINISH : Z_NO_FLUSH;
-		int ret = Z_OK;
-
-		std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-		do {
-			strm_.avail_out = static_cast<uInt>(buff.size());
-			strm_.next_out = reinterpret_cast<Bytef *>(buff.data());
-
-			ret = deflate(&strm_, flush);
-			if (ret == Z_STREAM_ERROR) { return false; }
-
-			if (!callback(buff.data(), buff.size() - strm_.avail_out)) {
-				return false;
-			}
-		} while (strm_.avail_out == 0);
-
-		assert((flush == Z_FINISH && ret == Z_STREAM_END) ||
-		       (flush == Z_NO_FLUSH && ret == Z_OK));
-		assert(strm_.avail_in == 0);
-
-	} while (data_length > 0);
-
-	return true;
-}
-
-inline gzip_decompressor::gzip_decompressor() {
-	std::memset(&strm_, 0, sizeof(strm_));
-	strm_.zalloc = Z_NULL;
-	strm_.zfree = Z_NULL;
-	strm_.opaque = Z_NULL;
-
-	// 15 is the value of wbits, which should be at the maximum possible value
-	// to ensure that any gzip stream can be decoded. The offset of 32 specifies
-	// that the stream type should be automatically detected either gzip or
-	// deflate.
-	is_valid_ = inflateInit2(&strm_, 32 + 15) == Z_OK;
-}
-
-inline gzip_decompressor::~gzip_decompressor() { inflateEnd(&strm_); }
-
-inline bool gzip_decompressor::is_valid() const { return is_valid_; }
-
-inline bool gzip_decompressor::decompress(const char *data, size_t data_length,
-                                          Callback callback) {
-	assert(is_valid_);
-
-	int ret = Z_OK;
-
-	do {
-		constexpr size_t max_avail_in =
-		    (std::numeric_limits<decltype(strm_.avail_in)>::max)();
-
-		strm_.avail_in = static_cast<decltype(strm_.avail_in)>(
-		    (std::min)(data_length, max_avail_in));
-		strm_.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
-
-		data_length -= strm_.avail_in;
-		data += strm_.avail_in;
-
-		std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-		while (strm_.avail_in > 0) {
-			strm_.avail_out = static_cast<uInt>(buff.size());
-			strm_.next_out = reinterpret_cast<Bytef *>(buff.data());
-
-			auto prev_avail_in = strm_.avail_in;
-
-			ret = inflate(&strm_, Z_NO_FLUSH);
-
-			if (prev_avail_in - strm_.avail_in == 0) { return false; }
-
-			assert(ret != Z_STREAM_ERROR);
-			switch (ret) {
-			case Z_NEED_DICT:
-			case Z_DATA_ERROR:
-			case Z_MEM_ERROR: inflateEnd(&strm_); return false;
-			}
-
-			if (!callback(buff.data(), buff.size() - strm_.avail_out)) {
-				return false;
-			}
-		}
-
-		if (ret != Z_OK && ret != Z_STREAM_END) return false;
-
-	} while (data_length > 0);
-
-	return true;
-}
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-inline brotli_compressor::brotli_compressor() {
-	state_ = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
-}
-
-inline brotli_compressor::~brotli_compressor() {
-	BrotliEncoderDestroyInstance(state_);
-}
-
-inline bool brotli_compressor::compress(const char *data, size_t data_length,
-                                        bool last, Callback callback) {
-	std::array<uint8_t, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-
-	auto operation = last ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS;
-	auto available_in = data_length;
-	auto next_in = reinterpret_cast<const uint8_t *>(data);
-
-	for (;;) {
-		if (last) {
-			if (BrotliEncoderIsFinished(state_)) { break; }
-		} else {
-			if (!available_in) { break; }
-		}
-
-		auto available_out = buff.size();
-		auto next_out = buff.data();
-
-		if (!BrotliEncoderCompressStream(state_, operation, &available_in, &next_in,
-		                                 &available_out, &next_out, nullptr)) {
-			return false;
-		}
-
-		auto output_bytes = buff.size() - available_out;
-		if (output_bytes) {
-			callback(reinterpret_cast<const char *>(buff.data()), output_bytes);
-		}
-	}
-
-	return true;
-}
-
-inline brotli_decompressor::brotli_decompressor() {
-	decoder_s = BrotliDecoderCreateInstance(0, 0, 0);
-	decoder_r = decoder_s ? BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT
-	                      : BROTLI_DECODER_RESULT_ERROR;
-}
-
-inline brotli_decompressor::~brotli_decompressor() {
-	if (decoder_s) { BrotliDecoderDestroyInstance(decoder_s); }
-}
-
-inline bool brotli_decompressor::is_valid() const { return decoder_s; }
-
-inline bool brotli_decompressor::decompress(const char *data,
-                                            size_t data_length,
-                                            Callback callback) {
-	if (decoder_r == BROTLI_DECODER_RESULT_SUCCESS ||
-	    decoder_r == BROTLI_DECODER_RESULT_ERROR) {
-		return 0;
-	}
-
-	const uint8_t *next_in = (const uint8_t *)data;
-	size_t avail_in = data_length;
-	size_t total_out;
-
-	decoder_r = BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT;
-
-	std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-	while (decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
-		char *next_out = buff.data();
-		size_t avail_out = buff.size();
-
-		decoder_r = BrotliDecoderDecompressStream(
-		    decoder_s, &avail_in, &next_in, &avail_out,
-		    reinterpret_cast<uint8_t **>(&next_out), &total_out);
-
-		if (decoder_r == BROTLI_DECODER_RESULT_ERROR) { return false; }
-
-		if (!callback(buff.data(), buff.size() - avail_out)) { return false; }
-	}
-
-	return decoder_r == BROTLI_DECODER_RESULT_SUCCESS ||
-	       decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
-}
-#endif
-
-inline bool has_header(const Headers &headers, const char *key) {
-	return headers.find(key) != headers.end();
-}
-
-inline const char *get_header_value(const Headers &headers, const char *key,
-                                    size_t id, const char *def) {
-	auto rng = headers.equal_range(key);
-	auto it = rng.first;
-	std::advance(it, static_cast<ssize_t>(id));
-	if (it != rng.second) { return it->second.c_str(); }
-	return def;
-}
-
-template <typename T>
-inline bool parse_header(const char *beg, const char *end, T fn) {
-	// Skip trailing spaces and tabs.
-	while (beg < end && is_space_or_tab(end[-1])) {
-		end--;
-	}
-
-	auto p = beg;
-	while (p < end && *p != ':') {
-		p++;
-	}
-
-	if (p == end) { return false; }
-
-	auto key_end = p;
-
-	if (*p++ != ':') { return false; }
-
-	while (p < end && is_space_or_tab(*p)) {
-		p++;
-	}
-
-	if (p < end) {
-		fn(std::string(beg, key_end), decode_url(std::string(p, end), false));
-		return true;
-	}
-
-	return false;
-}
-
-inline bool read_headers(Stream &strm, Headers &headers) {
-	const auto bufsiz = 2048;
-	char buf[bufsiz];
-	stream_line_reader line_reader(strm, buf, bufsiz);
-
-	for (;;) {
-		if (!line_reader.getline()) { return false; }
-
-		// Check if the line ends with CRLF.
-		auto line_terminator_len = 2;
-		if (line_reader.end_with_crlf()) {
-			// Blank line indicates end of headers.
-			if (line_reader.size() == 2) { break; }
-#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR
-		} else {
-			// Blank line indicates end of headers.
-			if (line_reader.size() == 1) { break; }
-			line_terminator_len = 1;
-		}
-#else
-		} else {
-			continue; // Skip invalid line.
-		}
-#endif
-
-		if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; }
-
-		// Exclude line terminator
-		auto end = line_reader.ptr() + line_reader.size() - line_terminator_len;
-
-		parse_header(line_reader.ptr(), end,
-		             [&](std::string &&key, std::string &&val) {
-			             headers.emplace(std::move(key), std::move(val));
-		             });
-	}
-
-	return true;
-}
-
-inline bool read_content_with_length(Stream &strm, uint64_t len,
-                                     Progress progress,
-                                     ContentReceiverWithProgress out) {
-	char buf[CPPHTTPLIB_RECV_BUFSIZ];
-
-	uint64_t r = 0;
-	while (r < len) {
-		auto read_len = static_cast<size_t>(len - r);
-		auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ));
-		if (n <= 0) { return false; }
-
-		if (!out(buf, static_cast<size_t>(n), r, len)) { return false; }
-		r += static_cast<uint64_t>(n);
-
-		if (progress) {
-			if (!progress(r, len)) { return false; }
-		}
-	}
-
-	return true;
-}
-
-inline void skip_content_with_length(Stream &strm, uint64_t len) {
-	char buf[CPPHTTPLIB_RECV_BUFSIZ];
-	uint64_t r = 0;
-	while (r < len) {
-		auto read_len = static_cast<size_t>(len - r);
-		auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ));
-		if (n <= 0) { return; }
-		r += static_cast<uint64_t>(n);
-	}
-}
-
-inline bool read_content_without_length(Stream &strm,
-                                        ContentReceiverWithProgress out) {
-	char buf[CPPHTTPLIB_RECV_BUFSIZ];
-	uint64_t r = 0;
-	for (;;) {
-		auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ);
-		if (n < 0) {
-			return false;
-		} else if (n == 0) {
-			return true;
-		}
-
-		if (!out(buf, static_cast<size_t>(n), r, 0)) { return false; }
-		r += static_cast<uint64_t>(n);
-	}
-
-	return true;
-}
-
-inline bool read_content_chunked(Stream &strm,
-                                 ContentReceiverWithProgress out) {
-	const auto bufsiz = 16;
-	char buf[bufsiz];
-
-	stream_line_reader line_reader(strm, buf, bufsiz);
-
-	if (!line_reader.getline()) { return false; }
-
-	unsigned long chunk_len;
-	while (true) {
-		char *end_ptr;
-
-		chunk_len = std::strtoul(line_reader.ptr(), &end_ptr, 16);
-
-		if (end_ptr == line_reader.ptr()) { return false; }
-		if (chunk_len == ULONG_MAX) { return false; }
-
-		if (chunk_len == 0) { break; }
-
-		if (!read_content_with_length(strm, chunk_len, nullptr, out)) {
-			return false;
-		}
-
-		if (!line_reader.getline()) { return false; }
-
-		if (strcmp(line_reader.ptr(), "\r\n")) { break; }
-
-		if (!line_reader.getline()) { return false; }
-	}
-
-	if (chunk_len == 0) {
-		// Reader terminator after chunks
-		if (!line_reader.getline() || strcmp(line_reader.ptr(), "\r\n"))
-			return false;
-	}
-
-	return true;
-}
-
-inline bool is_chunked_transfer_encoding(const Headers &headers) {
-	return !strcasecmp(get_header_value(headers, "Transfer-Encoding", 0, ""),
-	                   "chunked");
-}
-
-template <typename T, typename U>
-bool prepare_content_receiver(T &x, int &status,
-                              ContentReceiverWithProgress receiver,
-                              bool decompress, U callback) {
-	if (decompress) {
-		std::string encoding = x.get_header_value("Content-Encoding");
-		std::unique_ptr<decompressor> decompressor;
-
-		if (encoding == "gzip" || encoding == "deflate") {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-			decompressor = detail::make_unique<gzip_decompressor>();
-#else
-			status = 415;
-			return false;
-#endif
-		} else if (encoding.find("br") != std::string::npos) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-			decompressor = detail::make_unique<brotli_decompressor>();
-#else
-			status = 415;
-			return false;
-#endif
-		}
-
-		if (decompressor) {
-			if (decompressor->is_valid()) {
-				ContentReceiverWithProgress out = [&](const char *buf, size_t n,
-				                                      uint64_t off, uint64_t len) {
-					return decompressor->decompress(buf, n,
-					                                [&](const char *buf2, size_t n2) {
-						                                return receiver(buf2, n2, off, len);
-					                                });
-				};
-				return callback(std::move(out));
-			} else {
-				status = 500;
-				return false;
-			}
-		}
-	}
-
-	ContentReceiverWithProgress out = [&](const char *buf, size_t n, uint64_t off,
-	                                      uint64_t len) {
-		return receiver(buf, n, off, len);
-	};
-	return callback(std::move(out));
-}
-
-template <typename T>
-bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status,
-                  Progress progress, ContentReceiverWithProgress receiver,
-                  bool decompress) {
-	return prepare_content_receiver(
-	    x, status, std::move(receiver), decompress,
-	    [&](const ContentReceiverWithProgress &out) {
-		    auto ret = true;
-		    auto exceed_payload_max_length = false;
-
-		    if (is_chunked_transfer_encoding(x.headers)) {
-			    ret = read_content_chunked(strm, out);
-		    } else if (!has_header(x.headers, "Content-Length")) {
-			    ret = read_content_without_length(strm, out);
-		    } else {
-			    auto len = get_header_value<uint64_t>(x.headers, "Content-Length");
-			    if (len > payload_max_length) {
-				    exceed_payload_max_length = true;
-				    skip_content_with_length(strm, len);
-				    ret = false;
-			    } else if (len > 0) {
-				    ret = read_content_with_length(strm, len, std::move(progress), out);
-			    }
-		    }
-
-		    if (!ret) { status = exceed_payload_max_length ? 413 : 400; }
-		    return ret;
-	    });
-}
-
-inline ssize_t write_headers(Stream &strm, const Headers &headers) {
-	ssize_t write_len = 0;
-	for (const auto &x : headers) {
-		auto len =
-		    strm.write_format("%s: %s\r\n", x.first.c_str(), x.second.c_str());
-		if (len < 0) { return len; }
-		write_len += len;
-	}
-	auto len = strm.write("\r\n");
-	if (len < 0) { return len; }
-	write_len += len;
-	return write_len;
-}
-
-inline bool write_data(Stream &strm, const char *d, size_t l) {
-	size_t offset = 0;
-	while (offset < l) {
-		auto length = strm.write(d + offset, l - offset);
-		if (length < 0) { return false; }
-		offset += static_cast<size_t>(length);
-	}
-	return true;
-}
-
-template <typename T>
-inline bool write_content(Stream &strm, const ContentProvider &content_provider,
-                          size_t offset, size_t length, T is_shutting_down,
-                          Error &error) {
-	size_t end_offset = offset + length;
-	auto ok = true;
-	DataSink data_sink;
-
-	data_sink.write = [&](const char *d, size_t l) -> bool {
-		if (ok) {
-			if (write_data(strm, d, l)) {
-				offset += l;
-			} else {
-				ok = false;
-			}
-		}
-		return ok;
-	};
-
-	data_sink.is_writable = [&](void) { return ok && strm.is_writable(); };
-
-	while (offset < end_offset && !is_shutting_down()) {
-		if (!content_provider(offset, end_offset - offset, data_sink)) {
-			error = Error::Canceled;
-			return false;
-		}
-		if (!ok) {
-			error = Error::Write;
-			return false;
-		}
-	}
-
-	error = Error::Success;
-	return true;
-}
-
-template <typename T>
-inline bool write_content(Stream &strm, const ContentProvider &content_provider,
-                          size_t offset, size_t length,
-                          const T &is_shutting_down) {
-	auto error = Error::Success;
-	return write_content(strm, content_provider, offset, length, is_shutting_down,
-	                     error);
-}
-
-template <typename T>
-inline bool
-write_content_without_length(Stream &strm,
-                             const ContentProvider &content_provider,
-                             const T &is_shutting_down) {
-	size_t offset = 0;
-	auto data_available = true;
-	auto ok = true;
-	DataSink data_sink;
-
-	data_sink.write = [&](const char *d, size_t l) -> bool {
-		if (ok) {
-			offset += l;
-			if (!write_data(strm, d, l)) { ok = false; }
-		}
-		return ok;
-	};
-
-	data_sink.done = [&](void) { data_available = false; };
-
-	data_sink.is_writable = [&](void) { return ok && strm.is_writable(); };
-
-	while (data_available && !is_shutting_down()) {
-		if (!content_provider(offset, 0, data_sink)) { return false; }
-		if (!ok) { return false; }
-	}
-	return true;
-}
-
-template <typename T, typename U>
-inline bool
-write_content_chunked(Stream &strm, const ContentProvider &content_provider,
-                      const T &is_shutting_down, U &compressor, Error &error) {
-	size_t offset = 0;
-	auto data_available = true;
-	auto ok = true;
-	DataSink data_sink;
-
-	data_sink.write = [&](const char *d, size_t l) -> bool {
-		if (ok) {
-			data_available = l > 0;
-			offset += l;
-
-			std::string payload;
-			if (compressor.compress(d, l, false,
-			                        [&](const char *data, size_t data_len) {
-				                        payload.append(data, data_len);
-				                        return true;
-			                        })) {
-				if (!payload.empty()) {
-					// Emit chunked response header and footer for each chunk
-					auto chunk =
-					    from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n";
-					if (!write_data(strm, chunk.data(), chunk.size())) { ok = false; }
-				}
-			} else {
-				ok = false;
-			}
-		}
-		return ok;
-	};
-
-	data_sink.done = [&](void) {
-		if (!ok) { return; }
-
-		data_available = false;
-
-		std::string payload;
-		if (!compressor.compress(nullptr, 0, true,
-		                         [&](const char *data, size_t data_len) {
-			                         payload.append(data, data_len);
-			                         return true;
-		                         })) {
-			ok = false;
-			return;
-		}
-
-		if (!payload.empty()) {
-			// Emit chunked response header and footer for each chunk
-			auto chunk = from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n";
-			if (!write_data(strm, chunk.data(), chunk.size())) {
-				ok = false;
-				return;
-			}
-		}
-
-		static const std::string done_marker("0\r\n\r\n");
-		if (!write_data(strm, done_marker.data(), done_marker.size())) {
-			ok = false;
-		}
-	};
-
-	data_sink.is_writable = [&](void) { return ok && strm.is_writable(); };
-
-	while (data_available && !is_shutting_down()) {
-		if (!content_provider(offset, 0, data_sink)) {
-			error = Error::Canceled;
-			return false;
-		}
-		if (!ok) {
-			error = Error::Write;
-			return false;
-		}
-	}
-
-	error = Error::Success;
-	return true;
-}
-
-template <typename T, typename U>
-inline bool write_content_chunked(Stream &strm,
-                                  const ContentProvider &content_provider,
-                                  const T &is_shutting_down, U &compressor) {
-	auto error = Error::Success;
-	return write_content_chunked(strm, content_provider, is_shutting_down,
-	                             compressor, error);
-}
-
-template <typename T>
-inline bool redirect(T &cli, Request &req, Response &res,
-                     const std::string &path, const std::string &location,
-                     Error &error) {
-	Request new_req = req;
-	new_req.path = path;
-	new_req.redirect_count_ -= 1;
-
-	if (res.status == 303 && (req.method != "GET" && req.method != "HEAD")) {
-		new_req.method = "GET";
-		new_req.body.clear();
-		new_req.headers.clear();
-	}
-
-	Response new_res;
-
-	auto ret = cli.send(new_req, new_res, error);
-	if (ret) {
-		req = new_req;
-		res = new_res;
-		res.location = location;
-	}
-	return ret;
-}
-
-inline std::string params_to_query_str(const Params &params) {
-	std::string query;
-
-	for (auto it = params.begin(); it != params.end(); ++it) {
-		if (it != params.begin()) { query += "&"; }
-		query += it->first;
-		query += "=";
-		query += encode_query_param(it->second);
-	}
-	return query;
-}
-
-inline void parse_query_text(const std::string &s, Params &params) {
-	std::set<std::string> cache;
-	split(s.data(), s.data() + s.size(), '&', [&](const char *b, const char *e) {
-		std::string kv(b, e);
-		if (cache.find(kv) != cache.end()) { return; }
-		cache.insert(kv);
-
-		std::string key;
-		std::string val;
-		split(b, e, '=', [&](const char *b2, const char *e2) {
-			if (key.empty()) {
-				key.assign(b2, e2);
-			} else {
-				val.assign(b2, e2);
-			}
-		});
-
-		if (!key.empty()) {
-			params.emplace(decode_url(key, true), decode_url(val, false));
-		}
-	});
-}
-
-inline bool parse_multipart_boundary(const std::string &content_type,
-                                     std::string &boundary) {
-	auto pos = content_type.find("boundary=");
-	if (pos == std::string::npos) { return false; }
-	boundary = content_type.substr(pos + 9);
-	if (boundary.length() >= 2 && boundary.front() == '"' &&
-	    boundary.back() == '"') {
-		boundary = boundary.substr(1, boundary.size() - 2);
-	}
-	return !boundary.empty();
-}
-
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
-inline bool parse_range_header(const std::string &s, Ranges &ranges) {
-#else
-inline bool parse_range_header(const std::string &s, Ranges &ranges) try {
-#endif
-	static Regex re_first_range(R"(bytes=(\d*-\d*(?:,\s*\d*-\d*)*))");
-	Match m;
-	if (duckdb_re2::RegexMatch(s, m, re_first_range)) {
-		auto pos = static_cast<size_t>(m.position(1));
-		auto len = static_cast<size_t>(m.length(1));
-		bool all_valid_ranges = true;
-		split(&s[pos], &s[pos + len], ',', [&](const char *b, const char *e) {
-			if (!all_valid_ranges) return;
-			static Regex re_another_range(R"(\s*(\d*)-(\d*))");
-			Match cm;
-			if (duckdb_re2::RegexMatch(b, e, cm, re_another_range)) {
-				ssize_t first = -1;
-				if (!cm.str(1).empty()) {
-					first = static_cast<ssize_t>(std::stoll(cm.str(1)));
-				}
-
-				ssize_t last = -1;
-				if (!cm.str(2).empty()) {
-					last = static_cast<ssize_t>(std::stoll(cm.str(2)));
-				}
-
-				if (first != -1 && last != -1 && first > last) {
-					all_valid_ranges = false;
-					return;
-				}
-				ranges.emplace_back(std::make_pair(first, last));
-			}
-		});
-		return all_valid_ranges;
-	}
-	return false;
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
-}
-#else
-} catch (...) { return false; }
-#endif
-
-class MultipartFormDataParser {
-public:
-	MultipartFormDataParser() = default;
-
-	void set_boundary(std::string &&boundary) { boundary_ = boundary; }
-
-	bool is_valid() const { return is_valid_; }
-
-	bool parse(const char *buf, size_t n, const ContentReceiver &content_callback,
-	           const MultipartContentHeader &header_callback) {
-
-		static const Regex re_content_disposition(
-		    "^Content-Disposition:\\s*form-data;\\s*name=\"(.*?)\"(?:;\\s*filename="
-		    "\"(.*?)\")?\\s*$",
-		    duckdb_re2::RegexOptions::CASE_INSENSITIVE);
-		static const std::string dash_ = "--";
-		static const std::string crlf_ = "\r\n";
-
-		buf_append(buf, n);
-
-		while (buf_size() > 0) {
-			switch (state_) {
-			case 0: { // Initial boundary
-				auto pattern = dash_ + boundary_ + crlf_;
-				if (pattern.size() > buf_size()) { return true; }
-				if (!buf_start_with(pattern)) { return false; }
-				buf_erase(pattern.size());
-				state_ = 1;
-				break;
-			}
-			case 1: { // New entry
-				clear_file_info();
-				state_ = 2;
-				break;
-			}
-			case 2: { // Headers
-				auto pos = buf_find(crlf_);
-				if (pos > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; }
-				while (pos < buf_size()) {
-					// Empty line
-					if (pos == 0) {
-						if (!header_callback(file_)) {
-							is_valid_ = false;
-							return false;
-						}
-						buf_erase(crlf_.size());
-						state_ = 3;
-						break;
-					}
-
-					static const std::string header_name = "content-type:";
-					const auto header = buf_head(pos);
-					if (start_with_case_ignore(header, header_name)) {
-						file_.content_type = trim_copy(header.substr(header_name.size()));
-					} else {
-						Match m;
-						if (duckdb_re2::RegexMatch(header, m, re_content_disposition)) {
-							file_.name = m[1];
-							file_.filename = m[2];
-						}
-					}
-
-					buf_erase(pos + crlf_.size());
-					pos = buf_find(crlf_);
-				}
-				if (state_ != 3) { return true; }
-				break;
-			}
-			case 3: { // Body
-				{
-					auto pattern = crlf_ + dash_;
-					if (pattern.size() > buf_size()) { return true; }
-
-					auto pos = buf_find(pattern);
-
-					if (!content_callback(buf_data(), pos)) {
-						is_valid_ = false;
-						return false;
-					}
-
-					buf_erase(pos);
-				}
-				{
-					auto pattern = crlf_ + dash_ + boundary_;
-					if (pattern.size() > buf_size()) { return true; }
-
-					auto pos = buf_find(pattern);
-					if (pos < buf_size()) {
-						if (!content_callback(buf_data(), pos)) {
-							is_valid_ = false;
-							return false;
-						}
-
-						buf_erase(pos + pattern.size());
-						state_ = 4;
-					} else {
-						if (!content_callback(buf_data(), pattern.size())) {
-							is_valid_ = false;
-							return false;
-						}
-
-						buf_erase(pattern.size());
-					}
-				}
-				break;
-			}
-			case 4: { // Boundary
-				if (crlf_.size() > buf_size()) { return true; }
-				if (buf_start_with(crlf_)) {
-					buf_erase(crlf_.size());
-					state_ = 1;
-				} else {
-					auto pattern = dash_ + crlf_;
-					if (pattern.size() > buf_size()) { return true; }
-					if (buf_start_with(pattern)) {
-						buf_erase(pattern.size());
-						is_valid_ = true;
-						state_ = 5;
-					} else {
-						return true;
-					}
-				}
-				break;
-			}
-			case 5: { // Done
-				is_valid_ = false;
-				return false;
-			}
-			}
-		}
-
-		return true;
-	}
-
-private:
-	void clear_file_info() {
-		file_.name.clear();
-		file_.filename.clear();
-		file_.content_type.clear();
-	}
-
-	bool start_with_case_ignore(const std::string &a,
-	                            const std::string &b) const {
-		if (a.size() < b.size()) { return false; }
-		for (size_t i = 0; i < b.size(); i++) {
-			if (::tolower(a[i]) != ::tolower(b[i])) { return false; }
-		}
-		return true;
-	}
-
-	std::string boundary_;
-
-	size_t state_ = 0;
-	bool is_valid_ = false;
-	MultipartFormData file_;
-
-	// Buffer
-	bool start_with(const std::string &a, size_t spos, size_t epos,
-	                const std::string &b) const {
-		if (epos - spos < b.size()) { return false; }
-		for (size_t i = 0; i < b.size(); i++) {
-			if (a[i + spos] != b[i]) { return false; }
-		}
-		return true;
-	}
-
-	size_t buf_size() const { return buf_epos_ - buf_spos_; }
-
-	const char *buf_data() const { return &buf_[buf_spos_]; }
-
-	std::string buf_head(size_t l) const { return buf_.substr(buf_spos_, l); }
-
-	bool buf_start_with(const std::string &s) const {
-		return start_with(buf_, buf_spos_, buf_epos_, s);
-	}
-
-	size_t buf_find(const std::string &s) const {
-		auto c = s.front();
-
-		size_t off = buf_spos_;
-		while (off < buf_epos_) {
-			auto pos = off;
-			while (true) {
-				if (pos == buf_epos_) { return buf_size(); }
-				if (buf_[pos] == c) { break; }
-				pos++;
-			}
-
-			auto remaining_size = buf_epos_ - pos;
-			if (s.size() > remaining_size) { return buf_size(); }
-
-			if (start_with(buf_, pos, buf_epos_, s)) { return pos - buf_spos_; }
-
-			off = pos + 1;
-		}
-
-		return buf_size();
-	}
-
-	void buf_append(const char *data, size_t n) {
-		auto remaining_size = buf_size();
-		if (remaining_size > 0 && buf_spos_ > 0) {
-			for (size_t i = 0; i < remaining_size; i++) {
-				buf_[i] = buf_[buf_spos_ + i];
-			}
-		}
-		buf_spos_ = 0;
-		buf_epos_ = remaining_size;
-
-		if (remaining_size + n > buf_.size()) { buf_.resize(remaining_size + n); }
-
-		for (size_t i = 0; i < n; i++) {
-			buf_[buf_epos_ + i] = data[i];
-		}
-		buf_epos_ += n;
-	}
-
-	void buf_erase(size_t size) { buf_spos_ += size; }
-
-	std::string buf_;
-	size_t buf_spos_ = 0;
-	size_t buf_epos_ = 0;
-};
-
-inline std::string to_lower(const char *beg, const char *end) {
-	std::string out;
-	auto it = beg;
-	while (it != end) {
-		out += static_cast<char>(::tolower(*it));
-		it++;
-	}
-	return out;
-}
-
-inline std::string make_multipart_data_boundary() {
-	static const char data[] =
-	    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-	// std::random_device might actually be deterministic on some
-	// platforms, but due to lack of support in the c++ standard library,
-	// doing better requires either some ugly hacks or breaking portability.
-	std::random_device seed_gen;
-
-	// Request 128 bits of entropy for initialization
-	std::seed_seq seed_sequence{seed_gen(), seed_gen(), seed_gen(), seed_gen()};
-	std::mt19937 engine(seed_sequence);
-
-	std::string result = "--cpp-httplib-multipart-data-";
-
-	for (auto i = 0; i < 16; i++) {
-		result += data[engine() % (sizeof(data) - 1)];
-	}
-
-	return result;
-}
-
-inline std::pair<size_t, size_t>
-get_range_offset_and_length(const Request &req, size_t content_length,
-                            size_t index) {
-	auto r = req.ranges[index];
-
-	if (r.first == -1 && r.second == -1) {
-		return std::make_pair(0, content_length);
-	}
-
-	auto slen = static_cast<ssize_t>(content_length);
-
-	if (r.first == -1) {
-		r.first = (std::max)(static_cast<ssize_t>(0), slen - r.second);
-		r.second = slen - 1;
-	}
-
-	if (r.second == -1) { r.second = slen - 1; }
-	return std::make_pair(r.first, static_cast<size_t>(r.second - r.first) + 1);
-}
-
-inline std::string make_content_range_header_field(size_t offset, size_t length,
-                                                   size_t content_length) {
-	std::string field = "bytes ";
-	field += std::to_string(offset);
-	field += "-";
-	field += std::to_string(offset + length - 1);
-	field += "/";
-	field += std::to_string(content_length);
-	return field;
-}
-
-template <typename SToken, typename CToken, typename Content>
-bool process_multipart_ranges_data(const Request &req, Response &res,
-                                   const std::string &boundary,
-                                   const std::string &content_type,
-                                   SToken stoken, CToken ctoken,
-                                   Content content) {
-	for (size_t i = 0; i < req.ranges.size(); i++) {
-		ctoken("--");
-		stoken(boundary);
-		ctoken("\r\n");
-		if (!content_type.empty()) {
-			ctoken("Content-Type: ");
-			stoken(content_type);
-			ctoken("\r\n");
-		}
-
-		auto offsets = get_range_offset_and_length(req, res.body.size(), i);
-		auto offset = offsets.first;
-		auto length = offsets.second;
-
-		ctoken("Content-Range: ");
-		stoken(make_content_range_header_field(offset, length, res.body.size()));
-		ctoken("\r\n");
-		ctoken("\r\n");
-		if (!content(offset, length)) { return false; }
-		ctoken("\r\n");
-	}
-
-	ctoken("--");
-	stoken(boundary);
-	ctoken("--\r\n");
-
-	return true;
-}
-
-inline bool make_multipart_ranges_data(const Request &req, Response &res,
-                                       const std::string &boundary,
-                                       const std::string &content_type,
-                                       std::string &data) {
-	return process_multipart_ranges_data(
-	    req, res, boundary, content_type,
-	    [&](const std::string &token) { data += token; },
-	    [&](const char *token) { data += token; },
-	    [&](size_t offset, size_t length) {
-		    if (offset < res.body.size()) {
-			    data += res.body.substr(offset, length);
-			    return true;
-		    }
-		    return false;
-	    });
-}
-
-inline size_t
-get_multipart_ranges_data_length(const Request &req, Response &res,
-                                 const std::string &boundary,
-                                 const std::string &content_type) {
-	size_t data_length = 0;
-
-	process_multipart_ranges_data(
-	    req, res, boundary, content_type,
-	    [&](const std::string &token) { data_length += token.size(); },
-	    [&](const char *token) { data_length += strlen(token); },
-	    [&](size_t /*offset*/, size_t length) {
-		    data_length += length;
-		    return true;
-	    });
-
-	return data_length;
-}
-
-template <typename T>
-inline bool write_multipart_ranges_data(Stream &strm, const Request &req,
-                                        Response &res,
-                                        const std::string &boundary,
-                                        const std::string &content_type,
-                                        const T &is_shutting_down) {
-	return process_multipart_ranges_data(
-	    req, res, boundary, content_type,
-	    [&](const std::string &token) { strm.write(token); },
-	    [&](const char *token) { strm.write(token); },
-	    [&](size_t offset, size_t length) {
-		    return write_content(strm, res.content_provider_, offset, length,
-		                         is_shutting_down);
-	    });
-}
-
-inline std::pair<size_t, size_t>
-get_range_offset_and_length(const Request &req, const Response &res,
-                            size_t index) {
-	auto r = req.ranges[index];
-
-	if (r.second == -1) {
-		r.second = static_cast<ssize_t>(res.content_length_) - 1;
-	}
-
-	return std::make_pair(r.first, r.second - r.first + 1);
-}
-
-inline bool expect_content(const Request &req) {
-	if (req.method == "POST" || req.method == "PUT" || req.method == "PATCH" ||
-	    req.method == "PRI" || req.method == "DELETE") {
-		return true;
-	}
-	// TODO: check if Content-Length is set
-	return false;
-}
-
-inline bool has_crlf(const char *s) {
-	auto p = s;
-	while (*p) {
-		if (*p == '\r' || *p == '\n') { return true; }
-		p++;
-	}
-	return false;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-template <typename CTX, typename Init, typename Update, typename Final>
-inline std::string message_digest(const std::string &s, Init init,
-                                  Update update, Final final,
-                                  size_t digest_length) {
-	std::vector<unsigned char> md(digest_length, 0);
-	CTX ctx;
-	init(&ctx);
-	update(&ctx, s.data(), s.size());
-	final(md.data(), &ctx);
-
-	std::stringstream ss;
-	for (auto c : md) {
-		ss << std::setfill('0') << std::setw(2) << std::hex << (unsigned int)c;
-	}
-	return ss.str();
-}
-
-inline std::string MD5(const std::string &s) {
-	return message_digest<MD5_CTX>(s, MD5_Init, MD5_Update, MD5_Final,
-	                               MD5_DIGEST_LENGTH);
-}
-
-inline std::string SHA_256(const std::string &s) {
-	return message_digest<SHA256_CTX>(s, SHA256_Init, SHA256_Update, SHA256_Final,
-	                                  SHA256_DIGEST_LENGTH);
-}
-
-inline std::string SHA_512(const std::string &s) {
-	return message_digest<SHA512_CTX>(s, SHA512_Init, SHA512_Update, SHA512_Final,
-	                                  SHA512_DIGEST_LENGTH);
-}
-#endif
-
-#ifdef _WIN32
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-// NOTE: This code came up with the following stackoverflow post:
-// https://stackoverflow.com/questions/9507184/can-openssl-on-windows-use-the-system-certificate-store
-inline bool load_system_certs_on_windows(X509_STORE *store) {
-	auto hStore = CertOpenSystemStoreW((HCRYPTPROV_LEGACY)NULL, L"ROOT");
-
-	if (!hStore) { return false; }
-
-	PCCERT_CONTEXT pContext = NULL;
-	while ((pContext = CertEnumCertificatesInStore(hStore, pContext)) !=
-	       nullptr) {
-		auto encoded_cert =
-		    static_cast<const unsigned char *>(pContext->pbCertEncoded);
-
-		auto x509 = d2i_X509(NULL, &encoded_cert, pContext->cbCertEncoded);
-		if (x509) {
-			X509_STORE_add_cert(store, x509);
-			X509_free(x509);
-		}
-	}
-
-	CertFreeCertificateContext(pContext);
-	CertCloseStore(hStore, 0);
-
-	return true;
-}
-#endif
-
-class WSInit {
-public:
-	WSInit() {
-		WSADATA wsaData;
-		WSAStartup(0x0002, &wsaData);
-	}
-
-	~WSInit() { WSACleanup(); }
-};
-
-static WSInit wsinit_;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline std::pair<std::string, std::string> make_digest_authentication_header(
-    const Request &req, const std::map<std::string, std::string> &auth,
-    size_t cnonce_count, const std::string &cnonce, const std::string &username,
-    const std::string &password, bool is_proxy = false) {
-	std::string nc;
-	{
-		std::stringstream ss;
-		ss << std::setfill('0') << std::setw(8) << std::hex << cnonce_count;
-		nc = ss.str();
-	}
-
-	std::string qop;
-	if (auth.find("qop") != auth.end()) {
-		qop = auth.at("qop");
-		if (qop.find("auth-int") != std::string::npos) {
-			qop = "auth-int";
-		} else if (qop.find("auth") != std::string::npos) {
-			qop = "auth";
-		} else {
-			qop.clear();
-		}
-	}
-
-	std::string algo = "MD5";
-	if (auth.find("algorithm") != auth.end()) { algo = auth.at("algorithm"); }
-
-	std::string response;
-	{
-		auto H = algo == "SHA-256"   ? detail::SHA_256
-		         : algo == "SHA-512" ? detail::SHA_512
-		                             : detail::MD5;
-
-		auto A1 = username + ":" + auth.at("realm") + ":" + password;
-
-		auto A2 = req.method + ":" + req.path;
-		if (qop == "auth-int") { A2 += ":" + H(req.body); }
-
-		if (qop.empty()) {
-			response = H(H(A1) + ":" + auth.at("nonce") + ":" + H(A2));
-		} else {
-			response = H(H(A1) + ":" + auth.at("nonce") + ":" + nc + ":" + cnonce +
-			             ":" + qop + ":" + H(A2));
-		}
-	}
-
-	auto opaque = (auth.find("opaque") != auth.end()) ? auth.at("opaque") : "";
-
-	auto field = "Digest username=\"" + username + "\", realm=\"" +
-	             auth.at("realm") + "\", nonce=\"" + auth.at("nonce") +
-	             "\", uri=\"" + req.path + "\", algorithm=" + algo +
-	             (qop.empty() ? ", response=\""
-	                          : ", qop=" + qop + ", nc=" + nc + ", cnonce=\"" +
-	                                cnonce + "\", response=\"") +
-	             response + "\"" +
-	             (opaque.empty() ? "" : ", opaque=\"" + opaque + "\"");
-
-	auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
-	return std::make_pair(key, field);
-}
-#endif
-
-inline bool parse_www_authenticate(const Response &res,
-                                   std::map<std::string, std::string> &auth,
-                                   bool is_proxy) {
-	auto auth_key = is_proxy ? "Proxy-Authenticate" : "WWW-Authenticate";
-	if (res.has_header(auth_key)) {
-		static Regex re(R"~((?:(?:,\s*)?(.+?)=(?:"(.*?)"|([^,]*))))~");
-		auto s = res.get_header_value(auth_key);
-		auto pos = s.find(' ');
-		if (pos != std::string::npos) {
-			auto type = s.substr(0, pos);
-			if (type == "Basic") {
-				return false;
-			} else if (type == "Digest") {
-				s = s.substr(pos + 1);
-				auto matches = duckdb_re2::RegexFindAll(s, re);
-				for (auto &m : matches) {
-					auto key = s.substr(static_cast<size_t>(m.position(1)),
-					                    static_cast<size_t>(m.length(1)));
-					auto val = m.length(2) > 0
-					               ? s.substr(static_cast<size_t>(m.position(2)),
-					                          static_cast<size_t>(m.length(2)))
-					               : s.substr(static_cast<size_t>(m.position(3)),
-					                          static_cast<size_t>(m.length(3)));
-					auth[key] = val;
-				}
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-// https://stackoverflow.com/questions/440133/how-do-i-create-a-random-alpha-numeric-string-in-c/440240#answer-440240
-inline std::string random_string(size_t length) {
-	auto randchar = []() -> char {
-		const char charset[] = "0123456789"
-		                       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-		                       "abcdefghijklmnopqrstuvwxyz";
-		const size_t max_index = (sizeof(charset) - 1);
-		return charset[static_cast<size_t>(std::rand()) % max_index];
-	};
-	std::string str(length, 0);
-	std::generate_n(str.begin(), length, randchar);
-	return str;
-}
-
-class ContentProviderAdapter {
-public:
-	explicit ContentProviderAdapter(
-	    ContentProviderWithoutLength &&content_provider)
-	    : content_provider_(content_provider) {}
-
-	bool operator()(size_t offset, size_t, DataSink &sink) {
-		return content_provider_(offset, sink);
-	}
-
-private:
-	ContentProviderWithoutLength content_provider_;
-};
-
-} // namespace detail
-
-inline std::string hosted_at(const char *hostname) {
-	std::vector<std::string> addrs;
-	hosted_at(hostname, addrs);
-	if (addrs.empty()) { return std::string(); }
-	return addrs[0];
-}
-
-inline void hosted_at(const char *hostname, std::vector<std::string> &addrs) {
-	struct addrinfo hints;
-	struct addrinfo *result;
-
-	memset(&hints, 0, sizeof(struct addrinfo));
-	hints.ai_family = AF_UNSPEC;
-	hints.ai_socktype = SOCK_STREAM;
-	hints.ai_protocol = 0;
-
-	if (getaddrinfo(hostname, nullptr, &hints, &result)) {
-#if defined __linux__ && !defined __ANDROID__
-		res_init();
-#endif
-		return;
-	}
-
-	for (auto rp = result; rp; rp = rp->ai_next) {
-		const auto &addr =
-		    *reinterpret_cast<struct sockaddr_storage *>(rp->ai_addr);
-		std::string ip;
-		int dummy = -1;
-		if (detail::get_remote_ip_and_port(addr, sizeof(struct sockaddr_storage),
-		                                   ip, dummy)) {
-			addrs.push_back(ip);
-		}
-	}
-}
-
-inline std::string append_query_params(const char *path, const Params &params) {
-	std::string path_with_query = path;
-	const static Regex re("[^?]+\\?.*");
-	auto delm = duckdb_re2::RegexMatch(path, re) ? '&' : '?';
-	path_with_query += delm + detail::params_to_query_str(params);
-	return path_with_query;
-}
-
-// Header utilities
-inline std::pair<std::string, std::string> make_range_header(Ranges ranges) {
-	std::string field = "bytes=";
-	auto i = 0;
-	for (auto r : ranges) {
-		if (i != 0) { field += ", "; }
-		if (r.first != -1) { field += std::to_string(r.first); }
-		field += '-';
-		if (r.second != -1) { field += std::to_string(r.second); }
-		i++;
-	}
-	return std::make_pair("Range", std::move(field));
-}
-
-inline std::pair<std::string, std::string>
-make_basic_authentication_header(const std::string &username,
-                                 const std::string &password, bool is_proxy) {
-	auto field = "Basic " + detail::base64_encode(username + ":" + password);
-	auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
-	return std::make_pair(key, std::move(field));
-}
-
-inline std::pair<std::string, std::string>
-make_bearer_token_authentication_header(const std::string &token,
-                                        bool is_proxy = false) {
-	auto field = "Bearer " + token;
-	auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
-	return std::make_pair(key, std::move(field));
-}
-
-// Request implementation
-inline bool Request::has_header(const char *key) const {
-	return detail::has_header(headers, key);
-}
-
-inline std::string Request::get_header_value(const char *key, size_t id) const {
-	return detail::get_header_value(headers, key, id, "");
-}
-
-inline size_t Request::get_header_value_count(const char *key) const {
-	auto r = headers.equal_range(key);
-	return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline void Request::set_header(const char *key, const char *val) {
-	if (!detail::has_crlf(key) && !detail::has_crlf(val)) {
-		headers.emplace(key, val);
-	}
-}
-
-inline void Request::set_header(const char *key, const std::string &val) {
-	if (!detail::has_crlf(key) && !detail::has_crlf(val.c_str())) {
-		headers.emplace(key, val);
-	}
-}
-
-inline bool Request::has_param(const char *key) const {
-	return params.find(key) != params.end();
-}
-
-inline std::string Request::get_param_value(const char *key, size_t id) const {
-	auto rng = params.equal_range(key);
-	auto it = rng.first;
-	std::advance(it, static_cast<ssize_t>(id));
-	if (it != rng.second) { return it->second; }
-	return std::string();
-}
-
-inline size_t Request::get_param_value_count(const char *key) const {
-	auto r = params.equal_range(key);
-	return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline bool Request::is_multipart_form_data() const {
-	const auto &content_type = get_header_value("Content-Type");
-	return !content_type.rfind("multipart/form-data", 0);
-}
-
-inline bool Request::has_file(const char *key) const {
-	return files.find(key) != files.end();
-}
-
-inline MultipartFormData Request::get_file_value(const char *key) const {
-	auto it = files.find(key);
-	if (it != files.end()) { return it->second; }
-	return MultipartFormData();
-}
-
-// Response implementation
-inline bool Response::has_header(const char *key) const {
-	return headers.find(key) != headers.end();
-}
-
-inline std::string Response::get_header_value(const char *key,
-                                              size_t id) const {
-	return detail::get_header_value(headers, key, id, "");
-}
-
-inline size_t Response::get_header_value_count(const char *key) const {
-	auto r = headers.equal_range(key);
-	return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline void Response::set_header(const char *key, const char *val) {
-	if (!detail::has_crlf(key) && !detail::has_crlf(val)) {
-		headers.emplace(key, val);
-	}
-}
-
-inline void Response::set_header(const char *key, const std::string &val) {
-	if (!detail::has_crlf(key) && !detail::has_crlf(val.c_str())) {
-		headers.emplace(key, val);
-	}
-}
-
-inline void Response::set_redirect(const char *url, int stat) {
-	if (!detail::has_crlf(url)) {
-		set_header("Location", url);
-		if (300 <= stat && stat < 400) {
-			this->status = stat;
-		} else {
-			this->status = 302;
-		}
-	}
-}
-
-inline void Response::set_redirect(const std::string &url, int stat) {
-	set_redirect(url.c_str(), stat);
-}
-
-inline void Response::set_content(const char *s, size_t n,
-                                  const char *content_type) {
-	body.assign(s, n);
-
-	auto rng = headers.equal_range("Content-Type");
-	headers.erase(rng.first, rng.second);
-	set_header("Content-Type", content_type);
-}
-
-inline void Response::set_content(const std::string &s,
-                                  const char *content_type) {
-	set_content(s.data(), s.size(), content_type);
-}
-
-inline void Response::set_content_provider(
-    size_t in_length, const char *content_type, ContentProvider provider,
-    ContentProviderResourceReleaser resource_releaser) {
-	assert(in_length > 0);
-	set_header("Content-Type", content_type);
-	content_length_ = in_length;
-	content_provider_ = std::move(provider);
-	content_provider_resource_releaser_ = resource_releaser;
-	is_chunked_content_provider_ = false;
-}
-
-inline void Response::set_content_provider(
-    const char *content_type, ContentProviderWithoutLength provider,
-    ContentProviderResourceReleaser resource_releaser) {
-	set_header("Content-Type", content_type);
-	content_length_ = 0;
-	content_provider_ = detail::ContentProviderAdapter(std::move(provider));
-	content_provider_resource_releaser_ = resource_releaser;
-	is_chunked_content_provider_ = false;
-}
-
-inline void Response::set_chunked_content_provider(
-    const char *content_type, ContentProviderWithoutLength provider,
-    ContentProviderResourceReleaser resource_releaser) {
-	set_header("Content-Type", content_type);
-	content_length_ = 0;
-	content_provider_ = detail::ContentProviderAdapter(std::move(provider));
-	content_provider_resource_releaser_ = resource_releaser;
-	is_chunked_content_provider_ = true;
-}
-
-// Result implementation
-inline bool Result::has_request_header(const char *key) const {
-	return request_headers_.find(key) != request_headers_.end();
-}
-
-inline std::string Result::get_request_header_value(const char *key,
-                                                    size_t id) const {
-	return detail::get_header_value(request_headers_, key, id, "");
-}
-
-inline size_t Result::get_request_header_value_count(const char *key) const {
-	auto r = request_headers_.equal_range(key);
-	return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-// Stream implementation
-inline ssize_t Stream::write(const char *ptr) {
-	return write(ptr, strlen(ptr));
-}
-
-inline ssize_t Stream::write(const std::string &s) {
-	return write(s.data(), s.size());
-}
-
-namespace detail {
-
-// Socket stream implementation
-inline SocketStream::SocketStream(socket_t sock, time_t read_timeout_sec,
-                                  time_t read_timeout_usec,
-                                  time_t write_timeout_sec,
-                                  time_t write_timeout_usec)
-    : sock_(sock), read_timeout_sec_(read_timeout_sec),
-      read_timeout_usec_(read_timeout_usec),
-      write_timeout_sec_(write_timeout_sec),
-      write_timeout_usec_(write_timeout_usec), read_buff_(read_buff_size_, 0) {}
-
-inline SocketStream::~SocketStream() {}
-
-inline bool SocketStream::is_readable() const {
-	return select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
-}
-
-inline bool SocketStream::is_writable() const {
-	return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0;
-}
-
-inline ssize_t SocketStream::read(char *ptr, size_t size) {
-#ifdef _WIN32
-	size =
-	    (std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
-#else
-	size = (std::min)(size,
-	                  static_cast<size_t>((std::numeric_limits<ssize_t>::max)()));
-#endif
-
-	if (read_buff_off_ < read_buff_content_size_) {
-		auto remaining_size = read_buff_content_size_ - read_buff_off_;
-		if (size <= remaining_size) {
-			memcpy(ptr, read_buff_.data() + read_buff_off_, size);
-			read_buff_off_ += size;
-			return static_cast<ssize_t>(size);
-		} else {
-			memcpy(ptr, read_buff_.data() + read_buff_off_, remaining_size);
-			read_buff_off_ += remaining_size;
-			return static_cast<ssize_t>(remaining_size);
-		}
-	}
-
-	if (!is_readable()) { return -1; }
-
-	read_buff_off_ = 0;
-	read_buff_content_size_ = 0;
-
-	if (size < read_buff_size_) {
-		auto n = read_socket(sock_, read_buff_.data(), read_buff_size_,
-		                     CPPHTTPLIB_RECV_FLAGS);
-		if (n <= 0) {
-			return n;
-		} else if (n <= static_cast<ssize_t>(size)) {
-			memcpy(ptr, read_buff_.data(), static_cast<size_t>(n));
-			return n;
-		} else {
-			memcpy(ptr, read_buff_.data(), size);
-			read_buff_off_ = size;
-			read_buff_content_size_ = static_cast<size_t>(n);
-			return static_cast<ssize_t>(size);
-		}
-	} else {
-		return read_socket(sock_, ptr, size, CPPHTTPLIB_RECV_FLAGS);
-	}
-}
-
-inline ssize_t SocketStream::write(const char *ptr, size_t size) {
-	if (!is_writable()) { return -1; }
-
-#ifdef _WIN32
-	size =
-	    (std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
-#endif
-
-	return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS);
-}
-
-inline void SocketStream::get_remote_ip_and_port(std::string &ip,
-                                                 int &port) const {
-	return detail::get_remote_ip_and_port(sock_, ip, port);
-}
-
-inline socket_t SocketStream::socket() const { return sock_; }
-
-// Buffer stream implementation
-inline bool BufferStream::is_readable() const { return true; }
-
-inline bool BufferStream::is_writable() const { return true; }
-
-inline ssize_t BufferStream::read(char *ptr, size_t size) {
-#if defined(_MSC_VER) && _MSC_VER <= 1900
-	auto len_read = buffer._Copy_s(ptr, size, size, position);
-#else
-	auto len_read = buffer.copy(ptr, size, position);
-#endif
-	position += static_cast<size_t>(len_read);
-	return static_cast<ssize_t>(len_read);
-}
-
-inline ssize_t BufferStream::write(const char *ptr, size_t size) {
-	buffer.append(ptr, size);
-	return static_cast<ssize_t>(size);
-}
-
-inline void BufferStream::get_remote_ip_and_port(std::string & /*ip*/,
-                                                 int & /*port*/) const {}
-
-inline socket_t BufferStream::socket() const { return 0; }
-
-inline const std::string &BufferStream::get_buffer() const { return buffer; }
-
-} // namespace detail
-
-// HTTP server implementation
-inline Server::Server()
-    : new_task_queue(
-          [] { return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT); }),
-      svr_sock_(INVALID_SOCKET), is_running_(false) {
-#ifndef _WIN32
-	signal(SIGPIPE, SIG_IGN);
-#endif
-}
-
-inline Server::~Server() {}
-
-inline Server &Server::Get(const std::string &pattern, Handler handler) {
-	get_handlers_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Post(const std::string &pattern, Handler handler) {
-	post_handlers_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Post(const std::string &pattern,
-                            HandlerWithContentReader handler) {
-	post_handlers_for_content_reader_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Put(const std::string &pattern, Handler handler) {
-	put_handlers_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Put(const std::string &pattern,
-                           HandlerWithContentReader handler) {
-	put_handlers_for_content_reader_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Patch(const std::string &pattern, Handler handler) {
-	patch_handlers_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Patch(const std::string &pattern,
-                             HandlerWithContentReader handler) {
-	patch_handlers_for_content_reader_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Delete(const std::string &pattern, Handler handler) {
-	delete_handlers_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Delete(const std::string &pattern,
-                              HandlerWithContentReader handler) {
-	delete_handlers_for_content_reader_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline Server &Server::Options(const std::string &pattern, Handler handler) {
-	options_handlers_.push_back(
-	    std::make_pair(Regex(pattern), std::move(handler)));
-	return *this;
-}
-
-inline bool Server::set_base_dir(const std::string &dir,
-                                 const std::string &mount_point) {
-	return set_mount_point(mount_point, dir);
-}
-
-inline bool Server::set_mount_point(const std::string &mount_point,
-                                    const std::string &dir, Headers headers) {
-	if (detail::is_dir(dir)) {
-		std::string mnt = !mount_point.empty() ? mount_point : "/";
-		if (!mnt.empty() && mnt[0] == '/') {
-			base_dirs_.push_back({mnt, dir, std::move(headers)});
-			return true;
-		}
-	}
-	return false;
-}
-
-inline bool Server::remove_mount_point(const std::string &mount_point) {
-	for (auto it = base_dirs_.begin(); it != base_dirs_.end(); ++it) {
-		if (it->mount_point == mount_point) {
-			base_dirs_.erase(it);
-			return true;
-		}
-	}
-	return false;
-}
-
-inline Server &
-Server::set_file_extension_and_mimetype_mapping(const char *ext,
-                                                const char *mime) {
-	file_extension_and_mimetype_map_[ext] = mime;
-	return *this;
-}
-
-inline Server &Server::set_file_request_handler(Handler handler) {
-	file_request_handler_ = std::move(handler);
-	return *this;
-}
-
-inline Server &Server::set_error_handler(HandlerWithResponse handler) {
-	error_handler_ = std::move(handler);
-	return *this;
-}
-
-inline Server &Server::set_error_handler(Handler handler) {
-	error_handler_ = [handler](const Request &req, Response &res) {
-		handler(req, res);
-		return HandlerResponse::Handled;
-	};
-	return *this;
-}
-
-inline Server &Server::set_exception_handler(ExceptionHandler handler) {
-	exception_handler_ = std::move(handler);
-	return *this;
-}
-
-inline Server &Server::set_pre_routing_handler(HandlerWithResponse handler) {
-	pre_routing_handler_ = std::move(handler);
-	return *this;
-}
-
-inline Server &Server::set_post_routing_handler(Handler handler) {
-	post_routing_handler_ = std::move(handler);
-	return *this;
-}
-
-inline Server &Server::set_logger(Logger logger) {
-	logger_ = std::move(logger);
-	return *this;
-}
-
-inline Server &
-Server::set_expect_100_continue_handler(Expect100ContinueHandler handler) {
-	expect_100_continue_handler_ = std::move(handler);
-
-	return *this;
-}
-
-inline Server &Server::set_address_family(int family) {
-	address_family_ = family;
-	return *this;
-}
-
-inline Server &Server::set_tcp_nodelay(bool on) {
-	tcp_nodelay_ = on;
-	return *this;
-}
-
-inline Server &Server::set_socket_options(SocketOptions socket_options) {
-	socket_options_ = std::move(socket_options);
-	return *this;
-}
-
-inline Server &Server::set_default_headers(Headers headers) {
-	default_headers_ = std::move(headers);
-	return *this;
-}
-
-inline Server &Server::set_keep_alive_max_count(size_t count) {
-	keep_alive_max_count_ = count;
-	return *this;
-}
-
-inline Server &Server::set_keep_alive_timeout(time_t sec) {
-	keep_alive_timeout_sec_ = sec;
-	return *this;
-}
-
-inline Server &Server::set_read_timeout(time_t sec, time_t usec) {
-	read_timeout_sec_ = sec;
-	read_timeout_usec_ = usec;
-	return *this;
-}
-
-inline Server &Server::set_write_timeout(time_t sec, time_t usec) {
-	write_timeout_sec_ = sec;
-	write_timeout_usec_ = usec;
-	return *this;
-}
-
-inline Server &Server::set_idle_interval(time_t sec, time_t usec) {
-	idle_interval_sec_ = sec;
-	idle_interval_usec_ = usec;
-	return *this;
-}
-
-inline Server &Server::set_payload_max_length(size_t length) {
-	payload_max_length_ = length;
-	return *this;
-}
-
-inline bool Server::bind_to_port(const char *host, int port, int socket_flags) {
-	if (bind_internal(host, port, socket_flags) < 0) return false;
-	return true;
-}
-inline int Server::bind_to_any_port(const char *host, int socket_flags) {
-	return bind_internal(host, 0, socket_flags);
-}
-
-inline bool Server::listen_after_bind() { return listen_internal(); }
-
-inline bool Server::listen(const char *host, int port, int socket_flags) {
-	return bind_to_port(host, port, socket_flags) && listen_internal();
-}
-
-inline bool Server::is_running() const { return is_running_; }
-
-inline void Server::stop() {
-	if (is_running_) {
-		assert(svr_sock_ != INVALID_SOCKET);
-		std::atomic<socket_t> sock(svr_sock_.exchange(INVALID_SOCKET));
-		detail::shutdown_socket(sock);
-		detail::close_socket(sock);
-	}
-}
-
-inline bool Server::parse_request_line(const char *s, Request &req) {
-	auto len = strlen(s);
-	if (len < 2 || s[len - 2] != '\r' || s[len - 1] != '\n') { return false; }
-	len -= 2;
-
-	{
-		size_t count = 0;
-
-		detail::split(s, s + len, ' ', [&](const char *b, const char *e) {
-			switch (count) {
-			case 0: req.method = std::string(b, e); break;
-			case 1: req.target = std::string(b, e); break;
-			case 2: req.version = std::string(b, e); break;
-			default: break;
-			}
-			count++;
-		});
-
-		if (count != 3) { return false; }
-	}
-
-	static const std::set<std::string> methods{
-	    "GET",     "HEAD",    "POST",  "PUT",   "DELETE",
-	    "CONNECT", "OPTIONS", "TRACE", "PATCH", "PRI"};
-
-	if (methods.find(req.method) == methods.end()) { return false; }
-
-	if (req.version != "HTTP/1.1" && req.version != "HTTP/1.0") { return false; }
-
-	{
-		size_t count = 0;
-
-		detail::split(req.target.data(), req.target.data() + req.target.size(), '?',
-		              [&](const char *b, const char *e) {
-			              switch (count) {
-			              case 0:
-				              req.path = detail::decode_url(std::string(b, e), false);
-				              break;
-			              case 1: {
-				              if (e - b > 0) {
-					              detail::parse_query_text(std::string(b, e), req.params);
-				              }
-				              break;
-			              }
-			              default: break;
-			              }
-			              count++;
-		              });
-
-		if (count > 2) { return false; }
-	}
-
-	return true;
-}
-
-inline bool Server::write_response(Stream &strm, bool close_connection,
-                                   const Request &req, Response &res) {
-	return write_response_core(strm, close_connection, req, res, false);
-}
-
-inline bool Server::write_response_with_content(Stream &strm,
-                                                bool close_connection,
-                                                const Request &req,
-                                                Response &res) {
-	return write_response_core(strm, close_connection, req, res, true);
-}
-
-inline bool Server::write_response_core(Stream &strm, bool close_connection,
-                                        const Request &req, Response &res,
-                                        bool need_apply_ranges) {
-	assert(res.status != -1);
-
-	if (400 <= res.status && error_handler_ &&
-	    error_handler_(req, res) == HandlerResponse::Handled) {
-		need_apply_ranges = true;
-	}
-
-	std::string content_type;
-	std::string boundary;
-	if (need_apply_ranges) { apply_ranges(req, res, content_type, boundary); }
-
-	// Prepare additional headers
-	if (close_connection || req.get_header_value("Connection") == "close") {
-		res.set_header("Connection", "close");
-	} else {
-		std::stringstream ss;
-		ss << "timeout=" << keep_alive_timeout_sec_
-		   << ", max=" << keep_alive_max_count_;
-		res.set_header("Keep-Alive", ss.str());
-	}
-
-	if (!res.has_header("Content-Type") &&
-	    (!res.body.empty() || res.content_length_ > 0 || res.content_provider_)) {
-		res.set_header("Content-Type", "text/plain");
-	}
-
-	if (!res.has_header("Content-Length") && res.body.empty() &&
-	    !res.content_length_ && !res.content_provider_) {
-		res.set_header("Content-Length", "0");
-	}
-
-	if (!res.has_header("Accept-Ranges") && req.method == "HEAD") {
-		res.set_header("Accept-Ranges", "bytes");
-	}
-
-	if (post_routing_handler_) { post_routing_handler_(req, res); }
-
-	// Response line and headers
-	{
-		detail::BufferStream bstrm;
-
-		if (!bstrm.write_format("HTTP/1.1 %d %s\r\n", res.status,
-		                        detail::status_message(res.status))) {
-			return false;
-		}
-
-		if (!detail::write_headers(bstrm, res.headers)) { return false; }
-
-		// Flush buffer
-		auto &data = bstrm.get_buffer();
-		strm.write(data.data(), data.size());
-	}
-
-	// Body
-	auto ret = true;
-	if (req.method != "HEAD") {
-		if (!res.body.empty()) {
-			if (!strm.write(res.body)) { ret = false; }
-		} else if (res.content_provider_) {
-			if (write_content_with_provider(strm, req, res, boundary, content_type)) {
-				res.content_provider_success_ = true;
-			} else {
-				res.content_provider_success_ = false;
-				ret = false;
-			}
-		}
-	}
-
-	// Log
-	if (logger_) { logger_(req, res); }
-
-	return ret;
-}
-
-inline bool
-Server::write_content_with_provider(Stream &strm, const Request &req,
-                                    Response &res, const std::string &boundary,
-                                    const std::string &content_type) {
-	auto is_shutting_down = [this]() {
-		return this->svr_sock_ == INVALID_SOCKET;
-	};
-
-	if (res.content_length_ > 0) {
-		if (req.ranges.empty()) {
-			return detail::write_content(strm, res.content_provider_, 0,
-			                             res.content_length_, is_shutting_down);
-		} else if (req.ranges.size() == 1) {
-			auto offsets =
-			    detail::get_range_offset_and_length(req, res.content_length_, 0);
-			auto offset = offsets.first;
-			auto length = offsets.second;
-			return detail::write_content(strm, res.content_provider_, offset, length,
-			                             is_shutting_down);
-		} else {
-			return detail::write_multipart_ranges_data(
-			    strm, req, res, boundary, content_type, is_shutting_down);
-		}
-	} else {
-		if (res.is_chunked_content_provider_) {
-			auto type = detail::encoding_type(req, res);
-
-			std::unique_ptr<detail::compressor> compressor;
-			if (type == detail::EncodingType::Gzip) {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-				compressor = detail::make_unique<detail::gzip_compressor>();
-#endif
-			} else if (type == detail::EncodingType::Brotli) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-				compressor = detail::make_unique<detail::brotli_compressor>();
-#endif
-			} else {
-				compressor = detail::make_unique<detail::nocompressor>();
-			}
-			assert(compressor != nullptr);
-
-			return detail::write_content_chunked(strm, res.content_provider_,
-			                                     is_shutting_down, *compressor);
-		} else {
-			return detail::write_content_without_length(strm, res.content_provider_,
-			                                            is_shutting_down);
-		}
-	}
-}
-
-inline bool Server::read_content(Stream &strm, Request &req, Response &res) {
-	MultipartFormDataMap::iterator cur;
-	if (read_content_core(
-	        strm, req, res,
-	        // Regular
-	        [&](const char *buf, size_t n) {
-		        if (req.body.size() + n > req.body.max_size()) { return false; }
-		        req.body.append(buf, n);
-		        return true;
-	        },
-	        // Multipart
-	        [&](const MultipartFormData &file) {
-		        cur = req.files.emplace(file.name, file);
-		        return true;
-	        },
-	        [&](const char *buf, size_t n) {
-		        auto &content = cur->second.content;
-		        if (content.size() + n > content.max_size()) { return false; }
-		        content.append(buf, n);
-		        return true;
-	        })) {
-		const auto &content_type = req.get_header_value("Content-Type");
-		if (!content_type.find("application/x-www-form-urlencoded")) {
-			if (req.body.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) {
-				res.status = 413; // NOTE: should be 414?
-				return false;
-			}
-			detail::parse_query_text(req.body, req.params);
-		}
-		return true;
-	}
-	return false;
-}
-
-inline bool Server::read_content_with_content_receiver(
-    Stream &strm, Request &req, Response &res, ContentReceiver receiver,
-    MultipartContentHeader multipart_header,
-    ContentReceiver multipart_receiver) {
-	return read_content_core(strm, req, res, std::move(receiver),
-	                         std::move(multipart_header),
-	                         std::move(multipart_receiver));
-}
-
-inline bool Server::read_content_core(Stream &strm, Request &req, Response &res,
-                                      ContentReceiver receiver,
-                                      MultipartContentHeader mulitpart_header,
-                                      ContentReceiver multipart_receiver) {
-	detail::MultipartFormDataParser multipart_form_data_parser;
-	ContentReceiverWithProgress out;
-
-	if (req.is_multipart_form_data()) {
-		const auto &content_type = req.get_header_value("Content-Type");
-		std::string boundary;
-		if (!detail::parse_multipart_boundary(content_type, boundary)) {
-			res.status = 400;
-			return false;
-		}
-
-		multipart_form_data_parser.set_boundary(std::move(boundary));
-		out = [&](const char *buf, size_t n, uint64_t /*off*/, uint64_t /*len*/) {
-			/* For debug
-			size_t pos = 0;
-			while (pos < n) {
-			  auto read_size = (std::min)<size_t>(1, n - pos);
-			  auto ret = multipart_form_data_parser.parse(
-			      buf + pos, read_size, multipart_receiver, mulitpart_header);
-			  if (!ret) { return false; }
-			  pos += read_size;
-			}
-			return true;
-			*/
-			return multipart_form_data_parser.parse(buf, n, multipart_receiver,
-			                                        mulitpart_header);
-		};
-	} else {
-		out = [receiver](const char *buf, size_t n, uint64_t /*off*/,
-		                 uint64_t /*len*/) { return receiver(buf, n); };
-	}
-
-	if (req.method == "DELETE" && !req.has_header("Content-Length")) {
-		return true;
-	}
-
-	if (!detail::read_content(strm, req, payload_max_length_, res.status, nullptr,
-	                          out, true)) {
-		return false;
-	}
-
-	if (req.is_multipart_form_data()) {
-		if (!multipart_form_data_parser.is_valid()) {
-			res.status = 400;
-			return false;
-		}
-	}
-
-	return true;
-}
-
-inline bool Server::handle_file_request(const Request &req, Response &res,
-                                        bool head) {
-	for (const auto &entry : base_dirs_) {
-		// Prefix match
-		if (!req.path.compare(0, entry.mount_point.size(), entry.mount_point)) {
-			std::string sub_path = "/" + req.path.substr(entry.mount_point.size());
-			if (detail::is_valid_path(sub_path)) {
-				auto path = entry.base_dir + sub_path;
-				if (path.back() == '/') { path += "index.html"; }
-
-				if (detail::is_file(path)) {
-					detail::read_file(path, res.body);
-					auto type =
-					    detail::find_content_type(path, file_extension_and_mimetype_map_);
-					if (type) { res.set_header("Content-Type", type); }
-					for (const auto &kv : entry.headers) {
-						res.set_header(kv.first.c_str(), kv.second);
-					}
-					res.status = req.has_header("Range") ? 206 : 200;
-					if (!head && file_request_handler_) {
-						file_request_handler_(req, res);
-					}
-					return true;
-				}
-			}
-		}
-	}
-	return false;
-}
-
-inline socket_t
-Server::create_server_socket(const char *host, int port, int socket_flags,
-                             SocketOptions socket_options) const {
-	return detail::create_socket(
-	    host, "", port, address_family_, socket_flags, tcp_nodelay_,
-	    std::move(socket_options),
-	    [](socket_t sock, struct addrinfo &ai) -> bool {
-		    if (::bind(sock, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen))) {
-			    return false;
-		    }
-		    if (::listen(sock, CPPHTTPLIB_LISTEN_BACKLOG)) { return false; }
-		    return true;
-	    });
-}
-
-inline int Server::bind_internal(const char *host, int port, int socket_flags) {
-	if (!is_valid()) { return -1; }
-
-	svr_sock_ = create_server_socket(host, port, socket_flags, socket_options_);
-	if (svr_sock_ == INVALID_SOCKET) { return -1; }
-
-	if (port == 0) {
-		struct sockaddr_storage addr;
-		socklen_t addr_len = sizeof(addr);
-		if (getsockname(svr_sock_, reinterpret_cast<struct sockaddr *>(&addr),
-		                &addr_len) == -1) {
-			return -1;
-		}
-		if (addr.ss_family == AF_INET) {
-			return ntohs(reinterpret_cast<struct sockaddr_in *>(&addr)->sin_port);
-		} else if (addr.ss_family == AF_INET6) {
-			return ntohs(reinterpret_cast<struct sockaddr_in6 *>(&addr)->sin6_port);
-		} else {
-			return -1;
-		}
-	} else {
-		return port;
-	}
-}
-
-inline bool Server::listen_internal() {
-	auto ret = true;
-	is_running_ = true;
-
-	{
-		std::unique_ptr<TaskQueue> task_queue(new_task_queue());
-
-		while (svr_sock_ != INVALID_SOCKET) {
-#ifndef _WIN32
-			if (idle_interval_sec_ > 0 || idle_interval_usec_ > 0) {
-#endif
-				auto val = detail::select_read(svr_sock_, idle_interval_sec_,
-				                               idle_interval_usec_);
-				if (val == 0) { // Timeout
-					task_queue->on_idle();
-					continue;
-				}
-#ifndef _WIN32
-			}
-#endif
-			socket_t sock = accept(svr_sock_, nullptr, nullptr);
-
-			if (sock == INVALID_SOCKET) {
-				if (errno == EMFILE) {
-					// The per-process limit of open file descriptors has been reached.
-					// Try to accept new connections after a short sleep.
-					std::this_thread::sleep_for(std::chrono::milliseconds(1));
-					continue;
-				}
-				if (svr_sock_ != INVALID_SOCKET) {
-					detail::close_socket(svr_sock_);
-					ret = false;
-				} else {
-					; // The server socket was closed by user.
-				}
-				break;
-			}
-
-			{
-#ifdef _WIN32
-				auto timeout = static_cast<uint32_t>(read_timeout_sec_ * 1000 +
-				                                     read_timeout_usec_ / 1000);
-				setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout,
-				           sizeof(timeout));
-#else
-				timeval tv;
-				tv.tv_sec = static_cast<long>(read_timeout_sec_);
-				tv.tv_usec = static_cast<decltype(tv.tv_usec)>(read_timeout_usec_);
-				setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));
-#endif
-			}
-			{
-
-#ifdef _WIN32
-				auto timeout = static_cast<uint32_t>(write_timeout_sec_ * 1000 +
-				                                     write_timeout_usec_ / 1000);
-				setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout,
-				           sizeof(timeout));
-#else
-				timeval tv;
-				tv.tv_sec = static_cast<long>(write_timeout_sec_);
-				tv.tv_usec = static_cast<decltype(tv.tv_usec)>(write_timeout_usec_);
-				setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv));
-#endif
-			}
-
-#if __cplusplus > 201703L
-			task_queue->enqueue([=, this]() { process_and_close_socket(sock); });
-#else
-			task_queue->enqueue([=]() { process_and_close_socket(sock); });
-#endif
-		}
-
-		task_queue->shutdown();
-	}
-
-	is_running_ = false;
-	return ret;
-}
-
-inline bool Server::routing(Request &req, Response &res, Stream &strm) {
-	if (pre_routing_handler_ &&
-	    pre_routing_handler_(req, res) == HandlerResponse::Handled) {
-		return true;
-	}
-
-	// File handler
-	bool is_head_request = req.method == "HEAD";
-	if ((req.method == "GET" || is_head_request) &&
-	    handle_file_request(req, res, is_head_request)) {
-		return true;
-	}
-
-	if (detail::expect_content(req)) {
-		// Content reader handler
-		{
-			ContentReader reader(
-			    [&](ContentReceiver receiver) {
-				    return read_content_with_content_receiver(
-				        strm, req, res, std::move(receiver), nullptr, nullptr);
-			    },
-			    [&](MultipartContentHeader header, ContentReceiver receiver) {
-				    return read_content_with_content_receiver(strm, req, res, nullptr,
-				                                              std::move(header),
-				                                              std::move(receiver));
-			    });
-
-			if (req.method == "POST") {
-				if (dispatch_request_for_content_reader(
-				        req, res, std::move(reader),
-				        post_handlers_for_content_reader_)) {
-					return true;
-				}
-			} else if (req.method == "PUT") {
-				if (dispatch_request_for_content_reader(
-				        req, res, std::move(reader),
-				        put_handlers_for_content_reader_)) {
-					return true;
-				}
-			} else if (req.method == "PATCH") {
-				if (dispatch_request_for_content_reader(
-				        req, res, std::move(reader),
-				        patch_handlers_for_content_reader_)) {
-					return true;
-				}
-			} else if (req.method == "DELETE") {
-				if (dispatch_request_for_content_reader(
-				        req, res, std::move(reader),
-				        delete_handlers_for_content_reader_)) {
-					return true;
-				}
-			}
-		}
-
-		// Read content into `req.body`
-		if (!read_content(strm, req, res)) { return false; }
-	}
-
-	// Regular handler
-	if (req.method == "GET" || req.method == "HEAD") {
-		return dispatch_request(req, res, get_handlers_);
-	} else if (req.method == "POST") {
-		return dispatch_request(req, res, post_handlers_);
-	} else if (req.method == "PUT") {
-		return dispatch_request(req, res, put_handlers_);
-	} else if (req.method == "DELETE") {
-		return dispatch_request(req, res, delete_handlers_);
-	} else if (req.method == "OPTIONS") {
-		return dispatch_request(req, res, options_handlers_);
-	} else if (req.method == "PATCH") {
-		return dispatch_request(req, res, patch_handlers_);
-	}
-
-	res.status = 400;
-	return false;
-}
-
-inline bool Server::dispatch_request(Request &req, Response &res,
-                                     const Handlers &handlers) {
-	for (const auto &x : handlers) {
-		const auto &pattern = x.first;
-		const auto &handler = x.second;
-
-		if (duckdb_re2::RegexMatch(req.path, req.matches, pattern)) {
-			handler(req, res);
-			return true;
-		}
-	}
-	return false;
-}
-
-inline void Server::apply_ranges(const Request &req, Response &res,
-                                 std::string &content_type,
-                                 std::string &boundary) {
-	if (req.ranges.size() > 1) {
-		boundary = detail::make_multipart_data_boundary();
-
-		auto it = res.headers.find("Content-Type");
-		if (it != res.headers.end()) {
-			content_type = it->second;
-			res.headers.erase(it);
-		}
-
-		res.headers.emplace("Content-Type",
-		                    "multipart/byteranges; boundary=" + boundary);
-	}
-
-	auto type = detail::encoding_type(req, res);
-
-	if (res.body.empty()) {
-		if (res.content_length_ > 0) {
-			size_t length = 0;
-			if (req.ranges.empty()) {
-				length = res.content_length_;
-			} else if (req.ranges.size() == 1) {
-				auto offsets =
-				    detail::get_range_offset_and_length(req, res.content_length_, 0);
-				auto offset = offsets.first;
-				length = offsets.second;
-				auto content_range = detail::make_content_range_header_field(
-				    offset, length, res.content_length_);
-				res.set_header("Content-Range", content_range);
-			} else {
-				length = detail::get_multipart_ranges_data_length(req, res, boundary,
-				                                                  content_type);
-			}
-			res.set_header("Content-Length", std::to_string(length));
-		} else {
-			if (res.content_provider_) {
-				if (res.is_chunked_content_provider_) {
-					res.set_header("Transfer-Encoding", "chunked");
-					if (type == detail::EncodingType::Gzip) {
-						res.set_header("Content-Encoding", "gzip");
-					} else if (type == detail::EncodingType::Brotli) {
-						res.set_header("Content-Encoding", "br");
-					}
-				}
-			}
-		}
-	} else {
-		if (req.ranges.empty()) {
-			;
-		} else if (req.ranges.size() == 1) {
-			auto offsets =
-			    detail::get_range_offset_and_length(req, res.body.size(), 0);
-			auto offset = offsets.first;
-			auto length = offsets.second;
-			auto content_range = detail::make_content_range_header_field(
-			    offset, length, res.body.size());
-			res.set_header("Content-Range", content_range);
-			if (offset < res.body.size()) {
-				res.body = res.body.substr(offset, length);
-			} else {
-				res.body.clear();
-				res.status = 416;
-			}
-		} else {
-			std::string data;
-			if (detail::make_multipart_ranges_data(req, res, boundary, content_type,
-			                                       data)) {
-				res.body.swap(data);
-			} else {
-				res.body.clear();
-				res.status = 416;
-			}
-		}
-
-		if (type != detail::EncodingType::None) {
-			std::unique_ptr<detail::compressor> compressor;
-			std::string content_encoding;
-
-			if (type == detail::EncodingType::Gzip) {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-				compressor = detail::make_unique<detail::gzip_compressor>();
-				content_encoding = "gzip";
-#endif
-			} else if (type == detail::EncodingType::Brotli) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-				compressor = detail::make_unique<detail::brotli_compressor>();
-				content_encoding = "br";
-#endif
-			}
-
-			if (compressor) {
-				std::string compressed;
-				if (compressor->compress(res.body.data(), res.body.size(), true,
-				                         [&](const char *data, size_t data_len) {
-					                         compressed.append(data, data_len);
-					                         return true;
-				                         })) {
-					res.body.swap(compressed);
-					res.set_header("Content-Encoding", content_encoding);
-				}
-			}
-		}
-
-		auto length = std::to_string(res.body.size());
-		res.set_header("Content-Length", length);
-	}
-}
-
-inline bool Server::dispatch_request_for_content_reader(
-    Request &req, Response &res, ContentReader content_reader,
-    const HandlersForContentReader &handlers) {
-	for (const auto &x : handlers) {
-		const auto &pattern = x.first;
-		const auto &handler = x.second;
-
-		if (duckdb_re2::RegexMatch(req.path, req.matches, pattern)) {
-			handler(req, res, content_reader);
-			return true;
-		}
-	}
-	return false;
-}
-
-inline bool
-Server::process_request(Stream &strm, bool close_connection,
-                        bool &connection_closed,
-                        const std::function<void(Request &)> &setup_request) {
-	std::array<char, 2048> buf{};
-
-	detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
-
-	// Connection has been closed on client
-	if (!line_reader.getline()) { return false; }
-
-	Request req;
-	Response res;
-
-	res.version = "HTTP/1.1";
-
-	for (const auto &header : default_headers_) {
-		if (res.headers.find(header.first) == res.headers.end()) {
-			res.headers.insert(header);
-		}
-	}
-
-#ifdef _WIN32
-	// TODO: Increase FD_SETSIZE statically (libzmq), dynamically (MySQL).
-#else
-#ifndef CPPHTTPLIB_USE_POLL
-	// Socket file descriptor exceeded FD_SETSIZE...
-	if (strm.socket() >= FD_SETSIZE) {
-		Headers dummy;
-		detail::read_headers(strm, dummy);
-		res.status = 500;
-		return write_response(strm, close_connection, req, res);
-	}
-#endif
-#endif
-
-	// Check if the request URI doesn't exceed the limit
-	if (line_reader.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) {
-		Headers dummy;
-		detail::read_headers(strm, dummy);
-		res.status = 414;
-		return write_response(strm, close_connection, req, res);
-	}
-
-	// Request line and headers
-	if (!parse_request_line(line_reader.ptr(), req) ||
-	    !detail::read_headers(strm, req.headers)) {
-		res.status = 400;
-		return write_response(strm, close_connection, req, res);
-	}
-
-	if (req.get_header_value("Connection") == "close") {
-		connection_closed = true;
-	}
-
-	if (req.version == "HTTP/1.0" &&
-	    req.get_header_value("Connection") != "Keep-Alive") {
-		connection_closed = true;
-	}
-
-	strm.get_remote_ip_and_port(req.remote_addr, req.remote_port);
-	req.set_header("REMOTE_ADDR", req.remote_addr);
-	req.set_header("REMOTE_PORT", std::to_string(req.remote_port));
-
-	if (req.has_header("Range")) {
-		const auto &range_header_value = req.get_header_value("Range");
-		if (!detail::parse_range_header(range_header_value, req.ranges)) {
-			res.status = 416;
-			return write_response(strm, close_connection, req, res);
-		}
-	}
-
-	if (setup_request) { setup_request(req); }
-
-	if (req.get_header_value("Expect") == "100-continue") {
-		auto status = 100;
-		if (expect_100_continue_handler_) {
-			status = expect_100_continue_handler_(req, res);
-		}
-		switch (status) {
-		case 100:
-		case 417:
-			strm.write_format("HTTP/1.1 %d %s\r\n\r\n", status,
-			                  detail::status_message(status));
-			break;
-		default: return write_response(strm, close_connection, req, res);
-		}
-	}
-
-	// Rounting
-	bool routed = false;
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
-	routed = routing(req, res, strm);
-#else
-	try {
-		routed = routing(req, res, strm);
-	} catch (std::exception &e) {
-		if (exception_handler_) {
-			exception_handler_(req, res, e);
-			routed = true;
-		} else {
-			res.status = 500;
-			res.set_header("EXCEPTION_WHAT", e.what());
-		}
-	} catch (...) {
-		res.status = 500;
-		res.set_header("EXCEPTION_WHAT", "UNKNOWN");
-	}
-#endif
-
-	if (routed) {
-		if (res.status == -1) { res.status = req.ranges.empty() ? 200 : 206; }
-		return write_response_with_content(strm, close_connection, req, res);
-	} else {
-		if (res.status == -1) { res.status = 404; }
-		return write_response(strm, close_connection, req, res);
-	}
-}
-
-inline bool Server::is_valid() const { return true; }
-
-inline bool Server::process_and_close_socket(socket_t sock) {
-	auto ret = detail::process_server_socket(
-	    svr_sock_, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
-	    read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-	    write_timeout_usec_,
-	    [this](Stream &strm, bool close_connection, bool &connection_closed) {
-		    return process_request(strm, close_connection, connection_closed,
-		                           nullptr);
-	    });
-
-	detail::shutdown_socket(sock);
-	detail::close_socket(sock);
-	return ret;
-}
-
-// HTTP client implementation
-inline ClientImpl::ClientImpl(const std::string &host)
-    : ClientImpl(host, 80, std::string(), std::string()) {}
-
-inline ClientImpl::ClientImpl(const std::string &host, int port)
-    : ClientImpl(host, port, std::string(), std::string()) {}
-
-inline ClientImpl::ClientImpl(const std::string &host, int port,
-                              const std::string &client_cert_path,
-                              const std::string &client_key_path)
-    : host_(host), port_(port),
-      host_and_port_(adjust_host_string(host) + ":" + std::to_string(port)),
-      client_cert_path_(client_cert_path), client_key_path_(client_key_path) {}
-
-inline ClientImpl::~ClientImpl() {
-	std::lock_guard<std::mutex> guard(socket_mutex_);
-	shutdown_socket(socket_);
-	close_socket(socket_);
-}
-
-inline bool ClientImpl::is_valid() const { return true; }
-
-inline void ClientImpl::copy_settings(const ClientImpl &rhs) {
-	client_cert_path_ = rhs.client_cert_path_;
-	client_key_path_ = rhs.client_key_path_;
-	connection_timeout_sec_ = rhs.connection_timeout_sec_;
-	read_timeout_sec_ = rhs.read_timeout_sec_;
-	read_timeout_usec_ = rhs.read_timeout_usec_;
-	write_timeout_sec_ = rhs.write_timeout_sec_;
-	write_timeout_usec_ = rhs.write_timeout_usec_;
-	basic_auth_username_ = rhs.basic_auth_username_;
-	basic_auth_password_ = rhs.basic_auth_password_;
-	bearer_token_auth_token_ = rhs.bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	digest_auth_username_ = rhs.digest_auth_username_;
-	digest_auth_password_ = rhs.digest_auth_password_;
-#endif
-	keep_alive_ = rhs.keep_alive_;
-	follow_location_ = rhs.follow_location_;
-	url_encode_ = rhs.url_encode_;
-	address_family_ = rhs.address_family_;
-	tcp_nodelay_ = rhs.tcp_nodelay_;
-	socket_options_ = rhs.socket_options_;
-	compress_ = rhs.compress_;
-	decompress_ = rhs.decompress_;
-	interface_ = rhs.interface_;
-	proxy_host_ = rhs.proxy_host_;
-	proxy_port_ = rhs.proxy_port_;
-	proxy_basic_auth_username_ = rhs.proxy_basic_auth_username_;
-	proxy_basic_auth_password_ = rhs.proxy_basic_auth_password_;
-	proxy_bearer_token_auth_token_ = rhs.proxy_bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	proxy_digest_auth_username_ = rhs.proxy_digest_auth_username_;
-	proxy_digest_auth_password_ = rhs.proxy_digest_auth_password_;
-#endif
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	ca_cert_file_path_ = rhs.ca_cert_file_path_;
-	ca_cert_dir_path_ = rhs.ca_cert_dir_path_;
-	ca_cert_store_ = rhs.ca_cert_store_;
-#endif
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	server_certificate_verification_ = rhs.server_certificate_verification_;
-#endif
-	logger_ = rhs.logger_;
-}
-
-inline socket_t ClientImpl::create_client_socket(Error &error) const {
-	if (!proxy_host_.empty() && proxy_port_ != -1) {
-		return detail::create_client_socket(
-		    proxy_host_.c_str(), "", proxy_port_, address_family_, tcp_nodelay_,
-		    socket_options_, connection_timeout_sec_, connection_timeout_usec_,
-		    read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-		    write_timeout_usec_, interface_, error);
-	}
-
-	// Check is custom IP specified for host_
-	std::string ip;
-	auto it = addr_map_.find(host_);
-	if (it != addr_map_.end()) ip = it->second;
-
-	return detail::create_client_socket(
-	    host_.c_str(), ip.c_str(), port_, address_family_, tcp_nodelay_,
-	    socket_options_, connection_timeout_sec_, connection_timeout_usec_,
-	    read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-	    write_timeout_usec_, interface_, error);
-}
-
-inline bool ClientImpl::create_and_connect_socket(Socket &socket,
-                                                  Error &error) {
-	auto sock = create_client_socket(error);
-	if (sock == INVALID_SOCKET) { return false; }
-	socket.sock = sock;
-	return true;
-}
-
-inline void ClientImpl::shutdown_ssl(Socket & /*socket*/,
-                                     bool /*shutdown_gracefully*/) {
-	// If there are any requests in flight from threads other than us, then it's
-	// a thread-unsafe race because individual ssl* objects are not thread-safe.
-	assert(socket_requests_in_flight_ == 0 ||
-	       socket_requests_are_from_thread_ == std::this_thread::get_id());
-}
-
-inline void ClientImpl::shutdown_socket(Socket &socket) {
-	if (socket.sock == INVALID_SOCKET) { return; }
-	detail::shutdown_socket(socket.sock);
-}
-
-inline void ClientImpl::close_socket(Socket &socket) {
-	// If there are requests in flight in another thread, usually closing
-	// the socket will be fine and they will simply receive an error when
-	// using the closed socket, but it is still a bug since rarely the OS
-	// may reassign the socket id to be used for a new socket, and then
-	// suddenly they will be operating on a live socket that is different
-	// than the one they intended!
-	assert(socket_requests_in_flight_ == 0 ||
-	       socket_requests_are_from_thread_ == std::this_thread::get_id());
-
-	// It is also a bug if this happens while SSL is still active
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	assert(socket.ssl == nullptr);
-#endif
-	if (socket.sock == INVALID_SOCKET) { return; }
-	detail::close_socket(socket.sock);
-	socket.sock = INVALID_SOCKET;
-}
-
-inline bool ClientImpl::read_response_line(Stream &strm, const Request &req,
-                                           Response &res) {
-	std::array<char, 2048> buf{};
-
-	detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
-
-	if (!line_reader.getline()) { return false; }
-
-#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR
-	const static Regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r\n");
-#else
-	const static Regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r?\n");
-#endif
-
-	Match m;
-	if (!duckdb_re2::RegexMatch(line_reader.ptr(), m, re)) {
-		return req.method == "CONNECT";
-	}
-	res.version = std::string(m[1]);
-	res.status = std::stoi(std::string(m[2]));
-	res.reason = std::string(m[3]);
-
-	// Ignore '100 Continue'
-	while (res.status == 100) {
-		if (!line_reader.getline()) { return false; } // CRLF
-		if (!line_reader.getline()) { return false; } // next response line
-
-		if (!duckdb_re2::RegexMatch(line_reader.ptr(), m, re)) { return false; }
-		res.version = std::string(m[1]);
-		res.status = std::stoi(std::string(m[2]));
-		res.reason = std::string(m[3]);
-	}
-
-	return true;
-}
-
-inline bool ClientImpl::send(Request &req, Response &res, Error &error) {
-	std::lock_guard<std::recursive_mutex> request_mutex_guard(request_mutex_);
-
-	{
-		std::lock_guard<std::mutex> guard(socket_mutex_);
-
-		// Set this to false immediately - if it ever gets set to true by the end of
-		// the request, we know another thread instructed us to close the socket.
-		socket_should_be_closed_when_request_is_done_ = false;
-
-		auto is_alive = false;
-		if (socket_.is_open()) {
-			is_alive = detail::is_socket_alive(socket_.sock);
-			if (!is_alive) {
-				// Attempt to avoid sigpipe by shutting down nongracefully if it seems
-				// like the other side has already closed the connection Also, there
-				// cannot be any requests in flight from other threads since we locked
-				// request_mutex_, so safe to close everything immediately
-				const bool shutdown_gracefully = false;
-				shutdown_ssl(socket_, shutdown_gracefully);
-				shutdown_socket(socket_);
-				close_socket(socket_);
-			}
-		}
-
-		if (!is_alive) {
-			if (!create_and_connect_socket(socket_, error)) { return false; }
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-			// TODO: refactoring
-			if (is_ssl()) {
-				auto &scli = static_cast<SSLClient &>(*this);
-				if (!proxy_host_.empty() && proxy_port_ != -1) {
-					bool success = false;
-					if (!scli.connect_with_proxy(socket_, res, success, error)) {
-						return success;
-					}
-				}
-
-				if (!scli.initialize_ssl(socket_, error)) { return false; }
-			}
-#endif
-		}
-
-		// Mark the current socket as being in use so that it cannot be closed by
-		// anyone else while this request is ongoing, even though we will be
-		// releasing the mutex.
-		if (socket_requests_in_flight_ > 1) {
-			assert(socket_requests_are_from_thread_ == std::this_thread::get_id());
-		}
-		socket_requests_in_flight_ += 1;
-		socket_requests_are_from_thread_ = std::this_thread::get_id();
-	}
-
-	for (const auto &header : default_headers_) {
-		if (req.headers.find(header.first) == req.headers.end()) {
-			req.headers.insert(header);
-		}
-	}
-
-	auto close_connection = !keep_alive_;
-	auto ret = process_socket(socket_, [&](Stream &strm) {
-		return handle_request(strm, req, res, close_connection, error);
-	});
-
-	// Briefly lock mutex in order to mark that a request is no longer ongoing
-	{
-		std::lock_guard<std::mutex> guard(socket_mutex_);
-		socket_requests_in_flight_ -= 1;
-		if (socket_requests_in_flight_ <= 0) {
-			assert(socket_requests_in_flight_ == 0);
-			socket_requests_are_from_thread_ = std::thread::id();
-		}
-
-		if (socket_should_be_closed_when_request_is_done_ || close_connection ||
-		    !ret) {
-			shutdown_ssl(socket_, true);
-			shutdown_socket(socket_);
-			close_socket(socket_);
-		}
-	}
-
-	if (!ret) {
-		if (error == Error::Success) { error = Error::Unknown; }
-	}
-
-	return ret;
-}
-
-inline Result ClientImpl::send(const Request &req) {
-	auto req2 = req;
-	return send_(std::move(req2));
-}
-
-inline Result ClientImpl::send_(Request &&req) {
-	auto res = detail::make_unique<Response>();
-	auto error = Error::Success;
-	auto ret = send(req, *res, error);
-	return Result{ret ? std::move(res) : nullptr, error, std::move(req.headers)};
-}
-
-inline bool ClientImpl::handle_request(Stream &strm, Request &req,
-                                       Response &res, bool close_connection,
-                                       Error &error) {
-	if (req.path.empty()) {
-		error = Error::Connection;
-		return false;
-	}
-
-	auto req_save = req;
-
-	bool ret;
-
-	if (!is_ssl() && !proxy_host_.empty() && proxy_port_ != -1) {
-		auto req2 = req;
-		req2.path = "http://" + host_and_port_ + req.path;
-		ret = process_request(strm, req2, res, close_connection, error);
-		req = req2;
-		req.path = req_save.path;
-	} else {
-		ret = process_request(strm, req, res, close_connection, error);
-	}
-
-	if (!ret) { return false; }
-
-	if (300 < res.status && res.status < 400 && follow_location_) {
-		req = req_save;
-		ret = redirect(req, res, error);
-	}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-	if ((res.status == 401 || res.status == 407) &&
-	    req.authorization_count_ < 5) {
-		auto is_proxy = res.status == 407;
-		const auto &username =
-		    is_proxy ? proxy_digest_auth_username_ : digest_auth_username_;
-		const auto &password =
-		    is_proxy ? proxy_digest_auth_password_ : digest_auth_password_;
-
-		if (!username.empty() && !password.empty()) {
-			std::map<std::string, std::string> auth;
-			if (detail::parse_www_authenticate(res, auth, is_proxy)) {
-				Request new_req = req;
-				new_req.authorization_count_ += 1;
-				new_req.headers.erase(is_proxy ? "Proxy-Authorization"
-				                               : "Authorization");
-				new_req.headers.insert(detail::make_digest_authentication_header(
-				    req, auth, new_req.authorization_count_, detail::random_string(10),
-				    username, password, is_proxy));
-
-				Response new_res;
-
-				ret = send(new_req, new_res, error);
-				if (ret) { res = new_res; }
-			}
-		}
-	}
-#endif
-
-	return ret;
-}
-
-inline bool ClientImpl::redirect(Request &req, Response &res, Error &error) {
-	if (req.redirect_count_ == 0) {
-		error = Error::ExceedRedirectCount;
-		return false;
-	}
-
-	auto location = detail::decode_url(res.get_header_value("location"), false);
-	if (location.empty()) { return false; }
-
-	const static Regex re(
-	    R"((?:(https?):)?(?://(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)?([^?#]*(?:\?[^#]*)?)(?:#.*)?)");
-
-	Match m;
-	if (!duckdb_re2::RegexMatch(location, m, re)) { return false; }
-
-	auto scheme = is_ssl() ? "https" : "http";
-
-	auto next_scheme = m[1].str();
-	auto next_host = m[2].str();
-	if (next_host.empty()) { next_host = m[3].str(); }
-	auto port_str = m[4].str();
-	auto next_path = m[5].str();
-
-	auto next_port = port_;
-	if (!port_str.empty()) {
-		next_port = std::stoi(port_str);
-	} else if (!next_scheme.empty()) {
-		next_port = next_scheme == "https" ? 443 : 80;
-	}
-
-	if (next_scheme.empty()) { next_scheme = scheme; }
-	if (next_host.empty()) { next_host = host_; }
-	if (next_path.empty()) { next_path = "/"; }
-
-	if (next_scheme == scheme && next_host == host_ && next_port == port_) {
-		return detail::redirect(*this, req, res, next_path, location, error);
-	} else {
-		if (next_scheme == "https") {
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-			SSLClient cli(next_host.c_str(), next_port);
-			cli.copy_settings(*this);
-			if (ca_cert_store_) { cli.set_ca_cert_store(ca_cert_store_); }
-			return detail::redirect(cli, req, res, next_path, location, error);
-#else
-			return false;
-#endif
-		} else {
-			ClientImpl cli(next_host.c_str(), next_port);
-			cli.copy_settings(*this);
-			return detail::redirect(cli, req, res, next_path, location, error);
-		}
-	}
-}
-
-inline bool ClientImpl::write_content_with_provider(Stream &strm,
-                                                    const Request &req,
-                                                    Error &error) {
-	auto is_shutting_down = []() { return false; };
-
-	if (req.is_chunked_content_provider_) {
-		// TODO: Brotli suport
-		std::unique_ptr<detail::compressor> compressor;
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-		if (compress_) {
-			compressor = detail::make_unique<detail::gzip_compressor>();
-		} else
-#endif
-		{
-			compressor = detail::make_unique<detail::nocompressor>();
-		}
-
-		return detail::write_content_chunked(strm, req.content_provider_,
-		                                     is_shutting_down, *compressor, error);
-	} else {
-		return detail::write_content(strm, req.content_provider_, 0,
-		                             req.content_length_, is_shutting_down, error);
-	}
-} // namespace CPPHTTPLIB_NAMESPACE
-
-inline bool ClientImpl::write_request(Stream &strm, Request &req,
-                                      bool close_connection, Error &error) {
-	// Prepare additional headers
-	if (close_connection) {
-		if (!req.has_header("Connection")) {
-			req.headers.emplace("Connection", "close");
-		}
-	}
-
-	if (!req.has_header("Host")) {
-		if (is_ssl()) {
-			if (port_ == 443) {
-				req.headers.emplace("Host", host_);
-			} else {
-				req.headers.emplace("Host", host_and_port_);
-			}
-		} else {
-			if (port_ == 80) {
-				req.headers.emplace("Host", host_);
-			} else {
-				req.headers.emplace("Host", host_and_port_);
-			}
-		}
-	}
-
-	if (!req.has_header("Accept")) { req.headers.emplace("Accept", "*/*"); }
-
-	if (!req.has_header("User-Agent")) {
-		req.headers.emplace("User-Agent", "cpp-httplib/0.10.1");
-	}
-
-	if (req.body.empty()) {
-		if (req.content_provider_) {
-			if (!req.is_chunked_content_provider_) {
-				if (!req.has_header("Content-Length")) {
-					auto length = std::to_string(req.content_length_);
-					req.headers.emplace("Content-Length", length);
-				}
-			}
-		} else {
-			if (req.method == "POST" || req.method == "PUT" ||
-			    req.method == "PATCH") {
-				req.headers.emplace("Content-Length", "0");
-			}
-		}
-	} else {
-		if (!req.has_header("Content-Type")) {
-			req.headers.emplace("Content-Type", "text/plain");
-		}
-
-		if (!req.has_header("Content-Length")) {
-			auto length = std::to_string(req.body.size());
-			req.headers.emplace("Content-Length", length);
-		}
-	}
-
-	if (!basic_auth_password_.empty() || !basic_auth_username_.empty()) {
-		if (!req.has_header("Authorization")) {
-			req.headers.insert(make_basic_authentication_header(
-			    basic_auth_username_, basic_auth_password_, false));
-		}
-	}
-
-	if (!proxy_basic_auth_username_.empty() &&
-	    !proxy_basic_auth_password_.empty()) {
-		if (!req.has_header("Proxy-Authorization")) {
-			req.headers.insert(make_basic_authentication_header(
-			    proxy_basic_auth_username_, proxy_basic_auth_password_, true));
-		}
-	}
-
-	if (!bearer_token_auth_token_.empty()) {
-		if (!req.has_header("Authorization")) {
-			req.headers.insert(make_bearer_token_authentication_header(
-			    bearer_token_auth_token_, false));
-		}
-	}
-
-	if (!proxy_bearer_token_auth_token_.empty()) {
-		if (!req.has_header("Proxy-Authorization")) {
-			req.headers.insert(make_bearer_token_authentication_header(
-			    proxy_bearer_token_auth_token_, true));
-		}
-	}
-
-	// Request line and headers
-	{
-		detail::BufferStream bstrm;
-
-		const auto &path = url_encode_ ? detail::encode_url(req.path) : req.path;
-		bstrm.write_format("%s %s HTTP/1.1\r\n", req.method.c_str(), path.c_str());
-
-		detail::write_headers(bstrm, req.headers);
-
-		// Flush buffer
-		auto &data = bstrm.get_buffer();
-		if (!detail::write_data(strm, data.data(), data.size())) {
-			error = Error::Write;
-			return false;
-		}
-	}
-
-	// Body
-	if (req.body.empty()) {
-		return write_content_with_provider(strm, req, error);
-	}
-
-	if (!detail::write_data(strm, req.body.data(), req.body.size())) {
-		error = Error::Write;
-		return false;
-	}
-
-	return true;
-}
-
-inline std::unique_ptr<Response> ClientImpl::send_with_content_provider(
-    Request &req,
-    // const char *method, const char *path, const Headers &headers,
-    const char *body, size_t content_length, ContentProvider content_provider,
-    ContentProviderWithoutLength content_provider_without_length,
-    const char *content_type, Error &error) {
-
-	if (content_type) { req.headers.emplace("Content-Type", content_type); }
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-	if (compress_) { req.headers.emplace("Content-Encoding", "gzip"); }
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-	if (compress_ && !content_provider_without_length) {
-		// TODO: Brotli support
-		detail::gzip_compressor compressor;
-
-		if (content_provider) {
-			auto ok = true;
-			size_t offset = 0;
-			DataSink data_sink;
-
-			data_sink.write = [&](const char *data, size_t data_len) -> bool {
-				if (ok) {
-					auto last = offset + data_len == content_length;
-
-					auto ret = compressor.compress(
-					    data, data_len, last, [&](const char *data, size_t data_len) {
-						    req.body.append(data, data_len);
-						    return true;
-					    });
-
-					if (ret) {
-						offset += data_len;
-					} else {
-						ok = false;
-					}
-				}
-				return ok;
-			};
-
-			data_sink.is_writable = [&](void) { return ok && true; };
-
-			while (ok && offset < content_length) {
-				if (!content_provider(offset, content_length - offset, data_sink)) {
-					error = Error::Canceled;
-					return nullptr;
-				}
-			}
-		} else {
-			if (!compressor.compress(body, content_length, true,
-			                         [&](const char *data, size_t data_len) {
-				                         req.body.append(data, data_len);
-				                         return true;
-			                         })) {
-				error = Error::Compression;
-				return nullptr;
-			}
-		}
-	} else
-#endif
-	{
-		if (content_provider) {
-			req.content_length_ = content_length;
-			req.content_provider_ = std::move(content_provider);
-			req.is_chunked_content_provider_ = false;
-		} else if (content_provider_without_length) {
-			req.content_length_ = 0;
-			req.content_provider_ = detail::ContentProviderAdapter(
-			    std::move(content_provider_without_length));
-			req.is_chunked_content_provider_ = true;
-			req.headers.emplace("Transfer-Encoding", "chunked");
-		} else {
-			req.body.assign(body, content_length);
-			;
-		}
-	}
-
-	auto res = detail::make_unique<Response>();
-	return send(req, *res, error) ? std::move(res) : nullptr;
-}
-
-inline Result ClientImpl::send_with_content_provider(
-    const char *method, const char *path, const Headers &headers,
-    const char *body, size_t content_length, ContentProvider content_provider,
-    ContentProviderWithoutLength content_provider_without_length,
-    const char *content_type) {
-	Request req;
-	req.method = method;
-	req.headers = headers;
-	req.path = path;
-
-	auto error = Error::Success;
-
-	auto res = send_with_content_provider(
-	    req,
-	    // method, path, headers,
-	    body, content_length, std::move(content_provider),
-	    std::move(content_provider_without_length), content_type, error);
-
-	return Result{std::move(res), error, std::move(req.headers)};
-}
-
-inline std::string
-ClientImpl::adjust_host_string(const std::string &host) const {
-	if (host.find(':') != std::string::npos) { return "[" + host + "]"; }
-	return host;
-}
-
-inline bool ClientImpl::process_request(Stream &strm, Request &req,
-                                        Response &res, bool close_connection,
-                                        Error &error) {
-	// Send request
-	if (!write_request(strm, req, close_connection, error)) { return false; }
-
-	// Receive response and headers
-	if (!read_response_line(strm, req, res) ||
-	    !detail::read_headers(strm, res.headers)) {
-		error = Error::Read;
-		return false;
-	}
-
-	// Body
-	if ((res.status != 204) && req.method != "HEAD" && req.method != "CONNECT") {
-		auto redirect = 300 < res.status && res.status < 400 && follow_location_;
-
-		if (req.response_handler && !redirect) {
-			if (!req.response_handler(res)) {
-				error = Error::Canceled;
-				return false;
-			}
-		}
-
-		auto out =
-		    req.content_receiver
-		        ? static_cast<ContentReceiverWithProgress>(
-		              [&](const char *buf, size_t n, uint64_t off, uint64_t len) {
-			              if (redirect) { return true; }
-			              auto ret = req.content_receiver(buf, n, off, len);
-			              if (!ret) { error = Error::Canceled; }
-			              return ret;
-		              })
-		        : static_cast<ContentReceiverWithProgress>(
-		              [&](const char *buf, size_t n, uint64_t /*off*/,
-		                  uint64_t /*len*/) {
-			              if (res.body.size() + n > res.body.max_size()) {
-				              return false;
-			              }
-			              res.body.append(buf, n);
-			              return true;
-		              });
-
-		auto progress = [&](uint64_t current, uint64_t total) {
-			if (!req.progress || redirect) { return true; }
-			auto ret = req.progress(current, total);
-			if (!ret) { error = Error::Canceled; }
-			return ret;
-		};
-
-		int dummy_status;
-		if (!detail::read_content(strm, res, (std::numeric_limits<size_t>::max)(),
-		                          dummy_status, std::move(progress), std::move(out),
-		                          decompress_)) {
-			if (error != Error::Canceled) { error = Error::Read; }
-			return false;
-		}
-	}
-
-	if (res.get_header_value("Connection") == "close" ||
-	    (res.version == "HTTP/1.0" && res.reason != "Connection established")) {
-		// TODO this requires a not-entirely-obvious chain of calls to be correct
-		// for this to be safe. Maybe a code refactor (such as moving this out to
-		// the send function and getting rid of the recursiveness of the mutex)
-		// could make this more obvious.
-
-		// This is safe to call because process_request is only called by
-		// handle_request which is only called by send, which locks the request
-		// mutex during the process. It would be a bug to call it from a different
-		// thread since it's a thread-safety issue to do these things to the socket
-		// if another thread is using the socket.
-		std::lock_guard<std::mutex> guard(socket_mutex_);
-		shutdown_ssl(socket_, true);
-		shutdown_socket(socket_);
-		close_socket(socket_);
-	}
-
-	// Log
-	if (logger_) { logger_(req, res); }
-
-	return true;
-}
-
-inline bool
-ClientImpl::process_socket(const Socket &socket,
-                           std::function<bool(Stream &strm)> callback) {
-	return detail::process_client_socket(
-	    socket.sock, read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-	    write_timeout_usec_, std::move(callback));
-}
-
-inline bool ClientImpl::is_ssl() const { return false; }
-
-inline Result ClientImpl::Get(const char *path) {
-	return Get(path, Headers(), Progress());
-}
-
-inline Result ClientImpl::Get(const char *path, Progress progress) {
-	return Get(path, Headers(), std::move(progress));
-}
-
-inline Result ClientImpl::Get(const char *path, const Headers &headers) {
-	return Get(path, headers, Progress());
-}
-
-inline Result ClientImpl::Get(const char *path, const Headers &headers,
-                              Progress progress) {
-	Request req;
-	req.method = "GET";
-	req.path = path;
-	req.headers = headers;
-	req.progress = std::move(progress);
-
-	return send_(std::move(req));
-}
-
-inline Result ClientImpl::Get(const char *path,
-                              ContentReceiver content_receiver) {
-	return Get(path, Headers(), nullptr, std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const char *path,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-	return Get(path, Headers(), nullptr, std::move(content_receiver),
-	           std::move(progress));
-}
-
-inline Result ClientImpl::Get(const char *path, const Headers &headers,
-                              ContentReceiver content_receiver) {
-	return Get(path, headers, nullptr, std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const char *path, const Headers &headers,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-	return Get(path, headers, nullptr, std::move(content_receiver),
-	           std::move(progress));
-}
-
-inline Result ClientImpl::Get(const char *path,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver) {
-	return Get(path, Headers(), std::move(response_handler),
-	           std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const char *path, const Headers &headers,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver) {
-	return Get(path, headers, std::move(response_handler),
-	           std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const char *path,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-	return Get(path, Headers(), std::move(response_handler),
-	           std::move(content_receiver), std::move(progress));
-}
-
-inline Result ClientImpl::Get(const char *path, const Headers &headers,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-	Request req;
-	req.method = "GET";
-	req.path = path;
-	req.headers = headers;
-	req.response_handler = std::move(response_handler);
-	req.content_receiver =
-	    [content_receiver](const char *data, size_t data_length,
-	                       uint64_t /*offset*/, uint64_t /*total_length*/) {
-		    return content_receiver(data, data_length);
-	    };
-	req.progress = std::move(progress);
-
-	return send_(std::move(req));
-}
-
-inline Result ClientImpl::Get(const char *path, const Params &params,
-                              const Headers &headers, Progress progress) {
-	if (params.empty()) { return Get(path, headers); }
-
-	std::string path_with_query = append_query_params(path, params);
-	return Get(path_with_query.c_str(), headers, progress);
-}
-
-inline Result ClientImpl::Get(const char *path, const Params &params,
-                              const Headers &headers,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-	return Get(path, params, headers, nullptr, content_receiver, progress);
-}
-
-inline Result ClientImpl::Get(const char *path, const Params &params,
-                              const Headers &headers,
-                              ResponseHandler response_handler,
-                              ContentReceiver content_receiver,
-                              Progress progress) {
-	if (params.empty()) {
-		return Get(path, headers, response_handler, content_receiver, progress);
-	}
-
-	std::string path_with_query = append_query_params(path, params);
-	return Get(path_with_query.c_str(), headers, response_handler,
-	           content_receiver, progress);
-}
-
-inline Result ClientImpl::Head(const char *path) {
-	return Head(path, Headers());
-}
-
-inline Result ClientImpl::Head(const char *path, const Headers &headers) {
-	Request req;
-	req.method = "HEAD";
-	req.headers = headers;
-	req.path = path;
-
-	return send_(std::move(req));
-}
-
-inline Result ClientImpl::Post(const char *path) {
-	return Post(path, std::string(), nullptr);
-}
-
-inline Result ClientImpl::Post(const char *path, const char *body,
-                               size_t content_length,
-                               const char *content_type) {
-	return Post(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Post(const char *path, const Headers &headers,
-                               const char *body, size_t content_length,
-                               const char *content_type) {
-	return send_with_content_provider("POST", path, headers, body, content_length,
-	                                  nullptr, nullptr, content_type);
-}
-
-inline Result ClientImpl::Post(const char *path, const std::string &body,
-                               const char *content_type) {
-	return Post(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Post(const char *path, const Headers &headers,
-                               const std::string &body,
-                               const char *content_type) {
-	return send_with_content_provider("POST", path, headers, body.data(),
-	                                  body.size(), nullptr, nullptr,
-	                                  content_type);
-}
-
-inline Result ClientImpl::Post(const char *path, const Params &params) {
-	return Post(path, Headers(), params);
-}
-
-inline Result ClientImpl::Post(const char *path, size_t content_length,
-                               ContentProvider content_provider,
-                               const char *content_type) {
-	return Post(path, Headers(), content_length, std::move(content_provider),
-	            content_type);
-}
-
-inline Result ClientImpl::Post(const char *path,
-                               ContentProviderWithoutLength content_provider,
-                               const char *content_type) {
-	return Post(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Post(const char *path, const Headers &headers,
-                               size_t content_length,
-                               ContentProvider content_provider,
-                               const char *content_type) {
-	return send_with_content_provider("POST", path, headers, nullptr,
-	                                  content_length, std::move(content_provider),
-	                                  nullptr, content_type);
-}
-
-inline Result ClientImpl::Post(const char *path, const Headers &headers,
-                               ContentProviderWithoutLength content_provider,
-                               const char *content_type) {
-	return send_with_content_provider("POST", path, headers, nullptr, 0, nullptr,
-	                                  std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Post(const char *path, const Headers &headers,
-                               const Params &params) {
-	auto query = detail::params_to_query_str(params);
-	return Post(path, headers, query, "application/x-www-form-urlencoded");
-}
-
-inline Result ClientImpl::Post(const char *path,
-                               const MultipartFormDataItems &items) {
-	return Post(path, Headers(), items);
-}
-
-inline Result ClientImpl::Post(const char *path, const Headers &headers,
-                               const MultipartFormDataItems &items) {
-	return Post(path, headers, items, detail::make_multipart_data_boundary());
-}
-inline Result ClientImpl::Post(const char *path, const Headers &headers,
-                               const MultipartFormDataItems &items,
-                               const std::string &boundary) {
-	for (size_t i = 0; i < boundary.size(); i++) {
-		char c = boundary[i];
-		if (!std::isalnum(c) && c != '-' && c != '_') {
-			return Result{nullptr, Error::UnsupportedMultipartBoundaryChars};
-		}
-	}
-
-	std::string body;
-
-	for (const auto &item : items) {
-		body += "--" + boundary + "\r\n";
-		body += "Content-Disposition: form-data; name=\"" + item.name + "\"";
-		if (!item.filename.empty()) {
-			body += "; filename=\"" + item.filename + "\"";
-		}
-		body += "\r\n";
-		if (!item.content_type.empty()) {
-			body += "Content-Type: " + item.content_type + "\r\n";
-		}
-		body += "\r\n";
-		body += item.content + "\r\n";
-	}
-
-	body += "--" + boundary + "--\r\n";
-
-	std::string content_type = "multipart/form-data; boundary=" + boundary;
-	return Post(path, headers, body, content_type.c_str());
-}
-
-inline Result ClientImpl::Put(const char *path) {
-	return Put(path, std::string(), nullptr);
-}
-
-inline Result ClientImpl::Put(const char *path, const char *body,
-                              size_t content_length, const char *content_type) {
-	return Put(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Put(const char *path, const Headers &headers,
-                              const char *body, size_t content_length,
-                              const char *content_type) {
-	return send_with_content_provider("PUT", path, headers, body, content_length,
-	                                  nullptr, nullptr, content_type);
-}
-
-inline Result ClientImpl::Put(const char *path, const std::string &body,
-                              const char *content_type) {
-	return Put(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Put(const char *path, const Headers &headers,
-                              const std::string &body,
-                              const char *content_type) {
-	return send_with_content_provider("PUT", path, headers, body.data(),
-	                                  body.size(), nullptr, nullptr,
-	                                  content_type);
-}
-
-inline Result ClientImpl::Put(const char *path, size_t content_length,
-                              ContentProvider content_provider,
-                              const char *content_type) {
-	return Put(path, Headers(), content_length, std::move(content_provider),
-	           content_type);
-}
-
-inline Result ClientImpl::Put(const char *path,
-                              ContentProviderWithoutLength content_provider,
-                              const char *content_type) {
-	return Put(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Put(const char *path, const Headers &headers,
-                              size_t content_length,
-                              ContentProvider content_provider,
-                              const char *content_type) {
-	return send_with_content_provider("PUT", path, headers, nullptr,
-	                                  content_length, std::move(content_provider),
-	                                  nullptr, content_type);
-}
-
-inline Result ClientImpl::Put(const char *path, const Headers &headers,
-                              ContentProviderWithoutLength content_provider,
-                              const char *content_type) {
-	return send_with_content_provider("PUT", path, headers, nullptr, 0, nullptr,
-	                                  std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Put(const char *path, const Params &params) {
-	return Put(path, Headers(), params);
-}
-
-inline Result ClientImpl::Put(const char *path, const Headers &headers,
-                              const Params &params) {
-	auto query = detail::params_to_query_str(params);
-	return Put(path, headers, query, "application/x-www-form-urlencoded");
-}
-
-inline Result ClientImpl::Patch(const char *path) {
-	return Patch(path, std::string(), nullptr);
-}
-
-inline Result ClientImpl::Patch(const char *path, const char *body,
-                                size_t content_length,
-                                const char *content_type) {
-	return Patch(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Patch(const char *path, const Headers &headers,
-                                const char *body, size_t content_length,
-                                const char *content_type) {
-	return send_with_content_provider("PATCH", path, headers, body,
-	                                  content_length, nullptr, nullptr,
-	                                  content_type);
-}
-
-inline Result ClientImpl::Patch(const char *path, const std::string &body,
-                                const char *content_type) {
-	return Patch(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Patch(const char *path, const Headers &headers,
-                                const std::string &body,
-                                const char *content_type) {
-	return send_with_content_provider("PATCH", path, headers, body.data(),
-	                                  body.size(), nullptr, nullptr,
-	                                  content_type);
-}
-
-inline Result ClientImpl::Patch(const char *path, size_t content_length,
-                                ContentProvider content_provider,
-                                const char *content_type) {
-	return Patch(path, Headers(), content_length, std::move(content_provider),
-	             content_type);
-}
-
-inline Result ClientImpl::Patch(const char *path,
-                                ContentProviderWithoutLength content_provider,
-                                const char *content_type) {
-	return Patch(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Patch(const char *path, const Headers &headers,
-                                size_t content_length,
-                                ContentProvider content_provider,
-                                const char *content_type) {
-	return send_with_content_provider("PATCH", path, headers, nullptr,
-	                                  content_length, std::move(content_provider),
-	                                  nullptr, content_type);
-}
-
-inline Result ClientImpl::Patch(const char *path, const Headers &headers,
-                                ContentProviderWithoutLength content_provider,
-                                const char *content_type) {
-	return send_with_content_provider("PATCH", path, headers, nullptr, 0, nullptr,
-	                                  std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Delete(const char *path) {
-	return Delete(path, Headers(), std::string(), nullptr);
-}
-
-inline Result ClientImpl::Delete(const char *path, const Headers &headers) {
-	return Delete(path, headers, std::string(), nullptr);
-}
-
-inline Result ClientImpl::Delete(const char *path, const char *body,
-                                 size_t content_length,
-                                 const char *content_type) {
-	return Delete(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Delete(const char *path, const Headers &headers,
-                                 const char *body, size_t content_length,
-                                 const char *content_type) {
-	Request req;
-	req.method = "DELETE";
-	req.headers = headers;
-	req.path = path;
-
-	if (content_type) { req.headers.emplace("Content-Type", content_type); }
-	req.body.assign(body, content_length);
-
-	return send_(std::move(req));
-}
-
-inline Result ClientImpl::Delete(const char *path, const std::string &body,
-                                 const char *content_type) {
-	return Delete(path, Headers(), body.data(), body.size(), content_type);
-}
-
-inline Result ClientImpl::Delete(const char *path, const Headers &headers,
-                                 const std::string &body,
-                                 const char *content_type) {
-	return Delete(path, headers, body.data(), body.size(), content_type);
-}
-
-inline Result ClientImpl::Options(const char *path) {
-	return Options(path, Headers());
-}
-
-inline Result ClientImpl::Options(const char *path, const Headers &headers) {
-	Request req;
-	req.method = "OPTIONS";
-	req.headers = headers;
-	req.path = path;
-
-	return send_(std::move(req));
-}
-
-inline size_t ClientImpl::is_socket_open() const {
-	std::lock_guard<std::mutex> guard(socket_mutex_);
-	return socket_.is_open();
-}
-
-inline void ClientImpl::stop() {
-	std::lock_guard<std::mutex> guard(socket_mutex_);
-
-	// If there is anything ongoing right now, the ONLY thread-safe thing we can
-	// do is to shutdown_socket, so that threads using this socket suddenly
-	// discover they can't read/write any more and error out. Everything else
-	// (closing the socket, shutting ssl down) is unsafe because these actions are
-	// not thread-safe.
-	if (socket_requests_in_flight_ > 0) {
-		shutdown_socket(socket_);
-
-		// Aside from that, we set a flag for the socket to be closed when we're
-		// done.
-		socket_should_be_closed_when_request_is_done_ = true;
-		return;
-	}
-
-	// Otherwise, sitll holding the mutex, we can shut everything down ourselves
-	shutdown_ssl(socket_, true);
-	shutdown_socket(socket_);
-	close_socket(socket_);
-}
-
-inline void ClientImpl::set_connection_timeout(time_t sec, time_t usec) {
-	connection_timeout_sec_ = sec;
-	connection_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_read_timeout(time_t sec, time_t usec) {
-	read_timeout_sec_ = sec;
-	read_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_write_timeout(time_t sec, time_t usec) {
-	write_timeout_sec_ = sec;
-	write_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_basic_auth(const char *username,
-                                       const char *password) {
-	basic_auth_username_ = username;
-	basic_auth_password_ = password;
-}
-
-inline void ClientImpl::set_bearer_token_auth(const char *token) {
-	bearer_token_auth_token_ = token;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void ClientImpl::set_digest_auth(const char *username,
-                                        const char *password) {
-	digest_auth_username_ = username;
-	digest_auth_password_ = password;
-}
-#endif
-
-inline void ClientImpl::set_keep_alive(bool on) { keep_alive_ = on; }
-
-inline void ClientImpl::set_follow_location(bool on) { follow_location_ = on; }
-
-inline void ClientImpl::set_url_encode(bool on) { url_encode_ = on; }
-
-inline void ClientImpl::set_hostname_addr_map(
-    const std::map<std::string, std::string> addr_map) {
-	addr_map_ = std::move(addr_map);
-}
-
-inline void ClientImpl::set_default_headers(Headers headers) {
-	default_headers_ = std::move(headers);
-}
-
-inline void ClientImpl::set_address_family(int family) {
-	address_family_ = family;
-}
-
-inline void ClientImpl::set_tcp_nodelay(bool on) { tcp_nodelay_ = on; }
-
-inline void ClientImpl::set_socket_options(SocketOptions socket_options) {
-	socket_options_ = std::move(socket_options);
-}
-
-inline void ClientImpl::set_compress(bool on) { compress_ = on; }
-
-inline void ClientImpl::set_decompress(bool on) { decompress_ = on; }
-
-inline void ClientImpl::set_interface(const char *intf) { interface_ = intf; }
-
-inline void ClientImpl::set_proxy(const char *host, int port) {
-	proxy_host_ = host;
-	proxy_port_ = port;
-}
-
-inline void ClientImpl::set_proxy_basic_auth(const char *username,
-                                             const char *password) {
-	proxy_basic_auth_username_ = username;
-	proxy_basic_auth_password_ = password;
-}
-
-inline void ClientImpl::set_proxy_bearer_token_auth(const char *token) {
-	proxy_bearer_token_auth_token_ = token;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void ClientImpl::set_proxy_digest_auth(const char *username,
-                                              const char *password) {
-	proxy_digest_auth_username_ = username;
-	proxy_digest_auth_password_ = password;
-}
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void ClientImpl::set_ca_cert_path(const char *ca_cert_file_path,
-                                         const char *ca_cert_dir_path) {
-	if (ca_cert_file_path) { ca_cert_file_path_ = ca_cert_file_path; }
-	if (ca_cert_dir_path) { ca_cert_dir_path_ = ca_cert_dir_path; }
-}
-
-inline void ClientImpl::set_ca_cert_store(X509_STORE *ca_cert_store) {
-	if (ca_cert_store && ca_cert_store != ca_cert_store_) {
-		ca_cert_store_ = ca_cert_store;
-	}
-}
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void ClientImpl::enable_server_certificate_verification(bool enabled) {
-	server_certificate_verification_ = enabled;
-}
-#endif
-
-inline void ClientImpl::set_logger(Logger logger) {
-	logger_ = std::move(logger);
-}
-
-/*
- * SSL Implementation
- */
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-namespace detail {
-
-template <typename U, typename V>
-inline SSL *ssl_new(socket_t sock, SSL_CTX *ctx, std::mutex &ctx_mutex,
-                    U SSL_connect_or_accept, V setup) {
-	SSL *ssl = nullptr;
-	{
-		std::lock_guard<std::mutex> guard(ctx_mutex);
-		ssl = SSL_new(ctx);
-	}
-
-	if (ssl) {
-		set_nonblocking(sock, true);
-		auto bio = BIO_new_socket(static_cast<int>(sock), BIO_NOCLOSE);
-		BIO_set_nbio(bio, 1);
-		SSL_set_bio(ssl, bio, bio);
-
-		if (!setup(ssl) || SSL_connect_or_accept(ssl) != 1) {
-			SSL_shutdown(ssl);
-			{
-				std::lock_guard<std::mutex> guard(ctx_mutex);
-				SSL_free(ssl);
-			}
-			set_nonblocking(sock, false);
-			return nullptr;
-		}
-		BIO_set_nbio(bio, 0);
-		set_nonblocking(sock, false);
-	}
-
-	return ssl;
-}
-
-inline void ssl_delete(std::mutex &ctx_mutex, SSL *ssl,
-                       bool shutdown_gracefully) {
-	// sometimes we may want to skip this to try to avoid SIGPIPE if we know
-	// the remote has closed the network connection
-	// Note that it is not always possible to avoid SIGPIPE, this is merely a
-	// best-efforts.
-	if (shutdown_gracefully) { SSL_shutdown(ssl); }
-
-	std::lock_guard<std::mutex> guard(ctx_mutex);
-	SSL_free(ssl);
-}
-
-template <typename U>
-bool ssl_connect_or_accept_nonblocking(socket_t sock, SSL *ssl,
-                                       U ssl_connect_or_accept,
-                                       time_t timeout_sec,
-                                       time_t timeout_usec) {
-	int res = 0;
-	while ((res = ssl_connect_or_accept(ssl)) != 1) {
-		auto err = SSL_get_error(ssl, res);
-		switch (err) {
-		case SSL_ERROR_WANT_READ:
-			if (select_read(sock, timeout_sec, timeout_usec) > 0) { continue; }
-			break;
-		case SSL_ERROR_WANT_WRITE:
-			if (select_write(sock, timeout_sec, timeout_usec) > 0) { continue; }
-			break;
-		default: break;
-		}
-		return false;
-	}
-	return true;
-}
-
-template <typename T>
-inline bool process_server_socket_ssl(
-    const std::atomic<socket_t> &svr_sock, SSL *ssl, socket_t sock,
-    size_t keep_alive_max_count, time_t keep_alive_timeout_sec,
-    time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
-    time_t write_timeout_usec, T callback) {
-	return process_server_socket_core(
-	    svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec,
-	    [&](bool close_connection, bool &connection_closed) {
-		    SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec,
-		                         write_timeout_sec, write_timeout_usec);
-		    return callback(strm, close_connection, connection_closed);
-	    });
-}
-
-template <typename T>
-inline bool
-process_client_socket_ssl(SSL *ssl, socket_t sock, time_t read_timeout_sec,
-                          time_t read_timeout_usec, time_t write_timeout_sec,
-                          time_t write_timeout_usec, T callback) {
-	SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec,
-	                     write_timeout_sec, write_timeout_usec);
-	return callback(strm);
-}
-
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
-static std::shared_ptr<std::vector<std::mutex>> openSSL_locks_;
-
-class SSLThreadLocks {
-public:
-	SSLThreadLocks() {
-		openSSL_locks_ =
-		    std::make_shared<std::vector<std::mutex>>(CRYPTO_num_locks());
-		CRYPTO_set_locking_callback(locking_callback);
-	}
-
-	~SSLThreadLocks() { CRYPTO_set_locking_callback(nullptr); }
-
-private:
-	static void locking_callback(int mode, int type, const char * /*file*/,
-	                             int /*line*/) {
-		auto &lk = (*openSSL_locks_)[static_cast<size_t>(type)];
-		if (mode & CRYPTO_LOCK) {
-			lk.lock();
-		} else {
-			lk.unlock();
-		}
-	}
-};
-
-#endif
-
-class SSLInit {
-public:
-	SSLInit() {
-#if OPENSSL_VERSION_NUMBER < 0x1010001fL
-		SSL_load_error_strings();
-		SSL_library_init();
-#else
-		OPENSSL_init_ssl(
-		    OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL);
-#endif
-	}
-
-	~SSLInit() {
-#if OPENSSL_VERSION_NUMBER < 0x1010001fL
-		ERR_free_strings();
-#endif
-	}
-
-private:
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
-	SSLThreadLocks thread_init_;
-#endif
-};
-
-// SSL socket stream implementation
-inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl,
-                                        time_t read_timeout_sec,
-                                        time_t read_timeout_usec,
-                                        time_t write_timeout_sec,
-                                        time_t write_timeout_usec)
-    : sock_(sock), ssl_(ssl), read_timeout_sec_(read_timeout_sec),
-      read_timeout_usec_(read_timeout_usec),
-      write_timeout_sec_(write_timeout_sec),
-      write_timeout_usec_(write_timeout_usec) {
-	SSL_clear_mode(ssl, SSL_MODE_AUTO_RETRY);
-}
-
-inline SSLSocketStream::~SSLSocketStream() {}
-
-inline bool SSLSocketStream::is_readable() const {
-	return detail::select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
-}
-
-inline bool SSLSocketStream::is_writable() const {
-	return detail::select_write(sock_, write_timeout_sec_, write_timeout_usec_) >
-	       0;
-}
-
-inline ssize_t SSLSocketStream::read(char *ptr, size_t size) {
-	if (SSL_pending(ssl_) > 0) {
-		return SSL_read(ssl_, ptr, static_cast<int>(size));
-	} else if (is_readable()) {
-		auto ret = SSL_read(ssl_, ptr, static_cast<int>(size));
-		if (ret < 0) {
-			auto err = SSL_get_error(ssl_, ret);
-			int n = 1000;
-#ifdef _WIN32
-			while (--n >= 0 && (err == SSL_ERROR_WANT_READ ||
-			                    (err == SSL_ERROR_SYSCALL &&
-			                     WSAGetLastError() == WSAETIMEDOUT))) {
-#else
-			while (--n >= 0 && err == SSL_ERROR_WANT_READ) {
-#endif
-				if (SSL_pending(ssl_) > 0) {
-					return SSL_read(ssl_, ptr, static_cast<int>(size));
-				} else if (is_readable()) {
-					std::this_thread::sleep_for(std::chrono::milliseconds(1));
-					ret = SSL_read(ssl_, ptr, static_cast<int>(size));
-					if (ret >= 0) { return ret; }
-					err = SSL_get_error(ssl_, ret);
-				} else {
-					return -1;
-				}
-			}
-		}
-		return ret;
-	}
-	return -1;
-}
-
-inline ssize_t SSLSocketStream::write(const char *ptr, size_t size) {
-	if (is_writable()) {
-		auto ret = SSL_write(ssl_, ptr, static_cast<int>(size));
-		if (ret < 0) {
-			auto err = SSL_get_error(ssl_, ret);
-			int n = 1000;
-#ifdef _WIN32
-			while (--n >= 0 && (err == SSL_ERROR_WANT_WRITE ||
-			                    (err == SSL_ERROR_SYSCALL &&
-			                     WSAGetLastError() == WSAETIMEDOUT))) {
-#else
-			while (--n >= 0 && err == SSL_ERROR_WANT_WRITE) {
-#endif
-				if (is_writable()) {
-					std::this_thread::sleep_for(std::chrono::milliseconds(1));
-					ret = SSL_write(ssl_, ptr, static_cast<int>(size));
-					if (ret >= 0) { return ret; }
-					err = SSL_get_error(ssl_, ret);
-				} else {
-					return -1;
-				}
-			}
-		}
-		return ret;
-	}
-	return -1;
-}
-
-inline void SSLSocketStream::get_remote_ip_and_port(std::string &ip,
-                                                    int &port) const {
-	detail::get_remote_ip_and_port(sock_, ip, port);
-}
-
-inline socket_t SSLSocketStream::socket() const { return sock_; }
-
-static SSLInit sslinit_;
-
-} // namespace detail
-
-// SSL HTTP server implementation
-inline SSLServer::SSLServer(const char *cert_path, const char *private_key_path,
-                            const char *client_ca_cert_file_path,
-                            const char *client_ca_cert_dir_path) {
-	ctx_ = SSL_CTX_new(TLS_server_method());
-
-	if (ctx_) {
-		SSL_CTX_set_options(ctx_,
-		                    SSL_OP_NO_COMPRESSION |
-		                        SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
-
-		SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION);
-
-		if (SSL_CTX_use_certificate_chain_file(ctx_, cert_path) != 1 ||
-		    SSL_CTX_use_PrivateKey_file(ctx_, private_key_path, SSL_FILETYPE_PEM) !=
-		        1) {
-			SSL_CTX_free(ctx_);
-			ctx_ = nullptr;
-		} else if (client_ca_cert_file_path || client_ca_cert_dir_path) {
-			SSL_CTX_load_verify_locations(ctx_, client_ca_cert_file_path,
-			                              client_ca_cert_dir_path);
-
-			SSL_CTX_set_verify(
-			    ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
-		}
-	}
-}
-
-inline SSLServer::SSLServer(X509 *cert, EVP_PKEY *private_key,
-                            X509_STORE *client_ca_cert_store) {
-	ctx_ = SSL_CTX_new(TLS_server_method());
-
-	if (ctx_) {
-		SSL_CTX_set_options(ctx_,
-		                    SSL_OP_NO_COMPRESSION |
-		                        SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
-
-		SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION);
-
-		if (SSL_CTX_use_certificate(ctx_, cert) != 1 ||
-		    SSL_CTX_use_PrivateKey(ctx_, private_key) != 1) {
-			SSL_CTX_free(ctx_);
-			ctx_ = nullptr;
-		} else if (client_ca_cert_store) {
-			SSL_CTX_set_cert_store(ctx_, client_ca_cert_store);
-
-			SSL_CTX_set_verify(
-			    ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
-		}
-	}
-}
-
-inline SSLServer::SSLServer(
-    const std::function<bool(SSL_CTX &ssl_ctx)> &setup_ssl_ctx_callback) {
-	ctx_ = SSL_CTX_new(TLS_method());
-	if (ctx_) {
-		if (!setup_ssl_ctx_callback(*ctx_)) {
-			SSL_CTX_free(ctx_);
-			ctx_ = nullptr;
-		}
-	}
-}
-
-inline SSLServer::~SSLServer() {
-	if (ctx_) { SSL_CTX_free(ctx_); }
-}
-
-inline bool SSLServer::is_valid() const { return ctx_; }
-
-inline SSL_CTX *SSLServer::ssl_context() const { return ctx_; }
-
-inline bool SSLServer::process_and_close_socket(socket_t sock) {
-	auto ssl = detail::ssl_new(
-	    sock, ctx_, ctx_mutex_,
-	    [&](SSL *ssl) {
-		    return detail::ssl_connect_or_accept_nonblocking(
-		        sock, ssl, SSL_accept, read_timeout_sec_, read_timeout_usec_);
-	    },
-	    [](SSL * /*ssl*/) { return true; });
-
-	bool ret = false;
-	if (ssl) {
-		ret = detail::process_server_socket_ssl(
-		    svr_sock_, ssl, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
-		    read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
-		    write_timeout_usec_,
-		    [this, ssl](Stream &strm, bool close_connection,
-		                bool &connection_closed) {
-			    return process_request(strm, close_connection, connection_closed,
-			                           [&](Request &req) { req.ssl = ssl; });
-		    });
-
-		// Shutdown gracefully if the result seemed successful, non-gracefully if
-		// the connection appeared to be closed.
-		const bool shutdown_gracefully = ret;
-		detail::ssl_delete(ctx_mutex_, ssl, shutdown_gracefully);
-	}
-
-	detail::shutdown_socket(sock);
-	detail::close_socket(sock);
-	return ret;
-}
-
-// SSL HTTP client implementation
-inline SSLClient::SSLClient(const std::string &host)
-    : SSLClient(host, 443, std::string(), std::string()) {}
-
-inline SSLClient::SSLClient(const std::string &host, int port)
-    : SSLClient(host, port, std::string(), std::string()) {}
-
-inline SSLClient::SSLClient(const std::string &host, int port,
-                            const std::string &client_cert_path,
-                            const std::string &client_key_path)
-    : ClientImpl(host, port, client_cert_path, client_key_path) {
-	ctx_ = SSL_CTX_new(TLS_client_method());
-
-	detail::split(&host_[0], &host_[host_.size()], '.',
-	              [&](const char *b, const char *e) {
-		              host_components_.emplace_back(std::string(b, e));
-	              });
-
-	if (!client_cert_path.empty() && !client_key_path.empty()) {
-		if (SSL_CTX_use_certificate_file(ctx_, client_cert_path.c_str(),
-		                                 SSL_FILETYPE_PEM) != 1 ||
-		    SSL_CTX_use_PrivateKey_file(ctx_, client_key_path.c_str(),
-		                                SSL_FILETYPE_PEM) != 1) {
-			SSL_CTX_free(ctx_);
-			ctx_ = nullptr;
-		}
-	}
-}
-
-inline SSLClient::SSLClient(const std::string &host, int port,
-                            X509 *client_cert, EVP_PKEY *client_key)
-    : ClientImpl(host, port) {
-	ctx_ = SSL_CTX_new(TLS_client_method());
-
-	detail::split(&host_[0], &host_[host_.size()], '.',
-	              [&](const char *b, const char *e) {
-		              host_components_.emplace_back(std::string(b, e));
-	              });
-
-	if (client_cert != nullptr && client_key != nullptr) {
-		if (SSL_CTX_use_certificate(ctx_, client_cert) != 1 ||
-		    SSL_CTX_use_PrivateKey(ctx_, client_key) != 1) {
-			SSL_CTX_free(ctx_);
-			ctx_ = nullptr;
-		}
-	}
-}
-
-inline SSLClient::~SSLClient() {
-	if (ctx_) { SSL_CTX_free(ctx_); }
-	// Make sure to shut down SSL since shutdown_ssl will resolve to the
-	// base function rather than the derived function once we get to the
-	// base class destructor, and won't free the SSL (causing a leak).
-	shutdown_ssl_impl(socket_, true);
-}
-
-inline bool SSLClient::is_valid() const { return ctx_; }
-
-inline void SSLClient::set_ca_cert_store(X509_STORE *ca_cert_store) {
-	if (ca_cert_store) {
-		if (ctx_) {
-			if (SSL_CTX_get_cert_store(ctx_) != ca_cert_store) {
-				// Free memory allocated for old cert and use new store `ca_cert_store`
-				SSL_CTX_set_cert_store(ctx_, ca_cert_store);
-			}
-		} else {
-			X509_STORE_free(ca_cert_store);
-		}
-	}
-}
-
-inline long SSLClient::get_openssl_verify_result() const {
-	return verify_result_;
-}
-
-inline SSL_CTX *SSLClient::ssl_context() const { return ctx_; }
-
-inline bool SSLClient::create_and_connect_socket(Socket &socket, Error &error) {
-	return is_valid() && ClientImpl::create_and_connect_socket(socket, error);
-}
-
-// Assumes that socket_mutex_ is locked and that there are no requests in flight
-inline bool SSLClient::connect_with_proxy(Socket &socket, Response &res,
-                                          bool &success, Error &error) {
-	success = true;
-	Response res2;
-	if (!detail::process_client_socket(
-	        socket.sock, read_timeout_sec_, read_timeout_usec_,
-	        write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) {
-		        Request req2;
-		        req2.method = "CONNECT";
-		        req2.path = host_and_port_;
-		        return process_request(strm, req2, res2, false, error);
-	        })) {
-		// Thread-safe to close everything because we are assuming there are no
-		// requests in flight
-		shutdown_ssl(socket, true);
-		shutdown_socket(socket);
-		close_socket(socket);
-		success = false;
-		return false;
-	}
-
-	if (res2.status == 407) {
-		if (!proxy_digest_auth_username_.empty() &&
-		    !proxy_digest_auth_password_.empty()) {
-			std::map<std::string, std::string> auth;
-			if (detail::parse_www_authenticate(res2, auth, true)) {
-				Response res3;
-				if (!detail::process_client_socket(
-				        socket.sock, read_timeout_sec_, read_timeout_usec_,
-				        write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) {
-					        Request req3;
-					        req3.method = "CONNECT";
-					        req3.path = host_and_port_;
-					        req3.headers.insert(detail::make_digest_authentication_header(
-					            req3, auth, 1, detail::random_string(10),
-					            proxy_digest_auth_username_, proxy_digest_auth_password_,
-					            true));
-					        return process_request(strm, req3, res3, false, error);
-				        })) {
-					// Thread-safe to close everything because we are assuming there are
-					// no requests in flight
-					shutdown_ssl(socket, true);
-					shutdown_socket(socket);
-					close_socket(socket);
-					success = false;
-					return false;
-				}
-			}
-		} else {
-			res = res2;
-			return false;
-		}
-	}
-
-	return true;
-}
-
-inline bool SSLClient::load_certs() {
-	bool ret = true;
-
-	std::call_once(initialize_cert_, [&]() {
-		std::lock_guard<std::mutex> guard(ctx_mutex_);
-		if (!ca_cert_file_path_.empty()) {
-			if (!SSL_CTX_load_verify_locations(ctx_, ca_cert_file_path_.c_str(),
-			                                   nullptr)) {
-				ret = false;
-			}
-		} else if (!ca_cert_dir_path_.empty()) {
-			if (!SSL_CTX_load_verify_locations(ctx_, nullptr,
-			                                   ca_cert_dir_path_.c_str())) {
-				ret = false;
-			}
-		} else {
-#ifdef _WIN32
-			detail::load_system_certs_on_windows(SSL_CTX_get_cert_store(ctx_));
-#else
-			    SSL_CTX_set_default_verify_paths(ctx_);
-#endif
-		}
-	});
-
-	return ret;
-}
-
-inline bool SSLClient::initialize_ssl(Socket &socket, Error &error) {
-	auto ssl = detail::ssl_new(
-	    socket.sock, ctx_, ctx_mutex_,
-	    [&](SSL *ssl) {
-		    if (server_certificate_verification_) {
-			    if (!load_certs()) {
-				    error = Error::SSLLoadingCerts;
-				    return false;
-			    }
-			    SSL_set_verify(ssl, SSL_VERIFY_NONE, nullptr);
-		    }
-
-		    if (!detail::ssl_connect_or_accept_nonblocking(
-		            socket.sock, ssl, SSL_connect, connection_timeout_sec_,
-		            connection_timeout_usec_)) {
-			    error = Error::SSLConnection;
-			    return false;
-		    }
-
-		    if (server_certificate_verification_) {
-			    verify_result_ = SSL_get_verify_result(ssl);
-
-			    if (verify_result_ != X509_V_OK) {
-				    error = Error::SSLServerVerification;
-				    return false;
-			    }
-
-			    auto server_cert = SSL_get_peer_certificate(ssl);
-
-			    if (server_cert == nullptr) {
-				    error = Error::SSLServerVerification;
-				    return false;
-			    }
-
-			    if (!verify_host(server_cert)) {
-				    X509_free(server_cert);
-				    error = Error::SSLServerVerification;
-				    return false;
-			    }
-			    X509_free(server_cert);
-		    }
-
-		    return true;
-	    },
-	    [&](SSL *ssl) {
-		    SSL_set_tlsext_host_name(ssl, host_.c_str());
-		    return true;
-	    });
-
-	if (ssl) {
-		socket.ssl = ssl;
-		return true;
-	}
-
-	shutdown_socket(socket);
-	close_socket(socket);
-	return false;
-}
-
-inline void SSLClient::shutdown_ssl(Socket &socket, bool shutdown_gracefully) {
-	shutdown_ssl_impl(socket, shutdown_gracefully);
-}
-
-inline void SSLClient::shutdown_ssl_impl(Socket &socket,
-                                         bool shutdown_gracefully) {
-	if (socket.sock == INVALID_SOCKET) {
-		assert(socket.ssl == nullptr);
-		return;
-	}
-	if (socket.ssl) {
-		detail::ssl_delete(ctx_mutex_, socket.ssl, shutdown_gracefully);
-		socket.ssl = nullptr;
-	}
-	assert(socket.ssl == nullptr);
-}
-
-inline bool
-SSLClient::process_socket(const Socket &socket,
-                          std::function<bool(Stream &strm)> callback) {
-	assert(socket.ssl);
-	return detail::process_client_socket_ssl(
-	    socket.ssl, socket.sock, read_timeout_sec_, read_timeout_usec_,
-	    write_timeout_sec_, write_timeout_usec_, std::move(callback));
-}
-
-inline bool SSLClient::is_ssl() const { return true; }
-
-inline bool SSLClient::verify_host(X509 *server_cert) const {
-	/* Quote from RFC2818 section 3.1 "Server Identity"
-
-	   If a subjectAltName extension of type dNSName is present, that MUST
-	   be used as the identity. Otherwise, the (most specific) Common Name
-	   field in the Subject field of the certificate MUST be used. Although
-	   the use of the Common Name is existing practice, it is deprecated and
-	   Certification Authorities are encouraged to use the dNSName instead.
-
-	   Matching is performed using the matching rules specified by
-	   [RFC2459].  If more than one identity of a given type is present in
-	   the certificate (e.g., more than one dNSName name, a match in any one
-	   of the set is considered acceptable.) Names may contain the wildcard
-	   character * which is considered to match any single domain name
-	   component or component fragment. E.g., *.a.com matches foo.a.com but
-	   not bar.foo.a.com. f*.com matches foo.com but not bar.com.
-
-	   In some cases, the URI is specified as an IP address rather than a
-	   hostname. In this case, the iPAddress subjectAltName must be present
-	   in the certificate and must exactly match the IP in the URI.
-
-	*/
-	return verify_host_with_subject_alt_name(server_cert) ||
-	       verify_host_with_common_name(server_cert);
-}
-
-inline bool
-SSLClient::verify_host_with_subject_alt_name(X509 *server_cert) const {
-	auto ret = false;
-
-	auto type = GEN_DNS;
-
-	struct in6_addr addr6;
-	struct in_addr addr;
-	size_t addr_len = 0;
-
-#ifndef __MINGW32__
-	if (inet_pton(AF_INET6, host_.c_str(), &addr6)) {
-		type = GEN_IPADD;
-		addr_len = sizeof(struct in6_addr);
-	} else if (inet_pton(AF_INET, host_.c_str(), &addr)) {
-		type = GEN_IPADD;
-		addr_len = sizeof(struct in_addr);
-	}
-#endif
-
-	auto alt_names = static_cast<const struct stack_st_GENERAL_NAME *>(
-	    X509_get_ext_d2i(server_cert, NID_subject_alt_name, nullptr, nullptr));
-
-	if (alt_names) {
-		auto dsn_matched = false;
-		auto ip_mached = false;
-
-		auto count = sk_GENERAL_NAME_num(alt_names);
-
-		for (decltype(count) i = 0; i < count && !dsn_matched; i++) {
-			auto val = sk_GENERAL_NAME_value(alt_names, i);
-			if (val->type == type) {
-				auto name = (const char *)ASN1_STRING_get0_data(val->d.ia5);
-				auto name_len = (size_t)ASN1_STRING_length(val->d.ia5);
-
-				switch (type) {
-				case GEN_DNS: dsn_matched = check_host_name(name, name_len); break;
-
-				case GEN_IPADD:
-					if (!memcmp(&addr6, name, addr_len) ||
-					    !memcmp(&addr, name, addr_len)) {
-						ip_mached = true;
-					}
-					break;
-				}
-			}
-		}
-
-		if (dsn_matched || ip_mached) { ret = true; }
-	}
-
-	GENERAL_NAMES_free((STACK_OF(GENERAL_NAME) *)alt_names);
-	return ret;
-}
-
-inline bool SSLClient::verify_host_with_common_name(X509 *server_cert) const {
-	const auto subject_name = X509_get_subject_name(server_cert);
-
-	if (subject_name != nullptr) {
-		char name[BUFSIZ];
-		auto name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName,
-		                                          name, sizeof(name));
-
-		if (name_len != -1) {
-			return check_host_name(name, static_cast<size_t>(name_len));
-		}
-	}
-
-	return false;
-}
-
-inline bool SSLClient::check_host_name(const char *pattern,
-                                       size_t pattern_len) const {
-	if (host_.size() == pattern_len && host_ == pattern) { return true; }
-
-	// Wildcard match
-	// https://bugs.launchpad.net/ubuntu/+source/firefox-3.0/+bug/376484
-	std::vector<std::string> pattern_components;
-	detail::split(&pattern[0], &pattern[pattern_len], '.',
-	              [&](const char *b, const char *e) {
-		              pattern_components.emplace_back(std::string(b, e));
-	              });
-
-	if (host_components_.size() != pattern_components.size()) { return false; }
-
-	auto itr = pattern_components.begin();
-	for (const auto &h : host_components_) {
-		auto &p = *itr;
-		if (p != h && p != "*") {
-			auto partial_match = (p.size() > 0 && p[p.size() - 1] == '*' &&
-			                      !p.compare(0, p.size() - 1, h));
-			if (!partial_match) { return false; }
-		}
-		++itr;
-	}
-
-	return true;
-}
-#endif
-
-// Universal client implementation
-inline Client::Client(const std::string &scheme_host_port)
-    : Client(scheme_host_port, std::string(), std::string()) {}
-
-inline Client::Client(const std::string &scheme_host_port,
-                      const std::string &client_cert_path,
-                      const std::string &client_key_path) {
-	const static Regex re(
-	    R"((?:([a-z]+):\/\/)?(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)");
-
-	Match m;
-	if (duckdb_re2::RegexMatch(scheme_host_port, m, re)) {
-		auto scheme = m[1].str();
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-		if (!scheme.empty() && (scheme != "http" && scheme != "https")) {
-#else
-		if (!scheme.empty() && scheme != "http") {
-#endif
-#ifndef CPPHTTPLIB_NO_EXCEPTIONS
-			std::string msg = "'" + scheme + "' scheme is not supported.";
-			throw std::invalid_argument(msg);
-#endif
-			return;
-		}
-
-		auto is_ssl = scheme == "https";
-
-		auto host = m[2].str();
-		if (host.empty()) { host = m[3].str(); }
-
-		auto port_str = m[4].str();
-		auto port = !port_str.empty() ? std::stoi(port_str) : (is_ssl ? 443 : 80);
-
-		if (is_ssl) {
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-			cli_ = detail::make_unique<SSLClient>(host.c_str(), port,
-			                                      client_cert_path, client_key_path);
-			is_ssl_ = is_ssl;
-#endif
-		} else {
-			cli_ = detail::make_unique<ClientImpl>(host.c_str(), port,
-			                                       client_cert_path, client_key_path);
-		}
-	} else {
-		cli_ = detail::make_unique<ClientImpl>(scheme_host_port, 80,
-		                                       client_cert_path, client_key_path);
-	}
-}
-
-inline Client::Client(const std::string &host, int port)
-    : cli_(detail::make_unique<ClientImpl>(host, port)) {}
-
-inline Client::Client(const std::string &host, int port,
-                      const std::string &client_cert_path,
-                      const std::string &client_key_path)
-    : cli_(detail::make_unique<ClientImpl>(host, port, client_cert_path,
-                                           client_key_path)) {}
-
-inline Client::~Client() {}
-
-inline bool Client::is_valid() const {
-	return cli_ != nullptr && cli_->is_valid();
-}
-
-inline Result Client::Get(const char *path) { return cli_->Get(path); }
-inline Result Client::Get(const char *path, const Headers &headers) {
-	return cli_->Get(path, headers);
-}
-inline Result Client::Get(const char *path, Progress progress) {
-	return cli_->Get(path, std::move(progress));
-}
-inline Result Client::Get(const char *path, const Headers &headers,
-                          Progress progress) {
-	return cli_->Get(path, headers, std::move(progress));
-}
-inline Result Client::Get(const char *path, ContentReceiver content_receiver) {
-	return cli_->Get(path, std::move(content_receiver));
-}
-inline Result Client::Get(const char *path, const Headers &headers,
-                          ContentReceiver content_receiver) {
-	return cli_->Get(path, headers, std::move(content_receiver));
-}
-inline Result Client::Get(const char *path, ContentReceiver content_receiver,
-                          Progress progress) {
-	return cli_->Get(path, std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const char *path, const Headers &headers,
-                          ContentReceiver content_receiver, Progress progress) {
-	return cli_->Get(path, headers, std::move(content_receiver),
-	                 std::move(progress));
-}
-inline Result Client::Get(const char *path, ResponseHandler response_handler,
-                          ContentReceiver content_receiver) {
-	return cli_->Get(path, std::move(response_handler),
-	                 std::move(content_receiver));
-}
-inline Result Client::Get(const char *path, const Headers &headers,
-                          ResponseHandler response_handler,
-                          ContentReceiver content_receiver) {
-	return cli_->Get(path, headers, std::move(response_handler),
-	                 std::move(content_receiver));
-}
-inline Result Client::Get(const char *path, ResponseHandler response_handler,
-                          ContentReceiver content_receiver, Progress progress) {
-	return cli_->Get(path, std::move(response_handler),
-	                 std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const char *path, const Headers &headers,
-                          ResponseHandler response_handler,
-                          ContentReceiver content_receiver, Progress progress) {
-	return cli_->Get(path, headers, std::move(response_handler),
-	                 std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const char *path, const Params &params,
-                          const Headers &headers, Progress progress) {
-	return cli_->Get(path, params, headers, progress);
-}
-inline Result Client::Get(const char *path, const Params &params,
-                          const Headers &headers,
-                          ContentReceiver content_receiver, Progress progress) {
-	return cli_->Get(path, params, headers, content_receiver, progress);
-}
-inline Result Client::Get(const char *path, const Params &params,
-                          const Headers &headers,
-                          ResponseHandler response_handler,
-                          ContentReceiver content_receiver, Progress progress) {
-	return cli_->Get(path, params, headers, response_handler, content_receiver,
-	                 progress);
-}
-
-inline Result Client::Head(const char *path) { return cli_->Head(path); }
-inline Result Client::Head(const char *path, const Headers &headers) {
-	return cli_->Head(path, headers);
-}
-
-inline Result Client::Post(const char *path) { return cli_->Post(path); }
-inline Result Client::Post(const char *path, const char *body,
-                           size_t content_length, const char *content_type) {
-	return cli_->Post(path, body, content_length, content_type);
-}
-inline Result Client::Post(const char *path, const Headers &headers,
-                           const char *body, size_t content_length,
-                           const char *content_type) {
-	return cli_->Post(path, headers, body, content_length, content_type);
-}
-inline Result Client::Post(const char *path, const std::string &body,
-                           const char *content_type) {
-	return cli_->Post(path, body, content_type);
-}
-inline Result Client::Post(const char *path, const Headers &headers,
-                           const std::string &body, const char *content_type) {
-	return cli_->Post(path, headers, body, content_type);
-}
-inline Result Client::Post(const char *path, size_t content_length,
-                           ContentProvider content_provider,
-                           const char *content_type) {
-	return cli_->Post(path, content_length, std::move(content_provider),
-	                  content_type);
-}
-inline Result Client::Post(const char *path,
-                           ContentProviderWithoutLength content_provider,
-                           const char *content_type) {
-	return cli_->Post(path, std::move(content_provider), content_type);
-}
-inline Result Client::Post(const char *path, const Headers &headers,
-                           size_t content_length,
-                           ContentProvider content_provider,
-                           const char *content_type) {
-	return cli_->Post(path, headers, content_length, std::move(content_provider),
-	                  content_type);
-}
-inline Result Client::Post(const char *path, const Headers &headers,
-                           ContentProviderWithoutLength content_provider,
-                           const char *content_type) {
-	return cli_->Post(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Post(const char *path, const Params &params) {
-	return cli_->Post(path, params);
-}
-inline Result Client::Post(const char *path, const Headers &headers,
-                           const Params &params) {
-	return cli_->Post(path, headers, params);
-}
-inline Result Client::Post(const char *path,
-                           const MultipartFormDataItems &items) {
-	return cli_->Post(path, items);
-}
-inline Result Client::Post(const char *path, const Headers &headers,
-                           const MultipartFormDataItems &items) {
-	return cli_->Post(path, headers, items);
-}
-inline Result Client::Post(const char *path, const Headers &headers,
-                           const MultipartFormDataItems &items,
-                           const std::string &boundary) {
-	return cli_->Post(path, headers, items, boundary);
-}
-inline Result Client::Put(const char *path) { return cli_->Put(path); }
-inline Result Client::Put(const char *path, const char *body,
-                          size_t content_length, const char *content_type) {
-	return cli_->Put(path, body, content_length, content_type);
-}
-inline Result Client::Put(const char *path, const Headers &headers,
-                          const char *body, size_t content_length,
-                          const char *content_type) {
-	return cli_->Put(path, headers, body, content_length, content_type);
-}
-inline Result Client::Put(const char *path, const std::string &body,
-                          const char *content_type) {
-	return cli_->Put(path, body, content_type);
-}
-inline Result Client::Put(const char *path, const Headers &headers,
-                          const std::string &body, const char *content_type) {
-	return cli_->Put(path, headers, body, content_type);
-}
-inline Result Client::Put(const char *path, size_t content_length,
-                          ContentProvider content_provider,
-                          const char *content_type) {
-	return cli_->Put(path, content_length, std::move(content_provider),
-	                 content_type);
-}
-inline Result Client::Put(const char *path,
-                          ContentProviderWithoutLength content_provider,
-                          const char *content_type) {
-	return cli_->Put(path, std::move(content_provider), content_type);
-}
-inline Result Client::Put(const char *path, const Headers &headers,
-                          size_t content_length,
-                          ContentProvider content_provider,
-                          const char *content_type) {
-	return cli_->Put(path, headers, content_length, std::move(content_provider),
-	                 content_type);
-}
-inline Result Client::Put(const char *path, const Headers &headers,
-                          ContentProviderWithoutLength content_provider,
-                          const char *content_type) {
-	return cli_->Put(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Put(const char *path, const Params &params) {
-	return cli_->Put(path, params);
-}
-inline Result Client::Put(const char *path, const Headers &headers,
-                          const Params &params) {
-	return cli_->Put(path, headers, params);
-}
-inline Result Client::Patch(const char *path) { return cli_->Patch(path); }
-inline Result Client::Patch(const char *path, const char *body,
-                            size_t content_length, const char *content_type) {
-	return cli_->Patch(path, body, content_length, content_type);
-}
-inline Result Client::Patch(const char *path, const Headers &headers,
-                            const char *body, size_t content_length,
-                            const char *content_type) {
-	return cli_->Patch(path, headers, body, content_length, content_type);
-}
-inline Result Client::Patch(const char *path, const std::string &body,
-                            const char *content_type) {
-	return cli_->Patch(path, body, content_type);
-}
-inline Result Client::Patch(const char *path, const Headers &headers,
-                            const std::string &body, const char *content_type) {
-	return cli_->Patch(path, headers, body, content_type);
-}
-inline Result Client::Patch(const char *path, size_t content_length,
-                            ContentProvider content_provider,
-                            const char *content_type) {
-	return cli_->Patch(path, content_length, std::move(content_provider),
-	                   content_type);
-}
-inline Result Client::Patch(const char *path,
-                            ContentProviderWithoutLength content_provider,
-                            const char *content_type) {
-	return cli_->Patch(path, std::move(content_provider), content_type);
-}
-inline Result Client::Patch(const char *path, const Headers &headers,
-                            size_t content_length,
-                            ContentProvider content_provider,
-                            const char *content_type) {
-	return cli_->Patch(path, headers, content_length, std::move(content_provider),
-	                   content_type);
-}
-inline Result Client::Patch(const char *path, const Headers &headers,
-                            ContentProviderWithoutLength content_provider,
-                            const char *content_type) {
-	return cli_->Patch(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Delete(const char *path) { return cli_->Delete(path); }
-inline Result Client::Delete(const char *path, const Headers &headers) {
-	return cli_->Delete(path, headers);
-}
-inline Result Client::Delete(const char *path, const char *body,
-                             size_t content_length, const char *content_type) {
-	return cli_->Delete(path, body, content_length, content_type);
-}
-inline Result Client::Delete(const char *path, const Headers &headers,
-                             const char *body, size_t content_length,
-                             const char *content_type) {
-	return cli_->Delete(path, headers, body, content_length, content_type);
-}
-inline Result Client::Delete(const char *path, const std::string &body,
-                             const char *content_type) {
-	return cli_->Delete(path, body, content_type);
-}
-inline Result Client::Delete(const char *path, const Headers &headers,
-                             const std::string &body,
-                             const char *content_type) {
-	return cli_->Delete(path, headers, body, content_type);
-}
-inline Result Client::Options(const char *path) { return cli_->Options(path); }
-inline Result Client::Options(const char *path, const Headers &headers) {
-	return cli_->Options(path, headers);
-}
-
-inline bool Client::send(Request &req, Response &res, Error &error) {
-	return cli_->send(req, res, error);
-}
-
-inline Result Client::send(const Request &req) { return cli_->send(req); }
-
-inline size_t Client::is_socket_open() const { return cli_->is_socket_open(); }
-
-inline void Client::stop() { cli_->stop(); }
-
-inline void Client::set_hostname_addr_map(
-    const std::map<std::string, std::string> addr_map) {
-	cli_->set_hostname_addr_map(std::move(addr_map));
-}
-
-inline void Client::set_default_headers(Headers headers) {
-	cli_->set_default_headers(std::move(headers));
-}
-
-inline void Client::set_address_family(int family) {
-	cli_->set_address_family(family);
-}
-
-inline void Client::set_tcp_nodelay(bool on) { cli_->set_tcp_nodelay(on); }
-
-inline void Client::set_socket_options(SocketOptions socket_options) {
-	cli_->set_socket_options(std::move(socket_options));
-}
-
-inline void Client::set_connection_timeout(time_t sec, time_t usec) {
-	cli_->set_connection_timeout(sec, usec);
-}
-
-inline void Client::set_read_timeout(time_t sec, time_t usec) {
-	cli_->set_read_timeout(sec, usec);
-}
-
-inline void Client::set_write_timeout(time_t sec, time_t usec) {
-	cli_->set_write_timeout(sec, usec);
-}
-
-inline void Client::set_basic_auth(const char *username, const char *password) {
-	cli_->set_basic_auth(username, password);
-}
-inline void Client::set_bearer_token_auth(const char *token) {
-	cli_->set_bearer_token_auth(token);
-}
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_digest_auth(const char *username,
-                                    const char *password) {
-	cli_->set_digest_auth(username, password);
-}
-#endif
-
-inline void Client::set_keep_alive(bool on) { cli_->set_keep_alive(on); }
-inline void Client::set_follow_location(bool on) {
-	cli_->set_follow_location(on);
-}
-
-inline void Client::set_url_encode(bool on) { cli_->set_url_encode(on); }
-
-inline void Client::set_compress(bool on) { cli_->set_compress(on); }
-
-inline void Client::set_decompress(bool on) { cli_->set_decompress(on); }
-
-inline void Client::set_interface(const char *intf) {
-	cli_->set_interface(intf);
-}
-
-inline void Client::set_proxy(const char *host, int port) {
-	cli_->set_proxy(host, port);
-}
-inline void Client::set_proxy_basic_auth(const char *username,
-                                         const char *password) {
-	cli_->set_proxy_basic_auth(username, password);
-}
-inline void Client::set_proxy_bearer_token_auth(const char *token) {
-	cli_->set_proxy_bearer_token_auth(token);
-}
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_proxy_digest_auth(const char *username,
-                                          const char *password) {
-	cli_->set_proxy_digest_auth(username, password);
-}
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::enable_server_certificate_verification(bool enabled) {
-	cli_->enable_server_certificate_verification(enabled);
-}
-#endif
-
-inline void Client::set_logger(Logger logger) { cli_->set_logger(logger); }
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_ca_cert_path(const char *ca_cert_file_path,
-                                     const char *ca_cert_dir_path) {
-	cli_->set_ca_cert_path(ca_cert_file_path, ca_cert_dir_path);
-}
-
-inline void Client::set_ca_cert_store(X509_STORE *ca_cert_store) {
-	if (is_ssl_) {
-		static_cast<SSLClient &>(*cli_).set_ca_cert_store(ca_cert_store);
-	} else {
-		cli_->set_ca_cert_store(ca_cert_store);
-	}
-}
-
-inline long Client::get_openssl_verify_result() const {
-	if (is_ssl_) {
-		return static_cast<SSLClient &>(*cli_).get_openssl_verify_result();
-	}
-	return -1; // NOTE: -1 doesn't match any of X509_V_ERR_???
-}
-
-inline SSL_CTX *Client::ssl_context() const {
-	if (is_ssl_) { return static_cast<SSLClient &>(*cli_).ssl_context(); }
-	return nullptr;
-}
-#endif
-
-// ----------------------------------------------------------------------------
-
-} // namespace CPPHTTPLIB_NAMESPACE
-
-#endif // CPPHTTPLIB_HTTPLIB_H
-
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/dl.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-#ifndef _WIN32
-#include <dlfcn.h>
-#else
-#define RTLD_NOW   0
-#define RTLD_LOCAL 0
-#endif
-
-namespace duckdb {
-
-#ifdef _WIN32
-
-inline void *dlopen(const char *file, int mode) {
-	D_ASSERT(file);
-	return (void *)LoadLibrary(file);
-}
-
-inline void *dlsym(void *handle, const char *name) {
-	D_ASSERT(handle);
-	return (void *)GetProcAddress((HINSTANCE)handle, name);
-}
-
-inline std::string GetDLError(void) {
-	return LocalFileSystem::GetLastErrorAsString();
-}
-
-#else
-
-inline std::string GetDLError(void) {
-	return dlerror();
-}
-
-#endif
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/fstream.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <fstream>
-#include <iosfwd>
-
-namespace duckdb {
-using std::endl;
-using std::fstream;
-using std::ifstream;
-using std::ios;
-using std::ios_base;
-using std::ofstream;
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/aggregate_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class AggregateRelation : public Relation {
-public:
-	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions);
-	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
-	                             vector<unique_ptr<ParsedExpression>> groups);
-
-	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<unique_ptr<ParsedExpression>> groups;
-	vector<ColumnDefinition> columns;
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/create_table_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class CreateTableRelation : public Relation {
-public:
-	CreateTableRelation(shared_ptr<Relation> child, string schema_name, string table_name);
-
-	shared_ptr<Relation> child;
-	string schema_name;
-	string table_name;
-	vector<ColumnDefinition> columns;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/create_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class CreateStatement : public SQLStatement {
-public:
-	CreateStatement();
-
-	unique_ptr<CreateInfo> info;
-
-protected:
-	CreateStatement(const CreateStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/create_view_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class CreateViewRelation : public Relation {
-public:
-	CreateViewRelation(shared_ptr<Relation> child, string view_name, bool replace, bool temporary);
-
-	shared_ptr<Relation> child;
-	string view_name;
-	bool replace;
-	bool temporary;
-	vector<ColumnDefinition> columns;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/cross_product_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class CrossProductRelation : public Relation {
-public:
-	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right);
-
-	shared_ptr<Relation> left;
-	shared_ptr<Relation> right;
-	vector<ColumnDefinition> columns;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-
-	unique_ptr<TableRef> GetTableRef() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/delete_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class DeleteRelation : public Relation {
-public:
-	DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition, string schema_name,
-	               string table_name);
-
-	vector<ColumnDefinition> columns;
-	unique_ptr<ParsedExpression> condition;
-	string schema_name;
-	string table_name;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/delete_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class DeleteStatement : public SQLStatement {
-public:
-	DeleteStatement();
-
-	unique_ptr<ParsedExpression> condition;
-	unique_ptr<TableRef> table;
-	vector<unique_ptr<TableRef>> using_clauses;
-	vector<unique_ptr<ParsedExpression>> returning_list;
-	//! CTEs
-	CommonTableExpressionMap cte_map;
-
-protected:
-	DeleteStatement(const DeleteStatement &other);
-
-public:
-	string ToString() const override;
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/distinct_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class DistinctRelation : public Relation {
-public:
-	explicit DistinctRelation(shared_ptr<Relation> child);
-
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return true;
-	}
-	Relation *ChildRelation() override {
-		return child.get();
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/explain_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ExplainRelation : public Relation {
-public:
-	explicit ExplainRelation(shared_ptr<Relation> child);
-
-	shared_ptr<Relation> child;
-	vector<ColumnDefinition> columns;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/filter_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class FilterRelation : public Relation {
-public:
-	DUCKDB_API FilterRelation(shared_ptr<Relation> child, unique_ptr<ParsedExpression> condition);
-
-	unique_ptr<ParsedExpression> condition;
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return true;
-	}
-	Relation *ChildRelation() override {
-		return child.get();
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node/set_operation_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/set_operation_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class SetOperationType : uint8_t { NONE = 0, UNION = 1, EXCEPT = 2, INTERSECT = 3 };
-}
-
-
-
-
-
-namespace duckdb {
-
-class SetOperationNode : public QueryNode {
-public:
-	SetOperationNode() : QueryNode(QueryNodeType::SET_OPERATION_NODE) {
-	}
-
-	//! The type of set operation
-	SetOperationType setop_type = SetOperationType::NONE;
-	//! The left side of the set operation
-	unique_ptr<QueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<QueryNode> right;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		return left->GetSelectList();
-	}
-
-public:
-	//! Convert the query node to a string
-	string ToString() const override;
-
-	bool Equals(const QueryNode *other) const override;
-	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() const override;
-
-	//! Serializes a QueryNode to a stand-alone binary blob
-	void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a blob back into a QueryNode
-	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/insert_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class InsertRelation : public Relation {
-public:
-	InsertRelation(shared_ptr<Relation> child, string schema_name, string table_name);
-
-	shared_ptr<Relation> child;
-	string schema_name;
-	string table_name;
-	vector<ColumnDefinition> columns;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/insert_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class ExpressionListRef;
-
-class InsertStatement : public SQLStatement {
-public:
-	InsertStatement();
-
-	//! The select statement to insert from
-	unique_ptr<SelectStatement> select_statement;
-	//! Column names to insert into
-	vector<string> columns;
-
-	//! Table name to insert to
-	string table;
-	//! Schema name to insert to
-	string schema;
-
-	//! keep track of optional returningList if statement contains a RETURNING keyword
-	vector<unique_ptr<ParsedExpression>> returning_list;
-
-	//! CTEs
-	CommonTableExpressionMap cte_map;
-
-protected:
-	InsertStatement(const InsertStatement &other);
-
-public:
-	string ToString() const override;
-	unique_ptr<SQLStatement> Copy() const override;
-
-	//! If the INSERT statement is inserted DIRECTLY from a values list (i.e. INSERT INTO tbl VALUES (...)) this returns
-	//! the expression list Otherwise, this returns NULL
-	ExpressionListRef *GetValuesList() const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/join_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class JoinRelation : public Relation {
-public:
-	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
-	                        unique_ptr<ParsedExpression> condition, JoinType type);
-	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, vector<string> using_columns,
-	                        JoinType type);
-
-	shared_ptr<Relation> left;
-	shared_ptr<Relation> right;
-	unique_ptr<ParsedExpression> condition;
-	vector<string> using_columns;
-	JoinType join_type;
-	vector<ColumnDefinition> columns;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-
-	unique_ptr<TableRef> GetTableRef() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/limit_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class LimitRelation : public Relation {
-public:
-	DUCKDB_API LimitRelation(shared_ptr<Relation> child, int64_t limit, int64_t offset);
-
-	int64_t limit;
-	int64_t offset;
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return true;
-	}
-	Relation *ChildRelation() override {
-		return child.get();
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/order_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class OrderRelation : public Relation {
-public:
-	DUCKDB_API OrderRelation(shared_ptr<Relation> child, vector<OrderByNode> orders);
-
-	vector<OrderByNode> orders;
-	shared_ptr<Relation> child;
-	vector<ColumnDefinition> columns;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return true;
-	}
-	Relation *ChildRelation() override {
-		return child.get();
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/projection_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class ProjectionRelation : public Relation {
-public:
-	DUCKDB_API ProjectionRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
-	                              vector<string> aliases);
-
-	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<ColumnDefinition> columns;
-	shared_ptr<Relation> child;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/setop_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class SetOpRelation : public Relation {
-public:
-	SetOpRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, SetOperationType setop_type);
-
-	shared_ptr<Relation> left;
-	shared_ptr<Relation> right;
-	SetOperationType setop_type;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/subquery_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class SubqueryRelation : public Relation {
-public:
-	SubqueryRelation(shared_ptr<Relation> child, string alias);
-
-	shared_ptr<Relation> child;
-	string alias;
-
-public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	string GetAlias() override;
-
-public:
-	bool InheritsColumnBindings() override {
-		return child->InheritsColumnBindings();
-	}
-	Relation *ChildRelation() override {
-		return child->ChildRelation();
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/update_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class UpdateRelation : public Relation {
-public:
-	UpdateRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition, string schema_name,
-	               string table_name, vector<string> update_columns, vector<unique_ptr<ParsedExpression>> expressions);
-
-	vector<ColumnDefinition> columns;
-	unique_ptr<ParsedExpression> condition;
-	string schema_name;
-	string table_name;
-	vector<string> update_columns;
-	vector<unique_ptr<ParsedExpression>> expressions;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/update_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class UpdateStatement : public SQLStatement {
-public:
-	UpdateStatement();
-
-	unique_ptr<ParsedExpression> condition;
-	unique_ptr<TableRef> table;
-	unique_ptr<TableRef> from_table;
-	vector<string> columns;
-	vector<unique_ptr<ParsedExpression>> expressions;
-	//! keep track of optional returningList if statement contains a RETURNING keyword
-	vector<unique_ptr<ParsedExpression>> returning_list;
-	//! CTEs
-	CommonTableExpressionMap cte_map;
-
-protected:
-	UpdateStatement(const UpdateStatement &other);
-
-public:
-	string ToString() const override;
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation/write_csv_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class WriteCSVRelation : public Relation {
-public:
-	WriteCSVRelation(shared_ptr<Relation> child, string csv_file);
-
-	shared_ptr<Relation> child;
-	string csv_file;
-	vector<ColumnDefinition> columns;
-
-public:
-	BoundStatement Bind(Binder &binder) override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
-	bool IsReadOnly() override {
-		return false;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/copy_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class CopyStatement : public SQLStatement {
-public:
-	CopyStatement();
-
-	unique_ptr<CopyInfo> info;
-	// The SQL statement used instead of a table when copying data out to a file
-	unique_ptr<QueryNode> select_statement;
-
-protected:
-	CopyStatement(const CopyStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/column_lifetime_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class BoundColumnRefExpression;
-
-//! The ColumnLifetimeAnalyzer optimizer traverses the logical operator tree and ensures that columns are removed from
-//! the plan when no longer required
-class ColumnLifetimeAnalyzer : public LogicalOperatorVisitor {
-public:
-	explicit ColumnLifetimeAnalyzer(bool is_root = false) : everything_referenced(is_root) {
-	}
-
-	void VisitOperator(LogicalOperator &op) override;
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	unique_ptr<Expression> VisitReplace(BoundReferenceExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-private:
-	//! Whether or not all the columns are referenced. This happens in the case of the root expression (because the
-	//! output implicitly refers all the columns below it)
-	bool everything_referenced;
-	//! The set of column references
-	column_binding_set_t column_references;
-
-private:
-	void StandardVisitOperator(LogicalOperator &op);
-
-	void ExtractUnusedColumnBindings(vector<ColumnBinding> bindings, column_binding_set_t &unused_bindings);
-	void GenerateProjectionMap(vector<ColumnBinding> bindings, column_binding_set_t &unused_bindings,
-	                           vector<idx_t> &map);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/common_aggregate_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-//! The CommonAggregateOptimizer optimizer eliminates duplicate aggregates from aggregate nodes
-class CommonAggregateOptimizer : public LogicalOperatorVisitor {
-public:
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-	void ExtractCommonAggregates(LogicalAggregate &aggr);
-
-private:
-	column_binding_map_t<ColumnBinding> aggregate_map;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Expression;
-
-struct ExpressionHashFunction {
-	uint64_t operator()(const BaseExpression *const &expr) const {
-		return (uint64_t)expr->Hash();
-	}
-};
-
-struct ExpressionEquality {
-	bool operator()(const BaseExpression *const &a, const BaseExpression *const &b) const {
-		return a->Equals(b);
-	}
-};
-
-template <typename T>
-using expression_map_t = unordered_map<BaseExpression *, T, ExpressionHashFunction, ExpressionEquality>;
-
-using expression_set_t = unordered_set<BaseExpression *, ExpressionHashFunction, ExpressionEquality>;
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/cse_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Binder;
-struct CSEReplacementState;
-
-//! The CommonSubExpression optimizer traverses the expressions of a LogicalOperator to look for duplicate expressions
-//! if there are any, it pushes a projection under the operator that resolves these expressions
-class CommonSubExpressionOptimizer : public LogicalOperatorVisitor {
-public:
-	explicit CommonSubExpressionOptimizer(Binder &binder) : binder(binder) {
-	}
-
-public:
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	//! First iteration: count how many times each expression occurs
-	void CountExpressions(Expression &expr, CSEReplacementState &state);
-	//! Second iteration: perform the actual replacement of the duplicate expressions with common subexpressions nodes
-	void PerformCSEReplacement(unique_ptr<Expression> *expr, CSEReplacementState &state);
-
-	//! Main method to extract common subexpressions
-	void ExtractCommonSubExpresions(LogicalOperator &op);
-
-private:
-	Binder &binder;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/deliminator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class Optimizer;
-class DeliminatorPlanUpdater;
-
-//! The Deliminator optimizer traverses the logical operator tree and removes any redundant DelimGets/DelimJoins
-class Deliminator {
-public:
-	Deliminator() {
-	}
-	//! Perform DelimJoin elimination
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-
-private:
-	//! Find Joins with a DelimGet that can be removed
-	void FindCandidates(unique_ptr<LogicalOperator> *op_ptr, vector<unique_ptr<LogicalOperator> *> &candidates);
-	//! Try to remove a Join with a DelimGet, returns true if it was successful
-	bool RemoveCandidate(unique_ptr<LogicalOperator> *op_ptr, DeliminatorPlanUpdater &updater);
-	//! Replace references to a removed DelimGet, remove DelimJoins if all their DelimGets are gone
-	void UpdatePlan(LogicalOperator &op, expression_map_t<Expression *> &expr_map,
-	                column_binding_map_t<bool> &projection_map);
-	//! Whether the operator has one or more children of type DELIM_GET
-	bool HasChildDelimGet(LogicalOperator &op);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/expression_heuristics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class ExpressionHeuristics : public LogicalOperatorVisitor {
-public:
-	explicit ExpressionHeuristics(Optimizer &optimizer) : optimizer(optimizer) {
-	}
-
-	Optimizer &optimizer;
-	unique_ptr<LogicalOperator> root;
-
-public:
-	//! Search for filters to be reordered
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-	//! Reorder the expressions of a filter
-	void ReorderExpressions(vector<unique_ptr<Expression>> &expressions);
-	//! Return the cost of an expression
-	idx_t Cost(Expression &expr);
-
-	unique_ptr<Expression> VisitReplace(BoundConjunctionExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	//! Override this function to search for filter operators
-	void VisitOperator(LogicalOperator &op) override;
-
-private:
-	unordered_map<std::string, idx_t> function_costs = {
-	    {"+", 5},       {"-", 5},    {"&", 5},          {"#", 5},
-	    {">>", 5},      {"<<", 5},   {"abs", 5},        {"*", 10},
-	    {"%", 10},      {"/", 15},   {"date_part", 20}, {"year", 20},
-	    {"round", 100}, {"~~", 200}, {"!~~", 200},      {"regexp_matches", 200},
-	    {"||", 200}};
-
-	idx_t ExpressionCost(BoundBetweenExpression &expr);
-	idx_t ExpressionCost(BoundCaseExpression &expr);
-	idx_t ExpressionCost(BoundCastExpression &expr);
-	idx_t ExpressionCost(BoundComparisonExpression &expr);
-	idx_t ExpressionCost(BoundConjunctionExpression &expr);
-	idx_t ExpressionCost(BoundFunctionExpression &expr);
-	idx_t ExpressionCost(BoundOperatorExpression &expr, ExpressionType &expr_type);
-	idx_t ExpressionCost(PhysicalType return_type, idx_t multiplier);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/filter_combiner.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-#include <functional>
-#include <map>
-
-namespace duckdb {
-
-enum class ValueComparisonResult { PRUNE_LEFT, PRUNE_RIGHT, UNSATISFIABLE_CONDITION, PRUNE_NOTHING };
-enum class FilterResult { UNSATISFIABLE, SUCCESS, UNSUPPORTED };
-
-//! The FilterCombiner combines several filters and generates a logically equivalent set that is more efficient
-//! Amongst others:
-//! (1) it prunes obsolete filter conditions: i.e. [X > 5 and X > 7] => [X > 7]
-//! (2) it generates new filters for expressions in the same equivalence set: i.e. [X = Y and X = 500] => [Y = 500]
-//! (3) it prunes branches that have unsatisfiable filters: i.e. [X = 5 AND X > 6] => FALSE, prune branch
-class FilterCombiner {
-public:
-	struct ExpressionValueInformation {
-		Value constant;
-		ExpressionType comparison_type;
-	};
-
-	FilterResult AddFilter(unique_ptr<Expression> expr);
-
-	void GenerateFilters(const std::function<void(unique_ptr<Expression> filter)> &callback);
-	bool HasFilters();
-	TableFilterSet GenerateTableScanFilters(vector<idx_t> &column_ids);
-	// vector<unique_ptr<TableFilter>> GenerateZonemapChecks(vector<idx_t> &column_ids, vector<unique_ptr<TableFilter>>
-	// &pushed_filters);
-
-private:
-	FilterResult AddFilter(Expression *expr);
-	FilterResult AddBoundComparisonFilter(Expression *expr);
-	FilterResult AddTransitiveFilters(BoundComparisonExpression &comparison);
-	unique_ptr<Expression> FindTransitiveFilter(Expression *expr);
-	// unordered_map<idx_t, std::pair<Value *, Value *>>
-	// FindZonemapChecks(vector<idx_t> &column_ids, unordered_set<idx_t> &not_constants, Expression *filter);
-	Expression *GetNode(Expression *expr);
-	idx_t GetEquivalenceSet(Expression *expr);
-	FilterResult AddConstantComparison(vector<ExpressionValueInformation> &info_list, ExpressionValueInformation info);
-	//
-	//	//! Functions used to push and generate OR Filters
-	//	void LookUpConjunctions(Expression *expr);
-	//	bool BFSLookUpConjunctions(BoundConjunctionExpression *conjunction);
-	//	void VerifyOrsToPush(Expression &expr);
-	//
-	//	bool UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr);
-	//	bool UpdateFilterByColumn(BoundColumnRefExpression *column_ref, BoundComparisonExpression *comparison_expr);
-	//	void GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids);
-	//
-	//	template <typename CONJUNCTION_TYPE>
-	//	void GenerateConjunctionFilter(BoundConjunctionExpression *conjunction, ConjunctionFilter *last_conj_filter) {
-	//		auto new_filter = NextConjunctionFilter<CONJUNCTION_TYPE>(conjunction);
-	//		auto conj_filter_ptr = (ConjunctionFilter *)new_filter.get();
-	//		last_conj_filter->child_filters.push_back(move(new_filter));
-	//		last_conj_filter = conj_filter_ptr;
-	//	}
-	//
-	//	template <typename CONJUNCTION_TYPE>
-	//	unique_ptr<TableFilter> NextConjunctionFilter(BoundConjunctionExpression *conjunction) {
-	//		unique_ptr<ConjunctionFilter> conj_filter = make_unique<CONJUNCTION_TYPE>();
-	//		for (auto &expr : conjunction->children) {
-	//			auto comp_expr = (BoundComparisonExpression *)expr.get();
-	//			auto &const_expr =
-	//			    (comp_expr->left->type == ExpressionType::VALUE_CONSTANT) ? *comp_expr->left : *comp_expr->right;
-	//			auto const_value = ExpressionExecutor::EvaluateScalar(const_expr);
-	//			auto const_filter = make_unique<ConstantFilter>(comp_expr->type, const_value);
-	//			conj_filter->child_filters.push_back(move(const_filter));
-	//		}
-	//		return move(conj_filter);
-	//	}
-
-private:
-	vector<unique_ptr<Expression>> remaining_filters;
-
-	expression_map_t<unique_ptr<Expression>> stored_expressions;
-	unordered_map<Expression *, idx_t> equivalence_set_map;
-	unordered_map<idx_t, vector<ExpressionValueInformation>> constant_values;
-	unordered_map<idx_t, vector<Expression *>> equivalence_map;
-	idx_t set_index = 0;
-	//
-	//	//! Structures used for OR Filters
-	//
-	//	struct ConjunctionsToPush {
-	//		BoundConjunctionExpression *root_or;
-	//
-	//		// only preserve AND if there is a single column in the expression
-	//		bool preserve_and = true;
-	//
-	//		// conjunction chain for this column
-	//		vector<unique_ptr<BoundConjunctionExpression>> conjunctions;
-	//	};
-	//
-	//	expression_map_t<vector<unique_ptr<ConjunctionsToPush>>> map_col_conjunctions;
-	//	vector<BoundColumnRefExpression *> vec_colref_insertion_order;
-	//
-	//	BoundConjunctionExpression *cur_root_or;
-	//	BoundConjunctionExpression *cur_conjunction;
-	//
-	//	BoundColumnRefExpression *cur_colref_to_push;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/filter_pullup.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class FilterPullup {
-public:
-	explicit FilterPullup(bool pullup = false, bool add_column = false)
-	    : can_pullup(pullup), can_add_column(add_column) {
-	}
-
-	//! Perform filter pullup
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-
-private:
-	vector<unique_ptr<Expression>> filters_expr_pullup;
-
-	// only pull up filters when there is a fork
-	bool can_pullup = false;
-
-	// identifiy case the branch is a set operation (INTERSECT or EXCEPT)
-	bool can_add_column = false;
-
-private:
-	// Generate logical filters pulled up
-	unique_ptr<LogicalOperator> GeneratePullupFilter(unique_ptr<LogicalOperator> child,
-	                                                 vector<unique_ptr<Expression>> &expressions);
-
-	//! Pull up a LogicalFilter op
-	unique_ptr<LogicalOperator> PullupFilter(unique_ptr<LogicalOperator> op);
-
-	//! Pull up filter in a LogicalProjection op
-	unique_ptr<LogicalOperator> PullupProjection(unique_ptr<LogicalOperator> op);
-
-	//! Pull up filter in a LogicalCrossProduct op
-	unique_ptr<LogicalOperator> PullupCrossProduct(unique_ptr<LogicalOperator> op);
-
-	unique_ptr<LogicalOperator> PullupJoin(unique_ptr<LogicalOperator> op);
-
-	// PPullup filter in a left join
-	unique_ptr<LogicalOperator> PullupFromLeft(unique_ptr<LogicalOperator> op);
-
-	// Pullup filter in a inner join
-	unique_ptr<LogicalOperator> PullupInnerJoin(unique_ptr<LogicalOperator> op);
-
-	// Pullup filter in LogicalIntersect or LogicalExcept op
-	unique_ptr<LogicalOperator> PullupSetOperation(unique_ptr<LogicalOperator> op);
-
-	unique_ptr<LogicalOperator> PullupBothSide(unique_ptr<LogicalOperator> op);
-
-	// Finish pull up at this operator
-	unique_ptr<LogicalOperator> FinishPullup(unique_ptr<LogicalOperator> op);
-
-	// special treatment for SetOperations and projections
-	void ProjectSetOperation(LogicalProjection &proj);
-
-}; // end FilterPullup
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/filter_pushdown.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class Optimizer;
-
-class FilterPushdown {
-public:
-	explicit FilterPushdown(Optimizer &optimizer) : optimizer(optimizer) {
-	}
-	//! Perform filter pushdown
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-
-	struct Filter {
-		unordered_set<idx_t> bindings;
-		unique_ptr<Expression> filter;
-
-		Filter() {
-		}
-		explicit Filter(unique_ptr<Expression> filter) : filter(move(filter)) {
-		}
-
-		void ExtractBindings();
-	};
-
-private:
-	vector<unique_ptr<Filter>> filters;
-	Optimizer &optimizer;
-
-	//! Push down a LogicalAggregate op
-	unique_ptr<LogicalOperator> PushdownAggregate(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalFilter op
-	unique_ptr<LogicalOperator> PushdownFilter(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalCrossProduct op
-	unique_ptr<LogicalOperator> PushdownCrossProduct(unique_ptr<LogicalOperator> op);
-	//! Push down a join operator
-	unique_ptr<LogicalOperator> PushdownJoin(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalProjection op
-	unique_ptr<LogicalOperator> PushdownProjection(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalSetOperation op
-	unique_ptr<LogicalOperator> PushdownSetOperation(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalGet op
-	unique_ptr<LogicalOperator> PushdownGet(unique_ptr<LogicalOperator> op);
-	//! Push down a LogicalLimit op
-	unique_ptr<LogicalOperator> PushdownLimit(unique_ptr<LogicalOperator> op);
-	// Pushdown an inner join
-	unique_ptr<LogicalOperator> PushdownInnerJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                              unordered_set<idx_t> &right_bindings);
-	// Pushdown a left join
-	unique_ptr<LogicalOperator> PushdownLeftJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                             unordered_set<idx_t> &right_bindings);
-	// Pushdown a mark join
-	unique_ptr<LogicalOperator> PushdownMarkJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                             unordered_set<idx_t> &right_bindings);
-	// Pushdown a single join
-	unique_ptr<LogicalOperator> PushdownSingleJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
-	                                               unordered_set<idx_t> &right_bindings);
-
-	// Finish pushing down at this operator, creating a LogicalFilter to store any of the stored filters and recursively
-	// pushing down into its children (if any)
-	unique_ptr<LogicalOperator> FinishPushdown(unique_ptr<LogicalOperator> op);
-	//! Adds a filter to the set of filters. Returns FilterResult::UNSATISFIABLE if the subtree should be stripped, or
-	//! FilterResult::SUCCESS otherwise
-	FilterResult AddFilter(unique_ptr<Expression> expr);
-	//! Generate filters from the current set of filters stored in the FilterCombiner
-	void GenerateFilters();
-	//! if there are filters in this FilterPushdown node, push them into the combiner
-	void PushFilters();
-
-	FilterCombiner combiner;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/in_clause_rewriter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class Optimizer;
-
-class InClauseRewriter : public LogicalOperatorVisitor {
-public:
-	explicit InClauseRewriter(ClientContext &context, Optimizer &optimizer) : context(context), optimizer(optimizer) {
-	}
-
-	ClientContext &context;
-	Optimizer &optimizer;
-	unique_ptr<LogicalOperator> root;
-
-public:
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-
-	unique_ptr<Expression> VisitReplace(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/join_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class LogicalOperator;
-
-//! Represents a single relation and any metadata accompanying that relation
-struct SingleJoinRelation {
-	LogicalOperator *op;
-	LogicalOperator *parent;
-
-	SingleJoinRelation() {
-	}
-	SingleJoinRelation(LogicalOperator *op, LogicalOperator *parent) : op(op), parent(parent) {
-	}
-};
-
-//! Set of relations, used in the join graph.
-struct JoinRelationSet {
-	JoinRelationSet(unique_ptr<idx_t[]> relations, idx_t count) : relations(move(relations)), count(count) {
-	}
-
-	string ToString() const;
-
-	unique_ptr<idx_t[]> relations;
-	idx_t count;
-
-	static bool IsSubset(JoinRelationSet *super, JoinRelationSet *sub);
-};
-
-//! The JoinRelationTree is a structure holding all the created JoinRelationSet objects and allowing fast lookup on to
-//! them
-class JoinRelationSetManager {
-public:
-	//! Contains a node with a JoinRelationSet and child relations
-	// FIXME: this structure is inefficient, could use a bitmap for lookup instead (todo: profile)
-	struct JoinRelationTreeNode {
-		unique_ptr<JoinRelationSet> relation;
-		unordered_map<idx_t, unique_ptr<JoinRelationTreeNode>> children;
-	};
-
-public:
-	//! Create or get a JoinRelationSet from a single node with the given index
-	JoinRelationSet *GetJoinRelation(idx_t index);
-	//! Create or get a JoinRelationSet from a set of relation bindings
-	JoinRelationSet *GetJoinRelation(unordered_set<idx_t> &bindings);
-	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
-	JoinRelationSet *GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count);
-	//! Union two sets of relations together and create a new relation set
-	JoinRelationSet *Union(JoinRelationSet *left, JoinRelationSet *right);
-	// //! Create the set difference of left \ right (i.e. all elements in left that are not in right)
-	// JoinRelationSet *Difference(JoinRelationSet *left, JoinRelationSet *right);
-
-private:
-	JoinRelationTreeNode root;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/query_graph.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-class Expression;
-class LogicalOperator;
-
-struct FilterInfo {
-	idx_t filter_index;
-	JoinRelationSet *left_set = nullptr;
-	JoinRelationSet *right_set = nullptr;
-	JoinRelationSet *set = nullptr;
-};
-
-struct FilterNode {
-	vector<FilterInfo *> filters;
-	unordered_map<idx_t, unique_ptr<FilterNode>> children;
-};
-
-struct NeighborInfo {
-	JoinRelationSet *neighbor;
-	vector<FilterInfo *> filters;
-};
-
-//! The QueryGraph contains edges between relations and allows edges to be created/queried
-class QueryGraph {
-public:
-	//! Contains a node with info about neighboring relations and child edge infos
-	struct QueryEdge {
-		vector<unique_ptr<NeighborInfo>> neighbors;
-		unordered_map<idx_t, unique_ptr<QueryEdge>> children;
-	};
-
-public:
-	string ToString() const;
-	void Print();
-
-	//! Create an edge in the edge_set
-	void CreateEdge(JoinRelationSet *left, JoinRelationSet *right, FilterInfo *info);
-	//! Returns a connection if there is an edge that connects these two sets, or nullptr otherwise
-	NeighborInfo *GetConnection(JoinRelationSet *node, JoinRelationSet *other);
-	//! Enumerate the neighbors of a specific node that do not belong to any of the exclusion_set. Note that if a
-	//! neighbor has multiple nodes, this function will return the lowest entry in that set.
-	vector<idx_t> GetNeighbors(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
-	//! Enumerate all neighbors of a given JoinRelationSet node
-	void EnumerateNeighbors(JoinRelationSet *node, const std::function<bool(NeighborInfo *)> &callback);
-
-private:
-	//! Get the QueryEdge of a specific node
-	QueryEdge *GetQueryEdge(JoinRelationSet *left);
-
-	QueryEdge root;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-class JoinOrderOptimizer {
-public:
-	//! Represents a node in the join plan
-	struct JoinNode {
-		JoinRelationSet *set;
-		NeighborInfo *info;
-		idx_t cardinality;
-		idx_t cost;
-		JoinNode *left;
-		JoinNode *right;
-
-		//! Create a leaf node in the join tree
-		JoinNode(JoinRelationSet *set, idx_t cardinality)
-		    : set(set), info(nullptr), cardinality(cardinality), cost(cardinality), left(nullptr), right(nullptr) {
-		}
-		//! Create an intermediate node in the join tree
-		JoinNode(JoinRelationSet *set, NeighborInfo *info, JoinNode *left, JoinNode *right, idx_t cardinality,
-		         idx_t cost)
-		    : set(set), info(info), cardinality(cardinality), cost(cost), left(left), right(right) {
-		}
-	};
-
-public:
-	explicit JoinOrderOptimizer(ClientContext &context) : context(context) {
-	}
-
-	//! Perform join reordering inside a plan
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
-
-private:
-	ClientContext &context;
-	//! The total amount of join pairs that have been considered
-	idx_t pairs = 0;
-	//! Set of all relations considered in the join optimizer
-	vector<unique_ptr<SingleJoinRelation>> relations;
-	//! A mapping of base table index -> index into relations array (relation number)
-	unordered_map<idx_t, idx_t> relation_mapping;
-	//! A structure holding all the created JoinRelationSet objects
-	JoinRelationSetManager set_manager;
-	//! The set of edges used in the join optimizer
-	QueryGraph query_graph;
-	//! The optimal join plan found for the specific JoinRelationSet*
-	unordered_map<JoinRelationSet *, unique_ptr<JoinNode>> plans;
-	//! The set of filters extracted from the query graph
-	vector<unique_ptr<Expression>> filters;
-	//! The set of filter infos created from the extracted filters
-	vector<unique_ptr<FilterInfo>> filter_infos;
-	//! A map of all expressions a given expression has to be equivalent to. This is used to add "implied join edges".
-	//! i.e. in the join A=B AND B=C, the equivalence set of {B} is {A, C}, thus we can add an implied join edge {A <->
-	//! C}
-	expression_map_t<vector<FilterInfo *>> equivalence_sets;
-
-	//! Extract the bindings referred to by an Expression
-	bool ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings);
-	//! Traverse the query tree to find (1) base relations, (2) existing join conditions and (3) filters that can be
-	//! rewritten into joins. Returns true if there are joins in the tree that can be reordered, false otherwise.
-	bool ExtractJoinRelations(LogicalOperator &input_op, vector<LogicalOperator *> &filter_operators,
-	                          LogicalOperator *parent = nullptr);
-	//! Emit a pair as a potential join candidate. Returns the best plan found for the (left, right) connection (either
-	//! the newly created plan, or an existing plan)
-	JoinNode *EmitPair(JoinRelationSet *left, JoinRelationSet *right, NeighborInfo *info);
-	//! Tries to emit a potential join candidate pair. Returns false if too many pairs have already been emitted,
-	//! cancelling the dynamic programming step.
-	bool TryEmitPair(JoinRelationSet *left, JoinRelationSet *right, NeighborInfo *info);
-
-	bool EnumerateCmpRecursive(JoinRelationSet *left, JoinRelationSet *right, unordered_set<idx_t> exclusion_set);
-	//! Emit a relation set node
-	bool EmitCSG(JoinRelationSet *node);
-	//! Enumerate the possible connected subgraphs that can be joined together in the join graph
-	bool EnumerateCSGRecursive(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
-	//! Rewrite a logical query plan given the join plan
-	unique_ptr<LogicalOperator> RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode *node);
-	//! Generate cross product edges inside the side
-	void GenerateCrossProducts();
-	//! Perform the join order solving
-	void SolveJoinOrder();
-	//! Solve the join order exactly using dynamic programming. Returns true if it was completed successfully (i.e. did
-	//! not time-out)
-	bool SolveJoinOrderExactly();
-	//! Solve the join order approximately using a greedy algorithm
-	void SolveJoinOrderApproximately();
-
-	unique_ptr<LogicalOperator> ResolveJoinConditions(unique_ptr<LogicalOperator> op);
-	std::pair<JoinRelationSet *, unique_ptr<LogicalOperator>>
-	GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode *node);
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/regex_range_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class Optimizer;
-
-class RegexRangeFilter {
-public:
-	RegexRangeFilter() {
-	}
-	//! Perform filter pushdown
-	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/remove_unused_columns.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Binder;
-class BoundColumnRefExpression;
-class ClientContext;
-
-//! The RemoveUnusedColumns optimizer traverses the logical operator tree and removes any columns that are not required
-class RemoveUnusedColumns : public LogicalOperatorVisitor {
-public:
-	RemoveUnusedColumns(Binder &binder, ClientContext &context, bool is_root = false)
-	    : binder(binder), context(context), everything_referenced(is_root) {
-	}
-
-	void VisitOperator(LogicalOperator &op) override;
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	unique_ptr<Expression> VisitReplace(BoundReferenceExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-private:
-	Binder &binder;
-	ClientContext &context;
-	//! Whether or not all the columns are referenced. This happens in the case of the root expression (because the
-	//! output implicitly refers all the columns below it)
-	bool everything_referenced;
-	//! The map of column references
-	column_binding_map_t<vector<BoundColumnRefExpression *>> column_references;
-
-private:
-	template <class T>
-	void ClearUnusedExpressions(vector<T> &list, idx_t table_idx);
-
-	//! Perform a replacement of the ColumnBinding, iterating over all the currently found column references and
-	//! replacing the bindings
-	void ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/arithmetic_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The Arithmetic Simplification rule applies arithmetic expressions to which the answer is known (e.g. X + 0 => X, X *
-// 0 => 0)
-class ArithmeticSimplificationRule : public Rule {
-public:
-	explicit ArithmeticSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/case_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The Case Simplification rule rewrites cases with a constant check (i.e. [CASE WHEN 1=1 THEN x ELSE y END] => x)
-class CaseSimplificationRule : public Rule {
-public:
-	explicit CaseSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/comparison_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The Comparison Simplification rule rewrites comparisons with a constant NULL (i.e. [x = NULL] => [NULL])
-class ComparisonSimplificationRule : public Rule {
-public:
-	explicit ComparisonSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/conjunction_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The Conjunction Simplification rule rewrites conjunctions with a constant
-class ConjunctionSimplificationRule : public Rule {
-public:
-	explicit ConjunctionSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-	unique_ptr<Expression> RemoveExpression(BoundConjunctionExpression &conj, Expression *expr);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/constant_folding.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// Fold any constant scalar expressions into a single constant (i.e. [2 + 2] => [4], [2 = 2] => [True], etc...)
-class ConstantFoldingRule : public Rule {
-public:
-	explicit ConstantFoldingRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/date_part_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The DatePart Simplification rule rewrites date_part with a constant specifier into a specialized function (e.g.
-// date_part('year', x) => year(x))
-class DatePartSimplificationRule : public Rule {
-public:
-	explicit DatePartSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/distributivity.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-// (X AND B) OR (X AND C) OR (X AND D) = X AND (B OR C OR D)
-class DistributivityRule : public Rule {
-public:
-	explicit DistributivityRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-private:
-	void AddExpressionSet(Expression &expr, expression_set_t &set);
-	unique_ptr<Expression> ExtractExpression(BoundConjunctionExpression &conj, idx_t idx, Expression &expr);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/empty_needle_removal.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The Empty_needle_removal Optimization rule folds some foldable ConstantExpression
-//(e.g.: PREFIX('xyz', '') is TRUE, PREFIX(NULL, '') is NULL, so rewrite PREFIX(x, '') to (CASE WHEN x IS NOT NULL THEN)
-class EmptyNeedleRemovalRule : public Rule {
-public:
-	explicit EmptyNeedleRemovalRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/like_optimizations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-// The Like Optimization rule rewrites LIKE to optimized scalar functions (e.g.: prefix, suffix, and contains)
-class LikeOptimizationRule : public Rule {
-public:
-	explicit LikeOptimizationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-	unique_ptr<Expression> ApplyRule(BoundFunctionExpression *expr, ScalarFunction function, string pattern,
-	                                 bool is_not_like);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/move_constants.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The MoveConstantsRule moves constants to the same side of an expression, e.g. if we have an expression x + 1 = 5000
-// then this will turn it into x = 4999.
-class MoveConstantsRule : public Rule {
-public:
-	explicit MoveConstantsRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/enum_comparison.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The Enum Comparison rule rewrites cases where two Enums are compared on an equality check
-class EnumComparisonRule : public Rule {
-public:
-	explicit EnumComparisonRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/like_optimizations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class RegexOptimizationRule : public Rule {
-public:
-	explicit RegexOptimizationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-
-	unique_ptr<Expression> ApplyRule(BoundFunctionExpression *expr, ScalarFunction function, string pattern,
-	                                 bool is_not_like);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/statistics_propagator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class LogicalOperator;
-class TableFilter;
-struct BoundOrderByNode;
-
-class StatisticsPropagator {
-public:
-	explicit StatisticsPropagator(ClientContext &context);
-
-	unique_ptr<NodeStatistics> PropagateStatistics(unique_ptr<LogicalOperator> &node_ptr);
-
-private:
-	//! Propagate statistics through an operator
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOperator &node, unique_ptr<LogicalOperator> *node_ptr);
-
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalFilter &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalGet &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalJoin &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalProjection &op, unique_ptr<LogicalOperator> *node_ptr);
-	void PropagateStatistics(LogicalComparisonJoin &op, unique_ptr<LogicalOperator> *node_ptr);
-	void PropagateStatistics(LogicalAnyJoin &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalSetOperation &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalAggregate &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalCrossProduct &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalLimit &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOrder &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalWindow &op, unique_ptr<LogicalOperator> *node_ptr);
-
-	unique_ptr<NodeStatistics> PropagateChildren(LogicalOperator &node, unique_ptr<LogicalOperator> *node_ptr);
-
-	//! Return statistics from a constant value
-	unique_ptr<BaseStatistics> StatisticsFromValue(const Value &input);
-	//! Run a comparison with two sets of statistics, returns if the comparison will always returns true/false or not
-	FilterPropagateResult PropagateComparison(BaseStatistics &left, BaseStatistics &right, ExpressionType comparison);
-
-	//! Update filter statistics from a filter with a constant
-	void UpdateFilterStatistics(BaseStatistics &input, ExpressionType comparison_type, const Value &constant);
-	//! Update statistics from a filter between two stats
-	void UpdateFilterStatistics(BaseStatistics &lstats, BaseStatistics &rstats, ExpressionType comparison_type);
-	//! Update filter statistics from a generic comparison
-	void UpdateFilterStatistics(Expression &left, Expression &right, ExpressionType comparison_type);
-	//! Update filter statistics from an expression
-	void UpdateFilterStatistics(Expression &condition);
-	//! Set the statistics of a specific column binding to not contain null values
-	void SetStatisticsNotNull(ColumnBinding binding);
-
-	//! Run a comparison between the statistics and the table filter; returns the prune result
-	FilterPropagateResult PropagateTableFilter(BaseStatistics &stats, TableFilter &filter);
-	//! Update filter statistics from a TableFilter
-	void UpdateFilterStatistics(BaseStatistics &input, TableFilter &filter);
-
-	//! Add cardinalities together (i.e. new max is stats.max + new_stats.max): used for union
-	void AddCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats);
-	//! Multiply the cardinalities together (i.e. new max cardinality is stats.max * new_stats.max): used for
-	//! joins/cross products
-	void MultiplyCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats);
-
-	unique_ptr<BaseStatistics> PropagateExpression(unique_ptr<Expression> &expr);
-	unique_ptr<BaseStatistics> PropagateExpression(Expression &expr, unique_ptr<Expression> *expr_ptr);
-
-	unique_ptr<BaseStatistics> PropagateExpression(BoundAggregateExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundBetweenExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundCaseExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundCastExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundConjunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundFunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundComparisonExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundConstantExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr);
-
-	void PropagateAndCompress(unique_ptr<Expression> &expr, unique_ptr<BaseStatistics> &stats);
-
-	void ReplaceWithEmptyResult(unique_ptr<LogicalOperator> &node);
-
-	bool ExpressionIsConstant(Expression &expr, const Value &val);
-	bool ExpressionIsConstantOrNull(Expression &expr, const Value &val);
-
-private:
-	ClientContext &context;
-	//! The map of ColumnBinding -> statistics for the various nodes
-	column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map;
-	//! Node stats for the current node
-	unique_ptr<NodeStatistics> node_stats;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/topn_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class LogicalOperator;
-class Optimizer;
-
-class TopN {
-public:
-	//! Optimize ORDER BY + LIMIT to TopN
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/equal_or_null_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// Rewrite
-// a=b OR (a IS NULL AND b IS NULL) to a IS NOT DISTINCT FROM b
-class EqualOrNullSimplification : public Rule {
-public:
-	explicit EqualOrNullSimplification(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/rule/in_clause_simplification.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-// The in clause simplification rule rewrites cases where left is a column ref with a cast and right are constant values
-class InClauseSimplificationRule : public Rule {
-public:
-	explicit InClauseSimplificationRule(ExpressionRewriter &rewriter);
-
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
-	                             bool is_root) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/matcher/type_matcher_id.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The TypeMatcherId class contains a set of matchers that can be used to pattern match TypeIds for Rules
-class TypeMatcherId : public TypeMatcher {
-public:
-	explicit TypeMatcherId(LogicalTypeId type_id_p) : type_id(type_id_p) {
-	}
-
-	bool Match(const LogicalType &type) override {
-		return type.id() == this->type_id;
-	}
-
-private:
-	LogicalTypeId type_id;
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_REGEXP_H_
-#define RE2_REGEXP_H_
-
-// --- SPONSORED LINK --------------------------------------------------
-// If you want to use this library for regular expression matching,
-// you should use re2/re2.h, which provides a class RE2 that
-// mimics the PCRE interface provided by PCRE's C++ wrappers.
-// This header describes the low-level interface used to implement RE2
-// and may change in backwards-incompatible ways from time to time.
-// In contrast, RE2's interface will not.
-// ---------------------------------------------------------------------
-
-// Regular expression library: parsing, execution, and manipulation
-// of regular expressions.
-//
-// Any operation that traverses the Regexp structures should be written
-// using Regexp::Walker (see walker-inl.h), not recursively, because deeply nested
-// regular expressions such as x++++++++++++++++++++... might cause recursive
-// traversals to overflow the stack.
-//
-// It is the caller's responsibility to provide appropriate mutual exclusion
-// around manipulation of the regexps.  RE2 does this.
-//
-// PARSING
-//
-// Regexp::Parse parses regular expressions encoded in UTF-8.
-// The default syntax is POSIX extended regular expressions,
-// with the following changes:
-//
-//   1.  Backreferences (optional in POSIX EREs) are not supported.
-//         (Supporting them precludes the use of DFA-based
-//          matching engines.)
-//
-//   2.  Collating elements and collation classes are not supported.
-//         (No one has needed or wanted them.)
-//
-// The exact syntax accepted can be modified by passing flags to
-// Regexp::Parse.  In particular, many of the basic Perl additions
-// are available.  The flags are documented below (search for LikePerl).
-//
-// If parsed with the flag Regexp::Latin1, both the regular expression
-// and the input to the matching routines are assumed to be encoded in
-// Latin-1, not UTF-8.
-//
-// EXECUTION
-//
-// Once Regexp has parsed a regular expression, it provides methods
-// to search text using that regular expression.  These methods are
-// implemented via calling out to other regular expression libraries.
-// (Let's call them the sublibraries.)
-//
-// To call a sublibrary, Regexp does not simply prepare a
-// string version of the regular expression and hand it to the
-// sublibrary.  Instead, Regexp prepares, from its own parsed form, the
-// corresponding internal representation used by the sublibrary.
-// This has the drawback of needing to know the internal representation
-// used by the sublibrary, but it has two important benefits:
-//
-//   1. The syntax and meaning of regular expressions is guaranteed
-//      to be that used by Regexp's parser, not the syntax expected
-//      by the sublibrary.  Regexp might accept a restricted or
-//      expanded syntax for regular expressions as compared with
-//      the sublibrary.  As long as Regexp can translate from its
-//      internal form into the sublibrary's, clients need not know
-//      exactly which sublibrary they are using.
-//
-//   2. The sublibrary parsers are bypassed.  For whatever reason,
-//      sublibrary regular expression parsers often have security
-//      problems.  For example, plan9grep's regular expression parser
-//      has a buffer overflow in its handling of large character
-//      classes, and PCRE's parser has had buffer overflow problems
-//      in the past.  Security-team requires sandboxing of sublibrary
-//      regular expression parsers.  Avoiding the sublibrary parsers
-//      avoids the sandbox.
-//
-// The execution methods we use now are provided by the compiled form,
-// Prog, described in prog.h
-//
-// MANIPULATION
-//
-// Unlike other regular expression libraries, Regexp makes its parsed
-// form accessible to clients, so that client code can analyze the
-// parsed regular expressions.
-
-#include <stdint.h>
-#include <map>
-#include <set>
-#include <string>
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_UTIL_H_
-#define UTIL_UTIL_H_
-
-#define arraysize(array) (int)(sizeof(array)/sizeof((array)[0]))
-
-#ifndef ATTRIBUTE_NORETURN
-#if defined(__GNUC__)
-#define ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define ATTRIBUTE_NORETURN
-#endif
-#endif
-
-#ifndef FALLTHROUGH_INTENDED
-#if defined(__clang__)
-#define FALLTHROUGH_INTENDED [[clang::fallthrough]]
-#elif defined(__GNUC__) && __GNUC__ >= 7
-#define FALLTHROUGH_INTENDED [[gnu::fallthrough]]
-#else
-#define FALLTHROUGH_INTENDED do {} while (0)
-#endif
-#endif
-
-#ifndef NO_THREAD_SAFETY_ANALYSIS
-#define NO_THREAD_SAFETY_ANALYSIS
-#endif
-
-#endif  // UTIL_UTIL_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_LOGGING_H_
-#define UTIL_LOGGING_H_
-
-// Simplified version of Google's logging.
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <ostream>
-#include <sstream>
-
-
-
-// Debug-only checking.
-#define DCHECK(condition) assert(condition)
-#define DCHECK_EQ(val1, val2) assert((val1) == (val2))
-#define DCHECK_NE(val1, val2) assert((val1) != (val2))
-#define DCHECK_LE(val1, val2) assert((val1) <= (val2))
-#define DCHECK_LT(val1, val2) assert((val1) < (val2))
-#define DCHECK_GE(val1, val2) assert((val1) >= (val2))
-#define DCHECK_GT(val1, val2) assert((val1) > (val2))
-
-// Always-on checking
-#define CHECK(x)	if(x){}else LogMessageFatal(__FILE__, __LINE__).stream() << "Check failed: " #x
-#define CHECK_LT(x, y)	CHECK((x) < (y))
-#define CHECK_GT(x, y)	CHECK((x) > (y))
-#define CHECK_LE(x, y)	CHECK((x) <= (y))
-#define CHECK_GE(x, y)	CHECK((x) >= (y))
-#define CHECK_EQ(x, y)	CHECK((x) == (y))
-#define CHECK_NE(x, y)	CHECK((x) != (y))
-
-#define LOG_INFO LogMessage(__FILE__, __LINE__)
-#define LOG_WARNING LogMessage(__FILE__, __LINE__)
-#define LOG_ERROR LogMessage(__FILE__, __LINE__)
-#define LOG_FATAL LogMessageFatal(__FILE__, __LINE__)
-#define LOG_QFATAL LOG_FATAL
-
-// It seems that one of the Windows header files defines ERROR as 0.
-#ifdef _WIN32
-#define LOG_0 LOG_INFO
-#endif
-
-#ifdef NDEBUG
-#define LOG_DFATAL LOG_ERROR
-#else
-#define LOG_DFATAL LOG_FATAL
-#endif
-
-#define LOG(severity) LOG_ ## severity.stream()
-
-#define VLOG(x) if((x)>0){}else LOG_INFO.stream()
-
-namespace duckdb_re2 {
-
-
-class LogMessage {
- public:
-  LogMessage(const char* file, int line)
-      : flushed_(false) {
-    stream() << file << ":" << line << ": ";
-  }
-  void Flush() {
-    stream() << "\n";
-	/*// R does not allow us to have a reference to stderr even if we are not using it
-    std::string s = str_.str();
-    size_t n = s.size();
-    if (fwrite(s.data(), 1, n, stderr) < n) {}  // shut up gcc
-    */
-    flushed_ = true;
-  }
-  ~LogMessage() {
-    if (!flushed_) {
-      Flush();
-    }
-  }
-  std::ostream& stream() { return str_; }
-
- private:
-  bool flushed_;
-  std::ostringstream str_;
-
-  LogMessage(const LogMessage&) = delete;
-  LogMessage& operator=(const LogMessage&) = delete;
-};
-
-// Silence "destructor never returns" warning for ~LogMessageFatal().
-// Since this is a header file, push and then pop to limit the scope.
-#ifdef _MSC_VER
-//#pragma warning(push)
-//#pragma warning(disable: 4722)
-#endif
-
-class LogMessageFatal : public LogMessage {
- public:
-  LogMessageFatal(const char* file, int line)
-      : LogMessage(file, line) {}
-  ATTRIBUTE_NORETURN ~LogMessageFatal() {
-    Flush();
-    abort();
-  }
- private:
-  LogMessageFatal(const LogMessageFatal&) = delete;
-  LogMessageFatal& operator=(const LogMessageFatal&) = delete;
-};
-} // namespace
-
-#ifdef _MSC_VER
-//#pragma warning(pop)
-#endif
-
-#endif  // UTIL_LOGGING_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-/*
- * The authors of this software are Rob Pike and Ken Thompson.
- *              Copyright (c) 2002 by Lucent Technologies.
- * Permission to use, copy, modify, and distribute this software for any
- * purpose without fee is hereby granted, provided that this entire notice
- * is included in all copies of any software which is or includes a copy
- * or modification of this software and in all copies of the supporting
- * documentation for such software.
- * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
- * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
- * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- *
- * This file and rune.cc have been converted to compile as C++ code
- * in name space re2.
- */
-
-#ifndef UTIL_UTF_H_
-#define UTIL_UTF_H_
-
-#include <stdint.h>
-
-namespace duckdb_re2 {
-
-typedef signed int Rune;	/* Code-point values in Unicode 4.0 are 21 bits wide.*/
-
-enum
-{
-  UTFmax	= 4,		/* maximum bytes per rune */
-  Runesync	= 0x80,		/* cannot represent part of a UTF sequence (<) */
-  Runeself	= 0x80,		/* rune and UTF sequences are the same (<) */
-  Runeerror	= 0xFFFD,	/* decoding error in UTF */
-  Runemax	= 0x10FFFF,	/* maximum rune value */
-};
-
-int runetochar(char* s, const Rune* r);
-int chartorune(Rune* r, const char* s);
-int fullrune(const char* s, int n);
-int utflen(const char* s);
-char* utfrune(const char*, Rune);
-
-}  // namespace duckdb_re2
-
-#endif  // UTIL_UTF_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-namespace duckdb_re2 {
-
-// Keep in sync with string list kOpcodeNames[] in testing/dump.cc
-enum RegexpOp {
-  // Matches no strings.
-  kRegexpNoMatch = 1,
-
-  // Matches empty string.
-  kRegexpEmptyMatch,
-
-  // Matches rune_.
-  kRegexpLiteral,
-
-  // Matches runes_.
-  kRegexpLiteralString,
-
-  // Matches concatenation of sub_[0..nsub-1].
-  kRegexpConcat,
-  // Matches union of sub_[0..nsub-1].
-  kRegexpAlternate,
-
-  // Matches sub_[0] zero or more times.
-  kRegexpStar,
-  // Matches sub_[0] one or more times.
-  kRegexpPlus,
-  // Matches sub_[0] zero or one times.
-  kRegexpQuest,
-
-  // Matches sub_[0] at least min_ times, at most max_ times.
-  // max_ == -1 means no upper limit.
-  kRegexpRepeat,
-
-  // Parenthesized (capturing) subexpression.  Index is cap_.
-  // Optionally, capturing name is name_.
-  kRegexpCapture,
-
-  // Matches any character.
-  kRegexpAnyChar,
-
-  // Matches any byte [sic].
-  kRegexpAnyByte,
-
-  // Matches empty string at beginning of line.
-  kRegexpBeginLine,
-  // Matches empty string at end of line.
-  kRegexpEndLine,
-
-  // Matches word boundary "\b".
-  kRegexpWordBoundary,
-  // Matches not-a-word boundary "\B".
-  kRegexpNoWordBoundary,
-
-  // Matches empty string at beginning of text.
-  kRegexpBeginText,
-  // Matches empty string at end of text.
-  kRegexpEndText,
-
-  // Matches character class given by cc_.
-  kRegexpCharClass,
-
-  // Forces match of entire expression right now,
-  // with match ID match_id_ (used by RE2::Set).
-  kRegexpHaveMatch,
-
-  kMaxRegexpOp = kRegexpHaveMatch,
-};
-
-// Keep in sync with string list in regexp.cc
-enum RegexpStatusCode {
-  // No error
-  kRegexpSuccess = 0,
-
-  // Unexpected error
-  kRegexpInternalError,
-
-  // Parse errors
-  kRegexpBadEscape,          // bad escape sequence
-  kRegexpBadCharClass,       // bad character class
-  kRegexpBadCharRange,       // bad character class range
-  kRegexpMissingBracket,     // missing closing ]
-  kRegexpMissingParen,       // missing closing )
-  kRegexpTrailingBackslash,  // at end of regexp
-  kRegexpRepeatArgument,     // repeat argument missing, e.g. "*"
-  kRegexpRepeatSize,         // bad repetition argument
-  kRegexpRepeatOp,           // bad repetition operator
-  kRegexpBadPerlOp,          // bad perl operator
-  kRegexpBadUTF8,            // invalid UTF-8 in regexp
-  kRegexpBadNamedCapture,    // bad named capture
-};
-
-// Error status for certain operations.
-class RegexpStatus {
- public:
-  RegexpStatus() : code_(kRegexpSuccess), tmp_(NULL) {}
-  ~RegexpStatus() { delete tmp_; }
-
-  void set_code(RegexpStatusCode code) { code_ = code; }
-  void set_error_arg(const StringPiece& error_arg) { error_arg_ = error_arg; }
-  void set_tmp(std::string* tmp) { delete tmp_; tmp_ = tmp; }
-  RegexpStatusCode code() const { return code_; }
-  const StringPiece& error_arg() const { return error_arg_; }
-  bool ok() const { return code() == kRegexpSuccess; }
-
-  // Copies state from status.
-  void Copy(const RegexpStatus& status);
-
-  // Returns text equivalent of code, e.g.:
-  //   "Bad character class"
-  static std::string CodeText(RegexpStatusCode code);
-
-  // Returns text describing error, e.g.:
-  //   "Bad character class: [z-a]"
-  std::string Text() const;
-
- private:
-  RegexpStatusCode code_;  // Kind of error
-  StringPiece error_arg_;  // Piece of regexp containing syntax error.
-  std::string* tmp_;       // Temporary storage, possibly where error_arg_ is.
-
-  RegexpStatus(const RegexpStatus&) = delete;
-  RegexpStatus& operator=(const RegexpStatus&) = delete;
-};
-
-// Compiled form; see prog.h
-class Prog;
-
-struct RuneRange {
-  RuneRange() : lo(0), hi(0) { }
-  RuneRange(int l, int h) : lo(l), hi(h) { }
-  Rune lo;
-  Rune hi;
-};
-
-// Less-than on RuneRanges treats a == b if they overlap at all.
-// This lets us look in a set to find the range covering a particular Rune.
-struct RuneRangeLess {
-  bool operator()(const RuneRange& a, const RuneRange& b) const {
-    return a.hi < b.lo;
-  }
-};
-
-class CharClassBuilder;
-
-class CharClass {
- public:
-  void Delete();
-
-  typedef RuneRange* iterator;
-  iterator begin() { return ranges_; }
-  iterator end() { return ranges_ + nranges_; }
-
-  int size() { return nrunes_; }
-  bool empty() { return nrunes_ == 0; }
-  bool full() { return nrunes_ == Runemax+1; }
-  bool FoldsASCII() { return folds_ascii_; }
-
-  bool Contains(Rune r);
-  CharClass* Negate();
-
- private:
-  CharClass();  // not implemented
-  ~CharClass();  // not implemented
-  static CharClass* New(int maxranges);
-
-  friend class CharClassBuilder;
-
-  bool folds_ascii_;
-  int nrunes_;
-  RuneRange *ranges_;
-  int nranges_;
-
-  CharClass(const CharClass&) = delete;
-  CharClass& operator=(const CharClass&) = delete;
-};
-
-struct repeat_t {  // Repeat
-    int max_;
-    int min_;
-};
-
-struct capture_t {  // Capture
-    int cap_;
-    std::string* name_;
-};
-
-struct literal_string_t{  // LiteralString
-    int nrunes_;
-    Rune* runes_;
-};
-
-struct char_class_t {  // CharClass
-    // These two could be in separate union members,
-    // but it wouldn't save any space (there are other two-word structs)
-    // and keeping them separate avoids confusion during parsing.
-    CharClass* cc_;
-    CharClassBuilder* ccb_;
-};
-
-class Regexp {
- public:
-
-  // Flags for parsing.  Can be ORed together.
-  enum ParseFlags {
-    NoParseFlags  = 0,
-    FoldCase      = 1<<0,   // Fold case during matching (case-insensitive).
-    Literal       = 1<<1,   // Treat s as literal string instead of a regexp.
-    ClassNL       = 1<<2,   // Allow char classes like [^a-z] and \D and \s
-                            // and [[:space:]] to match newline.
-    DotNL         = 1<<3,   // Allow . to match newline.
-    MatchNL       = ClassNL | DotNL,
-    OneLine       = 1<<4,   // Treat ^ and $ as only matching at beginning and
-                            // end of text, not around embedded newlines.
-                            // (Perl's default)
-    Latin1        = 1<<5,   // Regexp and text are in Latin1, not UTF-8.
-    NonGreedy     = 1<<6,   // Repetition operators are non-greedy by default.
-    PerlClasses   = 1<<7,   // Allow Perl character classes like \d.
-    PerlB         = 1<<8,   // Allow Perl's \b and \B.
-    PerlX         = 1<<9,   // Perl extensions:
-                            //   non-capturing parens - (?: )
-                            //   non-greedy operators - *? +? ?? {}?
-                            //   flag edits - (?i) (?-i) (?i: )
-                            //     i - FoldCase
-                            //     m - !OneLine
-                            //     s - DotNL
-                            //     U - NonGreedy
-                            //   line ends: \A \z
-                            //   \Q and \E to disable/enable metacharacters
-                            //   (?P<name>expr) for named captures
-                            //   \C to match any single byte
-    UnicodeGroups = 1<<10,  // Allow \p{Han} for Unicode Han group
-                            //   and \P{Han} for its negation.
-    NeverNL       = 1<<11,  // Never match NL, even if the regexp mentions
-                            //   it explicitly.
-    NeverCapture  = 1<<12,  // Parse all parens as non-capturing.
-
-    // As close to Perl as we can get.
-    LikePerl      = ClassNL | OneLine | PerlClasses | PerlB | PerlX |
-                    UnicodeGroups,
-
-    // Internal use only.
-    WasDollar     = 1<<13,  // on kRegexpEndText: was $ in regexp text
-    AllParseFlags = (1<<14)-1,
-  };
-
-  // Get.  No set, Regexps are logically immutable once created.
-  RegexpOp op() { return static_cast<RegexpOp>(op_); }
-  int nsub() { return nsub_; }
-  bool simple() { return simple_ != 0; }
-  ParseFlags parse_flags() { return static_cast<ParseFlags>(parse_flags_); }
-  int Ref();  // For testing.
-
-  Regexp** sub() {
-    if(nsub_ <= 1)
-      return &subone_;
-    else
-      return submany_;
-  }
-
-  int min() { DCHECK_EQ(op_, kRegexpRepeat); return repeat_.min_; }
-  int max() { DCHECK_EQ(op_, kRegexpRepeat); return repeat_.max_; }
-  Rune rune() { DCHECK_EQ(op_, kRegexpLiteral); return rune_; }
-  CharClass* cc() { DCHECK_EQ(op_, kRegexpCharClass); return char_class_.cc_; }
-  int cap() { DCHECK_EQ(op_, kRegexpCapture); return capture_.cap_; }
-  const std::string* name() { DCHECK_EQ(op_, kRegexpCapture); return capture_.name_; }
-  Rune* runes() { DCHECK_EQ(op_, kRegexpLiteralString); return literal_string_.runes_; }
-  int nrunes() { DCHECK_EQ(op_, kRegexpLiteralString); return literal_string_.nrunes_; }
-  int match_id() { DCHECK_EQ(op_, kRegexpHaveMatch); return match_id_; }
-
-  // Increments reference count, returns object as convenience.
-  Regexp* Incref();
-
-  // Decrements reference count and deletes this object if count reaches 0.
-  void Decref();
-
-  // Parses string s to produce regular expression, returned.
-  // Caller must release return value with re->Decref().
-  // On failure, sets *status (if status != NULL) and returns NULL.
-  static Regexp* Parse(const StringPiece& s, ParseFlags flags,
-                       RegexpStatus* status);
-
-  // Returns a _new_ simplified version of the current regexp.
-  // Does not edit the current regexp.
-  // Caller must release return value with re->Decref().
-  // Simplified means that counted repetition has been rewritten
-  // into simpler terms and all Perl/POSIX features have been
-  // removed.  The result will capture exactly the same
-  // subexpressions the original did, unless formatted with ToString.
-  Regexp* Simplify();
-  friend class CoalesceWalker;
-  friend class SimplifyWalker;
-
-  // Parses the regexp src and then simplifies it and sets *dst to the
-  // string representation of the simplified form.  Returns true on success.
-  // Returns false and sets *status (if status != NULL) on parse error.
-  static bool SimplifyRegexp(const StringPiece& src, ParseFlags flags,
-                             std::string* dst, RegexpStatus* status);
-
-  // Returns the number of capturing groups in the regexp.
-  int NumCaptures();
-  friend class NumCapturesWalker;
-
-  // Returns a map from names to capturing group indices,
-  // or NULL if the regexp contains no named capture groups.
-  // The caller is responsible for deleting the map.
-  std::map<std::string, int>* NamedCaptures();
-
-  // Returns a map from capturing group indices to capturing group
-  // names or NULL if the regexp contains no named capture groups. The
-  // caller is responsible for deleting the map.
-  std::map<int, std::string>* CaptureNames();
-
-  // Returns a string representation of the current regexp,
-  // using as few parentheses as possible.
-  std::string ToString();
-
-  // Convenience functions.  They consume the passed reference,
-  // so in many cases you should use, e.g., Plus(re->Incref(), flags).
-  // They do not consume allocated arrays like subs or runes.
-  static Regexp* Plus(Regexp* sub, ParseFlags flags);
-  static Regexp* Star(Regexp* sub, ParseFlags flags);
-  static Regexp* Quest(Regexp* sub, ParseFlags flags);
-  static Regexp* Concat(Regexp** subs, int nsubs, ParseFlags flags);
-  static Regexp* Alternate(Regexp** subs, int nsubs, ParseFlags flags);
-  static Regexp* Capture(Regexp* sub, ParseFlags flags, int cap);
-  static Regexp* Repeat(Regexp* sub, ParseFlags flags, int min, int max);
-  static Regexp* NewLiteral(Rune rune, ParseFlags flags);
-  static Regexp* NewCharClass(CharClass* cc, ParseFlags flags);
-  static Regexp* LiteralString(Rune* runes, int nrunes, ParseFlags flags);
-  static Regexp* HaveMatch(int match_id, ParseFlags flags);
-
-  // Like Alternate but does not factor out common prefixes.
-  static Regexp* AlternateNoFactor(Regexp** subs, int nsubs, ParseFlags flags);
-
-  // Debugging function.  Returns string format for regexp
-  // that makes structure clear.  Does NOT use regexp syntax.
-  std::string Dump();
-
-  // Helper traversal class, defined fully in walker-inl.h.
-  template<typename T> class Walker;
-
-  // Compile to Prog.  See prog.h
-  // Reverse prog expects to be run over text backward.
-  // Construction and execution of prog will
-  // stay within approximately max_mem bytes of memory.
-  // If max_mem <= 0, a reasonable default is used.
-  Prog* CompileToProg(int64_t max_mem);
-  Prog* CompileToReverseProg(int64_t max_mem);
-
-  // Whether to expect this library to find exactly the same answer as PCRE
-  // when running this regexp.  Most regexps do mimic PCRE exactly, but a few
-  // obscure cases behave differently.  Technically this is more a property
-  // of the Prog than the Regexp, but the computation is much easier to do
-  // on the Regexp.  See mimics_pcre.cc for the exact conditions.
-  bool MimicsPCRE();
-
-  // Benchmarking function.
-  void NullWalk();
-
-  // Whether every match of this regexp must be anchored and
-  // begin with a non-empty fixed string (perhaps after ASCII
-  // case-folding).  If so, returns the prefix and the sub-regexp that
-  // follows it.
-  // Callers should expect *prefix, *foldcase and *suffix to be "zeroed"
-  // regardless of the return value.
-  bool RequiredPrefix(std::string* prefix, bool* foldcase,
-                      Regexp** suffix);
-
- private:
-  // Constructor allocates vectors as appropriate for operator.
-  explicit Regexp(RegexpOp op, ParseFlags parse_flags);
-
-  // Use Decref() instead of delete to release Regexps.
-  // This is private to catch deletes at compile time.
-  ~Regexp();
-  void Destroy();
-  bool QuickDestroy();
-
-  // Helpers for Parse.  Listed here so they can edit Regexps.
-  class ParseState;
-
-  friend class ParseState;
-  friend bool ParseCharClass(StringPiece* s, Regexp** out_re,
-                             RegexpStatus* status);
-
-  // Helper for testing [sic].
-  friend bool RegexpEqualTestingOnly(Regexp*, Regexp*);
-
-  // Computes whether Regexp is already simple.
-  bool ComputeSimple();
-
-  // Constructor that generates a Star, Plus or Quest,
-  // squashing the pair if sub is also a Star, Plus or Quest.
-  static Regexp* StarPlusOrQuest(RegexpOp op, Regexp* sub, ParseFlags flags);
-
-  // Constructor that generates a concatenation or alternation,
-  // enforcing the limit on the number of subexpressions for
-  // a particular Regexp.
-  static Regexp* ConcatOrAlternate(RegexpOp op, Regexp** subs, int nsubs,
-                                   ParseFlags flags, bool can_factor);
-
-  // Returns the leading string that re starts with.
-  // The returned Rune* points into a piece of re,
-  // so it must not be used after the caller calls re->Decref().
-  static Rune* LeadingString(Regexp* re, int* nrune, ParseFlags* flags);
-
-  // Removes the first n leading runes from the beginning of re.
-  // Edits re in place.
-  static void RemoveLeadingString(Regexp* re, int n);
-
-  // Returns the leading regexp in re's top-level concatenation.
-  // The returned Regexp* points at re or a sub-expression of re,
-  // so it must not be used after the caller calls re->Decref().
-  static Regexp* LeadingRegexp(Regexp* re);
-
-  // Removes LeadingRegexp(re) from re and returns the remainder.
-  // Might edit re in place.
-  static Regexp* RemoveLeadingRegexp(Regexp* re);
-
-  // Simplifies an alternation of literal strings by factoring out
-  // common prefixes.
-  static int FactorAlternation(Regexp** sub, int nsub, ParseFlags flags);
-  friend class FactorAlternationImpl;
-
-  // Is a == b?  Only efficient on regexps that have not been through
-  // Simplify yet - the expansion of a kRegexpRepeat will make this
-  // take a long time.  Do not call on such regexps, hence private.
-  static bool Equal(Regexp* a, Regexp* b);
-
-  // Allocate space for n sub-regexps.
-  void AllocSub(int n) {
-    DCHECK(n >= 0 && static_cast<uint16_t>(n) == n);
-    if (n > 1)
-      submany_ = new Regexp*[n];
-    nsub_ = static_cast<uint16_t>(n);
-  }
-
-  // Add Rune to LiteralString
-  void AddRuneToString(Rune r);
-
-  // Swaps this with that, in place.
-  void Swap(Regexp *that);
-
-  // Operator.  See description of operators above.
-  // uint8_t instead of RegexpOp to control space usage.
-  uint8_t op_;
-
-  // Is this regexp structure already simple
-  // (has it been returned by Simplify)?
-  // uint8_t instead of bool to control space usage.
-  uint8_t simple_;
-
-  // Flags saved from parsing and used during execution.
-  // (Only FoldCase is used.)
-  // uint16_t instead of ParseFlags to control space usage.
-  uint16_t parse_flags_;
-
-  // Reference count.  Exists so that SimplifyRegexp can build
-  // regexp structures that are dags rather than trees to avoid
-  // exponential blowup in space requirements.
-  // uint16_t to control space usage.
-  // The standard regexp routines will never generate a
-  // ref greater than the maximum repeat count (kMaxRepeat),
-  // but even so, Incref and Decref consult an overflow map
-  // when ref_ reaches kMaxRef.
-  uint16_t ref_;
-  static const uint16_t kMaxRef = 0xffff;
-
-  // Subexpressions.
-  // uint16_t to control space usage.
-  // Concat and Alternate handle larger numbers of subexpressions
-  // by building concatenation or alternation trees.
-  // Other routines should call Concat or Alternate instead of
-  // filling in sub() by hand.
-  uint16_t nsub_;
-  static const uint16_t kMaxNsub = 0xffff;
-  union {
-    Regexp** submany_;  // if nsub_ > 1
-    Regexp* subone_;  // if nsub_ == 1
-  };
-
-  // Extra space for parse and teardown stacks.
-  Regexp* down_;
-
-  // Arguments to operator.  See description of operators above.
-  union {
-    repeat_t repeat_;
-    capture_t capture_;
-    literal_string_t literal_string_;
-    char_class_t char_class_;
-    Rune rune_;  // Literal
-    int match_id_;  // HaveMatch
-    void *the_union_[2];  // as big as any other element, for memset
-  };
-
-  Regexp(const Regexp&) = delete;
-  Regexp& operator=(const Regexp&) = delete;
-};
-
-// Character class set: contains non-overlapping, non-abutting RuneRanges.
-typedef std::set<RuneRange, RuneRangeLess> RuneRangeSet;
-
-class CharClassBuilder {
- public:
-  CharClassBuilder();
-
-  typedef RuneRangeSet::iterator iterator;
-  iterator begin() { return ranges_.begin(); }
-  iterator end() { return ranges_.end(); }
-
-  int size() { return nrunes_; }
-  bool empty() { return nrunes_ == 0; }
-  bool full() { return nrunes_ == Runemax+1; }
-
-  bool Contains(Rune r);
-  bool FoldsASCII();
-  bool AddRange(Rune lo, Rune hi);  // returns whether class changed
-  CharClassBuilder* Copy();
-  void AddCharClass(CharClassBuilder* cc);
-  void Negate();
-  void RemoveAbove(Rune r);
-  CharClass* GetCharClass();
-  void AddRangeFlags(Rune lo, Rune hi, Regexp::ParseFlags parse_flags);
-
- private:
-  static const uint32_t AlphaMask = (1<<26) - 1;
-  uint32_t upper_;  // bitmap of A-Z
-  uint32_t lower_;  // bitmap of a-z
-  int nrunes_;
-  RuneRangeSet ranges_;
-
-  CharClassBuilder(const CharClassBuilder&) = delete;
-  CharClassBuilder& operator=(const CharClassBuilder&) = delete;
-};
-
-// Bitwise ops on ParseFlags produce ParseFlags.
-inline Regexp::ParseFlags operator|(Regexp::ParseFlags a,
-                                    Regexp::ParseFlags b) {
-  return static_cast<Regexp::ParseFlags>(
-      static_cast<int>(a) | static_cast<int>(b));
-}
-
-inline Regexp::ParseFlags operator^(Regexp::ParseFlags a,
-                                    Regexp::ParseFlags b) {
-  return static_cast<Regexp::ParseFlags>(
-      static_cast<int>(a) ^ static_cast<int>(b));
-}
-
-inline Regexp::ParseFlags operator&(Regexp::ParseFlags a,
-                                    Regexp::ParseFlags b) {
-  return static_cast<Regexp::ParseFlags>(
-      static_cast<int>(a) & static_cast<int>(b));
-}
-
-inline Regexp::ParseFlags operator~(Regexp::ParseFlags a) {
-  // Attempting to produce a value out of enum's range has undefined behaviour.
-  return static_cast<Regexp::ParseFlags>(
-      ~static_cast<int>(a) & static_cast<int>(Regexp::AllParseFlags));
-}
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_REGEXP_H_
-
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/distinct_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-class Vector;
-
-class DistinctStatistics : public BaseStatistics {
-public:
-	DistinctStatistics();
-	explicit DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count);
-
-	//! The HLL of the table
-	unique_ptr<HyperLogLog> log;
-	//! How many values have been sampled into the HLL
-	atomic<idx_t> sample_count;
-	//! How many values have been inserted (before sampling)
-	atomic<idx_t> total_count;
-
-public:
-	void Merge(const BaseStatistics &other) override;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-
-	void Serialize(Serializer &serializer) const override;
-	void Serialize(FieldWriter &writer) const override;
-
-	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &source);
-	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
-
-	void Update(Vector &update, idx_t count);
-	void Update(VectorData &update_data, const LogicalType &ptype, idx_t count);
-
-	string ToString() const override;
-	idx_t GetCount() const;
-
-private:
-	//! For distinct statistics we sample the input to speed up insertions
-	static constexpr const double SAMPLE_RATE = 0.1;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-class Executor;
-
-//! The Pipeline class represents an execution pipeline
-class PipelineExecutor {
-	static constexpr const idx_t CACHE_THRESHOLD = 64;
-
-public:
-	PipelineExecutor(ClientContext &context, Pipeline &pipeline);
-
-	//! Fully execute a pipeline with a source and a sink until the source is completely exhausted
-	void Execute();
-	//! Execute a pipeline with a source and a sink until finished, or until max_chunks have been processed
-	//! Returns true if execution is finished, false if Execute should be called again
-	bool Execute(idx_t max_chunks);
-
-	//! Push a single input DataChunk into the pipeline.
-	//! Returns either OperatorResultType::NEED_MORE_INPUT or OperatorResultType::FINISHED
-	//! If OperatorResultType::FINISHED is returned, more input will not change the result anymore
-	OperatorResultType ExecutePush(DataChunk &input);
-	//! Called after depleting the source: finalizes the execution of this pipeline executor
-	//! This should only be called once per PipelineExecutor
-	void PushFinalize();
-
-	//! Initializes a chunk with the types that will flow out of ExecutePull
-	void InitializeChunk(DataChunk &chunk);
-	//! Execute a pipeline without a sink, and retrieve a single DataChunk
-	//! Returns an empty chunk when finished.
-	void ExecutePull(DataChunk &result);
-	//! Called after depleting the source using ExecutePull
-	//! This flushes profiler states
-	void PullFinalize();
-
-private:
-	//! The pipeline to process
-	Pipeline &pipeline;
-	//! The thread context of this executor
-	ThreadContext thread;
-	//! The total execution context of this executor
-	ExecutionContext context;
-
-	//! Intermediate chunks for the operators
-	vector<unique_ptr<DataChunk>> intermediate_chunks;
-	//! Intermediate states for the operators
-	vector<unique_ptr<OperatorState>> intermediate_states;
-
-	//! The local source state
-	unique_ptr<LocalSourceState> local_source_state;
-	//! The local sink state (if any)
-	unique_ptr<LocalSinkState> local_sink_state;
-
-	//! The final chunk used for moving data into the sink
-	DataChunk final_chunk;
-
-	//! The operators that are not yet finished executing and have data remaining
-	//! If the stack of in_process_operators is empty, we fetch from the source instead
-	stack<idx_t> in_process_operators;
-	//! Whether or not the pipeline has been finalized (used for verification only)
-	bool finalized = false;
-	//! Whether or not the pipeline has finished processing
-	int32_t finished_processing_idx = -1;
-	//! Whether or not this pipeline requires keeping track of the batch index of the source
-	bool requires_batch_index = false;
-
-	//! Cached chunks for any operators that require caching
-	vector<unique_ptr<DataChunk>> cached_chunks;
-
-private:
-	void StartOperator(PhysicalOperator *op);
-	void EndOperator(PhysicalOperator *op, DataChunk *chunk);
-
-	//! Reset the operator index to the first operator
-	void GoToSource(idx_t &current_idx, idx_t initial_idx);
-	void FetchFromSource(DataChunk &result);
-
-	void FinishProcessing(int32_t operator_idx = -1);
-	bool IsFinished();
-
-	OperatorResultType ExecutePushInternal(DataChunk &input, idx_t initial_idx = 0);
-	//! Pushes a chunk through the pipeline and returns a single result chunk
-	//! Returns whether or not a new input chunk is needed, or whether or not we are finished
-	OperatorResultType Execute(DataChunk &input, DataChunk &result, idx_t initial_index = 0);
-
-	static bool CanCacheType(const LogicalType &type);
-	void CacheChunk(DataChunk &input, idx_t operator_idx);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class PipelineEvent : public Event {
-public:
-	PipelineEvent(shared_ptr<Pipeline> pipeline);
-
-	//! The pipeline that this event belongs to
-	shared_ptr<Pipeline> pipeline;
-
-public:
-	void Schedule() override;
-	void FinishEvent() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_finish_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class Executor;
-
-class PipelineFinishEvent : public Event {
-public:
-	PipelineFinishEvent(shared_ptr<Pipeline> pipeline);
-
-	//! The pipeline that this event belongs to
-	shared_ptr<Pipeline> pipeline;
-
-public:
-	void Schedule() override;
-	void FinishEvent() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_complete_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class Executor;
-
-class PipelineCompleteEvent : public Event {
-public:
-	PipelineCompleteEvent(Executor &executor, bool complete_pipeline_p);
-
-	bool complete_pipeline;
-
-public:
-	void Schedule() override;
-	void FinalizeFinish() override;
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #10
-// See the end of this file for a list
-
-// Provides a C++11 implementation of a multi-producer, multi-consumer lock-free queue.
-// An overview, including benchmark results, is provided here:
-//     http://moodycamel.com/blog/2014/a-fast-general-purpose-lock-free-queue-for-c++
-// The full design is also described in excruciating detail at:
-//    http://moodycamel.com/blog/2014/detailed-design-of-a-lock-free-queue
-
-// Simplified BSD license:
-// Copyright (c) 2013-2016, Cameron Desrochers.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// - Redistributions of source code must retain the above copyright notice, this list of
-// conditions and the following disclaimer.
-// - Redistributions in binary form must reproduce the above copyright notice, this list of
-// conditions and the following disclaimer in the documentation and/or other materials
-// provided with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
-// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-// TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-
-
-#if defined(__GNUC__)
-// Disable -Wconversion warnings (spuriously triggered when Traits::size_t and
-// Traits::index_t are set to < 32 bits, causing integer promotion, causing warnings
-// upon assigning any computed values)
-
-#endif
-
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
-#include <atomic>		// Requires C++11. Sorry VS2010.
-#include <cassert>
-#include <cstddef>              // for max_align_t
-#include <cstdint>
-#include <cstdlib>
-#include <type_traits>
-#include <algorithm>
-#include <utility>
-#include <limits>
-#include <climits>		// for CHAR_BIT
-#include <array>
-#include <thread>		// partly for __WINPTHREADS_VERSION if on MinGW-w64 w/ POSIX threading
-
-// Platform-specific definitions of a numeric thread ID type and an invalid value
-namespace duckdb_moodycamel { namespace details {
-	template<typename thread_id_t> struct thread_id_converter {
-		typedef thread_id_t thread_id_numeric_size_t;
-		typedef thread_id_t thread_id_hash_t;
-		static thread_id_hash_t prehash(thread_id_t const& x) { return x; }
-	};
-} }
-#if defined(MCDBGQ_USE_RELACY)
-namespace duckdb_moodycamel { namespace details {
-	typedef std::uint32_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0xFFFFFFFFU;
-	static const thread_id_t invalid_thread_id2 = 0xFFFFFFFEU;
-	static inline thread_id_t thread_id() { return rl::thread_index(); }
-} }
-#elif defined(_WIN32) || defined(__WINDOWS__) || defined(__WIN32__)
-// No sense pulling in windows.h in a header, we'll manually declare the function
-// we use and rely on backwards-compatibility for this not to break
-extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId(void);
-namespace duckdb_moodycamel { namespace details {
-	static_assert(sizeof(unsigned long) == sizeof(std::uint32_t), "Expected size of unsigned long to be 32 bits on Windows");
-	typedef std::uint32_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0;			// See http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx
-	static const thread_id_t invalid_thread_id2 = 0xFFFFFFFFU;	// Not technically guaranteed to be invalid, but is never used in practice. Note that all Win32 thread IDs are presently multiples of 4.
-	static inline thread_id_t thread_id() { return static_cast<thread_id_t>(::GetCurrentThreadId()); }
-} }
-#elif defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || (defined(__APPLE__) && TARGET_OS_IPHONE)
-namespace duckdb_moodycamel { namespace details {
-	static_assert(sizeof(std::thread::id) == 4 || sizeof(std::thread::id) == 8, "std::thread::id is expected to be either 4 or 8 bytes");
-
-	typedef std::thread::id thread_id_t;
-	static const thread_id_t invalid_thread_id;         // Default ctor creates invalid ID
-
-	// Note we don't define a invalid_thread_id2 since std::thread::id doesn't have one; it's
-	// only used if MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is defined anyway, which it won't
-	// be.
-	static inline thread_id_t thread_id() { return std::this_thread::get_id(); }
-
-	template<std::size_t> struct thread_id_size { };
-	template<> struct thread_id_size<4> { typedef std::uint32_t numeric_t; };
-	template<> struct thread_id_size<8> { typedef std::uint64_t numeric_t; };
-
-	template<> struct thread_id_converter<thread_id_t> {
-		typedef thread_id_size<sizeof(thread_id_t)>::numeric_t thread_id_numeric_size_t;
-#ifndef __APPLE__
-		typedef std::size_t thread_id_hash_t;
-#else
-		typedef thread_id_numeric_size_t thread_id_hash_t;
-#endif
-
-		static thread_id_hash_t prehash(thread_id_t const& x)
-		{
-#ifndef __APPLE__
-			return std::hash<std::thread::id>()(x);
-#else
-			return *reinterpret_cast<thread_id_hash_t const*>(&x);
-#endif
-		}
-	};
-} }
-#else
-// Use a nice trick from this answer: http://stackoverflow.com/a/8438730/21475
-// In order to get a numeric thread ID in a platform-independent way, we use a thread-local
-// static variable's address as a thread identifier :-)
-#if defined(__GNUC__) || defined(__INTEL_COMPILER)
-#define MOODYCAMEL_THREADLOCAL __thread
-#elif defined(_MSC_VER)
-#define MOODYCAMEL_THREADLOCAL __declspec(thread)
-#else
-// Assume C++11 compliant compiler
-#define MOODYCAMEL_THREADLOCAL thread_local
-#endif
-namespace duckdb_moodycamel { namespace details {
-	typedef std::uintptr_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0;		// Address can't be nullptr
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-	static const thread_id_t invalid_thread_id2 = 1;		// Member accesses off a null pointer are also generally invalid. Plus it's not aligned.
-#endif
-	inline thread_id_t thread_id() { static MOODYCAMEL_THREADLOCAL int x; return reinterpret_cast<thread_id_t>(&x); }
-} }
-#endif
-
-// Constexpr if
-#ifndef MOODYCAMEL_CONSTEXPR_IF
-#if (defined(_MSC_VER) && defined(_HAS_CXX17) && _HAS_CXX17) || __cplusplus > 201402L
-#define MOODYCAMEL_CONSTEXPR_IF if constexpr
-#define MOODYCAMEL_MAYBE_UNUSED [[maybe_unused]]
-#else
-#define MOODYCAMEL_CONSTEXPR_IF if
-#define MOODYCAMEL_MAYBE_UNUSED
-#endif
-#endif
-
-// Exceptions
-#ifndef MOODYCAMEL_EXCEPTIONS_ENABLED
-#if (defined(_MSC_VER) && defined(_CPPUNWIND)) || (defined(__GNUC__) && defined(__EXCEPTIONS)) || (!defined(_MSC_VER) && !defined(__GNUC__))
-#define MOODYCAMEL_EXCEPTIONS_ENABLED
-#endif
-#endif
-#ifdef MOODYCAMEL_EXCEPTIONS_ENABLED
-#define MOODYCAMEL_TRY try
-#define MOODYCAMEL_CATCH(...) catch(__VA_ARGS__)
-#define MOODYCAMEL_RETHROW throw
-#define MOODYCAMEL_THROW(expr) throw (expr)
-#else
-#define MOODYCAMEL_TRY MOODYCAMEL_CONSTEXPR_IF (true)
-#define MOODYCAMEL_CATCH(...) else MOODYCAMEL_CONSTEXPR_IF (false)
-#define MOODYCAMEL_RETHROW
-#define MOODYCAMEL_THROW(expr)
-#endif
-
-#ifndef MOODYCAMEL_NOEXCEPT
-#if !defined(MOODYCAMEL_EXCEPTIONS_ENABLED)
-#define MOODYCAMEL_NOEXCEPT
-#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) true
-#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) true
-#elif defined(_MSC_VER) && defined(_NOEXCEPT) && _MSC_VER < 1800
-// VS2012's std::is_nothrow_[move_]constructible is broken and returns true when it shouldn't :-(
-// We have to assume *all* non-trivial constructors may throw on VS2012!
-#define MOODYCAMEL_NOEXCEPT _NOEXCEPT
-#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) (std::is_rvalue_reference<valueType>::value && std::is_move_constructible<type>::value ? std::is_trivially_move_constructible<type>::value : std::is_trivially_copy_constructible<type>::value)
-#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) ((std::is_rvalue_reference<valueType>::value && std::is_move_assignable<type>::value ? std::is_trivially_move_assignable<type>::value || std::is_nothrow_move_assignable<type>::value : std::is_trivially_copy_assignable<type>::value || std::is_nothrow_copy_assignable<type>::value) && MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr))
-#elif defined(_MSC_VER) && defined(_NOEXCEPT) && _MSC_VER < 1900
-#define MOODYCAMEL_NOEXCEPT _NOEXCEPT
-#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) (std::is_rvalue_reference<valueType>::value && std::is_move_constructible<type>::value ? std::is_trivially_move_constructible<type>::value || std::is_nothrow_move_constructible<type>::value : std::is_trivially_copy_constructible<type>::value || std::is_nothrow_copy_constructible<type>::value)
-#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) ((std::is_rvalue_reference<valueType>::value && std::is_move_assignable<type>::value ? std::is_trivially_move_assignable<type>::value || std::is_nothrow_move_assignable<type>::value : std::is_trivially_copy_assignable<type>::value || std::is_nothrow_copy_assignable<type>::value) && MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr))
-#else
-#define MOODYCAMEL_NOEXCEPT noexcept
-#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) noexcept(expr)
-#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) noexcept(expr)
-#endif
-#endif
-
-#ifndef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-#ifdef MCDBGQ_USE_RELACY
-#define MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-#else
-// VS2013 doesn't support `thread_local`, and MinGW-w64 w/ POSIX threading has a crippling bug: http://sourceforge.net/p/mingw-w64/bugs/445
-// g++ <=4.7 doesn't support thread_local either.
-// Finally, iOS/ARM doesn't have support for it either, and g++/ARM allows it to compile but it's unconfirmed to actually work
-#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && (!defined(__MINGW32__) && !defined(__MINGW64__) || !defined(__WINPTHREADS_VERSION)) && (!defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) && (!defined(__APPLE__) || !TARGET_OS_IPHONE) && !defined(__arm__) && !defined(_M_ARM) && !defined(__aarch64__)
-// Assume `thread_local` is fully supported in all other C++11 compilers/platforms
-//#define MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED    // always disabled for now since several users report having problems with it on
-#endif
-#endif
-#endif
-
-// VS2012 doesn't support deleted functions.
-// In this case, we declare the function normally but don't define it. A link error will be generated if the function is called.
-#ifndef MOODYCAMEL_DELETE_FUNCTION
-#if defined(_MSC_VER) && _MSC_VER < 1800
-#define MOODYCAMEL_DELETE_FUNCTION
-#else
-#define MOODYCAMEL_DELETE_FUNCTION = delete
-#endif
-#endif
-
-#ifndef MOODYCAMEL_ALIGNAS
-// VS2013 doesn't support alignas or alignof
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-#define MOODYCAMEL_ALIGNAS(alignment) __declspec(align(alignment))
-#define MOODYCAMEL_ALIGNOF(obj) __alignof(obj)
-#else
-#define MOODYCAMEL_ALIGNAS(alignment) alignas(alignment)
-#define MOODYCAMEL_ALIGNOF(obj) alignof(obj)
-#endif
-#endif
-
-
-
-// Compiler-specific likely/unlikely hints
-namespace duckdb_moodycamel { namespace details {
-
-#if defined(__GNUC__)
-	static inline bool (likely)(bool x) { return __builtin_expect((x), true); }
-//	static inline bool (unlikely)(bool x) { return __builtin_expect((x), false); }
-#else
-	static inline bool (likely)(bool x) { return x; }
-//	static inline bool (unlikely)(bool x) { return x; }
-#endif
-} }
-
-namespace duckdb_moodycamel {
-namespace details {
-	template<typename T>
-	struct const_numeric_max {
-		static_assert(std::is_integral<T>::value, "const_numeric_max can only be used with integers");
-		static const T value = std::numeric_limits<T>::is_signed
-			? (static_cast<T>(1) << (sizeof(T) * CHAR_BIT - 1)) - static_cast<T>(1)
-			: static_cast<T>(-1);
-	};
-
-#if defined(__GLIBCXX__)
-	typedef ::max_align_t std_max_align_t;      // libstdc++ forgot to add it to std:: for a while
-#else
-	typedef std::max_align_t std_max_align_t;   // Others (e.g. MSVC) insist it can *only* be accessed via std::
-#endif
-
-	// Some platforms have incorrectly set max_align_t to a type with <8 bytes alignment even while supporting
-	// 8-byte aligned scalar values (*cough* 32-bit iOS). Work around this with our own union. See issue #64.
-	typedef union {
-		std_max_align_t x;
-		long long y;
-		void* z;
-	} max_align_t;
-}
-
-// Default traits for the ConcurrentQueue. To change some of the
-// traits without re-implementing all of them, inherit from this
-// struct and shadow the declarations you wish to be different;
-// since the traits are used as a template type parameter, the
-// shadowed declarations will be used where defined, and the defaults
-// otherwise.
-struct ConcurrentQueueDefaultTraits
-{
-	// General-purpose size type. std::size_t is strongly recommended.
-	typedef std::size_t size_t;
-
-	// The type used for the enqueue and dequeue indices. Must be at least as
-	// large as size_t. Should be significantly larger than the number of elements
-	// you expect to hold at once, especially if you have a high turnover rate;
-	// for example, on 32-bit x86, if you expect to have over a hundred million
-	// elements or pump several million elements through your queue in a very
-	// short space of time, using a 32-bit type *may* trigger a race condition.
-	// A 64-bit int type is recommended in that case, and in practice will
-	// prevent a race condition no matter the usage of the queue. Note that
-	// whether the queue is lock-free with a 64-int type depends on the whether
-	// std::atomic<std::uint64_t> is lock-free, which is platform-specific.
-	typedef std::size_t index_t;
-
-	// Internally, all elements are enqueued and dequeued from multi-element
-	// blocks; this is the smallest controllable unit. If you expect few elements
-	// but many producers, a smaller block size should be favoured. For few producers
-	// and/or many elements, a larger block size is preferred. A sane default
-	// is provided. Must be a power of 2.
-	static const size_t BLOCK_SIZE = 32;
-
-	// For explicit producers (i.e. when using a producer token), the block is
-	// checked for being empty by iterating through a list of flags, one per element.
-	// For large block sizes, this is too inefficient, and switching to an atomic
-	// counter-based approach is faster. The switch is made for block sizes strictly
-	// larger than this threshold.
-	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = 32;
-
-	// How many full blocks can be expected for a single explicit producer? This should
-	// reflect that number's maximum for optimal performance. Must be a power of 2.
-	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = 32;
-
-	// How many full blocks can be expected for a single implicit producer? This should
-	// reflect that number's maximum for optimal performance. Must be a power of 2.
-	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = 32;
-
-	// The initial size of the hash table mapping thread IDs to implicit producers.
-	// Note that the hash is resized every time it becomes half full.
-	// Must be a power of two, and either 0 or at least 1. If 0, implicit production
-	// (using the enqueue methods without an explicit producer token) is disabled.
-	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = 32;
-
-	// Controls the number of items that an explicit consumer (i.e. one with a token)
-	// must consume before it causes all consumers to rotate and move on to the next
-	// internal queue.
-	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = 256;
-
-	// The maximum number of elements (inclusive) that can be enqueued to a sub-queue.
-	// Enqueue operations that would cause this limit to be surpassed will fail. Note
-	// that this limit is enforced at the block level (for performance reasons), i.e.
-	// it's rounded up to the nearest block size.
-	static const size_t MAX_SUBQUEUE_SIZE = details::const_numeric_max<size_t>::value;
-
-
-#ifndef MCDBGQ_USE_RELACY
-	// Memory allocation can be customized if needed.
-	// malloc should return nullptr on failure, and handle alignment like std::malloc.
-#if defined(malloc) || defined(free)
-	// Gah, this is 2015, stop defining macros that break standard code already!
-	// Work around malloc/free being special macros:
-	static inline void* WORKAROUND_malloc(size_t size) { return malloc(size); }
-	static inline void WORKAROUND_free(void* ptr) { return free(ptr); }
-	static inline void* (malloc)(size_t size) { return WORKAROUND_malloc(size); }
-	static inline void (free)(void* ptr) { return WORKAROUND_free(ptr); }
-#else
-	static inline void* malloc(size_t size) { return std::malloc(size); }
-	static inline void free(void* ptr) { return std::free(ptr); }
-#endif
-#else
-	// Debug versions when running under the Relacy race detector (ignore
-	// these in user code)
-	static inline void* malloc(size_t size) { return rl::rl_malloc(size, $); }
-	static inline void free(void* ptr) { return rl::rl_free(ptr, $); }
-#endif
-};
-
-
-// When producing or consuming many elements, the most efficient way is to:
-//    1) Use one of the bulk-operation methods of the queue with a token
-//    2) Failing that, use the bulk-operation methods without a token
-//    3) Failing that, create a token and use that with the single-item methods
-//    4) Failing that, use the single-parameter methods of the queue
-// Having said that, don't create tokens willy-nilly -- ideally there should be
-// a maximum of one token per thread (of each kind).
-struct ProducerToken;
-struct ConsumerToken;
-
-template<typename T, typename Traits> class ConcurrentQueue;
-template<typename T, typename Traits> class BlockingConcurrentQueue;
-class ConcurrentQueueTests;
-
-
-namespace details
-{
-	struct ConcurrentQueueProducerTypelessBase
-	{
-		ConcurrentQueueProducerTypelessBase* next;
-		std::atomic<bool> inactive;
-		ProducerToken* token;
-
-		ConcurrentQueueProducerTypelessBase()
-			: next(nullptr), inactive(false), token(nullptr)
-		{
-		}
-	};
-
-	template<bool use32> struct _hash_32_or_64 {
-		static inline std::uint32_t hash(std::uint32_t h)
-		{
-			// MurmurHash3 finalizer -- see https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
-			// Since the thread ID is already unique, all we really want to do is propagate that
-			// uniqueness evenly across all the bits, so that we can use a subset of the bits while
-			// reducing collisions significantly
-			h ^= h >> 16;
-			h *= 0x85ebca6b;
-			h ^= h >> 13;
-			h *= 0xc2b2ae35;
-			return h ^ (h >> 16);
-		}
-	};
-	template<> struct _hash_32_or_64<1> {
-		static inline std::uint64_t hash(std::uint64_t h)
-		{
-			h ^= h >> 33;
-			h *= 0xff51afd7ed558ccd;
-			h ^= h >> 33;
-			h *= 0xc4ceb9fe1a85ec53;
-			return h ^ (h >> 33);
-		}
-	};
-	template<std::size_t size> struct hash_32_or_64 : public _hash_32_or_64<(size > 4)> {  };
-
-	static inline size_t hash_thread_id(thread_id_t id)
-	{
-		static_assert(sizeof(thread_id_t) <= 8, "Expected a platform where thread IDs are at most 64-bit values");
-		return static_cast<size_t>(hash_32_or_64<sizeof(thread_id_converter<thread_id_t>::thread_id_hash_t)>::hash(
-			thread_id_converter<thread_id_t>::prehash(id)));
-	}
-
-	template<typename T>
-	static inline bool circular_less_than(T a, T b)
-	{
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4554)
-#endif
-		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "circular_less_than is intended to be used only with unsigned integer types");
-		return static_cast<T>(a - b) > static_cast<T>(static_cast<T>(1) << static_cast<T>(sizeof(T) * CHAR_BIT - 1));
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-	}
-
-	template<typename U>
-	static inline char* align_for(char* ptr)
-	{
-		const std::size_t alignment = std::alignment_of<U>::value;
-		return ptr + (alignment - (reinterpret_cast<std::uintptr_t>(ptr) % alignment)) % alignment;
-	}
-
-	template<typename T>
-	static inline T ceil_to_pow_2(T x)
-	{
-		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types");
-
-		// Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-		--x;
-		x |= x >> 1;
-		x |= x >> 2;
-		x |= x >> 4;
-		for (std::size_t i = 1; i < sizeof(T); i <<= 1) {
-			x |= x >> (i << 3);
-		}
-		++x;
-		return x;
-	}
-
-	template<typename T>
-	static inline void swap_relaxed(std::atomic<T>& left, std::atomic<T>& right)
-	{
-		T temp = std::move(left.load(std::memory_order_relaxed));
-		left.store(std::move(right.load(std::memory_order_relaxed)), std::memory_order_relaxed);
-		right.store(std::move(temp), std::memory_order_relaxed);
-	}
-
-	template<typename T>
-	static inline T const& nomove(T const& x)
-	{
-		return x;
-	}
-
-	template<bool Enable>
-	struct nomove_if
-	{
-		template<typename T>
-		static inline T const& eval(T const& x)
-		{
-			return x;
-		}
-	};
-
-	template<>
-	struct nomove_if<false>
-	{
-		template<typename U>
-		static inline auto eval(U&& x)
-			-> decltype(std::forward<U>(x))
-		{
-			return std::forward<U>(x);
-		}
-	};
-
-	template<typename It>
-	static inline auto deref_noexcept(It& it) MOODYCAMEL_NOEXCEPT -> decltype(*it)
-	{
-		return *it;
-	}
-
-#if defined(__clang__) || !defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-	template<typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> { };
-#else
-	template<typename T> struct is_trivially_destructible : std::has_trivial_destructor<T> { };
-#endif
-
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-#ifdef MCDBGQ_USE_RELACY
-	typedef RelacyThreadExitListener ThreadExitListener;
-	typedef RelacyThreadExitNotifier ThreadExitNotifier;
-#else
-	struct ThreadExitListener
-	{
-		typedef void (*callback_t)(void*);
-		callback_t callback;
-		void* userData;
-
-		ThreadExitListener* next;		// reserved for use by the ThreadExitNotifier
-	};
-
-
-	class ThreadExitNotifier
-	{
-	public:
-		static void subscribe(ThreadExitListener* listener)
-		{
-			auto& tlsInst = instance();
-			listener->next = tlsInst.tail;
-			tlsInst.tail = listener;
-		}
-
-		static void unsubscribe(ThreadExitListener* listener)
-		{
-			auto& tlsInst = instance();
-			ThreadExitListener** prev = &tlsInst.tail;
-			for (auto ptr = tlsInst.tail; ptr != nullptr; ptr = ptr->next) {
-				if (ptr == listener) {
-					*prev = ptr->next;
-					break;
-				}
-				prev = &ptr->next;
-			}
-		}
-
-	private:
-		ThreadExitNotifier() : tail(nullptr) { }
-		ThreadExitNotifier(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
-		ThreadExitNotifier& operator=(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
-
-		~ThreadExitNotifier()
-		{
-			// This thread is about to exit, let everyone know!
-			assert(this == &instance() && "If this assert fails, you likely have a buggy compiler! Change the preprocessor conditions such that MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is no longer defined.");
-			for (auto ptr = tail; ptr != nullptr; ptr = ptr->next) {
-				ptr->callback(ptr->userData);
-			}
-		}
-
-		// Thread-local
-		static inline ThreadExitNotifier& instance()
-		{
-			static thread_local ThreadExitNotifier notifier;
-			return notifier;
-		}
-
-	private:
-		ThreadExitListener* tail;
-	};
-#endif
-#endif
-
-	template<typename T> struct static_is_lock_free_num { enum { value = 0 }; };
-	template<> struct static_is_lock_free_num<signed char> { enum { value = ATOMIC_CHAR_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<short> { enum { value = ATOMIC_SHORT_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<int> { enum { value = ATOMIC_INT_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<long> { enum { value = ATOMIC_LONG_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<long long> { enum { value = ATOMIC_LLONG_LOCK_FREE }; };
-	template<typename T> struct static_is_lock_free : static_is_lock_free_num<typename std::make_signed<T>::type> {  };
-	template<> struct static_is_lock_free<bool> { enum { value = ATOMIC_BOOL_LOCK_FREE }; };
-	template<typename U> struct static_is_lock_free<U*> { enum { value = ATOMIC_POINTER_LOCK_FREE }; };
-}
-
-
-struct ProducerToken
-{
-	template<typename T, typename Traits>
-	explicit ProducerToken(ConcurrentQueue<T, Traits>& queue);
-
-	template<typename T, typename Traits>
-	explicit ProducerToken(BlockingConcurrentQueue<T, Traits>& queue);
-
-	ProducerToken(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
-		: producer(other.producer)
-	{
-		other.producer = nullptr;
-		if (producer != nullptr) {
-			producer->token = this;
-		}
-	}
-
-	inline ProducerToken& operator=(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap(other);
-		return *this;
-	}
-
-	void swap(ProducerToken& other) MOODYCAMEL_NOEXCEPT
-	{
-		std::swap(producer, other.producer);
-		if (producer != nullptr) {
-			producer->token = this;
-		}
-		if (other.producer != nullptr) {
-			other.producer->token = &other;
-		}
-	}
-
-	// A token is always valid unless:
-	//     1) Memory allocation failed during construction
-	//     2) It was moved via the move constructor
-	//        (Note: assignment does a swap, leaving both potentially valid)
-	//     3) The associated queue was destroyed
-	// Note that if valid() returns true, that only indicates
-	// that the token is valid for use with a specific queue,
-	// but not which one; that's up to the user to track.
-	inline bool valid() const { return producer != nullptr; }
-
-	~ProducerToken()
-	{
-		if (producer != nullptr) {
-			producer->token = nullptr;
-			producer->inactive.store(true, std::memory_order_release);
-		}
-	}
-
-	// Disable copying and assignment
-	ProducerToken(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-	ProducerToken& operator=(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-
-private:
-	template<typename T, typename Traits> friend class ConcurrentQueue;
-	friend class ConcurrentQueueTests;
-
-protected:
-	details::ConcurrentQueueProducerTypelessBase* producer;
-};
-
-
-struct ConsumerToken
-{
-	template<typename T, typename Traits>
-	explicit ConsumerToken(ConcurrentQueue<T, Traits>& q);
-
-	template<typename T, typename Traits>
-	explicit ConsumerToken(BlockingConcurrentQueue<T, Traits>& q);
-
-	ConsumerToken(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
-		: initialOffset(other.initialOffset), lastKnownGlobalOffset(other.lastKnownGlobalOffset), itemsConsumedFromCurrent(other.itemsConsumedFromCurrent), currentProducer(other.currentProducer), desiredProducer(other.desiredProducer)
-	{
-	}
-
-	inline ConsumerToken& operator=(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap(other);
-		return *this;
-	}
-
-	void swap(ConsumerToken& other) MOODYCAMEL_NOEXCEPT
-	{
-		std::swap(initialOffset, other.initialOffset);
-		std::swap(lastKnownGlobalOffset, other.lastKnownGlobalOffset);
-		std::swap(itemsConsumedFromCurrent, other.itemsConsumedFromCurrent);
-		std::swap(currentProducer, other.currentProducer);
-		std::swap(desiredProducer, other.desiredProducer);
-	}
-
-	// Disable copying and assignment
-	ConsumerToken(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-	ConsumerToken& operator=(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-
-private:
-	template<typename T, typename Traits> friend class ConcurrentQueue;
-	friend class ConcurrentQueueTests;
-
-private: // but shared with ConcurrentQueue
-	std::uint32_t initialOffset;
-	std::uint32_t lastKnownGlobalOffset;
-	std::uint32_t itemsConsumedFromCurrent;
-	details::ConcurrentQueueProducerTypelessBase* currentProducer;
-	details::ConcurrentQueueProducerTypelessBase* desiredProducer;
-};
-
-// Need to forward-declare this swap because it's in a namespace.
-// See http://stackoverflow.com/questions/4492062/why-does-a-c-friend-class-need-a-forward-declaration-only-in-other-namespaces
-template<typename T, typename Traits>
-inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& a, typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& b) MOODYCAMEL_NOEXCEPT;
-
-
-template<typename T, typename Traits = ConcurrentQueueDefaultTraits>
-class ConcurrentQueue
-{
-public:
-	typedef ::duckdb_moodycamel::ProducerToken producer_token_t;
-	typedef ::duckdb_moodycamel::ConsumerToken consumer_token_t;
-
-	typedef typename Traits::index_t index_t;
-	typedef typename Traits::size_t size_t;
-
-	static const size_t BLOCK_SIZE = static_cast<size_t>(Traits::BLOCK_SIZE);
-	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = static_cast<size_t>(Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD);
-	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::EXPLICIT_INITIAL_INDEX_SIZE);
-	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::IMPLICIT_INITIAL_INDEX_SIZE);
-	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = static_cast<size_t>(Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE);
-	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = static_cast<std::uint32_t>(Traits::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE);
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4307)		// + integral constant overflow (that's what the ternary expression is for!)
-#pragma warning(disable: 4309)		// static_cast: Truncation of constant value
-#endif
-	static const size_t MAX_SUBQUEUE_SIZE = (details::const_numeric_max<size_t>::value - static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) < BLOCK_SIZE) ? details::const_numeric_max<size_t>::value : ((static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) + (BLOCK_SIZE - 1)) / BLOCK_SIZE * BLOCK_SIZE);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-	static_assert(!std::numeric_limits<size_t>::is_signed && std::is_integral<size_t>::value, "Traits::size_t must be an unsigned integral type");
-	static_assert(!std::numeric_limits<index_t>::is_signed && std::is_integral<index_t>::value, "Traits::index_t must be an unsigned integral type");
-	static_assert(sizeof(index_t) >= sizeof(size_t), "Traits::index_t must be at least as wide as Traits::size_t");
-	static_assert((BLOCK_SIZE > 1) && !(BLOCK_SIZE & (BLOCK_SIZE - 1)), "Traits::BLOCK_SIZE must be a power of 2 (and at least 2)");
-	static_assert((EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD > 1) && !(EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD & (EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD - 1)), "Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD must be a power of 2 (and greater than 1)");
-	static_assert((EXPLICIT_INITIAL_INDEX_SIZE > 1) && !(EXPLICIT_INITIAL_INDEX_SIZE & (EXPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::EXPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
-	static_assert((IMPLICIT_INITIAL_INDEX_SIZE > 1) && !(IMPLICIT_INITIAL_INDEX_SIZE & (IMPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::IMPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
-	static_assert((INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) || !(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE & (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE - 1)), "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be a power of 2");
-	static_assert(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0 || INITIAL_IMPLICIT_PRODUCER_HASH_SIZE >= 1, "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be at least 1 (or 0 to disable implicit enqueueing)");
-
-public:
-	// Creates a queue with at least `capacity` element slots; note that the
-	// actual number of elements that can be inserted without additional memory
-	// allocation depends on the number of producers and the block size (e.g. if
-	// the block size is equal to `capacity`, only a single block will be allocated
-	// up-front, which means only a single producer will be able to enqueue elements
-	// without an extra allocation -- blocks aren't shared between producers).
-	// This method is not thread safe -- it is up to the user to ensure that the
-	// queue is fully constructed before it starts being used by other threads (this
-	// includes making the memory effects of construction visible, possibly with a
-	// memory barrier).
-	explicit ConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
-		: producerListTail(nullptr),
-		producerCount(0),
-		initialBlockPoolIndex(0),
-		nextExplicitConsumerId(0),
-		globalExplicitConsumerOffset(0)
-	{
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
-
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		// Track all the producers using a fully-resolved typed list for
-		// each kind; this makes it possible to debug them starting from
-		// the root queue object (otherwise wacky casts are needed that
-		// don't compile in the debugger's expression evaluator).
-		explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-	}
-
-	// Computes the correct amount of pre-allocated blocks for you based
-	// on the minimum number of elements you want available at any given
-	// time, and the maximum concurrent number of each type of producer.
-	ConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
-		: producerListTail(nullptr),
-		producerCount(0),
-		initialBlockPoolIndex(0),
-		nextExplicitConsumerId(0),
-		globalExplicitConsumerOffset(0)
-	{
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		size_t blocks = (((minCapacity + BLOCK_SIZE - 1) / BLOCK_SIZE) - 1) * (maxExplicitProducers + 1) + 2 * (maxExplicitProducers + maxImplicitProducers);
-		populate_initial_block_list(blocks);
-
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-	}
-
-	// Note: The queue should not be accessed concurrently while it's
-	// being deleted. It's up to the user to synchronize this.
-	// This method is not thread safe.
-	~ConcurrentQueue()
-	{
-		// Destroy producers
-		auto ptr = producerListTail.load(std::memory_order_relaxed);
-		while (ptr != nullptr) {
-			auto next = ptr->next_prod();
-			if (ptr->token != nullptr) {
-				ptr->token->producer = nullptr;
-			}
-			destroy(ptr);
-			ptr = next;
-		}
-
-		// Destroy implicit producer hash tables
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
-			auto hash = implicitProducerHash.load(std::memory_order_relaxed);
-			while (hash != nullptr) {
-				auto prev = hash->prev;
-				if (prev != nullptr) {		// The last hash is part of this object and was not allocated dynamically
-					for (size_t i = 0; i != hash->capacity; ++i) {
-						hash->entries[i].~ImplicitProducerKVP();
-					}
-					hash->~ImplicitProducerHash();
-					(Traits::free)(hash);
-				}
-				hash = prev;
-			}
-		}
-
-		// Destroy global free list
-		auto block = freeList.head_unsafe();
-		while (block != nullptr) {
-			auto next = block->freeListNext.load(std::memory_order_relaxed);
-			if (block->dynamicallyAllocated) {
-				destroy(block);
-			}
-			block = next;
-		}
-
-		// Destroy initial free list
-		destroy_array(initialBlockPool, initialBlockPoolSize);
-	}
-
-	// Disable copying and copy assignment
-	ConcurrentQueue(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
-	ConcurrentQueue& operator=(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
-
-	// Moving is supported, but note that it is *not* a thread-safe operation.
-	// Nobody can use the queue while it's being moved, and the memory effects
-	// of that move must be propagated to other threads before they can use it.
-	// Note: When a queue is moved, its tokens are still valid but can only be
-	// used with the destination queue (i.e. semantically they are moved along
-	// with the queue itself).
-	ConcurrentQueue(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
-		: producerListTail(other.producerListTail.load(std::memory_order_relaxed)),
-		producerCount(other.producerCount.load(std::memory_order_relaxed)),
-		initialBlockPoolIndex(other.initialBlockPoolIndex.load(std::memory_order_relaxed)),
-		initialBlockPool(other.initialBlockPool),
-		initialBlockPoolSize(other.initialBlockPoolSize),
-		freeList(std::move(other.freeList)),
-		nextExplicitConsumerId(other.nextExplicitConsumerId.load(std::memory_order_relaxed)),
-		globalExplicitConsumerOffset(other.globalExplicitConsumerOffset.load(std::memory_order_relaxed))
-	{
-		// Move the other one into this, and leave the other one as an empty queue
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		swap_implicit_producer_hashes(other);
-
-		other.producerListTail.store(nullptr, std::memory_order_relaxed);
-		other.producerCount.store(0, std::memory_order_relaxed);
-		other.nextExplicitConsumerId.store(0, std::memory_order_relaxed);
-		other.globalExplicitConsumerOffset.store(0, std::memory_order_relaxed);
-
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		explicitProducers.store(other.explicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
-		other.explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(other.implicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
-		other.implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-
-		other.initialBlockPoolIndex.store(0, std::memory_order_relaxed);
-		other.initialBlockPoolSize = 0;
-		other.initialBlockPool = nullptr;
-
-		reown_producers();
-	}
-
-	inline ConcurrentQueue& operator=(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
-	{
-		return swap_internal(other);
-	}
-
-	// Swaps this queue's state with the other's. Not thread-safe.
-	// Swapping two queues does not invalidate their tokens, however
-	// the tokens that were created for one queue must be used with
-	// only the swapped queue (i.e. the tokens are tied to the
-	// queue's movable state, not the object itself).
-	inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap_internal(other);
-	}
-
-private:
-	ConcurrentQueue& swap_internal(ConcurrentQueue& other)
-	{
-		if (this == &other) {
-			return *this;
-		}
-
-		details::swap_relaxed(producerListTail, other.producerListTail);
-		details::swap_relaxed(producerCount, other.producerCount);
-		details::swap_relaxed(initialBlockPoolIndex, other.initialBlockPoolIndex);
-		std::swap(initialBlockPool, other.initialBlockPool);
-		std::swap(initialBlockPoolSize, other.initialBlockPoolSize);
-		freeList.swap(other.freeList);
-		details::swap_relaxed(nextExplicitConsumerId, other.nextExplicitConsumerId);
-		details::swap_relaxed(globalExplicitConsumerOffset, other.globalExplicitConsumerOffset);
-
-		swap_implicit_producer_hashes(other);
-
-		reown_producers();
-		other.reown_producers();
-
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		details::swap_relaxed(explicitProducers, other.explicitProducers);
-		details::swap_relaxed(implicitProducers, other.implicitProducers);
-#endif
-
-		return *this;
-	}
-
-public:
-	// Enqueues a single item (by copying it).
-	// Allocates memory if required. Only fails if memory allocation fails (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
-	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(T const& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CanAlloc>(item);
-	}
-
-	// Enqueues a single item (by moving it, if possible).
-	// Allocates memory if required. Only fails if memory allocation fails (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
-	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(T&& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CanAlloc>(std::move(item));
-	}
-
-	// Enqueues a single item (by copying it) using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(producer_token_t const& token, T const& item)
-	{
-		return inner_enqueue<CanAlloc>(token, item);
-	}
-
-	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(producer_token_t const& token, T&& item)
-	{
-		return inner_enqueue<CanAlloc>(token, std::move(item));
-	}
-
-	// Enqueues several items.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
-	// is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Note: Use std::make_move_iterator if the elements should be moved instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool enqueue_bulk(It itemFirst, size_t count)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue_bulk<CanAlloc>(itemFirst, count);
-	}
-
-	// Enqueues several items using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails
-	// (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return inner_enqueue_bulk<CanAlloc>(token, itemFirst, count);
-	}
-
-	// Enqueues a single item (by copying it).
-	// Does not allocate memory. Fails if not enough room to enqueue (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
-	// is 0).
-	// Thread-safe.
-	inline bool try_enqueue(T const& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CannotAlloc>(item);
-	}
-
-	// Enqueues a single item (by moving it, if possible).
-	// Does not allocate memory (except for one-time implicit producer).
-	// Fails if not enough room to enqueue (or implicit production is
-	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
-	// Thread-safe.
-	inline bool try_enqueue(T&& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CannotAlloc>(std::move(item));
-	}
-
-	// Enqueues a single item (by copying it) using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Thread-safe.
-	inline bool try_enqueue(producer_token_t const& token, T const& item)
-	{
-		return inner_enqueue<CannotAlloc>(token, item);
-	}
-
-	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Thread-safe.
-	inline bool try_enqueue(producer_token_t const& token, T&& item)
-	{
-		return inner_enqueue<CannotAlloc>(token, std::move(item));
-	}
-
-	// Enqueues several items.
-	// Does not allocate memory (except for one-time implicit producer).
-	// Fails if not enough room to enqueue (or implicit production is
-	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool try_enqueue_bulk(It itemFirst, size_t count)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue_bulk<CannotAlloc>(itemFirst, count);
-	}
-
-	// Enqueues several items using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return inner_enqueue_bulk<CannotAlloc>(token, itemFirst, count);
-	}
-
-
-
-	// Attempts to dequeue from the queue.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue(U& item)
-	{
-		// Instead of simply trying each producer in turn (which could cause needless contention on the first
-		// producer), we score them heuristically.
-		size_t nonEmptyCount = 0;
-		ProducerBase* best = nullptr;
-		size_t bestSize = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); nonEmptyCount < 3 && ptr != nullptr; ptr = ptr->next_prod()) {
-			auto size = ptr->size_approx();
-			if (size > 0) {
-				if (size > bestSize) {
-					bestSize = size;
-					best = ptr;
-				}
-				++nonEmptyCount;
-			}
-		}
-
-		// If there was at least one non-empty queue but it appears empty at the time
-		// we try to dequeue from it, we need to make sure every queue's been tried
-		if (nonEmptyCount > 0) {
-			if ((details::likely)(best->dequeue(item))) {
-				return true;
-			}
-			for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-				if (ptr != best && ptr->dequeue(item)) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	// Attempts to dequeue from the queue.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// This differs from the try_dequeue(item) method in that this one does
-	// not attempt to reduce contention by interleaving the order that producer
-	// streams are dequeued from. So, using this method can reduce overall throughput
-	// under contention, but will give more predictable results in single-threaded
-	// consumer scenarios. This is mostly only useful for internal unit tests.
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue_non_interleaved(U& item)
-	{
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			if (ptr->dequeue(item)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	// Attempts to dequeue from the queue using an explicit consumer token.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue(consumer_token_t& token, U& item)
-	{
-		// The idea is roughly as follows:
-		// Every 256 items from one producer, make everyone rotate (increase the global offset) -> this means the highest efficiency consumer dictates the rotation speed of everyone else, more or less
-		// If you see that the global offset has changed, you must reset your consumption counter and move to your designated place
-		// If there's no items where you're supposed to be, keep moving until you find a producer with some items
-		// If the global offset has not changed but you've run out of items to consume, move over from your current position until you find an producer with something in it
-
-		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
-			if (!update_current_producer_after_rotation(token)) {
-				return false;
-			}
-		}
-
-		// If there was at least one non-empty queue but it appears empty at the time
-		// we try to dequeue from it, we need to make sure every queue's been tried
-		if (static_cast<ProducerBase*>(token.currentProducer)->dequeue(item)) {
-			if (++token.itemsConsumedFromCurrent == EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
-				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
-			}
-			return true;
-		}
-
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
-		if (ptr == nullptr) {
-			ptr = tail;
-		}
-		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
-			if (ptr->dequeue(item)) {
-				token.currentProducer = ptr;
-				token.itemsConsumedFromCurrent = 1;
-				return true;
-			}
-			ptr = ptr->next_prod();
-			if (ptr == nullptr) {
-				ptr = tail;
-			}
-		}
-		return false;
-	}
-
-	// Attempts to dequeue several elements from the queue.
-	// Returns the number of items actually dequeued.
-	// Returns 0 if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	size_t try_dequeue_bulk(It itemFirst, size_t max)
-	{
-		size_t count = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			count += ptr->dequeue_bulk(itemFirst, max - count);
-			if (count == max) {
-				break;
-			}
-		}
-		return count;
-	}
-
-	// Attempts to dequeue several elements from the queue using an explicit consumer token.
-	// Returns the number of items actually dequeued.
-	// Returns 0 if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
-	{
-		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
-			if (!update_current_producer_after_rotation(token)) {
-				return 0;
-			}
-		}
-
-		size_t count = static_cast<ProducerBase*>(token.currentProducer)->dequeue_bulk(itemFirst, max);
-		if (count == max) {
-			if ((token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(max)) >= EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
-				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
-			}
-			return max;
-		}
-		token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(count);
-		max -= count;
-
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
-		if (ptr == nullptr) {
-			ptr = tail;
-		}
-		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
-			auto dequeued = ptr->dequeue_bulk(itemFirst, max);
-			count += dequeued;
-			if (dequeued != 0) {
-				token.currentProducer = ptr;
-				token.itemsConsumedFromCurrent = static_cast<std::uint32_t>(dequeued);
-			}
-			if (dequeued == max) {
-				break;
-			}
-			max -= dequeued;
-			ptr = ptr->next_prod();
-			if (ptr == nullptr) {
-				ptr = tail;
-			}
-		}
-		return count;
-	}
-
-
-
-	// Attempts to dequeue from a specific producer's inner queue.
-	// If you happen to know which producer you want to dequeue from, this
-	// is significantly faster than using the general-case try_dequeue methods.
-	// Returns false if the producer's queue appeared empty at the time it
-	// was checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline bool try_dequeue_from_producer(producer_token_t const& producer, U& item)
-	{
-		return static_cast<ExplicitProducer*>(producer.producer)->dequeue(item);
-	}
-
-	// Attempts to dequeue several elements from a specific producer's inner queue.
-	// Returns the number of items actually dequeued.
-	// If you happen to know which producer you want to dequeue from, this
-	// is significantly faster than using the general-case try_dequeue methods.
-	// Returns 0 if the producer's queue appeared empty at the time it
-	// was checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t try_dequeue_bulk_from_producer(producer_token_t const& producer, It itemFirst, size_t max)
-	{
-		return static_cast<ExplicitProducer*>(producer.producer)->dequeue_bulk(itemFirst, max);
-	}
-
-
-	// Returns an estimate of the total number of elements currently in the queue. This
-	// estimate is only accurate if the queue has completely stabilized before it is called
-	// (i.e. all enqueue and dequeue operations have completed and their memory effects are
-	// visible on the calling thread, and no further operations start while this method is
-	// being called).
-	// Thread-safe.
-	size_t size_approx() const
-	{
-		size_t size = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			size += ptr->size_approx();
-		}
-		return size;
-	}
-
-
-	// Returns true if the underlying atomic variables used by
-	// the queue are lock-free (they should be on most platforms).
-	// Thread-safe.
-	static bool is_lock_free()
-	{
-		return
-			details::static_is_lock_free<bool>::value == 2 &&
-			details::static_is_lock_free<size_t>::value == 2 &&
-			details::static_is_lock_free<std::uint32_t>::value == 2 &&
-			details::static_is_lock_free<index_t>::value == 2 &&
-			details::static_is_lock_free<void*>::value == 2 &&
-			details::static_is_lock_free<typename details::thread_id_converter<details::thread_id_t>::thread_id_numeric_size_t>::value == 2;
-	}
-
-
-private:
-	friend struct ProducerToken;
-	friend struct ConsumerToken;
-	struct ExplicitProducer;
-	friend struct ExplicitProducer;
-	struct ImplicitProducer;
-	friend struct ImplicitProducer;
-	friend class ConcurrentQueueTests;
-
-	enum AllocationMode { CanAlloc, CannotAlloc };
-
-
-	///////////////////////////////
-	// Queue methods
-	///////////////////////////////
-
-	template<AllocationMode canAlloc, typename U>
-	inline bool inner_enqueue(producer_token_t const& token, U&& element)
-	{
-		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
-	}
-
-	template<AllocationMode canAlloc, typename U>
-	inline bool inner_enqueue(U&& element)
-	{
-		auto producer = get_or_add_implicit_producer();
-		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
-	}
-
-	template<AllocationMode canAlloc, typename It>
-	inline bool inner_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
-	}
-
-	template<AllocationMode canAlloc, typename It>
-	inline bool inner_enqueue_bulk(It itemFirst, size_t count)
-	{
-		auto producer = get_or_add_implicit_producer();
-		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
-	}
-
-	inline bool update_current_producer_after_rotation(consumer_token_t& token)
-	{
-		// Ah, there's been a rotation, figure out where we should be!
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		if (token.desiredProducer == nullptr && tail == nullptr) {
-			return false;
-		}
-		auto prodCount = producerCount.load(std::memory_order_relaxed);
-		auto globalOffset = globalExplicitConsumerOffset.load(std::memory_order_relaxed);
-		if (token.desiredProducer == nullptr) {
-			// Aha, first time we're dequeueing anything.
-			// Figure out our local position
-			// Note: offset is from start, not end, but we're traversing from end -- subtract from count first
-			std::uint32_t offset = prodCount - 1 - (token.initialOffset % prodCount);
-			token.desiredProducer = tail;
-			for (std::uint32_t i = 0; i != offset; ++i) {
-				token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
-				if (token.desiredProducer == nullptr) {
-					token.desiredProducer = tail;
-				}
-			}
-		}
-
-		std::uint32_t delta = globalOffset - token.lastKnownGlobalOffset;
-		if (delta >= prodCount) {
-			delta = delta % prodCount;
-		}
-		for (std::uint32_t i = 0; i != delta; ++i) {
-			token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
-			if (token.desiredProducer == nullptr) {
-				token.desiredProducer = tail;
-			}
-		}
-
-		token.lastKnownGlobalOffset = globalOffset;
-		token.currentProducer = token.desiredProducer;
-		token.itemsConsumedFromCurrent = 0;
-		return true;
-	}
-
-
-	///////////////////////////
-	// Free list
-	///////////////////////////
-
-	template <typename N>
-	struct FreeListNode
-	{
-		FreeListNode() : freeListRefs(0), freeListNext(nullptr) { }
-
-		std::atomic<std::uint32_t> freeListRefs;
-		std::atomic<N*> freeListNext;
-	};
-
-	// A simple CAS-based lock-free free list. Not the fastest thing in the world under heavy contention, but
-	// simple and correct (assuming nodes are never freed until after the free list is destroyed), and fairly
-	// speedy under low contention.
-	template<typename N>		// N must inherit FreeListNode or have the same fields (and initialization of them)
-	struct FreeList
-	{
-		FreeList() : freeListHead(nullptr) { }
-		FreeList(FreeList&& other) : freeListHead(other.freeListHead.load(std::memory_order_relaxed)) { other.freeListHead.store(nullptr, std::memory_order_relaxed); }
-		void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.freeListHead); }
-
-		FreeList(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
-		FreeList& operator=(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
-
-		inline void add(N* node)
-		{
-#ifdef MCDBGQ_NOLOCKFREE_FREELIST
-			debug::DebugLock lock(mutex);
-#endif
-			// We know that the should-be-on-freelist bit is 0 at this point, so it's safe to
-			// set it using a fetch_add
-			if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST, std::memory_order_acq_rel) == 0) {
-				// Oh look! We were the last ones referencing this node, and we know
-				// we want to add it to the free list, so let's do it!
-		 		add_knowing_refcount_is_zero(node);
-			}
-		}
-
-		inline N* try_get()
-		{
-#ifdef MCDBGQ_NOLOCKFREE_FREELIST
-			debug::DebugLock lock(mutex);
-#endif
-			auto head = freeListHead.load(std::memory_order_acquire);
-			while (head != nullptr) {
-				auto prevHead = head;
-				auto refs = head->freeListRefs.load(std::memory_order_relaxed);
-				if ((refs & REFS_MASK) == 0 || !head->freeListRefs.compare_exchange_strong(refs, refs + 1, std::memory_order_acquire, std::memory_order_relaxed)) {
-					head = freeListHead.load(std::memory_order_acquire);
-					continue;
-				}
-
-				// Good, reference count has been incremented (it wasn't at zero), which means we can read the
-				// next and not worry about it changing between now and the time we do the CAS
-				auto next = head->freeListNext.load(std::memory_order_relaxed);
-				if (freeListHead.compare_exchange_strong(head, next, std::memory_order_acquire, std::memory_order_relaxed)) {
-					// Yay, got the node. This means it was on the list, which means shouldBeOnFreeList must be false no
-					// matter the refcount (because nobody else knows it's been taken off yet, it can't have been put back on).
-					assert((head->freeListRefs.load(std::memory_order_relaxed) & SHOULD_BE_ON_FREELIST) == 0);
-
-					// Decrease refcount twice, once for our ref, and once for the list's ref
-					head->freeListRefs.fetch_sub(2, std::memory_order_release);
-					return head;
-				}
-
-				// OK, the head must have changed on us, but we still need to decrease the refcount we increased.
-				// Note that we don't need to release any memory effects, but we do need to ensure that the reference
-				// count decrement happens-after the CAS on the head.
-				refs = prevHead->freeListRefs.fetch_sub(1, std::memory_order_acq_rel);
-				if (refs == SHOULD_BE_ON_FREELIST + 1) {
-					add_knowing_refcount_is_zero(prevHead);
-				}
-			}
-
-			return nullptr;
-		}
-
-		// Useful for traversing the list when there's no contention (e.g. to destroy remaining nodes)
-		N* head_unsafe() const { return freeListHead.load(std::memory_order_relaxed); }
-
-	private:
-		inline void add_knowing_refcount_is_zero(N* node)
-		{
-			// Since the refcount is zero, and nobody can increase it once it's zero (except us, and we run
-			// only one copy of this method per node at a time, i.e. the single thread case), then we know
-			// we can safely change the next pointer of the node; however, once the refcount is back above
-			// zero, then other threads could increase it (happens under heavy contention, when the refcount
-			// goes to zero in between a load and a refcount increment of a node in try_get, then back up to
-			// something non-zero, then the refcount increment is done by the other thread) -- so, if the CAS
-			// to add the node to the actual list fails, decrease the refcount and leave the add operation to
-			// the next thread who puts the refcount back at zero (which could be us, hence the loop).
-			auto head = freeListHead.load(std::memory_order_relaxed);
-			while (true) {
-				node->freeListNext.store(head, std::memory_order_relaxed);
-				node->freeListRefs.store(1, std::memory_order_release);
-				if (!freeListHead.compare_exchange_strong(head, node, std::memory_order_release, std::memory_order_relaxed)) {
-					// Hmm, the add failed, but we can only try again when the refcount goes back to zero
-					if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST - 1, std::memory_order_release) == 1) {
-						continue;
-					}
-				}
-				return;
-			}
-		}
-
-	private:
-		// Implemented like a stack, but where node order doesn't matter (nodes are inserted out of order under contention)
-		std::atomic<N*> freeListHead;
-
-	static const std::uint32_t REFS_MASK = 0x7FFFFFFF;
-	static const std::uint32_t SHOULD_BE_ON_FREELIST = 0x80000000;
-
-#ifdef MCDBGQ_NOLOCKFREE_FREELIST
-		debug::DebugMutex mutex;
-#endif
-	};
-
-
-	///////////////////////////
-	// Block
-	///////////////////////////
-
-	enum InnerQueueContext { implicit_context = 0, explicit_context = 1 };
-
-	struct Block
-	{
-		Block()
-			: next(nullptr), elementsCompletelyDequeued(0), freeListRefs(0), freeListNext(nullptr), shouldBeOnFreeList(false), dynamicallyAllocated(true)
-		{
-#ifdef MCDBGQ_TRACKMEM
-			owner = nullptr;
-#endif
-		}
-
-		template<InnerQueueContext context>
-		inline bool is_empty() const
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Check flags
-				for (size_t i = 0; i < BLOCK_SIZE; ++i) {
-					if (!emptyFlags[i].load(std::memory_order_relaxed)) {
-						return false;
-					}
-				}
-
-				// Aha, empty; make sure we have all other memory effects that happened before the empty flags were set
-				std::atomic_thread_fence(std::memory_order_acquire);
-				return true;
-			}
-			else {
-				// Check counter
-				if (elementsCompletelyDequeued.load(std::memory_order_relaxed) == BLOCK_SIZE) {
-					std::atomic_thread_fence(std::memory_order_acquire);
-					return true;
-				}
-				assert(elementsCompletelyDequeued.load(std::memory_order_relaxed) <= BLOCK_SIZE);
-				return false;
-			}
-		}
-
-		// Returns true if the block is now empty (does not apply in explicit context)
-		template<InnerQueueContext context>
-		inline bool set_empty(MOODYCAMEL_MAYBE_UNUSED index_t i)
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set flag
-				assert(!emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].load(std::memory_order_relaxed));
-				emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].store(true, std::memory_order_release);
-				return false;
-			}
-			else {
-				// Increment counter
-				auto prevVal = elementsCompletelyDequeued.fetch_add(1, std::memory_order_release);
-				assert(prevVal < BLOCK_SIZE);
-				return prevVal == BLOCK_SIZE - 1;
-			}
-		}
-
-		// Sets multiple contiguous item statuses to 'empty' (assumes no wrapping and count > 0).
-		// Returns true if the block is now empty (does not apply in explicit context).
-		template<InnerQueueContext context>
-		inline bool set_many_empty(MOODYCAMEL_MAYBE_UNUSED index_t i, size_t count)
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set flags
-				std::atomic_thread_fence(std::memory_order_release);
-				i = BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1)) - count + 1;
-				for (size_t j = 0; j != count; ++j) {
-					assert(!emptyFlags[i + j].load(std::memory_order_relaxed));
-					emptyFlags[i + j].store(true, std::memory_order_relaxed);
-				}
-				return false;
-			}
-			else {
-				// Increment counter
-				auto prevVal = elementsCompletelyDequeued.fetch_add(count, std::memory_order_release);
-				assert(prevVal + count <= BLOCK_SIZE);
-				return prevVal + count == BLOCK_SIZE;
-			}
-		}
-
-		template<InnerQueueContext context>
-		inline void set_all_empty()
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set all flags
-				for (size_t i = 0; i != BLOCK_SIZE; ++i) {
-					emptyFlags[i].store(true, std::memory_order_relaxed);
-				}
-			}
-			else {
-				// Reset counter
-				elementsCompletelyDequeued.store(BLOCK_SIZE, std::memory_order_relaxed);
-			}
-		}
-
-		template<InnerQueueContext context>
-		inline void reset_empty()
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Reset flags
-				for (size_t i = 0; i != BLOCK_SIZE; ++i) {
-					emptyFlags[i].store(false, std::memory_order_relaxed);
-				}
-			}
-			else {
-				// Reset counter
-				elementsCompletelyDequeued.store(0, std::memory_order_relaxed);
-			}
-		}
-
-		inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_cast<T*>(static_cast<void*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
-		inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { return static_cast<T const*>(static_cast<void const*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
-
-	private:
-		static_assert(std::alignment_of<T>::value <= sizeof(T), "The queue does not support types with an alignment greater than their size at this time");
-		MOODYCAMEL_ALIGNAS(MOODYCAMEL_ALIGNOF(T)) char elements[sizeof(T) * BLOCK_SIZE];
-	public:
-		Block* next;
-		std::atomic<size_t> elementsCompletelyDequeued;
-		std::atomic<bool> emptyFlags[BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD ? BLOCK_SIZE : 1];
-	public:
-		std::atomic<std::uint32_t> freeListRefs;
-		std::atomic<Block*> freeListNext;
-		std::atomic<bool> shouldBeOnFreeList;
-		bool dynamicallyAllocated;		// Perhaps a better name for this would be 'isNotPartOfInitialBlockPool'
-
-#ifdef MCDBGQ_TRACKMEM
-		void* owner;
-#endif
-	};
-	static_assert(std::alignment_of<Block>::value >= std::alignment_of<T>::value, "Internal error: Blocks must be at least as aligned as the type they are wrapping");
-
-
-#ifdef MCDBGQ_TRACKMEM
-public:
-	struct MemStats;
-private:
-#endif
-
-	///////////////////////////
-	// Producer base
-	///////////////////////////
-
-	struct ProducerBase : public details::ConcurrentQueueProducerTypelessBase
-	{
-		ProducerBase(ConcurrentQueue* parent_, bool isExplicit_) :
-			tailIndex(0),
-			headIndex(0),
-			dequeueOptimisticCount(0),
-			dequeueOvercommit(0),
-			tailBlock(nullptr),
-			isExplicit(isExplicit_),
-			parent(parent_)
-		{
-		}
-
-		virtual ~ProducerBase() { };
-
-		template<typename U>
-		inline bool dequeue(U& element)
-		{
-			if (isExplicit) {
-				return static_cast<ExplicitProducer*>(this)->dequeue(element);
-			}
-			else {
-				return static_cast<ImplicitProducer*>(this)->dequeue(element);
-			}
-		}
-
-		template<typename It>
-		inline size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			if (isExplicit) {
-				return static_cast<ExplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
-			}
-			else {
-				return static_cast<ImplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
-			}
-		}
-
-		inline ProducerBase* next_prod() const { return static_cast<ProducerBase*>(next); }
-
-		inline size_t size_approx() const
-		{
-			auto tail = tailIndex.load(std::memory_order_relaxed);
-			auto head = headIndex.load(std::memory_order_relaxed);
-			return details::circular_less_than(head, tail) ? static_cast<size_t>(tail - head) : 0;
-		}
-
-		inline index_t getTail() const { return tailIndex.load(std::memory_order_relaxed); }
-	protected:
-		std::atomic<index_t> tailIndex;		// Where to enqueue to next
-		std::atomic<index_t> headIndex;		// Where to dequeue from next
-
-		std::atomic<index_t> dequeueOptimisticCount;
-		std::atomic<index_t> dequeueOvercommit;
-
-		Block* tailBlock;
-
-	public:
-		bool isExplicit;
-		ConcurrentQueue* parent;
-
-	protected:
-#ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-
-
-	///////////////////////////
-	// Explicit queue
-	///////////////////////////
-
-	struct ExplicitProducer : public ProducerBase
-	{
-		explicit ExplicitProducer(ConcurrentQueue* parent_) :
-			ProducerBase(parent_, true),
-			blockIndex(nullptr),
-			pr_blockIndexSlotsUsed(0),
-			pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1),
-			pr_blockIndexFront(0),
-			pr_blockIndexEntries(nullptr),
-			pr_blockIndexRaw(nullptr)
-		{
-			size_t poolBasedIndexSize = details::ceil_to_pow_2(parent_->initialBlockPoolSize) >> 1;
-			if (poolBasedIndexSize > pr_blockIndexSize) {
-				pr_blockIndexSize = poolBasedIndexSize;
-			}
-
-			new_block_index(0);		// This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE
-		}
-
-		~ExplicitProducer()
-		{
-			// Destruct any elements not yet dequeued.
-			// Since we're in the destructor, we can assume all elements
-			// are either completely dequeued or completely not (no halfways).
-			if (this->tailBlock != nullptr) {		// Note this means there must be a block index too
-				// First find the block that's partially dequeued, if any
-				Block* halfDequeuedBlock = nullptr;
-				if ((this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) != 0) {
-					// The head's not on a block boundary, meaning a block somewhere is partially dequeued
-					// (or the head block is the tail block and was fully dequeued, but the head/tail are still not on a boundary)
-					size_t i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & (pr_blockIndexSize - 1);
-					while (details::circular_less_than<index_t>(pr_blockIndexEntries[i].base + BLOCK_SIZE, this->headIndex.load(std::memory_order_relaxed))) {
-						i = (i + 1) & (pr_blockIndexSize - 1);
-					}
-					assert(details::circular_less_than<index_t>(pr_blockIndexEntries[i].base, this->headIndex.load(std::memory_order_relaxed)));
-					halfDequeuedBlock = pr_blockIndexEntries[i].block;
-				}
-
-				// Start at the head block (note the first line in the loop gives us the head from the tail on the first iteration)
-				auto block = this->tailBlock;
-				do {
-					block = block->next;
-					if (block->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-						continue;
-					}
-
-					size_t i = 0;	// Offset into block
-					if (block == halfDequeuedBlock) {
-						i = static_cast<size_t>(this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
-					}
-
-					// Walk through all the items in the block; if this is the tail block, we need to stop when we reach the tail index
-					auto lastValidIndex = (this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 ? BLOCK_SIZE : static_cast<size_t>(this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
-					while (i != BLOCK_SIZE && (block != this->tailBlock || i != lastValidIndex)) {
-						(*block)[i++]->~T();
-					}
-				} while (block != this->tailBlock);
-			}
-
-			// Destroy all blocks that we own
-			if (this->tailBlock != nullptr) {
-				auto block = this->tailBlock;
-				do {
-					auto nextBlock = block->next;
-					if (block->dynamicallyAllocated) {
-						destroy(block);
-					}
-					else {
-						this->parent->add_block_to_free_list(block);
-					}
-					block = nextBlock;
-				} while (block != this->tailBlock);
-			}
-
-			// Destroy the block indices
-			auto header = static_cast<BlockIndexHeader*>(pr_blockIndexRaw);
-			while (header != nullptr) {
-				auto prev = static_cast<BlockIndexHeader*>(header->prev);
-				header->~BlockIndexHeader();
-				(Traits::free)(header);
-				header = prev;
-			}
-		}
-
-		template<AllocationMode allocMode, typename U>
-		inline bool enqueue(U&& element)
-		{
-			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			index_t newTailIndex = 1 + currentTailIndex;
-			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-				// We reached the end of a block, start a new one
-				auto startBlock = this->tailBlock;
-				auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
-				if (this->tailBlock != nullptr && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-					// We can re-use the block ahead of us, it's empty!
-					this->tailBlock = this->tailBlock->next;
-					this->tailBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-
-					// We'll put the block on the block index (guaranteed to be room since we're conceptually removing the
-					// last block from it first -- except instead of removing then adding, we can just overwrite).
-					// Note that there must be a valid block index here, since even if allocation failed in the ctor,
-					// it would have been re-attempted when adding the first block to the queue; since there is such
-					// a block, a block index must have been successfully allocated.
-				}
-				else {
-					// Whatever head value we see here is >= the last value we saw here (relatively),
-					// and <= its current value. Since we have the most recent tail, the head must be
-					// <= to it.
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE)
-						|| (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
-						// We can't enqueue in another block because there's not enough leeway -- the
-						// tail could surpass the head by the time the block fills up! (Or we'll exceed
-						// the size limit, if the second part of the condition was true.)
-						return false;
-					}
-					// We're going to need a new block; check that the block index has room
-					if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize) {
-						// Hmm, the circular block index is already full -- we'll need
-						// to allocate a new index. Note pr_blockIndexRaw can only be nullptr if
-						// the initial allocation failed in the constructor.
-
-						MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-							return false;
-						}
-						else if (!new_block_index(pr_blockIndexSlotsUsed)) {
-							return false;
-						}
-					}
-
-					// Insert a new block in the circular linked list
-					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-					if (newBlock == nullptr) {
-						return false;
-					}
-#ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-					if (this->tailBlock == nullptr) {
-						newBlock->next = newBlock;
-					}
-					else {
-						newBlock->next = this->tailBlock->next;
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					++pr_blockIndexSlotsUsed;
-				}
-
-				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
-					// The constructor may throw. We want the element not to appear in the queue in
-					// that case (without corrupting the queue):
-					MOODYCAMEL_TRY {
-						new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-					}
-					MOODYCAMEL_CATCH (...) {
-						// Revert change to the current block, but leave the new block available
-						// for next time
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? this->tailBlock : startBlock;
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				else {
-					(void)startBlock;
-					(void)originalBlockIndexSlotsUsed;
-				}
-
-				// Add block to block index
-				auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-				entry.base = currentTailIndex;
-				entry.block = this->tailBlock;
-				blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release);
-				pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-
-				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
-					this->tailIndex.store(newTailIndex, std::memory_order_release);
-					return true;
-				}
-			}
-
-			// Enqueue
-			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-
-		template<typename U>
-		bool dequeue(U& element)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
-				// Might be something to dequeue, let's give it a try
-
-				// Note that this if is purely for performance purposes in the common case when the queue is
-				// empty and the values are eventually consistent -- we may enter here spuriously.
-
-				// Note that whatever the values of overcommit and tail are, they are not going to change (unless we
-				// change them) and must be the same value at this point (inside the if) as when the if condition was
-				// evaluated.
-
-				// We insert an acquire fence here to synchronize-with the release upon incrementing dequeueOvercommit below.
-				// This ensures that whatever the value we got loaded into overcommit, the load of dequeueOptisticCount in
-				// the fetch_add below will result in a value at least as recent as that (and therefore at least as large).
-				// Note that I believe a compiler (signal) fence here would be sufficient due to the nature of fetch_add (all
-				// read-modify-write operations are guaranteed to work on the latest value in the modification order), but
-				// unfortunately that can't be shown to be correct using only the C++11 standard.
-				// See http://stackoverflow.com/questions/18223161/what-are-the-c11-memory-ordering-guarantees-in-this-corner-case
-				std::atomic_thread_fence(std::memory_order_acquire);
-
-				// Increment optimistic counter, then check if it went over the boundary
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
-
-				// Note that since dequeueOvercommit must be <= dequeueOptimisticCount (because dequeueOvercommit is only ever
-				// incremented after dequeueOptimisticCount -- this is enforced in the `else` block below), and since we now
-				// have a version of dequeueOptimisticCount that is at least as recent as overcommit (due to the release upon
-				// incrementing dequeueOvercommit and the acquire above that synchronizes with it), overcommit <= myDequeueCount.
-				// However, we can't assert this since both dequeueOptimisticCount and dequeueOvercommit may (independently)
-				// overflow; in such a case, though, the logic still holds since the difference between the two is maintained.
-
-				// Note that we reload tail here in case it changed; it will be the same value as before or greater, since
-				// this load is sequenced after (happens after) the earlier load above. This is supported by read-read
-				// coherency (as defined in the standard), explained here: http://en.cppreference.com/w/cpp/atomic/memory_order
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
-					// Guaranteed to be at least one element to dequeue!
-
-					// Get the index. Note that since there's guaranteed to be at least one element, this
-					// will never exceed tail. We need to do an acquire-release fence here since it's possible
-					// that whatever condition got us to this point was for an earlier enqueued element (that
-					// we already see the memory effects for), but that by the time we increment somebody else
-					// has incremented it, and we need to see the memory effects for *that* element, which is
-					// in such a case is necessarily visible on the thread that incremented it in the first
-					// place with the more current condition (they must have acquired a tail that is at least
-					// as recent).
-					auto index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
-
-
-					// Determine which block the element is in
-
-					auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
-					auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
-
-					// We need to be careful here about subtracting and dividing because of index wrap-around.
-					// When an index wraps, we need to preserve the sign of the offset when dividing it by the
-					// block size (in order to get a correct signed block count offset in all cases):
-					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
-					auto blockBaseIndex = index & ~static_cast<index_t>(BLOCK_SIZE - 1);
-					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(blockBaseIndex - headBase) / BLOCK_SIZE);
-					auto block = localBlockIndex->entries[(localBlockIndexHead + offset) & (localBlockIndex->size - 1)].block;
-
-					// Dequeue
-					auto& el = *((*block)[index]);
-					if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
-						// Make sure the element is still fully dequeued and destroyed even if the assignment
-						// throws
-						struct Guard {
-							Block* block;
-							index_t index;
-
-							~Guard()
-							{
-								(*block)[index]->~T();
-								block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
-							}
-						} guard = { block, index };
-
-						element = std::move(el); // NOLINT
-					}
-					else {
-						element = std::move(el); // NOLINT
-						el.~T(); // NOLINT
-						block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
-					}
-
-					return true;
-				}
-				else {
-					// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
-					this->dequeueOvercommit.fetch_add(1, std::memory_order_release);		// Release so that the fetch_add on dequeueOptimisticCount is guaranteed to happen before this write
-				}
-			}
-
-			return false;
-		}
-
-		template<AllocationMode allocMode, typename It>
-		bool enqueue_bulk(It itemFirst, size_t count)
-		{
-			// First, we need to make sure we have enough room to enqueue all of the elements;
-			// this means pre-allocating blocks and putting them in the block index (but only if
-			// all the allocations succeeded).
-			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			auto startBlock = this->tailBlock;
-			auto originalBlockIndexFront = pr_blockIndexFront;
-			auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
-
-			Block* firstAllocatedBlock = nullptr;
-
-			// Figure out how many blocks we'll need to allocate, and do so
-			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
-			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-			if (blockBaseDiff > 0) {
-				// Allocate as many blocks as possible from ahead
-				while (blockBaseDiff > 0 && this->tailBlock != nullptr && this->tailBlock->next != firstAllocatedBlock && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-
-					this->tailBlock = this->tailBlock->next;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
-
-					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-					entry.base = currentTailIndex;
-					entry.block = this->tailBlock;
-					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-				}
-
-				// Now allocate as many blocks as necessary from the block pool
-				while (blockBaseDiff > 0) {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
-					if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize || full) {
-						MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-							// Failed to allocate, undo changes (but keep injected blocks)
-							pr_blockIndexFront = originalBlockIndexFront;
-							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-							return false;
-						}
-						else if (full || !new_block_index(originalBlockIndexSlotsUsed)) {
-							// Failed to allocate, undo changes (but keep injected blocks)
-							pr_blockIndexFront = originalBlockIndexFront;
-							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-							return false;
-						}
-
-						// pr_blockIndexFront is updated inside new_block_index, so we need to
-						// update our fallback value too (since we keep the new index even if we
-						// later fail)
-						originalBlockIndexFront = originalBlockIndexSlotsUsed;
-					}
-
-					// Insert a new block in the circular linked list
-					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-					if (newBlock == nullptr) {
-						pr_blockIndexFront = originalBlockIndexFront;
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-						return false;
-					}
-
-#ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template set_all_empty<explicit_context>();
-					if (this->tailBlock == nullptr) {
-						newBlock->next = newBlock;
-					}
-					else {
-						newBlock->next = this->tailBlock->next;
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
-
-					++pr_blockIndexSlotsUsed;
-
-					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-					entry.base = currentTailIndex;
-					entry.block = this->tailBlock;
-					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-				}
-
-				// Excellent, all allocations succeeded. Reset each block's emptiness before we fill them up, and
-				// publish the new block index front
-				auto block = firstAllocatedBlock;
-				while (true) {
-					block->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-					if (block == this->tailBlock) {
-						break;
-					}
-					block = block->next;
-				}
-
-				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
-					blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
-				}
-			}
-
-			// Enqueue, one block at a time
-			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
-			currentTailIndex = startTailIndex;
-			auto endBlock = this->tailBlock;
-			this->tailBlock = startBlock;
-			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
-			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
-				this->tailBlock = firstAllocatedBlock;
-			}
-			while (true) {
-				auto stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
-					stopIndex = newTailIndex;
-				}
-				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
-					while (currentTailIndex != stopIndex) {
-						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
-					}
-				}
-				else {
-					MOODYCAMEL_TRY {
-						while (currentTailIndex != stopIndex) {
-							// Must use copy constructor even if move constructor is available
-							// because we may have to revert if there's an exception.
-							// Sorry about the horrible templated next line, but it was the only way
-							// to disable moving *at compile time*, which is important because a type
-							// may only define a (noexcept) move constructor, and so calls to the
-							// cctor will not compile, even if they are in an if branch that will never
-							// be executed
-							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
-							++currentTailIndex;
-							++itemFirst;
-						}
-					}
-					MOODYCAMEL_CATCH (...) {
-						// Oh dear, an exception's been thrown -- destroy the elements that
-						// were enqueued so far and revert the entire bulk operation (we'll keep
-						// any allocated blocks in our linked list for later, though).
-						auto constructedStopIndex = currentTailIndex;
-						auto lastBlockEnqueued = this->tailBlock;
-
-						pr_blockIndexFront = originalBlockIndexFront;
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-
-						if (!details::is_trivially_destructible<T>::value) {
-							auto block = startBlock;
-							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-								block = firstAllocatedBlock;
-							}
-							currentTailIndex = startTailIndex;
-							while (true) {
-								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
-									stopIndex = constructedStopIndex;
-								}
-								while (currentTailIndex != stopIndex) {
-									(*block)[currentTailIndex++]->~T();
-								}
-								if (block == lastBlockEnqueued) {
-									break;
-								}
-								block = block->next;
-							}
-						}
-						MOODYCAMEL_RETHROW;
-					}
-				}
-
-				if (this->tailBlock == endBlock) {
-					assert(currentTailIndex == newTailIndex);
-					break;
-				}
-				this->tailBlock = this->tailBlock->next;
-			}
-
-			if (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst))) && firstAllocatedBlock != nullptr) {
-				blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
-			}
-
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-
-		template<typename It>
-		size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
-			if (details::circular_less_than<size_t>(0, desiredCount)) {
-				desiredCount = desiredCount < max ? desiredCount : max;
-				std::atomic_thread_fence(std::memory_order_acquire);
-
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);;
-
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
-				if (details::circular_less_than<size_t>(0, actualCount)) {
-					actualCount = desiredCount < actualCount ? desiredCount : actualCount;
-					if (actualCount < desiredCount) {
-						this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
-					}
-
-					// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
-					// will never exceed tail.
-					auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
-
-					// Determine which block the first element is in
-					auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
-					auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
-
-					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
-					auto firstBlockBaseIndex = firstIndex & ~static_cast<index_t>(BLOCK_SIZE - 1);
-					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(firstBlockBaseIndex - headBase) / BLOCK_SIZE);
-					auto indexIndex = (localBlockIndexHead + offset) & (localBlockIndex->size - 1);
-
-					// Iterate the blocks and dequeue
-					auto index = firstIndex;
-					do {
-						auto firstIndexInBlock = index;
-						auto endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-						endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-						auto block = localBlockIndex->entries[indexIndex].block;
-						if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
-							while (index != endIndex) {
-								auto& el = *((*block)[index]);
-								*itemFirst++ = std::move(el);
-								el.~T();
-								++index;
-							}
-						}
-						else {
-							MOODYCAMEL_TRY {
-								while (index != endIndex) {
-									auto& el = *((*block)[index]);
-									*itemFirst = std::move(el);
-									++itemFirst;
-									el.~T();
-									++index;
-								}
-							}
-							MOODYCAMEL_CATCH (...) {
-								// It's too late to revert the dequeue, but we can make sure that all
-								// the dequeued objects are properly destroyed and the block index
-								// (and empty count) are properly updated before we propagate the exception
-								do {
-									block = localBlockIndex->entries[indexIndex].block;
-									while (index != endIndex) {
-										(*block)[index++]->~T();
-									}
-									block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
-									indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
-
-									firstIndexInBlock = index;
-									endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-									endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-								} while (index != firstIndex + actualCount);
-
-								MOODYCAMEL_RETHROW;
-							}
-						}
-						block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
-						indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
-					} while (index != firstIndex + actualCount);
-
-					return actualCount;
-				}
-				else {
-					// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
-					this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
-				}
-			}
-
-			return 0;
-		}
-
-	private:
-		struct BlockIndexEntry
-		{
-			index_t base;
-			Block* block;
-		};
-
-		struct BlockIndexHeader
-		{
-			size_t size;
-			std::atomic<size_t> front;		// Current slot (not next, like pr_blockIndexFront)
-			BlockIndexEntry* entries;
-			void* prev;
-		};
-
-
-		bool new_block_index(size_t numberOfFilledSlotsToExpose)
-		{
-			auto prevBlockSizeMask = pr_blockIndexSize - 1;
-
-			// Create the new block
-			pr_blockIndexSize <<= 1;
-			auto newRawPtr = static_cast<char*>((Traits::malloc)(sizeof(BlockIndexHeader) + std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * pr_blockIndexSize));
-			if (newRawPtr == nullptr) {
-				pr_blockIndexSize >>= 1;		// Reset to allow graceful retry
-				return false;
-			}
-
-			auto newBlockIndexEntries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(newRawPtr + sizeof(BlockIndexHeader)));
-
-			// Copy in all the old indices, if any
-			size_t j = 0;
-			if (pr_blockIndexSlotsUsed != 0) {
-				auto i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & prevBlockSizeMask;
-				do {
-					newBlockIndexEntries[j++] = pr_blockIndexEntries[i];
-					i = (i + 1) & prevBlockSizeMask;
-				} while (i != pr_blockIndexFront);
-			}
-
-			// Update everything
-			auto header = new (newRawPtr) BlockIndexHeader;
-			header->size = pr_blockIndexSize;
-			header->front.store(numberOfFilledSlotsToExpose - 1, std::memory_order_relaxed);
-			header->entries = newBlockIndexEntries;
-			header->prev = pr_blockIndexRaw;		// we link the new block to the old one so we can free it later
-
-			pr_blockIndexFront = j;
-			pr_blockIndexEntries = newBlockIndexEntries;
-			pr_blockIndexRaw = newRawPtr;
-			blockIndex.store(header, std::memory_order_release);
-
-			return true;
-		}
-
-	private:
-		std::atomic<BlockIndexHeader*> blockIndex;
-
-		// To be used by producer only -- consumer must use the ones in referenced by blockIndex
-		size_t pr_blockIndexSlotsUsed;
-		size_t pr_blockIndexSize;
-		size_t pr_blockIndexFront;		// Next slot (not current)
-		BlockIndexEntry* pr_blockIndexEntries;
-		void* pr_blockIndexRaw;
-
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	public:
-		ExplicitProducer* nextExplicitProducer;
-	private:
-#endif
-
-#ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-
-
-	//////////////////////////////////
-	// Implicit queue
-	//////////////////////////////////
-
-	struct ImplicitProducer : public ProducerBase
-	{
-		ImplicitProducer(ConcurrentQueue* parent_) :
-			ProducerBase(parent_, false),
-			nextBlockIndexCapacity(IMPLICIT_INITIAL_INDEX_SIZE),
-			blockIndex(nullptr)
-		{
-			new_block_index();
-		}
-
-		~ImplicitProducer()
-		{
-			// Note that since we're in the destructor we can assume that all enqueue/dequeue operations
-			// completed already; this means that all undequeued elements are placed contiguously across
-			// contiguous blocks, and that only the first and last remaining blocks can be only partially
-			// empty (all other remaining blocks must be completely full).
-
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-			// Unregister ourselves for thread termination notification
-			if (!this->inactive.load(std::memory_order_relaxed)) {
-				details::ThreadExitNotifier::unsubscribe(&threadExitListener);
-			}
-#endif
-
-			// Destroy all remaining elements!
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto index = this->headIndex.load(std::memory_order_relaxed);
-			Block* block = nullptr;
-			assert(index == tail || details::circular_less_than(index, tail));
-			bool forceFreeLastBlock = index != tail;		// If we enter the loop, then the last (tail) block will not be freed
-			while (index != tail) {
-				if ((index & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 || block == nullptr) {
-					if (block != nullptr) {
-						// Free the old block
-						this->parent->add_block_to_free_list(block);
-					}
-
-					block = get_block_index_entry_for_index(index)->value.load(std::memory_order_relaxed);
-				}
-
-				((*block)[index])->~T();
-				++index;
-			}
-			// Even if the queue is empty, there's still one block that's not on the free list
-			// (unless the head index reached the end of it, in which case the tail will be poised
-			// to create a new block).
-			if (this->tailBlock != nullptr && (forceFreeLastBlock || (tail & static_cast<index_t>(BLOCK_SIZE - 1)) != 0)) {
-				this->parent->add_block_to_free_list(this->tailBlock);
-			}
-
-			// Destroy block index
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-			if (localBlockIndex != nullptr) {
-				for (size_t i = 0; i != localBlockIndex->capacity; ++i) {
-					localBlockIndex->index[i]->~BlockIndexEntry();
-				}
-				do {
-					auto prev = localBlockIndex->prev;
-					localBlockIndex->~BlockIndexHeader();
-					(Traits::free)(localBlockIndex);
-					localBlockIndex = prev;
-				} while (localBlockIndex != nullptr);
-			}
-		}
-
-		template<AllocationMode allocMode, typename U>
-		inline bool enqueue(U&& element)
-		{
-			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			index_t newTailIndex = 1 + currentTailIndex;
-			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-				// We reached the end of a block, start a new one
-				auto head = this->headIndex.load(std::memory_order_relaxed);
-				assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-				if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
-					return false;
-				}
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-				debug::DebugLock lock(mutex);
-#endif
-				// Find out where we'll be inserting this block in the block index
-				BlockIndexEntry* idxEntry;
-				if (!insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) {
-					return false;
-				}
-
-				// Get ahold of a new block
-				auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-				if (newBlock == nullptr) {
-					rewind_block_index_tail();
-					idxEntry->value.store(nullptr, std::memory_order_relaxed);
-					return false;
-				}
-#ifdef MCDBGQ_TRACKMEM
-				newBlock->owner = this;
-#endif
-				newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
-
-				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
-					// May throw, try to insert now before we publish the fact that we have this new block
-					MOODYCAMEL_TRY {
-						new ((*newBlock)[currentTailIndex]) T(std::forward<U>(element));
-					}
-					MOODYCAMEL_CATCH (...) {
-						rewind_block_index_tail();
-						idxEntry->value.store(nullptr, std::memory_order_relaxed);
-						this->parent->add_block_to_free_list(newBlock);
-						MOODYCAMEL_RETHROW;
-					}
-				}
-
-				// Insert the new block into the index
-				idxEntry->value.store(newBlock, std::memory_order_relaxed);
-
-				this->tailBlock = newBlock;
-
-				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
-					this->tailIndex.store(newTailIndex, std::memory_order_release);
-					return true;
-				}
-			}
-
-			// Enqueue
-			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-
-		template<typename U>
-		bool dequeue(U& element)
-		{
-			// See ExplicitProducer::dequeue for rationale and explanation
-			index_t tail = this->tailIndex.load(std::memory_order_relaxed);
-			index_t overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
-				std::atomic_thread_fence(std::memory_order_acquire);
-
-				index_t myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
-					index_t index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
-
-					// Determine which block the element is in
-					auto entry = get_block_index_entry_for_index(index);
-
-					// Dequeue
-					auto block = entry->value.load(std::memory_order_relaxed);
-					auto& el = *((*block)[index]);
-
-					if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-						// Note: Acquiring the mutex with every dequeue instead of only when a block
-						// is released is very sub-optimal, but it is, after all, purely debug code.
-						debug::DebugLock lock(producer->mutex);
-#endif
-						struct Guard {
-							Block* block;
-							index_t index;
-							BlockIndexEntry* entry;
-							ConcurrentQueue* parent;
-
-							~Guard()
-							{
-								(*block)[index]->~T();
-								if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
-									entry->value.store(nullptr, std::memory_order_relaxed);
-									parent->add_block_to_free_list(block);
-								}
-							}
-						} guard = { block, index, entry, this->parent };
-
-						element = std::move(el); // NOLINT
-					}
-					else {
-						element = std::move(el); // NOLINT
-						el.~T(); // NOLINT
-
-						if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
-							{
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-								debug::DebugLock lock(mutex);
-#endif
-								// Add the block back into the global free pool (and remove from block index)
-								entry->value.store(nullptr, std::memory_order_relaxed);
-							}
-							this->parent->add_block_to_free_list(block);		// releases the above store
-						}
-					}
-
-					return true;
-				}
-				else {
-					this->dequeueOvercommit.fetch_add(1, std::memory_order_release);
-				}
-			}
-
-			return false;
-		}
-
-		template<AllocationMode allocMode, typename It>
-		bool enqueue_bulk(It itemFirst, size_t count)
-		{
-			// First, we need to make sure we have enough room to enqueue all of the elements;
-			// this means pre-allocating blocks and putting them in the block index (but only if
-			// all the allocations succeeded).
-
-			// Note that the tailBlock we start off with may not be owned by us any more;
-			// this happens if it was filled up exactly to the top (setting tailIndex to
-			// the first index of the next block which is not yet allocated), then dequeued
-			// completely (putting it on the free list) before we enqueue again.
-
-			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			auto startBlock = this->tailBlock;
-			Block* firstAllocatedBlock = nullptr;
-			auto endBlock = this->tailBlock;
-
-			// Figure out how many blocks we'll need to allocate, and do so
-			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
-			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-			if (blockBaseDiff > 0) {
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-				debug::DebugLock lock(mutex);
-#endif
-				do {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-
-					// Find out where we'll be inserting this block in the block index
-					BlockIndexEntry* idxEntry = nullptr;  // initialization here unnecessary but compiler can't always tell
-					Block* newBlock;
-					bool indexInserted = false;
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
-					if (full || !(indexInserted = insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) || (newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>()) == nullptr) {
-						// Index allocation or block allocation failed; revert any other allocations
-						// and index insertions done so far for this operation
-						if (indexInserted) {
-							rewind_block_index_tail();
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-						}
-						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
-							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-							idxEntry = get_block_index_entry_for_index(currentTailIndex);
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-							rewind_block_index_tail();
-						}
-						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
-						this->tailBlock = startBlock;
-
-						return false;
-					}
-
-#ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
-					newBlock->next = nullptr;
-
-					// Insert the new block into the index
-					idxEntry->value.store(newBlock, std::memory_order_relaxed);
-
-					// Store the chain of blocks so that we can undo if later allocations fail,
-					// and so that we can find the blocks when we do the actual enqueueing
-					if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr) {
-						assert(this->tailBlock != nullptr);
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					endBlock = newBlock;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? newBlock : firstAllocatedBlock;
-				} while (blockBaseDiff > 0);
-			}
-
-			// Enqueue, one block at a time
-			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
-			currentTailIndex = startTailIndex;
-			this->tailBlock = startBlock;
-			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
-			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
-				this->tailBlock = firstAllocatedBlock;
-			}
-			while (true) {
-				auto stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
-					stopIndex = newTailIndex;
-				}
-				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
-					while (currentTailIndex != stopIndex) {
-						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
-					}
-				}
-				else {
-					MOODYCAMEL_TRY {
-						while (currentTailIndex != stopIndex) {
-							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
-							++currentTailIndex;
-							++itemFirst;
-						}
-					}
-					MOODYCAMEL_CATCH (...) {
-						auto constructedStopIndex = currentTailIndex;
-						auto lastBlockEnqueued = this->tailBlock;
-
-						if (!details::is_trivially_destructible<T>::value) {
-							auto block = startBlock;
-							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-								block = firstAllocatedBlock;
-							}
-							currentTailIndex = startTailIndex;
-							while (true) {
-								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
-									stopIndex = constructedStopIndex;
-								}
-								while (currentTailIndex != stopIndex) {
-									(*block)[currentTailIndex++]->~T();
-								}
-								if (block == lastBlockEnqueued) {
-									break;
-								}
-								block = block->next;
-							}
-						}
-
-						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
-							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-							auto idxEntry = get_block_index_entry_for_index(currentTailIndex);
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-							rewind_block_index_tail();
-						}
-						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
-						this->tailBlock = startBlock;
-						MOODYCAMEL_RETHROW;
-					}
-				}
-
-				if (this->tailBlock == endBlock) {
-					assert(currentTailIndex == newTailIndex);
-					break;
-				}
-				this->tailBlock = this->tailBlock->next;
-			}
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-
-		template<typename It>
-		size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
-			if (details::circular_less_than<size_t>(0, desiredCount)) {
-				desiredCount = desiredCount < max ? desiredCount : max;
-				std::atomic_thread_fence(std::memory_order_acquire);
-
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
-
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
-				if (details::circular_less_than<size_t>(0, actualCount)) {
-					actualCount = desiredCount < actualCount ? desiredCount : actualCount;
-					if (actualCount < desiredCount) {
-						this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
-					}
-
-					// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
-					// will never exceed tail.
-					auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
-
-					// Iterate the blocks and dequeue
-					auto index = firstIndex;
-					BlockIndexHeader* localBlockIndex;
-					auto indexIndex = get_block_index_index_for_index(index, localBlockIndex);
-					do {
-						auto blockStartIndex = index;
-						auto endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-						endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-
-						auto entry = localBlockIndex->index[indexIndex];
-						auto block = entry->value.load(std::memory_order_relaxed);
-						if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
-							while (index != endIndex) {
-								auto& el = *((*block)[index]);
-								*itemFirst++ = std::move(el);
-								el.~T();
-								++index;
-							}
-						}
-						else {
-							MOODYCAMEL_TRY {
-								while (index != endIndex) {
-									auto& el = *((*block)[index]);
-									*itemFirst = std::move(el);
-									++itemFirst;
-									el.~T();
-									++index;
-								}
-							}
-							MOODYCAMEL_CATCH (...) {
-								do {
-									entry = localBlockIndex->index[indexIndex];
-									block = entry->value.load(std::memory_order_relaxed);
-									while (index != endIndex) {
-										(*block)[index++]->~T();
-									}
-
-									if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-										debug::DebugLock lock(mutex);
-#endif
-										entry->value.store(nullptr, std::memory_order_relaxed);
-										this->parent->add_block_to_free_list(block);
-									}
-									indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
-
-									blockStartIndex = index;
-									endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-									endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-								} while (index != firstIndex + actualCount);
-
-								MOODYCAMEL_RETHROW;
-							}
-						}
-						if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
-							{
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-								debug::DebugLock lock(mutex);
-#endif
-								// Note that the set_many_empty above did a release, meaning that anybody who acquires the block
-								// we're about to free can use it safely since our writes (and reads!) will have happened-before then.
-								entry->value.store(nullptr, std::memory_order_relaxed);
-							}
-							this->parent->add_block_to_free_list(block);		// releases the above store
-						}
-						indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
-					} while (index != firstIndex + actualCount);
-
-					return actualCount;
-				}
-				else {
-					this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
-				}
-			}
-
-			return 0;
-		}
-
-	private:
-		// The block size must be > 1, so any number with the low bit set is an invalid block base index
-		static const index_t INVALID_BLOCK_BASE = 1;
-
-		struct BlockIndexEntry
-		{
-			std::atomic<index_t> key;
-			std::atomic<Block*> value;
-		};
-
-		struct BlockIndexHeader
-		{
-			size_t capacity;
-			std::atomic<size_t> tail;
-			BlockIndexEntry* entries;
-			BlockIndexEntry** index;
-			BlockIndexHeader* prev;
-		};
-
-		template<AllocationMode allocMode>
-		inline bool insert_block_index_entry(BlockIndexEntry*& idxEntry, index_t blockStartIndex)
-		{
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);		// We're the only writer thread, relaxed is OK
-			if (localBlockIndex == nullptr) {
-				return false;  // this can happen if new_block_index failed in the constructor
-			}
-			auto newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
-			idxEntry = localBlockIndex->index[newTail];
-			if (idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE ||
-				idxEntry->value.load(std::memory_order_relaxed) == nullptr) {
-
-				idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
-				localBlockIndex->tail.store(newTail, std::memory_order_release);
-				return true;
-			}
-
-			// No room in the old block index, try to allocate another one!
-			MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-				return false;
-			}
-			else if (!new_block_index()) {
-				return false;
-			}
-			localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-			newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
-			idxEntry = localBlockIndex->index[newTail];
-			assert(idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE);
-			idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
-			localBlockIndex->tail.store(newTail, std::memory_order_release);
-			return true;
-		}
-
-		inline void rewind_block_index_tail()
-		{
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-			localBlockIndex->tail.store((localBlockIndex->tail.load(std::memory_order_relaxed) - 1) & (localBlockIndex->capacity - 1), std::memory_order_relaxed);
-		}
-
-		inline BlockIndexEntry* get_block_index_entry_for_index(index_t index) const
-		{
-			BlockIndexHeader* localBlockIndex;
-			auto idx = get_block_index_index_for_index(index, localBlockIndex);
-			return localBlockIndex->index[idx];
-		}
-
-		inline size_t get_block_index_index_for_index(index_t index, BlockIndexHeader*& localBlockIndex) const
-		{
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-			debug::DebugLock lock(mutex);
-#endif
-			index &= ~static_cast<index_t>(BLOCK_SIZE - 1);
-			localBlockIndex = blockIndex.load(std::memory_order_acquire);
-			auto tail = localBlockIndex->tail.load(std::memory_order_acquire);
-			auto tailBase = localBlockIndex->index[tail]->key.load(std::memory_order_relaxed);
-			assert(tailBase != INVALID_BLOCK_BASE);
-			// Note: Must use division instead of shift because the index may wrap around, causing a negative
-			// offset, whose negativity we want to preserve
-			auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(index - tailBase) / BLOCK_SIZE);
-			size_t idx = (tail + offset) & (localBlockIndex->capacity - 1);
-			assert(localBlockIndex->index[idx]->key.load(std::memory_order_relaxed) == index && localBlockIndex->index[idx]->value.load(std::memory_order_relaxed) != nullptr);
-			return idx;
-		}
-
-		bool new_block_index()
-		{
-			auto prev = blockIndex.load(std::memory_order_relaxed);
-			size_t prevCapacity = prev == nullptr ? 0 : prev->capacity;
-			auto entryCount = prev == nullptr ? nextBlockIndexCapacity : prevCapacity;
-			auto raw = static_cast<char*>((Traits::malloc)(
-				sizeof(BlockIndexHeader) +
-				std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * entryCount +
-				std::alignment_of<BlockIndexEntry*>::value - 1 + sizeof(BlockIndexEntry*) * nextBlockIndexCapacity));
-			if (raw == nullptr) {
-				return false;
-			}
-
-			auto header = new (raw) BlockIndexHeader;
-			auto entries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(raw + sizeof(BlockIndexHeader)));
-			auto index = reinterpret_cast<BlockIndexEntry**>(details::align_for<BlockIndexEntry*>(reinterpret_cast<char*>(entries) + sizeof(BlockIndexEntry) * entryCount));
-			if (prev != nullptr) {
-				auto prevTail = prev->tail.load(std::memory_order_relaxed);
-				auto prevPos = prevTail;
-				size_t i = 0;
-				do {
-					prevPos = (prevPos + 1) & (prev->capacity - 1);
-					index[i++] = prev->index[prevPos];
-				} while (prevPos != prevTail);
-				assert(i == prevCapacity);
-			}
-			for (size_t i = 0; i != entryCount; ++i) {
-				new (entries + i) BlockIndexEntry;
-				entries[i].key.store(INVALID_BLOCK_BASE, std::memory_order_relaxed);
-				index[prevCapacity + i] = entries + i;
-			}
-			header->prev = prev;
-			header->entries = entries;
-			header->index = index;
-			header->capacity = nextBlockIndexCapacity;
-			header->tail.store((prevCapacity - 1) & (nextBlockIndexCapacity - 1), std::memory_order_relaxed);
-
-			blockIndex.store(header, std::memory_order_release);
-
-			nextBlockIndexCapacity <<= 1;
-
-			return true;
-		}
-
-	private:
-		size_t nextBlockIndexCapacity;
-		std::atomic<BlockIndexHeader*> blockIndex;
-
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-	public:
-		details::ThreadExitListener threadExitListener;
-	private:
-#endif
-
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	public:
-		ImplicitProducer* nextImplicitProducer;
-	private:
-#endif
-
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-		mutable debug::DebugMutex mutex;
-#endif
-#ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-
-
-	//////////////////////////////////
-	// Block pool manipulation
-	//////////////////////////////////
-
-	void populate_initial_block_list(size_t blockCount)
-	{
-		initialBlockPoolSize = blockCount;
-		if (initialBlockPoolSize == 0) {
-			initialBlockPool = nullptr;
-			return;
-		}
-
-		initialBlockPool = create_array<Block>(blockCount);
-		if (initialBlockPool == nullptr) {
-			initialBlockPoolSize = 0;
-		}
-		for (size_t i = 0; i < initialBlockPoolSize; ++i) {
-			initialBlockPool[i].dynamicallyAllocated = false;
-		}
-	}
-
-	inline Block* try_get_block_from_initial_pool()
-	{
-		if (initialBlockPoolIndex.load(std::memory_order_relaxed) >= initialBlockPoolSize) {
-			return nullptr;
-		}
-
-		auto index = initialBlockPoolIndex.fetch_add(1, std::memory_order_relaxed);
-
-		return index < initialBlockPoolSize ? (initialBlockPool + index) : nullptr;
-	}
-
-	inline void add_block_to_free_list(Block* block)
-	{
-#ifdef MCDBGQ_TRACKMEM
-		block->owner = nullptr;
-#endif
-		freeList.add(block);
-	}
-
-	inline void add_blocks_to_free_list(Block* block)
-	{
-		while (block != nullptr) {
-			auto next = block->next;
-			add_block_to_free_list(block);
-			block = next;
-		}
-	}
-
-	inline Block* try_get_block_from_free_list()
-	{
-		return freeList.try_get();
-	}
-
-	// Gets a free block from one of the memory pools, or allocates a new one (if applicable)
-	template<AllocationMode canAlloc>
-	Block* requisition_block()
-	{
-		auto block = try_get_block_from_initial_pool();
-		if (block != nullptr) {
-			return block;
-		}
-
-		block = try_get_block_from_free_list();
-		if (block != nullptr) {
-			return block;
-		}
-
-		MOODYCAMEL_CONSTEXPR_IF (canAlloc == CanAlloc) {
-			return create<Block>();
-		}
-		else {
-			return nullptr;
-		}
-	}
-
-
-#ifdef MCDBGQ_TRACKMEM
-	public:
-		struct MemStats {
-			size_t allocatedBlocks;
-			size_t usedBlocks;
-			size_t freeBlocks;
-			size_t ownedBlocksExplicit;
-			size_t ownedBlocksImplicit;
-			size_t implicitProducers;
-			size_t explicitProducers;
-			size_t elementsEnqueued;
-			size_t blockClassBytes;
-			size_t queueClassBytes;
-			size_t implicitBlockIndexBytes;
-			size_t explicitBlockIndexBytes;
-
-			friend class ConcurrentQueue;
-
-		private:
-			static MemStats getFor(ConcurrentQueue* q)
-			{
-				MemStats stats = { 0 };
-
-				stats.elementsEnqueued = q->size_approx();
-
-				auto block = q->freeList.head_unsafe();
-				while (block != nullptr) {
-					++stats.allocatedBlocks;
-					++stats.freeBlocks;
-					block = block->freeListNext.load(std::memory_order_relaxed);
-				}
-
-				for (auto ptr = q->producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-					bool implicit = dynamic_cast<ImplicitProducer*>(ptr) != nullptr;
-					stats.implicitProducers += implicit ? 1 : 0;
-					stats.explicitProducers += implicit ? 0 : 1;
-
-					if (implicit) {
-						auto prod = static_cast<ImplicitProducer*>(ptr);
-						stats.queueClassBytes += sizeof(ImplicitProducer);
-						auto head = prod->headIndex.load(std::memory_order_relaxed);
-						auto tail = prod->tailIndex.load(std::memory_order_relaxed);
-						auto hash = prod->blockIndex.load(std::memory_order_relaxed);
-						if (hash != nullptr) {
-							for (size_t i = 0; i != hash->capacity; ++i) {
-								if (hash->index[i]->key.load(std::memory_order_relaxed) != ImplicitProducer::INVALID_BLOCK_BASE && hash->index[i]->value.load(std::memory_order_relaxed) != nullptr) {
-									++stats.allocatedBlocks;
-									++stats.ownedBlocksImplicit;
-								}
-							}
-							stats.implicitBlockIndexBytes += hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry);
-							for (; hash != nullptr; hash = hash->prev) {
-								stats.implicitBlockIndexBytes += sizeof(typename ImplicitProducer::BlockIndexHeader) + hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry*);
-							}
-						}
-						for (; details::circular_less_than<index_t>(head, tail); head += BLOCK_SIZE) {
-							//auto block = prod->get_block_index_entry_for_index(head);
-							++stats.usedBlocks;
-						}
-					}
-					else {
-						auto prod = static_cast<ExplicitProducer*>(ptr);
-						stats.queueClassBytes += sizeof(ExplicitProducer);
-						auto tailBlock = prod->tailBlock;
-						bool wasNonEmpty = false;
-						if (tailBlock != nullptr) {
-							auto block = tailBlock;
-							do {
-								++stats.allocatedBlocks;
-								if (!block->ConcurrentQueue::Block::template is_empty<explicit_context>() || wasNonEmpty) {
-									++stats.usedBlocks;
-									wasNonEmpty = wasNonEmpty || block != tailBlock;
-								}
-								++stats.ownedBlocksExplicit;
-								block = block->next;
-							} while (block != tailBlock);
-						}
-						auto index = prod->blockIndex.load(std::memory_order_relaxed);
-						while (index != nullptr) {
-							stats.explicitBlockIndexBytes += sizeof(typename ExplicitProducer::BlockIndexHeader) + index->size * sizeof(typename ExplicitProducer::BlockIndexEntry);
-							index = static_cast<typename ExplicitProducer::BlockIndexHeader*>(index->prev);
-						}
-					}
-				}
-
-				auto freeOnInitialPool = q->initialBlockPoolIndex.load(std::memory_order_relaxed) >= q->initialBlockPoolSize ? 0 : q->initialBlockPoolSize - q->initialBlockPoolIndex.load(std::memory_order_relaxed);
-				stats.allocatedBlocks += freeOnInitialPool;
-				stats.freeBlocks += freeOnInitialPool;
-
-				stats.blockClassBytes = sizeof(Block) * stats.allocatedBlocks;
-				stats.queueClassBytes += sizeof(ConcurrentQueue);
-
-				return stats;
-			}
-		};
-
-		// For debugging only. Not thread-safe.
-		MemStats getMemStats()
-		{
-			return MemStats::getFor(this);
-		}
-	private:
-		friend struct MemStats;
-#endif
-
-
-	//////////////////////////////////
-	// Producer list manipulation
-	//////////////////////////////////
-
-	ProducerBase* recycle_or_create_producer(bool isExplicit)
-	{
-		bool recycled;
-		return recycle_or_create_producer(isExplicit, recycled);
-	}
-
-	ProducerBase* recycle_or_create_producer(bool isExplicit, bool& recycled)
-	{
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-		// Try to re-use one first
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			if (ptr->inactive.load(std::memory_order_relaxed) && ptr->isExplicit == isExplicit) {
-				bool expected = true;
-				if (ptr->inactive.compare_exchange_strong(expected, /* desired */ false, std::memory_order_acquire, std::memory_order_relaxed)) {
-					// We caught one! It's been marked as activated, the caller can have it
-					recycled = true;
-					return ptr;
-				}
-			}
-		}
-
-		recycled = false;
-		return add_producer(isExplicit ? static_cast<ProducerBase*>(create<ExplicitProducer>(this)) : create<ImplicitProducer>(this));
-	}
-
-	ProducerBase* add_producer(ProducerBase* producer)
-	{
-		// Handle failed memory allocation
-		if (producer == nullptr) {
-			return nullptr;
-		}
-
-		producerCount.fetch_add(1, std::memory_order_relaxed);
-
-		// Add it to the lock-free list
-		auto prevTail = producerListTail.load(std::memory_order_relaxed);
-		do {
-			producer->next = prevTail;
-		} while (!producerListTail.compare_exchange_weak(prevTail, producer, std::memory_order_release, std::memory_order_relaxed));
-
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		if (producer->isExplicit) {
-			auto prevTailExplicit = explicitProducers.load(std::memory_order_relaxed);
-			do {
-				static_cast<ExplicitProducer*>(producer)->nextExplicitProducer = prevTailExplicit;
-			} while (!explicitProducers.compare_exchange_weak(prevTailExplicit, static_cast<ExplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
-		}
-		else {
-			auto prevTailImplicit = implicitProducers.load(std::memory_order_relaxed);
-			do {
-				static_cast<ImplicitProducer*>(producer)->nextImplicitProducer = prevTailImplicit;
-			} while (!implicitProducers.compare_exchange_weak(prevTailImplicit, static_cast<ImplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
-		}
-#endif
-
-		return producer;
-	}
-
-	void reown_producers()
-	{
-		// After another instance is moved-into/swapped-with this one, all the
-		// producers we stole still think their parents are the other queue.
-		// So fix them up!
-		for (auto ptr = producerListTail.load(std::memory_order_relaxed); ptr != nullptr; ptr = ptr->next_prod()) {
-			ptr->parent = this;
-		}
-	}
-
-
-	//////////////////////////////////
-	// Implicit producer hash
-	//////////////////////////////////
-
-	struct ImplicitProducerKVP
-	{
-		std::atomic<details::thread_id_t> key;
-		ImplicitProducer* value;		// No need for atomicity since it's only read by the thread that sets it in the first place
-
-		ImplicitProducerKVP() : value(nullptr) { }
-
-		ImplicitProducerKVP(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
-		{
-			key.store(other.key.load(std::memory_order_relaxed), std::memory_order_relaxed);
-			value = other.value;
-		}
-
-		inline ImplicitProducerKVP& operator=(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
-		{
-			swap(other);
-			return *this;
-		}
-
-		inline void swap(ImplicitProducerKVP& other) MOODYCAMEL_NOEXCEPT
-		{
-			if (this != &other) {
-				details::swap_relaxed(key, other.key);
-				std::swap(value, other.value);
-			}
-		}
-	};
-
-	template<typename XT, typename XTraits>
-	friend void duckdb_moodycamel::swap(typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&, typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&) MOODYCAMEL_NOEXCEPT;
-
-	struct ImplicitProducerHash
-	{
-		size_t capacity;
-		ImplicitProducerKVP* entries;
-		ImplicitProducerHash* prev;
-	};
-
-	inline void populate_initial_implicit_producer_hash()
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
-			return;
-		}
-		else {
-			implicitProducerHashCount.store(0, std::memory_order_relaxed);
-			auto hash = &initialImplicitProducerHash;
-			hash->capacity = INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
-			hash->entries = &initialImplicitProducerHashEntries[0];
-			for (size_t i = 0; i != INITIAL_IMPLICIT_PRODUCER_HASH_SIZE; ++i) {
-				initialImplicitProducerHashEntries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
-			}
-			hash->prev = nullptr;
-			implicitProducerHash.store(hash, std::memory_order_relaxed);
-		}
-	}
-
-	void swap_implicit_producer_hashes(ConcurrentQueue& other)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
-			return;
-		}
-		else {
-			// Swap (assumes our implicit producer hash is initialized)
-			initialImplicitProducerHashEntries.swap(other.initialImplicitProducerHashEntries);
-			initialImplicitProducerHash.entries = &initialImplicitProducerHashEntries[0];
-			other.initialImplicitProducerHash.entries = &other.initialImplicitProducerHashEntries[0];
-
-			details::swap_relaxed(implicitProducerHashCount, other.implicitProducerHashCount);
-
-			details::swap_relaxed(implicitProducerHash, other.implicitProducerHash);
-			if (implicitProducerHash.load(std::memory_order_relaxed) == &other.initialImplicitProducerHash) {
-				implicitProducerHash.store(&initialImplicitProducerHash, std::memory_order_relaxed);
-			}
-			else {
-				ImplicitProducerHash* hash;
-				for (hash = implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &other.initialImplicitProducerHash; hash = hash->prev) {
-					continue;
-				}
-				hash->prev = &initialImplicitProducerHash;
-			}
-			if (other.implicitProducerHash.load(std::memory_order_relaxed) == &initialImplicitProducerHash) {
-				other.implicitProducerHash.store(&other.initialImplicitProducerHash, std::memory_order_relaxed);
-			}
-			else {
-				ImplicitProducerHash* hash;
-				for (hash = other.implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &initialImplicitProducerHash; hash = hash->prev) {
-					continue;
-				}
-				hash->prev = &other.initialImplicitProducerHash;
-			}
-		}
-	}
-
-	// Only fails (returns nullptr) if memory allocation fails
-	ImplicitProducer* get_or_add_implicit_producer()
-	{
-		// Note that since the data is essentially thread-local (key is thread ID),
-		// there's a reduced need for fences (memory ordering is already consistent
-		// for any individual thread), except for the current table itself.
-
-		// Start by looking for the thread ID in the current and all previous hash tables.
-		// If it's not found, it must not be in there yet, since this same thread would
-		// have added it previously to one of the tables that we traversed.
-
-		// Code and algorithm adapted from http://preshing.com/20130605/the-worlds-simplest-lock-free-hash-table
-
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-
-		auto id = details::thread_id();
-		auto hashedId = details::hash_thread_id(id);
-
-		auto mainHash = implicitProducerHash.load(std::memory_order_acquire);
-		assert(mainHash != nullptr);  // silence clang-tidy and MSVC warnings (hash cannot be null)
-		for (auto hash = mainHash; hash != nullptr; hash = hash->prev) {
-			// Look for the id in this hash
-			auto index = hashedId;
-			while (true) {		// Not an infinite loop because at least one slot is free in the hash table
-				index &= hash->capacity - 1;
-
-				auto probedKey = hash->entries[index].key.load(std::memory_order_relaxed);
-				if (probedKey == id) {
-					// Found it! If we had to search several hashes deep, though, we should lazily add it
-					// to the current main hash table to avoid the extended search next time.
-					// Note there's guaranteed to be room in the current hash table since every subsequent
-					// table implicitly reserves space for all previous tables (there's only one
-					// implicitProducerHashCount).
-					auto value = hash->entries[index].value;
-					if (hash != mainHash) {
-						index = hashedId;
-						while (true) {
-							index &= mainHash->capacity - 1;
-							probedKey = mainHash->entries[index].key.load(std::memory_order_relaxed);
-							auto empty = details::invalid_thread_id;
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-							auto reusable = details::invalid_thread_id2;
-							if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed)) ||
-								(probedKey == reusable && mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_acquire, std::memory_order_acquire))) {
-#else
-							if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed))) {
-#endif
-								mainHash->entries[index].value = value;
-								break;
-							}
-							++index;
-						}
-					}
-
-					return value;
-				}
-				if (probedKey == details::invalid_thread_id) {
-					break;		// Not in this hash table
-				}
-				++index;
-			}
-		}
-
-		// Insert!
-		auto newCount = 1 + implicitProducerHashCount.fetch_add(1, std::memory_order_relaxed);
-		while (true) {
-			// NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
-			if (newCount >= (mainHash->capacity >> 1) && !implicitProducerHashResizeInProgress.test_and_set(std::memory_order_acquire)) {
-				// We've acquired the resize lock, try to allocate a bigger hash table.
-				// Note the acquire fence synchronizes with the release fence at the end of this block, and hence when
-				// we reload implicitProducerHash it must be the most recent version (it only gets changed within this
-				// locked block).
-				mainHash = implicitProducerHash.load(std::memory_order_acquire);
-				if (newCount >= (mainHash->capacity >> 1)) {
-					auto newCapacity = mainHash->capacity << 1;
-					while (newCount >= (newCapacity >> 1)) {
-						newCapacity <<= 1;
-					}
-					auto raw = static_cast<char*>((Traits::malloc)(sizeof(ImplicitProducerHash) + std::alignment_of<ImplicitProducerKVP>::value - 1 + sizeof(ImplicitProducerKVP) * newCapacity));
-					if (raw == nullptr) {
-						// Allocation failed
-						implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
-						implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-						return nullptr;
-					}
-
-					auto newHash = new (raw) ImplicitProducerHash;
-					newHash->capacity = newCapacity;
-					newHash->entries = reinterpret_cast<ImplicitProducerKVP*>(details::align_for<ImplicitProducerKVP>(raw + sizeof(ImplicitProducerHash)));
-					for (size_t i = 0; i != newCapacity; ++i) {
-						new (newHash->entries + i) ImplicitProducerKVP;
-						newHash->entries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
-					}
-					newHash->prev = mainHash;
-					implicitProducerHash.store(newHash, std::memory_order_release);
-					implicitProducerHashResizeInProgress.clear(std::memory_order_release);
-					mainHash = newHash;
-				}
-				else {
-					implicitProducerHashResizeInProgress.clear(std::memory_order_release);
-				}
-			}
-
-			// If it's < three-quarters full, add to the old one anyway so that we don't have to wait for the next table
-			// to finish being allocated by another thread (and if we just finished allocating above, the condition will
-			// always be true)
-			if (newCount < (mainHash->capacity >> 1) + (mainHash->capacity >> 2)) {
-				bool recycled;
-				auto producer = static_cast<ImplicitProducer*>(recycle_or_create_producer(false, recycled));
-				if (producer == nullptr) {
-					implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
-					return nullptr;
-				}
-				if (recycled) {
-					implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
-				}
-
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-				producer->threadExitListener.callback = &ConcurrentQueue::implicit_producer_thread_exited_callback;
-				producer->threadExitListener.userData = producer;
-				details::ThreadExitNotifier::subscribe(&producer->threadExitListener);
-#endif
-
-				auto index = hashedId;
-				while (true) {
-					index &= mainHash->capacity - 1;
-					auto probedKey = mainHash->entries[index].key.load(std::memory_order_relaxed);
-
-					auto empty = details::invalid_thread_id;
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-					auto reusable = details::invalid_thread_id2;
-					if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed)) ||
-						(probedKey == reusable && mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_acquire, std::memory_order_acquire))) {
-#else
-					if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed))) {
-#endif
-						mainHash->entries[index].value = producer;
-						break;
-					}
-					++index;
-				}
-				return producer;
-			}
-
-			// Hmm, the old hash is quite full and somebody else is busy allocating a new one.
-			// We need to wait for the allocating thread to finish (if it succeeds, we add, if not,
-			// we try to allocate ourselves).
-			mainHash = implicitProducerHash.load(std::memory_order_acquire);
-		}
-	}
-
-#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-	void implicit_producer_thread_exited(ImplicitProducer* producer)
-	{
-		// Remove from thread exit listeners
-		details::ThreadExitNotifier::unsubscribe(&producer->threadExitListener);
-
-		// Remove from hash
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-		auto hash = implicitProducerHash.load(std::memory_order_acquire);
-		assert(hash != nullptr);		// The thread exit listener is only registered if we were added to a hash in the first place
-		auto id = details::thread_id();
-		auto hashedId = details::hash_thread_id(id);
-		details::thread_id_t probedKey;
-
-		// We need to traverse all the hashes just in case other threads aren't on the current one yet and are
-		// trying to add an entry thinking there's a free slot (because they reused a producer)
-		for (; hash != nullptr; hash = hash->prev) {
-			auto index = hashedId;
-			do {
-				index &= hash->capacity - 1;
-				probedKey = hash->entries[index].key.load(std::memory_order_relaxed);
-				if (probedKey == id) {
-					hash->entries[index].key.store(details::invalid_thread_id2, std::memory_order_release);
-					break;
-				}
-				++index;
-			} while (probedKey != details::invalid_thread_id);		// Can happen if the hash has changed but we weren't put back in it yet, or if we weren't added to this hash in the first place
-		}
-
-		// Mark the queue as being recyclable
-		producer->inactive.store(true, std::memory_order_release);
-	}
-
-	static void implicit_producer_thread_exited_callback(void* userData)
-	{
-		auto producer = static_cast<ImplicitProducer*>(userData);
-		auto queue = producer->parent;
-		queue->implicit_producer_thread_exited(producer);
-	}
-#endif
-
-	//////////////////////////////////
-	// Utility functions
-	//////////////////////////////////
-
-	template<typename TAlign>
-	static inline void* aligned_malloc(size_t size)
-	{
-		if (std::alignment_of<TAlign>::value <= std::alignment_of<details::max_align_t>::value)
-			return (Traits::malloc)(size);
-		size_t alignment = std::alignment_of<TAlign>::value;
-		void* raw = (Traits::malloc)(size + alignment - 1 + sizeof(void*));
-		if (!raw)
-			return nullptr;
-		char* ptr = details::align_for<TAlign>(reinterpret_cast<char*>(raw) + sizeof(void*));
-		*(reinterpret_cast<void**>(ptr) - 1) = raw;
-		return ptr;
-	}
-
-	template<typename TAlign>
-	static inline void aligned_free(void* ptr)
-	{
-		if (std::alignment_of<TAlign>::value <= std::alignment_of<details::max_align_t>::value)
-			return (Traits::free)(ptr);
-		(Traits::free)(ptr ? *(reinterpret_cast<void**>(ptr) - 1) : nullptr);
-	}
-
-	template<typename U>
-	static inline U* create_array(size_t count)
-	{
-		assert(count > 0);
-		U* p = static_cast<U*>(aligned_malloc<U>(sizeof(U) * count));
-		if (p == nullptr)
-			return nullptr;
-
-		for (size_t i = 0; i != count; ++i)
-			new (p + i) U();
-		return p;
-	}
-
-	template<typename U>
-	static inline void destroy_array(U* p, size_t count)
-	{
-		if (p != nullptr) {
-			assert(count > 0);
-			for (size_t i = count; i != 0; )
-				(p + --i)->~U();
-		}
-		aligned_free<U>(p);
-	}
-
-	template<typename U>
-	static inline U* create()
-	{
-		void* p = aligned_malloc<U>(sizeof(U));
-		return p != nullptr ? new (p) U : nullptr;
-	}
-
-	template<typename U, typename A1>
-	static inline U* create(A1&& a1)
-	{
-		void* p = aligned_malloc<U>(sizeof(U));
-		return p != nullptr ? new (p) U(std::forward<A1>(a1)) : nullptr;
-	}
-
-	template<typename U>
-	static inline void destroy(U* p)
-	{
-		if (p != nullptr)
-			p->~U();
-		aligned_free<U>(p);
-	}
-
-private:
-	std::atomic<ProducerBase*> producerListTail;
-	std::atomic<std::uint32_t> producerCount;
-
-	std::atomic<size_t> initialBlockPoolIndex;
-	Block* initialBlockPool;
-	size_t initialBlockPoolSize;
-
-#ifndef MCDBGQ_USEDEBUGFREELIST
-	FreeList<Block> freeList;
-#else
-	debug::DebugFreeList<Block> freeList;
-#endif
-
-	std::atomic<ImplicitProducerHash*> implicitProducerHash;
-	std::atomic<size_t> implicitProducerHashCount;		// Number of slots logically used
-	ImplicitProducerHash initialImplicitProducerHash;
-	std::array<ImplicitProducerKVP, INITIAL_IMPLICIT_PRODUCER_HASH_SIZE> initialImplicitProducerHashEntries;
-	std::atomic_flag implicitProducerHashResizeInProgress;
-
-	std::atomic<std::uint32_t> nextExplicitConsumerId;
-	std::atomic<std::uint32_t> globalExplicitConsumerOffset;
-
-#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-	debug::DebugMutex implicitProdMutex;
-#endif
-
-#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	std::atomic<ExplicitProducer*> explicitProducers;
-	std::atomic<ImplicitProducer*> implicitProducers;
-#endif
-};
-
-
-template<typename T, typename Traits>
-ProducerToken::ProducerToken(ConcurrentQueue<T, Traits>& queue)
-	: producer(queue.recycle_or_create_producer(true))
-{
-	if (producer != nullptr) {
-		producer->token = this;
-	}
-}
-
-template<typename T, typename Traits>
-ProducerToken::ProducerToken(BlockingConcurrentQueue<T, Traits>& queue)
-	: producer(reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->recycle_or_create_producer(true))
-{
-	if (producer != nullptr) {
-		producer->token = this;
-	}
-}
-
-template<typename T, typename Traits>
-ConsumerToken::ConsumerToken(ConcurrentQueue<T, Traits>& queue)
-	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
-{
-	initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = -1;
-}
-
-template<typename T, typename Traits>
-ConsumerToken::ConsumerToken(BlockingConcurrentQueue<T, Traits>& queue)
-	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
-{
-	initialOffset = reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = -1;
-}
-
-template<typename T, typename Traits>
-inline void swap(ConcurrentQueue<T, Traits>& a, ConcurrentQueue<T, Traits>& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-inline void swap(ProducerToken& a, ProducerToken& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-inline void swap(ConsumerToken& a, ConsumerToken& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-template<typename T, typename Traits>
-inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& a, typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& b) MOODYCAMEL_NOEXCEPT
-{
-	a.swap(b);
-}
-
-}
-
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #10
-// See the end of this file for a list
-
-// Provides an efficient implementation of a semaphore (LightweightSemaphore).
-// This is an extension of Jeff Preshing's sempahore implementation (licensed
-// under the terms of its separate zlib license) that has been adapted and
-// extended by Cameron Desrochers.
-
-
-
-#include <cstddef> // For std::size_t
-#include <atomic>
-#include <type_traits> // For std::make_signed<T>
-
-#if defined(_WIN32)
-// Avoid including windows.h in a header; we only need a handful of
-// items, so we'll redeclare them here (this is relatively safe since
-// the API generally has to remain stable between Windows versions).
-// I know this is an ugly hack but it still beats polluting the global
-// namespace with thousands of generic names or adding a .cpp for nothing.
-extern "C" {
-	struct _SECURITY_ATTRIBUTES;
-	__declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES* lpSemaphoreAttributes, long lInitialCount, long lMaximumCount, const wchar_t* lpName);
-	__declspec(dllimport) int __stdcall CloseHandle(void* hObject);
-	__declspec(dllimport) unsigned long __stdcall WaitForSingleObject(void* hHandle, unsigned long dwMilliseconds);
-	__declspec(dllimport) int __stdcall ReleaseSemaphore(void* hSemaphore, long lReleaseCount, long* lpPreviousCount);
-}
-#elif defined(__MACH__)
-#include <mach/mach.h>
-#elif defined(__unix__)
-#include <semaphore.h>
-#include <chrono>
-#endif
-
-namespace duckdb_moodycamel
-{
-namespace details
-{
-
-// Code in the mpmc_sema namespace below is an adaptation of Jeff Preshing's
-// portable + lightweight semaphore implementations, originally from
-// https://github.com/preshing/cpp11-on-multicore/blob/master/common/sema.h
-// LICENSE:
-// Copyright (c) 2015 Jeff Preshing
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//	claim that you wrote the original software. If you use this software
-//	in a product, an acknowledgement in the product documentation would be
-//	appreciated but is not required.
-// 2. Altered source versions must be plainly marked as such, and must not be
-//	misrepresented as being the original software.
-// 3. This notice may not be removed or altered from any source distribution.
-#if defined(_WIN32)
-class Semaphore
-{
-private:
-	void* m_hSema;
-
-	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-
-public:
-	Semaphore(int initialCount = 0)
-	{
-		assert(initialCount >= 0);
-		const long maxLong = 0x7fffffff;
-		m_hSema = CreateSemaphoreW(nullptr, initialCount, maxLong, nullptr);
-		assert(m_hSema);
-	}
-
-	~Semaphore()
-	{
-		CloseHandle(m_hSema);
-	}
-
-	bool wait()
-	{
-		const unsigned long infinite = 0xffffffff;
-		return WaitForSingleObject(m_hSema, infinite) == 0;
-	}
-
-	bool try_wait()
-	{
-		return WaitForSingleObject(m_hSema, 0) == 0;
-	}
-
-	bool timed_wait(std::uint64_t usecs)
-	{
-		return WaitForSingleObject(m_hSema, (unsigned long)(usecs / 1000)) == 0;
-	}
-
-	void signal(int count = 1)
-	{
-		while (!ReleaseSemaphore(m_hSema, count, nullptr));
-	}
-};
-#elif defined(__MACH__)
-//---------------------------------------------------------
-// Semaphore (Apple iOS and OSX)
-// Can't use POSIX semaphores due to http://lists.apple.com/archives/darwin-kernel/2009/Apr/msg00010.html
-//---------------------------------------------------------
-class Semaphore
-{
-private:
-	semaphore_t m_sema;
-
-	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-
-public:
-	Semaphore(int initialCount = 0)
-	{
-		assert(initialCount >= 0);
-		kern_return_t rc = semaphore_create(mach_task_self(), &m_sema, SYNC_POLICY_FIFO, initialCount);
-		assert(rc == KERN_SUCCESS);
-		(void)rc;
-	}
-
-	~Semaphore()
-	{
-		semaphore_destroy(mach_task_self(), m_sema);
-	}
-
-	bool wait()
-	{
-		return semaphore_wait(m_sema) == KERN_SUCCESS;
-	}
-
-	bool try_wait()
-	{
-		return timed_wait(0);
-	}
-
-	bool timed_wait(std::uint64_t timeout_usecs)
-	{
-		mach_timespec_t ts;
-		ts.tv_sec = static_cast<unsigned int>(timeout_usecs / 1000000);
-		ts.tv_nsec = (timeout_usecs % 1000000) * 1000;
-
-		// added in OSX 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/modules/Darwin.html
-		kern_return_t rc = semaphore_timedwait(m_sema, ts);
-		return rc == KERN_SUCCESS;
-	}
-
-	void signal()
-	{
-		while (semaphore_signal(m_sema) != KERN_SUCCESS);
-	}
-
-	void signal(int count)
-	{
-		while (count-- > 0)
-		{
-			while (semaphore_signal(m_sema) != KERN_SUCCESS);
-		}
-	}
-};
-#elif defined(__unix__)
-//---------------------------------------------------------
-// Semaphore (POSIX, Linux)
-//---------------------------------------------------------
-class Semaphore
-{
-private:
-	sem_t m_sema;
-
-	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-
-public:
-	Semaphore(int initialCount = 0)
-	{
-		assert(initialCount >= 0);
-		int rc = sem_init(&m_sema, 0, initialCount);
-		assert(rc == 0);
-		(void)rc;
-	}
-
-	~Semaphore()
-	{
-		sem_destroy(&m_sema);
-	}
-
-	bool wait()
-	{
-		// http://stackoverflow.com/questions/2013181/gdb-causes-sem-wait-to-fail-with-eintr-error
-		int rc;
-		do {
-			rc = sem_wait(&m_sema);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	bool try_wait()
-	{
-		int rc;
-		do {
-			rc = sem_trywait(&m_sema);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	bool timed_wait(std::uint64_t usecs)
-	{
-		struct timespec ts;
-		const int usecs_in_1_sec = 1000000;
-		const int nsecs_in_1_sec = 1000000000;
-
-		// sem_timedwait needs an absolute time
-		// hence we need to first obtain the current time
-		// and then add the maximum time we want to wait
-		// we want to avoid clock_gettime because of linking issues
-		// chrono -> timespec conversion from here: https://embeddedartistry.com/blog/2019/01/31/converting-between-timespec-stdchrono/
-		auto current_time = std::chrono::system_clock::now();
-		auto secs =  std::chrono::time_point_cast<std::chrono::seconds>(current_time);
-		auto ns = std::chrono::time_point_cast<std::chrono::nanoseconds>(current_time) - std::chrono::time_point_cast<std::chrono::nanoseconds>(secs);
-
-		ts.tv_sec = secs.time_since_epoch().count();
-		ts.tv_nsec = ns.count();
-
-		// now add the time we want to wait
-		ts.tv_sec += usecs / usecs_in_1_sec;
-		ts.tv_nsec += (usecs % usecs_in_1_sec) * 1000;
-
-		// sem_timedwait bombs if you have more than 1e9 in tv_nsec
-		// so we have to clean things up before passing it in
-		if (ts.tv_nsec >= nsecs_in_1_sec) {
-			ts.tv_nsec -= nsecs_in_1_sec;
-			++ts.tv_sec;
-		}
-
-		int rc;
-		do {
-			rc = sem_timedwait(&m_sema, &ts);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	void signal()
-	{
-		while (sem_post(&m_sema) == -1);
-	}
-
-	void signal(int count)
-	{
-		while (count-- > 0)
-		{
-			while (sem_post(&m_sema) == -1);
-		}
-	}
-};
-#else
-#error Unsupported platform! (No semaphore wrapper available)
-#endif
-
-}	// end namespace details
-
-
-//---------------------------------------------------------
-// LightweightSemaphore
-//---------------------------------------------------------
-class LightweightSemaphore
-{
-public:
-	typedef std::make_signed<std::size_t>::type ssize_t;
-
-private:
-	std::atomic<ssize_t> m_count;
-	details::Semaphore m_sema;
-
-	bool waitWithPartialSpinning(std::int64_t timeout_usecs = -1)
-	{
-		ssize_t oldCount;
-		// Is there a better way to set the initial spin count?
-		// If we lower it to 1000, testBenaphore becomes 15x slower on my Core i7-5930K Windows PC,
-		// as threads start hitting the kernel semaphore.
-		int spin = 10000;
-		while (--spin >= 0)
-		{
-			oldCount = m_count.load(std::memory_order_relaxed);
-			if ((oldCount > 0) && m_count.compare_exchange_strong(oldCount, oldCount - 1, std::memory_order_acquire, std::memory_order_relaxed))
-				return true;
-			std::atomic_signal_fence(std::memory_order_acquire);	 // Prevent the compiler from collapsing the loop.
-		}
-		oldCount = m_count.fetch_sub(1, std::memory_order_acquire);
-		if (oldCount > 0)
-			return true;
-		if (timeout_usecs < 0)
-			return m_sema.wait();
-		if (m_sema.timed_wait((std::uint64_t)timeout_usecs))
-			return true;
-		// At this point, we've timed out waiting for the semaphore, but the
-		// count is still decremented indicating we may still be waiting on
-		// it. So we have to re-adjust the count, but only if the semaphore
-		// wasn't signaled enough times for us too since then. If it was, we
-		// need to release the semaphore too.
-		while (true)
-		{
-			oldCount = m_count.load(std::memory_order_acquire);
-			if (oldCount >= 0 && m_sema.try_wait())
-				return true;
-			if (oldCount < 0 && m_count.compare_exchange_strong(oldCount, oldCount + 1, std::memory_order_relaxed, std::memory_order_relaxed))
-				return false;
-		}
-	}
-
-	ssize_t waitManyWithPartialSpinning(ssize_t max, std::int64_t timeout_usecs = -1)
-	{
-		assert(max > 0);
-		ssize_t oldCount;
-		int spin = 10000;
-		while (--spin >= 0)
-		{
-			oldCount = m_count.load(std::memory_order_relaxed);
-			if (oldCount > 0)
-			{
-				ssize_t newCount = oldCount > max ? oldCount - max : 0;
-				if (m_count.compare_exchange_strong(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
-					return oldCount - newCount;
-			}
-			std::atomic_signal_fence(std::memory_order_acquire);
-		}
-		oldCount = m_count.fetch_sub(1, std::memory_order_acquire);
-		if (oldCount <= 0)
-		{
-			if (timeout_usecs < 0)
-			{
-				if (!m_sema.wait())
-					return 0;
-			}
-			else if (!m_sema.timed_wait((std::uint64_t)timeout_usecs))
-			{
-				while (true)
-				{
-					oldCount = m_count.load(std::memory_order_acquire);
-					if (oldCount >= 0 && m_sema.try_wait())
-						break;
-					if (oldCount < 0 && m_count.compare_exchange_strong(oldCount, oldCount + 1, std::memory_order_relaxed, std::memory_order_relaxed))
-						return 0;
-				}
-			}
-		}
-		if (max > 1)
-			return 1 + tryWaitMany(max - 1);
-		return 1;
-	}
-
-public:
-	LightweightSemaphore(ssize_t initialCount = 0) : m_count(initialCount)
-	{
-		assert(initialCount >= 0);
-	}
-
-	bool tryWait()
-	{
-		ssize_t oldCount = m_count.load(std::memory_order_relaxed);
-		while (oldCount > 0)
-		{
-			if (m_count.compare_exchange_weak(oldCount, oldCount - 1, std::memory_order_acquire, std::memory_order_relaxed))
-				return true;
-		}
-		return false;
-	}
-
-	bool wait()
-	{
-		return tryWait() || waitWithPartialSpinning();
-	}
-
-	bool wait(std::int64_t timeout_usecs)
-	{
-		return tryWait() || waitWithPartialSpinning(timeout_usecs);
-	}
-
-	// Acquires between 0 and (greedily) max, inclusive
-	ssize_t tryWaitMany(ssize_t max)
-	{
-		assert(max >= 0);
-		ssize_t oldCount = m_count.load(std::memory_order_relaxed);
-		while (oldCount > 0)
-		{
-			ssize_t newCount = oldCount > max ? oldCount - max : 0;
-			if (m_count.compare_exchange_weak(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
-				return oldCount - newCount;
-		}
-		return 0;
-	}
-
-	// Acquires at least one, and (greedily) at most max
-	ssize_t waitMany(ssize_t max, std::int64_t timeout_usecs)
-	{
-		assert(max >= 0);
-		ssize_t result = tryWaitMany(max);
-		if (result == 0 && max > 0)
-			result = waitManyWithPartialSpinning(max, timeout_usecs);
-		return result;
-	}
-
-	ssize_t waitMany(ssize_t max)
-	{
-		ssize_t result = waitMany(max, -1);
-		assert(result > 0);
-		return result;
-	}
-
-	void signal(ssize_t count = 1)
-	{
-		assert(count >= 0);
-		ssize_t oldCount = m_count.fetch_add(count, std::memory_order_release);
-		ssize_t toRelease = -oldCount < count ? -oldCount : count;
-		if (toRelease > 0)
-		{
-			m_sema.signal((int)toRelease);
-		}
-	}
-
-	ssize_t availableApprox() const
-	{
-		ssize_t count = m_count.load(std::memory_order_relaxed);
-		return count > 0 ? count : 0;
-	}
-};
-
-}   // end namespace duckdb_moodycamel
-
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node/recursive_cte_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class RecursiveCTENode : public QueryNode {
-public:
-	RecursiveCTENode() : QueryNode(QueryNodeType::RECURSIVE_CTE_NODE) {
-	}
-
-	string ctename;
-	bool union_all;
-	//! The left side of the set operation
-	unique_ptr<QueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<QueryNode> right;
-	//! Aliases of the recursive CTE node
-	vector<string> aliases;
-
-	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		return left->GetSelectList();
-	}
-
-public:
-	//! Convert the query node to a string
-	string ToString() const override;
-
-	bool Equals(const QueryNode *other) const override;
-	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() const override;
-
-	//! Serializes a QueryNode to a stand-alone binary blob
-	void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a blob back into a QueryNode
-	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/transformer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-// this is a bit of a mess from c.h, port.h and some others. Upside is it makes the parser compile with minimal
-// dependencies.
-
-
-
-#include <limits.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string>
-
-#ifdef ERROR
-#undef ERROR
-#endif
-
-typedef uintptr_t PGDatum;
-typedef uint64_t PGSize;
-
-typedef uint32_t PGIndex;
-typedef uint32_t PGOid;
-
-#define InvalidOid ((PGOid)0)
-
-#ifndef _MSC_VER
-#include <assert.h>
-#define Assert(a) assert(a);
-#define AssertMacro(p) ((void)assert(p))
-#else
-#define Assert(a) (a);
-#define AssertMacro(p) ((void)(p))
-#endif
-#define _(a) (a)
-
-#define lengthof(array) (sizeof(array) / sizeof((array)[0]))
-#define CppConcat(x, y) x##y
-
-#define HIGHBIT (0x80)
-#define IS_HIGHBIT_SET(ch) ((unsigned char)(ch)&HIGHBIT)
-
-#define FUNC_MAX_ARGS 100
-#define FLEXIBLE_ARRAY_MEMBER
-
-#define DEFAULT_INDEX_TYPE "art"
-#define INTERVAL_MASK(b) (1 << (b))
-
-#ifdef _MSC_VER
-#define __thread __declspec(thread)
-#endif
-
-
-//typedef struct {
-//	int32_t vl_len_;    /* these fields must match ArrayType! */
-//	int ndim;         /* always 1 for PGint2vector */
-//	int32_t dataoffset; /* always 0 for PGint2vector */
-//	PGOid elemtype;
-//	int dim1;
-//	int lbound1;
-//	int16_t values[];
-//} PGint2vector;
-
-struct pg_varlena {
-	char vl_len_[4];                    /* Do not touch this field directly! */
-	char vl_dat[1]; /* Data content is here */
-};
-
-typedef struct pg_varlena bytea;
-
-typedef int PGMemoryContext;
-
-namespace duckdb_libpgquery {
-
-typedef enum PGPostgresParserErrors {
-	PG_ERRCODE_SYNTAX_ERROR,
-	PG_ERRCODE_FEATURE_NOT_SUPPORTED,
-	PG_ERRCODE_INVALID_PARAMETER_VALUE,
-	PG_ERRCODE_WINDOWING_ERROR,
-	PG_ERRCODE_RESERVED_NAME,
-	PG_ERRCODE_INVALID_ESCAPE_SEQUENCE,
-	PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER,
-	ERRCODE_NAME_TOO_LONG
-} PGPostgresParserErrors;
-
-typedef enum PGPostgresRelPersistence {
-	PG_RELPERSISTENCE_TEMP,
-	PG_RELPERSISTENCE_UNLOGGED,
-	RELPERSISTENCE_PERMANENT
-} PGPostgresRelPersistence;
-
-typedef enum PGPostgresErrorLevel {
-	PGUNDEFINED,
-	PGNOTICE,
-	PGWARNING,
-	ERROR
-} PGPostgresErrorLevel;
-
-typedef enum PGPostgresAttributIdentityTypes {
-	PG_ATTRIBUTE_IDENTITY_ALWAYS,
-	ATTRIBUTE_IDENTITY_BY_DEFAULT
-} PGPostgresAttributIdentityTypes;
-
-}
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * parsenodes.h
- *	  definitions for parse tree nodes
- *
- * Many of the node types used in parsetrees include a "location" field.
- * This is a byte (not character) offset in the original source text, to be
- * used for positioning an error cursor when there is an error related to
- * the node.  Access to the original source text is needed to make use of
- * the location.  At the topmost (statement) level, we also provide a
- * statement length, likewise measured in bytes, for convenience in
- * identifying statement boundaries in multi-statement source strings.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/parsenodes.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * bitmapset.h
- *	  PostgreSQL generic bitmap set package
- *
- * A bitmap set can represent any set of nonnegative integers, although
- * it is mainly intended for sets where the maximum value is not large,
- * say at most a few hundred.  By convention, a NULL pointer is always
- * accepted by all operations to represent the empty set.  (But beware
- * that this is not the only representation of the empty set.  Use
- * bms_is_empty() in preference to testing for NULL.)
- *
- *
- * Copyright (c) 2003-2017, PostgreSQL Global Development PGGroup
- *
- * src/include/nodes/bitmapset.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-#include <cstdint>
-
-namespace duckdb_libpgquery {
-
-/*
- * Forward decl to save including pg_list.h
- */
-struct PGList;
-
-/*
- * Data representation
- */
-
-/* The unit size can be adjusted by changing these three declarations: */
-#define BITS_PER_BITMAPWORD 32
-typedef uint32_t bitmapword;      /* must be an unsigned type */
-typedef int32_t signedbitmapword; /* must be the matching signed type */
-
-typedef struct PGBitmapset {
-	int nwords;          /* number of words in array */
-	bitmapword words[1]; /* really [nwords] */
-} PGBitmapset;
-
-/* result of bms_subset_compare */
-typedef enum PG_BMS_Comparison {
-	PG_BMS_EQUAL,   /* sets are equal */
-	PG_BMS_SUBSET1, /* first set is a subset of the second */
-	PG_BMS_SUBSET2, /* second set is a subset of the first */
-	BMS_DIFFERENT   /* neither set is a subset of the other */
-} PG_BMS_Comparison;
-
-/* result of bms_membership */
-typedef enum PG_BMS_Membership {
-	PG_BMS_EMPTY_SET, /* 0 members */
-	PG_BMS_SINGLETON, /* 1 member */
-	BMS_MULTIPLE      /* >1 member */
-} PG_BMS_Membership;
-
-/*
- * function prototypes in nodes/bitmapset.c
- */
-
-PGBitmapset *bms_copy(const PGBitmapset *a);
-bool bms_equal(const PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_make_singleton(int x);
-void bms_free(PGBitmapset *a);
-
-PGBitmapset *bms_union(const PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_intersect(const PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_difference(const PGBitmapset *a, const PGBitmapset *b);
-bool bms_is_subset(const PGBitmapset *a, const PGBitmapset *b);
-PG_BMS_Comparison bms_subset_compare(const PGBitmapset *a, const PGBitmapset *b);
-bool bms_is_member(int x, const PGBitmapset *a);
-bool bms_overlap(const PGBitmapset *a, const PGBitmapset *b);
-bool bms_overlap_list(const PGBitmapset *a, const struct PGList *b);
-bool bms_nonempty_difference(const PGBitmapset *a, const PGBitmapset *b);
-int bms_singleton_member(const PGBitmapset *a);
-bool bms_get_singleton_member(const PGBitmapset *a, int *member);
-int bms_num_members(const PGBitmapset *a);
-
-/* optimized tests when we don't need to know exact membership count: */
-PG_BMS_Membership bms_membership(const PGBitmapset *a);
-bool bms_is_empty(const PGBitmapset *a);
-
-/* these routines recycle (modify or free) their non-const inputs: */
-
-PGBitmapset *bms_add_member(PGBitmapset *a, int x);
-PGBitmapset *bms_del_member(PGBitmapset *a, int x);
-PGBitmapset *bms_add_members(PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_int_members(PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_del_members(PGBitmapset *a, const PGBitmapset *b);
-PGBitmapset *bms_join(PGBitmapset *a, PGBitmapset *b);
-
-/* support for iterating through the integer elements of a set: */
-int bms_first_member(PGBitmapset *a);
-int bms_next_member(const PGBitmapset *a, int prevbit);
-
-/* support for hashtables using Bitmapsets as keys: */
-uint32_t bms_hash_value(const PGBitmapset *a);
-
-}
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * lockoptions.h
- *	  Common header for some locking-related declarations.
- *
- *
- * Copyright (c) 2014-2017, PostgreSQL Global Development PGGroup
- *
- * src/include/nodes/lockoptions.h
- *
- *-------------------------------------------------------------------------
- */
-
-namespace duckdb_libpgquery {
-
-/*
- * This enum represents the different strengths of FOR UPDATE/SHARE clauses.
- * The ordering here is important, because the highest numerical value takes
- * precedence when a RTE is specified multiple ways.  See applyLockingClause.
- */
-typedef enum PGLockClauseStrength {
-	PG_LCS_NONE,           /* no such clause - only used in PGPlanRowMark */
-	PG_LCS_FORKEYSHARE,    /* FOR KEY SHARE */
-	PG_LCS_FORSHARE,       /* FOR SHARE */
-	PG_LCS_FORNOKEYUPDATE, /* FOR NO KEY UPDATE */
-	LCS_FORUPDATE          /* FOR UPDATE */
-} PGLockClauseStrength;
-
-/*
- * This enum controls how to deal with rows being locked by FOR UPDATE/SHARE
- * clauses (i.e., it represents the NOWAIT and SKIP LOCKED options).
- * The ordering here is important, because the highest numerical value takes
- * precedence when a RTE is specified multiple ways.  See applyLockingClause.
- */
-typedef enum PGLockWaitPolicy {
-	/* Wait for the lock to become available (default behavior) */
-	PGLockWaitBlock,
-	/* Skip rows that can't be locked (SKIP LOCKED) */
-	PGLockWaitSkip,
-	/* Raise an error if a row cannot be locked (NOWAIT) */
-	LockWaitError
-} PGLockWaitPolicy;
-
-}
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * primnodes.h
- *	  Definitions for "primitive" node types, those that are used in more
- *	  than one of the parse/plan/execute stages of the query pipeline.
- *	  Currently, these are mostly nodes for executable expressions
- *	  and join trees.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/primnodes.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * attnum.h
- *	  POSTGRES attribute number definitions.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/access/attnum.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-#include <cstdint>
-
-/*
- * user defined attribute numbers start at 1.   -ay 2/95
- */
-typedef int16_t PGAttrNumber;
-
-#define InvalidAttrNumber		0
-#define MaxAttrNumber			32767
-
-/* ----------------
- *		support macros
- * ----------------
- */
-/*
- * AttributeNumberIsValid
- *		True iff the attribute number is valid.
- */
-#define AttributeNumberIsValid(attributeNumber) \
-	((bool) ((attributeNumber) != InvalidAttrNumber))
-
-/*
- * AttrNumberIsForUserDefinedAttr
- *		True iff the attribute number corresponds to an user defined attribute.
- */
-#define AttrNumberIsForUserDefinedAttr(attributeNumber) \
-	((bool) ((attributeNumber) > 0))
-
-/*
- * AttrNumberGetAttrOffset
- *		Returns the attribute offset for an attribute number.
- *
- * Note:
- *		Assumes the attribute number is for a user defined attribute.
- */
-#define AttrNumberGetAttrOffset(attNum) \
-( \
-	AssertMacro(AttrNumberIsForUserDefinedAttr(attNum)), \
-	((attNum) - 1) \
-)
-
-/*
- * AttributeOffsetGetAttributeNumber
- *		Returns the attribute number for an attribute offset.
- */
-#define AttrOffsetGetAttrNumber(attributeOffset) \
-	 ((PGAttrNumber) (1 + (attributeOffset)))
-
-
-// LICENSE_CHANGE_END
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * pg_list.h
- *	  interface for PostgreSQL generic linked list package
- *
- * This package implements singly-linked homogeneous lists.
- *
- * It is important to have constant-time length, append, and prepend
- * operations. To achieve this, we deal with two distinct data
- * structures:
- *
- *		1. A set of "list cells": each cell contains a data field and
- *		   a link to the next cell in the list or NULL.
- *		2. A single structure containing metadata about the list: the
- *		   type of the list, pointers to the head and tail cells, and
- *		   the length of the list.
- *
- * We support three types of lists:
- *
- *	duckdb_libpgquery::T_PGList: lists of pointers
- *		(in practice usually pointers to Nodes, but not always;
- *		declared as "void *" to minimize casting annoyances)
- *	duckdb_libpgquery::T_PGIntList: lists of integers
- *	duckdb_libpgquery::T_PGOidList: lists of Oids
- *
- * (At the moment, ints and Oids are the same size, but they may not
- * always be so; try to be careful to maintain the distinction.)
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/pg_list.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * nodes.h
- *	  Definitions for tagged nodes.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/nodes.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-namespace duckdb_libpgquery {
-
-/*
- * The first field of every node is NodeTag. Each node created (with makeNode)
- * will have one of the following tags as the value of its first field.
- *
- * Note that inserting or deleting node types changes the numbers of other
- * node types later in the list.  This is no problem during development, since
- * the node numbers are never stored on disk.  But don't do it in a released
- * branch, because that would represent an ABI break for extensions.
- */
-typedef enum PGNodeTag {
-	T_PGInvalid = 0,
-
-	/*
-	 * TAGS FOR EXECUTOR NODES (execnodes.h)
-	 */
-	T_PGIndexInfo,
-	T_PGExprContext,
-	T_PGProjectionInfo,
-	T_PGJunkFilter,
-	T_PGResultRelInfo,
-	T_PGEState,
-	T_PGTupleTableSlot,
-
-	/*
-	 * TAGS FOR PLAN NODES (plannodes.h)
-	 */
-	T_PGPlan,
-	T_PGResult,
-	T_PGProjectSet,
-	T_PGModifyTable,
-	T_PGAppend,
-	T_PGMergeAppend,
-	T_PGRecursiveUnion,
-	T_PGBitmapAnd,
-	T_PGBitmapOr,
-	T_PGScan,
-	T_PGSeqScan,
-	T_PGSampleScan,
-	T_PGIndexScan,
-	T_PGIndexOnlyScan,
-	T_PGBitmapIndexScan,
-	T_PGBitmapHeapScan,
-	T_PGTidScan,
-	T_PGSubqueryScan,
-	T_PGFunctionScan,
-	T_PGValuesScan,
-	T_PGTableFuncScan,
-	T_PGCteScan,
-	T_PGNamedTuplestoreScan,
-	T_PGWorkTableScan,
-	T_PGForeignScan,
-	T_PGCustomScan,
-	T_PGJoin,
-	T_PGNestLoop,
-	T_PGMergeJoin,
-	T_PGHashJoin,
-	T_PGMaterial,
-	T_PGSort,
-	T_PGGroup,
-	T_PGAgg,
-	T_PGWindowAgg,
-	T_PGUnique,
-	T_PGGather,
-	T_PGGatherMerge,
-	T_PGHash,
-	T_PGSetOp,
-	T_PGLockRows,
-	T_PGLimit,
-	/* these aren't subclasses of PGPlan: */
-	T_PGNestLoopParam,
-	T_PGPlanRowMark,
-	T_PGPlanInvalItem,
-
-	/*
-	 * TAGS FOR PLAN STATE NODES (execnodes.h)
-	 *
-	 * These should correspond one-to-one with PGPlan node types.
-	 */
-	T_PGPlanState,
-	T_PGResultState,
-	T_PGProjectSetState,
-	T_PGModifyTableState,
-	T_PGAppendState,
-	T_PGMergeAppendState,
-	T_PGRecursiveUnionState,
-	T_PGBitmapAndState,
-	T_PGBitmapOrState,
-	T_PGScanState,
-	T_PGSeqScanState,
-	T_PGSampleScanState,
-	T_PGIndexScanState,
-	T_PGIndexOnlyScanState,
-	T_PGBitmapIndexScanState,
-	T_PGBitmapHeapScanState,
-	T_PGTidScanState,
-	T_PGSubqueryScanState,
-	T_PGFunctionScanState,
-	T_PGTableFuncScanState,
-	T_PGValuesScanState,
-	T_PGCteScanState,
-	T_PGNamedTuplestoreScanState,
-	T_PGWorkTableScanState,
-	T_PGForeignScanState,
-	T_PGCustomScanState,
-	T_PGJoinState,
-	T_PGNestLoopState,
-	T_PGMergeJoinState,
-	T_PGHashJoinState,
-	T_PGMaterialState,
-	T_PGSortState,
-	T_PGGroupState,
-	T_PGAggState,
-	T_PGWindowAggState,
-	T_PGUniqueState,
-	T_PGGatherState,
-	T_PGGatherMergeState,
-	T_PGHashState,
-	T_PGSetOpState,
-	T_PGLockRowsState,
-	T_PGLimitState,
-
-	/*
-	 * TAGS FOR PRIMITIVE NODES (primnodes.h)
-	 */
-	T_PGAlias,
-	T_PGRangeVar,
-	T_PGTableFunc,
-	T_PGExpr,
-	T_PGVar,
-	T_PGConst,
-	T_PGParam,
-	T_PGAggref,
-	T_PGGroupingFunc,
-	T_PGWindowFunc,
-	T_PGArrayRef,
-	T_PGFuncExpr,
-	T_PGNamedArgExpr,
-	T_PGOpExpr,
-	T_PGDistinctExpr,
-	T_PGNullIfExpr,
-	T_PGScalarArrayOpExpr,
-	T_PGBoolExpr,
-	T_PGSubLink,
-	T_PGSubPlan,
-	T_PGAlternativeSubPlan,
-	T_PGFieldSelect,
-	T_PGFieldStore,
-	T_PGRelabelType,
-	T_PGCoerceViaIO,
-	T_PGArrayCoerceExpr,
-	T_PGConvertRowtypeExpr,
-	T_PGCollateExpr,
-	T_PGCaseExpr,
-	T_PGCaseWhen,
-	T_PGCaseTestExpr,
-	T_PGArrayExpr,
-	T_PGRowExpr,
-	T_PGRowCompareExpr,
-	T_PGCoalesceExpr,
-	T_PGMinMaxExpr,
-	T_PGSQLValueFunction,
-	T_PGXmlExpr,
-	T_PGNullTest,
-	T_PGBooleanTest,
-	T_PGCoerceToDomain,
-	T_PGCoerceToDomainValue,
-	T_PGSetToDefault,
-	T_PGCurrentOfExpr,
-	T_PGNextValueExpr,
-	T_PGInferenceElem,
-	T_PGTargetEntry,
-	T_PGRangeTblRef,
-	T_PGJoinExpr,
-	T_PGFromExpr,
-	T_PGOnConflictExpr,
-	T_PGIntoClause,
-	T_PGLambdaFunction,
-
-	/*
-	 * TAGS FOR EXPRESSION STATE NODES (execnodes.h)
-	 *
-	 * ExprState represents the evaluation state for a whole expression tree.
-	 * Most Expr-based plan nodes do not have a corresponding expression state
-	 * node, they're fully handled within execExpr* - but sometimes the state
-	 * needs to be shared with other parts of the executor, as for example
-	 * with AggrefExprState, which nodeAgg.c has to modify.
-	 */
-	T_PGExprState,
-	T_PGAggrefExprState,
-	T_PGWindowFuncExprState,
-	T_PGSetExprState,
-	T_PGSubPlanState,
-	T_PGAlternativeSubPlanState,
-	T_PGDomainConstraintState,
-
-	/*
-	 * TAGS FOR PLANNER NODES (relation.h)
-	 */
-	T_PGPlannerInfo,
-	T_PGPlannerGlobal,
-	T_PGRelOptInfo,
-	T_PGIndexOptInfo,
-	T_PGForeignKeyOptInfo,
-	T_PGParamPathInfo,
-	T_PGPath,
-	T_PGIndexPath,
-	T_PGBitmapHeapPath,
-	T_PGBitmapAndPath,
-	T_PGBitmapOrPath,
-	T_PGTidPath,
-	T_PGSubqueryScanPath,
-	T_PGForeignPath,
-	T_PGCustomPath,
-	T_PGNestPath,
-	T_PGMergePath,
-	T_PGHashPath,
-	T_PGAppendPath,
-	T_PGMergeAppendPath,
-	T_PGResultPath,
-	T_PGMaterialPath,
-	T_PGUniquePath,
-	T_PGGatherPath,
-	T_PGGatherMergePath,
-	T_PGProjectionPath,
-	T_PGProjectSetPath,
-	T_PGSortPath,
-	T_PGGroupPath,
-	T_PGUpperUniquePath,
-	T_PGAggPath,
-	T_PGGroupingSetsPath,
-	T_PGMinMaxAggPath,
-	T_PGWindowAggPath,
-	T_PGSetOpPath,
-	T_PGRecursiveUnionPath,
-	T_PGLockRowsPath,
-	T_PGModifyTablePath,
-	T_PGLimitPath,
-	/* these aren't subclasses of Path: */
-	T_PGEquivalenceClass,
-	T_PGEquivalenceMember,
-	T_PGPathKey,
-	T_PGPathTarget,
-	T_PGRestrictInfo,
-	T_PGPlaceHolderVar,
-	T_PGSpecialJoinInfo,
-	T_PGAppendRelInfo,
-	T_PGPartitionedChildRelInfo,
-	T_PGPlaceHolderInfo,
-	T_PGMinMaxAggInfo,
-	T_PGPlannerParamItem,
-	T_PGRollupData,
-	T_PGGroupingSetData,
-	T_PGStatisticExtInfo,
-
-	/*
-	 * TAGS FOR MEMORY NODES (memnodes.h)
-	 */
-	T_PGMemoryContext,
-	T_PGAllocSetContext,
-	T_PGSlabContext,
-
-	/*
-	 * TAGS FOR VALUE NODES (value.h)
-	 */
-	T_PGValue,
-	T_PGInteger,
-	T_PGFloat,
-	T_PGString,
-	T_PGBitString,
-	T_PGNull,
-
-	/*
-	 * TAGS FOR LIST NODES (pg_list.h)
-	 */
-	T_PGList,
-	T_PGIntList,
-	T_PGOidList,
-
-	/*
-	 * TAGS FOR EXTENSIBLE NODES (extensible.h)
-	 */
-	T_PGExtensibleNode,
-
-	/*
-	 * TAGS FOR STATEMENT NODES (mostly in parsenodes.h)
-	 */
-	T_PGRawStmt,
-	T_PGQuery,
-	T_PGPlannedStmt,
-	T_PGInsertStmt,
-	T_PGDeleteStmt,
-	T_PGUpdateStmt,
-	T_PGSelectStmt,
-	T_PGAlterTableStmt,
-	T_PGAlterTableCmd,
-	T_PGAlterDomainStmt,
-	T_PGSetOperationStmt,
-	T_PGGrantStmt,
-	T_PGGrantRoleStmt,
-	T_PGAlterDefaultPrivilegesStmt,
-	T_PGClosePortalStmt,
-	T_PGClusterStmt,
-	T_PGCopyStmt,
-	T_PGCreateStmt,
-	T_PGDefineStmt,
-	T_PGDropStmt,
-	T_PGTruncateStmt,
-	T_PGCommentStmt,
-	T_PGFetchStmt,
-	T_PGIndexStmt,
-	T_PGCreateFunctionStmt,
-	T_PGAlterFunctionStmt,
-	T_PGDoStmt,
-	T_PGRenameStmt,
-	T_PGRuleStmt,
-	T_PGNotifyStmt,
-	T_PGListenStmt,
-	T_PGUnlistenStmt,
-	T_PGTransactionStmt,
-	T_PGViewStmt,
-	T_PGLoadStmt,
-	T_PGCreateDomainStmt,
-	T_PGCreatedbStmt,
-	T_PGDropdbStmt,
-	T_PGVacuumStmt,
-	T_PGExplainStmt,
-	T_PGCreateTableAsStmt,
-	T_PGCreateSeqStmt,
-	T_PGAlterSeqStmt,
-	T_PGVariableSetStmt,
-	T_PGVariableShowStmt,
-	T_PGVariableShowSelectStmt,
-	T_PGDiscardStmt,
-	T_PGCreateTrigStmt,
-	T_PGCreatePLangStmt,
-	T_PGCreateRoleStmt,
-	T_PGAlterRoleStmt,
-	T_PGDropRoleStmt,
-	T_PGLockStmt,
-	T_PGConstraintsSetStmt,
-	T_PGReindexStmt,
-	T_PGCheckPointStmt,
-	T_PGCreateSchemaStmt,
-	T_PGAlterDatabaseStmt,
-	T_PGAlterDatabaseSetStmt,
-	T_PGAlterRoleSetStmt,
-	T_PGCreateConversionStmt,
-	T_PGCreateCastStmt,
-	T_PGCreateOpClassStmt,
-	T_PGCreateOpFamilyStmt,
-	T_PGAlterOpFamilyStmt,
-	T_PGPrepareStmt,
-	T_PGExecuteStmt,
-	T_PGCallStmt,
-	T_PGDeallocateStmt,
-	T_PGDeclareCursorStmt,
-	T_PGCreateTableSpaceStmt,
-	T_PGDropTableSpaceStmt,
-	T_PGAlterObjectDependsStmt,
-	T_PGAlterObjectSchemaStmt,
-	T_PGAlterOwnerStmt,
-	T_PGAlterOperatorStmt,
-	T_PGDropOwnedStmt,
-	T_PGReassignOwnedStmt,
-	T_PGCompositeTypeStmt,
-	T_PGCreateTypeStmt,
-	T_PGCreateRangeStmt,
-	T_PGAlterEnumStmt,
-	T_PGAlterTSDictionaryStmt,
-	T_PGAlterTSConfigurationStmt,
-	T_PGCreateFdwStmt,
-	T_PGAlterFdwStmt,
-	T_PGCreateForeignServerStmt,
-	T_PGAlterForeignServerStmt,
-	T_PGCreateUserMappingStmt,
-	T_PGAlterUserMappingStmt,
-	T_PGDropUserMappingStmt,
-	T_PGAlterTableSpaceOptionsStmt,
-	T_PGAlterTableMoveAllStmt,
-	T_PGSecLabelStmt,
-	T_PGCreateForeignTableStmt,
-	T_PGImportForeignSchemaStmt,
-	T_PGCreateExtensionStmt,
-	T_PGAlterExtensionStmt,
-	T_PGAlterExtensionContentsStmt,
-	T_PGCreateEventTrigStmt,
-	T_PGAlterEventTrigStmt,
-	T_PGRefreshMatViewStmt,
-	T_PGReplicaIdentityStmt,
-	T_PGAlterSystemStmt,
-	T_PGCreatePolicyStmt,
-	T_PGAlterPolicyStmt,
-	T_PGCreateTransformStmt,
-	T_PGCreateAmStmt,
-	T_PGCreatePublicationStmt,
-	T_PGAlterPublicationStmt,
-	T_PGCreateSubscriptionStmt,
-	T_PGAlterSubscriptionStmt,
-	T_PGDropSubscriptionStmt,
-	T_PGCreateStatsStmt,
-	T_PGAlterCollationStmt,
-	T_PGPragmaStmt,
-	T_PGExportStmt,
-	T_PGImportStmt,
-
-	/*
-	 * TAGS FOR PARSE TREE NODES (parsenodes.h)
-	 */
-	T_PGAExpr,
-	T_PGColumnRef,
-	T_PGParamRef,
-	T_PGAConst,
-	T_PGFuncCall,
-	T_PGAStar,
-	T_PGAIndices,
-	T_PGAIndirection,
-	T_PGAArrayExpr,
-	T_PGResTarget,
-	T_PGMultiAssignRef,
-	T_PGTypeCast,
-	T_PGCollateClause,
-	T_PGSortBy,
-	T_PGWindowDef,
-	T_PGRangeSubselect,
-	T_PGRangeFunction,
-	T_PGRangeTableSample,
-	T_PGRangeTableFunc,
-	T_PGRangeTableFuncCol,
-	T_PGTypeName,
-	T_PGColumnDef,
-	T_PGIndexElem,
-	T_PGConstraint,
-	T_PGDefElem,
-	T_PGRangeTblEntry,
-	T_PGRangeTblFunction,
-	T_PGTableSampleClause,
-	T_PGWithCheckOption,
-	T_PGSortGroupClause,
-	T_PGGroupingSet,
-	T_PGWindowClause,
-	T_PGObjectWithArgs,
-	T_PGAccessPriv,
-	T_PGCreateOpClassItem,
-	T_PGTableLikeClause,
-	T_PGFunctionParameter,
-	T_PGLockingClause,
-	T_PGRowMarkClause,
-	T_PGXmlSerialize,
-	T_PGWithClause,
-	T_PGInferClause,
-	T_PGOnConflictClause,
-	T_PGCommonTableExpr,
-	T_PGRoleSpec,
-	T_PGTriggerTransition,
-	T_PGPartitionElem,
-	T_PGPartitionSpec,
-	T_PGPartitionBoundSpec,
-	T_PGPartitionRangeDatum,
-	T_PGPartitionCmd,
-	T_PGIntervalConstant,
-	T_PGSampleSize,
-	T_PGSampleOptions,
-	T_PGLimitPercent,
-	T_PGPositionalReference,
-
-	/*
-	 * TAGS FOR REPLICATION GRAMMAR PARSE NODES (replnodes.h)
-	 */
-	T_PGIdentifySystemCmd,
-	T_PGBaseBackupCmd,
-	T_PGCreateReplicationSlotCmd,
-	T_PGDropReplicationSlotCmd,
-	T_PGStartReplicationCmd,
-	T_PGTimeLineHistoryCmd,
-	T_PGSQLCmd,
-
-	/*
-	 * TAGS FOR RANDOM OTHER STUFF
-	 *
-	 * These are objects that aren't part of parse/plan/execute node tree
-	 * structures, but we give them NodeTags anyway for identification
-	 * purposes (usually because they are involved in APIs where we want to
-	 * pass multiple object types through the same pointer).
-	 */
-	T_PGTriggerData,        /* in commands/trigger.h */
-	T_PGEventTriggerData,   /* in commands/event_trigger.h */
-	T_PGReturnSetInfo,      /* in nodes/execnodes.h */
-	T_PGWindowObjectData,   /* private in nodeWindowAgg.c */
-	T_PGTIDBitmap,          /* in nodes/tidbitmap.h */
-	T_PGInlineCodeBlock,    /* in nodes/parsenodes.h */
-	T_PGFdwRoutine,         /* in foreign/fdwapi.h */
-	T_PGIndexAmRoutine,     /* in access/amapi.h */
-	T_PGTsmRoutine,         /* in access/tsmapi.h */
-	T_PGForeignKeyCacheInfo /* in utils/rel.h */
-} PGNodeTag;
-
-/*
- * The first field of a node of any type is guaranteed to be the NodeTag.
- * Hence the type of any node can be gotten by casting it to Node. Declaring
- * a variable to be of PGNode * (instead of void *) can also facilitate
- * debugging.
- */
-typedef struct PGNode {
-	PGNodeTag type;
-} PGNode;
-
-#define nodeTag(nodeptr) (((const PGNode *)(nodeptr))->type)
-
-#define makeNode(_type_) ((_type_ *)newNode(sizeof(_type_), T_##_type_))
-
-#define NodeSetTag(nodeptr, t) (((PGNode *)(nodeptr))->type = (t))
-
-#define IsA(nodeptr, _type_) (nodeTag(nodeptr) == T_##_type_)
-
-/*
- * castNode(type, ptr) casts ptr to "type *", and if assertions are enabled,
- * verifies that the node has the appropriate type (using its nodeTag()).
- *
- * Use an inline function when assertions are enabled, to avoid multiple
- * evaluations of the ptr argument (which could e.g. be a function call).
- */
-#ifdef USE_ASSERT_CHECKING
-static inline PGNode *castNodeImpl(PGNodeTag type, void *ptr) {
-	Assert(ptr == NULL || nodeTag(ptr) == type);
-	return (PGNode *)ptr;
-}
-#define castNode(_type_, nodeptr) ((_type_ *)castNodeImpl(T_##_type_, nodeptr))
-#else
-#define castNode(_type_, nodeptr) ((_type_ *)(nodeptr))
-#endif /* USE_ASSERT_CHECKING */
-
-/* ----------------------------------------------------------------
- *					  extern declarations follow
- * ----------------------------------------------------------------
- */
-
-/*
- * nodes/{outfuncs.c,print.c}
- */
-struct PGBitmapset;      /* not to include bitmapset.h here */
-struct PGStringInfoData; /* not to include stringinfo.h here */
-
-PGNode* newNode(size_t size, PGNodeTag type);
-
-void outNode(struct PGStringInfoData *str, const void *obj);
-void outToken(struct PGStringInfoData *str, const char *s);
-void outBitmapset(struct PGStringInfoData *str, const struct PGBitmapset *bms);
-void outDatum(struct PGStringInfoData *str, uintptr_t value, int typlen, bool typbyval);
-char *nodeToString(const void *obj);
-char *bmsToString(const struct PGBitmapset *bms);
-
-/*
- * nodes/{readfuncs.c,read.c}
- */
-void *stringToNode(char *str);
-struct PGBitmapset *readBitmapset(void);
-uintptr_t readDatum(bool typbyval);
-bool *readBoolCols(int numCols);
-int *readIntCols(int numCols);
-PGOid *readOidCols(int numCols);
-int16_t *readAttrNumberCols(int numCols);
-
-/*
- * nodes/copyfuncs.c
- */
-void *copyObjectImpl(const void *obj);
-
-/* cast result back to argument type, if supported by compiler */
-//#ifdef HAVE_TYPEOF
-//#define copyObject(obj) ((typeof(obj)) copyObjectImpl(obj))
-//#else
-//#define copyObject(obj) copyObjectImpl(obj)
-//#endif
-
-/*
- * nodes/equalfuncs.c
- */
-// extern bool equal(const void *a, const void *b);
-
-/*
- * Typedefs for identifying qualifier selectivities and plan costs as such.
- * These are just plain "double"s, but declaring a variable as Selectivity
- * or Cost makes the intent more obvious.
- *
- * These could have gone into plannodes.h or some such, but many files
- * depend on them...
- */
-typedef double Selectivity; /* fraction of tuples a qualifier will pass */
-typedef double Cost;        /* execution cost (in page-access units) */
-
-/*
- * PGCmdType -
- *	  enums for type of operation represented by a PGQuery or PGPlannedStmt
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum PGCmdType {
-	PG_CMD_UNKNOWN,
-	PG_CMD_SELECT, /* select stmt */
-	PG_CMD_UPDATE, /* update stmt */
-	PG_CMD_INSERT, /* insert stmt */
-	PG_CMD_DELETE,
-	PG_CMD_UTILITY, /* cmds like create, destroy, copy, vacuum,
-								 * etc. */
-	PG_CMD_NOTHING  /* dummy command for instead nothing rules
-								 * with qual */
-} PGCmdType;
-
-/*
- * PGJoinType -
- *	  enums for types of relation joins
- *
- * PGJoinType determines the exact semantics of joining two relations using
- * a matching qualification.  For example, it tells what to do with a tuple
- * that has no match in the other relation.
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum PGJoinType {
-	/*
-	 * The canonical kinds of joins according to the SQL JOIN syntax. Only
-	 * these codes can appear in parser output (e.g., PGJoinExpr nodes).
-	 */
-	PG_JOIN_INNER, /* matching tuple pairs only */
-	PG_JOIN_LEFT,  /* pairs + unmatched LHS tuples */
-	PG_JOIN_FULL,  /* pairs + unmatched LHS + unmatched RHS */
-	PG_JOIN_RIGHT, /* pairs + unmatched RHS tuples */
-
-	/*
-	 * Semijoins and anti-semijoins (as defined in relational theory) do not
-	 * appear in the SQL JOIN syntax, but there are standard idioms for
-	 * representing them (e.g., using EXISTS).  The planner recognizes these
-	 * cases and converts them to joins.  So the planner and executor must
-	 * support these codes.  NOTE: in PG_JOIN_SEMI output, it is unspecified
-	 * which matching RHS row is joined to.  In PG_JOIN_ANTI output, the row is
-	 * guaranteed to be null-extended.
-	 */
-	PG_JOIN_SEMI, /* 1 copy of each LHS row that has match(es) */
-	PG_JOIN_ANTI, /* 1 copy of each LHS row that has no match */
-
-	/*
-	 * These codes are used internally in the planner, but are not supported
-	 * by the executor (nor, indeed, by most of the planner).
-	 */
-	PG_JOIN_UNIQUE_OUTER, /* LHS path must be made unique */
-	PG_JOIN_UNIQUE_INNER  /* RHS path must be made unique */
-
-	/*
-	 * We might need additional join types someday.
-	 */
-} PGJoinType;
-
-/*
- * OUTER joins are those for which pushed-down quals must behave differently
- * from the join's own quals.  This is in fact everything except INNER and
- * SEMI joins.  However, this macro must also exclude the JOIN_UNIQUE symbols
- * since those are temporary proxies for what will eventually be an INNER
- * join.
- *
- * Note: semijoins are a hybrid case, but we choose to treat them as not
- * being outer joins.  This is okay principally because the SQL syntax makes
- * it impossible to have a pushed-down qual that refers to the inner relation
- * of a semijoin; so there is no strong need to distinguish join quals from
- * pushed-down quals.  This is convenient because for almost all purposes,
- * quals attached to a semijoin can be treated the same as innerjoin quals.
- */
-#define IS_OUTER_JOIN(jointype) \
-	(((1 << (jointype)) & ((1 << PG_JOIN_LEFT) | (1 << PG_JOIN_FULL) | (1 << PG_JOIN_RIGHT) | (1 << PG_JOIN_ANTI))) != 0)
-
-/*
- * PGAggStrategy -
- *	  overall execution strategies for PGAgg plan nodes
- *
- * This is needed in both plannodes.h and relation.h, so put it here...
- */
-typedef enum PGAggStrategy {
-	PG_AGG_PLAIN,  /* simple agg across all input rows */
-	PG_AGG_SORTED, /* grouped agg, input must be sorted */
-	PG_AGG_HASHED, /* grouped agg, use internal hashtable */
-	AGG_MIXED      /* grouped agg, hash and sort both used */
-} PGAggStrategy;
-
-/*
- * PGAggSplit -
- *	  splitting (partial aggregation) modes for PGAgg plan nodes
- *
- * This is needed in both plannodes.h and relation.h, so put it here...
- */
-
-/* Primitive options supported by nodeAgg.c: */
-#define AGGSPLITOP_COMBINE 0x01 /* substitute combinefn for transfn */
-#define AGGSPLITOP_SKIPFINAL 0x02 /* skip finalfn, return state as-is */
-#define AGGSPLITOP_SERIALIZE 0x04 /* apply serializefn to output */
-#define AGGSPLITOP_DESERIALIZE 0x08 /* apply deserializefn to input */
-
-/* Supported operating modes (i.e., useful combinations of these options): */
-typedef enum PGAggSplit {
-	/* Basic, non-split aggregation: */
-	PG_AGGSPLIT_SIMPLE = 0,
-	/* Initial phase of partial aggregation, with serialization: */
-	PG_AGGSPLIT_INITIAL_SERIAL = AGGSPLITOP_SKIPFINAL | AGGSPLITOP_SERIALIZE,
-	/* Final phase of partial aggregation, with deserialization: */
-	PG_AGGSPLIT_FINAL_DESERIAL = AGGSPLITOP_COMBINE | AGGSPLITOP_DESERIALIZE
-} PGAggSplit;
-
-/* Test whether an PGAggSplit value selects each primitive option: */
-#define DO_AGGSPLIT_COMBINE(as) (((as)&AGGSPLITOP_COMBINE) != 0)
-#define DO_AGGSPLIT_SKIPFINAL(as) (((as)&AGGSPLITOP_SKIPFINAL) != 0)
-#define DO_AGGSPLIT_SERIALIZE(as) (((as)&AGGSPLITOP_SERIALIZE) != 0)
-#define DO_AGGSPLIT_DESERIALIZE(as) (((as)&AGGSPLITOP_DESERIALIZE) != 0)
-
-/*
- * PGSetOpCmd and PGSetOpStrategy -
- *	  overall semantics and execution strategies for PGSetOp plan nodes
- *
- * This is needed in both plannodes.h and relation.h, so put it here...
- */
-typedef enum PGSetOpCmd {
-	PG_SETOPCMD_INTERSECT,
-	PG_SETOPCMD_INTERSECT_ALL,
-	PG_SETOPCMD_EXCEPT,
-	PG_SETOPCMD_EXCEPT_ALL
-} PGSetOpCmd;
-
-typedef enum PGSetOpStrategy {
-	PG_SETOP_SORTED, /* input must be sorted */
-	PG_SETOP_HASHED  /* use internal hashtable */
-} PGSetOpStrategy;
-
-/*
- * PGOnConflictAction -
- *	  "ON CONFLICT" clause type of query
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum PGOnConflictAction {
-	PG_ONCONFLICT_NONE,    /* No "ON CONFLICT" clause */
-	PG_ONCONFLICT_NOTHING, /* ON CONFLICT ... DO NOTHING */
-	PG_ONCONFLICT_UPDATE   /* ON CONFLICT ... DO UPDATE */
-} PGOnConflictAction;
-
-}
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_libpgquery {
-
-typedef struct PGListCell ListCell;
-
-typedef struct PGList {
-	PGNodeTag		type;			/* duckdb_libpgquery::T_PGList, duckdb_libpgquery::T_PGIntList, or duckdb_libpgquery::T_PGOidList */
-	int			length;
-	PGListCell   *head;
-	PGListCell   *tail;
-} PGList;
-
-struct PGListCell {
-	union
-	{
-		void	   *ptr_value;
-		int			int_value;
-		PGOid			oid_value;
-	}			data;
-	PGListCell   *next;
-};
-
-/*
- * The *only* valid representation of an empty list is NIL; in other
- * words, a non-NIL list is guaranteed to have length >= 1 and
- * head/tail != NULL
- */
-#define NIL						((PGList *) NULL)
-
-/*
- * These routines are used frequently. However, we can't implement
- * them as macros, since we want to avoid double-evaluation of macro
- * arguments.
- */
-static inline PGListCell *
-list_head(const PGList *l)
-{
-	return l ? l->head : NULL;
-}
-
-static inline PGListCell *
-list_tail(PGList *l)
-{
-	return l ? l->tail : NULL;
-}
-
-static inline int
-list_length(const PGList *l)
-{
-	return l ? l->length : 0;
-}
-
-/*
- * NB: There is an unfortunate legacy from a previous incarnation of
- * the PGList API: the macro lfirst() was used to mean "the data in this
- * cons cell". To avoid changing every usage of lfirst(), that meaning
- * has been kept. As a result, lfirst() takes a PGListCell and returns
- * the data it contains; to get the data in the first cell of a
- * PGList, use linitial(). Worse, lsecond() is more closely related to
- * linitial() than lfirst(): given a PGList, lsecond() returns the data
- * in the second cons cell.
- */
-
-#define lnext(lc)				((lc)->next)
-#define lfirst(lc)				((lc)->data.ptr_value)
-#define lfirst_int(lc)			((lc)->data.int_value)
-#define lfirst_oid(lc)			((lc)->data.oid_value)
-#define lfirst_node(type,lc)	castNode(type, lfirst(lc))
-
-#define linitial(l)				lfirst(list_head(l))
-#define linitial_int(l)			lfirst_int(list_head(l))
-#define linitial_oid(l)			lfirst_oid(list_head(l))
-#define linitial_node(type,l)	castNode(type, linitial(l))
-
-#define lsecond(l)				lfirst(lnext(list_head(l)))
-#define lsecond_int(l)			lfirst_int(lnext(list_head(l)))
-#define lsecond_oid(l)			lfirst_oid(lnext(list_head(l)))
-#define lsecond_node(type,l)	castNode(type, lsecond(l))
-
-#define lthird(l)				lfirst(lnext(lnext(list_head(l))))
-#define lthird_int(l)			lfirst_int(lnext(lnext(list_head(l))))
-#define lthird_oid(l)			lfirst_oid(lnext(lnext(list_head(l))))
-#define lthird_node(type,l)		castNode(type, lthird(l))
-
-#define lfourth(l)				lfirst(lnext(lnext(lnext(list_head(l)))))
-#define lfourth_int(l)			lfirst_int(lnext(lnext(lnext(list_head(l)))))
-#define lfourth_oid(l)			lfirst_oid(lnext(lnext(lnext(list_head(l)))))
-#define lfourth_node(type,l)	castNode(type, lfourth(l))
-
-#define llast(l)				lfirst(list_tail(l))
-#define llast_int(l)			lfirst_int(list_tail(l))
-#define llast_oid(l)			lfirst_oid(list_tail(l))
-#define llast_node(type,l)		castNode(type, llast(l))
-
-/*
- * Convenience macros for building fixed-length lists
- */
-#define list_make1(x1)				lcons(x1, NIL)
-#define list_make2(x1,x2)			lcons(x1, list_make1(x2))
-#define list_make3(x1,x2,x3)		lcons(x1, list_make2(x2, x3))
-#define list_make4(x1,x2,x3,x4)		lcons(x1, list_make3(x2, x3, x4))
-#define list_make5(x1,x2,x3,x4,x5)	lcons(x1, list_make4(x2, x3, x4, x5))
-
-#define list_make1_int(x1)			lcons_int(x1, NIL)
-#define list_make2_int(x1,x2)		lcons_int(x1, list_make1_int(x2))
-#define list_make3_int(x1,x2,x3)	lcons_int(x1, list_make2_int(x2, x3))
-#define list_make4_int(x1,x2,x3,x4) lcons_int(x1, list_make3_int(x2, x3, x4))
-#define list_make5_int(x1,x2,x3,x4,x5)	lcons_int(x1, list_make4_int(x2, x3, x4, x5))
-
-#define list_make1_oid(x1)			lcons_oid(x1, NIL)
-#define list_make2_oid(x1,x2)		lcons_oid(x1, list_make1_oid(x2))
-#define list_make3_oid(x1,x2,x3)	lcons_oid(x1, list_make2_oid(x2, x3))
-#define list_make4_oid(x1,x2,x3,x4) lcons_oid(x1, list_make3_oid(x2, x3, x4))
-#define list_make5_oid(x1,x2,x3,x4,x5)	lcons_oid(x1, list_make4_oid(x2, x3, x4, x5))
-
-/*
- * foreach -
- *	  a convenience macro which loops through the list
- */
-#define foreach(cell, l)	\
-	for ((cell) = list_head(l); (cell) != NULL; (cell) = lnext(cell))
-
-/*
- * for_each_cell -
- *	  a convenience macro which loops through a list starting from a
- *	  specified cell
- */
-#define for_each_cell(cell, initcell)	\
-	for ((cell) = (initcell); (cell) != NULL; (cell) = lnext(cell))
-
-/*
- * forboth -
- *	  a convenience macro for advancing through two linked lists
- *	  simultaneously. This macro loops through both lists at the same
- *	  time, stopping when either list runs out of elements. Depending
- *	  on the requirements of the call site, it may also be wise to
- *	  assert that the lengths of the two lists are equal.
- */
-#define forboth(cell1, list1, cell2, list2)							\
-	for ((cell1) = list_head(list1), (cell2) = list_head(list2);	\
-		 (cell1) != NULL && (cell2) != NULL;						\
-		 (cell1) = lnext(cell1), (cell2) = lnext(cell2))
-
-/*
- * for_both_cell -
- *	  a convenience macro which loops through two lists starting from the
- *	  specified cells of each. This macro loops through both lists at the same
- *	  time, stopping when either list runs out of elements.  Depending on the
- *	  requirements of the call site, it may also be wise to assert that the
- *	  lengths of the two lists are equal, and initcell1 and initcell2 are at
- *	  the same position in the respective lists.
- */
-#define for_both_cell(cell1, initcell1, cell2, initcell2)	\
-	for ((cell1) = (initcell1), (cell2) = (initcell2);		\
-		 (cell1) != NULL && (cell2) != NULL;				\
-		 (cell1) = lnext(cell1), (cell2) = lnext(cell2))
-
-/*
- * forthree -
- *	  the same for three lists
- */
-#define forthree(cell1, list1, cell2, list2, cell3, list3)			\
-	for ((cell1) = list_head(list1), (cell2) = list_head(list2), (cell3) = list_head(list3); \
-		 (cell1) != NULL && (cell2) != NULL && (cell3) != NULL;		\
-		 (cell1) = lnext(cell1), (cell2) = lnext(cell2), (cell3) = lnext(cell3))
-
-PGList *lappend(PGList *list, void *datum);
-PGList *lappend_int(PGList *list, int datum);
-PGList *lappend_oid(PGList *list, PGOid datum);
-
-PGListCell *lappend_cell(PGList *list, PGListCell *prev, void *datum);
-PGListCell *lappend_cell_int(PGList *list, PGListCell *prev, int datum);
-PGListCell *lappend_cell_oid(PGList *list, PGListCell *prev, PGOid datum);
-
-PGList *lcons(void *datum, PGList *list);
-PGList *lcons_int(int datum, PGList *list);
-PGList *lcons_oid(PGOid datum, PGList *list);
-
-PGList *list_concat(PGList *list1, PGList *list2);
-PGList *list_truncate(PGList *list, int new_size);
-
-PGListCell *list_nth_cell(const PGList *list, int n);
-void *list_nth(const PGList *list, int n);
-int	list_nth_int(const PGList *list, int n);
-PGOid	list_nth_oid(const PGList *list, int n);
-#define list_nth_node(type,list,n)	castNode(type, list_nth(list, n))
-
-bool list_member(const PGList *list, const void *datum);
-bool list_member_ptr(const PGList *list, const void *datum);
-bool list_member_int(const PGList *list, int datum);
-bool list_member_oid(const PGList *list, PGOid datum);
-
-PGList *list_delete(PGList *list, void *datum);
-PGList *list_delete_ptr(PGList *list, void *datum);
-PGList *list_delete_int(PGList *list, int datum);
-PGList *list_delete_oid(PGList *list, PGOid datum);
-PGList *list_delete_first(PGList *list);
-PGList *list_delete_cell(PGList *list, PGListCell *cell, PGListCell *prev);
-
-PGList *list_union(const PGList *list1, const PGList *list2);
-PGList *list_union_ptr(const PGList *list1, const PGList *list2);
-PGList *list_union_int(const PGList *list1, const PGList *list2);
-PGList *list_union_oid(const PGList *list1, const PGList *list2);
-
-PGList *list_intersection(const PGList *list1, const PGList *list2);
-PGList *list_intersection_int(const PGList *list1, const PGList *list2);
-
-/* currently, there's no need for list_intersection_ptr etc */
-
-PGList *list_difference(const PGList *list1, const PGList *list2);
-PGList *list_difference_ptr(const PGList *list1, const PGList *list2);
-PGList *list_difference_int(const PGList *list1, const PGList *list2);
-PGList *list_difference_oid(const PGList *list1, const PGList *list2);
-
-PGList *list_append_unique(PGList *list, void *datum);
-PGList *list_append_unique_ptr(PGList *list, void *datum);
-PGList *list_append_unique_int(PGList *list, int datum);
-PGList *list_append_unique_oid(PGList *list, PGOid datum);
-
-PGList *list_concat_unique(PGList *list1, PGList *list2);
-PGList *list_concat_unique_ptr(PGList *list1, PGList *list2);
-PGList *list_concat_unique_int(PGList *list1, PGList *list2);
-PGList *list_concat_unique_oid(PGList *list1, PGList *list2);
-
-void list_free(PGList *list);
-void list_free_deep(PGList *list);
-
-PGList *list_copy(const PGList *list);
-PGList *list_copy_tail(const PGList *list, int nskip);
-
-/*
- * To ease migration to the new list API, a set of compatibility
- * macros are provided that reduce the impact of the list API changes
- * as far as possible. Until client code has been rewritten to use the
- * new list API, the ENABLE_LIST_COMPAT symbol can be defined before
- * including pg_list.h
- */
-#ifdef ENABLE_LIST_COMPAT
-
-#define lfirsti(lc)					lfirst_int(lc)
-#define lfirsto(lc)					lfirst_oid(lc)
-
-#define makeList1(x1)				list_make1(x1)
-#define makeList2(x1, x2)			list_make2(x1, x2)
-#define makeList3(x1, x2, x3)		list_make3(x1, x2, x3)
-#define makeList4(x1, x2, x3, x4)	list_make4(x1, x2, x3, x4)
-
-#define makeListi1(x1)				list_make1_int(x1)
-#define makeListi2(x1, x2)			list_make2_int(x1, x2)
-
-#define makeListo1(x1)				list_make1_oid(x1)
-#define makeListo2(x1, x2)			list_make2_oid(x1, x2)
-
-#define lconsi(datum, list)			lcons_int(datum, list)
-#define lconso(datum, list)			lcons_oid(datum, list)
-
-#define lappendi(list, datum)		lappend_int(list, datum)
-#define lappendo(list, datum)		lappend_oid(list, datum)
-
-#define nconc(l1, l2)				list_concat(l1, l2)
-
-#define nth(n, list)				list_nth(list, n)
-
-#define member(datum, list)			list_member(list, datum)
-#define ptrMember(datum, list)		list_member_ptr(list, datum)
-#define intMember(datum, list)		list_member_int(list, datum)
-#define oidMember(datum, list)		list_member_oid(list, datum)
-
-/*
- * Note that the old lremove() determined equality via pointer
- * comparison, whereas the new list_delete() uses equal(); in order to
- * keep the same behavior, we therefore need to map lremove() calls to
- * list_delete_ptr() rather than list_delete()
- */
-#define lremove(elem, list)			list_delete_ptr(list, elem)
-#define LispRemove(elem, list)		list_delete(list, elem)
-#define lremovei(elem, list)		list_delete_int(list, elem)
-#define lremoveo(elem, list)		list_delete_oid(list, elem)
-
-#define ltruncate(n, list)			list_truncate(list, n)
-
-#define set_union(l1, l2)			list_union(l1, l2)
-#define set_uniono(l1, l2)			list_union_oid(l1, l2)
-#define set_ptrUnion(l1, l2)		list_union_ptr(l1, l2)
-
-#define set_difference(l1, l2)		list_difference(l1, l2)
-#define set_differenceo(l1, l2)		list_difference_oid(l1, l2)
-#define set_ptrDifference(l1, l2)	list_difference_ptr(l1, l2)
-
-#define equali(l1, l2)				equal(l1, l2)
-#define equalo(l1, l2)				equal(l1, l2)
-
-#define freeList(list)				list_free(list)
-
-#define listCopy(list)				list_copy(list)
-
-int	length(PGList *list);
-#endif							/* ENABLE_LIST_COMPAT */
-
-}
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_libpgquery {
-
-/* ----------------------------------------------------------------
- *						node definitions
- * ----------------------------------------------------------------
- */
-
-/*
- * PGAlias -
- *	  specifies an alias for a range variable; the alias might also
- *	  specify renaming of columns within the table.
- *
- * Note: colnames is a list of PGValue nodes (always strings).  In PGAlias structs
- * associated with RTEs, there may be entries corresponding to dropped
- * columns; these are normally empty strings ("").  See parsenodes.h for info.
- */
-typedef struct PGAlias {
-	PGNodeTag type;
-	char *aliasname;  /* aliased rel name (never qualified) */
-	PGList *colnames; /* optional list of column aliases */
-} PGAlias;
-
-/* What to do at commit time for temporary relations */
-typedef enum PGOnCommitAction {
-	PG_ONCOMMIT_NOOP,          /* No ON COMMIT clause (do nothing) */
-	PG_ONCOMMIT_PRESERVE_ROWS, /* ON COMMIT PRESERVE ROWS (do nothing) */
-	PG_ONCOMMIT_DELETE_ROWS,   /* ON COMMIT DELETE ROWS */
-	ONCOMMIT_DROP              /* ON COMMIT DROP */
-} PGOnCommitAction;
-
-/* What to do at commit time for temporary relations */
-typedef enum PGOnCreateConflict {
-	// Standard: throw error
-	PG_ERROR_ON_CONFLICT,
-	// CREATE IF NOT EXISTS, silently do nothing on conflict
-	PG_IGNORE_ON_CONFLICT,
-	// CREATE OR REPLACE
-	PG_REPLACE_ON_CONFLICT
-} PGOnCreateConflict;
-
-/*
- * PGRangeVar - range variable, used in FROM clauses
- *
- * Also used to represent table names in utility statements; there, the alias
- * field is not used, and inh tells whether to apply the operation
- * recursively to child tables.  In some contexts it is also useful to carry
- * a TEMP table indication here.
- */
-typedef struct PGRangeVar {
-	PGNodeTag type;
-	char *catalogname;   /* the catalog (database) name, or NULL */
-	char *schemaname;    /* the schema name, or NULL */
-	char *relname;       /* the relation/sequence name */
-	bool inh;            /* expand rel by inheritance? recursively act
-								 * on children? */
-	char relpersistence; /* see RELPERSISTENCE_* in pg_class.h */
-	PGAlias *alias;      /* table alias & optional column aliases */
-	int location;        /* token location, or -1 if unknown */
-	PGNode *sample;      /* sample, if any */
-} PGRangeVar;
-
-/*
- * PGTableFunc - node for a table function, such as XMLTABLE.
- */
-typedef struct PGTableFunc {
-	PGNodeTag type;
-	PGList *ns_uris;       /* list of namespace uri */
-	PGList *ns_names;      /* list of namespace names */
-	PGNode *docexpr;       /* input document expression */
-	PGNode *rowexpr;       /* row filter expression */
-	PGList *colnames;      /* column names (list of String) */
-	PGList *coltypes;      /* OID list of column type OIDs */
-	PGList *coltypmods;    /* integer list of column typmods */
-	PGList *colcollations; /* OID list of column collation OIDs */
-	PGList *colexprs;      /* list of column filter expressions */
-	PGList *coldefexprs;   /* list of column default expressions */
-	PGBitmapset *notnulls; /* nullability flag for each output column */
-	int ordinalitycol;     /* counts from 0; -1 if none specified */
-	int location;          /* token location, or -1 if unknown */
-} PGTableFunc;
-
-/*
- * PGIntoClause - target information for SELECT INTO, CREATE TABLE AS, and
- * CREATE MATERIALIZED VIEW
- *
- * For CREATE MATERIALIZED VIEW, viewQuery is the parsed-but-not-rewritten
- * SELECT PGQuery for the view; otherwise it's NULL.  (Although it's actually
- * PGQuery*, we declare it as PGNode* to avoid a forward reference.)
- */
-typedef struct PGIntoClause {
-	PGNodeTag type;
-
-	PGRangeVar *rel;           /* target relation name */
-	PGList *colNames;          /* column names to assign, or NIL */
-	PGList *options;           /* options from WITH clause */
-	PGOnCommitAction onCommit; /* what do we do at COMMIT? */
-	char *tableSpaceName;      /* table space to use, or NULL */
-	PGNode *viewQuery;         /* materialized view's SELECT query */
-	bool skipData;             /* true for WITH NO DATA */
-} PGIntoClause;
-
-/* ----------------------------------------------------------------
- *					node types for executable expressions
- * ----------------------------------------------------------------
- */
-
-/*
- * PGExpr - generic superclass for executable-expression nodes
- *
- * All node types that are used in executable expression trees should derive
- * from PGExpr (that is, have PGExpr as their first field).  Since PGExpr only
- * contains PGNodeTag, this is a formality, but it is an easy form of
- * documentation.  See also the ExprState node types in execnodes.h.
- */
-typedef struct PGExpr {
-	PGNodeTag type;
-} PGExpr;
-
-/*
- * PGVar - expression node representing a variable (ie, a table column)
- *
- * Note: during parsing/planning, varnoold/varoattno are always just copies
- * of varno/varattno.  At the tail end of planning, PGVar nodes appearing in
- * upper-level plan nodes are reassigned to point to the outputs of their
- * subplans; for example, in a join node varno becomes INNER_VAR or OUTER_VAR
- * and varattno becomes the index of the proper element of that subplan's
- * target list.  Similarly, INDEX_VAR is used to identify Vars that reference
- * an index column rather than a heap column.  (In PGForeignScan and PGCustomScan
- * plan nodes, INDEX_VAR is abused to signify references to columns of a
- * custom scan tuple type.)  In all these cases, varnoold/varoattno hold the
- * original values.  The code doesn't really need varnoold/varoattno, but they
- * are very useful for debugging and interpreting completed plans, so we keep
- * them around.
- */
-#define INNER_VAR 65000 /* reference to inner subplan */
-#define OUTER_VAR 65001 /* reference to outer subplan */
-#define INDEX_VAR 65002 /* reference to index column */
-
-#define IS_SPECIAL_VARNO(varno) ((varno) >= INNER_VAR)
-
-/* Symbols for the indexes of the special RTE entries in rules */
-#define PRS2_OLD_VARNO 1
-#define PRS2_NEW_VARNO 2
-
-typedef struct PGVar {
-	PGExpr xpr;
-	PGIndex varno;          /* index of this var's relation in the range
-								 * table, or INNER_VAR/OUTER_VAR/INDEX_VAR */
-	PGAttrNumber varattno;  /* attribute number of this var, or zero for
-								 * all */
-	PGOid vartype;          /* pg_type OID for the type of this var */
-	int32_t vartypmod;      /* pg_attribute typmod value */
-	PGOid varcollid;        /* OID of collation, or InvalidOid if none */
-	PGIndex varlevelsup;    /* for subquery variables referencing outer
-								 * relations; 0 in a normal var, >0 means N
-								 * levels up */
-	PGIndex varnoold;       /* original value of varno, for debugging */
-	PGAttrNumber varoattno; /* original value of varattno */
-	int location;           /* token location, or -1 if unknown */
-} PGVar;
-
-/*
- * PGConst
- *
- * Note: for pg_varlena data types, we make a rule that a PGConst node's value
- * must be in non-extended form (4-byte header, no compression or external
- * references).  This ensures that the PGConst node is self-contained and makes
- * it more likely that equal() will see logically identical values as equal.
- */
-typedef struct PGConst {
-	PGExpr xpr;
-	PGOid consttype;     /* pg_type OID of the constant's datatype */
-	int32_t consttypmod; /* typmod value, if any */
-	PGOid constcollid;   /* OID of collation, or InvalidOid if none */
-	int constlen;        /* typlen of the constant's datatype */
-	PGDatum constvalue;  /* the constant's value */
-	bool constisnull;    /* whether the constant is null (if true,
-								 * constvalue is undefined) */
-	bool constbyval;     /* whether this datatype is passed by value.
-								 * If true, then all the information is stored
-								 * in the Datum. If false, then the PGDatum
-								 * contains a pointer to the information. */
-	int location;        /* token location, or -1 if unknown */
-} PGConst;
-
-/*
- * PGParam
- *
- *		paramkind specifies the kind of parameter. The possible values
- *		for this field are:
- *
- *		PG_PARAM_EXTERN:  The parameter value is supplied from outside the plan.
- *				Such parameters are numbered from 1 to n.
- *
- *		PG_PARAM_EXEC:  The parameter is an internal executor parameter, used
- *				for passing values into and out of sub-queries or from
- *				nestloop joins to their inner scans.
- *				For historical reasons, such parameters are numbered from 0.
- *				These numbers are independent of PG_PARAM_EXTERN numbers.
- *
- *		PG_PARAM_SUBLINK:	The parameter represents an output column of a PGSubLink
- *				node's sub-select.  The column number is contained in the
- *				`paramid' field.  (This type of PGParam is converted to
- *				PG_PARAM_EXEC during planning.)
- *
- *		PG_PARAM_MULTIEXPR:  Like PG_PARAM_SUBLINK, the parameter represents an
- *				output column of a PGSubLink node's sub-select, but here, the
- *				PGSubLink is always a MULTIEXPR SubLink.  The high-order 16 bits
- *				of the `paramid' field contain the SubLink's subLinkId, and
- *				the low-order 16 bits contain the column number.  (This type
- *				of PGParam is also converted to PG_PARAM_EXEC during planning.)
- */
-typedef enum PGParamKind { PG_PARAM_EXTERN, PG_PARAM_EXEC, PG_PARAM_SUBLINK, PG_PARAM_MULTIEXPR } PGParamKind;
-
-typedef struct PGParam {
-	PGExpr xpr;
-	PGParamKind paramkind; /* kind of parameter. See above */
-	int paramid;           /* numeric ID for parameter */
-	PGOid paramtype;       /* pg_type OID of parameter's datatype */
-	int32_t paramtypmod;   /* typmod value, if known */
-	PGOid paramcollid;     /* OID of collation, or InvalidOid if none */
-	int location;          /* token location, or -1 if unknown */
-} PGParam;
-
-/*
- * PGAggref
- *
- * The aggregate's args list is a targetlist, ie, a list of PGTargetEntry nodes.
- *
- * For a normal (non-ordered-set) aggregate, the non-resjunk TargetEntries
- * represent the aggregate's regular arguments (if any) and resjunk TLEs can
- * be added at the end to represent ORDER BY expressions that are not also
- * arguments.  As in a top-level PGQuery, the TLEs can be marked with
- * ressortgroupref indexes to let them be referenced by PGSortGroupClause
- * entries in the aggorder and/or aggdistinct lists.  This represents ORDER BY
- * and DISTINCT operations to be applied to the aggregate input rows before
- * they are passed to the transition function.  The grammar only allows a
- * simple "DISTINCT" specifier for the arguments, but we use the full
- * query-level representation to allow more code sharing.
- *
- * For an ordered-set aggregate, the args list represents the WITHIN GROUP
- * (aggregated) arguments, all of which will be listed in the aggorder list.
- * DISTINCT is not supported in this case, so aggdistinct will be NIL.
- * The direct arguments appear in aggdirectargs (as a list of plain
- * expressions, not PGTargetEntry nodes).
- *
- * aggtranstype is the data type of the state transition values for this
- * aggregate (resolved to an actual type, if agg's transtype is polymorphic).
- * This is determined during planning and is InvalidOid before that.
- *
- * aggargtypes is an OID list of the data types of the direct and regular
- * arguments.  Normally it's redundant with the aggdirectargs and args lists,
- * but in a combining aggregate, it's not because the args list has been
- * replaced with a single argument representing the partial-aggregate
- * transition values.
- *
- * aggsplit indicates the expected partial-aggregation mode for the Aggref's
- * parent plan node.  It's always set to PG_AGGSPLIT_SIMPLE in the parser, but
- * the planner might change it to something else.  We use this mainly as
- * a crosscheck that the Aggrefs match the plan; but note that when aggsplit
- * indicates a non-final mode, aggtype reflects the transition data type
- * not the SQL-level output type of the aggregate.
- */
-typedef struct PGAggref {
-	PGExpr xpr;
-	PGOid aggfnoid;        /* pg_proc PGOid of the aggregate */
-	PGOid aggtype;         /* type PGOid of result of the aggregate */
-	PGOid aggcollid;       /* OID of collation of result */
-	PGOid inputcollid;     /* OID of collation that function should use */
-	PGOid aggtranstype;    /* type PGOid of aggregate's transition value */
-	PGList *aggargtypes;   /* type Oids of direct and aggregated args */
-	PGList *aggdirectargs; /* direct arguments, if an ordered-set agg */
-	PGList *args;          /* aggregated arguments and sort expressions */
-	PGList *aggorder;      /* ORDER BY (list of PGSortGroupClause) */
-	PGList *aggdistinct;   /* DISTINCT (list of PGSortGroupClause) */
-	PGExpr *aggfilter;     /* FILTER expression, if any */
-	bool aggstar;          /* true if argument list was really '*' */
-	bool aggvariadic;      /* true if variadic arguments have been
-								 * combined into an array last argument */
-	char aggkind;          /* aggregate kind (see pg_aggregate.h) */
-	PGIndex agglevelsup;   /* > 0 if agg belongs to outer query */
-	PGAggSplit aggsplit;   /* expected agg-splitting mode of parent PGAgg */
-	int location;          /* token location, or -1 if unknown */
-} PGAggref;
-
-/*
- * PGGroupingFunc
- *
- * A PGGroupingFunc is a GROUPING(...) expression, which behaves in many ways
- * like an aggregate function (e.g. it "belongs" to a specific query level,
- * which might not be the one immediately containing it), but also differs in
- * an important respect: it never evaluates its arguments, they merely
- * designate expressions from the GROUP BY clause of the query level to which
- * it belongs.
- *
- * The spec defines the evaluation of GROUPING() purely by syntactic
- * replacement, but we make it a real expression for optimization purposes so
- * that one PGAgg node can handle multiple grouping sets at once.  Evaluating the
- * result only needs the column positions to check against the grouping set
- * being projected.  However, for EXPLAIN to produce meaningful output, we have
- * to keep the original expressions around, since expression deparse does not
- * give us any feasible way to get at the GROUP BY clause.
- *
- * Also, we treat two PGGroupingFunc nodes as equal if they have equal arguments
- * lists and agglevelsup, without comparing the refs and cols annotations.
- *
- * In raw parse output we have only the args list; parse analysis fills in the
- * refs list, and the planner fills in the cols list.
- */
-typedef struct PGGroupingFunc {
-	PGExpr xpr;
-	PGList *args;        /* arguments, not evaluated but kept for
-								 * benefit of EXPLAIN etc. */
-	PGList *refs;        /* ressortgrouprefs of arguments */
-	PGList *cols;        /* actual column positions set by planner */
-	PGIndex agglevelsup; /* same as Aggref.agglevelsup */
-	int location;        /* token location */
-} PGGroupingFunc;
-
-/*
- * PGWindowFunc
- */
-typedef struct PGWindowFunc {
-	PGExpr xpr;
-	PGOid winfnoid;    /* pg_proc PGOid of the function */
-	PGOid wintype;     /* type PGOid of result of the window function */
-	PGOid wincollid;   /* OID of collation of result */
-	PGOid inputcollid; /* OID of collation that function should use */
-	PGList *args;      /* arguments to the window function */
-	PGExpr *aggfilter; /* FILTER expression, if any */
-	PGIndex winref;    /* index of associated PGWindowClause */
-	bool winstar;      /* true if argument list was really '*' */
-	bool winagg;       /* is function a simple aggregate? */
-	int location;      /* token location, or -1 if unknown */
-} PGWindowFunc;
-
-/* ----------------
- *	PGArrayRef: describes an array subscripting operation
- *
- * An PGArrayRef can describe fetching a single element from an array,
- * fetching a subarray (array slice), storing a single element into
- * an array, or storing a slice.  The "store" cases work with an
- * initial array value and a source value that is inserted into the
- * appropriate part of the array; the result of the operation is an
- * entire new modified array value.
- *
- * If reflowerindexpr = NIL, then we are fetching or storing a single array
- * element at the subscripts given by refupperindexpr.  Otherwise we are
- * fetching or storing an array slice, that is a rectangular subarray
- * with lower and upper bounds given by the index expressions.
- * reflowerindexpr must be the same length as refupperindexpr when it
- * is not NIL.
- *
- * In the slice case, individual expressions in the subscript lists can be
- * NULL, meaning "substitute the array's current lower or upper bound".
- *
- * Note: the result datatype is the element type when fetching a single
- * element; but it is the array type when doing subarray fetch or either
- * type of store.
- *
- * Note: for the cases where an array is returned, if refexpr yields a R/W
- * expanded array, then the implementation is allowed to modify that object
- * in-place and return the same object.)
- * ----------------
- */
-typedef struct PGArrayRef {
-	PGExpr xpr;
-	PGOid refarraytype;      /* type of the array proper */
-	PGOid refelemtype;       /* type of the array elements */
-	int32_t reftypmod;       /* typmod of the array (and elements too) */
-	PGOid refcollid;         /* OID of collation, or InvalidOid if none */
-	PGList *refupperindexpr; /* expressions that evaluate to upper
-									 * array indexes */
-	PGList *reflowerindexpr; /* expressions that evaluate to lower
-									 * array indexes, or NIL for single array
-									 * element */
-	PGExpr *refexpr;         /* the expression that evaluates to an array
-								 * value */
-	PGExpr *refassgnexpr;    /* expression for the source value, or NULL if
-								 * fetch */
-} PGArrayRef;
-
-/*
- * PGCoercionContext - distinguishes the allowed set of type casts
- *
- * NB: ordering of the alternatives is significant; later (larger) values
- * allow more casts than earlier ones.
- */
-typedef enum PGCoercionContext {
-	PG_COERCION_IMPLICIT,   /* coercion in context of expression */
-	PG_COERCION_ASSIGNMENT, /* coercion in context of assignment */
-	PG_COERCION_EXPLICIT    /* explicit cast operation */
-} PGCoercionContext;
-
-/*
- * PGCoercionForm - how to display a node that could have come from a cast
- *
- * NB: equal() ignores PGCoercionForm fields, therefore this *must* not carry
- * any semantically significant information.  We need that behavior so that
- * the planner will consider equivalent implicit and explicit casts to be
- * equivalent.  In cases where those actually behave differently, the coercion
- * function's arguments will be different.
- */
-typedef enum PGCoercionForm {
-	PG_COERCE_EXPLICIT_CALL, /* display as a function call */
-	PG_COERCE_EXPLICIT_CAST, /* display as an explicit cast */
-	PG_COERCE_IMPLICIT_CAST  /* implicit cast, so hide it */
-} PGCoercionForm;
-
-/*
- * PGFuncExpr - expression node for a function call
- */
-typedef struct PGFuncExpr {
-	PGExpr xpr;
-	PGOid funcid;              /* PG_PROC OID of the function */
-	PGOid funcresulttype;      /* PG_TYPE OID of result value */
-	bool funcretset;           /* true if function returns set */
-	bool funcvariadic;         /* true if variadic arguments have been
-								 * combined into an array last argument */
-	PGCoercionForm funcformat; /* how to display this function call */
-	PGOid funccollid;          /* OID of collation of result */
-	PGOid inputcollid;         /* OID of collation that function should use */
-	PGList *args;              /* arguments to the function */
-	int location;              /* token location, or -1 if unknown */
-} PGFuncExpr;
-
-/*
- * PGNamedArgExpr - a named argument of a function
- *
- * This node type can only appear in the args list of a PGFuncCall or PGFuncExpr
- * node.  We support pure positional call notation (no named arguments),
- * named notation (all arguments are named), and mixed notation (unnamed
- * arguments followed by named ones).
- *
- * Parse analysis sets argnumber to the positional index of the argument,
- * but doesn't rearrange the argument list.
- *
- * The planner will convert argument lists to pure positional notation
- * during expression preprocessing, so execution never sees a NamedArgExpr.
- */
-typedef struct PGNamedArgExpr {
-	PGExpr xpr;
-	PGExpr *arg;   /* the argument expression */
-	char *name;    /* the name */
-	int argnumber; /* argument's number in positional notation */
-	int location;  /* argument name location, or -1 if unknown */
-} PGNamedArgExpr;
-
-/*
- * PGOpExpr - expression node for an operator invocation
- *
- * Semantically, this is essentially the same as a function call.
- *
- * Note that opfuncid is not necessarily filled in immediately on creation
- * of the node.  The planner makes sure it is valid before passing the node
- * tree to the executor, but during parsing/planning opfuncid can be 0.
- */
-typedef struct PGOpExpr {
-	PGExpr xpr;
-	PGOid opno;         /* PG_OPERATOR OID of the operator */
-	PGOid opfuncid;     /* PG_PROC OID of underlying function */
-	PGOid opresulttype; /* PG_TYPE OID of result value */
-	bool opretset;      /* true if operator returns set */
-	PGOid opcollid;     /* OID of collation of result */
-	PGOid inputcollid;  /* OID of collation that operator should use */
-	PGList *args;       /* arguments to the operator (1 or 2) */
-	int location;       /* token location, or -1 if unknown */
-} PGOpExpr;
-
-/*
- * DistinctExpr - expression node for "x IS DISTINCT FROM y"
- *
- * Except for the nodetag, this is represented identically to an PGOpExpr
- * referencing the "=" operator for x and y.
- * We use "=", not the more obvious "<>", because more datatypes have "="
- * than "<>".  This means the executor must invert the operator result.
- * Note that the operator function won't be called at all if either input
- * is NULL, since then the result can be determined directly.
- */
-typedef PGOpExpr DistinctExpr;
-
-/*
- * NullIfExpr - a NULLIF expression
- *
- * Like DistinctExpr, this is represented the same as an PGOpExpr referencing
- * the "=" operator for x and y.
- */
-typedef PGOpExpr NullIfExpr;
-
-/*
- * PGScalarArrayOpExpr - expression node for "scalar op ANY/ALL (array)"
- *
- * The operator must yield boolean.  It is applied to the left operand
- * and each element of the righthand array, and the results are combined
- * with OR or AND (for ANY or ALL respectively).  The node representation
- * is almost the same as for the underlying operator, but we need a useOr
- * flag to remember whether it's ANY or ALL, and we don't have to store
- * the result type (or the collation) because it must be boolean.
- */
-typedef struct PGScalarArrayOpExpr {
-	PGExpr xpr;
-	PGOid opno;        /* PG_OPERATOR OID of the operator */
-	PGOid opfuncid;    /* PG_PROC OID of underlying function */
-	bool useOr;        /* true for ANY, false for ALL */
-	PGOid inputcollid; /* OID of collation that operator should use */
-	PGList *args;      /* the scalar and array operands */
-	int location;      /* token location, or -1 if unknown */
-} PGScalarArrayOpExpr;
-
-/*
- * PGBoolExpr - expression node for the basic Boolean operators AND, OR, NOT
- *
- * Notice the arguments are given as a List.  For NOT, of course the list
- * must always have exactly one element.  For AND and OR, there can be two
- * or more arguments.
- */
-typedef enum PGBoolExprType { PG_AND_EXPR, PG_OR_EXPR, PG_NOT_EXPR } PGBoolExprType;
-
-typedef struct PGBoolExpr {
-	PGExpr xpr;
-	PGBoolExprType boolop;
-	PGList *args; /* arguments to this expression */
-	int location; /* token location, or -1 if unknown */
-} PGBoolExpr;
-
-/*
- * PGSubLink
- *
- * A PGSubLink represents a subselect appearing in an expression, and in some
- * cases also the combining operator(s) just above it.  The subLinkType
- * indicates the form of the expression represented:
- *	PG_EXISTS_SUBLINK		EXISTS(SELECT ...)
- *	PG_ALL_SUBLINK			(lefthand) op ALL (SELECT ...)
- *	PG_ANY_SUBLINK			(lefthand) op ANY (SELECT ...)
- *	PG_ROWCOMPARE_SUBLINK	(lefthand) op (SELECT ...)
- *	PG_EXPR_SUBLINK		(SELECT with single targetlist item ...)
- *	PG_MULTIEXPR_SUBLINK	(SELECT with multiple targetlist items ...)
- *	PG_ARRAY_SUBLINK		ARRAY(SELECT with single targetlist item ...)
- *	PG_CTE_SUBLINK			WITH query (never actually part of an expression)
- * For ALL, ANY, and ROWCOMPARE, the lefthand is a list of expressions of the
- * same length as the subselect's targetlist.  ROWCOMPARE will *always* have
- * a list with more than one entry; if the subselect has just one target
- * then the parser will create an PG_EXPR_SUBLINK instead (and any operator
- * above the subselect will be represented separately).
- * ROWCOMPARE, EXPR, and MULTIEXPR require the subselect to deliver at most
- * one row (if it returns no rows, the result is NULL).
- * ALL, ANY, and ROWCOMPARE require the combining operators to deliver boolean
- * results.  ALL and ANY combine the per-row results using AND and OR
- * semantics respectively.
- * ARRAY requires just one target column, and creates an array of the target
- * column's type using any number of rows resulting from the subselect.
- *
- * PGSubLink is classed as an PGExpr node, but it is not actually executable;
- * it must be replaced in the expression tree by a PGSubPlan node during
- * planning.
- *
- * NOTE: in the raw output of gram.y, testexpr contains just the raw form
- * of the lefthand expression (if any), and operName is the String name of
- * the combining operator.  Also, subselect is a raw parsetree.  During parse
- * analysis, the parser transforms testexpr into a complete boolean expression
- * that compares the lefthand value(s) to PG_PARAM_SUBLINK nodes representing the
- * output columns of the subselect.  And subselect is transformed to a Query.
- * This is the representation seen in saved rules and in the rewriter.
- *
- * In EXISTS, EXPR, MULTIEXPR, and ARRAY SubLinks, testexpr and operName
- * are unused and are always null.
- *
- * subLinkId is currently used only for MULTIEXPR SubLinks, and is zero in
- * other SubLinks.  This number identifies different multiple-assignment
- * subqueries within an UPDATE statement's SET list.  It is unique only
- * within a particular targetlist.  The output column(s) of the MULTIEXPR
- * are referenced by PG_PARAM_MULTIEXPR Params appearing elsewhere in the tlist.
- *
- * The PG_CTE_SUBLINK case never occurs in actual PGSubLink nodes, but it is used
- * in SubPlans generated for WITH subqueries.
- */
-typedef enum PGSubLinkType {
-	PG_EXISTS_SUBLINK,
-	PG_ALL_SUBLINK,
-	PG_ANY_SUBLINK,
-	PG_ROWCOMPARE_SUBLINK,
-	PG_EXPR_SUBLINK,
-	PG_MULTIEXPR_SUBLINK,
-	PG_ARRAY_SUBLINK,
-	PG_CTE_SUBLINK /* for SubPlans only */
-} PGSubLinkType;
-
-typedef struct PGSubLink {
-	PGExpr xpr;
-	PGSubLinkType subLinkType; /* see above */
-	int subLinkId;             /* ID (1..n); 0 if not MULTIEXPR */
-	PGNode *testexpr;          /* outer-query test for ALL/ANY/ROWCOMPARE */
-	PGList *operName;          /* originally specified operator name */
-	PGNode *subselect;         /* subselect as PGQuery* or raw parsetree */
-	int location;              /* token location, or -1 if unknown */
-} PGSubLink;
-
-/*
- * PGSubPlan - executable expression node for a subplan (sub-SELECT)
- *
- * The planner replaces PGSubLink nodes in expression trees with PGSubPlan
- * nodes after it has finished planning the subquery.  PGSubPlan references
- * a sub-plantree stored in the subplans list of the toplevel PlannedStmt.
- * (We avoid a direct link to make it easier to copy expression trees
- * without causing multiple processing of the subplan.)
- *
- * In an ordinary subplan, testexpr points to an executable expression
- * (PGOpExpr, an AND/OR tree of OpExprs, or PGRowCompareExpr) for the combining
- * operator(s); the left-hand arguments are the original lefthand expressions,
- * and the right-hand arguments are PG_PARAM_EXEC PGParam nodes representing the
- * outputs of the sub-select.  (NOTE: runtime coercion functions may be
- * inserted as well.)  This is just the same expression tree as testexpr in
- * the original PGSubLink node, but the PG_PARAM_SUBLINK nodes are replaced by
- * suitably numbered PG_PARAM_EXEC nodes.
- *
- * If the sub-select becomes an initplan rather than a subplan, the executable
- * expression is part of the outer plan's expression tree (and the PGSubPlan
- * node itself is not, but rather is found in the outer plan's initPlan
- * list).  In this case testexpr is NULL to avoid duplication.
- *
- * The planner also derives lists of the values that need to be passed into
- * and out of the subplan.  Input values are represented as a list "args" of
- * expressions to be evaluated in the outer-query context (currently these
- * args are always just Vars, but in principle they could be any expression).
- * The values are assigned to the global PG_PARAM_EXEC params indexed by parParam
- * (the parParam and args lists must have the same ordering).  setParam is a
- * list of the PG_PARAM_EXEC params that are computed by the sub-select, if it
- * is an initplan; they are listed in order by sub-select output column
- * position.  (parParam and setParam are integer Lists, not Bitmapsets,
- * because their ordering is significant.)
- *
- * Also, the planner computes startup and per-call costs for use of the
- * SubPlan.  Note that these include the cost of the subquery proper,
- * evaluation of the testexpr if any, and any hashtable management overhead.
- */
-typedef struct PGSubPlan {
-	PGExpr xpr;
-	/* Fields copied from original PGSubLink: */
-	PGSubLinkType subLinkType; /* see above */
-	/* The combining operators, transformed to an executable expression: */
-	PGNode *testexpr; /* PGOpExpr or PGRowCompareExpr expression tree */
-	PGList *paramIds; /* IDs of Params embedded in the above */
-	/* Identification of the PGPlan tree to use: */
-	int plan_id; /* PGIndex (from 1) in PlannedStmt.subplans */
-	/* Identification of the PGSubPlan for EXPLAIN and debugging purposes: */
-	char *plan_name; /* A name assigned during planning */
-	/* Extra data useful for determining subplan's output type: */
-	PGOid firstColType;      /* Type of first column of subplan result */
-	int32_t firstColTypmod;  /* Typmod of first column of subplan result */
-	PGOid firstColCollation; /* Collation of first column of subplan
-									 * result */
-	/* Information about execution strategy: */
-	bool useHashTable;   /* true to store subselect output in a hash
-								 * table (implies we are doing "IN") */
-	bool unknownEqFalse; /* true if it's okay to return false when the
-								 * spec result is UNKNOWN; this allows much
-								 * simpler handling of null values */
-	bool parallel_safe;  /* is the subplan parallel-safe? */
-	/* Note: parallel_safe does not consider contents of testexpr or args */
-	/* Information for passing params into and out of the subselect: */
-	/* setParam and parParam are lists of integers (param IDs) */
-	PGList *setParam; /* initplan subqueries have to set these
-								 * Params for parent plan */
-	PGList *parParam; /* indices of input Params from parent plan */
-	PGList *args;     /* exprs to pass as parParam values */
-	/* Estimated execution costs: */
-	Cost startup_cost;  /* one-time setup cost */
-	Cost per_call_cost; /* cost for each subplan evaluation */
-} PGSubPlan;
-
-/*
- * PGAlternativeSubPlan - expression node for a choice among SubPlans
- *
- * The subplans are given as a PGList so that the node definition need not
- * change if there's ever more than two alternatives.  For the moment,
- * though, there are always exactly two; and the first one is the fast-start
- * plan.
- */
-typedef struct PGAlternativeSubPlan {
-	PGExpr xpr;
-	PGList *subplans; /* SubPlan(s) with equivalent results */
-} PGAlternativeSubPlan;
-
-/* ----------------
- * PGFieldSelect
- *
- * PGFieldSelect represents the operation of extracting one field from a tuple
- * value.  At runtime, the input expression is expected to yield a rowtype
- * Datum.  The specified field number is extracted and returned as a Datum.
- * ----------------
- */
-
-typedef struct PGFieldSelect {
-	PGExpr xpr;
-	PGExpr *arg;           /* input expression */
-	PGAttrNumber fieldnum; /* attribute number of field to extract */
-	PGOid resulttype;      /* type of the field (result type of this
-								 * node) */
-	int32_t resulttypmod;  /* output typmod (usually -1) */
-	PGOid resultcollid;    /* OID of collation of the field */
-} PGFieldSelect;
-
-/* ----------------
- * PGFieldStore
- *
- * PGFieldStore represents the operation of modifying one field in a tuple
- * value, yielding a new tuple value (the input is not touched!).  Like
- * the assign case of PGArrayRef, this is used to implement UPDATE of a
- * portion of a column.
- *
- * A single PGFieldStore can actually represent updates of several different
- * fields.  The parser only generates FieldStores with single-element lists,
- * but the planner will collapse multiple updates of the same base column
- * into one FieldStore.
- * ----------------
- */
-
-typedef struct PGFieldStore {
-	PGExpr xpr;
-	PGExpr *arg;       /* input tuple value */
-	PGList *newvals;   /* new value(s) for field(s) */
-	PGList *fieldnums; /* integer list of field attnums */
-	PGOid resulttype;  /* type of result (same as type of arg) */
-	                   /* Like PGRowExpr, we deliberately omit a typmod and collation here */
-} PGFieldStore;
-
-/* ----------------
- * PGRelabelType
- *
- * PGRelabelType represents a "dummy" type coercion between two binary-
- * compatible datatypes, such as reinterpreting the result of an OID
- * expression as an int4.  It is a no-op at runtime; we only need it
- * to provide a place to store the correct type to be attributed to
- * the expression result during type resolution.  (We can't get away
- * with just overwriting the type field of the input expression node,
- * so we need a separate node to show the coercion's result type.)
- * ----------------
- */
-
-typedef struct PGRelabelType {
-	PGExpr xpr;
-	PGExpr *arg;                  /* input expression */
-	PGOid resulttype;             /* output type of coercion expression */
-	int32_t resulttypmod;         /* output typmod (usually -1) */
-	PGOid resultcollid;           /* OID of collation, or InvalidOid if none */
-	PGCoercionForm relabelformat; /* how to display this node */
-	int location;                 /* token location, or -1 if unknown */
-} PGRelabelType;
-
-/* ----------------
- * PGCoerceViaIO
- *
- * PGCoerceViaIO represents a type coercion between two types whose textual
- * representations are compatible, implemented by invoking the source type's
- * typoutput function then the destination type's typinput function.
- * ----------------
- */
-
-typedef struct PGCoerceViaIO {
-	PGExpr xpr;
-	PGExpr *arg;      /* input expression */
-	PGOid resulttype; /* output type of coercion */
-	/* output typmod is not stored, but is presumed -1 */
-	PGOid resultcollid;          /* OID of collation, or InvalidOid if none */
-	PGCoercionForm coerceformat; /* how to display this node */
-	int location;                /* token location, or -1 if unknown */
-} PGCoerceViaIO;
-
-/* ----------------
- * PGArrayCoerceExpr
- *
- * PGArrayCoerceExpr represents a type coercion from one array type to another,
- * which is implemented by applying the indicated element-type coercion
- * function to each element of the source array.  If elemfuncid is InvalidOid
- * then the element types are binary-compatible, but the coercion still
- * requires some effort (we have to fix the element type ID stored in the
- * array header).
- * ----------------
- */
-
-typedef struct PGArrayCoerceExpr {
-	PGExpr xpr;
-	PGExpr *arg;                 /* input expression (yields an array) */
-	PGOid elemfuncid;            /* OID of element coercion function, or 0 */
-	PGOid resulttype;            /* output type of coercion (an array type) */
-	int32_t resulttypmod;        /* output typmod (also element typmod) */
-	PGOid resultcollid;          /* OID of collation, or InvalidOid if none */
-	bool isExplicit;             /* conversion semantics flag to pass to func */
-	PGCoercionForm coerceformat; /* how to display this node */
-	int location;                /* token location, or -1 if unknown */
-} PGArrayCoerceExpr;
-
-/* ----------------
- * PGConvertRowtypeExpr
- *
- * PGConvertRowtypeExpr represents a type coercion from one composite type
- * to another, where the source type is guaranteed to contain all the columns
- * needed for the destination type plus possibly others; the columns need not
- * be in the same positions, but are matched up by name.  This is primarily
- * used to convert a whole-row value of an inheritance child table into a
- * valid whole-row value of its parent table's rowtype.
- * ----------------
- */
-
-typedef struct PGConvertRowtypeExpr {
-	PGExpr xpr;
-	PGExpr *arg;      /* input expression */
-	PGOid resulttype; /* output type (always a composite type) */
-	/* Like PGRowExpr, we deliberately omit a typmod and collation here */
-	PGCoercionForm convertformat; /* how to display this node */
-	int location;                 /* token location, or -1 if unknown */
-} PGConvertRowtypeExpr;
-
-/*----------
- * PGCollateExpr - COLLATE
- *
- * The planner replaces PGCollateExpr with PGRelabelType during expression
- * preprocessing, so execution never sees a CollateExpr.
- *----------
- */
-typedef struct PGCollateExpr {
-	PGExpr xpr;
-	PGExpr *arg;   /* input expression */
-	PGOid collOid; /* collation's OID */
-	int location;  /* token location, or -1 if unknown */
-} PGCollateExpr;
-
-/*----------
- * PGCaseExpr - a CASE expression
- *
- * We support two distinct forms of CASE expression:
- *		CASE WHEN boolexpr THEN expr [ WHEN boolexpr THEN expr ... ]
- *		CASE testexpr WHEN compexpr THEN expr [ WHEN compexpr THEN expr ... ]
- * These are distinguishable by the "arg" field being NULL in the first case
- * and the testexpr in the second case.
- *
- * In the raw grammar output for the second form, the condition expressions
- * of the WHEN clauses are just the comparison values.  Parse analysis
- * converts these to valid boolean expressions of the form
- *		PGCaseTestExpr '=' compexpr
- * where the PGCaseTestExpr node is a placeholder that emits the correct
- * value at runtime.  This structure is used so that the testexpr need be
- * evaluated only once.  Note that after parse analysis, the condition
- * expressions always yield boolean.
- *
- * Note: we can test whether a PGCaseExpr has been through parse analysis
- * yet by checking whether casetype is InvalidOid or not.
- *----------
- */
-typedef struct PGCaseExpr {
-	PGExpr xpr;
-	PGOid casetype;    /* type of expression result */
-	PGOid casecollid;  /* OID of collation, or InvalidOid if none */
-	PGExpr *arg;       /* implicit equality comparison argument */
-	PGList *args;      /* the arguments (list of WHEN clauses) */
-	PGExpr *defresult; /* the default result (ELSE clause) */
-	int location;      /* token location, or -1 if unknown */
-} PGCaseExpr;
-
-/*
- * PGCaseWhen - one arm of a CASE expression
- */
-typedef struct PGCaseWhen {
-	PGExpr xpr;
-	PGExpr *expr;   /* condition expression */
-	PGExpr *result; /* substitution result */
-	int location;   /* token location, or -1 if unknown */
-} PGCaseWhen;
-
-/*
- * Placeholder node for the test value to be processed by a CASE expression.
- * This is effectively like a PGParam, but can be implemented more simply
- * since we need only one replacement value at a time.
- *
- * We also use this in nested UPDATE expressions.
- * See transformAssignmentIndirection().
- */
-typedef struct PGCaseTestExpr {
-	PGExpr xpr;
-	PGOid typeId;    /* type for substituted value */
-	int32_t typeMod; /* typemod for substituted value */
-	PGOid collation; /* collation for the substituted value */
-} PGCaseTestExpr;
-
-/*
- * PGArrayExpr - an ARRAY[] expression
- *
- * Note: if multidims is false, the constituent expressions all yield the
- * scalar type identified by element_typeid.  If multidims is true, the
- * constituent expressions all yield arrays of element_typeid (ie, the same
- * type as array_typeid); at runtime we must check for compatible subscripts.
- */
-typedef struct PGArrayExpr {
-	PGExpr xpr;
-	PGOid array_typeid;   /* type of expression result */
-	PGOid array_collid;   /* OID of collation, or InvalidOid if none */
-	PGOid element_typeid; /* common type of array elements */
-	PGList *elements;     /* the array elements or sub-arrays */
-	bool multidims;       /* true if elements are sub-arrays */
-	int location;         /* token location, or -1 if unknown */
-} PGArrayExpr;
-
-/*
- * PGRowExpr - a ROW() expression
- *
- * Note: the list of fields must have a one-for-one correspondence with
- * physical fields of the associated rowtype, although it is okay for it
- * to be shorter than the rowtype.  That is, the N'th list element must
- * match up with the N'th physical field.  When the N'th physical field
- * is a dropped column (attisdropped) then the N'th list element can just
- * be a NULL constant.  (This case can only occur for named composite types,
- * not RECORD types, since those are built from the PGRowExpr itself rather
- * than vice versa.)  It is important not to assume that length(args) is
- * the same as the number of columns logically present in the rowtype.
- *
- * colnames provides field names in cases where the names can't easily be
- * obtained otherwise.  Names *must* be provided if row_typeid is RECORDOID.
- * If row_typeid identifies a known composite type, colnames can be NIL to
- * indicate the type's cataloged field names apply.  Note that colnames can
- * be non-NIL even for a composite type, and typically is when the PGRowExpr
- * was created by expanding a whole-row Var.  This is so that we can retain
- * the column alias names of the RTE that the PGVar referenced (which would
- * otherwise be very difficult to extract from the parsetree).  Like the
- * args list, colnames is one-for-one with physical fields of the rowtype.
- */
-typedef struct PGRowExpr {
-	PGExpr xpr;
-	PGList *args;     /* the fields */
-	PGOid row_typeid; /* RECORDOID or a composite type's ID */
-
-	/*
-	 * Note: we deliberately do NOT store a typmod.  Although a typmod will be
-	 * associated with specific RECORD types at runtime, it will differ for
-	 * different backends, and so cannot safely be stored in stored
-	 * parsetrees.  We must assume typmod -1 for a PGRowExpr node.
-	 *
-	 * We don't need to store a collation either.  The result type is
-	 * necessarily composite, and composite types never have a collation.
-	 */
-	PGCoercionForm row_format; /* how to display this node */
-	PGList *colnames;          /* list of String, or NIL */
-	int location;              /* token location, or -1 if unknown */
-} PGRowExpr;
-
-/*
- * PGRowCompareExpr - row-wise comparison, such as (a, b) <= (1, 2)
- *
- * We support row comparison for any operator that can be determined to
- * act like =, <>, <, <=, >, or >= (we determine this by looking for the
- * operator in btree opfamilies).  Note that the same operator name might
- * map to a different operator for each pair of row elements, since the
- * element datatypes can vary.
- *
- * A PGRowCompareExpr node is only generated for the < <= > >= cases;
- * the = and <> cases are translated to simple AND or OR combinations
- * of the pairwise comparisons.  However, we include = and <> in the
- * PGRowCompareType enum for the convenience of parser logic.
- */
-typedef enum PGRowCompareType {
-	/* Values of this enum are chosen to match btree strategy numbers */
-	PG_ROWCOMPARE_LT = 1, /* BTLessStrategyNumber */
-	PG_ROWCOMPARE_LE = 2, /* BTLessEqualStrategyNumber */
-	PG_ROWCOMPARE_EQ = 3, /* BTEqualStrategyNumber */
-	PG_ROWCOMPARE_GE = 4, /* BTGreaterEqualStrategyNumber */
-	PG_ROWCOMPARE_GT = 5, /* BTGreaterStrategyNumber */
-	PG_ROWCOMPARE_NE = 6  /* no such btree strategy */
-} PGRowCompareType;
-
-typedef struct PGRowCompareExpr {
-	PGExpr xpr;
-	PGRowCompareType rctype; /* LT LE GE or GT, never EQ or NE */
-	PGList *opnos;           /* OID list of pairwise comparison ops */
-	PGList *opfamilies;      /* OID list of containing operator families */
-	PGList *inputcollids;    /* OID list of collations for comparisons */
-	PGList *largs;           /* the left-hand input arguments */
-	PGList *rargs;           /* the right-hand input arguments */
-} PGRowCompareExpr;
-
-/*
- * PGCoalesceExpr - a COALESCE expression
- */
-typedef struct PGCoalesceExpr {
-	PGExpr xpr;
-	PGOid coalescetype;   /* type of expression result */
-	PGOid coalescecollid; /* OID of collation, or InvalidOid if none */
-	PGList *args;         /* the arguments */
-	int location;         /* token location, or -1 if unknown */
-} PGCoalesceExpr;
-
-/*
- * PGMinMaxExpr - a GREATEST or LEAST function
- */
-typedef enum PGMinMaxOp { PG_IS_GREATEST, IS_LEAST } PGMinMaxOp;
-
-typedef struct PGMinMaxExpr {
-	PGExpr xpr;
-	PGOid minmaxtype;   /* common type of arguments and result */
-	PGOid minmaxcollid; /* OID of collation of result */
-	PGOid inputcollid;  /* OID of collation that function should use */
-	PGMinMaxOp op;      /* function to execute */
-	PGList *args;       /* the arguments */
-	int location;       /* token location, or -1 if unknown */
-} PGMinMaxExpr;
-
-/*
- * PGSQLValueFunction - parameterless functions with special grammar productions
- *
- * The SQL standard categorizes some of these as <datetime value function>
- * and others as <general value specification>.  We call 'em SQLValueFunctions
- * for lack of a better term.  We store type and typmod of the result so that
- * some code doesn't need to know each function individually, and because
- * we would need to store typmod anyway for some of the datetime functions.
- * Note that currently, all variants return non-collating datatypes, so we do
- * not need a collation field; also, all these functions are stable.
- */
-typedef enum PGSQLValueFunctionOp {
-	PG_SVFOP_CURRENT_DATE,
-	PG_SVFOP_CURRENT_TIME,
-	PG_SVFOP_CURRENT_TIME_N,
-	PG_SVFOP_CURRENT_TIMESTAMP,
-	PG_SVFOP_CURRENT_TIMESTAMP_N,
-	PG_SVFOP_LOCALTIME,
-	PG_SVFOP_LOCALTIME_N,
-	PG_SVFOP_LOCALTIMESTAMP,
-	PG_SVFOP_LOCALTIMESTAMP_N,
-	PG_SVFOP_CURRENT_ROLE,
-	PG_SVFOP_CURRENT_USER,
-	PG_SVFOP_USER,
-	PG_SVFOP_SESSION_USER,
-	PG_SVFOP_CURRENT_CATALOG,
-	PG_SVFOP_CURRENT_SCHEMA
-} PGSQLValueFunctionOp;
-
-typedef struct PGSQLValueFunction {
-	PGExpr xpr;
-	PGSQLValueFunctionOp op; /* which function this is */
-	PGOid type;              /* result type/typmod */
-	int32_t typmod;
-	int location; /* token location, or -1 if unknown */
-} PGSQLValueFunction;
-
-/* ----------------
- * PGNullTest
- *
- * PGNullTest represents the operation of testing a value for NULLness.
- * The appropriate test is performed and returned as a boolean Datum.
- *
- * When argisrow is false, this simply represents a test for the null value.
- *
- * When argisrow is true, the input expression must yield a rowtype, and
- * the node implements "row IS [NOT] NULL" per the SQL standard.  This
- * includes checking individual fields for NULLness when the row datum
- * itself isn't NULL.
- *
- * NOTE: the combination of a rowtype input and argisrow==false does NOT
- * correspond to the SQL notation "row IS [NOT] NULL"; instead, this case
- * represents the SQL notation "row IS [NOT] DISTINCT FROM NULL".
- * ----------------
- */
-
-typedef enum PGNullTestType { PG_IS_NULL, IS_NOT_NULL } PGNullTestType;
-
-typedef struct PGNullTest {
-	PGExpr xpr;
-	PGExpr *arg;                 /* input expression */
-	PGNullTestType nulltesttype; /* IS NULL, IS NOT NULL */
-	bool argisrow;               /* T to perform field-by-field null checks */
-	int location;                /* token location, or -1 if unknown */
-} PGNullTest;
-
-/*
- * PGBooleanTest
- *
- * PGBooleanTest represents the operation of determining whether a boolean
- * is true, false, or UNKNOWN (ie, NULL).  All six meaningful combinations
- * are supported.  Note that a NULL input does *not* cause a NULL result.
- * The appropriate test is performed and returned as a boolean Datum.
- */
-
-typedef enum PGBoolTestType {
-	PG_IS_TRUE,
-	IS_NOT_TRUE,
-	IS_FALSE,
-	IS_NOT_FALSE,
-	IS_UNKNOWN,
-	IS_NOT_UNKNOWN
-} PGBoolTestType;
-
-typedef struct PGBooleanTest {
-	PGExpr xpr;
-	PGExpr *arg;                 /* input expression */
-	PGBoolTestType booltesttype; /* test type */
-	int location;                /* token location, or -1 if unknown */
-} PGBooleanTest;
-
-/*
- * PGCoerceToDomain
- *
- * PGCoerceToDomain represents the operation of coercing a value to a domain
- * type.  At runtime (and not before) the precise set of constraints to be
- * checked will be determined.  If the value passes, it is returned as the
- * result; if not, an error is raised.  Note that this is equivalent to
- * PGRelabelType in the scenario where no constraints are applied.
- */
-typedef struct PGCoerceToDomain {
-	PGExpr xpr;
-	PGExpr *arg;                   /* input expression */
-	PGOid resulttype;              /* domain type ID (result type) */
-	int32_t resulttypmod;          /* output typmod (currently always -1) */
-	PGOid resultcollid;            /* OID of collation, or InvalidOid if none */
-	PGCoercionForm coercionformat; /* how to display this node */
-	int location;                  /* token location, or -1 if unknown */
-} PGCoerceToDomain;
-
-/*
- * Placeholder node for the value to be processed by a domain's check
- * constraint.  This is effectively like a PGParam, but can be implemented more
- * simply since we need only one replacement value at a time.
- *
- * Note: the typeId/typeMod/collation will be set from the domain's base type,
- * not the domain itself.  This is because we shouldn't consider the value
- * to be a member of the domain if we haven't yet checked its constraints.
- */
-typedef struct PGCoerceToDomainValue {
-	PGExpr xpr;
-	PGOid typeId;    /* type for substituted value */
-	int32_t typeMod; /* typemod for substituted value */
-	PGOid collation; /* collation for the substituted value */
-	int location;    /* token location, or -1 if unknown */
-} PGCoerceToDomainValue;
-
-/*
- * Placeholder node for a DEFAULT marker in an INSERT or UPDATE command.
- *
- * This is not an executable expression: it must be replaced by the actual
- * column default expression during rewriting.  But it is convenient to
- * treat it as an expression node during parsing and rewriting.
- */
-typedef struct PGSetToDefault {
-	PGExpr xpr;
-	PGOid typeId;    /* type for substituted value */
-	int32_t typeMod; /* typemod for substituted value */
-	PGOid collation; /* collation for the substituted value */
-	int location;    /* token location, or -1 if unknown */
-} PGSetToDefault;
-
-/*
- * PGNode representing [WHERE] CURRENT OF cursor_name
- *
- * CURRENT OF is a bit like a PGVar, in that it carries the rangetable index
- * of the target relation being constrained; this aids placing the expression
- * correctly during planning.  We can assume however that its "levelsup" is
- * always zero, due to the syntactic constraints on where it can appear.
- *
- * The referenced cursor can be represented either as a hardwired string
- * or as a reference to a run-time parameter of type REFCURSOR.  The latter
- * case is for the convenience of plpgsql.
- */
-typedef struct PGCurrentOfExpr {
-	PGExpr xpr;
-	PGIndex cvarno;    /* RT index of target relation */
-	char *cursor_name; /* name of referenced cursor, or NULL */
-	int cursor_param;  /* refcursor parameter number, or 0 */
-} PGCurrentOfExpr;
-
-/*
- * PGNextValueExpr - get next value from sequence
- *
- * This has the same effect as calling the nextval() function, but it does not
- * check permissions on the sequence.  This is used for identity columns,
- * where the sequence is an implicit dependency without its own permissions.
- */
-typedef struct PGNextValueExpr {
-	PGExpr xpr;
-	PGOid seqid;
-	PGOid typeId;
-} PGNextValueExpr;
-
-/*
- * PGInferenceElem - an element of a unique index inference specification
- *
- * This mostly matches the structure of IndexElems, but having a dedicated
- * primnode allows for a clean separation between the use of index parameters
- * by utility commands, and this node.
- */
-typedef struct PGInferenceElem {
-	PGExpr xpr;
-	PGNode *expr;       /* expression to infer from, or NULL */
-	PGOid infercollid;  /* OID of collation, or InvalidOid */
-	PGOid inferopclass; /* OID of att opclass, or InvalidOid */
-} PGInferenceElem;
-
-/*--------------------
- * PGTargetEntry -
- *	   a target entry (used in query target lists)
- *
- * Strictly speaking, a PGTargetEntry isn't an expression node (since it can't
- * be evaluated by ExecEvalExpr).  But we treat it as one anyway, since in
- * very many places it's convenient to process a whole query targetlist as a
- * single expression tree.
- *
- * In a SELECT's targetlist, resno should always be equal to the item's
- * ordinal position (counting from 1).  However, in an INSERT or UPDATE
- * targetlist, resno represents the attribute number of the destination
- * column for the item; so there may be missing or out-of-order resnos.
- * It is even legal to have duplicated resnos; consider
- *		UPDATE table SET arraycol[1] = ..., arraycol[2] = ..., ...
- * The two meanings come together in the executor, because the planner
- * transforms INSERT/UPDATE tlists into a normalized form with exactly
- * one entry for each column of the destination table.  Before that's
- * happened, however, it is risky to assume that resno == position.
- * Generally get_tle_by_resno() should be used rather than list_nth()
- * to fetch tlist entries by resno, and only in SELECT should you assume
- * that resno is a unique identifier.
- *
- * resname is required to represent the correct column name in non-resjunk
- * entries of top-level SELECT targetlists, since it will be used as the
- * column title sent to the frontend.  In most other contexts it is only
- * a debugging aid, and may be wrong or even NULL.  (In particular, it may
- * be wrong in a tlist from a stored rule, if the referenced column has been
- * renamed by ALTER TABLE since the rule was made.  Also, the planner tends
- * to store NULL rather than look up a valid name for tlist entries in
- * non-toplevel plan nodes.)  In resjunk entries, resname should be either
- * a specific system-generated name (such as "ctid") or NULL; anything else
- * risks confusing ExecGetJunkAttribute!
- *
- * ressortgroupref is used in the representation of ORDER BY, GROUP BY, and
- * DISTINCT items.  Targetlist entries with ressortgroupref=0 are not
- * sort/group items.  If ressortgroupref>0, then this item is an ORDER BY,
- * GROUP BY, and/or DISTINCT target value.  No two entries in a targetlist
- * may have the same nonzero ressortgroupref --- but there is no particular
- * meaning to the nonzero values, except as tags.  (For example, one must
- * not assume that lower ressortgroupref means a more significant sort key.)
- * The order of the associated PGSortGroupClause lists determine the semantics.
- *
- * resorigtbl/resorigcol identify the source of the column, if it is a
- * simple reference to a column of a base table (or view).  If it is not
- * a simple reference, these fields are zeroes.
- *
- * If resjunk is true then the column is a working column (such as a sort key)
- * that should be removed from the final output of the query.  Resjunk columns
- * must have resnos that cannot duplicate any regular column's resno.  Also
- * note that there are places that assume resjunk columns come after non-junk
- * columns.
- *--------------------
- */
-typedef struct PGTargetEntry {
-	PGExpr xpr;
-	PGExpr *expr;            /* expression to evaluate */
-	PGAttrNumber resno;      /* attribute number (see notes above) */
-	char *resname;           /* name of the column (could be NULL) */
-	PGIndex ressortgroupref; /* nonzero if referenced by a sort/group
-									 * clause */
-	PGOid resorigtbl;        /* OID of column's source table */
-	PGAttrNumber resorigcol; /* column's number in source table */
-	bool resjunk;            /* set to true to eliminate the attribute from
-								 * final target list */
-} PGTargetEntry;
-
-/* ----------------------------------------------------------------
- *					node types for join trees
- *
- * The leaves of a join tree structure are PGRangeTblRef nodes.  Above
- * these, PGJoinExpr nodes can appear to denote a specific kind of join
- * or qualified join.  Also, PGFromExpr nodes can appear to denote an
- * ordinary cross-product join ("FROM foo, bar, baz WHERE ...").
- * PGFromExpr is like a PGJoinExpr of jointype PG_JOIN_INNER, except that it
- * may have any number of child nodes, not just two.
- *
- * NOTE: the top level of a Query's jointree is always a FromExpr.
- * Even if the jointree contains no rels, there will be a FromExpr.
- *
- * NOTE: the qualification expressions present in PGJoinExpr nodes are
- * *in addition to* the query's main WHERE clause, which appears as the
- * qual of the top-level FromExpr.  The reason for associating quals with
- * specific nodes in the jointree is that the position of a qual is critical
- * when outer joins are present.  (If we enforce a qual too soon or too late,
- * that may cause the outer join to produce the wrong set of NULL-extended
- * rows.)  If all joins are inner joins then all the qual positions are
- * semantically interchangeable.
- *
- * NOTE: in the raw output of gram.y, a join tree contains PGRangeVar,
- * PGRangeSubselect, and PGRangeFunction nodes, which are all replaced by
- * PGRangeTblRef nodes during the parse analysis phase.  Also, the top-level
- * PGFromExpr is added during parse analysis; the grammar regards FROM and
- * WHERE as separate.
- * ----------------------------------------------------------------
- */
-
-/*
- * PGRangeTblRef - reference to an entry in the query's rangetable
- *
- * We could use direct pointers to the RT entries and skip having these
- * nodes, but multiple pointers to the same node in a querytree cause
- * lots of headaches, so it seems better to store an index into the RT.
- */
-typedef struct PGRangeTblRef {
-	PGNodeTag type;
-	int rtindex;
-} PGRangeTblRef;
-
-/*----------
- * PGJoinExpr - for SQL JOIN expressions
- *
- * isNatural, usingClause, and quals are interdependent.  The user can write
- * only one of NATURAL, USING(), or ON() (this is enforced by the grammar).
- * If he writes NATURAL then parse analysis generates the equivalent USING()
- * list, and from that fills in "quals" with the right equality comparisons.
- * If he writes USING() then "quals" is filled with equality comparisons.
- * If he writes ON() then only "quals" is set.  Note that NATURAL/USING
- * are not equivalent to ON() since they also affect the output column list.
- *
- * alias is an PGAlias node representing the AS alias-clause attached to the
- * join expression, or NULL if no clause.  NB: presence or absence of the
- * alias has a critical impact on semantics, because a join with an alias
- * restricts visibility of the tables/columns inside it.
- *
- * During parse analysis, an RTE is created for the PGJoin, and its index
- * is filled into rtindex.  This RTE is present mainly so that Vars can
- * be created that refer to the outputs of the join.  The planner sometimes
- * generates JoinExprs internally; these can have rtindex = 0 if there are
- * no join alias variables referencing such joins.
- *----------
- */
-typedef struct PGJoinExpr {
-	PGNodeTag type;
-	PGJoinType jointype; /* type of join */
-	bool isNatural;      /* Natural join? Will need to shape table */
-	PGNode *larg;        /* left subtree */
-	PGNode *rarg;        /* right subtree */
-	PGList *usingClause; /* USING clause, if any (list of String) */
-	PGNode *quals;       /* qualifiers on join, if any */
-	PGAlias *alias;      /* user-written alias clause, if any */
-	int rtindex;         /* RT index assigned for join, or 0 */
-	int location;          /* token location, or -1 if unknown */
-} PGJoinExpr;
-
-/*----------
- * PGFromExpr - represents a FROM ... WHERE ... construct
- *
- * This is both more flexible than a PGJoinExpr (it can have any number of
- * children, including zero) and less so --- we don't need to deal with
- * aliases and so on.  The output column set is implicitly just the union
- * of the outputs of the children.
- *----------
- */
-typedef struct PGFromExpr {
-	PGNodeTag type;
-	PGList *fromlist; /* PGList of join subtrees */
-	PGNode *quals;    /* qualifiers on join, if any */
-} PGFromExpr;
-
-/*----------
- * PGOnConflictExpr - represents an ON CONFLICT DO ... expression
- *
- * The optimizer requires a list of inference elements, and optionally a WHERE
- * clause to infer a unique index.  The unique index (or, occasionally,
- * indexes) inferred are used to arbitrate whether or not the alternative ON
- * CONFLICT path is taken.
- *----------
- */
-typedef struct PGOnConflictExpr {
-	PGNodeTag type;
-	PGOnConflictAction action; /* DO NOTHING or UPDATE? */
-
-	/* Arbiter */
-	PGList *arbiterElems; /* unique index arbiter list (of
-								 * InferenceElem's) */
-	PGNode *arbiterWhere; /* unique index arbiter WHERE clause */
-	PGOid constraint;     /* pg_constraint OID for arbiter */
-
-	/* ON CONFLICT UPDATE */
-	PGList *onConflictSet;   /* PGList of ON CONFLICT SET TargetEntrys */
-	PGNode *onConflictWhere; /* qualifiers to restrict UPDATE to */
-	int exclRelIndex;        /* RT index of 'excluded' relation */
-	PGList *exclRelTlist;    /* tlist of the EXCLUDED pseudo relation */
-} PGOnConflictExpr;
-
-}
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * value.h
- *	  interface for PGValue nodes
- *
- *
- * Copyright (c) 2003-2017, PostgreSQL Global Development PGGroup
- *
- * src/include/nodes/value.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-
-namespace duckdb_libpgquery {
-
-/*----------------------
- *		PGValue node
- *
- * The same PGValue struct is used for five node types: duckdb_libpgquery::T_PGInteger,
- * duckdb_libpgquery::T_PGFloat, duckdb_libpgquery::T_PGString, duckdb_libpgquery::T_PGBitString, T_Null.
- *
- * Integral values are actually represented by a machine integer,
- * but both floats and strings are represented as strings.
- * Using duckdb_libpgquery::T_PGFloat as the node type simply indicates that
- * the contents of the string look like a valid numeric literal.
- *
- * (Before Postgres 7.0, we used a double to represent duckdb_libpgquery::T_PGFloat,
- * but that creates loss-of-precision problems when the value is
- * ultimately destined to be converted to NUMERIC.  Since PGValue nodes
- * are only used in the parsing process, not for runtime data, it's
- * better to use the more general representation.)
- *
- * Note that an integer-looking string will get lexed as duckdb_libpgquery::T_PGFloat if
- * the value is too large to fit in a 'long'.
- *
- * Nulls, of course, don't need the value part at all.
- *----------------------
- */
-typedef struct PGValue {
-	PGNodeTag type; /* tag appropriately (eg. duckdb_libpgquery::T_PGString) */
-	union ValUnion {
-		long ival; /* machine integer */
-		char *str; /* string */
-	} val;
-} PGValue;
-
-#define intVal(v) (((PGValue *)(v))->val.ival)
-#define floatVal(v) atof(((PGValue *)(v))->val.str)
-#define strVal(v) (((PGValue *)(v))->val.str)
-
-PGValue *makeInteger(long i);
-PGValue *makeFloat(char *numericStr);
-PGValue *makeString(const char *str);
-PGValue *makeBitString(char *str);
-
-}
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_libpgquery {
-
-typedef enum PGOverridingKind {
-	PG_OVERRIDING_NOT_SET = 0,
-	PG_OVERRIDING_USER_VALUE,
-	OVERRIDING_SYSTEM_VALUE
-} PGOverridingKind;
-
-/* Possible sources of a PGQuery */
-typedef enum PGQuerySource {
-	PG_QSRC_ORIGINAL,          /* original parsetree (explicit query) */
-	PG_QSRC_PARSER,            /* added by parse analysis (now unused) */
-	PG_QSRC_INSTEAD_RULE,      /* added by unconditional INSTEAD rule */
-	PG_QSRC_QUAL_INSTEAD_RULE, /* added by conditional INSTEAD rule */
-	QSRC_NON_INSTEAD_RULE      /* added by non-INSTEAD rule */
-} PGQuerySource;
-
-/* PGSort ordering options for ORDER BY and CREATE INDEX */
-typedef enum PGSortByDir {
-	PG_SORTBY_DEFAULT,
-	PG_SORTBY_ASC,
-	PG_SORTBY_DESC,
-	SORTBY_USING /* not allowed in CREATE INDEX ... */
-} PGSortByDir;
-
-typedef enum PGSortByNulls { PG_SORTBY_NULLS_DEFAULT, PG_SORTBY_NULLS_FIRST, PG_SORTBY_NULLS_LAST } PGSortByNulls;
-
-/*****************************************************************************
- *	PGQuery Tree
- *****************************************************************************/
-
-/*
- * PGQuery -
- *	  Parse analysis turns all statements into a PGQuery tree
- *	  for further processing by the rewriter and planner.
- *
- *	  Utility statements (i.e. non-optimizable statements) have the
- *	  utilityStmt field set, and the rest of the PGQuery is mostly dummy.
- *
- *	  Planning converts a PGQuery tree into a PGPlan tree headed by a PGPlannedStmt
- *	  node --- the PGQuery structure is not used by the executor.
- */
-typedef struct PGQuery {
-	PGNodeTag type;
-
-	PGCmdType commandType; /* select|insert|update|delete|utility */
-
-	PGQuerySource querySource; /* where did I come from? */
-
-	uint32_t queryId; /* query identifier (can be set by plugins) */
-
-	bool canSetTag; /* do I set the command result tag? */
-
-	PGNode *utilityStmt; /* non-null if commandType == PG_CMD_UTILITY */
-
-	int resultRelation; /* rtable index of target relation for
-								 * INSERT/UPDATE/DELETE; 0 for SELECT */
-
-	bool hasAggs;         /* has aggregates in tlist or havingQual */
-	bool hasWindowFuncs;  /* has window functions in tlist */
-	bool hasTargetSRFs;   /* has set-returning functions in tlist */
-	bool hasSubLinks;     /* has subquery PGSubLink */
-	bool hasDistinctOn;   /* distinctClause is from DISTINCT ON */
-	bool hasRecursive;    /* WITH RECURSIVE was specified */
-	bool hasModifyingCTE; /* has INSERT/UPDATE/DELETE in WITH */
-	bool hasForUpdate;    /* FOR [KEY] UPDATE/SHARE was specified */
-	bool hasRowSecurity;  /* rewriter has applied some RLS policy */
-
-	PGList *cteList; /* WITH list (of CommonTableExpr's) */
-
-	PGList *rtable;       /* list of range table entries */
-	PGFromExpr *jointree; /* table join tree (FROM and WHERE clauses) */
-
-	PGList *targetList; /* target list (of PGTargetEntry) */
-
-	PGOverridingKind override; /* OVERRIDING clause */
-
-	PGOnConflictExpr *onConflict; /* ON CONFLICT DO [NOTHING | UPDATE] */
-
-	PGList *returningList; /* return-values list (of PGTargetEntry) */
-
-	PGList *groupClause; /* a list of SortGroupClause's */
-
-	PGList *groupingSets; /* a list of GroupingSet's if present */
-
-	PGNode *havingQual; /* qualifications applied to groups */
-
-	PGList *windowClause; /* a list of WindowClause's */
-
-	PGList *distinctClause; /* a list of SortGroupClause's */
-
-	PGList *sortClause; /* a list of SortGroupClause's */
-
-	PGNode *limitOffset; /* # of result tuples to skip (int8_t expr) */
-	PGNode *limitCount;  /* # of result tuples to return (int8_t expr) */
-
-	PGList *rowMarks; /* a list of RowMarkClause's */
-
-	PGNode *setOperations; /* set-operation tree if this is top level of
-								 * a UNION/INTERSECT/EXCEPT query */
-
-	PGList *constraintDeps; /* a list of pg_constraint OIDs that the query
-								 * depends on to be semantically valid */
-
-	PGList *withCheckOptions; /* a list of WithCheckOption's, which are
-									 * only added during rewrite and therefore
-									 * are not written out as part of Query. */
-
-	/*
-	 * The following two fields identify the portion of the source text string
-	 * containing this query.  They are typically only populated in top-level
-	 * Queries, not in sub-queries.  When not set, they might both be zero, or
-	 * both be -1 meaning "unknown".
-	 */
-	int stmt_location; /* start location, or -1 if unknown */
-	int stmt_len;      /* length in bytes; 0 means "rest of string" */
-} PGQuery;
-
-/****************************************************************************
- *	Supporting data structures for Parse Trees
- *
- *	Most of these node types appear in raw parsetrees output by the grammar,
- *	and get transformed to something else by the analyzer.  A few of them
- *	are used as-is in transformed querytrees.
- ****************************************************************************/
-
-/*
- * PGTypeName - specifies a type in definitions
- *
- * For PGTypeName structures generated internally, it is often easier to
- * specify the type by OID than by name.  If "names" is NIL then the
- * actual type OID is given by typeOid, otherwise typeOid is unused.
- * Similarly, if "typmods" is NIL then the actual typmod is expected to
- * be prespecified in typemod, otherwise typemod is unused.
- *
- * If pct_type is true, then names is actually a field name and we look up
- * the type of that field.  Otherwise (the normal case), names is a type
- * name possibly qualified with schema and database name.
- */
-typedef struct PGTypeName {
-	PGNodeTag type;
-	PGList *names;       /* qualified name (list of PGValue strings) */
-	PGOid typeOid;       /* type identified by OID */
-	bool setof;          /* is a set? */
-	bool pct_type;       /* %TYPE specified? */
-	PGList *typmods;     /* type modifier expression(s) */
-	int32_t typemod;     /* prespecified type modifier */
-	PGList *arrayBounds; /* array bounds */
-	int location;        /* token location, or -1 if unknown */
-} PGTypeName;
-
-/*
- * PGColumnRef - specifies a reference to a column, or possibly a whole tuple
- *
- * The "fields" list must be nonempty.  It can contain string PGValue nodes
- * (representing names) and PGAStar nodes (representing occurrence of a '*').
- * Currently, PGAStar must appear only as the last list element --- the grammar
- * is responsible for enforcing this!
- *
- * Note: any array subscripting or selection of fields from composite columns
- * is represented by an PGAIndirection node above the ColumnRef.  However,
- * for simplicity in the normal case, initial field selection from a table
- * name is represented within PGColumnRef and not by adding AIndirection.
- */
-typedef struct PGColumnRef {
-	PGNodeTag type;
-	PGList *fields;       /* field names (PGValue strings) or PGAStar */
-	int location;         /* token location, or -1 if unknown */
-} PGColumnRef;
-
-/*
- * PGParamRef - specifies a $n parameter reference
- */
-typedef struct PGParamRef {
-	PGNodeTag type;
-	int number;   /* the number of the parameter */
-	int location; /* token location, or -1 if unknown */
-} PGParamRef;
-
-/*
- * PGAExpr - infix, prefix, and postfix expressions
- */
-typedef enum PGAExpr_Kind {
-	PG_AEXPR_OP,              /* normal operator */
-	PG_AEXPR_OP_ANY,          /* scalar op ANY (array) */
-	PG_AEXPR_OP_ALL,          /* scalar op ALL (array) */
-	PG_AEXPR_DISTINCT,        /* IS DISTINCT FROM - name must be "=" */
-	PG_AEXPR_NOT_DISTINCT,    /* IS NOT DISTINCT FROM - name must be "=" */
-	PG_AEXPR_NULLIF,          /* NULLIF - name must be "=" */
-	PG_AEXPR_OF,              /* IS [NOT] OF - name must be "=" or "<>" */
-	PG_AEXPR_IN,              /* [NOT] IN - name must be "=" or "<>" */
-	PG_AEXPR_LIKE,            /* [NOT] LIKE - name must be "~~" or "!~~" */
-	PG_AEXPR_ILIKE,           /* [NOT] ILIKE - name must be "~~*" or "!~~*" */
-	PG_AEXPR_GLOB,            /* [NOT] GLOB - name must be "~~~" or "!~~~" */
-	PG_AEXPR_SIMILAR,         /* [NOT] SIMILAR - name must be "~" or "!~" */
-	PG_AEXPR_BETWEEN,         /* name must be "BETWEEN" */
-	PG_AEXPR_NOT_BETWEEN,     /* name must be "NOT BETWEEN" */
-	PG_AEXPR_BETWEEN_SYM,     /* name must be "BETWEEN SYMMETRIC" */
-	PG_AEXPR_NOT_BETWEEN_SYM, /* name must be "NOT BETWEEN SYMMETRIC" */
-	AEXPR_PAREN               /* nameless dummy node for parentheses */
-} PGAExpr_Kind;
-
-typedef struct PGAExpr {
-	PGNodeTag type;
-	PGAExpr_Kind kind; /* see above */
-	PGList *name;      /* possibly-qualified name of operator */
-	PGNode *lexpr;     /* left argument, or NULL if none */
-	PGNode *rexpr;     /* right argument, or NULL if none */
-	int location;      /* token location, or -1 if unknown */
-} PGAExpr;
-
-/*
- * PGAConst - a literal constant
- */
-typedef struct PGAConst {
-	PGNodeTag type;
-	PGValue val;  /* value (includes type info, see value.h) */
-	int location; /* token location, or -1 if unknown */
-} PGAConst;
-
-/*
- * PGTypeCast - a CAST expression
- */
-typedef struct PGTypeCast {
-	PGNodeTag type;
-	PGNode *arg;          /* the expression being casted */
-	PGTypeName *typeName; /* the target type */
-	int tryCast;          /* TRY_CAST or CAST */
-	int location;         /* token location, or -1 if unknown */
-} PGTypeCast;
-
-/*
- * PGCollateClause - a COLLATE expression
- */
-typedef struct PGCollateClause {
-	PGNodeTag type;
-	PGNode *arg;      /* input expression */
-	PGList *collname; /* possibly-qualified collation name */
-	int location;     /* token location, or -1 if unknown */
-} PGCollateClause;
-
-/*
- * PGFuncCall - a function or aggregate invocation
- *
- * agg_order (if not NIL) indicates we saw 'foo(... ORDER BY ...)', or if
- * agg_within_group is true, it was 'foo(...) WITHIN GROUP (ORDER BY ...)'.
- * agg_star indicates we saw a 'foo(*)' construct, while agg_distinct
- * indicates we saw 'foo(DISTINCT ...)'.  In any of these cases, the
- * construct *must* be an aggregate call.  Otherwise, it might be either an
- * aggregate or some other kind of function.  However, if FILTER or OVER is
- * present it had better be an aggregate or window function.
- *
- * Normally, you'd initialize this via makeFuncCall() and then only change the
- * parts of the struct its defaults don't match afterwards, as needed.
- */
-typedef struct PGFuncCall {
-	PGNodeTag type;
-	PGList *funcname;         /* qualified name of function */
-	PGList *args;             /* the arguments (list of exprs) */
-	PGList *agg_order;        /* ORDER BY (list of PGSortBy) */
-	PGNode *agg_filter;       /* FILTER clause, if any */
-	bool export_state;        /* EXPORT_STATE clause, if any */
-	bool agg_within_group;    /* ORDER BY appeared in WITHIN GROUP */
-	bool agg_star;            /* argument was really '*' */
-	bool agg_distinct;        /* arguments were labeled DISTINCT */
-	bool agg_ignore_nulls;    /* arguments were labeled IGNORE NULLS */
-	bool func_variadic;       /* last argument was labeled VARIADIC */
-	struct PGWindowDef *over; /* OVER clause, if any */
-	int location;             /* token location, or -1 if unknown */
-} PGFuncCall;
-
-/*
- * PGAStar - '*' representing all columns of a table or compound field
- *
- * This can appear within ColumnRef.fields, AIndirection.indirection, and
- * ResTarget.indirection lists.
- */
-typedef struct PGAStar {
-	PGNodeTag type;
-	char *relation;       /* relation name (optional) */
-	PGList *except_list;  /* optional: EXCLUDE list */
-	PGList *replace_list; /* optional: REPLACE list */
-} PGAStar;
-
-/*
- * PGAIndices - array subscript or slice bounds ([idx] or [lidx:uidx])
- *
- * In slice case, either or both of lidx and uidx can be NULL (omitted).
- * In non-slice case, uidx holds the single subscript and lidx is always NULL.
- */
-typedef struct PGAIndices {
-	PGNodeTag type;
-	bool is_slice; /* true if slice (i.e., colon present) */
-	PGNode *lidx;  /* slice lower bound, if any */
-	PGNode *uidx;  /* subscript, or slice upper bound if any */
-} PGAIndices;
-
-/*
- * PGAIndirection - select a field and/or array element from an expression
- *
- * The indirection list can contain PGAIndices nodes (representing
- * subscripting), string PGValue nodes (representing field selection --- the
- * string value is the name of the field to select), and PGAStar nodes
- * (representing selection of all fields of a composite type).
- * For example, a complex selection operation like
- *				(foo).field1[42][7].field2
- * would be represented with a single PGAIndirection node having a 4-element
- * indirection list.
- *
- * Currently, PGAStar must appear only as the last list element --- the grammar
- * is responsible for enforcing this!
- */
-typedef struct PGAIndirection {
-	PGNodeTag type;
-	PGNode *arg;         /* the thing being selected from */
-	PGList *indirection; /* subscripts and/or field names and/or * */
-} PGAIndirection;
-
-/*
- * PGAArrayExpr - an ARRAY[] construct
- */
-typedef struct PGAArrayExpr {
-	PGNodeTag type;
-	PGList *elements; /* array element expressions */
-	int location;     /* token location, or -1 if unknown */
-} PGAArrayExpr;
-
-/*
- * PGResTarget -
- *	  result target (used in target list of pre-transformed parse trees)
- *
- * In a SELECT target list, 'name' is the column label from an
- * 'AS ColumnLabel' clause, or NULL if there was none, and 'val' is the
- * value expression itself.  The 'indirection' field is not used.
- *
- * INSERT uses PGResTarget in its target-column-names list.  Here, 'name' is
- * the name of the destination column, 'indirection' stores any subscripts
- * attached to the destination, and 'val' is not used.
- *
- * In an UPDATE target list, 'name' is the name of the destination column,
- * 'indirection' stores any subscripts attached to the destination, and
- * 'val' is the expression to assign.
- *
- * See PGAIndirection for more info about what can appear in 'indirection'.
- */
-typedef struct PGResTarget {
-	PGNodeTag type;
-	char *name;          /* column name or NULL */
-	PGList *indirection; /* subscripts, field names, and '*', or NIL */
-	PGNode *val;         /* the value expression to compute or assign */
-	int location;        /* token location, or -1 if unknown */
-} PGResTarget;
-
-/*
- * PGMultiAssignRef - element of a row source expression for UPDATE
- *
- * In an UPDATE target list, when we have SET (a,b,c) = row-valued-expression,
- * we generate separate PGResTarget items for each of a,b,c.  Their "val" trees
- * are PGMultiAssignRef nodes numbered 1..n, linking to a common copy of the
- * row-valued-expression (which parse analysis will process only once, when
- * handling the PGMultiAssignRef with colno=1).
- */
-typedef struct PGMultiAssignRef {
-	PGNodeTag type;
-	PGNode *source; /* the row-valued expression */
-	int colno;      /* column number for this target (1..n) */
-	int ncolumns;   /* number of targets in the construct */
-} PGMultiAssignRef;
-
-/*
- * PGSortBy - for ORDER BY clause
- */
-typedef struct PGSortBy {
-	PGNodeTag type;
-	PGNode *node;               /* expression to sort on */
-	PGSortByDir sortby_dir;     /* ASC/DESC/USING/default */
-	PGSortByNulls sortby_nulls; /* NULLS FIRST/LAST */
-	PGList *useOp;              /* name of op to use, if SORTBY_USING */
-	int location;               /* operator location, or -1 if none/unknown */
-} PGSortBy;
-
-/*
- * PGWindowDef - raw representation of WINDOW and OVER clauses
- *
- * For entries in a WINDOW list, "name" is the window name being defined.
- * For OVER clauses, we use "name" for the "OVER window" syntax, or "refname"
- * for the "OVER (window)" syntax, which is subtly different --- the latter
- * implies overriding the window frame clause.
- */
-typedef struct PGWindowDef {
-	PGNodeTag type;
-	char *name;              /* window's own name */
-	char *refname;           /* referenced window name, if any */
-	PGList *partitionClause; /* PARTITION BY expression list */
-	PGList *orderClause;     /* ORDER BY (list of PGSortBy) */
-	int frameOptions;        /* frame_clause options, see below */
-	PGNode *startOffset;     /* expression for starting bound, if any */
-	PGNode *endOffset;       /* expression for ending bound, if any */
-	int location;            /* parse location, or -1 if none/unknown */
-} PGWindowDef;
-
-/*
- * frameOptions is an OR of these bits.  The NONDEFAULT and BETWEEN bits are
- * used so that ruleutils.c can tell which properties were specified and
- * which were defaulted; the correct behavioral bits must be set either way.
- * The START_foo and END_foo options must come in pairs of adjacent bits for
- * the convenience of gram.y, even though some of them are useless/invalid.
- * We will need more bits (and fields) to cover the full SQL:2008 option set.
- */
-#define FRAMEOPTION_NONDEFAULT 0x00001 /* any specified? */
-#define FRAMEOPTION_RANGE 0x00002 /* RANGE behavior */
-#define FRAMEOPTION_ROWS 0x00004 /* ROWS behavior */
-#define FRAMEOPTION_BETWEEN 0x00008 /* BETWEEN given? */
-#define FRAMEOPTION_START_UNBOUNDED_PRECEDING 0x00010 /* start is U. P. */
-#define FRAMEOPTION_END_UNBOUNDED_PRECEDING 0x00020 /* (disallowed) */
-#define FRAMEOPTION_START_UNBOUNDED_FOLLOWING 0x00040 /* (disallowed) */
-#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING 0x00080 /* end is U. F. */
-#define FRAMEOPTION_START_CURRENT_ROW 0x00100 /* start is C. R. */
-#define FRAMEOPTION_END_CURRENT_ROW 0x00200 /* end is C. R. */
-#define FRAMEOPTION_START_VALUE_PRECEDING 0x00400 /* start is V. P. */
-#define FRAMEOPTION_END_VALUE_PRECEDING 0x00800 /* end is V. P. */
-#define FRAMEOPTION_START_VALUE_FOLLOWING 0x01000 /* start is V. F. */
-#define FRAMEOPTION_END_VALUE_FOLLOWING 0x02000 /* end is V. F. */
-
-#define FRAMEOPTION_START_VALUE (FRAMEOPTION_START_VALUE_PRECEDING | FRAMEOPTION_START_VALUE_FOLLOWING)
-#define FRAMEOPTION_END_VALUE (FRAMEOPTION_END_VALUE_PRECEDING | FRAMEOPTION_END_VALUE_FOLLOWING)
-
-#define FRAMEOPTION_DEFAULTS (FRAMEOPTION_RANGE | FRAMEOPTION_START_UNBOUNDED_PRECEDING | FRAMEOPTION_END_CURRENT_ROW)
-
-/*
- * PGRangeSubselect - subquery appearing in a FROM clause
- */
-typedef struct PGRangeSubselect {
-	PGNodeTag type;
-	bool lateral;     /* does it have LATERAL prefix? */
-	PGNode *subquery; /* the untransformed sub-select clause */
-	PGAlias *alias;   /* table alias & optional column aliases */
-	PGNode *sample;   /* sample options (if any) */
-} PGRangeSubselect;
-
-/*
- * PGRangeFunction - function call appearing in a FROM clause
- *
- * functions is a PGList because we use this to represent the construct
- * ROWS FROM(func1(...), func2(...), ...).  Each element of this list is a
- * two-element sublist, the first element being the untransformed function
- * call tree, and the second element being a possibly-empty list of PGColumnDef
- * nodes representing any columndef list attached to that function within the
- * ROWS FROM() syntax.
- *
- * alias and coldeflist represent any alias and/or columndef list attached
- * at the top level.  (We disallow coldeflist appearing both here and
- * per-function, but that's checked in parse analysis, not by the grammar.)
- */
-typedef struct PGRangeFunction {
-	PGNodeTag type;
-	bool lateral;       /* does it have LATERAL prefix? */
-	bool ordinality;    /* does it have WITH ORDINALITY suffix? */
-	bool is_rowsfrom;   /* is result of ROWS FROM() syntax? */
-	PGList *functions;  /* per-function information, see above */
-	PGAlias *alias;     /* table alias & optional column aliases */
-	PGList *coldeflist; /* list of PGColumnDef nodes to describe result
-								 * of function returning RECORD */
-	PGNode *sample;   /* sample options (if any) */
-} PGRangeFunction;
-
-/* Category of the column */
-typedef enum ColumnCategory {
-	COL_STANDARD,	/* regular column */
-	COL_GENERATED	/* generated (VIRTUAL|STORED) */
-}	ColumnCategory;
-
-/*
- * PGColumnDef - column definition (used in various creates)
- *
- * If the column has a default value, we may have the value expression
- * in either "raw" form (an untransformed parse tree) or "cooked" form
- * (a post-parse-analysis, executable expression tree), depending on
- * how this PGColumnDef node was created (by parsing, or by inheritance
- * from an existing relation).  We should never have both in the same node!
- *
- * Similarly, we may have a COLLATE specification in either raw form
- * (represented as a PGCollateClause with arg==NULL) or cooked form
- * (the collation's OID).
- *
- * The constraints list may contain a PG_CONSTR_DEFAULT item in a raw
- * parsetree produced by gram.y, but transformCreateStmt will remove
- * the item and set raw_default instead.  PG_CONSTR_DEFAULT items
- * should not appear in any subsequent processing.
- */
-
-typedef struct PGColumnDef {
-	PGNodeTag type;               /* ENSURES COMPATIBILITY WITH 'PGNode' - has to be first line */
-	char *colname;                /* name of column */
-	PGTypeName *typeName;         /* type of column */
-	int inhcount;                 /* number of times column is inherited */
-	bool is_local;                /* column has local (non-inherited) def'n */
-	bool is_not_null;             /* NOT NULL constraint specified? */
-	bool is_from_type;            /* column definition came from table type */
-	bool is_from_parent;          /* column def came from partition parent */
-	char storage;                 /* attstorage setting, or 0 for default */
-	PGNode *raw_default;          /* default value (untransformed parse tree) */
-	PGNode *cooked_default;       /* default value (transformed expr tree) */
-	char identity;                /* attidentity setting */
-	PGRangeVar *identitySequence; /* to store identity sequence name for ALTER
-								   * TABLE ... ADD COLUMN */
-	PGCollateClause *collClause;  /* untransformed COLLATE spec, if any */
-	PGOid collOid;                /* collation OID (InvalidOid if not set) */
-	PGList *constraints;          /* other constraints on column */
-	PGList *fdwoptions;           /* per-column FDW options */
-	int location;                 /* parse location, or -1 if none/unknown */
-	ColumnCategory category;	  /* category of the column */
-} PGColumnDef;
-
-/*
- * PGTableLikeClause - CREATE TABLE ( ... LIKE ... ) clause
- */
-typedef struct PGTableLikeClause {
-	PGNodeTag type;
-	PGRangeVar *relation;
-	uint32_t options; /* OR of PGTableLikeOption flags */
-} PGTableLikeClause;
-
-typedef enum PGTableLikeOption {
-	PG_CREATE_TABLE_LIKE_DEFAULTS = 1 << 0,
-	PG_CREATE_TABLE_LIKE_CONSTRAINTS = 1 << 1,
-	PG_CREATE_TABLE_LIKE_IDENTITY = 1 << 2,
-	PG_CREATE_TABLE_LIKE_INDEXES = 1 << 3,
-	PG_CREATE_TABLE_LIKE_STORAGE = 1 << 4,
-	PG_CREATE_TABLE_LIKE_COMMENTS = 1 << 5,
-	PG_CREATE_TABLE_LIKE_STATISTICS = 1 << 6,
-	PG_CREATE_TABLE_LIKE_ALL = INT_MAX
-} PGTableLikeOption;
-
-/*
- * PGIndexElem - index parameters (used in CREATE INDEX, and in ON CONFLICT)
- *
- * For a plain index attribute, 'name' is the name of the table column to
- * index, and 'expr' is NULL.  For an index expression, 'name' is NULL and
- * 'expr' is the expression tree.
- */
-typedef struct PGIndexElem {
-	PGNodeTag type;
-	char *name;                   /* name of attribute to index, or NULL */
-	PGNode *expr;                 /* expression to index, or NULL */
-	char *indexcolname;           /* name for index column; NULL = default */
-	PGList *collation;            /* name of collation; NIL = default */
-	PGList *opclass;              /* name of desired opclass; NIL = default */
-	PGSortByDir ordering;         /* ASC/DESC/default */
-	PGSortByNulls nulls_ordering; /* FIRST/LAST/default */
-} PGIndexElem;
-
-/*
- * PGDefElem - a generic "name = value" option definition
- *
- * In some contexts the name can be qualified.  Also, certain SQL commands
- * allow a SET/ADD/DROP action to be attached to option settings, so it's
- * convenient to carry a field for that too.  (Note: currently, it is our
- * practice that the grammar allows namespace and action only in statements
- * where they are relevant; C code can just ignore those fields in other
- * statements.)
- */
-typedef enum PGDefElemAction {
-	PG_DEFELEM_UNSPEC, /* no action given */
-	PG_DEFELEM_SET,
-	PG_DEFELEM_ADD,
-	DEFELEM_DROP
-} PGDefElemAction;
-
-typedef struct PGDefElem {
-	PGNodeTag type;
-	char *defnamespace; /* NULL if unqualified name */
-	char *defname;
-	PGNode *arg;               /* a (PGValue *) or a (PGTypeName *) */
-	PGDefElemAction defaction; /* unspecified action, or SET/ADD/DROP */
-	int location;              /* token location, or -1 if unknown */
-} PGDefElem;
-
-/*
- * PGLockingClause - raw representation of FOR [NO KEY] UPDATE/[KEY] SHARE
- *		options
- *
- * Note: lockedRels == NIL means "all relations in query".  Otherwise it
- * is a list of PGRangeVar nodes.  (We use PGRangeVar mainly because it carries
- * a location field --- currently, parse analysis insists on unqualified
- * names in LockingClause.)
- */
-typedef struct PGLockingClause {
-	PGNodeTag type;
-	PGList *lockedRels; /* FOR [KEY] UPDATE/SHARE relations */
-	PGLockClauseStrength strength;
-	PGLockWaitPolicy waitPolicy; /* NOWAIT and SKIP LOCKED */
-} PGLockingClause;
-
-/****************************************************************************
- *	Nodes for a PGQuery tree
- ****************************************************************************/
-
-/*--------------------
- * PGRangeTblEntry -
- *	  A range table is a PGList of PGRangeTblEntry nodes.
- *
- *	  A range table entry may represent a plain relation, a sub-select in
- *	  FROM, or the result of a JOIN clause.  (Only explicit JOIN syntax
- *	  produces an RTE, not the implicit join resulting from multiple FROM
- *	  items.  This is because we only need the RTE to deal with SQL features
- *	  like outer joins and join-output-column aliasing.)  Other special
- *	  RTE types also exist, as indicated by RTEKind.
- *
- *	  Note that we consider PG_RTE_RELATION to cover anything that has a pg_class
- *	  entry.  relkind distinguishes the sub-cases.
- *
- *	  alias is an PGAlias node representing the AS alias-clause attached to the
- *	  FROM expression, or NULL if no clause.
- *
- *	  eref is the table reference name and column reference names (either
- *	  real or aliases).  Note that system columns (OID etc) are not included
- *	  in the column list.
- *	  eref->aliasname is required to be present, and should generally be used
- *	  to identify the RTE for error messages etc.
- *
- *	  In RELATION RTEs, the colnames in both alias and eref are indexed by
- *	  physical attribute number; this means there must be colname entries for
- *	  dropped columns.  When building an RTE we insert empty strings ("") for
- *	  dropped columns.  Note however that a stored rule may have nonempty
- *	  colnames for columns dropped since the rule was created (and for that
- *	  matter the colnames might be out of date due to column renamings).
- *	  The same comments apply to FUNCTION RTEs when a function's return type
- *	  is a named composite type.
- *
- *	  In JOIN RTEs, the colnames in both alias and eref are one-to-one with
- *	  joinaliasvars entries.  A JOIN RTE will omit columns of its inputs when
- *	  those columns are known to be dropped at parse time.  Again, however,
- *	  a stored rule might contain entries for columns dropped since the rule
- *	  was created.  (This is only possible for columns not actually referenced
- *	  in the rule.)  When loading a stored rule, we replace the joinaliasvars
- *	  items for any such columns with null pointers.  (We can't simply delete
- *	  them from the joinaliasvars list, because that would affect the attnums
- *	  of Vars referencing the rest of the list.)
- *
- *	  inh is true for relation references that should be expanded to include
- *	  inheritance children, if the rel has any.  This *must* be false for
- *	  RTEs other than PG_RTE_RELATION entries.
- *
- *	  inFromCl marks those range variables that are listed in the FROM clause.
- *	  It's false for RTEs that are added to a query behind the scenes, such
- *	  as the NEW and OLD variables for a rule, or the subqueries of a UNION.
- *	  This flag is not used anymore during parsing, since the parser now uses
- *	  a separate "namespace" data structure to control visibility, but it is
- *	  needed by ruleutils.c to determine whether RTEs should be shown in
- *	  decompiled queries.
- *--------------------
- */
-typedef enum PGRTEKind {
-	PG_RTE_RELATION,    /* ordinary relation reference */
-	PG_RTE_SUBQUERY,    /* subquery in FROM */
-	PG_RTE_JOIN,        /* join */
-	PG_RTE_FUNCTION,    /* function in FROM */
-	PG_RTE_TABLEFUNC,   /* TableFunc(.., column list) */
-	PG_RTE_VALUES,      /* VALUES (<exprlist>), (<exprlist>), ... */
-	PG_RTE_CTE,         /* common table expr (WITH list element) */
-	RTE_NAMEDTUPLESTORE /* tuplestore, e.g. for AFTER triggers */
-} PGRTEKind;
-
-typedef struct PGRangeTblEntry {
-	PGNodeTag type;
-
-	PGRTEKind rtekind; /* see above */
-
-	/*
-	 * XXX the fields applicable to only some rte kinds should be merged into
-	 * a union.  I didn't do this yet because the diffs would impact a lot of
-	 * code that is being actively worked on.  FIXME someday.
-	 */
-
-	/*
-	 * Fields valid for a plain relation RTE (else zero):
-	 *
-	 * As a special case, RTE_NAMEDTUPLESTORE can also set relid to indicate
-	 * that the tuple format of the tuplestore is the same as the referenced
-	 * relation.  This allows plans referencing AFTER trigger transition
-	 * tables to be invalidated if the underlying table is altered.
-	 */
-	PGOid relid;                             /* OID of the relation */
-	char relkind;                            /* relation kind (see pg_class.relkind) */
-	struct PGTableSampleClause *tablesample; /* sampling info, or NULL */
-
-	/*
-	 * Fields valid for a subquery RTE (else NULL):
-	 */
-	PGQuery *subquery; /* the sub-query */
-
-	/*
-	 * Fields valid for a join RTE (else NULL/zero):
-	 *
-	 * joinaliasvars is a list of (usually) Vars corresponding to the columns
-	 * of the join result.  An alias PGVar referencing column K of the join
-	 * result can be replaced by the K'th element of joinaliasvars --- but to
-	 * simplify the task of reverse-listing aliases correctly, we do not do
-	 * that until planning time.  In detail: an element of joinaliasvars can
-	 * be a PGVar of one of the join's input relations, or such a PGVar with an
-	 * implicit coercion to the join's output column type, or a COALESCE
-	 * expression containing the two input column Vars (possibly coerced).
-	 * Within a PGQuery loaded from a stored rule, it is also possible for
-	 * joinaliasvars items to be null pointers, which are placeholders for
-	 * (necessarily unreferenced) columns dropped since the rule was made.
-	 * Also, once planning begins, joinaliasvars items can be almost anything,
-	 * as a result of subquery-flattening substitutions.
-	 */
-	PGJoinType jointype;   /* type of join */
-	PGList *joinaliasvars; /* list of alias-var expansions */
-
-	/*
-	 * Fields valid for a function RTE (else NIL/zero):
-	 *
-	 * When funcordinality is true, the eref->colnames list includes an alias
-	 * for the ordinality column.  The ordinality column is otherwise
-	 * implicit, and must be accounted for "by hand" in places such as
-	 * expandRTE().
-	 */
-	PGList *functions;   /* list of PGRangeTblFunction nodes */
-	bool funcordinality; /* is this called WITH ORDINALITY? */
-
-	/*
-	 * Fields valid for a PGTableFunc RTE (else NULL):
-	 */
-	PGTableFunc *tablefunc;
-
-	/*
-	 * Fields valid for a values RTE (else NIL):
-	 */
-	PGList *values_lists; /* list of expression lists */
-
-	/*
-	 * Fields valid for a CTE RTE (else NULL/zero):
-	 */
-	char *ctename;       /* name of the WITH list item */
-	PGIndex ctelevelsup; /* number of query levels up */
-	bool self_reference; /* is this a recursive self-reference? */
-
-	/*
-	 * Fields valid for table functions, values, CTE and ENR RTEs (else NIL):
-	 *
-	 * We need these for CTE RTEs so that the types of self-referential
-	 * columns are well-defined.  For VALUES RTEs, storing these explicitly
-	 * saves having to re-determine the info by scanning the values_lists. For
-	 * ENRs, we store the types explicitly here (we could get the information
-	 * from the catalogs if 'relid' was supplied, but we'd still need these
-	 * for TupleDesc-based ENRs, so we might as well always store the type
-	 * info here).
-	 *
-	 * For ENRs only, we have to consider the possibility of dropped columns.
-	 * A dropped column is included in these lists, but it will have zeroes in
-	 * all three lists (as well as an empty-string entry in eref).  Testing
-	 * for zero coltype is the standard way to detect a dropped column.
-	 */
-	PGList *coltypes;      /* OID list of column type OIDs */
-	PGList *coltypmods;    /* integer list of column typmods */
-	PGList *colcollations; /* OID list of column collation OIDs */
-
-	/*
-	 * Fields valid for ENR RTEs (else NULL/zero):
-	 */
-	char *enrname;    /* name of ephemeral named relation */
-	double enrtuples; /* estimated or actual from caller */
-
-	/*
-	 * Fields valid in all RTEs:
-	 */
-	PGAlias *alias; /* user-written alias clause, if any */
-	PGAlias *eref;  /* expanded reference names */
-	bool lateral;   /* subquery, function, or values is LATERAL? */
-	bool inh;       /* inheritance requested? */
-	bool inFromCl;  /* present in FROM clause? */
-} PGRangeTblEntry;
-
-/*
- * PGRangeTblFunction -
- *	  PGRangeTblEntry subsidiary data for one function in a FUNCTION RTE.
- *
- * If the function had a column definition list (required for an
- * otherwise-unspecified RECORD result), funccolnames lists the names given
- * in the definition list, funccoltypes lists their declared column types,
- * funccoltypmods lists their typmods, funccolcollations their collations.
- * Otherwise, those fields are NIL.
- *
- * Notice we don't attempt to store info about the results of functions
- * returning named composite types, because those can change from time to
- * time.  We do however remember how many columns we thought the type had
- * (including dropped columns!), so that we can successfully ignore any
- * columns added after the query was parsed.
- */
-typedef struct PGRangeTblFunction {
-	PGNodeTag type;
-
-	PGNode *funcexpr; /* expression tree for func call */
-	int funccolcount; /* number of columns it contributes to RTE */
-	/* These fields record the contents of a column definition list, if any: */
-	PGList *funccolnames;      /* column names (list of String) */
-	PGList *funccoltypes;      /* OID list of column type OIDs */
-	PGList *funccoltypmods;    /* integer list of column typmods */
-	PGList *funccolcollations; /* OID list of column collation OIDs */
-	/* This is set during planning for use by the executor: */
-	PGBitmapset *funcparams; /* PG_PARAM_EXEC PGParam IDs affecting this func */
-} PGRangeTblFunction;
-
-/*
- * PGSortGroupClause -
- *		representation of ORDER BY, GROUP BY, PARTITION BY,
- *		DISTINCT, DISTINCT ON items
- *
- * You might think that ORDER BY is only interested in defining ordering,
- * and GROUP/DISTINCT are only interested in defining equality.  However,
- * one way to implement grouping is to sort and then apply a "uniq"-like
- * filter.  So it's also interesting to keep track of possible sort operators
- * for GROUP/DISTINCT, and in particular to try to sort for the grouping
- * in a way that will also yield a requested ORDER BY ordering.  So we need
- * to be able to compare ORDER BY and GROUP/DISTINCT lists, which motivates
- * the decision to give them the same representation.
- *
- * tleSortGroupRef must match ressortgroupref of exactly one entry of the
- *		query's targetlist; that is the expression to be sorted or grouped by.
- * eqop is the OID of the equality operator.
- * sortop is the OID of the ordering operator (a "<" or ">" operator),
- *		or InvalidOid if not available.
- * nulls_first means about what you'd expect.  If sortop is InvalidOid
- *		then nulls_first is meaningless and should be set to false.
- * hashable is true if eqop is hashable (note this condition also depends
- *		on the datatype of the input expression).
- *
- * In an ORDER BY item, all fields must be valid.  (The eqop isn't essential
- * here, but it's cheap to get it along with the sortop, and requiring it
- * to be valid eases comparisons to grouping items.)  Note that this isn't
- * actually enough information to determine an ordering: if the sortop is
- * collation-sensitive, a collation OID is needed too.  We don't store the
- * collation in PGSortGroupClause because it's not available at the time the
- * parser builds the PGSortGroupClause; instead, consult the exposed collation
- * of the referenced targetlist expression to find out what it is.
- *
- * In a grouping item, eqop must be valid.  If the eqop is a btree equality
- * operator, then sortop should be set to a compatible ordering operator.
- * We prefer to set eqop/sortop/nulls_first to match any ORDER BY item that
- * the query presents for the same tlist item.  If there is none, we just
- * use the default ordering op for the datatype.
- *
- * If the tlist item's type has a hash opclass but no btree opclass, then
- * we will set eqop to the hash equality operator, sortop to InvalidOid,
- * and nulls_first to false.  A grouping item of this kind can only be
- * implemented by hashing, and of course it'll never match an ORDER BY item.
- *
- * The hashable flag is provided since we generally have the requisite
- * information readily available when the PGSortGroupClause is constructed,
- * and it's relatively expensive to get it again later.  Note there is no
- * need for a "sortable" flag since OidIsValid(sortop) serves the purpose.
- *
- * A query might have both ORDER BY and DISTINCT (or DISTINCT ON) clauses.
- * In SELECT DISTINCT, the distinctClause list is as long or longer than the
- * sortClause list, while in SELECT DISTINCT ON it's typically shorter.
- * The two lists must match up to the end of the shorter one --- the parser
- * rearranges the distinctClause if necessary to make this true.  (This
- * restriction ensures that only one sort step is needed to both satisfy the
- * ORDER BY and set up for the PGUnique step.  This is semantically necessary
- * for DISTINCT ON, and presents no real drawback for DISTINCT.)
- */
-typedef struct PGSortGroupClause {
-	PGNodeTag type;
-	PGIndex tleSortGroupRef; /* reference into targetlist */
-	PGOid eqop;              /* the equality operator ('=' op) */
-	PGOid sortop;            /* the ordering operator ('<' op), or 0 */
-	bool nulls_first;        /* do NULLs come before normal values? */
-	bool hashable;           /* can eqop be implemented by hashing? */
-} PGSortGroupClause;
-
-/*
- * PGGroupingSet -
- *		representation of CUBE, ROLLUP and GROUPING SETS clauses
- *
- * In a PGQuery with grouping sets, the groupClause contains a flat list of
- * PGSortGroupClause nodes for each distinct expression used.  The actual
- * structure of the GROUP BY clause is given by the groupingSets tree.
- *
- * In the raw parser output, PGGroupingSet nodes (of all types except SIMPLE
- * which is not used) are potentially mixed in with the expressions in the
- * groupClause of the SelectStmt.  (An expression can't contain a PGGroupingSet,
- * but a list may mix PGGroupingSet and expression nodes.)  At this stage, the
- * content of each node is a list of expressions, some of which may be RowExprs
- * which represent sublists rather than actual row constructors, and nested
- * PGGroupingSet nodes where legal in the grammar.  The structure directly
- * reflects the query syntax.
- *
- * In parse analysis, the transformed expressions are used to build the tlist
- * and groupClause list (of PGSortGroupClause nodes), and the groupingSets tree
- * is eventually reduced to a fixed format:
- *
- * EMPTY nodes represent (), and obviously have no content
- *
- * SIMPLE nodes represent a list of one or more expressions to be treated as an
- * atom by the enclosing structure; the content is an integer list of
- * ressortgroupref values (see PGSortGroupClause)
- *
- * CUBE and ROLLUP nodes contain a list of one or more SIMPLE nodes.
- *
- * SETS nodes contain a list of EMPTY, SIMPLE, CUBE or ROLLUP nodes, but after
- * parse analysis they cannot contain more SETS nodes; enough of the syntactic
- * transforms of the spec have been applied that we no longer have arbitrarily
- * deep nesting (though we still preserve the use of cube/rollup).
- *
- * Note that if the groupingSets tree contains no SIMPLE nodes (only EMPTY
- * nodes at the leaves), then the groupClause will be empty, but this is still
- * an aggregation query (similar to using aggs or HAVING without GROUP BY).
- *
- * As an example, the following clause:
- *
- * GROUP BY GROUPING SETS ((a,b), CUBE(c,(d,e)))
- *
- * looks like this after raw parsing:
- *
- * SETS( RowExpr(a,b) , CUBE( c, RowExpr(d,e) ) )
- *
- * and parse analysis converts it to:
- *
- * SETS( SIMPLE(1,2), CUBE( SIMPLE(3), SIMPLE(4,5) ) )
- */
-typedef enum {
-	GROUPING_SET_EMPTY,
-	GROUPING_SET_SIMPLE,
-	GROUPING_SET_ROLLUP,
-	GROUPING_SET_CUBE,
-	GROUPING_SET_SETS,
-	GROUPING_SET_ALL
-} GroupingSetKind;
-
-typedef struct PGGroupingSet {
-	PGNodeTag type;
-	GroupingSetKind kind;
-	PGList *content;
-	int location;
-} PGGroupingSet;
-
-/*
- * PGWindowClause -
- *		transformed representation of WINDOW and OVER clauses
- *
- * A parsed Query's windowClause list contains these structs.  "name" is set
- * if the clause originally came from WINDOW, and is NULL if it originally
- * was an OVER clause (but note that we collapse out duplicate OVERs).
- * partitionClause and orderClause are lists of PGSortGroupClause structs.
- * winref is an ID number referenced by PGWindowFunc nodes; it must be unique
- * among the members of a Query's windowClause list.
- * When refname isn't null, the partitionClause is always copied from there;
- * the orderClause might or might not be copied (see copiedOrder); the framing
- * options are never copied, per spec.
- */
-typedef struct PGWindowClause {
-	PGNodeTag type;
-	char *name;              /* window name (NULL in an OVER clause) */
-	char *refname;           /* referenced window name, if any */
-	PGList *partitionClause; /* PARTITION BY list */
-	PGList *orderClause;     /* ORDER BY list */
-	int frameOptions;        /* frame_clause options, see PGWindowDef */
-	PGNode *startOffset;     /* expression for starting bound, if any */
-	PGNode *endOffset;       /* expression for ending bound, if any */
-	PGIndex winref;          /* ID referenced by window functions */
-	bool copiedOrder;        /* did we copy orderClause from refname? */
-} PGWindowClause;
-
-/*
- * RowMarkClause -
- *	   parser output representation of FOR [KEY] UPDATE/SHARE clauses
- *
- * Query.rowMarks contains a separate RowMarkClause node for each relation
- * identified as a FOR [KEY] UPDATE/SHARE target.  If one of these clauses
- * is applied to a subquery, we generate RowMarkClauses for all normal and
- * subquery rels in the subquery, but they are marked pushedDown = true to
- * distinguish them from clauses that were explicitly written at this query
- * level.  Also, Query.hasForUpdate tells whether there were explicit FOR
- * UPDATE/SHARE/KEY SHARE clauses in the current query level.
- */
-
-/*
- * PGWithClause -
- *	   representation of WITH clause
- *
- * Note: PGWithClause does not propagate into the PGQuery representation;
- * but PGCommonTableExpr does.
- */
-typedef struct PGWithClause {
-	PGNodeTag type;
-	PGList *ctes;   /* list of CommonTableExprs */
-	bool recursive; /* true = WITH RECURSIVE */
-	int location;   /* token location, or -1 if unknown */
-} PGWithClause;
-
-/*
- * PGInferClause -
- *		ON CONFLICT unique index inference clause
- *
- * Note: PGInferClause does not propagate into the PGQuery representation.
- */
-typedef struct PGInferClause {
-	PGNodeTag type;
-	PGList *indexElems;  /* IndexElems to infer unique index */
-	PGNode *whereClause; /* qualification (partial-index predicate) */
-	char *conname;       /* PGConstraint name, or NULL if unnamed */
-	int location;        /* token location, or -1 if unknown */
-} PGInferClause;
-
-/*
- * PGOnConflictClause -
- *		representation of ON CONFLICT clause
- *
- * Note: PGOnConflictClause does not propagate into the PGQuery representation.
- */
-typedef struct PGOnConflictClause {
-	PGNodeTag type;
-	PGOnConflictAction action; /* DO NOTHING or UPDATE? */
-	PGInferClause *infer;      /* Optional index inference clause */
-	PGList *targetList;        /* the target list (of PGResTarget) */
-	PGNode *whereClause;       /* qualifications */
-	int location;              /* token location, or -1 if unknown */
-} PGOnConflictClause;
-
-/*
- * PGCommonTableExpr -
- *	   representation of WITH list element
- *
- * We don't currently support the SEARCH or CYCLE clause.
- */
-typedef struct PGCommonTableExpr {
-	PGNodeTag type;
-	char *ctename;         /* query name (never qualified) */
-	PGList *aliascolnames; /* optional list of column names */
-	/* SelectStmt/InsertStmt/etc before parse analysis, PGQuery afterwards: */
-	PGNode *ctequery; /* the CTE's subquery */
-	int location;     /* token location, or -1 if unknown */
-	/* These fields are set during parse analysis: */
-	bool cterecursive;        /* is this CTE actually recursive? */
-	int cterefcount;          /* number of RTEs referencing this CTE
-								 * (excluding internal self-references) */
-	PGList *ctecolnames;      /* list of output column names */
-	PGList *ctecoltypes;      /* OID list of output column type OIDs */
-	PGList *ctecoltypmods;    /* integer list of output column typmods */
-	PGList *ctecolcollations; /* OID list of column collation OIDs */
-} PGCommonTableExpr;
-
-/* Convenience macro to get the output tlist of a CTE's query */
-#define GetCTETargetList(cte) \
-	(AssertMacro(IsA((cte)->ctequery, PGQuery)), ((PGQuery *)(cte)->ctequery)->commandType == PG_CMD_SELECT ? ((PGQuery *)(cte)->ctequery)->targetList : ((PGQuery *)(cte)->ctequery)->returningList)
-
-/*
- * TriggerTransition -
- *	   representation of transition row or table naming clause
- *
- * Only transition tables are initially supported in the syntax, and only for
- * AFTER triggers, but other permutations are accepted by the parser so we can
- * give a meaningful message from C code.
- */
-
-/*****************************************************************************
- *		Raw Grammar Output Statements
- *****************************************************************************/
-
-/*
- *		PGRawStmt --- container for any one statement's raw parse tree
- *
- * Parse analysis converts a raw parse tree headed by a PGRawStmt node into
- * an analyzed statement headed by a PGQuery node.  For optimizable statements,
- * the conversion is complex.  For utility statements, the parser usually just
- * transfers the raw parse tree (sans PGRawStmt) into the utilityStmt field of
- * the PGQuery node, and all the useful work happens at execution time.
- *
- * stmt_location/stmt_len identify the portion of the source text string
- * containing this raw statement (useful for multi-statement strings).
- */
-typedef struct PGRawStmt {
-	PGNodeTag type;
-	PGNode *stmt;      /* raw parse tree */
-	int stmt_location; /* start location, or -1 if unknown */
-	int stmt_len;      /* length in bytes; 0 means "rest of string" */
-} PGRawStmt;
-
-/*****************************************************************************
- *		Optimizable Statements
- *****************************************************************************/
-
-/* ----------------------
- *		Insert Statement
- *
- * The source expression is represented by PGSelectStmt for both the
- * SELECT and VALUES cases.  If selectStmt is NULL, then the query
- * is INSERT ... DEFAULT VALUES.
- * ----------------------
- */
-typedef struct PGInsertStmt {
-	PGNodeTag type;
-	PGRangeVar *relation;                 /* relation to insert into */
-	PGList *cols;                         /* optional: names of the target columns */
-	PGNode *selectStmt;                   /* the source SELECT/VALUES, or NULL */
-	PGOnConflictClause *onConflictClause; /* ON CONFLICT clause */
-	PGList *returningList;                /* list of expressions to return */
-	PGWithClause *withClause;             /* WITH clause */
-	PGOverridingKind override;            /* OVERRIDING clause */
-} PGInsertStmt;
-
-/* ----------------------
- *		Delete Statement
- * ----------------------
- */
-typedef struct PGDeleteStmt {
-	PGNodeTag type;
-	PGRangeVar *relation;     /* relation to delete from */
-	PGList *usingClause;      /* optional using clause for more tables */
-	PGNode *whereClause;      /* qualifications */
-	PGList *returningList;    /* list of expressions to return */
-	PGWithClause *withClause; /* WITH clause */
-} PGDeleteStmt;
-
-/* ----------------------
- *		Update Statement
- * ----------------------
- */
-typedef struct PGUpdateStmt {
-	PGNodeTag type;
-	PGRangeVar *relation;     /* relation to update */
-	PGList *targetList;       /* the target list (of PGResTarget) */
-	PGNode *whereClause;      /* qualifications */
-	PGList *fromClause;       /* optional from clause for more tables */
-	PGList *returningList;    /* list of expressions to return */
-	PGWithClause *withClause; /* WITH clause */
-} PGUpdateStmt;
-
-/* ----------------------
- *		Select Statement
- *
- * A "simple" SELECT is represented in the output of gram.y by a single
- * PGSelectStmt node; so is a VALUES construct.  A query containing set
- * operators (UNION, INTERSECT, EXCEPT) is represented by a tree of PGSelectStmt
- * nodes, in which the leaf nodes are component SELECTs and the internal nodes
- * represent UNION, INTERSECT, or EXCEPT operators.  Using the same node
- * type for both leaf and internal nodes allows gram.y to stick ORDER BY,
- * LIMIT, etc, clause values into a SELECT statement without worrying
- * whether it is a simple or compound SELECT.
- * ----------------------
- */
-typedef enum PGSetOperation { PG_SETOP_NONE = 0, PG_SETOP_UNION, PG_SETOP_INTERSECT, PG_SETOP_EXCEPT } PGSetOperation;
-
-typedef struct PGSelectStmt {
-	PGNodeTag type;
-
-	/*
-	 * These fields are used only in "leaf" SelectStmts.
-	 */
-	PGList *distinctClause;   /* NULL, list of DISTINCT ON exprs, or
-								 * lcons(NIL,NIL) for all (SELECT DISTINCT) */
-	PGIntoClause *intoClause; /* target for SELECT INTO */
-	PGList *targetList;       /* the target list (of PGResTarget) */
-	PGList *fromClause;       /* the FROM clause */
-	PGNode *whereClause;      /* WHERE qualification */
-	PGList *groupClause;      /* GROUP BY clauses */
-	PGNode *havingClause;     /* HAVING conditional-expression */
-	PGList *windowClause;     /* WINDOW window_name AS (...), ... */
-	PGNode *qualifyClause;    /* QUALIFY conditional-expression */
-
-	/*
-	 * In a "leaf" node representing a VALUES list, the above fields are all
-	 * null, and instead this field is set.  Note that the elements of the
-	 * sublists are just expressions, without PGResTarget decoration. Also note
-	 * that a list element can be DEFAULT (represented as a PGSetToDefault
-	 * node), regardless of the context of the VALUES list. It's up to parse
-	 * analysis to reject that where not valid.
-	 */
-	PGList *valuesLists; /* untransformed list of expression lists */
-
-	/*
-	 * These fields are used in both "leaf" SelectStmts and upper-level
-	 * SelectStmts.
-	 */
-	PGList *sortClause;       /* sort clause (a list of SortBy's) */
-	PGNode *limitOffset;      /* # of result tuples to skip */
-	PGNode *limitCount;       /* # of result tuples to return */
-	PGNode *sampleOptions;    /* sample options (if any) */
-	PGList *lockingClause;    /* FOR UPDATE (list of LockingClause's) */
-	PGWithClause *withClause; /* WITH clause */
-
-	/*
-	 * These fields are used only in upper-level SelectStmts.
-	 */
-	PGSetOperation op;         /* type of set op */
-	bool all;                  /* ALL specified? */
-	struct PGSelectStmt *larg; /* left child */
-	struct PGSelectStmt *rarg; /* right child */
-	                           /* Eventually add fields for CORRESPONDING spec here */
-} PGSelectStmt;
-
-/* ----------------------
- *		Set Operation node for post-analysis query trees
- *
- * After parse analysis, a SELECT with set operations is represented by a
- * top-level PGQuery node containing the leaf SELECTs as subqueries in its
- * range table.  Its setOperations field shows the tree of set operations,
- * with leaf PGSelectStmt nodes replaced by PGRangeTblRef nodes, and internal
- * nodes replaced by SetOperationStmt nodes.  Information about the output
- * column types is added, too.  (Note that the child nodes do not necessarily
- * produce these types directly, but we've checked that their output types
- * can be coerced to the output column type.)  Also, if it's not UNION ALL,
- * information about the types' sort/group semantics is provided in the form
- * of a PGSortGroupClause list (same representation as, eg, DISTINCT).
- * The resolved common column collations are provided too; but note that if
- * it's not UNION ALL, it's okay for a column to not have a common collation,
- * so a member of the colCollations list could be InvalidOid even though the
- * column has a collatable type.
- * ----------------------
- */
-
-/*****************************************************************************
- *		Other Statements (no optimizations required)
- *
- *		These are not touched by parser/analyze.c except to put them into
- *		the utilityStmt field of a Query.  This is eventually passed to
- *		ProcessUtility (by-passing rewriting and planning).  Some of the
- *		statements do need attention from parse analysis, and this is
- *		done by routines in parser/parse_utilcmd.c after ProcessUtility
- *		receives the command for execution.
- *		DECLARE CURSOR, EXPLAIN, and CREATE TABLE AS are special cases:
- *		they contain optimizable statements, which get processed normally
- *		by parser/analyze.c.
- *****************************************************************************/
-
-/*
- * When a command can act on several kinds of objects with only one
- * parse structure required, use these constants to designate the
- * object type.  Note that commands typically don't support all the types.
- */
-
-typedef enum PGObjectType {
-	PG_OBJECT_ACCESS_METHOD,
-	PG_OBJECT_AGGREGATE,
-	PG_OBJECT_AMOP,
-	PG_OBJECT_AMPROC,
-	PG_OBJECT_ATTRIBUTE, /* type's attribute, when distinct from column */
-	PG_OBJECT_CAST,
-	PG_OBJECT_COLUMN,
-	PG_OBJECT_COLLATION,
-	PG_OBJECT_CONVERSION,
-	PG_OBJECT_DATABASE,
-	PG_OBJECT_DEFAULT,
-	PG_OBJECT_DEFACL,
-	PG_OBJECT_DOMAIN,
-	PG_OBJECT_DOMCONSTRAINT,
-	PG_OBJECT_EVENT_TRIGGER,
-	PG_OBJECT_EXTENSION,
-	PG_OBJECT_FDW,
-	PG_OBJECT_FOREIGN_SERVER,
-	PG_OBJECT_FOREIGN_TABLE,
-	PG_OBJECT_FUNCTION,
-	PG_OBJECT_TABLE_MACRO,
-	PG_OBJECT_INDEX,
-	PG_OBJECT_LANGUAGE,
-	PG_OBJECT_LARGEOBJECT,
-	PG_OBJECT_MATVIEW,
-	PG_OBJECT_OPCLASS,
-	PG_OBJECT_OPERATOR,
-	PG_OBJECT_OPFAMILY,
-	PG_OBJECT_POLICY,
-	PG_OBJECT_PUBLICATION,
-	PG_OBJECT_PUBLICATION_REL,
-	PG_OBJECT_ROLE,
-	PG_OBJECT_RULE,
-	PG_OBJECT_SCHEMA,
-	PG_OBJECT_SEQUENCE,
-	PG_OBJECT_SUBSCRIPTION,
-	PG_OBJECT_STATISTIC_EXT,
-	PG_OBJECT_TABCONSTRAINT,
-	PG_OBJECT_TABLE,
-	PG_OBJECT_TABLESPACE,
-	PG_OBJECT_TRANSFORM,
-	PG_OBJECT_TRIGGER,
-	PG_OBJECT_TSCONFIGURATION,
-	PG_OBJECT_TSDICTIONARY,
-	PG_OBJECT_TSPARSER,
-	PG_OBJECT_TSTEMPLATE,
-	PG_OBJECT_TYPE,
-	PG_OBJECT_USER_MAPPING,
-	PG_OBJECT_VIEW
-} PGObjectType;
-
-/* ----------------------
- *		Create Schema Statement
- *
- * NOTE: the schemaElts list contains raw parsetrees for component statements
- * of the schema, such as CREATE TABLE, GRANT, etc.  These are analyzed and
- * executed after the schema itself is created.
- * ----------------------
- */
-typedef struct PGCreateSchemaStmt {
-	PGNodeTag type;
-	char *schemaname;                     /* the name of the schema to create */
-	PGList *schemaElts;                   /* schema components (list of parsenodes) */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateSchemaStmt;
-
-typedef enum PGDropBehavior {
-	PG_DROP_RESTRICT, /* drop fails if any dependent objects */
-	PG_DROP_CASCADE   /* remove dependent objects too */
-} PGDropBehavior;
-
-/* ----------------------
- *	Alter Table
- * ----------------------
- */
-typedef struct PGAlterTableStmt {
-	PGNodeTag type;
-	PGRangeVar *relation; /* table to work on */
-	PGList *cmds;         /* list of subcommands */
-	PGObjectType relkind; /* type of object */
-	bool missing_ok;      /* skip error if table missing */
-} PGAlterTableStmt;
-
-typedef enum PGAlterTableType {
-	PG_AT_AddColumn,                 /* add column */
-	PG_AT_AddColumnRecurse,          /* internal to commands/tablecmds.c */
-	PG_AT_AddColumnToView,           /* implicitly via CREATE OR REPLACE VIEW */
-	PG_AT_ColumnDefault,             /* alter column default */
-	PG_AT_DropNotNull,               /* alter column drop not null */
-	PG_AT_SetNotNull,                /* alter column set not null */
-	PG_AT_SetStatistics,             /* alter column set statistics */
-	PG_AT_SetOptions,                /* alter column set ( options ) */
-	PG_AT_ResetOptions,              /* alter column reset ( options ) */
-	PG_AT_SetStorage,                /* alter column set storage */
-	PG_AT_DropColumn,                /* drop column */
-	PG_AT_DropColumnRecurse,         /* internal to commands/tablecmds.c */
-	PG_AT_AddIndex,                  /* add index */
-	PG_AT_ReAddIndex,                /* internal to commands/tablecmds.c */
-	PG_AT_AddConstraint,             /* add constraint */
-	PG_AT_AddConstraintRecurse,      /* internal to commands/tablecmds.c */
-	PG_AT_ReAddConstraint,           /* internal to commands/tablecmds.c */
-	PG_AT_AlterConstraint,           /* alter constraint */
-	PG_AT_ValidateConstraint,        /* validate constraint */
-	PG_AT_ValidateConstraintRecurse, /* internal to commands/tablecmds.c */
-	PG_AT_ProcessedConstraint,       /* pre-processed add constraint (local in
-								 * parser/parse_utilcmd.c) */
-	PG_AT_AddIndexConstraint,        /* add constraint using existing index */
-	PG_AT_DropConstraint,            /* drop constraint */
-	PG_AT_DropConstraintRecurse,     /* internal to commands/tablecmds.c */
-	PG_AT_ReAddComment,              /* internal to commands/tablecmds.c */
-	PG_AT_AlterColumnType,           /* alter column type */
-	PG_AT_AlterColumnGenericOptions, /* alter column OPTIONS (...) */
-	PG_AT_ChangeOwner,               /* change owner */
-	PG_AT_ClusterOn,                 /* CLUSTER ON */
-	PG_AT_DropCluster,               /* SET WITHOUT CLUSTER */
-	PG_AT_SetLogged,                 /* SET LOGGED */
-	PG_AT_SetUnLogged,               /* SET UNLOGGED */
-	PG_AT_AddOids,                   /* SET WITH OIDS */
-	PG_AT_AddOidsRecurse,            /* internal to commands/tablecmds.c */
-	PG_AT_DropOids,                  /* SET WITHOUT OIDS */
-	PG_AT_SetTableSpace,             /* SET TABLESPACE */
-	PG_AT_SetRelOptions,             /* SET (...) -- AM specific parameters */
-	PG_AT_ResetRelOptions,           /* RESET (...) -- AM specific parameters */
-	PG_AT_ReplaceRelOptions,         /* replace reloption list in its entirety */
-	PG_AT_EnableTrig,                /* ENABLE TRIGGER name */
-	PG_AT_EnableAlwaysTrig,          /* ENABLE ALWAYS TRIGGER name */
-	PG_AT_EnableReplicaTrig,         /* ENABLE REPLICA TRIGGER name */
-	PG_AT_DisableTrig,               /* DISABLE TRIGGER name */
-	PG_AT_EnableTrigAll,             /* ENABLE TRIGGER ALL */
-	PG_AT_DisableTrigAll,            /* DISABLE TRIGGER ALL */
-	PG_AT_EnableTrigUser,            /* ENABLE TRIGGER USER */
-	PG_AT_DisableTrigUser,           /* DISABLE TRIGGER USER */
-	PG_AT_EnableRule,                /* ENABLE RULE name */
-	PG_AT_EnableAlwaysRule,          /* ENABLE ALWAYS RULE name */
-	PG_AT_EnableReplicaRule,         /* ENABLE REPLICA RULE name */
-	PG_AT_DisableRule,               /* DISABLE RULE name */
-	PG_AT_AddInherit,                /* INHERIT parent */
-	PG_AT_DropInherit,               /* NO INHERIT parent */
-	PG_AT_AddOf,                     /* OF <type_name> */
-	PG_AT_DropOf,                    /* NOT OF */
-	PG_AT_ReplicaIdentity,           /* REPLICA IDENTITY */
-	PG_AT_EnableRowSecurity,         /* ENABLE ROW SECURITY */
-	PG_AT_DisableRowSecurity,        /* DISABLE ROW SECURITY */
-	PG_AT_ForceRowSecurity,          /* FORCE ROW SECURITY */
-	PG_AT_NoForceRowSecurity,        /* NO FORCE ROW SECURITY */
-	PG_AT_GenericOptions,            /* OPTIONS (...) */
-	PG_AT_AttachPartition,           /* ATTACH PARTITION */
-	PG_AT_DetachPartition,           /* DETACH PARTITION */
-	PG_AT_AddIdentity,               /* ADD IDENTITY */
-	PG_AT_SetIdentity,               /* SET identity column options */
-	AT_DropIdentity                  /* DROP IDENTITY */
-} PGAlterTableType;
-
-typedef struct PGAlterTableCmd /* one subcommand of an ALTER TABLE */
-{
-	PGNodeTag type;
-	PGAlterTableType subtype; /* Type of table alteration to apply */
-	char *name;               /* column, constraint, or trigger to act on,
-								 * or tablespace */
-	PGNode *def;              /* definition of new column, index,
-								 * constraint, or parent table */
-	PGDropBehavior behavior;  /* RESTRICT or CASCADE for DROP cases */
-	bool missing_ok;          /* skip error if missing? */
-} PGAlterTableCmd;
-
-/*
- * Note: PGObjectWithArgs carries only the types of the input parameters of the
- * function.  So it is sufficient to identify an existing function, but it
- * is not enough info to define a function nor to call it.
- */
-typedef struct PGObjectWithArgs {
-	PGNodeTag type;
-	PGList *objname;       /* qualified name of function/operator */
-	PGList *objargs;       /* list of Typename nodes */
-	bool args_unspecified; /* argument list was omitted, so name must
-									 * be unique (note that objargs == NIL
-									 * means zero args) */
-} PGObjectWithArgs;
-
-/* ----------------------
- *		Copy Statement
- *
- * We support "COPY relation FROM file", "COPY relation TO file", and
- * "COPY (query) TO file".  In any given PGCopyStmt, exactly one of "relation"
- * and "query" must be non-NULL.
- * ----------------------
- */
-typedef struct PGCopyStmt {
-	PGNodeTag type;
-	PGRangeVar *relation; /* the relation to copy */
-	PGNode *query;        /* the query (SELECT or DML statement with
-								 * RETURNING) to copy, as a raw parse tree */
-	PGList *attlist;      /* PGList of column names (as Strings), or NIL
-								 * for all columns */
-	bool is_from;         /* TO or FROM */
-	bool is_program;      /* is 'filename' a program to popen? */
-	char *filename;       /* filename, or NULL for STDIN/STDOUT */
-	PGList *options;      /* PGList of PGDefElem nodes */
-} PGCopyStmt;
-
-/* ----------------------
- * SET Statement (includes RESET)
- *
- * "SET var TO DEFAULT" and "RESET var" are semantically equivalent, but we
- * preserve the distinction in VariableSetKind for CreateCommandTag().
- * ----------------------
- */
-typedef enum {
-	VAR_SET_VALUE,   /* SET var = value */
-	VAR_SET_DEFAULT, /* SET var TO DEFAULT */
-	VAR_SET_CURRENT, /* SET var FROM CURRENT */
-	VAR_SET_MULTI,   /* special case for SET TRANSACTION ... */
-	VAR_RESET,       /* RESET var */
-	VAR_RESET_ALL    /* RESET ALL */
-} VariableSetKind;
-
-typedef enum {
-	VAR_SET_SCOPE_LOCAL,   /* SET LOCAL var */
-	VAR_SET_SCOPE_SESSION, /* SET SESSION var */
-	VAR_SET_SCOPE_GLOBAL,  /* SET GLOBAL var */
-	VAR_SET_SCOPE_DEFAULT  /* SET var (same as SET_SESSION) */
-} VariableSetScope;
-
-typedef struct PGVariableSetStmt {
-	PGNodeTag type;
-	VariableSetKind kind;
-	VariableSetScope scope;
-	char *name;    /* variable to be set */
-	PGList *args;  /* PGList of PGAConst nodes */
-} PGVariableSetStmt;
-
-/* ----------------------
- * Show Statement
- * ----------------------
- */
-typedef struct PGVariableShowStmt {
-	PGNodeTag   type;
-	char       *name;
-	int         is_summary; // whether or not this is a DESCRIBE or a SUMMARIZE
-} PGVariableShowStmt;
-
-/* ----------------------
- * Show Statement with Select Statement
- * ----------------------
- */
-typedef struct PGVariableShowSelectStmt
-{
-	PGNodeTag   type;
-	PGNode     *stmt;
-	char       *name;
-	int         is_summary; // whether or not this is a DESCRIBE or a SUMMARIZE
-} PGVariableShowSelectStmt;
-
-
-/* ----------------------
- *		Create Table Statement
- *
- * NOTE: in the raw gram.y output, PGColumnDef and PGConstraint nodes are
- * intermixed in tableElts, and constraints is NIL.  After parse analysis,
- * tableElts contains just ColumnDefs, and constraints contains just
- * PGConstraint nodes (in fact, only PG_CONSTR_CHECK nodes, in the present
- * implementation).
- * ----------------------
- */
-
-typedef struct PGCreateStmt {
-	PGNodeTag type;
-	PGRangeVar *relation;                 /* relation to create */
-	PGList *tableElts;                    /* column definitions (list of PGColumnDef) */
-	PGList *inhRelations;                 /* relations to inherit from (list of
-										* inhRelation) */
-	PGTypeName *ofTypename;               /* OF typename */
-	PGList *constraints;                  /* constraints (list of PGConstraint nodes) */
-	PGList *options;                      /* options from WITH clause */
-	PGOnCommitAction oncommit;            /* what do we do at COMMIT? */
-	char *tablespacename;                 /* table space to use, or NULL */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateStmt;
-
-/* ----------
- * Definitions for constraints in PGCreateStmt
- *
- * Note that column defaults are treated as a type of constraint,
- * even though that's a bit odd semantically.
- *
- * For constraints that use expressions (CONSTR_CHECK, PG_CONSTR_DEFAULT)
- * we may have the expression in either "raw" form (an untransformed
- * parse tree) or "cooked" form (the nodeToString representation of
- * an executable expression tree), depending on how this PGConstraint
- * node was created (by parsing, or by inheritance from an existing
- * relation).  We should never have both in the same node!
- *
- * PG_FKCONSTR_ACTION_xxx values are stored into pg_constraint.confupdtype
- * and pg_constraint.confdeltype columns; PG_FKCONSTR_MATCH_xxx values are
- * stored into pg_constraint.confmatchtype.  Changing the code values may
- * require an initdb!
- *
- * If skip_validation is true then we skip checking that the existing rows
- * in the table satisfy the constraint, and just install the catalog entries
- * for the constraint.  A new FK constraint is marked as valid iff
- * initially_valid is true.  (Usually skip_validation and initially_valid
- * are inverses, but we can set both true if the table is known empty.)
- *
- * PGConstraint attributes (DEFERRABLE etc) are initially represented as
- * separate PGConstraint nodes for simplicity of parsing.  parse_utilcmd.c makes
- * a pass through the constraints list to insert the info into the appropriate
- * PGConstraint node.
- * ----------
- */
-
-typedef enum PGConstrType /* types of constraints */
-{ PG_CONSTR_NULL,         /* not standard SQL, but a lot of people
-								 * expect it */
-  PG_CONSTR_NOTNULL,
-  PG_CONSTR_DEFAULT,
-  PG_CONSTR_IDENTITY,
-  PG_CONSTR_CHECK,
-  PG_CONSTR_PRIMARY,
-  PG_CONSTR_UNIQUE,
-  PG_CONSTR_EXCLUSION,
-  PG_CONSTR_FOREIGN,
-  PG_CONSTR_ATTR_DEFERRABLE, /* attributes for previous constraint node */
-  PG_CONSTR_ATTR_NOT_DEFERRABLE,
-  PG_CONSTR_ATTR_DEFERRED,
-  PG_CONSTR_ATTR_IMMEDIATE,
-  PG_CONSTR_COMPRESSION,
-  PG_CONSTR_GENERATED_VIRTUAL,
-  PG_CONSTR_GENERATED_STORED,
-  } PGConstrType;
-
-/* Foreign key action codes */
-#define PG_FKCONSTR_ACTION_NOACTION 'a'
-#define PG_FKCONSTR_ACTION_RESTRICT 'r'
-#define PG_FKCONSTR_ACTION_CASCADE 'c'
-#define PG_FKCONSTR_ACTION_SETNULL 'n'
-#define PG_FKCONSTR_ACTION_SETDEFAULT 'd'
-
-/* Foreign key matchtype codes */
-#define PG_FKCONSTR_MATCH_FULL 'f'
-#define PG_FKCONSTR_MATCH_PARTIAL 'p'
-#define PG_FKCONSTR_MATCH_SIMPLE 's'
-
-typedef struct PGConstraint {
-	PGNodeTag type;
-	PGConstrType contype; /* see above */
-
-	/* Fields used for most/all constraint types: */
-	char *conname;     /* PGConstraint name, or NULL if unnamed */
-	bool deferrable;   /* DEFERRABLE? */
-	bool initdeferred; /* INITIALLY DEFERRED? */
-	int location;      /* token location, or -1 if unknown */
-
-	/* Fields used for constraints with expressions (CHECK and DEFAULT): */
-	bool is_no_inherit; /* is constraint non-inheritable? */
-	PGNode *raw_expr;   /* expr, as untransformed parse tree */
-	char *cooked_expr;  /* expr, as nodeToString representation */
-	char generated_when;
-
-	/* Fields used for unique constraints (UNIQUE and PRIMARY KEY): */
-	PGList *keys; /* String nodes naming referenced column(s) */
-
-	/* Fields used for EXCLUSION constraints: */
-	PGList *exclusions; /* list of (PGIndexElem, operator name) pairs */
-
-	/* Fields used for index constraints (UNIQUE, PRIMARY KEY, EXCLUSION): */
-	PGList *options;  /* options from WITH clause */
-	char *indexname;  /* existing index to use; otherwise NULL */
-	char *indexspace; /* index tablespace; NULL for default */
-	/* These could be, but currently are not, used for UNIQUE/PKEY: */
-	char *access_method;  /* index access method; NULL for default */
-	PGNode *where_clause; /* partial index predicate */
-
-	/* Fields used for FOREIGN KEY constraints: */
-	PGRangeVar *pktable;   /* Primary key table */
-	PGList *fk_attrs;      /* Attributes of foreign key */
-	PGList *pk_attrs;      /* Corresponding attrs in PK table */
-	char fk_matchtype;     /* FULL, PARTIAL, SIMPLE */
-	char fk_upd_action;    /* ON UPDATE action */
-	char fk_del_action;    /* ON DELETE action */
-	PGList *old_conpfeqop; /* pg_constraint.conpfeqop of my former self */
-	PGOid old_pktable_oid; /* pg_constraint.confrelid of my former
-									 * self */
-
-	/* Fields used for constraints that allow a NOT VALID specification */
-	bool skip_validation; /* skip validation of existing rows? */
-	bool initially_valid; /* mark the new constraint as valid? */
-
-
-	/* Field Used for COMPRESSION constraint */
-	char *compression_name;  /* existing index to use; otherwise NULL */
-
-} PGConstraint;
-
-/* ----------------------
- *		{Create|Alter} SEQUENCE Statement
- * ----------------------
- */
-
-typedef struct PGCreateSeqStmt {
-	PGNodeTag type;
-	PGRangeVar *sequence; /* the sequence to create */
-	PGList *options;
-	PGOid ownerId; /* ID of owner, or InvalidOid for default */
-	bool for_identity;
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateSeqStmt;
-
-typedef struct PGAlterSeqStmt {
-	PGNodeTag type;
-	PGRangeVar *sequence; /* the sequence to alter */
-	PGList *options;
-	bool for_identity;
-	bool missing_ok; /* skip error if a role is missing? */
-} PGAlterSeqStmt;
-
-/* ----------------------
- *		CREATE FUNCTION Statement
- * ----------------------
- */
-
-typedef struct PGCreateFunctionStmt {
-	PGNodeTag type;
-	PGRangeVar *name;
-	PGList *params;
-	PGNode *function;
-  	PGNode *query;
-	char relpersistence;
-} PGCreateFunctionStmt;
-
-/* ----------------------
- *		Drop Table|Sequence|View|Index|Type|Domain|Conversion|Schema Statement
- * ----------------------
- */
-
-typedef struct PGDropStmt {
-	PGNodeTag type;
-	PGList *objects;         /* list of names */
-	PGObjectType removeType; /* object type */
-	PGDropBehavior behavior; /* RESTRICT or CASCADE behavior */
-	bool missing_ok;         /* skip error if object is missing? */
-	bool concurrent;         /* drop index concurrently? */
-} PGDropStmt;
-
-/* ----------------------
- *		Create PGIndex Statement
- *
- * This represents creation of an index and/or an associated constraint.
- * If isconstraint is true, we should create a pg_constraint entry along
- * with the index.  But if indexOid isn't InvalidOid, we are not creating an
- * index, just a UNIQUE/PKEY constraint using an existing index.  isconstraint
- * must always be true in this case, and the fields describing the index
- * properties are empty.
- * ----------------------
- */
-typedef struct PGIndexStmt {
-	PGNodeTag type;
-	char *idxname;          /* name of new index, or NULL for default */
-	PGRangeVar *relation;   /* relation to build index on */
-	char *accessMethod;     /* name of access method (eg. btree) */
-	char *tableSpace;       /* tablespace, or NULL for default */
-	PGList *indexParams;    /* columns to index: a list of PGIndexElem */
-	PGList *options;        /* WITH clause options: a list of PGDefElem */
-	PGNode *whereClause;    /* qualification (partial-index predicate) */
-	PGList *excludeOpNames; /* exclusion operator names, or NIL if none */
-	char *idxcomment;       /* comment to apply to index, or NULL */
-	PGOid indexOid;         /* OID of an existing index, if any */
-	PGOid oldNode;          /* relfilenode of existing storage, if any */
-	bool unique;            /* is index unique? */
-	bool primary;           /* is index a primary key? */
-	bool isconstraint;      /* is it for a pkey/unique constraint? */
-	bool deferrable;        /* is the constraint DEFERRABLE? */
-	bool initdeferred;      /* is the constraint INITIALLY DEFERRED? */
-	bool transformed;       /* true when transformIndexStmt is finished */
-	bool concurrent;        /* should this be a concurrent index build? */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGIndexStmt;
-
-/* ----------------------
- *		Alter Object Rename Statement
- * ----------------------
- */
-typedef struct PGRenameStmt {
-	PGNodeTag type;
-	PGObjectType renameType;   /* PG_OBJECT_TABLE, PG_OBJECT_COLUMN, etc */
-	PGObjectType relationType; /* if column name, associated relation type */
-	PGRangeVar *relation;      /* in case it's a table */
-	PGNode *object;            /* in case it's some other object */
-	char *subname;             /* name of contained object (column, rule,
-								 * trigger, etc) */
-	char *newname;             /* the new name */
-	PGDropBehavior behavior;   /* RESTRICT or CASCADE behavior */
-	bool missing_ok;           /* skip error if missing? */
-} PGRenameStmt;
-
-/* ----------------------
- *		ALTER object SET SCHEMA Statement
- * ----------------------
- */
-typedef struct PGAlterObjectSchemaStmt {
-	PGNodeTag type;
-	PGObjectType objectType; /* PG_OBJECT_TABLE, PG_OBJECT_TYPE, etc */
-	PGRangeVar *relation;    /* in case it's a table */
-	PGNode *object;          /* in case it's some other object */
-	char *newschema;         /* the new schema */
-	bool missing_ok;         /* skip error if missing? */
-} PGAlterObjectSchemaStmt;
-
-/* ----------------------
- *		{Begin|Commit|Rollback} Transaction Statement
- * ----------------------
- */
-typedef enum PGTransactionStmtKind {
-	PG_TRANS_STMT_BEGIN,
-	PG_TRANS_STMT_START, /* semantically identical to BEGIN */
-	PG_TRANS_STMT_COMMIT,
-	PG_TRANS_STMT_ROLLBACK,
-	PG_TRANS_STMT_SAVEPOINT,
-	PG_TRANS_STMT_RELEASE,
-	PG_TRANS_STMT_ROLLBACK_TO,
-	PG_TRANS_STMT_PREPARE,
-	PG_TRANS_STMT_COMMIT_PREPARED,
-	TRANS_STMT_ROLLBACK_PREPARED
-} PGTransactionStmtKind;
-
-typedef struct PGTransactionStmt {
-	PGNodeTag type;
-	PGTransactionStmtKind kind; /* see above */
-	PGList *options;            /* for BEGIN/START and savepoint commands */
-	char *gid;                  /* for two-phase-commit related commands */
-} PGTransactionStmt;
-
-/* ----------------------
- *		Create View Statement
- * ----------------------
- */
-typedef enum PGViewCheckOption { PG_NO_CHECK_OPTION, PG_LOCAL_CHECK_OPTION, CASCADED_CHECK_OPTION } PGViewCheckOption;
-
-typedef struct PGViewStmt {
-	PGNodeTag type;
-	PGRangeVar *view;                  /* the view to be created */
-	PGList *aliases;                   /* target column names */
-	PGNode *query;                     /* the SELECT query (as a raw parse tree) */
-	PGOnCreateConflict onconflict;     /* what to do on create conflict */
-	PGList *options;                   /* options from WITH clause */
-	PGViewCheckOption withCheckOption; /* WITH CHECK OPTION */
-} PGViewStmt;
-
-/* ----------------------
- *		Load Statement
- * ----------------------
- */
-
-typedef enum PGLoadInstallType { PG_LOAD_TYPE_LOAD,  PG_LOAD_TYPE_INSTALL, PG_LOAD_TYPE_FORCE_INSTALL } PGLoadInstallType;
-
-
-typedef struct PGLoadStmt {
-	PGNodeTag type;
-	const char *filename; /* file to load */
-	PGLoadInstallType load_type;
-} PGLoadStmt;
-
-/* ----------------------
- *		Vacuum and Analyze Statements
- *
- * Even though these are nominally two statements, it's convenient to use
- * just one node type for both.  Note that at least one of PG_VACOPT_VACUUM
- * and PG_VACOPT_ANALYZE must be set in options.
- * ----------------------
- */
-typedef enum PGVacuumOption {
-	PG_VACOPT_VACUUM = 1 << 0,               /* do VACUUM */
-	PG_VACOPT_ANALYZE = 1 << 1,              /* do ANALYZE */
-	PG_VACOPT_VERBOSE = 1 << 2,              /* print progress info */
-	PG_VACOPT_FREEZE = 1 << 3,               /* FREEZE option */
-	PG_VACOPT_FULL = 1 << 4,                 /* FULL (non-concurrent) vacuum */
-	PG_VACOPT_NOWAIT = 1 << 5,               /* don't wait to get lock (autovacuum only) */
-	PG_VACOPT_SKIPTOAST = 1 << 6,            /* don't process the TOAST table, if any */
-	PG_VACOPT_DISABLE_PAGE_SKIPPING = 1 << 7 /* don't skip any pages */
-} PGVacuumOption;
-
-typedef struct PGVacuumStmt {
-	PGNodeTag type;
-	int options;          /* OR of PGVacuumOption flags */
-	PGRangeVar *relation; /* single table to process, or NULL */
-	PGList *va_cols;      /* list of column names, or NIL for all */
-} PGVacuumStmt;
-
-/* ----------------------
- *		Explain Statement
- *
- * The "query" field is initially a raw parse tree, and is converted to a
- * PGQuery node during parse analysis.  Note that rewriting and planning
- * of the query are always postponed until execution.
- * ----------------------
- */
-typedef struct PGExplainStmt {
-	PGNodeTag type;
-	PGNode *query;   /* the query (see comments above) */
-	PGList *options; /* list of PGDefElem nodes */
-} PGExplainStmt;
-
-/* ----------------------
- *		CREATE TABLE AS Statement (a/k/a SELECT INTO)
- *
- * A query written as CREATE TABLE AS will produce this node type natively.
- * A query written as SELECT ... INTO will be transformed to this form during
- * parse analysis.
- * A query written as CREATE MATERIALIZED view will produce this node type,
- * during parse analysis, since it needs all the same data.
- *
- * The "query" field is handled similarly to EXPLAIN, though note that it
- * can be a SELECT or an EXECUTE, but not other DML statements.
- * ----------------------
- */
-typedef struct PGCreateTableAsStmt {
-	PGNodeTag type;
-	PGNode *query;        /* the query (see comments above) */
-	PGIntoClause *into;   /* destination table */
-	PGObjectType relkind; /* PG_OBJECT_TABLE or PG_OBJECT_MATVIEW */
-	bool is_select_into;  /* it was written as SELECT INTO */
-	PGOnCreateConflict onconflict;        /* what to do on create conflict */
-} PGCreateTableAsStmt;
-
-/* ----------------------
- * Checkpoint Statement
- * ----------------------
- */
-typedef struct PGCheckPointStmt {
-	PGNodeTag type;
-	bool force;
-} PGCheckPointStmt;
-
-/* ----------------------
- *		PREPARE Statement
- * ----------------------
- */
-typedef struct PGPrepareStmt {
-	PGNodeTag type;
-	char *name;       /* Name of plan, arbitrary */
-	PGList *argtypes; /* Types of parameters (PGList of PGTypeName) */
-	PGNode *query;    /* The query itself (as a raw parsetree) */
-} PGPrepareStmt;
-
-/* ----------------------
- *		EXECUTE Statement
- * ----------------------
- */
-
-typedef struct PGExecuteStmt {
-	PGNodeTag type;
-	char *name;     /* The name of the plan to execute */
-	PGList *params; /* Values to assign to parameters */
-} PGExecuteStmt;
-
-/* ----------------------
- *		DEALLOCATE Statement
- * ----------------------
- */
-typedef struct PGDeallocateStmt {
-	PGNodeTag type;
-	char *name; /* The name of the plan to remove */
-	            /* NULL means DEALLOCATE ALL */
-} PGDeallocateStmt;
-
-/* ----------------------
- * PRAGMA statements
- * Three types of pragma statements:
- * PRAGMA pragma_name;          (NOTHING)
- * PRAGMA pragma_name='param';  (ASSIGNMENT)
- * PRAGMA pragma_name('param'); (CALL)
- * ----------------------
- */
-typedef enum { PG_PRAGMA_TYPE_NOTHING, PG_PRAGMA_TYPE_ASSIGNMENT, PG_PRAGMA_TYPE_CALL } PGPragmaKind;
-
-typedef struct PGPragmaStmt {
-	PGNodeTag type;
-	PGPragmaKind kind;
-	char *name;   /* variable to be set */
-	PGList *args; /* PGList of PGAConst nodes */
-} PGPragmaStmt;
-
-/* ----------------------
- *		CALL Statement
- * ----------------------
- */
-
-typedef struct PGCallStmt {
-	PGNodeTag type;
-	PGNode *func;
-} PGCallStmt;
-
-/* ----------------------
- *		EXPORT/IMPORT Statements
- * ----------------------
- */
-
-typedef struct PGExportStmt {
-	PGNodeTag type;
-	char *filename;       /* filename */
-	PGList *options;      /* PGList of PGDefElem nodes */
-} PGExportStmt;
-
-typedef struct PGImportStmt {
-	PGNodeTag type;
-	char *filename;       /* filename */
-} PGImportStmt;
-
-/* ----------------------
- *		Interval Constant
- * ----------------------
- */
-typedef struct PGIntervalConstant {
-	PGNodeTag type;
-	int val_type;         /* interval constant type, either duckdb_libpgquery::T_PGString, duckdb_libpgquery::T_PGInteger or duckdb_libpgquery::T_PGAExpr */
-	char *sval;           /* duckdb_libpgquery::T_PGString */
-	int ival;             /* duckdb_libpgquery::T_PGString */
-	PGNode *eval;         /* duckdb_libpgquery::T_PGAExpr */
-	PGList *typmods;      /* how to interpret the interval constant (year, month, day, etc)  */
-	int location;         /* token location, or -1 if unknown */
-} PGIntervalConstant;
-
-/* ----------------------
- *		Sample Options
- * ----------------------
- */
-typedef struct PGSampleSize {
-	PGNodeTag type;
-	bool is_percentage;   /* whether or not the sample size is expressed in row numbers or a percentage */
-	PGValue sample_size;  /* sample size */
-} PGSampleSize;
-
-typedef struct PGSampleOptions {
-	PGNodeTag type;
-	PGNode *sample_size;      /* the size of the sample to take */
-	char *method;             /* sample method, or NULL for default */
-	int seed;                 /* seed, or NULL for default; */
-	int location;             /* token location, or -1 if unknown */
-} PGSampleOptions;
-
-/* ----------------------
- *      Limit Percentage
- * ----------------------
- */
-typedef struct PGLimitPercent {
-	PGNodeTag type;
-    PGNode* limit_percent;  /* limit percent */
-} PGLimitPercent;
-
-/* ----------------------
- *		Lambda Function (or Arrow Operator)
- * ----------------------
- */
-typedef struct PGLambdaFunction {
-	PGNodeTag type;
-	PGNode *lhs;                 /* list of input parameters */
-	PGNode *rhs;                 /* lambda expression */
-	int location;                /* token location, or -1 if unknown */
-} PGLambdaFunction;
-
-/* ----------------------
- *		Positional Reference
- * ----------------------
- */
-typedef struct PGPositionalReference {
-	PGNodeTag type;
-	int position;
-	int location;                /* token location, or -1 if unknown */
-} PGPositionalReference;
-
-/* ----------------------
- *		Type Statement
- * ----------------------
- */
-
-typedef enum { PG_NEWTYPE_NONE, PG_NEWTYPE_ENUM, PG_NEWTYPE_ALIAS } PGNewTypeKind;
-
-typedef struct PGCreateTypeStmt
-{
-	PGNodeTag		type;
-	PGNewTypeKind	kind;
-	PGList	   *typeName;		/* qualified name (list of Value strings) */
-	PGList	   *vals;			/* enum values (list of Value strings) */
-	PGTypeName *ofType;			/* original type of alias name */
-} PGCreateTypeStmt;
-
-
-
-
-
-}
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb {
-
-class ColumnDefinition;
-class StackChecker;
-struct OrderByNode;
-struct CopyInfo;
-struct CommonTableExpressionInfo;
-struct GroupingExpressionMap;
-
-//! The transformer class is responsible for transforming the internal Postgres
-//! parser representation into the DuckDB representation
-class Transformer {
-	friend class StackChecker;
-
-public:
-	explicit Transformer(idx_t max_expression_depth_p);
-	explicit Transformer(Transformer *parent);
-
-	//! Transforms a Postgres parse tree into a set of SQL Statements
-	bool TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements);
-	string NodetypeToString(duckdb_libpgquery::PGNodeTag type);
-
-	idx_t ParamCount() {
-		return parent ? parent->ParamCount() : prepared_statement_parameter_index;
-	}
-
-private:
-	Transformer *parent;
-	idx_t max_expression_depth;
-	//! The current prepared statement parameter index
-	idx_t prepared_statement_parameter_index = 0;
-	//! Holds window expressions defined by name. We need those when transforming the expressions referring to them.
-	unordered_map<string, duckdb_libpgquery::PGWindowDef *> window_clauses;
-
-	void SetParamCount(idx_t new_count) {
-		if (parent) {
-			parent->SetParamCount(new_count);
-		} else {
-			this->prepared_statement_parameter_index = new_count;
-		}
-	}
-
-private:
-	//! Transforms a Postgres statement into a single SQL statement
-	unique_ptr<SQLStatement> TransformStatement(duckdb_libpgquery::PGNode *stmt);
-	//! Transforms a Postgres statement into a single SQL statement
-	unique_ptr<SQLStatement> TransformStatementInternal(duckdb_libpgquery::PGNode *stmt);
-	//===--------------------------------------------------------------------===//
-	// Statement transformation
-	//===--------------------------------------------------------------------===//
-	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a SelectStatement
-	unique_ptr<SelectStatement> TransformSelect(duckdb_libpgquery::PGNode *node, bool isSelect = true);
-	//! Transform a Postgres T_AlterStmt node into a AlterStatement
-	unique_ptr<AlterStatement> TransformAlter(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGRenameStmt node into a RenameStatement
-	unique_ptr<AlterStatement> TransformRename(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateTable(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateTableAs(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateSchema(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateSeqStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateSequence(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGViewStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateView(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGIndexStmt node into CreateStatement
-	unique_ptr<CreateStatement> TransformCreateIndex(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateFunctionStmt node into CreateStatement
-	unique_ptr<CreateStatement> TransformCreateFunction(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateTypeStmt node into CreateStatement
-	unique_ptr<CreateStatement> TransformCreateType(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGAlterSeqStmt node into CreateStatement
-	unique_ptr<AlterStatement> TransformAlterSequence(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGDropStmt node into a Drop[Table,Schema]Statement
-	unique_ptr<SQLStatement> TransformDrop(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGInsertStmt node into a InsertStatement
-	unique_ptr<InsertStatement> TransformInsert(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCopyStmt node into a CopyStatement
-	unique_ptr<CopyStatement> TransformCopy(duckdb_libpgquery::PGNode *node);
-	void TransformCopyOptions(CopyInfo &info, duckdb_libpgquery::PGList *options);
-	//! Transform a Postgres duckdb_libpgquery::T_PGTransactionStmt node into a TransactionStatement
-	unique_ptr<TransactionStatement> TransformTransaction(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres T_DeleteStatement node into a DeleteStatement
-	unique_ptr<DeleteStatement> TransformDelete(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGUpdateStmt node into a UpdateStatement
-	unique_ptr<UpdateStatement> TransformUpdate(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGPragmaStmt node into a PragmaStatement
-	unique_ptr<SQLStatement> TransformPragma(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGExportStmt node into a ExportStatement
-	unique_ptr<ExportStatement> TransformExport(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres duckdb_libpgquery::T_PGImportStmt node into a PragmaStatement
-	unique_ptr<PragmaStatement> TransformImport(duckdb_libpgquery::PGNode *node);
-	unique_ptr<ExplainStatement> TransformExplain(duckdb_libpgquery::PGNode *node);
-	unique_ptr<VacuumStatement> TransformVacuum(duckdb_libpgquery::PGNode *node);
-	unique_ptr<SQLStatement> TransformShow(duckdb_libpgquery::PGNode *node);
-	unique_ptr<ShowStatement> TransformShowSelect(duckdb_libpgquery::PGNode *node);
-
-	unique_ptr<PrepareStatement> TransformPrepare(duckdb_libpgquery::PGNode *node);
-	unique_ptr<ExecuteStatement> TransformExecute(duckdb_libpgquery::PGNode *node);
-	unique_ptr<CallStatement> TransformCall(duckdb_libpgquery::PGNode *node);
-	unique_ptr<DropStatement> TransformDeallocate(duckdb_libpgquery::PGNode *node);
-	unique_ptr<SetStatement> TransformSet(duckdb_libpgquery::PGNode *node);
-	unique_ptr<SQLStatement> TransformCheckpoint(duckdb_libpgquery::PGNode *node);
-	unique_ptr<LoadStatement> TransformLoad(duckdb_libpgquery::PGNode *node);
-
-	//===--------------------------------------------------------------------===//
-	// Query Node Transform
-	//===--------------------------------------------------------------------===//
-	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a QueryNode
-	unique_ptr<QueryNode> TransformSelectNode(duckdb_libpgquery::PGSelectStmt *node);
-
-	//===--------------------------------------------------------------------===//
-	// Expression Transform
-	//===--------------------------------------------------------------------===//
-	//! Transform a Postgres boolean expression into an Expression
-	unique_ptr<ParsedExpression> TransformBoolExpr(duckdb_libpgquery::PGBoolExpr *root);
-	//! Transform a Postgres case expression into an Expression
-	unique_ptr<ParsedExpression> TransformCase(duckdb_libpgquery::PGCaseExpr *root);
-	//! Transform a Postgres type cast into an Expression
-	unique_ptr<ParsedExpression> TransformTypeCast(duckdb_libpgquery::PGTypeCast *root);
-	//! Transform a Postgres coalesce into an Expression
-	unique_ptr<ParsedExpression> TransformCoalesce(duckdb_libpgquery::PGAExpr *root);
-	//! Transform a Postgres column reference into an Expression
-	unique_ptr<ParsedExpression> TransformColumnRef(duckdb_libpgquery::PGColumnRef *root);
-	//! Transform a Postgres constant value into an Expression
-	unique_ptr<ConstantExpression> TransformValue(duckdb_libpgquery::PGValue val);
-	//! Transform a Postgres operator into an Expression
-	unique_ptr<ParsedExpression> TransformAExpr(duckdb_libpgquery::PGAExpr *root);
-	unique_ptr<ParsedExpression> TransformAExprInternal(duckdb_libpgquery::PGAExpr *root);
-	//! Transform a Postgres abstract expression into an Expression
-	unique_ptr<ParsedExpression> TransformExpression(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres function call into an Expression
-	unique_ptr<ParsedExpression> TransformFuncCall(duckdb_libpgquery::PGFuncCall *root);
-	//! Transform a Postgres boolean expression into an Expression
-	unique_ptr<ParsedExpression> TransformInterval(duckdb_libpgquery::PGIntervalConstant *root);
-	//! Transform a Postgres lambda node [e.g. (x, y) -> x + y] into a lambda expression
-	unique_ptr<ParsedExpression> TransformLambda(duckdb_libpgquery::PGLambdaFunction *node);
-	//! Transform a Postgres array access node (e.g. x[1] or x[1:3])
-	unique_ptr<ParsedExpression> TransformArrayAccess(duckdb_libpgquery::PGAIndirection *node);
-	//! Transform a positional reference (e.g. #1)
-	unique_ptr<ParsedExpression> TransformPositionalReference(duckdb_libpgquery::PGPositionalReference *node);
-	unique_ptr<ParsedExpression> TransformStarExpression(duckdb_libpgquery::PGNode *node);
-
-	//! Transform a Postgres constant value into an Expression
-	unique_ptr<ParsedExpression> TransformConstant(duckdb_libpgquery::PGAConst *c);
-	unique_ptr<ParsedExpression> TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc *n);
-	unique_ptr<ParsedExpression> TransformResTarget(duckdb_libpgquery::PGResTarget *root);
-	unique_ptr<ParsedExpression> TransformNullTest(duckdb_libpgquery::PGNullTest *root);
-	unique_ptr<ParsedExpression> TransformParamRef(duckdb_libpgquery::PGParamRef *node);
-	unique_ptr<ParsedExpression> TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr *root);
-
-	unique_ptr<ParsedExpression> TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction *node);
-
-	unique_ptr<ParsedExpression> TransformSubquery(duckdb_libpgquery::PGSubLink *root);
-	//===--------------------------------------------------------------------===//
-	// Constraints transform
-	//===--------------------------------------------------------------------===//
-	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell *cell);
-
-	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell *cell, ColumnDefinition &column,
-	                                           idx_t index);
-
-	//===--------------------------------------------------------------------===//
-	// Collation transform
-	//===--------------------------------------------------------------------===//
-	unique_ptr<ParsedExpression> TransformCollateExpr(duckdb_libpgquery::PGCollateClause *collate);
-
-	string TransformCollation(duckdb_libpgquery::PGCollateClause *collate);
-
-	ColumnDefinition TransformColumnDefinition(duckdb_libpgquery::PGColumnDef *cdef);
-	//===--------------------------------------------------------------------===//
-	// Helpers
-	//===--------------------------------------------------------------------===//
-	OnCreateConflict TransformOnConflict(duckdb_libpgquery::PGOnCreateConflict conflict);
-	string TransformAlias(duckdb_libpgquery::PGAlias *root, vector<string> &column_name_alias);
-	void TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause, CommonTableExpressionMap &cte_map);
-	unique_ptr<SelectStatement> TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr *node,
-	                                                  CommonTableExpressionInfo &info);
-
-	unique_ptr<ParsedExpression> TransformUnaryOperator(const string &op, unique_ptr<ParsedExpression> child);
-	unique_ptr<ParsedExpression> TransformBinaryOperator(const string &op, unique_ptr<ParsedExpression> left,
-	                                                     unique_ptr<ParsedExpression> right);
-	//===--------------------------------------------------------------------===//
-	// TableRef transform
-	//===--------------------------------------------------------------------===//
-	//! Transform a Postgres node into a TableRef
-	unique_ptr<TableRef> TransformTableRefNode(duckdb_libpgquery::PGNode *node);
-	//! Transform a Postgres FROM clause into a TableRef
-	unique_ptr<TableRef> TransformFrom(duckdb_libpgquery::PGList *root);
-	//! Transform a Postgres table reference into a TableRef
-	unique_ptr<TableRef> TransformRangeVar(duckdb_libpgquery::PGRangeVar *root);
-	//! Transform a Postgres table-producing function into a TableRef
-	unique_ptr<TableRef> TransformRangeFunction(duckdb_libpgquery::PGRangeFunction *root);
-	//! Transform a Postgres join node into a TableRef
-	unique_ptr<TableRef> TransformJoin(duckdb_libpgquery::PGJoinExpr *root);
-	//! Transform a table producing subquery into a TableRef
-	unique_ptr<TableRef> TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect *root);
-	//! Transform a VALUES list into a set of expressions
-	unique_ptr<TableRef> TransformValuesList(duckdb_libpgquery::PGList *list);
-
-	//! Transform a range var into a (schema) qualified name
-	QualifiedName TransformQualifiedName(duckdb_libpgquery::PGRangeVar *root);
-
-	//! Transform a Postgres TypeName string into a LogicalType
-	LogicalType TransformTypeName(duckdb_libpgquery::PGTypeName *name);
-
-	//! Transform a Postgres GROUP BY expression into a list of Expression
-	bool TransformGroupBy(duckdb_libpgquery::PGList *group, SelectNode &result);
-	void TransformGroupByNode(duckdb_libpgquery::PGNode *n, GroupingExpressionMap &map, SelectNode &result,
-	                          vector<GroupingSet> &result_sets);
-	void AddGroupByExpression(unique_ptr<ParsedExpression> expression, GroupingExpressionMap &map, GroupByNode &result,
-	                          vector<idx_t> &result_set);
-	void TransformGroupByExpression(duckdb_libpgquery::PGNode *n, GroupingExpressionMap &map, GroupByNode &result,
-	                                vector<idx_t> &result_set);
-	//! Transform a Postgres ORDER BY expression into an OrderByDescription
-	bool TransformOrderBy(duckdb_libpgquery::PGList *order, vector<OrderByNode> &result);
-
-	//! Transform a Postgres SELECT clause into a list of Expressions
-	void TransformExpressionList(duckdb_libpgquery::PGList &list, vector<unique_ptr<ParsedExpression>> &result);
-
-	//! Transform a Postgres PARTITION BY/ORDER BY specification into lists of expressions
-	void TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr);
-	//! Transform a Postgres window frame specification into frame expressions
-	void TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr);
-
-	unique_ptr<SampleOptions> TransformSampleOptions(duckdb_libpgquery::PGNode *options);
-
-private:
-	//! Current stack depth
-	idx_t stack_depth;
-
-	void InitializeStackCheck();
-	StackChecker StackCheck(idx_t extra_stack = 1);
-};
-
-class StackChecker {
-public:
-	StackChecker(Transformer &transformer, idx_t stack_usage);
-	~StackChecker();
-	StackChecker(StackChecker &&) noexcept;
-	StackChecker(const StackChecker &) = delete;
-
-private:
-	Transformer &transformer;
-	idx_t stack_usage;
-};
-
-vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/extension_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class ExtensionStatement : public SQLStatement {
-public:
-	ExtensionStatement(ParserExtension extension, unique_ptr<ParserExtensionParseData> parse_data);
-
-	//! The ParserExtension this statement was generated from
-	ParserExtension extension;
-	//! The parse data for this specific statement
-	unique_ptr<ParserExtensionParseData> parse_data;
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// postgres_parser.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <string>
-#include <vector>
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-
-
-#include <cstdint>
-#include <string>
-
-namespace duckdb_libpgquery {
-
-enum class PGSimplifiedTokenType : uint8_t {
-	PG_SIMPLIFIED_TOKEN_IDENTIFIER,
-	PG_SIMPLIFIED_TOKEN_NUMERIC_CONSTANT,
-	PG_SIMPLIFIED_TOKEN_STRING_CONSTANT,
-	PG_SIMPLIFIED_TOKEN_OPERATOR,
-	PG_SIMPLIFIED_TOKEN_KEYWORD,
-	PG_SIMPLIFIED_TOKEN_COMMENT
-};
-
-struct PGSimplifiedToken {
-	PGSimplifiedTokenType type;
-	int32_t start;
-};
-
-enum class PGKeywordCategory : uint8_t {
-	PG_KEYWORD_RESERVED,
-	PG_KEYWORD_UNRESERVED,
-	PG_KEYWORD_TYPE_FUNC,
-	PG_KEYWORD_COL_NAME
-};
-
-struct PGKeyword {
-	std::string text;
-	PGKeywordCategory category;
-};
-
-}
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb {
-class PostgresParser {
-public:
-	PostgresParser();
-	~PostgresParser();
-
-	bool success;
-	duckdb_libpgquery::PGList *parse_tree;
-	std::string error_message;
-	int error_location;
-public:
-	void Parse(const std::string &query);
-	static std::vector<duckdb_libpgquery::PGSimplifiedToken> Tokenize(const std::string &query);
-
-	static bool IsKeyword(const std::string &text);
-	static std::vector<duckdb_libpgquery::PGKeyword> KeywordList();
-
-	static void SetPreserveIdentifierCase(bool downcase);
-};
-
-}
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * parser.h
- *		Definitions for the "raw" parser (flex and bison phases only)
- *
- * This is the external API for the raw lexing/parsing functions.
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/parser.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-#include <vector>
-
-namespace duckdb_libpgquery {
-
-typedef enum PGBackslashQuoteType {
-	PG_BACKSLASH_QUOTE_OFF,
-	PG_BACKSLASH_QUOTE_ON,
-	PG_BACKSLASH_QUOTE_SAFE_ENCODING
-} PGBackslashQuoteType;
-
-/* Primary entry point for the raw parsing functions */
-PGList *raw_parser(const char *str);
-
-bool is_keyword(const char *str);
-std::vector<PGKeyword> keyword_list();
-
-std::vector<PGSimplifiedToken> tokenize(const char *str);
-
-/* Utility functions exported by gram.y (perhaps these should be elsewhere) */
-PGList *SystemFuncName(const char *name);
-PGTypeName *SystemTypeName(const char *name);
-
-}
-
-// LICENSE_CHANGE_END
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/alter_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class AlterStatement : public SQLStatement {
-public:
-	AlterStatement();
-
-	unique_ptr<AlterInfo> info;
-
-protected:
-	AlterStatement(const AlterStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/call_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class CallStatement : public SQLStatement {
-public:
-	CallStatement();
-
-	unique_ptr<ParsedExpression> function;
-
-protected:
-	CallStatement(const CallStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/execute_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class ExecuteStatement : public SQLStatement {
-public:
-	ExecuteStatement();
-
-	string name;
-	vector<unique_ptr<ParsedExpression>> values;
-
-protected:
-	ExecuteStatement(const ExecuteStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/export_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class ExportStatement : public SQLStatement {
-public:
-	explicit ExportStatement(unique_ptr<CopyInfo> info);
-
-	unique_ptr<CopyInfo> info;
-
-protected:
-	ExportStatement(const ExportStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/load_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class LoadStatement : public SQLStatement {
-public:
-	LoadStatement();
-
-protected:
-	LoadStatement(const LoadStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-
-	unique_ptr<LoadInfo> info;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/prepare_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class PrepareStatement : public SQLStatement {
-public:
-	PrepareStatement();
-
-	unique_ptr<SQLStatement> statement;
-	string name;
-
-protected:
-	PrepareStatement(const PrepareStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/set_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class SetStatement : public SQLStatement {
-public:
-	SetStatement(std::string name_p, Value value_p, SetScope scope_p);
-
-protected:
-	SetStatement(const SetStatement &other) = default;
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-
-	std::string name;
-	Value value;
-	SetScope scope;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/show_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class ShowStatement : public SQLStatement {
-public:
-	ShowStatement();
-
-	unique_ptr<ShowSelectInfo> info;
-
-protected:
-	ShowStatement(const ShowStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/transaction_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class TransactionStatement : public SQLStatement {
-public:
-	explicit TransactionStatement(TransactionType type);
-
-	unique_ptr<TransactionInfo> info;
-
-protected:
-	TransactionStatement(const TransactionStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/vacuum_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class VacuumStatement : public SQLStatement {
-public:
-	VacuumStatement();
-
-	unique_ptr<VacuumInfo> info;
-
-protected:
-	VacuumStatement(const VacuumStatement &other) : SQLStatement(other) {};
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/aggregate_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The AggregateBinder is responsible for binding aggregate statements extracted from a SELECT clause (by the
-//! SelectBinder)
-class AggregateBinder : public ExpressionBinder {
-	friend class SelectBinder;
-
-public:
-	AggregateBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/select_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class BoundColumnRefExpression;
-class WindowExpression;
-
-class BoundSelectNode;
-
-struct BoundGroupInformation {
-	expression_map_t<idx_t> map;
-	case_insensitive_map_t<idx_t> alias_map;
-};
-
-//! The SELECT binder is responsible for binding an expression within the SELECT clause of a SQL statement
-class SelectBinder : public ExpressionBinder {
-public:
-	SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info);
-
-	bool BoundAggregates() {
-		return bound_aggregate;
-	}
-	void ResetBindings() {
-		this->bound_aggregate = false;
-		this->bound_columns.clear();
-	}
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function, idx_t depth) override;
-
-	BindResult BindUnnest(FunctionExpression &function, idx_t depth) override;
-
-	bool inside_window;
-	bool bound_aggregate = false;
-
-	BoundSelectNode &node;
-	BoundGroupInformation &info;
-
-protected:
-	BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth) override;
-	BindResult BindWindow(WindowExpression &expr, idx_t depth);
-
-	idx_t TryBindGroup(ParsedExpression &expr, idx_t depth);
-	BindResult BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/query_node/bound_select_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_tableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundTableRef {
-public:
-	explicit BoundTableRef(TableReferenceType type) : type(type) {
-	}
-	virtual ~BoundTableRef() {
-	}
-
-	//! The type of table reference
-	TableReferenceType type;
-	//! The sample options (if any)
-	unique_ptr<SampleOptions> sample;
-};
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-class BoundGroupByNode {
-public:
-	//! The total set of all group expressions
-	vector<unique_ptr<Expression>> group_expressions;
-	//! The different grouping sets as they map to the group expressions
-	vector<GroupingSet> grouping_sets;
-};
-
-//! Bound equivalent of SelectNode
-class BoundSelectNode : public BoundQueryNode {
-public:
-	BoundSelectNode() : BoundQueryNode(QueryNodeType::SELECT_NODE) {
-	}
-
-	//! The original unparsed expressions. This is exported after binding, because the binding might change the
-	//! expressions (e.g. when a * clause is present)
-	vector<unique_ptr<ParsedExpression>> original_expressions;
-
-	//! The projection list
-	vector<unique_ptr<Expression>> select_list;
-	//! The FROM clause
-	unique_ptr<BoundTableRef> from_table;
-	//! The WHERE clause
-	unique_ptr<Expression> where_clause;
-	//! list of groups
-	BoundGroupByNode groups;
-	//! HAVING clause
-	unique_ptr<Expression> having;
-	//! QUALIFY clause
-	unique_ptr<Expression> qualify;
-	//! SAMPLE clause
-	unique_ptr<SampleOptions> sample_options;
-
-	//! The amount of columns in the final result
-	idx_t column_count;
-
-	//! Index used by the LogicalProjection
-	idx_t projection_index;
-
-	//! Group index used by the LogicalAggregate (only used if HasAggregation is true)
-	idx_t group_index;
-	//! Table index for the projection child of the group op
-	idx_t group_projection_index;
-	//! Aggregate index used by the LogicalAggregate (only used if HasAggregation is true)
-	idx_t aggregate_index;
-	//! Index used for GROUPINGS column references
-	idx_t groupings_index;
-	//! Aggregate functions to compute (only used if HasAggregation is true)
-	vector<unique_ptr<Expression>> aggregates;
-
-	//! GROUPING function calls
-	vector<vector<idx_t>> grouping_functions;
-
-	//! Map from aggregate function to aggregate index (used to eliminate duplicate aggregates)
-	expression_map_t<idx_t> aggregate_map;
-
-	//! Window index used by the LogicalWindow (only used if HasWindow is true)
-	idx_t window_index;
-	//! Window functions to compute (only used if HasWindow is true)
-	vector<unique_ptr<Expression>> windows;
-
-	idx_t unnest_index;
-	//! Unnest expression
-	vector<unique_ptr<Expression>> unnests;
-
-	//! Index of pruned node
-	idx_t prune_index;
-	bool need_prune = false;
-
-public:
-	idx_t GetRootIndex() override {
-		return need_prune ? prune_index : projection_index;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/where_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ColumnAliasBinder;
-
-//! The WHERE binder is responsible for binding an expression within the WHERE clause of a SQL statement
-class WhereBinder : public ExpressionBinder {
-public:
-	WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder = nullptr);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-
-private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
-
-	ColumnAliasBinder *column_alias_binder;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/query_node/bound_recursive_cte_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Bound equivalent of SetOperationNode
-class BoundRecursiveCTENode : public BoundQueryNode {
-public:
-	BoundRecursiveCTENode() : BoundQueryNode(QueryNodeType::RECURSIVE_CTE_NODE) {
-	}
-
-	//! Keep track of the CTE name this node represents
-	string ctename;
-
-	bool union_all;
-	//! The left side of the set operation
-	unique_ptr<BoundQueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<BoundQueryNode> right;
-
-	//! Index used by the set operation
-	idx_t setop_index;
-	//! The binder used by the left side of the set operation
-	shared_ptr<Binder> left_binder;
-	//! The binder used by the right side of the set operation
-	shared_ptr<Binder> right_binder;
-
-public:
-	idx_t GetRootIndex() override {
-		return setop_index;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/column_alias_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundSelectNode;
-class ColumnRefExpression;
-
-//! A helper binder for WhereBinder and HavingBinder which support alias as a columnref.
-class ColumnAliasBinder {
-public:
-	ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map);
-
-	BindResult BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
-	                     bool root_expression);
-
-private:
-	BoundSelectNode &node;
-	const case_insensitive_map_t<idx_t> &alias_map;
-	bool in_alias;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/constant_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The Constant binder can bind ONLY constant foldable expressions (i.e. no subqueries, column refs, etc)
-class ConstantBinder : public ExpressionBinder {
-public:
-	ConstantBinder(Binder &binder, ClientContext &context, string clause);
-
-	//! The location where this binder is used, used for error messages
-	string clause;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/group_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ConstantExpression;
-class ColumnRefExpression;
-
-//! The GROUP binder is responsible for binding expressions in the GROUP BY clause
-class GroupBinder : public ExpressionBinder {
-public:
-	GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-	            case_insensitive_map_t<idx_t> &alias_map, case_insensitive_map_t<idx_t> &group_alias_map);
-
-	//! The unbound root expression
-	unique_ptr<ParsedExpression> unbound_expression;
-	//! The group index currently being bound
-	idx_t bind_index;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) override;
-
-	string UnsupportedAggregateMessage() override;
-
-	BindResult BindSelectRef(idx_t entry);
-	BindResult BindColumnRef(ColumnRefExpression &expr);
-	BindResult BindConstant(ConstantExpression &expr);
-
-	SelectNode &node;
-	case_insensitive_map_t<idx_t> &alias_map;
-	case_insensitive_map_t<idx_t> &group_alias_map;
-	unordered_set<idx_t> used_aliases;
-
-	idx_t group_index;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/having_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! The HAVING binder is responsible for binding an expression within the HAVING clause of a SQL statement
-class HavingBinder : public SelectBinder {
-public:
-	HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	             case_insensitive_map_t<idx_t> &alias_map);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
-
-	ColumnAliasBinder column_alias_binder;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/qualify_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! The QUALIFY binder is responsible for binding an expression within the QUALIFY clause of a SQL statement
-class QualifyBinder : public SelectBinder {
-public:
-	QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	              case_insensitive_map_t<idx_t> &alias_map);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
-
-	ColumnAliasBinder column_alias_binder;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/order_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class Binder;
-class Expression;
-class SelectNode;
-
-//! The ORDER binder is responsible for binding an expression within the ORDER BY clause of a SQL statement
-class OrderBinder {
-public:
-	OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
-	            expression_map_t<idx_t> &projection_map, idx_t max_count);
-	OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-	            case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map);
-
-public:
-	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> expr);
-
-	idx_t MaxCount() {
-		return max_count;
-	}
-
-	unique_ptr<Expression> CreateExtraReference(unique_ptr<ParsedExpression> expr);
-
-private:
-	unique_ptr<Expression> CreateProjectionReference(ParsedExpression &expr, idx_t index);
-
-private:
-	vector<Binder *> binders;
-	idx_t projection_index;
-	idx_t max_count;
-	vector<unique_ptr<ParsedExpression>> *extra_list;
-	case_insensitive_map_t<idx_t> &alias_map;
-	expression_map_t<idx_t> &projection_map;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/query_node/bound_set_operation_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Bound equivalent of SetOperationNode
-class BoundSetOperationNode : public BoundQueryNode {
-public:
-	BoundSetOperationNode() : BoundQueryNode(QueryNodeType::SET_OPERATION_NODE) {
-	}
-
-	//! The type of set operation
-	SetOperationType setop_type = SetOperationType::NONE;
-	//! The left side of the set operation
-	unique_ptr<BoundQueryNode> left;
-	//! The right side of the set operation
-	unique_ptr<BoundQueryNode> right;
-
-	//! Index used by the set operation
-	idx_t setop_index;
-	//! The binder used by the left side of the set operation
-	shared_ptr<Binder> left_binder;
-	//! The binder used by the right side of the set operation
-	shared_ptr<Binder> right_binder;
-
-public:
-	idx_t GetRootIndex() override {
-		return setop_index;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/subquery/flatten_dependent_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The FlattenDependentJoins class is responsible for pushing the dependent join down into the plan to create a
-//! flattened subquery
-struct FlattenDependentJoins {
-	FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated, bool perform_delim = true,
-	                      bool any_join = false);
-
-	//! Detects which Logical Operators have correlated expressions that they are dependent upon, filling the
-	//! has_correlated_expressions map.
-	bool DetectCorrelatedExpressions(LogicalOperator *op);
-
-	//! Push the dependent join down a LogicalOperator
-	unique_ptr<LogicalOperator> PushDownDependentJoin(unique_ptr<LogicalOperator> plan);
-
-	Binder &binder;
-	ColumnBinding base_binding;
-	idx_t delim_offset;
-	idx_t data_offset;
-	unordered_map<LogicalOperator *, bool> has_correlated_expressions;
-	column_binding_map_t<idx_t> correlated_map;
-	column_binding_map_t<idx_t> replacement_map;
-	const vector<CorrelatedColumnInfo> &correlated_columns;
-	vector<LogicalType> delim_types;
-
-	bool perform_delim;
-	bool any_join;
-
-private:
-	unique_ptr<LogicalOperator> PushDownDependentJoinInternal(unique_ptr<LogicalOperator> plan,
-	                                                          bool &parent_propagate_null_values);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_table_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a reference to a table-producing function call
-class BoundTableFunction : public BoundTableRef {
-public:
-	explicit BoundTableFunction(unique_ptr<LogicalOperator> get)
-	    : BoundTableRef(TableReferenceType::TABLE_FUNCTION), get(move(get)) {
-	}
-
-	unique_ptr<LogicalOperator> get;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/index_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class BoundColumnRefExpression;
-
-//! The INDEX binder is responsible for binding an expression within an Index statement
-class IndexBinder : public ExpressionBinder {
-public:
-	IndexBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/parsed_data/bound_create_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class CatalogEntry;
-
-struct BoundCreateFunctionInfo {
-	explicit BoundCreateFunctionInfo(unique_ptr<CreateInfo> base) : base(move(base)) {
-	}
-
-	//! The schema to create the table in
-	SchemaCatalogEntry *schema;
-	//! The base CreateInfo object
-	unique_ptr<CreateInfo> base;
-
-	CreateMacroInfo &Base() {
-		return (CreateMacroInfo &)*base;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_basetableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class TableCatalogEntry;
-
-//! Represents a TableReference to a base table in the schema
-class BoundBaseTableRef : public BoundTableRef {
-public:
-	BoundBaseTableRef(TableCatalogEntry *table, unique_ptr<LogicalOperator> get)
-	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(move(get)) {
-	}
-
-	TableCatalogEntry *table;
-	unique_ptr<LogicalOperator> get;
-};
-} // namespace duckdb
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/check_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-//! The CHECK binder is responsible for binding an expression within a CHECK constraint
-class CheckBinder : public ExpressionBinder {
-public:
-	CheckBinder(Binder &binder, ClientContext &context, string table, vector<ColumnDefinition> &columns,
-	            unordered_set<column_t> &bound_columns);
-
-	string table;
-	vector<ColumnDefinition> &columns;
-	unordered_set<column_t> &bound_columns;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	BindResult BindCheckColumn(ColumnRefExpression &expr);
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/returning_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The RETURNING binder is responsible for binding expressions within the RETURNING statement
-class ReturningBinder : public ExpressionBinder {
-public:
-	ReturningBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/insert_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The INSERT binder is responsible for binding expressions within the VALUES of an INSERT statement
-class InsertBinder : public ExpressionBinder {
-public:
-	InsertBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/update_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The UPDATE binder is responsible for binding an expression within an UPDATE statement
-class UpdateBinder : public ExpressionBinder {
-public:
-	UpdateBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_crossproductref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a cross product
-class BoundCrossProductRef : public BoundTableRef {
-public:
-	BoundCrossProductRef() : BoundTableRef(TableReferenceType::CROSS_PRODUCT) {
-	}
-
-	//! The binder used to bind the LHS of the cross product
-	shared_ptr<Binder> left_binder;
-	//! The binder used to bind the RHS of the cross product
-	shared_ptr<Binder> right_binder;
-	//! The left hand side of the cross product
-	unique_ptr<BoundTableRef> left;
-	//! The right hand side of the cross product
-	unique_ptr<BoundTableRef> right;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_subqueryref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a cross product
-class BoundSubqueryRef : public BoundTableRef {
-public:
-	BoundSubqueryRef(shared_ptr<Binder> binder_p, unique_ptr<BoundQueryNode> subquery)
-	    : BoundTableRef(TableReferenceType::SUBQUERY), binder(move(binder_p)), subquery(move(subquery)) {
-	}
-
-	//! The binder used to bind the subquery
-	shared_ptr<Binder> binder;
-	//! The bound subquery node
-	unique_ptr<BoundQueryNode> subquery;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_cteref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BoundCTERef : public BoundTableRef {
-public:
-	BoundCTERef(idx_t bind_index, idx_t cte_index)
-	    : BoundTableRef(TableReferenceType::CTE), bind_index(bind_index), cte_index(cte_index) {
-	}
-
-	//! The set of columns bound to this base table reference
-	vector<string> bound_columns;
-	//! The types of the values list
-	vector<LogicalType> types;
-	//! The index in the bind context
-	idx_t bind_index;
-	//! The index of the cte
-	idx_t cte_index;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_dummytableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a cross product
-class BoundEmptyTableRef : public BoundTableRef {
-public:
-	explicit BoundEmptyTableRef(idx_t bind_index) : BoundTableRef(TableReferenceType::EMPTY), bind_index(bind_index) {
-	}
-	idx_t bind_index;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_expressionlistref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-//! Represents a TableReference to a base table in the schema
-class BoundExpressionListRef : public BoundTableRef {
-public:
-	BoundExpressionListRef() : BoundTableRef(TableReferenceType::EXPRESSION_LIST) {
-	}
-
-	//! The bound VALUES list
-	vector<vector<unique_ptr<Expression>>> values;
-	//! The generated names of the values list
-	vector<string> names;
-	//! The types of the values list
-	vector<LogicalType> types;
-	//! The index in the bind context
-	idx_t bind_index;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_joinref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a join
-class BoundJoinRef : public BoundTableRef {
-public:
-	BoundJoinRef() : BoundTableRef(TableReferenceType::JOIN) {
-	}
-
-	//! The binder used to bind the LHS of the join
-	shared_ptr<Binder> left_binder;
-	//! The binder used to bind the RHS of the join
-	shared_ptr<Binder> right_binder;
-	//! The left hand side of the join
-	unique_ptr<BoundTableRef> left;
-	//! The right hand side of the join
-	unique_ptr<BoundTableRef> right;
-	//! The join condition
-	unique_ptr<Expression> condition;
-	//! The join type
-	JoinType type;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/relation_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The relation binder is a binder used to bind expressions in the relation API
-class RelationBinder : public ExpressionBinder {
-public:
-	RelationBinder(Binder &binder, ClientContext &context, string op);
-
-	string op;
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-
-	string UnsupportedAggregateMessage() override;
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/subquery/has_correlated_expressions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Helper class to recursively detect correlated expressions inside a single LogicalOperator
-class HasCorrelatedExpressions : public LogicalOperatorVisitor {
-public:
-	explicit HasCorrelatedExpressions(const vector<CorrelatedColumnInfo> &correlated);
-
-	void VisitOperator(LogicalOperator &op) override;
-
-	bool has_correlated_expressions;
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-	const vector<CorrelatedColumnInfo> &correlated_columns;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/subquery/rewrite_correlated_expressions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Helper class to rewrite correlated expressions within a single LogicalOperator
-class RewriteCorrelatedExpressions : public LogicalOperatorVisitor {
-public:
-	RewriteCorrelatedExpressions(ColumnBinding base_binding, column_binding_map_t<idx_t> &correlated_map);
-
-	void VisitOperator(LogicalOperator &op) override;
-
-protected:
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-private:
-	//! Helper class used to recursively rewrite correlated expressions within nested subqueries.
-	class RewriteCorrelatedRecursive {
-	public:
-		RewriteCorrelatedRecursive(BoundSubqueryExpression &parent, ColumnBinding base_binding,
-		                           column_binding_map_t<idx_t> &correlated_map);
-
-		void RewriteCorrelatedSubquery(BoundSubqueryExpression &expr);
-		void RewriteCorrelatedExpressions(Expression &child);
-
-		BoundSubqueryExpression &parent;
-		ColumnBinding base_binding;
-		column_binding_map_t<idx_t> &correlated_map;
-	};
-
-private:
-	ColumnBinding base_binding;
-	column_binding_map_t<idx_t> &correlated_map;
-};
-
-//! Helper class that rewrites COUNT aggregates into a CASE expression turning NULL into 0 after a LEFT OUTER JOIN
-class RewriteCountAggregates : public LogicalOperatorVisitor {
-public:
-	explicit RewriteCountAggregates(column_binding_map_t<idx_t> &replacement_map);
-
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
-
-	column_binding_map_t<idx_t> &replacement_map;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//						 DuckDB
-//
-// duckdb/parallel/concurrentqueue.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef DUCKDB_NO_THREADS
-
-#else
-
-#include <cstddef>
-#include <deque>
-#include <queue>
-
-namespace duckdb_moodycamel {
-
-template <typename T>
-class ConcurrentQueue;
-template <typename T>
-class BlockingConcurrentQueue;
-
-struct ProducerToken {
-	//! Constructor
-	template <typename T, typename Traits>
-	explicit ProducerToken(ConcurrentQueue<T> &);
-	//! Constructor
-	template <typename T, typename Traits>
-	explicit ProducerToken(BlockingConcurrentQueue<T> &);
-	//! Constructor
-	ProducerToken(ProducerToken &&) {
-	}
-	//! Is valid token?
-	inline bool valid() const {
-		return true;
-	}
-};
-
-template <typename T>
-class ConcurrentQueue {
-private:
-	//! The queue
-	std::queue<T, std::deque<T>> q;
-
-public:
-	//! Constructor
-	ConcurrentQueue() = default;
-	//! Constructor
-	explicit ConcurrentQueue(size_t capacity) {
-		q.reserve(capacity);
-	}
-
-	//! Enqueue item
-	template <typename U>
-	bool enqueue(U &&item) {
-		q.push(std::forward<U>(item));
-		return true;
-	}
-	//! Try to dequeue an item
-	bool try_dequeue(T &item) {
-		if (q.empty()) {
-			return false;
-		}
-		item = std::move(q.front());
-		q.pop();
-		return true;
-	}
-};
-
-} // namespace duckdb_moodycamel
-
-#endif
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/table_data_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/meta_block_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-class DatabaseInstance;
-
-//! This struct is responsible for writing metadata to disk
-class MetaBlockWriter : public Serializer {
-public:
-	MetaBlockWriter(DatabaseInstance &db, block_id_t initial_block_id = INVALID_BLOCK);
-	~MetaBlockWriter() override;
-
-	DatabaseInstance &db;
-	unique_ptr<Block> block;
-	set<block_id_t> written_blocks;
-	idx_t offset;
-
-public:
-	BlockPointer GetBlockPointer();
-	void Flush();
-
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
-
-protected:
-	virtual block_id_t GetNextBlockId();
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class DatabaseInstance;
-class ClientContext;
-class ColumnSegment;
-class MetaBlockReader;
-class SchemaCatalogEntry;
-class SequenceCatalogEntry;
-class TableCatalogEntry;
-class ViewCatalogEntry;
-class TypeCatalogEntry;
-
-struct PartialColumnSegment {
-	ColumnSegment *segment;
-	uint32_t offset_in_block;
-};
-
-struct PartialBlock {
-	block_id_t block_id;
-	//! The block handle that stores this block
-	shared_ptr<BlockHandle> block;
-	//! The segments that are involved in the partial block
-	vector<PartialColumnSegment> segments;
-
-	void FlushToDisk(DatabaseInstance &db);
-};
-
-//! CheckpointManager is responsible for checkpointing the database
-class CheckpointManager {
-public:
-	static constexpr const idx_t PARTIAL_BLOCK_THRESHOLD = Storage::BLOCK_SIZE / 5 * 4;
-
-public:
-	explicit CheckpointManager(DatabaseInstance &db);
-
-	//! The database
-	DatabaseInstance &db;
-	//! The metadata writer is responsible for writing schema information
-	unique_ptr<MetaBlockWriter> metadata_writer;
-	//! The table data writer is responsible for writing the DataPointers used by the table chunks
-	unique_ptr<MetaBlockWriter> tabledata_writer;
-
-public:
-	//! Checkpoint the current state of the WAL and flush it to the main storage. This should be called BEFORE any
-	//! connction is available because right now the checkpointing cannot be done online. (TODO)
-	void CreateCheckpoint();
-	//! Load from a stored checkpoint
-	void LoadFromStorage();
-
-	//! Try to obtain a partially filled block that can fit "segment_size" bytes
-	//! If successful, returns true and returns the block_id and offset_in_block to write to
-	//! Otherwise, returns false
-	bool GetPartialBlock(ColumnSegment *segment, idx_t segment_size, block_id_t &block_id, uint32_t &offset_in_block,
-	                     PartialBlock *&partial_block_ptr, unique_ptr<PartialBlock> &owned_partial_block);
-
-	//! Register a partially filled block that is filled with "segment_size" entries
-	void RegisterPartialBlock(ColumnSegment *segment, idx_t segment_size, block_id_t block_id);
-
-	//! Flush any remaining partial segments to disk
-	void FlushPartialSegments();
-
-private:
-	void WriteSchema(SchemaCatalogEntry &schema);
-	void WriteTable(TableCatalogEntry &table);
-	void WriteView(ViewCatalogEntry &table);
-	void WriteSequence(SequenceCatalogEntry &table);
-	void WriteMacro(ScalarMacroCatalogEntry &table);
-	void WriteTableMacro(TableMacroCatalogEntry &table);
-	void WriteType(TypeCatalogEntry &table);
-
-	void ReadSchema(ClientContext &context, MetaBlockReader &reader);
-	void ReadTable(ClientContext &context, MetaBlockReader &reader);
-	void ReadView(ClientContext &context, MetaBlockReader &reader);
-	void ReadSequence(ClientContext &context, MetaBlockReader &reader);
-	void ReadMacro(ClientContext &context, MetaBlockReader &reader);
-	void ReadTableMacro(ClientContext &context, MetaBlockReader &reader);
-	void ReadType(ClientContext &context, MetaBlockReader &reader);
-
-private:
-	//! A map of (available space -> PartialBlock) for partially filled blocks
-	//! This is a multimap because there might be outstanding partial blocks with the same amount of left-over space
-	multimap<idx_t, unique_ptr<PartialBlock>> partially_filled_blocks;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-struct BoundCreateTableInfo;
-
-//! The table data reader is responsible for reading the data of a table from the block manager
-class TableDataReader {
-public:
-	TableDataReader(MetaBlockReader &reader, BoundCreateTableInfo &info);
-
-	void ReadTableData();
-
-private:
-	MetaBlockReader &reader;
-	BoundCreateTableInfo &info;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/meta_block_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class BlockHandle;
-class BufferHandle;
-class DatabaseInstance;
-
-//! This struct is responsible for reading meta data from disk
-class MetaBlockReader : public Deserializer {
-public:
-	MetaBlockReader(DatabaseInstance &db, block_id_t block);
-	~MetaBlockReader() override;
-
-	DatabaseInstance &db;
-	shared_ptr<BlockHandle> block;
-	BufferHandle handle;
-	idx_t offset;
-	block_id_t next_block;
-
-public:
-	//! Read content of size read_size into the buffer
-	void ReadData(data_ptr_t buffer, idx_t read_size) override;
-
-private:
-	void ReadNewBlock(block_id_t id);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/table_data_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class CheckpointManager;
-class ColumnData;
-class ColumnSegment;
-class RowGroup;
-class BaseStatistics;
-class SegmentStatistics;
-
-//! The table data writer is responsible for writing the data of a table to the block manager
-class TableDataWriter {
-	friend class ColumnData;
-
-public:
-	TableDataWriter(DatabaseInstance &db, CheckpointManager &checkpoint_manager, TableCatalogEntry &table,
-	                MetaBlockWriter &meta_writer);
-	~TableDataWriter();
-
-	BlockPointer WriteTableData();
-
-	MetaBlockWriter &GetMetaWriter() {
-		return meta_writer;
-	}
-
-	CheckpointManager &GetCheckpointManager() {
-		return checkpoint_manager;
-	}
-
-	CompressionType GetColumnCompressionType(idx_t i);
-
-private:
-	CheckpointManager &checkpoint_manager;
-	TableCatalogEntry &table;
-	MetaBlockWriter &meta_writer;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/checkpoint/string_checkpoint_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class OverflowStringWriter {
-public:
-	virtual ~OverflowStringWriter() {
-	}
-
-	virtual void WriteString(string_t string, block_id_t &result_block, int32_t &result_offset) = 0;
-};
-
-struct StringBlock {
-	shared_ptr<BlockHandle> block;
-	idx_t offset;
-	idx_t size;
-	unique_ptr<StringBlock> next;
-};
-
-struct string_location_t {
-	string_location_t(block_id_t block_id, int32_t offset) : block_id(block_id), offset(offset) {
-	}
-	string_location_t() {
-	}
-	bool IsValid() {
-		return offset < Storage::BLOCK_SIZE && (block_id == INVALID_BLOCK || block_id >= MAXIMUM_BLOCK);
-	}
-	block_id_t block_id;
-	int32_t offset;
-};
-
-struct UncompressedStringSegmentState : public CompressedSegmentState {
-	~UncompressedStringSegmentState();
-
-	//! The string block holding strings that do not fit in the main block
-	//! FIXME: this should be replaced by a heap that also allows freeing of unused strings
-	unique_ptr<StringBlock> head;
-	//! Overflow string writer (if any), if not set overflow strings will be written to memory blocks
-	unique_ptr<OverflowStringWriter> overflow_writer;
-	//! Map of block id to string block
-	unordered_map<block_id_t, StringBlock *> overflow_blocks;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class WriteOverflowStringsToDisk : public OverflowStringWriter {
-public:
-	explicit WriteOverflowStringsToDisk(DatabaseInstance &db);
-	~WriteOverflowStringsToDisk() override;
-
-	//! The checkpoint manager
-	DatabaseInstance &db;
-
-	//! Temporary buffer
-	BufferHandle handle;
-	//! The block on-disk to which we are writing
-	block_id_t block_id;
-	//! The offset within the current block
-	idx_t offset;
-
-	static constexpr idx_t STRING_SPACE = Storage::BLOCK_SIZE - sizeof(block_id_t);
-
-public:
-	void WriteString(string_t string, block_id_t &result_block, int32_t &result_offset) override;
-
-private:
-	void AllocateNewBlock(block_id_t new_block_id);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/bitpacking.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #12
-// See the end of this file for a list
-
-/**
-* This code is released under the
-* Apache License Version 2.0 http://www.apache.org/licenses/.
-*
-* (c) Daniel Lemire, http://lemire.me/en/
-*/
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #12
-// See the end of this file for a list
-
-/**
- * This code is released under the
- * Apache License Version 2.0 http://www.apache.org/licenses/.
- *
- * (c) Daniel Lemire, http://fastpforlib.me/en/
- */
-
-#include <cinttypes>
-#include <string>
-
-namespace duckdb_fastpforlib {
-namespace internal {
-
-// Unpacks 8 uint8_t values
-void __fastunpack0(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastunpack1(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastunpack2(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastunpack3(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastunpack4(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastunpack5(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastunpack6(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastunpack7(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastunpack8(const uint8_t *__restrict in, uint8_t *__restrict out);
-
-// Unpacks 16 uint16_t values
-void __fastunpack0(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack1(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack2(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack3(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack4(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack5(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack6(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack7(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack8(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack9(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack10(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack11(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack12(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack13(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack14(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack15(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastunpack16(const uint16_t *__restrict in, uint16_t *__restrict out);
-
-// Unpacks 32 uint32_t values
-void __fastunpack0(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack1(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack2(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack3(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack4(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack5(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack6(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack7(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack8(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack9(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack10(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack11(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack12(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack13(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack14(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack15(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack16(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack17(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack18(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack19(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack20(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack21(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack22(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack23(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack24(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack25(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack26(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack27(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack28(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack29(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack30(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack31(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastunpack32(const uint32_t *__restrict in, uint32_t *__restrict out);
-
-// Unpacks 32 uint64_t values
-void __fastunpack0(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack1(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack2(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack3(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack4(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack5(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack6(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack7(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack8(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack9(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack10(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack11(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack12(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack13(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack14(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack15(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack16(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack17(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack18(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack19(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack20(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack21(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack22(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack23(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack24(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack25(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack26(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack27(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack28(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack29(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack30(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack31(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack32(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack33(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack34(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack35(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack36(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack37(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack38(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack39(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack40(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack41(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack42(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack43(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack44(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack45(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack46(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack47(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack48(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack49(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack50(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack51(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack52(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack53(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack54(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack55(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack56(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack57(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack58(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack59(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack60(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack61(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack62(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack63(const uint32_t *__restrict in, uint64_t *__restrict out);
-void __fastunpack64(const uint32_t *__restrict in, uint64_t *__restrict out);
-
-// Packs 8 int8_t values
-void __fastpack0(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastpack1(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastpack2(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastpack3(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastpack4(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastpack5(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastpack6(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastpack7(const uint8_t *__restrict in, uint8_t *__restrict out);
-void __fastpack8(const uint8_t *__restrict in, uint8_t *__restrict out);
-
-// Packs 16 int16_t values
-void __fastpack0(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack1(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack2(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack3(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack4(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack5(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack6(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack7(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack8(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack9(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack10(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack11(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack12(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack13(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack14(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack15(const uint16_t *__restrict in, uint16_t *__restrict out);
-void __fastpack16(const uint16_t *__restrict in, uint16_t *__restrict out);
-
-// Packs 32 int32_t values
-void __fastpack0(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack1(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack2(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack3(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack4(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack5(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack6(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack7(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack8(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack9(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack10(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack11(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack12(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack13(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack14(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack15(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack16(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack17(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack18(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack19(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack20(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack21(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack22(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack23(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack24(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack25(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack26(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack27(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack28(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack29(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack30(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack31(const uint32_t *__restrict in, uint32_t *__restrict out);
-void __fastpack32(const uint32_t *__restrict in, uint32_t *__restrict out);
-
-// Packs 32 int64_t values
-void __fastpack0(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack1(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack2(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack3(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack4(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack5(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack6(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack7(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack8(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack9(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack10(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack11(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack12(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack13(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack14(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack15(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack16(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack17(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack18(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack19(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack20(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack21(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack22(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack23(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack24(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack25(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack26(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack27(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack28(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack29(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack30(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack31(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack32(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack33(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack34(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack35(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack36(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack37(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack38(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack39(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack40(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack41(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack42(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack43(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack44(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack45(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack46(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack47(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack48(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack49(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack50(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack51(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack52(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack53(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack54(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack55(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack56(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack57(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack58(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack59(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack60(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack61(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack62(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack63(const uint64_t *__restrict in, uint32_t *__restrict out);
-void __fastpack64(const uint64_t *__restrict in, uint32_t *__restrict out);
-} // namespace internal
-} // namespace duckdb_fastpforlib
-
-
-// LICENSE_CHANGE_END
-
-
-
-#include <stdexcept>
-
-namespace duckdb_fastpforlib {
-
-namespace internal {
-
-// Note that this only packs 8 values
-inline void fastunpack_quarter(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
-	// Could have used function pointers instead of switch.
-	// Switch calls do offer the compiler more opportunities for optimization in
-	// theory. In this case, it makes no difference with a good compiler.
-	switch (bit) {
-	case 0:
-		internal::__fastunpack0(in, out);
-		break;
-	case 1:
-		internal::__fastunpack1(in, out);
-		break;
-	case 2:
-		internal::__fastunpack2(in, out);
-		break;
-	case 3:
-		internal::__fastunpack3(in, out);
-		break;
-	case 4:
-		internal::__fastunpack4(in, out);
-		break;
-	case 5:
-		internal::__fastunpack5(in, out);
-		break;
-	case 6:
-		internal::__fastunpack6(in, out);
-		break;
-	case 7:
-		internal::__fastunpack7(in, out);
-		break;
-	case 8:
-		internal::__fastunpack8(in, out);
-		break;
-	default:
-		throw std::logic_error("Invalid bit width for bitpacking");
-	}
-}
-
-// Note that this only packs 8 values
-inline void fastpack_quarter(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
-	// Could have used function pointers instead of switch.
-	// Switch calls do offer the compiler more opportunities for optimization in
-	// theory. In this case, it makes no difference with a good compiler.
-	switch (bit) {
-	case 0:
-		internal::__fastpack0(in, out);
-		break;
-	case 1:
-		internal::__fastpack1(in, out);
-		break;
-	case 2:
-		internal::__fastpack2(in, out);
-		break;
-	case 3:
-		internal::__fastpack3(in, out);
-		break;
-	case 4:
-		internal::__fastpack4(in, out);
-		break;
-	case 5:
-		internal::__fastpack5(in, out);
-		break;
-	case 6:
-		internal::__fastpack6(in, out);
-		break;
-	case 7:
-		internal::__fastpack7(in, out);
-		break;
-	case 8:
-		internal::__fastpack8(in, out);
-		break;
-	default:
-		throw std::logic_error("Invalid bit width for bitpacking");
-	}
-}
-
-// Note that this only packs 16 values
-inline void fastunpack_half(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
-	// Could have used function pointers instead of switch.
-	// Switch calls do offer the compiler more opportunities for optimization in
-	// theory. In this case, it makes no difference with a good compiler.
-	switch (bit) {
-	case 0:
-		internal::__fastunpack0(in, out);
-		break;
-	case 1:
-		internal::__fastunpack1(in, out);
-		break;
-	case 2:
-		internal::__fastunpack2(in, out);
-		break;
-	case 3:
-		internal::__fastunpack3(in, out);
-		break;
-	case 4:
-		internal::__fastunpack4(in, out);
-		break;
-	case 5:
-		internal::__fastunpack5(in, out);
-		break;
-	case 6:
-		internal::__fastunpack6(in, out);
-		break;
-	case 7:
-		internal::__fastunpack7(in, out);
-		break;
-	case 8:
-		internal::__fastunpack8(in, out);
-		break;
-	case 9:
-		internal::__fastunpack9(in, out);
-		break;
-	case 10:
-		internal::__fastunpack10(in, out);
-		break;
-	case 11:
-		internal::__fastunpack11(in, out);
-		break;
-	case 12:
-		internal::__fastunpack12(in, out);
-		break;
-	case 13:
-		internal::__fastunpack13(in, out);
-		break;
-	case 14:
-		internal::__fastunpack14(in, out);
-		break;
-	case 15:
-		internal::__fastunpack15(in, out);
-		break;
-	case 16:
-		internal::__fastunpack16(in, out);
-		break;
-	default:
-		throw std::logic_error("Invalid bit width for bitpacking");
-	}
-}
-
-// Note that this only packs 16 values
-inline void fastpack_half(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
-	// Could have used function pointers instead of switch.
-	// Switch calls do offer the compiler more opportunities for optimization in
-	// theory. In this case, it makes no difference with a good compiler.
-	switch (bit) {
-	case 0:
-		internal::__fastpack0(in, out);
-		break;
-	case 1:
-		internal::__fastpack1(in, out);
-		break;
-	case 2:
-		internal::__fastpack2(in, out);
-		break;
-	case 3:
-		internal::__fastpack3(in, out);
-		break;
-	case 4:
-		internal::__fastpack4(in, out);
-		break;
-	case 5:
-		internal::__fastpack5(in, out);
-		break;
-	case 6:
-		internal::__fastpack6(in, out);
-		break;
-	case 7:
-		internal::__fastpack7(in, out);
-		break;
-	case 8:
-		internal::__fastpack8(in, out);
-		break;
-	case 9:
-		internal::__fastpack9(in, out);
-		break;
-	case 10:
-		internal::__fastpack10(in, out);
-		break;
-	case 11:
-		internal::__fastpack11(in, out);
-		break;
-	case 12:
-		internal::__fastpack12(in, out);
-		break;
-	case 13:
-		internal::__fastpack13(in, out);
-		break;
-	case 14:
-		internal::__fastpack14(in, out);
-		break;
-	case 15:
-		internal::__fastpack15(in, out);
-		break;
-	case 16:
-		internal::__fastpack16(in, out);
-		break;
-	default:
-		throw std::logic_error("Invalid bit width for bitpacking");
-	}
-}
-}
-
-inline void fastunpack(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
-	for (uint8_t i = 0; i < 4; i++) {
-		internal::fastunpack_quarter(in + (i*bit), out+(i*8), bit);
-	}
-}
-
-inline void fastunpack(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
-	internal::fastunpack_half(in, out, bit);
-	internal::fastunpack_half(in + bit, out+16, bit);
-}
-
-inline void fastunpack(const uint32_t *__restrict in,
-                       uint32_t *__restrict out, const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-  case 0:
-    internal::__fastunpack0(in, out);
-    break;
-  case 1:
-    internal::__fastunpack1(in, out);
-    break;
-  case 2:
-    internal::__fastunpack2(in, out);
-    break;
-  case 3:
-    internal::__fastunpack3(in, out);
-    break;
-  case 4:
-    internal::__fastunpack4(in, out);
-    break;
-  case 5:
-    internal::__fastunpack5(in, out);
-    break;
-  case 6:
-    internal::__fastunpack6(in, out);
-    break;
-  case 7:
-    internal::__fastunpack7(in, out);
-    break;
-  case 8:
-    internal::__fastunpack8(in, out);
-    break;
-  case 9:
-    internal::__fastunpack9(in, out);
-    break;
-  case 10:
-    internal::__fastunpack10(in, out);
-    break;
-  case 11:
-    internal::__fastunpack11(in, out);
-    break;
-  case 12:
-    internal::__fastunpack12(in, out);
-    break;
-  case 13:
-    internal::__fastunpack13(in, out);
-    break;
-  case 14:
-    internal::__fastunpack14(in, out);
-    break;
-  case 15:
-    internal::__fastunpack15(in, out);
-    break;
-  case 16:
-    internal::__fastunpack16(in, out);
-    break;
-  case 17:
-    internal::__fastunpack17(in, out);
-    break;
-  case 18:
-    internal::__fastunpack18(in, out);
-    break;
-  case 19:
-    internal::__fastunpack19(in, out);
-    break;
-  case 20:
-    internal::__fastunpack20(in, out);
-    break;
-  case 21:
-    internal::__fastunpack21(in, out);
-    break;
-  case 22:
-    internal::__fastunpack22(in, out);
-    break;
-  case 23:
-    internal::__fastunpack23(in, out);
-    break;
-  case 24:
-    internal::__fastunpack24(in, out);
-    break;
-  case 25:
-    internal::__fastunpack25(in, out);
-    break;
-  case 26:
-    internal::__fastunpack26(in, out);
-    break;
-  case 27:
-    internal::__fastunpack27(in, out);
-    break;
-  case 28:
-    internal::__fastunpack28(in, out);
-    break;
-  case 29:
-    internal::__fastunpack29(in, out);
-    break;
-  case 30:
-    internal::__fastunpack30(in, out);
-    break;
-  case 31:
-    internal::__fastunpack31(in, out);
-    break;
-  case 32:
-    internal::__fastunpack32(in, out);
-    break;
-  default:
-    throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-inline void fastunpack(const uint32_t *__restrict in,
-                       uint64_t *__restrict out, const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-  case 0:
-    internal::__fastunpack0(in, out);
-    break;
-  case 1:
-    internal::__fastunpack1(in, out);
-    break;
-  case 2:
-    internal::__fastunpack2(in, out);
-    break;
-  case 3:
-    internal::__fastunpack3(in, out);
-    break;
-  case 4:
-    internal::__fastunpack4(in, out);
-    break;
-  case 5:
-    internal::__fastunpack5(in, out);
-    break;
-  case 6:
-    internal::__fastunpack6(in, out);
-    break;
-  case 7:
-    internal::__fastunpack7(in, out);
-    break;
-  case 8:
-    internal::__fastunpack8(in, out);
-    break;
-  case 9:
-    internal::__fastunpack9(in, out);
-    break;
-  case 10:
-    internal::__fastunpack10(in, out);
-    break;
-  case 11:
-    internal::__fastunpack11(in, out);
-    break;
-  case 12:
-    internal::__fastunpack12(in, out);
-    break;
-  case 13:
-    internal::__fastunpack13(in, out);
-    break;
-  case 14:
-    internal::__fastunpack14(in, out);
-    break;
-  case 15:
-    internal::__fastunpack15(in, out);
-    break;
-  case 16:
-    internal::__fastunpack16(in, out);
-    break;
-  case 17:
-    internal::__fastunpack17(in, out);
-    break;
-  case 18:
-    internal::__fastunpack18(in, out);
-    break;
-  case 19:
-    internal::__fastunpack19(in, out);
-    break;
-  case 20:
-    internal::__fastunpack20(in, out);
-    break;
-  case 21:
-    internal::__fastunpack21(in, out);
-    break;
-  case 22:
-    internal::__fastunpack22(in, out);
-    break;
-  case 23:
-    internal::__fastunpack23(in, out);
-    break;
-  case 24:
-    internal::__fastunpack24(in, out);
-    break;
-  case 25:
-    internal::__fastunpack25(in, out);
-    break;
-  case 26:
-    internal::__fastunpack26(in, out);
-    break;
-  case 27:
-    internal::__fastunpack27(in, out);
-    break;
-  case 28:
-    internal::__fastunpack28(in, out);
-    break;
-  case 29:
-    internal::__fastunpack29(in, out);
-    break;
-  case 30:
-    internal::__fastunpack30(in, out);
-    break;
-  case 31:
-    internal::__fastunpack31(in, out);
-    break;
-  case 32:
-    internal::__fastunpack32(in, out);
-    break;
-  case 33:
-    internal::__fastunpack33(in, out);
-    break;
-  case 34:
-    internal::__fastunpack34(in, out);
-    break;
-  case 35:
-    internal::__fastunpack35(in, out);
-    break;
-  case 36:
-    internal::__fastunpack36(in, out);
-    break;
-  case 37:
-    internal::__fastunpack37(in, out);
-    break;
-  case 38:
-    internal::__fastunpack38(in, out);
-    break;
-  case 39:
-    internal::__fastunpack39(in, out);
-    break;
-  case 40:
-    internal::__fastunpack40(in, out);
-    break;
-  case 41:
-    internal::__fastunpack41(in, out);
-    break;
-  case 42:
-    internal::__fastunpack42(in, out);
-    break;
-  case 43:
-    internal::__fastunpack43(in, out);
-    break;
-  case 44:
-    internal::__fastunpack44(in, out);
-    break;
-  case 45:
-    internal::__fastunpack45(in, out);
-    break;
-  case 46:
-    internal::__fastunpack46(in, out);
-    break;
-  case 47:
-    internal::__fastunpack47(in, out);
-    break;
-  case 48:
-    internal::__fastunpack48(in, out);
-    break;
-  case 49:
-    internal::__fastunpack49(in, out);
-    break;
-  case 50:
-    internal::__fastunpack50(in, out);
-    break;
-  case 51:
-    internal::__fastunpack51(in, out);
-    break;
-  case 52:
-    internal::__fastunpack52(in, out);
-    break;
-  case 53:
-    internal::__fastunpack53(in, out);
-    break;
-  case 54:
-    internal::__fastunpack54(in, out);
-    break;
-  case 55:
-    internal::__fastunpack55(in, out);
-    break;
-  case 56:
-    internal::__fastunpack56(in, out);
-    break;
-  case 57:
-    internal::__fastunpack57(in, out);
-    break;
-  case 58:
-    internal::__fastunpack58(in, out);
-    break;
-  case 59:
-    internal::__fastunpack59(in, out);
-    break;
-  case 60:
-    internal::__fastunpack60(in, out);
-    break;
-  case 61:
-    internal::__fastunpack61(in, out);
-    break;
-  case 62:
-    internal::__fastunpack62(in, out);
-    break;
-  case 63:
-    internal::__fastunpack63(in, out);
-    break;
-  case 64:
-    internal::__fastunpack64(in, out);
-    break;
-  default:
-	throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-inline void fastpack(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
-
-	for (uint8_t i = 0; i < 4; i++) {
-		internal::fastpack_quarter(in+(i*8), out + (i*bit), bit);
-	}
-}
-
-inline void fastpack(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
-	internal::fastpack_half(in, out, bit);
-	internal::fastpack_half(in+16, out + bit, bit);
-}
-
-inline void fastpack(const uint32_t *__restrict in,
-                     uint32_t *__restrict out, const uint32_t bit) {
-  // Could have used function pointers instead of switch.
-  // Switch calls do offer the compiler more opportunities for optimization in
-  // theory. In this case, it makes no difference with a good compiler.
-  switch (bit) {
-  case 0:
-    internal::__fastpack0(in, out);
-    break;
-  case 1:
-    internal::__fastpack1(in, out);
-    break;
-  case 2:
-    internal::__fastpack2(in, out);
-    break;
-  case 3:
-    internal::__fastpack3(in, out);
-    break;
-  case 4:
-    internal::__fastpack4(in, out);
-    break;
-  case 5:
-    internal::__fastpack5(in, out);
-    break;
-  case 6:
-    internal::__fastpack6(in, out);
-    break;
-  case 7:
-    internal::__fastpack7(in, out);
-    break;
-  case 8:
-    internal::__fastpack8(in, out);
-    break;
-  case 9:
-    internal::__fastpack9(in, out);
-    break;
-  case 10:
-    internal::__fastpack10(in, out);
-    break;
-  case 11:
-    internal::__fastpack11(in, out);
-    break;
-  case 12:
-    internal::__fastpack12(in, out);
-    break;
-  case 13:
-    internal::__fastpack13(in, out);
-    break;
-  case 14:
-    internal::__fastpack14(in, out);
-    break;
-  case 15:
-    internal::__fastpack15(in, out);
-    break;
-  case 16:
-    internal::__fastpack16(in, out);
-    break;
-  case 17:
-    internal::__fastpack17(in, out);
-    break;
-  case 18:
-    internal::__fastpack18(in, out);
-    break;
-  case 19:
-    internal::__fastpack19(in, out);
-    break;
-  case 20:
-    internal::__fastpack20(in, out);
-    break;
-  case 21:
-    internal::__fastpack21(in, out);
-    break;
-  case 22:
-    internal::__fastpack22(in, out);
-    break;
-  case 23:
-    internal::__fastpack23(in, out);
-    break;
-  case 24:
-    internal::__fastpack24(in, out);
-    break;
-  case 25:
-    internal::__fastpack25(in, out);
-    break;
-  case 26:
-    internal::__fastpack26(in, out);
-    break;
-  case 27:
-    internal::__fastpack27(in, out);
-    break;
-  case 28:
-    internal::__fastpack28(in, out);
-    break;
-  case 29:
-    internal::__fastpack29(in, out);
-    break;
-  case 30:
-    internal::__fastpack30(in, out);
-    break;
-  case 31:
-    internal::__fastpack31(in, out);
-    break;
-  case 32:
-    internal::__fastpack32(in, out);
-    break;
-  default:
-	throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-
-inline void fastpack(const uint64_t *__restrict in,
-                     uint32_t *__restrict out, const uint32_t bit) {
-  switch (bit) {
-  case 0:
-    internal::__fastpack0(in, out);
-    break;
-  case 1:
-    internal::__fastpack1(in, out);
-    break;
-  case 2:
-    internal::__fastpack2(in, out);
-    break;
-  case 3:
-    internal::__fastpack3(in, out);
-    break;
-  case 4:
-    internal::__fastpack4(in, out);
-    break;
-  case 5:
-    internal::__fastpack5(in, out);
-    break;
-  case 6:
-    internal::__fastpack6(in, out);
-    break;
-  case 7:
-    internal::__fastpack7(in, out);
-    break;
-  case 8:
-    internal::__fastpack8(in, out);
-    break;
-  case 9:
-    internal::__fastpack9(in, out);
-    break;
-  case 10:
-    internal::__fastpack10(in, out);
-    break;
-  case 11:
-    internal::__fastpack11(in, out);
-    break;
-  case 12:
-    internal::__fastpack12(in, out);
-    break;
-  case 13:
-    internal::__fastpack13(in, out);
-    break;
-  case 14:
-    internal::__fastpack14(in, out);
-    break;
-  case 15:
-    internal::__fastpack15(in, out);
-    break;
-  case 16:
-    internal::__fastpack16(in, out);
-    break;
-  case 17:
-    internal::__fastpack17(in, out);
-    break;
-  case 18:
-    internal::__fastpack18(in, out);
-    break;
-  case 19:
-    internal::__fastpack19(in, out);
-    break;
-  case 20:
-    internal::__fastpack20(in, out);
-    break;
-  case 21:
-    internal::__fastpack21(in, out);
-    break;
-  case 22:
-    internal::__fastpack22(in, out);
-    break;
-  case 23:
-    internal::__fastpack23(in, out);
-    break;
-  case 24:
-    internal::__fastpack24(in, out);
-    break;
-  case 25:
-    internal::__fastpack25(in, out);
-    break;
-  case 26:
-    internal::__fastpack26(in, out);
-    break;
-  case 27:
-    internal::__fastpack27(in, out);
-    break;
-  case 28:
-    internal::__fastpack28(in, out);
-    break;
-  case 29:
-    internal::__fastpack29(in, out);
-    break;
-  case 30:
-    internal::__fastpack30(in, out);
-    break;
-  case 31:
-    internal::__fastpack31(in, out);
-    break;
-  case 32:
-    internal::__fastpack32(in, out);
-    break;
-  case 33:
-    internal::__fastpack33(in, out);
-    break;
-  case 34:
-    internal::__fastpack34(in, out);
-    break;
-  case 35:
-    internal::__fastpack35(in, out);
-    break;
-  case 36:
-    internal::__fastpack36(in, out);
-    break;
-  case 37:
-    internal::__fastpack37(in, out);
-    break;
-  case 38:
-    internal::__fastpack38(in, out);
-    break;
-  case 39:
-    internal::__fastpack39(in, out);
-    break;
-  case 40:
-    internal::__fastpack40(in, out);
-    break;
-  case 41:
-    internal::__fastpack41(in, out);
-    break;
-  case 42:
-    internal::__fastpack42(in, out);
-    break;
-  case 43:
-    internal::__fastpack43(in, out);
-    break;
-  case 44:
-    internal::__fastpack44(in, out);
-    break;
-  case 45:
-    internal::__fastpack45(in, out);
-    break;
-  case 46:
-    internal::__fastpack46(in, out);
-    break;
-  case 47:
-    internal::__fastpack47(in, out);
-    break;
-  case 48:
-    internal::__fastpack48(in, out);
-    break;
-  case 49:
-    internal::__fastpack49(in, out);
-    break;
-  case 50:
-    internal::__fastpack50(in, out);
-    break;
-  case 51:
-    internal::__fastpack51(in, out);
-    break;
-  case 52:
-    internal::__fastpack52(in, out);
-    break;
-  case 53:
-    internal::__fastpack53(in, out);
-    break;
-  case 54:
-    internal::__fastpack54(in, out);
-    break;
-  case 55:
-    internal::__fastpack55(in, out);
-    break;
-  case 56:
-    internal::__fastpack56(in, out);
-    break;
-  case 57:
-    internal::__fastpack57(in, out);
-    break;
-  case 58:
-    internal::__fastpack58(in, out);
-    break;
-  case 59:
-    internal::__fastpack59(in, out);
-    break;
-  case 60:
-    internal::__fastpack60(in, out);
-    break;
-  case 61:
-    internal::__fastpack61(in, out);
-    break;
-  case 62:
-    internal::__fastpack62(in, out);
-    break;
-  case 63:
-    internal::__fastpack63(in, out);
-    break;
-  case 64:
-    internal::__fastpack64(in, out);
-    break;
-  default:
-	throw std::logic_error("Invalid bit width for bitpacking");
-  }
-}
-} // namespace fastpfor_lib
-
-
-// LICENSE_CHANGE_END
-
-
-
-
-
-
-namespace duckdb {
-
-using bitpacking_width_t = uint8_t;
-
-class BitpackingPrimitives {
-
-public:
-	static constexpr const idx_t BITPACKING_ALGORITHM_GROUP_SIZE = 32;
-	static constexpr const idx_t BITPACKING_HEADER_SIZE = sizeof(uint64_t);
-	static constexpr const bool BYTE_ALIGNED = false;
-
-	// To ensure enough data is available, use GetRequiredSize() to determine the correct size for dst buffer
-	// Note: input should be aligned to BITPACKING_ALGORITHM_GROUP_SIZE for good performance.
-	template <class T, bool ASSUME_INPUT_ALIGNED = false>
-	inline static void PackBuffer(data_ptr_t dst, T *src, idx_t count, bitpacking_width_t width) {
-		if (ASSUME_INPUT_ALIGNED) {
-			for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
-				PackGroup<T>(dst + (i * width) / 8, src + i, width);
-			}
-		} else {
-			idx_t misaligned_count = count % BITPACKING_ALGORITHM_GROUP_SIZE;
-			T tmp_buffer[BITPACKING_ALGORITHM_GROUP_SIZE]; // TODO maybe faster on the heap?
-
-			if (misaligned_count) {
-				count -= misaligned_count;
-			}
-
-			for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
-				PackGroup<T>(dst + (i * width) / 8, src + i, width);
-			}
-
-			// Input was not aligned to BITPACKING_ALGORITHM_GROUP_SIZE, we need a copy
-			if (misaligned_count) {
-				memcpy(tmp_buffer, src + count, misaligned_count * sizeof(T));
-				PackGroup<T>(dst + (count * width) / 8, tmp_buffer, width);
-			}
-		}
-	}
-
-	// Unpacks a block of BITPACKING_ALGORITHM_GROUP_SIZE values
-	// Assumes both src and dst to be of the correct size
-	template <class T>
-	inline static void UnPackBuffer(data_ptr_t dst, data_ptr_t src, idx_t count, bitpacking_width_t width,
-	                                bool skip_sign_extension = false) {
-
-		for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
-			UnPackGroup<T>(dst + i * sizeof(T), src + (i * width) / 8, width, skip_sign_extension);
-		}
-	}
-
-	// Packs a block of BITPACKING_ALGORITHM_GROUP_SIZE values
-	template <class T>
-	inline static void PackBlock(data_ptr_t dst, T *src, bitpacking_width_t width) {
-		return PackGroup<T>(dst, src, width);
-	}
-
-	// Unpacks a block of BITPACKING_ALGORITHM_GROUP_SIZE values
-	template <class T>
-	inline static void UnPackBlock(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
-	                               bool skip_sign_extension = false) {
-		return UnPackGroup<T>(dst, src, width, skip_sign_extension);
-	}
-
-	// Calculates the minimum required number of bits per value that can store all values
-	template <class T>
-	inline static bitpacking_width_t MinimumBitWidth(T value) {
-		return FindMinimumBitWidth<T, BYTE_ALIGNED>(value, value);
-	}
-
-	// Calculates the minimum required number of bits per value that can store all values
-	template <class T>
-	inline static bitpacking_width_t MinimumBitWidth(T *values, idx_t count) {
-		return FindMinimumBitWidth<T, BYTE_ALIGNED>(values, count);
-	}
-
-	template <class T>
-	inline static idx_t GetRequiredSize(idx_t count, bitpacking_width_t width) {
-		count = RoundUpToAlgorithmGroupSize(count);
-		return ((count * width) / 8);
-	}
-
-	template <class T>
-	inline static T RoundUpToAlgorithmGroupSize(T num_to_round) {
-		int remainder = num_to_round % BITPACKING_ALGORITHM_GROUP_SIZE;
-		if (remainder == 0) {
-			return num_to_round;
-		}
-
-		return num_to_round + BITPACKING_ALGORITHM_GROUP_SIZE - remainder;
-	}
-
-private:
-	template <class T, bool round_to_next_byte = false>
-	static bitpacking_width_t FindMinimumBitWidth(T *values, idx_t count) {
-		T min_value = values[0];
-		T max_value = values[0];
-
-		for (idx_t i = 1; i < count; i++) {
-			if (values[i] > max_value) {
-				max_value = values[i];
-			}
-
-			if (std::is_signed<T>::value) {
-				if (values[i] < min_value) {
-					min_value = values[i];
-				}
-			}
-		}
-
-		return FindMinimumBitWidth<T, round_to_next_byte>(min_value, max_value);
-	}
-
-	template <class T, bool round_to_next_byte = false>
-	static bitpacking_width_t FindMinimumBitWidth(T min_value, T max_value) {
-		bitpacking_width_t bitwidth;
-		T value;
-
-		if (std::is_signed<T>::value) {
-			if (min_value == NumericLimits<T>::Minimum()) {
-				// handle special case of the minimal value, as it cannot be negated like all other values.
-				return sizeof(T) * 8;
-			} else {
-				value = MaxValue((T)-min_value, max_value);
-			}
-		} else {
-			value = max_value;
-		}
-
-		if (value == 0) {
-			return 0;
-		}
-
-		if (std::is_signed<T>::value) {
-			bitwidth = 1;
-		} else {
-			bitwidth = 0;
-		}
-
-		while (value) {
-			bitwidth++;
-			value >>= 1;
-		}
-
-		bitwidth = GetEffectiveWidth<T>(bitwidth);
-
-		// Assert results are correct
-#ifdef DEBUG
-		if (bitwidth < sizeof(T) * 8 && bitwidth != 0) {
-			if (std::is_signed<T>::value) {
-				D_ASSERT((int64_t)max_value <= (int64_t)(1L << (bitwidth - 1)) - 1);
-				D_ASSERT((int64_t)min_value >= (int64_t)(-1 * ((1L << (bitwidth - 1)) - 1) - 1));
-			} else {
-				D_ASSERT((uint64_t)max_value <= (uint64_t)(1L << (bitwidth)) - 1);
-			}
-		}
-#endif
-		if (round_to_next_byte) {
-			return (bitwidth / 8 + (bitwidth % 8 != 0)) * 8;
-		} else {
-			return bitwidth;
-		}
-	}
-
-	template <class T>
-	static void UnPackGroup(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
-	                        bool skip_sign_extension = false) {
-		if (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) {
-			duckdb_fastpforlib::fastunpack((const uint8_t *)src, (uint8_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value) {
-			duckdb_fastpforlib::fastunpack((const uint16_t *)src, (uint16_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value) {
-			duckdb_fastpforlib::fastunpack((const uint32_t *)src, (uint32_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value) {
-			duckdb_fastpforlib::fastunpack((const uint32_t *)src, (uint64_t *)dst, (uint32_t)width);
-		} else {
-			throw InternalException("Unsupported type found in bitpacking.");
-		}
-
-		if (NumericLimits<T>::IsSigned() && !skip_sign_extension && width > 0 && width < sizeof(T) * 8) {
-			SignExtend<T>(dst, width);
-		}
-	}
-
-	// Prevent compression at widths that are ineffective
-	template <class T>
-	static bitpacking_width_t GetEffectiveWidth(bitpacking_width_t width) {
-		if (width > 56) {
-			return 64;
-		}
-
-		if (width > 28 && (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value)) {
-			return 32;
-		}
-
-		else if (width > 14 && (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value)) {
-			return 16;
-		}
-
-		return width;
-	}
-
-	// Sign bit extension
-	template <class T, class T_U = typename std::make_unsigned<T>::type>
-	static void SignExtend(data_ptr_t dst, bitpacking_width_t width) {
-		T const mask = ((T_U)1) << (width - 1);
-		for (idx_t i = 0; i < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; ++i) {
-			T value = Load<T>(dst + i * sizeof(T));
-			value = value & ((((T_U)1) << width) - ((T_U)1));
-			T result = (value ^ mask) - mask;
-			Store(result, dst + i * sizeof(T));
-		}
-	}
-
-	template <class T>
-	static void PackGroup(data_ptr_t dst, T *values, bitpacking_width_t width) {
-		if (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) {
-			duckdb_fastpforlib::fastpack((const uint8_t *)values, (uint8_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value) {
-			duckdb_fastpforlib::fastpack((const uint16_t *)values, (uint16_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value) {
-			duckdb_fastpforlib::fastpack((const uint32_t *)values, (uint32_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value) {
-			duckdb_fastpforlib::fastpack((const uint64_t *)values, (uint32_t *)dst, (uint32_t)width);
-		} else {
-			throw InternalException("Unsupported type found in bitpacking.");
-		}
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_data_checkpointer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_checkpoint_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-class ColumnData;
-class DatabaseInstance;
-class RowGroup;
-class TableDataWriter;
-
-struct ColumnCheckpointState {
-	ColumnCheckpointState(RowGroup &row_group, ColumnData &column_data, TableDataWriter &writer);
-	virtual ~ColumnCheckpointState();
-
-	RowGroup &row_group;
-	ColumnData &column_data;
-	TableDataWriter &writer;
-	SegmentTree new_tree;
-	vector<DataPointer> data_pointers;
-	unique_ptr<BaseStatistics> global_stats;
-
-public:
-	virtual unique_ptr<BaseStatistics> GetStatistics();
-
-	virtual void FlushSegment(unique_ptr<ColumnSegment> segment, idx_t segment_size);
-	virtual void FlushToDisk();
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class ColumnData;
-class ColumnSegment;
-class DatabaseInstance;
-class RowGroup;
-class TableDataWriter;
-class Transaction;
-
-struct DataTableInfo;
-
-struct ColumnCheckpointInfo {
-	ColumnCheckpointInfo(CompressionType compression_type_p) : compression_type(compression_type_p) {};
-	CompressionType compression_type;
-};
-
-class ColumnData {
-	friend class ColumnDataCheckpointer;
-
-public:
-	ColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type, ColumnData *parent);
-	virtual ~ColumnData();
-
-	//! Table info for the column
-	DataTableInfo &info;
-	//! The column index of the column, either within the parent table or within the parent
-	idx_t column_index;
-	//! The start row
-	idx_t start;
-	//! The type of the column
-	LogicalType type;
-	//! The parent column (if any)
-	ColumnData *parent;
-
-public:
-	virtual bool CheckZonemap(ColumnScanState &state, TableFilter &filter) = 0;
-
-	DatabaseInstance &GetDatabase() const;
-	DataTableInfo &GetTableInfo() const;
-	virtual idx_t GetMaxEntry();
-
-	//! The root type of the column
-	const LogicalType &RootType() const;
-
-	//! Initialize a scan of the column
-	virtual void InitializeScan(ColumnScanState &state);
-	//! Initialize a scan starting at the specified offset
-	virtual void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx);
-	//! Scan the next vector from the column
-	virtual idx_t Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result);
-	virtual idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates);
-	virtual void ScanCommittedRange(idx_t row_group_start, idx_t offset_in_row_group, idx_t count, Vector &result);
-	virtual idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count);
-	//! Select
-	virtual void Select(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	                    SelectionVector &sel, idx_t &count, const TableFilter &filter);
-	virtual void FilterScan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-	                        SelectionVector &sel, idx_t count);
-	virtual void FilterScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, SelectionVector &sel,
-	                                 idx_t count, bool allow_updates);
-
-	//! Skip the scan forward by "count" rows
-	virtual void Skip(ColumnScanState &state, idx_t count = STANDARD_VECTOR_SIZE);
-
-	//! Initialize an appending phase for this column
-	virtual void InitializeAppend(ColumnAppendState &state);
-	//! Append a vector of type [type] to the end of the column
-	virtual void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count);
-	virtual void AppendData(BaseStatistics &stats, ColumnAppendState &state, VectorData &vdata, idx_t count);
-	//! Revert a set of appends to the ColumnData
-	virtual void RevertAppend(row_t start_row);
-
-	//! Fetch the vector from the column data that belongs to this specific row
-	virtual idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result);
-	//! Fetch a specific row id and append it to the vector
-	virtual void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	                      idx_t result_idx);
-
-	virtual void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	                    idx_t update_count);
-	virtual void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                          row_t *row_ids, idx_t update_count, idx_t depth);
-	virtual unique_ptr<BaseStatistics> GetUpdateStatistics();
-
-	virtual void CommitDropColumn();
-
-	virtual unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group, TableDataWriter &writer);
-	virtual unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-	                                                     ColumnCheckpointInfo &checkpoint_info);
-
-	virtual void CheckpointScan(ColumnSegment *segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
-	                            Vector &scan_vector);
-
-	virtual void DeserializeColumn(Deserializer &source);
-	static shared_ptr<ColumnData> Deserialize(DataTableInfo &info, idx_t column_index, idx_t start_row,
-	                                          Deserializer &source, const LogicalType &type, ColumnData *parent);
-
-	virtual void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result);
-	virtual void Verify(RowGroup &parent);
-
-	static shared_ptr<ColumnData> CreateColumn(DataTableInfo &info, idx_t column_index, idx_t start_row,
-	                                           const LogicalType &type, ColumnData *parent = nullptr);
-	static unique_ptr<ColumnData> CreateColumnUnique(DataTableInfo &info, idx_t column_index, idx_t start_row,
-	                                                 const LogicalType &type, ColumnData *parent = nullptr);
-
-protected:
-	//! Append a transient segment
-	void AppendTransientSegment(idx_t start_row);
-
-	//! Scans a base vector from the column
-	idx_t ScanVector(ColumnScanState &state, Vector &result, idx_t remaining);
-	//! Scans a vector from the column merged with any potential updates
-	//! If ALLOW_UPDATES is set to false, the function will instead throw an exception if any updates are found
-	template <bool SCAN_COMMITTED, bool ALLOW_UPDATES>
-	idx_t ScanVector(Transaction *transaction, idx_t vector_index, ColumnScanState &state, Vector &result);
-
-protected:
-	//! The segments holding the data of this column segment
-	SegmentTree data;
-	//! The lock for the updates
-	mutex update_lock;
-	//! The updates for this column segment
-	unique_ptr<UpdateSegment> updates;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-class ColumnDataCheckpointer {
-public:
-	ColumnDataCheckpointer(ColumnData &col_data_p, RowGroup &row_group_p, ColumnCheckpointState &state_p,
-	                       ColumnCheckpointInfo &checkpoint_info);
-
-public:
-	DatabaseInstance &GetDatabase();
-	const LogicalType &GetType() const;
-	ColumnData &GetColumnData();
-	RowGroup &GetRowGroup();
-	ColumnCheckpointState &GetCheckpointState();
-
-	void Checkpoint(unique_ptr<SegmentBase> segment);
-
-private:
-	void ScanSegments(const std::function<void(Vector &, idx_t)> &callback);
-	unique_ptr<AnalyzeState> DetectBestCompressionMethod(idx_t &compression_idx);
-	void WriteToDisk();
-	bool HasChanges();
-	void WritePersistentSegments();
-
-private:
-	ColumnData &col_data;
-	RowGroup &row_group;
-	ColumnCheckpointState &state;
-	bool is_validity;
-	Vector intermediate;
-	unique_ptr<SegmentBase> owned_segment;
-	vector<CompressionFunction *> compression_functions;
-	ColumnCheckpointInfo &checkpoint_info;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/segment/uncompressed.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class DatabaseInstance;
-
-struct UncompressedFunctions {
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointer &checkpointer,
-	                                                    unique_ptr<AnalyzeState> state);
-	static void Compress(CompressionState &state_p, Vector &data, idx_t count);
-	static void FinalizeCompress(CompressionState &state_p);
-	static void EmptySkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	}
-};
-
-struct FixedSizeUncompressed {
-	static CompressionFunction GetFunction(PhysicalType data_type);
-};
-
-struct ValidityUncompressed {
-public:
-	static CompressionFunction GetFunction(PhysicalType data_type);
-
-public:
-	static const validity_t LOWER_MASKS[65];
-	static const validity_t UPPER_MASKS[65];
-};
-
-struct StringUncompressed {
-public:
-	static CompressionFunction GetFunction(PhysicalType data_type);
-
-public:
-	//! The max string size that is allowed within a block. Strings bigger than this will be labeled as a BIG STRING and
-	//! offloaded to the overflow blocks.
-	static constexpr uint16_t STRING_BLOCK_LIMIT = 4096;
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-struct StringDictionaryContainer {
-	//! The size of the dictionary
-	uint32_t size;
-	//! The end of the dictionary (typically Storage::BLOCK_SIZE)
-	uint32_t end;
-
-	void Verify() {
-		D_ASSERT(size <= Storage::BLOCK_SIZE);
-		D_ASSERT(end <= Storage::BLOCK_SIZE);
-		D_ASSERT(size <= end);
-	}
-};
-
-struct StringScanState : public SegmentScanState {
-	BufferHandle handle;
-};
-
-struct UncompressedStringStorage {
-public:
-	//! Dictionary header size at the beginning of the string segment (offset + length)
-	static constexpr uint16_t DICTIONARY_HEADER_SIZE = sizeof(uint32_t) + sizeof(uint32_t);
-	//! Marker used in length field to indicate the presence of a big string
-	static constexpr uint16_t BIG_STRING_MARKER = (uint16_t)-1;
-	//! Base size of big string marker (block id + offset)
-	static constexpr idx_t BIG_STRING_MARKER_BASE_SIZE = sizeof(block_id_t) + sizeof(int32_t);
-	//! The marker size of the big string
-	static constexpr idx_t BIG_STRING_MARKER_SIZE = BIG_STRING_MARKER_BASE_SIZE;
-	//! The size below which the segment is compacted on flushing
-	static constexpr size_t COMPACTION_FLUSH_LIMIT = (size_t)Storage::BLOCK_SIZE / 5 * 4;
-
-public:
-	static unique_ptr<AnalyzeState> StringInitAnalyze(ColumnData &col_data, PhysicalType type);
-	static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count);
-	static idx_t StringFinalAnalyze(AnalyzeState &state_p);
-	static unique_ptr<SegmentScanState> StringInitScan(ColumnSegment &segment);
-	static void StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
-	                              idx_t result_offset);
-	static void StringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result);
-	static void StringFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-	                           idx_t result_idx);
-	static unique_ptr<CompressedSegmentState> StringInitSegment(ColumnSegment &segment, block_id_t block_id);
-
-	static idx_t StringAppend(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset,
-	                          idx_t count) {
-		return StringAppendBase(segment, stats, data, offset, count);
-	}
-
-	template <bool DUPLICATE_ELIMINATE = false>
-	static idx_t StringAppendBase(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset,
-	                              idx_t count, std::unordered_map<string, int32_t> *seen_strings = nullptr) {
-		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-		auto handle = buffer_manager.Pin(segment.block);
-
-		D_ASSERT(segment.GetBlockOffset() == 0);
-		auto source_data = (string_t *)data.data;
-		auto result_data = (int32_t *)(handle.Ptr() + DICTIONARY_HEADER_SIZE);
-		for (idx_t i = 0; i < count; i++) {
-			auto source_idx = data.sel->get_index(offset + i);
-			auto target_idx = segment.count.load();
-			idx_t remaining_space = RemainingSpace(segment, handle);
-			if (remaining_space < sizeof(int32_t)) {
-				// string index does not fit in the block at all
-				return i;
-			}
-			remaining_space -= sizeof(int32_t);
-			auto dictionary = GetDictionary(segment, handle);
-			if (!data.validity.RowIsValid(source_idx)) {
-				// null value is stored as a copy of the last value, this is done to be able to efficiently do the
-				// string_length calculation
-				if (target_idx > 0) {
-					result_data[target_idx] = result_data[target_idx - 1];
-				} else {
-					result_data[target_idx] = 0;
-				}
-			} else {
-				auto end = handle.Ptr() + dictionary.end;
-
-				dictionary.Verify();
-
-				int32_t match;
-				bool found;
-				if (DUPLICATE_ELIMINATE) {
-					auto search = seen_strings->find(source_data[source_idx].GetString());
-					if (search != seen_strings->end()) {
-						match = search->second;
-						found = true;
-					} else {
-						found = false;
-					}
-				}
-
-				if (DUPLICATE_ELIMINATE && found) {
-					// We have seen this string
-					result_data[target_idx] = match;
-				} else {
-					// Unknown string, continue
-					// non-null value, check if we can fit it within the block
-					idx_t string_length = source_data[source_idx].GetSize();
-					idx_t dictionary_length = string_length;
-
-					// determine whether or not we have space in the block for this string
-					bool use_overflow_block = false;
-					idx_t required_space = dictionary_length;
-					if (required_space >= StringUncompressed::STRING_BLOCK_LIMIT) {
-						// string exceeds block limit, store in overflow block and only write a marker here
-						required_space = BIG_STRING_MARKER_SIZE;
-						use_overflow_block = true;
-					}
-					if (required_space > remaining_space) {
-						// no space remaining: return how many tuples we ended up writing
-						return i;
-					}
-
-					// we have space: write the string
-					UpdateStringStats(stats, source_data[source_idx]);
-
-					if (use_overflow_block) {
-						// write to overflow blocks
-						block_id_t block;
-						int32_t offset;
-						// write the string into the current string block
-						WriteString(segment, source_data[source_idx], block, offset);
-						dictionary.size += BIG_STRING_MARKER_SIZE;
-						auto dict_pos = end - dictionary.size;
-
-						// write a big string marker into the dictionary
-						WriteStringMarker(dict_pos, block, offset);
-					} else {
-						// string fits in block, append to dictionary and increment dictionary position
-						D_ASSERT(string_length < NumericLimits<uint16_t>::Maximum());
-						dictionary.size += required_space;
-						auto dict_pos = end - dictionary.size;
-						// now write the actual string data into the dictionary
-						memcpy(dict_pos, source_data[source_idx].GetDataUnsafe(), string_length);
-					}
-					D_ASSERT(RemainingSpace(segment, handle) <= Storage::BLOCK_SIZE);
-					// place the dictionary offset into the set of vectors
-					dictionary.Verify();
-
-					// note: for overflow strings we write negative value
-					result_data[target_idx] = use_overflow_block ? -1 * dictionary.size : dictionary.size;
-
-					if (DUPLICATE_ELIMINATE) {
-						seen_strings->insert({source_data[source_idx].GetString(), dictionary.size});
-					}
-					SetDictionary(segment, handle, dictionary);
-				}
-			}
-			segment.count++;
-		}
-		return count;
-	}
-
-	static idx_t FinalizeAppend(ColumnSegment &segment, SegmentStatistics &stats);
-
-public:
-	static inline void UpdateStringStats(SegmentStatistics &stats, const string_t &new_value) {
-		auto &sstats = (StringStatistics &)*stats.statistics;
-		sstats.Update(new_value);
-	}
-
-	static void SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer dict);
-	static StringDictionaryContainer GetDictionary(ColumnSegment &segment, BufferHandle &handle);
-	static idx_t RemainingSpace(ColumnSegment &segment, BufferHandle &handle);
-	static void WriteString(ColumnSegment &segment, string_t string, block_id_t &result_block, int32_t &result_offset);
-	static void WriteStringMemory(ColumnSegment &segment, string_t string, block_id_t &result_block,
-	                              int32_t &result_offset);
-	static string_t ReadOverflowString(ColumnSegment &segment, Vector &result, block_id_t block, int32_t offset);
-	static string_t ReadString(data_ptr_t target, int32_t offset, uint32_t string_length);
-	static string_t ReadStringWithLength(data_ptr_t target, int32_t offset);
-	static void WriteStringMarker(data_ptr_t target, block_id_t block_id, int32_t offset);
-	static void ReadStringMarker(data_ptr_t target, block_id_t &block_id, int32_t &offset);
-
-	static string_location_t FetchStringLocation(StringDictionaryContainer dict, data_ptr_t baseptr,
-	                                             int32_t dict_offset);
-	static string_t FetchStringFromDict(ColumnSegment &segment, StringDictionaryContainer dict, Vector &result,
-	                                    data_ptr_t baseptr, int32_t dict_offset, uint32_t string_length);
-	static string_t FetchString(ColumnSegment &segment, StringDictionaryContainer dict, Vector &result,
-	                            data_ptr_t baseptr, string_location_t location, uint32_t string_length);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/standard_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/validity_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! Validity column data represents the validity data (i.e. which values are null)
-class ValidityColumnData : public ColumnData {
-public:
-	ValidityColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, ColumnData *parent);
-
-public:
-	bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//! Standard column data represents a regular flat column (e.g. a column of type INTEGER or STRING)
-class StandardColumnData : public ColumnData {
-public:
-	StandardColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type,
-	                   ColumnData *parent = nullptr);
-
-	//! The validity column data
-	ValidityColumnData validity;
-
-public:
-	bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
-
-	void InitializeScan(ColumnScanState &state) override;
-	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
-
-	idx_t Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) override;
-	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
-
-	void InitializeAppend(ColumnAppendState &state) override;
-	void AppendData(BaseStatistics &stats, ColumnAppendState &state, VectorData &vdata, idx_t count) override;
-	void RevertAppend(row_t start_row) override;
-	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
-	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	              idx_t result_idx) override;
-	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
-	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
-
-	void CommitDropColumn() override;
-
-	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group, TableDataWriter &writer) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-	                                             ColumnCheckpointInfo &checkpoint_info) override;
-	void CheckpointScan(ColumnSegment *segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
-	                    Vector &scan_vector) override;
-
-	void DeserializeColumn(Deserializer &source) override;
-
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) override;
-
-	void Verify(RowGroup &parent) override;
-
-private:
-	template <bool SCAN_COMMITTED, bool ALLOW_UPDATES>
-	void TemplatedScan(Transaction *transaction, ColumnScanState &state, Vector &result);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/single_file_block_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-class DatabaseInstance;
-
-//! SingleFileBlockManager is an implementation for a BlockManager which manages blocks in a single file
-class SingleFileBlockManager : public BlockManager {
-	//! The location in the file where the block writing starts
-	static constexpr uint64_t BLOCK_START = Storage::FILE_HEADER_SIZE * 3;
-
-public:
-	SingleFileBlockManager(DatabaseInstance &db, string path, bool read_only, bool create_new, bool use_direct_io);
-
-	void StartCheckpoint() override;
-	//! Creates a new Block using the specified block_id and returns a pointer
-	unique_ptr<Block> CreateBlock(block_id_t block_id) override;
-	//! Return the next free block id
-	block_id_t GetFreeBlockId() override;
-	//! Returns whether or not a specified block is the root block
-	bool IsRootBlock(block_id_t root) override;
-	//! Mark a block as modified
-	void MarkBlockAsModified(block_id_t block_id) override;
-	//! Increase the reference count of a block. The block should hold at least one reference
-	void IncreaseBlockReferenceCount(block_id_t block_id) override;
-	//! Return the meta block id
-	block_id_t GetMetaBlock() override;
-	//! Read the content of the block from disk
-	void Read(Block &block) override;
-	//! Write the given block to disk
-	void Write(FileBuffer &block, block_id_t block_id) override;
-	//! Write the header to disk, this is the final step of the checkpointing process
-	void WriteHeader(DatabaseHeader header) override;
-
-	//! Returns the number of total blocks
-	idx_t TotalBlocks() override {
-		return max_block;
-	}
-	//! Returns the number of free blocks
-	idx_t FreeBlocks() override {
-		return free_list.size();
-	}
-	//! Load the free list from the file
-	void LoadFreeList();
-
-private:
-	void Initialize(DatabaseHeader &header);
-
-	//! Return the blocks to which we will write the free list and modified blocks
-	vector<block_id_t> GetFreeListBlocks();
-
-private:
-	DatabaseInstance &db;
-	//! The active DatabaseHeader, either 0 (h1) or 1 (h2)
-	uint8_t active_header;
-	//! The path where the file is stored
-	string path;
-	//! The file handle
-	unique_ptr<FileHandle> handle;
-	//! The buffer used to read/write to the headers
-	FileBuffer header_buffer;
-	//! The list of free blocks that can be written to currently
-	set<block_id_t> free_list;
-	//! The list of multi-use blocks (i.e. blocks that have >1 reference in the file)
-	//! When a multi-use block is marked as modified, the reference count is decreased by 1 instead of directly
-	//! Appending the block to the modified_blocks list
-	unordered_map<block_id_t, uint32_t> multi_use_blocks;
-	//! The list of blocks that will be added to the free list
-	unordered_set<block_id_t> modified_blocks;
-	//! The current meta block id
-	block_id_t meta_block;
-	//! The current maximum block id, this id will be given away first after the free_list runs out
-	block_id_t max_block;
-	//! The block id where the free list can be found
-	block_id_t free_list_id;
-	//! The current header iteration count
-	uint64_t iteration_count;
-	//! Whether or not the db is opened in read-only mode
-	bool read_only;
-	//! Whether or not to use Direct IO to read the blocks
-	bool use_direct_io;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/in_memory_block_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! InMemoryBlockManager is an implementation for a BlockManager
-class InMemoryBlockManager : public BlockManager {
-public:
-	// LCOV_EXCL_START
-	void StartCheckpoint() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	unique_ptr<Block> CreateBlock(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	block_id_t GetFreeBlockId() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	bool IsRootBlock(block_id_t root) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void MarkBlockAsModified(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void IncreaseBlockReferenceCount(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	block_id_t GetMetaBlock() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void Read(Block &block) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void Write(FileBuffer &block, block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	void WriteHeader(DatabaseHeader header) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	idx_t TotalBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	idx_t FreeBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
-	}
-	// LCOV_EXCL_STOP
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/list_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! List column data represents a list
-class ListColumnData : public ColumnData {
-public:
-	ListColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type,
-	               ColumnData *parent = nullptr);
-
-	//! The child-column of the list
-	unique_ptr<ColumnData> child_column;
-	//! The validity column data of the struct
-	ValidityColumnData validity;
-
-public:
-	bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
-
-	void InitializeScan(ColumnScanState &state) override;
-	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
-
-	idx_t Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) override;
-	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
-
-	void Skip(ColumnScanState &state, idx_t count = STANDARD_VECTOR_SIZE) override;
-
-	void InitializeAppend(ColumnAppendState &state) override;
-	void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) override;
-	void RevertAppend(row_t start_row) override;
-	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
-	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	              idx_t result_idx) override;
-	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
-	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
-
-	void CommitDropColumn() override;
-
-	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group, TableDataWriter &writer) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-	                                             ColumnCheckpointInfo &checkpoint_info) override;
-
-	void DeserializeColumn(Deserializer &source) override;
-
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) override;
-
-private:
-	list_entry_t FetchListEntry(idx_t row_idx);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/struct_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Struct column data represents a struct
-class StructColumnData : public ColumnData {
-public:
-	StructColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type,
-	                 ColumnData *parent = nullptr);
-
-	//! The sub-columns of the struct
-	vector<unique_ptr<ColumnData>> sub_columns;
-	//! The validity column data of the struct
-	ValidityColumnData validity;
-
-public:
-	bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
-	idx_t GetMaxEntry() override;
-
-	void InitializeScan(ColumnScanState &state) override;
-	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
-
-	idx_t Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) override;
-	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
-
-	void InitializeAppend(ColumnAppendState &state) override;
-	void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) override;
-	void RevertAppend(row_t start_row) override;
-	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
-	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	              idx_t result_idx) override;
-	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
-	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
-
-	void CommitDropColumn() override;
-
-	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group, TableDataWriter &writer) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-	                                             ColumnCheckpointInfo &checkpoint_info) override;
-
-	void DeserializeColumn(Deserializer &source) override;
-
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) override;
-
-	void Verify(RowGroup &parent) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/update_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class ColumnData;
-class DataTable;
-class Vector;
-struct UpdateInfo;
-struct UpdateNode;
-
-class UpdateSegment {
-public:
-	UpdateSegment(ColumnData &column_data);
-	~UpdateSegment();
-
-	ColumnData &column_data;
-
-public:
-	bool HasUpdates() const;
-	bool HasUncommittedUpdates(idx_t vector_index);
-	bool HasUpdates(idx_t vector_index) const;
-	bool HasUpdates(idx_t start_row_idx, idx_t end_row_idx);
-	void ClearUpdates();
-
-	void FetchUpdates(Transaction &transaction, idx_t vector_index, Vector &result);
-	void FetchCommitted(idx_t vector_index, Vector &result);
-	void FetchCommittedRange(idx_t start_row, idx_t count, Vector &result);
-	void Update(Transaction &transaction, idx_t column_index, Vector &update, row_t *ids, idx_t count,
-	            Vector &base_data);
-	void FetchRow(Transaction &transaction, idx_t row_id, Vector &result, idx_t result_idx);
-
-	void RollbackUpdate(UpdateInfo *info);
-	void CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo *info);
-	void CleanupUpdate(UpdateInfo *info);
-
-	unique_ptr<BaseStatistics> GetStatistics();
-	StringHeap &GetStringHeap() {
-		return heap;
-	}
-
-private:
-	//! The lock for the update segment
-	StorageLock lock;
-	//! The root node (if any)
-	unique_ptr<UpdateNode> root;
-	//! Update statistics
-	SegmentStatistics stats;
-	//! Stats lock
-	mutex stats_lock;
-	//! Internal type size
-	idx_t type_size;
-	//! String heap, only used for strings
-	StringHeap heap;
-
-public:
-	typedef void (*initialize_update_function_t)(UpdateInfo *base_info, Vector &base_data, UpdateInfo *update_info,
-	                                             Vector &update, const SelectionVector &sel);
-	typedef void (*merge_update_function_t)(UpdateInfo *base_info, Vector &base_data, UpdateInfo *update_info,
-	                                        Vector &update, row_t *ids, idx_t count, const SelectionVector &sel);
-	typedef void (*fetch_update_function_t)(transaction_t start_time, transaction_t transaction_id, UpdateInfo *info,
-	                                        Vector &result);
-	typedef void (*fetch_committed_function_t)(UpdateInfo *info, Vector &result);
-	typedef void (*fetch_committed_range_function_t)(UpdateInfo *info, idx_t start, idx_t end, idx_t result_offset,
-	                                                 Vector &result);
-	typedef void (*fetch_row_function_t)(transaction_t start_time, transaction_t transaction_id, UpdateInfo *info,
-	                                     idx_t row_idx, Vector &result, idx_t result_idx);
-	typedef void (*rollback_update_function_t)(UpdateInfo *base_info, UpdateInfo *rollback_info);
-	typedef idx_t (*statistics_update_function_t)(UpdateSegment *segment, SegmentStatistics &stats, Vector &update,
-	                                              idx_t count, SelectionVector &sel);
-
-private:
-	initialize_update_function_t initialize_update_function;
-	merge_update_function_t merge_update_function;
-	fetch_update_function_t fetch_update_function;
-	fetch_committed_function_t fetch_committed_function;
-	fetch_committed_range_function_t fetch_committed_range;
-	fetch_row_function_t fetch_row_function;
-	rollback_update_function_t rollback_update_function;
-	statistics_update_function_t statistics_update_function;
-
-private:
-	void InitializeUpdateInfo(UpdateInfo &info, row_t *ids, const SelectionVector &sel, idx_t count, idx_t vector_index,
-	                          idx_t vector_offset);
-};
-
-struct UpdateNodeData {
-	unique_ptr<UpdateInfo> info;
-	unique_ptr<sel_t[]> tuples;
-	unique_ptr<data_t[]> tuple_data;
-};
-
-struct UpdateNode {
-	unique_ptr<UpdateNodeData> info[RowGroup::ROW_GROUP_VECTOR_COUNT];
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/update_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class UpdateSegment;
-struct DataTableInfo;
-
-struct UpdateInfo {
-	//! The update segment that this update info affects
-	UpdateSegment *segment;
-	//! The column index of which column we are updating
-	idx_t column_index;
-	//! The version number
-	atomic<transaction_t> version_number;
-	//! The vector index within the uncompressed segment
-	idx_t vector_index;
-	//! The amount of updated tuples
-	sel_t N;
-	//! The maximum amount of tuples that can fit into this UpdateInfo
-	sel_t max;
-	//! The row ids of the tuples that have been updated. This should always be kept sorted!
-	sel_t *tuples;
-	//! The data of the tuples
-	data_ptr_t tuple_data;
-	//! The previous update info (or nullptr if it is the base)
-	UpdateInfo *prev;
-	//! The next update info in the chain (or nullptr if it is the last)
-	UpdateInfo *next;
-
-	//! Loop over the update chain and execute the specified callback on all UpdateInfo's that are relevant for that
-	//! transaction in-order of newest to oldest
-	template <class T>
-	static void UpdatesForTransaction(UpdateInfo *current, transaction_t start_time, transaction_t transaction_id,
-	                                  T &&callback) {
-		while (current) {
-			if (current->version_number > start_time && current->version_number != transaction_id) {
-				// these tuples were either committed AFTER this transaction started or are not committed yet, use
-				// tuples stored in this version
-				callback(current);
-			}
-			current = current->next;
-		}
-	}
-
-	Value GetValue(idx_t index);
-	string ToString();
-	void Print();
-	void Verify();
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/cleanup_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class DataTable;
-
-struct DeleteInfo;
-struct UpdateInfo;
-
-class CleanupState {
-public:
-	CleanupState();
-	~CleanupState();
-
-public:
-	void CleanupEntry(UndoFlags type, data_ptr_t data);
-
-private:
-	// data for index cleanup
-	DataTable *current_table;
-	DataChunk chunk;
-	row_t row_numbers[STANDARD_VECTOR_SIZE];
-	idx_t count;
-
-private:
-	void CleanupDelete(DeleteInfo *info);
-	void CleanupUpdate(UpdateInfo *info);
-
-	void Flush();
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/delete_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class ChunkVectorInfo;
-class DataTable;
-
-struct DeleteInfo {
-	DataTable *table;
-	ChunkVectorInfo *vinfo;
-	idx_t count;
-	idx_t base_row;
-	row_t rows[1];
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/commit_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class CatalogEntry;
-class DataChunk;
-class WriteAheadLog;
-
-struct DataTableInfo;
-struct DeleteInfo;
-struct UpdateInfo;
-
-class CommitState {
-public:
-	explicit CommitState(transaction_t commit_id, WriteAheadLog *log = nullptr);
-
-	WriteAheadLog *log;
-	transaction_t commit_id;
-	UndoFlags current_op;
-
-	DataTableInfo *current_table_info;
-	idx_t row_identifiers[STANDARD_VECTOR_SIZE];
-
-	unique_ptr<DataChunk> delete_chunk;
-	unique_ptr<DataChunk> update_chunk;
-
-public:
-	template <bool HAS_LOG>
-	void CommitEntry(UndoFlags type, data_ptr_t data);
-	void RevertCommit(UndoFlags type, data_ptr_t data);
-
-private:
-	void SwitchTable(DataTableInfo *table, UndoFlags new_op);
-
-	void WriteCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data);
-	void WriteDelete(DeleteInfo *info);
-	void WriteUpdate(UpdateInfo *info);
-
-	void AppendRowId(row_t rowid);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/append_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class DataTable;
-
-struct AppendInfo {
-	DataTable *table;
-	idx_t start_row;
-	idx_t count;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/rollback_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class DataChunk;
-class DataTable;
-class WriteAheadLog;
-
-class RollbackState {
-public:
-	RollbackState() {
-	}
-
-public:
-	void RollbackEntry(UndoFlags type, data_ptr_t data);
-};
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/duckdb-libpg_query.cpp b/velox/external/duckdb/duckdb-libpg_query.cpp
deleted file mode 100644
index 16d3cf63ac860..0000000000000
--- a/velox/external/duckdb/duckdb-libpg_query.cpp
+++ /dev/null
@@ -1,35023 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-#include <stdexcept>
-#include <string>
-#include <thread>
-#include <mutex>
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-
-
-#include <stdlib.h>
-#include <string>
-
-#define fprintf(...)
-
-
-
-
-
-
-namespace duckdb_libpgquery {
-
-typedef struct parse_result_str parse_result;
-struct parse_result_str {
-	bool success;
-	PGList *parse_tree;
-	std::string error_message;
-	int error_location;
-};
-
-void pg_parser_init();
-void pg_parser_parse(const char *query, parse_result *res);
-void pg_parser_cleanup();
-
-// error handling
-int ereport(int code, ...);
-
-void elog(int code, const char *fmt, ...);
-int errcode(int sqlerrcode);
-int errmsg(const char *fmt, ...);
-int errhint(const char *msg);
-int errmsg_internal(const char *fmt, ...);
-int errdetail(const char *fmt, ...);
-int errposition(int cursorpos);
-char *psprintf(const char *fmt, ...);
-
-// memory mgmt
-char *pstrdup(const char *in);
-void *palloc(size_t n);
-void pfree(void *ptr);
-void *palloc0fast(size_t n);
-void *repalloc(void *ptr, size_t n);
-
-char *NameListToString(PGList *names);
-void *copyObject(const void *from);
-bool equal(const void *a, const void *b);
-int exprLocation(const PGNode *expr);
-
-// string gunk
-int pg_database_encoding_max_length(void);
-bool pg_verifymbstr(const char *mbstr, int len, bool noError);
-int pg_mbstrlen_with_len(const char *mbstr, int len);
-int pg_mbcliplen(const char *mbstr, int len, int limit);
-int pg_mblen(const char *mbstr);
-
-PGDefElem *defWithOids(bool value);
-
-typedef unsigned int pg_wchar;
-unsigned char *unicode_to_utf8(pg_wchar c, unsigned char *utf8string);
-
-}
-
-// LICENSE_CHANGE_END
-
-
-#include <stdarg.h>
-#include <mutex>
-#include <cstring>
-
-
-// max parse tree size approx 100 MB, should be enough
-#define PG_MALLOC_SIZE 10240
-
-namespace duckdb_libpgquery {
-
-typedef struct pg_parser_state_str parser_state;
-struct pg_parser_state_str {
-	int pg_err_code;
-	int pg_err_pos;
-	char pg_err_msg[BUFSIZ];
-
-	size_t malloc_pos;
-	size_t malloc_ptr_idx;
-	char **malloc_ptrs;
-	size_t malloc_ptr_size;
-};
-
-static __thread parser_state pg_parser_state;
-
-#ifndef __GNUC__
-__thread PGNode *duckdb_newNodeMacroHolder;
-#endif
-
-static void allocate_new(parser_state *state, size_t n) {
-	if (state->malloc_ptr_idx >= state->malloc_ptr_size) {
-		size_t new_size = state->malloc_ptr_size * 2;
-		auto new_malloc_ptrs = (char **) malloc(sizeof(char *) * new_size);
-		memset(new_malloc_ptrs, 0, sizeof(char*) * new_size);
-		memcpy(new_malloc_ptrs, state->malloc_ptrs, state->malloc_ptr_size * sizeof(char*));
-		free(state->malloc_ptrs);
-		state->malloc_ptr_size = new_size;
-		state->malloc_ptrs = new_malloc_ptrs;
-	}
-	if (n < PG_MALLOC_SIZE) {
-		n = PG_MALLOC_SIZE;
-	}
-	char *base_ptr = (char *)malloc(n);
-	if (!base_ptr) {
-		throw std::runtime_error("Memory allocation failure");
-	}
-	state->malloc_ptrs[state->malloc_ptr_idx] = base_ptr;
-	state->malloc_ptr_idx++;
-	state->malloc_pos = 0;
-}
-
-void *palloc(size_t n) {
-	// we need to align our pointers for the sanitizer
-	auto allocate_n = n + sizeof(size_t);
-	auto aligned_n = ((allocate_n + 7) / 8) * 8;
-	if (pg_parser_state.malloc_pos + aligned_n > PG_MALLOC_SIZE) {
-		allocate_new(&pg_parser_state, aligned_n);
-	}
-
-	// store the length of the allocation
-	char *base_ptr = pg_parser_state.malloc_ptrs[pg_parser_state.malloc_ptr_idx - 1] + pg_parser_state.malloc_pos;
-	memcpy(base_ptr, &n, sizeof(size_t));
-	// store the actual pointer
-	char *ptr = (char*) base_ptr + sizeof(size_t);
-	memset(ptr, 0, n);
-	pg_parser_state.malloc_pos += aligned_n;
-	return ptr;
-}
-
-void pg_parser_init() {
-	pg_parser_state.pg_err_code = PGUNDEFINED;
-	pg_parser_state.pg_err_msg[0] = '\0';
-
-	pg_parser_state.malloc_ptr_size = 4;
-	pg_parser_state.malloc_ptrs = (char **) malloc(sizeof(char *) * pg_parser_state.malloc_ptr_size);
-	memset(pg_parser_state.malloc_ptrs, 0, sizeof(char*) * pg_parser_state.malloc_ptr_size);
-	pg_parser_state.malloc_ptr_idx = 0;
-	allocate_new(&pg_parser_state, 1);
-}
-
-void pg_parser_parse(const char *query, parse_result *res) {
-	res->parse_tree = nullptr;
-	try {
-		res->parse_tree = duckdb_libpgquery::raw_parser(query);
-		res->success = pg_parser_state.pg_err_code == PGUNDEFINED;
-	} catch (std::exception &ex) {
-		res->success = false;
-		res->error_message = ex.what();
-	}
-	res->error_message = pg_parser_state.pg_err_msg;
-	res->error_location = pg_parser_state.pg_err_pos;
-}
-
-void pg_parser_cleanup() {
-	for (size_t ptr_idx = 0; ptr_idx < pg_parser_state.malloc_ptr_idx; ptr_idx++) {
-		char *ptr = pg_parser_state.malloc_ptrs[ptr_idx];
-		if (ptr) {
-			free(ptr);
-			pg_parser_state.malloc_ptrs[ptr_idx] = nullptr;
-		}
-	}
-	free(pg_parser_state.malloc_ptrs);
-}
-
-int ereport(int code, ...) {
-	std::string err = "parser error : " + std::string(pg_parser_state.pg_err_msg);
-	throw std::runtime_error(err);
-}
-void elog(int code, const char *fmt, ...) {
-	throw std::runtime_error("elog NOT IMPLEMENTED");
-}
-int errcode(int sqlerrcode) {
-	pg_parser_state.pg_err_code = sqlerrcode;
-	return 1;
-}
-int errmsg(const char *fmt, ...) {
-	va_list argptr;
-	va_start(argptr, fmt);
-	vsnprintf(pg_parser_state.pg_err_msg, BUFSIZ, fmt, argptr);
-	va_end(argptr);
-	return 1;
-}
-int errhint(const char *msg) {
-	throw std::runtime_error("errhint NOT IMPLEMENTED");
-}
-int errmsg_internal(const char *fmt, ...) {
-	throw std::runtime_error("errmsg_internal NOT IMPLEMENTED");
-}
-int errdetail(const char *fmt, ...) {
-	throw std::runtime_error("errdetail NOT IMPLEMENTED");
-}
-int errposition(int cursorpos) {
-	pg_parser_state.pg_err_pos = cursorpos;
-	return 1;
-}
-
-char *psprintf(const char *fmt, ...) {
-	char buf[BUFSIZ];
-	va_list args;
-	size_t newlen;
-
-	// attempt one: use stack buffer and determine length
-	va_start(args, fmt);
-	newlen = vsnprintf(buf, BUFSIZ, fmt, args);
-	va_end(args);
-	if (newlen < BUFSIZ) {
-		return pstrdup(buf);
-	}
-
-	// attempt two, malloc
-	char *mbuf = (char *)palloc(newlen);
-	va_start(args, fmt);
-	vsnprintf(mbuf, newlen, fmt, args);
-	va_end(args);
-	return mbuf;
-}
-
-char *pstrdup(const char *in) {
-	char *new_str = (char *)palloc(strlen(in) + 1);
-	memcpy(new_str, in, strlen(in));
-	return new_str;
-}
-
-void pfree(void *ptr) {
-	// nop, we free up entire context on parser cleanup
-}
-void *palloc0fast(size_t n) { // very fast
-	return palloc(n);
-}
-void *repalloc(void *ptr, size_t n) {
-	// get the length of the allocation
-	size_t old_len;
-	char *old_len_ptr = (char *) ptr - sizeof(size_t);
-	memcpy((void *) &old_len, old_len_ptr, sizeof(size_t));
-	// re-allocate and copy the data
-	void *new_buf = palloc(n);
-	memcpy(new_buf, ptr, old_len);
-	return new_buf;
-}
-char *NameListToString(PGList *names) {
-	throw std::runtime_error("NameListToString NOT IMPLEMENTED");
-}
-void *copyObject(const void *from) {
-	throw std::runtime_error("copyObject NOT IMPLEMENTED");
-}
-bool equal(const void *a, const void *b) {
-	throw std::runtime_error("equal NOT IMPLEMENTED");
-}
-int exprLocation(const PGNode *expr) {
-	throw std::runtime_error("exprLocation NOT IMPLEMENTED");
-}
-bool pg_verifymbstr(const char *mbstr, int len, bool noError) {
-	throw std::runtime_error("pg_verifymbstr NOT IMPLEMENTED");
-}
-
-int pg_database_encoding_max_length(void) {
-	return 4; // UTF8
-}
-
-static int pg_utf_mblen(const unsigned char *s) {
-	int len;
-
-	if ((*s & 0x80) == 0)
-		len = 1;
-	else if ((*s & 0xe0) == 0xc0)
-		len = 2;
-	else if ((*s & 0xf0) == 0xe0)
-		len = 3;
-	else if ((*s & 0xf8) == 0xf0)
-		len = 4;
-#ifdef NOT_USED
-	else if ((*s & 0xfc) == 0xf8)
-		len = 5;
-	else if ((*s & 0xfe) == 0xfc)
-		len = 6;
-#endif
-	else
-		len = 1;
-	return len;
-}
-
-int pg_mbstrlen_with_len(const char *mbstr, int limit) {
-	int len = 0;
-	while (limit > 0 && *mbstr) {
-		int l = pg_utf_mblen((const unsigned char *)mbstr);
-		limit -= l;
-		mbstr += l;
-		len++;
-	}
-	return len;
-}
-
-int pg_mbcliplen(const char *mbstr, int len, int limit) {
-	throw std::runtime_error("pg_mbcliplen NOT IMPLEMENTED");
-}
-int pg_mblen(const char *mbstr) {
-	throw std::runtime_error("pg_mblen NOT IMPLEMENTED");
-}
-PGDefElem *defWithOids(bool value) {
-	throw std::runtime_error("defWithOids NOT IMPLEMENTED");
-}
-unsigned char *unicode_to_utf8(pg_wchar c, unsigned char *utf8string) {
-	throw std::runtime_error("unicode_to_utf8 NOT IMPLEMENTED");
-}
-
-// this replaces a brain damaged macro in nodes.hpp
-PGNode *newNode(size_t size, PGNodeTag type) {
-	auto result = (PGNode *)palloc0fast(size);
-	result->type = type;
-	return result;
-}
-}
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * scansup.h
- *	  scanner support routines.  used by both the bootstrap lexer
- * as well as the normal lexer
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/scansup.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-namespace duckdb_libpgquery {
-
-char *scanstr(const char *s);
-
-char *downcase_truncate_identifier(const char *ident, int len, bool warn);
-
-char *downcase_identifier(const char *ident, int len, bool warn, bool truncate);
-
-bool scanner_isspace(char ch);
-
-void set_preserve_identifier_case(bool downcase);
-bool get_preserve_identifier_case();
-
-}
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * keywords.h
- *	  lexical token lookup for key words in PostgreSQL
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/common/keywords.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-#include <cstdint>
-
-/* Keyword categories --- should match lists in gram.y */
-#define UNRESERVED_KEYWORD		0
-#define COL_NAME_KEYWORD		1
-#define TYPE_FUNC_NAME_KEYWORD	2
-#define RESERVED_KEYWORD		3
-
-namespace duckdb_libpgquery {
-
-typedef struct PGScanKeyword {
-	const char *name; /* in lower case */
-	int16_t value;    /* grammar's token code */
-	int16_t category; /* see codes above */
-} PGScanKeyword;
-
-const PGScanKeyword *ScanKeywordLookup(const char *text, const PGScanKeyword *keywords, int num_keywords);
-}
-
-// LICENSE_CHANGE_END
-
-
-using namespace std;
-
-namespace duckdb {
-
-PostgresParser::PostgresParser() : success(false), parse_tree(nullptr), error_message(""), error_location(0) {}
-
-void PostgresParser::Parse(const string &query) {
-	duckdb_libpgquery::pg_parser_init();
-	duckdb_libpgquery::parse_result res;
-	pg_parser_parse(query.c_str(), &res);
-	success = res.success;
-
-	if (success) {
-		parse_tree = res.parse_tree;
-	} else {
-		error_message = string(res.error_message);
-		error_location = res.error_location;
-	}
-}
-
-vector<duckdb_libpgquery::PGSimplifiedToken> PostgresParser::Tokenize(const std::string &query) {
-	duckdb_libpgquery::pg_parser_init();
-	auto tokens = duckdb_libpgquery::tokenize(query.c_str());
-	duckdb_libpgquery::pg_parser_cleanup();
-	return tokens;
-}
-
-PostgresParser::~PostgresParser()  {
-    duckdb_libpgquery::pg_parser_cleanup();
-}
-
-bool PostgresParser::IsKeyword(const std::string &text) {
-	return duckdb_libpgquery::is_keyword(text.c_str());
-}
-
-vector<duckdb_libpgquery::PGKeyword> PostgresParser::KeywordList() {
-	return duckdb_libpgquery::keyword_list();
-}
-
-void PostgresParser::SetPreserveIdentifierCase(bool preserve) {
-	duckdb_libpgquery::set_preserve_identifier_case(preserve);
-}
-
-}
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - lappend
- * - new_list
- * - new_tail_cell
- * - lcons
- * - new_head_cell
- * - list_concat
- * - list_nth
- * - list_nth_cell
- * - list_delete_cell
- * - list_free
- * - list_free_private
- * - list_copy
- * - list_copy_tail
- * - list_truncate
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * list.c
- *	  implementation for PostgreSQL generic linked list package
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/nodes/list.c
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-namespace duckdb_libpgquery {
-
-/*
- * Routines to simplify writing assertions about the type of a list; a
- * NIL list is considered to be an empty list of any type.
- */
-#define IsPointerList(l)		((l) == NIL || IsA((l), PGList))
-#define IsIntegerList(l)		((l) == NIL || IsA((l), IntList))
-#define IsOidList(l)			((l) == NIL || IsA((l), OidList))
-
-#ifdef USE_ASSERT_CHECKING
-/*
- * Check that the specified PGList is valid (so far as we can tell).
- */
-static void
-check_list_invariants(const PGList *list)
-{
-	if (list == NIL)
-		return;
-
-	Assert(list->length > 0);
-	Assert(list->head != NULL);
-	Assert(list->tail != NULL);
-
-	Assert(list->type == T_PGList ||
-		   list->type == T_PGIntList ||
-		   list->type == T_PGOidList);
-
-	if (list->length == 1)
-		Assert(list->head == list->tail);
-	if (list->length == 2)
-		Assert(list->head->next == list->tail);
-	Assert(list->tail->next == NULL);
-}
-#else
-#define check_list_invariants(l)
-#endif							/* USE_ASSERT_CHECKING */
-
-/*
- * Return a freshly allocated List. Since empty non-NIL lists are
- * invalid, new_list() also allocates the head cell of the new list:
- * the caller should be sure to fill in that cell's data.
- */
-static PGList *
-new_list(PGNodeTag type)
-{
-	PGList	   *new_list;
-	PGListCell   *new_head;
-
-	new_head = (PGListCell *) palloc(sizeof(*new_head));
-	new_head->next = NULL;
-	/* new_head->data is left undefined! */
-
-	new_list = (PGList *) palloc(sizeof(*new_list));
-	new_list->type = type;
-	new_list->length = 1;
-	new_list->head = new_head;
-	new_list->tail = new_head;
-
-	return new_list;
-}
-
-/*
- * Allocate a new cell and make it the head of the specified
- * list. Assumes the list it is passed is non-NIL.
- *
- * The data in the new head cell is undefined; the caller should be
- * sure to fill it in
- */
-static void
-new_head_cell(PGList *list)
-{
-	PGListCell   *new_head;
-
-	new_head = (PGListCell *) palloc(sizeof(*new_head));
-	new_head->next = list->head;
-
-	list->head = new_head;
-	list->length++;
-}
-
-/*
- * Allocate a new cell and make it the tail of the specified
- * list. Assumes the list it is passed is non-NIL.
- *
- * The data in the new tail cell is undefined; the caller should be
- * sure to fill it in
- */
-static void
-new_tail_cell(PGList *list)
-{
-	PGListCell   *new_tail;
-
-	new_tail = (PGListCell *) palloc(sizeof(*new_tail));
-	new_tail->next = NULL;
-
-	list->tail->next = new_tail;
-	list->tail = new_tail;
-	list->length++;
-}
-
-/*
- * PGAppend a pointer to the list. A pointer to the modified list is
- * returned. Note that this function may or may not destructively
- * modify the list; callers should always use this function's return
- * value, rather than continuing to use the pointer passed as the
- * first argument.
- */
-PGList *
-lappend(PGList *list, void *datum)
-{
-	Assert(IsPointerList(list));
-
-	if (list == NIL)
-		list = new_list(T_PGList);
-	else
-		new_tail_cell(list);
-
-	lfirst(list->tail) = datum;
-	check_list_invariants(list);
-	return list;
-}
-
-/*
- * PGAppend an integer to the specified list. See lappend()
- */
-
-
-/*
- * PGAppend an OID to the specified list. See lappend()
- */
-
-
-/*
- * Add a new cell to the list, in the position after 'prev_cell'. The
- * data in the cell is left undefined, and must be filled in by the
- * caller. 'list' is assumed to be non-NIL, and 'prev_cell' is assumed
- * to be non-NULL and a member of 'list'.
- */
-
-
-/*
- * Add a new cell to the specified list (which must be non-NIL);
- * it will be placed after the list cell 'prev' (which must be
- * non-NULL and a member of 'list'). The data placed in the new cell
- * is 'datum'. The newly-constructed cell is returned.
- */
-
-
-
-
-
-
-/*
- * Prepend a new element to the list. A pointer to the modified list
- * is returned. Note that this function may or may not destructively
- * modify the list; callers should always use this function's return
- * value, rather than continuing to use the pointer passed as the
- * second argument.
- *
- * Caution: before Postgres 8.0, the original PGList was unmodified and
- * could be considered to retain its separate identity.  This is no longer
- * the case.
- */
-PGList *
-lcons(void *datum, PGList *list)
-{
-	Assert(IsPointerList(list));
-
-	if (list == NIL)
-		list = new_list(T_PGList);
-	else
-		new_head_cell(list);
-
-	lfirst(list->head) = datum;
-	check_list_invariants(list);
-	return list;
-}
-
-/*
- * Prepend an integer to the list. See lcons()
- */
-
-
-/*
- * Prepend an OID to the list. See lcons()
- */
-
-
-/*
- * Concatenate list2 to the end of list1, and return list1. list1 is
- * destructively changed. Callers should be sure to use the return
- * value as the new pointer to the concatenated list: the 'list1'
- * input pointer may or may not be the same as the returned pointer.
- *
- * The nodes in list2 are merely appended to the end of list1 in-place
- * (i.e. they aren't copied; the two lists will share some of the same
- * storage). Therefore, invoking list_free() on list2 will also
- * invalidate a portion of list1.
- */
-PGList *
-list_concat(PGList *list1, PGList *list2)
-{
-	if (list1 == NIL)
-		return list2;
-	if (list2 == NIL)
-		return list1;
-	if (list1 == list2)
-		elog(ERROR, "cannot list_concat() a list to itself");
-
-	Assert(list1->type == list2->type);
-
-	list1->length += list2->length;
-	list1->tail->next = list2->head;
-	list1->tail = list2->tail;
-
-	check_list_invariants(list1);
-	return list1;
-}
-
-/*
- * Truncate 'list' to contain no more than 'new_size' elements. This
- * modifies the list in-place! Despite this, callers should use the
- * pointer returned by this function to refer to the newly truncated
- * list -- it may or may not be the same as the pointer that was
- * passed.
- *
- * Note that any cells removed by list_truncate() are NOT pfree'd.
- */
-PGList *
-list_truncate(PGList *list, int new_size)
-{
-	PGListCell   *cell;
-	int			n;
-
-	if (new_size <= 0)
-		return NIL;				/* truncate to zero length */
-
-	/* If asked to effectively extend the list, do nothing */
-	if (new_size >= list_length(list))
-		return list;
-
-	n = 1;
-	foreach(cell, list)
-	{
-		if (n == new_size)
-		{
-			cell->next = NULL;
-			list->tail = cell;
-			list->length = new_size;
-			check_list_invariants(list);
-			return list;
-		}
-		n++;
-	}
-
-	/* keep the compiler quiet; never reached */
-	Assert(false);
-	return list;
-}
-
-/*
- * Locate the n'th cell (counting from 0) of the list.  It is an assertion
- * failure if there is no such cell.
- */
-PGListCell *
-list_nth_cell(const PGList *list, int n)
-{
-	PGListCell   *match;
-
-	Assert(list != NIL);
-	Assert(n >= 0);
-	Assert(n < list->length);
-	check_list_invariants(list);
-
-	/* Does the caller actually mean to fetch the tail? */
-	if (n == list->length - 1)
-		return list->tail;
-
-	for (match = list->head; n-- > 0; match = match->next)
-		;
-
-	return match;
-}
-
-/*
- * Return the data value contained in the n'th element of the
- * specified list. (PGList elements begin at 0.)
- */
-void *
-list_nth(const PGList *list, int n)
-{
-	Assert(IsPointerList(list));
-	return lfirst(list_nth_cell(list, n));
-}
-
-/*
- * Delete 'cell' from 'list'; 'prev' is the previous element to 'cell'
- * in 'list', if any (i.e. prev == NULL iff list->head == cell)
- *
- * The cell is pfree'd, as is the PGList header if this was the last member.
- */
-PGList *
-list_delete_cell(PGList *list, PGListCell *cell, PGListCell *prev)
-{
-	check_list_invariants(list);
-	Assert(prev != NULL ? lnext(prev) == cell : list_head(list) == cell);
-
-	/*
-	 * If we're about to delete the last node from the list, free the whole
-	 * list instead and return NIL, which is the only valid representation of
-	 * a zero-length list.
-	 */
-	if (list->length == 1)
-	{
-		list_free(list);
-		return NIL;
-	}
-
-	/*
-	 * Otherwise, adjust the necessary list links, deallocate the particular
-	 * node we have just removed, and return the list we were given.
-	 */
-	list->length--;
-
-	if (prev)
-		prev->next = cell->next;
-	else
-		list->head = cell->next;
-
-	if (list->tail == cell)
-		list->tail = prev;
-
-	pfree(cell);
-	return list;
-}
-
-/*
- * Free all storage in a list, and optionally the pointed-to elements
- */
-static void
-list_free_private(PGList *list, bool deep)
-{
-	PGListCell   *cell;
-
-	check_list_invariants(list);
-
-	cell = list_head(list);
-	while (cell != NULL)
-	{
-		PGListCell   *tmp = cell;
-
-		cell = lnext(cell);
-		if (deep)
-			pfree(lfirst(tmp));
-		pfree(tmp);
-	}
-
-	if (list)
-		pfree(list);
-}
-
-/*
- * Free all the cells of the list, as well as the list itself. Any
- * objects that are pointed-to by the cells of the list are NOT
- * free'd.
- *
- * On return, the argument to this function has been freed, so the
- * caller would be wise to set it to NIL for safety's sake.
- */
-void
-list_free(PGList *list)
-{
-	list_free_private(list, false);
-}
-
-/*
- * Free all the cells of the list, the list itself, and all the
- * objects pointed-to by the cells of the list (each element in the
- * list must contain a pointer to a palloc()'d region of memory!)
- *
- * On return, the argument to this function has been freed, so the
- * caller would be wise to set it to NIL for safety's sake.
- */
-
-
-/*
- * Return a shallow copy of the specified list.
- */
-PGList *
-list_copy(const PGList *oldlist)
-{
-	PGList	   *newlist;
-	PGListCell   *newlist_prev;
-	PGListCell   *oldlist_cur;
-
-	if (oldlist == NIL)
-		return NIL;
-
-	newlist = new_list(oldlist->type);
-	newlist->length = oldlist->length;
-
-	/*
-	 * Copy over the data in the first cell; new_list() has already allocated
-	 * the head cell itself
-	 */
-	newlist->head->data = oldlist->head->data;
-
-	newlist_prev = newlist->head;
-	oldlist_cur = oldlist->head->next;
-	while (oldlist_cur)
-	{
-		PGListCell   *newlist_cur;
-
-		newlist_cur = (PGListCell *) palloc(sizeof(*newlist_cur));
-		newlist_cur->data = oldlist_cur->data;
-		newlist_prev->next = newlist_cur;
-
-		newlist_prev = newlist_cur;
-		oldlist_cur = oldlist_cur->next;
-	}
-
-	newlist_prev->next = NULL;
-	newlist->tail = newlist_prev;
-
-	check_list_invariants(newlist);
-	return newlist;
-}
-
-/*
- * Return a shallow copy of the specified list, without the first N elements.
- */
-PGList *
-list_copy_tail(const PGList *oldlist, int nskip)
-{
-	PGList	   *newlist;
-	PGListCell   *newlist_prev;
-	PGListCell   *oldlist_cur;
-
-	if (nskip < 0)
-		nskip = 0;				/* would it be better to elog? */
-
-	if (oldlist == NIL || nskip >= oldlist->length)
-		return NIL;
-
-	newlist = new_list(oldlist->type);
-	newlist->length = oldlist->length - nskip;
-
-	/*
-	 * Skip over the unwanted elements.
-	 */
-	oldlist_cur = oldlist->head;
-	while (nskip-- > 0)
-		oldlist_cur = oldlist_cur->next;
-
-	/*
-	 * Copy over the data in the first remaining cell; new_list() has already
-	 * allocated the head cell itself
-	 */
-	newlist->head->data = oldlist_cur->data;
-
-	newlist_prev = newlist->head;
-	oldlist_cur = oldlist_cur->next;
-	while (oldlist_cur)
-	{
-		PGListCell   *newlist_cur;
-
-		newlist_cur = (PGListCell *) palloc(sizeof(*newlist_cur));
-		newlist_cur->data = oldlist_cur->data;
-		newlist_prev->next = newlist_cur;
-
-		newlist_prev = newlist_cur;
-		oldlist_cur = oldlist_cur->next;
-	}
-
-	newlist_prev->next = NULL;
-	newlist->tail = newlist_prev;
-
-	check_list_invariants(newlist);
-	return newlist;
-}
-
-/*
- * Temporary compatibility functions
- *
- * In order to avoid warnings for these function definitions, we need
- * to include a prototype here as well as in pg_list.h. That's because
- * we don't enable list API compatibility in list.c, so we
- * don't see the prototypes for these functions.
- */
-
-/*
- * Given a list, return its length. This is merely defined for the
- * sake of backward compatibility: we can't afford to define a macro
- * called "length", so it must be a function. New code should use the
- * list_length() macro in order to avoid the overhead of a function
- * call.
- */
-int			length(const PGList *list);
-
-
-}
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - makeDefElem
- * - makeTypeNameFromNameList
- * - makeDefElemExtended
- * - makeAlias
- * - makeSimpleAExpr
- * - makeGroupingSet
- * - makeTypeName
- * - makeFuncCall
- * - makeAExpr
- * - makeRangeVar
- * - makeBoolExpr
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * makefuncs.c
- *	  creator functions for primitive nodes. The functions here are for
- *	  the most frequently created nodes.
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/nodes/makefuncs.c
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * fmgr.h
- *	  Definitions for the Postgres function manager and function-call
- *	  interface.
- *
- * This file must be included by all Postgres modules that either define
- * or call fmgr-callable functions.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/fmgr.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-typedef struct PGFunctionCallInfoData *PGFunctionCallInfo;
-
-/* Standard parameter list for fmgr-compatible functions */
-#define PG_FUNCTION_ARGS	PGFunctionCallInfo fcinfo
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * makefuncs.h
- *	  prototypes for the creator functions (for primitive nodes)
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/makefuncs.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-namespace duckdb_libpgquery {
-
-PGAExpr *makeAExpr(PGAExpr_Kind kind, PGList *name, PGNode *lexpr, PGNode *rexpr, int location);
-
-PGAExpr *makeSimpleAExpr(PGAExpr_Kind kind, const char *name, PGNode *lexpr, PGNode *rexpr, int location);
-
-PGVar *makeVar(PGIndex varno, PGAttrNumber varattno, PGOid vartype, int32_t vartypmod, PGOid varcollid,
-               PGIndex varlevelsup);
-
-PGVar *makeVarFromTargetEntry(PGIndex varno, PGTargetEntry *tle);
-
-PGVar *makeWholeRowVar(PGRangeTblEntry *rte, PGIndex varno, PGIndex varlevelsup, bool allowScalar);
-
-PGTargetEntry *makeTargetEntry(PGExpr *expr, PGAttrNumber resno, char *resname, bool resjunk);
-
-PGTargetEntry *flatCopyTargetEntry(PGTargetEntry *src_tle);
-
-PGFromExpr *makeFromExpr(PGList *fromlist, PGNode *quals);
-
-PGConst *makeConst(PGOid consttype, int32_t consttypmod, PGOid constcollid, int constlen, PGDatum constvalue,
-                   bool constisnull, bool constbyval);
-
-PGConst *makeNullConst(PGOid consttype, int32_t consttypmod, PGOid constcollid);
-
-PGNode *makeBoolConst(bool value, bool isnull);
-
-PGExpr *makeBoolExpr(PGBoolExprType boolop, PGList *args, int location);
-
-PGAlias *makeAlias(const char *aliasname, PGList *colnames);
-
-PGRelabelType *makeRelabelType(PGExpr *arg, PGOid rtype, int32_t rtypmod, PGOid rcollid, PGCoercionForm rformat);
-
-PGRangeVar *makeRangeVar(char *schemaname, char *relname, int location);
-
-PGTypeName *makeTypeName(char *typnam);
-PGTypeName *makeTypeNameFromNameList(PGList *names);
-PGTypeName *makeTypeNameFromOid(PGOid typeOid, int32_t typmod);
-
-PGColumnDef *makeColumnDef(const char *colname, PGOid typeOid, int32_t typmod, PGOid collOid);
-
-PGFuncExpr *makeFuncExpr(PGOid funcid, PGOid rettype, PGList *args, PGOid funccollid, PGOid inputcollid,
-                         PGCoercionForm fformat);
-
-PGFuncCall *makeFuncCall(PGList *name, PGList *args, int location);
-
-PGDefElem *makeDefElem(const char *name, PGNode *arg, int location);
-PGDefElem *makeDefElemExtended(const char *nameSpace, const char *name, PGNode *arg, PGDefElemAction defaction,
-                               int location);
-
-PGGroupingSet *makeGroupingSet(GroupingSetKind kind, PGList *content, int location);
-
-}
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * nodeFuncs.h
- *		Various general-purpose manipulations of PGNode trees
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/nodeFuncs.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-namespace duckdb_libpgquery {
-
-/* flags bits for query_tree_walker and query_tree_mutator */
-#define QTW_IGNORE_RT_SUBQUERIES 0x01 /* subqueries in rtable */
-#define QTW_IGNORE_CTE_SUBQUERIES 0x02 /* subqueries in cteList */
-#define QTW_IGNORE_RC_SUBQUERIES 0x03 /* both of above */
-#define QTW_IGNORE_JOINALIASES 0x04 /* JOIN alias var lists */
-#define QTW_IGNORE_RANGE_TABLE 0x08 /* skip rangetable entirely */
-#define QTW_EXAMINE_RTES 0x10 /* examine RTEs */
-#define QTW_DONT_COPY_QUERY 0x20 /* do not copy top PGQuery */
-
-/* callback function for check_functions_in_node */
-typedef bool (*check_function_callback)(PGOid func_id, void *context);
-
-PGOid exprType(const PGNode *expr);
-int32_t exprTypmod(const PGNode *expr);
-bool exprIsLengthCoercion(const PGNode *expr, int32_t *coercedTypmod);
-PGNode *relabel_to_typmod(PGNode *expr, int32_t typmod);
-PGNode *strip_implicit_coercions(PGNode *node);
-bool expression_returns_set(PGNode *clause);
-
-PGOid exprCollation(const PGNode *expr);
-PGOid exprInputCollation(const PGNode *expr);
-void exprSetCollation(PGNode *expr, PGOid collation);
-void exprSetInputCollation(PGNode *expr, PGOid inputcollation);
-
-int exprLocation(const PGNode *expr);
-
-void fix_opfuncids(PGNode *node);
-void set_opfuncid(PGOpExpr *opexpr);
-void set_sa_opfuncid(PGScalarArrayOpExpr *opexpr);
-
-bool check_functions_in_node(PGNode *node, check_function_callback checker, void *context);
-
-bool expression_tree_walker(PGNode *node, bool (*walker)(), void *context);
-PGNode *expression_tree_mutator(PGNode *node, PGNode *(*mutator)(), void *context);
-
-bool query_tree_walker(PGQuery *query, bool (*walker)(), void *context, int flags);
-PGQuery *query_tree_mutator(PGQuery *query, PGNode *(*mutator)(), void *context, int flags);
-
-bool range_table_walker(PGList *rtable, bool (*walker)(), void *context, int flags);
-PGList *range_table_mutator(PGList *rtable, PGNode *(*mutator)(), void *context, int flags);
-
-bool query_or_expression_tree_walker(PGNode *node, bool (*walker)(), void *context, int flags);
-PGNode *query_or_expression_tree_mutator(PGNode *node, PGNode *(*mutator)(), void *context, int flags);
-
-bool raw_expression_tree_walker(PGNode *node, bool (*walker)(), void *context);
-
-struct PlanState;
-bool planstate_tree_walker(struct PlanState *planstate, bool (*walker)(), void *context);
-
-}
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_libpgquery {
-
-/*
- * makeAExpr -
- *		makes an PGAExpr node
- */
-PGAExpr *makeAExpr(PGAExpr_Kind kind, PGList *name, PGNode *lexpr, PGNode *rexpr, int location) {
-	PGAExpr *a = makeNode(PGAExpr);
-
-	a->kind = kind;
-	a->name = name;
-	a->lexpr = lexpr;
-	a->rexpr = rexpr;
-	a->location = location;
-	return a;
-}
-
-/*
- * makeSimpleAExpr -
- *		As above, given a simple (unqualified) operator name
- */
-PGAExpr *makeSimpleAExpr(PGAExpr_Kind kind, const char *name, PGNode *lexpr, PGNode *rexpr, int location) {
-	PGAExpr *a = makeNode(PGAExpr);
-
-	a->kind = kind;
-	a->name = list_make1(makeString((char *)name));
-	a->lexpr = lexpr;
-	a->rexpr = rexpr;
-	a->location = location;
-	return a;
-}
-
-/*
- * makeVar -
- *	  creates a PGVar node
- */
-
-/*
- * makeVarFromTargetEntry -
- *		convenience function to create a same-level PGVar node from a
- *		PGTargetEntry
- */
-
-/*
- * makeWholeRowVar -
- *	  creates a PGVar node representing a whole row of the specified RTE
- *
- * A whole-row reference is a PGVar with varno set to the correct range
- * table entry, and varattno == 0 to signal that it references the whole
- * tuple.  (Use of zero here is unclean, since it could easily be confused
- * with error cases, but it's not worth changing now.)  The vartype indicates
- * a rowtype; either a named composite type, or RECORD.  This function
- * encapsulates the logic for determining the correct rowtype OID to use.
- *
- * If allowScalar is true, then for the case where the RTE is a single function
- * returning a non-composite result type, we produce a normal PGVar referencing
- * the function's result directly, instead of the single-column composite
- * value that the whole-row notation might otherwise suggest.
- */
-
-/*
- * makeTargetEntry -
- *	  creates a PGTargetEntry node
- */
-
-/*
- * flatCopyTargetEntry -
- *	  duplicate a PGTargetEntry, but don't copy substructure
- *
- * This is commonly used when we just want to modify the resno or substitute
- * a new expression.
- */
-
-/*
- * makeFromExpr -
- *	  creates a PGFromExpr node
- */
-
-/*
- * makeConst -
- *	  creates a PGConst node
- */
-
-/*
- * makeNullConst -
- *	  creates a PGConst node representing a NULL of the specified type/typmod
- *
- * This is a convenience routine that just saves a lookup of the type's
- * storage properties.
- */
-
-/*
- * makeBoolConst -
- *	  creates a PGConst node representing a boolean value (can be NULL too)
- */
-
-/*
- * makeBoolExpr -
- *	  creates a PGBoolExpr node
- */
-PGExpr *makeBoolExpr(PGBoolExprType boolop, PGList *args, int location) {
-	PGBoolExpr *b = makeNode(PGBoolExpr);
-
-	b->boolop = boolop;
-	b->args = args;
-	b->location = location;
-
-	return (PGExpr *)b;
-}
-
-/*
- * makeAlias -
- *	  creates an PGAlias node
- *
- * NOTE: the given name is copied, but the colnames list (if any) isn't.
- */
-PGAlias *makeAlias(const char *aliasname, PGList *colnames) {
-	PGAlias *a = makeNode(PGAlias);
-
-	a->aliasname = pstrdup(aliasname);
-	a->colnames = colnames;
-
-	return a;
-}
-
-/*
- * makeRelabelType -
- *	  creates a PGRelabelType node
- */
-
-/*
- * makeRangeVar -
- *	  creates a PGRangeVar node (rather oversimplified case)
- */
-PGRangeVar *makeRangeVar(char *schemaname, char *relname, int location) {
-	PGRangeVar *r = makeNode(PGRangeVar);
-
-	r->catalogname = NULL;
-	r->schemaname = schemaname;
-	r->relname = relname;
-	r->inh = true;
-	r->relpersistence = RELPERSISTENCE_PERMANENT;
-	r->alias = NULL;
-	r->location = location;
-	r->sample = NULL;
-
-	return r;
-}
-
-/*
- * makeTypeName -
- *	build a PGTypeName node for an unqualified name.
- *
- * typmod is defaulted, but can be changed later by caller.
- */
-PGTypeName *makeTypeName(char *typnam) {
-	return makeTypeNameFromNameList(list_make1(makeString(typnam)));
-}
-
-/*
- * makeTypeNameFromNameList -
- *	build a PGTypeName node for a String list representing a qualified name.
- *
- * typmod is defaulted, but can be changed later by caller.
- */
-PGTypeName *makeTypeNameFromNameList(PGList *names) {
-	PGTypeName *n = makeNode(PGTypeName);
-
-	n->names = names;
-	n->typmods = NIL;
-	n->typemod = -1;
-	n->location = -1;
-	return n;
-}
-
-/*
- * makeTypeNameFromOid -
- *	build a PGTypeName node to represent a type already known by OID/typmod.
- */
-
-/*
- * makeColumnDef -
- *	build a PGColumnDef node to represent a simple column definition.
- *
- * Type and collation are specified by OID.
- * Other properties are all basic to start with.
- */
-
-/*
- * makeFuncExpr -
- *	build an expression tree representing a function call.
- *
- * The argument expressions must have been transformed already.
- */
-
-/*
- * makeDefElem -
- *	build a PGDefElem node
- *
- * This is sufficient for the "typical" case with an unqualified option name
- * and no special action.
- */
-PGDefElem *makeDefElem(const char *name, PGNode *arg, int location) {
-	PGDefElem *res = makeNode(PGDefElem);
-
-	res->defnamespace = NULL;
-	res->defname = (char *)name;
-	res->arg = arg;
-	res->defaction = PG_DEFELEM_UNSPEC;
-	res->location = location;
-
-	return res;
-}
-
-/*
- * makeDefElemExtended -
- *	build a PGDefElem node with all fields available to be specified
- */
-PGDefElem *makeDefElemExtended(const char *nameSpace, const char *name, PGNode *arg, PGDefElemAction defaction,
-                               int location) {
-	PGDefElem *res = makeNode(PGDefElem);
-
-	res->defnamespace = (char *)nameSpace;
-	res->defname = (char *)name;
-	res->arg = arg;
-	res->defaction = defaction;
-	res->location = location;
-
-	return res;
-}
-
-/*
- * makeFuncCall -
- *
- * Initialize a PGFuncCall struct with the information every caller must
- * supply.  Any non-default parameters have to be inserted by the caller.
- */
-PGFuncCall *makeFuncCall(PGList *name, PGList *args, int location) {
-	PGFuncCall *n = makeNode(PGFuncCall);
-
-	n->funcname = name;
-	n->args = args;
-	n->agg_order = NIL;
-	n->agg_filter = NULL;
-	n->agg_within_group = false;
-	n->agg_star = false;
-	n->agg_distinct = false;
-	n->func_variadic = false;
-	n->over = NULL;
-	n->location = location;
-	return n;
-}
-
-/*
- * makeGroupingSet
- *
- */
-PGGroupingSet *makeGroupingSet(GroupingSetKind kind, PGList *content, int location) {
-	PGGroupingSet *n = makeNode(PGGroupingSet);
-
-	n->kind = kind;
-	n->content = content;
-	n->location = location;
-	return n;
-}
-}
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - makeInteger
- * - makeString
- * - makeFloat
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * value.c
- *	  implementation of PGValue nodes
- *
- *
- * Copyright (c) 2003-2017, PostgreSQL Global Development PGGroup
- *
- *
- * IDENTIFICATION
- *	  src/backend/nodes/value.c
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-#include <string>
-#include <cstring>
-
-namespace duckdb_libpgquery {
-
-/*
- *	makeInteger
- */
-PGValue *makeInteger(long i) {
-	PGValue *v = makeNode(PGValue);
-
-	v->type = T_PGInteger;
-	v->val.ival = i;
-	return v;
-}
-
-/*
- *	makeFloat
- *
- * Caller is responsible for passing a palloc'd string.
- */
-PGValue *makeFloat(char *numericStr) {
-	PGValue *v = makeNode(PGValue);
-
-	v->type = T_PGFloat;
-	v->val.str = numericStr;
-	return v;
-}
-
-/*
- *	makeString
- *
- * Caller is responsible for passing a palloc'd string.
- */
-PGValue *makeString(const char *str) {
-	PGValue *v = makeNode(PGValue);
-
-	v->type = T_PGString;
-	v->val.str = (char *)str;
-	return v;
-}
-
-/*
- *	makeBitString
- *
- * Caller is responsible for passing a palloc'd string.
- */
-
-}
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/* A Bison parser, made by GNU Bison 2.3.  */
-
-/* Skeleton implementation for Bison's Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
-   simplifying the original so-called "semantic" parser.  */
-
-/* All symbols defined below should begin with yy or YY, to avoid
-   infringing on user name space.  This should be done even for local
-   variables, as they might otherwise be expanded by user macros.
-   There are some unavoidable exceptions within include files to
-   define necessary library symbols; they are noted "INFRINGES ON
-   USER NAME SPACE" below.  */
-
-/* Identify Bison output.  */
-#define YYBISON 1
-
-/* Bison version.  */
-#define YYBISON_VERSION "2.3"
-
-/* Skeleton name.  */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers.  */
-#define YYPURE 1
-
-/* Using locations.  */
-#define YYLSP_NEEDED 1
-
-/* Substitute the variable and function names.  */
-#define yyparse base_yyparse
-#define yylex   base_yylex
-#define yyerror base_yyerror
-#define yylval  base_yylval
-#define yychar  base_yychar
-#define yydebug base_yydebug
-#define yynerrs base_yynerrs
-#define yylloc base_yylloc
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     IDENT = 258,
-     FCONST = 259,
-     SCONST = 260,
-     BCONST = 261,
-     XCONST = 262,
-     Op = 263,
-     ICONST = 264,
-     PARAM = 265,
-     TYPECAST = 266,
-     DOT_DOT = 267,
-     COLON_EQUALS = 268,
-     EQUALS_GREATER = 269,
-     LAMBDA_ARROW = 270,
-     POWER_OF = 271,
-     LESS_EQUALS = 272,
-     GREATER_EQUALS = 273,
-     NOT_EQUALS = 274,
-     ABORT_P = 275,
-     ABSOLUTE_P = 276,
-     ACCESS = 277,
-     ACTION = 278,
-     ADD_P = 279,
-     ADMIN = 280,
-     AFTER = 281,
-     AGGREGATE = 282,
-     ALL = 283,
-     ALSO = 284,
-     ALTER = 285,
-     ALWAYS = 286,
-     ANALYSE = 287,
-     ANALYZE = 288,
-     AND = 289,
-     ANY = 290,
-     ARRAY = 291,
-     AS = 292,
-     ASC_P = 293,
-     ASSERTION = 294,
-     ASSIGNMENT = 295,
-     ASYMMETRIC = 296,
-     AT = 297,
-     ATTACH = 298,
-     ATTRIBUTE = 299,
-     AUTHORIZATION = 300,
-     BACKWARD = 301,
-     BEFORE = 302,
-     BEGIN_P = 303,
-     BETWEEN = 304,
-     BIGINT = 305,
-     BINARY = 306,
-     BIT = 307,
-     BOOLEAN_P = 308,
-     BOTH = 309,
-     BY = 310,
-     CACHE = 311,
-     CALL_P = 312,
-     CALLED = 313,
-     CASCADE = 314,
-     CASCADED = 315,
-     CASE = 316,
-     CAST = 317,
-     CATALOG_P = 318,
-     CHAIN = 319,
-     CHAR_P = 320,
-     CHARACTER = 321,
-     CHARACTERISTICS = 322,
-     CHECK_P = 323,
-     CHECKPOINT = 324,
-     CLASS = 325,
-     CLOSE = 326,
-     CLUSTER = 327,
-     COALESCE = 328,
-     COLLATE = 329,
-     COLLATION = 330,
-     COLUMN = 331,
-     COLUMNS = 332,
-     COMMENT = 333,
-     COMMENTS = 334,
-     COMMIT = 335,
-     COMMITTED = 336,
-     COMPRESSION = 337,
-     CONCURRENTLY = 338,
-     CONFIGURATION = 339,
-     CONFLICT = 340,
-     CONNECTION = 341,
-     CONSTRAINT = 342,
-     CONSTRAINTS = 343,
-     CONTENT_P = 344,
-     CONTINUE_P = 345,
-     CONVERSION_P = 346,
-     COPY = 347,
-     COST = 348,
-     CREATE_P = 349,
-     CROSS = 350,
-     CSV = 351,
-     CUBE = 352,
-     CURRENT_P = 353,
-     CURRENT_CATALOG = 354,
-     CURRENT_DATE = 355,
-     CURRENT_ROLE = 356,
-     CURRENT_SCHEMA = 357,
-     CURRENT_TIME = 358,
-     CURRENT_TIMESTAMP = 359,
-     CURRENT_USER = 360,
-     CURSOR = 361,
-     CYCLE = 362,
-     DATA_P = 363,
-     DATABASE = 364,
-     DAY_P = 365,
-     DAYS_P = 366,
-     DEALLOCATE = 367,
-     DEC = 368,
-     DECIMAL_P = 369,
-     DECLARE = 370,
-     DEFAULT = 371,
-     DEFAULTS = 372,
-     DEFERRABLE = 373,
-     DEFERRED = 374,
-     DEFINER = 375,
-     DELETE_P = 376,
-     DELIMITER = 377,
-     DELIMITERS = 378,
-     DEPENDS = 379,
-     DESC_P = 380,
-     DESCRIBE = 381,
-     DETACH = 382,
-     DICTIONARY = 383,
-     DISABLE_P = 384,
-     DISCARD = 385,
-     DISTINCT = 386,
-     DO = 387,
-     DOCUMENT_P = 388,
-     DOMAIN_P = 389,
-     DOUBLE_P = 390,
-     DROP = 391,
-     EACH = 392,
-     ELSE = 393,
-     ENABLE_P = 394,
-     ENCODING = 395,
-     ENCRYPTED = 396,
-     END_P = 397,
-     ENUM_P = 398,
-     ESCAPE = 399,
-     EVENT = 400,
-     EXCEPT = 401,
-     EXCLUDE = 402,
-     EXCLUDING = 403,
-     EXCLUSIVE = 404,
-     EXECUTE = 405,
-     EXISTS = 406,
-     EXPLAIN = 407,
-     EXPORT_P = 408,
-     EXPORT_STATE = 409,
-     EXTENSION = 410,
-     EXTERNAL = 411,
-     EXTRACT = 412,
-     FALSE_P = 413,
-     FAMILY = 414,
-     FETCH = 415,
-     FILTER = 416,
-     FIRST_P = 417,
-     FLOAT_P = 418,
-     FOLLOWING = 419,
-     FOR = 420,
-     FORCE = 421,
-     FOREIGN = 422,
-     FORWARD = 423,
-     FREEZE = 424,
-     FROM = 425,
-     FULL = 426,
-     FUNCTION = 427,
-     FUNCTIONS = 428,
-     GENERATED = 429,
-     GLOB = 430,
-     GLOBAL = 431,
-     GRANT = 432,
-     GRANTED = 433,
-     GROUP_P = 434,
-     GROUPING = 435,
-     GROUPING_ID = 436,
-     HANDLER = 437,
-     HAVING = 438,
-     HEADER_P = 439,
-     HOLD = 440,
-     HOUR_P = 441,
-     HOURS_P = 442,
-     IDENTITY_P = 443,
-     IF_P = 444,
-     IGNORE_P = 445,
-     ILIKE = 446,
-     IMMEDIATE = 447,
-     IMMUTABLE = 448,
-     IMPLICIT_P = 449,
-     IMPORT_P = 450,
-     IN_P = 451,
-     INCLUDING = 452,
-     INCREMENT = 453,
-     INDEX = 454,
-     INDEXES = 455,
-     INHERIT = 456,
-     INHERITS = 457,
-     INITIALLY = 458,
-     INLINE_P = 459,
-     INNER_P = 460,
-     INOUT = 461,
-     INPUT_P = 462,
-     INSENSITIVE = 463,
-     INSERT = 464,
-     INSTALL = 465,
-     INSTEAD = 466,
-     INT_P = 467,
-     INTEGER = 468,
-     INTERSECT = 469,
-     INTERVAL = 470,
-     INTO = 471,
-     INVOKER = 472,
-     IS = 473,
-     ISNULL = 474,
-     ISOLATION = 475,
-     JOIN = 476,
-     JSON = 477,
-     KEY = 478,
-     LABEL = 479,
-     LANGUAGE = 480,
-     LARGE_P = 481,
-     LAST_P = 482,
-     LATERAL_P = 483,
-     LEADING = 484,
-     LEAKPROOF = 485,
-     LEFT = 486,
-     LEVEL = 487,
-     LIKE = 488,
-     LIMIT = 489,
-     LISTEN = 490,
-     LOAD = 491,
-     LOCAL = 492,
-     LOCALTIME = 493,
-     LOCALTIMESTAMP = 494,
-     LOCATION = 495,
-     LOCK_P = 496,
-     LOCKED = 497,
-     LOGGED = 498,
-     MACRO = 499,
-     MAP = 500,
-     MAPPING = 501,
-     MATCH = 502,
-     MATERIALIZED = 503,
-     MAXVALUE = 504,
-     METHOD = 505,
-     MICROSECOND_P = 506,
-     MICROSECONDS_P = 507,
-     MILLISECOND_P = 508,
-     MILLISECONDS_P = 509,
-     MINUTE_P = 510,
-     MINUTES_P = 511,
-     MINVALUE = 512,
-     MODE = 513,
-     MONTH_P = 514,
-     MONTHS_P = 515,
-     MOVE = 516,
-     NAME_P = 517,
-     NAMES = 518,
-     NATIONAL = 519,
-     NATURAL = 520,
-     NCHAR = 521,
-     NEW = 522,
-     NEXT = 523,
-     NO = 524,
-     NONE = 525,
-     NOT = 526,
-     NOTHING = 527,
-     NOTIFY = 528,
-     NOTNULL = 529,
-     NOWAIT = 530,
-     NULL_P = 531,
-     NULLIF = 532,
-     NULLS_P = 533,
-     NUMERIC = 534,
-     OBJECT_P = 535,
-     OF = 536,
-     OFF = 537,
-     OFFSET = 538,
-     OIDS = 539,
-     OLD = 540,
-     ON = 541,
-     ONLY = 542,
-     OPERATOR = 543,
-     OPTION = 544,
-     OPTIONS = 545,
-     OR = 546,
-     ORDER = 547,
-     ORDINALITY = 548,
-     OUT_P = 549,
-     OUTER_P = 550,
-     OVER = 551,
-     OVERLAPS = 552,
-     OVERLAY = 553,
-     OVERRIDING = 554,
-     OWNED = 555,
-     OWNER = 556,
-     PARALLEL = 557,
-     PARSER = 558,
-     PARTIAL = 559,
-     PARTITION = 560,
-     PASSING = 561,
-     PASSWORD = 562,
-     PERCENT = 563,
-     PLACING = 564,
-     PLANS = 565,
-     POLICY = 566,
-     POSITION = 567,
-     PRAGMA_P = 568,
-     PRECEDING = 569,
-     PRECISION = 570,
-     PREPARE = 571,
-     PREPARED = 572,
-     PRESERVE = 573,
-     PRIMARY = 574,
-     PRIOR = 575,
-     PRIVILEGES = 576,
-     PROCEDURAL = 577,
-     PROCEDURE = 578,
-     PROGRAM = 579,
-     PUBLICATION = 580,
-     QUALIFY = 581,
-     QUOTE = 582,
-     RANGE = 583,
-     READ_P = 584,
-     REAL = 585,
-     REASSIGN = 586,
-     RECHECK = 587,
-     RECURSIVE = 588,
-     REF = 589,
-     REFERENCES = 590,
-     REFERENCING = 591,
-     REFRESH = 592,
-     REINDEX = 593,
-     RELATIVE_P = 594,
-     RELEASE = 595,
-     RENAME = 596,
-     REPEATABLE = 597,
-     REPLACE = 598,
-     REPLICA = 599,
-     RESET = 600,
-     RESPECT_P = 601,
-     RESTART = 602,
-     RESTRICT = 603,
-     RETURNING = 604,
-     RETURNS = 605,
-     REVOKE = 606,
-     RIGHT = 607,
-     ROLE = 608,
-     ROLLBACK = 609,
-     ROLLUP = 610,
-     ROW = 611,
-     ROWS = 612,
-     RULE = 613,
-     SAMPLE = 614,
-     SAVEPOINT = 615,
-     SCHEMA = 616,
-     SCHEMAS = 617,
-     SCROLL = 618,
-     SEARCH = 619,
-     SECOND_P = 620,
-     SECONDS_P = 621,
-     SECURITY = 622,
-     SELECT = 623,
-     SEQUENCE = 624,
-     SEQUENCES = 625,
-     SERIALIZABLE = 626,
-     SERVER = 627,
-     SESSION = 628,
-     SESSION_USER = 629,
-     SET = 630,
-     SETOF = 631,
-     SETS = 632,
-     SHARE = 633,
-     SHOW = 634,
-     SIMILAR = 635,
-     SIMPLE = 636,
-     SKIP = 637,
-     SMALLINT = 638,
-     SNAPSHOT = 639,
-     SOME = 640,
-     SQL_P = 641,
-     STABLE = 642,
-     STANDALONE_P = 643,
-     START = 644,
-     STATEMENT = 645,
-     STATISTICS = 646,
-     STDIN = 647,
-     STDOUT = 648,
-     STORAGE = 649,
-     STORED = 650,
-     STRICT_P = 651,
-     STRIP_P = 652,
-     STRUCT = 653,
-     SUBSCRIPTION = 654,
-     SUBSTRING = 655,
-     SUMMARIZE = 656,
-     SYMMETRIC = 657,
-     SYSID = 658,
-     SYSTEM_P = 659,
-     TABLE = 660,
-     TABLES = 661,
-     TABLESAMPLE = 662,
-     TABLESPACE = 663,
-     TEMP = 664,
-     TEMPLATE = 665,
-     TEMPORARY = 666,
-     TEXT_P = 667,
-     THEN = 668,
-     TIME = 669,
-     TIMESTAMP = 670,
-     TO = 671,
-     TRAILING = 672,
-     TRANSACTION = 673,
-     TRANSFORM = 674,
-     TREAT = 675,
-     TRIGGER = 676,
-     TRIM = 677,
-     TRUE_P = 678,
-     TRUNCATE = 679,
-     TRUSTED = 680,
-     TRY_CAST = 681,
-     TYPE_P = 682,
-     TYPES_P = 683,
-     UNBOUNDED = 684,
-     UNCOMMITTED = 685,
-     UNENCRYPTED = 686,
-     UNION = 687,
-     UNIQUE = 688,
-     UNKNOWN = 689,
-     UNLISTEN = 690,
-     UNLOGGED = 691,
-     UNTIL = 692,
-     UPDATE = 693,
-     USER = 694,
-     USING = 695,
-     VACUUM = 696,
-     VALID = 697,
-     VALIDATE = 698,
-     VALIDATOR = 699,
-     VALUE_P = 700,
-     VALUES = 701,
-     VARCHAR = 702,
-     VARIADIC = 703,
-     VARYING = 704,
-     VERBOSE = 705,
-     VERSION_P = 706,
-     VIEW = 707,
-     VIEWS = 708,
-     VIRTUAL = 709,
-     VOLATILE = 710,
-     WHEN = 711,
-     WHERE = 712,
-     WHITESPACE_P = 713,
-     WINDOW = 714,
-     WITH = 715,
-     WITHIN = 716,
-     WITHOUT = 717,
-     WORK = 718,
-     WRAPPER = 719,
-     WRITE_P = 720,
-     XML_P = 721,
-     XMLATTRIBUTES = 722,
-     XMLCONCAT = 723,
-     XMLELEMENT = 724,
-     XMLEXISTS = 725,
-     XMLFOREST = 726,
-     XMLNAMESPACES = 727,
-     XMLPARSE = 728,
-     XMLPI = 729,
-     XMLROOT = 730,
-     XMLSERIALIZE = 731,
-     XMLTABLE = 732,
-     YEAR_P = 733,
-     YEARS_P = 734,
-     YES_P = 735,
-     ZONE = 736,
-     NOT_LA = 737,
-     NULLS_LA = 738,
-     WITH_LA = 739,
-     POSTFIXOP = 740,
-     UMINUS = 741
-   };
-#endif
-/* Tokens.  */
-#define IDENT 258
-#define FCONST 259
-#define SCONST 260
-#define BCONST 261
-#define XCONST 262
-#define Op 263
-#define ICONST 264
-#define PARAM 265
-#define TYPECAST 266
-#define DOT_DOT 267
-#define COLON_EQUALS 268
-#define EQUALS_GREATER 269
-#define LAMBDA_ARROW 270
-#define POWER_OF 271
-#define LESS_EQUALS 272
-#define GREATER_EQUALS 273
-#define NOT_EQUALS 274
-#define ABORT_P 275
-#define ABSOLUTE_P 276
-#define ACCESS 277
-#define ACTION 278
-#define ADD_P 279
-#define ADMIN 280
-#define AFTER 281
-#define AGGREGATE 282
-#define ALL 283
-#define ALSO 284
-#define ALTER 285
-#define ALWAYS 286
-#define ANALYSE 287
-#define ANALYZE 288
-#define AND 289
-#define ANY 290
-#define ARRAY 291
-#define AS 292
-#define ASC_P 293
-#define ASSERTION 294
-#define ASSIGNMENT 295
-#define ASYMMETRIC 296
-#define AT 297
-#define ATTACH 298
-#define ATTRIBUTE 299
-#define AUTHORIZATION 300
-#define BACKWARD 301
-#define BEFORE 302
-#define BEGIN_P 303
-#define BETWEEN 304
-#define BIGINT 305
-#define BINARY 306
-#define BIT 307
-#define BOOLEAN_P 308
-#define BOTH 309
-#define BY 310
-#define CACHE 311
-#define CALL_P 312
-#define CALLED 313
-#define CASCADE 314
-#define CASCADED 315
-#define CASE 316
-#define CAST 317
-#define CATALOG_P 318
-#define CHAIN 319
-#define CHAR_P 320
-#define CHARACTER 321
-#define CHARACTERISTICS 322
-#define CHECK_P 323
-#define CHECKPOINT 324
-#define CLASS 325
-#define CLOSE 326
-#define CLUSTER 327
-#define COALESCE 328
-#define COLLATE 329
-#define COLLATION 330
-#define COLUMN 331
-#define COLUMNS 332
-#define COMMENT 333
-#define COMMENTS 334
-#define COMMIT 335
-#define COMMITTED 336
-#define COMPRESSION 337
-#define CONCURRENTLY 338
-#define CONFIGURATION 339
-#define CONFLICT 340
-#define CONNECTION 341
-#define CONSTRAINT 342
-#define CONSTRAINTS 343
-#define CONTENT_P 344
-#define CONTINUE_P 345
-#define CONVERSION_P 346
-#define COPY 347
-#define COST 348
-#define CREATE_P 349
-#define CROSS 350
-#define CSV 351
-#define CUBE 352
-#define CURRENT_P 353
-#define CURRENT_CATALOG 354
-#define CURRENT_DATE 355
-#define CURRENT_ROLE 356
-#define CURRENT_SCHEMA 357
-#define CURRENT_TIME 358
-#define CURRENT_TIMESTAMP 359
-#define CURRENT_USER 360
-#define CURSOR 361
-#define CYCLE 362
-#define DATA_P 363
-#define DATABASE 364
-#define DAY_P 365
-#define DAYS_P 366
-#define DEALLOCATE 367
-#define DEC 368
-#define DECIMAL_P 369
-#define DECLARE 370
-#define DEFAULT 371
-#define DEFAULTS 372
-#define DEFERRABLE 373
-#define DEFERRED 374
-#define DEFINER 375
-#define DELETE_P 376
-#define DELIMITER 377
-#define DELIMITERS 378
-#define DEPENDS 379
-#define DESC_P 380
-#define DESCRIBE 381
-#define DETACH 382
-#define DICTIONARY 383
-#define DISABLE_P 384
-#define DISCARD 385
-#define DISTINCT 386
-#define DO 387
-#define DOCUMENT_P 388
-#define DOMAIN_P 389
-#define DOUBLE_P 390
-#define DROP 391
-#define EACH 392
-#define ELSE 393
-#define ENABLE_P 394
-#define ENCODING 395
-#define ENCRYPTED 396
-#define END_P 397
-#define ENUM_P 398
-#define ESCAPE 399
-#define EVENT 400
-#define EXCEPT 401
-#define EXCLUDE 402
-#define EXCLUDING 403
-#define EXCLUSIVE 404
-#define EXECUTE 405
-#define EXISTS 406
-#define EXPLAIN 407
-#define EXPORT_P 408
-#define EXPORT_STATE 409
-#define EXTENSION 410
-#define EXTERNAL 411
-#define EXTRACT 412
-#define FALSE_P 413
-#define FAMILY 414
-#define FETCH 415
-#define FILTER 416
-#define FIRST_P 417
-#define FLOAT_P 418
-#define FOLLOWING 419
-#define FOR 420
-#define FORCE 421
-#define FOREIGN 422
-#define FORWARD 423
-#define FREEZE 424
-#define FROM 425
-#define FULL 426
-#define FUNCTION 427
-#define FUNCTIONS 428
-#define GENERATED 429
-#define GLOB 430
-#define GLOBAL 431
-#define GRANT 432
-#define GRANTED 433
-#define GROUP_P 434
-#define GROUPING 435
-#define GROUPING_ID 436
-#define HANDLER 437
-#define HAVING 438
-#define HEADER_P 439
-#define HOLD 440
-#define HOUR_P 441
-#define HOURS_P 442
-#define IDENTITY_P 443
-#define IF_P 444
-#define IGNORE_P 445
-#define ILIKE 446
-#define IMMEDIATE 447
-#define IMMUTABLE 448
-#define IMPLICIT_P 449
-#define IMPORT_P 450
-#define IN_P 451
-#define INCLUDING 452
-#define INCREMENT 453
-#define INDEX 454
-#define INDEXES 455
-#define INHERIT 456
-#define INHERITS 457
-#define INITIALLY 458
-#define INLINE_P 459
-#define INNER_P 460
-#define INOUT 461
-#define INPUT_P 462
-#define INSENSITIVE 463
-#define INSERT 464
-#define INSTALL 465
-#define INSTEAD 466
-#define INT_P 467
-#define INTEGER 468
-#define INTERSECT 469
-#define INTERVAL 470
-#define INTO 471
-#define INVOKER 472
-#define IS 473
-#define ISNULL 474
-#define ISOLATION 475
-#define JOIN 476
-#define JSON 477
-#define KEY 478
-#define LABEL 479
-#define LANGUAGE 480
-#define LARGE_P 481
-#define LAST_P 482
-#define LATERAL_P 483
-#define LEADING 484
-#define LEAKPROOF 485
-#define LEFT 486
-#define LEVEL 487
-#define LIKE 488
-#define LIMIT 489
-#define LISTEN 490
-#define LOAD 491
-#define LOCAL 492
-#define LOCALTIME 493
-#define LOCALTIMESTAMP 494
-#define LOCATION 495
-#define LOCK_P 496
-#define LOCKED 497
-#define LOGGED 498
-#define MACRO 499
-#define MAP 500
-#define MAPPING 501
-#define MATCH 502
-#define MATERIALIZED 503
-#define MAXVALUE 504
-#define METHOD 505
-#define MICROSECOND_P 506
-#define MICROSECONDS_P 507
-#define MILLISECOND_P 508
-#define MILLISECONDS_P 509
-#define MINUTE_P 510
-#define MINUTES_P 511
-#define MINVALUE 512
-#define MODE 513
-#define MONTH_P 514
-#define MONTHS_P 515
-#define MOVE 516
-#define NAME_P 517
-#define NAMES 518
-#define NATIONAL 519
-#define NATURAL 520
-#define NCHAR 521
-#define NEW 522
-#define NEXT 523
-#define NO 524
-#define NONE 525
-#define NOT 526
-#define NOTHING 527
-#define NOTIFY 528
-#define NOTNULL 529
-#define NOWAIT 530
-#define NULL_P 531
-#define NULLIF 532
-#define NULLS_P 533
-#define NUMERIC 534
-#define OBJECT_P 535
-#define OF 536
-#define OFF 537
-#define OFFSET 538
-#define OIDS 539
-#define OLD 540
-#define ON 541
-#define ONLY 542
-#define OPERATOR 543
-#define OPTION 544
-#define OPTIONS 545
-#define OR 546
-#define ORDER 547
-#define ORDINALITY 548
-#define OUT_P 549
-#define OUTER_P 550
-#define OVER 551
-#define OVERLAPS 552
-#define OVERLAY 553
-#define OVERRIDING 554
-#define OWNED 555
-#define OWNER 556
-#define PARALLEL 557
-#define PARSER 558
-#define PARTIAL 559
-#define PARTITION 560
-#define PASSING 561
-#define PASSWORD 562
-#define PERCENT 563
-#define PLACING 564
-#define PLANS 565
-#define POLICY 566
-#define POSITION 567
-#define PRAGMA_P 568
-#define PRECEDING 569
-#define PRECISION 570
-#define PREPARE 571
-#define PREPARED 572
-#define PRESERVE 573
-#define PRIMARY 574
-#define PRIOR 575
-#define PRIVILEGES 576
-#define PROCEDURAL 577
-#define PROCEDURE 578
-#define PROGRAM 579
-#define PUBLICATION 580
-#define QUALIFY 581
-#define QUOTE 582
-#define RANGE 583
-#define READ_P 584
-#define REAL 585
-#define REASSIGN 586
-#define RECHECK 587
-#define RECURSIVE 588
-#define REF 589
-#define REFERENCES 590
-#define REFERENCING 591
-#define REFRESH 592
-#define REINDEX 593
-#define RELATIVE_P 594
-#define RELEASE 595
-#define RENAME 596
-#define REPEATABLE 597
-#define REPLACE 598
-#define REPLICA 599
-#define RESET 600
-#define RESPECT_P 601
-#define RESTART 602
-#define RESTRICT 603
-#define RETURNING 604
-#define RETURNS 605
-#define REVOKE 606
-#define RIGHT 607
-#define ROLE 608
-#define ROLLBACK 609
-#define ROLLUP 610
-#define ROW 611
-#define ROWS 612
-#define RULE 613
-#define SAMPLE 614
-#define SAVEPOINT 615
-#define SCHEMA 616
-#define SCHEMAS 617
-#define SCROLL 618
-#define SEARCH 619
-#define SECOND_P 620
-#define SECONDS_P 621
-#define SECURITY 622
-#define SELECT 623
-#define SEQUENCE 624
-#define SEQUENCES 625
-#define SERIALIZABLE 626
-#define SERVER 627
-#define SESSION 628
-#define SESSION_USER 629
-#define SET 630
-#define SETOF 631
-#define SETS 632
-#define SHARE 633
-#define SHOW 634
-#define SIMILAR 635
-#define SIMPLE 636
-#define SKIP 637
-#define SMALLINT 638
-#define SNAPSHOT 639
-#define SOME 640
-#define SQL_P 641
-#define STABLE 642
-#define STANDALONE_P 643
-#define START 644
-#define STATEMENT 645
-#define STATISTICS 646
-#define STDIN 647
-#define STDOUT 648
-#define STORAGE 649
-#define STORED 650
-#define STRICT_P 651
-#define STRIP_P 652
-#define STRUCT 653
-#define SUBSCRIPTION 654
-#define SUBSTRING 655
-#define SUMMARIZE 656
-#define SYMMETRIC 657
-#define SYSID 658
-#define SYSTEM_P 659
-#define TABLE 660
-#define TABLES 661
-#define TABLESAMPLE 662
-#define TABLESPACE 663
-#define TEMP 664
-#define TEMPLATE 665
-#define TEMPORARY 666
-#define TEXT_P 667
-#define THEN 668
-#define TIME 669
-#define TIMESTAMP 670
-#define TO 671
-#define TRAILING 672
-#define TRANSACTION 673
-#define TRANSFORM 674
-#define TREAT 675
-#define TRIGGER 676
-#define TRIM 677
-#define TRUE_P 678
-#define TRUNCATE 679
-#define TRUSTED 680
-#define TRY_CAST 681
-#define TYPE_P 682
-#define TYPES_P 683
-#define UNBOUNDED 684
-#define UNCOMMITTED 685
-#define UNENCRYPTED 686
-#define UNION 687
-#define UNIQUE 688
-#define UNKNOWN 689
-#define UNLISTEN 690
-#define UNLOGGED 691
-#define UNTIL 692
-#define UPDATE 693
-#define USER 694
-#define USING 695
-#define VACUUM 696
-#define VALID 697
-#define VALIDATE 698
-#define VALIDATOR 699
-#define VALUE_P 700
-#define VALUES 701
-#define VARCHAR 702
-#define VARIADIC 703
-#define VARYING 704
-#define VERBOSE 705
-#define VERSION_P 706
-#define VIEW 707
-#define VIEWS 708
-#define VIRTUAL 709
-#define VOLATILE 710
-#define WHEN 711
-#define WHERE 712
-#define WHITESPACE_P 713
-#define WINDOW 714
-#define WITH 715
-#define WITHIN 716
-#define WITHOUT 717
-#define WORK 718
-#define WRAPPER 719
-#define WRITE_P 720
-#define XML_P 721
-#define XMLATTRIBUTES 722
-#define XMLCONCAT 723
-#define XMLELEMENT 724
-#define XMLEXISTS 725
-#define XMLFOREST 726
-#define XMLNAMESPACES 727
-#define XMLPARSE 728
-#define XMLPI 729
-#define XMLROOT 730
-#define XMLSERIALIZE 731
-#define XMLTABLE 732
-#define YEAR_P 733
-#define YEARS_P 734
-#define YES_P 735
-#define ZONE 736
-#define NOT_LA 737
-#define NULLS_LA 738
-#define WITH_LA 739
-#define POSTFIXOP 740
-#define UMINUS 741
-
-
-
-
-/* Copy the first part of user declarations.  */
-#line 1 "third_party/libpg_query/grammar/grammar.y.tmp"
-
-#line 1 "third_party/libpg_query/grammar/grammar.hpp"
-/*#define YYDEBUG 1*/
-/*-------------------------------------------------------------------------
- *
- * gram.y
- *	  POSTGRESQL BISON rules/actions
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/parser/gram.y
- *
- * HISTORY
- *	  AUTHOR			DATE			MAJOR EVENT
- *	  Andrew Yu			Sept, 1994		POSTQUEL to SQL conversion
- *	  Andrew Yu			Oct, 1994		lispy code conversion
- *
- * NOTES
- *	  CAPITALS are used to represent terminal symbols.
- *	  non-capitals are used to represent non-terminals.
- *
- *	  In general, nothing in this file should initiate database accesses
- *	  nor depend on changeable state (such as SET variables).  If you do
- *	  database accesses, your code will fail when we have aborted the
- *	  current transaction and are just parsing commands to find the next
- *	  ROLLBACK or COMMIT.  If you make use of SET variables, then you
- *	  will do the wrong thing in multi-query strings like this:
- *			SET constraint_exclusion TO off; SELECT * FROM foo;
- *	  because the entire string is parsed by gram.y before the SET gets
- *	  executed.  Anything that depends on the database or changeable state
- *	  should be handled during parse analysis so that it happens at the
- *	  right time not the wrong time.
- *
- * WARNINGS
- *	  If you use a list, make sure the datum is a node so that the printing
- *	  routines work.
- *
- *	  Sometimes we assign constants to makeStrings. Make sure we don't free
- *	  those.
- *
- *-------------------------------------------------------------------------
- */
-
-#include <string.h>
-
-#include <ctype.h>
-#include <limits.h>
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * gramparse.h
- *		Shared definitions for the "raw" parser (flex and bison phases only)
- *
- * NOTE: this file is only meant to be included in the core parsing files,
- * ie, parser.c, gram.y, scan.l, and src/common/keywords.c.
- * Definitions that are needed outside the core parser should be in parser.h.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/gramparse.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * scanner.h
- *		API for the core scanner (flex machine)
- *
- * The core scanner is also used by PL/pgSQL, so we provide a public API
- * for it.  However, the rest of the backend is only expected to use the
- * higher-level API provided by parser.h.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/scanner.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-#include <cstdint>
-
-
-
-
-namespace duckdb_libpgquery {
-
-/*
- * The scanner returns extra data about scanned tokens in this union type.
- * Note that this is a subset of the fields used in YYSTYPE of the bison
- * parsers built atop the scanner.
- */
-typedef union core_YYSTYPE {
-	int ival;            /* for integer literals */
-	char *str;           /* for identifiers and non-integer literals */
-	const char *keyword; /* canonical spelling of keywords */
-} core_YYSTYPE;
-
-/*
- * We track token locations in terms of byte offsets from the start of the
- * source string, not the column number/line number representation that
- * bison uses by default.  Also, to minimize overhead we track only one
- * location (usually the first token location) for each construct, not
- * the beginning and ending locations as bison does by default.  It's
- * therefore sufficient to make YYLTYPE an int.
- */
-#define YYLTYPE int
-
-/*
- * Another important component of the scanner's API is the token code numbers.
- * However, those are not defined in this file, because bison insists on
- * defining them for itself.  The token codes used by the core scanner are
- * the ASCII characters plus these:
- *	%token <str>	IDENT FCONST SCONST BCONST XCONST Op
- *	%token <ival>	ICONST PARAM
- *	%token			TYPECAST DOT_DOT COLON_EQUALS EQUALS_GREATER LAMBDA_ARROW
- *	%token			LESS_EQUALS GREATER_EQUALS NOT_EQUALS
- * The above token definitions *must* be the first ones declared in any
- * bison parser built atop this scanner, so that they will have consistent
- * numbers assigned to them (specifically, IDENT = 258 and so on).
- */
-
-/*
- * The YY_EXTRA data that a flex scanner allows us to pass around.
- * Private state needed by the core scanner goes here.  Note that the actual
- * yy_extra struct may be larger and have this as its first component, thus
- * allowing the calling parser to keep some fields of its own in YY_EXTRA.
- */
-typedef struct core_yy_extra_type {
-	/*
-	 * The string the scanner is physically scanning.  We keep this mainly so
-	 * that we can cheaply compute the offset of the current token (yytext).
-	 */
-	char *scanbuf;
-	PGSize scanbuflen;
-
-	/*
-	 * The keyword list to use.
-	 */
-	const PGScanKeyword *keywords;
-	int num_keywords;
-
-	/*
-	 * Scanner settings to use.  These are initialized from the corresponding
-	 * GUC variables by scanner_init().  Callers can modify them after
-	 * scanner_init() if they don't want the scanner's behavior to follow the
-	 * prevailing GUC settings.
-	 */
-	int backslash_quote;
-	bool escape_string_warning;
-	bool standard_conforming_strings;
-
-	/*
-	 * literalbuf is used to accumulate literal values when multiple rules are
-	 * needed to parse a single literal.  Call startlit() to reset buffer to
-	 * empty, addlit() to add text.  NOTE: the string in literalbuf is NOT
-	 * necessarily null-terminated, but there always IS room to add a trailing
-	 * null at offset literallen.  We store a null only when we need it.
-	 */
-	char *literalbuf; /* palloc'd expandable buffer */
-	int literallen;   /* actual current string length */
-	int literalalloc; /* current allocated buffer size */
-
-	int xcdepth;     /* depth of nesting in slash-star comments */
-	char *dolqstart; /* current $foo$ quote start string */
-
-	/* first part of UTF16 surrogate pair for Unicode escapes */
-	int32_t utf16_first_part;
-
-	/* state variables for literal-lexing warnings */
-	bool warn_on_first_escape;
-	bool saw_non_ascii;
-} core_yy_extra_type;
-
-/*
- * The type of yyscanner is opaque outside scan.l.
- */
-typedef void *core_yyscan_t;
-
-/* Entry points in parser/scan.l */
-core_yyscan_t scanner_init(const char *str, core_yy_extra_type *yyext, const PGScanKeyword *keywords, int num_keywords);
-void scanner_finish(core_yyscan_t yyscanner);
-int core_yylex(core_YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner);
-int scanner_errposition(int location, core_yyscan_t yyscanner);
-void scanner_yyerror(const char *message, core_yyscan_t yyscanner);
-
-}
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_libpgquery {
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/* A Bison parser, made by GNU Bison 2.3.  */
-
-/* Skeleton interface for Bison's Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     IDENT = 258,
-     FCONST = 259,
-     SCONST = 260,
-     BCONST = 261,
-     XCONST = 262,
-     Op = 263,
-     ICONST = 264,
-     PARAM = 265,
-     TYPECAST = 266,
-     DOT_DOT = 267,
-     COLON_EQUALS = 268,
-     EQUALS_GREATER = 269,
-     LAMBDA_ARROW = 270,
-     POWER_OF = 271,
-     LESS_EQUALS = 272,
-     GREATER_EQUALS = 273,
-     NOT_EQUALS = 274,
-     ABORT_P = 275,
-     ABSOLUTE_P = 276,
-     ACCESS = 277,
-     ACTION = 278,
-     ADD_P = 279,
-     ADMIN = 280,
-     AFTER = 281,
-     AGGREGATE = 282,
-     ALL = 283,
-     ALSO = 284,
-     ALTER = 285,
-     ALWAYS = 286,
-     ANALYSE = 287,
-     ANALYZE = 288,
-     AND = 289,
-     ANY = 290,
-     ARRAY = 291,
-     AS = 292,
-     ASC_P = 293,
-     ASSERTION = 294,
-     ASSIGNMENT = 295,
-     ASYMMETRIC = 296,
-     AT = 297,
-     ATTACH = 298,
-     ATTRIBUTE = 299,
-     AUTHORIZATION = 300,
-     BACKWARD = 301,
-     BEFORE = 302,
-     BEGIN_P = 303,
-     BETWEEN = 304,
-     BIGINT = 305,
-     BINARY = 306,
-     BIT = 307,
-     BOOLEAN_P = 308,
-     BOTH = 309,
-     BY = 310,
-     CACHE = 311,
-     CALL_P = 312,
-     CALLED = 313,
-     CASCADE = 314,
-     CASCADED = 315,
-     CASE = 316,
-     CAST = 317,
-     CATALOG_P = 318,
-     CHAIN = 319,
-     CHAR_P = 320,
-     CHARACTER = 321,
-     CHARACTERISTICS = 322,
-     CHECK_P = 323,
-     CHECKPOINT = 324,
-     CLASS = 325,
-     CLOSE = 326,
-     CLUSTER = 327,
-     COALESCE = 328,
-     COLLATE = 329,
-     COLLATION = 330,
-     COLUMN = 331,
-     COLUMNS = 332,
-     COMMENT = 333,
-     COMMENTS = 334,
-     COMMIT = 335,
-     COMMITTED = 336,
-     COMPRESSION = 337,
-     CONCURRENTLY = 338,
-     CONFIGURATION = 339,
-     CONFLICT = 340,
-     CONNECTION = 341,
-     CONSTRAINT = 342,
-     CONSTRAINTS = 343,
-     CONTENT_P = 344,
-     CONTINUE_P = 345,
-     CONVERSION_P = 346,
-     COPY = 347,
-     COST = 348,
-     CREATE_P = 349,
-     CROSS = 350,
-     CSV = 351,
-     CUBE = 352,
-     CURRENT_P = 353,
-     CURRENT_CATALOG = 354,
-     CURRENT_DATE = 355,
-     CURRENT_ROLE = 356,
-     CURRENT_SCHEMA = 357,
-     CURRENT_TIME = 358,
-     CURRENT_TIMESTAMP = 359,
-     CURRENT_USER = 360,
-     CURSOR = 361,
-     CYCLE = 362,
-     DATA_P = 363,
-     DATABASE = 364,
-     DAY_P = 365,
-     DAYS_P = 366,
-     DEALLOCATE = 367,
-     DEC = 368,
-     DECIMAL_P = 369,
-     DECLARE = 370,
-     DEFAULT = 371,
-     DEFAULTS = 372,
-     DEFERRABLE = 373,
-     DEFERRED = 374,
-     DEFINER = 375,
-     DELETE_P = 376,
-     DELIMITER = 377,
-     DELIMITERS = 378,
-     DEPENDS = 379,
-     DESC_P = 380,
-     DESCRIBE = 381,
-     DETACH = 382,
-     DICTIONARY = 383,
-     DISABLE_P = 384,
-     DISCARD = 385,
-     DISTINCT = 386,
-     DO = 387,
-     DOCUMENT_P = 388,
-     DOMAIN_P = 389,
-     DOUBLE_P = 390,
-     DROP = 391,
-     EACH = 392,
-     ELSE = 393,
-     ENABLE_P = 394,
-     ENCODING = 395,
-     ENCRYPTED = 396,
-     END_P = 397,
-     ENUM_P = 398,
-     ESCAPE = 399,
-     EVENT = 400,
-     EXCEPT = 401,
-     EXCLUDE = 402,
-     EXCLUDING = 403,
-     EXCLUSIVE = 404,
-     EXECUTE = 405,
-     EXISTS = 406,
-     EXPLAIN = 407,
-     EXPORT_P = 408,
-     EXPORT_STATE = 409,
-     EXTENSION = 410,
-     EXTERNAL = 411,
-     EXTRACT = 412,
-     FALSE_P = 413,
-     FAMILY = 414,
-     FETCH = 415,
-     FILTER = 416,
-     FIRST_P = 417,
-     FLOAT_P = 418,
-     FOLLOWING = 419,
-     FOR = 420,
-     FORCE = 421,
-     FOREIGN = 422,
-     FORWARD = 423,
-     FREEZE = 424,
-     FROM = 425,
-     FULL = 426,
-     FUNCTION = 427,
-     FUNCTIONS = 428,
-     GENERATED = 429,
-     GLOB = 430,
-     GLOBAL = 431,
-     GRANT = 432,
-     GRANTED = 433,
-     GROUP_P = 434,
-     GROUPING = 435,
-     GROUPING_ID = 436,
-     HANDLER = 437,
-     HAVING = 438,
-     HEADER_P = 439,
-     HOLD = 440,
-     HOUR_P = 441,
-     HOURS_P = 442,
-     IDENTITY_P = 443,
-     IF_P = 444,
-     IGNORE_P = 445,
-     ILIKE = 446,
-     IMMEDIATE = 447,
-     IMMUTABLE = 448,
-     IMPLICIT_P = 449,
-     IMPORT_P = 450,
-     IN_P = 451,
-     INCLUDING = 452,
-     INCREMENT = 453,
-     INDEX = 454,
-     INDEXES = 455,
-     INHERIT = 456,
-     INHERITS = 457,
-     INITIALLY = 458,
-     INLINE_P = 459,
-     INNER_P = 460,
-     INOUT = 461,
-     INPUT_P = 462,
-     INSENSITIVE = 463,
-     INSERT = 464,
-     INSTALL = 465,
-     INSTEAD = 466,
-     INT_P = 467,
-     INTEGER = 468,
-     INTERSECT = 469,
-     INTERVAL = 470,
-     INTO = 471,
-     INVOKER = 472,
-     IS = 473,
-     ISNULL = 474,
-     ISOLATION = 475,
-     JOIN = 476,
-     JSON = 477,
-     KEY = 478,
-     LABEL = 479,
-     LANGUAGE = 480,
-     LARGE_P = 481,
-     LAST_P = 482,
-     LATERAL_P = 483,
-     LEADING = 484,
-     LEAKPROOF = 485,
-     LEFT = 486,
-     LEVEL = 487,
-     LIKE = 488,
-     LIMIT = 489,
-     LISTEN = 490,
-     LOAD = 491,
-     LOCAL = 492,
-     LOCALTIME = 493,
-     LOCALTIMESTAMP = 494,
-     LOCATION = 495,
-     LOCK_P = 496,
-     LOCKED = 497,
-     LOGGED = 498,
-     MACRO = 499,
-     MAP = 500,
-     MAPPING = 501,
-     MATCH = 502,
-     MATERIALIZED = 503,
-     MAXVALUE = 504,
-     METHOD = 505,
-     MICROSECOND_P = 506,
-     MICROSECONDS_P = 507,
-     MILLISECOND_P = 508,
-     MILLISECONDS_P = 509,
-     MINUTE_P = 510,
-     MINUTES_P = 511,
-     MINVALUE = 512,
-     MODE = 513,
-     MONTH_P = 514,
-     MONTHS_P = 515,
-     MOVE = 516,
-     NAME_P = 517,
-     NAMES = 518,
-     NATIONAL = 519,
-     NATURAL = 520,
-     NCHAR = 521,
-     NEW = 522,
-     NEXT = 523,
-     NO = 524,
-     NONE = 525,
-     NOT = 526,
-     NOTHING = 527,
-     NOTIFY = 528,
-     NOTNULL = 529,
-     NOWAIT = 530,
-     NULL_P = 531,
-     NULLIF = 532,
-     NULLS_P = 533,
-     NUMERIC = 534,
-     OBJECT_P = 535,
-     OF = 536,
-     OFF = 537,
-     OFFSET = 538,
-     OIDS = 539,
-     OLD = 540,
-     ON = 541,
-     ONLY = 542,
-     OPERATOR = 543,
-     OPTION = 544,
-     OPTIONS = 545,
-     OR = 546,
-     ORDER = 547,
-     ORDINALITY = 548,
-     OUT_P = 549,
-     OUTER_P = 550,
-     OVER = 551,
-     OVERLAPS = 552,
-     OVERLAY = 553,
-     OVERRIDING = 554,
-     OWNED = 555,
-     OWNER = 556,
-     PARALLEL = 557,
-     PARSER = 558,
-     PARTIAL = 559,
-     PARTITION = 560,
-     PASSING = 561,
-     PASSWORD = 562,
-     PERCENT = 563,
-     PLACING = 564,
-     PLANS = 565,
-     POLICY = 566,
-     POSITION = 567,
-     PRAGMA_P = 568,
-     PRECEDING = 569,
-     PRECISION = 570,
-     PREPARE = 571,
-     PREPARED = 572,
-     PRESERVE = 573,
-     PRIMARY = 574,
-     PRIOR = 575,
-     PRIVILEGES = 576,
-     PROCEDURAL = 577,
-     PROCEDURE = 578,
-     PROGRAM = 579,
-     PUBLICATION = 580,
-     QUALIFY = 581,
-     QUOTE = 582,
-     RANGE = 583,
-     READ_P = 584,
-     REAL = 585,
-     REASSIGN = 586,
-     RECHECK = 587,
-     RECURSIVE = 588,
-     REF = 589,
-     REFERENCES = 590,
-     REFERENCING = 591,
-     REFRESH = 592,
-     REINDEX = 593,
-     RELATIVE_P = 594,
-     RELEASE = 595,
-     RENAME = 596,
-     REPEATABLE = 597,
-     REPLACE = 598,
-     REPLICA = 599,
-     RESET = 600,
-     RESPECT_P = 601,
-     RESTART = 602,
-     RESTRICT = 603,
-     RETURNING = 604,
-     RETURNS = 605,
-     REVOKE = 606,
-     RIGHT = 607,
-     ROLE = 608,
-     ROLLBACK = 609,
-     ROLLUP = 610,
-     ROW = 611,
-     ROWS = 612,
-     RULE = 613,
-     SAMPLE = 614,
-     SAVEPOINT = 615,
-     SCHEMA = 616,
-     SCHEMAS = 617,
-     SCROLL = 618,
-     SEARCH = 619,
-     SECOND_P = 620,
-     SECONDS_P = 621,
-     SECURITY = 622,
-     SELECT = 623,
-     SEQUENCE = 624,
-     SEQUENCES = 625,
-     SERIALIZABLE = 626,
-     SERVER = 627,
-     SESSION = 628,
-     SESSION_USER = 629,
-     SET = 630,
-     SETOF = 631,
-     SETS = 632,
-     SHARE = 633,
-     SHOW = 634,
-     SIMILAR = 635,
-     SIMPLE = 636,
-     SKIP = 637,
-     SMALLINT = 638,
-     SNAPSHOT = 639,
-     SOME = 640,
-     SQL_P = 641,
-     STABLE = 642,
-     STANDALONE_P = 643,
-     START = 644,
-     STATEMENT = 645,
-     STATISTICS = 646,
-     STDIN = 647,
-     STDOUT = 648,
-     STORAGE = 649,
-     STORED = 650,
-     STRICT_P = 651,
-     STRIP_P = 652,
-     STRUCT = 653,
-     SUBSCRIPTION = 654,
-     SUBSTRING = 655,
-     SUMMARIZE = 656,
-     SYMMETRIC = 657,
-     SYSID = 658,
-     SYSTEM_P = 659,
-     TABLE = 660,
-     TABLES = 661,
-     TABLESAMPLE = 662,
-     TABLESPACE = 663,
-     TEMP = 664,
-     TEMPLATE = 665,
-     TEMPORARY = 666,
-     TEXT_P = 667,
-     THEN = 668,
-     TIME = 669,
-     TIMESTAMP = 670,
-     TO = 671,
-     TRAILING = 672,
-     TRANSACTION = 673,
-     TRANSFORM = 674,
-     TREAT = 675,
-     TRIGGER = 676,
-     TRIM = 677,
-     TRUE_P = 678,
-     TRUNCATE = 679,
-     TRUSTED = 680,
-     TRY_CAST = 681,
-     TYPE_P = 682,
-     TYPES_P = 683,
-     UNBOUNDED = 684,
-     UNCOMMITTED = 685,
-     UNENCRYPTED = 686,
-     UNION = 687,
-     UNIQUE = 688,
-     UNKNOWN = 689,
-     UNLISTEN = 690,
-     UNLOGGED = 691,
-     UNTIL = 692,
-     UPDATE = 693,
-     USER = 694,
-     USING = 695,
-     VACUUM = 696,
-     VALID = 697,
-     VALIDATE = 698,
-     VALIDATOR = 699,
-     VALUE_P = 700,
-     VALUES = 701,
-     VARCHAR = 702,
-     VARIADIC = 703,
-     VARYING = 704,
-     VERBOSE = 705,
-     VERSION_P = 706,
-     VIEW = 707,
-     VIEWS = 708,
-     VIRTUAL = 709,
-     VOLATILE = 710,
-     WHEN = 711,
-     WHERE = 712,
-     WHITESPACE_P = 713,
-     WINDOW = 714,
-     WITH = 715,
-     WITHIN = 716,
-     WITHOUT = 717,
-     WORK = 718,
-     WRAPPER = 719,
-     WRITE_P = 720,
-     XML_P = 721,
-     XMLATTRIBUTES = 722,
-     XMLCONCAT = 723,
-     XMLELEMENT = 724,
-     XMLEXISTS = 725,
-     XMLFOREST = 726,
-     XMLNAMESPACES = 727,
-     XMLPARSE = 728,
-     XMLPI = 729,
-     XMLROOT = 730,
-     XMLSERIALIZE = 731,
-     XMLTABLE = 732,
-     YEAR_P = 733,
-     YEARS_P = 734,
-     YES_P = 735,
-     ZONE = 736,
-     NOT_LA = 737,
-     NULLS_LA = 738,
-     WITH_LA = 739,
-     POSTFIXOP = 740,
-     UMINUS = 741
-   };
-#endif
-/* Tokens.  */
-#define IDENT 258
-#define FCONST 259
-#define SCONST 260
-#define BCONST 261
-#define XCONST 262
-#define Op 263
-#define ICONST 264
-#define PARAM 265
-#define TYPECAST 266
-#define DOT_DOT 267
-#define COLON_EQUALS 268
-#define EQUALS_GREATER 269
-#define LAMBDA_ARROW 270
-#define POWER_OF 271
-#define LESS_EQUALS 272
-#define GREATER_EQUALS 273
-#define NOT_EQUALS 274
-#define ABORT_P 275
-#define ABSOLUTE_P 276
-#define ACCESS 277
-#define ACTION 278
-#define ADD_P 279
-#define ADMIN 280
-#define AFTER 281
-#define AGGREGATE 282
-#define ALL 283
-#define ALSO 284
-#define ALTER 285
-#define ALWAYS 286
-#define ANALYSE 287
-#define ANALYZE 288
-#define AND 289
-#define ANY 290
-#define ARRAY 291
-#define AS 292
-#define ASC_P 293
-#define ASSERTION 294
-#define ASSIGNMENT 295
-#define ASYMMETRIC 296
-#define AT 297
-#define ATTACH 298
-#define ATTRIBUTE 299
-#define AUTHORIZATION 300
-#define BACKWARD 301
-#define BEFORE 302
-#define BEGIN_P 303
-#define BETWEEN 304
-#define BIGINT 305
-#define BINARY 306
-#define BIT 307
-#define BOOLEAN_P 308
-#define BOTH 309
-#define BY 310
-#define CACHE 311
-#define CALL_P 312
-#define CALLED 313
-#define CASCADE 314
-#define CASCADED 315
-#define CASE 316
-#define CAST 317
-#define CATALOG_P 318
-#define CHAIN 319
-#define CHAR_P 320
-#define CHARACTER 321
-#define CHARACTERISTICS 322
-#define CHECK_P 323
-#define CHECKPOINT 324
-#define CLASS 325
-#define CLOSE 326
-#define CLUSTER 327
-#define COALESCE 328
-#define COLLATE 329
-#define COLLATION 330
-#define COLUMN 331
-#define COLUMNS 332
-#define COMMENT 333
-#define COMMENTS 334
-#define COMMIT 335
-#define COMMITTED 336
-#define COMPRESSION 337
-#define CONCURRENTLY 338
-#define CONFIGURATION 339
-#define CONFLICT 340
-#define CONNECTION 341
-#define CONSTRAINT 342
-#define CONSTRAINTS 343
-#define CONTENT_P 344
-#define CONTINUE_P 345
-#define CONVERSION_P 346
-#define COPY 347
-#define COST 348
-#define CREATE_P 349
-#define CROSS 350
-#define CSV 351
-#define CUBE 352
-#define CURRENT_P 353
-#define CURRENT_CATALOG 354
-#define CURRENT_DATE 355
-#define CURRENT_ROLE 356
-#define CURRENT_SCHEMA 357
-#define CURRENT_TIME 358
-#define CURRENT_TIMESTAMP 359
-#define CURRENT_USER 360
-#define CURSOR 361
-#define CYCLE 362
-#define DATA_P 363
-#define DATABASE 364
-#define DAY_P 365
-#define DAYS_P 366
-#define DEALLOCATE 367
-#define DEC 368
-#define DECIMAL_P 369
-#define DECLARE 370
-#define DEFAULT 371
-#define DEFAULTS 372
-#define DEFERRABLE 373
-#define DEFERRED 374
-#define DEFINER 375
-#define DELETE_P 376
-#define DELIMITER 377
-#define DELIMITERS 378
-#define DEPENDS 379
-#define DESC_P 380
-#define DESCRIBE 381
-#define DETACH 382
-#define DICTIONARY 383
-#define DISABLE_P 384
-#define DISCARD 385
-#define DISTINCT 386
-#define DO 387
-#define DOCUMENT_P 388
-#define DOMAIN_P 389
-#define DOUBLE_P 390
-#define DROP 391
-#define EACH 392
-#define ELSE 393
-#define ENABLE_P 394
-#define ENCODING 395
-#define ENCRYPTED 396
-#define END_P 397
-#define ENUM_P 398
-#define ESCAPE 399
-#define EVENT 400
-#define EXCEPT 401
-#define EXCLUDE 402
-#define EXCLUDING 403
-#define EXCLUSIVE 404
-#define EXECUTE 405
-#define EXISTS 406
-#define EXPLAIN 407
-#define EXPORT_P 408
-#define EXPORT_STATE 409
-#define EXTENSION 410
-#define EXTERNAL 411
-#define EXTRACT 412
-#define FALSE_P 413
-#define FAMILY 414
-#define FETCH 415
-#define FILTER 416
-#define FIRST_P 417
-#define FLOAT_P 418
-#define FOLLOWING 419
-#define FOR 420
-#define FORCE 421
-#define FOREIGN 422
-#define FORWARD 423
-#define FREEZE 424
-#define FROM 425
-#define FULL 426
-#define FUNCTION 427
-#define FUNCTIONS 428
-#define GENERATED 429
-#define GLOB 430
-#define GLOBAL 431
-#define GRANT 432
-#define GRANTED 433
-#define GROUP_P 434
-#define GROUPING 435
-#define GROUPING_ID 436
-#define HANDLER 437
-#define HAVING 438
-#define HEADER_P 439
-#define HOLD 440
-#define HOUR_P 441
-#define HOURS_P 442
-#define IDENTITY_P 443
-#define IF_P 444
-#define IGNORE_P 445
-#define ILIKE 446
-#define IMMEDIATE 447
-#define IMMUTABLE 448
-#define IMPLICIT_P 449
-#define IMPORT_P 450
-#define IN_P 451
-#define INCLUDING 452
-#define INCREMENT 453
-#define INDEX 454
-#define INDEXES 455
-#define INHERIT 456
-#define INHERITS 457
-#define INITIALLY 458
-#define INLINE_P 459
-#define INNER_P 460
-#define INOUT 461
-#define INPUT_P 462
-#define INSENSITIVE 463
-#define INSERT 464
-#define INSTALL 465
-#define INSTEAD 466
-#define INT_P 467
-#define INTEGER 468
-#define INTERSECT 469
-#define INTERVAL 470
-#define INTO 471
-#define INVOKER 472
-#define IS 473
-#define ISNULL 474
-#define ISOLATION 475
-#define JOIN 476
-#define JSON 477
-#define KEY 478
-#define LABEL 479
-#define LANGUAGE 480
-#define LARGE_P 481
-#define LAST_P 482
-#define LATERAL_P 483
-#define LEADING 484
-#define LEAKPROOF 485
-#define LEFT 486
-#define LEVEL 487
-#define LIKE 488
-#define LIMIT 489
-#define LISTEN 490
-#define LOAD 491
-#define LOCAL 492
-#define LOCALTIME 493
-#define LOCALTIMESTAMP 494
-#define LOCATION 495
-#define LOCK_P 496
-#define LOCKED 497
-#define LOGGED 498
-#define MACRO 499
-#define MAP 500
-#define MAPPING 501
-#define MATCH 502
-#define MATERIALIZED 503
-#define MAXVALUE 504
-#define METHOD 505
-#define MICROSECOND_P 506
-#define MICROSECONDS_P 507
-#define MILLISECOND_P 508
-#define MILLISECONDS_P 509
-#define MINUTE_P 510
-#define MINUTES_P 511
-#define MINVALUE 512
-#define MODE 513
-#define MONTH_P 514
-#define MONTHS_P 515
-#define MOVE 516
-#define NAME_P 517
-#define NAMES 518
-#define NATIONAL 519
-#define NATURAL 520
-#define NCHAR 521
-#define NEW 522
-#define NEXT 523
-#define NO 524
-#define NONE 525
-#define NOT 526
-#define NOTHING 527
-#define NOTIFY 528
-#define NOTNULL 529
-#define NOWAIT 530
-#define NULL_P 531
-#define NULLIF 532
-#define NULLS_P 533
-#define NUMERIC 534
-#define OBJECT_P 535
-#define OF 536
-#define OFF 537
-#define OFFSET 538
-#define OIDS 539
-#define OLD 540
-#define ON 541
-#define ONLY 542
-#define OPERATOR 543
-#define OPTION 544
-#define OPTIONS 545
-#define OR 546
-#define ORDER 547
-#define ORDINALITY 548
-#define OUT_P 549
-#define OUTER_P 550
-#define OVER 551
-#define OVERLAPS 552
-#define OVERLAY 553
-#define OVERRIDING 554
-#define OWNED 555
-#define OWNER 556
-#define PARALLEL 557
-#define PARSER 558
-#define PARTIAL 559
-#define PARTITION 560
-#define PASSING 561
-#define PASSWORD 562
-#define PERCENT 563
-#define PLACING 564
-#define PLANS 565
-#define POLICY 566
-#define POSITION 567
-#define PRAGMA_P 568
-#define PRECEDING 569
-#define PRECISION 570
-#define PREPARE 571
-#define PREPARED 572
-#define PRESERVE 573
-#define PRIMARY 574
-#define PRIOR 575
-#define PRIVILEGES 576
-#define PROCEDURAL 577
-#define PROCEDURE 578
-#define PROGRAM 579
-#define PUBLICATION 580
-#define QUALIFY 581
-#define QUOTE 582
-#define RANGE 583
-#define READ_P 584
-#define REAL 585
-#define REASSIGN 586
-#define RECHECK 587
-#define RECURSIVE 588
-#define REF 589
-#define REFERENCES 590
-#define REFERENCING 591
-#define REFRESH 592
-#define REINDEX 593
-#define RELATIVE_P 594
-#define RELEASE 595
-#define RENAME 596
-#define REPEATABLE 597
-#define REPLACE 598
-#define REPLICA 599
-#define RESET 600
-#define RESPECT_P 601
-#define RESTART 602
-#define RESTRICT 603
-#define RETURNING 604
-#define RETURNS 605
-#define REVOKE 606
-#define RIGHT 607
-#define ROLE 608
-#define ROLLBACK 609
-#define ROLLUP 610
-#define ROW 611
-#define ROWS 612
-#define RULE 613
-#define SAMPLE 614
-#define SAVEPOINT 615
-#define SCHEMA 616
-#define SCHEMAS 617
-#define SCROLL 618
-#define SEARCH 619
-#define SECOND_P 620
-#define SECONDS_P 621
-#define SECURITY 622
-#define SELECT 623
-#define SEQUENCE 624
-#define SEQUENCES 625
-#define SERIALIZABLE 626
-#define SERVER 627
-#define SESSION 628
-#define SESSION_USER 629
-#define SET 630
-#define SETOF 631
-#define SETS 632
-#define SHARE 633
-#define SHOW 634
-#define SIMILAR 635
-#define SIMPLE 636
-#define SKIP 637
-#define SMALLINT 638
-#define SNAPSHOT 639
-#define SOME 640
-#define SQL_P 641
-#define STABLE 642
-#define STANDALONE_P 643
-#define START 644
-#define STATEMENT 645
-#define STATISTICS 646
-#define STDIN 647
-#define STDOUT 648
-#define STORAGE 649
-#define STORED 650
-#define STRICT_P 651
-#define STRIP_P 652
-#define STRUCT 653
-#define SUBSCRIPTION 654
-#define SUBSTRING 655
-#define SUMMARIZE 656
-#define SYMMETRIC 657
-#define SYSID 658
-#define SYSTEM_P 659
-#define TABLE 660
-#define TABLES 661
-#define TABLESAMPLE 662
-#define TABLESPACE 663
-#define TEMP 664
-#define TEMPLATE 665
-#define TEMPORARY 666
-#define TEXT_P 667
-#define THEN 668
-#define TIME 669
-#define TIMESTAMP 670
-#define TO 671
-#define TRAILING 672
-#define TRANSACTION 673
-#define TRANSFORM 674
-#define TREAT 675
-#define TRIGGER 676
-#define TRIM 677
-#define TRUE_P 678
-#define TRUNCATE 679
-#define TRUSTED 680
-#define TRY_CAST 681
-#define TYPE_P 682
-#define TYPES_P 683
-#define UNBOUNDED 684
-#define UNCOMMITTED 685
-#define UNENCRYPTED 686
-#define UNION 687
-#define UNIQUE 688
-#define UNKNOWN 689
-#define UNLISTEN 690
-#define UNLOGGED 691
-#define UNTIL 692
-#define UPDATE 693
-#define USER 694
-#define USING 695
-#define VACUUM 696
-#define VALID 697
-#define VALIDATE 698
-#define VALIDATOR 699
-#define VALUE_P 700
-#define VALUES 701
-#define VARCHAR 702
-#define VARIADIC 703
-#define VARYING 704
-#define VERBOSE 705
-#define VERSION_P 706
-#define VIEW 707
-#define VIEWS 708
-#define VIRTUAL 709
-#define VOLATILE 710
-#define WHEN 711
-#define WHERE 712
-#define WHITESPACE_P 713
-#define WINDOW 714
-#define WITH 715
-#define WITHIN 716
-#define WITHOUT 717
-#define WORK 718
-#define WRAPPER 719
-#define WRITE_P 720
-#define XML_P 721
-#define XMLATTRIBUTES 722
-#define XMLCONCAT 723
-#define XMLELEMENT 724
-#define XMLEXISTS 725
-#define XMLFOREST 726
-#define XMLNAMESPACES 727
-#define XMLPARSE 728
-#define XMLPI 729
-#define XMLROOT 730
-#define XMLSERIALIZE 731
-#define XMLTABLE 732
-#define YEAR_P 733
-#define YEARS_P 734
-#define YES_P 735
-#define ZONE 736
-#define NOT_LA 737
-#define NULLS_LA 738
-#define WITH_LA 739
-#define POSTFIXOP 740
-#define UMINUS 741
-
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-#line 14 "third_party/libpg_query/grammar/grammar.y"
-{
-	core_YYSTYPE		core_yystype;
-	/* these fields must match core_YYSTYPE: */
-	int					ival;
-	char				*str;
-	const char			*keyword;
-	const char          *conststr;
-
-	char				chr;
-	bool				boolean;
-	PGJoinType			jtype;
-	PGDropBehavior		dbehavior;
-	PGOnCommitAction		oncommit;
-	PGOnCreateConflict		oncreateconflict;
-	PGList				*list;
-	PGNode				*node;
-	PGValue				*value;
-	PGObjectType			objtype;
-	PGTypeName			*typnam;
-	PGObjectWithArgs		*objwithargs;
-	PGDefElem				*defelt;
-	PGSortBy				*sortby;
-	PGWindowDef			*windef;
-	PGJoinExpr			*jexpr;
-	PGIndexElem			*ielem;
-	PGAlias				*alias;
-	PGRangeVar			*range;
-	PGIntoClause			*into;
-	PGWithClause			*with;
-	PGInferClause			*infer;
-	PGOnConflictClause	*onconflict;
-	PGAIndices			*aind;
-	PGResTarget			*target;
-	PGInsertStmt			*istmt;
-	PGVariableSetStmt		*vsetstmt;
-	PGOverridingKind       override;
-	PGSortByDir            sortorder;
-	PGSortByNulls          nullorder;
-	PGConstrType           constr;
-	PGLockClauseStrength lockstrength;
-	PGLockWaitPolicy lockwaitpolicy;
-	PGSubLinkType subquerytype;
-	PGViewCheckOption viewcheckoption;
-}
-/* Line 1529 of yacc.c.  */
-#line 1066 "third_party/libpg_query/grammar/grammar_out.hpp"
-	YYSTYPE;
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
-#endif
-
-
-
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-
-
-// LICENSE_CHANGE_END
-
-
-/*
- * The YY_EXTRA data that a flex scanner allows us to pass around.  Private
- * state needed for raw parsing/lexing goes here.
- */
-typedef struct base_yy_extra_type {
-	/*
-	 * Fields used by the core scanner.
-	 */
-	core_yy_extra_type core_yy_extra;
-
-	/*
-	 * State variables for base_yylex().
-	 */
-	bool have_lookahead;           /* is lookahead info valid? */
-	int lookahead_token;           /* one-token lookahead */
-	core_YYSTYPE lookahead_yylval; /* yylval for lookahead token */
-	YYLTYPE lookahead_yylloc;      /* yylloc for lookahead token */
-	char *lookahead_end;           /* end of current token */
-	char lookahead_hold_char;      /* to be put back at *lookahead_end */
-
-	/*
-	 * State variables that belong to the grammar.
-	 */
-	PGList *parsetree; /* final parse result is delivered here */
-} base_yy_extra_type;
-
-/*
- * In principle we should use yyget_extra() to fetch the yyextra field
- * from a yyscanner struct.  However, flex always puts that field first,
- * and this is sufficiently performance-critical to make it seem worth
- * cheating a bit to use an inline macro.
- */
-#define pg_yyget_extra(yyscanner) (*((base_yy_extra_type **)(yyscanner)))
-
-/* from parser.c */
-int base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner);
-
-/* from gram.y */
-void parser_init(base_yy_extra_type *yyext);
-int base_yyparse(core_yyscan_t yyscanner);
-
-}
-
-// LICENSE_CHANGE_END
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * datetime.h
- *	  Definitions for date/time support code.
- *	  The support code is shared with other date data types,
- *	   including abstime, reltime, date, and time.
- *
- *
- * Portions Copyright (c) 1996-2015, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/datetime.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * timestamp.h
- *	  Definitions for the SQL "timestamp" and "interval" types.
- *
- * Portions Copyright (c) 1996-2015, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/timestamp.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * timestamp.h
- *	  PGTimestamp and PGInterval typedefs and related macros.
- *
- * Note: this file must be includable in both frontend and backend contexts.
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/datatype/timestamp.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-#include <cstdint>
-
-/*
- * PGTimestamp represents absolute time.
- *
- * PGInterval represents delta time. Keep track of months (and years), days,
- * and hours/minutes/seconds separately since the elapsed time spanned is
- * unknown until instantiated relative to an absolute time.
- *
- * Note that Postgres uses "time interval" to mean a bounded interval,
- * consisting of a beginning and ending time, not a time span - thomas 97/03/20
- *
- * Timestamps, as well as the h/m/s fields of intervals, are stored as
- * int64_t values with units of microseconds.  (Once upon a time they were
- * double values with units of seconds.)
- *
- * PGTimeOffset and pg_fsec_t are convenience typedefs for temporary variables.
- * Do not use pg_fsec_t in values stored on-disk.
- * Also, pg_fsec_t is only meant for *fractional* seconds; beware of overflow
- * if the value you need to store could be many seconds.
- */
-namespace duckdb_libpgquery {
-
-typedef int64_t PGTimestamp;
-typedef int64_t PGTimestampTz;
-typedef int64_t PGTimeOffset;
-typedef int32_t pg_fsec_t; /* fractional seconds (in microseconds) */
-
-typedef struct {
-	PGTimeOffset time; /* all time units other than days, months and
-								 * years */
-	int32_t day;       /* days, after time for alignment */
-	int32_t month;     /* months and years, after time for alignment */
-} PGInterval;
-}
-
-// LICENSE_CHANGE_END
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * pgtime.h
- *	  PostgreSQL internal timezone library
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- *
- * IDENTIFICATION
- *	  src/include/pgtime.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-#include <cstdint>
-
-/*
- * The API of this library is generally similar to the corresponding
- * C library functions, except that we use pg_time_t which (we hope) is
- * 64 bits wide, and which is most definitely signed not unsigned.
- */
-
-typedef int64_t pg_time_t;
-
-struct pg_tm
-{
-	int			tm_sec;
-	int			tm_min;
-	int			tm_hour;
-	int			tm_mday;
-	int			tm_mon;			/* origin 1, not 0! */
-	int			tm_year;		/* relative to 1900 */
-	int			tm_wday;
-	int			tm_yday;
-	int			tm_isdst;
-	long int	tm_gmtoff;
-	const char *tm_zone;
-};
-
-typedef struct pg_tz pg_tz;
-typedef struct pg_tzenum pg_tzenum;
-
-/* Maximum length of a timezone name (not including trailing null) */
-#define TZ_STRLEN_MAX 255
-
-/* these functions are in localtime.c */
-
-struct pg_tm *pg_localtime(const pg_time_t *timep, const pg_tz *tz);
-struct pg_tm *pg_gmtime(const pg_time_t *timep);
-int pg_next_dst_boundary(const pg_time_t *timep,
-					 long int *before_gmtoff,
-					 int *before_isdst,
-					 pg_time_t *boundary,
-					 long int *after_gmtoff,
-					 int *after_isdst,
-					 const pg_tz *tz);
-bool pg_interpret_timezone_abbrev(const char *abbrev,
-							 const pg_time_t *timep,
-							 long int *gmtoff,
-							 int *isdst,
-							 const pg_tz *tz);
-bool pg_get_timezone_offset(const pg_tz *tz, long int *gmtoff);
-const char *pg_get_timezone_name(pg_tz *tz);
-bool pg_tz_acceptable(pg_tz *tz);
-
-/* these functions and variables are in pgtz.c */
-
-pg_tz *session_timezone;
-pg_tz *log_timezone;
-
-void pg_timezone_initialize(void);
-pg_tz *pg_tzset(const char *tzname);
-pg_tz *pg_tzset_offset(long gmtoffset);
-
-pg_tzenum *pg_tzenumerate_start(void);
-pg_tz *pg_tzenumerate_next(pg_tzenum *dir);
-void pg_tzenumerate_end(pg_tzenum *dir);
-
-
-// LICENSE_CHANGE_END
-
-
-/* Macros to handle packing and unpacking the typmod field for intervals */
-#define INTERVAL_FULL_RANGE (0x7FFF)
-#define INTERVAL_RANGE_MASK (0x7FFF)
-#define INTERVAL_FULL_PRECISION (0xFFFF)
-#define INTERVAL_PRECISION_MASK (0xFFFF)
-#define INTERVAL_TYPMOD(p,r) ((((r) & INTERVAL_RANGE_MASK) << 16) | ((p) & INTERVAL_PRECISION_MASK))
-#define INTERVAL_PRECISION(t) ((t) & INTERVAL_PRECISION_MASK)
-#define INTERVAL_RANGE(t) (((t) >> 16) & INTERVAL_RANGE_MASK)
-
-
-// LICENSE_CHANGE_END
-
-
-
-/*
- * Field types for time decoding.
- *
- * Can't have more of these than there are bits in an unsigned int
- * since these are turned into bit masks during parsing and decoding.
- *
- * Furthermore, the values for YEAR, MONTH, DAY, HOUR, MINUTE, SECOND
- * must be in the range 0..14 so that the associated bitmasks can fit
- * into the left half of an INTERVAL's typmod value.  Since those bits
- * are stored in typmods, you can't change them without initdb!
- */
-
-#define RESERV	0
-#define MONTH	1
-#define YEAR	2
-#define DAY		3
-#define JULIAN	4
-#define TZ		5				/* fixed-offset timezone abbreviation */
-#define DTZ		6				/* fixed-offset timezone abbrev, DST */
-#define DYNTZ	7				/* dynamic timezone abbreviation */
-#define IGNORE_DTF	8
-#define AMPM	9
-#define HOUR	10
-#define MINUTE	11
-#define SECOND	12
-#define MILLISECOND 13
-#define MICROSECOND 14
-#define DOY		15
-#define DOW		16
-#define UNITS	17
-#define ADBC	18
-/* these are only for relative dates */
-#define AGO		19
-#define ABS_BEFORE		20
-#define ABS_AFTER		21
-/* generic fields to help with parsing */
-#define ISODATE 22
-#define ISOTIME 23
-/* these are only for parsing intervals */
-#define WEEK		24
-#define DECADE		25
-#define CENTURY		26
-#define MILLENNIUM	27
-/* hack for parsing two-word timezone specs "MET DST" etc */
-#define DTZMOD	28				/* "DST" as a separate word */
-/* reserved for unrecognized string values */
-#define UNKNOWN_FIELD	31
-
-
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_libpgquery {
-#define DEFAULT_SCHEMA "main"
-
-/*
- * Location tracking support --- simpler than bison's default, since we only
- * want to track the start position not the end position of each nonterminal.
- */
-#define YYLLOC_DEFAULT(Current, Rhs, N) \
-	do { \
-		if ((N) > 0) \
-			(Current) = (Rhs)[1]; \
-		else \
-			(Current) = (-1); \
-	} while (0)
-
-/*
- * The above macro assigns -1 (unknown) as the parse location of any
- * nonterminal that was reduced from an empty rule, or whose leftmost
- * component was reduced from an empty rule.  This is problematic
- * for nonterminals defined like
- *		OptFooList: / * EMPTY * / { ... } | OptFooList Foo { ... } ;
- * because we'll set -1 as the location during the first reduction and then
- * copy it during each subsequent reduction, leaving us with -1 for the
- * location even when the list is not empty.  To fix that, do this in the
- * action for the nonempty rule(s):
- *		if (@$ < 0) @$ = @2;
- * (Although we have many nonterminals that follow this pattern, we only
- * bother with fixing @$ like this when the nonterminal's parse location
- * is actually referenced in some rule.)
- *
- * A cleaner answer would be to make YYLLOC_DEFAULT scan all the Rhs
- * locations until it's found one that's not -1.  Then we'd get a correct
- * location for any nonterminal that isn't entirely empty.  But this way
- * would add overhead to every rule reduction, and so far there's not been
- * a compelling reason to pay that overhead.
- */
-
-/*
- * Bison doesn't allocate anything that needs to live across parser calls,
- * so we can easily have it use palloc instead of malloc.  This prevents
- * memory leaks if we error out during parsing.  Note this only works with
- * bison >= 2.0.  However, in bison 1.875 the default is to use alloca()
- * if possible, so there's not really much problem anyhow, at least if
- * you're building with gcc.
- */
-#define YYMALLOC palloc
-#define YYFREE   pfree
-#define YYINITDEPTH 1000
-
-/* yields an integer bitmask of these flags: */
-#define CAS_NOT_DEFERRABLE			0x01
-#define CAS_DEFERRABLE				0x02
-#define CAS_INITIALLY_IMMEDIATE		0x04
-#define CAS_INITIALLY_DEFERRED		0x08
-#define CAS_NOT_VALID				0x10
-#define CAS_NO_INHERIT				0x20
-
-
-#define parser_yyerror(msg)  scanner_yyerror(msg, yyscanner)
-#define parser_errposition(pos)  scanner_errposition(pos, yyscanner)
-
-static void base_yyerror(YYLTYPE *yylloc, core_yyscan_t yyscanner,
-						 const char *msg);
-static PGRawStmt *makeRawStmt(PGNode *stmt, int stmt_location);
-static void updateRawStmtEnd(PGRawStmt *rs, int end_location);
-static PGNode *makeColumnRef(char *colname, PGList *indirection,
-						   int location, core_yyscan_t yyscanner);
-static PGNode *makeTypeCast(PGNode *arg, PGTypeName *tpname, int trycast, int location);
-static PGNode *makeStringConst(char *str, int location);
-static PGNode *makeStringConstCast(char *str, int location, PGTypeName *tpname);
-static PGNode *makeIntervalNode(char *str, int location, PGList *typmods);
-static PGNode *makeIntervalNode(int val, int location, PGList *typmods);
-static PGNode *makeIntervalNode(PGNode *arg, int location, PGList *typmods);
-static PGNode *makeSampleSize(PGValue *sample_size, bool is_percentage);
-static PGNode *makeSampleOptions(PGNode *sample_size, char *method, int seed, int location);
-static PGNode *makeIntConst(int val, int location);
-static PGNode *makeFloatConst(char *str, int location);
-static PGNode *makeBitStringConst(char *str, int location);
-static PGNode *makeNullAConst(int location);
-static PGNode *makeAConst(PGValue *v, int location);
-static PGNode *makeBoolAConst(bool state, int location);
-static PGNode *makeParamRef(int number, int location);
-static void check_qualified_name(PGList *names, core_yyscan_t yyscanner);
-static PGList *check_func_name(PGList *names, core_yyscan_t yyscanner);
-static PGList *check_indirection(PGList *indirection, core_yyscan_t yyscanner);
-static void insertSelectOptions(PGSelectStmt *stmt,
-								PGList *sortClause, PGList *lockingClause,
-								PGNode *limitOffset, PGNode *limitCount,
-								PGWithClause *withClause,
-								core_yyscan_t yyscanner);
-static PGNode *makeSetOp(PGSetOperation op, bool all, PGNode *larg, PGNode *rarg);
-static PGNode *doNegate(PGNode *n, int location);
-static void doNegateFloat(PGValue *v);
-static PGNode *makeAndExpr(PGNode *lexpr, PGNode *rexpr, int location);
-static PGNode *makeOrExpr(PGNode *lexpr, PGNode *rexpr, int location);
-static PGNode *makeNotExpr(PGNode *expr, int location);
-static PGNode *makeSQLValueFunction(PGSQLValueFunctionOp op, int32_t typmod,
-								  int location);
-static void SplitColQualList(PGList *qualList,
-							 PGList **constraintList, PGCollateClause **collClause,
-							 core_yyscan_t yyscanner);
-static void processCASbits(int cas_bits, int location, const char *constrType,
-			   bool *deferrable, bool *initdeferred, bool *not_valid,
-			   bool *no_inherit, core_yyscan_t yyscanner);
-static PGNode *makeRecursiveViewSelect(char *relname, PGList *aliases, PGNode *query);
-static PGNode *makeLimitPercent(PGNode *limit_percent);
-
-
-
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-
-/* Enabling verbose error messages.  */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-/* Enabling the token table.  */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
-#endif
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-#line 14 "third_party/libpg_query/grammar/grammar.y"
-{
-	core_YYSTYPE		core_yystype;
-	/* these fields must match core_YYSTYPE: */
-	int					ival;
-	char				*str;
-	const char			*keyword;
-	const char          *conststr;
-
-	char				chr;
-	bool				boolean;
-	PGJoinType			jtype;
-	PGDropBehavior		dbehavior;
-	PGOnCommitAction		oncommit;
-	PGOnCreateConflict		oncreateconflict;
-	PGList				*list;
-	PGNode				*node;
-	PGValue				*value;
-	PGObjectType			objtype;
-	PGTypeName			*typnam;
-	PGObjectWithArgs		*objwithargs;
-	PGDefElem				*defelt;
-	PGSortBy				*sortby;
-	PGWindowDef			*windef;
-	PGJoinExpr			*jexpr;
-	PGIndexElem			*ielem;
-	PGAlias				*alias;
-	PGRangeVar			*range;
-	PGIntoClause			*into;
-	PGWithClause			*with;
-	PGInferClause			*infer;
-	PGOnConflictClause	*onconflict;
-	PGAIndices			*aind;
-	PGResTarget			*target;
-	PGInsertStmt			*istmt;
-	PGVariableSetStmt		*vsetstmt;
-	PGOverridingKind       override;
-	PGSortByDir            sortorder;
-	PGSortByNulls          nullorder;
-	PGConstrType           constr;
-	PGLockClauseStrength lockstrength;
-	PGLockWaitPolicy lockwaitpolicy;
-	PGSubLinkType subquerytype;
-	PGViewCheckOption viewcheckoption;
-}
-/* Line 193 of yacc.c.  */
-#line 1287 "third_party/libpg_query/grammar/grammar_out.cpp"
-	YYSTYPE;
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
-#endif
-
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-/* Copy the second part of user declarations.  */
-
-
-/* Line 216 of yacc.c.  */
-#line 1312 "third_party/libpg_query/grammar/grammar_out.cpp"
-
-#ifdef short
-# undef short
-#endif
-
-#ifdef YYTYPE_UINT8
-typedef YYTYPE_UINT8 yytype_uint8;
-#else
-typedef unsigned char yytype_uint8;
-#endif
-
-#ifdef YYTYPE_INT8
-typedef YYTYPE_INT8 yytype_int8;
-#elif (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-typedef signed char yytype_int8;
-#else
-typedef short int yytype_int8;
-#endif
-
-#ifdef YYTYPE_UINT16
-typedef YYTYPE_UINT16 yytype_uint16;
-#else
-typedef unsigned short int yytype_uint16;
-#endif
-
-#ifdef YYTYPE_INT16
-typedef YYTYPE_INT16 yytype_int16;
-#else
-typedef short int yytype_int16;
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-#  define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-#  define YYSIZE_T size_t
-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# else
-#  define YYSIZE_T unsigned int
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-#  if ENABLE_NLS
-#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
-#  endif
-# endif
-# ifndef YY_
-#  define YY_(msgid) msgid
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E.  */
-#if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
-#else
-# define YYUSE(e) /* empty */
-#endif
-
-/* Identity function, used to suppress warnings about constant conditions.  */
-#ifndef lint
-# define YYID(n) (n)
-#else
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static int
-YYID (int i)
-#else
-static int
-YYID (i)
-    int i;
-#endif
-{
-  return i;
-}
-#endif
-
-#if ! defined yyoverflow || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols.  */
-
-# ifdef YYSTACK_USE_ALLOCA
-#  if YYSTACK_USE_ALLOCA
-#   ifdef __GNUC__
-#    define YYSTACK_ALLOC __builtin_alloca
-#   elif defined __BUILTIN_VA_ARG_INCR
-#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-#   elif defined _AIX
-#    define YYSTACK_ALLOC __alloca
-#   elif defined _MSC_VER
-#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-#    define alloca _alloca
-#   else
-#    define YYSTACK_ALLOC alloca
-#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#     ifndef _STDLIB_H
-#      define _STDLIB_H 1
-#     endif
-#    endif
-#   endif
-#  endif
-# endif
-
-# ifdef YYSTACK_ALLOC
-   /* Pacify GCC's `empty if-body' warning.  */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-    /* The OS might guarantee only one guard page at the bottom of the stack,
-       and a page size can be as small as 4096 bytes.  So we cannot safely
-       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
-       to allow for a few compiler-allocated temporary stack slots.  */
-#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-#  endif
-# else
-#  define YYSTACK_ALLOC YYMALLOC
-#  define YYSTACK_FREE YYFREE
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-#  endif
-#  if (defined __cplusplus && ! defined _STDLIB_H \
-       && ! ((defined YYMALLOC || defined malloc) \
-	     && (defined YYFREE || defined free)))
-#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   ifndef _STDLIB_H
-#    define _STDLIB_H 1
-#   endif
-#  endif
-#  ifndef YYMALLOC
-#   define YYMALLOC malloc
-#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-#  ifndef YYFREE
-#   define YYFREE free
-#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-# endif
-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-
-
-#if (! defined yyoverflow \
-     && (! defined __cplusplus \
-	 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
-	     && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member.  */
-union yyalloc
-{
-  yytype_int16 yyss;
-  YYSTYPE yyvs;
-    YYLTYPE yyls;
-};
-
-/* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
-   N elements.  */
-# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
-      + 2 * YYSTACK_GAP_MAXIMUM)
-
-/* Copy COUNT objects from FROM to TO.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
-#  else
-#   define YYCOPY(To, From, Count)		\
-      do					\
-	{					\
-	  YYSIZE_T yyi;				\
-	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];		\
-	}					\
-      while (YYID (0))
-#  endif
-# endif
-
-/* Relocate STACK from its old location to the new one.  The
-   local variables YYSIZE and YYSTACKSIZE give the old and new number of
-   elements in the stack, and YYPTR gives the new location of the
-   stack.  Advance YYPTR to a properly aligned location for the next
-   stack.  */
-# define YYSTACK_RELOCATE(Stack)					\
-    do									\
-      {									\
-	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack, Stack, yysize);				\
-	Stack = &yyptr->Stack;						\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-	yyptr += yynewbytes / sizeof (*yyptr);				\
-      }									\
-    while (YYID (0))
-
-#endif
-
-/* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  605
-/* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   55412
-
-/* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  508
-/* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  395
-/* YYNRULES -- Number of rules.  */
-#define YYNRULES  1887
-/* YYNRULES -- Number of states.  */
-#define YYNSTATES  3082
-
-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-#define YYUNDEFTOK  2
-#define YYMAXUTOK   741
-
-#define YYTRANSLATE(YYX)						\
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-static const yytype_uint16 yytranslate[] =
-{
-       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,   505,     2,   493,     2,     2,
-     498,   499,   491,   489,   502,   490,   500,   492,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,   507,   501,
-     485,   487,   486,   506,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,   496,     2,   497,   494,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,   503,     2,   504,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
-     455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
-     488,   495
-};
-
-#if YYDEBUG
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-   YYRHS.  */
-static const yytype_uint16 yyprhs[] =
-{
-       0,     0,     3,     5,     9,    11,    13,    15,    17,    19,
-      21,    23,    25,    27,    29,    31,    33,    35,    37,    39,
-      41,    43,    45,    47,    49,    51,    53,    55,    57,    59,
-      61,    63,    65,    67,    69,    71,    73,    75,    77,    79,
-      80,    85,    92,    97,   104,   109,   116,   121,   128,   130,
-     133,   137,   140,   142,   146,   149,   153,   155,   159,   162,
-     168,   172,   179,   184,   191,   198,   205,   211,   217,   224,
-     234,   239,   245,   253,   260,   265,   274,   279,   282,   287,
-     291,   298,   303,   306,   309,   312,   315,   317,   320,   321,
-     323,   326,   329,   332,   334,   338,   343,   346,   348,   349,
-     352,   356,   359,   363,   370,   377,   386,   393,   402,   409,
-     418,   425,   434,   443,   454,   463,   474,   476,   477,   485,
-     487,   492,   497,   505,   508,   510,   514,   519,   523,   524,
-     526,   527,   530,   534,   540,   549,   555,   556,   562,   568,
-     576,   579,   580,   582,   584,   586,   590,   593,   594,   596,
-     597,   599,   603,   605,   609,   611,   614,   616,   620,   623,
-     629,   632,   637,   643,   649,   658,   660,   661,   665,   675,
-     688,   692,   693,   698,   705,   707,   710,   712,   714,   715,
-     717,   720,   723,   725,   728,   731,   733,   736,   740,   743,
-     746,   749,   752,   756,   760,   764,   766,   770,   772,   773,
-     775,   778,   781,   784,   787,   790,   793,   796,   799,   801,
-     803,   804,   814,   827,   839,   840,   843,   845,   847,   849,
-     851,   853,   855,   859,   860,   862,   865,   867,   869,   872,
-     875,   879,   881,   883,   886,   889,   891,   894,   898,   904,
-     908,   911,   917,   919,   921,   923,   924,   930,   938,   944,
-     947,   951,   953,   955,   958,   961,   962,   966,   971,   976,
-     977,   981,   984,   985,   989,   991,   993,   995,   997,   999,
-    1001,  1003,  1005,  1007,  1009,  1013,  1017,  1019,  1022,  1025,
-    1028,  1031,  1034,  1037,  1038,  1042,  1046,  1050,  1051,  1053,
-    1056,  1058,  1061,  1064,  1067,  1070,  1074,  1079,  1081,  1085,
-    1087,  1089,  1091,  1093,  1097,  1099,  1102,  1103,  1105,  1108,
-    1109,  1111,  1115,  1116,  1119,  1120,  1124,  1128,  1130,  1136,
-    1140,  1142,  1146,  1148,  1151,  1153,  1158,  1164,  1170,  1177,
-    1181,  1189,  1194,  1206,  1208,  1212,  1215,  1218,  1221,  1222,
-    1226,  1228,  1230,  1233,  1236,  1239,  1242,  1244,  1245,  1247,
-    1250,  1257,  1262,  1269,  1274,  1281,  1290,  1295,  1302,  1304,
-    1306,  1308,  1310,  1313,  1315,  1318,  1320,  1323,  1325,  1327,
-    1329,  1333,  1337,  1341,  1345,  1348,  1351,  1353,  1357,  1359,
-    1361,  1363,  1365,  1369,  1371,  1373,  1374,  1376,  1378,  1380,
-    1382,  1386,  1395,  1403,  1405,  1407,  1410,  1414,  1423,  1435,
-    1445,  1447,  1449,  1453,  1454,  1456,  1460,  1462,  1463,  1465,
-    1466,  1468,  1469,  1471,  1475,  1477,  1479,  1481,  1485,  1486,
-    1489,  1492,  1493,  1496,  1497,  1499,  1500,  1502,  1504,  1506,
-    1510,  1514,  1516,  1518,  1522,  1526,  1530,  1534,  1539,  1543,
-    1546,  1548,  1550,  1552,  1554,  1556,  1560,  1562,  1564,  1568,
-    1572,  1574,  1577,  1582,  1587,  1590,  1594,  1600,  1606,  1608,
-    1610,  1622,  1634,  1636,  1639,  1644,  1649,  1654,  1657,  1660,
-    1664,  1666,  1670,  1677,  1680,  1681,  1685,  1689,  1694,  1699,
-    1704,  1709,  1713,  1716,  1718,  1720,  1721,  1723,  1725,  1726,
-    1728,  1734,  1736,  1737,  1740,  1743,  1744,  1746,  1747,  1751,
-    1757,  1763,  1765,  1769,  1774,  1778,  1780,  1782,  1783,  1786,
-    1789,  1790,  1793,  1796,  1798,  1800,  1802,  1803,  1806,  1811,
-    1817,  1822,  1825,  1829,  1832,  1835,  1838,  1841,  1843,  1846,
-    1850,  1851,  1853,  1854,  1860,  1862,  1867,  1874,  1877,  1879,
-    1880,  1885,  1886,  1888,  1890,  1893,  1896,  1899,  1901,  1903,
-    1906,  1909,  1911,  1913,  1915,  1917,  1919,  1921,  1925,  1929,
-    1933,  1934,  1936,  1940,  1942,  1945,  1947,  1949,  1951,  1953,
-    1955,  1958,  1963,  1968,  1974,  1976,  1978,  1981,  1982,  1985,
-    1986,  1988,  1992,  1994,  1995,  1997,  2000,  2004,  2007,  2012,
-    2015,  2019,  2022,  2023,  2025,  2028,  2029,  2034,  2040,  2042,
-    2045,  2048,  2049,  2051,  2055,  2057,  2060,  2064,  2068,  2072,
-    2076,  2080,  2082,  2087,  2091,  2096,  2102,  2107,  2113,  2118,
-    2124,  2127,  2132,  2134,  2136,  2137,  2139,  2144,  2150,  2155,
-    2156,  2159,  2162,  2165,  2167,  2169,  2170,  2175,  2178,  2180,
-    2183,  2186,  2191,  2194,  2201,  2204,  2206,  2210,  2215,  2216,
-    2219,  2220,  2223,  2224,  2226,  2230,  2234,  2237,  2238,  2241,
-    2246,  2248,  2250,  2252,  2253,  2256,  2260,  2266,  2273,  2276,
-    2280,  2286,  2292,  2296,  2301,  2302,  2304,  2306,  2308,  2310,
-    2312,  2315,  2320,  2322,  2324,  2326,  2328,  2331,  2335,  2336,
-    2338,  2340,  2342,  2344,  2346,  2349,  2352,  2355,  2358,  2361,
-    2363,  2367,  2368,  2370,  2372,  2374,  2376,  2382,  2385,  2387,
-    2389,  2391,  2393,  2398,  2400,  2403,  2406,  2408,  2412,  2416,
-    2419,  2421,  2422,  2428,  2431,  2437,  2440,  2442,  2446,  2450,
-    2451,  2453,  2455,  2457,  2459,  2461,  2463,  2465,  2467,  2469,
-    2471,  2473,  2475,  2477,  2479,  2481,  2483,  2485,  2487,  2489,
-    2491,  2493,  2495,  2497,  2499,  2503,  2507,  2511,  2515,  2519,
-    2523,  2527,  2528,  2530,  2534,  2538,  2544,  2547,  2550,  2554,
-    2558,  2562,  2566,  2570,  2574,  2578,  2582,  2586,  2590,  2594,
-    2598,  2602,  2606,  2609,  2612,  2616,  2620,  2623,  2626,  2630,
-    2634,  2640,  2645,  2652,  2656,  2662,  2667,  2674,  2679,  2686,
-    2692,  2700,  2704,  2707,  2712,  2716,  2719,  2721,  2725,  2729,
-    2733,  2737,  2741,  2746,  2750,  2755,  2759,  2764,  2770,  2777,
-    2784,  2792,  2799,  2807,  2814,  2822,  2826,  2831,  2836,  2843,
-    2845,  2850,  2852,  2856,  2859,  2862,  2866,  2870,  2874,  2878,
-    2882,  2886,  2890,  2894,  2898,  2902,  2906,  2910,  2914,  2918,
-    2921,  2924,  2930,  2937,  2944,  2952,  2954,  2956,  2959,  2962,
-    2965,  2970,  2972,  2975,  2977,  2980,  2983,  2988,  2992,  2999,
-    3007,  3017,  3025,  3033,  3038,  3044,  3046,  3048,  3050,  3056,
-    3058,  3060,  3065,  3067,  3072,  3074,  3079,  3081,  3086,  3088,
-    3090,  3092,  3094,  3096,  3098,  3105,  3112,  3117,  3122,  3127,
-    3132,  3139,  3145,  3151,  3157,  3162,  3169,  3174,  3180,  3181,
-    3187,  3188,  3190,  3191,  3194,  3195,  3197,  3201,  3205,  3208,
-    3211,  3212,  3219,  3221,  3222,  3226,  3227,  3230,  3233,  3234,
-    3236,  3241,  3244,  3247,  3250,  3253,  3256,  3261,  3265,  3267,
-    3273,  3277,  3279,  3283,  3285,  3288,  3290,  3292,  3294,  3296,
-    3298,  3300,  3302,  3304,  3306,  3308,  3310,  3312,  3314,  3316,
-    3318,  3320,  3322,  3324,  3326,  3331,  3333,  3338,  3340,  3345,
-    3347,  3350,  3352,  3355,  3357,  3360,  3362,  3366,  3368,  3372,
-    3374,  3377,  3379,  3380,  3382,  3386,  3388,  3392,  3396,  3398,
-    3402,  3406,  3407,  3409,  3411,  3413,  3415,  3417,  3419,  3421,
-    3423,  3425,  3427,  3432,  3436,  3439,  3443,  3444,  3448,  3452,
-    3455,  3458,  3460,  3461,  3464,  3467,  3471,  3474,  3476,  3478,
-    3482,  3488,  3490,  3493,  3498,  3501,  3502,  3504,  3505,  3507,
-    3510,  3513,  3517,  3523,  3525,  3526,  3528,  3531,  3532,  3535,
-    3537,  3538,  3540,  3541,  3543,  3547,  3549,  3552,  3556,  3559,
-    3561,  3565,  3571,  3576,  3579,  3581,  3582,  3586,  3588,  3592,
-    3594,  3597,  3602,  3605,  3606,  3608,  3612,  3614,  3617,  3619,
-    3623,  3625,  3628,  3630,  3632,  3634,  3637,  3639,  3641,  3644,
-    3646,  3648,  3651,  3659,  3662,  3668,  3672,  3676,  3678,  3680,
-    3682,  3684,  3686,  3688,  3690,  3692,  3694,  3696,  3698,  3700,
-    3702,  3704,  3706,  3708,  3710,  3712,  3714,  3716,  3719,  3722,
-    3726,  3730,  3731,  3733,  3735,  3737,  3739,  3741,  3743,  3745,
-    3751,  3755,  3756,  3758,  3760,  3762,  3764,  3769,  3777,  3780,
-    3781,  3783,  3785,  3787,  3789,  3803,  3820,  3822,  3825,  3826,
-    3828,  3829,  3831,  3832,  3835,  3836,  3838,  3839,  3846,  3855,
-    3862,  3871,  3878,  3887,  3890,  3892,  3897,  3901,  3904,  3909,
-    3913,  3919,  3921,  3922,  3924,  3926,  3927,  3929,  3931,  3933,
-    3935,  3937,  3939,  3941,  3943,  3945,  3947,  3949,  3953,  3955,
-    3957,  3959,  3961,  3963,  3965,  3968,  3970,  3972,  3975,  3979,
-    3983,  3987,  3989,  3993,  3997,  4000,  4004,  4008,  4012,  4016,
-    4018,  4020,  4022,  4024,  4028,  4034,  4036,  4038,  4040,  4042,
-    4046,  4049,  4052,  4056,  4058,  4060,  4065,  4071,  4077,  4082,
-    4089,  4091,  4093,  4095,  4097,  4099,  4101,  4102,  4104,  4108,
-    4110,  4111,  4119,  4121,  4124,  4128,  4131,  4132,  4135,  4136,
-    4139,  4144,  4147,  4149,  4151,  4153,  4156,  4160,  4163,  4166,
-    4169,  4172,  4176,  4181,  4184,  4186,  4188,  4190,  4192,  4196,
-    4199,  4209,  4221,  4234,  4249,  4253,  4258,  4263,  4264,  4272,
-    4283,  4293,  4296,  4300,  4301,  4306,  4308,  4310,  4312,  4314,
-    4316,  4318,  4320,  4322,  4324,  4326,  4328,  4330,  4332,  4334,
-    4336,  4338,  4340,  4342,  4344,  4346,  4348,  4350,  4352,  4354,
-    4356,  4358,  4360,  4362,  4364,  4366,  4368,  4370,  4372,  4374,
-    4376,  4378,  4380,  4382,  4384,  4386,  4388,  4390,  4392,  4394,
-    4396,  4398,  4400,  4402,  4404,  4406,  4408,  4410,  4412,  4414,
-    4416,  4418,  4420,  4422,  4424,  4426,  4428,  4430,  4432,  4434,
-    4436,  4438,  4440,  4442,  4444,  4446,  4448,  4450,  4452,  4454,
-    4456,  4458,  4460,  4462,  4464,  4466,  4468,  4470,  4472,  4474,
-    4476,  4478,  4480,  4482,  4484,  4486,  4488,  4490,  4492,  4494,
-    4496,  4498,  4500,  4502,  4504,  4506,  4508,  4510,  4512,  4514,
-    4516,  4518,  4520,  4522,  4524,  4526,  4528,  4530,  4532,  4534,
-    4536,  4538,  4540,  4542,  4544,  4546,  4548,  4550,  4552,  4554,
-    4556,  4558,  4560,  4562,  4564,  4566,  4568,  4570,  4572,  4574,
-    4576,  4578,  4580,  4582,  4584,  4586,  4588,  4590,  4592,  4594,
-    4596,  4598,  4600,  4602,  4604,  4606,  4608,  4610,  4612,  4614,
-    4616,  4618,  4620,  4622,  4624,  4626,  4628,  4630,  4632,  4634,
-    4636,  4638,  4640,  4642,  4644,  4646,  4648,  4650,  4652,  4654,
-    4656,  4658,  4660,  4662,  4664,  4666,  4668,  4670,  4672,  4674,
-    4676,  4678,  4680,  4682,  4684,  4686,  4688,  4690,  4692,  4694,
-    4696,  4698,  4700,  4702,  4704,  4706,  4708,  4710,  4712,  4714,
-    4716,  4718,  4720,  4722,  4724,  4726,  4728,  4730,  4732,  4734,
-    4736,  4738,  4740,  4742,  4744,  4746,  4748,  4750,  4752,  4754,
-    4756,  4758,  4760,  4762,  4764,  4766,  4768,  4770,  4772,  4774,
-    4776,  4778,  4780,  4782,  4784,  4786,  4788,  4790,  4792,  4794,
-    4796,  4798,  4800,  4802,  4804,  4806,  4808,  4810,  4812,  4814,
-    4816,  4818,  4820,  4822,  4824,  4826,  4828,  4830,  4832,  4834,
-    4836,  4838,  4840,  4842,  4844,  4846,  4848,  4850,  4852,  4854,
-    4856,  4858,  4860,  4862,  4864,  4866,  4868,  4870,  4872,  4874,
-    4876,  4878,  4880,  4882,  4884,  4886,  4888,  4890,  4892,  4894,
-    4896,  4898,  4900,  4902,  4904,  4906,  4908,  4910,  4912,  4914,
-    4916,  4918,  4920,  4922,  4924,  4926,  4928,  4930,  4932,  4934,
-    4936,  4938,  4940,  4942,  4944,  4946,  4948,  4950,  4952,  4954,
-    4956,  4958,  4960,  4962,  4964,  4966,  4968,  4970,  4972,  4974,
-    4976,  4978,  4980,  4982,  4984,  4986,  4988,  4990,  4992,  4994,
-    4996,  4998,  5000,  5002,  5004,  5006,  5008,  5010,  5012,  5014,
-    5016,  5018,  5020,  5022,  5024,  5026,  5028,  5030,  5032,  5034,
-    5036,  5038,  5040,  5042,  5044,  5046,  5048,  5050,  5052,  5054,
-    5056,  5058,  5060,  5062,  5064,  5066,  5068,  5070,  5072,  5074,
-    5076,  5078,  5080,  5082,  5084,  5086,  5088,  5090,  5092,  5094,
-    5096,  5098,  5100,  5102,  5104,  5106,  5108,  5110,  5112,  5114,
-    5116,  5118,  5120,  5122,  5124,  5126,  5128,  5130,  5132,  5134,
-    5136,  5138,  5140,  5142,  5144,  5146,  5148,  5150,  5152,  5154,
-    5156,  5158,  5160,  5162,  5164,  5166,  5168,  5170,  5172,  5174,
-    5176,  5178,  5180,  5182,  5184,  5186,  5188,  5190,  5192,  5194,
-    5196,  5198,  5200,  5202,  5204,  5206,  5208,  5210,  5212,  5214,
-    5216,  5218,  5220,  5222,  5224,  5226,  5228,  5230,  5232,  5234,
-    5236,  5238,  5240,  5242,  5244,  5246,  5248,  5250,  5252,  5254,
-    5256,  5258,  5260,  5262,  5264,  5266,  5268,  5270,  5272,  5274,
-    5276,  5278,  5280,  5282,  5284,  5286,  5288,  5290,  5292,  5294,
-    5296,  5298,  5300,  5302,  5304,  5306,  5308,  5310,  5312,  5314,
-    5316,  5318,  5320,  5322,  5324,  5326,  5328,  5330,  5332,  5334,
-    5336,  5338,  5340,  5342,  5344,  5346,  5348,  5350,  5352,  5354,
-    5356,  5358,  5360,  5362,  5364,  5366,  5368,  5370,  5372,  5374,
-    5376,  5378,  5380,  5382,  5384,  5386,  5388,  5390,  5392,  5394,
-    5396,  5398,  5400,  5402,  5404,  5406,  5408,  5410,  5412,  5414,
-    5416,  5418,  5420,  5422,  5424,  5426,  5428,  5430,  5432,  5434,
-    5436,  5438,  5440,  5442,  5444,  5446,  5448,  5450,  5452,  5454,
-    5456,  5458,  5460,  5462,  5464,  5466,  5468,  5470,  5472,  5474,
-    5476,  5478,  5480,  5482,  5484,  5486,  5488,  5490,  5492,  5494,
-    5496,  5498,  5500,  5502,  5504,  5506,  5508,  5510,  5512,  5514,
-    5516,  5518,  5520,  5522,  5524,  5526,  5528,  5530
-};
-
-/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
-static const yytype_int16 yyrhs[] =
-{
-     509,     0,    -1,   510,    -1,   510,   501,   511,    -1,   511,
-      -1,   851,    -1,   551,    -1,   512,    -1,   883,    -1,   890,
-      -1,   852,    -1,   619,    -1,   893,    -1,   615,    -1,   841,
-      -1,   547,    -1,   560,    -1,   545,    -1,   523,    -1,   879,
-      -1,   608,    -1,   549,    -1,   855,    -1,   853,    -1,   854,
-      -1,   844,    -1,   526,    -1,   872,    -1,   546,    -1,   838,
-      -1,   524,    -1,   636,    -1,   558,    -1,   618,    -1,   874,
-      -1,   884,    -1,   866,    -1,   887,    -1,   891,    -1,    -1,
-      30,   405,   705,   520,    -1,    30,   405,   189,   151,   705,
-     520,    -1,    30,   199,   818,   520,    -1,    30,   199,   189,
-     151,   818,   520,    -1,    30,   369,   818,   520,    -1,    30,
-     369,   189,   151,   818,   520,    -1,    30,   452,   818,   520,
-      -1,    30,   452,   189,   151,   818,   520,    -1,   515,    -1,
-     513,   515,    -1,   375,   116,   748,    -1,   136,   116,    -1,
-     347,    -1,   347,   553,   554,    -1,   375,   555,    -1,   375,
-     174,   607,    -1,   519,    -1,   516,   502,   519,    -1,    24,
-     587,    -1,    24,   189,   271,   151,   587,    -1,    24,    76,
-     587,    -1,    24,    76,   189,   271,   151,   587,    -1,    30,
-     525,   827,   514,    -1,    30,   525,   827,   136,   271,   276,
-      -1,    30,   525,   827,   375,   271,   276,    -1,    30,   525,
-     827,   375,   391,   557,    -1,    30,   525,   827,   375,   575,
-      -1,    30,   525,   827,   345,   575,    -1,    30,   525,   827,
-     375,   394,   827,    -1,    30,   525,   827,    24,   174,   607,
-      37,   188,   563,    -1,    30,   525,   827,   513,    -1,    30,
-     525,   827,   136,   188,    -1,    30,   525,   827,   136,   188,
-     189,   151,    -1,   136,   525,   189,   151,   827,   612,    -1,
-     136,   525,   827,   612,    -1,    30,   525,   827,   522,   427,
-     718,   714,   518,    -1,    30,   525,   827,   521,    -1,    24,
-     577,    -1,    30,    87,   821,   561,    -1,   443,    87,   821,
-      -1,   136,    87,   189,   151,   821,   612,    -1,   136,    87,
-     821,   612,    -1,   375,   243,    -1,   375,   436,    -1,   375,
-     575,    -1,   345,   575,    -1,   521,    -1,   440,   748,    -1,
-      -1,   571,    -1,   375,   571,    -1,    24,   571,    -1,   136,
-     585,    -1,   517,    -1,   520,   502,   517,    -1,   290,   498,
-     516,   499,    -1,   375,   108,    -1,   375,    -1,    -1,   112,
-     821,    -1,   112,   316,   821,    -1,   112,    28,    -1,   112,
-     316,    28,    -1,    30,   361,   821,   341,   416,   821,    -1,
-      30,   405,   705,   341,   416,   821,    -1,    30,   405,   189,
-     151,   705,   341,   416,   821,    -1,    30,   369,   818,   341,
-     416,   821,    -1,    30,   369,   189,   151,   818,   341,   416,
-     821,    -1,    30,   452,   818,   341,   416,   821,    -1,    30,
-     452,   189,   151,   818,   341,   416,   821,    -1,    30,   199,
-     818,   341,   416,   821,    -1,    30,   199,   189,   151,   818,
-     341,   416,   821,    -1,    30,   405,   705,   341,   525,   821,
-     416,   821,    -1,    30,   405,   189,   151,   705,   341,   525,
-     821,   416,   821,    -1,    30,   405,   705,   341,    87,   821,
-     416,   821,    -1,    30,   405,   189,   151,   705,   341,    87,
-     821,   416,   821,    -1,    76,    -1,    -1,   530,   209,   216,
-     528,   527,   533,   535,    -1,   636,    -1,   299,   536,   445,
-     636,    -1,   498,   540,   499,   636,    -1,   498,   540,   499,
-     299,   536,   445,   636,    -1,   116,   446,    -1,   818,    -1,
-     818,    37,   827,    -1,   498,   543,   499,   711,    -1,   286,
-      87,   821,    -1,    -1,   641,    -1,    -1,   827,   805,    -1,
-     544,   487,   748,    -1,   498,   537,   499,   487,   748,    -1,
-     286,    85,   529,   132,   438,   375,   542,   711,    -1,   286,
-      85,   529,   132,   272,    -1,    -1,   827,   538,   539,   655,
-     656,    -1,   753,   538,   539,   655,   656,    -1,   498,   748,
-     499,   538,   539,   655,   656,    -1,   349,   808,    -1,    -1,
-     439,    -1,   404,    -1,   544,    -1,   537,   502,   544,    -1,
-      74,   832,    -1,    -1,   832,    -1,    -1,   531,    -1,   540,
-     502,   531,    -1,   532,    -1,   541,   502,   532,    -1,   541,
-      -1,   541,   502,    -1,   534,    -1,   543,   502,   534,    -1,
-     827,   805,    -1,    94,   427,   832,    37,   718,    -1,   313,
-     827,    -1,   313,   827,   487,   871,    -1,   313,   827,   498,
-     783,   499,    -1,    94,   606,   369,   818,   548,    -1,    94,
-     606,   369,   189,   271,   151,   818,   548,    -1,   552,    -1,
-      -1,   150,   821,   550,    -1,    94,   606,   405,   895,    37,
-     150,   821,   550,   894,    -1,    94,   606,   405,   189,   271,
-     151,   895,    37,   150,   821,   550,   894,    -1,   498,   781,
-     499,    -1,    -1,    30,   369,   818,   552,    -1,    30,   369,
-     189,   151,   818,   552,    -1,   555,    -1,   552,   555,    -1,
-     460,    -1,   484,    -1,    -1,     4,    -1,   489,     4,    -1,
-     490,     4,    -1,   557,    -1,    37,   720,    -1,    56,   554,
-      -1,   107,    -1,   269,   107,    -1,   198,   556,   554,    -1,
-     249,   554,    -1,   257,   554,    -1,   269,   249,    -1,   269,
-     257,    -1,   300,    55,   832,    -1,   369,   262,   832,    -1,
-     389,   553,   554,    -1,   347,    -1,   347,   553,   554,    -1,
-      55,    -1,    -1,   825,    -1,   489,   825,    -1,   490,   825,
-      -1,    20,   559,    -1,    48,   559,    -1,   389,   559,    -1,
-      80,   559,    -1,   142,   559,    -1,   354,   559,    -1,   463,
-      -1,   418,    -1,    -1,    94,   606,   405,   818,   498,   593,
-     499,   582,   574,    -1,    94,   606,   405,   189,   271,   151,
-     818,   498,   593,   499,   582,   574,    -1,    94,   291,   343,
-     606,   405,   818,   498,   593,   499,   582,   574,    -1,    -1,
-     561,   586,    -1,   601,    -1,   902,    -1,   777,    -1,   554,
-      -1,   826,    -1,   270,    -1,   498,   552,   499,    -1,    -1,
-     826,    -1,   269,    23,    -1,   348,    -1,    59,    -1,   375,
-     276,    -1,   375,   116,    -1,    87,   821,   567,    -1,   567,
-      -1,   581,    -1,    74,   832,    -1,   271,   276,    -1,   276,
-      -1,   433,   592,    -1,   319,   223,   592,    -1,    68,   498,
-     748,   499,   576,    -1,   440,    82,   821,    -1,   116,   749,
-      -1,   335,   818,   595,   604,   573,    -1,   454,    -1,   395,
-      -1,   568,    -1,    -1,   174,   607,    37,   188,   563,    -1,
-     174,   607,    37,   498,   748,   499,   569,    -1,    37,   498,
-     748,   499,   569,    -1,   585,   564,    -1,   286,   438,   565,
-      -1,   572,    -1,   597,    -1,   572,   597,    -1,   597,   572,
-      -1,    -1,   286,    80,   136,    -1,   286,    80,   121,   357,
-      -1,   286,    80,   318,   357,    -1,    -1,   498,   579,   499,
-      -1,   269,   201,    -1,    -1,    87,   821,   602,    -1,   602,
-      -1,    79,    -1,    88,    -1,   117,    -1,   188,    -1,   200,
-      -1,   391,    -1,   394,    -1,    28,    -1,   598,    -1,   579,
-     502,   598,    -1,   440,   199,   589,    -1,   118,    -1,   271,
-     118,    -1,   203,   119,    -1,   203,   192,    -1,   460,   575,
-      -1,   460,   284,    -1,   462,   284,    -1,    -1,   498,   588,
-     499,    -1,   584,   197,   578,    -1,   584,   148,   578,    -1,
-      -1,   836,    -1,   271,   118,    -1,   118,    -1,   203,   192,
-      -1,   203,   119,    -1,   271,   442,    -1,   269,   201,    -1,
-     827,   718,   596,    -1,   827,   717,   570,   596,    -1,   591,
-      -1,   588,   502,   591,    -1,   827,    -1,   587,    -1,   605,
-      -1,   577,    -1,   836,   487,   562,    -1,   836,    -1,   460,
-     583,    -1,    -1,   603,    -1,   603,   502,    -1,    -1,   827,
-      -1,   498,   599,   499,    -1,    -1,   596,   566,    -1,    -1,
-     286,   121,   565,    -1,   836,   487,   562,    -1,   836,    -1,
-     836,   500,   836,   487,   562,    -1,   836,   500,   836,    -1,
-     594,    -1,   599,   502,   594,    -1,   599,    -1,   599,   502,
-      -1,   718,    -1,   829,   833,   493,   427,    -1,   376,   829,
-     833,   493,   427,    -1,    68,   498,   748,   499,   561,    -1,
-     433,   498,   600,   499,   592,   561,    -1,   433,   580,   561,
-      -1,   319,   223,   498,   600,   499,   592,   561,    -1,   319,
-     223,   580,   561,    -1,   167,   223,   498,   600,   499,   335,
-     818,   595,   604,   573,   561,    -1,   590,    -1,   603,   502,
-     590,    -1,   247,   171,    -1,   247,   304,    -1,   247,   381,
-      -1,    -1,   233,   818,   584,    -1,   411,    -1,   409,    -1,
-     237,   411,    -1,   237,   409,    -1,   176,   411,    -1,   176,
-     409,    -1,   436,    -1,    -1,    31,    -1,    55,   116,    -1,
-     136,   609,   189,   151,   611,   612,    -1,   136,   609,   611,
-     612,    -1,   136,   610,   189,   151,   819,   612,    -1,   136,
-     610,   819,   612,    -1,   136,   613,   821,   286,   832,   612,
-      -1,   136,   613,   189,   151,   821,   286,   832,   612,    -1,
-     136,   427,   614,   612,    -1,   136,   427,   189,   151,   614,
-     612,    -1,   405,    -1,   369,    -1,   172,    -1,   244,    -1,
-     244,   405,    -1,   452,    -1,   248,   452,    -1,   199,    -1,
-     167,   405,    -1,    75,    -1,    91,    -1,   391,    -1,   412,
-     364,   303,    -1,   412,   364,   128,    -1,   412,   364,   410,
-      -1,   412,   364,    84,    -1,    22,   250,    -1,   145,   421,
-      -1,   155,    -1,   167,   108,   464,    -1,   325,    -1,   361,
-      -1,   372,    -1,   832,    -1,   611,   502,   832,    -1,    59,
-      -1,   348,    -1,    -1,   311,    -1,   358,    -1,   421,    -1,
-     718,    -1,   614,   502,   718,    -1,    94,   606,   616,   818,
-     617,    37,   405,   636,    -1,    94,   606,   616,   818,   617,
-      37,   748,    -1,   172,    -1,   244,    -1,   498,   499,    -1,
-     498,   783,   499,    -1,   530,   438,   880,   375,   542,   694,
-     881,   535,    -1,    92,   631,   818,   595,   629,   620,   625,
-     634,   621,   553,   626,    -1,    92,   498,   840,   499,   416,
-     625,   634,   553,   626,    -1,   170,    -1,   416,    -1,   623,
-     123,   826,    -1,    -1,   633,    -1,   622,   502,   633,    -1,
-     440,    -1,    -1,    37,    -1,    -1,   324,    -1,    -1,   630,
-      -1,   498,   635,   499,    -1,   863,    -1,   554,    -1,   491,
-      -1,   498,   622,   499,    -1,    -1,   836,   627,    -1,   460,
-     284,    -1,    -1,   630,   632,    -1,    -1,    51,    -1,    -1,
-      51,    -1,   284,    -1,   169,    -1,   122,   624,   826,    -1,
-     276,   624,   826,    -1,    96,    -1,   184,    -1,   327,   624,
-     826,    -1,   144,   624,   826,    -1,   166,   327,   599,    -1,
-     166,   327,   491,    -1,   166,   271,   276,   599,    -1,   166,
-     276,   599,    -1,   140,   826,    -1,   863,    -1,   826,    -1,
-     392,    -1,   393,    -1,   628,    -1,   635,   502,   628,    -1,
-     638,    -1,   637,    -1,   498,   638,   499,    -1,   498,   637,
-     499,    -1,   640,    -1,   639,   652,    -1,   639,   651,   685,
-     658,    -1,   639,   651,   657,   686,    -1,   641,   639,    -1,
-     641,   639,   652,    -1,   641,   639,   651,   685,   658,    -1,
-     641,   639,   651,   657,   686,    -1,   640,    -1,   637,    -1,
-     368,   649,   807,   644,   694,   711,   674,   683,   758,   684,
-     662,    -1,   368,   648,   809,   644,   694,   711,   674,   683,
-     758,   684,   662,    -1,   693,    -1,   405,   705,    -1,   639,
-     432,   647,   639,    -1,   639,   214,   647,   639,    -1,   639,
-     146,   647,   639,    -1,   460,   642,    -1,   484,   642,    -1,
-     460,   333,   642,    -1,   643,    -1,   642,   502,   643,    -1,
-     821,   834,    37,   498,   840,   499,    -1,   216,   645,    -1,
-      -1,   411,   646,   818,    -1,   409,   646,   818,    -1,   237,
-     411,   646,   818,    -1,   237,   409,   646,   818,    -1,   176,
-     411,   646,   818,    -1,   176,   409,   646,   818,    -1,   436,
-     646,   818,    -1,   405,   818,    -1,   818,    -1,   405,    -1,
-      -1,    28,    -1,   131,    -1,    -1,   131,    -1,   131,   286,
-     498,   781,   499,    -1,    28,    -1,    -1,   190,   278,    -1,
-     346,   278,    -1,    -1,   652,    -1,    -1,   292,    55,   653,
-      -1,   292,    55,    28,   655,   656,    -1,   292,    55,   491,
-     655,   656,    -1,   654,    -1,   653,   502,   654,    -1,   748,
-     440,   777,   656,    -1,   748,   655,   656,    -1,    38,    -1,
-     125,    -1,    -1,   483,   162,    -1,   483,   227,    -1,    -1,
-     659,   660,    -1,   660,   659,    -1,   659,    -1,   660,    -1,
-     657,    -1,    -1,   234,   668,    -1,   234,   668,   502,   669,
-      -1,   160,   673,   670,   672,   287,    -1,   160,   673,   672,
-     287,    -1,   283,   669,    -1,   283,   670,   672,    -1,     4,
-     493,    -1,     9,   493,    -1,     4,   308,    -1,     9,   308,
-      -1,     9,    -1,     9,   357,    -1,   440,   359,   664,    -1,
-      -1,   827,    -1,    -1,   663,   498,   661,   499,   667,    -1,
-     661,    -1,   661,   498,   827,   499,    -1,   661,   498,   827,
-     502,     9,   499,    -1,   407,   664,    -1,   665,    -1,    -1,
-     342,   498,     9,   499,    -1,    -1,   748,    -1,    28,    -1,
-     748,   493,    -1,     4,   308,    -1,     9,   308,    -1,   748,
-      -1,   750,    -1,   489,   671,    -1,   490,   671,    -1,   825,
-      -1,     4,    -1,   356,    -1,   357,    -1,   162,    -1,   268,
-      -1,   179,    55,   676,    -1,   179,    55,    28,    -1,   179,
-      55,   491,    -1,    -1,   677,    -1,   675,   502,   677,    -1,
-     675,    -1,   675,   502,    -1,   748,    -1,   678,    -1,   680,
-      -1,   679,    -1,   681,    -1,   498,   499,    -1,   355,   498,
-     781,   499,    -1,    97,   498,   781,   499,    -1,   180,   377,
-     498,   676,   499,    -1,   180,    -1,   181,    -1,   183,   748,
-      -1,    -1,   326,   748,    -1,    -1,   687,    -1,   165,   329,
-     287,    -1,   685,    -1,    -1,   688,    -1,   687,   688,    -1,
-     689,   690,   691,    -1,   165,   438,    -1,   165,   269,   223,
-     438,    -1,   165,   378,    -1,   165,   223,   378,    -1,   281,
-     817,    -1,    -1,   275,    -1,   382,   242,    -1,    -1,   446,
-     498,   781,   499,    -1,   692,   502,   498,   781,   499,    -1,
-     692,    -1,   692,   502,    -1,   170,   696,    -1,    -1,   697,
-      -1,   695,   502,   697,    -1,   695,    -1,   695,   502,    -1,
-     705,   700,   666,    -1,   706,   701,   666,    -1,   228,   706,
-     701,    -1,   637,   700,   666,    -1,   228,   637,   700,    -1,
-     698,    -1,   498,   698,   499,   699,    -1,   498,   698,   499,
-      -1,   697,    95,   221,   697,    -1,   697,   702,   221,   697,
-     704,    -1,   697,   221,   697,   704,    -1,   697,   265,   702,
-     221,   697,    -1,   697,   265,   221,   697,    -1,    37,   827,
-     498,   820,   499,    -1,    37,   828,    -1,   827,   498,   820,
-     499,    -1,   827,    -1,   699,    -1,    -1,   699,    -1,    37,
-     498,   712,   499,    -1,    37,   827,   498,   712,   499,    -1,
-     827,   498,   712,   499,    -1,    -1,   171,   703,    -1,   231,
-     703,    -1,   352,   703,    -1,   205,    -1,   295,    -1,    -1,
-     440,   498,   820,   499,    -1,   286,   748,    -1,   818,    -1,
-     818,   491,    -1,   287,   818,    -1,   287,   498,   818,   499,
-      -1,   753,   710,    -1,   357,   170,   498,   708,   499,   710,
-      -1,   753,   709,    -1,   707,    -1,   708,   502,   707,    -1,
-      37,   498,   712,   499,    -1,    -1,   484,   293,    -1,    -1,
-     457,   748,    -1,    -1,   713,    -1,   712,   502,   713,    -1,
-     827,   718,   714,    -1,    74,   832,    -1,    -1,   827,   718,
-      -1,   715,   502,   827,   718,    -1,   356,    -1,   398,    -1,
-     718,    -1,    -1,   720,   719,    -1,   376,   720,   719,    -1,
-     720,    36,   496,   825,   497,    -1,   376,   720,    36,   496,
-     825,   497,    -1,   720,    36,    -1,   376,   720,    36,    -1,
-     716,   498,   715,   499,   719,    -1,   245,   498,   785,   499,
-     719,    -1,   719,   496,   497,    -1,   719,   496,   825,   497,
-      -1,    -1,   722,    -1,   724,    -1,   726,    -1,   730,    -1,
-     736,    -1,   737,   747,    -1,   737,   498,   825,   499,    -1,
-     724,    -1,   727,    -1,   731,    -1,   736,    -1,   831,   723,
-      -1,   498,   782,   499,    -1,    -1,   212,    -1,   213,    -1,
-     383,    -1,    50,    -1,   330,    -1,   163,   725,    -1,   135,
-     315,    -1,   114,   723,    -1,   113,   723,    -1,   279,   723,
-      -1,    53,    -1,   498,   825,   499,    -1,    -1,   728,    -1,
-     729,    -1,   728,    -1,   729,    -1,    52,   735,   498,   781,
-     499,    -1,    52,   735,    -1,   732,    -1,   733,    -1,   732,
-      -1,   733,    -1,   734,   498,   825,   499,    -1,   734,    -1,
-      66,   735,    -1,    65,   735,    -1,   447,    -1,   264,    66,
-     735,    -1,   264,    65,   735,    -1,   266,   735,    -1,   449,
-      -1,    -1,   415,   498,   825,   499,   738,    -1,   415,   738,
-      -1,   414,   498,   825,   499,   738,    -1,   414,   738,    -1,
-     215,    -1,   484,   414,   481,    -1,   462,   414,   481,    -1,
-      -1,   478,    -1,   479,    -1,   259,    -1,   260,    -1,   110,
-      -1,   111,    -1,   186,    -1,   187,    -1,   255,    -1,   256,
-      -1,   365,    -1,   366,    -1,   253,    -1,   254,    -1,   251,
-      -1,   252,    -1,   739,    -1,   740,    -1,   741,    -1,   742,
-      -1,   743,    -1,   744,    -1,   745,    -1,   746,    -1,   739,
-     416,   740,    -1,   741,   416,   742,    -1,   741,   416,   743,
-      -1,   741,   416,   744,    -1,   742,   416,   743,    -1,   742,
-     416,   744,    -1,   743,   416,   744,    -1,    -1,   750,    -1,
-     748,    11,   718,    -1,   748,    74,   832,    -1,   748,    42,
-     414,   481,   748,    -1,   489,   748,    -1,   490,   748,    -1,
-     748,   489,   748,    -1,   748,   490,   748,    -1,   748,   491,
-     748,    -1,   748,   492,   748,    -1,   748,   493,   748,    -1,
-     748,   494,   748,    -1,   748,    16,   748,    -1,   748,   485,
-     748,    -1,   748,   486,   748,    -1,   748,   487,   748,    -1,
-     748,    17,   748,    -1,   748,    18,   748,    -1,   748,    19,
-     748,    -1,   748,   776,   748,    -1,   776,   748,    -1,   748,
-     776,    -1,   748,    34,   748,    -1,   748,   291,   748,    -1,
-     271,   748,    -1,   482,   748,    -1,   748,   175,   748,    -1,
-     748,   233,   748,    -1,   748,   233,   748,   144,   748,    -1,
-     748,   482,   233,   748,    -1,   748,   482,   233,   748,   144,
-     748,    -1,   748,   191,   748,    -1,   748,   191,   748,   144,
-     748,    -1,   748,   482,   191,   748,    -1,   748,   482,   191,
-     748,   144,   748,    -1,   748,   380,   416,   748,    -1,   748,
-     380,   416,   748,   144,   748,    -1,   748,   482,   380,   416,
-     748,    -1,   748,   482,   380,   416,   748,   144,   748,    -1,
-     748,   218,   276,    -1,   748,   219,    -1,   748,   218,   271,
-     276,    -1,   748,   271,   276,    -1,   748,   274,    -1,   769,
-      -1,   503,   772,   504,    -1,   496,   782,   497,    -1,   748,
-      15,   748,    -1,   769,   297,   769,    -1,   748,   218,   423,
-      -1,   748,   218,   271,   423,    -1,   748,   218,   158,    -1,
-     748,   218,   271,   158,    -1,   748,   218,   434,    -1,   748,
-     218,   271,   434,    -1,   748,   218,   131,   170,   748,    -1,
-     748,   218,   271,   131,   170,   748,    -1,   748,   218,   281,
-     498,   785,   499,    -1,   748,   218,   271,   281,   498,   785,
-     499,    -1,   748,    49,   806,   749,    34,   748,    -1,   748,
-     482,    49,   806,   749,    34,   748,    -1,   748,    49,   402,
-     749,    34,   748,    -1,   748,   482,    49,   402,   749,    34,
-     748,    -1,   748,   196,   795,    -1,   748,   482,   196,   795,
-      -1,   748,   778,   773,   637,    -1,   748,   778,   773,   498,
-     748,   499,    -1,   116,    -1,    36,   496,   782,   497,    -1,
-     750,    -1,   749,    11,   718,    -1,   489,   749,    -1,   490,
-     749,    -1,   749,   489,   749,    -1,   749,   490,   749,    -1,
-     749,   491,   749,    -1,   749,   492,   749,    -1,   749,   493,
-     749,    -1,   749,   494,   749,    -1,   749,    16,   749,    -1,
-     749,   485,   749,    -1,   749,   486,   749,    -1,   749,   487,
-     749,    -1,   749,    17,   749,    -1,   749,    18,   749,    -1,
-     749,    19,   749,    -1,   749,   776,   749,    -1,   776,   749,
-      -1,   749,   776,    -1,   749,   218,   131,   170,   749,    -1,
-     749,   218,   271,   131,   170,   749,    -1,   749,   218,   281,
-     498,   785,   499,    -1,   749,   218,   271,   281,   498,   785,
-     499,    -1,   801,    -1,   824,    -1,   505,     9,    -1,   506,
-     805,    -1,    10,   805,    -1,   498,   748,   499,   805,    -1,
-     796,    -1,   752,   805,    -1,   637,    -1,   637,   804,    -1,
-     151,   637,    -1,   682,   498,   781,   499,    -1,   823,   498,
-     499,    -1,   823,   498,   783,   651,   650,   499,    -1,   823,
-     498,   448,   784,   651,   650,   499,    -1,   823,   498,   783,
-     502,   448,   784,   651,   650,   499,    -1,   823,   498,    28,
-     783,   651,   650,   499,    -1,   823,   498,   131,   783,   651,
-     650,   499,    -1,   823,   498,   491,   499,    -1,   751,   755,
-     756,   757,   761,    -1,   754,    -1,   751,    -1,   754,    -1,
-      75,   165,   498,   748,   499,    -1,   100,    -1,   103,    -1,
-     103,   498,   825,   499,    -1,   104,    -1,   104,   498,   825,
-     499,    -1,   238,    -1,   238,   498,   825,   499,    -1,   239,
-      -1,   239,   498,   825,   499,    -1,   101,    -1,   105,    -1,
-     374,    -1,   439,    -1,    99,    -1,   102,    -1,    62,   498,
-     748,    37,   718,   499,    -1,   426,   498,   748,    37,   718,
-     499,    -1,   157,   498,   786,   499,    -1,   298,   498,   788,
-     499,    -1,   312,   498,   790,   499,    -1,   400,   498,   791,
-     499,    -1,   420,   498,   748,    37,   718,   499,    -1,   422,
-     498,    54,   794,   499,    -1,   422,   498,   229,   794,   499,
-      -1,   422,   498,   417,   794,   499,    -1,   422,   498,   794,
-     499,    -1,   277,   498,   748,   502,   748,   499,    -1,    73,
-     498,   781,   499,    -1,   461,   179,   498,   652,   499,    -1,
-      -1,   161,   498,   457,   748,   499,    -1,    -1,   154,    -1,
-      -1,   459,   759,    -1,    -1,   760,    -1,   759,   502,   760,
-      -1,   827,    37,   762,    -1,   296,   762,    -1,   296,   827,
-      -1,    -1,   498,   763,   764,   651,   765,   499,    -1,   827,
-      -1,    -1,   305,    55,   780,    -1,    -1,   328,   766,    -1,
-     357,   766,    -1,    -1,   767,    -1,    49,   767,    34,   767,
-      -1,   429,   314,    -1,   429,   164,    -1,    98,   356,    -1,
-     748,   314,    -1,   748,   164,    -1,   356,   498,   781,   499,
-      -1,   356,   498,   499,    -1,   768,    -1,   498,   780,   502,
-     748,   499,    -1,   828,   507,   748,    -1,   770,    -1,   771,
-     502,   770,    -1,   771,    -1,   771,   502,    -1,    35,    -1,
-     385,    -1,    28,    -1,     8,    -1,   775,    -1,   489,    -1,
-     490,    -1,   491,    -1,   492,    -1,   493,    -1,   494,    -1,
-      16,    -1,   485,    -1,   486,    -1,   487,    -1,    17,    -1,
-      18,    -1,    19,    -1,     8,    -1,   288,   498,   779,   499,
-      -1,   774,    -1,   288,   498,   779,   499,    -1,   774,    -1,
-     288,   498,   779,   499,    -1,   233,    -1,   482,   233,    -1,
-     175,    -1,   482,   175,    -1,   191,    -1,   482,   191,    -1,
-     774,    -1,   827,   500,   779,    -1,   748,    -1,   780,   502,
-     748,    -1,   780,    -1,   780,   502,    -1,   781,    -1,    -1,
-     784,    -1,   783,   502,   784,    -1,   748,    -1,   835,    13,
-     748,    -1,   835,    14,   748,    -1,   718,    -1,   785,   502,
-     718,    -1,   787,   170,   748,    -1,    -1,     3,    -1,   739,
-      -1,   740,    -1,   741,    -1,   742,    -1,   743,    -1,   744,
-      -1,   745,    -1,   746,    -1,   826,    -1,   748,   789,   792,
-     793,    -1,   748,   789,   792,    -1,   309,   748,    -1,   749,
-     196,   749,    -1,    -1,   748,   792,   793,    -1,   748,   793,
-     792,    -1,   748,   792,    -1,   748,   793,    -1,   780,    -1,
-      -1,   170,   748,    -1,   165,   748,    -1,   748,   170,   781,
-      -1,   170,   781,    -1,   781,    -1,   637,    -1,   498,   781,
-     499,    -1,    61,   800,   797,   799,   142,    -1,   798,    -1,
-     797,   798,    -1,   456,   748,   413,   748,    -1,   138,   748,
-      -1,    -1,   748,    -1,    -1,   827,    -1,   827,   804,    -1,
-     500,   822,    -1,   496,   748,   497,    -1,   496,   803,   507,
-     803,   497,    -1,   748,    -1,    -1,   802,    -1,   804,   802,
-      -1,    -1,   805,   802,    -1,    41,    -1,    -1,   809,    -1,
-      -1,   810,    -1,   808,   502,   810,    -1,   808,    -1,   808,
-     502,    -1,   748,    37,   837,    -1,   748,     3,    -1,   748,
-      -1,   491,   812,   816,    -1,   827,   500,   491,   812,   816,
-      -1,   147,   498,   820,   499,    -1,   147,   827,    -1,   811,
-      -1,    -1,   748,    37,   827,    -1,   813,    -1,   814,   502,
-     813,    -1,   814,    -1,   814,   502,    -1,   343,   498,   815,
-     499,    -1,   343,   813,    -1,    -1,   818,    -1,   817,   502,
-     818,    -1,   828,    -1,   827,   804,    -1,   821,    -1,   819,
-     502,   821,    -1,   819,    -1,   819,   502,    -1,   827,    -1,
-     836,    -1,   830,    -1,   827,   804,    -1,   825,    -1,     4,
-      -1,   826,   805,    -1,     6,    -1,     7,    -1,   823,   826,
-      -1,   823,   498,   783,   651,   650,   499,   826,    -1,   721,
-     826,    -1,   737,   498,   748,   499,   747,    -1,   737,   825,
-     747,    -1,   737,   826,   747,    -1,   423,    -1,   158,    -1,
-     276,    -1,     9,    -1,     5,    -1,     3,    -1,   896,    -1,
-     897,    -1,   827,    -1,     5,    -1,     3,    -1,   896,    -1,
-     901,    -1,     3,    -1,   896,    -1,   898,    -1,     3,    -1,
-     896,    -1,   899,    -1,   827,    -1,   827,   833,    -1,   500,
-     822,    -1,   833,   500,   822,    -1,   498,   819,   499,    -1,
-      -1,   829,    -1,     3,    -1,   900,    -1,   896,    -1,   902,
-      -1,   836,    -1,     5,    -1,   316,   821,   839,    37,   840,
-      -1,   498,   785,   499,    -1,    -1,   636,    -1,   526,    -1,
-     618,    -1,   879,    -1,    94,   361,   827,   842,    -1,    94,
-     361,   189,   271,   151,   827,   842,    -1,   842,   843,    -1,
-      -1,   560,    -1,   844,    -1,   547,    -1,   891,    -1,    94,
-     850,   199,   847,   848,   286,   818,   846,   498,   543,   499,
-     849,   711,    -1,    94,   850,   199,   847,   189,   271,   151,
-     589,   286,   818,   846,   498,   543,   499,   849,   711,    -1,
-     827,    -1,   440,   845,    -1,    -1,    83,    -1,    -1,   589,
-      -1,    -1,   460,   575,    -1,    -1,   433,    -1,    -1,    30,
-     405,   705,   375,   361,   821,    -1,    30,   405,   189,   151,
-     705,   375,   361,   821,    -1,    30,   369,   818,   375,   361,
-     821,    -1,    30,   369,   189,   151,   818,   375,   361,   821,
-      -1,    30,   452,   818,   375,   361,   821,    -1,    30,   452,
-     189,   151,   818,   375,   361,   821,    -1,   166,    69,    -1,
-      69,    -1,   153,   109,   826,   626,    -1,   195,   109,   826,
-      -1,   152,   858,    -1,   152,   862,   856,   858,    -1,   152,
-     450,   858,    -1,   152,   498,   861,   499,   858,    -1,   450,
-      -1,    -1,   863,    -1,   554,    -1,    -1,   636,    -1,   526,
-      -1,   618,    -1,   879,    -1,   893,    -1,     3,    -1,   896,
-      -1,   900,    -1,   859,    -1,   826,    -1,   864,    -1,   861,
-     502,   864,    -1,    33,    -1,    32,    -1,   423,    -1,   158,
-      -1,   286,    -1,   860,    -1,   865,   857,    -1,   859,    -1,
-     862,    -1,   375,   867,    -1,   375,   237,   867,    -1,   375,
-     373,   867,    -1,   375,   176,   867,    -1,   868,    -1,   889,
-     170,    98,    -1,   414,   481,   870,    -1,   361,   826,    -1,
-     889,   416,   871,    -1,   889,   487,   871,    -1,   889,   416,
-     116,    -1,   889,   487,   116,    -1,   863,    -1,   554,    -1,
-     826,    -1,     3,    -1,   737,   826,   747,    -1,   737,   498,
-     825,   499,   826,    -1,   554,    -1,   116,    -1,   237,    -1,
-     869,    -1,   871,   502,   869,    -1,   236,   873,    -1,   210,
-     873,    -1,   166,   210,   873,    -1,   826,    -1,   827,    -1,
-     441,   876,   878,   856,    -1,   441,   876,   878,   856,   818,
-      -1,   441,   876,   878,   856,   883,    -1,   441,   498,   877,
-     499,    -1,   441,   498,   877,   499,   818,   834,    -1,   862,
-      -1,   450,    -1,   169,    -1,   171,    -1,     3,    -1,   171,
-      -1,    -1,   875,    -1,   877,   502,   875,    -1,   169,    -1,
-      -1,   530,   121,   170,   880,   882,   881,   535,    -1,   705,
-      -1,   705,   827,    -1,   705,    37,   827,    -1,   457,   748,
-      -1,    -1,   440,   696,    -1,    -1,   862,   856,    -1,   862,
-     856,   818,   834,    -1,   345,   886,    -1,   889,    -1,    28,
-      -1,   885,    -1,   414,   481,    -1,   418,   220,   232,    -1,
-     888,   636,    -1,   401,   636,    -1,   401,   889,    -1,   888,
-     889,    -1,   888,   414,   481,    -1,   888,   418,   220,   232,
-      -1,   888,    28,    -1,   888,    -1,   379,    -1,   126,    -1,
-     827,    -1,   889,   500,   827,    -1,    57,   751,    -1,    94,
-     606,   452,   818,   595,   849,    37,   636,   892,    -1,    94,
-     291,   343,   606,   452,   818,   595,   849,    37,   636,   892,
-      -1,    94,   606,   333,   452,   818,   498,   599,   499,   849,
-      37,   636,   892,    -1,    94,   291,   343,   606,   333,   452,
-     818,   498,   599,   499,   849,    37,   636,   892,    -1,   460,
-      68,   289,    -1,   460,    60,    68,   289,    -1,   460,   237,
-      68,   289,    -1,    -1,    94,   606,   405,   895,    37,   636,
-     894,    -1,    94,   606,   405,   189,   271,   151,   895,    37,
-     636,   894,    -1,    94,   291,   343,   606,   405,   895,    37,
-     636,   894,    -1,   460,   108,    -1,   460,   269,   108,    -1,
-      -1,   818,   595,   582,   574,    -1,    20,    -1,    21,    -1,
-      22,    -1,    23,    -1,    24,    -1,    25,    -1,    26,    -1,
-      27,    -1,    29,    -1,    30,    -1,    31,    -1,    39,    -1,
-      40,    -1,    42,    -1,    43,    -1,    44,    -1,    46,    -1,
-      47,    -1,    48,    -1,    55,    -1,    56,    -1,    57,    -1,
-      58,    -1,    59,    -1,    60,    -1,    63,    -1,    64,    -1,
-      67,    -1,    69,    -1,    70,    -1,    71,    -1,    72,    -1,
-      77,    -1,    78,    -1,    79,    -1,    80,    -1,    81,    -1,
-      82,    -1,    84,    -1,    85,    -1,    86,    -1,    88,    -1,
-      89,    -1,    90,    -1,    91,    -1,    92,    -1,    93,    -1,
-      96,    -1,    97,    -1,    98,    -1,   106,    -1,   107,    -1,
-     108,    -1,   109,    -1,   110,    -1,   111,    -1,   112,    -1,
-     115,    -1,   117,    -1,   119,    -1,   120,    -1,   121,    -1,
-     122,    -1,   123,    -1,   124,    -1,   126,    -1,   127,    -1,
-     128,    -1,   129,    -1,   130,    -1,   133,    -1,   134,    -1,
-     135,    -1,   136,    -1,   137,    -1,   139,    -1,   140,    -1,
-     141,    -1,   143,    -1,   144,    -1,   145,    -1,   147,    -1,
-     148,    -1,   149,    -1,   150,    -1,   152,    -1,   153,    -1,
-     154,    -1,   155,    -1,   156,    -1,   159,    -1,   161,    -1,
-     162,    -1,   164,    -1,   166,    -1,   168,    -1,   172,    -1,
-     173,    -1,   176,    -1,   178,    -1,   182,    -1,   184,    -1,
-     185,    -1,   186,    -1,   187,    -1,   188,    -1,   189,    -1,
-     190,    -1,   192,    -1,   193,    -1,   194,    -1,   195,    -1,
-     197,    -1,   198,    -1,   199,    -1,   200,    -1,   201,    -1,
-     202,    -1,   204,    -1,   207,    -1,   208,    -1,   209,    -1,
-     210,    -1,   211,    -1,   217,    -1,   220,    -1,   222,    -1,
-     223,    -1,   224,    -1,   225,    -1,   226,    -1,   227,    -1,
-     230,    -1,   232,    -1,   235,    -1,   236,    -1,   237,    -1,
-     240,    -1,   241,    -1,   242,    -1,   243,    -1,   244,    -1,
-     246,    -1,   247,    -1,   248,    -1,   249,    -1,   250,    -1,
-     251,    -1,   252,    -1,   253,    -1,   254,    -1,   255,    -1,
-     256,    -1,   257,    -1,   258,    -1,   259,    -1,   260,    -1,
-     261,    -1,   262,    -1,   263,    -1,   267,    -1,   268,    -1,
-     269,    -1,   272,    -1,   273,    -1,   275,    -1,   278,    -1,
-     280,    -1,   281,    -1,   282,    -1,   284,    -1,   285,    -1,
-     288,    -1,   289,    -1,   290,    -1,   293,    -1,   296,    -1,
-     299,    -1,   300,    -1,   301,    -1,   302,    -1,   303,    -1,
-     304,    -1,   305,    -1,   306,    -1,   307,    -1,   308,    -1,
-     310,    -1,   311,    -1,   313,    -1,   314,    -1,   316,    -1,
-     317,    -1,   318,    -1,   320,    -1,   321,    -1,   322,    -1,
-     323,    -1,   324,    -1,   325,    -1,   327,    -1,   328,    -1,
-     329,    -1,   331,    -1,   332,    -1,   333,    -1,   334,    -1,
-     336,    -1,   337,    -1,   338,    -1,   339,    -1,   340,    -1,
-     341,    -1,   342,    -1,   343,    -1,   344,    -1,   345,    -1,
-     346,    -1,   347,    -1,   348,    -1,   350,    -1,   351,    -1,
-     353,    -1,   354,    -1,   355,    -1,   357,    -1,   358,    -1,
-     359,    -1,   360,    -1,   361,    -1,   362,    -1,   363,    -1,
-     364,    -1,   365,    -1,   366,    -1,   367,    -1,   369,    -1,
-     370,    -1,   371,    -1,   372,    -1,   373,    -1,   375,    -1,
-     377,    -1,   378,    -1,   379,    -1,   381,    -1,   382,    -1,
-     384,    -1,   386,    -1,   387,    -1,   388,    -1,   389,    -1,
-     390,    -1,   391,    -1,   392,    -1,   393,    -1,   394,    -1,
-     395,    -1,   396,    -1,   397,    -1,   399,    -1,   401,    -1,
-     403,    -1,   404,    -1,   406,    -1,   408,    -1,   409,    -1,
-     410,    -1,   411,    -1,   412,    -1,   418,    -1,   419,    -1,
-     421,    -1,   424,    -1,   425,    -1,   427,    -1,   428,    -1,
-     429,    -1,   430,    -1,   431,    -1,   434,    -1,   435,    -1,
-     436,    -1,   437,    -1,   438,    -1,   441,    -1,   442,    -1,
-     443,    -1,   444,    -1,   445,    -1,   449,    -1,   451,    -1,
-     452,    -1,   453,    -1,   454,    -1,   455,    -1,   458,    -1,
-     461,    -1,   462,    -1,   463,    -1,   464,    -1,   465,    -1,
-     466,    -1,   478,    -1,   479,    -1,   480,    -1,   481,    -1,
-      49,    -1,    50,    -1,    52,    -1,    53,    -1,    65,    -1,
-      66,    -1,    73,    -1,   113,    -1,   114,    -1,   151,    -1,
-     157,    -1,   163,    -1,   174,    -1,   180,    -1,   181,    -1,
-     206,    -1,   212,    -1,   213,    -1,   215,    -1,   245,    -1,
-     264,    -1,   266,    -1,   270,    -1,   277,    -1,   279,    -1,
-     294,    -1,   298,    -1,   312,    -1,   315,    -1,   330,    -1,
-     356,    -1,   376,    -1,   383,    -1,   398,    -1,   400,    -1,
-     414,    -1,   415,    -1,   420,    -1,   422,    -1,   426,    -1,
-     446,    -1,   447,    -1,   467,    -1,   468,    -1,   469,    -1,
-     470,    -1,   471,    -1,   472,    -1,   473,    -1,   474,    -1,
-     475,    -1,   476,    -1,   477,    -1,    45,    -1,    51,    -1,
-      75,    -1,    83,    -1,    95,    -1,    99,    -1,   100,    -1,
-     101,    -1,   102,    -1,   105,    -1,   169,    -1,   171,    -1,
-     174,    -1,   175,    -1,   191,    -1,   205,    -1,   218,    -1,
-     219,    -1,   221,    -1,   231,    -1,   233,    -1,   245,    -1,
-     265,    -1,   274,    -1,   295,    -1,   297,    -1,   352,    -1,
-     374,    -1,   380,    -1,   398,    -1,   407,    -1,   439,    -1,
-     450,    -1,    45,    -1,    51,    -1,    75,    -1,    83,    -1,
-      95,    -1,    99,    -1,   100,    -1,   101,    -1,   102,    -1,
-     105,    -1,   169,    -1,   171,    -1,   175,    -1,   191,    -1,
-     205,    -1,   218,    -1,   219,    -1,   221,    -1,   231,    -1,
-     233,    -1,   265,    -1,   274,    -1,   295,    -1,   297,    -1,
-     352,    -1,   374,    -1,   380,    -1,   407,    -1,   426,    -1,
-     439,    -1,   450,    -1,    45,    -1,    49,    -1,    50,    -1,
-      51,    -1,    52,    -1,    53,    -1,    66,    -1,    65,    -1,
-      73,    -1,    75,    -1,    83,    -1,    95,    -1,    99,    -1,
-     100,    -1,   101,    -1,   102,    -1,   105,    -1,   113,    -1,
-     114,    -1,   151,    -1,   157,    -1,   163,    -1,   169,    -1,
-     171,    -1,   174,    -1,   175,    -1,   180,    -1,   181,    -1,
-     191,    -1,   205,    -1,   206,    -1,   213,    -1,   215,    -1,
-     212,    -1,   218,    -1,   219,    -1,   221,    -1,   231,    -1,
-     233,    -1,   245,    -1,   264,    -1,   265,    -1,   266,    -1,
-     270,    -1,   274,    -1,   277,    -1,   279,    -1,   295,    -1,
-     294,    -1,   297,    -1,   298,    -1,   312,    -1,   315,    -1,
-     330,    -1,   352,    -1,   356,    -1,   374,    -1,   376,    -1,
-     380,    -1,   383,    -1,   398,    -1,   400,    -1,   407,    -1,
-     414,    -1,   415,    -1,   420,    -1,   422,    -1,   426,    -1,
-     439,    -1,   446,    -1,   447,    -1,   450,    -1,   467,    -1,
-     468,    -1,   469,    -1,   470,    -1,   471,    -1,   472,    -1,
-     473,    -1,   474,    -1,   475,    -1,   476,    -1,   477,    -1,
-      45,    -1,    51,    -1,    75,    -1,    83,    -1,    95,    -1,
-      99,    -1,   100,    -1,   101,    -1,   102,    -1,   105,    -1,
-     169,    -1,   171,    -1,   174,    -1,   175,    -1,   191,    -1,
-     205,    -1,   218,    -1,   219,    -1,   221,    -1,   231,    -1,
-     233,    -1,   245,    -1,   265,    -1,   274,    -1,   295,    -1,
-     297,    -1,   352,    -1,   374,    -1,   380,    -1,   398,    -1,
-     407,    -1,   426,    -1,   439,    -1,   450,    -1,    28,    -1,
-      32,    -1,    33,    -1,    34,    -1,    35,    -1,    36,    -1,
-      37,    -1,    38,    -1,    41,    -1,    54,    -1,    61,    -1,
-      62,    -1,    68,    -1,    74,    -1,    76,    -1,    87,    -1,
-      94,    -1,   103,    -1,   104,    -1,   116,    -1,   118,    -1,
-     125,    -1,   131,    -1,   132,    -1,   138,    -1,   142,    -1,
-     146,    -1,   158,    -1,   160,    -1,   165,    -1,   167,    -1,
-     170,    -1,   177,    -1,   179,    -1,   183,    -1,   196,    -1,
-     203,    -1,   214,    -1,   216,    -1,   228,    -1,   229,    -1,
-     234,    -1,   238,    -1,   239,    -1,   271,    -1,   276,    -1,
-     283,    -1,   286,    -1,   287,    -1,   291,    -1,   292,    -1,
-     309,    -1,   319,    -1,   326,    -1,   335,    -1,   349,    -1,
-     368,    -1,   385,    -1,   402,    -1,   405,    -1,   413,    -1,
-     416,    -1,   417,    -1,   423,    -1,   432,    -1,   433,    -1,
-     440,    -1,   448,    -1,   456,    -1,   457,    -1,   459,    -1,
-     460,    -1
-};
-
-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const yytype_uint16 yyrline[] =
-{
-       0,   466,   466,   482,   494,   503,   504,   505,   506,   507,
-     508,   509,   510,   511,   512,   513,   514,   515,   516,   517,
-     518,   519,   520,   521,   522,   523,   524,   525,   526,   527,
-     528,   529,   530,   531,   532,   533,   534,   535,   536,   538,
-       9,    18,    27,    36,    45,    54,    63,    72,    85,    87,
-      93,    94,    99,   103,   107,   118,   126,   130,   139,   148,
-     157,   166,   175,   184,   192,   200,   209,   218,   227,   236,
-     253,   262,   271,   280,   290,   303,   318,   327,   335,   350,
-     358,   368,   378,   385,   392,   400,   407,   418,   419,   424,
-     428,   433,   438,   446,   447,   452,   456,   457,   458,     7,
-      13,    19,    25,     6,    15,    25,    35,    45,    55,    65,
-      75,    85,    95,   106,   117,   127,   140,   141,     8,    21,
-      27,    34,    40,    47,    57,    61,    70,    79,    88,    95,
-      96,   101,   113,   118,   143,   153,   163,   169,   180,   191,
-     206,   207,   213,   214,   219,   220,   226,   227,   231,   232,
-     237,   239,   245,   246,   250,   251,   254,   255,   260,     7,
-       7,    14,    22,     9,    19,    32,    33,     7,    14,    31,
-      51,    52,     9,    17,    29,    30,    34,    35,    36,    41,
-      42,    43,    48,    52,    56,    60,    64,    68,    72,    76,
-      80,    84,    88,    92,    97,   101,   105,   112,   113,   117,
-     118,   119,     2,     9,    15,    21,    28,    35,    45,    46,
-      47,     7,    21,    36,    56,    57,    84,    85,    86,    87,
-      88,    89,    93,    94,    99,   104,   105,   106,   107,   108,
-     113,   120,   121,   122,   139,   146,   153,   163,   173,   185,
-     193,   202,   220,   221,   225,   226,   230,   239,   262,   276,
-     283,   288,   290,   292,   294,   297,   300,   301,   302,   303,
-     308,   312,   313,   318,   325,   330,   331,   332,   333,   334,
-     335,   336,   337,   343,   344,   348,   353,   360,   367,   374,
-     386,   387,   388,   389,   393,   398,   399,   400,   405,   410,
-     411,   412,   413,   414,   415,   420,   440,   469,   470,   474,
-     478,   479,   480,   484,   488,   496,   497,   502,   503,   504,
-     508,   516,   517,   522,   523,   527,   532,   536,   540,   545,
-     553,   554,   558,   559,   563,   564,   570,   581,   594,   608,
-     622,   636,   650,   673,   677,   684,   688,   696,   701,   708,
-     718,   719,   720,   721,   722,   729,   736,   737,   742,   743,
-       9,    19,    29,    39,    49,    59,    69,    79,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   113,   114,   115,   116,   117,   118,
-     119,   124,   125,   130,   131,   132,   137,   138,   139,   142,
-     143,     8,    20,    36,    37,    41,    45,     7,     1,    30,
-      53,    54,    59,    63,    68,    72,    80,    81,    85,    86,
-      91,    92,    96,    97,   102,   103,   104,   105,   106,   111,
-     119,   123,   128,   129,   134,   138,   143,   147,   151,   155,
-     159,   163,   167,   171,   175,   179,   183,   187,   191,   195,
-     203,   209,   210,   211,   216,   220,    47,    48,    52,    53,
-      68,    69,    76,    84,    92,   100,   108,   116,   127,   128,
-     155,   171,   188,   189,   208,   212,   216,   233,   240,   247,
-     257,   258,   261,   273,   284,   292,   297,   302,   307,   312,
-     320,   328,   333,   338,   345,   346,   350,   351,   352,   359,
-     360,   364,   365,   369,   370,   371,   375,   376,   380,   381,
-     391,   404,   405,   408,   417,   428,   429,   430,   433,   434,
-     435,   439,   440,   441,   442,   446,   447,   451,   453,   469,
-     471,   476,   479,   487,   491,   495,   499,   503,   507,   514,
-     519,   526,   527,   531,   535,   539,   543,   550,   557,   558,
-     563,   564,   568,   569,   574,   576,   578,   583,   603,   604,
-     606,   611,   612,   616,   617,   620,   621,   646,   647,   652,
-     657,   661,   662,   666,   667,   671,   672,   673,   674,   675,
-     679,   692,   699,   706,   713,   714,   718,   719,   723,   724,
-     728,   729,   733,   734,   738,   739,   743,   754,   755,   756,
-     757,   761,   762,   767,   768,   769,   778,   784,   793,   794,
-     807,   808,   812,   813,   817,   818,   824,   830,   838,   846,
-     855,   864,   868,   894,   898,   911,   925,   940,   952,   968,
-     974,   979,   985,   992,   993,  1001,  1005,  1009,  1015,  1022,
-    1027,  1028,  1029,  1030,  1034,  1035,  1047,  1048,  1053,  1060,
-    1067,  1074,  1106,  1117,  1130,  1135,  1136,  1139,  1140,  1143,
-    1144,  1149,  1150,  1155,  1159,  1165,  1186,  1194,  1207,  1210,
-    1214,  1214,  1217,  1218,  1220,  1225,  1232,  1237,  1243,  1248,
-    1254,  1260,  1269,  1271,  1274,  1278,  1279,  1280,  1281,  1282,
-    1283,  1288,  1308,  1309,  1310,  1311,  1322,  1336,  1337,  1343,
-    1348,  1353,  1358,  1363,  1368,  1373,  1378,  1384,  1390,  1396,
-    1403,  1425,  1434,  1438,  1446,  1450,  1458,  1470,  1491,  1495,
-    1501,  1505,  1518,  1526,  1536,  1538,  1540,  1542,  1544,  1546,
-    1551,  1552,  1559,  1568,  1576,  1585,  1596,  1604,  1605,  1606,
-    1610,  1610,  1613,  1613,  1616,  1616,  1619,  1619,  1622,  1622,
-    1625,  1625,  1628,  1628,  1631,  1631,  1634,  1636,  1638,  1640,
-    1642,  1644,  1646,  1648,  1650,  1655,  1660,  1666,  1673,  1678,
-    1684,  1690,  1721,  1723,  1725,  1733,  1748,  1750,  1752,  1754,
-    1756,  1758,  1760,  1762,  1764,  1766,  1768,  1770,  1772,  1774,
-    1776,  1779,  1781,  1783,  1786,  1788,  1790,  1792,  1795,  1800,
-    1805,  1812,  1817,  1824,  1829,  1836,  1841,  1849,  1857,  1865,
-    1873,  1891,  1899,  1907,  1915,  1923,  1931,  1935,  1939,  1943,
-    1951,  1967,  1975,  1983,  1991,  1999,  2007,  2015,  2019,  2023,
-    2027,  2031,  2039,  2047,  2055,  2063,  2083,  2105,  2116,  2123,
-    2137,  2153,  2155,  2157,  2159,  2161,  2163,  2165,  2167,  2169,
-    2171,  2173,  2175,  2177,  2179,  2181,  2183,  2185,  2187,  2189,
-    2191,  2193,  2197,  2201,  2205,  2219,  2220,  2221,  2228,  2240,
-    2255,  2267,  2269,  2281,  2292,  2316,  2327,  2336,  2340,  2347,
-    2355,  2363,  2374,  2382,  2410,  2446,  2457,  2458,  2465,  2471,
-    2475,  2479,  2483,  2487,  2491,  2495,  2499,  2503,  2507,  2511,
-    2515,  2519,  2523,  2527,  2531,  2533,  2535,  2539,  2548,  2553,
-    2560,  2575,  2582,  2586,  2590,  2594,  2598,  2612,  2613,  2617,
-    2618,  2622,  2623,  2630,  2631,  2635,  2636,  2641,  2649,  2651,
-    2665,  2668,  2695,  2696,  2699,  2700,  2711,  2717,  2724,  2733,
-    2750,  2795,  2803,  2811,  2819,  2827,  2848,  2849,  2852,  2853,
-    2857,  2867,  2868,  2872,  2873,  2877,  2878,  2879,  2882,  2883,
-    2886,  2887,  2888,  2889,  2890,  2891,  2892,  2893,  2894,  2895,
-    2896,  2897,  2898,  2901,  2903,  2908,  2910,  2915,  2917,  2919,
-    2921,  2923,  2925,  2927,  2929,  2943,  2945,  2949,  2953,  2960,
-    2965,  2972,  2977,  2985,  2989,  2995,  2999,  3008,  3019,  3020,
-    3024,  3028,  3035,  3036,  3037,  3038,  3039,  3040,  3041,  3042,
-    3043,  3044,  3054,  3058,  3065,  3072,  3073,  3089,  3093,  3098,
-    3102,  3117,  3122,  3126,  3129,  3132,  3133,  3134,  3137,  3144,
-    3154,  3168,  3169,  3173,  3184,  3185,  3188,  3189,  3192,  3196,
-    3203,  3207,  3215,  3226,  3227,  3231,  3232,  3236,  3237,  3240,
-    3241,  3251,  3252,  3256,  3257,  3261,  3262,  3265,  3281,  3289,
-    3297,  3312,  3330,  3331,  3334,  3335,  3338,  3342,  3343,  3347,
-    3348,  3351,  3352,  3353,  3363,  3364,  3375,  3379,  3406,  3408,
-    3414,  3415,  3418,  3420,  3430,  3433,  3444,  3448,  3452,  3464,
-    3468,  3477,  3484,  3522,  3526,  3530,  3534,  3538,  3542,  3546,
-    3552,  3553,  3569,  3570,  3571,  3574,  3575,  3581,  3582,  3583,
-    3586,  3587,  3588,  3591,  3592,  3593,  3596,  3597,  3600,  3602,
-    3607,  3608,  3611,  3619,  3620,  3621,  3622,  3625,  3626,     7,
-      18,    19,    23,    24,    25,    26,     7,    16,    34,    41,
-      46,    47,    48,    49,     8,    33,    62,    66,    67,    72,
-      73,    78,    79,    83,    84,    89,    90,     7,    16,    25,
-      34,    43,    52,     5,    11,     7,    20,     9,    16,    26,
-      33,    44,    45,    50,    51,    52,    57,    58,    59,    60,
-      61,    65,    66,    67,    72,    73,    78,    82,    90,    91,
-      96,    97,    98,   104,   109,   117,   118,    10,    16,    22,
-      28,    38,    39,    47,    58,    70,    78,    86,    93,   103,
-     105,   111,   115,   119,   134,   141,   142,   143,   147,   148,
-       7,    14,    20,    28,    29,     8,    22,    36,    48,    56,
-      70,    71,    72,    73,    74,    87,    88,    93,    94,    98,
-      99,     7,    21,    25,    32,    43,    44,    50,    51,     9,
-      19,     2,     7,    14,    24,    25,    32,     3,    10,    17,
-      24,    31,    38,    45,    52,    61,    61,    63,    64,     6,
-       8,    21,    34,    52,    74,    75,    76,    77,    11,    24,
-      37,    54,    55,    56,    61,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    75,    76,    76,    76,    76,    76,
-      76,    76,    76,    76,    76,    76,    76,    76,    76,    76,
-      76,    76,    76,    76,    76,    76,    76,    76,    76,    76,
-      76,    76,    76,    76,    76,    76,    76,    76,    77,    77,
-      77,    77,    77,    77,    77,    77,    77,    77,    77,    77,
-      77,    77,    77,    77,    77,    77,    77,    77,    77,    77,
-      77,    77,    77,    77,    77,    77,    77,    77,    77,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    78,    78,    78,    78,    78,    78,    78,    78,
-      78,    78,    79,    79,    79,    79,    79,    79,    79,    79,
-      79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
-      79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
-      79,    79,    79,    79,    79,    79,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80
-};
-#endif
-
-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
-static const char *const yytname[] =
-{
-  "$end", "error", "$undefined", "IDENT", "FCONST", "SCONST", "BCONST",
-  "XCONST", "Op", "ICONST", "PARAM", "TYPECAST", "DOT_DOT", "COLON_EQUALS",
-  "EQUALS_GREATER", "LAMBDA_ARROW", "POWER_OF", "LESS_EQUALS",
-  "GREATER_EQUALS", "NOT_EQUALS", "ABORT_P", "ABSOLUTE_P", "ACCESS",
-  "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE", "ALL", "ALSO", "ALTER",
-  "ALWAYS", "ANALYSE", "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC_P",
-  "ASSERTION", "ASSIGNMENT", "ASYMMETRIC", "AT", "ATTACH", "ATTRIBUTE",
-  "AUTHORIZATION", "BACKWARD", "BEFORE", "BEGIN_P", "BETWEEN", "BIGINT",
-  "BINARY", "BIT", "BOOLEAN_P", "BOTH", "BY", "CACHE", "CALL_P", "CALLED",
-  "CASCADE", "CASCADED", "CASE", "CAST", "CATALOG_P", "CHAIN", "CHAR_P",
-  "CHARACTER", "CHARACTERISTICS", "CHECK_P", "CHECKPOINT", "CLASS",
-  "CLOSE", "CLUSTER", "COALESCE", "COLLATE", "COLLATION", "COLUMN",
-  "COLUMNS", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "COMPRESSION",
-  "CONCURRENTLY", "CONFIGURATION", "CONFLICT", "CONNECTION", "CONSTRAINT",
-  "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P", "COPY", "COST",
-  "CREATE_P", "CROSS", "CSV", "CUBE", "CURRENT_P", "CURRENT_CATALOG",
-  "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_SCHEMA", "CURRENT_TIME",
-  "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "CYCLE", "DATA_P",
-  "DATABASE", "DAY_P", "DAYS_P", "DEALLOCATE", "DEC", "DECIMAL_P",
-  "DECLARE", "DEFAULT", "DEFAULTS", "DEFERRABLE", "DEFERRED", "DEFINER",
-  "DELETE_P", "DELIMITER", "DELIMITERS", "DEPENDS", "DESC_P", "DESCRIBE",
-  "DETACH", "DICTIONARY", "DISABLE_P", "DISCARD", "DISTINCT", "DO",
-  "DOCUMENT_P", "DOMAIN_P", "DOUBLE_P", "DROP", "EACH", "ELSE", "ENABLE_P",
-  "ENCODING", "ENCRYPTED", "END_P", "ENUM_P", "ESCAPE", "EVENT", "EXCEPT",
-  "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXISTS", "EXPLAIN",
-  "EXPORT_P", "EXPORT_STATE", "EXTENSION", "EXTERNAL", "EXTRACT",
-  "FALSE_P", "FAMILY", "FETCH", "FILTER", "FIRST_P", "FLOAT_P",
-  "FOLLOWING", "FOR", "FORCE", "FOREIGN", "FORWARD", "FREEZE", "FROM",
-  "FULL", "FUNCTION", "FUNCTIONS", "GENERATED", "GLOB", "GLOBAL", "GRANT",
-  "GRANTED", "GROUP_P", "GROUPING", "GROUPING_ID", "HANDLER", "HAVING",
-  "HEADER_P", "HOLD", "HOUR_P", "HOURS_P", "IDENTITY_P", "IF_P",
-  "IGNORE_P", "ILIKE", "IMMEDIATE", "IMMUTABLE", "IMPLICIT_P", "IMPORT_P",
-  "IN_P", "INCLUDING", "INCREMENT", "INDEX", "INDEXES", "INHERIT",
-  "INHERITS", "INITIALLY", "INLINE_P", "INNER_P", "INOUT", "INPUT_P",
-  "INSENSITIVE", "INSERT", "INSTALL", "INSTEAD", "INT_P", "INTEGER",
-  "INTERSECT", "INTERVAL", "INTO", "INVOKER", "IS", "ISNULL", "ISOLATION",
-  "JOIN", "JSON", "KEY", "LABEL", "LANGUAGE", "LARGE_P", "LAST_P",
-  "LATERAL_P", "LEADING", "LEAKPROOF", "LEFT", "LEVEL", "LIKE", "LIMIT",
-  "LISTEN", "LOAD", "LOCAL", "LOCALTIME", "LOCALTIMESTAMP", "LOCATION",
-  "LOCK_P", "LOCKED", "LOGGED", "MACRO", "MAP", "MAPPING", "MATCH",
-  "MATERIALIZED", "MAXVALUE", "METHOD", "MICROSECOND_P", "MICROSECONDS_P",
-  "MILLISECOND_P", "MILLISECONDS_P", "MINUTE_P", "MINUTES_P", "MINVALUE",
-  "MODE", "MONTH_P", "MONTHS_P", "MOVE", "NAME_P", "NAMES", "NATIONAL",
-  "NATURAL", "NCHAR", "NEW", "NEXT", "NO", "NONE", "NOT", "NOTHING",
-  "NOTIFY", "NOTNULL", "NOWAIT", "NULL_P", "NULLIF", "NULLS_P", "NUMERIC",
-  "OBJECT_P", "OF", "OFF", "OFFSET", "OIDS", "OLD", "ON", "ONLY",
-  "OPERATOR", "OPTION", "OPTIONS", "OR", "ORDER", "ORDINALITY", "OUT_P",
-  "OUTER_P", "OVER", "OVERLAPS", "OVERLAY", "OVERRIDING", "OWNED", "OWNER",
-  "PARALLEL", "PARSER", "PARTIAL", "PARTITION", "PASSING", "PASSWORD",
-  "PERCENT", "PLACING", "PLANS", "POLICY", "POSITION", "PRAGMA_P",
-  "PRECEDING", "PRECISION", "PREPARE", "PREPARED", "PRESERVE", "PRIMARY",
-  "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "PROGRAM",
-  "PUBLICATION", "QUALIFY", "QUOTE", "RANGE", "READ_P", "REAL", "REASSIGN",
-  "RECHECK", "RECURSIVE", "REF", "REFERENCES", "REFERENCING", "REFRESH",
-  "REINDEX", "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE", "REPLACE",
-  "REPLICA", "RESET", "RESPECT_P", "RESTART", "RESTRICT", "RETURNING",
-  "RETURNS", "REVOKE", "RIGHT", "ROLE", "ROLLBACK", "ROLLUP", "ROW",
-  "ROWS", "RULE", "SAMPLE", "SAVEPOINT", "SCHEMA", "SCHEMAS", "SCROLL",
-  "SEARCH", "SECOND_P", "SECONDS_P", "SECURITY", "SELECT", "SEQUENCE",
-  "SEQUENCES", "SERIALIZABLE", "SERVER", "SESSION", "SESSION_USER", "SET",
-  "SETOF", "SETS", "SHARE", "SHOW", "SIMILAR", "SIMPLE", "SKIP",
-  "SMALLINT", "SNAPSHOT", "SOME", "SQL_P", "STABLE", "STANDALONE_P",
-  "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT", "STORAGE",
-  "STORED", "STRICT_P", "STRIP_P", "STRUCT", "SUBSCRIPTION", "SUBSTRING",
-  "SUMMARIZE", "SYMMETRIC", "SYSID", "SYSTEM_P", "TABLE", "TABLES",
-  "TABLESAMPLE", "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P",
-  "THEN", "TIME", "TIMESTAMP", "TO", "TRAILING", "TRANSACTION",
-  "TRANSFORM", "TREAT", "TRIGGER", "TRIM", "TRUE_P", "TRUNCATE", "TRUSTED",
-  "TRY_CAST", "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED",
-  "UNENCRYPTED", "UNION", "UNIQUE", "UNKNOWN", "UNLISTEN", "UNLOGGED",
-  "UNTIL", "UPDATE", "USER", "USING", "VACUUM", "VALID", "VALIDATE",
-  "VALIDATOR", "VALUE_P", "VALUES", "VARCHAR", "VARIADIC", "VARYING",
-  "VERBOSE", "VERSION_P", "VIEW", "VIEWS", "VIRTUAL", "VOLATILE", "WHEN",
-  "WHERE", "WHITESPACE_P", "WINDOW", "WITH", "WITHIN", "WITHOUT", "WORK",
-  "WRAPPER", "WRITE_P", "XML_P", "XMLATTRIBUTES", "XMLCONCAT",
-  "XMLELEMENT", "XMLEXISTS", "XMLFOREST", "XMLNAMESPACES", "XMLPARSE",
-  "XMLPI", "XMLROOT", "XMLSERIALIZE", "XMLTABLE", "YEAR_P", "YEARS_P",
-  "YES_P", "ZONE", "NOT_LA", "NULLS_LA", "WITH_LA", "'<'", "'>'", "'='",
-  "POSTFIXOP", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "UMINUS", "'['",
-  "']'", "'('", "')'", "'.'", "';'", "','", "'{'", "'}'", "'#'", "'?'",
-  "':'", "$accept", "stmtblock", "stmtmulti", "stmt", "AlterTableStmt",
-  "alter_identity_column_option_list", "alter_column_default",
-  "alter_identity_column_option", "alter_generic_option_list",
-  "alter_table_cmd", "alter_using", "alter_generic_option_elem",
-  "alter_table_cmds", "alter_generic_options", "opt_set_data",
-  "DeallocateStmt", "RenameStmt", "opt_column", "InsertStmt",
-  "insert_rest", "insert_target", "opt_conf_expr", "opt_with_clause",
-  "insert_column_item", "set_clause", "opt_on_conflict", "index_elem",
-  "returning_clause", "override_kind", "set_target_list", "opt_collate",
-  "opt_class", "insert_column_list", "set_clause_list",
-  "set_clause_list_opt_comma", "index_params", "set_target",
-  "CreateTypeStmt", "PragmaStmt", "CreateSeqStmt", "OptSeqOptList",
-  "ExecuteStmt", "execute_param_clause", "AlterSeqStmt", "SeqOptList",
-  "opt_with", "NumericOnly", "SeqOptElem", "opt_by", "SignedIconst",
-  "TransactionStmt", "opt_transaction", "CreateStmt",
-  "ConstraintAttributeSpec", "def_arg", "OptParenthesizedSeqOptList",
-  "generic_option_arg", "key_action", "ColConstraint", "ColConstraintElem",
-  "GeneratedColumnType", "opt_GeneratedColumnType",
-  "GeneratedConstraintElem", "generic_option_elem", "key_update",
-  "key_actions", "OnCommitOption", "reloptions", "opt_no_inherit",
-  "TableConstraint", "TableLikeOption", "reloption_list", "ExistingIndex",
-  "ConstraintAttr", "OptWith", "definition", "TableLikeOptionList",
-  "generic_option_name", "ConstraintAttributeElem", "columnDef",
-  "def_list", "index_name", "TableElement", "def_elem", "opt_definition",
-  "OptTableElementList", "columnElem", "opt_column_list", "ColQualList",
-  "key_delete", "reloption_elem", "columnList", "columnList_opt_comma",
-  "func_type", "ConstraintElem", "TableElementList", "key_match",
-  "TableLikeClause", "OptTemp", "generated_when", "DropStmt",
-  "drop_type_any_name", "drop_type_name", "any_name_list",
-  "opt_drop_behavior", "drop_type_name_on_any_name", "type_name_list",
-  "CreateFunctionStmt", "macro_alias", "param_list", "UpdateStmt",
-  "CopyStmt", "copy_from", "copy_delimiter", "copy_generic_opt_arg_list",
-  "opt_using", "opt_as", "opt_program", "copy_options",
-  "copy_generic_opt_arg", "copy_generic_opt_elem", "opt_oids",
-  "copy_opt_list", "opt_binary", "copy_opt_item",
-  "copy_generic_opt_arg_list_item", "copy_file_name",
-  "copy_generic_opt_list", "SelectStmt", "select_with_parens",
-  "select_no_parens", "select_clause", "simple_select", "with_clause",
-  "cte_list", "common_table_expr", "into_clause", "OptTempTableName",
-  "opt_table", "all_or_distinct", "distinct_clause", "opt_all_clause",
-  "opt_ignore_nulls", "opt_sort_clause", "sort_clause", "sortby_list",
-  "sortby", "opt_asc_desc", "opt_nulls_order", "select_limit",
-  "opt_select_limit", "limit_clause", "offset_clause", "sample_count",
-  "sample_clause", "opt_sample_func", "tablesample_entry",
-  "tablesample_clause", "opt_tablesample_clause", "opt_repeatable_clause",
-  "select_limit_value", "select_offset_value", "select_fetch_first_value",
-  "I_or_F_const", "row_or_rows", "first_or_next", "group_clause",
-  "group_by_list", "group_by_list_opt_comma", "group_by_item",
-  "empty_grouping_set", "rollup_clause", "cube_clause",
-  "grouping_sets_clause", "grouping_or_grouping_id", "having_clause",
-  "qualify_clause", "for_locking_clause", "opt_for_locking_clause",
-  "for_locking_items", "for_locking_item", "for_locking_strength",
-  "locked_rels_list", "opt_nowait_or_skip", "values_clause",
-  "values_clause_opt_comma", "from_clause", "from_list",
-  "from_list_opt_comma", "table_ref", "joined_table", "alias_clause",
-  "opt_alias_clause", "func_alias_clause", "join_type", "join_outer",
-  "join_qual", "relation_expr", "func_table", "rowsfrom_item",
-  "rowsfrom_list", "opt_col_def_list", "opt_ordinality", "where_clause",
-  "TableFuncElementList", "TableFuncElement", "opt_collate_clause",
-  "colid_type_list", "RowOrStruct", "opt_Typename", "Typename",
-  "opt_array_bounds", "SimpleTypename", "ConstTypename", "GenericType",
-  "opt_type_modifiers", "Numeric", "opt_float", "Bit", "ConstBit",
-  "BitWithLength", "BitWithoutLength", "Character", "ConstCharacter",
-  "CharacterWithLength", "CharacterWithoutLength", "character",
-  "opt_varying", "ConstDatetime", "ConstInterval", "opt_timezone",
-  "year_keyword", "month_keyword", "day_keyword", "hour_keyword",
-  "minute_keyword", "second_keyword", "millisecond_keyword",
-  "microsecond_keyword", "opt_interval", "a_expr", "b_expr", "c_expr",
-  "func_application", "func_expr", "func_expr_windowless",
-  "func_expr_common_subexpr", "within_group_clause", "filter_clause",
-  "export_clause", "window_clause", "window_definition_list",
-  "window_definition", "over_clause", "window_specification",
-  "opt_existing_window_name", "opt_partition_clause", "opt_frame_clause",
-  "frame_extent", "frame_bound", "qualified_row", "row", "dict_arg",
-  "dict_arguments", "dict_arguments_opt_comma", "sub_type", "all_Op",
-  "MathOp", "qual_Op", "qual_all_Op", "subquery_Op", "any_operator",
-  "expr_list", "expr_list_opt_comma", "opt_expr_list_opt_comma",
-  "func_arg_list", "func_arg_expr", "type_list", "extract_list",
-  "extract_arg", "overlay_list", "overlay_placing", "position_list",
-  "substr_list", "substr_from", "substr_for", "trim_list", "in_expr",
-  "case_expr", "when_clause_list", "when_clause", "case_default",
-  "case_arg", "columnref", "indirection_el", "opt_slice_bound",
-  "indirection", "opt_indirection", "opt_asymmetric",
-  "opt_target_list_opt_comma", "target_list", "target_list_opt_comma",
-  "target_el", "except_list", "opt_except_list", "replace_list_el",
-  "replace_list", "replace_list_opt_comma", "opt_replace_list",
-  "qualified_name_list", "qualified_name", "name_list",
-  "name_list_opt_comma", "name", "attr_name", "func_name", "AexprConst",
-  "Iconst", "Sconst", "ColId", "ColIdOrString", "type_function_name",
-  "function_name_token", "type_name_token", "any_name", "attrs",
-  "opt_name_list", "param_name", "ColLabel", "ColLabelOrString",
-  "PrepareStmt", "prep_type_clause", "PreparableStmt", "CreateSchemaStmt",
-  "OptSchemaEltList", "schema_stmt", "IndexStmt", "access_method",
-  "access_method_clause", "opt_concurrently", "opt_index_name",
-  "opt_reloptions", "opt_unique", "AlterObjectSchemaStmt",
-  "CheckPointStmt", "ExportStmt", "ImportStmt", "ExplainStmt",
-  "opt_verbose", "explain_option_arg", "ExplainableStmt",
-  "NonReservedWord", "NonReservedWord_or_Sconst", "explain_option_list",
-  "analyze_keyword", "opt_boolean_or_string", "explain_option_elem",
-  "explain_option_name", "VariableSetStmt", "set_rest", "generic_set",
-  "var_value", "zone_value", "var_list", "LoadStmt", "file_name",
-  "VacuumStmt", "vacuum_option_elem", "opt_full", "vacuum_option_list",
-  "opt_freeze", "DeleteStmt", "relation_expr_opt_alias",
-  "where_or_current_clause", "using_clause", "AnalyzeStmt",
-  "VariableResetStmt", "generic_reset", "reset_rest", "VariableShowStmt",
-  "show_or_describe", "var_name", "CallStmt", "ViewStmt",
-  "opt_check_option", "CreateAsStmt", "opt_with_data", "create_as_target",
-  "unreserved_keyword", "col_name_keyword", "func_name_keyword",
-  "type_name_keyword", "other_keyword", "type_func_name_keyword",
-  "reserved_keyword", 0
-};
-#endif
-
-# ifdef YYPRINT
-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-   token YYLEX-NUM.  */
-static const yytype_uint16 yytoknum[] =
-{
-       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
-     455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
-     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
-     495,   496,   497,   498,   499,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   520,   521,   522,   523,   524,
-     525,   526,   527,   528,   529,   530,   531,   532,   533,   534,
-     535,   536,   537,   538,   539,   540,   541,   542,   543,   544,
-     545,   546,   547,   548,   549,   550,   551,   552,   553,   554,
-     555,   556,   557,   558,   559,   560,   561,   562,   563,   564,
-     565,   566,   567,   568,   569,   570,   571,   572,   573,   574,
-     575,   576,   577,   578,   579,   580,   581,   582,   583,   584,
-     585,   586,   587,   588,   589,   590,   591,   592,   593,   594,
-     595,   596,   597,   598,   599,   600,   601,   602,   603,   604,
-     605,   606,   607,   608,   609,   610,   611,   612,   613,   614,
-     615,   616,   617,   618,   619,   620,   621,   622,   623,   624,
-     625,   626,   627,   628,   629,   630,   631,   632,   633,   634,
-     635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
-     645,   646,   647,   648,   649,   650,   651,   652,   653,   654,
-     655,   656,   657,   658,   659,   660,   661,   662,   663,   664,
-     665,   666,   667,   668,   669,   670,   671,   672,   673,   674,
-     675,   676,   677,   678,   679,   680,   681,   682,   683,   684,
-     685,   686,   687,   688,   689,   690,   691,   692,   693,   694,
-     695,   696,   697,   698,   699,   700,   701,   702,   703,   704,
-     705,   706,   707,   708,   709,   710,   711,   712,   713,   714,
-     715,   716,   717,   718,   719,   720,   721,   722,   723,   724,
-     725,   726,   727,   728,   729,   730,   731,   732,   733,   734,
-     735,   736,   737,   738,   739,    60,    62,    61,   740,    43,
-      45,    42,    47,    37,    94,   741,    91,    93,    40,    41,
-      46,    59,    44,   123,   125,    35,    63,    58
-};
-# endif
-
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const yytype_uint16 yyr1[] =
-{
-       0,   508,   509,   510,   510,   511,   511,   511,   511,   511,
-     511,   511,   511,   511,   511,   511,   511,   511,   511,   511,
-     511,   511,   511,   511,   511,   511,   511,   511,   511,   511,
-     511,   511,   511,   511,   511,   511,   511,   511,   511,   511,
-     512,   512,   512,   512,   512,   512,   512,   512,   513,   513,
-     514,   514,   515,   515,   515,   515,   516,   516,   517,   517,
-     517,   517,   517,   517,   517,   517,   517,   517,   517,   517,
-     517,   517,   517,   517,   517,   517,   517,   517,   517,   517,
-     517,   517,   517,   517,   517,   517,   517,   518,   518,   519,
-     519,   519,   519,   520,   520,   521,   522,   522,   522,   523,
-     523,   523,   523,   524,   524,   524,   524,   524,   524,   524,
-     524,   524,   524,   524,   524,   524,   525,   525,   526,   527,
-     527,   527,   527,   527,   528,   528,   529,   529,   529,   530,
-     530,   531,   532,   532,   533,   533,   533,   534,   534,   534,
-     535,   535,   536,   536,   537,   537,   538,   538,   539,   539,
-     540,   540,   541,   541,   542,   542,   543,   543,   544,   545,
-     546,   546,   546,   547,   547,   548,   548,   549,   549,   549,
-     550,   550,   551,   551,   552,   552,   553,   553,   553,   554,
-     554,   554,   554,   555,   555,   555,   555,   555,   555,   555,
-     555,   555,   555,   555,   555,   555,   555,   556,   556,   557,
-     557,   557,   558,   558,   558,   558,   558,   558,   559,   559,
-     559,   560,   560,   560,   561,   561,   562,   562,   562,   562,
-     562,   562,   563,   563,   564,   565,   565,   565,   565,   565,
-     566,   566,   566,   566,   567,   567,   567,   567,   567,   567,
-     567,   567,   568,   568,   569,   569,   570,   570,   570,   571,
-     572,   573,   573,   573,   573,   573,   574,   574,   574,   574,
-     575,   576,   576,   577,   577,   578,   578,   578,   578,   578,
-     578,   578,   578,   579,   579,   580,   581,   581,   581,   581,
-     582,   582,   582,   582,   583,   584,   584,   584,   585,   586,
-     586,   586,   586,   586,   586,   587,   587,   588,   588,   589,
-     590,   590,   590,   591,   591,   592,   592,   593,   593,   593,
-     594,   595,   595,   596,   596,   597,   598,   598,   598,   598,
-     599,   599,   600,   600,   601,   601,   601,   602,   602,   602,
-     602,   602,   602,   603,   603,   604,   604,   604,   604,   605,
-     606,   606,   606,   606,   606,   606,   606,   606,   607,   607,
-     608,   608,   608,   608,   608,   608,   608,   608,   609,   609,
-     609,   609,   609,   609,   609,   609,   609,   609,   609,   609,
-     609,   609,   609,   609,   610,   610,   610,   610,   610,   610,
-     610,   611,   611,   612,   612,   612,   613,   613,   613,   614,
-     614,   615,   615,   616,   616,   617,   617,   618,   619,   619,
-     620,   620,   621,   621,   622,   622,   623,   623,   624,   624,
-     625,   625,   626,   626,   627,   627,   627,   627,   627,   628,
-     629,   629,   630,   630,   631,   631,   632,   632,   632,   632,
-     632,   632,   632,   632,   632,   632,   632,   632,   632,   632,
-     633,   634,   634,   634,   635,   635,   636,   636,   637,   637,
-     638,   638,   638,   638,   638,   638,   638,   638,   639,   639,
-     640,   640,   640,   640,   640,   640,   640,   641,   641,   641,
-     642,   642,   643,   644,   644,   645,   645,   645,   645,   645,
-     645,   645,   645,   645,   646,   646,   647,   647,   647,   648,
-     648,   649,   649,   650,   650,   650,   651,   651,   652,   652,
-     652,   653,   653,   654,   654,   655,   655,   655,   656,   656,
-     656,   657,   657,   657,   657,   658,   658,   659,   659,   659,
-     659,   660,   660,   661,   661,   661,   661,   661,   661,   662,
-     662,   663,   663,   664,   664,   664,   664,   665,   666,   666,
-     667,   667,   668,   668,   668,   668,   668,   669,   670,   670,
-     670,   671,   671,   672,   672,   673,   673,   674,   674,   674,
-     674,   675,   675,   676,   676,   677,   677,   677,   677,   677,
-     678,   679,   680,   681,   682,   682,   683,   683,   684,   684,
-     685,   685,   686,   686,   687,   687,   688,   689,   689,   689,
-     689,   690,   690,   691,   691,   691,   692,   692,   693,   693,
-     694,   694,   695,   695,   696,   696,   697,   697,   697,   697,
-     697,   697,   697,   698,   698,   698,   698,   698,   698,   699,
-     699,   699,   699,   700,   700,   701,   701,   701,   701,   701,
-     702,   702,   702,   702,   703,   703,   704,   704,   705,   705,
-     705,   705,   706,   706,   707,   708,   708,   709,   709,   710,
-     710,   711,   711,   712,   712,   713,   714,   714,   715,   715,
-     716,   716,   717,   717,   718,   718,   718,   718,   718,   718,
-     718,   718,   719,   719,   719,   720,   720,   720,   720,   720,
-     720,   720,   721,   721,   721,   721,   722,   723,   723,   724,
-     724,   724,   724,   724,   724,   724,   724,   724,   724,   724,
-     725,   725,   726,   726,   727,   727,   728,   729,   730,   730,
-     731,   731,   732,   733,   734,   734,   734,   734,   734,   734,
-     735,   735,   736,   736,   736,   736,   737,   738,   738,   738,
-     739,   739,   740,   740,   741,   741,   742,   742,   743,   743,
-     744,   744,   745,   745,   746,   746,   747,   747,   747,   747,
-     747,   747,   747,   747,   747,   747,   747,   747,   747,   747,
-     747,   747,   748,   748,   748,   748,   748,   748,   748,   748,
-     748,   748,   748,   748,   748,   748,   748,   748,   748,   748,
-     748,   748,   748,   748,   748,   748,   748,   748,   748,   748,
-     748,   748,   748,   748,   748,   748,   748,   748,   748,   748,
-     748,   748,   748,   748,   748,   748,   748,   748,   748,   748,
-     748,   748,   748,   748,   748,   748,   748,   748,   748,   748,
-     748,   748,   748,   748,   748,   748,   748,   748,   748,   748,
-     748,   749,   749,   749,   749,   749,   749,   749,   749,   749,
-     749,   749,   749,   749,   749,   749,   749,   749,   749,   749,
-     749,   749,   749,   749,   749,   750,   750,   750,   750,   750,
-     750,   750,   750,   750,   750,   750,   750,   751,   751,   751,
-     751,   751,   751,   751,   752,   752,   753,   753,   754,   754,
-     754,   754,   754,   754,   754,   754,   754,   754,   754,   754,
-     754,   754,   754,   754,   754,   754,   754,   754,   754,   754,
-     754,   754,   754,   754,   754,   754,   754,   755,   755,   756,
-     756,   757,   757,   758,   758,   759,   759,   760,   761,   761,
-     761,   762,   763,   763,   764,   764,   765,   765,   765,   766,
-     766,   767,   767,   767,   767,   767,   768,   768,   769,   769,
-     770,   771,   771,   772,   772,   773,   773,   773,   774,   774,
-     775,   775,   775,   775,   775,   775,   775,   775,   775,   775,
-     775,   775,   775,   776,   776,   777,   777,   778,   778,   778,
-     778,   778,   778,   778,   778,   779,   779,   780,   780,   781,
-     781,   782,   782,   783,   783,   784,   784,   784,   785,   785,
-     786,   786,   787,   787,   787,   787,   787,   787,   787,   787,
-     787,   787,   788,   788,   789,   790,   790,   791,   791,   791,
-     791,   791,   791,   792,   793,   794,   794,   794,   795,   795,
-     796,   797,   797,   798,   799,   799,   800,   800,   801,   801,
-     802,   802,   802,   803,   803,   804,   804,   805,   805,   806,
-     806,   807,   807,   808,   808,   809,   809,   810,   810,   810,
-     810,   810,   811,   811,   812,   812,   813,   814,   814,   815,
-     815,   816,   816,   816,   817,   817,   818,   818,   819,   819,
-     820,   820,   821,   822,   823,   823,   824,   824,   824,   824,
-     824,   824,   824,   824,   824,   824,   824,   824,   824,   824,
-     825,   826,   827,   827,   827,   828,   828,   829,   829,   829,
-     830,   830,   830,   831,   831,   831,   832,   832,   833,   833,
-     834,   834,   835,   836,   836,   836,   836,   837,   837,   838,
-     839,   839,   840,   840,   840,   840,   841,   841,   842,   842,
-     843,   843,   843,   843,   844,   844,   845,   846,   846,   847,
-     847,   848,   848,   849,   849,   850,   850,   851,   851,   851,
-     851,   851,   851,   852,   852,   853,   854,   855,   855,   855,
-     855,   856,   856,   857,   857,   857,   858,   858,   858,   858,
-     858,   859,   859,   859,   860,   860,   861,   861,   862,   862,
-     863,   863,   863,   863,   864,   865,   865,   866,   866,   866,
-     866,   867,   867,   867,   867,   868,   868,   868,   868,   869,
-     869,   870,   870,   870,   870,   870,   870,   870,   871,   871,
-     872,   872,   872,   873,   873,   874,   874,   874,   874,   874,
-     875,   875,   875,   875,   875,   876,   876,   877,   877,   878,
-     878,   879,   880,   880,   880,   881,   881,   882,   882,   883,
-     883,   884,   885,   885,   886,   886,   886,   887,   887,   887,
-     887,   887,   887,   887,   887,   888,   888,   889,   889,   890,
-     891,   891,   891,   891,   892,   892,   892,   892,   893,   893,
-     893,   894,   894,   894,   895,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   896,   896,   896,   896,   896,   896,   896,   896,
-     896,   896,   897,   897,   897,   897,   897,   897,   897,   897,
-     897,   897,   897,   897,   897,   897,   897,   897,   897,   897,
-     897,   897,   897,   897,   897,   897,   897,   897,   897,   897,
-     897,   897,   897,   897,   897,   897,   897,   897,   897,   897,
-     897,   897,   897,   897,   897,   897,   897,   897,   897,   897,
-     897,   897,   897,   897,   897,   898,   898,   898,   898,   898,
-     898,   898,   898,   898,   898,   898,   898,   898,   898,   898,
-     898,   898,   898,   898,   898,   898,   898,   898,   898,   898,
-     898,   898,   898,   898,   898,   898,   898,   898,   899,   899,
-     899,   899,   899,   899,   899,   899,   899,   899,   899,   899,
-     899,   899,   899,   899,   899,   899,   899,   899,   899,   899,
-     899,   899,   899,   899,   899,   899,   899,   899,   899,   900,
-     900,   900,   900,   900,   900,   900,   900,   900,   900,   900,
-     900,   900,   900,   900,   900,   900,   900,   900,   900,   900,
-     900,   900,   900,   900,   900,   900,   900,   900,   900,   900,
-     900,   900,   900,   900,   900,   900,   900,   900,   900,   900,
-     900,   900,   900,   900,   900,   900,   900,   900,   900,   900,
-     900,   900,   900,   900,   900,   900,   900,   900,   900,   900,
-     900,   900,   900,   900,   900,   900,   900,   900,   900,   900,
-     900,   900,   900,   900,   900,   900,   900,   900,   900,   900,
-     900,   900,   901,   901,   901,   901,   901,   901,   901,   901,
-     901,   901,   901,   901,   901,   901,   901,   901,   901,   901,
-     901,   901,   901,   901,   901,   901,   901,   901,   901,   901,
-     901,   901,   901,   901,   901,   901,   902,   902,   902,   902,
-     902,   902,   902,   902,   902,   902,   902,   902,   902,   902,
-     902,   902,   902,   902,   902,   902,   902,   902,   902,   902,
-     902,   902,   902,   902,   902,   902,   902,   902,   902,   902,
-     902,   902,   902,   902,   902,   902,   902,   902,   902,   902,
-     902,   902,   902,   902,   902,   902,   902,   902,   902,   902,
-     902,   902,   902,   902,   902,   902,   902,   902,   902,   902,
-     902,   902,   902,   902,   902,   902,   902,   902
-};
-
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-static const yytype_uint8 yyr2[] =
-{
-       0,     2,     1,     3,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
-       4,     6,     4,     6,     4,     6,     4,     6,     1,     2,
-       3,     2,     1,     3,     2,     3,     1,     3,     2,     5,
-       3,     6,     4,     6,     6,     6,     5,     5,     6,     9,
-       4,     5,     7,     6,     4,     8,     4,     2,     4,     3,
-       6,     4,     2,     2,     2,     2,     1,     2,     0,     1,
-       2,     2,     2,     1,     3,     4,     2,     1,     0,     2,
-       3,     2,     3,     6,     6,     8,     6,     8,     6,     8,
-       6,     8,     8,    10,     8,    10,     1,     0,     7,     1,
-       4,     4,     7,     2,     1,     3,     4,     3,     0,     1,
-       0,     2,     3,     5,     8,     5,     0,     5,     5,     7,
-       2,     0,     1,     1,     1,     3,     2,     0,     1,     0,
-       1,     3,     1,     3,     1,     2,     1,     3,     2,     5,
-       2,     4,     5,     5,     8,     1,     0,     3,     9,    12,
-       3,     0,     4,     6,     1,     2,     1,     1,     0,     1,
-       2,     2,     1,     2,     2,     1,     2,     3,     2,     2,
-       2,     2,     3,     3,     3,     1,     3,     1,     0,     1,
-       2,     2,     2,     2,     2,     2,     2,     2,     1,     1,
-       0,     9,    12,    11,     0,     2,     1,     1,     1,     1,
-       1,     1,     3,     0,     1,     2,     1,     1,     2,     2,
-       3,     1,     1,     2,     2,     1,     2,     3,     5,     3,
-       2,     5,     1,     1,     1,     0,     5,     7,     5,     2,
-       3,     1,     1,     2,     2,     0,     3,     4,     4,     0,
-       3,     2,     0,     3,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     3,     3,     1,     2,     2,     2,
-       2,     2,     2,     0,     3,     3,     3,     0,     1,     2,
-       1,     2,     2,     2,     2,     3,     4,     1,     3,     1,
-       1,     1,     1,     3,     1,     2,     0,     1,     2,     0,
-       1,     3,     0,     2,     0,     3,     3,     1,     5,     3,
-       1,     3,     1,     2,     1,     4,     5,     5,     6,     3,
-       7,     4,    11,     1,     3,     2,     2,     2,     0,     3,
-       1,     1,     2,     2,     2,     2,     1,     0,     1,     2,
-       6,     4,     6,     4,     6,     8,     4,     6,     1,     1,
-       1,     1,     2,     1,     2,     1,     2,     1,     1,     1,
-       3,     3,     3,     3,     2,     2,     1,     3,     1,     1,
-       1,     1,     3,     1,     1,     0,     1,     1,     1,     1,
-       3,     8,     7,     1,     1,     2,     3,     8,    11,     9,
-       1,     1,     3,     0,     1,     3,     1,     0,     1,     0,
-       1,     0,     1,     3,     1,     1,     1,     3,     0,     2,
-       2,     0,     2,     0,     1,     0,     1,     1,     1,     3,
-       3,     1,     1,     3,     3,     3,     3,     4,     3,     2,
-       1,     1,     1,     1,     1,     3,     1,     1,     3,     3,
-       1,     2,     4,     4,     2,     3,     5,     5,     1,     1,
-      11,    11,     1,     2,     4,     4,     4,     2,     2,     3,
-       1,     3,     6,     2,     0,     3,     3,     4,     4,     4,
-       4,     3,     2,     1,     1,     0,     1,     1,     0,     1,
-       5,     1,     0,     2,     2,     0,     1,     0,     3,     5,
-       5,     1,     3,     4,     3,     1,     1,     0,     2,     2,
-       0,     2,     2,     1,     1,     1,     0,     2,     4,     5,
-       4,     2,     3,     2,     2,     2,     2,     1,     2,     3,
-       0,     1,     0,     5,     1,     4,     6,     2,     1,     0,
-       4,     0,     1,     1,     2,     2,     2,     1,     1,     2,
-       2,     1,     1,     1,     1,     1,     1,     3,     3,     3,
-       0,     1,     3,     1,     2,     1,     1,     1,     1,     1,
-       2,     4,     4,     5,     1,     1,     2,     0,     2,     0,
-       1,     3,     1,     0,     1,     2,     3,     2,     4,     2,
-       3,     2,     0,     1,     2,     0,     4,     5,     1,     2,
-       2,     0,     1,     3,     1,     2,     3,     3,     3,     3,
-       3,     1,     4,     3,     4,     5,     4,     5,     4,     5,
-       2,     4,     1,     1,     0,     1,     4,     5,     4,     0,
-       2,     2,     2,     1,     1,     0,     4,     2,     1,     2,
-       2,     4,     2,     6,     2,     1,     3,     4,     0,     2,
-       0,     2,     0,     1,     3,     3,     2,     0,     2,     4,
-       1,     1,     1,     0,     2,     3,     5,     6,     2,     3,
-       5,     5,     3,     4,     0,     1,     1,     1,     1,     1,
-       2,     4,     1,     1,     1,     1,     2,     3,     0,     1,
-       1,     1,     1,     1,     2,     2,     2,     2,     2,     1,
-       3,     0,     1,     1,     1,     1,     5,     2,     1,     1,
-       1,     1,     4,     1,     2,     2,     1,     3,     3,     2,
-       1,     0,     5,     2,     5,     2,     1,     3,     3,     0,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     3,     3,     3,     3,     3,     3,
-       3,     0,     1,     3,     3,     5,     2,     2,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     2,     2,     3,     3,     2,     2,     3,     3,
-       5,     4,     6,     3,     5,     4,     6,     4,     6,     5,
-       7,     3,     2,     4,     3,     2,     1,     3,     3,     3,
-       3,     3,     4,     3,     4,     3,     4,     5,     6,     6,
-       7,     6,     7,     6,     7,     3,     4,     4,     6,     1,
-       4,     1,     3,     2,     2,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     2,
-       2,     5,     6,     6,     7,     1,     1,     2,     2,     2,
-       4,     1,     2,     1,     2,     2,     4,     3,     6,     7,
-       9,     7,     7,     4,     5,     1,     1,     1,     5,     1,
-       1,     4,     1,     4,     1,     4,     1,     4,     1,     1,
-       1,     1,     1,     1,     6,     6,     4,     4,     4,     4,
-       6,     5,     5,     5,     4,     6,     4,     5,     0,     5,
-       0,     1,     0,     2,     0,     1,     3,     3,     2,     2,
-       0,     6,     1,     0,     3,     0,     2,     2,     0,     1,
-       4,     2,     2,     2,     2,     2,     4,     3,     1,     5,
-       3,     1,     3,     1,     2,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     4,     1,     4,     1,     4,     1,
-       2,     1,     2,     1,     2,     1,     3,     1,     3,     1,
-       2,     1,     0,     1,     3,     1,     3,     3,     1,     3,
-       3,     0,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     4,     3,     2,     3,     0,     3,     3,     2,
-       2,     1,     0,     2,     2,     3,     2,     1,     1,     3,
-       5,     1,     2,     4,     2,     0,     1,     0,     1,     2,
-       2,     3,     5,     1,     0,     1,     2,     0,     2,     1,
-       0,     1,     0,     1,     3,     1,     2,     3,     2,     1,
-       3,     5,     4,     2,     1,     0,     3,     1,     3,     1,
-       2,     4,     2,     0,     1,     3,     1,     2,     1,     3,
-       1,     2,     1,     1,     1,     2,     1,     1,     2,     1,
-       1,     2,     7,     2,     5,     3,     3,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     2,     2,     3,
-       3,     0,     1,     1,     1,     1,     1,     1,     1,     5,
-       3,     0,     1,     1,     1,     1,     4,     7,     2,     0,
-       1,     1,     1,     1,    13,    16,     1,     2,     0,     1,
-       0,     1,     0,     2,     0,     1,     0,     6,     8,     6,
-       8,     6,     8,     2,     1,     4,     3,     2,     4,     3,
-       5,     1,     0,     1,     1,     0,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     3,     1,     1,
-       1,     1,     1,     1,     2,     1,     1,     2,     3,     3,
-       3,     1,     3,     3,     2,     3,     3,     3,     3,     1,
-       1,     1,     1,     3,     5,     1,     1,     1,     1,     3,
-       2,     2,     3,     1,     1,     4,     5,     5,     4,     6,
-       1,     1,     1,     1,     1,     1,     0,     1,     3,     1,
-       0,     7,     1,     2,     3,     2,     0,     2,     0,     2,
-       4,     2,     1,     1,     1,     2,     3,     2,     2,     2,
-       2,     3,     4,     2,     1,     1,     1,     1,     3,     2,
-       9,    11,    12,    14,     3,     4,     4,     0,     7,    10,
-       9,     2,     3,     0,     4,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1
-};
-
-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
-   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
-   means the default is an error.  */
-static const yytype_uint16 yydefact[] =
-{
-     130,   210,     0,  1179,  1178,   210,     0,  1154,   210,   425,
-     347,     0,  1256,     0,   210,     0,   130,     0,     0,     0,
-       0,     0,     0,     0,     0,   210,   492,     0,  1255,   210,
-       0,     0,  1226,     0,     0,     0,     0,     0,     2,     4,
-       7,    18,    30,    26,     0,    17,    28,    15,    21,     6,
-      32,    16,    20,    13,    33,    11,    31,   459,   446,   497,
-     458,   129,   598,   462,    29,    14,    25,     5,    10,    23,
-      24,    22,  1162,    36,    27,    34,    19,     8,    35,    37,
-    1254,     9,    38,    12,   209,   208,   202,     0,     0,     0,
-       0,     0,   203,  1092,  1275,  1276,  1277,  1278,  1279,  1280,
-    1281,  1282,  1283,  1284,  1285,  1286,  1287,  1288,  1289,  1290,
-    1635,  1291,  1292,  1293,  1582,  1583,  1636,  1584,  1585,  1294,
-    1295,  1296,  1297,  1298,  1299,  1300,  1301,  1586,  1587,  1302,
-    1303,  1304,  1305,  1306,  1588,  1637,  1307,  1308,  1309,  1310,
-    1311,  1312,  1638,  1313,  1314,  1315,  1316,  1317,  1318,  1319,
-    1320,  1321,  1639,  1322,  1323,  1324,  1640,  1641,  1642,  1643,
-    1644,  1325,  1326,  1327,  1328,  1329,  1330,  1331,  1589,  1590,
-    1332,  1333,  1334,  1335,  1336,  1337,  1338,  1339,  1340,  1341,
-    1342,  1343,  1344,  1345,  1346,  1347,  1348,  1349,  1350,  1351,
-    1352,  1353,  1354,  1355,  1356,  1357,  1358,  1359,  1591,  1360,
-    1361,  1362,  1363,  1364,  1592,  1365,  1366,  1367,  1593,  1368,
-    1369,  1370,  1645,  1646,  1371,  1372,  1594,  1648,  1373,  1374,
-    1595,  1596,  1375,  1376,  1377,  1378,  1379,  1380,  1381,  1382,
-    1649,  1383,  1384,  1385,  1386,  1387,  1388,  1389,  1390,  1391,
-    1392,  1393,  1650,  1597,  1394,  1395,  1396,  1397,  1398,  1598,
-    1599,  1600,  1399,  1651,  1652,  1400,  1653,  1401,  1402,  1403,
-    1404,  1405,  1406,  1407,  1654,  1408,  1655,  1409,  1410,  1411,
-    1412,  1413,  1414,  1415,  1416,  1601,  1417,  1418,  1419,  1420,
-    1421,  1422,  1423,  1424,  1425,  1426,  1427,  1428,  1429,  1430,
-    1431,  1432,  1433,  1434,  1602,  1657,  1603,  1435,  1436,  1437,
-    1604,  1438,  1439,  1658,  1440,  1605,  1441,  1606,  1442,  1443,
-    1444,  1445,  1446,  1447,  1448,  1449,  1450,  1607,  1659,  1451,
-    1660,  1608,  1452,  1453,  1454,  1455,  1456,  1457,  1458,  1459,
-    1460,  1461,  1462,  1463,  1609,  1464,  1465,  1610,  1466,  1467,
-    1468,  1469,  1470,  1471,  1472,  1473,  1474,  1475,  1476,  1477,
-    1611,  1478,  1479,  1480,  1481,  1482,  1483,  1484,  1485,  1486,
-    1487,  1488,  1489,  1490,  1491,  1492,  1493,  1494,  1495,  1496,
-    1661,  1497,  1498,  1499,  1612,  1500,  1501,  1502,  1503,  1504,
-    1505,  1506,  1507,  1508,  1509,  1510,  1511,  1512,  1513,  1514,
-    1515,  1662,  1516,  1613,  1517,  1518,  1519,  1663,  1520,  1521,
-    1614,  1522,  1523,  1524,  1525,  1526,  1527,  1528,  1529,  1530,
-    1531,  1532,  1533,  1534,  1615,  1535,  1616,  1536,  1537,  1538,
-    1539,  1665,  1540,  1541,  1542,  1543,  1544,  1617,  1618,  1545,
-    1546,  1619,  1547,  1620,  1548,  1549,  1621,  1550,  1551,  1552,
-    1553,  1554,  1555,  1556,  1557,  1558,  1559,  1666,  1560,  1561,
-    1562,  1563,  1564,  1622,  1623,  1565,  1667,  1566,  1567,  1568,
-    1569,  1570,  1571,  1572,  1573,  1574,  1575,  1576,  1577,  1624,
-    1625,  1626,  1627,  1628,  1629,  1630,  1631,  1632,  1633,  1634,
-    1578,  1579,  1580,  1581,  1259,     0,     0,  1074,  1093,  1094,
-    1102,   205,   424,   130,     0,     0,     0,     0,     0,   341,
-     340,     0,  1145,   346,     0,     0,  1092,   101,  1594,  1601,
-    1466,  1615,    99,  1072,  1093,     0,   367,   368,     0,   376,
-       0,   360,   365,   361,     0,   386,   378,   387,   379,   359,
-     380,   369,   358,     0,   388,     0,   363,     0,     0,     0,
-     206,   171,   347,   130,     0,  1167,  1168,  1166,  1157,  1162,
-    1169,  1170,     0,  1153,     0,     0,  1091,  1213,  1214,  1211,
-    1210,   160,  1121,  1243,  1617,  1545,  1257,  1244,  1241,  1242,
-     207,   491,   489,     0,  1042,  1373,  1411,  1504,  1515,  1617,
-    1187,  1191,     0,   204,  1622,  1248,     0,  1249,  1096,     0,
-     463,   638,  1095,  1066,  1225,     0,  1230,     0,  1480,   467,
-     470,  1111,   468,   459,     0,     1,   130,     0,     0,     0,
-     488,   488,     0,   488,     0,   451,   459,   454,   458,   599,
-    1161,  1239,  1253,  1617,  1545,  1247,  1250,  1381,     0,     0,
-    1381,     0,  1381,     0,  1381,     0,     0,  1034,     0,  1035,
-    1075,  1123,  1124,  1122,     0,  1125,   312,   345,   344,   343,
-     342,   347,  1381,  1129,  1106,     0,   393,   394,     0,     0,
-       0,     0,     0,  1140,   102,   100,   374,   375,     0,   366,
-     362,   364,     0,  1103,  1668,   692,  1669,   721,   699,   721,
-     721,  1670,  1671,  1672,  1673,  1674,  1675,  1676,  1677,   688,
-     688,  1347,   701,  1678,  1679,  1680,  1381,  1681,  1682,   689,
-     690,   726,  1683,  1684,  1685,  1686,  1687,     0,     0,  1688,
-     721,  1689,   688,  1690,  1691,   693,  1692,   660,  1693,     0,
-    1694,   691,   661,  1695,   729,   729,  1696,  1697,   716,  1698,
-     385,     0,   389,   674,   675,   676,   677,   702,   703,   678,
-     708,   709,   713,   679,   761,   688,  1104,  1105,  1381,   385,
-     381,  1381,   385,  1068,  1381,     0,     0,   167,     0,     0,
-    1159,  1171,  1699,  1700,  1701,  1702,  1703,  1704,  1706,  1705,
-    1707,  1708,  1709,  1710,  1711,  1712,  1713,  1714,  1715,  1716,
-    1717,  1718,  1719,  1720,  1721,  1722,  1723,  1724,  1725,  1726,
-    1727,  1728,  1729,  1732,  1730,  1731,  1733,  1734,  1735,  1736,
-    1737,  1738,  1739,  1740,  1741,  1742,  1743,  1744,  1745,  1747,
-    1746,  1748,  1749,  1750,  1751,  1752,  1753,  1754,  1755,  1756,
-    1757,  1758,  1759,  1760,  1761,  1762,  1763,  1764,  1765,  1766,
-    1767,  1768,  1769,  1770,  1771,  1772,  1773,  1774,  1775,  1776,
-    1777,  1778,  1779,  1780,  1781,  1185,     0,  1186,  1176,  1165,
-    1172,  1173,   130,   423,  1212,  1156,     0,     0,     0,     0,
-    1245,     0,     0,     0,  1077,  1079,  1080,   963,  1090,  1037,
-       0,  1583,  1584,  1585,  1027,     0,  1586,  1587,  1588,  1637,
-     892,   879,   888,   893,   880,   882,   889,  1589,  1590,   829,
-    1591,  1592,  1088,  1593,  1595,  1596,  1598,  1599,  1600,   884,
-     886,  1602,  1603,     0,  1089,  1605,  1606,  1447,  1608,  1609,
-    1611,  1612,   890,  1614,  1616,  1617,  1618,  1619,  1620,  1087,
-    1621,   891,  1623,     0,     0,     0,  1055,   982,     0,     0,
-       0,  1037,   863,     0,     0,   682,   683,   704,   705,   684,
-     710,   711,   685,     0,  1049,   762,   908,  1037,   875,   938,
-     806,     0,   861,   855,  1045,   474,  1043,     0,   856,  1076,
-    1037,  1028,   474,  1041,  1190,  1188,  1194,  1189,     0,     0,
-       0,     0,     0,   640,   639,  1067,  1224,  1222,  1223,  1221,
-    1220,  1227,     0,  1229,  1162,   977,   979,     0,  1028,   469,
-       0,     0,     0,   449,   448,     3,     0,     0,  1232,     0,
-     486,   487,     0,     0,     0,     0,     0,     0,     0,     0,
-     583,   513,   514,   516,   580,   584,   592,     0,   455,     0,
-    1111,  1251,     0,     0,     0,   117,   117,     0,     0,     0,
-       0,     0,    93,    42,    86,     0,     0,     0,     0,   185,
-     198,     0,     0,     0,     0,     0,   195,     0,     0,   178,
-      44,   172,   174,     0,   117,     0,    40,     0,     0,     0,
-      46,  1092,     0,  1635,  1636,  1637,  1638,  1639,   892,   879,
-     888,   893,   889,     0,  1645,  1646,  1594,  1648,  1649,  1650,
-    1651,  1652,  1653,  1654,  1655,  1601,  1657,  1658,  1659,  1660,
-    1661,   890,  1663,  1615,  1665,  1621,   891,     0,  1667,     0,
-     867,   985,   497,   983,  1112,     0,  1093,  1099,  1033,     0,
-    1113,  1816,  1817,  1818,  1819,  1820,  1821,  1822,  1823,  1824,
-    1825,  1826,  1827,  1828,  1829,  1830,  1831,  1832,  1833,  1834,
-    1835,  1836,  1837,  1838,  1839,  1840,  1841,  1842,  1843,  1844,
-    1845,  1846,  1847,  1848,  1849,  1850,  1851,  1852,  1853,  1854,
-    1855,  1856,  1857,  1858,  1859,  1860,  1861,  1862,  1863,  1864,
-    1865,  1866,  1867,  1868,  1869,  1870,  1871,  1872,  1873,  1874,
-    1875,  1876,  1877,  1878,  1879,  1880,  1881,  1882,  1768,  1883,
-    1884,  1885,  1886,  1887,  1030,  1073,  1115,  1114,  1116,  1036,
-       0,     0,   421,     0,     0,  1126,     0,  1107,     0,     0,
-    1381,   166,  1381,   312,     0,   312,     0,  1139,  1142,   377,
-     373,   371,   370,   372,   720,   707,   715,   714,   982,   697,
-     696,   695,     0,   694,     0,     0,   721,   721,   719,   698,
-     674,     0,     0,     0,   725,     0,   723,   383,   384,     0,
-     356,     0,   668,   664,     0,   734,   735,   736,   737,   744,
-     745,   742,   743,   738,   739,   732,   733,   740,   741,   730,
-     731,     0,   746,   747,   748,   749,   750,   751,   752,   753,
-     680,   686,     0,     0,   351,     0,     0,   353,     0,     0,
-       0,   347,     0,   130,     0,   179,  1181,  1182,  1180,     0,
-       0,  1164,   182,   199,  1175,  1184,  1174,  1183,  1163,  1158,
-       0,  1155,   412,  1200,  1199,  1208,   161,     0,   988,     0,
-     130,  1246,  1258,     0,   859,   982,  1026,     0,     0,     0,
-       0,     0,     0,   865,   991,     0,     0,   786,     0,     0,
-       0,  1006,     0,  1012,     0,     0,     0,   787,   766,   767,
-       0,  1054,  1063,   981,     0,   863,   977,     0,   941,   943,
-       0,  1095,     0,   857,   858,   864,     0,  1083,     0,   761,
-     761,  1048,   963,     0,     0,   956,   960,   961,   962,     0,
-       0,     0,  1040,     0,   971,   973,     0,     0,   802,   969,
-       0,   805,     0,     0,     0,     0,   957,   958,   959,   950,
-     951,   952,   953,   954,   955,   967,   949,   783,     0,     0,
-     910,   862,     0,   782,  1046,     0,   601,     0,  1081,  1078,
-       0,  1029,   601,  1202,  1206,  1207,  1205,     0,  1201,  1193,
-    1192,  1197,  1195,  1198,  1196,     0,  1218,     0,  1215,   980,
-     596,   471,     0,     0,  1238,     0,   124,     0,  1233,     0,
-     466,   465,   507,   507,   498,   501,   507,   464,   555,   556,
-       0,     0,     0,     0,   589,   587,  1077,  1090,   543,   517,
-     542,     0,     0,   521,     0,   547,   762,   582,   453,   511,
-     512,   515,   452,     0,   585,     0,   595,   583,   516,     0,
-    1240,  1252,     0,     0,     0,     0,     0,  1381,     0,     0,
-      77,    58,   264,   663,   116,     0,     0,     0,     0,     0,
-       0,     0,    85,    82,    83,    84,     0,     0,     0,     0,
-     183,   184,   197,     0,   188,   189,   186,   190,   191,     0,
-       0,   176,   177,     0,     0,     0,     0,   175,     0,     0,
-       0,     0,     0,     0,     0,     0,   497,   497,   497,   873,
-       0,   495,   496,     0,     0,  1031,  1034,   411,   320,     0,
-     310,     0,     0,     0,     0,     0,     0,   347,  1132,  1130,
-    1128,  1131,  1133,  1108,     0,   159,     0,     0,   163,   165,
-       0,   309,   283,     0,  1144,     0,     0,  1381,  1141,   299,
-       0,     0,     0,     0,   385,     0,   718,   717,   669,   665,
-       0,     0,     0,     0,   390,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   385,   382,   385,  1069,     0,
-     385,   170,     0,  1381,   312,     0,  1160,  1177,   180,   200,
-     181,   201,   444,     0,   418,   426,   431,   409,     0,   409,
-       0,   428,   432,   409,   427,   409,   422,     0,   162,     0,
-    1120,     0,  1119,     0,  1038,     0,     0,  1025,  1021,     0,
-       0,     0,     0,     0,   992,   993,   994,   995,   996,   997,
-     998,   999,  1000,     0,     0,  1001,     0,     0,     0,   948,
-     956,   960,   961,   962,   957,   958,   959,   950,   951,   952,
-     953,   954,   955,   975,     0,     0,     0,     0,     0,     0,
-       0,     0,   831,     0,     0,   937,     0,   977,  1011,     0,
-       0,     0,     0,     0,     0,   977,  1017,     0,     0,     0,
-    1053,     0,  1050,   808,  1037,     0,   944,   807,     0,     0,
-       0,  1085,  1086,   763,   809,   774,   778,   779,   780,   784,
-    1118,  1117,  1047,     0,  1039,     0,     0,   764,   788,   793,
-       0,  1018,   825,     0,   813,     0,   801,     0,   811,   815,
-     789,   804,     0,   785,     0,  1040,   972,   974,     0,   970,
-       0,   775,   776,   777,   768,   769,   770,   771,   772,   773,
-     781,   947,   945,   946,     0,     0,     0,   912,     0,     0,
-     810,  1044,  1373,  1411,     0,   485,   485,   485,   473,   483,
-       0,   652,   497,  1055,   652,     0,   761,   641,  1111,  1228,
-    1216,  1217,   978,  1110,   130,     0,  1236,     0,     0,     0,
-     136,   119,     0,  1234,     0,   152,   154,   601,     0,  1037,
-     505,   506,   510,   510,     0,     0,   510,  1612,  1500,     0,
-       0,     0,     0,   548,   590,     0,   581,   545,   546,     0,
-     544,  1077,   549,  1076,   550,   553,   554,   522,   591,  1064,
-     593,     0,   586,   457,   456,   597,     0,    43,     0,  1381,
-      60,     0,     0,     0,     0,     0,     0,   214,     0,   314,
-     214,    98,  1381,   385,  1381,   385,  1279,  1348,  1516,     0,
-      56,    89,     0,   288,   110,     0,   273,   317,    79,    94,
-     103,     0,     0,    45,   173,   187,   192,   106,   196,   193,
-    1149,   194,   117,     0,    41,     0,   104,     0,  1147,     0,
-       0,    47,   108,  1151,   495,   495,   495,     0,   984,     0,
-       0,     0,   986,   987,  1033,     0,   410,     0,   311,     0,
-     420,   400,   401,   411,     0,   312,     0,   312,  1129,     0,
-       0,  1109,     0,     0,     0,     0,   302,   300,   333,     0,
-     307,   301,   310,     0,     0,   259,     0,  1273,     0,     0,
-     395,     0,     0,     0,     0,     0,   687,   700,   357,   674,
-       0,   728,   727,   729,   729,   674,     0,   658,     0,   672,
-       0,   712,   681,   754,   755,   756,   757,   758,   759,   760,
-     350,   352,     0,   354,     0,     0,     0,   413,     0,   416,
-       0,   415,   419,   414,   408,     0,   439,     0,     0,     0,
-       0,     0,     0,  1209,   989,   490,   830,     0,     0,  1022,
-       0,     0,   906,     0,   881,   883,   896,     0,   885,   887,
-       0,   964,     0,     0,     0,   897,   833,   834,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   850,   849,   898,   936,
-       0,     0,  1009,  1010,     0,   899,     0,     0,  1016,     0,
-       0,     0,   904,     0,  1070,     0,     0,     0,  1062,   860,
-     978,   942,   940,   866,   761,     0,     0,     0,     0,     0,
-       0,     0,   814,   803,     0,   812,   816,     0,     0,     0,
-     797,     0,     0,   795,   826,   791,     0,     0,   827,     0,
-       0,   911,   920,   485,   485,   485,   485,   482,   484,     0,
-       0,     0,     0,  1500,     0,   624,   604,   600,   602,   611,
-     624,   629,   876,   650,   877,  1095,     0,   560,   495,  1063,
-     560,     0,  1203,  1219,     0,  1237,     0,   141,   123,   143,
-     142,     0,   150,     0,  1037,     0,   141,   125,     0,   144,
-     155,  1236,     0,   158,     0,   499,   500,   502,     0,   965,
-     510,   504,   552,   551,     0,   520,   588,   518,     0,   594,
-       0,     0,     0,   263,     0,     0,     0,   214,     0,   322,
-       0,   329,     0,     0,   314,   295,    78,     0,     0,     0,
-      52,    97,    70,    62,    48,    76,     0,     0,    81,     0,
-      74,    91,    92,    90,    95,     0,   249,   224,   260,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   497,   493,   494,   868,  1032,
-     442,   443,   178,   441,   321,     0,     0,   309,     0,  1144,
-    1127,   347,     0,     0,   166,   312,     0,   287,   283,   308,
-     281,   280,   282,     0,  1274,   171,     0,  1268,  1143,     0,
-     396,     0,   392,     0,  1138,   706,   671,     0,   724,   722,
-     670,     0,   666,   673,   385,     0,   445,     0,   404,   440,
-     429,   434,     0,   438,   436,   435,   430,   433,     0,  1024,
-    1020,     0,   878,   990,     0,   976,  1004,  1003,   832,   841,
-     845,   846,   847,  1005,     0,     0,     0,   842,   843,   844,
-     835,   836,   837,   838,   839,   840,   848,  1014,  1013,  1007,
-    1008,     0,   901,   902,   903,  1015,     0,  1071,  1052,   977,
-    1057,  1059,     0,     0,   939,  1084,   765,     0,     0,   794,
-    1019,   817,     0,     0,     0,   790,   964,     0,     0,     0,
-       0,     0,   799,     0,     0,     0,     0,   874,     0,     0,
-       0,     0,   476,   475,   481,   624,   629,     0,   459,     0,
-     611,     0,   623,   539,   622,   605,     0,   635,   633,     0,
-     635,     0,   635,     0,   539,     0,   625,   539,   622,     0,
-     642,  1067,   651,     0,   577,     0,  1051,   577,     0,   472,
-    1235,     0,  1231,     0,     0,     0,   131,   128,   118,     0,
-       0,   153,   141,   132,   508,   509,     0,   503,   519,  1065,
-     111,   214,     0,     0,    59,     0,   331,   275,   323,   306,
-     290,     0,     0,     0,   215,     0,   348,     0,     0,   296,
-       0,     0,     0,     0,   276,     0,     0,   235,     0,     0,
-     306,     0,   313,   231,   232,     0,    51,    71,     0,    67,
-       0,    96,     0,     0,     0,     0,     0,    54,    66,     0,
-      49,     0,   385,   385,    57,   274,  1103,  1668,  1669,  1670,
-    1671,  1672,  1673,  1674,  1675,  1676,  1677,  1678,  1679,  1794,
-    1680,  1681,  1682,  1683,  1684,  1685,  1686,  1687,  1803,  1688,
-     221,  1689,  1447,  1690,  1691,  1692,  1693,     0,  1694,   661,
-    1695,  1696,  1697,  1698,   950,   951,   219,   316,   216,   324,
-     218,   220,     0,  1104,   217,   319,   107,  1150,     0,   105,
-       0,  1148,   114,   112,   109,  1152,   871,   872,   869,   495,
-     423,   403,     0,     0,  1273,     0,     0,  1381,     0,  1144,
-     164,   309,     0,   339,   259,   334,     0,  1273,  1271,     0,
-    1267,   391,     0,     0,     0,   667,   659,   355,     0,   417,
-       0,   437,  1023,   894,   905,  1002,     0,     0,     0,     0,
-     900,   895,  1060,  1061,  1056,   823,   821,   818,     0,   819,
-     798,     0,     0,   796,   792,     0,   828,   907,     0,   923,
-     918,   919,   480,   479,   478,   477,   610,   608,     0,   613,
-    1095,   620,   532,   538,   609,     0,   603,     0,   634,   630,
-       0,   631,     0,     0,   632,     0,   606,     0,  1095,   607,
-       0,   649,     0,     0,   914,   868,   914,  1204,   140,   120,
-       0,   121,   151,     0,     0,     0,     0,   145,   397,     0,
-     327,    61,     0,   306,     0,   214,   292,   291,   294,   289,
-     293,     0,   349,     0,     0,   233,     0,   240,   278,   279,
-     277,   234,   306,   312,   236,     0,     0,     0,    63,    53,
-      50,    55,    64,     0,     0,    65,    68,   657,    80,    73,
-    1803,  1811,     0,     0,     0,     0,     0,     0,   399,   406,
-     178,     0,     0,   283,  1270,     0,     0,     0,   309,     0,
-       0,     0,  1273,     0,     0,   211,     0,   256,     0,   168,
-    1272,     0,  1260,     0,  1136,  1137,     0,     0,   405,   851,
-       0,     0,     0,  1058,   820,   824,   822,   800,   909,   925,
-     922,   645,     0,   648,   612,     0,     0,   527,   534,     0,
-     537,   531,     0,   614,     0,     0,   616,   618,     0,     0,
-       0,   653,     0,     0,     0,  1072,   558,  1323,  1595,  1499,
-     559,     0,   563,   557,   561,   566,   568,   567,   569,   565,
-     576,     0,   579,  1082,   579,     0,     0,     0,     0,   156,
-       0,   147,   147,     0,   133,   966,     0,   214,     0,   305,
-     328,   245,   223,     0,     0,     0,   230,   237,   338,   239,
-       0,    72,     0,    88,     0,     0,   318,   115,   113,   870,
-     423,     0,  1144,   259,  1267,     0,     0,     0,   283,   171,
-    1269,   272,   265,   266,   267,   268,   269,   270,   271,   286,
-     285,   257,   258,     0,     0,     0,  1138,     0,   852,     0,
-     853,     0,   497,   650,     0,     0,   644,     0,   525,   523,
-     526,   528,   524,     0,     0,   621,   637,     0,   617,   615,
-     626,     0,   657,     0,   628,     0,     0,     0,   570,   564,
-     913,   915,     0,     0,   530,   530,     0,   127,     0,   652,
-       0,     0,   149,   149,   135,     0,   312,   330,     0,   297,
-     304,   243,   242,   244,   248,     0,   246,     0,   262,     0,
-     255,   223,   656,     0,    75,     0,   325,   398,   402,     0,
-     213,  1261,   309,     0,  1267,   259,  1273,     0,  1264,     0,
-       0,  1144,   854,     0,   928,   643,   646,     0,   619,     0,
-       0,     0,   654,   655,   627,     0,     0,     0,   562,     0,
-       0,   578,     0,   461,   460,   122,   147,   126,   157,   146,
-     507,   148,   507,     0,   338,   284,     0,     0,     0,   245,
-       0,   238,   335,   336,   337,     0,   251,   241,   252,    69,
-      87,   326,     0,   309,  1262,   212,   169,  1265,  1266,     0,
-     652,   924,     0,     0,     0,     0,   535,     0,   541,   636,
-     572,     0,   571,   916,   917,   532,   149,   510,   510,   652,
-     255,   298,   303,   222,   247,   261,     0,     0,     0,   253,
-       0,   254,  1267,     0,  1134,  1582,  1324,  1552,     0,   926,
-     929,   927,   921,   647,     0,     0,   533,   573,   529,   507,
-     138,   137,   134,   214,   227,     0,   226,     0,   315,   250,
-    1263,  1144,     0,   933,   932,   931,   935,   934,   536,     0,
-     510,   332,   225,   229,   228,   652,     0,     0,   139,  1135,
-     930,   540
-};
-
-/* YYDEFGOTO[NTERM-NUM].  */
-static const yytype_int16 yydefgoto[] =
-{
-      -1,    37,    38,    39,    40,  2202,  2203,  2204,  1879,  1032,
-    2924,  1880,  1033,  1034,  2206,    41,    42,  1496,   545,  1810,
-    1435,  2655,    44,  2152,  1815,  2156,  2799,  2412,  2151,  2158,
-    2902,  2970,  2153,  1816,  1817,  2800,  1818,    45,    46,    47,
-    1568,    48,   757,    49,  1569,  1523,  1303,  1052,  1513,  1292,
-      50,    86,    51,  2191,  2527,  2916,  2216,  3058,  2462,  2463,
-    2913,  2914,  2194,  1881,  2986,  2987,  2264,  1505,  2981,  1946,
-    2849,  1885,  1867,  2464,  1955,  2809,  2563,  1882,  2444,  1947,
-    2908,  1578,  1948,  2909,  2665,  1949,  1548,  1572,  2195,  2988,
-    1886,  1549,  2190,  2528,  1492,  1950,  2920,  1951,   504,  2448,
-      52,   537,   538,   749,  1240,   539,   730,    53,   662,  1576,
-     546,    55,  1933,  2710,  2287,  2711,  2005,  1927,  1301,  2002,
-    1622,  1552,  1302,   494,  1636,  2288,  2242,  1623,   547,   932,
-      58,    59,    60,   586,   599,   600,  1406,  1788,  2119,  1002,
-     573,   574,  1921,   614,  1542,  1444,  1445,  1822,  2165,  1471,
-    1472,  1011,  1012,  2758,  2963,  2759,  2760,  2623,  2624,  3046,
-    1459,  1463,  1464,  1842,  1832,  1450,  2404,  2782,  2783,  2784,
-    2785,  2786,  2787,  2788,   933,  2644,  2894,  1467,  1468,  1014,
-    1015,  1016,  1476,  1852,    62,    63,  1791,  2126,  2127,  2128,
-    2129,  2382,  2383,  2397,  2393,  2629,  2766,  2130,  2131,  2751,
-    2752,  2866,  2400,  2137,  2770,  2771,  2823,  1595,   731,  1868,
-    1308,  1243,   733,   934,   734,  1219,   935,  1223,   736,   936,
-     937,   938,   739,   939,   940,   941,   742,  1215,   942,   943,
-    1234,  1262,  1263,  1264,  1265,  1266,  1267,  1268,  1269,  1270,
-     985,  1691,   945,   946,   947,  2133,   948,  1400,  1777,  2112,
-    2792,  2890,  2891,  2367,  2610,  2749,  2862,  3004,  3039,  3040,
-     949,   950,  1348,  1349,  1350,  1774,  1395,  1396,   951,  2530,
-    1398,  1684,   986,  1706,  1344,  1102,  1103,  1309,  1663,  1664,
-    1687,  2034,  1694,  1699,  2062,  2063,  1707,  1742,   952,  1647,
-    1648,  2020,  1317,   953,   639,  1109,   640,  1314,  1736,   962,
-     954,   955,   956,  1341,  1342,  2078,  2341,  2342,  1712,  1848,
-     591,  2074,  2762,   753,  1184,   957,   958,   959,   960,   988,
-     593,  1104,   487,   745,  2971,  1197,   992,  1105,  1883,  1732,
-      64,   859,   644,    65,  1195,  1560,    66,  2735,  2574,  1208,
-    1580,  1959,   505,    67,    68,    69,    70,    71,   621,  1295,
-     548,  1296,  1297,   846,    72,  1304,   848,   849,    73,   580,
-     581,  1305,  1419,  1306,    74,   559,    75,   981,   596,   982,
-     984,   550,   999,  2147,  1806,    77,    78,   567,   568,    79,
-      80,   582,    81,    82,  2732,   551,  2267,  1936,   514,   489,
-     490,   747,  1187,  1107,  1188
-};
-
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-   STATE-NUM.  */
-#define YYPACT_NINF -2709
-static const int yypact[] =
-{
-    3201,  -111,   600, -2709, -2709,  -111, 35846, -2709,  -111,    54,
-    1232, 40142, -2709,  6825,  -111, 47776,  1052,   238,   239,   255,
-   40621, 40621, 47776, 47776, 41100,  -111,   266, 48255, -2709,  -111,
-   24693, 38226,   -20,  -102, 48734, 47776,  1256,   408,   -38, -2709,
-   -2709, -2709, -2709, -2709,   124, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709,   196, -2709,   211,
-     205,   -84,   -16, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709,   222, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   24214, -2709, -2709, -2709, -2709, -2709, -2709, 41579, 47776, 42058,
-   38705, 42537, -2709,   110, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709,   155, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709,   156, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709,   163, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709,    84,   622, -2709,   176, -2709,
-   -2709, -2709, -2709,  1256, 43016,   639,   796,   261, 49213, -2709,
-   -2709, 47776, -2709, -2709,  1316,   540, -2709, -2709, -2709, -2709,
-   43495, -2709, -2709, -2709, -2709,   520, -2709, -2709,   375, -2709,
-     136, -2709, -2709,   442,   405, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709,   502, -2709, 43974, -2709, 49692, 50171, 50650,
-   -2709,   437,   665,   649, 22777, -2709, -2709, -2709, -2709,   222,
-   -2709, -2709,   936, -2709, 40621,   936, -2709, -2709, -2709, -2709,
-   -2709,   324,   457, -2709,   494,   769, -2709, -2709, -2709,   525,
-   -2709, -2709,   754, 10807, 10807, 51129, 51129,   936, 51129,   594,
-   -2709, -2709,   315, -2709,  -102, -2709,   -84,   525, -2709, 25173,
-   -2709,   620,   622, -2709, -2709,   216,   924, 14335, 47776,   617,
-   -2709,   633,   617,   674,   678, -2709,  3201,  1024,  1010, 38226,
-     310,   310,  1186,   310,   545,   675, -2709,  1317, -2709,   767,
-   -2709, 43016, -2709,   789,  1057, -2709,   525,  1132,   235,   951,
-    1153,  4009,  1157,   824,  1180,   846,  7279, 14335, 33451, -2709,
-     622, -2709, -2709, -2709,   837, -2709,   869, -2709, -2709, -2709,
-   -2709,   740,  1124, -2709,   919,  1385, -2709, -2709,   984, 44438,
-   44917, 43016, 43016,  1343, -2709, -2709, -2709, -2709,   986, -2709,
-   -2709, -2709,   123, -2709, -2709, -2709, -2709,   980, -2709,   980,
-     980, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,   982,
-     982,  1143,   992, -2709, -2709, -2709,  1324, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709,  1001,  1017, -2709,
-     980, -2709,   982, -2709, -2709, -2709, -2709, -2709, -2709, 54467,
-   -2709, -2709, -2709, -2709,   654,   731, -2709, -2709, -2709, -2709,
-      72,  1018, -2709,  1430, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709,  1045, -2709,  5229,   982, -2709, -2709,  1404,   166,
-   -2709,  1444,   180, -2709,  1450,  1292, 14335, -2709,  1262,  1203,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709,  -102, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709,   712, -2709, -2709, 31026,
-   -2709, -2709,   649,  1115, -2709, -2709, 31026, 14839, 45396,  1583,
-   -2709,  1398, 47776,  1134, -2709, -2709, -2709, -2709, -2709, -2709,
-    1146,  1653,   140,  1655, 14335,  1164,   140,   140,  1169,  1499,
-     177,   178,   179,   182,  1179,  1188,   186,   187,   187, -2709,
-    1194,  1195, -2709,   188,  1206,  1210,  1673,  1674,   141,  1216,
-    1217,  1017,   140, 14335, -2709,  1219,   187,  1221,  1222,  1226,
-    1696,  1227,   189,  1728,  1237,    97,   103,  1238,  1243, -2709,
-    1244,   192,   195, 14335, 14335, 14335,  1592, 14335,  8287, 43016,
-    1734, -2709,   622,  1252,   936, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709,   157,  5014, -2709,  1295, -2709, -2709, -2709,
-    1455, 14335, -2709, -2709,  1255,  1543, -2709,   198, -2709, -2709,
-   -2709,   625,  1543, -2709, -2709, -2709, -2709, -2709,   227,  1662,
-   30068, 30547, 43016, -2709, -2709,   622, -2709, -2709, -2709, -2709,
-   -2709, -2709,   721, -2709,   222, 32269,  1260,  1264,   622,   617,
-   47776, 47776,  1730, -2709, -2709, -2709, 38226, 43016, 51608,  1394,
-   -2709, -2709,   -84,   -84,  9799,   -84,   106,   630, 11311, 15343,
-    1605,  1488,   585,   751,  1607, -2709,  1494,   545,   675, 14335,
-     633, -2709,  1545, 43016, 36325,   747,   954,  1280,  1363,  1284,
-     516,  1701, -2709,  1281, -2709,  1375, 43016, 54467,   231, -2709,
-    1737,   231,   231,   683,  1739,  1382,   243,  1539,   -41,  -106,
-    1281,  2808, -2709, 38226,    65,   469,  1281, 43016,  1387,   534,
-    1281,    96, 14839,  1130,  1149,   268,  1241,  1274,   109,   114,
-     119,   125,   130, 14839,  1285,  1301,   142,  1307,  1335,  1341,
-    1427,  1471,  1534,  1549,  1553,   160,  1575,  1585,  1590,  1598,
-    1602,   162,  1612,   165,  1614,    86,   172, 14839,  1624,  1305,
-   -2709, 32269,   -46, -2709, -2709,  1633,   175, -2709, 28632,  1299,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-    1391, 47776,  1348,   -36,  1658,  1716, 33451,  1320, 45396, 43016,
-    1550,  2808,  1551,  1318,  1792,   869,  1333, -2709, 52087, -2709,
-   -2709, -2709, -2709, -2709, -2709,  1334, -2709, -2709, 14335, -2709,
-   -2709, -2709,  1826, -2709, 45396, 45396,   980,   980, -2709, -2709,
-    1800,  1423,  1424,  1826, -2709,  1826, -2709, -2709, -2709, 45396,
-   -2709, 47776,  1344,  1345,  1826, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709,  1826,  1428, -2709,  1429,  1431,  1434, -2709, -2709, -2709,
-   -2709, -2709, 47776, 47776, -2709, 47776, 47776, -2709, 47776, 47776,
-    1340,   740, 45860,   649, 35367, -2709, -2709, -2709, -2709,  1053,
-    1111, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   33451, -2709,  2760, -2709, -2709, -2709,  1351,   729, -2709,   757,
-    1256, -2709, -2709, 14335,   622, 14335, 32269,  1399, 14335, 14335,
-    1358,  1826,  1826, -2709,  4962,  1826,  1826,  3687, 14335, 28052,
-   14335, 18871, 11815, 14335, 14335,  8791, 14335,  3687,  1846,  1846,
-   26131, -2709,  1516, -2709,  1365,  1990,  5299,  1361, -2709,  1362,
-    1378, -2709,  1359, -2709,   622,   622, 14335, -2709, 14335,  2845,
-    2845, -2709,   296, 45396, 14335, 14335, 14335, 14335, 14335, 14335,
-   32972,  1453,   122, 47776, 14335, 14335,  1371,  1030, -2709, 14335,
-    1608, -2709,  1389, 14335,  1467,   257, 14335, 14335, 14335, 14335,
-   14335, 14335, 14335, 14335, 14335, -2709, -2709, 20369,   313,  1706,
-    1727,   622,   -99,   262, 10807, 39184,  1719,  7279, -2709,   622,
-   29110,   120,  1719, -2709, -2709, -2709, -2709,   201, -2709, -2709,
-   -2709, -2709,  1351, -2709,  1351,  1395, 43016,   216, 37283, 14335,
-   -2709, -2709,   783,  1403,  1463,   644,  1856, 47776, -2709, 26610,
-    1690, -2709,   708,   708,  1405, -2709, 31502,  1690, -2709, -2709,
-   19361,  1530,  1689,  1626, -2709, -2709,  1610,  1613, -2709,  1414,
-   32497, 15847, 15847, -2709,  1294, 32269,  1297, -2709, -2709, -2709,
-   -2709, -2709, -2709,   651, -2709, 43016,    20,  1605,   751,  1421,
-   -2709, -2709,   927,  1432, 52566, 47776,  1704,  1657,  1708,  -105,
-   -2709, -2709, -2709, 45396, -2709, 47776, 47776, 53045, 53524, 33930,
-   47776, 33451, -2709, -2709, -2709, -2709, 47776,   510, 47776,  6851,
-   -2709, -2709, -2709,   231, -2709, -2709, -2709, -2709, -2709, 47776,
-   47776, -2709, -2709,   231, 47776, 47776,   231, -2709,   996, 47776,
-   47776, 47776, 47776,  1448, 47776, 47776,    33,    33,  1640, -2709,
-   12319,    85, -2709, 14335, 14335, -2709, 14335,  1609, -2709,   836,
-   -2709,  1650,   153,  1484, 43016, 43016, 47776,  1415, -2709, -2709,
-   -2709, -2709, -2709, -2709, 33451, -2709,  1439,  1787, -2709,  2808,
-    1788, 36804,   436,   905,  1481, 12823,  1905,  1672, -2709, -2709,
-    1663, 14335,  1445,  1449,    72,   841, -2709, -2709,  1456,  1345,
-    1470,  1472,  1458,  1459, -2709,   843, 45396,  1826,   139,  1460,
-    1462,  1246,   832,   817,  1291,   166, -2709,   180, -2709,  1668,
-     149, -2709,  1562,  1697,   869,  1932, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709,   845, 21819, -2709, -2709,  1933,   936,  1933,
-     560, -2709, -2709,  1933, -2709,  1933, -2709, 31026, -2709, 14839,
-   -2709, 45396, -2709,  1473, -2709,  1474, 14335,    71, -2709, 31563,
-    1476, 14335,  1477,  1490, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709,  1491,  1810, -2709,  1496,  1498,  4568, -2709,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709, -2709,  1501,  1493, 31653,  1502, 18871, 18871,
-    8287,  1492, -2709, 18871,  1503, -2709,  1506, 31515,  1489,  1507,
-   31883, 13327, 14335, 13327, 13327, 31937, -2709,  1508, 32076, 47776,
-   -2709, 16351, -2709, -2709, -2709, 14335, 43016, -2709, 14335,  1509,
-    5385, -2709, -2709, -2709,   262,   838,  4939,  4939,  4939,  3687,
-   -2709, -2709, -2709,  1517, -2709, 18871, 18871, -2709,  4034,  1386,
-    8287, -2709, -2709,  1834, -2709,   707, -2709,  1511, -2709, -2709,
-    2965, -2709, 28052,  2635, 14335,   154, -2709, 14335,  1371, 14335,
-    1594,  4939,  4939,  4939,   333,   333,   200,   200,   200,   838,
-     262, -2709, -2709, -2709,  1513,  1515,  1518,  1860,  1227, 14335,
-   -2709, -2709,   965,  1161, 43016,   126,  3326,  4540, -2709, -2709,
-   22298,  1560,   -46,  1592,  1560,  1826,  2845, -2709,   633, -2709,
-   -2709, -2709, 32269, -2709,  1256, 22298,  1561,  1576,   400, 24693,
-    1740, -2709, 47776, -2709, 47776, -2709,  1521,  1719,  1541, -2709,
-   -2709, -2709,  1546,  1546, 14335,   920,  1546,  1743,  1744,  1141,
-    1141,  1294,  1745, -2709, -2709,  1621, -2709, -2709, -2709, 14335,
-    9295,  1313, -2709,  1315, -2709, -2709, -2709, -2709,  1538, -2709,
-   -2709,  1809, -2709, -2709, -2709, -2709,  1645,  1281, 14335,  1795,
-   -2709,   104,  1565,  1917,   286,  1870, 47776, -2709,   224,   280,
-   -2709,   779,  1920,   149,  1921,   149, 33451, 33451, 33451,   854,
-   -2709, -2709,   936, -2709, -2709,   876, -2709,  -184, -2709, -2709,
-   -2709,  1659,   602,  1281,  2808, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709,   134,   650,  1281,  1660, -2709,  1661, -2709,  1664,
-     773,  1281, -2709, -2709,    85,    85,    85, 14839, -2709,  1796,
-    1803,  1579, 32269, 32269, 32269,  1586, -2709,   332, -2709, 47776,
-   -2709, -2709, -2709,  1609, 43016,  1587,  2049,   869, -2709,  1746,
-     827, -2709, 47776, 43016, 43016, 43016, -2709, -2709, -2709,  1588,
-    1595, -2709, 37762,   -22,  1804,  1812, 47776,  1630,  1284,  2062,
-   -2709,   897, 13831,  1951, 43016,  1604, -2709, -2709, -2709, -2709,
-    1826, -2709, -2709,   488,   488, -2709, 47776, -2709,  1616, -2709,
-    1617, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, 47776, -2709, 43016,  1953,  1256, -2709, 33451, -2709,
-   34888, -2709, -2709, -2709, -2709,   936, -2709,   936,  1829, 47776,
-   29589,   936,   936, -2709, -2709, -2709, -2709, 32161, 14335, -2709,
-    1964, 45396, -2709,  5632, -2709, -2709, -2709, 14335, -2709, -2709,
-   14335, -2709, 28052, 14335,  1937, -2709,  2098,  2098,  5299, 45396,
-   18871, 18871, 18871, 18871, 18871,   663,  1221, 18871, 18871, 18871,
-   18871, 18871, 18871, 18871, 18871, 18871, 19865,   272, -2709, -2709,
-   14335, 14335,  1946,  1937, 14335, -2709, 45396,  1622, -2709,  1623,
-    1628, 14335, -2709, 45396,  1618,  1629,  8287, 32215, -2709,   622,
-    5910, -2709, 32269, -2709,  2845, 14335,  1906,  2497, 14335,  1634,
-   14335,  1955, -2709, -2709,  1625, -2709, -2709, 45396, 14335,  1636,
-    3366, 18871, 18871,  3519, -2709,  3975, 14335,  8287, -2709,  1640,
-    1681, -2709,  1843,  1736,  1736,  1736,  1736, -2709, -2709, 43016,
-   43016, 43016, 23256,  1973, 21337, 46339,  1643, -2709,  1069, -2709,
-   46339, 46818, -2709,  1669, -2709,   622, 14335,  1967,    85,  1516,
-    1967,  1648, -2709, -2709,  1670, -2709, 14335,  1805, -2709, -2709,
-   -2709,  1707, -2709,   916, -2709,  2072,  1805, -2709,   925, -2709,
-   26610,  1561, 14335,   622,   553, -2709, -2709, -2709,  1676, -2709,
-    1546, -2709, -2709, -2709,  1871, -2709, -2709, -2709, 43016, -2709,
-   47776,  6233,  2008, -2709, 47776, 47776, 47776, -2709, 47776,  1666,
-    1671,   903,  1677,   349, -2709,  2256,   903,  1987,   212,  1284,
-     243,  6665,   624, -2709, -2709, -2709,  1749, 47776, -2709, 47776,
-   -2709, -2709, -2709, -2709, -2709, 33930, -2709, -2709, -2709, 33451,
-   27572, 33451, 47776, 47776, 47776, 47776, 47776, 47776, 47776, 47776,
-   47776, 47776,  1678,  1680,  1682,  1640, -2709, -2709, -2709, -2709,
-   -2709, -2709,  -106, -2709, -2709,   332,  1684, 36804,  1256,  1481,
-    1716,   740, 47297,   931,  2808,  1685,  2134, -2709,   436, 36804,
-   -2709, -2709, -2709,  2092, -2709,   437,   150, -2709, -2709,  1256,
-   -2709,  1256, 32269, 47776,  1747, -2709,  1345,  1687, -2709, -2709,
-    1345, 45396, -2709, -2709,   149, 43016, -2709,   935, -2709, -2709,
-   -2709, -2709, 47776,  1683, -2709,  1683, -2709, -2709, 14335, 32269,
-   -2709,  1691, -2709, 32269,  6457, -2709, 32269,  1946, -2709,  2098,
-    1028,  1028,  1028,  2560,  2016,   158,  1693,  1028,  1028,  1028,
-     244,   244,   213,   213,   213,  2098,   272, 32269, 32269, -2709,
-   -2709,  1694, -2709, -2709, -2709, -2709,  1698, 47776, -2709,  5063,
-   -2709,  1686,  1700, 47776, -2709, -2709,   299, 14335, 14335,  4034,
-   -2709,  3705, 14335, 45396,   946,  4034,   323, 14335,  4327,  4876,
-   14335, 14335,  6247,  6639,  1702, 14335, 27089, -2709, 43016, 43016,
-   43016, 43016, -2709, -2709, -2709, 46339, 46818,  1705, 20857,  1069,
-    1703, 43016, -2709,  1782,  1709, 22298,  1971,  1900, -2709, 22298,
-    1900,   658,  1900,  1975,  1782, 25652, -2709,  1782,  1710,  1907,
-   -2709,   764, 32269,  2150,  2028,  1713, -2709,  2028,   936, -2709,
-   32269, 10807, -2709,  1256,  1234, 47776,   622,     6, -2709,  1729,
-   47776, -2709,  1805, 32269, -2709, -2709, 28052, -2709, -2709, -2709,
-   -2709, -2709, 47776,  1718, -2709,  1720,   903, -2709, 47776,  1758,
-   -2709,   194,  2020,    81, -2709, 14335, -2709,  2106,  2188,  2256,
-    1731, 47776, 47776, 18871, -2709,   253,   161, -2709,  2003, 43016,
-    1758,  2146, -2709, -2709, -2709,   349, -2709,  2041,  1956, -2709,
-     231, -2709, 14335,   349,  1957,    88, 47776, -2709, -2709,  3218,
-   -2709, 45396,   149,   149, -2709, -2709,  1735,  1738,  1741,  1750,
-    1751,  1752,  1753,  1754,  1756,  1759,  1760,  1761,  1763, -2709,
-    1764,  1765,  1766,  1767,  1768,  1770,  1771,  1772,  1001,  1774,
-   -2709,  1777,  1676,  1779,  1780,  1781,  1783, 54003,  1784,  1785,
-    1789,  1791,  1794,  1797,  1053,  1111, -2709, -2709, -2709, -2709,
-   -2709, -2709,   919,  1798, -2709,  1757, -2709, -2709,  1815, -2709,
-    1818, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,    85,
-    1115,    75, 47776,  1748,  1630,  2199,   -35,  1966,  1742,  1481,
-   -2709, 36804,  1229,   170,  1812, -2709,   133,  1630, -2709,  2135,
-    1786, -2709,  1959, 47776,  1790, -2709, -2709, -2709,  2221, -2709,
-   34888,  1683, 32269, -2709, -2709, -2709, 18871,  2129,  1807, 45396,
-   -2709, -2709, 14335, -2709, -2709,  4034,  4034,  3705,   952, -2709,
-    4034, 14335, 14335,  4034,  4034, 14335, -2709, -2709,  6742, 54931,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, 34409, 46339,
-    1808, -2709, 39663, -2709, -2709, 47776,  1069, 22298, -2709, -2709,
-     219, -2709, 22298,  2080, -2709, 22298, -2709, 47776,  1811, -2709,
-   47776, -2709, 10303, 14335,  1844,   936,  1844, -2709,  1806, -2709,
-     400, -2709, -2709,  2220, 23735,  2179, 14335, -2709, -2709,  1813,
-     903, -2709,  1978,  1758,  1816, -2709, -2709, -2709, -2709, -2709,
-   -2709,  6777, -2709,    55, 14335, -2709,   794,  2560, -2709, -2709,
-   -2709, -2709,  1758,   869, -2709, 47776,  2280,  2167, -2709, -2709,
-   32269, -2709, -2709,  1826,  1826, -2709, -2709,  2246, -2709, -2709,
-   -2709, -2709,   919,   487, 27572, 47776, 47776,  1822, -2709, -2709,
-    -106,  2200,   960,   436, -2709,  1256, 43016,  2171, 36804,  2289,
-    1830, 47776,  1630,  1364,  1364, -2709,  1976, -2709,  1979, -2709,
-   -2709,   725, -2709, 43016, -2709, -2709, 23735,  1256, -2709,  3952,
-   18871, 45396,   968, -2709, -2709,  4034,  4034,  4034, -2709,  2023,
-   -2709, -2709,   972,  2295, -2709, 47776,   -58,   -80,  1837,  1839,
-   -2709, -2709,  1840, -2709, 14335,  1842, -2709, -2709, 22298,   219,
-     977, -2709, 45396, 47776,   990, 45396, -2709,  1850,  -107,  1851,
-   -2709,  7783,  1848, -2709, -2709, -2709, -2709, -2709, -2709, 32269,
-   32269, 47776,  2018, -2709,  2018, 10807,  1908, 47776, 14335, -2709,
-    1005,  2278,    46,    -9, 32269, -2709, 43016, -2709, 33451, -2709,
-     903,   410,  1858, 14335, 28539,  2082, -2709, -2709,  2113, -2709,
-    2173, -2709, 47776,  1922,   542,  1936, -2709, -2709, -2709, -2709,
-    1115,   936,  1481,  1812,  1786,  1866, 43016,  1256,   436,   437,
-   -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709, -2709,
-   -2709, -2709, -2709,  2298,  2078,  2300,  1747,  1025,  3952,  1026,
-   -2709,  2316,  1640,  1669, 34409,  1879, -2709,  1887, -2709, -2709,
-   -2709, -2709, -2709, 47776,  1166, -2709, 32269, 47776, -2709, -2709,
-   -2709, 47776,  2246,  1027, -2709, 14335,  1889, 14335, -2709, 16855,
-    1886, -2709,  2352, 14335,  1954,  1954,  1256, -2709, 28568,  1560,
-   23735, 47776, 47776, 47776, -2709,  2026,   869,   903,  1033, -2709,
-    1915, -2709, -2709, -2709, -2709,  2808, -2709, 28603,  2138,    41,
-    2117,  1858, -2709, 14335, -2709,  1977, -2709, -2709, -2709,  2371,
-   -2709, -2709, 36804,  1913,  1786,  1812,  1630,  2126, -2709,  2127,
-    1919,  1481, -2709, 14335,   576, -2709, -2709, 47776, -2709,  1040,
-    1925,  1926, -2709, -2709, -2709,  1927, 16855,  1929, -2709, 47776,
-    1935, 32269,  2059, -2709, -2709, -2709,  2278, -2709, -2709, -2709,
-     708, -2709,   708, 26610,  2113, -2709, 33451, 27572,  2183,   410,
-    2218, -2709, -2709, -2709, -2709,   132,  2144, -2709,  2145, -2709,
-   32269, -2709,  1256, 36804, -2709, -2709, -2709, -2709, -2709, 23735,
-    1560,  1489, 17359, 17359,  1938,  1042, -2709,  2426,  2094, -2709,
-   -2709,  1939, -2709, -2709, -2709, 39663, 47776,  1546,  1546,  1560,
-    2117, -2709, -2709, -2709, -2709, -2709,   304,   304,  2322, -2709,
-    2006, -2709,  1786,  1054, -2709, 18367,  2090,   116, 31550, -2709,
-   -2709, -2709, -2709, -2709,  1958,  1960, -2709, -2709, -2709,   708,
-   -2709, -2709, -2709, -2709, -2709,  2432, -2709,   151, -2709, -2709,
-   -2709,  1481,  2422, -2709, -2709, -2709, -2709, -2709, -2709,  2451,
-    1546,   903, -2709, -2709, -2709,  1560, 17863,  1962, -2709, -2709,
-   -2709, -2709
-};
-
-/* YYPGOTO[NTERM-NUM].  */
-static const yytype_int16 yypgoto[] =
-{
-   -2709, -2709, -2709,  1857, -2709, -2709, -2709,   260, -2709,   958,
-   -2709,   252,  -555,   597, -2709, -2709, -2709,  -973,     9, -2709,
-   -2709, -2709, -2709,    57,   311, -2709,  -426, -1915,  -172, -2709,
-   -2538, -2610, -2709, -2709,  -494, -2522, -1737, -2709, -2709, -1154,
-     228, -2709, -2172, -2709,  -628, -1029,  -804, -1033, -2709,    10,
-   -2709,  1181, -1152, -1828, -2489,  -440, -2709,  -540, -2709,  -188,
-   -2709,  -488, -2709,  -305,  -495,  -528, -2422,  -977, -2709,  1475,
-    -230, -2709,   631, -2709, -2174, -2709, -2709,   621, -2709,  -985,
-   -2709, -1858,   241,  -479, -2227, -2184, -1833,  -644,   307,  -483,
-     285, -1783,  -610, -2709,   645, -2709,  -467, -2709,  -514, -1573,
-   -2709, -2709, -2709,  1240,  -738, -2709,  1286, -2709, -2709, -2709,
-      13, -2709, -2709, -2709, -2709, -2709,  -569,   586, -2337, -2709,
-     511, -2709, -2709, -2709, -2709,   -62,   275, -2709,     7,    56,
-     -14,   -11,     4,     8,    59,  1532,  1563, -2709, -1340,   974,
-   -2709, -2709, -1826,  -613,   -53, -2709,   699, -1413, -1765,  -496,
-    1046,  1514,  1522,  -345,  -357, -2709,  -475, -2709, -1131, -2709,
-   -2709,   700,  1092, -1322, -1274, -2709,   403, -2709,  -412,  -343,
-   -2709, -2709, -2709, -2709, -2709,   143,  -247,  -485,  1072, -2709,
-    1540, -2709, -2709, -2709, -2709, -2709, -1299, -2709,   748, -2039,
-     431, -2010, -1815,   183,   167,  -811,  -213,    26,   438,  -303,
-   -2709, -2709,  -300, -1743, -2384,  -316,  -315, -2709, -2709, -2709,
-    -456, -1168,  -698, -2709, -2709,   278,  -224, -2709, -2709, -2709,
-    -147,   749, -2709, -2709,  1071,  1596, -2709,  -576,  1941,  -366,
-    -693,  1242, -1107,  1249, -1106, -1123,  -655,  1257,  1258, -1286,
-    3547, -1582,  -805,    -5, -2709, -2352, -1741, -2709, -2709, -2709,
-     -76, -2709,  -375, -2709,  -373, -2709, -2709, -2709,  -418, -2708,
-   -2709,  1187,   872, -2709, -2709, -2709, -1314, -2709,  4282,   765,
-   -2709, -1677,  -923,  -585,  -933,  -786, -1042, -1196, -2709, -2709,
-   -2709, -2709, -2709, -2709, -1010, -1728,  -523,   834, -2709, -2709,
-     950, -2709, -2709, -2709,  -614,  1047,  -567,  -893,   847, -2709,
-     190,  2024, -1370, -2709,   807, -1981, -2709, -2709,   464, -2709,
-    1505,  -469, -1674,  1688, -1047,    38, -2709,  3440,   137,  1875,
-    -898, -2161, -2709, -2709,  -491, -2310,  -984, -2709,  -598, -2709,
-   -2709, -2709, -1212, -2709,   666, -2709, -1148, -2709,  -251, -2709,
-   -2709, -2183, -2709, -2709, -2709, -2709, -2709, -2709,  -437, -2709,
-    -473,  -476, -2709, -2709,    11,  -833,  1322, -2709, -2709,   626,
-   -2709,   970, -2709,   720, -2709,    70, -2709,  1182, -2709, -2709,
-   -2709,    23,  1619,   447, -2709,  1189, -2709, -2709, -2709, -2709,
-   -2709,   762, -2709, -1147, -2090,    82, -2235,  -641,    -6, -2709,
-   -2709, -2709,  -527, -2709, -2160
-};
-
-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-   positive, shift that token.  If negative, reduce the rule which
-   number is the opposite.  If zero, do what YYDEFACT says.
-   If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -1816
-static const yytype_int16 yytable[] =
-{
-     488,   484,  1192,  1051,  1017,  1347,   615,    56,    61,    43,
-     655,  1274,   987,    54,  1277,  1683,  1298,   851,  1527,  1204,
-    1526,  1230,   604,    76,    61,   975,  1189,   549,   759,  1585,
-    1823,  1352,  1236,  1826,  1781,  2075,  1480,   585,  1354,  1491,
-    1185,  1558,  2196,  1559,   485,  1291,   750,  1561,  1562,  2134,
-     617,  2140,  1502,  1498,  1401,  1538,    57,   590,  2166,  2532,
-    2534,  2171,  1589,  2553,  2134,   618,  2555,  1409,   845,   752,
-     760,  1307,    57,  1721,  1722,  2099,  1050,  2159,  1056,   732,
-    1060,  1531,    83,  2189,  2564,  2379,    57,   625,  2232,  2233,
-    2234,   560,   603,  2567,   602,  2340,  2244,   868,  1642, -1813,
-   -1813, -1100,  -729,  1216,  1217,   492,  2036,  2037,  -729, -1097,
-   -1097,  2057,   852,  1794, -1640, -1100,   633,   616,  1010, -1641,
-    2901,  2396, -1787, -1787, -1642, -1075, -1541, -1788, -1788,  1013,
-   -1643,  1237, -1789, -1789,  1228, -1644,    57,  1193, -1790, -1790,
-    1844,  1494,  2725, -1791, -1791,  -721,  -726, -1647,   868,  1563,
-    -726,   594,  1529,  2086,  2087, -1794, -1794,   557,   557,  2253,
-   -1647, -1656,   556,  1734,  1416, -1656,   868, -1662, -1664,   744,
-   -1664,  1280,  1483, -1803, -1803, -1809, -1809, -1666, -1811, -1811,
-   -1101, -1101, -1640, -1641, -1642, -1814, -1814, -1643, -1098, -1098,
-    1847, -1644,  -688,  -701, -1662,  1734,  -447, -1666,  -407,  2669,
-    -716,  1659,  1503,   556,  1466,  -450,   556,  1210,  1237,  2018,
-    1494,  1363,  2982,  2708,  2857,  2826,  1365,  1656,  1658,   976,
-   -1541,  2224,  2703,  1236,  2039,  1237,  2293,  2295,  2870,  2040,
-    1413,  1285,   556,  2684,  1511,  1285,   868,  1514,  1515,  1237,
-     868,  2418,  1371,  2812,   668,   607,   612,  -178,     3,     4,
-    2868,  1211,  -178,  3026,  2726,  2039,  2774,  1778,  2568,  1024,
-    2040,  2192,  2260,  2904,  2903,  1025,  2753,  3073,  1448,  2727,
-    2886,  1486, -1541,  1363,  1373,  1919,  1536,  2871,  1365,  2680,
-    3064, -1784, -1784,  2039,    26,  1582, -1541,  1537,  2040,  2587,
-    -447, -1541,  2653,  2972,   571,  1850, -1541,  1553,  1553,  -450,
-    1216,  1217,  2801,  2220,  1371, -1541,  1755,    84,   553, -1541,
-    1363,   735,  2405,  2666,  2386,  2394,  2221,  -662,  2723,  2714,
-    1525,    31,   851,  1931,  -948,   612,  1228,  3062,  2466,   851,
-    2437,  -948,  2729,   608,  2329,  1865,  1373,   556,  1000,  1510,
-   -1541,  1771,  1343,  1414,  1363,  2983,  2626,   552,  1772,  1365,
-    2630,  -968,    85,   744,  1521,  2305,  2702,   610,  -968,  2436,
-   -1541,  1189,    33,  3054,   555,  1355,  2396,  2724,  3080,  1554,
-    2716,  1026,  2678,  1373,  1449,  1371,  2719,  2720,  1522,  1299,
-    2446,  2134,  1645,  2134,  2801,   977,  2667,   978,   737,  2883,
-    2387,  -574,  2824,  1866,  1411,  1504,   597,   572,  2193,  1779,
-    2467,  2189,  1851,  2189,  2447,  2427,  3049,  1373,   605, -1541,
-    1698,  2930, -1541,  2872,    36,  2572,  1555,  1555, -1541,  2569,
-    1238,  1411,  2984,  1488,  2388,   611,  1212,  3074,  3016,  2905,
-    3065,  1920,  1756,  1320,  1479,  2869,  2807,  2681,  1683,  2588,
-    2389,  1001,   701,   851,   851,  2679,  2120,  2121,  1757,   554,
-    2390,  2728, -1541,  1758,  -662,  2817,  1540,  1501,  2309,  2310,
-    2311,  2312,  2313,   606,  1415,  2317,  2318,  2319,  2320,  2321,
-    2322,  2323,  2324,  2325,  2326, -1541,  1501,  3033,   595,  1985,
-    1987,  1530,  -447,  2468,  2391,   969,   619,  2840,  3022,  1541,
-    1759,  -450,   744,  2927,  1983,   735,  1984,  1238,  1918,  1860,
-     643,    61,   641,   612,  2654,  2764,   642,  2658,  1844,  2581,
-    2142,  2169,  2753,  2995,  1238,  2709,   645,  1941,  2161,  2358,
-    2359,  1477,  1432,  2670,  1735,  1027,  1692,  1646,  1238,   746,
-     604,  2118,  1478,  1213,  1024,  1639,  1527,  1489,   850,  2833,
-    1025,   669,   637,  2532,  2534,  -447,   638,  1428,  2801,    57,
-    2225,    61,   493,  2813,  -450,   847,  2101,  2174, -1541,  1231,
-    2616,  1574,   609,  3005,  1018,  1231, -1541,   488,   488,  1932,
-    3027,  2392,   737,  3055,  1239,   617,  1028,  2693,  2694,  2585,
-    1029,  1232,   636, -1541,  1336, -1541, -1541,  1232,  2763,  1214,
-     618,   488,  2144,  2767, -1100,  1233,  2769,  1918,  1185,    57,
-     603,  1235,  1417,  2660,   651,  2244,   980, -1640, -1100,  2754,
-    1030,  2743, -1641,    56,    61,    43,   637, -1642, -1075,    54,
-     638,  1792, -1541, -1643,   854, -1541, -1541, -1541, -1644,    76,
-    1106,   488,  1186,  1343,   735,   998,  1979,  1760,  -721,  -726,
-   -1647,  1615,   616,   613,  2134,  1833,  1026,  2801,  2134,  2929,
-    1586,  1587,  3056, -1647, -1656,  1358,  -447,   989, -1656,  2765,
-   -1662, -1664,    57, -1664,  2935,  -450,   979,  2936,  1273,  1660,
-   -1666,   744,   620, -1101, -1101, -1640, -1641, -1642,  1031,  3057,
-   -1643,  -948,  1276,  2657, -1644,  1218,  1222, -1662,    83,   853,
-   -1666,   557,   855,  -716,  1394,  -447,  1407,  -447,  1773,  1795,
-    1644,  2996,  1624,  1521,  -450,  1006,  -450,  2055,  -968,  1895,
-    1007,   737,  1503,   746,   966,  2424,  1289,  1290,  1683,  1898,
-    1289,  1290,  1901,  2707,  2240,  2241,  1865,  1522,  1643,  2878,
-    1343,   970,  -178,  -178,  1650,  2052,  2053,  2054,  2055,   663,
-    1644,  1189,  1565,   542,  2931,  1006,  1820,  1696,  2553,  2659,
-     488,  1389,  1390,  1391,  1392,  1393,  1394,   851,  3000,  1503,
-    1807,  2050,  2051,  2052,  2053,  2054,  2055,  1612,   732,  2712,
-     666,  1719,  1731,  2368,  2369,  2370,  2371,  1503,  1355,  1008,
-    2425,   750,  1606,  1594,  2186,  2853,   569,  1644,  1610,  1961,
-    1516,  2003,   587,  2854,  2314,  1644,   667,  1189,  2345,    87,
-    1027,  2276,   971,  2197,  2149,  2911,  1607,  2280,   845,  2720,
-    1616,   856,  1185,   735,  2143,   862,  2532,  2534,  1352,  1008,
-    2001,  2079,   857,  1494,  1391,  1392,  1393,  1394,  1009,  2387,
-    1532,  2008,   744,  1821,  1495,  -496,  2009,  2810,  2091,  2150,
-    -496,   495,   626,   850,  2994,  1503,  1968,   670,  1024,  1363,
-     850,  1106,   746,  1451,  1025,  1029,  1347,   671,   744,   744,
-      61,  1527,  2450,  2388,  2912,  2092,   672,  1990,   488,  1991,
-    1024,  2677,  1993,   744,  1451,  2235,  1025,  2134,  3075,  2632,
-    1371,  1894,  1737,  1692,  1692,  1030,  2134,  2010,  1692,  2390,
-     737,  2134,  2686,  1503,  2134,  1535,  1953,   488,  1954,  1452,
-    2691,  2354,   496,  1887,  3002,  1504,  2169,  1723,    57,  -496,
-    2453,  1006,  1373,  2134,   604,  2198,   495,   488,   488,   488,
-    1452,   488,   488,  1914,  1915,  1916,  2163,  1857,  1669,  2226,
-    1692,  1692,  1517,  3003,  2315,   756,  1670,  1671,  1672,  1673,
-    1518,   556,  3060,  1808,  2316,   488,  1323,  1986,  1988,  1989,
-    1231,  1024,  1504,  1031,  1893,   858,   758,  1025,  -496,  1453,
-    1026,    88,  2855,  2223,   850,   850,  1185,  1501,  1220,    89,
-    1504,  2200,  1232,  1904,   735,   860,  2261,   496,  1911,  2907,
-    2825,  2268,  1026,  2093,  1345,  1008,  1294,  1564,  2094,   861,
-    1229,  1440,  1441,  1294,  1447,  2134,  1965,   744,   488,  2479,
-     735,   735,   488,   488,  2739,    90,   618,   618,  1454,   618,
-    2392,  2227,    26,   488,  1501,   735,  1503,    26,  1247,  1248,
-    1024,  2440,   998,  1271,  2307,   862,  1025,  2134,  1896,  1454,
-    1494,   746,  1501,  1899,  1009,  2925,   867,  1869,  1504,  2039,
-     863,  1497,  1564,  1940,  2040, -1816, -1816, -1816,   647,    31,
-     648,   737,    91,  2330,    31,  1956,  1106,  1618,   616,   616,
-    2007,   616,   868,  1026,  2011,  2815,  2012,  1106,  1455,  1027,
-    2457,  1357,  1253,  1254,   499,   968,   500,   737,   737,  1528,
-    1360,  2867,  1226,  1227,     3,     4,  1504,  1253,  1254,  1455,
-      33,  1106,   737,   983,  1408,    33,  1558,   851,  1559,  2867,
-    1501,   503,  1561,  1562,    34,  1418,  2441,  1294,  1294,    34,
-     851,   974,  1683,  2458,  1027,  1620,  1231,  2068,   637,   990,
-     868,   637,   638,  2134,  2199,  1410,  2200,   744,    35,  2459,
-    2095,   991,  1026,    35,  2231,  2208,  1027,  2210,  1232,   735,
-    1977,  2096,  1809, -1782, -1782,  2172,   542,    36,  1501,   499,
-     868,   500,  1233,  1347,  2201,  2089,  2967,  2598,  2858,  2134,
-     658,  1743, -1783, -1783,  2386,  1054,  1220,  2289,  2477,  1029,
-    2756,  2470,  2442,   993,  2443,  2757,   503,   994,  2067,  2138,
-    2069,  2070,  1257,  1258,  1229,  2014,    92,  1058,  1744,   491,
-    1186,  1029,   746,  1231,   996,   540,   659,  1257,  1258,  1055,
-    2434,   964,   965,  2951,   967,   649,   570,   650,  2168,  1504,
-     583,  1283,   488,  2550,  1284,  1232,   737,  1027,   746,   746,
-    1426,  1059,  2469,  1427,  2478,  3071,   997,  2460,  1638,  1235,
-     744,  1639,  2252,   746,  2461,  1692,  1692,  1692,  1692,  1692,
-    2387,  1004,  1692,  1692,  1692,  1692,  1692,  1692,  1692,  1692,
-    1692,  1692,  3050,  3051, -1785, -1785,  1640,  3034,  2134,  1641,
-     637,  2416, -1075,  2636,   638,  1019,  2639,  1031,  1856,   735,
-    1021,  1501,  1029,    26,  2388,   744,  3052,  1022,   850,   661,
-    2278,  2279,  1803,  1023,   738,  1276,  1027, -1786, -1786,  1031,
-    2389,    61,  1035,  2249,  1186,   847,  1692,  1692, -1792, -1792,
-    2390,  1745,  1030,  2256,  1036,  3078,  1746,   488,  1053,   488,
-      31,  1747,   488,   488, -1793, -1793,  2046,   643,    61,   641,
-   -1795, -1795,   488,   642,   488,   488,   488,   488,   488,   488,
-     488,  1057,  3079,   645,  2391,  1928,  1190,  1902,  1929,    57,
-    1969,  1029,  1975,  1641,  1997,  1976,   737,  1998, -1796, -1796,
-     488,    33,   488,  2214, -1797, -1797,  2215,   746,   488,   488,
-     488,   488,   488,   488,  1186,    34,    57,  1191,   488,   488,
-    1031,  1903,   735,   488,  2113,  2218,  2114,   488,  2219,  2721,
-     488,   488,   488,   488,   488,   488,   488,   488,   488,    35,
-    2169,   488,  2841,  2742,  1362,  1194,  2270,  1363,   488,  1639,
-    1624,  1106,  1365,    36,  1186,  1674,  1675,  1676,   495,  1677,
-    1678,  1679,  1680,  1681,  1682,  2414,  2526,   735,  2415,  1196,
-      26,  2392,  1198,   488,  2419,  1781,  1207,  2420,  1371,  1214,
-    2559, -1146,  1741,  1929,  2579, -1816,  1199,  2580,   980,  1031,
-   -1798, -1798,  1811,  2842,   488,  2599,  2477,  2661,  1641,   737,
-    1209,  2744,  2843,  1748,  1641,   488,   488,    31,  1221,  2832,
-    1373,  1665,  1929,   610,  1749,  1644,  1242,  2860,   738,   496,
-    1641,  2863,  1024,   851,  2864,  1224,  2880,  -497,  1025,  2881,
-    1218,  2844,  -497,  2621, -1799, -1799,  2335,   746,   656,  2884,
-    1222,    57,  2881,  1186,   737,  1186,  1869,  2621,    33,  1225,
-     867,  2284,   543,  2039,  2899,  1255,  1256,  2900,  2040,  2041,
-    2042,  2043,    34, -1816, -1816, -1816,  1241,  2050,  2051,  2052,
-    2053,  2054,  2055,   497,  2941,  2942,  2954,  2900,  1641,  2881,
-    2088,   611,  2975,  2650,  1106,  2976,    35,   488,   488,  3006,
-     488,  3043,  3007,  1244,  2881,  2859,  2577, -1800, -1800,  1644,
-     544,  -497,  2845,  3061,  1796,  1272,  2900,  3017,  1186,  3018,
-     657, -1816, -1801, -1801,  2846,  2301, -1802, -1802,  2401,  1106,
-    2115,  2211,  2116,  2213,  2433,   488,  2435, -1816,  1279,  2631,
-    1957,  2634, -1816,  2308,  1026,  1003,   744,  1005, -1804, -1804,
-     746,   495,   628,   498,   631,  1275,   635,    26, -1805, -1805,
-    -497,  1278,    26, -1806, -1806,  1281,   740,   738,  1282,   612,
-    2331, -1807, -1807,  1300, -1146, -1808, -1808,  2336,   850, -1816,
-    1310,  1887,  2549,  2535,    26, -1810, -1810, -1812, -1812,    57,
-    1311,   850,  1313,  1106,    31,   746,  3070, -1815, -1815,    31,
-     488,   499,  1315,   500,  2578,   488,  1543,  1544,  1692,   658,
-    1845,  1846,   496,  -548,  -548,   744,  1257,  1258,  -692,   501,
-    -699,    31,  1318,  2169,  1320,   502,  2689,  1319,   503,  -552,
-    -552,  -551,  -551,   744,  1382,    33,   604,  1321,  -689,  -690,
-      33,  2830,   488,   488,   488,   659,  1322,   488,  2044,    34,
-    1422,  1424,    36,  1324,    34,   488,   488,   488,   488,   512,
-     744,  -693,    33,   541,  -574,   488,  1939,   744,  -575,   488,
-    2045,   562,   488,    35,  1325,  1326,    34,  1328,    35,  1329,
-    1330,   660,   601,   601,  1331,  1332,   604,    36,   735,   488,
-     488,   744,    36,  -691,   488,  1333,  1334,  2556,  1027,  1340,
-      35,  1335,  1336,  1353,  2698,  2699,  1345,  2289,   488,   613,
-    1356,   488,  1402,   488,    36,  2847,  1399,  1404,  2848,  1405,
-    1420,  1294,  1429,  1430,  2529,  2006, -1816,  1433,   661,  1439,
-    1007,  1009,  1473,   488,  1294,  1475,   629,  1481,  1499,  1500,
-    2046,  1692,  1501,  1507,   488,  2132,   738,  1189,  1506,  1909,
-     740,  1508,  1512,  1029,  1519,   604,  1345,   735,  1520,   488,
-    2132,  1524,  1644,  1534,  1539,   737,  1546,  1547,  1551,  1556,
-    1557,   643,    61,   641,  1741,   735,  1571,   642,   488,  1230,
-    1564,  1567,  1570,  1910,   499,  2576,   500,   645,   485,  1573,
-    2108,  1575,  1581,   488,   488,   868,  1588,  1590,  1591,  1611,
-    1597,  1598,   735,   485,  1601,  1602,  2125,  1603,   502,   735,
-    1604,   503,   488,  1637,   744,  1646,  1651,  1363,  1347,  1711,
-      57,  2125,  1713,  1715,  1716,   603,  1718,  1733, -1816,  1740,
-    1186,  1186,  1186,   735,   737,  1389,  1390,  1391,  1392,  1393,
-    1394,   486,  1717,  1754,  1751,  1775,   513,  1752,  1776,  1790,
-     513,  1031,   737,  1812,  1797,   558,   558,   561,   513,   566,
-    2526,  1804,   566,  1805,   611,   566,   592,  1824,  1834,   513,
-     513,  1106,  1835,  1836,   867,   744,  1839,  2039,  1837,   737,
-    1855,  1838,  2040,  2041,  2042,  2043,   737,  1862,  1863,   740,
-    1858,  1864,   612,  1926,  1930,  1692,  1934,  1942,  1943,  1944,
-    2347,  1958,  1962,  1963,  1966,  1527,   746,   738,  1967,  1964,
-     737,  1971,  1970,  1972,  1992,   566,   488,  1973,  1974,  1981,
-    2675,  1982,   592,   513,   592,   592,   592,  1994,  1995,  1996,
-    2004,  2016,  2015,   738,   738,  2022,  2024,  2047,  2048,  2049,
-    2027,  2050,  2051,  2052,  2053,  2054,  2055,   744,   738,  2025,
-    2026,  2064,  1186,  2032,   850,  2028,   735,  2029,  2085,   646,
-    2031,  2035,  2058,  1957,  2090,  2059,  2065,  2072,  2083,  2097,
-    2106,  2107,   488,  2109,  2111,   746,  2110,  2136,  2146,  2217,
-    3001,   488,  2148,  2160,   488,  2697,  2155,   488,  2162,  2164,
-    -553,  -554,  2175,   746,   488,   488,   488,   488,   488,  2818,
-    2178,   488,   488,   488,   488,   488,   488,   488,   488,   488,
-     488,  2179,    57,   851,   488,   488,  2364,   735,   488,  2176,
-     746,  2180,   604,  2184,  2243,   488,  2182,   746,  2185,  2188,
-     488,  2207,  2209,   737,  2236,  2222,  2228,  2229,  2238,   488,
-    2230,  2237,   488,  2239,   488,  2247,  2248,  2258,  2262,  2251,
-    2266,   746,   488,   604,   973,   488,   488,  2259,  2263,  2269,
-     488,   488,  2273,  2275,  2285,  2292,  2300,  2061,   740,  2039,
-     604,  2060,   738,  2282,  2283,   744,   488,  2132,   488,  2132,
-    2337,  2332,  2333,  2353,  2045,  2352,  1020,  2334,  2338,   735,
-     488,   741,  1345,  2350,   737,  2356,  -459,  1294,  2365,  2366,
-     488,  2118,  2290,  2377,  2291,  2385,  2403,  2408,  2296,  2297,
-    -459,   744,  2413,  2399,  2411,  -459,   488,  2417,  2428,  2432,
-     485,  2465,   485,  1345,  1201,  1203,  1205,  1206,  2438,  2409,
-    2439,  2562,  2566,  2526,  2426,  2445,  2481,  2546,  2375,  2547,
-    2378,  2548,  2552,  2561,  2575,  1929,  2586,  2573,  2592,  2622,
-    2583,  2589,  2627,  2590,  2046,  2628,  2635,  2591,   665,  2593,
-    2641,  2607,  2619,  2618,  -459,  2642,   737,  2625,  2640,  1186,
-    2910,  2643,  2645,  1186,  2533,  1186,  2656,  2662,  2664,  2663,
-    1037,  2668,  2672,   744,  -459,  2673,  2682,   755,  2685,  2674,
-    2687,  2705,  2688,  2692,  2706, -1097,  2715,  2717, -1782,  1038,
-    2718, -1783,   738,  2730,  2704,  2733,  2731,  2713,  2529,  2944,
-   -1784, -1785, -1786, -1787, -1788,  2554, -1789,   735,  2737, -1790,
-   -1791, -1792,  2974, -1793, -1795, -1796, -1797, -1798, -1799,   740,
-   -1800, -1801, -1802,  -459, -1804,   746,  2570, -1805,  2571, -1806,
-   -1807, -1808,  -459, -1809, -1810, -1811,   601,  2978,  2736, -1812,
-    1039, -1813,   488,   735, -1814,   740,   740, -1815, -1098,  2740,
-    2955,  2768,  2957,  2791,    57,  2741,  2755,  2797,  2795,  2773,
-     740,  2803,  2805,  2806,  2808,   741,  2882,  2820,  2821,  2882,
-    2822,  2829,  2836,  2831,  2450,    57,  2837,    57,  2861,  2838,
-    2451,  2922,  2865,  2851,   737,  2873,  2852,  2874,   744,  2875,
-    2877,   488,   488,  2452,  2893,   738,   488,   746,  2885,  2887,
-    2889,   488,  2901,  2896,   488,   488,  2915,  2531,  2681,   488,
-    2919,  2921,  2923,  2926,  2932,   735,  2937,  2938,  2939,   592,
-     737,  2943,  2453,   653,  2454,   744,   654,  2947,  2910,   488,
-    2132,  1040,  2243,   488,  2132,   513,  2948,  2956,  2959,  2960,
-     738,  2047,  2048,  2049,  2962,  2050,  2051,  2052,  2053,  2054,
-    2055,  2973,  2977,  2985,  2991,   488,   744,  2980,  2992,   744,
-    2969,  2993,   654,   513,   513,  2997,  2998,  2999,  3015,  3025,
-    2649,  2651,  -459,   485,  3008,  3009,  3010,   485,  3012,   558,
-    3028,  3030,  1041,  2609,   740,  3044,  3045,  3042,  3047,   488,
-    1042,  2125,   737,  3026,  3027,  2125,  3063,   488,   961,   961,
-     566,   566,  1043,   566,   741,  3072,  3076,  3068,  3069,  2455,
-    3077,  3081,  2480,   995,   592,  1889,   488,  2484,  2205,    57,
-      57,  2421,  2652,   513,  2968,   746,   743,  1425,  2796,  3019,
-     735,  2989,  2560,  1044,   592,  2695,   637,  3059,  2816,   993,
-     638,  3024,  3053,  3031,  2850,  2187,   592,  3021,  2212,  1490,
-    2565,  2449,  1436,  3029,  2485,   867,  2183,  3020,  2039,  2286,
-    1584,  2533,  1605,  2040,  2041,  2042,  2043,   735,  2738,  2245,
-    2551,  2529,  1431,  2167,  1854,  1412,  1470,  2456,  1482,  2950,
-    1046,  2348,  2457,  1469,   592,   592,   592,   592,  2964,  2177,
-    3048,  1509,  1831,  2407,  3011,  2647,  2958,  2895,   735,  1853,
-    2646,   735,  1047,  2145,  1474,  2380,  2879,   737,  2633,  2617,
-    2376,  2946,  1533,  2945,   740,  2952,  1655,  2953,   867,  2722,
-    2794,  2039,  1049,  1657,   850,  2458,  2040,  2041,  2042,  2043,
-     488,  1661,  1662,   746,  3013,  3041,   488,  3014,  2081,  1780,
-    2170,  2459,  2104,  1925,   737,   488,   488,  2019,   963,   488,
-    2139,  2648,  2102,  2406,  2250,  2940,  1617,  2013,  2422,  1799,
-       0,   744,   488,  2132,     0,  1434,     0,  1801,    57,     0,
-       0,   488,  2132,     0,     0,   737,   488,  2132,   737,   488,
-    2132,     0,     0,   741,     0,     0,   488,   488,     0,     0,
-       0,     0,     0,  1362,     0,     0,  1363,     0,   488,  2132,
-     488,  1365,  1366,  1367,  1368,     0,   485,     0,     0,     0,
-     743,     0,     0,     0,     0,   485,     0,   740,   488,  1369,
-     485,     0,     0,   485,     0,     0,     0,  1371,   601,     0,
-       0,     0,  3023,  2125,  1372,     0,     0,     0,  2125,  2460,
-       0,  2125,   485,     0,     0,     0,  2461,     0,  2533,     0,
-       0,   738,     0,     0,  1566,     0,     0,     0,     0,  1373,
-       0,     0,   740,     0,     0,  2045,     0,  1294,     0,     0,
-       0,     0,  2834,     0,     0,     0,     0,     0,     0,     0,
-     488,  2132,     0,     0,   488,   746,     0,  1312,     0,     0,
-       0,     0,     0,     0,  2722,     0,     0,     0,     0,     0,
-       0,     0,     0,   735,     0,     0,     0,     0,   488,     0,
-       0,     0,   488,  2132,     0,     0,   746,   604,     0,   746,
-     738,    57,     0,     0,   485,   488,     0,     0,  2045,     0,
-       0,     0,  2793,     0,     0,  2046,     0,  1614,   738,   488,
-       0,     0,   488,    57,   741,     0,     0,     0,     0,   743,
-       0,     0,  1186,     0,  1351,     0,   485,   488,     0,     0,
-    1374,  1625,     0,     0,     0,   738,     0,     0,     0,     0,
-     741,   741,   738,     0,  2125,     0,  1375,     0,     0,     0,
-     737,  1376,     0,     0,     0,   741,     0,  1345,     0,     0,
-       0,  2531,     0,     0,  2934,  1037,   738,   592,  2046,     0,
-       0,     0,     0,  1377,  1378,     0,  1626,     0,   488,  2132,
-       0,     0,     0,     0,  1038,   513,   513,     0,  1379,     0,
-       0,   592,   592,  1438,     0,     0,     0,     0,     0,   488,
-       0,   488,  1627,   488,     0,     0,     0,   488,     0,     0,
-       0,     0,     0,    57,   488,  2132,     0,     0,   592,  1493,
-    1628,     0,   485,  2965,  1629,     0,  1380,     0,     0,  1381,
-    1789,   592,     0,     0,     0,  1039,     0,   488,     0,     0,
-       0,     0,     0,  1382,     0,     0,  1630,     0,   592,  1631,
-       0,  1798,   592,  1800,     0,     0,     0,   488,   485,     0,
-       0,     0,     0,     0,  1632,     0,     0,     0,     0,     0,
-     488,     0,    57,     0,     0,  1245,  1246,     0,     0,   741,
-       0,     0,     0,     0,  1608,     0,  1609,     0,  2928,   738,
-    1186,  2533,     0,  1362,     0,     0,  1363,     0,   743,     0,
-    1849,  1365,  2047,  2048,  2049,     0,  2050,  2051,  2052,  2053,
-    2054,  2055,     0,   488,  2132,     0,   488,   488,     0,  3032,
-       0,     0,     0,     0,     0,     0,  1040,  1371,     0,     0,
-       0,     0,     0,     0, -1816,  1384,     0,     0,     0,     0,
-       0,     0,     0,   740,     0,     0,     0,     0,     0,   488,
-     738,  1247,  1248,     0,     0,     0,  1633,   485,     0,  1373,
-       0,     0,     0,     0,  1634,  2047,  2048,  2049,    57,  2050,
-    2051,  2052,  2053,  2054,  2055,     0,     0,  1041,     0,  1935,
-    1937,     0,     0,     0,     0,  1042,  1550,     0,     0,     0,
-     488,     0,     0,     0,   592,     0,     0,  1043,     0,     0,
-       0,     0,     0,  1579,     0,     0,     0,  1635,     0,   741,
-       0,     0,   740,     0,     0,     0,  1249,  1250,  1251,  1252,
-    1253,  1254,   738,     0,  1255,  1256,     0,     0,  1044,  2098,
-     740,     0,     0,     0,  2531,     0,  1596,  1385,     0,     0,
-    1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,
-       0,     0,     0,     0,     0,     0,     0,   740,     0,   743,
-   -1816,     0,     0,     0,   740,     0,     0,   654,   654,     0,
-     513,   513,     0,   513,   654,  1046, -1816,   592,     0,     0,
-       0, -1816,     0,     0,     0,   743,   743,     0,   740,     0,
-       0,     0,     0,  1861,     0,     0,     0,  1047,     0,     0,
-     743,     0,     0,  1870,     0,  1873,     0,     0,  1884,     0,
-       0,     0,   741,     0,  1888,     0,  1890,  1049, -1816,     0,
-       0,   -39,     0,     0,  1685,     0,     0,     0,  1897,     0,
-    1257,  1258,     0,  1900,     0,  1710,     0,  1905,  1906,  1907,
-    1908,     1,  1912,  1913,     0,     0,     0,     0,     0,     0,
-     738,     2,     0,     3,     4,     0,     0,   741,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   654,     5,
-       0,     0,     0,  1382,     0,  1037,     0,     0,     6,     0,
-       0,     0,     0,     0,     0,     0,   738,     0,     0,     0,
-       7,     0,     0,     0,  1038,     0,     0,     0,     0,   961,
-     592,     8,     0,     0,     0,     0,     0,     0,     0,  2117,
-       0,   740,     0,     9,     0,    10,     0,     0,     0,     0,
-       0,   592,     0,   592,   743,     0,     0,     0,     0,     0,
-       0,     0,  1813,    11,  1819,     0,     0,     0,     0,     0,
-       0,     0,     0,  1259,  1260,  1039, -1543,    12,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    13,   738,     0,
-       0,     0,     0,    14,     0, -1816,     0,     0,     0,     0,
-     592,    15,   740,    16,    17,     0,     0,     0,     0,  1493,
-     513,     0,     0,     0,     0,     0,     0,    18,     0,     0,
-     513,  1871,   513,  1875,  1362,   513,     0,  1363,     0,     0,
-       0,   513,  1365,   513,     0,     0,     0,     0,     0,     0,
-       0,     0,  2473,     0,   654,   513,    19,     0,     0,   654,
-     513,     0,     0,     0,   513,   513,   513,   513,  1371,   513,
-     513,    20,     0,     0,     0, -1816,  1040,     0,     0,     0,
-   -1543,     0,     0,     0,   740,     0,     0,     0,     0,   592,
-     592,  1938,     0,     0,   743,     0,     0,    21,     0,  2246,
-    1373,     0,     0,     0,     0,     0,  1952, -1816,  2254,  2255,
-    2257,     0,     0,   738,  1389,  1390,  1391,  1392,  1393,  1394,
-       0,     0,     0,     0,     0,     0,     0,  1041,     0,  2274,
-       0,     0, -1543,     0,     0,  1042,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0, -1543,  1043,     0,     0,
-     738, -1543,     0,     0,     0,     0, -1543,     0,     0,  1614,
-       0,     0,     0,     0,     0, -1543,     0,     0,     0, -1543,
-    2357,     0,     0,     0,    22,     0,     0,    23,  1044,     0,
-       0,   738,     0,     0,   738,     0,     0,  1362,     0,     0,
-    1363,     0,     0,     0,     0,  1365,     0,   743,     0,     0,
-   -1543, -1816,     0,     0,     0,     0,    24,     0,   741,     0,
-       0,     0,   740,     0,     0,    25,     0, -1816,     0,     0,
-   -1543,  1371, -1816,     0,     0,  1046,     0,     0, -1816,    26,
-       0,     0,     0,     0,     0,     0,    27,     0,     0,     0,
-      28,     0,   743,     0,   513,     0,     0,  1047,   740,     0,
-      29,  1351,     0,  1373,     0,     0,     0,     0,     0, -1816,
-       0,     0,    30,     0,     0,     0,    31,  1049,     0, -1543,
-       0,     0, -1543,     0,     0,     0,     0,   741, -1543,     0,
-       0,     0,     0,     0,  2372,  2373,  2374,  1685,     0,     0,
-       0,     0,     0,     0,     0,   741,     0,     0,     0,     0,
-       0,     0,    32,     0,  2265,     0,     0,    33,     0,     0,
-       0,     0, -1543,     0,  1382,     0,     0,     0,     0,   592,
-     740,    34,   741,  2360,     0,  2135,     0,     0,     0,   741,
-       0,     0,     0,     0,     0, -1543,     0,     0,     0,     0,
-    2135,     0,     0,  2429,  2154,    35,     0,  2157,     0,  1819,
-       0,     0,     0,   741, -1816,  1362,     0,     0,  1363,    36,
-       0,     0,   -39,  1365,  1366,  1367,  1368,     0,     0,     0,
-   -1816,     0,     0,  1362,     0, -1816,  1363,     0,     0,     0,
-       0,  1365,  1366,  1367,  1368,     0,   738,     0,     0,  1371,
-       0,  2118,     0,     0,     0,     0,  1372,     0,     0,     0,
-       0,  1550,     0,     0,     0,     0, -1816,  1371,     0,     0,
-       0,     0, -1816,     0,  1372,     0,     0,  2558, -1543,     0,
-       0,  1373,     0,     0,     0,     0, -1543,     0,     0,     0,
-       0,     0,     0,     0,     0,   740,     0,     0,     0,  1373,
-       0,     0,     0, -1543,     0, -1543, -1543,     0,     0,     0,
-    1614,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1550,     0,     0,  1382,     0,   592,
-       0,     0,   740,     0,     0,     0,   741,  1550,   592,   592,
-     592,     0, -1543,     0,     0, -1543, -1543, -1543,     0,     0,
-       0,   513,     0,     0,     0,     0,     0,     0,     0,   592,
-       0,     0,     0,   740,     0,     0,   740,     0, -1816,     0,
-       0,  2281,     0,     0,     0,  1389,  1390,  1391,  1392,  1393,
-    1394,     0,  1374,     0,     0,     0,     0,   654,  2430,   592,
-       0,     0,     0,  2612,  2613,  2614,  2615,   741,  1375,     0,
-    1374,     0,     0,  1376,  1550,  1550,     0,     0,     0,     0,
-       0,     0,     0,   743,     0,  2482,  1375,     0,     0, -1816,
-       0,  1376,     0,     0,     0,  1377,  1378,  1685,     0,     0,
-    2536,  2537,  2538,  2539,  2540,  2541,  2542,  2543,  2544,  2545,
-    1379,     0,     0, -1816, -1816,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1379,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   741,
-       0,     0,     0,     0,     0,     0,     0,     0,  1380,     0,
-     867,  1381,   743,  2039,  2683,     0,     0,     0,  2040,  2041,
-    2042,  2043,     0,     0,     0,  1382,     0,     0,     0, -1816,
-     743,     0,     0,  1362,     0,     0,  1363,     0,     0,     0,
-       0,  1365,     0,  1382,   592,   592,   592,   486,     0,  2135,
-    2384, -1816,     0,     0,     0,  2384,  2398,   743,  1389,  1390,
-    1391,  1392,  1393,  1394,   743,     0,     0,  1371,     0,     0,
-       0,     0,     0,     0, -1816,  1608,     0,     0,     0,     0,
-       0,     0,     0,  1024,     0,  1819,     0,     0,   743,  1025,
-       0,     0,  1362,     0,     0,  1363,  1037,     0,   740,  1373,
-    1365,     0,     0,   592,     0,   513,     0,     0,     0,  1550,
-    1493,  1550,     0,  1579,     0,  1038,     0,  1384,     0,     0,
-       0,     0,     0,     0,     0,     0,  1371,   741,     0,     0,
-       0,     0,   513, -1816,  2483,  1384,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   513,   513,   513,
-     513,   513,   513,   513,   513,   513,   513,     0,  1373,     0,
-       0,     0,     0,   741,     0,     0,  1039,     0,     0,  2361,
-     944,   944,  1952,     0,     0,     0,     0,   592,     0,     0,
-       0,     0,     0,     0,  1493,     0,     0,     0,     0,     0,
-    2676,     0,     0,     0,     0,  1026,     0,     0,  1579,     0,
-   -1816,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     592,   743,     0,     0,     0,     0, -1816,  1550,     0,  1385,
-   -1816, -1816,  1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,
-    1393,  1394,     0,  1101,  1108,   741,     0,  1385,     0,     0,
-    1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,
-       0,     0,     0,     0,     0,     0,     0,  1040, -1816, -1816,
-       0,     0,   513,     0,     0,     0,     0,     0,  2594,     0,
-       0,  2835,   743,     0,     0, -1816,     0,     0,     0,     0,
-   -1816,     0,     0,     0,     0,     0,     0,     0,  2856,     0,
-    2046,  2611,     0,   592,   592,   592,   592,     0,     0,     0,
-    2384,  2398,     0,  2384,     0,     0,  2620,     0,  1041,     0,
-    2135,     0,     0,  1382,  2135,     0,  1042, -1816,     0,     0,
-    2638,     0,     0,     0,     0,     0,     0,     0,  1043,     0,
-       0,     0,     0,     0,     0,     0,   961,     0,     0,  1293,
-    2154,     0,     0,     0,   743,  1819,  1293,     0,     0,  1027,
-     741,  1685,     0,     0,     0,     0,     0,  1493,     0,  1044,
-       0,  2906,     0,  1550,     0,     0,     0,     0,     0,     0,
-       0,     0,  1382,     0,     0,     0,   654,   513,     0,     0,
-       0,     0,     0,     0,   592,   867,     0,   741,  2039,     0,
-       0,  2933,     0,  2040,  2041,  2042,  2043,     0,     0,     0,
-    1045,  2696,     0,     0,  1029, -1816,  1046,     0,     0,     0,
-       0,  2601,     0,     0,     0,     0,     0,     0,   741,     0,
-       0,   741,     0,  2819,     0,     0,     0,     0,  1047,     0,
-       0,     0,     0,  1359,  1048,     0,     0,     0,     0,     0,
-       0,     0,     0,  2827,  2828,     0,     0,     0,  1049,     0,
-       0,     0,     0,     0,  1101,     0,     0,     0,  1293,  2839,
-    1293,  1293,     0,     0, -1816,     0,     0,     0,     0,     0,
-       0,  1316,   743,     0,     0,     0,     0,  1550,     0,     0,
-       0,     0,     0,     0,     0,     0,  1952,  2047,  2048,  2049,
-       0,  2050,  2051,  2052,  2053,  2054,  2055,     0,  2734,     0,
-    1327,     0,  1031,     0,     0,     0,     0, -1816,   743,     0,
-       0,     0,     0,     0,  1389,  1390,  1391,  1392,  1393,  1394,
-    1337,  1338,  1339,     0,     0,  1346,     0,     0,  1293,     0,
-       0,  1293,  1293,     0,  2750,  2897,     0,     0,     0,     0,
-       0,     0,     0,   486,  2384,     0,     0,  2761,  1403,     0,
-     513,     0,  2135,     0,     0,     0,     0,  2135,     0,     0,
-    2135,     0,  2772,     0,     0,  2775, -1816,     0,     0,     0,
-       0,     0,     0,  1389,  1390,  1391,  1392,  1393,  1394,  2802,
-     743,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-   -1557,     0,     0,     0,     0,  2045,     0,     0,     0,     0,
-       0,  1446,     0,     0,     0,  1460,  1465,     0,     0,     0,
-     513,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   741,     0,     0,  1362,     0,     0,  1363,
-     513,   513,     0,  1364,  1365,  1366,  1367,  1368,     0,     0,
-       0,   592,     0,  1493,     0,     0,   513,     0,     0,     0,
-       0,     0,  1369,     0,     0,     0,     0,     0,   592,  1101,
-    1371,  2802,     0,     0,     0,  2046,     0,  1372,     0,     0,
-    1101,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     513,     0,     0,     0, -1557,     0,     0,     0,     0,     0,
-       0,     0,  1373,  2135,  1101,   743,     0,     0,  2775,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1583,     0,     0,     0,  2892,     0,     0,     0,
-     961,     0,   513,  1592,     0,  1593,     0,     0,     0,     0,
-       0,   592,   743,     0,  1599,     0, -1557,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   654,     0,     0,
-   -1557,  1600,     0,     0,     0, -1557,     0,     0,     0,     0,
-   -1557,   592,     0,   743,     0,     0,   743,     0,     0, -1557,
-       0,     0,     0, -1557,     0,     0,     0,     0,     0,  1619,
-    1621,     0,     0,     0,     0,     0,     0,     0,     0,   486,
-       0,     0,     0,  1374,     0,     0,     0,     0,  2949,     0,
-       0,     0,   513,     0, -1557,     0,  2772,     0,     0,  1375,
-       0,  1652,  1653,     0,  1376,  1666,  1667,     0,     0,     0,
-       0,     0,     0,     0, -1557,  2802,   654,   654,   654,     0,
-       0,     0,     0,     0,     0,     0,  1377,  1378,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1379,     0,     0,     0,     0,     0,  1493,     0,     0,
-       0,     0,  2047,  2048,  2049,     0,  2050,  2051,  2052,  2053,
-    2054,  2055,  2772, -1557,     0,     0, -1557,     0,     0,     0,
-       0,     0, -1557,     0,  2892,     0,     0,     0,     0,  1380,
-       0,     0,  1381,     0,     0,     0,     0,     0,  1819,     0,
-       0,     0,     0,     0,     0,     0,  1382,     0,     0,  1383,
-       0,     0,     0,     0,     0,  1649, -1557,     0,  1493,     0,
-       0,     0,     0,     0,  2802,  1668,     0,  1686,     0,     0,
-    1697,  1700,  1705,  1708,   867,     0,     0,  2039,     0, -1557,
-    2761,   654,  2040,  2041,  2042,  2043,     0,     0,     0,     0,
-       0,  1843,  1843,     0,     0,  1720,     0,     0,     0,     0,
-    2602,  1724,  1725,  1726,  1727,  1728,  1729,     0,   743,     0,
-       0,  1738,  1739,     0,     0,     0,  1750,     0,     0,     0,
-    1753,     0,     0,  1761,  1762,  1763,  1764,  1765,  1766,  1767,
-    1768,  1769,     0,     0,  1770,  2118,     0,  1362,  1384,     0,
-    1363,   944,     0,  1293,  1101,  1365, -1816, -1816, -1816,     0,
-       0,     0,     0,  1293,     0,  1654,  1293,   556,     0,     0,
-       0,     0, -1557,     0,     0,     0,  1802,     0,     0,     0,
-   -1557,  1371,     0,     0,     0,     0,     0,     0,  1372,     0,
-       0,     0,     0,     0,     0,     0,     0, -1557,     0, -1557,
-   -1557,     0,     0,     0,     0,     0,     0,     0,  1338,  1339,
-       0,     0,     0,  1373,     0,     0,     0,  1361,     0,     0,
-       0,     0,  1362,     0,     0,  1363,     0,     0,     0,  1364,
-    1365,  1366,  1367,  1368,     0,     0, -1557,  1978,  1980, -1557,
-   -1557, -1557,     0,     0,     0,     0,     0,     0,  1369,     0,
-    1385,  1370,     0,  1386,  1387,  1388,  1371,  1389,  1390,  1391,
-    1392,  1393,  1394,  1372,  1293,     0,     0,     0,     0,     0,
-    2030,  1362,  1245,  1246,  1363,     0,     0,  1293,  1364,  1365,
-    1366,  1367,  1368,     0,     0,     0,     0,  1101,  1373,     0,
-    1922,  1923,     0,  1924,  2045,     0,     0,  1369,     0,     0,
-    2343,     0,     0,     0,     0,  1371,     0,     0,     0,     0,
-       0,     0,  1372,     0,  1374,     0,     0,     0,     0,     0,
-       0,     0,  1101,     0,     0,     0,     0,     0,     0,     0,
-    1375,     0,     0,     0,     0,  1376,     0,  1373,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1247,  1248,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  2046,     0,     0,     0,     0,     0,
-       0,     0,  1379,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1101,     0,     0,  1374,
-       0,     0,     0,  2017,     0,     0,     0,     0,  2023,     0,
-       0,     0,     0,     0,     0,  1375,     0,     0,     0,     0,
-    1376,     0,     0,  1249,  1250,  1251,  1252,  1253,  1254,     0,
-       0,  1255,  1256,     0,     0,     0,  1397,  1382,     0,     0,
-       0,     0,  1377,  1378,     0,  2141,     0,  2038,  1374,     0,
-       0,     0,     0,     0,     0,     0,     0,  1379,  1705,     0,
-    1705,  1705,     0,     0,  1375,     0,     0,     0,  2077,  1376,
-       0,     0,  2080,     0,     0,  2082,     0,  1397,     0,  2173,
-    2173,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1377,  1378,     0,     0,  1380,     0,     0,  1381,     0,
-       0,     0,     0,     0,     0,     0,  1379,     0,     0,     0,
-       0,  2100,  1382,     0,  2103,  1383,  2105,  1362,     0,     0,
-    1363,     0,     0,     0,  1364,  1365,  1366,  1367,  1368,  1384,
-       0,     0,     0,     0,     0,     0,     0,  1257,  1258,     0,
-       0,     0,     0,  1369,  1380,     0,     0,  1381,     0,  1245,
-    1246,  1371,     0,     0,     0,     0,     0,     0,  1372,     0,
-       0,  1382,     0,     0,  1383,     0,     0,     0,     0,     0,
-       0,  2047,  2048,  2049,     0,  2050,  2051,  2052,  2053,  2054,
-    2055,  1446,     0,  1373,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1397,     0,     0,  1465,  1768,     0,     0,
-    1397,     0,     0,  1362,  1384,     0,  1363,     0,     0,     0,
-    1364,  1365,  1366,  1367,  1368,  2181,     0,     0,     0,     0,
-    2277,     0,     0,     0,     0,  1247,  1248,     0,     0,  1369,
-       0,  1385,     0,     0, -1816, -1816, -1816,  1371,  1389,  1390,
-    1391,  1392,  1393,  1394,  1372,     0,     0,     0,     0,     0,
-    1259,  1260,     0,  1384,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1373,
-       0,     0,     0,     0,  1101,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1374,     0,     0,     0,     0,     0,
-    1249,  1250,  1251,  1252,  1253,  1254,     0,     0,  1255,  1256,
-    1375,     0,     0,     0,     0,  1376,  1385,     0,     0,  1386,
-    1387,  1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,  2272,
-       0,     0,     0,     0,     0,     0,     0,  1377,  1378,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1379,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1385,     0,     0,  1386,  1387,
-    1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,     0,     0,
-    1374,     0,  1714,     0,     0,  2299,     0,     0,     0,     0,
-    1380,     0,     0,  1381,  2303,     0,  1375,  2304,     0,     0,
-    2306,  1376,     0,     0,     0,     0,     0,  1382,     0,     0,
-    1383,     0,     0,     0,  1257,  1258,     0,     0,  1397,     0,
-       0,     0,     0,  1377,  1378,     0,     0,  2327,  2328,  1397,
-       0,  1802,     0,  1693,     0,     0,     0,     0,  1379,  1397,
-    1397,  1397,     0,  2339,     0,     0,     0,     0,  1397,     0,
-       0,     0,  2346,     0,     0,  2349,     0,  2351,     0,     0,
-    1362,     0,     0,  1363,     0,  2355,     0,  1364,  1365,  1366,
-    1367,  1368,     0,  2362,  2363,     0,  1380,     0,     0,  1381,
-    1293,     0,     0,     0,     0,     0,  1369,     0,     0,     0,
-       0,     0,     0,  1382,  1371,     0,  1383,     0,     0,  1384,
-       0,  1372,     0,  2402,     0,  1397,     0,     0,     0,     0,
-       0,     0,     0,  2410,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1373,  1259,  1260,  2423,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1261,  1397,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1397,     0,     0,     0,     0,  1397,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1384,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1385,     0,     0,  1386,  1387,  1388,     0,  1389,  1390,
-    1391,  1392,  1393,  1394,     0,     0,     0,     0,  1714,     0,
-       0,     0,     0,     0,     0,     0,     0,  1374,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1375,     0,     0,     0,     0,  1376,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  2582,     0,     0,     0,     0,
-    1377,  1378,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1379,     0,  1385,     0,     0,
-    1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,
-       0,     0,     0,     0,  2084,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  2595,  2596,     0,     0,     0,  2597,
-       0,     0,     0,  1380,  2600,     0,  1381,  2603,  2604,     0,
-    1293,     0,  2608,     0,     0,  1293,     0,     0,  1362,     0,
-    1382,  1363,     0,  1383,     0,  1364,  1365,  1366,  1367,  1368,
-       0,  1397,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1369,     0,     0,     0,     0,     0,
-    1397,     0,  1371,     0,     0,     0,     0,     0,   944,  1372,
-       0,     0,     0,     0,  1619,  1621,     0,     0,  1397,     0,
-    1693,  1693,     0,  2056,     0,  1693,     0,     0,     0,  1397,
-       0,     0,  1397,     0,  1373,     0,     0,  1397,     0,     0,
-    1397,     0,  2671,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1397,     0,     0,     0,  1397,  1397,  1397,  1397,
-    1397,  1397,  1384,     0,     0,     0,     0,  1693,  1693,  2690,
-    1397,  1397,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1397,     0,     0,  1397,     0,     0,     0,     0,
-       0,     0,     0,  1397,  1397,  1397,  1397,  1397,  1397,  1397,
-    1397,  1397,  1397,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1397,  1374,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1375,     0,     0,     0,     0,  1376,     0,     0,     0,
-       0,     0,     0,     0,  1385,     0,     0,  1386,  1387,  1388,
-       0,  1389,  1390,  1391,  1392,  1393,  1394,     0,  1377,  1378,
-       0,  2302,     0,  1619,  1621,     0,     0,     0,     0,  2077,
-       0,     0,     0,  1379,  1293,     0,     0,     0,  2745,  2746,
-       0,     0,  2747,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1380,     0,     0,  1381,     0,     0,     0,     0,  2789,
-    2790,     0,     0,     0,     0,     0,     0,     0,  1382,     0,
-       0,  1383,     0,  2804,  1397,  1397,  1397,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  2814,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1362,     0,     0,  1363,     0,     0,     0,  1364,  1365,
-    1366,  1367,  1368,     0,     0,  1362,     0,     0,  1363,     0,
-       0,     0,     0,  1365,     0,     0,     0,  1369,     0,     0,
-       0,     0,     0,     0,     0,  1371,     0,     0,     0,     0,
-       0,     0,  1372,     0,     0,     0,     0,     0,     0,  1371,
-    1384,     0,     0,     0,     0,     0, -1816,     0,     0,  1397,
-       0,     0,     0,     0,     0,  1397,     0,  1373,     0,     0,
-       0,  2876,     0,     0,     0,     0,     0,     0,  2056,  2056,
-    1397,  1373,  1693,  1693,  1693,  1693,  1693,     0,  1346,  1693,
-    1693,  1693,  1693,  1693,  1693,  1693,  1693,  1693,  1693,  2056,
-       0,     0,   944,     0,     0,  2898,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1397,
-    2917,     0,  1397,     0,  1397,     0,     0,     0,  2056,  2056,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1397,  1693,  1693,  1397,     0,  1397,     0,     0,
-       0,  2605,  1385,     0,     0,  1386,  1387,  1388,     0,  1389,
-    1390,  1391,  1392,  1393,  1394,     0,     0,     0,  1374,  2344,
-       0,     0,     0,     0,     0,     0,     0,  1293,     0,     0,
-       0,     0, -1816,     0,  1375,     0,     0,     0,     0,  1376,
-       0,     0,     0,     0,     0,     0,  2789,     0, -1816,     0,
-    2961,     0,     0, -1816,     0,     0,     0,     0,     0,     0,
-       0,  1377,  1378,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1397,     0,  1362,  1379,     0,  1363,     0,
-    2990,     0,  1364,  1365,  1366,  1367,  1368,     0,     0,     0,
-   -1816,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1369,     0,     0,     0,     0,     0,     0,     0,  1371,
-       0,     0,     0,  2789,  1380,     0,  1372,  1381,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1382,     0,     0,  1383,     0,     0,     0,     0,     0,
-       0,  1373,     0,     0,     0,  1382,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  3038,
-    3038,     0,     0,     0,  1397,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1397,  3038,     0,     0,  1397,  1397,     0,  1397,     0,
-       0,  2056,  2056,  2056,  2056,  2056,     0,     0,     0,  2056,
-    2056,  2056,  2056,  2056,  2056,  2056,  2056,  2056,  2056,  1397,
-    1397,     0,     0,  1384,     0,     0,     0,     0,     0,     0,
-       0,  1397,     0,  3038,     0,     0,     0, -1816,  1397,     0,
-       0,  1397,  1374,  1397,     0,     0,     0,  1397,     0,     0,
-    2056,  2056,     0,     0,  1397,  1397,     0,  1362,  1375,     0,
-    1363,     0,     0,  1376,  1364,  1365,  1366,  1367,  1368,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1369,     0,  1377,  1378,     0,     0,     0,
-       0,  1371,     0,     0,  1397,     0,     0,     0,  1372,     0,
-    1379,     0,  1397,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1037,     0,     0,  1397,     0,     0,     0,     0,
-       0,     0,     0,  1373,     0,  1385,     0,     0,  1386,  1387,
-    1388,  1038,  1389,  1390,  1391,  1392,  1393,  1394,  1380, -1816,
-       0,  1381,  2431,     0,     0,  1693,  1389,  1390,  1391,  1392,
-    1393,  1394,     0,     0,     0,  1382,     0,     0,  1383,     0,
-    1362,     0,     0,  1363,     0,     0,     0,  1364,  1365,  1366,
-    1367,  1368,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1039,  2471,     0,     0,  1369,     0,     0,     0,
-       0,  2472,     0,     0,  1371,  1362,     0,     0,  1363,     0,
-       0,  1372,  1364,  1365,  1366,  1367,  1368,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1369,     0,     0,  1374,     0,  1373,     0,     0,  1371,
-       0,     0,     0,     0,     0,     0,  1372,     0,     0,     0,
-    1375,     0,     0,     0,     0,  1376,     0,  1384,     0,  2473,
-       0,     0,     0,     0,     0,     0,     0,   515,     0,     0,
-       0,  1373,     0,     0,     0,     0,     0,  1377,  1378,     0,
-       0,     0,     0,  1040,  1397,     0,     0,     0,  1693,     0,
-       0,     0,  1379,     0,     0,  1024,     0,  1397,  1397,  1397,
-       0,  1025,  1397,     0,     0,  1397,  1397,     0,  1037,     0,
-    1397,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     516,     0,     0,     0,     0,     0,     0,  1038,     0,     0,
-    1380,     0,     0,  1381,  1041,     0,   517,  1374,     0,     0,
-       0,     0,  1042,     0,     0,     0,     0,  1382,     0,     0,
-    1383,     0,     0,  1375,  1043,     0,  2474,     0,  1376,  1385,
-       0,     0,  1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,
-    1393,  1394,  1374,  1397,     0,     0,  2584,     0,  1039,  2056,
-    1377,  1378,     0,     0,     0,  1044,     0,     0,  1375,     0,
-     518,     0,  1397,  1376,     0,  1379,     0,     0,     0,     0,
-     519,     0,     0,     0,     0,     0,     0,  1026,     0,     0,
-       0,     0,   520,     0,     0,  1377,  1378,   521,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1379,     0,  1046,  1380,     0,     0,  1381,     0,     0,  1384,
-       0,  2056,  1693,     0,   522,     0,     0,  1397,  1397,  1397,
-    1382,     0,     0,  1383,  1047,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1380,  1040,
-       0,  1381,     0,     0,  1049,     0,  2475,     0,     0,  2476,
-       0,     0,     0,     0,     0,  1382,     0,     0,  1383,   523,
-       0,  1397,  1397,   524,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1397,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1397,     0,     0,     0,
-    1041,     0,     0,     0,     0,     0,     0,     0,  1042,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1043,  1385,  1384,     0,  1386,  1387,  1388,     0,  1389,  1390,
-    1391,  1392,  1393,  1394,     0,     0,   525,     0,  2606,     0,
-    2056,  1027,     0,     0,     0,     0,     0,     0,     0,     0,
-     526,  1044,     0,     0,     0,     0,     0,  1384,  1397,     0,
-       0,     0,     0,  1501,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1397,     0,     0,   527,     0,     0,   528,     0,     0,     0,
-       0,     0,  1891,     0,   529,     0,  1029,   530,  1046,  1397,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   531,     0,     0,     0,
-    1047,     0,     0,     0,  1385,     0,  1892,  1386,  1387,  1388,
-     532,  1389,  1390,  1391,  1392,  1393,  1394,   533,     0,     0,
-    1049,  2748,     0,  1397,     0,     0,   534,     0,     0,     0,
-       0,     0,   535,     0,     0,     0,     0,     0,     0,  1385,
-       0,     0,  1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,
-    1393,  1394,  1397,     0,     0,     0,  2811,   536,     0,     0,
-       0,     0,  1061,   864,   556,   865,   866,   867,   868,   869,
-       0,     0,     0,     0,  1031,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,  1062,   102,   103,
-     104,     0,     0,     0,     0,   870,     0,     0,   105,   106,
-    1397,   107,   108,   109,  1063,   111,   112,   113,   114,   871,
-    1064,   872,   873,     0,   119,   120,   121,   122,   123,   124,
-     874,   875,   125,   126,   876,   877,   129,     0,   130,   131,
-     132,   133,   878,     0,  1065,     0,   136,   137,   138,   139,
-     140,   141,  1066,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,  1067,   153,   154,   155,  1068,  1069,
-    1070,  1071,   884,   885,  1072,   161,   162,   163,   164,   165,
-     166,   167,   887,   888,   170,   889,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-    1073,     0,   183,   184,   691,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     890,   199,   200,   201,   202,   203,   891,   892,   205,     0,
-     206,   207,   893,   209,     0,   210,     0,   211,  1074,     0,
-    1075,   214,   215,  1076,  1077,   218,     0,   219,     0,   894,
-     895,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-    1078,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,  1079,   243,   244,   245,   246,   247,
-     248,   896,   897,     0,   898,     0,   252,  1080,  1081,   255,
-    1082,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-    1083,   265,  1084,     0,   267,   268,   269,   899,   900,   270,
-     271,   272,   273,   274,  1085,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   901,  1086,   902,   297,   298,   299,   300,
-     903,   301,   302,  1087,   304,   904,   905,   306,   906,   308,
-     309,   310,     0,   311,   312,     0,     0,   907,   314,   315,
-       0,     0,   316,   317,  1088,   319,  1089,   908,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   909,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   910,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,  1090,   371,   372,   373,   911,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,  1091,   392,   393,   394,   395,   396,  1092,
-     398,   399,   913,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,  1093,   415,   914,
-     417,     0,   418,   419,     0,   420,  1094,   422,   423,   424,
-     425,   426,     0,   915,   916,     0,     0,   429,   430,   917,
-     432,   918,   919,   434,   435,  1095,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,  1096,     0,
-     448,   449,   450,   451,   452,   453,   922,  1097,   455,  1098,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   923,     0,     0,     0,     0,     0,     0,   924,   925,
-    1099,     0,     0,     0,     0,   927,     0,   928,  1100,     0,
-       0,     0,   929,     0,   930,   931,    93,   864,   556,   865,
-     866,   867,   868,   869,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,   870,
-       0,     0,   105,   106,     0,   107,   108,   109,   110,   111,
-     112,   113,   114,   871,   116,   872,   873,     0,   119,   120,
-     121,   122,   123,   124,   874,   875,   125,   126,   876,   877,
-     129,     0,   130,   131,   132,   133,   878,     0,   879,     0,
-     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,   152,   153,
-     154,   155,   880,   881,   882,   883,   884,   885,   886,   161,
-     162,   163,   164,   165,   166,   167,   887,   888,   170,   889,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   691,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   890,   199,   200,   201,   202,   203,
-     891,   892,   205,     0,   206,   207,   893,   209,     0,   210,
-       0,   211,   212,     0,   213,   214,   215,   216,   217,   218,
-       0,   219,     0,   894,   895,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,   242,   243,
-     244,   245,   246,   247,   248,   896,   897,     0,   898,     0,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,   264,   265,   266,     0,   267,   268,
-     269,   899,   900,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   901,   295,   902,
-     297,   298,   299,   300,   903,   301,   302,   303,   304,   904,
-     905,   306,   906,   308,   309,   310,     0,   311,   312,     0,
-       0,   907,   314,   315,     0,     0,   316,   317,   318,   319,
-     320,   908,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   909,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   910,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,   370,   371,   372,   373,   911,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,    26,   386,   387,   388,   389,   390,   912,   392,   393,
-     394,   395,   396,   397,   398,   399,   913,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   914,   417,     0,   418,   419,    31,   420,
-     421,   422,   423,   424,   425,   426,     0,   915,   916,     0,
-       0,   429,   430,   917,   432,   918,   919,   434,   435,   920,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,   921,     0,   448,   449,   450,   451,   452,   584,
-     922,     0,   455,   456,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,    34,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   923,     0,    35,     0,     0,
-       0,     0,   924,   925,     0,     0,     0,     0,     0,   927,
-       0,   928,  2888,     0,     0,     0,   929,     0,   930,   931,
-      93,   864,   556,   865,   866,   867,   868,   869,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,   870,     0,     0,   105,   106,     0,   107,
-     108,   109,   110,   111,   112,   113,   114,   871,   116,   872,
-     873,     0,   119,   120,   121,   122,   123,   124,   874,   875,
-     125,   126,   876,   877,   129,     0,   130,   131,   132,   133,
-     878,     0,   879,     0,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   152,   153,   154,   155,   880,   881,   882,   883,
-     884,   885,   886,   161,   162,   163,   164,   165,   166,   167,
-     887,   888,   170,   889,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   691,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   890,   199,
-     200,   201,   202,   203,   891,   892,   205,     0,   206,   207,
-     893,   209,     0,   210,     0,   211,   212,     0,   213,   214,
-     215,   216,   217,   218,     0,   219,     0,   894,   895,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   242,   243,   244,   245,   246,   247,   248,   896,
-     897,     0,   898,     0,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   264,   265,
-     266,     0,   267,   268,   269,   899,   900,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   901,   295,   902,   297,   298,   299,   300,   903,   301,
-     302,   303,   304,   904,   905,   306,   906,   308,   309,   310,
-       0,   311,   312,     0,     0,   907,   314,   315,     0,     0,
-     316,   317,   318,   319,   320,   908,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   909,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   910,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   370,
-     371,   372,   373,   911,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,    26,   386,   387,   388,   389,
-     390,   912,   392,   393,   394,   395,   396,   397,   398,   399,
-     913,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   914,   417,     0,
-     418,   419,    31,   420,   421,   422,   423,   424,   425,   426,
-       0,   915,   916,     0,     0,   429,   430,   917,   432,   918,
-     919,   434,   435,   920,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   921,     0,   448,   449,
-     450,   451,   452,   584,   922,     0,   455,   456,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,    34,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   923,
-       0,    35,     0,     0,     0,     0,   924,   925,     0,     0,
-       0,     0,     0,   927,     0,   928,     0,     0,     0,     0,
-     929,     0,   930,   931,    93,   864,   556,   865,   866,   867,
-     868,   869,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,   870,     0,     0,
-     105,   106,     0,   107,   108,   109,   110,   111,   112,   113,
-     114,   871,   116,   872,   873,  1701,   119,   120,   121,   122,
-     123,   124,   874,   875,   125,   126,   876,   877,   129,     0,
-     130,   131,   132,   133,   878,     0,   879,     0,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,   152,   153,   154,   155,
-     880,   881,   882,   883,   884,   885,   886,   161,   162,   163,
-     164,   165,   166,   167,   887,   888,   170,   889,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   691,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   890,   199,   200,   201,   202,   203,   891,   892,
-     205,     0,   206,   207,   893,   209,     0,   210,     0,   211,
-     212,  1702,   213,   214,   215,   216,   217,   218,     0,   219,
-       0,   894,   895,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,   242,   243,   244,   245,
-     246,   247,   248,   896,   897,     0,   898,     0,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,     0,
-    1703,   263,   264,   265,   266,     0,   267,   268,   269,   899,
-     900,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   901,   295,   902,   297,   298,
-     299,   300,   903,   301,   302,   303,   304,   904,   905,   306,
-     906,   308,   309,   310,     0,   311,   312,     0,     0,   907,
-     314,   315,     0,     0,   316,   317,   318,   319,   320,   908,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   909,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   910,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,   370,   371,   372,   373,   911,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,   912,   392,   393,   394,   395,
-     396,   397,   398,   399,   913,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   914,   417,     0,   418,   419,     0,   420,   421,   422,
-     423,   424,   425,   426,     0,   915,   916,     0,  1704,   429,
-     430,   917,   432,   918,   919,   434,   435,   920,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-     921,     0,   448,   449,   450,   451,   452,   453,   922,     0,
-     455,   456,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   923,     0,     0,     0,     0,     0,     0,
-     924,   925,     0,     0,     0,     0,     0,   927,     0,   928,
-       0,     0,     0,     0,   929,     0,   930,   931,    93,   864,
-     556,   865,   866,   867,   868,   869,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,  -954,   102,   103,   104,     0,     0,     0,
-    -954,   870,     0,     0,   105,   106,     0,   107,   108,   109,
-     110,   111,   112,   113,   114,   871,   116,   872,   873,     0,
-     119,   120,   121,   122,   123,   124,   874,   875,   125,   126,
-     876,   877,   129,     0,   130,   131,   132,   133,   878,     0,
-     879,     0,   136,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-     152,   153,   154,   155,   880,   881,   882,   883,   884,   885,
-     886,   161,   162,   163,   164,   165,   166,   167,   887,   888,
-     170,   889,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     691,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   890,   199,   200,   201,
-     202,   203,   891,   892,   205,     0,   206,   207,   893,   209,
-       0,   210,     0,   211,   212,     0,   213,   214,   215,   216,
-     217,   218,     0,   219,     0,   894,   895,   222,     0,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-     242,   243,   244,   245,   246,   247,   248,   896,   897,     0,
-     898,     0,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,   264,   265,   266,     0,
-     267,   268,   269,   899,   900,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   901,
-     295,   902,   297,   298,   299,   300,   903,   301,   302,   303,
-     304,   904,   905,   306,   906,   308,   309,   310,     0,   311,
-     312,     0,     0,   907,   314,   315,     0,     0,   316,   317,
-     318,   319,   320,   908,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   909,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   910,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,   370,   371,   372,
-     373,   911,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,   912,
-     392,   393,   394,   395,   396,   397,   398,   399,   913,   401,
-    -954,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   914,   417,     0,   418,   419,
-       0,   420,   421,   422,   423,   424,   425,   426,     0,   915,
-     916,     0,     0,   429,   430,   917,   432,   918,   919,   434,
-     435,   920,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,   921,     0,   448,   449,   450,   451,
-     452,   453,   922,     0,   455,   456,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   923,     0,     0,
-       0,     0,     0,     0,   924,   925,     0,     0,     0,     0,
-       0,   927,     0,   928,     0,     0,     0,     0,   929,     0,
-     930,   931,    93,   864,   556,   865,   866,   867,   868,   869,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,  1442,   102,   103,
-     104,     0,     0,     0,     0,   870,     0,     0,   105,   106,
-       0,   107,   108,   109,   110,   111,   112,   113,   114,   871,
-     116,   872,   873,     0,   119,   120,   121,   122,   123,   124,
-     874,   875,   125,   126,   876,   877,   129,     0,   130,   131,
-     132,   133,   878,     0,   879,     0,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,   152,   153,   154,   155,   880,   881,
-     882,   883,   884,   885,   886,   161,   162,   163,   164,   165,
-     166,   167,   887,   888,   170,   889,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   691,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     890,   199,   200,   201,   202,   203,   891,   892,   205,     0,
-     206,   207,   893,   209,     0,   210,     0,   211,   212,     0,
-     213,   214,   215,   216,   217,   218,     0,   219,     0,   894,
-     895,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,   242,   243,   244,   245,   246,   247,
-     248,   896,   897,     0,   898,     0,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-     264,   265,   266,     0,   267,   268,   269,   899,   900,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   901,   295,   902,   297,   298,   299,   300,
-     903,   301,   302,   303,   304,   904,   905,   306,   906,   308,
-     309,   310,     0,   311,   312,     0,     0,   907,   314,   315,
-       0,     0,   316,   317,   318,   319,   320,   908,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   909,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   910,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,   370,   371,   372,   373,   911,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,   912,   392,   393,   394,   395,   396,   397,
-     398,   399,   913,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   914,
-     417,     0,   418,   419,     0,   420,   421,   422,   423,   424,
-     425,   426,     0,   915,   916,     0,     0,   429,   430,   917,
-     432,   918,   919,   434,   435,   920,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,   921,     0,
-     448,   449,   450,   451,   452,   453,   922,     0,   455,   456,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   923,     0,     0,     0,     0,     0,     0,   924,   925,
-    1443,     0,     0,     0,     0,   927,     0,   928,     0,     0,
-       0,     0,   929,     0,   930,   931,    93,   864,   556,   865,
-     866,   867,   868,   869,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,  2776,   102,   103,   104,     0,     0,     0,     0,   870,
-       0,     0,   105,   106,     0,   107,   108,   109,   110,   111,
-     112,   113,   114,   871,   116,   872,   873,     0,   119,   120,
-     121,   122,   123,   124,   874,   875,   125,   126,   876,   877,
-     129,     0,   130,   131,   132,   133,   878,     0,   879,     0,
-     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,   152,   153,
-    2777,   155,   880,   881,   882,   883,   884,   885,   886,   161,
-     162,   163,   164,   165,   166,   167,   887,   888,   170,   889,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   691,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   890,   199,   200,   201,   202,   203,
-     891,   892,   205,     0,   206,   207,   893,   209,     0,   210,
-       0,   211,   212,     0,   213,   214,   215,   216,   217,   218,
-       0,   219,     0,  2778,   895,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,   242,   243,
-     244,   245,   246,   247,   248,   896,   897,     0,   898,     0,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,   264,   265,   266,     0,   267,   268,
-     269,   899,   900,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   901,   295,   902,
-     297,   298,   299,   300,   903,   301,   302,   303,   304,   904,
-     905,   306,   906,   308,   309,   310,     0,   311,   312,     0,
-       0,   907,   314,   315,     0,     0,   316,   317,   318,   319,
-     320,   908,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   909,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   910,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,   370,   371,   372,  2779,   911,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,   912,   392,   393,
-     394,   395,   396,   397,   398,   399,   913,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   914,   417,     0,   418,   419,     0,   420,
-     421,   422,   423,   424,   425,   426,     0,   915,   916,     0,
-       0,   429,   430,   917,   432,   918,   919,   434,   435,   920,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,   921,     0,   448,   449,   450,   451,   452,   453,
-     922,     0,   455,   456,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   923,     0,     0,     0,     0,
-       0,     0,   924,   925,  2780,     0,     0,     0,     0,   927,
-       0,  2781,     0,     0,     0,     0,   929,     0,   930,   931,
-      93,   864,   556,   865,   866,   867,   868,   869,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,   870,     0,     0,   105,   106,     0,   107,
-     108,   109,   110,   111,   112,   113,   114,   871,   116,   872,
-     873,     0,   119,   120,   121,   122,   123,   124,   874,   875,
-     125,   126,   876,   877,   129,     0,   130,   131,   132,   133,
-     878,     0,   879,     0,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   152,   153,   154,   155,   880,   881,   882,   883,
-     884,   885,   886,   161,   162,   163,   164,   165,   166,   167,
-     887,   888,   170,   889,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   691,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   890,   199,
-     200,   201,   202,   203,   891,   892,   205,     0,   206,   207,
-     893,   209,     0,   210,     0,   211,   212,     0,   213,   214,
-     215,   216,   217,   218,     0,   219,     0,   894,   895,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   242,   243,   244,   245,   246,   247,   248,   896,
-     897,     0,   898,     0,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   264,   265,
-     266,     0,   267,   268,   269,   899,   900,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   901,   295,   902,   297,   298,   299,   300,   903,   301,
-     302,   303,   304,   904,   905,   306,   906,   308,   309,   310,
-       0,   311,   312,     0,     0,   907,   314,   315,     0,     0,
-     316,   317,   318,   319,   320,   908,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   909,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   910,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   370,
-     371,   372,   373,   911,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,   912,   392,   393,   394,   395,   396,   397,   398,   399,
-     913,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   914,   417,     0,
-     418,   419,     0,   420,   421,   422,   423,   424,   425,   426,
-       0,   915,   916,     0,     0,   429,   430,   917,   432,   918,
-     919,   434,   435,   920,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   921,     0,   448,   449,
-     450,   451,   452,   453,   922,     0,   455,   456,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   923,
-       0,     0,     0,     0,     0,     0,   924,   925,   926,     0,
-       0,     0,     0,   927,     0,   928,     0,     0,     0,     0,
-     929,     0,   930,   931,    93,  1456,   556,   865,   866,   867,
-    1457,   869,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,  1458,
-     102,   103,   104,     0,     0,     0,     0,   870,     0,     0,
-     105,   106,     0,   107,   108,   109,   110,   111,   112,   113,
-     114,   871,   116,   872,   873,     0,   119,   120,   121,   122,
-     123,   124,   874,   875,   125,   126,   876,   877,   129,     0,
-     130,   131,   132,   133,   878,     0,   879,     0,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,   152,   153,   154,   155,
-     880,   881,   882,   883,   884,   885,   886,   161,   162,   163,
-     164,   165,   166,   167,   887,   888,   170,   889,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   691,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   890,   199,   200,   201,   202,   203,   891,   892,
-     205,     0,   206,   207,   893,   209,     0,   210,     0,   211,
-     212,     0,   213,   214,   215,   216,   217,   218,     0,   219,
-       0,   894,   895,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,   242,   243,   244,   245,
-     246,   247,   248,   896,   897,     0,   898,     0,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,   264,   265,   266,     0,   267,   268,   269,   899,
-     900,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   901,   295,   902,   297,   298,
-     299,   300,   903,   301,   302,   303,   304,   904,   905,   306,
-     906,   308,   309,   310,     0,   311,   312,     0,     0,   907,
-     314,   315,     0,     0,   316,   317,   318,   319,   320,   908,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   909,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   910,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,   370,   371,   372,   373,   911,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,   912,   392,   393,   394,   395,
-     396,   397,   398,   399,   913,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   914,   417,     0,   418,   419,     0,   420,   421,   422,
-     423,   424,   425,   426,     0,   915,   916,     0,     0,   429,
-     430,   917,   432,   918,   919,   434,   435,   920,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-     921,     0,   448,   449,   450,   451,   452,   453,   922,     0,
-     455,   456,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   923,     0,     0,     0,     0,     0,     0,
-     924,   925,     0,     0,     0,     0,     0,   927,     0,   928,
-       0,     0,     0,     0,   929,     0,   930,   931,    93,   864,
-     556,   865,   866,   867,   868,   869,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,   870,     0,     0,   105,   106,     0,   107,   108,   109,
-     110,   111,   112,   113,   114,   871,   116,   872,   873,     0,
-     119,   120,   121,   122,   123,   124,   874,   875,   125,   126,
-     876,   877,   129,     0,   130,   131,   132,   133,   878,     0,
-     879,     0,   136,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-     152,   153,   154,   155,   880,   881,   882,   883,   884,   885,
-     886,   161,   162,   163,   164,   165,   166,   167,   887,   888,
-     170,   889,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     691,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   890,   199,   200,   201,
-     202,   203,   891,   892,   205,     0,   206,   207,   893,   209,
-       0,   210,     0,   211,   212,     0,   213,   214,   215,   216,
-     217,   218,     0,   219,     0,   894,   895,   222,     0,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-     242,   243,   244,   245,   246,   247,   248,   896,   897,     0,
-     898,     0,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,   264,   265,   266,     0,
-     267,   268,   269,   899,   900,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   901,
-     295,   902,   297,   298,   299,   300,   903,   301,   302,   303,
-     304,   904,   905,   306,   906,   308,   309,   310,     0,   311,
-     312,     0,     0,   907,   314,   315,     0,     0,   316,   317,
-     318,   319,   320,   908,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   909,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   910,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,   370,   371,   372,
-     373,   911,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,   912,
-     392,   393,   394,   395,   396,   397,   398,   399,   913,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   914,   417,     0,   418,   419,
-       0,   420,   421,   422,   423,   424,   425,   426,     0,   915,
-     916,     0,     0,   429,   430,   917,   432,   918,   919,   434,
-     435,   920,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,   921,     0,   448,   449,   450,   451,
-     452,   453,   922,     0,   455,   456,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   923,     0,     0,
-       0,     0,     0,     0,   924,   925,     0,     0,     0,     0,
-       0,   927,     0,   928,  1695,     0,     0,     0,   929,     0,
-     930,   931,  1061,   864,   556,   865,   866,   867,   868,   869,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,   870,     0,     0,   105,   106,
-       0,   107,   108,   109,  1063,   111,   112,   113,   114,   871,
-    1064,   872,   873,     0,   119,   120,   121,   122,   123,   124,
-     874,   875,   125,   126,   876,   877,   129,     0,   130,   131,
-     132,   133,   878,     0,  1065,     0,   136,   137,   138,   139,
-     140,   141,  1066,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,  1067,   153,   154,   155,  1068,  1069,
-    1070,  1071,   884,   885,  1072,   161,   162,   163,   164,   165,
-     166,   167,   887,   888,   170,   889,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   691,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     890,   199,   200,   201,   202,   203,   891,   892,   205,     0,
-     206,   207,   893,   209,     0,   210,     0,   211,  1074,     0,
-    1075,   214,   215,  1076,  1077,   218,     0,   219,     0,   894,
-     895,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-    1078,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,  1079,   243,   244,   245,   246,   247,
-     248,   896,   897,     0,   898,     0,   252,  1080,  1081,   255,
-    1082,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-    1083,   265,  1084,     0,   267,   268,   269,   899,   900,   270,
-     271,   272,   273,   274,  1085,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   901,  1086,   902,   297,   298,   299,   300,
-     903,   301,   302,  1087,   304,   904,   905,   306,   906,   308,
-     309,   310,     0,   311,   312,     0,     0,   907,   314,   315,
-       0,     0,   316,   317,  1088,   319,  1089,   908,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   909,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   910,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,  1090,   371,   372,   373,   911,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,  1091,   392,   393,   394,   395,   396,  1092,
-     398,   399,   913,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,  1093,   415,   914,
-     417,     0,   418,   419,     0,   420,  1094,   422,   423,   424,
-     425,   426,     0,   915,   916,     0,     0,   429,   430,   917,
-     432,   918,   919,   434,   435,  1095,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,  1096,     0,
-     448,   449,   450,   451,   452,   453,   922,  1917,   455,  1098,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   923,     0,     0,     0,     0,     0,     0,   924,   925,
-       0,     0,     0,     0,     0,   927,     0,   928,     0,     0,
-       0,     0,   929,     0,   930,   931,  1061,   864,   556,   865,
-     866,   867,   868,   869,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,   870,
-       0,     0,   105,   106,     0,   107,   108,   109,  1063,   111,
-     112,   113,   114,   871,  1064,   872,   873,     0,   119,   120,
-     121,   122,   123,   124,   874,   875,   125,   126,   876,   877,
-     129,     0,   130,   131,   132,   133,   878,     0,  1065,     0,
-     136,   137,   138,   139,   140,   141,  1066,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,  1067,   153,
-     154,   155,  1068,  1069,  1070,  1071,   884,   885,  1072,   161,
-     162,   163,   164,   165,   166,   167,   887,   888,   170,   889,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   691,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   890,   199,   200,   201,   202,   203,
-     891,   892,   205,     0,   206,   207,   893,   209,     0,   210,
-       0,   211,  1074,     0,  1075,   214,   215,  1076,  1077,   218,
-       0,   219,     0,   894,   895,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,  1078,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,  1079,   243,
-     244,   245,   246,   247,   248,   896,   897,     0,   898,     0,
-     252,  1080,  1081,   255,  1082,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,  1083,   265,  1084,     0,   267,   268,
-     269,   899,   900,   270,   271,   272,   273,   274,  1085,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   901,  1086,   902,
-     297,   298,   299,   300,   903,   301,   302,  1087,   304,   904,
-     905,   306,   906,   308,   309,   310,     0,   311,   312,     0,
-       0,   907,   314,   315,     0,     0,   316,   317,  1088,   319,
-    1089,   908,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   909,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   910,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,  1090,   371,   372,   373,   911,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,  1091,   392,   393,
-     394,   395,   396,  1092,   398,   399,   913,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,  1093,   415,   914,   417,     0,   418,   419,     0,   420,
-    1094,   422,   423,   424,   425,   426,     0,   915,   916,     0,
-       0,   429,   430,   917,   432,   918,   919,   434,   435,  1095,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,  1096,     0,   448,   449,   450,   451,   452,   453,
-     922,     0,   455,  1098,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   923,     0,     0,     0,     0,
-       0,     0,   924,   925,     0,     0,     0,     0,     0,   927,
-       0,   928,  1960,     0,     0,     0,   929,     0,   930,   931,
-      93,   864,   556,   865,   866,   867,   868,   869,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,   870,     0,     0,   105,   106,     0,   107,
-     108,   109,   110,   111,   112,   113,   114,   871,   116,   872,
-     873,     0,   119,   120,   121,   122,   123,   124,   874,   875,
-     125,   126,   876,   877,   129,     0,   130,   131,   132,   133,
-     878,     0,   879,     0,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   152,   153,   154,   155,   880,   881,   882,   883,
-     884,   885,   886,   161,   162,   163,   164,   165,   166,   167,
-     887,   888,   170,   889,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   691,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   890,   199,
-     200,   201,   202,   203,   891,   892,   205,     0,   206,   207,
-     893,   209,     0,   210,     0,   211,   212,  1702,   213,   214,
-     215,   216,   217,   218,     0,   219,     0,   894,   895,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   242,   243,   244,   245,   246,   247,   248,   896,
-     897,     0,   898,     0,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   264,   265,
-     266,     0,   267,   268,   269,   899,   900,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   901,   295,   902,   297,   298,   299,   300,   903,   301,
-     302,   303,   304,   904,   905,   306,   906,   308,   309,   310,
-       0,   311,   312,     0,     0,   907,   314,   315,     0,     0,
-     316,   317,   318,   319,   320,   908,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   909,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   910,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   370,
-     371,   372,   373,   911,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,   912,   392,   393,   394,   395,   396,   397,   398,   399,
-     913,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   914,   417,     0,
-     418,   419,     0,   420,   421,   422,   423,   424,   425,   426,
-       0,   915,   916,     0,     0,   429,   430,   917,   432,   918,
-     919,   434,   435,   920,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   921,     0,   448,   449,
-     450,   451,   452,   453,   922,     0,   455,   456,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   923,
-       0,     0,     0,     0,     0,     0,   924,   925,     0,     0,
-       0,     0,     0,   927,     0,   928,     0,     0,     0,     0,
-     929,     0,   930,   931,    93,   864,   556,   865,   866,   867,
-     868,   869,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,   870,     0,     0,
-     105,   106,     0,   107,   108,   109,   110,   111,   112,   113,
-     114,   871,   116,   872,   873,     0,   119,   120,   121,   122,
-     123,   124,   874,   875,   125,   126,   876,   877,   129,     0,
-     130,   131,   132,   133,   878,     0,   879,     0,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,   152,   153,   154,   155,
-     880,   881,   882,   883,   884,   885,   886,   161,   162,   163,
-     164,   165,   166,   167,   887,   888,   170,   889,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   691,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   890,   199,   200,   201,   202,   203,   891,   892,
-     205,     0,   206,   207,   893,   209,     0,   210,     0,   211,
-     212,     0,   213,   214,   215,   216,   217,   218,     0,   219,
-       0,   894,   895,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,   242,   243,   244,   245,
-     246,   247,   248,   896,   897,     0,   898,     0,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,   264,   265,   266,     0,   267,   268,   269,   899,
-     900,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   901,   295,   902,   297,   298,
-     299,   300,   903,   301,   302,   303,   304,   904,   905,   306,
-     906,   308,   309,   310,     0,   311,   312,     0,     0,   907,
-     314,   315,     0,     0,   316,   317,   318,   319,   320,   908,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   909,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   910,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,   370,   371,   372,   373,   911,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,   912,   392,   393,   394,   395,
-     396,   397,   398,   399,   913,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   914,   417,     0,   418,   419,  2271,   420,   421,   422,
-     423,   424,   425,   426,     0,   915,   916,     0,     0,   429,
-     430,   917,   432,   918,   919,   434,   435,   920,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-     921,     0,   448,   449,   450,   451,   452,   453,   922,     0,
-     455,   456,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   923,     0,     0,     0,     0,     0,     0,
-     924,   925,     0,     0,     0,     0,     0,   927,     0,   928,
-       0,     0,     0,     0,   929,     0,   930,   931,    93,   864,
-     556,   865,   866,   867,   868,   869,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,   870,     0,     0,   105,   106,     0,   107,   108,   109,
-     110,   111,   112,   113,   114,   871,   116,   872,   873,     0,
-     119,   120,   121,   122,   123,   124,   874,   875,   125,   126,
-     876,   877,   129,     0,   130,   131,   132,   133,   878,     0,
-     879,     0,   136,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-     152,   153,   154,   155,   880,   881,   882,   883,   884,   885,
-     886,   161,   162,   163,   164,   165,   166,   167,   887,   888,
-     170,   889,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     691,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   890,   199,   200,   201,
-     202,   203,   891,   892,   205,     0,   206,   207,   893,   209,
-       0,   210,     0,   211,   212,     0,   213,   214,   215,   216,
-     217,   218,     0,   219,     0,   894,   895,   222,     0,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-     242,   243,   244,   245,   246,   247,   248,   896,   897,     0,
-     898,     0,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,   264,   265,   266,     0,
-     267,   268,   269,   899,   900,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   901,
-     295,   902,   297,   298,   299,   300,   903,   301,   302,   303,
-     304,   904,   905,   306,   906,   308,   309,   310,     0,   311,
-     312,     0,     0,   907,   314,   315,     0,     0,   316,   317,
-     318,   319,   320,   908,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   909,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   910,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,   370,   371,   372,
-     373,   911,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,   912,
-     392,   393,   394,   395,   396,   397,   398,   399,   913,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   914,   417,     0,   418,   419,
-       0,   420,   421,   422,   423,   424,   425,   426,     0,   915,
-     916,     0,     0,   429,   430,   917,   432,   918,   919,   434,
-     435,   920,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,   921,     0,   448,   449,   450,   451,
-     452,   453,   922,     0,   455,   456,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   923,     0,     0,
-       0,     0,     0,     0,   924,   925,     0,     0,     0,     0,
-       0,   927,     0,   928,     0,     0,     0,     0,   929,     0,
-     930,   931,  1061,   864,   556,   865,   866,   867,   868,   869,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,   870,     0,     0,   105,   106,
-       0,   107,   108,   109,  1063,   111,   112,   113,   114,   871,
-    1064,   872,   873,     0,   119,   120,   121,   122,   123,   124,
-     874,   875,   125,   126,   876,   877,   129,     0,   130,   131,
-     132,   133,   878,     0,  1065,     0,   136,   137,   138,   139,
-     140,   141,  1066,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,  1067,   153,   154,   155,  1068,  1069,
-    1070,  1071,   884,   885,  1072,   161,   162,   163,   164,   165,
-     166,   167,   887,   888,   170,   889,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   691,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     890,   199,   200,   201,   202,   203,   891,   892,   205,     0,
-     206,   207,   893,   209,     0,   210,     0,   211,  1074,     0,
-    1075,   214,   215,  1076,  1077,   218,     0,   219,     0,   894,
-     895,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-    1078,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,  1079,   243,   244,   245,   246,   247,
-     248,   896,   897,     0,   898,     0,   252,  1080,  1081,   255,
-    1082,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-    1083,   265,  1084,     0,   267,   268,   269,   899,   900,   270,
-     271,   272,   273,   274,  1085,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   901,  1086,   902,   297,   298,   299,   300,
-     903,   301,   302,  1087,   304,   904,   905,   306,   906,   308,
-     309,   310,     0,   311,   312,     0,     0,   907,   314,   315,
-       0,     0,   316,   317,  1088,   319,  1089,   908,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   909,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   910,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,  1090,   371,   372,   373,   911,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,  1091,   392,   393,   394,   395,   396,  1092,
-     398,   399,   913,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,  1093,   415,   914,
-     417,     0,   418,   419,     0,   420,  1094,   422,   423,   424,
-     425,   426,     0,   915,   916,     0,     0,   429,   430,   917,
-     432,   918,   919,   434,   435,  1095,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,  1096,     0,
-     448,   449,   450,   451,   452,   453,   922,     0,   455,  1098,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   923,     0,     0,     0,     0,     0,     0,   924,   925,
-       0,     0,     0,     0,     0,   927,     0,   928,     0,     0,
-       0,     0,   929,     0,   930,   931,    93,   864,   556,   865,
-     866,   867,   868,   869,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,   870,
-       0,     0,   105,   106,     0,   107,   108,   109,   110,   111,
-     112,   113,   114,   871,   116,   872,   873,     0,   119,   120,
-     121,   122,   123,   124,   874,   875,   125,   126,   876,   877,
-     129,     0,   130,   131,   132,   133,   878,     0,   879,     0,
-     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,   152,   153,
-     154,   155,   880,   881,   882,   883,   884,   885,   886,   161,
-     162,   163,   164,   165,   166,   167,   887,   888,   170,   889,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   691,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   890,   199,   200,   201,   202,   203,
-     891,   892,   205,     0,   206,   207,   893,   209,     0,   210,
-       0,   211,   212,     0,   213,   214,   215,   216,   217,   218,
-       0,   219,     0,   894,   895,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,   242,   243,
-     244,   245,   246,   247,   248,   896,   897,     0,   898,     0,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,   264,   265,   266,     0,   267,   268,
-     269,   899,   900,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   901,   295,   902,
-     297,   298,   299,   300,   903,   301,   302,   303,   304,   904,
-     905,   306,   906,   308,   309,   310,     0,   311,   312,     0,
-       0,   907,   314,   315,     0,     0,   316,   317,   318,   319,
-     320,   908,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   909,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   910,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,   370,   371,   372,   373,   911,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,   912,   392,   393,
-     394,   395,   396,   397,   398,   399,   913,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   914,   417,     0,   418,   419,     0,   420,
-     421,   422,   423,   424,   425,   426,     0,   915,   916,     0,
-       0,   429,   430,   917,   432,   918,   919,   434,   435,   920,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,   921,     0,   448,   449,   450,   451,   452,   453,
-     922,     0,   455,   456,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   923,     0,     0,     0,     0,
-       0,     0,  1461,  1462,     0,     0,     0,     0,     0,   927,
-       0,   928,     0,     0,     0,     0,   929,     0,   930,   931,
-      93,  1841,   556,   865,   866,   867,   868,   869,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,   870,     0,     0,   105,   106,     0,   107,
-     108,   109,   110,   111,   112,   113,   114,   871,   116,   872,
-     873,     0,   119,   120,   121,   122,   123,   124,   874,   875,
-     125,   126,   876,   877,   129,     0,   130,   131,   132,   133,
-     878,     0,   879,     0,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   152,   153,   154,   155,   880,   881,   882,   883,
-     884,   885,   886,   161,   162,   163,   164,   165,   166,   167,
-     887,   888,   170,   889,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   691,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   890,   199,
-     200,   201,   202,   203,   891,   892,   205,     0,   206,   207,
-     893,   209,     0,   210,     0,   211,   212,     0,   213,   214,
-     215,   216,   217,   218,     0,   219,     0,   894,   895,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   242,   243,   244,   245,   246,   247,   248,   896,
-     897,     0,   898,     0,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   264,   265,
-     266,     0,   267,   268,   269,   899,   900,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   901,   295,   902,   297,   298,   299,   300,   903,   301,
-     302,   303,   304,   904,   905,   306,   906,   308,   309,   310,
-       0,   311,   312,     0,     0,   907,   314,   315,     0,     0,
-     316,   317,   318,   319,   320,   908,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   909,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   910,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   370,
-     371,   372,   373,   911,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,   912,   392,   393,   394,   395,   396,   397,   398,   399,
-     913,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   914,   417,     0,
-     418,   419,     0,   420,   421,   422,   423,   424,   425,   426,
-       0,   915,   916,     0,     0,   429,   430,   917,   432,   918,
-     919,   434,   435,   920,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   921,     0,   448,   449,
-     450,   451,   452,   453,   922,     0,   455,   456,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   923,
-       0,     0,     0,     0,     0,     0,   924,   925,     0,     0,
-       0,     0,     0,   927,     0,   928,     0,     0,     0,     0,
-     929,     0,   930,   931,    93,   864,   556,   865,   866,   867,
-     868,   869,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,   870,     0,     0,
-     105,   106,     0,   107,   108,   109,   110,   111,   112,   113,
-     114,   871,   116,   872,   873,     0,   119,   120,   121,   122,
-     123,   124,   874,   875,   125,   126,   876,   877,   129,     0,
-     130,   131,   132,   133,   878,     0,   879,     0,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,   152,   153,   154,   155,
-     880,   881,   882,   883,   884,   885,   886,   161,   162,   163,
-     164,   165,   166,   167,   887,   888,   170,   889,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   691,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   890,   199,   200,   201,   202,   203,   891,   892,
-     205,     0,   206,   207,   893,   209,     0,   210,     0,   211,
-     212,     0,   213,   214,   215,   216,   217,   218,     0,   219,
-       0,   894,   895,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,   242,   243,   244,   245,
-     246,   247,   248,   896,   897,     0,   898,     0,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,   264,   265,   266,     0,   267,   268,   269,   899,
-     900,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   901,   295,   902,   297,   298,
-     299,   300,   903,   301,   302,   303,   304,   904,   905,   306,
-     906,   308,   309,   310,     0,   311,   312,     0,     0,   907,
-     314,   315,     0,     0,   316,   317,   318,   319,   320,   908,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   909,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   910,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,   370,   371,   372,   373,   911,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,   912,   392,   393,   394,   395,
-     396,   397,   398,   399,   913,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   914,   417,     0,   418,   419,     0,   420,   421,   422,
-     423,   424,   425,   426,     0,   915,   916,     0,     0,   429,
-     430,   917,   432,   918,   919,   434,   435,   920,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-     921,     0,   448,   449,   450,   451,   452,   453,   922,     0,
-     455,   456,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   923,     0,     0,     0,     0,     0,     0,
-     924,   925,     0,     0,     0,     0,     0,   927,     0,  2076,
-       0,     0,     0,     0,   929,     0,   930,   931,    93,   864,
-     556,   865,   866,   867,   868,   869,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,   870,     0,     0,   105,   106,     0,   107,   108,   109,
-     110,   111,   112,   113,   114,   871,   116,   872,   873,     0,
-     119,   120,   121,   122,   123,   124,   874,   875,   125,   126,
-     876,   877,   129,     0,   130,   131,   132,   133,   878,     0,
-     879,     0,   136,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-     152,   153,  2777,   155,   880,   881,   882,   883,   884,   885,
-     886,   161,   162,   163,   164,   165,   166,   167,   887,   888,
-     170,   889,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     691,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   890,   199,   200,   201,
-     202,   203,   891,   892,   205,     0,   206,   207,   893,   209,
-       0,   210,     0,   211,   212,     0,   213,   214,   215,   216,
-     217,   218,     0,   219,     0,  2778,   895,   222,     0,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-     242,   243,   244,   245,   246,   247,   248,   896,   897,     0,
-     898,     0,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,   264,   265,   266,     0,
-     267,   268,   269,   899,   900,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   901,
-     295,   902,   297,   298,   299,   300,   903,   301,   302,   303,
-     304,   904,   905,   306,   906,   308,   309,   310,     0,   311,
-     312,     0,     0,   907,   314,   315,     0,     0,   316,   317,
-     318,   319,   320,   908,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   909,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   910,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,   370,   371,   372,
-    2779,   911,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,   912,
-     392,   393,   394,   395,   396,   397,   398,   399,   913,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   914,   417,     0,   418,   419,
-       0,   420,   421,   422,   423,   424,   425,   426,     0,   915,
-     916,     0,     0,   429,   430,   917,   432,   918,   919,   434,
-     435,   920,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,   921,     0,   448,   449,   450,   451,
-     452,   453,   922,     0,   455,   456,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   923,     0,     0,
-       0,     0,     0,     0,   924,   925,     0,     0,     0,     0,
-       0,   927,     0,  2781,     0,     0,     0,     0,   929,     0,
-     930,   931,    93,   864,   556,   865,   866,   867,   868,   869,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,   870,     0,     0,   105,   106,
-       0,   107,   108,   109,   110,   111,   112,   113,  3035,   871,
-     116,   872,   873,     0,   119,   120,   121,   122,   123,   124,
-     874,   875,   125,   126,   876,   877,   129,     0,   130,   131,
-     132,   133,   878,     0,   879,     0,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,   152,   153,   154,  3036,   880,   881,
-     882,   883,   884,   885,   886,   161,   162,   163,   164,   165,
-     166,   167,   887,   888,   170,   889,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   691,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     890,   199,   200,   201,   202,   203,   891,   892,   205,     0,
-     206,   207,   893,   209,     0,   210,     0,   211,   212,     0,
-     213,   214,   215,   216,   217,   218,     0,   219,     0,   894,
-     895,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,   242,   243,   244,   245,   246,   247,
-     248,   896,   897,     0,   898,     0,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-     264,   265,   266,     0,   267,   268,   269,   899,   900,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   901,   295,   902,   297,   298,   299,   300,
-     903,   301,   302,   303,   304,   904,   905,   306,   906,   308,
-     309,   310,     0,   311,   312,     0,     0,   907,   314,   315,
-       0,     0,   316,   317,   318,   319,   320,   908,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   909,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   910,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,   370,   371,   372,   373,   911,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,   912,   392,   393,   394,   395,   396,   397,
-     398,   399,   913,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   914,
-     417,     0,   418,   419,     0,   420,   421,   422,   423,   424,
-     425,   426,     0,   915,   916,     0,     0,   429,   430,   917,
-     432,   918,   919,   434,   435,   920,   437,   438,  3037,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,   921,     0,
-     448,   449,   450,   451,   452,   453,   922,     0,   455,   456,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   923,     0,     0,     0,     0,     0,     0,   924,   925,
-       0,     0,     0,     0,     0,   927,     0,   928,     0,     0,
-       0,     0,   929,     0,   930,   931,    93,   864,   556,   865,
-     866,   867,   868,   869,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,   870,
-       0,     0,   105,   106,     0,   107,   108,   109,   110,   111,
-     112,   113,   114,   871,   116,   872,   873,     0,   119,   120,
-     121,   122,   123,   124,   874,   875,   125,   126,   876,   877,
-     129,     0,   130,   131,   132,   133,   878,     0,   879,     0,
-     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,   152,   153,
-     154,  3036,   880,   881,   882,   883,   884,   885,   886,   161,
-     162,   163,   164,   165,   166,   167,   887,   888,   170,   889,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   691,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   890,   199,   200,   201,   202,   203,
-     891,   892,   205,     0,   206,   207,   893,   209,     0,   210,
-       0,   211,   212,     0,   213,   214,   215,   216,   217,   218,
-       0,   219,     0,   894,   895,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,   242,   243,
-     244,   245,   246,   247,   248,   896,   897,     0,   898,     0,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,   264,   265,   266,     0,   267,   268,
-     269,   899,   900,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   901,   295,   902,
-     297,   298,   299,   300,   903,   301,   302,   303,   304,   904,
-     905,   306,   906,   308,   309,   310,     0,   311,   312,     0,
-       0,   907,   314,   315,     0,     0,   316,   317,   318,   319,
-     320,   908,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   909,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   910,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,   370,   371,   372,   373,   911,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,   912,   392,   393,
-     394,   395,   396,   397,   398,   399,   913,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   914,   417,     0,   418,   419,     0,   420,
-     421,   422,   423,   424,   425,   426,     0,   915,   916,     0,
-       0,   429,   430,   917,   432,   918,   919,   434,   435,   920,
-     437,   438,  3037,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,   921,     0,   448,   449,   450,   451,   452,   453,
-     922,     0,   455,   456,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   923,     0,     0,     0,     0,
-       0,     0,   924,   925,     0,     0,     0,     0,     0,   927,
-       0,   928,     0,     0,     0,     0,   929,     0,   930,   931,
-      93,   864,   556,   865,   866,   867,   868,   869,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,   870,     0,     0,   105,   106,     0,   107,
-     108,   109,   110,   111,   112,   113, -1816,   871,   116,   872,
-     873,     0,   119,   120,   121,   122,   123,   124,   874,   875,
-     125,   126,   876,   877,   129,     0,   130,   131,   132,   133,
-     878,     0,   879,     0,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   152,   153,   154,  3036,   880,   881,   882,   883,
-     884,   885,   886,   161,   162,   163,   164,   165,   166,   167,
-     887,   888,   170,   889,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   691,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   890,   199,
-     200,   201,   202,   203,   891,   892,   205,     0,   206,   207,
-     893,   209,     0,   210,     0,   211,   212,     0,   213,   214,
-     215,   216, -1816,   218,     0,   219,     0,   894,   895,   222,
-       0,   223,   224,   225,   226,   227,   228,   229, -1816,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   242,   243,   244,   245,   246,   247,   248,   896,
-     897,     0,   898,     0,   252,     0,     0,   255,   256,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   264,   265,
-   -1816,     0,   267,   268,   269,   899,   900,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   901,   295,   902,   297,   298,   299,   300,     0,   301,
-     302,     0,   304,   904,   905,   306,   906,   308,   309,   310,
-       0,   311,   312,     0,     0,   907,   314,   315,     0,     0,
-     316,   317,   318,   319,   320,   908,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   909,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   910,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   370,
-     371,   372,   373,   911,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,   912,   392,   393,   394,   395,   396, -1816,   398,   399,
-     913,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   914,   417,     0,
-     418,   419,     0,   420,   421,   422,   423,   424,   425,   426,
-       0,   915,   916,     0,     0,   429,   430,   917,   432,   918,
-     919,   434,   435,   920,   437,   438,  3037,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   921,     0,   448,   449,
-     450,   451,   452,   453,   922,     0,   455,   456,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483, -1816,
-       0,     0,     0,     0,     0,     0,   924,   925,     0,     0,
-       0,     0,     0,   927,     0,   928,     0,     0,     0,     0,
-     929,     0,   930,   931,    93,   864,   556,   865,   866,   867,
-     868,   869,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,     0,     0,     0,
-     105,   106,     0,   107,   108,   109,   110,   111,   112,   113,
-     114,   871,   116,   872,   873,     0,   119,   120,   121,   122,
-     123,   124,   874,   875,   125,   126,   876,   877,   129,     0,
-     130,   131,   132,   133,   878,     0,   879,     0,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,   152,   153,   154,   155,
-     880,   881,   882,   883,   884,   885,   886,   161,   162,   163,
-     164,   165,   166,   167,   887,   888,   170,     0,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   691,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   890,   199,   200,   201,   202,   203,   891,   892,
-     205,     0,   206,   207,   893,   209,     0,   210,     0,   211,
-     212,     0,   213,   214,   215,   216,   217,   218,     0,   219,
-       0,   894,   895,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,   242,   243,   244,   245,
-     246,   247,   248,   896,   897,     0,   898,     0,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,   264,   265,   266,     0,   267,   268,   269,   899,
-     900,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   901,   295,   902,   297,   298,
-     299,   300,     0,   301,   302,   303,   304,   904,   905,   306,
-     906,   308,   309,   310,     0,   311,   312,     0,     0,   907,
-     314,   315,     0,     0,   316,   317,   318,   319,   320,   908,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   909,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   910,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,   912,   392,   393,   394,   395,
-     396,   397,   398,   399,   913,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   914,   417,     0,   418,   419,     0,   420,   421,   422,
-     423,   424,   425,   426,     0,   915,   916,     0,     0,   429,
-     430,   917,   432,   918,   919,   434,   435,   920,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-     921,     0,   448,   449,   450,   451,   452,   453,   922,     0,
-     455,   456,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,     0,     0,     0,     0,     0,     0,     0,
-    1688,  1689,     0,     0,    93,   864,   556,   865,   866,  1690,
-     868,   869,     0,     0,     0,     0,   930,   931,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,     0,     0,     0,
-     105,   106,     0,   107,   108,   109,   110,   111,   112,   113,
-     114,   871,   116,   872,   873,     0,   119,   120,   121,   122,
-     123,   124,   874,   875,   125,   126,   876,   877,   129,     0,
-     130,   131,   132,   133,   878,     0,   879,     0,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,   152,   153,   154,   155,
-     880,   881,   882,   883,   884,   885,   886,   161,   162,   163,
-     164,   165,   166,   167,   887,   888,   170,     0,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   691,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   890,   199,   200,   201,   202,   203,   891,   892,
-     205,     0,   206,   207,   893,   209,     0,   210,     0,   211,
-     212,     0,   213,   214,   215,   216,   217,   218,     0,   219,
-       0,   894,   895,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,   242,   243,   244,   245,
-     246,   247,   248,   896,   897,     0,   898,     0,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,   264,   265,   266,     0,   267,   268,   269,   899,
-     900,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   901,   295,   902,   297,   298,
-     299,   300,     0,   301,   302,   303,   304,   904,   905,   306,
-     906,   308,   309,   310,     0,   311,   312,     0,     0,   313,
-     314,   315,     0,     0,   316,   317,   318,   319,   320,   908,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   909,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   910,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,   370,   371,   372,   373,  1827,  1828,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,   912,   392,   393,   394,   395,
-     396,   397,   398,   399,   913,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   914,   417,     0,   418,   419,     0,   420,   421,   422,
-     423,   424,   425,   426,     0,   915,   916,     0,     0,   429,
-     430,   917,   432,   918,   919,   434,   435,   920,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-     921,     0,   448,   449,   450,   451,   452,   453,   922,     0,
-     455,   456,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,     0,     0,     0,     0,     0,     0,     0,
-    1829,  1830,     0,     0,     0,     0,     0,     0,     0,  1690,
-       0,     0,     0,     0,     0,     0,   930,   931,    93,   864,
-     556,   865,   866,   867,   868,   869,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,     0,     0,     0,   105,   106,     0,   107,   108,   109,
-     110,   111,   112,   113,   114,   871,   116,   872,   873,     0,
-     119,   120,   121,   122,   123,   124,   874,   875,   125,   126,
-     876,   877,   129,     0,   130,   131,   132,   133,   878,     0,
-     879,     0,   136,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-     152,   153,   154,   155,   880,   881,   882,   883,   884,   885,
-     886,   161,   162,   163,   164,   165,   166,   167,   887,   888,
-     170,     0,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     691,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   890,   199,   200,   201,
-     202,   203,   891,   892,   205,     0,   206,   207,   893,   209,
-       0,   210,     0,   211,   212,     0,   213,   214,   215,   216,
-     217,   218,     0,   219,     0,   894,   895,   222,     0,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-     242,   243,   244,   245,   246,   247,   248,   896,   897,     0,
-     898,     0,   252,     0,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,   264,   265,   266,     0,
-     267,   268,   269,   899,   900,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   901,
-     295,   902,   297,   298,   299,   300,     0,   301,   302,   303,
-     304,   904,   905,   306,   906,   308,   309,   310,     0,   311,
-     312,     0,     0,   907,   314,   315,     0,     0,   316,   317,
-     318,   319,   320,   908,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   909,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   910,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,   912,
-     392,   393,   394,   395,   396,   397,   398,   399,   913,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   914,   417,     0,   418,   419,
-       0,   420,   421,   422,   423,   424,   425,   426,     0,   915,
-     916,     0,     0,   429,   430,   917,   432,   918,   919,   434,
-     435,   920,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,   921,     0,   448,   449,   450,   451,
-     452,   453,   922,     0,   455,   456,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,     0,     0,     0,
-       0,     0,     0,     0,  1688,  1689,     0,     0,     0,     0,
-       0,     0,     0,  1690,     0,     0,     0,     0,     0,     0,
-     930,   931,    93,   864,   556,   865,   866,   867,   868,   869,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,   870,     0,     0,   105,   106,
-       0,   107,   108,   109,   110,   111,   112,   113,     0,   871,
-     116,   872,   873,     0,   119,   120,   121,   122,   123,   124,
-     874,   875,   125,   126,   876,   877,   129,     0,   130,   131,
-     132,   133,   878,     0,   879,     0,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,   152,   153,   154,   155,   880,   881,
-     882,   883,   884,   885,   886,   161,   162,   163,   164,   165,
-     166,   167,   887,   888,   170,   889,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   691,   186,   187,     0,   188,   189,
-     190,     0,   191,     0,   193,     0,   194,   195,   196,   197,
-     890,   199,   200,   201,   202,   203,   891,   892,   205,     0,
-     206,   207,   893,   209,     0,   210,     0,   211,   212,     0,
-     213,   214,   215,   216,     0,   218,     0,   219,     0,   894,
-     895,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-       0,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,   242,   243,   244,   245,   246,   247,
-     248,   896,   897,     0,   898,     0,   252,     0,     0,   255,
-     256,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-     264,   265,     0,     0,   267,   268,   269,   899,   900,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   901,   295,   902,   297,   298,   299,   300,
-       0,   301,   302,     0,   304,   904,   905,   306,   906,   308,
-     309,   310,     0,   311,   312,     0,     0,   907,   314,   315,
-       0,     0,   316,   317,   318,   319,   320,   908,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   909,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   910,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,   370,   371,   372,   373,   911,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,   912,   392,   393,   394,   395,   396,     0,
-     398,   399,   913,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   914,
-     417,     0,   418,   419,     0,   420,   421,   422,   423,   424,
-     425,   426,     0,   915,   916,     0,     0,   429,   430,   917,
-     432,   918,   919,   434,   435,   920,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,   921,     0,
-     448,   449,   450,   451,   452,   453,   922,     0,   455,   456,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,     0,     0,     0,     0,     0,     0,     0,   924,   925,
-     506,     0,     0,     0,     0,   927,     0,   928,     0,     0,
-       0,     0,   929,     0,   930,   931,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,     0,  2381,     0,   105,   106,     0,   107,
-     108,   109,     0,   111,   112,   113,   114,   115,     0,   117,
-     118,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   127,   128,   129,     0,   130,   131,   132,   133,
-     134,     0,     0,     0,   136,   137,   138,   139,   140,   141,
-       0,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,  -624,   153,   154,   155,     0,     0,     0,     0,
-       0,     0,     0,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,     0,   205,     0,   206,   207,
-     208,   209,     0,   210,     0,   211,     0,     0,  -624,   214,
-     215,   508,     0,   218,     0,   219,     0,   220,   221,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,     0,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,  -624,   243,   244,   245,   246,   247,   248,   249,
-     250,     0,   251,     0,   252,     0,     0,   255,  -624,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,  -624,   265,
-       0,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,   509,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,  -624,   296,   297,   298,   299,   300,     0,   301,
-     302,     0,   304,     0,   305,   306,   307,   308,   309,   310,
-       0,   311,   312,     0,     0,   313,   314,   315,     0,     0,
-     316,   317,     0,   319,     0,   321,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   350,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,  -624,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,     0,   392,   393,   394,   395,   396,     0,   398,   399,
-     400,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   511,   415,   416,   417,     0,
-     418,   419,     0,   420,  -624,   422,   423,   424,   425,   426,
-       0,   427,   428,     0,     0,   429,   430,   431,   432,   433,
-       0,   434,   435,   436,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,     0,     0,   448,   449,
-     450,   451,   452,   453,   454,     0,   455,     0,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,     0,
-      93,     0,   588,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   993,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
-     118,     0,   119,   120,   121,   122,   123,   124,     0,   875,
-     125,   126,   127,   128,   129,     0,   130,   131,   132,   133,
-     878,     0,   879,     0,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   152,   153,   154,   155,   880,   881,   882,   883,
-     884,   885,   886,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   891,     0,   205,     0,   206,   207,
-     208,   209,     0,   210,     0,   211,   212,     0,   213,   214,
-     215,   216,   217,   218,     0,   219,     0,   220,   221,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,     0,   251,     0,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,  2122,     0,   263,   264,   265,
-     266,     0,   267,   268,   269,   899,   900,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,     0,   301,
-     302,   303,   304,     0,   905,   306,   307,   308,   309,   310,
-       0,   311,   312,     0,   589,   313,   314,   315,     0,     0,
-     316,   317,   318,   319,   320,   908,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   909,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   350,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   370,
-     371,   372,   373,   374,  2123,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,    26,   386,   387,   388,   389,
-     390,   912,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   914,   417,     0,
-     418,   419,    31,   420,   421,   422,   423,   424,   425,   426,
-       0,   427,   428,     0,     0,   429,   430,   917,   432,   918,
-       0,   434,   435,   920,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   921,     0,   448,   449,
-     450,   451,   452,   584,   454,     0,   455,   456,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,    34,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,     0,
-       0,    35,   761,  1285,   556,     0,     0,     0,   868,     0,
-       0,     0,     0,     0,     0,  2124,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,     0,     0,     0,   105,   106,
-       0,   107,   108,   109,   762,   111,   112,   113,   763,   764,
-     765,   766,   767,     0,   119,   120,   121,   122,   123,   124,
-       0,     0,   125,   126,   768,   769,   129,     0,   130,   131,
-     132,   133,   770,     0,   771,     0,   136,   137,   138,   139,
-     140,   141,   772,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,   773,   153,   154,   155,   774,   775,
-     776,   777,     0,     0,   778,   161,   162,   163,   164,   165,
-     166,   167,   779,   780,   170,     0,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   185,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     781,   199,   200,   201,   202,   203,   782,  1286,   205,     0,
-     206,   207,   783,   209,     0,   210,     0,   211,   784,     0,
-     785,   214,   215,   786,   787,   218,     0,   219,     0,   788,
-     789,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-     790,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,   791,   792,   244,   245,   246,   247,
-     248,   793,   794,     0,   795,     0,   252,   796,   797,   255,
-     798,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-     799,   265,   800,     0,   267,   268,   269,     0,     0,   270,
-     271,   272,   273,   274,   801,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   802,   803,   804,   297,   298,   299,   805,
-       0,   301,   302,   806,   304,     0,   807,   306,   808,   308,
-     309,   310,     0,   311,   312,  1287,     0,   313,   314,   315,
-       0,     0,   316,   809,   810,   319,   811,   812,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   813,   335,   336,   814,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   815,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,   816,   371,   372,   373,   817,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,   818,   392,   819,   394,   395,   396,   820,
-     398,   399,   821,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   822,   415,   823,
-     417,     0,   418,   419,     0,   420,   824,   422,   423,   424,
-     425,   426,     0,   825,   826,     0,     0,   429,   430,   827,
-     432,   828,  1288,   434,   435,   829,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,   830,     0,
-     448,   449,   450,   451,   452,  1178,   832,     0,   455,   833,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   834,   835,   836,   837,
-     838,   839,   840,   841,   842,   843,   844,   480,   481,   482,
-     483,    93,     0,   588,     0,     0,     0,     0,  1289,  1290,
-    1999,     0,     0,     0,     0,     0,     0,  2000,    94,    95,
-      96,    97,    98,    99,   100,   101,     0,   102,   103,   104,
-       0,     0,     0,     0,     0,     0,     0,   105,   106,     0,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,     0,   119,   120,   121,   122,   123,   124,     0,
-     875,   125,   126,   127,   128,   129,     0,   130,   131,   132,
-     133,   878,     0,   879,     0,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,     0,   146,   147,   148,   149,
-     150,   151,     0,   152,   153,   154,   155,   880,   881,   882,
-     883,   884,   885,   886,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,     0,   171,     0,   172,   173,   174,
-     175,   176,   177,     0,   178,   179,   180,   181,   182,     0,
-       0,   183,   184,   185,   186,   187,     0,   188,   189,   190,
-       0,   191,   192,   193,     0,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   891,     0,   205,     0,   206,
-     207,   208,   209,     0,   210,     0,   211,   212,     0,   213,
-     214,   215,   216,   217,   218,     0,   219,     0,   220,   221,
-     222,     0,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,     0,   235,   236,   237,   238,   239,
-     240,     0,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,     0,   251,     0,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,  2122,     0,   263,   264,
-     265,   266,     0,   267,   268,   269,   899,   900,   270,   271,
-     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   294,   295,   296,   297,   298,   299,   300,     0,
-     301,   302,   303,   304,     0,   905,   306,   307,   308,   309,
-     310,     0,   311,   312,     0,   589,   313,   314,   315,     0,
-       0,   316,   317,   318,   319,   320,   908,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,     0,   332,   333,
-     909,   335,   336,   337,   338,   339,   340,     0,   341,   342,
-     343,   344,   345,   346,     0,   347,   348,   349,   350,   351,
-     352,   353,   354,     0,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,     0,   368,   369,
-     370,   371,   372,   373,   374,  2123,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,     0,   386,   387,   388,
-     389,   390,   912,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,     0,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   914,   417,
-       0,   418,   419,     0,   420,   421,   422,   423,   424,   425,
-     426,     0,   427,   428,     0,     0,   429,   430,   917,   432,
-     918,     0,   434,   435,   920,   437,   438,   439,   440,   441,
-       0,     0,   442,   443,   444,   445,   446,   921,     0,   448,
-     449,   450,   451,   452,   453,   454,     0,   455,   456,   457,
-     458,   459,   460,   461,     0,     0,   462,     0,     0,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
-     761,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  2124,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     3,
-       4,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,   762,   111,   112,   113,   763,   764,   765,   766,
-     767,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   768,   769,   129,     0,   130,   131,   132,   133,
-     770,     0,   771,     0,   136,   137,   138,   139,   140,   141,
-     772,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   773,   153,   154,   155,   774,   775,   776,   777,
-       0,     0,   778,   161,   162,   163,   164,   165,   166,   167,
-     779,   780,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   781,   199,
-     200,   201,   202,   203,   782,     0,   205,     0,   206,   207,
-     783,   209,     0,   210,     0,   211,   784,     0,   785,   214,
-     215,   786,   787,   218,     0,   219,     0,   788,   789,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   790,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   791,   792,   244,   245,   246,   247,   248,   793,
-     794,     0,   795,     0,   252,   796,   797,   255,   798,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   799,   265,
-     800,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,   801,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   802,   803,   804,   297,   298,   299,   805,     0,   301,
-     302,   806,   304,     0,   807,   306,   808,   308,   309,   310,
-       0,   311,   312,     0,     0,   313,   314,   315,     0,     0,
-     316,   809,   810,   319,   811,   812,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   813,
-     335,   336,   814,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   815,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   816,
-     371,   372,   373,   817,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,    26,   386,   387,   388,   389,
-     390,   818,   392,   819,   394,   395,   396,   820,   398,   399,
-     821,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   822,   415,   823,   417,     0,
-     418,   419,    31,   420,   824,   422,   423,   424,   425,   426,
-       0,   825,   826,     0,     0,   429,   430,   827,   432,   828,
-       0,   434,   435,   829,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   830,     0,   448,   449,
-     450,   451,   452,   831,   832,     0,   455,   833,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,    34,   463,   464,
-     465,   466,   467,   468,   834,   835,   836,   837,   838,   839,
-     840,   841,   842,   843,   844,   480,   481,   482,   483,    93,
-       0,    35,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    36,    94,    95,    96,    97,
-      98,    99,   100,   101,     0,   102,   103,   104,     0,     0,
-       0,     0,     0,     0,     0,   105,   106,     0,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-       0,   119,   120,   121,   122,   123,   124,     0,   875,   125,
-     126,   127,   128,   129,     0,   130,   131,   132,   133,   878,
-       0,   879,     0,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,     0,   146,   147,   148,   149,   150,   151,
-       0,   152,   153,   154,   155,   880,   881,   882,   883,   884,
-     885,   886,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,     0,   171,     0,   172,   173,   174,   175,   176,
-     177,     0,   178,   179,   180,   181,   182,     0,     0,   183,
-     184,   185,   186,   187,     0,   188,   189,   190,     0,   191,
-     192,   193,     0,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   891,     0,   205,     0,   206,   207,   208,
-     209,     0,   210,     0,   211,   212,     0,   213,   214,   215,
-     216,   217,   218,     0,   219,     0,   220,   221,   222,     0,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,     0,   235,   236,   237,   238,   239,   240,     0,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-       0,   251,     0,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,     0,     0,   263,   264,   265,   266,
-       0,   267,   268,   269,   899,   900,   270,   271,   272,   273,
-     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     294,   295,   296,   297,   298,   299,   300,     0,   301,   302,
-     303,   304,     0,   905,   306,   307,   308,   309,   310,     0,
-     311,   312,     0,     0,   313,   314,   315,     0,     0,   316,
-     317,   318,   319,   320,   908,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,     0,   332,   333,   909,   335,
-     336,   337,   338,   339,   340,     0,   341,   342,   343,   344,
-     345,   346,     0,   347,   348,   349,   350,   351,   352,   353,
-     354,     0,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,     0,   368,   369,   370,   371,
-     372,   373,   374,  2123,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,     0,   386,   387,   388,   389,   390,
-     912,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,     0,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   914,   417,     0,   418,
-     419,     0,   420,   421,   422,   423,   424,   425,   426,     0,
-     427,   428,     0,     0,   429,   430,   917,   432,   918,     0,
-     434,   435,   920,   437,   438,   439,   440,   441,     0,     0,
-     442,   443,   444,   445,   446,   921,     0,   448,   449,   450,
-     451,   452,   453,   454,     0,   455,   456,   457,   458,   459,
-     460,   461,     0,     0,   462,     0,     0,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,   482,   483,    93,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    36,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,     0,     0,     0,   105,   106,     0,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,   117,   118,     0,
-     119,   120,   121,   122,   123,   124,     0,   875,   125,   126,
-     127,   128,   129,     0,   130,   131,   132,   133,   878,     0,
-     879,     0,   136,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-     152,   153,   154,   155,   880,   881,   882,   883,   884,   885,
-     886,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,     0,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     185,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   891,     0,   205,     0,   206,   207,   208,   209,
-       0,   210,     0,   211,   212,     0,   213,   214,   215,   216,
-     217,   218,     0,   219,     0,   220,   221,   222,     0,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,     0,
-     251,     0,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,   264,   265,   266,     0,
-     267,   268,   269,   899,   900,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,     0,   301,   302,   303,
-     304,     0,   905,   306,   307,   308,   309,   310,     0,   311,
-     312,     0,     0,   313,   314,   315,     0,     0,   316,   317,
-     318,   319,   320,   908,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   909,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   350,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,   912,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   914,   417,     0,   418,   419,
-       0,   420,   421,   422,   423,   424,   425,   426,     0,   427,
-     428,     0,     0,   429,   430,   917,   432,   918,     0,   434,
-     435,   920,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,   921,     0,   448,   449,   450,   451,
-     452,   453,   454,     0,   455,   456,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   506,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  2798,    94,    95,    96,    97,    98,    99,
-     100,   101,   622,   102,   103,   104,     0,     0,     0,     0,
-       0,     0,     0,   105,   106,     0,   107,   108,   109,     0,
-     111,   112,   113,   114,   115,     0,   117,   118,     0,   119,
-     120,   121,   122,   123,   124,     0,     0,   125,   126,   127,
-     128,   129,     0,   130,   131,   132,   133,   134,     0,     0,
-       0,   136,   137,   138,   139,   140,   141,     0,   143,   144,
-     145,     0,   146,   147,   148,   149,   150,   151,     0,     0,
-     153,   154,   155,     0,     0,     0,     0,     0,     0,     0,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-       0,   171,     0,   172,   173,   174,   175,   176,   177,     0,
-     178,   179,   180,   181,   182,     0,     0,   183,   184,   185,
-     186,   187,     0,   188,   189,   190,     0,   191,   192,   193,
-       0,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,     0,   205,     0,   206,   207,   208,   209,     0,
-     210,     0,   211,     0,     0,     0,   214,   215,   508,     0,
-     218,     0,   219,     0,   220,   221,   222,     0,   223,   224,
-     225,   226,   227,   228,   229,     0,   231,   232,   233,   234,
-       0,   235,   236,   237,   238,   239,   240,     0,   241,     0,
-     243,   244,   245,   246,   247,   248,   249,   250,     0,   251,
-       0,   252,     0,     0,   255,     0,   257,   258,   259,   260,
-     261,   262,     0,     0,   263,     0,   265,     0,     0,   267,
-     268,   269,     0,     0,   270,   271,   272,   273,   274,   509,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,   287,   288,   289,   290,   291,   292,   293,   294,     0,
-     296,   297,   298,   299,   300,     0,   301,   302,     0,   304,
-       0,   305,   306,   307,   308,   309,   310,     0,   311,   312,
-       0,     0,   313,   314,   315,     0,     0,   316,   317,     0,
-     319,     0,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,     0,   332,   333,   334,   335,   336,   337,
-     338,   339,   340,     0,   341,   342,   343,   344,   345,   346,
-       0,   347,   348,   349,   350,   351,   352,   353,   354,     0,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,     0,   368,   369,     0,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,   385,    26,   386,   387,   388,   389,   390,     0,   392,
-     393,   394,   395,   396,     0,   398,   399,   400,   401,     0,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   511,   415,   416,   417,     0,   418,   419,    31,
-     420,     0,   422,   423,   424,   425,   426,     0,   623,   428,
-       0,     0,   624,   430,   431,   432,   433,     0,   434,   435,
-     436,   437,   438,   439,   440,   441,     0,     0,   442,   443,
-     444,   445,   446,     0,     0,   448,   449,   450,   451,   452,
-     584,   454,     0,   455,     0,   457,   458,   459,   460,   461,
-       0,     0,   462,     0,    34,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,   482,   483,   506,     0,    35,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    36,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,     0,
-       0,     0,   105,   106,     0,   107,   108,   109,     0,   111,
-     112,   113,   114,   115,     0,   117,   118,     0,   119,   120,
-     121,   122,   123,   124,     0,     0,   125,   126,   127,   128,
-     129,     0,   130,   131,   132,   133,   134,     0,     0,     0,
-     136,   137,   138,   139,   140,   141,     0,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,     0,   153,
-     154,   155,     0,     0,     0,     0,     0,     0,     0,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,     0,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   185,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
-     204,     0,   205,     0,   206,   207,   208,   209,     0,   210,
-       0,   211,     0,     0,     0,   214,   215,   508,     0,   218,
-       0,   219,     0,   220,   221,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,     0,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,     0,   243,
-     244,   245,   246,   247,   248,   249,   250,     0,   251,     0,
-     252,     0,     0,   255,     0,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,     0,   265,     0,     0,   267,   268,
-     269,     0,     0,   270,   271,   272,   273,   274,   509,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,     0,   296,
-     297,   298,   299,   300,     0,   301,   302,     0,   304,     0,
-     305,   306,   307,   308,   309,   310,     0,   311,   312,     0,
-       0,   313,   314,   315,     0,     0,   316,   317,     0,   319,
-       0,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   350,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,     0,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,    26,   386,   387,   388,   389,   390,     0,   392,   393,
-     394,   395,   396,     0,   398,   399,   400,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   511,   415,   416,   417,     0,   418,   419,    31,   420,
-       0,   422,   423,   424,   425,   426,     0,   427,   428,     0,
-       0,   429,   430,   431,   432,   433,     0,   434,   435,   436,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,     0,     0,   448,   449,   450,   451,   452,   584,
-     454,     0,   455,     0,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,    34,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,     0,   506,    35,   588,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    36,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,     0,
-       0,     0,   105,   106,     0,   107,   108,   109,     0,   111,
-     112,   113,   114,   115,     0,   117,   118,     0,   119,   120,
-     121,   122,   123,   124,     0,     0,   125,   126,   127,   128,
-     129,     0,   130,   131,   132,   133,   134,     0,     0,     0,
-     136,   137,   138,   139,   140,   141,     0,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,     0,   153,
-     154,   155,     0,     0,     0,     0,     0,     0,     0,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,     0,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   185,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
-     204,     0,   205,     0,   206,   207,   208,   209,     0,   210,
-       0,   211,     0,     0,     0,   214,   215,   508,     0,   218,
-       0,   219,     0,   220,   221,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,     0,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,     0,   243,
-     244,   245,   246,   247,   248,   249,   250,     0,   251,     0,
-     252,     0,     0,   255,     0,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,     0,   265,     0,     0,   267,   268,
-     269,     0,     0,   270,   271,   272,   273,   274,   509,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,     0,   296,
-     297,   298,   299,   300,     0,   301,   302,     0,   304,     0,
-     305,   306,   307,   308,   309,   310,     0,   311,   312,     0,
-       0,   313,   314,   315,     0,     0,   316,   317,     0,   319,
-       0,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   350,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,     0,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,     0,   392,   393,
-     394,   395,   396,     0,   398,   399,   400,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   511,   415,   416,   417,     0,   418,   419,     0,   420,
-       0,   422,   423,   424,   425,   426,     0,   427,   428,     0,
-       0,   429,   430,   431,   432,   433,     0,   434,   435,   436,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,     0,     0,   448,   449,   450,   451,   452,   453,
-     454,     0,   455,     0,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   506,     0,   588,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   972,    94,    95,    96,    97,    98,    99,   100,   101,
-       0,   102,   103,   104,     0,     0,     0,     0,     0,     0,
-       0,   105,   106,     0,   107,   108,   109,     0,   111,   112,
-     113,   114,   115,     0,   117,   118,     0,   119,   120,   121,
-     122,   123,   124,     0,     0,   125,   126,   127,   128,   129,
-       0,   130,   131,   132,   133,   134,     0,     0,     0,   136,
-     137,   138,   139,   140,   141,     0,   143,   144,   145,     0,
-     146,   147,   148,   149,   150,   151,     0,     0,   153,   154,
-     155,     0,     0,     0,     0,     0,     0,     0,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,     0,   171,
-       0,   172,   173,   174,   175,   176,   177,     0,   178,   179,
-     180,   181,   182,     0,     0,   183,   184,   185,   186,   187,
-       0,   188,   189,   190,     0,   191,   192,   193,     0,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-       0,   205,     0,   206,   207,   208,   209,     0,   210,     0,
-     211,     0,     0,     0,   214,   215,   508,     0,   218,     0,
-     219,     0,   220,   221,   222,     0,   223,   224,   225,   226,
-     227,   228,   229,     0,   231,   232,   233,   234,     0,   235,
-     236,   237,   238,   239,   240,     0,   241,     0,   243,   244,
-     245,   246,   247,   248,   249,   250,     0,   251,     0,   252,
-       0,     0,   255,     0,   257,   258,   259,   260,   261,   262,
-       0,     0,   263,     0,   265,     0,     0,   267,   268,   269,
-       0,     0,   270,   271,   272,   273,   274,   509,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   294,     0,   296,   297,
-     298,   299,   300,     0,   301,   302,     0,   304,     0,   305,
-     306,   307,   308,   309,   310,     0,   311,   312,     0,     0,
-     313,   314,   315,     0,     0,   316,   317,     0,   319,     0,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,     0,   332,   333,   334,   335,   336,   337,   338,   339,
-     340,     0,   341,   342,   343,   344,   345,   346,     0,   347,
-     348,   349,   350,   351,   352,   353,   354,     0,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,     0,   368,   369,     0,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-       0,   386,   387,   388,   389,   390,     0,   392,   393,   394,
-     395,   396,     0,   398,   399,   400,   401,     0,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     511,   415,   416,   417,     0,   418,   419,     0,   420,     0,
-     422,   423,   424,   425,   426,     0,   427,   428,     0,     0,
-     429,   430,   431,   432,   433,     0,   434,   435,   436,   437,
-     438,   439,   440,   441,     0,     0,   442,   443,   444,   445,
-     446,     0,     0,   448,   449,   450,   451,   452,   453,   454,
-       0,   455,     0,   457,   458,   459,   460,   461,     0,     0,
-     462,     0,     0,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,   482,   483,   506,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    2637,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,     0,     0,     0,
-     105,   106,     0,   107,   108,   109,     0,   111,   112,   113,
-     114,   115,     0,   117,   118,     0,   119,   120,   121,   122,
-     123,   124,     0,     0,   125,   126,   127,   128,   129,     0,
-     130,   131,   132,   133,   134,     0,     0,     0,   136,   137,
-     138,   139,   140,   141,     0,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,     0,   153,   154,   155,
-       0,     0,     0,     0,     0,     0,     0,   161,   162,   163,
-     164,   165,   166,   167,   168,   169,   170,     0,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   185,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   198,   199,   200,   201,   202,   203,   204,     0,
-     205,     0,   206,   207,   208,   209,     0,   210,     0,   211,
-       0,     0,     0,   214,   215,   508,     0,   218,     0,   219,
-       0,   220,   221,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,     0,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,     0,   243,   244,   245,
-     246,   247,   248,   249,   250,     0,   251,     0,   252,     0,
-       0,   255,     0,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,     0,   265,     0,     0,   267,   268,   269,     0,
-       0,   270,   271,   272,   273,   274,   509,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,     0,   296,   297,   298,
-     299,   300,     0,   301,   302,     0,   304,     0,   305,   306,
-     307,   308,   309,   310,     0,   311,   312,     0,     0,   313,
-     314,   315,     0,     0,   316,   317,     0,   319,     0,   321,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   334,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   350,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,     0,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,     0,   392,   393,   394,   395,
-     396,     0,   398,   399,   400,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   511,
-     415,   416,   417,     0,   418,   419,     0,   420,     0,   422,
-     423,   424,   425,   426,     0,   427,   428,     0,     0,   429,
-     430,   431,   432,   433,     0,   434,   435,   436,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-       0,     0,   448,   449,   450,   451,   452,   453,   454,     0,
-     455,     0,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   506,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1709,
-      94,    95,    96,    97,    98,    99,   100,   101,     0,   102,
-     103,   104,     0,     0,     0,     0,     0,     0,     0,   105,
-     106,     0,   107,   108,   109,     0,   111,   112,   113,   114,
-     115,     0,   117,   118,     0,   119,   120,   121,   122,   123,
-     124,     0,     0,   125,   126,   127,   128,   129,     0,   130,
-     131,   132,   133,   134,     0,     0,     0,   136,   137,   138,
-     139,   140,   141,     0,   143,   144,   145,     0,   146,   147,
-     148,   149,   150,   151,     0,     0,   153,   154,   155,     0,
-       0,     0,     0,     0,     0,     0,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,     0,   171,     0,   172,
-     173,   174,   175,   176,   177,     0,   178,   179,   180,   181,
-     182,     0,     0,   183,   184,   185,   186,   187,     0,   188,
-     189,   190,     0,   191,   192,   193,     0,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,     0,   205,
-       0,   206,   207,   208,   209,     0,   210,     0,   211,     0,
-       0,     0,   214,   215,   508,     0,   218,     0,   219,     0,
-     220,   221,   222,     0,   223,   224,   225,   226,   227,   228,
-     229,     0,   231,   232,   233,   234,     0,   235,   236,   237,
-     238,   239,   240,     0,   241,     0,   243,   244,   245,   246,
-     247,   248,   249,   250,     0,   251,     0,   252,     0,     0,
-     255,     0,   257,   258,   259,   260,   261,   262,     0,     0,
-     263,     0,   265,     0,     0,   267,   268,   269,     0,     0,
-     270,   271,   272,   273,   274,   509,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   294,     0,   296,   297,   298,   299,
-     300,     0,   301,   302,     0,   304,     0,   305,   306,   307,
-     308,   309,   310,     0,   311,   312,     0,     0,   313,   314,
-     315,     0,     0,   316,   317,     0,   319,     0,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,     0,
-     332,   333,   334,   335,   336,   337,   338,   339,   340,     0,
-     341,   342,   343,   344,   345,   346,     0,   347,   348,   349,
-     350,   351,   352,   353,   354,     0,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,     0,
-     368,   369,     0,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,     0,   386,
-     387,   388,   389,   390,     0,   392,   393,   394,   395,   396,
-       0,   398,   399,   400,   401,     0,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   511,   415,
-     416,   417,     0,   418,   419,     0,   420,     0,   422,   423,
-     424,   425,   426,     0,   427,   428,     0,     0,   429,   430,
-     431,   432,   433,     0,   434,   435,   436,   437,   438,   439,
-     440,   441,     0,     0,   442,   443,   444,   445,   446,     0,
-       0,   448,   449,   450,   451,   452,   453,   454,     0,   455,
-       0,   457,   458,   459,   460,   461,     0,     0,   462,     0,
-       0,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-     482,   483,   506,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1814,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,     0,     0,     0,   105,   106,
-       0,   107,   108,   109,     0,   111,   112,   113,   114,   115,
-       0,   117,   118,     0,   119,   120,   121,   122,   123,   124,
-       0,     0,   125,   126,   127,   128,   129,     0,   130,   131,
-     132,   133,   134,     0,     0,     0,   136,   137,   138,   139,
-     140,   141,     0,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,     0,   153,   154,   155,     0,     0,
-       0,     0,     0,     0,     0,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,     0,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   185,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   204,     0,   205,     0,
-     206,   207,   208,   209,     0,   210,     0,   211,     0,     0,
-       0,   214,   215,   508,     0,   218,     0,   219,     0,   220,
-     221,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-       0,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,     0,   243,   244,   245,   246,   247,
-     248,   249,   250,     0,   251,     0,   252,     0,     0,   255,
-       0,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-       0,   265,     0,     0,   267,   268,   269,     0,     0,   270,
-     271,   272,   273,   274,   509,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,     0,   296,   297,   298,   299,   300,
-       0,   301,   302,     0,   304,     0,   305,   306,   307,   308,
-     309,   310,     0,   311,   312,     0,     0,   313,   314,   315,
-       0,     0,   316,   317,     0,   319,     0,   321,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   350,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,     0,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,     0,   392,   393,   394,   395,   396,     0,
-     398,   399,   400,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   511,   415,   416,
-     417,     0,   418,   419,     0,   420,     0,   422,   423,   424,
-     425,   426,     0,   427,   428,     0,     0,   429,   430,   431,
-     432,   433,     0,   434,   435,   436,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,     0,     0,
-     448,   449,   450,   451,   452,   453,   454,     0,   455,     0,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,     0,     0,     0,     0,  2486,  1285,   556,     0,     0,
-    1669,   868,     0,     0,     0,     0,     0,  2609,  1670,  1671,
-    1672,  1673,    94,    95,    96,    97,    98,    99,   100,   101,
-    1111,   102,   103,   104,  1112,  1113,  1114,  1115,  1116,  1117,
-    1118,   105,   106,  1119,   107,   108,   109,  2487,   111,   112,
-     113,     0,   675,  2488,   677,   678,  1120,   119,   120,   121,
-     122,   123,   124,  1121,  1122,   125,   126,   679,   680,   129,
-    1123,   130,   131,   132,   133,     0,  1124,  2489,  1125,   136,
-     137,   138,   139,   140,   141,  2490,   143,   144,   145,  1126,
-     146,   147,   148,   149,   150,   151,  1127,  2491,   153,   154,
-     155,  2492,  2493,  2494,  2495,  1128,  1129,  2496,   161,   162,
-     163,   164,   165,   166,   167,   689,   690,   170,  1130,   171,
-    1131,   172,   173,   174,   175,   176,   177,  1132,   178,   179,
-     180,   181,   182,  1133,  1134,   183,   184,   691,   186,   187,
-    1135,   188,   189,   190,  1136,   191,   192,   193,  1137,   194,
-     195,   196,   197,     0,   199,   200,   201,   202,   203,     0,
-    1138,   205,  1139,   206,   207,   692,   209,  1140,   210,  1141,
-     211,  2497,  1142,  2498,   214,   215,  2499,  2500,   218,  1143,
-     219,  1144,     0,     0,   222,  1145,   223,   224,   225,   226,
-     227,   228,   229,  2501,   231,   232,   233,   234,  1146,   235,
-     236,   237,   238,   239,   240,  1147,   241,  2502,     0,   244,
-     245,   246,   247,   248,   699,   700,  1148,   701,  1149,   252,
-    2503,  2504,   255,  2505,   257,   258,   259,   260,   261,   262,
-    1150,  1151,   263,  2506,   265,  2507,  1152,   267,   268,   269,
-    1153,  1154,   270,   271,   272,   273,   274,  2508,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   708,  2509,   710,   297,
-     298,   299,  2510,  1155,   301,   302,  2511,   304,  1156,     0,
-     306,   712,   308,   309,   310,  1157,   311,   312,  1158,  1159,
-    2512,   314,   315,  1160,  1161,   316,     0,  2513,   319,  2514,
-       0,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,  1162,   332,   333,     0,   335,   336,     0,   338,   339,
-     340,  1163,   341,   342,   343,   344,   345,   346,  1164,   347,
-     348,   349,   715,   351,   352,   353,   354,  1165,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,  1166,   368,   369,  2515,   371,   372,   373,   717,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-    1167,   386,   387,   388,   389,   390,  2516,   392,  2517,   394,
-     395,   396,  2518,   398,   399,   721,   401,  1168,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-    2519,   415,     0,   417,  1169,   418,   419,  1170,   420,  2520,
-     422,   423,   424,   425,   426,  1171,   724,   725,  1172,  1173,
-     429,   430,     0,   432,     0,  1174,   434,   435,  2521,   437,
-     438,   439,   440,   441,  1175,  1176,   442,   443,   444,   445,
-     446,  2522,  1177,   448,   449,   450,   451,   452,     0,   728,
-    1179,   455,  2523,   457,   458,   459,   460,   461,  1180,  1181,
-     462,  1182,  1183,   463,   464,   465,   466,   467,   468,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     480,   481,   482,   483,     0,   506,     0,  1674,  1675,  1676,
-    1669,  2524,  2525,  1679,  1680,  1681,  1682,     0,  1670,  1671,
-    1672,  1673,    94,    95,    96,    97,    98,    99,   100,   101,
-       0,   102,   103,   104,     0,     0,     0,     0,     0,     0,
-       0,   105,   106,     0,   107,   108,   109,     0,   111,   112,
-     113,   114,   115,     0,   117,   118,     0,   119,   120,   121,
-     122,   123,   124,     0,     0,   125,   126,   127,   128,   129,
-       0,   130,   131,   132,   133,   134,     0,     0,     0,   136,
-     137,   138,   139,   140,   141,     0,   143,   144,   145,     0,
-     146,   147,   148,   149,   150,   151,     0,     0,   153,   154,
-     155,     0,     0,     0,     0,     0,     0,     0,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,     0,   171,
-       0,   172,   173,   174,   175,   176,   177,     0,   178,   179,
-     180,   181,   182,     0,     0,   183,   184,   185,   186,   187,
-       0,   188,   189,   190,     0,   191,   192,   193,     0,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-       0,   205,     0,   206,   207,   208,   209,     0,   210,     0,
-     211,     0,     0,     0,   214,   215,   508,     0,   218,     0,
-     219,     0,   220,   221,   222,     0,   223,   224,   225,   226,
-     227,   228,   229,     0,   231,   232,   233,   234,     0,   235,
-     236,   237,   238,   239,   240,     0,   241,     0,   243,   244,
-     245,   246,   247,   248,   249,   250,     0,   251,     0,   252,
-       0,     0,   255,     0,   257,   258,   259,   260,   261,   262,
-       0,     0,   263,     0,   265,     0,     0,   267,   268,   269,
-       0,     0,   270,   271,   272,   273,   274,   509,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   294,     0,   296,   297,
-     298,   299,   300,     0,   301,   302,     0,   304,     0,   305,
-     306,   307,   308,   309,   310,     0,   311,   312,     0,     0,
-     313,   314,   315,     0,     0,   316,   317,     0,   319,     0,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,     0,   332,   333,   334,   335,   336,   337,   338,   339,
-     340,     0,   341,   342,   343,   344,   345,   346,     0,   347,
-     348,   349,   350,   351,   352,   353,   354,     0,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,     0,   368,   369,     0,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-       0,   386,   387,   388,   389,   390,     0,   392,   393,   394,
-     395,   396,     0,   398,   399,   400,   401,     0,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     511,   415,   416,   417,     0,   418,   419,     0,   420,     0,
-     422,   423,   424,   425,   426,     0,   427,   428,     0,     0,
-     429,   430,   431,   432,   433,     0,   434,   435,   436,   437,
-     438,   439,   440,   441,     0,     0,   442,   443,   444,   445,
-     446,     0,     0,   448,   449,   450,   451,   452,   453,   454,
-       0,   455,     0,   457,   458,   459,   460,   461,     0,     0,
-     462,     0,     0,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,   482,   483,     0,     0,     0,  1674,  1675,  1676,
-       0,  1677,  1678,  1679,  1680,  1681,  1682,  1362,     0,     0,
-    1363,     0,     0,     0,  1364,  1365,  1366,  1367,  1368,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1369,     0,     0,  1362,     0,     0,  1363,
-       0,  1371,     0,  1364,  1365,  1366,  1367,  1368,  1372,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1369,     0,     0,     0,     0,     0,     0,     0,
-    1371,  1362,     0,  1373,  1363,     0,     0,  1372,  1364,  1365,
-    1366,  1367,  1368,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1369,     0,     0,
-    1362,     0,  1373,  1363,     0,  1371,     0,  1364,  1365,  1366,
-    1367,  1368,  1372,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1369,     0,     0,     0,
-       0,     0,     0,     0,  1371,     0,     0,  1373,     0,     0,
-       0,  1372,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1373,     0,     0,     0,
-       0,     0,     0,     0,  1374,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1375,     0,     0,     0,     0,  1376,     0,     0,     0,     0,
-       0,     0,     0,  1374,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1377,  1378,  1375,
-       0,     0,     0,     0,  1376,     0,     0,     0,     0,     0,
-       0,     0,  1379,     0,     0,     0,     0,     0,  1374,     0,
-       0,     0,     0,     0,     0,     0,  1377,  1378,     0,     0,
-       0,     0,     0,     0,  1375,     0,     0,     0,     0,  1376,
-       0,  1379,     0,     0,     0,     0,     0,  1374,     0,     0,
-    1380,     0,     0,  1381,     0,     0,     0,     0,     0,     0,
-       0,  1377,  1378,  1375,     0,     0,     0,  1382,  1376,     0,
-    1383,     0,     0,     0,     0,     0,  1379,     0,     0,  1380,
-       0,     0,  1381,     0,     0,     0,     0,     0,     0,     0,
-    1377,  1378,     0,     0,     0,     0,  1382,     0,     0,  1383,
-       0,     0,     0,     0,     0,  1379,     0,     0,     0,     0,
-       0,     0,     0,     0,  1380,     0,     0,  1381,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1382,     0,     0,  1383,     0,     0,     0,     0,     0,
-       0,     0,     0,  1380,     0,     0,  1381,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1384,
-    1382,     0,     0,  1383,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1384,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1384,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1384,     0,     0,     0,     0,     0,     0,     0,
-       0,  1385,     0,     0,  1386,  1387,  1388,     0,  1389,  1390,
-    1391,  1392,  1393,  1394,     0,     0,     0,     0,  2918,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1385,     0,     0,  1386,  1387,  1388,     0,  1389,  1390,  1391,
-    1392,  1393,  1394,     0,     0,     0,     0,  2966,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1385,     0,     0,  1386,  1387,
-    1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,     0,     0,
-       0,     0,  2979,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1110,  1385,     0,     0,  1386,  1387,  1388,
-       0,  1389,  1390,  1391,  1392,  1393,  1394,     0,     0,  1545,
-      94,    95,    96,    97,    98,    99,   100,   101,  1111,   102,
-     103,   104,  1112,  1113,  1114,  1115,  1116,  1117,  1118,   105,
-     106,  1119,   107,   108,   109,   762,   111,   112,   113,   763,
-     764,   765,   766,   767,  1120,   119,   120,   121,   122,   123,
-     124,  1121,  1122,   125,   126,   768,   769,   129,  1123,   130,
-     131,   132,   133,   770,  1124,   771,  1125,   136,   137,   138,
-     139,   140,   141,   772,   143,   144,   145,  1126,   146,   147,
-     148,   149,   150,   151,  1127,   773,   153,   154,   155,   774,
-     775,   776,   777,  1128,  1129,   778,   161,   162,   163,   164,
-     165,   166,   167,   779,   780,   170,  1130,   171,  1131,   172,
-     173,   174,   175,   176,   177,  1132,   178,   179,   180,   181,
-     182,  1133,  1134,   183,   184,   185,   186,   187,  1135,   188,
-     189,   190,  1136,   191,   192,   193,  1137,   194,   195,   196,
-     197,   781,   199,   200,   201,   202,   203,   782,  1138,   205,
-    1139,   206,   207,   783,   209,  1140,   210,  1141,   211,   784,
-    1142,   785,   214,   215,   786,   787,   218,  1143,   219,  1144,
-     788,   789,   222,  1145,   223,   224,   225,   226,   227,   228,
-     229,   790,   231,   232,   233,   234,  1146,   235,   236,   237,
-     238,   239,   240,  1147,   241,   791,   792,   244,   245,   246,
-     247,   248,   793,   794,  1148,   795,  1149,   252,   796,   797,
-     255,   798,   257,   258,   259,   260,   261,   262,  1150,  1151,
-     263,   799,   265,   800,  1152,   267,   268,   269,  1153,  1154,
-     270,   271,   272,   273,   274,   801,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   802,   803,   804,   297,   298,   299,
-     805,  1155,   301,   302,   806,   304,  1156,   807,   306,   808,
-     308,   309,   310,  1157,   311,   312,  1158,  1159,   313,   314,
-     315,  1160,  1161,   316,   809,   810,   319,   811,   812,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,  1162,
-     332,   333,   813,   335,   336,   814,   338,   339,   340,  1163,
-     341,   342,   343,   344,   345,   346,  1164,   347,   348,   349,
-     815,   351,   352,   353,   354,  1165,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,  1166,
-     368,   369,   816,   371,   372,   373,   817,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,  1167,   386,
-     387,   388,   389,   390,   818,   392,   819,   394,   395,   396,
-     820,   398,   399,   821,   401,  1168,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   822,   415,
-     823,   417,  1169,   418,   419,  1170,   420,   824,   422,   423,
-     424,   425,   426,  1171,   825,   826,  1172,  1173,   429,   430,
-     827,   432,   828,  1174,   434,   435,   829,   437,   438,   439,
-     440,   441,  1175,  1176,   442,   443,   444,   445,   446,   830,
-    1177,   448,   449,   450,   451,   452,  1178,   832,  1179,   455,
-     833,   457,   458,   459,   460,   461,  1180,  1181,   462,  1182,
-    1183,   463,   464,   465,   466,   467,   468,   834,   835,   836,
-     837,   838,   839,   840,   841,   842,   843,   844,   480,   481,
-     482,   483,   506,     0,     0,     0,     0,     0,     0,     0,
-       0,  1793,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,     0,     0,     0,   105,   106,
-       0,   107,   108,   109,     0,   111,   112,   113,   114,   115,
-       0,   117,   118,     0,   119,   120,   121,   122,   123,   124,
-       0,     0,   125,   126,   127,   128,   129,     0,   130,   131,
-     132,   133,   134,     0,     0,     0,   136,   137,   138,   139,
-     140,   141,     0,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,     0,   153,   154,   155,     0,     0,
-       0,     0,     0,     0,     0,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,     0,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   185,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   204,     0,   205,     0,
-     206,   207,   208,   209,     0,   210,     0,   211,     0,     0,
-       0,   214,   215,   508,     0,   218,     0,   219,     0,   220,
-     221,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-       0,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,     0,   243,   244,   245,   246,   247,
-     248,   249,   250,     0,   251,     0,   252,     0,     0,   255,
-       0,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-       0,   265,     0,     0,   267,   268,   269,     0,     0,   270,
-     271,   272,   273,   274,   509,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,     0,   296,   297,   298,   299,   300,
-       0,   301,   302,     0,   304,     0,   305,   306,   307,   308,
-     309,   310,     0,   311,   312,     0,     0,   313,   314,   315,
-       0,     0,   316,   317,     0,   319,     0,   321,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   350,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,     0,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,     0,   392,   393,   394,   395,   396,     0,
-     398,   399,   400,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   511,   415,   416,
-     417,     0,   418,   419,     0,   420,     0,   422,   423,   424,
-     425,   426,     0,   427,   428,     0,     0,   429,   430,   431,
-     432,   433,     0,   434,   435,   436,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,     0,     0,
-     448,   449,   450,   451,   452,   453,   454,     0,   455,     0,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   761,  1285,   556,     0,     0,     0,   868,     0,     0,
-    2294,     0,     0,     0,     0,     0,     0,     0,    94,    95,
-      96,    97,    98,    99,   100,   101,     0,   102,   103,   104,
-       0,     0,     0,     0,     0,     0,     0,   105,   106,     0,
-     107,   108,   109,   762,   111,   112,   113,   763,   764,   765,
-     766,   767,     0,   119,   120,   121,   122,   123,   124,     0,
-       0,   125,   126,   768,   769,   129,     0,   130,   131,   132,
-     133,   770,     0,   771,     0,   136,   137,   138,   139,   140,
-     141,   772,   143,   144,   145,     0,   146,   147,   148,   149,
-     150,   151,     0,   773,   153,   154,   155,   774,   775,   776,
-     777,     0,     0,   778,   161,   162,   163,   164,   165,   166,
-     167,   779,   780,   170,  1421,   171,     0,   172,   173,   174,
-     175,   176,   177,     0,   178,   179,   180,   181,   182,     0,
-       0,   183,   184,   185,   186,   187,     0,   188,   189,   190,
-       0,   191,   192,   193,     0,   194,   195,   196,   197,   781,
-     199,   200,   201,   202,   203,   782,  1286,   205,     0,   206,
-     207,   783,   209,     0,   210,     0,   211,   784,     0,   785,
-     214,   215,   786,   787,   218,     0,   219,     0,   788,   789,
-     222,     0,   223,   224,   225,   226,   227,   228,   229,   790,
-     231,   232,   233,   234,     0,   235,   236,   237,   238,   239,
-     240,     0,   241,   791,   792,   244,   245,   246,   247,   248,
-     793,   794,     0,   795,     0,   252,   796,   797,   255,   798,
-     257,   258,   259,   260,   261,   262,     0,     0,   263,   799,
-     265,   800,     0,   267,   268,   269,     0,     0,   270,   271,
-     272,   273,   274,   801,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   802,   803,   804,   297,   298,   299,   805,     0,
-     301,   302,   806,   304,     0,   807,   306,   808,   308,   309,
-     310,     0,   311,   312,  1287,     0,   313,   314,   315,     0,
-       0,   316,   809,   810,   319,   811,   812,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,     0,   332,   333,
-     813,   335,   336,   814,   338,   339,   340,     0,   341,   342,
-     343,   344,   345,   346,     0,   347,   348,   349,   815,   351,
-     352,   353,   354,     0,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,     0,   368,   369,
-     816,   371,   372,   373,   817,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,     0,   386,   387,   388,
-     389,   390,   818,   392,   819,   394,   395,   396,   820,   398,
-     399,   821,   401,     0,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   822,   415,   823,   417,
-       0,   418,   419,     0,   420,   824,   422,   423,   424,   425,
-     426,     0,   825,   826,     0,     0,   429,   430,   827,   432,
-     828,  1288,   434,   435,   829,   437,   438,   439,   440,   441,
-       0,     0,   442,   443,   444,   445,   446,   830,     0,   448,
-     449,   450,   451,   452,  1178,   832,     0,   455,   833,   457,
-     458,   459,   460,   461,     0,     0,   462,     0,     0,   463,
-     464,   465,   466,   467,   468,   834,   835,   836,   837,   838,
-     839,   840,   841,   842,   843,   844,   480,   481,   482,   483,
-     761,  1285,   556,     0,     0,     0,   868,  1289,  1290,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,   762,   111,   112,   113,   763,   764,   765,   766,
-     767,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   768,   769,   129,     0,   130,   131,   132,   133,
-     770,     0,   771,     0,   136,   137,   138,   139,   140,   141,
-     772,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   773,   153,   154,   155,   774,   775,   776,   777,
-       0,     0,   778,   161,   162,   163,   164,   165,   166,   167,
-     779,   780,   170,  1423,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   781,   199,
-     200,   201,   202,   203,   782,  1286,   205,     0,   206,   207,
-     783,   209,     0,   210,     0,   211,   784,     0,   785,   214,
-     215,   786,   787,   218,     0,   219,     0,   788,   789,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   790,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   791,   792,   244,   245,   246,   247,   248,   793,
-     794,     0,   795,     0,   252,   796,   797,   255,   798,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   799,   265,
-     800,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,   801,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   802,   803,   804,   297,   298,   299,   805,     0,   301,
-     302,   806,   304,     0,   807,   306,   808,   308,   309,   310,
-       0,   311,   312,  1287,     0,   313,   314,   315,     0,     0,
-     316,   809,   810,   319,   811,   812,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   813,
-     335,   336,   814,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   815,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   816,
-     371,   372,   373,   817,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,   818,   392,   819,   394,   395,   396,   820,   398,   399,
-     821,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   822,   415,   823,   417,     0,
-     418,   419,     0,   420,   824,   422,   423,   424,   425,   426,
-       0,   825,   826,     0,     0,   429,   430,   827,   432,   828,
-    1288,   434,   435,   829,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   830,     0,   448,   449,
-     450,   451,   452,  1178,   832,     0,   455,   833,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   834,   835,   836,   837,   838,   839,
-     840,   841,   842,   843,   844,   480,   481,   482,   483,   761,
-    1285,   556,     0,     0,     0,   868,  1289,  1290,     0,     0,
-       0,     0,     0,     0,     0,     0,    94,    95,    96,    97,
-      98,    99,   100,   101,     0,   102,   103,   104,     0,     0,
-       0,     0,     0,     0,     0,   105,   106,     0,   107,   108,
-     109,   762,   111,   112,   113,   763,   764,   765,   766,   767,
-       0,   119,   120,   121,   122,   123,   124,     0,     0,   125,
-     126,   768,   769,   129,     0,   130,   131,   132,   133,   770,
-       0,   771,     0,   136,   137,   138,   139,   140,   141,   772,
-     143,   144,   145,     0,   146,   147,   148,   149,   150,   151,
-       0,   773,   153,   154,   155,   774,   775,   776,   777,     0,
-       0,   778,   161,   162,   163,   164,   165,   166,   167,   779,
-     780,   170,     0,   171,     0,   172,   173,   174,   175,   176,
-     177,     0,   178,   179,   180,   181,   182,     0,     0,   183,
-     184,   185,   186,   187,     0,   188,   189,   190,     0,   191,
-     192,   193,     0,   194,   195,   196,   197,   781,   199,   200,
-     201,   202,   203,   782,  1286,   205,     0,   206,   207,   783,
-     209,     0,   210,     0,   211,   784,     0,   785,   214,   215,
-     786,   787,   218,     0,   219,     0,   788,   789,   222,     0,
-     223,   224,   225,   226,   227,   228,   229,   790,   231,   232,
-     233,   234,     0,   235,   236,   237,   238,   239,   240,     0,
-     241,   791,   792,   244,   245,   246,   247,   248,   793,   794,
-       0,   795,     0,   252,   796,   797,   255,   798,   257,   258,
-     259,   260,   261,   262,     0,     0,   263,   799,   265,   800,
-       0,   267,   268,   269,     0,     0,   270,   271,   272,   273,
-     274,   801,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     802,   803,   804,   297,   298,   299,   805,     0,   301,   302,
-     806,   304,     0,   807,   306,   808,   308,   309,   310,     0,
-     311,   312,  1287,     0,   313,   314,   315,     0,     0,   316,
-     809,   810,   319,   811,   812,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,     0,   332,   333,   813,   335,
-     336,   814,   338,   339,   340,     0,   341,   342,   343,   344,
-     345,   346,     0,   347,   348,   349,   815,   351,   352,   353,
-     354,     0,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,     0,   368,   369,   816,   371,
-     372,   373,   817,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,     0,   386,   387,   388,   389,   390,
-     818,   392,   819,   394,   395,   396,   820,   398,   399,   821,
-     401,     0,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   822,   415,   823,   417,     0,   418,
-     419,     0,   420,   824,   422,   423,   424,   425,   426,     0,
-     825,   826,     0,     0,   429,   430,   827,   432,   828,  1288,
-     434,   435,   829,   437,   438,   439,   440,   441,     0,     0,
-     442,   443,   444,   445,   446,   830,     0,   448,   449,   450,
-     451,   452,  1178,   832,     0,   455,   833,   457,   458,   459,
-     460,   461,     0,     0,   462,     0,     0,   463,   464,   465,
-     466,   467,   468,   834,   835,   836,   837,   838,   839,   840,
-     841,   842,   843,   844,   480,   481,   482,   483,     0,     0,
-    1362,     0,     0,  1363,     0,  1289,  1290,  1364,  1365,  1366,
-    1367,  1368,     0,  1362,     0,     0,  1363,     0,     0,     0,
-    1364,  1365,  1366,  1367,  1368,     0,  1369,     0,     0,     0,
-    1820,     0,     0,     0,  1371,     0,     0,     0,     0,  1369,
-       0,  1372,     0,     0,     0,     0,     0,  1371,  1362,     0,
-       0,  1363,     0,     0,  1372,  1364,  1365,  1366,  1367,  1368,
-       0,  1362,     0,     0,  1363,     0,  1373,     0,  1364,  1365,
-    1366,  1367,  1368,     0,  1369,     0,     0,     0,     0,  1373,
-       0,     0,  1371,     0,     0,     0,     0,  1369,     0,  1372,
-    2021,     0,     0,     0,     0,  1371,     0,     0,     0,     0,
-       0,     0,  1372,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1373,     0,     0,  1821,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1373,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1362,     0,     0,  1363,     0,     0,     0,  1364,  1365,
-    1366,  1367,  1368,     0,     0,     0,     0,  1374,     0,     0,
-    2060,     0,     0,     0,     0,  2061,     0,  1369,     0,     0,
-    1374,     0,     0,  1375,     0,  1371,     0,     0,  1376,     0,
-       0,     0,  1372,     0,     0,     0,  1375,     0,     0,     0,
-       0,  1376,     0,     0,  3066,     0,     0,     0,     0,     0,
-    1377,  1378,     0,     0,     0,  1374,     0,  1373,     0,     0,
-       0,     0,     0,  1377,  1378,  1379,     0,     0,  1374,     0,
-       0,  1375,     0,     0,     0,     0,  1376,     0,  1379,     0,
-       0,     0,     0,     0,  1375,     0,     0,     0,     0,  1376,
-       0,     0,     0,     0,     0,     0,     0,     0,  1377,  1378,
-       0,     0,     0,  1380,     0,     0,  1381,     0,     0,     0,
-       0,  1377,  1378,  1379,     0,     0,  1380,     0,     0,  1381,
-    1382,     0,     0,  1383,     0,     0,  1379,     0,     0,     0,
-       0,     0,     0,  1382,     0,     0,  1383,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1380,     0,     0,  1381,     0,     0,     0,  1374,     0,
-       0,     0,     0,     0,  1380,     0,     0,  1381,  1382,     0,
-       0,  1383,     0,     0,  1375,     0,     0,     0,     0,  1376,
-       0,  1382,     0,     0,  1383,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  3067,     0,     0,     0,     0,     0,
-       0,  1377,  1378,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1384,     0,     0,     0,  1379,     0,     0,     0,
-       0,  1362,     0,     0,  1363,  1384,     0,     0,  1364,  1365,
-    1366,  1367,  1368,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1369,     0,     0,
-    2066,     0,     0,     0,  1380,  1371,     0,  1381,     0,     0,
-    1384,     0,  1372,     0,     0,     0,     0,     0,     0,     0,
-       0,  1382,  1825,  1384,  1383,  1362,     0,     0,  1363,     0,
-       0,     0,  1364,  1365,  1366,  1367,  1368,  1373,     0,     0,
-       0,     0,  2033,     0,     0,     0,     0,     0,     0,     0,
-       0,  1369,     0,     0,     0,     0,     0,     0,     0,  1371,
-       0,     0,     0,     0,  1385,     0,  1372,  1386,  1387,  1388,
-       0,  1389,  1390,  1391,  1392,  1393,  1394,  1385,     0,     0,
-    1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,
-       0,  1373,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1385,  1384,     0,  1386,  1387,  1388,     0,  1389,
-    1390,  1391,  1392,  1393,  1394,  1385,     0,     0,  1386,  1387,
-    1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,  1374,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  1375,     0,     0,     0,     0,  1376,
-       0,     0,     0,     0,  1362,     0,     0,  1363,     0,     0,
-       0,  1364,  1365,  1366,  1367,  1368,     0,     0,     0,     0,
-       0,  1377,  1378,     0,     0,     0,     0,  2071,     0,     0,
-    1369,     0,  1374,  2073,     0,     0,  1379,     0,  1371,     0,
-       0,     0,     0,     0,     0,  1372,     0,     0,  1375,     0,
-       0,     0,     0,  1376,     0,  1385,     0,     0,  1386,  1387,
-    1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,     0,     0,
-    1373,     0,     0,     0,  1380,  1377,  1378,  1381,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1362,
-    1379,  1382,  1363,     0,  1383,     0,  1364,  1365,  1366,  1367,
-    1368,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1369,     0,     0,     0,     0,
-       0,     0,     0,  1371,     0,     0,     0,     0,  1380,     0,
-    1372,  1381,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1362,     0,  1382,  1363,     0,  1383,     0,
-    1364,  1365,  1366,  1367,  1368,  1373,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  1369,
-       0,  1374,  2343,     0,     0,     0,     0,  1371,     0,     0,
-       0,     0,     0,  1384,  1372,     0,     0,  1375,     0,     0,
-       0,     0,  1376,     0,     0,     0,     0,  1362,     0,     0,
-    1363,     0,     0,     0,  1364,  1365,  1366,  1367,  1368,  1373,
-       0,     0,     0,     0,  1377,  1378,     0,     0,     0,     0,
-       0,     0,     0,  1369,     0,     0,     0,     0,     0,  1379,
-       0,  1371,     0,     0,     0,     0,     0,  1384,  1372,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1374,     0,     0,     0,
-       0,     0,     0,  1373,     0,     0,     0,  1380,     0,     0,
-    1381,     0,  1375,     0,     0,     0,     0,  1376,     0,     0,
-       0,     0,     0,     0,  1382,  1385,     0,  1383,  1386,  1387,
-    1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,     0,  1377,
-    1378,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1374,     0,     0,     0,  1379,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1375,     0,     0,     0,
-       0,  1376,     0,     0,     0,     0,     0,     0,     0,  1385,
-       0,     0,  1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,
-    1393,  1394,  1380,  1377,  1378,  1381,     0,     0,     0,     0,
-       0,     0,     0,     0,  1374,     0,     0,     0,  1379,  1382,
-       0,     0,  1383,     0,     0,     0,  1384,     0,     0,     0,
-    1375,     0,     0,     0,     0,  1376,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  1380,  1377,  1378,  1381,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1379,  1382,     0,  1362,  1383,     0,  1363,     0,
-       0,     0,  1364,  1365,  1366,  1367,  1368,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1369,     0,     0,     0,     0,     0,     0,     0,  1371,
-    1380,  1384,     0,  1381,     0,     0,  1372,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1382,  1385,     0,
-    1383,  1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,  1393,
-    1394,  1373,     0,     0,  2298,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1384,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1385,     0,     0,  1386,  1387,  1388,  1384,
-    1389,  1390,  1391,  1392,  1393,  1394,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  1374,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1375,     0,
-       0,     0,     0,  1376,     0,     0,     0,  1385,     0,     0,
-    1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,  1393,  1394,
-       0,     0,     0,     0,     0,  1377,  1378,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1379,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  1385,     0,     0,  1386,  1387,  1388,     0,  1389,  1390,
-    1391,  1392,  1393,  1394,     0,     0,     0,     0,  1380,     0,
-       0,  1381,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1382,     0,     0,  1383,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1384,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1110,     0,  1730,     0,  1385,
-       0,     0,  1386,  1387,  1388,     0,  1389,  1390,  1391,  1392,
-    1840,  1394,    94,    95,    96,    97,    98,    99,   100,   101,
-    1111,   102,   103,   104,  1112,  1113,  1114,  1115,  1116,  1117,
-    1118,   105,   106,  1119,   107,   108,   109,   762,   111,   112,
-     113,   763,   764,   765,   766,   767,  1120,   119,   120,   121,
-     122,   123,   124,  1121,  1122,   125,   126,   768,   769,   129,
-    1123,   130,   131,   132,   133,   770,  1124,   771,  1125,   136,
-     137,   138,   139,   140,   141,   772,   143,   144,   145,  1126,
-     146,   147,   148,   149,   150,   151,  1127,   773,   153,   154,
-     155,   774,   775,   776,   777,  1128,  1129,   778,   161,   162,
-     163,   164,   165,   166,   167,   779,   780,   170,  1130,   171,
-    1131,   172,   173,   174,   175,   176,   177,  1132,   178,   179,
-     180,   181,   182,  1133,  1134,   183,   184,   185,   186,   187,
-    1135,   188,   189,   190,  1136,   191,   192,   193,  1137,   194,
-     195,   196,   197,   781,   199,   200,   201,   202,   203,   782,
-    1138,   205,  1139,   206,   207,   783,   209,  1140,   210,  1141,
-     211,   784,  1142,   785,   214,   215,   786,   787,   218,  1143,
-     219,  1144,   788,   789,   222,  1145,   223,   224,   225,   226,
-     227,   228,   229,   790,   231,   232,   233,   234,  1146,   235,
-     236,   237,   238,   239,   240,  1147,   241,   791,   792,   244,
-     245,   246,   247,   248,   793,   794,  1148,   795,  1149,   252,
-     796,   797,   255,   798,   257,   258,   259,   260,   261,   262,
-    1150,  1151,   263,   799,   265,   800,  1152,   267,   268,   269,
-    1153,  1154,   270,   271,   272,   273,   274,   801,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   802,   803,   804,   297,
-     298,   299,   805,  1155,   301,   302,   806,   304,  1156,   807,
-     306,   808,   308,   309,   310,  1157,   311,   312,  1158,  1159,
-     313,   314,   315,  1160,  1161,   316,   809,   810,   319,   811,
-     812,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,  1162,   332,   333,   813,   335,   336,   814,   338,   339,
-     340,  1163,   341,   342,   343,   344,   345,   346,  1164,   347,
-     348,   349,   815,   351,   352,   353,   354,  1165,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,  1166,   368,   369,   816,   371,   372,   373,   817,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-    1167,   386,   387,   388,   389,   390,   818,   392,   819,   394,
-     395,   396,   820,   398,   399,   821,   401,  1168,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     822,   415,   823,   417,  1169,   418,   419,  1170,   420,   824,
-     422,   423,   424,   425,   426,  1171,   825,   826,  1172,  1173,
-     429,   430,   827,   432,   828,  1174,   434,   435,   829,   437,
-     438,   439,   440,   441,  1175,  1176,   442,   443,   444,   445,
-     446,   830,  1177,   448,   449,   450,   451,   452,  1178,   832,
-    1179,   455,   833,   457,   458,   459,   460,   461,  1180,  1181,
-     462,  1182,  1183,   463,   464,   465,   466,   467,   468,   834,
-     835,   836,   837,   838,   839,   840,   841,   842,   843,   844,
-     480,   481,   482,   483,  1110,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,  1111,
-     102,   103,   104,  1112,  1113,  1114,  1115,  1116,  1117,  1118,
-     105,   106,  1119,   107,   108,   109,   762,   111,   112,   113,
-     763,   764,   765,   766,   767,  1120,   119,   120,   121,   122,
-     123,   124,  1121,  1122,   125,   126,   768,   769,   129,  1123,
-     130,   131,   132,   133,   770,  1124,   771,  1125,   136,   137,
-     138,   139,   140,   141,   772,   143,   144,   145,  1126,   146,
-     147,   148,   149,   150,   151,  1127,   773,   153,   154,   155,
-     774,   775,   776,   777,  1128,  1129,   778,   161,   162,   163,
-     164,   165,   166,   167,   779,   780,   170,  1130,   171,  1131,
-     172,   173,   174,   175,   176,   177,  1132,   178,   179,   180,
-     181,   182,  1133,  1134,   183,   184,   185,   186,   187,  1135,
-     188,   189,   190,  1136,   191,   192,   193,  1137,   194,   195,
-     196,   197,   781,   199,   200,   201,   202,   203,   782,  1138,
-     205,  1139,   206,   207,   783,   209,  1140,   210,  1141,   211,
-     784,  1142,   785,   214,   215,   786,   787,   218,  1143,   219,
-    1144,   788,   789,   222,  1145,   223,   224,   225,   226,   227,
-     228,   229,   790,   231,   232,   233,   234,  1146,   235,   236,
-     237,   238,   239,   240,  1147,   241,   791,   792,   244,   245,
-     246,   247,   248,   793,   794,  1148,   795,  1149,   252,   796,
-     797,   255,   798,   257,   258,   259,   260,   261,   262,  1150,
-    1151,   263,   799,   265,   800,  1152,   267,   268,   269,  1153,
-    1154,   270,   271,   272,   273,   274,   801,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   802,   803,   804,   297,   298,
-     299,   805,  1155,   301,   302,   806,   304,  1156,   807,   306,
-     808,   308,   309,   310,  1157,   311,   312,  1158,  1159,   313,
-     314,   315,  1160,  1161,   316,   809,   810,   319,   811,   812,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-    1162,   332,   333,   813,   335,   336,   814,   338,   339,   340,
-    1163,   341,   342,   343,   344,   345,   346,  1164,   347,   348,
-     349,   815,   351,   352,   353,   354,  1165,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-    1166,   368,   369,   816,   371,   372,   373,   817,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,  1167,
-     386,   387,   388,   389,   390,   818,   392,   819,   394,   395,
-     396,   820,   398,   399,   821,   401,  1168,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   822,
-     415,   823,   417,  1169,   418,   419,  1170,   420,   824,   422,
-     423,   424,   425,   426,  1171,   825,   826,  1172,  1173,   429,
-     430,   827,   432,   828,  1174,   434,   435,   829,   437,   438,
-     439,   440,   441,  1175,  1176,   442,   443,   444,   445,   446,
-     830,  1177,   448,   449,   450,   451,   452,  1178,   832,  1179,
-     455,   833,   457,   458,   459,   460,   461,  1180,  1181,   462,
-    1182,  1183,   463,   464,   465,   466,   467,   468,   834,   835,
-     836,   837,   838,   839,   840,   841,   842,   843,   844,   480,
-     481,   482,   483,  1110,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      94,    95,    96,    97,  1876,    99,   100,   101,  1111,   102,
-     103,   104,  1112,  1113,  1114,  1115,  1116,  1117,  1118,   105,
-     106,  1119,   107,   108,   109,   762,   111,   112,   113,   763,
-     764,   765,   766,   767,  1120,   119,   120,   121,   122,   123,
-     124,  1121,  1122,   125,   126,   768,   769,   129,  1123,   130,
-     131,   132,   133,   770,  1124,   771,  1125,   136,   137,   138,
-     139,   140,   141,   772,   143,   144,   145,  1126,   146,   147,
-     148,   149,   150,   151,  1127,   773,   153,   154,   155,   774,
-     775,   776,   777,  1128,  1129,   778,   161,   162,   163,   164,
-     165,   166,   167,   779,   780,   170,  1130,   171,  1131,   172,
-     173,   174,   175,   176,   177,  1132,   178,   179,   180,   181,
-     182,  1133,  1134,   183,   184,   185,  1877,   187,  1135,   188,
-     189,   190,  1136,   191,   192,   193,  1137,   194,   195,   196,
-     197,   781,   199,   200,   201,   202,   203,   782,  1138,   205,
-    1139,   206,   207,   783,   209,  1140,   210,  1141,   211,   784,
-    1142,   785,   214,   215,   786,   787,   218,  1143,   219,  1144,
-     788,   789,   222,  1145,   223,   224,   225,   226,   227,   228,
-     229,   790,   231,   232,   233,   234,  1146,   235,   236,   237,
-     238,   239,   240,  1147,   241,   791,   792,   244,   245,   246,
-     247,   248,   793,   794,  1148,   795,  1149,   252,   796,   797,
-     255,   798,   257,   258,   259,   260,   261,   262,  1150,  1151,
-     263,   799,   265,   800,  1152,   267,   268,   269,  1153,  1154,
-     270,   271,   272,   273,   274,   801,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   802,   803,   804,   297,   298,   299,
-     805,  1155,   301,   302,   806,   304,  1156,   807,   306,   808,
-     308,   309,   310,  1157,   311,   312,  1158,  1159,   313,   314,
-     315,  1160,  1161,   316,   809,   810,   319,   811,   812,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,  1162,
-     332,   333,   813,   335,   336,   814,   338,   339,   340,  1163,
-     341,   342,   343,   344,   345,   346,  1164,   347,   348,   349,
-     815,   351,   352,   353,   354,  1165,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,  1166,
-     368,   369,   816,   371,   372,   373,   817,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,  1167,   386,
-     387,   388,   389,   390,   818,  1878,   819,   394,   395,   396,
-     820,   398,   399,   821,   401,  1168,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   822,   415,
-     823,   417,  1169,   418,   419,  1170,   420,   824,   422,   423,
-     424,   425,   426,  1171,   825,   826,  1172,  1173,   429,   430,
-     827,   432,   828,  1174,   434,   435,   829,   437,   438,   439,
-     440,   441,  1175,  1176,   442,   443,   444,   445,   446,   830,
-    1177,   448,   449,   450,   451,   452,  1178,   832,  1179,   455,
-     833,   457,   458,   459,   460,   461,  1180,  1181,   462,  1182,
-    1183,   463,   464,   465,   466,   467,   468,   834,   835,   836,
-     837,   838,   839,   840,   841,   842,   843,   844,   480,   481,
-     482,   483,    93,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,     0,     0,     0,   105,   106,
-       0,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,     0,   119,   120,   121,   122,   123,   124,
-       0,   875,   125,   126,   127,   128,   129,     0,   130,   131,
-     132,   133,   878,     0,   879,     0,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,   152,   153,   154,   155,   880,   881,
-     882,   883,   884,   885,   886,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,     0,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   185,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   891,     0,   205,     0,
-     206,   207,   208,   209,     0,   210,     0,   211,   212,     0,
-     213,   214,   215,   216,   217,   218,     0,   219,     0,   220,
-     221,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,     0,   251,     0,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-     264,   265,   266,     0,   267,   268,   269,   899,   900,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-       0,   301,   302,   303,   304,     0,   905,   306,   307,   308,
-     309,   310,     0,   311,   312,     0,     0,   313,   314,   315,
-       0,     0,   316,   317,   318,   319,   320,   908,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   909,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   350,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,   912,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   914,
-     417,     0,   418,   419,     0,   420,   421,   422,   423,   424,
-     425,   426,     0,   427,   428,     0,     0,   429,   430,   917,
-     432,   918,     0,   434,   435,   920,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,   921,     0,
-     448,   449,   450,   451,   452,   453,   454,     0,   455,   456,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   761,     0,   556,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    94,    95,
-      96,    97,    98,    99,   100,   101,     0,   102,   103,   104,
-       0,     0,     0,     0,     0,     0,     0,   105,   106,     0,
-     107,   108,   109,   762,   111,   112,   113,   763,   764,   765,
-     766,   767,     0,   119,   120,   121,   122,   123,   124,     0,
-       0,   125,   126,   768,   769,   129,     0,   130,   131,   132,
-     133,   770,     0,   771,     0,   136,   137,   138,   139,   140,
-     141,   772,   143,   144,   145,     0,   146,   147,   148,   149,
-     150,   151,     0,   773,   153,   154,   155,   774,   775,   776,
-     777,     0,     0,   778,   161,   162,   163,   164,   165,   166,
-     167,   779,   780,   170,     0,   171,     0,   172,   173,   174,
-     175,   176,   177,     0,   178,   179,   180,   181,   182,     0,
-       0,   183,   184,   185,   186,   187,     0,   188,   189,   190,
-       0,   191,   192,   193,     0,   194,   195,   196,   197,   781,
-     199,   200,   201,   202,   203,   782,  1286,   205,     0,   206,
-     207,   783,   209,     0,   210,     0,   211,   784,     0,   785,
-     214,   215,   786,   787,   218,     0,   219,     0,   788,   789,
-     222,     0,   223,   224,   225,   226,   227,   228,   229,   790,
-     231,   232,   233,   234,     0,   235,   236,   237,   238,   239,
-     240,     0,   241,   791,   792,   244,   245,   246,   247,   248,
-     793,   794,     0,   795,     0,   252,   796,   797,   255,   798,
-     257,   258,   259,   260,   261,   262,     0,     0,   263,   799,
-     265,   800,     0,   267,   268,   269,     0,     0,   270,   271,
-     272,   273,   274,   801,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   802,   803,   804,   297,   298,   299,   805,     0,
-     301,   302,   806,   304,     0,   807,   306,   808,   308,   309,
-     310,     0,   311,   312,  1287,     0,   313,   314,   315,     0,
-       0,   316,   809,   810,   319,   811,   812,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,     0,   332,   333,
-     813,   335,   336,   814,   338,   339,   340,     0,   341,   342,
-     343,   344,   345,   346,     0,   347,   348,   349,   815,   351,
-     352,   353,   354,     0,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,     0,   368,   369,
-     816,   371,   372,   373,   817,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,     0,   386,   387,   388,
-     389,   390,   818,   392,   819,   394,   395,   396,   820,   398,
-     399,   821,   401,     0,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   822,   415,   823,   417,
-       0,   418,   419,     0,   420,   824,   422,   423,   424,   425,
-     426,     0,   825,   826,     0,     0,   429,   430,   827,   432,
-     828,  1288,   434,   435,   829,   437,   438,   439,   440,   441,
-       0,     0,   442,   443,   444,   445,   446,   830,     0,   448,
-     449,   450,   451,   452,  1178,   832,     0,   455,   833,   457,
-     458,   459,   460,   461,     0,     0,   462,     0,     0,   463,
-     464,   465,   466,   467,   468,   834,   835,   836,   837,   838,
-     839,   840,   841,   842,   843,   844,   480,   481,   482,   483,
-     761,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     3,
-       4,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,   762,   111,   112,   113,   763,   764,   765,   766,
-     767,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   768,   769,   129,     0,   130,   131,   132,   133,
-     770,     0,   771,     0,   136,   137,   138,   139,   140,   141,
-     772,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   773,   153,   154,   155,   774,   775,   776,   777,
-       0,     0,   778,   161,   162,   163,   164,   165,   166,   167,
-     779,   780,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   781,   199,
-     200,   201,   202,   203,   782,     0,   205,     0,   206,   207,
-     783,   209,     0,   210,     0,   211,   784,     0,   785,   214,
-     215,   786,   787,   218,     0,   219,     0,   788,   789,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   790,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   791,   792,   244,   245,   246,   247,   248,   793,
-     794,     0,   795,     0,   252,   796,   797,   255,   798,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   799,   265,
-     800,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,   801,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   802,   803,   804,   297,   298,   299,   805,     0,   301,
-     302,   806,   304,     0,   807,   306,   808,   308,   309,   310,
-       0,   311,   312,     0,     0,   313,   314,   315,     0,     0,
-     316,   809,   810,   319,   811,   812,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   813,
-     335,   336,   814,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   815,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   816,
-     371,   372,   373,   817,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,   818,   392,   819,   394,   395,   396,   820,   398,   399,
-     821,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   822,   415,   823,   417,     0,
-     418,   419,     0,   420,   824,   422,   423,   424,   425,   426,
-       0,   825,   826,     0,     0,   429,   430,   827,   432,   828,
-       0,   434,   435,   829,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   830,     0,   448,   449,
-     450,   451,   452,  1178,   832,     0,   455,   833,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   834,   835,   836,   837,   838,   839,
-     840,   841,   842,   843,   844,   480,   481,   482,   483,    93,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    94,    95,    96,    97,
-      98,    99,   100,   101,     0,   102,   103,   104,     0,     0,
-       0,     0,     0,     0,     0,   105,   106,     0,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-       0,   119,   120,   121,   122,   123,   124,     0,     0,   125,
-     126,   127,   128,   129,     0,   130,   131,   132,   133,   134,
-       0,   135,     0,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,     0,   146,   147,   148,   149,   150,   151,
-       0,   152,   153,   154,   155,   156,   157,   158,   159,     0,
-       0,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,     0,   171,     0,   172,   173,   174,   175,   176,
-     177,     0,   178,   179,   180,   181,   182,     0,     0,   183,
-     184,   185,   186,   187,     0,   188,   189,   190,     0,   191,
-     192,   193,     0,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,     0,   205,     0,   206,   207,   208,
-     209,     0,   210,     0,   211,   212,     0,   213,   214,   215,
-     216,   217,   218,     0,   219,     0,   220,   221,   222,     0,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,     0,   235,   236,   237,   238,   239,   240,     0,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-       0,   251,     0,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,     0,     0,   263,   264,   265,   266,
-       0,   267,   268,   269,     0,     0,   270,   271,   272,   273,
-     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     294,   295,   296,   297,   298,   299,   300,     0,   301,   302,
-     303,   304,     0,   305,   306,   307,   308,   309,   310,     0,
-     311,   312,     0,     0,   313,   314,   315,     0,     0,   316,
-     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,     0,   332,   333,   334,   335,
-     336,   337,   338,   339,   340,     0,   341,   342,   343,   344,
-     345,   346,     0,   347,   348,   349,   350,   351,   352,   353,
-     354,     0,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,     0,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,     0,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,     0,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,     0,   418,
-     419,     0,   420,   421,   422,   423,   424,   425,   426,     0,
-     427,   428,     0,     0,   429,   430,   431,   432,   433,     0,
-     434,   435,   436,   437,   438,   439,   440,   441,     0,     0,
-     442,   443,   444,   445,   446,   447,     0,   448,   449,   450,
-     451,   452,   453,   454,     0,   455,   456,   457,   458,   459,
-     460,   461,     0,     0,   462,     0,     0,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,   482,   483,   506,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,     0,     0,     0,   105,   106,     0,   107,   108,   109,
-       0,   111,   112,   113,   114,   115,     0,   117,   118,     0,
-     119,   120,   121,   122,   123,   124,     0,     0,   125,   126,
-     127,   128,   129,  1483,   130,   131,   132,   133,   134,     0,
-       0,  1484,   136,   137,   138,   139,   140,   141,     0,   143,
-     144,   145,  1485,   146,   147,   148,   149,   150,   151,     0,
-       0,   153,   154,   155,     0,     0,     0,     0,     0,     0,
-       0,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,     0,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     185,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   204,     0,   205,     0,   206,   207,   208,   209,
-       0,   210,  1486,   211,     0,     0,     0,   214,   215,   508,
-       0,   218,     0,   219,     0,   220,   221,   222,     0,   223,
-     224,   225,   226,   227,  1487,   229,     0,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-       0,   243,   244,   245,   246,   247,   248,   249,   250,     0,
-     251,     0,   252,     0,     0,   255,     0,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,     0,   265,     0,     0,
-     267,   268,   269,     0,     0,   270,   271,   272,   273,   274,
-     509,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-       0,   296,   297,   298,   299,   300,     0,   301,   302,     0,
-     304,     0,   305,   306,   307,   308,   309,   310,     0,   311,
-     312,     0,     0,   313,   314,   315,     0,     0,   316,   317,
-       0,   319,     0,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,  1488,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   350,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,     0,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,     0,
-     392,   393,   394,   395,   396,     0,   398,   399,   400,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   511,   415,   416,   417,     0,   418,   419,
-       0,   420,     0,   422,   423,   424,   425,   426,     0,   427,
-     428,     0,     0,   429,   430,   431,   432,   433,     0,   434,
-     435,   436,   437,   438,   439,   440,   441,     0,  1489,   442,
-     443,   444,   445,   446,     0,     0,   448,   449,   450,   451,
-     452,   453,   454,     0,   455,     0,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   506,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    94,    95,    96,    97,    98,    99,
-     100,   101,     0,   102,   103,   104,     0,     0,     0,     0,
-       0,     0,     0,   105,   106,     0,   107,   108,   109,     0,
-     111,   112,   113,   114,   115,     0,   117,   118,     0,   119,
-     120,   121,   122,   123,   124,     0,     0,   125,   126,   127,
-     128,   129,  1483,   130,   131,   132,   133,   134,     0,     0,
-       0,   136,   137,   138,   139,   140,   141,     0,   143,   144,
-     145,  1485,   146,   147,   148,   149,   150,   151,     0,     0,
-     153,   154,   155,     0,     0,     0,     0,     0,     0,     0,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-       0,   171,     0,   172,   173,   174,   175,   176,   177,     0,
-     178,   179,   180,   181,   182,     0,     0,   183,   184,   185,
-     186,   187,     0,   188,   189,   190,     0,   191,   192,   193,
-       0,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,     0,   205,     0,   206,   207,   208,   209,     0,
-     210,  1486,   211,     0,     0,     0,   214,   215,   508,     0,
-     218,     0,   219,     0,   220,   221,   222,     0,   223,   224,
-     225,   226,   227,   228,   229,     0,   231,   232,   233,   234,
-       0,   235,   236,   237,   238,   239,   240,     0,   241,     0,
-     243,   244,   245,   246,   247,   248,   249,   250,     0,   251,
-       0,   252,     0,     0,   255,     0,   257,   258,   259,   260,
-     261,   262,     0,     0,   263,     0,   265,  1945,     0,   267,
-     268,   269,     0,     0,   270,   271,   272,   273,   274,   509,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,   287,   288,   289,   290,   291,   292,   293,   294,     0,
-     296,   297,   298,   299,   300,     0,   301,   302,     0,   304,
-       0,   305,   306,   307,   308,   309,   310,     0,   311,   312,
-       0,     0,   313,   314,   315,     0,     0,   316,   317,     0,
-     319,     0,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,     0,   332,   333,   334,   335,   336,   337,
-     338,   339,   340,  1488,   341,   342,   343,   344,   345,   346,
-       0,   347,   348,   349,   350,   351,   352,   353,   354,     0,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,     0,   368,   369,     0,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,   385,     0,   386,   387,   388,   389,   390,     0,   392,
-     393,   394,   395,   396,     0,   398,   399,   400,   401,     0,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   511,   415,   416,   417,     0,   418,   419,     0,
-     420,     0,   422,   423,   424,   425,   426,     0,   427,   428,
-       0,     0,   429,   430,   431,   432,   433,     0,   434,   435,
-     436,   437,   438,   439,   440,   441,     0,  1489,   442,   443,
-     444,   445,   446,     0,     0,   448,   449,   450,   451,   452,
-     453,   454,     0,   455,     0,   457,   458,   459,   460,   461,
-       0,     0,   462,     0,     0,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,   482,   483,   506,     0,   588,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     3,     4,     0,     0,     0,
-       0,     0,   105,   106,     0,   107,   108,   109,     0,   111,
-     112,   113,   114,   115,     0,   117,   118,     0,   119,   120,
-     121,   122,   123,   124,     0,     0,   125,   126,   127,   128,
-     129,     0,   130,   131,   132,   133,   134,     0,     0,     0,
-     136,   137,   138,   139,   140,   141,     0,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,     0,   153,
-     154,   155,     0,     0,     0,     0,     0,     0,     0,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,     0,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   185,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
-     204,     0,   205,     0,   206,   207,   208,   209,     0,   210,
-       0,   211,     0,     0,     0,   214,   215,   508,     0,   218,
-       0,   219,     0,   220,   221,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,     0,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,     0,   243,
-     244,   245,   246,   247,   248,   249,   250,     0,   251,     0,
-     252,     0,     0,   255,     0,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,     0,   265,     0,     0,   267,   268,
-     269,     0,     0,   270,   271,   272,   273,   274,   509,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,     0,   296,
-     297,   298,   299,   300,     0,   301,   302,     0,   304,     0,
-     305,   306,   307,   308,   309,   310,     0,   311,   312,     0,
-       0,   313,   314,   315,     0,     0,   316,   317,     0,   319,
-       0,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   350,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,     0,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,     0,   392,   393,
-     394,   395,   396,     0,   398,   399,   400,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   511,   415,   416,   417,     0,   418,   419,     0,   420,
-       0,   422,   423,   424,   425,   426,     0,   427,   428,     0,
-       0,   429,   430,   431,   432,   433,     0,   434,   435,   436,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,     0,     0,   448,   449,   450,   451,   452,   453,
-     454,     0,   455,     0,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   673,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    94,    95,    96,    97,    98,    99,   100,   101,
-       0,   102,   103,   104,     0,     0,     0,     0,     0,  -663,
-       0,   105,   106,     0,   107,   108,   109,   674,   111,   112,
-     113,     0,   675,   676,   677,   678,     0,   119,   120,   121,
-     122,   123,   124,     0,     0,   125,   126,   679,   680,   129,
-       0,   130,   131,   132,   133,     0,     0,   681,     0,   136,
-     137,   138,   139,   140,   141,   682,   143,   144,   145,     0,
-     146,   147,   148,   149,   150,   151,     0,   683,   153,   154,
-     155,   684,   685,   686,   687,     0,     0,   688,   161,   162,
-     163,   164,   165,   166,   167,   689,   690,   170,     0,   171,
-       0,   172,   173,   174,   175,   176,   177,     0,   178,   179,
-     180,   181,   182,     0,     0,   183,   184,   691,   186,   187,
-       0,   188,   189,   190,     0,   191,   192,   193,     0,   194,
-     195,   196,   197,     0,   199,   200,   201,   202,   203,     0,
-       0,   205,     0,   206,   207,   692,   209,     0,   210,     0,
-     211,   693,     0,   694,   214,   215,  -663,   695,   218,     0,
-     219,     0,     0,     0,   222,     0,   223,   224,   225,   226,
-     227,   228,   229,   697,   231,   232,   233,   234,     0,   235,
-     236,   237,   238,   239,   240,     0,   241,   698,     0,   244,
-     245,   246,   247,   248,   699,   700,     0,   701,     0,   252,
-     702,   703,   255,   704,   257,   258,   259,   260,   261,   262,
-       0,     0,   263,   705,   265,   706,     0,   267,   268,   269,
-       0,     0,   270,   271,   272,   273,   274,   707,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   708,   709,   710,   297,
-     298,   299,     0,     0,   301,   302,   711,   304,     0,     0,
-     306,   712,   308,   309,   310,     0,   311,   312,     0,     0,
-     313,   314,   315,     0,     0,   316,     0,   713,   319,   714,
-       0,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,     0,   332,   333,     0,   335,   336,     0,   338,   339,
-     340,     0,   341,   342,   343,   344,   345,   346,     0,   347,
-     348,   349,   715,   351,   352,   353,   354,     0,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,     0,   368,   369,   716,   371,   372,   373,   717,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-       0,   386,   387,   388,   389,   390,   718,   392,   719,   394,
-     395,   396,   720,   398,   399,   721,   401,     0,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     722,   415,     0,   417,     0,   418,   419,     0,   420,   723,
-     422,   423,   424,   425,   426,     0,   724,   725,     0,     0,
-     429,   430,     0,   432,     0,     0,   434,   435,   726,   437,
-     438,   439,   440,   441,     0,     0,   442,   443,   444,   445,
-     446,   727,     0,   448,   449,   450,   451,   452,     0,   728,
-       0,   455,   729,   457,   458,   459,   460,   461,     0,     0,
-     462,     0,     0,   463,   464,   465,   466,   467,   468,   506,
-       0,   588,     0,     0,     0,     0,     0,     0,     0,     0,
-     480,   481,   482,   483,     0,     0,    94,    95,    96,    97,
-      98,    99,   100,   101,     0,   102,   103,   104,     0,     0,
-       0,     0,     0,     0,     0,   105,   106,     0,   107,   108,
-     109,     0,   111,   112,   113,   114,   115,     0,   117,   118,
-       0,   119,   120,   121,   122,   123,   124,     0,     0,   125,
-     126,   127,   128,   129,     0,   130,   131,   132,   133,   134,
-       0,     0,     0,   136,   137,   138,   139,   140,   141,     0,
-     143,   144,   145,     0,   146,   147,   148,   149,   150,   151,
-       0,     0,   153,   154,   155,     0,     0,     0,     0,     0,
-       0,     0,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,     0,   171,     0,   172,   173,   174,   175,   176,
-     177,     0,   178,   179,   180,   181,   182,     0,     0,   183,
-     184,   185,   186,   187,     0,   188,   189,   190,     0,   191,
-     192,   193,     0,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,     0,   205,     0,   206,   207,   208,
-     209,     0,   210,     0,   211,     0,     0,     0,   214,   215,
-     508,     0,   218,     0,   219,     0,   220,   221,   222,     0,
-     223,   224,   225,   226,   227,   228,   229,     0,   231,   232,
-     233,   234,     0,   235,   236,   237,   238,   239,   240,     0,
-     241,     0,   243,   244,   245,   246,   247,   248,   249,   250,
-       0,   251,     0,   252,     0,     0,   255,     0,   257,   258,
-     259,   260,   261,   262,     0,     0,   263,     0,   265,     0,
-       0,   267,   268,   269,     0,     0,   270,   271,   272,   273,
-     274,   509,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     294,     0,   296,   297,   298,   299,   300,     0,   301,   302,
-       0,   304,     0,   305,   306,   307,   308,   309,   310,     0,
-     311,   312,     0,   589,   313,   314,   315,     0,     0,   316,
-     317,     0,   319,     0,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,     0,   332,   333,   334,   335,
-     336,   337,   338,   339,   340,     0,   341,   342,   343,   344,
-     345,   346,     0,   347,   348,   349,   350,   351,   352,   353,
-     354,     0,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,     0,   368,   369,     0,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,     0,   386,   387,   388,   389,   390,
-       0,   392,   393,   394,   395,   396,     0,   398,   399,   400,
-     401,     0,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   511,   415,   416,   417,     0,   418,
-     419,     0,   420,     0,   422,   423,   424,   425,   426,     0,
-     427,   428,     0,     0,   429,   430,   431,   432,   433,     0,
-     434,   435,   436,   437,   438,   439,   440,   441,     0,     0,
-     442,   443,   444,   445,   446,     0,     0,   448,   449,   450,
-     451,   452,   453,   454,     0,   455,     0,   457,   458,   459,
-     460,   461,     0,     0,   462,     0,     0,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,   482,   483,   506,     0,
-     588,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,     0,     0,     0,   105,   106,     0,   107,   108,   109,
-       0,   111,   112,   113,   114,   115,     0,   117,   118,     0,
-     119,   120,   121,   122,   123,   124,     0,     0,   125,   126,
-     127,   128,   129,     0,   130,   131,   132,   133,   134,     0,
-       0,     0,   136,   137,   138,   139,   140,   141,     0,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-       0,   153,   154,   155,     0,     0,     0,     0,     0,     0,
-       0,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,     0,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     185,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   204,     0,   205,     0,   206,   207,   208,   209,
-       0,   210,     0,   211,     0,     0,     0,   214,   215,   508,
-       0,   218,     0,   219,     0,   220,   221,   222,     0,   223,
-     224,   225,   226,   227,   632,   229,     0,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-       0,   243,   244,   245,   246,   247,   248,   249,   250,     0,
-     251,     0,   252,     0,     0,   255,     0,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,     0,   265,     0,     0,
-     267,   268,   269,     0,     0,   270,   271,   272,   273,   274,
-     509,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-       0,   296,   297,   298,   299,   300,     0,   301,   302,     0,
-     304,     0,   305,   306,   307,   308,   309,   310,     0,   311,
-     312,     0,   589,   313,   314,   315,     0,     0,   316,   317,
-       0,   319,     0,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   350,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,     0,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,     0,
-     392,   393,   394,   395,   396,     0,   398,   399,   400,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   511,   415,   416,   417,     0,   418,   419,
-       0,   420,     0,   422,   423,   424,   425,   426,     0,   427,
-     428,     0,     0,   429,   430,   431,   432,   433,     0,   434,
-     435,   436,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,     0,     0,   448,   449,   450,   451,
-     452,   453,   454,     0,   455,     0,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   506,     0,   588,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    94,    95,    96,    97,    98,    99,
-     100,   101,     0,   102,   103,   104,     0,     0,     0,     0,
-       0,     0,     0,   105,   106,     0,   107,   108,   109,     0,
-     111,   112,   113,   114,   115,     0,   117,   118,     0,   119,
-     120,   121,   122,   123,   124,     0,     0,   125,   126,   127,
-     128,   129,     0,   130,   131,   132,   133,   134,     0,     0,
-       0,   136,   137,   138,   139,   140,   141,     0,   143,   144,
-     145,     0,   146,   147,   148,   149,   150,   151,     0,     0,
-     153,   154,   155,     0,     0,     0,     0,     0,     0,     0,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-       0,   171,     0,   172,   173,   174,   175,   176,   177,     0,
-     178,   179,   180,   181,   182,     0,     0,   183,   184,   185,
-     186,   187,     0,   188,   189,   190,     0,   191,   192,   193,
-       0,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,     0,   205,     0,   206,   207,   208,   209,     0,
-     210,     0,   211,     0,     0,     0,   214,   215,   508,     0,
-    1782,     0,   219,     0,   220,   221,   222,     0,   223,   224,
-     225,   226,   227,   228,   229,     0,   231,   232,   233,   234,
-       0,   235,   236,   237,   238,   239,   240,     0,   241,     0,
-     243,   244,   245,   246,   247,   248,   249,   250,     0,   251,
-       0,   252,     0,     0,   255,     0,   257,   258,   259,   260,
-     261,   262,     0,     0,   263,     0,   265,     0,     0,   267,
-     268,  1783,     0,     0,   270,   271,   272,   273,   274,   509,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,   287,   288,   289,   290,   291,   292,   293,   294,     0,
-     296,   297,   298,   299,   300,     0,   301,   302,     0,   304,
-       0,   305,   306,   307,   308,   309,   310,     0,   311,   312,
-       0,     0,   313,   314,   315,     0,     0,   316,   317,     0,
-     319,     0,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,     0,   332,   333,   334,   335,   336,   337,
-     338,   339,   340,     0,   341,   342,   343,   344,   345,   346,
-       0,   347,   348,   349,   350,   351,   352,   353,   354,     0,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,     0,   368,   369,     0,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,   385,     0,   386,   387,   388,   389,   390,     0,   392,
-     393,   394,   395,   396,     0,   398,   399,   400,   401,     0,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   511,   415,   416,   417,     0,   418,   419,  1784,
-     420,     0,   422,  1785,   424,  1786,   426,     0,   427,   428,
-       0,     0,   429,   430,   431,   432,   433,     0,   434,   435,
-     436,   437,   438,   439,   440,   441,     0,     0,   442,   443,
-    1787,   445,   446,     0,     0,   448,   449,   450,   451,   452,
-     453,   454,     0,   455,     0,   457,   458,   459,   460,   461,
-       0,     0,   462,     0,     0,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,   482,   483,   506,  2756,     0,     0,
-       0,     0,  2757,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,     0,
-       0,     0,   105,   106,     0,   107,   108,   109,     0,   111,
-     112,   113,   114,   115,     0,   117,   118,     0,   119,   120,
-     121,   122,   123,   124,     0,     0,   125,   126,   127,   128,
-     129,     0,   130,   131,   132,   133,   134,     0,     0,     0,
-     136,   137,   138,   139,   140,   141,     0,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,     0,   153,
-     154,   155,     0,     0,     0,     0,     0,     0,     0,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,     0,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   185,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
-     204,     0,   205,     0,   206,   207,   208,   209,     0,   210,
-       0,   211,     0,     0,     0,   214,   215,   508,     0,   218,
-       0,   219,     0,   220,   221,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,     0,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,     0,   243,
-     244,   245,   246,   247,   248,   249,   250,     0,   251,     0,
-     252,     0,     0,   255,     0,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,     0,   265,     0,     0,   267,   268,
-     269,     0,     0,   270,   271,   272,   273,   274,   509,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,     0,   296,
-     297,   298,   299,   300,     0,   301,   302,     0,   304,     0,
-     305,   306,   307,   308,   309,   310,     0,   311,   312,     0,
-       0,   313,   314,   315,     0,     0,   316,   317,     0,   319,
-       0,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   350,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,     0,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,     0,   392,   393,
-     394,   395,   396,     0,   398,   399,   400,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   511,   415,   416,   417,     0,   418,   419,     0,   420,
-       0,   422,   423,   424,   425,   426,     0,   427,   428,     0,
-       0,   429,   430,   431,   432,   433,     0,   434,   435,   436,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,     0,     0,   448,   449,   450,   451,   452,   453,
-     454,     0,   455,     0,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   506,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    94,    95,    96,    97,    98,    99,   100,   101,
-     507,   102,   103,   104,     0,     0,     0,     0,     0,     0,
-       0,   105,   106,     0,   107,   108,   109,     0,   111,   112,
-     113,   114,   115,     0,   117,   118,     0,   119,   120,   121,
-     122,   123,   124,     0,     0,   125,   126,   127,   128,   129,
-       0,   130,   131,   132,   133,   134,     0,     0,     0,   136,
-     137,   138,   139,   140,   141,     0,   143,   144,   145,     0,
-     146,   147,   148,   149,   150,   151,     0,     0,   153,   154,
-     155,     0,     0,     0,     0,     0,     0,     0,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,     0,   171,
-       0,   172,   173,   174,   175,   176,   177,     0,   178,   179,
-     180,   181,   182,     0,     0,   183,   184,   185,   186,   187,
-       0,   188,   189,   190,     0,   191,   192,   193,     0,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-       0,   205,     0,   206,   207,   208,   209,     0,   210,     0,
-     211,     0,     0,     0,   214,   215,   508,     0,   218,     0,
-     219,     0,   220,   221,   222,     0,   223,   224,   225,   226,
-     227,   228,   229,     0,   231,   232,   233,   234,     0,   235,
-     236,   237,   238,   239,   240,     0,   241,     0,   243,   244,
-     245,   246,   247,   248,   249,   250,     0,   251,     0,   252,
-       0,     0,   255,     0,   257,   258,   259,   260,   261,   262,
-       0,     0,   263,     0,   265,     0,     0,   267,   268,   269,
-       0,     0,   270,   271,   272,   273,   274,   509,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   294,     0,   296,   297,
-     298,   299,   300,     0,   301,   302,     0,   304,     0,   305,
-     306,   307,   308,   309,   310,     0,   311,   312,     0,     0,
-     313,   314,   315,     0,     0,   316,   317,     0,   319,     0,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,     0,   332,   333,   334,   335,   336,   337,   510,   339,
-     340,     0,   341,   342,   343,   344,   345,   346,     0,   347,
-     348,   349,   350,   351,   352,   353,   354,     0,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,     0,   368,   369,     0,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-       0,   386,   387,   388,   389,   390,     0,   392,   393,   394,
-     395,   396,     0,   398,   399,   400,   401,     0,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     511,   415,   416,   417,     0,   418,   419,     0,   420,     0,
-     422,   423,   424,   425,   426,     0,   427,   428,     0,     0,
-     429,   430,   431,   432,   433,     0,   434,   435,   436,   437,
-     438,   439,   440,   441,     0,     0,   442,   443,   444,   445,
-     446,     0,     0,   448,   449,   450,   451,   452,   453,   454,
-       0,   455,     0,   457,   458,   459,   460,   461,     0,     0,
-     462,     0,     0,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,   482,   483,   506,     0,   556,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,     0,     0,     0,
-     105,   106,     0,   107,   108,   109,     0,   111,   112,   113,
-     114,   115,     0,   117,   118,     0,   119,   120,   121,   122,
-     123,   124,     0,     0,   125,   126,   127,   128,   129,     0,
-     130,   131,   132,   133,   134,     0,     0,     0,   136,   137,
-     138,   139,   140,   141,     0,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,     0,   153,   154,   155,
-       0,     0,     0,     0,     0,     0,     0,   161,   162,   163,
-     164,   165,   166,   167,   168,   169,   170,     0,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   185,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   198,   199,   200,   201,   202,   203,   204,     0,
-     205,     0,   206,   207,   208,   209,     0,   210,     0,   211,
-       0,     0,     0,   214,   215,   508,     0,   218,     0,   219,
-       0,   220,   221,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,     0,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,     0,   243,   244,   245,
-     246,   247,   248,   249,   250,     0,   251,     0,   252,     0,
-       0,   255,     0,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,     0,   265,     0,     0,   267,   268,   269,     0,
-       0,   270,   271,   272,   273,   274,   509,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,     0,   296,   297,   298,
-     299,   300,     0,   301,   302,     0,   304,     0,   305,   306,
-     307,   308,   309,   310,     0,   311,   312,     0,     0,   313,
-     314,   315,     0,     0,   316,   317,     0,   319,     0,   321,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   334,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   350,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,     0,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,     0,   392,   393,   394,   395,
-     396,     0,   398,   399,   400,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   511,
-     415,   416,   417,     0,   418,   419,     0,   420,     0,   422,
-     423,   424,   425,   426,     0,   427,   428,     0,     0,   429,
-     430,   431,   432,   433,     0,   434,   435,   436,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-       0,     0,   448,   449,   450,   451,   452,   453,   454,     0,
-     455,     0,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   506,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      94,    95,    96,    97,    98,    99,   100,   101,   563,   102,
-     103,   104,     0,     0,     0,     0,     0,     0,     0,   105,
-     106,     0,   107,   108,   109,     0,   111,   112,   113,   114,
-     115,     0,   117,   118,     0,   119,   120,   121,   122,   123,
-     124,     0,     0,   125,   126,   127,   128,   129,     0,   130,
-     131,   132,   133,   134,     0,     0,     0,   136,   137,   138,
-     139,   140,   141,     0,   143,   144,   145,     0,   146,   147,
-     148,   149,   150,   151,     0,     0,   153,   154,   155,     0,
-       0,     0,     0,     0,     0,     0,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,     0,   171,     0,   172,
-     173,   174,   175,   176,   177,     0,   178,   179,   180,   181,
-     182,     0,     0,   183,   184,   185,   186,   187,     0,   188,
-     189,   190,     0,   191,   192,   193,     0,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,     0,   205,
-       0,   206,   207,   208,   209,     0,   210,     0,   211,     0,
-       0,     0,   214,   215,   508,     0,   218,     0,   219,     0,
-     220,   221,   222,     0,   223,   224,   225,   226,   227,   228,
-     229,     0,   231,   232,   233,   234,     0,   235,   236,   237,
-     238,   239,   240,     0,   241,     0,   243,   244,   245,   246,
-     247,   248,   249,   250,     0,   251,     0,   252,     0,     0,
-     255,     0,   257,   258,   259,   260,   261,   262,     0,     0,
-     263,     0,   265,     0,     0,   267,   268,   269,     0,     0,
-     270,   271,   272,   273,   274,   509,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   294,     0,   296,   297,   298,   299,
-     300,     0,   301,   302,     0,   304,     0,   305,   306,   307,
-     308,   309,   310,     0,   311,   312,     0,     0,   313,   314,
-     315,     0,     0,   316,   317,     0,   319,     0,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,     0,
-     332,   333,   334,   335,   336,   337,   338,   339,   340,     0,
-     341,   342,   343,   344,   345,   346,     0,   347,   348,   349,
-     350,   351,   352,   353,   354,     0,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,     0,
-     368,   369,     0,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,     0,   386,
-     387,   388,   389,   390,     0,   392,   393,   394,   395,   396,
-       0,   398,   399,   400,   401,     0,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   511,   415,
-     416,   417,     0,   418,   419,     0,   420,     0,   422,   423,
-     424,   425,   426,     0,   564,   428,     0,     0,   565,   430,
-     431,   432,   433,     0,   434,   435,   436,   437,   438,   439,
-     440,   441,     0,     0,   442,   443,   444,   445,   446,     0,
-       0,   448,   449,   450,   451,   452,   453,   454,     0,   455,
-       0,   457,   458,   459,   460,   461,     0,     0,   462,     0,
-       0,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-     482,   483,   506,     0,   588,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,     0,     0,     0,   105,   106,
-       0,   107,   108,   109,     0,   111,   112,   113,   114,   115,
-       0,   117,   118,     0,   119,   120,   121,   122,   123,   124,
-       0,     0,   125,   126,   127,   128,   129,     0,   130,   131,
-     132,   133,   134,     0,     0,     0,   136,   137,   138,   139,
-     140,   141,     0,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,     0,   153,   154,   155,     0,     0,
-       0,     0,     0,     0,     0,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,     0,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   185,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   204,     0,   205,     0,
-     206,   207,   208,   209,     0,   210,     0,   211,     0,     0,
-       0,   214,   215,   508,     0,   218,     0,   219,     0,   220,
-     221,   222,     0,   223,   224,   225,   226,   227,   627,   229,
-       0,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,     0,   243,   244,   245,   246,   247,
-     248,   249,   250,     0,   251,     0,   252,     0,     0,   255,
-       0,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-       0,   265,     0,     0,   267,   268,   269,     0,     0,   270,
-     271,   272,   273,   274,   509,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,     0,   296,   297,   298,   299,   300,
-       0,   301,   302,     0,   304,     0,   305,   306,   307,   308,
-     309,   310,     0,   311,   312,     0,     0,   313,   314,   315,
-       0,     0,   316,   317,     0,   319,     0,   321,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   350,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,     0,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,     0,   392,   393,   394,   395,   396,     0,
-     398,   399,   400,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   511,   415,   416,
-     417,     0,   418,   419,     0,   420,     0,   422,   423,   424,
-     425,   426,     0,   427,   428,     0,     0,   429,   430,   431,
-     432,   433,     0,   434,   435,   436,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,     0,     0,
-     448,   449,   450,   451,   452,   453,   454,     0,   455,     0,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   506,     0,   588,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    94,    95,
-      96,    97,    98,    99,   100,   101,     0,   102,   103,   104,
-       0,     0,     0,     0,     0,     0,     0,   105,   106,     0,
-     107,   108,   109,     0,   111,   112,   113,   114,   115,     0,
-     117,   118,     0,   119,   120,   121,   122,   123,   124,     0,
-       0,   125,   126,   127,   128,   129,     0,   130,   131,   132,
-     133,   134,     0,     0,     0,   136,   137,   138,   139,   140,
-     141,     0,   143,   144,   145,     0,   146,   147,   148,   149,
-     150,   151,     0,     0,   153,   154,   155,     0,     0,     0,
-       0,     0,     0,     0,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,     0,   171,     0,   172,   173,   174,
-     175,   176,   177,     0,   178,   179,   180,   181,   182,     0,
-       0,   183,   184,   185,   186,   187,     0,   188,   189,   190,
-       0,   191,   192,   193,     0,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,     0,   205,     0,   206,
-     207,   208,   209,     0,   210,     0,   211,     0,     0,     0,
-     214,   215,   508,     0,   218,     0,   219,     0,   220,   221,
-     222,     0,   223,   224,   225,   226,   227,   630,   229,     0,
-     231,   232,   233,   234,     0,   235,   236,   237,   238,   239,
-     240,     0,   241,     0,   243,   244,   245,   246,   247,   248,
-     249,   250,     0,   251,     0,   252,     0,     0,   255,     0,
-     257,   258,   259,   260,   261,   262,     0,     0,   263,     0,
-     265,     0,     0,   267,   268,   269,     0,     0,   270,   271,
-     272,   273,   274,   509,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   294,     0,   296,   297,   298,   299,   300,     0,
-     301,   302,     0,   304,     0,   305,   306,   307,   308,   309,
-     310,     0,   311,   312,     0,     0,   313,   314,   315,     0,
-       0,   316,   317,     0,   319,     0,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,     0,   332,   333,
-     334,   335,   336,   337,   338,   339,   340,     0,   341,   342,
-     343,   344,   345,   346,     0,   347,   348,   349,   350,   351,
-     352,   353,   354,     0,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,     0,   368,   369,
-       0,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,     0,   386,   387,   388,
-     389,   390,     0,   392,   393,   394,   395,   396,     0,   398,
-     399,   400,   401,     0,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   511,   415,   416,   417,
-       0,   418,   419,     0,   420,     0,   422,   423,   424,   425,
-     426,     0,   427,   428,     0,     0,   429,   430,   431,   432,
-     433,     0,   434,   435,   436,   437,   438,   439,   440,   441,
-       0,     0,   442,   443,   444,   445,   446,     0,     0,   448,
-     449,   450,   451,   452,   453,   454,     0,   455,     0,   457,
-     458,   459,   460,   461,     0,     0,   462,     0,     0,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
-     506,     0,   588,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,     0,   111,   112,   113,   114,   115,     0,   117,
-     118,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   127,   128,   129,     0,   130,   131,   132,   133,
-     134,     0,     0,     0,   136,   137,   138,   139,   140,   141,
-       0,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,     0,   153,   154,   155,     0,     0,     0,     0,
-       0,     0,     0,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,     0,   205,     0,   206,   207,
-     208,   209,     0,   210,     0,   211,     0,     0,     0,   214,
-     215,   508,     0,   218,     0,   219,     0,   220,   221,   222,
-       0,   223,   224,   225,   226,   227,   634,   229,     0,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,     0,   243,   244,   245,   246,   247,   248,   249,
-     250,     0,   251,     0,   252,     0,     0,   255,     0,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,     0,   265,
-       0,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,   509,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,     0,   296,   297,   298,   299,   300,     0,   301,
-     302,     0,   304,     0,   305,   306,   307,   308,   309,   310,
-       0,   311,   312,     0,     0,   313,   314,   315,     0,     0,
-     316,   317,     0,   319,     0,   321,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   350,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,     0,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,     0,   392,   393,   394,   395,   396,     0,   398,   399,
-     400,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   511,   415,   416,   417,     0,
-     418,   419,     0,   420,     0,   422,   423,   424,   425,   426,
-       0,   427,   428,     0,     0,   429,   430,   431,   432,   433,
-       0,   434,   435,   436,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,     0,     0,   448,   449,
-     450,   451,   452,   453,   454,     0,   455,     0,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   506,
-       0,   588,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    94,    95,    96,    97,
-      98,    99,   100,   101,     0,   102,   103,   104,     0,     0,
-       0,     0,     0,     0,     0,   105,   106,     0,   107,   108,
-     109,     0,   111,   112,   113,   114,   115,     0,   117,   118,
-       0,   119,   120,   121,   122,   123,   124,     0,     0,   125,
-     126,   127,   128,   129,     0,   130,   131,   132,   133,   134,
-       0,     0,     0,   136,   137,   138,   139,   140,   141,     0,
-     143,   144,   145,     0,   146,   147,   148,   149,   150,   151,
-       0,     0,   153,   154,   155,     0,     0,     0,     0,     0,
-       0,     0,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,     0,   171,     0,   172,   173,   174,   175,   176,
-     177,     0,   178,   179,   180,   181,   182,     0,     0,   183,
-     184,   185,   186,   187,     0,   188,   189,   190,     0,   191,
-     192,   193,     0,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,     0,   205,     0,   206,   207,   208,
-     209,     0,   210,     0,   211,     0,     0,     0,   214,   215,
-     508,     0,   218,     0,   219,     0,   220,   221,   222,     0,
-     223,   224,   225,   226,   227,   228,   229,     0,   231,   232,
-     233,   234,     0,   235,   236,   237,   238,   239,   240,     0,
-     241,     0,   243,   244,   245,   246,   247,   248,   249,   250,
-       0,   251,     0,   252,     0,     0,   255,     0,   257,   258,
-     259,   260,   261,   262,     0,     0,   263,     0,   265,     0,
-       0,   267,   268,   269,     0,     0,   270,   271,   272,   273,
-     274,   509,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     294,     0,   296,   297,   298,   299,   300,     0,   301,   302,
-       0,   304,     0,   305,   306,   307,   308,   309,   310,     0,
-     311,   312,     0,     0,   313,   314,   315,     0,     0,   316,
-     317,     0,   319,     0,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,     0,   332,   333,   334,   335,
-     336,   337,   338,   339,   340,     0,   341,   342,   343,   344,
-     345,   346,     0,   347,   348,   349,   350,   351,   352,   353,
-     354,     0,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,     0,   368,   369,     0,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,     0,   386,   387,   388,   389,   390,
-       0,   392,   393,   394,   395,   396,     0,   398,   399,   400,
-     401,     0,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   511,   415,   416,   417,     0,   418,
-     419,     0,   420,     0,   422,   423,   424,   425,   426,     0,
-     427,   428,     0,     0,   429,   430,   431,   432,   433,     0,
-     434,   435,   436,   437,   438,   439,   440,   441,     0,     0,
-     442,   443,   444,   445,   446,     0,     0,   448,   449,   450,
-     451,   452,   453,   454,     0,   455,     0,   457,   458,   459,
-     460,   461,     0,     0,   462,     0,     0,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,   482,   483,   506,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,   664,   102,   103,   104,     0,     0,     0,
-       0,     0,     0,     0,   105,   106,     0,   107,   108,   109,
-       0,   111,   112,   113,   114,   115,     0,   117,   118,     0,
-     119,   120,   121,   122,   123,   124,     0,     0,   125,   126,
-     127,   128,   129,     0,   130,   131,   132,   133,   134,     0,
-       0,     0,   136,   137,   138,   139,   140,   141,     0,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-       0,   153,   154,   155,     0,     0,     0,     0,     0,     0,
-       0,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,     0,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     185,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   204,     0,   205,     0,   206,   207,   208,   209,
-       0,   210,     0,   211,     0,     0,     0,   214,   215,   508,
-       0,   218,     0,   219,     0,   220,   221,   222,     0,   223,
-     224,   225,   226,   227,   228,   229,     0,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-       0,   243,   244,   245,   246,   247,   248,   249,   250,     0,
-     251,     0,   252,     0,     0,   255,     0,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,     0,   265,     0,     0,
-     267,   268,   269,     0,     0,   270,   271,   272,   273,   274,
-     509,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-       0,   296,   297,   298,   299,   300,     0,   301,   302,     0,
-     304,     0,   305,   306,   307,   308,   309,   310,     0,   311,
-     312,     0,     0,   313,   314,   315,     0,     0,   316,   317,
-       0,   319,     0,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   350,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,     0,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,     0,
-     392,   393,   394,   395,   396,     0,   398,   399,   400,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   511,   415,   416,   417,     0,   418,   419,
-       0,   420,     0,   422,   423,   424,   425,   426,     0,   427,
-     428,     0,     0,   429,   430,   431,   432,   433,     0,   434,
-     435,   436,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,     0,     0,   448,   449,   450,   451,
-     452,   453,   454,     0,   455,     0,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   673,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    94,    95,    96,    97,    98,    99,
-     100,   101,     0,   102,   103,   104,     0,     0,     0,     0,
-       0,     0,     0,   105,   106,     0,   107,   108,   109,   674,
-     111,   112,   113,     0,   675,   676,   677,   678,     0,   119,
-     120,   121,   122,   123,   124,     0,     0,   125,   126,   679,
-     680,   129,     0,   130,   131,   132,   133,     0,     0,   681,
-       0,   136,   137,   138,   139,   140,   141,   682,   143,   144,
-     145,     0,   146,   147,   148,   149,   150,   151,     0,   683,
-     153,   154,   155,   684,   685,   686,   687,     0,     0,   688,
-     161,   162,   163,   164,   165,   166,   167,   689,   690,   170,
-       0,   171,     0,   172,   173,   174,   175,   176,   177,     0,
-     178,   179,   180,   181,   182,     0,     0,   183,   184,   691,
-     186,   187,     0,   188,   189,   190,     0,   191,   192,   193,
-       0,   194,   195,   196,   197,     0,   199,   200,   201,   202,
-     203,     0,     0,   205,     0,   206,   207,   692,   209,     0,
-     210,     0,   211,   693,     0,   694,   214,   215,     0,   695,
-     218,     0,   219,     0,     0,     0,   222,     0,   223,   224,
-     225,   226,   227,   696,   229,   697,   231,   232,   233,   234,
-       0,   235,   236,   237,   238,   239,   240,     0,   241,   698,
-       0,   244,   245,   246,   247,   248,   699,   700,     0,   701,
-       0,   252,   702,   703,   255,   704,   257,   258,   259,   260,
-     261,   262,     0,     0,   263,   705,   265,   706,     0,   267,
-     268,   269,     0,     0,   270,   271,   272,   273,   274,   707,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,   287,   288,   289,   290,   291,   292,   293,   708,   709,
-     710,   297,   298,   299,     0,     0,   301,   302,   711,   304,
-       0,     0,   306,   712,   308,   309,   310,     0,   311,   312,
-       0,     0,   313,   314,   315,     0,     0,   316,     0,   713,
-     319,   714,     0,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,     0,   332,   333,     0,   335,   336,     0,
-     338,   339,   340,     0,   341,   342,   343,   344,   345,   346,
-       0,   347,   348,   349,   715,   351,   352,   353,   354,     0,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,     0,   368,   369,   716,   371,   372,   373,
-     717,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,   385,     0,   386,   387,   388,   389,   390,   718,   392,
-     719,   394,   395,   396,   720,   398,   399,   721,   401,     0,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   722,   415,     0,   417,     0,   418,   419,     0,
-     420,   723,   422,   423,   424,   425,   426,     0,   724,   725,
-       0,     0,   429,   430,     0,   432,     0,     0,   434,   435,
-     726,   437,   438,   439,   440,   441,     0,     0,   442,   443,
-     444,   445,   446,   727,     0,   448,   449,   450,   451,   452,
-       0,   728,     0,   455,   729,   457,   458,   459,   460,   461,
-       0,     0,   462,     0,     0,   463,   464,   465,   466,   467,
-     468,   506,     0,   588,     0,     0,     0,     0,     0,     0,
-       0,     0,   480,   481,   482,   483,     0,     0,    94,    95,
-      96,    97,    98,    99,   100,   101,     0,   102,   103,   104,
-       0,     0,     0,     0,     0,     0,     0,   105,   106,     0,
-     107,   108,   109,     0,   111,   112,   113,   114,   115,     0,
-     117,   118,     0,   119,   120,   121,   122,   123,   124,     0,
-       0,   125,   126,   127,   128,   129,     0,   130,   131,   132,
-     133,   134,     0,     0,     0,   136,   137,   138,   139,   140,
-     141,     0,   143,   144,   145,     0,   146,   147,   148,   149,
-     150,   151,     0,     0,   153,   154,   155,     0,     0,     0,
-       0,     0,     0,     0,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,     0,   171,     0,   172,   173,   174,
-     175,   176,   177,     0,   178,   179,   180,   181,   182,     0,
-       0,   183,   184,   185,   186,   187,     0,   188,   189,   190,
-       0,   191,   192,   193,     0,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,     0,   205,     0,   206,
-     207,   208,   209,     0,   210,     0,   211,     0,     0,     0,
-     214,   215,   508,     0,   218,     0,   219,     0,   220,   221,
-     222,     0,   223,   224,   225,   226,   227,  1200,   229,     0,
-     231,   232,   233,   234,     0,   235,   236,   237,   238,   239,
-     240,     0,   241,     0,   243,   244,   245,   246,   247,   248,
-     249,   250,     0,   251,     0,   252,     0,     0,   255,     0,
-     257,   258,   259,   260,   261,   262,     0,     0,   263,     0,
-     265,     0,     0,   267,   268,   269,     0,     0,   270,   271,
-     272,   273,   274,   509,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   294,     0,   296,   297,   298,   299,   300,     0,
-     301,   302,     0,   304,     0,   305,   306,   307,   308,   309,
-     310,     0,   311,   312,     0,     0,   313,   314,   315,     0,
-       0,   316,   317,     0,   319,     0,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,     0,   332,   333,
-     334,   335,   336,   337,   338,   339,   340,     0,   341,   342,
-     343,   344,   345,   346,     0,   347,   348,   349,   350,   351,
-     352,   353,   354,     0,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,     0,   368,   369,
-       0,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,     0,   386,   387,   388,
-     389,   390,     0,   392,   393,   394,   395,   396,     0,   398,
-     399,   400,   401,     0,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   511,   415,   416,   417,
-       0,   418,   419,     0,   420,     0,   422,   423,   424,   425,
-     426,     0,   427,   428,     0,     0,   429,   430,   431,   432,
-     433,     0,   434,   435,   436,   437,   438,   439,   440,   441,
-       0,     0,   442,   443,   444,   445,   446,     0,     0,   448,
-     449,   450,   451,   452,   453,   454,     0,   455,     0,   457,
-     458,   459,   460,   461,     0,     0,   462,     0,     0,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
-     506,     0,   588,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,     0,   111,   112,   113,   114,   115,     0,   117,
-     118,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   127,   128,   129,     0,   130,   131,   132,   133,
-     134,     0,     0,     0,   136,   137,   138,   139,   140,   141,
-       0,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,     0,   153,   154,   155,     0,     0,     0,     0,
-       0,     0,     0,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,     0,   205,     0,   206,   207,
-     208,   209,     0,   210,     0,   211,     0,     0,     0,   214,
-     215,   508,     0,   218,     0,   219,     0,   220,   221,   222,
-       0,   223,   224,   225,   226,   227,  1202,   229,     0,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,     0,   243,   244,   245,   246,   247,   248,   249,
-     250,     0,   251,     0,   252,     0,     0,   255,     0,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,     0,   265,
-       0,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,   509,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,     0,   296,   297,   298,   299,   300,     0,   301,
-     302,     0,   304,     0,   305,   306,   307,   308,   309,   310,
-       0,   311,   312,     0,     0,   313,   314,   315,     0,     0,
-     316,   317,     0,   319,     0,   321,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   350,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,     0,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,     0,   392,   393,   394,   395,   396,     0,   398,   399,
-     400,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   511,   415,   416,   417,     0,
-     418,   419,     0,   420,     0,   422,   423,   424,   425,   426,
-       0,   427,   428,     0,     0,   429,   430,   431,   432,   433,
-       0,   434,   435,   436,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,     0,     0,   448,   449,
-     450,   451,   452,   453,   454,     0,   455,     0,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   673,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    94,    95,    96,    97,
-      98,    99,   100,   101,     0,   102,   103,   104,     0,     0,
-       0,     0,     0,     0,     0,   105,   106,     0,   107,   108,
-     109,   674,   111,   112,   113,     0,   675,   676,   677,   678,
-       0,   119,   120,   121,   122,   123,   124,     0,     0,   125,
-     126,   679,   680,   129,     0,   130,   131,   132,   133,     0,
-       0,   681,     0,   136,   137,   138,   139,   140,   141,   682,
-     143,   144,   145,     0,   146,   147,   148,   149,   150,   151,
-       0,   683,   153,   154,   155,   684,   685,   686,   687,     0,
-       0,   688,   161,   162,   163,   164,   165,   166,   167,   689,
-     690,   170,     0,   171,     0,   172,   173,   174,   175,   176,
-     177,     0,   178,   179,   180,   181,   182,     0,     0,   183,
-     184,   691,   186,   187,     0,   188,   189,   190,     0,   191,
-     192,   193,     0,   194,   195,   196,   197,     0,   199,   200,
-     201,   202,   203,     0,     0,   205,     0,   206,   207,   692,
-     209,     0,   210,     0,   211,   693,     0,   694,   214,   215,
-       0,   695,   218,     0,   219,     0,     0,     0,   222,     0,
-     223,   224,   225,   226,   227,   228,   229,   697,   231,   232,
-     233,   234,     0,   235,   236,   237,   238,   239,   240,     0,
-     241,   698,     0,   244,   245,   246,   247,   248,   699,   700,
-       0,   701,     0,   252,   702,   703,   255,   704,   257,   258,
-     259,   260,   261,   262,     0,     0,   263,   705,   265,   706,
-       0,   267,   268,   269,     0,     0,   270,   271,   272,   273,
-     274,   707,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     708,   709,   710,   297,   298,   299,     0,     0,   301,   302,
-     711,   304,     0,     0,   306,   712,   308,   309,   310,     0,
-     311,   312,     0,     0,   313,   314,   315,     0,     0,   316,
-       0,   713,   319,   714,     0,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,     0,   332,   333,     0,   335,
-     336,     0,   338,   339,   340,     0,   341,   342,   343,   344,
-     345,   346,     0,   347,   348,   349,   715,   351,   352,   353,
-     354,     0,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,     0,   368,   369,   716,   371,
-     372,   373,   717,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,     0,   386,   387,   388,   389,   390,
-     718,   392,   719,   394,   395,   396,   720,   398,   399,   721,
-     401,     0,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   722,   415,     0,   417,     0,   418,
-     419,     0,   420,   723,   422,   423,   424,   425,   426,     0,
-     724,   725,     0,     0,   429,   430,     0,   432,     0,     0,
-     434,   435,   726,   437,   438,   439,   440,   441,     0,     0,
-     442,   443,   444,   445,   446,   727,     0,   448,   449,   450,
-     451,   452,     0,   728,     0,   455,   729,   457,   458,   459,
-     460,   461,     0,     0,   462,     0,     0,   463,   464,   465,
-     466,   467,   468,   506,     0,   588,     0,     0,     0,     0,
-       0,     0,     0,     0,   480,   481,   482,   483,     0,     0,
-      94,    95,    96,    97,    98,    99,   100,   101,     0,   102,
-     103,   104,     0,     0,     0,     0,     0,     0,     0,   105,
-     106,     0,   107,   108,   109,     0,   111,   112,   113,   114,
-     115,     0,   117,   118,     0,   119,   120,   121,   122,   123,
-     124,     0,     0,   125,   126,   127,   128,   129,     0,   130,
-     131,   132,   133,   134,     0,     0,     0,   136,   137,   138,
-     139,   140,   141,     0,   143,   144,   145,     0,   146,   147,
-     148,   149,   150,   151,     0,     0,   153,   154,   155,     0,
-       0,     0,     0,     0,     0,     0,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,     0,   171,     0,   172,
-     173,   174,   175,   176,   177,     0,   178,   179,   180,   181,
-     182,     0,     0,   183,   184,   185,   186,   187,     0,   188,
-     189,   190,     0,   191,   192,   193,     0,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,     0,   205,
-       0,   206,   207,   208,   209,     0,   210,     0,   211,     0,
-       0,     0,   214,   215,   508,     0,   218,     0,   219,     0,
-     220,   221,   222,     0,   223,   224,   225,   226,   227,  1613,
-     229,     0,   231,   232,   233,   234,     0,   235,   236,   237,
-     238,   239,   240,     0,   241,     0,   243,   244,   245,   246,
-     247,   248,   249,   250,     0,   251,     0,   252,     0,     0,
-     255,     0,   257,   258,   259,   260,   261,   262,     0,     0,
-     263,     0,   265,     0,     0,   267,   268,   269,     0,     0,
-     270,   271,   272,   273,   274,   509,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   294,     0,   296,   297,   298,   299,
-     300,     0,   301,   302,     0,   304,     0,   305,   306,   307,
-     308,   309,   310,     0,   311,   312,     0,     0,   313,   314,
-     315,     0,     0,   316,   317,     0,   319,     0,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,     0,
-     332,   333,   334,   335,   336,   337,   338,   339,   340,     0,
-     341,   342,   343,   344,   345,   346,     0,   347,   348,   349,
-     350,   351,   352,   353,   354,     0,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,     0,
-     368,   369,     0,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,     0,   386,
-     387,   388,   389,   390,     0,   392,   393,   394,   395,   396,
-       0,   398,   399,   400,   401,     0,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   511,   415,
-     416,   417,     0,   418,   419,     0,   420,     0,   422,   423,
-     424,   425,   426,     0,   427,   428,     0,     0,   429,   430,
-     431,   432,   433,     0,   434,   435,   436,   437,   438,   439,
-     440,   441,     0,     0,   442,   443,   444,   445,   446,     0,
-       0,   448,   449,   450,   451,   452,   453,   454,     0,   455,
-       0,   457,   458,   459,   460,   461,     0,     0,   462,     0,
-       0,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-     482,   483,   506,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,     0,  2381,     0,   105,   106,
-       0,   107,   108,   109,     0,   111,   112,   113,   114,   115,
-       0,   117,   118,     0,   119,   120,   121,   122,   123,   124,
-       0,     0,   125,   126,   127,   128,   129,     0,   130,   131,
-     132,   133,   134,     0,     0,     0,   136,   137,   138,   139,
-     140,   141,     0,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,     0,   153,   154,   155,     0,     0,
-       0,     0,     0,     0,     0,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,     0,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   185,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   204,     0,   205,     0,
-     206,   207,   208,   209,     0,   210,     0,   211,     0,     0,
-       0,   214,   215,   508,     0,   218,     0,   219,     0,   220,
-     221,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-       0,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,     0,   243,   244,   245,   246,   247,
-     248,   249,   250,     0,   251,     0,   252,     0,     0,   255,
-       0,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-       0,   265,     0,     0,   267,   268,   269,     0,     0,   270,
-     271,   272,   273,   274,   509,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,     0,   296,   297,   298,   299,   300,
-       0,   301,   302,     0,   304,     0,   305,   306,   307,   308,
-     309,   310,     0,   311,   312,     0,     0,   313,   314,   315,
-       0,     0,   316,   317,     0,   319,     0,   321,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   350,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,     0,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,     0,   392,   393,   394,   395,   396,     0,
-     398,   399,   400,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   511,   415,   416,
-     417,     0,   418,   419,     0,   420,     0,   422,   423,   424,
-     425,   426,     0,   427,   428,     0,     0,   429,   430,   431,
-     432,   433,     0,   434,   435,   436,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,     0,     0,
-     448,   449,   450,   451,   452,   453,   454,     0,   455,     0,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   506,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    94,    95,
-      96,    97,    98,    99,   100,   101,     0,   102,   103,   104,
-       0,     0,     0,     0,     0,  2395,     0,   105,   106,     0,
-     107,   108,   109,     0,   111,   112,   113,   114,   115,     0,
-     117,   118,     0,   119,   120,   121,   122,   123,   124,     0,
-       0,   125,   126,   127,   128,   129,     0,   130,   131,   132,
-     133,   134,     0,     0,     0,   136,   137,   138,   139,   140,
-     141,     0,   143,   144,   145,     0,   146,   147,   148,   149,
-     150,   151,     0,     0,   153,   154,   155,     0,     0,     0,
-       0,     0,     0,     0,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,     0,   171,     0,   172,   173,   174,
-     175,   176,   177,     0,   178,   179,   180,   181,   182,     0,
-       0,   183,   184,   185,   186,   187,     0,   188,   189,   190,
-       0,   191,   192,   193,     0,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,     0,   205,     0,   206,
-     207,   208,   209,     0,   210,     0,   211,     0,     0,     0,
-     214,   215,   508,     0,   218,     0,   219,     0,   220,   221,
-     222,     0,   223,   224,   225,   226,   227,   228,   229,     0,
-     231,   232,   233,   234,     0,   235,   236,   237,   238,   239,
-     240,     0,   241,     0,   243,   244,   245,   246,   247,   248,
-     249,   250,     0,   251,     0,   252,     0,     0,   255,     0,
-     257,   258,   259,   260,   261,   262,     0,     0,   263,     0,
-     265,     0,     0,   267,   268,   269,     0,     0,   270,   271,
-     272,   273,   274,   509,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   294,     0,   296,   297,   298,   299,   300,     0,
-     301,   302,     0,   304,     0,   305,   306,   307,   308,   309,
-     310,     0,   311,   312,     0,     0,   313,   314,   315,     0,
-       0,   316,   317,     0,   319,     0,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,     0,   332,   333,
-     334,   335,   336,   337,   338,   339,   340,     0,   341,   342,
-     343,   344,   345,   346,     0,   347,   348,   349,   350,   351,
-     352,   353,   354,     0,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,     0,   368,   369,
-       0,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,     0,   386,   387,   388,
-     389,   390,     0,   392,   393,   394,   395,   396,     0,   398,
-     399,   400,   401,     0,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   511,   415,   416,   417,
-       0,   418,   419,     0,   420,     0,   422,   423,   424,   425,
-     426,     0,   427,   428,     0,     0,   429,   430,   431,   432,
-     433,     0,   434,   435,   436,   437,   438,   439,   440,   441,
-       0,     0,   442,   443,   444,   445,   446,     0,     0,   448,
-     449,   450,   451,   452,   453,   454,     0,   455,     0,   457,
-     458,   459,   460,   461,     0,     0,   462,     0,     0,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
-     506,     0,   588,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,     0,   111,   112,   113,   114,   115,     0,   117,
-     118,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   127,   128,   129,     0,   130,   131,   132,   133,
-     134,     0,     0,     0,   136,   137,   138,   139,   140,   141,
-       0,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,     0,   153,   154,   155,     0,     0,     0,     0,
-       0,     0,     0,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,     0,   205,     0,   206,   207,
-     208,   209,     0,   210,     0,   211,     0,     0,     0,   214,
-     215,   508,     0,   218,     0,   219,     0,   220,   221,   222,
-       0,   223,   224,   225,   226,   227,  2557,   229,     0,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,     0,   243,   244,   245,   246,   247,   248,   249,
-     250,     0,   251,     0,   252,     0,     0,   255,     0,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,     0,   265,
-       0,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,   509,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,     0,   296,   297,   298,   299,   300,     0,   301,
-     302,     0,   304,     0,   305,   306,   307,   308,   309,   310,
-       0,   311,   312,     0,     0,   313,   314,   315,     0,     0,
-     316,   317,     0,   319,     0,   321,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   350,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,     0,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,     0,   392,   393,   394,   395,   396,     0,   398,   399,
-     400,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   511,   415,   416,   417,     0,
-     418,   419,     0,   420,     0,   422,   423,   424,   425,   426,
-       0,   427,   428,     0,     0,   429,   430,   431,   432,   433,
-       0,   434,   435,   436,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,     0,     0,   448,   449,
-     450,   451,   452,   453,   454,     0,   455,     0,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   506,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    94,    95,    96,    97,
-      98,    99,   100,   101,     0,   102,   103,   104,     0,     0,
-       0,     0,     0,     0,     0,   105,   106,     0,   107,   108,
-     109,     0,   111,   112,   113,   114,   115,     0,   117,   118,
-       0,   119,   120,   121,   122,   123,   124,     0,     0,   125,
-     126,   127,   128,   129,     0,   130,   131,   132,   133,   134,
-       0,     0,     0,   136,   137,   138,   139,   140,   141,     0,
-     143,   144,   145,     0,   146,   147,   148,   149,   150,   151,
-       0,     0,   153,   154,   155,     0,     0,     0,     0,     0,
-       0,     0,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,     0,   171,     0,   172,   173,   174,   175,   176,
-     177,     0,   178,   179,   180,   181,   182,     0,     0,   183,
-     184,   185,   186,   187,     0,   188,   189,   190,     0,   191,
-     192,   193,     0,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,     0,   205,     0,   206,   207,   208,
-     209,     0,   210,     0,   211,     0,     0,     0,   214,   215,
-     508,     0,   218,     0,   219,     0,   220,   221,   222,     0,
-     223,   224,   225,   226,   227,   228,   229,     0,   231,   232,
-     233,   234,     0,   235,   236,   237,   238,   239,   240,     0,
-     241,     0,   243,   244,   245,   246,   247,   248,   249,   250,
-       0,   251,     0,   252,     0,     0,   255,     0,   257,   258,
-     259,   260,   261,   262,     0,     0,   263,     0,   265,     0,
-       0,   267,   268,   269,     0,     0,   270,   271,   272,   273,
-     274,   509,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     294,     0,   296,   297,   298,   299,   300,     0,   301,   302,
-       0,   304,     0,   305,   306,   307,   308,   309,   310,     0,
-     311,   312,     0,     0,   313,   314,   315,     0,     0,   316,
-     317,     0,   319,     0,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,     0,   332,   333,   334,   335,
-     336,   337,   338,   339,   340,     0,   341,   342,   343,   344,
-     345,   346,     0,   347,   348,   349,   350,   351,   352,   353,
-     354,     0,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,     0,   368,   369,     0,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,     0,   386,   387,   388,   389,   390,
-       0,   392,   393,   394,   395,   396,     0,   398,   399,   400,
-     401,     0,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   511,   415,   416,   417,     0,   418,
-     419,     0,   420,     0,   422,   423,   424,   425,   426,     0,
-     427,   428,     0,     0,   429,   430,   431,   432,   433,     0,
-     434,   435,   436,   437,   438,   439,   440,   441,     0,     0,
-     442,   443,   444,   445,   446,     0,     0,   448,   449,   450,
-     451,   452,   453,   454,     0,   455,     0,   457,   458,   459,
-     460,   461,     0,     0,   462,     0,     0,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,   482,   483,   506,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,     0,     0,     0,   105,   106,     0,   107,   108,   109,
-       0,   111,   112,   113,   114,   115,     0,   117,   118,     0,
-     119,   120,   121,   122,   123,   124,     0,     0,   125,   126,
-     127,   128,   129,     0,   130,   131,   132,   133,   134,     0,
-       0,     0,   136,   137,   138,   139,   140,   141,     0,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-       0,   153,   154,   155,     0,     0,     0,     0,     0,     0,
-       0,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,     0,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     185,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   204,     0,   205,     0,   206,   207,   208,   209,
-       0,   210,     0,   211,     0,     0,     0,   214,   215,   508,
-       0,   575,     0,   219,     0,   220,   221,   222,     0,   223,
-     224,   225,   226,   227,   228,   229,     0,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-       0,   243,   244,   245,   246,   247,   248,   249,   250,     0,
-     251,     0,   252,     0,     0,   255,     0,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,     0,   265,     0,     0,
-     267,   268,   576,     0,     0,   270,   271,   272,   273,   274,
-     509,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-       0,   296,   297,   298,   299,   300,     0,   301,   302,     0,
-     304,     0,   305,   306,   307,   308,   309,   310,     0,   311,
-     312,     0,     0,   313,   314,   315,     0,     0,   316,   317,
-       0,   319,     0,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   350,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,     0,   371,   372,
-     373,   374,   375,   376,   377,   378,   577,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   578,     0,
-     392,   393,   394,   395,   396,     0,   398,   399,   400,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   511,   415,   416,   417,     0,   418,   419,
-       0,   420,     0,   422,   423,   424,   425,   426,     0,   579,
-     428,     0,     0,   429,   430,   431,   432,   433,     0,   434,
-     435,   436,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,     0,     0,   448,   449,   450,   451,
-     452,   453,   454,     0,   455,     0,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   506,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    94,    95,    96,    97,    98,    99,
-     100,   101,     0,   102,   103,   104,     0,     0,     0,     0,
-       0,     0,     0,   105,   106,     0,   107,   108,   109,     0,
-     111,   112,   113,   114,   115,     0,   117,   118,     0,   119,
-     120,   121,   122,   123,   124,     0,     0,   125,   126,   127,
-     128,   129,     0,   130,   131,   132,   133,   134,     0,     0,
-       0,   136,   137,   138,   139,   140,   141,     0,   143,   144,
-     145,     0,   146,   147,   148,   149,   150,   151,     0,     0,
-     153,   154,   155,     0,     0,     0,     0,     0,     0,     0,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-       0,   171,     0,   172,   173,   174,   175,   176,   177,     0,
-     178,   179,   180,   181,   182,     0,     0,   183,   184,   185,
-     186,   187,     0,   188,   189,   190,     0,   191,   192,   193,
-       0,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,     0,   205,     0,   206,   207,   208,   209,     0,
-     210,     0,   211,     0,     0,     0,   214,   215,   508,     0,
-     218,     0,   219,     0,   220,   221,   222,     0,   223,   224,
-     225,   226,   227,   228,   229,     0,   231,   232,   233,   234,
-       0,   235,   236,   237,   238,   239,   240,     0,   241,     0,
-     243,   244,   245,   246,   247,   248,   249,   250,     0,   251,
-       0,   252,     0,     0,   255,     0,   257,   258,   259,   260,
-     261,   262,     0,     0,   263,     0,   265,     0,     0,   267,
-     268,   269,     0,     0,   270,   271,   272,   273,   274,   509,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,   287,   288,   289,   290,   291,   292,   293,   294,     0,
-     296,   297,   298,   299,   300,     0,   301,   302,     0,   304,
-       0,   305,   306,   307,   308,   309,   310,     0,   311,   312,
-       0,     0,   313,   314,   315,     0,     0,   316,   317,     0,
-     319,     0,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,     0,   332,   333,   334,   335,   336,   337,
-     338,   339,   340,     0,   341,   342,   343,   344,   345,   346,
-       0,   347,   348,   349,   350,   351,   352,   598,   354,     0,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,     0,   368,   369,     0,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,   385,     0,   386,   387,   388,   389,   390,     0,   392,
-     393,   394,   395,   396,     0,   398,   399,   400,   401,     0,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   511,   415,   416,   417,     0,   418,   419,     0,
-     420,     0,   422,   423,   424,   425,   426,     0,   427,   428,
-       0,     0,   429,   430,   431,   432,   433,     0,   434,   435,
-     436,   437,   438,   439,   440,   441,     0,     0,   442,   443,
-     444,   445,   446,     0,     0,   448,   449,   450,   451,   452,
-     453,   454,     0,   455,     0,   457,   458,   459,   460,   461,
-       0,     0,   462,     0,     0,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,   482,   483,   506,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,     0,
-       0,     0,   105,   106,     0,   107,   108,   109,     0,   111,
-     112,   113,   114,   115,     0,   117,   118,     0,   119,   120,
-     121,   122,   123,   124,     0,     0,   125,   126,   127,   128,
-     129,     0,   130,   131,   132,   133,   134,     0,     0,     0,
-     136,   137,   138,   139,   140,   141,     0,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,     0,   153,
-     154,   155,     0,     0,     0,     0,     0,     0,     0,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,     0,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   185,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
-     204,     0,   205,     0,   206,   207,   208,   209,     0,   210,
-       0,   211,     0,     0,     0,   214,   215,   508,     0,   218,
-       0,   219,     0,   220,   221,   222,     0,   223,   224,   225,
-     226,   227,   652,   229,     0,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,     0,   243,
-     244,   245,   246,   247,   248,   249,   250,     0,   251,     0,
-     252,     0,     0,   255,     0,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,     0,   265,     0,     0,   267,   268,
-     269,     0,     0,   270,   271,   272,   273,   274,   509,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,     0,   296,
-     297,   298,   299,   300,     0,   301,   302,     0,   304,     0,
-     305,   306,   307,   308,   309,   310,     0,   311,   312,     0,
-       0,   313,   314,   315,     0,     0,   316,   317,     0,   319,
-       0,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   350,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,     0,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,     0,   392,   393,
-     394,   395,   396,     0,   398,   399,   400,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   511,   415,   416,   417,     0,   418,   419,     0,   420,
-       0,   422,   423,   424,   425,   426,     0,   427,   428,     0,
-       0,   429,   430,   431,   432,   433,     0,   434,   435,   436,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,     0,     0,   448,   449,   450,   451,   452,   453,
-     454,     0,   455,     0,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   506,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    94,    95,    96,    97,    98,    99,   100,   101,
-       0,   102,   103,   104,     0,     0,     0,     0,     0,     0,
-       0,   105,   106,     0,   107,   108,   109,     0,   111,   112,
-     113,   114,   115,     0,   117,   118,     0,   119,   120,   121,
-     122,   123,   124,     0,     0,   125,   126,   127,   128,   129,
-       0,   130,   131,   132,   133,   134,     0,     0,     0,   136,
-     137,   138,   139,   140,   141,     0,   143,   144,   145,     0,
-     146,   147,   148,   149,   150,   151,     0,     0,   153,   154,
-     155,     0,     0,     0,     0,     0,     0,     0,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,     0,   171,
-       0,   172,   173,   174,   175,   176,   177,     0,   178,   179,
-     180,   181,   182,     0,     0,   183,   184,   185,   186,   187,
-       0,   188,   189,   190,     0,   191,   192,   193,     0,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-       0,   205,     0,   206,   207,   208,   209,     0,   210,     0,
-     211,     0,     0,     0,   214,   215,   508,     0,   218,     0,
-     219,     0,   220,   221,   222,     0,   223,   224,   225,   226,
-     227,   748,   229,     0,   231,   232,   233,   234,     0,   235,
-     236,   237,   238,   239,   240,     0,   241,     0,   243,   244,
-     245,   246,   247,   248,   249,   250,     0,   251,     0,   252,
-       0,     0,   255,     0,   257,   258,   259,   260,   261,   262,
-       0,     0,   263,     0,   265,     0,     0,   267,   268,   269,
-       0,     0,   270,   271,   272,   273,   274,   509,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   294,     0,   296,   297,
-     298,   299,   300,     0,   301,   302,     0,   304,     0,   305,
-     306,   307,   308,   309,   310,     0,   311,   312,     0,     0,
-     313,   314,   315,     0,     0,   316,   317,     0,   319,     0,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,     0,   332,   333,   334,   335,   336,   337,   338,   339,
-     340,     0,   341,   342,   343,   344,   345,   346,     0,   347,
-     348,   349,   350,   351,   352,   353,   354,     0,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,     0,   368,   369,     0,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-       0,   386,   387,   388,   389,   390,     0,   392,   393,   394,
-     395,   396,     0,   398,   399,   400,   401,     0,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     511,   415,   416,   417,     0,   418,   419,     0,   420,     0,
-     422,   423,   424,   425,   426,     0,   427,   428,     0,     0,
-     429,   430,   431,   432,   433,     0,   434,   435,   436,   437,
-     438,   439,   440,   441,     0,     0,   442,   443,   444,   445,
-     446,     0,     0,   448,   449,   450,   451,   452,   453,   454,
-       0,   455,     0,   457,   458,   459,   460,   461,     0,     0,
-     462,     0,     0,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,   482,   483,   506,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,     0,     0,     0,
-     105,   106,     0,   107,   108,   109,     0,   111,   112,   113,
-     114,   115,     0,   117,   118,     0,   119,   120,   121,   122,
-     123,   124,     0,     0,   125,   126,   127,   128,   129,     0,
-     130,   131,   132,   133,   134,     0,     0,     0,   136,   137,
-     138,   139,   140,   141,     0,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,     0,   153,   154,   155,
-       0,     0,     0,     0,     0,     0,     0,   161,   162,   163,
-     164,   165,   166,   167,   168,   169,   170,     0,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   185,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   198,   199,   200,   201,   202,   203,   204,     0,
-     205,     0,   206,   207,   208,   209,     0,   210,     0,   211,
-       0,     0,     0,   214,   215,   508,     0,   218,     0,   219,
-       0,   220,   221,   222,     0,   223,   224,   225,   226,   227,
-     751,   229,     0,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,     0,   243,   244,   245,
-     246,   247,   248,   249,   250,     0,   251,     0,   252,     0,
-       0,   255,     0,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,     0,   265,     0,     0,   267,   268,   269,     0,
-       0,   270,   271,   272,   273,   274,   509,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,     0,   296,   297,   298,
-     299,   300,     0,   301,   302,     0,   304,     0,   305,   306,
-     307,   308,   309,   310,     0,   311,   312,     0,     0,   313,
-     314,   315,     0,     0,   316,   317,     0,   319,     0,   321,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-       0,   332,   333,   334,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,   348,
-     349,   350,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,     0,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,     0,   392,   393,   394,   395,
-     396,     0,   398,   399,   400,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   511,
-     415,   416,   417,     0,   418,   419,     0,   420,     0,   422,
-     423,   424,   425,   426,     0,   427,   428,     0,     0,   429,
-     430,   431,   432,   433,     0,   434,   435,   436,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-       0,     0,   448,   449,   450,   451,   452,   453,   454,     0,
-     455,     0,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   506,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      94,    95,    96,    97,    98,    99,   100,   101,     0,   102,
-     103,   104,     0,     0,     0,     0,     0,     0,     0,   105,
-     106,     0,   107,   108,   109,     0,   111,   112,   113,   114,
-     115,     0,   117,   118,     0,   119,   120,   121,   122,   123,
-     124,     0,     0,   125,   126,   127,   128,   129,     0,   130,
-     131,   132,   133,   134,     0,     0,     0,   136,   137,   138,
-     139,   140,   141,     0,   143,   144,   145,     0,   146,   147,
-     148,   149,   150,   151,     0,     0,   153,   154,   155,     0,
-       0,     0,     0,     0,     0,     0,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,     0,   171,     0,   172,
-     173,   174,   175,   176,   177,     0,   178,   179,   180,   181,
-     182,     0,     0,   183,   184,   185,   186,   187,     0,   188,
-     189,   190,     0,   191,   192,   193,     0,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,     0,   205,
-       0,   206,   207,   208,   209,     0,   210,     0,   211,     0,
-       0,     0,   214,   215,   508,     0,   218,     0,   219,     0,
-     220,   221,   222,     0,   223,   224,   225,   226,   227,   754,
-     229,     0,   231,   232,   233,   234,     0,   235,   236,   237,
-     238,   239,   240,     0,   241,     0,   243,   244,   245,   246,
-     247,   248,   249,   250,     0,   251,     0,   252,     0,     0,
-     255,     0,   257,   258,   259,   260,   261,   262,     0,     0,
-     263,     0,   265,     0,     0,   267,   268,   269,     0,     0,
-     270,   271,   272,   273,   274,   509,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   294,     0,   296,   297,   298,   299,
-     300,     0,   301,   302,     0,   304,     0,   305,   306,   307,
-     308,   309,   310,     0,   311,   312,     0,     0,   313,   314,
-     315,     0,     0,   316,   317,     0,   319,     0,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,     0,
-     332,   333,   334,   335,   336,   337,   338,   339,   340,     0,
-     341,   342,   343,   344,   345,   346,     0,   347,   348,   349,
-     350,   351,   352,   353,   354,     0,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,     0,
-     368,   369,     0,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,     0,   386,
-     387,   388,   389,   390,     0,   392,   393,   394,   395,   396,
-       0,   398,   399,   400,   401,     0,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   511,   415,
-     416,   417,     0,   418,   419,     0,   420,     0,   422,   423,
-     424,   425,   426,     0,   427,   428,     0,     0,   429,   430,
-     431,   432,   433,     0,   434,   435,   436,   437,   438,   439,
-     440,   441,     0,     0,   442,   443,   444,   445,   446,     0,
-       0,   448,   449,   450,   451,   452,   453,   454,     0,   455,
-       0,   457,   458,   459,   460,   461,     0,     0,   462,     0,
-       0,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-     482,   483,   506,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-      95,    96,    97,    98,    99,   100,   101,     0,   102,   103,
-     104,     0,     0,     0,     0,     0,     0,     0,   105,   106,
-       0,   107,   108,   109,     0,   111,   112,   113,   114,   115,
-       0,   117,   118,     0,   119,   120,   121,   122,   123,   124,
-       0,     0,   125,   126,   127,   128,   129,     0,   130,   131,
-     132,   133,   134,     0,     0,     0,   136,   137,   138,   139,
-     140,   141,     0,   143,   144,   145,     0,   146,   147,   148,
-     149,   150,   151,     0,     0,   153,   154,   155,     0,     0,
-       0,     0,     0,     0,     0,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,     0,   171,     0,   172,   173,
-     174,   175,   176,   177,     0,   178,   179,   180,   181,   182,
-       0,     0,   183,   184,   185,   186,   187,     0,   188,   189,
-     190,     0,   191,   192,   193,     0,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   204,     0,   205,     0,
-     206,   207,   208,   209,     0,   210,     0,   211,     0,     0,
-       0,   214,   215,   508,     0,   218,     0,   219,     0,   220,
-     221,   222,     0,   223,   224,   225,   226,   227,   228,   229,
-       0,   231,   232,   233,   234,     0,   235,   236,   237,   238,
-     239,   240,     0,   241,     0,   243,   244,   245,   246,   247,
-     248,   249,   250,     0,   251,     0,   252,     0,     0,   255,
-       0,   257,   258,   259,   260,   261,   262,     0,     0,   263,
-       0,   265,     0,     0,   267,   268,   269,     0,     0,   270,
-     271,   272,   273,   274,   509,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,     0,   296,   297,   298,   299,   300,
-       0,   301,   302,     0,   304,     0,   305,   306,   307,   308,
-     309,   310,     0,   311,   312,     0,     0,   313,   314,   315,
-       0,     0,   316,   317,     0,   319,     0,   321,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,     0,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,     0,   341,
-     342,   343,   344,   345,   346,     0,   347,   348,   349,   350,
-     351,   352,   353,   354,     0,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,     0,   368,
-     369,     0,   371,   372,   373,   374,   375,   376,   377,   378,
-     577,   380,   381,   382,   383,   384,   385,     0,   386,   387,
-     388,   389,   390,     0,   392,   393,   394,   395,   396,     0,
-     398,   399,   400,   401,     0,   402,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   511,   415,   416,
-     417,     0,   418,   419,     0,   420,     0,   422,   423,   424,
-     425,   426,     0,   579,   428,     0,     0,   429,   430,   431,
-     432,   433,     0,   434,   435,   436,   437,   438,   439,   440,
-     441,     0,     0,   442,   443,   444,   445,   446,     0,     0,
-     448,   449,   450,   451,   452,   453,   454,     0,   455,     0,
-     457,   458,   459,   460,   461,     0,     0,   462,     0,     0,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   506,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    94,    95,
-      96,    97,    98,    99,   100,   101,     0,   102,   103,   104,
-       0,     0,     0,     0,     0,  1437,     0,   105,   106,     0,
-     107,   108,   109,     0,   111,   112,   113,   114,   115,     0,
-     117,   118,     0,   119,   120,   121,   122,   123,   124,     0,
-       0,   125,   126,   127,   128,   129,     0,   130,   131,   132,
-     133,   134,     0,     0,     0,   136,   137,   138,   139,   140,
-     141,     0,   143,   144,   145,     0,   146,   147,   148,   149,
-     150,   151,     0,     0,   153,   154,   155,     0,     0,     0,
-       0,     0,     0,     0,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,     0,   171,     0,   172,   173,   174,
-     175,   176,   177,     0,   178,   179,   180,   181,   182,     0,
-       0,   183,   184,   185,   186,   187,     0,   188,   189,   190,
-       0,   191,   192,   193,     0,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,     0,   205,     0,   206,
-     207,   208,   209,     0,   210,     0,   211,     0,     0,     0,
-     214,   215,   508,     0,   218,     0,   219,     0,   220,   221,
-     222,     0,   223,   224,   225,   226,   227,   228,   229,     0,
-     231,   232,   233,   234,     0,   235,   236,   237,   238,   239,
-     240,     0,   241,     0,   243,   244,   245,   246,   247,   248,
-     249,   250,     0,   251,     0,   252,     0,     0,   255,     0,
-     257,   258,   259,   260,   261,   262,     0,     0,   263,     0,
-     265,     0,     0,   267,   268,   269,     0,     0,   270,   271,
-     272,   273,   274,   509,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   294,     0,   296,   297,   298,   299,   300,     0,
-     301,   302,     0,   304,     0,   305,   306,   307,   308,   309,
-     310,     0,   311,   312,     0,     0,   313,   314,   315,     0,
-       0,   316,   317,     0,   319,     0,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,     0,   332,   333,
-     334,   335,   336,   337,   338,   339,   340,     0,   341,   342,
-     343,   344,   345,   346,     0,   347,   348,   349,   350,   351,
-     352,   353,   354,     0,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,     0,   368,   369,
-       0,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,     0,   386,   387,   388,
-     389,   390,     0,     0,   393,   394,   395,   396,     0,   398,
-     399,   400,   401,     0,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   511,   415,   416,   417,
-       0,   418,   419,     0,   420,     0,   422,   423,   424,   425,
-     426,     0,   427,   428,     0,     0,   429,   430,   431,   432,
-     433,     0,   434,   435,   436,   437,   438,   439,   440,   441,
-       0,     0,   442,   443,   444,   445,   446,     0,     0,   448,
-     449,   450,   451,   452,   453,   454,     0,   455,     0,   457,
-     458,   459,   460,   461,     0,     0,   462,     0,     0,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
-     506,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,     0,   111,   112,   113,   114,   115,     0,   117,
-     118,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   127,   128,   129,     0,   130,   131,   132,   133,
-     134,     0,     0,     0,   136,   137,   138,   139,   140,   141,
-       0,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,     0,   153,   154,   155,     0,     0,     0,     0,
-       0,     0,     0,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   185,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,     0,   205,     0,   206,   207,
-     208,   209,     0,   210,     0,   211,     0,     0,     0,   214,
-     215,   508,     0,   218,     0,   219,     0,   220,   221,   222,
-       0,   223,   224,   225,   226,   227,  1577,   229,     0,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,     0,   243,   244,   245,   246,   247,   248,   249,
-     250,     0,   251,     0,   252,     0,     0,   255,     0,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,     0,   265,
-       0,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,   509,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,     0,   296,   297,   298,   299,   300,     0,   301,
-     302,     0,   304,     0,   305,   306,   307,   308,   309,   310,
-       0,   311,   312,     0,     0,   313,   314,   315,     0,     0,
-     316,   317,     0,   319,     0,   321,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   350,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,     0,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,     0,   392,   393,   394,   395,   396,     0,   398,   399,
-     400,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   511,   415,   416,   417,     0,
-     418,   419,     0,   420,     0,   422,   423,   424,   425,   426,
-       0,   427,   428,     0,     0,   429,   430,   431,   432,   433,
-       0,   434,   435,   436,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,     0,     0,   448,   449,
-     450,   451,   452,   453,   454,     0,   455,     0,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   506,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    94,    95,    96,    97,
-      98,    99,   100,   101,     0,   102,   103,   104,     0,     0,
-       0,     0,     0,     0,     0,   105,   106,     0,   107,   108,
-     109,     0,   111,   112,   113,   114,   115,     0,   117,   118,
-       0,   119,   120,   121,   122,   123,   124,     0,     0,   125,
-     126,   127,   128,   129,     0,   130,   131,   132,   133,   134,
-       0,     0,     0,   136,   137,   138,   139,   140,   141,     0,
-     143,   144,   145,     0,   146,   147,   148,   149,   150,   151,
-       0,     0,   153,   154,   155,     0,     0,     0,     0,     0,
-       0,     0,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,     0,   171,     0,   172,   173,   174,   175,   176,
-     177,     0,   178,   179,   180,   181,   182,     0,     0,   183,
-     184,   185,   186,   187,     0,   188,   189,   190,     0,   191,
-     192,   193,     0,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,     0,   205,     0,   206,   207,   208,
-     209,     0,   210,     0,   211,     0,     0,     0,   214,   215,
-     508,     0,   218,     0,   219,     0,   220,   221,   222,     0,
-     223,   224,   225,   226,   227,  1859,   229,     0,   231,   232,
-     233,   234,     0,   235,   236,   237,   238,   239,   240,     0,
-     241,     0,   243,   244,   245,   246,   247,   248,   249,   250,
-       0,   251,     0,   252,     0,     0,   255,     0,   257,   258,
-     259,   260,   261,   262,     0,     0,   263,     0,   265,     0,
-       0,   267,   268,   269,     0,     0,   270,   271,   272,   273,
-     274,   509,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     294,     0,   296,   297,   298,   299,   300,     0,   301,   302,
-       0,   304,     0,   305,   306,   307,   308,   309,   310,     0,
-     311,   312,     0,     0,   313,   314,   315,     0,     0,   316,
-     317,     0,   319,     0,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,     0,   332,   333,   334,   335,
-     336,   337,   338,   339,   340,     0,   341,   342,   343,   344,
-     345,   346,     0,   347,   348,   349,   350,   351,   352,   353,
-     354,     0,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,     0,   368,   369,     0,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,     0,   386,   387,   388,   389,   390,
-       0,   392,   393,   394,   395,   396,     0,   398,   399,   400,
-     401,     0,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   511,   415,   416,   417,     0,   418,
-     419,     0,   420,     0,   422,   423,   424,   425,   426,     0,
-     427,   428,     0,     0,   429,   430,   431,   432,   433,     0,
-     434,   435,   436,   437,   438,   439,   440,   441,     0,     0,
-     442,   443,   444,   445,   446,     0,     0,   448,   449,   450,
-     451,   452,   453,   454,     0,   455,     0,   457,   458,   459,
-     460,   461,     0,     0,   462,     0,     0,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,   482,   483,   506,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,    95,    96,    97,    98,
-      99,   100,   101,     0,   102,   103,   104,     0,     0,     0,
-       0,     0,     0,     0,   105,   106,     0,   107,   108,   109,
-       0,   111,   112,   113,   114,   115,     0,   117,   118,     0,
-     119,   120,   121,   122,   123,   124,     0,     0,   125,   126,
-     127,   128,   129,     0,   130,   131,   132,   133,   134,     0,
-       0,     0,   136,   137,   138,   139,   140,   141,     0,   143,
-     144,   145,     0,   146,   147,   148,   149,   150,   151,     0,
-       0,   153,   154,   155,     0,     0,     0,     0,     0,     0,
-       0,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,     0,   171,     0,   172,   173,   174,   175,   176,   177,
-       0,   178,   179,   180,   181,   182,     0,     0,   183,   184,
-     185,   186,   187,     0,   188,   189,   190,     0,   191,   192,
-     193,     0,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   204,     0,   205,     0,   206,   207,   208,   209,
-       0,   210,     0,   211,     0,     0,     0,   214,   215,   508,
-       0,   218,     0,   219,     0,   220,   221,   222,     0,   223,
-     224,   225,   226,   227,  1872,   229,     0,   231,   232,   233,
-     234,     0,   235,   236,   237,   238,   239,   240,     0,   241,
-       0,   243,   244,   245,   246,   247,   248,   249,   250,     0,
-     251,     0,   252,     0,     0,   255,     0,   257,   258,   259,
-     260,   261,   262,     0,     0,   263,     0,   265,     0,     0,
-     267,   268,   269,     0,     0,   270,   271,   272,   273,   274,
-     509,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-       0,   296,   297,   298,   299,   300,     0,   301,   302,     0,
-     304,     0,   305,   306,   307,   308,   309,   310,     0,   311,
-     312,     0,     0,   313,   314,   315,     0,     0,   316,   317,
-       0,   319,     0,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,     0,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,     0,   341,   342,   343,   344,   345,
-     346,     0,   347,   348,   349,   350,   351,   352,   353,   354,
-       0,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,     0,   368,   369,     0,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,     0,   386,   387,   388,   389,   390,     0,
-     392,   393,   394,   395,   396,     0,   398,   399,   400,   401,
-       0,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   511,   415,   416,   417,     0,   418,   419,
-       0,   420,     0,   422,   423,   424,   425,   426,     0,   427,
-     428,     0,     0,   429,   430,   431,   432,   433,     0,   434,
-     435,   436,   437,   438,   439,   440,   441,     0,     0,   442,
-     443,   444,   445,   446,     0,     0,   448,   449,   450,   451,
-     452,   453,   454,     0,   455,     0,   457,   458,   459,   460,
-     461,     0,     0,   462,     0,     0,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   506,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    94,    95,    96,    97,    98,    99,
-     100,   101,     0,   102,   103,   104,     0,     0,     0,     0,
-       0,     0,     0,   105,   106,     0,   107,   108,   109,     0,
-     111,   112,   113,   114,   115,     0,   117,   118,     0,   119,
-     120,   121,   122,   123,   124,     0,     0,   125,   126,   127,
-     128,   129,     0,   130,   131,   132,   133,   134,     0,     0,
-       0,   136,   137,   138,   139,   140,   141,     0,   143,   144,
-     145,     0,   146,   147,   148,   149,   150,   151,     0,     0,
-     153,   154,   155,     0,     0,     0,     0,     0,     0,     0,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-       0,   171,     0,   172,   173,   174,   175,   176,   177,     0,
-     178,   179,   180,   181,   182,     0,     0,   183,   184,   185,
-     186,   187,     0,   188,   189,   190,     0,   191,   192,   193,
-       0,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,     0,   205,     0,   206,   207,   208,   209,     0,
-     210,     0,   211,     0,     0,     0,   214,   215,   508,     0,
-     218,     0,   219,     0,   220,   221,   222,     0,   223,   224,
-     225,   226,   227,  1874,   229,     0,   231,   232,   233,   234,
-       0,   235,   236,   237,   238,   239,   240,     0,   241,     0,
-     243,   244,   245,   246,   247,   248,   249,   250,     0,   251,
-       0,   252,     0,     0,   255,     0,   257,   258,   259,   260,
-     261,   262,     0,     0,   263,     0,   265,     0,     0,   267,
-     268,   269,     0,     0,   270,   271,   272,   273,   274,   509,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,   287,   288,   289,   290,   291,   292,   293,   294,     0,
-     296,   297,   298,   299,   300,     0,   301,   302,     0,   304,
-       0,   305,   306,   307,   308,   309,   310,     0,   311,   312,
-       0,     0,   313,   314,   315,     0,     0,   316,   317,     0,
-     319,     0,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,     0,   332,   333,   334,   335,   336,   337,
-     338,   339,   340,     0,   341,   342,   343,   344,   345,   346,
-       0,   347,   348,   349,   350,   351,   352,   353,   354,     0,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,     0,   368,   369,     0,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,   385,     0,   386,   387,   388,   389,   390,     0,   392,
-     393,   394,   395,   396,     0,   398,   399,   400,   401,     0,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   511,   415,   416,   417,     0,   418,   419,     0,
-     420,     0,   422,   423,   424,   425,   426,     0,   427,   428,
-       0,     0,   429,   430,   431,   432,   433,     0,   434,   435,
-     436,   437,   438,   439,   440,   441,     0,     0,   442,   443,
-     444,   445,   446,     0,     0,   448,   449,   450,   451,   452,
-     453,   454,     0,   455,     0,   457,   458,   459,   460,   461,
-       0,     0,   462,     0,     0,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,   482,   483,  2486,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,    95,    96,    97,    98,    99,   100,
-     101,     0,   102,   103,   104,     0,     0,     0,     0,     0,
-       0,     0,   105,   106,     0,   107,   108,   109,  2487,   111,
-     112,   113,     0,   675,  2488,   677,   678,     0,   119,   120,
-     121,   122,   123,   124,     0,     0,   125,   126,   679,   680,
-     129,     0,   130,   131,   132,   133,     0,     0,  2489,     0,
-     136,   137,   138,   139,   140,   141,  2490,   143,   144,   145,
-       0,   146,   147,   148,   149,   150,   151,     0,  2491,   153,
-     154,   155,  2492,  2493,  2494,  2495,     0,     0,  2496,   161,
-     162,   163,   164,   165,   166,   167,   689,   690,   170,     0,
-     171,     0,   172,   173,   174,   175,   176,   177,     0,   178,
-     179,   180,   181,   182,     0,     0,   183,   184,   691,   186,
-     187,     0,   188,   189,   190,     0,   191,   192,   193,     0,
-     194,   195,   196,   197,     0,   199,   200,   201,   202,   203,
-       0,     0,   205,     0,   206,   207,   692,   209,     0,   210,
-       0,   211,  2497,     0,  2498,   214,   215,  2499,  2500,   218,
-       0,   219,     0,     0,     0,   222,     0,   223,   224,   225,
-     226,   227,   228,   229,  2501,   231,   232,   233,   234,     0,
-     235,   236,   237,   238,   239,   240,     0,   241,  2502,     0,
-     244,   245,   246,   247,   248,   699,   700,     0,   701,     0,
-     252,  2503,  2504,   255,  2505,   257,   258,   259,   260,   261,
-     262,     0,     0,   263,  2506,   265,  2507,     0,   267,   268,
-     269,     0,     0,   270,   271,   272,   273,   274,  2700,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   708,  2509,   710,
-     297,   298,   299,     0,     0,   301,   302,  2511,   304,     0,
-       0,   306,   712,   308,   309,   310,     0,   311,   312,     0,
-       0,   313,   314,   315,     0,     0,   316,     0,  2513,   319,
-    2514,     0,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,     0,   332,   333,     0,   335,   336,     0,   338,
-     339,   340,     0,   341,   342,   343,   344,   345,   346,     0,
-     347,   348,   349,   715,   351,   352,   353,   354,     0,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,     0,   368,   369,  2515,   371,   372,   373,     0,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,     0,   386,   387,   388,   389,   390,  2516,   392,     0,
-     394,   395,   396,  2518,   398,   399,   721,   401,     0,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,  2701,   415,     0,   417,     0,   418,   419,     0,   420,
-    2520,   422,   423,   424,   425,   426,     0,   724,   725,     0,
-       0,   429,   430,     0,   432,     0,     0,   434,   435,  2521,
-     437,   438,   439,   440,   441,     0,     0,   442,   443,   444,
-     445,   446,  2522,     0,   448,   449,   450,   451,   452,     0,
-     728,     0,   455,  2523,   457,   458,   459,   460,   461,     0,
-       0,   462,     0,     0,   463,   464,   465,   466,   467,   468,
-     673,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   480,   481,   482,   483,     0,     0,    94,    95,    96,
-      97,    98,    99,   100,   101,     0,   102,   103,   104,     0,
-       0,     0,     0,     0,     0,     0,   105,   106,     0,   107,
-     108,   109,   674,   111,   112,   113,     0,   675,   676,   677,
-     678,     0,   119,   120,   121,   122,   123,   124,     0,     0,
-     125,   126,   679,   680,   129,     0,   130,   131,   132,   133,
-       0,     0,   681,     0,   136,   137,   138,   139,   140,   141,
-     682,   143,   144,   145,     0,   146,   147,   148,   149,   150,
-     151,     0,   683,   153,   154,   155,   684,   685,   686,   687,
-       0,     0,   688,   161,   162,   163,   164,   165,   166,   167,
-     689,   690,   170,     0,   171,     0,   172,   173,   174,   175,
-     176,   177,     0,   178,   179,   180,   181,   182,     0,     0,
-     183,   184,   691,   186,   187,     0,   188,   189,   190,     0,
-     191,   192,   193,     0,   194,   195,   196,   197,     0,   199,
-     200,   201,   202,   203,     0,     0,   205,     0,   206,   207,
-     692,   209,     0,   210,     0,   211,   693,     0,   694,   214,
-     215,     0,   695,   218,     0,   219,     0,     0,     0,   222,
-       0,   223,   224,   225,   226,   227,   228,   229,   697,   231,
-     232,   233,   234,     0,   235,   236,   237,   238,   239,   240,
-       0,   241,   698,     0,   244,   245,   246,   247,   248,   699,
-     700,     0,   701,     0,   252,   702,   703,   255,   704,   257,
-     258,   259,   260,   261,   262,     0,     0,   263,   705,   265,
-     706,     0,   267,   268,   269,     0,     0,   270,   271,   272,
-     273,   274,     0,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   708,   709,   710,   297,   298,   299,     0,     0,   301,
-     302,   711,   304,     0,     0,   306,   712,   308,   309,   310,
-       0,   311,   312,     0,     0,   313,   314,   315,     0,     0,
-     316,     0,   713,   319,   714,     0,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,     0,   332,   333,     0,
-     335,   336,     0,   338,   339,   340,     0,   341,   342,   343,
-     344,   345,   346,     0,   347,   348,   349,   715,   351,   352,
-     353,   354,     0,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,     0,   368,   369,   716,
-     371,   372,   373,     0,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,     0,   386,   387,   388,   389,
-     390,   718,   392,     0,   394,   395,   396,   720,   398,   399,
-     721,   401,     0,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,     0,   415,     0,   417,     0,
-     418,   419,     0,   420,   723,   422,   423,   424,   425,   426,
-       0,   724,   725,     0,     0,   429,   430,     0,   432,     0,
-       0,   434,   435,   726,   437,   438,   439,   440,   441,     0,
-       0,   442,   443,   444,   445,   446,   727,     0,   448,   449,
-     450,   451,   452,     0,   728,     0,   455,   729,   457,   458,
-     459,   460,   461,     0,     0,   462,     0,     0,   463,   464,
-     465,   466,   467,   468,   506,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   480,   481,   482,   483,     0,
-       0,    94,    95,    96,    97,    98,    99,   100,   101,     0,
-     102,   103,   104,     0,     0,     0,     0,     0,     0,     0,
-     105,   106,     0,   107,   108,   109,     0,   111,   112,   113,
-     114,   115,     0,   117,   118,     0,   119,   120,   121,   122,
-     123,   124,     0,     0,   125,   126,   127,   128,   129,     0,
-     130,   131,   132,   133,   134,     0,     0,     0,   136,   137,
-     138,   139,   140,   141,     0,   143,   144,   145,     0,   146,
-     147,   148,   149,   150,   151,     0,     0,   153,   154,   155,
-       0,     0,     0,     0,     0,     0,     0,   161,   162,   163,
-     164,   165,   166,   167,   168,   169,   170,     0,   171,     0,
-     172,   173,   174,   175,   176,   177,     0,   178,   179,   180,
-     181,   182,     0,     0,   183,   184,   185,   186,   187,     0,
-     188,   189,   190,     0,   191,   192,   193,     0,   194,   195,
-     196,   197,   198,   199,   200,   201,   202,   203,   204,     0,
-     205,     0,   206,   207,   208,   209,     0,   210,     0,   211,
-       0,     0,     0,   214,   215,   508,     0,   218,     0,   219,
-       0,   220,   221,   222,     0,   223,   224,   225,   226,   227,
-     228,   229,     0,   231,   232,   233,   234,     0,   235,   236,
-     237,   238,   239,   240,     0,   241,     0,   243,   244,   245,
-     246,   247,   248,   249,   250,     0,   251,     0,   252,     0,
-       0,   255,     0,   257,   258,   259,   260,   261,   262,     0,
-       0,   263,     0,   265,     0,     0,   267,   268,   269,     0,
-       0,   270,   271,   272,   273,   274,   509,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,     0,   296,   297,   298,
-     299,   300,     0,   301,   302,     0,   304,     0,   305,   306,
-     307,   308,   309,   310,     0,   311,   312,     0,     0,   313,
-     314,   315,     0,     0,   316,   317,     0,   319,     0,   321,
-     322,   323,   324,   325,   326,   327,     0,   329,   330,   331,
-       0,   332,   333,   334,   335,   336,   337,   338,   339,   340,
-       0,   341,   342,   343,   344,   345,   346,     0,   347,     0,
-     349,   350,   351,   352,   353,   354,     0,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-       0,   368,   369,     0,   371,   372,   373,   374,     0,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,     0,
-     386,   387,   388,   389,   390,     0,   392,   393,   394,   395,
-     396,     0,   398,   399,   400,   401,     0,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   511,
-     415,   416,   417,     0,   418,   419,     0,   420,     0,   422,
-     423,   424,   425,   426,     0,   427,   428,     0,     0,   429,
-     430,   431,   432,   433,     0,   434,   435,   436,   437,   438,
-     439,   440,   441,     0,     0,   442,   443,   444,   445,   446,
-       0,     0,   448,   449,   450,   451,   452,   453,   454,     0,
-     455,     0,   457,   458,   459,   460,   461,     0,     0,   462,
-       0,     0,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483
-};
-
-static const yytype_int16 yycheck[] =
-{
-       6,     6,   646,   631,   617,   928,    59,     0,     0,     0,
-     501,   749,   597,     0,   752,  1329,   849,   544,  1051,   660,
-    1049,   719,    36,     0,    16,   592,   640,    16,   542,  1225,
-    1443,   929,   725,  1446,  1404,  1709,  1020,    30,   931,  1024,
-     638,  1195,  1870,  1195,     6,   849,   537,  1195,  1195,  1790,
-      61,  1794,  1029,  1026,   947,  1097,     0,    31,  1823,  2220,
-    2220,  1826,  1230,  2247,  1805,    61,  2249,   960,   544,   538,
-     543,   857,    16,  1359,  1360,  1752,   631,  1814,   633,   535,
-     635,  1054,     0,  1866,  2258,  2124,    30,    80,  1914,  1915,
-    1916,    21,    36,  2265,    35,  2076,  1929,     9,  1310,    13,
-      14,     5,     5,   679,   680,    51,  1688,  1689,     5,    13,
-      14,  1693,   549,  1412,     5,     5,    90,    61,   614,     5,
-      74,  2131,    13,    14,     5,     5,     0,    13,    14,   614,
-       5,    59,    13,    14,   710,     5,    80,   651,    13,    14,
-    1462,    76,  2564,    13,    14,     5,     5,     5,     9,  1196,
-       9,   171,    87,  1735,  1736,    13,    14,    20,    21,  1942,
-       5,     5,     5,    41,   968,     5,     9,     5,     5,   535,
-       5,   756,    68,    13,    14,    13,    14,     5,    13,    14,
-       5,     5,     5,     5,     5,    13,    14,     5,    13,    14,
-    1464,     5,     5,     5,     5,    41,     0,     5,   123,   118,
-       5,  1324,   243,     5,  1009,     0,     5,    84,    59,   138,
-      76,    11,   171,  2550,  2736,  2704,    16,  1324,  1324,     3,
-      94,    87,  2532,   916,    11,    59,  2009,  2010,   308,    16,
-       3,     4,     5,  2460,  1038,     4,     9,  1041,  1042,    59,
-       9,  2156,    42,   188,   108,   121,   292,     4,    32,    33,
-     308,   128,     9,   121,   121,    11,  2640,   356,   108,    24,
-      16,    37,   284,   272,  2802,    30,  2618,   116,   162,   136,
-     377,   167,   146,    11,    74,   190,  1062,   357,    16,   118,
-     164,    13,    14,    11,   368,  1218,   160,  1073,    16,   131,
-      94,   165,   286,  2903,    28,   275,   170,   333,   333,    94,
-     876,   877,  2654,   487,    42,   179,    49,   418,    69,   183,
-      11,   535,  2138,   119,    95,  2130,   500,    37,   148,  2554,
-     361,   405,   849,   170,    28,   292,   902,  3035,   116,   856,
-    2188,    35,  2567,   209,  2062,   440,    74,     5,    28,  1037,
-     214,    28,   927,   116,    11,   304,  2385,   109,    35,    16,
-    2389,    28,   463,   719,   460,  2032,  2517,   146,    35,  2187,
-     234,   975,   446,    59,   109,   932,  2376,   197,  3076,   405,
-     405,   136,   119,    74,   268,    42,  2559,  2561,   484,   852,
-      31,  2122,  1315,  2124,  2736,   169,   192,   171,   535,  2773,
-     171,   498,  2702,   498,   961,   436,   498,   131,   174,   498,
-     188,  2184,   382,  2186,    55,  2170,  3016,    74,     0,   283,
-    1333,  2833,   286,   493,   498,  2273,   452,   452,   292,   269,
-     348,   988,   381,   319,   205,   214,   303,   276,  2966,   438,
-     314,   346,   175,   165,  1019,   493,  2663,   276,  1752,   281,
-     221,   131,   215,   970,   971,   192,  1786,  1787,   191,   210,
-     231,   318,   326,   196,   174,  2682,   502,   498,  2040,  2041,
-    2042,  2043,  2044,   501,   237,  2047,  2048,  2049,  2050,  2051,
-    2052,  2053,  2054,  2055,  2056,   349,   498,  2999,   498,  1602,
-    1603,   416,   286,   271,   265,   170,   502,  2722,  2977,  1102,
-     233,   286,   858,  2830,  1601,   719,  1602,   348,  1540,  1484,
-     493,   493,   493,   292,   498,   286,   493,  2422,  1830,  2292,
-    1796,  1825,  2864,  2935,   348,   440,   493,  1564,  1817,  2101,
-    2102,  1017,   991,   442,   402,   290,  1331,   456,   348,   535,
-     544,   405,  1017,   410,    24,   502,  1569,   433,   544,  2713,
-      30,   405,   496,  2704,  2704,   349,   500,   984,  2900,   493,
-     416,   543,   498,   498,   349,   544,   402,  1831,   432,   462,
-    2375,  1205,   438,  2947,   617,   462,   440,   573,   574,   416,
-     438,   352,   719,   269,   502,   586,   341,   489,   490,  2307,
-     345,   484,   498,   457,   498,   459,   460,   484,  2627,   449,
-     586,   597,  1804,  2632,   498,   498,  2635,  1639,  1196,   543,
-     544,   498,   968,  2431,   343,  2438,   595,   498,   498,  2619,
-     375,  2592,   498,   606,   606,   606,   496,   498,   498,   606,
-     500,  1407,   496,   498,   554,   499,   500,   501,   498,   606,
-     636,   637,   638,  1218,   858,   609,   497,   380,   498,   498,
-     498,  1282,   586,   432,  2385,  1450,   136,  2999,  2389,  2832,
-    1226,  1227,   348,   498,   498,   498,   460,   598,   498,   440,
-     498,   498,   606,   498,  2838,   460,   450,  2839,   502,  1324,
-     498,  1037,   450,   498,   498,   498,   498,   498,   443,   375,
-     498,   385,   502,  2420,   498,   498,   498,   498,   606,   552,
-     498,   554,   555,   498,   494,   499,   498,   501,   385,   498,
-    1314,  2936,  1300,   460,   499,   160,   501,   494,   385,  1513,
-     165,   858,   243,   719,   577,   162,   489,   490,  2032,  1523,
-     489,   490,  1526,  2549,   392,   393,   440,   484,  1313,  2768,
-    1315,   416,   489,   490,  1319,   491,   492,   493,   494,   199,
-    1354,  1355,  1198,    94,  2834,   160,    38,  1332,  2932,  2426,
-     756,   489,   490,   491,   492,   493,   494,  1284,  2941,   243,
-     116,   489,   490,   491,   492,   493,   494,  1281,  1224,  2552,
-     250,  1356,  1370,  2113,  2114,  2115,  2116,   243,  1345,   234,
-     227,  1272,  1273,  1239,   498,    60,    24,  1401,  1279,  1575,
-     107,  1624,    30,    68,   131,  1409,   421,  1411,  2084,   199,
-     290,  1969,   487,    24,   404,   395,  1275,  1975,  1284,  2993,
-    1283,   487,  1410,  1037,  1798,   500,  2977,  2977,  1716,   234,
-    1624,  1714,   498,    76,   491,   492,   493,   494,   283,   171,
-     361,   271,  1198,   125,    87,   160,   276,  2665,   131,   439,
-     165,   176,    80,   849,  2934,   243,  1584,   405,    24,    11,
-     856,   857,   858,   223,    30,   345,  1779,   452,  1224,  1225,
-     852,  1894,    68,   205,   454,   158,   364,  1605,   874,  1607,
-      24,  2453,  1610,  1239,   223,  1917,    30,  2618,  3061,   221,
-      42,  1509,  1373,  1688,  1689,   375,  2627,   327,  1693,   231,
-    1037,  2632,  2465,   243,  2635,   361,   460,   903,   462,   269,
-    2473,  2097,   237,  1501,   328,   436,  2220,  1363,   852,   234,
-     116,   160,    74,  2654,   928,   136,   176,   923,   924,   925,
-     269,   927,   928,  1536,  1537,  1538,  1819,  1482,     8,  1902,
-    1735,  1736,   249,   357,   271,   498,    16,    17,    18,    19,
-     257,     5,  3032,   299,   281,   951,   890,  1602,  1603,  1604,
-     462,    24,   436,   443,  1509,   498,   291,    30,   283,   329,
-     136,   361,   237,   361,   970,   971,  1564,   498,   690,   369,
-     436,   347,   484,  1528,  1198,   481,  1953,   237,  1533,  2807,
-     493,  1958,   136,   276,   928,   234,   849,   500,   281,   220,
-     712,  1002,  1003,   856,  1005,  2736,  1581,  1363,  1004,   375,
-    1224,  1225,  1008,  1009,  2586,   405,  1002,  1003,   378,  1005,
-     352,   361,   368,  1019,   498,  1239,   243,   368,   186,   187,
-      24,   118,   996,   745,  2034,   500,    30,  2768,  1519,   378,
-      76,  1037,   498,  1524,   283,   493,     8,  1493,   436,    11,
-     286,    87,   500,  1557,    16,    17,    18,    19,   409,   405,
-     411,  1198,   452,  2063,   405,   150,  1062,     4,  1002,  1003,
-    1629,  1005,     9,   136,  1633,   271,  1635,  1073,   438,   290,
-     276,   934,   255,   256,   409,   481,   411,  1224,  1225,  1053,
-     943,  2755,    65,    66,    32,    33,   436,   255,   256,   438,
-     446,  1097,  1239,   169,   957,   446,  2250,  1624,  2250,  2773,
-     498,   436,  2250,  2250,   460,   968,   203,   970,   971,   460,
-    1637,   491,  2426,   319,   290,     4,   462,  1702,   496,   502,
-       9,   496,   500,  2864,   345,   500,   347,  1493,   484,   335,
-     423,   498,   136,   484,   361,  1873,   290,  1875,   484,  1363,
-    1596,   434,   498,    13,    14,     4,    94,   498,   498,   409,
-       9,   411,   498,  2076,   375,  1740,  2899,  2353,  2740,  2900,
-     333,   131,    13,    14,    95,   341,   888,  2000,  2201,   345,
-       4,  2200,   269,   499,   271,     9,   436,   499,  1701,  1792,
-    1703,  1704,   365,   366,   906,  1641,     5,   341,   158,     8,
-    1196,   345,  1198,   462,   170,    14,   369,   365,   366,   375,
-    2185,   575,   576,  2877,   578,   409,    25,   411,   288,   436,
-      29,   499,  1218,  2242,   502,   484,  1363,   290,  1224,  1225,
-     499,   375,  2199,   502,  2201,  3053,   216,   433,   499,   498,
-    1596,   502,   405,  1239,   440,  2040,  2041,  2042,  2043,  2044,
-     171,    55,  2047,  2048,  2049,  2050,  2051,  2052,  2053,  2054,
-    2055,  2056,  3017,  3018,    13,    14,   499,  3000,  2999,   502,
-     496,  2154,   498,  2394,   500,   498,  2397,   443,   341,  1493,
-     481,   498,   345,   368,   205,  1641,  3019,   220,  1284,   452,
-    1973,  1974,   499,   151,   535,   502,   290,    13,    14,   443,
-     221,  1283,   341,  1937,  1300,  1284,  2101,  2102,    13,    14,
-     231,   271,   375,  1944,   151,  3070,   276,  1313,   151,  1315,
-     405,   281,  1318,  1319,    13,    14,   288,  1310,  1310,  1310,
-      13,    14,  1328,  1310,  1330,  1331,  1332,  1333,  1334,  1335,
-    1336,   151,  3075,  1310,   265,   499,   499,   341,   502,  1283,
-     499,   345,   499,   502,   499,   502,  1493,   502,    13,    14,
-    1356,   446,  1358,   499,    13,    14,   502,  1363,  1364,  1365,
-    1366,  1367,  1368,  1369,  1370,   460,  1310,   498,  1374,  1375,
-     443,   375,  1596,  1379,   409,   499,   411,  1383,   502,   150,
-    1386,  1387,  1388,  1389,  1390,  1391,  1392,  1393,  1394,   484,
-    2704,  1397,    28,  2589,     8,   271,   499,    11,  1404,   502,
-    1998,  1407,    16,   498,  1410,   485,   486,   487,   176,   489,
-     490,   491,   492,   493,   494,   499,  2220,  1641,   502,   500,
-     368,   352,    37,  1429,   499,  2795,    83,   502,    42,   449,
-     499,   199,  1376,   502,   499,    49,   452,   502,  1427,   443,
-      13,    14,  1435,    79,  1450,   499,  2479,  2432,   502,  1596,
-     464,   499,    88,   423,   502,  1461,  1462,   405,   315,   499,
-      74,  1324,   502,   146,   434,  2079,    36,   499,   719,   237,
-     502,   499,    24,  2000,   502,   151,   499,   160,    30,   502,
-     498,   117,   165,  2381,    13,    14,  2071,  1493,   172,   499,
-     498,  1435,   502,  1499,  1641,  1501,  1952,  2395,   446,   498,
-       8,  1992,   450,    11,   499,   259,   260,   502,    16,    17,
-      18,    19,   460,   485,   486,   487,   498,   489,   490,   491,
-     492,   493,   494,   291,   499,   499,   499,   502,   502,   502,
-     144,   214,   499,   299,  1540,   502,   484,  1543,  1544,   499,
-    1546,   499,   502,   498,   502,  2741,  2284,    13,    14,  2163,
-     498,   234,   188,   499,  1417,   151,   502,  2970,  1564,  2972,
-     244,   175,    13,    14,   200,  2021,    13,    14,  2135,  1575,
-     409,  1876,   411,  1878,  2184,  1581,  2186,   191,   286,  2390,
-    1573,  2392,   196,  2039,   136,   611,  1952,   613,    13,    14,
-    1596,   176,    87,   361,    89,   151,    91,   368,    13,    14,
-     283,   151,   368,    13,    14,   343,   535,   858,   405,   292,
-    2066,    13,    14,   498,   199,    13,    14,  2073,  1624,   233,
-      37,  2219,  2235,  2221,   368,    13,    14,    13,    14,  1573,
-     232,  1637,   498,  1639,   405,  1641,  3049,    13,    14,   405,
-    1646,   409,   496,   411,  2285,  1651,    13,    14,  2453,   333,
-     356,   357,   237,   356,   357,  2021,   365,   366,     5,   427,
-       5,   405,   498,  2977,   165,   433,  2470,   498,   436,   356,
-     357,   356,   357,  2039,   288,   446,  1690,   498,     5,     5,
-     446,  2710,  1688,  1689,  1690,   369,   498,  1693,   196,   460,
-     970,   971,   498,   498,   460,  1701,  1702,  1703,  1704,    11,
-    2066,     5,   446,    15,   498,  1711,   291,  2073,   498,  1715,
-     218,    23,  1718,   484,   498,   498,   460,   498,   484,   498,
-     498,   405,    34,    35,   498,   498,  1740,   498,  1952,  1735,
-    1736,  2097,   498,     5,  1740,   498,   498,  2251,   290,   147,
-     484,   498,   498,     9,  2482,  2483,  1690,  2580,  1754,   432,
-     498,  1757,   297,  1759,   498,   391,   461,   502,   394,   216,
-      98,  1624,   502,   499,  2220,  1628,   380,    37,   452,   375,
-     165,   283,   165,  1779,  1637,   281,    88,   232,   498,   416,
-     288,  2586,   498,   502,  1790,  1790,  1037,  2401,    87,   341,
-     719,   416,    55,   345,    55,  1809,  1740,  2021,   416,  1805,
-    1805,   262,  2416,   416,   499,  1952,   507,   416,   460,   151,
-      94,  1804,  1804,  1804,  1758,  2039,   498,  1804,  1824,  2517,
-     500,   271,   271,   375,   409,  2281,   411,  1804,  1790,    37,
-    1774,   498,   498,  1839,  1840,     9,    36,   414,   414,   499,
-     496,   496,  2066,  1805,   416,   416,  1790,   416,   433,  2073,
-     416,   436,  1858,   502,  2220,   456,   498,    11,  2781,   343,
-    1804,  1805,   497,   502,   502,  1809,   507,   414,   482,   498,
-    1876,  1877,  1878,  2097,  2021,   489,   490,   491,   492,   493,
-     494,     6,   504,   416,   276,   179,    11,   498,   161,   170,
-      15,   443,  2039,    37,   499,    20,    21,    22,    23,    24,
-    2704,   498,    27,   440,   214,    30,    31,   502,   378,    34,
-      35,  1917,   223,   287,     8,  2281,   502,    11,   308,  2066,
-     499,   308,    16,    17,    18,    19,  2073,   223,   271,   858,
-     498,   223,   292,   324,   284,  2740,   452,   498,   151,   151,
-      34,   460,    37,   271,   499,  2978,  1952,  1198,   499,   286,
-    2097,   481,   496,   481,   286,    80,  1962,   499,   499,   499,
-    2451,   499,    87,    88,    89,    90,    91,   405,   271,    37,
-      37,   497,   499,  1224,  1225,   499,   499,   485,   486,   487,
-     170,   489,   490,   491,   492,   493,   494,  2353,  1239,   499,
-     499,   502,  1998,   500,  2000,   499,  2220,   499,   481,   494,
-     499,   499,   499,  1996,   170,   499,   499,   499,   499,   498,
-     416,   498,  2018,   498,   154,  2021,   498,   457,   457,  1882,
-    2943,  2027,   446,   502,  2030,  2481,   286,  2033,   487,   483,
-     287,   287,   287,  2039,  2040,  2041,  2042,  2043,  2044,  2683,
-     502,  2047,  2048,  2049,  2050,  2051,  2052,  2053,  2054,  2055,
-    2056,   242,  1996,  2580,  2060,  2061,  2109,  2281,  2064,   438,
-    2066,   416,  2076,   498,  1927,  2071,   271,  2073,   151,   199,
-    2076,   151,   151,  2220,   278,   416,   416,   416,   499,  2085,
-     416,   278,  2088,   497,  2090,   498,    37,   499,   284,   343,
-     460,  2097,  2098,  2107,   589,  2101,  2102,   502,   286,    37,
-    2106,  2107,   151,   499,   151,   276,   142,   170,  1037,    11,
-    2124,   165,  1363,   497,   497,  2481,  2122,  2122,  2124,  2124,
-     502,   499,   499,   498,   218,   170,   621,   499,   499,  2353,
-    2136,   535,  2076,   499,  2281,   499,   146,  2000,   457,   296,
-    2146,   405,  2005,   170,  2007,   502,   179,   499,  2011,  2012,
-     160,  2517,   445,   484,   349,   165,  2162,    85,   287,   151,
-    2122,   174,  2124,  2107,   659,   660,   661,   662,   502,   499,
-     499,    37,    80,  2977,   498,   498,   427,   499,  2122,   499,
-    2124,   499,   498,   498,   497,   502,   170,   440,   502,   407,
-     499,   498,   221,   499,   288,   295,   221,   499,   510,   499,
-     293,   499,   499,   498,   214,    55,  2353,   498,   498,  2215,
-    2808,   183,   499,  2219,  2220,  2221,   487,   499,   460,   499,
-      37,   201,   116,  2589,   234,    37,   223,   539,    82,   498,
-     189,   416,   276,   276,   416,   500,    37,   271,   500,    56,
-     498,   500,  1493,   108,   487,   286,   460,   499,  2704,  2862,
-     500,   500,   500,   500,   500,  2248,   500,  2481,    37,   500,
-     500,   500,  2906,   500,   500,   500,   500,   500,   500,  1198,
-     500,   500,   500,   283,   500,  2281,  2269,   500,  2271,   500,
-     500,   500,   292,   500,   500,   500,   598,  2915,   498,   500,
-     107,   500,  2298,  2517,   500,  1224,  1225,   500,   500,   170,
-    2885,   221,  2887,   459,  2248,   498,   498,    87,   502,   498,
-    1239,   132,   499,   335,   498,   719,  2772,    37,   151,  2775,
-      74,   499,   151,   123,    68,  2269,    37,  2271,   305,   499,
-      74,  2822,    37,   357,  2481,   498,   357,   498,  2704,   499,
-     498,  2347,  2348,    87,   326,  1596,  2352,  2353,   498,   498,
-     502,  2357,    74,   445,  2360,  2361,   498,  2220,   276,  2365,
-     247,   188,   440,   427,   498,  2589,    68,   289,    68,   494,
-    2517,    55,   116,   498,   118,  2741,   501,   498,  2976,  2385,
-    2385,   198,  2245,  2389,  2389,   510,   499,   498,   502,    37,
-    1641,   485,   486,   487,   440,   489,   490,   491,   492,   493,
-     494,   375,   487,   286,   427,  2411,  2772,   269,    37,  2775,
-    2901,   498,   537,   538,   539,   289,   289,   498,   359,   201,
-    2413,  2414,   432,  2385,   499,   499,   499,  2389,   499,   554,
-     286,   286,   249,   498,  1363,     9,   342,   499,   499,  2445,
-     257,  2385,  2589,   121,   438,  2389,   356,  2453,   573,   574,
-     575,   576,   269,   578,   858,    23,    34,   499,   498,   203,
-       9,   499,  2202,   606,   589,  1507,  2472,  2215,  1871,  2413,
-    2414,  2160,  2415,   598,  2900,  2481,   535,   972,  2650,  2973,
-    2704,  2921,  2254,   300,   609,  2475,   496,  3027,  2676,   499,
-     500,  2979,  3020,  2988,  2724,  1864,   621,  2976,  1877,  1024,
-    2259,  2194,   997,  2986,  2219,     8,  1861,  2974,    11,  1998,
-    1224,  2517,  1272,    16,    17,    18,    19,  2741,  2580,  1933,
-    2245,  2977,   990,  1824,  1478,   962,  1012,   271,  1023,  2874,
-     347,    34,   276,  1011,   659,   660,   661,   662,  2895,  1839,
-    3015,  1036,  1450,  2140,  2956,  2408,  2889,  2794,  2772,  1477,
-    2407,  2775,   369,  1805,  1014,  2124,  2769,  2704,  2391,  2376,
-    2122,  2864,  1057,  2863,  1493,  2881,  1324,  2882,     8,  2562,
-    2646,    11,   389,  1324,  2580,   319,    16,    17,    18,    19,
-    2586,  1324,  1324,  2589,  2959,  3003,  2592,  2960,  1716,  1402,
-    1825,   335,  1758,  1546,  2741,  2601,  2602,  1647,   574,  2605,
-    1793,  2411,  1755,  2139,  1938,  2856,  1284,  1637,  2161,  1427,
-      -1,  2977,  2618,  2618,    -1,   996,    -1,  1428,  2562,    -1,
-      -1,  2627,  2627,    -1,    -1,  2772,  2632,  2632,  2775,  2635,
-    2635,    -1,    -1,  1037,    -1,    -1,  2642,  2643,    -1,    -1,
-      -1,    -1,    -1,     8,    -1,    -1,    11,    -1,  2654,  2654,
-    2656,    16,    17,    18,    19,    -1,  2618,    -1,    -1,    -1,
-     719,    -1,    -1,    -1,    -1,  2627,    -1,  1596,  2674,    34,
-    2632,    -1,    -1,  2635,    -1,    -1,    -1,    42,   990,    -1,
-      -1,    -1,   499,  2627,    49,    -1,    -1,    -1,  2632,   433,
-      -1,  2635,  2654,    -1,    -1,    -1,   440,    -1,  2704,    -1,
-      -1,  1952,    -1,    -1,  1199,    -1,    -1,    -1,    -1,    74,
-      -1,    -1,  1641,    -1,    -1,   218,    -1,  2580,    -1,    -1,
-      -1,    -1,  2715,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    2736,  2736,    -1,    -1,  2740,  2741,    -1,   862,    -1,    -1,
-      -1,    -1,    -1,    -1,  2737,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2977,    -1,    -1,    -1,    -1,  2764,    -1,
-      -1,    -1,  2768,  2768,    -1,    -1,  2772,  2781,    -1,  2775,
-    2021,  2715,    -1,    -1,  2736,  2781,    -1,    -1,   218,    -1,
-      -1,    -1,  2645,    -1,    -1,   288,    -1,  1282,  2039,  2795,
-      -1,    -1,  2798,  2737,  1198,    -1,    -1,    -1,    -1,   858,
-      -1,    -1,  2808,    -1,   929,    -1,  2768,  2813,    -1,    -1,
-     175,    51,    -1,    -1,    -1,  2066,    -1,    -1,    -1,    -1,
-    1224,  1225,  2073,    -1,  2768,    -1,   191,    -1,    -1,    -1,
-    2977,   196,    -1,    -1,    -1,  1239,    -1,  2781,    -1,    -1,
-      -1,  2704,    -1,    -1,  2837,    37,  2097,   972,   288,    -1,
-      -1,    -1,    -1,   218,   219,    -1,    96,    -1,  2864,  2864,
-      -1,    -1,    -1,    -1,    56,   990,   991,    -1,   233,    -1,
-      -1,   996,   997,   998,    -1,    -1,    -1,    -1,    -1,  2885,
-      -1,  2887,   122,  2889,    -1,    -1,    -1,  2893,    -1,    -1,
-      -1,    -1,    -1,  2837,  2900,  2900,    -1,    -1,  1023,  1024,
-     140,    -1,  2864,  2896,   144,    -1,   271,    -1,    -1,   274,
-    1405,  1036,    -1,    -1,    -1,   107,    -1,  2923,    -1,    -1,
-      -1,    -1,    -1,   288,    -1,    -1,   166,    -1,  1053,   169,
-      -1,  1426,  1057,  1428,    -1,    -1,    -1,  2943,  2900,    -1,
-      -1,    -1,    -1,    -1,   184,    -1,    -1,    -1,    -1,    -1,
-    2956,    -1,  2896,    -1,    -1,   110,   111,    -1,    -1,  1363,
-      -1,    -1,    -1,    -1,  1276,    -1,  1278,    -1,  2831,  2220,
-    2976,  2977,    -1,     8,    -1,    -1,    11,    -1,  1037,    -1,
-    1475,    16,   485,   486,   487,    -1,   489,   490,   491,   492,
-     493,   494,    -1,  2999,  2999,    -1,  3002,  3003,    -1,  2992,
-      -1,    -1,    -1,    -1,    -1,    -1,   198,    42,    -1,    -1,
-      -1,    -1,    -1,    -1,    49,   380,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1952,    -1,    -1,    -1,    -1,    -1,  3035,
-    2281,   186,   187,    -1,    -1,    -1,   276,  2999,    -1,    74,
-      -1,    -1,    -1,    -1,   284,   485,   486,   487,  2992,   489,
-     490,   491,   492,   493,   494,    -1,    -1,   249,    -1,  1554,
-    1555,    -1,    -1,    -1,    -1,   257,  1191,    -1,    -1,    -1,
-    3076,    -1,    -1,    -1,  1199,    -1,    -1,   269,    -1,    -1,
-      -1,    -1,    -1,  1208,    -1,    -1,    -1,   327,    -1,  1493,
-      -1,    -1,  2021,    -1,    -1,    -1,   251,   252,   253,   254,
-     255,   256,  2353,    -1,   259,   260,    -1,    -1,   300,   144,
-    2039,    -1,    -1,    -1,  2977,    -1,  1241,   482,    -1,    -1,
-     485,   486,   487,    -1,   489,   490,   491,   492,   493,   494,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  2066,    -1,  1198,
-     175,    -1,    -1,    -1,  2073,    -1,    -1,  1272,  1273,    -1,
-    1275,  1276,    -1,  1278,  1279,   347,   191,  1282,    -1,    -1,
-      -1,   196,    -1,    -1,    -1,  1224,  1225,    -1,  2097,    -1,
-      -1,    -1,    -1,  1485,    -1,    -1,    -1,   369,    -1,    -1,
-    1239,    -1,    -1,  1495,    -1,  1497,    -1,    -1,  1500,    -1,
-      -1,    -1,  1596,    -1,  1506,    -1,  1508,   389,   233,    -1,
-      -1,     0,    -1,    -1,  1329,    -1,    -1,    -1,  1520,    -1,
-     365,   366,    -1,  1525,    -1,  1340,    -1,  1529,  1530,  1531,
-    1532,    20,  1534,  1535,    -1,    -1,    -1,    -1,    -1,    -1,
-    2481,    30,    -1,    32,    33,    -1,    -1,  1641,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1373,    48,
-      -1,    -1,    -1,   288,    -1,    37,    -1,    -1,    57,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  2517,    -1,    -1,    -1,
-      69,    -1,    -1,    -1,    56,    -1,    -1,    -1,    -1,  1404,
-    1405,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1784,
-      -1,  2220,    -1,    92,    -1,    94,    -1,    -1,    -1,    -1,
-      -1,  1426,    -1,  1428,  1363,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1437,   112,  1439,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   478,   479,   107,     0,   126,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   136,  2589,    -1,
-      -1,    -1,    -1,   142,    -1,   380,    -1,    -1,    -1,    -1,
-    1475,   150,  2281,   152,   153,    -1,    -1,    -1,    -1,  1484,
-    1485,    -1,    -1,    -1,    -1,    -1,    -1,   166,    -1,    -1,
-    1495,  1496,  1497,  1498,     8,  1500,    -1,    11,    -1,    -1,
-      -1,  1506,    16,  1508,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   174,    -1,  1519,  1520,   195,    -1,    -1,  1524,
-    1525,    -1,    -1,    -1,  1529,  1530,  1531,  1532,    42,  1534,
-    1535,   210,    -1,    -1,    -1,    49,   198,    -1,    -1,    -1,
-      94,    -1,    -1,    -1,  2353,    -1,    -1,    -1,    -1,  1554,
-    1555,  1556,    -1,    -1,  1493,    -1,    -1,   236,    -1,  1934,
-      74,    -1,    -1,    -1,    -1,    -1,  1571,   482,  1943,  1944,
-    1945,    -1,    -1,  2704,   489,   490,   491,   492,   493,   494,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   249,    -1,  1964,
-      -1,    -1,   146,    -1,    -1,   257,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   160,   269,    -1,    -1,
-    2741,   165,    -1,    -1,    -1,    -1,   170,    -1,    -1,  1994,
-      -1,    -1,    -1,    -1,    -1,   179,    -1,    -1,    -1,   183,
-     144,    -1,    -1,    -1,   313,    -1,    -1,   316,   300,    -1,
-      -1,  2772,    -1,    -1,  2775,    -1,    -1,     8,    -1,    -1,
-      11,    -1,    -1,    -1,    -1,    16,    -1,  1596,    -1,    -1,
-     214,   175,    -1,    -1,    -1,    -1,   345,    -1,  1952,    -1,
-      -1,    -1,  2481,    -1,    -1,   354,    -1,   191,    -1,    -1,
-     234,    42,   196,    -1,    -1,   347,    -1,    -1,    49,   368,
-      -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,    -1,    -1,
-     379,    -1,  1641,    -1,  1709,    -1,    -1,   369,  2517,    -1,
-     389,  1716,    -1,    74,    -1,    -1,    -1,    -1,    -1,   233,
-      -1,    -1,   401,    -1,    -1,    -1,   405,   389,    -1,   283,
-      -1,    -1,   286,    -1,    -1,    -1,    -1,  2021,   292,    -1,
-      -1,    -1,    -1,    -1,  2119,  2120,  2121,  1752,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  2039,    -1,    -1,    -1,    -1,
-      -1,    -1,   441,    -1,  1956,    -1,    -1,   446,    -1,    -1,
-      -1,    -1,   326,    -1,   288,    -1,    -1,    -1,    -1,  1784,
-    2589,   460,  2066,   144,    -1,  1790,    -1,    -1,    -1,  2073,
-      -1,    -1,    -1,    -1,    -1,   349,    -1,    -1,    -1,    -1,
-    1805,    -1,    -1,  2178,  1809,   484,    -1,  1812,    -1,  1814,
-      -1,    -1,    -1,  2097,   175,     8,    -1,    -1,    11,   498,
-      -1,    -1,   501,    16,    17,    18,    19,    -1,    -1,    -1,
-     191,    -1,    -1,     8,    -1,   196,    11,    -1,    -1,    -1,
-      -1,    16,    17,    18,    19,    -1,  2977,    -1,    -1,    42,
-      -1,   405,    -1,    -1,    -1,    -1,    49,    -1,    -1,    -1,
-      -1,  1866,    -1,    -1,    -1,    -1,   380,    42,    -1,    -1,
-      -1,    -1,   233,    -1,    49,    -1,    -1,  2252,   432,    -1,
-      -1,    74,    -1,    -1,    -1,    -1,   440,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  2704,    -1,    -1,    -1,    74,
-      -1,    -1,    -1,   457,    -1,   459,   460,    -1,    -1,    -1,
-    2285,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1929,    -1,    -1,   288,    -1,  1934,
-      -1,    -1,  2741,    -1,    -1,    -1,  2220,  1942,  1943,  1944,
-    1945,    -1,   496,    -1,    -1,   499,   500,   501,    -1,    -1,
-      -1,  1956,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1964,
-      -1,    -1,    -1,  2772,    -1,    -1,  2775,    -1,   482,    -1,
-      -1,  1976,    -1,    -1,    -1,   489,   490,   491,   492,   493,
-     494,    -1,   175,    -1,    -1,    -1,    -1,  1992,  2180,  1994,
-      -1,    -1,    -1,  2368,  2369,  2370,  2371,  2281,   191,    -1,
-     175,    -1,    -1,   196,  2009,  2010,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1952,    -1,  2207,   191,    -1,    -1,   380,
-      -1,   196,    -1,    -1,    -1,   218,   219,  2032,    -1,    -1,
-    2222,  2223,  2224,  2225,  2226,  2227,  2228,  2229,  2230,  2231,
-     233,    -1,    -1,   218,   219,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   233,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2353,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   271,    -1,
-       8,   274,  2021,    11,  2459,    -1,    -1,    -1,    16,    17,
-      18,    19,    -1,    -1,    -1,   288,    -1,    -1,    -1,   274,
-    2039,    -1,    -1,     8,    -1,    -1,    11,    -1,    -1,    -1,
-      -1,    16,    -1,   288,  2119,  2120,  2121,  2122,    -1,  2124,
-    2125,   482,    -1,    -1,    -1,  2130,  2131,  2066,   489,   490,
-     491,   492,   493,   494,  2073,    -1,    -1,    42,    -1,    -1,
-      -1,    -1,    -1,    -1,    49,  2337,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    24,    -1,  2160,    -1,    -1,  2097,    30,
-      -1,    -1,     8,    -1,    -1,    11,    37,    -1,  2977,    74,
-      16,    -1,    -1,  2178,    -1,  2180,    -1,    -1,    -1,  2184,
-    2185,  2186,    -1,  2188,    -1,    56,    -1,   380,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    42,  2481,    -1,    -1,
-      -1,    -1,  2207,    49,  2209,   380,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  2222,  2223,  2224,
-    2225,  2226,  2227,  2228,  2229,  2230,  2231,    -1,    74,    -1,
-      -1,    -1,    -1,  2517,    -1,    -1,   107,    -1,    -1,   144,
-     573,   574,  2247,    -1,    -1,    -1,    -1,  2252,    -1,    -1,
-      -1,    -1,    -1,    -1,  2259,    -1,    -1,    -1,    -1,    -1,
-    2452,    -1,    -1,    -1,    -1,   136,    -1,    -1,  2273,    -1,
-     175,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    2285,  2220,    -1,    -1,    -1,    -1,   191,  2292,    -1,   482,
-     218,   196,   485,   486,   487,    -1,   489,   490,   491,   492,
-     493,   494,    -1,   636,   637,  2589,    -1,   482,    -1,    -1,
-     485,   486,   487,    -1,   489,   490,   491,   492,   493,   494,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   198,   233,   175,
-      -1,    -1,  2337,    -1,    -1,    -1,    -1,    -1,  2343,    -1,
-      -1,  2716,  2281,    -1,    -1,   191,    -1,    -1,    -1,    -1,
-     196,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2733,    -1,
-     288,  2366,    -1,  2368,  2369,  2370,  2371,    -1,    -1,    -1,
-    2375,  2376,    -1,  2378,    -1,    -1,  2381,    -1,   249,    -1,
-    2385,    -1,    -1,   288,  2389,    -1,   257,   233,    -1,    -1,
-    2395,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   269,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  2411,    -1,    -1,   849,
-    2415,    -1,    -1,    -1,  2353,  2420,   856,    -1,    -1,   290,
-    2704,  2426,    -1,    -1,    -1,    -1,    -1,  2432,    -1,   300,
-      -1,  2806,    -1,  2438,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   288,    -1,    -1,    -1,  2451,  2452,    -1,    -1,
-      -1,    -1,    -1,    -1,  2459,     8,    -1,  2741,    11,    -1,
-      -1,  2836,    -1,    16,    17,    18,    19,    -1,    -1,    -1,
-     341,  2476,    -1,    -1,   345,   380,   347,    -1,    -1,    -1,
-      -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,  2772,    -1,
-      -1,  2775,    -1,  2685,    -1,    -1,    -1,    -1,   369,    -1,
-      -1,    -1,    -1,   943,   375,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2705,  2706,    -1,    -1,    -1,   389,    -1,
-      -1,    -1,    -1,    -1,   857,    -1,    -1,    -1,   968,  2721,
-     970,   971,    -1,    -1,   380,    -1,    -1,    -1,    -1,    -1,
-      -1,   874,  2481,    -1,    -1,    -1,    -1,  2552,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  2561,   485,   486,   487,
-      -1,   489,   490,   491,   492,   493,   494,    -1,  2573,    -1,
-     903,    -1,   443,    -1,    -1,    -1,    -1,   482,  2517,    -1,
-      -1,    -1,    -1,    -1,   489,   490,   491,   492,   493,   494,
-     923,   924,   925,    -1,    -1,   928,    -1,    -1,  1038,    -1,
-      -1,  1041,  1042,    -1,  2609,  2797,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2618,  2619,    -1,    -1,  2622,   951,    -1,
-    2625,    -1,  2627,    -1,    -1,    -1,    -1,  2632,    -1,    -1,
-    2635,    -1,  2637,    -1,    -1,  2640,   482,    -1,    -1,    -1,
-      -1,    -1,    -1,   489,   490,   491,   492,   493,   494,  2654,
-    2589,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-       0,    -1,    -1,    -1,    -1,   218,    -1,    -1,    -1,    -1,
-      -1,  1004,    -1,    -1,    -1,  1008,  1009,    -1,    -1,    -1,
-    2685,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2977,    -1,    -1,     8,    -1,    -1,    11,
-    2705,  2706,    -1,    15,    16,    17,    18,    19,    -1,    -1,
-      -1,  2716,    -1,  2718,    -1,    -1,  2721,    -1,    -1,    -1,
-      -1,    -1,    34,    -1,    -1,    -1,    -1,    -1,  2733,  1062,
-      42,  2736,    -1,    -1,    -1,   288,    -1,    49,    -1,    -1,
-    1073,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    2755,    -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    74,  2768,  1097,  2704,    -1,    -1,  2773,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1222,    -1,    -1,    -1,  2791,    -1,    -1,    -1,
-    2795,    -1,  2797,  1233,    -1,  1235,    -1,    -1,    -1,    -1,
-      -1,  2806,  2741,    -1,  1244,    -1,   146,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  2822,    -1,    -1,
-     160,  1261,    -1,    -1,    -1,   165,    -1,    -1,    -1,    -1,
-     170,  2836,    -1,  2772,    -1,    -1,  2775,    -1,    -1,   179,
-      -1,    -1,    -1,   183,    -1,    -1,    -1,    -1,    -1,  1289,
-    1290,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2864,
-      -1,    -1,    -1,   175,    -1,    -1,    -1,    -1,  2873,    -1,
-      -1,    -1,  2877,    -1,   214,    -1,  2881,    -1,    -1,   191,
-      -1,  1321,  1322,    -1,   196,  1325,  1326,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   234,  2900,  2901,  2902,  2903,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   218,   219,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   233,    -1,    -1,    -1,    -1,    -1,  2932,    -1,    -1,
-      -1,    -1,   485,   486,   487,    -1,   489,   490,   491,   492,
-     493,   494,  2947,   283,    -1,    -1,   286,    -1,    -1,    -1,
-      -1,    -1,   292,    -1,  2959,    -1,    -1,    -1,    -1,   271,
-      -1,    -1,   274,    -1,    -1,    -1,    -1,    -1,  2973,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   288,    -1,    -1,   291,
-      -1,    -1,    -1,    -1,    -1,  1318,   326,    -1,  2993,    -1,
-      -1,    -1,    -1,    -1,  2999,  1328,    -1,  1330,    -1,    -1,
-    1333,  1334,  1335,  1336,     8,    -1,    -1,    11,    -1,   349,
-    3015,  3016,    16,    17,    18,    19,    -1,    -1,    -1,    -1,
-      -1,  1461,  1462,    -1,    -1,  1358,    -1,    -1,    -1,    -1,
-      34,  1364,  1365,  1366,  1367,  1368,  1369,    -1,  2977,    -1,
-      -1,  1374,  1375,    -1,    -1,    -1,  1379,    -1,    -1,    -1,
-    1383,    -1,    -1,  1386,  1387,  1388,  1389,  1390,  1391,  1392,
-    1393,  1394,    -1,    -1,  1397,   405,    -1,     8,   380,    -1,
-      11,  1404,    -1,  1513,  1407,    16,    17,    18,    19,    -1,
-      -1,    -1,    -1,  1523,    -1,     3,  1526,     5,    -1,    -1,
-      -1,    -1,   432,    -1,    -1,    -1,  1429,    -1,    -1,    -1,
-     440,    42,    -1,    -1,    -1,    -1,    -1,    -1,    49,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   457,    -1,   459,
-     460,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1461,  1462,
-      -1,    -1,    -1,    74,    -1,    -1,    -1,     3,    -1,    -1,
-      -1,    -1,     8,    -1,    -1,    11,    -1,    -1,    -1,    15,
-      16,    17,    18,    19,    -1,    -1,   496,  1597,  1598,   499,
-     500,   501,    -1,    -1,    -1,    -1,    -1,    -1,    34,    -1,
-     482,    37,    -1,   485,   486,   487,    42,   489,   490,   491,
-     492,   493,   494,    49,  1624,    -1,    -1,    -1,    -1,    -1,
-     502,     8,   110,   111,    11,    -1,    -1,  1637,    15,    16,
-      17,    18,    19,    -1,    -1,    -1,    -1,  1540,    74,    -1,
-    1543,  1544,    -1,  1546,   218,    -1,    -1,    34,    -1,    -1,
-      37,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    -1,
-      -1,    -1,    49,    -1,   175,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1575,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     191,    -1,    -1,    -1,    -1,   196,    -1,    74,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   186,   187,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   288,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   233,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1639,    -1,    -1,   175,
-      -1,    -1,    -1,  1646,    -1,    -1,    -1,    -1,  1651,    -1,
-      -1,    -1,    -1,    -1,    -1,   191,    -1,    -1,    -1,    -1,
-     196,    -1,    -1,   251,   252,   253,   254,   255,   256,    -1,
-      -1,   259,   260,    -1,    -1,    -1,   944,   288,    -1,    -1,
-      -1,    -1,   218,   219,    -1,  1795,    -1,  1690,   175,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   233,  1701,    -1,
-    1703,  1704,    -1,    -1,   191,    -1,    -1,    -1,  1711,   196,
-      -1,    -1,  1715,    -1,    -1,  1718,    -1,   985,    -1,  1829,
-    1830,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   218,   219,    -1,    -1,   271,    -1,    -1,   274,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   233,    -1,    -1,    -1,
-      -1,  1754,   288,    -1,  1757,   291,  1759,     8,    -1,    -1,
-      11,    -1,    -1,    -1,    15,    16,    17,    18,    19,   380,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   365,   366,    -1,
-      -1,    -1,    -1,    34,   271,    -1,    -1,   274,    -1,   110,
-     111,    42,    -1,    -1,    -1,    -1,    -1,    -1,    49,    -1,
-      -1,   288,    -1,    -1,   291,    -1,    -1,    -1,    -1,    -1,
-      -1,   485,   486,   487,    -1,   489,   490,   491,   492,   493,
-     494,  1824,    -1,    74,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1101,    -1,    -1,  1839,  1840,    -1,    -1,
-    1108,    -1,    -1,     8,   380,    -1,    11,    -1,    -1,    -1,
-      15,    16,    17,    18,    19,  1858,    -1,    -1,    -1,    -1,
-    1970,    -1,    -1,    -1,    -1,   186,   187,    -1,    -1,    34,
-      -1,   482,    -1,    -1,   485,   486,   487,    42,   489,   490,
-     491,   492,   493,   494,    49,    -1,    -1,    -1,    -1,    -1,
-     478,   479,    -1,   380,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    74,
-      -1,    -1,    -1,    -1,  1917,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   175,    -1,    -1,    -1,    -1,    -1,
-     251,   252,   253,   254,   255,   256,    -1,    -1,   259,   260,
-     191,    -1,    -1,    -1,    -1,   196,   482,    -1,    -1,   485,
-     486,   487,    -1,   489,   490,   491,   492,   493,   494,  1962,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   218,   219,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   233,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   482,    -1,    -1,   485,   486,
-     487,    -1,   489,   490,   491,   492,   493,   494,    -1,    -1,
-     175,    -1,   499,    -1,    -1,  2018,    -1,    -1,    -1,    -1,
-     271,    -1,    -1,   274,  2027,    -1,   191,  2030,    -1,    -1,
-    2033,   196,    -1,    -1,    -1,    -1,    -1,   288,    -1,    -1,
-     291,    -1,    -1,    -1,   365,   366,    -1,    -1,  1316,    -1,
-      -1,    -1,    -1,   218,   219,    -1,    -1,  2060,  2061,  1327,
-      -1,  2064,    -1,  1331,    -1,    -1,    -1,    -1,   233,  1337,
-    1338,  1339,    -1,  2076,    -1,    -1,    -1,    -1,  1346,    -1,
-      -1,    -1,  2085,    -1,    -1,  2088,    -1,  2090,    -1,    -1,
-       8,    -1,    -1,    11,    -1,  2098,    -1,    15,    16,    17,
-      18,    19,    -1,  2106,  2107,    -1,   271,    -1,    -1,   274,
-    2220,    -1,    -1,    -1,    -1,    -1,    34,    -1,    -1,    -1,
-      -1,    -1,    -1,   288,    42,    -1,   291,    -1,    -1,   380,
-      -1,    49,    -1,  2136,    -1,  1403,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2146,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    74,   478,   479,  2162,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   498,  1446,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1460,    -1,    -1,    -1,    -1,  1465,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   380,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   482,    -1,    -1,   485,   486,   487,    -1,   489,   490,
-     491,   492,   493,   494,    -1,    -1,    -1,    -1,   499,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   175,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   191,    -1,    -1,    -1,    -1,   196,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  2298,    -1,    -1,    -1,    -1,
-     218,   219,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   233,    -1,   482,    -1,    -1,
-     485,   486,   487,    -1,   489,   490,   491,   492,   493,   494,
-      -1,    -1,    -1,    -1,   499,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  2347,  2348,    -1,    -1,    -1,  2352,
-      -1,    -1,    -1,   271,  2357,    -1,   274,  2360,  2361,    -1,
-    2470,    -1,  2365,    -1,    -1,  2475,    -1,    -1,     8,    -1,
-     288,    11,    -1,   291,    -1,    15,    16,    17,    18,    19,
-      -1,  1649,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    34,    -1,    -1,    -1,    -1,    -1,
-    1668,    -1,    42,    -1,    -1,    -1,    -1,    -1,  2411,    49,
-      -1,    -1,    -1,    -1,  2524,  2525,    -1,    -1,  1686,    -1,
-    1688,  1689,    -1,  1691,    -1,  1693,    -1,    -1,    -1,  1697,
-      -1,    -1,  1700,    -1,    74,    -1,    -1,  1705,    -1,    -1,
-    1708,    -1,  2445,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1720,    -1,    -1,    -1,  1724,  1725,  1726,  1727,
-    1728,  1729,   380,    -1,    -1,    -1,    -1,  1735,  1736,  2472,
-    1738,  1739,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1750,    -1,    -1,  1753,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1761,  1762,  1763,  1764,  1765,  1766,  1767,
-    1768,  1769,  1770,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1802,   175,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   191,    -1,    -1,    -1,    -1,   196,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   482,    -1,    -1,   485,   486,   487,
-      -1,   489,   490,   491,   492,   493,   494,    -1,   218,   219,
-      -1,   499,    -1,  2693,  2694,    -1,    -1,    -1,    -1,  2592,
-      -1,    -1,    -1,   233,  2704,    -1,    -1,    -1,  2601,  2602,
-      -1,    -1,  2605,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   271,    -1,    -1,   274,    -1,    -1,    -1,    -1,  2642,
-    2643,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   288,    -1,
-      -1,   291,    -1,  2656,  1922,  1923,  1924,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  2674,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,     8,    -1,    -1,    11,    -1,    -1,    -1,    15,    16,
-      17,    18,    19,    -1,    -1,     8,    -1,    -1,    11,    -1,
-      -1,    -1,    -1,    16,    -1,    -1,    -1,    34,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    -1,
-      -1,    -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,    42,
-     380,    -1,    -1,    -1,    -1,    -1,    49,    -1,    -1,  2017,
-      -1,    -1,    -1,    -1,    -1,  2023,    -1,    74,    -1,    -1,
-      -1,  2764,    -1,    -1,    -1,    -1,    -1,    -1,  2036,  2037,
-    2038,    74,  2040,  2041,  2042,  2043,  2044,    -1,  2781,  2047,
-    2048,  2049,  2050,  2051,  2052,  2053,  2054,  2055,  2056,  2057,
-      -1,    -1,  2795,    -1,    -1,  2798,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  2077,
-    2813,    -1,  2080,    -1,  2082,    -1,    -1,    -1,  2086,  2087,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  2100,  2101,  2102,  2103,    -1,  2105,    -1,    -1,
-      -1,   144,   482,    -1,    -1,   485,   486,   487,    -1,   489,
-     490,   491,   492,   493,   494,    -1,    -1,    -1,   175,   499,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  2977,    -1,    -1,
-      -1,    -1,   175,    -1,   191,    -1,    -1,    -1,    -1,   196,
-      -1,    -1,    -1,    -1,    -1,    -1,  2889,    -1,   191,    -1,
-    2893,    -1,    -1,   196,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   218,   219,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  2181,    -1,     8,   233,    -1,    11,    -1,
-    2923,    -1,    15,    16,    17,    18,    19,    -1,    -1,    -1,
-     233,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
-      -1,    -1,    -1,  2956,   271,    -1,    49,   274,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   288,    -1,    -1,   291,    -1,    -1,    -1,    -1,    -1,
-      -1,    74,    -1,    -1,    -1,   288,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  3002,
-    3003,    -1,    -1,    -1,  2272,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  2299,  3035,    -1,    -1,  2303,  2304,    -1,  2306,    -1,
-      -1,  2309,  2310,  2311,  2312,  2313,    -1,    -1,    -1,  2317,
-    2318,  2319,  2320,  2321,  2322,  2323,  2324,  2325,  2326,  2327,
-    2328,    -1,    -1,   380,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  2339,    -1,  3076,    -1,    -1,    -1,   380,  2346,    -1,
-      -1,  2349,   175,  2351,    -1,    -1,    -1,  2355,    -1,    -1,
-    2358,  2359,    -1,    -1,  2362,  2363,    -1,     8,   191,    -1,
-      11,    -1,    -1,   196,    15,    16,    17,    18,    19,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    34,    -1,   218,   219,    -1,    -1,    -1,
-      -1,    42,    -1,    -1,  2402,    -1,    -1,    -1,    49,    -1,
-     233,    -1,  2410,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    37,    -1,    -1,  2423,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    74,    -1,   482,    -1,    -1,   485,   486,
-     487,    56,   489,   490,   491,   492,   493,   494,   271,   482,
-      -1,   274,   499,    -1,    -1,  2453,   489,   490,   491,   492,
-     493,   494,    -1,    -1,    -1,   288,    -1,    -1,   291,    -1,
-       8,    -1,    -1,    11,    -1,    -1,    -1,    15,    16,    17,
-      18,    19,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   107,   108,    -1,    -1,    34,    -1,    -1,    -1,
-      -1,   116,    -1,    -1,    42,     8,    -1,    -1,    11,    -1,
-      -1,    49,    15,    16,    17,    18,    19,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    34,    -1,    -1,   175,    -1,    74,    -1,    -1,    42,
-      -1,    -1,    -1,    -1,    -1,    -1,    49,    -1,    -1,    -1,
-     191,    -1,    -1,    -1,    -1,   196,    -1,   380,    -1,   174,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    -1,    -1,
-      -1,    74,    -1,    -1,    -1,    -1,    -1,   218,   219,    -1,
-      -1,    -1,    -1,   198,  2582,    -1,    -1,    -1,  2586,    -1,
-      -1,    -1,   233,    -1,    -1,    24,    -1,  2595,  2596,  2597,
-      -1,    30,  2600,    -1,    -1,  2603,  2604,    -1,    37,    -1,
-    2608,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      75,    -1,    -1,    -1,    -1,    -1,    -1,    56,    -1,    -1,
-     271,    -1,    -1,   274,   249,    -1,    91,   175,    -1,    -1,
-      -1,    -1,   257,    -1,    -1,    -1,    -1,   288,    -1,    -1,
-     291,    -1,    -1,   191,   269,    -1,   271,    -1,   196,   482,
-      -1,    -1,   485,   486,   487,    -1,   489,   490,   491,   492,
-     493,   494,   175,  2671,    -1,    -1,   499,    -1,   107,  2677,
-     218,   219,    -1,    -1,    -1,   300,    -1,    -1,   191,    -1,
-     145,    -1,  2690,   196,    -1,   233,    -1,    -1,    -1,    -1,
-     155,    -1,    -1,    -1,    -1,    -1,    -1,   136,    -1,    -1,
-      -1,    -1,   167,    -1,    -1,   218,   219,   172,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     233,    -1,   347,   271,    -1,    -1,   274,    -1,    -1,   380,
-      -1,  2739,  2740,    -1,   199,    -1,    -1,  2745,  2746,  2747,
-     288,    -1,    -1,   291,   369,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   271,   198,
-      -1,   274,    -1,    -1,   389,    -1,   391,    -1,    -1,   394,
-      -1,    -1,    -1,    -1,    -1,   288,    -1,    -1,   291,   244,
-      -1,  2789,  2790,   248,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  2804,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  2814,    -1,    -1,    -1,
-     249,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   257,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     269,   482,   380,    -1,   485,   486,   487,    -1,   489,   490,
-     491,   492,   493,   494,    -1,    -1,   311,    -1,   499,    -1,
-    2858,   290,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     325,   300,    -1,    -1,    -1,    -1,    -1,   380,  2876,    -1,
-      -1,    -1,    -1,   498,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    2898,    -1,    -1,   358,    -1,    -1,   361,    -1,    -1,    -1,
-      -1,    -1,   341,    -1,   369,    -1,   345,   372,   347,  2917,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   391,    -1,    -1,    -1,
-     369,    -1,    -1,    -1,   482,    -1,   375,   485,   486,   487,
-     405,   489,   490,   491,   492,   493,   494,   412,    -1,    -1,
-     389,   499,    -1,  2961,    -1,    -1,   421,    -1,    -1,    -1,
-      -1,    -1,   427,    -1,    -1,    -1,    -1,    -1,    -1,   482,
-      -1,    -1,   485,   486,   487,    -1,   489,   490,   491,   492,
-     493,   494,  2990,    -1,    -1,    -1,   499,   452,    -1,    -1,
-      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,   443,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    -1,    -1,    -1,    -1,    36,    -1,    -1,    39,    40,
-    3038,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    75,    -1,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-     131,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,   169,    -1,
-     171,   172,   173,   174,   175,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-     231,   232,   233,    -1,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,   439,    -1,
-     441,   442,   443,   444,   445,   446,   447,   448,   449,   450,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,    -1,    -1,    -1,    -1,    -1,    -1,   489,   490,
-     491,    -1,    -1,    -1,    -1,   496,    -1,   498,   499,    -1,
-      -1,    -1,   503,    -1,   505,   506,     3,     4,     5,     6,
-       7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    75,    -1,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,   169,    -1,   171,   172,   173,   174,   175,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,   231,   232,   233,    -1,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,   405,   406,
-     407,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,   439,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,   460,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,    -1,   484,    -1,    -1,
-      -1,    -1,   489,   490,    -1,    -1,    -1,    -1,    -1,   496,
-      -1,   498,   499,    -1,    -1,    -1,   503,    -1,   505,   506,
-       3,     4,     5,     6,     7,     8,     9,    10,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    36,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,   460,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-      -1,   484,    -1,    -1,    -1,    -1,   489,   490,    -1,    -1,
-      -1,    -1,    -1,   496,    -1,   498,    -1,    -1,    -1,    -1,
-     503,    -1,   505,   506,     3,     4,     5,     6,     7,     8,
-       9,    10,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    36,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    75,    -1,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,    -1,
-     229,   230,   231,   232,   233,    -1,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,   407,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,   417,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-     439,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,    -1,    -1,    -1,    -1,    -1,    -1,
-     489,   490,    -1,    -1,    -1,    -1,    -1,   496,    -1,   498,
-      -1,    -1,    -1,    -1,   503,    -1,   505,   506,     3,     4,
-       5,     6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
-      35,    36,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      75,    -1,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,   169,    -1,   171,   172,   173,   174,
-     175,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,   231,   232,   233,    -1,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,   407,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,   439,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,   450,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,    -1,    -1,
-      -1,    -1,    -1,    -1,   489,   490,    -1,    -1,    -1,    -1,
-      -1,   496,    -1,   498,    -1,    -1,    -1,    -1,   503,    -1,
-     505,   506,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    -1,    -1,    -1,    -1,    36,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    75,    -1,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,   169,    -1,
-     171,   172,   173,   174,   175,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-     231,   232,   233,    -1,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,   439,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,   450,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,    -1,    -1,    -1,    -1,    -1,    -1,   489,   490,
-     491,    -1,    -1,    -1,    -1,   496,    -1,   498,    -1,    -1,
-      -1,    -1,   503,    -1,   505,   506,     3,     4,     5,     6,
-       7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    75,    -1,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,   169,    -1,   171,   172,   173,   174,   175,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,   231,   232,   233,    -1,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,    -1,   406,
-     407,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,   439,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,    -1,    -1,    -1,    -1,
-      -1,    -1,   489,   490,   491,    -1,    -1,    -1,    -1,   496,
-      -1,   498,    -1,    -1,    -1,    -1,   503,    -1,   505,   506,
-       3,     4,     5,     6,     7,     8,     9,    10,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    36,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-      -1,    -1,    -1,    -1,    -1,    -1,   489,   490,   491,    -1,
-      -1,    -1,    -1,   496,    -1,   498,    -1,    -1,    -1,    -1,
-     503,    -1,   505,   506,     3,     4,     5,     6,     7,     8,
-       9,    10,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    -1,    -1,    -1,    -1,    36,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    75,    -1,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-     169,    -1,   171,   172,   173,   174,   175,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,   231,   232,   233,    -1,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,   407,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-     439,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,    -1,    -1,    -1,    -1,    -1,    -1,
-     489,   490,    -1,    -1,    -1,    -1,    -1,   496,    -1,   498,
-      -1,    -1,    -1,    -1,   503,    -1,   505,   506,     3,     4,
-       5,     6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    36,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      75,    -1,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,   169,    -1,   171,   172,   173,   174,
-     175,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,   231,   232,   233,    -1,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,   407,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,   439,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,   450,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,    -1,    -1,
-      -1,    -1,    -1,    -1,   489,   490,    -1,    -1,    -1,    -1,
-      -1,   496,    -1,   498,   499,    -1,    -1,    -1,   503,    -1,
-     505,   506,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    36,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    75,    -1,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,   169,    -1,
-     171,   172,   173,   174,   175,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-     231,   232,   233,    -1,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,   439,    -1,
-     441,   442,   443,   444,   445,   446,   447,   448,   449,   450,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,    -1,    -1,    -1,    -1,    -1,    -1,   489,   490,
-      -1,    -1,    -1,    -1,    -1,   496,    -1,   498,    -1,    -1,
-      -1,    -1,   503,    -1,   505,   506,     3,     4,     5,     6,
-       7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    75,    -1,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,   169,    -1,   171,   172,   173,   174,   175,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,   231,   232,   233,    -1,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,    -1,   406,
-     407,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,   439,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,    -1,    -1,    -1,    -1,
-      -1,    -1,   489,   490,    -1,    -1,    -1,    -1,    -1,   496,
-      -1,   498,   499,    -1,    -1,    -1,   503,    -1,   505,   506,
-       3,     4,     5,     6,     7,     8,     9,    10,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    36,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-      -1,    -1,    -1,    -1,    -1,    -1,   489,   490,    -1,    -1,
-      -1,    -1,    -1,   496,    -1,   498,    -1,    -1,    -1,    -1,
-     503,    -1,   505,   506,     3,     4,     5,     6,     7,     8,
-       9,    10,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    36,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    75,    -1,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-     169,    -1,   171,   172,   173,   174,   175,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,   231,   232,   233,    -1,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-     439,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,    -1,    -1,    -1,    -1,    -1,    -1,
-     489,   490,    -1,    -1,    -1,    -1,    -1,   496,    -1,   498,
-      -1,    -1,    -1,    -1,   503,    -1,   505,   506,     3,     4,
-       5,     6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    36,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      75,    -1,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,   169,    -1,   171,   172,   173,   174,
-     175,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,   231,   232,   233,    -1,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,   407,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,   439,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,   450,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,    -1,    -1,
-      -1,    -1,    -1,    -1,   489,   490,    -1,    -1,    -1,    -1,
-      -1,   496,    -1,   498,    -1,    -1,    -1,    -1,   503,    -1,
-     505,   506,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    36,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    75,    -1,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,   169,    -1,
-     171,   172,   173,   174,   175,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-     231,   232,   233,    -1,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,   439,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,   450,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,    -1,    -1,    -1,    -1,    -1,    -1,   489,   490,
-      -1,    -1,    -1,    -1,    -1,   496,    -1,   498,    -1,    -1,
-      -1,    -1,   503,    -1,   505,   506,     3,     4,     5,     6,
-       7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    75,    -1,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,   169,    -1,   171,   172,   173,   174,   175,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,   231,   232,   233,    -1,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,    -1,   406,
-     407,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,   439,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,    -1,    -1,    -1,    -1,
-      -1,    -1,   489,   490,    -1,    -1,    -1,    -1,    -1,   496,
-      -1,   498,    -1,    -1,    -1,    -1,   503,    -1,   505,   506,
-       3,     4,     5,     6,     7,     8,     9,    10,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    36,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-      -1,    -1,    -1,    -1,    -1,    -1,   489,   490,    -1,    -1,
-      -1,    -1,    -1,   496,    -1,   498,    -1,    -1,    -1,    -1,
-     503,    -1,   505,   506,     3,     4,     5,     6,     7,     8,
-       9,    10,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    36,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    75,    -1,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-     169,    -1,   171,   172,   173,   174,   175,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,   231,   232,   233,    -1,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,   407,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-     439,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,    -1,    -1,    -1,    -1,    -1,    -1,
-     489,   490,    -1,    -1,    -1,    -1,    -1,   496,    -1,   498,
-      -1,    -1,    -1,    -1,   503,    -1,   505,   506,     3,     4,
-       5,     6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    36,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      75,    -1,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,   169,    -1,   171,   172,   173,   174,
-     175,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,   231,   232,   233,    -1,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,   407,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,   439,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,   450,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,    -1,    -1,
-      -1,    -1,    -1,    -1,   489,   490,    -1,    -1,    -1,    -1,
-      -1,   496,    -1,   498,    -1,    -1,    -1,    -1,   503,    -1,
-     505,   506,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    36,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    75,    -1,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,   169,    -1,
-     171,   172,   173,   174,   175,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-     231,   232,   233,    -1,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,   439,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,   450,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,    -1,    -1,    -1,    -1,    -1,    -1,   489,   490,
-      -1,    -1,    -1,    -1,    -1,   496,    -1,   498,    -1,    -1,
-      -1,    -1,   503,    -1,   505,   506,     3,     4,     5,     6,
-       7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    75,    -1,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,   169,    -1,   171,   172,   173,   174,   175,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,   231,   232,   233,    -1,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,    -1,   406,
-     407,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,   423,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,   439,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,    -1,    -1,    -1,    -1,
-      -1,    -1,   489,   490,    -1,    -1,    -1,    -1,    -1,   496,
-      -1,   498,    -1,    -1,    -1,    -1,   503,    -1,   505,   506,
-       3,     4,     5,     6,     7,     8,     9,    10,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    36,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,    -1,    -1,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,    -1,   272,
-     273,    -1,   275,   276,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-      -1,    -1,    -1,    -1,    -1,    -1,   489,   490,    -1,    -1,
-      -1,    -1,    -1,   496,    -1,   498,    -1,    -1,    -1,    -1,
-     503,    -1,   505,   506,     3,     4,     5,     6,     7,     8,
-       9,    10,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    75,    -1,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,    -1,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-     169,    -1,   171,   172,   173,   174,   175,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,   231,   232,   233,    -1,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,    -1,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,   407,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-     439,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     489,   490,    -1,    -1,     3,     4,     5,     6,     7,   498,
-       9,    10,    -1,    -1,    -1,    -1,   505,   506,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    75,    -1,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,    -1,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-     169,    -1,   171,   172,   173,   174,   175,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,   231,   232,   233,    -1,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,    -1,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,   407,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-     439,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     489,   490,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   498,
-      -1,    -1,    -1,    -1,    -1,    -1,   505,   506,     3,     4,
-       5,     6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      75,    -1,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,    -1,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,   169,    -1,   171,   172,   173,   174,
-     175,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,    -1,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,   231,   232,   233,    -1,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,    -1,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,   407,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,   439,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,   450,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   489,   490,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   498,    -1,    -1,    -1,    -1,    -1,    -1,
-     505,   506,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    36,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    45,    46,    47,    48,    -1,    50,
-      51,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    75,    -1,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,    -1,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,   169,    -1,
-     171,   172,   173,   174,    -1,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-      -1,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,
-     221,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-     231,   232,    -1,    -1,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-      -1,   272,   273,    -1,   275,   276,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,    -1,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,   439,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,   450,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   489,   490,
-       3,    -1,    -1,    -1,    -1,   496,    -1,   498,    -1,    -1,
-      -1,    -1,   503,    -1,   505,   506,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    37,    -1,    39,    40,    -1,    42,
-      43,    44,    -1,    46,    47,    48,    49,    50,    -1,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    -1,    -1,    77,    78,    79,    80,    81,    82,
-      -1,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,    -1,    -1,   171,   172,
-     173,   174,    -1,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,    -1,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,    -1,    -1,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-      -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,    -1,   272,
-     273,    -1,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,    -1,   296,    -1,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,    -1,   375,   376,   377,   378,   379,    -1,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,    -1,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,    -1,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,    -1,
-       3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   499,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    62,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,    -1,   272,
-     273,   274,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,   287,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,   460,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,    -1,
-      -1,   484,     3,     4,     5,    -1,    -1,    -1,     9,    -1,
-      -1,    -1,    -1,    -1,    -1,   498,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      -1,    -1,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    75,    -1,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
-     101,   102,    -1,    -1,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,    -1,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,   169,    -1,
-     171,   172,   173,   174,   175,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-     231,   232,   233,    -1,   235,   236,   237,    -1,    -1,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-      -1,   272,   273,   274,   275,    -1,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,   286,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,   439,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,   450,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,     3,    -1,     5,    -1,    -1,    -1,    -1,   489,   490,
-     491,    -1,    -1,    -1,    -1,    -1,    -1,   498,    20,    21,
-      22,    23,    24,    25,    26,    27,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,
-      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
-      52,    53,    -1,    55,    56,    57,    58,    59,    60,    -1,
-      62,    63,    64,    65,    66,    67,    -1,    69,    70,    71,
-      72,    73,    -1,    75,    -1,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    -1,    88,    89,    90,    91,
-      92,    93,    -1,    95,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,    -1,   117,    -1,   119,   120,   121,
-     122,   123,   124,    -1,   126,   127,   128,   129,   130,    -1,
-      -1,   133,   134,   135,   136,   137,    -1,   139,   140,   141,
-      -1,   143,   144,   145,    -1,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,    -1,   159,    -1,   161,
-     162,   163,   164,    -1,   166,    -1,   168,   169,    -1,   171,
-     172,   173,   174,   175,   176,    -1,   178,    -1,   180,   181,
-     182,    -1,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,    -1,   197,   198,   199,   200,   201,
-     202,    -1,   204,   205,   206,   207,   208,   209,   210,   211,
-     212,   213,    -1,   215,    -1,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,    -1,   230,   231,
-     232,   233,    -1,   235,   236,   237,   238,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,    -1,
-     272,   273,   274,   275,    -1,   277,   278,   279,   280,   281,
-     282,    -1,   284,   285,    -1,   287,   288,   289,   290,    -1,
-      -1,   293,   294,   295,   296,   297,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,    -1,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,    -1,   320,   321,
-     322,   323,   324,   325,    -1,   327,   328,   329,   330,   331,
-     332,   333,   334,    -1,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,    -1,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,    -1,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-      -1,   403,   404,    -1,   406,   407,   408,   409,   410,   411,
-     412,    -1,   414,   415,    -1,    -1,   418,   419,   420,   421,
-     422,    -1,   424,   425,   426,   427,   428,   429,   430,   431,
-      -1,    -1,   434,   435,   436,   437,   438,   439,    -1,   441,
-     442,   443,   444,   445,   446,   447,    -1,   449,   450,   451,
-     452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,
-     462,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   498,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-      -1,    -1,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,    -1,   272,
-     273,   274,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,   460,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,     3,
-      -1,   484,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   498,    20,    21,    22,    23,
-      24,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,
-      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
-      -1,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
-      64,    65,    66,    67,    -1,    69,    70,    71,    72,    73,
-      -1,    75,    -1,    77,    78,    79,    80,    81,    82,    83,
-      84,    85,    86,    -1,    88,    89,    90,    91,    92,    93,
-      -1,    95,    96,    97,    98,    99,   100,   101,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,    -1,   117,    -1,   119,   120,   121,   122,   123,
-     124,    -1,   126,   127,   128,   129,   130,    -1,    -1,   133,
-     134,   135,   136,   137,    -1,   139,   140,   141,    -1,   143,
-     144,   145,    -1,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,    -1,   159,    -1,   161,   162,   163,
-     164,    -1,   166,    -1,   168,   169,    -1,   171,   172,   173,
-     174,   175,   176,    -1,   178,    -1,   180,   181,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,   195,    -1,   197,   198,   199,   200,   201,   202,    -1,
-     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
-      -1,   215,    -1,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,    -1,    -1,   230,   231,   232,   233,
-      -1,   235,   236,   237,   238,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,   269,   270,    -1,   272,   273,
-     274,   275,    -1,   277,   278,   279,   280,   281,   282,    -1,
-     284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,
-     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,    -1,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,    -1,   320,   321,   322,   323,
-     324,   325,    -1,   327,   328,   329,   330,   331,   332,   333,
-     334,    -1,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,    -1,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,    -1,   403,
-     404,    -1,   406,   407,   408,   409,   410,   411,   412,    -1,
-     414,   415,    -1,    -1,   418,   419,   420,   421,   422,    -1,
-     424,   425,   426,   427,   428,   429,   430,   431,    -1,    -1,
-     434,   435,   436,   437,   438,   439,    -1,   441,   442,   443,
-     444,   445,   446,   447,    -1,   449,   450,   451,   452,   453,
-     454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,     3,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   498,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    -1,    62,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      75,    -1,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,    -1,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,    -1,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,   169,    -1,   171,   172,   173,   174,
-     175,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,   231,   232,   233,    -1,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,    -1,   272,   273,   274,
-     275,    -1,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,   407,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,    -1,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,   439,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,   450,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,     3,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   498,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    -1,    52,    53,    -1,    55,
-      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
-      66,    67,    -1,    69,    70,    71,    72,    73,    -1,    -1,
-      -1,    77,    78,    79,    80,    81,    82,    -1,    84,    85,
-      86,    -1,    88,    89,    90,    91,    92,    93,    -1,    -1,
-      96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-      -1,   117,    -1,   119,   120,   121,   122,   123,   124,    -1,
-     126,   127,   128,   129,   130,    -1,    -1,   133,   134,   135,
-     136,   137,    -1,   139,   140,   141,    -1,   143,   144,   145,
-      -1,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,    -1,   159,    -1,   161,   162,   163,   164,    -1,
-     166,    -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,
-     176,    -1,   178,    -1,   180,   181,   182,    -1,   184,   185,
-     186,   187,   188,   189,   190,    -1,   192,   193,   194,   195,
-      -1,   197,   198,   199,   200,   201,   202,    -1,   204,    -1,
-     206,   207,   208,   209,   210,   211,   212,   213,    -1,   215,
-      -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,   225,
-     226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,
-     236,   237,    -1,    -1,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,    -1,
-     266,   267,   268,   269,   270,    -1,   272,   273,    -1,   275,
-      -1,   277,   278,   279,   280,   281,   282,    -1,   284,   285,
-      -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,
-     296,    -1,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,    -1,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,    -1,   320,   321,   322,   323,   324,   325,
-      -1,   327,   328,   329,   330,   331,   332,   333,   334,    -1,
-     336,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,   347,   348,    -1,   350,   351,    -1,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,    -1,   375,
-     376,   377,   378,   379,    -1,   381,   382,   383,   384,    -1,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,    -1,   403,   404,   405,
-     406,    -1,   408,   409,   410,   411,   412,    -1,   414,   415,
-      -1,    -1,   418,   419,   420,   421,   422,    -1,   424,   425,
-     426,   427,   428,   429,   430,   431,    -1,    -1,   434,   435,
-     436,   437,   438,    -1,    -1,   441,   442,   443,   444,   445,
-     446,   447,    -1,   449,    -1,   451,   452,   453,   454,   455,
-      -1,    -1,   458,    -1,   460,   461,   462,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,     3,    -1,   484,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   498,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,    46,
-      47,    48,    49,    50,    -1,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    -1,    -1,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,
-      77,    78,    79,    80,    81,    82,    -1,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    -1,    96,
-      97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,    -1,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,    -1,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,    -1,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,    -1,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,    -1,    -1,   220,    -1,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,
-     237,    -1,    -1,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,    -1,   266,
-     267,   268,   269,   270,    -1,   272,   273,    -1,   275,    -1,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,   296,
-      -1,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,    -1,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,    -1,   375,   376,
-     377,   378,   379,    -1,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,   405,   406,
-      -1,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,    -1,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,    -1,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,    -1,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,   460,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,    -1,     3,   484,     5,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   498,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,    46,
-      47,    48,    49,    50,    -1,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    -1,    -1,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,
-      77,    78,    79,    80,    81,    82,    -1,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    -1,    96,
-      97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,    -1,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,    -1,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,    -1,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,    -1,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,    -1,    -1,   220,    -1,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,
-     237,    -1,    -1,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,    -1,   266,
-     267,   268,   269,   270,    -1,   272,   273,    -1,   275,    -1,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,   296,
-      -1,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,    -1,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,    -1,   375,   376,
-     377,   378,   379,    -1,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,    -1,   406,
-      -1,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,    -1,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,    -1,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,    -1,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,     3,    -1,     5,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   498,    20,    21,    22,    23,    24,    25,    26,    27,
-      -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    39,    40,    -1,    42,    43,    44,    -1,    46,    47,
-      48,    49,    50,    -1,    52,    53,    -1,    55,    56,    57,
-      58,    59,    60,    -1,    -1,    63,    64,    65,    66,    67,
-      -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,    77,
-      78,    79,    80,    81,    82,    -1,    84,    85,    86,    -1,
-      88,    89,    90,    91,    92,    93,    -1,    -1,    96,    97,
-      98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,    -1,   117,
-      -1,   119,   120,   121,   122,   123,   124,    -1,   126,   127,
-     128,   129,   130,    -1,    -1,   133,   134,   135,   136,   137,
-      -1,   139,   140,   141,    -1,   143,   144,   145,    -1,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-      -1,   159,    -1,   161,   162,   163,   164,    -1,   166,    -1,
-     168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,    -1,
-     178,    -1,   180,   181,   182,    -1,   184,   185,   186,   187,
-     188,   189,   190,    -1,   192,   193,   194,   195,    -1,   197,
-     198,   199,   200,   201,   202,    -1,   204,    -1,   206,   207,
-     208,   209,   210,   211,   212,   213,    -1,   215,    -1,   217,
-      -1,    -1,   220,    -1,   222,   223,   224,   225,   226,   227,
-      -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,   237,
-      -1,    -1,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,    -1,   266,   267,
-     268,   269,   270,    -1,   272,   273,    -1,   275,    -1,   277,
-     278,   279,   280,   281,   282,    -1,   284,   285,    -1,    -1,
-     288,   289,   290,    -1,    -1,   293,   294,    -1,   296,    -1,
-     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,    -1,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,    -1,   320,   321,   322,   323,   324,   325,    -1,   327,
-     328,   329,   330,   331,   332,   333,   334,    -1,   336,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
-     348,    -1,   350,   351,    -1,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-      -1,   369,   370,   371,   372,   373,    -1,   375,   376,   377,
-     378,   379,    -1,   381,   382,   383,   384,    -1,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,   401,    -1,   403,   404,    -1,   406,    -1,
-     408,   409,   410,   411,   412,    -1,   414,   415,    -1,    -1,
-     418,   419,   420,   421,   422,    -1,   424,   425,   426,   427,
-     428,   429,   430,   431,    -1,    -1,   434,   435,   436,   437,
-     438,    -1,    -1,   441,   442,   443,   444,   445,   446,   447,
-      -1,   449,    -1,   451,   452,   453,   454,   455,    -1,    -1,
-     458,    -1,    -1,   461,   462,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,     3,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     498,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    -1,    46,    47,    48,
-      49,    50,    -1,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    -1,    -1,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    -1,    -1,    77,    78,
-      79,    80,    81,    82,    -1,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    -1,    96,    97,    98,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,    -1,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,    -1,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-      -1,    -1,    -1,   172,   173,   174,    -1,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,    -1,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,    -1,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,    -1,
-      -1,   220,    -1,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,    -1,   232,    -1,    -1,   235,   236,   237,    -1,
-      -1,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,    -1,   266,   267,   268,
-     269,   270,    -1,   272,   273,    -1,   275,    -1,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,    -1,   296,    -1,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,    -1,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,    -1,   375,   376,   377,   378,
-     379,    -1,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,    -1,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,    -1,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-      -1,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,    -1,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   498,
-      20,    21,    22,    23,    24,    25,    26,    27,    -1,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,
-      40,    -1,    42,    43,    44,    -1,    46,    47,    48,    49,
-      50,    -1,    52,    53,    -1,    55,    56,    57,    58,    59,
-      60,    -1,    -1,    63,    64,    65,    66,    67,    -1,    69,
-      70,    71,    72,    73,    -1,    -1,    -1,    77,    78,    79,
-      80,    81,    82,    -1,    84,    85,    86,    -1,    88,    89,
-      90,    91,    92,    93,    -1,    -1,    96,    97,    98,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,    -1,   117,    -1,   119,
-     120,   121,   122,   123,   124,    -1,   126,   127,   128,   129,
-     130,    -1,    -1,   133,   134,   135,   136,   137,    -1,   139,
-     140,   141,    -1,   143,   144,   145,    -1,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,    -1,   159,
-      -1,   161,   162,   163,   164,    -1,   166,    -1,   168,    -1,
-      -1,    -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,
-     180,   181,   182,    -1,   184,   185,   186,   187,   188,   189,
-     190,    -1,   192,   193,   194,   195,    -1,   197,   198,   199,
-     200,   201,   202,    -1,   204,    -1,   206,   207,   208,   209,
-     210,   211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,
-     220,    -1,   222,   223,   224,   225,   226,   227,    -1,    -1,
-     230,    -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,    -1,   266,   267,   268,   269,
-     270,    -1,   272,   273,    -1,   275,    -1,   277,   278,   279,
-     280,   281,   282,    -1,   284,   285,    -1,    -1,   288,   289,
-     290,    -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,    -1,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,    -1,
-     320,   321,   322,   323,   324,   325,    -1,   327,   328,   329,
-     330,   331,   332,   333,   334,    -1,   336,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,   347,   348,    -1,
-     350,   351,    -1,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,    -1,   369,
-     370,   371,   372,   373,    -1,   375,   376,   377,   378,   379,
-      -1,   381,   382,   383,   384,    -1,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,    -1,   403,   404,    -1,   406,    -1,   408,   409,
-     410,   411,   412,    -1,   414,   415,    -1,    -1,   418,   419,
-     420,   421,   422,    -1,   424,   425,   426,   427,   428,   429,
-     430,   431,    -1,    -1,   434,   435,   436,   437,   438,    -1,
-      -1,   441,   442,   443,   444,   445,   446,   447,    -1,   449,
-      -1,   451,   452,   453,   454,   455,    -1,    -1,   458,    -1,
-      -1,   461,   462,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   498,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      -1,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      -1,    -1,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    -1,    -1,    77,    78,    79,    80,
-      81,    82,    -1,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,    -1,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,    -1,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,
-      -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-      -1,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,    -1,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,
-      -1,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-      -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,    -1,   266,   267,   268,   269,   270,
-      -1,   272,   273,    -1,   275,    -1,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,    -1,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,    -1,   375,   376,   377,   378,   379,    -1,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,    -1,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,    -1,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,    -1,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,    -1,
-       8,     9,    -1,    -1,    -1,    -1,    -1,   498,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,    -1,    50,    51,    52,    53,    54,    55,    56,    57,
-      58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
-      68,    69,    70,    71,    72,    -1,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
-     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
-     148,   149,   150,    -1,   152,   153,   154,   155,   156,    -1,
-     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,    -1,    -1,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   204,   205,    -1,   207,
-     208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
-     238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,   274,   275,   276,    -1,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,    -1,   295,   296,   297,
-      -1,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,    -1,   313,   314,    -1,   316,   317,
-     318,   319,   320,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,    -1,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,    -1,   421,    -1,   423,   424,   425,   426,   427,
-     428,   429,   430,   431,   432,   433,   434,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,    -1,   447,
-     448,   449,   450,   451,   452,   453,   454,   455,   456,   457,
-     458,   459,   460,   461,   462,   463,   464,   465,   466,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     478,   479,   480,   481,    -1,     3,    -1,   485,   486,   487,
-       8,   489,   490,   491,   492,   493,   494,    -1,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    39,    40,    -1,    42,    43,    44,    -1,    46,    47,
-      48,    49,    50,    -1,    52,    53,    -1,    55,    56,    57,
-      58,    59,    60,    -1,    -1,    63,    64,    65,    66,    67,
-      -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,    77,
-      78,    79,    80,    81,    82,    -1,    84,    85,    86,    -1,
-      88,    89,    90,    91,    92,    93,    -1,    -1,    96,    97,
-      98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,    -1,   117,
-      -1,   119,   120,   121,   122,   123,   124,    -1,   126,   127,
-     128,   129,   130,    -1,    -1,   133,   134,   135,   136,   137,
-      -1,   139,   140,   141,    -1,   143,   144,   145,    -1,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-      -1,   159,    -1,   161,   162,   163,   164,    -1,   166,    -1,
-     168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,    -1,
-     178,    -1,   180,   181,   182,    -1,   184,   185,   186,   187,
-     188,   189,   190,    -1,   192,   193,   194,   195,    -1,   197,
-     198,   199,   200,   201,   202,    -1,   204,    -1,   206,   207,
-     208,   209,   210,   211,   212,   213,    -1,   215,    -1,   217,
-      -1,    -1,   220,    -1,   222,   223,   224,   225,   226,   227,
-      -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,   237,
-      -1,    -1,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,    -1,   266,   267,
-     268,   269,   270,    -1,   272,   273,    -1,   275,    -1,   277,
-     278,   279,   280,   281,   282,    -1,   284,   285,    -1,    -1,
-     288,   289,   290,    -1,    -1,   293,   294,    -1,   296,    -1,
-     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,    -1,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,    -1,   320,   321,   322,   323,   324,   325,    -1,   327,
-     328,   329,   330,   331,   332,   333,   334,    -1,   336,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
-     348,    -1,   350,   351,    -1,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-      -1,   369,   370,   371,   372,   373,    -1,   375,   376,   377,
-     378,   379,    -1,   381,   382,   383,   384,    -1,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,   401,    -1,   403,   404,    -1,   406,    -1,
-     408,   409,   410,   411,   412,    -1,   414,   415,    -1,    -1,
-     418,   419,   420,   421,   422,    -1,   424,   425,   426,   427,
-     428,   429,   430,   431,    -1,    -1,   434,   435,   436,   437,
-     438,    -1,    -1,   441,   442,   443,   444,   445,   446,   447,
-      -1,   449,    -1,   451,   452,   453,   454,   455,    -1,    -1,
-     458,    -1,    -1,   461,   462,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,    -1,    -1,    -1,   485,   486,   487,
-      -1,   489,   490,   491,   492,   493,   494,     8,    -1,    -1,
-      11,    -1,    -1,    -1,    15,    16,    17,    18,    19,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    34,    -1,    -1,     8,    -1,    -1,    11,
-      -1,    42,    -1,    15,    16,    17,    18,    19,    49,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      42,     8,    -1,    74,    11,    -1,    -1,    49,    15,    16,
-      17,    18,    19,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    34,    -1,    -1,
-       8,    -1,    74,    11,    -1,    42,    -1,    15,    16,    17,
-      18,    19,    49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    34,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    42,    -1,    -1,    74,    -1,    -1,
-      -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    74,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   175,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     191,    -1,    -1,    -1,    -1,   196,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   175,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   218,   219,   191,
-      -1,    -1,    -1,    -1,   196,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   233,    -1,    -1,    -1,    -1,    -1,   175,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   218,   219,    -1,    -1,
-      -1,    -1,    -1,    -1,   191,    -1,    -1,    -1,    -1,   196,
-      -1,   233,    -1,    -1,    -1,    -1,    -1,   175,    -1,    -1,
-     271,    -1,    -1,   274,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   218,   219,   191,    -1,    -1,    -1,   288,   196,    -1,
-     291,    -1,    -1,    -1,    -1,    -1,   233,    -1,    -1,   271,
-      -1,    -1,   274,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     218,   219,    -1,    -1,    -1,    -1,   288,    -1,    -1,   291,
-      -1,    -1,    -1,    -1,    -1,   233,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   271,    -1,    -1,   274,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   288,    -1,    -1,   291,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   271,    -1,    -1,   274,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   380,
-     288,    -1,    -1,   291,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   380,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   380,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   380,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   482,    -1,    -1,   485,   486,   487,    -1,   489,   490,
-     491,   492,   493,   494,    -1,    -1,    -1,    -1,   499,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     482,    -1,    -1,   485,   486,   487,    -1,   489,   490,   491,
-     492,   493,   494,    -1,    -1,    -1,    -1,   499,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   482,    -1,    -1,   485,   486,
-     487,    -1,   489,   490,   491,   492,   493,   494,    -1,    -1,
-      -1,    -1,   499,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,     3,   482,    -1,    -1,   485,   486,   487,
-      -1,   489,   490,   491,   492,   493,   494,    -1,    -1,   497,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
-      60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
-     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
-     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,   347,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-     430,   431,   432,   433,   434,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,   447,   448,   449,
-     450,   451,   452,   453,   454,   455,   456,   457,   458,   459,
-     460,   461,   462,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   491,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      -1,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      -1,    -1,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    -1,    -1,    77,    78,    79,    80,
-      81,    82,    -1,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,    -1,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,    -1,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,
-      -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-      -1,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,    -1,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,
-      -1,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-      -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,    -1,   266,   267,   268,   269,   270,
-      -1,   272,   273,    -1,   275,    -1,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,    -1,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,    -1,   375,   376,   377,   378,   379,    -1,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,    -1,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,    -1,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,    -1,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,     3,     4,     5,    -1,    -1,    -1,     9,    -1,    -1,
-     491,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,
-      22,    23,    24,    25,    26,    27,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,
-      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
-      52,    53,    -1,    55,    56,    57,    58,    59,    60,    -1,
-      -1,    63,    64,    65,    66,    67,    -1,    69,    70,    71,
-      72,    73,    -1,    75,    -1,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    -1,    88,    89,    90,    91,
-      92,    93,    -1,    95,    96,    97,    98,    99,   100,   101,
-     102,    -1,    -1,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,   117,    -1,   119,   120,   121,
-     122,   123,   124,    -1,   126,   127,   128,   129,   130,    -1,
-      -1,   133,   134,   135,   136,   137,    -1,   139,   140,   141,
-      -1,   143,   144,   145,    -1,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-     162,   163,   164,    -1,   166,    -1,   168,   169,    -1,   171,
-     172,   173,   174,   175,   176,    -1,   178,    -1,   180,   181,
-     182,    -1,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,    -1,   197,   198,   199,   200,   201,
-     202,    -1,   204,   205,   206,   207,   208,   209,   210,   211,
-     212,   213,    -1,   215,    -1,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,    -1,    -1,   230,   231,
-     232,   233,    -1,   235,   236,   237,    -1,    -1,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,    -1,
-     272,   273,   274,   275,    -1,   277,   278,   279,   280,   281,
-     282,    -1,   284,   285,   286,    -1,   288,   289,   290,    -1,
-      -1,   293,   294,   295,   296,   297,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,    -1,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,    -1,   320,   321,
-     322,   323,   324,   325,    -1,   327,   328,   329,   330,   331,
-     332,   333,   334,    -1,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,    -1,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,    -1,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-      -1,   403,   404,    -1,   406,   407,   408,   409,   410,   411,
-     412,    -1,   414,   415,    -1,    -1,   418,   419,   420,   421,
-     422,   423,   424,   425,   426,   427,   428,   429,   430,   431,
-      -1,    -1,   434,   435,   436,   437,   438,   439,    -1,   441,
-     442,   443,   444,   445,   446,   447,    -1,   449,   450,   451,
-     452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,
-     462,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-       3,     4,     5,    -1,    -1,    -1,     9,   489,   490,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-      -1,    -1,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,    -1,   272,
-     273,   274,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,   286,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,     3,
-       4,     5,    -1,    -1,    -1,     9,   489,   490,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,
-      24,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,
-      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
-      -1,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
-      64,    65,    66,    67,    -1,    69,    70,    71,    72,    73,
-      -1,    75,    -1,    77,    78,    79,    80,    81,    82,    83,
-      84,    85,    86,    -1,    88,    89,    90,    91,    92,    93,
-      -1,    95,    96,    97,    98,    99,   100,   101,   102,    -1,
-      -1,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,    -1,   117,    -1,   119,   120,   121,   122,   123,
-     124,    -1,   126,   127,   128,   129,   130,    -1,    -1,   133,
-     134,   135,   136,   137,    -1,   139,   140,   141,    -1,   143,
-     144,   145,    -1,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,    -1,   161,   162,   163,
-     164,    -1,   166,    -1,   168,   169,    -1,   171,   172,   173,
-     174,   175,   176,    -1,   178,    -1,   180,   181,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,   195,    -1,   197,   198,   199,   200,   201,   202,    -1,
-     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
-      -1,   215,    -1,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,    -1,    -1,   230,   231,   232,   233,
-      -1,   235,   236,   237,    -1,    -1,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,   269,   270,    -1,   272,   273,
-     274,   275,    -1,   277,   278,   279,   280,   281,   282,    -1,
-     284,   285,   286,    -1,   288,   289,   290,    -1,    -1,   293,
-     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,    -1,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,    -1,   320,   321,   322,   323,
-     324,   325,    -1,   327,   328,   329,   330,   331,   332,   333,
-     334,    -1,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,    -1,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,    -1,   403,
-     404,    -1,   406,   407,   408,   409,   410,   411,   412,    -1,
-     414,   415,    -1,    -1,   418,   419,   420,   421,   422,   423,
-     424,   425,   426,   427,   428,   429,   430,   431,    -1,    -1,
-     434,   435,   436,   437,   438,   439,    -1,   441,   442,   443,
-     444,   445,   446,   447,    -1,   449,   450,   451,   452,   453,
-     454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,    -1,    -1,
-       8,    -1,    -1,    11,    -1,   489,   490,    15,    16,    17,
-      18,    19,    -1,     8,    -1,    -1,    11,    -1,    -1,    -1,
-      15,    16,    17,    18,    19,    -1,    34,    -1,    -1,    -1,
-      38,    -1,    -1,    -1,    42,    -1,    -1,    -1,    -1,    34,
-      -1,    49,    -1,    -1,    -1,    -1,    -1,    42,     8,    -1,
-      -1,    11,    -1,    -1,    49,    15,    16,    17,    18,    19,
-      -1,     8,    -1,    -1,    11,    -1,    74,    -1,    15,    16,
-      17,    18,    19,    -1,    34,    -1,    -1,    -1,    -1,    74,
-      -1,    -1,    42,    -1,    -1,    -1,    -1,    34,    -1,    49,
-      37,    -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    -1,
-      -1,    -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    74,    -1,    -1,   125,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    74,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,     8,    -1,    -1,    11,    -1,    -1,    -1,    15,    16,
-      17,    18,    19,    -1,    -1,    -1,    -1,   175,    -1,    -1,
-     165,    -1,    -1,    -1,    -1,   170,    -1,    34,    -1,    -1,
-     175,    -1,    -1,   191,    -1,    42,    -1,    -1,   196,    -1,
-      -1,    -1,    49,    -1,    -1,    -1,   191,    -1,    -1,    -1,
-      -1,   196,    -1,    -1,   164,    -1,    -1,    -1,    -1,    -1,
-     218,   219,    -1,    -1,    -1,   175,    -1,    74,    -1,    -1,
-      -1,    -1,    -1,   218,   219,   233,    -1,    -1,   175,    -1,
-      -1,   191,    -1,    -1,    -1,    -1,   196,    -1,   233,    -1,
-      -1,    -1,    -1,    -1,   191,    -1,    -1,    -1,    -1,   196,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   218,   219,
-      -1,    -1,    -1,   271,    -1,    -1,   274,    -1,    -1,    -1,
-      -1,   218,   219,   233,    -1,    -1,   271,    -1,    -1,   274,
-     288,    -1,    -1,   291,    -1,    -1,   233,    -1,    -1,    -1,
-      -1,    -1,    -1,   288,    -1,    -1,   291,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   271,    -1,    -1,   274,    -1,    -1,    -1,   175,    -1,
-      -1,    -1,    -1,    -1,   271,    -1,    -1,   274,   288,    -1,
-      -1,   291,    -1,    -1,   191,    -1,    -1,    -1,    -1,   196,
-      -1,   288,    -1,    -1,   291,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,    -1,    -1,
-      -1,   218,   219,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   380,    -1,    -1,    -1,   233,    -1,    -1,    -1,
-      -1,     8,    -1,    -1,    11,   380,    -1,    -1,    15,    16,
-      17,    18,    19,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    34,    -1,    -1,
-      37,    -1,    -1,    -1,   271,    42,    -1,   274,    -1,    -1,
-     380,    -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   288,   440,   380,   291,     8,    -1,    -1,    11,    -1,
-      -1,    -1,    15,    16,    17,    18,    19,    74,    -1,    -1,
-      -1,    -1,   309,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
-      -1,    -1,    -1,    -1,   482,    -1,    49,   485,   486,   487,
-      -1,   489,   490,   491,   492,   493,   494,   482,    -1,    -1,
-     485,   486,   487,    -1,   489,   490,   491,   492,   493,   494,
-      -1,    74,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   482,   380,    -1,   485,   486,   487,    -1,   489,
-     490,   491,   492,   493,   494,   482,    -1,    -1,   485,   486,
-     487,    -1,   489,   490,   491,   492,   493,   494,   175,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   191,    -1,    -1,    -1,    -1,   196,
-      -1,    -1,    -1,    -1,     8,    -1,    -1,    11,    -1,    -1,
-      -1,    15,    16,    17,    18,    19,    -1,    -1,    -1,    -1,
-      -1,   218,   219,    -1,    -1,    -1,    -1,   170,    -1,    -1,
-      34,    -1,   175,    37,    -1,    -1,   233,    -1,    42,    -1,
-      -1,    -1,    -1,    -1,    -1,    49,    -1,    -1,   191,    -1,
-      -1,    -1,    -1,   196,    -1,   482,    -1,    -1,   485,   486,
-     487,    -1,   489,   490,   491,   492,   493,   494,    -1,    -1,
-      74,    -1,    -1,    -1,   271,   218,   219,   274,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,
-     233,   288,    11,    -1,   291,    -1,    15,    16,    17,    18,
-      19,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    34,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    42,    -1,    -1,    -1,    -1,   271,    -1,
-      49,   274,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,     8,    -1,   288,    11,    -1,   291,    -1,
-      15,    16,    17,    18,    19,    74,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    34,
-      -1,   175,    37,    -1,    -1,    -1,    -1,    42,    -1,    -1,
-      -1,    -1,    -1,   380,    49,    -1,    -1,   191,    -1,    -1,
-      -1,    -1,   196,    -1,    -1,    -1,    -1,     8,    -1,    -1,
-      11,    -1,    -1,    -1,    15,    16,    17,    18,    19,    74,
-      -1,    -1,    -1,    -1,   218,   219,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    34,    -1,    -1,    -1,    -1,    -1,   233,
-      -1,    42,    -1,    -1,    -1,    -1,    -1,   380,    49,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   175,    -1,    -1,    -1,
-      -1,    -1,    -1,    74,    -1,    -1,    -1,   271,    -1,    -1,
-     274,    -1,   191,    -1,    -1,    -1,    -1,   196,    -1,    -1,
-      -1,    -1,    -1,    -1,   288,   482,    -1,   291,   485,   486,
-     487,    -1,   489,   490,   491,   492,   493,   494,    -1,   218,
-     219,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     175,    -1,    -1,    -1,   233,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   191,    -1,    -1,    -1,
-      -1,   196,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   482,
-      -1,    -1,   485,   486,   487,    -1,   489,   490,   491,   492,
-     493,   494,   271,   218,   219,   274,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   175,    -1,    -1,    -1,   233,   288,
-      -1,    -1,   291,    -1,    -1,    -1,   380,    -1,    -1,    -1,
-     191,    -1,    -1,    -1,    -1,   196,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   271,   218,   219,   274,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   233,   288,    -1,     8,   291,    -1,    11,    -1,
-      -1,    -1,    15,    16,    17,    18,    19,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
-     271,   380,    -1,   274,    -1,    -1,    49,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   288,   482,    -1,
-     291,   485,   486,   487,    -1,   489,   490,   491,   492,   493,
-     494,    74,    -1,    -1,   413,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   380,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   482,    -1,    -1,   485,   486,   487,   380,
-     489,   490,   491,   492,   493,   494,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   175,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   191,    -1,
-      -1,    -1,    -1,   196,    -1,    -1,    -1,   482,    -1,    -1,
-     485,   486,   487,    -1,   489,   490,   491,   492,   493,   494,
-      -1,    -1,    -1,    -1,    -1,   218,   219,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     233,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   482,    -1,    -1,   485,   486,   487,    -1,   489,   490,
-     491,   492,   493,   494,    -1,    -1,    -1,    -1,   271,    -1,
-      -1,   274,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   288,    -1,    -1,   291,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   380,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,     3,    -1,     5,    -1,   482,
-      -1,    -1,   485,   486,   487,    -1,   489,   490,   491,   492,
-     493,   494,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
-      58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
-      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
-     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
-     208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
-     238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   294,   295,   296,   297,
-     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   319,   320,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,   421,   422,   423,   424,   425,   426,   427,
-     428,   429,   430,   431,   432,   433,   434,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   445,   446,   447,
-     448,   449,   450,   451,   452,   453,   454,   455,   456,   457,
-     458,   459,   460,   461,   462,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,     3,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,   368,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
-     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
-     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
-      60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
-     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
-     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
-     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
-     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
-     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
-     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
-     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
-     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,   347,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-     430,   431,   432,   433,   434,   435,   436,   437,   438,   439,
-     440,   441,   442,   443,   444,   445,   446,   447,   448,   449,
-     450,   451,   452,   453,   454,   455,   456,   457,   458,   459,
-     460,   461,   462,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      -1,    62,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    75,    -1,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,    -1,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,    -1,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,   169,    -1,
-     171,   172,   173,   174,   175,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-     231,   232,   233,    -1,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-      -1,   272,   273,   274,   275,    -1,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,    -1,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,   439,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,   450,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,
-      22,    23,    24,    25,    26,    27,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,
-      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
-      52,    53,    -1,    55,    56,    57,    58,    59,    60,    -1,
-      -1,    63,    64,    65,    66,    67,    -1,    69,    70,    71,
-      72,    73,    -1,    75,    -1,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    -1,    88,    89,    90,    91,
-      92,    93,    -1,    95,    96,    97,    98,    99,   100,   101,
-     102,    -1,    -1,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,    -1,   117,    -1,   119,   120,   121,
-     122,   123,   124,    -1,   126,   127,   128,   129,   130,    -1,
-      -1,   133,   134,   135,   136,   137,    -1,   139,   140,   141,
-      -1,   143,   144,   145,    -1,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,    -1,   161,
-     162,   163,   164,    -1,   166,    -1,   168,   169,    -1,   171,
-     172,   173,   174,   175,   176,    -1,   178,    -1,   180,   181,
-     182,    -1,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,    -1,   197,   198,   199,   200,   201,
-     202,    -1,   204,   205,   206,   207,   208,   209,   210,   211,
-     212,   213,    -1,   215,    -1,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,    -1,    -1,   230,   231,
-     232,   233,    -1,   235,   236,   237,    -1,    -1,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,    -1,
-     272,   273,   274,   275,    -1,   277,   278,   279,   280,   281,
-     282,    -1,   284,   285,   286,    -1,   288,   289,   290,    -1,
-      -1,   293,   294,   295,   296,   297,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,    -1,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,    -1,   320,   321,
-     322,   323,   324,   325,    -1,   327,   328,   329,   330,   331,
-     332,   333,   334,    -1,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,    -1,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,    -1,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-      -1,   403,   404,    -1,   406,   407,   408,   409,   410,   411,
-     412,    -1,   414,   415,    -1,    -1,   418,   419,   420,   421,
-     422,   423,   424,   425,   426,   427,   428,   429,   430,   431,
-      -1,    -1,   434,   435,   436,   437,   438,   439,    -1,   441,
-     442,   443,   444,   445,   446,   447,    -1,   449,   450,   451,
-     452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,
-     462,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    32,
-      33,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-      -1,    -1,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,   174,   175,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,    -1,   272,
-     273,   274,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,     3,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,
-      24,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,
-      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
-      -1,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
-      64,    65,    66,    67,    -1,    69,    70,    71,    72,    73,
-      -1,    75,    -1,    77,    78,    79,    80,    81,    82,    83,
-      84,    85,    86,    -1,    88,    89,    90,    91,    92,    93,
-      -1,    95,    96,    97,    98,    99,   100,   101,   102,    -1,
-      -1,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,    -1,   117,    -1,   119,   120,   121,   122,   123,
-     124,    -1,   126,   127,   128,   129,   130,    -1,    -1,   133,
-     134,   135,   136,   137,    -1,   139,   140,   141,    -1,   143,
-     144,   145,    -1,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,    -1,   159,    -1,   161,   162,   163,
-     164,    -1,   166,    -1,   168,   169,    -1,   171,   172,   173,
-     174,   175,   176,    -1,   178,    -1,   180,   181,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,   195,    -1,   197,   198,   199,   200,   201,   202,    -1,
-     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
-      -1,   215,    -1,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,    -1,    -1,   230,   231,   232,   233,
-      -1,   235,   236,   237,    -1,    -1,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,   269,   270,    -1,   272,   273,
-     274,   275,    -1,   277,   278,   279,   280,   281,   282,    -1,
-     284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,
-     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,    -1,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,    -1,   320,   321,   322,   323,
-     324,   325,    -1,   327,   328,   329,   330,   331,   332,   333,
-     334,    -1,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,    -1,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,    -1,   403,
-     404,    -1,   406,   407,   408,   409,   410,   411,   412,    -1,
-     414,   415,    -1,    -1,   418,   419,   420,   421,   422,    -1,
-     424,   425,   426,   427,   428,   429,   430,   431,    -1,    -1,
-     434,   435,   436,   437,   438,   439,    -1,   441,   442,   443,
-     444,   445,   446,   447,    -1,   449,   450,   451,   452,   453,
-     454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,     3,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      -1,    46,    47,    48,    49,    50,    -1,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    -1,    -1,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    -1,
-      -1,    76,    77,    78,    79,    80,    81,    82,    -1,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    -1,
-      -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,    -1,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,    -1,   159,    -1,   161,   162,   163,   164,
-      -1,   166,   167,   168,    -1,    -1,    -1,   172,   173,   174,
-      -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,    -1,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-      -1,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,
-     235,   236,   237,    -1,    -1,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-      -1,   266,   267,   268,   269,   270,    -1,   272,   273,    -1,
-     275,    -1,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-      -1,   296,    -1,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,    -1,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,    -1,
-     375,   376,   377,   378,   379,    -1,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,    -1,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,    -1,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,   433,   434,
-     435,   436,   437,   438,    -1,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,    -1,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,     3,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
-      26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    -1,    52,    53,    -1,    55,
-      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    -1,    -1,
-      -1,    77,    78,    79,    80,    81,    82,    -1,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    -1,    -1,
-      96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-      -1,   117,    -1,   119,   120,   121,   122,   123,   124,    -1,
-     126,   127,   128,   129,   130,    -1,    -1,   133,   134,   135,
-     136,   137,    -1,   139,   140,   141,    -1,   143,   144,   145,
-      -1,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,    -1,   159,    -1,   161,   162,   163,   164,    -1,
-     166,   167,   168,    -1,    -1,    -1,   172,   173,   174,    -1,
-     176,    -1,   178,    -1,   180,   181,   182,    -1,   184,   185,
-     186,   187,   188,   189,   190,    -1,   192,   193,   194,   195,
-      -1,   197,   198,   199,   200,   201,   202,    -1,   204,    -1,
-     206,   207,   208,   209,   210,   211,   212,   213,    -1,   215,
-      -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,   225,
-     226,   227,    -1,    -1,   230,    -1,   232,   233,    -1,   235,
-     236,   237,    -1,    -1,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,    -1,
-     266,   267,   268,   269,   270,    -1,   272,   273,    -1,   275,
-      -1,   277,   278,   279,   280,   281,   282,    -1,   284,   285,
-      -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,
-     296,    -1,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,    -1,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,   323,   324,   325,
-      -1,   327,   328,   329,   330,   331,   332,   333,   334,    -1,
-     336,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,   347,   348,    -1,   350,   351,    -1,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,    -1,   369,   370,   371,   372,   373,    -1,   375,
-     376,   377,   378,   379,    -1,   381,   382,   383,   384,    -1,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,    -1,   403,   404,    -1,
-     406,    -1,   408,   409,   410,   411,   412,    -1,   414,   415,
-      -1,    -1,   418,   419,   420,   421,   422,    -1,   424,   425,
-     426,   427,   428,   429,   430,   431,    -1,   433,   434,   435,
-     436,   437,   438,    -1,    -1,   441,   442,   443,   444,   445,
-     446,   447,    -1,   449,    -1,   451,   452,   453,   454,   455,
-      -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,     3,    -1,     5,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    32,    33,    -1,    -1,    -1,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,    46,
-      47,    48,    49,    50,    -1,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    -1,    -1,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,
-      77,    78,    79,    80,    81,    82,    -1,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    -1,    96,
-      97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,    -1,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,    -1,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,    -1,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,    -1,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,    -1,    -1,   220,    -1,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,
-     237,    -1,    -1,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,    -1,   266,
-     267,   268,   269,   270,    -1,   272,   273,    -1,   275,    -1,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,   296,
-      -1,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,    -1,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,    -1,   375,   376,
-     377,   378,   379,    -1,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,    -1,   406,
-      -1,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,    -1,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,    -1,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,    -1,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    20,    21,    22,    23,    24,    25,    26,    27,
-      -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    37,
-      -1,    39,    40,    -1,    42,    43,    44,    45,    46,    47,
-      48,    -1,    50,    51,    52,    53,    -1,    55,    56,    57,
-      58,    59,    60,    -1,    -1,    63,    64,    65,    66,    67,
-      -1,    69,    70,    71,    72,    -1,    -1,    75,    -1,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,    -1,
-      88,    89,    90,    91,    92,    93,    -1,    95,    96,    97,
-      98,    99,   100,   101,   102,    -1,    -1,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,    -1,   117,
-      -1,   119,   120,   121,   122,   123,   124,    -1,   126,   127,
-     128,   129,   130,    -1,    -1,   133,   134,   135,   136,   137,
-      -1,   139,   140,   141,    -1,   143,   144,   145,    -1,   147,
-     148,   149,   150,    -1,   152,   153,   154,   155,   156,    -1,
-      -1,   159,    -1,   161,   162,   163,   164,    -1,   166,    -1,
-     168,   169,    -1,   171,   172,   173,   174,   175,   176,    -1,
-     178,    -1,    -1,    -1,   182,    -1,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,   195,    -1,   197,
-     198,   199,   200,   201,   202,    -1,   204,   205,    -1,   207,
-     208,   209,   210,   211,   212,   213,    -1,   215,    -1,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-      -1,    -1,   230,   231,   232,   233,    -1,   235,   236,   237,
-      -1,    -1,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,   269,    -1,    -1,   272,   273,   274,   275,    -1,    -1,
-     278,   279,   280,   281,   282,    -1,   284,   285,    -1,    -1,
-     288,   289,   290,    -1,    -1,   293,    -1,   295,   296,   297,
-      -1,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,    -1,   310,   311,    -1,   313,   314,    -1,   316,   317,
-     318,    -1,   320,   321,   322,   323,   324,   325,    -1,   327,
-     328,   329,   330,   331,   332,   333,   334,    -1,   336,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
-     348,    -1,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-      -1,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,    -1,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,    -1,   401,    -1,   403,   404,    -1,   406,   407,
-     408,   409,   410,   411,   412,    -1,   414,   415,    -1,    -1,
-     418,   419,    -1,   421,    -1,    -1,   424,   425,   426,   427,
-     428,   429,   430,   431,    -1,    -1,   434,   435,   436,   437,
-     438,   439,    -1,   441,   442,   443,   444,   445,    -1,   447,
-      -1,   449,   450,   451,   452,   453,   454,   455,    -1,    -1,
-     458,    -1,    -1,   461,   462,   463,   464,   465,   466,     3,
-      -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     478,   479,   480,   481,    -1,    -1,    20,    21,    22,    23,
-      24,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,
-      44,    -1,    46,    47,    48,    49,    50,    -1,    52,    53,
-      -1,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
-      64,    65,    66,    67,    -1,    69,    70,    71,    72,    73,
-      -1,    -1,    -1,    77,    78,    79,    80,    81,    82,    -1,
-      84,    85,    86,    -1,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,    -1,   117,    -1,   119,   120,   121,   122,   123,
-     124,    -1,   126,   127,   128,   129,   130,    -1,    -1,   133,
-     134,   135,   136,   137,    -1,   139,   140,   141,    -1,   143,
-     144,   145,    -1,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,    -1,   159,    -1,   161,   162,   163,
-     164,    -1,   166,    -1,   168,    -1,    -1,    -1,   172,   173,
-     174,    -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,    -1,   192,   193,
-     194,   195,    -1,   197,   198,   199,   200,   201,   202,    -1,
-     204,    -1,   206,   207,   208,   209,   210,   211,   212,   213,
-      -1,   215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,
-     224,   225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,
-      -1,   235,   236,   237,    -1,    -1,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,    -1,   266,   267,   268,   269,   270,    -1,   272,   273,
-      -1,   275,    -1,   277,   278,   279,   280,   281,   282,    -1,
-     284,   285,    -1,   287,   288,   289,   290,    -1,    -1,   293,
-     294,    -1,   296,    -1,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,    -1,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,    -1,   320,   321,   322,   323,
-     324,   325,    -1,   327,   328,   329,   330,   331,   332,   333,
-     334,    -1,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,    -1,   350,   351,    -1,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-      -1,   375,   376,   377,   378,   379,    -1,   381,   382,   383,
-     384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,    -1,   403,
-     404,    -1,   406,    -1,   408,   409,   410,   411,   412,    -1,
-     414,   415,    -1,    -1,   418,   419,   420,   421,   422,    -1,
-     424,   425,   426,   427,   428,   429,   430,   431,    -1,    -1,
-     434,   435,   436,   437,   438,    -1,    -1,   441,   442,   443,
-     444,   445,   446,   447,    -1,   449,    -1,   451,   452,   453,
-     454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,     3,    -1,
-       5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      -1,    46,    47,    48,    49,    50,    -1,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    -1,    -1,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      -1,    -1,    77,    78,    79,    80,    81,    82,    -1,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,    -1,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,    -1,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,    -1,    -1,    -1,   172,   173,   174,
-      -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,    -1,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-      -1,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,
-     235,   236,   237,    -1,    -1,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-      -1,   266,   267,   268,   269,   270,    -1,   272,   273,    -1,
-     275,    -1,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,   287,   288,   289,   290,    -1,    -1,   293,   294,
-      -1,   296,    -1,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,    -1,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,    -1,
-     375,   376,   377,   378,   379,    -1,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,    -1,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,    -1,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,    -1,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,    -1,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,     3,    -1,     5,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
-      26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    -1,    52,    53,    -1,    55,
-      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
-      66,    67,    -1,    69,    70,    71,    72,    73,    -1,    -1,
-      -1,    77,    78,    79,    80,    81,    82,    -1,    84,    85,
-      86,    -1,    88,    89,    90,    91,    92,    93,    -1,    -1,
-      96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-      -1,   117,    -1,   119,   120,   121,   122,   123,   124,    -1,
-     126,   127,   128,   129,   130,    -1,    -1,   133,   134,   135,
-     136,   137,    -1,   139,   140,   141,    -1,   143,   144,   145,
-      -1,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,    -1,   159,    -1,   161,   162,   163,   164,    -1,
-     166,    -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,
-     176,    -1,   178,    -1,   180,   181,   182,    -1,   184,   185,
-     186,   187,   188,   189,   190,    -1,   192,   193,   194,   195,
-      -1,   197,   198,   199,   200,   201,   202,    -1,   204,    -1,
-     206,   207,   208,   209,   210,   211,   212,   213,    -1,   215,
-      -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,   225,
-     226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,
-     236,   237,    -1,    -1,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,    -1,
-     266,   267,   268,   269,   270,    -1,   272,   273,    -1,   275,
-      -1,   277,   278,   279,   280,   281,   282,    -1,   284,   285,
-      -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,
-     296,    -1,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,    -1,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,    -1,   320,   321,   322,   323,   324,   325,
-      -1,   327,   328,   329,   330,   331,   332,   333,   334,    -1,
-     336,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,   347,   348,    -1,   350,   351,    -1,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,    -1,   369,   370,   371,   372,   373,    -1,   375,
-     376,   377,   378,   379,    -1,   381,   382,   383,   384,    -1,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,    -1,   403,   404,   405,
-     406,    -1,   408,   409,   410,   411,   412,    -1,   414,   415,
-      -1,    -1,   418,   419,   420,   421,   422,    -1,   424,   425,
-     426,   427,   428,   429,   430,   431,    -1,    -1,   434,   435,
-     436,   437,   438,    -1,    -1,   441,   442,   443,   444,   445,
-     446,   447,    -1,   449,    -1,   451,   452,   453,   454,   455,
-      -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,     3,     4,    -1,    -1,
-      -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,    46,
-      47,    48,    49,    50,    -1,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    -1,    -1,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,
-      77,    78,    79,    80,    81,    82,    -1,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    -1,    96,
-      97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,    -1,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,    -1,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,    -1,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,    -1,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,    -1,    -1,   220,    -1,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,
-     237,    -1,    -1,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,    -1,   266,
-     267,   268,   269,   270,    -1,   272,   273,    -1,   275,    -1,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,   296,
-      -1,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,    -1,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,    -1,   375,   376,
-     377,   378,   379,    -1,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,    -1,   406,
-      -1,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,    -1,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,    -1,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,    -1,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    39,    40,    -1,    42,    43,    44,    -1,    46,    47,
-      48,    49,    50,    -1,    52,    53,    -1,    55,    56,    57,
-      58,    59,    60,    -1,    -1,    63,    64,    65,    66,    67,
-      -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,    77,
-      78,    79,    80,    81,    82,    -1,    84,    85,    86,    -1,
-      88,    89,    90,    91,    92,    93,    -1,    -1,    96,    97,
-      98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,    -1,   117,
-      -1,   119,   120,   121,   122,   123,   124,    -1,   126,   127,
-     128,   129,   130,    -1,    -1,   133,   134,   135,   136,   137,
-      -1,   139,   140,   141,    -1,   143,   144,   145,    -1,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-      -1,   159,    -1,   161,   162,   163,   164,    -1,   166,    -1,
-     168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,    -1,
-     178,    -1,   180,   181,   182,    -1,   184,   185,   186,   187,
-     188,   189,   190,    -1,   192,   193,   194,   195,    -1,   197,
-     198,   199,   200,   201,   202,    -1,   204,    -1,   206,   207,
-     208,   209,   210,   211,   212,   213,    -1,   215,    -1,   217,
-      -1,    -1,   220,    -1,   222,   223,   224,   225,   226,   227,
-      -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,   237,
-      -1,    -1,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,    -1,   266,   267,
-     268,   269,   270,    -1,   272,   273,    -1,   275,    -1,   277,
-     278,   279,   280,   281,   282,    -1,   284,   285,    -1,    -1,
-     288,   289,   290,    -1,    -1,   293,   294,    -1,   296,    -1,
-     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,    -1,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,    -1,   320,   321,   322,   323,   324,   325,    -1,   327,
-     328,   329,   330,   331,   332,   333,   334,    -1,   336,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
-     348,    -1,   350,   351,    -1,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-      -1,   369,   370,   371,   372,   373,    -1,   375,   376,   377,
-     378,   379,    -1,   381,   382,   383,   384,    -1,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,   401,    -1,   403,   404,    -1,   406,    -1,
-     408,   409,   410,   411,   412,    -1,   414,   415,    -1,    -1,
-     418,   419,   420,   421,   422,    -1,   424,   425,   426,   427,
-     428,   429,   430,   431,    -1,    -1,   434,   435,   436,   437,
-     438,    -1,    -1,   441,   442,   443,   444,   445,   446,   447,
-      -1,   449,    -1,   451,   452,   453,   454,   455,    -1,    -1,
-     458,    -1,    -1,   461,   462,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,     3,    -1,     5,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    -1,    46,    47,    48,
-      49,    50,    -1,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    -1,    -1,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    -1,    -1,    77,    78,
-      79,    80,    81,    82,    -1,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    -1,    96,    97,    98,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,    -1,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,    -1,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-      -1,    -1,    -1,   172,   173,   174,    -1,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,    -1,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,    -1,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,    -1,
-      -1,   220,    -1,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,    -1,   232,    -1,    -1,   235,   236,   237,    -1,
-      -1,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,    -1,   266,   267,   268,
-     269,   270,    -1,   272,   273,    -1,   275,    -1,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,    -1,   296,    -1,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,    -1,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,    -1,   375,   376,   377,   378,
-     379,    -1,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,    -1,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,    -1,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-      -1,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,    -1,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,
-      40,    -1,    42,    43,    44,    -1,    46,    47,    48,    49,
-      50,    -1,    52,    53,    -1,    55,    56,    57,    58,    59,
-      60,    -1,    -1,    63,    64,    65,    66,    67,    -1,    69,
-      70,    71,    72,    73,    -1,    -1,    -1,    77,    78,    79,
-      80,    81,    82,    -1,    84,    85,    86,    -1,    88,    89,
-      90,    91,    92,    93,    -1,    -1,    96,    97,    98,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,    -1,   117,    -1,   119,
-     120,   121,   122,   123,   124,    -1,   126,   127,   128,   129,
-     130,    -1,    -1,   133,   134,   135,   136,   137,    -1,   139,
-     140,   141,    -1,   143,   144,   145,    -1,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,    -1,   159,
-      -1,   161,   162,   163,   164,    -1,   166,    -1,   168,    -1,
-      -1,    -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,
-     180,   181,   182,    -1,   184,   185,   186,   187,   188,   189,
-     190,    -1,   192,   193,   194,   195,    -1,   197,   198,   199,
-     200,   201,   202,    -1,   204,    -1,   206,   207,   208,   209,
-     210,   211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,
-     220,    -1,   222,   223,   224,   225,   226,   227,    -1,    -1,
-     230,    -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,    -1,   266,   267,   268,   269,
-     270,    -1,   272,   273,    -1,   275,    -1,   277,   278,   279,
-     280,   281,   282,    -1,   284,   285,    -1,    -1,   288,   289,
-     290,    -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,    -1,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,    -1,
-     320,   321,   322,   323,   324,   325,    -1,   327,   328,   329,
-     330,   331,   332,   333,   334,    -1,   336,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,   347,   348,    -1,
-     350,   351,    -1,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,    -1,   369,
-     370,   371,   372,   373,    -1,   375,   376,   377,   378,   379,
-      -1,   381,   382,   383,   384,    -1,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,    -1,   403,   404,    -1,   406,    -1,   408,   409,
-     410,   411,   412,    -1,   414,   415,    -1,    -1,   418,   419,
-     420,   421,   422,    -1,   424,   425,   426,   427,   428,   429,
-     430,   431,    -1,    -1,   434,   435,   436,   437,   438,    -1,
-      -1,   441,   442,   443,   444,   445,   446,   447,    -1,   449,
-      -1,   451,   452,   453,   454,   455,    -1,    -1,   458,    -1,
-      -1,   461,   462,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      -1,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      -1,    -1,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    -1,    -1,    77,    78,    79,    80,
-      81,    82,    -1,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,    -1,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,    -1,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,
-      -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-      -1,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,    -1,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,
-      -1,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-      -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,    -1,   266,   267,   268,   269,   270,
-      -1,   272,   273,    -1,   275,    -1,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,    -1,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,    -1,   375,   376,   377,   378,   379,    -1,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,    -1,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,    -1,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,    -1,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,
-      22,    23,    24,    25,    26,    27,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,
-      42,    43,    44,    -1,    46,    47,    48,    49,    50,    -1,
-      52,    53,    -1,    55,    56,    57,    58,    59,    60,    -1,
-      -1,    63,    64,    65,    66,    67,    -1,    69,    70,    71,
-      72,    73,    -1,    -1,    -1,    77,    78,    79,    80,    81,
-      82,    -1,    84,    85,    86,    -1,    88,    89,    90,    91,
-      92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,    -1,   117,    -1,   119,   120,   121,
-     122,   123,   124,    -1,   126,   127,   128,   129,   130,    -1,
-      -1,   133,   134,   135,   136,   137,    -1,   139,   140,   141,
-      -1,   143,   144,   145,    -1,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,    -1,   159,    -1,   161,
-     162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,    -1,
-     172,   173,   174,    -1,   176,    -1,   178,    -1,   180,   181,
-     182,    -1,   184,   185,   186,   187,   188,   189,   190,    -1,
-     192,   193,   194,   195,    -1,   197,   198,   199,   200,   201,
-     202,    -1,   204,    -1,   206,   207,   208,   209,   210,   211,
-     212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,    -1,
-     222,   223,   224,   225,   226,   227,    -1,    -1,   230,    -1,
-     232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,    -1,   266,   267,   268,   269,   270,    -1,
-     272,   273,    -1,   275,    -1,   277,   278,   279,   280,   281,
-     282,    -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,
-      -1,   293,   294,    -1,   296,    -1,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,    -1,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,    -1,   320,   321,
-     322,   323,   324,   325,    -1,   327,   328,   329,   330,   331,
-     332,   333,   334,    -1,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,    -1,   350,   351,
-      -1,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,    -1,   369,   370,   371,
-     372,   373,    -1,   375,   376,   377,   378,   379,    -1,   381,
-     382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-      -1,   403,   404,    -1,   406,    -1,   408,   409,   410,   411,
-     412,    -1,   414,   415,    -1,    -1,   418,   419,   420,   421,
-     422,    -1,   424,   425,   426,   427,   428,   429,   430,   431,
-      -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,   441,
-     442,   443,   444,   445,   446,   447,    -1,   449,    -1,   451,
-     452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,
-     462,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-       3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    -1,    46,    47,    48,    49,    50,    -1,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    -1,    -1,    77,    78,    79,    80,    81,    82,
-      -1,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    -1,    96,    97,    98,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,    -1,    -1,    -1,   172,
-     173,   174,    -1,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,    -1,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,    -1,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,    -1,    -1,   220,    -1,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,    -1,   232,
-      -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,    -1,   266,   267,   268,   269,   270,    -1,   272,
-     273,    -1,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,    -1,   296,    -1,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,    -1,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,    -1,   375,   376,   377,   378,   379,    -1,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,    -1,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,    -1,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,    -1,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,     3,
-      -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,
-      24,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,
-      44,    -1,    46,    47,    48,    49,    50,    -1,    52,    53,
-      -1,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
-      64,    65,    66,    67,    -1,    69,    70,    71,    72,    73,
-      -1,    -1,    -1,    77,    78,    79,    80,    81,    82,    -1,
-      84,    85,    86,    -1,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,    -1,   117,    -1,   119,   120,   121,   122,   123,
-     124,    -1,   126,   127,   128,   129,   130,    -1,    -1,   133,
-     134,   135,   136,   137,    -1,   139,   140,   141,    -1,   143,
-     144,   145,    -1,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,    -1,   159,    -1,   161,   162,   163,
-     164,    -1,   166,    -1,   168,    -1,    -1,    -1,   172,   173,
-     174,    -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,    -1,   192,   193,
-     194,   195,    -1,   197,   198,   199,   200,   201,   202,    -1,
-     204,    -1,   206,   207,   208,   209,   210,   211,   212,   213,
-      -1,   215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,
-     224,   225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,
-      -1,   235,   236,   237,    -1,    -1,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,    -1,   266,   267,   268,   269,   270,    -1,   272,   273,
-      -1,   275,    -1,   277,   278,   279,   280,   281,   282,    -1,
-     284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,
-     294,    -1,   296,    -1,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,    -1,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,    -1,   320,   321,   322,   323,
-     324,   325,    -1,   327,   328,   329,   330,   331,   332,   333,
-     334,    -1,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,    -1,   350,   351,    -1,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-      -1,   375,   376,   377,   378,   379,    -1,   381,   382,   383,
-     384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,    -1,   403,
-     404,    -1,   406,    -1,   408,   409,   410,   411,   412,    -1,
-     414,   415,    -1,    -1,   418,   419,   420,   421,   422,    -1,
-     424,   425,   426,   427,   428,   429,   430,   431,    -1,    -1,
-     434,   435,   436,   437,   438,    -1,    -1,   441,   442,   443,
-     444,   445,   446,   447,    -1,   449,    -1,   451,   452,   453,
-     454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,     3,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      -1,    46,    47,    48,    49,    50,    -1,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    -1,    -1,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      -1,    -1,    77,    78,    79,    80,    81,    82,    -1,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,    -1,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,    -1,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,    -1,    -1,    -1,   172,   173,   174,
-      -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,    -1,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-      -1,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,
-     235,   236,   237,    -1,    -1,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-      -1,   266,   267,   268,   269,   270,    -1,   272,   273,    -1,
-     275,    -1,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-      -1,   296,    -1,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,    -1,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,    -1,
-     375,   376,   377,   378,   379,    -1,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,    -1,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,    -1,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,    -1,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,    -1,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,     3,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
-      26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,    45,
-      46,    47,    48,    -1,    50,    51,    52,    53,    -1,    55,
-      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
-      66,    67,    -1,    69,    70,    71,    72,    -1,    -1,    75,
-      -1,    77,    78,    79,    80,    81,    82,    83,    84,    85,
-      86,    -1,    88,    89,    90,    91,    92,    93,    -1,    95,
-      96,    97,    98,    99,   100,   101,   102,    -1,    -1,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-      -1,   117,    -1,   119,   120,   121,   122,   123,   124,    -1,
-     126,   127,   128,   129,   130,    -1,    -1,   133,   134,   135,
-     136,   137,    -1,   139,   140,   141,    -1,   143,   144,   145,
-      -1,   147,   148,   149,   150,    -1,   152,   153,   154,   155,
-     156,    -1,    -1,   159,    -1,   161,   162,   163,   164,    -1,
-     166,    -1,   168,   169,    -1,   171,   172,   173,    -1,   175,
-     176,    -1,   178,    -1,    -1,    -1,   182,    -1,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-      -1,   197,   198,   199,   200,   201,   202,    -1,   204,   205,
-      -1,   207,   208,   209,   210,   211,   212,   213,    -1,   215,
-      -1,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,    -1,    -1,   230,   231,   232,   233,    -1,   235,
-     236,   237,    -1,    -1,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,    -1,    -1,   272,   273,   274,   275,
-      -1,    -1,   278,   279,   280,   281,   282,    -1,   284,   285,
-      -1,    -1,   288,   289,   290,    -1,    -1,   293,    -1,   295,
-     296,   297,    -1,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,    -1,   310,   311,    -1,   313,   314,    -1,
-     316,   317,   318,    -1,   320,   321,   322,   323,   324,   325,
-      -1,   327,   328,   329,   330,   331,   332,   333,   334,    -1,
-     336,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,   347,   348,    -1,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,    -1,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,    -1,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,    -1,   401,    -1,   403,   404,    -1,
-     406,   407,   408,   409,   410,   411,   412,    -1,   414,   415,
-      -1,    -1,   418,   419,    -1,   421,    -1,    -1,   424,   425,
-     426,   427,   428,   429,   430,   431,    -1,    -1,   434,   435,
-     436,   437,   438,   439,    -1,   441,   442,   443,   444,   445,
-      -1,   447,    -1,   449,   450,   451,   452,   453,   454,   455,
-      -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,   465,
-     466,     3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   478,   479,   480,   481,    -1,    -1,    20,    21,
-      22,    23,    24,    25,    26,    27,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,
-      42,    43,    44,    -1,    46,    47,    48,    49,    50,    -1,
-      52,    53,    -1,    55,    56,    57,    58,    59,    60,    -1,
-      -1,    63,    64,    65,    66,    67,    -1,    69,    70,    71,
-      72,    73,    -1,    -1,    -1,    77,    78,    79,    80,    81,
-      82,    -1,    84,    85,    86,    -1,    88,    89,    90,    91,
-      92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,    -1,   117,    -1,   119,   120,   121,
-     122,   123,   124,    -1,   126,   127,   128,   129,   130,    -1,
-      -1,   133,   134,   135,   136,   137,    -1,   139,   140,   141,
-      -1,   143,   144,   145,    -1,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,    -1,   159,    -1,   161,
-     162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,    -1,
-     172,   173,   174,    -1,   176,    -1,   178,    -1,   180,   181,
-     182,    -1,   184,   185,   186,   187,   188,   189,   190,    -1,
-     192,   193,   194,   195,    -1,   197,   198,   199,   200,   201,
-     202,    -1,   204,    -1,   206,   207,   208,   209,   210,   211,
-     212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,    -1,
-     222,   223,   224,   225,   226,   227,    -1,    -1,   230,    -1,
-     232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,    -1,   266,   267,   268,   269,   270,    -1,
-     272,   273,    -1,   275,    -1,   277,   278,   279,   280,   281,
-     282,    -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,
-      -1,   293,   294,    -1,   296,    -1,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,    -1,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,    -1,   320,   321,
-     322,   323,   324,   325,    -1,   327,   328,   329,   330,   331,
-     332,   333,   334,    -1,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,    -1,   350,   351,
-      -1,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,    -1,   369,   370,   371,
-     372,   373,    -1,   375,   376,   377,   378,   379,    -1,   381,
-     382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-      -1,   403,   404,    -1,   406,    -1,   408,   409,   410,   411,
-     412,    -1,   414,   415,    -1,    -1,   418,   419,   420,   421,
-     422,    -1,   424,   425,   426,   427,   428,   429,   430,   431,
-      -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,   441,
-     442,   443,   444,   445,   446,   447,    -1,   449,    -1,   451,
-     452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,
-     462,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-       3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    -1,    46,    47,    48,    49,    50,    -1,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    -1,    -1,    77,    78,    79,    80,    81,    82,
-      -1,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    -1,    96,    97,    98,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,    -1,    -1,    -1,   172,
-     173,   174,    -1,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,    -1,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,    -1,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,    -1,    -1,   220,    -1,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,    -1,   232,
-      -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,    -1,   266,   267,   268,   269,   270,    -1,   272,
-     273,    -1,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,    -1,   296,    -1,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,    -1,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,    -1,   375,   376,   377,   378,   379,    -1,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,    -1,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,    -1,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,    -1,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,     3,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,
-      24,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,
-      44,    45,    46,    47,    48,    -1,    50,    51,    52,    53,
-      -1,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
-      64,    65,    66,    67,    -1,    69,    70,    71,    72,    -1,
-      -1,    75,    -1,    77,    78,    79,    80,    81,    82,    83,
-      84,    85,    86,    -1,    88,    89,    90,    91,    92,    93,
-      -1,    95,    96,    97,    98,    99,   100,   101,   102,    -1,
-      -1,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,    -1,   117,    -1,   119,   120,   121,   122,   123,
-     124,    -1,   126,   127,   128,   129,   130,    -1,    -1,   133,
-     134,   135,   136,   137,    -1,   139,   140,   141,    -1,   143,
-     144,   145,    -1,   147,   148,   149,   150,    -1,   152,   153,
-     154,   155,   156,    -1,    -1,   159,    -1,   161,   162,   163,
-     164,    -1,   166,    -1,   168,   169,    -1,   171,   172,   173,
-      -1,   175,   176,    -1,   178,    -1,    -1,    -1,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,   195,    -1,   197,   198,   199,   200,   201,   202,    -1,
-     204,   205,    -1,   207,   208,   209,   210,   211,   212,   213,
-      -1,   215,    -1,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,    -1,    -1,   230,   231,   232,   233,
-      -1,   235,   236,   237,    -1,    -1,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,   269,    -1,    -1,   272,   273,
-     274,   275,    -1,    -1,   278,   279,   280,   281,   282,    -1,
-     284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,
-      -1,   295,   296,   297,    -1,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,    -1,   310,   311,    -1,   313,
-     314,    -1,   316,   317,   318,    -1,   320,   321,   322,   323,
-     324,   325,    -1,   327,   328,   329,   330,   331,   332,   333,
-     334,    -1,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,    -1,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,    -1,   401,    -1,   403,
-     404,    -1,   406,   407,   408,   409,   410,   411,   412,    -1,
-     414,   415,    -1,    -1,   418,   419,    -1,   421,    -1,    -1,
-     424,   425,   426,   427,   428,   429,   430,   431,    -1,    -1,
-     434,   435,   436,   437,   438,   439,    -1,   441,   442,   443,
-     444,   445,    -1,   447,    -1,   449,   450,   451,   452,   453,
-     454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,
-     464,   465,   466,     3,    -1,     5,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   478,   479,   480,   481,    -1,    -1,
-      20,    21,    22,    23,    24,    25,    26,    27,    -1,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,
-      40,    -1,    42,    43,    44,    -1,    46,    47,    48,    49,
-      50,    -1,    52,    53,    -1,    55,    56,    57,    58,    59,
-      60,    -1,    -1,    63,    64,    65,    66,    67,    -1,    69,
-      70,    71,    72,    73,    -1,    -1,    -1,    77,    78,    79,
-      80,    81,    82,    -1,    84,    85,    86,    -1,    88,    89,
-      90,    91,    92,    93,    -1,    -1,    96,    97,    98,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,    -1,   117,    -1,   119,
-     120,   121,   122,   123,   124,    -1,   126,   127,   128,   129,
-     130,    -1,    -1,   133,   134,   135,   136,   137,    -1,   139,
-     140,   141,    -1,   143,   144,   145,    -1,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,    -1,   159,
-      -1,   161,   162,   163,   164,    -1,   166,    -1,   168,    -1,
-      -1,    -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,
-     180,   181,   182,    -1,   184,   185,   186,   187,   188,   189,
-     190,    -1,   192,   193,   194,   195,    -1,   197,   198,   199,
-     200,   201,   202,    -1,   204,    -1,   206,   207,   208,   209,
-     210,   211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,
-     220,    -1,   222,   223,   224,   225,   226,   227,    -1,    -1,
-     230,    -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,    -1,   266,   267,   268,   269,
-     270,    -1,   272,   273,    -1,   275,    -1,   277,   278,   279,
-     280,   281,   282,    -1,   284,   285,    -1,    -1,   288,   289,
-     290,    -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,    -1,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,    -1,
-     320,   321,   322,   323,   324,   325,    -1,   327,   328,   329,
-     330,   331,   332,   333,   334,    -1,   336,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,   347,   348,    -1,
-     350,   351,    -1,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,    -1,   369,
-     370,   371,   372,   373,    -1,   375,   376,   377,   378,   379,
-      -1,   381,   382,   383,   384,    -1,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,    -1,   403,   404,    -1,   406,    -1,   408,   409,
-     410,   411,   412,    -1,   414,   415,    -1,    -1,   418,   419,
-     420,   421,   422,    -1,   424,   425,   426,   427,   428,   429,
-     430,   431,    -1,    -1,   434,   435,   436,   437,   438,    -1,
-      -1,   441,   442,   443,   444,   445,   446,   447,    -1,   449,
-      -1,   451,   452,   453,   454,   455,    -1,    -1,   458,    -1,
-      -1,   461,   462,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    37,    -1,    39,    40,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      -1,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      -1,    -1,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    -1,    -1,    77,    78,    79,    80,
-      81,    82,    -1,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,    -1,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,    -1,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,
-      -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-      -1,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,    -1,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,
-      -1,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-      -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,    -1,   266,   267,   268,   269,   270,
-      -1,   272,   273,    -1,   275,    -1,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,    -1,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,    -1,   375,   376,   377,   378,   379,    -1,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,    -1,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,    -1,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,    -1,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,
-      22,    23,    24,    25,    26,    27,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    37,    -1,    39,    40,    -1,
-      42,    43,    44,    -1,    46,    47,    48,    49,    50,    -1,
-      52,    53,    -1,    55,    56,    57,    58,    59,    60,    -1,
-      -1,    63,    64,    65,    66,    67,    -1,    69,    70,    71,
-      72,    73,    -1,    -1,    -1,    77,    78,    79,    80,    81,
-      82,    -1,    84,    85,    86,    -1,    88,    89,    90,    91,
-      92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,    -1,   117,    -1,   119,   120,   121,
-     122,   123,   124,    -1,   126,   127,   128,   129,   130,    -1,
-      -1,   133,   134,   135,   136,   137,    -1,   139,   140,   141,
-      -1,   143,   144,   145,    -1,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,    -1,   159,    -1,   161,
-     162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,    -1,
-     172,   173,   174,    -1,   176,    -1,   178,    -1,   180,   181,
-     182,    -1,   184,   185,   186,   187,   188,   189,   190,    -1,
-     192,   193,   194,   195,    -1,   197,   198,   199,   200,   201,
-     202,    -1,   204,    -1,   206,   207,   208,   209,   210,   211,
-     212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,    -1,
-     222,   223,   224,   225,   226,   227,    -1,    -1,   230,    -1,
-     232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,    -1,   266,   267,   268,   269,   270,    -1,
-     272,   273,    -1,   275,    -1,   277,   278,   279,   280,   281,
-     282,    -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,
-      -1,   293,   294,    -1,   296,    -1,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,    -1,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,    -1,   320,   321,
-     322,   323,   324,   325,    -1,   327,   328,   329,   330,   331,
-     332,   333,   334,    -1,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,    -1,   350,   351,
-      -1,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,    -1,   369,   370,   371,
-     372,   373,    -1,   375,   376,   377,   378,   379,    -1,   381,
-     382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-      -1,   403,   404,    -1,   406,    -1,   408,   409,   410,   411,
-     412,    -1,   414,   415,    -1,    -1,   418,   419,   420,   421,
-     422,    -1,   424,   425,   426,   427,   428,   429,   430,   431,
-      -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,   441,
-     442,   443,   444,   445,   446,   447,    -1,   449,    -1,   451,
-     452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,
-     462,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-       3,    -1,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    -1,    46,    47,    48,    49,    50,    -1,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    -1,    -1,    77,    78,    79,    80,    81,    82,
-      -1,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    -1,    96,    97,    98,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,    -1,    -1,    -1,   172,
-     173,   174,    -1,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,    -1,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,    -1,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,    -1,    -1,   220,    -1,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,    -1,   232,
-      -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,    -1,   266,   267,   268,   269,   270,    -1,   272,
-     273,    -1,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,    -1,   296,    -1,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,    -1,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,    -1,   375,   376,   377,   378,   379,    -1,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,    -1,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,    -1,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,    -1,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,     3,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,
-      24,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,
-      44,    -1,    46,    47,    48,    49,    50,    -1,    52,    53,
-      -1,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
-      64,    65,    66,    67,    -1,    69,    70,    71,    72,    73,
-      -1,    -1,    -1,    77,    78,    79,    80,    81,    82,    -1,
-      84,    85,    86,    -1,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,    -1,   117,    -1,   119,   120,   121,   122,   123,
-     124,    -1,   126,   127,   128,   129,   130,    -1,    -1,   133,
-     134,   135,   136,   137,    -1,   139,   140,   141,    -1,   143,
-     144,   145,    -1,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,    -1,   159,    -1,   161,   162,   163,
-     164,    -1,   166,    -1,   168,    -1,    -1,    -1,   172,   173,
-     174,    -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,    -1,   192,   193,
-     194,   195,    -1,   197,   198,   199,   200,   201,   202,    -1,
-     204,    -1,   206,   207,   208,   209,   210,   211,   212,   213,
-      -1,   215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,
-     224,   225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,
-      -1,   235,   236,   237,    -1,    -1,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,    -1,   266,   267,   268,   269,   270,    -1,   272,   273,
-      -1,   275,    -1,   277,   278,   279,   280,   281,   282,    -1,
-     284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,
-     294,    -1,   296,    -1,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,    -1,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,    -1,   320,   321,   322,   323,
-     324,   325,    -1,   327,   328,   329,   330,   331,   332,   333,
-     334,    -1,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,    -1,   350,   351,    -1,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-      -1,   375,   376,   377,   378,   379,    -1,   381,   382,   383,
-     384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,    -1,   403,
-     404,    -1,   406,    -1,   408,   409,   410,   411,   412,    -1,
-     414,   415,    -1,    -1,   418,   419,   420,   421,   422,    -1,
-     424,   425,   426,   427,   428,   429,   430,   431,    -1,    -1,
-     434,   435,   436,   437,   438,    -1,    -1,   441,   442,   443,
-     444,   445,   446,   447,    -1,   449,    -1,   451,   452,   453,
-     454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,     3,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      -1,    46,    47,    48,    49,    50,    -1,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    -1,    -1,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      -1,    -1,    77,    78,    79,    80,    81,    82,    -1,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,    -1,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,    -1,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,    -1,    -1,    -1,   172,   173,   174,
-      -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,    -1,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-      -1,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,
-     235,   236,   237,    -1,    -1,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-      -1,   266,   267,   268,   269,   270,    -1,   272,   273,    -1,
-     275,    -1,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-      -1,   296,    -1,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,    -1,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,    -1,
-     375,   376,   377,   378,   379,    -1,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,    -1,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,    -1,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,    -1,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,    -1,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,     3,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
-      26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    -1,    52,    53,    -1,    55,
-      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
-      66,    67,    -1,    69,    70,    71,    72,    73,    -1,    -1,
-      -1,    77,    78,    79,    80,    81,    82,    -1,    84,    85,
-      86,    -1,    88,    89,    90,    91,    92,    93,    -1,    -1,
-      96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-      -1,   117,    -1,   119,   120,   121,   122,   123,   124,    -1,
-     126,   127,   128,   129,   130,    -1,    -1,   133,   134,   135,
-     136,   137,    -1,   139,   140,   141,    -1,   143,   144,   145,
-      -1,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,    -1,   159,    -1,   161,   162,   163,   164,    -1,
-     166,    -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,
-     176,    -1,   178,    -1,   180,   181,   182,    -1,   184,   185,
-     186,   187,   188,   189,   190,    -1,   192,   193,   194,   195,
-      -1,   197,   198,   199,   200,   201,   202,    -1,   204,    -1,
-     206,   207,   208,   209,   210,   211,   212,   213,    -1,   215,
-      -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,   225,
-     226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,
-     236,   237,    -1,    -1,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,    -1,
-     266,   267,   268,   269,   270,    -1,   272,   273,    -1,   275,
-      -1,   277,   278,   279,   280,   281,   282,    -1,   284,   285,
-      -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,
-     296,    -1,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,    -1,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,    -1,   320,   321,   322,   323,   324,   325,
-      -1,   327,   328,   329,   330,   331,   332,   333,   334,    -1,
-     336,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,   347,   348,    -1,   350,   351,    -1,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,    -1,   369,   370,   371,   372,   373,    -1,   375,
-     376,   377,   378,   379,    -1,   381,   382,   383,   384,    -1,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,    -1,   403,   404,    -1,
-     406,    -1,   408,   409,   410,   411,   412,    -1,   414,   415,
-      -1,    -1,   418,   419,   420,   421,   422,    -1,   424,   425,
-     426,   427,   428,   429,   430,   431,    -1,    -1,   434,   435,
-     436,   437,   438,    -1,    -1,   441,   442,   443,   444,   445,
-     446,   447,    -1,   449,    -1,   451,   452,   453,   454,   455,
-      -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,     3,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,    46,
-      47,    48,    49,    50,    -1,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    -1,    -1,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,
-      77,    78,    79,    80,    81,    82,    -1,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    -1,    96,
-      97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,    -1,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,    -1,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,
-      -1,   178,    -1,   180,   181,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,    -1,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,    -1,   206,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,    -1,    -1,   220,    -1,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,
-     237,    -1,    -1,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,    -1,   266,
-     267,   268,   269,   270,    -1,   272,   273,    -1,   275,    -1,
-     277,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,   296,
-      -1,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,    -1,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,    -1,   375,   376,
-     377,   378,   379,    -1,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,    -1,   403,   404,    -1,   406,
-      -1,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,   420,   421,   422,    -1,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,    -1,    -1,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,    -1,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,     3,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    20,    21,    22,    23,    24,    25,    26,    27,
-      -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    39,    40,    -1,    42,    43,    44,    -1,    46,    47,
-      48,    49,    50,    -1,    52,    53,    -1,    55,    56,    57,
-      58,    59,    60,    -1,    -1,    63,    64,    65,    66,    67,
-      -1,    69,    70,    71,    72,    73,    -1,    -1,    -1,    77,
-      78,    79,    80,    81,    82,    -1,    84,    85,    86,    -1,
-      88,    89,    90,    91,    92,    93,    -1,    -1,    96,    97,
-      98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,    -1,   117,
-      -1,   119,   120,   121,   122,   123,   124,    -1,   126,   127,
-     128,   129,   130,    -1,    -1,   133,   134,   135,   136,   137,
-      -1,   139,   140,   141,    -1,   143,   144,   145,    -1,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-      -1,   159,    -1,   161,   162,   163,   164,    -1,   166,    -1,
-     168,    -1,    -1,    -1,   172,   173,   174,    -1,   176,    -1,
-     178,    -1,   180,   181,   182,    -1,   184,   185,   186,   187,
-     188,   189,   190,    -1,   192,   193,   194,   195,    -1,   197,
-     198,   199,   200,   201,   202,    -1,   204,    -1,   206,   207,
-     208,   209,   210,   211,   212,   213,    -1,   215,    -1,   217,
-      -1,    -1,   220,    -1,   222,   223,   224,   225,   226,   227,
-      -1,    -1,   230,    -1,   232,    -1,    -1,   235,   236,   237,
-      -1,    -1,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,    -1,   266,   267,
-     268,   269,   270,    -1,   272,   273,    -1,   275,    -1,   277,
-     278,   279,   280,   281,   282,    -1,   284,   285,    -1,    -1,
-     288,   289,   290,    -1,    -1,   293,   294,    -1,   296,    -1,
-     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,    -1,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,    -1,   320,   321,   322,   323,   324,   325,    -1,   327,
-     328,   329,   330,   331,   332,   333,   334,    -1,   336,   337,
-     338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
-     348,    -1,   350,   351,    -1,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,   364,   365,   366,   367,
-      -1,   369,   370,   371,   372,   373,    -1,   375,   376,   377,
-     378,   379,    -1,   381,   382,   383,   384,    -1,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,   401,    -1,   403,   404,    -1,   406,    -1,
-     408,   409,   410,   411,   412,    -1,   414,   415,    -1,    -1,
-     418,   419,   420,   421,   422,    -1,   424,   425,   426,   427,
-     428,   429,   430,   431,    -1,    -1,   434,   435,   436,   437,
-     438,    -1,    -1,   441,   442,   443,   444,   445,   446,   447,
-      -1,   449,    -1,   451,   452,   453,   454,   455,    -1,    -1,
-     458,    -1,    -1,   461,   462,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,     3,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    -1,    46,    47,    48,
-      49,    50,    -1,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    -1,    -1,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    -1,    -1,    77,    78,
-      79,    80,    81,    82,    -1,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    -1,    96,    97,    98,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,    -1,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,    -1,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-      -1,    -1,    -1,   172,   173,   174,    -1,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,    -1,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,    -1,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,    -1,
-      -1,   220,    -1,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,    -1,   232,    -1,    -1,   235,   236,   237,    -1,
-      -1,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,    -1,   266,   267,   268,
-     269,   270,    -1,   272,   273,    -1,   275,    -1,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,    -1,   296,    -1,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,   328,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,    -1,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,    -1,   375,   376,   377,   378,
-     379,    -1,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,    -1,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,    -1,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-      -1,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,    -1,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      20,    21,    22,    23,    24,    25,    26,    27,    -1,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,
-      40,    -1,    42,    43,    44,    -1,    46,    47,    48,    49,
-      50,    -1,    52,    53,    -1,    55,    56,    57,    58,    59,
-      60,    -1,    -1,    63,    64,    65,    66,    67,    -1,    69,
-      70,    71,    72,    73,    -1,    -1,    -1,    77,    78,    79,
-      80,    81,    82,    -1,    84,    85,    86,    -1,    88,    89,
-      90,    91,    92,    93,    -1,    -1,    96,    97,    98,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,    -1,   117,    -1,   119,
-     120,   121,   122,   123,   124,    -1,   126,   127,   128,   129,
-     130,    -1,    -1,   133,   134,   135,   136,   137,    -1,   139,
-     140,   141,    -1,   143,   144,   145,    -1,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,    -1,   159,
-      -1,   161,   162,   163,   164,    -1,   166,    -1,   168,    -1,
-      -1,    -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,
-     180,   181,   182,    -1,   184,   185,   186,   187,   188,   189,
-     190,    -1,   192,   193,   194,   195,    -1,   197,   198,   199,
-     200,   201,   202,    -1,   204,    -1,   206,   207,   208,   209,
-     210,   211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,
-     220,    -1,   222,   223,   224,   225,   226,   227,    -1,    -1,
-     230,    -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,    -1,   266,   267,   268,   269,
-     270,    -1,   272,   273,    -1,   275,    -1,   277,   278,   279,
-     280,   281,   282,    -1,   284,   285,    -1,    -1,   288,   289,
-     290,    -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,
-     300,   301,   302,   303,   304,   305,   306,   307,   308,    -1,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,    -1,
-     320,   321,   322,   323,   324,   325,    -1,   327,   328,   329,
-     330,   331,   332,   333,   334,    -1,   336,   337,   338,   339,
-     340,   341,   342,   343,   344,   345,   346,   347,   348,    -1,
-     350,   351,    -1,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,   366,   367,    -1,   369,
-     370,   371,   372,   373,    -1,   375,   376,   377,   378,   379,
-      -1,   381,   382,   383,   384,    -1,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,    -1,   403,   404,    -1,   406,    -1,   408,   409,
-     410,   411,   412,    -1,   414,   415,    -1,    -1,   418,   419,
-     420,   421,   422,    -1,   424,   425,   426,   427,   428,   429,
-     430,   431,    -1,    -1,   434,   435,   436,   437,   438,    -1,
-      -1,   441,   442,   443,   444,   445,   446,   447,    -1,   449,
-      -1,   451,   452,   453,   454,   455,    -1,    -1,   458,    -1,
-      -1,   461,   462,   463,   464,   465,   466,   467,   468,   469,
-     470,   471,   472,   473,   474,   475,   476,   477,   478,   479,
-     480,   481,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    40,
-      -1,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
-      -1,    52,    53,    -1,    55,    56,    57,    58,    59,    60,
-      -1,    -1,    63,    64,    65,    66,    67,    -1,    69,    70,
-      71,    72,    73,    -1,    -1,    -1,    77,    78,    79,    80,
-      81,    82,    -1,    84,    85,    86,    -1,    88,    89,    90,
-      91,    92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,    -1,   117,    -1,   119,   120,
-     121,   122,   123,   124,    -1,   126,   127,   128,   129,   130,
-      -1,    -1,   133,   134,   135,   136,   137,    -1,   139,   140,
-     141,    -1,   143,   144,   145,    -1,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,    -1,   159,    -1,
-     161,   162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,
-      -1,   172,   173,   174,    -1,   176,    -1,   178,    -1,   180,
-     181,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-      -1,   192,   193,   194,   195,    -1,   197,   198,   199,   200,
-     201,   202,    -1,   204,    -1,   206,   207,   208,   209,   210,
-     211,   212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,
-      -1,   222,   223,   224,   225,   226,   227,    -1,    -1,   230,
-      -1,   232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,    -1,   266,   267,   268,   269,   270,
-      -1,   272,   273,    -1,   275,    -1,   277,   278,   279,   280,
-     281,   282,    -1,   284,   285,    -1,    -1,   288,   289,   290,
-      -1,    -1,   293,   294,    -1,   296,    -1,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,    -1,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,    -1,   320,
-     321,   322,   323,   324,   325,    -1,   327,   328,   329,   330,
-     331,   332,   333,   334,    -1,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,    -1,   350,
-     351,    -1,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,   367,    -1,   369,   370,
-     371,   372,   373,    -1,   375,   376,   377,   378,   379,    -1,
-     381,   382,   383,   384,    -1,   386,   387,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,    -1,   403,   404,    -1,   406,    -1,   408,   409,   410,
-     411,   412,    -1,   414,   415,    -1,    -1,   418,   419,   420,
-     421,   422,    -1,   424,   425,   426,   427,   428,   429,   430,
-     431,    -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,
-     441,   442,   443,   444,   445,   446,   447,    -1,   449,    -1,
-     451,   452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,
-      22,    23,    24,    25,    26,    27,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    37,    -1,    39,    40,    -1,
-      42,    43,    44,    -1,    46,    47,    48,    49,    50,    -1,
-      52,    53,    -1,    55,    56,    57,    58,    59,    60,    -1,
-      -1,    63,    64,    65,    66,    67,    -1,    69,    70,    71,
-      72,    73,    -1,    -1,    -1,    77,    78,    79,    80,    81,
-      82,    -1,    84,    85,    86,    -1,    88,    89,    90,    91,
-      92,    93,    -1,    -1,    96,    97,    98,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,    -1,   117,    -1,   119,   120,   121,
-     122,   123,   124,    -1,   126,   127,   128,   129,   130,    -1,
-      -1,   133,   134,   135,   136,   137,    -1,   139,   140,   141,
-      -1,   143,   144,   145,    -1,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,    -1,   159,    -1,   161,
-     162,   163,   164,    -1,   166,    -1,   168,    -1,    -1,    -1,
-     172,   173,   174,    -1,   176,    -1,   178,    -1,   180,   181,
-     182,    -1,   184,   185,   186,   187,   188,   189,   190,    -1,
-     192,   193,   194,   195,    -1,   197,   198,   199,   200,   201,
-     202,    -1,   204,    -1,   206,   207,   208,   209,   210,   211,
-     212,   213,    -1,   215,    -1,   217,    -1,    -1,   220,    -1,
-     222,   223,   224,   225,   226,   227,    -1,    -1,   230,    -1,
-     232,    -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,    -1,   266,   267,   268,   269,   270,    -1,
-     272,   273,    -1,   275,    -1,   277,   278,   279,   280,   281,
-     282,    -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,
-      -1,   293,   294,    -1,   296,    -1,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,    -1,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,    -1,   320,   321,
-     322,   323,   324,   325,    -1,   327,   328,   329,   330,   331,
-     332,   333,   334,    -1,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,    -1,   350,   351,
-      -1,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,    -1,   369,   370,   371,
-     372,   373,    -1,    -1,   376,   377,   378,   379,    -1,   381,
-     382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-      -1,   403,   404,    -1,   406,    -1,   408,   409,   410,   411,
-     412,    -1,   414,   415,    -1,    -1,   418,   419,   420,   421,
-     422,    -1,   424,   425,   426,   427,   428,   429,   430,   431,
-      -1,    -1,   434,   435,   436,   437,   438,    -1,    -1,   441,
-     442,   443,   444,   445,   446,   447,    -1,   449,    -1,   451,
-     452,   453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,
-     462,   463,   464,   465,   466,   467,   468,   469,   470,   471,
-     472,   473,   474,   475,   476,   477,   478,   479,   480,   481,
-       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    -1,    46,    47,    48,    49,    50,    -1,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      73,    -1,    -1,    -1,    77,    78,    79,    80,    81,    82,
-      -1,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    -1,    96,    97,    98,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,    -1,    -1,    -1,   172,
-     173,   174,    -1,   176,    -1,   178,    -1,   180,   181,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,    -1,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,    -1,   206,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,    -1,    -1,   220,    -1,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,    -1,   232,
-      -1,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,    -1,   266,   267,   268,   269,   270,    -1,   272,
-     273,    -1,   275,    -1,   277,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,   294,    -1,   296,    -1,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,    -1,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,    -1,   375,   376,   377,   378,   379,    -1,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,    -1,
-     403,   404,    -1,   406,    -1,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,   420,   421,   422,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,    -1,    -1,   441,   442,
-     443,   444,   445,   446,   447,    -1,   449,    -1,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,     3,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,
-      24,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,
-      44,    -1,    46,    47,    48,    49,    50,    -1,    52,    53,
-      -1,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
-      64,    65,    66,    67,    -1,    69,    70,    71,    72,    73,
-      -1,    -1,    -1,    77,    78,    79,    80,    81,    82,    -1,
-      84,    85,    86,    -1,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,    -1,   117,    -1,   119,   120,   121,   122,   123,
-     124,    -1,   126,   127,   128,   129,   130,    -1,    -1,   133,
-     134,   135,   136,   137,    -1,   139,   140,   141,    -1,   143,
-     144,   145,    -1,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,    -1,   159,    -1,   161,   162,   163,
-     164,    -1,   166,    -1,   168,    -1,    -1,    -1,   172,   173,
-     174,    -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,    -1,   192,   193,
-     194,   195,    -1,   197,   198,   199,   200,   201,   202,    -1,
-     204,    -1,   206,   207,   208,   209,   210,   211,   212,   213,
-      -1,   215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,
-     224,   225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,
-      -1,   235,   236,   237,    -1,    -1,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,    -1,   266,   267,   268,   269,   270,    -1,   272,   273,
-      -1,   275,    -1,   277,   278,   279,   280,   281,   282,    -1,
-     284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,
-     294,    -1,   296,    -1,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,    -1,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,    -1,   320,   321,   322,   323,
-     324,   325,    -1,   327,   328,   329,   330,   331,   332,   333,
-     334,    -1,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,    -1,   350,   351,    -1,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,   366,   367,    -1,   369,   370,   371,   372,   373,
-      -1,   375,   376,   377,   378,   379,    -1,   381,   382,   383,
-     384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,    -1,   403,
-     404,    -1,   406,    -1,   408,   409,   410,   411,   412,    -1,
-     414,   415,    -1,    -1,   418,   419,   420,   421,   422,    -1,
-     424,   425,   426,   427,   428,   429,   430,   431,    -1,    -1,
-     434,   435,   436,   437,   438,    -1,    -1,   441,   442,   443,
-     444,   445,   446,   447,    -1,   449,    -1,   451,   452,   453,
-     454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,
-     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
-     474,   475,   476,   477,   478,   479,   480,   481,     3,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,
-      -1,    46,    47,    48,    49,    50,    -1,    52,    53,    -1,
-      55,    56,    57,    58,    59,    60,    -1,    -1,    63,    64,
-      65,    66,    67,    -1,    69,    70,    71,    72,    73,    -1,
-      -1,    -1,    77,    78,    79,    80,    81,    82,    -1,    84,
-      85,    86,    -1,    88,    89,    90,    91,    92,    93,    -1,
-      -1,    96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,    -1,   117,    -1,   119,   120,   121,   122,   123,   124,
-      -1,   126,   127,   128,   129,   130,    -1,    -1,   133,   134,
-     135,   136,   137,    -1,   139,   140,   141,    -1,   143,   144,
-     145,    -1,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,    -1,   159,    -1,   161,   162,   163,   164,
-      -1,   166,    -1,   168,    -1,    -1,    -1,   172,   173,   174,
-      -1,   176,    -1,   178,    -1,   180,   181,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,    -1,   192,   193,   194,
-     195,    -1,   197,   198,   199,   200,   201,   202,    -1,   204,
-      -1,   206,   207,   208,   209,   210,   211,   212,   213,    -1,
-     215,    -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,
-     225,   226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,
-     235,   236,   237,    -1,    -1,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-      -1,   266,   267,   268,   269,   270,    -1,   272,   273,    -1,
-     275,    -1,   277,   278,   279,   280,   281,   282,    -1,   284,
-     285,    -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,
-      -1,   296,    -1,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,    -1,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,    -1,   320,   321,   322,   323,   324,
-     325,    -1,   327,   328,   329,   330,   331,   332,   333,   334,
-      -1,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,    -1,   350,   351,    -1,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,    -1,   369,   370,   371,   372,   373,    -1,
-     375,   376,   377,   378,   379,    -1,   381,   382,   383,   384,
-      -1,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,    -1,   403,   404,
-      -1,   406,    -1,   408,   409,   410,   411,   412,    -1,   414,
-     415,    -1,    -1,   418,   419,   420,   421,   422,    -1,   424,
-     425,   426,   427,   428,   429,   430,   431,    -1,    -1,   434,
-     435,   436,   437,   438,    -1,    -1,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,    -1,   451,   452,   453,   454,
-     455,    -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,     3,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
-      26,    27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    39,    40,    -1,    42,    43,    44,    -1,
-      46,    47,    48,    49,    50,    -1,    52,    53,    -1,    55,
-      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
-      66,    67,    -1,    69,    70,    71,    72,    73,    -1,    -1,
-      -1,    77,    78,    79,    80,    81,    82,    -1,    84,    85,
-      86,    -1,    88,    89,    90,    91,    92,    93,    -1,    -1,
-      96,    97,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-      -1,   117,    -1,   119,   120,   121,   122,   123,   124,    -1,
-     126,   127,   128,   129,   130,    -1,    -1,   133,   134,   135,
-     136,   137,    -1,   139,   140,   141,    -1,   143,   144,   145,
-      -1,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,    -1,   159,    -1,   161,   162,   163,   164,    -1,
-     166,    -1,   168,    -1,    -1,    -1,   172,   173,   174,    -1,
-     176,    -1,   178,    -1,   180,   181,   182,    -1,   184,   185,
-     186,   187,   188,   189,   190,    -1,   192,   193,   194,   195,
-      -1,   197,   198,   199,   200,   201,   202,    -1,   204,    -1,
-     206,   207,   208,   209,   210,   211,   212,   213,    -1,   215,
-      -1,   217,    -1,    -1,   220,    -1,   222,   223,   224,   225,
-     226,   227,    -1,    -1,   230,    -1,   232,    -1,    -1,   235,
-     236,   237,    -1,    -1,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,    -1,
-     266,   267,   268,   269,   270,    -1,   272,   273,    -1,   275,
-      -1,   277,   278,   279,   280,   281,   282,    -1,   284,   285,
-      -1,    -1,   288,   289,   290,    -1,    -1,   293,   294,    -1,
-     296,    -1,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,    -1,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,    -1,   320,   321,   322,   323,   324,   325,
-      -1,   327,   328,   329,   330,   331,   332,   333,   334,    -1,
-     336,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,   347,   348,    -1,   350,   351,    -1,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
-     366,   367,    -1,   369,   370,   371,   372,   373,    -1,   375,
-     376,   377,   378,   379,    -1,   381,   382,   383,   384,    -1,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,    -1,   403,   404,    -1,
-     406,    -1,   408,   409,   410,   411,   412,    -1,   414,   415,
-      -1,    -1,   418,   419,   420,   421,   422,    -1,   424,   425,
-     426,   427,   428,   429,   430,   431,    -1,    -1,   434,   435,
-     436,   437,   438,    -1,    -1,   441,   442,   443,   444,   445,
-     446,   447,    -1,   449,    -1,   451,   452,   453,   454,   455,
-      -1,    -1,   458,    -1,    -1,   461,   462,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,     3,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    39,    40,    -1,    42,    43,    44,    45,    46,
-      47,    48,    -1,    50,    51,    52,    53,    -1,    55,    56,
-      57,    58,    59,    60,    -1,    -1,    63,    64,    65,    66,
-      67,    -1,    69,    70,    71,    72,    -1,    -1,    75,    -1,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      -1,    88,    89,    90,    91,    92,    93,    -1,    95,    96,
-      97,    98,    99,   100,   101,   102,    -1,    -1,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,    -1,
-     117,    -1,   119,   120,   121,   122,   123,   124,    -1,   126,
-     127,   128,   129,   130,    -1,    -1,   133,   134,   135,   136,
-     137,    -1,   139,   140,   141,    -1,   143,   144,   145,    -1,
-     147,   148,   149,   150,    -1,   152,   153,   154,   155,   156,
-      -1,    -1,   159,    -1,   161,   162,   163,   164,    -1,   166,
-      -1,   168,   169,    -1,   171,   172,   173,   174,   175,   176,
-      -1,   178,    -1,    -1,    -1,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,    -1,
-     197,   198,   199,   200,   201,   202,    -1,   204,   205,    -1,
-     207,   208,   209,   210,   211,   212,   213,    -1,   215,    -1,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,    -1,    -1,   230,   231,   232,   233,    -1,   235,   236,
-     237,    -1,    -1,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,    -1,    -1,   272,   273,   274,   275,    -1,
-      -1,   278,   279,   280,   281,   282,    -1,   284,   285,    -1,
-      -1,   288,   289,   290,    -1,    -1,   293,    -1,   295,   296,
-     297,    -1,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,    -1,   310,   311,    -1,   313,   314,    -1,   316,
-     317,   318,    -1,   320,   321,   322,   323,   324,   325,    -1,
-     327,   328,   329,   330,   331,   332,   333,   334,    -1,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,    -1,   350,   351,   352,   353,   354,   355,    -1,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,    -1,   369,   370,   371,   372,   373,   374,   375,    -1,
-     377,   378,   379,   380,   381,   382,   383,   384,    -1,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,    -1,   401,    -1,   403,   404,    -1,   406,
-     407,   408,   409,   410,   411,   412,    -1,   414,   415,    -1,
-      -1,   418,   419,    -1,   421,    -1,    -1,   424,   425,   426,
-     427,   428,   429,   430,   431,    -1,    -1,   434,   435,   436,
-     437,   438,   439,    -1,   441,   442,   443,   444,   445,    -1,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,    -1,
-      -1,   458,    -1,    -1,   461,   462,   463,   464,   465,   466,
-       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   478,   479,   480,   481,    -1,    -1,    20,    21,    22,
-      23,    24,    25,    26,    27,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    39,    40,    -1,    42,
-      43,    44,    45,    46,    47,    48,    -1,    50,    51,    52,
-      53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    -1,    69,    70,    71,    72,
-      -1,    -1,    75,    -1,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
-      -1,    -1,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,    -1,   117,    -1,   119,   120,   121,   122,
-     123,   124,    -1,   126,   127,   128,   129,   130,    -1,    -1,
-     133,   134,   135,   136,   137,    -1,   139,   140,   141,    -1,
-     143,   144,   145,    -1,   147,   148,   149,   150,    -1,   152,
-     153,   154,   155,   156,    -1,    -1,   159,    -1,   161,   162,
-     163,   164,    -1,   166,    -1,   168,   169,    -1,   171,   172,
-     173,    -1,   175,   176,    -1,   178,    -1,    -1,    -1,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,    -1,   197,   198,   199,   200,   201,   202,
-      -1,   204,   205,    -1,   207,   208,   209,   210,   211,   212,
-     213,    -1,   215,    -1,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,    -1,    -1,   230,   231,   232,
-     233,    -1,   235,   236,   237,    -1,    -1,   240,   241,   242,
-     243,   244,    -1,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,    -1,    -1,   272,
-     273,   274,   275,    -1,    -1,   278,   279,   280,   281,   282,
-      -1,   284,   285,    -1,    -1,   288,   289,   290,    -1,    -1,
-     293,    -1,   295,   296,   297,    -1,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,    -1,   310,   311,    -1,
-     313,   314,    -1,   316,   317,   318,    -1,   320,   321,   322,
-     323,   324,   325,    -1,   327,   328,   329,   330,   331,   332,
-     333,   334,    -1,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,    -1,   350,   351,   352,
-     353,   354,   355,    -1,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,   367,    -1,   369,   370,   371,   372,
-     373,   374,   375,    -1,   377,   378,   379,   380,   381,   382,
-     383,   384,    -1,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,    -1,   399,    -1,   401,    -1,
-     403,   404,    -1,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,    -1,    -1,   418,   419,    -1,   421,    -1,
-      -1,   424,   425,   426,   427,   428,   429,   430,   431,    -1,
-      -1,   434,   435,   436,   437,   438,   439,    -1,   441,   442,
-     443,   444,   445,    -1,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,    -1,    -1,   458,    -1,    -1,   461,   462,
-     463,   464,   465,   466,     3,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   478,   479,   480,   481,    -1,
-      -1,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      39,    40,    -1,    42,    43,    44,    -1,    46,    47,    48,
-      49,    50,    -1,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    -1,    -1,    63,    64,    65,    66,    67,    -1,
-      69,    70,    71,    72,    73,    -1,    -1,    -1,    77,    78,
-      79,    80,    81,    82,    -1,    84,    85,    86,    -1,    88,
-      89,    90,    91,    92,    93,    -1,    -1,    96,    97,    98,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,    -1,   117,    -1,
-     119,   120,   121,   122,   123,   124,    -1,   126,   127,   128,
-     129,   130,    -1,    -1,   133,   134,   135,   136,   137,    -1,
-     139,   140,   141,    -1,   143,   144,   145,    -1,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,    -1,
-     159,    -1,   161,   162,   163,   164,    -1,   166,    -1,   168,
-      -1,    -1,    -1,   172,   173,   174,    -1,   176,    -1,   178,
-      -1,   180,   181,   182,    -1,   184,   185,   186,   187,   188,
-     189,   190,    -1,   192,   193,   194,   195,    -1,   197,   198,
-     199,   200,   201,   202,    -1,   204,    -1,   206,   207,   208,
-     209,   210,   211,   212,   213,    -1,   215,    -1,   217,    -1,
-      -1,   220,    -1,   222,   223,   224,   225,   226,   227,    -1,
-      -1,   230,    -1,   232,    -1,    -1,   235,   236,   237,    -1,
-      -1,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,    -1,   266,   267,   268,
-     269,   270,    -1,   272,   273,    -1,   275,    -1,   277,   278,
-     279,   280,   281,   282,    -1,   284,   285,    -1,    -1,   288,
-     289,   290,    -1,    -1,   293,   294,    -1,   296,    -1,   298,
-     299,   300,   301,   302,   303,   304,    -1,   306,   307,   308,
-      -1,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-      -1,   320,   321,   322,   323,   324,   325,    -1,   327,    -1,
-     329,   330,   331,   332,   333,   334,    -1,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-      -1,   350,   351,    -1,   353,   354,   355,   356,    -1,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,   367,    -1,
-     369,   370,   371,   372,   373,    -1,   375,   376,   377,   378,
-     379,    -1,   381,   382,   383,   384,    -1,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,    -1,   403,   404,    -1,   406,    -1,   408,
-     409,   410,   411,   412,    -1,   414,   415,    -1,    -1,   418,
-     419,   420,   421,   422,    -1,   424,   425,   426,   427,   428,
-     429,   430,   431,    -1,    -1,   434,   435,   436,   437,   438,
-      -1,    -1,   441,   442,   443,   444,   445,   446,   447,    -1,
-     449,    -1,   451,   452,   453,   454,   455,    -1,    -1,   458,
-      -1,    -1,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481
-};
-
-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-   symbol of state STATE-NUM.  */
-static const yytype_uint16 yystos[] =
-{
-       0,    20,    30,    32,    33,    48,    57,    69,    80,    92,
-      94,   112,   126,   136,   142,   150,   152,   153,   166,   195,
-     210,   236,   313,   316,   345,   354,   368,   375,   379,   389,
-     401,   405,   441,   446,   460,   484,   498,   509,   510,   511,
-     512,   523,   524,   526,   530,   545,   546,   547,   549,   551,
-     558,   560,   608,   615,   618,   619,   636,   637,   638,   639,
-     640,   641,   692,   693,   838,   841,   844,   851,   852,   853,
-     854,   855,   862,   866,   872,   874,   879,   883,   884,   887,
-     888,   890,   891,   893,   418,   463,   559,   199,   361,   369,
-     405,   452,   559,     3,    20,    21,    22,    23,    24,    25,
-      26,    27,    29,    30,    31,    39,    40,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    55,
-      56,    57,    58,    59,    60,    63,    64,    65,    66,    67,
-      69,    70,    71,    72,    73,    75,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    88,    89,    90,    91,
-      92,    93,    95,    96,    97,    98,    99,   100,   101,   102,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   117,   119,   120,   121,   122,   123,   124,   126,   127,
-     128,   129,   130,   133,   134,   135,   136,   137,   139,   140,
-     141,   143,   144,   145,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   159,   161,   162,   163,   164,
-     166,   168,   169,   171,   172,   173,   174,   175,   176,   178,
-     180,   181,   182,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   197,   198,   199,   200,   201,
-     202,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   215,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   230,   231,   232,   233,   235,   236,   237,
-     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
-     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
-     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
-     270,   272,   273,   274,   275,   277,   278,   279,   280,   281,
-     282,   284,   285,   288,   289,   290,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   310,   311,   312,   313,   314,   315,   316,   317,
-     318,   320,   321,   322,   323,   324,   325,   327,   328,   329,
-     330,   331,   332,   333,   334,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,   366,   367,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,   403,   404,
-     406,   407,   408,   409,   410,   411,   412,   414,   415,   418,
-     419,   420,   421,   422,   424,   425,   426,   427,   428,   429,
-     430,   431,   434,   435,   436,   437,   438,   439,   441,   442,
-     443,   444,   445,   446,   447,   449,   450,   451,   452,   453,
-     454,   455,   458,   461,   462,   463,   464,   465,   466,   467,
-     468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,   751,   823,   827,   830,   896,   897,
-     898,   559,    51,   498,   631,   176,   237,   291,   361,   409,
-     411,   427,   433,   436,   606,   850,     3,    28,   174,   245,
-     316,   398,   821,   827,   896,    22,    75,    91,   145,   155,
-     167,   172,   199,   244,   248,   311,   325,   358,   361,   369,
-     372,   391,   405,   412,   421,   427,   452,   609,   610,   613,
-     559,   821,    94,   450,   498,   526,   618,   636,   858,   862,
-     879,   893,   109,    69,   210,   109,     5,   826,   827,   873,
-     873,   827,   821,    28,   414,   418,   827,   885,   886,   889,
-     559,    28,   131,   648,   649,   176,   237,   361,   373,   414,
-     867,   868,   889,   559,   446,   636,   641,   889,     5,   287,
-     705,   818,   827,   828,   171,   498,   876,   498,   333,   642,
-     643,   821,   642,   637,   638,     0,   501,   121,   209,   438,
-     146,   214,   292,   432,   651,   652,   637,   639,   640,   502,
-     450,   856,    28,   414,   418,   636,   889,   189,   818,   821,
-     189,   818,   189,   705,   189,   818,   498,   496,   500,   802,
-     804,   526,   618,   636,   840,   879,   818,   409,   411,   409,
-     411,   343,   189,   827,   827,   832,   172,   244,   333,   369,
-     405,   452,   616,   199,    28,   821,   250,   421,   108,   405,
-     405,   452,   364,     3,    45,    50,    51,    52,    53,    65,
-      66,    75,    83,    95,    99,   100,   101,   102,   105,   113,
-     114,   135,   163,   169,   171,   175,   189,   191,   205,   212,
-     213,   215,   218,   219,   221,   231,   233,   245,   264,   265,
-     266,   274,   279,   295,   297,   330,   352,   356,   374,   376,
-     380,   383,   398,   407,   414,   415,   426,   439,   447,   450,
-     614,   716,   718,   720,   722,   724,   726,   728,   729,   730,
-     732,   733,   734,   736,   737,   831,   896,   899,   189,   611,
-     832,   189,   819,   821,   189,   821,   498,   550,   291,   606,
-     858,     3,    45,    49,    50,    51,    52,    53,    65,    66,
-      73,    75,    83,    95,    99,   100,   101,   102,   105,   113,
-     114,   151,   157,   163,   169,   171,   174,   175,   180,   181,
-     191,   205,   206,   212,   213,   215,   218,   219,   221,   231,
-     233,   245,   264,   265,   266,   270,   274,   277,   279,   294,
-     295,   297,   298,   312,   315,   330,   352,   356,   374,   376,
-     380,   383,   398,   400,   407,   414,   415,   420,   422,   426,
-     439,   446,   447,   450,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   859,   861,   862,   864,   865,
-     896,   900,   856,   826,   873,   826,   487,   498,   498,   839,
-     481,   220,   500,   286,     4,     6,     7,     8,     9,    10,
-      36,    50,    52,    53,    61,    62,    65,    66,    73,    75,
-      99,   100,   101,   102,   103,   104,   105,   113,   114,   116,
-     151,   157,   158,   163,   180,   181,   212,   213,   215,   238,
-     239,   264,   266,   271,   276,   277,   279,   288,   298,   312,
-     330,   356,   374,   383,   400,   414,   415,   420,   422,   423,
-     426,   439,   447,   482,   489,   490,   491,   496,   498,   503,
-     505,   506,   637,   682,   721,   724,   727,   728,   729,   731,
-     732,   733,   736,   737,   748,   750,   751,   752,   754,   768,
-     769,   776,   796,   801,   808,   809,   810,   823,   824,   825,
-     826,   827,   807,   809,   867,   867,   826,   867,   481,   170,
-     416,   487,   498,   818,   491,   804,     3,   169,   171,   450,
-     862,   875,   877,   169,   878,   748,   780,   781,   827,   642,
-     502,   498,   834,   499,   499,   511,   170,   216,   705,   880,
-      28,   131,   647,   647,    55,   647,   160,   165,   234,   283,
-     657,   659,   660,   685,   687,   688,   689,   651,   652,   498,
-     818,   481,   220,   151,    24,    30,   136,   290,   341,   345,
-     375,   443,   517,   520,   521,   341,   151,    37,    56,   107,
-     198,   249,   257,   269,   300,   341,   347,   369,   375,   389,
-     520,   552,   555,   151,   341,   375,   520,   151,   341,   375,
-     520,     3,    28,    45,    51,    75,    83,    95,    99,   100,
-     101,   102,   105,   131,   169,   171,   174,   175,   191,   205,
-     218,   219,   221,   231,   233,   245,   265,   274,   295,   297,
-     352,   374,   380,   398,   407,   426,   439,   448,   450,   491,
-     499,   748,   783,   784,   829,   835,   896,   901,   748,   803,
-       3,    28,    32,    33,    34,    35,    36,    37,    38,    41,
-      54,    61,    62,    68,    74,    76,    87,    94,   103,   104,
-     116,   118,   125,   131,   132,   138,   142,   146,   158,   160,
-     165,   167,   170,   177,   179,   183,   196,   203,   214,   216,
-     228,   229,   234,   238,   239,   271,   276,   283,   286,   287,
-     291,   292,   309,   319,   326,   335,   349,   368,   385,   402,
-     405,   413,   416,   417,   423,   432,   433,   440,   446,   448,
-     456,   457,   459,   460,   822,   836,   896,   900,   902,   802,
-     499,   498,   595,   606,   271,   842,   500,   833,    37,   452,
-     189,   818,   189,   818,   895,   818,   818,    83,   847,   464,
-      84,   128,   303,   410,   449,   735,   735,   735,   498,   723,
-     723,   315,   498,   725,   151,   498,    65,    66,   735,   723,
-     720,   462,   484,   498,   738,   498,   738,    59,   348,   502,
-     612,   498,    36,   719,   498,   110,   111,   186,   187,   251,
-     252,   253,   254,   255,   256,   259,   260,   365,   366,   478,
-     479,   498,   739,   740,   741,   742,   743,   744,   745,   746,
-     747,   723,   151,   502,   612,   151,   502,   612,   151,   286,
-     781,   343,   405,   499,   502,     4,   158,   286,   423,   489,
-     490,   554,   557,   825,   826,   857,   859,   860,   863,   858,
-     498,   626,   630,   554,   863,   869,   871,   783,   718,   785,
-      37,   232,   827,   498,   805,   496,   748,   800,   498,   498,
-     165,   498,   498,   637,   498,   498,   498,   748,   498,   498,
-     498,   498,   498,   498,   498,   498,   498,   748,   748,   748,
-     147,   811,   812,   781,   782,   637,   748,   780,   770,   771,
-     772,   827,   828,     9,   805,   804,   498,   826,   498,   825,
-     826,     3,     8,    11,    15,    16,    17,    18,    19,    34,
-      37,    42,    49,    74,   175,   191,   196,   218,   219,   233,
-     271,   274,   288,   291,   380,   482,   485,   486,   487,   489,
-     490,   491,   492,   493,   494,   774,   775,   776,   778,   461,
-     755,   805,   297,   748,   502,   216,   644,   498,   826,   805,
-     500,   804,   644,     3,   116,   237,   554,   737,   826,   870,
-      98,   116,   871,   116,   871,   818,   499,   502,   856,   502,
-     499,   643,   819,    37,   880,   528,   818,    37,   827,   375,
-     639,   639,    28,   491,   653,   654,   748,   639,   162,   268,
-     673,   223,   269,   329,   378,   438,     4,     9,    28,   668,
-     748,   489,   490,   669,   670,   748,   750,   685,   686,   660,
-     659,   657,   658,   165,   688,   281,   690,   657,   685,   781,
-     834,   232,   818,    68,    76,    87,   167,   189,   319,   433,
-     577,   587,   602,   827,    76,    87,   525,    87,   525,   498,
-     416,   498,   575,   243,   436,   575,    87,   502,   416,   818,
-     720,   554,    55,   556,   554,   554,   107,   249,   257,    55,
-     416,   460,   484,   553,   262,   361,   553,   555,   705,    87,
-     416,   525,   361,   818,   416,   361,   783,   783,   784,   499,
-     502,   651,   652,    13,    14,   497,   507,   416,   594,   599,
-     827,   460,   629,   333,   405,   452,   151,    94,   547,   560,
-     843,   844,   891,   822,   500,   718,   818,   271,   548,   552,
-     271,   498,   595,    37,   595,   498,   617,   189,   589,   827,
-     848,   498,   782,   825,   614,   785,   735,   735,    36,   719,
-     414,   414,   825,   825,   718,   715,   827,   496,   496,   825,
-     825,   416,   416,   416,   416,   611,   832,   819,   821,   821,
-     832,   499,   606,   189,   818,   895,   858,   864,     4,   825,
-       4,   825,   628,   635,   836,    51,    96,   122,   140,   144,
-     166,   169,   184,   276,   284,   327,   632,   502,   499,   502,
-     499,   502,   840,   781,   802,   782,   456,   797,   798,   748,
-     781,   498,   825,   825,     3,   739,   740,   741,   742,   743,
-     744,   745,   746,   786,   787,   826,   825,   825,   748,     8,
-      16,    17,    18,    19,   485,   486,   487,   489,   490,   491,
-     492,   493,   494,   774,   779,   827,   748,   788,   489,   490,
-     498,   749,   750,   776,   790,   499,   781,   748,   780,   791,
-     748,    54,   170,   229,   417,   748,   781,   794,   748,   498,
-     827,   343,   816,   497,   499,   502,   502,   504,   507,   781,
-     748,   747,   747,   718,   748,   748,   748,   748,   748,   748,
-       5,   836,   837,   414,    41,   402,   806,   832,   748,   748,
-     498,   637,   795,   131,   158,   271,   276,   281,   423,   434,
-     748,   276,   498,   748,   416,    49,   175,   191,   196,   233,
-     380,   748,   748,   748,   748,   748,   748,   748,   748,   748,
-     748,    28,    35,   385,   773,   179,   161,   756,   356,   498,
-     769,   810,   176,   237,   405,   409,   411,   436,   645,   818,
-     170,   694,   783,   491,   694,   498,   826,   499,   818,   875,
-     818,   883,   748,   499,   498,   440,   882,   116,   299,   498,
-     527,   636,    37,   827,   498,   532,   541,   542,   544,   827,
-      38,   125,   655,   655,   502,   440,   655,   356,   357,   489,
-     490,   670,   672,   750,   378,   223,   287,   308,   308,   502,
-     493,     4,   671,   825,   671,   356,   357,   672,   817,   818,
-     275,   382,   691,   686,   658,   499,   341,   520,   498,   189,
-     587,   821,   223,   271,   223,   440,   498,   580,   717,   718,
-     821,   827,   189,   821,   189,   827,    24,   136,   375,   516,
-     519,   571,   585,   836,   821,   579,   598,   836,   821,   517,
-     821,   341,   375,   520,   552,   554,   832,   821,   554,   832,
-     821,   554,   341,   375,   520,   821,   821,   821,   821,   341,
-     375,   520,   821,   821,   651,   651,   651,   448,   784,   190,
-     346,   650,   748,   748,   748,   803,   324,   625,   499,   502,
-     284,   170,   416,   620,   452,   818,   895,   818,   827,   291,
-     606,   822,   498,   151,   151,   233,   577,   587,   590,   593,
-     603,   605,   827,   460,   462,   582,   150,   636,   460,   849,
-     499,   783,    37,   271,   286,   781,   499,   499,   612,   499,
-     496,   481,   481,   499,   499,   499,   502,   718,   825,   497,
-     825,   499,   499,   740,   742,   743,   744,   743,   744,   744,
-     612,   612,   286,   612,   405,   271,    37,   499,   502,   491,
-     498,   554,   627,   863,    37,   624,   826,   624,   271,   276,
-     327,   624,   624,   869,   718,   499,   497,   748,   138,   798,
-     799,    37,   499,   748,   499,   499,   499,   170,   499,   499,
-     502,   499,   500,   309,   789,   499,   749,   749,   748,    11,
-      16,    17,    18,    19,   196,   218,   288,   485,   486,   487,
-     489,   490,   491,   492,   493,   494,   776,   749,   499,   499,
-     165,   170,   792,   793,   502,   499,    37,   794,   781,   794,
-     794,   170,   499,    37,   819,   820,   498,   748,   813,   805,
-     748,   770,   748,   499,   499,   481,   749,   749,   144,   781,
-     170,   131,   158,   276,   281,   423,   434,   498,   144,   779,
-     748,   402,   806,   748,   795,   748,   416,   498,   637,   498,
-     498,   154,   757,   409,   411,   409,   411,   818,   405,   646,
-     646,   646,   228,   357,   498,   637,   695,   696,   697,   698,
-     705,   706,   751,   753,   754,   827,   457,   711,   651,   812,
-     711,   825,   747,   834,   840,   696,   457,   881,   446,   404,
-     439,   536,   531,   540,   827,   286,   533,   827,   537,   544,
-     502,   694,   487,   805,   483,   656,   656,   654,   288,   774,
-     777,   656,     4,   825,   672,   287,   438,   669,   502,   242,
-     416,   748,   271,   602,   498,   151,   498,   580,   199,   599,
-     600,   561,    37,   174,   570,   596,   561,    24,   136,   345,
-     347,   375,   513,   514,   515,   521,   522,   151,   612,   151,
-     612,   571,   585,   571,   499,   502,   564,   826,   499,   502,
-     487,   500,   416,   361,    87,   416,   525,   361,   416,   416,
-     416,   361,   650,   650,   650,   784,   278,   278,   499,   497,
-     392,   393,   634,   826,   594,   625,   818,   498,    37,   595,
-     842,   343,   405,   599,   818,   818,   895,   818,   499,   502,
-     284,   575,   284,   286,   574,   821,   460,   894,   575,    37,
-     499,   405,   748,   151,   818,   499,   719,   825,   738,   738,
-     719,   827,   497,   497,   832,   151,   628,   622,   633,   863,
-     826,   826,   276,   599,   491,   599,   826,   826,   413,   748,
-     142,   718,   499,   748,   748,   779,   748,   792,   718,   749,
-     749,   749,   749,   749,   131,   271,   281,   749,   749,   749,
-     749,   749,   749,   749,   749,   749,   749,   748,   748,   793,
-     792,   718,   499,   499,   499,   781,   718,   502,   499,   748,
-     813,   814,   815,    37,   499,   747,   748,    34,    34,   748,
-     499,   748,   170,   498,   785,   748,   499,   144,   749,   749,
-     144,   144,   748,   748,   652,   457,   296,   761,   646,   646,
-     646,   646,   818,   818,   818,   637,   706,   170,   637,   697,
-     698,    37,   699,   700,   827,   502,    95,   171,   205,   221,
-     231,   265,   352,   702,   700,    37,   699,   701,   827,   484,
-     710,   804,   748,   179,   674,   650,   816,   674,   499,   499,
-     748,   349,   535,   445,   499,   502,   805,    85,   535,   499,
-     502,   532,   881,   748,   162,   227,   498,   656,   287,   818,
-     821,   499,   151,   600,   587,   600,   561,   589,   502,   499,
-     118,   203,   269,   271,   586,   498,    31,    55,   607,   596,
-      68,    74,    87,   116,   118,   203,   271,   276,   319,   335,
-     433,   440,   566,   567,   581,   174,   116,   188,   271,   575,
-     553,   108,   116,   174,   271,   391,   394,   555,   575,   375,
-     515,   427,   821,   827,   519,   598,     3,    45,    51,    75,
-      83,    95,    99,   100,   101,   102,   105,   169,   171,   174,
-     175,   191,   205,   218,   219,   221,   231,   233,   245,   265,
-     270,   274,   288,   295,   297,   352,   374,   376,   380,   398,
-     407,   426,   439,   450,   489,   490,   554,   562,   601,   718,
-     777,   826,   829,   896,   902,   836,   821,   821,   821,   821,
-     821,   821,   821,   821,   821,   821,   499,   499,   499,   651,
-     553,   634,   498,   593,   636,   849,   606,   189,   818,   499,
-     548,   498,    37,   584,   582,   590,    80,   550,   108,   269,
-     636,   636,   589,   440,   846,   497,   718,   612,   895,   499,
-     502,   599,   748,   499,   499,   793,   170,   131,   281,   498,
-     499,   499,   502,   499,   827,   748,   748,   748,   785,   499,
-     748,    34,    34,   748,   748,   144,   499,   499,   748,   498,
-     762,   827,   818,   818,   818,   818,   700,   701,   498,   499,
-     827,   828,   407,   665,   666,   498,   697,   221,   295,   703,
-     697,   703,   221,   702,   703,   221,   666,   498,   827,   666,
-     498,   293,    55,   183,   683,   499,   683,   826,   808,   636,
-     299,   636,   531,   286,   498,   529,   487,   544,   535,   779,
-     561,   587,   499,   499,   460,   592,   119,   192,   201,   118,
-     442,   748,   116,    37,   498,   832,   821,   749,   119,   192,
-     118,   276,   223,   818,   592,    82,   607,   189,   276,   554,
-     748,   607,   276,   489,   490,   557,   827,   718,   612,   612,
-     245,   398,   829,   833,   487,   416,   416,   650,   626,   440,
-     621,   623,   599,   499,   894,    37,   405,   271,   498,   849,
-     593,   150,   636,   148,   197,   574,   121,   136,   318,   894,
-     108,   460,   892,   286,   827,   845,   498,    37,   633,   749,
-     170,   498,   785,   813,   499,   748,   748,   748,   499,   763,
-     827,   707,   708,   753,   699,   498,     4,     9,   661,   663,
-     664,   827,   820,   697,   286,   440,   704,   697,   221,   697,
-     712,   713,   827,   498,   712,   827,    28,    97,   180,   355,
-     491,   498,   675,   676,   677,   678,   679,   680,   681,   748,
-     748,   459,   758,   826,   758,   502,   536,    87,   498,   534,
-     543,   753,   827,   132,   748,   499,   335,   592,   498,   583,
-     561,   499,   188,   498,   748,   271,   567,   592,   595,   821,
-      37,   151,    74,   714,   833,   493,   562,   821,   821,   499,
-     553,   123,   499,   582,   636,   818,   151,    37,   499,   821,
-     894,    28,    79,    88,   117,   188,   200,   391,   394,   578,
-     578,   357,   357,    60,    68,   237,   818,   543,   749,   785,
-     499,   305,   764,   499,   502,    37,   709,   820,   308,   493,
-     308,   357,   493,   498,   498,   499,   748,   498,   697,   704,
-     499,   502,   718,   712,   499,   498,   377,   498,   499,   502,
-     759,   760,   827,   326,   684,   684,   445,   821,   748,   499,
-     502,    74,   538,   538,   272,   438,   818,   561,   588,   591,
-     836,   395,   454,   568,   569,   498,   563,   748,   499,   247,
-     604,   188,   832,   440,   518,   493,   427,   626,   826,   849,
-     574,   892,   498,   818,   636,   582,   550,    68,   289,    68,
-     846,   499,   499,    55,   651,   710,   707,   498,   499,   827,
-     661,   820,   713,   714,   499,   781,   498,   781,   677,   502,
-      37,   748,   440,   662,   662,   636,   499,   711,   534,   832,
-     539,   832,   539,   375,   595,   499,   502,   487,   552,   499,
-     269,   576,   171,   304,   381,   286,   572,   573,   597,   563,
-     748,   427,    37,   498,   892,   574,   894,   289,   289,   498,
-     849,   780,   328,   357,   765,   712,   499,   502,   499,   499,
-     499,   676,   499,   760,   762,   359,   538,   655,   655,   542,
-     604,   591,   562,   499,   569,   201,   121,   438,   286,   597,
-     286,   572,   636,   543,   711,    49,    98,   429,   748,   766,
-     767,   766,   499,   499,     9,   342,   667,   499,   664,   539,
-     656,   656,   711,   573,    59,   269,   348,   375,   565,   565,
-     892,   499,   767,   356,   164,   314,   164,   314,   499,   498,
-     655,   561,    23,   116,   276,   849,    34,     9,   656,   711,
-     767,   499
-};
-
-#define yyerrok		(yyerrstatus = 0)
-#define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		(-2)
-#define YYEOF		0
-
-#define YYACCEPT	goto yyacceptlab
-#define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrorlab
-
-
-/* Like YYERROR except do call yyerror.  This remains here temporarily
-   to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  */
-
-#define YYFAIL		goto yyerrlab
-
-#define YYRECOVERING()  (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value)					\
-do								\
-  if (yychar == YYEMPTY && yylen == 1)				\
-    {								\
-      yychar = (Token);						\
-      yylval = (Value);						\
-      yytoken = YYTRANSLATE (yychar);				\
-      YYPOPSTACK (1);						\
-      goto yybackup;						\
-    }								\
-  else								\
-    {								\
-      yyerror (&yylloc, yyscanner, YY_("syntax error: cannot back up")); \
-      YYERROR;							\
-    }								\
-while (YYID (0))
-
-
-#define YYTERROR	1
-#define YYERRCODE	256
-
-
-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
-   If N is 0, then set CURRENT to the empty location which ends
-   the previous symbol: RHS[0] (always defined).  */
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)				\
-    do									\
-      if (YYID (N))                                                    \
-	{								\
-	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
-	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
-	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
-	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
-	}								\
-      else								\
-	{								\
-	  (Current).first_line   = (Current).last_line   =		\
-	    YYRHSLOC (Rhs, 0).last_line;				\
-	  (Current).first_column = (Current).last_column =		\
-	    YYRHSLOC (Rhs, 0).last_column;				\
-	}								\
-    while (YYID (0))
-#endif
-
-
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
-
-#ifndef YY_LOCATION_PRINT
-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-#  define YY_LOCATION_PRINT(File, Loc)			\
-     fprintf (File, "%d.%d-%d.%d",			\
-	      (Loc).first_line, (Loc).first_column,	\
-	      (Loc).last_line,  (Loc).last_column)
-# else
-#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-# endif
-#endif
-
-
-/* YYLEX -- calling `yylex' with the right arguments.  */
-
-#ifdef YYLEX_PARAM
-# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
-#else
-# define YYLEX yylex (&yylval, &yylloc, yyscanner)
-#endif
-
-/* Enable debugging if requested.  */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args)			\
-do {						\
-  if (yydebug)					\
-    YYFPRINTF Args;				\
-} while (YYID (0))
-
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
-do {									  \
-  if (yydebug)								  \
-    {									  \
-      YYFPRINTF (stderr, "%s ", Title);					  \
-      yy_symbol_print (stderr,						  \
-		  Type, Value, Location, yyscanner); \
-      YYFPRINTF (stderr, "\n");						  \
-    }									  \
-} while (YYID (0))
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner)
-#else
-static void
-yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
-    core_yyscan_t yyscanner;
-#endif
-{
-  if (!yyvaluep)
-    return;
-  YYUSE (yylocationp);
-  YYUSE (yyscanner);
-# ifdef YYPRINT
-  if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# else
-  YYUSE (yyoutput);
-# endif
-  switch (yytype)
-    {
-      default:
-	break;
-    }
-}
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, core_yyscan_t yyscanner)
-#else
-static void
-yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
-    core_yyscan_t yyscanner;
-#endif
-{
-  if (yytype < YYNTOKENS)
-    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-  else
-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
-
-  YY_LOCATION_PRINT (yyoutput, *yylocationp);
-  YYFPRINTF (yyoutput, ": ");
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, yyscanner);
-  YYFPRINTF (yyoutput, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included).                                                   |
-`------------------------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
-#else
-static void
-yy_stack_print (bottom, top)
-    yytype_int16 *bottom;
-    yytype_int16 *top;
-#endif
-{
-  YYFPRINTF (stderr, "Stack now");
-  for (; bottom <= top; ++bottom)
-    YYFPRINTF (stderr, " %d", *bottom);
-  YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top)				\
-do {								\
-  if (yydebug)							\
-    yy_stack_print ((Bottom), (Top));				\
-} while (YYID (0))
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced.  |
-`------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, core_yyscan_t yyscanner)
-#else
-static void
-yy_reduce_print (yyvsp, yylsp, yyrule, yyscanner)
-    YYSTYPE *yyvsp;
-    YYLTYPE *yylsp;
-    int yyrule;
-    core_yyscan_t yyscanner;
-#endif
-{
-  int yynrhs = yyr2[yyrule];
-  int yyi;
-  unsigned long int yylno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
-	     yyrule - 1, yylno);
-  /* The symbols being reduced.  */
-  for (yyi = 0; yyi < yynrhs; yyi++)
-    {
-      fprintf (stderr, "   $%d = ", yyi + 1);
-      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
-		       &(yyvsp[(yyi + 1) - (yynrhs)])
-		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , yyscanner);
-      fprintf (stderr, "\n");
-    }
-}
-
-# define YY_REDUCE_PRINT(Rule)		\
-do {					\
-  if (yydebug)				\
-    yy_reduce_print (yyvsp, yylsp, Rule, yyscanner); \
-} while (YYID (0))
-
-/* Nonzero means print parse trace.  It is left uninitialized so that
-   multiple parsers can coexist.  */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks.  */
-#ifndef	YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
-   if the built-in stack extension method is used).
-
-   Do not make this value too large; the results are undefined if
-   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
-   evaluated with infinite-precision integer arithmetic.  */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-
-#if YYERROR_VERBOSE
-
-# ifndef yystrlen
-#  if defined __GLIBC__ && defined _STRING_H
-#   define yystrlen strlen
-#  else
-/* Return the length of YYSTR.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static YYSIZE_T
-yystrlen (const char *yystr)
-#else
-static YYSIZE_T
-yystrlen (yystr)
-    const char *yystr;
-#endif
-{
-  YYSIZE_T yylen;
-  for (yylen = 0; yystr[yylen]; yylen++)
-    continue;
-  return yylen;
-}
-#  endif
-# endif
-
-# ifndef yystpcpy
-#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
-#   define yystpcpy stpcpy
-#  else
-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
-   YYDEST.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static char *
-yystpcpy (char *yydest, const char *yysrc)
-#else
-static char *
-yystpcpy (yydest, yysrc)
-    char *yydest;
-    const char *yysrc;
-#endif
-{
-  char *yyd = yydest;
-  const char *yys = yysrc;
-
-  while ((*yyd++ = *yys++) != '\0')
-    continue;
-
-  return yyd - 1;
-}
-#  endif
-# endif
-
-# ifndef yytnamerr
-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
-   quotes and backslashes, so that it's suitable for yyerror.  The
-   heuristic is that double-quoting is unnecessary unless the string
-   contains an apostrophe, a comma, or backslash (other than
-   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
-   null, do not copy; instead, return the length of what the result
-   would have been.  */
-static YYSIZE_T
-yytnamerr (char *yyres, const char *yystr)
-{
-  if (*yystr == '"')
-    {
-      YYSIZE_T yyn = 0;
-      char const *yyp = yystr;
-
-      for (;;)
-	switch (*++yyp)
-	  {
-	  case '\'':
-	  case ',':
-	    goto do_not_strip_quotes;
-
-	  case '\\':
-	    if (*++yyp != '\\')
-	      goto do_not_strip_quotes;
-	    /* Fall through.  */
-	  default:
-	    if (yyres)
-	      yyres[yyn] = *yyp;
-	    yyn++;
-	    break;
-
-	  case '"':
-	    if (yyres)
-	      yyres[yyn] = '\0';
-	    return yyn;
-	  }
-    do_not_strip_quotes: ;
-    }
-
-  if (! yyres)
-    return yystrlen (yystr);
-
-  return yystpcpy (yyres, yystr) - yyres;
-}
-# endif
-
-/* Copy into YYRESULT an error message about the unexpected token
-   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
-   including the terminating null byte.  If YYRESULT is null, do not
-   copy anything; just return the number of bytes that would be
-   copied.  As a special case, return 0 if an ordinary "syntax error"
-   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
-   size calculation.  */
-static YYSIZE_T
-yysyntax_error (char *yyresult, int yystate, int yychar)
-{
-  int yyn = yypact[yystate];
-
-  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
-    return 0;
-  else
-    {
-      int yytype = YYTRANSLATE (yychar);
-      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
-      YYSIZE_T yysize = yysize0;
-      YYSIZE_T yysize1;
-      int yysize_overflow = 0;
-      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
-      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-      int yyx;
-
-# if 0
-      /* This is so xgettext sees the translatable formats that are
-	 constructed on the fly.  */
-      YY_("syntax error, unexpected %s");
-      YY_("syntax error, unexpected %s, expecting %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
-# endif
-      char *yyfmt;
-      char const *yyf;
-      static char const yyunexpected[] = "syntax error, unexpected %s";
-      static char const yyexpecting[] = ", expecting %s";
-      static char const yyor[] = " or %s";
-      char yyformat[sizeof yyunexpected
-		    + sizeof yyexpecting - 1
-		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
-		       * (sizeof yyor - 1))];
-      char const *yyprefix = yyexpecting;
-
-      /* Start YYX at -YYN if negative to avoid negative indexes in
-	 YYCHECK.  */
-      int yyxbegin = yyn < 0 ? -yyn : 0;
-
-      /* Stay within bounds of both yycheck and yytname.  */
-      int yychecklim = YYLAST - yyn + 1;
-      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-      int yycount = 1;
-
-      yyarg[0] = yytname[yytype];
-      yyfmt = yystpcpy (yyformat, yyunexpected);
-
-      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-	  {
-	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
-	      {
-		yycount = 1;
-		yysize = yysize0;
-		yyformat[sizeof yyunexpected - 1] = '\0';
-		break;
-	      }
-	    yyarg[yycount++] = yytname[yyx];
-	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
-	    yysize_overflow |= (yysize1 < yysize);
-	    yysize = yysize1;
-	    yyfmt = yystpcpy (yyfmt, yyprefix);
-	    yyprefix = yyor;
-	  }
-
-      yyf = YY_(yyformat);
-      yysize1 = yysize + yystrlen (yyf);
-      yysize_overflow |= (yysize1 < yysize);
-      yysize = yysize1;
-
-      if (yysize_overflow)
-	return YYSIZE_MAXIMUM;
-
-      if (yyresult)
-	{
-	  /* Avoid sprintf, as that infringes on the user's name space.
-	     Don't have undefined behavior even if the translation
-	     produced a string with the wrong number of "%s"s.  */
-	  char *yyp = yyresult;
-	  int yyi = 0;
-	  while ((*yyp = *yyf) != '\0')
-	    {
-	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
-		{
-		  yyp += yytnamerr (yyp, yyarg[yyi++]);
-		  yyf += 2;
-		}
-	      else
-		{
-		  yyp++;
-		  yyf++;
-		}
-	    }
-	}
-      return yysize;
-    }
-}
-#endif /* YYERROR_VERBOSE */
-
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, core_yyscan_t yyscanner)
-#else
-static void
-yydestruct (yymsg, yytype, yyvaluep, yylocationp, yyscanner)
-    const char *yymsg;
-    int yytype;
-    YYSTYPE *yyvaluep;
-    YYLTYPE *yylocationp;
-    core_yyscan_t yyscanner;
-#endif
-{
-  YYUSE (yyvaluep);
-  YYUSE (yylocationp);
-  YYUSE (yyscanner);
-
-  if (!yymsg)
-    yymsg = "Deleting";
-  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-
-  switch (yytype)
-    {
-
-      default:
-	break;
-    }
-}
-
-
-/* Prevent warnings from -Wmissing-prototypes.  */
-
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (core_yyscan_t yyscanner);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-
-
-
-
-
-/*----------.
-| yyparse.  |
-`----------*/
-
-#ifdef YYPARSE_PARAM
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (void *YYPARSE_PARAM)
-#else
-int
-yyparse (YYPARSE_PARAM)
-    void *YYPARSE_PARAM;
-#endif
-#else /* ! YYPARSE_PARAM */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (core_yyscan_t yyscanner)
-#else
-int
-yyparse (yyscanner)
-    core_yyscan_t yyscanner;
-#endif
-#endif
-{
-  /* The look-ahead symbol.  */
-int yychar;
-
-/* The semantic value of the look-ahead symbol.  */
-YYSTYPE yylval;
-
-/* Number of syntax errors so far.  */
-int yynerrs;
-/* Location data for the look-ahead symbol.  */
-YYLTYPE yylloc;
-
-  int yystate;
-  int yyn;
-  int yyresult;
-  /* Number of tokens to shift before error messages enabled.  */
-  int yyerrstatus;
-  /* Look-ahead token as an internal (translated) token number.  */
-  int yytoken = 0;
-#if YYERROR_VERBOSE
-  /* Buffer for error messages, and its allocated size.  */
-  char yymsgbuf[128];
-  char *yymsg = yymsgbuf;
-  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
-#endif
-
-  /* Three stacks and their tools:
-     `yyss': related to states,
-     `yyvs': related to semantic values,
-     `yyls': related to locations.
-
-     Refer to the stacks thru separate pointers, to allow yyoverflow
-     to reallocate them elsewhere.  */
-
-  /* The state stack.  */
-  yytype_int16 yyssa[YYINITDEPTH];
-  yytype_int16 *yyss = yyssa;
-  yytype_int16 *yyssp;
-
-  /* The semantic value stack.  */
-  YYSTYPE yyvsa[YYINITDEPTH];
-  YYSTYPE *yyvs = yyvsa;
-  YYSTYPE *yyvsp;
-
-  /* The location stack.  */
-  YYLTYPE yylsa[YYINITDEPTH];
-  YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;
-  /* The locations where the error started and ended.  */
-  YYLTYPE yyerror_range[2];
-
-#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
-
-  YYSIZE_T yystacksize = YYINITDEPTH;
-
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-  YYLTYPE yyloc;
-
-  /* The number of symbols on the RHS of the reduced rule.
-     Keep to zero when no symbol should be popped.  */
-  int yylen = 0;
-
-  YYDPRINTF ((stderr, "Starting parse\n"));
-
-  yystate = 0;
-  yyerrstatus = 0;
-  yynerrs = 0;
-  yychar = YYEMPTY;		/* Cause a token to be read.  */
-
-  /* Initialize stack pointers.
-     Waste one element of value and location stack
-     so that they stay on the same level as the state stack.
-     The wasted elements are never initialized.  */
-
-  yyssp = yyss;
-  yyvsp = yyvs;
-  yylsp = yyls;
-#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-  /* Initialize the default location before parsing starts.  */
-  yylloc.first_line   = yylloc.last_line   = 1;
-  yylloc.first_column = yylloc.last_column = 0;
-#endif
-
-  goto yysetstate;
-
-/*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
-`------------------------------------------------------------*/
- yynewstate:
-  /* In all cases, when you get here, the value and location stacks
-     have just been pushed.  So pushing a state here evens the stacks.  */
-  yyssp++;
-
- yysetstate:
-  *yyssp = yystate;
-
-  if (yyss + yystacksize - 1 <= yyssp)
-    {
-      /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
-
-#ifdef yyoverflow
-      {
-	/* Give user a chance to reallocate the stack.  Use copies of
-	   these so that the &'s don't force the real ones into
-	   memory.  */
-	YYSTYPE *yyvs1 = yyvs;
-	yytype_int16 *yyss1 = yyss;
-	YYLTYPE *yyls1 = yyls;
-
-	/* Each stack pointer address is followed by the size of the
-	   data in use in that stack, in bytes.  This used to be a
-	   conditional around just the two extra args, but that might
-	   be undefined if yyoverflow is a macro.  */
-	yyoverflow (YY_("memory exhausted"),
-		    &yyss1, yysize * sizeof (*yyssp),
-		    &yyvs1, yysize * sizeof (*yyvsp),
-		    &yyls1, yysize * sizeof (*yylsp),
-		    &yystacksize);
-	yyls = yyls1;
-	yyss = yyss1;
-	yyvs = yyvs1;
-      }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
-      /* Extend the stack our own way.  */
-      if (YYMAXDEPTH <= yystacksize)
-	goto yyexhaustedlab;
-      yystacksize *= 2;
-      if (YYMAXDEPTH < yystacksize)
-	yystacksize = YYMAXDEPTH;
-
-      {
-	yytype_int16 *yyss1 = yyss;
-	union yyalloc *yyptr =
-	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-	if (! yyptr)
-	  goto yyexhaustedlab;
-	YYSTACK_RELOCATE (yyss);
-	YYSTACK_RELOCATE (yyvs);
-	YYSTACK_RELOCATE (yyls);
-#  undef YYSTACK_RELOCATE
-	if (yyss1 != yyssa)
-	  YYSTACK_FREE (yyss1);
-      }
-# endif
-#endif /* no yyoverflow */
-
-      yyssp = yyss + yysize - 1;
-      yyvsp = yyvs + yysize - 1;
-      yylsp = yyls + yysize - 1;
-
-      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-		  (unsigned long int) yystacksize));
-
-      if (yyss + yystacksize - 1 <= yyssp)
-	YYABORT;
-    }
-
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
-
-  goto yybackup;
-
-/*-----------.
-| yybackup.  |
-`-----------*/
-yybackup:
-
-  /* Do appropriate processing given the current state.  Read a
-     look-ahead token if we need one and don't already have one.  */
-
-  /* First try to decide what to do without reference to look-ahead token.  */
-  yyn = yypact[yystate];
-  if (yyn == YYPACT_NINF)
-    goto yydefault;
-
-  /* Not known => get a look-ahead token if don't already have one.  */
-
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
-  if (yychar == YYEMPTY)
-    {
-      YYDPRINTF ((stderr, "Reading a token: "));
-      yychar = YYLEX;
-    }
-
-  if (yychar <= YYEOF)
-    {
-      yychar = yytoken = YYEOF;
-      YYDPRINTF ((stderr, "Now at end of input.\n"));
-    }
-  else
-    {
-      yytoken = YYTRANSLATE (yychar);
-      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
-    }
-
-  /* If the proper action on seeing token YYTOKEN is to reduce or to
-     detect an error, take that action.  */
-  yyn += yytoken;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
-    goto yydefault;
-  yyn = yytable[yyn];
-  if (yyn <= 0)
-    {
-      if (yyn == 0 || yyn == YYTABLE_NINF)
-	goto yyerrlab;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-  /* Count tokens shifted since error; after three, turn off error
-     status.  */
-  if (yyerrstatus)
-    yyerrstatus--;
-
-  /* Shift the look-ahead token.  */
-  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-
-  /* Discard the shifted token unless it is eof.  */
-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
-
-  yystate = yyn;
-  *++yyvsp = yylval;
-  *++yylsp = yylloc;
-  goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state.  |
-`-----------------------------------------------------------*/
-yydefault:
-  yyn = yydefact[yystate];
-  if (yyn == 0)
-    goto yyerrlab;
-  goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- Do a reduction.  |
-`-----------------------------*/
-yyreduce:
-  /* yyn is the number of a rule to reduce with.  */
-  yylen = yyr2[yyn];
-
-  /* If YYLEN is nonzero, implement the default value of the action:
-     `$$ = $1'.
-
-     Otherwise, the following line sets YYVAL to garbage.
-     This behavior is undocumented and Bison
-     users should not rely upon it.  Assigning to YYVAL
-     unconditionally makes the parser a bit smaller, and it avoids a
-     GCC warning that YYVAL may be used uninitialized.  */
-  yyval = yyvsp[1-yylen];
-
-  /* Default location.  */
-  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
-  YY_REDUCE_PRINT (yyn);
-  switch (yyn)
-    {
-        case 2:
-#line 467 "third_party/libpg_query/grammar/grammar.y"
-    {
-				pg_yyget_extra(yyscanner)->parsetree = (yyvsp[(1) - (1)].list);
-			;}
-    break;
-
-  case 3:
-#line 483 "third_party/libpg_query/grammar/grammar.y"
-    {
-					if ((yyvsp[(1) - (3)].list) != NIL)
-					{
-						/* update length of previous stmt */
-						updateRawStmtEnd(llast_node(PGRawStmt, (yyvsp[(1) - (3)].list)), (yylsp[(2) - (3)]));
-					}
-					if ((yyvsp[(3) - (3)].node) != NULL)
-						(yyval.list) = lappend((yyvsp[(1) - (3)].list), makeRawStmt((yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]) + 1));
-					else
-						(yyval.list) = (yyvsp[(1) - (3)].list);
-				;}
-    break;
-
-  case 4:
-#line 495 "third_party/libpg_query/grammar/grammar.y"
-    {
-					if ((yyvsp[(1) - (1)].node) != NULL)
-						(yyval.list) = list_make1(makeRawStmt((yyvsp[(1) - (1)].node), 0));
-					else
-						(yyval.list) = NIL;
-				;}
-    break;
-
-  case 39:
-#line 538 "third_party/libpg_query/grammar/grammar.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 40:
-#line 10 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->cmds = (yyvsp[(4) - (4)].list);
-					n->relkind = PG_OBJECT_TABLE;
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 41:
-#line 19 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->cmds = (yyvsp[(6) - (6)].list);
-					n->relkind = PG_OBJECT_TABLE;
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 42:
-#line 28 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->cmds = (yyvsp[(4) - (4)].list);
-					n->relkind = PG_OBJECT_INDEX;
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 43:
-#line 37 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->cmds = (yyvsp[(6) - (6)].list);
-					n->relkind = PG_OBJECT_INDEX;
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 44:
-#line 46 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->cmds = (yyvsp[(4) - (4)].list);
-					n->relkind = PG_OBJECT_SEQUENCE;
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 45:
-#line 55 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->cmds = (yyvsp[(6) - (6)].list);
-					n->relkind = PG_OBJECT_SEQUENCE;
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 46:
-#line 64 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->cmds = (yyvsp[(4) - (4)].list);
-					n->relkind = PG_OBJECT_VIEW;
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 47:
-#line 73 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableStmt *n = makeNode(PGAlterTableStmt);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->cmds = (yyvsp[(6) - (6)].list);
-					n->relkind = PG_OBJECT_VIEW;
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 48:
-#line 86 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;}
-    break;
-
-  case 49:
-#line 88 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;}
-    break;
-
-  case 50:
-#line 93 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.node) = (yyvsp[(3) - (3)].node); ;}
-    break;
-
-  case 51:
-#line 94 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 52:
-#line 100 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = makeDefElem("restart", NULL, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 53:
-#line 104 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 54:
-#line 108 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					if (strcmp((yyvsp[(2) - (2)].defelt)->defname, "as") == 0 ||
-						strcmp((yyvsp[(2) - (2)].defelt)->defname, "restart") == 0 ||
-						strcmp((yyvsp[(2) - (2)].defelt)->defname, "owned_by") == 0)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("sequence option \"%s\" not supported here", (yyvsp[(2) - (2)].defelt)->defname),
-								 parser_errposition((yylsp[(2) - (2)]))));
-					(yyval.defelt) = (yyvsp[(2) - (2)].defelt);
-				;}
-    break;
-
-  case 55:
-#line 119 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = makeDefElem("generated", (PGNode *) makeInteger((yyvsp[(3) - (3)].ival)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 56:
-#line 127 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].defelt));
-				;}
-    break;
-
-  case 57:
-#line 131 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt));
-				;}
-    break;
-
-  case 58:
-#line 140 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddColumn;
-					n->def = (yyvsp[(2) - (2)].node);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 59:
-#line 149 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddColumn;
-					n->def = (yyvsp[(5) - (5)].node);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 60:
-#line 158 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddColumn;
-					n->def = (yyvsp[(3) - (3)].node);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 61:
-#line 167 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddColumn;
-					n->def = (yyvsp[(6) - (6)].node);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 62:
-#line 176 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_ColumnDefault;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->def = (yyvsp[(4) - (4)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 63:
-#line 185 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropNotNull;
-					n->name = (yyvsp[(3) - (6)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 64:
-#line 193 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetNotNull;
-					n->name = (yyvsp[(3) - (6)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 65:
-#line 201 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetStatistics;
-					n->name = (yyvsp[(3) - (6)].str);
-					n->def = (PGNode *) makeInteger((yyvsp[(6) - (6)].ival));
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 66:
-#line 210 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetOptions;
-					n->name = (yyvsp[(3) - (5)].str);
-					n->def = (PGNode *) (yyvsp[(5) - (5)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 67:
-#line 219 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_ResetOptions;
-					n->name = (yyvsp[(3) - (5)].str);
-					n->def = (PGNode *) (yyvsp[(5) - (5)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 68:
-#line 228 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetStorage;
-					n->name = (yyvsp[(3) - (6)].str);
-					n->def = (PGNode *) makeString((yyvsp[(6) - (6)].str));
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 69:
-#line 237 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					PGConstraint *c = makeNode(PGConstraint);
-
-					c->contype = PG_CONSTR_IDENTITY;
-					c->generated_when = (yyvsp[(6) - (9)].ival);
-					c->options = (yyvsp[(9) - (9)].list);
-					c->location = (yylsp[(5) - (9)]);
-
-					n->subtype = PG_AT_AddIdentity;
-					n->name = (yyvsp[(3) - (9)].str);
-					n->def = (PGNode *) c;
-
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 70:
-#line 254 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetIdentity;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->def = (PGNode *) (yyvsp[(4) - (4)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 71:
-#line 263 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = AT_DropIdentity;
-					n->name = (yyvsp[(3) - (5)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 72:
-#line 272 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = AT_DropIdentity;
-					n->name = (yyvsp[(3) - (7)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 73:
-#line 281 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropColumn;
-					n->name = (yyvsp[(5) - (6)].str);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 74:
-#line 291 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropColumn;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 75:
-#line 304 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					PGColumnDef *def = makeNode(PGColumnDef);
-					n->subtype = PG_AT_AlterColumnType;
-					n->name = (yyvsp[(3) - (8)].str);
-					n->def = (PGNode *) def;
-					/* We only use these fields of the PGColumnDef node */
-					def->typeName = (yyvsp[(6) - (8)].typnam);
-					def->collClause = (PGCollateClause *) (yyvsp[(7) - (8)].node);
-					def->raw_default = (yyvsp[(8) - (8)].node);
-					def->location = (yylsp[(3) - (8)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 76:
-#line 319 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AlterColumnGenericOptions;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->def = (PGNode *) (yyvsp[(4) - (4)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 77:
-#line 328 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_AddConstraint;
-					n->def = (yyvsp[(2) - (2)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 78:
-#line 336 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					PGConstraint *c = makeNode(PGConstraint);
-					n->subtype = PG_AT_AlterConstraint;
-					n->def = (PGNode *) c;
-					c->contype = PG_CONSTR_FOREIGN; /* others not supported, yet */
-					c->conname = (yyvsp[(3) - (4)].str);
-					processCASbits((yyvsp[(4) - (4)].ival), (yylsp[(4) - (4)]), "ALTER CONSTRAINT statement",
-									&c->deferrable,
-									&c->initdeferred,
-									NULL, NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 79:
-#line 351 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_ValidateConstraint;
-					n->name = (yyvsp[(3) - (3)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 80:
-#line 359 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropConstraint;
-					n->name = (yyvsp[(5) - (6)].str);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 81:
-#line 369 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_DropConstraint;
-					n->name = (yyvsp[(3) - (4)].str);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 82:
-#line 379 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetLogged;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 83:
-#line 386 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetUnLogged;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 84:
-#line 393 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_SetRelOptions;
-					n->def = (PGNode *)(yyvsp[(2) - (2)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 85:
-#line 401 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_ResetRelOptions;
-					n->def = (PGNode *)(yyvsp[(2) - (2)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 86:
-#line 408 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					PGAlterTableCmd *n = makeNode(PGAlterTableCmd);
-					n->subtype = PG_AT_GenericOptions;
-					n->def = (PGNode *)(yyvsp[(1) - (1)].list);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 87:
-#line 418 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 88:
-#line 419 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 89:
-#line 425 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = (yyvsp[(1) - (1)].defelt);
-				;}
-    break;
-
-  case 90:
-#line 429 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = (yyvsp[(2) - (2)].defelt);
-					(yyval.defelt)->defaction = PG_DEFELEM_SET;
-				;}
-    break;
-
-  case 91:
-#line 434 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = (yyvsp[(2) - (2)].defelt);
-					(yyval.defelt)->defaction = PG_DEFELEM_ADD;
-				;}
-    break;
-
-  case 92:
-#line 439 "third_party/libpg_query/grammar/statements/alter_table.y"
-    {
-					(yyval.defelt) = makeDefElemExtended(NULL, (yyvsp[(2) - (2)].str), NULL, DEFELEM_DROP, (yylsp[(2) - (2)]));
-				;}
-    break;
-
-  case 93:
-#line 446 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 94:
-#line 447 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 95:
-#line 452 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 96:
-#line 456 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.ival) = 1; ;}
-    break;
-
-  case 97:
-#line 457 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 98:
-#line 458 "third_party/libpg_query/grammar/statements/alter_table.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 99:
-#line 8 "third_party/libpg_query/grammar/statements/deallocate.y"
-    {
-						PGDeallocateStmt *n = makeNode(PGDeallocateStmt);
-						n->name = (yyvsp[(2) - (2)].str);
-						(yyval.node) = (PGNode *) n;
-					;}
-    break;
-
-  case 100:
-#line 14 "third_party/libpg_query/grammar/statements/deallocate.y"
-    {
-						PGDeallocateStmt *n = makeNode(PGDeallocateStmt);
-						n->name = (yyvsp[(3) - (3)].str);
-						(yyval.node) = (PGNode *) n;
-					;}
-    break;
-
-  case 101:
-#line 20 "third_party/libpg_query/grammar/statements/deallocate.y"
-    {
-						PGDeallocateStmt *n = makeNode(PGDeallocateStmt);
-						n->name = NULL;
-						(yyval.node) = (PGNode *) n;
-					;}
-    break;
-
-  case 102:
-#line 26 "third_party/libpg_query/grammar/statements/deallocate.y"
-    {
-						PGDeallocateStmt *n = makeNode(PGDeallocateStmt);
-						n->name = NULL;
-						(yyval.node) = (PGNode *) n;
-					;}
-    break;
-
-  case 103:
-#line 7 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_SCHEMA;
-					n->subname = (yyvsp[(3) - (6)].str);
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 104:
-#line 16 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 105:
-#line 26 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 106:
-#line 36 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_SEQUENCE;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 107:
-#line 46 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_SEQUENCE;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 108:
-#line 56 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_VIEW;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 109:
-#line 66 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_VIEW;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 110:
-#line 76 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_INDEX;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 111:
-#line 86 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_INDEX;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->subname = NULL;
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 112:
-#line 96 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_COLUMN;
-					n->relationType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(3) - (8)].range);
-					n->subname = (yyvsp[(6) - (8)].str);
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 113:
-#line 107 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_COLUMN;
-					n->relationType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(5) - (10)].range);
-					n->subname = (yyvsp[(8) - (10)].str);
-					n->newname = (yyvsp[(10) - (10)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 114:
-#line 118 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_TABCONSTRAINT;
-					n->relation = (yyvsp[(3) - (8)].range);
-					n->subname = (yyvsp[(6) - (8)].str);
-					n->newname = (yyvsp[(8) - (8)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 115:
-#line 128 "third_party/libpg_query/grammar/statements/rename.y"
-    {
-					PGRenameStmt *n = makeNode(PGRenameStmt);
-					n->renameType = PG_OBJECT_TABCONSTRAINT;
-					n->relation = (yyvsp[(5) - (10)].range);
-					n->subname = (yyvsp[(8) - (10)].str);
-					n->newname = (yyvsp[(10) - (10)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 116:
-#line 140 "third_party/libpg_query/grammar/statements/rename.y"
-    { (yyval.ival) = COLUMN; ;}
-    break;
-
-  case 117:
-#line 141 "third_party/libpg_query/grammar/statements/rename.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 118:
-#line 10 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyvsp[(5) - (7)].istmt)->relation = (yyvsp[(4) - (7)].range);
-					(yyvsp[(5) - (7)].istmt)->onConflictClause = (yyvsp[(6) - (7)].onconflict);
-					(yyvsp[(5) - (7)].istmt)->returningList = (yyvsp[(7) - (7)].list);
-					(yyvsp[(5) - (7)].istmt)->withClause = (yyvsp[(1) - (7)].with);
-					(yyval.node) = (PGNode *) (yyvsp[(5) - (7)].istmt);
-				;}
-    break;
-
-  case 119:
-#line 22 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = NIL;
-					(yyval.istmt)->selectStmt = (yyvsp[(1) - (1)].node);
-				;}
-    break;
-
-  case 120:
-#line 28 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = NIL;
-					(yyval.istmt)->override = (yyvsp[(2) - (4)].override);
-					(yyval.istmt)->selectStmt = (yyvsp[(4) - (4)].node);
-				;}
-    break;
-
-  case 121:
-#line 35 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = (yyvsp[(2) - (4)].list);
-					(yyval.istmt)->selectStmt = (yyvsp[(4) - (4)].node);
-				;}
-    break;
-
-  case 122:
-#line 41 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = (yyvsp[(2) - (7)].list);
-					(yyval.istmt)->override = (yyvsp[(5) - (7)].override);
-					(yyval.istmt)->selectStmt = (yyvsp[(7) - (7)].node);
-				;}
-    break;
-
-  case 123:
-#line 48 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.istmt) = makeNode(PGInsertStmt);
-					(yyval.istmt)->cols = NIL;
-					(yyval.istmt)->selectStmt = NULL;
-				;}
-    break;
-
-  case 124:
-#line 58 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.range) = (yyvsp[(1) - (1)].range);
-				;}
-    break;
-
-  case 125:
-#line 62 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyvsp[(1) - (3)].range)->alias = makeAlias((yyvsp[(3) - (3)].str), NIL);
-					(yyval.range) = (yyvsp[(1) - (3)].range);
-				;}
-    break;
-
-  case 126:
-#line 71 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.infer) = makeNode(PGInferClause);
-					(yyval.infer)->indexElems = (yyvsp[(2) - (4)].list);
-					(yyval.infer)->whereClause = (yyvsp[(4) - (4)].node);
-					(yyval.infer)->conname = NULL;
-					(yyval.infer)->location = (yylsp[(1) - (4)]);
-				;}
-    break;
-
-  case 127:
-#line 80 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.infer) = makeNode(PGInferClause);
-					(yyval.infer)->indexElems = NIL;
-					(yyval.infer)->whereClause = NULL;
-					(yyval.infer)->conname = (yyvsp[(3) - (3)].str);
-					(yyval.infer)->location = (yylsp[(1) - (3)]);
-				;}
-    break;
-
-  case 128:
-#line 88 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.infer) = NULL;
-				;}
-    break;
-
-  case 129:
-#line 95 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.with) = (yyvsp[(1) - (1)].with); ;}
-    break;
-
-  case 130:
-#line 96 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.with) = NULL; ;}
-    break;
-
-  case 131:
-#line 102 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(1) - (2)].str);
-					(yyval.target)->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-					(yyval.target)->val = NULL;
-					(yyval.target)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 132:
-#line 114 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyvsp[(1) - (3)].target)->val = (PGNode *) (yyvsp[(3) - (3)].node);
-					(yyval.list) = list_make1((yyvsp[(1) - (3)].target));
-				;}
-    break;
-
-  case 133:
-#line 119 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					int ncolumns = list_length((yyvsp[(2) - (5)].list));
-					int i = 1;
-					PGListCell *col_cell;
-
-					/* Create a PGMultiAssignRef source for each target */
-					foreach(col_cell, (yyvsp[(2) - (5)].list))
-					{
-						PGResTarget *res_col = (PGResTarget *) lfirst(col_cell);
-						PGMultiAssignRef *r = makeNode(PGMultiAssignRef);
-
-						r->source = (PGNode *) (yyvsp[(5) - (5)].node);
-						r->colno = i;
-						r->ncolumns = ncolumns;
-						res_col->val = (PGNode *) r;
-						i++;
-					}
-
-					(yyval.list) = (yyvsp[(2) - (5)].list);
-				;}
-    break;
-
-  case 134:
-#line 144 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflict) = makeNode(PGOnConflictClause);
-					(yyval.onconflict)->action = PG_ONCONFLICT_UPDATE;
-					(yyval.onconflict)->infer = (yyvsp[(3) - (8)].infer);
-					(yyval.onconflict)->targetList = (yyvsp[(7) - (8)].list);
-					(yyval.onconflict)->whereClause = (yyvsp[(8) - (8)].node);
-					(yyval.onconflict)->location = (yylsp[(1) - (8)]);
-				;}
-    break;
-
-  case 135:
-#line 154 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflict) = makeNode(PGOnConflictClause);
-					(yyval.onconflict)->action = PG_ONCONFLICT_NOTHING;
-					(yyval.onconflict)->infer = (yyvsp[(3) - (5)].infer);
-					(yyval.onconflict)->targetList = NIL;
-					(yyval.onconflict)->whereClause = NULL;
-					(yyval.onconflict)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 136:
-#line 163 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.onconflict) = NULL;
-				;}
-    break;
-
-  case 137:
-#line 170 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.ielem) = makeNode(PGIndexElem);
-					(yyval.ielem)->name = (yyvsp[(1) - (5)].str);
-					(yyval.ielem)->expr = NULL;
-					(yyval.ielem)->indexcolname = NULL;
-					(yyval.ielem)->collation = (yyvsp[(2) - (5)].list);
-					(yyval.ielem)->opclass = (yyvsp[(3) - (5)].list);
-					(yyval.ielem)->ordering = (yyvsp[(4) - (5)].sortorder);
-					(yyval.ielem)->nulls_ordering = (yyvsp[(5) - (5)].nullorder);
-				;}
-    break;
-
-  case 138:
-#line 181 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.ielem) = makeNode(PGIndexElem);
-					(yyval.ielem)->name = NULL;
-					(yyval.ielem)->expr = (yyvsp[(1) - (5)].node);
-					(yyval.ielem)->indexcolname = NULL;
-					(yyval.ielem)->collation = (yyvsp[(2) - (5)].list);
-					(yyval.ielem)->opclass = (yyvsp[(3) - (5)].list);
-					(yyval.ielem)->ordering = (yyvsp[(4) - (5)].sortorder);
-					(yyval.ielem)->nulls_ordering = (yyvsp[(5) - (5)].nullorder);
-				;}
-    break;
-
-  case 139:
-#line 192 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.ielem) = makeNode(PGIndexElem);
-					(yyval.ielem)->name = NULL;
-					(yyval.ielem)->expr = (yyvsp[(2) - (7)].node);
-					(yyval.ielem)->indexcolname = NULL;
-					(yyval.ielem)->collation = (yyvsp[(4) - (7)].list);
-					(yyval.ielem)->opclass = (yyvsp[(5) - (7)].list);
-					(yyval.ielem)->ordering = (yyvsp[(6) - (7)].sortorder);
-					(yyval.ielem)->nulls_ordering = (yyvsp[(7) - (7)].nullorder);
-				;}
-    break;
-
-  case 140:
-#line 206 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 141:
-#line 207 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 142:
-#line 213 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.override) = PG_OVERRIDING_USER_VALUE; ;}
-    break;
-
-  case 143:
-#line 214 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.override) = OVERRIDING_SYSTEM_VALUE; ;}
-    break;
-
-  case 144:
-#line 219 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;}
-    break;
-
-  case 145:
-#line 220 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].target)); ;}
-    break;
-
-  case 146:
-#line 226 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 147:
-#line 227 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 148:
-#line 231 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 149:
-#line 232 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 150:
-#line 238 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;}
-    break;
-
-  case 151:
-#line 240 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;}
-    break;
-
-  case 152:
-#line 245 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 153:
-#line 246 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = list_concat((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 154:
-#line 250 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 155:
-#line 251 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 156:
-#line 254 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].ielem)); ;}
-    break;
-
-  case 157:
-#line 255 "third_party/libpg_query/grammar/statements/insert.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].ielem)); ;}
-    break;
-
-  case 158:
-#line 261 "third_party/libpg_query/grammar/statements/insert.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(1) - (2)].str);
-					(yyval.target)->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-					(yyval.target)->val = NULL;	/* upper production sets this */
-					(yyval.target)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 159:
-#line 8 "third_party/libpg_query/grammar/statements/create_type.y"
-    {
-					PGCreateTypeStmt *n = makeNode(PGCreateTypeStmt);
-					n->typeName = (yyvsp[(3) - (5)].list);
-					auto name = std::string(reinterpret_cast<PGValue *>((yyvsp[(5) - (5)].typnam)->names->tail->data.ptr_value)->val.str);
-					if (name == "enum") {
-						n->kind = PG_NEWTYPE_ENUM;
-						n->vals = (yyvsp[(5) - (5)].typnam)->typmods;
-					} else {
-						n->kind = PG_NEWTYPE_ALIAS;
-						n->ofType = (yyvsp[(5) - (5)].typnam);
-					}
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 160:
-#line 8 "third_party/libpg_query/grammar/statements/pragma.y"
-    {
-					PGPragmaStmt *n = makeNode(PGPragmaStmt);
-					n->kind = PG_PRAGMA_TYPE_NOTHING;
-					n->name = (yyvsp[(2) - (2)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 161:
-#line 15 "third_party/libpg_query/grammar/statements/pragma.y"
-    {
-					PGPragmaStmt *n = makeNode(PGPragmaStmt);
-					n->kind = PG_PRAGMA_TYPE_ASSIGNMENT;
-					n->name = (yyvsp[(2) - (4)].str);
-					n->args = (yyvsp[(4) - (4)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 162:
-#line 23 "third_party/libpg_query/grammar/statements/pragma.y"
-    {
-					PGPragmaStmt *n = makeNode(PGPragmaStmt);
-					n->kind = PG_PRAGMA_TYPE_CALL;
-					n->name = (yyvsp[(2) - (5)].str);
-					n->args = (yyvsp[(4) - (5)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 163:
-#line 10 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    {
-					PGCreateSeqStmt *n = makeNode(PGCreateSeqStmt);
-					(yyvsp[(4) - (5)].range)->relpersistence = (yyvsp[(2) - (5)].ival);
-					n->sequence = (yyvsp[(4) - (5)].range);
-					n->options = (yyvsp[(5) - (5)].list);
-					n->ownerId = InvalidOid;
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 164:
-#line 20 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    {
-					PGCreateSeqStmt *n = makeNode(PGCreateSeqStmt);
-					(yyvsp[(7) - (8)].range)->relpersistence = (yyvsp[(2) - (8)].ival);
-					n->sequence = (yyvsp[(7) - (8)].range);
-					n->options = (yyvsp[(8) - (8)].list);
-					n->ownerId = InvalidOid;
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 165:
-#line 32 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 166:
-#line 33 "third_party/libpg_query/grammar/statements/create_sequence.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 167:
-#line 8 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					PGExecuteStmt *n = makeNode(PGExecuteStmt);
-					n->name = (yyvsp[(2) - (3)].str);
-					n->params = (yyvsp[(3) - (3)].list);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 168:
-#line 16 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					PGExecuteStmt *n = makeNode(PGExecuteStmt);
-					n->name = (yyvsp[(7) - (9)].str);
-					n->params = (yyvsp[(8) - (9)].list);
-					ctas->query = (PGNode *) n;
-					ctas->into = (yyvsp[(4) - (9)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_ERROR_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(4) - (9)].into)->rel->relpersistence = (yyvsp[(2) - (9)].ival);
-					(yyvsp[(4) - (9)].into)->skipData = !((yyvsp[(9) - (9)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 169:
-#line 33 "third_party/libpg_query/grammar/statements/execute.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					PGExecuteStmt *n = makeNode(PGExecuteStmt);
-					n->name = (yyvsp[(10) - (12)].str);
-					n->params = (yyvsp[(11) - (12)].list);
-					ctas->query = (PGNode *) n;
-					ctas->into = (yyvsp[(7) - (12)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_IGNORE_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(7) - (12)].into)->rel->relpersistence = (yyvsp[(2) - (12)].ival);
-					(yyvsp[(7) - (12)].into)->skipData = !((yyvsp[(12) - (12)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 170:
-#line 51 "third_party/libpg_query/grammar/statements/execute.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 171:
-#line 52 "third_party/libpg_query/grammar/statements/execute.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 172:
-#line 10 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					PGAlterSeqStmt *n = makeNode(PGAlterSeqStmt);
-					n->sequence = (yyvsp[(3) - (4)].range);
-					n->options = (yyvsp[(4) - (4)].list);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 173:
-#line 18 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					PGAlterSeqStmt *n = makeNode(PGAlterSeqStmt);
-					n->sequence = (yyvsp[(5) - (6)].range);
-					n->options = (yyvsp[(6) - (6)].list);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 174:
-#line 29 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;}
-    break;
-
-  case 175:
-#line 30 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;}
-    break;
-
-  case 176:
-#line 34 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 177:
-#line 35 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 178:
-#line 36 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 179:
-#line 41 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.value) = makeFloat((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 180:
-#line 42 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.value) = makeFloat((yyvsp[(2) - (2)].str)); ;}
-    break;
-
-  case 181:
-#line 44 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.value) = makeFloat((yyvsp[(2) - (2)].str));
-					doNegateFloat((yyval.value));
-				;}
-    break;
-
-  case 182:
-#line 48 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.value) = makeInteger((yyvsp[(1) - (1)].ival)); ;}
-    break;
-
-  case 183:
-#line 53 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("as", (PGNode *)(yyvsp[(2) - (2)].typnam), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 184:
-#line 57 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("cache", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 185:
-#line 61 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(true), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 186:
-#line 65 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("cycle", (PGNode *)makeInteger(false), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 187:
-#line 69 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("increment", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 188:
-#line 73 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("maxvalue", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 189:
-#line 77 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("minvalue", (PGNode *)(yyvsp[(2) - (2)].value), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 190:
-#line 81 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("maxvalue", NULL, (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 191:
-#line 85 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("minvalue", NULL, (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 192:
-#line 89 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("owned_by", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 193:
-#line 93 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					/* not documented, only used by pg_dump */
-					(yyval.defelt) = makeDefElem("sequence_name", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 194:
-#line 98 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("start", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 195:
-#line 102 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("restart", NULL, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 196:
-#line 106 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {
-					(yyval.defelt) = makeDefElem("restart", (PGNode *)(yyvsp[(3) - (3)].value), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 197:
-#line 112 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 198:
-#line 113 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    {;}
-    break;
-
-  case 199:
-#line 117 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;}
-    break;
-
-  case 200:
-#line 118 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.ival) = + (yyvsp[(2) - (2)].ival); ;}
-    break;
-
-  case 201:
-#line 119 "third_party/libpg_query/grammar/statements/alter_sequence.y"
-    { (yyval.ival) = - (yyvsp[(2) - (2)].ival); ;}
-    break;
-
-  case 202:
-#line 3 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_ROLLBACK;
-					n->options = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 203:
-#line 10 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_BEGIN;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 204:
-#line 16 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_START;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 205:
-#line 22 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_COMMIT;
-					n->options = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 206:
-#line 29 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_COMMIT;
-					n->options = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 207:
-#line 36 "third_party/libpg_query/grammar/statements/transaction.y"
-    {
-					PGTransactionStmt *n = makeNode(PGTransactionStmt);
-					n->kind = PG_TRANS_STMT_ROLLBACK;
-					n->options = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 208:
-#line 45 "third_party/libpg_query/grammar/statements/transaction.y"
-    {;}
-    break;
-
-  case 209:
-#line 46 "third_party/libpg_query/grammar/statements/transaction.y"
-    {;}
-    break;
-
-  case 210:
-#line 47 "third_party/libpg_query/grammar/statements/transaction.y"
-    {;}
-    break;
-
-  case 211:
-#line 9 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGCreateStmt *n = makeNode(PGCreateStmt);
-					(yyvsp[(4) - (9)].range)->relpersistence = (yyvsp[(2) - (9)].ival);
-					n->relation = (yyvsp[(4) - (9)].range);
-					n->tableElts = (yyvsp[(6) - (9)].list);
-					n->ofTypename = NULL;
-					n->constraints = NIL;
-					n->options = (yyvsp[(8) - (9)].list);
-					n->oncommit = (yyvsp[(9) - (9)].oncommit);
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 212:
-#line 24 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGCreateStmt *n = makeNode(PGCreateStmt);
-					(yyvsp[(7) - (12)].range)->relpersistence = (yyvsp[(2) - (12)].ival);
-					n->relation = (yyvsp[(7) - (12)].range);
-					n->tableElts = (yyvsp[(9) - (12)].list);
-					n->ofTypename = NULL;
-					n->constraints = NIL;
-					n->options = (yyvsp[(11) - (12)].list);
-					n->oncommit = (yyvsp[(12) - (12)].oncommit);
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 213:
-#line 39 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGCreateStmt *n = makeNode(PGCreateStmt);
-					(yyvsp[(6) - (11)].range)->relpersistence = (yyvsp[(4) - (11)].ival);
-					n->relation = (yyvsp[(6) - (11)].range);
-					n->tableElts = (yyvsp[(8) - (11)].list);
-					n->ofTypename = NULL;
-					n->constraints = NIL;
-					n->options = (yyvsp[(10) - (11)].list);
-					n->oncommit = (yyvsp[(11) - (11)].oncommit);
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 214:
-#line 56 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 215:
-#line 58 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					/*
-					 * We must complain about conflicting options.
-					 * We could, but choose not to, complain about redundant
-					 * options (ie, where $2's bit is already set in $1).
-					 */
-					int		newspec = (yyvsp[(1) - (2)].ival) | (yyvsp[(2) - (2)].ival);
-
-					/* special message for this case */
-					if ((newspec & (CAS_NOT_DEFERRABLE | CAS_INITIALLY_DEFERRED)) == (CAS_NOT_DEFERRABLE | CAS_INITIALLY_DEFERRED))
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"),
-								 parser_errposition((yylsp[(2) - (2)]))));
-					/* generic message for other conflicts */
-					if ((newspec & (CAS_NOT_DEFERRABLE | CAS_DEFERRABLE)) == (CAS_NOT_DEFERRABLE | CAS_DEFERRABLE) ||
-						(newspec & (CAS_INITIALLY_IMMEDIATE | CAS_INITIALLY_DEFERRED)) == (CAS_INITIALLY_IMMEDIATE | CAS_INITIALLY_DEFERRED))
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("conflicting constraint properties"),
-								 parser_errposition((yylsp[(2) - (2)]))));
-					(yyval.ival) = newspec;
-				;}
-    break;
-
-  case 216:
-#line 84 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 217:
-#line 85 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;}
-    break;
-
-  case 218:
-#line 86 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 219:
-#line 87 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].value); ;}
-    break;
-
-  case 220:
-#line 88 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 221:
-#line 89 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;}
-    break;
-
-  case 222:
-#line 93 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 223:
-#line 94 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 224:
-#line 99 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 225:
-#line 104 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_NOACTION; ;}
-    break;
-
-  case 226:
-#line 105 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_RESTRICT; ;}
-    break;
-
-  case 227:
-#line 106 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_CASCADE; ;}
-    break;
-
-  case 228:
-#line 107 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_SETNULL; ;}
-    break;
-
-  case 229:
-#line 108 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_FKCONSTR_ACTION_SETDEFAULT; ;}
-    break;
-
-  case 230:
-#line 114 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = castNode(PGConstraint, (yyvsp[(3) - (3)].node));
-					n->conname = (yyvsp[(2) - (3)].str);
-					n->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 231:
-#line 120 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 232:
-#line 121 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 233:
-#line 123 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					/*
-					 * Note: the PGCollateClause is momentarily included in
-					 * the list built by ColQualList, but we split it out
-					 * again in SplitColQualList.
-					 */
-					PGCollateClause *n = makeNode(PGCollateClause);
-					n->arg = NULL;
-					n->collname = (yyvsp[(2) - (2)].list);
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 234:
-#line 140 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_NOTNULL;
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 235:
-#line 147 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_NULL;
-					n->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 236:
-#line 154 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_UNIQUE;
-					n->location = (yylsp[(1) - (2)]);
-					n->keys = NULL;
-					n->options = (yyvsp[(2) - (2)].list);
-					n->indexname = NULL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 237:
-#line 164 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_PRIMARY;
-					n->location = (yylsp[(1) - (3)]);
-					n->keys = NULL;
-					n->options = (yyvsp[(3) - (3)].list);
-					n->indexname = NULL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 238:
-#line 174 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_CHECK;
-					n->location = (yylsp[(1) - (5)]);
-					n->is_no_inherit = (yyvsp[(5) - (5)].boolean);
-					n->raw_expr = (yyvsp[(3) - (5)].node);
-					n->cooked_expr = NULL;
-					n->skip_validation = false;
-					n->initially_valid = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 239:
-#line 186 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_COMPRESSION;
-					n->location = (yylsp[(1) - (3)]);
-					n->compression_name = (yyvsp[(3) - (3)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 240:
-#line 194 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_DEFAULT;
-					n->location = (yylsp[(1) - (2)]);
-					n->raw_expr = (yyvsp[(2) - (2)].node);
-					n->cooked_expr = NULL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 241:
-#line 203 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_FOREIGN;
-					n->location = (yylsp[(1) - (5)]);
-					n->pktable			= (yyvsp[(2) - (5)].range);
-					n->fk_attrs			= NIL;
-					n->pk_attrs			= (yyvsp[(3) - (5)].list);
-					n->fk_matchtype		= (yyvsp[(4) - (5)].ival);
-					n->fk_upd_action	= (char) ((yyvsp[(5) - (5)].ival) >> 8);
-					n->fk_del_action	= (char) ((yyvsp[(5) - (5)].ival) & 0xFF);
-					n->skip_validation  = false;
-					n->initially_valid  = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 242:
-#line 220 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;}
-    break;
-
-  case 243:
-#line 221 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.constr) = PG_CONSTR_GENERATED_STORED; ;}
-    break;
-
-  case 244:
-#line 225 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.constr) = (yyvsp[(1) - (1)].constr) ;}
-    break;
-
-  case 245:
-#line 226 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;}
-    break;
-
-  case 246:
-#line 231 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_IDENTITY;
-					n->generated_when = (yyvsp[(2) - (5)].ival);
-					n->options = (yyvsp[(5) - (5)].list);
-					n->location = (yylsp[(1) - (5)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 247:
-#line 240 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = (yyvsp[(7) - (7)].constr);
-					n->generated_when = (yyvsp[(2) - (7)].ival);
-					n->raw_expr = (yyvsp[(5) - (7)].node);
-					n->cooked_expr = NULL;
-					n->location = (yylsp[(1) - (7)]);
-
-					/*
-					 * Can't do this in the grammar because of shift/reduce
-					 * conflicts.  (IDENTITY allows both ALWAYS and BY
-					 * DEFAULT, but generated columns only allow ALWAYS.)  We
-					 * can also give a more useful error message and location.
-					 */
-					if ((yyvsp[(2) - (7)].ival) != PG_ATTRIBUTE_IDENTITY_ALWAYS)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("for a generated column, GENERATED ALWAYS must be specified"),
-								 parser_errposition((yylsp[(2) - (7)]))));
-
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 248:
-#line 263 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = (yyvsp[(5) - (5)].constr);
-					n->generated_when = PG_ATTRIBUTE_IDENTITY_ALWAYS;
-					n->raw_expr = (yyvsp[(3) - (5)].node);
-					n->cooked_expr = NULL;
-					n->location = (yylsp[(1) - (5)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 249:
-#line 277 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 250:
-#line 283 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 251:
-#line 289 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = ((yyvsp[(1) - (1)].ival) << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;}
-    break;
-
-  case 252:
-#line 291 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | ((yyvsp[(1) - (1)].ival) & 0xFF); ;}
-    break;
-
-  case 253:
-#line 293 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = ((yyvsp[(1) - (2)].ival) << 8) | ((yyvsp[(2) - (2)].ival) & 0xFF); ;}
-    break;
-
-  case 254:
-#line 295 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = ((yyvsp[(2) - (2)].ival) << 8) | ((yyvsp[(1) - (2)].ival) & 0xFF); ;}
-    break;
-
-  case 255:
-#line 297 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;}
-    break;
-
-  case 256:
-#line 300 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.oncommit) = ONCOMMIT_DROP; ;}
-    break;
-
-  case 257:
-#line 301 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.oncommit) = PG_ONCOMMIT_DELETE_ROWS; ;}
-    break;
-
-  case 258:
-#line 302 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.oncommit) = PG_ONCOMMIT_PRESERVE_ROWS; ;}
-    break;
-
-  case 259:
-#line 303 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.oncommit) = PG_ONCOMMIT_NOOP; ;}
-    break;
-
-  case 260:
-#line 308 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 261:
-#line 312 "third_party/libpg_query/grammar/statements/create.y"
-    {  (yyval.boolean) = true; ;}
-    break;
-
-  case 262:
-#line 313 "third_party/libpg_query/grammar/statements/create.y"
-    {  (yyval.boolean) = false; ;}
-    break;
-
-  case 263:
-#line 319 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = castNode(PGConstraint, (yyvsp[(3) - (3)].node));
-					n->conname = (yyvsp[(2) - (3)].str);
-					n->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 264:
-#line 325 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 265:
-#line 330 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_COMMENTS; ;}
-    break;
-
-  case 266:
-#line 331 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_CONSTRAINTS; ;}
-    break;
-
-  case 267:
-#line 332 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_DEFAULTS; ;}
-    break;
-
-  case 268:
-#line 333 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_IDENTITY; ;}
-    break;
-
-  case 269:
-#line 334 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_INDEXES; ;}
-    break;
-
-  case 270:
-#line 335 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_STATISTICS; ;}
-    break;
-
-  case 271:
-#line 336 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_STORAGE; ;}
-    break;
-
-  case 272:
-#line 337 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_CREATE_TABLE_LIKE_ALL; ;}
-    break;
-
-  case 273:
-#line 343 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;}
-    break;
-
-  case 274:
-#line 344 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;}
-    break;
-
-  case 275:
-#line 348 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.str) = (yyvsp[(3) - (3)].str); ;}
-    break;
-
-  case 276:
-#line 354 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_ATTR_DEFERRABLE;
-					n->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 277:
-#line 361 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_ATTR_NOT_DEFERRABLE;
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 278:
-#line 368 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_ATTR_DEFERRED;
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 279:
-#line 375 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_ATTR_IMMEDIATE;
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 280:
-#line 386 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 281:
-#line 387 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(true), (yylsp[(1) - (2)]))); ;}
-    break;
-
-  case 282:
-#line 388 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(false), (yylsp[(1) - (2)]))); ;}
-    break;
-
-  case 283:
-#line 389 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 284:
-#line 393 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 285:
-#line 398 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 286:
-#line 399 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (yyvsp[(1) - (3)].ival) & ~(yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 287:
-#line 400 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 288:
-#line 405 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 289:
-#line 410 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_NOT_DEFERRABLE; ;}
-    break;
-
-  case 290:
-#line 411 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_DEFERRABLE; ;}
-    break;
-
-  case 291:
-#line 412 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_INITIALLY_IMMEDIATE; ;}
-    break;
-
-  case 292:
-#line 413 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_INITIALLY_DEFERRED; ;}
-    break;
-
-  case 293:
-#line 414 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_NOT_VALID; ;}
-    break;
-
-  case 294:
-#line 415 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = CAS_NO_INHERIT; ;}
-    break;
-
-  case 295:
-#line 421 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGColumnDef *n = makeNode(PGColumnDef);
-					n->category = COL_STANDARD;
-					n->colname = (yyvsp[(1) - (3)].str);
-					n->typeName = (yyvsp[(2) - (3)].typnam);
-					n->inhcount = 0;
-					n->is_local = true;
-					n->is_not_null = false;
-					n->is_from_type = false;
-					n->storage = 0;
-					n->raw_default = NULL;
-					n->cooked_default = NULL;
-					n->collOid = InvalidOid;
-					SplitColQualList((yyvsp[(3) - (3)].list), &n->constraints, &n->collClause,
-									 yyscanner);
-					n->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 296:
-#line 441 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGColumnDef *n = makeNode(PGColumnDef);
-					n->category = COL_GENERATED;
-					n->colname = (yyvsp[(1) - (4)].str);
-					n->typeName = (yyvsp[(2) - (4)].typnam);
-					n->inhcount = 0;
-					n->is_local = true;
-					n->is_not_null = false;
-					n->is_from_type = false;
-					n->storage = 0;
-					n->raw_default = NULL;
-					n->cooked_default = NULL;
-					n->collOid = InvalidOid;
-					// merge the constraints with the generated column constraint
-					auto constraints = (yyvsp[(4) - (4)].list);
-					if (constraints) {
-					    constraints = lappend(constraints, (yyvsp[(3) - (4)].node));
-					} else {
-					    constraints = list_make1((yyvsp[(3) - (4)].node));
-					}
-					SplitColQualList(constraints, &n->constraints, &n->collClause,
-									 yyscanner);
-					n->location = (yylsp[(1) - (4)]);
-					(yyval.node) = (PGNode *)n;
-			;}
-    break;
-
-  case 297:
-#line 469 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;}
-    break;
-
-  case 298:
-#line 470 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;}
-    break;
-
-  case 299:
-#line 474 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 300:
-#line 478 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 301:
-#line 479 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 302:
-#line 480 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 303:
-#line 485 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 304:
-#line 489 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 305:
-#line 496 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 306:
-#line 497 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 307:
-#line 502 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 308:
-#line 503 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 309:
-#line 504 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 310:
-#line 509 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str));
-				;}
-    break;
-
-  case 311:
-#line 516 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 312:
-#line 517 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 313:
-#line 522 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 314:
-#line 523 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 315:
-#line 527 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 316:
-#line 533 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 317:
-#line 537 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 318:
-#line 541 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (PGNode *) (yyvsp[(5) - (5)].node),
-											 PG_DEFELEM_UNSPEC, (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 319:
-#line 546 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), NULL, PG_DEFELEM_UNSPEC, (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 320:
-#line 553 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 321:
-#line 554 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 322:
-#line 558 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 323:
-#line 559 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 324:
-#line 563 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 325:
-#line 565 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(1) - (4)].str)), (yyvsp[(2) - (4)].list)));
-					(yyval.typnam)->pct_type = true;
-					(yyval.typnam)->location = (yylsp[(1) - (4)]);
-				;}
-    break;
-
-  case 326:
-#line 571 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(2) - (5)].str)), (yyvsp[(3) - (5)].list)));
-					(yyval.typnam)->pct_type = true;
-					(yyval.typnam)->setof = true;
-					(yyval.typnam)->location = (yylsp[(2) - (5)]);
-				;}
-    break;
-
-  case 327:
-#line 582 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_CHECK;
-					n->location = (yylsp[(1) - (5)]);
-					n->raw_expr = (yyvsp[(3) - (5)].node);
-					n->cooked_expr = NULL;
-					processCASbits((yyvsp[(5) - (5)].ival), (yylsp[(5) - (5)]), "CHECK",
-								   NULL, NULL, &n->skip_validation,
-								   &n->is_no_inherit, yyscanner);
-					n->initially_valid = !n->skip_validation;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 328:
-#line 596 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_UNIQUE;
-					n->location = (yylsp[(1) - (6)]);
-					n->keys = (yyvsp[(3) - (6)].list);
-					n->options = (yyvsp[(5) - (6)].list);
-					n->indexname = NULL;
-					processCASbits((yyvsp[(6) - (6)].ival), (yylsp[(6) - (6)]), "UNIQUE",
-								   &n->deferrable, &n->initdeferred, NULL,
-								   NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 329:
-#line 609 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_UNIQUE;
-					n->location = (yylsp[(1) - (3)]);
-					n->keys = NIL;
-					n->options = NIL;
-					n->indexname = (yyvsp[(2) - (3)].str);
-					n->indexspace = NULL;
-					processCASbits((yyvsp[(3) - (3)].ival), (yylsp[(3) - (3)]), "UNIQUE",
-								   &n->deferrable, &n->initdeferred, NULL,
-								   NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 330:
-#line 624 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_PRIMARY;
-					n->location = (yylsp[(1) - (7)]);
-					n->keys = (yyvsp[(4) - (7)].list);
-					n->options = (yyvsp[(6) - (7)].list);
-					n->indexname = NULL;
-					processCASbits((yyvsp[(7) - (7)].ival), (yylsp[(7) - (7)]), "PRIMARY KEY",
-								   &n->deferrable, &n->initdeferred, NULL,
-								   NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 331:
-#line 637 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_PRIMARY;
-					n->location = (yylsp[(1) - (4)]);
-					n->keys = NIL;
-					n->options = NIL;
-					n->indexname = (yyvsp[(3) - (4)].str);
-					n->indexspace = NULL;
-					processCASbits((yyvsp[(4) - (4)].ival), (yylsp[(4) - (4)]), "PRIMARY KEY",
-								   &n->deferrable, &n->initdeferred, NULL,
-								   NULL, yyscanner);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 332:
-#line 652 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGConstraint *n = makeNode(PGConstraint);
-					n->contype = PG_CONSTR_FOREIGN;
-					n->location = (yylsp[(1) - (11)]);
-					n->pktable			= (yyvsp[(7) - (11)].range);
-					n->fk_attrs			= (yyvsp[(4) - (11)].list);
-					n->pk_attrs			= (yyvsp[(8) - (11)].list);
-					n->fk_matchtype		= (yyvsp[(9) - (11)].ival);
-					n->fk_upd_action	= (char) ((yyvsp[(10) - (11)].ival) >> 8);
-					n->fk_del_action	= (char) ((yyvsp[(10) - (11)].ival) & 0xFF);
-					processCASbits((yyvsp[(11) - (11)].ival), (yylsp[(11) - (11)]), "FOREIGN KEY",
-								   &n->deferrable, &n->initdeferred,
-								   &n->skip_validation, NULL,
-								   yyscanner);
-					n->initially_valid = !n->skip_validation;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 333:
-#line 674 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 334:
-#line 678 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 335:
-#line 685 "third_party/libpg_query/grammar/statements/create.y"
-    {
-				(yyval.ival) = PG_FKCONSTR_MATCH_FULL;
-			;}
-    break;
-
-  case 336:
-#line 689 "third_party/libpg_query/grammar/statements/create.y"
-    {
-				ereport(ERROR,
-						(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-						 errmsg("MATCH PARTIAL not yet implemented"),
-						 parser_errposition((yylsp[(1) - (2)]))));
-				(yyval.ival) = PG_FKCONSTR_MATCH_PARTIAL;
-			;}
-    break;
-
-  case 337:
-#line 697 "third_party/libpg_query/grammar/statements/create.y"
-    {
-				(yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE;
-			;}
-    break;
-
-  case 338:
-#line 701 "third_party/libpg_query/grammar/statements/create.y"
-    {
-				(yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE;
-			;}
-    break;
-
-  case 339:
-#line 709 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					PGTableLikeClause *n = makeNode(PGTableLikeClause);
-					n->relation = (yyvsp[(2) - (3)].range);
-					n->options = (yyvsp[(3) - (3)].ival);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 340:
-#line 718 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;}
-    break;
-
-  case 341:
-#line 719 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;}
-    break;
-
-  case 342:
-#line 720 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;}
-    break;
-
-  case 343:
-#line 721 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;}
-    break;
-
-  case 344:
-#line 723 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					ereport(PGWARNING,
-							(errmsg("GLOBAL is deprecated in temporary table creation"),
-							 parser_errposition((yylsp[(1) - (2)]))));
-					(yyval.ival) = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 345:
-#line 730 "third_party/libpg_query/grammar/statements/create.y"
-    {
-					ereport(PGWARNING,
-							(errmsg("GLOBAL is deprecated in temporary table creation"),
-							 parser_errposition((yylsp[(1) - (2)]))));
-					(yyval.ival) = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 346:
-#line 736 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_RELPERSISTENCE_UNLOGGED; ;}
-    break;
-
-  case 347:
-#line 737 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = RELPERSISTENCE_PERMANENT; ;}
-    break;
-
-  case 348:
-#line 742 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = PG_ATTRIBUTE_IDENTITY_ALWAYS; ;}
-    break;
-
-  case 349:
-#line 743 "third_party/libpg_query/grammar/statements/create.y"
-    { (yyval.ival) = ATTRIBUTE_IDENTITY_BY_DEFAULT; ;}
-    break;
-
-  case 350:
-#line 10 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (6)].objtype);
-					n->missing_ok = true;
-					n->objects = (yyvsp[(5) - (6)].list);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 351:
-#line 20 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (4)].objtype);
-					n->missing_ok = false;
-					n->objects = (yyvsp[(3) - (4)].list);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 352:
-#line 30 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (6)].objtype);
-					n->missing_ok = true;
-					n->objects = (yyvsp[(5) - (6)].list);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 353:
-#line 40 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (4)].objtype);
-					n->missing_ok = false;
-					n->objects = (yyvsp[(3) - (4)].list);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 354:
-#line 50 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (6)].objtype);
-					n->objects = list_make1(lappend((yyvsp[(5) - (6)].list), makeString((yyvsp[(3) - (6)].str))));
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->missing_ok = false;
-					n->concurrent = false;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 355:
-#line 60 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = (yyvsp[(2) - (8)].objtype);
-					n->objects = list_make1(lappend((yyvsp[(7) - (8)].list), makeString((yyvsp[(5) - (8)].str))));
-					n->behavior = (yyvsp[(8) - (8)].dbehavior);
-					n->missing_ok = true;
-					n->concurrent = false;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 356:
-#line 70 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = PG_OBJECT_TYPE;
-					n->missing_ok = false;
-					n->objects = (yyvsp[(3) - (4)].list);
-					n->behavior = (yyvsp[(4) - (4)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 357:
-#line 80 "third_party/libpg_query/grammar/statements/drop.y"
-    {
-					PGDropStmt *n = makeNode(PGDropStmt);
-					n->removeType = PG_OBJECT_TYPE;
-					n->missing_ok = true;
-					n->objects = (yyvsp[(5) - (6)].list);
-					n->behavior = (yyvsp[(6) - (6)].dbehavior);
-					n->concurrent = false;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 358:
-#line 93 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TABLE; ;}
-    break;
-
-  case 359:
-#line 94 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;}
-    break;
-
-  case 360:
-#line 95 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FUNCTION; ;}
-    break;
-
-  case 361:
-#line 96 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FUNCTION; ;}
-    break;
-
-  case 362:
-#line 97 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;}
-    break;
-
-  case 363:
-#line 98 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_VIEW; ;}
-    break;
-
-  case 364:
-#line 99 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_MATVIEW; ;}
-    break;
-
-  case 365:
-#line 100 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_INDEX; ;}
-    break;
-
-  case 366:
-#line 101 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FOREIGN_TABLE; ;}
-    break;
-
-  case 367:
-#line 102 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_COLLATION; ;}
-    break;
-
-  case 368:
-#line 103 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_CONVERSION; ;}
-    break;
-
-  case 369:
-#line 104 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_STATISTIC_EXT; ;}
-    break;
-
-  case 370:
-#line 105 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TSPARSER; ;}
-    break;
-
-  case 371:
-#line 106 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TSDICTIONARY; ;}
-    break;
-
-  case 372:
-#line 107 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TSTEMPLATE; ;}
-    break;
-
-  case 373:
-#line 108 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TSCONFIGURATION; ;}
-    break;
-
-  case 374:
-#line 113 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_ACCESS_METHOD; ;}
-    break;
-
-  case 375:
-#line 114 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_EVENT_TRIGGER; ;}
-    break;
-
-  case 376:
-#line 115 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_EXTENSION; ;}
-    break;
-
-  case 377:
-#line 116 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FDW; ;}
-    break;
-
-  case 378:
-#line 117 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_PUBLICATION; ;}
-    break;
-
-  case 379:
-#line 118 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_SCHEMA; ;}
-    break;
-
-  case 380:
-#line 119 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_FOREIGN_SERVER; ;}
-    break;
-
-  case 381:
-#line 124 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 382:
-#line 125 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 383:
-#line 130 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.dbehavior) = PG_DROP_CASCADE; ;}
-    break;
-
-  case 384:
-#line 131 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.dbehavior) = PG_DROP_RESTRICT; ;}
-    break;
-
-  case 385:
-#line 132 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.dbehavior) = PG_DROP_RESTRICT; /* default */ ;}
-    break;
-
-  case 386:
-#line 137 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_POLICY; ;}
-    break;
-
-  case 387:
-#line 138 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_RULE; ;}
-    break;
-
-  case 388:
-#line 139 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.objtype) = PG_OBJECT_TRIGGER; ;}
-    break;
-
-  case 389:
-#line 142 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].typnam)); ;}
-    break;
-
-  case 390:
-#line 143 "third_party/libpg_query/grammar/statements/drop.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].typnam)); ;}
-    break;
-
-  case 391:
-#line 9 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt);
-				n->relpersistence=(yyvsp[(2) - (8)].ival);
-				n->name = (yyvsp[(4) - (8)].range);
-				n->params = (yyvsp[(5) - (8)].list);
-				n->function = NULL;
-				n->query = (yyvsp[(8) - (8)].node);
-				(yyval.node) = (PGNode *)n;
-				
-			;}
-    break;
-
-  case 392:
-#line 21 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt);
-				n->relpersistence=(yyvsp[(2) - (7)].ival);
-				n->name = (yyvsp[(4) - (7)].range);
-				n->params = (yyvsp[(5) - (7)].list);
-				n->function = (yyvsp[(7) - (7)].node);
-				n->query = NULL;
-				(yyval.node) = (PGNode *)n;
-                         ;}
-    break;
-
-  case 395:
-#line 42 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				(yyval.list) = NIL;
-			;}
-    break;
-
-  case 396:
-#line 46 "third_party/libpg_query/grammar/statements/create_function.y"
-    {
-				(yyval.list) = (yyvsp[(2) - (3)].list);
-			;}
-    break;
-
-  case 397:
-#line 12 "third_party/libpg_query/grammar/statements/update.y"
-    {
-					PGUpdateStmt *n = makeNode(PGUpdateStmt);
-					n->relation = (yyvsp[(3) - (8)].range);
-					n->targetList = (yyvsp[(5) - (8)].list);
-					n->fromClause = (yyvsp[(6) - (8)].list);
-					n->whereClause = (yyvsp[(7) - (8)].node);
-					n->returningList = (yyvsp[(8) - (8)].list);
-					n->withClause = (yyvsp[(1) - (8)].with);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 398:
-#line 3 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					PGCopyStmt *n = makeNode(PGCopyStmt);
-					n->relation = (yyvsp[(3) - (11)].range);
-					n->query = NULL;
-					n->attlist = (yyvsp[(4) - (11)].list);
-					n->is_from = (yyvsp[(6) - (11)].boolean);
-					n->is_program = (yyvsp[(7) - (11)].boolean);
-					n->filename = (yyvsp[(8) - (11)].str);
-
-					if (n->is_program && n->filename == NULL)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("STDIN/STDOUT not allowed with PROGRAM"),
-								 parser_errposition((yylsp[(8) - (11)]))));
-
-					n->options = NIL;
-					/* Concatenate user-supplied flags */
-					if ((yyvsp[(2) - (11)].defelt))
-						n->options = lappend(n->options, (yyvsp[(2) - (11)].defelt));
-					if ((yyvsp[(5) - (11)].defelt))
-						n->options = lappend(n->options, (yyvsp[(5) - (11)].defelt));
-					if ((yyvsp[(9) - (11)].defelt))
-						n->options = lappend(n->options, (yyvsp[(9) - (11)].defelt));
-					if ((yyvsp[(11) - (11)].list))
-						n->options = list_concat(n->options, (yyvsp[(11) - (11)].list));
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 399:
-#line 31 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					PGCopyStmt *n = makeNode(PGCopyStmt);
-					n->relation = NULL;
-					n->query = (yyvsp[(3) - (9)].node);
-					n->attlist = NIL;
-					n->is_from = false;
-					n->is_program = (yyvsp[(6) - (9)].boolean);
-					n->filename = (yyvsp[(7) - (9)].str);
-					n->options = (yyvsp[(9) - (9)].list);
-
-					if (n->is_program && n->filename == NULL)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("STDIN/STDOUT not allowed with PROGRAM"),
-								 parser_errposition((yylsp[(5) - (9)]))));
-
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 400:
-#line 53 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 401:
-#line 54 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 402:
-#line 60 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 403:
-#line 63 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.defelt) = NULL; ;}
-    break;
-
-  case 404:
-#line 69 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 405:
-#line 73 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 406:
-#line 80 "third_party/libpg_query/grammar/statements/copy.y"
-    {;}
-    break;
-
-  case 407:
-#line 81 "third_party/libpg_query/grammar/statements/copy.y"
-    {;}
-    break;
-
-  case 408:
-#line 85 "third_party/libpg_query/grammar/statements/copy.y"
-    {;}
-    break;
-
-  case 409:
-#line 86 "third_party/libpg_query/grammar/statements/copy.y"
-    {;}
-    break;
-
-  case 410:
-#line 91 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 411:
-#line 92 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 412:
-#line 96 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 413:
-#line 97 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 414:
-#line 102 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 415:
-#line 103 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;}
-    break;
-
-  case 416:
-#line 104 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) makeNode(PGAStar); ;}
-    break;
-
-  case 417:
-#line 105 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 418:
-#line 106 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 419:
-#line 112 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 420:
-#line 120 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 421:
-#line 123 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.defelt) = NULL; ;}
-    break;
-
-  case 422:
-#line 128 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;}
-    break;
-
-  case 423:
-#line 129 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 424:
-#line 135 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 425:
-#line 138 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.defelt) = NULL; ;}
-    break;
-
-  case 426:
-#line 144 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("format", (PGNode *)makeString("binary"), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 427:
-#line 148 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("oids", (PGNode *)makeInteger(true), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 428:
-#line 152 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("freeze", (PGNode *)makeInteger(true), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 429:
-#line 156 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 430:
-#line 160 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("null", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 431:
-#line 164 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("format", (PGNode *)makeString("csv"), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 432:
-#line 168 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("header", (PGNode *)makeInteger(true), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 433:
-#line 172 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("quote", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 434:
-#line 176 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("escape", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 435:
-#line 180 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("force_quote", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 436:
-#line 184 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("force_quote", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 437:
-#line 188 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("force_not_null", (PGNode *)(yyvsp[(4) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 438:
-#line 192 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("force_null", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 439:
-#line 196 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.defelt) = makeDefElem("encoding", (PGNode *)makeString((yyvsp[(2) - (2)].str)), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 440:
-#line 203 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 441:
-#line 209 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 442:
-#line 210 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 443:
-#line 211 "third_party/libpg_query/grammar/statements/copy.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 444:
-#line 217 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].defelt));
-				;}
-    break;
-
-  case 445:
-#line 221 "third_party/libpg_query/grammar/statements/copy.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt));
-				;}
-    break;
-
-  case 448:
-#line 52 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (3)].node); ;}
-    break;
-
-  case 449:
-#line 53 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (3)].node); ;}
-    break;
-
-  case 450:
-#line 68 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 451:
-#line 70 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list), NIL,
-										NULL, NULL, NULL,
-										yyscanner);
-					(yyval.node) = (yyvsp[(1) - (2)].node);
-				;}
-    break;
-
-  case 452:
-#line 77 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(3) - (4)].list),
-										(PGNode*) list_nth((yyvsp[(4) - (4)].list), 0), (PGNode*) list_nth((yyvsp[(4) - (4)].list), 1),
-										NULL,
-										yyscanner);
-					(yyval.node) = (yyvsp[(1) - (4)].node);
-				;}
-    break;
-
-  case 453:
-#line 85 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(4) - (4)].list),
-										(PGNode*) list_nth((yyvsp[(3) - (4)].list), 0), (PGNode*) list_nth((yyvsp[(3) - (4)].list), 1),
-										NULL,
-										yyscanner);
-					(yyval.node) = (yyvsp[(1) - (4)].node);
-				;}
-    break;
-
-  case 454:
-#line 93 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (2)].node), NULL, NIL,
-										NULL, NULL,
-										(yyvsp[(1) - (2)].with),
-										yyscanner);
-					(yyval.node) = (yyvsp[(2) - (2)].node);
-				;}
-    break;
-
-  case 455:
-#line 101 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].list), NIL,
-										NULL, NULL,
-										(yyvsp[(1) - (3)].with),
-										yyscanner);
-					(yyval.node) = (yyvsp[(2) - (3)].node);
-				;}
-    break;
-
-  case 456:
-#line 109 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(4) - (5)].list),
-										(PGNode*) list_nth((yyvsp[(5) - (5)].list), 0), (PGNode*) list_nth((yyvsp[(5) - (5)].list), 1),
-										(yyvsp[(1) - (5)].with),
-										yyscanner);
-					(yyval.node) = (yyvsp[(2) - (5)].node);
-				;}
-    break;
-
-  case 457:
-#line 117 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list),
-										(PGNode*) list_nth((yyvsp[(4) - (5)].list), 0), (PGNode*) list_nth((yyvsp[(4) - (5)].list), 1),
-										(yyvsp[(1) - (5)].with),
-										yyscanner);
-					(yyval.node) = (yyvsp[(2) - (5)].node);
-				;}
-    break;
-
-  case 458:
-#line 127 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 459:
-#line 128 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 460:
-#line 158 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-					n->targetList = (yyvsp[(3) - (11)].list);
-					n->intoClause = (yyvsp[(4) - (11)].into);
-					n->fromClause = (yyvsp[(5) - (11)].list);
-					n->whereClause = (yyvsp[(6) - (11)].node);
-					n->groupClause = (yyvsp[(7) - (11)].list);
-					n->havingClause = (yyvsp[(8) - (11)].node);
-					n->windowClause = (yyvsp[(9) - (11)].list);
-					n->qualifyClause = (yyvsp[(10) - (11)].node);
-					n->sampleOptions = (yyvsp[(11) - (11)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 461:
-#line 174 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-					n->distinctClause = (yyvsp[(2) - (11)].list);
-					n->targetList = (yyvsp[(3) - (11)].list);
-					n->intoClause = (yyvsp[(4) - (11)].into);
-					n->fromClause = (yyvsp[(5) - (11)].list);
-					n->whereClause = (yyvsp[(6) - (11)].node);
-					n->groupClause = (yyvsp[(7) - (11)].list);
-					n->havingClause = (yyvsp[(8) - (11)].node);
-					n->windowClause = (yyvsp[(9) - (11)].list);
-					n->qualifyClause = (yyvsp[(10) - (11)].node);
-					n->sampleOptions = (yyvsp[(11) - (11)].node);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 462:
-#line 188 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 463:
-#line 190 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* same as SELECT * FROM relation_expr */
-					PGColumnRef *cr = makeNode(PGColumnRef);
-					PGResTarget *rt = makeNode(PGResTarget);
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-
-					cr->fields = list_make1(makeNode(PGAStar));
-					cr->location = -1;
-
-					rt->name = NULL;
-					rt->indirection = NIL;
-					rt->val = (PGNode *)cr;
-					rt->location = -1;
-
-					n->targetList = list_make1(rt);
-					n->fromClause = list_make1((yyvsp[(2) - (2)].range));
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 464:
-#line 209 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSetOp(PG_SETOP_UNION, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
-				;}
-    break;
-
-  case 465:
-#line 213 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSetOp(PG_SETOP_INTERSECT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
-				;}
-    break;
-
-  case 466:
-#line 217 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSetOp(PG_SETOP_EXCEPT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
-				;}
-    break;
-
-  case 467:
-#line 234 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.with) = makeNode(PGWithClause);
-				(yyval.with)->ctes = (yyvsp[(2) - (2)].list);
-				(yyval.with)->recursive = false;
-				(yyval.with)->location = (yylsp[(1) - (2)]);
-			;}
-    break;
-
-  case 468:
-#line 241 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.with) = makeNode(PGWithClause);
-				(yyval.with)->ctes = (yyvsp[(2) - (2)].list);
-				(yyval.with)->recursive = false;
-				(yyval.with)->location = (yylsp[(1) - (2)]);
-			;}
-    break;
-
-  case 469:
-#line 248 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				(yyval.with) = makeNode(PGWithClause);
-				(yyval.with)->ctes = (yyvsp[(3) - (3)].list);
-				(yyval.with)->recursive = true;
-				(yyval.with)->location = (yylsp[(1) - (3)]);
-			;}
-    break;
-
-  case 470:
-#line 257 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 471:
-#line 258 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 472:
-#line 262 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGCommonTableExpr *n = makeNode(PGCommonTableExpr);
-				n->ctename = (yyvsp[(1) - (6)].str);
-				n->aliascolnames = (yyvsp[(2) - (6)].list);
-				n->ctequery = (yyvsp[(5) - (6)].node);
-				n->location = (yylsp[(1) - (6)]);
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 473:
-#line 274 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.into) = makeNode(PGIntoClause);
-					(yyval.into)->rel = (yyvsp[(2) - (2)].range);
-					(yyval.into)->colNames = NIL;
-					(yyval.into)->options = NIL;
-					(yyval.into)->onCommit = PG_ONCOMMIT_NOOP;
-					(yyval.into)->viewQuery = NULL;
-					(yyval.into)->skipData = false;
-				;}
-    break;
-
-  case 474:
-#line 284 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.into) = NULL; ;}
-    break;
-
-  case 475:
-#line 293 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(3) - (3)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 476:
-#line 298 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(3) - (3)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 477:
-#line 303 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(4) - (4)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 478:
-#line 308 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(4) - (4)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 479:
-#line 313 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					ereport(PGWARNING,
-							(errmsg("GLOBAL is deprecated in temporary table creation"),
-							 parser_errposition((yylsp[(1) - (4)]))));
-					(yyval.range) = (yyvsp[(4) - (4)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 480:
-#line 321 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					ereport(PGWARNING,
-							(errmsg("GLOBAL is deprecated in temporary table creation"),
-							 parser_errposition((yylsp[(1) - (4)]))));
-					(yyval.range) = (yyvsp[(4) - (4)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_TEMP;
-				;}
-    break;
-
-  case 481:
-#line 329 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(3) - (3)].range);
-					(yyval.range)->relpersistence = PG_RELPERSISTENCE_UNLOGGED;
-				;}
-    break;
-
-  case 482:
-#line 334 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(2) - (2)].range);
-					(yyval.range)->relpersistence = RELPERSISTENCE_PERMANENT;
-				;}
-    break;
-
-  case 483:
-#line 339 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = (yyvsp[(1) - (1)].range);
-					(yyval.range)->relpersistence = RELPERSISTENCE_PERMANENT;
-				;}
-    break;
-
-  case 484:
-#line 345 "third_party/libpg_query/grammar/statements/select.y"
-    {;}
-    break;
-
-  case 485:
-#line 346 "third_party/libpg_query/grammar/statements/select.y"
-    {;}
-    break;
-
-  case 486:
-#line 350 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 487:
-#line 351 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 488:
-#line 352 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 489:
-#line 359 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(NIL); ;}
-    break;
-
-  case 490:
-#line 360 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(4) - (5)].list); ;}
-    break;
-
-  case 491:
-#line 364 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL;;}
-    break;
-
-  case 492:
-#line 365 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 493:
-#line 369 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true;;}
-    break;
-
-  case 494:
-#line 370 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false;;}
-    break;
-
-  case 495:
-#line 371 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 496:
-#line 375 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list);;}
-    break;
-
-  case 497:
-#line 376 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 498:
-#line 380 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (3)].list); ;}
-    break;
-
-  case 499:
-#line 382 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSortBy *sort = makeNode(PGSortBy);
-					sort->node = (PGNode *) makeNode(PGAStar);
-					sort->sortby_dir = (yyvsp[(4) - (5)].sortorder);
-					sort->sortby_nulls = (yyvsp[(5) - (5)].nullorder);
-					sort->useOp = NIL;
-					sort->location = -1;		/* no operator */
-					(yyval.list) = list_make1(sort);
-				;}
-    break;
-
-  case 500:
-#line 392 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSortBy *sort = makeNode(PGSortBy);
-					sort->node = (PGNode *) makeNode(PGAStar);
-					sort->sortby_dir = (yyvsp[(4) - (5)].sortorder);
-					sort->sortby_nulls = (yyvsp[(5) - (5)].nullorder);
-					sort->useOp = NIL;
-					sort->location = -1;		/* no operator */
-					(yyval.list) = list_make1(sort);
-				;}
-    break;
-
-  case 501:
-#line 404 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].sortby)); ;}
-    break;
-
-  case 502:
-#line 405 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].sortby)); ;}
-    break;
-
-  case 503:
-#line 409 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.sortby) = makeNode(PGSortBy);
-					(yyval.sortby)->node = (yyvsp[(1) - (4)].node);
-					(yyval.sortby)->sortby_dir = SORTBY_USING;
-					(yyval.sortby)->sortby_nulls = (yyvsp[(4) - (4)].nullorder);
-					(yyval.sortby)->useOp = (yyvsp[(3) - (4)].list);
-					(yyval.sortby)->location = (yylsp[(3) - (4)]);
-				;}
-    break;
-
-  case 504:
-#line 418 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.sortby) = makeNode(PGSortBy);
-					(yyval.sortby)->node = (yyvsp[(1) - (3)].node);
-					(yyval.sortby)->sortby_dir = (yyvsp[(2) - (3)].sortorder);
-					(yyval.sortby)->sortby_nulls = (yyvsp[(3) - (3)].nullorder);
-					(yyval.sortby)->useOp = NIL;
-					(yyval.sortby)->location = -1;		/* no operator */
-				;}
-    break;
-
-  case 505:
-#line 428 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.sortorder) = PG_SORTBY_ASC; ;}
-    break;
-
-  case 506:
-#line 429 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.sortorder) = PG_SORTBY_DESC; ;}
-    break;
-
-  case 507:
-#line 430 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.sortorder) = PG_SORTBY_DEFAULT; ;}
-    break;
-
-  case 508:
-#line 433 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.nullorder) = PG_SORTBY_NULLS_FIRST; ;}
-    break;
-
-  case 509:
-#line 434 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.nullorder) = PG_SORTBY_NULLS_LAST; ;}
-    break;
-
-  case 510:
-#line 435 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.nullorder) = PG_SORTBY_NULLS_DEFAULT; ;}
-    break;
-
-  case 511:
-#line 439 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].node)); ;}
-    break;
-
-  case 512:
-#line 440 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 513:
-#line 441 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2(NULL, (yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 514:
-#line 442 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (1)].node), NULL); ;}
-    break;
-
-  case 515:
-#line 446 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 516:
-#line 447 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2(NULL,NULL); ;}
-    break;
-
-  case 517:
-#line 452 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 518:
-#line 454 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* Disabled because it was too confusing, bjm 2002-02-18 */
-					ereport(ERROR,
-							(errcode(PG_ERRCODE_SYNTAX_ERROR),
-							 errmsg("LIMIT #,# syntax is not supported"),
-							 errhint("Use separate LIMIT and OFFSET clauses."),
-							 parser_errposition((yylsp[(1) - (4)]))));
-				;}
-    break;
-
-  case 519:
-#line 470 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(3) - (5)].node); ;}
-    break;
-
-  case 520:
-#line 472 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeIntConst(1, -1); ;}
-    break;
-
-  case 521:
-#line 477 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 522:
-#line 480 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (3)].node); ;}
-    break;
-
-  case 523:
-#line 488 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize(makeFloat((yyvsp[(1) - (2)].str)), true);
-		;}
-    break;
-
-  case 524:
-#line 492 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), true);
-		;}
-    break;
-
-  case 525:
-#line 496 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize(makeFloat((yyvsp[(1) - (2)].str)), true);
-		;}
-    break;
-
-  case 526:
-#line 500 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), true);
-		;}
-    break;
-
-  case 527:
-#line 504 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (1)].ival)), false);
-		;}
-    break;
-
-  case 528:
-#line 508 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleSize(makeInteger((yyvsp[(1) - (2)].ival)), false);
-		;}
-    break;
-
-  case 529:
-#line 515 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (yyvsp[(3) - (3)].node);
-				;}
-    break;
-
-  case 530:
-#line 519 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 531:
-#line 526 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 532:
-#line 527 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 533:
-#line 532 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSampleOptions((yyvsp[(3) - (5)].node), (yyvsp[(1) - (5)].str), (yyvsp[(5) - (5)].ival), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 534:
-#line 536 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleOptions((yyvsp[(1) - (1)].node), NULL, -1, (yylsp[(1) - (1)]));
-		;}
-    break;
-
-  case 535:
-#line 540 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleOptions((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].str), -1, (yylsp[(1) - (4)]));
-		;}
-    break;
-
-  case 536:
-#line 544 "third_party/libpg_query/grammar/statements/select.y"
-    {
-			(yyval.node) = makeSampleOptions((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].str), (yyvsp[(5) - (6)].ival), (yylsp[(1) - (6)]));
-		;}
-    break;
-
-  case 537:
-#line 551 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (yyvsp[(2) - (2)].node);
-				;}
-    break;
-
-  case 538:
-#line 557 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 539:
-#line 558 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 540:
-#line 563 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = (yyvsp[(3) - (4)].ival); ;}
-    break;
-
-  case 541:
-#line 564 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = -1; ;}
-    break;
-
-  case 542:
-#line 568 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 543:
-#line 570 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* LIMIT ALL is represented as a NULL constant */
-					(yyval.node) = makeNullAConst((yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 544:
-#line 575 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeLimitPercent((yyvsp[(1) - (2)].node)); ;}
-    break;
-
-  case 545:
-#line 577 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeLimitPercent(makeFloatConst((yyvsp[(1) - (2)].str),(yylsp[(1) - (2)]))); ;}
-    break;
-
-  case 546:
-#line 579 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeLimitPercent(makeIntConst((yyvsp[(1) - (2)].ival),(yylsp[(1) - (2)]))); ;}
-    break;
-
-  case 547:
-#line 583 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 548:
-#line 603 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 549:
-#line 605 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 550:
-#line 607 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 551:
-#line 611 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival),(yylsp[(1) - (1)])); ;}
-    break;
-
-  case 552:
-#line 612 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str),(yylsp[(1) - (1)])); ;}
-    break;
-
-  case 553:
-#line 616 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 554:
-#line 617 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 555:
-#line 620 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 556:
-#line 621 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = 0; ;}
-    break;
-
-  case 557:
-#line 646 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (3)].list); ;}
-    break;
-
-  case 558:
-#line 648 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNode *node = (PGNode *) makeGroupingSet(GROUPING_SET_ALL, NIL, (yylsp[(3) - (3)]));
-					(yyval.list) = list_make1(node);
-				;}
-    break;
-
-  case 559:
-#line 653 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNode *node = (PGNode *) makeGroupingSet(GROUPING_SET_ALL, NIL, (yylsp[(3) - (3)]));
-					(yyval.list) = list_make1(node);
-				;}
-    break;
-
-  case 560:
-#line 657 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 561:
-#line 661 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 562:
-#line 662 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 563:
-#line 666 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 564:
-#line 667 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 565:
-#line 671 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 566:
-#line 672 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 567:
-#line 673 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 568:
-#line 674 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 569:
-#line 675 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 570:
-#line 680 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_EMPTY, NIL, (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 571:
-#line 693 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_ROLLUP, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 572:
-#line 700 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_CUBE, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 573:
-#line 707 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_SETS, (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 574:
-#line 713 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 575:
-#line 714 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 576:
-#line 718 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 577:
-#line 719 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 578:
-#line 723 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 579:
-#line 724 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 580:
-#line 728 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 581:
-#line 729 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 582:
-#line 733 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 583:
-#line 734 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 584:
-#line 738 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 585:
-#line 739 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 586:
-#line 744 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGLockingClause *n = makeNode(PGLockingClause);
-					n->lockedRels = (yyvsp[(2) - (3)].list);
-					n->strength = (yyvsp[(1) - (3)].lockstrength);
-					n->waitPolicy = (yyvsp[(3) - (3)].lockwaitpolicy);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 587:
-#line 754 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockstrength) = LCS_FORUPDATE; ;}
-    break;
-
-  case 588:
-#line 755 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockstrength) = PG_LCS_FORNOKEYUPDATE; ;}
-    break;
-
-  case 589:
-#line 756 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockstrength) = PG_LCS_FORSHARE; ;}
-    break;
-
-  case 590:
-#line 757 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockstrength) = PG_LCS_FORKEYSHARE; ;}
-    break;
-
-  case 591:
-#line 761 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 592:
-#line 762 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 593:
-#line 767 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockwaitpolicy) = LockWaitError; ;}
-    break;
-
-  case 594:
-#line 768 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockwaitpolicy) = PGLockWaitSkip; ;}
-    break;
-
-  case 595:
-#line 769 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.lockwaitpolicy) = PGLockWaitBlock; ;}
-    break;
-
-  case 596:
-#line 779 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = makeNode(PGSelectStmt);
-					n->valuesLists = list_make1((yyvsp[(3) - (4)].list));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 597:
-#line 785 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSelectStmt *n = (PGSelectStmt *) (yyvsp[(1) - (5)].node);
-					n->valuesLists = lappend(n->valuesLists, (yyvsp[(4) - (5)].list));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 598:
-#line 793 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 599:
-#line 794 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (2)].node); ;}
-    break;
-
-  case 600:
-#line 807 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 601:
-#line 808 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 602:
-#line 812 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 603:
-#line 813 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 604:
-#line 817 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 605:
-#line 818 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 606:
-#line 825 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyvsp[(1) - (3)].range)->alias = (yyvsp[(2) - (3)].alias);
-					(yyvsp[(1) - (3)].range)->sample = (yyvsp[(3) - (3)].node);
-					(yyval.node) = (PGNode *) (yyvsp[(1) - (3)].range);
-				;}
-    break;
-
-  case 607:
-#line 831 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(1) - (3)].node);
-					n->alias = (PGAlias*) linitial((yyvsp[(2) - (3)].list));
-					n->coldeflist = (PGList*) lsecond((yyvsp[(2) - (3)].list));
-					n->sample = (yyvsp[(3) - (3)].node);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 608:
-#line 839 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(2) - (3)].node);
-					n->lateral = true;
-					n->alias = (PGAlias*) linitial((yyvsp[(3) - (3)].list));
-					n->coldeflist = (PGList*) lsecond((yyvsp[(3) - (3)].list));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 609:
-#line 847 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeSubselect *n = makeNode(PGRangeSubselect);
-					n->lateral = false;
-					n->subquery = (yyvsp[(1) - (3)].node);
-					n->alias = (yyvsp[(2) - (3)].alias);
-					n->sample = (yyvsp[(3) - (3)].node);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 610:
-#line 856 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeSubselect *n = makeNode(PGRangeSubselect);
-					n->lateral = true;
-					n->subquery = (yyvsp[(2) - (3)].node);
-					n->alias = (yyvsp[(3) - (3)].alias);
-					n->sample = NULL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 611:
-#line 865 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) (yyvsp[(1) - (1)].jexpr);
-				;}
-    break;
-
-  case 612:
-#line 869 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyvsp[(2) - (4)].jexpr)->alias = (yyvsp[(4) - (4)].alias);
-					(yyval.node) = (PGNode *) (yyvsp[(2) - (4)].jexpr);
-				;}
-    break;
-
-  case 613:
-#line 895 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.jexpr) = (yyvsp[(2) - (3)].jexpr);
-				;}
-    break;
-
-  case 614:
-#line 899 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* CROSS JOIN is same as unqualified inner join */
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = PG_JOIN_INNER;
-					n->isNatural = false;
-					n->larg = (yyvsp[(1) - (4)].node);
-					n->rarg = (yyvsp[(4) - (4)].node);
-					n->usingClause = NIL;
-					n->quals = NULL;
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 615:
-#line 912 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = (yyvsp[(2) - (5)].jtype);
-					n->isNatural = false;
-					n->larg = (yyvsp[(1) - (5)].node);
-					n->rarg = (yyvsp[(4) - (5)].node);
-					if ((yyvsp[(5) - (5)].node) != NULL && IsA((yyvsp[(5) - (5)].node), PGList))
-						n->usingClause = (PGList *) (yyvsp[(5) - (5)].node); /* USING clause */
-					else
-						n->quals = (yyvsp[(5) - (5)].node); /* ON clause */
-					n->location = (yylsp[(2) - (5)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 616:
-#line 926 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* letting join_type reduce to empty doesn't work */
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = PG_JOIN_INNER;
-					n->isNatural = false;
-					n->larg = (yyvsp[(1) - (4)].node);
-					n->rarg = (yyvsp[(3) - (4)].node);
-					if ((yyvsp[(4) - (4)].node) != NULL && IsA((yyvsp[(4) - (4)].node), PGList))
-						n->usingClause = (PGList *) (yyvsp[(4) - (4)].node); /* USING clause */
-					else
-						n->quals = (yyvsp[(4) - (4)].node); /* ON clause */
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 617:
-#line 941 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = (yyvsp[(3) - (5)].jtype);
-					n->isNatural = true;
-					n->larg = (yyvsp[(1) - (5)].node);
-					n->rarg = (yyvsp[(5) - (5)].node);
-					n->usingClause = NIL; /* figure out which columns later... */
-					n->quals = NULL; /* fill later */
-					n->location = (yylsp[(2) - (5)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 618:
-#line 953 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* letting join_type reduce to empty doesn't work */
-					PGJoinExpr *n = makeNode(PGJoinExpr);
-					n->jointype = PG_JOIN_INNER;
-					n->isNatural = true;
-					n->larg = (yyvsp[(1) - (4)].node);
-					n->rarg = (yyvsp[(4) - (4)].node);
-					n->usingClause = NIL; /* figure out which columns later... */
-					n->quals = NULL; /* fill later */
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.jexpr) = n;
-				;}
-    break;
-
-  case 619:
-#line 969 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.alias) = makeNode(PGAlias);
-					(yyval.alias)->aliasname = (yyvsp[(2) - (5)].str);
-					(yyval.alias)->colnames = (yyvsp[(4) - (5)].list);
-				;}
-    break;
-
-  case 620:
-#line 975 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.alias) = makeNode(PGAlias);
-					(yyval.alias)->aliasname = (yyvsp[(2) - (2)].str);
-				;}
-    break;
-
-  case 621:
-#line 980 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.alias) = makeNode(PGAlias);
-					(yyval.alias)->aliasname = (yyvsp[(1) - (4)].str);
-					(yyval.alias)->colnames = (yyvsp[(3) - (4)].list);
-				;}
-    break;
-
-  case 622:
-#line 986 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.alias) = makeNode(PGAlias);
-					(yyval.alias)->aliasname = (yyvsp[(1) - (1)].str);
-				;}
-    break;
-
-  case 623:
-#line 992 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.alias) = (yyvsp[(1) - (1)].alias); ;}
-    break;
-
-  case 624:
-#line 993 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.alias) = NULL; ;}
-    break;
-
-  case 625:
-#line 1002 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2((yyvsp[(1) - (1)].alias), NIL);
-				;}
-    break;
-
-  case 626:
-#line 1006 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2(NULL, (yyvsp[(3) - (4)].list));
-				;}
-    break;
-
-  case 627:
-#line 1010 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAlias *a = makeNode(PGAlias);
-					a->aliasname = (yyvsp[(2) - (5)].str);
-					(yyval.list) = list_make2(a, (yyvsp[(4) - (5)].list));
-				;}
-    break;
-
-  case 628:
-#line 1016 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAlias *a = makeNode(PGAlias);
-					a->aliasname = (yyvsp[(1) - (4)].str);
-					(yyval.list) = list_make2(a, (yyvsp[(3) - (4)].list));
-				;}
-    break;
-
-  case 629:
-#line 1022 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2(NULL, NIL);
-				;}
-    break;
-
-  case 630:
-#line 1027 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_FULL; ;}
-    break;
-
-  case 631:
-#line 1028 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_LEFT; ;}
-    break;
-
-  case 632:
-#line 1029 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_RIGHT; ;}
-    break;
-
-  case 633:
-#line 1030 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.jtype) = PG_JOIN_INNER; ;}
-    break;
-
-  case 634:
-#line 1034 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 635:
-#line 1035 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 636:
-#line 1047 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 637:
-#line 1048 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 638:
-#line 1054 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* inheritance query, implicitly */
-					(yyval.range) = (yyvsp[(1) - (1)].range);
-					(yyval.range)->inh = true;
-					(yyval.range)->alias = NULL;
-				;}
-    break;
-
-  case 639:
-#line 1061 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* inheritance query, explicitly */
-					(yyval.range) = (yyvsp[(1) - (2)].range);
-					(yyval.range)->inh = true;
-					(yyval.range)->alias = NULL;
-				;}
-    break;
-
-  case 640:
-#line 1068 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* no inheritance */
-					(yyval.range) = (yyvsp[(2) - (2)].range);
-					(yyval.range)->inh = false;
-					(yyval.range)->alias = NULL;
-				;}
-    break;
-
-  case 641:
-#line 1075 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* no inheritance, SQL99-style syntax */
-					(yyval.range) = (yyvsp[(3) - (4)].range);
-					(yyval.range)->inh = false;
-					(yyval.range)->alias = NULL;
-				;}
-    break;
-
-  case 642:
-#line 1107 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeFunction *n = makeNode(PGRangeFunction);
-					n->lateral = false;
-					n->ordinality = (yyvsp[(2) - (2)].boolean);
-					n->is_rowsfrom = false;
-					n->functions = list_make1(list_make2((yyvsp[(1) - (2)].node), NIL));
-					n->sample = NULL;
-					/* alias and coldeflist are set by table_ref production */
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 643:
-#line 1118 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGRangeFunction *n = makeNode(PGRangeFunction);
-					n->lateral = false;
-					n->ordinality = (yyvsp[(6) - (6)].boolean);
-					n->is_rowsfrom = true;
-					n->functions = (yyvsp[(4) - (6)].list);
-					n->sample = NULL;
-					/* alias and coldeflist are set by table_ref production */
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 644:
-#line 1131 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list)); ;}
-    break;
-
-  case 645:
-#line 1135 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 646:
-#line 1136 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 647:
-#line 1139 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 648:
-#line 1140 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 649:
-#line 1143 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 650:
-#line 1144 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 651:
-#line 1149 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 652:
-#line 1150 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 653:
-#line 1156 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 654:
-#line 1160 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 655:
-#line 1166 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGColumnDef *n = makeNode(PGColumnDef);
-					n->colname = (yyvsp[(1) - (3)].str);
-					n->typeName = (yyvsp[(2) - (3)].typnam);
-					n->inhcount = 0;
-					n->is_local = true;
-					n->is_not_null = false;
-					n->is_from_type = false;
-					n->storage = 0;
-					n->raw_default = NULL;
-					n->cooked_default = NULL;
-					n->collClause = (PGCollateClause *) (yyvsp[(3) - (3)].node);
-					n->collOid = InvalidOid;
-					n->constraints = NIL;
-					n->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 656:
-#line 1187 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCollateClause *n = makeNode(PGCollateClause);
-					n->arg = NULL;
-					n->collname = (yyvsp[(2) - (2)].list);
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 657:
-#line 1194 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 658:
-#line 1207 "third_party/libpg_query/grammar/statements/select.y"
-    {
-             (yyval.list) = list_make1(list_make2(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].typnam)));
-            ;}
-    break;
-
-  case 659:
-#line 1210 "third_party/libpg_query/grammar/statements/select.y"
-    {
-             (yyval.list) = lappend((yyvsp[(1) - (4)].list), list_make2(makeString((yyvsp[(3) - (4)].str)), (yyvsp[(4) - (4)].typnam)));
-            ;}
-    break;
-
-  case 662:
-#line 1217 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 663:
-#line 1218 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = NULL; ;}
-    break;
-
-  case 664:
-#line 1221 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (2)].typnam);
-					(yyval.typnam)->arrayBounds = (yyvsp[(2) - (2)].list);
-				;}
-    break;
-
-  case 665:
-#line 1226 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(2) - (3)].typnam);
-					(yyval.typnam)->arrayBounds = (yyvsp[(3) - (3)].list);
-					(yyval.typnam)->setof = true;
-				;}
-    break;
-
-  case 666:
-#line 1233 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (5)].typnam);
-					(yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[(4) - (5)].ival)));
-				;}
-    break;
-
-  case 667:
-#line 1238 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(2) - (6)].typnam);
-					(yyval.typnam)->arrayBounds = list_make1(makeInteger((yyvsp[(5) - (6)].ival)));
-					(yyval.typnam)->setof = true;
-				;}
-    break;
-
-  case 668:
-#line 1244 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (2)].typnam);
-					(yyval.typnam)->arrayBounds = list_make1(makeInteger(-1));
-				;}
-    break;
-
-  case 669:
-#line 1249 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(2) - (3)].typnam);
-					(yyval.typnam)->arrayBounds = list_make1(makeInteger(-1));
-					(yyval.typnam)->setof = true;
-				;}
-    break;
-
-  case 670:
-#line 1254 "third_party/libpg_query/grammar/statements/select.y"
-    {
-               (yyval.typnam) = SystemTypeName("struct");
-               (yyval.typnam)->arrayBounds = (yyvsp[(5) - (5)].list);
-               (yyval.typnam)->typmods = (yyvsp[(3) - (5)].list);
-               (yyval.typnam)->location = (yylsp[(1) - (5)]);
-               ;}
-    break;
-
-  case 671:
-#line 1260 "third_party/libpg_query/grammar/statements/select.y"
-    {
-               (yyval.typnam) = SystemTypeName("map");
-               (yyval.typnam)->arrayBounds = (yyvsp[(5) - (5)].list);
-               (yyval.typnam)->typmods = (yyvsp[(3) - (5)].list);
-               (yyval.typnam)->location = (yylsp[(1) - (5)]);
-			;}
-    break;
-
-  case 672:
-#line 1270 "third_party/libpg_query/grammar/statements/select.y"
-    {  (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeInteger(-1)); ;}
-    break;
-
-  case 673:
-#line 1272 "third_party/libpg_query/grammar/statements/select.y"
-    {  (yyval.list) = lappend((yyvsp[(1) - (4)].list), makeInteger((yyvsp[(3) - (4)].ival))); ;}
-    break;
-
-  case 674:
-#line 1274 "third_party/libpg_query/grammar/statements/select.y"
-    {  (yyval.list) = NIL; ;}
-    break;
-
-  case 675:
-#line 1278 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 676:
-#line 1279 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 677:
-#line 1280 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 678:
-#line 1281 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 679:
-#line 1282 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 680:
-#line 1284 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (2)].typnam);
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-				;}
-    break;
-
-  case 681:
-#line 1289 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (4)].typnam);
-					(yyval.typnam)->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
-											 makeIntConst((yyvsp[(3) - (4)].ival), (yylsp[(3) - (4)])));
-				;}
-    break;
-
-  case 682:
-#line 1308 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 683:
-#line 1309 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 684:
-#line 1310 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 685:
-#line 1311 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;}
-    break;
-
-  case 686:
-#line 1323 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = makeTypeName((yyvsp[(1) - (2)].str));
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 687:
-#line 1336 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 688:
-#line 1337 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 689:
-#line 1344 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("int4");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 690:
-#line 1349 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("int4");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 691:
-#line 1354 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("int2");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 692:
-#line 1359 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("int8");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 693:
-#line 1364 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("float4");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 694:
-#line 1369 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(2) - (2)].typnam);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 695:
-#line 1374 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("float8");
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 696:
-#line 1379 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("numeric");
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 697:
-#line 1385 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("numeric");
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 698:
-#line 1391 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("numeric");
-					(yyval.typnam)->typmods = (yyvsp[(2) - (2)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 699:
-#line 1397 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("bool");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 700:
-#line 1404 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * Check FLOAT() precision limits assuming IEEE floating
-					 * types - thomas 1997-09-18
-					 */
-					if ((yyvsp[(2) - (3)].ival) < 1)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_INVALID_PARAMETER_VALUE),
-								 errmsg("precision for type float must be at least 1 bit"),
-								 parser_errposition((yylsp[(2) - (3)]))));
-					else if ((yyvsp[(2) - (3)].ival) <= 24)
-						(yyval.typnam) = SystemTypeName("float4");
-					else if ((yyvsp[(2) - (3)].ival) <= 53)
-						(yyval.typnam) = SystemTypeName("float8");
-					else
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_INVALID_PARAMETER_VALUE),
-								 errmsg("precision for type float must be less than 54 bits"),
-								 parser_errposition((yylsp[(2) - (3)]))));
-				;}
-    break;
-
-  case 701:
-#line 1425 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("float4");
-				;}
-    break;
-
-  case 702:
-#line 1435 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 703:
-#line 1439 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 704:
-#line 1447 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 705:
-#line 1451 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-					(yyval.typnam)->typmods = NIL;
-				;}
-    break;
-
-  case 706:
-#line 1459 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					const char *typname;
-
-					typname = (yyvsp[(2) - (5)].boolean) ? "varbit" : "bit";
-					(yyval.typnam) = SystemTypeName(typname);
-					(yyval.typnam)->typmods = (yyvsp[(4) - (5)].list);
-					(yyval.typnam)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 707:
-#line 1471 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* bit defaults to bit(1), varbit to no limit */
-					if ((yyvsp[(2) - (2)].boolean))
-					{
-						(yyval.typnam) = SystemTypeName("varbit");
-					}
-					else
-					{
-						(yyval.typnam) = SystemTypeName("bit");
-						(yyval.typnam)->typmods = list_make1(makeIntConst(1, -1));
-					}
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 708:
-#line 1492 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 709:
-#line 1496 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 710:
-#line 1502 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-				;}
-    break;
-
-  case 711:
-#line 1506 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* Length was not specified so allow to be unrestricted.
-					 * This handles problems with fixed-length (bpchar) strings
-					 * which in column definitions must default to a length
-					 * of one, but should not be constrained if the length
-					 * was not specified.
-					 */
-					(yyval.typnam) = (yyvsp[(1) - (1)].typnam);
-					(yyval.typnam)->typmods = NIL;
-				;}
-    break;
-
-  case 712:
-#line 1519 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName((yyvsp[(1) - (4)].conststr));
-					(yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (4)].ival), (yylsp[(3) - (4)])));
-					(yyval.typnam)->location = (yylsp[(1) - (4)]);
-				;}
-    break;
-
-  case 713:
-#line 1527 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName((yyvsp[(1) - (1)].conststr));
-					/* char defaults to char(1), varchar to no limit */
-					if (strcmp((yyvsp[(1) - (1)].conststr), "bpchar") == 0)
-						(yyval.typnam)->typmods = list_make1(makeIntConst(1, -1));
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 714:
-#line 1537 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 715:
-#line 1539 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 716:
-#line 1541 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "varchar"; ;}
-    break;
-
-  case 717:
-#line 1543 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 718:
-#line 1545 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 719:
-#line 1547 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;}
-    break;
-
-  case 720:
-#line 1551 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 721:
-#line 1552 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 722:
-#line 1560 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(5) - (5)].boolean))
-						(yyval.typnam) = SystemTypeName("timestamptz");
-					else
-						(yyval.typnam) = SystemTypeName("timestamp");
-					(yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)])));
-					(yyval.typnam)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 723:
-#line 1569 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].boolean))
-						(yyval.typnam) = SystemTypeName("timestamptz");
-					else
-						(yyval.typnam) = SystemTypeName("timestamp");
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 724:
-#line 1577 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(5) - (5)].boolean))
-						(yyval.typnam) = SystemTypeName("timetz");
-					else
-						(yyval.typnam) = SystemTypeName("time");
-					(yyval.typnam)->typmods = list_make1(makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)])));
-					(yyval.typnam)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 725:
-#line 1586 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].boolean))
-						(yyval.typnam) = SystemTypeName("timetz");
-					else
-						(yyval.typnam) = SystemTypeName("time");
-					(yyval.typnam)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 726:
-#line 1597 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.typnam) = SystemTypeName("interval");
-					(yyval.typnam)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 727:
-#line 1604 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 728:
-#line 1605 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 729:
-#line 1606 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 746:
-#line 1635 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 747:
-#line 1637 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MONTH), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 748:
-#line 1639 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 749:
-#line 1641 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 750:
-#line 1643 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 751:
-#line 1645 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 752:
-#line 1647 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLISECOND), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 753:
-#line 1649 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MICROSECOND), (yylsp[(1) - (1)]))); ;}
-    break;
-
-  case 754:
-#line 1651 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR) |
-												 INTERVAL_MASK(MONTH), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 755:
-#line 1656 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) |
-												 INTERVAL_MASK(HOUR), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 756:
-#line 1661 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) |
-												 INTERVAL_MASK(HOUR) |
-												 INTERVAL_MASK(MINUTE), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 757:
-#line 1667 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) |
-												 INTERVAL_MASK(HOUR) |
-												 INTERVAL_MASK(MINUTE) |
-												 INTERVAL_MASK(SECOND), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 758:
-#line 1674 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) |
-												 INTERVAL_MASK(MINUTE), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 759:
-#line 1679 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) |
-												 INTERVAL_MASK(MINUTE) |
-												 INTERVAL_MASK(SECOND), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 760:
-#line 1685 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE) |
-												 INTERVAL_MASK(SECOND), (yylsp[(1) - (3)])));
-				;}
-    break;
-
-  case 761:
-#line 1690 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 762:
-#line 1721 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 763:
-#line 1724 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 764:
-#line 1726 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCollateClause *n = makeNode(PGCollateClause);
-					n->arg = (yyvsp[(1) - (3)].node);
-					n->collname = (yyvsp[(3) - (3)].list);
-					n->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 765:
-#line 1734 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("timezone"),
-											   list_make2((yyvsp[(5) - (5)].node), (yyvsp[(1) - (5)].node)),
-											   (yylsp[(2) - (5)]));
-				;}
-    break;
-
-  case 766:
-#line 1749 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 767:
-#line 1751 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 768:
-#line 1753 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 769:
-#line 1755 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 770:
-#line 1757 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 771:
-#line 1759 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 772:
-#line 1761 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 773:
-#line 1763 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 774:
-#line 1765 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 775:
-#line 1767 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 776:
-#line 1769 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 777:
-#line 1771 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 778:
-#line 1773 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 779:
-#line 1775 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 780:
-#line 1777 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 781:
-#line 1780 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 782:
-#line 1782 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 783:
-#line 1784 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;}
-    break;
-
-  case 784:
-#line 1787 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeAndExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 785:
-#line 1789 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeOrExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 786:
-#line 1791 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 787:
-#line 1793 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 788:
-#line 1796 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_GLOB, "~~~",
-												   (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 789:
-#line 1801 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "~~",
-												   (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 790:
-#line 1806 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("like_escape"),
-											   list_make3((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)),
-											   (yylsp[(2) - (5)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 791:
-#line 1813 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "!~~",
-												   (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)]));
-				;}
-    break;
-
-  case 792:
-#line 1818 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("not_like_escape"),
-											   list_make3((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-											   (yylsp[(2) - (6)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 793:
-#line 1825 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "~~*",
-												   (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 794:
-#line 1830 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("ilike_escape"),
-											   list_make3((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)),
-											   (yylsp[(2) - (5)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 795:
-#line 1837 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "!~~*",
-												   (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)]));
-				;}
-    break;
-
-  case 796:
-#line 1842 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("not_ilike_escape"),
-											   list_make3((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-											   (yylsp[(2) - (6)]));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 797:
-#line 1850 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"),
-											   list_make2((yyvsp[(4) - (4)].node), makeNullAConst(-1)),
-											   (yylsp[(2) - (4)]));
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "~",
-												   (yyvsp[(1) - (4)].node), (PGNode *) n, (yylsp[(2) - (4)]));
-				;}
-    break;
-
-  case 798:
-#line 1858 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"),
-											   list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-											   (yylsp[(2) - (6)]));
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "~",
-												   (yyvsp[(1) - (6)].node), (PGNode *) n, (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 799:
-#line 1866 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"),
-											   list_make2((yyvsp[(5) - (5)].node), makeNullAConst(-1)),
-											   (yylsp[(2) - (5)]));
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "!~",
-												   (yyvsp[(1) - (5)].node), (PGNode *) n, (yylsp[(2) - (5)]));
-				;}
-    break;
-
-  case 800:
-#line 1874 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"),
-											   list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)),
-											   (yylsp[(2) - (7)]));
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_SIMILAR, "!~",
-												   (yyvsp[(1) - (7)].node), (PGNode *) n, (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 801:
-#line 1892 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					n->nulltesttype = PG_IS_NULL;
-					n->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 802:
-#line 1900 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (2)].node);
-					n->nulltesttype = PG_IS_NULL;
-					n->location = (yylsp[(2) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 803:
-#line 1908 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (4)].node);
-					n->nulltesttype = IS_NOT_NULL;
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 804:
-#line 1916 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					n->nulltesttype = IS_NOT_NULL;
-					n->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 805:
-#line 1924 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNullTest *n = makeNode(PGNullTest);
-					n->arg = (PGExpr *) (yyvsp[(1) - (2)].node);
-					n->nulltesttype = IS_NOT_NULL;
-					n->location = (yylsp[(2) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 806:
-#line 1931 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[(1) - (1)].list), (yylsp[(1) - (1)]));
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 807:
-#line 1935 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGFuncCall *n = makeFuncCall(SystemFuncName("struct_pack"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)]));
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 808:
-#line 1939 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGFuncCall *n = makeFuncCall(SystemFuncName("list_value"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)]));
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 809:
-#line 1944 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGLambdaFunction *n = makeNode(PGLambdaFunction);
-				n->lhs = (yyvsp[(1) - (3)].node);
-				n->rhs = (yyvsp[(3) - (3)].node);
-				n->location = (yylsp[(2) - (3)]);
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 810:
-#line 1952 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if (list_length((yyvsp[(1) - (3)].list)) != 2)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("wrong number of parameters on left side of OVERLAPS expression"),
-								 parser_errposition((yylsp[(1) - (3)]))));
-					if (list_length((yyvsp[(3) - (3)].list)) != 2)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-								 errmsg("wrong number of parameters on right side of OVERLAPS expression"),
-								 parser_errposition((yylsp[(3) - (3)]))));
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("overlaps"),
-											   list_concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)),
-											   (yylsp[(2) - (3)]));
-				;}
-    break;
-
-  case 811:
-#line 1968 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					b->booltesttype = PG_IS_TRUE;
-					b->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 812:
-#line 1976 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (4)].node);
-					b->booltesttype = IS_NOT_TRUE;
-					b->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 813:
-#line 1984 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					b->booltesttype = IS_FALSE;
-					b->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 814:
-#line 1992 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (4)].node);
-					b->booltesttype = IS_NOT_FALSE;
-					b->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 815:
-#line 2000 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (3)].node);
-					b->booltesttype = IS_UNKNOWN;
-					b->location = (yylsp[(2) - (3)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 816:
-#line 2008 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGBooleanTest *b = makeNode(PGBooleanTest);
-					b->arg = (PGExpr *) (yyvsp[(1) - (4)].node);
-					b->booltesttype = IS_NOT_UNKNOWN;
-					b->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)b;
-				;}
-    break;
-
-  case 817:
-#line 2016 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)]));
-				;}
-    break;
-
-  case 818:
-#line 2020 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 819:
-#line 2024 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 820:
-#line 2028 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 821:
-#line 2032 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_BETWEEN,
-												   "BETWEEN",
-												   (yyvsp[(1) - (6)].node),
-												   (PGNode *) list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-												   (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 822:
-#line 2040 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_BETWEEN,
-												   "NOT BETWEEN",
-												   (yyvsp[(1) - (7)].node),
-												   (PGNode *) list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)),
-												   (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 823:
-#line 2048 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_BETWEEN_SYM,
-												   "BETWEEN SYMMETRIC",
-												   (yyvsp[(1) - (6)].node),
-												   (PGNode *) list_make2((yyvsp[(4) - (6)].node), (yyvsp[(6) - (6)].node)),
-												   (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 824:
-#line 2056 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_BETWEEN_SYM,
-												   "NOT BETWEEN SYMMETRIC",
-												   (yyvsp[(1) - (7)].node),
-												   (PGNode *) list_make2((yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)),
-												   (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 825:
-#line 2064 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* in_expr returns a PGSubLink or a list of a_exprs */
-					if (IsA((yyvsp[(3) - (3)].node), PGSubLink))
-					{
-						/* generate foo = ANY (subquery) */
-						PGSubLink *n = (PGSubLink *) (yyvsp[(3) - (3)].node);
-						n->subLinkType = PG_ANY_SUBLINK;
-						n->subLinkId = 0;
-						n->testexpr = (yyvsp[(1) - (3)].node);
-						n->operName = NIL;		/* show it's IN not = ANY */
-						n->location = (yylsp[(2) - (3)]);
-						(yyval.node) = (PGNode *)n;
-					}
-					else
-					{
-						/* generate scalar IN expression */
-						(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_IN, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)]));
-					}
-				;}
-    break;
-
-  case 826:
-#line 2084 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* in_expr returns a PGSubLink or a list of a_exprs */
-					if (IsA((yyvsp[(4) - (4)].node), PGSubLink))
-					{
-						/* generate NOT (foo = ANY (subquery)) */
-						/* Make an = ANY node */
-						PGSubLink *n = (PGSubLink *) (yyvsp[(4) - (4)].node);
-						n->subLinkType = PG_ANY_SUBLINK;
-						n->subLinkId = 0;
-						n->testexpr = (yyvsp[(1) - (4)].node);
-						n->operName = NIL;		/* show it's IN not = ANY */
-						n->location = (yylsp[(2) - (4)]);
-						/* Stick a NOT on top; must have same parse location */
-						(yyval.node) = makeNotExpr((PGNode *) n, (yylsp[(2) - (4)]));
-					}
-					else
-					{
-						/* generate scalar NOT IN expression */
-						(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_IN, "<>", (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)]));
-					}
-				;}
-    break;
-
-  case 827:
-#line 2106 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subLinkType = (yyvsp[(3) - (4)].subquerytype);
-					n->subLinkId = 0;
-					n->testexpr = (yyvsp[(1) - (4)].node);
-					n->operName = (yyvsp[(2) - (4)].list);
-					n->subselect = (yyvsp[(4) - (4)].node);
-					n->location = (yylsp[(2) - (4)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 828:
-#line 2117 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(3) - (6)].subquerytype) == PG_ANY_SUBLINK)
-						(yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP_ANY, (yyvsp[(2) - (6)].list), (yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(2) - (6)]));
-					else
-						(yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP_ALL, (yyvsp[(2) - (6)].list), (yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 829:
-#line 2124 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * The SQL spec only allows DEFAULT in "contextually typed
-					 * expressions", but for us, it's easier to allow it in
-					 * any a_expr and then throw error during parse analysis
-					 * if it's in an inappropriate context.  This way also
-					 * lets us say something smarter than "syntax error".
-					 */
-					PGSetToDefault *n = makeNode(PGSetToDefault);
-					/* parse analysis will fill in the rest */
-					n->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 830:
-#line 2137 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				PGList *func_name = list_make1(makeString("construct_array"));
-				PGFuncCall *n = makeFuncCall(func_name, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 831:
-#line 2154 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 832:
-#line 2156 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 833:
-#line 2158 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 834:
-#line 2160 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 835:
-#line 2162 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 836:
-#line 2164 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 837:
-#line 2166 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 838:
-#line 2168 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 839:
-#line 2170 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 840:
-#line 2172 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 841:
-#line 2174 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 842:
-#line 2176 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 843:
-#line 2178 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 844:
-#line 2180 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 845:
-#line 2182 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 846:
-#line 2184 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 847:
-#line 2186 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 848:
-#line 2188 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;}
-    break;
-
-  case 849:
-#line 2190 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;}
-    break;
-
-  case 850:
-#line 2192 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;}
-    break;
-
-  case 851:
-#line 2194 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)]));
-				;}
-    break;
-
-  case 852:
-#line 2198 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 853:
-#line 2202 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)]));
-				;}
-    break;
-
-  case 854:
-#line 2206 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)]));
-				;}
-    break;
-
-  case 855:
-#line 2219 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 856:
-#line 2220 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 857:
-#line 2222 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGPositionalReference *n = makeNode(PGPositionalReference);
-					n->position = (yyvsp[(2) - (2)].ival);
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 858:
-#line 2229 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].list))
-					{
-						PGAIndirection *n = makeNode(PGAIndirection);
-						n->arg = makeParamRef(0, (yylsp[(1) - (2)]));
-						n->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-						(yyval.node) = (PGNode *) n;
-					}
-					else
-						(yyval.node) = makeParamRef(0, (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 859:
-#line 2241 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGParamRef *p = makeNode(PGParamRef);
-					p->number = (yyvsp[(1) - (2)].ival);
-					p->location = (yylsp[(1) - (2)]);
-					if ((yyvsp[(2) - (2)].list))
-					{
-						PGAIndirection *n = makeNode(PGAIndirection);
-						n->arg = (PGNode *) p;
-						n->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-						(yyval.node) = (PGNode *) n;
-					}
-					else
-						(yyval.node) = (PGNode *) p;
-				;}
-    break;
-
-  case 860:
-#line 2256 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(4) - (4)].list))
-					{
-						PGAIndirection *n = makeNode(PGAIndirection);
-						n->arg = (yyvsp[(2) - (4)].node);
-						n->indirection = check_indirection((yyvsp[(4) - (4)].list), yyscanner);
-						(yyval.node) = (PGNode *)n;
-					}
-					else
-						(yyval.node) = (yyvsp[(2) - (4)].node);
-				;}
-    break;
-
-  case 861:
-#line 2268 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 862:
-#line 2270 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].list)) {
-						PGAIndirection *n = makeNode(PGAIndirection);
-						n->arg = (yyvsp[(1) - (2)].node);
-						n->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-						(yyval.node) = (PGNode *)n;
-					}
-					else {
-						(yyval.node) = (yyvsp[(1) - (2)].node);
-					}
-				;}
-    break;
-
-  case 863:
-#line 2282 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subLinkType = PG_EXPR_SUBLINK;
-					n->subLinkId = 0;
-					n->testexpr = NULL;
-					n->operName = NIL;
-					n->subselect = (yyvsp[(1) - (1)].node);
-					n->location = (yylsp[(1) - (1)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 864:
-#line 2293 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * Because the select_with_parens nonterminal is designed
-					 * to "eat" as many levels of parens as possible, the
-					 * '(' a_expr ')' opt_indirection production above will
-					 * fail to match a sub-SELECT with indirection decoration;
-					 * the sub-SELECT won't be regarded as an a_expr as long
-					 * as there are parens around it.  To support applying
-					 * subscripting or field selection to a sub-SELECT result,
-					 * we need this redundant-looking production.
-					 */
-					PGSubLink *n = makeNode(PGSubLink);
-					PGAIndirection *a = makeNode(PGAIndirection);
-					n->subLinkType = PG_EXPR_SUBLINK;
-					n->subLinkId = 0;
-					n->testexpr = NULL;
-					n->operName = NIL;
-					n->subselect = (yyvsp[(1) - (2)].node);
-					n->location = (yylsp[(1) - (2)]);
-					a->arg = (PGNode *)n;
-					a->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-					(yyval.node) = (PGNode *)a;
-				;}
-    break;
-
-  case 865:
-#line 2317 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subLinkType = PG_EXISTS_SUBLINK;
-					n->subLinkId = 0;
-					n->testexpr = NULL;
-					n->operName = NIL;
-					n->subselect = (yyvsp[(2) - (2)].node);
-					n->location = (yylsp[(1) - (2)]);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 866:
-#line 2328 "third_party/libpg_query/grammar/statements/select.y"
-    {
-				  PGGroupingFunc *g = makeNode(PGGroupingFunc);
-				  g->args = (yyvsp[(3) - (4)].list);
-				  g->location = (yylsp[(1) - (4)]);
-				  (yyval.node) = (PGNode *)g;
-			  ;}
-    break;
-
-  case 867:
-#line 2337 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall((yyvsp[(1) - (3)].list), NIL, (yylsp[(1) - (3)]));
-				;}
-    break;
-
-  case 868:
-#line 2341 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (6)].list), (yyvsp[(3) - (6)].list), (yylsp[(1) - (6)]));
-					n->agg_order = (yyvsp[(4) - (6)].list);
-					n->agg_ignore_nulls = (yyvsp[(5) - (6)].boolean);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 869:
-#line 2348 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), list_make1((yyvsp[(4) - (7)].node)), (yylsp[(1) - (7)]));
-					n->func_variadic = true;
-					n->agg_order = (yyvsp[(5) - (7)].list);
-					n->agg_ignore_nulls = (yyvsp[(6) - (7)].boolean);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 870:
-#line 2356 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (9)].list), lappend((yyvsp[(3) - (9)].list), (yyvsp[(6) - (9)].node)), (yylsp[(1) - (9)]));
-					n->func_variadic = true;
-					n->agg_order = (yyvsp[(7) - (9)].list);
-					n->agg_ignore_nulls = (yyvsp[(8) - (9)].boolean);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 871:
-#line 2364 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), (yyvsp[(4) - (7)].list), (yylsp[(1) - (7)]));
-					n->agg_order = (yyvsp[(5) - (7)].list);
-					n->agg_ignore_nulls = (yyvsp[(6) - (7)].boolean);
-					/* Ideally we'd mark the PGFuncCall node to indicate
-					 * "must be an aggregate", but there's no provision
-					 * for that in PGFuncCall at the moment.
-					 */
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 872:
-#line 2375 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), (yyvsp[(4) - (7)].list), (yylsp[(1) - (7)]));
-					n->agg_order = (yyvsp[(5) - (7)].list);
-					n->agg_ignore_nulls = (yyvsp[(6) - (7)].boolean);
-					n->agg_distinct = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 873:
-#line 2383 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * We consider AGGREGATE(*) to invoke a parameterless
-					 * aggregate.  This does the right thing for COUNT(*),
-					 * and there are no other aggregates in SQL that accept
-					 * '*' as parameter.
-					 *
-					 * The PGFuncCall node is also marked agg_star = true,
-					 * so that later processing can detect what the argument
-					 * really was.
-					 */
-					PGFuncCall *n = makeFuncCall((yyvsp[(1) - (4)].list), NIL, (yylsp[(1) - (4)]));
-					n->agg_star = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 874:
-#line 2411 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGFuncCall *n = (PGFuncCall *) (yyvsp[(1) - (5)].node);
-					/*
-					 * The order clause for WITHIN GROUP and the one for
-					 * plain-aggregate ORDER BY share a field, so we have to
-					 * check here that at most one is present.  We also check
-					 * for DISTINCT and VARIADIC here to give a better error
-					 * location.  Other consistency checks are deferred to
-					 * parse analysis.
-					 */
-					if ((yyvsp[(2) - (5)].list) != NIL)
-					{
-						if (n->agg_order != NIL)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("cannot use multiple ORDER BY clauses with WITHIN GROUP"),
-									 parser_errposition((yylsp[(2) - (5)]))));
-						if (n->agg_distinct)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("cannot use DISTINCT with WITHIN GROUP"),
-									 parser_errposition((yylsp[(2) - (5)]))));
-						if (n->func_variadic)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("cannot use VARIADIC with WITHIN GROUP"),
-									 parser_errposition((yylsp[(2) - (5)]))));
-						n->agg_order = (yyvsp[(2) - (5)].list);
-						n->agg_within_group = true;
-					}
-					n->agg_filter = (yyvsp[(3) - (5)].node);
-					n->export_state = (yyvsp[(4) - (5)].boolean);
-					n->over = (yyvsp[(5) - (5)].windef);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 875:
-#line 2447 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 876:
-#line 2457 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 877:
-#line 2458 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 878:
-#line 2466 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("pg_collation_for"),
-											   list_make1((yyvsp[(4) - (5)].node)),
-											   (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 879:
-#line 2472 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_DATE, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 880:
-#line 2476 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_TIME, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 881:
-#line 2480 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_TIME_N, (yyvsp[(3) - (4)].ival), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 882:
-#line 2484 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_TIMESTAMP, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 883:
-#line 2488 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_TIMESTAMP_N, (yyvsp[(3) - (4)].ival), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 884:
-#line 2492 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_LOCALTIME, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 885:
-#line 2496 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_LOCALTIME_N, (yyvsp[(3) - (4)].ival), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 886:
-#line 2500 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_LOCALTIMESTAMP, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 887:
-#line 2504 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_LOCALTIMESTAMP_N, (yyvsp[(3) - (4)].ival), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 888:
-#line 2508 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_ROLE, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 889:
-#line 2512 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_USER, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 890:
-#line 2516 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_SESSION_USER, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 891:
-#line 2520 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_USER, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 892:
-#line 2524 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_CATALOG, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 893:
-#line 2528 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeSQLValueFunction(PG_SVFOP_CURRENT_SCHEMA, -1, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 894:
-#line 2532 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), 0, (yylsp[(1) - (6)])); ;}
-    break;
-
-  case 895:
-#line 2534 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), 1, (yylsp[(1) - (6)])); ;}
-    break;
-
-  case 896:
-#line 2536 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("date_part"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 897:
-#line 2540 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* overlay(A PLACING B FROM C FOR D) is converted to
-					 * overlay(A, B, C, D)
-					 * overlay(A PLACING B FROM C) is converted to
-					 * overlay(A, B, C)
-					 */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("overlay"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 898:
-#line 2549 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* position(A in B) is converted to position(B, A) */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("position"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 899:
-#line 2554 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* substring(A from B for C) is converted to
-					 * substring(A, B, C) - thomas 2000-11-28
-					 */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("substring"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 900:
-#line 2561 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* TREAT(expr AS target) converts expr of a particular type to target,
-					 * which is defined to be a subtype of the original expression.
-					 * In SQL99, this is intended for use with structured UDTs,
-					 * but let's make this a generally useful form allowing stronger
-					 * coercions than are handled by implicit casting.
-					 *
-					 * Convert SystemTypeName() to SystemFuncName() even though
-					 * at the moment they result in the same thing.
-					 */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName(((PGValue *)llast((yyvsp[(5) - (6)].typnam)->names))->val.str),
-												list_make1((yyvsp[(3) - (6)].node)),
-												(yylsp[(1) - (6)]));
-				;}
-    break;
-
-  case 901:
-#line 2576 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* various trim expressions are defined in SQL
-					 * - thomas 1997-07-19
-					 */
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 902:
-#line 2583 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("ltrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 903:
-#line 2587 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("rtrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)]));
-				;}
-    break;
-
-  case 904:
-#line 2591 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)]));
-				;}
-    break;
-
-  case 905:
-#line 2595 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NULLIF, "=", (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(1) - (6)]));
-				;}
-    break;
-
-  case 906:
-#line 2599 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCoalesceExpr *c = makeNode(PGCoalesceExpr);
-					c->args = (yyvsp[(3) - (4)].list);
-					c->location = (yylsp[(1) - (4)]);
-					(yyval.node) = (PGNode *)c;
-				;}
-    break;
-
-  case 907:
-#line 2612 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(4) - (5)].list); ;}
-    break;
-
-  case 908:
-#line 2613 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 909:
-#line 2617 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(4) - (5)].node); ;}
-    break;
-
-  case 910:
-#line 2618 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 911:
-#line 2622 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 912:
-#line 2623 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 913:
-#line 2630 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 914:
-#line 2631 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 915:
-#line 2635 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].windef)); ;}
-    break;
-
-  case 916:
-#line 2637 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].windef)); ;}
-    break;
-
-  case 917:
-#line 2642 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(3) - (3)].windef);
-					n->name = (yyvsp[(1) - (3)].str);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 918:
-#line 2650 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.windef) = (yyvsp[(2) - (2)].windef); ;}
-    break;
-
-  case 919:
-#line 2652 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->name = (yyvsp[(2) - (2)].str);
-					n->refname = NULL;
-					n->partitionClause = NIL;
-					n->orderClause = NIL;
-					n->frameOptions = FRAMEOPTION_DEFAULTS;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					n->location = (yylsp[(2) - (2)]);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 920:
-#line 2665 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.windef) = NULL; ;}
-    break;
-
-  case 921:
-#line 2670 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->name = NULL;
-					n->refname = (yyvsp[(2) - (6)].str);
-					n->partitionClause = (yyvsp[(3) - (6)].list);
-					n->orderClause = (yyvsp[(4) - (6)].list);
-					/* copy relevant fields of opt_frame_clause */
-					n->frameOptions = (yyvsp[(5) - (6)].windef)->frameOptions;
-					n->startOffset = (yyvsp[(5) - (6)].windef)->startOffset;
-					n->endOffset = (yyvsp[(5) - (6)].windef)->endOffset;
-					n->location = (yylsp[(1) - (6)]);
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 922:
-#line 2695 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 923:
-#line 2696 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 924:
-#line 2699 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (3)].list); ;}
-    break;
-
-  case 925:
-#line 2700 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 926:
-#line 2712 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(2) - (2)].windef);
-					n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_RANGE;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 927:
-#line 2718 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(2) - (2)].windef);
-					n->frameOptions |= FRAMEOPTION_NONDEFAULT | FRAMEOPTION_ROWS;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 928:
-#line 2724 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->frameOptions = FRAMEOPTION_DEFAULTS;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 929:
-#line 2734 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = (yyvsp[(1) - (1)].windef);
-					/* reject invalid cases */
-					if (n->frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame start cannot be UNBOUNDED FOLLOWING"),
-								 parser_errposition((yylsp[(1) - (1)]))));
-					if (n->frameOptions & FRAMEOPTION_START_VALUE_FOLLOWING)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame starting from following row cannot end with current row"),
-								 parser_errposition((yylsp[(1) - (1)]))));
-					n->frameOptions |= FRAMEOPTION_END_CURRENT_ROW;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 930:
-#line 2751 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n1 = (yyvsp[(2) - (4)].windef);
-					PGWindowDef *n2 = (yyvsp[(4) - (4)].windef);
-					/* form merged options */
-					int		frameOptions = n1->frameOptions;
-					/* shift converts START_ options to END_ options */
-					frameOptions |= n2->frameOptions << 1;
-					frameOptions |= FRAMEOPTION_BETWEEN;
-					/* reject invalid cases */
-					if (frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame start cannot be UNBOUNDED FOLLOWING"),
-								 parser_errposition((yylsp[(2) - (4)]))));
-					if (frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame end cannot be UNBOUNDED PRECEDING"),
-								 parser_errposition((yylsp[(4) - (4)]))));
-					if ((frameOptions & FRAMEOPTION_START_CURRENT_ROW) &&
-						(frameOptions & FRAMEOPTION_END_VALUE_PRECEDING))
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame starting from current row cannot have preceding rows"),
-								 parser_errposition((yylsp[(4) - (4)]))));
-					if ((frameOptions & FRAMEOPTION_START_VALUE_FOLLOWING) &&
-						(frameOptions & (FRAMEOPTION_END_VALUE_PRECEDING |
-										 FRAMEOPTION_END_CURRENT_ROW)))
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_WINDOWING_ERROR),
-								 errmsg("frame starting from following row cannot have preceding rows"),
-								 parser_errposition((yylsp[(4) - (4)]))));
-					n1->frameOptions = frameOptions;
-					n1->endOffset = n2->startOffset;
-					(yyval.windef) = n1;
-				;}
-    break;
-
-  case 931:
-#line 2796 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->frameOptions = FRAMEOPTION_START_UNBOUNDED_PRECEDING;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 932:
-#line 2804 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->frameOptions = FRAMEOPTION_START_UNBOUNDED_FOLLOWING;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 933:
-#line 2812 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->frameOptions = FRAMEOPTION_START_CURRENT_ROW;
-					n->startOffset = NULL;
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 934:
-#line 2820 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->frameOptions = FRAMEOPTION_START_VALUE_PRECEDING;
-					n->startOffset = (yyvsp[(1) - (2)].node);
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 935:
-#line 2828 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGWindowDef *n = makeNode(PGWindowDef);
-					n->frameOptions = FRAMEOPTION_START_VALUE_FOLLOWING;
-					n->startOffset = (yyvsp[(1) - (2)].node);
-					n->endOffset = NULL;
-					(yyval.windef) = n;
-				;}
-    break;
-
-  case 936:
-#line 2848 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 937:
-#line 2849 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 938:
-#line 2852 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list);;}
-    break;
-
-  case 939:
-#line 2853 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(2) - (5)].list), (yyvsp[(4) - (5)].node)); ;}
-    break;
-
-  case 940:
-#line 2857 "third_party/libpg_query/grammar/statements/select.y"
-    {
-		PGNamedArgExpr *na = makeNode(PGNamedArgExpr);
-		na->name = (yyvsp[(1) - (3)].str);
-		na->arg = (PGExpr *) (yyvsp[(3) - (3)].node);
-		na->argnumber = -1;
-		na->location = (yylsp[(1) - (3)]);
-		(yyval.node) = (PGNode *) na;
-	;}
-    break;
-
-  case 941:
-#line 2867 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 942:
-#line 2868 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 943:
-#line 2872 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 944:
-#line 2873 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 945:
-#line 2877 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.subquerytype) = PG_ANY_SUBLINK; ;}
-    break;
-
-  case 946:
-#line 2878 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.subquerytype) = PG_ANY_SUBLINK; ;}
-    break;
-
-  case 947:
-#line 2879 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.subquerytype) = PG_ALL_SUBLINK; ;}
-    break;
-
-  case 948:
-#line 2882 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 949:
-#line 2883 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) (yyvsp[(1) - (1)].conststr); ;}
-    break;
-
-  case 950:
-#line 2886 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "+"; ;}
-    break;
-
-  case 951:
-#line 2887 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "-"; ;}
-    break;
-
-  case 952:
-#line 2888 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "*"; ;}
-    break;
-
-  case 953:
-#line 2889 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "/"; ;}
-    break;
-
-  case 954:
-#line 2890 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "%"; ;}
-    break;
-
-  case 955:
-#line 2891 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "^"; ;}
-    break;
-
-  case 956:
-#line 2892 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "**"; ;}
-    break;
-
-  case 957:
-#line 2893 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "<"; ;}
-    break;
-
-  case 958:
-#line 2894 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = ">"; ;}
-    break;
-
-  case 959:
-#line 2895 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "="; ;}
-    break;
-
-  case 960:
-#line 2896 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "<="; ;}
-    break;
-
-  case 961:
-#line 2897 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = ">="; ;}
-    break;
-
-  case 962:
-#line 2898 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.conststr) = "<>"; ;}
-    break;
-
-  case 963:
-#line 2902 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 964:
-#line 2904 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 965:
-#line 2909 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 966:
-#line 2911 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 967:
-#line 2916 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 968:
-#line 2918 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 969:
-#line 2920 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("~~")); ;}
-    break;
-
-  case 970:
-#line 2922 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("!~~")); ;}
-    break;
-
-  case 971:
-#line 2924 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("~~~")); ;}
-    break;
-
-  case 972:
-#line 2926 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("!~~~")); ;}
-    break;
-
-  case 973:
-#line 2928 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("~~*")); ;}
-    break;
-
-  case 974:
-#line 2930 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString("!~~*")); ;}
-    break;
-
-  case 975:
-#line 2944 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 976:
-#line 2946 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lcons(makeString((yyvsp[(1) - (3)].str)), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 977:
-#line 2950 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 978:
-#line 2954 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 979:
-#line 2961 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (1)].list);
-				;}
-    break;
-
-  case 980:
-#line 2966 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (2)].list);
-				;}
-    break;
-
-  case 981:
-#line 2973 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (1)].list);
-				;}
-    break;
-
-  case 982:
-#line 2977 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = NULL;
-				;}
-    break;
-
-  case 983:
-#line 2986 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].node));
-				;}
-    break;
-
-  case 984:
-#line 2990 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 985:
-#line 2996 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (yyvsp[(1) - (1)].node);
-				;}
-    break;
-
-  case 986:
-#line 3000 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNamedArgExpr *na = makeNode(PGNamedArgExpr);
-					na->name = (yyvsp[(1) - (3)].str);
-					na->arg = (PGExpr *) (yyvsp[(3) - (3)].node);
-					na->argnumber = -1;		/* until determined */
-					na->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) na;
-				;}
-    break;
-
-  case 987:
-#line 3009 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGNamedArgExpr *na = makeNode(PGNamedArgExpr);
-					na->name = (yyvsp[(1) - (3)].str);
-					na->arg = (PGExpr *) (yyvsp[(3) - (3)].node);
-					na->argnumber = -1;		/* until determined */
-					na->location = (yylsp[(1) - (3)]);
-					(yyval.node) = (PGNode *) na;
-				;}
-    break;
-
-  case 988:
-#line 3019 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].typnam)); ;}
-    break;
-
-  case 989:
-#line 3020 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].typnam)); ;}
-    break;
-
-  case 990:
-#line 3025 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2(makeStringConst((yyvsp[(1) - (3)].str), (yylsp[(1) - (3)])), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 991:
-#line 3028 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 992:
-#line 3035 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 993:
-#line 3036 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "year"; ;}
-    break;
-
-  case 994:
-#line 3037 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "month"; ;}
-    break;
-
-  case 995:
-#line 3038 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "day"; ;}
-    break;
-
-  case 996:
-#line 3039 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "hour"; ;}
-    break;
-
-  case 997:
-#line 3040 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "minute"; ;}
-    break;
-
-  case 998:
-#line 3041 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "second"; ;}
-    break;
-
-  case 999:
-#line 3042 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "millisecond"; ;}
-    break;
-
-  case 1000:
-#line 3043 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (char*) "microsecond"; ;}
-    break;
-
-  case 1001:
-#line 3044 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1002:
-#line 3055 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make4((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
-				;}
-    break;
-
-  case 1003:
-#line 3059 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 1004:
-#line 3066 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1005:
-#line 3072 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(3) - (3)].node), (yyvsp[(1) - (3)].node)); ;}
-    break;
-
-  case 1006:
-#line 3073 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1007:
-#line 3090 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node));
-				;}
-    break;
-
-  case 1008:
-#line 3094 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* not legal per SQL99, but might as well allow it */
-					(yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yyvsp[(2) - (3)].node));
-				;}
-    break;
-
-  case 1009:
-#line 3099 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
-				;}
-    break;
-
-  case 1010:
-#line 3103 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/*
-					 * Since there are no cases where this syntax allows
-					 * a textual FOR value, we forcibly cast the argument
-					 * to int4.  The possible matches in pg_proc are
-					 * substring(text,int4) and substring(text,text),
-					 * and we don't want the parser to choose the latter,
-					 * which it is likely to do if the second argument
-					 * is unknown or doesn't have an implicit cast to int4.
-					 */
-					(yyval.list) = list_make3((yyvsp[(1) - (2)].node), makeIntConst(1, -1),
-									makeTypeCast((yyvsp[(2) - (2)].node),
-												 SystemTypeName("int4"), 0, -1));
-				;}
-    break;
-
-  case 1011:
-#line 3118 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.list) = (yyvsp[(1) - (1)].list);
-				;}
-    break;
-
-  case 1012:
-#line 3122 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1013:
-#line 3126 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1014:
-#line 3129 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1015:
-#line 3132 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(3) - (3)].list), (yyvsp[(1) - (3)].node)); ;}
-    break;
-
-  case 1016:
-#line 3133 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 1017:
-#line 3134 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1018:
-#line 3138 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGSubLink *n = makeNode(PGSubLink);
-					n->subselect = (yyvsp[(1) - (1)].node);
-					/* other fields will be filled later */
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1019:
-#line 3144 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (PGNode *)(yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 1020:
-#line 3155 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCaseExpr *c = makeNode(PGCaseExpr);
-					c->casetype = InvalidOid; /* not analyzed yet */
-					c->arg = (PGExpr *) (yyvsp[(2) - (5)].node);
-					c->args = (yyvsp[(3) - (5)].list);
-					c->defresult = (PGExpr *) (yyvsp[(4) - (5)].node);
-					c->location = (yylsp[(1) - (5)]);
-					(yyval.node) = (PGNode *)c;
-				;}
-    break;
-
-  case 1021:
-#line 3168 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 1022:
-#line 3169 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 1023:
-#line 3174 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGCaseWhen *w = makeNode(PGCaseWhen);
-					w->expr = (PGExpr *) (yyvsp[(2) - (4)].node);
-					w->result = (PGExpr *) (yyvsp[(4) - (4)].node);
-					w->location = (yylsp[(1) - (4)]);
-					(yyval.node) = (PGNode *)w;
-				;}
-    break;
-
-  case 1024:
-#line 3184 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1025:
-#line 3185 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1026:
-#line 3188 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1027:
-#line 3189 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1028:
-#line 3193 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner);
-				;}
-    break;
-
-  case 1029:
-#line 3197 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeColumnRef((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].list), (yylsp[(1) - (2)]), yyscanner);
-				;}
-    break;
-
-  case 1030:
-#line 3204 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = (PGNode *) makeString((yyvsp[(2) - (2)].str));
-				;}
-    break;
-
-  case 1031:
-#line 3208 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = false;
-					ai->lidx = NULL;
-					ai->uidx = (yyvsp[(2) - (3)].node);
-					(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1032:
-#line 3216 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGAIndices *ai = makeNode(PGAIndices);
-					ai->is_slice = true;
-					ai->lidx = (yyvsp[(2) - (5)].node);
-					ai->uidx = (yyvsp[(4) - (5)].node);
-					(yyval.node) = (PGNode *) ai;
-				;}
-    break;
-
-  case 1033:
-#line 3226 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
-    break;
-
-  case 1034:
-#line 3227 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1035:
-#line 3231 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 1036:
-#line 3232 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 1037:
-#line 3236 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1038:
-#line 3237 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;}
-    break;
-
-  case 1041:
-#line 3251 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1042:
-#line 3252 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1043:
-#line 3256 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;}
-    break;
-
-  case 1044:
-#line 3257 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;}
-    break;
-
-  case 1045:
-#line 3261 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1046:
-#line 3262 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1047:
-#line 3266 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(3) - (3)].str);
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)(yyvsp[(1) - (3)].node);
-					(yyval.target)->location = (yylsp[(1) - (3)]);
-				;}
-    break;
-
-  case 1048:
-#line 3282 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = (yyvsp[(2) - (2)].str);
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)(yyvsp[(1) - (2)].node);
-					(yyval.target)->location = (yylsp[(1) - (2)]);
-				;}
-    break;
-
-  case 1049:
-#line 3290 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = NULL;
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)(yyvsp[(1) - (1)].node);
-					(yyval.target)->location = (yylsp[(1) - (1)]);
-				;}
-    break;
-
-  case 1050:
-#line 3298 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGColumnRef *n = makeNode(PGColumnRef);
-					PGAStar *star = makeNode(PGAStar);
-					n->fields = list_make1(star);
-					n->location = (yylsp[(1) - (3)]);
-					star->except_list = (yyvsp[(2) - (3)].list);
-					star->replace_list = (yyvsp[(3) - (3)].list);
-
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = NULL;
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)n;
-					(yyval.target)->location = (yylsp[(1) - (3)]);
-				;}
-    break;
-
-  case 1051:
-#line 3313 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					PGColumnRef *n = makeNode(PGColumnRef);
-					PGAStar *star = makeNode(PGAStar);
-					n->fields = list_make1(star);
-					n->location = (yylsp[(1) - (5)]);
-					star->relation = (yyvsp[(1) - (5)].str);
-					star->except_list = (yyvsp[(4) - (5)].list);
-					star->replace_list = (yyvsp[(5) - (5)].list);
-
-					(yyval.target) = makeNode(PGResTarget);
-					(yyval.target)->name = NULL;
-					(yyval.target)->indirection = NIL;
-					(yyval.target)->val = (PGNode *)n;
-					(yyval.target)->location = (yylsp[(1) - (5)]);
-				;}
-    break;
-
-  case 1052:
-#line 3330 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1053:
-#line 3331 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;}
-    break;
-
-  case 1054:
-#line 3334 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1055:
-#line 3335 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NULL; ;}
-    break;
-
-  case 1056:
-#line 3338 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), makeString((yyvsp[(3) - (3)].str))); ;}
-    break;
-
-  case 1057:
-#line 3342 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;}
-    break;
-
-  case 1058:
-#line 3343 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;}
-    break;
-
-  case 1059:
-#line 3347 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1060:
-#line 3348 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1061:
-#line 3351 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(3) - (4)].list); ;}
-    break;
-
-  case 1062:
-#line 3352 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;}
-    break;
-
-  case 1063:
-#line 3353 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NULL; ;}
-    break;
-
-  case 1064:
-#line 3363 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].range)); ;}
-    break;
-
-  case 1065:
-#line 3364 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].range)); ;}
-    break;
-
-  case 1066:
-#line 3376 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.range) = makeRangeVar(NULL, (yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1067:
-#line 3380 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					check_qualified_name((yyvsp[(2) - (2)].list), yyscanner);
-					(yyval.range) = makeRangeVar(NULL, NULL, (yylsp[(1) - (2)]));
-					switch (list_length((yyvsp[(2) - (2)].list)))
-					{
-						case 1:
-							(yyval.range)->catalogname = NULL;
-							(yyval.range)->schemaname = (yyvsp[(1) - (2)].str);
-							(yyval.range)->relname = strVal(linitial((yyvsp[(2) - (2)].list)));
-							break;
-						case 2:
-							(yyval.range)->catalogname = (yyvsp[(1) - (2)].str);
-							(yyval.range)->schemaname = strVal(linitial((yyvsp[(2) - (2)].list)));
-							(yyval.range)->relname = strVal(lsecond((yyvsp[(2) - (2)].list)));
-							break;
-						default:
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("improper qualified name (too many dotted names): %s",
-											NameListToString(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)))),
-									 parser_errposition((yylsp[(1) - (2)]))));
-							break;
-					}
-				;}
-    break;
-
-  case 1068:
-#line 3407 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1069:
-#line 3409 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;}
-    break;
-
-  case 1070:
-#line 3414 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (1)].list); ;}
-    break;
-
-  case 1071:
-#line 3415 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(1) - (2)].list); ;}
-    break;
-
-  case 1072:
-#line 3418 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1073:
-#line 3420 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1074:
-#line 3431 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1075:
-#line 3434 "third_party/libpg_query/grammar/statements/select.y"
-    {
-						(yyval.list) = check_func_name(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)),
-											 yyscanner);
-					;}
-    break;
-
-  case 1076:
-#line 3445 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1077:
-#line 3449 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1078:
-#line 3453 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					if ((yyvsp[(2) - (2)].list))
-					{
-						PGAIndirection *n = makeNode(PGAIndirection);
-						n->arg = makeStringConst((yyvsp[(1) - (2)].str), (yylsp[(1) - (2)]));
-						n->indirection = check_indirection((yyvsp[(2) - (2)].list), yyscanner);
-						(yyval.node) = (PGNode *) n;
-					}
-					else
-						(yyval.node) = makeStringConst((yyvsp[(1) - (2)].str), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 1079:
-#line 3465 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1080:
-#line 3469 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* This is a bit constant per SQL99:
-					 * Without Feature F511, "BIT data type",
-					 * a <general literal> shall not be a
-					 * <bit string literal> or a <hex string literal>.
-					 */
-					(yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1081:
-#line 3478 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* generic type 'literal' syntax */
-					PGTypeName *t = makeTypeNameFromNameList((yyvsp[(1) - (2)].list));
-					t->location = (yylsp[(1) - (2)]);
-					(yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), t);
-				;}
-    break;
-
-  case 1082:
-#line 3485 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					/* generic syntax with a type modifier */
-					PGTypeName *t = makeTypeNameFromNameList((yyvsp[(1) - (7)].list));
-					PGListCell *lc;
-
-					/*
-					 * We must use func_arg_list and opt_sort_clause in the
-					 * production to avoid reduce/reduce conflicts, but we
-					 * don't actually wish to allow PGNamedArgExpr in this
-					 * context, ORDER BY, nor IGNORE NULLS.
-					 */
-					foreach(lc, (yyvsp[(3) - (7)].list))
-					{
-						PGNamedArgExpr *arg = (PGNamedArgExpr *) lfirst(lc);
-
-						if (IsA(arg, PGNamedArgExpr))
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("type modifier cannot have parameter name"),
-									 parser_errposition(arg->location)));
-					}
-					if ((yyvsp[(4) - (7)].list) != NIL)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("type modifier cannot have ORDER BY"),
-									 parser_errposition((yylsp[(4) - (7)]))));
-					if ((yyvsp[(5) - (7)].boolean) != false)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("type modifier cannot have IGNORE NULLS"),
-									 parser_errposition((yylsp[(5) - (7)]))));
-
-
-					t->typmods = (yyvsp[(3) - (7)].list);
-					t->location = (yylsp[(1) - (7)]);
-					(yyval.node) = makeStringConstCast((yyvsp[(7) - (7)].str), (yylsp[(7) - (7)]), t);
-				;}
-    break;
-
-  case 1083:
-#line 3523 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), (yyvsp[(1) - (2)].typnam));
-				;}
-    break;
-
-  case 1084:
-#line 3527 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeIntervalNode((yyvsp[(3) - (5)].node), (yylsp[(3) - (5)]), (yyvsp[(5) - (5)].list));
-				;}
-    break;
-
-  case 1085:
-#line 3531 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].ival), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list));
-				;}
-    break;
-
-  case 1086:
-#line 3535 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list));
-				;}
-    break;
-
-  case 1087:
-#line 3539 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeBoolAConst(true, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1088:
-#line 3543 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeBoolAConst(false, (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1089:
-#line 3547 "third_party/libpg_query/grammar/statements/select.y"
-    {
-					(yyval.node) = makeNullAConst((yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1090:
-#line 3552 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;}
-    break;
-
-  case 1091:
-#line 3553 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1092:
-#line 3569 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1093:
-#line 3570 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1094:
-#line 3571 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1095:
-#line 3574 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1096:
-#line 3575 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1097:
-#line 3581 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1098:
-#line 3582 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1099:
-#line 3583 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1100:
-#line 3586 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1101:
-#line 3587 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1102:
-#line 3588 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1103:
-#line 3591 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1104:
-#line 3592 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1105:
-#line 3593 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1106:
-#line 3596 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;}
-    break;
-
-  case 1107:
-#line 3597 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)); ;}
-    break;
-
-  case 1108:
-#line 3601 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;}
-    break;
-
-  case 1109:
-#line 3603 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;}
-    break;
-
-  case 1110:
-#line 3607 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 1111:
-#line 3608 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1113:
-#line 3619 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1114:
-#line 3620 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1115:
-#line 3621 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1116:
-#line 3622 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1117:
-#line 3625 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1118:
-#line 3626 "third_party/libpg_query/grammar/statements/select.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1119:
-#line 8 "third_party/libpg_query/grammar/statements/prepare.y"
-    {
-					PGPrepareStmt *n = makeNode(PGPrepareStmt);
-					n->name = (yyvsp[(2) - (5)].str);
-					n->argtypes = (yyvsp[(3) - (5)].list);
-					n->query = (yyvsp[(5) - (5)].node);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1120:
-#line 18 "third_party/libpg_query/grammar/statements/prepare.y"
-    { (yyval.list) = (yyvsp[(2) - (3)].list); ;}
-    break;
-
-  case 1121:
-#line 19 "third_party/libpg_query/grammar/statements/prepare.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1126:
-#line 8 "third_party/libpg_query/grammar/statements/create_schema.y"
-    {
-					PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt);
-					/* ...but not both */
-					n->schemaname = (yyvsp[(3) - (4)].str);
-					n->schemaElts = (yyvsp[(4) - (4)].list);
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1127:
-#line 17 "third_party/libpg_query/grammar/statements/create_schema.y"
-    {
-					PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt);
-					/* ...but not here */
-					n->schemaname = (yyvsp[(6) - (7)].str);
-					if ((yyvsp[(7) - (7)].list) != NIL)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("CREATE SCHEMA IF NOT EXISTS cannot include schema elements"),
-								 parser_errposition((yylsp[(7) - (7)]))));
-					n->schemaElts = (yyvsp[(7) - (7)].list);
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1128:
-#line 35 "third_party/libpg_query/grammar/statements/create_schema.y"
-    {
-					if ((yyloc) < 0)			/* see comments for YYLLOC_DEFAULT */
-						(yyloc) = (yylsp[(2) - (2)]);
-					(yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node));
-				;}
-    break;
-
-  case 1129:
-#line 41 "third_party/libpg_query/grammar/statements/create_schema.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1134:
-#line 11 "third_party/libpg_query/grammar/statements/index.y"
-    {
-					PGIndexStmt *n = makeNode(PGIndexStmt);
-					n->unique = (yyvsp[(2) - (13)].boolean);
-					n->concurrent = (yyvsp[(4) - (13)].boolean);
-					n->idxname = (yyvsp[(5) - (13)].str);
-					n->relation = (yyvsp[(7) - (13)].range);
-					n->accessMethod = (yyvsp[(8) - (13)].str);
-					n->indexParams = (yyvsp[(10) - (13)].list);
-					n->options = (yyvsp[(12) - (13)].list);
-					n->whereClause = (yyvsp[(13) - (13)].node);
-					n->excludeOpNames = NIL;
-					n->idxcomment = NULL;
-					n->indexOid = InvalidOid;
-					n->oldNode = InvalidOid;
-					n->primary = false;
-					n->isconstraint = false;
-					n->deferrable = false;
-					n->initdeferred = false;
-					n->transformed = false;
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1135:
-#line 36 "third_party/libpg_query/grammar/statements/index.y"
-    {
-					PGIndexStmt *n = makeNode(PGIndexStmt);
-					n->unique = (yyvsp[(2) - (16)].boolean);
-					n->concurrent = (yyvsp[(4) - (16)].boolean);
-					n->idxname = (yyvsp[(8) - (16)].str);
-					n->relation = (yyvsp[(10) - (16)].range);
-					n->accessMethod = (yyvsp[(11) - (16)].str);
-					n->indexParams = (yyvsp[(13) - (16)].list);
-					n->options = (yyvsp[(15) - (16)].list);
-					n->whereClause = (yyvsp[(16) - (16)].node);
-					n->excludeOpNames = NIL;
-					n->idxcomment = NULL;
-					n->indexOid = InvalidOid;
-					n->oldNode = InvalidOid;
-					n->primary = false;
-					n->isconstraint = false;
-					n->deferrable = false;
-					n->initdeferred = false;
-					n->transformed = false;
-					n->onconflict = PG_IGNORE_ON_CONFLICT;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1136:
-#line 62 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1137:
-#line 66 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
-    break;
-
-  case 1138:
-#line 67 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = (char*) DEFAULT_INDEX_TYPE; ;}
-    break;
-
-  case 1139:
-#line 72 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1140:
-#line 73 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1141:
-#line 78 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1142:
-#line 79 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.str) = NULL; ;}
-    break;
-
-  case 1143:
-#line 83 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 1144:
-#line 84 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1145:
-#line 89 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1146:
-#line 90 "third_party/libpg_query/grammar/statements/index.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1147:
-#line 8 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->newschema = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1148:
-#line 17 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_TABLE;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->newschema = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1149:
-#line 26 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_SEQUENCE;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->newschema = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1150:
-#line 35 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_SEQUENCE;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->newschema = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1151:
-#line 44 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_VIEW;
-					n->relation = (yyvsp[(3) - (6)].range);
-					n->newschema = (yyvsp[(6) - (6)].str);
-					n->missing_ok = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1152:
-#line 53 "third_party/libpg_query/grammar/statements/alter_schema.y"
-    {
-					PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt);
-					n->objectType = PG_OBJECT_VIEW;
-					n->relation = (yyvsp[(5) - (8)].range);
-					n->newschema = (yyvsp[(8) - (8)].str);
-					n->missing_ok = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1153:
-#line 6 "third_party/libpg_query/grammar/statements/checkpoint.y"
-    {
-					PGCheckPointStmt *n = makeNode(PGCheckPointStmt);
-					n->force = true;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1154:
-#line 12 "third_party/libpg_query/grammar/statements/checkpoint.y"
-    {
-					PGCheckPointStmt *n = makeNode(PGCheckPointStmt);
-					n->force = false;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1155:
-#line 8 "third_party/libpg_query/grammar/statements/export.y"
-    {
-					PGExportStmt *n = makeNode(PGExportStmt);
-					n->filename = (yyvsp[(3) - (4)].str);
-					n->options = NIL;
-					if ((yyvsp[(4) - (4)].list)) {
-						n->options = list_concat(n->options, (yyvsp[(4) - (4)].list));
-					}
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1156:
-#line 21 "third_party/libpg_query/grammar/statements/export.y"
-    {
-					PGImportStmt *n = makeNode(PGImportStmt);
-					n->filename = (yyvsp[(3) - (3)].str);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1157:
-#line 10 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					PGExplainStmt *n = makeNode(PGExplainStmt);
-					n->query = (yyvsp[(2) - (2)].node);
-					n->options = NIL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1158:
-#line 17 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					PGExplainStmt *n = makeNode(PGExplainStmt);
-					n->query = (yyvsp[(4) - (4)].node);
-					n->options = list_make1(makeDefElem("analyze", NULL, (yylsp[(2) - (4)])));
-					if ((yyvsp[(3) - (4)].boolean))
-						n->options = lappend(n->options,
-											 makeDefElem("verbose", NULL, (yylsp[(3) - (4)])));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1159:
-#line 27 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					PGExplainStmt *n = makeNode(PGExplainStmt);
-					n->query = (yyvsp[(3) - (3)].node);
-					n->options = list_make1(makeDefElem("verbose", NULL, (yylsp[(2) - (3)])));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1160:
-#line 34 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					PGExplainStmt *n = makeNode(PGExplainStmt);
-					n->query = (yyvsp[(5) - (5)].node);
-					n->options = (yyvsp[(3) - (5)].list);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1161:
-#line 44 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1162:
-#line 45 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1163:
-#line 50 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;}
-    break;
-
-  case 1164:
-#line 51 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;}
-    break;
-
-  case 1165:
-#line 52 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1171:
-#line 65 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1172:
-#line 66 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1173:
-#line 67 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;}
-    break;
-
-  case 1174:
-#line 72 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1175:
-#line 73 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1176:
-#line 79 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					(yyval.list) = list_make1((yyvsp[(1) - (1)].defelt));
-				;}
-    break;
-
-  case 1177:
-#line 83 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					(yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt));
-				;}
-    break;
-
-  case 1178:
-#line 90 "third_party/libpg_query/grammar/statements/explain.y"
-    {;}
-    break;
-
-  case 1179:
-#line 91 "third_party/libpg_query/grammar/statements/explain.y"
-    {;}
-    break;
-
-  case 1180:
-#line 96 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (char*) "true"; ;}
-    break;
-
-  case 1181:
-#line 97 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (char*) "false"; ;}
-    break;
-
-  case 1182:
-#line 98 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (char*) "on"; ;}
-    break;
-
-  case 1183:
-#line 104 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1184:
-#line 110 "third_party/libpg_query/grammar/statements/explain.y"
-    {
-					(yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)]));
-				;}
-    break;
-
-  case 1185:
-#line 117 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1186:
-#line 118 "third_party/libpg_query/grammar/statements/explain.y"
-    { (yyval.str) = (char*) "analyze"; ;}
-    break;
-
-  case 1187:
-#line 11 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(2) - (2)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_DEFAULT;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1188:
-#line 17 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_LOCAL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1189:
-#line 23 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_SESSION;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1190:
-#line 29 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt);
-					n->scope = VAR_SET_SCOPE_GLOBAL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1191:
-#line 38 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {(yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt);;}
-    break;
-
-  case 1192:
-#line 40 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_CURRENT;
-					n->name = (yyvsp[(1) - (3)].str);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1193:
-#line 48 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_VALUE;
-					n->name = (char*) "timezone";
-					if ((yyvsp[(3) - (3)].node) != NULL)
-						n->args = list_make1((yyvsp[(3) - (3)].node));
-					else
-						n->kind = VAR_SET_DEFAULT;
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1194:
-#line 59 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_VALUE;
-					n->name = (char*) "search_path";
-					n->args = list_make1(makeStringConst((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)])));
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1195:
-#line 71 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_VALUE;
-					n->name = (yyvsp[(1) - (3)].str);
-					n->args = (yyvsp[(3) - (3)].list);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1196:
-#line 79 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_VALUE;
-					n->name = (yyvsp[(1) - (3)].str);
-					n->args = (yyvsp[(3) - (3)].list);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1197:
-#line 87 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_DEFAULT;
-					n->name = (yyvsp[(1) - (3)].str);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1198:
-#line 94 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_SET_DEFAULT;
-					n->name = (yyvsp[(1) - (3)].str);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1199:
-#line 104 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;}
-    break;
-
-  case 1200:
-#line 106 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = makeAConst((yyvsp[(1) - (1)].value), (yylsp[(1) - (1)])); ;}
-    break;
-
-  case 1201:
-#line 112 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					(yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1202:
-#line 116 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					(yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)]));
-				;}
-    break;
-
-  case 1203:
-#line 120 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGTypeName *t = (yyvsp[(1) - (3)].typnam);
-					if ((yyvsp[(3) - (3)].list) != NIL)
-					{
-						PGAConst *n = (PGAConst *) linitial((yyvsp[(3) - (3)].list));
-						if ((n->val.val.ival & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
-							ereport(ERROR,
-									(errcode(PG_ERRCODE_SYNTAX_ERROR),
-									 errmsg("time zone interval must be HOUR or HOUR TO MINUTE"),
-									 parser_errposition((yylsp[(3) - (3)]))));
-					}
-					t->typmods = (yyvsp[(3) - (3)].list);
-					(yyval.node) = makeStringConstCast((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), t);
-				;}
-    break;
-
-  case 1204:
-#line 135 "third_party/libpg_query/grammar/statements/variable_set.y"
-    {
-					PGTypeName *t = (yyvsp[(1) - (5)].typnam);
-					t->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
-											makeIntConst((yyvsp[(3) - (5)].ival), (yylsp[(3) - (5)])));
-					(yyval.node) = makeStringConstCast((yyvsp[(5) - (5)].str), (yylsp[(5) - (5)]), t);
-				;}
-    break;
-
-  case 1205:
-#line 141 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = makeAConst((yyvsp[(1) - (1)].value), (yylsp[(1) - (1)])); ;}
-    break;
-
-  case 1206:
-#line 142 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1207:
-#line 143 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1208:
-#line 147 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;}
-    break;
-
-  case 1209:
-#line 148 "third_party/libpg_query/grammar/statements/variable_set.y"
-    { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;}
-    break;
-
-  case 1210:
-#line 8 "third_party/libpg_query/grammar/statements/load.y"
-    {
-					PGLoadStmt *n = makeNode(PGLoadStmt);
-					n->filename = (yyvsp[(2) - (2)].str);
-					n->load_type = PG_LOAD_TYPE_LOAD;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1211:
-#line 14 "third_party/libpg_query/grammar/statements/load.y"
-    {
-                    PGLoadStmt *n = makeNode(PGLoadStmt);
-                    n->filename = (yyvsp[(2) - (2)].str);
-                    n->load_type = PG_LOAD_TYPE_INSTALL;
-                    (yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1212:
-#line 20 "third_party/libpg_query/grammar/statements/load.y"
-    {
-                      PGLoadStmt *n = makeNode(PGLoadStmt);
-                      n->filename = (yyvsp[(3) - (3)].str);
-                      n->load_type = PG_LOAD_TYPE_FORCE_INSTALL;
-                      (yyval.node) = (PGNode *)n;
-                ;}
-    break;
-
-  case 1213:
-#line 28 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1214:
-#line 29 "third_party/libpg_query/grammar/statements/load.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1215:
-#line 9 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_VACUUM;
-					if ((yyvsp[(2) - (4)].boolean))
-						n->options |= PG_VACOPT_FULL;
-					if ((yyvsp[(3) - (4)].boolean))
-						n->options |= PG_VACOPT_FREEZE;
-					if ((yyvsp[(4) - (4)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					n->relation = NULL;
-					n->va_cols = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1216:
-#line 23 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_VACUUM;
-					if ((yyvsp[(2) - (5)].boolean))
-						n->options |= PG_VACOPT_FULL;
-					if ((yyvsp[(3) - (5)].boolean))
-						n->options |= PG_VACOPT_FREEZE;
-					if ((yyvsp[(4) - (5)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					n->relation = (yyvsp[(5) - (5)].range);
-					n->va_cols = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1217:
-#line 37 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = (PGVacuumStmt *) (yyvsp[(5) - (5)].node);
-					n->options |= PG_VACOPT_VACUUM;
-					if ((yyvsp[(2) - (5)].boolean))
-						n->options |= PG_VACOPT_FULL;
-					if ((yyvsp[(3) - (5)].boolean))
-						n->options |= PG_VACOPT_FREEZE;
-					if ((yyvsp[(4) - (5)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1218:
-#line 49 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_VACUUM | (yyvsp[(3) - (4)].ival);
-					n->relation = NULL;
-					n->va_cols = NIL;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1219:
-#line 57 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_VACUUM | (yyvsp[(3) - (6)].ival);
-					n->relation = (yyvsp[(5) - (6)].range);
-					n->va_cols = (yyvsp[(6) - (6)].list);
-					if (n->va_cols != NIL)	/* implies analyze */
-						n->options |= PG_VACOPT_ANALYZE;
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1220:
-#line 70 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = PG_VACOPT_ANALYZE; ;}
-    break;
-
-  case 1221:
-#line 71 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = PG_VACOPT_VERBOSE; ;}
-    break;
-
-  case 1222:
-#line 72 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = PG_VACOPT_FREEZE; ;}
-    break;
-
-  case 1223:
-#line 73 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = PG_VACOPT_FULL; ;}
-    break;
-
-  case 1224:
-#line 75 "third_party/libpg_query/grammar/statements/vacuum.y"
-    {
-					if (strcmp((yyvsp[(1) - (1)].str), "disable_page_skipping") == 0)
-						(yyval.ival) = PG_VACOPT_DISABLE_PAGE_SKIPPING;
-					else
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_SYNTAX_ERROR),
-							 errmsg("unrecognized VACUUM option \"%s\"", (yyvsp[(1) - (1)].str)),
-									 parser_errposition((yylsp[(1) - (1)]))));
-				;}
-    break;
-
-  case 1225:
-#line 87 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1226:
-#line 88 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1227:
-#line 93 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;}
-    break;
-
-  case 1228:
-#line 94 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;}
-    break;
-
-  case 1229:
-#line 98 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1230:
-#line 99 "third_party/libpg_query/grammar/statements/vacuum.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1231:
-#line 9 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					PGDeleteStmt *n = makeNode(PGDeleteStmt);
-					n->relation = (yyvsp[(4) - (7)].range);
-					n->usingClause = (yyvsp[(5) - (7)].list);
-					n->whereClause = (yyvsp[(6) - (7)].node);
-					n->returningList = (yyvsp[(7) - (7)].list);
-					n->withClause = (yyvsp[(1) - (7)].with);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1232:
-#line 22 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					(yyval.range) = (yyvsp[(1) - (1)].range);
-				;}
-    break;
-
-  case 1233:
-#line 26 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					PGAlias *alias = makeNode(PGAlias);
-					alias->aliasname = (yyvsp[(2) - (2)].str);
-					(yyvsp[(1) - (2)].range)->alias = alias;
-					(yyval.range) = (yyvsp[(1) - (2)].range);
-				;}
-    break;
-
-  case 1234:
-#line 33 "third_party/libpg_query/grammar/statements/delete.y"
-    {
-					PGAlias *alias = makeNode(PGAlias);
-					alias->aliasname = (yyvsp[(3) - (3)].str);
-					(yyvsp[(1) - (3)].range)->alias = alias;
-					(yyval.range) = (yyvsp[(1) - (3)].range);
-				;}
-    break;
-
-  case 1235:
-#line 43 "third_party/libpg_query/grammar/statements/delete.y"
-    { (yyval.node) = (yyvsp[(2) - (2)].node); ;}
-    break;
-
-  case 1236:
-#line 44 "third_party/libpg_query/grammar/statements/delete.y"
-    { (yyval.node) = NULL; ;}
-    break;
-
-  case 1237:
-#line 50 "third_party/libpg_query/grammar/statements/delete.y"
-    { (yyval.list) = (yyvsp[(2) - (2)].list); ;}
-    break;
-
-  case 1238:
-#line 51 "third_party/libpg_query/grammar/statements/delete.y"
-    { (yyval.list) = NIL; ;}
-    break;
-
-  case 1239:
-#line 10 "third_party/libpg_query/grammar/statements/analyze.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_ANALYZE;
-					if ((yyvsp[(2) - (2)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					n->relation = NULL;
-					n->va_cols = NIL;
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1240:
-#line 20 "third_party/libpg_query/grammar/statements/analyze.y"
-    {
-					PGVacuumStmt *n = makeNode(PGVacuumStmt);
-					n->options = PG_VACOPT_ANALYZE;
-					if ((yyvsp[(2) - (4)].boolean))
-						n->options |= PG_VACOPT_VERBOSE;
-					n->relation = (yyvsp[(3) - (4)].range);
-					n->va_cols = (yyvsp[(4) - (4)].list);
-					(yyval.node) = (PGNode *)n;
-				;}
-    break;
-
-  case 1241:
-#line 2 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    { (yyval.node) = (PGNode *) (yyvsp[(2) - (2)].vsetstmt); ;}
-    break;
-
-  case 1242:
-#line 8 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_RESET;
-					n->name = (yyvsp[(1) - (1)].str);
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1243:
-#line 15 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_RESET_ALL;
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1244:
-#line 24 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    { (yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt); ;}
-    break;
-
-  case 1245:
-#line 26 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_RESET;
-					n->name = (char*) "timezone";
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1246:
-#line 33 "third_party/libpg_query/grammar/statements/variable_reset.y"
-    {
-					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
-					n->kind = VAR_RESET;
-					n->name = (char*) "transaction_isolation";
-					(yyval.vsetstmt) = n;
-				;}
-    break;
-
-  case 1247:
-#line 3 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowSelectStmt *n = makeNode(PGVariableShowSelectStmt);
-				n->stmt = (yyvsp[(2) - (2)].node);
-				n->name = (char*) "select";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1248:
-#line 10 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowSelectStmt *n = makeNode(PGVariableShowSelectStmt);
-				n->stmt = (yyvsp[(2) - (2)].node);
-				n->name = (char*) "select";
-				n->is_summary = 1;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1249:
-#line 18 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->name = (yyvsp[(2) - (2)].str);
-				n->is_summary = 1;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1250:
-#line 25 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->name = (yyvsp[(2) - (2)].str);
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1251:
-#line 32 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->name = (char*) "timezone";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1252:
-#line 39 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->name = (char*) "transaction_isolation";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1253:
-#line 46 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->name = (char*) "__show_tables_expanded";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1254:
-#line 53 "third_party/libpg_query/grammar/statements/variable_show.y"
-    {
-				PGVariableShowStmt *n = makeNode(PGVariableShowStmt);
-				n->name = (char*) "__show_tables_expanded";
-				n->is_summary = 0;
-				(yyval.node) = (PGNode *) n;
-			;}
-    break;
-
-  case 1257:
-#line 63 "third_party/libpg_query/grammar/statements/variable_show.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
-    break;
-
-  case 1258:
-#line 65 "third_party/libpg_query/grammar/statements/variable_show.y"
-    { (yyval.str) = psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;}
-    break;
-
-  case 1259:
-#line 7 "third_party/libpg_query/grammar/statements/call.y"
-    {
-					PGCallStmt *n = makeNode(PGCallStmt);
-					n->func = (yyvsp[(2) - (2)].node);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1260:
-#line 10 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(4) - (9)].range);
-					n->view->relpersistence = (yyvsp[(2) - (9)].ival);
-					n->aliases = (yyvsp[(5) - (9)].list);
-					n->query = (yyvsp[(8) - (9)].node);
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					n->options = (yyvsp[(6) - (9)].list);
-					n->withCheckOption = (yyvsp[(9) - (9)].viewcheckoption);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1261:
-#line 23 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(6) - (11)].range);
-					n->view->relpersistence = (yyvsp[(4) - (11)].ival);
-					n->aliases = (yyvsp[(7) - (11)].list);
-					n->query = (yyvsp[(10) - (11)].node);
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					n->options = (yyvsp[(8) - (11)].list);
-					n->withCheckOption = (yyvsp[(11) - (11)].viewcheckoption);
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1262:
-#line 36 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(5) - (12)].range);
-					n->view->relpersistence = (yyvsp[(2) - (12)].ival);
-					n->aliases = (yyvsp[(7) - (12)].list);
-					n->query = makeRecursiveViewSelect(n->view->relname, n->aliases, (yyvsp[(11) - (12)].node));
-					n->onconflict = PG_ERROR_ON_CONFLICT;
-					n->options = (yyvsp[(9) - (12)].list);
-					n->withCheckOption = (yyvsp[(12) - (12)].viewcheckoption);
-					if (n->withCheckOption != PG_NO_CHECK_OPTION)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("WITH CHECK OPTION not supported on recursive views"),
-								 parser_errposition((yylsp[(12) - (12)]))));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1263:
-#line 54 "third_party/libpg_query/grammar/statements/view.y"
-    {
-					PGViewStmt *n = makeNode(PGViewStmt);
-					n->view = (yyvsp[(7) - (14)].range);
-					n->view->relpersistence = (yyvsp[(4) - (14)].ival);
-					n->aliases = (yyvsp[(9) - (14)].list);
-					n->query = makeRecursiveViewSelect(n->view->relname, n->aliases, (yyvsp[(13) - (14)].node));
-					n->onconflict = PG_REPLACE_ON_CONFLICT;
-					n->options = (yyvsp[(11) - (14)].list);
-					n->withCheckOption = (yyvsp[(14) - (14)].viewcheckoption);
-					if (n->withCheckOption != PG_NO_CHECK_OPTION)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("WITH CHECK OPTION not supported on recursive views"),
-								 parser_errposition((yylsp[(14) - (14)]))));
-					(yyval.node) = (PGNode *) n;
-				;}
-    break;
-
-  case 1264:
-#line 74 "third_party/libpg_query/grammar/statements/view.y"
-    { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;}
-    break;
-
-  case 1265:
-#line 75 "third_party/libpg_query/grammar/statements/view.y"
-    { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;}
-    break;
-
-  case 1266:
-#line 76 "third_party/libpg_query/grammar/statements/view.y"
-    { (yyval.viewcheckoption) = PG_LOCAL_CHECK_OPTION; ;}
-    break;
-
-  case 1267:
-#line 77 "third_party/libpg_query/grammar/statements/view.y"
-    { (yyval.viewcheckoption) = PG_NO_CHECK_OPTION; ;}
-    break;
-
-  case 1268:
-#line 12 "third_party/libpg_query/grammar/statements/create_as.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					ctas->query = (yyvsp[(6) - (7)].node);
-					ctas->into = (yyvsp[(4) - (7)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_ERROR_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(4) - (7)].into)->rel->relpersistence = (yyvsp[(2) - (7)].ival);
-					(yyvsp[(4) - (7)].into)->skipData = !((yyvsp[(7) - (7)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 1269:
-#line 25 "third_party/libpg_query/grammar/statements/create_as.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					ctas->query = (yyvsp[(9) - (10)].node);
-					ctas->into = (yyvsp[(7) - (10)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_IGNORE_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(7) - (10)].into)->rel->relpersistence = (yyvsp[(2) - (10)].ival);
-					(yyvsp[(7) - (10)].into)->skipData = !((yyvsp[(10) - (10)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 1270:
-#line 38 "third_party/libpg_query/grammar/statements/create_as.y"
-    {
-					PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt);
-					ctas->query = (yyvsp[(8) - (9)].node);
-					ctas->into = (yyvsp[(6) - (9)].into);
-					ctas->relkind = PG_OBJECT_TABLE;
-					ctas->is_select_into = false;
-					ctas->onconflict = PG_REPLACE_ON_CONFLICT;
-					/* cram additional flags into the PGIntoClause */
-					(yyvsp[(6) - (9)].into)->rel->relpersistence = (yyvsp[(4) - (9)].ival);
-					(yyvsp[(6) - (9)].into)->skipData = !((yyvsp[(9) - (9)].boolean));
-					(yyval.node) = (PGNode *) ctas;
-				;}
-    break;
-
-  case 1271:
-#line 54 "third_party/libpg_query/grammar/statements/create_as.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1272:
-#line 55 "third_party/libpg_query/grammar/statements/create_as.y"
-    { (yyval.boolean) = false; ;}
-    break;
-
-  case 1273:
-#line 56 "third_party/libpg_query/grammar/statements/create_as.y"
-    { (yyval.boolean) = true; ;}
-    break;
-
-  case 1274:
-#line 62 "third_party/libpg_query/grammar/statements/create_as.y"
-    {
-					(yyval.into) = makeNode(PGIntoClause);
-					(yyval.into)->rel = (yyvsp[(1) - (4)].range);
-					(yyval.into)->colNames = (yyvsp[(2) - (4)].list);
-					(yyval.into)->options = (yyvsp[(3) - (4)].list);
-					(yyval.into)->onCommit = (yyvsp[(4) - (4)].oncommit);
-					(yyval.into)->viewQuery = NULL;
-					(yyval.into)->skipData = false;		/* might get changed later */
-				;}
-    break;
-
-
-/* Line 1267 of yacc.c.  */
-#line 25472 "third_party/libpg_query/grammar/grammar_out.cpp"
-      default: break;
-    }
-  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
-
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-
-  *++yyvsp = yyval;
-  *++yylsp = yyloc;
-
-  /* Now `shift' the result of the reduction.  Determine what state
-     that goes to, based on the state we popped back to and the rule
-     number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
-
-  goto yynewstate;
-
-
-/*------------------------------------.
-| yyerrlab -- here on detecting error |
-`------------------------------------*/
-yyerrlab:
-  /* If not already recovering from an error, report this error.  */
-  if (!yyerrstatus)
-    {
-      ++yynerrs;
-#if ! YYERROR_VERBOSE
-      yyerror (&yylloc, yyscanner, YY_("syntax error"));
-#else
-      {
-	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
-	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
-	  {
-	    YYSIZE_T yyalloc = 2 * yysize;
-	    if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
-	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
-	    if (yymsg != yymsgbuf)
-	      YYSTACK_FREE (yymsg);
-	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
-	    if (yymsg)
-	      yymsg_alloc = yyalloc;
-	    else
-	      {
-		yymsg = yymsgbuf;
-		yymsg_alloc = sizeof yymsgbuf;
-	      }
-	  }
-
-	if (0 < yysize && yysize <= yymsg_alloc)
-	  {
-	    (void) yysyntax_error (yymsg, yystate, yychar);
-	    yyerror (&yylloc, yyscanner, yymsg);
-	  }
-	else
-	  {
-	    yyerror (&yylloc, yyscanner, YY_("syntax error"));
-	    if (yysize != 0)
-	      goto yyexhaustedlab;
-	  }
-      }
-#endif
-    }
-
-  yyerror_range[0] = yylloc;
-
-  if (yyerrstatus == 3)
-    {
-      /* If just tried and failed to reuse look-ahead token after an
-	 error, discard it.  */
-
-      if (yychar <= YYEOF)
-	{
-	  /* Return failure if at end of input.  */
-	  if (yychar == YYEOF)
-	    YYABORT;
-	}
-      else
-	{
-	  yydestruct ("Error: discarding",
-		      yytoken, &yylval, &yylloc, yyscanner);
-	  yychar = YYEMPTY;
-	}
-    }
-
-  /* Else will try to reuse look-ahead token after shifting the error
-     token.  */
-  goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR.  |
-`---------------------------------------------------*/
-yyerrorlab:
-
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
-
-  yyerror_range[0] = yylsp[1-yylen];
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYERROR.  */
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-  yystate = *yyssp;
-  goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR.  |
-`-------------------------------------------------------------*/
-yyerrlab1:
-  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
-
-  for (;;)
-    {
-      yyn = yypact[yystate];
-      if (yyn != YYPACT_NINF)
-	{
-	  yyn += YYTERROR;
-	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
-	    {
-	      yyn = yytable[yyn];
-	      if (0 < yyn)
-		break;
-	    }
-	}
-
-      /* Pop the current state because it cannot handle the error token.  */
-      if (yyssp == yyss)
-	YYABORT;
-
-      yyerror_range[0] = *yylsp;
-      yydestruct ("Error: popping",
-		  yystos[yystate], yyvsp, yylsp, yyscanner);
-      YYPOPSTACK (1);
-      yystate = *yyssp;
-      YY_STACK_PRINT (yyss, yyssp);
-    }
-
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-  *++yyvsp = yylval;
-
-  yyerror_range[1] = yylloc;
-  /* Using YYLLOC is tempting, but would change the location of
-     the look-ahead.  YYLOC is available though.  */
-  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
-  *++yylsp = yyloc;
-
-  /* Shift the error token.  */
-  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
-
-  yystate = yyn;
-  goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here.  |
-`-------------------------------------*/
-yyacceptlab:
-  yyresult = 0;
-  goto yyreturn;
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here.  |
-`-----------------------------------*/
-yyabortlab:
-  yyresult = 1;
-  goto yyreturn;
-
-#ifndef yyoverflow
-/*-------------------------------------------------.
-| yyexhaustedlab -- memory exhaustion comes here.  |
-`-------------------------------------------------*/
-yyexhaustedlab:
-  yyerror (&yylloc, yyscanner, YY_("memory exhausted"));
-  yyresult = 2;
-  /* Fall through.  */
-#endif
-
-yyreturn:
-  if (yychar != YYEOF && yychar != YYEMPTY)
-     yydestruct ("Cleanup: discarding lookahead",
-		 yytoken, &yylval, &yylloc, yyscanner);
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYABORT or YYACCEPT.  */
-  YYPOPSTACK (yylen);
-  YY_STACK_PRINT (yyss, yyssp);
-  while (yyssp != yyss)
-    {
-      yydestruct ("Cleanup: popping",
-		  yystos[*yyssp], yyvsp, yylsp, yyscanner);
-      YYPOPSTACK (1);
-    }
-#ifndef yyoverflow
-  if (yyss != yyssa)
-    YYSTACK_FREE (yyss);
-#endif
-#if YYERROR_VERBOSE
-  if (yymsg != yymsgbuf)
-    YYSTACK_FREE (yymsg);
-#endif
-  /* Make sure YYID is used.  */
-  return YYID (yyresult);
-}
-
-
-#line 83 "third_party/libpg_query/grammar/statements/create_as.y"
-
-
-#line 1 "third_party/libpg_query/grammar/grammar.cpp"
-/*
- * The signature of this function is required by bison.  However, we
- * ignore the passed yylloc and instead use the last token position
- * available from the scanner.
- */
-static void
-base_yyerror(YYLTYPE *yylloc, core_yyscan_t yyscanner, const char *msg)
-{
-	parser_yyerror(msg);
-}
-
-static PGRawStmt *
-makeRawStmt(PGNode *stmt, int stmt_location)
-{
-	PGRawStmt    *rs = makeNode(PGRawStmt);
-
-	rs->stmt = stmt;
-	rs->stmt_location = stmt_location;
-	rs->stmt_len = 0;			/* might get changed later */
-	return rs;
-}
-
-/* Adjust a PGRawStmt to reflect that it doesn't run to the end of the string */
-static void
-updateRawStmtEnd(PGRawStmt *rs, int end_location)
-{
-	/*
-	 * If we already set the length, don't change it.  This is for situations
-	 * like "select foo ;; select bar" where the same statement will be last
-	 * in the string for more than one semicolon.
-	 */
-	if (rs->stmt_len > 0)
-		return;
-
-	/* OK, update length of PGRawStmt */
-	rs->stmt_len = end_location - rs->stmt_location;
-}
-
-static PGNode *
-makeColumnRef(char *colname, PGList *indirection,
-			  int location, core_yyscan_t yyscanner)
-{
-	/*
-	 * Generate a PGColumnRef node, with an PGAIndirection node added if there
-	 * is any subscripting in the specified indirection list.  However,
-	 * any field selection at the start of the indirection list must be
-	 * transposed into the "fields" part of the PGColumnRef node.
-	 */
-	PGColumnRef  *c = makeNode(PGColumnRef);
-	int		nfields = 0;
-	PGListCell *l;
-
-	c->location = location;
-	foreach(l, indirection)
-	{
-		if (IsA(lfirst(l), PGAIndices))
-		{
-			PGAIndirection *i = makeNode(PGAIndirection);
-
-			if (nfields == 0)
-			{
-				/* easy case - all indirection goes to PGAIndirection */
-				c->fields = list_make1(makeString(colname));
-				i->indirection = check_indirection(indirection, yyscanner);
-			}
-			else
-			{
-				/* got to split the list in two */
-				i->indirection = check_indirection(list_copy_tail(indirection,
-																  nfields),
-												   yyscanner);
-				indirection = list_truncate(indirection, nfields);
-				c->fields = lcons(makeString(colname), indirection);
-			}
-			i->arg = (PGNode *) c;
-			return (PGNode *) i;
-		}
-		else if (IsA(lfirst(l), PGAStar))
-		{
-			/* We only allow '*' at the end of a PGColumnRef */
-			if (lnext(l) != NULL)
-				parser_yyerror("improper use of \"*\"");
-		}
-		nfields++;
-	}
-	/* No subscripting, so all indirection gets added to field list */
-	c->fields = lcons(makeString(colname), indirection);
-	return (PGNode *) c;
-}
-
-static PGNode *
-makeTypeCast(PGNode *arg, PGTypeName *tpname, int trycast, int location)
-{
-	PGTypeCast *n = makeNode(PGTypeCast);
-	n->arg = arg;
-	n->typeName = tpname;
-	n->tryCast = trycast;
-	n->location = location;
-	return (PGNode *) n;
-}
-
-static PGNode *
-makeStringConst(char *str, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGString;
-	n->val.val.str = str;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeStringConstCast(char *str, int location, PGTypeName *tpname)
-{
-	PGNode *s = makeStringConst(str, location);
-
-	return makeTypeCast(s, tpname, 0, -1);
-}
-
-static PGNode *
-makeIntervalNode(char *str, int location, PGList *typmods) {
-	PGIntervalConstant *n = makeNode(PGIntervalConstant);
-
-	n->val_type = T_PGString;
-	n->sval = str;
-	n->location = location;
-	n->typmods = typmods;
-
-	return (PGNode *)n;
-
-}
-
-static PGNode *
-makeIntervalNode(int val, int location, PGList *typmods) {
-	PGIntervalConstant *n = makeNode(PGIntervalConstant);
-
-	n->val_type = T_PGInteger;
-	n->ival = val;
-	n->location = location;
-	n->typmods = typmods;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeIntervalNode(PGNode *arg, int location, PGList *typmods) {
-	PGIntervalConstant *n = makeNode(PGIntervalConstant);
-
-	n->val_type = T_PGAExpr;
-	n->eval = arg;
-	n->location = location;
-	n->typmods = typmods;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeSampleSize(PGValue *sample_size, bool is_percentage) {
-	PGSampleSize *n = makeNode(PGSampleSize);
-
-	n->sample_size = *sample_size;
-	n->is_percentage = is_percentage;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeSampleOptions(PGNode *sample_size, char *method, int seed, int location) {
-	PGSampleOptions *n = makeNode(PGSampleOptions);
-
-	n->sample_size = sample_size;
-	n->method = method;
-	n->seed = seed;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-/* makeLimitPercent()
- * Make limit percent node
- */
-static PGNode *
-makeLimitPercent(PGNode *limit_percent) {
-	PGLimitPercent *n = makeNode(PGLimitPercent);
-
-	n->limit_percent = limit_percent;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeIntConst(int val, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGInteger;
-	n->val.val.ival = val;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeFloatConst(char *str, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGFloat;
-	n->val.val.str = str;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeBitStringConst(char *str, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGBitString;
-	n->val.val.str = str;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeNullAConst(int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGNull;
-	n->location = location;
-
-	return (PGNode *)n;
-}
-
-static PGNode *
-makeAConst(PGValue *v, int location)
-{
-	PGNode *n;
-
-	switch (v->type)
-	{
-		case T_PGFloat:
-			n = makeFloatConst(v->val.str, location);
-			break;
-
-		case T_PGInteger:
-			n = makeIntConst(v->val.ival, location);
-			break;
-
-		case T_PGString:
-		default:
-			n = makeStringConst(v->val.str, location);
-			break;
-	}
-
-	return n;
-}
-
-/* makeBoolAConst()
- * Create an PGAConst string node and put it inside a boolean cast.
- */
-static PGNode *
-makeBoolAConst(bool state, int location)
-{
-	PGAConst *n = makeNode(PGAConst);
-
-	n->val.type = T_PGString;
-	n->val.val.str = (state ? (char*) "t" : (char*) "f");
-	n->location = location;
-
-	return makeTypeCast((PGNode *)n, SystemTypeName("bool"), 0, -1);
-}
-
-/* check_qualified_name --- check the result of qualified_name production
- *
- * It's easiest to let the grammar production for qualified_name allow
- * subscripts and '*', which we then must reject here.
- */
-static void
-check_qualified_name(PGList *names, core_yyscan_t yyscanner)
-{
-	PGListCell   *i;
-
-	foreach(i, names)
-	{
-		if (!IsA(lfirst(i), PGString))
-			parser_yyerror("syntax error");
-	}
-}
-
-/* check_func_name --- check the result of func_name production
- *
- * It's easiest to let the grammar production for func_name allow subscripts
- * and '*', which we then must reject here.
- */
-static PGList *
-check_func_name(PGList *names, core_yyscan_t yyscanner)
-{
-	PGListCell   *i;
-
-	foreach(i, names)
-	{
-		if (!IsA(lfirst(i), PGString))
-			parser_yyerror("syntax error");
-	}
-	return names;
-}
-
-/* check_indirection --- check the result of indirection production
- *
- * We only allow '*' at the end of the list, but it's hard to enforce that
- * in the grammar, so do it here.
- */
-static PGList *
-check_indirection(PGList *indirection, core_yyscan_t yyscanner)
-{
-	PGListCell *l;
-
-	foreach(l, indirection)
-	{
-		if (IsA(lfirst(l), PGAStar))
-		{
-			if (lnext(l) != NULL)
-				parser_yyerror("improper use of \"*\"");
-		}
-	}
-	return indirection;
-}
-
-/* makeParamRef
- * Creates a new PGParamRef node
- */
-static PGNode* makeParamRef(int number, int location)
-{
-	PGParamRef *p = makeNode(PGParamRef);
-	p->number = number;
-	p->location = location;
-	return (PGNode *) p;
-}
-
-
-/* insertSelectOptions()
- * Insert ORDER BY, etc into an already-constructed SelectStmt.
- *
- * This routine is just to avoid duplicating code in PGSelectStmt productions.
- */
-static void
-insertSelectOptions(PGSelectStmt *stmt,
-					PGList *sortClause, PGList *lockingClause,
-					PGNode *limitOffset, PGNode *limitCount,
-					PGWithClause *withClause,
-					core_yyscan_t yyscanner)
-{
-	Assert(IsA(stmt, PGSelectStmt));
-
-	/*
-	 * Tests here are to reject constructs like
-	 *	(SELECT foo ORDER BY bar) ORDER BY baz
-	 */
-	if (sortClause)
-	{
-		if (stmt->sortClause)
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_SYNTAX_ERROR),
-					 errmsg("multiple ORDER BY clauses not allowed"),
-					 parser_errposition(exprLocation((PGNode *) sortClause))));
-		stmt->sortClause = sortClause;
-	}
-	/* We can handle multiple locking clauses, though */
-	stmt->lockingClause = list_concat(stmt->lockingClause, lockingClause);
-	if (limitOffset)
-	{
-		if (stmt->limitOffset)
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_SYNTAX_ERROR),
-					 errmsg("multiple OFFSET clauses not allowed"),
-					 parser_errposition(exprLocation(limitOffset))));
-		stmt->limitOffset = limitOffset;
-	}
-	if (limitCount)
-	{
-		if (stmt->limitCount)
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_SYNTAX_ERROR),
-					 errmsg("multiple LIMIT clauses not allowed"),
-					 parser_errposition(exprLocation(limitCount))));
-		stmt->limitCount = limitCount;
-	}
-	if (withClause)
-	{
-		if (stmt->withClause)
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_SYNTAX_ERROR),
-					 errmsg("multiple WITH clauses not allowed"),
-					 parser_errposition(exprLocation((PGNode *) withClause))));
-		stmt->withClause = withClause;
-	}
-}
-
-static PGNode *
-makeSetOp(PGSetOperation op, bool all, PGNode *larg, PGNode *rarg)
-{
-	PGSelectStmt *n = makeNode(PGSelectStmt);
-
-	n->op = op;
-	n->all = all;
-	n->larg = (PGSelectStmt *) larg;
-	n->rarg = (PGSelectStmt *) rarg;
-	return (PGNode *) n;
-}
-
-/* SystemFuncName()
- * Build a properly-qualified reference to a built-in function.
- */
-PGList *
-SystemFuncName(const char *name)
-{
-	return list_make2(makeString(DEFAULT_SCHEMA), makeString(name));
-}
-
-/* SystemTypeName()
- * Build a properly-qualified reference to a built-in type.
- *
- * typmod is defaulted, but may be changed afterwards by caller.
- * Likewise for the location.
- */
-PGTypeName *
-SystemTypeName(const char *name)
-{
-	return makeTypeNameFromNameList(list_make2(makeString(DEFAULT_SCHEMA),
-											   makeString(name)));
-}
-
-/* doNegate()
- * Handle negation of a numeric constant.
- *
- * Formerly, we did this here because the optimizer couldn't cope with
- * indexquals that looked like "var = -4" --- it wants "var = const"
- * and a unary minus operator applied to a constant didn't qualify.
- * As of Postgres 7.0, that problem doesn't exist anymore because there
- * is a constant-subexpression simplifier in the optimizer.  However,
- * there's still a good reason for doing this here, which is that we can
- * postpone committing to a particular internal representation for simple
- * negative constants.	It's better to leave "-123.456" in string form
- * until we know what the desired type is.
- */
-static PGNode *
-doNegate(PGNode *n, int location)
-{
-	if (IsA(n, PGAConst))
-	{
-		PGAConst *con = (PGAConst *)n;
-
-		/* report the constant's location as that of the '-' sign */
-		con->location = location;
-
-		if (con->val.type == T_PGInteger)
-		{
-			con->val.val.ival = -con->val.val.ival;
-			return n;
-		}
-		if (con->val.type == T_PGFloat)
-		{
-			doNegateFloat(&con->val);
-			return n;
-		}
-	}
-
-	return (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", NULL, n, location);
-}
-
-static void
-doNegateFloat(PGValue *v)
-{
-	char   *oldval = v->val.str;
-
-	Assert(IsA(v, PGFloat));
-	if (*oldval == '+')
-		oldval++;
-	if (*oldval == '-')
-		v->val.str = oldval+1;	/* just strip the '-' */
-	else
-		v->val.str = psprintf("-%s", oldval);
-}
-
-static PGNode *
-makeAndExpr(PGNode *lexpr, PGNode *rexpr, int location)
-{
-	PGNode	   *lexp = lexpr;
-
-	/* Look through AEXPR_PAREN nodes so they don't affect flattening */
-	while (IsA(lexp, PGAExpr) &&
-		   ((PGAExpr *) lexp)->kind == AEXPR_PAREN)
-		lexp = ((PGAExpr *) lexp)->lexpr;
-	/* Flatten "a AND b AND c ..." to a single PGBoolExpr on sight */
-	if (IsA(lexp, PGBoolExpr))
-	{
-		PGBoolExpr *blexpr = (PGBoolExpr *) lexp;
-
-		if (blexpr->boolop == PG_AND_EXPR)
-		{
-			blexpr->args = lappend(blexpr->args, rexpr);
-			return (PGNode *) blexpr;
-		}
-	}
-	return (PGNode *) makeBoolExpr(PG_AND_EXPR, list_make2(lexpr, rexpr), location);
-}
-
-static PGNode *
-makeOrExpr(PGNode *lexpr, PGNode *rexpr, int location)
-{
-	PGNode	   *lexp = lexpr;
-
-	/* Look through AEXPR_PAREN nodes so they don't affect flattening */
-	while (IsA(lexp, PGAExpr) &&
-		   ((PGAExpr *) lexp)->kind == AEXPR_PAREN)
-		lexp = ((PGAExpr *) lexp)->lexpr;
-	/* Flatten "a OR b OR c ..." to a single PGBoolExpr on sight */
-	if (IsA(lexp, PGBoolExpr))
-	{
-		PGBoolExpr *blexpr = (PGBoolExpr *) lexp;
-
-		if (blexpr->boolop == PG_OR_EXPR)
-		{
-			blexpr->args = lappend(blexpr->args, rexpr);
-			return (PGNode *) blexpr;
-		}
-	}
-	return (PGNode *) makeBoolExpr(PG_OR_EXPR, list_make2(lexpr, rexpr), location);
-}
-
-static PGNode *
-makeNotExpr(PGNode *expr, int location)
-{
-	return (PGNode *) makeBoolExpr(PG_NOT_EXPR, list_make1(expr), location);
-}
-
-static PGNode *
-makeSQLValueFunction(PGSQLValueFunctionOp op, int32_t typmod, int location)
-{
-	PGSQLValueFunction *svf = makeNode(PGSQLValueFunction);
-
-	svf->op = op;
-	/* svf->type will be filled during parse analysis */
-	svf->typmod = typmod;
-	svf->location = location;
-	return (PGNode *) svf;
-}
-
-/* Separate PGConstraint nodes from COLLATE clauses in a */
-static void
-SplitColQualList(PGList *qualList,
-				 PGList **constraintList, PGCollateClause **collClause,
-				 core_yyscan_t yyscanner)
-{
-	PGListCell   *cell;
-	PGListCell   *prev;
-	PGListCell   *next;
-
-	*collClause = NULL;
-	prev = NULL;
-	for (cell = list_head(qualList); cell; cell = next)
-	{
-		PGNode   *n = (PGNode *) lfirst(cell);
-
-		next = lnext(cell);
-		if (IsA(n, PGConstraint))
-		{
-			/* keep it in list */
-			prev = cell;
-			continue;
-		}
-		if (IsA(n, PGCollateClause))
-		{
-			PGCollateClause *c = (PGCollateClause *) n;
-
-			if (*collClause)
-				ereport(ERROR,
-						(errcode(PG_ERRCODE_SYNTAX_ERROR),
-						 errmsg("multiple COLLATE clauses not allowed"),
-						 parser_errposition(c->location)));
-			*collClause = c;
-		}
-		else
-			elog(ERROR, "unexpected node type %d", (int) n->type);
-		/* remove non-Constraint nodes from qualList */
-		qualList = list_delete_cell(qualList, cell, prev);
-	}
-	*constraintList = qualList;
-}
-
-/*
- * Process result of ConstraintAttributeSpec, and set appropriate bool flags
- * in the output command node.  Pass NULL for any flags the particular
- * command doesn't support.
- */
-static void
-processCASbits(int cas_bits, int location, const char *constrType,
-			   bool *deferrable, bool *initdeferred, bool *not_valid,
-			   bool *no_inherit, core_yyscan_t yyscanner)
-{
-	/* defaults */
-	if (deferrable)
-		*deferrable = false;
-	if (initdeferred)
-		*initdeferred = false;
-	if (not_valid)
-		*not_valid = false;
-
-	if (cas_bits & (CAS_DEFERRABLE | CAS_INITIALLY_DEFERRED))
-	{
-		if (deferrable)
-			*deferrable = true;
-		else
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-					 /* translator: %s is CHECK, UNIQUE, or similar */
-					 errmsg("%s constraints cannot be marked DEFERRABLE",
-							constrType),
-					 parser_errposition(location)));
-	}
-
-	if (cas_bits & CAS_INITIALLY_DEFERRED)
-	{
-		if (initdeferred)
-			*initdeferred = true;
-		else
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-					 /* translator: %s is CHECK, UNIQUE, or similar */
-					 errmsg("%s constraints cannot be marked DEFERRABLE",
-							constrType),
-					 parser_errposition(location)));
-	}
-
-	if (cas_bits & CAS_NOT_VALID)
-	{
-		if (not_valid)
-			*not_valid = true;
-		else
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-					 /* translator: %s is CHECK, UNIQUE, or similar */
-					 errmsg("%s constraints cannot be marked NOT VALID",
-							constrType),
-					 parser_errposition(location)));
-	}
-
-	if (cas_bits & CAS_NO_INHERIT)
-	{
-		if (no_inherit)
-			*no_inherit = true;
-		else
-			ereport(ERROR,
-					(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-					 /* translator: %s is CHECK, UNIQUE, or similar */
-					 errmsg("%s constraints cannot be marked NO INHERIT",
-							constrType),
-					 parser_errposition(location)));
-	}
-}
-
-/*----------
- * Recursive view transformation
- *
- * Convert
- *
- *     CREATE RECURSIVE VIEW relname (aliases) AS query
- *
- * to
- *
- *     CREATE VIEW relname (aliases) AS
- *         WITH RECURSIVE relname (aliases) AS (query)
- *         SELECT aliases FROM relname
- *
- * Actually, just the WITH ... part, which is then inserted into the original
- * view as the query.
- * ----------
- */
-static PGNode *
-makeRecursiveViewSelect(char *relname, PGList *aliases, PGNode *query)
-{
-	PGSelectStmt *s = makeNode(PGSelectStmt);
-	PGWithClause *w = makeNode(PGWithClause);
-	PGCommonTableExpr *cte = makeNode(PGCommonTableExpr);
-	PGList	   *tl = NIL;
-	PGListCell   *lc;
-
-	/* create common table expression */
-	cte->ctename = relname;
-	cte->aliascolnames = aliases;
-	cte->ctequery = query;
-	cte->location = -1;
-
-	/* create WITH clause and attach CTE */
-	w->recursive = true;
-	w->ctes = list_make1(cte);
-	w->location = -1;
-
-	/* create target list for the new SELECT from the alias list of the
-	 * recursive view specification */
-	foreach (lc, aliases)
-	{
-		PGResTarget *rt = makeNode(PGResTarget);
-
-		rt->name = NULL;
-		rt->indirection = NIL;
-		rt->val = makeColumnRef(strVal(lfirst(lc)), NIL, -1, 0);
-		rt->location = -1;
-
-		tl = lappend(tl, rt);
-	}
-
-	/* create new SELECT combining WITH clause, target list, and fake FROM
-	 * clause */
-	s->withClause = w;
-	s->targetList = tl;
-	s->fromClause = list_make1(makeRangeVar(NULL, relname, -1));
-
-	return (PGNode *) s;
-}
-
-/* parser_init()
- * Initialize to parse one query string
- */
-void
-parser_init(base_yy_extra_type *yyext)
-{
-	yyext->parsetree = NIL;		/* in case grammar forgets to set it */
-}
-
-#undef yyparse
-#undef yylex
-#undef yyerror
-#undef yylval
-#undef yychar
-#undef yydebug
-#undef yynerrs
-#undef yylloc
-
-} // namespace duckdb_libpgquery
-
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - raw_parser
- * - base_yylex
- * - raw_parser
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * parser.c
- *		Main entry point/driver for PostgreSQL grammar
- *
- * Note that the grammar is not allowed to perform any table access
- * (since we need to be able to do basic parsing even while inside an
- * aborted transaction).  Therefore, the data structures returned by
- * the grammar are "raw" parsetrees that still need to be analyzed by
- * analyze.c and related files.
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * IDENTIFICATION
- *	  src/backend/parser/parser.c
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-
-namespace duckdb_libpgquery {
-#define PG_KEYWORD(a,b,c) {a,b,c},
-
-const PGScanKeyword ScanKeywords[] = {
-PG_KEYWORD("abort", ABORT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("absolute", ABSOLUTE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("access", ACCESS, UNRESERVED_KEYWORD)
-PG_KEYWORD("action", ACTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("add", ADD_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("admin", ADMIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("after", AFTER, UNRESERVED_KEYWORD)
-PG_KEYWORD("aggregate", AGGREGATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("all", ALL, RESERVED_KEYWORD)
-PG_KEYWORD("also", ALSO, UNRESERVED_KEYWORD)
-PG_KEYWORD("alter", ALTER, UNRESERVED_KEYWORD)
-PG_KEYWORD("always", ALWAYS, UNRESERVED_KEYWORD)
-PG_KEYWORD("analyse", ANALYSE, RESERVED_KEYWORD)
-PG_KEYWORD("analyze", ANALYZE, RESERVED_KEYWORD)
-PG_KEYWORD("and", AND, RESERVED_KEYWORD)
-PG_KEYWORD("any", ANY, RESERVED_KEYWORD)
-PG_KEYWORD("array", ARRAY, RESERVED_KEYWORD)
-PG_KEYWORD("as", AS, RESERVED_KEYWORD)
-PG_KEYWORD("asc", ASC_P, RESERVED_KEYWORD)
-PG_KEYWORD("assertion", ASSERTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("assignment", ASSIGNMENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("asymmetric", ASYMMETRIC, RESERVED_KEYWORD)
-PG_KEYWORD("at", AT, UNRESERVED_KEYWORD)
-PG_KEYWORD("attach", ATTACH, UNRESERVED_KEYWORD)
-PG_KEYWORD("attribute", ATTRIBUTE, UNRESERVED_KEYWORD)
-PG_KEYWORD("authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("backward", BACKWARD, UNRESERVED_KEYWORD)
-PG_KEYWORD("before", BEFORE, UNRESERVED_KEYWORD)
-PG_KEYWORD("begin", BEGIN_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("between", BETWEEN, COL_NAME_KEYWORD)
-PG_KEYWORD("bigint", BIGINT, COL_NAME_KEYWORD)
-PG_KEYWORD("binary", BINARY, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("bit", BIT, COL_NAME_KEYWORD)
-PG_KEYWORD("boolean", BOOLEAN_P, COL_NAME_KEYWORD)
-PG_KEYWORD("both", BOTH, RESERVED_KEYWORD)
-PG_KEYWORD("by", BY, UNRESERVED_KEYWORD)
-PG_KEYWORD("cache", CACHE, UNRESERVED_KEYWORD)
-PG_KEYWORD("call", CALL_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("called", CALLED, UNRESERVED_KEYWORD)
-PG_KEYWORD("cascade", CASCADE, UNRESERVED_KEYWORD)
-PG_KEYWORD("cascaded", CASCADED, UNRESERVED_KEYWORD)
-PG_KEYWORD("case", CASE, RESERVED_KEYWORD)
-PG_KEYWORD("cast", CAST, RESERVED_KEYWORD)
-PG_KEYWORD("catalog", CATALOG_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("chain", CHAIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("char", CHAR_P, COL_NAME_KEYWORD)
-PG_KEYWORD("character", CHARACTER, COL_NAME_KEYWORD)
-PG_KEYWORD("characteristics", CHARACTERISTICS, UNRESERVED_KEYWORD)
-PG_KEYWORD("check", CHECK_P, RESERVED_KEYWORD)
-PG_KEYWORD("checkpoint", CHECKPOINT, UNRESERVED_KEYWORD)
-PG_KEYWORD("class", CLASS, UNRESERVED_KEYWORD)
-PG_KEYWORD("close", CLOSE, UNRESERVED_KEYWORD)
-PG_KEYWORD("cluster", CLUSTER, UNRESERVED_KEYWORD)
-PG_KEYWORD("coalesce", COALESCE, COL_NAME_KEYWORD)
-PG_KEYWORD("collate", COLLATE, RESERVED_KEYWORD)
-PG_KEYWORD("collation", COLLATION, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("column", COLUMN, RESERVED_KEYWORD)
-PG_KEYWORD("columns", COLUMNS, UNRESERVED_KEYWORD)
-PG_KEYWORD("comment", COMMENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("comments", COMMENTS, UNRESERVED_KEYWORD)
-PG_KEYWORD("commit", COMMIT, UNRESERVED_KEYWORD)
-PG_KEYWORD("committed", COMMITTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("compression", COMPRESSION, UNRESERVED_KEYWORD)
-PG_KEYWORD("concurrently", CONCURRENTLY, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("configuration", CONFIGURATION, UNRESERVED_KEYWORD)
-PG_KEYWORD("conflict", CONFLICT, UNRESERVED_KEYWORD)
-PG_KEYWORD("connection", CONNECTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("constraint", CONSTRAINT, RESERVED_KEYWORD)
-PG_KEYWORD("constraints", CONSTRAINTS, UNRESERVED_KEYWORD)
-PG_KEYWORD("content", CONTENT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("continue", CONTINUE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("conversion", CONVERSION_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("copy", COPY, UNRESERVED_KEYWORD)
-PG_KEYWORD("cost", COST, UNRESERVED_KEYWORD)
-PG_KEYWORD("create", CREATE_P, RESERVED_KEYWORD)
-PG_KEYWORD("cross", CROSS, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("csv", CSV, UNRESERVED_KEYWORD)
-PG_KEYWORD("cube", CUBE, UNRESERVED_KEYWORD)
-PG_KEYWORD("current", CURRENT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("current_catalog", CURRENT_CATALOG, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("current_date", CURRENT_DATE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("current_role", CURRENT_ROLE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("current_schema", CURRENT_SCHEMA, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("current_time", CURRENT_TIME, RESERVED_KEYWORD)
-PG_KEYWORD("current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD)
-PG_KEYWORD("current_user", CURRENT_USER, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("cursor", CURSOR, UNRESERVED_KEYWORD)
-PG_KEYWORD("cycle", CYCLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("data", DATA_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("database", DATABASE, UNRESERVED_KEYWORD)
-PG_KEYWORD("day", DAY_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("days", DAYS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("deallocate", DEALLOCATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("dec", DEC, COL_NAME_KEYWORD)
-PG_KEYWORD("decimal", DECIMAL_P, COL_NAME_KEYWORD)
-PG_KEYWORD("declare", DECLARE, UNRESERVED_KEYWORD)
-PG_KEYWORD("default", DEFAULT, RESERVED_KEYWORD)
-PG_KEYWORD("defaults", DEFAULTS, UNRESERVED_KEYWORD)
-PG_KEYWORD("deferrable", DEFERRABLE, RESERVED_KEYWORD)
-PG_KEYWORD("deferred", DEFERRED, UNRESERVED_KEYWORD)
-PG_KEYWORD("definer", DEFINER, UNRESERVED_KEYWORD)
-PG_KEYWORD("delete", DELETE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("delimiter", DELIMITER, UNRESERVED_KEYWORD)
-PG_KEYWORD("delimiters", DELIMITERS, UNRESERVED_KEYWORD)
-PG_KEYWORD("depends", DEPENDS, UNRESERVED_KEYWORD)
-PG_KEYWORD("desc", DESC_P, RESERVED_KEYWORD)
-PG_KEYWORD("describe", DESCRIBE, UNRESERVED_KEYWORD)
-PG_KEYWORD("detach", DETACH, UNRESERVED_KEYWORD)
-PG_KEYWORD("dictionary", DICTIONARY, UNRESERVED_KEYWORD)
-PG_KEYWORD("disable", DISABLE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("discard", DISCARD, UNRESERVED_KEYWORD)
-PG_KEYWORD("distinct", DISTINCT, RESERVED_KEYWORD)
-PG_KEYWORD("do", DO, RESERVED_KEYWORD)
-PG_KEYWORD("document", DOCUMENT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("domain", DOMAIN_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("double", DOUBLE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("drop", DROP, UNRESERVED_KEYWORD)
-PG_KEYWORD("each", EACH, UNRESERVED_KEYWORD)
-PG_KEYWORD("else", ELSE, RESERVED_KEYWORD)
-PG_KEYWORD("enable", ENABLE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("encoding", ENCODING, UNRESERVED_KEYWORD)
-PG_KEYWORD("encrypted", ENCRYPTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("end", END_P, RESERVED_KEYWORD)
-PG_KEYWORD("enum", ENUM_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("escape", ESCAPE, UNRESERVED_KEYWORD)
-PG_KEYWORD("event", EVENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("except", EXCEPT, RESERVED_KEYWORD)
-PG_KEYWORD("exclude", EXCLUDE, UNRESERVED_KEYWORD)
-PG_KEYWORD("excluding", EXCLUDING, UNRESERVED_KEYWORD)
-PG_KEYWORD("exclusive", EXCLUSIVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("execute", EXECUTE, UNRESERVED_KEYWORD)
-PG_KEYWORD("exists", EXISTS, COL_NAME_KEYWORD)
-PG_KEYWORD("explain", EXPLAIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("export", EXPORT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("export_state", EXPORT_STATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("extension", EXTENSION, UNRESERVED_KEYWORD)
-PG_KEYWORD("external", EXTERNAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("extract", EXTRACT, COL_NAME_KEYWORD)
-PG_KEYWORD("false", FALSE_P, RESERVED_KEYWORD)
-PG_KEYWORD("family", FAMILY, UNRESERVED_KEYWORD)
-PG_KEYWORD("fetch", FETCH, RESERVED_KEYWORD)
-PG_KEYWORD("filter", FILTER, UNRESERVED_KEYWORD)
-PG_KEYWORD("first", FIRST_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("float", FLOAT_P, COL_NAME_KEYWORD)
-PG_KEYWORD("following", FOLLOWING, UNRESERVED_KEYWORD)
-PG_KEYWORD("for", FOR, RESERVED_KEYWORD)
-PG_KEYWORD("force", FORCE, UNRESERVED_KEYWORD)
-PG_KEYWORD("foreign", FOREIGN, RESERVED_KEYWORD)
-PG_KEYWORD("forward", FORWARD, UNRESERVED_KEYWORD)
-PG_KEYWORD("freeze", FREEZE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("from", FROM, RESERVED_KEYWORD)
-PG_KEYWORD("full", FULL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("function", FUNCTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("functions", FUNCTIONS, UNRESERVED_KEYWORD)
-PG_KEYWORD("generated", GENERATED, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("glob", GLOB, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("global", GLOBAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("grant", GRANT, RESERVED_KEYWORD)
-PG_KEYWORD("granted", GRANTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("group", GROUP_P, RESERVED_KEYWORD)
-PG_KEYWORD("grouping", GROUPING, COL_NAME_KEYWORD)
-PG_KEYWORD("grouping_id", GROUPING_ID, COL_NAME_KEYWORD)
-PG_KEYWORD("handler", HANDLER, UNRESERVED_KEYWORD)
-PG_KEYWORD("having", HAVING, RESERVED_KEYWORD)
-PG_KEYWORD("header", HEADER_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("hold", HOLD, UNRESERVED_KEYWORD)
-PG_KEYWORD("hour", HOUR_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("hours", HOURS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("identity", IDENTITY_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("if", IF_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("ignore", IGNORE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("ilike", ILIKE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("immediate", IMMEDIATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("immutable", IMMUTABLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("implicit", IMPLICIT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("import", IMPORT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("in", IN_P, RESERVED_KEYWORD)
-PG_KEYWORD("including", INCLUDING, UNRESERVED_KEYWORD)
-PG_KEYWORD("increment", INCREMENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("index", INDEX, UNRESERVED_KEYWORD)
-PG_KEYWORD("indexes", INDEXES, UNRESERVED_KEYWORD)
-PG_KEYWORD("inherit", INHERIT, UNRESERVED_KEYWORD)
-PG_KEYWORD("inherits", INHERITS, UNRESERVED_KEYWORD)
-PG_KEYWORD("initially", INITIALLY, RESERVED_KEYWORD)
-PG_KEYWORD("inline", INLINE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("inner", INNER_P, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("inout", INOUT, COL_NAME_KEYWORD)
-PG_KEYWORD("input", INPUT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("insensitive", INSENSITIVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("insert", INSERT, UNRESERVED_KEYWORD)
-PG_KEYWORD("install", INSTALL, UNRESERVED_KEYWORD)
-PG_KEYWORD("instead", INSTEAD, UNRESERVED_KEYWORD)
-PG_KEYWORD("int", INT_P, COL_NAME_KEYWORD)
-PG_KEYWORD("integer", INTEGER, COL_NAME_KEYWORD)
-PG_KEYWORD("intersect", INTERSECT, RESERVED_KEYWORD)
-PG_KEYWORD("interval", INTERVAL, COL_NAME_KEYWORD)
-PG_KEYWORD("into", INTO, RESERVED_KEYWORD)
-PG_KEYWORD("invoker", INVOKER, UNRESERVED_KEYWORD)
-PG_KEYWORD("is", IS, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("isnull", ISNULL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("isolation", ISOLATION, UNRESERVED_KEYWORD)
-PG_KEYWORD("join", JOIN, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("json", JSON, UNRESERVED_KEYWORD)
-PG_KEYWORD("key", KEY, UNRESERVED_KEYWORD)
-PG_KEYWORD("label", LABEL, UNRESERVED_KEYWORD)
-PG_KEYWORD("language", LANGUAGE, UNRESERVED_KEYWORD)
-PG_KEYWORD("large", LARGE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("last", LAST_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("lateral", LATERAL_P, RESERVED_KEYWORD)
-PG_KEYWORD("leading", LEADING, RESERVED_KEYWORD)
-PG_KEYWORD("leakproof", LEAKPROOF, UNRESERVED_KEYWORD)
-PG_KEYWORD("left", LEFT, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("level", LEVEL, UNRESERVED_KEYWORD)
-PG_KEYWORD("like", LIKE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("limit", LIMIT, RESERVED_KEYWORD)
-PG_KEYWORD("listen", LISTEN, UNRESERVED_KEYWORD)
-PG_KEYWORD("load", LOAD, UNRESERVED_KEYWORD)
-PG_KEYWORD("local", LOCAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("localtime", LOCALTIME, RESERVED_KEYWORD)
-PG_KEYWORD("localtimestamp", LOCALTIMESTAMP, RESERVED_KEYWORD)
-PG_KEYWORD("location", LOCATION, UNRESERVED_KEYWORD)
-PG_KEYWORD("lock", LOCK_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("locked", LOCKED, UNRESERVED_KEYWORD)
-PG_KEYWORD("logged", LOGGED, UNRESERVED_KEYWORD)
-PG_KEYWORD("macro", MACRO, UNRESERVED_KEYWORD)
-PG_KEYWORD("map", MAP, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("mapping", MAPPING, UNRESERVED_KEYWORD)
-PG_KEYWORD("match", MATCH, UNRESERVED_KEYWORD)
-PG_KEYWORD("materialized", MATERIALIZED, UNRESERVED_KEYWORD)
-PG_KEYWORD("maxvalue", MAXVALUE, UNRESERVED_KEYWORD)
-PG_KEYWORD("method", METHOD, UNRESERVED_KEYWORD)
-PG_KEYWORD("microsecond", MICROSECOND_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("microseconds", MICROSECONDS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("millisecond", MILLISECOND_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("milliseconds", MILLISECONDS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("minute", MINUTE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("minutes", MINUTES_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("minvalue", MINVALUE, UNRESERVED_KEYWORD)
-PG_KEYWORD("mode", MODE, UNRESERVED_KEYWORD)
-PG_KEYWORD("month", MONTH_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("months", MONTHS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("move", MOVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("name", NAME_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("names", NAMES, UNRESERVED_KEYWORD)
-PG_KEYWORD("national", NATIONAL, COL_NAME_KEYWORD)
-PG_KEYWORD("natural", NATURAL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("nchar", NCHAR, COL_NAME_KEYWORD)
-PG_KEYWORD("new", NEW, UNRESERVED_KEYWORD)
-PG_KEYWORD("next", NEXT, UNRESERVED_KEYWORD)
-PG_KEYWORD("no", NO, UNRESERVED_KEYWORD)
-PG_KEYWORD("none", NONE, COL_NAME_KEYWORD)
-PG_KEYWORD("not", NOT, RESERVED_KEYWORD)
-PG_KEYWORD("nothing", NOTHING, UNRESERVED_KEYWORD)
-PG_KEYWORD("notify", NOTIFY, UNRESERVED_KEYWORD)
-PG_KEYWORD("notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("nowait", NOWAIT, UNRESERVED_KEYWORD)
-PG_KEYWORD("null", NULL_P, RESERVED_KEYWORD)
-PG_KEYWORD("nullif", NULLIF, COL_NAME_KEYWORD)
-PG_KEYWORD("nulls", NULLS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("numeric", NUMERIC, COL_NAME_KEYWORD)
-PG_KEYWORD("object", OBJECT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("of", OF, UNRESERVED_KEYWORD)
-PG_KEYWORD("off", OFF, UNRESERVED_KEYWORD)
-PG_KEYWORD("offset", OFFSET, RESERVED_KEYWORD)
-PG_KEYWORD("oids", OIDS, UNRESERVED_KEYWORD)
-PG_KEYWORD("old", OLD, UNRESERVED_KEYWORD)
-PG_KEYWORD("on", ON, RESERVED_KEYWORD)
-PG_KEYWORD("only", ONLY, RESERVED_KEYWORD)
-PG_KEYWORD("operator", OPERATOR, UNRESERVED_KEYWORD)
-PG_KEYWORD("option", OPTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("options", OPTIONS, UNRESERVED_KEYWORD)
-PG_KEYWORD("or", OR, RESERVED_KEYWORD)
-PG_KEYWORD("order", ORDER, RESERVED_KEYWORD)
-PG_KEYWORD("ordinality", ORDINALITY, UNRESERVED_KEYWORD)
-PG_KEYWORD("out", OUT_P, COL_NAME_KEYWORD)
-PG_KEYWORD("outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("over", OVER, UNRESERVED_KEYWORD)
-PG_KEYWORD("overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("overlay", OVERLAY, COL_NAME_KEYWORD)
-PG_KEYWORD("overriding", OVERRIDING, UNRESERVED_KEYWORD)
-PG_KEYWORD("owned", OWNED, UNRESERVED_KEYWORD)
-PG_KEYWORD("owner", OWNER, UNRESERVED_KEYWORD)
-PG_KEYWORD("parallel", PARALLEL, UNRESERVED_KEYWORD)
-PG_KEYWORD("parser", PARSER, UNRESERVED_KEYWORD)
-PG_KEYWORD("partial", PARTIAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("partition", PARTITION, UNRESERVED_KEYWORD)
-PG_KEYWORD("passing", PASSING, UNRESERVED_KEYWORD)
-PG_KEYWORD("password", PASSWORD, UNRESERVED_KEYWORD)
-PG_KEYWORD("percent", PERCENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("placing", PLACING, RESERVED_KEYWORD)
-PG_KEYWORD("plans", PLANS, UNRESERVED_KEYWORD)
-PG_KEYWORD("policy", POLICY, UNRESERVED_KEYWORD)
-PG_KEYWORD("position", POSITION, COL_NAME_KEYWORD)
-PG_KEYWORD("pragma", PRAGMA_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("preceding", PRECEDING, UNRESERVED_KEYWORD)
-PG_KEYWORD("precision", PRECISION, COL_NAME_KEYWORD)
-PG_KEYWORD("prepare", PREPARE, UNRESERVED_KEYWORD)
-PG_KEYWORD("prepared", PREPARED, UNRESERVED_KEYWORD)
-PG_KEYWORD("preserve", PRESERVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("primary", PRIMARY, RESERVED_KEYWORD)
-PG_KEYWORD("prior", PRIOR, UNRESERVED_KEYWORD)
-PG_KEYWORD("privileges", PRIVILEGES, UNRESERVED_KEYWORD)
-PG_KEYWORD("procedural", PROCEDURAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("procedure", PROCEDURE, UNRESERVED_KEYWORD)
-PG_KEYWORD("program", PROGRAM, UNRESERVED_KEYWORD)
-PG_KEYWORD("publication", PUBLICATION, UNRESERVED_KEYWORD)
-PG_KEYWORD("qualify", QUALIFY, RESERVED_KEYWORD)
-PG_KEYWORD("quote", QUOTE, UNRESERVED_KEYWORD)
-PG_KEYWORD("range", RANGE, UNRESERVED_KEYWORD)
-PG_KEYWORD("read", READ_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("real", REAL, COL_NAME_KEYWORD)
-PG_KEYWORD("reassign", REASSIGN, UNRESERVED_KEYWORD)
-PG_KEYWORD("recheck", RECHECK, UNRESERVED_KEYWORD)
-PG_KEYWORD("recursive", RECURSIVE, UNRESERVED_KEYWORD)
-PG_KEYWORD("ref", REF, UNRESERVED_KEYWORD)
-PG_KEYWORD("references", REFERENCES, RESERVED_KEYWORD)
-PG_KEYWORD("referencing", REFERENCING, UNRESERVED_KEYWORD)
-PG_KEYWORD("refresh", REFRESH, UNRESERVED_KEYWORD)
-PG_KEYWORD("reindex", REINDEX, UNRESERVED_KEYWORD)
-PG_KEYWORD("relative", RELATIVE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("release", RELEASE, UNRESERVED_KEYWORD)
-PG_KEYWORD("rename", RENAME, UNRESERVED_KEYWORD)
-PG_KEYWORD("repeatable", REPEATABLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("replace", REPLACE, UNRESERVED_KEYWORD)
-PG_KEYWORD("replica", REPLICA, UNRESERVED_KEYWORD)
-PG_KEYWORD("reset", RESET, UNRESERVED_KEYWORD)
-PG_KEYWORD("respect", RESPECT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("restart", RESTART, UNRESERVED_KEYWORD)
-PG_KEYWORD("restrict", RESTRICT, UNRESERVED_KEYWORD)
-PG_KEYWORD("returning", RETURNING, RESERVED_KEYWORD)
-PG_KEYWORD("returns", RETURNS, UNRESERVED_KEYWORD)
-PG_KEYWORD("revoke", REVOKE, UNRESERVED_KEYWORD)
-PG_KEYWORD("right", RIGHT, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("role", ROLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("rollback", ROLLBACK, UNRESERVED_KEYWORD)
-PG_KEYWORD("rollup", ROLLUP, UNRESERVED_KEYWORD)
-PG_KEYWORD("row", ROW, COL_NAME_KEYWORD)
-PG_KEYWORD("rows", ROWS, UNRESERVED_KEYWORD)
-PG_KEYWORD("rule", RULE, UNRESERVED_KEYWORD)
-PG_KEYWORD("sample", SAMPLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("savepoint", SAVEPOINT, UNRESERVED_KEYWORD)
-PG_KEYWORD("schema", SCHEMA, UNRESERVED_KEYWORD)
-PG_KEYWORD("schemas", SCHEMAS, UNRESERVED_KEYWORD)
-PG_KEYWORD("scroll", SCROLL, UNRESERVED_KEYWORD)
-PG_KEYWORD("search", SEARCH, UNRESERVED_KEYWORD)
-PG_KEYWORD("second", SECOND_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("seconds", SECONDS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("security", SECURITY, UNRESERVED_KEYWORD)
-PG_KEYWORD("select", SELECT, RESERVED_KEYWORD)
-PG_KEYWORD("sequence", SEQUENCE, UNRESERVED_KEYWORD)
-PG_KEYWORD("sequences", SEQUENCES, UNRESERVED_KEYWORD)
-PG_KEYWORD("serializable", SERIALIZABLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("server", SERVER, UNRESERVED_KEYWORD)
-PG_KEYWORD("session", SESSION, UNRESERVED_KEYWORD)
-PG_KEYWORD("session_user", SESSION_USER, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("set", SET, UNRESERVED_KEYWORD)
-PG_KEYWORD("setof", SETOF, COL_NAME_KEYWORD)
-PG_KEYWORD("sets", SETS, UNRESERVED_KEYWORD)
-PG_KEYWORD("share", SHARE, UNRESERVED_KEYWORD)
-PG_KEYWORD("show", SHOW, UNRESERVED_KEYWORD)
-PG_KEYWORD("similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("simple", SIMPLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("skip", SKIP, UNRESERVED_KEYWORD)
-PG_KEYWORD("smallint", SMALLINT, COL_NAME_KEYWORD)
-PG_KEYWORD("snapshot", SNAPSHOT, UNRESERVED_KEYWORD)
-PG_KEYWORD("some", SOME, RESERVED_KEYWORD)
-PG_KEYWORD("sql", SQL_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("stable", STABLE, UNRESERVED_KEYWORD)
-PG_KEYWORD("standalone", STANDALONE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("start", START, UNRESERVED_KEYWORD)
-PG_KEYWORD("statement", STATEMENT, UNRESERVED_KEYWORD)
-PG_KEYWORD("statistics", STATISTICS, UNRESERVED_KEYWORD)
-PG_KEYWORD("stdin", STDIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("stdout", STDOUT, UNRESERVED_KEYWORD)
-PG_KEYWORD("storage", STORAGE, UNRESERVED_KEYWORD)
-PG_KEYWORD("stored", STORED, UNRESERVED_KEYWORD)
-PG_KEYWORD("strict", STRICT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("strip", STRIP_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("struct", STRUCT, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("subscription", SUBSCRIPTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("substring", SUBSTRING, COL_NAME_KEYWORD)
-PG_KEYWORD("summarize", SUMMARIZE, UNRESERVED_KEYWORD)
-PG_KEYWORD("symmetric", SYMMETRIC, RESERVED_KEYWORD)
-PG_KEYWORD("sysid", SYSID, UNRESERVED_KEYWORD)
-PG_KEYWORD("system", SYSTEM_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("table", TABLE, RESERVED_KEYWORD)
-PG_KEYWORD("tables", TABLES, UNRESERVED_KEYWORD)
-PG_KEYWORD("tablesample", TABLESAMPLE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("tablespace", TABLESPACE, UNRESERVED_KEYWORD)
-PG_KEYWORD("temp", TEMP, UNRESERVED_KEYWORD)
-PG_KEYWORD("template", TEMPLATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("temporary", TEMPORARY, UNRESERVED_KEYWORD)
-PG_KEYWORD("text", TEXT_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("then", THEN, RESERVED_KEYWORD)
-PG_KEYWORD("time", TIME, COL_NAME_KEYWORD)
-PG_KEYWORD("timestamp", TIMESTAMP, COL_NAME_KEYWORD)
-PG_KEYWORD("to", TO, RESERVED_KEYWORD)
-PG_KEYWORD("trailing", TRAILING, RESERVED_KEYWORD)
-PG_KEYWORD("transaction", TRANSACTION, UNRESERVED_KEYWORD)
-PG_KEYWORD("transform", TRANSFORM, UNRESERVED_KEYWORD)
-PG_KEYWORD("treat", TREAT, COL_NAME_KEYWORD)
-PG_KEYWORD("trigger", TRIGGER, UNRESERVED_KEYWORD)
-PG_KEYWORD("trim", TRIM, COL_NAME_KEYWORD)
-PG_KEYWORD("true", TRUE_P, RESERVED_KEYWORD)
-PG_KEYWORD("truncate", TRUNCATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("trusted", TRUSTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("try_cast", TRY_CAST, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("type", TYPE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("types", TYPES_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("unbounded", UNBOUNDED, UNRESERVED_KEYWORD)
-PG_KEYWORD("uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD)
-PG_KEYWORD("union", UNION, RESERVED_KEYWORD)
-PG_KEYWORD("unique", UNIQUE, RESERVED_KEYWORD)
-PG_KEYWORD("unknown", UNKNOWN, UNRESERVED_KEYWORD)
-PG_KEYWORD("unlisten", UNLISTEN, UNRESERVED_KEYWORD)
-PG_KEYWORD("unlogged", UNLOGGED, UNRESERVED_KEYWORD)
-PG_KEYWORD("until", UNTIL, UNRESERVED_KEYWORD)
-PG_KEYWORD("update", UPDATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("user", USER, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("using", USING, RESERVED_KEYWORD)
-PG_KEYWORD("vacuum", VACUUM, UNRESERVED_KEYWORD)
-PG_KEYWORD("valid", VALID, UNRESERVED_KEYWORD)
-PG_KEYWORD("validate", VALIDATE, UNRESERVED_KEYWORD)
-PG_KEYWORD("validator", VALIDATOR, UNRESERVED_KEYWORD)
-PG_KEYWORD("value", VALUE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("values", VALUES, COL_NAME_KEYWORD)
-PG_KEYWORD("varchar", VARCHAR, COL_NAME_KEYWORD)
-PG_KEYWORD("variadic", VARIADIC, RESERVED_KEYWORD)
-PG_KEYWORD("varying", VARYING, UNRESERVED_KEYWORD)
-PG_KEYWORD("verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD)
-PG_KEYWORD("version", VERSION_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("view", VIEW, UNRESERVED_KEYWORD)
-PG_KEYWORD("views", VIEWS, UNRESERVED_KEYWORD)
-PG_KEYWORD("virtual", VIRTUAL, UNRESERVED_KEYWORD)
-PG_KEYWORD("volatile", VOLATILE, UNRESERVED_KEYWORD)
-PG_KEYWORD("when", WHEN, RESERVED_KEYWORD)
-PG_KEYWORD("where", WHERE, RESERVED_KEYWORD)
-PG_KEYWORD("whitespace", WHITESPACE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("window", WINDOW, RESERVED_KEYWORD)
-PG_KEYWORD("with", WITH, RESERVED_KEYWORD)
-PG_KEYWORD("within", WITHIN, UNRESERVED_KEYWORD)
-PG_KEYWORD("without", WITHOUT, UNRESERVED_KEYWORD)
-PG_KEYWORD("work", WORK, UNRESERVED_KEYWORD)
-PG_KEYWORD("wrapper", WRAPPER, UNRESERVED_KEYWORD)
-PG_KEYWORD("write", WRITE_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("xml", XML_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlconcat", XMLCONCAT, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlelement", XMLELEMENT, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlexists", XMLEXISTS, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlforest", XMLFOREST, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlnamespaces", XMLNAMESPACES, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlparse", XMLPARSE, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlpi", XMLPI, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlroot", XMLROOT, COL_NAME_KEYWORD)
-PG_KEYWORD("xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD)
-PG_KEYWORD("xmltable", XMLTABLE, COL_NAME_KEYWORD)
-PG_KEYWORD("year", YEAR_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("years", YEARS_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("yes", YES_P, UNRESERVED_KEYWORD)
-PG_KEYWORD("zone", ZONE, UNRESERVED_KEYWORD)
-
-};
-
-const int NumScanKeywords = lengthof(ScanKeywords);
-} // namespace duckdb_libpgquery
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_libpgquery {
-
-/*
- * raw_parser
- *		Given a query in string form, do lexical and grammatical analysis.
- *
- * Returns a list of raw (un-analyzed) parse trees.  The immediate elements
- * of the list are always PGRawStmt nodes.
- */
-PGList *raw_parser(const char *str) {
-	core_yyscan_t yyscanner;
-	base_yy_extra_type yyextra;
-	int yyresult;
-
-	/* initialize the flex scanner */
-	yyscanner = scanner_init(str, &yyextra.core_yy_extra, ScanKeywords, NumScanKeywords);
-
-	/* base_yylex() only needs this much initialization */
-	yyextra.have_lookahead = false;
-
-	/* initialize the bison parser */
-	parser_init(&yyextra);
-
-	/* Parse! */
-	yyresult = base_yyparse(yyscanner);
-
-	/* Clean up (release memory) */
-	scanner_finish(yyscanner);
-
-	if (yyresult) /* error */
-		return NIL;
-
-	return yyextra.parsetree;
-}
-
-bool is_keyword(const char *text) {
-	return ScanKeywordLookup(text, ScanKeywords, NumScanKeywords) != NULL;
-}
-
-std::vector<PGKeyword> keyword_list() {
-    std::vector<PGKeyword> result;
-	for(size_t i = 0; i < NumScanKeywords; i++) {
-		PGKeyword keyword;
-		keyword.text = ScanKeywords[i].name;
-		switch(ScanKeywords[i].category) {
-		case UNRESERVED_KEYWORD:
-			keyword.category = PGKeywordCategory::PG_KEYWORD_UNRESERVED;
-			break;
-		case RESERVED_KEYWORD:
-			keyword.category = PGKeywordCategory::PG_KEYWORD_RESERVED;
-			break;
-		case TYPE_FUNC_NAME_KEYWORD:
-			keyword.category = PGKeywordCategory::PG_KEYWORD_TYPE_FUNC;
-			break;
-		case COL_NAME_KEYWORD:
-			keyword.category = PGKeywordCategory::PG_KEYWORD_COL_NAME;
-			break;
-		}
-		result.push_back(keyword);
-	}
-	return result;
-}
-
-std::vector<PGSimplifiedToken> tokenize(const char *str) {
-	core_yyscan_t yyscanner;
-	base_yy_extra_type yyextra;
-
-	std::vector<PGSimplifiedToken> result;
-	yyscanner = scanner_init(str, &yyextra.core_yy_extra, ScanKeywords, NumScanKeywords);
-	yyextra.have_lookahead = false;
-
-	while(true) {
-		YYSTYPE type;
-		YYLTYPE loc;
-		int token;
-		try {
-			token = base_yylex(&type, &loc, yyscanner);
-		} catch(...) {
-			token = 0;
-		}
-		if (token == 0) {
-			break;
-		}
-		PGSimplifiedToken current_token;
-		switch(token) {
-		case IDENT:
-			current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_IDENTIFIER;
-			break;
-		case ICONST:
-		case FCONST:
-			current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_NUMERIC_CONSTANT;
-			break;
-		case SCONST:
-		case BCONST:
-		case XCONST:
-			current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_STRING_CONSTANT;
-			break;
-		case Op:
-		case PARAM:
-		case COLON_EQUALS:
-		case EQUALS_GREATER:
-		case LESS_EQUALS:
-		case GREATER_EQUALS:
-		case NOT_EQUALS:
-			current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_OPERATOR;
-			break;
-		default:
-			if (token >= 255) {
-				// non-ascii value, probably a keyword
-				current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_KEYWORD;
-			} else {
-				// ascii value, probably an operator
-				current_token.type = PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_OPERATOR;
-			}
-			break;
-		}
-		current_token.start = loc;
-		result.push_back(current_token);
-	}
-
-	scanner_finish(yyscanner);
-	return result;
-}
-
-
-
-/*
- * Intermediate filter between parser and core lexer (core_yylex in scan.l).
- *
- * This filter is needed because in some cases the standard SQL grammar
- * requires more than one token lookahead.  We reduce these cases to one-token
- * lookahead by replacing tokens here, in order to keep the grammar LALR(1).
- *
- * Using a filter is simpler than trying to recognize multiword tokens
- * directly in scan.l, because we'd have to allow for comments between the
- * words.  Furthermore it's not clear how to do that without re-introducing
- * scanner backtrack, which would cost more performance than this filter
- * layer does.
- *
- * The filter also provides a convenient place to translate between
- * the core_YYSTYPE and YYSTYPE representations (which are really the
- * same thing anyway, but notationally they're different).
- */
-int base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner) {
-	base_yy_extra_type *yyextra = pg_yyget_extra(yyscanner);
-	int cur_token;
-	int next_token;
-	int cur_token_length;
-	YYLTYPE cur_yylloc;
-
-	/* Get next token --- we might already have it */
-	if (yyextra->have_lookahead) {
-		cur_token = yyextra->lookahead_token;
-		lvalp->core_yystype = yyextra->lookahead_yylval;
-		*llocp = yyextra->lookahead_yylloc;
-		*(yyextra->lookahead_end) = yyextra->lookahead_hold_char;
-		yyextra->have_lookahead = false;
-	} else
-		cur_token = core_yylex(&(lvalp->core_yystype), llocp, yyscanner);
-
-	/*
-	 * If this token isn't one that requires lookahead, just return it.  If it
-	 * does, determine the token length.  (We could get that via strlen(), but
-	 * since we have such a small set of possibilities, hardwiring seems
-	 * feasible and more efficient.)
-	 */
-	switch (cur_token) {
-	case NOT:
-		cur_token_length = 3;
-		break;
-	case NULLS_P:
-		cur_token_length = 5;
-		break;
-	case WITH:
-		cur_token_length = 4;
-		break;
-	default:
-		return cur_token;
-	}
-
-	/*
-	 * Identify end+1 of current token.  core_yylex() has temporarily stored a
-	 * '\0' here, and will undo that when we call it again.  We need to redo
-	 * it to fully revert the lookahead call for error reporting purposes.
-	 */
-	yyextra->lookahead_end = yyextra->core_yy_extra.scanbuf + *llocp + cur_token_length;
-	Assert(*(yyextra->lookahead_end) == '\0');
-
-	/*
-	 * Save and restore *llocp around the call.  It might look like we could
-	 * avoid this by just passing &lookahead_yylloc to core_yylex(), but that
-	 * does not work because flex actually holds onto the last-passed pointer
-	 * internally, and will use that for error reporting.  We need any error
-	 * reports to point to the current token, not the next one.
-	 */
-	cur_yylloc = *llocp;
-
-	/* Get next token, saving outputs into lookahead variables */
-	next_token = core_yylex(&(yyextra->lookahead_yylval), llocp, yyscanner);
-	yyextra->lookahead_token = next_token;
-	yyextra->lookahead_yylloc = *llocp;
-
-	*llocp = cur_yylloc;
-
-	/* Now revert the un-truncation of the current token */
-	yyextra->lookahead_hold_char = *(yyextra->lookahead_end);
-	*(yyextra->lookahead_end) = '\0';
-
-	yyextra->have_lookahead = true;
-
-	/* Replace cur_token if needed, based on lookahead */
-	switch (cur_token) {
-	case NOT:
-		/* Replace NOT by NOT_LA if it's followed by BETWEEN, IN, etc */
-		switch (next_token) {
-		case BETWEEN:
-		case IN_P:
-		case LIKE:
-		case ILIKE:
-		case SIMILAR:
-			cur_token = NOT_LA;
-			break;
-		}
-		break;
-
-	case NULLS_P:
-		/* Replace NULLS_P by NULLS_LA if it's followed by FIRST or LAST */
-		switch (next_token) {
-		case FIRST_P:
-		case LAST_P:
-			cur_token = NULLS_LA;
-			break;
-		}
-		break;
-
-	case WITH:
-		/* Replace WITH by WITH_LA if it's followed by TIME or ORDINALITY */
-		switch (next_token) {
-		case TIME:
-		case ORDINALITY:
-			cur_token = WITH_LA;
-			break;
-		}
-		break;
-	}
-
-	return cur_token;
-}
-
-}
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-#line 1 "third_party/libpg_query/src_backend_parser_scan.cpp"
-/*-------------------------------------------------------------------------
- *
- * scan.l
- *	  lexical scanner for PostgreSQL
- *
- * NOTE NOTE NOTE:
- *
- * The rules in this file must be kept in sync with src/fe_utils/psqlscan.l!
- *
- * The rules are designed so that the scanner never has to backtrack,
- * in the sense that there is always a rule that can match the input
- * consumed so far (the rule action may internally throw back some input
- * with yyless(), however).  As explained in the flex manual, this makes
- * for a useful speed increase --- about a third faster than a plain -CF
- * lexer, in simple testing.  The extra complexity is mostly in the rules
- * for handling float numbers and continued string literals.  If you change
- * the lexical rules, verify that you haven't broken the no-backtrack '
- * property by running flex with the "-b" option and checking that the
- * resulting "lex.backup" file says that no backing up is needed.  (As of
- * Postgres 9.2, this check is made automatically by the Makefile.)
- *
- *
- * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * IDENTIFICATION
- *	  src/backend/parser/scan.l
- *
- *-------------------------------------------------------------------------
- */
-#include <ctype.h>
-//#include <unistd.h>
-
-
-
-		/* only needed for GUC variables */
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * pg_wchar.h
- *	  multibyte-character support
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/mb/pg_wchar.h
- *
- *	NOTES
- *		This is used both by the backend and by libpq, but should not be
- *		included by libpq client programs.  In particular, a libpq client
- *		should not assume that the encoding IDs used by the version of libpq
- *		it's linked to match up with the IDs declared here.
- *
- *-------------------------------------------------------------------------
- */
-
-
-#include <cstdint>
-
-/*
- * The pg_wchar type
- */
-namespace duckdb_libpgquery {
-typedef unsigned int pg_wchar;
-}
-
-// LICENSE_CHANGE_END
-
-
-#include <stdexcept>
-
-#line 43 "third_party/libpg_query/src_backend_parser_scan.cpp"
-
-#define  YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 6
-#define YY_FLEX_SUBMINOR_VERSION 4
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-#ifdef yy_create_buffer
-#define core_yy_create_buffer_ALREADY_DEFINED
-#else
-#define yy_create_buffer core_yy_create_buffer
-#endif
-
-#ifdef yy_delete_buffer
-#define core_yy_delete_buffer_ALREADY_DEFINED
-#else
-#define yy_delete_buffer core_yy_delete_buffer
-#endif
-
-#ifdef yy_scan_buffer
-#define core_yy_scan_buffer_ALREADY_DEFINED
-#else
-#define yy_scan_buffer core_yy_scan_buffer
-#endif
-
-#ifdef yy_scan_string
-#define core_yy_scan_string_ALREADY_DEFINED
-#else
-#define yy_scan_string core_yy_scan_string
-#endif
-
-#ifdef yy_scan_bytes
-#define core_yy_scan_bytes_ALREADY_DEFINED
-#else
-#define yy_scan_bytes core_yy_scan_bytes
-#endif
-
-#ifdef yy_init_buffer
-#define core_yy_init_buffer_ALREADY_DEFINED
-#else
-#define yy_init_buffer core_yy_init_buffer
-#endif
-
-#ifdef yy_flush_buffer
-#define core_yy_flush_buffer_ALREADY_DEFINED
-#else
-#define yy_flush_buffer core_yy_flush_buffer
-#endif
-
-#ifdef yy_load_buffer_state
-#define core_yy_load_buffer_state_ALREADY_DEFINED
-#else
-#define yy_load_buffer_state core_yy_load_buffer_state
-#endif
-
-#ifdef yy_switch_to_buffer
-#define core_yy_switch_to_buffer_ALREADY_DEFINED
-#else
-#define yy_switch_to_buffer core_yy_switch_to_buffer
-#endif
-
-#ifdef yypush_buffer_state
-#define core_yypush_buffer_state_ALREADY_DEFINED
-#else
-#define yypush_buffer_state core_yypush_buffer_state
-#endif
-
-#ifdef yypop_buffer_state
-#define core_yypop_buffer_state_ALREADY_DEFINED
-#else
-#define yypop_buffer_state core_yypop_buffer_state
-#endif
-
-#ifdef yyensure_buffer_stack
-#define core_yyensure_buffer_stack_ALREADY_DEFINED
-#else
-#define yyensure_buffer_stack core_yyensure_buffer_stack
-#endif
-
-#ifdef yylex
-#define core_yylex_ALREADY_DEFINED
-#else
-#define yylex core_yylex
-#endif
-
-#ifdef yyrestart
-#define core_yyrestart_ALREADY_DEFINED
-#else
-#define yyrestart core_yyrestart
-#endif
-
-#ifdef yylex_init
-#define core_yylex_init_ALREADY_DEFINED
-#else
-#define yylex_init core_yylex_init
-#endif
-
-#ifdef yylex_init_extra
-#define core_yylex_init_extra_ALREADY_DEFINED
-#else
-#define yylex_init_extra core_yylex_init_extra
-#endif
-
-#ifdef yylex_destroy
-#define core_yylex_destroy_ALREADY_DEFINED
-#else
-#define yylex_destroy core_yylex_destroy
-#endif
-
-#ifdef yyget_debug
-#define core_yyget_debug_ALREADY_DEFINED
-#else
-#define yyget_debug core_yyget_debug
-#endif
-
-#ifdef yyset_debug
-#define core_yyset_debug_ALREADY_DEFINED
-#else
-#define yyset_debug core_yyset_debug
-#endif
-
-#ifdef yyget_extra
-#define core_yyget_extra_ALREADY_DEFINED
-#else
-#define yyget_extra core_yyget_extra
-#endif
-
-#ifdef yyset_extra
-#define core_yyset_extra_ALREADY_DEFINED
-#else
-#define yyset_extra core_yyset_extra
-#endif
-
-#ifdef yyget_in
-#define core_yyget_in_ALREADY_DEFINED
-#else
-#define yyget_in core_yyget_in
-#endif
-
-#ifdef yyset_in
-#define core_yyset_in_ALREADY_DEFINED
-#else
-#define yyset_in core_yyset_in
-#endif
-
-#ifdef yyget_out
-#define core_yyget_out_ALREADY_DEFINED
-#else
-#define yyget_out core_yyget_out
-#endif
-
-#ifdef yyset_out
-#define core_yyset_out_ALREADY_DEFINED
-#else
-#define yyset_out core_yyset_out
-#endif
-
-#ifdef yyget_leng
-#define core_yyget_leng_ALREADY_DEFINED
-#else
-#define yyget_leng core_yyget_leng
-#endif
-
-#ifdef yyget_text
-#define core_yyget_text_ALREADY_DEFINED
-#else
-#define yyget_text core_yyget_text
-#endif
-
-#ifdef yyget_lineno
-#define core_yyget_lineno_ALREADY_DEFINED
-#else
-#define yyget_lineno core_yyget_lineno
-#endif
-
-#ifdef yyset_lineno
-#define core_yyset_lineno_ALREADY_DEFINED
-#else
-#define yyset_lineno core_yyset_lineno
-#endif
-
-#ifdef yyget_column
-#define core_yyget_column_ALREADY_DEFINED
-#else
-#define yyget_column core_yyget_column
-#endif
-
-#ifdef yyset_column
-#define core_yyset_column_ALREADY_DEFINED
-#else
-#define yyset_column core_yyset_column
-#endif
-
-#ifdef yywrap
-#define core_yywrap_ALREADY_DEFINED
-#else
-#define yywrap core_yywrap
-#endif
-
-#ifdef yyget_lval
-#define core_yyget_lval_ALREADY_DEFINED
-#else
-#define yyget_lval core_yyget_lval
-#endif
-
-#ifdef yyset_lval
-#define core_yyset_lval_ALREADY_DEFINED
-#else
-#define yyset_lval core_yyset_lval
-#endif
-
-#ifdef yyget_lloc
-#define core_yyget_lloc_ALREADY_DEFINED
-#else
-#define yyget_lloc core_yyget_lloc
-#endif
-
-#ifdef yyset_lloc
-#define core_yyset_lloc_ALREADY_DEFINED
-#else
-#define yyset_lloc core_yyset_lloc
-#endif
-
-#ifdef yyalloc
-#define core_yyalloc_ALREADY_DEFINED
-#else
-#define yyalloc core_yyalloc
-#endif
-
-#ifdef yyrealloc
-#define core_yyrealloc_ALREADY_DEFINED
-#else
-#define yyrealloc core_yyrealloc
-#endif
-
-#ifdef yyfree
-#define core_yyfree_ALREADY_DEFINED
-#else
-#define yyfree core_yyfree
-#endif
-
-/* First, we deal with  platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-namespace duckdb_libpgquery {
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-typedef uint64_t flex_uint64_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN               (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX               (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX              (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
-#endif
-
-#ifndef SIZE_MAX
-#define SIZE_MAX               (~(size_t)0)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-/* begin standard C++ headers. */
-
-/* TODO: this is always defined, so inline it */
-#define yyconst const
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define yynoreturn __attribute__((__noreturn__))
-#else
-#define yynoreturn
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an
- *   integer in range [0..255] for use as an array index.
- */
-#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
-   are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Enter a start condition.  This macro really ought to take a parameter,
- * but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN.
- */
-#define BEGIN yyg->yy_start = 1 + 2 *
-/* Translate the current start state into a value that can be later handed
- * to BEGIN to return to the state.  The YYSTATE alias is for lex
- * compatibility.
- */
-#define YY_START ((yyg->yy_start - 1) / 2)
-#define YYSTATE YY_START
-/* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-/* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( yyin , yyscanner )
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-    
-    #define YY_LESS_LINENO(n)
-    #define YY_LINENO_REWIND_TO(ptr)
-    
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		*yy_cp = yyg->yy_hold_char; \
-		YY_RESTORE_YY_MORE_OFFSET \
-		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-		} \
-	while ( 0 )
-#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
-	{
-	FILE *yy_input_file;
-
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	int yy_buf_size;
-
-	/* Number of characters read into yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	yy_size_t yy_n_chars;
-
-	/* Whether we "own" the buffer - i.e., we know we created it,
-	 * and can realloc() it to grow it, and should free() it to
-	 * delete it.
-	 */
-	int yy_is_our_buffer;
-
-	/* Whether this is an "interactive" input source; if so, and
-	 * if we're using stdio for input, then we want to use getc()
-	 * instead of fread(), to make sure we stop fetching input after
-	 * each newline.
-	 */
-	int yy_is_interactive;
-
-	/* Whether we're considered to be at the beginning of a line.
-	 * If so, '^' rules will be active on the next match, otherwise
-	 * not.
-	 */
-	int yy_at_bol;
-
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
-
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int yy_fill_buffer;
-
-	int yy_buffer_status;
-
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
-	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-	 * shouldn't try reading from the input source any more.  We might
-	 * still have a bunch of tokens to match, though, because of
-	 * possible backing-up.
-	 *
-	 * When we actually see the EOF, we change the status to "new"
-	 * (via yyrestart()), so that the user can continue scanning by
-	 * just pointing yyin at a new input file.
-	 */
-#define YY_BUFFER_EOF_PENDING 2
-
-	};
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* We provide macros for accessing buffer states in case in the
- * future we want to put the buffer states in a more general
- * "scanner state".
- *
- * Returns the top of the stack, or NULL.
- */
-#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
-                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
-                          : NULL)
-/* Same as previous macro, but useful when we know that the buffer stack is not
- * NULL or when we need an lvalue. For internal use only.
- */
-#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
-
-void yyrestart ( FILE *input_file , yyscan_t yyscanner );
-void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
-void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-void yypop_buffer_state ( yyscan_t yyscanner );
-
-static void yyensure_buffer_stack ( yyscan_t yyscanner );
-static void yy_load_buffer_state ( yyscan_t yyscanner );
-static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
-#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
-
-YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len , yyscan_t yyscanner );
-
-void *yyalloc ( yy_size_t , yyscan_t yyscanner );
-void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
-void yyfree ( void * , yyscan_t yyscanner );
-
-#define yy_new_buffer yy_create_buffer
-#define yy_set_interactive(is_interactive) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){ \
-        yyensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-	}
-#define yy_set_bol(at_bol) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){\
-        yyensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-	}
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-/* Begin user sect3 */
-
-#define core_yywrap(yyscanner) (/*CONSTCOND*/1)
-#define YY_SKIP_YYWRAP
-typedef flex_uint8_t YY_CHAR;
-
-typedef int yy_state_type;
-
-#define yytext_ptr yytext_r
-
-static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
-static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
-static int yy_get_next_buffer ( yyscan_t yyscanner );
-static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
-	yyg->yytext_ptr = yy_bp; \
-	yyleng = (yy_size_t) (yy_cp - yy_bp); \
-	yyg->yy_hold_char = *yy_cp; \
-	*yy_cp = '\0'; \
-	yyg->yy_c_buf_p = yy_cp;
-#define YY_NUM_RULES 82
-#define YY_END_OF_BUFFER 83
-/* This struct is not used in this scanner,
-   but its presence is necessary. */
-struct yy_trans_info
-	{
-	flex_int32_t yy_verify;
-	flex_int32_t yy_nxt;
-	};
-static const flex_int16_t yy_accept[295] =
-    {   0,
-        0,    0,   12,   12,    0,    0,    0,    0,   11,   11,
-        0,    0,    0,    0,    0,    0,    0,    0,   55,   55,
-        0,    0,   28,   28,    0,    0,   83,   81,    1,    1,
-       71,   49,   81,   70,   71,   19,   70,   70,   70,   70,
-       70,   74,   70,   70,   70,   70,   81,   80,   80,   80,
-       80,   80,   80,   12,    9,    5,    5,    6,    6,   58,
-       51,   11,   16,   32,   32,   22,   42,   31,   22,   46,
-       46,   48,   52,   54,   53,   53,   54,   54,   24,   27,
-       26,   26,   27,   27,   35,   36,   35,    1,   71,   69,
-       43,   72,   44,   64,    1,   63,   61,   75,    2,   75,
-
-       74,   78,   60,   62,   66,   68,   65,   67,   73,   80,
-        8,   20,   18,   59,   15,   12,    9,    9,   10,    5,
-        7,    4,    3,   58,   57,   11,   16,   16,   17,   32,
-       22,   22,   30,   23,   38,   39,   37,   37,   38,   31,
-       46,   45,   47,   53,   53,   55,   24,   24,   25,   26,
-       26,   28,   37,   37,   44,    1,    1,    2,   76,   75,
-       79,   77,   50,   21,    9,   14,   10,    9,    3,   16,
-       13,   17,   16,   22,   41,   23,   22,   39,   37,   37,
-       40,   47,   53,   55,   24,   25,   24,   26,   28,   37,
-       37,    9,    9,    9,    9,   16,   16,   16,   16,   22,
-
-       22,   22,   22,   39,   37,   37,   40,   55,   24,   24,
-       24,   24,   28,   37,   37,    9,    9,    9,    9,    9,
-       16,   16,   16,   16,   16,   22,   22,   22,   22,   22,
-       37,   37,   55,   24,   24,   24,   24,   24,   28,   37,
-       37,    9,   16,   22,   37,   33,   55,   24,   28,   37,
-       34,   37,   55,   28,   37,   37,   55,   55,   55,   28,
-       28,   28,   37,   37,   55,   55,   28,   28,   37,   56,
-       55,   55,   55,   55,   29,   28,   28,   28,   28,   55,
-       55,   55,   55,   55,   28,   28,   28,   28,   28,   55,
-       55,   28,   28,    0
-
-    } ;
-
-static const YY_CHAR yy_ec[256] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-        1,    2,    4,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    5,    6,    1,    7,    8,    9,   10,   11,
-       11,   12,   13,   11,   14,   15,   16,   17,   17,   17,
-       17,   17,   17,   17,   17,   18,   18,   19,   11,   20,
-       21,   22,   23,   24,   25,   26,   27,   28,   29,   28,
-       30,   30,   30,   30,   30,   30,   30,   31,   30,   32,
-       30,   30,   33,   30,   34,   30,   30,   35,   30,   30,
-       11,   36,   11,    8,   30,   24,   25,   26,   27,   28,
-
-       29,   28,   30,   30,   30,   30,   30,   30,   30,   31,
-       30,   32,   30,   30,   33,   30,   37,   30,   30,   38,
-       30,   30,    1,   24,    1,   24,    1,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30
-    } ;
-
-static const YY_CHAR yy_meta[39] =
-    {   0,
-        1,    1,    2,    2,    3,    4,    5,    3,    3,    6,
-        1,    7,    3,    3,    1,    7,    8,    8,    1,    3,
-        3,    3,    1,    3,    9,    9,    9,    9,    9,   10,
-       10,   10,   10,   10,   10,   11,   10,   10
-    } ;
-
-static const flex_int16_t yy_base[362] =
-    {   0,
-        0,    0,  430,  424,   34,   54,  419,  418,  409,  408,
-       41,   50,  402,  401,   38,   54,  393,  392,   85,  121,
-      386,  385,  157,  193,   37,   46,  383, 1208,   77,   81,
-      361, 1208,   83,    0,    0, 1208, 1208,  365,   50,   76,
-      364,   80,   50,   81,  348,  348,   87,    0,  347,  346,
-      344,  344,  331,    0,  104,    0,    0,   80,  328,    0,
-      329,    0,  112,    0,    0,  126,  100,    0,  129,    0,
-        0,  327,  321, 1208,  108,  142,  306,  285,  160, 1208,
-      145,  148,  298,  282, 1208, 1208,  119,  163,    0,    0,
-     1208,  103,  297,    0,  226,    0, 1208,  151,    0,  158,
-
-      164,  171, 1208, 1208,    0,    0,    0,    0,  124,    0,
-     1208, 1208, 1208,  180, 1208,    0,  196,  199,  283,    0,
-      192, 1208,    0,    0, 1208,    0,  212,  215,  276,    0,
-      218,  241, 1208,  268, 1208,  261,    0,    0,    0,    0,
-        0, 1208,  270,  250,    0,  241,  254,  257,  259,  260,
-        0,  237,    0,    0,  262,    0,  267,    0, 1208,  194,
-      160,  188, 1208, 1208,  282, 1208,  252,  291,    0,  296,
-     1208,  251,  299,  305, 1208,  235,  314,  224,    0,    0,
-        0,  230,    0,  209,  319,  219,  322,    0,  201,    0,
-        0,  328,  335,  341,  344,  348,  357,  361,  364,  370,
-
-      377,  383,  386, 1208,    0,    0, 1208,  199,  390,  399,
-      403,  406,  167,    0,    0,  412,  419,  425,  428,  434,
-      441,  447,  450,  454,  463,  467,  470,  476,  485,  489,
-        0,    0,  151,  492,  498,  505,  514,  518,  140,    0,
-        0,  521,  527,  534,    0, 1208,  128,  540,  125,    0,
-     1208,    0,  543,  548,    0,    0,  557,    0,  113,  562,
-        0,   99,    0,    0,   55,  571,   42,  576,    0, 1208,
-      585,  590,  599,  604, 1208,  613,  618,  627,  632,  641,
-      646,  655,  660,  669,  674,  683,  688,  697,  702,  711,
-        0,  716,    0, 1208,  730,  741,  752,  763,  774,  785,
-
-      796,  807,  818,  829,  838,  841,  847,  857,  868,  879,
-      890,  901,  911,  922,  933,  940,  946,  956,  965,  970,
-      970,  972,  974,  979,  989, 1000, 1004, 1006, 1015, 1026,
-     1037, 1041, 1043, 1045, 1054, 1058, 1060, 1069, 1080, 1091,
-     1095, 1097, 1106, 1110, 1112, 1114, 1116, 1118, 1120, 1122,
-     1124, 1126, 1128, 1130, 1139, 1150, 1154, 1163, 1174, 1185,
-     1196
-    } ;
-
-static const flex_int16_t yy_def[362] =
-    {   0,
-      294,    1,  295,  295,  296,  296,  297,  297,  298,  298,
-      299,  299,  300,  300,  301,  301,  297,  297,  302,  302,
-      300,  300,  303,  303,  304,  304,  294,  294,  294,  294,
-      305,  294,  306,  305,  305,  294,  294,  305,  305,  294,
-      305,  294,  294,  305,  305,  305,  294,  307,  307,  307,
-      307,  307,  307,  308,  294,  309,  309,  294,  294,  310,
-      294,  311,  294,  312,  312,  294,  313,  314,  294,  315,
-      315,  316,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  305,  305,
-      294,  294,  317,  305,  318,  305,  294,  294,  319,  294,
-
-      294,  294,  294,  294,  305,  305,  305,  305,  294,  307,
-      294,  294,  294,  294,  294,  308,  294,  294,  294,  309,
-      294,  294,  320,  310,  294,  311,  294,  294,  294,  312,
-      294,  294,  294,  294,  294,  294,  321,  322,  323,  314,
-      315,  294,  324,  294,  325,  294,  294,  294,  294,  294,
-      326,  294,  327,  328,  317,  318,  318,  319,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  329,  320,  294,
-      294,  294,  330,  294,  294,  294,  331,  294,  332,  333,
-      334,  324,  325,  294,  294,  294,  335,  326,  294,  336,
-      337,  338,  329,  329,  329,  339,  330,  330,  330,  340,
-
-      331,  331,  331,  294,  341,  342,  294,  294,  343,  335,
-      335,  335,  294,  344,  345,  338,  338,  294,  338,  329,
-      339,  339,  294,  339,  330,  340,  340,  294,  340,  331,
-      346,  347,  294,  343,  343,  294,  343,  335,  294,  348,
-      349,  338,  339,  340,  350,  294,  294,  343,  294,  351,
-      294,  352,  294,  294,  353,  354,  294,  355,  294,  294,
-      356,  294,  357,  347,  294,  358,  294,  359,  349,  294,
-      358,  358,  360,  358,  294,  359,  359,  361,  359,  358,
-      358,  294,  358,  358,  359,  359,  294,  359,  359,  360,
-      355,  361,  356,    0,  294,  294,  294,  294,  294,  294,
-
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294
-    } ;
-
-static const flex_int16_t yy_nxt[1247] =
-    {   0,
-       28,   29,   30,   29,   31,   32,   33,   34,   35,   36,
-       37,   38,   34,   39,   40,   41,   42,   42,   43,   44,
-       45,   46,   47,   35,   48,   49,   48,   48,   50,   48,
-       51,   48,   48,   52,   53,   28,   52,   53,   57,   86,
-       71,   57,   57,   65,   72,   58,   57,   57,   86,   59,
-       66,  275,   65,   57,   57,   57,   71,   57,   57,   66,
-       72,   57,   57,   95,  270,   58,   57,   57,  103,   59,
-      104,   96,   87,   57,   57,   57,   67,   57,   88,   88,
-       88,   87,   88,   88,   88,   67,   75,   76,   75,   91,
-       97,  121,   98,   98,  100,  122,  101,  101,   77,   92,
-
-       92,  105,  106,  109,  109,  117,  118,  118,  102,  144,
-      144,  144,  268,  127,  128,  128,  136,  119,   78,   92,
-       92,   78,   75,   76,   75,  129,  266,  131,  132,  132,
-      131,  132,  132,  137,   77,  133,  138,  139,  133,  134,
-      109,  109,  134,  144,  144,  144,  150,  150,  150,  150,
-      150,  150,  153,  254,   78,  154,  253,   78,   81,   82,
-       81,  147,  148,  148,   88,   88,   88,   98,   98,  133,
-       83,  249,  159,  149,  160,  160,  162,  162,  100,  102,
-      101,  101,  247,  161,  161,  163,  102,  162,  162,  164,
-       84,  239,  102,   84,   81,   82,   81,  117,  118,  118,
-
-      165,  165,  165,  121,  162,  162,   83,  122,  166,  119,
-      160,  160,  167,  127,  128,  128,  170,  170,  170,  131,
-      132,  132,  102,  233,  171,  129,   84,  213,  172,   84,
-      157,  134,  209,  157,  157,  208,  142,  157,  157,  157,
-      204,  157,  174,  174,  174,  157,  157,  157,  200,  157,
-      175,  144,  144,  144,  176,  147,  148,  148,  185,  185,
-      185,  150,  150,  150,  196,  192,  175,  149,   91,  189,
-      186,  157,  187,  184,  157,  157,  142,  178,  157,  157,
-      157,  177,  157,  165,  165,  165,  157,  157,  157,  173,
-      157,  166,  194,  118,  118,  167,  168,  170,  170,  170,
-
-      198,  128,  128,   91,  195,  171,  174,  174,  174,  172,
-      152,  151,  199,  146,  175,  202,  132,  132,  176,  145,
-      185,  185,  185,  211,  148,  148,  125,  203,  175,  217,
-      218,  218,  186,  142,  125,  212,  194,  118,  118,  123,
-      115,  219,  194,  118,  118,  194,  118,  118,  195,  222,
-      223,  223,  114,  113,  195,  112,  111,  220,  198,  128,
-      128,  224,  198,  128,  128,  198,  128,  128,  108,  107,
-      199,  227,  228,  228,  199,   99,   94,  225,  202,  132,
-      132,   90,  294,  229,  202,  132,  132,  202,  132,  132,
-      203,  235,  236,  236,   79,   79,  203,   73,   73,  230,
-
-      211,  148,  148,  237,  211,  148,  148,  211,  148,  148,
-       69,   69,  212,  217,  218,  218,  212,   63,   63,  238,
-      217,  218,  218,   61,   61,  219,  165,  165,  165,  217,
-      218,  218,  219,   55,  166,  194,  118,  118,  167,   55,
-      294,  242,  222,  223,  223,  294,  294,  220,  222,  223,
-      223,  170,  170,  170,  224,  222,  223,  223,  294,  171,
-      224,  294,  294,  172,  198,  128,  128,  243,  227,  228,
-      228,  227,  228,  228,  294,  294,  225,  174,  174,  174,
-      229,  294,  294,  229,  294,  175,  227,  228,  228,  176,
-      202,  132,  132,  235,  236,  236,  294,  294,  244,  235,
-
-      236,  236,  230,  294,  294,  237,  185,  185,  185,  294,
-      294,  237,  294,  294,  175,  235,  236,  236,  186,  211,
-      148,  148,  217,  218,  218,  294,  294,  248,  222,  223,
-      223,  238,  294,  294,  242,  227,  228,  228,  294,  294,
-      243,  235,  236,  236,  257,  257,  257,  244,  294,  260,
-      260,  260,  258,  248,  294,  294,  259,  261,  257,  257,
-      257,  262,  294,  260,  260,  260,  258,  294,  294,  294,
-      259,  261,  272,  257,  257,  262,  294,  277,  260,  260,
-      273,  294,  294,  294,  274,  278,  272,  257,  257,  279,
-      294,  272,  257,  257,  273,  294,  294,  294,  274,  273,
-
-      281,  282,  282,  274,  294,  272,  257,  257,  273,  294,
-      294,  294,  283,  273,  277,  260,  260,  284,  294,  277,
-      260,  260,  278,  294,  294,  294,  279,  278,  286,  287,
-      287,  279,  294,  277,  260,  260,  278,  294,  294,  294,
-      288,  278,  272,  257,  257,  289,  294,  272,  257,  257,
-      290,  294,  294,  294,  274,  290,  257,  257,  257,  274,
-      294,  272,  257,  257,  291,  294,  294,  294,  259,  290,
-      272,  257,  257,  284,  294,  277,  260,  260,  273,  294,
-      294,  294,  284,  292,  277,  260,  260,  279,  294,  260,
-      260,  260,  292,  294,  294,  294,  279,  293,  277,  260,
-
-      260,  262,  294,  277,  260,  260,  292,  294,  294,  294,
-      289,  278,  281,  282,  282,  289,  294,  286,  287,  287,
-      273,  294,  294,  294,  283,  278,  294,  294,  294,  288,
-       54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
-       54,   56,   56,   56,   56,   56,   56,   56,   56,   56,
-       56,   56,   60,   60,   60,   60,   60,   60,   60,   60,
-       60,   60,   60,   62,   62,   62,   62,   62,   62,   62,
-       62,   62,   62,   62,   64,   64,   64,   64,   64,   64,
-       64,   64,   64,   64,   64,   68,   68,   68,   68,   68,
-       68,   68,   68,   68,   68,   68,   70,   70,   70,   70,
-
-       70,   70,   70,   70,   70,   70,   70,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   80,   80,
-       80,   80,   80,   80,   80,   80,   80,   80,   80,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       89,  294,  294,  294,   89,   93,  294,  294,   93,   93,
-       93,  110,  294,  294,  110,  110,  110,  116,  116,  116,
-      116,  116,  294,  116,  116,  116,  116,  116,  120,  120,
-      120,  120,  120,  120,  294,  120,  120,  120,  120,  124,
-      124,  124,  294,  124,  124,  124,  124,  124,  124,  124,
-      126,  126,  126,  126,  126,  294,  126,  126,  126,  126,
-
-      126,  130,  130,  130,  130,  130,  294,  130,  130,  130,
-      130,  135,  135,  135,  135,  135,  135,  135,  135,  135,
-      135,  135,  140,  140,  140,  140,  140,  294,  140,  140,
-      140,  140,  140,  141,  141,  141,  141,  294,  141,  141,
-      141,  141,  141,  141,  143,  294,  294,  294,  143,  143,
-      155,  294,  294,  155,  155,  155,  156,  294,  156,  156,
-      156,  156,  156,  156,  156,  156,  156,  158,  294,  294,
-      294,  158,  169,  294,  294,  294,  169,  179,  179,  180,
-      180,  181,  181,  182,  294,  294,  182,  182,  182,  183,
-      294,  183,  183,  183,  183,  183,  183,  183,  183,  183,
-
-      188,  294,  188,  188,  188,  188,  188,  188,  188,  188,
-      188,  190,  190,  191,  191,  193,  193,  193,  193,  193,
-      193,  193,  193,  193,  193,  193,  197,  197,  197,  197,
-      197,  197,  197,  197,  197,  197,  197,  201,  201,  201,
-      201,  201,  201,  201,  201,  201,  201,  201,  205,  205,
-      206,  206,  207,  207,  210,  210,  210,  210,  210,  210,
-      210,  210,  210,  210,  210,  214,  214,  215,  215,  216,
-      216,  216,  216,  216,  216,  216,  216,  216,  216,  216,
-      221,  221,  221,  221,  221,  221,  221,  221,  221,  221,
-      221,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-
-      226,  226,  231,  231,  232,  232,  234,  234,  234,  234,
-      234,  234,  234,  234,  234,  234,  234,  240,  240,  241,
-      241,  245,  245,  246,  246,  250,  250,  251,  251,  252,
-      252,  255,  255,  256,  256,  263,  263,  264,  264,  265,
-      265,  265,  265,  265,  294,  265,  265,  265,  265,  265,
-      267,  267,  267,  267,  267,  294,  267,  267,  267,  267,
-      267,  269,  269,  271,  271,  271,  271,  271,  271,  271,
-      271,  271,  271,  271,  276,  276,  276,  276,  276,  276,
-      276,  276,  276,  276,  276,  280,  280,  280,  280,  280,
-      280,  280,  280,  280,  280,  280,  285,  285,  285,  285,
-
-      285,  285,  285,  285,  285,  285,  285,   27,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294
-    } ;
-
-static const flex_int16_t yy_chk[1247] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    5,   25,
-       15,    5,    5,   11,   15,    5,    5,    5,   26,    5,
-       11,  267,   12,    5,    5,    5,   16,    5,    6,   12,
-       16,    6,    6,   39,  265,    6,    6,    6,   43,    6,
-       43,   39,   25,    6,    6,    6,   11,    6,   29,   29,
-       29,   26,   30,   30,   30,   12,   19,   19,   19,   33,
-       40,   58,   40,   40,   42,   58,   42,   42,   19,   33,
-
-       33,   44,   44,   47,   47,   55,   55,   55,   42,   75,
-       75,   75,  262,   63,   63,   63,   67,   55,   19,   92,
-       92,   19,   20,   20,   20,   63,  259,   66,   66,   66,
-       69,   69,   69,   67,   20,   66,   67,   67,   69,   66,
-      109,  109,   69,   76,   76,   76,   81,   81,   81,   82,
-       82,   82,   87,  249,   20,   87,  247,   20,   23,   23,
-       23,   79,   79,   79,   88,   88,   88,   98,   98,   79,
-       23,  239,  100,   79,  100,  100,  161,  161,  101,   98,
-      101,  101,  233,  102,  102,  114,  100,  102,  102,  114,
-       23,  213,  101,   23,   24,   24,   24,  117,  117,  117,
-
-      118,  118,  118,  121,  162,  162,   24,  121,  118,  117,
-      160,  160,  118,  127,  127,  127,  128,  128,  128,  131,
-      131,  131,  160,  208,  128,  127,   24,  189,  128,   24,
-       95,  131,  186,   95,   95,  184,  182,   95,   95,   95,
-      178,   95,  132,  132,  132,   95,   95,   95,  176,   95,
-      132,  144,  144,  144,  132,  147,  147,  147,  148,  148,
-      148,  150,  150,  150,  172,  167,  148,  147,  155,  152,
-      148,  157,  149,  146,  157,  157,  143,  136,  157,  157,
-      157,  134,  157,  165,  165,  165,  157,  157,  157,  129,
-      157,  165,  168,  168,  168,  165,  119,  170,  170,  170,
-
-      173,  173,  173,   93,  168,  170,  174,  174,  174,  170,
-       84,   83,  173,   78,  174,  177,  177,  177,  174,   77,
-      185,  185,  185,  187,  187,  187,   73,  177,  185,  192,
-      192,  192,  185,   72,   61,  187,  193,  193,  193,   59,
-       53,  192,  194,  194,  194,  195,  195,  195,  193,  196,
-      196,  196,   52,   51,  194,   50,   49,  195,  197,  197,
-      197,  196,  198,  198,  198,  199,  199,  199,   46,   45,
-      197,  200,  200,  200,  198,   41,   38,  199,  201,  201,
-      201,   31,   27,  200,  202,  202,  202,  203,  203,  203,
-      201,  209,  209,  209,   22,   21,  202,   18,   17,  203,
-
-      210,  210,  210,  209,  211,  211,  211,  212,  212,  212,
-       14,   13,  210,  216,  216,  216,  211,   10,    9,  212,
-      217,  217,  217,    8,    7,  216,  218,  218,  218,  219,
-      219,  219,  217,    4,  218,  220,  220,  220,  218,    3,
-        0,  219,  221,  221,  221,    0,    0,  220,  222,  222,
-      222,  223,  223,  223,  221,  224,  224,  224,    0,  223,
-      222,    0,    0,  223,  225,  225,  225,  224,  226,  226,
-      226,  227,  227,  227,    0,    0,  225,  228,  228,  228,
-      226,    0,    0,  227,    0,  228,  229,  229,  229,  228,
-      230,  230,  230,  234,  234,  234,    0,    0,  229,  235,
-
-      235,  235,  230,    0,    0,  234,  236,  236,  236,    0,
-        0,  235,    0,    0,  236,  237,  237,  237,  236,  238,
-      238,  238,  242,  242,  242,    0,    0,  237,  243,  243,
-      243,  238,    0,    0,  242,  244,  244,  244,    0,    0,
-      243,  248,  248,  248,  253,  253,  253,  244,    0,  254,
-      254,  254,  253,  248,    0,    0,  253,  254,  257,  257,
-      257,  254,    0,  260,  260,  260,  257,    0,    0,    0,
-      257,  260,  266,  266,  266,  260,    0,  268,  268,  268,
-      266,    0,    0,    0,  266,  268,  271,  271,  271,  268,
-        0,  272,  272,  272,  271,    0,    0,    0,  271,  272,
-
-      273,  273,  273,  272,    0,  274,  274,  274,  273,    0,
-        0,    0,  273,  274,  276,  276,  276,  274,    0,  277,
-      277,  277,  276,    0,    0,    0,  276,  277,  278,  278,
-      278,  277,    0,  279,  279,  279,  278,    0,    0,    0,
-      278,  279,  280,  280,  280,  279,    0,  281,  281,  281,
-      280,    0,    0,    0,  280,  281,  282,  282,  282,  281,
-        0,  283,  283,  283,  282,    0,    0,    0,  282,  283,
-      284,  284,  284,  283,    0,  285,  285,  285,  284,    0,
-        0,    0,  284,  285,  286,  286,  286,  285,    0,  287,
-      287,  287,  286,    0,    0,    0,  286,  287,  288,  288,
-
-      288,  287,    0,  289,  289,  289,  288,    0,    0,    0,
-      288,  289,  290,  290,  290,  289,    0,  292,  292,  292,
-      290,    0,    0,    0,  290,  292,    0,    0,    0,  292,
-      295,  295,  295,  295,  295,  295,  295,  295,  295,  295,
-      295,  296,  296,  296,  296,  296,  296,  296,  296,  296,
-      296,  296,  297,  297,  297,  297,  297,  297,  297,  297,
-      297,  297,  297,  298,  298,  298,  298,  298,  298,  298,
-      298,  298,  298,  298,  299,  299,  299,  299,  299,  299,
-      299,  299,  299,  299,  299,  300,  300,  300,  300,  300,
-      300,  300,  300,  300,  300,  300,  301,  301,  301,  301,
-
-      301,  301,  301,  301,  301,  301,  301,  302,  302,  302,
-      302,  302,  302,  302,  302,  302,  302,  302,  303,  303,
-      303,  303,  303,  303,  303,  303,  303,  303,  303,  304,
-      304,  304,  304,  304,  304,  304,  304,  304,  304,  304,
-      305,    0,    0,    0,  305,  306,    0,    0,  306,  306,
-      306,  307,    0,    0,  307,  307,  307,  308,  308,  308,
-      308,  308,    0,  308,  308,  308,  308,  308,  309,  309,
-      309,  309,  309,  309,    0,  309,  309,  309,  309,  310,
-      310,  310,    0,  310,  310,  310,  310,  310,  310,  310,
-      311,  311,  311,  311,  311,    0,  311,  311,  311,  311,
-
-      311,  312,  312,  312,  312,  312,    0,  312,  312,  312,
-      312,  313,  313,  313,  313,  313,  313,  313,  313,  313,
-      313,  313,  314,  314,  314,  314,  314,    0,  314,  314,
-      314,  314,  314,  315,  315,  315,  315,    0,  315,  315,
-      315,  315,  315,  315,  316,    0,    0,    0,  316,  316,
-      317,    0,    0,  317,  317,  317,  318,    0,  318,  318,
-      318,  318,  318,  318,  318,  318,  318,  319,    0,    0,
-        0,  319,  320,    0,    0,    0,  320,  321,  321,  322,
-      322,  323,  323,  324,    0,    0,  324,  324,  324,  325,
-        0,  325,  325,  325,  325,  325,  325,  325,  325,  325,
-
-      326,    0,  326,  326,  326,  326,  326,  326,  326,  326,
-      326,  327,  327,  328,  328,  329,  329,  329,  329,  329,
-      329,  329,  329,  329,  329,  329,  330,  330,  330,  330,
-      330,  330,  330,  330,  330,  330,  330,  331,  331,  331,
-      331,  331,  331,  331,  331,  331,  331,  331,  332,  332,
-      333,  333,  334,  334,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  336,  336,  337,  337,  338,
-      338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  340,  340,  340,  340,  340,  340,  340,  340,  340,
-
-      340,  340,  341,  341,  342,  342,  343,  343,  343,  343,
-      343,  343,  343,  343,  343,  343,  343,  344,  344,  345,
-      345,  346,  346,  347,  347,  348,  348,  349,  349,  350,
-      350,  351,  351,  352,  352,  353,  353,  354,  354,  355,
-      355,  355,  355,  355,    0,  355,  355,  355,  355,  355,
-      356,  356,  356,  356,  356,    0,  356,  356,  356,  356,
-      356,  357,  357,  358,  358,  358,  358,  358,  358,  358,
-      358,  358,  358,  358,  359,  359,  359,  359,  359,  359,
-      359,  359,  359,  359,  359,  360,  360,  360,  360,  360,
-      360,  360,  360,  360,  360,  360,  361,  361,  361,  361,
-
-      361,  361,  361,  361,  361,  361,  361,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
-      294,  294,  294,  294,  294,  294
-    } ;
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
- */
-#define REJECT reject_used_but_not_detected
-#define yymore() yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-#define YY_RESTORE_YY_MORE_OFFSET
-#line 1 "third_party/libpg_query/scan.l"
-
-#line 46 "third_party/libpg_query/scan.l"
-
-/* LCOV_EXCL_START */
-
-/*
- * GUC variables.  This is a DIRECT violation of the warning given at the
- * head of gram.y, ie flex/bison code must not depend on any GUC variables;
- * as such, changing their values can induce very unintuitive behavior.
- * But we shall have to live with it until we can remove these variables.
- */
-
-int			backslash_quote = PG_BACKSLASH_QUOTE_SAFE_ENCODING;
-bool		escape_string_warning = true;
-bool		standard_conforming_strings = true;
-
-/*
- * Set the type of YYSTYPE.
- */
-#define YYSTYPE core_YYSTYPE
-
-/*
- * Set the type of yyextra.  All state variables used by the scanner should
- * be in yyextra, *not* statically allocated.
- */
-#define YY_EXTRA_TYPE core_yy_extra_type *
-
-/*
- * Each call to yylex must set yylloc to the location of the found token
- * (expressed as a byte offset from the start of the input text).
- * When we parse a token that requires multiple lexer rules to process,
- * this should be done in the first such rule, else yylloc will point
- * into the middle of the token.
- */
-#define SET_YYLLOC()  (*(yylloc) = yytext - yyextra->scanbuf)
-
-/*
- * Advance yylloc by the given number of bytes.
- */
-#define ADVANCE_YYLLOC(delta)  ( *(yylloc) += (delta) )
-
-#define startlit()	( yyextra->literallen = 0 )
-static void addlit(char *ytext, int yleng, core_yyscan_t yyscanner);
-static void addlitchar(unsigned char ychar, core_yyscan_t yyscanner);
-static char *litbufdup(core_yyscan_t yyscanner);
-static char *litbuf_udeescape(unsigned char escape, core_yyscan_t yyscanner);
-static unsigned char unescape_single_char(unsigned char c, core_yyscan_t yyscanner);
-static int	process_integer_literal(const char *token, YYSTYPE *lval);
-static bool is_utf16_surrogate_first(pg_wchar c);
-static bool is_utf16_surrogate_second(pg_wchar c);
-static pg_wchar surrogate_pair_to_codepoint(pg_wchar first, pg_wchar second);
-static void addunicode(pg_wchar c, yyscan_t yyscanner);
-static bool check_uescapechar(unsigned char escape);
-
-#define yyerror(msg)  scanner_yyerror(msg, yyscanner)
-
-#define lexer_errposition()  scanner_errposition(*(yylloc), yyscanner)
-
-static void check_string_escape_warning(unsigned char ychar, core_yyscan_t yyscanner);
-static void check_escape_warning(core_yyscan_t yyscanner);
-
-/*
- * Work around a bug in flex 2.5.35: it emits a couple of functions that
- * it forgets to emit declarations for.  Since we use -Wmissing-prototypes,
- * this would cause warnings.  Providing our own declarations should be
- * harmless even when the bug gets fixed.
- */
-extern int	core_yyget_column(yyscan_t yyscanner);
-extern void core_yyset_column(int column_no, yyscan_t yyscanner);
-
-#line 1151 "third_party/libpg_query/src_backend_parser_scan.cpp"
-#define YY_NO_INPUT 1
-/*
- * OK, here is a short description of lex/flex rules behavior.
- * The longest pattern which matches an input string is always chosen.
- * For equal-length patterns, the first occurring in the rules list is chosen.
- * INITIAL is the starting state, to which all non-conditional rules apply.
- * Exclusive states change parsing rules while the state is active.  When in
- * an exclusive state, only those rules defined for that state apply.
- *
- * We use exclusive states for quoted strings, extended comments,
- * and to eliminate parsing troubles for numeric strings.
- * Exclusive states:
- *  <xb> bit string literal
- *  <xc> extended C-style comments
- *  <xd> delimited identifiers (double-quoted identifiers)
- *  <xh> hexadecimal numeric string
- *  <xq> standard quoted strings
- *  <xe> extended quoted strings (support backslash escape sequences)
- *  <xdolq> $foo$ quoted strings
- *  <xui> quoted identifier with Unicode escapes
- *  <xuiend> end of a quoted identifier with Unicode escapes, UESCAPE can follow
- *  <xus> quoted string with Unicode escapes
- *  <xusend> end of a quoted string with Unicode escapes, UESCAPE can follow
- *  <xeu> Unicode surrogate pair in extended quoted string
- *
- * Remember to add an <<EOF>> case whenever you add a new exclusive state!
- * The default one is probably not the right thing.
- */
-
-/*
- * In order to make the world safe for Windows and Mac clients as well as
- * Unix ones, we accept either \n or \r as a newline.  A DOS-style \r\n
- * sequence will be seen as two successive newlines, but that doesn't cause '
- * any problems.  Comments that start with -- and extend to the next
- * newline are treated as equivalent to a single whitespace character.
- *
- * NOTE a fine point: if there is no newline following --, we will absorb
- * everything to the end of the input as a comment.  This is correct.  Older
- * versions of Postgres failed to recognize -- as a comment if the input
- * did not end with a newline.
- *
- * XXX perhaps \f (formfeed) should be treated as a newline as well?
- *
- * XXX if you change the set of whitespace characters, fix scanner_isspace()
- * to agree, and see also the plpgsql lexer.
- */
-/*
- * SQL requires at least one newline in the whitespace separating
- * string literals that are to be concatenated.  Silly, but who are we
- * to argue?  Note that {whitespace_with_newline} should not have * after
- * it, whereas {whitespace} should generally have a * after it...
- */
-/*
- * To ensure that {quotecontinue} can be scanned without having to back up
- * if the full pattern isn't matched, we include trailing whitespace in
- * {quotestop}.  This matches all cases where {quotecontinue} fails to match,
- * except for {quote} followed by whitespace and just one "-" (not two,
- * which would start a {comment}).  To cover that we have {quotefail}.
- * The actions for {quotestop} and {quotefail} must throw back characters
- * beyond the quote proper.
- */
-/* Bit string
- * It is tempting to scan the string for only those characters
- * which are allowed. However, this leads to silently swallowed
- * characters if illegal characters are included in the string.
- * For example, if xbinside is [01] then B'ABCD' is interpreted
- * as a zero-length string, and the ABCD' is lost!
- * Better to pass the string forward and let the input routines
- * validate the contents.
- */
-/* Hexadecimal number */
-/* National character */
-/* Quoted string that allows backslash escapes */
-/* Extended quote
- * xqdouble implements embedded quote, ''''
- */
-/* $foo$ style quotes ("dollar quoting")
- * The quoted string starts with $foo$ where "foo" is an optional string
- * in the form of an identifier, except that it may not contain "$",
- * and extends to the first occurrence of an identical string.
- * There is *no* processing of the quoted text.
- *
- * {dolqfailed} is an error rule to avoid scanner backup when {dolqdelim}
- * fails to match its trailing "$".
- */
-/* Double quote
- * Allows embedded spaces and other special characters into identifiers.
- */
-/* Unicode escapes */
-/* error rule to avoid backup */
-/* Quoted identifier with Unicode escapes */
-/* Quoted string with Unicode escapes */
-/* Optional UESCAPE after a quoted string or identifier with Unicode escapes. */
-/* error rule to avoid backup */
-/* C-style comments
- *
- * The "extended comment" syntax closely resembles allowable operator syntax.
- * The tricky part here is to get lex to recognize a string starting with
- * slash-star as a comment, when interpreting it as an operator would produce
- * a longer match --- remember lex will prefer a longer match!  Also, if we
- * have something like plus-slash-star, lex will think this is a 3-character
- * operator whereas we want to see it as a + operator and a comment start.
- * The solution is two-fold:
- * 1. append {op_chars}* to xcstart so that it matches as much text as
- *    {operator} would. Then the tie-breaker (first matching rule of same
- *    length) ensures xcstart wins.  We put back the extra stuff with yyless()
- *    in case it contains a star-slash that should terminate the comment.
- * 2. In the operator rule, check for slash-star within the operator, and
- *    if found throw it back with yyless().  This handles the plus-slash-star
- *    problem.
- * Dash-dash comments have similar interactions with the operator rule.
- */
-/* Assorted special-case operators and operator-like tokens */
-/* " */
-/*
- * These operator-like tokens (unlike the above ones) also match the {operator}
- * rule, which means that they might be overridden by a longer match if they
- * are followed by a comment start or a + or - character. Accordingly, if you
- * add to this list, you must also add corresponding code to the {operator}
- * block to return the correct token in such cases. (This is not needed in
- * psqlscan.l since the token value is ignored there.)
- */
-/*
- * "self" is the set of chars that should be returned as single-character
- * tokens.  "op_chars" is the set of chars that can make up "Op" tokens,
- * which can be one or more characters long (but if a single-char token
- * appears in the "self" set, it is not to be returned as an Op).  Note
- * that the sets overlap, but each has some chars that are not in the other.
- *
- * If you change either set, adjust the character lists appearing in the
- * rule for "operator"!
- */
-/* we no longer allow unary minus in numbers.
- * instead we pass it separately to parser. there it gets
- * coerced via doNegate() -- Leon aug 20 1999
- *
- * {decimalfail} is used because we would like "1..10" to lex as 1, dot_dot, 10.
- *
- * {realfail1} and {realfail2} are added to prevent the need for scanner
- * backup when the {real} rule fails to match completely.
- */
-/*
- * Dollar quoted strings are totally opaque, and no escaping is done on them.
- * Other quoted strings must allow some special characters such as single-quote
- *  and newline.
- * Embedded single-quotes are implemented both in the SQL standard
- *  style of two adjacent single quotes "''" and in the Postgres/Java style
- *  of escaped-quote "\'".
- * Other embedded escaped characters are matched explicitly and the leading
- *  backslash is dropped from the string.
- * Note that xcstart must appear before operator, as explained above!
- *  Also whitespace (comment) must appear before operator.
- */
-#line 1305 "third_party/libpg_query/src_backend_parser_scan.cpp"
-
-#define INITIAL 0
-#define xb 1
-#define xc 2
-#define xd 3
-#define xh 4
-#define xe 5
-#define xq 6
-#define xdolq 7
-#define xui 8
-#define xuiend 9
-#define xus 10
-#define xusend 11
-#define xeu 12
-
-#ifndef YY_EXTRA_TYPE
-#define YY_EXTRA_TYPE void *
-#endif
-
-/* Holds the entire state of the reentrant scanner. */
-struct yyguts_t
-    {
-
-    /* User-defined. Not touched by flex. */
-    YY_EXTRA_TYPE yyextra_r;
-
-    /* The rest are the same as the globals declared in the non-reentrant scanner. */
-    FILE *yyin_r, *yyout_r;
-    size_t yy_buffer_stack_top; /**< index of top of stack. */
-    size_t yy_buffer_stack_max; /**< capacity of stack. */
-    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
-    char yy_hold_char;
-    yy_size_t yy_n_chars;
-    yy_size_t yyleng_r;
-    char *yy_c_buf_p;
-    int yy_init;
-    int yy_start;
-    int yy_did_buffer_switch_on_eof;
-    int yy_start_stack_ptr;
-    int yy_start_stack_depth;
-    int *yy_start_stack;
-    yy_state_type yy_last_accepting_state;
-    char* yy_last_accepting_cpos;
-
-    int yylineno_r;
-    int yy_flex_debug_r;
-
-    char *yytext_r;
-    int yy_more_flag;
-    int yy_more_len;
-
-    YYSTYPE * yylval_r;
-
-    YYLTYPE * yylloc_r;
-
-    }; /* end struct yyguts_t */
-
-static int yy_init_globals ( yyscan_t yyscanner );
-
-    /* This must go here because YYSTYPE and YYLTYPE are included
-     * from bison output in section 1.*/
-    #    define yylval yyg->yylval_r
-    
-    #    define yylloc yyg->yylloc_r
-    
-int yylex_init (yyscan_t* scanner);
-
-int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
-
-/* Accessor methods to globals.
-   These are made visible to non-reentrant scanners for convenience. */
-
-int yylex_destroy ( yyscan_t yyscanner );
-
-int yyget_debug ( yyscan_t yyscanner );
-
-void yyset_debug ( int debug_flag , yyscan_t yyscanner );
-
-YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
-
-void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
-
-FILE *yyget_in ( yyscan_t yyscanner );
-
-void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
-
-FILE *yyget_out ( yyscan_t yyscanner );
-
-void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
-
-			yy_size_t yyget_leng ( yyscan_t yyscanner );
-
-char *yyget_text ( yyscan_t yyscanner );
-
-int yyget_lineno ( yyscan_t yyscanner );
-
-void yyset_lineno ( int _line_number , yyscan_t yyscanner );
-
-int yyget_column  ( yyscan_t yyscanner );
-
-void yyset_column ( int _column_no , yyscan_t yyscanner );
-
-YYSTYPE * yyget_lval ( yyscan_t yyscanner );
-
-void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
-
-       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
-    
-        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
-    
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap ( yyscan_t yyscanner );
-#else
-extern int yywrap ( yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef YY_NO_UNPUT
-    
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput ( yyscan_t yyscanner );
-#else
-static int input ( yyscan_t yyscanner );
-#endif
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-#ifndef ECHO
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
-#endif
-
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
- * is returned in "result".
- */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-		{ \
-		int c = '*'; \
-		yy_size_t n; \
-		for ( n = 0; n < max_size && \
-			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
-			buf[n] = (char) c; \
-		if ( c == '\n' ) \
-			buf[n++] = (char) c; \
-		if ( c == EOF && ferror( yyin ) ) \
-			YY_FATAL_ERROR( "input in flex scanner failed" ); \
-		result = n; \
-		} \
-	else \
-		{ \
-		errno=0; \
-		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
-			{ \
-			if( errno != EINTR) \
-				{ \
-				YY_FATAL_ERROR( "input in flex scanner failed" ); \
-				break; \
-				} \
-			errno=0; \
-			clearerr(yyin); \
-			} \
-		}\
-\
-
-#endif
-
-/* No semi-colon after return; correct usage is to write "yyterminate();" -
- * we don't want an extra ';' after the "return" because that will cause
- * some compilers to complain about unreachable statements.
- */
-#ifndef yyterminate
-#define yyterminate() return YY_NULL
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
-#endif
-
-/* end tables serialization structures and prototypes */
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int yylex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
-
-#define YY_DECL int yylex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * have been set up.
- */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
-#endif
-
-/* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK /*LINTED*/break;
-#endif
-
-#define YY_RULE_SETUP \
-	YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
-	yy_state_type yy_current_state;
-	char *yy_cp, *yy_bp;
-	int yy_act;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-    yylval = yylval_param;
-
-    yylloc = yylloc_param;
-
-	if ( !yyg->yy_init )
-		{
-		yyg->yy_init = 1;
-
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
-#endif
-
-		if ( ! yyg->yy_start )
-			yyg->yy_start = 1;	/* first start state */
-		if ( ! YY_CURRENT_BUFFER ) {
-			yyensure_buffer_stack (yyscanner);
-			YY_CURRENT_BUFFER_LVALUE =
-				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
-		}
-
-		yy_load_buffer_state( yyscanner );
-		}
-
-	{
-#line 402 "third_party/libpg_query/scan.l"
-
-
-#line 1594 "third_party/libpg_query/src_backend_parser_scan.cpp"
-
-	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
-		{
-		yy_cp = yyg->yy_c_buf_p;
-
-		/* Support of yytext. */
-		*yy_cp = yyg->yy_hold_char;
-
-		/* yy_bp points to the position in yy_ch_buf of the start of
-		 * the current run.
-		 */
-		yy_bp = yy_cp;
-
-		yy_current_state = yyg->yy_start;
-yy_match:
-		do
-			{
-			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
-			if ( yy_accept[yy_current_state] )
-				{
-				yyg->yy_last_accepting_state = yy_current_state;
-				yyg->yy_last_accepting_cpos = yy_cp;
-				}
-			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-				{
-				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 295 )
-					yy_c = yy_meta[yy_c];
-				}
-			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-			++yy_cp;
-			}
-		while ( yy_current_state != 294 );
-		yy_cp = yyg->yy_last_accepting_cpos;
-		yy_current_state = yyg->yy_last_accepting_state;
-
-yy_find_action:
-		yy_act = yy_accept[yy_current_state];
-
-		YY_DO_BEFORE_ACTION;
-
-do_action:	/* This label is used only to access EOF actions. */
-
-		switch ( yy_act )
-	{ /* beginning of action switch */
-			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
-			*yy_cp = yyg->yy_hold_char;
-			yy_cp = yyg->yy_last_accepting_cpos;
-			yy_current_state = yyg->yy_last_accepting_state;
-			goto yy_find_action;
-
-case 1:
-/* rule 1 can match eol */
-YY_RULE_SETUP
-#line 404 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case 2:
-YY_RULE_SETUP
-#line 408 "third_party/libpg_query/scan.l"
-{
-					/* Set location in case of syntax error in comment */
-					SET_YYLLOC();
-					yyextra->xcdepth = 0;
-					BEGIN(xc);
-					/* Put back any characters past slash-star; see above */
-					yyless(2);
-				}
-	YY_BREAK
-case 3:
-YY_RULE_SETUP
-#line 417 "third_party/libpg_query/scan.l"
-{
-					(yyextra->xcdepth)++;
-					/* Put back any characters past slash-star; see above */
-					yyless(2);
-				}
-	YY_BREAK
-case 4:
-YY_RULE_SETUP
-#line 423 "third_party/libpg_query/scan.l"
-{
-					if (yyextra->xcdepth <= 0)
-						BEGIN(INITIAL);
-					else
-						(yyextra->xcdepth)--;
-				}
-	YY_BREAK
-case 5:
-/* rule 5 can match eol */
-YY_RULE_SETUP
-#line 430 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case 6:
-YY_RULE_SETUP
-#line 434 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case 7:
-YY_RULE_SETUP
-#line 438 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case YY_STATE_EOF(xc):
-#line 442 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated /* comment"); }
-	YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 444 "third_party/libpg_query/scan.l"
-{
-					/* Binary bit type.
-					 * At some point we should simply pass the string
-					 * forward to the parser and label it there.
-					 * In the meantime, place a leading "b" on the string
-					 * to mark it for the input routine as a binary string.
-					 */
-					SET_YYLLOC();
-					BEGIN(xb);
-					startlit();
-					addlitchar('b', yyscanner);
-				}
-	YY_BREAK
-case 9:
-/* rule 9 can match eol */
-#line 457 "third_party/libpg_query/scan.l"
-case 10:
-/* rule 10 can match eol */
-YY_RULE_SETUP
-#line 457 "third_party/libpg_query/scan.l"
-{
-					yyless(1);
-					BEGIN(INITIAL);
-					yylval->str = litbufdup(yyscanner);
-					return BCONST;
-				}
-	YY_BREAK
-case 11:
-/* rule 11 can match eol */
-#line 464 "third_party/libpg_query/scan.l"
-case 12:
-/* rule 12 can match eol */
-YY_RULE_SETUP
-#line 464 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 13:
-/* rule 13 can match eol */
-#line 468 "third_party/libpg_query/scan.l"
-case 14:
-/* rule 14 can match eol */
-YY_RULE_SETUP
-#line 468 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case YY_STATE_EOF(xb):
-#line 471 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated bit string literal"); }
-	YY_BREAK
-case 15:
-YY_RULE_SETUP
-#line 473 "third_party/libpg_query/scan.l"
-{
-					/* Hexadecimal bit type.
-					 * At some point we should simply pass the string
-					 * forward to the parser and label it there.
-					 * In the meantime, place a leading "x" on the string
-					 * to mark it for the input routine as a hex string.
-					 */
-					SET_YYLLOC();
-					BEGIN(xh);
-					startlit();
-					addlitchar('x', yyscanner);
-				}
-	YY_BREAK
-case 16:
-/* rule 16 can match eol */
-#line 486 "third_party/libpg_query/scan.l"
-case 17:
-/* rule 17 can match eol */
-YY_RULE_SETUP
-#line 486 "third_party/libpg_query/scan.l"
-{
-					yyless(1);
-					BEGIN(INITIAL);
-					yylval->str = litbufdup(yyscanner);
-					return XCONST;
-				}
-	YY_BREAK
-case YY_STATE_EOF(xh):
-#line 492 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated hexadecimal string literal"); }
-	YY_BREAK
-case 18:
-YY_RULE_SETUP
-#line 494 "third_party/libpg_query/scan.l"
-{
-					/* National character.
-					 * We will pass this along as a normal character string,
-					 * but preceded with an internally-generated "NCHAR".
-					 */
-					const PGScanKeyword *keyword;
-
-					SET_YYLLOC();
-					yyless(1);	/* eat only 'n' this time */
-
-					keyword = ScanKeywordLookup("nchar",
-												yyextra->keywords,
-												yyextra->num_keywords);
-					if (keyword != NULL)
-					{
-						yylval->keyword = keyword->name;
-						return keyword->value;
-					}
-					else
-					{
-						/* If NCHAR isn't a keyword, just return "n" */
-						yylval->str = pstrdup("n");
-						return IDENT;
-					}
-				}
-	YY_BREAK
-case 19:
-YY_RULE_SETUP
-#line 520 "third_party/libpg_query/scan.l"
-{
-					yyextra->warn_on_first_escape = true;
-					yyextra->saw_non_ascii = false;
-					SET_YYLLOC();
-					if (yyextra->standard_conforming_strings)
-						BEGIN(xq);
-					else
-						BEGIN(xe);
-					startlit();
-				}
-	YY_BREAK
-case 20:
-YY_RULE_SETUP
-#line 530 "third_party/libpg_query/scan.l"
-{
-					yyextra->warn_on_first_escape = false;
-					yyextra->saw_non_ascii = false;
-					SET_YYLLOC();
-					BEGIN(xe);
-					startlit();
-				}
-	YY_BREAK
-case 21:
-YY_RULE_SETUP
-#line 537 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					if (!yyextra->standard_conforming_strings)
-						ereport(ERROR,
-								(errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("unsafe use of string constant with Unicode escapes"),
-								 errdetail("String constants with Unicode escapes cannot be used when standard_conforming_strings is off."),
-								 lexer_errposition()));
-					BEGIN(xus);
-					startlit();
-				}
-	YY_BREAK
-case 22:
-/* rule 22 can match eol */
-#line 549 "third_party/libpg_query/scan.l"
-case 23:
-/* rule 23 can match eol */
-YY_RULE_SETUP
-#line 549 "third_party/libpg_query/scan.l"
-{
-					yyless(1);
-					BEGIN(INITIAL);
-					/*
-					 * check that the data remains valid if it might have been
-					 * made invalid by unescaping any chars.
-					 */
-					if (yyextra->saw_non_ascii)
-						pg_verifymbstr(yyextra->literalbuf,
-									   yyextra->literallen,
-									   false);
-					yylval->str = litbufdup(yyscanner);
-					return SCONST;
-				}
-	YY_BREAK
-case 24:
-/* rule 24 can match eol */
-#line 564 "third_party/libpg_query/scan.l"
-case 25:
-/* rule 25 can match eol */
-YY_RULE_SETUP
-#line 564 "third_party/libpg_query/scan.l"
-{
-					/* throw back all but the quote */
-					yyless(1);
-					/* xusend state looks for possible UESCAPE */
-					BEGIN(xusend);
-				}
-	YY_BREAK
-case 26:
-/* rule 26 can match eol */
-YY_RULE_SETUP
-#line 570 "third_party/libpg_query/scan.l"
-{
-					/* stay in xusend state over whitespace */
-				}
-	YY_BREAK
-case YY_STATE_EOF(xusend):
-#line 573 "third_party/libpg_query/scan.l"
-case 27:
-/* rule 27 can match eol */
-#line 575 "third_party/libpg_query/scan.l"
-case 28:
-/* rule 28 can match eol */
-YY_RULE_SETUP
-#line 575 "third_party/libpg_query/scan.l"
-{
-					/* no UESCAPE after the quote, throw back everything */
-					yyless(0);
-					BEGIN(INITIAL);
-					yylval->str = litbuf_udeescape('\\', yyscanner);
-					return SCONST;
-				}
-	YY_BREAK
-case 29:
-/* rule 29 can match eol */
-YY_RULE_SETUP
-#line 582 "third_party/libpg_query/scan.l"
-{
-					/* found UESCAPE after the end quote */
-					BEGIN(INITIAL);
-					if (!check_uescapechar(yytext[yyleng - 2]))
-					{
-						SET_YYLLOC();
-						ADVANCE_YYLLOC(yyleng - 2);
-						yyerror("invalid Unicode escape character");
-					}
-					yylval->str = litbuf_udeescape(yytext[yyleng - 2],
-												   yyscanner);
-					return SCONST;
-				}
-	YY_BREAK
-case 30:
-YY_RULE_SETUP
-#line 595 "third_party/libpg_query/scan.l"
-{
-					addlitchar('\'', yyscanner);
-				}
-	YY_BREAK
-case 31:
-/* rule 31 can match eol */
-YY_RULE_SETUP
-#line 598 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 32:
-/* rule 32 can match eol */
-YY_RULE_SETUP
-#line 601 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 33:
-YY_RULE_SETUP
-#line 604 "third_party/libpg_query/scan.l"
-{
-					pg_wchar	c = strtoul(yytext + 2, NULL, 16);
-
-					check_escape_warning(yyscanner);
-
-					if (is_utf16_surrogate_first(c))
-					{
-						yyextra->utf16_first_part = c;
-						BEGIN(xeu);
-					}
-					else if (is_utf16_surrogate_second(c))
-						yyerror("invalid Unicode surrogate pair");
-					else
-						addunicode(c, yyscanner);
-				}
-	YY_BREAK
-case 34:
-YY_RULE_SETUP
-#line 619 "third_party/libpg_query/scan.l"
-{
-					pg_wchar	c = strtoul(yytext + 2, NULL, 16);
-
-					if (!is_utf16_surrogate_second(c))
-						yyerror("invalid Unicode surrogate pair");
-
-					c = surrogate_pair_to_codepoint(yyextra->utf16_first_part, c);
-
-					addunicode(c, yyscanner);
-
-					BEGIN(xe);
-				}
-	YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 631 "third_party/libpg_query/scan.l"
-{ yyerror("invalid Unicode surrogate pair"); }
-	YY_BREAK
-case 36:
-/* rule 36 can match eol */
-YY_RULE_SETUP
-#line 632 "third_party/libpg_query/scan.l"
-{ yyerror("invalid Unicode surrogate pair"); }
-	YY_BREAK
-case YY_STATE_EOF(xeu):
-#line 633 "third_party/libpg_query/scan.l"
-{ yyerror("invalid Unicode surrogate pair"); }
-	YY_BREAK
-case 37:
-YY_RULE_SETUP
-#line 634 "third_party/libpg_query/scan.l"
-{
-					ereport(ERROR,
-							(errcode(PG_ERRCODE_INVALID_ESCAPE_SEQUENCE),
-							 errmsg("invalid Unicode escape"),
-							 errhint("Unicode escapes must be \\uXXXX or \\UXXXXXXXX."),
-							 lexer_errposition()));
-				}
-	YY_BREAK
-case 38:
-/* rule 38 can match eol */
-YY_RULE_SETUP
-#line 641 "third_party/libpg_query/scan.l"
-{
-					// if (yytext[1] == '\'')
-					// {
-					// 	if (yyextra->backslash_quote == PG_BACKSLASH_QUOTE_OFF ||
-					// 		(yyextra->backslash_quote == PG_BACKSLASH_QUOTE_SAFE_ENCODING &&
-					// 		 PG_ENCODING_IS_CLIENT_ONLY(pg_get_client_encoding())))
-					// 		ereport(ERROR,
-					// 				(errcode(PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
-					// 				 errmsg("unsafe use of \\' in a string literal"),
-					// 				 errhint("Use '' to write quotes in strings. \\' is insecure in client-only encodings."),
-					// 				 lexer_errposition()));
-					// }
-					check_string_escape_warning(yytext[1], yyscanner);
-					addlitchar(unescape_single_char(yytext[1], yyscanner),
-							   yyscanner);
-				}
-	YY_BREAK
-case 39:
-YY_RULE_SETUP
-#line 657 "third_party/libpg_query/scan.l"
-{
-					unsigned char c = strtoul(yytext + 1, NULL, 8);
-
-					check_escape_warning(yyscanner);
-					addlitchar(c, yyscanner);
-					if (c == '\0' || IS_HIGHBIT_SET(c))
-						yyextra->saw_non_ascii = true;
-				}
-	YY_BREAK
-case 40:
-YY_RULE_SETUP
-#line 665 "third_party/libpg_query/scan.l"
-{
-					unsigned char c = strtoul(yytext + 2, NULL, 16);
-
-					check_escape_warning(yyscanner);
-					addlitchar(c, yyscanner);
-					if (c == '\0' || IS_HIGHBIT_SET(c))
-						yyextra->saw_non_ascii = true;
-				}
-	YY_BREAK
-case 41:
-/* rule 41 can match eol */
-YY_RULE_SETUP
-#line 673 "third_party/libpg_query/scan.l"
-{
-					/* ignore */
-				}
-	YY_BREAK
-case 42:
-YY_RULE_SETUP
-#line 676 "third_party/libpg_query/scan.l"
-{
-					/* This is only needed for \ just before EOF */
-					addlitchar(yytext[0], yyscanner);
-				}
-	YY_BREAK
-case YY_STATE_EOF(xq):
-case YY_STATE_EOF(xe):
-case YY_STATE_EOF(xus):
-#line 680 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated quoted string"); }
-	YY_BREAK
-case 43:
-YY_RULE_SETUP
-#line 682 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yyextra->dolqstart = pstrdup(yytext);
-					BEGIN(xdolq);
-					startlit();
-				}
-	YY_BREAK
-case 44:
-YY_RULE_SETUP
-#line 688 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					/* throw back all but the initial "$" */
-					yyless(1);
-					/* and treat it as {other} */
-					return yytext[0];
-				}
-	YY_BREAK
-case 45:
-YY_RULE_SETUP
-#line 695 "third_party/libpg_query/scan.l"
-{
-					if (strcmp(yytext, yyextra->dolqstart) == 0)
-					{
-						pfree(yyextra->dolqstart);
-						yyextra->dolqstart = NULL;
-						BEGIN(INITIAL);
-						yylval->str = litbufdup(yyscanner);
-						return SCONST;
-					}
-					else
-					{
-						/*
-						 * When we fail to match $...$ to dolqstart, transfer
-						 * the $... part to the output, but put back the final
-						 * $ for rescanning.  Consider $delim$...$junk$delim$
-						 */
-						addlit(yytext, yyleng - 1, yyscanner);
-						yyless(yyleng - 1);
-					}
-				}
-	YY_BREAK
-case 46:
-/* rule 46 can match eol */
-YY_RULE_SETUP
-#line 715 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 47:
-YY_RULE_SETUP
-#line 718 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case 48:
-YY_RULE_SETUP
-#line 721 "third_party/libpg_query/scan.l"
-{
-					/* This is only needed for $ inside the quoted text */
-					addlitchar(yytext[0], yyscanner);
-				}
-	YY_BREAK
-case YY_STATE_EOF(xdolq):
-#line 725 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated dollar-quoted string"); }
-	YY_BREAK
-case 49:
-YY_RULE_SETUP
-#line 727 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					BEGIN(xd);
-					startlit();
-				}
-	YY_BREAK
-case 50:
-YY_RULE_SETUP
-#line 732 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					BEGIN(xui);
-					startlit();
-				}
-	YY_BREAK
-case 51:
-YY_RULE_SETUP
-#line 737 "third_party/libpg_query/scan.l"
-{
-					char	   *ident;
-
-					BEGIN(INITIAL);
-					if (yyextra->literallen == 0)
-						yyerror("zero-length delimited identifier");
-					ident = litbufdup(yyscanner);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 52:
-YY_RULE_SETUP
-#line 747 "third_party/libpg_query/scan.l"
-{
-					yyless(1);
-					/* xuiend state looks for possible UESCAPE */
-					BEGIN(xuiend);
-				}
-	YY_BREAK
-case 53:
-/* rule 53 can match eol */
-YY_RULE_SETUP
-#line 752 "third_party/libpg_query/scan.l"
-{
-					/* stay in xuiend state over whitespace */
-				}
-	YY_BREAK
-case YY_STATE_EOF(xuiend):
-#line 755 "third_party/libpg_query/scan.l"
-case 54:
-/* rule 54 can match eol */
-#line 757 "third_party/libpg_query/scan.l"
-case 55:
-/* rule 55 can match eol */
-YY_RULE_SETUP
-#line 757 "third_party/libpg_query/scan.l"
-{
-					/* no UESCAPE after the quote, throw back everything */
-					char	   *ident;
-					int			identlen;
-
-					yyless(0);
-
-					BEGIN(INITIAL);
-					if (yyextra->literallen == 0)
-						yyerror("zero-length delimited identifier");
-					ident = litbuf_udeescape('\\', yyscanner);
-					identlen = strlen(ident);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 56:
-/* rule 56 can match eol */
-YY_RULE_SETUP
-#line 772 "third_party/libpg_query/scan.l"
-{
-					/* found UESCAPE after the end quote */
-					char	   *ident;
-					int			identlen;
-
-					BEGIN(INITIAL);
-					if (yyextra->literallen == 0)
-						yyerror("zero-length delimited identifier");
-					if (!check_uescapechar(yytext[yyleng - 2]))
-					{
-						SET_YYLLOC();
-						ADVANCE_YYLLOC(yyleng - 2);
-						yyerror("invalid Unicode escape character");
-					}
-					ident = litbuf_udeescape(yytext[yyleng - 2], yyscanner);
-					identlen = strlen(ident);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 57:
-YY_RULE_SETUP
-#line 791 "third_party/libpg_query/scan.l"
-{
-					addlitchar('"', yyscanner);
-				}
-	YY_BREAK
-case 58:
-/* rule 58 can match eol */
-YY_RULE_SETUP
-#line 794 "third_party/libpg_query/scan.l"
-{
-					addlit(yytext, yyleng, yyscanner);
-				}
-	YY_BREAK
-case YY_STATE_EOF(xd):
-case YY_STATE_EOF(xui):
-#line 797 "third_party/libpg_query/scan.l"
-{ yyerror("unterminated quoted identifier"); }
-	YY_BREAK
-case 59:
-YY_RULE_SETUP
-#line 799 "third_party/libpg_query/scan.l"
-{
-					char	   *ident;
-
-					SET_YYLLOC();
-					/* throw back all but the initial u/U */
-					yyless(1);
-					/* and treat it as {identifier} */
-					ident = downcase_truncate_identifier(yytext, yyleng, true);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 60:
-YY_RULE_SETUP
-#line 811 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return TYPECAST;
-				}
-	YY_BREAK
-case 61:
-YY_RULE_SETUP
-#line 816 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return DOT_DOT;
-				}
-	YY_BREAK
-case 62:
-YY_RULE_SETUP
-#line 821 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return COLON_EQUALS;
-				}
-	YY_BREAK
-case 63:
-YY_RULE_SETUP
-#line 826 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return LAMBDA_ARROW;
-				}
-	YY_BREAK
-case 64:
-YY_RULE_SETUP
-#line 831 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return POWER_OF;
-				}
-	YY_BREAK
-case 65:
-YY_RULE_SETUP
-#line 836 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return EQUALS_GREATER;
-				}
-	YY_BREAK
-case 66:
-YY_RULE_SETUP
-#line 841 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return LESS_EQUALS;
-				}
-	YY_BREAK
-case 67:
-YY_RULE_SETUP
-#line 846 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return GREATER_EQUALS;
-				}
-	YY_BREAK
-case 68:
-YY_RULE_SETUP
-#line 851 "third_party/libpg_query/scan.l"
-{
-					/* We accept both "<>" and "!=" as meaning NOT_EQUALS */
-					SET_YYLLOC();
-					return NOT_EQUALS;
-				}
-	YY_BREAK
-case 69:
-YY_RULE_SETUP
-#line 857 "third_party/libpg_query/scan.l"
-{
-					/* We accept both "<>" and "!=" as meaning NOT_EQUALS */
-					SET_YYLLOC();
-					return NOT_EQUALS;
-				}
-	YY_BREAK
-case 70:
-YY_RULE_SETUP
-#line 863 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return yytext[0];
-				}
-	YY_BREAK
-case 71:
-YY_RULE_SETUP
-#line 868 "third_party/libpg_query/scan.l"
-{
-					/*
-					 * Check for embedded slash-star or dash-dash; those
-					 * are comment starts, so operator must stop there.
-					 * Note that slash-star or dash-dash at the first
-					 * character will match a prior rule, not this one.
-					 */
-					int			nchars = yyleng;
-					char	   *slashstar = strstr(yytext, "/*"); /* slash star */
-					char	   *dashdash = strstr(yytext, "--");
-
-					if (slashstar && dashdash) {
-						/* if both appear, take the first one */
-						if (slashstar > dashdash)
-							slashstar = dashdash;
-					} else if (!slashstar) {
-						slashstar = dashdash;
-					}
-					if (slashstar) {
-						nchars = slashstar - yytext;
-					}
-
-					/*
-					 * For SQL compatibility, '+' and '-' cannot be the
-					 * last char of a multi-char operator unless the operator
-					 * contains chars that are not in SQL operators.
-					 * The idea is to lex '=-' as two operators, but not
-					 * to forbid operator names like '?-' that could not be
-					 * sequences of SQL operators.
-					 */
-					while (nchars > 1 &&
-						(yytext[nchars - 1] == '+' ||
-						 yytext[nchars - 1] == '-'))
-					{
-						int			ic;
-
-						for (ic = nchars - 2; ic >= 0; ic--)
-						{
-							if (strchr("~!@^&|`?%", yytext[ic]))
-								break;
-						}
-						if (ic >= 0)
-							break; /* found a char that makes it OK */
-						nchars--; /* else remove the +/-, and check again */
-					}
-
-					/* We don't accept leading ? in any multi-character operators
-					* except for those in use by hstore, JSON and geometric operators.
-					*
-					* We don't accept contained or trailing ? in any
-					* multi-character operators.
-					*
-					* This is necessary in order to support normalized queries without
-					* spacing between ? as a substition character and a simple operator (e.g. "?=?")
-					*/
-					if (yytext[0] == '?' &&
-						strcmp(yytext, "?|") != 0 && strcmp(yytext, "?&") != 0 &&
-						strcmp(yytext, "?-") != 0 &&
-						strcmp(yytext, "?-|") != 0 && strcmp(yytext, "?||") != 0) {
-						nchars = 1;
-					}
-
-					if (yytext[0] != '?' && strchr(yytext, '?')) {
-						/* Lex up to just before the ? character */
-						nchars = strchr(yytext, '?') - yytext;
-					}
-
-					SET_YYLLOC();
-
-					if ((yy_size_t) nchars < yyleng)
-					{
-						/* Strip the unwanted chars from the token */
-						yyless(nchars);
-						/*
-						 * If what we have left is only one char, and it's
-						 * one of the characters matching "self", then
-						 * return it as a character token the same way
-						 * that the "self" rule would have.
-						 */
-						if (nchars == 1 &&
-							strchr(",()[].;:+-*/%^<>=?", yytext[0])) {
-							return yytext[0];
-						}
-						/*
-						 * Likewise, if what we have left is two chars, and
-						 * those match the tokens ">=", "<=", "=>", "<>" or
-						 * "!=", then we must return the appropriate token
-						 * rather than the generic Op.
-						 */
-						if (nchars == 2)
-						{
-							if (yytext[0] == '=' && yytext[1] == '>')
-								return EQUALS_GREATER;
-							if (yytext[0] == '>' && yytext[1] == '=')
-								return GREATER_EQUALS;
-							if (yytext[0] == '<' && yytext[1] == '=')
-								return LESS_EQUALS;
-							if (yytext[0] == '<' && yytext[1] == '>')
-								return NOT_EQUALS;
-							if (yytext[0] == '!' && yytext[1] == '=')
-								return NOT_EQUALS;
-						}
-					}
-
-					/*
-					 * Complain if operator is too long.  Unlike the case
-					 * for identifiers, we make this an error not a notice-
-					 * and-truncate, because the odds are we are looking at
-					 * a syntactic mistake anyway. NAMEDDATALEN
-					 */
-					if (nchars >= 64)
-						yyerror("operator too long: operators longer than 64 bytes are not supported");
-
-					yylval->str = pstrdup(yytext);
-					return Op;
-				}
-	YY_BREAK
-case 72:
-YY_RULE_SETUP
-#line 985 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yylval->ival = atol(yytext + 1);
-					return PARAM;
-				}
-	YY_BREAK
-case 73:
-YY_RULE_SETUP
-#line 991 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yylval->ival = atol(yytext + 1);
-					return PARAM;
-				}
-	YY_BREAK
-case 74:
-YY_RULE_SETUP
-#line 997 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return process_integer_literal(yytext, yylval);
-				}
-	YY_BREAK
-case 75:
-YY_RULE_SETUP
-#line 1001 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yylval->str = pstrdup(yytext);
-					return FCONST;
-				}
-	YY_BREAK
-case 76:
-YY_RULE_SETUP
-#line 1006 "third_party/libpg_query/scan.l"
-{
-					/* throw back the .., and treat as integer */
-					yyless(yyleng - 2);
-					SET_YYLLOC();
-					return process_integer_literal(yytext, yylval);
-				}
-	YY_BREAK
-case 77:
-YY_RULE_SETUP
-#line 1012 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yylval->str = pstrdup(yytext);
-					return FCONST;
-				}
-	YY_BREAK
-case 78:
-YY_RULE_SETUP
-#line 1017 "third_party/libpg_query/scan.l"
-{
-					/*
-					 * throw back the [Ee], and treat as {decimal}.  Note
-					 * that it is possible the input is actually {integer},
-					 * but since this case will almost certainly lead to a
-					 * syntax error anyway, we don't bother to distinguish.
-					 */
-					yyless(yyleng - 1);
-					SET_YYLLOC();
-					yylval->str = pstrdup(yytext);
-					return FCONST;
-				}
-	YY_BREAK
-case 79:
-YY_RULE_SETUP
-#line 1029 "third_party/libpg_query/scan.l"
-{
-					/* throw back the [Ee][+-], and proceed as above */
-					yyless(yyleng - 2);
-					SET_YYLLOC();
-					yylval->str = pstrdup(yytext);
-					return FCONST;
-				}
-	YY_BREAK
-case 80:
-YY_RULE_SETUP
-#line 1038 "third_party/libpg_query/scan.l"
-{
-					const PGScanKeyword *keyword;
-					char	   *ident;
-					char       *keyword_text = pstrdup(yytext);
-
-					SET_YYLLOC();
-
-					if (yytext[yyleng - 1] == '?') {
-						keyword_text[yyleng - 1] = '\0';
-					}
-
-					/* Is it a keyword? */
-					keyword = ScanKeywordLookup(keyword_text,
-												yyextra->keywords,
-												yyextra->num_keywords);
-					if (keyword != NULL)
-					{
-						if (keyword_text[yyleng - 1] == '\0') {
-							yyless(yyleng - 1);
-						}
-						yylval->keyword = keyword->name;
-						return keyword->value;
-					}
-
-					/*
-					 * No.  Convert the identifier to lower case, and truncate
-					 * if necessary.
-					 */
-					ident = downcase_truncate_identifier(yytext, yyleng, true);
-					yylval->str = ident;
-					return IDENT;
-				}
-	YY_BREAK
-case 81:
-YY_RULE_SETUP
-#line 1071 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					return yytext[0];
-				}
-	YY_BREAK
-case YY_STATE_EOF(INITIAL):
-#line 1076 "third_party/libpg_query/scan.l"
-{
-					SET_YYLLOC();
-					yyterminate();
-				}
-	YY_BREAK
-case 82:
-YY_RULE_SETUP
-#line 1081 "third_party/libpg_query/scan.l"
-YY_FATAL_ERROR( "flex scanner jammed" );
-	YY_BREAK
-#line 2653 "third_party/libpg_query/src_backend_parser_scan.cpp"
-
-	case YY_END_OF_BUFFER:
-		{
-		/* Amount of text matched not including the EOB char. */
-		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
-
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-		*yy_cp = yyg->yy_hold_char;
-		YY_RESTORE_YY_MORE_OFFSET
-
-		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-			{
-			/* We're scanning a new file or input source.  It's
-			 * possible that this happened because the user
-			 * just pointed yyin at a new source and called
-			 * yylex().  If so, then we have to assure
-			 * consistency between YY_CURRENT_BUFFER and our
-			 * globals.  Here is the right place to do so, because
-			 * this is the first action (other than possibly a
-			 * back-up) that will match for the new input source.
-			 */
-			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-			}
-
-		/* Note that here we test for yy_c_buf_p "<=" to the position
-		 * of the first EOB in the buffer, since yy_c_buf_p will
-		 * already have been incremented past the NUL character
-		 * (since all states make transitions on EOB to the
-		 * end-of-buffer state).  Contrast this with the test
-		 * in input().
-		 */
-		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			{ /* This was really a NUL. */
-			yy_state_type yy_next_state;
-
-			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
-
-			yy_current_state = yy_get_previous_state( yyscanner );
-
-			/* Okay, we're now positioned to make the NUL
-			 * transition.  We couldn't have
-			 * yy_get_previous_state() go ahead and do it
-			 * for us because it doesn't know how to deal
-			 * with the possibility of jamming (and we don't
-			 * want to build jamming into it because then it
-			 * will run more slowly).
-			 */
-
-			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
-
-			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-
-			if ( yy_next_state )
-				{
-				/* Consume the NUL. */
-				yy_cp = ++yyg->yy_c_buf_p;
-				yy_current_state = yy_next_state;
-				goto yy_match;
-				}
-
-			else
-				{
-				yy_cp = yyg->yy_last_accepting_cpos;
-				yy_current_state = yyg->yy_last_accepting_state;
-				goto yy_find_action;
-				}
-			}
-
-		else switch ( yy_get_next_buffer( yyscanner ) )
-			{
-			case EOB_ACT_END_OF_FILE:
-				{
-				yyg->yy_did_buffer_switch_on_eof = 0;
-
-				if ( yywrap( yyscanner ) )
-					{
-					/* Note: because we've taken care in
-					 * yy_get_next_buffer() to have set up
-					 * yytext, we can now set up
-					 * yy_c_buf_p so that if some total
-					 * hoser (like flex itself) wants to
-					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
-					 */
-					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
-
-					yy_act = YY_STATE_EOF(YY_START);
-					goto do_action;
-					}
-
-				else
-					{
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-					}
-				break;
-				}
-
-			case EOB_ACT_CONTINUE_SCAN:
-				yyg->yy_c_buf_p =
-					yyg->yytext_ptr + yy_amount_of_matched_text;
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_match;
-
-			case EOB_ACT_LAST_MATCH:
-				yyg->yy_c_buf_p =
-				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_find_action;
-			}
-		break;
-		}
-
-	default:
-		YY_FATAL_ERROR(
-			"fatal flex scanner internal error--no action found" );
-	} /* end of action switch */
-		} /* end of scanning one token */
-	} /* end of user's declarations */
-} /* end of yylex */
-
-/* yy_get_next_buffer - try to read in a new buffer
- *
- * Returns a code representing an action:
- *	EOB_ACT_LAST_MATCH -
- *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *	EOB_ACT_END_OF_FILE - end of file
- */
-static int yy_get_next_buffer (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-	char *source = yyg->yytext_ptr;
-	int number_to_move, i;
-	int ret_val;
-
-	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
-		YY_FATAL_ERROR(
-		"fatal flex scanner internal error--end of buffer missed" );
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-		{ /* Don't try to fill the buffer, so this is an EOF. */
-		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
-			{
-			/* We matched a single character, the EOB, so
-			 * treat this as a final EOF.
-			 */
-			return EOB_ACT_END_OF_FILE;
-			}
-
-		else
-			{
-			/* We matched some text prior to the EOB, first
-			 * process it.
-			 */
-			return EOB_ACT_LAST_MATCH;
-			}
-		}
-
-	/* Try to read more data. */
-
-	/* First move last chars to start of buffer. */
-	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
-
-	for ( i = 0; i < number_to_move; ++i )
-		*(dest++) = *(source++);
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-		/* don't do the read, it's not guaranteed to return an EOF,
-		 * just force an EOF
-		 */
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
-
-	else
-		{
-			yy_size_t num_to_read =
-			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-		while ( num_to_read <= 0 )
-			{ /* Not enough room in the buffer - grow it. */
-
-			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
-
-			int yy_c_buf_p_offset =
-				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
-
-			if ( b->yy_is_our_buffer )
-				{
-				yy_size_t new_size = b->yy_buf_size * 2;
-
-				if ( new_size <= 0 )
-					b->yy_buf_size += b->yy_buf_size / 8;
-				else
-					b->yy_buf_size *= 2;
-
-				b->yy_ch_buf = (char *)
-					/* Include room in for 2 EOB chars. */
-					yyrealloc( (void *) b->yy_ch_buf,
-							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
-				}
-			else
-				/* Can't grow it, we don't own it. */
-				b->yy_ch_buf = NULL;
-
-			if ( ! b->yy_ch_buf )
-				YY_FATAL_ERROR(
-				"fatal error - scanner input buffer overflow" );
-
-			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-						number_to_move - 1;
-
-			}
-
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
-
-		/* Read in more data. */
-		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			yyg->yy_n_chars, num_to_read );
-
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	if ( yyg->yy_n_chars == 0 )
-		{
-		if ( number_to_move == YY_MORE_ADJ )
-			{
-			ret_val = EOB_ACT_END_OF_FILE;
-			yyrestart( yyin  , yyscanner);
-			}
-
-		else
-			{
-			ret_val = EOB_ACT_LAST_MATCH;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
-			}
-		}
-
-	else
-		ret_val = EOB_ACT_CONTINUE_SCAN;
-
-	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-		/* Extend the array by 50%, plus the number we really need. */
-		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
-		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
-			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
-		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-		/* "- 2" to take care of EOB's */
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
-	}
-
-	yyg->yy_n_chars += number_to_move;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
-
-	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-	return ret_val;
-}
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
-{
-	yy_state_type yy_current_state;
-	char *yy_cp;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	yy_current_state = yyg->yy_start;
-
-	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
-		{
-		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-		if ( yy_accept[yy_current_state] )
-			{
-			yyg->yy_last_accepting_state = yy_current_state;
-			yyg->yy_last_accepting_cpos = yy_cp;
-			}
-		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-			{
-			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 295 )
-				yy_c = yy_meta[yy_c];
-			}
-		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-		}
-
-	return yy_current_state;
-}
-
-/* yy_try_NUL_trans - try to make a transition on the NUL character
- *
- * synopsis
- *	next_state = yy_try_NUL_trans( current_state );
- */
-    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
-{
-	int yy_is_jam;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
-	char *yy_cp = yyg->yy_c_buf_p;
-
-	YY_CHAR yy_c = 1;
-	if ( yy_accept[yy_current_state] )
-		{
-		yyg->yy_last_accepting_state = yy_current_state;
-		yyg->yy_last_accepting_cpos = yy_cp;
-		}
-	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-		{
-		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 295 )
-			yy_c = yy_meta[yy_c];
-		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-	yy_is_jam = (yy_current_state == 294);
-
-	(void)yyg;
-	return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_UNPUT
-
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-    static int yyinput (yyscan_t yyscanner)
-#else
-    static int input  (yyscan_t yyscanner)
-#endif
-
-{
-	int c;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	*yyg->yy_c_buf_p = yyg->yy_hold_char;
-
-	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
-		{
-		/* yy_c_buf_p now points to the character we want to return.
-		 * If this occurs *before* the EOB characters, then it's a
-		 * valid NUL; if not, then we've hit the end of the buffer.
-		 */
-		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			/* This was really a NUL. */
-			*yyg->yy_c_buf_p = '\0';
-
-		else
-			{ /* need more input */
-			yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
-			++yyg->yy_c_buf_p;
-
-			switch ( yy_get_next_buffer( yyscanner ) )
-				{
-				case EOB_ACT_LAST_MATCH:
-					/* This happens because yy_g_n_b()
-					 * sees that we've accumulated a
-					 * token and flags that we need to
-					 * try matching the token before
-					 * proceeding.  But for input(),
-					 * there's no matching to consider.
-					 * So convert the EOB_ACT_LAST_MATCH
-					 * to EOB_ACT_END_OF_FILE.
-					 */
-
-					/* Reset buffer status. */
-					yyrestart( yyin , yyscanner);
-
-					/*FALLTHROUGH*/
-
-				case EOB_ACT_END_OF_FILE:
-					{
-					if ( yywrap( yyscanner ) )
-						return 0;
-
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-#ifdef __cplusplus
-					return yyinput(yyscanner);
-#else
-					return input(yyscanner);
-#endif
-					}
-
-				case EOB_ACT_CONTINUE_SCAN:
-					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
-					break;
-				}
-			}
-		}
-
-	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
-	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
-	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
-
-	return c;
-}
-#endif	/* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- * @param yyscanner The scanner object.
- * @note This function does not reset the start condition to @c INITIAL .
- */
-    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! YY_CURRENT_BUFFER ){
-        yyensure_buffer_stack (yyscanner);
-		YY_CURRENT_BUFFER_LVALUE =
-            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
-	}
-
-	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
-	yy_load_buffer_state( yyscanner );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- * @param yyscanner The scanner object.
- */
-    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	/* TODO. We should be able to replace this entire function body
-	 * with
-	 *		yypop_buffer_state();
-	 *		yypush_buffer_state(new_buffer);
-     */
-	yyensure_buffer_stack (yyscanner);
-	if ( YY_CURRENT_BUFFER == new_buffer )
-		return;
-
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-	yy_load_buffer_state( yyscanner );
-
-	/* We don't actually know whether we did this switch during
-	 * EOF (yywrap()) processing, but the only time this flag
-	 * is looked at is after yywrap() is called, so it's safe
-	 * to go ahead and always set it.
-	 */
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-static void yy_load_buffer_state  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-	yyg->yy_hold_char = *yyg->yy_c_buf_p;
-}
-
-/** Allocate and initialize an input buffer state.
- * @param file A readable stream.
- * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
- * @param yyscanner The scanner object.
- * @return the allocated buffer state.
- */
-    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
-	b->yy_buf_size = size;
-
-	/* yy_ch_buf has to be 2 characters longer than the size given because
-	 * we need to put in 2 end-of-buffer characters.
-	 */
-	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
-	if ( ! b->yy_ch_buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
-	b->yy_is_our_buffer = 1;
-
-	yy_init_buffer( b, file , yyscanner);
-
-	return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with yy_create_buffer()
- * @param yyscanner The scanner object.
- */
-    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! b )
-		return;
-
-	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-
-	if ( b->yy_is_our_buffer )
-		yyfree( (void *) b->yy_ch_buf , yyscanner );
-
-	yyfree( (void *) b , yyscanner );
-}
-
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a yyrestart() or at EOF.
- */
-    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
-
-{
-	int oerrno = errno;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	yy_flush_buffer( b , yyscanner);
-
-	b->yy_input_file = file;
-	b->yy_fill_buffer = 1;
-
-    /* If b is the current buffer, then yy_init_buffer was _probably_
-     * called from yyrestart() or through yy_get_next_buffer.
-     * In that case, we don't want to reset the lineno or column.
-     */
-    if (b != YY_CURRENT_BUFFER){
-        b->yy_bs_lineno = 1;
-        b->yy_bs_column = 0;
-    }
-
-        b->yy_is_interactive = 0;
-    
-	errno = oerrno;
-}
-
-/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
- * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
- * @param yyscanner The scanner object.
- */
-    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( ! b )
-		return;
-
-	b->yy_n_chars = 0;
-
-	/* We always need two end-of-buffer characters.  The first causes
-	 * a transition to the end-of-buffer state.  The second causes
-	 * a jam in that state.
-	 */
-	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-
-	b->yy_buf_pos = &b->yy_ch_buf[0];
-
-	b->yy_at_bol = 1;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	if ( b == YY_CURRENT_BUFFER )
-		yy_load_buffer_state( yyscanner );
-}
-
-/** Pushes the new state onto the stack. The new state becomes
- *  the current state. This function will allocate the stack
- *  if necessary.
- *  @param new_buffer The new state.
- *  @param yyscanner The scanner object.
- */
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (new_buffer == NULL)
-		return;
-
-	yyensure_buffer_stack(yyscanner);
-
-	/* This block is copied from yy_switch_to_buffer. */
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	/* Only push if top exists. Otherwise, replace top. */
-	if (YY_CURRENT_BUFFER)
-		yyg->yy_buffer_stack_top++;
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
-	/* copied from yy_switch_to_buffer. */
-	yy_load_buffer_state( yyscanner );
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- *  The next element becomes the new top.
- *  @param yyscanner The scanner object.
- */
-void yypop_buffer_state (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (!YY_CURRENT_BUFFER)
-		return;
-
-	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
-	YY_CURRENT_BUFFER_LVALUE = NULL;
-	if (yyg->yy_buffer_stack_top > 0)
-		--yyg->yy_buffer_stack_top;
-
-	if (YY_CURRENT_BUFFER) {
-		yy_load_buffer_state( yyscanner );
-		yyg->yy_did_buffer_switch_on_eof = 1;
-	}
-}
-
-/* Allocates the stack if it does not exist.
- *  Guarantees space for at least one push.
- */
-static void yyensure_buffer_stack (yyscan_t yyscanner)
-{
-	yy_size_t num_to_alloc;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if (!yyg->yy_buffer_stack) {
-
-		/* First allocation is just for 2 elements, since we don't know if this
-		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
-		 * immediate realloc on the next call.
-         */
-      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
-								(num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
-		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-
-		yyg->yy_buffer_stack_max = num_to_alloc;
-		yyg->yy_buffer_stack_top = 0;
-		return;
-	}
-
-	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
-
-		/* Increase the buffer to prepare for a possible push. */
-		yy_size_t grow_size = 8 /* arbitrary grow size */;
-
-		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
-								(yyg->yy_buffer_stack,
-								num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
-		/* zero only the new slots.*/
-		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-		yyg->yy_buffer_stack_max = num_to_alloc;
-	}
-}
-
-/** Setup the input buffer state to scan directly from a user-specified character buffer.
- * @param base the character buffer
- * @param size the size in bytes of the character buffer
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	if ( size < 2 ||
-	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
-	     base[size-1] != YY_END_OF_BUFFER_CHAR )
-		/* They forgot to leave room for the EOB's. */
-		return NULL;
-
-	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
-
-	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
-	b->yy_buf_pos = b->yy_ch_buf = base;
-	b->yy_is_our_buffer = 0;
-	b->yy_input_file = NULL;
-	b->yy_n_chars = b->yy_buf_size;
-	b->yy_is_interactive = 0;
-	b->yy_at_bol = 1;
-	b->yy_fill_buffer = 0;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	yy_switch_to_buffer( b , yyscanner );
-
-	return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to yylex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- *       yy_scan_bytes() instead.
- */
-YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
-{
-    
-	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, yy_size_t  _yybytes_len , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-	char *buf;
-	yy_size_t n;
-	yy_size_t i;
-    
-	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = (yy_size_t) (_yybytes_len + 2);
-	buf = (char *) yyalloc( n , yyscanner );
-	if ( ! buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
-
-	for ( i = 0; i < _yybytes_len; ++i )
-		buf[i] = yybytes[i];
-
-	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
-	b = yy_scan_buffer( buf, n , yyscanner);
-	if ( ! b )
-		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
-
-	/* It's okay to grow etc. this buffer, and we should throw it
-	 * away when we're done.
-	 */
-	b->yy_is_our_buffer = 1;
-
-	return b;
-}
-
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
-
-static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
-{
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
-	//( stderr, "%s\n", msg );
-	throw std::runtime_error(msg); // YY_EXIT_FAILURE );
-}
-
-/* Redefine yyless() so it works in section 3 code. */
-
-#undef yyless
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        yy_size_t yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		yytext[yyleng] = yyg->yy_hold_char; \
-		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
-		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
-		*yyg->yy_c_buf_p = '\0'; \
-		yyleng = yyless_macro_arg; \
-		} \
-	while ( 0 )
-
-/* Accessor  methods (get/set functions) to struct members. */
-
-/** Get the user-defined data for this scanner.
- * @param yyscanner The scanner object.
- */
-YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyextra;
-}
-
-/** Get the current line number.
- * @param yyscanner The scanner object.
- */
-int yyget_lineno  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yylineno;
-}
-
-/** Get the current column number.
- * @param yyscanner The scanner object.
- */
-int yyget_column  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yycolumn;
-}
-
-/** Get the input stream.
- * @param yyscanner The scanner object.
- */
-FILE *yyget_in  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyin;
-}
-
-/** Get the output stream.
- * @param yyscanner The scanner object.
- */
-FILE *yyget_out  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyout;
-}
-
-/** Get the length of the current token.
- * @param yyscanner The scanner object.
- */
-yy_size_t yyget_leng  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyleng;
-}
-
-/** Get the current token.
- * @param yyscanner The scanner object.
- */
-
-char *yyget_text  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yytext;
-}
-
-/** Set the user-defined data. This data is never touched by the scanner.
- * @param user_defined The data to be associated with this scanner.
- * @param yyscanner The scanner object.
- */
-void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyextra = user_defined ;
-}
-
-/** Set the current line number.
- * @param _line_number line number
- * @param yyscanner The scanner object.
- */
-void yyset_lineno (int  _line_number , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* lineno is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
-    
-    yylineno = _line_number;
-}
-
-/** Set the current column.
- * @param _column_no column number
- * @param yyscanner The scanner object.
- */
-void yyset_column (int  _column_no , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* column is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           YY_FATAL_ERROR( "yyset_column called with no buffer" );
-    
-    yycolumn = _column_no;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param _in_str A readable stream.
- * @param yyscanner The scanner object.
- * @see yy_switch_to_buffer
- */
-void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyin = _in_str ;
-}
-
-void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyout = _out_str ;
-}
-
-int yyget_debug  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yy_flex_debug;
-}
-
-void yyset_debug (int  _bdebug , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yy_flex_debug = _bdebug ;
-}
-
-/* Accessor methods for yylval and yylloc */
-
-YYSTYPE * yyget_lval  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylval;
-}
-
-void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylval = yylval_param;
-}
-
-YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylloc;
-}
-    
-void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylloc = yylloc_param;
-}
-    
-/* User-visible API */
-
-/* yylex_init is special because it creates the scanner itself, so it is
- * the ONLY reentrant function that doesn't take the scanner as the last argument.
- * That's why we explicitly handle the declaration, instead of using our macros.
- */
-int yylex_init(yyscan_t* ptr_yy_globals)
-{
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
-    }
-
-    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
-
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-
-    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-/* yylex_init_extra has the same functionality as yylex_init, but follows the
- * convention of taking the scanner as the last argument. Note however, that
- * this is a *pointer* to a scanner, as it will be allocated by this call (and
- * is the reason, too, why this function also must handle its own declaration).
- * The user defined value in the first argument will be available to yyalloc in
- * the yyextra field.
- */
-int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
-{
-    struct yyguts_t dummy_yyguts;
-
-    yyset_extra (yy_user_defined, &dummy_yyguts);
-
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
-    }
-
-    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
-
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-
-    /* By setting to 0xAA, we expose bugs in
-    yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
-    yyset_extra (yy_user_defined, *ptr_yy_globals);
-
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-static int yy_init_globals (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    /* Initialization is the same as for the non-reentrant scanner.
-     * This function is called from yylex_destroy(), so don't allocate here.
-     */
-
-    yyg->yy_buffer_stack = NULL;
-    yyg->yy_buffer_stack_top = 0;
-    yyg->yy_buffer_stack_max = 0;
-    yyg->yy_c_buf_p = NULL;
-    yyg->yy_init = 0;
-    yyg->yy_start = 0;
-
-    yyg->yy_start_stack_ptr = 0;
-    yyg->yy_start_stack_depth = 0;
-    yyg->yy_start_stack =  NULL;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
-    yyin = stdin;
-    yyout = stdout;
-#else
-    yyin = NULL;
-    yyout = NULL;
-#endif
-
-    /* For future reference: Set errno on error, since we are called by
-     * yylex_init()
-     */
-    return 0;
-}
-
-/* yylex_destroy is for both reentrant and non-reentrant scanners. */
-int yylex_destroy  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-    /* Pop the buffer stack, destroying each element. */
-	while(YY_CURRENT_BUFFER){
-		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
-		YY_CURRENT_BUFFER_LVALUE = NULL;
-		yypop_buffer_state(yyscanner);
-	}
-
-	/* Destroy the stack itself. */
-	yyfree(yyg->yy_buffer_stack , yyscanner);
-	yyg->yy_buffer_stack = NULL;
-
-    /* Destroy the start condition stack. */
-        yyfree( yyg->yy_start_stack , yyscanner );
-        yyg->yy_start_stack = NULL;
-
-    /* Reset the globals. This is important in a non-reentrant scanner so the next time
-     * yylex() is called, initialization will occur. */
-    yy_init_globals( yyscanner);
-
-    /* Destroy the main struct (reentrant only). */
-    yyfree ( yyscanner , yyscanner );
-    yyscanner = NULL;
-    return 0;
-}
-
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
-{
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
-
-	int i;
-	for ( i = 0; i < n; ++i )
-		s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
-{
-	int n;
-	for ( n = 0; s[n]; ++n )
-		;
-
-	return n;
-}
-#endif
-
-#define YYTABLES_NAME "yytables"
-
-#line 1081 "third_party/libpg_query/scan.l"
-
-
-/* LCOV_EXCL_STOP */
-
-/*
- * Arrange access to yyextra for subroutines of the main yylex() function.
- * We expect each subroutine to have a yyscanner parameter.  Rather than
- * use the yyget_xxx functions, which might or might not get inlined by the
- * compiler, we cheat just a bit and cast yyscanner to the right type.
- */
-#undef yyextra
-#define yyextra  (((struct yyguts_t *) yyscanner)->yyextra_r)
-
-/* Likewise for a couple of other things we need. */
-#undef yylloc
-#define yylloc	(((struct yyguts_t *) yyscanner)->yylloc_r)
-#undef yyleng
-#define yyleng	(((struct yyguts_t *) yyscanner)->yyleng_r)
-
-
-/*
- * scanner_errposition
- *		Report a lexer or grammar error cursor position, if possible.
- *
- * This is expected to be used within an ereport() call.  The return value
- * is a dummy (always 0, in fact).
- *
- * Note that this can only be used for messages emitted during raw parsing
- * (essentially, scan.l and gram.y), since it requires the yyscanner struct
- * to still be available.
- */
-int
-scanner_errposition(int location, core_yyscan_t yyscanner)
-{
-	int			pos;
-
-	if (location < 0)
-		return 0;				/* no-op if location is unknown */
-
-	/* Convert byte offset to character number */
-	pos = pg_mbstrlen_with_len(yyextra->scanbuf, location) + 1;
-	/* And pass it to the ereport mechanism */
-	return errposition(pos);
-}
-
-/*
- * scanner_yyerror
- *		Report a lexer or grammar error.
- *
- * The message's cursor position is whatever YYLLOC was last set to,
- * ie, the start of the current token if called within yylex(), or the
- * most recently lexed token if called from the grammar.
- * This is OK for syntax error messages from the Bison parser, because Bison
- * parsers report error as soon as the first unparsable token is reached.
- * Beware of using yyerror for other purposes, as the cursor position might
- * be misleading!
- */
-void
-scanner_yyerror(const char *message, core_yyscan_t yyscanner)
-{
-	const char *loc = yyextra->scanbuf + *yylloc;
-
-	if (*loc == YY_END_OF_BUFFER_CHAR)
-	{
-		ereport(ERROR,
-				(errcode(PG_ERRCODE_SYNTAX_ERROR),
-		/* translator: %s is typically the translation of "syntax error" */
-				 errmsg("%s at end of input", _(message)),
-				 lexer_errposition()));
-	}
-	else
-	{
-		ereport(ERROR,
-				(errcode(PG_ERRCODE_SYNTAX_ERROR),
-		/* translator: first %s is typically the translation of "syntax error" */
-				 errmsg("%s at or near \"%s\"", _(message), loc),
-				 lexer_errposition()));
-	}
-}
-
-
-/*
- * Called before any actual parsing is done
- */
-core_yyscan_t
-scanner_init(const char *str,
-			 core_yy_extra_type *yyext,
-			 const PGScanKeyword *keywords,
-			 int num_keywords)
-{
-	PGSize		slen = strlen(str);
-	yyscan_t	scanner;
-
-	if (yylex_init(&scanner) != 0)
-		elog(ERROR, "yylex_init() failed: %m");
-
-	core_yyset_extra(yyext, scanner);
-
-	yyext->keywords = keywords;
-	yyext->num_keywords = num_keywords;
-
-	yyext->backslash_quote = backslash_quote;
-	yyext->escape_string_warning = escape_string_warning;
-	yyext->standard_conforming_strings = standard_conforming_strings;
-
-	/*
-	 * Make a scan buffer with special termination needed by flex.
-	 */
-	yyext->scanbuf = (char *) palloc(slen + 2);
-	yyext->scanbuflen = slen;
-	memcpy(yyext->scanbuf, str, slen);
-	yyext->scanbuf[slen] = yyext->scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
-	yy_scan_buffer(yyext->scanbuf, slen + 2, scanner);
-
-	/* initialize literal buffer to a reasonable but expansible size */
-	yyext->literalalloc = 1024;
-	yyext->literalbuf = (char *) palloc(yyext->literalalloc);
-	yyext->literallen = 0;
-
-	return scanner;
-}
-
-
-/*
- * Called after parsing is done to clean up after scanner_init()
- */
-void
-scanner_finish(core_yyscan_t yyscanner)
-{
-	/*
-	 * We don't bother to call yylex_destroy(), because all it would do is
-	 * pfree a small amount of control storage.  It's cheaper to leak the
-	 * storage until the parsing context is destroyed.  The amount of space
-	 * involved is usually negligible compared to the output parse tree
-	 * anyway.
-	 *
-	 * We do bother to pfree the scanbuf and literal buffer, but only if they
-	 * represent a nontrivial amount of space.  The 8K cutoff is arbitrary.
-	 */
-	if (yyextra->scanbuflen >= 8192)
-		pfree(yyextra->scanbuf);
-	if (yyextra->literalalloc >= 8192)
-		pfree(yyextra->literalbuf);
-}
-
-
-static void
-addlit(char *ytext, int yleng, core_yyscan_t yyscanner)
-{
-	/* enlarge buffer if needed */
-	if ((yyextra->literallen + yleng) >= yyextra->literalalloc)
-	{
-		do
-		{
-			yyextra->literalalloc *= 2;
-		} while ((yyextra->literallen + yleng) >= yyextra->literalalloc);
-		yyextra->literalbuf = (char *) repalloc(yyextra->literalbuf,
-												yyextra->literalalloc);
-	}
-	/* append new data */
-	memcpy(yyextra->literalbuf + yyextra->literallen, ytext, yleng);
-	yyextra->literallen += yleng;
-}
-
-
-static void
-addlitchar(unsigned char ychar, core_yyscan_t yyscanner)
-{
-	/* enlarge buffer if needed */
-	if ((yyextra->literallen + 1) >= yyextra->literalalloc)
-	{
-		yyextra->literalalloc *= 2;
-		yyextra->literalbuf = (char *) repalloc(yyextra->literalbuf,
-												yyextra->literalalloc);
-	}
-	/* append new data */
-	yyextra->literalbuf[yyextra->literallen] = ychar;
-	yyextra->literallen += 1;
-}
-
-
-/*
- * Create a palloc'd copy of literalbuf, adding a trailing null.
- */
-static char *
-litbufdup(core_yyscan_t yyscanner)
-{
-	int			llen = yyextra->literallen;
-	char	   *newbuf;
-
-	newbuf = (char*) palloc(llen + 1);
-	memcpy(newbuf, yyextra->literalbuf, llen);
-	newbuf[llen] = '\0';
-	return newbuf;
-}
-
-static int
-process_integer_literal(const char *token, YYSTYPE *lval)
-{
-	long		val;
-	char	   *endptr;
-
-	errno = 0;
-	val = strtol(token, &endptr, 10);
-	if (*endptr != '\0' || errno == ERANGE
-	/* if long > 32 bits, check for overflow of int4_t */
-		|| val != (long) ((int32_t) val) )
-	{
-		/* integer too large, treat it as a float */
-		lval->str = pstrdup(token);
-		return FCONST;
-	}
-	lval->ival = val;
-	return ICONST;
-}
-
-static unsigned int
-hexval(unsigned char c)
-{
-	if (c >= '0' && c <= '9')
-		return c - '0';
-	if (c >= 'a' && c <= 'f')
-		return c - 'a' + 0xA;
-	if (c >= 'A' && c <= 'F')
-		return c - 'A' + 0xA;
-	elog(ERROR, "invalid hexadecimal digit");
-	return 0;					/* not reached */
-}
-
-static void
-check_unicode_value(pg_wchar c, char *loc, core_yyscan_t yyscanner)
-{
-	// database encoding is always UTF8
-	// if (GetDatabaseEncoding() == PG_UTF8)
-	// 	return;
-
-	// if (c > 0x7F)
-	// {
-	// 	ADVANCE_YYLLOC(loc - yyextra->literalbuf + 3);	/* 3 for U&" */
-	// 	yyerror("Unicode escape values cannot be used for code point values above 007F when the server encoding is not UTF8");
-	// }
-}
-
-static bool
-is_utf16_surrogate_first(pg_wchar c)
-{
-	return (c >= 0xD800 && c <= 0xDBFF);
-}
-
-static bool
-is_utf16_surrogate_second(pg_wchar c)
-{
-	return (c >= 0xDC00 && c <= 0xDFFF);
-}
-
-static pg_wchar
-surrogate_pair_to_codepoint(pg_wchar first, pg_wchar second)
-{
-	return ((first & 0x3FF) << 10) + 0x10000 + (second & 0x3FF);
-}
-
-static void
-addunicode(pg_wchar c, core_yyscan_t yyscanner)
-{
-	char		buf[8];
-
-	if (c == 0 || c > 0x10FFFF)
-		yyerror("invalid Unicode escape value");
-	if (c > 0x7F)
-	{
-		// if (GetDatabaseEncoding() != PG_UTF8)
-		// 	yyerror("Unicode escape values cannot be used for code point values above 007F when the server encoding is not UTF8");
-		yyextra->saw_non_ascii = true;
-	}
-	unicode_to_utf8(c, (unsigned char *) buf);
-	addlit(buf, pg_mblen(buf), yyscanner);
-}
-
-/* is 'escape' acceptable as Unicode escape character (UESCAPE syntax) ? */
-static bool
-check_uescapechar(unsigned char escape)
-{
-	if (isxdigit(escape)
-		|| escape == '+'
-		|| escape == '\''
-		|| escape == '"'
-		|| scanner_isspace(escape))
-	{
-		return false;
-	}
-	else
-		return true;
-}
-
-/* like litbufdup, but handle unicode escapes */
-static char *
-litbuf_udeescape(unsigned char escape, core_yyscan_t yyscanner)
-{
-	char	   *newbuf;
-	char	   *litbuf,
-			   *in,
-			   *out;
-	pg_wchar	pair_first = 0;
-
-	/* Make literalbuf null-terminated to simplify the scanning loop */
-	litbuf = yyextra->literalbuf;
-	litbuf[yyextra->literallen] = '\0';
-
-	/*
-	 * This relies on the subtle assumption that a UTF-8 expansion cannot be
-	 * longer than its escaped representation.
-	 */
-	newbuf = (char*) palloc(yyextra->literallen + 1);
-
-	in = litbuf;
-	out = newbuf;
-	while (*in)
-	{
-		if (in[0] == escape)
-		{
-			if (in[1] == escape)
-			{
-				if (pair_first)
-				{
-					ADVANCE_YYLLOC(in - litbuf + 3);	/* 3 for U&" */
-					yyerror("invalid Unicode surrogate pair");
-				}
-				*out++ = escape;
-				in += 2;
-			}
-			else if (isxdigit((unsigned char) in[1]) &&
-					 isxdigit((unsigned char) in[2]) &&
-					 isxdigit((unsigned char) in[3]) &&
-					 isxdigit((unsigned char) in[4]))
-			{
-				pg_wchar	unicode;
-
-				unicode = (hexval(in[1]) << 12) +
-					(hexval(in[2]) << 8) +
-					(hexval(in[3]) << 4) +
-					hexval(in[4]);
-				check_unicode_value(unicode, in, yyscanner);
-				if (pair_first)
-				{
-					if (is_utf16_surrogate_second(unicode))
-					{
-						unicode = surrogate_pair_to_codepoint(pair_first, unicode);
-						pair_first = 0;
-					}
-					else
-					{
-						ADVANCE_YYLLOC(in - litbuf + 3);		/* 3 for U&" */
-						yyerror("invalid Unicode surrogate pair");
-					}
-				}
-				else if (is_utf16_surrogate_second(unicode))
-					yyerror("invalid Unicode surrogate pair");
-
-				if (is_utf16_surrogate_first(unicode))
-					pair_first = unicode;
-				else
-				{
-					unicode_to_utf8(unicode, (unsigned char *) out);
-					out += pg_mblen(out);
-				}
-				in += 5;
-			}
-			else if (in[1] == '+' &&
-					 isxdigit((unsigned char) in[2]) &&
-					 isxdigit((unsigned char) in[3]) &&
-					 isxdigit((unsigned char) in[4]) &&
-					 isxdigit((unsigned char) in[5]) &&
-					 isxdigit((unsigned char) in[6]) &&
-					 isxdigit((unsigned char) in[7]))
-			{
-				pg_wchar	unicode;
-
-				unicode = (hexval(in[2]) << 20) +
-					(hexval(in[3]) << 16) +
-					(hexval(in[4]) << 12) +
-					(hexval(in[5]) << 8) +
-					(hexval(in[6]) << 4) +
-					hexval(in[7]);
-				check_unicode_value(unicode, in, yyscanner);
-				if (pair_first)
-				{
-					if (is_utf16_surrogate_second(unicode))
-					{
-						unicode = surrogate_pair_to_codepoint(pair_first, unicode);
-						pair_first = 0;
-					}
-					else
-					{
-						ADVANCE_YYLLOC(in - litbuf + 3);		/* 3 for U&" */
-						yyerror("invalid Unicode surrogate pair");
-					}
-				}
-				else if (is_utf16_surrogate_second(unicode))
-					yyerror("invalid Unicode surrogate pair");
-
-				if (is_utf16_surrogate_first(unicode))
-					pair_first = unicode;
-				else
-				{
-					unicode_to_utf8(unicode, (unsigned char *) out);
-					out += pg_mblen(out);
-				}
-				in += 8;
-			}
-			else
-			{
-				ADVANCE_YYLLOC(in - litbuf + 3);		/* 3 for U&" */
-				yyerror("invalid Unicode escape value");
-			}
-		}
-		else
-		{
-			if (pair_first)
-			{
-				ADVANCE_YYLLOC(in - litbuf + 3);		/* 3 for U&" */
-				yyerror("invalid Unicode surrogate pair");
-			}
-			*out++ = *in++;
-		}
-	}
-
-	/* unfinished surrogate pair? */
-	if (pair_first)
-	{
-		ADVANCE_YYLLOC(in - litbuf + 3);				/* 3 for U&" */
-		yyerror("invalid Unicode surrogate pair");
-	}
-
-	*out = '\0';
-
-	/*
-	 * We could skip pg_verifymbstr if we didn't process any non-7-bit-ASCII
-	 * codes; but it's probably not worth the trouble, since this isn't likely
-	 * to be a performance-critical path.
-	 */
-	pg_verifymbstr(newbuf, out - newbuf, false);
-	return newbuf;
-}
-
-static unsigned char
-unescape_single_char(unsigned char c, core_yyscan_t yyscanner)
-{
-	switch (c)
-	{
-		case 'b':
-			return '\b';
-		case 'f':
-			return '\f';
-		case 'n':
-			return '\n';
-		case 'r':
-			return '\r';
-		case 't':
-			return '\t';
-		default:
-			/* check for backslash followed by non-7-bit-ASCII */
-			if (c == '\0' || IS_HIGHBIT_SET(c))
-				yyextra->saw_non_ascii = true;
-
-			return c;
-	}
-}
-
-static void
-check_string_escape_warning(unsigned char ychar, core_yyscan_t yyscanner)
-{
-	if (ychar == '\'')
-	{
-		if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
-			ereport(PGWARNING,
-					(errcode(PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
-					 errmsg("nonstandard use of \\' in a string literal"),
-					 errhint("Use '' to write quotes in strings, or use the escape string syntax (E'...')."),
-					 lexer_errposition()));
-		yyextra->warn_on_first_escape = false;	/* warn only once per string */
-	}
-	else if (ychar == '\\')
-	{
-		if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
-			ereport(PGWARNING,
-					(errcode(PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
-					 errmsg("nonstandard use of \\\\ in a string literal"),
-					 errhint("Use the escape string syntax for backslashes, e.g., E'\\\\'."),
-					 lexer_errposition()));
-		yyextra->warn_on_first_escape = false;	/* warn only once per string */
-	}
-	else
-		check_escape_warning(yyscanner);
-}
-
-static void
-check_escape_warning(core_yyscan_t yyscanner)
-{
-	if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
-		ereport(PGWARNING,
-				(errcode(PG_ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
-				 errmsg("nonstandard use of escape in a string literal"),
-		errhint("Use the escape string syntax for escapes, e.g., E'\\r\\n'."),
-				 lexer_errposition()));
-	yyextra->warn_on_first_escape = false;		/* warn only once per string */
-}
-
-/*
- * Interface functions to make flex use palloc() instead of malloc().
- * It'd be better to make these static, but flex insists otherwise.
- */
-
-void *
-core_yyalloc(yy_size_t bytes, core_yyscan_t yyscanner)
-{
-	return palloc(bytes);
-}
-
-void *
-core_yyrealloc(void *ptr, yy_size_t bytes, core_yyscan_t yyscanner)
-{
-	if (ptr)
-		return repalloc(ptr, bytes);
-	else
-		return palloc(bytes);
-}
-
-void
-core_yyfree(void *ptr, core_yyscan_t yyscanner)
-{
-	if (ptr)
-		pfree(ptr);
-}
-
-#undef yyerror
-#undef yylloc
-#undef yylval
-#undef yyin
-#undef yyout
-#undef yyextra
-#undef yyleng
-#undef yytext
-#undef yylineno
-#undef yycolumn
-#undef yy_flex_debug
-#undef yyless
-#undef YYSTYPE
-#undef YY_EXTRA_TYPE
-#undef SET_YYLLOC
-#undef ADVANCE_YYLLOC
-#undef BEGIN
-#undef REJECT
-#undef INITIAL
-#undef xb
-#undef xc
-#undef xd
-#undef xh
-#undef xe
-#undef xq
-#undef xdolq
-#undef xui
-#undef xuiend
-#undef xus
-#undef xusend
-#undef xeu
-#undef ECHO
-
-
-} /* duckdb_libpgquery */
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - truncate_identifier
- * - downcase_truncate_identifier
- * - downcase_identifier
- * - scanner_isspace
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * scansup.c
- *	  support routines for the lex/flex scanner, used by both the normal
- * backend as well as the bootstrap backend
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/parser/scansup.c
- *
- *-------------------------------------------------------------------------
- */
-
-#include <string.h>
-
-#include <ctype.h>
-
-
-
-
-namespace duckdb_libpgquery {
-
-/* ----------------
- *		scanstr
- *
- * if the string passed in has escaped codes, map the escape codes to actual
- * chars
- *
- * the string returned is palloc'd and should eventually be pfree'd by the
- * caller!
- * ----------------
- */
-
-/*
- * downcase_truncate_identifier() --- do appropriate downcasing and
- * truncation of an unquoted identifier.  Optionally warn of truncation.
- *
- * Returns a palloc'd string containing the adjusted identifier.
- *
- * Note: in some usages the passed string is not null-terminated.
- *
- * Note: the API of this function is designed to allow for downcasing
- * transformations that increase the string length, but we don't yet
- * support that.  If you want to implement it, you'll need to fix
- * SplitIdentifierString() in utils/adt/varlena.c.
- */
-char *downcase_truncate_identifier(const char *ident, int len, bool warn) {
-	return downcase_identifier(ident, len, warn, true);
-}
-
-static __thread bool pg_preserve_identifier_case = false;
-
-void set_preserve_identifier_case(bool preserve) {
-	pg_preserve_identifier_case = preserve;
-}
-
-bool get_preserve_identifier_case() {
-	return pg_preserve_identifier_case;
-}
-
-/*
- * a workhorse for downcase_truncate_identifier
- */
-char *downcase_identifier(const char *ident, int len, bool warn, bool truncate) {
-	char *result;
-	int i;
-	bool enc_is_single_byte;
-
-	result = (char *)palloc(len + 1);
-	enc_is_single_byte = pg_database_encoding_max_length() == 1;
-
-	/*
-	 * SQL99 specifies Unicode-aware case normalization, which we don't yet
-	 * have the infrastructure for.  Instead we use tolower() to provide a
-	 * locale-aware translation.  However, there are some locales where this
-	 * is not right either (eg, Turkish may do strange things with 'i' and
-	 * 'I').  Our current compromise is to use tolower() for characters with
-	 * the high bit set, as long as they aren't part of a multi-byte
-	 * character, and use an ASCII-only downcasing for 7-bit characters.
-	 */
-	for (i = 0; i < len; i++) {
-		unsigned char ch = (unsigned char)ident[i];
-
-		if (!get_preserve_identifier_case()) {
-			if (ch >= 'A' && ch <= 'Z')
-				ch += 'a' - 'A';
-			else if (enc_is_single_byte && IS_HIGHBIT_SET(ch) && isupper(ch))
-				ch = tolower(ch);
-		}
-		result[i] = (char)ch;
-	}
-	result[i] = '\0';
-
-	return result;
-}
-
-/*
- * scanner_isspace() --- return true if flex scanner considers char whitespace
- *
- * This should be used instead of the potentially locale-dependent isspace()
- * function when it's important to match the lexer's behavior.
- *
- * In principle we might need similar functions for isalnum etc, but for the
- * moment only isspace seems needed.
- */
-bool scanner_isspace(char ch) {
-	/* This must match scan.l's list of {space} characters */
-	if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\f')
-		return true;
-	return false;
-}
-}
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
-// See the end of this file for a list
-
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - ScanKeywords
- * - NumScanKeywords
- * - ScanKeywordLookup
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * keywords.c
- *	  lexical token lookup for key words in PostgreSQL
- *
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/common/keywords.c
- *
- *-------------------------------------------------------------------------
- */
-
-#include <string.h>
-#include <string>
-#include <memory>
-
-
-
-
-
-namespace duckdb_libpgquery {
-
-/*
- * ScanKeywordLookup - see if a given word is a keyword
- *
- * The table to be searched is passed explicitly, so that this can be used
- * to search keyword lists other than the standard list appearing above.
- *
- * Returns a pointer to the PGScanKeyword table entry, or NULL if no match.
- *
- * The match is done case-insensitively.  Note that we deliberately use a
- * dumbed-down case conversion that will only translate 'A'-'Z' into 'a'-'z',
- * even if we are in a locale where tolower() would produce more or different
- * translations.  This is to conform to the SQL99 spec, which says that
- * keywords are to be matched in this way even though non-keyword identifiers
- * receive a different case-normalization mapping.
- */
-const PGScanKeyword *ScanKeywordLookup(const char *text, const PGScanKeyword *keywords, int num_keywords) {
-	int len, i;
-	const PGScanKeyword *low;
-	const PGScanKeyword *high;
-
-	len = strlen(text);
-	auto data = std::unique_ptr<char[]>(new char[len + 1]);
-	auto word = data.get();
-	/* We assume all keywords are shorter than NAMEDATALEN. */
-
-	/*
-	 * Apply an ASCII-only downcasing.  We must not use tolower() since it may
-	 * produce the wrong translation in some locales (eg, Turkish).
-	 */
-	for (i = 0; i < len; i++) {
-		char ch = text[i];
-
-		if (ch >= 'A' && ch <= 'Z')
-			ch += 'a' - 'A';
-		word[i] = ch;
-	}
-	word[len] = '\0';
-
-	/*
-	 * Now do a binary search using plain strcmp() comparison.
-	 */
-	low = keywords;
-	high = keywords + (num_keywords - 1);
-	while (low <= high) {
-		const PGScanKeyword *middle;
-		int difference;
-
-		middle = low + (high - low) / 2;
-		difference = strcmp(middle->name, word);
-		if (difference == 0)
-			return middle;
-		else if (difference < 0)
-			low = middle + 1;
-		else
-			high = middle - 1;
-	}
-
-	return NULL;
-}
-}
-
-// LICENSE_CHANGE_END
diff --git a/velox/external/duckdb/duckdb-miniz.cpp b/velox/external/duckdb/duckdb-miniz.cpp
deleted file mode 100644
index 4afa830cc7388..0000000000000
--- a/velox/external/duckdb/duckdb-miniz.cpp
+++ /dev/null
@@ -1,7559 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
-// See the end of this file for a list
-
-/**************************************************************************
- *
- * Copyright 2013-2014 RAD Game Tools and Valve Software
- * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- **************************************************************************/
-
-
-
-namespace duckdb_miniz {
-typedef unsigned char mz_validate_uint16[sizeof(mz_uint16) == 2 ? 1 : -1];
-typedef unsigned char mz_validate_uint32[sizeof(mz_uint32) == 4 ? 1 : -1];
-typedef unsigned char mz_validate_uint64[sizeof(mz_uint64) == 8 ? 1 : -1];
-
-
-
-/* ------------------- zlib-style API's */
-
-mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
-{
-    mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16);
-    size_t block_len = buf_len % 5552;
-    if (!ptr)
-        return MZ_ADLER32_INIT;
-    while (buf_len)
-    {
-        for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
-        {
-            s1 += ptr[0], s2 += s1;
-            s1 += ptr[1], s2 += s1;
-            s1 += ptr[2], s2 += s1;
-            s1 += ptr[3], s2 += s1;
-            s1 += ptr[4], s2 += s1;
-            s1 += ptr[5], s2 += s1;
-            s1 += ptr[6], s2 += s1;
-            s1 += ptr[7], s2 += s1;
-        }
-        for (; i < block_len; ++i)
-            s1 += *ptr++, s2 += s1;
-        s1 %= 65521U, s2 %= 65521U;
-        buf_len -= block_len;
-        block_len = 5552;
-    }
-    return (s2 << 16) + s1;
-}
-
-/* Karl Malbrain's compact CRC-32. See "A compact CCITT crc16 and crc32 C implementation that balances processor cache usage against speed": http://www.geocities.com/malbrain/ */
-#if 0
-    mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
-    {
-        static const mz_uint32 s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
-                                               0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };
-        mz_uint32 crcu32 = (mz_uint32)crc;
-        if (!ptr)
-            return MZ_CRC32_INIT;
-        crcu32 = ~crcu32;
-        while (buf_len--)
-        {
-            mz_uint8 b = *ptr++;
-            crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)];
-            crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)];
-        }
-        return ~crcu32;
-    }
-#else
-/* Faster, but larger CPU cache footprint.
- */
-mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
-{
-    static const mz_uint32 s_crc_table[256] =
-        {
-          0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
-          0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
-          0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D,
-          0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
-          0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
-          0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
-          0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC,
-          0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
-          0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,
-          0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
-          0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB,
-          0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
-          0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA,
-          0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE,
-          0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
-          0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
-          0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409,
-          0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
-          0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,
-          0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
-          0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268,
-          0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0,
-          0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,
-          0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
-          0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
-          0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
-          0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,
-          0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
-          0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE,
-          0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
-          0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6,
-          0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
-          0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D,
-          0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
-          0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
-          0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
-          0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
-        };
-
-    mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF;
-    const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr;
-
-    while (buf_len >= 4)
-    {
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF];
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF];
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF];
-        pByte_buf += 4;
-        buf_len -= 4;
-    }
-
-    while (buf_len)
-    {
-        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
-        ++pByte_buf;
-        --buf_len;
-    }
-
-    return ~crc32;
-}
-#endif
-
-void mz_free(void *p)
-{
-    MZ_FREE(p);
-}
-
-void *miniz_def_alloc_func(void *opaque, size_t items, size_t size)
-{
-    (void)opaque, (void)items, (void)size;
-    return MZ_MALLOC(items * size);
-}
-void miniz_def_free_func(void *opaque, void *address)
-{
-    (void)opaque, (void)address;
-    MZ_FREE(address);
-}
-void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size)
-{
-    (void)opaque, (void)address, (void)items, (void)size;
-    return MZ_REALLOC(address, items * size);
-}
-
-const char *mz_version(void)
-{
-    return MZ_VERSION;
-}
-
-#ifndef MINIZ_NO_ZLIB_APIS
-
-int mz_deflateInit(mz_streamp pStream, int level)
-{
-    return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY);
-}
-
-int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
-{
-    tdefl_compressor *pComp;
-    mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy);
-
-    if (!pStream)
-        return MZ_STREAM_ERROR;
-    if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)))
-        return MZ_PARAM_ERROR;
-
-    pStream->data_type = 0;
-    pStream->adler = MZ_ADLER32_INIT;
-    pStream->msg = NULL;
-    pStream->reserved = 0;
-    pStream->total_in = 0;
-    pStream->total_out = 0;
-    if (!pStream->zalloc)
-        pStream->zalloc = miniz_def_alloc_func;
-    if (!pStream->zfree)
-        pStream->zfree = miniz_def_free_func;
-
-    pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor));
-    if (!pComp)
-        return MZ_MEM_ERROR;
-
-    pStream->state = (struct mz_internal_state *)pComp;
-
-    if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY)
-    {
-        mz_deflateEnd(pStream);
-        return MZ_PARAM_ERROR;
-    }
-
-    return MZ_OK;
-}
-
-int mz_deflateReset(mz_streamp pStream)
-{
-    if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree))
-        return MZ_STREAM_ERROR;
-    pStream->total_in = pStream->total_out = 0;
-    tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags);
-    return MZ_OK;
-}
-
-int mz_deflate(mz_streamp pStream, int flush)
-{
-    size_t in_bytes, out_bytes;
-    mz_ulong orig_total_in, orig_total_out;
-    int mz_status = MZ_OK;
-
-    if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out))
-        return MZ_STREAM_ERROR;
-    if (!pStream->avail_out)
-        return MZ_BUF_ERROR;
-
-    if (flush == MZ_PARTIAL_FLUSH)
-        flush = MZ_SYNC_FLUSH;
-
-    if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE)
-        return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
-
-    orig_total_in = pStream->total_in;
-    orig_total_out = pStream->total_out;
-    for (;;)
-    {
-        tdefl_status defl_status;
-        in_bytes = pStream->avail_in;
-        out_bytes = pStream->avail_out;
-
-        defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush);
-        pStream->next_in += (mz_uint)in_bytes;
-        pStream->avail_in -= (mz_uint)in_bytes;
-        pStream->total_in += (mz_uint)in_bytes;
-        pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state);
-
-        pStream->next_out += (mz_uint)out_bytes;
-        pStream->avail_out -= (mz_uint)out_bytes;
-        pStream->total_out += (mz_uint)out_bytes;
-
-        if (defl_status < 0)
-        {
-            mz_status = MZ_STREAM_ERROR;
-            break;
-        }
-        else if (defl_status == TDEFL_STATUS_DONE)
-        {
-            mz_status = MZ_STREAM_END;
-            break;
-        }
-        else if (!pStream->avail_out)
-            break;
-        else if ((!pStream->avail_in) && (flush != MZ_FINISH))
-        {
-            if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out))
-                break;
-            return MZ_BUF_ERROR; /* Can't make forward progress without some input.
- */
-        }
-    }
-    return mz_status;
-}
-
-int mz_deflateEnd(mz_streamp pStream)
-{
-    if (!pStream)
-        return MZ_STREAM_ERROR;
-    if (pStream->state)
-    {
-        pStream->zfree(pStream->opaque, pStream->state);
-        pStream->state = NULL;
-    }
-    return MZ_OK;
-}
-
-mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len)
-{
-    (void)pStream;
-    /* This is really over conservative. (And lame, but it's actually pretty tricky to compute a true upper bound given the way tdefl's blocking works.) */
-    return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5);
-}
-
-int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
-{
-    int status;
-    mz_stream stream;
-    memset(&stream, 0, sizeof(stream));
-
-    /* In case mz_ulong is 64-bits (argh I hate longs). */
-    if ((source_len | *pDest_len) > 0xFFFFFFFFU)
-        return MZ_PARAM_ERROR;
-
-    stream.next_in = pSource;
-    stream.avail_in = (mz_uint32)source_len;
-    stream.next_out = pDest;
-    stream.avail_out = (mz_uint32)*pDest_len;
-
-    status = mz_deflateInit(&stream, level);
-    if (status != MZ_OK)
-        return status;
-
-    status = mz_deflate(&stream, MZ_FINISH);
-    if (status != MZ_STREAM_END)
-    {
-        mz_deflateEnd(&stream);
-        return (status == MZ_OK) ? MZ_BUF_ERROR : status;
-    }
-
-    *pDest_len = stream.total_out;
-    return mz_deflateEnd(&stream);
-}
-
-int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
-{
-    return mz_compress2(pDest, pDest_len, pSource, source_len, MZ_DEFAULT_COMPRESSION);
-}
-
-mz_ulong mz_compressBound(mz_ulong source_len)
-{
-    return mz_deflateBound(NULL, source_len);
-}
-
-typedef struct
-{
-    tinfl_decompressor m_decomp;
-    mz_uint m_dict_ofs, m_dict_avail, m_first_call, m_has_flushed;
-    int m_window_bits;
-    mz_uint8 m_dict[TINFL_LZ_DICT_SIZE];
-    tinfl_status m_last_status;
-} inflate_state;
-
-int mz_inflateInit2(mz_streamp pStream, int window_bits)
-{
-    inflate_state *pDecomp;
-    if (!pStream)
-        return MZ_STREAM_ERROR;
-    if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))
-        return MZ_PARAM_ERROR;
-
-    pStream->data_type = 0;
-    pStream->adler = 0;
-    pStream->msg = NULL;
-    pStream->total_in = 0;
-    pStream->total_out = 0;
-    pStream->reserved = 0;
-    if (!pStream->zalloc)
-        pStream->zalloc = miniz_def_alloc_func;
-    if (!pStream->zfree)
-        pStream->zfree = miniz_def_free_func;
-
-    pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state));
-    if (!pDecomp)
-        return MZ_MEM_ERROR;
-
-    pStream->state = (struct mz_internal_state *)pDecomp;
-
-    tinfl_init(&pDecomp->m_decomp);
-    pDecomp->m_dict_ofs = 0;
-    pDecomp->m_dict_avail = 0;
-    pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
-    pDecomp->m_first_call = 1;
-    pDecomp->m_has_flushed = 0;
-    pDecomp->m_window_bits = window_bits;
-
-    return MZ_OK;
-}
-
-int mz_inflateInit(mz_streamp pStream)
-{
-    return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS);
-}
-
-int mz_inflate(mz_streamp pStream, int flush)
-{
-    inflate_state *pState;
-    mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32;
-    size_t in_bytes, out_bytes, orig_avail_in;
-    tinfl_status status;
-
-    if ((!pStream) || (!pStream->state))
-        return MZ_STREAM_ERROR;
-    if (flush == MZ_PARTIAL_FLUSH)
-        flush = MZ_SYNC_FLUSH;
-    if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH))
-        return MZ_STREAM_ERROR;
-
-    pState = (inflate_state *)pStream->state;
-    if (pState->m_window_bits > 0)
-        decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER;
-    orig_avail_in = pStream->avail_in;
-
-    first_call = pState->m_first_call;
-    pState->m_first_call = 0;
-    if (pState->m_last_status < 0)
-        return MZ_DATA_ERROR;
-
-    if (pState->m_has_flushed && (flush != MZ_FINISH))
-        return MZ_STREAM_ERROR;
-    pState->m_has_flushed |= (flush == MZ_FINISH);
-
-    if ((flush == MZ_FINISH) && (first_call))
-    {
-        /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */
-        decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF;
-        in_bytes = pStream->avail_in;
-        out_bytes = pStream->avail_out;
-        status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags);
-        pState->m_last_status = status;
-        pStream->next_in += (mz_uint)in_bytes;
-        pStream->avail_in -= (mz_uint)in_bytes;
-        pStream->total_in += (mz_uint)in_bytes;
-        pStream->adler = tinfl_get_adler32(&pState->m_decomp);
-        pStream->next_out += (mz_uint)out_bytes;
-        pStream->avail_out -= (mz_uint)out_bytes;
-        pStream->total_out += (mz_uint)out_bytes;
-
-        if (status < 0)
-            return MZ_DATA_ERROR;
-        else if (status != TINFL_STATUS_DONE)
-        {
-            pState->m_last_status = TINFL_STATUS_FAILED;
-            return MZ_BUF_ERROR;
-        }
-        return MZ_STREAM_END;
-    }
-    /* flush != MZ_FINISH then we must assume there's more input. */
-    if (flush != MZ_FINISH)
-        decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT;
-
-    if (pState->m_dict_avail)
-    {
-        n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
-        memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
-        pStream->next_out += n;
-        pStream->avail_out -= n;
-        pStream->total_out += n;
-        pState->m_dict_avail -= n;
-        pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
-        return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
-    }
-
-    for (;;)
-    {
-        in_bytes = pStream->avail_in;
-        out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs;
-
-        status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags);
-        pState->m_last_status = status;
-
-        pStream->next_in += (mz_uint)in_bytes;
-        pStream->avail_in -= (mz_uint)in_bytes;
-        pStream->total_in += (mz_uint)in_bytes;
-        pStream->adler = tinfl_get_adler32(&pState->m_decomp);
-
-        pState->m_dict_avail = (mz_uint)out_bytes;
-
-        n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
-        memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
-        pStream->next_out += n;
-        pStream->avail_out -= n;
-        pStream->total_out += n;
-        pState->m_dict_avail -= n;
-        pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
-
-        if (status < 0)
-            return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */
-        else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in))
-            return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */
-        else if (flush == MZ_FINISH)
-        {
-            /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */
-            if (status == TINFL_STATUS_DONE)
-                return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END;
-            /* status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's at least 1 more byte on the way. If there's no more room left in the output buffer then something is wrong. */
-            else if (!pStream->avail_out)
-                return MZ_BUF_ERROR;
-        }
-        else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail))
-            break;
-    }
-
-    return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
-}
-
-int mz_inflateEnd(mz_streamp pStream)
-{
-    if (!pStream)
-        return MZ_STREAM_ERROR;
-    if (pStream->state)
-    {
-        pStream->zfree(pStream->opaque, pStream->state);
-        pStream->state = NULL;
-    }
-    return MZ_OK;
-}
-
-int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
-{
-    mz_stream stream;
-    int status;
-    memset(&stream, 0, sizeof(stream));
-
-    /* In case mz_ulong is 64-bits (argh I hate longs). */
-    if ((source_len | *pDest_len) > 0xFFFFFFFFU)
-        return MZ_PARAM_ERROR;
-
-    stream.next_in = pSource;
-    stream.avail_in = (mz_uint32)source_len;
-    stream.next_out = pDest;
-    stream.avail_out = (mz_uint32)*pDest_len;
-
-    status = mz_inflateInit(&stream);
-    if (status != MZ_OK)
-        return status;
-
-    status = mz_inflate(&stream, MZ_FINISH);
-    if (status != MZ_STREAM_END)
-    {
-        mz_inflateEnd(&stream);
-        return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
-    }
-    *pDest_len = stream.total_out;
-
-    return mz_inflateEnd(&stream);
-}
-
-const char *mz_error(int err)
-{
-    static struct
-    {
-        int m_err;
-        const char *m_pDesc;
-    } s_error_descs[] =
-        {
-          { MZ_OK, "" }, { MZ_STREAM_END, "stream end" }, { MZ_NEED_DICT, "need dictionary" }, { MZ_ERRNO, "file error" }, { MZ_STREAM_ERROR, "stream error" }, { MZ_DATA_ERROR, "data error" }, { MZ_MEM_ERROR, "out of memory" }, { MZ_BUF_ERROR, "buf error" }, { MZ_VERSION_ERROR, "version error" }, { MZ_PARAM_ERROR, "parameter error" }
-        };
-    mz_uint i;
-    for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i)
-        if (s_error_descs[i].m_err == err)
-            return s_error_descs[i].m_pDesc;
-    return NULL;
-}
-
-#endif /*MINIZ_NO_ZLIB_APIS */
-
-
-
-/*
-  This is free and unencumbered software released into the public domain.
-
-  Anyone is free to copy, modify, publish, use, compile, sell, or
-  distribute this software, either in source code form or as a compiled
-  binary, for any purpose, commercial or non-commercial, and by any
-  means.
-
-  In jurisdictions that recognize copyright laws, the author or authors
-  of this software dedicate any and all copyright interest in the
-  software to the public domain. We make this dedication for the benefit
-  of the public at large and to the detriment of our heirs and
-  successors. We intend this dedication to be an overt act of
-  relinquishment in perpetuity of all present and future rights to this
-  software under copyright law.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-  OTHER DEALINGS IN THE SOFTWARE.
-
-  For more information, please refer to <http://unlicense.org/>
-*/
-/**************************************************************************
- *
- * Copyright 2013-2014 RAD Game Tools and Valve Software
- * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- ***********************************************************************/
-
-/* ------------------- Low-level Compression (independent from all decompression API's) */
-
-/* Purposely making these tables static for faster init and thread safety. */
-static const mz_uint16 s_tdefl_len_sym[256] =
-    {
-      257, 258, 259, 260, 261, 262, 263, 264, 265, 265, 266, 266, 267, 267, 268, 268, 269, 269, 269, 269, 270, 270, 270, 270, 271, 271, 271, 271, 272, 272, 272, 272,
-      273, 273, 273, 273, 273, 273, 273, 273, 274, 274, 274, 274, 274, 274, 274, 274, 275, 275, 275, 275, 275, 275, 275, 275, 276, 276, 276, 276, 276, 276, 276, 276,
-      277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
-      279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280,
-      281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
-      282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,
-      283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
-      284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 285
-    };
-
-static const mz_uint8 s_tdefl_len_extra[256] =
-    {
-      0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0
-    };
-
-static const mz_uint8 s_tdefl_small_dist_sym[512] =
-    {
-      0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,
-      11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13,
-      13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-      14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-      15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
-      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
-      17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
-      17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
-      17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17
-    };
-
-static const mz_uint8 s_tdefl_small_dist_extra[512] =
-    {
-      0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
-      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-      6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-      6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-      7, 7, 7, 7, 7, 7, 7, 7
-    };
-
-static const mz_uint8 s_tdefl_large_dist_sym[128] =
-    {
-      0, 0, 18, 19, 20, 20, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-      26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-      28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
-    };
-
-static const mz_uint8 s_tdefl_large_dist_extra[128] =
-    {
-      0, 0, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-      12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-      13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13
-    };
-
-/* Radix sorts tdefl_sym_freq[] array by 16-bit key m_key. Returns ptr to sorted values. */
-typedef struct
-{
-    mz_uint16 m_key, m_sym_index;
-} tdefl_sym_freq;
-static tdefl_sym_freq *tdefl_radix_sort_syms(mz_uint num_syms, tdefl_sym_freq *pSyms0, tdefl_sym_freq *pSyms1)
-{
-    mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2];
-    tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1;
-    MZ_CLEAR_OBJ(hist);
-    for (i = 0; i < num_syms; i++)
-    {
-        mz_uint freq = pSyms0[i].m_key;
-        hist[freq & 0xFF]++;
-        hist[256 + ((freq >> 8) & 0xFF)]++;
-    }
-    while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256]))
-        total_passes--;
-    for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)
-    {
-        const mz_uint32 *pHist = &hist[pass << 8];
-        mz_uint offsets[256], cur_ofs = 0;
-        for (i = 0; i < 256; i++)
-        {
-            offsets[i] = cur_ofs;
-            cur_ofs += pHist[i];
-        }
-        for (i = 0; i < num_syms; i++)
-            pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i];
-        {
-            tdefl_sym_freq *t = pCur_syms;
-            pCur_syms = pNew_syms;
-            pNew_syms = t;
-        }
-    }
-    return pCur_syms;
-}
-
-/* tdefl_calculate_minimum_redundancy() originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996. */
-static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n)
-{
-    int root, leaf, next, avbl, used, dpth;
-    if (n == 0)
-        return;
-    else if (n == 1)
-    {
-        A[0].m_key = 1;
-        return;
-    }
-    A[0].m_key += A[1].m_key;
-    root = 0;
-    leaf = 2;
-    for (next = 1; next < n - 1; next++)
-    {
-        if (leaf >= n || A[root].m_key < A[leaf].m_key)
-        {
-            A[next].m_key = A[root].m_key;
-            A[root++].m_key = (mz_uint16)next;
-        }
-        else
-            A[next].m_key = A[leaf++].m_key;
-        if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key))
-        {
-            A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key);
-            A[root++].m_key = (mz_uint16)next;
-        }
-        else
-            A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key);
-    }
-    A[n - 2].m_key = 0;
-    for (next = n - 3; next >= 0; next--)
-        A[next].m_key = A[A[next].m_key].m_key + 1;
-    avbl = 1;
-    used = dpth = 0;
-    root = n - 2;
-    next = n - 1;
-    while (avbl > 0)
-    {
-        while (root >= 0 && (int)A[root].m_key == dpth)
-        {
-            used++;
-            root--;
-        }
-        while (avbl > used)
-        {
-            A[next--].m_key = (mz_uint16)(dpth);
-            avbl--;
-        }
-        avbl = 2 * used;
-        dpth++;
-        used = 0;
-    }
-}
-
-/* Limits canonical Huffman code table's max code size. */
-enum
-{
-    TDEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32
-};
-static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
-{
-    int i;
-    mz_uint32 total = 0;
-    if (code_list_len <= 1)
-        return;
-    for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++)
-        pNum_codes[max_code_size] += pNum_codes[i];
-    for (i = max_code_size; i > 0; i--)
-        total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i));
-    while (total != (1UL << max_code_size))
-    {
-        pNum_codes[max_code_size]--;
-        for (i = max_code_size - 1; i > 0; i--)
-            if (pNum_codes[i])
-            {
-                pNum_codes[i]--;
-                pNum_codes[i + 1] += 2;
-                break;
-            }
-        total--;
-    }
-}
-
-static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table)
-{
-    int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE];
-    mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1];
-    MZ_CLEAR_OBJ(num_codes);
-    if (static_table)
-    {
-        for (i = 0; i < table_len; i++)
-            num_codes[d->m_huff_code_sizes[table_num][i]]++;
-    }
-    else
-    {
-        tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms;
-        int num_used_syms = 0;
-        const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0];
-        for (i = 0; i < table_len; i++)
-            if (pSym_count[i])
-            {
-                syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i];
-                syms0[num_used_syms++].m_sym_index = (mz_uint16)i;
-            }
-
-        pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1);
-        tdefl_calculate_minimum_redundancy(pSyms, num_used_syms);
-
-        for (i = 0; i < num_used_syms; i++)
-            num_codes[pSyms[i].m_key]++;
-
-        tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit);
-
-        MZ_CLEAR_OBJ(d->m_huff_code_sizes[table_num]);
-        MZ_CLEAR_OBJ(d->m_huff_codes[table_num]);
-        for (i = 1, j = num_used_syms; i <= code_size_limit; i++)
-            for (l = num_codes[i]; l > 0; l--)
-                d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i);
-    }
-
-    next_code[1] = 0;
-    for (j = 0, i = 2; i <= code_size_limit; i++)
-        next_code[i] = j = ((j + num_codes[i - 1]) << 1);
-
-    for (i = 0; i < table_len; i++)
-    {
-        mz_uint rev_code = 0, code, code_size;
-        if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0)
-            continue;
-        code = next_code[code_size]++;
-        for (l = code_size; l > 0; l--, code >>= 1)
-            rev_code = (rev_code << 1) | (code & 1);
-        d->m_huff_codes[table_num][i] = (mz_uint16)rev_code;
-    }
-}
-
-#define TDEFL_PUT_BITS(b, l)                                       \
-    do                                                             \
-    {                                                              \
-        mz_uint bits = b;                                          \
-        mz_uint len = l;                                           \
-        MZ_ASSERT(bits <= ((1U << len) - 1U));                     \
-        d->m_bit_buffer |= (bits << d->m_bits_in);                 \
-        d->m_bits_in += len;                                       \
-        while (d->m_bits_in >= 8)                                  \
-        {                                                          \
-            if (d->m_pOutput_buf < d->m_pOutput_buf_end)           \
-                *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \
-            d->m_bit_buffer >>= 8;                                 \
-            d->m_bits_in -= 8;                                     \
-        }                                                          \
-    }                                                              \
-    MZ_MACRO_END
-
-#define TDEFL_RLE_PREV_CODE_SIZE()                                                                                       \
-    {                                                                                                                    \
-        if (rle_repeat_count)                                                                                            \
-        {                                                                                                                \
-            if (rle_repeat_count < 3)                                                                                    \
-            {                                                                                                            \
-                d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \
-                while (rle_repeat_count--)                                                                               \
-                    packed_code_sizes[num_packed_code_sizes++] = prev_code_size;                                         \
-            }                                                                                                            \
-            else                                                                                                         \
-            {                                                                                                            \
-                d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1);                                        \
-                packed_code_sizes[num_packed_code_sizes++] = 16;                                                         \
-                packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3);                           \
-            }                                                                                                            \
-            rle_repeat_count = 0;                                                                                        \
-        }                                                                                                                \
-    }
-
-#define TDEFL_RLE_ZERO_CODE_SIZE()                                                         \
-    {                                                                                      \
-        if (rle_z_count)                                                                   \
-        {                                                                                  \
-            if (rle_z_count < 3)                                                           \
-            {                                                                              \
-                d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count);  \
-                while (rle_z_count--)                                                      \
-                    packed_code_sizes[num_packed_code_sizes++] = 0;                        \
-            }                                                                              \
-            else if (rle_z_count <= 10)                                                    \
-            {                                                                              \
-                d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1);          \
-                packed_code_sizes[num_packed_code_sizes++] = 17;                           \
-                packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3);  \
-            }                                                                              \
-            else                                                                           \
-            {                                                                              \
-                d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1);          \
-                packed_code_sizes[num_packed_code_sizes++] = 18;                           \
-                packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \
-            }                                                                              \
-            rle_z_count = 0;                                                               \
-        }                                                                                  \
-    }
-
-static mz_uint8 s_tdefl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
-
-static void tdefl_start_dynamic_block(tdefl_compressor *d)
-{
-    int num_lit_codes, num_dist_codes, num_bit_lengths;
-    mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index;
-    mz_uint8 code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF;
-
-    d->m_huff_count[0][256] = 1;
-
-    tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE);
-    tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE);
-
-    for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--)
-        if (d->m_huff_code_sizes[0][num_lit_codes - 1])
-            break;
-    for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--)
-        if (d->m_huff_code_sizes[1][num_dist_codes - 1])
-            break;
-
-    memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes);
-    memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes);
-    total_code_sizes_to_pack = num_lit_codes + num_dist_codes;
-    num_packed_code_sizes = 0;
-    rle_z_count = 0;
-    rle_repeat_count = 0;
-
-    memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2);
-    for (i = 0; i < total_code_sizes_to_pack; i++)
-    {
-        mz_uint8 code_size = code_sizes_to_pack[i];
-        if (!code_size)
-        {
-            TDEFL_RLE_PREV_CODE_SIZE();
-            if (++rle_z_count == 138)
-            {
-                TDEFL_RLE_ZERO_CODE_SIZE();
-            }
-        }
-        else
-        {
-            TDEFL_RLE_ZERO_CODE_SIZE();
-            if (code_size != prev_code_size)
-            {
-                TDEFL_RLE_PREV_CODE_SIZE();
-                d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1);
-                packed_code_sizes[num_packed_code_sizes++] = code_size;
-            }
-            else if (++rle_repeat_count == 6)
-            {
-                TDEFL_RLE_PREV_CODE_SIZE();
-            }
-        }
-        prev_code_size = code_size;
-    }
-    if (rle_repeat_count)
-    {
-        TDEFL_RLE_PREV_CODE_SIZE();
-    }
-    else
-    {
-        TDEFL_RLE_ZERO_CODE_SIZE();
-    }
-
-    tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE);
-
-    TDEFL_PUT_BITS(2, 2);
-
-    TDEFL_PUT_BITS(num_lit_codes - 257, 5);
-    TDEFL_PUT_BITS(num_dist_codes - 1, 5);
-
-    for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--)
-        if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]])
-            break;
-    num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1));
-    TDEFL_PUT_BITS(num_bit_lengths - 4, 4);
-    for (i = 0; (int)i < num_bit_lengths; i++)
-        TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3);
-
-    for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;)
-    {
-        mz_uint code = packed_code_sizes[packed_code_sizes_index++];
-        MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2);
-        TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]);
-        if (code >= 16)
-            TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]);
-    }
-}
-
-static void tdefl_start_static_block(tdefl_compressor *d)
-{
-    mz_uint i;
-    mz_uint8 *p = &d->m_huff_code_sizes[0][0];
-
-    for (i = 0; i <= 143; ++i)
-        *p++ = 8;
-    for (; i <= 255; ++i)
-        *p++ = 9;
-    for (; i <= 279; ++i)
-        *p++ = 7;
-    for (; i <= 287; ++i)
-        *p++ = 8;
-
-    memset(d->m_huff_code_sizes[1], 5, 32);
-
-    tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE);
-    tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE);
-
-    TDEFL_PUT_BITS(1, 2);
-}
-
-static const mz_uint mz_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS
-static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
-{
-    mz_uint flags;
-    mz_uint8 *pLZ_codes;
-    mz_uint8 *pOutput_buf = d->m_pOutput_buf;
-    mz_uint8 *pLZ_code_buf_end = d->m_pLZ_code_buf;
-    mz_uint64 bit_buffer = d->m_bit_buffer;
-    mz_uint bits_in = d->m_bits_in;
-
-#define TDEFL_PUT_BITS_FAST(b, l)                    \
-    {                                                \
-        bit_buffer |= (((mz_uint64)(b)) << bits_in); \
-        bits_in += (l);                              \
-    }
-
-    flags = 1;
-    for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; flags >>= 1)
-    {
-        if (flags == 1)
-            flags = *pLZ_codes++ | 0x100;
-
-        if (flags & 1)
-        {
-            mz_uint s0, s1, n0, n1, sym, num_extra_bits;
-            mz_uint match_len = pLZ_codes[0], match_dist = *(const mz_uint16 *)(pLZ_codes + 1);
-            pLZ_codes += 3;
-
-            MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
-            TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
-            TDEFL_PUT_BITS_FAST(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
-
-            /* This sequence coaxes MSVC into using cmov's vs. jmp's. */
-            s0 = s_tdefl_small_dist_sym[match_dist & 511];
-            n0 = s_tdefl_small_dist_extra[match_dist & 511];
-            s1 = s_tdefl_large_dist_sym[match_dist >> 8];
-            n1 = s_tdefl_large_dist_extra[match_dist >> 8];
-            sym = (match_dist < 512) ? s0 : s1;
-            num_extra_bits = (match_dist < 512) ? n0 : n1;
-
-            MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
-            TDEFL_PUT_BITS_FAST(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
-            TDEFL_PUT_BITS_FAST(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
-        }
-        else
-        {
-            mz_uint lit = *pLZ_codes++;
-            MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
-            TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
-
-            if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
-            {
-                flags >>= 1;
-                lit = *pLZ_codes++;
-                MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
-                TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
-
-                if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
-                {
-                    flags >>= 1;
-                    lit = *pLZ_codes++;
-                    MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
-                    TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
-                }
-            }
-        }
-
-        if (pOutput_buf >= d->m_pOutput_buf_end)
-            return MZ_FALSE;
-
-        *(mz_uint64 *)pOutput_buf = bit_buffer;
-        pOutput_buf += (bits_in >> 3);
-        bit_buffer >>= (bits_in & ~7);
-        bits_in &= 7;
-    }
-
-#undef TDEFL_PUT_BITS_FAST
-
-    d->m_pOutput_buf = pOutput_buf;
-    d->m_bits_in = 0;
-    d->m_bit_buffer = 0;
-
-    while (bits_in)
-    {
-        mz_uint32 n = MZ_MIN(bits_in, 16);
-        TDEFL_PUT_BITS((mz_uint)bit_buffer & mz_bitmasks[n], n);
-        bit_buffer >>= n;
-        bits_in -= n;
-    }
-
-    TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
-
-    return (d->m_pOutput_buf < d->m_pOutput_buf_end);
-}
-#else
-static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
-{
-    mz_uint flags;
-    mz_uint8 *pLZ_codes;
-
-    flags = 1;
-    for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1)
-    {
-        if (flags == 1)
-            flags = *pLZ_codes++ | 0x100;
-        if (flags & 1)
-        {
-            mz_uint sym, num_extra_bits;
-            mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8));
-            pLZ_codes += 3;
-
-            MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
-            TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
-            TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
-
-            if (match_dist < 512)
-            {
-                sym = s_tdefl_small_dist_sym[match_dist];
-                num_extra_bits = s_tdefl_small_dist_extra[match_dist];
-            }
-            else
-            {
-                sym = s_tdefl_large_dist_sym[match_dist >> 8];
-                num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8];
-            }
-            MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
-            TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
-            TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
-        }
-        else
-        {
-            mz_uint lit = *pLZ_codes++;
-            MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
-            TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
-        }
-    }
-
-    TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
-
-    return (d->m_pOutput_buf < d->m_pOutput_buf_end);
-}
-#endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS */
-
-static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block)
-{
-    if (static_block)
-        tdefl_start_static_block(d);
-    else
-        tdefl_start_dynamic_block(d);
-    return tdefl_compress_lz_codes(d);
-}
-
-static int tdefl_flush_block(tdefl_compressor *d, int flush)
-{
-    mz_uint saved_bit_buf, saved_bits_in;
-    mz_uint8 *pSaved_output_buf;
-    mz_bool comp_block_succeeded = MZ_FALSE;
-    int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size;
-    mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf;
-
-    d->m_pOutput_buf = pOutput_buf_start;
-    d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16;
-
-    MZ_ASSERT(!d->m_output_flush_remaining);
-    d->m_output_flush_ofs = 0;
-    d->m_output_flush_remaining = 0;
-
-    *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left);
-    d->m_pLZ_code_buf -= (d->m_num_flags_left == 8);
-
-    if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index))
-    {
-        TDEFL_PUT_BITS(0x78, 8);
-        TDEFL_PUT_BITS(0x01, 8);
-    }
-
-    TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1);
-
-    pSaved_output_buf = d->m_pOutput_buf;
-    saved_bit_buf = d->m_bit_buffer;
-    saved_bits_in = d->m_bits_in;
-
-    if (!use_raw_block)
-        comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48));
-
-    /* If the block gets expanded, forget the current contents of the output buffer and send a raw block instead. */
-    if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) &&
-        ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size))
-    {
-        mz_uint i;
-        d->m_pOutput_buf = pSaved_output_buf;
-        d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
-        TDEFL_PUT_BITS(0, 2);
-        if (d->m_bits_in)
-        {
-            TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
-        }
-        for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF)
-        {
-            TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16);
-        }
-        for (i = 0; i < d->m_total_lz_bytes; ++i)
-        {
-            TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8);
-        }
-    }
-    /* Check for the extremely unlikely (if not impossible) case of the compressed block not fitting into the output buffer when using dynamic codes. */
-    else if (!comp_block_succeeded)
-    {
-        d->m_pOutput_buf = pSaved_output_buf;
-        d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
-        tdefl_compress_block(d, MZ_TRUE);
-    }
-
-    if (flush)
-    {
-        if (flush == TDEFL_FINISH)
-        {
-            if (d->m_bits_in)
-            {
-                TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
-            }
-            if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER)
-            {
-                mz_uint i, a = d->m_adler32;
-                for (i = 0; i < 4; i++)
-                {
-                    TDEFL_PUT_BITS((a >> 24) & 0xFF, 8);
-                    a <<= 8;
-                }
-            }
-        }
-        else
-        {
-            mz_uint i, z = 0;
-            TDEFL_PUT_BITS(0, 3);
-            if (d->m_bits_in)
-            {
-                TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
-            }
-            for (i = 2; i; --i, z ^= 0xFFFF)
-            {
-                TDEFL_PUT_BITS(z & 0xFFFF, 16);
-            }
-        }
-    }
-
-    MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end);
-
-    memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
-    memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
-
-    d->m_pLZ_code_buf = d->m_lz_code_buf + 1;
-    d->m_pLZ_flags = d->m_lz_code_buf;
-    d->m_num_flags_left = 8;
-    d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes;
-    d->m_total_lz_bytes = 0;
-    d->m_block_index++;
-
-    if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0)
-    {
-        if (d->m_pPut_buf_func)
-        {
-            *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
-            if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user))
-                return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED);
-        }
-        else if (pOutput_buf_start == d->m_output_buf)
-        {
-            int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs));
-            memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy);
-            d->m_out_buf_ofs += bytes_to_copy;
-            if ((n -= bytes_to_copy) != 0)
-            {
-                d->m_output_flush_ofs = bytes_to_copy;
-                d->m_output_flush_remaining = n;
-            }
-        }
-        else
-        {
-            d->m_out_buf_ofs += n;
-        }
-    }
-
-    return d->m_output_flush_remaining;
-}
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
-#ifdef MINIZ_UNALIGNED_USE_MEMCPY
-static inline mz_uint16 TDEFL_READ_UNALIGNED_WORD(const mz_uint8* p)
-{
-	mz_uint16 ret;
-	memcpy(&ret, p, sizeof(mz_uint16));
-	return ret;
-}
-static inline mz_uint16 TDEFL_READ_UNALIGNED_WORD2(const mz_uint16* p)
-{
-	mz_uint16 ret;
-	memcpy(&ret, p, sizeof(mz_uint16));
-	return ret;
-}
-#else
-#define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p)
-#define TDEFL_READ_UNALIGNED_WORD2(p) *(const mz_uint16 *)(p)
-#endif
-static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
-{
-    mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
-    mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
-    const mz_uint16 *s = (const mz_uint16 *)(d->m_dict + pos), *p, *q;
-    mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]), s01 = TDEFL_READ_UNALIGNED_WORD2(s);
-    MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN);
-    if (max_match_len <= match_len)
-        return;
-    for (;;)
-    {
-        for (;;)
-        {
-            if (--num_probes_left == 0)
-                return;
-#define TDEFL_PROBE                                                                             \
-    next_probe_pos = d->m_next[probe_pos];                                                      \
-    if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \
-        return;                                                                                 \
-    probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK;                                       \
-    if (TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01)                \
-        break;
-            TDEFL_PROBE;
-            TDEFL_PROBE;
-            TDEFL_PROBE;
-        }
-        if (!dist)
-            break;
-        q = (const mz_uint16 *)(d->m_dict + probe_pos);
-        if (TDEFL_READ_UNALIGNED_WORD2(q) != s01)
-            continue;
-        p = s;
-        probe_len = 32;
-        do
-        {
-        } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) &&
-                 (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0));
-        if (!probe_len)
-        {
-            *pMatch_dist = dist;
-            *pMatch_len = MZ_MIN(max_match_len, (mz_uint)TDEFL_MAX_MATCH_LEN);
-            break;
-        }
-        else if ((probe_len = ((mz_uint)(p - s) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q)) > match_len)
-        {
-            *pMatch_dist = dist;
-            if ((*pMatch_len = match_len = MZ_MIN(max_match_len, probe_len)) == max_match_len)
-                break;
-            c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]);
-        }
-    }
-}
-#else
-static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
-{
-    mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
-    mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
-    const mz_uint8 *s = d->m_dict + pos, *p, *q;
-    mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1];
-    MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN);
-    if (max_match_len <= match_len)
-        return;
-    for (;;)
-    {
-        for (;;)
-        {
-            if (--num_probes_left == 0)
-                return;
-#define TDEFL_PROBE                                                                               \
-    next_probe_pos = d->m_next[probe_pos];                                                        \
-    if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist))   \
-        return;                                                                                   \
-    probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK;                                         \
-    if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \
-        break;
-            TDEFL_PROBE;
-            TDEFL_PROBE;
-            TDEFL_PROBE;
-        }
-        if (!dist)
-            break;
-        p = s;
-        q = d->m_dict + probe_pos;
-        for (probe_len = 0; probe_len < max_match_len; probe_len++)
-            if (*p++ != *q++)
-                break;
-        if (probe_len > match_len)
-        {
-            *pMatch_dist = dist;
-            if ((*pMatch_len = match_len = probe_len) == max_match_len)
-                return;
-            c0 = d->m_dict[pos + match_len];
-            c1 = d->m_dict[pos + match_len - 1];
-        }
-    }
-}
-#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES */
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
-static mz_bool tdefl_compress_fast(tdefl_compressor *d)
-{
-    /* Faster, minimally featured LZRW1-style match+parse loop with better register utilization. Intended for applications where raw throughput is valued more highly than ratio. */
-    mz_uint lookahead_pos = d->m_lookahead_pos, lookahead_size = d->m_lookahead_size, dict_size = d->m_dict_size, total_lz_bytes = d->m_total_lz_bytes, num_flags_left = d->m_num_flags_left;
-    mz_uint8 *pLZ_code_buf = d->m_pLZ_code_buf, *pLZ_flags = d->m_pLZ_flags;
-    mz_uint cur_pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
-
-    while ((d->m_src_buf_left) || ((d->m_flush) && (lookahead_size)))
-    {
-        const mz_uint TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096;
-        mz_uint dst_pos = (lookahead_pos + lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
-        mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(d->m_src_buf_left, TDEFL_COMP_FAST_LOOKAHEAD_SIZE - lookahead_size);
-        d->m_src_buf_left -= num_bytes_to_process;
-        lookahead_size += num_bytes_to_process;
-
-        while (num_bytes_to_process)
-        {
-            mz_uint32 n = MZ_MIN(TDEFL_LZ_DICT_SIZE - dst_pos, num_bytes_to_process);
-            memcpy(d->m_dict + dst_pos, d->m_pSrc, n);
-            if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
-                memcpy(d->m_dict + TDEFL_LZ_DICT_SIZE + dst_pos, d->m_pSrc, MZ_MIN(n, (TDEFL_MAX_MATCH_LEN - 1) - dst_pos));
-            d->m_pSrc += n;
-            dst_pos = (dst_pos + n) & TDEFL_LZ_DICT_SIZE_MASK;
-            num_bytes_to_process -= n;
-        }
-
-        dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - lookahead_size, dict_size);
-        if ((!d->m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE))
-            break;
-
-        while (lookahead_size >= 4)
-        {
-            mz_uint cur_match_dist, cur_match_len = 1;
-            mz_uint8 *pCur_dict = d->m_dict + cur_pos;
-            mz_uint first_trigram = (*(const mz_uint32 *)pCur_dict) & 0xFFFFFF;
-            mz_uint hash = (first_trigram ^ (first_trigram >> (24 - (TDEFL_LZ_HASH_BITS - 8)))) & TDEFL_LEVEL1_HASH_SIZE_MASK;
-            mz_uint probe_pos = d->m_hash[hash];
-            d->m_hash[hash] = (mz_uint16)lookahead_pos;
-
-            if (((cur_match_dist = (mz_uint16)(lookahead_pos - probe_pos)) <= dict_size) && ((*(const mz_uint32 *)(d->m_dict + (probe_pos &= TDEFL_LZ_DICT_SIZE_MASK)) & 0xFFFFFF) == first_trigram))
-            {
-                const mz_uint16 *p = (const mz_uint16 *)pCur_dict;
-                const mz_uint16 *q = (const mz_uint16 *)(d->m_dict + probe_pos);
-                mz_uint32 probe_len = 32;
-                do
-                {
-                } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) &&
-                         (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0));
-                cur_match_len = ((mz_uint)(p - (const mz_uint16 *)pCur_dict) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q);
-                if (!probe_len)
-                    cur_match_len = cur_match_dist ? TDEFL_MAX_MATCH_LEN : 0;
-
-                if ((cur_match_len < TDEFL_MIN_MATCH_LEN) || ((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)))
-                {
-                    cur_match_len = 1;
-                    *pLZ_code_buf++ = (mz_uint8)first_trigram;
-                    *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
-                    d->m_huff_count[0][(mz_uint8)first_trigram]++;
-                }
-                else
-                {
-                    mz_uint32 s0, s1;
-                    cur_match_len = MZ_MIN(cur_match_len, lookahead_size);
-
-                    MZ_ASSERT((cur_match_len >= TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 1) && (cur_match_dist <= TDEFL_LZ_DICT_SIZE));
-
-                    cur_match_dist--;
-
-                    pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN);
-                    *(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist;
-                    pLZ_code_buf += 3;
-                    *pLZ_flags = (mz_uint8)((*pLZ_flags >> 1) | 0x80);
-
-                    s0 = s_tdefl_small_dist_sym[cur_match_dist & 511];
-                    s1 = s_tdefl_large_dist_sym[cur_match_dist >> 8];
-                    d->m_huff_count[1][(cur_match_dist < 512) ? s0 : s1]++;
-
-                    d->m_huff_count[0][s_tdefl_len_sym[cur_match_len - TDEFL_MIN_MATCH_LEN]]++;
-                }
-            }
-            else
-            {
-                *pLZ_code_buf++ = (mz_uint8)first_trigram;
-                *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
-                d->m_huff_count[0][(mz_uint8)first_trigram]++;
-            }
-
-            if (--num_flags_left == 0)
-            {
-                num_flags_left = 8;
-                pLZ_flags = pLZ_code_buf++;
-            }
-
-            total_lz_bytes += cur_match_len;
-            lookahead_pos += cur_match_len;
-            dict_size = MZ_MIN(dict_size + cur_match_len, (mz_uint)TDEFL_LZ_DICT_SIZE);
-            cur_pos = (cur_pos + cur_match_len) & TDEFL_LZ_DICT_SIZE_MASK;
-            MZ_ASSERT(lookahead_size >= cur_match_len);
-            lookahead_size -= cur_match_len;
-
-            if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
-            {
-                int n;
-                d->m_lookahead_pos = lookahead_pos;
-                d->m_lookahead_size = lookahead_size;
-                d->m_dict_size = dict_size;
-                d->m_total_lz_bytes = total_lz_bytes;
-                d->m_pLZ_code_buf = pLZ_code_buf;
-                d->m_pLZ_flags = pLZ_flags;
-                d->m_num_flags_left = num_flags_left;
-                if ((n = tdefl_flush_block(d, 0)) != 0)
-                    return (n < 0) ? MZ_FALSE : MZ_TRUE;
-                total_lz_bytes = d->m_total_lz_bytes;
-                pLZ_code_buf = d->m_pLZ_code_buf;
-                pLZ_flags = d->m_pLZ_flags;
-                num_flags_left = d->m_num_flags_left;
-            }
-        }
-
-        while (lookahead_size)
-        {
-            mz_uint8 lit = d->m_dict[cur_pos];
-
-            total_lz_bytes++;
-            *pLZ_code_buf++ = lit;
-            *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
-            if (--num_flags_left == 0)
-            {
-                num_flags_left = 8;
-                pLZ_flags = pLZ_code_buf++;
-            }
-
-            d->m_huff_count[0][lit]++;
-
-            lookahead_pos++;
-            dict_size = MZ_MIN(dict_size + 1, (mz_uint)TDEFL_LZ_DICT_SIZE);
-            cur_pos = (cur_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK;
-            lookahead_size--;
-
-            if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
-            {
-                int n;
-                d->m_lookahead_pos = lookahead_pos;
-                d->m_lookahead_size = lookahead_size;
-                d->m_dict_size = dict_size;
-                d->m_total_lz_bytes = total_lz_bytes;
-                d->m_pLZ_code_buf = pLZ_code_buf;
-                d->m_pLZ_flags = pLZ_flags;
-                d->m_num_flags_left = num_flags_left;
-                if ((n = tdefl_flush_block(d, 0)) != 0)
-                    return (n < 0) ? MZ_FALSE : MZ_TRUE;
-                total_lz_bytes = d->m_total_lz_bytes;
-                pLZ_code_buf = d->m_pLZ_code_buf;
-                pLZ_flags = d->m_pLZ_flags;
-                num_flags_left = d->m_num_flags_left;
-            }
-        }
-    }
-
-    d->m_lookahead_pos = lookahead_pos;
-    d->m_lookahead_size = lookahead_size;
-    d->m_dict_size = dict_size;
-    d->m_total_lz_bytes = total_lz_bytes;
-    d->m_pLZ_code_buf = pLZ_code_buf;
-    d->m_pLZ_flags = pLZ_flags;
-    d->m_num_flags_left = num_flags_left;
-    return MZ_TRUE;
-}
-#endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */
-
-static MZ_FORCEINLINE void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit)
-{
-    d->m_total_lz_bytes++;
-    *d->m_pLZ_code_buf++ = lit;
-    *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1);
-    if (--d->m_num_flags_left == 0)
-    {
-        d->m_num_flags_left = 8;
-        d->m_pLZ_flags = d->m_pLZ_code_buf++;
-    }
-    d->m_huff_count[0][lit]++;
-}
-
-static MZ_FORCEINLINE void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)
-{
-    mz_uint32 s0, s1;
-
-    MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE));
-
-    d->m_total_lz_bytes += match_len;
-
-    d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN);
-
-    match_dist -= 1;
-    d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF);
-    d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8);
-    d->m_pLZ_code_buf += 3;
-
-    *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80);
-    if (--d->m_num_flags_left == 0)
-    {
-        d->m_num_flags_left = 8;
-        d->m_pLZ_flags = d->m_pLZ_code_buf++;
-    }
-
-    s0 = s_tdefl_small_dist_sym[match_dist & 511];
-    s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127];
-    d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++;
-
-    if (match_len >= TDEFL_MIN_MATCH_LEN)
-        d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++;
-}
-
-static mz_bool tdefl_compress_normal(tdefl_compressor *d)
-{
-    const mz_uint8 *pSrc = d->m_pSrc;
-    size_t src_buf_left = d->m_src_buf_left;
-    tdefl_flush flush = d->m_flush;
-
-    while ((src_buf_left) || ((flush) && (d->m_lookahead_size)))
-    {
-        mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos;
-        /* Update dictionary and hash chains. Keeps the lookahead size equal to TDEFL_MAX_MATCH_LEN. */
-        if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1))
-        {
-            mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK, ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2;
-            mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK];
-            mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size);
-            const mz_uint8 *pSrc_end = pSrc + num_bytes_to_process;
-            src_buf_left -= num_bytes_to_process;
-            d->m_lookahead_size += num_bytes_to_process;
-            while (pSrc != pSrc_end)
-            {
-                mz_uint8 c = *pSrc++;
-                d->m_dict[dst_pos] = c;
-                if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
-                    d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
-                hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
-                d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash];
-                d->m_hash[hash] = (mz_uint16)(ins_pos);
-                dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK;
-                ins_pos++;
-            }
-        }
-        else
-        {
-            while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
-            {
-                mz_uint8 c = *pSrc++;
-                mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
-                src_buf_left--;
-                d->m_dict[dst_pos] = c;
-                if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
-                    d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
-                if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN)
-                {
-                    mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2;
-                    mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << (TDEFL_LZ_HASH_SHIFT * 2)) ^ (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
-                    d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash];
-                    d->m_hash[hash] = (mz_uint16)(ins_pos);
-                }
-            }
-        }
-        d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size);
-        if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
-            break;
-
-        /* Simple lazy/greedy parsing state machine. */
-        len_to_move = 1;
-        cur_match_dist = 0;
-        cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1);
-        cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
-        if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS))
-        {
-            if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))
-            {
-                mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK];
-                cur_match_len = 0;
-                while (cur_match_len < d->m_lookahead_size)
-                {
-                    if (d->m_dict[cur_pos + cur_match_len] != c)
-                        break;
-                    cur_match_len++;
-                }
-                if (cur_match_len < TDEFL_MIN_MATCH_LEN)
-                    cur_match_len = 0;
-                else
-                    cur_match_dist = 1;
-            }
-        }
-        else
-        {
-            tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len);
-        }
-        if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5)))
-        {
-            cur_match_dist = cur_match_len = 0;
-        }
-        if (d->m_saved_match_len)
-        {
-            if (cur_match_len > d->m_saved_match_len)
-            {
-                tdefl_record_literal(d, (mz_uint8)d->m_saved_lit);
-                if (cur_match_len >= 128)
-                {
-                    tdefl_record_match(d, cur_match_len, cur_match_dist);
-                    d->m_saved_match_len = 0;
-                    len_to_move = cur_match_len;
-                }
-                else
-                {
-                    d->m_saved_lit = d->m_dict[cur_pos];
-                    d->m_saved_match_dist = cur_match_dist;
-                    d->m_saved_match_len = cur_match_len;
-                }
-            }
-            else
-            {
-                tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist);
-                len_to_move = d->m_saved_match_len - 1;
-                d->m_saved_match_len = 0;
-            }
-        }
-        else if (!cur_match_dist)
-            tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]);
-        else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128))
-        {
-            tdefl_record_match(d, cur_match_len, cur_match_dist);
-            len_to_move = cur_match_len;
-        }
-        else
-        {
-            d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)];
-            d->m_saved_match_dist = cur_match_dist;
-            d->m_saved_match_len = cur_match_len;
-        }
-        /* Move the lookahead forward by len_to_move bytes. */
-        d->m_lookahead_pos += len_to_move;
-        MZ_ASSERT(d->m_lookahead_size >= len_to_move);
-        d->m_lookahead_size -= len_to_move;
-        d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE);
-        /* Check if it's time to flush the current LZ codes to the internal output buffer. */
-        if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) ||
-            ((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))))
-        {
-            int n;
-            d->m_pSrc = pSrc;
-            d->m_src_buf_left = src_buf_left;
-            if ((n = tdefl_flush_block(d, 0)) != 0)
-                return (n < 0) ? MZ_FALSE : MZ_TRUE;
-        }
-    }
-
-    d->m_pSrc = pSrc;
-    d->m_src_buf_left = src_buf_left;
-    return MZ_TRUE;
-}
-
-static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
-{
-    if (d->m_pIn_buf_size)
-    {
-        *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
-    }
-
-    if (d->m_pOut_buf_size)
-    {
-        size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining);
-        memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n);
-        d->m_output_flush_ofs += (mz_uint)n;
-        d->m_output_flush_remaining -= (mz_uint)n;
-        d->m_out_buf_ofs += n;
-
-        *d->m_pOut_buf_size = d->m_out_buf_ofs;
-    }
-
-    return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY;
-}
-
-tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)
-{
-    if (!d)
-    {
-        if (pIn_buf_size)
-            *pIn_buf_size = 0;
-        if (pOut_buf_size)
-            *pOut_buf_size = 0;
-        return TDEFL_STATUS_BAD_PARAM;
-    }
-
-    d->m_pIn_buf = pIn_buf;
-    d->m_pIn_buf_size = pIn_buf_size;
-    d->m_pOut_buf = pOut_buf;
-    d->m_pOut_buf_size = pOut_buf_size;
-    d->m_pSrc = (const mz_uint8 *)(pIn_buf);
-    d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0;
-    d->m_out_buf_ofs = 0;
-    d->m_flush = flush;
-
-    if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) ||
-        (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf))
-    {
-        if (pIn_buf_size)
-            *pIn_buf_size = 0;
-        if (pOut_buf_size)
-            *pOut_buf_size = 0;
-        return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM);
-    }
-    d->m_wants_to_finish |= (flush == TDEFL_FINISH);
-
-    if ((d->m_output_flush_remaining) || (d->m_finished))
-        return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
-
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
-    if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) &&
-        ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) &&
-        ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0))
-    {
-        if (!tdefl_compress_fast(d))
-            return d->m_prev_return_status;
-    }
-    else
-#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */
-    {
-        if (!tdefl_compress_normal(d))
-            return d->m_prev_return_status;
-    }
-
-    if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf))
-        d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf);
-
-    if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining))
-    {
-        if (tdefl_flush_block(d, flush) < 0)
-            return d->m_prev_return_status;
-        d->m_finished = (flush == TDEFL_FINISH);
-        if (flush == TDEFL_FULL_FLUSH)
-        {
-            MZ_CLEAR_OBJ(d->m_hash);
-            MZ_CLEAR_OBJ(d->m_next);
-            d->m_dict_size = 0;
-        }
-    }
-
-    return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
-}
-
-tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
-{
-    MZ_ASSERT(d->m_pPut_buf_func);
-    return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush);
-}
-
-tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
-{
-    d->m_pPut_buf_func = pPut_buf_func;
-    d->m_pPut_buf_user = pPut_buf_user;
-    d->m_flags = (mz_uint)(flags);
-    d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3;
-    d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0;
-    d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
-    if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG))
-        MZ_CLEAR_OBJ(d->m_hash);
-    d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0;
-    d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0;
-    d->m_pLZ_code_buf = d->m_lz_code_buf + 1;
-    d->m_pLZ_flags = d->m_lz_code_buf;
-    d->m_num_flags_left = 8;
-    d->m_pOutput_buf = d->m_output_buf;
-    d->m_pOutput_buf_end = d->m_output_buf;
-    d->m_prev_return_status = TDEFL_STATUS_OKAY;
-    d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0;
-    d->m_adler32 = 1;
-    d->m_pIn_buf = NULL;
-    d->m_pOut_buf = NULL;
-    d->m_pIn_buf_size = NULL;
-    d->m_pOut_buf_size = NULL;
-    d->m_flush = TDEFL_NO_FLUSH;
-    d->m_pSrc = NULL;
-    d->m_src_buf_left = 0;
-    d->m_out_buf_ofs = 0;
-    if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG))
-        MZ_CLEAR_OBJ(d->m_dict);
-    memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
-    memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
-    return TDEFL_STATUS_OKAY;
-}
-
-tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d)
-{
-    return d->m_prev_return_status;
-}
-
-mz_uint32 tdefl_get_adler32(tdefl_compressor *d)
-{
-    return d->m_adler32;
-}
-
-mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
-{
-    tdefl_compressor *pComp;
-    mz_bool succeeded;
-    if (((buf_len) && (!pBuf)) || (!pPut_buf_func))
-        return MZ_FALSE;
-    pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
-    if (!pComp)
-        return MZ_FALSE;
-    succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
-    succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
-    MZ_FREE(pComp);
-    return succeeded;
-}
-
-typedef struct
-{
-    size_t m_size, m_capacity;
-    mz_uint8 *m_pBuf;
-    mz_bool m_expandable;
-} tdefl_output_buffer;
-
-static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
-{
-    tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
-    size_t new_size = p->m_size + len;
-    if (new_size > p->m_capacity)
-    {
-        size_t new_capacity = p->m_capacity;
-        mz_uint8 *pNew_buf;
-        if (!p->m_expandable)
-            return MZ_FALSE;
-        do
-        {
-            new_capacity = MZ_MAX(128U, new_capacity << 1U);
-        } while (new_size > new_capacity);
-        pNew_buf = (mz_uint8 *)MZ_REALLOC(p->m_pBuf, new_capacity);
-        if (!pNew_buf)
-            return MZ_FALSE;
-        p->m_pBuf = pNew_buf;
-        p->m_capacity = new_capacity;
-    }
-    memcpy((mz_uint8 *)p->m_pBuf + p->m_size, pBuf, len);
-    p->m_size = new_size;
-    return MZ_TRUE;
-}
-
-void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
-{
-    tdefl_output_buffer out_buf;
-    MZ_CLEAR_OBJ(out_buf);
-    if (!pOut_len)
-        return MZ_FALSE;
-    else
-        *pOut_len = 0;
-    out_buf.m_expandable = MZ_TRUE;
-    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
-        return NULL;
-    *pOut_len = out_buf.m_size;
-    return out_buf.m_pBuf;
-}
-
-size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
-{
-    tdefl_output_buffer out_buf;
-    MZ_CLEAR_OBJ(out_buf);
-    if (!pOut_buf)
-        return 0;
-    out_buf.m_pBuf = (mz_uint8 *)pOut_buf;
-    out_buf.m_capacity = out_buf_len;
-    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
-        return 0;
-    return out_buf.m_size;
-}
-
-static const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
-
-/* level may actually range from [0,10] (10 is a "hidden" max level, where we want a bit more compression and it's fine if throughput to fall off a cliff on some files). */
-mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
-{
-    mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
-    if (window_bits > 0)
-        comp_flags |= TDEFL_WRITE_ZLIB_HEADER;
-
-    if (!level)
-        comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
-    else if (strategy == MZ_FILTERED)
-        comp_flags |= TDEFL_FILTER_MATCHES;
-    else if (strategy == MZ_HUFFMAN_ONLY)
-        comp_flags &= ~TDEFL_MAX_PROBES_MASK;
-    else if (strategy == MZ_FIXED)
-        comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
-    else if (strategy == MZ_RLE)
-        comp_flags |= TDEFL_RLE_MATCHES;
-
-    return comp_flags;
-}
-
-#ifdef _MSC_VER
-//#pragma warning(push)
-//#pragma warning(disable : 4204) /* nonstandard extension used : non-constant aggregate initializer (also supported by GNU C and C99, so no big deal) */
-#endif
-
-/* Simple PNG writer function by Alex Evans, 2011. Released into the public domain: https://gist.github.com/908299, more context at
- http://altdevblogaday.org/2011/04/06/a-smaller-jpg-encoder/.
- This is actually a modification of Alex's original code so PNG files generated by this function pass pngcheck. */
-void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip)
-{
-    /* Using a local copy of this array here in case MINIZ_NO_ZLIB_APIS was defined. */
-    static const mz_uint s_tdefl_png_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
-    tdefl_compressor *pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
-    tdefl_output_buffer out_buf;
-    int i, bpl = w * num_chans, y, z;
-    mz_uint32 c;
-    *pLen_out = 0;
-    if (!pComp)
-        return NULL;
-    MZ_CLEAR_OBJ(out_buf);
-    out_buf.m_expandable = MZ_TRUE;
-    out_buf.m_capacity = 57 + MZ_MAX(64, (1 + bpl) * h);
-    if (NULL == (out_buf.m_pBuf = (mz_uint8 *)MZ_MALLOC(out_buf.m_capacity)))
-    {
-        MZ_FREE(pComp);
-        return NULL;
-    }
-    /* write dummy header */
-    for (z = 41; z; --z)
-        tdefl_output_buffer_putter(&z, 1, &out_buf);
-    /* compress image data */
-    tdefl_init(pComp, tdefl_output_buffer_putter, &out_buf, s_tdefl_png_num_probes[MZ_MIN(10, level)] | TDEFL_WRITE_ZLIB_HEADER);
-    for (y = 0; y < h; ++y)
-    {
-        tdefl_compress_buffer(pComp, &z, 1, TDEFL_NO_FLUSH);
-        tdefl_compress_buffer(pComp, (mz_uint8 *)pImage + (flip ? (h - 1 - y) : y) * bpl, bpl, TDEFL_NO_FLUSH);
-    }
-    if (tdefl_compress_buffer(pComp, NULL, 0, TDEFL_FINISH) != TDEFL_STATUS_DONE)
-    {
-        MZ_FREE(pComp);
-        MZ_FREE(out_buf.m_pBuf);
-        return NULL;
-    }
-    /* write real header */
-    *pLen_out = out_buf.m_size - 41;
-    {
-        static const mz_uint8 chans[] = { 0x00, 0x00, 0x04, 0x02, 0x06 };
-        mz_uint8 pnghdr[41] = { 0x89, 0x50, 0x4e, 0x47, 0x0d,
-                                0x0a, 0x1a, 0x0a, 0x00, 0x00,
-                                0x00, 0x0d, 0x49, 0x48, 0x44,
-                                0x52, 0x00, 0x00, 0x00, 0x00,
-                                0x00, 0x00, 0x00, 0x00, 0x08,
-                                0x00, 0x00, 0x00, 0x00, 0x00,
-                                0x00, 0x00, 0x00, 0x00, 0x00,
-                                0x00, 0x00, 0x49, 0x44, 0x41,
-                                0x54 };
-        pnghdr[18] = (mz_uint8)(w >> 8);
-        pnghdr[19] = (mz_uint8)w;
-        pnghdr[22] = (mz_uint8)(h >> 8);
-        pnghdr[23] = (mz_uint8)h;
-        pnghdr[25] = chans[num_chans];
-        pnghdr[33] = (mz_uint8)(*pLen_out >> 24);
-        pnghdr[34] = (mz_uint8)(*pLen_out >> 16);
-        pnghdr[35] = (mz_uint8)(*pLen_out >> 8);
-        pnghdr[36] = (mz_uint8)*pLen_out;
-        c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, pnghdr + 12, 17);
-        for (i = 0; i < 4; ++i, c <<= 8)
-            ((mz_uint8 *)(pnghdr + 29))[i] = (mz_uint8)(c >> 24);
-        memcpy(out_buf.m_pBuf, pnghdr, 41);
-    }
-    /* write footer (IDAT CRC-32, followed by IEND chunk) */
-    if (!tdefl_output_buffer_putter("\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf))
-    {
-        *pLen_out = 0;
-        MZ_FREE(pComp);
-        MZ_FREE(out_buf.m_pBuf);
-        return NULL;
-    }
-    c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, out_buf.m_pBuf + 41 - 4, *pLen_out + 4);
-    for (i = 0; i < 4; ++i, c <<= 8)
-        (out_buf.m_pBuf + out_buf.m_size - 16)[i] = (mz_uint8)(c >> 24);
-    /* compute final size of file, grab compressed data buffer and return */
-    *pLen_out += 57;
-    MZ_FREE(pComp);
-    return out_buf.m_pBuf;
-}
-void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out)
-{
-    /* Level 6 corresponds to TDEFL_DEFAULT_MAX_PROBES or MZ_DEFAULT_LEVEL (but we can't depend on MZ_DEFAULT_LEVEL being available in case the zlib API's where #defined out) */
-    return tdefl_write_image_to_png_file_in_memory_ex(pImage, w, h, num_chans, pLen_out, 6, MZ_FALSE);
-}
-
-/* Allocate the tdefl_compressor and tinfl_decompressor structures in C so that */
-/* non-C language bindings to tdefL_ and tinfl_ API don't need to worry about */
-/* structure size and allocation mechanism. */
-tdefl_compressor *tdefl_compressor_alloc()
-{
-    return (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
-}
-
-void tdefl_compressor_free(tdefl_compressor *pComp)
-{
-    MZ_FREE(pComp);
-}
-
-#ifdef _MSC_VER
-//#pragma warning(pop)
-#endif
-
-/**************************************************************************
- *
- * Copyright 2013-2014 RAD Game Tools and Valve Software
- * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- **************************************************************************/
-
-
-
-
-/* ------------------- Low-level Decompression (completely independent from all compression API's) */
-
-#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l)
-#define TINFL_MEMSET(p, c, l) memset(p, c, l)
-
-#define TINFL_CR_BEGIN  \
-    switch (r->m_state) \
-    {                   \
-        case 0:
-#define TINFL_CR_RETURN(state_index, result) \
-    do                                       \
-    {                                        \
-        status = result;                     \
-        r->m_state = state_index;            \
-        goto common_exit;                    \
-        case state_index:;                   \
-    }                                        \
-    MZ_MACRO_END
-#define TINFL_CR_RETURN_FOREVER(state_index, result) \
-    do                                               \
-    {                                                \
-        for (;;)                                     \
-        {                                            \
-            TINFL_CR_RETURN(state_index, result);    \
-        }                                            \
-    }                                                \
-    MZ_MACRO_END
-#define TINFL_CR_FINISH }
-
-#define TINFL_GET_BYTE(state_index, c)                                                                                                                           \
-    do                                                                                                                                                           \
-    {                                                                                                                                                            \
-        while (pIn_buf_cur >= pIn_buf_end)                                                                                                                       \
-        {                                                                                                                                                        \
-            TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \
-        }                                                                                                                                                        \
-        c = *pIn_buf_cur++;                                                                                                                                      \
-    }                                                                                                                                                            \
-    MZ_MACRO_END
-
-#define TINFL_NEED_BITS(state_index, n)                \
-    do                                                 \
-    {                                                  \
-        mz_uint c;                                     \
-        TINFL_GET_BYTE(state_index, c);                \
-        bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \
-        num_bits += 8;                                 \
-    } while (num_bits < (mz_uint)(n))
-#define TINFL_SKIP_BITS(state_index, n)      \
-    do                                       \
-    {                                        \
-        if (num_bits < (mz_uint)(n))         \
-        {                                    \
-            TINFL_NEED_BITS(state_index, n); \
-        }                                    \
-        bit_buf >>= (n);                     \
-        num_bits -= (n);                     \
-    }                                        \
-    MZ_MACRO_END
-#define TINFL_GET_BITS(state_index, b, n)    \
-    do                                       \
-    {                                        \
-        if (num_bits < (mz_uint)(n))         \
-        {                                    \
-            TINFL_NEED_BITS(state_index, n); \
-        }                                    \
-        b = bit_buf & ((1 << (n)) - 1);      \
-        bit_buf >>= (n);                     \
-        num_bits -= (n);                     \
-    }                                        \
-    MZ_MACRO_END
-
-/* TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes remaining in the input buffer falls below 2. */
-/* It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a */
-/* Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the */
-/* bit buffer contains >=15 bits (deflate's max. Huffman code size). */
-#define TINFL_HUFF_BITBUF_FILL(state_index, pHuff)                             \
-    do                                                                         \
-    {                                                                          \
-        temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)];     \
-        if (temp >= 0)                                                         \
-        {                                                                      \
-            code_len = temp >> 9;                                              \
-            if ((code_len) && (num_bits >= code_len))                          \
-                break;                                                         \
-        }                                                                      \
-        else if (num_bits > TINFL_FAST_LOOKUP_BITS)                            \
-        {                                                                      \
-            code_len = TINFL_FAST_LOOKUP_BITS;                                 \
-            do                                                                 \
-            {                                                                  \
-                temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \
-            } while ((temp < 0) && (num_bits >= (code_len + 1)));              \
-            if (temp >= 0)                                                     \
-                break;                                                         \
-        }                                                                      \
-        TINFL_GET_BYTE(state_index, c);                                        \
-        bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                         \
-        num_bits += 8;                                                         \
-    } while (num_bits < 15);
-
-/* TINFL_HUFF_DECODE() decodes the next Huffman coded symbol. It's more complex than you would initially expect because the zlib API expects the decompressor to never read */
-/* beyond the final byte of the deflate stream. (In other words, when this macro wants to read another byte from the input, it REALLY needs another byte in order to fully */
-/* decode the next Huffman code.) Handling this properly is particularly important on raw deflate (non-zlib) streams, which aren't followed by a byte aligned adler-32. */
-/* The slow path is only executed at the very end of the input buffer. */
-/* v1.16: The original macro handled the case at the very end of the passed-in input buffer, but we also need to handle the case where the user passes in 1+zillion bytes */
-/* following the deflate data and our non-conservative read-ahead path won't kick in here on this code. This is much trickier. */
-#define TINFL_HUFF_DECODE(state_index, sym, pHuff)                                                                                  \
-    do                                                                                                                              \
-    {                                                                                                                               \
-        int temp;                                                                                                                   \
-        mz_uint code_len, c;                                                                                                        \
-        if (num_bits < 15)                                                                                                          \
-        {                                                                                                                           \
-            if ((pIn_buf_end - pIn_buf_cur) < 2)                                                                                    \
-            {                                                                                                                       \
-                TINFL_HUFF_BITBUF_FILL(state_index, pHuff);                                                                         \
-            }                                                                                                                       \
-            else                                                                                                                    \
-            {                                                                                                                       \
-                bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \
-                pIn_buf_cur += 2;                                                                                                   \
-                num_bits += 16;                                                                                                     \
-            }                                                                                                                       \
-        }                                                                                                                           \
-        if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)                                               \
-            code_len = temp >> 9, temp &= 511;                                                                                      \
-        else                                                                                                                        \
-        {                                                                                                                           \
-            code_len = TINFL_FAST_LOOKUP_BITS;                                                                                      \
-            do                                                                                                                      \
-            {                                                                                                                       \
-                temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)];                                                      \
-            } while (temp < 0);                                                                                                     \
-        }                                                                                                                           \
-        sym = temp;                                                                                                                 \
-        bit_buf >>= code_len;                                                                                                       \
-        num_bits -= code_len;                                                                                                       \
-    }                                                                                                                               \
-    MZ_MACRO_END
-
-tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags)
-{
-    static const int s_length_base[31] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 };
-    static const int s_length_extra[31] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0 };
-    static const int s_dist_base[32] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0 };
-    static const int s_dist_extra[32] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };
-    static const mz_uint8 s_length_dezigzag[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
-    static const int s_min_table_sizes[3] = { 257, 1, 4 };
-
-    tinfl_status status = TINFL_STATUS_FAILED;
-    mz_uint32 num_bits, dist, counter, num_extra;
-    tinfl_bit_buf_t bit_buf;
-    const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
-    mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next + *pOut_buf_size;
-    size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start;
-
-    /* Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter). */
-    if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start))
-    {
-        *pIn_buf_size = *pOut_buf_size = 0;
-        return TINFL_STATUS_BAD_PARAM;
-    }
-
-    num_bits = r->m_num_bits;
-    bit_buf = r->m_bit_buf;
-    dist = r->m_dist;
-    counter = r->m_counter;
-    num_extra = r->m_num_extra;
-    dist_from_out_buf_start = r->m_dist_from_out_buf_start;
-    TINFL_CR_BEGIN
-
-    bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0;
-    r->m_z_adler32 = r->m_check_adler32 = 1;
-    if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
-    {
-        TINFL_GET_BYTE(1, r->m_zhdr0);
-        TINFL_GET_BYTE(2, r->m_zhdr1);
-        counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
-        if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
-            counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)(1U << (8U + (r->m_zhdr0 >> 4)))));
-        if (counter)
-        {
-            TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED);
-        }
-    }
-
-    do
-    {
-        TINFL_GET_BITS(3, r->m_final, 3);
-        r->m_type = r->m_final >> 1;
-        if (r->m_type == 0)
-        {
-            TINFL_SKIP_BITS(5, num_bits & 7);
-            for (counter = 0; counter < 4; ++counter)
-            {
-                if (num_bits)
-                    TINFL_GET_BITS(6, r->m_raw_header[counter], 8);
-                else
-                    TINFL_GET_BYTE(7, r->m_raw_header[counter]);
-            }
-            if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8))))
-            {
-                TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED);
-            }
-            while ((counter) && (num_bits))
-            {
-                TINFL_GET_BITS(51, dist, 8);
-                while (pOut_buf_cur >= pOut_buf_end)
-                {
-                    TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT);
-                }
-                *pOut_buf_cur++ = (mz_uint8)dist;
-                counter--;
-            }
-            while (counter)
-            {
-                size_t n;
-                while (pOut_buf_cur >= pOut_buf_end)
-                {
-                    TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT);
-                }
-                while (pIn_buf_cur >= pIn_buf_end)
-                {
-                    TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);
-                }
-                n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter);
-                TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n);
-                pIn_buf_cur += n;
-                pOut_buf_cur += n;
-                counter -= (mz_uint)n;
-            }
-        }
-        else if (r->m_type == 3)
-        {
-            TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED);
-        }
-        else
-        {
-            if (r->m_type == 1)
-            {
-                mz_uint8 *p = r->m_tables[0].m_code_size;
-                mz_uint i;
-                r->m_table_sizes[0] = 288;
-                r->m_table_sizes[1] = 32;
-                TINFL_MEMSET(r->m_tables[1].m_code_size, 5, 32);
-                for (i = 0; i <= 143; ++i)
-                    *p++ = 8;
-                for (; i <= 255; ++i)
-                    *p++ = 9;
-                for (; i <= 279; ++i)
-                    *p++ = 7;
-                for (; i <= 287; ++i)
-                    *p++ = 8;
-            }
-            else
-            {
-                for (counter = 0; counter < 3; counter++)
-                {
-                    TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]);
-                    r->m_table_sizes[counter] += s_min_table_sizes[counter];
-                }
-                MZ_CLEAR_OBJ(r->m_tables[2].m_code_size);
-                for (counter = 0; counter < r->m_table_sizes[2]; counter++)
-                {
-                    mz_uint s;
-                    TINFL_GET_BITS(14, s, 3);
-                    r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (mz_uint8)s;
-                }
-                r->m_table_sizes[2] = 19;
-            }
-            for (; (int)r->m_type >= 0; r->m_type--)
-            {
-                int tree_next, tree_cur;
-                tinfl_huff_table *pTable;
-                mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16];
-                pTable = &r->m_tables[r->m_type];
-                MZ_CLEAR_OBJ(total_syms);
-                MZ_CLEAR_OBJ(pTable->m_look_up);
-                MZ_CLEAR_OBJ(pTable->m_tree);
-                for (i = 0; i < r->m_table_sizes[r->m_type]; ++i)
-                    total_syms[pTable->m_code_size[i]]++;
-                used_syms = 0, total = 0;
-                next_code[0] = next_code[1] = 0;
-                for (i = 1; i <= 15; ++i)
-                {
-                    used_syms += total_syms[i];
-                    next_code[i + 1] = (total = ((total + total_syms[i]) << 1));
-                }
-                if ((65536 != total) && (used_syms > 1))
-                {
-                    TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED);
-                }
-                for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index)
-                {
-                    mz_uint rev_code = 0, l, cur_code, code_size = pTable->m_code_size[sym_index];
-                    if (!code_size)
-                        continue;
-                    cur_code = next_code[code_size]++;
-                    for (l = code_size; l > 0; l--, cur_code >>= 1)
-                        rev_code = (rev_code << 1) | (cur_code & 1);
-                    if (code_size <= TINFL_FAST_LOOKUP_BITS)
-                    {
-                        mz_int16 k = (mz_int16)((code_size << 9) | sym_index);
-                        while (rev_code < TINFL_FAST_LOOKUP_SIZE)
-                        {
-                            pTable->m_look_up[rev_code] = k;
-                            rev_code += (1 << code_size);
-                        }
-                        continue;
-                    }
-                    if (0 == (tree_cur = pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)]))
-                    {
-                        pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next;
-                        tree_cur = tree_next;
-                        tree_next -= 2;
-                    }
-                    rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
-                    for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--)
-                    {
-                        tree_cur -= ((rev_code >>= 1) & 1);
-                        if (!pTable->m_tree[-tree_cur - 1])
-                        {
-                            pTable->m_tree[-tree_cur - 1] = (mz_int16)tree_next;
-                            tree_cur = tree_next;
-                            tree_next -= 2;
-                        }
-                        else
-                            tree_cur = pTable->m_tree[-tree_cur - 1];
-                    }
-                    tree_cur -= ((rev_code >>= 1) & 1);
-                    pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index;
-                }
-                if (r->m_type == 2)
-                {
-                    for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);)
-                    {
-                        mz_uint s;
-                        TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]);
-                        if (dist < 16)
-                        {
-                            r->m_len_codes[counter++] = (mz_uint8)dist;
-                            continue;
-                        }
-                        if ((dist == 16) && (!counter))
-                        {
-                            TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED);
-                        }
-                        num_extra = "\02\03\07"[dist - 16];
-                        TINFL_GET_BITS(18, s, num_extra);
-                        s += "\03\03\013"[dist - 16];
-                        TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s);
-                        counter += s;
-                    }
-                    if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter)
-                    {
-                        TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED);
-                    }
-                    TINFL_MEMCPY(r->m_tables[0].m_code_size, r->m_len_codes, r->m_table_sizes[0]);
-                    TINFL_MEMCPY(r->m_tables[1].m_code_size, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]);
-                }
-            }
-            for (;;)
-            {
-                mz_uint8 *pSrc;
-                for (;;)
-                {
-                    if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
-                    {
-                        TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]);
-                        if (counter >= 256)
-                            break;
-                        while (pOut_buf_cur >= pOut_buf_end)
-                        {
-                            TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT);
-                        }
-                        *pOut_buf_cur++ = (mz_uint8)counter;
-                    }
-                    else
-                    {
-                        int sym2;
-                        mz_uint code_len;
-#if TINFL_USE_64BIT_BITBUF
-                        if (num_bits < 30)
-                        {
-                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits);
-                            pIn_buf_cur += 4;
-                            num_bits += 32;
-                        }
-#else
-                        if (num_bits < 15)
-                        {
-                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
-                            pIn_buf_cur += 2;
-                            num_bits += 16;
-                        }
-#endif
-                        if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
-                            code_len = sym2 >> 9;
-                        else
-                        {
-                            code_len = TINFL_FAST_LOOKUP_BITS;
-                            do
-                            {
-                                sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];
-                            } while (sym2 < 0);
-                        }
-                        counter = sym2;
-                        bit_buf >>= code_len;
-                        num_bits -= code_len;
-                        if (counter & 256)
-                            break;
-
-#if !TINFL_USE_64BIT_BITBUF
-                        if (num_bits < 15)
-                        {
-                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
-                            pIn_buf_cur += 2;
-                            num_bits += 16;
-                        }
-#endif
-                        if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
-                            code_len = sym2 >> 9;
-                        else
-                        {
-                            code_len = TINFL_FAST_LOOKUP_BITS;
-                            do
-                            {
-                                sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];
-                            } while (sym2 < 0);
-                        }
-                        bit_buf >>= code_len;
-                        num_bits -= code_len;
-
-                        pOut_buf_cur[0] = (mz_uint8)counter;
-                        if (sym2 & 256)
-                        {
-                            pOut_buf_cur++;
-                            counter = sym2;
-                            break;
-                        }
-                        pOut_buf_cur[1] = (mz_uint8)sym2;
-                        pOut_buf_cur += 2;
-                    }
-                }
-                if ((counter &= 511) == 256)
-                    break;
-
-                num_extra = s_length_extra[counter - 257];
-                counter = s_length_base[counter - 257];
-                if (num_extra)
-                {
-                    mz_uint extra_bits;
-                    TINFL_GET_BITS(25, extra_bits, num_extra);
-                    counter += extra_bits;
-                }
-
-                TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]);
-                num_extra = s_dist_extra[dist];
-                dist = s_dist_base[dist];
-                if (num_extra)
-                {
-                    mz_uint extra_bits;
-                    TINFL_GET_BITS(27, extra_bits, num_extra);
-                    dist += extra_bits;
-                }
-
-                dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
-                if ((dist > dist_from_out_buf_start) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
-                {
-                    TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED);
-                }
-
-                pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
-
-                if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
-                {
-                    while (counter--)
-                    {
-                        while (pOut_buf_cur >= pOut_buf_end)
-                        {
-                            TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT);
-                        }
-                        *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
-                    }
-                    continue;
-                }
-#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
-                else if ((counter >= 9) && (counter <= dist))
-                {
-                    const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
-                    do
-                    {
-                        ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
-                        ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
-                        pOut_buf_cur += 8;
-                    } while ((pSrc += 8) < pSrc_end);
-                    if ((counter &= 7) < 3)
-                    {
-                        if (counter)
-                        {
-                            pOut_buf_cur[0] = pSrc[0];
-                            if (counter > 1)
-                                pOut_buf_cur[1] = pSrc[1];
-                            pOut_buf_cur += counter;
-                        }
-                        continue;
-                    }
-                }
-#endif
-                while(counter>2)
-                {
-                    pOut_buf_cur[0] = pSrc[0];
-                    pOut_buf_cur[1] = pSrc[1];
-                    pOut_buf_cur[2] = pSrc[2];
-                    pOut_buf_cur += 3;
-                    pSrc += 3;
-					counter -= 3;
-                }
-                if (counter > 0)
-                {
-                    pOut_buf_cur[0] = pSrc[0];
-                    if (counter > 1)
-                        pOut_buf_cur[1] = pSrc[1];
-                    pOut_buf_cur += counter;
-                }
-            }
-        }
-    } while (!(r->m_final & 1));
-
-    /* Ensure byte alignment and put back any bytes from the bitbuf if we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */
-    /* I'm being super conservative here. A number of simplifications can be made to the byte alignment part, and the Adler32 check shouldn't ever need to worry about reading from the bitbuf now. */
-    TINFL_SKIP_BITS(32, num_bits & 7);
-    while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
-    {
-        --pIn_buf_cur;
-        num_bits -= 8;
-    }
-    bit_buf &= (tinfl_bit_buf_t)((((mz_uint64)1) << num_bits) - (mz_uint64)1);
-    MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end of non-deflate/zlib streams with following data (such as gzip streams). */
-
-    if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
-    {
-        for (counter = 0; counter < 4; ++counter)
-        {
-            mz_uint s;
-            if (num_bits)
-                TINFL_GET_BITS(41, s, 8);
-            else
-                TINFL_GET_BYTE(42, s);
-            r->m_z_adler32 = (r->m_z_adler32 << 8) | s;
-        }
-    }
-    TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE);
-
-    TINFL_CR_FINISH
-
-common_exit:
-    /* As long as we aren't telling the caller that we NEED more input to make forward progress: */
-    /* Put back any bytes from the bitbuf in case we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */
-    /* We need to be very careful here to NOT push back any bytes we definitely know we need to make forward progress, though, or we'll lock the caller up into an inf loop. */
-    if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS))
-    {
-        while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
-        {
-            --pIn_buf_cur;
-            num_bits -= 8;
-        }
-    }
-    r->m_num_bits = num_bits;
-    r->m_bit_buf = bit_buf & (tinfl_bit_buf_t)((((mz_uint64)1) << num_bits) - (mz_uint64)1);
-    r->m_dist = dist;
-    r->m_counter = counter;
-    r->m_num_extra = num_extra;
-    r->m_dist_from_out_buf_start = dist_from_out_buf_start;
-    *pIn_buf_size = pIn_buf_cur - pIn_buf_next;
-    *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
-    if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0))
-    {
-        const mz_uint8 *ptr = pOut_buf_next;
-        size_t buf_len = *pOut_buf_size;
-        mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16;
-        size_t block_len = buf_len % 5552;
-        while (buf_len)
-        {
-            for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
-            {
-                s1 += ptr[0], s2 += s1;
-                s1 += ptr[1], s2 += s1;
-                s1 += ptr[2], s2 += s1;
-                s1 += ptr[3], s2 += s1;
-                s1 += ptr[4], s2 += s1;
-                s1 += ptr[5], s2 += s1;
-                s1 += ptr[6], s2 += s1;
-                s1 += ptr[7], s2 += s1;
-            }
-            for (; i < block_len; ++i)
-                s1 += *ptr++, s2 += s1;
-            s1 %= 65521U, s2 %= 65521U;
-            buf_len -= block_len;
-            block_len = 5552;
-        }
-        r->m_check_adler32 = (s2 << 16) + s1;
-        if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32))
-            status = TINFL_STATUS_ADLER32_MISMATCH;
-    }
-    return status;
-}
-
-/* Higher level helper functions. */
-void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
-{
-    tinfl_decompressor decomp;
-    void *pBuf = NULL, *pNew_buf;
-    size_t src_buf_ofs = 0, out_buf_capacity = 0;
-    *pOut_len = 0;
-    tinfl_init(&decomp);
-    for (;;)
-    {
-        size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
-        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8 *)pBuf, pBuf ? (mz_uint8 *)pBuf + *pOut_len : NULL, &dst_buf_size,
-                                               (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
-        if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
-        {
-            MZ_FREE(pBuf);
-            *pOut_len = 0;
-            return NULL;
-        }
-        src_buf_ofs += src_buf_size;
-        *pOut_len += dst_buf_size;
-        if (status == TINFL_STATUS_DONE)
-            break;
-        new_out_buf_capacity = out_buf_capacity * 2;
-        if (new_out_buf_capacity < 128)
-            new_out_buf_capacity = 128;
-        pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
-        if (!pNew_buf)
-        {
-            MZ_FREE(pBuf);
-            *pOut_len = 0;
-            return NULL;
-        }
-        pBuf = pNew_buf;
-        out_buf_capacity = new_out_buf_capacity;
-    }
-    return pBuf;
-}
-
-size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
-{
-    tinfl_decompressor decomp;
-    tinfl_status status;
-    tinfl_init(&decomp);
-    status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf, &src_buf_len, (mz_uint8 *)pOut_buf, (mz_uint8 *)pOut_buf, &out_buf_len, (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
-    return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len;
-}
-
-int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
-{
-    int result = 0;
-    tinfl_decompressor decomp;
-    mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE);
-    size_t in_buf_ofs = 0, dict_ofs = 0;
-    if (!pDict)
-        return TINFL_STATUS_FAILED;
-    tinfl_init(&decomp);
-    for (;;)
-    {
-        size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
-        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
-                                               (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
-        in_buf_ofs += in_buf_size;
-        if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
-            break;
-        if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
-        {
-            result = (status == TINFL_STATUS_DONE);
-            break;
-        }
-        dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
-    }
-    MZ_FREE(pDict);
-    *pIn_buf_size = in_buf_ofs;
-    return result;
-}
-
-tinfl_decompressor *tinfl_decompressor_alloc()
-{
-    tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor));
-    if (pDecomp)
-        tinfl_init(pDecomp);
-    return pDecomp;
-}
-
-void tinfl_decompressor_free(tinfl_decompressor *pDecomp)
-{
-    MZ_FREE(pDecomp);
-}
-
-
-
-/**************************************************************************
- *
- * Copyright 2013-2014 RAD Game Tools and Valve Software
- * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
- * Copyright 2016 Martin Raiber
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- **************************************************************************/
-
-
-#ifndef MINIZ_NO_ARCHIVE_APIS
-
-
-
-/* ------------------- .ZIP archive reading */
-
-#ifdef MINIZ_NO_STDIO
-#define MZ_FILE void *
-#else
-#include <sys/stat.h>
-
-#if defined(_MSC_VER) || defined(__MINGW64__)
-static FILE *mz_fopen(const char *pFilename, const char *pMode)
-{
-    FILE *pFile = NULL;
-    fopen_s(&pFile, pFilename, pMode);
-    return pFile;
-}
-static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream)
-{
-    FILE *pFile = NULL;
-    if (freopen_s(&pFile, pPath, pMode, pStream))
-        return NULL;
-    return pFile;
-}
-#ifndef MINIZ_NO_TIME
-#include <sys/utime.h>
-#endif
-#define MZ_FOPEN mz_fopen
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 _ftelli64
-#define MZ_FSEEK64 _fseeki64
-#define MZ_FILE_STAT_STRUCT _stat
-#define MZ_FILE_STAT _stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN mz_freopen
-#define MZ_DELETE_FILE remove
-#elif defined(__MINGW32__)
-#ifndef MINIZ_NO_TIME
-#include <sys/utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 ftello64
-#define MZ_FSEEK64 fseeko64
-#define MZ_FILE_STAT_STRUCT _stat
-#define MZ_FILE_STAT _stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(f, m, s) freopen(f, m, s)
-#define MZ_DELETE_FILE remove
-#elif defined(__TINYC__)
-#ifndef MINIZ_NO_TIME
-#include <sys/utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 ftell
-#define MZ_FSEEK64 fseek
-#define MZ_FILE_STAT_STRUCT stat
-#define MZ_FILE_STAT stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(f, m, s) freopen(f, m, s)
-#define MZ_DELETE_FILE remove
-#elif defined(__GNUC__) && _LARGEFILE64_SOURCE
-#ifndef MINIZ_NO_TIME
-#include <utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen64(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 ftello64
-#define MZ_FSEEK64 fseeko64
-#define MZ_FILE_STAT_STRUCT stat64
-#define MZ_FILE_STAT stat64
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(p, m, s) freopen64(p, m, s)
-#define MZ_DELETE_FILE remove
-#elif defined(__APPLE__)
-#ifndef MINIZ_NO_TIME
-#include <utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#define MZ_FTELL64 ftello
-#define MZ_FSEEK64 fseeko
-#define MZ_FILE_STAT_STRUCT stat
-#define MZ_FILE_STAT stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(p, m, s) freopen(p, m, s)
-#define MZ_DELETE_FILE remove
-
-#else
-//#pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.")
-#ifndef MINIZ_NO_TIME
-#include <utime.h>
-#endif
-#define MZ_FOPEN(f, m) fopen(f, m)
-#define MZ_FCLOSE fclose
-#define MZ_FREAD fread
-#define MZ_FWRITE fwrite
-#ifdef __STRICT_ANSI__
-#define MZ_FTELL64 ftell
-#define MZ_FSEEK64 fseek
-#else
-#define MZ_FTELL64 ftello
-#define MZ_FSEEK64 fseeko
-#endif
-#define MZ_FILE_STAT_STRUCT stat
-#define MZ_FILE_STAT stat
-#define MZ_FFLUSH fflush
-#define MZ_FREOPEN(f, m, s) freopen(f, m, s)
-#define MZ_DELETE_FILE remove
-#endif /* #ifdef _MSC_VER */
-#endif /* #ifdef MINIZ_NO_STDIO */
-
-#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
-
-/* Various ZIP archive enums. To completely avoid cross platform compiler alignment and platform endian issues, miniz.c doesn't use structs for any of this stuff. */
-enum
-{
-    /* ZIP archive identifiers and record sizes */
-    MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06054b50,
-    MZ_ZIP_CENTRAL_DIR_HEADER_SIG = 0x02014b50,
-    MZ_ZIP_LOCAL_DIR_HEADER_SIG = 0x04034b50,
-    MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30,
-    MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46,
-    MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22,
-
-    /* ZIP64 archive identifier and record sizes */
-    MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50,
-    MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50,
-    MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56,
-    MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20,
-    MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001,
-    MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50,
-    MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24,
-    MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16,
-
-    /* Central directory header record offsets */
-    MZ_ZIP_CDH_SIG_OFS = 0,
-    MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4,
-    MZ_ZIP_CDH_VERSION_NEEDED_OFS = 6,
-    MZ_ZIP_CDH_BIT_FLAG_OFS = 8,
-    MZ_ZIP_CDH_METHOD_OFS = 10,
-    MZ_ZIP_CDH_FILE_TIME_OFS = 12,
-    MZ_ZIP_CDH_FILE_DATE_OFS = 14,
-    MZ_ZIP_CDH_CRC32_OFS = 16,
-    MZ_ZIP_CDH_COMPRESSED_SIZE_OFS = 20,
-    MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS = 24,
-    MZ_ZIP_CDH_FILENAME_LEN_OFS = 28,
-    MZ_ZIP_CDH_EXTRA_LEN_OFS = 30,
-    MZ_ZIP_CDH_COMMENT_LEN_OFS = 32,
-    MZ_ZIP_CDH_DISK_START_OFS = 34,
-    MZ_ZIP_CDH_INTERNAL_ATTR_OFS = 36,
-    MZ_ZIP_CDH_EXTERNAL_ATTR_OFS = 38,
-    MZ_ZIP_CDH_LOCAL_HEADER_OFS = 42,
-
-    /* Local directory header offsets */
-    MZ_ZIP_LDH_SIG_OFS = 0,
-    MZ_ZIP_LDH_VERSION_NEEDED_OFS = 4,
-    MZ_ZIP_LDH_BIT_FLAG_OFS = 6,
-    MZ_ZIP_LDH_METHOD_OFS = 8,
-    MZ_ZIP_LDH_FILE_TIME_OFS = 10,
-    MZ_ZIP_LDH_FILE_DATE_OFS = 12,
-    MZ_ZIP_LDH_CRC32_OFS = 14,
-    MZ_ZIP_LDH_COMPRESSED_SIZE_OFS = 18,
-    MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS = 22,
-    MZ_ZIP_LDH_FILENAME_LEN_OFS = 26,
-    MZ_ZIP_LDH_EXTRA_LEN_OFS = 28,
-    MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR = 1 << 3,
-
-    /* End of central directory offsets */
-    MZ_ZIP_ECDH_SIG_OFS = 0,
-    MZ_ZIP_ECDH_NUM_THIS_DISK_OFS = 4,
-    MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS = 6,
-    MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 8,
-    MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS = 10,
-    MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12,
-    MZ_ZIP_ECDH_CDIR_OFS_OFS = 16,
-    MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20,
-
-    /* ZIP64 End of central directory locator offsets */
-    MZ_ZIP64_ECDL_SIG_OFS = 0,                    /* 4 bytes */
-    MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4,          /* 4 bytes */
-    MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8,  /* 8 bytes */
-    MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */
-
-    /* ZIP64 End of central directory header offsets */
-    MZ_ZIP64_ECDH_SIG_OFS = 0,                       /* 4 bytes */
-    MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4,            /* 8 bytes */
-    MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12,          /* 2 bytes */
-    MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14,           /* 2 bytes */
-    MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16,            /* 4 bytes */
-    MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20,            /* 4 bytes */
-    MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */
-    MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32,       /* 8 bytes */
-    MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40,                /* 8 bytes */
-    MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48,                 /* 8 bytes */
-    MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0,
-    MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192,
-    MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11
-};
-
-typedef struct
-{
-    void *m_p;
-    size_t m_size, m_capacity;
-    mz_uint m_element_size;
-} mz_zip_array;
-
-struct mz_zip_internal_state_tag
-{
-    mz_zip_array m_central_dir;
-    mz_zip_array m_central_dir_offsets;
-    mz_zip_array m_sorted_central_dir_offsets;
-
-    /* The flags passed in when the archive is initially opened. */
-    uint32_t m_init_flags;
-
-    /* MZ_TRUE if the archive has a zip64 end of central directory headers, etc. */
-    mz_bool m_zip64;
-
-    /* MZ_TRUE if we found zip64 extended info in the central directory (m_zip64 will also be slammed to true too, even if we didn't find a zip64 end of central dir header, etc.) */
-    mz_bool m_zip64_has_extended_info_fields;
-
-    /* These fields are used by the file, FILE, memory, and memory/heap read/write helpers. */
-    MZ_FILE *m_pFile;
-    mz_uint64 m_file_archive_start_ofs;
-
-    void *m_pMem;
-    size_t m_mem_size;
-    size_t m_mem_capacity;
-};
-
-#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size) (array_ptr)->m_element_size = element_size
-
-#if defined(DEBUG) || defined(_DEBUG) || defined(NDEBUG)
-static MZ_FORCEINLINE mz_uint mz_zip_array_range_check(const mz_zip_array *pArray, mz_uint index)
-{
-    MZ_ASSERT(index < pArray->m_size);
-    return index;
-}
-#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[mz_zip_array_range_check(array_ptr, index)]
-#else
-#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[index]
-#endif
-
-static MZ_FORCEINLINE void mz_zip_array_init(mz_zip_array *pArray, mz_uint32 element_size)
-{
-    memset(pArray, 0, sizeof(mz_zip_array));
-    pArray->m_element_size = element_size;
-}
-
-static MZ_FORCEINLINE void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray)
-{
-    pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p);
-    memset(pArray, 0, sizeof(mz_zip_array));
-}
-
-static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)
-{
-    void *pNew_p;
-    size_t new_capacity = min_new_capacity;
-    MZ_ASSERT(pArray->m_element_size);
-    if (pArray->m_capacity >= min_new_capacity)
-        return MZ_TRUE;
-    if (growing)
-    {
-        new_capacity = MZ_MAX(1, pArray->m_capacity);
-        while (new_capacity < min_new_capacity)
-            new_capacity *= 2;
-    }
-    if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, pArray->m_element_size, new_capacity)))
-        return MZ_FALSE;
-    pArray->m_p = pNew_p;
-    pArray->m_capacity = new_capacity;
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing)
-{
-    if (new_capacity > pArray->m_capacity)
-    {
-        if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing))
-            return MZ_FALSE;
-    }
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)
-{
-    if (new_size > pArray->m_capacity)
-    {
-        if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing))
-            return MZ_FALSE;
-    }
-    pArray->m_size = new_size;
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)
-{
-    return mz_zip_array_reserve(pZip, pArray, pArray->m_size + n, MZ_TRUE);
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)
-{
-    size_t orig_size = pArray->m_size;
-    if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE))
-        return MZ_FALSE;
-    memcpy((mz_uint8 *)pArray->m_p + orig_size * pArray->m_element_size, pElements, n * pArray->m_element_size);
-    return MZ_TRUE;
-}
-
-#ifndef MINIZ_NO_TIME
-static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date)
-{
-    struct tm tm;
-    memset(&tm, 0, sizeof(tm));
-    tm.tm_isdst = -1;
-    tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900;
-    tm.tm_mon = ((dos_date >> 5) & 15) - 1;
-    tm.tm_mday = dos_date & 31;
-    tm.tm_hour = (dos_time >> 11) & 31;
-    tm.tm_min = (dos_time >> 5) & 63;
-    tm.tm_sec = (dos_time << 1) & 62;
-    return mktime(&tm);
-}
-
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-static void mz_zip_time_t_to_dos_time(MZ_TIME_T time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
-{
-#ifdef _MSC_VER
-    struct tm tm_struct;
-    struct tm *tm = &tm_struct;
-    errno_t err = localtime_s(tm, &time);
-    if (err)
-    {
-        *pDOS_date = 0;
-        *pDOS_time = 0;
-        return;
-    }
-#else
-    struct tm *tm = localtime(&time);
-#endif /* #ifdef _MSC_VER */
-
-    *pDOS_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1));
-    *pDOS_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday);
-}
-#endif /* MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-#ifndef MINIZ_NO_STDIO
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-static mz_bool mz_zip_get_file_modified_time(const char *pFilename, MZ_TIME_T *pTime)
-{
-    struct MZ_FILE_STAT_STRUCT file_stat;
-
-    /* On Linux with x86 glibc, this call will fail on large files (I think >= 0x80000000 bytes) unless you compiled with _LARGEFILE64_SOURCE. Argh. */
-    if (MZ_FILE_STAT(pFilename, &file_stat) != 0)
-        return MZ_FALSE;
-
-    *pTime = file_stat.st_mtime;
-
-    return MZ_TRUE;
-}
-#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS*/
-
-static mz_bool mz_zip_set_file_times(const char *pFilename, MZ_TIME_T access_time, MZ_TIME_T modified_time)
-{
-    struct utimbuf t;
-
-    memset(&t, 0, sizeof(t));
-    t.actime = access_time;
-    t.modtime = modified_time;
-
-    return !utime(pFilename, &t);
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-#endif /* #ifndef MINIZ_NO_TIME */
-
-static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip, mz_zip_error err_num)
-{
-    if (pZip)
-        pZip->m_last_error = err_num;
-    return MZ_FALSE;
-}
-
-static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags)
-{
-    (void)flags;
-    if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!pZip->m_pAlloc)
-        pZip->m_pAlloc = miniz_def_alloc_func;
-    if (!pZip->m_pFree)
-        pZip->m_pFree = miniz_def_free_func;
-    if (!pZip->m_pRealloc)
-        pZip->m_pRealloc = miniz_def_realloc_func;
-
-    pZip->m_archive_size = 0;
-    pZip->m_central_directory_file_ofs = 0;
-    pZip->m_total_files = 0;
-    pZip->m_last_error = MZ_ZIP_NO_ERROR;
-
-    if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
-    pZip->m_pState->m_init_flags = flags;
-    pZip->m_pState->m_zip64 = MZ_FALSE;
-    pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE;
-
-    pZip->m_zip_mode = MZ_ZIP_MODE_READING;
-
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_reader_filename_less(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, mz_uint r_index)
-{
-    const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;
-    const mz_uint8 *pR = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, r_index));
-    mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS), r_len = MZ_READ_LE16(pR + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    mz_uint8 l = 0, r = 0;
-    pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
-    pR += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
-    pE = pL + MZ_MIN(l_len, r_len);
-    while (pL < pE)
-    {
-        if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
-            break;
-        pL++;
-        pR++;
-    }
-    return (pL == pE) ? (l_len < r_len) : (l < r);
-}
-
-#define MZ_SWAP_UINT32(a, b) \
-    do                       \
-    {                        \
-        mz_uint32 t = a;     \
-        a = b;               \
-        b = t;               \
-    }                        \
-    MZ_MACRO_END
-
-/* Heap sort of lowercased filenames, used to help accelerate plain central directory searches by mz_zip_reader_locate_file(). (Could also use qsort(), but it could allocate memory.) */
-static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip)
-{
-    mz_zip_internal_state *pState = pZip->m_pState;
-    const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
-    const mz_zip_array *pCentral_dir = &pState->m_central_dir;
-    mz_uint32 *pIndices;
-    mz_uint32 start, end;
-    const mz_uint32 size = pZip->m_total_files;
-
-    if (size <= 1U)
-        return;
-
-    pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);
-
-    start = (size - 2U) >> 1U;
-    for (;;)
-    {
-        mz_uint64 child, root = start;
-        for (;;)
-        {
-            if ((child = (root << 1U) + 1U) >= size)
-                break;
-            child += (((child + 1U) < size) && (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U])));
-            if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))
-                break;
-            MZ_SWAP_UINT32(pIndices[root], pIndices[child]);
-            root = child;
-        }
-        if (!start)
-            break;
-        start--;
-    }
-
-    end = size - 1;
-    while (end > 0)
-    {
-        mz_uint64 child, root = 0;
-        MZ_SWAP_UINT32(pIndices[end], pIndices[0]);
-        for (;;)
-        {
-            if ((child = (root << 1U) + 1U) >= end)
-                break;
-            child += (((child + 1U) < end) && mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]));
-            if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))
-                break;
-            MZ_SWAP_UINT32(pIndices[root], pIndices[child]);
-            root = child;
-        }
-        end--;
-    }
-}
-
-static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, mz_uint32 record_sig, mz_uint32 record_size, mz_int64 *pOfs)
-{
-    mz_int64 cur_file_ofs;
-    mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
-    mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
-
-    /* Basic sanity checks - reject files which are too small */
-    if (pZip->m_archive_size < record_size)
-        return MZ_FALSE;
-
-    /* Find the record by scanning the file from the end towards the beginning. */
-    cur_file_ofs = MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0);
-    for (;;)
-    {
-        int i, n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs);
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n)
-            return MZ_FALSE;
-
-        for (i = n - 4; i >= 0; --i)
-        {
-            mz_uint s = MZ_READ_LE32(pBuf + i);
-            if (s == record_sig)
-            {
-                if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size)
-                    break;
-            }
-        }
-
-        if (i >= 0)
-        {
-            cur_file_ofs += i;
-            break;
-        }
-
-        /* Give up if we've searched the entire file, or we've gone back "too far" (~64kb) */
-        if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= (MZ_UINT16_MAX + record_size)))
-            return MZ_FALSE;
-
-        cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0);
-    }
-
-    *pOfs = cur_file_ofs;
-    return MZ_TRUE;
-}
-
-static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flags)
-{
-    mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, cdir_disk_index = 0;
-    mz_uint64 cdir_ofs = 0;
-    mz_int64 cur_file_ofs = 0;
-    const mz_uint8 *p;
-
-    mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
-    mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
-    mz_bool sort_central_dir = ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
-    mz_uint32 zip64_end_of_central_dir_locator_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32;
-
-    mz_uint32 zip64_end_of_central_dir_header_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pZip64_end_of_central_dir = (mz_uint8 *)zip64_end_of_central_dir_header_u32;
-
-    mz_uint64 zip64_end_of_central_dir_ofs = 0;
-
-    /* Basic sanity checks - reject files which are too small, and check the first 4 bytes of the file to make sure a local header is there. */
-    if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-    if (!mz_zip_reader_locate_header_sig(pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs))
-        return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR);
-
-    /* Read and verify the end of central directory record. */
-    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-    if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
-    {
-        if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, pZip64_locator, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
-        {
-            if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG)
-            {
-                zip64_end_of_central_dir_ofs = MZ_READ_LE64(pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS);
-                if (zip64_end_of_central_dir_ofs > (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
-                    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-                if (pZip->m_pRead(pZip->m_pIO_opaque, zip64_end_of_central_dir_ofs, pZip64_end_of_central_dir, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
-                {
-                    if (MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG)
-                    {
-                        pZip->m_pState->m_zip64 = MZ_TRUE;
-                    }
-                }
-            }
-        }
-    }
-
-    pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS);
-    cdir_entries_on_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
-    num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS);
-    cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS);
-    cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS);
-    cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
-
-    if (pZip->m_pState->m_zip64)
-    {
-        mz_uint32 zip64_total_num_of_disks = MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS);
-        mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS);
-        mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
-        mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS);
-        mz_uint64 zip64_size_of_central_directory = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS);
-
-        if (zip64_size_of_end_of_central_dir_record < (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12))
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-        if (zip64_total_num_of_disks != 1U)
-            return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-        /* Check for miniz's practical limits */
-        if (zip64_cdir_total_entries > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
-        pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries;
-
-        if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
-        cdir_entries_on_this_disk = (mz_uint32)zip64_cdir_total_entries_on_this_disk;
-
-        /* Check for miniz's current practical limits (sorry, this should be enough for millions of files) */
-        if (zip64_size_of_central_directory > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-        cdir_size = (mz_uint32)zip64_size_of_central_directory;
-
-        num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS);
-
-        cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS);
-
-        cdir_ofs = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS);
-    }
-
-    if (pZip->m_total_files != cdir_entries_on_this_disk)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-    if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1)))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-    if (cdir_size < pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    pZip->m_central_directory_file_ofs = cdir_ofs;
-
-    if (pZip->m_total_files)
-    {
-        mz_uint i, n;
-        /* Read the entire central directory into a heap block, and allocate another heap block to hold the unsorted central dir file record offsets, and possibly another to hold the sorted indices. */
-        if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, MZ_FALSE)) ||
-            (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, pZip->m_total_files, MZ_FALSE)))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-        if (sort_central_dir)
-        {
-            if (!mz_zip_array_resize(pZip, &pZip->m_pState->m_sorted_central_dir_offsets, pZip->m_total_files, MZ_FALSE))
-                return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, pZip->m_pState->m_central_dir.m_p, cdir_size) != cdir_size)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-        /* Now create an index into the central directory file records, do some basic sanity checking on each record */
-        p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p;
-        for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i)
-        {
-            mz_uint total_header_size, disk_index, bit_flags, filename_size, ext_data_size;
-            mz_uint64 comp_size, decomp_size, local_header_ofs;
-
-            if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG))
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, i) = (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p);
-
-            if (sort_central_dir)
-                MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, mz_uint32, i) = i;
-
-            comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
-            decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
-            local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
-            filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-            ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
-
-            if ((!pZip->m_pState->m_zip64_has_extended_info_fields) &&
-                (ext_data_size) &&
-                (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == MZ_UINT32_MAX))
-            {
-                /* Attempt to find zip64 extended information field in the entry's extra data */
-                mz_uint32 extra_size_remaining = ext_data_size;
-
-                if (extra_size_remaining)
-                {
-                    const mz_uint8 *pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
-
-                    do
-                    {
-                        mz_uint32 field_id;
-                        mz_uint32 field_data_size;
-
-                        if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        field_id = MZ_READ_LE16(pExtra_data);
-                        field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-
-                        if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-                        {
-                            /* Ok, the archive didn't have any zip64 headers but it uses a zip64 extended information field so mark it as zip64 anyway (this can occur with infozip's zip util when it reads compresses files from stdin). */
-                            pZip->m_pState->m_zip64 = MZ_TRUE;
-                            pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE;
-                            break;
-                        }
-
-                        pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
-                        extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
-                    } while (extra_size_remaining);
-                }
-            }
-
-            /* I've seen archives that aren't marked as zip64 that uses zip64 ext data, argh */
-            if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX))
-            {
-                if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size))
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS);
-            if ((disk_index == MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1)))
-                return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-            if (comp_size != MZ_UINT32_MAX)
-            {
-                if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-            if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED)
-                return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
-            if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > n)
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            n -= total_header_size;
-            p += total_header_size;
-        }
-    }
-
-    if (sort_central_dir)
-        mz_zip_reader_sort_central_dir_offsets_by_filename(pZip);
-
-    return MZ_TRUE;
-}
-
-void mz_zip_zero_struct(mz_zip_archive *pZip)
-{
-    if (pZip)
-        MZ_CLEAR_OBJ(*pZip);
-}
-
-static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
-{
-    mz_bool status = MZ_TRUE;
-
-    if (!pZip)
-        return MZ_FALSE;
-
-    if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
-    {
-        if (set_last_error)
-            pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER;
-
-        return MZ_FALSE;
-    }
-
-    if (pZip->m_pState)
-    {
-        mz_zip_internal_state *pState = pZip->m_pState;
-        pZip->m_pState = NULL;
-
-        mz_zip_array_clear(pZip, &pState->m_central_dir);
-        mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
-        mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
-
-#ifndef MINIZ_NO_STDIO
-        if (pState->m_pFile)
-        {
-            if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
-            {
-                if (MZ_FCLOSE(pState->m_pFile) == EOF)
-                {
-                    if (set_last_error)
-                        pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED;
-                    status = MZ_FALSE;
-                }
-            }
-            pState->m_pFile = NULL;
-        }
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-    }
-    pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
-
-    return status;
-}
-
-mz_bool mz_zip_reader_end(mz_zip_archive *pZip)
-{
-    return mz_zip_reader_end_internal(pZip, MZ_TRUE);
-}
-mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags)
-{
-    if ((!pZip) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_reader_init_internal(pZip, flags))
-        return MZ_FALSE;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_USER;
-    pZip->m_archive_size = size;
-
-    if (!mz_zip_reader_read_central_dir(pZip, flags))
-    {
-        mz_zip_reader_end_internal(pZip, MZ_FALSE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
-{
-    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
-    size_t s = (file_ofs >= pZip->m_archive_size) ? 0 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
-    memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
-    return s;
-}
-
-mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags)
-{
-    if (!pMem)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-    if (!mz_zip_reader_init_internal(pZip, flags))
-        return MZ_FALSE;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY;
-    pZip->m_archive_size = size;
-    pZip->m_pRead = mz_zip_mem_read_func;
-    pZip->m_pIO_opaque = pZip;
-    pZip->m_pNeeds_keepalive = NULL;
-
-#ifdef __cplusplus
-    pZip->m_pState->m_pMem = const_cast<void *>(pMem);
-#else
-    pZip->m_pState->m_pMem = (void *)pMem;
-#endif
-
-    pZip->m_pState->m_mem_size = size;
-
-    if (!mz_zip_reader_read_central_dir(pZip, flags))
-    {
-        mz_zip_reader_end_internal(pZip, MZ_FALSE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-#ifndef MINIZ_NO_STDIO
-static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
-{
-    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
-    mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
-
-    file_ofs += pZip->m_pState->m_file_archive_start_ofs;
-
-    if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
-        return 0;
-
-    return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile);
-}
-
-mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags)
-{
-    return mz_zip_reader_init_file_v2(pZip, pFilename, flags, 0, 0);
-}
-
-mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size)
-{
-    mz_uint64 file_size;
-    MZ_FILE *pFile;
-
-    if ((!pZip) || (!pFilename) || ((archive_size) && (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pFile = MZ_FOPEN(pFilename, "rb");
-    if (!pFile)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
-    file_size = archive_size;
-    if (!file_size)
-    {
-        if (MZ_FSEEK64(pFile, 0, SEEK_END))
-        {
-            MZ_FCLOSE(pFile);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
-        }
-
-        file_size = MZ_FTELL64(pFile);
-    }
-
-    /* TODO: Better sanity check archive_size and the # of actual remaining bytes */
-
-    if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-    {
-	MZ_FCLOSE(pFile);
-        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-    }
-
-    if (!mz_zip_reader_init_internal(pZip, flags))
-    {
-        MZ_FCLOSE(pFile);
-        return MZ_FALSE;
-    }
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
-    pZip->m_pRead = mz_zip_file_read_func;
-    pZip->m_pIO_opaque = pZip;
-    pZip->m_pState->m_pFile = pFile;
-    pZip->m_archive_size = file_size;
-    pZip->m_pState->m_file_archive_start_ofs = file_start_ofs;
-
-    if (!mz_zip_reader_read_central_dir(pZip, flags))
-    {
-        mz_zip_reader_end_internal(pZip, MZ_FALSE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags)
-{
-    mz_uint64 cur_file_ofs;
-
-    if ((!pZip) || (!pFile))
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
-    cur_file_ofs = MZ_FTELL64(pFile);
-
-    if (!archive_size)
-    {
-        if (MZ_FSEEK64(pFile, 0, SEEK_END))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
-
-        archive_size = MZ_FTELL64(pFile) - cur_file_ofs;
-
-        if (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-            return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-    }
-
-    if (!mz_zip_reader_init_internal(pZip, flags))
-        return MZ_FALSE;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
-    pZip->m_pRead = mz_zip_file_read_func;
-
-    pZip->m_pIO_opaque = pZip;
-    pZip->m_pState->m_pFile = pFile;
-    pZip->m_archive_size = archive_size;
-    pZip->m_pState->m_file_archive_start_ofs = cur_file_ofs;
-
-    if (!mz_zip_reader_read_central_dir(pZip, flags))
-    {
-        mz_zip_reader_end_internal(pZip, MZ_FALSE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-static MZ_FORCEINLINE const mz_uint8 *mz_zip_get_cdh(mz_zip_archive *pZip, mz_uint file_index)
-{
-    if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files))
-        return NULL;
-    return &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
-}
-
-mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index)
-{
-    mz_uint m_bit_flag;
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    if (!p)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return MZ_FALSE;
-    }
-
-    m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-    return (m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0;
-}
-
-mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index)
-{
-    mz_uint bit_flag;
-    mz_uint method;
-
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    if (!p)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return MZ_FALSE;
-    }
-
-    method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
-    bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-
-    if ((method != 0) && (method != MZ_DEFLATED))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-        return MZ_FALSE;
-    }
-
-    if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-        return MZ_FALSE;
-    }
-
-    if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
-        return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index)
-{
-    mz_uint filename_len, attribute_mapping_id, external_attr;
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    if (!p)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return MZ_FALSE;
-    }
-
-    filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    if (filename_len)
-    {
-        if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/')
-            return MZ_TRUE;
-    }
-
-    /* Bugfix: This code was also checking if the internal attribute was non-zero, which wasn't correct. */
-    /* Most/all zip writers (hopefully) set DOS file/directory attributes in the low 16-bits, so check for the DOS directory flag and ignore the source OS ID in the created by field. */
-    /* FIXME: Remove this check? Is it necessary - we already check the filename. */
-    attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8;
-    (void)attribute_mapping_id;
-
-    external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
-    if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0)
-    {
-        return MZ_TRUE;
-    }
-
-    return MZ_FALSE;
-}
-
-static mz_bool mz_zip_file_stat_internal(mz_zip_archive *pZip, mz_uint file_index, const mz_uint8 *pCentral_dir_header, mz_zip_archive_file_stat *pStat, mz_bool *pFound_zip64_extra_data)
-{
-    mz_uint n;
-    const mz_uint8 *p = pCentral_dir_header;
-
-    if (pFound_zip64_extra_data)
-        *pFound_zip64_extra_data = MZ_FALSE;
-
-    if ((!p) || (!pStat))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    /* Extract fields from the central directory record. */
-    pStat->m_file_index = file_index;
-    pStat->m_central_dir_ofs = MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index);
-    pStat->m_version_made_by = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS);
-    pStat->m_version_needed = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_NEEDED_OFS);
-    pStat->m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-    pStat->m_method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
-#ifndef MINIZ_NO_TIME
-    pStat->m_time = mz_zip_dos_to_time_t(MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_TIME_OFS), MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_DATE_OFS));
-#endif
-    pStat->m_crc32 = MZ_READ_LE32(p + MZ_ZIP_CDH_CRC32_OFS);
-    pStat->m_comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
-    pStat->m_uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
-    pStat->m_internal_attr = MZ_READ_LE16(p + MZ_ZIP_CDH_INTERNAL_ATTR_OFS);
-    pStat->m_external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
-    pStat->m_local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
-
-    /* Copy as much of the filename and comment as possible. */
-    n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1);
-    memcpy(pStat->m_filename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
-    pStat->m_filename[n] = '\0';
-
-    n = MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS);
-    n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE - 1);
-    pStat->m_comment_size = n;
-    memcpy(pStat->m_comment, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS), n);
-    pStat->m_comment[n] = '\0';
-
-    /* Set some flags for convienance */
-    pStat->m_is_directory = mz_zip_reader_is_file_a_directory(pZip, file_index);
-    pStat->m_is_encrypted = mz_zip_reader_is_file_encrypted(pZip, file_index);
-    pStat->m_is_supported = mz_zip_reader_is_file_supported(pZip, file_index);
-
-    /* See if we need to read any zip64 extended information fields. */
-    /* Confusingly, these zip64 fields can be present even on non-zip64 archives (Debian zip on a huge files from stdin piped to stdout creates them). */
-    if (MZ_MAX(MZ_MAX(pStat->m_comp_size, pStat->m_uncomp_size), pStat->m_local_header_ofs) == MZ_UINT32_MAX)
-    {
-        /* Attempt to find zip64 extended information field in the entry's extra data */
-        mz_uint32 extra_size_remaining = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
-
-        if (extra_size_remaining)
-        {
-            const mz_uint8 *pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-
-            do
-            {
-                mz_uint32 field_id;
-                mz_uint32 field_data_size;
-
-                if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                field_id = MZ_READ_LE16(pExtra_data);
-                field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-
-                if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-                {
-                    const mz_uint8 *pField_data = pExtra_data + sizeof(mz_uint16) * 2;
-                    mz_uint32 field_data_remaining = field_data_size;
-
-                    if (pFound_zip64_extra_data)
-                        *pFound_zip64_extra_data = MZ_TRUE;
-
-                    if (pStat->m_uncomp_size == MZ_UINT32_MAX)
-                    {
-                        if (field_data_remaining < sizeof(mz_uint64))
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        pStat->m_uncomp_size = MZ_READ_LE64(pField_data);
-                        pField_data += sizeof(mz_uint64);
-                        field_data_remaining -= sizeof(mz_uint64);
-                    }
-
-                    if (pStat->m_comp_size == MZ_UINT32_MAX)
-                    {
-                        if (field_data_remaining < sizeof(mz_uint64))
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        pStat->m_comp_size = MZ_READ_LE64(pField_data);
-                        pField_data += sizeof(mz_uint64);
-                        field_data_remaining -= sizeof(mz_uint64);
-                    }
-
-                    if (pStat->m_local_header_ofs == MZ_UINT32_MAX)
-                    {
-                        if (field_data_remaining < sizeof(mz_uint64))
-                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-                        pStat->m_local_header_ofs = MZ_READ_LE64(pField_data);
-                        pField_data += sizeof(mz_uint64);
-                        field_data_remaining -= sizeof(mz_uint64);
-                    }
-
-                    break;
-                }
-
-                pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
-                extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
-            } while (extra_size_remaining);
-        }
-    }
-
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE mz_bool mz_zip_string_equal(const char *pA, const char *pB, mz_uint len, mz_uint flags)
-{
-    mz_uint i;
-    if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE)
-        return 0 == memcmp(pA, pB, len);
-    for (i = 0; i < len; ++i)
-        if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i]))
-            return MZ_FALSE;
-    return MZ_TRUE;
-}
-
-static MZ_FORCEINLINE int mz_zip_filename_compare(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, const char *pR, mz_uint r_len)
-{
-    const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;
-    mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    mz_uint8 l = 0, r = 0;
-    pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
-    pE = pL + MZ_MIN(l_len, r_len);
-    while (pL < pE)
-    {
-        if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
-            break;
-        pL++;
-        pR++;
-    }
-    return (pL == pE) ? (int)(l_len - r_len) : (l - r);
-}
-
-static mz_bool mz_zip_locate_file_binary_search(mz_zip_archive *pZip, const char *pFilename, mz_uint32 *pIndex)
-{
-    mz_zip_internal_state *pState = pZip->m_pState;
-    const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
-    const mz_zip_array *pCentral_dir = &pState->m_central_dir;
-    mz_uint32 *pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);
-    const uint32_t size = pZip->m_total_files;
-    const mz_uint filename_len = (mz_uint)strlen(pFilename);
-
-    if (pIndex)
-        *pIndex = 0;
-
-    if (size)
-    {
-        /* yes I could use uint32_t's, but then we would have to add some special case checks in the loop, argh, and */
-        /* honestly the major expense here on 32-bit CPU's will still be the filename compare */
-        mz_int64 l = 0, h = (mz_int64)size - 1;
-
-        while (l <= h)
-        {
-            mz_int64 m = l + ((h - l) >> 1);
-            uint32_t file_index = pIndices[(uint32_t)m];
-
-            int comp = mz_zip_filename_compare(pCentral_dir, pCentral_dir_offsets, file_index, pFilename, filename_len);
-            if (!comp)
-            {
-                if (pIndex)
-                    *pIndex = file_index;
-                return MZ_TRUE;
-            }
-            else if (comp < 0)
-                l = m + 1;
-            else
-                h = m - 1;
-        }
-    }
-
-    return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND);
-}
-
-int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags)
-{
-    mz_uint32 index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index))
-        return -1;
-    else
-        return (int)index;
-}
-
-mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *pIndex)
-{
-    mz_uint file_index;
-    size_t name_len, comment_len;
-
-    if (pIndex)
-        *pIndex = 0;
-
-    if ((!pZip) || (!pZip->m_pState) || (!pName))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    /* See if we can use a binary search */
-    if (((pZip->m_pState->m_init_flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) &&
-        (pZip->m_zip_mode == MZ_ZIP_MODE_READING) &&
-        ((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size))
-    {
-        return mz_zip_locate_file_binary_search(pZip, pName, pIndex);
-    }
-
-    /* Locate the entry by scanning the entire central directory */
-    name_len = strlen(pName);
-    if (name_len > MZ_UINT16_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    comment_len = pComment ? strlen(pComment) : 0;
-    if (comment_len > MZ_UINT16_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    for (file_index = 0; file_index < pZip->m_total_files; file_index++)
-    {
-        const mz_uint8 *pHeader = &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
-        mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-        const char *pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
-        if (filename_len < name_len)
-            continue;
-        if (comment_len)
-        {
-            mz_uint file_extra_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_EXTRA_LEN_OFS), file_comment_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_COMMENT_LEN_OFS);
-            const char *pFile_comment = pFilename + filename_len + file_extra_len;
-            if ((file_comment_len != comment_len) || (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags)))
-                continue;
-        }
-        if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len))
-        {
-            int ofs = filename_len - 1;
-            do
-            {
-                if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':'))
-                    break;
-            } while (--ofs >= 0);
-            ofs++;
-            pFilename += ofs;
-            filename_len -= ofs;
-        }
-        if ((filename_len == name_len) && (mz_zip_string_equal(pName, pFilename, filename_len, flags)))
-        {
-            if (pIndex)
-                *pIndex = file_index;
-            return MZ_TRUE;
-        }
-    }
-
-    return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND);
-}
-
-mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
-{
-    int status = TINFL_STATUS_DONE;
-    mz_uint64 needed_size, cur_file_ofs, comp_remaining, out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail;
-    mz_zip_archive_file_stat file_stat;
-    void *pRead_buf;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-    tinfl_decompressor inflator;
-
-    if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
-        return MZ_FALSE;
-
-    /* A directory or zero length file */
-    if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
-        return MZ_TRUE;
-
-    /* Encryption and patch files are not supported. */
-    if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
-    /* This function only supports decompressing stored and deflate. */
-    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-
-    /* Ensure supplied output buffer is large enough. */
-    needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size;
-    if (buf_size < needed_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_BUF_TOO_SMALL);
-
-    /* Read and parse the local directory entry. */
-    cur_file_ofs = file_stat.m_local_header_ofs;
-    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
-    {
-        /* The file is stored or the caller has requested the compressed data. */
-        if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, (size_t)needed_size) != needed_size)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0)
-        {
-            if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
-                return mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
-        }
-#endif
-
-        return MZ_TRUE;
-    }
-
-    /* Decompress the file either directly from memory or from a file input buffer. */
-    tinfl_init(&inflator);
-
-    if (pZip->m_pState->m_pMem)
-    {
-        /* Read directly from the archive in memory. */
-        pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
-        read_buf_size = read_buf_avail = file_stat.m_comp_size;
-        comp_remaining = 0;
-    }
-    else if (pUser_read_buf)
-    {
-        /* Use a user provided read buffer. */
-        if (!user_read_buf_size)
-            return MZ_FALSE;
-        pRead_buf = (mz_uint8 *)pUser_read_buf;
-        read_buf_size = user_read_buf_size;
-        read_buf_avail = 0;
-        comp_remaining = file_stat.m_comp_size;
-    }
-    else
-    {
-        /* Temporarily allocate a read buffer. */
-        read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
-        if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-        read_buf_avail = 0;
-        comp_remaining = file_stat.m_comp_size;
-    }
-
-    do
-    {
-        /* The size_t cast here should be OK because we've verified that the output buffer is >= file_stat.m_uncomp_size above */
-        size_t in_buf_size, out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs);
-        if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
-        {
-            read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
-            if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
-            {
-                status = TINFL_STATUS_FAILED;
-                mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-                break;
-            }
-            cur_file_ofs += read_buf_avail;
-            comp_remaining -= read_buf_avail;
-            read_buf_ofs = 0;
-        }
-        in_buf_size = (size_t)read_buf_avail;
-        status = tinfl_decompress(&inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0));
-        read_buf_avail -= in_buf_size;
-        read_buf_ofs += in_buf_size;
-        out_buf_ofs += out_buf_size;
-    } while (status == TINFL_STATUS_NEEDS_MORE_INPUT);
-
-    if (status == TINFL_STATUS_DONE)
-    {
-        /* Make sure the entire file was decompressed, and check its CRC. */
-        if (out_buf_ofs != file_stat.m_uncomp_size)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
-            status = TINFL_STATUS_FAILED;
-        }
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
-            status = TINFL_STATUS_FAILED;
-        }
-#endif
-    }
-
-    if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf))
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-
-    return status == TINFL_STATUS_DONE;
-}
-
-mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
-        return MZ_FALSE;
-    return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size);
-}
-
-mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags)
-{
-    return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, flags, NULL, 0);
-}
-
-mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags)
-{
-    return mz_zip_reader_extract_file_to_mem_no_alloc(pZip, pFilename, pBuf, buf_size, flags, NULL, 0);
-}
-
-void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
-{
-    mz_uint64 comp_size, uncomp_size, alloc_size;
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    void *pBuf;
-
-    if (pSize)
-        *pSize = 0;
-
-    if (!p)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return NULL;
-    }
-
-    comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
-    uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
-
-    alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? comp_size : uncomp_size;
-    if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-        return NULL;
-    }
-
-    if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        return NULL;
-    }
-
-    if (!mz_zip_reader_extract_to_mem(pZip, file_index, pBuf, (size_t)alloc_size, flags))
-    {
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-        return NULL;
-    }
-
-    if (pSize)
-        *pSize = (size_t)alloc_size;
-    return pBuf;
-}
-
-void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
-    {
-        if (pSize)
-            *pSize = 0;
-        return MZ_FALSE;
-    }
-    return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
-}
-
-mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
-{
-    int status = TINFL_STATUS_DONE;
-    mz_uint file_crc32 = MZ_CRC32_INIT;
-    mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs;
-    mz_zip_archive_file_stat file_stat;
-    void *pRead_buf = NULL;
-    void *pWrite_buf = NULL;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-
-    if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
-        return MZ_FALSE;
-
-    /* A directory or zero length file */
-    if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
-        return MZ_TRUE;
-
-    /* Encryption and patch files are not supported. */
-    if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
-    /* This function only supports decompressing stored and deflate. */
-    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-
-    /* Read and do some minimal validation of the local directory entry (this doesn't crack the zip64 stuff, which we already have from the central dir) */
-    cur_file_ofs = file_stat.m_local_header_ofs;
-    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    /* Decompress the file either directly from memory or from a file input buffer. */
-    if (pZip->m_pState->m_pMem)
-    {
-        pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
-        read_buf_size = read_buf_avail = file_stat.m_comp_size;
-        comp_remaining = 0;
-    }
-    else
-    {
-        read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
-        if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-        read_buf_avail = 0;
-        comp_remaining = file_stat.m_comp_size;
-    }
-
-    if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
-    {
-        /* The file is stored or the caller has requested the compressed data. */
-        if (pZip->m_pState->m_pMem)
-        {
-            if (((sizeof(size_t) == sizeof(mz_uint32))) && (file_stat.m_comp_size > MZ_UINT32_MAX))
-                return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-            if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)file_stat.m_comp_size) != file_stat.m_comp_size)
-            {
-                mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
-                status = TINFL_STATUS_FAILED;
-            }
-            else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-            {
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-                file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)file_stat.m_comp_size);
-#endif
-            }
-
-            cur_file_ofs += file_stat.m_comp_size;
-            out_buf_ofs += file_stat.m_comp_size;
-            comp_remaining = 0;
-        }
-        else
-        {
-            while (comp_remaining)
-            {
-                read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
-                if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-                    status = TINFL_STATUS_FAILED;
-                    break;
-                }
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-                if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-                {
-                    file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail);
-                }
-#endif
-
-                if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
-                    status = TINFL_STATUS_FAILED;
-                    break;
-                }
-
-                cur_file_ofs += read_buf_avail;
-                out_buf_ofs += read_buf_avail;
-                comp_remaining -= read_buf_avail;
-            }
-        }
-    }
-    else
-    {
-        tinfl_decompressor inflator;
-        tinfl_init(&inflator);
-
-        if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            status = TINFL_STATUS_FAILED;
-        }
-        else
-        {
-            do
-            {
-                mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pWrite_buf + (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
-                size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
-                if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
-                {
-                    read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
-                    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
-                    {
-                        mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-                        status = TINFL_STATUS_FAILED;
-                        break;
-                    }
-                    cur_file_ofs += read_buf_avail;
-                    comp_remaining -= read_buf_avail;
-                    read_buf_ofs = 0;
-                }
-
-                in_buf_size = (size_t)read_buf_avail;
-                status = tinfl_decompress(&inflator, (const mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pWrite_buf, pWrite_buf_cur, &out_buf_size, comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
-                read_buf_avail -= in_buf_size;
-                read_buf_ofs += in_buf_size;
-
-                if (out_buf_size)
-                {
-                    if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size)
-                    {
-                        mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
-                        status = TINFL_STATUS_FAILED;
-                        break;
-                    }
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-                    file_crc32 = (mz_uint32)mz_crc32(file_crc32, pWrite_buf_cur, out_buf_size);
-#endif
-                    if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size)
-                    {
-                        mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-                        status = TINFL_STATUS_FAILED;
-                        break;
-                    }
-                }
-            } while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT));
-        }
-    }
-
-    if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
-    {
-        /* Make sure the entire file was decompressed, and check its CRC. */
-        if (out_buf_ofs != file_stat.m_uncomp_size)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
-            status = TINFL_STATUS_FAILED;
-        }
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        else if (file_crc32 != file_stat.m_crc32)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-            status = TINFL_STATUS_FAILED;
-        }
-#endif
-    }
-
-    if (!pZip->m_pState->m_pMem)
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-
-    if (pWrite_buf)
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pWrite_buf);
-
-    return status == TINFL_STATUS_DONE;
-}
-
-mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
-        return MZ_FALSE;
-
-    return mz_zip_reader_extract_to_callback(pZip, file_index, pCallback, pOpaque, flags);
-}
-
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
-{
-    mz_zip_reader_extract_iter_state *pState;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-
-    /* Argument sanity check */
-    if ((!pZip) || (!pZip->m_pState))
-        return NULL;
-
-    /* Allocate an iterator status structure */
-    pState = (mz_zip_reader_extract_iter_state*)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_reader_extract_iter_state));
-    if (!pState)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        return NULL;
-    }
-
-    /* Fetch file details */
-    if (!mz_zip_reader_file_stat(pZip, file_index, &pState->file_stat))
-    {
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    /* Encryption and patch files are not supported. */
-    if (pState->file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    /* This function only supports decompressing stored and deflate. */
-    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    /* Init state - save args */
-    pState->pZip = pZip;
-    pState->flags = flags;
-
-    /* Init state - reset variables to defaults */
-    pState->status = TINFL_STATUS_DONE;
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-    pState->file_crc32 = MZ_CRC32_INIT;
-#endif
-    pState->read_buf_ofs = 0;
-    pState->out_buf_ofs = 0;
-    pState->pRead_buf = NULL;
-    pState->pWrite_buf = NULL;
-    pState->out_blk_remain = 0;
-
-    /* Read and parse the local directory entry. */
-    pState->cur_file_ofs = pState->file_stat.m_local_header_ofs;
-    if (pZip->m_pRead(pZip->m_pIO_opaque, pState->cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    pState->cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) > pZip->m_archive_size)
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-        return NULL;
-    }
-
-    /* Decompress the file either directly from memory or from a file input buffer. */
-    if (pZip->m_pState->m_pMem)
-    {
-        pState->pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + pState->cur_file_ofs;
-        pState->read_buf_size = pState->read_buf_avail = pState->file_stat.m_comp_size;
-        pState->comp_remaining = pState->file_stat.m_comp_size;
-    }
-    else
-    {
-        if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
-        {
-            /* Decompression required, therefore intermediate read buffer required */
-            pState->read_buf_size = MZ_MIN(pState->file_stat.m_comp_size, int(MZ_ZIP_MAX_IO_BUF_SIZE));
-            if (NULL == (pState->pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)pState->read_buf_size)))
-            {
-                mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-                return NULL;
-            }
-        }
-        else
-        {
-            /* Decompression not required - we will be reading directly into user buffer, no temp buf required */
-            pState->read_buf_size = 0;
-        }
-        pState->read_buf_avail = 0;
-        pState->comp_remaining = pState->file_stat.m_comp_size;
-    }
-
-    if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
-    {
-        /* Decompression required, init decompressor */
-        tinfl_init( &pState->inflator );
-
-        /* Allocate write buffer */
-        if (NULL == (pState->pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            if (pState->pRead_buf)
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pState->pRead_buf);
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-            return NULL;
-        }
-    }
-
-    return pState;
-}
-
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)
-{
-    mz_uint32 file_index;
-
-    /* Locate file index by name */
-    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
-        return NULL;
-
-    /* Construct iterator */
-    return mz_zip_reader_extract_iter_new(pZip, file_index, flags);
-}
-
-size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size)
-{
-    size_t copied_to_caller = 0;
-
-    /* Argument sanity check */
-    if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf))
-        return 0;
-
-    if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))
-    {
-        /* The file is stored or the caller has requested the compressed data, calc amount to return. */
-        copied_to_caller = MZ_MIN( buf_size, pState->comp_remaining );
-
-        /* Zip is in memory....or requires reading from a file? */
-        if (pState->pZip->m_pState->m_pMem)
-        {
-            /* Copy data to caller's buffer */
-            memcpy( pvBuf, pState->pRead_buf, copied_to_caller );
-            pState->pRead_buf = ((mz_uint8*)pState->pRead_buf) + copied_to_caller;
-        }
-        else
-        {
-            /* Read directly into caller's buffer */
-            if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pvBuf, copied_to_caller) != copied_to_caller)
-            {
-                /* Failed to read all that was asked for, flag failure and alert user */
-                mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED);
-                pState->status = TINFL_STATUS_FAILED;
-                copied_to_caller = 0;
-            }
-        }
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        /* Compute CRC if not returning compressed data only */
-        if (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-            pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, (const mz_uint8 *)pvBuf, copied_to_caller);
-#endif
-
-        /* Advance offsets, dec counters */
-        pState->cur_file_ofs += copied_to_caller;
-        pState->out_buf_ofs += copied_to_caller;
-        pState->comp_remaining -= copied_to_caller;
-    }
-    else
-    {
-        do
-        {
-            /* Calc ptr to write buffer - given current output pos and block size */
-            mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pState->pWrite_buf + (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
-
-            /* Calc max output size - given current output pos and block size */
-            size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
-
-            if (!pState->out_blk_remain)
-            {
-                /* Read more data from file if none available (and reading from file) */
-                if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem))
-                {
-                    /* Calc read size */
-                    pState->read_buf_avail = MZ_MIN(pState->read_buf_size, pState->comp_remaining);
-                    if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pState->pRead_buf, (size_t)pState->read_buf_avail) != pState->read_buf_avail)
-                    {
-                        mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED);
-                        pState->status = TINFL_STATUS_FAILED;
-                        break;
-                    }
-
-                    /* Advance offsets, dec counters */
-                    pState->cur_file_ofs += pState->read_buf_avail;
-                    pState->comp_remaining -= pState->read_buf_avail;
-                    pState->read_buf_ofs = 0;
-                }
-
-                /* Perform decompression */
-                in_buf_size = (size_t)pState->read_buf_avail;
-                pState->status = tinfl_decompress(&pState->inflator, (const mz_uint8 *)pState->pRead_buf + pState->read_buf_ofs, &in_buf_size, (mz_uint8 *)pState->pWrite_buf, pWrite_buf_cur, &out_buf_size, pState->comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
-                pState->read_buf_avail -= in_buf_size;
-                pState->read_buf_ofs += in_buf_size;
-
-                /* Update current output block size remaining */
-                pState->out_blk_remain = out_buf_size;
-            }
-
-            if (pState->out_blk_remain)
-            {
-                /* Calc amount to return. */
-                size_t to_copy = MZ_MIN( (buf_size - copied_to_caller), pState->out_blk_remain );
-
-                /* Copy data to caller's buffer */
-                memcpy( (uint8_t*)pvBuf + copied_to_caller, pWrite_buf_cur, to_copy );
-
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-                /* Perform CRC */
-                pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, pWrite_buf_cur, to_copy);
-#endif
-
-                /* Decrement data consumed from block */
-                pState->out_blk_remain -= to_copy;
-
-                /* Inc output offset, while performing sanity check */
-                if ((pState->out_buf_ofs += to_copy) > pState->file_stat.m_uncomp_size)
-                {
-                    mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-                    pState->status = TINFL_STATUS_FAILED;
-                    break;
-                }
-
-                /* Increment counter of data copied to caller */
-                copied_to_caller += to_copy;
-            }
-        } while ( (copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT)) );
-    }
-
-    /* Return how many bytes were copied into user buffer */
-    return copied_to_caller;
-}
-
-mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState)
-{
-    int status;
-
-    /* Argument sanity check */
-    if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState))
-        return MZ_FALSE;
-
-    /* Was decompression completed and requested? */
-    if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
-    {
-        /* Make sure the entire file was decompressed, and check its CRC. */
-        if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size)
-        {
-            mz_zip_set_error(pState->pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
-            pState->status = TINFL_STATUS_FAILED;
-        }
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-        else if (pState->file_crc32 != pState->file_stat.m_crc32)
-        {
-            mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
-            pState->status = TINFL_STATUS_FAILED;
-        }
-#endif
-    }
-
-    /* Free buffers */
-    if (!pState->pZip->m_pState->m_pMem)
-        pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pRead_buf);
-    if (pState->pWrite_buf)
-        pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pWrite_buf);
-
-    /* Save status */
-    status = pState->status;
-
-    /* Free context */
-    pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState);
-
-    return status == TINFL_STATUS_DONE;
-}
-
-#ifndef MINIZ_NO_STDIO
-static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n)
-{
-    (void)ofs;
-
-    return MZ_FWRITE(pBuf, 1, n, (MZ_FILE *)pOpaque);
-}
-
-mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
-{
-    mz_bool status;
-    mz_zip_archive_file_stat file_stat;
-    MZ_FILE *pFile;
-
-    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
-        return MZ_FALSE;
-
-    if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
-
-    pFile = MZ_FOPEN(pDst_filename, "wb");
-    if (!pFile)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
-    status = mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
-
-    if (MZ_FCLOSE(pFile) == EOF)
-    {
-        if (status)
-            mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
-
-        status = MZ_FALSE;
-    }
-
-#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
-    if (status)
-        mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time);
-#endif
-
-    return status;
-}
-
-mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
-        return MZ_FALSE;
-
-    return mz_zip_reader_extract_to_file(pZip, file_index, pDst_filename, flags);
-}
-
-mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *pFile, mz_uint flags)
-{
-    mz_zip_archive_file_stat file_stat;
-
-    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
-        return MZ_FALSE;
-
-    if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
-
-    return mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
-}
-
-mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags)
-{
-    mz_uint32 file_index;
-    if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
-        return MZ_FALSE;
-
-    return mz_zip_reader_extract_to_cfile(pZip, file_index, pFile, flags);
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-static size_t mz_zip_compute_crc32_callback(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
-{
-    mz_uint32 *p = (mz_uint32 *)pOpaque;
-    (void)file_ofs;
-    *p = (mz_uint32)mz_crc32(*p, (const mz_uint8 *)pBuf, n);
-    return n;
-}
-
-mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
-{
-    mz_zip_archive_file_stat file_stat;
-    mz_zip_internal_state *pState;
-    const mz_uint8 *pCentral_dir_header;
-    mz_bool found_zip64_ext_data_in_cdir = MZ_FALSE;
-    mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-    mz_uint64 local_header_ofs = 0;
-    mz_uint32 local_header_filename_len, local_header_extra_len, local_header_crc32;
-    mz_uint64 local_header_comp_size, local_header_uncomp_size;
-    mz_uint32 uncomp_crc32 = MZ_CRC32_INIT;
-    mz_bool has_data_descriptor;
-    mz_uint32 local_header_bit_flags;
-
-    mz_zip_array file_data_array;
-    mz_zip_array_init(&file_data_array, 1);
-
-    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (file_index > pZip->m_total_files)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    pCentral_dir_header = mz_zip_get_cdh(pZip, file_index);
-
-    if (!mz_zip_file_stat_internal(pZip, file_index, pCentral_dir_header, &file_stat, &found_zip64_ext_data_in_cdir))
-        return MZ_FALSE;
-
-    /* A directory or zero length file */
-    if ((file_stat.m_is_directory) || (!file_stat.m_uncomp_size))
-        return MZ_TRUE;
-
-    /* Encryption and patch files are not supported. */
-    if (file_stat.m_is_encrypted)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
-    /* This function only supports stored and deflate. */
-    if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
-
-    if (!file_stat.m_is_supported)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
-
-    /* Read and parse the local directory entry. */
-    local_header_ofs = file_stat.m_local_header_ofs;
-    if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    local_header_filename_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
-    local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
-    local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
-    local_header_crc32 = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_CRC32_OFS);
-    local_header_bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
-    has_data_descriptor = (local_header_bit_flags & 8) != 0;
-
-    if (local_header_filename_len != strlen(file_stat.m_filename))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if ((local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size) > pZip->m_archive_size)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if (!mz_zip_array_resize(pZip, &file_data_array, MZ_MAX(local_header_filename_len, local_header_extra_len), MZ_FALSE))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    if (local_header_filename_len)
-    {
-        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE, file_data_array.m_p, local_header_filename_len) != local_header_filename_len)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            goto handle_failure;
-        }
-
-        /* I've seen 1 archive that had the same pathname, but used backslashes in the local dir and forward slashes in the central dir. Do we care about this? For now, this case will fail validation. */
-        if (memcmp(file_stat.m_filename, file_data_array.m_p, local_header_filename_len) != 0)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-            goto handle_failure;
-        }
-    }
-
-    if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
-    {
-        mz_uint32 extra_size_remaining = local_header_extra_len;
-        const mz_uint8 *pExtra_data = (const mz_uint8 *)file_data_array.m_p;
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len, file_data_array.m_p, local_header_extra_len) != local_header_extra_len)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            goto handle_failure;
-        }
-
-        do
-        {
-            mz_uint32 field_id, field_data_size, field_total_size;
-
-            if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            field_id = MZ_READ_LE16(pExtra_data);
-            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-            field_total_size = field_data_size + sizeof(mz_uint16) * 2;
-
-            if (field_total_size > extra_size_remaining)
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-            {
-                const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
-
-                if (field_data_size < sizeof(mz_uint64) * 2)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-                    goto handle_failure;
-                }
-
-                local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
-                local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64));
-
-                found_zip64_ext_data_in_ldir = MZ_TRUE;
-                break;
-            }
-
-            pExtra_data += field_total_size;
-            extra_size_remaining -= field_total_size;
-        } while (extra_size_remaining);
-    }
-
-    /* TODO: parse local header extra data when local_header_comp_size is 0xFFFFFFFF! (big_descriptor.zip) */
-    /* I've seen zips in the wild with the data descriptor bit set, but proper local header values and bogus data descriptors */
-    if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32))
-    {
-        mz_uint8 descriptor_buf[32];
-        mz_bool has_id;
-        const mz_uint8 *pSrc;
-        mz_uint32 file_crc32;
-        mz_uint64 comp_size = 0, uncomp_size = 0;
-
-        mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4;
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size, descriptor_buf, sizeof(mz_uint32) * num_descriptor_uint32s) != (sizeof(mz_uint32) * num_descriptor_uint32s))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            goto handle_failure;
-        }
-
-        has_id = (MZ_READ_LE32(descriptor_buf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
-        pSrc = has_id ? (descriptor_buf + sizeof(mz_uint32)) : descriptor_buf;
-
-        file_crc32 = MZ_READ_LE32(pSrc);
-
-        if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir))
-        {
-            comp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32));
-            uncomp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32) + sizeof(mz_uint64));
-        }
-        else
-        {
-            comp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32));
-            uncomp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32) + sizeof(mz_uint32));
-        }
-
-        if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-            goto handle_failure;
-        }
-    }
-    else
-    {
-        if ((local_header_crc32 != file_stat.m_crc32) || (local_header_comp_size != file_stat.m_comp_size) || (local_header_uncomp_size != file_stat.m_uncomp_size))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-            goto handle_failure;
-        }
-    }
-
-    mz_zip_array_clear(pZip, &file_data_array);
-
-    if ((flags & MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY) == 0)
-    {
-        if (!mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_compute_crc32_callback, &uncomp_crc32, 0))
-            return MZ_FALSE;
-
-        /* 1 more check to be sure, although the extract checks too. */
-        if (uncomp_crc32 != file_stat.m_crc32)
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-            return MZ_FALSE;
-        }
-    }
-
-    return MZ_TRUE;
-
-handle_failure:
-    mz_zip_array_clear(pZip, &file_data_array);
-    return MZ_FALSE;
-}
-
-mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags)
-{
-    mz_zip_internal_state *pState;
-    uint32_t i;
-
-    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    /* Basic sanity checks */
-    if (!pState->m_zip64)
-    {
-        if (pZip->m_total_files > MZ_UINT16_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-        if (pZip->m_archive_size > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-    }
-    else
-    {
-        if (pZip->m_total_files >= MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-        if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-    }
-
-    for (i = 0; i < pZip->m_total_files; i++)
-    {
-        if (MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG & flags)
-        {
-            mz_uint32 found_index;
-            mz_zip_archive_file_stat stat;
-
-            if (!mz_zip_reader_file_stat(pZip, i, &stat))
-                return MZ_FALSE;
-
-            if (!mz_zip_reader_locate_file_v2(pZip, stat.m_filename, NULL, 0, &found_index))
-                return MZ_FALSE;
-
-            /* This check can fail if there are duplicate filenames in the archive (which we don't check for when writing - that's up to the user) */
-            if (found_index != i)
-                return mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
-        }
-
-        if (!mz_zip_validate_file(pZip, i, flags))
-            return MZ_FALSE;
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr)
-{
-    mz_bool success = MZ_TRUE;
-    mz_zip_archive zip;
-    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
-
-    if ((!pMem) || (!size))
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_PARAMETER;
-        return MZ_FALSE;
-    }
-
-    mz_zip_zero_struct(&zip);
-
-    if (!mz_zip_reader_init_mem(&zip, pMem, size, flags))
-    {
-        if (pErr)
-            *pErr = zip.m_last_error;
-        return MZ_FALSE;
-    }
-
-    if (!mz_zip_validate_archive(&zip, flags))
-    {
-        actual_err = zip.m_last_error;
-        success = MZ_FALSE;
-    }
-
-    if (!mz_zip_reader_end_internal(&zip, success))
-    {
-        if (!actual_err)
-            actual_err = zip.m_last_error;
-        success = MZ_FALSE;
-    }
-
-    if (pErr)
-        *pErr = actual_err;
-
-    return success;
-}
-
-#ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr)
-{
-    mz_bool success = MZ_TRUE;
-    mz_zip_archive zip;
-    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
-
-    if (!pFilename)
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_PARAMETER;
-        return MZ_FALSE;
-    }
-
-    mz_zip_zero_struct(&zip);
-
-    if (!mz_zip_reader_init_file_v2(&zip, pFilename, flags, 0, 0))
-    {
-        if (pErr)
-            *pErr = zip.m_last_error;
-        return MZ_FALSE;
-    }
-
-    if (!mz_zip_validate_archive(&zip, flags))
-    {
-        actual_err = zip.m_last_error;
-        success = MZ_FALSE;
-    }
-
-    if (!mz_zip_reader_end_internal(&zip, success))
-    {
-        if (!actual_err)
-            actual_err = zip.m_last_error;
-        success = MZ_FALSE;
-    }
-
-    if (pErr)
-        *pErr = actual_err;
-
-    return success;
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-/* ------------------- .ZIP archive writing */
-
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-
-static MZ_FORCEINLINE void mz_write_le16(mz_uint8 *p, mz_uint16 v)
-{
-    p[0] = (mz_uint8)v;
-    p[1] = (mz_uint8)(v >> 8);
-}
-static MZ_FORCEINLINE void mz_write_le32(mz_uint8 *p, mz_uint32 v)
-{
-    p[0] = (mz_uint8)v;
-    p[1] = (mz_uint8)(v >> 8);
-    p[2] = (mz_uint8)(v >> 16);
-    p[3] = (mz_uint8)(v >> 24);
-}
-static MZ_FORCEINLINE void mz_write_le64(mz_uint8 *p, mz_uint64 v)
-{
-    mz_write_le32(p, (mz_uint32)v);
-    mz_write_le32(p + sizeof(mz_uint32), (mz_uint32)(v >> 32));
-}
-
-#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v))
-#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))
-#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v))
-
-static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
-{
-    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
-    mz_zip_internal_state *pState = pZip->m_pState;
-    mz_uint64 new_size = MZ_MAX(file_ofs + n, pState->m_mem_size);
-
-    if (!n)
-        return 0;
-
-    /* An allocation this big is likely to just fail on 32-bit systems, so don't even go there. */
-    if ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
-        return 0;
-    }
-
-    if (new_size > pState->m_mem_capacity)
-    {
-        void *pNew_block;
-        size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity);
-
-        while (new_capacity < new_size)
-            new_capacity *= 2;
-
-        if (NULL == (pNew_block = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity)))
-        {
-            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            return 0;
-        }
-
-        pState->m_pMem = pNew_block;
-        pState->m_mem_capacity = new_capacity;
-    }
-    memcpy((mz_uint8 *)pState->m_pMem + file_ofs, pBuf, n);
-    pState->m_mem_size = (size_t)new_size;
-    return n;
-}
-
-static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
-{
-    mz_zip_internal_state *pState;
-    mz_bool status = MZ_TRUE;
-
-    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)))
-    {
-        if (set_last_error)
-            mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return MZ_FALSE;
-    }
-
-    pState = pZip->m_pState;
-    pZip->m_pState = NULL;
-    mz_zip_array_clear(pZip, &pState->m_central_dir);
-    mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
-    mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
-
-#ifndef MINIZ_NO_STDIO
-    if (pState->m_pFile)
-    {
-        if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
-        {
-            if (MZ_FCLOSE(pState->m_pFile) == EOF)
-            {
-                if (set_last_error)
-                    mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
-                status = MZ_FALSE;
-            }
-        }
-
-        pState->m_pFile = NULL;
-    }
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-    if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem))
-    {
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pState->m_pMem);
-        pState->m_pMem = NULL;
-    }
-
-    pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
-    pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
-    return status;
-}
-
-mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags)
-{
-    mz_bool zip64 = (flags & MZ_ZIP_FLAG_WRITE_ZIP64) != 0;
-
-    if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
-    {
-        if (!pZip->m_pRead)
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-    }
-
-    if (pZip->m_file_offset_alignment)
-    {
-        /* Ensure user specified file offset alignment is a power of 2. */
-        if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1))
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-    }
-
-    if (!pZip->m_pAlloc)
-        pZip->m_pAlloc = miniz_def_alloc_func;
-    if (!pZip->m_pFree)
-        pZip->m_pFree = miniz_def_free_func;
-    if (!pZip->m_pRealloc)
-        pZip->m_pRealloc = miniz_def_realloc_func;
-
-    pZip->m_archive_size = existing_size;
-    pZip->m_central_directory_file_ofs = 0;
-    pZip->m_total_files = 0;
-
-    if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
-
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
-    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
-
-    pZip->m_pState->m_zip64 = zip64;
-    pZip->m_pState->m_zip64_has_extended_info_fields = zip64;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_USER;
-    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size)
-{
-    return mz_zip_writer_init_v2(pZip, existing_size, 0);
-}
-
-mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags)
-{
-    pZip->m_pWrite = mz_zip_heap_write_func;
-    pZip->m_pNeeds_keepalive = NULL;
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
-        pZip->m_pRead = mz_zip_mem_read_func;
-
-    pZip->m_pIO_opaque = pZip;
-
-    if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
-        return MZ_FALSE;
-
-    pZip->m_zip_type = MZ_ZIP_TYPE_HEAP;
-
-    if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning)))
-    {
-        if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size)))
-        {
-            mz_zip_writer_end_internal(pZip, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-        pZip->m_pState->m_mem_capacity = initial_allocation_size;
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size)
-{
-    return mz_zip_writer_init_heap_v2(pZip, size_to_reserve_at_beginning, initial_allocation_size, 0);
-}
-
-#ifndef MINIZ_NO_STDIO
-static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
-{
-    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
-    mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
-
-    file_ofs += pZip->m_pState->m_file_archive_start_ofs;
-
-    if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
-    {
-        mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
-        return 0;
-    }
-
-    return MZ_FWRITE(pBuf, 1, n, pZip->m_pState->m_pFile);
-}
-
-mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning)
-{
-    return mz_zip_writer_init_file_v2(pZip, pFilename, size_to_reserve_at_beginning, 0);
-}
-
-mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags)
-{
-    MZ_FILE *pFile;
-
-    pZip->m_pWrite = mz_zip_file_write_func;
-    pZip->m_pNeeds_keepalive = NULL;
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
-        pZip->m_pRead = mz_zip_file_read_func;
-
-    pZip->m_pIO_opaque = pZip;
-
-    if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
-        return MZ_FALSE;
-
-    if (NULL == (pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ? "w+b" : "wb")))
-    {
-        mz_zip_writer_end(pZip);
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-    }
-
-    pZip->m_pState->m_pFile = pFile;
-    pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
-
-    if (size_to_reserve_at_beginning)
-    {
-        mz_uint64 cur_ofs = 0;
-        char buf[4096];
-
-        MZ_CLEAR_OBJ(buf);
-
-        do
-        {
-            size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning);
-            if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n)
-            {
-                mz_zip_writer_end(pZip);
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-            }
-            cur_ofs += n;
-            size_to_reserve_at_beginning -= n;
-        } while (size_to_reserve_at_beginning);
-    }
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags)
-{
-    pZip->m_pWrite = mz_zip_file_write_func;
-    pZip->m_pNeeds_keepalive = NULL;
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
-        pZip->m_pRead = mz_zip_file_read_func;
-
-    pZip->m_pIO_opaque = pZip;
-
-    if (!mz_zip_writer_init_v2(pZip, 0, flags))
-        return MZ_FALSE;
-
-    pZip->m_pState->m_pFile = pFile;
-    pZip->m_pState->m_file_archive_start_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
-    pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
-
-    return MZ_TRUE;
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)
-{
-    mz_zip_internal_state *pState;
-
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (flags & MZ_ZIP_FLAG_WRITE_ZIP64)
-    {
-        /* We don't support converting a non-zip64 file to zip64 - this seems like more trouble than it's worth. (What about the existing 32-bit data descriptors that could follow the compressed data?) */
-        if (!pZip->m_pState->m_zip64)
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-    }
-
-    /* No sense in trying to write to an archive that's already at the support max size */
-    if (pZip->m_pState->m_zip64)
-    {
-        if (pZip->m_total_files == MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        if (pZip->m_total_files == MZ_UINT16_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
-        if ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
-    }
-
-    pState = pZip->m_pState;
-
-    if (pState->m_pFile)
-    {
-#ifdef MINIZ_NO_STDIO
-        (void)pFilename;
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-#else
-        if (pZip->m_pIO_opaque != pZip)
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-        if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
-        {
-            if (!pFilename)
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-            /* Archive is being read from stdio and was originally opened only for reading. Try to reopen as writable. */
-            if (NULL == (pState->m_pFile = MZ_FREOPEN(pFilename, "r+b", pState->m_pFile)))
-            {
-                /* The mz_zip_archive is now in a bogus state because pState->m_pFile is NULL, so just close it. */
-                mz_zip_reader_end_internal(pZip, MZ_FALSE);
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-            }
-        }
-
-        pZip->m_pWrite = mz_zip_file_write_func;
-        pZip->m_pNeeds_keepalive = NULL;
-#endif /* #ifdef MINIZ_NO_STDIO */
-    }
-    else if (pState->m_pMem)
-    {
-        /* Archive lives in a memory block. Assume it's from the heap that we can resize using the realloc callback. */
-        if (pZip->m_pIO_opaque != pZip)
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-        pState->m_mem_capacity = pState->m_mem_size;
-        pZip->m_pWrite = mz_zip_heap_write_func;
-        pZip->m_pNeeds_keepalive = NULL;
-    }
-    /* Archive is being read via a user provided read function - make sure the user has specified a write function too. */
-    else if (!pZip->m_pWrite)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    /* Start writing new files at the archive's current central directory location. */
-    /* TODO: We could add a flag that lets the user start writing immediately AFTER the existing central dir - this would be safer. */
-    pZip->m_archive_size = pZip->m_central_directory_file_ofs;
-    pZip->m_central_directory_file_ofs = 0;
-
-    /* Clear the sorted central dir offsets, they aren't useful or maintained now. */
-    /* Even though we're now in write mode, files can still be extracted and verified, but file locates will be slow. */
-    /* TODO: We could easily maintain the sorted central directory offsets. */
-    mz_zip_array_clear(pZip, &pZip->m_pState->m_sorted_central_dir_offsets);
-
-    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename)
-{
-    return mz_zip_writer_init_from_reader_v2(pZip, pFilename, 0);
-}
-
-/* TODO: pArchive_name is a terrible name here! */
-mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags)
-{
-    return mz_zip_writer_add_mem_ex(pZip, pArchive_name, pBuf, buf_size, NULL, 0, level_and_flags, 0, 0);
-}
-
-typedef struct
-{
-    mz_zip_archive *m_pZip;
-    mz_uint64 m_cur_archive_file_ofs;
-    mz_uint64 m_comp_size;
-} mz_zip_writer_add_state;
-
-static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, void *pUser)
-{
-    mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser;
-    if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, pState->m_cur_archive_file_ofs, pBuf, len) != len)
-        return MZ_FALSE;
-
-    pState->m_cur_archive_file_ofs += len;
-    pState->m_comp_size += len;
-    return MZ_TRUE;
-}
-
-#define MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 2)
-#define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 3)
-static mz_uint32 mz_zip_writer_create_zip64_extra_data(mz_uint8 *pBuf, mz_uint64 *pUncomp_size, mz_uint64 *pComp_size, mz_uint64 *pLocal_header_ofs)
-{
-    mz_uint8 *pDst = pBuf;
-    mz_uint32 field_size = 0;
-
-    MZ_WRITE_LE16(pDst + 0, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID);
-    MZ_WRITE_LE16(pDst + 2, 0);
-    pDst += sizeof(mz_uint16) * 2;
-
-    if (pUncomp_size)
-    {
-        MZ_WRITE_LE64(pDst, *pUncomp_size);
-        pDst += sizeof(mz_uint64);
-        field_size += sizeof(mz_uint64);
-    }
-
-    if (pComp_size)
-    {
-        MZ_WRITE_LE64(pDst, *pComp_size);
-        pDst += sizeof(mz_uint64);
-        field_size += sizeof(mz_uint64);
-    }
-
-    if (pLocal_header_ofs)
-    {
-        MZ_WRITE_LE64(pDst, *pLocal_header_ofs);
-        pDst += sizeof(mz_uint64);
-        field_size += sizeof(mz_uint64);
-    }
-
-    MZ_WRITE_LE16(pBuf + 2, field_size);
-
-    return (mz_uint32)(pDst - pBuf);
-}
-
-static mz_bool mz_zip_writer_create_local_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date)
-{
-    (void)pZip;
-    memset(pDst, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_SIG_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_VERSION_NEEDED_OFS, method ? 20 : 0);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_BIT_FLAG_OFS, bit_flags);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_METHOD_OFS, method);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_TIME_OFS, dos_time);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_DATE_OFS, dos_date);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_CRC32_OFS, uncomp_crc32);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX));
-    MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX));
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILENAME_LEN_OFS, filename_size);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_EXTRA_LEN_OFS, extra_size);
-    return MZ_TRUE;
-}
-
-static mz_bool mz_zip_writer_create_central_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst,
-                                                       mz_uint16 filename_size, mz_uint16 extra_size, mz_uint16 comment_size,
-                                                       mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32,
-                                                       mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date,
-                                                       mz_uint64 local_header_ofs, mz_uint32 ext_attributes)
-{
-    (void)pZip;
-    memset(pDst, 0, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_BIT_FLAG_OFS, bit_flags);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_METHOD_OFS, method);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_TIME_OFS, dos_time);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_DATE_OFS, dos_date);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_CRC32_OFS, uncomp_crc32);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX));
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX));
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILENAME_LEN_OFS, filename_size);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_EXTRA_LEN_OFS, extra_size);
-    MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_COMMENT_LEN_OFS, comment_size);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, ext_attributes);
-    MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_MIN(local_header_ofs, MZ_UINT32_MAX));
-    return MZ_TRUE;
-}
-
-static mz_bool mz_zip_writer_add_to_central_dir(mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size,
-                                                const void *pExtra, mz_uint16 extra_size, const void *pComment, mz_uint16 comment_size,
-                                                mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32,
-                                                mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date,
-                                                mz_uint64 local_header_ofs, mz_uint32 ext_attributes,
-                                                const char *user_extra_data, mz_uint user_extra_data_len)
-{
-    mz_zip_internal_state *pState = pZip->m_pState;
-    mz_uint32 central_dir_ofs = (mz_uint32)pState->m_central_dir.m_size;
-    size_t orig_central_dir_size = pState->m_central_dir.m_size;
-    mz_uint8 central_dir_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
-
-    if (!pZip->m_pState->m_zip64)
-    {
-        if (local_header_ofs > 0xFFFFFFFF)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
-    }
-
-    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
-    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + extra_size + user_extra_data_len + comment_size) >= MZ_UINT32_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    if (!mz_zip_writer_create_central_dir_header(pZip, central_dir_header, filename_size, extra_size + user_extra_data_len, comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_header_ofs, ext_attributes))
-        return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-    if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, filename_size)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, extra_size)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir, user_extra_data, user_extra_data_len)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, comment_size)) ||
-        (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &central_dir_ofs, 1)))
-    {
-        /* Try to resize the central directory array back into its original state. */
-        mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-    }
-
-    return MZ_TRUE;
-}
-
-static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name)
-{
-    /* Basic ZIP archive filename validity checks: Valid filenames cannot start with a forward slash, cannot contain a drive letter, and cannot use DOS-style backward slashes. */
-    if (*pArchive_name == '/')
-        return MZ_FALSE;
-
-    while (*pArchive_name)
-    {
-        if ((*pArchive_name == '\\') || (*pArchive_name == ':'))
-            return MZ_FALSE;
-
-        pArchive_name++;
-    }
-
-    return MZ_TRUE;
-}
-
-static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip)
-{
-    mz_uint32 n;
-    if (!pZip->m_file_offset_alignment)
-        return 0;
-    n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1));
-    return (mz_uint)((pZip->m_file_offset_alignment - n) & (pZip->m_file_offset_alignment - 1));
-}
-
-static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
-{
-    char buf[4096];
-    memset(buf, 0, MZ_MIN(sizeof(buf), n));
-    while (n)
-    {
-        mz_uint32 s = MZ_MIN(sizeof(buf), n);
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_file_ofs += s;
-        n -= s;
-    }
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32)
-{
-    return mz_zip_writer_add_mem_ex_v2(pZip, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, uncomp_size, uncomp_crc32, NULL, NULL, 0, NULL, 0);
-}
-
-mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size,
-                                    mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified,
-                                    const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
-{
-    mz_uint16 method = 0, dos_time = 0, dos_date = 0;
-    mz_uint level, ext_attributes = 0, num_alignment_padding_bytes;
-    mz_uint64 local_dir_header_ofs = pZip->m_archive_size, cur_archive_file_ofs = pZip->m_archive_size, comp_size = 0;
-    size_t archive_name_size;
-    mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
-    tdefl_compressor *pComp = NULL;
-    mz_bool store_data_uncompressed;
-    mz_zip_internal_state *pState;
-    mz_uint8 *pExtra_data = NULL;
-    mz_uint32 extra_size = 0;
-    mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
-    mz_uint16 bit_flags = 0;
-
-    if ((int)level_and_flags < 0)
-        level_and_flags = MZ_DEFAULT_LEVEL;
-
-    if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
-        bit_flags |= MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
-
-    if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
-        bit_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
-
-    level = level_and_flags & 0xF;
-    store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA));
-
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    if (pState->m_zip64)
-    {
-        if (pZip->m_total_files == MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        if (pZip->m_total_files == MZ_UINT16_MAX)
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
-        }
-        if ((buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF))
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
-        }
-    }
-
-    if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_writer_validate_archive_name(pArchive_name))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
-
-#ifndef MINIZ_NO_TIME
-    if (last_modified != NULL)
-    {
-        mz_zip_time_t_to_dos_time(*last_modified, &dos_time, &dos_date);
-    }
-    else
-    {
-        MZ_TIME_T cur_time;
-        time(&cur_time);
-        mz_zip_time_t_to_dos_time(cur_time, &dos_time, &dos_date);
-    }
-#endif /* #ifndef MINIZ_NO_TIME */
-
-	if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-	{
-		uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size);
-		uncomp_size = buf_size;
-		if (uncomp_size <= 3)
-		{
-			level = 0;
-			store_data_uncompressed = MZ_TRUE;
-		}
-	}
-
-    archive_name_size = strlen(pArchive_name);
-    if (archive_name_size > MZ_UINT16_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
-
-    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
-
-    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
-    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    if (!pState->m_zip64)
-    {
-        /* Bail early if the archive would obviously become too large */
-        if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size
-			+ MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len +
-			pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len
-			+ MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF)
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
-        }
-    }
-
-    if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/'))
-    {
-        /* Set DOS Subdirectory attribute bit. */
-        ext_attributes |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG;
-
-        /* Subdirectories cannot contain data. */
-        if ((buf_size) || (uncomp_size))
-            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-    }
-
-    /* Try to do any allocations before writing to the archive, so if an allocation fails the file remains unmodified. (A good idea if we're doing an in-place modification.) */
-    if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1)))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    if ((!store_data_uncompressed) && (buf_size))
-    {
-        if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor))))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-    }
-
-    if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
-    {
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-        return MZ_FALSE;
-    }
-
-    local_dir_header_ofs += num_alignment_padding_bytes;
-    if (pZip->m_file_offset_alignment)
-    {
-        MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
-    }
-    cur_archive_file_ofs += num_alignment_padding_bytes;
-
-    MZ_CLEAR_OBJ(local_dir_header);
-
-    if (!store_data_uncompressed || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-    {
-        method = MZ_DEFLATED;
-    }
-
-    if (pState->m_zip64)
-    {
-        if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
-        {
-            pExtra_data = extra_data;
-            extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
-                                                               (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
-        }
-
-        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, extra_size + user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += sizeof(local_dir_header);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-        cur_archive_file_ofs += archive_name_size;
-
-        if (pExtra_data != NULL)
-        {
-            if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-            cur_archive_file_ofs += extra_size;
-        }
-    }
-    else
-    {
-        if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += sizeof(local_dir_header);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-        cur_archive_file_ofs += archive_name_size;
-    }
-
-	if (user_extra_data_len > 0)
-	{
-		if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
-			return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-		cur_archive_file_ofs += user_extra_data_len;
-	}
-
-    if (store_data_uncompressed)
-    {
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, buf_size) != buf_size)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-
-        cur_archive_file_ofs += buf_size;
-        comp_size = buf_size;
-    }
-    else if (buf_size)
-    {
-        mz_zip_writer_add_state state;
-
-        state.m_pZip = pZip;
-        state.m_cur_archive_file_ofs = cur_archive_file_ofs;
-        state.m_comp_size = 0;
-
-        if ((tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY) ||
-            (tdefl_compress_buffer(pComp, pBuf, buf_size, TDEFL_FINISH) != TDEFL_STATUS_DONE))
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-            return mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED);
-        }
-
-        comp_size = state.m_comp_size;
-        cur_archive_file_ofs = state.m_cur_archive_file_ofs;
-    }
-
-    pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-    pComp = NULL;
-
-    if (uncomp_size)
-    {
-        mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
-        mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
-
-        MZ_ASSERT(bit_flags & MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR);
-
-        MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
-        MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
-        if (pExtra_data == NULL)
-        {
-            if (comp_size > MZ_UINT32_MAX)
-                return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-            MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
-            MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
-        }
-        else
-        {
-            MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
-            MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
-            local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
-        }
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
-            return MZ_FALSE;
-
-        cur_archive_file_ofs += local_dir_footer_size;
-    }
-
-    if (pExtra_data != NULL)
-    {
-        extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
-                                                           (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
-    }
-
-    if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, extra_size, pComment,
-                                          comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
-                                          user_extra_data_central, user_extra_data_central_len))
-        return MZ_FALSE;
-
-    pZip->m_total_files++;
-    pZip->m_archive_size = cur_archive_file_ofs;
-
-    return MZ_TRUE;
-}
-
-#ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 size_to_add, const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
-{
-    mz_uint16 gen_flags = MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
-    mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes;
-    mz_uint16 method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0;
-    mz_uint64 local_dir_header_ofs, cur_archive_file_ofs = pZip->m_archive_size, uncomp_size = size_to_add, comp_size = 0;
-    size_t archive_name_size;
-    mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
-    mz_uint8 *pExtra_data = NULL;
-    mz_uint32 extra_size = 0;
-    mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
-    mz_zip_internal_state *pState;
-
-    if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
-        gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
-
-    if ((int)level_and_flags < 0)
-        level_and_flags = MZ_DEFAULT_LEVEL;
-    level = level_and_flags & 0xF;
-
-    /* Sanity checks */
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    if ((!pState->m_zip64) && (uncomp_size > MZ_UINT32_MAX))
-    {
-        /* Source file is too large for non-zip64 */
-        /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
-        pState->m_zip64 = MZ_TRUE;
-    }
-
-    /* We could support this, but why? */
-    if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_writer_validate_archive_name(pArchive_name))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
-
-    if (pState->m_zip64)
-    {
-        if (pZip->m_total_files == MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        if (pZip->m_total_files == MZ_UINT16_MAX)
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
-        }
-    }
-
-    archive_name_size = strlen(pArchive_name);
-    if (archive_name_size > MZ_UINT16_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
-
-    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
-
-    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
-    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    if (!pState->m_zip64)
-    {
-        /* Bail early if the archive would obviously become too large */
-        if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
-			+ archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024
-			+ MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
-        {
-            pState->m_zip64 = MZ_TRUE;
-            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
-        }
-    }
-
-#ifndef MINIZ_NO_TIME
-    if (pFile_time)
-    {
-        mz_zip_time_t_to_dos_time(*pFile_time, &dos_time, &dos_date);
-    }
-#endif
-
-    if (uncomp_size <= 3)
-        level = 0;
-
-    if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
-    {
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-    }
-
-    cur_archive_file_ofs += num_alignment_padding_bytes;
-    local_dir_header_ofs = cur_archive_file_ofs;
-
-    if (pZip->m_file_offset_alignment)
-    {
-        MZ_ASSERT((cur_archive_file_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
-    }
-
-    if (uncomp_size && level)
-    {
-        method = MZ_DEFLATED;
-    }
-
-    MZ_CLEAR_OBJ(local_dir_header);
-    if (pState->m_zip64)
-    {
-        if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
-        {
-            pExtra_data = extra_data;
-            extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
-                                                               (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
-        }
-
-        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, extra_size + user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += sizeof(local_dir_header);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
-        {
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-
-        cur_archive_file_ofs += archive_name_size;
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += extra_size;
-    }
-    else
-    {
-        if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))
-            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += sizeof(local_dir_header);
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
-        {
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-
-        cur_archive_file_ofs += archive_name_size;
-    }
-
-    if (user_extra_data_len > 0)
-    {
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        cur_archive_file_ofs += user_extra_data_len;
-    }
-
-    if (uncomp_size)
-    {
-        mz_uint64 uncomp_remaining = uncomp_size;
-        void *pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, MZ_ZIP_MAX_IO_BUF_SIZE);
-        if (!pRead_buf)
-        {
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (!level)
-        {
-            while (uncomp_remaining)
-            {
-                mz_uint n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, uncomp_remaining);
-                if ((MZ_FREAD(pRead_buf, 1, n, pSrc_file) != n) || (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, n) != n))
-                {
-                    pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-                    return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-                }
-                uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
-                uncomp_remaining -= n;
-                cur_archive_file_ofs += n;
-            }
-            comp_size = uncomp_size;
-        }
-        else
-        {
-            mz_bool result = MZ_FALSE;
-            mz_zip_writer_add_state state;
-            tdefl_compressor *pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor));
-            if (!pComp)
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-                return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            }
-
-            state.m_pZip = pZip;
-            state.m_cur_archive_file_ofs = cur_archive_file_ofs;
-            state.m_comp_size = 0;
-
-            if (tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY)
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-                return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
-            }
-
-            for (;;)
-            {
-                size_t in_buf_size = (mz_uint32)MZ_MIN(uncomp_remaining, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
-                tdefl_status status;
-                tdefl_flush flush = TDEFL_NO_FLUSH;
-
-                if (MZ_FREAD(pRead_buf, 1, in_buf_size, pSrc_file) != in_buf_size)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-                    break;
-                }
-
-                uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, in_buf_size);
-                uncomp_remaining -= in_buf_size;
-
-                if (pZip->m_pNeeds_keepalive != NULL && pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque))
-                    flush = TDEFL_FULL_FLUSH;
-
-                status = tdefl_compress_buffer(pComp, pRead_buf, in_buf_size, uncomp_remaining ? flush : TDEFL_FINISH);
-                if (status == TDEFL_STATUS_DONE)
-                {
-                    result = MZ_TRUE;
-                    break;
-                }
-                else if (status != TDEFL_STATUS_OKAY)
-                {
-                    mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED);
-                    break;
-                }
-            }
-
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
-
-            if (!result)
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-                return MZ_FALSE;
-            }
-
-            comp_size = state.m_comp_size;
-            cur_archive_file_ofs = state.m_cur_archive_file_ofs;
-        }
-
-        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
-    }
-
-    {
-        mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
-        mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
-
-        MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
-        MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
-        if (pExtra_data == NULL)
-        {
-            if (comp_size > MZ_UINT32_MAX)
-                return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-            MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
-            MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
-        }
-        else
-        {
-            MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
-            MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
-            local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
-        }
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
-            return MZ_FALSE;
-
-        cur_archive_file_ofs += local_dir_footer_size;
-    }
-
-    if (pExtra_data != NULL)
-    {
-        extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
-                                                           (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
-    }
-
-    if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, extra_size, pComment, comment_size,
-                                          uncomp_size, comp_size, uncomp_crc32, method, gen_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
-                                          user_extra_data_central, user_extra_data_central_len))
-        return MZ_FALSE;
-
-    pZip->m_total_files++;
-    pZip->m_archive_size = cur_archive_file_ofs;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
-{
-    MZ_FILE *pSrc_file = NULL;
-    mz_uint64 uncomp_size = 0;
-    MZ_TIME_T file_modified_time;
-    MZ_TIME_T *pFile_time = NULL;
-    mz_bool status;
-
-    memset(&file_modified_time, 0, sizeof(file_modified_time));
-
-#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
-    pFile_time = &file_modified_time;
-    if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time))
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_STAT_FAILED);
-#endif
-
-    pSrc_file = MZ_FOPEN(pSrc_filename, "rb");
-    if (!pSrc_file)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
-    MZ_FSEEK64(pSrc_file, 0, SEEK_END);
-    uncomp_size = MZ_FTELL64(pSrc_file);
-    MZ_FSEEK64(pSrc_file, 0, SEEK_SET);
-
-    status = mz_zip_writer_add_cfile(pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, comment_size, level_and_flags, NULL, 0, NULL, 0);
-
-    MZ_FCLOSE(pSrc_file);
-
-    return status;
-}
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-static mz_bool mz_zip_writer_update_zip64_extension_block(mz_zip_array *pNew_ext, mz_zip_archive *pZip, const mz_uint8 *pExt, uint32_t ext_len, mz_uint64 *pComp_size, mz_uint64 *pUncomp_size, mz_uint64 *pLocal_header_ofs, mz_uint32 *pDisk_start)
-{
-    /* + 64 should be enough for any new zip64 data */
-    if (!mz_zip_array_reserve(pZip, pNew_ext, ext_len + 64, MZ_FALSE))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    mz_zip_array_resize(pZip, pNew_ext, 0, MZ_FALSE);
-
-    if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start))
-    {
-        mz_uint8 new_ext_block[64];
-        mz_uint8 *pDst = new_ext_block;
-        mz_write_le16(pDst, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID);
-        mz_write_le16(pDst + sizeof(mz_uint16), 0);
-        pDst += sizeof(mz_uint16) * 2;
-
-        if (pUncomp_size)
-        {
-            mz_write_le64(pDst, *pUncomp_size);
-            pDst += sizeof(mz_uint64);
-        }
-
-        if (pComp_size)
-        {
-            mz_write_le64(pDst, *pComp_size);
-            pDst += sizeof(mz_uint64);
-        }
-
-        if (pLocal_header_ofs)
-        {
-            mz_write_le64(pDst, *pLocal_header_ofs);
-            pDst += sizeof(mz_uint64);
-        }
-
-        if (pDisk_start)
-        {
-            mz_write_le32(pDst, *pDisk_start);
-            pDst += sizeof(mz_uint32);
-        }
-
-        mz_write_le16(new_ext_block + sizeof(mz_uint16), (mz_uint16)((pDst - new_ext_block) - sizeof(mz_uint16) * 2));
-
-        if (!mz_zip_array_push_back(pZip, pNew_ext, new_ext_block, pDst - new_ext_block))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-    }
-
-    if ((pExt) && (ext_len))
-    {
-        mz_uint32 extra_size_remaining = ext_len;
-        const mz_uint8 *pExtra_data = pExt;
-
-        do
-        {
-            mz_uint32 field_id, field_data_size, field_total_size;
-
-            if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            field_id = MZ_READ_LE16(pExtra_data);
-            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-            field_total_size = field_data_size + sizeof(mz_uint16) * 2;
-
-            if (field_total_size > extra_size_remaining)
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-            if (field_id != MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-            {
-                if (!mz_zip_array_push_back(pZip, pNew_ext, pExtra_data, field_total_size))
-                    return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-            }
-
-            pExtra_data += field_total_size;
-            extra_size_remaining -= field_total_size;
-        } while (extra_size_remaining);
-    }
-
-    return MZ_TRUE;
-}
-
-/* TODO: This func is now pretty freakin complex due to zip64, split it up? */
-mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index)
-{
-    mz_uint n, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size;
-    mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs;
-    mz_uint64 cur_src_file_ofs, cur_dst_file_ofs;
-    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
-    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
-    mz_uint8 new_central_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
-    size_t orig_central_dir_size;
-    mz_zip_internal_state *pState;
-    void *pBuf;
-    const mz_uint8 *pSrc_central_header;
-    mz_zip_archive_file_stat src_file_stat;
-    mz_uint32 src_filename_len, src_comment_len, src_ext_len;
-    mz_uint32 local_header_filename_size, local_header_extra_len;
-    mz_uint64 local_header_comp_size, local_header_uncomp_size;
-    mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
-
-    /* Sanity checks */
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    /* Don't support copying files from zip64 archives to non-zip64, even though in some cases this is possible */
-    if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    /* Get pointer to the source central dir header and crack it */
-    if (NULL == (pSrc_central_header = mz_zip_get_cdh(pSource_zip, src_file_index)))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_SIG_OFS) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    src_filename_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    src_comment_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_COMMENT_LEN_OFS);
-    src_ext_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS);
-    src_central_dir_following_data_size = src_filename_len + src_ext_len + src_comment_len;
-
-    /* TODO: We don't support central dir's >= MZ_UINT32_MAX bytes right now (+32 fudge factor in case we need to add more extra data) */
-    if ((pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + 32) >= MZ_UINT32_MAX)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
-
-    if (!pState->m_zip64)
-    {
-        if (pZip->m_total_files == MZ_UINT16_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        /* TODO: Our zip64 support still has some 32-bit limits that may not be worth fixing. */
-        if (pZip->m_total_files == MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-
-    if (!mz_zip_file_stat_internal(pSource_zip, src_file_index, pSrc_central_header, &src_file_stat, NULL))
-        return MZ_FALSE;
-
-    cur_src_file_ofs = src_file_stat.m_local_header_ofs;
-    cur_dst_file_ofs = pZip->m_archive_size;
-
-    /* Read the source archive's local dir header */
-    if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-
-    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    cur_src_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
-
-    /* Compute the total size we need to copy (filename+extra data+compressed data) */
-    local_header_filename_size = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
-    local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
-    local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
-    local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
-    src_archive_bytes_remaining = local_header_filename_size + local_header_extra_len + src_file_stat.m_comp_size;
-
-    /* Try to find a zip64 extended information field */
-    if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
-    {
-        mz_zip_array file_data_array;
-        const mz_uint8 *pExtra_data;
-        mz_uint32 extra_size_remaining = local_header_extra_len;
-
-        mz_zip_array_init(&file_data_array, 1);
-        if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, MZ_FALSE))
-        {
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, src_file_stat.m_local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_size, file_data_array.m_p, local_header_extra_len) != local_header_extra_len)
-        {
-            mz_zip_array_clear(pZip, &file_data_array);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-        }
-
-        pExtra_data = (const mz_uint8 *)file_data_array.m_p;
-
-        do
-        {
-            mz_uint32 field_id, field_data_size, field_total_size;
-
-            if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-            {
-                mz_zip_array_clear(pZip, &file_data_array);
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            field_id = MZ_READ_LE16(pExtra_data);
-            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-            field_total_size = field_data_size + sizeof(mz_uint16) * 2;
-
-            if (field_total_size > extra_size_remaining)
-            {
-                mz_zip_array_clear(pZip, &file_data_array);
-                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
-            {
-                const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
-
-                if (field_data_size < sizeof(mz_uint64) * 2)
-                {
-                    mz_zip_array_clear(pZip, &file_data_array);
-                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-                }
-
-                local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
-                local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64)); /* may be 0 if there's a descriptor */
-
-                found_zip64_ext_data_in_ldir = MZ_TRUE;
-                break;
-            }
-
-            pExtra_data += field_total_size;
-            extra_size_remaining -= field_total_size;
-        } while (extra_size_remaining);
-
-        mz_zip_array_clear(pZip, &file_data_array);
-    }
-
-    if (!pState->m_zip64)
-    {
-        /* Try to detect if the new archive will most likely wind up too big and bail early (+(sizeof(mz_uint32) * 4) is for the optional descriptor which could be present, +64 is a fudge factor). */
-        /* We also check when the archive is finalized so this doesn't need to be perfect. */
-        mz_uint64 approx_new_archive_size = cur_dst_file_ofs + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + src_archive_bytes_remaining + (sizeof(mz_uint32) * 4) +
-                                            pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 64;
-
-        if (approx_new_archive_size >= MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-    }
-
-    /* Write dest archive padding */
-    if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, num_alignment_padding_bytes))
-        return MZ_FALSE;
-
-    cur_dst_file_ofs += num_alignment_padding_bytes;
-
-    local_dir_header_ofs = cur_dst_file_ofs;
-    if (pZip->m_file_offset_alignment)
-    {
-        MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
-    }
-
-    /* The original zip's local header+ext block doesn't change, even with zip64, so we can just copy it over to the dest zip */
-    if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-    cur_dst_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
-
-    /* Copy over the source archive bytes to the dest archive, also ensure we have enough buf space to handle optional data descriptor */
-    if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)MZ_MAX(32U, MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining)))))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-    while (src_archive_bytes_remaining)
-    {
-        n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining);
-        if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-        }
-        cur_src_file_ofs += n;
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-        cur_dst_file_ofs += n;
-
-        src_archive_bytes_remaining -= n;
-    }
-
-    /* Now deal with the optional data descriptor */
-    bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
-    if (bit_flags & 8)
-    {
-        /* Copy data descriptor */
-        if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir))
-        {
-            /* src is zip64, dest must be zip64 */
-
-            /* name			uint32_t's */
-            /* id				1 (optional in zip64?) */
-            /* crc			1 */
-            /* comp_size	2 */
-            /* uncomp_size 2 */
-            if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6))
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            }
-
-            n = sizeof(mz_uint32) * ((MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID) ? 6 : 5);
-        }
-        else
-        {
-            /* src is NOT zip64 */
-            mz_bool has_id;
-
-            if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, sizeof(mz_uint32) * 4) != sizeof(mz_uint32) * 4)
-            {
-                pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-                return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            }
-
-            has_id = (MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
-
-            if (pZip->m_pState->m_zip64)
-            {
-                /* dest is zip64, so upgrade the data descriptor */
-                const mz_uint32 *pSrc_descriptor = (const mz_uint32 *)((const mz_uint8 *)pBuf + (has_id ? sizeof(mz_uint32) : 0));
-                const mz_uint32 src_crc32 = pSrc_descriptor[0];
-                const mz_uint64 src_comp_size = pSrc_descriptor[1];
-                const mz_uint64 src_uncomp_size = pSrc_descriptor[2];
-
-                mz_write_le32((mz_uint8 *)pBuf, MZ_ZIP_DATA_DESCRIPTOR_ID);
-                mz_write_le32((mz_uint8 *)pBuf + sizeof(mz_uint32) * 1, src_crc32);
-                mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 2, src_comp_size);
-                mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 4, src_uncomp_size);
-
-                n = sizeof(mz_uint32) * 6;
-            }
-            else
-            {
-                /* dest is NOT zip64, just copy it as-is */
-                n = sizeof(mz_uint32) * (has_id ? 4 : 3);
-            }
-        }
-
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
-        {
-            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-        }
-
-        cur_src_file_ofs += n;
-        cur_dst_file_ofs += n;
-    }
-    pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
-
-    /* Finally, add the new central dir header */
-    orig_central_dir_size = pState->m_central_dir.m_size;
-
-    memcpy(new_central_header, pSrc_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
-
-    if (pState->m_zip64)
-    {
-        /* This is the painful part: We need to write a new central dir header + ext block with updated zip64 fields, and ensure the old fields (if any) are not included. */
-        const mz_uint8 *pSrc_ext = pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len;
-        mz_zip_array new_ext_block;
-
-        mz_zip_array_init(&new_ext_block, sizeof(mz_uint8));
-
-        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_UINT32_MAX);
-        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_UINT32_MAX);
-        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_UINT32_MAX);
-
-        if (!mz_zip_writer_update_zip64_extension_block(&new_ext_block, pZip, pSrc_ext, src_ext_len, &src_file_stat.m_comp_size, &src_file_stat.m_uncomp_size, &local_dir_header_ofs, NULL))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            return MZ_FALSE;
-        }
-
-        MZ_WRITE_LE16(new_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS, new_ext_block.m_size);
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_filename_len))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, new_ext_block.m_size))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len + src_ext_len, src_comment_len))
-        {
-            mz_zip_array_clear(pZip, &new_ext_block);
-            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-
-        mz_zip_array_clear(pZip, &new_ext_block);
-    }
-    else
-    {
-        /* sanity checks */
-        if (cur_dst_file_ofs > MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-        if (local_dir_header_ofs >= MZ_UINT32_MAX)
-            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
-
-        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, local_dir_header_ofs);
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_central_dir_following_data_size))
-        {
-            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-        }
-    }
-
-    /* This shouldn't trigger unless we screwed up during the initial sanity checks */
-    if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
-    {
-        /* TODO: Support central dirs >= 32-bits in size */
-        mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-    }
-
-    n = (mz_uint32)orig_central_dir_size;
-    if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1))
-    {
-        mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-    }
-
-    pZip->m_total_files++;
-    pZip->m_archive_size = cur_dst_file_ofs;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip)
-{
-    mz_zip_internal_state *pState;
-    mz_uint64 central_dir_ofs, central_dir_size;
-    mz_uint8 hdr[256];
-
-    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    pState = pZip->m_pState;
-
-    if (pState->m_zip64)
-    {
-        if ((pZip->m_total_files > MZ_UINT32_MAX) || (pState->m_central_dir.m_size >= MZ_UINT32_MAX))
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-    else
-    {
-        if ((pZip->m_total_files > MZ_UINT16_MAX) || ((pZip->m_archive_size + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX))
-            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-    }
-
-    central_dir_ofs = 0;
-    central_dir_size = 0;
-    if (pZip->m_total_files)
-    {
-        /* Write central directory */
-        central_dir_ofs = pZip->m_archive_size;
-        central_dir_size = pState->m_central_dir.m_size;
-        pZip->m_central_directory_file_ofs = central_dir_ofs;
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, central_dir_ofs, pState->m_central_dir.m_p, (size_t)central_dir_size) != central_dir_size)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        pZip->m_archive_size += central_dir_size;
-    }
-
-    if (pState->m_zip64)
-    {
-        /* Write zip64 end of central directory header */
-        mz_uint64 rel_ofs_to_zip64_ecdr = pZip->m_archive_size;
-
-        MZ_CLEAR_OBJ(hdr);
-        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDH_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - sizeof(mz_uint32) - sizeof(mz_uint64));
-        MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, 0x031E); /* TODO: always Unix */
-        MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS, 0x002D);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, pZip->m_total_files);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS, pZip->m_total_files);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_SIZE_OFS, central_dir_size);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_OFS_OFS, central_dir_ofs);
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE;
-
-        /* Write zip64 end of central directory locator */
-        MZ_CLEAR_OBJ(hdr);
-        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG);
-        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, rel_ofs_to_zip64_ecdr);
-        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, 1);
-        if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
-            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-        pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE;
-    }
-
-    /* Write end of central directory record */
-    MZ_CLEAR_OBJ(hdr);
-    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_SIG_OFS, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG);
-    MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files));
-    MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files));
-    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_size));
-    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_ofs));
-
-    if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-
-#ifndef MINIZ_NO_STDIO
-    if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF))
-        return mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-    pZip->m_archive_size += MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE;
-
-    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED;
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize)
-{
-    if ((!ppBuf) || (!pSize))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    *ppBuf = NULL;
-    *pSize = 0;
-
-    if ((!pZip) || (!pZip->m_pState))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (pZip->m_pWrite != mz_zip_heap_write_func)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    if (!mz_zip_writer_finalize_archive(pZip))
-        return MZ_FALSE;
-
-    *ppBuf = pZip->m_pState->m_pMem;
-    *pSize = pZip->m_pState->m_mem_size;
-    pZip->m_pState->m_pMem = NULL;
-    pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0;
-
-    return MZ_TRUE;
-}
-
-mz_bool mz_zip_writer_end(mz_zip_archive *pZip)
-{
-    return mz_zip_writer_end_internal(pZip, MZ_TRUE);
-}
-
-#ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
-{
-    return mz_zip_add_mem_to_archive_file_in_place_v2(pZip_filename, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, NULL);
-}
-
-mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr)
-{
-    mz_bool status, created_new_archive = MZ_FALSE;
-    mz_zip_archive zip_archive;
-    struct MZ_FILE_STAT_STRUCT file_stat;
-    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
-
-    mz_zip_zero_struct(&zip_archive);
-    if ((int)level_and_flags < 0)
-        level_and_flags = MZ_DEFAULT_LEVEL;
-
-    if ((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) > MZ_UBER_COMPRESSION))
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_PARAMETER;
-        return MZ_FALSE;
-    }
-
-    if (!mz_zip_writer_validate_archive_name(pArchive_name))
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_FILENAME;
-        return MZ_FALSE;
-    }
-
-    /* Important: The regular non-64 bit version of stat() can fail here if the file is very large, which could cause the archive to be overwritten. */
-    /* So be sure to compile with _LARGEFILE64_SOURCE 1 */
-    if (MZ_FILE_STAT(pZip_filename, &file_stat) != 0)
-    {
-        /* Create a new archive. */
-        if (!mz_zip_writer_init_file_v2(&zip_archive, pZip_filename, 0, level_and_flags))
-        {
-            if (pErr)
-                *pErr = zip_archive.m_last_error;
-            return MZ_FALSE;
-        }
-
-        created_new_archive = MZ_TRUE;
-    }
-    else
-    {
-        /* Append to an existing archive. */
-        if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, level_and_flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
-        {
-            if (pErr)
-                *pErr = zip_archive.m_last_error;
-            return MZ_FALSE;
-        }
-
-        if (!mz_zip_writer_init_from_reader_v2(&zip_archive, pZip_filename, level_and_flags))
-        {
-            if (pErr)
-                *pErr = zip_archive.m_last_error;
-
-            mz_zip_reader_end_internal(&zip_archive, MZ_FALSE);
-
-            return MZ_FALSE;
-        }
-    }
-
-    status = mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0);
-    actual_err = zip_archive.m_last_error;
-
-    /* Always finalize, even if adding failed for some reason, so we have a valid central directory. (This may not always succeed, but we can try.) */
-    if (!mz_zip_writer_finalize_archive(&zip_archive))
-    {
-        if (!actual_err)
-            actual_err = zip_archive.m_last_error;
-
-        status = MZ_FALSE;
-    }
-
-    if (!mz_zip_writer_end_internal(&zip_archive, status))
-    {
-        if (!actual_err)
-            actual_err = zip_archive.m_last_error;
-
-        status = MZ_FALSE;
-    }
-
-    if ((!status) && (created_new_archive))
-    {
-        /* It's a new archive and something went wrong, so just delete it. */
-        int ignoredStatus = MZ_DELETE_FILE(pZip_filename);
-        (void)ignoredStatus;
-    }
-
-    if (pErr)
-        *pErr = actual_err;
-
-    return status;
-}
-
-void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr)
-{
-    mz_uint32 file_index;
-    mz_zip_archive zip_archive;
-    void *p = NULL;
-
-    if (pSize)
-        *pSize = 0;
-
-    if ((!pZip_filename) || (!pArchive_name))
-    {
-        if (pErr)
-            *pErr = MZ_ZIP_INVALID_PARAMETER;
-
-        return NULL;
-    }
-
-    mz_zip_zero_struct(&zip_archive);
-    if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
-    {
-        if (pErr)
-            *pErr = zip_archive.m_last_error;
-
-        return NULL;
-    }
-
-    if (mz_zip_reader_locate_file_v2(&zip_archive, pArchive_name, pComment, flags, &file_index))
-    {
-        p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags);
-    }
-
-    mz_zip_reader_end_internal(&zip_archive, p != NULL);
-
-    if (pErr)
-        *pErr = zip_archive.m_last_error;
-
-    return p;
-}
-
-void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags)
-{
-    return mz_zip_extract_archive_file_to_heap_v2(pZip_filename, pArchive_name, NULL, pSize, flags, NULL);
-}
-
-#endif /* #ifndef MINIZ_NO_STDIO */
-
-#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-/* ------------------- Misc utils */
-
-mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip)
-{
-    return pZip ? pZip->m_zip_mode : MZ_ZIP_MODE_INVALID;
-}
-
-mz_zip_type mz_zip_get_type(mz_zip_archive *pZip)
-{
-    return pZip ? pZip->m_zip_type : MZ_ZIP_TYPE_INVALID;
-}
-
-mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num)
-{
-    mz_zip_error prev_err;
-
-    if (!pZip)
-        return MZ_ZIP_INVALID_PARAMETER;
-
-    prev_err = pZip->m_last_error;
-
-    pZip->m_last_error = err_num;
-    return prev_err;
-}
-
-mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip)
-{
-    if (!pZip)
-        return MZ_ZIP_INVALID_PARAMETER;
-
-    return pZip->m_last_error;
-}
-
-mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip)
-{
-    return mz_zip_set_last_error(pZip, MZ_ZIP_NO_ERROR);
-}
-
-mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip)
-{
-    mz_zip_error prev_err;
-
-    if (!pZip)
-        return MZ_ZIP_INVALID_PARAMETER;
-
-    prev_err = pZip->m_last_error;
-
-    pZip->m_last_error = MZ_ZIP_NO_ERROR;
-    return prev_err;
-}
-
-const char *mz_zip_get_error_string(mz_zip_error mz_err)
-{
-    switch (mz_err)
-    {
-        case MZ_ZIP_NO_ERROR:
-            return "no error";
-        case MZ_ZIP_UNDEFINED_ERROR:
-            return "undefined error";
-        case MZ_ZIP_TOO_MANY_FILES:
-            return "too many files";
-        case MZ_ZIP_FILE_TOO_LARGE:
-            return "file too large";
-        case MZ_ZIP_UNSUPPORTED_METHOD:
-            return "unsupported method";
-        case MZ_ZIP_UNSUPPORTED_ENCRYPTION:
-            return "unsupported encryption";
-        case MZ_ZIP_UNSUPPORTED_FEATURE:
-            return "unsupported feature";
-        case MZ_ZIP_FAILED_FINDING_CENTRAL_DIR:
-            return "failed finding central directory";
-        case MZ_ZIP_NOT_AN_ARCHIVE:
-            return "not a ZIP archive";
-        case MZ_ZIP_INVALID_HEADER_OR_CORRUPTED:
-            return "invalid header or archive is corrupted";
-        case MZ_ZIP_UNSUPPORTED_MULTIDISK:
-            return "unsupported multidisk archive";
-        case MZ_ZIP_DECOMPRESSION_FAILED:
-            return "decompression failed or archive is corrupted";
-        case MZ_ZIP_COMPRESSION_FAILED:
-            return "compression failed";
-        case MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE:
-            return "unexpected decompressed size";
-        case MZ_ZIP_CRC_CHECK_FAILED:
-            return "CRC-32 check failed";
-        case MZ_ZIP_UNSUPPORTED_CDIR_SIZE:
-            return "unsupported central directory size";
-        case MZ_ZIP_ALLOC_FAILED:
-            return "allocation failed";
-        case MZ_ZIP_FILE_OPEN_FAILED:
-            return "file open failed";
-        case MZ_ZIP_FILE_CREATE_FAILED:
-            return "file create failed";
-        case MZ_ZIP_FILE_WRITE_FAILED:
-            return "file write failed";
-        case MZ_ZIP_FILE_READ_FAILED:
-            return "file read failed";
-        case MZ_ZIP_FILE_CLOSE_FAILED:
-            return "file close failed";
-        case MZ_ZIP_FILE_SEEK_FAILED:
-            return "file seek failed";
-        case MZ_ZIP_FILE_STAT_FAILED:
-            return "file stat failed";
-        case MZ_ZIP_INVALID_PARAMETER:
-            return "invalid parameter";
-        case MZ_ZIP_INVALID_FILENAME:
-            return "invalid filename";
-        case MZ_ZIP_BUF_TOO_SMALL:
-            return "buffer too small";
-        case MZ_ZIP_INTERNAL_ERROR:
-            return "internal error";
-        case MZ_ZIP_FILE_NOT_FOUND:
-            return "file not found";
-        case MZ_ZIP_ARCHIVE_TOO_LARGE:
-            return "archive is too large";
-        case MZ_ZIP_VALIDATION_FAILED:
-            return "validation failed";
-        case MZ_ZIP_WRITE_CALLBACK_FAILED:
-            return "write calledback failed";
-        default:
-            break;
-    }
-
-    return "unknown error";
-}
-
-/* Note: Just because the archive is not zip64 doesn't necessarily mean it doesn't have Zip64 extended information extra field, argh. */
-mz_bool mz_zip_is_zip64(mz_zip_archive *pZip)
-{
-    if ((!pZip) || (!pZip->m_pState))
-        return MZ_FALSE;
-
-    return pZip->m_pState->m_zip64;
-}
-
-size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip)
-{
-    if ((!pZip) || (!pZip->m_pState))
-        return 0;
-
-    return pZip->m_pState->m_central_dir.m_size;
-}
-
-mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip)
-{
-    return pZip ? pZip->m_total_files : 0;
-}
-
-mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip)
-{
-    if (!pZip)
-        return 0;
-    return pZip->m_archive_size;
-}
-
-mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip)
-{
-    if ((!pZip) || (!pZip->m_pState))
-        return 0;
-    return pZip->m_pState->m_file_archive_start_ofs;
-}
-
-MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip)
-{
-    if ((!pZip) || (!pZip->m_pState))
-        return 0;
-    return pZip->m_pState->m_pFile;
-}
-
-size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n)
-{
-    if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
-    return pZip->m_pRead(pZip->m_pIO_opaque, file_ofs, pBuf, n);
-}
-
-mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)
-{
-    mz_uint n;
-    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
-    if (!p)
-    {
-        if (filename_buf_size)
-            pFilename[0] = '\0';
-        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-        return 0;
-    }
-    n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-    if (filename_buf_size)
-    {
-        n = MZ_MIN(n, filename_buf_size - 1);
-        memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
-        pFilename[n] = '\0';
-    }
-    return n + 1;
-}
-
-mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)
-{
-    return mz_zip_file_stat_internal(pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL);
-}
-
-mz_bool mz_zip_end(mz_zip_archive *pZip)
-{
-    if (!pZip)
-        return MZ_FALSE;
-
-    if (pZip->m_zip_mode == MZ_ZIP_MODE_READING)
-        return mz_zip_reader_end(pZip);
-#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
-    else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))
-        return mz_zip_writer_end(pZip);
-#endif
-
-    return MZ_FALSE;
-}
-
-
-
-#endif /*#ifndef MINIZ_NO_ARCHIVE_APIS*/
-} // namespace duckdb_miniz
-
-// LICENSE_CHANGE_END
diff --git a/velox/external/duckdb/duckdb-re2.cpp b/velox/external/duckdb/duckdb-re2.cpp
deleted file mode 100644
index 53df823b17352..0000000000000
--- a/velox/external/duckdb/duckdb-re2.cpp
+++ /dev/null
@@ -1,23035 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Tested by search_test.cc, exhaustive_test.cc, tester.cc
-
-// Prog::SearchBitState is a regular expression search with submatch
-// tracking for small regular expressions and texts.  Similarly to
-// testing/backtrack.cc, it allocates a bitmap with (count of
-// lists) * (length of prog) bits to make sure it never explores the
-// same (instruction list, character position) multiple times.  This
-// limits the search to run in time linear in the length of the text.
-//
-// Unlike testing/backtrack.cc, SearchBitState is not recursive
-// on the text.
-//
-// SearchBitState is a fast replacement for the NFA code on small
-// regexps and texts when SearchOnePass cannot be used.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-#include <limits>
-#include <utility>
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2018 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_POD_ARRAY_H_
-#define UTIL_POD_ARRAY_H_
-
-#include <memory>
-#include <type_traits>
-
-namespace duckdb_re2 {
-
-template <typename T>
-class PODArray {
- public:
-  static_assert(std::is_pod<T>::value,
-                "T must be POD");
-
-  PODArray()
-      : ptr_() {}
-  explicit PODArray(int len)
-      : ptr_(std::allocator<T>().allocate(len), Deleter(len)) {}
-
-  T* data() const {
-    return ptr_.get();
-  }
-
-  int size() const {
-    return ptr_.get_deleter().len_;
-  }
-
-  T& operator[](int pos) const {
-    return ptr_[pos];
-  }
-
- private:
-  struct Deleter {
-    Deleter()
-        : len_(0) {}
-    explicit Deleter(int len)
-        : len_(len) {}
-
-    void operator()(T* ptr) const {
-      std::allocator<T>().deallocate(ptr, len_);
-    }
-
-    int len_;
-  };
-
-  std::unique_ptr<T[], Deleter> ptr_;
-};
-
-}  // namespace duckdb_re2
-
-#endif  // UTIL_POD_ARRAY_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_PROG_H_
-#define RE2_PROG_H_
-
-// Compiled representation of regular expressions.
-// See regexp.h for the Regexp class, which represents a regular
-// expression symbolically.
-
-#include <stdint.h>
-#include <functional>
-#include <mutex>
-#include <string>
-#include <vector>
-#include <type_traits>
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_SPARSE_ARRAY_H_
-#define UTIL_SPARSE_ARRAY_H_
-
-// DESCRIPTION
-//
-// SparseArray<T>(m) is a map from integers in [0, m) to T values.
-// It requires (sizeof(T)+sizeof(int))*m memory, but it provides
-// fast iteration through the elements in the array and fast clearing
-// of the array.  The array has a concept of certain elements being
-// uninitialized (having no value).
-//
-// Insertion and deletion are constant time operations.
-//
-// Allocating the array is a constant time operation
-// when memory allocation is a constant time operation.
-//
-// Clearing the array is a constant time operation (unusual!).
-//
-// Iterating through the array is an O(n) operation, where n
-// is the number of items in the array (not O(m)).
-//
-// The array iterator visits entries in the order they were first
-// inserted into the array.  It is safe to add items to the array while
-// using an iterator: the iterator will visit indices added to the array
-// during the iteration, but will not re-visit indices whose values
-// change after visiting.  Thus SparseArray can be a convenient
-// implementation of a work queue.
-//
-// The SparseArray implementation is NOT thread-safe.  It is up to the
-// caller to make sure only one thread is accessing the array.  (Typically
-// these arrays are temporary values and used in situations where speed is
-// important.)
-//
-// The SparseArray interface does not present all the usual STL bells and
-// whistles.
-//
-// Implemented with reference to Briggs & Torczon, An Efficient
-// Representation for Sparse Sets, ACM Letters on Programming Languages
-// and Systems, Volume 2, Issue 1-4 (March-Dec.  1993), pp.  59-69.
-//
-// Briggs & Torczon popularized this technique, but it had been known
-// long before their paper.  They point out that Aho, Hopcroft, and
-// Ullman's 1974 Design and Analysis of Computer Algorithms and Bentley's
-// 1986 Programming Pearls both hint at the technique in exercises to the
-// reader (in Aho & Hopcroft, exercise 2.12; in Bentley, column 1
-// exercise 8).
-//
-// Briggs & Torczon describe a sparse set implementation.  I have
-// trivially generalized it to create a sparse array (actually the original
-// target of the AHU and Bentley exercises).
-
-// IMPLEMENTATION
-//
-// SparseArray is an array dense_ and an array sparse_ of identical size.
-// At any point, the number of elements in the sparse array is size_.
-//
-// The array dense_ contains the size_ elements in the sparse array (with
-// their indices),
-// in the order that the elements were first inserted.  This array is dense:
-// the size_ pairs are dense_[0] through dense_[size_-1].
-//
-// The array sparse_ maps from indices in [0,m) to indices in [0,size_).
-// For indices present in the array, dense_[sparse_[i]].index_ == i.
-// For indices not present in the array, sparse_ can contain any value at all,
-// perhaps outside the range [0, size_) but perhaps not.
-//
-// The lax requirement on sparse_ values makes clearing the array very easy:
-// set size_ to 0.  Lookups are slightly more complicated.
-// An index i has a value in the array if and only if:
-//   sparse_[i] is in [0, size_) AND
-//   dense_[sparse_[i]].index_ == i.
-// If both these properties hold, only then it is safe to refer to
-//   dense_[sparse_[i]].value_
-// as the value associated with index i.
-//
-// To insert a new entry, set sparse_[i] to size_,
-// initialize dense_[size_], and then increment size_.
-//
-// To make the sparse array as efficient as possible for non-primitive types,
-// elements may or may not be destroyed when they are deleted from the sparse
-// array through a call to resize(). They immediately become inaccessible, but
-// they are only guaranteed to be destroyed when the SparseArray destructor is
-// called.
-//
-// A moved-from SparseArray will be empty.
-
-// Doing this simplifies the logic below.
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#include <assert.h>
-#include <stdint.h>
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#endif
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-
-
-namespace duckdb_re2 {
-
-template<typename Value>
-class SparseArray {
- public:
-  SparseArray();
-  explicit SparseArray(int max_size);
-  ~SparseArray();
-
-  // IndexValue pairs: exposed in SparseArray::iterator.
-  class IndexValue;
-
-  typedef IndexValue* iterator;
-  typedef const IndexValue* const_iterator;
-
-  SparseArray(const SparseArray& src);
-  SparseArray(SparseArray&& src);
-
-  SparseArray& operator=(const SparseArray& src);
-  SparseArray& operator=(SparseArray&& src);
-
-  // Return the number of entries in the array.
-  int size() const {
-    return size_;
-  }
-
-  // Indicate whether the array is empty.
-  int empty() const {
-    return size_ == 0;
-  }
-
-  // Iterate over the array.
-  iterator begin() {
-    return dense_.data();
-  }
-  iterator end() {
-    return dense_.data() + size_;
-  }
-
-  const_iterator begin() const {
-    return dense_.data();
-  }
-  const_iterator end() const {
-    return dense_.data() + size_;
-  }
-
-  // Change the maximum size of the array.
-  // Invalidates all iterators.
-  void resize(int new_max_size);
-
-  // Return the maximum size of the array.
-  // Indices can be in the range [0, max_size).
-  int max_size() const {
-    if (dense_.data() != NULL)
-      return dense_.size();
-    else
-      return 0;
-  }
-
-  // Clear the array.
-  void clear() {
-    size_ = 0;
-  }
-
-  // Check whether index i is in the array.
-  bool has_index(int i) const;
-
-  // Comparison function for sorting.
-  // Can sort the sparse array so that future iterations
-  // will visit indices in increasing order using
-  // std::sort(arr.begin(), arr.end(), arr.less);
-  static bool less(const IndexValue& a, const IndexValue& b);
-
- public:
-  // Set the value at index i to v.
-  iterator set(int i, const Value& v) {
-    return SetInternal(true, i, v);
-  }
-
-  // Set the value at new index i to v.
-  // Fast but unsafe: only use if has_index(i) is false.
-  iterator set_new(int i, const Value& v) {
-    return SetInternal(false, i, v);
-  }
-
-  // Set the value at index i to v.
-  // Fast but unsafe: only use if has_index(i) is true.
-  iterator set_existing(int i, const Value& v) {
-    return SetExistingInternal(i, v);
-  }
-
-  // Get the value at index i.
-  // Fast but unsafe: only use if has_index(i) is true.
-  Value& get_existing(int i) {
-    assert(has_index(i));
-    return dense_[sparse_[i]].value_;
-  }
-  const Value& get_existing(int i) const {
-    assert(has_index(i));
-    return dense_[sparse_[i]].value_;
-  }
-
- private:
-  iterator SetInternal(bool allow_existing, int i, const Value& v) {
-    DebugCheckInvariants();
-    if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-      assert(false && "illegal index");
-      // Semantically, end() would be better here, but we already know
-      // the user did something stupid, so begin() insulates them from
-      // dereferencing an invalid pointer.
-      return begin();
-    }
-    if (!allow_existing) {
-      assert(!has_index(i));
-      create_index(i);
-    } else {
-      if (!has_index(i))
-        create_index(i);
-    }
-    return SetExistingInternal(i, v);
-  }
-
-  iterator SetExistingInternal(int i, const Value& v) {
-    DebugCheckInvariants();
-    assert(has_index(i));
-    dense_[sparse_[i]].value_ = v;
-    DebugCheckInvariants();
-    return dense_.data() + sparse_[i];
-  }
-
-  // Add the index i to the array.
-  // Only use if has_index(i) is known to be false.
-  // Since it doesn't set the value associated with i,
-  // this function is private, only intended as a helper
-  // for other methods.
-  void create_index(int i);
-
-  // In debug mode, verify that some invariant properties of the class
-  // are being maintained. This is called at the end of the constructor
-  // and at the beginning and end of all public non-const member functions.
-  void DebugCheckInvariants() const;
-
-  // Initializes memory for elements [min, max).
-  void MaybeInitializeMemory(int min, int max) {
-#if __has_feature(memory_sanitizer)
-    __msan_unpoison(sparse_.data() + min, (max - min) * sizeof sparse_[0]);
-#elif defined(RE2_ON_VALGRIND)
-    for (int i = min; i < max; i++) {
-      sparse_[i] = 0xababababU;
-    }
-#endif
-  }
-
-  int size_ = 0;
-  PODArray<int> sparse_;
-  PODArray<IndexValue> dense_;
-};
-
-template<typename Value>
-SparseArray<Value>::SparseArray() = default;
-
-template<typename Value>
-SparseArray<Value>::SparseArray(const SparseArray& src)
-    : size_(src.size_),
-      sparse_(src.max_size()),
-      dense_(src.max_size()) {
-  std::copy_n(src.sparse_.data(), src.max_size(), sparse_.data());
-  std::copy_n(src.dense_.data(), src.max_size(), dense_.data());
-}
-
-template<typename Value>
-SparseArray<Value>::SparseArray(SparseArray&& src)
-    : size_(src.size_),
-      sparse_(std::move(src.sparse_)),
-      dense_(std::move(src.dense_)) {
-  src.size_ = 0;
-}
-
-template<typename Value>
-SparseArray<Value>& SparseArray<Value>::operator=(const SparseArray& src) {
-  // Construct these first for exception safety.
-  PODArray<int> a(src.max_size());
-  PODArray<IndexValue> b(src.max_size());
-
-  size_ = src.size_;
-  sparse_ = std::move(a);
-  dense_ = std::move(b);
-  std::copy_n(src.sparse_.data(), src.max_size(), sparse_.data());
-  std::copy_n(src.dense_.data(), src.max_size(), dense_.data());
-  return *this;
-}
-
-template<typename Value>
-SparseArray<Value>& SparseArray<Value>::operator=(SparseArray&& src) {
-  size_ = src.size_;
-  sparse_ = std::move(src.sparse_);
-  dense_ = std::move(src.dense_);
-  src.size_ = 0;
-  return *this;
-}
-
-// IndexValue pairs: exposed in SparseArray::iterator.
-template<typename Value>
-class SparseArray<Value>::IndexValue {
- public:
-  int index() const { return index_; }
-  Value& value() { return value_; }
-  const Value& value() const { return value_; }
-
- private:
-  friend class SparseArray;
-  int index_;
-  Value value_;
-};
-
-// Change the maximum size of the array.
-// Invalidates all iterators.
-template<typename Value>
-void SparseArray<Value>::resize(int new_max_size) {
-  DebugCheckInvariants();
-  if (new_max_size > max_size()) {
-    const int old_max_size = max_size();
-
-    // Construct these first for exception safety.
-    PODArray<int> a(new_max_size);
-    PODArray<IndexValue> b(new_max_size);
-
-    std::copy_n(sparse_.data(), old_max_size, a.data());
-    std::copy_n(dense_.data(), old_max_size, b.data());
-
-    sparse_ = std::move(a);
-    dense_ = std::move(b);
-
-    MaybeInitializeMemory(old_max_size, new_max_size);
-  }
-  if (size_ > new_max_size)
-    size_ = new_max_size;
-  DebugCheckInvariants();
-}
-
-// Check whether index i is in the array.
-template<typename Value>
-bool SparseArray<Value>::has_index(int i) const {
-  assert(i >= 0);
-  assert(i < max_size());
-  if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-    return false;
-  }
-  // Unsigned comparison avoids checking sparse_[i] < 0.
-  return (uint32_t)sparse_[i] < (uint32_t)size_ &&
-         dense_[sparse_[i]].index_ == i;
-}
-
-template<typename Value>
-void SparseArray<Value>::create_index(int i) {
-  assert(!has_index(i));
-  assert(size_ < max_size());
-  sparse_[i] = size_;
-  dense_[size_].index_ = i;
-  size_++;
-}
-
-template<typename Value> SparseArray<Value>::SparseArray(int max_size) :
-    sparse_(max_size), dense_(max_size) {
-  MaybeInitializeMemory(size_, max_size);
-  DebugCheckInvariants();
-}
-
-template<typename Value> SparseArray<Value>::~SparseArray() {
-  DebugCheckInvariants();
-}
-
-template<typename Value> void SparseArray<Value>::DebugCheckInvariants() const {
-  assert(0 <= size_);
-  assert(size_ <= max_size());
-}
-
-// Comparison function for sorting.
-template<typename Value> bool SparseArray<Value>::less(const IndexValue& a,
-                                                       const IndexValue& b) {
-  return a.index_ < b.index_;
-}
-
-}  // namespace duckdb_re2
-
-#endif  // UTIL_SPARSE_ARRAY_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_SPARSE_SET_H_
-#define UTIL_SPARSE_SET_H_
-
-// DESCRIPTION
-//
-// SparseSet(m) is a set of integers in [0, m).
-// It requires sizeof(int)*m memory, but it provides
-// fast iteration through the elements in the set and fast clearing
-// of the set.
-//
-// Insertion and deletion are constant time operations.
-//
-// Allocating the set is a constant time operation
-// when memory allocation is a constant time operation.
-//
-// Clearing the set is a constant time operation (unusual!).
-//
-// Iterating through the set is an O(n) operation, where n
-// is the number of items in the set (not O(m)).
-//
-// The set iterator visits entries in the order they were first
-// inserted into the set.  It is safe to add items to the set while
-// using an iterator: the iterator will visit indices added to the set
-// during the iteration, but will not re-visit indices whose values
-// change after visiting.  Thus SparseSet can be a convenient
-// implementation of a work queue.
-//
-// The SparseSet implementation is NOT thread-safe.  It is up to the
-// caller to make sure only one thread is accessing the set.  (Typically
-// these sets are temporary values and used in situations where speed is
-// important.)
-//
-// The SparseSet interface does not present all the usual STL bells and
-// whistles.
-//
-// Implemented with reference to Briggs & Torczon, An Efficient
-// Representation for Sparse Sets, ACM Letters on Programming Languages
-// and Systems, Volume 2, Issue 1-4 (March-Dec.  1993), pp.  59-69.
-//
-// This is a specialization of sparse array; see sparse_array.h.
-
-// IMPLEMENTATION
-//
-// See sparse_array.h for implementation details.
-
-// Doing this simplifies the logic below.
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#include <assert.h>
-#include <stdint.h>
-#if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
-#endif
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-
-
-namespace duckdb_re2 {
-
-template<typename Value>
-class SparseSetT {
- public:
-  SparseSetT();
-  explicit SparseSetT(int max_size);
-  ~SparseSetT();
-
-  typedef int* iterator;
-  typedef const int* const_iterator;
-
-  // Return the number of entries in the set.
-  int size() const {
-    return size_;
-  }
-
-  // Indicate whether the set is empty.
-  int empty() const {
-    return size_ == 0;
-  }
-
-  // Iterate over the set.
-  iterator begin() {
-    return dense_.data();
-  }
-  iterator end() {
-    return dense_.data() + size_;
-  }
-
-  const_iterator begin() const {
-    return dense_.data();
-  }
-  const_iterator end() const {
-    return dense_.data() + size_;
-  }
-
-  // Change the maximum size of the set.
-  // Invalidates all iterators.
-  void resize(int new_max_size);
-
-  // Return the maximum size of the set.
-  // Indices can be in the range [0, max_size).
-  int max_size() const {
-    if (dense_.data() != NULL)
-      return dense_.size();
-    else
-      return 0;
-  }
-
-  // Clear the set.
-  void clear() {
-    size_ = 0;
-  }
-
-  // Check whether index i is in the set.
-  bool contains(int i) const;
-
-  // Comparison function for sorting.
-  // Can sort the sparse set so that future iterations
-  // will visit indices in increasing order using
-  // std::sort(arr.begin(), arr.end(), arr.less);
-  static bool less(int a, int b);
-
- public:
-  // Insert index i into the set.
-  iterator insert(int i) {
-    return InsertInternal(true, i);
-  }
-
-  // Insert index i into the set.
-  // Fast but unsafe: only use if contains(i) is false.
-  iterator insert_new(int i) {
-    return InsertInternal(false, i);
-  }
-
- private:
-  iterator InsertInternal(bool allow_existing, int i) {
-    DebugCheckInvariants();
-    if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-      assert(false && "illegal index");
-      // Semantically, end() would be better here, but we already know
-      // the user did something stupid, so begin() insulates them from
-      // dereferencing an invalid pointer.
-      return begin();
-    }
-    if (!allow_existing) {
-      assert(!contains(i));
-      create_index(i);
-    } else {
-      if (!contains(i))
-        create_index(i);
-    }
-    DebugCheckInvariants();
-    return dense_.data() + sparse_[i];
-  }
-
-  // Add the index i to the set.
-  // Only use if contains(i) is known to be false.
-  // This function is private, only intended as a helper
-  // for other methods.
-  void create_index(int i);
-
-  // In debug mode, verify that some invariant properties of the class
-  // are being maintained. This is called at the end of the constructor
-  // and at the beginning and end of all public non-const member functions.
-  void DebugCheckInvariants() const;
-
-  // Initializes memory for elements [min, max).
-  void MaybeInitializeMemory(int min, int max) {
-#if __has_feature(memory_sanitizer)
-    __msan_unpoison(sparse_.data() + min, (max - min) * sizeof sparse_[0]);
-#elif defined(RE2_ON_VALGRIND)
-    for (int i = min; i < max; i++) {
-      sparse_[i] = 0xababababU;
-    }
-#endif
-  }
-
-  int size_ = 0;
-  PODArray<int> sparse_;
-  PODArray<int> dense_;
-};
-
-template<typename Value>
-SparseSetT<Value>::SparseSetT() = default;
-
-// Change the maximum size of the set.
-// Invalidates all iterators.
-template<typename Value>
-void SparseSetT<Value>::resize(int new_max_size) {
-  DebugCheckInvariants();
-  if (new_max_size > max_size()) {
-    const int old_max_size = max_size();
-
-    // Construct these first for exception safety.
-    PODArray<int> a(new_max_size);
-    PODArray<int> b(new_max_size);
-
-    std::copy_n(sparse_.data(), old_max_size, a.data());
-    std::copy_n(dense_.data(), old_max_size, b.data());
-
-    sparse_ = std::move(a);
-    dense_ = std::move(b);
-
-    MaybeInitializeMemory(old_max_size, new_max_size);
-  }
-  if (size_ > new_max_size)
-    size_ = new_max_size;
-  DebugCheckInvariants();
-}
-
-// Check whether index i is in the set.
-template<typename Value>
-bool SparseSetT<Value>::contains(int i) const {
-  assert(i >= 0);
-  assert(i < max_size());
-  if (static_cast<uint32_t>(i) >= static_cast<uint32_t>(max_size())) {
-    return false;
-  }
-  // Unsigned comparison avoids checking sparse_[i] < 0.
-  return (uint32_t)sparse_[i] < (uint32_t)size_ &&
-         dense_[sparse_[i]] == i;
-}
-
-template<typename Value>
-void SparseSetT<Value>::create_index(int i) {
-  assert(!contains(i));
-  assert(size_ < max_size());
-  sparse_[i] = size_;
-  dense_[size_] = i;
-  size_++;
-}
-
-template<typename Value> SparseSetT<Value>::SparseSetT(int max_size) :
-    sparse_(max_size), dense_(max_size) {
-  MaybeInitializeMemory(size_, max_size);
-  DebugCheckInvariants();
-}
-
-template<typename Value> SparseSetT<Value>::~SparseSetT() {
-  DebugCheckInvariants();
-}
-
-template<typename Value> void SparseSetT<Value>::DebugCheckInvariants() const {
-  assert(0 <= size_);
-  assert(size_ <= max_size());
-}
-
-// Comparison function for sorting.
-template<typename Value> bool SparseSetT<Value>::less(int a, int b) {
-  return a < b;
-}
-
-typedef SparseSetT<void> SparseSet;
-
-}  // namespace duckdb_re2
-
-#endif  // UTIL_SPARSE_SET_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-namespace duckdb_re2 {
-
-// Opcodes for Inst
-enum InstOp {
-  kInstAlt = 0,      // choose between out_ and out1_
-  kInstAltMatch,     // Alt: out_ is [00-FF] and back, out1_ is match; or vice versa.
-  kInstByteRange,    // next (possible case-folded) byte must be in [lo_, hi_]
-  kInstCapture,      // capturing parenthesis number cap_
-  kInstEmptyWidth,   // empty-width special (^ $ ...); bit(s) set in empty_
-  kInstMatch,        // found a match!
-  kInstNop,          // no-op; occasionally unavoidable
-  kInstFail,         // never match; occasionally unavoidable
-  kNumInst,
-};
-
-// Bit flags for empty-width specials
-enum EmptyOp {
-  kEmptyBeginLine        = 1<<0,      // ^ - beginning of line
-  kEmptyEndLine          = 1<<1,      // $ - end of line
-  kEmptyBeginText        = 1<<2,      // \A - beginning of text
-  kEmptyEndText          = 1<<3,      // \z - end of text
-  kEmptyWordBoundary     = 1<<4,      // \b - word boundary
-  kEmptyNonWordBoundary  = 1<<5,      // \B - not \b
-  kEmptyAllFlags         = (1<<6)-1,
-};
-
-struct inst_byte_range_data_t {             // opcode == kInstByteRange
-    uint8_t lo_;       //   byte range is lo_-hi_ inclusive
-    uint8_t hi_;       //
-    uint16_t hint_foldcase_;  // 15 bits: hint, 1 (low) bit: foldcase
-    //   hint to execution engines: the delta to the
-    //   next instruction (in the current list) worth
-    //   exploring iff this instruction matched; 0
-    //   means there are no remaining possibilities,
-    //   which is most likely for character classes.
-    //   foldcase: A-Z -> a-z before checking range.
-} ;
-
-class DFA;
-class Regexp;
-
-// Compiled form of regexp program.
-class Prog {
- public:
-  Prog();
-  ~Prog();
-
-  // Single instruction in regexp program.
-  class Inst {
-   public:
-    // See the assertion below for why this is so.
-    Inst() = default;
-
-    // Copyable.
-    Inst(const Inst&) = default;
-    Inst& operator=(const Inst&) = default;
-
-    // Constructors per opcode
-    void InitAlt(uint32_t out, uint32_t out1);
-    void InitByteRange(int lo, int hi, int foldcase, uint32_t out);
-    void InitCapture(int cap, uint32_t out);
-    void InitEmptyWidth(EmptyOp empty, uint32_t out);
-    void InitMatch(int id);
-    void InitNop(uint32_t out);
-    void InitFail();
-
-    // Getters
-    int id(Prog* p) { return static_cast<int>(this - p->inst_.data()); }
-    InstOp opcode() { return static_cast<InstOp>(out_opcode_&7); }
-    int last()      { return (out_opcode_>>3)&1; }
-    int out()       { return out_opcode_>>4; }
-    int out1()      { DCHECK(opcode() == kInstAlt || opcode() == kInstAltMatch); return out1_; }
-    int cap()       { DCHECK_EQ(opcode(), kInstCapture); return cap_; }
-    int lo()        { DCHECK_EQ(opcode(), kInstByteRange); return inst_byte_range_data_.lo_; }
-    int hi()        { DCHECK_EQ(opcode(), kInstByteRange); return inst_byte_range_data_.hi_; }
-    int foldcase()  { DCHECK_EQ(opcode(), kInstByteRange); return inst_byte_range_data_.hint_foldcase_&1; }
-    int hint()      { DCHECK_EQ(opcode(), kInstByteRange); return inst_byte_range_data_.hint_foldcase_>>1; }
-    int match_id()  { DCHECK_EQ(opcode(), kInstMatch); return match_id_; }
-    EmptyOp empty() { DCHECK_EQ(opcode(), kInstEmptyWidth); return empty_; }
-
-    bool greedy(Prog* p) {
-      DCHECK_EQ(opcode(), kInstAltMatch);
-      return p->inst(out())->opcode() == kInstByteRange ||
-             (p->inst(out())->opcode() == kInstNop &&
-              p->inst(p->inst(out())->out())->opcode() == kInstByteRange);
-    }
-
-    // Does this inst (an kInstByteRange) match c?
-    inline bool Matches(int c) {
-      DCHECK_EQ(opcode(), kInstByteRange);
-      if (foldcase() && 'A' <= c && c <= 'Z')
-        c += 'a' - 'A';
-      return inst_byte_range_data_.lo_ <= c && c <= inst_byte_range_data_.hi_;
-    }
-
-    // Returns string representation for debugging.
-    std::string Dump();
-
-    // Maximum instruction id.
-    // (Must fit in out_opcode_. PatchList/last steal another bit.)
-    static const int kMaxInst = (1<<28) - 1;
-
-   private:
-    void set_opcode(InstOp opcode) {
-      out_opcode_ = (out()<<4) | (last()<<3) | opcode;
-    }
-
-    void set_last() {
-      out_opcode_ = (out()<<4) | (1<<3) | opcode();
-    }
-
-    void set_out(int out) {
-      out_opcode_ = (out<<4) | (last()<<3) | opcode();
-    }
-
-    void set_out_opcode(int out, InstOp opcode) {
-      out_opcode_ = (out<<4) | (last()<<3) | opcode;
-    }
-
-    uint32_t out_opcode_;  // 28 bits: out, 1 bit: last, 3 (low) bits: opcode
-    union {                // additional instruction arguments:
-      uint32_t out1_;      // opcode == kInstAlt
-                           //   alternate next instruction
-
-      int32_t cap_;        // opcode == kInstCapture
-                           //   Index of capture register (holds text
-                           //   position recorded by capturing parentheses).
-                           //   For \n (the submatch for the nth parentheses),
-                           //   the left parenthesis captures into register 2*n
-                           //   and the right one captures into register 2*n+1.
-
-      int32_t match_id_;   // opcode == kInstMatch
-                           //   Match ID to identify this match (for duckdb_re2::Set).
-
-      struct inst_byte_range_data_t inst_byte_range_data_;
-
-      EmptyOp empty_;       // opcode == kInstEmptyWidth
-                            //   empty_ is bitwise OR of kEmpty* flags above.
-    };
-
-    friend class Compiler;
-    friend struct PatchList;
-    friend class Prog;
-  };
-
-  // Inst must be trivial so that we can freely clear it with memset(3).
-  // Arrays of Inst are initialised by copying the initial elements with
-  // memmove(3) and then clearing any remaining elements with memset(3).
-  static_assert(std::is_trivial<Inst>::value, "Inst must be trivial");
-
-  // Whether to anchor the search.
-  enum Anchor {
-    kUnanchored,  // match anywhere
-    kAnchored,    // match only starting at beginning of text
-  };
-
-  // Kind of match to look for (for anchor != kFullMatch)
-  //
-  // kLongestMatch mode finds the overall longest
-  // match but still makes its submatch choices the way
-  // Perl would, not in the way prescribed by POSIX.
-  // The POSIX rules are much more expensive to implement,
-  // and no one has needed them.
-  //
-  // kFullMatch is not strictly necessary -- we could use
-  // kLongestMatch and then check the length of the match -- but
-  // the matching code can run faster if it knows to consider only
-  // full matches.
-  enum MatchKind {
-    kFirstMatch,     // like Perl, PCRE
-    kLongestMatch,   // like egrep or POSIX
-    kFullMatch,      // match only entire text; implies anchor==kAnchored
-    kManyMatch       // for SearchDFA, records set of matches
-  };
-
-  Inst *inst(int id) { return &inst_[id]; }
-  int start() { return start_; }
-  int start_unanchored() { return start_unanchored_; }
-  void set_start(int start) { start_ = start; }
-  void set_start_unanchored(int start) { start_unanchored_ = start; }
-  int size() { return size_; }
-  bool reversed() { return reversed_; }
-  void set_reversed(bool reversed) { reversed_ = reversed; }
-  int list_count() { return list_count_; }
-  int inst_count(InstOp op) { return inst_count_[op]; }
-  uint16_t* list_heads() { return list_heads_.data(); }
-  void set_dfa_mem(int64_t dfa_mem) { dfa_mem_ = dfa_mem; }
-  int64_t dfa_mem() { return dfa_mem_; }
-  int flags() { return flags_; }
-  void set_flags(int flags) { flags_ = flags; }
-  bool anchor_start() { return anchor_start_; }
-  void set_anchor_start(bool b) { anchor_start_ = b; }
-  bool anchor_end() { return anchor_end_; }
-  void set_anchor_end(bool b) { anchor_end_ = b; }
-  int bytemap_range() { return bytemap_range_; }
-  const uint8_t* bytemap() { return bytemap_; }
-
-  // Lazily computed.
-  int first_byte();
-
-  // Returns string representation of program for debugging.
-  std::string Dump();
-  std::string DumpUnanchored();
-  std::string DumpByteMap();
-
-  // Returns the set of kEmpty flags that are in effect at
-  // position p within context.
-  static uint32_t EmptyFlags(const StringPiece& context, const char* p);
-
-  // Returns whether byte c is a word character: ASCII only.
-  // Used by the implementation of \b and \B.
-  // This is not right for Unicode, but:
-  //   - it's hard to get right in a byte-at-a-time matching world
-  //     (the DFA has only one-byte lookahead).
-  //   - even if the lookahead were possible, the Progs would be huge.
-  // This crude approximation is the same one PCRE uses.
-  static bool IsWordChar(uint8_t c) {
-    return ('A' <= c && c <= 'Z') ||
-           ('a' <= c && c <= 'z') ||
-           ('0' <= c && c <= '9') ||
-           c == '_';
-  }
-
-  // Execution engines.  They all search for the regexp (run the prog)
-  // in text, which is in the larger context (used for ^ $ \b etc).
-  // Anchor and kind control the kind of search.
-  // Returns true if match found, false if not.
-  // If match found, fills match[0..nmatch-1] with submatch info.
-  // match[0] is overall match, match[1] is first set of parens, etc.
-  // If a particular submatch is not matched during the regexp match,
-  // it is set to NULL.
-  //
-  // Matching text == StringPiece(NULL, 0) is treated as any other empty
-  // string, but note that on return, it will not be possible to distinguish
-  // submatches that matched that empty string from submatches that didn't
-  // match anything.  Either way, match[i] == NULL.
-
-  // Search using NFA: can find submatches but kind of slow.
-  bool SearchNFA(const StringPiece& text, const StringPiece& context,
-                 Anchor anchor, MatchKind kind,
-                 StringPiece* match, int nmatch);
-
-  // Search using DFA: much faster than NFA but only finds
-  // end of match and can use a lot more memory.
-  // Returns whether a match was found.
-  // If the DFA runs out of memory, sets *failed to true and returns false.
-  // If matches != NULL and kind == kManyMatch and there is a match,
-  // SearchDFA fills matches with the match IDs of the final matching state.
-  bool SearchDFA(const StringPiece& text, const StringPiece& context,
-                 Anchor anchor, MatchKind kind, StringPiece* match0,
-                 bool* failed, SparseSet* matches);
-
-  // The callback issued after building each DFA state with BuildEntireDFA().
-  // If next is null, then the memory budget has been exhausted and building
-  // will halt. Otherwise, the state has been built and next points to an array
-  // of bytemap_range()+1 slots holding the next states as per the bytemap and
-  // kByteEndText. The number of the state is implied by the callback sequence:
-  // the first callback is for state 0, the second callback is for state 1, ...
-  // match indicates whether the state is a matching state.
-  using DFAStateCallback = std::function<void(const int* next, bool match)>;
-
-  // Build the entire DFA for the given match kind.
-  // Usually the DFA is built out incrementally, as needed, which
-  // avoids lots of unnecessary work.
-  // If cb is not empty, it receives one callback per state built.
-  // Returns the number of states built.
-  // FOR TESTING OR EXPERIMENTAL PURPOSES ONLY.
-  int BuildEntireDFA(MatchKind kind, const DFAStateCallback& cb);
-
-  // Controls whether the DFA should bail out early if the NFA would be faster.
-  // FOR TESTING ONLY.
-  static void TEST_dfa_should_bail_when_slow(bool b);
-
-  // Compute bytemap.
-  void ComputeByteMap();
-
-  // Computes whether all matches must begin with the same first
-  // byte, and if so, returns that byte.  If not, returns -1.
-  int ComputeFirstByte();
-
-  // Run peep-hole optimizer on program.
-  void Optimize();
-
-  // One-pass NFA: only correct if IsOnePass() is true,
-  // but much faster than NFA (competitive with PCRE)
-  // for those expressions.
-  bool IsOnePass();
-  bool SearchOnePass(const StringPiece& text, const StringPiece& context,
-                     Anchor anchor, MatchKind kind,
-                     StringPiece* match, int nmatch);
-
-  // Bit-state backtracking.  Fast on small cases but uses memory
-  // proportional to the product of the list count and the text size.
-  bool CanBitState() { return list_heads_.data() != NULL; }
-  bool SearchBitState(const StringPiece& text, const StringPiece& context,
-                      Anchor anchor, MatchKind kind,
-                      StringPiece* match, int nmatch);
-
-  static const int kMaxOnePassCapture = 5;  // $0 through $4
-
-  // Backtracking search: the gold standard against which the other
-  // implementations are checked.  FOR TESTING ONLY.
-  // It allocates a ton of memory to avoid running forever.
-  // It is also recursive, so can't use in production (will overflow stacks).
-  // The name "Unsafe" here is supposed to be a flag that
-  // you should not be using this function.
-  bool UnsafeSearchBacktrack(const StringPiece& text,
-                             const StringPiece& context,
-                             Anchor anchor, MatchKind kind,
-                             StringPiece* match, int nmatch);
-
-  // Computes range for any strings matching regexp. The min and max can in
-  // some cases be arbitrarily precise, so the caller gets to specify the
-  // maximum desired length of string returned.
-  //
-  // Assuming PossibleMatchRange(&min, &max, N) returns successfully, any
-  // string s that is an anchored match for this regexp satisfies
-  //   min <= s && s <= max.
-  //
-  // Note that PossibleMatchRange() will only consider the first copy of an
-  // infinitely repeated element (i.e., any regexp element followed by a '*' or
-  // '+' operator). Regexps with "{N}" constructions are not affected, as those
-  // do not compile down to infinite repetitions.
-  //
-  // Returns true on success, false on error.
-  bool PossibleMatchRange(std::string* min, std::string* max, int maxlen);
-
-  // EXPERIMENTAL! SUBJECT TO CHANGE!
-  // Outputs the program fanout into the given sparse array.
-  void Fanout(SparseArray<int>* fanout);
-
-  // Compiles a collection of regexps to Prog.  Each regexp will have
-  // its own Match instruction recording the index in the output vector.
-  static Prog* CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem);
-
-  // Flattens the Prog from "tree" form to "list" form. This is an in-place
-  // operation in the sense that the old instructions are lost.
-  void Flatten();
-
-  // Walks the Prog; the "successor roots" or predecessors of the reachable
-  // instructions are marked in rootmap or predmap/predvec, respectively.
-  // reachable and stk are preallocated scratch structures.
-  void MarkSuccessors(SparseArray<int>* rootmap,
-                      SparseArray<int>* predmap,
-                      std::vector<std::vector<int>>* predvec,
-                      SparseSet* reachable, std::vector<int>* stk);
-
-  // Walks the Prog from the given "root" instruction; the "dominator root"
-  // of the reachable instructions (if such exists) is marked in rootmap.
-  // reachable and stk are preallocated scratch structures.
-  void MarkDominator(int root, SparseArray<int>* rootmap,
-                     SparseArray<int>* predmap,
-                     std::vector<std::vector<int>>* predvec,
-                     SparseSet* reachable, std::vector<int>* stk);
-
-  // Walks the Prog from the given "root" instruction; the reachable
-  // instructions are emitted in "list" form and appended to flat.
-  // reachable and stk are preallocated scratch structures.
-  void EmitList(int root, SparseArray<int>* rootmap,
-                std::vector<Inst>* flat,
-                SparseSet* reachable, std::vector<int>* stk);
-
-  // Computes hints for ByteRange instructions in [begin, end).
-  void ComputeHints(std::vector<Inst>* flat, int begin, int end);
-
- private:
-  friend class Compiler;
-
-  DFA* GetDFA(MatchKind kind);
-  void DeleteDFA(DFA* dfa);
-
-  bool anchor_start_;       // regexp has explicit start anchor
-  bool anchor_end_;         // regexp has explicit end anchor
-  bool reversed_;           // whether program runs backward over input
-  bool did_flatten_;        // has Flatten been called?
-  bool did_onepass_;        // has IsOnePass been called?
-
-  int start_;               // entry point for program
-  int start_unanchored_;    // unanchored entry point for program
-  int size_;                // number of instructions
-  int bytemap_range_;       // bytemap_[x] < bytemap_range_
-  int first_byte_;          // required first byte for match, or -1 if none
-  int flags_;               // regexp parse flags
-
-  int list_count_;                 // count of lists (see above)
-  int inst_count_[kNumInst];       // count of instructions by opcode
-  PODArray<uint16_t> list_heads_;  // sparse array enumerating list heads
-                                   // not populated if size_ is overly large
-
-  PODArray<Inst> inst_;              // pointer to instruction array
-  PODArray<uint8_t> onepass_nodes_;  // data for OnePass nodes
-
-  int64_t dfa_mem_;         // Maximum memory for DFAs.
-  DFA* dfa_first_;          // DFA cached for kFirstMatch/kManyMatch
-  DFA* dfa_longest_;        // DFA cached for kLongestMatch/kFullMatch
-
-  uint8_t bytemap_[256];    // map from input bytes to byte classes
-
-  std::once_flag first_byte_once_;
-  std::once_flag dfa_first_once_;
-  std::once_flag dfa_longest_once_;
-
-  Prog(const Prog&) = delete;
-  Prog& operator=(const Prog&) = delete;
-};
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_PROG_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-namespace duckdb_re2 {
-
-struct Job {
-  int id;
-  int rle;  // run length encoding
-  const char* p;
-};
-
-class BitState {
- public:
-  explicit BitState(Prog* prog);
-
-  // The usual Search prototype.
-  // Can only call Search once per BitState.
-  bool Search(const StringPiece& text, const StringPiece& context,
-              bool anchored, bool longest,
-              StringPiece* submatch, int nsubmatch);
-
- private:
-  inline bool ShouldVisit(int id, const char* p);
-  void Push(int id, const char* p);
-  void GrowStack();
-  bool TrySearch(int id, const char* p);
-
-  // Search parameters
-  Prog* prog_;              // program being run
-  StringPiece text_;        // text being searched
-  StringPiece context_;     // greater context of text being searched
-  bool anchored_;           // whether search is anchored at text.begin()
-  bool longest_;            // whether search wants leftmost-longest match
-  bool endmatch_;           // whether match must end at text.end()
-  StringPiece* submatch_;   // submatches to fill in
-  int nsubmatch_;           //   # of submatches to fill in
-
-  // Search state
-  static const int VisitedBits = 32;
-  PODArray<uint32_t> visited_;  // bitmap: (list ID, char*) pairs visited
-  PODArray<const char*> cap_;   // capture registers
-  PODArray<Job> job_;           // stack of text positions to explore
-  int njob_;                    // stack size
-};
-
-BitState::BitState(Prog* prog)
-  : prog_(prog),
-    anchored_(false),
-    longest_(false),
-    endmatch_(false),
-    submatch_(NULL),
-    nsubmatch_(0),
-    njob_(0) {
-}
-
-// Given id, which *must* be a list head, we can look up its list ID.
-// Then the question is: Should the search visit the (list ID, p) pair?
-// If so, remember that it was visited so that the next time,
-// we don't repeat the visit.
-bool BitState::ShouldVisit(int id, const char* p) {
-  int n = prog_->list_heads()[id] * static_cast<int>(text_.size()+1) +
-          static_cast<int>(p-text_.begin());
-  if (visited_[n/VisitedBits] & (1 << (n & (VisitedBits-1))))
-    return false;
-  visited_[n/VisitedBits] |= 1 << (n & (VisitedBits-1));
-  return true;
-}
-
-// Grow the stack.
-void BitState::GrowStack() {
-  PODArray<Job> tmp(2*job_.size());
-  memmove(tmp.data(), job_.data(), njob_*sizeof job_[0]);
-  job_ = std::move(tmp);
-}
-
-// Push (id, p) onto the stack, growing it if necessary.
-void BitState::Push(int id, const char* p) {
-  if (njob_ >= job_.size()) {
-    GrowStack();
-    if (njob_ >= job_.size()) {
-      LOG(DFATAL) << "GrowStack() failed: "
-                  << "njob_ = " << njob_ << ", "
-                  << "job_.size() = " << job_.size();
-      return;
-    }
-  }
-
-  // If id < 0, it's undoing a Capture,
-  // so we mustn't interfere with that.
-  if (id >= 0 && njob_ > 0) {
-    Job* top = &job_[njob_-1];
-    if (id == top->id &&
-        p == top->p + top->rle + 1 &&
-        top->rle < std::numeric_limits<int>::max()) {
-      ++top->rle;
-      return;
-    }
-  }
-
-  Job* top = &job_[njob_++];
-  top->id = id;
-  top->rle = 0;
-  top->p = p;
-}
-
-// Try a search from instruction id0 in state p0.
-// Return whether it succeeded.
-bool BitState::TrySearch(int id0, const char* p0) {
-  bool matched = false;
-  const char* end = text_.end();
-  njob_ = 0;
-  // Push() no longer checks ShouldVisit(),
-  // so we must perform the check ourselves.
-  if (ShouldVisit(id0, p0))
-    Push(id0, p0);
-  while (njob_ > 0) {
-    // Pop job off stack.
-    --njob_;
-    int id = job_[njob_].id;
-    int& rle = job_[njob_].rle;
-    const char* p = job_[njob_].p;
-
-    if (id < 0) {
-      // Undo the Capture.
-      cap_[prog_->inst(-id)->cap()] = p;
-      continue;
-    }
-
-    if (rle > 0) {
-      p += rle;
-      // Revivify job on stack.
-      --rle;
-      ++njob_;
-    }
-
-  Loop:
-    // Visit id, p.
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "Unexpected opcode: " << ip->opcode();
-        return false;
-
-      case kInstFail:
-        break;
-
-      case kInstAltMatch:
-        if (ip->greedy(prog_)) {
-          // out1 is the Match instruction.
-          id = ip->out1();
-          p = end;
-          goto Loop;
-        }
-        if (longest_) {
-          // ip must be non-greedy...
-          // out is the Match instruction.
-          id = ip->out();
-          p = end;
-          goto Loop;
-        }
-        goto Next;
-
-      case kInstByteRange: {
-        int c = -1;
-        if (p < end)
-          c = *p & 0xFF;
-        if (!ip->Matches(c))
-          goto Next;
-
-        if (ip->hint() != 0)
-          Push(id+ip->hint(), p);  // try the next when we're done
-        id = ip->out();
-        p++;
-        goto CheckAndLoop;
-      }
-
-      case kInstCapture:
-        if (!ip->last())
-          Push(id+1, p);  // try the next when we're done
-
-        if (0 <= ip->cap() && ip->cap() < cap_.size()) {
-          // Capture p to register, but save old value first.
-          Push(-id, cap_[ip->cap()]);  // undo when we're done
-          cap_[ip->cap()] = p;
-        }
-
-        id = ip->out();
-        goto CheckAndLoop;
-
-      case kInstEmptyWidth:
-        if (ip->empty() & ~Prog::EmptyFlags(context_, p))
-          goto Next;
-
-        if (!ip->last())
-          Push(id+1, p);  // try the next when we're done
-        id = ip->out();
-        goto CheckAndLoop;
-
-      case kInstNop:
-        if (!ip->last())
-          Push(id+1, p);  // try the next when we're done
-        id = ip->out();
-
-      CheckAndLoop:
-        // Sanity check: id is the head of its list, which must
-        // be the case if id-1 is the last of *its* list. :)
-        DCHECK(id == 0 || prog_->inst(id-1)->last());
-        if (ShouldVisit(id, p))
-          goto Loop;
-        break;
-
-      case kInstMatch: {
-        if (endmatch_ && p != end)
-          goto Next;
-
-        // We found a match.  If the caller doesn't care
-        // where the match is, no point going further.
-        if (nsubmatch_ == 0)
-          return true;
-
-        // Record best match so far.
-        // Only need to check end point, because this entire
-        // call is only considering one start position.
-        matched = true;
-        cap_[1] = p;
-        if (submatch_[0].data() == NULL ||
-            (longest_ && p > submatch_[0].end())) {
-          for (int i = 0; i < nsubmatch_; i++)
-            submatch_[i] =
-                StringPiece(cap_[2 * i],
-                            static_cast<size_t>(cap_[2 * i + 1] - cap_[2 * i]));
-        }
-
-        // If going for first match, we're done.
-        if (!longest_)
-          return true;
-
-        // If we used the entire text, no longer match is possible.
-        if (p == end)
-          return true;
-
-        // Otherwise, continue on in hope of a longer match.
-        // Note the absence of the ShouldVisit() check here
-        // due to execution remaining in the same list.
-      Next:
-        if (!ip->last()) {
-          id++;
-          goto Loop;
-        }
-        break;
-      }
-    }
-  }
-  return matched;
-}
-
-// Search text (within context) for prog_.
-bool BitState::Search(const StringPiece& text, const StringPiece& context,
-                      bool anchored, bool longest,
-                      StringPiece* submatch, int nsubmatch) {
-  // Search parameters.
-  text_ = text;
-  context_ = context;
-  if (context_.begin() == NULL)
-    context_ = text;
-  if (prog_->anchor_start() && context_.begin() != text.begin())
-    return false;
-  if (prog_->anchor_end() && context_.end() != text.end())
-    return false;
-  anchored_ = anchored || prog_->anchor_start();
-  longest_ = longest || prog_->anchor_end();
-  endmatch_ = prog_->anchor_end();
-  submatch_ = submatch;
-  nsubmatch_ = nsubmatch;
-  for (int i = 0; i < nsubmatch_; i++)
-    submatch_[i] = StringPiece();
-
-  // Allocate scratch space.
-  int nvisited = prog_->list_count() * static_cast<int>(text.size()+1);
-  nvisited = (nvisited + VisitedBits-1) / VisitedBits;
-  visited_ = PODArray<uint32_t>(nvisited);
-  memset(visited_.data(), 0, nvisited*sizeof visited_[0]);
-
-  int ncap = 2*nsubmatch;
-  if (ncap < 2)
-    ncap = 2;
-  cap_ = PODArray<const char*>(ncap);
-  memset(cap_.data(), 0, ncap*sizeof cap_[0]);
-
-  // When sizeof(Job) == 16, we start with a nice round 1KiB. :)
-  job_ = PODArray<Job>(64);
-
-  // Anchored search must start at text.begin().
-  if (anchored_) {
-    cap_[0] = text.begin();
-    return TrySearch(prog_->start(), text.begin());
-  }
-
-  // Unanchored search, starting from each possible text position.
-  // Notice that we have to try the empty string at the end of
-  // the text, so the loop condition is p <= text.end(), not p < text.end().
-  // This looks like it's quadratic in the size of the text,
-  // but we are not clearing visited_ between calls to TrySearch,
-  // so no work is duplicated and it ends up still being linear.
-  for (const char* p = text.begin(); p <= text.end(); p++) {
-    // Try to use memchr to find the first byte quickly.
-    int fb = prog_->first_byte();
-    if (fb >= 0 && p < text.end() && (p[0] & 0xFF) != fb) {
-      p = reinterpret_cast<const char*>(memchr(p, fb, text.end() - p));
-      if (p == NULL)
-        p = text.end();
-    }
-
-    cap_[0] = p;
-    if (TrySearch(prog_->start(), p))  // Match must be leftmost; done.
-      return true;
-  }
-  return false;
-}
-
-// Bit-state search.
-bool Prog::SearchBitState(const StringPiece& text,
-                          const StringPiece& context,
-                          Anchor anchor,
-                          MatchKind kind,
-                          StringPiece* match,
-                          int nmatch) {
-  // If full match, we ask for an anchored longest match
-  // and then check that match[0] == text.
-  // So make sure match[0] exists.
-  StringPiece sp0;
-  if (kind == kFullMatch) {
-    anchor = kAnchored;
-    if (nmatch < 1) {
-      match = &sp0;
-      nmatch = 1;
-    }
-  }
-
-  // Run the search.
-  BitState b(this);
-  bool anchored = anchor == kAnchored;
-  bool longest = kind != kFirstMatch;
-  if (!b.Search(text, context, anchored, longest, match, nmatch))
-    return false;
-  if (kind == kFullMatch && match[0].end() != text.end())
-    return false;
-  return true;
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Compile regular expression to Prog.
-//
-// Prog and Inst are defined in prog.h.
-// This file's external interface is just Regexp::CompileToProg.
-// The Compiler class defined in this file is private.
-
-#include <stdint.h>
-#include <string.h>
-#include <unordered_map>
-#include <utility>
-
-
-
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_WALKER_INL_H_
-#define RE2_WALKER_INL_H_
-
-// Helper class for traversing Regexps without recursion.
-// Clients should declare their own subclasses that override
-// the PreVisit and PostVisit methods, which are called before
-// and after visiting the subexpressions.
-
-// Not quite the Visitor pattern, because (among other things)
-// the Visitor pattern is recursive.
-
-#include <stack>
-
-
-
-
-namespace duckdb_re2 {
-
-template<typename T> struct WalkState;
-
-template<typename T> class Regexp::Walker {
- public:
-  Walker();
-  virtual ~Walker() {
-    Reset();
-	delete stack_;
-  }
-
-  // Virtual method called before visiting re's children.
-  // PreVisit passes ownership of its return value to its caller.
-  // The Arg* that PreVisit returns will be passed to PostVisit as pre_arg
-  // and passed to the child PreVisits and PostVisits as parent_arg.
-  // At the top-most Regexp, parent_arg is arg passed to walk.
-  // If PreVisit sets *stop to true, the walk does not recurse
-  // into the children.  Instead it behaves as though the return
-  // value from PreVisit is the return value from PostVisit.
-  // The default PreVisit returns parent_arg.
-  virtual T PreVisit(Regexp* re, T parent_arg, bool* stop);
-
-  // Virtual method called after visiting re's children.
-  // The pre_arg is the T that PreVisit returned.
-  // The child_args is a vector of the T that the child PostVisits returned.
-  // PostVisit takes ownership of pre_arg.
-  // PostVisit takes ownership of the Ts
-  // in *child_args, but not the vector itself.
-  // PostVisit passes ownership of its return value
-  // to its caller.
-  // The default PostVisit simply returns pre_arg.
-  virtual T PostVisit(Regexp* re, T parent_arg, T pre_arg,
-                      T* child_args, int nchild_args);
-
-  // Virtual method called to copy a T,
-  // when Walk notices that more than one child is the same re.
-  virtual T Copy(T arg);
-
-  // Virtual method called to do a "quick visit" of the re,
-  // but not its children.  Only called once the visit budget
-  // has been used up and we're trying to abort the walk
-  // as quickly as possible.  Should return a value that
-  // makes sense for the parent PostVisits still to be run.
-  // This function is (hopefully) only called by
-  // WalkExponential, but must be implemented by all clients,
-  // just in case.
-  virtual T ShortVisit(Regexp* re, T parent_arg) = 0;
-
-  // Walks over a regular expression.
-  // Top_arg is passed as parent_arg to PreVisit and PostVisit of re.
-  // Returns the T returned by PostVisit on re.
-  T Walk(Regexp* re, T top_arg);
-
-  // Like Walk, but doesn't use Copy.  This can lead to
-  // exponential runtimes on cross-linked Regexps like the
-  // ones generated by Simplify.  To help limit this,
-  // at most max_visits nodes will be visited and then
-  // the walk will be cut off early.
-  // If the walk *is* cut off early, ShortVisit(re)
-  // will be called on regexps that cannot be fully
-  // visited rather than calling PreVisit/PostVisit.
-  T WalkExponential(Regexp* re, T top_arg, int max_visits);
-
-  // Clears the stack.  Should never be necessary, since
-  // Walk always enters and exits with an empty stack.
-  // Logs DFATAL if stack is not already clear.
-  void Reset();
-
-  // Returns whether walk was cut off.
-  bool stopped_early() { return stopped_early_; }
-
- private:
-  // Walk state for the entire traversal.
-  std::stack<WalkState<T> >* stack_;
-  bool stopped_early_;
-  int max_visits_;
-
-  T WalkInternal(Regexp* re, T top_arg, bool use_copy);
-
-  Walker(const Walker&) = delete;
-  Walker& operator=(const Walker&) = delete;
-};
-
-template<typename T> T Regexp::Walker<T>::PreVisit(Regexp* re,
-                                                   T parent_arg,
-                                                   bool* stop) {
-  return parent_arg;
-}
-
-template<typename T> T Regexp::Walker<T>::PostVisit(Regexp* re,
-                                                    T parent_arg,
-                                                    T pre_arg,
-                                                    T* child_args,
-                                                    int nchild_args) {
-  return pre_arg;
-}
-
-template<typename T> T Regexp::Walker<T>::Copy(T arg) {
-  return arg;
-}
-
-// State about a single level in the traversal.
-template<typename T> struct WalkState {
-  WalkState<T>(Regexp* re, T parent)
-    : re(re),
-      n(-1),
-      parent_arg(parent),
-      child_args(NULL) { }
-
-  Regexp* re;  // The regexp
-  int n;  // The index of the next child to process; -1 means need to PreVisit
-  T parent_arg;  // Accumulated arguments.
-  T pre_arg;
-  T child_arg;  // One-element buffer for child_args.
-  T* child_args;
-};
-
-template<typename T> Regexp::Walker<T>::Walker() {
-  stack_ = new std::stack<WalkState<T> >;
-  stopped_early_ = false;
-}
-
-// Clears the stack.  Should never be necessary, since
-// Walk always enters and exits with an empty stack.
-// Logs DFATAL if stack is not already clear.
-template<typename T> void Regexp::Walker<T>::Reset() {
-  if (stack_ && stack_->size() > 0) {
-    LOG(DFATAL) << "Stack not empty.";
-    while (stack_->size() > 0) {
-      delete stack_->top().child_args;
-      stack_->pop();
-    }
-  }
-}
-
-template<typename T> T Regexp::Walker<T>::WalkInternal(Regexp* re, T top_arg,
-                                                       bool use_copy) {
-  Reset();
-
-  if (re == NULL) {
-    LOG(DFATAL) << "Walk NULL";
-    return top_arg;
-  }
-
-  stack_->push(WalkState<T>(re, top_arg));
-
-  WalkState<T>* s;
-  for (;;) {
-    T t;
-    s = &stack_->top();
-    Regexp* re = s->re;
-    switch (s->n) {
-      case -1: {
-        if (--max_visits_ < 0) {
-          stopped_early_ = true;
-          t = ShortVisit(re, s->parent_arg);
-          break;
-        }
-        bool stop = false;
-        s->pre_arg = PreVisit(re, s->parent_arg, &stop);
-        if (stop) {
-          t = s->pre_arg;
-          break;
-        }
-        s->n = 0;
-        s->child_args = NULL;
-        if (re->nsub_ == 1)
-          s->child_args = &s->child_arg;
-        else if (re->nsub_ > 1)
-          s->child_args = new T[re->nsub_];
-        FALLTHROUGH_INTENDED;
-      }
-      default: {
-        if (re->nsub_ > 0) {
-          Regexp** sub = re->sub();
-          if (s->n < re->nsub_) {
-            if (use_copy && s->n > 0 && sub[s->n - 1] == sub[s->n]) {
-              s->child_args[s->n] = Copy(s->child_args[s->n - 1]);
-              s->n++;
-            } else {
-              stack_->push(WalkState<T>(sub[s->n], s->pre_arg));
-            }
-            continue;
-          }
-        }
-
-        t = PostVisit(re, s->parent_arg, s->pre_arg, s->child_args, s->n);
-        if (re->nsub_ > 1)
-          delete[] s->child_args;
-        break;
-      }
-    }
-
-    // We've finished stack_->top().
-    // Update next guy down.
-    stack_->pop();
-    if (stack_->size() == 0)
-      return t;
-    s = &stack_->top();
-    if (s->child_args != NULL)
-      s->child_args[s->n] = t;
-    else
-      s->child_arg = t;
-    s->n++;
-  }
-}
-
-template<typename T> T Regexp::Walker<T>::Walk(Regexp* re, T top_arg) {
-  // Without the exponential walking behavior,
-  // this budget should be more than enough for any
-  // regexp, and yet not enough to get us in trouble
-  // as far as CPU time.
-  max_visits_ = 1000000;
-  return WalkInternal(re, top_arg, true);
-}
-
-template<typename T> T Regexp::Walker<T>::WalkExponential(Regexp* re, T top_arg,
-                                                          int max_visits) {
-  max_visits_ = max_visits;
-  return WalkInternal(re, top_arg, false);
-}
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_WALKER_INL_H_
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_re2 {
-
-// List of pointers to Inst* that need to be filled in (patched).
-// Because the Inst* haven't been filled in yet,
-// we can use the Inst* word to hold the list's "next" pointer.
-// It's kind of sleazy, but it works well in practice.
-// See http://swtch.com/~rsc/regexp/regexp1.html for inspiration.
-//
-// Because the out and out1 fields in Inst are no longer pointers,
-// we can't use pointers directly here either.  Instead, p refers
-// to inst_[p>>1].out (p&1 == 0) or inst_[p>>1].out1 (p&1 == 1).
-// p == 0 represents the NULL list.  This is okay because instruction #0
-// is always the fail instruction, which never appears on a list.
-
-struct PatchList {
-  uint32_t p;
-
-  // Returns patch list containing just p.
-  static PatchList Mk(uint32_t p);
-
-  // Patches all the entries on l to have value v.
-  // Caller must not ever use patch list again.
-  static void Patch(Prog::Inst *inst0, PatchList l, uint32_t v);
-
-  // Deref returns the next pointer pointed at by p.
-  static PatchList Deref(Prog::Inst *inst0, PatchList l);
-
-  // Appends two patch lists and returns result.
-  static PatchList Append(Prog::Inst *inst0, PatchList l1, PatchList l2);
-};
-
-static PatchList nullPatchList = { 0 };
-
-// Returns patch list containing just p.
-PatchList PatchList::Mk(uint32_t p) {
-  PatchList l;
-  l.p = p;
-  return l;
-}
-
-// Returns the next pointer pointed at by l.
-PatchList PatchList::Deref(Prog::Inst* inst0, PatchList l) {
-  Prog::Inst* ip = &inst0[l.p>>1];
-  if (l.p&1)
-    l.p = ip->out1();
-  else
-    l.p = ip->out();
-  return l;
-}
-
-// Patches all the entries on l to have value v.
-void PatchList::Patch(Prog::Inst *inst0, PatchList l, uint32_t val) {
-  while (l.p != 0) {
-    Prog::Inst* ip = &inst0[l.p>>1];
-    if (l.p&1) {
-      l.p = ip->out1();
-      ip->out1_ = val;
-    } else {
-      l.p = ip->out();
-      ip->set_out(val);
-    }
-  }
-}
-
-// Appends two patch lists and returns result.
-PatchList PatchList::Append(Prog::Inst* inst0, PatchList l1, PatchList l2) {
-  if (l1.p == 0)
-    return l2;
-  if (l2.p == 0)
-    return l1;
-
-  PatchList l = l1;
-  for (;;) {
-    PatchList next = PatchList::Deref(inst0, l);
-    if (next.p == 0)
-      break;
-    l = next;
-  }
-
-  Prog::Inst* ip = &inst0[l.p>>1];
-  if (l.p&1)
-    ip->out1_ = l2.p;
-  else
-    ip->set_out(l2.p);
-
-  return l1;
-}
-
-// Compiled program fragment.
-struct Frag {
-  uint32_t begin;
-  PatchList end;
-
-  Frag() : begin(0) { end.p = 0; }  // needed so Frag can go in vector
-  Frag(uint32_t begin, PatchList end) : begin(begin), end(end) {}
-};
-
-// Input encodings.
-enum Encoding {
-  kEncodingUTF8 = 1,  // UTF-8 (0-10FFFF)
-  kEncodingLatin1,    // Latin-1 (0-FF)
-};
-
-class Compiler : public Regexp::Walker<Frag> {
- public:
-  explicit Compiler();
-  ~Compiler();
-
-  // Compiles Regexp to a new Prog.
-  // Caller is responsible for deleting Prog when finished with it.
-  // If reversed is true, compiles for walking over the input
-  // string backward (reverses all concatenations).
-  static Prog *Compile(Regexp* re, bool reversed, int64_t max_mem);
-
-  // Compiles alternation of all the re to a new Prog.
-  // Each re has a match with an id equal to its index in the vector.
-  static Prog* CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem);
-
-  // Interface for Regexp::Walker, which helps traverse the Regexp.
-  // The walk is purely post-recursive: given the machines for the
-  // children, PostVisit combines them to create the machine for
-  // the current node.  The child_args are Frags.
-  // The Compiler traverses the Regexp parse tree, visiting
-  // each node in depth-first order.  It invokes PreVisit before
-  // visiting the node's children and PostVisit after visiting
-  // the children.
-  Frag PreVisit(Regexp* re, Frag parent_arg, bool* stop);
-  Frag PostVisit(Regexp* re, Frag parent_arg, Frag pre_arg, Frag* child_args,
-                 int nchild_args);
-  Frag ShortVisit(Regexp* re, Frag parent_arg);
-  Frag Copy(Frag arg);
-
-  // Given fragment a, returns a+ or a+?; a* or a*?; a? or a??
-  Frag Plus(Frag a, bool nongreedy);
-  Frag Star(Frag a, bool nongreedy);
-  Frag Quest(Frag a, bool nongreedy);
-
-  // Given fragment a, returns (a) capturing as \n.
-  Frag Capture(Frag a, int n);
-
-  // Given fragments a and b, returns ab; a|b
-  Frag Cat(Frag a, Frag b);
-  Frag Alt(Frag a, Frag b);
-
-  // Returns a fragment that can't match anything.
-  Frag NoMatch();
-
-  // Returns a fragment that matches the empty string.
-  Frag Match(int32_t id);
-
-  // Returns a no-op fragment.
-  Frag Nop();
-
-  // Returns a fragment matching the byte range lo-hi.
-  Frag ByteRange(int lo, int hi, bool foldcase);
-
-  // Returns a fragment matching an empty-width special op.
-  Frag EmptyWidth(EmptyOp op);
-
-  // Adds n instructions to the program.
-  // Returns the index of the first one.
-  // Returns -1 if no more instructions are available.
-  int AllocInst(int n);
-
-  // Rune range compiler.
-
-  // Begins a new alternation.
-  void BeginRange();
-
-  // Adds a fragment matching the rune range lo-hi.
-  void AddRuneRange(Rune lo, Rune hi, bool foldcase);
-  void AddRuneRangeLatin1(Rune lo, Rune hi, bool foldcase);
-  void AddRuneRangeUTF8(Rune lo, Rune hi, bool foldcase);
-  void Add_80_10ffff();
-
-  // New suffix that matches the byte range lo-hi, then goes to next.
-  int UncachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase, int next);
-  int CachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase, int next);
-
-  // Returns true iff the suffix is cached.
-  bool IsCachedRuneByteSuffix(int id);
-
-  // Adds a suffix to alternation.
-  void AddSuffix(int id);
-
-  // Adds a suffix to the trie starting from the given root node.
-  // Returns zero iff allocating an instruction fails. Otherwise, returns
-  // the current root node, which might be different from what was given.
-  int AddSuffixRecursive(int root, int id);
-
-  // Finds the trie node for the given suffix. Returns a Frag in order to
-  // distinguish between pointing at the root node directly (end.p == 0)
-  // and pointing at an Alt's out1 or out (end.p&1 == 1 or 0, respectively).
-  Frag FindByteRange(int root, int id);
-
-  // Compares two ByteRanges and returns true iff they are equal.
-  bool ByteRangeEqual(int id1, int id2);
-
-  // Returns the alternation of all the added suffixes.
-  Frag EndRange();
-
-  // Single rune.
-  Frag Literal(Rune r, bool foldcase);
-
-  void Setup(Regexp::ParseFlags, int64_t, RE2::Anchor);
-  Prog* Finish();
-
-  // Returns .* where dot = any byte
-  Frag DotStar();
-
- private:
-  Prog* prog_;         // Program being built.
-  bool failed_;        // Did we give up compiling?
-  Encoding encoding_;  // Input encoding
-  bool reversed_;      // Should program run backward over text?
-
-  PODArray<Prog::Inst> inst_;
-  int ninst_;          // Number of instructions used.
-  int max_ninst_;      // Maximum number of instructions.
-
-  int64_t max_mem_;    // Total memory budget.
-
-  std::unordered_map<uint64_t, int> rune_cache_;
-  Frag rune_range_;
-
-  RE2::Anchor anchor_;  // anchor mode for RE2::Set
-
-  Compiler(const Compiler&) = delete;
-  Compiler& operator=(const Compiler&) = delete;
-};
-
-Compiler::Compiler() {
-  prog_ = new Prog();
-  failed_ = false;
-  encoding_ = kEncodingUTF8;
-  reversed_ = false;
-  ninst_ = 0;
-  max_ninst_ = 1;  // make AllocInst for fail instruction okay
-  max_mem_ = 0;
-  int fail = AllocInst(1);
-  inst_[fail].InitFail();
-  max_ninst_ = 0;  // Caller must change
-}
-
-Compiler::~Compiler() {
-  delete prog_;
-}
-
-int Compiler::AllocInst(int n) {
-  if (failed_ || ninst_ + n > max_ninst_) {
-    failed_ = true;
-    return -1;
-  }
-
-  if (ninst_ + n > inst_.size()) {
-    int cap = inst_.size();
-    if (cap == 0)
-      cap = 8;
-    while (ninst_ + n > cap)
-      cap *= 2;
-    PODArray<Prog::Inst> inst(cap);
-    if (inst_.data() != NULL)
-      memmove(inst.data(), inst_.data(), ninst_*sizeof inst_[0]);
-    memset(inst.data() + ninst_, 0, (cap - ninst_)*sizeof inst_[0]);
-    inst_ = std::move(inst);
-  }
-  int id = ninst_;
-  ninst_ += n;
-  return id;
-}
-
-// These routines are somewhat hard to visualize in text --
-// see http://swtch.com/~rsc/regexp/regexp1.html for
-// pictures explaining what is going on here.
-
-// Returns an unmatchable fragment.
-Frag Compiler::NoMatch() {
-  return Frag(0, nullPatchList);
-}
-
-// Is a an unmatchable fragment?
-static bool IsNoMatch(Frag a) {
-  return a.begin == 0;
-}
-
-// Given fragments a and b, returns fragment for ab.
-Frag Compiler::Cat(Frag a, Frag b) {
-  if (IsNoMatch(a) || IsNoMatch(b))
-    return NoMatch();
-
-  // Elide no-op.
-  Prog::Inst* begin = &inst_[a.begin];
-  if (begin->opcode() == kInstNop &&
-      a.end.p == (a.begin << 1) &&
-      begin->out() == 0) {
-    // in case refs to a somewhere
-    PatchList::Patch(inst_.data(), a.end, b.begin);
-    return b;
-  }
-
-  // To run backward over string, reverse all concatenations.
-  if (reversed_) {
-    PatchList::Patch(inst_.data(), b.end, a.begin);
-    return Frag(b.begin, a.end);
-  }
-
-  PatchList::Patch(inst_.data(), a.end, b.begin);
-  return Frag(a.begin, b.end);
-}
-
-// Given fragments for a and b, returns fragment for a|b.
-Frag Compiler::Alt(Frag a, Frag b) {
-  // Special case for convenience in loops.
-  if (IsNoMatch(a))
-    return b;
-  if (IsNoMatch(b))
-    return a;
-
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-
-  inst_[id].InitAlt(a.begin, b.begin);
-  return Frag(id, PatchList::Append(inst_.data(), a.end, b.end));
-}
-
-// When capturing submatches in like-Perl mode, a kOpAlt Inst
-// treats out_ as the first choice, out1_ as the second.
-//
-// For *, +, and ?, if out_ causes another repetition,
-// then the operator is greedy.  If out1_ is the repetition
-// (and out_ moves forward), then the operator is non-greedy.
-
-// Given a fragment a, returns a fragment for a* or a*? (if nongreedy)
-Frag Compiler::Star(Frag a, bool nongreedy) {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitAlt(0, 0);
-  PatchList::Patch(inst_.data(), a.end, id);
-  if (nongreedy) {
-    inst_[id].out1_ = a.begin;
-    return Frag(id, PatchList::Mk(id << 1));
-  } else {
-    inst_[id].set_out(a.begin);
-    return Frag(id, PatchList::Mk((id << 1) | 1));
-  }
-}
-
-// Given a fragment for a, returns a fragment for a+ or a+? (if nongreedy)
-Frag Compiler::Plus(Frag a, bool nongreedy) {
-  // a+ is just a* with a different entry point.
-  Frag f = Star(a, nongreedy);
-  return Frag(a.begin, f.end);
-}
-
-// Given a fragment for a, returns a fragment for a? or a?? (if nongreedy)
-Frag Compiler::Quest(Frag a, bool nongreedy) {
-  if (IsNoMatch(a))
-    return Nop();
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  PatchList pl;
-  if (nongreedy) {
-    inst_[id].InitAlt(0, a.begin);
-    pl = PatchList::Mk(id << 1);
-  } else {
-    inst_[id].InitAlt(a.begin, 0);
-    pl = PatchList::Mk((id << 1) | 1);
-  }
-  return Frag(id, PatchList::Append(inst_.data(), pl, a.end));
-}
-
-// Returns a fragment for the byte range lo-hi.
-Frag Compiler::ByteRange(int lo, int hi, bool foldcase) {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitByteRange(lo, hi, foldcase, 0);
-  return Frag(id, PatchList::Mk(id << 1));
-}
-
-// Returns a no-op fragment.  Sometimes unavoidable.
-Frag Compiler::Nop() {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitNop(0);
-  return Frag(id, PatchList::Mk(id << 1));
-}
-
-// Returns a fragment that signals a match.
-Frag Compiler::Match(int32_t match_id) {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitMatch(match_id);
-  return Frag(id, nullPatchList);
-}
-
-// Returns a fragment matching a particular empty-width op (like ^ or $)
-Frag Compiler::EmptyWidth(EmptyOp empty) {
-  int id = AllocInst(1);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitEmptyWidth(empty, 0);
-  return Frag(id, PatchList::Mk(id << 1));
-}
-
-// Given a fragment a, returns a fragment with capturing parens around a.
-Frag Compiler::Capture(Frag a, int n) {
-  if (IsNoMatch(a))
-    return NoMatch();
-  int id = AllocInst(2);
-  if (id < 0)
-    return NoMatch();
-  inst_[id].InitCapture(2*n, a.begin);
-  inst_[id+1].InitCapture(2*n+1, 0);
-  PatchList::Patch(inst_.data(), a.end, id+1);
-
-  return Frag(id, PatchList::Mk((id+1) << 1));
-}
-
-// A Rune is a name for a Unicode code point.
-// Returns maximum rune encoded by UTF-8 sequence of length len.
-static int MaxRune(int len) {
-  int b;  // number of Rune bits in len-byte UTF-8 sequence (len < UTFmax)
-  if (len == 1)
-    b = 7;
-  else
-    b = 8-(len+1) + 6*(len-1);
-  return (1<<b) - 1;   // maximum Rune for b bits.
-}
-
-// The rune range compiler caches common suffix fragments,
-// which are very common in UTF-8 (e.g., [80-bf]).
-// The fragment suffixes are identified by their start
-// instructions.  NULL denotes the eventual end match.
-// The Frag accumulates in rune_range_.  Caching common
-// suffixes reduces the UTF-8 "." from 32 to 24 instructions,
-// and it reduces the corresponding one-pass NFA from 16 nodes to 8.
-
-void Compiler::BeginRange() {
-  rune_cache_.clear();
-  rune_range_.begin = 0;
-  rune_range_.end = nullPatchList;
-}
-
-int Compiler::UncachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase,
-                                     int next) {
-  Frag f = ByteRange(lo, hi, foldcase);
-  if (next != 0) {
-    PatchList::Patch(inst_.data(), f.end, next);
-  } else {
-    rune_range_.end = PatchList::Append(inst_.data(), rune_range_.end, f.end);
-  }
-  return f.begin;
-}
-
-static uint64_t MakeRuneCacheKey(uint8_t lo, uint8_t hi, bool foldcase,
-                                 int next) {
-  return (uint64_t)next << 17 |
-         (uint64_t)lo   <<  9 |
-         (uint64_t)hi   <<  1 |
-         (uint64_t)foldcase;
-}
-
-int Compiler::CachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase,
-                                   int next) {
-  uint64_t key = MakeRuneCacheKey(lo, hi, foldcase, next);
-  std::unordered_map<uint64_t, int>::const_iterator it = rune_cache_.find(key);
-  if (it != rune_cache_.end())
-    return it->second;
-  int id = UncachedRuneByteSuffix(lo, hi, foldcase, next);
-  rune_cache_[key] = id;
-  return id;
-}
-
-bool Compiler::IsCachedRuneByteSuffix(int id) {
-  uint8_t lo = inst_[id].inst_byte_range_data_.lo_;
-  uint8_t hi = inst_[id].inst_byte_range_data_.hi_;
-  bool foldcase = inst_[id].foldcase() != 0;
-  int next = inst_[id].out();
-
-  uint64_t key = MakeRuneCacheKey(lo, hi, foldcase, next);
-  return rune_cache_.find(key) != rune_cache_.end();
-}
-
-void Compiler::AddSuffix(int id) {
-  if (failed_)
-    return;
-
-  if (rune_range_.begin == 0) {
-    rune_range_.begin = id;
-    return;
-  }
-
-  if (encoding_ == kEncodingUTF8) {
-    // Build a trie in order to reduce fanout.
-    rune_range_.begin = AddSuffixRecursive(rune_range_.begin, id);
-    return;
-  }
-
-  int alt = AllocInst(1);
-  if (alt < 0) {
-    rune_range_.begin = 0;
-    return;
-  }
-  inst_[alt].InitAlt(rune_range_.begin, id);
-  rune_range_.begin = alt;
-}
-
-int Compiler::AddSuffixRecursive(int root, int id) {
-  DCHECK(inst_[root].opcode() == kInstAlt ||
-         inst_[root].opcode() == kInstByteRange);
-
-  Frag f = FindByteRange(root, id);
-  if (IsNoMatch(f)) {
-    int alt = AllocInst(1);
-    if (alt < 0)
-      return 0;
-    inst_[alt].InitAlt(root, id);
-    return alt;
-  }
-
-  int br;
-  if (f.end.p == 0)
-    br = root;
-  else if (f.end.p&1)
-    br = inst_[f.begin].out1();
-  else
-    br = inst_[f.begin].out();
-
-  if (IsCachedRuneByteSuffix(br)) {
-    // We can't fiddle with cached suffixes, so make a clone of the head.
-    int byterange = AllocInst(1);
-    if (byterange < 0)
-      return 0;
-    inst_[byterange].InitByteRange(inst_[br].lo(), inst_[br].hi(),
-                                   inst_[br].foldcase(), inst_[br].out());
-
-    // Ensure that the parent points to the clone, not to the original.
-    // Note that this could leave the head unreachable except via the cache.
-    br = byterange;
-    if (f.end.p == 0)
-      root = br;
-    else if (f.end.p&1)
-      inst_[f.begin].out1_ = br;
-    else
-      inst_[f.begin].set_out(br);
-  }
-
-  int out = inst_[id].out();
-  if (!IsCachedRuneByteSuffix(id)) {
-    // The head should be the instruction most recently allocated, so free it
-    // instead of leaving it unreachable.
-    DCHECK_EQ(id, ninst_-1);
-    inst_[id].out_opcode_ = 0;
-    inst_[id].out1_ = 0;
-    ninst_--;
-  }
-
-  out = AddSuffixRecursive(inst_[br].out(), out);
-  if (out == 0)
-    return 0;
-
-  inst_[br].set_out(out);
-  return root;
-}
-
-bool Compiler::ByteRangeEqual(int id1, int id2) {
-  return inst_[id1].lo() == inst_[id2].lo() &&
-         inst_[id1].hi() == inst_[id2].hi() &&
-         inst_[id1].foldcase() == inst_[id2].foldcase();
-}
-
-Frag Compiler::FindByteRange(int root, int id) {
-  if (inst_[root].opcode() == kInstByteRange) {
-    if (ByteRangeEqual(root, id))
-      return Frag(root, nullPatchList);
-    else
-      return NoMatch();
-  }
-
-  while (inst_[root].opcode() == kInstAlt) {
-    int out1 = inst_[root].out1();
-    if (ByteRangeEqual(out1, id))
-      return Frag(root, PatchList::Mk((root << 1) | 1));
-
-    // CharClass is a sorted list of ranges, so if out1 of the root Alt wasn't
-    // what we're looking for, then we can stop immediately. Unfortunately, we
-    // can't short-circuit the search in reverse mode.
-    if (!reversed_)
-      return NoMatch();
-
-    int out = inst_[root].out();
-    if (inst_[out].opcode() == kInstAlt)
-      root = out;
-    else if (ByteRangeEqual(out, id))
-      return Frag(root, PatchList::Mk(root << 1));
-    else
-      return NoMatch();
-  }
-
-  LOG(DFATAL) << "should never happen";
-  return NoMatch();
-}
-
-Frag Compiler::EndRange() {
-  return rune_range_;
-}
-
-// Converts rune range lo-hi into a fragment that recognizes
-// the bytes that would make up those runes in the current
-// encoding (Latin 1 or UTF-8).
-// This lets the machine work byte-by-byte even when
-// using multibyte encodings.
-
-void Compiler::AddRuneRange(Rune lo, Rune hi, bool foldcase) {
-  switch (encoding_) {
-    default:
-    case kEncodingUTF8:
-      AddRuneRangeUTF8(lo, hi, foldcase);
-      break;
-    case kEncodingLatin1:
-      AddRuneRangeLatin1(lo, hi, foldcase);
-      break;
-  }
-}
-
-void Compiler::AddRuneRangeLatin1(Rune lo, Rune hi, bool foldcase) {
-  // Latin-1 is easy: runes *are* bytes.
-  if (lo > hi || lo > 0xFF)
-    return;
-  if (hi > 0xFF)
-    hi = 0xFF;
-  AddSuffix(UncachedRuneByteSuffix(static_cast<uint8_t>(lo),
-                                   static_cast<uint8_t>(hi), foldcase, 0));
-}
-
-// Table describing how to make a UTF-8 matching machine
-// for the rune range 80-10FFFF (Runeself-Runemax).
-// This range happens frequently enough (for example /./ and /[^a-z]/)
-// and the rune_cache_ map is slow enough that this is worth
-// special handling.  Makes compilation of a small expression
-// with a dot in it about 10% faster.
-// The * in the comments below mark whole sequences.
-static struct ByteRangeProg {
-  int next;
-  int lo;
-  int hi;
-} prog_80_10ffff[] = {
-  // Two-byte
-  { -1, 0x80, 0xBF, },  // 0:  80-BF
-  {  0, 0xC2, 0xDF, },  // 1:  C2-DF 80-BF*
-
-  // Three-byte
-  {  0, 0xA0, 0xBF, },  // 2:  A0-BF 80-BF
-  {  2, 0xE0, 0xE0, },  // 3:  E0 A0-BF 80-BF*
-  {  0, 0x80, 0xBF, },  // 4:  80-BF 80-BF
-  {  4, 0xE1, 0xEF, },  // 5:  E1-EF 80-BF 80-BF*
-
-  // Four-byte
-  {  4, 0x90, 0xBF, },  // 6:  90-BF 80-BF 80-BF
-  {  6, 0xF0, 0xF0, },  // 7:  F0 90-BF 80-BF 80-BF*
-  {  4, 0x80, 0xBF, },  // 8:  80-BF 80-BF 80-BF
-  {  8, 0xF1, 0xF3, },  // 9: F1-F3 80-BF 80-BF 80-BF*
-  {  4, 0x80, 0x8F, },  // 10: 80-8F 80-BF 80-BF
-  { 10, 0xF4, 0xF4, },  // 11: F4 80-8F 80-BF 80-BF*
-};
-
-void Compiler::Add_80_10ffff() {
-  int inst[arraysize(prog_80_10ffff)] = { 0 }; // does not need to be initialized; silences gcc warning
-  for (int i = 0; i < arraysize(prog_80_10ffff); i++) {
-    const ByteRangeProg& p = prog_80_10ffff[i];
-    int next = 0;
-    if (p.next >= 0)
-      next = inst[p.next];
-    inst[i] = UncachedRuneByteSuffix(static_cast<uint8_t>(p.lo),
-                                     static_cast<uint8_t>(p.hi), false, next);
-    if ((p.lo & 0xC0) != 0x80)
-      AddSuffix(inst[i]);
-  }
-}
-
-void Compiler::AddRuneRangeUTF8(Rune lo, Rune hi, bool foldcase) {
-  if (lo > hi)
-    return;
-
-  // Pick off 80-10FFFF as a common special case
-  // that can bypass the slow rune_cache_.
-  if (lo == 0x80 && hi == 0x10ffff && !reversed_) {
-    Add_80_10ffff();
-    return;
-  }
-
-  // Split range into same-length sized ranges.
-  for (int i = 1; i < UTFmax; i++) {
-    Rune max = MaxRune(i);
-    if (lo <= max && max < hi) {
-      AddRuneRangeUTF8(lo, max, foldcase);
-      AddRuneRangeUTF8(max+1, hi, foldcase);
-      return;
-    }
-  }
-
-  // ASCII range is always a special case.
-  if (hi < Runeself) {
-    AddSuffix(UncachedRuneByteSuffix(static_cast<uint8_t>(lo),
-                                     static_cast<uint8_t>(hi), foldcase, 0));
-    return;
-  }
-
-  // Split range into sections that agree on leading bytes.
-  for (int i = 1; i < UTFmax; i++) {
-    uint32_t m = (1<<(6*i)) - 1;  // last i bytes of a UTF-8 sequence
-    if ((lo & ~m) != (hi & ~m)) {
-      if ((lo & m) != 0) {
-        AddRuneRangeUTF8(lo, lo|m, foldcase);
-        AddRuneRangeUTF8((lo|m)+1, hi, foldcase);
-        return;
-      }
-      if ((hi & m) != m) {
-        AddRuneRangeUTF8(lo, (hi&~m)-1, foldcase);
-        AddRuneRangeUTF8(hi&~m, hi, foldcase);
-        return;
-      }
-    }
-  }
-
-  // Finally.  Generate byte matching equivalent for lo-hi.
-  uint8_t ulo[UTFmax], uhi[UTFmax];
-  int n = runetochar(reinterpret_cast<char*>(ulo), &lo);
-  int m = runetochar(reinterpret_cast<char*>(uhi), &hi);
-  (void)m;  // USED(m)
-  DCHECK_EQ(n, m);
-
-  // The logic below encodes this thinking:
-  //
-  // 1. When we have built the whole suffix, we know that it cannot
-  // possibly be a suffix of anything longer: in forward mode, nothing
-  // else can occur before the leading byte; in reverse mode, nothing
-  // else can occur after the last continuation byte or else the leading
-  // byte would have to change. Thus, there is no benefit to caching
-  // the first byte of the suffix whereas there is a cost involved in
-  // cloning it if it begins a common prefix, which is fairly likely.
-  //
-  // 2. Conversely, the last byte of the suffix cannot possibly be a
-  // prefix of anything because next == 0, so we will never want to
-  // clone it, but it is fairly likely to be a common suffix. Perhaps
-  // more so in reverse mode than in forward mode because the former is
-  // "converging" towards lower entropy, but caching is still worthwhile
-  // for the latter in cases such as 80-BF.
-  //
-  // 3. Handling the bytes between the first and the last is less
-  // straightforward and, again, the approach depends on whether we are
-  // "converging" towards lower entropy: in forward mode, a single byte
-  // is unlikely to be part of a common suffix whereas a byte range
-  // is more likely so; in reverse mode, a byte range is unlikely to
-  // be part of a common suffix whereas a single byte is more likely
-  // so. The same benefit versus cost argument applies here.
-  int id = 0;
-  if (reversed_) {
-    for (int i = 0; i < n; i++) {
-      // In reverse UTF-8 mode: cache the leading byte; don't cache the last
-      // continuation byte; cache anything else iff it's a single byte (XX-XX).
-      if (i == 0 || (ulo[i] == uhi[i] && i != n-1))
-        id = CachedRuneByteSuffix(ulo[i], uhi[i], false, id);
-      else
-        id = UncachedRuneByteSuffix(ulo[i], uhi[i], false, id);
-    }
-  } else {
-    for (int i = n-1; i >= 0; i--) {
-      // In forward UTF-8 mode: don't cache the leading byte; cache the last
-      // continuation byte; cache anything else iff it's a byte range (XX-YY).
-      if (i == n-1 || (ulo[i] < uhi[i] && i != 0))
-        id = CachedRuneByteSuffix(ulo[i], uhi[i], false, id);
-      else
-        id = UncachedRuneByteSuffix(ulo[i], uhi[i], false, id);
-    }
-  }
-  AddSuffix(id);
-}
-
-// Should not be called.
-Frag Compiler::Copy(Frag arg) {
-  // We're using WalkExponential; there should be no copying.
-  LOG(DFATAL) << "Compiler::Copy called!";
-  failed_ = true;
-  return NoMatch();
-}
-
-// Visits a node quickly; called once WalkExponential has
-// decided to cut this walk short.
-Frag Compiler::ShortVisit(Regexp* re, Frag) {
-  failed_ = true;
-  return NoMatch();
-}
-
-// Called before traversing a node's children during the walk.
-Frag Compiler::PreVisit(Regexp* re, Frag, bool* stop) {
-  // Cut off walk if we've already failed.
-  if (failed_)
-    *stop = true;
-
-  return Frag();  // not used by caller
-}
-
-Frag Compiler::Literal(Rune r, bool foldcase) {
-  switch (encoding_) {
-    default:
-      return Frag();
-
-    case kEncodingLatin1:
-      return ByteRange(r, r, foldcase);
-
-    case kEncodingUTF8: {
-      if (r < Runeself)  // Make common case fast.
-        return ByteRange(r, r, foldcase);
-      uint8_t buf[UTFmax];
-      int n = runetochar(reinterpret_cast<char*>(buf), &r);
-      Frag f = ByteRange((uint8_t)buf[0], buf[0], false);
-      for (int i = 1; i < n; i++)
-        f = Cat(f, ByteRange((uint8_t)buf[i], buf[i], false));
-      return f;
-    }
-  }
-}
-
-// Called after traversing the node's children during the walk.
-// Given their frags, build and return the frag for this re.
-Frag Compiler::PostVisit(Regexp* re, Frag, Frag, Frag* child_frags,
-                         int nchild_frags) {
-  // If a child failed, don't bother going forward, especially
-  // since the child_frags might contain Frags with NULLs in them.
-  if (failed_)
-    return NoMatch();
-
-  // Given the child fragments, return the fragment for this node.
-  switch (re->op()) {
-    case kRegexpRepeat:
-      // Should not see; code at bottom of function will print error
-      break;
-
-    case kRegexpNoMatch:
-      return NoMatch();
-
-    case kRegexpEmptyMatch:
-      return Nop();
-
-    case kRegexpHaveMatch: {
-      Frag f = Match(re->match_id());
-      if (anchor_ == RE2::ANCHOR_BOTH) {
-        // Append \z or else the subexpression will effectively be unanchored.
-        // Complemented by the UNANCHORED case in CompileSet().
-        f = Cat(EmptyWidth(kEmptyEndText), f);
-      }
-      return f;
-    }
-
-    case kRegexpConcat: {
-      Frag f = child_frags[0];
-      for (int i = 1; i < nchild_frags; i++)
-        f = Cat(f, child_frags[i]);
-      return f;
-    }
-
-    case kRegexpAlternate: {
-      Frag f = child_frags[0];
-      for (int i = 1; i < nchild_frags; i++)
-        f = Alt(f, child_frags[i]);
-      return f;
-    }
-
-    case kRegexpStar:
-      return Star(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
-
-    case kRegexpPlus:
-      return Plus(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
-
-    case kRegexpQuest:
-      return Quest(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
-
-    case kRegexpLiteral:
-      return Literal(re->rune(), (re->parse_flags()&Regexp::FoldCase) != 0);
-
-    case kRegexpLiteralString: {
-      // Concatenation of literals.
-      if (re->nrunes() == 0)
-        return Nop();
-      Frag f;
-      for (int i = 0; i < re->nrunes(); i++) {
-        Frag f1 = Literal(re->runes()[i],
-                          (re->parse_flags()&Regexp::FoldCase) != 0);
-        if (i == 0)
-          f = f1;
-        else
-          f = Cat(f, f1);
-      }
-      return f;
-    }
-
-    case kRegexpAnyChar:
-      BeginRange();
-      AddRuneRange(0, Runemax, false);
-      return EndRange();
-
-    case kRegexpAnyByte:
-      return ByteRange(0x00, 0xFF, false);
-
-    case kRegexpCharClass: {
-      CharClass* cc = re->cc();
-      if (cc->empty()) {
-        // This can't happen.
-        LOG(DFATAL) << "No ranges in char class";
-        failed_ = true;
-        return NoMatch();
-      }
-
-      // ASCII case-folding optimization: if the char class
-      // behaves the same on A-Z as it does on a-z,
-      // discard any ranges wholly contained in A-Z
-      // and mark the other ranges as foldascii.
-      // This reduces the size of a program for
-      // (?i)abc from 3 insts per letter to 1 per letter.
-      bool foldascii = cc->FoldsASCII();
-
-      // Character class is just a big OR of the different
-      // character ranges in the class.
-      BeginRange();
-      for (CharClass::iterator i = cc->begin(); i != cc->end(); ++i) {
-        // ASCII case-folding optimization (see above).
-        if (foldascii && 'A' <= i->lo && i->hi <= 'Z')
-          continue;
-
-        // If this range contains all of A-Za-z or none of it,
-        // the fold flag is unnecessary; don't bother.
-        bool fold = foldascii;
-        if ((i->lo <= 'A' && 'z' <= i->hi) || i->hi < 'A' || 'z' < i->lo ||
-            ('Z' < i->lo && i->hi < 'a'))
-          fold = false;
-
-        AddRuneRange(i->lo, i->hi, fold);
-      }
-      return EndRange();
-    }
-
-    case kRegexpCapture:
-      // If this is a non-capturing parenthesis -- (?:foo) --
-      // just use the inner expression.
-      if (re->cap() < 0)
-        return child_frags[0];
-      return Capture(child_frags[0], re->cap());
-
-    case kRegexpBeginLine:
-      return EmptyWidth(reversed_ ? kEmptyEndLine : kEmptyBeginLine);
-
-    case kRegexpEndLine:
-      return EmptyWidth(reversed_ ? kEmptyBeginLine : kEmptyEndLine);
-
-    case kRegexpBeginText:
-      return EmptyWidth(reversed_ ? kEmptyEndText : kEmptyBeginText);
-
-    case kRegexpEndText:
-      return EmptyWidth(reversed_ ? kEmptyBeginText : kEmptyEndText);
-
-    case kRegexpWordBoundary:
-      return EmptyWidth(kEmptyWordBoundary);
-
-    case kRegexpNoWordBoundary:
-      return EmptyWidth(kEmptyNonWordBoundary);
-  }
-  LOG(DFATAL) << "Missing case in Compiler: " << re->op();
-  failed_ = true;
-  return NoMatch();
-}
-
-// Is this regexp required to start at the beginning of the text?
-// Only approximate; can return false for complicated regexps like (\Aa|\Ab),
-// but handles (\A(a|b)).  Could use the Walker to write a more exact one.
-static bool IsAnchorStart(Regexp** pre, int depth) {
-  Regexp* re = *pre;
-  Regexp* sub;
-  // The depth limit makes sure that we don't overflow
-  // the stack on a deeply nested regexp.  As the comment
-  // above says, IsAnchorStart is conservative, so returning
-  // a false negative is okay.  The exact limit is somewhat arbitrary.
-  if (re == NULL || depth >= 4)
-    return false;
-  switch (re->op()) {
-    default:
-      break;
-    case kRegexpConcat:
-      if (re->nsub() > 0) {
-        sub = re->sub()[0]->Incref();
-        if (IsAnchorStart(&sub, depth+1)) {
-          PODArray<Regexp*> subcopy(re->nsub());
-          subcopy[0] = sub;  // already have reference
-          for (int i = 1; i < re->nsub(); i++)
-            subcopy[i] = re->sub()[i]->Incref();
-          *pre = Regexp::Concat(subcopy.data(), re->nsub(), re->parse_flags());
-          re->Decref();
-          return true;
-        }
-        sub->Decref();
-      }
-      break;
-    case kRegexpCapture:
-      sub = re->sub()[0]->Incref();
-      if (IsAnchorStart(&sub, depth+1)) {
-        *pre = Regexp::Capture(sub, re->parse_flags(), re->cap());
-        re->Decref();
-        return true;
-      }
-      sub->Decref();
-      break;
-    case kRegexpBeginText:
-      *pre = Regexp::LiteralString(NULL, 0, re->parse_flags());
-      re->Decref();
-      return true;
-  }
-  return false;
-}
-
-// Is this regexp required to start at the end of the text?
-// Only approximate; can return false for complicated regexps like (a\z|b\z),
-// but handles ((a|b)\z).  Could use the Walker to write a more exact one.
-static bool IsAnchorEnd(Regexp** pre, int depth) {
-  Regexp* re = *pre;
-  Regexp* sub;
-  // The depth limit makes sure that we don't overflow
-  // the stack on a deeply nested regexp.  As the comment
-  // above says, IsAnchorEnd is conservative, so returning
-  // a false negative is okay.  The exact limit is somewhat arbitrary.
-  if (re == NULL || depth >= 4)
-    return false;
-  switch (re->op()) {
-    default:
-      break;
-    case kRegexpConcat:
-      if (re->nsub() > 0) {
-        sub = re->sub()[re->nsub() - 1]->Incref();
-        if (IsAnchorEnd(&sub, depth+1)) {
-          PODArray<Regexp*> subcopy(re->nsub());
-          subcopy[re->nsub() - 1] = sub;  // already have reference
-          for (int i = 0; i < re->nsub() - 1; i++)
-            subcopy[i] = re->sub()[i]->Incref();
-          *pre = Regexp::Concat(subcopy.data(), re->nsub(), re->parse_flags());
-          re->Decref();
-          return true;
-        }
-        sub->Decref();
-      }
-      break;
-    case kRegexpCapture:
-      sub = re->sub()[0]->Incref();
-      if (IsAnchorEnd(&sub, depth+1)) {
-        *pre = Regexp::Capture(sub, re->parse_flags(), re->cap());
-        re->Decref();
-        return true;
-      }
-      sub->Decref();
-      break;
-    case kRegexpEndText:
-      *pre = Regexp::LiteralString(NULL, 0, re->parse_flags());
-      re->Decref();
-      return true;
-  }
-  return false;
-}
-
-void Compiler::Setup(Regexp::ParseFlags flags, int64_t max_mem,
-                     RE2::Anchor anchor) {
-  prog_->set_flags(flags);
-
-  if (flags & Regexp::Latin1)
-    encoding_ = kEncodingLatin1;
-  max_mem_ = max_mem;
-  if (max_mem <= 0) {
-    max_ninst_ = 100000;  // more than enough
-  } else if (static_cast<size_t>(max_mem) <= sizeof(Prog)) {
-    // No room for anything.
-    max_ninst_ = 0;
-  } else {
-    int64_t m = (max_mem - sizeof(Prog)) / sizeof(Prog::Inst);
-    // Limit instruction count so that inst->id() fits nicely in an int.
-    // SparseArray also assumes that the indices (inst->id()) are ints.
-    // The call to WalkExponential uses 2*max_ninst_ below,
-    // and other places in the code use 2 or 3 * prog->size().
-    // Limiting to 2^24 should avoid overflow in those places.
-    // (The point of allowing more than 32 bits of memory is to
-    // have plenty of room for the DFA states, not to use it up
-    // on the program.)
-    if (m >= 1<<24)
-      m = 1<<24;
-
-    // Inst imposes its own limit (currently bigger than 2^24 but be safe).
-    if (m > Prog::Inst::kMaxInst)
-      m = Prog::Inst::kMaxInst;
-
-    max_ninst_ = static_cast<int>(m);
-  }
-
-  anchor_ = anchor;
-}
-
-// Compiles re, returning program.
-// Caller is responsible for deleting prog_.
-// If reversed is true, compiles a program that expects
-// to run over the input string backward (reverses all concatenations).
-// The reversed flag is also recorded in the returned program.
-Prog* Compiler::Compile(Regexp* re, bool reversed, int64_t max_mem) {
-  Compiler c;
-  c.Setup(re->parse_flags(), max_mem, RE2::UNANCHORED /* unused */);
-  c.reversed_ = reversed;
-
-  // Simplify to remove things like counted repetitions
-  // and character classes like \d.
-  Regexp* sre = re->Simplify();
-  if (sre == NULL)
-    return NULL;
-
-  // Record whether prog is anchored, removing the anchors.
-  // (They get in the way of other optimizations.)
-  bool is_anchor_start = IsAnchorStart(&sre, 0);
-  bool is_anchor_end = IsAnchorEnd(&sre, 0);
-
-  // Generate fragment for entire regexp.
-  Frag all = c.WalkExponential(sre, Frag(), 2*c.max_ninst_);
-  sre->Decref();
-  if (c.failed_)
-    return NULL;
-
-  // Success!  Finish by putting Match node at end, and record start.
-  // Turn off c.reversed_ (if it is set) to force the remaining concatenations
-  // to behave normally.
-  c.reversed_ = false;
-  all = c.Cat(all, c.Match(0));
-
-  c.prog_->set_reversed(reversed);
-  if (c.prog_->reversed()) {
-    c.prog_->set_anchor_start(is_anchor_end);
-    c.prog_->set_anchor_end(is_anchor_start);
-  } else {
-    c.prog_->set_anchor_start(is_anchor_start);
-    c.prog_->set_anchor_end(is_anchor_end);
-  }
-
-  c.prog_->set_start(all.begin);
-  if (!c.prog_->anchor_start()) {
-    // Also create unanchored version, which starts with a .*? loop.
-    all = c.Cat(c.DotStar(), all);
-  }
-  c.prog_->set_start_unanchored(all.begin);
-
-  // Hand ownership of prog_ to caller.
-  return c.Finish();
-}
-
-Prog* Compiler::Finish() {
-  if (failed_)
-    return NULL;
-
-  if (prog_->start() == 0 && prog_->start_unanchored() == 0) {
-    // No possible matches; keep Fail instruction only.
-    ninst_ = 1;
-  }
-
-  // Hand off the array to Prog.
-  prog_->inst_ = std::move(inst_);
-  prog_->size_ = ninst_;
-
-  prog_->Optimize();
-  prog_->Flatten();
-  prog_->ComputeByteMap();
-
-  // Record remaining memory for DFA.
-  if (max_mem_ <= 0) {
-    prog_->set_dfa_mem(1<<20);
-  } else {
-    int64_t m = max_mem_ - sizeof(Prog);
-    m -= prog_->size_*sizeof(Prog::Inst);  // account for inst_
-    if (prog_->CanBitState())
-      m -= prog_->size_*sizeof(uint16_t);  // account for list_heads_
-    if (m < 0)
-      m = 0;
-    prog_->set_dfa_mem(m);
-  }
-
-  Prog* p = prog_;
-  prog_ = NULL;
-  return p;
-}
-
-// Converts Regexp to Prog.
-Prog* Regexp::CompileToProg(int64_t max_mem) {
-  return Compiler::Compile(this, false, max_mem);
-}
-
-Prog* Regexp::CompileToReverseProg(int64_t max_mem) {
-  return Compiler::Compile(this, true, max_mem);
-}
-
-Frag Compiler::DotStar() {
-  return Star(ByteRange(0x00, 0xff, false), true);
-}
-
-// Compiles RE set to Prog.
-Prog* Compiler::CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem) {
-  Compiler c;
-  c.Setup(re->parse_flags(), max_mem, anchor);
-
-  Regexp* sre = re->Simplify();
-  if (sre == NULL)
-    return NULL;
-
-  Frag all = c.WalkExponential(sre, Frag(), 2*c.max_ninst_);
-  sre->Decref();
-  if (c.failed_)
-    return NULL;
-
-  c.prog_->set_anchor_start(true);
-  c.prog_->set_anchor_end(true);
-
-  if (anchor == RE2::UNANCHORED) {
-    // Prepend .* or else the expression will effectively be anchored.
-    // Complemented by the ANCHOR_BOTH case in PostVisit().
-    all = c.Cat(c.DotStar(), all);
-  }
-  c.prog_->set_start(all.begin);
-  c.prog_->set_start_unanchored(all.begin);
-
-  Prog* prog = c.Finish();
-  if (prog == NULL)
-    return NULL;
-
-  // Make sure DFA has enough memory to operate,
-  // since we're not going to fall back to the NFA.
-  bool dfa_failed = false;
-  StringPiece sp = "hello, world";
-  prog->SearchDFA(sp, sp, Prog::kAnchored, Prog::kManyMatch,
-                  NULL, &dfa_failed, NULL);
-  if (dfa_failed) {
-    delete prog;
-    return NULL;
-  }
-
-  return prog;
-}
-
-Prog* Prog::CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem) {
-  return Compiler::CompileSet(re, anchor, max_mem);
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// A DFA (deterministic finite automaton)-based regular expression search.
-//
-// The DFA search has two main parts: the construction of the automaton,
-// which is represented by a graph of State structures, and the execution
-// of the automaton over a given input string.
-//
-// The basic idea is that the State graph is constructed so that the
-// execution can simply start with a state s, and then for each byte c in
-// the input string, execute "s = s->next[c]", checking at each point whether
-// the current s represents a matching state.
-//
-// The simple explanation just given does convey the essence of this code,
-// but it omits the details of how the State graph gets constructed as well
-// as some performance-driven optimizations to the execution of the automaton.
-// All these details are explained in the comments for the code following
-// the definition of class DFA.
-//
-// See http://swtch.com/~rsc/regexp/ for a very bare-bones equivalent.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <algorithm>
-#include <atomic>
-#include <deque>
-#include <mutex>
-#include <new>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_MIX_H_
-#define UTIL_MIX_H_
-
-#include <stddef.h>
-#include <limits>
-
-namespace duckdb_re2 {
-
-// Silence "truncation of constant value" warning for kMul in 32-bit mode.
-// Since this is a header file, push and then pop to limit the scope.
-#ifdef _MSC_VER
-//#pragma warning(push)
-//#pragma warning(disable: 4309)
-#endif
-
-class HashMix {
- public:
-  HashMix() : hash_(1) {}
-  explicit HashMix(size_t val) : hash_(val + 83) {}
-  void Mix(size_t val) {
-    static const size_t kMul = static_cast<size_t>(0xdc3eb94af8ab4c93ULL);
-    hash_ *= kMul;
-    hash_ = ((hash_ << 19) |
-             (hash_ >> (std::numeric_limits<size_t>::digits - 19))) + val;
-  }
-  size_t get() const { return hash_; }
- private:
-  size_t hash_;
-};
-
-#ifdef _MSC_VER
-//#pragma warning(pop)
-#endif
-
-}  // namespace duckdb_re2
-
-#endif  // UTIL_MIX_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_MUTEX_H_
-#define UTIL_MUTEX_H_
-
-/*
- * A simple mutex wrapper, supporting locks and read-write locks.
- * You should assume the locks are *not* re-entrant.
- */
-
-#if !defined(_WIN32)
-#ifndef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE 200809L
-#endif
-#include <unistd.h>
-//#if defined(_POSIX_READER_WRITER_LOCKS) && _POSIX_READER_WRITER_LOCKS > 0
-//#define MUTEX_IS_PTHREAD_RWLOCK
-//#endif
-#endif
-
-#if defined(MUTEX_IS_PTHREAD_RWLOCK)
-#error We really dont want to include pthread
-#include <pthread.h>
-#include <stdlib.h>
-typedef pthread_rwlock_t MutexType;
-#else
-#include <mutex>
-typedef std::mutex MutexType;
-#endif
-
-namespace duckdb_re2 {
-
-class Mutex {
- public:
-  inline Mutex();
-  inline ~Mutex();
-  inline void Lock();    // Block if needed until free then acquire exclusively
-  inline void Unlock();  // Release a lock acquired via Lock()
-  // Note that on systems that don't support read-write locks, these may
-  // be implemented as synonyms to Lock() and Unlock().  So you can use
-  // these for efficiency, but don't use them anyplace where being able
-  // to do shared reads is necessary to avoid deadlock.
-  inline void ReaderLock();   // Block until free or shared then acquire a share
-  inline void ReaderUnlock(); // Release a read share of this Mutex
-  inline void WriterLock() { Lock(); }     // Acquire an exclusive lock
-  inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock()
-
- private:
-  MutexType mutex_;
-
-  // Catch the error of writing Mutex when intending MutexLock.
-  Mutex(Mutex *ignored);
-
-  Mutex(const Mutex&) = delete;
-  Mutex& operator=(const Mutex&) = delete;
-};
-
-#if defined(MUTEX_IS_PTHREAD_RWLOCK)
-
-#define SAFE_PTHREAD(fncall)    \
-  do {                          \
-    if ((fncall) != 0) abort(); \
-  } while (0)
-
-Mutex::Mutex()             { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); }
-Mutex::~Mutex()            { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); }
-void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); }
-void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
-void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); }
-void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
-
-#undef SAFE_PTHREAD
-
-#else
-
-Mutex::Mutex()             { }
-Mutex::~Mutex()            { }
-void Mutex::Lock()         { mutex_.lock(); }
-void Mutex::Unlock()       { mutex_.unlock(); }
-void Mutex::ReaderLock()   { Lock(); }  // C++11 doesn't have std::shared_mutex.
-void Mutex::ReaderUnlock() { Unlock(); }
-
-#endif
-
-// --------------------------------------------------------------------------
-// Some helper classes
-
-// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
-class MutexLock {
- public:
-  explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); }
-  ~MutexLock() { mu_->Unlock(); }
- private:
-  Mutex * const mu_;
-
-  MutexLock(const MutexLock&) = delete;
-  MutexLock& operator=(const MutexLock&) = delete;
-};
-
-// ReaderMutexLock and WriterMutexLock do the same, for rwlocks
-class ReaderMutexLock {
- public:
-  explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); }
-  ~ReaderMutexLock() { mu_->ReaderUnlock(); }
- private:
-  Mutex * const mu_;
-
-  ReaderMutexLock(const ReaderMutexLock&) = delete;
-  ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
-};
-
-class WriterMutexLock {
- public:
-  explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); }
-  ~WriterMutexLock() { mu_->WriterUnlock(); }
- private:
-  Mutex * const mu_;
-
-  WriterMutexLock(const WriterMutexLock&) = delete;
-  WriterMutexLock& operator=(const WriterMutexLock&) = delete;
-};
-
-// Catch bug where variable name is omitted, e.g. MutexLock (&mu);
-#define MutexLock(x) static_assert(false, "MutexLock declaration missing variable name")
-#define ReaderMutexLock(x) static_assert(false, "ReaderMutexLock declaration missing variable name")
-#define WriterMutexLock(x) static_assert(false, "WriterMutexLock declaration missing variable name")
-
-}  // namespace duckdb_re2
-
-#endif  // UTIL_MUTEX_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_STRUTIL_H_
-#define UTIL_STRUTIL_H_
-
-#include <string>
-
-
-
-
-namespace duckdb_re2 {
-
-std::string CEscape(const StringPiece& src);
-void PrefixSuccessor(std::string* prefix);
-std::string StringPrintf(const char* format, ...);
-void SStringPrintf(std::string* dst, const char* format, ...);
-void StringAppendF(std::string* dst, const char* format, ...);
-
-}  // namespace duckdb_re2
-
-#endif  // UTIL_STRUTIL_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-
-// Silence "zero-sized array in struct/union" warning for DFA::State::next_.
-#ifdef _MSC_VER
-//#pragma warning(disable: 4200)
-#endif
-
-namespace duckdb_re2 {
-
-#if !defined(__linux__)  /* only Linux seems to have memrchr */
-static void* memrchr(const void* s, int c, size_t n) {
-  const unsigned char* p = (const unsigned char*)s;
-  for (p += n; n > 0; n--)
-    if (*--p == c)
-      return (void*)p;
-
-  return NULL;
-}
-#endif
-
-// Controls whether the DFA should bail out early if the NFA would be faster.
-static bool dfa_should_bail_when_slow = true;
-
-// A DFA implementation of a regular expression program.
-// Since this is entirely a forward declaration mandated by C++,
-// some of the comments here are better understood after reading
-// the comments in the sections that follow the DFA definition.
-class DFA {
- public:
-  DFA(Prog* prog, Prog::MatchKind kind, int64_t max_mem);
-  ~DFA();
-  bool ok() const { return !init_failed_; }
-  Prog::MatchKind kind() { return kind_; }
-
-  // Searches for the regular expression in text, which is considered
-  // as a subsection of context for the purposes of interpreting flags
-  // like ^ and $ and \A and \z.
-  // Returns whether a match was found.
-  // If a match is found, sets *ep to the end point of the best match in text.
-  // If "anchored", the match must begin at the start of text.
-  // If "want_earliest_match", the match that ends first is used, not
-  //   necessarily the best one.
-  // If "run_forward" is true, the DFA runs from text.begin() to text.end().
-  //   If it is false, the DFA runs from text.end() to text.begin(),
-  //   returning the leftmost end of the match instead of the rightmost one.
-  // If the DFA cannot complete the search (for example, if it is out of
-  //   memory), it sets *failed and returns false.
-  bool Search(const StringPiece& text, const StringPiece& context,
-              bool anchored, bool want_earliest_match, bool run_forward,
-              bool* failed, const char** ep, SparseSet* matches);
-
-  // Builds out all states for the entire DFA.
-  // If cb is not empty, it receives one callback per state built.
-  // Returns the number of states built.
-  // FOR TESTING OR EXPERIMENTAL PURPOSES ONLY.
-  int BuildAllStates(const Prog::DFAStateCallback& cb);
-
-  // Computes min and max for matching strings.  Won't return strings
-  // bigger than maxlen.
-  bool PossibleMatchRange(std::string* min, std::string* max, int maxlen);
-
-  // These data structures are logically private, but C++ makes it too
-  // difficult to mark them as such.
-  class RWLocker;
-  class StateSaver;
-  class Workq;
-
-  // A single DFA state.  The DFA is represented as a graph of these
-  // States, linked by the next_ pointers.  If in state s and reading
-  // byte c, the next state should be s->next_[c].
-  struct State {
-    inline bool IsMatch() const { return (flag_ & kFlagMatch) != 0; }
-    void SaveMatch(std::vector<int>* v);
-
-    int* inst_;         // Instruction pointers in the state.
-    int ninst_;         // # of inst_ pointers.
-    uint32_t flag_;     // Empty string bitfield flags in effect on the way
-                        // into this state, along with kFlagMatch if this
-                        // is a matching state.
-
-// Work around the bug affecting flexible array members in GCC 6.x (for x >= 1).
-// (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70932)
-    std::atomic<State*> next_[1];    // Outgoing arrows from State,
-                        // one per input byte class
-  };
-
-  // Marks separate thread groups of different priority
-  // in the work queue when in leftmost-longest matching mode.
-  constexpr static int32_t Mark = -1;
-  // Separates the match IDs from the instructions in inst_.
-  // Used only for "many match" DFA states.
-  constexpr static int32_t MatchSep = -2;
-
-  enum {
-    kByteEndText = 256,         // imaginary byte at end of text
-
-    kFlagEmptyMask = 0xFF,      // State.flag_: bits holding kEmptyXXX flags
-    kFlagMatch = 0x0100,        // State.flag_: this is a matching state
-    kFlagLastWord = 0x0200,     // State.flag_: last byte was a word char
-    kFlagNeedShift = 16,        // needed kEmpty bits are or'ed in shifted left
-  };
-
-  struct StateHash {
-    size_t operator()(const State* a) const {
-      DCHECK(a != NULL);
-      HashMix mix(a->flag_);
-      for (int i = 0; i < a->ninst_; i++)
-        mix.Mix(a->inst_[i]);
-      mix.Mix(0);
-      return mix.get();
-    }
-  };
-
-  struct StateEqual {
-    bool operator()(const State* a, const State* b) const {
-      DCHECK(a != NULL);
-      DCHECK(b != NULL);
-      if (a == b)
-        return true;
-      if (a->flag_ != b->flag_)
-        return false;
-      if (a->ninst_ != b->ninst_)
-        return false;
-      for (int i = 0; i < a->ninst_; i++)
-        if (a->inst_[i] != b->inst_[i])
-          return false;
-      return true;
-    }
-  };
-
-  typedef std::unordered_set<State*, StateHash, StateEqual> StateSet;
-
- private:
-  // Special "first_byte" values for a state.  (Values >= 0 denote actual bytes.)
-  enum {
-    kFbUnknown = -1,   // No analysis has been performed.
-    kFbNone = -2,      // The first-byte trick cannot be used.
-  };
-
-  enum {
-    // Indices into start_ for unanchored searches.
-    // Add kStartAnchored for anchored searches.
-    kStartBeginText = 0,          // text at beginning of context
-    kStartBeginLine = 2,          // text at beginning of line
-    kStartAfterWordChar = 4,      // text follows a word character
-    kStartAfterNonWordChar = 6,   // text follows non-word character
-    kMaxStart = 8,
-
-    kStartAnchored = 1,
-  };
-
-  // Resets the DFA State cache, flushing all saved State* information.
-  // Releases and reacquires cache_mutex_ via cache_lock, so any
-  // State* existing before the call are not valid after the call.
-  // Use a StateSaver to preserve important states across the call.
-  // cache_mutex_.r <= L < mutex_
-  // After: cache_mutex_.w <= L < mutex_
-  void ResetCache(RWLocker* cache_lock);
-
-  // Looks up and returns the State corresponding to a Workq.
-  // L >= mutex_
-  State* WorkqToCachedState(Workq* q, Workq* mq, uint32_t flag);
-
-  // Looks up and returns a State matching the inst, ninst, and flag.
-  // L >= mutex_
-  State* CachedState(int* inst, int ninst, uint32_t flag);
-
-  // Clear the cache entirely.
-  // Must hold cache_mutex_.w or be in destructor.
-  void ClearCache();
-
-  // Converts a State into a Workq: the opposite of WorkqToCachedState.
-  // L >= mutex_
-  void StateToWorkq(State* s, Workq* q);
-
-  // Runs a State on a given byte, returning the next state.
-  State* RunStateOnByteUnlocked(State*, int);  // cache_mutex_.r <= L < mutex_
-  State* RunStateOnByte(State*, int);          // L >= mutex_
-
-  // Runs a Workq on a given byte followed by a set of empty-string flags,
-  // producing a new Workq in nq.  If a match instruction is encountered,
-  // sets *ismatch to true.
-  // L >= mutex_
-  void RunWorkqOnByte(Workq* q, Workq* nq,
-                      int c, uint32_t flag, bool* ismatch);
-
-  // Runs a Workq on a set of empty-string flags, producing a new Workq in nq.
-  // L >= mutex_
-  void RunWorkqOnEmptyString(Workq* q, Workq* nq, uint32_t flag);
-
-  // Adds the instruction id to the Workq, following empty arrows
-  // according to flag.
-  // L >= mutex_
-  void AddToQueue(Workq* q, int id, uint32_t flag);
-
-  // For debugging, returns a text representation of State.
-  static std::string DumpState(State* state);
-
-  // For debugging, returns a text representation of a Workq.
-  static std::string DumpWorkq(Workq* q);
-
-  // Search parameters
-  struct SearchParams {
-    SearchParams(const StringPiece& text, const StringPiece& context,
-                 RWLocker* cache_lock)
-      : text(text), context(context),
-        anchored(false),
-        want_earliest_match(false),
-        run_forward(false),
-        start(NULL),
-        first_byte(kFbUnknown),
-        cache_lock(cache_lock),
-        failed(false),
-        ep(NULL),
-        matches(NULL) { }
-
-    StringPiece text;
-    StringPiece context;
-    bool anchored;
-    bool want_earliest_match;
-    bool run_forward;
-    State* start;
-    int first_byte;
-    RWLocker *cache_lock;
-    bool failed;     // "out" parameter: whether search gave up
-    const char* ep;  // "out" parameter: end pointer for match
-    SparseSet* matches;
-
-   private:
-    SearchParams(const SearchParams&) = delete;
-    SearchParams& operator=(const SearchParams&) = delete;
-  };
-
-  // Before each search, the parameters to Search are analyzed by
-  // AnalyzeSearch to determine the state in which to start and the
-  // "first_byte" for that state, if any.
-  struct StartInfo {
-    StartInfo() : start(NULL), first_byte(kFbUnknown) {}
-    State* start;
-    std::atomic<int> first_byte;
-  };
-
-  // Fills in params->start and params->first_byte using
-  // the other search parameters.  Returns true on success,
-  // false on failure.
-  // cache_mutex_.r <= L < mutex_
-  bool AnalyzeSearch(SearchParams* params);
-  bool AnalyzeSearchHelper(SearchParams* params, StartInfo* info,
-                           uint32_t flags);
-
-  // The generic search loop, inlined to create specialized versions.
-  // cache_mutex_.r <= L < mutex_
-  // Might unlock and relock cache_mutex_ via params->cache_lock.
-  inline bool InlinedSearchLoop(SearchParams* params,
-                                bool have_first_byte,
-                                bool want_earliest_match,
-                                bool run_forward);
-
-  // The specialized versions of InlinedSearchLoop.  The three letters
-  // at the ends of the name denote the true/false values used as the
-  // last three parameters of InlinedSearchLoop.
-  // cache_mutex_.r <= L < mutex_
-  // Might unlock and relock cache_mutex_ via params->cache_lock.
-  bool SearchFFF(SearchParams* params);
-  bool SearchFFT(SearchParams* params);
-  bool SearchFTF(SearchParams* params);
-  bool SearchFTT(SearchParams* params);
-  bool SearchTFF(SearchParams* params);
-  bool SearchTFT(SearchParams* params);
-  bool SearchTTF(SearchParams* params);
-  bool SearchTTT(SearchParams* params);
-
-  // The main search loop: calls an appropriate specialized version of
-  // InlinedSearchLoop.
-  // cache_mutex_.r <= L < mutex_
-  // Might unlock and relock cache_mutex_ via params->cache_lock.
-  bool FastSearchLoop(SearchParams* params);
-
-  // For debugging, a slow search loop that calls InlinedSearchLoop
-  // directly -- because the booleans passed are not constants, the
-  // loop is not specialized like the SearchFFF etc. versions, so it
-  // runs much more slowly.  Useful only for debugging.
-  // cache_mutex_.r <= L < mutex_
-  // Might unlock and relock cache_mutex_ via params->cache_lock.
-  bool SlowSearchLoop(SearchParams* params);
-
-  // Looks up bytes in bytemap_ but handles case c == kByteEndText too.
-  int ByteMap(int c) {
-    if (c == kByteEndText)
-      return prog_->bytemap_range();
-    return prog_->bytemap()[c];
-  }
-
-  // Constant after initialization.
-  Prog* prog_;              // The regular expression program to run.
-  Prog::MatchKind kind_;    // The kind of DFA.
-  bool init_failed_;        // initialization failed (out of memory)
-
-  Mutex mutex_;  // mutex_ >= cache_mutex_.r
-
-  // Scratch areas, protected by mutex_.
-  Workq* q0_;             // Two pre-allocated work queues.
-  Workq* q1_;
-  PODArray<int> stack_;   // Pre-allocated stack for AddToQueue
-
-  // State* cache.  Many threads use and add to the cache simultaneously,
-  // holding cache_mutex_ for reading and mutex_ (above) when adding.
-  // If the cache fills and needs to be discarded, the discarding is done
-  // while holding cache_mutex_ for writing, to avoid interrupting other
-  // readers.  Any State* pointers are only valid while cache_mutex_
-  // is held.
-  Mutex cache_mutex_;
-  int64_t mem_budget_;     // Total memory budget for all States.
-  int64_t state_budget_;   // Amount of memory remaining for new States.
-  StateSet state_cache_;   // All States computed so far.
-  StartInfo start_[kMaxStart];
-};
-
-// Shorthand for casting to uint8_t*.
-static inline const uint8_t* BytePtr(const void* v) {
-  return reinterpret_cast<const uint8_t*>(v);
-}
-
-// Work queues
-
-// Internally, the DFA uses a sparse array of
-// program instruction pointers as a work queue.
-// In leftmost longest mode, marks separate sections
-// of workq that started executing at different
-// locations in the string (earlier locations first).
-class DFA::Workq : public SparseSet {
- public:
-  // Constructor: n is number of normal slots, maxmark number of mark slots.
-  Workq(int n, int maxmark) :
-    SparseSet(n+maxmark),
-    n_(n),
-    maxmark_(maxmark),
-    nextmark_(n),
-    last_was_mark_(true) {
-  }
-
-  bool is_mark(int i) { return i >= n_; }
-
-  int maxmark() { return maxmark_; }
-
-  void clear() {
-    SparseSet::clear();
-    nextmark_ = n_;
-  }
-
-  void mark() {
-    if (last_was_mark_)
-      return;
-    last_was_mark_ = false;
-    SparseSet::insert_new(nextmark_++);
-  }
-
-  int size() {
-    return n_ + maxmark_;
-  }
-
-  void insert(int id) {
-    if (contains(id))
-      return;
-    insert_new(id);
-  }
-
-  void insert_new(int id) {
-    last_was_mark_ = false;
-    SparseSet::insert_new(id);
-  }
-
- private:
-  int n_;                // size excluding marks
-  int maxmark_;          // maximum number of marks
-  int nextmark_;         // id of next mark
-  bool last_was_mark_;   // last inserted was mark
-
-  Workq(const Workq&) = delete;
-  Workq& operator=(const Workq&) = delete;
-};
-
-DFA::DFA(Prog* prog, Prog::MatchKind kind, int64_t max_mem)
-  : prog_(prog),
-    kind_(kind),
-    init_failed_(false),
-    q0_(NULL),
-    q1_(NULL),
-    mem_budget_(max_mem) {
-  int nmark = 0;
-  if (kind_ == Prog::kLongestMatch)
-    nmark = prog_->size();
-  // See DFA::AddToQueue() for why this is so.
-  int nstack = prog_->inst_count(kInstCapture) +
-               prog_->inst_count(kInstEmptyWidth) +
-               prog_->inst_count(kInstNop) +
-               nmark + 1;  // + 1 for start inst
-
-  // Account for space needed for DFA, q0, q1, stack.
-  mem_budget_ -= sizeof(DFA);
-  mem_budget_ -= (prog_->size() + nmark) *
-                 (sizeof(int)+sizeof(int)) * 2;  // q0, q1
-  mem_budget_ -= nstack * sizeof(int);  // stack
-  if (mem_budget_ < 0) {
-    init_failed_ = true;
-    return;
-  }
-
-  state_budget_ = mem_budget_;
-
-  // Make sure there is a reasonable amount of working room left.
-  // At minimum, the search requires room for two states in order
-  // to limp along, restarting frequently.  We'll get better performance
-  // if there is room for a larger number of states, say 20.
-  // Note that a state stores list heads only, so we use the program
-  // list count for the upper bound, not the program size.
-  int nnext = prog_->bytemap_range() + 1;  // + 1 for kByteEndText slot
-  int64_t one_state = sizeof(State) + nnext*sizeof(std::atomic<State*>) +
-                      (prog_->list_count()+nmark)*sizeof(int);
-  if (state_budget_ < 20*one_state) {
-    init_failed_ = true;
-    return;
-  }
-
-  q0_ = new Workq(prog_->size(), nmark);
-  q1_ = new Workq(prog_->size(), nmark);
-  stack_ = PODArray<int>(nstack);
-}
-
-DFA::~DFA() {
-  delete q0_;
-  delete q1_;
-  ClearCache();
-}
-
-// In the DFA state graph, s->next[c] == NULL means that the
-// state has not yet been computed and needs to be.  We need
-// a different special value to signal that s->next[c] is a
-// state that can never lead to a match (and thus the search
-// can be called off).  Hence DeadState.
-#define DeadState reinterpret_cast<State*>(1)
-
-// Signals that the rest of the string matches no matter what it is.
-#define FullMatchState reinterpret_cast<State*>(2)
-
-#define SpecialStateMax FullMatchState
-
-// Debugging printouts
-
-// For debugging, returns a string representation of the work queue.
-std::string DFA::DumpWorkq(Workq* q) {
-  std::string s;
-  const char* sep = "";
-  for (Workq::iterator it = q->begin(); it != q->end(); ++it) {
-    if (q->is_mark(*it)) {
-      StringAppendF(&s, "|");
-      sep = "";
-    } else {
-      StringAppendF(&s, "%s%d", sep, *it);
-      sep = ",";
-    }
-  }
-  return s;
-}
-
-// For debugging, returns a string representation of the state.
-std::string DFA::DumpState(State* state) {
-  if (state == NULL)
-    return "_";
-  if (state == DeadState)
-    return "X";
-  if (state == FullMatchState)
-    return "*";
-  std::string s;
-  const char* sep = "";
-  StringAppendF(&s, "(%p)", state);
-  for (int i = 0; i < state->ninst_; i++) {
-    if (state->inst_[i] == Mark) {
-      StringAppendF(&s, "|");
-      sep = "";
-    } else if (state->inst_[i] == MatchSep) {
-      StringAppendF(&s, "||");
-      sep = "";
-    } else {
-      StringAppendF(&s, "%s%d", sep, state->inst_[i]);
-      sep = ",";
-    }
-  }
-  StringAppendF(&s, " flag=%#x", state->flag_);
-  return s;
-}
-
-//////////////////////////////////////////////////////////////////////
-//
-// DFA state graph construction.
-//
-// The DFA state graph is a heavily-linked collection of State* structures.
-// The state_cache_ is a set of all the State structures ever allocated,
-// so that if the same state is reached by two different paths,
-// the same State structure can be used.  This reduces allocation
-// requirements and also avoids duplication of effort across the two
-// identical states.
-//
-// A State is defined by an ordered list of instruction ids and a flag word.
-//
-// The choice of an ordered list of instructions differs from a typical
-// textbook DFA implementation, which would use an unordered set.
-// Textbook descriptions, however, only care about whether
-// the DFA matches, not where it matches in the text.  To decide where the
-// DFA matches, we need to mimic the behavior of the dominant backtracking
-// implementations like PCRE, which try one possible regular expression
-// execution, then another, then another, stopping when one of them succeeds.
-// The DFA execution tries these many executions in parallel, representing
-// each by an instruction id.  These pointers are ordered in the State.inst_
-// list in the same order that the executions would happen in a backtracking
-// search: if a match is found during execution of inst_[2], inst_[i] for i>=3
-// can be discarded.
-//
-// Textbooks also typically do not consider context-aware empty string operators
-// like ^ or $.  These are handled by the flag word, which specifies the set
-// of empty-string operators that should be matched when executing at the
-// current text position.  These flag bits are defined in prog.h.
-// The flag word also contains two DFA-specific bits: kFlagMatch if the state
-// is a matching state (one that reached a kInstMatch in the program)
-// and kFlagLastWord if the last processed byte was a word character, for the
-// implementation of \B and \b.
-//
-// The flag word also contains, shifted up 16 bits, the bits looked for by
-// any kInstEmptyWidth instructions in the state.  These provide a useful
-// summary indicating when new flags might be useful.
-//
-// The permanent representation of a State's instruction ids is just an array,
-// but while a state is being analyzed, these instruction ids are represented
-// as a Workq, which is an array that allows iteration in insertion order.
-
-// NOTE(rsc): The choice of State construction determines whether the DFA
-// mimics backtracking implementations (so-called leftmost first matching) or
-// traditional DFA implementations (so-called leftmost longest matching as
-// prescribed by POSIX).  This implementation chooses to mimic the
-// backtracking implementations, because we want to replace PCRE.  To get
-// POSIX behavior, the states would need to be considered not as a simple
-// ordered list of instruction ids, but as a list of unordered sets of instruction
-// ids.  A match by a state in one set would inhibit the running of sets
-// farther down the list but not other instruction ids in the same set.  Each
-// set would correspond to matches beginning at a given point in the string.
-// This is implemented by separating different sets with Mark pointers.
-
-// Looks in the State cache for a State matching q, flag.
-// If one is found, returns it.  If one is not found, allocates one,
-// inserts it in the cache, and returns it.
-// If mq is not null, MatchSep and the match IDs in mq will be appended
-// to the State.
-DFA::State* DFA::WorkqToCachedState(Workq* q, Workq* mq, uint32_t flag) {
-  //mutex_.AssertHeld();
-
-  // Construct array of instruction ids for the new state.
-  // Only ByteRange, EmptyWidth, and Match instructions are useful to keep:
-  // those are the only operators with any effect in
-  // RunWorkqOnEmptyString or RunWorkqOnByte.
-  int* inst = new int[q->size()];
-  int n = 0;
-  uint32_t needflags = 0;  // flags needed by kInstEmptyWidth instructions
-  bool sawmatch = false;   // whether queue contains guaranteed kInstMatch
-  bool sawmark = false;    // whether queue contains a Mark
-  for (Workq::iterator it = q->begin(); it != q->end(); ++it) {
-    int id = *it;
-    if (sawmatch && (kind_ == Prog::kFirstMatch || q->is_mark(id)))
-      break;
-    if (q->is_mark(id)) {
-      if (n > 0 && inst[n-1] != Mark) {
-        sawmark = true;
-        inst[n++] = Mark;
-      }
-      continue;
-    }
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-      case kInstAltMatch:
-        // This state will continue to a match no matter what
-        // the rest of the input is.  If it is the highest priority match
-        // being considered, return the special FullMatchState
-        // to indicate that it's all matches from here out.
-        if (kind_ != Prog::kManyMatch &&
-            (kind_ != Prog::kFirstMatch ||
-             (it == q->begin() && ip->greedy(prog_))) &&
-            (kind_ != Prog::kLongestMatch || !sawmark) &&
-            (flag & kFlagMatch)) {
-          delete[] inst;
-          return FullMatchState;
-        }
-        FALLTHROUGH_INTENDED;
-      default:
-        // Record iff id is the head of its list, which must
-        // be the case if id-1 is the last of *its* list. :)
-        if (prog_->inst(id-1)->last())
-          inst[n++] = *it;
-        if (ip->opcode() == kInstEmptyWidth)
-          needflags |= ip->empty();
-        if (ip->opcode() == kInstMatch && !prog_->anchor_end())
-          sawmatch = true;
-        break;
-    }
-  }
-  DCHECK_LE(n, q->size());
-  if (n > 0 && inst[n-1] == Mark)
-    n--;
-
-  // If there are no empty-width instructions waiting to execute,
-  // then the extra flag bits will not be used, so there is no
-  // point in saving them.  (Discarding them reduces the number
-  // of distinct states.)
-  if (needflags == 0)
-    flag &= kFlagMatch;
-
-  // NOTE(rsc): The code above cannot do flag &= needflags,
-  // because if the right flags were present to pass the current
-  // kInstEmptyWidth instructions, new kInstEmptyWidth instructions
-  // might be reached that in turn need different flags.
-  // The only sure thing is that if there are no kInstEmptyWidth
-  // instructions at all, no flags will be needed.
-  // We could do the extra work to figure out the full set of
-  // possibly needed flags by exploring past the kInstEmptyWidth
-  // instructions, but the check above -- are any flags needed
-  // at all? -- handles the most common case.  More fine-grained
-  // analysis can only be justified by measurements showing that
-  // too many redundant states are being allocated.
-
-  // If there are no Insts in the list, it's a dead state,
-  // which is useful to signal with a special pointer so that
-  // the execution loop can stop early.  This is only okay
-  // if the state is *not* a matching state.
-  if (n == 0 && flag == 0) {
-    delete[] inst;
-    return DeadState;
-  }
-
-  // If we're in longest match mode, the state is a sequence of
-  // unordered state sets separated by Marks.  Sort each set
-  // to canonicalize, to reduce the number of distinct sets stored.
-  if (kind_ == Prog::kLongestMatch) {
-    int* ip = inst;
-    int* ep = ip + n;
-    while (ip < ep) {
-      int* markp = ip;
-      while (markp < ep && *markp != Mark)
-        markp++;
-      std::sort(ip, markp);
-      if (markp < ep)
-        markp++;
-      ip = markp;
-    }
-  }
-
-  // Append MatchSep and the match IDs in mq if necessary.
-  if (mq != NULL) {
-    inst[n++] = MatchSep;
-    for (Workq::iterator i = mq->begin(); i != mq->end(); ++i) {
-      int id = *i;
-      Prog::Inst* ip = prog_->inst(id);
-      if (ip->opcode() == kInstMatch)
-        inst[n++] = ip->match_id();
-    }
-  }
-
-  // Save the needed empty-width flags in the top bits for use later.
-  flag |= needflags << kFlagNeedShift;
-
-  State* state = CachedState(inst, n, flag);
-  delete[] inst;
-  return state;
-}
-
-// Looks in the State cache for a State matching inst, ninst, flag.
-// If one is found, returns it.  If one is not found, allocates one,
-// inserts it in the cache, and returns it.
-DFA::State* DFA::CachedState(int* inst, int ninst, uint32_t flag) {
-  //mutex_.AssertHeld();
-
-  // Look in the cache for a pre-existing state.
-  // We have to initialise the struct like this because otherwise
-  // MSVC will complain about the flexible array member. :(
-  State state;
-  state.inst_ = inst;
-  state.ninst_ = ninst;
-  state.flag_ = flag;
-  StateSet::iterator it = state_cache_.find(&state);
-  if (it != state_cache_.end()) {
-    return *it;
-  }
-
-  // Must have enough memory for new state.
-  // In addition to what we're going to allocate,
-  // the state cache hash table seems to incur about 40 bytes per
-  // State*, empirically.
-  const int kStateCacheOverhead = 40;
-  int nnext = prog_->bytemap_range() + 1;  // + 1 for kByteEndText slot
-  int mem = sizeof(State) + nnext*sizeof(std::atomic<State*>) +
-            ninst*sizeof(int);
-  if (mem_budget_ < mem + kStateCacheOverhead) {
-    mem_budget_ = -1;
-    return NULL;
-  }
-  mem_budget_ -= mem + kStateCacheOverhead;
-
-  // Allocate new state along with room for next_ and inst_.
-  char* space = std::allocator<char>().allocate(mem);
-  State* s = new (space) State;
-  (void) new (s->next_) std::atomic<State*>[nnext];
-  // Work around a unfortunate bug in older versions of libstdc++.
-  // (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64658)
-  for (int i = 0; i < nnext; i++)
-    (void) new (s->next_ + i) std::atomic<State*>(NULL);
-  s->inst_ = new (s->next_ + nnext) int[ninst];
-  memmove(s->inst_, inst, ninst*sizeof s->inst_[0]);
-  s->ninst_ = ninst;
-  s->flag_ = flag;
-  // Put state in cache and return it.
-  state_cache_.insert(s);
-  return s;
-}
-
-// Clear the cache.  Must hold cache_mutex_.w or be in destructor.
-void DFA::ClearCache() {
-  StateSet::iterator begin = state_cache_.begin();
-  StateSet::iterator end = state_cache_.end();
-  while (begin != end) {
-    StateSet::iterator tmp = begin;
-    ++begin;
-    // Deallocate the blob of memory that we allocated in DFA::CachedState().
-    // We recompute mem in order to benefit from sized delete where possible.
-    int ninst = (*tmp)->ninst_;
-    int nnext = prog_->bytemap_range() + 1;  // + 1 for kByteEndText slot
-    int mem = sizeof(State) + nnext*sizeof(std::atomic<State*>) +
-              ninst*sizeof(int);
-    std::allocator<char>().deallocate(reinterpret_cast<char*>(*tmp), mem);
-  }
-  state_cache_.clear();
-}
-
-// Copies insts in state s to the work queue q.
-void DFA::StateToWorkq(State* s, Workq* q) {
-  q->clear();
-  for (int i = 0; i < s->ninst_; i++) {
-    if (s->inst_[i] == Mark) {
-      q->mark();
-    } else if (s->inst_[i] == MatchSep) {
-      // Nothing after this is an instruction!
-      break;
-    } else {
-      // Explore from the head of the list.
-      AddToQueue(q, s->inst_[i], s->flag_ & kFlagEmptyMask);
-    }
-  }
-}
-
-// Adds ip to the work queue, following empty arrows according to flag.
-void DFA::AddToQueue(Workq* q, int id, uint32_t flag) {
-
-  // Use stack_ to hold our stack of instructions yet to process.
-  // It was preallocated as follows:
-  //   one entry per Capture;
-  //   one entry per EmptyWidth; and
-  //   one entry per Nop.
-  // This reflects the maximum number of stack pushes that each can
-  // perform. (Each instruction can be processed at most once.)
-  // When using marks, we also added nmark == prog_->size().
-  // (Otherwise, nmark == 0.)
-  int* stk = stack_.data();
-  int nstk = 0;
-
-  stk[nstk++] = id;
-  while (nstk > 0) {
-    DCHECK_LE(nstk, stack_.size());
-    id = stk[--nstk];
-
-  Loop:
-    if (id == Mark) {
-      q->mark();
-      continue;
-    }
-
-    if (id == 0)
-      continue;
-
-    // If ip is already on the queue, nothing to do.
-    // Otherwise add it.  We don't actually keep all the
-    // ones that get added, but adding all of them here
-    // increases the likelihood of q->contains(id),
-    // reducing the amount of duplicated work.
-    if (q->contains(id))
-      continue;
-    q->insert_new(id);
-
-    // Process instruction.
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstByteRange:  // just save these on the queue
-      case kInstMatch:
-        if (ip->last())
-          break;
-        id = id+1;
-        goto Loop;
-
-      case kInstCapture:    // DFA treats captures as no-ops.
-      case kInstNop:
-        if (!ip->last())
-          stk[nstk++] = id+1;
-
-        // If this instruction is the [00-FF]* loop at the beginning of
-        // a leftmost-longest unanchored search, separate with a Mark so
-        // that future threads (which will start farther to the right in
-        // the input string) are lower priority than current threads.
-        if (ip->opcode() == kInstNop && q->maxmark() > 0 &&
-            id == prog_->start_unanchored() && id != prog_->start())
-          stk[nstk++] = Mark;
-        id = ip->out();
-        goto Loop;
-
-      case kInstAltMatch:
-        DCHECK(!ip->last());
-        id = id+1;
-        goto Loop;
-
-      case kInstEmptyWidth:
-        if (!ip->last())
-          stk[nstk++] = id+1;
-
-        // Continue on if we have all the right flag bits.
-        if (ip->empty() & ~flag)
-          break;
-        id = ip->out();
-        goto Loop;
-    }
-  }
-}
-
-// Running of work queues.  In the work queue, order matters:
-// the queue is sorted in priority order.  If instruction i comes before j,
-// then the instructions that i produces during the run must come before
-// the ones that j produces.  In order to keep this invariant, all the
-// work queue runners have to take an old queue to process and then
-// also a new queue to fill in.  It's not acceptable to add to the end of
-// an existing queue, because new instructions will not end up in the
-// correct position.
-
-// Runs the work queue, processing the empty strings indicated by flag.
-// For example, flag == kEmptyBeginLine|kEmptyEndLine means to match
-// both ^ and $.  It is important that callers pass all flags at once:
-// processing both ^ and $ is not the same as first processing only ^
-// and then processing only $.  Doing the two-step sequence won't match
-// ^$^$^$ but processing ^ and $ simultaneously will (and is the behavior
-// exhibited by existing implementations).
-void DFA::RunWorkqOnEmptyString(Workq* oldq, Workq* newq, uint32_t flag) {
-  newq->clear();
-  for (Workq::iterator i = oldq->begin(); i != oldq->end(); ++i) {
-    if (oldq->is_mark(*i))
-      AddToQueue(newq, Mark, flag);
-    else
-      AddToQueue(newq, *i, flag);
-  }
-}
-
-// Runs the work queue, processing the single byte c followed by any empty
-// strings indicated by flag.  For example, c == 'a' and flag == kEmptyEndLine,
-// means to match c$.  Sets the bool *ismatch to true if the end of the
-// regular expression program has been reached (the regexp has matched).
-void DFA::RunWorkqOnByte(Workq* oldq, Workq* newq,
-                         int c, uint32_t flag, bool* ismatch) {
-  //mutex_.AssertHeld();
-
-  newq->clear();
-  for (Workq::iterator i = oldq->begin(); i != oldq->end(); ++i) {
-    if (oldq->is_mark(*i)) {
-      if (*ismatch)
-        return;
-      newq->mark();
-      continue;
-    }
-    int id = *i;
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstFail:        // never succeeds
-      case kInstCapture:     // already followed
-      case kInstNop:         // already followed
-      case kInstAltMatch:    // already followed
-      case kInstEmptyWidth:  // already followed
-        break;
-
-      case kInstByteRange:   // can follow if c is in range
-        if (ip->Matches(c))
-          AddToQueue(newq, ip->out(), flag);
-        break;
-
-      case kInstMatch:
-        if (prog_->anchor_end() && c != kByteEndText &&
-            kind_ != Prog::kManyMatch)
-          break;
-        *ismatch = true;
-        if (kind_ == Prog::kFirstMatch) {
-          // Can stop processing work queue since we found a match.
-          return;
-        }
-        break;
-    }
-  }
-}
-
-// Processes input byte c in state, returning new state.
-// Caller does not hold mutex.
-DFA::State* DFA::RunStateOnByteUnlocked(State* state, int c) {
-  // Keep only one RunStateOnByte going
-  // even if the DFA is being run by multiple threads.
-  MutexLock l(&mutex_);
-  return RunStateOnByte(state, c);
-}
-
-// Processes input byte c in state, returning new state.
-DFA::State* DFA::RunStateOnByte(State* state, int c) {
-  //mutex_.AssertHeld();
-
-  if (state <= SpecialStateMax) {
-    if (state == FullMatchState) {
-      // It is convenient for routines like PossibleMatchRange
-      // if we implement RunStateOnByte for FullMatchState:
-      // once you get into this state you never get out,
-      // so it's pretty easy.
-      return FullMatchState;
-    }
-    if (state == DeadState) {
-      LOG(DFATAL) << "DeadState in RunStateOnByte";
-      return NULL;
-    }
-    if (state == NULL) {
-      LOG(DFATAL) << "NULL state in RunStateOnByte";
-      return NULL;
-    }
-    LOG(DFATAL) << "Unexpected special state in RunStateOnByte";
-    return NULL;
-  }
-
-  // If someone else already computed this, return it.
-  State* ns = state->next_[ByteMap(c)].load(std::memory_order_relaxed);
-  if (ns != NULL)
-    return ns;
-
-  // Convert state into Workq.
-  StateToWorkq(state, q0_);
-
-  // Flags marking the kinds of empty-width things (^ $ etc)
-  // around this byte.  Before the byte we have the flags recorded
-  // in the State structure itself.  After the byte we have
-  // nothing yet (but that will change: read on).
-  uint32_t needflag = state->flag_ >> kFlagNeedShift;
-  uint32_t beforeflag = state->flag_ & kFlagEmptyMask;
-  uint32_t oldbeforeflag = beforeflag;
-  uint32_t afterflag = 0;
-
-  if (c == '\n') {
-    // Insert implicit $ and ^ around \n
-    beforeflag |= kEmptyEndLine;
-    afterflag |= kEmptyBeginLine;
-  }
-
-  if (c == kByteEndText) {
-    // Insert implicit $ and \z before the fake "end text" byte.
-    beforeflag |= kEmptyEndLine | kEmptyEndText;
-  }
-
-  // The state flag kFlagLastWord says whether the last
-  // byte processed was a word character.  Use that info to
-  // insert empty-width (non-)word boundaries.
-  bool islastword = (state->flag_ & kFlagLastWord) != 0;
-  bool isword = c != kByteEndText && Prog::IsWordChar(static_cast<uint8_t>(c));
-  if (isword == islastword)
-    beforeflag |= kEmptyNonWordBoundary;
-  else
-    beforeflag |= kEmptyWordBoundary;
-
-  // Okay, finally ready to run.
-  // Only useful to rerun on empty string if there are new, useful flags.
-  if (beforeflag & ~oldbeforeflag & needflag) {
-    RunWorkqOnEmptyString(q0_, q1_, beforeflag);
-    using std::swap;
-    swap(q0_, q1_);
-  }
-  bool ismatch = false;
-  RunWorkqOnByte(q0_, q1_, c, afterflag, &ismatch);
-  using std::swap;
-  swap(q0_, q1_);
-
-  // Save afterflag along with ismatch and isword in new state.
-  uint32_t flag = afterflag;
-  if (ismatch)
-    flag |= kFlagMatch;
-  if (isword)
-    flag |= kFlagLastWord;
-
-  if (ismatch && kind_ == Prog::kManyMatch)
-    ns = WorkqToCachedState(q0_, q1_, flag);
-  else
-    ns = WorkqToCachedState(q0_, NULL, flag);
-
-  // Flush ns before linking to it.
-  // Write barrier before updating state->next_ so that the
-  // main search loop can proceed without any locking, for speed.
-  // (Otherwise it would need one mutex operation per input byte.)
-  state->next_[ByteMap(c)].store(ns, std::memory_order_release);
-  return ns;
-}
-
-
-//////////////////////////////////////////////////////////////////////
-// DFA cache reset.
-
-// Reader-writer lock helper.
-//
-// The DFA uses a reader-writer mutex to protect the state graph itself.
-// Traversing the state graph requires holding the mutex for reading,
-// and discarding the state graph and starting over requires holding the
-// lock for writing.  If a search needs to expand the graph but is out
-// of memory, it will need to drop its read lock and then acquire the
-// write lock.  Since it cannot then atomically downgrade from write lock
-// to read lock, it runs the rest of the search holding the write lock.
-// (This probably helps avoid repeated contention, but really the decision
-// is forced by the Mutex interface.)  It's a bit complicated to keep
-// track of whether the lock is held for reading or writing and thread
-// that through the search, so instead we encapsulate it in the RWLocker
-// and pass that around.
-
-class DFA::RWLocker {
- public:
-  explicit RWLocker(Mutex* mu);
-  ~RWLocker();
-
-  // If the lock is only held for reading right now,
-  // drop the read lock and re-acquire for writing.
-  // Subsequent calls to LockForWriting are no-ops.
-  // Notice that the lock is *released* temporarily.
-  void LockForWriting();
-
- private:
-  Mutex* mu_;
-  bool writing_;
-
-  RWLocker(const RWLocker&) = delete;
-  RWLocker& operator=(const RWLocker&) = delete;
-};
-
-DFA::RWLocker::RWLocker(Mutex* mu) : mu_(mu), writing_(false) {
-  mu_->ReaderLock();
-}
-
-// This function is marked as NO_THREAD_SAFETY_ANALYSIS because the annotations
-// does not support lock upgrade.
-void DFA::RWLocker::LockForWriting() NO_THREAD_SAFETY_ANALYSIS {
-  if (!writing_) {
-    mu_->ReaderUnlock();
-    mu_->WriterLock();
-    writing_ = true;
-  }
-}
-
-DFA::RWLocker::~RWLocker() {
-  if (!writing_)
-    mu_->ReaderUnlock();
-  else
-    mu_->WriterUnlock();
-}
-
-
-// When the DFA's State cache fills, we discard all the states in the
-// cache and start over.  Many threads can be using and adding to the
-// cache at the same time, so we synchronize using the cache_mutex_
-// to keep from stepping on other threads.  Specifically, all the
-// threads using the current cache hold cache_mutex_ for reading.
-// When a thread decides to flush the cache, it drops cache_mutex_
-// and then re-acquires it for writing.  That ensures there are no
-// other threads accessing the cache anymore.  The rest of the search
-// runs holding cache_mutex_ for writing, avoiding any contention
-// with or cache pollution caused by other threads.
-
-void DFA::ResetCache(RWLocker* cache_lock) {
-  // Re-acquire the cache_mutex_ for writing (exclusive use).
-  cache_lock->LockForWriting();
-
-  // Clear the cache, reset the memory budget.
-  for (int i = 0; i < kMaxStart; i++) {
-    start_[i].start = NULL;
-    start_[i].first_byte.store(kFbUnknown, std::memory_order_relaxed);
-  }
-  ClearCache();
-  mem_budget_ = state_budget_;
-}
-
-// Typically, a couple States do need to be preserved across a cache
-// reset, like the State at the current point in the search.
-// The StateSaver class helps keep States across cache resets.
-// It makes a copy of the state's guts outside the cache (before the reset)
-// and then can be asked, after the reset, to recreate the State
-// in the new cache.  For example, in a DFA method ("this" is a DFA):
-//
-//   StateSaver saver(this, s);
-//   ResetCache(cache_lock);
-//   s = saver.Restore();
-//
-// The saver should always have room in the cache to re-create the state,
-// because resetting the cache locks out all other threads, and the cache
-// is known to have room for at least a couple states (otherwise the DFA
-// constructor fails).
-
-class DFA::StateSaver {
- public:
-  explicit StateSaver(DFA* dfa, State* state);
-  ~StateSaver();
-
-  // Recreates and returns a state equivalent to the
-  // original state passed to the constructor.
-  // Returns NULL if the cache has filled, but
-  // since the DFA guarantees to have room in the cache
-  // for a couple states, should never return NULL
-  // if used right after ResetCache.
-  State* Restore();
-
- private:
-  DFA* dfa_;         // the DFA to use
-  int* inst_;        // saved info from State
-  int ninst_;
-  uint32_t flag_;
-  bool is_special_;  // whether original state was special
-  State* special_;   // if is_special_, the original state
-
-  StateSaver(const StateSaver&) = delete;
-  StateSaver& operator=(const StateSaver&) = delete;
-};
-
-DFA::StateSaver::StateSaver(DFA* dfa, State* state) {
-  dfa_ = dfa;
-  if (state <= SpecialStateMax) {
-    inst_ = NULL;
-    ninst_ = 0;
-    flag_ = 0;
-    is_special_ = true;
-    special_ = state;
-    return;
-  }
-  is_special_ = false;
-  special_ = NULL;
-  flag_ = state->flag_;
-  ninst_ = state->ninst_;
-  inst_ = new int[ninst_];
-  memmove(inst_, state->inst_, ninst_*sizeof inst_[0]);
-}
-
-DFA::StateSaver::~StateSaver() {
-  if (!is_special_)
-    delete[] inst_;
-}
-
-DFA::State* DFA::StateSaver::Restore() {
-  if (is_special_)
-    return special_;
-  MutexLock l(&dfa_->mutex_);
-  State* s = dfa_->CachedState(inst_, ninst_, flag_);
-  if (s == NULL)
-    LOG(DFATAL) << "StateSaver failed to restore state.";
-  return s;
-}
-
-
-//////////////////////////////////////////////////////////////////////
-//
-// DFA execution.
-//
-// The basic search loop is easy: start in a state s and then for each
-// byte c in the input, s = s->next[c].
-//
-// This simple description omits a few efficiency-driven complications.
-//
-// First, the State graph is constructed incrementally: it is possible
-// that s->next[c] is null, indicating that that state has not been
-// fully explored.  In this case, RunStateOnByte must be invoked to
-// determine the next state, which is cached in s->next[c] to save
-// future effort.  An alternative reason for s->next[c] to be null is
-// that the DFA has reached a so-called "dead state", in which any match
-// is no longer possible.  In this case RunStateOnByte will return NULL
-// and the processing of the string can stop early.
-//
-// Second, a 256-element pointer array for s->next_ makes each State
-// quite large (2kB on 64-bit machines).  Instead, dfa->bytemap_[]
-// maps from bytes to "byte classes" and then next_ only needs to have
-// as many pointers as there are byte classes.  A byte class is simply a
-// range of bytes that the regexp never distinguishes between.
-// A regexp looking for a[abc] would have four byte ranges -- 0 to 'a'-1,
-// 'a', 'b' to 'c', and 'c' to 0xFF.  The bytemap slows us a little bit
-// but in exchange we typically cut the size of a State (and thus our
-// memory footprint) by about 5-10x.  The comments still refer to
-// s->next[c] for simplicity, but code should refer to s->next_[bytemap_[c]].
-//
-// Third, it is common for a DFA for an unanchored match to begin in a
-// state in which only one particular byte value can take the DFA to a
-// different state.  That is, s->next[c] != s for only one c.  In this
-// situation, the DFA can do better than executing the simple loop.
-// Instead, it can call memchr to search very quickly for the byte c.
-// Whether the start state has this property is determined during a
-// pre-compilation pass, and if so, the byte b is passed to the search
-// loop as the "first_byte" argument, along with a boolean "have_first_byte".
-//
-// Fourth, the desired behavior is to search for the leftmost-best match
-// (approximately, the same one that Perl would find), which is not
-// necessarily the match ending earliest in the string.  Each time a
-// match is found, it must be noted, but the DFA must continue on in
-// hope of finding a higher-priority match.  In some cases, the caller only
-// cares whether there is any match at all, not which one is found.
-// The "want_earliest_match" flag causes the search to stop at the first
-// match found.
-//
-// Fifth, one algorithm that uses the DFA needs it to run over the
-// input string backward, beginning at the end and ending at the beginning.
-// Passing false for the "run_forward" flag causes the DFA to run backward.
-//
-// The checks for these last three cases, which in a naive implementation
-// would be performed once per input byte, slow the general loop enough
-// to merit specialized versions of the search loop for each of the
-// eight possible settings of the three booleans.  Rather than write
-// eight different functions, we write one general implementation and then
-// inline it to create the specialized ones.
-//
-// Note that matches are delayed by one byte, to make it easier to
-// accommodate match conditions depending on the next input byte (like $ and \b).
-// When s->next[c]->IsMatch(), it means that there is a match ending just
-// *before* byte c.
-
-// The generic search loop.  Searches text for a match, returning
-// the pointer to the end of the chosen match, or NULL if no match.
-// The bools are equal to the same-named variables in params, but
-// making them function arguments lets the inliner specialize
-// this function to each combination (see two paragraphs above).
-inline bool DFA::InlinedSearchLoop(SearchParams* params,
-                                   bool have_first_byte,
-                                   bool want_earliest_match,
-                                   bool run_forward) {
-  State* start = params->start;
-  const uint8_t* bp = BytePtr(params->text.begin());  // start of text
-  const uint8_t* p = bp;                              // text scanning point
-  const uint8_t* ep = BytePtr(params->text.end());    // end of text
-  const uint8_t* resetp = NULL;                       // p at last cache reset
-  if (!run_forward) {
-    using std::swap;
-    swap(p, ep);
-  }
-
-  const uint8_t* bytemap = prog_->bytemap();
-  const uint8_t* lastmatch = NULL;   // most recent matching position in text
-  bool matched = false;
-
-  State* s = start;
-
-  if (s->IsMatch()) {
-    matched = true;
-    lastmatch = p;
-    if (params->matches != NULL && kind_ == Prog::kManyMatch) {
-      for (int i = s->ninst_ - 1; i >= 0; i--) {
-        int id = s->inst_[i];
-        if (id == MatchSep)
-          break;
-        params->matches->insert(id);
-      }
-    }
-    if (want_earliest_match) {
-      params->ep = reinterpret_cast<const char*>(lastmatch);
-      return true;
-    }
-  }
-
-  while (p != ep) {
-    if (have_first_byte && s == start) {
-      // In start state, only way out is to find first_byte,
-      // so use optimized assembly in memchr to skip ahead.
-      // If first_byte isn't found, we can skip to the end
-      // of the string.
-      if (run_forward) {
-        if ((p = BytePtr(memchr(p, params->first_byte, ep - p))) == NULL) {
-          p = ep;
-          break;
-        }
-      } else {
-        if ((p = BytePtr(memrchr(ep, params->first_byte, p - ep))) == NULL) {
-          p = ep;
-          break;
-        }
-        p++;
-      }
-    }
-
-    int c;
-    if (run_forward)
-      c = *p++;
-    else
-      c = *--p;
-
-    // Note that multiple threads might be consulting
-    // s->next_[bytemap[c]] simultaneously.
-    // RunStateOnByte takes care of the appropriate locking,
-    // including a memory barrier so that the unlocked access
-    // (sometimes known as "double-checked locking") is safe.
-    // The alternative would be either one DFA per thread
-    // or one mutex operation per input byte.
-    //
-    // ns == DeadState means the state is known to be dead
-    // (no more matches are possible).
-    // ns == NULL means the state has not yet been computed
-    // (need to call RunStateOnByteUnlocked).
-    // RunStateOnByte returns ns == NULL if it is out of memory.
-    // ns == FullMatchState means the rest of the string matches.
-    //
-    // Okay to use bytemap[] not ByteMap() here, because
-    // c is known to be an actual byte and not kByteEndText.
-
-    State* ns = s->next_[bytemap[c]].load(std::memory_order_acquire);
-    if (ns == NULL) {
-      ns = RunStateOnByteUnlocked(s, c);
-      if (ns == NULL) {
-        // After we reset the cache, we hold cache_mutex exclusively,
-        // so if resetp != NULL, it means we filled the DFA state
-        // cache with this search alone (without any other threads).
-        // Benchmarks show that doing a state computation on every
-        // byte runs at about 0.2 MB/s, while the NFA (nfa.cc) can do the
-        // same at about 2 MB/s.  Unless we're processing an average
-        // of 10 bytes per state computation, fail so that RE2 can
-        // fall back to the NFA.
-        if (dfa_should_bail_when_slow && resetp != NULL &&
-            static_cast<size_t>(p - resetp) < 10*state_cache_.size()) {
-          params->failed = true;
-          return false;
-        }
-        resetp = p;
-
-        // Prepare to save start and s across the reset.
-        StateSaver save_start(this, start);
-        StateSaver save_s(this, s);
-
-        // Discard all the States in the cache.
-        ResetCache(params->cache_lock);
-
-        // Restore start and s so we can continue.
-        if ((start = save_start.Restore()) == NULL ||
-            (s = save_s.Restore()) == NULL) {
-          // Restore already did LOG(DFATAL).
-          params->failed = true;
-          return false;
-        }
-        ns = RunStateOnByteUnlocked(s, c);
-        if (ns == NULL) {
-          LOG(DFATAL) << "RunStateOnByteUnlocked failed after ResetCache";
-          params->failed = true;
-          return false;
-        }
-      }
-    }
-    if (ns <= SpecialStateMax) {
-      if (ns == DeadState) {
-        params->ep = reinterpret_cast<const char*>(lastmatch);
-        return matched;
-      }
-      // FullMatchState
-      params->ep = reinterpret_cast<const char*>(ep);
-      return true;
-    }
-
-    s = ns;
-    if (s->IsMatch()) {
-      matched = true;
-      // The DFA notices the match one byte late,
-      // so adjust p before using it in the match.
-      if (run_forward)
-        lastmatch = p - 1;
-      else
-        lastmatch = p + 1;
-      if (params->matches != NULL && kind_ == Prog::kManyMatch) {
-        for (int i = s->ninst_ - 1; i >= 0; i--) {
-          int id = s->inst_[i];
-          if (id == MatchSep)
-            break;
-          params->matches->insert(id);
-        }
-      }
-      if (want_earliest_match) {
-        params->ep = reinterpret_cast<const char*>(lastmatch);
-        return true;
-      }
-    }
-  }
-
-  // Process one more byte to see if it triggers a match.
-  // (Remember, matches are delayed one byte.)
-  int lastbyte;
-  if (run_forward) {
-    if (params->text.end() == params->context.end())
-      lastbyte = kByteEndText;
-    else
-      lastbyte = params->text.end()[0] & 0xFF;
-  } else {
-    if (params->text.begin() == params->context.begin())
-      lastbyte = kByteEndText;
-    else
-      lastbyte = params->text.begin()[-1] & 0xFF;
-  }
-
-  State* ns = s->next_[ByteMap(lastbyte)].load(std::memory_order_acquire);
-  if (ns == NULL) {
-    ns = RunStateOnByteUnlocked(s, lastbyte);
-    if (ns == NULL) {
-      StateSaver save_s(this, s);
-      ResetCache(params->cache_lock);
-      if ((s = save_s.Restore()) == NULL) {
-        params->failed = true;
-        return false;
-      }
-      ns = RunStateOnByteUnlocked(s, lastbyte);
-      if (ns == NULL) {
-        LOG(DFATAL) << "RunStateOnByteUnlocked failed after Reset";
-        params->failed = true;
-        return false;
-      }
-    }
-  }
-  if (ns <= SpecialStateMax) {
-    if (ns == DeadState) {
-      params->ep = reinterpret_cast<const char*>(lastmatch);
-      return matched;
-    }
-    // FullMatchState
-    params->ep = reinterpret_cast<const char*>(ep);
-    return true;
-  }
-
-  s = ns;
-  if (s->IsMatch()) {
-    matched = true;
-    lastmatch = p;
-    if (params->matches != NULL && kind_ == Prog::kManyMatch) {
-      for (int i = s->ninst_ - 1; i >= 0; i--) {
-        int id = s->inst_[i];
-        if (id == MatchSep)
-          break;
-        params->matches->insert(id);
-      }
-    }
-  }
-
-  params->ep = reinterpret_cast<const char*>(lastmatch);
-  return matched;
-}
-
-// Inline specializations of the general loop.
-bool DFA::SearchFFF(SearchParams* params) {
-  return InlinedSearchLoop(params, 0, 0, 0);
-}
-bool DFA::SearchFFT(SearchParams* params) {
-  return InlinedSearchLoop(params, 0, 0, 1);
-}
-bool DFA::SearchFTF(SearchParams* params) {
-  return InlinedSearchLoop(params, 0, 1, 0);
-}
-bool DFA::SearchFTT(SearchParams* params) {
-  return InlinedSearchLoop(params, 0, 1, 1);
-}
-bool DFA::SearchTFF(SearchParams* params) {
-  return InlinedSearchLoop(params, 1, 0, 0);
-}
-bool DFA::SearchTFT(SearchParams* params) {
-  return InlinedSearchLoop(params, 1, 0, 1);
-}
-bool DFA::SearchTTF(SearchParams* params) {
-  return InlinedSearchLoop(params, 1, 1, 0);
-}
-bool DFA::SearchTTT(SearchParams* params) {
-  return InlinedSearchLoop(params, 1, 1, 1);
-}
-
-// For debugging, calls the general code directly.
-bool DFA::SlowSearchLoop(SearchParams* params) {
-  return InlinedSearchLoop(params,
-                           params->first_byte >= 0,
-                           params->want_earliest_match,
-                           params->run_forward);
-}
-
-// For performance, calls the appropriate specialized version
-// of InlinedSearchLoop.
-bool DFA::FastSearchLoop(SearchParams* params) {
-  // Because the methods are private, the Searches array
-  // cannot be declared at top level.
-  static bool (DFA::*Searches[])(SearchParams*) = {
-    &DFA::SearchFFF,
-    &DFA::SearchFFT,
-    &DFA::SearchFTF,
-    &DFA::SearchFTT,
-    &DFA::SearchTFF,
-    &DFA::SearchTFT,
-    &DFA::SearchTTF,
-    &DFA::SearchTTT,
-  };
-
-  bool have_first_byte = params->first_byte >= 0;
-  int index = 4 * have_first_byte +
-              2 * params->want_earliest_match +
-              1 * params->run_forward;
-  return (this->*Searches[index])(params);
-}
-
-
-// The discussion of DFA execution above ignored the question of how
-// to determine the initial state for the search loop.  There are two
-// factors that influence the choice of start state.
-//
-// The first factor is whether the search is anchored or not.
-// The regexp program (Prog*) itself has
-// two different entry points: one for anchored searches and one for
-// unanchored searches.  (The unanchored version starts with a leading ".*?"
-// and then jumps to the anchored one.)
-//
-// The second factor is where text appears in the larger context, which
-// determines which empty-string operators can be matched at the beginning
-// of execution.  If text is at the very beginning of context, \A and ^ match.
-// Otherwise if text is at the beginning of a line, then ^ matches.
-// Otherwise it matters whether the character before text is a word character
-// or a non-word character.
-//
-// The two cases (unanchored vs not) and four cases (empty-string flags)
-// combine to make the eight cases recorded in the DFA's begin_text_[2],
-// begin_line_[2], after_wordchar_[2], and after_nonwordchar_[2] cached
-// StartInfos.  The start state for each is filled in the first time it
-// is used for an actual search.
-
-// Examines text, context, and anchored to determine the right start
-// state for the DFA search loop.  Fills in params and returns true on success.
-// Returns false on failure.
-bool DFA::AnalyzeSearch(SearchParams* params) {
-  const StringPiece& text = params->text;
-  const StringPiece& context = params->context;
-
-  // Sanity check: make sure that text lies within context.
-  if (text.begin() < context.begin() || text.end() > context.end()) {
-    LOG(DFATAL) << "context does not contain text";
-    params->start = DeadState;
-    return true;
-  }
-
-  // Determine correct search type.
-  int start;
-  uint32_t flags;
-  if (params->run_forward) {
-    if (text.begin() == context.begin()) {
-      start = kStartBeginText;
-      flags = kEmptyBeginText|kEmptyBeginLine;
-    } else if (text.begin()[-1] == '\n') {
-      start = kStartBeginLine;
-      flags = kEmptyBeginLine;
-    } else if (Prog::IsWordChar(text.begin()[-1] & 0xFF)) {
-      start = kStartAfterWordChar;
-      flags = kFlagLastWord;
-    } else {
-      start = kStartAfterNonWordChar;
-      flags = 0;
-    }
-  } else {
-    if (text.end() == context.end()) {
-      start = kStartBeginText;
-      flags = kEmptyBeginText|kEmptyBeginLine;
-    } else if (text.end()[0] == '\n') {
-      start = kStartBeginLine;
-      flags = kEmptyBeginLine;
-    } else if (Prog::IsWordChar(text.end()[0] & 0xFF)) {
-      start = kStartAfterWordChar;
-      flags = kFlagLastWord;
-    } else {
-      start = kStartAfterNonWordChar;
-      flags = 0;
-    }
-  }
-  if (params->anchored)
-    start |= kStartAnchored;
-  StartInfo* info = &start_[start];
-
-  // Try once without cache_lock for writing.
-  // Try again after resetting the cache
-  // (ResetCache will relock cache_lock for writing).
-  if (!AnalyzeSearchHelper(params, info, flags)) {
-    ResetCache(params->cache_lock);
-    if (!AnalyzeSearchHelper(params, info, flags)) {
-      LOG(DFATAL) << "Failed to analyze start state.";
-      params->failed = true;
-      return false;
-    }
-  }
-
-  params->start = info->start;
-  params->first_byte = info->first_byte.load(std::memory_order_acquire);
-
-  return true;
-}
-
-// Fills in info if needed.  Returns true on success, false on failure.
-bool DFA::AnalyzeSearchHelper(SearchParams* params, StartInfo* info,
-                              uint32_t flags) {
-  // Quick check.
-  int fb = info->first_byte.load(std::memory_order_acquire);
-  if (fb != kFbUnknown)
-    return true;
-
-  MutexLock l(&mutex_);
-  fb = info->first_byte.load(std::memory_order_relaxed);
-  if (fb != kFbUnknown)
-    return true;
-
-  q0_->clear();
-  AddToQueue(q0_,
-             params->anchored ? prog_->start() : prog_->start_unanchored(),
-             flags);
-  info->start = WorkqToCachedState(q0_, NULL, flags);
-  if (info->start == NULL)
-    return false;
-
-  if (info->start == DeadState) {
-    // Synchronize with "quick check" above.
-    info->first_byte.store(kFbNone, std::memory_order_release);
-    return true;
-  }
-
-  if (info->start == FullMatchState) {
-    // Synchronize with "quick check" above.
-    info->first_byte.store(kFbNone, std::memory_order_release);  // will be ignored
-    return true;
-  }
-
-  // Even if we have a first_byte, we cannot use it when anchored and,
-  // less obviously, we cannot use it when we are going to need flags.
-  // This trick works only when there is a single byte that leads to a
-  // different state!
-  int first_byte = prog_->first_byte();
-  if (first_byte == -1 ||
-      params->anchored ||
-      info->start->flag_ >> kFlagNeedShift != 0)
-    first_byte = kFbNone;
-
-  // Synchronize with "quick check" above.
-  info->first_byte.store(first_byte, std::memory_order_release);
-  return true;
-}
-
-// The actual DFA search: calls AnalyzeSearch and then FastSearchLoop.
-bool DFA::Search(const StringPiece& text,
-                 const StringPiece& context,
-                 bool anchored,
-                 bool want_earliest_match,
-                 bool run_forward,
-                 bool* failed,
-                 const char** epp,
-                 SparseSet* matches) {
-  *epp = NULL;
-  if (!ok()) {
-    *failed = true;
-    return false;
-  }
-  *failed = false;
-
-  RWLocker l(&cache_mutex_);
-  SearchParams params(text, context, &l);
-  params.anchored = anchored;
-  params.want_earliest_match = want_earliest_match;
-  params.run_forward = run_forward;
-  params.matches = matches;
-
-  if (!AnalyzeSearch(&params)) {
-    *failed = true;
-    return false;
-  }
-  if (params.start == DeadState)
-    return false;
-  if (params.start == FullMatchState) {
-    if (run_forward == want_earliest_match)
-      *epp = text.begin();
-    else
-      *epp = text.end();
-    return true;
-  }
-  bool ret = FastSearchLoop(&params);
-  if (params.failed) {
-    *failed = true;
-    return false;
-  }
-  *epp = params.ep;
-  return ret;
-}
-
-DFA* Prog::GetDFA(MatchKind kind) {
-  // For a forward DFA, half the memory goes to each DFA.
-  // However, if it is a "many match" DFA, then there is
-  // no counterpart with which the memory must be shared.
-  //
-  // For a reverse DFA, all the memory goes to the
-  // "longest match" DFA, because RE2 never does reverse
-  // "first match" searches.
-  if (kind == kFirstMatch) {
-    std::call_once(dfa_first_once_, [](Prog* prog) {
-      prog->dfa_first_ = new DFA(prog, kFirstMatch, prog->dfa_mem_ / 2);
-    }, this);
-    return dfa_first_;
-  } else if (kind == kManyMatch) {
-    std::call_once(dfa_first_once_, [](Prog* prog) {
-      prog->dfa_first_ = new DFA(prog, kManyMatch, prog->dfa_mem_);
-    }, this);
-    return dfa_first_;
-  } else {
-    std::call_once(dfa_longest_once_, [](Prog* prog) {
-      if (!prog->reversed_)
-        prog->dfa_longest_ = new DFA(prog, kLongestMatch, prog->dfa_mem_ / 2);
-      else
-        prog->dfa_longest_ = new DFA(prog, kLongestMatch, prog->dfa_mem_);
-    }, this);
-    return dfa_longest_;
-  }
-}
-
-void Prog::DeleteDFA(DFA* dfa) {
-  delete dfa;
-}
-
-// Executes the regexp program to search in text,
-// which itself is inside the larger context.  (As a convenience,
-// passing a NULL context is equivalent to passing text.)
-// Returns true if a match is found, false if not.
-// If a match is found, fills in match0->end() to point at the end of the match
-// and sets match0->begin() to text.begin(), since the DFA can't track
-// where the match actually began.
-//
-// This is the only external interface (class DFA only exists in this file).
-//
-bool Prog::SearchDFA(const StringPiece& text, const StringPiece& const_context,
-                     Anchor anchor, MatchKind kind, StringPiece* match0,
-                     bool* failed, SparseSet* matches) {
-  *failed = false;
-
-  StringPiece context = const_context;
-  if (context.begin() == NULL)
-    context = text;
-  bool carat = anchor_start();
-  bool dollar = anchor_end();
-  if (reversed_) {
-    using std::swap;
-    swap(carat, dollar);
-  }
-  if (carat && context.begin() != text.begin())
-    return false;
-  if (dollar && context.end() != text.end())
-    return false;
-
-  // Handle full match by running an anchored longest match
-  // and then checking if it covers all of text.
-  bool anchored = anchor == kAnchored || anchor_start() || kind == kFullMatch;
-  bool endmatch = false;
-  if (kind == kManyMatch) {
-    // This is split out in order to avoid clobbering kind.
-  } else if (kind == kFullMatch || anchor_end()) {
-    endmatch = true;
-    kind = kLongestMatch;
-  }
-
-  // If the caller doesn't care where the match is (just whether one exists),
-  // then we can stop at the very first match we find, the so-called
-  // "earliest match".
-  bool want_earliest_match = false;
-  if (kind == kManyMatch) {
-    // This is split out in order to avoid clobbering kind.
-    if (matches == NULL) {
-      want_earliest_match = true;
-    }
-  } else if (match0 == NULL && !endmatch) {
-    want_earliest_match = true;
-    kind = kLongestMatch;
-  }
-
-  DFA* dfa = GetDFA(kind);
-  const char* ep;
-  bool matched = dfa->Search(text, context, anchored,
-                             want_earliest_match, !reversed_,
-                             failed, &ep, matches);
-  if (*failed)
-    return false;
-  if (!matched)
-    return false;
-  if (endmatch && ep != (reversed_ ? text.begin() : text.end()))
-    return false;
-
-  // If caller cares, record the boundary of the match.
-  // We only know where it ends, so use the boundary of text
-  // as the beginning.
-  if (match0) {
-    if (reversed_)
-      *match0 = StringPiece(ep, static_cast<size_t>(text.end() - ep));
-    else
-      *match0 =
-          StringPiece(text.begin(), static_cast<size_t>(ep - text.begin()));
-  }
-  return true;
-}
-
-// Build out all states in DFA.  Returns number of states.
-int DFA::BuildAllStates(const Prog::DFAStateCallback& cb) {
-  if (!ok())
-    return 0;
-
-  // Pick out start state for unanchored search
-  // at beginning of text.
-  RWLocker l(&cache_mutex_);
-  SearchParams params(StringPiece(), StringPiece(), &l);
-  params.anchored = false;
-  if (!AnalyzeSearch(&params) ||
-      params.start == NULL ||
-      params.start == DeadState)
-    return 0;
-
-  // Add start state to work queue.
-  // Note that any State* that we handle here must point into the cache,
-  // so we can simply depend on pointer-as-a-number hashing and equality.
-  std::unordered_map<State*, int> m;
-  std::deque<State*> q;
-  m.emplace(params.start, static_cast<int>(m.size()));
-  q.push_back(params.start);
-
-  // Compute the input bytes needed to cover all of the next pointers.
-  int nnext = prog_->bytemap_range() + 1;  // + 1 for kByteEndText slot
-  std::vector<int> input(nnext);
-  for (int c = 0; c < 256; c++) {
-    int b = prog_->bytemap()[c];
-    while (c < 256-1 && prog_->bytemap()[c+1] == b)
-      c++;
-    input[b] = c;
-  }
-  input[prog_->bytemap_range()] = kByteEndText;
-
-  // Scratch space for the output.
-  std::vector<int> output(nnext);
-
-  // Flood to expand every state.
-  bool oom = false;
-  while (!q.empty()) {
-    State* s = q.front();
-    q.pop_front();
-    for (int c : input) {
-      State* ns = RunStateOnByteUnlocked(s, c);
-      if (ns == NULL) {
-        oom = true;
-        break;
-      }
-      if (ns == DeadState) {
-        output[ByteMap(c)] = -1;
-        continue;
-      }
-      if (m.find(ns) == m.end()) {
-        m.emplace(ns, static_cast<int>(m.size()));
-        q.push_back(ns);
-      }
-      output[ByteMap(c)] = m[ns];
-    }
-    if (cb)
-      cb(oom ? NULL : output.data(),
-         s == FullMatchState || s->IsMatch());
-    if (oom)
-      break;
-  }
-
-  return static_cast<int>(m.size());
-}
-
-// Build out all states in DFA for kind.  Returns number of states.
-int Prog::BuildEntireDFA(MatchKind kind, const DFAStateCallback& cb) {
-  return GetDFA(kind)->BuildAllStates(cb);
-}
-
-void Prog::TEST_dfa_should_bail_when_slow(bool b) {
-  dfa_should_bail_when_slow = b;
-}
-
-// Computes min and max for matching string.
-// Won't return strings bigger than maxlen.
-bool DFA::PossibleMatchRange(std::string* min, std::string* max, int maxlen) {
-  if (!ok())
-    return false;
-
-  // NOTE: if future users of PossibleMatchRange want more precision when
-  // presented with infinitely repeated elements, consider making this a
-  // parameter to PossibleMatchRange.
-  static int kMaxEltRepetitions = 0;
-
-  // Keep track of the number of times we've visited states previously. We only
-  // revisit a given state if it's part of a repeated group, so if the value
-  // portion of the map tuple exceeds kMaxEltRepetitions we bail out and set
-  // |*max| to |PrefixSuccessor(*max)|.
-  //
-  // Also note that previously_visited_states[UnseenStatePtr] will, in the STL
-  // tradition, implicitly insert a '0' value at first use. We take advantage
-  // of that property below.
-  std::unordered_map<State*, int> previously_visited_states;
-
-  // Pick out start state for anchored search at beginning of text.
-  RWLocker l(&cache_mutex_);
-  SearchParams params(StringPiece(), StringPiece(), &l);
-  params.anchored = true;
-  if (!AnalyzeSearch(&params))
-    return false;
-  if (params.start == DeadState) {  // No matching strings
-    *min = "";
-    *max = "";
-    return true;
-  }
-  if (params.start == FullMatchState)  // Every string matches: no max
-    return false;
-
-  // The DFA is essentially a big graph rooted at params.start,
-  // and paths in the graph correspond to accepted strings.
-  // Each node in the graph has potentially 256+1 arrows
-  // coming out, one for each byte plus the magic end of
-  // text character kByteEndText.
-
-  // To find the smallest possible prefix of an accepted
-  // string, we just walk the graph preferring to follow
-  // arrows with the lowest bytes possible.  To find the
-  // largest possible prefix, we follow the largest bytes
-  // possible.
-
-  // The test for whether there is an arrow from s on byte j is
-  //    ns = RunStateOnByteUnlocked(s, j);
-  //    if (ns == NULL)
-  //      return false;
-  //    if (ns != DeadState && ns->ninst > 0)
-  // The RunStateOnByteUnlocked call asks the DFA to build out the graph.
-  // It returns NULL only if the DFA has run out of memory,
-  // in which case we can't be sure of anything.
-  // The second check sees whether there was graph built
-  // and whether it is interesting graph.  Nodes might have
-  // ns->ninst == 0 if they exist only to represent the fact
-  // that a match was found on the previous byte.
-
-  // Build minimum prefix.
-  State* s = params.start;
-  min->clear();
-  MutexLock lock(&mutex_);
-  for (int i = 0; i < maxlen; i++) {
-    if (previously_visited_states[s] > kMaxEltRepetitions)
-      break;
-    previously_visited_states[s]++;
-
-    // Stop if min is a match.
-    State* ns = RunStateOnByte(s, kByteEndText);
-    if (ns == NULL)  // DFA out of memory
-      return false;
-    if (ns != DeadState && (ns == FullMatchState || ns->IsMatch()))
-      break;
-
-    // Try to extend the string with low bytes.
-    bool extended = false;
-    for (int j = 0; j < 256; j++) {
-      ns = RunStateOnByte(s, j);
-      if (ns == NULL)  // DFA out of memory
-        return false;
-      if (ns == FullMatchState ||
-          (ns > SpecialStateMax && ns->ninst_ > 0)) {
-        extended = true;
-        min->append(1, static_cast<char>(j));
-        s = ns;
-        break;
-      }
-    }
-    if (!extended)
-      break;
-  }
-
-  // Build maximum prefix.
-  previously_visited_states.clear();
-  s = params.start;
-  max->clear();
-  for (int i = 0; i < maxlen; i++) {
-    if (previously_visited_states[s] > kMaxEltRepetitions)
-      break;
-    previously_visited_states[s] += 1;
-
-    // Try to extend the string with high bytes.
-    bool extended = false;
-    for (int j = 255; j >= 0; j--) {
-      State* ns = RunStateOnByte(s, j);
-      if (ns == NULL)
-        return false;
-      if (ns == FullMatchState ||
-          (ns > SpecialStateMax && ns->ninst_ > 0)) {
-        extended = true;
-        max->append(1, static_cast<char>(j));
-        s = ns;
-        break;
-      }
-    }
-    if (!extended) {
-      // Done, no need for PrefixSuccessor.
-      return true;
-    }
-  }
-
-  // Stopped while still adding to *max - round aaaaaaaaaa... to aaaa...b
-  PrefixSuccessor(max);
-
-  // If there are no bytes left, we have no way to say "there is no maximum
-  // string".  We could make the interface more complicated and be able to
-  // return "there is no maximum but here is a minimum", but that seems like
-  // overkill -- the most common no-max case is all possible strings, so not
-  // telling the caller that the empty string is the minimum match isn't a
-  // great loss.
-  if (max->empty())
-    return false;
-
-  return true;
-}
-
-// PossibleMatchRange for a Prog.
-bool Prog::PossibleMatchRange(std::string* min, std::string* max, int maxlen) {
-  // Have to use dfa_longest_ to get all strings for full matches.
-  // For example, (a|aa) never matches aa in first-match mode.
-  return GetDFA(kLongestMatch)->PossibleMatchRange(min, max, maxlen);
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_FILTERED_RE2_H_
-#define RE2_FILTERED_RE2_H_
-
-// The class FilteredRE2 is used as a wrapper to multiple RE2 regexps.
-// It provides a prefilter mechanism that helps in cutting down the
-// number of regexps that need to be actually searched.
-//
-// By design, it does not include a string matching engine. This is to
-// allow the user of the class to use their favorite string match
-// engine. The overall flow is: Add all the regexps using Add, then
-// Compile the FilteredRE2. The compile returns strings that need to
-// be matched. Note that all returned strings are lowercase. For
-// applying regexps to a search text, the caller does the string
-// matching using the strings returned. When doing the string match,
-// note that the caller has to do that on lower cased version of the
-// search text. Then call FirstMatch or AllMatches with a vector of
-// indices of strings that were found in the text to get the actual
-// regexp matches.
-
-#include <string>
-#include <vector>
-
-
-
-namespace duckdb_re2 {
-
-class PrefilterTree;
-
-class FilteredRE2 {
- public:
-  FilteredRE2();
-  explicit FilteredRE2(int min_atom_len);
-  ~FilteredRE2();
-
-  // Uses RE2 constructor to create a RE2 object (re). Returns
-  // re->error_code(). If error_code is other than NoError, then re is
-  // deleted and not added to re2_vec_.
-  RE2::ErrorCode Add(const StringPiece& pattern,
-                     const RE2::Options& options,
-                     int *id);
-
-  // Prepares the regexps added by Add for filtering.  Returns a set
-  // of strings that the caller should check for in candidate texts.
-  // The returned strings are lowercased. When doing string matching,
-  // the search text should be lowercased first to find matching
-  // strings from the set of strings returned by Compile.  Call after
-  // all Add calls are done.
-  void Compile(std::vector<std::string>* strings_to_match);
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Can be called prior to Compile.
-  // Does not do any filtering: simply tries to Match the
-  // regexps in a loop.
-  int SlowFirstMatch(const StringPiece& text) const;
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Compile has to be called before
-  // calling this.
-  int FirstMatch(const StringPiece& text,
-                 const std::vector<int>& atoms) const;
-
-  // Returns the indices of all matching regexps, after first clearing
-  // matched_regexps.
-  bool AllMatches(const StringPiece& text,
-                  const std::vector<int>& atoms,
-                  std::vector<int>* matching_regexps) const;
-
-  // Returns the indices of all potentially matching regexps after first
-  // clearing potential_regexps.
-  // A regexp is potentially matching if it passes the filter.
-  // If a regexp passes the filter it may still not match.
-  // A regexp that does not pass the filter is guaranteed to not match.
-  void AllPotentials(const std::vector<int>& atoms,
-                     std::vector<int>* potential_regexps) const;
-
-  // The number of regexps added.
-  int NumRegexps() const { return static_cast<int>(re2_vec_.size()); }
-
- private:
-
-  // Get the individual RE2 objects. Useful for testing.
-  RE2* GetRE2(int regexpid) const { return re2_vec_[regexpid]; }
-
-  // Print prefilter.
-  void PrintPrefilter(int regexpid);
-
-  // Useful for testing and debugging.
-  void RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                           std::vector<int>* passed_regexps);
-
-  // All the regexps in the FilteredRE2.
-  std::vector<RE2*> re2_vec_;
-
-  // Has the FilteredRE2 been compiled using Compile()
-  bool compiled_;
-
-  // An AND-OR tree of string atoms used for filtering regexps.
-  PrefilterTree* prefilter_tree_;
-
-  FilteredRE2(const FilteredRE2&) = delete;
-  FilteredRE2& operator=(const FilteredRE2&) = delete;
-};
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_FILTERED_RE2_H_
-
-
-// LICENSE_CHANGE_END
-
-
-#include <stddef.h>
-#include <string>
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_PREFILTER_H_
-#define RE2_PREFILTER_H_
-
-// Prefilter is the class used to extract string guards from regexps.
-// Rather than using Prefilter class directly, use FilteredRE2.
-// See filtered_re2.h
-
-#include <set>
-#include <string>
-#include <vector>
-
-
-
-
-namespace duckdb_re2 {
-
-class RE2;
-
-class Regexp;
-
-class Prefilter {
-  // Instead of using Prefilter directly, use FilteredRE2; see filtered_re2.h
- public:
-  enum Op {
-    ALL = 0,  // Everything matches
-    NONE,  // Nothing matches
-    ATOM,  // The string atom() must match
-    AND,   // All in subs() must match
-    OR,   // One of subs() must match
-  };
-
-  explicit Prefilter(Op op);
-  ~Prefilter();
-
-  Op op() { return op_; }
-  const std::string& atom() const { return atom_; }
-  void set_unique_id(int id) { unique_id_ = id; }
-  int unique_id() const { return unique_id_; }
-
-  // The children of the Prefilter node.
-  std::vector<Prefilter*>* subs() {
-    DCHECK(op_ == AND || op_ == OR);
-    return subs_;
-  }
-
-  // Set the children vector. Prefilter takes ownership of subs and
-  // subs_ will be deleted when Prefilter is deleted.
-  void set_subs(std::vector<Prefilter*>* subs) { subs_ = subs; }
-
-  // Given a RE2, return a Prefilter. The caller takes ownership of
-  // the Prefilter and should deallocate it. Returns NULL if Prefilter
-  // cannot be formed.
-  static Prefilter* FromRE2(const RE2* re2);
-
-  // Returns a readable debug string of the prefilter.
-  std::string DebugString() const;
-
- private:
-  class Info;
-
-  // Combines two prefilters together to create an AND. The passed
-  // Prefilters will be part of the returned Prefilter or deleted.
-  static Prefilter* And(Prefilter* a, Prefilter* b);
-
-  // Combines two prefilters together to create an OR. The passed
-  // Prefilters will be part of the returned Prefilter or deleted.
-  static Prefilter* Or(Prefilter* a, Prefilter* b);
-
-  // Generalized And/Or
-  static Prefilter* AndOr(Op op, Prefilter* a, Prefilter* b);
-
-  static Prefilter* FromRegexp(Regexp* a);
-
-  static Prefilter* FromString(const std::string& str);
-
-  static Prefilter* OrStrings(std::set<std::string>* ss);
-
-  static Info* BuildInfo(Regexp* re);
-
-  Prefilter* Simplify();
-
-  // Kind of Prefilter.
-  Op op_;
-
-  // Sub-matches for AND or OR Prefilter.
-  std::vector<Prefilter*>* subs_;
-
-  // Actual string to match in leaf node.
-  std::string atom_;
-
-  // If different prefilters have the same string atom, or if they are
-  // structurally the same (e.g., OR of same atom strings) they are
-  // considered the same unique nodes. This is the id for each unique
-  // node. This field is populated with a unique id for every node,
-  // and -1 for duplicate nodes.
-  int unique_id_;
-
-  Prefilter(const Prefilter&) = delete;
-  Prefilter& operator=(const Prefilter&) = delete;
-};
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_PREFILTER_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_PREFILTER_TREE_H_
-#define RE2_PREFILTER_TREE_H_
-
-// The PrefilterTree class is used to form an AND-OR tree of strings
-// that would trigger each regexp. The 'prefilter' of each regexp is
-// added tp PrefilterTree, and then PrefilterTree is used to find all
-// the unique strings across the prefilters. During search, by using
-// matches from a string matching engine, PrefilterTree deduces the
-// set of regexps that are to be triggered. The 'string matching
-// engine' itself is outside of this class, and the caller can use any
-// favorite engine. PrefilterTree provides a set of strings (called
-// atoms) that the user of this class should use to do the string
-// matching.
-
-#include <map>
-#include <string>
-#include <vector>
-
-
-
-
-
-namespace duckdb_re2 {
-
-class PrefilterTree {
- public:
-  PrefilterTree();
-  explicit PrefilterTree(int min_atom_len);
-  ~PrefilterTree();
-
-  // Adds the prefilter for the next regexp. Note that we assume that
-  // Add called sequentially for all regexps. All Add calls
-  // must precede Compile.
-  void Add(Prefilter* prefilter);
-
-  // The Compile returns a vector of string in atom_vec.
-  // Call this after all the prefilters are added through Add.
-  // No calls to Add after Compile are allowed.
-  // The caller should use the returned set of strings to do string matching.
-  // Each time a string matches, the corresponding index then has to be
-  // and passed to RegexpsGivenStrings below.
-  void Compile(std::vector<std::string>* atom_vec);
-
-  // Given the indices of the atoms that matched, returns the indexes
-  // of regexps that should be searched.  The matched_atoms should
-  // contain all the ids of string atoms that were found to match the
-  // content. The caller can use any string match engine to perform
-  // this function. This function is thread safe.
-  void RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                           std::vector<int>* regexps) const;
-
-  // Print debug prefilter. Also prints unique ids associated with
-  // nodes of the prefilter of the regexp.
-  void PrintPrefilter(int regexpid);
-
- private:
-  typedef SparseArray<int> IntMap;
-  typedef std::map<int, int> StdIntMap;
-  typedef std::map<std::string, Prefilter*> NodeMap;
-
-  // Each unique node has a corresponding Entry that helps in
-  // passing the matching trigger information along the tree.
-  struct Entry {
-   public:
-    // How many children should match before this node triggers the
-    // parent. For an atom and an OR node, this is 1 and for an AND
-    // node, it is the number of unique children.
-    int propagate_up_at_count;
-
-    // When this node is ready to trigger the parent, what are the indices
-    // of the parent nodes to trigger. The reason there may be more than
-    // one is because of sharing. For example (abc | def) and (xyz | def)
-    // are two different nodes, but they share the atom 'def'. So when
-    // 'def' matches, it triggers two parents, corresponding to the two
-    // different OR nodes.
-    StdIntMap* parents;
-
-    // When this node is ready to trigger the parent, what are the
-    // regexps that are triggered.
-    std::vector<int> regexps;
-  };
-
-  // Returns true if the prefilter node should be kept.
-  bool KeepNode(Prefilter* node) const;
-
-  // This function assigns unique ids to various parts of the
-  // prefilter, by looking at if these nodes are already in the
-  // PrefilterTree.
-  void AssignUniqueIds(NodeMap* nodes, std::vector<std::string>* atom_vec);
-
-  // Given the matching atoms, find the regexps to be triggered.
-  void PropagateMatch(const std::vector<int>& atom_ids,
-                      IntMap* regexps) const;
-
-  // Returns the prefilter node that has the same NodeString as this
-  // node. For the canonical node, returns node.
-  Prefilter* CanonicalNode(NodeMap* nodes, Prefilter* node);
-
-  // A string that uniquely identifies the node. Assumes that the
-  // children of node has already been assigned unique ids.
-  std::string NodeString(Prefilter* node) const;
-
-  // Recursively constructs a readable prefilter string.
-  std::string DebugNodeString(Prefilter* node) const;
-
-  // Used for debugging.
-  void PrintDebugInfo(NodeMap* nodes);
-
-  // These are all the nodes formed by Compile. Essentially, there is
-  // one node for each unique atom and each unique AND/OR node.
-  std::vector<Entry> entries_;
-
-  // indices of regexps that always pass through the filter (since we
-  // found no required literals in these regexps).
-  std::vector<int> unfiltered_;
-
-  // vector of Prefilter for all regexps.
-  std::vector<Prefilter*> prefilter_vec_;
-
-  // Atom index in returned strings to entry id mapping.
-  std::vector<int> atom_index_to_id_;
-
-  // Has the prefilter tree been compiled.
-  bool compiled_;
-
-  // Strings less than this length are not stored as atoms.
-  const int min_atom_len_;
-
-  PrefilterTree(const PrefilterTree&) = delete;
-  PrefilterTree& operator=(const PrefilterTree&) = delete;
-};
-
-}  // namespace
-
-#endif  // RE2_PREFILTER_TREE_H_
-
-
-// LICENSE_CHANGE_END
-
-
-namespace duckdb_re2 {
-
-FilteredRE2::FilteredRE2()
-    : compiled_(false),
-      prefilter_tree_(new PrefilterTree()) {
-}
-
-FilteredRE2::FilteredRE2(int min_atom_len)
-    : compiled_(false),
-      prefilter_tree_(new PrefilterTree(min_atom_len)) {
-}
-
-FilteredRE2::~FilteredRE2() {
-  for (size_t i = 0; i < re2_vec_.size(); i++)
-    delete re2_vec_[i];
-  delete prefilter_tree_;
-}
-
-RE2::ErrorCode FilteredRE2::Add(const StringPiece& pattern,
-                                const RE2::Options& options, int* id) {
-  RE2* re = new RE2(pattern, options);
-  RE2::ErrorCode code = re->error_code();
-
-  if (!re->ok()) {
-    if (options.log_errors()) {
-      LOG(ERROR) << "Couldn't compile regular expression, skipping: "
-                 << re << " due to error " << re->error();
-    }
-    delete re;
-  } else {
-    *id = static_cast<int>(re2_vec_.size());
-    re2_vec_.push_back(re);
-  }
-
-  return code;
-}
-
-void FilteredRE2::Compile(std::vector<std::string>* atoms) {
-  if (compiled_) {
-    LOG(ERROR) << "Compile called already.";
-    return;
-  }
-
-  if (re2_vec_.empty()) {
-    LOG(ERROR) << "Compile called before Add.";
-    return;
-  }
-
-  for (size_t i = 0; i < re2_vec_.size(); i++) {
-    Prefilter* prefilter = Prefilter::FromRE2(re2_vec_[i]);
-    prefilter_tree_->Add(prefilter);
-  }
-  atoms->clear();
-  prefilter_tree_->Compile(atoms);
-  compiled_ = true;
-}
-
-int FilteredRE2::SlowFirstMatch(const StringPiece& text) const {
-  for (size_t i = 0; i < re2_vec_.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[i]))
-      return static_cast<int>(i);
-  return -1;
-}
-
-int FilteredRE2::FirstMatch(const StringPiece& text,
-                            const std::vector<int>& atoms) const {
-  if (!compiled_) {
-    LOG(DFATAL) << "FirstMatch called before Compile.";
-    return -1;
-  }
-  std::vector<int> regexps;
-  prefilter_tree_->RegexpsGivenStrings(atoms, &regexps);
-  for (size_t i = 0; i < regexps.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[regexps[i]]))
-      return regexps[i];
-  return -1;
-}
-
-bool FilteredRE2::AllMatches(
-    const StringPiece& text,
-    const std::vector<int>& atoms,
-    std::vector<int>* matching_regexps) const {
-  matching_regexps->clear();
-  std::vector<int> regexps;
-  prefilter_tree_->RegexpsGivenStrings(atoms, &regexps);
-  for (size_t i = 0; i < regexps.size(); i++)
-    if (RE2::PartialMatch(text, *re2_vec_[regexps[i]]))
-      matching_regexps->push_back(regexps[i]);
-  return !matching_regexps->empty();
-}
-
-void FilteredRE2::AllPotentials(
-    const std::vector<int>& atoms,
-    std::vector<int>* potential_regexps) const {
-  prefilter_tree_->RegexpsGivenStrings(atoms, potential_regexps);
-}
-
-void FilteredRE2::RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                                      std::vector<int>* passed_regexps) {
-  prefilter_tree_->RegexpsGivenStrings(matched_atoms, passed_regexps);
-}
-
-void FilteredRE2::PrintPrefilter(int regexpid) {
-  prefilter_tree_->PrintPrefilter(regexpid);
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Determine whether this library should match PCRE exactly
-// for a particular Regexp.  (If so, the testing framework can
-// check that it does.)
-//
-// This library matches PCRE except in these cases:
-//   * the regexp contains a repetition of an empty string,
-//     like (a*)* or (a*)+.  In this case, PCRE will treat
-//     the repetition sequence as ending with an empty string,
-//     while this library does not.
-//   * Perl and PCRE differ on whether \v matches \n.
-//     For historical reasons, this library implements the Perl behavior.
-//   * Perl and PCRE allow $ in one-line mode to match either the very
-//     end of the text or just before a \n at the end of the text.
-//     This library requires it to match only the end of the text.
-//   * Similarly, Perl and PCRE do not allow ^ in multi-line mode to
-//     match the end of the text if the last character is a \n.
-//     This library does allow it.
-//
-// Regexp::MimicsPCRE checks for any of these conditions.
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-// Returns whether re might match an empty string.
-static bool CanBeEmptyString(Regexp *re);
-
-// Walker class to compute whether library handles a regexp
-// exactly as PCRE would.  See comment at top for conditions.
-
-class PCREWalker : public Regexp::Walker<bool> {
- public:
-  PCREWalker() {}
-  bool PostVisit(Regexp* re, bool parent_arg, bool pre_arg, bool* child_args,
-                 int nchild_args);
-
-  bool ShortVisit(Regexp* re, bool a) {
-    // Should never be called: we use Walk not WalkExponential.
-    LOG(DFATAL) << "EmptyStringWalker::ShortVisit called";
-    return a;
-  }
-};
-
-// Called after visiting each of re's children and accumulating
-// the return values in child_args.  So child_args contains whether
-// this library mimics PCRE for those subexpressions.
-bool PCREWalker::PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
-                           bool* child_args, int nchild_args) {
-  // If children failed, so do we.
-  for (int i = 0; i < nchild_args; i++)
-    if (!child_args[i])
-      return false;
-
-  // Otherwise look for other reasons to fail.
-  switch (re->op()) {
-    // Look for repeated empty string.
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-      if (CanBeEmptyString(re->sub()[0]))
-        return false;
-      break;
-    case kRegexpRepeat:
-      if (re->max() == -1 && CanBeEmptyString(re->sub()[0]))
-        return false;
-      break;
-
-    // Look for \v
-    case kRegexpLiteral:
-      if (re->rune() == '\v')
-        return false;
-      break;
-
-    // Look for $ in single-line mode.
-    case kRegexpEndText:
-    case kRegexpEmptyMatch:
-      if (re->parse_flags() & Regexp::WasDollar)
-        return false;
-      break;
-
-    // Look for ^ in multi-line mode.
-    case kRegexpBeginLine:
-      // No condition: in single-line mode ^ becomes kRegexpBeginText.
-      return false;
-
-    default:
-      break;
-  }
-
-  // Not proven guilty.
-  return true;
-}
-
-// Returns whether this regexp's behavior will mimic PCRE's exactly.
-bool Regexp::MimicsPCRE() {
-  PCREWalker w;
-  return w.Walk(this, true);
-}
-
-
-// Walker class to compute whether a Regexp can match an empty string.
-// It is okay to overestimate.  For example, \b\B cannot match an empty
-// string, because \b and \B are mutually exclusive, but this isn't
-// that smart and will say it can.  Spurious empty strings
-// will reduce the number of regexps we sanity check against PCRE,
-// but they won't break anything.
-
-class EmptyStringWalker : public Regexp::Walker<bool> {
- public:
-  EmptyStringWalker() { }
-  bool PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
-                 bool* child_args, int nchild_args);
-
-  bool ShortVisit(Regexp* re, bool a) {
-    // Should never be called: we use Walk not WalkExponential.
-    LOG(DFATAL) << "EmptyStringWalker::ShortVisit called";
-    return a;
-  }
-
- private:
-  EmptyStringWalker(const EmptyStringWalker&) = delete;
-  EmptyStringWalker& operator=(const EmptyStringWalker&) = delete;
-};
-
-// Called after visiting re's children.  child_args contains the return
-// value from each of the children's PostVisits (i.e., whether each child
-// can match an empty string).  Returns whether this clause can match an
-// empty string.
-bool EmptyStringWalker::PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
-                                  bool* child_args, int nchild_args) {
-  switch (re->op()) {
-    case kRegexpNoMatch:               // never empty
-    case kRegexpLiteral:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpCharClass:
-    case kRegexpLiteralString:
-      return false;
-
-    case kRegexpEmptyMatch:            // always empty
-    case kRegexpBeginLine:             // always empty, when they match
-    case kRegexpEndLine:
-    case kRegexpNoWordBoundary:
-    case kRegexpWordBoundary:
-    case kRegexpBeginText:
-    case kRegexpEndText:
-    case kRegexpStar:                  // can always be empty
-    case kRegexpQuest:
-    case kRegexpHaveMatch:
-      return true;
-
-    case kRegexpConcat:                // can be empty if all children can
-      for (int i = 0; i < nchild_args; i++)
-        if (!child_args[i])
-          return false;
-      return true;
-
-    case kRegexpAlternate:             // can be empty if any child can
-      for (int i = 0; i < nchild_args; i++)
-        if (child_args[i])
-          return true;
-      return false;
-
-    case kRegexpPlus:                  // can be empty if the child can
-    case kRegexpCapture:
-      return child_args[0];
-
-    case kRegexpRepeat:                // can be empty if child can or is x{0}
-      return child_args[0] || re->min() == 0;
-  }
-  return false;
-}
-
-// Returns whether re can match an empty string.
-static bool CanBeEmptyString(Regexp* re) {
-  EmptyStringWalker w;
-  return w.Walk(re, true);
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006-2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Tested by search_test.cc.
-//
-// Prog::SearchNFA, an NFA search.
-// This is an actual NFA like the theorists talk about,
-// not the pseudo-NFA found in backtracking regexp implementations.
-//
-// IMPLEMENTATION
-//
-// This algorithm is a variant of one that appeared in Rob Pike's sam editor,
-// which is a variant of the one described in Thompson's 1968 CACM paper.
-// See http://swtch.com/~rsc/regexp/ for various history.  The main feature
-// over the DFA implementation is that it tracks submatch boundaries.
-//
-// When the choice of submatch boundaries is ambiguous, this particular
-// implementation makes the same choices that traditional backtracking
-// implementations (in particular, Perl and PCRE) do.
-// Note that unlike in Perl and PCRE, this algorithm *cannot* take exponential
-// time in the length of the input.
-//
-// Like Thompson's original machine and like the DFA implementation, this
-// implementation notices a match only once it is one byte past it.
-
-#include <stdio.h>
-#include <string.h>
-#include <algorithm>
-#include <string>
-#include <utility>
-#include <vector>
-
-
-
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-class NFA {
- public:
-  NFA(Prog* prog);
-  ~NFA();
-
-  // Searches for a matching string.
-  //   * If anchored is true, only considers matches starting at offset.
-  //     Otherwise finds lefmost match at or after offset.
-  //   * If longest is true, returns the longest match starting
-  //     at the chosen start point.  Otherwise returns the so-called
-  //     left-biased match, the one traditional backtracking engines
-  //     (like Perl and PCRE) find.
-  // Records submatch boundaries in submatch[1..nsubmatch-1].
-  // Submatch[0] is the entire match.  When there is a choice in
-  // which text matches each subexpression, the submatch boundaries
-  // are chosen to match what a backtracking implementation would choose.
-  bool Search(const StringPiece& text, const StringPiece& context,
-              bool anchored, bool longest,
-              StringPiece* submatch, int nsubmatch);
-
- private:
-  struct Thread {
-    union {
-      int ref;
-      Thread* next;  // when on free list
-    };
-    const char** capture;
-  };
-
-  // State for explicit stack in AddToThreadq.
-  struct AddState {
-    int id;     // Inst to process
-    Thread* t;  // if not null, set t0 = t before processing id
-  };
-
-  // Threadq is a list of threads.  The list is sorted by the order
-  // in which Perl would explore that particular state -- the earlier
-  // choices appear earlier in the list.
-  typedef SparseArray<Thread*> Threadq;
-
-  inline Thread* AllocThread();
-  inline Thread* Incref(Thread* t);
-  inline void Decref(Thread* t);
-
-  // Follows all empty arrows from id0 and enqueues all the states reached.
-  // Enqueues only the ByteRange instructions that match byte c.
-  // context is used (with p) for evaluating empty-width specials.
-  // p is the current input position, and t0 is the current thread.
-  void AddToThreadq(Threadq* q, int id0, int c, const StringPiece& context,
-                    const char* p, Thread* t0);
-
-  // Run runq on byte c, appending new states to nextq.
-  // Updates matched_ and match_ as new, better matches are found.
-  // context is used (with p) for evaluating empty-width specials.
-  // p is the position of byte c in the input string for AddToThreadq;
-  // p-1 will be used when processing Match instructions.
-  // Frees all the threads on runq.
-  // If there is a shortcut to the end, returns that shortcut.
-  int Step(Threadq* runq, Threadq* nextq, int c, const StringPiece& context,
-           const char* p);
-
-  // Returns text version of capture information, for debugging.
-  std::string FormatCapture(const char** capture);
-
-  inline void CopyCapture(const char** dst, const char** src);
-
-  Prog* prog_;                // underlying program
-  int start_;                 // start instruction in program
-  int ncapture_;              // number of submatches to track
-  bool longest_;              // whether searching for longest match
-  bool endmatch_;             // whether match must end at text.end()
-  const char* btext_;         // beginning of text being matched (for FormatSubmatch)
-  const char* etext_;         // end of text being matched (for endmatch_)
-  Threadq q0_, q1_;           // pre-allocated for Search.
-  PODArray<AddState> stack_;  // pre-allocated for AddToThreadq
-  Thread* free_threads_;      // free list
-  const char** match_;        // best match so far
-  bool matched_;              // any match so far?
-
-  NFA(const NFA&) = delete;
-  NFA& operator=(const NFA&) = delete;
-};
-
-NFA::NFA(Prog* prog) {
-  prog_ = prog;
-  start_ = prog_->start();
-  ncapture_ = 0;
-  longest_ = false;
-  endmatch_ = false;
-  btext_ = NULL;
-  etext_ = NULL;
-  q0_.resize(prog_->size());
-  q1_.resize(prog_->size());
-  // See NFA::AddToThreadq() for why this is so.
-  int nstack = 2*prog_->inst_count(kInstCapture) +
-               prog_->inst_count(kInstEmptyWidth) +
-               prog_->inst_count(kInstNop) + 1;  // + 1 for start inst
-  stack_ = PODArray<AddState>(nstack);
-  free_threads_ = NULL;
-  match_ = NULL;
-  matched_ = false;
-}
-
-NFA::~NFA() {
-  delete[] match_;
-  Thread* next;
-  for (Thread* t = free_threads_; t; t = next) {
-    next = t->next;
-    delete[] t->capture;
-    delete t;
-  }
-}
-
-NFA::Thread* NFA::AllocThread() {
-  Thread* t = free_threads_;
-  if (t == NULL) {
-    t = new Thread;
-    t->ref = 1;
-    t->capture = new const char*[ncapture_];
-    return t;
-  }
-  free_threads_ = t->next;
-  t->ref = 1;
-  return t;
-}
-
-NFA::Thread* NFA::Incref(Thread* t) {
-  DCHECK(t != NULL);
-  t->ref++;
-  return t;
-}
-
-void NFA::Decref(Thread* t) {
-  if (t == NULL)
-    return;
-  t->ref--;
-  if (t->ref > 0)
-    return;
-  DCHECK_EQ(t->ref, 0);
-  t->next = free_threads_;
-  free_threads_ = t;
-}
-
-void NFA::CopyCapture(const char** dst, const char** src) {
-  for (int i = 0; i < ncapture_; i+=2) {
-    dst[i] = src[i];
-    dst[i+1] = src[i+1];
-  }
-}
-
-// Follows all empty arrows from id0 and enqueues all the states reached.
-// Enqueues only the ByteRange instructions that match byte c.
-// context is used (with p) for evaluating empty-width specials.
-// p is the current input position, and t0 is the current thread.
-void NFA::AddToThreadq(Threadq* q, int id0, int c, const StringPiece& context,
-                       const char* p, Thread* t0) {
-  if (id0 == 0)
-    return;
-
-  // Use stack_ to hold our stack of instructions yet to process.
-  // It was preallocated as follows:
-  //   two entries per Capture;
-  //   one entry per EmptyWidth; and
-  //   one entry per Nop.
-  // This reflects the maximum number of stack pushes that each can
-  // perform. (Each instruction can be processed at most once.)
-  AddState* stk = stack_.data();
-  int nstk = 0;
-
-  stk[nstk++] = {id0, NULL};
-  while (nstk > 0) {
-    DCHECK_LE(nstk, stack_.size());
-    AddState a = stk[--nstk];
-
-  Loop:
-    if (a.t != NULL) {
-      // t0 was a thread that we allocated and copied in order to
-      // record the capture, so we must now decref it.
-      Decref(t0);
-      t0 = a.t;
-    }
-
-    int id = a.id;
-    if (id == 0)
-      continue;
-    if (q->has_index(id)) {
-      continue;
-    }
-
-    // Create entry in q no matter what.  We might fill it in below,
-    // or we might not.  Even if not, it is necessary to have it,
-    // so that we don't revisit id0 during the recursion.
-    q->set_new(id, NULL);
-    Thread** tp = &q->get_existing(id);
-    int j;
-    Thread* t;
-    Prog::Inst* ip = prog_->inst(id);
-    switch (ip->opcode()) {
-    default:
-      LOG(DFATAL) << "unhandled " << ip->opcode() << " in AddToThreadq";
-      break;
-
-    case kInstFail:
-      break;
-
-    case kInstAltMatch:
-      // Save state; will pick up at next byte.
-      t = Incref(t0);
-      *tp = t;
-
-      DCHECK(!ip->last());
-      a = {id+1, NULL};
-      goto Loop;
-
-    case kInstNop:
-      if (!ip->last())
-        stk[nstk++] = {id+1, NULL};
-
-      // Continue on.
-      a = {ip->out(), NULL};
-      goto Loop;
-
-    case kInstCapture:
-      if (!ip->last())
-        stk[nstk++] = {id+1, NULL};
-
-      if ((j=ip->cap()) < ncapture_) {
-        // Push a dummy whose only job is to restore t0
-        // once we finish exploring this possibility.
-        stk[nstk++] = {0, t0};
-
-        // Record capture.
-        t = AllocThread();
-        CopyCapture(t->capture, t0->capture);
-        t->capture[j] = p;
-        t0 = t;
-      }
-      a = {ip->out(), NULL};
-      goto Loop;
-
-    case kInstByteRange:
-      if (!ip->Matches(c))
-        goto Next;
-
-      // Save state; will pick up at next byte.
-      t = Incref(t0);
-      *tp = t;
-      if (ip->hint() == 0)
-        break;
-      a = {id+ip->hint(), NULL};
-      goto Loop;
-
-    case kInstMatch:
-      // Save state; will pick up at next byte.
-      t = Incref(t0);
-      *tp = t;
-    Next:
-      if (ip->last())
-        break;
-      a = {id+1, NULL};
-      goto Loop;
-
-    case kInstEmptyWidth:
-      if (!ip->last())
-        stk[nstk++] = {id+1, NULL};
-
-      // Continue on if we have all the right flag bits.
-      if (ip->empty() & ~Prog::EmptyFlags(context, p))
-        break;
-      a = {ip->out(), NULL};
-      goto Loop;
-    }
-  }
-}
-
-// Run runq on byte c, appending new states to nextq.
-// Updates matched_ and match_ as new, better matches are found.
-// context is used (with p) for evaluating empty-width specials.
-// p is the position of byte c in the input string for AddToThreadq;
-// p-1 will be used when processing Match instructions.
-// Frees all the threads on runq.
-// If there is a shortcut to the end, returns that shortcut.
-int NFA::Step(Threadq* runq, Threadq* nextq, int c, const StringPiece& context,
-              const char* p) {
-  nextq->clear();
-
-  for (Threadq::iterator i = runq->begin(); i != runq->end(); ++i) {
-    Thread* t = i->value();
-    if (t == NULL)
-      continue;
-
-    if (longest_) {
-      // Can skip any threads started after our current best match.
-      if (matched_ && match_[0] < t->capture[0]) {
-        Decref(t);
-        continue;
-      }
-    }
-
-    int id = i->index();
-    Prog::Inst* ip = prog_->inst(id);
-
-    switch (ip->opcode()) {
-      default:
-        // Should only see the values handled below.
-        LOG(DFATAL) << "Unhandled " << ip->opcode() << " in step";
-        break;
-
-      case kInstByteRange:
-        AddToThreadq(nextq, ip->out(), c, context, p, t);
-        break;
-
-      case kInstAltMatch:
-        if (i != runq->begin())
-          break;
-        // The match is ours if we want it.
-        if (ip->greedy(prog_) || longest_) {
-          CopyCapture(match_, t->capture);
-          matched_ = true;
-
-          Decref(t);
-          for (++i; i != runq->end(); ++i)
-            Decref(i->value());
-          runq->clear();
-          if (ip->greedy(prog_))
-            return ip->out1();
-          return ip->out();
-        }
-        break;
-
-      case kInstMatch: {
-        // Avoid invoking undefined behavior when p happens
-        // to be null - and p-1 would be meaningless anyway.
-        if (p == NULL)
-          break;
-
-        if (endmatch_ && p-1 != etext_)
-          break;
-
-        if (longest_) {
-          // Leftmost-longest mode: save this match only if
-          // it is either farther to the left or at the same
-          // point but longer than an existing match.
-          if (!matched_ || t->capture[0] < match_[0] ||
-              (t->capture[0] == match_[0] && p-1 > match_[1])) {
-            CopyCapture(match_, t->capture);
-            match_[1] = p-1;
-            matched_ = true;
-          }
-        } else {
-          // Leftmost-biased mode: this match is by definition
-          // better than what we've already found (see next line).
-          CopyCapture(match_, t->capture);
-          match_[1] = p-1;
-          matched_ = true;
-
-          // Cut off the threads that can only find matches
-          // worse than the one we just found: don't run the
-          // rest of the current Threadq.
-          Decref(t);
-          for (++i; i != runq->end(); ++i)
-            Decref(i->value());
-          runq->clear();
-          return 0;
-        }
-        break;
-      }
-    }
-    Decref(t);
-  }
-  runq->clear();
-  return 0;
-}
-
-std::string NFA::FormatCapture(const char** capture) {
-  std::string s;
-  for (int i = 0; i < ncapture_; i+=2) {
-    if (capture[i] == NULL)
-      StringAppendF(&s, "(?,?)");
-    else if (capture[i+1] == NULL)
-      StringAppendF(&s, "(%d,?)", (int)(capture[i] - btext_));
-    else
-      StringAppendF(&s, "(%d,%d)",
-                    (int)(capture[i] - btext_),
-                    (int)(capture[i+1] - btext_));
-  }
-  return s;
-}
-
-bool NFA::Search(const StringPiece& text, const StringPiece& const_context,
-            bool anchored, bool longest,
-            StringPiece* submatch, int nsubmatch) {
-  if (start_ == 0)
-    return false;
-
-  StringPiece context = const_context;
-  if (context.begin() == NULL)
-    context = text;
-
-  // Sanity check: make sure that text lies within context.
-  if (text.begin() < context.begin() || text.end() > context.end()) {
-    LOG(DFATAL) << "context does not contain text";
-    return false;
-  }
-
-  if (prog_->anchor_start() && context.begin() != text.begin())
-    return false;
-  if (prog_->anchor_end() && context.end() != text.end())
-    return false;
-  anchored |= prog_->anchor_start();
-  if (prog_->anchor_end()) {
-    longest = true;
-    endmatch_ = true;
-    etext_ = text.end();
-  }
-
-  if (nsubmatch < 0) {
-    LOG(DFATAL) << "Bad args: nsubmatch=" << nsubmatch;
-    return false;
-  }
-
-  // Save search parameters.
-  ncapture_ = 2*nsubmatch;
-  longest_ = longest;
-
-  if (nsubmatch == 0) {
-    // We need to maintain match[0], both to distinguish the
-    // longest match (if longest is true) and also to tell
-    // whether we've seen any matches at all.
-    ncapture_ = 2;
-  }
-
-  match_ = new const char*[ncapture_];
-  matched_ = false;
-
-  // For debugging prints.
-  btext_ = context.begin();
-
-  // Set up search.
-  Threadq* runq = &q0_;
-  Threadq* nextq = &q1_;
-  runq->clear();
-  nextq->clear();
-  memset(&match_[0], 0, ncapture_*sizeof match_[0]);
-
-  // Loop over the text, stepping the machine.
-  for (const char* p = text.begin();; p++) {
-    // This is a no-op the first time around the loop because runq is empty.
-    int id = Step(runq, nextq, p < text.end() ? p[0] & 0xFF : -1, context, p);
-    DCHECK_EQ(runq->size(), 0);
-    using std::swap;
-    swap(nextq, runq);
-    nextq->clear();
-    if (id != 0) {
-      // We're done: full match ahead.
-      p = text.end();
-      for (;;) {
-        Prog::Inst* ip = prog_->inst(id);
-        switch (ip->opcode()) {
-          default:
-            LOG(DFATAL) << "Unexpected opcode in short circuit: " << ip->opcode();
-            break;
-
-          case kInstCapture:
-            if (ip->cap() < ncapture_)
-              match_[ip->cap()] = p;
-            id = ip->out();
-            continue;
-
-          case kInstNop:
-            id = ip->out();
-            continue;
-
-          case kInstMatch:
-            match_[1] = p;
-            matched_ = true;
-            break;
-        }
-        break;
-      }
-      break;
-    }
-
-    if (p > text.end())
-      break;
-
-    // Start a new thread if there have not been any matches.
-    // (No point in starting a new thread if there have been
-    // matches, since it would be to the right of the match
-    // we already found.)
-    if (!matched_ && (!anchored || p == text.begin())) {
-      // If there's a required first byte for an unanchored search
-      // and we're not in the middle of any possible matches,
-      // use memchr to search for the byte quickly.
-      int fb = prog_->first_byte();
-      if (!anchored && runq->size() == 0 &&
-          fb >= 0 && p < text.end() && (p[0] & 0xFF) != fb) {
-        p = reinterpret_cast<const char*>(memchr(p, fb, text.end() - p));
-        if (p == NULL) {
-          p = text.end();
-        }
-      }
-
-      Thread* t = AllocThread();
-      CopyCapture(t->capture, match_);
-      t->capture[0] = p;
-      AddToThreadq(runq, start_, p < text.end() ? p[0] & 0xFF : -1, context, p,
-                   t);
-      Decref(t);
-    }
-
-    // If all the threads have died, stop early.
-    if (runq->size() == 0) {
-      break;
-    }
-  }
-
-  for (Threadq::iterator i = runq->begin(); i != runq->end(); ++i)
-    Decref(i->value());
-
-  if (matched_) {
-    for (int i = 0; i < nsubmatch; i++)
-      submatch[i] =
-          StringPiece(match_[2 * i],
-                      static_cast<size_t>(match_[2 * i + 1] - match_[2 * i]));
-    return true;
-  }
-  return false;
-}
-
-// Computes whether all successful matches have a common first byte,
-// and if so, returns that byte.  If not, returns -1.
-int Prog::ComputeFirstByte() {
-  int b = -1;
-  SparseSet q(size());
-  q.insert(start());
-  for (SparseSet::iterator it = q.begin(); it != q.end(); ++it) {
-    int id = *it;
-    Prog::Inst* ip = inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled " << ip->opcode() << " in ComputeFirstByte";
-        break;
-
-      case kInstMatch:
-        // The empty string matches: no first byte.
-        return -1;
-
-      case kInstByteRange:
-        if (!ip->last())
-          q.insert(id+1);
-
-        // Must match only a single byte
-        if (ip->lo() != ip->hi())
-          return -1;
-        if (ip->foldcase() && 'a' <= ip->lo() && ip->lo() <= 'z')
-          return -1;
-        // If we haven't seen any bytes yet, record it;
-        // otherwise must match the one we saw before.
-        if (b == -1)
-          b = ip->lo();
-        else if (b != ip->lo())
-          return -1;
-        break;
-
-      case kInstNop:
-      case kInstCapture:
-      case kInstEmptyWidth:
-        if (!ip->last())
-          q.insert(id+1);
-
-        // Continue on.
-        // Ignore ip->empty() flags for kInstEmptyWidth
-        // in order to be as conservative as possible
-        // (assume all possible empty-width flags are true).
-        if (ip->out())
-          q.insert(ip->out());
-        break;
-
-      case kInstAltMatch:
-        DCHECK(!ip->last());
-        q.insert(id+1);
-        break;
-
-      case kInstFail:
-        break;
-    }
-  }
-  return b;
-}
-
-bool
-Prog::SearchNFA(const StringPiece& text, const StringPiece& context,
-                Anchor anchor, MatchKind kind,
-                StringPiece* match, int nmatch) {
-  NFA nfa(this);
-  StringPiece sp;
-  if (kind == kFullMatch) {
-    anchor = kAnchored;
-    if (nmatch == 0) {
-      match = &sp;
-      nmatch = 1;
-    }
-  }
-  if (!nfa.Search(text, context, anchor == kAnchored, kind != kFirstMatch, match, nmatch))
-    return false;
-  if (kind == kFullMatch && match[0].end() != text.end())
-    return false;
-  return true;
-}
-
-// For each instruction i in the program reachable from the start, compute the
-// number of instructions reachable from i by following only empty transitions
-// and record that count as fanout[i].
-//
-// fanout holds the results and is also the work queue for the outer iteration.
-// reachable holds the reached nodes for the inner iteration.
-void Prog::Fanout(SparseArray<int>* fanout) {
-  DCHECK_EQ(fanout->max_size(), size());
-  SparseSet reachable(size());
-  fanout->clear();
-  fanout->set_new(start(), 0);
-  for (SparseArray<int>::iterator i = fanout->begin(); i != fanout->end(); ++i) {
-    int* count = &i->value();
-    reachable.clear();
-    reachable.insert(i->index());
-    for (SparseSet::iterator j = reachable.begin(); j != reachable.end(); ++j) {
-      int id = *j;
-      Prog::Inst* ip = inst(id);
-      switch (ip->opcode()) {
-        default:
-          LOG(DFATAL) << "unhandled " << ip->opcode() << " in Prog::Fanout()";
-          break;
-
-        case kInstByteRange:
-          if (!ip->last())
-            reachable.insert(id+1);
-
-          (*count)++;
-          if (!fanout->has_index(ip->out())) {
-            fanout->set_new(ip->out(), 0);
-          }
-          break;
-
-        case kInstAltMatch:
-          DCHECK(!ip->last());
-          reachable.insert(id+1);
-          break;
-
-        case kInstCapture:
-        case kInstEmptyWidth:
-        case kInstNop:
-          if (!ip->last())
-            reachable.insert(id+1);
-
-          reachable.insert(ip->out());
-          break;
-
-        case kInstMatch:
-          if (!ip->last())
-            reachable.insert(id+1);
-          break;
-
-        case kInstFail:
-          break;
-      }
-    }
-  }
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Tested by search_test.cc.
-//
-// Prog::SearchOnePass is an efficient implementation of
-// regular expression search with submatch tracking for
-// what I call "one-pass regular expressions".  (An alternate
-// name might be "backtracking-free regular expressions".)
-//
-// One-pass regular expressions have the property that
-// at each input byte during an anchored match, there may be
-// multiple alternatives but only one can proceed for any
-// given input byte.
-//
-// For example, the regexp /x*yx*/ is one-pass: you read
-// x's until a y, then you read the y, then you keep reading x's.
-// At no point do you have to guess what to do or back up
-// and try a different guess.
-//
-// On the other hand, /x*x/ is not one-pass: when you're
-// looking at an input "x", it's not clear whether you should
-// use it to extend the x* or as the final x.
-//
-// More examples: /([^ ]*) (.*)/ is one-pass; /(.*) (.*)/ is not.
-// /(\d+)-(\d+)/ is one-pass; /(\d+).(\d+)/ is not.
-//
-// A simple intuition for identifying one-pass regular expressions
-// is that it's always immediately obvious when a repetition ends.
-// It must also be immediately obvious which branch of an | to take:
-//
-// /x(y|z)/ is one-pass, but /(xy|xz)/ is not.
-//
-// The NFA-based search in nfa.cc does some bookkeeping to
-// avoid the need for backtracking and its associated exponential blowup.
-// But if we have a one-pass regular expression, there is no
-// possibility of backtracking, so there is no need for the
-// extra bookkeeping.  Hence, this code.
-//
-// On a one-pass regular expression, the NFA code in nfa.cc
-// runs at about 1/20 of the backtracking-based PCRE speed.
-// In contrast, the code in this file runs at about the same
-// speed as PCRE.
-//
-// One-pass regular expressions get used a lot when RE is
-// used for parsing simple strings, so it pays off to
-// notice them and handle them efficiently.
-//
-// See also Anne Brüggemann-Klein and Derick Wood,
-// "One-unambiguous regular languages", Information and Computation 142(2).
-
-#include <stdint.h>
-#include <string.h>
-#include <algorithm>
-#include <map>
-#include <string>
-#include <vector>
-
-
-
-
-
-
-
-
-
-
-// Silence "zero-sized array in struct/union" warning for OneState::action.
-#ifdef _MSC_VER
-//#pragma warning(disable: 4200)
-#endif
-
-namespace duckdb_re2 {
-
-// The key insight behind this implementation is that the
-// non-determinism in an NFA for a one-pass regular expression
-// is contained.  To explain what that means, first a
-// refresher about what regular expression programs look like
-// and how the usual NFA execution runs.
-//
-// In a regular expression program, only the kInstByteRange
-// instruction processes an input byte c and moves on to the
-// next byte in the string (it does so if c is in the given range).
-// The kInstByteRange instructions correspond to literal characters
-// and character classes in the regular expression.
-//
-// The kInstAlt instructions are used as wiring to connect the
-// kInstByteRange instructions together in interesting ways when
-// implementing | + and *.
-// The kInstAlt instruction forks execution, like a goto that
-// jumps to ip->out() and ip->out1() in parallel.  Each of the
-// resulting computation paths is called a thread.
-//
-// The other instructions -- kInstEmptyWidth, kInstMatch, kInstCapture --
-// are interesting in their own right but like kInstAlt they don't
-// advance the input pointer.  Only kInstByteRange does.
-//
-// The automaton execution in nfa.cc runs all the possible
-// threads of execution in lock-step over the input.  To process
-// a particular byte, each thread gets run until it either dies
-// or finds a kInstByteRange instruction matching the byte.
-// If the latter happens, the thread stops just past the
-// kInstByteRange instruction (at ip->out()) and waits for
-// the other threads to finish processing the input byte.
-// Then, once all the threads have processed that input byte,
-// the whole process repeats.  The kInstAlt state instruction
-// might create new threads during input processing, but no
-// matter what, all the threads stop after a kInstByteRange
-// and wait for the other threads to "catch up".
-// Running in lock step like this ensures that the NFA reads
-// the input string only once.
-//
-// Each thread maintains its own set of capture registers
-// (the string positions at which it executed the kInstCapture
-// instructions corresponding to capturing parentheses in the
-// regular expression).  Repeated copying of the capture registers
-// is the main performance bottleneck in the NFA implementation.
-//
-// A regular expression program is "one-pass" if, no matter what
-// the input string, there is only one thread that makes it
-// past a kInstByteRange instruction at each input byte.  This means
-// that there is in some sense only one active thread throughout
-// the execution.  Other threads might be created during the
-// processing of an input byte, but they are ephemeral: only one
-// thread is left to start processing the next input byte.
-// This is what I meant above when I said the non-determinism
-// was "contained".
-//
-// To execute a one-pass regular expression program, we can build
-// a DFA (no non-determinism) that has at most as many states as
-// the NFA (compare this to the possibly exponential number of states
-// in the general case).  Each state records, for each possible
-// input byte, the next state along with the conditions required
-// before entering that state -- empty-width flags that must be true
-// and capture operations that must be performed.  It also records
-// whether a set of conditions required to finish a match at that
-// point in the input rather than process the next byte.
-
-// A state in the one-pass NFA - just an array of actions indexed
-// by the bytemap_[] of the next input byte.  (The bytemap
-// maps next input bytes into equivalence classes, to reduce
-// the memory footprint.)
-struct OneState {
-  uint32_t matchcond;   // conditions to match right now.
-  uint32_t action[1];
-};
-
-// The uint32_t conditions in the action are a combination of
-// condition and capture bits and the next state.  The bottom 16 bits
-// are the condition and capture bits, and the top 16 are the index of
-// the next state.
-//
-// Bits 0-5 are the empty-width flags from prog.h.
-// Bit 6 is kMatchWins, which means the match takes
-// priority over moving to next in a first-match search.
-// The remaining bits mark capture registers that should
-// be set to the current input position.  The capture bits
-// start at index 2, since the search loop can take care of
-// cap[0], cap[1] (the overall match position).
-// That means we can handle up to 5 capturing parens: $1 through $4, plus $0.
-// No input position can satisfy both kEmptyWordBoundary
-// and kEmptyNonWordBoundary, so we can use that as a sentinel
-// instead of needing an extra bit.
-
-static const int    kIndexShift   = 16;  // number of bits below index
-static const int    kEmptyShift   = 6;   // number of empty flags in prog.h
-static const int    kRealCapShift = kEmptyShift + 1;
-static const int    kRealMaxCap   = (kIndexShift - kRealCapShift) / 2 * 2;
-
-// Parameters used to skip over cap[0], cap[1].
-static const int    kCapShift     = kRealCapShift - 2;
-static const int    kMaxCap       = kRealMaxCap + 2;
-
-static const uint32_t kMatchWins  = 1 << kEmptyShift;
-static const uint32_t kCapMask    = ((1 << kRealMaxCap) - 1) << kRealCapShift;
-
-static const uint32_t kImpossible = kEmptyWordBoundary | kEmptyNonWordBoundary;
-
-// Check, at compile time, that prog.h agrees with math above.
-// This function is never called.
-void OnePass_Checks() {
-  static_assert((1<<kEmptyShift)-1 == kEmptyAllFlags,
-                "kEmptyShift disagrees with kEmptyAllFlags");
-  // kMaxCap counts pointers, kMaxOnePassCapture counts pairs.
-  static_assert(kMaxCap == Prog::kMaxOnePassCapture*2,
-                "kMaxCap disagrees with kMaxOnePassCapture");
-}
-
-static bool Satisfy(uint32_t cond, const StringPiece& context, const char* p) {
-  uint32_t satisfied = Prog::EmptyFlags(context, p);
-  if (cond & kEmptyAllFlags & ~satisfied)
-    return false;
-  return true;
-}
-
-// Apply the capture bits in cond, saving p to the appropriate
-// locations in cap[].
-static void ApplyCaptures(uint32_t cond, const char* p,
-                          const char** cap, int ncap) {
-  for (int i = 2; i < ncap; i++)
-    if (cond & (1 << kCapShift << i))
-      cap[i] = p;
-}
-
-// Computes the OneState* for the given nodeindex.
-static inline OneState* IndexToNode(uint8_t* nodes, int statesize,
-                                    int nodeindex) {
-  return reinterpret_cast<OneState*>(nodes + statesize*nodeindex);
-}
-
-bool Prog::SearchOnePass(const StringPiece& text,
-                         const StringPiece& const_context,
-                         Anchor anchor, MatchKind kind,
-                         StringPiece* match, int nmatch) {
-  if (anchor != kAnchored && kind != kFullMatch) {
-    LOG(DFATAL) << "Cannot use SearchOnePass for unanchored matches.";
-    return false;
-  }
-
-  // Make sure we have at least cap[1],
-  // because we use it to tell if we matched.
-  int ncap = 2*nmatch;
-  if (ncap < 2)
-    ncap = 2;
-
-  const char* cap[kMaxCap];
-  for (int i = 0; i < ncap; i++)
-    cap[i] = NULL;
-
-  const char* matchcap[kMaxCap];
-  for (int i = 0; i < ncap; i++)
-    matchcap[i] = NULL;
-
-  StringPiece context = const_context;
-  if (context.begin() == NULL)
-    context = text;
-  if (anchor_start() && context.begin() != text.begin())
-    return false;
-  if (anchor_end() && context.end() != text.end())
-    return false;
-  if (anchor_end())
-    kind = kFullMatch;
-
-  uint8_t* nodes = onepass_nodes_.data();
-  int statesize = sizeof(OneState) + bytemap_range()*sizeof(uint32_t);
-  // start() is always mapped to the zeroth OneState.
-  OneState* state = IndexToNode(nodes, statesize, 0);
-  uint8_t* bytemap = bytemap_;
-  const char* bp = text.begin();
-  const char* ep = text.end();
-  const char* p;
-  bool matched = false;
-  matchcap[0] = bp;
-  cap[0] = bp;
-  uint32_t nextmatchcond = state->matchcond;
-  for (p = bp; p < ep; p++) {
-    int c = bytemap[*p & 0xFF];
-    uint32_t matchcond = nextmatchcond;
-    uint32_t cond = state->action[c];
-
-    // Determine whether we can reach act->next.
-    // If so, advance state and nextmatchcond.
-    if ((cond & kEmptyAllFlags) == 0 || Satisfy(cond, context, p)) {
-      uint32_t nextindex = cond >> kIndexShift;
-      state = IndexToNode(nodes, statesize, nextindex);
-      nextmatchcond = state->matchcond;
-    } else {
-      state = NULL;
-      nextmatchcond = kImpossible;
-    }
-
-    // This code section is carefully tuned.
-    // The goto sequence is about 10% faster than the
-    // obvious rewrite as a large if statement in the
-    // ASCIIMatchRE2 and DotMatchRE2 benchmarks.
-
-    // Saving the match capture registers is expensive.
-    // Is this intermediate match worth thinking about?
-
-    // Not if we want a full match.
-    if (kind == kFullMatch)
-      goto skipmatch;
-
-    // Not if it's impossible.
-    if (matchcond == kImpossible)
-      goto skipmatch;
-
-    // Not if the possible match is beaten by the certain
-    // match at the next byte.  When this test is useless
-    // (e.g., HTTPPartialMatchRE2) it slows the loop by
-    // about 10%, but when it avoids work (e.g., DotMatchRE2),
-    // it cuts the loop execution by about 45%.
-    if ((cond & kMatchWins) == 0 && (nextmatchcond & kEmptyAllFlags) == 0)
-      goto skipmatch;
-
-    // Finally, the match conditions must be satisfied.
-    if ((matchcond & kEmptyAllFlags) == 0 || Satisfy(matchcond, context, p)) {
-      for (int i = 2; i < 2*nmatch; i++)
-        matchcap[i] = cap[i];
-      if (nmatch > 1 && (matchcond & kCapMask))
-        ApplyCaptures(matchcond, p, matchcap, ncap);
-      matchcap[1] = p;
-      matched = true;
-
-      // If we're in longest match mode, we have to keep
-      // going and see if we find a longer match.
-      // In first match mode, we can stop if the match
-      // takes priority over the next state for this input byte.
-      // That bit is per-input byte and thus in cond, not matchcond.
-      if (kind == kFirstMatch && (cond & kMatchWins))
-        goto done;
-    }
-
-  skipmatch:
-    if (state == NULL)
-      goto done;
-    if ((cond & kCapMask) && nmatch > 1)
-      ApplyCaptures(cond, p, cap, ncap);
-  }
-
-  // Look for match at end of input.
-  {
-    uint32_t matchcond = state->matchcond;
-    if (matchcond != kImpossible &&
-        ((matchcond & kEmptyAllFlags) == 0 || Satisfy(matchcond, context, p))) {
-      if (nmatch > 1 && (matchcond & kCapMask))
-        ApplyCaptures(matchcond, p, cap, ncap);
-      for (int i = 2; i < ncap; i++)
-        matchcap[i] = cap[i];
-      matchcap[1] = p;
-      matched = true;
-    }
-  }
-
-done:
-  if (!matched)
-    return false;
-  for (int i = 0; i < nmatch; i++)
-    match[i] =
-        StringPiece(matchcap[2 * i],
-                    static_cast<size_t>(matchcap[2 * i + 1] - matchcap[2 * i]));
-  return true;
-}
-
-
-// Analysis to determine whether a given regexp program is one-pass.
-
-// If ip is not on workq, adds ip to work queue and returns true.
-// If ip is already on work queue, does nothing and returns false.
-// If ip is NULL, does nothing and returns true (pretends to add it).
-typedef SparseSet Instq;
-static bool AddQ(Instq *q, int id) {
-  if (id == 0)
-    return true;
-  if (q->contains(id))
-    return false;
-  q->insert(id);
-  return true;
-}
-
-struct InstCond {
-  int id;
-  uint32_t cond;
-};
-
-// Returns whether this is a one-pass program; that is,
-// returns whether it is safe to use SearchOnePass on this program.
-// These conditions must be true for any instruction ip:
-//
-//   (1) for any other Inst nip, there is at most one input-free
-//       path from ip to nip.
-//   (2) there is at most one kInstByte instruction reachable from
-//       ip that matches any particular byte c.
-//   (3) there is at most one input-free path from ip to a kInstMatch
-//       instruction.
-//
-// This is actually just a conservative approximation: it might
-// return false when the answer is true, when kInstEmptyWidth
-// instructions are involved.
-// Constructs and saves corresponding one-pass NFA on success.
-bool Prog::IsOnePass() {
-  if (did_onepass_)
-    return onepass_nodes_.data() != NULL;
-  did_onepass_ = true;
-
-  if (start() == 0)  // no match
-    return false;
-
-  // Steal memory for the one-pass NFA from the overall DFA budget.
-  // Willing to use at most 1/4 of the DFA budget (heuristic).
-  // Limit max node count to 65000 as a conservative estimate to
-  // avoid overflowing 16-bit node index in encoding.
-  int maxnodes = 2 + inst_count(kInstByteRange);
-  int statesize = sizeof(OneState) + bytemap_range()*sizeof(uint32_t);
-  if (maxnodes >= 65000 || dfa_mem_ / 4 / statesize < maxnodes)
-    return false;
-
-  // Flood the graph starting at the start state, and check
-  // that in each reachable state, each possible byte leads
-  // to a unique next state.
-  int stacksize = inst_count(kInstCapture) +
-                  inst_count(kInstEmptyWidth) +
-                  inst_count(kInstNop) + 1;  // + 1 for start inst
-  PODArray<InstCond> stack(stacksize);
-
-  int size = this->size();
-  PODArray<int> nodebyid(size);  // indexed by ip
-  memset(nodebyid.data(), 0xFF, size*sizeof nodebyid[0]);
-
-  // Originally, nodes was a uint8_t[maxnodes*statesize], but that was
-  // unnecessarily optimistic: why allocate a large amount of memory
-  // upfront for a large program when it is unlikely to be one-pass?
-  std::vector<uint8_t> nodes;
-
-  Instq tovisit(size), workq(size);
-  AddQ(&tovisit, start());
-  nodebyid[start()] = 0;
-  int nalloc = 1;
-  nodes.insert(nodes.end(), statesize, 0);
-  for (Instq::iterator it = tovisit.begin(); it != tovisit.end(); ++it) {
-    int id = *it;
-    int nodeindex = nodebyid[id];
-    OneState* node = IndexToNode(nodes.data(), statesize, nodeindex);
-
-    // Flood graph using manual stack, filling in actions as found.
-    // Default is none.
-    for (int b = 0; b < bytemap_range_; b++)
-      node->action[b] = kImpossible;
-    node->matchcond = kImpossible;
-
-    workq.clear();
-    bool matched = false;
-    int nstack = 0;
-    stack[nstack].id = id;
-    stack[nstack++].cond = 0;
-    while (nstack > 0) {
-      int id = stack[--nstack].id;
-      uint32_t cond = stack[nstack].cond;
-
-    Loop:
-      Prog::Inst* ip = inst(id);
-      switch (ip->opcode()) {
-        default:
-          LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-          break;
-
-        case kInstAltMatch:
-          // TODO(rsc): Ignoring kInstAltMatch optimization.
-          // Should implement it in this engine, but it's subtle.
-          DCHECK(!ip->last());
-          // If already on work queue, (1) is violated: bail out.
-          if (!AddQ(&workq, id+1))
-            goto fail;
-          id = id+1;
-          goto Loop;
-
-        case kInstByteRange: {
-          int nextindex = nodebyid[ip->out()];
-          if (nextindex == -1) {
-            if (nalloc >= maxnodes) {
-              goto fail;
-            }
-            nextindex = nalloc;
-            AddQ(&tovisit, ip->out());
-            nodebyid[ip->out()] = nalloc;
-            nalloc++;
-            nodes.insert(nodes.end(), statesize, 0);
-            // Update node because it might have been invalidated.
-            node = IndexToNode(nodes.data(), statesize, nodeindex);
-          }
-          for (int c = ip->lo(); c <= ip->hi(); c++) {
-            int b = bytemap_[c];
-            // Skip any bytes immediately after c that are also in b.
-            while (c < 256-1 && bytemap_[c+1] == b)
-              c++;
-            uint32_t act = node->action[b];
-            uint32_t newact = (nextindex << kIndexShift) | cond;
-            if (matched)
-              newact |= kMatchWins;
-            if ((act & kImpossible) == kImpossible) {
-              node->action[b] = newact;
-            } else if (act != newact) {
-              goto fail;
-            }
-          }
-          if (ip->foldcase()) {
-            Rune lo = std::max<Rune>(ip->lo(), 'a') + 'A' - 'a';
-            Rune hi = std::min<Rune>(ip->hi(), 'z') + 'A' - 'a';
-            for (int c = lo; c <= hi; c++) {
-              int b = bytemap_[c];
-              // Skip any bytes immediately after c that are also in b.
-              while (c < 256-1 && bytemap_[c+1] == b)
-                c++;
-              uint32_t act = node->action[b];
-              uint32_t newact = (nextindex << kIndexShift) | cond;
-              if (matched)
-                newact |= kMatchWins;
-              if ((act & kImpossible) == kImpossible) {
-                node->action[b] = newact;
-              } else if (act != newact) {
-                goto fail;
-              }
-            }
-          }
-
-          if (ip->last())
-            break;
-          // If already on work queue, (1) is violated: bail out.
-          if (!AddQ(&workq, id+1))
-            goto fail;
-          id = id+1;
-          goto Loop;
-        }
-
-        case kInstCapture:
-        case kInstEmptyWidth:
-        case kInstNop:
-          if (!ip->last()) {
-            // If already on work queue, (1) is violated: bail out.
-            if (!AddQ(&workq, id+1))
-              goto fail;
-            stack[nstack].id = id+1;
-            stack[nstack++].cond = cond;
-          }
-
-          if (ip->opcode() == kInstCapture && ip->cap() < kMaxCap)
-            cond |= (1 << kCapShift) << ip->cap();
-          if (ip->opcode() == kInstEmptyWidth)
-            cond |= ip->empty();
-
-          // kInstCapture and kInstNop always proceed to ip->out().
-          // kInstEmptyWidth only sometimes proceeds to ip->out(),
-          // but as a conservative approximation we assume it always does.
-          // We could be a little more precise by looking at what c
-          // is, but that seems like overkill.
-
-          // If already on work queue, (1) is violated: bail out.
-          if (!AddQ(&workq, ip->out())) {
-            goto fail;
-          }
-          id = ip->out();
-          goto Loop;
-
-        case kInstMatch:
-          if (matched) {
-            // (3) is violated
-            goto fail;
-          }
-          matched = true;
-          node->matchcond = cond;
-
-          if (ip->last())
-            break;
-          // If already on work queue, (1) is violated: bail out.
-          if (!AddQ(&workq, id+1))
-            goto fail;
-          id = id+1;
-          goto Loop;
-
-        case kInstFail:
-          break;
-      }
-    }
-  }
-  dfa_mem_ -= nalloc*statesize;
-  onepass_nodes_ = PODArray<uint8_t>(nalloc*statesize);
-  memmove(onepass_nodes_.data(), nodes.data(), nalloc*statesize);
-  return true;
-
-fail:
-  return false;
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Regular expression parser.
-
-// The parser is a simple precedence-based parser with a
-// manual stack.  The parsing work is done by the methods
-// of the ParseState class.  The Regexp::Parse function is
-// essentially just a lexer that calls the ParseState method
-// for each token.
-
-// The parser recognizes POSIX extended regular expressions
-// excluding backreferences, collating elements, and collating
-// classes.  It also allows the empty string as a regular expression
-// and recognizes the Perl escape sequences \d, \s, \w, \D, \S, and \W.
-// See regexp.h for rationale.
-
-#include <ctype.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-#include <algorithm>
-#include <map>
-#include <string>
-#include <vector>
-
-
-
-
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_UNICODE_CASEFOLD_H_
-#define RE2_UNICODE_CASEFOLD_H_
-
-// Unicode case folding tables.
-
-// The Unicode case folding tables encode the mapping from one Unicode point
-// to the next largest Unicode point with equivalent folding.  The largest
-// point wraps back to the first.  For example, the tables map:
-//
-//     'A' -> 'a'
-//     'a' -> 'A'
-//
-//     'K' -> 'k'
-//     'k' -> 'K'  (Kelvin symbol)
-//     'K' -> 'K'
-//
-// Like everything Unicode, these tables are big.  If we represent the table
-// as a sorted list of uint32_t pairs, it has 2049 entries and is 16 kB.
-// Most table entries look like the ones around them:
-// 'A' maps to 'A'+32, 'B' maps to 'B'+32, etc.
-// Instead of listing all the pairs explicitly, we make a list of ranges
-// and deltas, so that the table entries for 'A' through 'Z' can be represented
-// as a single entry { 'A', 'Z', +32 }.
-//
-// In addition to blocks that map to each other (A-Z mapping to a-z)
-// there are blocks of pairs that individually map to each other
-// (for example, 0100<->0101, 0102<->0103, 0104<->0105, ...).
-// For those, the special delta value EvenOdd marks even/odd pairs
-// (if even, add 1; if odd, subtract 1), and OddEven marks odd/even pairs.
-//
-// In this form, the table has 274 entries, about 3kB.  If we were to split
-// the table into one for 16-bit codes and an overflow table for larger ones,
-// we could get it down to about 1.5kB, but that's not worth the complexity.
-//
-// The grouped form also allows for efficient fold range calculations
-// rather than looping one character at a time.
-
-#include <stdint.h>
-
-
-
-
-namespace duckdb_re2 {
-
-enum {
-  EvenOdd = 1,
-  OddEven = -1,
-  EvenOddSkip = 1<<30,
-  OddEvenSkip,
-};
-
-struct CaseFold {
-  Rune lo;
-  Rune hi;
-  int32_t delta;
-};
-
-extern const CaseFold unicode_casefold[];
-extern const int num_unicode_casefold;
-
-extern const CaseFold unicode_tolower[];
-extern const int num_unicode_tolower;
-
-// Returns the CaseFold* in the tables that contains rune.
-// If rune is not in the tables, returns the first CaseFold* after rune.
-// If rune is larger than any value in the tables, returns NULL.
-extern const CaseFold* LookupCaseFold(const CaseFold*, int, Rune rune);
-
-// Returns the result of applying the fold f to the rune r.
-extern Rune ApplyFold(const CaseFold *f, Rune r);
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_UNICODE_CASEFOLD_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_UNICODE_GROUPS_H_
-#define RE2_UNICODE_GROUPS_H_
-
-// Unicode character groups.
-
-// The codes get split into ranges of 16-bit codes
-// and ranges of 32-bit codes.  It would be simpler
-// to use only 32-bit ranges, but these tables are large
-// enough to warrant extra care.
-//
-// Using just 32-bit ranges gives 27 kB of data.
-// Adding 16-bit ranges gives 18 kB of data.
-// Adding an extra table of 16-bit singletons would reduce
-// to 16.5 kB of data but make the data harder to use;
-// we don't bother.
-
-#include <stdint.h>
-
-
-
-
-namespace duckdb_re2 {
-
-struct URange16
-{
-  uint16_t lo;
-  uint16_t hi;
-};
-
-struct URange32
-{
-  Rune lo;
-  Rune hi;
-};
-
-struct UGroup
-{
-  const char *name;
-  int sign;  // +1 for [abc], -1 for [^abc]
-  const URange16 *r16;
-  int nr16;
-  const URange32 *r32;
-  int nr32;
-};
-
-// Named by property or script name (e.g., "Nd", "N", "Han").
-// Negated groups are not included.
-extern const UGroup unicode_groups[];
-extern const int num_unicode_groups;
-
-// Named by POSIX name (e.g., "[:alpha:]", "[:^lower:]").
-// Negated groups are included.
-extern const UGroup posix_groups[];
-extern const int num_posix_groups;
-
-// Named by Perl name (e.g., "\\d", "\\D").
-// Negated groups are included.
-extern const UGroup perl_groups[];
-extern const int num_perl_groups;
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_UNICODE_GROUPS_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-// #if defined(RE2_USE_ICU)
-// #include "unicode/uniset.h"
-// #include "unicode/unistr.h"
-// #include "unicode/utypes.h"
-// #endif
-
-namespace duckdb_re2 {
-
-// Reduce the maximum repeat count by an order of magnitude when fuzzing.
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-static const int kMaxRepeat = 100;
-#else
-static const int kMaxRepeat = 1000;
-#endif
-
-// Regular expression parse state.
-// The list of parsed regexps so far is maintained as a vector of
-// Regexp pointers called the stack.  Left parenthesis and vertical
-// bar markers are also placed on the stack, as Regexps with
-// non-standard opcodes.
-// Scanning a left parenthesis causes the parser to push a left parenthesis
-// marker on the stack.
-// Scanning a vertical bar causes the parser to pop the stack until it finds a
-// vertical bar or left parenthesis marker (not popping the marker),
-// concatenate all the popped results, and push them back on
-// the stack (DoConcatenation).
-// Scanning a right parenthesis causes the parser to act as though it
-// has seen a vertical bar, which then leaves the top of the stack in the
-// form LeftParen regexp VerticalBar regexp VerticalBar ... regexp VerticalBar.
-// The parser pops all this off the stack and creates an alternation of the
-// regexps (DoAlternation).
-
-class Regexp::ParseState {
- public:
-  ParseState(ParseFlags flags, const StringPiece& whole_regexp,
-             RegexpStatus* status);
-  ~ParseState();
-
-  ParseFlags flags() { return flags_; }
-  int rune_max() { return rune_max_; }
-
-  // Parse methods.  All public methods return a bool saying
-  // whether parsing should continue.  If a method returns
-  // false, it has set fields in *status_, and the parser
-  // should return NULL.
-
-  // Pushes the given regular expression onto the stack.
-  // Could check for too much memory used here.
-  bool PushRegexp(Regexp* re);
-
-  // Pushes the literal rune r onto the stack.
-  bool PushLiteral(Rune r);
-
-  // Pushes a regexp with the given op (and no args) onto the stack.
-  bool PushSimpleOp(RegexpOp op);
-
-  // Pushes a ^ onto the stack.
-  bool PushCarat();
-
-  // Pushes a \b (word == true) or \B (word == false) onto the stack.
-  bool PushWordBoundary(bool word);
-
-  // Pushes a $ onto the stack.
-  bool PushDollar();
-
-  // Pushes a . onto the stack
-  bool PushDot();
-
-  // Pushes a repeat operator regexp onto the stack.
-  // A valid argument for the operator must already be on the stack.
-  // s is the name of the operator, for use in error messages.
-  bool PushRepeatOp(RegexpOp op, const StringPiece& s, bool nongreedy);
-
-  // Pushes a repetition regexp onto the stack.
-  // A valid argument for the operator must already be on the stack.
-  bool PushRepetition(int min, int max, const StringPiece& s, bool nongreedy);
-
-  // Checks whether a particular regexp op is a marker.
-  bool IsMarker(RegexpOp op);
-
-  // Processes a left parenthesis in the input.
-  // Pushes a marker onto the stack.
-  bool DoLeftParen(const StringPiece& name);
-  bool DoLeftParenNoCapture();
-
-  // Processes a vertical bar in the input.
-  bool DoVerticalBar();
-
-  // Processes a right parenthesis in the input.
-  bool DoRightParen();
-
-  // Processes the end of input, returning the final regexp.
-  Regexp* DoFinish();
-
-  // Finishes the regexp if necessary, preparing it for use
-  // in a more complicated expression.
-  // If it is a CharClassBuilder, converts into a CharClass.
-  Regexp* FinishRegexp(Regexp*);
-
-  // These routines don't manipulate the parse stack
-  // directly, but they do need to look at flags_.
-  // ParseCharClass also manipulates the internals of Regexp
-  // while creating *out_re.
-
-  // Parse a character class into *out_re.
-  // Removes parsed text from s.
-  bool ParseCharClass(StringPiece* s, Regexp** out_re,
-                      RegexpStatus* status);
-
-  // Parse a character class character into *rp.
-  // Removes parsed text from s.
-  bool ParseCCCharacter(StringPiece* s, Rune *rp,
-                        const StringPiece& whole_class,
-                        RegexpStatus* status);
-
-  // Parse a character class range into rr.
-  // Removes parsed text from s.
-  bool ParseCCRange(StringPiece* s, RuneRange* rr,
-                    const StringPiece& whole_class,
-                    RegexpStatus* status);
-
-  // Parse a Perl flag set or non-capturing group from s.
-  bool ParsePerlFlags(StringPiece* s);
-
-
-  // Finishes the current concatenation,
-  // collapsing it into a single regexp on the stack.
-  void DoConcatenation();
-
-  // Finishes the current alternation,
-  // collapsing it to a single regexp on the stack.
-  void DoAlternation();
-
-  // Generalized DoAlternation/DoConcatenation.
-  void DoCollapse(RegexpOp op);
-
-  // Maybe concatenate Literals into LiteralString.
-  bool MaybeConcatString(int r, ParseFlags flags);
-
-private:
-  ParseFlags flags_;
-  StringPiece whole_regexp_;
-  RegexpStatus* status_;
-  Regexp* stacktop_;
-  int ncap_;  // number of capturing parens seen
-  int rune_max_;  // maximum char value for this encoding
-
-  ParseState(const ParseState&) = delete;
-  ParseState& operator=(const ParseState&) = delete;
-};
-
-// Pseudo-operators - only on parse stack.
-const RegexpOp kLeftParen = static_cast<RegexpOp>(kMaxRegexpOp+1);
-const RegexpOp kVerticalBar = static_cast<RegexpOp>(kMaxRegexpOp+2);
-
-Regexp::ParseState::ParseState(ParseFlags flags,
-                               const StringPiece& whole_regexp,
-                               RegexpStatus* status)
-  : flags_(flags), whole_regexp_(whole_regexp),
-    status_(status), stacktop_(NULL), ncap_(0) {
-  if (flags_ & Latin1)
-    rune_max_ = 0xFF;
-  else
-    rune_max_ = Runemax;
-}
-
-// Cleans up by freeing all the regexps on the stack.
-Regexp::ParseState::~ParseState() {
-  Regexp* next;
-  for (Regexp* re = stacktop_; re != NULL; re = next) {
-    next = re->down_;
-    re->down_ = NULL;
-    if (re->op() == kLeftParen)
-      delete re->capture_.name_;
-    re->Decref();
-  }
-}
-
-// Finishes the regexp if necessary, preparing it for use in
-// a more complex expression.
-// If it is a CharClassBuilder, converts into a CharClass.
-Regexp* Regexp::ParseState::FinishRegexp(Regexp* re) {
-  if (re == NULL)
-    return NULL;
-  re->down_ = NULL;
-
-  if (re->op_ == kRegexpCharClass && re->char_class_.ccb_ != NULL) {
-    CharClassBuilder* ccb = re->char_class_.ccb_;
-    re->char_class_.ccb_ = NULL;
-    re->char_class_.cc_ = ccb->GetCharClass();
-    delete ccb;
-  }
-
-  return re;
-}
-
-// Pushes the given regular expression onto the stack.
-// Could check for too much memory used here.
-bool Regexp::ParseState::PushRegexp(Regexp* re) {
-  MaybeConcatString(-1, NoParseFlags);
-
-  // Special case: a character class of one character is just
-  // a literal.  This is a common idiom for escaping
-  // single characters (e.g., [.] instead of \.), and some
-  // analysis does better with fewer character classes.
-  // Similarly, [Aa] can be rewritten as a literal A with ASCII case folding.
-  auto ccb = re->char_class_.ccb_;
-  if (re->op_ == kRegexpCharClass && ccb != NULL) {
-	  ccb->RemoveAbove(rune_max_);
-    if (ccb->size() == 1) {
-      Rune r = ccb->begin()->lo;
-      re->Decref();
-      re = new Regexp(kRegexpLiteral, flags_);
-      re->rune_ = r;
-    } else if (ccb->size() == 2) {
-      Rune r = ccb->begin()->lo;
-      if ('A' <= r && r <= 'Z' && ccb->Contains(r + 'a' - 'A')) {
-        re->Decref();
-        re = new Regexp(kRegexpLiteral, flags_ | FoldCase);
-        re->rune_ = r + 'a' - 'A';
-      }
-    }
-  }
-
-  if (!IsMarker(re->op()))
-    re->simple_ = re->ComputeSimple();
-  re->down_ = stacktop_;
-  stacktop_ = re;
-  return true;
-}
-
-// Searches the case folding tables and returns the CaseFold* that contains r.
-// If there isn't one, returns the CaseFold* with smallest f->lo bigger than r.
-// If there isn't one, returns NULL.
-const CaseFold* LookupCaseFold(const CaseFold *f, int n, Rune r) {
-  const CaseFold* ef = f + n;
-
-  // Binary search for entry containing r.
-  while (n > 0) {
-    int m = n/2;
-    if (f[m].lo <= r && r <= f[m].hi)
-      return &f[m];
-    if (r < f[m].lo) {
-      n = m;
-    } else {
-      f += m+1;
-      n -= m+1;
-    }
-  }
-
-  // There is no entry that contains r, but f points
-  // where it would have been.  Unless f points at
-  // the end of the array, it points at the next entry
-  // after r.
-  if (f < ef)
-    return f;
-
-  // No entry contains r; no entry contains runes > r.
-  return NULL;
-}
-
-// Returns the result of applying the fold f to the rune r.
-Rune ApplyFold(const CaseFold *f, Rune r) {
-  switch (f->delta) {
-    default:
-      return r + f->delta;
-
-    case EvenOddSkip:  // even <-> odd but only applies to every other
-      if ((r - f->lo) % 2)
-        return r;
-      FALLTHROUGH_INTENDED;
-    case EvenOdd:  // even <-> odd
-      if (r%2 == 0)
-        return r + 1;
-      return r - 1;
-
-    case OddEvenSkip:  // odd <-> even but only applies to every other
-      if ((r - f->lo) % 2)
-        return r;
-      FALLTHROUGH_INTENDED;
-    case OddEven:  // odd <-> even
-      if (r%2 == 1)
-        return r + 1;
-      return r - 1;
-  }
-}
-
-// Returns the next Rune in r's folding cycle (see unicode_casefold.h).
-// Examples:
-//   CycleFoldRune('A') = 'a'
-//   CycleFoldRune('a') = 'A'
-//
-//   CycleFoldRune('K') = 'k'
-//   CycleFoldRune('k') = 0x212A (Kelvin)
-//   CycleFoldRune(0x212A) = 'K'
-//
-//   CycleFoldRune('?') = '?'
-Rune CycleFoldRune(Rune r) {
-  const CaseFold* f = LookupCaseFold(unicode_casefold, num_unicode_casefold, r);
-  if (f == NULL || r < f->lo)
-    return r;
-  return ApplyFold(f, r);
-}
-
-// Add lo-hi to the class, along with their fold-equivalent characters.
-// If lo-hi is already in the class, assume that the fold-equivalent
-// chars are there too, so there's no work to do.
-static void AddFoldedRange(CharClassBuilder* cc, Rune lo, Rune hi, int depth) {
-  // AddFoldedRange calls itself recursively for each rune in the fold cycle.
-  // Most folding cycles are small: there aren't any bigger than four in the
-  // current Unicode tables.  make_unicode_casefold.py checks that
-  // the cycles are not too long, and we double-check here using depth.
-  if (depth > 10) {
-    LOG(DFATAL) << "AddFoldedRange recurses too much.";
-    return;
-  }
-
-  if (!cc->AddRange(lo, hi))  // lo-hi was already there? we're done
-    return;
-
-  while (lo <= hi) {
-    const CaseFold* f = LookupCaseFold(unicode_casefold, num_unicode_casefold, lo);
-    if (f == NULL)  // lo has no fold, nor does anything above lo
-      break;
-    if (lo < f->lo) {  // lo has no fold; next rune with a fold is f->lo
-      lo = f->lo;
-      continue;
-    }
-
-    // Add in the result of folding the range lo - f->hi
-    // and that range's fold, recursively.
-    Rune lo1 = lo;
-    Rune hi1 = std::min<Rune>(hi, f->hi);
-    switch (f->delta) {
-      default:
-        lo1 += f->delta;
-        hi1 += f->delta;
-        break;
-      case EvenOdd:
-        if (lo1%2 == 1)
-          lo1--;
-        if (hi1%2 == 0)
-          hi1++;
-        break;
-      case OddEven:
-        if (lo1%2 == 0)
-          lo1--;
-        if (hi1%2 == 1)
-          hi1++;
-        break;
-    }
-    AddFoldedRange(cc, lo1, hi1, depth+1);
-
-    // Pick up where this fold left off.
-    lo = f->hi + 1;
-  }
-}
-
-// Pushes the literal rune r onto the stack.
-bool Regexp::ParseState::PushLiteral(Rune r) {
-  // Do case folding if needed.
-  if ((flags_ & FoldCase) && CycleFoldRune(r) != r) {
-    Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
-    re->char_class_.ccb_ = new CharClassBuilder;
-    Rune r1 = r;
-    do {
-      if (!(flags_ & NeverNL) || r != '\n') {
-        re->char_class_.ccb_->AddRange(r, r);
-      }
-      r = CycleFoldRune(r);
-    } while (r != r1);
-    return PushRegexp(re);
-  }
-
-  // Exclude newline if applicable.
-  if ((flags_ & NeverNL) && r == '\n')
-    return PushRegexp(new Regexp(kRegexpNoMatch, flags_));
-
-  // No fancy stuff worked.  Ordinary literal.
-  if (MaybeConcatString(r, flags_))
-    return true;
-
-  Regexp* re = new Regexp(kRegexpLiteral, flags_);
-  re->rune_ = r;
-  return PushRegexp(re);
-}
-
-// Pushes a ^ onto the stack.
-bool Regexp::ParseState::PushCarat() {
-  if (flags_ & OneLine) {
-    return PushSimpleOp(kRegexpBeginText);
-  }
-  return PushSimpleOp(kRegexpBeginLine);
-}
-
-// Pushes a \b or \B onto the stack.
-bool Regexp::ParseState::PushWordBoundary(bool word) {
-  if (word)
-    return PushSimpleOp(kRegexpWordBoundary);
-  return PushSimpleOp(kRegexpNoWordBoundary);
-}
-
-// Pushes a $ onto the stack.
-bool Regexp::ParseState::PushDollar() {
-  if (flags_ & OneLine) {
-    // Clumsy marker so that MimicsPCRE() can tell whether
-    // this kRegexpEndText was a $ and not a \z.
-    Regexp::ParseFlags oflags = flags_;
-    flags_ = flags_ | WasDollar;
-    bool ret = PushSimpleOp(kRegexpEndText);
-    flags_ = oflags;
-    return ret;
-  }
-  return PushSimpleOp(kRegexpEndLine);
-}
-
-// Pushes a . onto the stack.
-bool Regexp::ParseState::PushDot() {
-  if ((flags_ & DotNL) && !(flags_ & NeverNL))
-    return PushSimpleOp(kRegexpAnyChar);
-  // Rewrite . into [^\n]
-  Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
-  re->char_class_.ccb_ = new CharClassBuilder;
-  re->char_class_.ccb_->AddRange(0, '\n' - 1);
-  re->char_class_.ccb_->AddRange('\n' + 1, rune_max_);
-  return PushRegexp(re);
-}
-
-// Pushes a regexp with the given op (and no args) onto the stack.
-bool Regexp::ParseState::PushSimpleOp(RegexpOp op) {
-  Regexp* re = new Regexp(op, flags_);
-  return PushRegexp(re);
-}
-
-// Pushes a repeat operator regexp onto the stack.
-// A valid argument for the operator must already be on the stack.
-// The char c is the name of the operator, for use in error messages.
-bool Regexp::ParseState::PushRepeatOp(RegexpOp op, const StringPiece& s,
-                                      bool nongreedy) {
-  if (stacktop_ == NULL || IsMarker(stacktop_->op())) {
-    status_->set_code(kRegexpRepeatArgument);
-    status_->set_error_arg(s);
-    return false;
-  }
-  Regexp::ParseFlags fl = flags_;
-  if (nongreedy)
-    fl = fl ^ NonGreedy;
-
-  // Squash **, ++ and ??. Regexp::Star() et al. handle this too, but
-  // they're mostly for use during simplification, not during parsing.
-  if (op == stacktop_->op() && fl == stacktop_->parse_flags())
-    return true;
-
-  // Squash *+, *?, +*, +?, ?* and ?+. They all squash to *, so because
-  // op is a repeat, we just have to check that stacktop_->op() is too,
-  // then adjust stacktop_.
-  if ((stacktop_->op() == kRegexpStar ||
-       stacktop_->op() == kRegexpPlus ||
-       stacktop_->op() == kRegexpQuest) &&
-      fl == stacktop_->parse_flags()) {
-    stacktop_->op_ = kRegexpStar;
-    return true;
-  }
-
-  Regexp* re = new Regexp(op, fl);
-  re->AllocSub(1);
-  re->down_ = stacktop_->down_;
-  re->sub()[0] = FinishRegexp(stacktop_);
-  re->simple_ = re->ComputeSimple();
-  stacktop_ = re;
-  return true;
-}
-
-// RepetitionWalker reports whether the repetition regexp is valid.
-// Valid means that the combination of the top-level repetition
-// and any inner repetitions does not exceed n copies of the
-// innermost thing.
-// This rewalks the regexp tree and is called for every repetition,
-// so we have to worry about inducing quadratic behavior in the parser.
-// We avoid this by only using RepetitionWalker when min or max >= 2.
-// In that case the depth of any >= 2 nesting can only get to 9 without
-// triggering a parse error, so each subtree can only be rewalked 9 times.
-class RepetitionWalker : public Regexp::Walker<int> {
- public:
-  RepetitionWalker() {}
-  virtual int PreVisit(Regexp* re, int parent_arg, bool* stop);
-  virtual int PostVisit(Regexp* re, int parent_arg, int pre_arg,
-                        int* child_args, int nchild_args);
-  virtual int ShortVisit(Regexp* re, int parent_arg);
-
- private:
-  RepetitionWalker(const RepetitionWalker&) = delete;
-  RepetitionWalker& operator=(const RepetitionWalker&) = delete;
-};
-
-int RepetitionWalker::PreVisit(Regexp* re, int parent_arg, bool* stop) {
-  int arg = parent_arg;
-  if (re->op() == kRegexpRepeat) {
-    int m = re->max();
-    if (m < 0) {
-      m = re->min();
-    }
-    if (m > 0) {
-      arg /= m;
-    }
-  }
-  return arg;
-}
-
-int RepetitionWalker::PostVisit(Regexp* re, int parent_arg, int pre_arg,
-                                int* child_args, int nchild_args) {
-  int arg = pre_arg;
-  for (int i = 0; i < nchild_args; i++) {
-    if (child_args[i] < arg) {
-      arg = child_args[i];
-    }
-  }
-  return arg;
-}
-
-int RepetitionWalker::ShortVisit(Regexp* re, int parent_arg) {
-  // This should never be called, since we use Walk and not
-  // WalkExponential.
-  LOG(DFATAL) << "RepetitionWalker::ShortVisit called";
-  return 0;
-}
-
-// Pushes a repetition regexp onto the stack.
-// A valid argument for the operator must already be on the stack.
-bool Regexp::ParseState::PushRepetition(int min, int max,
-                                        const StringPiece& s,
-                                        bool nongreedy) {
-  if ((max != -1 && max < min) || min > kMaxRepeat || max > kMaxRepeat) {
-    status_->set_code(kRegexpRepeatSize);
-    status_->set_error_arg(s);
-    return false;
-  }
-  if (stacktop_ == NULL || IsMarker(stacktop_->op())) {
-    status_->set_code(kRegexpRepeatArgument);
-    status_->set_error_arg(s);
-    return false;
-  }
-  Regexp::ParseFlags fl = flags_;
-  if (nongreedy)
-    fl = fl ^ NonGreedy;
-  Regexp* re = new Regexp(kRegexpRepeat, fl);
-  re->repeat_.min_ = min;
-  re->repeat_.max_ = max;
-  re->AllocSub(1);
-  re->down_ = stacktop_->down_;
-  re->sub()[0] = FinishRegexp(stacktop_);
-  re->simple_ = re->ComputeSimple();
-  stacktop_ = re;
-  if (min >= 2 || max >= 2) {
-    RepetitionWalker w;
-    if (w.Walk(stacktop_, kMaxRepeat) == 0) {
-      status_->set_code(kRegexpRepeatSize);
-      status_->set_error_arg(s);
-      return false;
-    }
-  }
-  return true;
-}
-
-// Checks whether a particular regexp op is a marker.
-bool Regexp::ParseState::IsMarker(RegexpOp op) {
-  return op >= kLeftParen;
-}
-
-// Processes a left parenthesis in the input.
-// Pushes a marker onto the stack.
-bool Regexp::ParseState::DoLeftParen(const StringPiece& name) {
-  Regexp* re = new Regexp(kLeftParen, flags_);
-  re->capture_.cap_ = ++ncap_;
-  if (name.data() != NULL)
-    re->capture_.name_ = new std::string(name);
-  return PushRegexp(re);
-}
-
-// Pushes a non-capturing marker onto the stack.
-bool Regexp::ParseState::DoLeftParenNoCapture() {
-  Regexp* re = new Regexp(kLeftParen, flags_);
-  re->capture_.cap_ = -1;
-  return PushRegexp(re);
-}
-
-// Processes a vertical bar in the input.
-bool Regexp::ParseState::DoVerticalBar() {
-  MaybeConcatString(-1, NoParseFlags);
-  DoConcatenation();
-
-  // Below the vertical bar is a list to alternate.
-  // Above the vertical bar is a list to concatenate.
-  // We just did the concatenation, so either swap
-  // the result below the vertical bar or push a new
-  // vertical bar on the stack.
-  Regexp* r1;
-  Regexp* r2;
-  if ((r1 = stacktop_) != NULL &&
-      (r2 = r1->down_) != NULL &&
-      r2->op() == kVerticalBar) {
-    Regexp* r3;
-    if ((r3 = r2->down_) != NULL &&
-        (r1->op() == kRegexpAnyChar || r3->op() == kRegexpAnyChar)) {
-      // AnyChar is above or below the vertical bar. Let it subsume
-      // the other when the other is Literal, CharClass or AnyChar.
-      if (r3->op() == kRegexpAnyChar &&
-          (r1->op() == kRegexpLiteral ||
-           r1->op() == kRegexpCharClass ||
-           r1->op() == kRegexpAnyChar)) {
-        // Discard r1.
-        stacktop_ = r2;
-        r1->Decref();
-        return true;
-      }
-      if (r1->op() == kRegexpAnyChar &&
-          (r3->op() == kRegexpLiteral ||
-           r3->op() == kRegexpCharClass ||
-           r3->op() == kRegexpAnyChar)) {
-        // Rearrange the stack and discard r3.
-        r1->down_ = r3->down_;
-        r2->down_ = r1;
-        stacktop_ = r2;
-        r3->Decref();
-        return true;
-      }
-    }
-    // Swap r1 below vertical bar (r2).
-    r1->down_ = r2->down_;
-    r2->down_ = r1;
-    stacktop_ = r2;
-    return true;
-  }
-  return PushSimpleOp(kVerticalBar);
-}
-
-// Processes a right parenthesis in the input.
-bool Regexp::ParseState::DoRightParen() {
-  // Finish the current concatenation and alternation.
-  DoAlternation();
-
-  // The stack should be: LeftParen regexp
-  // Remove the LeftParen, leaving the regexp,
-  // parenthesized.
-  Regexp* r1;
-  Regexp* r2;
-  if ((r1 = stacktop_) == NULL ||
-      (r2 = r1->down_) == NULL ||
-      r2->op() != kLeftParen) {
-    status_->set_code(kRegexpMissingParen);
-    status_->set_error_arg(whole_regexp_);
-    return false;
-  }
-
-  // Pop off r1, r2.  Will Decref or reuse below.
-  stacktop_ = r2->down_;
-
-  // Restore flags from when paren opened.
-  Regexp* re = r2;
-  flags_ = re->parse_flags();
-
-  // Rewrite LeftParen as capture if needed.
-  if (re->capture_.cap_ > 0) {
-    re->op_ = kRegexpCapture;
-    // re->cap_ is already set
-    re->AllocSub(1);
-    re->sub()[0] = FinishRegexp(r1);
-    re->simple_ = re->ComputeSimple();
-  } else {
-    re->Decref();
-    re = r1;
-  }
-  return PushRegexp(re);
-}
-
-// Processes the end of input, returning the final regexp.
-Regexp* Regexp::ParseState::DoFinish() {
-  DoAlternation();
-  Regexp* re = stacktop_;
-  if (re != NULL && re->down_ != NULL) {
-    status_->set_code(kRegexpMissingParen);
-    status_->set_error_arg(whole_regexp_);
-    return NULL;
-  }
-  stacktop_ = NULL;
-  return FinishRegexp(re);
-}
-
-// Returns the leading regexp that re starts with.
-// The returned Regexp* points into a piece of re,
-// so it must not be used after the caller calls re->Decref().
-Regexp* Regexp::LeadingRegexp(Regexp* re) {
-  if (re->op() == kRegexpEmptyMatch)
-    return NULL;
-  if (re->op() == kRegexpConcat && re->nsub() >= 2) {
-    Regexp** sub = re->sub();
-    if (sub[0]->op() == kRegexpEmptyMatch)
-      return NULL;
-    return sub[0];
-  }
-  return re;
-}
-
-// Removes LeadingRegexp(re) from re and returns what's left.
-// Consumes the reference to re and may edit it in place.
-// If caller wants to hold on to LeadingRegexp(re),
-// must have already Incref'ed it.
-Regexp* Regexp::RemoveLeadingRegexp(Regexp* re) {
-  if (re->op() == kRegexpEmptyMatch)
-    return re;
-  if (re->op() == kRegexpConcat && re->nsub() >= 2) {
-    Regexp** sub = re->sub();
-    if (sub[0]->op() == kRegexpEmptyMatch)
-      return re;
-    sub[0]->Decref();
-    sub[0] = NULL;
-    if (re->nsub() == 2) {
-      // Collapse concatenation to single regexp.
-      Regexp* nre = sub[1];
-      sub[1] = NULL;
-      re->Decref();
-      return nre;
-    }
-    // 3 or more -> 2 or more.
-    re->nsub_--;
-    memmove(sub, sub + 1, re->nsub_ * sizeof sub[0]);
-    return re;
-  }
-  Regexp::ParseFlags pf = re->parse_flags();
-  re->Decref();
-  return new Regexp(kRegexpEmptyMatch, pf);
-}
-
-// Returns the leading string that re starts with.
-// The returned Rune* points into a piece of re,
-// so it must not be used after the caller calls re->Decref().
-Rune* Regexp::LeadingString(Regexp* re, int *nrune,
-                            Regexp::ParseFlags *flags) {
-  while (re->op() == kRegexpConcat && re->nsub() > 0)
-    re = re->sub()[0];
-
-  *flags = static_cast<Regexp::ParseFlags>(re->parse_flags_ & Regexp::FoldCase);
-
-  if (re->op() == kRegexpLiteral) {
-    *nrune = 1;
-    return &re->rune_;
-  }
-
-  if (re->op() == kRegexpLiteralString) {
-    *nrune = re->literal_string_.nrunes_;
-    return re->literal_string_.runes_;
-  }
-
-  *nrune = 0;
-  return NULL;
-}
-
-// Removes the first n leading runes from the beginning of re.
-// Edits re in place.
-void Regexp::RemoveLeadingString(Regexp* re, int n) {
-  // Chase down concats to find first string.
-  // For regexps generated by parser, nested concats are
-  // flattened except when doing so would overflow the 16-bit
-  // limit on the size of a concatenation, so we should never
-  // see more than two here.
-  Regexp* stk[4];
-  int d = 0;
-  while (re->op() == kRegexpConcat) {
-    if (d < arraysize(stk))
-      stk[d++] = re;
-    re = re->sub()[0];
-  }
-
-  // Remove leading string from re.
-  if (re->op() == kRegexpLiteral) {
-    re->rune_ = 0;
-    re->op_ = kRegexpEmptyMatch;
-  } else if (re->op() == kRegexpLiteralString) {
-    if (n >= re->literal_string_.nrunes_) {
-      delete[] re->literal_string_.runes_;
-      re->literal_string_.runes_ = NULL;
-      re->literal_string_.nrunes_ = 0;
-      re->op_ = kRegexpEmptyMatch;
-    } else if (n == re->literal_string_.nrunes_ - 1) {
-      Rune rune = re->literal_string_.runes_[re->literal_string_.nrunes_ - 1];
-      delete[] re->literal_string_.runes_;
-      re->literal_string_.runes_ = NULL;
-      re->literal_string_.nrunes_ = 0;
-      re->rune_ = rune;
-      re->op_ = kRegexpLiteral;
-    } else {
-      re->literal_string_.nrunes_ -= n;
-      memmove(re->literal_string_.runes_, re->literal_string_.runes_ + n, re->literal_string_.nrunes_ * sizeof re->literal_string_.runes_[0]);
-    }
-  }
-
-  // If re is now empty, concatenations might simplify too.
-  while (d-- > 0) {
-    re = stk[d];
-    Regexp** sub = re->sub();
-    if (sub[0]->op() == kRegexpEmptyMatch) {
-      sub[0]->Decref();
-      sub[0] = NULL;
-      // Delete first element of concat.
-      switch (re->nsub()) {
-        case 0:
-        case 1:
-          // Impossible.
-          LOG(DFATAL) << "Concat of " << re->nsub();
-          re->submany_ = NULL;
-          re->op_ = kRegexpEmptyMatch;
-          break;
-
-        case 2: {
-          // Replace re with sub[1].
-          Regexp* old = sub[1];
-          sub[1] = NULL;
-          re->Swap(old);
-          old->Decref();
-          break;
-        }
-
-        default:
-          // Slide down.
-          re->nsub_--;
-          memmove(sub, sub + 1, re->nsub_ * sizeof sub[0]);
-          break;
-      }
-    }
-  }
-}
-
-// In the context of factoring alternations, a Splice is: a factored prefix or
-// merged character class computed by one iteration of one round of factoring;
-// the span of subexpressions of the alternation to be "spliced" (i.e. removed
-// and replaced); and, for a factored prefix, the number of suffixes after any
-// factoring that might have subsequently been performed on them. For a merged
-// character class, there are no suffixes, of course, so the field is ignored.
-struct Splice {
-  Splice(Regexp* prefix, Regexp** sub, int nsub)
-      : prefix(prefix),
-        sub(sub),
-        nsub(nsub),
-        nsuffix(-1) {}
-
-  Regexp* prefix;
-  Regexp** sub;
-  int nsub;
-  int nsuffix;
-};
-
-// Named so because it is used to implement an explicit stack, a Frame is: the
-// span of subexpressions of the alternation to be factored; the current round
-// of factoring; any Splices computed; and, for a factored prefix, an iterator
-// to the next Splice to be factored (i.e. in another Frame) because suffixes.
-struct Frame {
-  Frame(Regexp** sub, int nsub)
-      : sub(sub),
-        nsub(nsub),
-        round(0) {}
-
-  Regexp** sub;
-  int nsub;
-  int round;
-  std::vector<Splice> splices;
-  int spliceidx;
-};
-
-// Bundled into a class for friend access to Regexp without needing to declare
-// (or define) Splice in regexp.h.
-class FactorAlternationImpl {
- public:
-  static void Round1(Regexp** sub, int nsub,
-                     Regexp::ParseFlags flags,
-                     std::vector<Splice>* splices);
-  static void Round2(Regexp** sub, int nsub,
-                     Regexp::ParseFlags flags,
-                     std::vector<Splice>* splices);
-  static void Round3(Regexp** sub, int nsub,
-                     Regexp::ParseFlags flags,
-                     std::vector<Splice>* splices);
-};
-
-// Factors common prefixes from alternation.
-// For example,
-//     ABC|ABD|AEF|BCX|BCY
-// simplifies to
-//     A(B(C|D)|EF)|BC(X|Y)
-// and thence to
-//     A(B[CD]|EF)|BC[XY]
-//
-// Rewrites sub to contain simplified list to alternate and returns
-// the new length of sub.  Adjusts reference counts accordingly
-// (incoming sub[i] decremented, outgoing sub[i] incremented).
-int Regexp::FactorAlternation(Regexp** sub, int nsub, ParseFlags flags) {
-  std::vector<Frame> stk;
-  stk.emplace_back(sub, nsub);
-
-  for (;;) {
-    auto& sub = stk.back().sub;
-    auto& nsub = stk.back().nsub;
-    auto& round = stk.back().round;
-    auto& splices = stk.back().splices;
-    auto& spliceidx = stk.back().spliceidx;
-
-    if (splices.empty()) {
-      // Advance to the next round of factoring. Note that this covers
-      // the initialised state: when splices is empty and round is 0.
-      round++;
-    } else if (spliceidx < static_cast<int>(splices.size())) {
-      // We have at least one more Splice to factor. Recurse logically.
-      stk.emplace_back(splices[spliceidx].sub, splices[spliceidx].nsub);
-      continue;
-    } else {
-      // We have no more Splices to factor. Apply them.
-      auto iter = splices.begin();
-      int out = 0;
-      for (int i = 0; i < nsub; ) {
-        // Copy until we reach where the next Splice begins.
-        while (sub + i < iter->sub)
-          sub[out++] = sub[i++];
-        switch (round) {
-          case 1:
-          case 2: {
-            // Assemble the Splice prefix and the suffixes.
-            Regexp* re[2];
-            re[0] = iter->prefix;
-            re[1] = Regexp::AlternateNoFactor(iter->sub, iter->nsuffix, flags);
-            sub[out++] = Regexp::Concat(re, 2, flags);
-            i += iter->nsub;
-            break;
-          }
-          case 3:
-            // Just use the Splice prefix.
-            sub[out++] = iter->prefix;
-            i += iter->nsub;
-            break;
-          default:
-            LOG(DFATAL) << "unknown round: " << round;
-            break;
-        }
-        // If we are done, copy until the end of sub.
-        if (++iter == splices.end()) {
-          while (i < nsub)
-            sub[out++] = sub[i++];
-        }
-      }
-      splices.clear();
-      nsub = out;
-      // Advance to the next round of factoring.
-      round++;
-    }
-
-    switch (round) {
-      case 1:
-        FactorAlternationImpl::Round1(sub, nsub, flags, &splices);
-        break;
-      case 2:
-        FactorAlternationImpl::Round2(sub, nsub, flags, &splices);
-        break;
-      case 3:
-        FactorAlternationImpl::Round3(sub, nsub, flags, &splices);
-        break;
-      case 4:
-        if (stk.size() == 1) {
-          // We are at the top of the stack. Just return.
-          return nsub;
-        } else {
-          // Pop the stack and set the number of suffixes.
-          // (Note that references will be invalidated!)
-          int nsuffix = nsub;
-          stk.pop_back();
-          stk.back().splices[stk.back().spliceidx].nsuffix = nsuffix;
-          ++stk.back().spliceidx;
-          continue;
-        }
-      default:
-        LOG(DFATAL) << "unknown round: " << round;
-        break;
-    }
-
-    // Set spliceidx depending on whether we have Splices to factor.
-    if (splices.empty() || round == 3) {
-      spliceidx = static_cast<int>(splices.size());
-    } else {
-      spliceidx = 0;
-    }
-  }
-}
-
-void FactorAlternationImpl::Round1(Regexp** sub, int nsub,
-                                   Regexp::ParseFlags flags,
-                                   std::vector<Splice>* splices) {
-  // Round 1: Factor out common literal prefixes.
-  int start = 0;
-  Rune* rune = NULL;
-  int nrune = 0;
-  Regexp::ParseFlags runeflags = Regexp::NoParseFlags;
-  for (int i = 0; i <= nsub; i++) {
-    // Invariant: sub[start:i] consists of regexps that all
-    // begin with rune[0:nrune].
-    Rune* rune_i = NULL;
-    int nrune_i = 0;
-    Regexp::ParseFlags runeflags_i = Regexp::NoParseFlags;
-    if (i < nsub) {
-      rune_i = Regexp::LeadingString(sub[i], &nrune_i, &runeflags_i);
-      if (runeflags_i == runeflags) {
-        int same = 0;
-        while (same < nrune && same < nrune_i && rune[same] == rune_i[same])
-          same++;
-        if (same > 0) {
-          // Matches at least one rune in current range.  Keep going around.
-          nrune = same;
-          continue;
-        }
-      }
-    }
-
-    // Found end of a run with common leading literal string:
-    // sub[start:i] all begin with rune[0:nrune],
-    // but sub[i] does not even begin with rune[0].
-    if (i == start) {
-      // Nothing to do - first iteration.
-    } else if (i == start+1) {
-      // Just one: don't bother factoring.
-    } else {
-      Regexp* prefix = Regexp::LiteralString(rune, nrune, runeflags);
-      for (int j = start; j < i; j++)
-        Regexp::RemoveLeadingString(sub[j], nrune);
-      splices->emplace_back(prefix, sub + start, i - start);
-    }
-
-    // Prepare for next iteration (if there is one).
-    if (i < nsub) {
-      start = i;
-      rune = rune_i;
-      nrune = nrune_i;
-      runeflags = runeflags_i;
-    }
-  }
-}
-
-void FactorAlternationImpl::Round2(Regexp** sub, int nsub,
-                                   Regexp::ParseFlags flags,
-                                   std::vector<Splice>* splices) {
-  // Round 2: Factor out common simple prefixes,
-  // just the first piece of each concatenation.
-  // This will be good enough a lot of the time.
-  //
-  // Complex subexpressions (e.g. involving quantifiers)
-  // are not safe to factor because that collapses their
-  // distinct paths through the automaton, which affects
-  // correctness in some cases.
-  int start = 0;
-  Regexp* first = NULL;
-  for (int i = 0; i <= nsub; i++) {
-    // Invariant: sub[start:i] consists of regexps that all
-    // begin with first.
-    Regexp* first_i = NULL;
-    if (i < nsub) {
-      first_i = Regexp::LeadingRegexp(sub[i]);
-      if (first != NULL &&
-          // first must be an empty-width op
-          // OR a char class, any char or any byte
-          // OR a fixed repeat of a literal, char class, any char or any byte.
-          (first->op() == kRegexpBeginLine ||
-           first->op() == kRegexpEndLine ||
-           first->op() == kRegexpWordBoundary ||
-           first->op() == kRegexpNoWordBoundary ||
-           first->op() == kRegexpBeginText ||
-           first->op() == kRegexpEndText ||
-           first->op() == kRegexpCharClass ||
-           first->op() == kRegexpAnyChar ||
-           first->op() == kRegexpAnyByte ||
-           (first->op() == kRegexpRepeat &&
-            first->min() == first->max() &&
-            (first->sub()[0]->op() == kRegexpLiteral ||
-             first->sub()[0]->op() == kRegexpCharClass ||
-             first->sub()[0]->op() == kRegexpAnyChar ||
-             first->sub()[0]->op() == kRegexpAnyByte))) &&
-          Regexp::Equal(first, first_i))
-        continue;
-    }
-
-    // Found end of a run with common leading regexp:
-    // sub[start:i] all begin with first,
-    // but sub[i] does not.
-    if (i == start) {
-      // Nothing to do - first iteration.
-    } else if (i == start+1) {
-      // Just one: don't bother factoring.
-    } else {
-      Regexp* prefix = first->Incref();
-      for (int j = start; j < i; j++)
-        sub[j] = Regexp::RemoveLeadingRegexp(sub[j]);
-      splices->emplace_back(prefix, sub + start, i - start);
-    }
-
-    // Prepare for next iteration (if there is one).
-    if (i < nsub) {
-      start = i;
-      first = first_i;
-    }
-  }
-}
-
-void FactorAlternationImpl::Round3(Regexp** sub, int nsub,
-                                   Regexp::ParseFlags flags,
-                                   std::vector<Splice>* splices) {
-  // Round 3: Merge runs of literals and/or character classes.
-  int start = 0;
-  Regexp* first = NULL;
-  for (int i = 0; i <= nsub; i++) {
-    // Invariant: sub[start:i] consists of regexps that all
-    // are either literals (i.e. runes) or character classes.
-    Regexp* first_i = NULL;
-    if (i < nsub) {
-      first_i = sub[i];
-      if (first != NULL &&
-          (first->op() == kRegexpLiteral ||
-           first->op() == kRegexpCharClass) &&
-          (first_i->op() == kRegexpLiteral ||
-           first_i->op() == kRegexpCharClass))
-        continue;
-    }
-
-    // Found end of a run of Literal/CharClass:
-    // sub[start:i] all are either one or the other,
-    // but sub[i] is not.
-    if (i == start) {
-      // Nothing to do - first iteration.
-    } else if (i == start+1) {
-      // Just one: don't bother factoring.
-    } else {
-      CharClassBuilder ccb;
-      for (int j = start; j < i; j++) {
-        Regexp* re = sub[j];
-        if (re->op() == kRegexpCharClass) {
-          CharClass* cc = re->cc();
-          for (CharClass::iterator it = cc->begin(); it != cc->end(); ++it)
-            ccb.AddRange(it->lo, it->hi);
-        } else if (re->op() == kRegexpLiteral) {
-          ccb.AddRangeFlags(re->rune(), re->rune(), re->parse_flags());
-        } else {
-          LOG(DFATAL) << "RE2: unexpected op: " << re->op() << " "
-                      << re->ToString();
-        }
-        re->Decref();
-      }
-      Regexp* re = Regexp::NewCharClass(ccb.GetCharClass(), flags);
-      splices->emplace_back(re, sub + start, i - start);
-    }
-
-    // Prepare for next iteration (if there is one).
-    if (i < nsub) {
-      start = i;
-      first = first_i;
-    }
-  }
-}
-
-// Collapse the regexps on top of the stack, down to the
-// first marker, into a new op node (op == kRegexpAlternate
-// or op == kRegexpConcat).
-void Regexp::ParseState::DoCollapse(RegexpOp op) {
-  // Scan backward to marker, counting children of composite.
-  int n = 0;
-  Regexp* next = NULL;
-  Regexp* sub;
-  for (sub = stacktop_; sub != NULL && !IsMarker(sub->op()); sub = next) {
-    next = sub->down_;
-    if (sub->op_ == op)
-      n += sub->nsub_;
-    else
-      n++;
-  }
-
-  // If there's just one child, leave it alone.
-  // (Concat of one thing is that one thing; alternate of one thing is same.)
-  if (stacktop_ != NULL && stacktop_->down_ == next)
-    return;
-
-  // Construct op (alternation or concatenation), flattening op of op.
-  PODArray<Regexp*> subs(n);
-  next = NULL;
-  int i = n;
-  for (sub = stacktop_; sub != NULL && !IsMarker(sub->op()); sub = next) {
-    next = sub->down_;
-    if (sub->op_ == op) {
-      Regexp** sub_subs = sub->sub();
-      for (int k = sub->nsub_ - 1; k >= 0; k--)
-        subs[--i] = sub_subs[k]->Incref();
-      sub->Decref();
-    } else {
-      subs[--i] = FinishRegexp(sub);
-    }
-  }
-
-  Regexp* re = ConcatOrAlternate(op, subs.data(), n, flags_, true);
-  re->simple_ = re->ComputeSimple();
-  re->down_ = next;
-  stacktop_ = re;
-}
-
-// Finishes the current concatenation,
-// collapsing it into a single regexp on the stack.
-void Regexp::ParseState::DoConcatenation() {
-  Regexp* r1 = stacktop_;
-  if (r1 == NULL || IsMarker(r1->op())) {
-    // empty concatenation is special case
-    Regexp* re = new Regexp(kRegexpEmptyMatch, flags_);
-    PushRegexp(re);
-  }
-  DoCollapse(kRegexpConcat);
-}
-
-// Finishes the current alternation,
-// collapsing it to a single regexp on the stack.
-void Regexp::ParseState::DoAlternation() {
-  DoVerticalBar();
-  // Now stack top is kVerticalBar.
-  Regexp* r1 = stacktop_;
-  stacktop_ = r1->down_;
-  r1->Decref();
-  DoCollapse(kRegexpAlternate);
-}
-
-// Incremental conversion of concatenated literals into strings.
-// If top two elements on stack are both literal or string,
-// collapse into single string.
-// Don't walk down the stack -- the parser calls this frequently
-// enough that below the bottom two is known to be collapsed.
-// Only called when another regexp is about to be pushed
-// on the stack, so that the topmost literal is not being considered.
-// (Otherwise ab* would turn into (ab)*.)
-// If r >= 0, consider pushing a literal r on the stack.
-// Return whether that happened.
-bool Regexp::ParseState::MaybeConcatString(int r, ParseFlags flags) {
-  Regexp* re1;
-  Regexp* re2;
-  if ((re1 = stacktop_) == NULL || (re2 = re1->down_) == NULL)
-    return false;
-
-  if (re1->op_ != kRegexpLiteral && re1->op_ != kRegexpLiteralString)
-    return false;
-  if (re2->op_ != kRegexpLiteral && re2->op_ != kRegexpLiteralString)
-    return false;
-  if ((re1->parse_flags_ & FoldCase) != (re2->parse_flags_ & FoldCase))
-    return false;
-
-  if (re2->op_ == kRegexpLiteral) {
-    // convert into string
-    Rune rune = re2->rune_;
-    re2->op_ = kRegexpLiteralString;
-    re2->literal_string_.nrunes_ = 0;
-    re2->literal_string_.runes_ = NULL;
-    re2->AddRuneToString(rune);
-  }
-
-  // push re1 into re2.
-  if (re1->op_ == kRegexpLiteral) {
-    re2->AddRuneToString(re1->rune_);
-  } else {
-    for (int i = 0; i < re1->literal_string_.nrunes_; i++)
-      re2->AddRuneToString(re1->literal_string_.runes_[i]);
-    re1->literal_string_.nrunes_ = 0;
-    delete[] re1->literal_string_.runes_;
-    re1->literal_string_.runes_ = NULL;
-  }
-
-  // reuse re1 if possible
-  if (r >= 0) {
-    re1->op_ = kRegexpLiteral;
-    re1->rune_ = r;
-    re1->parse_flags_ = static_cast<uint16_t>(flags);
-    return true;
-  }
-
-  stacktop_ = re2;
-  re1->Decref();
-  return false;
-}
-
-// Lexing routines.
-
-// Parses a decimal integer, storing it in *np.
-// Sets *s to span the remainder of the string.
-static bool ParseInteger(StringPiece* s, int* np) {
-  if (s->size() == 0 || !isdigit((*s)[0] & 0xFF))
-    return false;
-  // Disallow leading zeros.
-  if (s->size() >= 2 && (*s)[0] == '0' && isdigit((*s)[1] & 0xFF))
-    return false;
-  int n = 0;
-  int c;
-  while (s->size() > 0 && isdigit(c = (*s)[0] & 0xFF)) {
-    // Avoid overflow.
-    if (n >= 100000000)
-      return false;
-    n = n*10 + c - '0';
-    s->remove_prefix(1);  // digit
-  }
-  *np = n;
-  return true;
-}
-
-// Parses a repetition suffix like {1,2} or {2} or {2,}.
-// Sets *s to span the remainder of the string on success.
-// Sets *lo and *hi to the given range.
-// In the case of {2,}, the high number is unbounded;
-// sets *hi to -1 to signify this.
-// {,2} is NOT a valid suffix.
-// The Maybe in the name signifies that the regexp parse
-// doesn't fail even if ParseRepetition does, so the StringPiece
-// s must NOT be edited unless MaybeParseRepetition returns true.
-static bool MaybeParseRepetition(StringPiece* sp, int* lo, int* hi) {
-  StringPiece s = *sp;
-  if (s.size() == 0 || s[0] != '{')
-    return false;
-  s.remove_prefix(1);  // '{'
-  if (!ParseInteger(&s, lo))
-    return false;
-  if (s.size() == 0)
-    return false;
-  if (s[0] == ',') {
-    s.remove_prefix(1);  // ','
-    if (s.size() == 0)
-      return false;
-    if (s[0] == '}') {
-      // {2,} means at least 2
-      *hi = -1;
-    } else {
-      // {2,4} means 2, 3, or 4.
-      if (!ParseInteger(&s, hi))
-        return false;
-    }
-  } else {
-    // {2} means exactly two
-    *hi = *lo;
-  }
-  if (s.size() == 0 || s[0] != '}')
-    return false;
-  s.remove_prefix(1);  // '}'
-  *sp = s;
-  return true;
-}
-
-// Removes the next Rune from the StringPiece and stores it in *r.
-// Returns number of bytes removed from sp.
-// Behaves as though there is a terminating NUL at the end of sp.
-// Argument order is backwards from usual Google style
-// but consistent with chartorune.
-static int StringPieceToRune(Rune *r, StringPiece *sp, RegexpStatus* status) {
-  // fullrune() takes int, not size_t. However, it just looks
-  // at the leading byte and treats any length >= 4 the same.
-  if (fullrune(sp->data(), static_cast<int>(std::min(size_t{4}, sp->size())))) {
-    int n = chartorune(r, sp->data());
-    // Some copies of chartorune have a bug that accepts
-    // encodings of values in (10FFFF, 1FFFFF] as valid.
-    // Those values break the character class algorithm,
-    // which assumes Runemax is the largest rune.
-    if (*r > Runemax) {
-      n = 1;
-      *r = Runeerror;
-    }
-    if (!(n == 1 && *r == Runeerror)) {  // no decoding error
-      sp->remove_prefix(n);
-      return n;
-    }
-  }
-
-  status->set_code(kRegexpBadUTF8);
-  status->set_error_arg(StringPiece());
-  return -1;
-}
-
-// Return whether name is valid UTF-8.
-// If not, set status to kRegexpBadUTF8.
-static bool IsValidUTF8(const StringPiece& s, RegexpStatus* status) {
-  StringPiece t = s;
-  Rune r;
-  while (t.size() > 0) {
-    if (StringPieceToRune(&r, &t, status) < 0)
-      return false;
-  }
-  return true;
-}
-
-// Is c a hex digit?
-static int IsHex(int c) {
-  return ('0' <= c && c <= '9') ||
-         ('A' <= c && c <= 'F') ||
-         ('a' <= c && c <= 'f');
-}
-
-// Convert hex digit to value.
-static int UnHex(int c) {
-  if ('0' <= c && c <= '9')
-    return c - '0';
-  if ('A' <= c && c <= 'F')
-    return c - 'A' + 10;
-  if ('a' <= c && c <= 'f')
-    return c - 'a' + 10;
-  LOG(DFATAL) << "Bad hex digit " << c;
-  return 0;
-}
-
-// Parse an escape sequence (e.g., \n, \{).
-// Sets *s to span the remainder of the string.
-// Sets *rp to the named character.
-static bool ParseEscape(StringPiece* s, Rune* rp,
-                        RegexpStatus* status, int rune_max) {
-  const char* begin = s->begin();
-  if (s->size() < 1 || (*s)[0] != '\\') {
-    // Should not happen - caller always checks.
-    status->set_code(kRegexpInternalError);
-    status->set_error_arg(StringPiece());
-    return false;
-  }
-  if (s->size() < 2) {
-    status->set_code(kRegexpTrailingBackslash);
-    status->set_error_arg(StringPiece());
-    return false;
-  }
-  Rune c, c1;
-  s->remove_prefix(1);  // backslash
-  if (StringPieceToRune(&c, s, status) < 0)
-    return false;
-  int code;
-  switch (c) {
-    default:
-      if (c < Runeself && !isalpha(c) && !isdigit(c)) {
-        // Escaped non-word characters are always themselves.
-        // PCRE is not quite so rigorous: it accepts things like
-        // \q, but we don't.  We once rejected \_, but too many
-        // programs and people insist on using it, so allow \_.
-        *rp = c;
-        return true;
-      }
-      goto BadEscape;
-
-    // Octal escapes.
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-      // Single non-zero octal digit is a backreference; not supported.
-      if (s->size() == 0 || (*s)[0] < '0' || (*s)[0] > '7')
-        goto BadEscape;
-      FALLTHROUGH_INTENDED;
-    case '0':
-      // consume up to three octal digits; already have one.
-      code = c - '0';
-      if (s->size() > 0 && '0' <= (c = (*s)[0]) && c <= '7') {
-        code = code * 8 + c - '0';
-        s->remove_prefix(1);  // digit
-        if (s->size() > 0) {
-          c = (*s)[0];
-          if ('0' <= c && c <= '7') {
-            code = code * 8 + c - '0';
-            s->remove_prefix(1);  // digit
-          }
-        }
-      }
-      if (code > rune_max)
-        goto BadEscape;
-      *rp = code;
-      return true;
-
-    // Hexadecimal escapes
-    case 'x':
-      if (s->size() == 0)
-        goto BadEscape;
-      if (StringPieceToRune(&c, s, status) < 0)
-        return false;
-      if (c == '{') {
-        // Any number of digits in braces.
-        // Update n as we consume the string, so that
-        // the whole thing gets shown in the error message.
-        // Perl accepts any text at all; it ignores all text
-        // after the first non-hex digit.  We require only hex digits,
-        // and at least one.
-        if (StringPieceToRune(&c, s, status) < 0)
-          return false;
-        int nhex = 0;
-        code = 0;
-        while (IsHex(c)) {
-          nhex++;
-          code = code * 16 + UnHex(c);
-          if (code > rune_max)
-            goto BadEscape;
-          if (s->size() == 0)
-            goto BadEscape;
-          if (StringPieceToRune(&c, s, status) < 0)
-            return false;
-        }
-        if (c != '}' || nhex == 0)
-          goto BadEscape;
-        *rp = code;
-        return true;
-      }
-      // Easy case: two hex digits.
-      if (s->size() == 0)
-        goto BadEscape;
-      if (StringPieceToRune(&c1, s, status) < 0)
-        return false;
-      if (!IsHex(c) || !IsHex(c1))
-        goto BadEscape;
-      *rp = UnHex(c) * 16 + UnHex(c1);
-      return true;
-
-    // C escapes.
-    case 'n':
-      *rp = '\n';
-      return true;
-    case 'r':
-      *rp = '\r';
-      return true;
-    case 't':
-      *rp = '\t';
-      return true;
-
-    // Less common C escapes.
-    case 'a':
-      *rp = '\a';
-      return true;
-    case 'f':
-      *rp = '\f';
-      return true;
-    case 'v':
-      *rp = '\v';
-      return true;
-
-    // This code is disabled to avoid misparsing
-    // the Perl word-boundary \b as a backspace
-    // when in POSIX regexp mode.  Surprisingly,
-    // in Perl, \b means word-boundary but [\b]
-    // means backspace.  We don't support that:
-    // if you want a backspace embed a literal
-    // backspace character or use \x08.
-    //
-    // case 'b':
-    //   *rp = '\b';
-    //   return true;
-  }
-
-  LOG(DFATAL) << "Not reached in ParseEscape.";
-
-BadEscape:
-  // Unrecognized escape sequence.
-  status->set_code(kRegexpBadEscape);
-  status->set_error_arg(
-      StringPiece(begin, static_cast<size_t>(s->begin() - begin)));
-  return false;
-}
-
-// Add a range to the character class, but exclude newline if asked.
-// Also handle case folding.
-void CharClassBuilder::AddRangeFlags(
-    Rune lo, Rune hi, Regexp::ParseFlags parse_flags) {
-
-  // Take out \n if the flags say so.
-  bool cutnl = !(parse_flags & Regexp::ClassNL) ||
-               (parse_flags & Regexp::NeverNL);
-  if (cutnl && lo <= '\n' && '\n' <= hi) {
-    if (lo < '\n')
-      AddRangeFlags(lo, '\n' - 1, parse_flags);
-    if (hi > '\n')
-      AddRangeFlags('\n' + 1, hi, parse_flags);
-    return;
-  }
-
-  // If folding case, add fold-equivalent characters too.
-  if (parse_flags & Regexp::FoldCase)
-    AddFoldedRange(this, lo, hi, 0);
-  else
-    AddRange(lo, hi);
-}
-
-// Look for a group with the given name.
-static const UGroup* LookupGroup(const StringPiece& name,
-                                 const UGroup *groups, int ngroups) {
-  // Simple name lookup.
-  for (int i = 0; i < ngroups; i++)
-    if (StringPiece(groups[i].name) == name)
-      return &groups[i];
-  return NULL;
-}
-
-// Look for a POSIX group with the given name (e.g., "[:^alpha:]")
-static const UGroup* LookupPosixGroup(const StringPiece& name) {
-  return LookupGroup(name, posix_groups, num_posix_groups);
-}
-
-static const UGroup* LookupPerlGroup(const StringPiece& name) {
-  return LookupGroup(name, perl_groups, num_perl_groups);
-}
-
-#if !defined(RE2_USE_ICU)
-// Fake UGroup containing all Runes
-static URange16 any16[] = { { 0, 65535 } };
-static URange32 any32[] = { { 65536, Runemax } };
-static UGroup anygroup = { "Any", +1, any16, 1, any32, 1 };
-
-// Look for a Unicode group with the given name (e.g., "Han")
-static const UGroup* LookupUnicodeGroup(const StringPiece& name) {
-  // Special case: "Any" means any.
-  if (name == StringPiece("Any"))
-    return &anygroup;
-  return LookupGroup(name, unicode_groups, num_unicode_groups);
-}
-#endif
-
-// Add a UGroup or its negation to the character class.
-static void AddUGroup(CharClassBuilder *cc, const UGroup *g, int sign,
-                      Regexp::ParseFlags parse_flags) {
-  if (sign == +1) {
-    for (int i = 0; i < g->nr16; i++) {
-      cc->AddRangeFlags(g->r16[i].lo, g->r16[i].hi, parse_flags);
-    }
-    for (int i = 0; i < g->nr32; i++) {
-      cc->AddRangeFlags(g->r32[i].lo, g->r32[i].hi, parse_flags);
-    }
-  } else {
-    if (parse_flags & Regexp::FoldCase) {
-      // Normally adding a case-folded group means
-      // adding all the extra fold-equivalent runes too.
-      // But if we're adding the negation of the group,
-      // we have to exclude all the runes that are fold-equivalent
-      // to what's already missing.  Too hard, so do in two steps.
-      CharClassBuilder ccb1;
-      AddUGroup(&ccb1, g, +1, parse_flags);
-      // If the flags say to take out \n, put it in, so that negating will take it out.
-      // Normally AddRangeFlags does this, but we're bypassing AddRangeFlags.
-      bool cutnl = !(parse_flags & Regexp::ClassNL) ||
-                   (parse_flags & Regexp::NeverNL);
-      if (cutnl) {
-        ccb1.AddRange('\n', '\n');
-      }
-      ccb1.Negate();
-      cc->AddCharClass(&ccb1);
-      return;
-    }
-    int next = 0;
-    for (int i = 0; i < g->nr16; i++) {
-      if (next < g->r16[i].lo)
-        cc->AddRangeFlags(next, g->r16[i].lo - 1, parse_flags);
-      next = g->r16[i].hi + 1;
-    }
-    for (int i = 0; i < g->nr32; i++) {
-      if (next < g->r32[i].lo)
-        cc->AddRangeFlags(next, g->r32[i].lo - 1, parse_flags);
-      next = g->r32[i].hi + 1;
-    }
-    if (next <= Runemax)
-      cc->AddRangeFlags(next, Runemax, parse_flags);
-  }
-}
-
-// Maybe parse a Perl character class escape sequence.
-// Only recognizes the Perl character classes (\d \s \w \D \S \W),
-// not the Perl empty-string classes (\b \B \A \Z \z).
-// On success, sets *s to span the remainder of the string
-// and returns the corresponding UGroup.
-// The StringPiece must *NOT* be edited unless the call succeeds.
-const UGroup* MaybeParsePerlCCEscape(StringPiece* s, Regexp::ParseFlags parse_flags) {
-  if (!(parse_flags & Regexp::PerlClasses))
-    return NULL;
-  if (s->size() < 2 || (*s)[0] != '\\')
-    return NULL;
-  // Could use StringPieceToRune, but there aren't
-  // any non-ASCII Perl group names.
-  StringPiece name(s->begin(), 2);
-  const UGroup *g = LookupPerlGroup(name);
-  if (g == NULL)
-    return NULL;
-  s->remove_prefix(name.size());
-  return g;
-}
-
-enum ParseStatus {
-  kParseOk,  // Did some parsing.
-  kParseError,  // Found an error.
-  kParseNothing,  // Decided not to parse.
-};
-
-// Maybe parses a Unicode character group like \p{Han} or \P{Han}
-// (the latter is a negated group).
-ParseStatus ParseUnicodeGroup(StringPiece* s, Regexp::ParseFlags parse_flags,
-                              CharClassBuilder *cc,
-                              RegexpStatus* status) {
-  // Decide whether to parse.
-  if (!(parse_flags & Regexp::UnicodeGroups))
-    return kParseNothing;
-  if (s->size() < 2 || (*s)[0] != '\\')
-    return kParseNothing;
-  Rune c = (*s)[1];
-  if (c != 'p' && c != 'P')
-    return kParseNothing;
-
-  // Committed to parse.  Results:
-  int sign = +1;  // -1 = negated char class
-  if (c == 'P')
-    sign = -sign;
-  StringPiece seq = *s;  // \p{Han} or \pL
-  StringPiece name;  // Han or L
-  s->remove_prefix(2);  // '\\', 'p'
-
-  if (!StringPieceToRune(&c, s, status))
-    return kParseError;
-  if (c != '{') {
-    // Name is the bit of string we just skipped over for c.
-    const char* p = seq.begin() + 2;
-    name = StringPiece(p, static_cast<size_t>(s->begin() - p));
-  } else {
-    // Name is in braces. Look for closing }
-    size_t end = s->find('}', 0);
-    if (end == StringPiece::npos) {
-      if (!IsValidUTF8(seq, status))
-        return kParseError;
-      status->set_code(kRegexpBadCharRange);
-      status->set_error_arg(seq);
-      return kParseError;
-    }
-    name = StringPiece(s->begin(), end);  // without '}'
-    s->remove_prefix(end + 1);  // with '}'
-    if (!IsValidUTF8(name, status))
-      return kParseError;
-  }
-
-  // Chop seq where s now begins.
-  seq = StringPiece(seq.begin(), static_cast<size_t>(s->begin() - seq.begin()));
-
-  if (name.size() > 0 && name[0] == '^') {
-    sign = -sign;
-    name.remove_prefix(1);  // '^'
-  }
-
-#if !defined(RE2_USE_ICU)
-  // Look up the group in the RE2 Unicode data.
-  const UGroup *g = LookupUnicodeGroup(name);
-  if (g == NULL) {
-    status->set_code(kRegexpBadCharRange);
-    status->set_error_arg(seq);
-    return kParseError;
-  }
-
-  AddUGroup(cc, g, sign, parse_flags);
-#else
-  // Look up the group in the ICU Unicode data. Because ICU provides full
-  // Unicode properties support, this could be more than a lookup by name.
-  ::icu::UnicodeString ustr = ::icu::UnicodeString::fromUTF8(
-      std::string("\\p{") + std::string(name) + std::string("}"));
-  UErrorCode uerr = U_ZERO_ERROR;
-  ::icu::UnicodeSet uset(ustr, uerr);
-  if (U_FAILURE(uerr)) {
-    status->set_code(kRegexpBadCharRange);
-    status->set_error_arg(seq);
-    return kParseError;
-  }
-
-  // Convert the UnicodeSet to a URange32 and UGroup that we can add.
-  int nr = uset.getRangeCount();
-  URange32* r = new URange32[nr];
-  for (int i = 0; i < nr; i++) {
-    r[i].lo = uset.getRangeStart(i);
-    r[i].hi = uset.getRangeEnd(i);
-  }
-  UGroup g = {"", +1, 0, 0, r, nr};
-  AddUGroup(cc, &g, sign, parse_flags);
-  delete[] r;
-#endif
-
-  return kParseOk;
-}
-
-// Parses a character class name like [:alnum:].
-// Sets *s to span the remainder of the string.
-// Adds the ranges corresponding to the class to ranges.
-static ParseStatus ParseCCName(StringPiece* s, Regexp::ParseFlags parse_flags,
-                               CharClassBuilder *cc,
-                               RegexpStatus* status) {
-  // Check begins with [:
-  const char* p = s->data();
-  const char* ep = s->data() + s->size();
-  if (ep - p < 2 || p[0] != '[' || p[1] != ':')
-    return kParseNothing;
-
-  // Look for closing :].
-  const char* q;
-  for (q = p+2; q <= ep-2 && (*q != ':' || *(q+1) != ']'); q++)
-    ;
-
-  // If no closing :], then ignore.
-  if (q > ep-2)
-    return kParseNothing;
-
-  // Got it.  Check that it's valid.
-  q += 2;
-  StringPiece name(p, static_cast<size_t>(q - p));
-
-  const UGroup *g = LookupPosixGroup(name);
-  if (g == NULL) {
-    status->set_code(kRegexpBadCharRange);
-    status->set_error_arg(name);
-    return kParseError;
-  }
-
-  s->remove_prefix(name.size());
-  AddUGroup(cc, g, g->sign, parse_flags);
-  return kParseOk;
-}
-
-// Parses a character inside a character class.
-// There are fewer special characters here than in the rest of the regexp.
-// Sets *s to span the remainder of the string.
-// Sets *rp to the character.
-bool Regexp::ParseState::ParseCCCharacter(StringPiece* s, Rune *rp,
-                                          const StringPiece& whole_class,
-                                          RegexpStatus* status) {
-  if (s->size() == 0) {
-    status->set_code(kRegexpMissingBracket);
-    status->set_error_arg(whole_class);
-    return false;
-  }
-
-  // Allow regular escape sequences even though
-  // many need not be escaped in this context.
-  if (s->size() >= 1 && (*s)[0] == '\\')
-    return ParseEscape(s, rp, status, rune_max_);
-
-  // Otherwise take the next rune.
-  return StringPieceToRune(rp, s, status) >= 0;
-}
-
-// Parses a character class character, or, if the character
-// is followed by a hyphen, parses a character class range.
-// For single characters, rr->lo == rr->hi.
-// Sets *s to span the remainder of the string.
-// Sets *rp to the character.
-bool Regexp::ParseState::ParseCCRange(StringPiece* s, RuneRange* rr,
-                                      const StringPiece& whole_class,
-                                      RegexpStatus* status) {
-  StringPiece os = *s;
-  if (!ParseCCCharacter(s, &rr->lo, whole_class, status))
-    return false;
-  // [a-] means (a|-), so check for final ].
-  if (s->size() >= 2 && (*s)[0] == '-' && (*s)[1] != ']') {
-    s->remove_prefix(1);  // '-'
-    if (!ParseCCCharacter(s, &rr->hi, whole_class, status))
-      return false;
-    if (rr->hi < rr->lo) {
-      status->set_code(kRegexpBadCharRange);
-      status->set_error_arg(
-          StringPiece(os.data(), static_cast<size_t>(s->data() - os.data())));
-      return false;
-    }
-  } else {
-    rr->hi = rr->lo;
-  }
-  return true;
-}
-
-// Parses a possibly-negated character class expression like [^abx-z[:digit:]].
-// Sets *s to span the remainder of the string.
-// Sets *out_re to the regexp for the class.
-bool Regexp::ParseState::ParseCharClass(StringPiece* s,
-                                        Regexp** out_re,
-                                        RegexpStatus* status) {
-  StringPiece whole_class = *s;
-  if (s->size() == 0 || (*s)[0] != '[') {
-    // Caller checked this.
-    status->set_code(kRegexpInternalError);
-    status->set_error_arg(StringPiece());
-    return false;
-  }
-  bool negated = false;
-  Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
-  re->char_class_.ccb_ = new CharClassBuilder;
-  s->remove_prefix(1);  // '['
-  if (s->size() > 0 && (*s)[0] == '^') {
-    s->remove_prefix(1);  // '^'
-    negated = true;
-    if (!(flags_ & ClassNL) || (flags_ & NeverNL)) {
-      // If NL can't match implicitly, then pretend
-      // negated classes include a leading \n.
-      re->char_class_.ccb_->AddRange('\n', '\n');
-    }
-  }
-  bool first = true;  // ] is okay as first char in class
-  while (s->size() > 0 && ((*s)[0] != ']' || first)) {
-    // - is only okay unescaped as first or last in class.
-    // Except that Perl allows - anywhere.
-    if ((*s)[0] == '-' && !first && !(flags_&PerlX) &&
-        (s->size() == 1 || (*s)[1] != ']')) {
-      StringPiece t = *s;
-      t.remove_prefix(1);  // '-'
-      Rune r;
-      int n = StringPieceToRune(&r, &t, status);
-      if (n < 0) {
-        re->Decref();
-        return false;
-      }
-      status->set_code(kRegexpBadCharRange);
-      status->set_error_arg(StringPiece(s->data(), 1+n));
-      re->Decref();
-      return false;
-    }
-    first = false;
-
-    // Look for [:alnum:] etc.
-    if (s->size() > 2 && (*s)[0] == '[' && (*s)[1] == ':') {
-      switch (ParseCCName(s, flags_, re->char_class_.ccb_, status)) {
-        case kParseOk:
-          continue;
-        case kParseError:
-          re->Decref();
-          return false;
-        case kParseNothing:
-          break;
-      }
-    }
-
-    // Look for Unicode character group like \p{Han}
-    if (s->size() > 2 &&
-        (*s)[0] == '\\' &&
-        ((*s)[1] == 'p' || (*s)[1] == 'P')) {
-      switch (ParseUnicodeGroup(s, flags_, re->char_class_.ccb_, status)) {
-        case kParseOk:
-          continue;
-        case kParseError:
-          re->Decref();
-          return false;
-        case kParseNothing:
-          break;
-      }
-    }
-
-    // Look for Perl character class symbols (extension).
-    const UGroup *g = MaybeParsePerlCCEscape(s, flags_);
-    if (g != NULL) {
-      AddUGroup(re->char_class_.ccb_, g, g->sign, flags_);
-      continue;
-    }
-
-    // Otherwise assume single character or simple range.
-    RuneRange rr;
-    if (!ParseCCRange(s, &rr, whole_class, status)) {
-      re->Decref();
-      return false;
-    }
-    // AddRangeFlags is usually called in response to a class like
-    // \p{Foo} or [[:foo:]]; for those, it filters \n out unless
-    // Regexp::ClassNL is set.  In an explicit range or singleton
-    // like we just parsed, we do not filter \n out, so set ClassNL
-    // in the flags.
-    re->char_class_.ccb_->AddRangeFlags(rr.lo, rr.hi, flags_ | Regexp::ClassNL);
-  }
-  if (s->size() == 0) {
-    status->set_code(kRegexpMissingBracket);
-    status->set_error_arg(whole_class);
-    re->Decref();
-    return false;
-  }
-  s->remove_prefix(1);  // ']'
-
-  if (negated)
-    re->char_class_.ccb_->Negate();
-
-  *out_re = re;
-  return true;
-}
-
-// Is this a valid capture name?  [A-Za-z0-9_]+
-// PCRE limits names to 32 bytes.
-// Python rejects names starting with digits.
-// We don't enforce either of those.
-static bool IsValidCaptureName(const StringPiece& name) {
-  if (name.size() == 0)
-    return false;
-  for (size_t i = 0; i < name.size(); i++) {
-    int c = name[i];
-    if (('0' <= c && c <= '9') ||
-        ('a' <= c && c <= 'z') ||
-        ('A' <= c && c <= 'Z') ||
-        c == '_')
-      continue;
-    return false;
-  }
-  return true;
-}
-
-// Parses a Perl flag setting or non-capturing group or both,
-// like (?i) or (?: or (?i:.  Removes from s, updates parse state.
-// The caller must check that s begins with "(?".
-// Returns true on success.  If the Perl flag is not
-// well-formed or not supported, sets status_ and returns false.
-bool Regexp::ParseState::ParsePerlFlags(StringPiece* s) {
-  StringPiece t = *s;
-
-  // Caller is supposed to check this.
-  if (!(flags_ & PerlX) || t.size() < 2 || t[0] != '(' || t[1] != '?') {
-    LOG(DFATAL) << "Bad call to ParseState::ParsePerlFlags";
-    status_->set_code(kRegexpInternalError);
-    return false;
-  }
-
-  t.remove_prefix(2);  // "(?"
-
-  // Check for named captures, first introduced in Python's regexp library.
-  // As usual, there are three slightly different syntaxes:
-  //
-  //   (?P<name>expr)   the original, introduced by Python
-  //   (?<name>expr)    the .NET alteration, adopted by Perl 5.10
-  //   (?'name'expr)    another .NET alteration, adopted by Perl 5.10
-  //
-  // Perl 5.10 gave in and implemented the Python version too,
-  // but they claim that the last two are the preferred forms.
-  // PCRE and languages based on it (specifically, PHP and Ruby)
-  // support all three as well.  EcmaScript 4 uses only the Python form.
-  //
-  // In both the open source world (via Code Search) and the
-  // Google source tree, (?P<expr>name) is the dominant form,
-  // so that's the one we implement.  One is enough.
-  if (t.size() > 2 && t[0] == 'P' && t[1] == '<') {
-    // Pull out name.
-    size_t end = t.find('>', 2);
-    if (end == StringPiece::npos) {
-      if (!IsValidUTF8(*s, status_))
-        return false;
-      status_->set_code(kRegexpBadNamedCapture);
-      status_->set_error_arg(*s);
-      return false;
-    }
-
-    // t is "P<name>...", t[end] == '>'
-    StringPiece capture(t.begin()-2, end+3);  // "(?P<name>"
-    StringPiece name(t.begin()+2, end-2);     // "name"
-    if (!IsValidUTF8(name, status_))
-      return false;
-    if (!IsValidCaptureName(name)) {
-      status_->set_code(kRegexpBadNamedCapture);
-      status_->set_error_arg(capture);
-      return false;
-    }
-
-    if (!DoLeftParen(name)) {
-      // DoLeftParen's failure set status_.
-      return false;
-    }
-
-    s->remove_prefix(static_cast<size_t>(capture.end() - s->begin()));
-    return true;
-  }
-
-  bool negated = false;
-  bool sawflags = false;
-  int nflags = flags_;
-  Rune c;
-  for (bool done = false; !done; ) {
-    if (t.size() == 0)
-      goto BadPerlOp;
-    if (StringPieceToRune(&c, &t, status_) < 0)
-      return false;
-    switch (c) {
-      default:
-        goto BadPerlOp;
-
-      // Parse flags.
-      case 'i':
-        sawflags = true;
-        if (negated)
-          nflags &= ~FoldCase;
-        else
-          nflags |= FoldCase;
-        break;
-
-      case 'm':  // opposite of our OneLine
-        sawflags = true;
-        if (negated)
-          nflags |= OneLine;
-        else
-          nflags &= ~OneLine;
-        break;
-
-      case 's':
-        sawflags = true;
-        if (negated)
-          nflags &= ~DotNL;
-        else
-          nflags |= DotNL;
-        break;
-
-      case 'U':
-        sawflags = true;
-        if (negated)
-          nflags &= ~NonGreedy;
-        else
-          nflags |= NonGreedy;
-        break;
-
-      // Negation
-      case '-':
-        if (negated)
-          goto BadPerlOp;
-        negated = true;
-        sawflags = false;
-        break;
-
-      // Open new group.
-      case ':':
-        if (!DoLeftParenNoCapture()) {
-          // DoLeftParenNoCapture's failure set status_.
-          return false;
-        }
-        done = true;
-        break;
-
-      // Finish flags.
-      case ')':
-        done = true;
-        break;
-    }
-  }
-
-  if (negated && !sawflags)
-    goto BadPerlOp;
-
-  flags_ = static_cast<Regexp::ParseFlags>(nflags);
-  *s = t;
-  return true;
-
-BadPerlOp:
-  status_->set_code(kRegexpBadPerlOp);
-  status_->set_error_arg(
-      StringPiece(s->begin(), static_cast<size_t>(t.begin() - s->begin())));
-  return false;
-}
-
-// Converts latin1 (assumed to be encoded as Latin1 bytes)
-// into UTF8 encoding in string.
-// Can't use EncodingUtils::EncodeLatin1AsUTF8 because it is
-// deprecated and because it rejects code points 0x80-0x9F.
-void ConvertLatin1ToUTF8(const StringPiece& latin1, std::string* utf) {
-  char buf[UTFmax];
-
-  utf->clear();
-  for (size_t i = 0; i < latin1.size(); i++) {
-    Rune r = latin1[i] & 0xFF;
-    int n = runetochar(buf, &r);
-    utf->append(buf, n);
-  }
-}
-
-// Parses the regular expression given by s,
-// returning the corresponding Regexp tree.
-// The caller must Decref the return value when done with it.
-// Returns NULL on error.
-Regexp* Regexp::Parse(const StringPiece& s, ParseFlags global_flags,
-                      RegexpStatus* status) {
-  // Make status non-NULL (easier on everyone else).
-  RegexpStatus xstatus;
-  if (status == NULL)
-    status = &xstatus;
-
-  ParseState ps(global_flags, s, status);
-  StringPiece t = s;
-
-  // Convert regexp to UTF-8 (easier on the rest of the parser).
-  if (global_flags & Latin1) {
-    std::string* tmp = new std::string;
-    ConvertLatin1ToUTF8(t, tmp);
-    status->set_tmp(tmp);
-    t = *tmp;
-  }
-
-  if (global_flags & Literal) {
-    // Special parse loop for literal string.
-    while (t.size() > 0) {
-      Rune r;
-      if (StringPieceToRune(&r, &t, status) < 0)
-        return NULL;
-      if (!ps.PushLiteral(r))
-        return NULL;
-    }
-    return ps.DoFinish();
-  }
-
-  StringPiece lastunary = StringPiece();
-  while (t.size() > 0) {
-    StringPiece isunary = StringPiece();
-    switch (t[0]) {
-      default: {
-        Rune r;
-        if (StringPieceToRune(&r, &t, status) < 0)
-          return NULL;
-        if (!ps.PushLiteral(r))
-          return NULL;
-        break;
-      }
-
-      case '(':
-        // "(?" introduces Perl escape.
-        if ((ps.flags() & PerlX) && (t.size() >= 2 && t[1] == '?')) {
-          // Flag changes and non-capturing groups.
-          if (!ps.ParsePerlFlags(&t))
-            return NULL;
-          break;
-        }
-        if (ps.flags() & NeverCapture) {
-          if (!ps.DoLeftParenNoCapture())
-            return NULL;
-        } else {
-          if (!ps.DoLeftParen(StringPiece()))
-            return NULL;
-        }
-        t.remove_prefix(1);  // '('
-        break;
-
-      case '|':
-        if (!ps.DoVerticalBar())
-          return NULL;
-        t.remove_prefix(1);  // '|'
-        break;
-
-      case ')':
-        if (!ps.DoRightParen())
-          return NULL;
-        t.remove_prefix(1);  // ')'
-        break;
-
-      case '^':  // Beginning of line.
-        if (!ps.PushCarat())
-          return NULL;
-        t.remove_prefix(1);  // '^'
-        break;
-
-      case '$':  // End of line.
-        if (!ps.PushDollar())
-          return NULL;
-        t.remove_prefix(1);  // '$'
-        break;
-
-      case '.':  // Any character (possibly except newline).
-        if (!ps.PushDot())
-          return NULL;
-        t.remove_prefix(1);  // '.'
-        break;
-
-      case '[': {  // Character class.
-        Regexp* re;
-        if (!ps.ParseCharClass(&t, &re, status))
-          return NULL;
-        if (!ps.PushRegexp(re))
-          return NULL;
-        break;
-      }
-
-      case '*': {  // Zero or more.
-        RegexpOp op;
-        op = kRegexpStar;
-        goto Rep;
-      case '+':  // One or more.
-        op = kRegexpPlus;
-        goto Rep;
-      case '?':  // Zero or one.
-        op = kRegexpQuest;
-        goto Rep;
-      Rep:
-        StringPiece opstr = t;
-        bool nongreedy = false;
-        t.remove_prefix(1);  // '*' or '+' or '?'
-        if (ps.flags() & PerlX) {
-          if (t.size() > 0 && t[0] == '?') {
-            nongreedy = true;
-            t.remove_prefix(1);  // '?'
-          }
-          if (lastunary.size() > 0) {
-            // In Perl it is not allowed to stack repetition operators:
-            //   a** is a syntax error, not a double-star.
-            // (and a++ means something else entirely, which we don't support!)
-            status->set_code(kRegexpRepeatOp);
-            status->set_error_arg(StringPiece(
-                lastunary.begin(),
-                static_cast<size_t>(t.begin() - lastunary.begin())));
-            return NULL;
-          }
-        }
-        opstr = StringPiece(opstr.data(),
-                            static_cast<size_t>(t.data() - opstr.data()));
-        if (!ps.PushRepeatOp(op, opstr, nongreedy))
-          return NULL;
-        isunary = opstr;
-        break;
-      }
-
-      case '{': {  // Counted repetition.
-        int lo, hi;
-        StringPiece opstr = t;
-        if (!MaybeParseRepetition(&t, &lo, &hi)) {
-          // Treat like a literal.
-          if (!ps.PushLiteral('{'))
-            return NULL;
-          t.remove_prefix(1);  // '{'
-          break;
-        }
-        bool nongreedy = false;
-        if (ps.flags() & PerlX) {
-          if (t.size() > 0 && t[0] == '?') {
-            nongreedy = true;
-            t.remove_prefix(1);  // '?'
-          }
-          if (lastunary.size() > 0) {
-            // Not allowed to stack repetition operators.
-            status->set_code(kRegexpRepeatOp);
-            status->set_error_arg(StringPiece(
-                lastunary.begin(),
-                static_cast<size_t>(t.begin() - lastunary.begin())));
-            return NULL;
-          }
-        }
-        opstr = StringPiece(opstr.data(),
-                            static_cast<size_t>(t.data() - opstr.data()));
-        if (!ps.PushRepetition(lo, hi, opstr, nongreedy))
-          return NULL;
-        isunary = opstr;
-        break;
-      }
-
-      case '\\': {  // Escaped character or Perl sequence.
-        // \b and \B: word boundary or not
-        if ((ps.flags() & Regexp::PerlB) &&
-            t.size() >= 2 && (t[1] == 'b' || t[1] == 'B')) {
-          if (!ps.PushWordBoundary(t[1] == 'b'))
-            return NULL;
-          t.remove_prefix(2);  // '\\', 'b'
-          break;
-        }
-
-        if ((ps.flags() & Regexp::PerlX) && t.size() >= 2) {
-          if (t[1] == 'A') {
-            if (!ps.PushSimpleOp(kRegexpBeginText))
-              return NULL;
-            t.remove_prefix(2);  // '\\', 'A'
-            break;
-          }
-          if (t[1] == 'z') {
-            if (!ps.PushSimpleOp(kRegexpEndText))
-              return NULL;
-            t.remove_prefix(2);  // '\\', 'z'
-            break;
-          }
-          // Do not recognize \Z, because this library can't
-          // implement the exact Perl/PCRE semantics.
-          // (This library treats "(?-m)$" as \z, even though
-          // in Perl and PCRE it is equivalent to \Z.)
-
-          if (t[1] == 'C') {  // \C: any byte [sic]
-            if (!ps.PushSimpleOp(kRegexpAnyByte))
-              return NULL;
-            t.remove_prefix(2);  // '\\', 'C'
-            break;
-          }
-
-          if (t[1] == 'Q') {  // \Q ... \E: the ... is always literals
-            t.remove_prefix(2);  // '\\', 'Q'
-            while (t.size() > 0) {
-              if (t.size() >= 2 && t[0] == '\\' && t[1] == 'E') {
-                t.remove_prefix(2);  // '\\', 'E'
-                break;
-              }
-              Rune r;
-              if (StringPieceToRune(&r, &t, status) < 0)
-                return NULL;
-              if (!ps.PushLiteral(r))
-                return NULL;
-            }
-            break;
-          }
-        }
-
-        if (t.size() >= 2 && (t[1] == 'p' || t[1] == 'P')) {
-          Regexp* re = new Regexp(kRegexpCharClass, ps.flags() & ~FoldCase);
-          re->char_class_.ccb_ = new CharClassBuilder;
-          switch (ParseUnicodeGroup(&t, ps.flags(), re->char_class_.ccb_, status)) {
-            case kParseOk:
-              if (!ps.PushRegexp(re))
-                return NULL;
-              goto Break2;
-            case kParseError:
-              re->Decref();
-              return NULL;
-            case kParseNothing:
-              re->Decref();
-              break;
-          }
-        }
-
-        const UGroup *g = MaybeParsePerlCCEscape(&t, ps.flags());
-        if (g != NULL) {
-          Regexp* re = new Regexp(kRegexpCharClass, ps.flags() & ~FoldCase);
-          re->char_class_.ccb_ = new CharClassBuilder;
-          AddUGroup(re->char_class_.ccb_, g, g->sign, ps.flags());
-          if (!ps.PushRegexp(re))
-            return NULL;
-          break;
-        }
-
-        Rune r;
-        if (!ParseEscape(&t, &r, status, ps.rune_max()))
-          return NULL;
-        if (!ps.PushLiteral(r))
-          return NULL;
-        break;
-      }
-    }
-  Break2:
-    lastunary = isunary;
-  }
-  return ps.DoFinish();
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// GENERATED BY make_perl_groups.pl; DO NOT EDIT.
-// make_perl_groups.pl >perl_groups.cc
-
-
-
-namespace duckdb_re2 {
-
-static const URange16 code1[] = {  /* \d */
-	{ 0x30, 0x39 },
-};
-static const URange16 code2[] = {  /* \s */
-	{ 0x9, 0xa },
-	{ 0xc, 0xd },
-	{ 0x20, 0x20 },
-};
-static const URange16 code3[] = {  /* \w */
-	{ 0x30, 0x39 },
-	{ 0x41, 0x5a },
-	{ 0x5f, 0x5f },
-	{ 0x61, 0x7a },
-};
-const UGroup perl_groups[] = {
-	{ "\\d", +1, code1, 1 , nullptr, 0},
-	{ "\\D", -1, code1, 1 , nullptr, 0},
-	{ "\\s", +1, code2, 3 , nullptr, 0},
-	{ "\\S", -1, code2, 3 , nullptr, 0},
-	{ "\\w", +1, code3, 4 , nullptr, 0},
-	{ "\\W", -1, code3, 4 , nullptr, 0},
-};
-const int num_perl_groups = 6;
-static const URange16 code4[] = {  /* [:alnum:] */
-	{ 0x30, 0x39 },
-	{ 0x41, 0x5a },
-	{ 0x61, 0x7a },
-};
-static const URange16 code5[] = {  /* [:alpha:] */
-	{ 0x41, 0x5a },
-	{ 0x61, 0x7a },
-};
-static const URange16 code6[] = {  /* [:ascii:] */
-	{ 0x0, 0x7f },
-};
-static const URange16 code7[] = {  /* [:blank:] */
-	{ 0x9, 0x9 },
-	{ 0x20, 0x20 },
-};
-static const URange16 code8[] = {  /* [:cntrl:] */
-	{ 0x0, 0x1f },
-	{ 0x7f, 0x7f },
-};
-static const URange16 code9[] = {  /* [:digit:] */
-	{ 0x30, 0x39 },
-};
-static const URange16 code10[] = {  /* [:graph:] */
-	{ 0x21, 0x7e },
-};
-static const URange16 code11[] = {  /* [:lower:] */
-	{ 0x61, 0x7a },
-};
-static const URange16 code12[] = {  /* [:print:] */
-	{ 0x20, 0x7e },
-};
-static const URange16 code13[] = {  /* [:punct:] */
-	{ 0x21, 0x2f },
-	{ 0x3a, 0x40 },
-	{ 0x5b, 0x60 },
-	{ 0x7b, 0x7e },
-};
-static const URange16 code14[] = {  /* [:space:] */
-	{ 0x9, 0xd },
-	{ 0x20, 0x20 },
-};
-static const URange16 code15[] = {  /* [:upper:] */
-	{ 0x41, 0x5a },
-};
-static const URange16 code16[] = {  /* [:word:] */
-	{ 0x30, 0x39 },
-	{ 0x41, 0x5a },
-	{ 0x5f, 0x5f },
-	{ 0x61, 0x7a },
-};
-static const URange16 code17[] = {  /* [:xdigit:] */
-	{ 0x30, 0x39 },
-	{ 0x41, 0x46 },
-	{ 0x61, 0x66 },
-};
-const UGroup posix_groups[] = {
-	{ "[:alnum:]", +1, code4, 3 , nullptr, 0},
-	{ "[:^alnum:]", -1, code4, 3 , nullptr, 0},
-	{ "[:alpha:]", +1, code5, 2 , nullptr, 0},
-	{ "[:^alpha:]", -1, code5, 2 , nullptr, 0},
-	{ "[:ascii:]", +1, code6, 1 , nullptr, 0},
-	{ "[:^ascii:]", -1, code6, 1 , nullptr, 0},
-	{ "[:blank:]", +1, code7, 2 , nullptr, 0},
-	{ "[:^blank:]", -1, code7, 2 , nullptr, 0},
-	{ "[:cntrl:]", +1, code8, 2 , nullptr, 0},
-	{ "[:^cntrl:]", -1, code8, 2 , nullptr, 0},
-	{ "[:digit:]", +1, code9, 1 , nullptr, 0},
-	{ "[:^digit:]", -1, code9, 1 , nullptr, 0},
-	{ "[:graph:]", +1, code10, 1 , nullptr, 0},
-	{ "[:^graph:]", -1, code10, 1 , nullptr, 0},
-	{ "[:lower:]", +1, code11, 1 , nullptr, 0},
-	{ "[:^lower:]", -1, code11, 1 , nullptr, 0},
-	{ "[:print:]", +1, code12, 1 , nullptr, 0},
-	{ "[:^print:]", -1, code12, 1 , nullptr, 0},
-	{ "[:punct:]", +1, code13, 4 , nullptr, 0},
-	{ "[:^punct:]", -1, code13, 4 , nullptr, 0},
-	{ "[:space:]", +1, code14, 2 , nullptr, 0},
-	{ "[:^space:]", -1, code14, 2 , nullptr, 0},
-	{ "[:upper:]", +1, code15, 1 , nullptr, 0},
-	{ "[:^upper:]", -1, code15, 1, nullptr, 0},
-	{ "[:word:]", +1, code16, 4 , nullptr, 0},
-	{ "[:^word:]", -1, code16, 4 , nullptr, 0},
-	{ "[:xdigit:]", +1, code17, 3 , nullptr, 0},
-	{ "[:^xdigit:]", -1, code17, 3 , nullptr, 0},
-};
-const int num_posix_groups = 28;
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string>
-#include <vector>
-
-
-
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-typedef std::set<std::string>::iterator SSIter;
-typedef std::set<std::string>::const_iterator ConstSSIter;
-
-// Initializes a Prefilter, allocating subs_ as necessary.
-Prefilter::Prefilter(Op op) {
-  op_ = op;
-  subs_ = NULL;
-  if (op_ == AND || op_ == OR)
-    subs_ = new std::vector<Prefilter*>;
-}
-
-// Destroys a Prefilter.
-Prefilter::~Prefilter() {
-  if (subs_) {
-    for (size_t i = 0; i < subs_->size(); i++)
-      delete (*subs_)[i];
-    delete subs_;
-    subs_ = NULL;
-  }
-}
-
-// Simplify if the node is an empty Or or And.
-Prefilter* Prefilter::Simplify() {
-  if (op_ != AND && op_ != OR) {
-    return this;
-  }
-
-  // Nothing left in the AND/OR.
-  if (subs_->empty()) {
-    if (op_ == AND)
-      op_ = ALL;  // AND of nothing is true
-    else
-      op_ = NONE;  // OR of nothing is false
-
-    return this;
-  }
-
-  // Just one subnode: throw away wrapper.
-  if (subs_->size() == 1) {
-    Prefilter* a = (*subs_)[0];
-    subs_->clear();
-    delete this;
-    return a->Simplify();
-  }
-
-  return this;
-}
-
-// Combines two Prefilters together to create an "op" (AND or OR).
-// The passed Prefilters will be part of the returned Prefilter or deleted.
-// Does lots of work to avoid creating unnecessarily complicated structures.
-Prefilter* Prefilter::AndOr(Op op, Prefilter* a, Prefilter* b) {
-  // If a, b can be rewritten as op, do so.
-  a = a->Simplify();
-  b = b->Simplify();
-
-  // Canonicalize: a->op <= b->op.
-  if (a->op() > b->op()) {
-    Prefilter* t = a;
-    a = b;
-    b = t;
-  }
-
-  // Trivial cases.
-  //    ALL AND b = b
-  //    NONE OR b = b
-  //    ALL OR b   = ALL
-  //    NONE AND b = NONE
-  // Don't need to look at b, because of canonicalization above.
-  // ALL and NONE are smallest opcodes.
-  if (a->op() == ALL || a->op() == NONE) {
-    if ((a->op() == ALL && op == AND) ||
-        (a->op() == NONE && op == OR)) {
-      delete a;
-      return b;
-    } else {
-      delete b;
-      return a;
-    }
-  }
-
-  // If a and b match op, merge their contents.
-  if (a->op() == op && b->op() == op) {
-    for (size_t i = 0; i < b->subs()->size(); i++) {
-      Prefilter* bb = (*b->subs())[i];
-      a->subs()->push_back(bb);
-    }
-    b->subs()->clear();
-    delete b;
-    return a;
-  }
-
-  // If a already has the same op as the op that is under construction
-  // add in b (similarly if b already has the same op, add in a).
-  if (b->op() == op) {
-    Prefilter* t = a;
-    a = b;
-    b = t;
-  }
-  if (a->op() == op) {
-    a->subs()->push_back(b);
-    return a;
-  }
-
-  // Otherwise just return the op.
-  Prefilter* c = new Prefilter(op);
-  c->subs()->push_back(a);
-  c->subs()->push_back(b);
-  return c;
-}
-
-Prefilter* Prefilter::And(Prefilter* a, Prefilter* b) {
-  return AndOr(AND, a, b);
-}
-
-Prefilter* Prefilter::Or(Prefilter* a, Prefilter* b) {
-  return AndOr(OR, a, b);
-}
-
-static void SimplifyStringSet(std::set<std::string> *ss) {
-  // Now make sure that the strings aren't redundant.  For example, if
-  // we know "ab" is a required string, then it doesn't help at all to
-  // know that "abc" is also a required string, so delete "abc". This
-  // is because, when we are performing a string search to filter
-  // regexps, matching ab will already allow this regexp to be a
-  // candidate for match, so further matching abc is redundant.
-
-  for (SSIter i = ss->begin(); i != ss->end(); ++i) {
-    SSIter j = i;
-    ++j;
-    while (j != ss->end()) {
-      // Increment j early so that we can erase the element it points to.
-      SSIter old_j = j;
-      ++j;
-      if (old_j->find(*i) != std::string::npos)
-        ss->erase(old_j);
-    }
-  }
-}
-
-Prefilter* Prefilter::OrStrings(std::set<std::string>* ss) {
-  SimplifyStringSet(ss);
-  Prefilter* or_prefilter = NULL;
-  if (!ss->empty()) {
-    or_prefilter = new Prefilter(NONE);
-    for (SSIter i = ss->begin(); i != ss->end(); ++i)
-      or_prefilter = Or(or_prefilter, FromString(*i));
-  }
-  return or_prefilter;
-}
-
-static Rune ToLowerRune(Rune r) {
-  if (r < Runeself) {
-    if ('A' <= r && r <= 'Z')
-      r += 'a' - 'A';
-    return r;
-  }
-
-  const CaseFold *f = LookupCaseFold(unicode_tolower, num_unicode_tolower, r);
-  if (f == NULL || r < f->lo)
-    return r;
-  return ApplyFold(f, r);
-}
-
-static Rune ToLowerRuneLatin1(Rune r) {
-  if ('A' <= r && r <= 'Z')
-    r += 'a' - 'A';
-  return r;
-}
-
-Prefilter* Prefilter::FromString(const std::string& str) {
-  Prefilter* m = new Prefilter(Prefilter::ATOM);
-  m->atom_ = str;
-  return m;
-}
-
-// Information about a regexp used during computation of Prefilter.
-// Can be thought of as information about the set of strings matching
-// the given regular expression.
-class Prefilter::Info {
- public:
-  Info();
-  ~Info();
-
-  // More constructors.  They delete their Info* arguments.
-  static Info* Alt(Info* a, Info* b);
-  static Info* Concat(Info* a, Info* b);
-  static Info* And(Info* a, Info* b);
-  static Info* Star(Info* a);
-  static Info* Plus(Info* a);
-  static Info* Quest(Info* a);
-  static Info* EmptyString();
-  static Info* NoMatch();
-  static Info* AnyCharOrAnyByte();
-  static Info* CClass(CharClass* cc, bool latin1);
-  static Info* Literal(Rune r);
-  static Info* LiteralLatin1(Rune r);
-  static Info* AnyMatch();
-
-  // Format Info as a string.
-  std::string ToString();
-
-  // Caller takes ownership of the Prefilter.
-  Prefilter* TakeMatch();
-
-  std::set<std::string>& exact() { return exact_; }
-
-  bool is_exact() const { return is_exact_; }
-
-  class Walker;
-
- private:
-  std::set<std::string> exact_;
-
-  // When is_exact_ is true, the strings that match
-  // are placed in exact_. When it is no longer an exact
-  // set of strings that match this RE, then is_exact_
-  // is false and the match_ contains the required match
-  // criteria.
-  bool is_exact_;
-
-  // Accumulated Prefilter query that any
-  // match for this regexp is guaranteed to match.
-  Prefilter* match_;
-};
-
-
-Prefilter::Info::Info()
-  : is_exact_(false),
-    match_(NULL) {
-}
-
-Prefilter::Info::~Info() {
-  delete match_;
-}
-
-Prefilter* Prefilter::Info::TakeMatch() {
-  if (is_exact_) {
-    match_ = Prefilter::OrStrings(&exact_);
-    is_exact_ = false;
-  }
-  Prefilter* m = match_;
-  match_ = NULL;
-  return m;
-}
-
-// Format a Info in string form.
-std::string Prefilter::Info::ToString() {
-  if (is_exact_) {
-    int n = 0;
-    std::string s;
-    for (SSIter i = exact_.begin(); i != exact_.end(); ++i) {
-      if (n++ > 0)
-        s += ",";
-      s += *i;
-    }
-    return s;
-  }
-
-  if (match_)
-    return match_->DebugString();
-
-  return "";
-}
-
-// Add the strings from src to dst.
-static void CopyIn(const std::set<std::string>& src,
-                   std::set<std::string>* dst) {
-  for (ConstSSIter i = src.begin(); i != src.end(); ++i)
-    dst->insert(*i);
-}
-
-// Add the cross-product of a and b to dst.
-// (For each string i in a and j in b, add i+j.)
-static void CrossProduct(const std::set<std::string>& a,
-                         const std::set<std::string>& b,
-                         std::set<std::string>* dst) {
-  for (ConstSSIter i = a.begin(); i != a.end(); ++i)
-    for (ConstSSIter j = b.begin(); j != b.end(); ++j)
-      dst->insert(*i + *j);
-}
-
-// Concats a and b. Requires that both are exact sets.
-// Forms an exact set that is a crossproduct of a and b.
-Prefilter::Info* Prefilter::Info::Concat(Info* a, Info* b) {
-  if (a == NULL)
-    return b;
-  DCHECK(a->is_exact_);
-  DCHECK(b && b->is_exact_);
-  Info *ab = new Info();
-
-  CrossProduct(a->exact_, b->exact_, &ab->exact_);
-  ab->is_exact_ = true;
-
-  delete a;
-  delete b;
-  return ab;
-}
-
-// Constructs an inexact Info for ab given a and b.
-// Used only when a or b is not exact or when the
-// exact cross product is likely to be too big.
-Prefilter::Info* Prefilter::Info::And(Info* a, Info* b) {
-  if (a == NULL)
-    return b;
-  if (b == NULL)
-    return a;
-
-  Info *ab = new Info();
-
-  ab->match_ = Prefilter::And(a->TakeMatch(), b->TakeMatch());
-  ab->is_exact_ = false;
-  delete a;
-  delete b;
-  return ab;
-}
-
-// Constructs Info for a|b given a and b.
-Prefilter::Info* Prefilter::Info::Alt(Info* a, Info* b) {
-  Info *ab = new Info();
-
-  if (a->is_exact_ && b->is_exact_) {
-    CopyIn(a->exact_, &ab->exact_);
-    CopyIn(b->exact_, &ab->exact_);
-    ab->is_exact_ = true;
-  } else {
-    // Either a or b has is_exact_ = false. If the other
-    // one has is_exact_ = true, we move it to match_ and
-    // then create a OR of a,b. The resulting Info has
-    // is_exact_ = false.
-    ab->match_ = Prefilter::Or(a->TakeMatch(), b->TakeMatch());
-    ab->is_exact_ = false;
-  }
-
-  delete a;
-  delete b;
-  return ab;
-}
-
-// Constructs Info for a? given a.
-Prefilter::Info* Prefilter::Info::Quest(Info *a) {
-  Info *ab = new Info();
-
-  ab->is_exact_ = false;
-  ab->match_ = new Prefilter(ALL);
-  delete a;
-  return ab;
-}
-
-// Constructs Info for a* given a.
-// Same as a? -- not much to do.
-Prefilter::Info* Prefilter::Info::Star(Info *a) {
-  return Quest(a);
-}
-
-// Constructs Info for a+ given a. If a was exact set, it isn't
-// anymore.
-Prefilter::Info* Prefilter::Info::Plus(Info *a) {
-  Info *ab = new Info();
-
-  ab->match_ = a->TakeMatch();
-  ab->is_exact_ = false;
-
-  delete a;
-  return ab;
-}
-
-static std::string RuneToString(Rune r) {
-  char buf[UTFmax];
-  int n = runetochar(buf, &r);
-  return std::string(buf, n);
-}
-
-static std::string RuneToStringLatin1(Rune r) {
-  char c = r & 0xff;
-  return std::string(&c, 1);
-}
-
-// Constructs Info for literal rune.
-Prefilter::Info* Prefilter::Info::Literal(Rune r) {
-  Info* info = new Info();
-  info->exact_.insert(RuneToString(ToLowerRune(r)));
-  info->is_exact_ = true;
-  return info;
-}
-
-// Constructs Info for literal rune for Latin1 encoded string.
-Prefilter::Info* Prefilter::Info::LiteralLatin1(Rune r) {
-  Info* info = new Info();
-  info->exact_.insert(RuneToStringLatin1(ToLowerRuneLatin1(r)));
-  info->is_exact_ = true;
-  return info;
-}
-
-// Constructs Info for dot (any character) or \C (any byte).
-Prefilter::Info* Prefilter::Info::AnyCharOrAnyByte() {
-  Prefilter::Info* info = new Prefilter::Info();
-  info->match_ = new Prefilter(ALL);
-  return info;
-}
-
-// Constructs Prefilter::Info for no possible match.
-Prefilter::Info* Prefilter::Info::NoMatch() {
-  Prefilter::Info* info = new Prefilter::Info();
-  info->match_ = new Prefilter(NONE);
-  return info;
-}
-
-// Constructs Prefilter::Info for any possible match.
-// This Prefilter::Info is valid for any regular expression,
-// since it makes no assertions whatsoever about the
-// strings being matched.
-Prefilter::Info* Prefilter::Info::AnyMatch() {
-  Prefilter::Info *info = new Prefilter::Info();
-  info->match_ = new Prefilter(ALL);
-  return info;
-}
-
-// Constructs Prefilter::Info for just the empty string.
-Prefilter::Info* Prefilter::Info::EmptyString() {
-  Prefilter::Info* info = new Prefilter::Info();
-  info->is_exact_ = true;
-  info->exact_.insert("");
-  return info;
-}
-
-// Constructs Prefilter::Info for a character class.
-typedef CharClass::iterator CCIter;
-Prefilter::Info* Prefilter::Info::CClass(CharClass *cc,
-                                         bool latin1) {
-  // If the class is too large, it's okay to overestimate.
-  if (cc->size() > 10)
-    return AnyCharOrAnyByte();
-
-  Prefilter::Info *a = new Prefilter::Info();
-  for (CCIter i = cc->begin(); i != cc->end(); ++i)
-    for (Rune r = i->lo; r <= i->hi; r++) {
-      if (latin1) {
-        a->exact_.insert(RuneToStringLatin1(ToLowerRuneLatin1(r)));
-      } else {
-        a->exact_.insert(RuneToString(ToLowerRune(r)));
-      }
-    }
-
-
-  a->is_exact_ = true;
-
-  return a;
-}
-
-class Prefilter::Info::Walker : public Regexp::Walker<Prefilter::Info*> {
- public:
-  Walker(bool latin1) : latin1_(latin1) {}
-
-  virtual Info* PostVisit(
-      Regexp* re, Info* parent_arg,
-      Info* pre_arg,
-      Info** child_args, int nchild_args);
-
-  virtual Info* ShortVisit(
-      Regexp* re,
-      Info* parent_arg);
-
-  bool latin1() { return latin1_; }
- private:
-  bool latin1_;
-
-  Walker(const Walker&) = delete;
-  Walker& operator=(const Walker&) = delete;
-};
-
-Prefilter::Info* Prefilter::BuildInfo(Regexp* re) {
-  bool latin1 = (re->parse_flags() & Regexp::Latin1) != 0;
-  Prefilter::Info::Walker w(latin1);
-  Prefilter::Info* info = w.WalkExponential(re, NULL, 100000);
-
-  if (w.stopped_early()) {
-    delete info;
-    return NULL;
-  }
-
-  return info;
-}
-
-Prefilter::Info* Prefilter::Info::Walker::ShortVisit(
-    Regexp* re, Prefilter::Info* parent_arg) {
-  return AnyMatch();
-}
-
-// Constructs the Prefilter::Info for the given regular expression.
-// Assumes re is simplified.
-Prefilter::Info* Prefilter::Info::Walker::PostVisit(
-    Regexp* re, Prefilter::Info* parent_arg,
-    Prefilter::Info* pre_arg, Prefilter::Info** child_args,
-    int nchild_args) {
-  Prefilter::Info *info;
-  switch (re->op()) {
-    default:
-    case kRegexpRepeat:
-      LOG(DFATAL) << "Bad regexp op " << re->op();
-      info = EmptyString();
-      break;
-
-    case kRegexpNoMatch:
-      info = NoMatch();
-      break;
-
-    // These ops match the empty string:
-    case kRegexpEmptyMatch:      // anywhere
-    case kRegexpBeginLine:       // at beginning of line
-    case kRegexpEndLine:         // at end of line
-    case kRegexpBeginText:       // at beginning of text
-    case kRegexpEndText:         // at end of text
-    case kRegexpWordBoundary:    // at word boundary
-    case kRegexpNoWordBoundary:  // not at word boundary
-      info = EmptyString();
-      break;
-
-    case kRegexpLiteral:
-      if (latin1()) {
-        info = LiteralLatin1(re->rune());
-      }
-      else {
-        info = Literal(re->rune());
-      }
-      break;
-
-    case kRegexpLiteralString:
-      if (re->nrunes() == 0) {
-        info = NoMatch();
-        break;
-      }
-      if (latin1()) {
-        info = LiteralLatin1(re->runes()[0]);
-        for (int i = 1; i < re->nrunes(); i++) {
-          info = Concat(info, LiteralLatin1(re->runes()[i]));
-        }
-      } else {
-        info = Literal(re->runes()[0]);
-        for (int i = 1; i < re->nrunes(); i++) {
-          info = Concat(info, Literal(re->runes()[i]));
-        }
-      }
-      break;
-
-    case kRegexpConcat: {
-      // Accumulate in info.
-      // Exact is concat of recent contiguous exact nodes.
-      info = NULL;
-      Info* exact = NULL;
-      for (int i = 0; i < nchild_args; i++) {
-        Info* ci = child_args[i];  // child info
-        if (!ci->is_exact() ||
-            (exact && ci->exact().size() * exact->exact().size() > 16)) {
-          // Exact run is over.
-          info = And(info, exact);
-          exact = NULL;
-          // Add this child's info.
-          info = And(info, ci);
-        } else {
-          // Append to exact run.
-          exact = Concat(exact, ci);
-        }
-      }
-      info = And(info, exact);
-    }
-      break;
-
-    case kRegexpAlternate:
-      info = child_args[0];
-      for (int i = 1; i < nchild_args; i++)
-        info = Alt(info, child_args[i]);
-      break;
-
-    case kRegexpStar:
-      info = Star(child_args[0]);
-      break;
-
-    case kRegexpQuest:
-      info = Quest(child_args[0]);
-      break;
-
-    case kRegexpPlus:
-      info = Plus(child_args[0]);
-      break;
-
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-      // Claim nothing, except that it's not empty.
-      info = AnyCharOrAnyByte();
-      break;
-
-    case kRegexpCharClass:
-      info = CClass(re->cc(), latin1());
-      break;
-
-    case kRegexpCapture:
-      // These don't affect the set of matching strings.
-      info = child_args[0];
-      break;
-  }
-
-  return info;
-}
-
-
-Prefilter* Prefilter::FromRegexp(Regexp* re) {
-  if (re == NULL)
-    return NULL;
-
-  Regexp* simple = re->Simplify();
-  Prefilter::Info *info = BuildInfo(simple);
-
-  simple->Decref();
-  if (info == NULL)
-    return NULL;
-
-  Prefilter* m = info->TakeMatch();
-
-  delete info;
-  return m;
-}
-
-std::string Prefilter::DebugString() const {
-  switch (op_) {
-    default:
-      LOG(DFATAL) << "Bad op in Prefilter::DebugString: " << op_;
-      return StringPrintf("op%d", op_);
-    case NONE:
-      return "*no-matches*";
-    case ATOM:
-      return atom_;
-    case ALL:
-      return "";
-    case AND: {
-      std::string s = "";
-      for (size_t i = 0; i < subs_->size(); i++) {
-        if (i > 0)
-          s += " ";
-        Prefilter* sub = (*subs_)[i];
-        s += sub ? sub->DebugString() : "<nil>";
-      }
-      return s;
-    }
-    case OR: {
-      std::string s = "(";
-      for (size_t i = 0; i < subs_->size(); i++) {
-        if (i > 0)
-          s += "|";
-        Prefilter* sub = (*subs_)[i];
-        s += sub ? sub->DebugString() : "<nil>";
-      }
-      s += ")";
-      return s;
-    }
-  }
-}
-
-Prefilter* Prefilter::FromRE2(const RE2* re2) {
-  if (re2 == NULL)
-    return NULL;
-
-  Regexp* regexp = re2->Regexp();
-  if (regexp == NULL)
-    return NULL;
-
-  return FromRegexp(regexp);
-}
-
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-
-
-#include <stddef.h>
-#include <algorithm>
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-PrefilterTree::PrefilterTree()
-    : compiled_(false),
-      min_atom_len_(3) {
-}
-
-PrefilterTree::PrefilterTree(int min_atom_len)
-    : compiled_(false),
-      min_atom_len_(min_atom_len) {
-}
-
-PrefilterTree::~PrefilterTree() {
-  for (size_t i = 0; i < prefilter_vec_.size(); i++)
-    delete prefilter_vec_[i];
-
-  for (size_t i = 0; i < entries_.size(); i++)
-    delete entries_[i].parents;
-}
-
-void PrefilterTree::Add(Prefilter* prefilter) {
-  if (compiled_) {
-    LOG(DFATAL) << "Add called after Compile.";
-    return;
-  }
-  if (prefilter != NULL && !KeepNode(prefilter)) {
-    delete prefilter;
-    prefilter = NULL;
-  }
-
-  prefilter_vec_.push_back(prefilter);
-}
-
-void PrefilterTree::Compile(std::vector<std::string>* atom_vec) {
-  if (compiled_) {
-    LOG(DFATAL) << "Compile called already.";
-    return;
-  }
-
-  // Some legacy users of PrefilterTree call Compile() before
-  // adding any regexps and expect Compile() to have no effect.
-  if (prefilter_vec_.empty())
-    return;
-
-  compiled_ = true;
-
-  // TODO(junyer): Use std::unordered_set<Prefilter*> instead?
-  NodeMap nodes;
-  AssignUniqueIds(&nodes, atom_vec);
-
-  // Identify nodes that are too common among prefilters and are
-  // triggering too many parents. Then get rid of them if possible.
-  // Note that getting rid of a prefilter node simply means they are
-  // no longer necessary for their parent to trigger; that is, we do
-  // not miss out on any regexps triggering by getting rid of a
-  // prefilter node.
-  for (size_t i = 0; i < entries_.size(); i++) {
-    StdIntMap* parents = entries_[i].parents;
-    if (parents->size() > 8) {
-      // This one triggers too many things. If all the parents are AND
-      // nodes and have other things guarding them, then get rid of
-      // this trigger. TODO(vsri): Adjust the threshold appropriately,
-      // make it a function of total number of nodes?
-      bool have_other_guard = true;
-      for (StdIntMap::iterator it = parents->begin();
-           it != parents->end(); ++it) {
-        have_other_guard = have_other_guard &&
-            (entries_[it->first].propagate_up_at_count > 1);
-      }
-
-      if (have_other_guard) {
-        for (StdIntMap::iterator it = parents->begin();
-             it != parents->end(); ++it)
-          entries_[it->first].propagate_up_at_count -= 1;
-
-        parents->clear();  // Forget the parents
-      }
-    }
-  }
-}
-
-Prefilter* PrefilterTree::CanonicalNode(NodeMap* nodes, Prefilter* node) {
-  std::string node_string = NodeString(node);
-  std::map<std::string, Prefilter*>::iterator iter = nodes->find(node_string);
-  if (iter == nodes->end())
-    return NULL;
-  return (*iter).second;
-}
-
-std::string PrefilterTree::NodeString(Prefilter* node) const {
-  // Adding the operation disambiguates AND/OR/atom nodes.
-  std::string s = StringPrintf("%d", node->op()) + ":";
-  if (node->op() == Prefilter::ATOM) {
-    s += node->atom();
-  } else {
-    for (size_t i = 0; i < node->subs()->size(); i++) {
-      if (i > 0)
-        s += ',';
-      s += StringPrintf("%d", (*node->subs())[i]->unique_id());
-    }
-  }
-  return s;
-}
-
-bool PrefilterTree::KeepNode(Prefilter* node) const {
-  if (node == NULL)
-    return false;
-
-  switch (node->op()) {
-    default:
-      LOG(DFATAL) << "Unexpected op in KeepNode: " << node->op();
-      return false;
-
-    case Prefilter::ALL:
-    case Prefilter::NONE:
-      return false;
-
-    case Prefilter::ATOM:
-      return node->atom().size() >= static_cast<size_t>(min_atom_len_);
-
-    case Prefilter::AND: {
-      int j = 0;
-      std::vector<Prefilter*>* subs = node->subs();
-      for (size_t i = 0; i < subs->size(); i++)
-        if (KeepNode((*subs)[i]))
-          (*subs)[j++] = (*subs)[i];
-        else
-          delete (*subs)[i];
-
-      subs->resize(j);
-      return j > 0;
-    }
-
-    case Prefilter::OR:
-      for (size_t i = 0; i < node->subs()->size(); i++)
-        if (!KeepNode((*node->subs())[i]))
-          return false;
-      return true;
-  }
-}
-
-void PrefilterTree::AssignUniqueIds(NodeMap* nodes,
-                                    std::vector<std::string>* atom_vec) {
-  atom_vec->clear();
-
-  // Build vector of all filter nodes, sorted topologically
-  // from top to bottom in v.
-  std::vector<Prefilter*> v;
-
-  // Add the top level nodes of each regexp prefilter.
-  for (size_t i = 0; i < prefilter_vec_.size(); i++) {
-    Prefilter* f = prefilter_vec_[i];
-    if (f == NULL)
-      unfiltered_.push_back(static_cast<int>(i));
-
-    // We push NULL also on to v, so that we maintain the
-    // mapping of index==regexpid for level=0 prefilter nodes.
-    v.push_back(f);
-  }
-
-  // Now add all the descendant nodes.
-  for (size_t i = 0; i < v.size(); i++) {
-    Prefilter* f = v[i];
-    if (f == NULL)
-      continue;
-    if (f->op() == Prefilter::AND || f->op() == Prefilter::OR) {
-      const std::vector<Prefilter*>& subs = *f->subs();
-      for (size_t j = 0; j < subs.size(); j++)
-        v.push_back(subs[j]);
-    }
-  }
-
-  // Identify unique nodes.
-  int unique_id = 0;
-  for (int i = static_cast<int>(v.size()) - 1; i >= 0; i--) {
-    Prefilter *node = v[i];
-    if (node == NULL)
-      continue;
-    node->set_unique_id(-1);
-    Prefilter* canonical = CanonicalNode(nodes, node);
-    if (canonical == NULL) {
-      // Any further nodes that have the same node string
-      // will find this node as the canonical node.
-      nodes->emplace(NodeString(node), node);
-      if (node->op() == Prefilter::ATOM) {
-        atom_vec->push_back(node->atom());
-        atom_index_to_id_.push_back(unique_id);
-      }
-      node->set_unique_id(unique_id++);
-    } else {
-      node->set_unique_id(canonical->unique_id());
-    }
-  }
-  entries_.resize(nodes->size());
-
-  // Create parent StdIntMap for the entries.
-  for (int i = static_cast<int>(v.size()) - 1; i >= 0; i--) {
-    Prefilter* prefilter = v[i];
-    if (prefilter == NULL)
-      continue;
-
-    if (CanonicalNode(nodes, prefilter) != prefilter)
-      continue;
-
-    Entry* entry = &entries_[prefilter->unique_id()];
-    entry->parents = new StdIntMap();
-  }
-
-  // Fill the entries.
-  for (int i = static_cast<int>(v.size()) - 1; i >= 0; i--) {
-    Prefilter* prefilter = v[i];
-    if (prefilter == NULL)
-      continue;
-
-    if (CanonicalNode(nodes, prefilter) != prefilter)
-      continue;
-
-    Entry* entry = &entries_[prefilter->unique_id()];
-
-    switch (prefilter->op()) {
-      default:
-      case Prefilter::ALL:
-        LOG(DFATAL) << "Unexpected op: " << prefilter->op();
-        return;
-
-      case Prefilter::ATOM:
-        entry->propagate_up_at_count = 1;
-        break;
-
-      case Prefilter::OR:
-      case Prefilter::AND: {
-        std::set<int> uniq_child;
-        for (size_t j = 0; j < prefilter->subs()->size(); j++) {
-          Prefilter* child = (*prefilter->subs())[j];
-          Prefilter* canonical = CanonicalNode(nodes, child);
-          if (canonical == NULL) {
-            LOG(DFATAL) << "Null canonical node";
-            return;
-          }
-          int child_id = canonical->unique_id();
-          uniq_child.insert(child_id);
-          // To the child, we want to add to parent indices.
-          Entry* child_entry = &entries_[child_id];
-          if (child_entry->parents->find(prefilter->unique_id()) ==
-              child_entry->parents->end()) {
-            (*child_entry->parents)[prefilter->unique_id()] = 1;
-          }
-        }
-        entry->propagate_up_at_count = prefilter->op() == Prefilter::AND
-                                           ? static_cast<int>(uniq_child.size())
-                                           : 1;
-
-        break;
-      }
-    }
-  }
-
-  // For top level nodes, populate regexp id.
-  for (size_t i = 0; i < prefilter_vec_.size(); i++) {
-    if (prefilter_vec_[i] == NULL)
-      continue;
-    int id = CanonicalNode(nodes, prefilter_vec_[i])->unique_id();
-    DCHECK_LE(0, id);
-    Entry* entry = &entries_[id];
-    entry->regexps.push_back(static_cast<int>(i));
-  }
-}
-
-// Functions for triggering during search.
-void PrefilterTree::RegexpsGivenStrings(
-    const std::vector<int>& matched_atoms,
-    std::vector<int>* regexps) const {
-  regexps->clear();
-  if (!compiled_) {
-    // Some legacy users of PrefilterTree call Compile() before
-    // adding any regexps and expect Compile() to have no effect.
-    // This kludge is a counterpart to that kludge.
-    if (prefilter_vec_.empty())
-      return;
-
-    LOG(ERROR) << "RegexpsGivenStrings called before Compile.";
-    for (size_t i = 0; i < prefilter_vec_.size(); i++)
-      regexps->push_back(static_cast<int>(i));
-  } else {
-    IntMap regexps_map(static_cast<int>(prefilter_vec_.size()));
-    std::vector<int> matched_atom_ids;
-    for (size_t j = 0; j < matched_atoms.size(); j++)
-      matched_atom_ids.push_back(atom_index_to_id_[matched_atoms[j]]);
-    PropagateMatch(matched_atom_ids, &regexps_map);
-    for (IntMap::iterator it = regexps_map.begin();
-         it != regexps_map.end();
-         ++it)
-      regexps->push_back(it->index());
-
-    regexps->insert(regexps->end(), unfiltered_.begin(), unfiltered_.end());
-  }
-  std::sort(regexps->begin(), regexps->end());
-}
-
-void PrefilterTree::PropagateMatch(const std::vector<int>& atom_ids,
-                                   IntMap* regexps) const {
-  IntMap count(static_cast<int>(entries_.size()));
-  IntMap work(static_cast<int>(entries_.size()));
-  for (size_t i = 0; i < atom_ids.size(); i++)
-    work.set(atom_ids[i], 1);
-  for (IntMap::iterator it = work.begin(); it != work.end(); ++it) {
-    const Entry& entry = entries_[it->index()];
-    // Record regexps triggered.
-    for (size_t i = 0; i < entry.regexps.size(); i++)
-      regexps->set(entry.regexps[i], 1);
-    int c;
-    // Pass trigger up to parents.
-    for (StdIntMap::iterator it = entry.parents->begin();
-         it != entry.parents->end();
-         ++it) {
-      int j = it->first;
-      const Entry& parent = entries_[j];
-      // Delay until all the children have succeeded.
-      if (parent.propagate_up_at_count > 1) {
-        if (count.has_index(j)) {
-          c = count.get_existing(j) + 1;
-          count.set_existing(j, c);
-        } else {
-          c = 1;
-          count.set_new(j, c);
-        }
-        if (c < parent.propagate_up_at_count)
-          continue;
-      }
-      // Trigger the parent.
-      work.set(j, 1);
-    }
-  }
-}
-
-// Debugging help.
-void PrefilterTree::PrintPrefilter(int regexpid) {
-  LOG(ERROR) << DebugNodeString(prefilter_vec_[regexpid]);
-}
-
-void PrefilterTree::PrintDebugInfo(NodeMap* nodes) {
-  LOG(ERROR) << "#Unique Atoms: " << atom_index_to_id_.size();
-  LOG(ERROR) << "#Unique Nodes: " << entries_.size();
-
-  for (size_t i = 0; i < entries_.size(); i++) {
-    StdIntMap* parents = entries_[i].parents;
-    const std::vector<int>& regexps = entries_[i].regexps;
-    LOG(ERROR) << "EntryId: " << i
-               << " N: " << parents->size() << " R: " << regexps.size();
-    for (StdIntMap::iterator it = parents->begin(); it != parents->end(); ++it)
-      LOG(ERROR) << it->first;
-  }
-  LOG(ERROR) << "Map:";
-  for (std::map<std::string, Prefilter*>::const_iterator iter = nodes->begin();
-       iter != nodes->end(); ++iter)
-    LOG(ERROR) << "NodeId: " << (*iter).second->unique_id()
-               << " Str: " << (*iter).first;
-}
-
-std::string PrefilterTree::DebugNodeString(Prefilter* node) const {
-  std::string node_string = "";
-  if (node->op() == Prefilter::ATOM) {
-    DCHECK(!node->atom().empty());
-    node_string += node->atom();
-  } else {
-    // Adding the operation disambiguates AND and OR nodes.
-    node_string +=  node->op() == Prefilter::AND ? "AND" : "OR";
-    node_string += "(";
-    for (size_t i = 0; i < node->subs()->size(); i++) {
-      if (i > 0)
-        node_string += ',';
-      node_string += StringPrintf("%d", (*node->subs())[i]->unique_id());
-      node_string += ":";
-      node_string += DebugNodeString((*node->subs())[i]);
-    }
-    node_string += ")";
-  }
-  return node_string;
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Compiled regular expression representation.
-// Tested by compile_test.cc
-
-
-
-#include <stdint.h>
-#include <string.h>
-#include <algorithm>
-#include <memory>
-#include <utility>
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_BITMAP256_H_
-#define RE2_BITMAP256_H_
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-#include <stdint.h>
-#include <string.h>
-
-
-
-
-namespace duckdb_re2 {
-
-class Bitmap256 {
- public:
-  Bitmap256() {
-    Clear();
-  }
-
-  // Clears all of the bits.
-  void Clear() {
-    memset(words_, 0, sizeof words_);
-  }
-
-  // Tests the bit with index c.
-  bool Test(int c) const {
-    DCHECK_GE(c, 0);
-    DCHECK_LE(c, 255);
-
-    return (words_[c / 64] & (1ULL << (c % 64))) != 0;
-  }
-
-  // Sets the bit with index c.
-  void Set(int c) {
-    DCHECK_GE(c, 0);
-    DCHECK_LE(c, 255);
-
-    words_[c / 64] |= (1ULL << (c % 64));
-  }
-
-  // Finds the next non-zero bit with index >= c.
-  // Returns -1 if no such bit exists.
-  int FindNextSetBit(int c) const;
-
- private:
-  // Finds the least significant non-zero bit in n.
-  static int FindLSBSet(uint64_t n) {
-    DCHECK_NE(n, 0);
-
-#if defined(__GNUC__)
-    return __builtin_ctzll(n);
-#elif defined(_MSC_VER) && defined(_M_X64)
-    unsigned long c;
-    _BitScanForward64(&c, n);
-    return static_cast<int>(c);
-#elif defined(_MSC_VER) && defined(_M_IX86)
-    unsigned long c;
-    if (static_cast<uint32_t>(n) != 0) {
-      _BitScanForward(&c, static_cast<uint32_t>(n));
-      return static_cast<int>(c);
-    } else {
-      _BitScanForward(&c, static_cast<uint32_t>(n >> 32));
-      return static_cast<int>(c) + 32;
-    }
-#else
-    int c = 63;
-    for (int shift = 1 << 5; shift != 0; shift >>= 1) {
-      uint64_t word = n << shift;
-      if (word != 0) {
-        n = word;
-        c -= shift;
-      }
-    }
-    return c;
-#endif
-  }
-
-  uint64_t words_[4];
-};
-
-int Bitmap256::FindNextSetBit(int c) const {
-  DCHECK_GE(c, 0);
-  DCHECK_LE(c, 255);
-
-  // Check the word that contains the bit. Mask out any lower bits.
-  int i = c / 64;
-  uint64_t word = words_[i] & (~0ULL << (c % 64));
-  if (word != 0)
-    return (i * 64) + FindLSBSet(word);
-
-  // Check any following words.
-  i++;
-  switch (i) {
-    case 1:
-      if (words_[1] != 0)
-        return (1 * 64) + FindLSBSet(words_[1]);
-      FALLTHROUGH_INTENDED;
-    case 2:
-      if (words_[2] != 0)
-        return (2 * 64) + FindLSBSet(words_[2]);
-      FALLTHROUGH_INTENDED;
-    case 3:
-      if (words_[3] != 0)
-        return (3 * 64) + FindLSBSet(words_[3]);
-      FALLTHROUGH_INTENDED;
-    default:
-      return -1;
-  }
-}
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_BITMAP256_H_
-
-
-// LICENSE_CHANGE_END
-
-
-
-namespace duckdb_re2 {
-
-// Constructors per Inst opcode
-
-void Prog::Inst::InitAlt(uint32_t out, uint32_t out1) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_out_opcode(out, kInstAlt);
-  out1_ = out1;
-}
-
-void Prog::Inst::InitByteRange(int lo, int hi, int foldcase, uint32_t out) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_out_opcode(out, kInstByteRange);
-    inst_byte_range_data_.lo_ = lo & 0xFF;
-    inst_byte_range_data_.hi_ = hi & 0xFF;
-    inst_byte_range_data_.hint_foldcase_ = foldcase&1;
-}
-
-void Prog::Inst::InitCapture(int cap, uint32_t out) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_out_opcode(out, kInstCapture);
-  cap_ = cap;
-}
-
-void Prog::Inst::InitEmptyWidth(EmptyOp empty, uint32_t out) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_out_opcode(out, kInstEmptyWidth);
-  empty_ = empty;
-}
-
-void Prog::Inst::InitMatch(int32_t id) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_opcode(kInstMatch);
-  match_id_ = id;
-}
-
-void Prog::Inst::InitNop(uint32_t out) {
-  DCHECK_EQ(out_opcode_, 0);
-  set_opcode(kInstNop);
-}
-
-void Prog::Inst::InitFail() {
-  DCHECK_EQ(out_opcode_, 0);
-  set_opcode(kInstFail);
-}
-
-std::string Prog::Inst::Dump() {
-  switch (opcode()) {
-    default:
-      return StringPrintf("opcode %d", static_cast<int>(opcode()));
-
-    case kInstAlt:
-      return StringPrintf("alt -> %d | %d", out(), out1_);
-
-    case kInstAltMatch:
-      return StringPrintf("altmatch -> %d | %d", out(), out1_);
-
-    case kInstByteRange:
-      return StringPrintf("byte%s [%02x-%02x] %d -> %d",
-                          foldcase() ? "/i" : "",
-                          inst_byte_range_data_.lo_, inst_byte_range_data_.hi_, hint(), out());
-
-    case kInstCapture:
-      return StringPrintf("capture %d -> %d", cap_, out());
-
-    case kInstEmptyWidth:
-      return StringPrintf("emptywidth %#x -> %d",
-                          static_cast<int>(empty_), out());
-
-    case kInstMatch:
-      return StringPrintf("match! %d", match_id());
-
-    case kInstNop:
-      return StringPrintf("nop -> %d", out());
-
-    case kInstFail:
-      return StringPrintf("fail");
-  }
-}
-
-Prog::Prog()
-  : anchor_start_(false),
-    anchor_end_(false),
-    reversed_(false),
-    did_flatten_(false),
-    did_onepass_(false),
-    start_(0),
-    start_unanchored_(0),
-    size_(0),
-    bytemap_range_(0),
-    first_byte_(-1),
-    flags_(0),
-    list_count_(0),
-    dfa_mem_(0),
-    dfa_first_(NULL),
-    dfa_longest_(NULL) {
-}
-
-Prog::~Prog() {
-  DeleteDFA(dfa_longest_);
-  DeleteDFA(dfa_first_);
-}
-
-typedef SparseSet Workq;
-
-static inline void AddToQueue(Workq* q, int id) {
-  if (id != 0)
-    q->insert(id);
-}
-
-static std::string ProgToString(Prog* prog, Workq* q) {
-  std::string s;
-  for (Workq::iterator i = q->begin(); i != q->end(); ++i) {
-    int id = *i;
-    Prog::Inst* ip = prog->inst(id);
-    StringAppendF(&s, "%d. %s\n", id, ip->Dump().c_str());
-    AddToQueue(q, ip->out());
-    if (ip->opcode() == kInstAlt || ip->opcode() == kInstAltMatch)
-      AddToQueue(q, ip->out1());
-  }
-  return s;
-}
-
-static std::string FlattenedProgToString(Prog* prog, int start) {
-  std::string s;
-  for (int id = start; id < prog->size(); id++) {
-    Prog::Inst* ip = prog->inst(id);
-    if (ip->last())
-      StringAppendF(&s, "%d. %s\n", id, ip->Dump().c_str());
-    else
-      StringAppendF(&s, "%d+ %s\n", id, ip->Dump().c_str());
-  }
-  return s;
-}
-
-std::string Prog::Dump() {
-  if (did_flatten_)
-    return FlattenedProgToString(this, start_);
-
-  Workq q(size_);
-  AddToQueue(&q, start_);
-  return ProgToString(this, &q);
-}
-
-std::string Prog::DumpUnanchored() {
-  if (did_flatten_)
-    return FlattenedProgToString(this, start_unanchored_);
-
-  Workq q(size_);
-  AddToQueue(&q, start_unanchored_);
-  return ProgToString(this, &q);
-}
-
-std::string Prog::DumpByteMap() {
-  std::string map;
-  for (int c = 0; c < 256; c++) {
-    int b = bytemap_[c];
-    int lo = c;
-    while (c < 256-1 && bytemap_[c+1] == b)
-      c++;
-    int hi = c;
-    StringAppendF(&map, "[%02x-%02x] -> %d\n", lo, hi, b);
-  }
-  return map;
-}
-
-int Prog::first_byte() {
-  std::call_once(first_byte_once_, [](Prog* prog) {
-    prog->first_byte_ = prog->ComputeFirstByte();
-  }, this);
-  return first_byte_;
-}
-
-static bool IsMatch(Prog*, Prog::Inst*);
-
-// Peep-hole optimizer.
-void Prog::Optimize() {
-  Workq q(size_);
-
-  // Eliminate nops.  Most are taken out during compilation
-  // but a few are hard to avoid.
-  q.clear();
-  AddToQueue(&q, start_);
-  for (Workq::iterator i = q.begin(); i != q.end(); ++i) {
-    int id = *i;
-
-    Inst* ip = inst(id);
-    int j = ip->out();
-    Inst* jp;
-    while (j != 0 && (jp=inst(j))->opcode() == kInstNop) {
-      j = jp->out();
-    }
-    ip->set_out(j);
-    AddToQueue(&q, ip->out());
-
-    if (ip->opcode() == kInstAlt) {
-      j = ip->out1();
-      while (j != 0 && (jp=inst(j))->opcode() == kInstNop) {
-        j = jp->out();
-      }
-      ip->out1_ = j;
-      AddToQueue(&q, ip->out1());
-    }
-  }
-
-  // Insert kInstAltMatch instructions
-  // Look for
-  //   ip: Alt -> j | k
-  //	  j: ByteRange [00-FF] -> ip
-  //    k: Match
-  // or the reverse (the above is the greedy one).
-  // Rewrite Alt to AltMatch.
-  q.clear();
-  AddToQueue(&q, start_);
-  for (Workq::iterator i = q.begin(); i != q.end(); ++i) {
-    int id = *i;
-    Inst* ip = inst(id);
-    AddToQueue(&q, ip->out());
-    if (ip->opcode() == kInstAlt)
-      AddToQueue(&q, ip->out1());
-
-    if (ip->opcode() == kInstAlt) {
-      Inst* j = inst(ip->out());
-      Inst* k = inst(ip->out1());
-      if (j->opcode() == kInstByteRange && j->out() == id &&
-          j->lo() == 0x00 && j->hi() == 0xFF &&
-          IsMatch(this, k)) {
-        ip->set_opcode(kInstAltMatch);
-        continue;
-      }
-      if (IsMatch(this, j) &&
-          k->opcode() == kInstByteRange && k->out() == id &&
-          k->lo() == 0x00 && k->hi() == 0xFF) {
-        ip->set_opcode(kInstAltMatch);
-      }
-    }
-  }
-}
-
-// Is ip a guaranteed match at end of text, perhaps after some capturing?
-static bool IsMatch(Prog* prog, Prog::Inst* ip) {
-  for (;;) {
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "Unexpected opcode in IsMatch: " << ip->opcode();
-        return false;
-
-      case kInstAlt:
-      case kInstAltMatch:
-      case kInstByteRange:
-      case kInstFail:
-      case kInstEmptyWidth:
-        return false;
-
-      case kInstCapture:
-      case kInstNop:
-        ip = prog->inst(ip->out());
-        break;
-
-      case kInstMatch:
-        return true;
-    }
-  }
-}
-
-uint32_t Prog::EmptyFlags(const StringPiece& text, const char* p) {
-  int flags = 0;
-
-  // ^ and \A
-  if (p == text.begin())
-    flags |= kEmptyBeginText | kEmptyBeginLine;
-  else if (p[-1] == '\n')
-    flags |= kEmptyBeginLine;
-
-  // $ and \z
-  if (p == text.end())
-    flags |= kEmptyEndText | kEmptyEndLine;
-  else if (p < text.end() && p[0] == '\n')
-    flags |= kEmptyEndLine;
-
-  // \b and \B
-  if (p == text.begin() && p == text.end()) {
-    // no word boundary here
-  } else if (p == text.begin()) {
-    if (IsWordChar(p[0]))
-      flags |= kEmptyWordBoundary;
-  } else if (p == text.end()) {
-    if (IsWordChar(p[-1]))
-      flags |= kEmptyWordBoundary;
-  } else {
-    if (IsWordChar(p[-1]) != IsWordChar(p[0]))
-      flags |= kEmptyWordBoundary;
-  }
-  if (!(flags & kEmptyWordBoundary))
-    flags |= kEmptyNonWordBoundary;
-
-  return flags;
-}
-
-// ByteMapBuilder implements a coloring algorithm.
-//
-// The first phase is a series of "mark and merge" batches: we mark one or more
-// [lo-hi] ranges, then merge them into our internal state. Batching is not for
-// performance; rather, it means that the ranges are treated indistinguishably.
-//
-// Internally, the ranges are represented using a bitmap that stores the splits
-// and a vector that stores the colors; both of them are indexed by the ranges'
-// last bytes. Thus, in order to merge a [lo-hi] range, we split at lo-1 and at
-// hi (if not already split), then recolor each range in between. The color map
-// (i.e. from the old color to the new color) is maintained for the lifetime of
-// the batch and so underpins this somewhat obscure approach to set operations.
-//
-// The second phase builds the bytemap from our internal state: we recolor each
-// range, then store the new color (which is now the byte class) in each of the
-// corresponding array elements. Finally, we output the number of byte classes.
-class ByteMapBuilder {
- public:
-  ByteMapBuilder() {
-    // Initial state: the [0-255] range has color 256.
-    // This will avoid problems during the second phase,
-    // in which we assign byte classes numbered from 0.
-    splits_.Set(255);
-    colors_[255] = 256;
-    nextcolor_ = 257;
-  }
-
-  void Mark(int lo, int hi);
-  void Merge();
-  void Build(uint8_t* bytemap, int* bytemap_range);
-
- private:
-  int Recolor(int oldcolor);
-
-  Bitmap256 splits_;
-  int colors_[256];
-  int nextcolor_;
-  std::vector<std::pair<int, int>> colormap_;
-  std::vector<std::pair<int, int>> ranges_;
-
-  ByteMapBuilder(const ByteMapBuilder&) = delete;
-  ByteMapBuilder& operator=(const ByteMapBuilder&) = delete;
-};
-
-void ByteMapBuilder::Mark(int lo, int hi) {
-  DCHECK_GE(lo, 0);
-  DCHECK_GE(hi, 0);
-  DCHECK_LE(lo, 255);
-  DCHECK_LE(hi, 255);
-  DCHECK_LE(lo, hi);
-
-  // Ignore any [0-255] ranges. They cause us to recolor every range, which
-  // has no effect on the eventual result and is therefore a waste of time.
-  if (lo == 0 && hi == 255)
-    return;
-
-  ranges_.emplace_back(lo, hi);
-}
-
-void ByteMapBuilder::Merge() {
-  for (std::vector<std::pair<int, int>>::const_iterator it = ranges_.begin();
-       it != ranges_.end();
-       ++it) {
-    int lo = it->first-1;
-    int hi = it->second;
-
-    if (0 <= lo && !splits_.Test(lo)) {
-      splits_.Set(lo);
-      int next = splits_.FindNextSetBit(lo+1);
-      colors_[lo] = colors_[next];
-    }
-    if (!splits_.Test(hi)) {
-      splits_.Set(hi);
-      int next = splits_.FindNextSetBit(hi+1);
-      colors_[hi] = colors_[next];
-    }
-
-    int c = lo+1;
-    while (c < 256) {
-      int next = splits_.FindNextSetBit(c);
-      colors_[next] = Recolor(colors_[next]);
-      if (next == hi)
-        break;
-      c = next+1;
-    }
-  }
-  colormap_.clear();
-  ranges_.clear();
-}
-
-void ByteMapBuilder::Build(uint8_t* bytemap, int* bytemap_range) {
-  // Assign byte classes numbered from 0.
-  nextcolor_ = 0;
-
-  int c = 0;
-  while (c < 256) {
-    int next = splits_.FindNextSetBit(c);
-    uint8_t b = static_cast<uint8_t>(Recolor(colors_[next]));
-    while (c <= next) {
-      bytemap[c] = b;
-      c++;
-    }
-  }
-
-  *bytemap_range = nextcolor_;
-}
-
-int ByteMapBuilder::Recolor(int oldcolor) {
-  // Yes, this is a linear search. There can be at most 256
-  // colors and there will typically be far fewer than that.
-  // Also, we need to consider keys *and* values in order to
-  // avoid recoloring a given range more than once per batch.
-  std::vector<std::pair<int, int>>::const_iterator it =
-      std::find_if(colormap_.begin(), colormap_.end(),
-                   [=](const std::pair<int, int>& kv) -> bool {
-                     return kv.first == oldcolor || kv.second == oldcolor;
-                   });
-  if (it != colormap_.end())
-    return it->second;
-  int newcolor = nextcolor_;
-  nextcolor_++;
-  colormap_.emplace_back(oldcolor, newcolor);
-  return newcolor;
-}
-
-void Prog::ComputeByteMap() {
-  // Fill in bytemap with byte classes for the program.
-  // Ranges of bytes that are treated indistinguishably
-  // will be mapped to a single byte class.
-  ByteMapBuilder builder;
-
-  // Don't repeat the work for ^ and $.
-  bool marked_line_boundaries = false;
-  // Don't repeat the work for \b and \B.
-  bool marked_word_boundaries = false;
-
-  for (int id = 0; id < size(); id++) {
-    Inst* ip = inst(id);
-    if (ip->opcode() == kInstByteRange) {
-      int lo = ip->lo();
-      int hi = ip->hi();
-      builder.Mark(lo, hi);
-      if (ip->foldcase() && lo <= 'z' && hi >= 'a') {
-        int foldlo = lo;
-        int foldhi = hi;
-        if (foldlo < 'a')
-          foldlo = 'a';
-        if (foldhi > 'z')
-          foldhi = 'z';
-        if (foldlo <= foldhi) {
-          foldlo += 'A' - 'a';
-          foldhi += 'A' - 'a';
-          builder.Mark(foldlo, foldhi);
-        }
-      }
-      // If this Inst is not the last Inst in its list AND the next Inst is
-      // also a ByteRange AND the Insts have the same out, defer the merge.
-      if (!ip->last() &&
-          inst(id+1)->opcode() == kInstByteRange &&
-          ip->out() == inst(id+1)->out())
-        continue;
-      builder.Merge();
-    } else if (ip->opcode() == kInstEmptyWidth) {
-      if (ip->empty() & (kEmptyBeginLine|kEmptyEndLine) &&
-          !marked_line_boundaries) {
-        builder.Mark('\n', '\n');
-        builder.Merge();
-        marked_line_boundaries = true;
-      }
-      if (ip->empty() & (kEmptyWordBoundary|kEmptyNonWordBoundary) &&
-          !marked_word_boundaries) {
-        // We require two batches here: the first for ranges that are word
-        // characters, the second for ranges that are not word characters.
-        for (bool isword : {true, false}) {
-          int j;
-          for (int i = 0; i < 256; i = j) {
-            for (j = i + 1; j < 256 &&
-                            Prog::IsWordChar(static_cast<uint8_t>(i)) ==
-                                Prog::IsWordChar(static_cast<uint8_t>(j));
-                 j++)
-              ;
-            if (Prog::IsWordChar(static_cast<uint8_t>(i)) == isword)
-              builder.Mark(i, j - 1);
-          }
-          builder.Merge();
-        }
-        marked_word_boundaries = true;
-      }
-    }
-  }
-
-  builder.Build(bytemap_, &bytemap_range_);
-}
-
-// Prog::Flatten() implements a graph rewriting algorithm.
-//
-// The overall process is similar to epsilon removal, but retains some epsilon
-// transitions: those from Capture and EmptyWidth instructions; and those from
-// nullable subexpressions. (The latter avoids quadratic blowup in transitions
-// in the worst case.) It might be best thought of as Alt instruction elision.
-//
-// In conceptual terms, it divides the Prog into "trees" of instructions, then
-// traverses the "trees" in order to produce "lists" of instructions. A "tree"
-// is one or more instructions that grow from one "root" instruction to one or
-// more "leaf" instructions; if a "tree" has exactly one instruction, then the
-// "root" is also the "leaf". In most cases, a "root" is the successor of some
-// "leaf" (i.e. the "leaf" instruction's out() returns the "root" instruction)
-// and is considered a "successor root". A "leaf" can be a ByteRange, Capture,
-// EmptyWidth or Match instruction. However, this is insufficient for handling
-// nested nullable subexpressions correctly, so in some cases, a "root" is the
-// dominator of the instructions reachable from some "successor root" (i.e. it
-// has an unreachable predecessor) and is considered a "dominator root". Since
-// only Alt instructions can be "dominator roots" (other instructions would be
-// "leaves"), only Alt instructions are required to be marked as predecessors.
-//
-// Dividing the Prog into "trees" comprises two passes: marking the "successor
-// roots" and the predecessors; and marking the "dominator roots". Sorting the
-// "successor roots" by their bytecode offsets enables iteration in order from
-// greatest to least during the second pass; by working backwards in this case
-// and flooding the graph no further than "leaves" and already marked "roots",
-// it becomes possible to mark "dominator roots" without doing excessive work.
-//
-// Traversing the "trees" is just iterating over the "roots" in order of their
-// marking and flooding the graph no further than "leaves" and "roots". When a
-// "leaf" is reached, the instruction is copied with its successor remapped to
-// its "root" number. When a "root" is reached, a Nop instruction is generated
-// with its successor remapped similarly. As each "list" is produced, its last
-// instruction is marked as such. After all of the "lists" have been produced,
-// a pass over their instructions remaps their successors to bytecode offsets.
-void Prog::Flatten() {
-  if (did_flatten_)
-    return;
-  did_flatten_ = true;
-
-  // Scratch structures. It's important that these are reused by functions
-  // that we call in loops because they would thrash the heap otherwise.
-  SparseSet reachable(size());
-  std::vector<int> stk;
-  stk.reserve(size());
-
-  // First pass: Marks "successor roots" and predecessors.
-  // Builds the mapping from inst-ids to root-ids.
-  SparseArray<int> rootmap(size());
-  SparseArray<int> predmap(size());
-  std::vector<std::vector<int>> predvec;
-  MarkSuccessors(&rootmap, &predmap, &predvec, &reachable, &stk);
-
-  // Second pass: Marks "dominator roots".
-  SparseArray<int> sorted(rootmap);
-  std::sort(sorted.begin(), sorted.end(), sorted.less);
-  for (SparseArray<int>::const_iterator i = sorted.end() - 1;
-       i != sorted.begin();
-       --i) {
-    if (i->index() != start_unanchored() && i->index() != start())
-      MarkDominator(i->index(), &rootmap, &predmap, &predvec, &reachable, &stk);
-  }
-
-  // Third pass: Emits "lists". Remaps outs to root-ids.
-  // Builds the mapping from root-ids to flat-ids.
-  std::vector<int> flatmap(rootmap.size());
-  std::vector<Inst> flat;
-  flat.reserve(size());
-  for (SparseArray<int>::const_iterator i = rootmap.begin();
-       i != rootmap.end();
-       ++i) {
-    flatmap[i->value()] = static_cast<int>(flat.size());
-    EmitList(i->index(), &rootmap, &flat, &reachable, &stk);
-    flat.back().set_last();
-    // We have the bounds of the "list", so this is the
-    // most convenient point at which to compute hints.
-    ComputeHints(&flat, flatmap[i->value()], static_cast<int>(flat.size()));
-  }
-
-  list_count_ = static_cast<int>(flatmap.size());
-  for (int i = 0; i < kNumInst; i++)
-    inst_count_[i] = 0;
-
-  // Fourth pass: Remaps outs to flat-ids.
-  // Counts instructions by opcode.
-  for (int id = 0; id < static_cast<int>(flat.size()); id++) {
-    Inst* ip = &flat[id];
-    if (ip->opcode() != kInstAltMatch)  // handled in EmitList()
-      ip->set_out(flatmap[ip->out()]);
-    inst_count_[ip->opcode()]++;
-  }
-
-  int total = 0;
-  for (int i = 0; i < kNumInst; i++)
-    total += inst_count_[i];
-  DCHECK_EQ(total, static_cast<int>(flat.size()));
-
-  // Remap start_unanchored and start.
-  if (start_unanchored() == 0) {
-    DCHECK_EQ(start(), 0);
-  } else if (start_unanchored() == start()) {
-    set_start_unanchored(flatmap[1]);
-    set_start(flatmap[1]);
-  } else {
-    set_start_unanchored(flatmap[1]);
-    set_start(flatmap[2]);
-  }
-
-  // Finally, replace the old instructions with the new instructions.
-  size_ = static_cast<int>(flat.size());
-  inst_ = PODArray<Inst>(size_);
-  memmove(inst_.data(), flat.data(), size_*sizeof inst_[0]);
-
-  // Populate the list heads for BitState.
-  // 512 instructions limits the memory footprint to 1KiB.
-  if (size_ <= 512) {
-    list_heads_ = PODArray<uint16_t>(size_);
-    // 0xFF makes it more obvious if we try to look up a non-head.
-    memset(list_heads_.data(), 0xFF, size_*sizeof list_heads_[0]);
-    for (int i = 0; i < list_count_; ++i)
-      list_heads_[flatmap[i]] = i;
-  }
-}
-
-void Prog::MarkSuccessors(SparseArray<int>* rootmap,
-                          SparseArray<int>* predmap,
-                          std::vector<std::vector<int>>* predvec,
-                          SparseSet* reachable, std::vector<int>* stk) {
-  // Mark the kInstFail instruction.
-  rootmap->set_new(0, rootmap->size());
-
-  // Mark the start_unanchored and start instructions.
-  if (!rootmap->has_index(start_unanchored()))
-    rootmap->set_new(start_unanchored(), rootmap->size());
-  if (!rootmap->has_index(start()))
-    rootmap->set_new(start(), rootmap->size());
-
-  reachable->clear();
-  stk->clear();
-  stk->push_back(start_unanchored());
-  while (!stk->empty()) {
-    int id = stk->back();
-    stk->pop_back();
-  Loop:
-    if (reachable->contains(id))
-      continue;
-    reachable->insert_new(id);
-
-    Inst* ip = inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstAltMatch:
-      case kInstAlt:
-        // Mark this instruction as a predecessor of each out.
-        for (int out : {ip->out(), ip->out1()}) {
-          if (!predmap->has_index(out)) {
-            predmap->set_new(out, static_cast<int>(predvec->size()));
-            predvec->emplace_back();
-          }
-          (*predvec)[predmap->get_existing(out)].emplace_back(id);
-        }
-        stk->push_back(ip->out1());
-        id = ip->out();
-        goto Loop;
-
-      case kInstByteRange:
-      case kInstCapture:
-      case kInstEmptyWidth:
-        // Mark the out of this instruction as a "root".
-        if (!rootmap->has_index(ip->out()))
-          rootmap->set_new(ip->out(), rootmap->size());
-        id = ip->out();
-        goto Loop;
-
-      case kInstNop:
-        id = ip->out();
-        goto Loop;
-
-      case kInstMatch:
-      case kInstFail:
-        break;
-    }
-  }
-}
-
-void Prog::MarkDominator(int root, SparseArray<int>* rootmap,
-                         SparseArray<int>* predmap,
-                         std::vector<std::vector<int>>* predvec,
-                         SparseSet* reachable, std::vector<int>* stk) {
-  reachable->clear();
-  stk->clear();
-  stk->push_back(root);
-  while (!stk->empty()) {
-    int id = stk->back();
-    stk->pop_back();
-  Loop:
-    if (reachable->contains(id))
-      continue;
-    reachable->insert_new(id);
-
-    if (id != root && rootmap->has_index(id)) {
-      // We reached another "tree" via epsilon transition.
-      continue;
-    }
-
-    Inst* ip = inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstAltMatch:
-      case kInstAlt:
-        stk->push_back(ip->out1());
-        id = ip->out();
-        goto Loop;
-
-      case kInstByteRange:
-      case kInstCapture:
-      case kInstEmptyWidth:
-        break;
-
-      case kInstNop:
-        id = ip->out();
-        goto Loop;
-
-      case kInstMatch:
-      case kInstFail:
-        break;
-    }
-  }
-
-  for (SparseSet::const_iterator i = reachable->begin();
-       i != reachable->end();
-       ++i) {
-    int id = *i;
-    if (predmap->has_index(id)) {
-      for (int pred : (*predvec)[predmap->get_existing(id)]) {
-        if (!reachable->contains(pred)) {
-          // id has a predecessor that cannot be reached from root!
-          // Therefore, id must be a "root" too - mark it as such.
-          if (!rootmap->has_index(id))
-            rootmap->set_new(id, rootmap->size());
-        }
-      }
-    }
-  }
-}
-
-void Prog::EmitList(int root, SparseArray<int>* rootmap,
-                    std::vector<Inst>* flat,
-                    SparseSet* reachable, std::vector<int>* stk) {
-  reachable->clear();
-  stk->clear();
-  stk->push_back(root);
-  while (!stk->empty()) {
-    int id = stk->back();
-    stk->pop_back();
-  Loop:
-    if (reachable->contains(id))
-      continue;
-    reachable->insert_new(id);
-
-    if (id != root && rootmap->has_index(id)) {
-      // We reached another "tree" via epsilon transition. Emit a kInstNop
-      // instruction so that the Prog does not become quadratically larger.
-      flat->emplace_back();
-      flat->back().set_opcode(kInstNop);
-      flat->back().set_out(rootmap->get_existing(id));
-      continue;
-    }
-
-    Inst* ip = inst(id);
-    switch (ip->opcode()) {
-      default:
-        LOG(DFATAL) << "unhandled opcode: " << ip->opcode();
-        break;
-
-      case kInstAltMatch:
-        flat->emplace_back();
-        flat->back().set_opcode(kInstAltMatch);
-        flat->back().set_out(static_cast<int>(flat->size()));
-        flat->back().out1_ = static_cast<uint32_t>(flat->size())+1;
-        FALLTHROUGH_INTENDED;
-
-      case kInstAlt:
-        stk->push_back(ip->out1());
-        id = ip->out();
-        goto Loop;
-
-      case kInstByteRange:
-      case kInstCapture:
-      case kInstEmptyWidth:
-        flat->emplace_back();
-        memmove(&flat->back(), ip, sizeof *ip);
-        flat->back().set_out(rootmap->get_existing(ip->out()));
-        break;
-
-      case kInstNop:
-        id = ip->out();
-        goto Loop;
-
-      case kInstMatch:
-      case kInstFail:
-        flat->emplace_back();
-        memmove(&flat->back(), ip, sizeof *ip);
-        break;
-    }
-  }
-}
-
-// For each ByteRange instruction in [begin, end), computes a hint to execution
-// engines: the delta to the next instruction (in flat) worth exploring iff the
-// current instruction matched.
-//
-// Implements a coloring algorithm related to ByteMapBuilder, but in this case,
-// colors are instructions and recoloring ranges precisely identifies conflicts
-// between instructions. Iterating backwards over [begin, end) is guaranteed to
-// identify the nearest conflict (if any) with only linear complexity.
-void Prog::ComputeHints(std::vector<Inst>* flat, int begin, int end) {
-  Bitmap256 splits;
-  int colors[256];
-
-  bool dirty = false;
-  for (int id = end; id >= begin; --id) {
-    if (id == end ||
-        (*flat)[id].opcode() != kInstByteRange) {
-      if (dirty) {
-        dirty = false;
-        splits.Clear();
-      }
-      splits.Set(255);
-      colors[255] = id;
-      // At this point, the [0-255] range is colored with id.
-      // Thus, hints cannot point beyond id; and if id == end,
-      // hints that would have pointed to id will be 0 instead.
-      continue;
-    }
-    dirty = true;
-
-    // We recolor the [lo-hi] range with id. Note that first ratchets backwards
-    // from end to the nearest conflict (if any) during recoloring.
-    int first = end;
-    auto Recolor = [&](int lo, int hi) {
-      // Like ByteMapBuilder, we split at lo-1 and at hi.
-      --lo;
-
-      if (0 <= lo && !splits.Test(lo)) {
-        splits.Set(lo);
-        int next = splits.FindNextSetBit(lo+1);
-        colors[lo] = colors[next];
-      }
-      if (!splits.Test(hi)) {
-        splits.Set(hi);
-        int next = splits.FindNextSetBit(hi+1);
-        colors[hi] = colors[next];
-      }
-
-      int c = lo+1;
-      while (c < 256) {
-        int next = splits.FindNextSetBit(c);
-        // Ratchet backwards...
-        first = std::min(first, colors[next]);
-        // Recolor with id - because it's the new nearest conflict!
-        colors[next] = id;
-        if (next == hi)
-          break;
-        c = next+1;
-      }
-    };
-
-    Inst* ip = &(*flat)[id];
-    int lo = ip->lo();
-    int hi = ip->hi();
-    Recolor(lo, hi);
-    if (ip->foldcase() && lo <= 'z' && hi >= 'a') {
-      int foldlo = lo;
-      int foldhi = hi;
-      if (foldlo < 'a')
-        foldlo = 'a';
-      if (foldhi > 'z')
-        foldhi = 'z';
-      if (foldlo <= foldhi) {
-        foldlo += 'A' - 'a';
-        foldhi += 'A' - 'a';
-        Recolor(foldlo, foldhi);
-      }
-    }
-
-    if (first != end) {
-      uint16_t hint = static_cast<uint16_t>(std::min(first - id, 32767));
-      ip->inst_byte_range_data_.hint_foldcase_ |= hint<<1;
-    }
-  }
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2003-2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Regular expression interface RE2.
-//
-// Originally the PCRE C++ wrapper, but adapted to use
-// the new automata-based regular expression engines.
-
-
-
-#include <assert.h>
-#include <ctype.h>
-#include <errno.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <algorithm>
-#include <iterator>
-#include <mutex>
-#include <string>
-#include <utility>
-#include <vector>
-
-
-
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-// Maximum number of args we can set
-static const int kMaxArgs = 16;
-static const int kVecSize = 1+kMaxArgs;
-
-const int RE2::Options::kDefaultMaxMem;  // initialized in re2.h
-
-RE2::Options::Options(RE2::CannedOptions opt)
-  : encoding_(opt == RE2::Latin1 ? EncodingLatin1 : EncodingUTF8),
-    posix_syntax_(opt == RE2::POSIX),
-    longest_match_(opt == RE2::POSIX),
-    log_errors_(opt != RE2::Quiet),
-    max_mem_(kDefaultMaxMem),
-    literal_(false),
-    never_nl_(false),
-    dot_nl_(false),
-    never_capture_(false),
-    case_sensitive_(true),
-    perl_classes_(false),
-    word_boundary_(false),
-    one_line_(false) {
-}
-
-// static empty objects for use as const references.
-// To avoid global constructors, allocated in RE2::Init().
-static const std::string* empty_string;
-static const std::map<std::string, int>* empty_named_groups;
-static const std::map<int, std::string>* empty_group_names;
-
-// Converts from Regexp error code to RE2 error code.
-// Maybe some day they will diverge.  In any event, this
-// hides the existence of Regexp from RE2 users.
-static RE2::ErrorCode RegexpErrorToRE2(duckdb_re2::RegexpStatusCode code) {
-  switch (code) {
-    case duckdb_re2::kRegexpSuccess:
-      return RE2::NoError;
-    case duckdb_re2::kRegexpInternalError:
-      return RE2::ErrorInternal;
-    case duckdb_re2::kRegexpBadEscape:
-      return RE2::ErrorBadEscape;
-    case duckdb_re2::kRegexpBadCharClass:
-      return RE2::ErrorBadCharClass;
-    case duckdb_re2::kRegexpBadCharRange:
-      return RE2::ErrorBadCharRange;
-    case duckdb_re2::kRegexpMissingBracket:
-      return RE2::ErrorMissingBracket;
-    case duckdb_re2::kRegexpMissingParen:
-      return RE2::ErrorMissingParen;
-    case duckdb_re2::kRegexpTrailingBackslash:
-      return RE2::ErrorTrailingBackslash;
-    case duckdb_re2::kRegexpRepeatArgument:
-      return RE2::ErrorRepeatArgument;
-    case duckdb_re2::kRegexpRepeatSize:
-      return RE2::ErrorRepeatSize;
-    case duckdb_re2::kRegexpRepeatOp:
-      return RE2::ErrorRepeatOp;
-    case duckdb_re2::kRegexpBadPerlOp:
-      return RE2::ErrorBadPerlOp;
-    case duckdb_re2::kRegexpBadUTF8:
-      return RE2::ErrorBadUTF8;
-    case duckdb_re2::kRegexpBadNamedCapture:
-      return RE2::ErrorBadNamedCapture;
-  }
-  return RE2::ErrorInternal;
-}
-
-static std::string trunc(const StringPiece& pattern) {
-  if (pattern.size() < 100)
-    return std::string(pattern);
-  return std::string(pattern.substr(0, 100)) + "...";
-}
-
-
-RE2::RE2(const char* pattern) {
-  Init(pattern, DefaultOptions);
-}
-
-RE2::RE2(const std::string& pattern) {
-  Init(pattern, DefaultOptions);
-}
-
-RE2::RE2(const StringPiece& pattern) {
-  Init(pattern, DefaultOptions);
-}
-
-RE2::RE2(const StringPiece& pattern, const Options& options) {
-  Init(pattern, options);
-}
-
-int RE2::Options::ParseFlags() const {
-  int flags = Regexp::ClassNL;
-  switch (encoding()) {
-    default:
-      if (log_errors())
-        LOG(ERROR) << "Unknown encoding " << encoding();
-      break;
-    case RE2::Options::EncodingUTF8:
-      break;
-    case RE2::Options::EncodingLatin1:
-      flags |= Regexp::Latin1;
-      break;
-  }
-
-  if (!posix_syntax())
-    flags |= Regexp::LikePerl;
-
-  if (literal())
-    flags |= Regexp::Literal;
-
-  if (never_nl())
-    flags |= Regexp::NeverNL;
-
-  if (dot_nl())
-    flags |= Regexp::DotNL;
-
-  if (never_capture())
-    flags |= Regexp::NeverCapture;
-
-  if (!case_sensitive())
-    flags |= Regexp::FoldCase;
-
-  if (perl_classes())
-    flags |= Regexp::PerlClasses;
-
-  if (word_boundary())
-    flags |= Regexp::PerlB;
-
-  if (one_line())
-    flags |= Regexp::OneLine;
-
-  return flags;
-}
-
-void RE2::Init(const StringPiece& pattern, const Options& options) {
-  static std::once_flag empty_once;
-  std::call_once(empty_once, []() {
-    empty_string = new std::string;
-    empty_named_groups = new std::map<std::string, int>;
-    empty_group_names = new std::map<int, std::string>;
-  });
-
-  pattern_ = std::string(pattern);
-  options_.Copy(options);
-  entire_regexp_ = NULL;
-  suffix_regexp_ = NULL;
-  prog_ = NULL;
-  num_captures_ = -1;
-  rprog_ = NULL;
-  error_ = empty_string;
-  error_code_ = NoError;
-  named_groups_ = NULL;
-  group_names_ = NULL;
-
-  RegexpStatus status;
-  entire_regexp_ = Regexp::Parse(
-    pattern_,
-    static_cast<Regexp::ParseFlags>(options_.ParseFlags()),
-    &status);
-  if (entire_regexp_ == NULL) {
-    if (options_.log_errors()) {
-      LOG(ERROR) << "Error parsing '" << trunc(pattern_) << "': "
-                 << status.Text();
-    }
-    error_ = new std::string(status.Text());
-    error_code_ = RegexpErrorToRE2(status.code());
-    error_arg_ = std::string(status.error_arg());
-    return;
-  }
-
-  duckdb_re2::Regexp* suffix;
-  if (entire_regexp_->RequiredPrefix(&prefix_, &prefix_foldcase_, &suffix))
-    suffix_regexp_ = suffix;
-  else
-    suffix_regexp_ = entire_regexp_->Incref();
-
-  // Two thirds of the memory goes to the forward Prog,
-  // one third to the reverse prog, because the forward
-  // Prog has two DFAs but the reverse prog has one.
-  prog_ = suffix_regexp_->CompileToProg(options_.max_mem()*2/3);
-  if (prog_ == NULL) {
-    if (options_.log_errors())
-      LOG(ERROR) << "Error compiling '" << trunc(pattern_) << "'";
-    error_ = new std::string("pattern too large - compile failed");
-    error_code_ = RE2::ErrorPatternTooLarge;
-    return;
-  }
-
-  // We used to compute this lazily, but it's used during the
-  // typical control flow for a match call, so we now compute
-  // it eagerly, which avoids the overhead of std::once_flag.
-  num_captures_ = suffix_regexp_->NumCaptures();
-
-  // Could delay this until the first match call that
-  // cares about submatch information, but the one-pass
-  // machine's memory gets cut from the DFA memory budget,
-  // and that is harder to do if the DFA has already
-  // been built.
-  is_one_pass_ = prog_->IsOnePass();
-}
-
-// Returns rprog_, computing it if needed.
-duckdb_re2::Prog* RE2::ReverseProg() const {
-  std::call_once(rprog_once_, [](const RE2* re) {
-    re->rprog_ =
-        re->suffix_regexp_->CompileToReverseProg(re->options_.max_mem() / 3);
-    if (re->rprog_ == NULL) {
-      if (re->options_.log_errors())
-        LOG(ERROR) << "Error reverse compiling '" << trunc(re->pattern_) << "'";
-      re->error_ =
-          new std::string("pattern too large - reverse compile failed");
-      re->error_code_ = RE2::ErrorPatternTooLarge;
-    }
-  }, this);
-  return rprog_;
-}
-
-RE2::~RE2() {
-  if (suffix_regexp_)
-    suffix_regexp_->Decref();
-  if (entire_regexp_)
-    entire_regexp_->Decref();
-  delete prog_;
-  delete rprog_;
-  if (error_ != empty_string)
-    delete error_;
-  if (named_groups_ != NULL && named_groups_ != empty_named_groups)
-    delete named_groups_;
-  if (group_names_ != NULL &&  group_names_ != empty_group_names)
-    delete group_names_;
-}
-
-int RE2::ProgramSize() const {
-  if (prog_ == NULL)
-    return -1;
-  return prog_->size();
-}
-
-int RE2::ReverseProgramSize() const {
-  if (prog_ == NULL)
-    return -1;
-  Prog* prog = ReverseProg();
-  if (prog == NULL)
-    return -1;
-  return prog->size();
-}
-
-static int Fanout(Prog* prog, std::map<int, int>* histogram) {
-  SparseArray<int> fanout(prog->size());
-  prog->Fanout(&fanout);
-  histogram->clear();
-  for (SparseArray<int>::iterator i = fanout.begin(); i != fanout.end(); ++i) {
-    // TODO(junyer): Optimise this?
-    int bucket = 0;
-    while (1 << bucket < i->value()) {
-      bucket++;
-    }
-    (*histogram)[bucket]++;
-  }
-  return histogram->rbegin()->first;
-}
-
-int RE2::ProgramFanout(std::map<int, int>* histogram) const {
-  if (prog_ == NULL)
-    return -1;
-  return Fanout(prog_, histogram);
-}
-
-int RE2::ReverseProgramFanout(std::map<int, int>* histogram) const {
-  if (prog_ == NULL)
-    return -1;
-  Prog* prog = ReverseProg();
-  if (prog == NULL)
-    return -1;
-  return Fanout(prog, histogram);
-}
-
-// Returns named_groups_, computing it if needed.
-const std::map<std::string, int>& RE2::NamedCapturingGroups() const {
-  std::call_once(named_groups_once_, [](const RE2* re) {
-    if (re->suffix_regexp_ != NULL)
-      re->named_groups_ = re->suffix_regexp_->NamedCaptures();
-    if (re->named_groups_ == NULL)
-      re->named_groups_ = empty_named_groups;
-  }, this);
-  return *named_groups_;
-}
-
-// Returns group_names_, computing it if needed.
-const std::map<int, std::string>& RE2::CapturingGroupNames() const {
-  std::call_once(group_names_once_, [](const RE2* re) {
-    if (re->suffix_regexp_ != NULL)
-      re->group_names_ = re->suffix_regexp_->CaptureNames();
-    if (re->group_names_ == NULL)
-      re->group_names_ = empty_group_names;
-  }, this);
-  return *group_names_;
-}
-
-/***** Convenience interfaces *****/
-
-bool RE2::FullMatchN(const StringPiece& text, const RE2& re,
-                     const Arg* const args[], int n) {
-  return re.DoMatch(text, ANCHOR_BOTH, NULL, args, n);
-}
-
-bool RE2::PartialMatchN(const StringPiece& text, const RE2& re,
-                        const Arg* const args[], int n) {
-  return re.DoMatch(text, UNANCHORED, NULL, args, n);
-}
-
-bool RE2::ConsumeN(StringPiece* input, const RE2& re,
-                   const Arg* const args[], int n) {
-  size_t consumed;
-  if (re.DoMatch(*input, ANCHOR_START, &consumed, args, n)) {
-    input->remove_prefix(consumed);
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool RE2::FindAndConsumeN(StringPiece* input, const RE2& re,
-                          const Arg* const args[], int n) {
-  size_t consumed;
-  if (re.DoMatch(*input, UNANCHORED, &consumed, args, n)) {
-    input->remove_prefix(consumed);
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool RE2::Replace(std::string* str,
-                  const RE2& re,
-                  const StringPiece& rewrite) {
-  StringPiece vec[kVecSize];
-  int nvec = 1 + MaxSubmatch(rewrite);
-  if (nvec > arraysize(vec))
-    return false;
-  if (!re.Match(*str, 0, str->size(), UNANCHORED, vec, nvec))
-    return false;
-
-  std::string s;
-  if (!re.Rewrite(&s, rewrite, vec, nvec))
-    return false;
-
-  assert(vec[0].begin() >= str->data());
-  assert(vec[0].end() <= str->data()+str->size());
-  str->replace(vec[0].data() - str->data(), vec[0].size(), s);
-  return true;
-}
-
-int RE2::GlobalReplace(std::string* str,
-                       const RE2& re,
-                       const StringPiece& rewrite) {
-  StringPiece vec[kVecSize];
-  int nvec = 1 + MaxSubmatch(rewrite);
-  if (nvec > arraysize(vec))
-    return false;
-
-  const char* p = str->data();
-  const char* ep = p + str->size();
-  const char* lastend = NULL;
-  std::string out;
-  int count = 0;
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  // Iterate just once when fuzzing. Otherwise, we easily get bogged down
-  // and coverage is unlikely to improve despite significant expense.
-  while (p == str->data()) {
-#else
-  while (p <= ep) {
-#endif
-    if (!re.Match(*str, static_cast<size_t>(p - str->data()),
-                  str->size(), UNANCHORED, vec, nvec))
-      break;
-    if (p < vec[0].begin())
-      out.append(p, vec[0].begin() - p);
-    if (vec[0].begin() == lastend && vec[0].size() == 0) {
-      // Disallow empty match at end of last match: skip ahead.
-      //
-      // fullrune() takes int, not ptrdiff_t. However, it just looks
-      // at the leading byte and treats any length >= 4 the same.
-      if (re.options().encoding() == RE2::Options::EncodingUTF8 &&
-          fullrune(p, static_cast<int>(std::min(ptrdiff_t{4}, ep - p)))) {
-        // re is in UTF-8 mode and there is enough left of str
-        // to allow us to advance by up to UTFmax bytes.
-        Rune r;
-        int n = chartorune(&r, p);
-        // Some copies of chartorune have a bug that accepts
-        // encodings of values in (10FFFF, 1FFFFF] as valid.
-        if (r > Runemax) {
-          n = 1;
-          r = Runeerror;
-        }
-        if (!(n == 1 && r == Runeerror)) {  // no decoding error
-          out.append(p, n);
-          p += n;
-          continue;
-        }
-      }
-      // Most likely, re is in Latin-1 mode. If it is in UTF-8 mode,
-      // we fell through from above and the GIGO principle applies.
-      if (p < ep)
-        out.append(p, 1);
-      p++;
-      continue;
-    }
-    re.Rewrite(&out, rewrite, vec, nvec);
-    p = vec[0].end();
-    lastend = p;
-    count++;
-  }
-
-  if (count == 0)
-    return 0;
-
-  if (p < ep)
-    out.append(p, ep - p);
-  using std::swap;
-  swap(out, *str);
-  return count;
-}
-
-bool RE2::Extract(const StringPiece& text,
-                  const RE2& re,
-                  const StringPiece& rewrite,
-                  std::string* out) {
-  StringPiece vec[kVecSize];
-  int nvec = 1 + MaxSubmatch(rewrite);
-  if (nvec > arraysize(vec))
-    return false;
-
-  if (!re.Match(text, 0, text.size(), UNANCHORED, vec, nvec))
-    return false;
-
-  out->clear();
-  return re.Rewrite(out, rewrite, vec, nvec);
-}
-
-std::string RE2::QuoteMeta(const StringPiece& unquoted) {
-  std::string result;
-  result.reserve(unquoted.size() << 1);
-
-  // Escape any ascii character not in [A-Za-z_0-9].
-  //
-  // Note that it's legal to escape a character even if it has no
-  // special meaning in a regular expression -- so this function does
-  // that.  (This also makes it identical to the perl function of the
-  // same name except for the null-character special case;
-  // see `perldoc -f quotemeta`.)
-  for (size_t ii = 0; ii < unquoted.size(); ++ii) {
-    // Note that using 'isalnum' here raises the benchmark time from
-    // 32ns to 58ns:
-    if ((unquoted[ii] < 'a' || unquoted[ii] > 'z') &&
-        (unquoted[ii] < 'A' || unquoted[ii] > 'Z') &&
-        (unquoted[ii] < '0' || unquoted[ii] > '9') &&
-        unquoted[ii] != '_' &&
-        // If this is the part of a UTF8 or Latin1 character, we need
-        // to copy this byte without escaping.  Experimentally this is
-        // what works correctly with the regexp library.
-        !(unquoted[ii] & 128)) {
-      if (unquoted[ii] == '\0') {  // Special handling for null chars.
-        // Note that this special handling is not strictly required for RE2,
-        // but this quoting is required for other regexp libraries such as
-        // PCRE.
-        // Can't use "\\0" since the next character might be a digit.
-        result += "\\x00";
-        continue;
-      }
-      result += '\\';
-    }
-    result += unquoted[ii];
-  }
-
-  return result;
-}
-
-bool RE2::PossibleMatchRange(std::string* min, std::string* max,
-                             int maxlen) const {
-  if (prog_ == NULL)
-    return false;
-
-  int n = static_cast<int>(prefix_.size());
-  if (n > maxlen)
-    n = maxlen;
-
-  // Determine initial min max from prefix_ literal.
-  *min = prefix_.substr(0, n);
-  *max = prefix_.substr(0, n);
-  if (prefix_foldcase_) {
-    // prefix is ASCII lowercase; change *min to uppercase.
-    for (int i = 0; i < n; i++) {
-      char& c = (*min)[i];
-      if ('a' <= c && c <= 'z')
-        c += 'A' - 'a';
-    }
-  }
-
-  // Add to prefix min max using PossibleMatchRange on regexp.
-  std::string dmin, dmax;
-  maxlen -= n;
-  if (maxlen > 0 && prog_->PossibleMatchRange(&dmin, &dmax, maxlen)) {
-    min->append(dmin);
-    max->append(dmax);
-  } else if (!max->empty()) {
-    // prog_->PossibleMatchRange has failed us,
-    // but we still have useful information from prefix_.
-    // Round up *max to allow any possible suffix.
-    PrefixSuccessor(max);
-  } else {
-    // Nothing useful.
-    *min = "";
-    *max = "";
-    return false;
-  }
-
-  return true;
-}
-
-// Avoid possible locale nonsense in standard strcasecmp.
-// The string a is known to be all lowercase.
-static int ascii_strcasecmp(const char* a, const char* b, size_t len) {
-  const char* ae = a + len;
-
-  for (; a < ae; a++, b++) {
-    uint8_t x = *a;
-    uint8_t y = *b;
-    if ('A' <= y && y <= 'Z')
-      y += 'a' - 'A';
-    if (x != y)
-      return x - y;
-  }
-  return 0;
-}
-
-
-/***** Actual matching and rewriting code *****/
-
-bool RE2::Match(const StringPiece& text,
-                size_t startpos,
-                size_t endpos,
-                Anchor re_anchor,
-                StringPiece* submatch,
-                int nsubmatch) const {
-  if (!ok()) {
-    if (options_.log_errors())
-      LOG(ERROR) << "Invalid RE2: " << *error_;
-    return false;
-  }
-
-  if (startpos > endpos || endpos > text.size()) {
-    if (options_.log_errors())
-      LOG(ERROR) << "RE2: invalid startpos, endpos pair. ["
-                 << "startpos: " << startpos << ", "
-                 << "endpos: " << endpos << ", "
-                 << "text size: " << text.size() << "]";
-    return false;
-  }
-
-  StringPiece subtext = text;
-  subtext.remove_prefix(startpos);
-  subtext.remove_suffix(text.size() - endpos);
-
-  // Use DFAs to find exact location of match, filter out non-matches.
-
-  // Don't ask for the location if we won't use it.
-  // SearchDFA can do extra optimizations in that case.
-  StringPiece match;
-  StringPiece* matchp = &match;
-  if (nsubmatch == 0)
-    matchp = NULL;
-
-  int ncap = 1 + NumberOfCapturingGroups();
-  if (ncap > nsubmatch)
-    ncap = nsubmatch;
-
-  // If the regexp is anchored explicitly, must not be in middle of text.
-  if (prog_->anchor_start() && startpos != 0)
-    return false;
-
-  // If the regexp is anchored explicitly, update re_anchor
-  // so that we can potentially fall into a faster case below.
-  if (prog_->anchor_start() && prog_->anchor_end())
-    re_anchor = ANCHOR_BOTH;
-  else if (prog_->anchor_start() && re_anchor != ANCHOR_BOTH)
-    re_anchor = ANCHOR_START;
-
-  // Check for the required prefix, if any.
-  size_t prefixlen = 0;
-  if (!prefix_.empty()) {
-    if (startpos != 0)
-      return false;
-    prefixlen = prefix_.size();
-    if (prefixlen > subtext.size())
-      return false;
-    if (prefix_foldcase_) {
-      if (ascii_strcasecmp(&prefix_[0], subtext.data(), prefixlen) != 0)
-        return false;
-    } else {
-      if (memcmp(&prefix_[0], subtext.data(), prefixlen) != 0)
-        return false;
-    }
-    subtext.remove_prefix(prefixlen);
-    // If there is a required prefix, the anchor must be at least ANCHOR_START.
-    if (re_anchor != ANCHOR_BOTH)
-      re_anchor = ANCHOR_START;
-  }
-
-  Prog::Anchor anchor = Prog::kUnanchored;
-  Prog::MatchKind kind = Prog::kFirstMatch;
-  if (options_.longest_match())
-    kind = Prog::kLongestMatch;
-  bool skipped_test = false;
-
-  bool can_one_pass = (is_one_pass_ && ncap <= Prog::kMaxOnePassCapture);
-
-  // BitState allocates a bitmap of size prog_->list_count() * text.size().
-  // It also allocates a stack of 3-word structures which could potentially
-  // grow as large as prog_->list_count() * text.size(), but in practice is
-  // much smaller.
-  const int kMaxBitStateBitmapSize = 256*1024;  // bitmap size <= max (bits)
-  bool can_bit_state = prog_->CanBitState();
-  size_t bit_state_text_max = kMaxBitStateBitmapSize / prog_->list_count();
-
-  bool dfa_failed = false;
-  switch (re_anchor) {
-    default:
-    case UNANCHORED: {
-      if (!prog_->SearchDFA(subtext, text, anchor, kind,
-                            matchp, &dfa_failed, NULL)) {
-        if (dfa_failed) {
-          if (options_.log_errors())
-            LOG(ERROR) << "DFA out of memory: size " << prog_->size() << ", "
-                       << "bytemap range " << prog_->bytemap_range() << ", "
-                       << "list count " << prog_->list_count();
-          // Fall back to NFA below.
-          skipped_test = true;
-          break;
-        }
-        return false;
-      }
-      if (matchp == NULL)  // Matched.  Don't care where
-        return true;
-      // SearchDFA set match[0].end() but didn't know where the
-      // match started.  Run the regexp backward from match[0].end()
-      // to find the longest possible match -- that's where it started.
-      Prog* prog = ReverseProg();
-      if (prog == NULL)
-        return false;
-      if (!prog->SearchDFA(match, text, Prog::kAnchored,
-                           Prog::kLongestMatch, &match, &dfa_failed, NULL)) {
-        if (dfa_failed) {
-          if (options_.log_errors())
-            LOG(ERROR) << "DFA out of memory: size " << prog->size() << ", "
-                       << "bytemap range " << prog->bytemap_range() << ", "
-                       << "list count " << prog->list_count();
-          // Fall back to NFA below.
-          skipped_test = true;
-          break;
-        }
-        if (options_.log_errors())
-          LOG(ERROR) << "SearchDFA inconsistency";
-        return false;
-      }
-      break;
-    }
-
-    case ANCHOR_BOTH:
-    case ANCHOR_START:
-      if (re_anchor == ANCHOR_BOTH)
-        kind = Prog::kFullMatch;
-      anchor = Prog::kAnchored;
-
-      // If only a small amount of text and need submatch
-      // information anyway and we're going to use OnePass or BitState
-      // to get it, we might as well not even bother with the DFA:
-      // OnePass or BitState will be fast enough.
-      // On tiny texts, OnePass outruns even the DFA, and
-      // it doesn't have the shared state and occasional mutex that
-      // the DFA does.
-      if (can_one_pass && text.size() <= 4096 &&
-          (ncap > 1 || text.size() <= 8)) {
-        skipped_test = true;
-        break;
-      }
-      if (can_bit_state && text.size() <= bit_state_text_max && ncap > 1) {
-        skipped_test = true;
-        break;
-      }
-      if (!prog_->SearchDFA(subtext, text, anchor, kind,
-                            &match, &dfa_failed, NULL)) {
-        if (dfa_failed) {
-          if (options_.log_errors())
-            LOG(ERROR) << "DFA out of memory: size " << prog_->size() << ", "
-                       << "bytemap range " << prog_->bytemap_range() << ", "
-                       << "list count " << prog_->list_count();
-          // Fall back to NFA below.
-          skipped_test = true;
-          break;
-        }
-        return false;
-      }
-      break;
-  }
-
-  if (!skipped_test && ncap <= 1) {
-    // We know exactly where it matches.  That's enough.
-    if (ncap == 1)
-      submatch[0] = match;
-  } else {
-    StringPiece subtext1;
-    if (skipped_test) {
-      // DFA ran out of memory or was skipped:
-      // need to search in entire original text.
-      subtext1 = subtext;
-    } else {
-      // DFA found the exact match location:
-      // let NFA run an anchored, full match search
-      // to find submatch locations.
-      subtext1 = match;
-      anchor = Prog::kAnchored;
-      kind = Prog::kFullMatch;
-    }
-
-    if (can_one_pass && anchor != Prog::kUnanchored) {
-      if (!prog_->SearchOnePass(subtext1, text, anchor, kind, submatch, ncap)) {
-        if (!skipped_test && options_.log_errors())
-          LOG(ERROR) << "SearchOnePass inconsistency";
-        return false;
-      }
-    } else if (can_bit_state && subtext1.size() <= bit_state_text_max) {
-      if (!prog_->SearchBitState(subtext1, text, anchor,
-                                 kind, submatch, ncap)) {
-        if (!skipped_test && options_.log_errors())
-          LOG(ERROR) << "SearchBitState inconsistency";
-        return false;
-      }
-    } else {
-      if (!prog_->SearchNFA(subtext1, text, anchor, kind, submatch, ncap)) {
-        if (!skipped_test && options_.log_errors())
-          LOG(ERROR) << "SearchNFA inconsistency";
-        return false;
-      }
-    }
-  }
-
-  // Adjust overall match for required prefix that we stripped off.
-  if (prefixlen > 0 && nsubmatch > 0)
-    submatch[0] = StringPiece(submatch[0].data() - prefixlen,
-                              submatch[0].size() + prefixlen);
-
-  // Zero submatches that don't exist in the regexp.
-  for (int i = ncap; i < nsubmatch; i++)
-    submatch[i] = StringPiece();
-  return true;
-}
-
-// Internal matcher - like Match() but takes Args not StringPieces.
-bool RE2::DoMatch(const StringPiece& text,
-                  Anchor re_anchor,
-                  size_t* consumed,
-                  const Arg* const* args,
-                  int n) const {
-  if (!ok()) {
-    if (options_.log_errors())
-      LOG(ERROR) << "Invalid RE2: " << *error_;
-    return false;
-  }
-
-  if (NumberOfCapturingGroups() < n) {
-    // RE has fewer capturing groups than number of Arg pointers passed in.
-    return false;
-  }
-
-  // Count number of capture groups needed.
-  int nvec;
-  if (n == 0 && consumed == NULL)
-    nvec = 0;
-  else
-    nvec = n+1;
-
-  StringPiece* vec;
-  StringPiece stkvec[kVecSize];
-  StringPiece* heapvec = NULL;
-
-  if (nvec <= arraysize(stkvec)) {
-    vec = stkvec;
-  } else {
-    vec = new StringPiece[nvec];
-    heapvec = vec;
-  }
-
-  if (!Match(text, 0, text.size(), re_anchor, vec, nvec)) {
-    delete[] heapvec;
-    return false;
-  }
-
-  if (consumed != NULL)
-    *consumed = static_cast<size_t>(vec[0].end() - text.begin());
-
-  if (n == 0 || args == NULL) {
-    // We are not interested in results
-    delete[] heapvec;
-    return true;
-  }
-
-  // If we got here, we must have matched the whole pattern.
-  for (int i = 0; i < n; i++) {
-    const StringPiece& s = vec[i+1];
-    if (!args[i]->Parse(s.data(), s.size())) {
-      // TODO: Should we indicate what the error was?
-      delete[] heapvec;
-      return false;
-    }
-  }
-
-  delete[] heapvec;
-  return true;
-}
-
-// Checks that the rewrite string is well-formed with respect to this
-// regular expression.
-bool RE2::CheckRewriteString(const StringPiece& rewrite,
-                             std::string* error) const {
-  int max_token = -1;
-  for (const char *s = rewrite.data(), *end = s + rewrite.size();
-       s < end; s++) {
-    int c = *s;
-    if (c != '\\') {
-      continue;
-    }
-    if (++s == end) {
-      *error = "Rewrite schema error: '\\' not allowed at end.";
-      return false;
-    }
-    c = *s;
-    if (c == '\\') {
-      continue;
-    }
-    if (!isdigit(c)) {
-      *error = "Rewrite schema error: "
-               "'\\' must be followed by a digit or '\\'.";
-      return false;
-    }
-    int n = (c - '0');
-    if (max_token < n) {
-      max_token = n;
-    }
-  }
-
-  if (max_token > NumberOfCapturingGroups()) {
-    SStringPrintf(error, "Rewrite schema requests %d matches, "
-                  "but the regexp only has %d parenthesized subexpressions.",
-                  max_token, NumberOfCapturingGroups());
-    return false;
-  }
-  return true;
-}
-
-// Returns the maximum submatch needed for the rewrite to be done by Replace().
-// E.g. if rewrite == "foo \\2,\\1", returns 2.
-int RE2::MaxSubmatch(const StringPiece& rewrite) {
-  int max = 0;
-  for (const char *s = rewrite.data(), *end = s + rewrite.size();
-       s < end; s++) {
-    if (*s == '\\') {
-      s++;
-      int c = (s < end) ? *s : -1;
-      if (isdigit(c)) {
-        int n = (c - '0');
-        if (n > max)
-          max = n;
-      }
-    }
-  }
-  return max;
-}
-
-// Append the "rewrite" string, with backslash subsitutions from "vec",
-// to string "out".
-bool RE2::Rewrite(std::string* out,
-                  const StringPiece& rewrite,
-                  const StringPiece* vec,
-                  int veclen) const {
-  for (const char *s = rewrite.data(), *end = s + rewrite.size();
-       s < end; s++) {
-    if (*s != '\\') {
-      out->push_back(*s);
-      continue;
-    }
-    s++;
-    int c = (s < end) ? *s : -1;
-    if (isdigit(c)) {
-      int n = (c - '0');
-      if (n >= veclen) {
-        if (options_.log_errors()) {
-          LOG(ERROR) << "requested group " << n
-                     << " in regexp " << rewrite.data();
-        }
-        return false;
-      }
-      StringPiece snip = vec[n];
-      if (snip.size() > 0)
-        out->append(snip.data(), snip.size());
-    } else if (c == '\\') {
-      out->push_back('\\');
-    } else {
-      if (options_.log_errors())
-        LOG(ERROR) << "invalid rewrite pattern: " << rewrite.data();
-      return false;
-    }
-  }
-  return true;
-}
-
-/***** Parsers for various types *****/
-
-bool RE2::Arg::parse_null(const char* str, size_t n, void* dest) {
-  // We fail if somebody asked us to store into a non-NULL void* pointer
-  return (dest == NULL);
-}
-
-bool RE2::Arg::parse_string(const char* str, size_t n, void* dest) {
-  if (dest == NULL) return true;
-  reinterpret_cast<std::string*>(dest)->assign(str, n);
-  return true;
-}
-
-bool RE2::Arg::parse_stringpiece(const char* str, size_t n, void* dest) {
-  if (dest == NULL) return true;
-  *(reinterpret_cast<StringPiece*>(dest)) = StringPiece(str, n);
-  return true;
-}
-
-bool RE2::Arg::parse_char(const char* str, size_t n, void* dest) {
-  if (n != 1) return false;
-  if (dest == NULL) return true;
-  *(reinterpret_cast<char*>(dest)) = str[0];
-  return true;
-}
-
-bool RE2::Arg::parse_schar(const char* str, size_t n, void* dest) {
-  if (n != 1) return false;
-  if (dest == NULL) return true;
-  *(reinterpret_cast<signed char*>(dest)) = str[0];
-  return true;
-}
-
-bool RE2::Arg::parse_uchar(const char* str, size_t n, void* dest) {
-  if (n != 1) return false;
-  if (dest == NULL) return true;
-  *(reinterpret_cast<unsigned char*>(dest)) = str[0];
-  return true;
-}
-
-// Largest number spec that we are willing to parse
-static const int kMaxNumberLength = 32;
-
-// REQUIRES "buf" must have length at least nbuf.
-// Copies "str" into "buf" and null-terminates.
-// Overwrites *np with the new length.
-static const char* TerminateNumber(char* buf, size_t nbuf, const char* str,
-                                   size_t* np, bool accept_spaces) {
-  size_t n = *np;
-  if (n == 0) return "";
-  if (n > 0 && isspace(*str)) {
-    // We are less forgiving than the strtoxxx() routines and do not
-    // allow leading spaces. We do allow leading spaces for floats.
-    if (!accept_spaces) {
-      return "";
-    }
-    while (n > 0 && isspace(*str)) {
-      n--;
-      str++;
-    }
-  }
-
-  // Although buf has a fixed maximum size, we can still handle
-  // arbitrarily large integers correctly by omitting leading zeros.
-  // (Numbers that are still too long will be out of range.)
-  // Before deciding whether str is too long,
-  // remove leading zeros with s/000+/00/.
-  // Leaving the leading two zeros in place means that
-  // we don't change 0000x123 (invalid) into 0x123 (valid).
-  // Skip over leading - before replacing.
-  bool neg = false;
-  if (n >= 1 && str[0] == '-') {
-    neg = true;
-    n--;
-    str++;
-  }
-
-  if (n >= 3 && str[0] == '0' && str[1] == '0') {
-    while (n >= 3 && str[2] == '0') {
-      n--;
-      str++;
-    }
-  }
-
-  if (neg) {  // make room in buf for -
-    n++;
-    str--;
-  }
-
-  if (n > nbuf-1) return "";
-
-  memmove(buf, str, n);
-  if (neg) {
-    buf[0] = '-';
-  }
-  buf[n] = '\0';
-  *np = n;
-  return buf;
-}
-
-bool RE2::Arg::parse_long_radix(const char* str,
-                                size_t n,
-                                void* dest,
-                                int radix) {
-  if (n == 0) return false;
-  char buf[kMaxNumberLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, false);
-  char* end;
-  errno = 0;
-  long r = strtol(str, &end, radix);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *(reinterpret_cast<long*>(dest)) = r;
-  return true;
-}
-
-bool RE2::Arg::parse_ulong_radix(const char* str,
-                                 size_t n,
-                                 void* dest,
-                                 int radix) {
-  if (n == 0) return false;
-  char buf[kMaxNumberLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, false);
-  if (str[0] == '-') {
-    // strtoul() will silently accept negative numbers and parse
-    // them.  This module is more strict and treats them as errors.
-    return false;
-  }
-
-  char* end;
-  errno = 0;
-  unsigned long r = strtoul(str, &end, radix);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *(reinterpret_cast<unsigned long*>(dest)) = r;
-  return true;
-}
-
-bool RE2::Arg::parse_short_radix(const char* str,
-                                 size_t n,
-                                 void* dest,
-                                 int radix) {
-  long r;
-  if (!parse_long_radix(str, n, &r, radix)) return false;  // Could not parse
-  if ((short)r != r) return false;                         // Out of range
-  if (dest == NULL) return true;
-  *(reinterpret_cast<short*>(dest)) = (short)r;
-  return true;
-}
-
-bool RE2::Arg::parse_ushort_radix(const char* str,
-                                  size_t n,
-                                  void* dest,
-                                  int radix) {
-  unsigned long r;
-  if (!parse_ulong_radix(str, n, &r, radix)) return false;  // Could not parse
-  if ((unsigned short)r != r) return false;                 // Out of range
-  if (dest == NULL) return true;
-  *(reinterpret_cast<unsigned short*>(dest)) = (unsigned short)r;
-  return true;
-}
-
-bool RE2::Arg::parse_int_radix(const char* str,
-                               size_t n,
-                               void* dest,
-                               int radix) {
-  long r;
-  if (!parse_long_radix(str, n, &r, radix)) return false;  // Could not parse
-  if ((int)r != r) return false;                           // Out of range
-  if (dest == NULL) return true;
-  *(reinterpret_cast<int*>(dest)) = (int)r;
-  return true;
-}
-
-bool RE2::Arg::parse_uint_radix(const char* str,
-                                size_t n,
-                                void* dest,
-                                int radix) {
-  unsigned long r;
-  if (!parse_ulong_radix(str, n, &r, radix)) return false;  // Could not parse
-  if ((unsigned int)r != r) return false;                   // Out of range
-  if (dest == NULL) return true;
-  *(reinterpret_cast<unsigned int*>(dest)) = (unsigned int)r;
-  return true;
-}
-
-bool RE2::Arg::parse_longlong_radix(const char* str,
-                                    size_t n,
-                                    void* dest,
-                                    int radix) {
-  if (n == 0) return false;
-  char buf[kMaxNumberLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, false);
-  char* end;
-  errno = 0;
-  long long r = strtoll(str, &end, radix);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *(reinterpret_cast<long long*>(dest)) = r;
-  return true;
-}
-
-bool RE2::Arg::parse_ulonglong_radix(const char* str,
-                                     size_t n,
-                                     void* dest,
-                                     int radix) {
-  if (n == 0) return false;
-  char buf[kMaxNumberLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, false);
-  if (str[0] == '-') {
-    // strtoull() will silently accept negative numbers and parse
-    // them.  This module is more strict and treats them as errors.
-    return false;
-  }
-  char* end;
-  errno = 0;
-  unsigned long long r = strtoull(str, &end, radix);
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  *(reinterpret_cast<unsigned long long*>(dest)) = r;
-  return true;
-}
-
-static bool parse_double_float(const char* str, size_t n, bool isfloat,
-                               void* dest) {
-  if (n == 0) return false;
-  static const int kMaxLength = 200;
-  char buf[kMaxLength+1];
-  str = TerminateNumber(buf, sizeof buf, str, &n, true);
-  char* end;
-  errno = 0;
-  double r;
-  if (isfloat) {
-    r = strtof(str, &end);
-  } else {
-    r = strtod(str, &end);
-  }
-  if (end != str + n) return false;   // Leftover junk
-  if (errno) return false;
-  if (dest == NULL) return true;
-  if (isfloat) {
-    *(reinterpret_cast<float*>(dest)) = (float)r;
-  } else {
-    *(reinterpret_cast<double*>(dest)) = r;
-  }
-  return true;
-}
-
-bool RE2::Arg::parse_double(const char* str, size_t n, void* dest) {
-  return parse_double_float(str, n, false, dest);
-}
-
-bool RE2::Arg::parse_float(const char* str, size_t n, void* dest) {
-  return parse_double_float(str, n, true, dest);
-}
-
-#define DEFINE_INTEGER_PARSER(name)                                            \
-  bool RE2::Arg::parse_##name(const char* str, size_t n, void* dest) {         \
-    return parse_##name##_radix(str, n, dest, 10);                             \
-  }                                                                            \
-  bool RE2::Arg::parse_##name##_hex(const char* str, size_t n, void* dest) {   \
-    return parse_##name##_radix(str, n, dest, 16);                             \
-  }                                                                            \
-  bool RE2::Arg::parse_##name##_octal(const char* str, size_t n, void* dest) { \
-    return parse_##name##_radix(str, n, dest, 8);                              \
-  }                                                                            \
-  bool RE2::Arg::parse_##name##_cradix(const char* str, size_t n,              \
-                                       void* dest) {                           \
-    return parse_##name##_radix(str, n, dest, 0);                              \
-  }
-
-DEFINE_INTEGER_PARSER(short)
-DEFINE_INTEGER_PARSER(ushort)
-DEFINE_INTEGER_PARSER(int)
-DEFINE_INTEGER_PARSER(uint)
-DEFINE_INTEGER_PARSER(long)
-DEFINE_INTEGER_PARSER(ulong)
-DEFINE_INTEGER_PARSER(longlong)
-DEFINE_INTEGER_PARSER(ulonglong)
-
-#undef DEFINE_INTEGER_PARSER
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Regular expression representation.
-// Tested by parse_test.cc
-
-
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-#include <algorithm>
-#include <map>
-#include <mutex>
-#include <string>
-#include <vector>
-
-
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-// Constructor.  Allocates vectors as appropriate for operator.
-Regexp::Regexp(RegexpOp op, ParseFlags parse_flags)
-  : op_(static_cast<uint8_t>(op)),
-    simple_(false),
-    parse_flags_(static_cast<uint16_t>(parse_flags)),
-    ref_(1),
-    nsub_(0),
-    down_(NULL) {
-  subone_ = NULL;
-  memset(the_union_, 0, sizeof the_union_);
-}
-
-// Destructor.  Assumes already cleaned up children.
-// Private: use Decref() instead of delete to destroy Regexps.
-// Can't call Decref on the sub-Regexps here because
-// that could cause arbitrarily deep recursion, so
-// required Decref() to have handled them for us.
-Regexp::~Regexp() {
-  if (nsub_ > 0)
-    LOG(DFATAL) << "Regexp not destroyed.";
-
-  switch (op_) {
-    default:
-      break;
-    case kRegexpCapture:
-      delete capture_.name_;
-      break;
-    case kRegexpLiteralString:
-      delete[] literal_string_.runes_;
-      break;
-    case kRegexpCharClass:
-      if (char_class_.cc_)
-          char_class_.cc_->Delete();
-      delete char_class_.ccb_;
-      break;
-  }
-}
-
-// If it's possible to destroy this regexp without recurring,
-// do so and return true.  Else return false.
-bool Regexp::QuickDestroy() {
-  if (nsub_ == 0) {
-    delete this;
-    return true;
-  }
-  return false;
-}
-
-// Lazily allocated.
-static Mutex* ref_mutex;
-static std::map<Regexp*, int>* ref_map;
-
-int Regexp::Ref() {
-  if (ref_ < kMaxRef)
-    return ref_;
-
-  MutexLock l(ref_mutex);
-  return (*ref_map)[this];
-}
-
-// Increments reference count, returns object as convenience.
-Regexp* Regexp::Incref() {
-  if (ref_ >= kMaxRef-1) {
-    static std::once_flag ref_once;
-    std::call_once(ref_once, []() {
-      ref_mutex = new Mutex;
-      ref_map = new std::map<Regexp*, int>;
-    });
-
-    // Store ref count in overflow map.
-    MutexLock l(ref_mutex);
-    if (ref_ == kMaxRef) {
-      // already overflowed
-      (*ref_map)[this]++;
-    } else {
-      // overflowing now
-      (*ref_map)[this] = kMaxRef;
-      ref_ = kMaxRef;
-    }
-    return this;
-  }
-
-  ref_++;
-  return this;
-}
-
-// Decrements reference count and deletes this object if count reaches 0.
-void Regexp::Decref() {
-  if (ref_ == kMaxRef) {
-    // Ref count is stored in overflow map.
-    MutexLock l(ref_mutex);
-    int r = (*ref_map)[this] - 1;
-    if (r < kMaxRef) {
-      ref_ = static_cast<uint16_t>(r);
-      ref_map->erase(this);
-    } else {
-      (*ref_map)[this] = r;
-    }
-    return;
-  }
-  ref_--;
-  if (ref_ == 0)
-    Destroy();
-}
-
-// Deletes this object; ref count has count reached 0.
-void Regexp::Destroy() {
-  if (QuickDestroy())
-    return;
-
-  // Handle recursive Destroy with explicit stack
-  // to avoid arbitrarily deep recursion on process stack [sigh].
-  down_ = NULL;
-  Regexp* stack = this;
-  while (stack != NULL) {
-    Regexp* re = stack;
-    stack = re->down_;
-    if (re->ref_ != 0)
-      LOG(DFATAL) << "Bad reference count " << re->ref_;
-    if (re->nsub_ > 0) {
-      Regexp** subs = re->sub();
-      for (int i = 0; i < re->nsub_; i++) {
-        Regexp* sub = subs[i];
-        if (sub == NULL)
-          continue;
-        if (sub->ref_ == kMaxRef)
-          sub->Decref();
-        else
-          --sub->ref_;
-        if (sub->ref_ == 0 && !sub->QuickDestroy()) {
-          sub->down_ = stack;
-          stack = sub;
-        }
-      }
-      if (re->nsub_ > 1)
-        delete[] subs;
-      re->nsub_ = 0;
-    }
-    delete re;
-  }
-}
-
-void Regexp::AddRuneToString(Rune r) {
-  DCHECK(op_ == kRegexpLiteralString);
-  if (literal_string_.nrunes_ == 0) {
-    // start with 8
-      literal_string_.runes_ = new Rune[8];
-  } else if (literal_string_.nrunes_ >= 8 && (literal_string_.nrunes_ & (literal_string_.nrunes_ - 1)) == 0) {
-    // double on powers of two
-    Rune *old = literal_string_.runes_;
-      literal_string_.runes_ = new Rune[literal_string_.nrunes_ * 2];
-    for (int i = 0; i < literal_string_.nrunes_; i++)
-        literal_string_.runes_[i] = old[i];
-    delete[] old;
-  }
-
-    literal_string_.runes_[literal_string_.nrunes_++] = r;
-}
-
-Regexp* Regexp::HaveMatch(int match_id, ParseFlags flags) {
-  Regexp* re = new Regexp(kRegexpHaveMatch, flags);
-  re->match_id_ = match_id;
-  return re;
-}
-
-Regexp* Regexp::StarPlusOrQuest(RegexpOp op, Regexp* sub, ParseFlags flags) {
-  // Squash **, ++ and ??.
-  if (op == sub->op() && flags == sub->parse_flags())
-    return sub;
-
-  // Squash *+, *?, +*, +?, ?* and ?+. They all squash to *, so because
-  // op is Star/Plus/Quest, we just have to check that sub->op() is too.
-  if ((sub->op() == kRegexpStar ||
-       sub->op() == kRegexpPlus ||
-       sub->op() == kRegexpQuest) &&
-      flags == sub->parse_flags()) {
-    // If sub is Star, no need to rewrite it.
-    if (sub->op() == kRegexpStar)
-      return sub;
-
-    // Rewrite sub to Star.
-    Regexp* re = new Regexp(kRegexpStar, flags);
-    re->AllocSub(1);
-    re->sub()[0] = sub->sub()[0]->Incref();
-    sub->Decref();  // We didn't consume the reference after all.
-    return re;
-  }
-
-  Regexp* re = new Regexp(op, flags);
-  re->AllocSub(1);
-  re->sub()[0] = sub;
-  return re;
-}
-
-Regexp* Regexp::Plus(Regexp* sub, ParseFlags flags) {
-  return StarPlusOrQuest(kRegexpPlus, sub, flags);
-}
-
-Regexp* Regexp::Star(Regexp* sub, ParseFlags flags) {
-  return StarPlusOrQuest(kRegexpStar, sub, flags);
-}
-
-Regexp* Regexp::Quest(Regexp* sub, ParseFlags flags) {
-  return StarPlusOrQuest(kRegexpQuest, sub, flags);
-}
-
-Regexp* Regexp::ConcatOrAlternate(RegexpOp op, Regexp** sub, int nsub,
-                                  ParseFlags flags, bool can_factor) {
-  if (nsub == 1)
-    return sub[0];
-
-  if (nsub == 0) {
-    if (op == kRegexpAlternate)
-      return new Regexp(kRegexpNoMatch, flags);
-    else
-      return new Regexp(kRegexpEmptyMatch, flags);
-  }
-
-  Regexp** subcopy = NULL;
-  if (op == kRegexpAlternate && can_factor) {
-    // Going to edit sub; make a copy so we don't step on caller.
-    subcopy = new Regexp*[nsub];
-    memmove(subcopy, sub, nsub * sizeof sub[0]);
-    sub = subcopy;
-    nsub = FactorAlternation(sub, nsub, flags);
-    if (nsub == 1) {
-      Regexp* re = sub[0];
-      delete[] subcopy;
-      return re;
-    }
-  }
-
-  if (nsub > kMaxNsub) {
-    // Too many subexpressions to fit in a single Regexp.
-    // Make a two-level tree.  Two levels gets us to 65535^2.
-    int nbigsub = (nsub+kMaxNsub-1)/kMaxNsub;
-    Regexp* re = new Regexp(op, flags);
-    re->AllocSub(nbigsub);
-    Regexp** subs = re->sub();
-    for (int i = 0; i < nbigsub - 1; i++)
-      subs[i] = ConcatOrAlternate(op, sub+i*kMaxNsub, kMaxNsub, flags, false);
-    subs[nbigsub - 1] = ConcatOrAlternate(op, sub+(nbigsub-1)*kMaxNsub,
-                                          nsub - (nbigsub-1)*kMaxNsub, flags,
-                                          false);
-    delete[] subcopy;
-    return re;
-  }
-
-  Regexp* re = new Regexp(op, flags);
-  re->AllocSub(nsub);
-  Regexp** subs = re->sub();
-  for (int i = 0; i < nsub; i++)
-    subs[i] = sub[i];
-
-  delete[] subcopy;
-  return re;
-}
-
-Regexp* Regexp::Concat(Regexp** sub, int nsub, ParseFlags flags) {
-  return ConcatOrAlternate(kRegexpConcat, sub, nsub, flags, false);
-}
-
-Regexp* Regexp::Alternate(Regexp** sub, int nsub, ParseFlags flags) {
-  return ConcatOrAlternate(kRegexpAlternate, sub, nsub, flags, true);
-}
-
-Regexp* Regexp::AlternateNoFactor(Regexp** sub, int nsub, ParseFlags flags) {
-  return ConcatOrAlternate(kRegexpAlternate, sub, nsub, flags, false);
-}
-
-Regexp* Regexp::Capture(Regexp* sub, ParseFlags flags, int cap) {
-  Regexp* re = new Regexp(kRegexpCapture, flags);
-  re->AllocSub(1);
-  re->sub()[0] = sub;
-  re->capture_.cap_ = cap;
-  return re;
-}
-
-Regexp* Regexp::Repeat(Regexp* sub, ParseFlags flags, int min, int max) {
-  Regexp* re = new Regexp(kRegexpRepeat, flags);
-  re->AllocSub(1);
-  re->sub()[0] = sub;
-  re->repeat_.min_ = min;
-  re->repeat_.max_ = max;
-  return re;
-}
-
-Regexp* Regexp::NewLiteral(Rune rune, ParseFlags flags) {
-  Regexp* re = new Regexp(kRegexpLiteral, flags);
-  re->rune_ = rune;
-  return re;
-}
-
-Regexp* Regexp::LiteralString(Rune* runes, int nrunes, ParseFlags flags) {
-  if (nrunes <= 0)
-    return new Regexp(kRegexpEmptyMatch, flags);
-  if (nrunes == 1)
-    return NewLiteral(runes[0], flags);
-  Regexp* re = new Regexp(kRegexpLiteralString, flags);
-  for (int i = 0; i < nrunes; i++)
-    re->AddRuneToString(runes[i]);
-  return re;
-}
-
-Regexp* Regexp::NewCharClass(CharClass* cc, ParseFlags flags) {
-  Regexp* re = new Regexp(kRegexpCharClass, flags);
-  re->char_class_.cc_ = cc;
-  return re;
-}
-
-void Regexp::Swap(Regexp* that) {
-  // Regexp is not trivially copyable, so we cannot freely copy it with
-  // memmove(3), but swapping objects like so is safe for our purposes.
-  char tmp[sizeof *this];
-  void* vthis = reinterpret_cast<void*>(this);
-  void* vthat = reinterpret_cast<void*>(that);
-  memmove(tmp, vthis, sizeof *this);
-  memmove(vthis, vthat, sizeof *this);
-  memmove(vthat, tmp, sizeof *this);
-}
-
-// Tests equality of all top-level structure but not subregexps.
-static bool TopEqual(Regexp* a, Regexp* b) {
-  if (a->op() != b->op())
-    return false;
-
-  switch (a->op()) {
-    case kRegexpNoMatch:
-    case kRegexpEmptyMatch:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpBeginLine:
-    case kRegexpEndLine:
-    case kRegexpWordBoundary:
-    case kRegexpNoWordBoundary:
-    case kRegexpBeginText:
-      return true;
-
-    case kRegexpEndText:
-      // The parse flags remember whether it's \z or (?-m:$),
-      // which matters when testing against PCRE.
-      return ((a->parse_flags() ^ b->parse_flags()) & Regexp::WasDollar) == 0;
-
-    case kRegexpLiteral:
-      return a->rune() == b->rune() &&
-             ((a->parse_flags() ^ b->parse_flags()) & Regexp::FoldCase) == 0;
-
-    case kRegexpLiteralString:
-      return a->nrunes() == b->nrunes() &&
-             ((a->parse_flags() ^ b->parse_flags()) & Regexp::FoldCase) == 0 &&
-             memcmp(a->runes(), b->runes(),
-                    a->nrunes() * sizeof a->runes()[0]) == 0;
-
-    case kRegexpAlternate:
-    case kRegexpConcat:
-      return a->nsub() == b->nsub();
-
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-      return ((a->parse_flags() ^ b->parse_flags()) & Regexp::NonGreedy) == 0;
-
-    case kRegexpRepeat:
-      return ((a->parse_flags() ^ b->parse_flags()) & Regexp::NonGreedy) == 0 &&
-             a->min() == b->min() &&
-             a->max() == b->max();
-
-    case kRegexpCapture:
-      return a->cap() == b->cap() && a->name() == b->name();
-
-    case kRegexpHaveMatch:
-      return a->match_id() == b->match_id();
-
-    case kRegexpCharClass: {
-      CharClass* acc = a->cc();
-      CharClass* bcc = b->cc();
-      return acc->size() == bcc->size() &&
-             acc->end() - acc->begin() == bcc->end() - bcc->begin() &&
-             memcmp(acc->begin(), bcc->begin(),
-                    (acc->end() - acc->begin()) * sizeof acc->begin()[0]) == 0;
-    }
-  }
-
-  LOG(DFATAL) << "Unexpected op in Regexp::Equal: " << a->op();
-  return 0;
-}
-
-bool Regexp::Equal(Regexp* a, Regexp* b) {
-  if (a == NULL || b == NULL)
-    return a == b;
-
-  if (!TopEqual(a, b))
-    return false;
-
-  // Fast path:
-  // return without allocating vector if there are no subregexps.
-  switch (a->op()) {
-    case kRegexpAlternate:
-    case kRegexpConcat:
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-    case kRegexpRepeat:
-    case kRegexpCapture:
-      break;
-
-    default:
-      return true;
-  }
-
-  // Committed to doing real work.
-  // The stack (vector) has pairs of regexps waiting to
-  // be compared.  The regexps are only equal if
-  // all the pairs end up being equal.
-  std::vector<Regexp*> stk;
-
-  for (;;) {
-    // Invariant: TopEqual(a, b) == true.
-    Regexp* a2;
-    Regexp* b2;
-    switch (a->op()) {
-      default:
-        break;
-      case kRegexpAlternate:
-      case kRegexpConcat:
-        for (int i = 0; i < a->nsub(); i++) {
-          a2 = a->sub()[i];
-          b2 = b->sub()[i];
-          if (!TopEqual(a2, b2))
-            return false;
-          stk.push_back(a2);
-          stk.push_back(b2);
-        }
-        break;
-
-      case kRegexpStar:
-      case kRegexpPlus:
-      case kRegexpQuest:
-      case kRegexpRepeat:
-      case kRegexpCapture:
-        a2 = a->sub()[0];
-        b2 = b->sub()[0];
-        if (!TopEqual(a2, b2))
-          return false;
-        // Really:
-        //   stk.push_back(a2);
-        //   stk.push_back(b2);
-        //   break;
-        // but faster to assign directly and loop.
-        a = a2;
-        b = b2;
-        continue;
-    }
-
-    size_t n = stk.size();
-    if (n == 0)
-      break;
-
-    DCHECK_GE(n, 2);
-    a = stk[n-2];
-    b = stk[n-1];
-    stk.resize(n-2);
-  }
-
-  return true;
-}
-
-// Keep in sync with enum RegexpStatusCode in regexp.h
-static const char *kErrorStrings[] = {
-  "no error",
-  "unexpected error",
-  "invalid escape sequence",
-  "invalid character class",
-  "invalid character class range",
-  "missing ]",
-  "missing )",
-  "trailing \\",
-  "no argument for repetition operator",
-  "invalid repetition size",
-  "bad repetition operator",
-  "invalid perl operator",
-  "invalid UTF-8",
-  "invalid named capture group",
-};
-
-std::string RegexpStatus::CodeText(enum RegexpStatusCode code) {
-  if (code < 0 || code >= arraysize(kErrorStrings))
-    code = kRegexpInternalError;
-  return kErrorStrings[code];
-}
-
-std::string RegexpStatus::Text() const {
-  if (error_arg_.empty())
-    return CodeText(code_);
-  std::string s;
-  s.append(CodeText(code_));
-  s.append(": ");
-  s.append(error_arg_.data(), error_arg_.size());
-  return s;
-}
-
-void RegexpStatus::Copy(const RegexpStatus& status) {
-  code_ = status.code_;
-  error_arg_ = status.error_arg_;
-}
-
-typedef int Ignored;  // Walker<void> doesn't exist
-
-// Walker subclass to count capturing parens in regexp.
-class NumCapturesWalker : public Regexp::Walker<Ignored> {
- public:
-  NumCapturesWalker() : ncapture_(0) {}
-  int ncapture() { return ncapture_; }
-
-  virtual Ignored PreVisit(Regexp* re, Ignored ignored, bool* stop) {
-    if (re->op() == kRegexpCapture)
-      ncapture_++;
-    return ignored;
-  }
-  virtual Ignored ShortVisit(Regexp* re, Ignored ignored) {
-    // Should never be called: we use Walk not WalkExponential.
-    LOG(DFATAL) << "NumCapturesWalker::ShortVisit called";
-    return ignored;
-  }
-
- private:
-  int ncapture_;
-
-  NumCapturesWalker(const NumCapturesWalker&) = delete;
-  NumCapturesWalker& operator=(const NumCapturesWalker&) = delete;
-};
-
-int Regexp::NumCaptures() {
-  NumCapturesWalker w;
-  w.Walk(this, 0);
-  return w.ncapture();
-}
-
-// Walker class to build map of named capture groups and their indices.
-class NamedCapturesWalker : public Regexp::Walker<Ignored> {
- public:
-  NamedCapturesWalker() : map_(NULL) {}
-  ~NamedCapturesWalker() { delete map_; }
-
-  std::map<std::string, int>* TakeMap() {
-    std::map<std::string, int>* m = map_;
-    map_ = NULL;
-    return m;
-  }
-
-  Ignored PreVisit(Regexp* re, Ignored ignored, bool* stop) {
-    if (re->op() == kRegexpCapture && re->name() != NULL) {
-      // Allocate map once we find a name.
-      if (map_ == NULL)
-        map_ = new std::map<std::string, int>;
-
-      // Record first occurrence of each name.
-      // (The rule is that if you have the same name
-      // multiple times, only the leftmost one counts.)
-      if (map_->find(*re->name()) == map_->end())
-        (*map_)[*re->name()] = re->cap();
-    }
-    return ignored;
-  }
-
-  virtual Ignored ShortVisit(Regexp* re, Ignored ignored) {
-    // Should never be called: we use Walk not WalkExponential.
-    LOG(DFATAL) << "NamedCapturesWalker::ShortVisit called";
-    return ignored;
-  }
-
- private:
-  std::map<std::string, int>* map_;
-
-  NamedCapturesWalker(const NamedCapturesWalker&) = delete;
-  NamedCapturesWalker& operator=(const NamedCapturesWalker&) = delete;
-};
-
-std::map<std::string, int>* Regexp::NamedCaptures() {
-  NamedCapturesWalker w;
-  w.Walk(this, 0);
-  return w.TakeMap();
-}
-
-// Walker class to build map from capture group indices to their names.
-class CaptureNamesWalker : public Regexp::Walker<Ignored> {
- public:
-  CaptureNamesWalker() : map_(NULL) {}
-  ~CaptureNamesWalker() { delete map_; }
-
-  std::map<int, std::string>* TakeMap() {
-    std::map<int, std::string>* m = map_;
-    map_ = NULL;
-    return m;
-  }
-
-  Ignored PreVisit(Regexp* re, Ignored ignored, bool* stop) {
-    if (re->op() == kRegexpCapture && re->name() != NULL) {
-      // Allocate map once we find a name.
-      if (map_ == NULL)
-        map_ = new std::map<int, std::string>;
-
-      (*map_)[re->cap()] = *re->name();
-    }
-    return ignored;
-  }
-
-  virtual Ignored ShortVisit(Regexp* re, Ignored ignored) {
-    // Should never be called: we use Walk not WalkExponential.
-    LOG(DFATAL) << "CaptureNamesWalker::ShortVisit called";
-    return ignored;
-  }
-
- private:
-  std::map<int, std::string>* map_;
-
-  CaptureNamesWalker(const CaptureNamesWalker&) = delete;
-  CaptureNamesWalker& operator=(const CaptureNamesWalker&) = delete;
-};
-
-std::map<int, std::string>* Regexp::CaptureNames() {
-  CaptureNamesWalker w;
-  w.Walk(this, 0);
-  return w.TakeMap();
-}
-
-// Determines whether regexp matches must be anchored
-// with a fixed string prefix.  If so, returns the prefix and
-// the regexp that remains after the prefix.  The prefix might
-// be ASCII case-insensitive.
-bool Regexp::RequiredPrefix(std::string* prefix, bool* foldcase,
-                            Regexp** suffix) {
-  // No need for a walker: the regexp must be of the form
-  // 1. some number of ^ anchors
-  // 2. a literal char or string
-  // 3. the rest
-  prefix->clear();
-  *foldcase = false;
-  *suffix = NULL;
-  if (op_ != kRegexpConcat)
-    return false;
-
-  // Some number of anchors, then a literal or concatenation.
-  int i = 0;
-  Regexp** sub = this->sub();
-  while (i < nsub_ && sub[i]->op_ == kRegexpBeginText)
-    i++;
-  if (i == 0 || i >= nsub_)
-    return false;
-
-  Regexp* re = sub[i];
-  switch (re->op_) {
-    default:
-      return false;
-
-    case kRegexpLiteralString:
-      // Convert to string in proper encoding.
-      if (re->parse_flags() & Latin1) {
-        prefix->resize(re->literal_string_.nrunes_);
-        for (int j = 0; j < re->literal_string_.nrunes_; j++)
-          (*prefix)[j] = static_cast<char>(re->literal_string_.runes_[j]);
-      } else {
-        // Convert to UTF-8 in place.
-        // Assume worst-case space and then trim.
-        prefix->resize(re->literal_string_.nrunes_ * UTFmax);
-        char *p = &(*prefix)[0];
-        for (int j = 0; j < re->literal_string_.nrunes_; j++) {
-          Rune r = re->literal_string_.runes_[j];
-          if (r < Runeself)
-            *p++ = static_cast<char>(r);
-          else
-            p += runetochar(p, &r);
-        }
-        prefix->resize(p - &(*prefix)[0]);
-      }
-      break;
-
-    case kRegexpLiteral:
-      if ((re->parse_flags() & Latin1) || re->rune_ < Runeself) {
-        prefix->append(1, static_cast<char>(re->rune_));
-      } else {
-        char buf[UTFmax];
-        prefix->append(buf, runetochar(buf, &re->rune_));
-      }
-      break;
-  }
-  *foldcase = (sub[i]->parse_flags() & FoldCase) != 0;
-  i++;
-
-  // The rest.
-  if (i < nsub_) {
-    for (int j = i; j < nsub_; j++)
-      sub[j]->Incref();
-    re = Concat(sub + i, nsub_ - i, parse_flags());
-  } else {
-    re = new Regexp(kRegexpEmptyMatch, parse_flags());
-  }
-  *suffix = re;
-  return true;
-}
-
-// Character class builder is a balanced binary tree (STL set)
-// containing non-overlapping, non-abutting RuneRanges.
-// The less-than operator used in the tree treats two
-// ranges as equal if they overlap at all, so that
-// lookups for a particular Rune are possible.
-
-CharClassBuilder::CharClassBuilder() {
-  nrunes_ = 0;
-  upper_ = 0;
-  lower_ = 0;
-}
-
-// Add lo-hi to the class; return whether class got bigger.
-bool CharClassBuilder::AddRange(Rune lo, Rune hi) {
-  if (hi < lo)
-    return false;
-
-  if (lo <= 'z' && hi >= 'A') {
-    // Overlaps some alpha, maybe not all.
-    // Update bitmaps telling which ASCII letters are in the set.
-    Rune lo1 = std::max<Rune>(lo, 'A');
-    Rune hi1 = std::min<Rune>(hi, 'Z');
-    if (lo1 <= hi1)
-      upper_ |= ((1 << (hi1 - lo1 + 1)) - 1) << (lo1 - 'A');
-
-    lo1 = std::max<Rune>(lo, 'a');
-    hi1 = std::min<Rune>(hi, 'z');
-    if (lo1 <= hi1)
-      lower_ |= ((1 << (hi1 - lo1 + 1)) - 1) << (lo1 - 'a');
-  }
-
-  {  // Check whether lo, hi is already in the class.
-    iterator it = ranges_.find(RuneRange(lo, lo));
-    if (it != end() && it->lo <= lo && hi <= it->hi)
-      return false;
-  }
-
-  // Look for a range abutting lo on the left.
-  // If it exists, take it out and increase our range.
-  if (lo > 0) {
-    iterator it = ranges_.find(RuneRange(lo-1, lo-1));
-    if (it != end()) {
-      lo = it->lo;
-      if (it->hi > hi)
-        hi = it->hi;
-      nrunes_ -= it->hi - it->lo + 1;
-      ranges_.erase(it);
-    }
-  }
-
-  // Look for a range abutting hi on the right.
-  // If it exists, take it out and increase our range.
-  if (hi < Runemax) {
-    iterator it = ranges_.find(RuneRange(hi+1, hi+1));
-    if (it != end()) {
-      hi = it->hi;
-      nrunes_ -= it->hi - it->lo + 1;
-      ranges_.erase(it);
-    }
-  }
-
-  // Look for ranges between lo and hi.  Take them out.
-  // This is only safe because the set has no overlapping ranges.
-  // We've already removed any ranges abutting lo and hi, so
-  // any that overlap [lo, hi] must be contained within it.
-  for (;;) {
-    iterator it = ranges_.find(RuneRange(lo, hi));
-    if (it == end())
-      break;
-    nrunes_ -= it->hi - it->lo + 1;
-    ranges_.erase(it);
-  }
-
-  // Finally, add [lo, hi].
-  nrunes_ += hi - lo + 1;
-  ranges_.insert(RuneRange(lo, hi));
-  return true;
-}
-
-void CharClassBuilder::AddCharClass(CharClassBuilder *cc) {
-  for (iterator it = cc->begin(); it != cc->end(); ++it)
-    AddRange(it->lo, it->hi);
-}
-
-bool CharClassBuilder::Contains(Rune r) {
-  return ranges_.find(RuneRange(r, r)) != end();
-}
-
-// Does the character class behave the same on A-Z as on a-z?
-bool CharClassBuilder::FoldsASCII() {
-  return ((upper_ ^ lower_) & AlphaMask) == 0;
-}
-
-CharClassBuilder* CharClassBuilder::Copy() {
-  CharClassBuilder* cc = new CharClassBuilder;
-  for (iterator it = begin(); it != end(); ++it)
-    cc->ranges_.insert(RuneRange(it->lo, it->hi));
-  cc->upper_ = upper_;
-  cc->lower_ = lower_;
-  cc->nrunes_ = nrunes_;
-  return cc;
-}
-
-
-
-void CharClassBuilder::RemoveAbove(Rune r) {
-  if (r >= Runemax)
-    return;
-
-  if (r < 'z') {
-    if (r < 'a')
-      lower_ = 0;
-    else
-      lower_ &= AlphaMask >> ('z' - r);
-  }
-
-  if (r < 'Z') {
-    if (r < 'A')
-      upper_ = 0;
-    else
-      upper_ &= AlphaMask >> ('Z' - r);
-  }
-
-  for (;;) {
-
-    iterator it = ranges_.find(RuneRange(r + 1, Runemax));
-    if (it == end())
-      break;
-    RuneRange rr = *it;
-    ranges_.erase(it);
-    nrunes_ -= rr.hi - rr.lo + 1;
-    if (rr.lo <= r) {
-      rr.hi = r;
-      ranges_.insert(rr);
-      nrunes_ += rr.hi - rr.lo + 1;
-    }
-  }
-}
-
-void CharClassBuilder::Negate() {
-  // Build up negation and then copy in.
-  // Could edit ranges in place, but C++ won't let me.
-  std::vector<RuneRange> v;
-  v.reserve(ranges_.size() + 1);
-
-  // In negation, first range begins at 0, unless
-  // the current class begins at 0.
-  iterator it = begin();
-  if (it == end()) {
-    v.push_back(RuneRange(0, Runemax));
-  } else {
-    int nextlo = 0;
-    if (it->lo == 0) {
-      nextlo = it->hi + 1;
-      ++it;
-    }
-    for (; it != end(); ++it) {
-      v.push_back(RuneRange(nextlo, it->lo - 1));
-      nextlo = it->hi + 1;
-    }
-    if (nextlo <= Runemax)
-      v.push_back(RuneRange(nextlo, Runemax));
-  }
-
-  ranges_.clear();
-  for (size_t i = 0; i < v.size(); i++)
-    ranges_.insert(v[i]);
-
-  upper_ = AlphaMask & ~upper_;
-  lower_ = AlphaMask & ~lower_;
-  nrunes_ = Runemax+1 - nrunes_;
-}
-
-// Character class is a sorted list of ranges.
-// The ranges are allocated in the same block as the header,
-// necessitating a special allocator and Delete method.
-
-CharClass* CharClass::New(int maxranges) {
-  CharClass* cc;
-  uint8_t* data = new uint8_t[sizeof *cc + maxranges*sizeof cc->ranges_[0]];
-  cc = reinterpret_cast<CharClass*>(data);
-  cc->ranges_ = reinterpret_cast<RuneRange*>(data + sizeof *cc);
-  cc->nranges_ = 0;
-  cc->folds_ascii_ = false;
-  cc->nrunes_ = 0;
-  return cc;
-}
-
-void CharClass::Delete() {
-  uint8_t* data = reinterpret_cast<uint8_t*>(this);
-  delete[] data;
-}
-
-CharClass* CharClass::Negate() {
-  CharClass* cc = CharClass::New(nranges_+1);
-  cc->folds_ascii_ = folds_ascii_;
-  cc->nrunes_ = Runemax + 1 - nrunes_;
-  int n = 0;
-  int nextlo = 0;
-  for (CharClass::iterator it = begin(); it != end(); ++it) {
-    if (it->lo == nextlo) {
-      nextlo = it->hi + 1;
-    } else {
-      cc->ranges_[n++] = RuneRange(nextlo, it->lo - 1);
-      nextlo = it->hi + 1;
-    }
-  }
-  if (nextlo <= Runemax)
-    cc->ranges_[n++] = RuneRange(nextlo, Runemax);
-  cc->nranges_ = n;
-  return cc;
-}
-
-bool CharClass::Contains(Rune r) {
-  RuneRange* rr = ranges_;
-  int n = nranges_;
-  while (n > 0) {
-    int m = n/2;
-    if (rr[m].hi < r) {
-      rr += m+1;
-      n -= m+1;
-    } else if (r < rr[m].lo) {
-      n = m;
-    } else {  // rr[m].lo <= r && r <= rr[m].hi
-      return true;
-    }
-  }
-  return false;
-}
-
-CharClass* CharClassBuilder::GetCharClass() {
-  CharClass* cc = CharClass::New(static_cast<int>(ranges_.size()));
-  int n = 0;
-  for (iterator it = begin(); it != end(); ++it)
-    cc->ranges_[n++] = *it;
-  cc->nranges_ = n;
-  DCHECK_LE(n, static_cast<int>(ranges_.size()));
-  cc->nrunes_ = nrunes_;
-  cc->folds_ascii_ = FoldsASCII();
-  return cc;
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_SET_H_
-#define RE2_SET_H_
-
-#include <string>
-#include <utility>
-#include <vector>
-
-
-
-namespace duckdb_re2 {
-class Prog;
-class Regexp;
-}  // namespace duckdb_re2
-
-namespace duckdb_re2 {
-
-// An RE2::Set represents a collection of regexps that can
-// be searched for simultaneously.
-class RE2::Set {
- public:
-  enum ErrorKind {
-    kNoError = 0,
-    kNotCompiled,   // The set is not compiled.
-    kOutOfMemory,   // The DFA ran out of memory.
-    kInconsistent,  // The result is inconsistent. This should never happen.
-  };
-
-  struct ErrorInfo {
-    ErrorKind kind;
-  };
-
-  Set(const RE2::Options& options, RE2::Anchor anchor);
-  ~Set();
-
-  // Adds pattern to the set using the options passed to the constructor.
-  // Returns the index that will identify the regexp in the output of Match(),
-  // or -1 if the regexp cannot be parsed.
-  // Indices are assigned in sequential order starting from 0.
-  // Errors do not increment the index; if error is not NULL, *error will hold
-  // the error message from the parser.
-  int Add(const StringPiece& pattern, std::string* error);
-
-  // Compiles the set in preparation for matching.
-  // Returns false if the compiler runs out of memory.
-  // Add() must not be called again after Compile().
-  // Compile() must be called before Match().
-  bool Compile();
-
-  // Returns true if text matches at least one of the regexps in the set.
-  // Fills v (if not NULL) with the indices of the matching regexps.
-  // Callers must not expect v to be sorted.
-  bool Match(const StringPiece& text, std::vector<int>* v) const;
-
-  // As above, but populates error_info (if not NULL) when none of the regexps
-  // in the set matched. This can inform callers when DFA execution fails, for
-  // example, because they might wish to handle that case differently.
-  bool Match(const StringPiece& text, std::vector<int>* v,
-             ErrorInfo* error_info) const;
-
- private:
-  typedef std::pair<std::string, duckdb_re2::Regexp*> Elem;
-
-  RE2::Options options_;
-  RE2::Anchor anchor_;
-  std::vector<Elem> elem_;
-  duckdb_re2::Prog* prog_;
-  bool compiled_;
-  int size_;
-
-  Set(const Set&) = delete;
-  Set& operator=(const Set&) = delete;
-};
-
-}  // namespace duckdb_re2
-
-#endif  // RE2_SET_H_
-
-
-// LICENSE_CHANGE_END
-
-
-#include <stddef.h>
-#include <algorithm>
-#include <memory>
-
-
-
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-RE2::Set::Set(const RE2::Options& options, RE2::Anchor anchor) {
-  options_.Copy(options);
-  options_.set_never_capture(true);  // might unblock some optimisations
-  anchor_ = anchor;
-  prog_ = NULL;
-  compiled_ = false;
-  size_ = 0;
-}
-
-RE2::Set::~Set() {
-  for (size_t i = 0; i < elem_.size(); i++)
-    elem_[i].second->Decref();
-  delete prog_;
-}
-
-int RE2::Set::Add(const StringPiece& pattern, std::string* error) {
-  if (compiled_) {
-    LOG(DFATAL) << "RE2::Set::Add() called after compiling";
-    return -1;
-  }
-
-  Regexp::ParseFlags pf = static_cast<Regexp::ParseFlags>(
-    options_.ParseFlags());
-  RegexpStatus status;
-  duckdb_re2::Regexp* re = Regexp::Parse(pattern, pf, &status);
-  if (re == NULL) {
-    if (error != NULL)
-      *error = status.Text();
-    if (options_.log_errors())
-      LOG(ERROR) << "Error parsing '" << pattern << "': " << status.Text();
-    return -1;
-  }
-
-  // Concatenate with match index and push on vector.
-  int n = static_cast<int>(elem_.size());
-  duckdb_re2::Regexp* m = duckdb_re2::Regexp::HaveMatch(n, pf);
-  if (re->op() == kRegexpConcat) {
-    int nsub = re->nsub();
-    PODArray<duckdb_re2::Regexp*> sub(nsub + 1);
-    for (int i = 0; i < nsub; i++)
-      sub[i] = re->sub()[i]->Incref();
-    sub[nsub] = m;
-    re->Decref();
-    re = duckdb_re2::Regexp::Concat(sub.data(), nsub + 1, pf);
-  } else {
-    duckdb_re2::Regexp* sub[2];
-    sub[0] = re;
-    sub[1] = m;
-    re = duckdb_re2::Regexp::Concat(sub, 2, pf);
-  }
-  elem_.emplace_back(std::string(pattern), re);
-  return n;
-}
-
-bool RE2::Set::Compile() {
-  if (compiled_) {
-    LOG(DFATAL) << "RE2::Set::Compile() called more than once";
-    return false;
-  }
-  compiled_ = true;
-  size_ = static_cast<int>(elem_.size());
-
-  // Sort the elements by their patterns. This is good enough for now
-  // until we have a Regexp comparison function. (Maybe someday...)
-  std::sort(elem_.begin(), elem_.end(),
-            [](const Elem& a, const Elem& b) -> bool {
-              return a.first < b.first;
-            });
-
-  PODArray<duckdb_re2::Regexp*> sub(size_);
-  for (int i = 0; i < size_; i++)
-    sub[i] = elem_[i].second;
-  elem_.clear();
-  elem_.shrink_to_fit();
-
-  Regexp::ParseFlags pf = static_cast<Regexp::ParseFlags>(
-    options_.ParseFlags());
-  duckdb_re2::Regexp* re = duckdb_re2::Regexp::Alternate(sub.data(), size_, pf);
-
-  prog_ = Prog::CompileSet(re, anchor_, options_.max_mem());
-  re->Decref();
-  return prog_ != NULL;
-}
-
-bool RE2::Set::Match(const StringPiece& text, std::vector<int>* v) const {
-  return Match(text, v, NULL);
-}
-
-bool RE2::Set::Match(const StringPiece& text, std::vector<int>* v,
-                     ErrorInfo* error_info) const {
-  if (!compiled_) {
-    LOG(DFATAL) << "RE2::Set::Match() called before compiling";
-    if (error_info != NULL)
-      error_info->kind = kNotCompiled;
-    return false;
-  }
-  bool dfa_failed = false;
-  std::unique_ptr<SparseSet> matches;
-  if (v != NULL) {
-    matches.reset(new SparseSet(size_));
-    v->clear();
-  }
-  bool ret = prog_->SearchDFA(text, text, Prog::kAnchored, Prog::kManyMatch,
-                              NULL, &dfa_failed, matches.get());
-  if (dfa_failed) {
-    if (options_.log_errors())
-      LOG(ERROR) << "DFA out of memory: size " << prog_->size() << ", "
-                 << "bytemap range " << prog_->bytemap_range() << ", "
-                 << "list count " << prog_->list_count();
-    if (error_info != NULL)
-      error_info->kind = kOutOfMemory;
-    return false;
-  }
-  if (ret == false) {
-    if (error_info != NULL)
-      error_info->kind = kNoError;
-    return false;
-  }
-  if (v != NULL) {
-    if (matches->empty()) {
-      LOG(DFATAL) << "RE2::Set::Match() matched, but no matches returned?!";
-      if (error_info != NULL)
-        error_info->kind = kInconsistent;
-      return false;
-    }
-    v->assign(matches->begin(), matches->end());
-  }
-  if (error_info != NULL)
-    error_info->kind = kNoError;
-  return true;
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Rewrite POSIX and other features in re
-// to use simple extended regular expression features.
-// Also sort and simplify character classes.
-
-#include <string>
-
-
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-// Parses the regexp src and then simplifies it and sets *dst to the
-// string representation of the simplified form.  Returns true on success.
-// Returns false and sets *error (if error != NULL) on error.
-bool Regexp::SimplifyRegexp(const StringPiece& src, ParseFlags flags,
-                            std::string* dst, RegexpStatus* status) {
-  Regexp* re = Parse(src, flags, status);
-  if (re == NULL)
-    return false;
-  Regexp* sre = re->Simplify();
-  re->Decref();
-  if (sre == NULL) {
-    // Should not happen, since Simplify never fails.
-    LOG(ERROR) << "Simplify failed on " << src;
-    if (status) {
-      status->set_code(kRegexpInternalError);
-      status->set_error_arg(src);
-    }
-    return false;
-  }
-  *dst = sre->ToString();
-  sre->Decref();
-  return true;
-}
-
-// Assuming the simple_ flags on the children are accurate,
-// is this Regexp* simple?
-bool Regexp::ComputeSimple() {
-  Regexp** subs;
-  auto ccb = char_class_.ccb_;
-  auto cc = char_class_.cc_;
-
-  switch (op_) {
-    case kRegexpNoMatch:
-    case kRegexpEmptyMatch:
-    case kRegexpLiteral:
-    case kRegexpLiteralString:
-    case kRegexpBeginLine:
-    case kRegexpEndLine:
-    case kRegexpBeginText:
-    case kRegexpWordBoundary:
-    case kRegexpNoWordBoundary:
-    case kRegexpEndText:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpHaveMatch:
-      return true;
-    case kRegexpConcat:
-    case kRegexpAlternate:
-      // These are simple as long as the subpieces are simple.
-      subs = sub();
-      for (int i = 0; i < nsub_; i++)
-        if (!subs[i]->simple())
-          return false;
-      return true;
-    case kRegexpCharClass:
-      // Simple as long as the char class is not empty, not full.
-      if (ccb != NULL)
-        return !ccb->empty() && !ccb->full();
-      return !cc->empty() && !cc->full();
-    case kRegexpCapture:
-      subs = sub();
-      return subs[0]->simple();
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-      subs = sub();
-      if (!subs[0]->simple())
-        return false;
-      switch (subs[0]->op_) {
-        case kRegexpStar:
-        case kRegexpPlus:
-        case kRegexpQuest:
-        case kRegexpEmptyMatch:
-        case kRegexpNoMatch:
-          return false;
-        default:
-          break;
-      }
-      return true;
-    case kRegexpRepeat:
-      return false;
-  }
-  LOG(DFATAL) << "Case not handled in ComputeSimple: " << op_;
-  return false;
-}
-
-// Walker subclass used by Simplify.
-// Coalesces runs of star/plus/quest/repeat of the same literal along with any
-// occurrences of that literal into repeats of that literal. It also works for
-// char classes, any char and any byte.
-// PostVisit creates the coalesced result, which should then be simplified.
-class CoalesceWalker : public Regexp::Walker<Regexp*> {
- public:
-  CoalesceWalker() {}
-  virtual Regexp* PostVisit(Regexp* re, Regexp* parent_arg, Regexp* pre_arg,
-                            Regexp** child_args, int nchild_args);
-  virtual Regexp* Copy(Regexp* re);
-  virtual Regexp* ShortVisit(Regexp* re, Regexp* parent_arg);
-
- private:
-  // These functions are declared inside CoalesceWalker so that
-  // they can edit the private fields of the Regexps they construct.
-
-  // Returns true if r1 and r2 can be coalesced. In particular, ensures that
-  // the parse flags are consistent. (They will not be checked again later.)
-  static bool CanCoalesce(Regexp* r1, Regexp* r2);
-
-  // Coalesces *r1ptr and *r2ptr. In most cases, the array elements afterwards
-  // will be empty match and the coalesced op. In other cases, where part of a
-  // literal string was removed to be coalesced, the array elements afterwards
-  // will be the coalesced op and the remainder of the literal string.
-  static void DoCoalesce(Regexp** r1ptr, Regexp** r2ptr);
-
-  CoalesceWalker(const CoalesceWalker&) = delete;
-  CoalesceWalker& operator=(const CoalesceWalker&) = delete;
-};
-
-// Walker subclass used by Simplify.
-// The simplify walk is purely post-recursive: given the simplified children,
-// PostVisit creates the simplified result.
-// The child_args are simplified Regexp*s.
-class SimplifyWalker : public Regexp::Walker<Regexp*> {
- public:
-  SimplifyWalker() {}
-  virtual Regexp* PreVisit(Regexp* re, Regexp* parent_arg, bool* stop);
-  virtual Regexp* PostVisit(Regexp* re, Regexp* parent_arg, Regexp* pre_arg,
-                            Regexp** child_args, int nchild_args);
-  virtual Regexp* Copy(Regexp* re);
-  virtual Regexp* ShortVisit(Regexp* re, Regexp* parent_arg);
-
- private:
-  // These functions are declared inside SimplifyWalker so that
-  // they can edit the private fields of the Regexps they construct.
-
-  // Creates a concatenation of two Regexp, consuming refs to re1 and re2.
-  // Caller must Decref return value when done with it.
-  static Regexp* Concat2(Regexp* re1, Regexp* re2, Regexp::ParseFlags flags);
-
-  // Simplifies the expression re{min,max} in terms of *, +, and ?.
-  // Returns a new regexp.  Does not edit re.  Does not consume reference to re.
-  // Caller must Decref return value when done with it.
-  static Regexp* SimplifyRepeat(Regexp* re, int min, int max,
-                                Regexp::ParseFlags parse_flags);
-
-  // Simplifies a character class by expanding any named classes
-  // into rune ranges.  Does not edit re.  Does not consume ref to re.
-  // Caller must Decref return value when done with it.
-  static Regexp* SimplifyCharClass(Regexp* re);
-
-  SimplifyWalker(const SimplifyWalker&) = delete;
-  SimplifyWalker& operator=(const SimplifyWalker&) = delete;
-};
-
-// Simplifies a regular expression, returning a new regexp.
-// The new regexp uses traditional Unix egrep features only,
-// plus the Perl (?:) non-capturing parentheses.
-// Otherwise, no POSIX or Perl additions.  The new regexp
-// captures exactly the same subexpressions (with the same indices)
-// as the original.
-// Does not edit current object.
-// Caller must Decref() return value when done with it.
-
-Regexp* Regexp::Simplify() {
-  CoalesceWalker cw;
-  Regexp* cre = cw.Walk(this, NULL);
-  if (cre == NULL)
-    return cre;
-  SimplifyWalker sw;
-  Regexp* sre = sw.Walk(cre, NULL);
-  cre->Decref();
-  return sre;
-}
-
-// Utility function for PostVisit implementations that compares re->sub() with
-// child_args to determine whether any child_args changed. In the common case,
-// where nothing changed, calls Decref() for all child_args and returns false,
-// so PostVisit must return re->Incref(). Otherwise, returns true.
-static bool ChildArgsChanged(Regexp* re, Regexp** child_args) {
-  for (int i = 0; i < re->nsub(); i++) {
-    Regexp* sub = re->sub()[i];
-    Regexp* newsub = child_args[i];
-    if (newsub != sub)
-      return true;
-  }
-  for (int i = 0; i < re->nsub(); i++) {
-    Regexp* newsub = child_args[i];
-    newsub->Decref();
-  }
-  return false;
-}
-
-Regexp* CoalesceWalker::Copy(Regexp* re) {
-  return re->Incref();
-}
-
-Regexp* CoalesceWalker::ShortVisit(Regexp* re, Regexp* parent_arg) {
-  // This should never be called, since we use Walk and not
-  // WalkExponential.
-  LOG(DFATAL) << "CoalesceWalker::ShortVisit called";
-  return re->Incref();
-}
-
-Regexp* CoalesceWalker::PostVisit(Regexp* re,
-                                  Regexp* parent_arg,
-                                  Regexp* pre_arg,
-                                  Regexp** child_args,
-                                  int nchild_args) {
-  if (re->nsub() == 0)
-    return re->Incref();
-
-  if (re->op() != kRegexpConcat) {
-    if (!ChildArgsChanged(re, child_args))
-      return re->Incref();
-
-    // Something changed. Build a new op.
-    Regexp* nre = new Regexp(re->op(), re->parse_flags());
-    nre->AllocSub(re->nsub());
-    Regexp** nre_subs = nre->sub();
-    for (int i = 0; i < re->nsub(); i++)
-      nre_subs[i] = child_args[i];
-    // Repeats and Captures have additional data that must be copied.
-    if (re->op() == kRegexpRepeat) {
-      nre->repeat_.min_ = re->min();
-      nre->repeat_.max_ = re->max();
-    } else if (re->op() == kRegexpCapture) {
-      nre->capture_.cap_ = re->cap();
-    }
-    return nre;
-  }
-
-  bool can_coalesce = false;
-  for (int i = 0; i < re->nsub(); i++) {
-    if (i+1 < re->nsub() &&
-        CanCoalesce(child_args[i], child_args[i+1])) {
-      can_coalesce = true;
-      break;
-    }
-  }
-  if (!can_coalesce) {
-    if (!ChildArgsChanged(re, child_args))
-      return re->Incref();
-
-    // Something changed. Build a new op.
-    Regexp* nre = new Regexp(re->op(), re->parse_flags());
-    nre->AllocSub(re->nsub());
-    Regexp** nre_subs = nre->sub();
-    for (int i = 0; i < re->nsub(); i++)
-      nre_subs[i] = child_args[i];
-    return nre;
-  }
-
-  for (int i = 0; i < re->nsub(); i++) {
-    if (i+1 < re->nsub() &&
-        CanCoalesce(child_args[i], child_args[i+1]))
-      DoCoalesce(&child_args[i], &child_args[i+1]);
-  }
-  // Determine how many empty matches were left by DoCoalesce.
-  int n = 0;
-  for (int i = n; i < re->nsub(); i++) {
-    if (child_args[i]->op() == kRegexpEmptyMatch)
-      n++;
-  }
-  // Build a new op.
-  Regexp* nre = new Regexp(re->op(), re->parse_flags());
-  nre->AllocSub(re->nsub() - n);
-  Regexp** nre_subs = nre->sub();
-  for (int i = 0, j = 0; i < re->nsub(); i++) {
-    if (child_args[i]->op() == kRegexpEmptyMatch) {
-      child_args[i]->Decref();
-      continue;
-    }
-    nre_subs[j] = child_args[i];
-    j++;
-  }
-  return nre;
-}
-
-bool CoalesceWalker::CanCoalesce(Regexp* r1, Regexp* r2) {
-  // r1 must be a star/plus/quest/repeat of a literal, char class, any char or
-  // any byte.
-  if ((r1->op() == kRegexpStar ||
-       r1->op() == kRegexpPlus ||
-       r1->op() == kRegexpQuest ||
-       r1->op() == kRegexpRepeat) &&
-      (r1->sub()[0]->op() == kRegexpLiteral ||
-       r1->sub()[0]->op() == kRegexpCharClass ||
-       r1->sub()[0]->op() == kRegexpAnyChar ||
-       r1->sub()[0]->op() == kRegexpAnyByte)) {
-    // r2 must be a star/plus/quest/repeat of the same literal, char class,
-    // any char or any byte.
-    if ((r2->op() == kRegexpStar ||
-         r2->op() == kRegexpPlus ||
-         r2->op() == kRegexpQuest ||
-         r2->op() == kRegexpRepeat) &&
-        Regexp::Equal(r1->sub()[0], r2->sub()[0]) &&
-        // The parse flags must be consistent.
-        ((r1->parse_flags() & Regexp::NonGreedy) ==
-         (r2->parse_flags() & Regexp::NonGreedy))) {
-      return true;
-    }
-    // ... OR an occurrence of that literal, char class, any char or any byte
-    if (Regexp::Equal(r1->sub()[0], r2)) {
-      return true;
-    }
-    // ... OR a literal string that begins with that literal.
-    if (r1->sub()[0]->op() == kRegexpLiteral &&
-        r2->op() == kRegexpLiteralString &&
-        r2->runes()[0] == r1->sub()[0]->rune() &&
-        // The parse flags must be consistent.
-        ((r1->sub()[0]->parse_flags() & Regexp::FoldCase) ==
-         (r2->parse_flags() & Regexp::FoldCase))) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void CoalesceWalker::DoCoalesce(Regexp** r1ptr, Regexp** r2ptr) {
-  Regexp* r1 = *r1ptr;
-  Regexp* r2 = *r2ptr;
-
-  Regexp* nre = Regexp::Repeat(
-      r1->sub()[0]->Incref(), r1->parse_flags(), 0, 0);
-
-  switch (r1->op()) {
-    case kRegexpStar:
-      nre->repeat_.min_ = 0;
-      nre->repeat_.max_ = -1;
-      break;
-
-    case kRegexpPlus:
-      nre->repeat_.min_ = 1;
-      nre->repeat_.max_ = -1;
-      break;
-
-    case kRegexpQuest:
-      nre->repeat_.min_ = 0;
-      nre->repeat_.max_ = 1;
-      break;
-
-    case kRegexpRepeat:
-      nre->repeat_.min_ = r1->min();
-      nre->repeat_.max_ = r1->max();
-      break;
-
-    default:
-      LOG(DFATAL) << "DoCoalesce failed: r1->op() is " << r1->op();
-      nre->Decref();
-      return;
-  }
-
-  switch (r2->op()) {
-    case kRegexpStar:
-      nre->repeat_.max_ = -1;
-      goto LeaveEmpty;
-
-    case kRegexpPlus:
-      nre->repeat_.min_++;
-      nre->repeat_.max_ = -1;
-      goto LeaveEmpty;
-
-    case kRegexpQuest:
-      if (nre->max() != -1)
-        nre->repeat_.max_++;
-      goto LeaveEmpty;
-
-    case kRegexpRepeat:
-      nre->repeat_.min_ += r2->min();
-      if (r2->max() == -1)
-        nre->repeat_.max_ = -1;
-      else if (nre->max() != -1)
-        nre->repeat_.max_ += r2->max();
-      goto LeaveEmpty;
-
-    case kRegexpLiteral:
-    case kRegexpCharClass:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-      nre->repeat_.min_++;
-      if (nre->max() != -1)
-        nre->repeat_.max_++;
-      goto LeaveEmpty;
-
-    LeaveEmpty:
-      *r1ptr = new Regexp(kRegexpEmptyMatch, Regexp::NoParseFlags);
-      *r2ptr = nre;
-      break;
-
-    case kRegexpLiteralString: {
-      Rune r = r1->sub()[0]->rune();
-      // Determine how much of the literal string is removed.
-      // We know that we have at least one rune. :)
-      int n = 1;
-      while (n < r2->nrunes() && r2->runes()[n] == r)
-        n++;
-      nre->repeat_.min_ += n;
-      if (nre->max() != -1)
-        nre->repeat_.max_ += n;
-      if (n == r2->nrunes())
-        goto LeaveEmpty;
-      *r1ptr = nre;
-      *r2ptr = Regexp::LiteralString(
-          &r2->runes()[n], r2->nrunes() - n, r2->parse_flags());
-      break;
-    }
-
-    default:
-      LOG(DFATAL) << "DoCoalesce failed: r2->op() is " << r2->op();
-      nre->Decref();
-      return;
-  }
-
-  r1->Decref();
-  r2->Decref();
-}
-
-Regexp* SimplifyWalker::Copy(Regexp* re) {
-  return re->Incref();
-}
-
-Regexp* SimplifyWalker::ShortVisit(Regexp* re, Regexp* parent_arg) {
-  // This should never be called, since we use Walk and not
-  // WalkExponential.
-  LOG(DFATAL) << "SimplifyWalker::ShortVisit called";
-  return re->Incref();
-}
-
-Regexp* SimplifyWalker::PreVisit(Regexp* re, Regexp* parent_arg, bool* stop) {
-  if (re->simple()) {
-    *stop = true;
-    return re->Incref();
-  }
-  return NULL;
-}
-
-Regexp* SimplifyWalker::PostVisit(Regexp* re,
-                                  Regexp* parent_arg,
-                                  Regexp* pre_arg,
-                                  Regexp** child_args,
-                                  int nchild_args) {
-  switch (re->op()) {
-    case kRegexpNoMatch:
-    case kRegexpEmptyMatch:
-    case kRegexpLiteral:
-    case kRegexpLiteralString:
-    case kRegexpBeginLine:
-    case kRegexpEndLine:
-    case kRegexpBeginText:
-    case kRegexpWordBoundary:
-    case kRegexpNoWordBoundary:
-    case kRegexpEndText:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpHaveMatch:
-      // All these are always simple.
-      re->simple_ = true;
-      return re->Incref();
-
-    case kRegexpConcat:
-    case kRegexpAlternate: {
-      // These are simple as long as the subpieces are simple.
-      if (!ChildArgsChanged(re, child_args)) {
-        re->simple_ = true;
-        return re->Incref();
-      }
-      Regexp* nre = new Regexp(re->op(), re->parse_flags());
-      nre->AllocSub(re->nsub());
-      Regexp** nre_subs = nre->sub();
-      for (int i = 0; i < re->nsub(); i++)
-        nre_subs[i] = child_args[i];
-      nre->simple_ = true;
-      return nre;
-    }
-
-    case kRegexpCapture: {
-      Regexp* newsub = child_args[0];
-      if (newsub == re->sub()[0]) {
-        newsub->Decref();
-        re->simple_ = true;
-        return re->Incref();
-      }
-      Regexp* nre = new Regexp(kRegexpCapture, re->parse_flags());
-      nre->AllocSub(1);
-      nre->sub()[0] = newsub;
-      nre->capture_.cap_ = re->cap();
-      nre->simple_ = true;
-      return nre;
-    }
-
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest: {
-      Regexp* newsub = child_args[0];
-      // Special case: repeat the empty string as much as
-      // you want, but it's still the empty string.
-      if (newsub->op() == kRegexpEmptyMatch)
-        return newsub;
-
-      // These are simple as long as the subpiece is simple.
-      if (newsub == re->sub()[0]) {
-        newsub->Decref();
-        re->simple_ = true;
-        return re->Incref();
-      }
-
-      // These are also idempotent if flags are constant.
-      if (re->op() == newsub->op() &&
-          re->parse_flags() == newsub->parse_flags())
-        return newsub;
-
-      Regexp* nre = new Regexp(re->op(), re->parse_flags());
-      nre->AllocSub(1);
-      nre->sub()[0] = newsub;
-      nre->simple_ = true;
-      return nre;
-    }
-
-    case kRegexpRepeat: {
-      Regexp* newsub = child_args[0];
-      // Special case: repeat the empty string as much as
-      // you want, but it's still the empty string.
-      if (newsub->op() == kRegexpEmptyMatch)
-        return newsub;
-
-      Regexp* nre = SimplifyRepeat(newsub, re->repeat_.min_, re->repeat_.max_,
-                                   re->parse_flags());
-      newsub->Decref();
-      nre->simple_ = true;
-      return nre;
-    }
-
-    case kRegexpCharClass: {
-      Regexp* nre = SimplifyCharClass(re);
-      nre->simple_ = true;
-      return nre;
-    }
-  }
-
-  LOG(ERROR) << "Simplify case not handled: " << re->op();
-  return re->Incref();
-}
-
-// Creates a concatenation of two Regexp, consuming refs to re1 and re2.
-// Returns a new Regexp, handing the ref to the caller.
-Regexp* SimplifyWalker::Concat2(Regexp* re1, Regexp* re2,
-                                Regexp::ParseFlags parse_flags) {
-  Regexp* re = new Regexp(kRegexpConcat, parse_flags);
-  re->AllocSub(2);
-  Regexp** subs = re->sub();
-  subs[0] = re1;
-  subs[1] = re2;
-  return re;
-}
-
-// Simplifies the expression re{min,max} in terms of *, +, and ?.
-// Returns a new regexp.  Does not edit re.  Does not consume reference to re.
-// Caller must Decref return value when done with it.
-// The result will *not* necessarily have the right capturing parens
-// if you call ToString() and re-parse it: (x){2} becomes (x)(x),
-// but in the Regexp* representation, both (x) are marked as $1.
-Regexp* SimplifyWalker::SimplifyRepeat(Regexp* re, int min, int max,
-                                       Regexp::ParseFlags f) {
-  // x{n,} means at least n matches of x.
-  if (max == -1) {
-    // Special case: x{0,} is x*
-    if (min == 0)
-      return Regexp::Star(re->Incref(), f);
-
-    // Special case: x{1,} is x+
-    if (min == 1)
-      return Regexp::Plus(re->Incref(), f);
-
-    // General case: x{4,} is xxxx+
-    PODArray<Regexp*> nre_subs(min);
-    for (int i = 0; i < min-1; i++)
-      nre_subs[i] = re->Incref();
-    nre_subs[min-1] = Regexp::Plus(re->Incref(), f);
-    return Regexp::Concat(nre_subs.data(), min, f);
-  }
-
-  // Special case: (x){0} matches only empty string.
-  if (min == 0 && max == 0)
-    return new Regexp(kRegexpEmptyMatch, f);
-
-  // Special case: x{1} is just x.
-  if (min == 1 && max == 1)
-    return re->Incref();
-
-  // General case: x{n,m} means n copies of x and m copies of x?.
-  // The machine will do less work if we nest the final m copies,
-  // so that x{2,5} = xx(x(x(x)?)?)?
-
-  // Build leading prefix: xx.  Capturing only on the last one.
-  Regexp* nre = NULL;
-  if (min > 0) {
-    PODArray<Regexp*> nre_subs(min);
-    for (int i = 0; i < min; i++)
-      nre_subs[i] = re->Incref();
-    nre = Regexp::Concat(nre_subs.data(), min, f);
-  }
-
-  // Build and attach suffix: (x(x(x)?)?)?
-  if (max > min) {
-    Regexp* suf = Regexp::Quest(re->Incref(), f);
-    for (int i = min+1; i < max; i++)
-      suf = Regexp::Quest(Concat2(re->Incref(), suf, f), f);
-    if (nre == NULL)
-      nre = suf;
-    else
-      nre = Concat2(nre, suf, f);
-  }
-
-  if (nre == NULL) {
-    // Some degenerate case, like min > max, or min < max < 0.
-    // This shouldn't happen, because the parser rejects such regexps.
-    LOG(DFATAL) << "Malformed repeat " << re->ToString() << " " << min << " " << max;
-    return new Regexp(kRegexpNoMatch, f);
-  }
-
-  return nre;
-}
-
-// Simplifies a character class.
-// Caller must Decref return value when done with it.
-Regexp* SimplifyWalker::SimplifyCharClass(Regexp* re) {
-  CharClass* cc = re->cc();
-
-  // Special cases
-  if (cc->empty())
-    return new Regexp(kRegexpNoMatch, re->parse_flags());
-  if (cc->full())
-    return new Regexp(kRegexpAnyChar, re->parse_flags());
-
-  return re->Incref();
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2004 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-
-
-#include <ostream>
-
-
-
-namespace duckdb_re2 {
-
-const StringPiece::size_type StringPiece::npos;  // initialized in stringpiece.h
-
-StringPiece::size_type StringPiece::copy(char* buf, size_type n,
-                                         size_type pos) const {
-  size_type ret = std::min(size_ - pos, n);
-  memcpy(buf, data_ + pos, ret);
-  return ret;
-}
-
-StringPiece StringPiece::substr(size_type pos, size_type n) const {
-  if (pos > size_) pos = size_;
-  if (n > size_ - pos) n = size_ - pos;
-  return StringPiece(data_ + pos, n);
-}
-
-StringPiece::size_type StringPiece::find(const StringPiece& s,
-                                         size_type pos) const {
-  if (pos > size_) return npos;
-  const_pointer result = std::search(data_ + pos, data_ + size_,
-                                     s.data_, s.data_ + s.size_);
-  size_type xpos = result - data_;
-  return xpos + s.size_ <= size_ ? xpos : npos;
-}
-
-StringPiece::size_type StringPiece::find(char c, size_type pos) const {
-  if (size_ <= 0 || pos >= size_) return npos;
-  const_pointer result = std::find(data_ + pos, data_ + size_, c);
-  return result != data_ + size_ ? result - data_ : npos;
-}
-
-StringPiece::size_type StringPiece::rfind(const StringPiece& s,
-                                          size_type pos) const {
-  if (size_ < s.size_) return npos;
-  if (s.size_ == 0) return std::min(size_, pos);
-  const_pointer last = data_ + std::min(size_ - s.size_, pos) + s.size_;
-  const_pointer result = std::find_end(data_, last, s.data_, s.data_ + s.size_);
-  return result != last ? result - data_ : npos;
-}
-
-StringPiece::size_type StringPiece::rfind(char c, size_type pos) const {
-  if (size_ <= 0) return npos;
-  for (size_t i = std::min(pos + 1, size_); i != 0;) {
-    if (data_[--i] == c) return i;
-  }
-  return npos;
-}
-
-std::ostream& operator<<(std::ostream& o, const StringPiece& p) {
-  o.write(p.data(), p.size());
-  return o;
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 2006 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Format a regular expression structure as a string.
-// Tested by parse_test.cc
-
-#include <string.h>
-#include <string>
-
-
-
-
-
-
-
-
-namespace duckdb_re2 {
-
-enum {
-  PrecAtom,
-  PrecUnary,
-  PrecConcat,
-  PrecAlternate,
-  PrecEmpty,
-  PrecParen,
-  PrecToplevel,
-};
-
-// Helper function.  See description below.
-static void AppendCCRange(std::string* t, Rune lo, Rune hi);
-
-// Walker to generate string in s_.
-// The arg pointers are actually integers giving the
-// context precedence.
-// The child_args are always NULL.
-class ToStringWalker : public Regexp::Walker<int> {
- public:
-  explicit ToStringWalker(std::string* t) : t_(t) {}
-
-  virtual int PreVisit(Regexp* re, int parent_arg, bool* stop);
-  virtual int PostVisit(Regexp* re, int parent_arg, int pre_arg,
-                        int* child_args, int nchild_args);
-  virtual int ShortVisit(Regexp* re, int parent_arg) {
-    return 0;
-  }
-
- private:
-  std::string* t_;  // The string the walker appends to.
-
-  ToStringWalker(const ToStringWalker&) = delete;
-  ToStringWalker& operator=(const ToStringWalker&) = delete;
-};
-
-std::string Regexp::ToString() {
-  std::string t;
-  ToStringWalker w(&t);
-  w.WalkExponential(this, PrecToplevel, 100000);
-  if (w.stopped_early())
-    t += " [truncated]";
-  return t;
-}
-
-// Visits re before children are processed.
-// Appends ( if needed and passes new precedence to children.
-int ToStringWalker::PreVisit(Regexp* re, int parent_arg, bool* stop) {
-  int prec = parent_arg;
-  int nprec = PrecAtom;
-
-  switch (re->op()) {
-    case kRegexpNoMatch:
-    case kRegexpEmptyMatch:
-    case kRegexpLiteral:
-    case kRegexpAnyChar:
-    case kRegexpAnyByte:
-    case kRegexpBeginLine:
-    case kRegexpEndLine:
-    case kRegexpBeginText:
-    case kRegexpEndText:
-    case kRegexpWordBoundary:
-    case kRegexpNoWordBoundary:
-    case kRegexpCharClass:
-    case kRegexpHaveMatch:
-      nprec = PrecAtom;
-      break;
-
-    case kRegexpConcat:
-    case kRegexpLiteralString:
-      if (prec < PrecConcat)
-        t_->append("(?:");
-      nprec = PrecConcat;
-      break;
-
-    case kRegexpAlternate:
-      if (prec < PrecAlternate)
-        t_->append("(?:");
-      nprec = PrecAlternate;
-      break;
-
-    case kRegexpCapture:
-      t_->append("(");
-      if (re->cap() == 0)
-        LOG(DFATAL) << "kRegexpCapture cap() == 0";
-      if (re->name()) {
-        t_->append("?P<");
-        t_->append(*re->name());
-        t_->append(">");
-      }
-      nprec = PrecParen;
-      break;
-
-    case kRegexpStar:
-    case kRegexpPlus:
-    case kRegexpQuest:
-    case kRegexpRepeat:
-      if (prec < PrecUnary)
-        t_->append("(?:");
-      // The subprecedence here is PrecAtom instead of PrecUnary
-      // because PCRE treats two unary ops in a row as a parse error.
-      nprec = PrecAtom;
-      break;
-  }
-
-  return nprec;
-}
-
-static void AppendLiteral(std::string *t, Rune r, bool foldcase) {
-  if (r != 0 && r < 0x80 && strchr("(){}[]*+?|.^$\\", r)) {
-    t->append(1, '\\');
-    t->append(1, static_cast<char>(r));
-  } else if (foldcase && 'a' <= r && r <= 'z') {
-    r -= 'a' - 'A';
-    t->append(1, '[');
-    t->append(1, static_cast<char>(r));
-    t->append(1, static_cast<char>(r) + 'a' - 'A');
-    t->append(1, ']');
-  } else {
-    AppendCCRange(t, r, r);
-  }
-}
-
-// Visits re after children are processed.
-// For childless regexps, all the work is done here.
-// For regexps with children, append any unary suffixes or ).
-int ToStringWalker::PostVisit(Regexp* re, int parent_arg, int pre_arg,
-                              int* child_args, int nchild_args) {
-  int prec = parent_arg;
-  switch (re->op()) {
-    case kRegexpNoMatch:
-      // There's no simple symbol for "no match", but
-      // [^0-Runemax] excludes everything.
-      t_->append("[^\\x00-\\x{10ffff}]");
-      break;
-
-    case kRegexpEmptyMatch:
-      // Append (?:) to make empty string visible,
-      // unless this is already being parenthesized.
-      if (prec < PrecEmpty)
-        t_->append("(?:)");
-      break;
-
-    case kRegexpLiteral:
-      AppendLiteral(t_, re->rune(),
-                    (re->parse_flags() & Regexp::FoldCase) != 0);
-      break;
-
-    case kRegexpLiteralString:
-      for (int i = 0; i < re->nrunes(); i++)
-        AppendLiteral(t_, re->runes()[i],
-                      (re->parse_flags() & Regexp::FoldCase) != 0);
-      if (prec < PrecConcat)
-        t_->append(")");
-      break;
-
-    case kRegexpConcat:
-      if (prec < PrecConcat)
-        t_->append(")");
-      break;
-
-    case kRegexpAlternate:
-      // Clumsy but workable: the children all appended |
-      // at the end of their strings, so just remove the last one.
-      if ((*t_)[t_->size()-1] == '|')
-        t_->erase(t_->size()-1);
-      else
-        LOG(DFATAL) << "Bad final char: " << t_;
-      if (prec < PrecAlternate)
-        t_->append(")");
-      break;
-
-    case kRegexpStar:
-      t_->append("*");
-      if (re->parse_flags() & Regexp::NonGreedy)
-        t_->append("?");
-      if (prec < PrecUnary)
-        t_->append(")");
-      break;
-
-    case kRegexpPlus:
-      t_->append("+");
-      if (re->parse_flags() & Regexp::NonGreedy)
-        t_->append("?");
-      if (prec < PrecUnary)
-        t_->append(")");
-      break;
-
-    case kRegexpQuest:
-      t_->append("?");
-      if (re->parse_flags() & Regexp::NonGreedy)
-        t_->append("?");
-      if (prec < PrecUnary)
-        t_->append(")");
-      break;
-
-    case kRegexpRepeat:
-      if (re->max() == -1)
-        t_->append(StringPrintf("{%d,}", re->min()));
-      else if (re->min() == re->max())
-        t_->append(StringPrintf("{%d}", re->min()));
-      else
-        t_->append(StringPrintf("{%d,%d}", re->min(), re->max()));
-      if (re->parse_flags() & Regexp::NonGreedy)
-        t_->append("?");
-      if (prec < PrecUnary)
-        t_->append(")");
-      break;
-
-    case kRegexpAnyChar:
-      t_->append(".");
-      break;
-
-    case kRegexpAnyByte:
-      t_->append("\\C");
-      break;
-
-    case kRegexpBeginLine:
-      t_->append("^");
-      break;
-
-    case kRegexpEndLine:
-      t_->append("$");
-      break;
-
-    case kRegexpBeginText:
-      t_->append("(?-m:^)");
-      break;
-
-    case kRegexpEndText:
-      if (re->parse_flags() & Regexp::WasDollar)
-        t_->append("(?-m:$)");
-      else
-        t_->append("\\z");
-      break;
-
-    case kRegexpWordBoundary:
-      t_->append("\\b");
-      break;
-
-    case kRegexpNoWordBoundary:
-      t_->append("\\B");
-      break;
-
-    case kRegexpCharClass: {
-      if (re->cc()->size() == 0) {
-        t_->append("[^\\x00-\\x{10ffff}]");
-        break;
-      }
-      t_->append("[");
-      // Heuristic: show class as negated if it contains the
-      // non-character 0xFFFE.
-      CharClass* cc = re->cc();
-      if (cc->Contains(0xFFFE)) {
-        cc = cc->Negate();
-        t_->append("^");
-      }
-      for (CharClass::iterator i = cc->begin(); i != cc->end(); ++i)
-        AppendCCRange(t_, i->lo, i->hi);
-      if (cc != re->cc())
-        cc->Delete();
-      t_->append("]");
-      break;
-    }
-
-    case kRegexpCapture:
-      t_->append(")");
-      break;
-
-    case kRegexpHaveMatch:
-      // There's no syntax accepted by the parser to generate
-      // this node (it is generated by RE2::Set) so make something
-      // up that is readable but won't compile.
-      t_->append("(?HaveMatch:%d)", re->match_id());
-      break;
-  }
-
-  // If the parent is an alternation, append the | for it.
-  if (prec == PrecAlternate)
-    t_->append("|");
-
-  return 0;
-}
-
-// Appends a rune for use in a character class to the string t.
-static void AppendCCChar(std::string* t, Rune r) {
-  if (0x20 <= r && r <= 0x7E) {
-    if (strchr("[]^-\\", r))
-      t->append("\\");
-    t->append(1, static_cast<char>(r));
-    return;
-  }
-  switch (r) {
-    default:
-      break;
-
-    case '\r':
-      t->append("\\r");
-      return;
-
-    case '\t':
-      t->append("\\t");
-      return;
-
-    case '\n':
-      t->append("\\n");
-      return;
-
-    case '\f':
-      t->append("\\f");
-      return;
-  }
-
-  if (r < 0x100) {
-    StringAppendF(t, "\\x%02x", static_cast<int>(r));
-    return;
-  }
-  StringAppendF(t, "\\x{%x}", static_cast<int>(r));
-}
-
-static void AppendCCRange(std::string* t, Rune lo, Rune hi) {
-  if (lo > hi)
-    return;
-  AppendCCChar(t, lo);
-  if (lo < hi) {
-    t->append("-");
-    AppendCCChar(t, hi);
-  }
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-
-// GENERATED BY make_unicode_casefold.py; DO NOT EDIT.
-// make_unicode_casefold.py >unicode_casefold.cc
-
-
-
-namespace duckdb_re2 {
-
-
-// 1374 groups, 2778 pairs, 349 ranges
-const CaseFold unicode_casefold[] = {
-	{ 65, 90, 32 },
-	{ 97, 106, -32 },
-	{ 107, 107, 8383 },
-	{ 108, 114, -32 },
-	{ 115, 115, 268 },
-	{ 116, 122, -32 },
-	{ 181, 181, 743 },
-	{ 192, 214, 32 },
-	{ 216, 222, 32 },
-	{ 223, 223, 7615 },
-	{ 224, 228, -32 },
-	{ 229, 229, 8262 },
-	{ 230, 246, -32 },
-	{ 248, 254, -32 },
-	{ 255, 255, 121 },
-	{ 256, 303, EvenOdd },
-	{ 306, 311, EvenOdd },
-	{ 313, 328, OddEven },
-	{ 330, 375, EvenOdd },
-	{ 376, 376, -121 },
-	{ 377, 382, OddEven },
-	{ 383, 383, -300 },
-	{ 384, 384, 195 },
-	{ 385, 385, 210 },
-	{ 386, 389, EvenOdd },
-	{ 390, 390, 206 },
-	{ 391, 392, OddEven },
-	{ 393, 394, 205 },
-	{ 395, 396, OddEven },
-	{ 398, 398, 79 },
-	{ 399, 399, 202 },
-	{ 400, 400, 203 },
-	{ 401, 402, OddEven },
-	{ 403, 403, 205 },
-	{ 404, 404, 207 },
-	{ 405, 405, 97 },
-	{ 406, 406, 211 },
-	{ 407, 407, 209 },
-	{ 408, 409, EvenOdd },
-	{ 410, 410, 163 },
-	{ 412, 412, 211 },
-	{ 413, 413, 213 },
-	{ 414, 414, 130 },
-	{ 415, 415, 214 },
-	{ 416, 421, EvenOdd },
-	{ 422, 422, 218 },
-	{ 423, 424, OddEven },
-	{ 425, 425, 218 },
-	{ 428, 429, EvenOdd },
-	{ 430, 430, 218 },
-	{ 431, 432, OddEven },
-	{ 433, 434, 217 },
-	{ 435, 438, OddEven },
-	{ 439, 439, 219 },
-	{ 440, 441, EvenOdd },
-	{ 444, 445, EvenOdd },
-	{ 447, 447, 56 },
-	{ 452, 452, EvenOdd },
-	{ 453, 453, OddEven },
-	{ 454, 454, -2 },
-	{ 455, 455, OddEven },
-	{ 456, 456, EvenOdd },
-	{ 457, 457, -2 },
-	{ 458, 458, EvenOdd },
-	{ 459, 459, OddEven },
-	{ 460, 460, -2 },
-	{ 461, 476, OddEven },
-	{ 477, 477, -79 },
-	{ 478, 495, EvenOdd },
-	{ 497, 497, OddEven },
-	{ 498, 498, EvenOdd },
-	{ 499, 499, -2 },
-	{ 500, 501, EvenOdd },
-	{ 502, 502, -97 },
-	{ 503, 503, -56 },
-	{ 504, 543, EvenOdd },
-	{ 544, 544, -130 },
-	{ 546, 563, EvenOdd },
-	{ 570, 570, 10795 },
-	{ 571, 572, OddEven },
-	{ 573, 573, -163 },
-	{ 574, 574, 10792 },
-	{ 575, 576, 10815 },
-	{ 577, 578, OddEven },
-	{ 579, 579, -195 },
-	{ 580, 580, 69 },
-	{ 581, 581, 71 },
-	{ 582, 591, EvenOdd },
-	{ 592, 592, 10783 },
-	{ 593, 593, 10780 },
-	{ 594, 594, 10782 },
-	{ 595, 595, -210 },
-	{ 596, 596, -206 },
-	{ 598, 599, -205 },
-	{ 601, 601, -202 },
-	{ 603, 603, -203 },
-	{ 604, 604, 42319 },
-	{ 608, 608, -205 },
-	{ 609, 609, 42315 },
-	{ 611, 611, -207 },
-	{ 613, 613, 42280 },
-	{ 614, 614, 42308 },
-	{ 616, 616, -209 },
-	{ 617, 617, -211 },
-	{ 618, 618, 42308 },
-	{ 619, 619, 10743 },
-	{ 620, 620, 42305 },
-	{ 623, 623, -211 },
-	{ 625, 625, 10749 },
-	{ 626, 626, -213 },
-	{ 629, 629, -214 },
-	{ 637, 637, 10727 },
-	{ 640, 640, -218 },
-	{ 643, 643, -218 },
-	{ 647, 647, 42282 },
-	{ 648, 648, -218 },
-	{ 649, 649, -69 },
-	{ 650, 651, -217 },
-	{ 652, 652, -71 },
-	{ 658, 658, -219 },
-	{ 669, 669, 42261 },
-	{ 670, 670, 42258 },
-	{ 837, 837, 84 },
-	{ 880, 883, EvenOdd },
-	{ 886, 887, EvenOdd },
-	{ 891, 893, 130 },
-	{ 895, 895, 116 },
-	{ 902, 902, 38 },
-	{ 904, 906, 37 },
-	{ 908, 908, 64 },
-	{ 910, 911, 63 },
-	{ 913, 929, 32 },
-	{ 931, 931, 31 },
-	{ 932, 939, 32 },
-	{ 940, 940, -38 },
-	{ 941, 943, -37 },
-	{ 945, 945, -32 },
-	{ 946, 946, 30 },
-	{ 947, 948, -32 },
-	{ 949, 949, 64 },
-	{ 950, 951, -32 },
-	{ 952, 952, 25 },
-	{ 953, 953, 7173 },
-	{ 954, 954, 54 },
-	{ 955, 955, -32 },
-	{ 956, 956, -775 },
-	{ 957, 959, -32 },
-	{ 960, 960, 22 },
-	{ 961, 961, 48 },
-	{ 962, 962, EvenOdd },
-	{ 963, 965, -32 },
-	{ 966, 966, 15 },
-	{ 967, 968, -32 },
-	{ 969, 969, 7517 },
-	{ 970, 971, -32 },
-	{ 972, 972, -64 },
-	{ 973, 974, -63 },
-	{ 975, 975, 8 },
-	{ 976, 976, -62 },
-	{ 977, 977, 35 },
-	{ 981, 981, -47 },
-	{ 982, 982, -54 },
-	{ 983, 983, -8 },
-	{ 984, 1007, EvenOdd },
-	{ 1008, 1008, -86 },
-	{ 1009, 1009, -80 },
-	{ 1010, 1010, 7 },
-	{ 1011, 1011, -116 },
-	{ 1012, 1012, -92 },
-	{ 1013, 1013, -96 },
-	{ 1015, 1016, OddEven },
-	{ 1017, 1017, -7 },
-	{ 1018, 1019, EvenOdd },
-	{ 1021, 1023, -130 },
-	{ 1024, 1039, 80 },
-	{ 1040, 1071, 32 },
-	{ 1072, 1073, -32 },
-	{ 1074, 1074, 6222 },
-	{ 1075, 1075, -32 },
-	{ 1076, 1076, 6221 },
-	{ 1077, 1085, -32 },
-	{ 1086, 1086, 6212 },
-	{ 1087, 1088, -32 },
-	{ 1089, 1090, 6210 },
-	{ 1091, 1097, -32 },
-	{ 1098, 1098, 6204 },
-	{ 1099, 1103, -32 },
-	{ 1104, 1119, -80 },
-	{ 1120, 1122, EvenOdd },
-	{ 1123, 1123, 6180 },
-	{ 1124, 1153, EvenOdd },
-	{ 1162, 1215, EvenOdd },
-	{ 1216, 1216, 15 },
-	{ 1217, 1230, OddEven },
-	{ 1231, 1231, -15 },
-	{ 1232, 1327, EvenOdd },
-	{ 1329, 1366, 48 },
-	{ 1377, 1414, -48 },
-	{ 4256, 4293, 7264 },
-	{ 4295, 4295, 7264 },
-	{ 4301, 4301, 7264 },
-	{ 4304, 4346, 3008 },
-	{ 4349, 4351, 3008 },
-	{ 5024, 5103, 38864 },
-	{ 5104, 5109, 8 },
-	{ 5112, 5117, -8 },
-	{ 7296, 7296, -6254 },
-	{ 7297, 7297, -6253 },
-	{ 7298, 7298, -6244 },
-	{ 7299, 7299, -6242 },
-	{ 7300, 7300, EvenOdd },
-	{ 7301, 7301, -6243 },
-	{ 7302, 7302, -6236 },
-	{ 7303, 7303, -6181 },
-	{ 7304, 7304, 35266 },
-	{ 7312, 7354, -3008 },
-	{ 7357, 7359, -3008 },
-	{ 7545, 7545, 35332 },
-	{ 7549, 7549, 3814 },
-	{ 7680, 7776, EvenOdd },
-	{ 7777, 7777, 58 },
-	{ 7778, 7829, EvenOdd },
-	{ 7835, 7835, -59 },
-	{ 7838, 7838, -7615 },
-	{ 7840, 7935, EvenOdd },
-	{ 7936, 7943, 8 },
-	{ 7944, 7951, -8 },
-	{ 7952, 7957, 8 },
-	{ 7960, 7965, -8 },
-	{ 7968, 7975, 8 },
-	{ 7976, 7983, -8 },
-	{ 7984, 7991, 8 },
-	{ 7992, 7999, -8 },
-	{ 8000, 8005, 8 },
-	{ 8008, 8013, -8 },
-	{ 8017, 8017, 8 },
-	{ 8019, 8019, 8 },
-	{ 8021, 8021, 8 },
-	{ 8023, 8023, 8 },
-	{ 8025, 8025, -8 },
-	{ 8027, 8027, -8 },
-	{ 8029, 8029, -8 },
-	{ 8031, 8031, -8 },
-	{ 8032, 8039, 8 },
-	{ 8040, 8047, -8 },
-	{ 8048, 8049, 74 },
-	{ 8050, 8053, 86 },
-	{ 8054, 8055, 100 },
-	{ 8056, 8057, 128 },
-	{ 8058, 8059, 112 },
-	{ 8060, 8061, 126 },
-	{ 8064, 8071, 8 },
-	{ 8072, 8079, -8 },
-	{ 8080, 8087, 8 },
-	{ 8088, 8095, -8 },
-	{ 8096, 8103, 8 },
-	{ 8104, 8111, -8 },
-	{ 8112, 8113, 8 },
-	{ 8115, 8115, 9 },
-	{ 8120, 8121, -8 },
-	{ 8122, 8123, -74 },
-	{ 8124, 8124, -9 },
-	{ 8126, 8126, -7289 },
-	{ 8131, 8131, 9 },
-	{ 8136, 8139, -86 },
-	{ 8140, 8140, -9 },
-	{ 8144, 8145, 8 },
-	{ 8152, 8153, -8 },
-	{ 8154, 8155, -100 },
-	{ 8160, 8161, 8 },
-	{ 8165, 8165, 7 },
-	{ 8168, 8169, -8 },
-	{ 8170, 8171, -112 },
-	{ 8172, 8172, -7 },
-	{ 8179, 8179, 9 },
-	{ 8184, 8185, -128 },
-	{ 8186, 8187, -126 },
-	{ 8188, 8188, -9 },
-	{ 8486, 8486, -7549 },
-	{ 8490, 8490, -8415 },
-	{ 8491, 8491, -8294 },
-	{ 8498, 8498, 28 },
-	{ 8526, 8526, -28 },
-	{ 8544, 8559, 16 },
-	{ 8560, 8575, -16 },
-	{ 8579, 8580, OddEven },
-	{ 9398, 9423, 26 },
-	{ 9424, 9449, -26 },
-	{ 11264, 11310, 48 },
-	{ 11312, 11358, -48 },
-	{ 11360, 11361, EvenOdd },
-	{ 11362, 11362, -10743 },
-	{ 11363, 11363, -3814 },
-	{ 11364, 11364, -10727 },
-	{ 11365, 11365, -10795 },
-	{ 11366, 11366, -10792 },
-	{ 11367, 11372, OddEven },
-	{ 11373, 11373, -10780 },
-	{ 11374, 11374, -10749 },
-	{ 11375, 11375, -10783 },
-	{ 11376, 11376, -10782 },
-	{ 11378, 11379, EvenOdd },
-	{ 11381, 11382, OddEven },
-	{ 11390, 11391, -10815 },
-	{ 11392, 11491, EvenOdd },
-	{ 11499, 11502, OddEven },
-	{ 11506, 11507, EvenOdd },
-	{ 11520, 11557, -7264 },
-	{ 11559, 11559, -7264 },
-	{ 11565, 11565, -7264 },
-	{ 42560, 42570, EvenOdd },
-	{ 42571, 42571, -35267 },
-	{ 42572, 42605, EvenOdd },
-	{ 42624, 42651, EvenOdd },
-	{ 42786, 42799, EvenOdd },
-	{ 42802, 42863, EvenOdd },
-	{ 42873, 42876, OddEven },
-	{ 42877, 42877, -35332 },
-	{ 42878, 42887, EvenOdd },
-	{ 42891, 42892, OddEven },
-	{ 42893, 42893, -42280 },
-	{ 42896, 42899, EvenOdd },
-	{ 42902, 42921, EvenOdd },
-	{ 42922, 42922, -42308 },
-	{ 42923, 42923, -42319 },
-	{ 42924, 42924, -42315 },
-	{ 42925, 42925, -42305 },
-	{ 42926, 42926, -42308 },
-	{ 42928, 42928, -42258 },
-	{ 42929, 42929, -42282 },
-	{ 42930, 42930, -42261 },
-	{ 42931, 42931, 928 },
-	{ 42932, 42937, EvenOdd },
-	{ 43859, 43859, -928 },
-	{ 43888, 43967, -38864 },
-	{ 65313, 65338, 32 },
-	{ 65345, 65370, -32 },
-	{ 66560, 66599, 40 },
-	{ 66600, 66639, -40 },
-	{ 66736, 66771, 40 },
-	{ 66776, 66811, -40 },
-	{ 68736, 68786, 64 },
-	{ 68800, 68850, -64 },
-	{ 71840, 71871, 32 },
-	{ 71872, 71903, -32 },
-	{ 93760, 93791, 32 },
-	{ 93792, 93823, -32 },
-	{ 125184, 125217, 34 },
-	{ 125218, 125251, -34 },
-};
-const int num_unicode_casefold = 349;
-
-// 1374 groups, 1404 pairs, 194 ranges
-const CaseFold unicode_tolower[] = {
-	{ 65, 90, 32 },
-	{ 181, 181, 775 },
-	{ 192, 214, 32 },
-	{ 216, 222, 32 },
-	{ 256, 302, EvenOddSkip },
-	{ 306, 310, EvenOddSkip },
-	{ 313, 327, OddEvenSkip },
-	{ 330, 374, EvenOddSkip },
-	{ 376, 376, -121 },
-	{ 377, 381, OddEvenSkip },
-	{ 383, 383, -268 },
-	{ 385, 385, 210 },
-	{ 386, 388, EvenOddSkip },
-	{ 390, 390, 206 },
-	{ 391, 391, OddEven },
-	{ 393, 394, 205 },
-	{ 395, 395, OddEven },
-	{ 398, 398, 79 },
-	{ 399, 399, 202 },
-	{ 400, 400, 203 },
-	{ 401, 401, OddEven },
-	{ 403, 403, 205 },
-	{ 404, 404, 207 },
-	{ 406, 406, 211 },
-	{ 407, 407, 209 },
-	{ 408, 408, EvenOdd },
-	{ 412, 412, 211 },
-	{ 413, 413, 213 },
-	{ 415, 415, 214 },
-	{ 416, 420, EvenOddSkip },
-	{ 422, 422, 218 },
-	{ 423, 423, OddEven },
-	{ 425, 425, 218 },
-	{ 428, 428, EvenOdd },
-	{ 430, 430, 218 },
-	{ 431, 431, OddEven },
-	{ 433, 434, 217 },
-	{ 435, 437, OddEvenSkip },
-	{ 439, 439, 219 },
-	{ 440, 440, EvenOdd },
-	{ 444, 444, EvenOdd },
-	{ 452, 452, 2 },
-	{ 453, 453, OddEven },
-	{ 455, 455, 2 },
-	{ 456, 456, EvenOdd },
-	{ 458, 458, 2 },
-	{ 459, 475, OddEvenSkip },
-	{ 478, 494, EvenOddSkip },
-	{ 497, 497, 2 },
-	{ 498, 500, EvenOddSkip },
-	{ 502, 502, -97 },
-	{ 503, 503, -56 },
-	{ 504, 542, EvenOddSkip },
-	{ 544, 544, -130 },
-	{ 546, 562, EvenOddSkip },
-	{ 570, 570, 10795 },
-	{ 571, 571, OddEven },
-	{ 573, 573, -163 },
-	{ 574, 574, 10792 },
-	{ 577, 577, OddEven },
-	{ 579, 579, -195 },
-	{ 580, 580, 69 },
-	{ 581, 581, 71 },
-	{ 582, 590, EvenOddSkip },
-	{ 837, 837, 116 },
-	{ 880, 882, EvenOddSkip },
-	{ 886, 886, EvenOdd },
-	{ 895, 895, 116 },
-	{ 902, 902, 38 },
-	{ 904, 906, 37 },
-	{ 908, 908, 64 },
-	{ 910, 911, 63 },
-	{ 913, 929, 32 },
-	{ 931, 939, 32 },
-	{ 962, 962, EvenOdd },
-	{ 975, 975, 8 },
-	{ 976, 976, -30 },
-	{ 977, 977, -25 },
-	{ 981, 981, -15 },
-	{ 982, 982, -22 },
-	{ 984, 1006, EvenOddSkip },
-	{ 1008, 1008, -54 },
-	{ 1009, 1009, -48 },
-	{ 1012, 1012, -60 },
-	{ 1013, 1013, -64 },
-	{ 1015, 1015, OddEven },
-	{ 1017, 1017, -7 },
-	{ 1018, 1018, EvenOdd },
-	{ 1021, 1023, -130 },
-	{ 1024, 1039, 80 },
-	{ 1040, 1071, 32 },
-	{ 1120, 1152, EvenOddSkip },
-	{ 1162, 1214, EvenOddSkip },
-	{ 1216, 1216, 15 },
-	{ 1217, 1229, OddEvenSkip },
-	{ 1232, 1326, EvenOddSkip },
-	{ 1329, 1366, 48 },
-	{ 4256, 4293, 7264 },
-	{ 4295, 4295, 7264 },
-	{ 4301, 4301, 7264 },
-	{ 5112, 5117, -8 },
-	{ 7296, 7296, -6222 },
-	{ 7297, 7297, -6221 },
-	{ 7298, 7298, -6212 },
-	{ 7299, 7300, -6210 },
-	{ 7301, 7301, -6211 },
-	{ 7302, 7302, -6204 },
-	{ 7303, 7303, -6180 },
-	{ 7304, 7304, 35267 },
-	{ 7312, 7354, -3008 },
-	{ 7357, 7359, -3008 },
-	{ 7680, 7828, EvenOddSkip },
-	{ 7835, 7835, -58 },
-	{ 7838, 7838, -7615 },
-	{ 7840, 7934, EvenOddSkip },
-	{ 7944, 7951, -8 },
-	{ 7960, 7965, -8 },
-	{ 7976, 7983, -8 },
-	{ 7992, 7999, -8 },
-	{ 8008, 8013, -8 },
-	{ 8025, 8025, -8 },
-	{ 8027, 8027, -8 },
-	{ 8029, 8029, -8 },
-	{ 8031, 8031, -8 },
-	{ 8040, 8047, -8 },
-	{ 8072, 8079, -8 },
-	{ 8088, 8095, -8 },
-	{ 8104, 8111, -8 },
-	{ 8120, 8121, -8 },
-	{ 8122, 8123, -74 },
-	{ 8124, 8124, -9 },
-	{ 8126, 8126, -7173 },
-	{ 8136, 8139, -86 },
-	{ 8140, 8140, -9 },
-	{ 8152, 8153, -8 },
-	{ 8154, 8155, -100 },
-	{ 8168, 8169, -8 },
-	{ 8170, 8171, -112 },
-	{ 8172, 8172, -7 },
-	{ 8184, 8185, -128 },
-	{ 8186, 8187, -126 },
-	{ 8188, 8188, -9 },
-	{ 8486, 8486, -7517 },
-	{ 8490, 8490, -8383 },
-	{ 8491, 8491, -8262 },
-	{ 8498, 8498, 28 },
-	{ 8544, 8559, 16 },
-	{ 8579, 8579, OddEven },
-	{ 9398, 9423, 26 },
-	{ 11264, 11310, 48 },
-	{ 11360, 11360, EvenOdd },
-	{ 11362, 11362, -10743 },
-	{ 11363, 11363, -3814 },
-	{ 11364, 11364, -10727 },
-	{ 11367, 11371, OddEvenSkip },
-	{ 11373, 11373, -10780 },
-	{ 11374, 11374, -10749 },
-	{ 11375, 11375, -10783 },
-	{ 11376, 11376, -10782 },
-	{ 11378, 11378, EvenOdd },
-	{ 11381, 11381, OddEven },
-	{ 11390, 11391, -10815 },
-	{ 11392, 11490, EvenOddSkip },
-	{ 11499, 11501, OddEvenSkip },
-	{ 11506, 11506, EvenOdd },
-	{ 42560, 42604, EvenOddSkip },
-	{ 42624, 42650, EvenOddSkip },
-	{ 42786, 42798, EvenOddSkip },
-	{ 42802, 42862, EvenOddSkip },
-	{ 42873, 42875, OddEvenSkip },
-	{ 42877, 42877, -35332 },
-	{ 42878, 42886, EvenOddSkip },
-	{ 42891, 42891, OddEven },
-	{ 42893, 42893, -42280 },
-	{ 42896, 42898, EvenOddSkip },
-	{ 42902, 42920, EvenOddSkip },
-	{ 42922, 42922, -42308 },
-	{ 42923, 42923, -42319 },
-	{ 42924, 42924, -42315 },
-	{ 42925, 42925, -42305 },
-	{ 42926, 42926, -42308 },
-	{ 42928, 42928, -42258 },
-	{ 42929, 42929, -42282 },
-	{ 42930, 42930, -42261 },
-	{ 42931, 42931, 928 },
-	{ 42932, 42936, EvenOddSkip },
-	{ 43888, 43967, -38864 },
-	{ 65313, 65338, 32 },
-	{ 66560, 66599, 40 },
-	{ 66736, 66771, 40 },
-	{ 68736, 68786, 64 },
-	{ 71840, 71871, 32 },
-	{ 93760, 93791, 32 },
-	{ 125184, 125217, 34 },
-};
-const int num_unicode_tolower = 194;
-
-
-
-} // namespace duckdb_re2
-
-
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-
-// GENERATED BY make_unicode_groups.py; DO NOT EDIT.
-// make_unicode_groups.py >unicode_groups.cc
-
-
-
-namespace duckdb_re2 {
-
-
-static const URange16 Ps_range16[] = {
-	{ 40, 40 },
-	{ 91, 91 },
-	{ 123, 123 },
-	{ 3898, 3898 },
-	{ 3900, 3900 },
-	{ 5787, 5787 },
-	{ 8218, 8218 },
-	{ 8222, 8222 },
-	{ 8261, 8261 },
-	{ 8317, 8317 },
-	{ 8333, 8333 },
-	{ 8968, 8968 },
-	{ 8970, 8970 },
-	{ 9001, 9001 },
-	{ 10088, 10088 },
-	{ 10090, 10090 },
-	{ 10092, 10092 },
-	{ 10094, 10094 },
-	{ 10096, 10096 },
-	{ 10098, 10098 },
-	{ 10100, 10100 },
-	{ 10181, 10181 },
-	{ 10214, 10214 },
-	{ 10216, 10216 },
-	{ 10218, 10218 },
-	{ 10220, 10220 },
-	{ 10222, 10222 },
-	{ 10627, 10627 },
-	{ 10629, 10629 },
-	{ 10631, 10631 },
-	{ 10633, 10633 },
-	{ 10635, 10635 },
-	{ 10637, 10637 },
-	{ 10639, 10639 },
-	{ 10641, 10641 },
-	{ 10643, 10643 },
-	{ 10645, 10645 },
-	{ 10647, 10647 },
-	{ 10712, 10712 },
-	{ 10714, 10714 },
-	{ 10748, 10748 },
-	{ 11810, 11810 },
-	{ 11812, 11812 },
-	{ 11814, 11814 },
-	{ 11816, 11816 },
-	{ 11842, 11842 },
-	{ 12296, 12296 },
-	{ 12298, 12298 },
-	{ 12300, 12300 },
-	{ 12302, 12302 },
-	{ 12304, 12304 },
-	{ 12308, 12308 },
-	{ 12310, 12310 },
-	{ 12312, 12312 },
-	{ 12314, 12314 },
-	{ 12317, 12317 },
-	{ 64831, 64831 },
-	{ 65047, 65047 },
-	{ 65077, 65077 },
-	{ 65079, 65079 },
-	{ 65081, 65081 },
-	{ 65083, 65083 },
-	{ 65085, 65085 },
-	{ 65087, 65087 },
-	{ 65089, 65089 },
-	{ 65091, 65091 },
-	{ 65095, 65095 },
-	{ 65113, 65113 },
-	{ 65115, 65115 },
-	{ 65117, 65117 },
-	{ 65288, 65288 },
-	{ 65339, 65339 },
-	{ 65371, 65371 },
-	{ 65375, 65375 },
-	{ 65378, 65378 },
-};
-static const URange16 Nl_range16[] = {
-	{ 5870, 5872 },
-	{ 8544, 8578 },
-	{ 8581, 8584 },
-	{ 12295, 12295 },
-	{ 12321, 12329 },
-	{ 12344, 12346 },
-	{ 42726, 42735 },
-};
-static const URange32 Nl_range32[] = {
-	{ 65856, 65908 },
-	{ 66369, 66369 },
-	{ 66378, 66378 },
-	{ 66513, 66517 },
-	{ 74752, 74862 },
-};
-static const URange16 No_range16[] = {
-	{ 178, 179 },
-	{ 185, 185 },
-	{ 188, 190 },
-	{ 2548, 2553 },
-	{ 2930, 2935 },
-	{ 3056, 3058 },
-	{ 3192, 3198 },
-	{ 3416, 3422 },
-	{ 3440, 3448 },
-	{ 3882, 3891 },
-	{ 4969, 4988 },
-	{ 6128, 6137 },
-	{ 6618, 6618 },
-	{ 8304, 8304 },
-	{ 8308, 8313 },
-	{ 8320, 8329 },
-	{ 8528, 8543 },
-	{ 8585, 8585 },
-	{ 9312, 9371 },
-	{ 9450, 9471 },
-	{ 10102, 10131 },
-	{ 11517, 11517 },
-	{ 12690, 12693 },
-	{ 12832, 12841 },
-	{ 12872, 12879 },
-	{ 12881, 12895 },
-	{ 12928, 12937 },
-	{ 12977, 12991 },
-	{ 43056, 43061 },
-};
-static const URange32 No_range32[] = {
-	{ 65799, 65843 },
-	{ 65909, 65912 },
-	{ 65930, 65931 },
-	{ 66273, 66299 },
-	{ 66336, 66339 },
-	{ 67672, 67679 },
-	{ 67705, 67711 },
-	{ 67751, 67759 },
-	{ 67835, 67839 },
-	{ 67862, 67867 },
-	{ 68028, 68029 },
-	{ 68032, 68047 },
-	{ 68050, 68095 },
-	{ 68160, 68168 },
-	{ 68221, 68222 },
-	{ 68253, 68255 },
-	{ 68331, 68335 },
-	{ 68440, 68447 },
-	{ 68472, 68479 },
-	{ 68521, 68527 },
-	{ 68858, 68863 },
-	{ 69216, 69246 },
-	{ 69405, 69414 },
-	{ 69457, 69460 },
-	{ 69714, 69733 },
-	{ 70113, 70132 },
-	{ 71482, 71483 },
-	{ 71914, 71922 },
-	{ 72794, 72812 },
-	{ 93019, 93025 },
-	{ 93824, 93846 },
-	{ 119520, 119539 },
-	{ 119648, 119672 },
-	{ 125127, 125135 },
-	{ 126065, 126123 },
-	{ 126125, 126127 },
-	{ 126129, 126132 },
-	{ 127232, 127244 },
-};
-static const URange16 Lo_range16[] = {
-	{ 170, 170 },
-	{ 186, 186 },
-	{ 443, 443 },
-	{ 448, 451 },
-	{ 660, 660 },
-	{ 1488, 1514 },
-	{ 1519, 1522 },
-	{ 1568, 1599 },
-	{ 1601, 1610 },
-	{ 1646, 1647 },
-	{ 1649, 1747 },
-	{ 1749, 1749 },
-	{ 1774, 1775 },
-	{ 1786, 1788 },
-	{ 1791, 1791 },
-	{ 1808, 1808 },
-	{ 1810, 1839 },
-	{ 1869, 1957 },
-	{ 1969, 1969 },
-	{ 1994, 2026 },
-	{ 2048, 2069 },
-	{ 2112, 2136 },
-	{ 2144, 2154 },
-	{ 2208, 2228 },
-	{ 2230, 2237 },
-	{ 2308, 2361 },
-	{ 2365, 2365 },
-	{ 2384, 2384 },
-	{ 2392, 2401 },
-	{ 2418, 2432 },
-	{ 2437, 2444 },
-	{ 2447, 2448 },
-	{ 2451, 2472 },
-	{ 2474, 2480 },
-	{ 2482, 2482 },
-	{ 2486, 2489 },
-	{ 2493, 2493 },
-	{ 2510, 2510 },
-	{ 2524, 2525 },
-	{ 2527, 2529 },
-	{ 2544, 2545 },
-	{ 2556, 2556 },
-	{ 2565, 2570 },
-	{ 2575, 2576 },
-	{ 2579, 2600 },
-	{ 2602, 2608 },
-	{ 2610, 2611 },
-	{ 2613, 2614 },
-	{ 2616, 2617 },
-	{ 2649, 2652 },
-	{ 2654, 2654 },
-	{ 2674, 2676 },
-	{ 2693, 2701 },
-	{ 2703, 2705 },
-	{ 2707, 2728 },
-	{ 2730, 2736 },
-	{ 2738, 2739 },
-	{ 2741, 2745 },
-	{ 2749, 2749 },
-	{ 2768, 2768 },
-	{ 2784, 2785 },
-	{ 2809, 2809 },
-	{ 2821, 2828 },
-	{ 2831, 2832 },
-	{ 2835, 2856 },
-	{ 2858, 2864 },
-	{ 2866, 2867 },
-	{ 2869, 2873 },
-	{ 2877, 2877 },
-	{ 2908, 2909 },
-	{ 2911, 2913 },
-	{ 2929, 2929 },
-	{ 2947, 2947 },
-	{ 2949, 2954 },
-	{ 2958, 2960 },
-	{ 2962, 2965 },
-	{ 2969, 2970 },
-	{ 2972, 2972 },
-	{ 2974, 2975 },
-	{ 2979, 2980 },
-	{ 2984, 2986 },
-	{ 2990, 3001 },
-	{ 3024, 3024 },
-	{ 3077, 3084 },
-	{ 3086, 3088 },
-	{ 3090, 3112 },
-	{ 3114, 3129 },
-	{ 3133, 3133 },
-	{ 3160, 3162 },
-	{ 3168, 3169 },
-	{ 3200, 3200 },
-	{ 3205, 3212 },
-	{ 3214, 3216 },
-	{ 3218, 3240 },
-	{ 3242, 3251 },
-	{ 3253, 3257 },
-	{ 3261, 3261 },
-	{ 3294, 3294 },
-	{ 3296, 3297 },
-	{ 3313, 3314 },
-	{ 3333, 3340 },
-	{ 3342, 3344 },
-	{ 3346, 3386 },
-	{ 3389, 3389 },
-	{ 3406, 3406 },
-	{ 3412, 3414 },
-	{ 3423, 3425 },
-	{ 3450, 3455 },
-	{ 3461, 3478 },
-	{ 3482, 3505 },
-	{ 3507, 3515 },
-	{ 3517, 3517 },
-	{ 3520, 3526 },
-	{ 3585, 3632 },
-	{ 3634, 3635 },
-	{ 3648, 3653 },
-	{ 3713, 3714 },
-	{ 3716, 3716 },
-	{ 3719, 3720 },
-	{ 3722, 3722 },
-	{ 3725, 3725 },
-	{ 3732, 3735 },
-	{ 3737, 3743 },
-	{ 3745, 3747 },
-	{ 3749, 3749 },
-	{ 3751, 3751 },
-	{ 3754, 3755 },
-	{ 3757, 3760 },
-	{ 3762, 3763 },
-	{ 3773, 3773 },
-	{ 3776, 3780 },
-	{ 3804, 3807 },
-	{ 3840, 3840 },
-	{ 3904, 3911 },
-	{ 3913, 3948 },
-	{ 3976, 3980 },
-	{ 4096, 4138 },
-	{ 4159, 4159 },
-	{ 4176, 4181 },
-	{ 4186, 4189 },
-	{ 4193, 4193 },
-	{ 4197, 4198 },
-	{ 4206, 4208 },
-	{ 4213, 4225 },
-	{ 4238, 4238 },
-	{ 4352, 4680 },
-	{ 4682, 4685 },
-	{ 4688, 4694 },
-	{ 4696, 4696 },
-	{ 4698, 4701 },
-	{ 4704, 4744 },
-	{ 4746, 4749 },
-	{ 4752, 4784 },
-	{ 4786, 4789 },
-	{ 4792, 4798 },
-	{ 4800, 4800 },
-	{ 4802, 4805 },
-	{ 4808, 4822 },
-	{ 4824, 4880 },
-	{ 4882, 4885 },
-	{ 4888, 4954 },
-	{ 4992, 5007 },
-	{ 5121, 5740 },
-	{ 5743, 5759 },
-	{ 5761, 5786 },
-	{ 5792, 5866 },
-	{ 5873, 5880 },
-	{ 5888, 5900 },
-	{ 5902, 5905 },
-	{ 5920, 5937 },
-	{ 5952, 5969 },
-	{ 5984, 5996 },
-	{ 5998, 6000 },
-	{ 6016, 6067 },
-	{ 6108, 6108 },
-	{ 6176, 6210 },
-	{ 6212, 6264 },
-	{ 6272, 6276 },
-	{ 6279, 6312 },
-	{ 6314, 6314 },
-	{ 6320, 6389 },
-	{ 6400, 6430 },
-	{ 6480, 6509 },
-	{ 6512, 6516 },
-	{ 6528, 6571 },
-	{ 6576, 6601 },
-	{ 6656, 6678 },
-	{ 6688, 6740 },
-	{ 6917, 6963 },
-	{ 6981, 6987 },
-	{ 7043, 7072 },
-	{ 7086, 7087 },
-	{ 7098, 7141 },
-	{ 7168, 7203 },
-	{ 7245, 7247 },
-	{ 7258, 7287 },
-	{ 7401, 7404 },
-	{ 7406, 7409 },
-	{ 7413, 7414 },
-	{ 8501, 8504 },
-	{ 11568, 11623 },
-	{ 11648, 11670 },
-	{ 11680, 11686 },
-	{ 11688, 11694 },
-	{ 11696, 11702 },
-	{ 11704, 11710 },
-	{ 11712, 11718 },
-	{ 11720, 11726 },
-	{ 11728, 11734 },
-	{ 11736, 11742 },
-	{ 12294, 12294 },
-	{ 12348, 12348 },
-	{ 12353, 12438 },
-	{ 12447, 12447 },
-	{ 12449, 12538 },
-	{ 12543, 12543 },
-	{ 12549, 12591 },
-	{ 12593, 12686 },
-	{ 12704, 12730 },
-	{ 12784, 12799 },
-	{ 13312, 19893 },
-	{ 19968, 40943 },
-	{ 40960, 40980 },
-	{ 40982, 42124 },
-	{ 42192, 42231 },
-	{ 42240, 42507 },
-	{ 42512, 42527 },
-	{ 42538, 42539 },
-	{ 42606, 42606 },
-	{ 42656, 42725 },
-	{ 42895, 42895 },
-	{ 42999, 42999 },
-	{ 43003, 43009 },
-	{ 43011, 43013 },
-	{ 43015, 43018 },
-	{ 43020, 43042 },
-	{ 43072, 43123 },
-	{ 43138, 43187 },
-	{ 43250, 43255 },
-	{ 43259, 43259 },
-	{ 43261, 43262 },
-	{ 43274, 43301 },
-	{ 43312, 43334 },
-	{ 43360, 43388 },
-	{ 43396, 43442 },
-	{ 43488, 43492 },
-	{ 43495, 43503 },
-	{ 43514, 43518 },
-	{ 43520, 43560 },
-	{ 43584, 43586 },
-	{ 43588, 43595 },
-	{ 43616, 43631 },
-	{ 43633, 43638 },
-	{ 43642, 43642 },
-	{ 43646, 43695 },
-	{ 43697, 43697 },
-	{ 43701, 43702 },
-	{ 43705, 43709 },
-	{ 43712, 43712 },
-	{ 43714, 43714 },
-	{ 43739, 43740 },
-	{ 43744, 43754 },
-	{ 43762, 43762 },
-	{ 43777, 43782 },
-	{ 43785, 43790 },
-	{ 43793, 43798 },
-	{ 43808, 43814 },
-	{ 43816, 43822 },
-	{ 43968, 44002 },
-	{ 44032, 55203 },
-	{ 55216, 55238 },
-	{ 55243, 55291 },
-	{ 63744, 64109 },
-	{ 64112, 64217 },
-	{ 64285, 64285 },
-	{ 64287, 64296 },
-	{ 64298, 64310 },
-	{ 64312, 64316 },
-	{ 64318, 64318 },
-	{ 64320, 64321 },
-	{ 64323, 64324 },
-	{ 64326, 64433 },
-	{ 64467, 64829 },
-	{ 64848, 64911 },
-	{ 64914, 64967 },
-	{ 65008, 65019 },
-	{ 65136, 65140 },
-	{ 65142, 65276 },
-	{ 65382, 65391 },
-	{ 65393, 65437 },
-	{ 65440, 65470 },
-	{ 65474, 65479 },
-	{ 65482, 65487 },
-	{ 65490, 65495 },
-	{ 65498, 65500 },
-};
-static const URange32 Lo_range32[] = {
-	{ 65536, 65547 },
-	{ 65549, 65574 },
-	{ 65576, 65594 },
-	{ 65596, 65597 },
-	{ 65599, 65613 },
-	{ 65616, 65629 },
-	{ 65664, 65786 },
-	{ 66176, 66204 },
-	{ 66208, 66256 },
-	{ 66304, 66335 },
-	{ 66349, 66368 },
-	{ 66370, 66377 },
-	{ 66384, 66421 },
-	{ 66432, 66461 },
-	{ 66464, 66499 },
-	{ 66504, 66511 },
-	{ 66640, 66717 },
-	{ 66816, 66855 },
-	{ 66864, 66915 },
-	{ 67072, 67382 },
-	{ 67392, 67413 },
-	{ 67424, 67431 },
-	{ 67584, 67589 },
-	{ 67592, 67592 },
-	{ 67594, 67637 },
-	{ 67639, 67640 },
-	{ 67644, 67644 },
-	{ 67647, 67669 },
-	{ 67680, 67702 },
-	{ 67712, 67742 },
-	{ 67808, 67826 },
-	{ 67828, 67829 },
-	{ 67840, 67861 },
-	{ 67872, 67897 },
-	{ 67968, 68023 },
-	{ 68030, 68031 },
-	{ 68096, 68096 },
-	{ 68112, 68115 },
-	{ 68117, 68119 },
-	{ 68121, 68149 },
-	{ 68192, 68220 },
-	{ 68224, 68252 },
-	{ 68288, 68295 },
-	{ 68297, 68324 },
-	{ 68352, 68405 },
-	{ 68416, 68437 },
-	{ 68448, 68466 },
-	{ 68480, 68497 },
-	{ 68608, 68680 },
-	{ 68864, 68899 },
-	{ 69376, 69404 },
-	{ 69415, 69415 },
-	{ 69424, 69445 },
-	{ 69635, 69687 },
-	{ 69763, 69807 },
-	{ 69840, 69864 },
-	{ 69891, 69926 },
-	{ 69956, 69956 },
-	{ 69968, 70002 },
-	{ 70006, 70006 },
-	{ 70019, 70066 },
-	{ 70081, 70084 },
-	{ 70106, 70106 },
-	{ 70108, 70108 },
-	{ 70144, 70161 },
-	{ 70163, 70187 },
-	{ 70272, 70278 },
-	{ 70280, 70280 },
-	{ 70282, 70285 },
-	{ 70287, 70301 },
-	{ 70303, 70312 },
-	{ 70320, 70366 },
-	{ 70405, 70412 },
-	{ 70415, 70416 },
-	{ 70419, 70440 },
-	{ 70442, 70448 },
-	{ 70450, 70451 },
-	{ 70453, 70457 },
-	{ 70461, 70461 },
-	{ 70480, 70480 },
-	{ 70493, 70497 },
-	{ 70656, 70708 },
-	{ 70727, 70730 },
-	{ 70784, 70831 },
-	{ 70852, 70853 },
-	{ 70855, 70855 },
-	{ 71040, 71086 },
-	{ 71128, 71131 },
-	{ 71168, 71215 },
-	{ 71236, 71236 },
-	{ 71296, 71338 },
-	{ 71424, 71450 },
-	{ 71680, 71723 },
-	{ 71935, 71935 },
-	{ 72192, 72192 },
-	{ 72203, 72242 },
-	{ 72250, 72250 },
-	{ 72272, 72272 },
-	{ 72284, 72323 },
-	{ 72326, 72329 },
-	{ 72349, 72349 },
-	{ 72384, 72440 },
-	{ 72704, 72712 },
-	{ 72714, 72750 },
-	{ 72768, 72768 },
-	{ 72818, 72847 },
-	{ 72960, 72966 },
-	{ 72968, 72969 },
-	{ 72971, 73008 },
-	{ 73030, 73030 },
-	{ 73056, 73061 },
-	{ 73063, 73064 },
-	{ 73066, 73097 },
-	{ 73112, 73112 },
-	{ 73440, 73458 },
-	{ 73728, 74649 },
-	{ 74880, 75075 },
-	{ 77824, 78894 },
-	{ 82944, 83526 },
-	{ 92160, 92728 },
-	{ 92736, 92766 },
-	{ 92880, 92909 },
-	{ 92928, 92975 },
-	{ 93027, 93047 },
-	{ 93053, 93071 },
-	{ 93952, 94020 },
-	{ 94032, 94032 },
-	{ 94208, 100337 },
-	{ 100352, 101106 },
-	{ 110592, 110878 },
-	{ 110960, 111355 },
-	{ 113664, 113770 },
-	{ 113776, 113788 },
-	{ 113792, 113800 },
-	{ 113808, 113817 },
-	{ 124928, 125124 },
-	{ 126464, 126467 },
-	{ 126469, 126495 },
-	{ 126497, 126498 },
-	{ 126500, 126500 },
-	{ 126503, 126503 },
-	{ 126505, 126514 },
-	{ 126516, 126519 },
-	{ 126521, 126521 },
-	{ 126523, 126523 },
-	{ 126530, 126530 },
-	{ 126535, 126535 },
-	{ 126537, 126537 },
-	{ 126539, 126539 },
-	{ 126541, 126543 },
-	{ 126545, 126546 },
-	{ 126548, 126548 },
-	{ 126551, 126551 },
-	{ 126553, 126553 },
-	{ 126555, 126555 },
-	{ 126557, 126557 },
-	{ 126559, 126559 },
-	{ 126561, 126562 },
-	{ 126564, 126564 },
-	{ 126567, 126570 },
-	{ 126572, 126578 },
-	{ 126580, 126583 },
-	{ 126585, 126588 },
-	{ 126590, 126590 },
-	{ 126592, 126601 },
-	{ 126603, 126619 },
-	{ 126625, 126627 },
-	{ 126629, 126633 },
-	{ 126635, 126651 },
-	{ 131072, 173782 },
-	{ 173824, 177972 },
-	{ 177984, 178205 },
-	{ 178208, 183969 },
-	{ 183984, 191456 },
-	{ 194560, 195101 },
-};
-static const URange16 Ll_range16[] = {
-	{ 97, 122 },
-	{ 181, 181 },
-	{ 223, 246 },
-	{ 248, 255 },
-	{ 257, 257 },
-	{ 259, 259 },
-	{ 261, 261 },
-	{ 263, 263 },
-	{ 265, 265 },
-	{ 267, 267 },
-	{ 269, 269 },
-	{ 271, 271 },
-	{ 273, 273 },
-	{ 275, 275 },
-	{ 277, 277 },
-	{ 279, 279 },
-	{ 281, 281 },
-	{ 283, 283 },
-	{ 285, 285 },
-	{ 287, 287 },
-	{ 289, 289 },
-	{ 291, 291 },
-	{ 293, 293 },
-	{ 295, 295 },
-	{ 297, 297 },
-	{ 299, 299 },
-	{ 301, 301 },
-	{ 303, 303 },
-	{ 305, 305 },
-	{ 307, 307 },
-	{ 309, 309 },
-	{ 311, 312 },
-	{ 314, 314 },
-	{ 316, 316 },
-	{ 318, 318 },
-	{ 320, 320 },
-	{ 322, 322 },
-	{ 324, 324 },
-	{ 326, 326 },
-	{ 328, 329 },
-	{ 331, 331 },
-	{ 333, 333 },
-	{ 335, 335 },
-	{ 337, 337 },
-	{ 339, 339 },
-	{ 341, 341 },
-	{ 343, 343 },
-	{ 345, 345 },
-	{ 347, 347 },
-	{ 349, 349 },
-	{ 351, 351 },
-	{ 353, 353 },
-	{ 355, 355 },
-	{ 357, 357 },
-	{ 359, 359 },
-	{ 361, 361 },
-	{ 363, 363 },
-	{ 365, 365 },
-	{ 367, 367 },
-	{ 369, 369 },
-	{ 371, 371 },
-	{ 373, 373 },
-	{ 375, 375 },
-	{ 378, 378 },
-	{ 380, 380 },
-	{ 382, 384 },
-	{ 387, 387 },
-	{ 389, 389 },
-	{ 392, 392 },
-	{ 396, 397 },
-	{ 402, 402 },
-	{ 405, 405 },
-	{ 409, 411 },
-	{ 414, 414 },
-	{ 417, 417 },
-	{ 419, 419 },
-	{ 421, 421 },
-	{ 424, 424 },
-	{ 426, 427 },
-	{ 429, 429 },
-	{ 432, 432 },
-	{ 436, 436 },
-	{ 438, 438 },
-	{ 441, 442 },
-	{ 445, 447 },
-	{ 454, 454 },
-	{ 457, 457 },
-	{ 460, 460 },
-	{ 462, 462 },
-	{ 464, 464 },
-	{ 466, 466 },
-	{ 468, 468 },
-	{ 470, 470 },
-	{ 472, 472 },
-	{ 474, 474 },
-	{ 476, 477 },
-	{ 479, 479 },
-	{ 481, 481 },
-	{ 483, 483 },
-	{ 485, 485 },
-	{ 487, 487 },
-	{ 489, 489 },
-	{ 491, 491 },
-	{ 493, 493 },
-	{ 495, 496 },
-	{ 499, 499 },
-	{ 501, 501 },
-	{ 505, 505 },
-	{ 507, 507 },
-	{ 509, 509 },
-	{ 511, 511 },
-	{ 513, 513 },
-	{ 515, 515 },
-	{ 517, 517 },
-	{ 519, 519 },
-	{ 521, 521 },
-	{ 523, 523 },
-	{ 525, 525 },
-	{ 527, 527 },
-	{ 529, 529 },
-	{ 531, 531 },
-	{ 533, 533 },
-	{ 535, 535 },
-	{ 537, 537 },
-	{ 539, 539 },
-	{ 541, 541 },
-	{ 543, 543 },
-	{ 545, 545 },
-	{ 547, 547 },
-	{ 549, 549 },
-	{ 551, 551 },
-	{ 553, 553 },
-	{ 555, 555 },
-	{ 557, 557 },
-	{ 559, 559 },
-	{ 561, 561 },
-	{ 563, 569 },
-	{ 572, 572 },
-	{ 575, 576 },
-	{ 578, 578 },
-	{ 583, 583 },
-	{ 585, 585 },
-	{ 587, 587 },
-	{ 589, 589 },
-	{ 591, 659 },
-	{ 661, 687 },
-	{ 881, 881 },
-	{ 883, 883 },
-	{ 887, 887 },
-	{ 891, 893 },
-	{ 912, 912 },
-	{ 940, 974 },
-	{ 976, 977 },
-	{ 981, 983 },
-	{ 985, 985 },
-	{ 987, 987 },
-	{ 989, 989 },
-	{ 991, 991 },
-	{ 993, 993 },
-	{ 995, 995 },
-	{ 997, 997 },
-	{ 999, 999 },
-	{ 1001, 1001 },
-	{ 1003, 1003 },
-	{ 1005, 1005 },
-	{ 1007, 1011 },
-	{ 1013, 1013 },
-	{ 1016, 1016 },
-	{ 1019, 1020 },
-	{ 1072, 1119 },
-	{ 1121, 1121 },
-	{ 1123, 1123 },
-	{ 1125, 1125 },
-	{ 1127, 1127 },
-	{ 1129, 1129 },
-	{ 1131, 1131 },
-	{ 1133, 1133 },
-	{ 1135, 1135 },
-	{ 1137, 1137 },
-	{ 1139, 1139 },
-	{ 1141, 1141 },
-	{ 1143, 1143 },
-	{ 1145, 1145 },
-	{ 1147, 1147 },
-	{ 1149, 1149 },
-	{ 1151, 1151 },
-	{ 1153, 1153 },
-	{ 1163, 1163 },
-	{ 1165, 1165 },
-	{ 1167, 1167 },
-	{ 1169, 1169 },
-	{ 1171, 1171 },
-	{ 1173, 1173 },
-	{ 1175, 1175 },
-	{ 1177, 1177 },
-	{ 1179, 1179 },
-	{ 1181, 1181 },
-	{ 1183, 1183 },
-	{ 1185, 1185 },
-	{ 1187, 1187 },
-	{ 1189, 1189 },
-	{ 1191, 1191 },
-	{ 1193, 1193 },
-	{ 1195, 1195 },
-	{ 1197, 1197 },
-	{ 1199, 1199 },
-	{ 1201, 1201 },
-	{ 1203, 1203 },
-	{ 1205, 1205 },
-	{ 1207, 1207 },
-	{ 1209, 1209 },
-	{ 1211, 1211 },
-	{ 1213, 1213 },
-	{ 1215, 1215 },
-	{ 1218, 1218 },
-	{ 1220, 1220 },
-	{ 1222, 1222 },
-	{ 1224, 1224 },
-	{ 1226, 1226 },
-	{ 1228, 1228 },
-	{ 1230, 1231 },
-	{ 1233, 1233 },
-	{ 1235, 1235 },
-	{ 1237, 1237 },
-	{ 1239, 1239 },
-	{ 1241, 1241 },
-	{ 1243, 1243 },
-	{ 1245, 1245 },
-	{ 1247, 1247 },
-	{ 1249, 1249 },
-	{ 1251, 1251 },
-	{ 1253, 1253 },
-	{ 1255, 1255 },
-	{ 1257, 1257 },
-	{ 1259, 1259 },
-	{ 1261, 1261 },
-	{ 1263, 1263 },
-	{ 1265, 1265 },
-	{ 1267, 1267 },
-	{ 1269, 1269 },
-	{ 1271, 1271 },
-	{ 1273, 1273 },
-	{ 1275, 1275 },
-	{ 1277, 1277 },
-	{ 1279, 1279 },
-	{ 1281, 1281 },
-	{ 1283, 1283 },
-	{ 1285, 1285 },
-	{ 1287, 1287 },
-	{ 1289, 1289 },
-	{ 1291, 1291 },
-	{ 1293, 1293 },
-	{ 1295, 1295 },
-	{ 1297, 1297 },
-	{ 1299, 1299 },
-	{ 1301, 1301 },
-	{ 1303, 1303 },
-	{ 1305, 1305 },
-	{ 1307, 1307 },
-	{ 1309, 1309 },
-	{ 1311, 1311 },
-	{ 1313, 1313 },
-	{ 1315, 1315 },
-	{ 1317, 1317 },
-	{ 1319, 1319 },
-	{ 1321, 1321 },
-	{ 1323, 1323 },
-	{ 1325, 1325 },
-	{ 1327, 1327 },
-	{ 1376, 1416 },
-	{ 4304, 4346 },
-	{ 4349, 4351 },
-	{ 5112, 5117 },
-	{ 7296, 7304 },
-	{ 7424, 7467 },
-	{ 7531, 7543 },
-	{ 7545, 7578 },
-	{ 7681, 7681 },
-	{ 7683, 7683 },
-	{ 7685, 7685 },
-	{ 7687, 7687 },
-	{ 7689, 7689 },
-	{ 7691, 7691 },
-	{ 7693, 7693 },
-	{ 7695, 7695 },
-	{ 7697, 7697 },
-	{ 7699, 7699 },
-	{ 7701, 7701 },
-	{ 7703, 7703 },
-	{ 7705, 7705 },
-	{ 7707, 7707 },
-	{ 7709, 7709 },
-	{ 7711, 7711 },
-	{ 7713, 7713 },
-	{ 7715, 7715 },
-	{ 7717, 7717 },
-	{ 7719, 7719 },
-	{ 7721, 7721 },
-	{ 7723, 7723 },
-	{ 7725, 7725 },
-	{ 7727, 7727 },
-	{ 7729, 7729 },
-	{ 7731, 7731 },
-	{ 7733, 7733 },
-	{ 7735, 7735 },
-	{ 7737, 7737 },
-	{ 7739, 7739 },
-	{ 7741, 7741 },
-	{ 7743, 7743 },
-	{ 7745, 7745 },
-	{ 7747, 7747 },
-	{ 7749, 7749 },
-	{ 7751, 7751 },
-	{ 7753, 7753 },
-	{ 7755, 7755 },
-	{ 7757, 7757 },
-	{ 7759, 7759 },
-	{ 7761, 7761 },
-	{ 7763, 7763 },
-	{ 7765, 7765 },
-	{ 7767, 7767 },
-	{ 7769, 7769 },
-	{ 7771, 7771 },
-	{ 7773, 7773 },
-	{ 7775, 7775 },
-	{ 7777, 7777 },
-	{ 7779, 7779 },
-	{ 7781, 7781 },
-	{ 7783, 7783 },
-	{ 7785, 7785 },
-	{ 7787, 7787 },
-	{ 7789, 7789 },
-	{ 7791, 7791 },
-	{ 7793, 7793 },
-	{ 7795, 7795 },
-	{ 7797, 7797 },
-	{ 7799, 7799 },
-	{ 7801, 7801 },
-	{ 7803, 7803 },
-	{ 7805, 7805 },
-	{ 7807, 7807 },
-	{ 7809, 7809 },
-	{ 7811, 7811 },
-	{ 7813, 7813 },
-	{ 7815, 7815 },
-	{ 7817, 7817 },
-	{ 7819, 7819 },
-	{ 7821, 7821 },
-	{ 7823, 7823 },
-	{ 7825, 7825 },
-	{ 7827, 7827 },
-	{ 7829, 7837 },
-	{ 7839, 7839 },
-	{ 7841, 7841 },
-	{ 7843, 7843 },
-	{ 7845, 7845 },
-	{ 7847, 7847 },
-	{ 7849, 7849 },
-	{ 7851, 7851 },
-	{ 7853, 7853 },
-	{ 7855, 7855 },
-	{ 7857, 7857 },
-	{ 7859, 7859 },
-	{ 7861, 7861 },
-	{ 7863, 7863 },
-	{ 7865, 7865 },
-	{ 7867, 7867 },
-	{ 7869, 7869 },
-	{ 7871, 7871 },
-	{ 7873, 7873 },
-	{ 7875, 7875 },
-	{ 7877, 7877 },
-	{ 7879, 7879 },
-	{ 7881, 7881 },
-	{ 7883, 7883 },
-	{ 7885, 7885 },
-	{ 7887, 7887 },
-	{ 7889, 7889 },
-	{ 7891, 7891 },
-	{ 7893, 7893 },
-	{ 7895, 7895 },
-	{ 7897, 7897 },
-	{ 7899, 7899 },
-	{ 7901, 7901 },
-	{ 7903, 7903 },
-	{ 7905, 7905 },
-	{ 7907, 7907 },
-	{ 7909, 7909 },
-	{ 7911, 7911 },
-	{ 7913, 7913 },
-	{ 7915, 7915 },
-	{ 7917, 7917 },
-	{ 7919, 7919 },
-	{ 7921, 7921 },
-	{ 7923, 7923 },
-	{ 7925, 7925 },
-	{ 7927, 7927 },
-	{ 7929, 7929 },
-	{ 7931, 7931 },
-	{ 7933, 7933 },
-	{ 7935, 7943 },
-	{ 7952, 7957 },
-	{ 7968, 7975 },
-	{ 7984, 7991 },
-	{ 8000, 8005 },
-	{ 8016, 8023 },
-	{ 8032, 8039 },
-	{ 8048, 8061 },
-	{ 8064, 8071 },
-	{ 8080, 8087 },
-	{ 8096, 8103 },
-	{ 8112, 8116 },
-	{ 8118, 8119 },
-	{ 8126, 8126 },
-	{ 8130, 8132 },
-	{ 8134, 8135 },
-	{ 8144, 8147 },
-	{ 8150, 8151 },
-	{ 8160, 8167 },
-	{ 8178, 8180 },
-	{ 8182, 8183 },
-	{ 8458, 8458 },
-	{ 8462, 8463 },
-	{ 8467, 8467 },
-	{ 8495, 8495 },
-	{ 8500, 8500 },
-	{ 8505, 8505 },
-	{ 8508, 8509 },
-	{ 8518, 8521 },
-	{ 8526, 8526 },
-	{ 8580, 8580 },
-	{ 11312, 11358 },
-	{ 11361, 11361 },
-	{ 11365, 11366 },
-	{ 11368, 11368 },
-	{ 11370, 11370 },
-	{ 11372, 11372 },
-	{ 11377, 11377 },
-	{ 11379, 11380 },
-	{ 11382, 11387 },
-	{ 11393, 11393 },
-	{ 11395, 11395 },
-	{ 11397, 11397 },
-	{ 11399, 11399 },
-	{ 11401, 11401 },
-	{ 11403, 11403 },
-	{ 11405, 11405 },
-	{ 11407, 11407 },
-	{ 11409, 11409 },
-	{ 11411, 11411 },
-	{ 11413, 11413 },
-	{ 11415, 11415 },
-	{ 11417, 11417 },
-	{ 11419, 11419 },
-	{ 11421, 11421 },
-	{ 11423, 11423 },
-	{ 11425, 11425 },
-	{ 11427, 11427 },
-	{ 11429, 11429 },
-	{ 11431, 11431 },
-	{ 11433, 11433 },
-	{ 11435, 11435 },
-	{ 11437, 11437 },
-	{ 11439, 11439 },
-	{ 11441, 11441 },
-	{ 11443, 11443 },
-	{ 11445, 11445 },
-	{ 11447, 11447 },
-	{ 11449, 11449 },
-	{ 11451, 11451 },
-	{ 11453, 11453 },
-	{ 11455, 11455 },
-	{ 11457, 11457 },
-	{ 11459, 11459 },
-	{ 11461, 11461 },
-	{ 11463, 11463 },
-	{ 11465, 11465 },
-	{ 11467, 11467 },
-	{ 11469, 11469 },
-	{ 11471, 11471 },
-	{ 11473, 11473 },
-	{ 11475, 11475 },
-	{ 11477, 11477 },
-	{ 11479, 11479 },
-	{ 11481, 11481 },
-	{ 11483, 11483 },
-	{ 11485, 11485 },
-	{ 11487, 11487 },
-	{ 11489, 11489 },
-	{ 11491, 11492 },
-	{ 11500, 11500 },
-	{ 11502, 11502 },
-	{ 11507, 11507 },
-	{ 11520, 11557 },
-	{ 11559, 11559 },
-	{ 11565, 11565 },
-	{ 42561, 42561 },
-	{ 42563, 42563 },
-	{ 42565, 42565 },
-	{ 42567, 42567 },
-	{ 42569, 42569 },
-	{ 42571, 42571 },
-	{ 42573, 42573 },
-	{ 42575, 42575 },
-	{ 42577, 42577 },
-	{ 42579, 42579 },
-	{ 42581, 42581 },
-	{ 42583, 42583 },
-	{ 42585, 42585 },
-	{ 42587, 42587 },
-	{ 42589, 42589 },
-	{ 42591, 42591 },
-	{ 42593, 42593 },
-	{ 42595, 42595 },
-	{ 42597, 42597 },
-	{ 42599, 42599 },
-	{ 42601, 42601 },
-	{ 42603, 42603 },
-	{ 42605, 42605 },
-	{ 42625, 42625 },
-	{ 42627, 42627 },
-	{ 42629, 42629 },
-	{ 42631, 42631 },
-	{ 42633, 42633 },
-	{ 42635, 42635 },
-	{ 42637, 42637 },
-	{ 42639, 42639 },
-	{ 42641, 42641 },
-	{ 42643, 42643 },
-	{ 42645, 42645 },
-	{ 42647, 42647 },
-	{ 42649, 42649 },
-	{ 42651, 42651 },
-	{ 42787, 42787 },
-	{ 42789, 42789 },
-	{ 42791, 42791 },
-	{ 42793, 42793 },
-	{ 42795, 42795 },
-	{ 42797, 42797 },
-	{ 42799, 42801 },
-	{ 42803, 42803 },
-	{ 42805, 42805 },
-	{ 42807, 42807 },
-	{ 42809, 42809 },
-	{ 42811, 42811 },
-	{ 42813, 42813 },
-	{ 42815, 42815 },
-	{ 42817, 42817 },
-	{ 42819, 42819 },
-	{ 42821, 42821 },
-	{ 42823, 42823 },
-	{ 42825, 42825 },
-	{ 42827, 42827 },
-	{ 42829, 42829 },
-	{ 42831, 42831 },
-	{ 42833, 42833 },
-	{ 42835, 42835 },
-	{ 42837, 42837 },
-	{ 42839, 42839 },
-	{ 42841, 42841 },
-	{ 42843, 42843 },
-	{ 42845, 42845 },
-	{ 42847, 42847 },
-	{ 42849, 42849 },
-	{ 42851, 42851 },
-	{ 42853, 42853 },
-	{ 42855, 42855 },
-	{ 42857, 42857 },
-	{ 42859, 42859 },
-	{ 42861, 42861 },
-	{ 42863, 42863 },
-	{ 42865, 42872 },
-	{ 42874, 42874 },
-	{ 42876, 42876 },
-	{ 42879, 42879 },
-	{ 42881, 42881 },
-	{ 42883, 42883 },
-	{ 42885, 42885 },
-	{ 42887, 42887 },
-	{ 42892, 42892 },
-	{ 42894, 42894 },
-	{ 42897, 42897 },
-	{ 42899, 42901 },
-	{ 42903, 42903 },
-	{ 42905, 42905 },
-	{ 42907, 42907 },
-	{ 42909, 42909 },
-	{ 42911, 42911 },
-	{ 42913, 42913 },
-	{ 42915, 42915 },
-	{ 42917, 42917 },
-	{ 42919, 42919 },
-	{ 42921, 42921 },
-	{ 42927, 42927 },
-	{ 42933, 42933 },
-	{ 42935, 42935 },
-	{ 42937, 42937 },
-	{ 43002, 43002 },
-	{ 43824, 43866 },
-	{ 43872, 43877 },
-	{ 43888, 43967 },
-	{ 64256, 64262 },
-	{ 64275, 64279 },
-	{ 65345, 65370 },
-};
-static const URange32 Ll_range32[] = {
-	{ 66600, 66639 },
-	{ 66776, 66811 },
-	{ 68800, 68850 },
-	{ 71872, 71903 },
-	{ 93792, 93823 },
-	{ 119834, 119859 },
-	{ 119886, 119892 },
-	{ 119894, 119911 },
-	{ 119938, 119963 },
-	{ 119990, 119993 },
-	{ 119995, 119995 },
-	{ 119997, 120003 },
-	{ 120005, 120015 },
-	{ 120042, 120067 },
-	{ 120094, 120119 },
-	{ 120146, 120171 },
-	{ 120198, 120223 },
-	{ 120250, 120275 },
-	{ 120302, 120327 },
-	{ 120354, 120379 },
-	{ 120406, 120431 },
-	{ 120458, 120485 },
-	{ 120514, 120538 },
-	{ 120540, 120545 },
-	{ 120572, 120596 },
-	{ 120598, 120603 },
-	{ 120630, 120654 },
-	{ 120656, 120661 },
-	{ 120688, 120712 },
-	{ 120714, 120719 },
-	{ 120746, 120770 },
-	{ 120772, 120777 },
-	{ 120779, 120779 },
-	{ 125218, 125251 },
-};
-static const URange16 Lm_range16[] = {
-	{ 688, 705 },
-	{ 710, 721 },
-	{ 736, 740 },
-	{ 748, 748 },
-	{ 750, 750 },
-	{ 884, 884 },
-	{ 890, 890 },
-	{ 1369, 1369 },
-	{ 1600, 1600 },
-	{ 1765, 1766 },
-	{ 2036, 2037 },
-	{ 2042, 2042 },
-	{ 2074, 2074 },
-	{ 2084, 2084 },
-	{ 2088, 2088 },
-	{ 2417, 2417 },
-	{ 3654, 3654 },
-	{ 3782, 3782 },
-	{ 4348, 4348 },
-	{ 6103, 6103 },
-	{ 6211, 6211 },
-	{ 6823, 6823 },
-	{ 7288, 7293 },
-	{ 7468, 7530 },
-	{ 7544, 7544 },
-	{ 7579, 7615 },
-	{ 8305, 8305 },
-	{ 8319, 8319 },
-	{ 8336, 8348 },
-	{ 11388, 11389 },
-	{ 11631, 11631 },
-	{ 11823, 11823 },
-	{ 12293, 12293 },
-	{ 12337, 12341 },
-	{ 12347, 12347 },
-	{ 12445, 12446 },
-	{ 12540, 12542 },
-	{ 40981, 40981 },
-	{ 42232, 42237 },
-	{ 42508, 42508 },
-	{ 42623, 42623 },
-	{ 42652, 42653 },
-	{ 42775, 42783 },
-	{ 42864, 42864 },
-	{ 42888, 42888 },
-	{ 43000, 43001 },
-	{ 43471, 43471 },
-	{ 43494, 43494 },
-	{ 43632, 43632 },
-	{ 43741, 43741 },
-	{ 43763, 43764 },
-	{ 43868, 43871 },
-	{ 65392, 65392 },
-	{ 65438, 65439 },
-};
-static const URange32 Lm_range32[] = {
-	{ 92992, 92995 },
-	{ 94099, 94111 },
-	{ 94176, 94177 },
-};
-static const URange16 Nd_range16[] = {
-	{ 48, 57 },
-	{ 1632, 1641 },
-	{ 1776, 1785 },
-	{ 1984, 1993 },
-	{ 2406, 2415 },
-	{ 2534, 2543 },
-	{ 2662, 2671 },
-	{ 2790, 2799 },
-	{ 2918, 2927 },
-	{ 3046, 3055 },
-	{ 3174, 3183 },
-	{ 3302, 3311 },
-	{ 3430, 3439 },
-	{ 3558, 3567 },
-	{ 3664, 3673 },
-	{ 3792, 3801 },
-	{ 3872, 3881 },
-	{ 4160, 4169 },
-	{ 4240, 4249 },
-	{ 6112, 6121 },
-	{ 6160, 6169 },
-	{ 6470, 6479 },
-	{ 6608, 6617 },
-	{ 6784, 6793 },
-	{ 6800, 6809 },
-	{ 6992, 7001 },
-	{ 7088, 7097 },
-	{ 7232, 7241 },
-	{ 7248, 7257 },
-	{ 42528, 42537 },
-	{ 43216, 43225 },
-	{ 43264, 43273 },
-	{ 43472, 43481 },
-	{ 43504, 43513 },
-	{ 43600, 43609 },
-	{ 44016, 44025 },
-	{ 65296, 65305 },
-};
-static const URange32 Nd_range32[] = {
-	{ 66720, 66729 },
-	{ 68912, 68921 },
-	{ 69734, 69743 },
-	{ 69872, 69881 },
-	{ 69942, 69951 },
-	{ 70096, 70105 },
-	{ 70384, 70393 },
-	{ 70736, 70745 },
-	{ 70864, 70873 },
-	{ 71248, 71257 },
-	{ 71360, 71369 },
-	{ 71472, 71481 },
-	{ 71904, 71913 },
-	{ 72784, 72793 },
-	{ 73040, 73049 },
-	{ 73120, 73129 },
-	{ 92768, 92777 },
-	{ 93008, 93017 },
-	{ 120782, 120831 },
-	{ 125264, 125273 },
-};
-static const URange16 Pc_range16[] = {
-	{ 95, 95 },
-	{ 8255, 8256 },
-	{ 8276, 8276 },
-	{ 65075, 65076 },
-	{ 65101, 65103 },
-	{ 65343, 65343 },
-};
-static const URange16 Lt_range16[] = {
-	{ 453, 453 },
-	{ 456, 456 },
-	{ 459, 459 },
-	{ 498, 498 },
-	{ 8072, 8079 },
-	{ 8088, 8095 },
-	{ 8104, 8111 },
-	{ 8124, 8124 },
-	{ 8140, 8140 },
-	{ 8188, 8188 },
-};
-static const URange16 Lu_range16[] = {
-	{ 65, 90 },
-	{ 192, 214 },
-	{ 216, 222 },
-	{ 256, 256 },
-	{ 258, 258 },
-	{ 260, 260 },
-	{ 262, 262 },
-	{ 264, 264 },
-	{ 266, 266 },
-	{ 268, 268 },
-	{ 270, 270 },
-	{ 272, 272 },
-	{ 274, 274 },
-	{ 276, 276 },
-	{ 278, 278 },
-	{ 280, 280 },
-	{ 282, 282 },
-	{ 284, 284 },
-	{ 286, 286 },
-	{ 288, 288 },
-	{ 290, 290 },
-	{ 292, 292 },
-	{ 294, 294 },
-	{ 296, 296 },
-	{ 298, 298 },
-	{ 300, 300 },
-	{ 302, 302 },
-	{ 304, 304 },
-	{ 306, 306 },
-	{ 308, 308 },
-	{ 310, 310 },
-	{ 313, 313 },
-	{ 315, 315 },
-	{ 317, 317 },
-	{ 319, 319 },
-	{ 321, 321 },
-	{ 323, 323 },
-	{ 325, 325 },
-	{ 327, 327 },
-	{ 330, 330 },
-	{ 332, 332 },
-	{ 334, 334 },
-	{ 336, 336 },
-	{ 338, 338 },
-	{ 340, 340 },
-	{ 342, 342 },
-	{ 344, 344 },
-	{ 346, 346 },
-	{ 348, 348 },
-	{ 350, 350 },
-	{ 352, 352 },
-	{ 354, 354 },
-	{ 356, 356 },
-	{ 358, 358 },
-	{ 360, 360 },
-	{ 362, 362 },
-	{ 364, 364 },
-	{ 366, 366 },
-	{ 368, 368 },
-	{ 370, 370 },
-	{ 372, 372 },
-	{ 374, 374 },
-	{ 376, 377 },
-	{ 379, 379 },
-	{ 381, 381 },
-	{ 385, 386 },
-	{ 388, 388 },
-	{ 390, 391 },
-	{ 393, 395 },
-	{ 398, 401 },
-	{ 403, 404 },
-	{ 406, 408 },
-	{ 412, 413 },
-	{ 415, 416 },
-	{ 418, 418 },
-	{ 420, 420 },
-	{ 422, 423 },
-	{ 425, 425 },
-	{ 428, 428 },
-	{ 430, 431 },
-	{ 433, 435 },
-	{ 437, 437 },
-	{ 439, 440 },
-	{ 444, 444 },
-	{ 452, 452 },
-	{ 455, 455 },
-	{ 458, 458 },
-	{ 461, 461 },
-	{ 463, 463 },
-	{ 465, 465 },
-	{ 467, 467 },
-	{ 469, 469 },
-	{ 471, 471 },
-	{ 473, 473 },
-	{ 475, 475 },
-	{ 478, 478 },
-	{ 480, 480 },
-	{ 482, 482 },
-	{ 484, 484 },
-	{ 486, 486 },
-	{ 488, 488 },
-	{ 490, 490 },
-	{ 492, 492 },
-	{ 494, 494 },
-	{ 497, 497 },
-	{ 500, 500 },
-	{ 502, 504 },
-	{ 506, 506 },
-	{ 508, 508 },
-	{ 510, 510 },
-	{ 512, 512 },
-	{ 514, 514 },
-	{ 516, 516 },
-	{ 518, 518 },
-	{ 520, 520 },
-	{ 522, 522 },
-	{ 524, 524 },
-	{ 526, 526 },
-	{ 528, 528 },
-	{ 530, 530 },
-	{ 532, 532 },
-	{ 534, 534 },
-	{ 536, 536 },
-	{ 538, 538 },
-	{ 540, 540 },
-	{ 542, 542 },
-	{ 544, 544 },
-	{ 546, 546 },
-	{ 548, 548 },
-	{ 550, 550 },
-	{ 552, 552 },
-	{ 554, 554 },
-	{ 556, 556 },
-	{ 558, 558 },
-	{ 560, 560 },
-	{ 562, 562 },
-	{ 570, 571 },
-	{ 573, 574 },
-	{ 577, 577 },
-	{ 579, 582 },
-	{ 584, 584 },
-	{ 586, 586 },
-	{ 588, 588 },
-	{ 590, 590 },
-	{ 880, 880 },
-	{ 882, 882 },
-	{ 886, 886 },
-	{ 895, 895 },
-	{ 902, 902 },
-	{ 904, 906 },
-	{ 908, 908 },
-	{ 910, 911 },
-	{ 913, 929 },
-	{ 931, 939 },
-	{ 975, 975 },
-	{ 978, 980 },
-	{ 984, 984 },
-	{ 986, 986 },
-	{ 988, 988 },
-	{ 990, 990 },
-	{ 992, 992 },
-	{ 994, 994 },
-	{ 996, 996 },
-	{ 998, 998 },
-	{ 1000, 1000 },
-	{ 1002, 1002 },
-	{ 1004, 1004 },
-	{ 1006, 1006 },
-	{ 1012, 1012 },
-	{ 1015, 1015 },
-	{ 1017, 1018 },
-	{ 1021, 1071 },
-	{ 1120, 1120 },
-	{ 1122, 1122 },
-	{ 1124, 1124 },
-	{ 1126, 1126 },
-	{ 1128, 1128 },
-	{ 1130, 1130 },
-	{ 1132, 1132 },
-	{ 1134, 1134 },
-	{ 1136, 1136 },
-	{ 1138, 1138 },
-	{ 1140, 1140 },
-	{ 1142, 1142 },
-	{ 1144, 1144 },
-	{ 1146, 1146 },
-	{ 1148, 1148 },
-	{ 1150, 1150 },
-	{ 1152, 1152 },
-	{ 1162, 1162 },
-	{ 1164, 1164 },
-	{ 1166, 1166 },
-	{ 1168, 1168 },
-	{ 1170, 1170 },
-	{ 1172, 1172 },
-	{ 1174, 1174 },
-	{ 1176, 1176 },
-	{ 1178, 1178 },
-	{ 1180, 1180 },
-	{ 1182, 1182 },
-	{ 1184, 1184 },
-	{ 1186, 1186 },
-	{ 1188, 1188 },
-	{ 1190, 1190 },
-	{ 1192, 1192 },
-	{ 1194, 1194 },
-	{ 1196, 1196 },
-	{ 1198, 1198 },
-	{ 1200, 1200 },
-	{ 1202, 1202 },
-	{ 1204, 1204 },
-	{ 1206, 1206 },
-	{ 1208, 1208 },
-	{ 1210, 1210 },
-	{ 1212, 1212 },
-	{ 1214, 1214 },
-	{ 1216, 1217 },
-	{ 1219, 1219 },
-	{ 1221, 1221 },
-	{ 1223, 1223 },
-	{ 1225, 1225 },
-	{ 1227, 1227 },
-	{ 1229, 1229 },
-	{ 1232, 1232 },
-	{ 1234, 1234 },
-	{ 1236, 1236 },
-	{ 1238, 1238 },
-	{ 1240, 1240 },
-	{ 1242, 1242 },
-	{ 1244, 1244 },
-	{ 1246, 1246 },
-	{ 1248, 1248 },
-	{ 1250, 1250 },
-	{ 1252, 1252 },
-	{ 1254, 1254 },
-	{ 1256, 1256 },
-	{ 1258, 1258 },
-	{ 1260, 1260 },
-	{ 1262, 1262 },
-	{ 1264, 1264 },
-	{ 1266, 1266 },
-	{ 1268, 1268 },
-	{ 1270, 1270 },
-	{ 1272, 1272 },
-	{ 1274, 1274 },
-	{ 1276, 1276 },
-	{ 1278, 1278 },
-	{ 1280, 1280 },
-	{ 1282, 1282 },
-	{ 1284, 1284 },
-	{ 1286, 1286 },
-	{ 1288, 1288 },
-	{ 1290, 1290 },
-	{ 1292, 1292 },
-	{ 1294, 1294 },
-	{ 1296, 1296 },
-	{ 1298, 1298 },
-	{ 1300, 1300 },
-	{ 1302, 1302 },
-	{ 1304, 1304 },
-	{ 1306, 1306 },
-	{ 1308, 1308 },
-	{ 1310, 1310 },
-	{ 1312, 1312 },
-	{ 1314, 1314 },
-	{ 1316, 1316 },
-	{ 1318, 1318 },
-	{ 1320, 1320 },
-	{ 1322, 1322 },
-	{ 1324, 1324 },
-	{ 1326, 1326 },
-	{ 1329, 1366 },
-	{ 4256, 4293 },
-	{ 4295, 4295 },
-	{ 4301, 4301 },
-	{ 5024, 5109 },
-	{ 7312, 7354 },
-	{ 7357, 7359 },
-	{ 7680, 7680 },
-	{ 7682, 7682 },
-	{ 7684, 7684 },
-	{ 7686, 7686 },
-	{ 7688, 7688 },
-	{ 7690, 7690 },
-	{ 7692, 7692 },
-	{ 7694, 7694 },
-	{ 7696, 7696 },
-	{ 7698, 7698 },
-	{ 7700, 7700 },
-	{ 7702, 7702 },
-	{ 7704, 7704 },
-	{ 7706, 7706 },
-	{ 7708, 7708 },
-	{ 7710, 7710 },
-	{ 7712, 7712 },
-	{ 7714, 7714 },
-	{ 7716, 7716 },
-	{ 7718, 7718 },
-	{ 7720, 7720 },
-	{ 7722, 7722 },
-	{ 7724, 7724 },
-	{ 7726, 7726 },
-	{ 7728, 7728 },
-	{ 7730, 7730 },
-	{ 7732, 7732 },
-	{ 7734, 7734 },
-	{ 7736, 7736 },
-	{ 7738, 7738 },
-	{ 7740, 7740 },
-	{ 7742, 7742 },
-	{ 7744, 7744 },
-	{ 7746, 7746 },
-	{ 7748, 7748 },
-	{ 7750, 7750 },
-	{ 7752, 7752 },
-	{ 7754, 7754 },
-	{ 7756, 7756 },
-	{ 7758, 7758 },
-	{ 7760, 7760 },
-	{ 7762, 7762 },
-	{ 7764, 7764 },
-	{ 7766, 7766 },
-	{ 7768, 7768 },
-	{ 7770, 7770 },
-	{ 7772, 7772 },
-	{ 7774, 7774 },
-	{ 7776, 7776 },
-	{ 7778, 7778 },
-	{ 7780, 7780 },
-	{ 7782, 7782 },
-	{ 7784, 7784 },
-	{ 7786, 7786 },
-	{ 7788, 7788 },
-	{ 7790, 7790 },
-	{ 7792, 7792 },
-	{ 7794, 7794 },
-	{ 7796, 7796 },
-	{ 7798, 7798 },
-	{ 7800, 7800 },
-	{ 7802, 7802 },
-	{ 7804, 7804 },
-	{ 7806, 7806 },
-	{ 7808, 7808 },
-	{ 7810, 7810 },
-	{ 7812, 7812 },
-	{ 7814, 7814 },
-	{ 7816, 7816 },
-	{ 7818, 7818 },
-	{ 7820, 7820 },
-	{ 7822, 7822 },
-	{ 7824, 7824 },
-	{ 7826, 7826 },
-	{ 7828, 7828 },
-	{ 7838, 7838 },
-	{ 7840, 7840 },
-	{ 7842, 7842 },
-	{ 7844, 7844 },
-	{ 7846, 7846 },
-	{ 7848, 7848 },
-	{ 7850, 7850 },
-	{ 7852, 7852 },
-	{ 7854, 7854 },
-	{ 7856, 7856 },
-	{ 7858, 7858 },
-	{ 7860, 7860 },
-	{ 7862, 7862 },
-	{ 7864, 7864 },
-	{ 7866, 7866 },
-	{ 7868, 7868 },
-	{ 7870, 7870 },
-	{ 7872, 7872 },
-	{ 7874, 7874 },
-	{ 7876, 7876 },
-	{ 7878, 7878 },
-	{ 7880, 7880 },
-	{ 7882, 7882 },
-	{ 7884, 7884 },
-	{ 7886, 7886 },
-	{ 7888, 7888 },
-	{ 7890, 7890 },
-	{ 7892, 7892 },
-	{ 7894, 7894 },
-	{ 7896, 7896 },
-	{ 7898, 7898 },
-	{ 7900, 7900 },
-	{ 7902, 7902 },
-	{ 7904, 7904 },
-	{ 7906, 7906 },
-	{ 7908, 7908 },
-	{ 7910, 7910 },
-	{ 7912, 7912 },
-	{ 7914, 7914 },
-	{ 7916, 7916 },
-	{ 7918, 7918 },
-	{ 7920, 7920 },
-	{ 7922, 7922 },
-	{ 7924, 7924 },
-	{ 7926, 7926 },
-	{ 7928, 7928 },
-	{ 7930, 7930 },
-	{ 7932, 7932 },
-	{ 7934, 7934 },
-	{ 7944, 7951 },
-	{ 7960, 7965 },
-	{ 7976, 7983 },
-	{ 7992, 7999 },
-	{ 8008, 8013 },
-	{ 8025, 8025 },
-	{ 8027, 8027 },
-	{ 8029, 8029 },
-	{ 8031, 8031 },
-	{ 8040, 8047 },
-	{ 8120, 8123 },
-	{ 8136, 8139 },
-	{ 8152, 8155 },
-	{ 8168, 8172 },
-	{ 8184, 8187 },
-	{ 8450, 8450 },
-	{ 8455, 8455 },
-	{ 8459, 8461 },
-	{ 8464, 8466 },
-	{ 8469, 8469 },
-	{ 8473, 8477 },
-	{ 8484, 8484 },
-	{ 8486, 8486 },
-	{ 8488, 8488 },
-	{ 8490, 8493 },
-	{ 8496, 8499 },
-	{ 8510, 8511 },
-	{ 8517, 8517 },
-	{ 8579, 8579 },
-	{ 11264, 11310 },
-	{ 11360, 11360 },
-	{ 11362, 11364 },
-	{ 11367, 11367 },
-	{ 11369, 11369 },
-	{ 11371, 11371 },
-	{ 11373, 11376 },
-	{ 11378, 11378 },
-	{ 11381, 11381 },
-	{ 11390, 11392 },
-	{ 11394, 11394 },
-	{ 11396, 11396 },
-	{ 11398, 11398 },
-	{ 11400, 11400 },
-	{ 11402, 11402 },
-	{ 11404, 11404 },
-	{ 11406, 11406 },
-	{ 11408, 11408 },
-	{ 11410, 11410 },
-	{ 11412, 11412 },
-	{ 11414, 11414 },
-	{ 11416, 11416 },
-	{ 11418, 11418 },
-	{ 11420, 11420 },
-	{ 11422, 11422 },
-	{ 11424, 11424 },
-	{ 11426, 11426 },
-	{ 11428, 11428 },
-	{ 11430, 11430 },
-	{ 11432, 11432 },
-	{ 11434, 11434 },
-	{ 11436, 11436 },
-	{ 11438, 11438 },
-	{ 11440, 11440 },
-	{ 11442, 11442 },
-	{ 11444, 11444 },
-	{ 11446, 11446 },
-	{ 11448, 11448 },
-	{ 11450, 11450 },
-	{ 11452, 11452 },
-	{ 11454, 11454 },
-	{ 11456, 11456 },
-	{ 11458, 11458 },
-	{ 11460, 11460 },
-	{ 11462, 11462 },
-	{ 11464, 11464 },
-	{ 11466, 11466 },
-	{ 11468, 11468 },
-	{ 11470, 11470 },
-	{ 11472, 11472 },
-	{ 11474, 11474 },
-	{ 11476, 11476 },
-	{ 11478, 11478 },
-	{ 11480, 11480 },
-	{ 11482, 11482 },
-	{ 11484, 11484 },
-	{ 11486, 11486 },
-	{ 11488, 11488 },
-	{ 11490, 11490 },
-	{ 11499, 11499 },
-	{ 11501, 11501 },
-	{ 11506, 11506 },
-	{ 42560, 42560 },
-	{ 42562, 42562 },
-	{ 42564, 42564 },
-	{ 42566, 42566 },
-	{ 42568, 42568 },
-	{ 42570, 42570 },
-	{ 42572, 42572 },
-	{ 42574, 42574 },
-	{ 42576, 42576 },
-	{ 42578, 42578 },
-	{ 42580, 42580 },
-	{ 42582, 42582 },
-	{ 42584, 42584 },
-	{ 42586, 42586 },
-	{ 42588, 42588 },
-	{ 42590, 42590 },
-	{ 42592, 42592 },
-	{ 42594, 42594 },
-	{ 42596, 42596 },
-	{ 42598, 42598 },
-	{ 42600, 42600 },
-	{ 42602, 42602 },
-	{ 42604, 42604 },
-	{ 42624, 42624 },
-	{ 42626, 42626 },
-	{ 42628, 42628 },
-	{ 42630, 42630 },
-	{ 42632, 42632 },
-	{ 42634, 42634 },
-	{ 42636, 42636 },
-	{ 42638, 42638 },
-	{ 42640, 42640 },
-	{ 42642, 42642 },
-	{ 42644, 42644 },
-	{ 42646, 42646 },
-	{ 42648, 42648 },
-	{ 42650, 42650 },
-	{ 42786, 42786 },
-	{ 42788, 42788 },
-	{ 42790, 42790 },
-	{ 42792, 42792 },
-	{ 42794, 42794 },
-	{ 42796, 42796 },
-	{ 42798, 42798 },
-	{ 42802, 42802 },
-	{ 42804, 42804 },
-	{ 42806, 42806 },
-	{ 42808, 42808 },
-	{ 42810, 42810 },
-	{ 42812, 42812 },
-	{ 42814, 42814 },
-	{ 42816, 42816 },
-	{ 42818, 42818 },
-	{ 42820, 42820 },
-	{ 42822, 42822 },
-	{ 42824, 42824 },
-	{ 42826, 42826 },
-	{ 42828, 42828 },
-	{ 42830, 42830 },
-	{ 42832, 42832 },
-	{ 42834, 42834 },
-	{ 42836, 42836 },
-	{ 42838, 42838 },
-	{ 42840, 42840 },
-	{ 42842, 42842 },
-	{ 42844, 42844 },
-	{ 42846, 42846 },
-	{ 42848, 42848 },
-	{ 42850, 42850 },
-	{ 42852, 42852 },
-	{ 42854, 42854 },
-	{ 42856, 42856 },
-	{ 42858, 42858 },
-	{ 42860, 42860 },
-	{ 42862, 42862 },
-	{ 42873, 42873 },
-	{ 42875, 42875 },
-	{ 42877, 42878 },
-	{ 42880, 42880 },
-	{ 42882, 42882 },
-	{ 42884, 42884 },
-	{ 42886, 42886 },
-	{ 42891, 42891 },
-	{ 42893, 42893 },
-	{ 42896, 42896 },
-	{ 42898, 42898 },
-	{ 42902, 42902 },
-	{ 42904, 42904 },
-	{ 42906, 42906 },
-	{ 42908, 42908 },
-	{ 42910, 42910 },
-	{ 42912, 42912 },
-	{ 42914, 42914 },
-	{ 42916, 42916 },
-	{ 42918, 42918 },
-	{ 42920, 42920 },
-	{ 42922, 42926 },
-	{ 42928, 42932 },
-	{ 42934, 42934 },
-	{ 42936, 42936 },
-	{ 65313, 65338 },
-};
-static const URange32 Lu_range32[] = {
-	{ 66560, 66599 },
-	{ 66736, 66771 },
-	{ 68736, 68786 },
-	{ 71840, 71871 },
-	{ 93760, 93791 },
-	{ 119808, 119833 },
-	{ 119860, 119885 },
-	{ 119912, 119937 },
-	{ 119964, 119964 },
-	{ 119966, 119967 },
-	{ 119970, 119970 },
-	{ 119973, 119974 },
-	{ 119977, 119980 },
-	{ 119982, 119989 },
-	{ 120016, 120041 },
-	{ 120068, 120069 },
-	{ 120071, 120074 },
-	{ 120077, 120084 },
-	{ 120086, 120092 },
-	{ 120120, 120121 },
-	{ 120123, 120126 },
-	{ 120128, 120132 },
-	{ 120134, 120134 },
-	{ 120138, 120144 },
-	{ 120172, 120197 },
-	{ 120224, 120249 },
-	{ 120276, 120301 },
-	{ 120328, 120353 },
-	{ 120380, 120405 },
-	{ 120432, 120457 },
-	{ 120488, 120512 },
-	{ 120546, 120570 },
-	{ 120604, 120628 },
-	{ 120662, 120686 },
-	{ 120720, 120744 },
-	{ 120778, 120778 },
-	{ 125184, 125217 },
-};
-static const URange16 Pf_range16[] = {
-	{ 187, 187 },
-	{ 8217, 8217 },
-	{ 8221, 8221 },
-	{ 8250, 8250 },
-	{ 11779, 11779 },
-	{ 11781, 11781 },
-	{ 11786, 11786 },
-	{ 11789, 11789 },
-	{ 11805, 11805 },
-	{ 11809, 11809 },
-};
-static const URange16 Pd_range16[] = {
-	{ 45, 45 },
-	{ 1418, 1418 },
-	{ 1470, 1470 },
-	{ 5120, 5120 },
-	{ 6150, 6150 },
-	{ 8208, 8213 },
-	{ 11799, 11799 },
-	{ 11802, 11802 },
-	{ 11834, 11835 },
-	{ 11840, 11840 },
-	{ 12316, 12316 },
-	{ 12336, 12336 },
-	{ 12448, 12448 },
-	{ 65073, 65074 },
-	{ 65112, 65112 },
-	{ 65123, 65123 },
-	{ 65293, 65293 },
-};
-static const URange16 Pe_range16[] = {
-	{ 41, 41 },
-	{ 93, 93 },
-	{ 125, 125 },
-	{ 3899, 3899 },
-	{ 3901, 3901 },
-	{ 5788, 5788 },
-	{ 8262, 8262 },
-	{ 8318, 8318 },
-	{ 8334, 8334 },
-	{ 8969, 8969 },
-	{ 8971, 8971 },
-	{ 9002, 9002 },
-	{ 10089, 10089 },
-	{ 10091, 10091 },
-	{ 10093, 10093 },
-	{ 10095, 10095 },
-	{ 10097, 10097 },
-	{ 10099, 10099 },
-	{ 10101, 10101 },
-	{ 10182, 10182 },
-	{ 10215, 10215 },
-	{ 10217, 10217 },
-	{ 10219, 10219 },
-	{ 10221, 10221 },
-	{ 10223, 10223 },
-	{ 10628, 10628 },
-	{ 10630, 10630 },
-	{ 10632, 10632 },
-	{ 10634, 10634 },
-	{ 10636, 10636 },
-	{ 10638, 10638 },
-	{ 10640, 10640 },
-	{ 10642, 10642 },
-	{ 10644, 10644 },
-	{ 10646, 10646 },
-	{ 10648, 10648 },
-	{ 10713, 10713 },
-	{ 10715, 10715 },
-	{ 10749, 10749 },
-	{ 11811, 11811 },
-	{ 11813, 11813 },
-	{ 11815, 11815 },
-	{ 11817, 11817 },
-	{ 12297, 12297 },
-	{ 12299, 12299 },
-	{ 12301, 12301 },
-	{ 12303, 12303 },
-	{ 12305, 12305 },
-	{ 12309, 12309 },
-	{ 12311, 12311 },
-	{ 12313, 12313 },
-	{ 12315, 12315 },
-	{ 12318, 12319 },
-	{ 64830, 64830 },
-	{ 65048, 65048 },
-	{ 65078, 65078 },
-	{ 65080, 65080 },
-	{ 65082, 65082 },
-	{ 65084, 65084 },
-	{ 65086, 65086 },
-	{ 65088, 65088 },
-	{ 65090, 65090 },
-	{ 65092, 65092 },
-	{ 65096, 65096 },
-	{ 65114, 65114 },
-	{ 65116, 65116 },
-	{ 65118, 65118 },
-	{ 65289, 65289 },
-	{ 65341, 65341 },
-	{ 65373, 65373 },
-	{ 65376, 65376 },
-	{ 65379, 65379 },
-};
-static const URange16 Pi_range16[] = {
-	{ 171, 171 },
-	{ 8216, 8216 },
-	{ 8219, 8220 },
-	{ 8223, 8223 },
-	{ 8249, 8249 },
-	{ 11778, 11778 },
-	{ 11780, 11780 },
-	{ 11785, 11785 },
-	{ 11788, 11788 },
-	{ 11804, 11804 },
-	{ 11808, 11808 },
-};
-static const URange16 Po_range16[] = {
-	{ 33, 35 },
-	{ 37, 39 },
-	{ 42, 42 },
-	{ 44, 44 },
-	{ 46, 47 },
-	{ 58, 59 },
-	{ 63, 64 },
-	{ 92, 92 },
-	{ 161, 161 },
-	{ 167, 167 },
-	{ 182, 183 },
-	{ 191, 191 },
-	{ 894, 894 },
-	{ 903, 903 },
-	{ 1370, 1375 },
-	{ 1417, 1417 },
-	{ 1472, 1472 },
-	{ 1475, 1475 },
-	{ 1478, 1478 },
-	{ 1523, 1524 },
-	{ 1545, 1546 },
-	{ 1548, 1549 },
-	{ 1563, 1563 },
-	{ 1566, 1567 },
-	{ 1642, 1645 },
-	{ 1748, 1748 },
-	{ 1792, 1805 },
-	{ 2039, 2041 },
-	{ 2096, 2110 },
-	{ 2142, 2142 },
-	{ 2404, 2405 },
-	{ 2416, 2416 },
-	{ 2557, 2557 },
-	{ 2678, 2678 },
-	{ 2800, 2800 },
-	{ 3204, 3204 },
-	{ 3572, 3572 },
-	{ 3663, 3663 },
-	{ 3674, 3675 },
-	{ 3844, 3858 },
-	{ 3860, 3860 },
-	{ 3973, 3973 },
-	{ 4048, 4052 },
-	{ 4057, 4058 },
-	{ 4170, 4175 },
-	{ 4347, 4347 },
-	{ 4960, 4968 },
-	{ 5741, 5742 },
-	{ 5867, 5869 },
-	{ 5941, 5942 },
-	{ 6100, 6102 },
-	{ 6104, 6106 },
-	{ 6144, 6149 },
-	{ 6151, 6154 },
-	{ 6468, 6469 },
-	{ 6686, 6687 },
-	{ 6816, 6822 },
-	{ 6824, 6829 },
-	{ 7002, 7008 },
-	{ 7164, 7167 },
-	{ 7227, 7231 },
-	{ 7294, 7295 },
-	{ 7360, 7367 },
-	{ 7379, 7379 },
-	{ 8214, 8215 },
-	{ 8224, 8231 },
-	{ 8240, 8248 },
-	{ 8251, 8254 },
-	{ 8257, 8259 },
-	{ 8263, 8273 },
-	{ 8275, 8275 },
-	{ 8277, 8286 },
-	{ 11513, 11516 },
-	{ 11518, 11519 },
-	{ 11632, 11632 },
-	{ 11776, 11777 },
-	{ 11782, 11784 },
-	{ 11787, 11787 },
-	{ 11790, 11798 },
-	{ 11800, 11801 },
-	{ 11803, 11803 },
-	{ 11806, 11807 },
-	{ 11818, 11822 },
-	{ 11824, 11833 },
-	{ 11836, 11839 },
-	{ 11841, 11841 },
-	{ 11843, 11854 },
-	{ 12289, 12291 },
-	{ 12349, 12349 },
-	{ 12539, 12539 },
-	{ 42238, 42239 },
-	{ 42509, 42511 },
-	{ 42611, 42611 },
-	{ 42622, 42622 },
-	{ 42738, 42743 },
-	{ 43124, 43127 },
-	{ 43214, 43215 },
-	{ 43256, 43258 },
-	{ 43260, 43260 },
-	{ 43310, 43311 },
-	{ 43359, 43359 },
-	{ 43457, 43469 },
-	{ 43486, 43487 },
-	{ 43612, 43615 },
-	{ 43742, 43743 },
-	{ 43760, 43761 },
-	{ 44011, 44011 },
-	{ 65040, 65046 },
-	{ 65049, 65049 },
-	{ 65072, 65072 },
-	{ 65093, 65094 },
-	{ 65097, 65100 },
-	{ 65104, 65106 },
-	{ 65108, 65111 },
-	{ 65119, 65121 },
-	{ 65128, 65128 },
-	{ 65130, 65131 },
-	{ 65281, 65283 },
-	{ 65285, 65287 },
-	{ 65290, 65290 },
-	{ 65292, 65292 },
-	{ 65294, 65295 },
-	{ 65306, 65307 },
-	{ 65311, 65312 },
-	{ 65340, 65340 },
-	{ 65377, 65377 },
-	{ 65380, 65381 },
-};
-static const URange32 Po_range32[] = {
-	{ 65792, 65794 },
-	{ 66463, 66463 },
-	{ 66512, 66512 },
-	{ 66927, 66927 },
-	{ 67671, 67671 },
-	{ 67871, 67871 },
-	{ 67903, 67903 },
-	{ 68176, 68184 },
-	{ 68223, 68223 },
-	{ 68336, 68342 },
-	{ 68409, 68415 },
-	{ 68505, 68508 },
-	{ 69461, 69465 },
-	{ 69703, 69709 },
-	{ 69819, 69820 },
-	{ 69822, 69825 },
-	{ 69952, 69955 },
-	{ 70004, 70005 },
-	{ 70085, 70088 },
-	{ 70093, 70093 },
-	{ 70107, 70107 },
-	{ 70109, 70111 },
-	{ 70200, 70205 },
-	{ 70313, 70313 },
-	{ 70731, 70735 },
-	{ 70747, 70747 },
-	{ 70749, 70749 },
-	{ 70854, 70854 },
-	{ 71105, 71127 },
-	{ 71233, 71235 },
-	{ 71264, 71276 },
-	{ 71484, 71486 },
-	{ 71739, 71739 },
-	{ 72255, 72262 },
-	{ 72346, 72348 },
-	{ 72350, 72354 },
-	{ 72769, 72773 },
-	{ 72816, 72817 },
-	{ 73463, 73464 },
-	{ 74864, 74868 },
-	{ 92782, 92783 },
-	{ 92917, 92917 },
-	{ 92983, 92987 },
-	{ 92996, 92996 },
-	{ 93847, 93850 },
-	{ 113823, 113823 },
-	{ 121479, 121483 },
-	{ 125278, 125279 },
-};
-static const URange16 Me_range16[] = {
-	{ 1160, 1161 },
-	{ 6846, 6846 },
-	{ 8413, 8416 },
-	{ 8418, 8420 },
-	{ 42608, 42610 },
-};
-static const URange16 C_range16[] = {
-	{ 0, 31 },
-	{ 127, 159 },
-	{ 173, 173 },
-	{ 1536, 1541 },
-	{ 1564, 1564 },
-	{ 1757, 1757 },
-	{ 1807, 1807 },
-	{ 2274, 2274 },
-	{ 6158, 6158 },
-	{ 8203, 8207 },
-	{ 8234, 8238 },
-	{ 8288, 8292 },
-	{ 8294, 8303 },
-	{ 55296, 63743 },
-	{ 65279, 65279 },
-	{ 65529, 65531 },
-};
-static const URange32 C_range32[] = {
-	{ 69821, 69821 },
-	{ 69837, 69837 },
-	{ 113824, 113827 },
-	{ 119155, 119162 },
-	{ 917505, 917505 },
-	{ 917536, 917631 },
-	{ 983040, 1048573 },
-	{ 1048576, 1114109 },
-};
-static const URange16 Mc_range16[] = {
-	{ 2307, 2307 },
-	{ 2363, 2363 },
-	{ 2366, 2368 },
-	{ 2377, 2380 },
-	{ 2382, 2383 },
-	{ 2434, 2435 },
-	{ 2494, 2496 },
-	{ 2503, 2504 },
-	{ 2507, 2508 },
-	{ 2519, 2519 },
-	{ 2563, 2563 },
-	{ 2622, 2624 },
-	{ 2691, 2691 },
-	{ 2750, 2752 },
-	{ 2761, 2761 },
-	{ 2763, 2764 },
-	{ 2818, 2819 },
-	{ 2878, 2878 },
-	{ 2880, 2880 },
-	{ 2887, 2888 },
-	{ 2891, 2892 },
-	{ 2903, 2903 },
-	{ 3006, 3007 },
-	{ 3009, 3010 },
-	{ 3014, 3016 },
-	{ 3018, 3020 },
-	{ 3031, 3031 },
-	{ 3073, 3075 },
-	{ 3137, 3140 },
-	{ 3202, 3203 },
-	{ 3262, 3262 },
-	{ 3264, 3268 },
-	{ 3271, 3272 },
-	{ 3274, 3275 },
-	{ 3285, 3286 },
-	{ 3330, 3331 },
-	{ 3390, 3392 },
-	{ 3398, 3400 },
-	{ 3402, 3404 },
-	{ 3415, 3415 },
-	{ 3458, 3459 },
-	{ 3535, 3537 },
-	{ 3544, 3551 },
-	{ 3570, 3571 },
-	{ 3902, 3903 },
-	{ 3967, 3967 },
-	{ 4139, 4140 },
-	{ 4145, 4145 },
-	{ 4152, 4152 },
-	{ 4155, 4156 },
-	{ 4182, 4183 },
-	{ 4194, 4196 },
-	{ 4199, 4205 },
-	{ 4227, 4228 },
-	{ 4231, 4236 },
-	{ 4239, 4239 },
-	{ 4250, 4252 },
-	{ 6070, 6070 },
-	{ 6078, 6085 },
-	{ 6087, 6088 },
-	{ 6435, 6438 },
-	{ 6441, 6443 },
-	{ 6448, 6449 },
-	{ 6451, 6456 },
-	{ 6681, 6682 },
-	{ 6741, 6741 },
-	{ 6743, 6743 },
-	{ 6753, 6753 },
-	{ 6755, 6756 },
-	{ 6765, 6770 },
-	{ 6916, 6916 },
-	{ 6965, 6965 },
-	{ 6971, 6971 },
-	{ 6973, 6977 },
-	{ 6979, 6980 },
-	{ 7042, 7042 },
-	{ 7073, 7073 },
-	{ 7078, 7079 },
-	{ 7082, 7082 },
-	{ 7143, 7143 },
-	{ 7146, 7148 },
-	{ 7150, 7150 },
-	{ 7154, 7155 },
-	{ 7204, 7211 },
-	{ 7220, 7221 },
-	{ 7393, 7393 },
-	{ 7410, 7411 },
-	{ 7415, 7415 },
-	{ 12334, 12335 },
-	{ 43043, 43044 },
-	{ 43047, 43047 },
-	{ 43136, 43137 },
-	{ 43188, 43203 },
-	{ 43346, 43347 },
-	{ 43395, 43395 },
-	{ 43444, 43445 },
-	{ 43450, 43451 },
-	{ 43453, 43456 },
-	{ 43567, 43568 },
-	{ 43571, 43572 },
-	{ 43597, 43597 },
-	{ 43643, 43643 },
-	{ 43645, 43645 },
-	{ 43755, 43755 },
-	{ 43758, 43759 },
-	{ 43765, 43765 },
-	{ 44003, 44004 },
-	{ 44006, 44007 },
-	{ 44009, 44010 },
-	{ 44012, 44012 },
-};
-static const URange32 Mc_range32[] = {
-	{ 69632, 69632 },
-	{ 69634, 69634 },
-	{ 69762, 69762 },
-	{ 69808, 69810 },
-	{ 69815, 69816 },
-	{ 69932, 69932 },
-	{ 69957, 69958 },
-	{ 70018, 70018 },
-	{ 70067, 70069 },
-	{ 70079, 70080 },
-	{ 70188, 70190 },
-	{ 70194, 70195 },
-	{ 70197, 70197 },
-	{ 70368, 70370 },
-	{ 70402, 70403 },
-	{ 70462, 70463 },
-	{ 70465, 70468 },
-	{ 70471, 70472 },
-	{ 70475, 70477 },
-	{ 70487, 70487 },
-	{ 70498, 70499 },
-	{ 70709, 70711 },
-	{ 70720, 70721 },
-	{ 70725, 70725 },
-	{ 70832, 70834 },
-	{ 70841, 70841 },
-	{ 70843, 70846 },
-	{ 70849, 70849 },
-	{ 71087, 71089 },
-	{ 71096, 71099 },
-	{ 71102, 71102 },
-	{ 71216, 71218 },
-	{ 71227, 71228 },
-	{ 71230, 71230 },
-	{ 71340, 71340 },
-	{ 71342, 71343 },
-	{ 71350, 71350 },
-	{ 71456, 71457 },
-	{ 71462, 71462 },
-	{ 71724, 71726 },
-	{ 71736, 71736 },
-	{ 72249, 72249 },
-	{ 72279, 72280 },
-	{ 72343, 72343 },
-	{ 72751, 72751 },
-	{ 72766, 72766 },
-	{ 72873, 72873 },
-	{ 72881, 72881 },
-	{ 72884, 72884 },
-	{ 73098, 73102 },
-	{ 73107, 73108 },
-	{ 73110, 73110 },
-	{ 73461, 73462 },
-	{ 94033, 94078 },
-	{ 119141, 119142 },
-	{ 119149, 119154 },
-};
-static const URange16 Mn_range16[] = {
-	{ 768, 879 },
-	{ 1155, 1159 },
-	{ 1425, 1469 },
-	{ 1471, 1471 },
-	{ 1473, 1474 },
-	{ 1476, 1477 },
-	{ 1479, 1479 },
-	{ 1552, 1562 },
-	{ 1611, 1631 },
-	{ 1648, 1648 },
-	{ 1750, 1756 },
-	{ 1759, 1764 },
-	{ 1767, 1768 },
-	{ 1770, 1773 },
-	{ 1809, 1809 },
-	{ 1840, 1866 },
-	{ 1958, 1968 },
-	{ 2027, 2035 },
-	{ 2045, 2045 },
-	{ 2070, 2073 },
-	{ 2075, 2083 },
-	{ 2085, 2087 },
-	{ 2089, 2093 },
-	{ 2137, 2139 },
-	{ 2259, 2273 },
-	{ 2275, 2306 },
-	{ 2362, 2362 },
-	{ 2364, 2364 },
-	{ 2369, 2376 },
-	{ 2381, 2381 },
-	{ 2385, 2391 },
-	{ 2402, 2403 },
-	{ 2433, 2433 },
-	{ 2492, 2492 },
-	{ 2497, 2500 },
-	{ 2509, 2509 },
-	{ 2530, 2531 },
-	{ 2558, 2558 },
-	{ 2561, 2562 },
-	{ 2620, 2620 },
-	{ 2625, 2626 },
-	{ 2631, 2632 },
-	{ 2635, 2637 },
-	{ 2641, 2641 },
-	{ 2672, 2673 },
-	{ 2677, 2677 },
-	{ 2689, 2690 },
-	{ 2748, 2748 },
-	{ 2753, 2757 },
-	{ 2759, 2760 },
-	{ 2765, 2765 },
-	{ 2786, 2787 },
-	{ 2810, 2815 },
-	{ 2817, 2817 },
-	{ 2876, 2876 },
-	{ 2879, 2879 },
-	{ 2881, 2884 },
-	{ 2893, 2893 },
-	{ 2902, 2902 },
-	{ 2914, 2915 },
-	{ 2946, 2946 },
-	{ 3008, 3008 },
-	{ 3021, 3021 },
-	{ 3072, 3072 },
-	{ 3076, 3076 },
-	{ 3134, 3136 },
-	{ 3142, 3144 },
-	{ 3146, 3149 },
-	{ 3157, 3158 },
-	{ 3170, 3171 },
-	{ 3201, 3201 },
-	{ 3260, 3260 },
-	{ 3263, 3263 },
-	{ 3270, 3270 },
-	{ 3276, 3277 },
-	{ 3298, 3299 },
-	{ 3328, 3329 },
-	{ 3387, 3388 },
-	{ 3393, 3396 },
-	{ 3405, 3405 },
-	{ 3426, 3427 },
-	{ 3530, 3530 },
-	{ 3538, 3540 },
-	{ 3542, 3542 },
-	{ 3633, 3633 },
-	{ 3636, 3642 },
-	{ 3655, 3662 },
-	{ 3761, 3761 },
-	{ 3764, 3769 },
-	{ 3771, 3772 },
-	{ 3784, 3789 },
-	{ 3864, 3865 },
-	{ 3893, 3893 },
-	{ 3895, 3895 },
-	{ 3897, 3897 },
-	{ 3953, 3966 },
-	{ 3968, 3972 },
-	{ 3974, 3975 },
-	{ 3981, 3991 },
-	{ 3993, 4028 },
-	{ 4038, 4038 },
-	{ 4141, 4144 },
-	{ 4146, 4151 },
-	{ 4153, 4154 },
-	{ 4157, 4158 },
-	{ 4184, 4185 },
-	{ 4190, 4192 },
-	{ 4209, 4212 },
-	{ 4226, 4226 },
-	{ 4229, 4230 },
-	{ 4237, 4237 },
-	{ 4253, 4253 },
-	{ 4957, 4959 },
-	{ 5906, 5908 },
-	{ 5938, 5940 },
-	{ 5970, 5971 },
-	{ 6002, 6003 },
-	{ 6068, 6069 },
-	{ 6071, 6077 },
-	{ 6086, 6086 },
-	{ 6089, 6099 },
-	{ 6109, 6109 },
-	{ 6155, 6157 },
-	{ 6277, 6278 },
-	{ 6313, 6313 },
-	{ 6432, 6434 },
-	{ 6439, 6440 },
-	{ 6450, 6450 },
-	{ 6457, 6459 },
-	{ 6679, 6680 },
-	{ 6683, 6683 },
-	{ 6742, 6742 },
-	{ 6744, 6750 },
-	{ 6752, 6752 },
-	{ 6754, 6754 },
-	{ 6757, 6764 },
-	{ 6771, 6780 },
-	{ 6783, 6783 },
-	{ 6832, 6845 },
-	{ 6912, 6915 },
-	{ 6964, 6964 },
-	{ 6966, 6970 },
-	{ 6972, 6972 },
-	{ 6978, 6978 },
-	{ 7019, 7027 },
-	{ 7040, 7041 },
-	{ 7074, 7077 },
-	{ 7080, 7081 },
-	{ 7083, 7085 },
-	{ 7142, 7142 },
-	{ 7144, 7145 },
-	{ 7149, 7149 },
-	{ 7151, 7153 },
-	{ 7212, 7219 },
-	{ 7222, 7223 },
-	{ 7376, 7378 },
-	{ 7380, 7392 },
-	{ 7394, 7400 },
-	{ 7405, 7405 },
-	{ 7412, 7412 },
-	{ 7416, 7417 },
-	{ 7616, 7673 },
-	{ 7675, 7679 },
-	{ 8400, 8412 },
-	{ 8417, 8417 },
-	{ 8421, 8432 },
-	{ 11503, 11505 },
-	{ 11647, 11647 },
-	{ 11744, 11775 },
-	{ 12330, 12333 },
-	{ 12441, 12442 },
-	{ 42607, 42607 },
-	{ 42612, 42621 },
-	{ 42654, 42655 },
-	{ 42736, 42737 },
-	{ 43010, 43010 },
-	{ 43014, 43014 },
-	{ 43019, 43019 },
-	{ 43045, 43046 },
-	{ 43204, 43205 },
-	{ 43232, 43249 },
-	{ 43263, 43263 },
-	{ 43302, 43309 },
-	{ 43335, 43345 },
-	{ 43392, 43394 },
-	{ 43443, 43443 },
-	{ 43446, 43449 },
-	{ 43452, 43452 },
-	{ 43493, 43493 },
-	{ 43561, 43566 },
-	{ 43569, 43570 },
-	{ 43573, 43574 },
-	{ 43587, 43587 },
-	{ 43596, 43596 },
-	{ 43644, 43644 },
-	{ 43696, 43696 },
-	{ 43698, 43700 },
-	{ 43703, 43704 },
-	{ 43710, 43711 },
-	{ 43713, 43713 },
-	{ 43756, 43757 },
-	{ 43766, 43766 },
-	{ 44005, 44005 },
-	{ 44008, 44008 },
-	{ 44013, 44013 },
-	{ 64286, 64286 },
-	{ 65024, 65039 },
-	{ 65056, 65071 },
-};
-static const URange32 Mn_range32[] = {
-	{ 66045, 66045 },
-	{ 66272, 66272 },
-	{ 66422, 66426 },
-	{ 68097, 68099 },
-	{ 68101, 68102 },
-	{ 68108, 68111 },
-	{ 68152, 68154 },
-	{ 68159, 68159 },
-	{ 68325, 68326 },
-	{ 68900, 68903 },
-	{ 69446, 69456 },
-	{ 69633, 69633 },
-	{ 69688, 69702 },
-	{ 69759, 69761 },
-	{ 69811, 69814 },
-	{ 69817, 69818 },
-	{ 69888, 69890 },
-	{ 69927, 69931 },
-	{ 69933, 69940 },
-	{ 70003, 70003 },
-	{ 70016, 70017 },
-	{ 70070, 70078 },
-	{ 70089, 70092 },
-	{ 70191, 70193 },
-	{ 70196, 70196 },
-	{ 70198, 70199 },
-	{ 70206, 70206 },
-	{ 70367, 70367 },
-	{ 70371, 70378 },
-	{ 70400, 70401 },
-	{ 70459, 70460 },
-	{ 70464, 70464 },
-	{ 70502, 70508 },
-	{ 70512, 70516 },
-	{ 70712, 70719 },
-	{ 70722, 70724 },
-	{ 70726, 70726 },
-	{ 70750, 70750 },
-	{ 70835, 70840 },
-	{ 70842, 70842 },
-	{ 70847, 70848 },
-	{ 70850, 70851 },
-	{ 71090, 71093 },
-	{ 71100, 71101 },
-	{ 71103, 71104 },
-	{ 71132, 71133 },
-	{ 71219, 71226 },
-	{ 71229, 71229 },
-	{ 71231, 71232 },
-	{ 71339, 71339 },
-	{ 71341, 71341 },
-	{ 71344, 71349 },
-	{ 71351, 71351 },
-	{ 71453, 71455 },
-	{ 71458, 71461 },
-	{ 71463, 71467 },
-	{ 71727, 71735 },
-	{ 71737, 71738 },
-	{ 72193, 72202 },
-	{ 72243, 72248 },
-	{ 72251, 72254 },
-	{ 72263, 72263 },
-	{ 72273, 72278 },
-	{ 72281, 72283 },
-	{ 72330, 72342 },
-	{ 72344, 72345 },
-	{ 72752, 72758 },
-	{ 72760, 72765 },
-	{ 72767, 72767 },
-	{ 72850, 72871 },
-	{ 72874, 72880 },
-	{ 72882, 72883 },
-	{ 72885, 72886 },
-	{ 73009, 73014 },
-	{ 73018, 73018 },
-	{ 73020, 73021 },
-	{ 73023, 73029 },
-	{ 73031, 73031 },
-	{ 73104, 73105 },
-	{ 73109, 73109 },
-	{ 73111, 73111 },
-	{ 73459, 73460 },
-	{ 92912, 92916 },
-	{ 92976, 92982 },
-	{ 94095, 94098 },
-	{ 113821, 113822 },
-	{ 119143, 119145 },
-	{ 119163, 119170 },
-	{ 119173, 119179 },
-	{ 119210, 119213 },
-	{ 119362, 119364 },
-	{ 121344, 121398 },
-	{ 121403, 121452 },
-	{ 121461, 121461 },
-	{ 121476, 121476 },
-	{ 121499, 121503 },
-	{ 121505, 121519 },
-	{ 122880, 122886 },
-	{ 122888, 122904 },
-	{ 122907, 122913 },
-	{ 122915, 122916 },
-	{ 122918, 122922 },
-	{ 125136, 125142 },
-	{ 125252, 125258 },
-	{ 917760, 917999 },
-};
-static const URange16 M_range16[] = {
-	{ 768, 879 },
-	{ 1155, 1161 },
-	{ 1425, 1469 },
-	{ 1471, 1471 },
-	{ 1473, 1474 },
-	{ 1476, 1477 },
-	{ 1479, 1479 },
-	{ 1552, 1562 },
-	{ 1611, 1631 },
-	{ 1648, 1648 },
-	{ 1750, 1756 },
-	{ 1759, 1764 },
-	{ 1767, 1768 },
-	{ 1770, 1773 },
-	{ 1809, 1809 },
-	{ 1840, 1866 },
-	{ 1958, 1968 },
-	{ 2027, 2035 },
-	{ 2045, 2045 },
-	{ 2070, 2073 },
-	{ 2075, 2083 },
-	{ 2085, 2087 },
-	{ 2089, 2093 },
-	{ 2137, 2139 },
-	{ 2259, 2273 },
-	{ 2275, 2307 },
-	{ 2362, 2364 },
-	{ 2366, 2383 },
-	{ 2385, 2391 },
-	{ 2402, 2403 },
-	{ 2433, 2435 },
-	{ 2492, 2492 },
-	{ 2494, 2500 },
-	{ 2503, 2504 },
-	{ 2507, 2509 },
-	{ 2519, 2519 },
-	{ 2530, 2531 },
-	{ 2558, 2558 },
-	{ 2561, 2563 },
-	{ 2620, 2620 },
-	{ 2622, 2626 },
-	{ 2631, 2632 },
-	{ 2635, 2637 },
-	{ 2641, 2641 },
-	{ 2672, 2673 },
-	{ 2677, 2677 },
-	{ 2689, 2691 },
-	{ 2748, 2748 },
-	{ 2750, 2757 },
-	{ 2759, 2761 },
-	{ 2763, 2765 },
-	{ 2786, 2787 },
-	{ 2810, 2815 },
-	{ 2817, 2819 },
-	{ 2876, 2876 },
-	{ 2878, 2884 },
-	{ 2887, 2888 },
-	{ 2891, 2893 },
-	{ 2902, 2903 },
-	{ 2914, 2915 },
-	{ 2946, 2946 },
-	{ 3006, 3010 },
-	{ 3014, 3016 },
-	{ 3018, 3021 },
-	{ 3031, 3031 },
-	{ 3072, 3076 },
-	{ 3134, 3140 },
-	{ 3142, 3144 },
-	{ 3146, 3149 },
-	{ 3157, 3158 },
-	{ 3170, 3171 },
-	{ 3201, 3203 },
-	{ 3260, 3260 },
-	{ 3262, 3268 },
-	{ 3270, 3272 },
-	{ 3274, 3277 },
-	{ 3285, 3286 },
-	{ 3298, 3299 },
-	{ 3328, 3331 },
-	{ 3387, 3388 },
-	{ 3390, 3396 },
-	{ 3398, 3400 },
-	{ 3402, 3405 },
-	{ 3415, 3415 },
-	{ 3426, 3427 },
-	{ 3458, 3459 },
-	{ 3530, 3530 },
-	{ 3535, 3540 },
-	{ 3542, 3542 },
-	{ 3544, 3551 },
-	{ 3570, 3571 },
-	{ 3633, 3633 },
-	{ 3636, 3642 },
-	{ 3655, 3662 },
-	{ 3761, 3761 },
-	{ 3764, 3769 },
-	{ 3771, 3772 },
-	{ 3784, 3789 },
-	{ 3864, 3865 },
-	{ 3893, 3893 },
-	{ 3895, 3895 },
-	{ 3897, 3897 },
-	{ 3902, 3903 },
-	{ 3953, 3972 },
-	{ 3974, 3975 },
-	{ 3981, 3991 },
-	{ 3993, 4028 },
-	{ 4038, 4038 },
-	{ 4139, 4158 },
-	{ 4182, 4185 },
-	{ 4190, 4192 },
-	{ 4194, 4196 },
-	{ 4199, 4205 },
-	{ 4209, 4212 },
-	{ 4226, 4237 },
-	{ 4239, 4239 },
-	{ 4250, 4253 },
-	{ 4957, 4959 },
-	{ 5906, 5908 },
-	{ 5938, 5940 },
-	{ 5970, 5971 },
-	{ 6002, 6003 },
-	{ 6068, 6099 },
-	{ 6109, 6109 },
-	{ 6155, 6157 },
-	{ 6277, 6278 },
-	{ 6313, 6313 },
-	{ 6432, 6443 },
-	{ 6448, 6459 },
-	{ 6679, 6683 },
-	{ 6741, 6750 },
-	{ 6752, 6780 },
-	{ 6783, 6783 },
-	{ 6832, 6846 },
-	{ 6912, 6916 },
-	{ 6964, 6980 },
-	{ 7019, 7027 },
-	{ 7040, 7042 },
-	{ 7073, 7085 },
-	{ 7142, 7155 },
-	{ 7204, 7223 },
-	{ 7376, 7378 },
-	{ 7380, 7400 },
-	{ 7405, 7405 },
-	{ 7410, 7412 },
-	{ 7415, 7417 },
-	{ 7616, 7673 },
-	{ 7675, 7679 },
-	{ 8400, 8432 },
-	{ 11503, 11505 },
-	{ 11647, 11647 },
-	{ 11744, 11775 },
-	{ 12330, 12335 },
-	{ 12441, 12442 },
-	{ 42607, 42610 },
-	{ 42612, 42621 },
-	{ 42654, 42655 },
-	{ 42736, 42737 },
-	{ 43010, 43010 },
-	{ 43014, 43014 },
-	{ 43019, 43019 },
-	{ 43043, 43047 },
-	{ 43136, 43137 },
-	{ 43188, 43205 },
-	{ 43232, 43249 },
-	{ 43263, 43263 },
-	{ 43302, 43309 },
-	{ 43335, 43347 },
-	{ 43392, 43395 },
-	{ 43443, 43456 },
-	{ 43493, 43493 },
-	{ 43561, 43574 },
-	{ 43587, 43587 },
-	{ 43596, 43597 },
-	{ 43643, 43645 },
-	{ 43696, 43696 },
-	{ 43698, 43700 },
-	{ 43703, 43704 },
-	{ 43710, 43711 },
-	{ 43713, 43713 },
-	{ 43755, 43759 },
-	{ 43765, 43766 },
-	{ 44003, 44010 },
-	{ 44012, 44013 },
-	{ 64286, 64286 },
-	{ 65024, 65039 },
-	{ 65056, 65071 },
-};
-static const URange32 M_range32[] = {
-	{ 66045, 66045 },
-	{ 66272, 66272 },
-	{ 66422, 66426 },
-	{ 68097, 68099 },
-	{ 68101, 68102 },
-	{ 68108, 68111 },
-	{ 68152, 68154 },
-	{ 68159, 68159 },
-	{ 68325, 68326 },
-	{ 68900, 68903 },
-	{ 69446, 69456 },
-	{ 69632, 69634 },
-	{ 69688, 69702 },
-	{ 69759, 69762 },
-	{ 69808, 69818 },
-	{ 69888, 69890 },
-	{ 69927, 69940 },
-	{ 69957, 69958 },
-	{ 70003, 70003 },
-	{ 70016, 70018 },
-	{ 70067, 70080 },
-	{ 70089, 70092 },
-	{ 70188, 70199 },
-	{ 70206, 70206 },
-	{ 70367, 70378 },
-	{ 70400, 70403 },
-	{ 70459, 70460 },
-	{ 70462, 70468 },
-	{ 70471, 70472 },
-	{ 70475, 70477 },
-	{ 70487, 70487 },
-	{ 70498, 70499 },
-	{ 70502, 70508 },
-	{ 70512, 70516 },
-	{ 70709, 70726 },
-	{ 70750, 70750 },
-	{ 70832, 70851 },
-	{ 71087, 71093 },
-	{ 71096, 71104 },
-	{ 71132, 71133 },
-	{ 71216, 71232 },
-	{ 71339, 71351 },
-	{ 71453, 71467 },
-	{ 71724, 71738 },
-	{ 72193, 72202 },
-	{ 72243, 72249 },
-	{ 72251, 72254 },
-	{ 72263, 72263 },
-	{ 72273, 72283 },
-	{ 72330, 72345 },
-	{ 72751, 72758 },
-	{ 72760, 72767 },
-	{ 72850, 72871 },
-	{ 72873, 72886 },
-	{ 73009, 73014 },
-	{ 73018, 73018 },
-	{ 73020, 73021 },
-	{ 73023, 73029 },
-	{ 73031, 73031 },
-	{ 73098, 73102 },
-	{ 73104, 73105 },
-	{ 73107, 73111 },
-	{ 73459, 73462 },
-	{ 92912, 92916 },
-	{ 92976, 92982 },
-	{ 94033, 94078 },
-	{ 94095, 94098 },
-	{ 113821, 113822 },
-	{ 119141, 119145 },
-	{ 119149, 119154 },
-	{ 119163, 119170 },
-	{ 119173, 119179 },
-	{ 119210, 119213 },
-	{ 119362, 119364 },
-	{ 121344, 121398 },
-	{ 121403, 121452 },
-	{ 121461, 121461 },
-	{ 121476, 121476 },
-	{ 121499, 121503 },
-	{ 121505, 121519 },
-	{ 122880, 122886 },
-	{ 122888, 122904 },
-	{ 122907, 122913 },
-	{ 122915, 122916 },
-	{ 122918, 122922 },
-	{ 125136, 125142 },
-	{ 125252, 125258 },
-	{ 917760, 917999 },
-};
-static const URange16 L_range16[] = {
-	{ 65, 90 },
-	{ 97, 122 },
-	{ 170, 170 },
-	{ 181, 181 },
-	{ 186, 186 },
-	{ 192, 214 },
-	{ 216, 246 },
-	{ 248, 705 },
-	{ 710, 721 },
-	{ 736, 740 },
-	{ 748, 748 },
-	{ 750, 750 },
-	{ 880, 884 },
-	{ 886, 887 },
-	{ 890, 893 },
-	{ 895, 895 },
-	{ 902, 902 },
-	{ 904, 906 },
-	{ 908, 908 },
-	{ 910, 929 },
-	{ 931, 1013 },
-	{ 1015, 1153 },
-	{ 1162, 1327 },
-	{ 1329, 1366 },
-	{ 1369, 1369 },
-	{ 1376, 1416 },
-	{ 1488, 1514 },
-	{ 1519, 1522 },
-	{ 1568, 1610 },
-	{ 1646, 1647 },
-	{ 1649, 1747 },
-	{ 1749, 1749 },
-	{ 1765, 1766 },
-	{ 1774, 1775 },
-	{ 1786, 1788 },
-	{ 1791, 1791 },
-	{ 1808, 1808 },
-	{ 1810, 1839 },
-	{ 1869, 1957 },
-	{ 1969, 1969 },
-	{ 1994, 2026 },
-	{ 2036, 2037 },
-	{ 2042, 2042 },
-	{ 2048, 2069 },
-	{ 2074, 2074 },
-	{ 2084, 2084 },
-	{ 2088, 2088 },
-	{ 2112, 2136 },
-	{ 2144, 2154 },
-	{ 2208, 2228 },
-	{ 2230, 2237 },
-	{ 2308, 2361 },
-	{ 2365, 2365 },
-	{ 2384, 2384 },
-	{ 2392, 2401 },
-	{ 2417, 2432 },
-	{ 2437, 2444 },
-	{ 2447, 2448 },
-	{ 2451, 2472 },
-	{ 2474, 2480 },
-	{ 2482, 2482 },
-	{ 2486, 2489 },
-	{ 2493, 2493 },
-	{ 2510, 2510 },
-	{ 2524, 2525 },
-	{ 2527, 2529 },
-	{ 2544, 2545 },
-	{ 2556, 2556 },
-	{ 2565, 2570 },
-	{ 2575, 2576 },
-	{ 2579, 2600 },
-	{ 2602, 2608 },
-	{ 2610, 2611 },
-	{ 2613, 2614 },
-	{ 2616, 2617 },
-	{ 2649, 2652 },
-	{ 2654, 2654 },
-	{ 2674, 2676 },
-	{ 2693, 2701 },
-	{ 2703, 2705 },
-	{ 2707, 2728 },
-	{ 2730, 2736 },
-	{ 2738, 2739 },
-	{ 2741, 2745 },
-	{ 2749, 2749 },
-	{ 2768, 2768 },
-	{ 2784, 2785 },
-	{ 2809, 2809 },
-	{ 2821, 2828 },
-	{ 2831, 2832 },
-	{ 2835, 2856 },
-	{ 2858, 2864 },
-	{ 2866, 2867 },
-	{ 2869, 2873 },
-	{ 2877, 2877 },
-	{ 2908, 2909 },
-	{ 2911, 2913 },
-	{ 2929, 2929 },
-	{ 2947, 2947 },
-	{ 2949, 2954 },
-	{ 2958, 2960 },
-	{ 2962, 2965 },
-	{ 2969, 2970 },
-	{ 2972, 2972 },
-	{ 2974, 2975 },
-	{ 2979, 2980 },
-	{ 2984, 2986 },
-	{ 2990, 3001 },
-	{ 3024, 3024 },
-	{ 3077, 3084 },
-	{ 3086, 3088 },
-	{ 3090, 3112 },
-	{ 3114, 3129 },
-	{ 3133, 3133 },
-	{ 3160, 3162 },
-	{ 3168, 3169 },
-	{ 3200, 3200 },
-	{ 3205, 3212 },
-	{ 3214, 3216 },
-	{ 3218, 3240 },
-	{ 3242, 3251 },
-	{ 3253, 3257 },
-	{ 3261, 3261 },
-	{ 3294, 3294 },
-	{ 3296, 3297 },
-	{ 3313, 3314 },
-	{ 3333, 3340 },
-	{ 3342, 3344 },
-	{ 3346, 3386 },
-	{ 3389, 3389 },
-	{ 3406, 3406 },
-	{ 3412, 3414 },
-	{ 3423, 3425 },
-	{ 3450, 3455 },
-	{ 3461, 3478 },
-	{ 3482, 3505 },
-	{ 3507, 3515 },
-	{ 3517, 3517 },
-	{ 3520, 3526 },
-	{ 3585, 3632 },
-	{ 3634, 3635 },
-	{ 3648, 3654 },
-	{ 3713, 3714 },
-	{ 3716, 3716 },
-	{ 3719, 3720 },
-	{ 3722, 3722 },
-	{ 3725, 3725 },
-	{ 3732, 3735 },
-	{ 3737, 3743 },
-	{ 3745, 3747 },
-	{ 3749, 3749 },
-	{ 3751, 3751 },
-	{ 3754, 3755 },
-	{ 3757, 3760 },
-	{ 3762, 3763 },
-	{ 3773, 3773 },
-	{ 3776, 3780 },
-	{ 3782, 3782 },
-	{ 3804, 3807 },
-	{ 3840, 3840 },
-	{ 3904, 3911 },
-	{ 3913, 3948 },
-	{ 3976, 3980 },
-	{ 4096, 4138 },
-	{ 4159, 4159 },
-	{ 4176, 4181 },
-	{ 4186, 4189 },
-	{ 4193, 4193 },
-	{ 4197, 4198 },
-	{ 4206, 4208 },
-	{ 4213, 4225 },
-	{ 4238, 4238 },
-	{ 4256, 4293 },
-	{ 4295, 4295 },
-	{ 4301, 4301 },
-	{ 4304, 4346 },
-	{ 4348, 4680 },
-	{ 4682, 4685 },
-	{ 4688, 4694 },
-	{ 4696, 4696 },
-	{ 4698, 4701 },
-	{ 4704, 4744 },
-	{ 4746, 4749 },
-	{ 4752, 4784 },
-	{ 4786, 4789 },
-	{ 4792, 4798 },
-	{ 4800, 4800 },
-	{ 4802, 4805 },
-	{ 4808, 4822 },
-	{ 4824, 4880 },
-	{ 4882, 4885 },
-	{ 4888, 4954 },
-	{ 4992, 5007 },
-	{ 5024, 5109 },
-	{ 5112, 5117 },
-	{ 5121, 5740 },
-	{ 5743, 5759 },
-	{ 5761, 5786 },
-	{ 5792, 5866 },
-	{ 5873, 5880 },
-	{ 5888, 5900 },
-	{ 5902, 5905 },
-	{ 5920, 5937 },
-	{ 5952, 5969 },
-	{ 5984, 5996 },
-	{ 5998, 6000 },
-	{ 6016, 6067 },
-	{ 6103, 6103 },
-	{ 6108, 6108 },
-	{ 6176, 6264 },
-	{ 6272, 6276 },
-	{ 6279, 6312 },
-	{ 6314, 6314 },
-	{ 6320, 6389 },
-	{ 6400, 6430 },
-	{ 6480, 6509 },
-	{ 6512, 6516 },
-	{ 6528, 6571 },
-	{ 6576, 6601 },
-	{ 6656, 6678 },
-	{ 6688, 6740 },
-	{ 6823, 6823 },
-	{ 6917, 6963 },
-	{ 6981, 6987 },
-	{ 7043, 7072 },
-	{ 7086, 7087 },
-	{ 7098, 7141 },
-	{ 7168, 7203 },
-	{ 7245, 7247 },
-	{ 7258, 7293 },
-	{ 7296, 7304 },
-	{ 7312, 7354 },
-	{ 7357, 7359 },
-	{ 7401, 7404 },
-	{ 7406, 7409 },
-	{ 7413, 7414 },
-	{ 7424, 7615 },
-	{ 7680, 7957 },
-	{ 7960, 7965 },
-	{ 7968, 8005 },
-	{ 8008, 8013 },
-	{ 8016, 8023 },
-	{ 8025, 8025 },
-	{ 8027, 8027 },
-	{ 8029, 8029 },
-	{ 8031, 8061 },
-	{ 8064, 8116 },
-	{ 8118, 8124 },
-	{ 8126, 8126 },
-	{ 8130, 8132 },
-	{ 8134, 8140 },
-	{ 8144, 8147 },
-	{ 8150, 8155 },
-	{ 8160, 8172 },
-	{ 8178, 8180 },
-	{ 8182, 8188 },
-	{ 8305, 8305 },
-	{ 8319, 8319 },
-	{ 8336, 8348 },
-	{ 8450, 8450 },
-	{ 8455, 8455 },
-	{ 8458, 8467 },
-	{ 8469, 8469 },
-	{ 8473, 8477 },
-	{ 8484, 8484 },
-	{ 8486, 8486 },
-	{ 8488, 8488 },
-	{ 8490, 8493 },
-	{ 8495, 8505 },
-	{ 8508, 8511 },
-	{ 8517, 8521 },
-	{ 8526, 8526 },
-	{ 8579, 8580 },
-	{ 11264, 11310 },
-	{ 11312, 11358 },
-	{ 11360, 11492 },
-	{ 11499, 11502 },
-	{ 11506, 11507 },
-	{ 11520, 11557 },
-	{ 11559, 11559 },
-	{ 11565, 11565 },
-	{ 11568, 11623 },
-	{ 11631, 11631 },
-	{ 11648, 11670 },
-	{ 11680, 11686 },
-	{ 11688, 11694 },
-	{ 11696, 11702 },
-	{ 11704, 11710 },
-	{ 11712, 11718 },
-	{ 11720, 11726 },
-	{ 11728, 11734 },
-	{ 11736, 11742 },
-	{ 11823, 11823 },
-	{ 12293, 12294 },
-	{ 12337, 12341 },
-	{ 12347, 12348 },
-	{ 12353, 12438 },
-	{ 12445, 12447 },
-	{ 12449, 12538 },
-	{ 12540, 12543 },
-	{ 12549, 12591 },
-	{ 12593, 12686 },
-	{ 12704, 12730 },
-	{ 12784, 12799 },
-	{ 13312, 19893 },
-	{ 19968, 40943 },
-	{ 40960, 42124 },
-	{ 42192, 42237 },
-	{ 42240, 42508 },
-	{ 42512, 42527 },
-	{ 42538, 42539 },
-	{ 42560, 42606 },
-	{ 42623, 42653 },
-	{ 42656, 42725 },
-	{ 42775, 42783 },
-	{ 42786, 42888 },
-	{ 42891, 42937 },
-	{ 42999, 43009 },
-	{ 43011, 43013 },
-	{ 43015, 43018 },
-	{ 43020, 43042 },
-	{ 43072, 43123 },
-	{ 43138, 43187 },
-	{ 43250, 43255 },
-	{ 43259, 43259 },
-	{ 43261, 43262 },
-	{ 43274, 43301 },
-	{ 43312, 43334 },
-	{ 43360, 43388 },
-	{ 43396, 43442 },
-	{ 43471, 43471 },
-	{ 43488, 43492 },
-	{ 43494, 43503 },
-	{ 43514, 43518 },
-	{ 43520, 43560 },
-	{ 43584, 43586 },
-	{ 43588, 43595 },
-	{ 43616, 43638 },
-	{ 43642, 43642 },
-	{ 43646, 43695 },
-	{ 43697, 43697 },
-	{ 43701, 43702 },
-	{ 43705, 43709 },
-	{ 43712, 43712 },
-	{ 43714, 43714 },
-	{ 43739, 43741 },
-	{ 43744, 43754 },
-	{ 43762, 43764 },
-	{ 43777, 43782 },
-	{ 43785, 43790 },
-	{ 43793, 43798 },
-	{ 43808, 43814 },
-	{ 43816, 43822 },
-	{ 43824, 43866 },
-	{ 43868, 43877 },
-	{ 43888, 44002 },
-	{ 44032, 55203 },
-	{ 55216, 55238 },
-	{ 55243, 55291 },
-	{ 63744, 64109 },
-	{ 64112, 64217 },
-	{ 64256, 64262 },
-	{ 64275, 64279 },
-	{ 64285, 64285 },
-	{ 64287, 64296 },
-	{ 64298, 64310 },
-	{ 64312, 64316 },
-	{ 64318, 64318 },
-	{ 64320, 64321 },
-	{ 64323, 64324 },
-	{ 64326, 64433 },
-	{ 64467, 64829 },
-	{ 64848, 64911 },
-	{ 64914, 64967 },
-	{ 65008, 65019 },
-	{ 65136, 65140 },
-	{ 65142, 65276 },
-	{ 65313, 65338 },
-	{ 65345, 65370 },
-	{ 65382, 65470 },
-	{ 65474, 65479 },
-	{ 65482, 65487 },
-	{ 65490, 65495 },
-	{ 65498, 65500 },
-};
-static const URange32 L_range32[] = {
-	{ 65536, 65547 },
-	{ 65549, 65574 },
-	{ 65576, 65594 },
-	{ 65596, 65597 },
-	{ 65599, 65613 },
-	{ 65616, 65629 },
-	{ 65664, 65786 },
-	{ 66176, 66204 },
-	{ 66208, 66256 },
-	{ 66304, 66335 },
-	{ 66349, 66368 },
-	{ 66370, 66377 },
-	{ 66384, 66421 },
-	{ 66432, 66461 },
-	{ 66464, 66499 },
-	{ 66504, 66511 },
-	{ 66560, 66717 },
-	{ 66736, 66771 },
-	{ 66776, 66811 },
-	{ 66816, 66855 },
-	{ 66864, 66915 },
-	{ 67072, 67382 },
-	{ 67392, 67413 },
-	{ 67424, 67431 },
-	{ 67584, 67589 },
-	{ 67592, 67592 },
-	{ 67594, 67637 },
-	{ 67639, 67640 },
-	{ 67644, 67644 },
-	{ 67647, 67669 },
-	{ 67680, 67702 },
-	{ 67712, 67742 },
-	{ 67808, 67826 },
-	{ 67828, 67829 },
-	{ 67840, 67861 },
-	{ 67872, 67897 },
-	{ 67968, 68023 },
-	{ 68030, 68031 },
-	{ 68096, 68096 },
-	{ 68112, 68115 },
-	{ 68117, 68119 },
-	{ 68121, 68149 },
-	{ 68192, 68220 },
-	{ 68224, 68252 },
-	{ 68288, 68295 },
-	{ 68297, 68324 },
-	{ 68352, 68405 },
-	{ 68416, 68437 },
-	{ 68448, 68466 },
-	{ 68480, 68497 },
-	{ 68608, 68680 },
-	{ 68736, 68786 },
-	{ 68800, 68850 },
-	{ 68864, 68899 },
-	{ 69376, 69404 },
-	{ 69415, 69415 },
-	{ 69424, 69445 },
-	{ 69635, 69687 },
-	{ 69763, 69807 },
-	{ 69840, 69864 },
-	{ 69891, 69926 },
-	{ 69956, 69956 },
-	{ 69968, 70002 },
-	{ 70006, 70006 },
-	{ 70019, 70066 },
-	{ 70081, 70084 },
-	{ 70106, 70106 },
-	{ 70108, 70108 },
-	{ 70144, 70161 },
-	{ 70163, 70187 },
-	{ 70272, 70278 },
-	{ 70280, 70280 },
-	{ 70282, 70285 },
-	{ 70287, 70301 },
-	{ 70303, 70312 },
-	{ 70320, 70366 },
-	{ 70405, 70412 },
-	{ 70415, 70416 },
-	{ 70419, 70440 },
-	{ 70442, 70448 },
-	{ 70450, 70451 },
-	{ 70453, 70457 },
-	{ 70461, 70461 },
-	{ 70480, 70480 },
-	{ 70493, 70497 },
-	{ 70656, 70708 },
-	{ 70727, 70730 },
-	{ 70784, 70831 },
-	{ 70852, 70853 },
-	{ 70855, 70855 },
-	{ 71040, 71086 },
-	{ 71128, 71131 },
-	{ 71168, 71215 },
-	{ 71236, 71236 },
-	{ 71296, 71338 },
-	{ 71424, 71450 },
-	{ 71680, 71723 },
-	{ 71840, 71903 },
-	{ 71935, 71935 },
-	{ 72192, 72192 },
-	{ 72203, 72242 },
-	{ 72250, 72250 },
-	{ 72272, 72272 },
-	{ 72284, 72323 },
-	{ 72326, 72329 },
-	{ 72349, 72349 },
-	{ 72384, 72440 },
-	{ 72704, 72712 },
-	{ 72714, 72750 },
-	{ 72768, 72768 },
-	{ 72818, 72847 },
-	{ 72960, 72966 },
-	{ 72968, 72969 },
-	{ 72971, 73008 },
-	{ 73030, 73030 },
-	{ 73056, 73061 },
-	{ 73063, 73064 },
-	{ 73066, 73097 },
-	{ 73112, 73112 },
-	{ 73440, 73458 },
-	{ 73728, 74649 },
-	{ 74880, 75075 },
-	{ 77824, 78894 },
-	{ 82944, 83526 },
-	{ 92160, 92728 },
-	{ 92736, 92766 },
-	{ 92880, 92909 },
-	{ 92928, 92975 },
-	{ 92992, 92995 },
-	{ 93027, 93047 },
-	{ 93053, 93071 },
-	{ 93760, 93823 },
-	{ 93952, 94020 },
-	{ 94032, 94032 },
-	{ 94099, 94111 },
-	{ 94176, 94177 },
-	{ 94208, 100337 },
-	{ 100352, 101106 },
-	{ 110592, 110878 },
-	{ 110960, 111355 },
-	{ 113664, 113770 },
-	{ 113776, 113788 },
-	{ 113792, 113800 },
-	{ 113808, 113817 },
-	{ 119808, 119892 },
-	{ 119894, 119964 },
-	{ 119966, 119967 },
-	{ 119970, 119970 },
-	{ 119973, 119974 },
-	{ 119977, 119980 },
-	{ 119982, 119993 },
-	{ 119995, 119995 },
-	{ 119997, 120003 },
-	{ 120005, 120069 },
-	{ 120071, 120074 },
-	{ 120077, 120084 },
-	{ 120086, 120092 },
-	{ 120094, 120121 },
-	{ 120123, 120126 },
-	{ 120128, 120132 },
-	{ 120134, 120134 },
-	{ 120138, 120144 },
-	{ 120146, 120485 },
-	{ 120488, 120512 },
-	{ 120514, 120538 },
-	{ 120540, 120570 },
-	{ 120572, 120596 },
-	{ 120598, 120628 },
-	{ 120630, 120654 },
-	{ 120656, 120686 },
-	{ 120688, 120712 },
-	{ 120714, 120744 },
-	{ 120746, 120770 },
-	{ 120772, 120779 },
-	{ 124928, 125124 },
-	{ 125184, 125251 },
-	{ 126464, 126467 },
-	{ 126469, 126495 },
-	{ 126497, 126498 },
-	{ 126500, 126500 },
-	{ 126503, 126503 },
-	{ 126505, 126514 },
-	{ 126516, 126519 },
-	{ 126521, 126521 },
-	{ 126523, 126523 },
-	{ 126530, 126530 },
-	{ 126535, 126535 },
-	{ 126537, 126537 },
-	{ 126539, 126539 },
-	{ 126541, 126543 },
-	{ 126545, 126546 },
-	{ 126548, 126548 },
-	{ 126551, 126551 },
-	{ 126553, 126553 },
-	{ 126555, 126555 },
-	{ 126557, 126557 },
-	{ 126559, 126559 },
-	{ 126561, 126562 },
-	{ 126564, 126564 },
-	{ 126567, 126570 },
-	{ 126572, 126578 },
-	{ 126580, 126583 },
-	{ 126585, 126588 },
-	{ 126590, 126590 },
-	{ 126592, 126601 },
-	{ 126603, 126619 },
-	{ 126625, 126627 },
-	{ 126629, 126633 },
-	{ 126635, 126651 },
-	{ 131072, 173782 },
-	{ 173824, 177972 },
-	{ 177984, 178205 },
-	{ 178208, 183969 },
-	{ 183984, 191456 },
-	{ 194560, 195101 },
-};
-static const URange16 N_range16[] = {
-	{ 48, 57 },
-	{ 178, 179 },
-	{ 185, 185 },
-	{ 188, 190 },
-	{ 1632, 1641 },
-	{ 1776, 1785 },
-	{ 1984, 1993 },
-	{ 2406, 2415 },
-	{ 2534, 2543 },
-	{ 2548, 2553 },
-	{ 2662, 2671 },
-	{ 2790, 2799 },
-	{ 2918, 2927 },
-	{ 2930, 2935 },
-	{ 3046, 3058 },
-	{ 3174, 3183 },
-	{ 3192, 3198 },
-	{ 3302, 3311 },
-	{ 3416, 3422 },
-	{ 3430, 3448 },
-	{ 3558, 3567 },
-	{ 3664, 3673 },
-	{ 3792, 3801 },
-	{ 3872, 3891 },
-	{ 4160, 4169 },
-	{ 4240, 4249 },
-	{ 4969, 4988 },
-	{ 5870, 5872 },
-	{ 6112, 6121 },
-	{ 6128, 6137 },
-	{ 6160, 6169 },
-	{ 6470, 6479 },
-	{ 6608, 6618 },
-	{ 6784, 6793 },
-	{ 6800, 6809 },
-	{ 6992, 7001 },
-	{ 7088, 7097 },
-	{ 7232, 7241 },
-	{ 7248, 7257 },
-	{ 8304, 8304 },
-	{ 8308, 8313 },
-	{ 8320, 8329 },
-	{ 8528, 8578 },
-	{ 8581, 8585 },
-	{ 9312, 9371 },
-	{ 9450, 9471 },
-	{ 10102, 10131 },
-	{ 11517, 11517 },
-	{ 12295, 12295 },
-	{ 12321, 12329 },
-	{ 12344, 12346 },
-	{ 12690, 12693 },
-	{ 12832, 12841 },
-	{ 12872, 12879 },
-	{ 12881, 12895 },
-	{ 12928, 12937 },
-	{ 12977, 12991 },
-	{ 42528, 42537 },
-	{ 42726, 42735 },
-	{ 43056, 43061 },
-	{ 43216, 43225 },
-	{ 43264, 43273 },
-	{ 43472, 43481 },
-	{ 43504, 43513 },
-	{ 43600, 43609 },
-	{ 44016, 44025 },
-	{ 65296, 65305 },
-};
-static const URange32 N_range32[] = {
-	{ 65799, 65843 },
-	{ 65856, 65912 },
-	{ 65930, 65931 },
-	{ 66273, 66299 },
-	{ 66336, 66339 },
-	{ 66369, 66369 },
-	{ 66378, 66378 },
-	{ 66513, 66517 },
-	{ 66720, 66729 },
-	{ 67672, 67679 },
-	{ 67705, 67711 },
-	{ 67751, 67759 },
-	{ 67835, 67839 },
-	{ 67862, 67867 },
-	{ 68028, 68029 },
-	{ 68032, 68047 },
-	{ 68050, 68095 },
-	{ 68160, 68168 },
-	{ 68221, 68222 },
-	{ 68253, 68255 },
-	{ 68331, 68335 },
-	{ 68440, 68447 },
-	{ 68472, 68479 },
-	{ 68521, 68527 },
-	{ 68858, 68863 },
-	{ 68912, 68921 },
-	{ 69216, 69246 },
-	{ 69405, 69414 },
-	{ 69457, 69460 },
-	{ 69714, 69743 },
-	{ 69872, 69881 },
-	{ 69942, 69951 },
-	{ 70096, 70105 },
-	{ 70113, 70132 },
-	{ 70384, 70393 },
-	{ 70736, 70745 },
-	{ 70864, 70873 },
-	{ 71248, 71257 },
-	{ 71360, 71369 },
-	{ 71472, 71483 },
-	{ 71904, 71922 },
-	{ 72784, 72812 },
-	{ 73040, 73049 },
-	{ 73120, 73129 },
-	{ 74752, 74862 },
-	{ 92768, 92777 },
-	{ 93008, 93017 },
-	{ 93019, 93025 },
-	{ 93824, 93846 },
-	{ 119520, 119539 },
-	{ 119648, 119672 },
-	{ 120782, 120831 },
-	{ 125127, 125135 },
-	{ 125264, 125273 },
-	{ 126065, 126123 },
-	{ 126125, 126127 },
-	{ 126129, 126132 },
-	{ 127232, 127244 },
-};
-static const URange16 Sk_range16[] = {
-	{ 94, 94 },
-	{ 96, 96 },
-	{ 168, 168 },
-	{ 175, 175 },
-	{ 180, 180 },
-	{ 184, 184 },
-	{ 706, 709 },
-	{ 722, 735 },
-	{ 741, 747 },
-	{ 749, 749 },
-	{ 751, 767 },
-	{ 885, 885 },
-	{ 900, 901 },
-	{ 8125, 8125 },
-	{ 8127, 8129 },
-	{ 8141, 8143 },
-	{ 8157, 8159 },
-	{ 8173, 8175 },
-	{ 8189, 8190 },
-	{ 12443, 12444 },
-	{ 42752, 42774 },
-	{ 42784, 42785 },
-	{ 42889, 42890 },
-	{ 43867, 43867 },
-	{ 64434, 64449 },
-	{ 65342, 65342 },
-	{ 65344, 65344 },
-	{ 65507, 65507 },
-};
-static const URange32 Sk_range32[] = {
-	{ 127995, 127999 },
-};
-static const URange16 P_range16[] = {
-	{ 33, 35 },
-	{ 37, 42 },
-	{ 44, 47 },
-	{ 58, 59 },
-	{ 63, 64 },
-	{ 91, 93 },
-	{ 95, 95 },
-	{ 123, 123 },
-	{ 125, 125 },
-	{ 161, 161 },
-	{ 167, 167 },
-	{ 171, 171 },
-	{ 182, 183 },
-	{ 187, 187 },
-	{ 191, 191 },
-	{ 894, 894 },
-	{ 903, 903 },
-	{ 1370, 1375 },
-	{ 1417, 1418 },
-	{ 1470, 1470 },
-	{ 1472, 1472 },
-	{ 1475, 1475 },
-	{ 1478, 1478 },
-	{ 1523, 1524 },
-	{ 1545, 1546 },
-	{ 1548, 1549 },
-	{ 1563, 1563 },
-	{ 1566, 1567 },
-	{ 1642, 1645 },
-	{ 1748, 1748 },
-	{ 1792, 1805 },
-	{ 2039, 2041 },
-	{ 2096, 2110 },
-	{ 2142, 2142 },
-	{ 2404, 2405 },
-	{ 2416, 2416 },
-	{ 2557, 2557 },
-	{ 2678, 2678 },
-	{ 2800, 2800 },
-	{ 3204, 3204 },
-	{ 3572, 3572 },
-	{ 3663, 3663 },
-	{ 3674, 3675 },
-	{ 3844, 3858 },
-	{ 3860, 3860 },
-	{ 3898, 3901 },
-	{ 3973, 3973 },
-	{ 4048, 4052 },
-	{ 4057, 4058 },
-	{ 4170, 4175 },
-	{ 4347, 4347 },
-	{ 4960, 4968 },
-	{ 5120, 5120 },
-	{ 5741, 5742 },
-	{ 5787, 5788 },
-	{ 5867, 5869 },
-	{ 5941, 5942 },
-	{ 6100, 6102 },
-	{ 6104, 6106 },
-	{ 6144, 6154 },
-	{ 6468, 6469 },
-	{ 6686, 6687 },
-	{ 6816, 6822 },
-	{ 6824, 6829 },
-	{ 7002, 7008 },
-	{ 7164, 7167 },
-	{ 7227, 7231 },
-	{ 7294, 7295 },
-	{ 7360, 7367 },
-	{ 7379, 7379 },
-	{ 8208, 8231 },
-	{ 8240, 8259 },
-	{ 8261, 8273 },
-	{ 8275, 8286 },
-	{ 8317, 8318 },
-	{ 8333, 8334 },
-	{ 8968, 8971 },
-	{ 9001, 9002 },
-	{ 10088, 10101 },
-	{ 10181, 10182 },
-	{ 10214, 10223 },
-	{ 10627, 10648 },
-	{ 10712, 10715 },
-	{ 10748, 10749 },
-	{ 11513, 11516 },
-	{ 11518, 11519 },
-	{ 11632, 11632 },
-	{ 11776, 11822 },
-	{ 11824, 11854 },
-	{ 12289, 12291 },
-	{ 12296, 12305 },
-	{ 12308, 12319 },
-	{ 12336, 12336 },
-	{ 12349, 12349 },
-	{ 12448, 12448 },
-	{ 12539, 12539 },
-	{ 42238, 42239 },
-	{ 42509, 42511 },
-	{ 42611, 42611 },
-	{ 42622, 42622 },
-	{ 42738, 42743 },
-	{ 43124, 43127 },
-	{ 43214, 43215 },
-	{ 43256, 43258 },
-	{ 43260, 43260 },
-	{ 43310, 43311 },
-	{ 43359, 43359 },
-	{ 43457, 43469 },
-	{ 43486, 43487 },
-	{ 43612, 43615 },
-	{ 43742, 43743 },
-	{ 43760, 43761 },
-	{ 44011, 44011 },
-	{ 64830, 64831 },
-	{ 65040, 65049 },
-	{ 65072, 65106 },
-	{ 65108, 65121 },
-	{ 65123, 65123 },
-	{ 65128, 65128 },
-	{ 65130, 65131 },
-	{ 65281, 65283 },
-	{ 65285, 65290 },
-	{ 65292, 65295 },
-	{ 65306, 65307 },
-	{ 65311, 65312 },
-	{ 65339, 65341 },
-	{ 65343, 65343 },
-	{ 65371, 65371 },
-	{ 65373, 65373 },
-	{ 65375, 65381 },
-};
-static const URange32 P_range32[] = {
-	{ 65792, 65794 },
-	{ 66463, 66463 },
-	{ 66512, 66512 },
-	{ 66927, 66927 },
-	{ 67671, 67671 },
-	{ 67871, 67871 },
-	{ 67903, 67903 },
-	{ 68176, 68184 },
-	{ 68223, 68223 },
-	{ 68336, 68342 },
-	{ 68409, 68415 },
-	{ 68505, 68508 },
-	{ 69461, 69465 },
-	{ 69703, 69709 },
-	{ 69819, 69820 },
-	{ 69822, 69825 },
-	{ 69952, 69955 },
-	{ 70004, 70005 },
-	{ 70085, 70088 },
-	{ 70093, 70093 },
-	{ 70107, 70107 },
-	{ 70109, 70111 },
-	{ 70200, 70205 },
-	{ 70313, 70313 },
-	{ 70731, 70735 },
-	{ 70747, 70747 },
-	{ 70749, 70749 },
-	{ 70854, 70854 },
-	{ 71105, 71127 },
-	{ 71233, 71235 },
-	{ 71264, 71276 },
-	{ 71484, 71486 },
-	{ 71739, 71739 },
-	{ 72255, 72262 },
-	{ 72346, 72348 },
-	{ 72350, 72354 },
-	{ 72769, 72773 },
-	{ 72816, 72817 },
-	{ 73463, 73464 },
-	{ 74864, 74868 },
-	{ 92782, 92783 },
-	{ 92917, 92917 },
-	{ 92983, 92987 },
-	{ 92996, 92996 },
-	{ 93847, 93850 },
-	{ 113823, 113823 },
-	{ 121479, 121483 },
-	{ 125278, 125279 },
-};
-static const URange16 S_range16[] = {
-	{ 36, 36 },
-	{ 43, 43 },
-	{ 60, 62 },
-	{ 94, 94 },
-	{ 96, 96 },
-	{ 124, 124 },
-	{ 126, 126 },
-	{ 162, 166 },
-	{ 168, 169 },
-	{ 172, 172 },
-	{ 174, 177 },
-	{ 180, 180 },
-	{ 184, 184 },
-	{ 215, 215 },
-	{ 247, 247 },
-	{ 706, 709 },
-	{ 722, 735 },
-	{ 741, 747 },
-	{ 749, 749 },
-	{ 751, 767 },
-	{ 885, 885 },
-	{ 900, 901 },
-	{ 1014, 1014 },
-	{ 1154, 1154 },
-	{ 1421, 1423 },
-	{ 1542, 1544 },
-	{ 1547, 1547 },
-	{ 1550, 1551 },
-	{ 1758, 1758 },
-	{ 1769, 1769 },
-	{ 1789, 1790 },
-	{ 2038, 2038 },
-	{ 2046, 2047 },
-	{ 2546, 2547 },
-	{ 2554, 2555 },
-	{ 2801, 2801 },
-	{ 2928, 2928 },
-	{ 3059, 3066 },
-	{ 3199, 3199 },
-	{ 3407, 3407 },
-	{ 3449, 3449 },
-	{ 3647, 3647 },
-	{ 3841, 3843 },
-	{ 3859, 3859 },
-	{ 3861, 3863 },
-	{ 3866, 3871 },
-	{ 3892, 3892 },
-	{ 3894, 3894 },
-	{ 3896, 3896 },
-	{ 4030, 4037 },
-	{ 4039, 4044 },
-	{ 4046, 4047 },
-	{ 4053, 4056 },
-	{ 4254, 4255 },
-	{ 5008, 5017 },
-	{ 6107, 6107 },
-	{ 6464, 6464 },
-	{ 6622, 6655 },
-	{ 7009, 7018 },
-	{ 7028, 7036 },
-	{ 8125, 8125 },
-	{ 8127, 8129 },
-	{ 8141, 8143 },
-	{ 8157, 8159 },
-	{ 8173, 8175 },
-	{ 8189, 8190 },
-	{ 8260, 8260 },
-	{ 8274, 8274 },
-	{ 8314, 8316 },
-	{ 8330, 8332 },
-	{ 8352, 8383 },
-	{ 8448, 8449 },
-	{ 8451, 8454 },
-	{ 8456, 8457 },
-	{ 8468, 8468 },
-	{ 8470, 8472 },
-	{ 8478, 8483 },
-	{ 8485, 8485 },
-	{ 8487, 8487 },
-	{ 8489, 8489 },
-	{ 8494, 8494 },
-	{ 8506, 8507 },
-	{ 8512, 8516 },
-	{ 8522, 8525 },
-	{ 8527, 8527 },
-	{ 8586, 8587 },
-	{ 8592, 8967 },
-	{ 8972, 9000 },
-	{ 9003, 9254 },
-	{ 9280, 9290 },
-	{ 9372, 9449 },
-	{ 9472, 10087 },
-	{ 10132, 10180 },
-	{ 10183, 10213 },
-	{ 10224, 10626 },
-	{ 10649, 10711 },
-	{ 10716, 10747 },
-	{ 10750, 11123 },
-	{ 11126, 11157 },
-	{ 11160, 11208 },
-	{ 11210, 11262 },
-	{ 11493, 11498 },
-	{ 11904, 11929 },
-	{ 11931, 12019 },
-	{ 12032, 12245 },
-	{ 12272, 12283 },
-	{ 12292, 12292 },
-	{ 12306, 12307 },
-	{ 12320, 12320 },
-	{ 12342, 12343 },
-	{ 12350, 12351 },
-	{ 12443, 12444 },
-	{ 12688, 12689 },
-	{ 12694, 12703 },
-	{ 12736, 12771 },
-	{ 12800, 12830 },
-	{ 12842, 12871 },
-	{ 12880, 12880 },
-	{ 12896, 12927 },
-	{ 12938, 12976 },
-	{ 12992, 13054 },
-	{ 13056, 13311 },
-	{ 19904, 19967 },
-	{ 42128, 42182 },
-	{ 42752, 42774 },
-	{ 42784, 42785 },
-	{ 42889, 42890 },
-	{ 43048, 43051 },
-	{ 43062, 43065 },
-	{ 43639, 43641 },
-	{ 43867, 43867 },
-	{ 64297, 64297 },
-	{ 64434, 64449 },
-	{ 65020, 65021 },
-	{ 65122, 65122 },
-	{ 65124, 65126 },
-	{ 65129, 65129 },
-	{ 65284, 65284 },
-	{ 65291, 65291 },
-	{ 65308, 65310 },
-	{ 65342, 65342 },
-	{ 65344, 65344 },
-	{ 65372, 65372 },
-	{ 65374, 65374 },
-	{ 65504, 65510 },
-	{ 65512, 65518 },
-	{ 65532, 65533 },
-};
-static const URange32 S_range32[] = {
-	{ 65847, 65855 },
-	{ 65913, 65929 },
-	{ 65932, 65934 },
-	{ 65936, 65947 },
-	{ 65952, 65952 },
-	{ 66000, 66044 },
-	{ 67703, 67704 },
-	{ 68296, 68296 },
-	{ 71487, 71487 },
-	{ 92988, 92991 },
-	{ 92997, 92997 },
-	{ 113820, 113820 },
-	{ 118784, 119029 },
-	{ 119040, 119078 },
-	{ 119081, 119140 },
-	{ 119146, 119148 },
-	{ 119171, 119172 },
-	{ 119180, 119209 },
-	{ 119214, 119272 },
-	{ 119296, 119361 },
-	{ 119365, 119365 },
-	{ 119552, 119638 },
-	{ 120513, 120513 },
-	{ 120539, 120539 },
-	{ 120571, 120571 },
-	{ 120597, 120597 },
-	{ 120629, 120629 },
-	{ 120655, 120655 },
-	{ 120687, 120687 },
-	{ 120713, 120713 },
-	{ 120745, 120745 },
-	{ 120771, 120771 },
-	{ 120832, 121343 },
-	{ 121399, 121402 },
-	{ 121453, 121460 },
-	{ 121462, 121475 },
-	{ 121477, 121478 },
-	{ 126124, 126124 },
-	{ 126128, 126128 },
-	{ 126704, 126705 },
-	{ 126976, 127019 },
-	{ 127024, 127123 },
-	{ 127136, 127150 },
-	{ 127153, 127167 },
-	{ 127169, 127183 },
-	{ 127185, 127221 },
-	{ 127248, 127339 },
-	{ 127344, 127404 },
-	{ 127462, 127490 },
-	{ 127504, 127547 },
-	{ 127552, 127560 },
-	{ 127568, 127569 },
-	{ 127584, 127589 },
-	{ 127744, 128724 },
-	{ 128736, 128748 },
-	{ 128752, 128761 },
-	{ 128768, 128883 },
-	{ 128896, 128984 },
-	{ 129024, 129035 },
-	{ 129040, 129095 },
-	{ 129104, 129113 },
-	{ 129120, 129159 },
-	{ 129168, 129197 },
-	{ 129280, 129291 },
-	{ 129296, 129342 },
-	{ 129344, 129392 },
-	{ 129395, 129398 },
-	{ 129402, 129402 },
-	{ 129404, 129442 },
-	{ 129456, 129465 },
-	{ 129472, 129474 },
-	{ 129488, 129535 },
-	{ 129632, 129645 },
-};
-static const URange16 So_range16[] = {
-	{ 166, 166 },
-	{ 169, 169 },
-	{ 174, 174 },
-	{ 176, 176 },
-	{ 1154, 1154 },
-	{ 1421, 1422 },
-	{ 1550, 1551 },
-	{ 1758, 1758 },
-	{ 1769, 1769 },
-	{ 1789, 1790 },
-	{ 2038, 2038 },
-	{ 2554, 2554 },
-	{ 2928, 2928 },
-	{ 3059, 3064 },
-	{ 3066, 3066 },
-	{ 3199, 3199 },
-	{ 3407, 3407 },
-	{ 3449, 3449 },
-	{ 3841, 3843 },
-	{ 3859, 3859 },
-	{ 3861, 3863 },
-	{ 3866, 3871 },
-	{ 3892, 3892 },
-	{ 3894, 3894 },
-	{ 3896, 3896 },
-	{ 4030, 4037 },
-	{ 4039, 4044 },
-	{ 4046, 4047 },
-	{ 4053, 4056 },
-	{ 4254, 4255 },
-	{ 5008, 5017 },
-	{ 6464, 6464 },
-	{ 6622, 6655 },
-	{ 7009, 7018 },
-	{ 7028, 7036 },
-	{ 8448, 8449 },
-	{ 8451, 8454 },
-	{ 8456, 8457 },
-	{ 8468, 8468 },
-	{ 8470, 8471 },
-	{ 8478, 8483 },
-	{ 8485, 8485 },
-	{ 8487, 8487 },
-	{ 8489, 8489 },
-	{ 8494, 8494 },
-	{ 8506, 8507 },
-	{ 8522, 8522 },
-	{ 8524, 8525 },
-	{ 8527, 8527 },
-	{ 8586, 8587 },
-	{ 8597, 8601 },
-	{ 8604, 8607 },
-	{ 8609, 8610 },
-	{ 8612, 8613 },
-	{ 8615, 8621 },
-	{ 8623, 8653 },
-	{ 8656, 8657 },
-	{ 8659, 8659 },
-	{ 8661, 8691 },
-	{ 8960, 8967 },
-	{ 8972, 8991 },
-	{ 8994, 9000 },
-	{ 9003, 9083 },
-	{ 9085, 9114 },
-	{ 9140, 9179 },
-	{ 9186, 9254 },
-	{ 9280, 9290 },
-	{ 9372, 9449 },
-	{ 9472, 9654 },
-	{ 9656, 9664 },
-	{ 9666, 9719 },
-	{ 9728, 9838 },
-	{ 9840, 10087 },
-	{ 10132, 10175 },
-	{ 10240, 10495 },
-	{ 11008, 11055 },
-	{ 11077, 11078 },
-	{ 11085, 11123 },
-	{ 11126, 11157 },
-	{ 11160, 11208 },
-	{ 11210, 11262 },
-	{ 11493, 11498 },
-	{ 11904, 11929 },
-	{ 11931, 12019 },
-	{ 12032, 12245 },
-	{ 12272, 12283 },
-	{ 12292, 12292 },
-	{ 12306, 12307 },
-	{ 12320, 12320 },
-	{ 12342, 12343 },
-	{ 12350, 12351 },
-	{ 12688, 12689 },
-	{ 12694, 12703 },
-	{ 12736, 12771 },
-	{ 12800, 12830 },
-	{ 12842, 12871 },
-	{ 12880, 12880 },
-	{ 12896, 12927 },
-	{ 12938, 12976 },
-	{ 12992, 13054 },
-	{ 13056, 13311 },
-	{ 19904, 19967 },
-	{ 42128, 42182 },
-	{ 43048, 43051 },
-	{ 43062, 43063 },
-	{ 43065, 43065 },
-	{ 43639, 43641 },
-	{ 65021, 65021 },
-	{ 65508, 65508 },
-	{ 65512, 65512 },
-	{ 65517, 65518 },
-	{ 65532, 65533 },
-};
-static const URange32 So_range32[] = {
-	{ 65847, 65855 },
-	{ 65913, 65929 },
-	{ 65932, 65934 },
-	{ 65936, 65947 },
-	{ 65952, 65952 },
-	{ 66000, 66044 },
-	{ 67703, 67704 },
-	{ 68296, 68296 },
-	{ 71487, 71487 },
-	{ 92988, 92991 },
-	{ 92997, 92997 },
-	{ 113820, 113820 },
-	{ 118784, 119029 },
-	{ 119040, 119078 },
-	{ 119081, 119140 },
-	{ 119146, 119148 },
-	{ 119171, 119172 },
-	{ 119180, 119209 },
-	{ 119214, 119272 },
-	{ 119296, 119361 },
-	{ 119365, 119365 },
-	{ 119552, 119638 },
-	{ 120832, 121343 },
-	{ 121399, 121402 },
-	{ 121453, 121460 },
-	{ 121462, 121475 },
-	{ 121477, 121478 },
-	{ 126124, 126124 },
-	{ 126976, 127019 },
-	{ 127024, 127123 },
-	{ 127136, 127150 },
-	{ 127153, 127167 },
-	{ 127169, 127183 },
-	{ 127185, 127221 },
-	{ 127248, 127339 },
-	{ 127344, 127404 },
-	{ 127462, 127490 },
-	{ 127504, 127547 },
-	{ 127552, 127560 },
-	{ 127568, 127569 },
-	{ 127584, 127589 },
-	{ 127744, 127994 },
-	{ 128000, 128724 },
-	{ 128736, 128748 },
-	{ 128752, 128761 },
-	{ 128768, 128883 },
-	{ 128896, 128984 },
-	{ 129024, 129035 },
-	{ 129040, 129095 },
-	{ 129104, 129113 },
-	{ 129120, 129159 },
-	{ 129168, 129197 },
-	{ 129280, 129291 },
-	{ 129296, 129342 },
-	{ 129344, 129392 },
-	{ 129395, 129398 },
-	{ 129402, 129402 },
-	{ 129404, 129442 },
-	{ 129456, 129465 },
-	{ 129472, 129474 },
-	{ 129488, 129535 },
-	{ 129632, 129645 },
-};
-static const URange16 Sm_range16[] = {
-	{ 43, 43 },
-	{ 60, 62 },
-	{ 124, 124 },
-	{ 126, 126 },
-	{ 172, 172 },
-	{ 177, 177 },
-	{ 215, 215 },
-	{ 247, 247 },
-	{ 1014, 1014 },
-	{ 1542, 1544 },
-	{ 8260, 8260 },
-	{ 8274, 8274 },
-	{ 8314, 8316 },
-	{ 8330, 8332 },
-	{ 8472, 8472 },
-	{ 8512, 8516 },
-	{ 8523, 8523 },
-	{ 8592, 8596 },
-	{ 8602, 8603 },
-	{ 8608, 8608 },
-	{ 8611, 8611 },
-	{ 8614, 8614 },
-	{ 8622, 8622 },
-	{ 8654, 8655 },
-	{ 8658, 8658 },
-	{ 8660, 8660 },
-	{ 8692, 8959 },
-	{ 8992, 8993 },
-	{ 9084, 9084 },
-	{ 9115, 9139 },
-	{ 9180, 9185 },
-	{ 9655, 9655 },
-	{ 9665, 9665 },
-	{ 9720, 9727 },
-	{ 9839, 9839 },
-	{ 10176, 10180 },
-	{ 10183, 10213 },
-	{ 10224, 10239 },
-	{ 10496, 10626 },
-	{ 10649, 10711 },
-	{ 10716, 10747 },
-	{ 10750, 11007 },
-	{ 11056, 11076 },
-	{ 11079, 11084 },
-	{ 64297, 64297 },
-	{ 65122, 65122 },
-	{ 65124, 65126 },
-	{ 65291, 65291 },
-	{ 65308, 65310 },
-	{ 65372, 65372 },
-	{ 65374, 65374 },
-	{ 65506, 65506 },
-	{ 65513, 65516 },
-};
-static const URange32 Sm_range32[] = {
-	{ 120513, 120513 },
-	{ 120539, 120539 },
-	{ 120571, 120571 },
-	{ 120597, 120597 },
-	{ 120629, 120629 },
-	{ 120655, 120655 },
-	{ 120687, 120687 },
-	{ 120713, 120713 },
-	{ 120745, 120745 },
-	{ 120771, 120771 },
-	{ 126704, 126705 },
-};
-static const URange16 Sc_range16[] = {
-	{ 36, 36 },
-	{ 162, 165 },
-	{ 1423, 1423 },
-	{ 1547, 1547 },
-	{ 2046, 2047 },
-	{ 2546, 2547 },
-	{ 2555, 2555 },
-	{ 2801, 2801 },
-	{ 3065, 3065 },
-	{ 3647, 3647 },
-	{ 6107, 6107 },
-	{ 8352, 8383 },
-	{ 43064, 43064 },
-	{ 65020, 65020 },
-	{ 65129, 65129 },
-	{ 65284, 65284 },
-	{ 65504, 65505 },
-	{ 65509, 65510 },
-};
-static const URange32 Sc_range32[] = {
-	{ 126128, 126128 },
-};
-static const URange16 Z_range16[] = {
-	{ 32, 32 },
-	{ 160, 160 },
-	{ 5760, 5760 },
-	{ 8192, 8202 },
-	{ 8232, 8233 },
-	{ 8239, 8239 },
-	{ 8287, 8287 },
-	{ 12288, 12288 },
-};
-static const URange16 Zl_range16[] = {
-	{ 8232, 8232 },
-};
-static const URange16 Co_range16[] = {
-	{ 57344, 63743 },
-};
-static const URange32 Co_range32[] = {
-	{ 983040, 1048573 },
-	{ 1048576, 1114109 },
-};
-static const URange16 Cc_range16[] = {
-	{ 0, 31 },
-	{ 127, 159 },
-};
-static const URange16 Cf_range16[] = {
-	{ 173, 173 },
-	{ 1536, 1541 },
-	{ 1564, 1564 },
-	{ 1757, 1757 },
-	{ 1807, 1807 },
-	{ 2274, 2274 },
-	{ 6158, 6158 },
-	{ 8203, 8207 },
-	{ 8234, 8238 },
-	{ 8288, 8292 },
-	{ 8294, 8303 },
-	{ 65279, 65279 },
-	{ 65529, 65531 },
-};
-static const URange32 Cf_range32[] = {
-	{ 69821, 69821 },
-	{ 69837, 69837 },
-	{ 113824, 113827 },
-	{ 119155, 119162 },
-	{ 917505, 917505 },
-	{ 917536, 917631 },
-};
-static const URange16 Cs_range16[] = {
-	{ 55296, 57343 },
-};
-static const URange16 Zp_range16[] = {
-	{ 8233, 8233 },
-};
-static const URange16 Zs_range16[] = {
-	{ 32, 32 },
-	{ 160, 160 },
-	{ 5760, 5760 },
-	{ 8192, 8202 },
-	{ 8239, 8239 },
-	{ 8287, 8287 },
-	{ 12288, 12288 },
-};
-static const URange32 Tangut_range32[] = {
-	{ 94176, 94176 },
-	{ 94208, 100337 },
-	{ 100352, 101106 },
-};
-static const URange16 Thaana_range16[] = {
-	{ 1920, 1969 },
-};
-static const URange32 Adlam_range32[] = {
-	{ 125184, 125258 },
-	{ 125264, 125273 },
-	{ 125278, 125279 },
-};
-static const URange16 Telugu_range16[] = {
-	{ 3072, 3084 },
-	{ 3086, 3088 },
-	{ 3090, 3112 },
-	{ 3114, 3129 },
-	{ 3133, 3140 },
-	{ 3142, 3144 },
-	{ 3146, 3149 },
-	{ 3157, 3158 },
-	{ 3160, 3162 },
-	{ 3168, 3171 },
-	{ 3174, 3183 },
-	{ 3192, 3199 },
-};
-static const URange16 Cyrillic_range16[] = {
-	{ 1024, 1156 },
-	{ 1159, 1327 },
-	{ 7296, 7304 },
-	{ 7467, 7467 },
-	{ 7544, 7544 },
-	{ 11744, 11775 },
-	{ 42560, 42655 },
-	{ 65070, 65071 },
-};
-static const URange32 Zanabazar_Square_range32[] = {
-	{ 72192, 72263 },
-};
-static const URange16 Hangul_range16[] = {
-	{ 4352, 4607 },
-	{ 12334, 12335 },
-	{ 12593, 12686 },
-	{ 12800, 12830 },
-	{ 12896, 12926 },
-	{ 43360, 43388 },
-	{ 44032, 55203 },
-	{ 55216, 55238 },
-	{ 55243, 55291 },
-	{ 65440, 65470 },
-	{ 65474, 65479 },
-	{ 65482, 65487 },
-	{ 65490, 65495 },
-	{ 65498, 65500 },
-};
-static const URange32 Old_South_Arabian_range32[] = {
-	{ 68192, 68223 },
-};
-static const URange16 Ethiopic_range16[] = {
-	{ 4608, 4680 },
-	{ 4682, 4685 },
-	{ 4688, 4694 },
-	{ 4696, 4696 },
-	{ 4698, 4701 },
-	{ 4704, 4744 },
-	{ 4746, 4749 },
-	{ 4752, 4784 },
-	{ 4786, 4789 },
-	{ 4792, 4798 },
-	{ 4800, 4800 },
-	{ 4802, 4805 },
-	{ 4808, 4822 },
-	{ 4824, 4880 },
-	{ 4882, 4885 },
-	{ 4888, 4954 },
-	{ 4957, 4988 },
-	{ 4992, 5017 },
-	{ 11648, 11670 },
-	{ 11680, 11686 },
-	{ 11688, 11694 },
-	{ 11696, 11702 },
-	{ 11704, 11710 },
-	{ 11712, 11718 },
-	{ 11720, 11726 },
-	{ 11728, 11734 },
-	{ 11736, 11742 },
-	{ 43777, 43782 },
-	{ 43785, 43790 },
-	{ 43793, 43798 },
-	{ 43808, 43814 },
-	{ 43816, 43822 },
-};
-static const URange16 Inherited_range16[] = {
-	{ 768, 879 },
-	{ 1157, 1158 },
-	{ 1611, 1621 },
-	{ 1648, 1648 },
-	{ 2385, 2386 },
-	{ 6832, 6846 },
-	{ 7376, 7378 },
-	{ 7380, 7392 },
-	{ 7394, 7400 },
-	{ 7405, 7405 },
-	{ 7412, 7412 },
-	{ 7416, 7417 },
-	{ 7616, 7673 },
-	{ 7675, 7679 },
-	{ 8204, 8205 },
-	{ 8400, 8432 },
-	{ 12330, 12333 },
-	{ 12441, 12442 },
-	{ 65024, 65039 },
-	{ 65056, 65069 },
-};
-static const URange32 Inherited_range32[] = {
-	{ 66045, 66045 },
-	{ 66272, 66272 },
-	{ 70459, 70459 },
-	{ 119143, 119145 },
-	{ 119163, 119170 },
-	{ 119173, 119179 },
-	{ 119210, 119213 },
-	{ 917760, 917999 },
-};
-static const URange32 Meroitic_Cursive_range32[] = {
-	{ 68000, 68023 },
-	{ 68028, 68047 },
-	{ 68050, 68095 },
-};
-static const URange32 Bhaiksuki_range32[] = {
-	{ 72704, 72712 },
-	{ 72714, 72758 },
-	{ 72760, 72773 },
-	{ 72784, 72812 },
-};
-static const URange32 Ahom_range32[] = {
-	{ 71424, 71450 },
-	{ 71453, 71467 },
-	{ 71472, 71487 },
-};
-static const URange16 Han_range16[] = {
-	{ 11904, 11929 },
-	{ 11931, 12019 },
-	{ 12032, 12245 },
-	{ 12293, 12293 },
-	{ 12295, 12295 },
-	{ 12321, 12329 },
-	{ 12344, 12347 },
-	{ 13312, 19893 },
-	{ 19968, 40943 },
-	{ 63744, 64109 },
-	{ 64112, 64217 },
-};
-static const URange32 Han_range32[] = {
-	{ 131072, 173782 },
-	{ 173824, 177972 },
-	{ 177984, 178205 },
-	{ 178208, 183969 },
-	{ 183984, 191456 },
-	{ 194560, 195101 },
-};
-static const URange32 Old_North_Arabian_range32[] = {
-	{ 68224, 68255 },
-};
-static const URange16 Armenian_range16[] = {
-	{ 1329, 1366 },
-	{ 1369, 1416 },
-	{ 1418, 1418 },
-	{ 1421, 1423 },
-	{ 64275, 64279 },
-};
-static const URange16 Tamil_range16[] = {
-	{ 2946, 2947 },
-	{ 2949, 2954 },
-	{ 2958, 2960 },
-	{ 2962, 2965 },
-	{ 2969, 2970 },
-	{ 2972, 2972 },
-	{ 2974, 2975 },
-	{ 2979, 2980 },
-	{ 2984, 2986 },
-	{ 2990, 3001 },
-	{ 3006, 3010 },
-	{ 3014, 3016 },
-	{ 3018, 3021 },
-	{ 3024, 3024 },
-	{ 3031, 3031 },
-	{ 3046, 3066 },
-};
-static const URange16 Bopomofo_range16[] = {
-	{ 746, 747 },
-	{ 12549, 12591 },
-	{ 12704, 12730 },
-};
-static const URange32 Bassa_Vah_range32[] = {
-	{ 92880, 92909 },
-	{ 92912, 92917 },
-};
-static const URange16 Sundanese_range16[] = {
-	{ 7040, 7103 },
-	{ 7360, 7367 },
-};
-static const URange32 Osage_range32[] = {
-	{ 66736, 66771 },
-	{ 66776, 66811 },
-};
-static const URange32 Old_Sogdian_range32[] = {
-	{ 69376, 69415 },
-};
-static const URange16 Tagalog_range16[] = {
-	{ 5888, 5900 },
-	{ 5902, 5908 },
-};
-static const URange16 Malayalam_range16[] = {
-	{ 3328, 3331 },
-	{ 3333, 3340 },
-	{ 3342, 3344 },
-	{ 3346, 3396 },
-	{ 3398, 3400 },
-	{ 3402, 3407 },
-	{ 3412, 3427 },
-	{ 3430, 3455 },
-};
-static const URange32 Marchen_range32[] = {
-	{ 72816, 72847 },
-	{ 72850, 72871 },
-	{ 72873, 72886 },
-};
-static const URange32 Carian_range32[] = {
-	{ 66208, 66256 },
-};
-static const URange16 Hiragana_range16[] = {
-	{ 12353, 12438 },
-	{ 12445, 12447 },
-};
-static const URange32 Hiragana_range32[] = {
-	{ 110593, 110878 },
-	{ 127488, 127488 },
-};
-static const URange16 Tagbanwa_range16[] = {
-	{ 5984, 5996 },
-	{ 5998, 6000 },
-	{ 6002, 6003 },
-};
-static const URange16 Meetei_Mayek_range16[] = {
-	{ 43744, 43766 },
-	{ 43968, 44013 },
-	{ 44016, 44025 },
-};
-static const URange32 Hanifi_Rohingya_range32[] = {
-	{ 68864, 68903 },
-	{ 68912, 68921 },
-};
-static const URange32 Pahawh_Hmong_range32[] = {
-	{ 92928, 92997 },
-	{ 93008, 93017 },
-	{ 93019, 93025 },
-	{ 93027, 93047 },
-	{ 93053, 93071 },
-};
-static const URange16 Tai_Le_range16[] = {
-	{ 6480, 6509 },
-	{ 6512, 6516 },
-};
-static const URange16 Kayah_Li_range16[] = {
-	{ 43264, 43309 },
-	{ 43311, 43311 },
-};
-static const URange16 Buginese_range16[] = {
-	{ 6656, 6683 },
-	{ 6686, 6687 },
-};
-static const URange32 Kharoshthi_range32[] = {
-	{ 68096, 68099 },
-	{ 68101, 68102 },
-	{ 68108, 68115 },
-	{ 68117, 68119 },
-	{ 68121, 68149 },
-	{ 68152, 68154 },
-	{ 68159, 68168 },
-	{ 68176, 68184 },
-};
-static const URange16 Tai_Tham_range16[] = {
-	{ 6688, 6750 },
-	{ 6752, 6780 },
-	{ 6783, 6793 },
-	{ 6800, 6809 },
-	{ 6816, 6829 },
-};
-static const URange32 Old_Italic_range32[] = {
-	{ 66304, 66339 },
-	{ 66349, 66351 },
-};
-static const URange32 Old_Persian_range32[] = {
-	{ 66464, 66499 },
-	{ 66504, 66517 },
-};
-static const URange32 Warang_Citi_range32[] = {
-	{ 71840, 71922 },
-	{ 71935, 71935 },
-};
-static const URange16 Latin_range16[] = {
-	{ 65, 90 },
-	{ 97, 122 },
-	{ 170, 170 },
-	{ 186, 186 },
-	{ 192, 214 },
-	{ 216, 246 },
-	{ 248, 696 },
-	{ 736, 740 },
-	{ 7424, 7461 },
-	{ 7468, 7516 },
-	{ 7522, 7525 },
-	{ 7531, 7543 },
-	{ 7545, 7614 },
-	{ 7680, 7935 },
-	{ 8305, 8305 },
-	{ 8319, 8319 },
-	{ 8336, 8348 },
-	{ 8490, 8491 },
-	{ 8498, 8498 },
-	{ 8526, 8526 },
-	{ 8544, 8584 },
-	{ 11360, 11391 },
-	{ 42786, 42887 },
-	{ 42891, 42937 },
-	{ 42999, 43007 },
-	{ 43824, 43866 },
-	{ 43868, 43876 },
-	{ 64256, 64262 },
-	{ 65313, 65338 },
-	{ 65345, 65370 },
-};
-static const URange16 Saurashtra_range16[] = {
-	{ 43136, 43205 },
-	{ 43214, 43225 },
-};
-static const URange32 Shavian_range32[] = {
-	{ 66640, 66687 },
-};
-static const URange16 Georgian_range16[] = {
-	{ 4256, 4293 },
-	{ 4295, 4295 },
-	{ 4301, 4301 },
-	{ 4304, 4346 },
-	{ 4348, 4351 },
-	{ 7312, 7354 },
-	{ 7357, 7359 },
-	{ 11520, 11557 },
-	{ 11559, 11559 },
-	{ 11565, 11565 },
-};
-static const URange32 Grantha_range32[] = {
-	{ 70400, 70403 },
-	{ 70405, 70412 },
-	{ 70415, 70416 },
-	{ 70419, 70440 },
-	{ 70442, 70448 },
-	{ 70450, 70451 },
-	{ 70453, 70457 },
-	{ 70460, 70468 },
-	{ 70471, 70472 },
-	{ 70475, 70477 },
-	{ 70480, 70480 },
-	{ 70487, 70487 },
-	{ 70493, 70499 },
-	{ 70502, 70508 },
-	{ 70512, 70516 },
-};
-static const URange32 Duployan_range32[] = {
-	{ 113664, 113770 },
-	{ 113776, 113788 },
-	{ 113792, 113800 },
-	{ 113808, 113817 },
-	{ 113820, 113823 },
-};
-static const URange16 Batak_range16[] = {
-	{ 7104, 7155 },
-	{ 7164, 7167 },
-};
-static const URange16 Devanagari_range16[] = {
-	{ 2304, 2384 },
-	{ 2387, 2403 },
-	{ 2406, 2431 },
-	{ 43232, 43263 },
-};
-static const URange16 Thai_range16[] = {
-	{ 3585, 3642 },
-	{ 3648, 3675 },
-};
-static const URange16 Tibetan_range16[] = {
-	{ 3840, 3911 },
-	{ 3913, 3948 },
-	{ 3953, 3991 },
-	{ 3993, 4028 },
-	{ 4030, 4044 },
-	{ 4046, 4052 },
-	{ 4057, 4058 },
-};
-static const URange16 Tifinagh_range16[] = {
-	{ 11568, 11623 },
-	{ 11631, 11632 },
-	{ 11647, 11647 },
-};
-static const URange32 Ugaritic_range32[] = {
-	{ 66432, 66461 },
-	{ 66463, 66463 },
-};
-static const URange16 Braille_range16[] = {
-	{ 10240, 10495 },
-};
-static const URange32 Anatolian_Hieroglyphs_range32[] = {
-	{ 82944, 83526 },
-};
-static const URange16 Greek_range16[] = {
-	{ 880, 883 },
-	{ 885, 887 },
-	{ 890, 893 },
-	{ 895, 895 },
-	{ 900, 900 },
-	{ 902, 902 },
-	{ 904, 906 },
-	{ 908, 908 },
-	{ 910, 929 },
-	{ 931, 993 },
-	{ 1008, 1023 },
-	{ 7462, 7466 },
-	{ 7517, 7521 },
-	{ 7526, 7530 },
-	{ 7615, 7615 },
-	{ 7936, 7957 },
-	{ 7960, 7965 },
-	{ 7968, 8005 },
-	{ 8008, 8013 },
-	{ 8016, 8023 },
-	{ 8025, 8025 },
-	{ 8027, 8027 },
-	{ 8029, 8029 },
-	{ 8031, 8061 },
-	{ 8064, 8116 },
-	{ 8118, 8132 },
-	{ 8134, 8147 },
-	{ 8150, 8155 },
-	{ 8157, 8175 },
-	{ 8178, 8180 },
-	{ 8182, 8190 },
-	{ 8486, 8486 },
-	{ 43877, 43877 },
-};
-static const URange32 Greek_range32[] = {
-	{ 65856, 65934 },
-	{ 65952, 65952 },
-	{ 119296, 119365 },
-};
-static const URange32 Lycian_range32[] = {
-	{ 66176, 66204 },
-};
-static const URange32 Mende_Kikakui_range32[] = {
-	{ 124928, 125124 },
-	{ 125127, 125142 },
-};
-static const URange16 Tai_Viet_range16[] = {
-	{ 43648, 43714 },
-	{ 43739, 43743 },
-};
-static const URange16 Vai_range16[] = {
-	{ 42240, 42539 },
-};
-static const URange16 Ogham_range16[] = {
-	{ 5760, 5788 },
-};
-static const URange32 Inscriptional_Parthian_range32[] = {
-	{ 68416, 68437 },
-	{ 68440, 68447 },
-};
-static const URange16 Cham_range16[] = {
-	{ 43520, 43574 },
-	{ 43584, 43597 },
-	{ 43600, 43609 },
-	{ 43612, 43615 },
-};
-static const URange16 Syriac_range16[] = {
-	{ 1792, 1805 },
-	{ 1807, 1866 },
-	{ 1869, 1871 },
-	{ 2144, 2154 },
-};
-static const URange16 Runic_range16[] = {
-	{ 5792, 5866 },
-	{ 5870, 5880 },
-};
-static const URange32 Gothic_range32[] = {
-	{ 66352, 66378 },
-};
-static const URange32 Mahajani_range32[] = {
-	{ 69968, 70006 },
-};
-static const URange16 Katakana_range16[] = {
-	{ 12449, 12538 },
-	{ 12541, 12543 },
-	{ 12784, 12799 },
-	{ 13008, 13054 },
-	{ 13056, 13143 },
-	{ 65382, 65391 },
-	{ 65393, 65437 },
-};
-static const URange32 Katakana_range32[] = {
-	{ 110592, 110592 },
-};
-static const URange32 Osmanya_range32[] = {
-	{ 66688, 66717 },
-	{ 66720, 66729 },
-};
-static const URange16 New_Tai_Lue_range16[] = {
-	{ 6528, 6571 },
-	{ 6576, 6601 },
-	{ 6608, 6618 },
-	{ 6622, 6623 },
-};
-static const URange16 Ol_Chiki_range16[] = {
-	{ 7248, 7295 },
-};
-static const URange32 Newa_range32[] = {
-	{ 70656, 70745 },
-	{ 70747, 70747 },
-	{ 70749, 70750 },
-};
-static const URange16 Limbu_range16[] = {
-	{ 6400, 6430 },
-	{ 6432, 6443 },
-	{ 6448, 6459 },
-	{ 6464, 6464 },
-	{ 6468, 6479 },
-};
-static const URange32 Pau_Cin_Hau_range32[] = {
-	{ 72384, 72440 },
-};
-static const URange16 Cherokee_range16[] = {
-	{ 5024, 5109 },
-	{ 5112, 5117 },
-	{ 43888, 43967 },
-};
-static const URange32 Miao_range32[] = {
-	{ 93952, 94020 },
-	{ 94032, 94078 },
-	{ 94095, 94111 },
-};
-static const URange16 Oriya_range16[] = {
-	{ 2817, 2819 },
-	{ 2821, 2828 },
-	{ 2831, 2832 },
-	{ 2835, 2856 },
-	{ 2858, 2864 },
-	{ 2866, 2867 },
-	{ 2869, 2873 },
-	{ 2876, 2884 },
-	{ 2887, 2888 },
-	{ 2891, 2893 },
-	{ 2902, 2903 },
-	{ 2908, 2909 },
-	{ 2911, 2915 },
-	{ 2918, 2935 },
-};
-static const URange32 Medefaidrin_range32[] = {
-	{ 93760, 93850 },
-};
-static const URange32 Sharada_range32[] = {
-	{ 70016, 70093 },
-	{ 70096, 70111 },
-};
-static const URange16 Gujarati_range16[] = {
-	{ 2689, 2691 },
-	{ 2693, 2701 },
-	{ 2703, 2705 },
-	{ 2707, 2728 },
-	{ 2730, 2736 },
-	{ 2738, 2739 },
-	{ 2741, 2745 },
-	{ 2748, 2757 },
-	{ 2759, 2761 },
-	{ 2763, 2765 },
-	{ 2768, 2768 },
-	{ 2784, 2787 },
-	{ 2790, 2801 },
-	{ 2809, 2815 },
-};
-static const URange32 Nushu_range32[] = {
-	{ 94177, 94177 },
-	{ 110960, 111355 },
-};
-static const URange32 Modi_range32[] = {
-	{ 71168, 71236 },
-	{ 71248, 71257 },
-};
-static const URange32 Gunjala_Gondi_range32[] = {
-	{ 73056, 73061 },
-	{ 73063, 73064 },
-	{ 73066, 73102 },
-	{ 73104, 73105 },
-	{ 73107, 73112 },
-	{ 73120, 73129 },
-};
-static const URange32 Inscriptional_Pahlavi_range32[] = {
-	{ 68448, 68466 },
-	{ 68472, 68479 },
-};
-static const URange32 Manichaean_range32[] = {
-	{ 68288, 68326 },
-	{ 68331, 68342 },
-};
-static const URange16 Khmer_range16[] = {
-	{ 6016, 6109 },
-	{ 6112, 6121 },
-	{ 6128, 6137 },
-	{ 6624, 6655 },
-};
-static const URange32 Cuneiform_range32[] = {
-	{ 73728, 74649 },
-	{ 74752, 74862 },
-	{ 74864, 74868 },
-	{ 74880, 75075 },
-};
-static const URange32 Khudawadi_range32[] = {
-	{ 70320, 70378 },
-	{ 70384, 70393 },
-};
-static const URange16 Mandaic_range16[] = {
-	{ 2112, 2139 },
-	{ 2142, 2142 },
-};
-static const URange32 Hatran_range32[] = {
-	{ 67808, 67826 },
-	{ 67828, 67829 },
-	{ 67835, 67839 },
-};
-static const URange16 Syloti_Nagri_range16[] = {
-	{ 43008, 43051 },
-};
-static const URange16 Nko_range16[] = {
-	{ 1984, 2042 },
-	{ 2045, 2047 },
-};
-static const URange16 Canadian_Aboriginal_range16[] = {
-	{ 5120, 5759 },
-	{ 6320, 6389 },
-};
-static const URange32 Meroitic_Hieroglyphs_range32[] = {
-	{ 67968, 67999 },
-};
-static const URange32 Phoenician_range32[] = {
-	{ 67840, 67867 },
-	{ 67871, 67871 },
-};
-static const URange32 Nabataean_range32[] = {
-	{ 67712, 67742 },
-	{ 67751, 67759 },
-};
-static const URange16 Bengali_range16[] = {
-	{ 2432, 2435 },
-	{ 2437, 2444 },
-	{ 2447, 2448 },
-	{ 2451, 2472 },
-	{ 2474, 2480 },
-	{ 2482, 2482 },
-	{ 2486, 2489 },
-	{ 2492, 2500 },
-	{ 2503, 2504 },
-	{ 2507, 2510 },
-	{ 2519, 2519 },
-	{ 2524, 2525 },
-	{ 2527, 2531 },
-	{ 2534, 2558 },
-};
-static const URange32 Kaithi_range32[] = {
-	{ 69760, 69825 },
-	{ 69837, 69837 },
-};
-static const URange16 Glagolitic_range16[] = {
-	{ 11264, 11310 },
-	{ 11312, 11358 },
-};
-static const URange32 Glagolitic_range32[] = {
-	{ 122880, 122886 },
-	{ 122888, 122904 },
-	{ 122907, 122913 },
-	{ 122915, 122916 },
-	{ 122918, 122922 },
-};
-static const URange32 Imperial_Aramaic_range32[] = {
-	{ 67648, 67669 },
-	{ 67671, 67679 },
-};
-static const URange32 Sora_Sompeng_range32[] = {
-	{ 69840, 69864 },
-	{ 69872, 69881 },
-};
-static const URange16 Gurmukhi_range16[] = {
-	{ 2561, 2563 },
-	{ 2565, 2570 },
-	{ 2575, 2576 },
-	{ 2579, 2600 },
-	{ 2602, 2608 },
-	{ 2610, 2611 },
-	{ 2613, 2614 },
-	{ 2616, 2617 },
-	{ 2620, 2620 },
-	{ 2622, 2626 },
-	{ 2631, 2632 },
-	{ 2635, 2637 },
-	{ 2641, 2641 },
-	{ 2649, 2652 },
-	{ 2654, 2654 },
-	{ 2662, 2678 },
-};
-static const URange16 Javanese_range16[] = {
-	{ 43392, 43469 },
-	{ 43472, 43481 },
-	{ 43486, 43487 },
-};
-static const URange32 Old_Permic_range32[] = {
-	{ 66384, 66426 },
-};
-static const URange16 Phags_Pa_range16[] = {
-	{ 43072, 43127 },
-};
-static const URange32 Cypriot_range32[] = {
-	{ 67584, 67589 },
-	{ 67592, 67592 },
-	{ 67594, 67637 },
-	{ 67639, 67640 },
-	{ 67644, 67644 },
-	{ 67647, 67647 },
-};
-static const URange16 Kannada_range16[] = {
-	{ 3200, 3212 },
-	{ 3214, 3216 },
-	{ 3218, 3240 },
-	{ 3242, 3251 },
-	{ 3253, 3257 },
-	{ 3260, 3268 },
-	{ 3270, 3272 },
-	{ 3274, 3277 },
-	{ 3285, 3286 },
-	{ 3294, 3294 },
-	{ 3296, 3299 },
-	{ 3302, 3311 },
-	{ 3313, 3314 },
-};
-static const URange32 Khojki_range32[] = {
-	{ 70144, 70161 },
-	{ 70163, 70206 },
-};
-static const URange16 Mongolian_range16[] = {
-	{ 6144, 6145 },
-	{ 6148, 6148 },
-	{ 6150, 6158 },
-	{ 6160, 6169 },
-	{ 6176, 6264 },
-	{ 6272, 6314 },
-};
-static const URange32 Mongolian_range32[] = {
-	{ 71264, 71276 },
-};
-static const URange16 Sinhala_range16[] = {
-	{ 3458, 3459 },
-	{ 3461, 3478 },
-	{ 3482, 3505 },
-	{ 3507, 3515 },
-	{ 3517, 3517 },
-	{ 3520, 3526 },
-	{ 3530, 3530 },
-	{ 3535, 3540 },
-	{ 3542, 3542 },
-	{ 3544, 3551 },
-	{ 3558, 3567 },
-	{ 3570, 3572 },
-};
-static const URange32 Sinhala_range32[] = {
-	{ 70113, 70132 },
-};
-static const URange32 Brahmi_range32[] = {
-	{ 69632, 69709 },
-	{ 69714, 69743 },
-	{ 69759, 69759 },
-};
-static const URange32 Elbasan_range32[] = {
-	{ 66816, 66855 },
-};
-static const URange32 Deseret_range32[] = {
-	{ 66560, 66639 },
-};
-static const URange16 Rejang_range16[] = {
-	{ 43312, 43347 },
-	{ 43359, 43359 },
-};
-static const URange32 SignWriting_range32[] = {
-	{ 120832, 121483 },
-	{ 121499, 121503 },
-	{ 121505, 121519 },
-};
-static const URange32 Multani_range32[] = {
-	{ 70272, 70278 },
-	{ 70280, 70280 },
-	{ 70282, 70285 },
-	{ 70287, 70301 },
-	{ 70303, 70313 },
-};
-static const URange16 Yi_range16[] = {
-	{ 40960, 42124 },
-	{ 42128, 42182 },
-};
-static const URange16 Balinese_range16[] = {
-	{ 6912, 6987 },
-	{ 6992, 7036 },
-};
-static const URange16 Lao_range16[] = {
-	{ 3713, 3714 },
-	{ 3716, 3716 },
-	{ 3719, 3720 },
-	{ 3722, 3722 },
-	{ 3725, 3725 },
-	{ 3732, 3735 },
-	{ 3737, 3743 },
-	{ 3745, 3747 },
-	{ 3749, 3749 },
-	{ 3751, 3751 },
-	{ 3754, 3755 },
-	{ 3757, 3769 },
-	{ 3771, 3773 },
-	{ 3776, 3780 },
-	{ 3782, 3782 },
-	{ 3784, 3789 },
-	{ 3792, 3801 },
-	{ 3804, 3807 },
-};
-static const URange16 Hanunoo_range16[] = {
-	{ 5920, 5940 },
-};
-static const URange32 Masaram_Gondi_range32[] = {
-	{ 72960, 72966 },
-	{ 72968, 72969 },
-	{ 72971, 73014 },
-	{ 73018, 73018 },
-	{ 73020, 73021 },
-	{ 73023, 73031 },
-	{ 73040, 73049 },
-};
-static const URange32 Linear_B_range32[] = {
-	{ 65536, 65547 },
-	{ 65549, 65574 },
-	{ 65576, 65594 },
-	{ 65596, 65597 },
-	{ 65599, 65613 },
-	{ 65616, 65629 },
-	{ 65664, 65786 },
-};
-static const URange32 Linear_A_range32[] = {
-	{ 67072, 67382 },
-	{ 67392, 67413 },
-	{ 67424, 67431 },
-};
-static const URange32 Dogra_range32[] = {
-	{ 71680, 71739 },
-};
-static const URange32 Old_Turkic_range32[] = {
-	{ 68608, 68680 },
-};
-static const URange16 Lepcha_range16[] = {
-	{ 7168, 7223 },
-	{ 7227, 7241 },
-	{ 7245, 7247 },
-};
-static const URange32 Lydian_range32[] = {
-	{ 67872, 67897 },
-	{ 67903, 67903 },
-};
-static const URange32 Egyptian_Hieroglyphs_range32[] = {
-	{ 77824, 78894 },
-};
-static const URange32 Sogdian_range32[] = {
-	{ 69424, 69465 },
-};
-static const URange32 Caucasian_Albanian_range32[] = {
-	{ 66864, 66915 },
-	{ 66927, 66927 },
-};
-static const URange32 Makasar_range32[] = {
-	{ 73440, 73464 },
-};
-static const URange32 Old_Hungarian_range32[] = {
-	{ 68736, 68786 },
-	{ 68800, 68850 },
-	{ 68858, 68863 },
-};
-static const URange16 Samaritan_range16[] = {
-	{ 2048, 2093 },
-	{ 2096, 2110 },
-};
-static const URange16 Lisu_range16[] = {
-	{ 42192, 42239 },
-};
-static const URange16 Buhid_range16[] = {
-	{ 5952, 5971 },
-};
-static const URange32 Palmyrene_range32[] = {
-	{ 67680, 67711 },
-};
-static const URange32 Tirhuta_range32[] = {
-	{ 70784, 70855 },
-	{ 70864, 70873 },
-};
-static const URange32 Mro_range32[] = {
-	{ 92736, 92766 },
-	{ 92768, 92777 },
-	{ 92782, 92783 },
-};
-static const URange16 Common_range16[] = {
-	{ 0, 64 },
-	{ 91, 96 },
-	{ 123, 169 },
-	{ 171, 185 },
-	{ 187, 191 },
-	{ 215, 215 },
-	{ 247, 247 },
-	{ 697, 735 },
-	{ 741, 745 },
-	{ 748, 767 },
-	{ 884, 884 },
-	{ 894, 894 },
-	{ 901, 901 },
-	{ 903, 903 },
-	{ 1417, 1417 },
-	{ 1541, 1541 },
-	{ 1548, 1548 },
-	{ 1563, 1563 },
-	{ 1567, 1567 },
-	{ 1600, 1600 },
-	{ 1757, 1757 },
-	{ 2274, 2274 },
-	{ 2404, 2405 },
-	{ 3647, 3647 },
-	{ 4053, 4056 },
-	{ 4347, 4347 },
-	{ 5867, 5869 },
-	{ 5941, 5942 },
-	{ 6146, 6147 },
-	{ 6149, 6149 },
-	{ 7379, 7379 },
-	{ 7393, 7393 },
-	{ 7401, 7404 },
-	{ 7406, 7411 },
-	{ 7413, 7415 },
-	{ 8192, 8203 },
-	{ 8206, 8292 },
-	{ 8294, 8304 },
-	{ 8308, 8318 },
-	{ 8320, 8334 },
-	{ 8352, 8383 },
-	{ 8448, 8485 },
-	{ 8487, 8489 },
-	{ 8492, 8497 },
-	{ 8499, 8525 },
-	{ 8527, 8543 },
-	{ 8585, 8587 },
-	{ 8592, 9254 },
-	{ 9280, 9290 },
-	{ 9312, 10239 },
-	{ 10496, 11123 },
-	{ 11126, 11157 },
-	{ 11160, 11208 },
-	{ 11210, 11262 },
-	{ 11776, 11854 },
-	{ 12272, 12283 },
-	{ 12288, 12292 },
-	{ 12294, 12294 },
-	{ 12296, 12320 },
-	{ 12336, 12343 },
-	{ 12348, 12351 },
-	{ 12443, 12444 },
-	{ 12448, 12448 },
-	{ 12539, 12540 },
-	{ 12688, 12703 },
-	{ 12736, 12771 },
-	{ 12832, 12895 },
-	{ 12927, 13007 },
-	{ 13144, 13311 },
-	{ 19904, 19967 },
-	{ 42752, 42785 },
-	{ 42888, 42890 },
-	{ 43056, 43065 },
-	{ 43310, 43310 },
-	{ 43471, 43471 },
-	{ 43867, 43867 },
-	{ 64830, 64831 },
-	{ 65040, 65049 },
-	{ 65072, 65106 },
-	{ 65108, 65126 },
-	{ 65128, 65131 },
-	{ 65279, 65279 },
-	{ 65281, 65312 },
-	{ 65339, 65344 },
-	{ 65371, 65381 },
-	{ 65392, 65392 },
-	{ 65438, 65439 },
-	{ 65504, 65510 },
-	{ 65512, 65518 },
-	{ 65529, 65533 },
-};
-static const URange32 Common_range32[] = {
-	{ 65792, 65794 },
-	{ 65799, 65843 },
-	{ 65847, 65855 },
-	{ 65936, 65947 },
-	{ 66000, 66044 },
-	{ 66273, 66299 },
-	{ 113824, 113827 },
-	{ 118784, 119029 },
-	{ 119040, 119078 },
-	{ 119081, 119142 },
-	{ 119146, 119162 },
-	{ 119171, 119172 },
-	{ 119180, 119209 },
-	{ 119214, 119272 },
-	{ 119520, 119539 },
-	{ 119552, 119638 },
-	{ 119648, 119672 },
-	{ 119808, 119892 },
-	{ 119894, 119964 },
-	{ 119966, 119967 },
-	{ 119970, 119970 },
-	{ 119973, 119974 },
-	{ 119977, 119980 },
-	{ 119982, 119993 },
-	{ 119995, 119995 },
-	{ 119997, 120003 },
-	{ 120005, 120069 },
-	{ 120071, 120074 },
-	{ 120077, 120084 },
-	{ 120086, 120092 },
-	{ 120094, 120121 },
-	{ 120123, 120126 },
-	{ 120128, 120132 },
-	{ 120134, 120134 },
-	{ 120138, 120144 },
-	{ 120146, 120485 },
-	{ 120488, 120779 },
-	{ 120782, 120831 },
-	{ 126065, 126132 },
-	{ 126976, 127019 },
-	{ 127024, 127123 },
-	{ 127136, 127150 },
-	{ 127153, 127167 },
-	{ 127169, 127183 },
-	{ 127185, 127221 },
-	{ 127232, 127244 },
-	{ 127248, 127339 },
-	{ 127344, 127404 },
-	{ 127462, 127487 },
-	{ 127489, 127490 },
-	{ 127504, 127547 },
-	{ 127552, 127560 },
-	{ 127568, 127569 },
-	{ 127584, 127589 },
-	{ 127744, 128724 },
-	{ 128736, 128748 },
-	{ 128752, 128761 },
-	{ 128768, 128883 },
-	{ 128896, 128984 },
-	{ 129024, 129035 },
-	{ 129040, 129095 },
-	{ 129104, 129113 },
-	{ 129120, 129159 },
-	{ 129168, 129197 },
-	{ 129280, 129291 },
-	{ 129296, 129342 },
-	{ 129344, 129392 },
-	{ 129395, 129398 },
-	{ 129402, 129402 },
-	{ 129404, 129442 },
-	{ 129456, 129465 },
-	{ 129472, 129474 },
-	{ 129488, 129535 },
-	{ 129632, 129645 },
-	{ 917505, 917505 },
-	{ 917536, 917631 },
-};
-static const URange16 Coptic_range16[] = {
-	{ 994, 1007 },
-	{ 11392, 11507 },
-	{ 11513, 11519 },
-};
-static const URange32 Chakma_range32[] = {
-	{ 69888, 69940 },
-	{ 69942, 69958 },
-};
-static const URange16 Arabic_range16[] = {
-	{ 1536, 1540 },
-	{ 1542, 1547 },
-	{ 1549, 1562 },
-	{ 1564, 1564 },
-	{ 1566, 1566 },
-	{ 1568, 1599 },
-	{ 1601, 1610 },
-	{ 1622, 1647 },
-	{ 1649, 1756 },
-	{ 1758, 1791 },
-	{ 1872, 1919 },
-	{ 2208, 2228 },
-	{ 2230, 2237 },
-	{ 2259, 2273 },
-	{ 2275, 2303 },
-	{ 64336, 64449 },
-	{ 64467, 64829 },
-	{ 64848, 64911 },
-	{ 64914, 64967 },
-	{ 65008, 65021 },
-	{ 65136, 65140 },
-	{ 65142, 65276 },
-};
-static const URange32 Arabic_range32[] = {
-	{ 69216, 69246 },
-	{ 126464, 126467 },
-	{ 126469, 126495 },
-	{ 126497, 126498 },
-	{ 126500, 126500 },
-	{ 126503, 126503 },
-	{ 126505, 126514 },
-	{ 126516, 126519 },
-	{ 126521, 126521 },
-	{ 126523, 126523 },
-	{ 126530, 126530 },
-	{ 126535, 126535 },
-	{ 126537, 126537 },
-	{ 126539, 126539 },
-	{ 126541, 126543 },
-	{ 126545, 126546 },
-	{ 126548, 126548 },
-	{ 126551, 126551 },
-	{ 126553, 126553 },
-	{ 126555, 126555 },
-	{ 126557, 126557 },
-	{ 126559, 126559 },
-	{ 126561, 126562 },
-	{ 126564, 126564 },
-	{ 126567, 126570 },
-	{ 126572, 126578 },
-	{ 126580, 126583 },
-	{ 126585, 126588 },
-	{ 126590, 126590 },
-	{ 126592, 126601 },
-	{ 126603, 126619 },
-	{ 126625, 126627 },
-	{ 126629, 126633 },
-	{ 126635, 126651 },
-	{ 126704, 126705 },
-};
-static const URange16 Bamum_range16[] = {
-	{ 42656, 42743 },
-};
-static const URange32 Bamum_range32[] = {
-	{ 92160, 92728 },
-};
-static const URange16 Myanmar_range16[] = {
-	{ 4096, 4255 },
-	{ 43488, 43518 },
-	{ 43616, 43647 },
-};
-static const URange32 Siddham_range32[] = {
-	{ 71040, 71093 },
-	{ 71096, 71133 },
-};
-static const URange32 Soyombo_range32[] = {
-	{ 72272, 72323 },
-	{ 72326, 72354 },
-};
-static const URange32 Avestan_range32[] = {
-	{ 68352, 68405 },
-	{ 68409, 68415 },
-};
-static const URange16 Hebrew_range16[] = {
-	{ 1425, 1479 },
-	{ 1488, 1514 },
-	{ 1519, 1524 },
-	{ 64285, 64310 },
-	{ 64312, 64316 },
-	{ 64318, 64318 },
-	{ 64320, 64321 },
-	{ 64323, 64324 },
-	{ 64326, 64335 },
-};
-static const URange32 Psalter_Pahlavi_range32[] = {
-	{ 68480, 68497 },
-	{ 68505, 68508 },
-	{ 68521, 68527 },
-};
-static const URange32 Takri_range32[] = {
-	{ 71296, 71351 },
-	{ 71360, 71369 },
-};
-// 3994 16-bit ranges, 1429 32-bit ranges
-const UGroup unicode_groups[] = {
-	{ "Adlam", +1, 0, 0, Adlam_range32, 3 },
-	{ "Ahom", +1, 0, 0, Ahom_range32, 3 },
-	{ "Anatolian_Hieroglyphs", +1, 0, 0, Anatolian_Hieroglyphs_range32, 1 },
-	{ "Arabic", +1, Arabic_range16, 22, Arabic_range32, 35 },
-	{ "Armenian", +1, Armenian_range16, 5, 0, 0 },
-	{ "Avestan", +1, 0, 0, Avestan_range32, 2 },
-	{ "Balinese", +1, Balinese_range16, 2, 0, 0 },
-	{ "Bamum", +1, Bamum_range16, 1, Bamum_range32, 1 },
-	{ "Bassa_Vah", +1, 0, 0, Bassa_Vah_range32, 2 },
-	{ "Batak", +1, Batak_range16, 2, 0, 0 },
-	{ "Bengali", +1, Bengali_range16, 14, 0, 0 },
-	{ "Bhaiksuki", +1, 0, 0, Bhaiksuki_range32, 4 },
-	{ "Bopomofo", +1, Bopomofo_range16, 3, 0, 0 },
-	{ "Brahmi", +1, 0, 0, Brahmi_range32, 3 },
-	{ "Braille", +1, Braille_range16, 1, 0, 0 },
-	{ "Buginese", +1, Buginese_range16, 2, 0, 0 },
-	{ "Buhid", +1, Buhid_range16, 1, 0, 0 },
-	{ "C", +1, C_range16, 16, C_range32, 8 },
-	{ "Canadian_Aboriginal", +1, Canadian_Aboriginal_range16, 2, 0, 0 },
-	{ "Carian", +1, 0, 0, Carian_range32, 1 },
-	{ "Caucasian_Albanian", +1, 0, 0, Caucasian_Albanian_range32, 2 },
-	{ "Cc", +1, Cc_range16, 2, 0, 0 },
-	{ "Cf", +1, Cf_range16, 13, Cf_range32, 6 },
-	{ "Chakma", +1, 0, 0, Chakma_range32, 2 },
-	{ "Cham", +1, Cham_range16, 4, 0, 0 },
-	{ "Cherokee", +1, Cherokee_range16, 3, 0, 0 },
-	{ "Co", +1, Co_range16, 1, Co_range32, 2 },
-	{ "Common", +1, Common_range16, 90, Common_range32, 76 },
-	{ "Coptic", +1, Coptic_range16, 3, 0, 0 },
-	{ "Cs", +1, Cs_range16, 1, 0, 0 },
-	{ "Cuneiform", +1, 0, 0, Cuneiform_range32, 4 },
-	{ "Cypriot", +1, 0, 0, Cypriot_range32, 6 },
-	{ "Cyrillic", +1, Cyrillic_range16, 8, 0, 0 },
-	{ "Deseret", +1, 0, 0, Deseret_range32, 1 },
-	{ "Devanagari", +1, Devanagari_range16, 4, 0, 0 },
-	{ "Dogra", +1, 0, 0, Dogra_range32, 1 },
-	{ "Duployan", +1, 0, 0, Duployan_range32, 5 },
-	{ "Egyptian_Hieroglyphs", +1, 0, 0, Egyptian_Hieroglyphs_range32, 1 },
-	{ "Elbasan", +1, 0, 0, Elbasan_range32, 1 },
-	{ "Ethiopic", +1, Ethiopic_range16, 32, 0, 0 },
-	{ "Georgian", +1, Georgian_range16, 10, 0, 0 },
-	{ "Glagolitic", +1, Glagolitic_range16, 2, Glagolitic_range32, 5 },
-	{ "Gothic", +1, 0, 0, Gothic_range32, 1 },
-	{ "Grantha", +1, 0, 0, Grantha_range32, 15 },
-	{ "Greek", +1, Greek_range16, 33, Greek_range32, 3 },
-	{ "Gujarati", +1, Gujarati_range16, 14, 0, 0 },
-	{ "Gunjala_Gondi", +1, 0, 0, Gunjala_Gondi_range32, 6 },
-	{ "Gurmukhi", +1, Gurmukhi_range16, 16, 0, 0 },
-	{ "Han", +1, Han_range16, 11, Han_range32, 6 },
-	{ "Hangul", +1, Hangul_range16, 14, 0, 0 },
-	{ "Hanifi_Rohingya", +1, 0, 0, Hanifi_Rohingya_range32, 2 },
-	{ "Hanunoo", +1, Hanunoo_range16, 1, 0, 0 },
-	{ "Hatran", +1, 0, 0, Hatran_range32, 3 },
-	{ "Hebrew", +1, Hebrew_range16, 9, 0, 0 },
-	{ "Hiragana", +1, Hiragana_range16, 2, Hiragana_range32, 2 },
-	{ "Imperial_Aramaic", +1, 0, 0, Imperial_Aramaic_range32, 2 },
-	{ "Inherited", +1, Inherited_range16, 20, Inherited_range32, 8 },
-	{ "Inscriptional_Pahlavi", +1, 0, 0, Inscriptional_Pahlavi_range32, 2 },
-	{ "Inscriptional_Parthian", +1, 0, 0, Inscriptional_Parthian_range32, 2 },
-	{ "Javanese", +1, Javanese_range16, 3, 0, 0 },
-	{ "Kaithi", +1, 0, 0, Kaithi_range32, 2 },
-	{ "Kannada", +1, Kannada_range16, 13, 0, 0 },
-	{ "Katakana", +1, Katakana_range16, 7, Katakana_range32, 1 },
-	{ "Kayah_Li", +1, Kayah_Li_range16, 2, 0, 0 },
-	{ "Kharoshthi", +1, 0, 0, Kharoshthi_range32, 8 },
-	{ "Khmer", +1, Khmer_range16, 4, 0, 0 },
-	{ "Khojki", +1, 0, 0, Khojki_range32, 2 },
-	{ "Khudawadi", +1, 0, 0, Khudawadi_range32, 2 },
-	{ "L", +1, L_range16, 384, L_range32, 215 },
-	{ "Lao", +1, Lao_range16, 18, 0, 0 },
-	{ "Latin", +1, Latin_range16, 30, 0, 0 },
-	{ "Lepcha", +1, Lepcha_range16, 3, 0, 0 },
-	{ "Limbu", +1, Limbu_range16, 5, 0, 0 },
-	{ "Linear_A", +1, 0, 0, Linear_A_range32, 3 },
-	{ "Linear_B", +1, 0, 0, Linear_B_range32, 7 },
-	{ "Lisu", +1, Lisu_range16, 1, 0, 0 },
-	{ "Ll", +1, Ll_range16, 604, Ll_range32, 34 },
-	{ "Lm", +1, Lm_range16, 54, Lm_range32, 3 },
-	{ "Lo", +1, Lo_range16, 295, Lo_range32, 175 },
-	{ "Lt", +1, Lt_range16, 10, 0, 0 },
-	{ "Lu", +1, Lu_range16, 594, Lu_range32, 37 },
-	{ "Lycian", +1, 0, 0, Lycian_range32, 1 },
-	{ "Lydian", +1, 0, 0, Lydian_range32, 2 },
-	{ "M", +1, M_range16, 187, M_range32, 88 },
-	{ "Mahajani", +1, 0, 0, Mahajani_range32, 1 },
-	{ "Makasar", +1, 0, 0, Makasar_range32, 1 },
-	{ "Malayalam", +1, Malayalam_range16, 8, 0, 0 },
-	{ "Mandaic", +1, Mandaic_range16, 2, 0, 0 },
-	{ "Manichaean", +1, 0, 0, Manichaean_range32, 2 },
-	{ "Marchen", +1, 0, 0, Marchen_range32, 3 },
-	{ "Masaram_Gondi", +1, 0, 0, Masaram_Gondi_range32, 7 },
-	{ "Mc", +1, Mc_range16, 110, Mc_range32, 56 },
-	{ "Me", +1, Me_range16, 5, 0, 0 },
-	{ "Medefaidrin", +1, 0, 0, Medefaidrin_range32, 1 },
-	{ "Meetei_Mayek", +1, Meetei_Mayek_range16, 3, 0, 0 },
-	{ "Mende_Kikakui", +1, 0, 0, Mende_Kikakui_range32, 2 },
-	{ "Meroitic_Cursive", +1, 0, 0, Meroitic_Cursive_range32, 3 },
-	{ "Meroitic_Hieroglyphs", +1, 0, 0, Meroitic_Hieroglyphs_range32, 1 },
-	{ "Miao", +1, 0, 0, Miao_range32, 3 },
-	{ "Mn", +1, Mn_range16, 208, Mn_range32, 105 },
-	{ "Modi", +1, 0, 0, Modi_range32, 2 },
-	{ "Mongolian", +1, Mongolian_range16, 6, Mongolian_range32, 1 },
-	{ "Mro", +1, 0, 0, Mro_range32, 3 },
-	{ "Multani", +1, 0, 0, Multani_range32, 5 },
-	{ "Myanmar", +1, Myanmar_range16, 3, 0, 0 },
-	{ "N", +1, N_range16, 67, N_range32, 58 },
-	{ "Nabataean", +1, 0, 0, Nabataean_range32, 2 },
-	{ "Nd", +1, Nd_range16, 37, Nd_range32, 20 },
-	{ "New_Tai_Lue", +1, New_Tai_Lue_range16, 4, 0, 0 },
-	{ "Newa", +1, 0, 0, Newa_range32, 3 },
-	{ "Nko", +1, Nko_range16, 2, 0, 0 },
-	{ "Nl", +1, Nl_range16, 7, Nl_range32, 5 },
-	{ "No", +1, No_range16, 29, No_range32, 38 },
-	{ "Nushu", +1, 0, 0, Nushu_range32, 2 },
-	{ "Ogham", +1, Ogham_range16, 1, 0, 0 },
-	{ "Ol_Chiki", +1, Ol_Chiki_range16, 1, 0, 0 },
-	{ "Old_Hungarian", +1, 0, 0, Old_Hungarian_range32, 3 },
-	{ "Old_Italic", +1, 0, 0, Old_Italic_range32, 2 },
-	{ "Old_North_Arabian", +1, 0, 0, Old_North_Arabian_range32, 1 },
-	{ "Old_Permic", +1, 0, 0, Old_Permic_range32, 1 },
-	{ "Old_Persian", +1, 0, 0, Old_Persian_range32, 2 },
-	{ "Old_Sogdian", +1, 0, 0, Old_Sogdian_range32, 1 },
-	{ "Old_South_Arabian", +1, 0, 0, Old_South_Arabian_range32, 1 },
-	{ "Old_Turkic", +1, 0, 0, Old_Turkic_range32, 1 },
-	{ "Oriya", +1, Oriya_range16, 14, 0, 0 },
-	{ "Osage", +1, 0, 0, Osage_range32, 2 },
-	{ "Osmanya", +1, 0, 0, Osmanya_range32, 2 },
-	{ "P", +1, P_range16, 130, P_range32, 48 },
-	{ "Pahawh_Hmong", +1, 0, 0, Pahawh_Hmong_range32, 5 },
-	{ "Palmyrene", +1, 0, 0, Palmyrene_range32, 1 },
-	{ "Pau_Cin_Hau", +1, 0, 0, Pau_Cin_Hau_range32, 1 },
-	{ "Pc", +1, Pc_range16, 6, 0, 0 },
-	{ "Pd", +1, Pd_range16, 17, 0, 0 },
-	{ "Pe", +1, Pe_range16, 72, 0, 0 },
-	{ "Pf", +1, Pf_range16, 10, 0, 0 },
-	{ "Phags_Pa", +1, Phags_Pa_range16, 1, 0, 0 },
-	{ "Phoenician", +1, 0, 0, Phoenician_range32, 2 },
-	{ "Pi", +1, Pi_range16, 11, 0, 0 },
-	{ "Po", +1, Po_range16, 127, Po_range32, 48 },
-	{ "Ps", +1, Ps_range16, 75, 0, 0 },
-	{ "Psalter_Pahlavi", +1, 0, 0, Psalter_Pahlavi_range32, 3 },
-	{ "Rejang", +1, Rejang_range16, 2, 0, 0 },
-	{ "Runic", +1, Runic_range16, 2, 0, 0 },
-	{ "S", +1, S_range16, 147, S_range32, 73 },
-	{ "Samaritan", +1, Samaritan_range16, 2, 0, 0 },
-	{ "Saurashtra", +1, Saurashtra_range16, 2, 0, 0 },
-	{ "Sc", +1, Sc_range16, 18, Sc_range32, 1 },
-	{ "Sharada", +1, 0, 0, Sharada_range32, 2 },
-	{ "Shavian", +1, 0, 0, Shavian_range32, 1 },
-	{ "Siddham", +1, 0, 0, Siddham_range32, 2 },
-	{ "SignWriting", +1, 0, 0, SignWriting_range32, 3 },
-	{ "Sinhala", +1, Sinhala_range16, 12, Sinhala_range32, 1 },
-	{ "Sk", +1, Sk_range16, 28, Sk_range32, 1 },
-	{ "Sm", +1, Sm_range16, 53, Sm_range32, 11 },
-	{ "So", +1, So_range16, 112, So_range32, 62 },
-	{ "Sogdian", +1, 0, 0, Sogdian_range32, 1 },
-	{ "Sora_Sompeng", +1, 0, 0, Sora_Sompeng_range32, 2 },
-	{ "Soyombo", +1, 0, 0, Soyombo_range32, 2 },
-	{ "Sundanese", +1, Sundanese_range16, 2, 0, 0 },
-	{ "Syloti_Nagri", +1, Syloti_Nagri_range16, 1, 0, 0 },
-	{ "Syriac", +1, Syriac_range16, 4, 0, 0 },
-	{ "Tagalog", +1, Tagalog_range16, 2, 0, 0 },
-	{ "Tagbanwa", +1, Tagbanwa_range16, 3, 0, 0 },
-	{ "Tai_Le", +1, Tai_Le_range16, 2, 0, 0 },
-	{ "Tai_Tham", +1, Tai_Tham_range16, 5, 0, 0 },
-	{ "Tai_Viet", +1, Tai_Viet_range16, 2, 0, 0 },
-	{ "Takri", +1, 0, 0, Takri_range32, 2 },
-	{ "Tamil", +1, Tamil_range16, 16, 0, 0 },
-	{ "Tangut", +1, 0, 0, Tangut_range32, 3 },
-	{ "Telugu", +1, Telugu_range16, 12, 0, 0 },
-	{ "Thaana", +1, Thaana_range16, 1, 0, 0 },
-	{ "Thai", +1, Thai_range16, 2, 0, 0 },
-	{ "Tibetan", +1, Tibetan_range16, 7, 0, 0 },
-	{ "Tifinagh", +1, Tifinagh_range16, 3, 0, 0 },
-	{ "Tirhuta", +1, 0, 0, Tirhuta_range32, 2 },
-	{ "Ugaritic", +1, 0, 0, Ugaritic_range32, 2 },
-	{ "Vai", +1, Vai_range16, 1, 0, 0 },
-	{ "Warang_Citi", +1, 0, 0, Warang_Citi_range32, 2 },
-	{ "Yi", +1, Yi_range16, 2, 0, 0 },
-	{ "Z", +1, Z_range16, 8, 0, 0 },
-	{ "Zanabazar_Square", +1, 0, 0, Zanabazar_Square_range32, 1 },
-	{ "Zl", +1, Zl_range16, 1, 0, 0 },
-	{ "Zp", +1, Zp_range16, 1, 0, 0 },
-	{ "Zs", +1, Zs_range16, 7, 0, 0 },
-};
-const int num_unicode_groups = 184;
-
-
-}  // namespace duckdb_re2
-
-
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-/*
- * The authors of this software are Rob Pike and Ken Thompson.
- *              Copyright (c) 2002 by Lucent Technologies.
- * Permission to use, copy, modify, and distribute this software for any
- * purpose without fee is hereby granted, provided that this entire notice
- * is included in all copies of any software which is or includes a copy
- * or modification of this software and in all copies of the supporting
- * documentation for such software.
- * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
- * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
- * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- */
-
-#include <stdarg.h>
-#include <string.h>
-
-
-
-namespace duckdb_re2 {
-
-enum
-{
-	Bit1	= 7,
-	Bitx	= 6,
-	Bit2	= 5,
-	Bit3	= 4,
-	Bit4	= 3,
-	Bit5	= 2, 
-
-	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */
-	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */
-	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */
-	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */
-	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */
-	T5	= ((1<<(Bit5+1))-1) ^ 0xFF,	/* 1111 1000 */
-
-	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0111 1111 */
-	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0111 1111 1111 */
-	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 1111 1111 1111 1111 */
-	Rune4	= (1<<(Bit4+3*Bitx))-1,
-                                        /* 0001 1111 1111 1111 1111 1111 */
-
-	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */
-	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */
-
-	Bad	= Runeerror,
-};
-
-int
-chartorune(Rune *rune, const char *str)
-{
-	int c, c1, c2, c3;
-	long l;
-
-	/*
-	 * one character sequence
-	 *	00000-0007F => T1
-	 */
-	c = *(unsigned char*)str;
-	if(c < Tx) {
-		*rune = c;
-		return 1;
-	}
-
-	/*
-	 * two character sequence
-	 *	0080-07FF => T2 Tx
-	 */
-	c1 = *(unsigned char*)(str+1) ^ Tx;
-	if(c1 & Testx)
-		goto bad;
-	if(c < T3) {
-		if(c < T2)
-			goto bad;
-		l = ((c << Bitx) | c1) & Rune2;
-		if(l <= Rune1)
-			goto bad;
-		*rune = l;
-		return 2;
-	}
-
-	/*
-	 * three character sequence
-	 *	0800-FFFF => T3 Tx Tx
-	 */
-	c2 = *(unsigned char*)(str+2) ^ Tx;
-	if(c2 & Testx)
-		goto bad;
-	if(c < T4) {
-		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
-		if(l <= Rune2)
-			goto bad;
-		*rune = l;
-		return 3;
-	}
-
-	/*
-	 * four character sequence (21-bit value)
-	 *	10000-1FFFFF => T4 Tx Tx Tx
-	 */
-	c3 = *(unsigned char*)(str+3) ^ Tx;
-	if (c3 & Testx)
-		goto bad;
-	if (c < T5) {
-		l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4;
-		if (l <= Rune3)
-			goto bad;
-		*rune = l;
-		return 4;
-	}
-
-	/*
-	 * Support for 5-byte or longer UTF-8 would go here, but
-	 * since we don't have that, we'll just fall through to bad.
-	 */
-
-	/*
-	 * bad decoding
-	 */
-bad:
-	*rune = Bad;
-	return 1;
-}
-
-int
-runetochar(char *str, const Rune *rune)
-{
-	/* Runes are signed, so convert to unsigned for range check. */
-	unsigned long c;
-
-	/*
-	 * one character sequence
-	 *	00000-0007F => 00-7F
-	 */
-	c = *rune;
-	if(c <= Rune1) {
-		str[0] = static_cast<char>(c);
-		return 1;
-	}
-
-	/*
-	 * two character sequence
-	 *	0080-07FF => T2 Tx
-	 */
-	if(c <= Rune2) {
-		str[0] = T2 | static_cast<char>(c >> 1*Bitx);
-		str[1] = Tx | (c & Maskx);
-		return 2;
-	}
-
-	/*
-	 * If the Rune is out of range, convert it to the error rune.
-	 * Do this test here because the error rune encodes to three bytes.
-	 * Doing it earlier would duplicate work, since an out of range
-	 * Rune wouldn't have fit in one or two bytes.
-	 */
-	if (c > Runemax)
-		c = Runeerror;
-
-	/*
-	 * three character sequence
-	 *	0800-FFFF => T3 Tx Tx
-	 */
-	if (c <= Rune3) {
-		str[0] = T3 | static_cast<char>(c >> 2*Bitx);
-		str[1] = Tx | ((c >> 1*Bitx) & Maskx);
-		str[2] = Tx | (c & Maskx);
-		return 3;
-	}
-
-	/*
-	 * four character sequence (21-bit value)
-	 *     10000-1FFFFF => T4 Tx Tx Tx
-	 */
-	str[0] = T4 | static_cast<char>(c >> 3*Bitx);
-	str[1] = Tx | ((c >> 2*Bitx) & Maskx);
-	str[2] = Tx | ((c >> 1*Bitx) & Maskx);
-	str[3] = Tx | (c & Maskx);
-	return 4;
-}
-
-int
-runelen(Rune rune)
-{
-	char str[10];
-
-	return runetochar(str, &rune);
-}
-
-int
-fullrune(const char *str, int n)
-{
-	if (n > 0) {
-		int c = *(unsigned char*)str;
-		if (c < Tx)
-			return 1;
-		if (n > 1) {
-			if (c < T3)
-				return 1;
-			if (n > 2) {
-				if (c < T4 || n > 3)
-					return 1;
-			}
-		}
-	}
-	return 0;
-}
-
-
-int
-utflen(const char *s)
-{
-	int c;
-	long n;
-	Rune rune;
-
-	n = 0;
-	for(;;) {
-		c = *(unsigned char*)s;
-		if(c < Runeself) {
-			if(c == 0)
-				return n;
-			s++;
-		} else
-			s += chartorune(&rune, s);
-		n++;
-	}
-	return 0;
-}
-
-char*
-utfrune(const char *s, Rune c)
-{
-	long c1;
-	Rune r;
-	int n;
-
-	if(c < Runesync)		/* not part of utf sequence */
-		return strchr((char*)s, c);
-
-	for(;;) {
-		c1 = *(unsigned char*)s;
-		if(c1 < Runeself) {	/* one byte rune */
-			if(c1 == 0)
-				return 0;
-			if(c1 == c)
-				return (char*)s;
-			s++;
-			continue;
-		}
-		n = chartorune(&r, s);
-		if(r == c)
-			return (char*)s;
-		s += n;
-	}
-	return 0;
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
-// See the end of this file for a list
-
-// Copyright 1999-2005 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include <stdarg.h>
-#include <stdio.h>
-
-
-
-#ifdef _WIN32
-#define snprintf _snprintf
-#define vsnprintf _vsnprintf
-#endif
-
-namespace duckdb_re2 {
-
-// ----------------------------------------------------------------------
-// CEscapeString()
-//    Copies 'src' to 'dest', escaping dangerous characters using
-//    C-style escape sequences.  'src' and 'dest' should not overlap.
-//    Returns the number of bytes written to 'dest' (not including the \0)
-//    or (size_t)-1 if there was insufficient space.
-// ----------------------------------------------------------------------
-static size_t CEscapeString(const char* src, size_t src_len,
-                            char* dest, size_t dest_len) {
-  const char* src_end = src + src_len;
-  size_t used = 0;
-
-  for (; src < src_end; src++) {
-    if (dest_len - used < 2)   // space for two-character escape
-      return (size_t)-1;
-
-    unsigned char c = *src;
-    switch (c) {
-      case '\n': dest[used++] = '\\'; dest[used++] = 'n';  break;
-      case '\r': dest[used++] = '\\'; dest[used++] = 'r';  break;
-      case '\t': dest[used++] = '\\'; dest[used++] = 't';  break;
-      case '\"': dest[used++] = '\\'; dest[used++] = '\"'; break;
-      case '\'': dest[used++] = '\\'; dest[used++] = '\''; break;
-      case '\\': dest[used++] = '\\'; dest[used++] = '\\'; break;
-      default:
-        // Note that if we emit \xNN and the src character after that is a hex
-        // digit then that digit must be escaped too to prevent it being
-        // interpreted as part of the character code by C.
-        if (c < ' ' || c > '~') {
-          if (dest_len - used < 5)   // space for four-character escape + \0
-            return (size_t)-1;
-          snprintf(dest + used, 5, "\\%03o", c);
-          used += 4;
-        } else {
-          dest[used++] = c; break;
-        }
-    }
-  }
-
-  if (dest_len - used < 1)   // make sure that there is room for \0
-    return (size_t)-1;
-
-  dest[used] = '\0';   // doesn't count towards return value though
-  return used;
-}
-
-// ----------------------------------------------------------------------
-// CEscape()
-//    Copies 'src' to result, escaping dangerous characters using
-//    C-style escape sequences.  'src' and 'dest' should not overlap.
-// ----------------------------------------------------------------------
-std::string CEscape(const StringPiece& src) {
-  const size_t dest_len = src.size() * 4 + 1; // Maximum possible expansion
-  char* dest = new char[dest_len];
-  const size_t used = CEscapeString(src.data(), src.size(),
-                                    dest, dest_len);
-  std::string s = std::string(dest, used);
-  delete[] dest;
-  return s;
-}
-
-void PrefixSuccessor(std::string* prefix) {
-  // We can increment the last character in the string and be done
-  // unless that character is 255, in which case we have to erase the
-  // last character and increment the previous character, unless that
-  // is 255, etc. If the string is empty or consists entirely of
-  // 255's, we just return the empty string.
-  while (!prefix->empty()) {
-    char& c = prefix->back();
-    if (c == '\xff') {  // char literal avoids signed/unsigned.
-      prefix->pop_back();
-    } else {
-      ++c;
-      break;
-    }
-  }
-}
-
-static void StringAppendV(std::string* dst, const char* format, va_list ap) {
-  // First try with a small fixed size buffer
-  char space[1024];
-
-  // It's possible for methods that use a va_list to invalidate
-  // the data in it upon use.  The fix is to make a copy
-  // of the structure before using it and use that copy instead.
-  va_list backup_ap;
-  va_copy(backup_ap, ap);
-  int result = vsnprintf(space, sizeof(space), format, backup_ap);
-  va_end(backup_ap);
-
-  if ((result >= 0) && (static_cast<size_t>(result) < sizeof(space))) {
-    // It fit
-    dst->append(space, result);
-    return;
-  }
-
-  // Repeatedly increase buffer size until it fits
-  int length = sizeof(space);
-  while (true) {
-    if (result < 0) {
-      // Older behavior: just try doubling the buffer size
-      length *= 2;
-    } else {
-      // We need exactly "result+1" characters
-      length = result+1;
-    }
-    char* buf = new char[length];
-
-    // Restore the va_list before we use it again
-    va_copy(backup_ap, ap);
-    result = vsnprintf(buf, length, format, backup_ap);
-    va_end(backup_ap);
-
-    if ((result >= 0) && (result < length)) {
-      // It fit
-      dst->append(buf, result);
-      delete[] buf;
-      return;
-    }
-    delete[] buf;
-  }
-}
-
-std::string StringPrintf(const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  std::string result;
-  StringAppendV(&result, format, ap);
-  va_end(ap);
-  return result;
-}
-
-void SStringPrintf(std::string* dst, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  dst->clear();
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-}
-
-void StringAppendF(std::string* dst, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-}
-
-}  // namespace duckdb_re2
-
-
-// LICENSE_CHANGE_END
diff --git a/velox/external/duckdb/duckdb-utf8proc.cpp b/velox/external/duckdb/duckdb-utf8proc.cpp
deleted file mode 100644
index 113671328533f..0000000000000
--- a/velox/external/duckdb/duckdb-utf8proc.cpp
+++ /dev/null
@@ -1,15853 +0,0 @@
-// See https://raw.githubusercontent.com/duckdb/duckdb/master/LICENSE for licensing information
-
-#include "duckdb.hpp"
-#include "duckdb-internal.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#error header mismatch
-#endif
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
-// See the end of this file for a list
-
-/* -*- mode: c; c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil -*- */
-/*
- *  Copyright (c) 2014-2019 Steven G. Johnson, Jiahao Chen, Peter Colberg, Tony Kelman, Scott P. Jones, and other contributors.
- *  Copyright (c) 2009 Public Software Group e. V., Berlin, Germany
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a
- *  copy of this software and associated documentation files (the "Software"),
- *  to deal in the Software without restriction, including without limitation
- *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
- *  and/or sell copies of the Software, and to permit persons to whom the
- *  Software is furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in
- *  all copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- *  DEALINGS IN THE SOFTWARE.
- */
-
-/*
- *  This library contains derived data from a modified version of the
- *  Unicode data files.
- *
- *  The original data files are available at
- *  http://www.unicode.org/Public/UNIDATA/
- *
- *  Please notice the copyright statement in the file "utf8proc_data.c".
- */
-
-
-/*
- *  File name:    utf8proc.c
- *
- *  Description:
- *  Implementation of libutf8proc.
- */
-
-
-
-
-namespace duckdb {
-
-#ifndef SSIZE_MAX
-#define SSIZE_MAX ((size_t)SIZE_MAX/2)
-#endif
-#ifndef UINT16_MAX
-#  define UINT16_MAX 65535U
-#endif
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
-// See the end of this file for a list
-
-static const utf8proc_uint16_t utf8proc_sequences[] = {
-  97, 98, 99, 100, 101, 102, 103, 
-  104, 105, 106, 107, 108, 109, 110, 111, 
-  112, 113, 114, 115, 116, 117, 118, 119, 
-  120, 121, 122, 32, 32, 776, 32, 772, 
-  50, 51, 32, 769, 956, 32, 807, 49, 
-  49, 8260, 52, 49, 8260, 50, 51, 8260, 
-  52, 65, 768, 224, 65, 769, 225, 65, 
-  770, 226, 65, 771, 227, 65, 776, 228, 
-  65, 778, 229, 230, 67, 807, 231, 69, 
-  768, 232, 69, 769, 233, 69, 770, 234, 
-  69, 776, 235, 73, 768, 236, 73, 769, 
-  237, 73, 770, 238, 73, 776, 239, 240, 
-  78, 771, 241, 79, 768, 242, 79, 769, 
-  243, 79, 770, 244, 79, 771, 245, 79, 
-  776, 246, 248, 85, 768, 249, 85, 769, 
-  250, 85, 770, 251, 85, 776, 252, 89, 
-  769, 253, 254, 115, 115, 97, 768, 97, 
-  769, 97, 770, 97, 771, 97, 776, 97, 
-  778, 99, 807, 101, 768, 101, 769, 101, 
-  770, 101, 776, 105, 768, 105, 769, 105, 
-  770, 105, 776, 110, 771, 111, 768, 111, 
-  769, 111, 770, 111, 771, 111, 776, 117, 
-  768, 117, 769, 117, 770, 117, 776, 121, 
-  769, 121, 776, 65, 772, 257, 97, 772, 
-  65, 774, 259, 97, 774, 65, 808, 261, 
-  97, 808, 67, 769, 263, 99, 769, 67, 
-  770, 265, 99, 770, 67, 775, 267, 99, 
-  775, 67, 780, 269, 99, 780, 68, 780, 
-  271, 100, 780, 273, 69, 772, 275, 101, 
-  772, 69, 774, 277, 101, 774, 69, 775, 
-  279, 101, 775, 69, 808, 281, 101, 808, 
-  69, 780, 283, 101, 780, 71, 770, 285, 
-  103, 770, 71, 774, 287, 103, 774, 71, 
-  775, 289, 103, 775, 71, 807, 291, 103, 
-  807, 72, 770, 293, 104, 770, 295, 73, 
-  771, 297, 105, 771, 73, 772, 299, 105, 
-  772, 73, 774, 301, 105, 774, 73, 808, 
-  303, 105, 808, 73, 775, 105, 775, 73, 
-  74, 307, 105, 106, 74, 770, 309, 106, 
-  770, 75, 807, 311, 107, 807, 76, 769, 
-  314, 108, 769, 76, 807, 316, 108, 807, 
-  76, 780, 318, 108, 780, 76, 183, 320, 
-  108, 183, 322, 78, 769, 324, 110, 769, 
-  78, 807, 326, 110, 807, 78, 780, 328, 
-  110, 780, 700, 110, 331, 79, 772, 333, 
-  111, 772, 79, 774, 335, 111, 774, 79, 
-  779, 337, 111, 779, 339, 82, 769, 341, 
-  114, 769, 82, 807, 343, 114, 807, 82, 
-  780, 345, 114, 780, 83, 769, 347, 115, 
-  769, 83, 770, 349, 115, 770, 83, 807, 
-  351, 115, 807, 83, 780, 353, 115, 780, 
-  84, 807, 355, 116, 807, 84, 780, 357, 
-  116, 780, 359, 85, 771, 361, 117, 771, 
-  85, 772, 363, 117, 772, 85, 774, 365, 
-  117, 774, 85, 778, 367, 117, 778, 85, 
-  779, 369, 117, 779, 85, 808, 371, 117, 
-  808, 87, 770, 373, 119, 770, 89, 770, 
-  375, 121, 770, 89, 776, 255, 90, 769, 
-  378, 122, 769, 90, 775, 380, 122, 775, 
-  90, 780, 382, 122, 780, 595, 387, 389, 
-  596, 392, 598, 599, 396, 477, 601, 603, 
-  402, 608, 611, 617, 616, 409, 623, 626, 
-  629, 79, 795, 417, 111, 795, 419, 421, 
-  640, 424, 643, 429, 648, 85, 795, 432, 
-  117, 795, 650, 651, 436, 438, 658, 441, 
-  445, 68, 381, 454, 68, 382, 100, 382, 
-  76, 74, 457, 76, 106, 108, 106, 78, 
-  74, 460, 78, 106, 110, 106, 65, 780, 
-  462, 97, 780, 73, 780, 464, 105, 780, 
-  79, 780, 466, 111, 780, 85, 780, 468, 
-  117, 780, 220, 772, 470, 252, 772, 220, 
-  769, 472, 252, 769, 220, 780, 474, 252, 
-  780, 220, 768, 476, 252, 768, 196, 772, 
-  479, 228, 772, 550, 772, 481, 551, 772, 
-  198, 772, 483, 230, 772, 485, 71, 780, 
-  487, 103, 780, 75, 780, 489, 107, 780, 
-  79, 808, 491, 111, 808, 490, 772, 493, 
-  491, 772, 439, 780, 495, 658, 780, 106, 
-  780, 68, 90, 499, 68, 122, 100, 122, 
-  71, 769, 501, 103, 769, 405, 447, 78, 
-  768, 505, 110, 768, 197, 769, 507, 229, 
-  769, 198, 769, 509, 230, 769, 216, 769, 
-  511, 248, 769, 65, 783, 513, 97, 783, 
-  65, 785, 515, 97, 785, 69, 783, 517, 
-  101, 783, 69, 785, 519, 101, 785, 73, 
-  783, 521, 105, 783, 73, 785, 523, 105, 
-  785, 79, 783, 525, 111, 783, 79, 785, 
-  527, 111, 785, 82, 783, 529, 114, 783, 
-  82, 785, 531, 114, 785, 85, 783, 533, 
-  117, 783, 85, 785, 535, 117, 785, 83, 
-  806, 537, 115, 806, 84, 806, 539, 116, 
-  806, 541, 72, 780, 543, 104, 780, 414, 
-  547, 549, 65, 775, 551, 97, 775, 69, 
-  807, 553, 101, 807, 214, 772, 555, 246, 
-  772, 213, 772, 557, 245, 772, 79, 775, 
-  559, 111, 775, 558, 772, 561, 559, 772, 
-  89, 772, 563, 121, 772, 11365, 572, 410, 
-  11366, 578, 384, 649, 652, 583, 585, 587, 
-  589, 591, 614, 633, 635, 641, 32, 774, 
-  32, 775, 32, 778, 32, 808, 32, 771, 
-  32, 779, 661, 768, 769, 787, 776, 769, 
-  953, 881, 883, 697, 887, 32, 837, 59, 
-  1011, 168, 769, 913, 769, 940, 183, 917, 
-  769, 941, 919, 769, 942, 921, 769, 943, 
-  927, 769, 972, 933, 769, 973, 937, 769, 
-  974, 970, 769, 953, 776, 769, 945, 946, 
-  947, 948, 949, 950, 951, 952, 954, 955, 
-  957, 958, 959, 960, 961, 963, 964, 965, 
-  966, 967, 968, 969, 921, 776, 970, 933, 
-  776, 971, 945, 769, 949, 769, 951, 769, 
-  953, 769, 971, 769, 965, 776, 769, 953, 
-  776, 965, 776, 959, 769, 965, 769, 969, 
-  769, 983, 933, 978, 769, 978, 776, 985, 
-  987, 989, 991, 993, 995, 997, 999, 1001, 
-  1003, 1005, 1007, 962, 920, 1016, 931, 1010, 
-  1019, 891, 892, 893, 1045, 768, 1104, 1045, 
-  776, 1105, 1106, 1043, 769, 1107, 1108, 1109, 
-  1110, 1030, 776, 1111, 1112, 1113, 1114, 1115, 
-  1050, 769, 1116, 1048, 768, 1117, 1059, 774, 
-  1118, 1119, 1072, 1073, 1074, 1075, 1076, 1077, 
-  1078, 1079, 1080, 1048, 774, 1081, 1082, 1083, 
-  1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 
-  1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 
-  1100, 1101, 1102, 1103, 1080, 774, 1077, 768, 
-  1077, 776, 1075, 769, 1110, 776, 1082, 769, 
-  1080, 768, 1091, 774, 1121, 1123, 1125, 1127, 
-  1129, 1131, 1133, 1135, 1137, 1139, 1141, 1140, 
-  783, 1143, 1141, 783, 1145, 1147, 1149, 1151, 
-  1153, 1163, 1165, 1167, 1169, 1171, 1173, 1175, 
-  1177, 1179, 1181, 1183, 1185, 1187, 1189, 1191, 
-  1193, 1195, 1197, 1199, 1201, 1203, 1205, 1207, 
-  1209, 1211, 1213, 1215, 1231, 1046, 774, 1218, 
-  1078, 774, 1220, 1222, 1224, 1226, 1228, 1230, 
-  1040, 774, 1233, 1072, 774, 1040, 776, 1235, 
-  1072, 776, 1237, 1045, 774, 1239, 1077, 774, 
-  1241, 1240, 776, 1243, 1241, 776, 1046, 776, 
-  1245, 1078, 776, 1047, 776, 1247, 1079, 776, 
-  1249, 1048, 772, 1251, 1080, 772, 1048, 776, 
-  1253, 1080, 776, 1054, 776, 1255, 1086, 776, 
-  1257, 1256, 776, 1259, 1257, 776, 1069, 776, 
-  1261, 1101, 776, 1059, 772, 1263, 1091, 772, 
-  1059, 776, 1265, 1091, 776, 1059, 779, 1267, 
-  1091, 779, 1063, 776, 1269, 1095, 776, 1271, 
-  1067, 776, 1273, 1099, 776, 1275, 1277, 1279, 
-  1281, 1283, 1285, 1287, 1289, 1291, 1293, 1295, 
-  1297, 1299, 1301, 1303, 1305, 1307, 1309, 1311, 
-  1313, 1315, 1317, 1319, 1321, 1323, 1325, 1327, 
-  1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 
-  1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 
-  1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 
-  1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 
-  1409, 1410, 1411, 1412, 1413, 1414, 1381, 1410, 
-  1575, 1619, 1575, 1620, 1608, 1620, 1575, 1621, 
-  1610, 1620, 1575, 1652, 1608, 1652, 1735, 1652, 
-  1610, 1652, 1749, 1620, 1729, 1620, 1746, 1620, 
-  2344, 2364, 2352, 2364, 2355, 2364, 2325, 2364, 
-  2326, 2364, 2327, 2364, 2332, 2364, 2337, 2364, 
-  2338, 2364, 2347, 2364, 2351, 2364, 2503, 2494, 
-  2503, 2519, 2465, 2492, 2466, 2492, 2479, 2492, 
-  2610, 2620, 2616, 2620, 2582, 2620, 2583, 2620, 
-  2588, 2620, 2603, 2620, 2887, 2902, 2887, 2878, 
-  2887, 2903, 2849, 2876, 2850, 2876, 2962, 3031, 
-  3014, 3006, 3015, 3006, 3014, 3031, 3142, 3158, 
-  3263, 3285, 3270, 3285, 3270, 3286, 3270, 3266, 
-  3274, 3285, 3398, 3390, 3399, 3390, 3398, 3415, 
-  3545, 3530, 3545, 3535, 3548, 3530, 3545, 3551, 
-  3661, 3634, 3789, 3762, 3755, 3737, 3755, 3745, 
-  3851, 3906, 4023, 3916, 4023, 3921, 4023, 3926, 
-  4023, 3931, 4023, 3904, 4021, 3953, 3954, 3953, 
-  3956, 4018, 3968, 4018, 3969, 4019, 3968, 4019, 
-  3969, 3953, 3968, 3986, 4023, 3996, 4023, 4001, 
-  4023, 4006, 4023, 4011, 4023, 3984, 4021, 4133, 
-  4142, 11520, 11521, 11522, 11523, 11524, 11525, 11526, 
-  11527, 11528, 11529, 11530, 11531, 11532, 11533, 11534, 
-  11535, 11536, 11537, 11538, 11539, 11540, 11541, 11542, 
-  11543, 11544, 11545, 11546, 11547, 11548, 11549, 11550, 
-  11551, 11552, 11553, 11554, 11555, 11556, 11557, 11559, 
-  11565, 4316, 5104, 5105, 5106, 5107, 5108, 5109, 
-  6917, 6965, 6919, 6965, 6921, 6965, 6923, 6965, 
-  6925, 6965, 6929, 6965, 6970, 6965, 6972, 6965, 
-  6974, 6965, 6975, 6965, 6978, 6965, 42571, 4304, 
-  4305, 4306, 4307, 4308, 4309, 4310, 4311, 4312, 
-  4313, 4314, 4315, 4317, 4318, 4319, 4320, 4321, 
-  4322, 4323, 4324, 4325, 4326, 4327, 4328, 4329, 
-  4330, 4331, 4332, 4333, 4334, 4335, 4336, 4337, 
-  4338, 4339, 4340, 4341, 4342, 4343, 4344, 4345, 
-  4346, 4349, 4350, 4351, 65, 198, 66, 68, 
-  69, 398, 71, 72, 73, 74, 75, 76, 
-  77, 78, 79, 546, 80, 82, 84, 85, 
-  87, 592, 593, 7426, 604, 7446, 7447, 7453, 
-  7461, 594, 597, 607, 609, 613, 618, 7547, 
-  669, 621, 7557, 671, 625, 624, 627, 628, 
-  632, 642, 427, 7452, 656, 657, 65, 805, 
-  7681, 97, 805, 66, 775, 7683, 98, 775, 
-  66, 803, 7685, 98, 803, 66, 817, 7687, 
-  98, 817, 199, 769, 7689, 231, 769, 68, 
-  775, 7691, 100, 775, 68, 803, 7693, 100, 
-  803, 68, 817, 7695, 100, 817, 68, 807, 
-  7697, 100, 807, 68, 813, 7699, 100, 813, 
-  274, 768, 7701, 275, 768, 274, 769, 7703, 
-  275, 769, 69, 813, 7705, 101, 813, 69, 
-  816, 7707, 101, 816, 552, 774, 7709, 553, 
-  774, 70, 775, 7711, 102, 775, 71, 772, 
-  7713, 103, 772, 72, 775, 7715, 104, 775, 
-  72, 803, 7717, 104, 803, 72, 776, 7719, 
-  104, 776, 72, 807, 7721, 104, 807, 72, 
-  814, 7723, 104, 814, 73, 816, 7725, 105, 
-  816, 207, 769, 7727, 239, 769, 75, 769, 
-  7729, 107, 769, 75, 803, 7731, 107, 803, 
-  75, 817, 7733, 107, 817, 76, 803, 7735, 
-  108, 803, 7734, 772, 7737, 7735, 772, 76, 
-  817, 7739, 108, 817, 76, 813, 7741, 108, 
-  813, 77, 769, 7743, 109, 769, 77, 775, 
-  7745, 109, 775, 77, 803, 7747, 109, 803, 
-  78, 775, 7749, 110, 775, 78, 803, 7751, 
-  110, 803, 78, 817, 7753, 110, 817, 78, 
-  813, 7755, 110, 813, 213, 769, 7757, 245, 
-  769, 213, 776, 7759, 245, 776, 332, 768, 
-  7761, 333, 768, 332, 769, 7763, 333, 769, 
-  80, 769, 7765, 112, 769, 80, 775, 7767, 
-  112, 775, 82, 775, 7769, 114, 775, 82, 
-  803, 7771, 114, 803, 7770, 772, 7773, 7771, 
-  772, 82, 817, 7775, 114, 817, 83, 775, 
-  7777, 115, 775, 83, 803, 7779, 115, 803, 
-  346, 775, 7781, 347, 775, 352, 775, 7783, 
-  353, 775, 7778, 775, 7785, 7779, 775, 84, 
-  775, 7787, 116, 775, 84, 803, 7789, 116, 
-  803, 84, 817, 7791, 116, 817, 84, 813, 
-  7793, 116, 813, 85, 804, 7795, 117, 804, 
-  85, 816, 7797, 117, 816, 85, 813, 7799, 
-  117, 813, 360, 769, 7801, 361, 769, 362, 
-  776, 7803, 363, 776, 86, 771, 7805, 118, 
-  771, 86, 803, 7807, 118, 803, 87, 768, 
-  7809, 119, 768, 87, 769, 7811, 119, 769, 
-  87, 776, 7813, 119, 776, 87, 775, 7815, 
-  119, 775, 87, 803, 7817, 119, 803, 88, 
-  775, 7819, 120, 775, 88, 776, 7821, 120, 
-  776, 89, 775, 7823, 121, 775, 90, 770, 
-  7825, 122, 770, 90, 803, 7827, 122, 803, 
-  90, 817, 7829, 122, 817, 104, 817, 116, 
-  776, 119, 778, 121, 778, 97, 702, 383, 
-  775, 65, 803, 7841, 97, 803, 65, 777, 
-  7843, 97, 777, 194, 769, 7845, 226, 769, 
-  194, 768, 7847, 226, 768, 194, 777, 7849, 
-  226, 777, 194, 771, 7851, 226, 771, 7840, 
-  770, 7853, 7841, 770, 258, 769, 7855, 259, 
-  769, 258, 768, 7857, 259, 768, 258, 777, 
-  7859, 259, 777, 258, 771, 7861, 259, 771, 
-  7840, 774, 7863, 7841, 774, 69, 803, 7865, 
-  101, 803, 69, 777, 7867, 101, 777, 69, 
-  771, 7869, 101, 771, 202, 769, 7871, 234, 
-  769, 202, 768, 7873, 234, 768, 202, 777, 
-  7875, 234, 777, 202, 771, 7877, 234, 771, 
-  7864, 770, 7879, 7865, 770, 73, 777, 7881, 
-  105, 777, 73, 803, 7883, 105, 803, 79, 
-  803, 7885, 111, 803, 79, 777, 7887, 111, 
-  777, 212, 769, 7889, 244, 769, 212, 768, 
-  7891, 244, 768, 212, 777, 7893, 244, 777, 
-  212, 771, 7895, 244, 771, 7884, 770, 7897, 
-  7885, 770, 416, 769, 7899, 417, 769, 416, 
-  768, 7901, 417, 768, 416, 777, 7903, 417, 
-  777, 416, 771, 7905, 417, 771, 416, 803, 
-  7907, 417, 803, 85, 803, 7909, 117, 803, 
-  85, 777, 7911, 117, 777, 431, 769, 7913, 
-  432, 769, 431, 768, 7915, 432, 768, 431, 
-  777, 7917, 432, 777, 431, 771, 7919, 432, 
-  771, 431, 803, 7921, 432, 803, 89, 768, 
-  7923, 121, 768, 89, 803, 7925, 121, 803, 
-  89, 777, 7927, 121, 777, 89, 771, 7929, 
-  121, 771, 7931, 7933, 7935, 945, 787, 945, 
-  788, 7936, 768, 7937, 768, 7936, 769, 7937, 
-  769, 7936, 834, 7937, 834, 913, 787, 7936, 
-  913, 788, 7937, 7944, 768, 7938, 7945, 768, 
-  7939, 7944, 769, 7940, 7945, 769, 7941, 7944, 
-  834, 7942, 7945, 834, 7943, 949, 787, 949, 
-  788, 7952, 768, 7953, 768, 7952, 769, 7953, 
-  769, 917, 787, 7952, 917, 788, 7953, 7960, 
-  768, 7954, 7961, 768, 7955, 7960, 769, 7956, 
-  7961, 769, 7957, 951, 787, 951, 788, 7968, 
-  768, 7969, 768, 7968, 769, 7969, 769, 7968, 
-  834, 7969, 834, 919, 787, 7968, 919, 788, 
-  7969, 7976, 768, 7970, 7977, 768, 7971, 7976, 
-  769, 7972, 7977, 769, 7973, 7976, 834, 7974, 
-  7977, 834, 7975, 953, 787, 953, 788, 7984, 
-  768, 7985, 768, 7984, 769, 7985, 769, 7984, 
-  834, 7985, 834, 921, 787, 7984, 921, 788, 
-  7985, 7992, 768, 7986, 7993, 768, 7987, 7992, 
-  769, 7988, 7993, 769, 7989, 7992, 834, 7990, 
-  7993, 834, 7991, 959, 787, 959, 788, 8000, 
-  768, 8001, 768, 8000, 769, 8001, 769, 927, 
-  787, 8000, 927, 788, 8001, 8008, 768, 8002, 
-  8009, 768, 8003, 8008, 769, 8004, 8009, 769, 
-  8005, 965, 787, 965, 788, 8016, 768, 965, 
-  787, 768, 8017, 768, 8016, 769, 965, 787, 
-  769, 8017, 769, 8016, 834, 965, 787, 834, 
-  8017, 834, 933, 788, 8017, 8025, 768, 8019, 
-  8025, 769, 8021, 8025, 834, 8023, 969, 787, 
-  969, 788, 8032, 768, 8033, 768, 8032, 769, 
-  8033, 769, 8032, 834, 8033, 834, 937, 787, 
-  8032, 937, 788, 8033, 8040, 768, 8034, 8041, 
-  768, 8035, 8040, 769, 8036, 8041, 769, 8037, 
-  8040, 834, 8038, 8041, 834, 8039, 945, 768, 
-  949, 768, 951, 768, 953, 768, 959, 768, 
-  965, 768, 969, 768, 7936, 837, 7936, 953, 
-  7937, 837, 7937, 953, 7938, 837, 7938, 953, 
-  7939, 837, 7939, 953, 7940, 837, 7940, 953, 
-  7941, 837, 7941, 953, 7942, 837, 7942, 953, 
-  7943, 837, 7943, 953, 7944, 837, 7945, 837, 
-  7946, 837, 7947, 837, 7948, 837, 7949, 837, 
-  7950, 837, 7951, 837, 7968, 837, 7968, 953, 
-  7969, 837, 7969, 953, 7970, 837, 7970, 953, 
-  7971, 837, 7971, 953, 7972, 837, 7972, 953, 
-  7973, 837, 7973, 953, 7974, 837, 7974, 953, 
-  7975, 837, 7975, 953, 7976, 837, 7977, 837, 
-  7978, 837, 7979, 837, 7980, 837, 7981, 837, 
-  7982, 837, 7983, 837, 8032, 837, 8032, 953, 
-  8033, 837, 8033, 953, 8034, 837, 8034, 953, 
-  8035, 837, 8035, 953, 8036, 837, 8036, 953, 
-  8037, 837, 8037, 953, 8038, 837, 8038, 953, 
-  8039, 837, 8039, 953, 8040, 837, 8041, 837, 
-  8042, 837, 8043, 837, 8044, 837, 8045, 837, 
-  8046, 837, 8047, 837, 945, 774, 945, 772, 
-  8048, 837, 8048, 953, 945, 837, 945, 953, 
-  940, 837, 940, 953, 945, 834, 8118, 837, 
-  945, 834, 953, 913, 774, 8112, 913, 772, 
-  8113, 913, 768, 8048, 902, 8049, 913, 837, 
-  32, 787, 32, 834, 168, 834, 8052, 837, 
-  8052, 953, 951, 837, 951, 953, 942, 837, 
-  942, 953, 951, 834, 8134, 837, 951, 834, 
-  953, 917, 768, 8050, 904, 8051, 919, 768, 
-  8052, 905, 8053, 919, 837, 8127, 768, 8127, 
-  769, 8127, 834, 953, 774, 953, 772, 970, 
-  768, 953, 776, 768, 912, 953, 834, 970, 
-  834, 953, 776, 834, 921, 774, 8144, 921, 
-  772, 8145, 921, 768, 8054, 906, 8055, 8190, 
-  768, 8190, 769, 8190, 834, 965, 774, 965, 
-  772, 971, 768, 965, 776, 768, 944, 961, 
-  787, 961, 788, 965, 834, 971, 834, 965, 
-  776, 834, 933, 774, 8160, 933, 772, 8161, 
-  933, 768, 8058, 910, 8059, 929, 788, 8165, 
-  168, 768, 901, 96, 8060, 837, 8060, 953, 
-  969, 837, 969, 953, 974, 837, 974, 953, 
-  969, 834, 8182, 837, 969, 834, 953, 927, 
-  768, 8056, 908, 8057, 937, 768, 8060, 911, 
-  8061, 937, 837, 180, 32, 788, 8194, 8195, 
-  8208, 32, 819, 46, 46, 46, 46, 46, 
-  46, 8242, 8242, 8242, 8242, 8242, 8245, 8245, 
-  8245, 8245, 8245, 33, 33, 32, 773, 63, 
-  63, 63, 33, 33, 63, 8242, 8242, 8242, 
-  8242, 48, 52, 53, 54, 55, 56, 57, 
-  43, 8722, 61, 40, 41, 82, 115, 97, 
-  47, 99, 97, 47, 115, 67, 176, 67, 
-  99, 47, 111, 99, 47, 117, 400, 176, 
-  70, 78, 111, 81, 83, 77, 84, 69, 
-  76, 84, 77, 90, 937, 197, 70, 8526, 
-  1488, 1489, 1490, 1491, 70, 65, 88, 915, 
-  928, 8721, 49, 8260, 55, 49, 8260, 57, 
-  49, 8260, 49, 48, 49, 8260, 51, 50, 
-  8260, 51, 49, 8260, 53, 50, 8260, 53, 
-  51, 8260, 53, 52, 8260, 53, 49, 8260, 
-  54, 53, 8260, 54, 49, 8260, 56, 51, 
-  8260, 56, 53, 8260, 56, 55, 8260, 56, 
-  49, 8260, 8560, 73, 73, 8561, 73, 73, 
-  73, 8562, 73, 86, 8563, 86, 8564, 86, 
-  73, 8565, 86, 73, 73, 8566, 86, 73, 
-  73, 73, 8567, 73, 88, 8568, 88, 8569, 
-  88, 73, 8570, 88, 73, 73, 8571, 8572, 
-  8573, 8574, 8575, 105, 105, 105, 105, 105, 
-  105, 118, 118, 105, 118, 105, 105, 118, 
-  105, 105, 105, 105, 120, 120, 105, 120, 
-  105, 105, 8580, 48, 8260, 51, 8592, 824, 
-  8594, 824, 8596, 824, 8656, 824, 8660, 824, 
-  8658, 824, 8707, 824, 8712, 824, 8715, 824, 
-  8739, 824, 8741, 824, 8747, 8747, 8747, 8747, 
-  8747, 8750, 8750, 8750, 8750, 8750, 8764, 824, 
-  8771, 824, 8773, 824, 8776, 824, 61, 824, 
-  8801, 824, 8781, 824, 60, 824, 62, 824, 
-  8804, 824, 8805, 824, 8818, 824, 8819, 824, 
-  8822, 824, 8823, 824, 8826, 824, 8827, 824, 
-  8834, 824, 8835, 824, 8838, 824, 8839, 824, 
-  8866, 824, 8872, 824, 8873, 824, 8875, 824, 
-  8828, 824, 8829, 824, 8849, 824, 8850, 824, 
-  8882, 824, 8883, 824, 8884, 824, 8885, 824, 
-  12296, 12297, 49, 48, 49, 49, 49, 50, 
-  49, 51, 49, 52, 49, 53, 49, 54, 
-  49, 55, 49, 56, 49, 57, 50, 48, 
-  40, 49, 41, 40, 50, 41, 40, 51, 
-  41, 40, 52, 41, 40, 53, 41, 40, 
-  54, 41, 40, 55, 41, 40, 56, 41, 
-  40, 57, 41, 40, 49, 48, 41, 40, 
-  49, 49, 41, 40, 49, 50, 41, 40, 
-  49, 51, 41, 40, 49, 52, 41, 40, 
-  49, 53, 41, 40, 49, 54, 41, 40, 
-  49, 55, 41, 40, 49, 56, 41, 40, 
-  49, 57, 41, 40, 50, 48, 41, 49, 
-  46, 50, 46, 51, 46, 52, 46, 53, 
-  46, 54, 46, 55, 46, 56, 46, 57, 
-  46, 49, 48, 46, 49, 49, 46, 49, 
-  50, 46, 49, 51, 46, 49, 52, 46, 
-  49, 53, 46, 49, 54, 46, 49, 55, 
-  46, 49, 56, 46, 49, 57, 46, 50, 
-  48, 46, 40, 97, 41, 40, 98, 41, 
-  40, 99, 41, 40, 100, 41, 40, 101, 
-  41, 40, 102, 41, 40, 103, 41, 40, 
-  104, 41, 40, 105, 41, 40, 106, 41, 
-  40, 107, 41, 40, 108, 41, 40, 109, 
-  41, 40, 110, 41, 40, 111, 41, 40, 
-  112, 41, 40, 113, 41, 40, 114, 41, 
-  40, 115, 41, 40, 116, 41, 40, 117, 
-  41, 40, 118, 41, 40, 119, 41, 40, 
-  120, 41, 40, 121, 41, 40, 122, 41, 
-  9424, 9425, 9426, 9427, 9428, 9429, 9430, 9431, 
-  9432, 9433, 9434, 9435, 9436, 9437, 9438, 9439, 
-  9440, 9441, 83, 9442, 9443, 9444, 9445, 9446, 
-  9447, 89, 9448, 9449, 8747, 8747, 8747, 8747, 
-  58, 58, 61, 61, 61, 61, 61, 61, 
-  10973, 824, 11312, 11313, 11314, 11315, 11316, 11317, 
-  11318, 11319, 11320, 11321, 11322, 11323, 11324, 11325, 
-  11326, 11327, 11328, 11329, 11330, 11331, 11332, 11333, 
-  11334, 11335, 11336, 11337, 11338, 11339, 11340, 11341, 
-  11342, 11343, 11344, 11345, 11346, 11347, 11348, 11349, 
-  11350, 11351, 11352, 11353, 11354, 11355, 11356, 11357, 
-  11358, 11361, 619, 7549, 637, 11368, 11370, 11372, 
-  11379, 11382, 575, 576, 11393, 11395, 11397, 11399, 
-  11401, 11403, 11405, 11407, 11409, 11411, 11413, 11415, 
-  11417, 11419, 11421, 11423, 11425, 11427, 11429, 11431, 
-  11433, 11435, 11437, 11439, 11441, 11443, 11445, 11447, 
-  11449, 11451, 11453, 11455, 11457, 11459, 11461, 11463, 
-  11465, 11467, 11469, 11471, 11473, 11475, 11477, 11479, 
-  11481, 11483, 11485, 11487, 11489, 11491, 11500, 11502, 
-  11507, 11617, 27597, 40863, 19968, 20008, 20022, 20031, 
-  20057, 20101, 20108, 20128, 20154, 20799, 20837, 20843, 
-  20866, 20886, 20907, 20960, 20981, 20992, 21147, 21241, 
-  21269, 21274, 21304, 21313, 21340, 21353, 21378, 21430, 
-  21448, 21475, 22231, 22303, 22763, 22786, 22794, 22805, 
-  22823, 22899, 23376, 23424, 23544, 23567, 23586, 23608, 
-  23662, 23665, 24027, 24037, 24049, 24062, 24178, 24186, 
-  24191, 24308, 24318, 24331, 24339, 24400, 24417, 24435, 
-  24515, 25096, 25142, 25163, 25903, 25908, 25991, 26007, 
-  26020, 26041, 26080, 26085, 26352, 26376, 26408, 27424, 
-  27490, 27513, 27571, 27595, 27604, 27611, 27663, 27668, 
-  27700, 28779, 29226, 29238, 29243, 29247, 29255, 29273, 
-  29275, 29356, 29572, 29577, 29916, 29926, 29976, 29983, 
-  29992, 30000, 30091, 30098, 30326, 30333, 30382, 30399, 
-  30446, 30683, 30690, 30707, 31034, 31160, 31166, 31348, 
-  31435, 31481, 31859, 31992, 32566, 32593, 32650, 32701, 
-  32769, 32780, 32786, 32819, 32895, 32905, 33251, 33258, 
-  33267, 33276, 33292, 33307, 33311, 33390, 33394, 33400, 
-  34381, 34411, 34880, 34892, 34915, 35198, 35211, 35282, 
-  35328, 35895, 35910, 35925, 35960, 35997, 36196, 36208, 
-  36275, 36523, 36554, 36763, 36784, 36789, 37009, 37193, 
-  37318, 37324, 37329, 38263, 38272, 38428, 38582, 38585, 
-  38632, 38737, 38750, 38754, 38761, 38859, 38893, 38899, 
-  38913, 39080, 39131, 39135, 39318, 39321, 39340, 39592, 
-  39640, 39647, 39717, 39727, 39730, 39740, 39770, 40165, 
-  40565, 40575, 40613, 40635, 40643, 40653, 40657, 40697, 
-  40701, 40718, 40723, 40736, 40763, 40778, 40786, 40845, 
-  40860, 40864, 12306, 21316, 21317, 12363, 12441, 12365, 
-  12441, 12367, 12441, 12369, 12441, 12371, 12441, 12373, 
-  12441, 12375, 12441, 12377, 12441, 12379, 12441, 12381, 
-  12441, 12383, 12441, 12385, 12441, 12388, 12441, 12390, 
-  12441, 12392, 12441, 12399, 12441, 12399, 12442, 12402, 
-  12441, 12402, 12442, 12405, 12441, 12405, 12442, 12408, 
-  12441, 12408, 12442, 12411, 12441, 12411, 12442, 12358, 
-  12441, 32, 12441, 32, 12442, 12445, 12441, 12424, 
-  12426, 12459, 12441, 12461, 12441, 12463, 12441, 12465, 
-  12441, 12467, 12441, 12469, 12441, 12471, 12441, 12473, 
-  12441, 12475, 12441, 12477, 12441, 12479, 12441, 12481, 
-  12441, 12484, 12441, 12486, 12441, 12488, 12441, 12495, 
-  12441, 12495, 12442, 12498, 12441, 12498, 12442, 12501, 
-  12441, 12501, 12442, 12504, 12441, 12504, 12442, 12507, 
-  12441, 12507, 12442, 12454, 12441, 12527, 12441, 12528, 
-  12441, 12529, 12441, 12530, 12441, 12541, 12441, 12467, 
-  12488, 4352, 4353, 4522, 4354, 4524, 4525, 4355, 
-  4356, 4357, 4528, 4529, 4530, 4531, 4532, 4533, 
-  4378, 4358, 4359, 4360, 4385, 4361, 4362, 4363, 
-  4364, 4365, 4366, 4367, 4368, 4369, 4370, 4449, 
-  4450, 4451, 4452, 4453, 4454, 4455, 4456, 4457, 
-  4458, 4459, 4460, 4461, 4462, 4463, 4464, 4465, 
-  4466, 4467, 4468, 4469, 4448, 4372, 4373, 4551, 
-  4552, 4556, 4558, 4563, 4567, 4569, 4380, 4573, 
-  4575, 4381, 4382, 4384, 4386, 4387, 4391, 4393, 
-  4395, 4396, 4397, 4398, 4399, 4402, 4406, 4416, 
-  4423, 4428, 4593, 4594, 4439, 4440, 4441, 4484, 
-  4485, 4488, 4497, 4498, 4500, 4510, 4513, 19977, 
-  22235, 19978, 20013, 19979, 30002, 19993, 19969, 22825, 
-  22320, 40, 4352, 41, 40, 4354, 41, 40, 
-  4355, 41, 40, 4357, 41, 40, 4358, 41, 
-  40, 4359, 41, 40, 4361, 41, 40, 4363, 
-  41, 40, 4364, 41, 40, 4366, 41, 40, 
-  4367, 41, 40, 4368, 41, 40, 4369, 41, 
-  40, 4370, 41, 40, 4352, 4449, 41, 40, 
-  4354, 4449, 41, 40, 4355, 4449, 41, 40, 
-  4357, 4449, 41, 40, 4358, 4449, 41, 40, 
-  4359, 4449, 41, 40, 4361, 4449, 41, 40, 
-  4363, 4449, 41, 40, 4364, 4449, 41, 40, 
-  4366, 4449, 41, 40, 4367, 4449, 41, 40, 
-  4368, 4449, 41, 40, 4369, 4449, 41, 40, 
-  4370, 4449, 41, 40, 4364, 4462, 41, 40, 
-  4363, 4457, 4364, 4453, 4523, 41, 40, 4363, 
-  4457, 4370, 4462, 41, 40, 19968, 41, 40, 
-  20108, 41, 40, 19977, 41, 40, 22235, 41, 
-  40, 20116, 41, 40, 20845, 41, 40, 19971, 
-  41, 40, 20843, 41, 40, 20061, 41, 40, 
-  21313, 41, 40, 26376, 41, 40, 28779, 41, 
-  40, 27700, 41, 40, 26408, 41, 40, 37329, 
-  41, 40, 22303, 41, 40, 26085, 41, 40, 
-  26666, 41, 40, 26377, 41, 40, 31038, 41, 
-  40, 21517, 41, 40, 29305, 41, 40, 36001, 
-  41, 40, 31069, 41, 40, 21172, 41, 40, 
-  20195, 41, 40, 21628, 41, 40, 23398, 41, 
-  40, 30435, 41, 40, 20225, 41, 40, 36039, 
-  41, 40, 21332, 41, 40, 31085, 41, 40, 
-  20241, 41, 40, 33258, 41, 40, 33267, 41, 
-  21839, 24188, 31631, 80, 84, 69, 50, 49, 
-  50, 50, 50, 51, 50, 52, 50, 53, 
-  50, 54, 50, 55, 50, 56, 50, 57, 
-  51, 48, 51, 49, 51, 50, 51, 51, 
-  51, 52, 51, 53, 4352, 4449, 4354, 4449, 
-  4355, 4449, 4357, 4449, 4358, 4449, 4359, 4449, 
-  4361, 4449, 4363, 4449, 4364, 4449, 4366, 4449, 
-  4367, 4449, 4368, 4449, 4369, 4449, 4370, 4449, 
-  4366, 4449, 4535, 4352, 4457, 4364, 4462, 4363, 
-  4468, 4363, 4462, 20116, 20845, 19971, 20061, 26666, 
-  26377, 31038, 21517, 29305, 36001, 31069, 21172, 31192, 
-  30007, 36969, 20778, 21360, 27880, 38917, 20241, 20889, 
-  27491, 24038, 21491, 21307, 23447, 23398, 30435, 20225, 
-  36039, 21332, 22812, 51, 54, 51, 55, 51, 
-  56, 51, 57, 52, 48, 52, 49, 52, 
-  50, 52, 51, 52, 52, 52, 53, 52, 
-  54, 52, 55, 52, 56, 52, 57, 53, 
-  48, 49, 26376, 50, 26376, 51, 26376, 52, 
-  26376, 53, 26376, 54, 26376, 55, 26376, 56, 
-  26376, 57, 26376, 49, 48, 26376, 49, 49, 
-  26376, 49, 50, 26376, 72, 103, 101, 114, 
-  103, 101, 86, 76, 84, 68, 12450, 12452, 
-  12454, 12456, 12458, 12459, 12461, 12463, 12465, 12467, 
-  12469, 12471, 12473, 12475, 12477, 12479, 12481, 12484, 
-  12486, 12488, 12490, 12491, 12492, 12493, 12494, 12495, 
-  12498, 12501, 12504, 12507, 12510, 12511, 12512, 12513, 
-  12514, 12516, 12518, 12520, 12521, 12522, 12523, 12524, 
-  12525, 12527, 12528, 12529, 12530, 20196, 21644, 12450, 
-  12497, 12540, 12488, 12450, 12523, 12501, 12449, 12450, 
-  12531, 12506, 12450, 12450, 12540, 12523, 12452, 12491, 
-  12531, 12464, 12452, 12531, 12481, 12454, 12457, 12531, 
-  12456, 12473, 12463, 12540, 12489, 12456, 12540, 12459, 
-  12540, 12458, 12531, 12473, 12458, 12540, 12512, 12459, 
-  12452, 12522, 12459, 12521, 12483, 12488, 12459, 12525, 
-  12522, 12540, 12460, 12525, 12531, 12460, 12531, 12510, 
-  12462, 12460, 12462, 12491, 12540, 12461, 12517, 12522, 
-  12540, 12462, 12523, 12480, 12540, 12461, 12525, 12461, 
-  12525, 12464, 12521, 12512, 12461, 12525, 12513, 12540, 
-  12488, 12523, 12461, 12525, 12527, 12483, 12488, 12464, 
-  12521, 12512, 12464, 12521, 12512, 12488, 12531, 12463, 
-  12523, 12476, 12452, 12525, 12463, 12525, 12540, 12493, 
-  12465, 12540, 12473, 12467, 12523, 12490, 12467, 12540, 
-  12509, 12469, 12452, 12463, 12523, 12469, 12531, 12481, 
-  12540, 12512, 12471, 12522, 12531, 12464, 12475, 12531, 
-  12481, 12475, 12531, 12488, 12480, 12540, 12473, 12487, 
-  12471, 12489, 12523, 12488, 12531, 12490, 12494, 12494, 
-  12483, 12488, 12495, 12452, 12484, 12497, 12540, 12475, 
-  12531, 12488, 12497, 12540, 12484, 12496, 12540, 12524, 
-  12523, 12500, 12450, 12473, 12488, 12523, 12500, 12463, 
-  12523, 12500, 12467, 12499, 12523, 12501, 12449, 12521, 
-  12483, 12489, 12501, 12451, 12540, 12488, 12502, 12483, 
-  12471, 12455, 12523, 12501, 12521, 12531, 12504, 12463, 
-  12479, 12540, 12523, 12506, 12477, 12506, 12491, 12498, 
-  12504, 12523, 12484, 12506, 12531, 12473, 12506, 12540, 
-  12472, 12505, 12540, 12479, 12509, 12452, 12531, 12488, 
-  12508, 12523, 12488, 12507, 12531, 12509, 12531, 12489, 
-  12507, 12540, 12523, 12507, 12540, 12531, 12510, 12452, 
-  12463, 12525, 12510, 12452, 12523, 12510, 12483, 12495, 
-  12510, 12523, 12463, 12510, 12531, 12471, 12519, 12531, 
-  12511, 12463, 12525, 12531, 12511, 12522, 12511, 12522, 
-  12496, 12540, 12523, 12513, 12460, 12513, 12460, 12488, 
-  12531, 12513, 12540, 12488, 12523, 12516, 12540, 12489, 
-  12516, 12540, 12523, 12518, 12450, 12531, 12522, 12483, 
-  12488, 12523, 12522, 12521, 12523, 12500, 12540, 12523, 
-  12540, 12502, 12523, 12524, 12512, 12524, 12531, 12488, 
-  12466, 12531, 12527, 12483, 12488, 48, 28857, 49, 
-  28857, 50, 28857, 51, 28857, 52, 28857, 53, 
-  28857, 54, 28857, 55, 28857, 56, 28857, 57, 
-  28857, 49, 48, 28857, 49, 49, 28857, 49, 
-  50, 28857, 49, 51, 28857, 49, 52, 28857, 
-  49, 53, 28857, 49, 54, 28857, 49, 55, 
-  28857, 49, 56, 28857, 49, 57, 28857, 50, 
-  48, 28857, 50, 49, 28857, 50, 50, 28857, 
-  50, 51, 28857, 50, 52, 28857, 104, 80, 
-  97, 100, 97, 65, 85, 98, 97, 114, 
-  111, 86, 112, 99, 100, 109, 100, 109, 
-  178, 100, 109, 179, 73, 85, 24179, 25104, 
-  26157, 21644, 22823, 27491, 26126, 27835, 26666, 24335, 
-  20250, 31038, 112, 65, 110, 65, 956, 65, 
-  109, 65, 107, 65, 75, 66, 77, 66, 
-  71, 66, 99, 97, 108, 107, 99, 97, 
-  108, 112, 70, 110, 70, 956, 70, 956, 
-  103, 109, 103, 107, 103, 72, 122, 107, 
-  72, 122, 77, 72, 122, 71, 72, 122, 
-  84, 72, 122, 956, 8467, 109, 8467, 100, 
-  8467, 107, 8467, 102, 109, 110, 109, 956, 
-  109, 109, 109, 99, 109, 107, 109, 109, 
-  109, 178, 99, 109, 178, 109, 178, 107, 
-  109, 178, 109, 109, 179, 99, 109, 179, 
-  109, 179, 107, 109, 179, 109, 8725, 115, 
-  109, 8725, 115, 178, 80, 97, 107, 80, 
-  97, 77, 80, 97, 71, 80, 97, 114, 
-  97, 100, 114, 97, 100, 8725, 115, 114, 
-  97, 100, 8725, 115, 178, 112, 115, 110, 
-  115, 956, 115, 109, 115, 112, 86, 110, 
-  86, 956, 86, 109, 86, 107, 86, 77, 
-  86, 112, 87, 110, 87, 956, 87, 109, 
-  87, 107, 87, 77, 87, 107, 937, 77, 
-  937, 97, 46, 109, 46, 66, 113, 99, 
-  99, 99, 100, 67, 8725, 107, 103, 67, 
-  111, 46, 100, 66, 71, 121, 104, 97, 
-  72, 80, 105, 110, 75, 75, 75, 77, 
-  107, 116, 108, 109, 108, 110, 108, 111, 
-  103, 108, 120, 109, 98, 109, 105, 108, 
-  109, 111, 108, 80, 72, 112, 46, 109, 
-  46, 80, 80, 77, 80, 82, 115, 114, 
-  83, 118, 87, 98, 86, 8725, 109, 65, 
-  8725, 109, 49, 26085, 50, 26085, 51, 26085, 
-  52, 26085, 53, 26085, 54, 26085, 55, 26085, 
-  56, 26085, 57, 26085, 49, 48, 26085, 49, 
-  49, 26085, 49, 50, 26085, 49, 51, 26085, 
-  49, 52, 26085, 49, 53, 26085, 49, 54, 
-  26085, 49, 55, 26085, 49, 56, 26085, 49, 
-  57, 26085, 50, 48, 26085, 50, 49, 26085, 
-  50, 50, 26085, 50, 51, 26085, 50, 52, 
-  26085, 50, 53, 26085, 50, 54, 26085, 50, 
-  55, 26085, 50, 56, 26085, 50, 57, 26085, 
-  51, 48, 26085, 51, 49, 26085, 103, 97, 
-  108, 42561, 42563, 42565, 42567, 42569, 42573, 42575, 
-  42577, 42579, 42581, 42583, 42585, 42587, 42589, 42591, 
-  42593, 42595, 42597, 42599, 42601, 42603, 42605, 42625, 
-  42627, 42629, 42631, 42633, 42635, 42637, 42639, 42641, 
-  42643, 42645, 42647, 42649, 42651, 42787, 42789, 42791, 
-  42793, 42795, 42797, 42799, 42803, 42805, 42807, 42809, 
-  42811, 42813, 42815, 42817, 42819, 42821, 42823, 42825, 
-  42827, 42829, 42831, 42833, 42835, 42837, 42839, 42841, 
-  42843, 42845, 42847, 42849, 42851, 42853, 42855, 42857, 
-  42859, 42861, 42863, 42874, 42876, 7545, 42879, 42881, 
-  42883, 42885, 42887, 42892, 42897, 42899, 42903, 42905, 
-  42907, 42909, 42911, 42913, 42915, 42917, 42919, 42921, 
-  620, 670, 647, 43859, 42933, 42935, 42937, 42939, 
-  42941, 42943, 42947, 42900, 7566, 294, 43831, 43858, 
-  5024, 5025, 5026, 5027, 5028, 5029, 5030, 5031, 
-  5032, 5033, 5034, 5035, 5036, 5037, 5038, 5039, 
-  5040, 5041, 5042, 5043, 5044, 5045, 5046, 5047, 
-  5048, 5049, 5050, 5051, 5052, 5053, 5054, 5055, 
-  5056, 5057, 5058, 5059, 5060, 5061, 5062, 5063, 
-  5064, 5065, 5066, 5067, 5068, 5069, 5070, 5071, 
-  5072, 5073, 5074, 5075, 5076, 5077, 5078, 5079, 
-  5080, 5081, 5082, 5083, 5084, 5085, 5086, 5087, 
-  5088, 5089, 5090, 5091, 5092, 5093, 5094, 5095, 
-  5096, 5097, 5098, 5099, 5100, 5101, 5102, 5103, 
-  35912, 26356, 36040, 28369, 20018, 21477, 22865, 21895, 
-  22856, 25078, 30313, 32645, 34367, 34746, 35064, 37007, 
-  27138, 27931, 28889, 29662, 33853, 37226, 39409, 20098, 
-  21365, 27396, 29211, 34349, 40478, 23888, 28651, 34253, 
-  35172, 25289, 33240, 34847, 24266, 26391, 28010, 29436, 
-  37070, 20358, 20919, 21214, 25796, 27347, 29200, 30439, 
-  34310, 34396, 36335, 38706, 39791, 40442, 30860, 31103, 
-  32160, 33737, 37636, 35542, 22751, 24324, 31840, 32894, 
-  29282, 30922, 36034, 38647, 22744, 23650, 27155, 28122, 
-  28431, 32047, 32311, 38475, 21202, 32907, 20956, 20940, 
-  31260, 32190, 33777, 38517, 35712, 25295, 35582, 20025, 
-  23527, 24594, 29575, 30064, 21271, 30971, 20415, 24489, 
-  19981, 27852, 25976, 32034, 21443, 22622, 30465, 33865, 
-  35498, 27578, 27784, 25342, 33509, 25504, 30053, 20142, 
-  20841, 20937, 26753, 31975, 33391, 35538, 37327, 21237, 
-  21570, 24300, 26053, 28670, 31018, 38317, 39530, 40599, 
-  40654, 26310, 27511, 36706, 24180, 24976, 25088, 25754, 
-  28451, 29001, 29833, 31178, 32244, 32879, 36646, 34030, 
-  36899, 37706, 21015, 21155, 21693, 28872, 35010, 24265, 
-  24565, 25467, 27566, 31806, 29557, 20196, 22265, 23994, 
-  24604, 29618, 29801, 32666, 32838, 37428, 38646, 38728, 
-  38936, 20363, 31150, 37300, 38584, 24801, 20102, 20698, 
-  23534, 23615, 26009, 29134, 30274, 34044, 36988, 26248, 
-  38446, 21129, 26491, 26611, 27969, 28316, 29705, 30041, 
-  30827, 32016, 39006, 25134, 38520, 20523, 23833, 28138, 
-  36650, 24459, 24900, 26647, 38534, 21033, 21519, 23653, 
-  26131, 26446, 26792, 27877, 29702, 30178, 32633, 35023, 
-  35041, 38626, 21311, 28346, 21533, 29136, 29848, 34298, 
-  38563, 40023, 40607, 26519, 28107, 33256, 31520, 31890, 
-  29376, 28825, 35672, 20160, 33590, 21050, 20999, 24230, 
-  25299, 31958, 23429, 27934, 26292, 36667, 38477, 24275, 
-  20800, 21952, 22618, 26228, 20958, 29482, 30410, 31036, 
-  31070, 31077, 31119, 38742, 31934, 34322, 35576, 36920, 
-  37117, 39151, 39164, 39208, 40372, 37086, 38583, 20398, 
-  20711, 20813, 21193, 21220, 21329, 21917, 22022, 22120, 
-  22592, 22696, 23652, 24724, 24936, 24974, 25074, 25935, 
-  26082, 26257, 26757, 28023, 28186, 28450, 29038, 29227, 
-  29730, 30865, 31049, 31048, 31056, 31062, 31117, 31118, 
-  31296, 31361, 31680, 32265, 32321, 32626, 32773, 33261, 
-  33401, 33879, 35088, 35222, 35585, 35641, 36051, 36104, 
-  36790, 38627, 38911, 38971, 24693, 55376, 57070, 33304, 
-  20006, 20917, 20840, 20352, 20805, 20864, 21191, 21242, 
-  21845, 21913, 21986, 22707, 22852, 22868, 23138, 23336, 
-  24274, 24281, 24425, 24493, 24792, 24910, 24840, 24928, 
-  25140, 25540, 25628, 25682, 25942, 26395, 26454, 28379, 
-  28363, 28702, 30631, 29237, 29359, 29809, 29958, 30011, 
-  30237, 30239, 30427, 30452, 30538, 30528, 30924, 31409, 
-  31867, 32091, 32574, 33618, 33775, 34681, 35137, 35206, 
-  35519, 35531, 35565, 35722, 36664, 36978, 37273, 37494, 
-  38524, 38875, 38923, 39698, 55370, 56394, 55370, 56388, 
-  55372, 57301, 15261, 16408, 16441, 55380, 56905, 55383, 
-  56528, 55391, 57043, 40771, 40846, 102, 102, 102, 
-  105, 102, 108, 102, 102, 105, 102, 102, 
-  108, 383, 116, 115, 116, 1396, 1398, 1396, 
-  1381, 1396, 1387, 1406, 1398, 1396, 1389, 1497, 
-  1460, 1522, 1463, 1506, 1492, 1499, 1500, 1501, 
-  1512, 1514, 1513, 1473, 1513, 1474, 64329, 1473, 
-  64329, 1474, 1488, 1463, 1488, 1464, 1488, 1468, 
-  1489, 1468, 1490, 1468, 1491, 1468, 1492, 1468, 
-  1493, 1468, 1494, 1468, 1496, 1468, 1497, 1468, 
-  1498, 1468, 1499, 1468, 1500, 1468, 1502, 1468, 
-  1504, 1468, 1505, 1468, 1507, 1468, 1508, 1468, 
-  1510, 1468, 1511, 1468, 1512, 1468, 1513, 1468, 
-  1514, 1468, 1493, 1465, 1489, 1471, 1499, 1471, 
-  1508, 1471, 1488, 1500, 1649, 1659, 1662, 1664, 
-  1658, 1663, 1657, 1700, 1702, 1668, 1667, 1670, 
-  1671, 1677, 1676, 1678, 1672, 1688, 1681, 1705, 
-  1711, 1715, 1713, 1722, 1723, 1728, 1729, 1726, 
-  1746, 1747, 1709, 1735, 1734, 1736, 1655, 1739, 
-  1733, 1737, 1744, 1609, 1574, 1575, 1574, 1749, 
-  1574, 1608, 1574, 1735, 1574, 1734, 1574, 1736, 
-  1574, 1744, 1574, 1609, 1740, 1574, 1580, 1574, 
-  1581, 1574, 1605, 1574, 1610, 1576, 1580, 1576, 
-  1581, 1576, 1582, 1576, 1605, 1576, 1609, 1576, 
-  1610, 1578, 1580, 1578, 1581, 1578, 1582, 1578, 
-  1605, 1578, 1609, 1578, 1610, 1579, 1580, 1579, 
-  1605, 1579, 1609, 1579, 1610, 1580, 1581, 1580, 
-  1605, 1581, 1580, 1581, 1605, 1582, 1580, 1582, 
-  1581, 1582, 1605, 1587, 1580, 1587, 1581, 1587, 
-  1582, 1587, 1605, 1589, 1581, 1589, 1605, 1590, 
-  1580, 1590, 1581, 1590, 1582, 1590, 1605, 1591, 
-  1581, 1591, 1605, 1592, 1605, 1593, 1580, 1593, 
-  1605, 1594, 1580, 1594, 1605, 1601, 1580, 1601, 
-  1581, 1601, 1582, 1601, 1605, 1601, 1609, 1601, 
-  1610, 1602, 1581, 1602, 1605, 1602, 1609, 1602, 
-  1610, 1603, 1575, 1603, 1580, 1603, 1581, 1603, 
-  1582, 1603, 1604, 1603, 1605, 1603, 1609, 1603, 
-  1610, 1604, 1580, 1604, 1581, 1604, 1582, 1604, 
-  1605, 1604, 1609, 1604, 1610, 1605, 1580, 1605, 
-  1581, 1605, 1582, 1605, 1605, 1605, 1609, 1605, 
-  1610, 1606, 1580, 1606, 1581, 1606, 1582, 1606, 
-  1605, 1606, 1609, 1606, 1610, 1607, 1580, 1607, 
-  1605, 1607, 1609, 1607, 1610, 1610, 1580, 1610, 
-  1581, 1610, 1582, 1610, 1605, 1610, 1609, 1610, 
-  1610, 1584, 1648, 1585, 1648, 1609, 1648, 32, 
-  1612, 1617, 32, 1613, 1617, 32, 1614, 1617, 
-  32, 1615, 1617, 32, 1616, 1617, 32, 1617, 
-  1648, 1574, 1585, 1574, 1586, 1574, 1606, 1576, 
-  1585, 1576, 1586, 1576, 1606, 1578, 1585, 1578, 
-  1586, 1578, 1606, 1579, 1585, 1579, 1586, 1579, 
-  1606, 1605, 1575, 1606, 1585, 1606, 1586, 1606, 
-  1606, 1610, 1585, 1610, 1586, 1610, 1606, 1574, 
-  1582, 1574, 1607, 1576, 1607, 1578, 1607, 1589, 
-  1582, 1604, 1607, 1606, 1607, 1607, 1648, 1610, 
-  1607, 1579, 1607, 1587, 1607, 1588, 1605, 1588, 
-  1607, 1600, 1614, 1617, 1600, 1615, 1617, 1600, 
-  1616, 1617, 1591, 1609, 1591, 1610, 1593, 1609, 
-  1593, 1610, 1594, 1609, 1594, 1610, 1587, 1609, 
-  1587, 1610, 1588, 1609, 1588, 1610, 1581, 1609, 
-  1581, 1610, 1580, 1609, 1580, 1610, 1582, 1609, 
-  1582, 1610, 1589, 1609, 1589, 1610, 1590, 1609, 
-  1590, 1610, 1588, 1580, 1588, 1581, 1588, 1582, 
-  1588, 1585, 1587, 1585, 1589, 1585, 1590, 1585, 
-  1575, 1611, 1578, 1580, 1605, 1578, 1581, 1580, 
-  1578, 1581, 1605, 1578, 1582, 1605, 1578, 1605, 
-  1580, 1578, 1605, 1581, 1578, 1605, 1582, 1580, 
-  1605, 1581, 1581, 1605, 1610, 1581, 1605, 1609, 
-  1587, 1581, 1580, 1587, 1580, 1581, 1587, 1580, 
-  1609, 1587, 1605, 1581, 1587, 1605, 1580, 1587, 
-  1605, 1605, 1589, 1581, 1581, 1589, 1605, 1605, 
-  1588, 1581, 1605, 1588, 1580, 1610, 1588, 1605, 
-  1582, 1588, 1605, 1605, 1590, 1581, 1609, 1590, 
-  1582, 1605, 1591, 1605, 1581, 1591, 1605, 1605, 
-  1591, 1605, 1610, 1593, 1580, 1605, 1593, 1605, 
-  1605, 1593, 1605, 1609, 1594, 1605, 1605, 1594, 
-  1605, 1610, 1594, 1605, 1609, 1601, 1582, 1605, 
-  1602, 1605, 1581, 1602, 1605, 1605, 1604, 1581, 
-  1605, 1604, 1581, 1610, 1604, 1581, 1609, 1604, 
-  1580, 1580, 1604, 1582, 1605, 1604, 1605, 1581, 
-  1605, 1581, 1580, 1605, 1581, 1605, 1605, 1581, 
-  1610, 1605, 1580, 1581, 1605, 1580, 1605, 1605, 
-  1582, 1580, 1605, 1582, 1605, 1605, 1580, 1582, 
-  1607, 1605, 1580, 1607, 1605, 1605, 1606, 1581, 
-  1605, 1606, 1581, 1609, 1606, 1580, 1605, 1606, 
-  1580, 1609, 1606, 1605, 1610, 1606, 1605, 1609, 
-  1610, 1605, 1605, 1576, 1582, 1610, 1578, 1580, 
-  1610, 1578, 1580, 1609, 1578, 1582, 1610, 1578, 
-  1582, 1609, 1578, 1605, 1610, 1578, 1605, 1609, 
-  1580, 1605, 1610, 1580, 1581, 1609, 1580, 1605, 
-  1609, 1587, 1582, 1609, 1589, 1581, 1610, 1588, 
-  1581, 1610, 1590, 1581, 1610, 1604, 1580, 1610, 
-  1604, 1605, 1610, 1610, 1581, 1610, 1610, 1580, 
-  1610, 1610, 1605, 1610, 1605, 1605, 1610, 1602, 
-  1605, 1610, 1606, 1581, 1610, 1593, 1605, 1610, 
-  1603, 1605, 1610, 1606, 1580, 1581, 1605, 1582, 
-  1610, 1604, 1580, 1605, 1603, 1605, 1605, 1580, 
-  1581, 1610, 1581, 1580, 1610, 1605, 1580, 1610, 
-  1601, 1605, 1610, 1576, 1581, 1610, 1587, 1582, 
-  1610, 1606, 1580, 1610, 1589, 1604, 1746, 1602, 
-  1604, 1746, 1575, 1604, 1604, 1607, 1575, 1603, 
-  1576, 1585, 1605, 1581, 1605, 1583, 1589, 1604, 
-  1593, 1605, 1585, 1587, 1608, 1604, 1593, 1604, 
-  1610, 1607, 1608, 1587, 1604, 1605, 1589, 1604, 
-  1609, 17, 1589, 1604, 1609, 32, 1575, 1604, 
-  1604, 1607, 32, 1593, 1604, 1610, 1607, 32, 
-  1608, 1587, 1604, 1605, 7, 1580, 1604, 32, 
-  1580, 1604, 1575, 1604, 1607, 1585, 1740, 1575, 
-  1604, 44, 12289, 12290, 58, 33, 63, 12310, 
-  12311, 8230, 8229, 8212, 8211, 95, 123, 125, 
-  12308, 12309, 12304, 12305, 12298, 12299, 12300, 12301, 
-  12302, 12303, 91, 93, 8254, 35, 38, 42, 
-  45, 60, 62, 92, 36, 37, 64, 32, 
-  1611, 1600, 1611, 32, 1612, 32, 1613, 32, 
-  1614, 1600, 1614, 32, 1615, 1600, 1615, 32, 
-  1616, 1600, 1616, 32, 1617, 1600, 1617, 32, 
-  1618, 1600, 1618, 1569, 1570, 1571, 1572, 1573, 
-  1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 
-  1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 
-  1590, 1591, 1592, 1593, 1594, 1601, 1602, 1603, 
-  1604, 1605, 1606, 1607, 1608, 1610, 1604, 1570, 
-  1604, 1571, 1604, 1573, 1604, 1575, 34, 39, 
-  47, 65345, 65346, 65347, 65348, 65349, 65350, 65351, 
-  65352, 65353, 65354, 65355, 65356, 65357, 65358, 65359, 
-  65360, 65361, 65362, 65363, 65364, 65365, 65366, 65367, 
-  65368, 65369, 65370, 94, 124, 126, 10629, 10630, 
-  12539, 12449, 12451, 12453, 12455, 12457, 12515, 12517, 
-  12519, 12483, 12540, 12531, 12441, 12442, 12644, 12593, 
-  12594, 12595, 12596, 12597, 12598, 12599, 12600, 12601, 
-  12602, 12603, 12604, 12605, 12606, 12607, 12608, 12609, 
-  12610, 12611, 12612, 12613, 12614, 12615, 12616, 12617, 
-  12618, 12619, 12620, 12621, 12622, 12623, 12624, 12625, 
-  12626, 12627, 12628, 12629, 12630, 12631, 12632, 12633, 
-  12634, 12635, 12636, 12637, 12638, 12639, 12640, 12641, 
-  12642, 12643, 162, 163, 172, 175, 166, 165, 
-  8361, 9474, 8592, 8593, 8594, 8595, 9632, 9675, 
-  55297, 56360, 55297, 56361, 55297, 56362, 55297, 56363, 
-  55297, 56364, 55297, 56365, 55297, 56366, 55297, 56367, 
-  55297, 56368, 55297, 56369, 55297, 56370, 55297, 56371, 
-  55297, 56372, 55297, 56373, 55297, 56374, 55297, 56375, 
-  55297, 56376, 55297, 56377, 55297, 56378, 55297, 56379, 
-  55297, 56380, 55297, 56381, 55297, 56382, 55297, 56383, 
-  55297, 56384, 55297, 56385, 55297, 56386, 55297, 56387, 
-  55297, 56388, 55297, 56389, 55297, 56390, 55297, 56391, 
-  55297, 56392, 55297, 56393, 55297, 56394, 55297, 56395, 
-  55297, 56396, 55297, 56397, 55297, 56398, 55297, 56399, 
-  55297, 56536, 55297, 56537, 55297, 56538, 55297, 56539, 
-  55297, 56540, 55297, 56541, 55297, 56542, 55297, 56543, 
-  55297, 56544, 55297, 56545, 55297, 56546, 55297, 56547, 
-  55297, 56548, 55297, 56549, 55297, 56550, 55297, 56551, 
-  55297, 56552, 55297, 56553, 55297, 56554, 55297, 56555, 
-  55297, 56556, 55297, 56557, 55297, 56558, 55297, 56559, 
-  55297, 56560, 55297, 56561, 55297, 56562, 55297, 56563, 
-  55297, 56564, 55297, 56565, 55297, 56566, 55297, 56567, 
-  55297, 56568, 55297, 56569, 55297, 56570, 55297, 56571, 
-  55299, 56512, 55299, 56513, 55299, 56514, 55299, 56515, 
-  55299, 56516, 55299, 56517, 55299, 56518, 55299, 56519, 
-  55299, 56520, 55299, 56521, 55299, 56522, 55299, 56523, 
-  55299, 56524, 55299, 56525, 55299, 56526, 55299, 56527, 
-  55299, 56528, 55299, 56529, 55299, 56530, 55299, 56531, 
-  55299, 56532, 55299, 56533, 55299, 56534, 55299, 56535, 
-  55299, 56536, 55299, 56537, 55299, 56538, 55299, 56539, 
-  55299, 56540, 55299, 56541, 55299, 56542, 55299, 56543, 
-  55299, 56544, 55299, 56545, 55299, 56546, 55299, 56547, 
-  55299, 56548, 55299, 56549, 55299, 56550, 55299, 56551, 
-  55299, 56552, 55299, 56553, 55299, 56554, 55299, 56555, 
-  55299, 56556, 55299, 56557, 55299, 56558, 55299, 56559, 
-  55299, 56560, 55299, 56561, 55299, 56562, 55300, 56473, 
-  55300, 56506, 55300, 56475, 55300, 56506, 55300, 56485, 
-  55300, 56506, 55300, 56625, 55300, 56615, 55300, 56626, 
-  55300, 56615, 55300, 57159, 55300, 57150, 55300, 57159, 
-  55300, 57175, 55301, 56505, 55301, 56506, 55301, 56505, 
-  55301, 56496, 55301, 56505, 55301, 56509, 55301, 56760, 
-  55301, 56751, 55301, 56761, 55301, 56751, 55302, 56512, 
-  55302, 56513, 55302, 56514, 55302, 56515, 55302, 56516, 
-  55302, 56517, 55302, 56518, 55302, 56519, 55302, 56520, 
-  55302, 56521, 55302, 56522, 55302, 56523, 55302, 56524, 
-  55302, 56525, 55302, 56526, 55302, 56527, 55302, 56528, 
-  55302, 56529, 55302, 56530, 55302, 56531, 55302, 56532, 
-  55302, 56533, 55302, 56534, 55302, 56535, 55302, 56536, 
-  55302, 56537, 55302, 56538, 55302, 56539, 55302, 56540, 
-  55302, 56541, 55302, 56542, 55302, 56543, 55323, 56928, 
-  55323, 56929, 55323, 56930, 55323, 56931, 55323, 56932, 
-  55323, 56933, 55323, 56934, 55323, 56935, 55323, 56936, 
-  55323, 56937, 55323, 56938, 55323, 56939, 55323, 56940, 
-  55323, 56941, 55323, 56942, 55323, 56943, 55323, 56944, 
-  55323, 56945, 55323, 56946, 55323, 56947, 55323, 56948, 
-  55323, 56949, 55323, 56950, 55323, 56951, 55323, 56952, 
-  55323, 56953, 55323, 56954, 55323, 56955, 55323, 56956, 
-  55323, 56957, 55323, 56958, 55323, 56959, 55348, 56663, 
-  55348, 56677, 55348, 56664, 55348, 56677, 55348, 56671, 
-  55348, 56686, 55348, 56671, 55348, 56687, 55348, 56671, 
-  55348, 56688, 55348, 56671, 55348, 56689, 55348, 56671, 
-  55348, 56690, 55348, 56761, 55348, 56677, 55348, 56762, 
-  55348, 56677, 55348, 56763, 55348, 56686, 55348, 56764, 
-  55348, 56686, 55348, 56763, 55348, 56687, 55348, 56764, 
-  55348, 56687, 305, 567, 913, 914, 916, 917, 
-  918, 919, 921, 922, 923, 924, 925, 926, 
-  927, 929, 1012, 932, 934, 935, 936, 8711, 
-  8706, 1013, 977, 1008, 981, 1009, 982, 988, 
-  55354, 56610, 55354, 56611, 55354, 56612, 55354, 56613, 
-  55354, 56614, 55354, 56615, 55354, 56616, 55354, 56617, 
-  55354, 56618, 55354, 56619, 55354, 56620, 55354, 56621, 
-  55354, 56622, 55354, 56623, 55354, 56624, 55354, 56625, 
-  55354, 56626, 55354, 56627, 55354, 56628, 55354, 56629, 
-  55354, 56630, 55354, 56631, 55354, 56632, 55354, 56633, 
-  55354, 56634, 55354, 56635, 55354, 56636, 55354, 56637, 
-  55354, 56638, 55354, 56639, 55354, 56640, 55354, 56641, 
-  55354, 56642, 55354, 56643, 1646, 1697, 1647, 48, 
-  46, 48, 44, 49, 44, 50, 44, 51, 
-  44, 52, 44, 53, 44, 54, 44, 55, 
-  44, 56, 44, 57, 44, 40, 65, 41, 
-  40, 66, 41, 40, 67, 41, 40, 68, 
-  41, 40, 69, 41, 40, 70, 41, 40, 
-  71, 41, 40, 72, 41, 40, 73, 41, 
-  40, 74, 41, 40, 75, 41, 40, 76, 
-  41, 40, 77, 41, 40, 78, 41, 40, 
-  79, 41, 40, 80, 41, 40, 81, 41, 
-  40, 82, 41, 40, 83, 41, 40, 84, 
-  41, 40, 85, 41, 40, 86, 41, 40, 
-  87, 41, 40, 88, 41, 40, 89, 41, 
-  40, 90, 41, 12308, 83, 12309, 67, 68, 
-  87, 90, 72, 86, 83, 68, 83, 83, 
-  80, 80, 86, 87, 67, 77, 67, 77, 
-  68, 77, 82, 68, 74, 12411, 12363, 12467, 
-  12467, 23383, 21452, 12487, 22810, 35299, 20132, 26144, 
-  28961, 21069, 24460, 20877, 26032, 21021, 32066, 36009, 
-  22768, 21561, 28436, 25237, 25429, 36938, 25351, 25171, 
-  31105, 31354, 21512, 28288, 30003, 21106, 21942, 37197, 
-  12308, 26412, 12309, 12308, 19977, 12309, 12308, 20108, 
-  12309, 12308, 23433, 12309, 12308, 28857, 12309, 12308, 
-  25171, 12309, 12308, 30423, 12309, 12308, 21213, 12309, 
-  12308, 25943, 12309, 24471, 21487, 20029, 20024, 20033, 
-  55360, 56610, 20320, 20411, 20482, 20602, 20633, 20687, 
-  13470, 55361, 56890, 20820, 20836, 20855, 55361, 56604, 
-  13497, 20839, 55361, 56651, 20887, 20900, 20172, 20908, 
-  55396, 56799, 20995, 13535, 21051, 21062, 21111, 13589, 
-  21253, 21254, 21321, 21338, 21363, 21373, 21375, 55362, 
-  56876, 28784, 21450, 21471, 55362, 57187, 21483, 21489, 
-  21510, 21662, 21560, 21576, 21608, 21666, 21750, 21776, 
-  21843, 21859, 21892, 21931, 21939, 21954, 22294, 22295, 
-  22097, 22132, 22766, 22478, 22516, 22541, 22411, 22578, 
-  22577, 22700, 55365, 56548, 22770, 22775, 22790, 22818, 
-  22882, 55365, 57000, 55365, 57066, 23020, 23067, 23079, 
-  23000, 23142, 14062, 14076, 23304, 23358, 55366, 56776, 
-  23491, 23512, 23539, 55366, 57112, 23551, 23558, 24403, 
-  14209, 23648, 23744, 23693, 55367, 56804, 23875, 55367, 
-  56806, 23918, 23915, 23932, 24033, 24034, 14383, 24061, 
-  24104, 24125, 24169, 14434, 55368, 56707, 14460, 24240, 
-  24243, 24246, 55400, 57234, 55368, 57137, 33281, 24354, 
-  14535, 55372, 57016, 55384, 56794, 24418, 24427, 14563, 
-  24474, 24525, 24535, 24569, 24705, 14650, 14620, 55369, 
-  57044, 24775, 24904, 24908, 24954, 25010, 24996, 25007, 
-  25054, 25104, 25115, 25181, 25265, 25300, 25424, 55370, 
-  57100, 25405, 25340, 25448, 25475, 25572, 55370, 57329, 
-  25634, 25541, 25513, 14894, 25705, 25726, 25757, 25719, 
-  14956, 25964, 55372, 56330, 26083, 26360, 26185, 15129, 
-  15112, 15076, 20882, 20885, 26368, 26268, 32941, 17369, 
-  26401, 26462, 26451, 55372, 57283, 15177, 26618, 26501, 
-  26706, 55373, 56429, 26766, 26655, 26900, 26946, 27043, 
-  27114, 27304, 55373, 56995, 27355, 15384, 27425, 55374, 
-  56487, 27476, 15438, 27506, 27551, 27579, 55374, 56973, 
-  55367, 56587, 55374, 57082, 27726, 55375, 56508, 27839, 
-  27853, 27751, 27926, 27966, 28009, 28024, 28037, 55375, 
-  56606, 27956, 28207, 28270, 15667, 28359, 55375, 57041, 
-  28153, 28526, 55375, 57182, 55375, 57230, 28614, 28729, 
-  28699, 15766, 28746, 28797, 28791, 28845, 55361, 56613, 
-  28997, 55376, 56931, 29084, 55376, 57259, 29224, 29264, 
-  55377, 56840, 29312, 29333, 55377, 57141, 55378, 56340, 
-  29562, 29579, 16044, 29605, 16056, 29767, 29788, 29829, 
-  29898, 16155, 29988, 55379, 56374, 30014, 55379, 56466, 
-  55368, 56735, 30224, 55379, 57249, 55379, 57272, 55380, 
-  56388, 16380, 16392, 55380, 56563, 55380, 56562, 55380, 
-  56601, 55380, 56627, 30494, 30495, 30603, 16454, 16534, 
-  55381, 56349, 30798, 16611, 55381, 56870, 55381, 56986, 
-  55381, 57029, 31211, 16687, 31306, 31311, 55382, 56700, 
-  55382, 56999, 31470, 16898, 55382, 57259, 31686, 31689, 
-  16935, 55383, 56448, 31954, 17056, 31976, 31971, 32000, 
-  55383, 57222, 32099, 17153, 32199, 32258, 32325, 17204, 
-  55384, 56872, 55384, 56903, 17241, 55384, 57049, 32634, 
-  55384, 57150, 32661, 32762, 55385, 56538, 55385, 56611, 
-  32864, 55385, 56744, 32880, 55372, 57183, 17365, 32946, 
-  33027, 17419, 33086, 23221, 55385, 57255, 55385, 57269, 
-  55372, 57235, 55372, 57244, 33284, 36766, 17515, 33425, 
-  33419, 33437, 21171, 33457, 33459, 33469, 33510, 55386, 
-  57148, 33565, 33635, 33709, 33571, 33725, 33767, 33619, 
-  33738, 33740, 33756, 55387, 56374, 55387, 56683, 55387, 
-  56533, 17707, 34033, 34035, 34070, 55388, 57290, 34148, 
-  55387, 57132, 17757, 17761, 55387, 57265, 55388, 56530, 
-  17771, 34384, 34407, 34409, 34473, 34440, 34574, 34530, 
-  34600, 34667, 34694, 17879, 34785, 34817, 17913, 34912, 
-  55389, 56935, 35031, 35038, 17973, 35066, 13499, 55390, 
-  56494, 55390, 56678, 18110, 18119, 35488, 55391, 56488, 
-  36011, 36033, 36123, 36215, 55391, 57135, 55362, 56324, 
-  36299, 36284, 36336, 55362, 56542, 36564, 55393, 56786, 
-  55393, 56813, 37012, 37105, 37137, 55393, 57134, 37147, 
-  37432, 37591, 37592, 37500, 37881, 37909, 55394, 57338, 
-  38283, 18837, 38327, 55395, 56695, 18918, 38595, 23986, 
-  38691, 55396, 56645, 55396, 56858, 19054, 19062, 38880, 
-  55397, 56330, 19122, 55397, 56470, 38953, 55397, 56758, 
-  39138, 19251, 39209, 39335, 39362, 39422, 19406, 55398, 
-  57136, 40000, 40189, 19662, 19693, 40295, 55400, 56526, 
-  19704, 55400, 56581, 55400, 56846, 55400, 56977, 19798, 
-  40702, 40709, 40719, 40726, 55401, 56832, 7838, 192, 
-  193, 194, 195, 196, 199, 200, 201, 202, 
-  203, 204, 205, 206, 207, 208, 209, 210, 
-  211, 212, 213, 214, 216, 217, 218, 219, 
-  220, 221, 222, 376, 256, 258, 260, 262, 
-  264, 266, 268, 270, 272, 274, 276, 278, 
-  280, 282, 284, 286, 288, 290, 292, 296, 
-  298, 300, 302, 306, 308, 310, 313, 315, 
-  317, 319, 321, 323, 325, 327, 330, 332, 
-  334, 336, 338, 340, 342, 344, 346, 348, 
-  350, 352, 354, 356, 358, 360, 362, 364, 
-  366, 368, 370, 372, 374, 377, 379, 381, 
-  579, 386, 388, 391, 395, 401, 502, 408, 
-  573, 544, 416, 418, 420, 423, 428, 431, 
-  435, 437, 440, 444, 503, 453, 452, 456, 
-  455, 459, 458, 461, 463, 465, 467, 469, 
-  471, 473, 475, 478, 480, 482, 484, 486, 
-  488, 490, 492, 494, 498, 497, 500, 504, 
-  506, 508, 510, 512, 514, 516, 518, 520, 
-  522, 524, 526, 528, 530, 532, 534, 536, 
-  538, 540, 542, 548, 550, 552, 554, 556, 
-  558, 560, 562, 571, 11390, 11391, 577, 582, 
-  584, 586, 588, 590, 11375, 11373, 11376, 385, 
-  390, 393, 394, 399, 42923, 403, 42924, 404, 
-  42893, 42922, 407, 406, 42926, 11362, 42925, 412, 
-  11374, 413, 415, 11364, 422, 42949, 425, 42929, 
-  430, 580, 433, 434, 581, 439, 42930, 42928, 
-  880, 882, 886, 1021, 1022, 1023, 938, 939, 
-  975, 984, 986, 990, 992, 994, 996, 998, 
-  1000, 1002, 1004, 1006, 1017, 895, 1015, 1018, 
-  1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 
-  1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 
-  1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 
-  1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 
-  1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 
-  1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 
-  1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, 
-  1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 
-  1152, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 
-  1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190, 
-  1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, 
-  1208, 1210, 1212, 1214, 1217, 1219, 1221, 1223, 
-  1225, 1227, 1229, 1216, 1232, 1234, 1236, 1238, 
-  1240, 1242, 1244, 1246, 1248, 1250, 1252, 1254, 
-  1256, 1258, 1260, 1262, 1264, 1266, 1268, 1270, 
-  1272, 1274, 1276, 1278, 1280, 1282, 1284, 1286, 
-  1288, 1290, 1292, 1294, 1296, 1298, 1300, 1302, 
-  1304, 1306, 1308, 1310, 1312, 1314, 1316, 1318, 
-  1320, 1322, 1324, 1326, 1329, 1330, 1331, 1332, 
-  1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 
-  1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 
-  1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 
-  1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 
-  1365, 1366, 7312, 7313, 7314, 7315, 7316, 7317, 
-  7318, 7319, 7320, 7321, 7322, 7323, 7324, 7325, 
-  7326, 7327, 7328, 7329, 7330, 7331, 7332, 7333, 
-  7334, 7335, 7336, 7337, 7338, 7339, 7340, 7341, 
-  7342, 7343, 7344, 7345, 7346, 7347, 7348, 7349, 
-  7350, 7351, 7352, 7353, 7354, 7357, 7358, 7359, 
-  43888, 43889, 43890, 43891, 43892, 43893, 43894, 43895, 
-  43896, 43897, 43898, 43899, 43900, 43901, 43902, 43903, 
-  43904, 43905, 43906, 43907, 43908, 43909, 43910, 43911, 
-  43912, 43913, 43914, 43915, 43916, 43917, 43918, 43919, 
-  43920, 43921, 43922, 43923, 43924, 43925, 43926, 43927, 
-  43928, 43929, 43930, 43931, 43932, 43933, 43934, 43935, 
-  43936, 43937, 43938, 43939, 43940, 43941, 43942, 43943, 
-  43944, 43945, 43946, 43947, 43948, 43949, 43950, 43951, 
-  43952, 43953, 43954, 43955, 43956, 43957, 43958, 43959, 
-  43960, 43961, 43962, 43963, 43964, 43965, 43966, 43967, 
-  5112, 5113, 5114, 5115, 5116, 5117, 42570, 42877, 
-  11363, 42950, 7680, 7682, 7684, 7686, 7688, 7690, 
-  7692, 7694, 7696, 7698, 7700, 7702, 7704, 7706, 
-  7708, 7710, 7712, 7714, 7716, 7718, 7720, 7722, 
-  7724, 7726, 7728, 7730, 7732, 7734, 7736, 7738, 
-  7740, 7742, 7744, 7746, 7748, 7750, 7752, 7754, 
-  7756, 7758, 7760, 7762, 7764, 7766, 7768, 7770, 
-  7772, 7774, 7776, 7778, 7780, 7782, 7784, 7786, 
-  7788, 7790, 7792, 7794, 7796, 7798, 7800, 7802, 
-  7804, 7806, 7808, 7810, 7812, 7814, 7816, 7818, 
-  7820, 7822, 7824, 7826, 7828, 223, 7840, 7842, 
-  7844, 7846, 7848, 7850, 7852, 7854, 7856, 7858, 
-  7860, 7862, 7864, 7866, 7868, 7870, 7872, 7874, 
-  7876, 7878, 7880, 7882, 7884, 7886, 7888, 7890, 
-  7892, 7894, 7896, 7898, 7900, 7902, 7904, 7906, 
-  7908, 7910, 7912, 7914, 7916, 7918, 7920, 7922, 
-  7924, 7926, 7928, 7930, 7932, 7934, 7944, 7945, 
-  7946, 7947, 7948, 7949, 7950, 7951, 7960, 7961, 
-  7962, 7963, 7964, 7965, 7976, 7977, 7978, 7979, 
-  7980, 7981, 7982, 7983, 7992, 7993, 7994, 7995, 
-  7996, 7997, 7998, 7999, 8008, 8009, 8010, 8011, 
-  8012, 8013, 8025, 8027, 8029, 8031, 8040, 8041, 
-  8042, 8043, 8044, 8045, 8046, 8047, 8122, 8123, 
-  8136, 8137, 8138, 8139, 8154, 8155, 8184, 8185, 
-  8170, 8171, 8186, 8187, 8072, 8073, 8074, 8075, 
-  8076, 8077, 8078, 8079, 8064, 8065, 8066, 8067, 
-  8068, 8069, 8070, 8071, 8088, 8089, 8090, 8091, 
-  8092, 8093, 8094, 8095, 8080, 8081, 8082, 8083, 
-  8084, 8085, 8086, 8087, 8104, 8105, 8106, 8107, 
-  8108, 8109, 8110, 8111, 8096, 8097, 8098, 8099, 
-  8100, 8101, 8102, 8103, 8120, 8121, 8124, 8115, 
-  8140, 8131, 8152, 8153, 8168, 8169, 8172, 8188, 
-  8179, 8498, 8544, 8545, 8546, 8547, 8548, 8549, 
-  8550, 8551, 8552, 8553, 8554, 8555, 8556, 8557, 
-  8558, 8559, 8579, 9398, 9399, 9400, 9401, 9402, 
-  9403, 9404, 9405, 9406, 9407, 9408, 9409, 9410, 
-  9411, 9412, 9413, 9414, 9415, 9416, 9417, 9418, 
-  9419, 9420, 9421, 9422, 9423, 11264, 11265, 11266, 
-  11267, 11268, 11269, 11270, 11271, 11272, 11273, 11274, 
-  11275, 11276, 11277, 11278, 11279, 11280, 11281, 11282, 
-  11283, 11284, 11285, 11286, 11287, 11288, 11289, 11290, 
-  11291, 11292, 11293, 11294, 11295, 11296, 11297, 11298, 
-  11299, 11300, 11301, 11302, 11303, 11304, 11305, 11306, 
-  11307, 11308, 11309, 11310, 11360, 570, 574, 11367, 
-  11369, 11371, 11378, 11381, 11392, 11394, 11396, 11398, 
-  11400, 11402, 11404, 11406, 11408, 11410, 11412, 11414, 
-  11416, 11418, 11420, 11422, 11424, 11426, 11428, 11430, 
-  11432, 11434, 11436, 11438, 11440, 11442, 11444, 11446, 
-  11448, 11450, 11452, 11454, 11456, 11458, 11460, 11462, 
-  11464, 11466, 11468, 11470, 11472, 11474, 11476, 11478, 
-  11480, 11482, 11484, 11486, 11488, 11490, 11499, 11501, 
-  11506, 4256, 4257, 4258, 4259, 4260, 4261, 4262, 
-  4263, 4264, 4265, 4266, 4267, 4268, 4269, 4270, 
-  4271, 4272, 4273, 4274, 4275, 4276, 4277, 4278, 
-  4279, 4280, 4281, 4282, 4283, 4284, 4285, 4286, 
-  4287, 4288, 4289, 4290, 4291, 4292, 4293, 4295, 
-  4301, 42560, 42562, 42564, 42566, 42568, 42572, 42574, 
-  42576, 42578, 42580, 42582, 42584, 42586, 42588, 42590, 
-  42592, 42594, 42596, 42598, 42600, 42602, 42604, 42624, 
-  42626, 42628, 42630, 42632, 42634, 42636, 42638, 42640, 
-  42642, 42644, 42646, 42648, 42650, 42786, 42788, 42790, 
-  42792, 42794, 42796, 42798, 42802, 42804, 42806, 42808, 
-  42810, 42812, 42814, 42816, 42818, 42820, 42822, 42824, 
-  42826, 42828, 42830, 42832, 42834, 42836, 42838, 42840, 
-  42842, 42844, 42846, 42848, 42850, 42852, 42854, 42856, 
-  42858, 42860, 42862, 42873, 42875, 42878, 42880, 42882, 
-  42884, 42886, 42891, 42896, 42898, 42948, 42902, 42904, 
-  42906, 42908, 42910, 42912, 42914, 42916, 42918, 42920, 
-  42932, 42934, 42936, 42938, 42940, 42942, 42946, 42931, 
-  65313, 65314, 65315, 65316, 65317, 65318, 65319, 65320, 
-  65321, 65322, 65323, 65324, 65325, 65326, 65327, 65328, 
-  65329, 65330, 65331, 65332, 65333, 65334, 65335, 65336, 
-  65337, 65338, 55297, 56320, 55297, 56321, 55297, 56322, 
-  55297, 56323, 55297, 56324, 55297, 56325, 55297, 56326, 
-  55297, 56327, 55297, 56328, 55297, 56329, 55297, 56330, 
-  55297, 56331, 55297, 56332, 55297, 56333, 55297, 56334, 
-  55297, 56335, 55297, 56336, 55297, 56337, 55297, 56338, 
-  55297, 56339, 55297, 56340, 55297, 56341, 55297, 56342, 
-  55297, 56343, 55297, 56344, 55297, 56345, 55297, 56346, 
-  55297, 56347, 55297, 56348, 55297, 56349, 55297, 56350, 
-  55297, 56351, 55297, 56352, 55297, 56353, 55297, 56354, 
-  55297, 56355, 55297, 56356, 55297, 56357, 55297, 56358, 
-  55297, 56359, 55297, 56496, 55297, 56497, 55297, 56498, 
-  55297, 56499, 55297, 56500, 55297, 56501, 55297, 56502, 
-  55297, 56503, 55297, 56504, 55297, 56505, 55297, 56506, 
-  55297, 56507, 55297, 56508, 55297, 56509, 55297, 56510, 
-  55297, 56511, 55297, 56512, 55297, 56513, 55297, 56514, 
-  55297, 56515, 55297, 56516, 55297, 56517, 55297, 56518, 
-  55297, 56519, 55297, 56520, 55297, 56521, 55297, 56522, 
-  55297, 56523, 55297, 56524, 55297, 56525, 55297, 56526, 
-  55297, 56527, 55297, 56528, 55297, 56529, 55297, 56530, 
-  55297, 56531, 55299, 56448, 55299, 56449, 55299, 56450, 
-  55299, 56451, 55299, 56452, 55299, 56453, 55299, 56454, 
-  55299, 56455, 55299, 56456, 55299, 56457, 55299, 56458, 
-  55299, 56459, 55299, 56460, 55299, 56461, 55299, 56462, 
-  55299, 56463, 55299, 56464, 55299, 56465, 55299, 56466, 
-  55299, 56467, 55299, 56468, 55299, 56469, 55299, 56470, 
-  55299, 56471, 55299, 56472, 55299, 56473, 55299, 56474, 
-  55299, 56475, 55299, 56476, 55299, 56477, 55299, 56478, 
-  55299, 56479, 55299, 56480, 55299, 56481, 55299, 56482, 
-  55299, 56483, 55299, 56484, 55299, 56485, 55299, 56486, 
-  55299, 56487, 55299, 56488, 55299, 56489, 55299, 56490, 
-  55299, 56491, 55299, 56492, 55299, 56493, 55299, 56494, 
-  55299, 56495, 55299, 56496, 55299, 56497, 55299, 56498, 
-  55302, 56480, 55302, 56481, 55302, 56482, 55302, 56483, 
-  55302, 56484, 55302, 56485, 55302, 56486, 55302, 56487, 
-  55302, 56488, 55302, 56489, 55302, 56490, 55302, 56491, 
-  55302, 56492, 55302, 56493, 55302, 56494, 55302, 56495, 
-  55302, 56496, 55302, 56497, 55302, 56498, 55302, 56499, 
-  55302, 56500, 55302, 56501, 55302, 56502, 55302, 56503, 
-  55302, 56504, 55302, 56505, 55302, 56506, 55302, 56507, 
-  55302, 56508, 55302, 56509, 55302, 56510, 55302, 56511, 
-  55323, 56896, 55323, 56897, 55323, 56898, 55323, 56899, 
-  55323, 56900, 55323, 56901, 55323, 56902, 55323, 56903, 
-  55323, 56904, 55323, 56905, 55323, 56906, 55323, 56907, 
-  55323, 56908, 55323, 56909, 55323, 56910, 55323, 56911, 
-  55323, 56912, 55323, 56913, 55323, 56914, 55323, 56915, 
-  55323, 56916, 55323, 56917, 55323, 56918, 55323, 56919, 
-  55323, 56920, 55323, 56921, 55323, 56922, 55323, 56923, 
-  55323, 56924, 55323, 56925, 55323, 56926, 55323, 56927, 
-  55354, 56576, 55354, 56577, 55354, 56578, 55354, 56579, 
-  55354, 56580, 55354, 56581, 55354, 56582, 55354, 56583, 
-  55354, 56584, 55354, 56585, 55354, 56586, 55354, 56587, 
-  55354, 56588, 55354, 56589, 55354, 56590, 55354, 56591, 
-  55354, 56592, 55354, 56593, 55354, 56594, 55354, 56595, 
-  55354, 56596, 55354, 56597, 55354, 56598, 55354, 56599, 
-  55354, 56600, 55354, 56601, 55354, 56602, 55354, 56603, 
-  55354, 56604, 55354, 56605, 55354, 56606, 55354, 56607, 
-  55354, 56608, 55354, 56609, };
-
-static const utf8proc_uint16_t utf8proc_stage1table[] = {
-  0, 256, 512, 768, 1024, 1280, 1536, 
-  1792, 2048, 2304, 2560, 2816, 3072, 3328, 3584, 
-  3840, 4096, 4352, 4608, 4864, 5120, 5376, 5632, 
-  5888, 6144, 6400, 6656, 6912, 7168, 7424, 7680, 
-  7936, 8192, 8448, 8704, 8960, 9216, 9472, 9728, 
-  9984, 10240, 10496, 10752, 11008, 11264, 11520, 11776, 
-  12032, 12288, 12544, 12800, 13056, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13568, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13824, 14080, 13312, 13312, 13312, 14336, 5376, 14592, 
-  14848, 15104, 15360, 15616, 15872, 16128, 16384, 16640, 
-  16896, 17152, 17408, 17664, 16128, 16384, 16640, 16896, 
-  17152, 17408, 17664, 16128, 16384, 16640, 16896, 17152, 
-  17408, 17664, 16128, 16384, 16640, 16896, 17152, 17408, 
-  17664, 16128, 16384, 16640, 16896, 17152, 17408, 17664, 
-  16128, 16384, 16640, 16896, 17152, 17408, 17664, 16128, 
-  17920, 18176, 18176, 18176, 18176, 18176, 18176, 18176, 
-  18176, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18688, 18944, 19200, 19456, 19712, 19968, 
-  20224, 20480, 20736, 20992, 21248, 21504, 21760, 5376, 
-  22016, 22272, 22528, 22784, 23040, 23296, 23552, 23808, 
-  24064, 24320, 24576, 24832, 25088, 25344, 25600, 25856, 
-  26112, 26368, 26624, 26880, 27136, 27392, 27648, 27904, 
-  28160, 5376, 5376, 5376, 28416, 28672, 28928, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 5376, 5376, 5376, 5376, 29184, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 5376, 5376, 29440, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 5376, 5376, 29696, 29952, 27136, 27136, 30208, 
-  30464, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  30720, 13312, 13312, 30976, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 13312, 31232, 31488, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 31744, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 32000, 32256, 32512, 32768, 33024, 33280, 33536, 
-  33792, 10240, 10240, 34048, 27136, 27136, 27136, 27136, 
-  27136, 34304, 34560, 34816, 27136, 27136, 27136, 27136, 
-  27136, 35072, 35328, 27136, 27136, 35584, 35840, 36096, 
-  27136, 36352, 36608, 36864, 37120, 37376, 37632, 37888, 
-  38144, 38400, 38656, 38912, 27136, 27136, 27136, 27136, 
-  27136, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 39168, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  39424, 39680, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 39936, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 13312, 13312, 13312, 13312, 
-  13312, 13312, 13312, 13312, 40192, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 40448, 40704, 40960, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 41216, 41472, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 27136, 27136, 27136, 27136, 27136, 27136, 27136, 
-  27136, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  41728, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  18432, 18432, 18432, 18432, 18432, 18432, 18432, 18432, 
-  41728, };
-
-static const utf8proc_uint16_t utf8proc_stage2table[] = {
-  1, 2, 2, 2, 2, 2, 2, 
-  2, 2, 3, 4, 3, 5, 6, 2, 
-  2, 2, 2, 2, 2, 2, 2, 2, 
-  2, 2, 2, 2, 2, 7, 7, 7, 
-  3, 8, 9, 9, 10, 11, 10, 9, 
-  9, 12, 13, 9, 14, 15, 16, 15, 
-  15, 17, 17, 17, 17, 17, 17, 17, 
-  17, 17, 17, 15, 9, 18, 19, 20, 
-  9, 9, 21, 22, 23, 24, 25, 26, 
-  27, 28, 29, 30, 31, 32, 33, 34, 
-  35, 36, 37, 38, 39, 40, 41, 42, 
-  43, 44, 45, 46, 12, 9, 13, 47, 
-  48, 47, 49, 50, 51, 52, 53, 54, 
-  55, 56, 57, 58, 59, 60, 61, 62, 
-  63, 64, 65, 66, 67, 68, 69, 70, 
-  71, 72, 73, 74, 12, 75, 13, 75, 
-  2, 2, 2, 2, 2, 2, 7, 2, 
-  2, 2, 2, 2, 2, 2, 2, 2, 
-  2, 2, 2, 2, 2, 2, 2, 2, 
-  2, 2, 2, 2, 2, 2, 2, 2, 
-  2, 76, 9, 11, 11, 11, 11, 77, 
-  9, 78, 79, 80, 81, 75, 82, 79, 
-  83, 84, 85, 86, 87, 88, 89, 9, 
-  9, 90, 91, 92, 93, 94, 95, 96, 
-  9, 97, 98, 99, 100, 101, 102, 103, 
-  104, 105, 106, 107, 108, 109, 110, 111, 
-  112, 113, 114, 115, 116, 117, 118, 119, 
-  75, 120, 121, 122, 123, 124, 125, 126, 
-  127, 128, 129, 130, 131, 132, 133, 134, 
-  135, 136, 137, 138, 139, 140, 141, 142, 
-  143, 144, 145, 146, 147, 148, 149, 150, 
-  75, 151, 152, 153, 154, 155, 156, 157, 
-  158, 159, 160, 161, 162, 163, 164, 165, 
-  166, 167, 168, 169, 170, 171, 172, 173, 
-  174, 175, 176, 177, 178, 179, 180, 181, 
-  182, 183, 184, 185, 186, 187, 188, 189, 
-  190, 191, 192, 193, 194, 195, 196, 197, 
-  198, 199, 200, 201, 202, 203, 204, 205, 
-  206, 207, 208, 209, 210, 211, 212, 213, 
-  214, 215, 216, 217, 218, 219, 220, 221, 
-  222, 223, 224, 225, 226, 227, 228, 229, 
-  230, 231, 232, 233, 234, 235, 236, 237, 
-  238, 239, 240, 241, 242, 243, 244, 245, 
-  246, 247, 248, 249, 250, 251, 252, 253, 
-  254, 255, 256, 257, 258, 259, 260, 261, 
-  262, 263, 264, 265, 266, 267, 268, 269, 
-  270, 271, 272, 273, 274, 275, 276, 277, 
-  278, 279, 280, 281, 282, 283, 284, 285, 
-  286, 287, 288, 289, 290, 291, 292, 293, 
-  294, 295, 296, 297, 298, 299, 215, 300, 
-  301, 302, 303, 304, 305, 306, 307, 308, 
-  309, 310, 311, 312, 215, 313, 314, 315, 
-  316, 317, 318, 319, 320, 321, 322, 323, 
-  324, 325, 326, 215, 215, 327, 328, 329, 
-  330, 331, 332, 333, 334, 335, 336, 337, 
-  338, 339, 340, 215, 341, 342, 343, 215, 
-  344, 341, 341, 341, 341, 345, 346, 347, 
-  348, 349, 350, 351, 352, 353, 354, 355, 
-  356, 357, 358, 359, 360, 361, 362, 363, 
-  364, 365, 366, 367, 368, 369, 370, 371, 
-  372, 373, 374, 375, 376, 377, 378, 379, 
-  380, 381, 382, 383, 384, 385, 386, 387, 
-  388, 389, 390, 391, 392, 393, 394, 395, 
-  396, 397, 398, 399, 400, 401, 402, 403, 
-  404, 405, 406, 407, 408, 409, 410, 411, 
-  412, 413, 414, 415, 416, 417, 418, 419, 
-  420, 421, 422, 423, 424, 425, 426, 427, 
-  428, 429, 430, 431, 432, 433, 434, 435, 
-  436, 437, 215, 438, 439, 440, 441, 442, 
-  443, 444, 445, 446, 447, 448, 449, 450, 
-  451, 452, 453, 454, 455, 215, 215, 215, 
-  215, 215, 215, 456, 457, 458, 459, 460, 
-  461, 462, 463, 464, 465, 466, 467, 468, 
-  469, 470, 471, 472, 473, 474, 475, 476, 
-  477, 478, 479, 480, 481, 482, 215, 483, 
-  484, 215, 485, 215, 486, 487, 215, 215, 
-  215, 488, 489, 215, 490, 215, 491, 492, 
-  215, 493, 494, 495, 496, 497, 215, 215, 
-  498, 215, 499, 500, 215, 215, 501, 215, 
-  215, 215, 215, 215, 215, 215, 502, 215, 
-  215, 503, 215, 504, 505, 215, 215, 215, 
-  506, 507, 508, 509, 510, 511, 215, 215, 
-  215, 215, 215, 512, 215, 341, 215, 215, 
-  215, 215, 215, 215, 215, 215, 513, 514, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 515, 516, 517, 518, 519, 520, 521, 
-  522, 523, 524, 524, 525, 525, 525, 525, 
-  525, 525, 525, 526, 526, 526, 526, 524, 
-  524, 524, 524, 524, 524, 524, 524, 524, 
-  524, 525, 525, 526, 526, 526, 526, 526, 
-  526, 527, 528, 529, 530, 531, 532, 526, 
-  526, 533, 534, 535, 536, 537, 526, 526, 
-  526, 526, 526, 526, 526, 524, 526, 525, 
-  526, 526, 526, 526, 526, 526, 526, 526, 
-  526, 526, 526, 526, 526, 526, 526, 526, 
-  526, 538, 539, 540, 541, 542, 543, 544, 
-  545, 546, 547, 548, 549, 550, 543, 543, 
-  551, 543, 552, 543, 553, 554, 555, 556, 
-  556, 556, 556, 555, 557, 556, 556, 556, 
-  556, 556, 558, 558, 559, 560, 561, 562, 
-  563, 564, 556, 556, 556, 556, 565, 566, 
-  556, 567, 568, 556, 556, 569, 569, 569, 
-  569, 570, 556, 556, 556, 556, 543, 543, 
-  543, 571, 572, 573, 574, 575, 576, 543, 
-  556, 556, 556, 543, 543, 543, 556, 556, 
-  577, 543, 543, 543, 556, 556, 556, 556, 
-  543, 555, 556, 556, 543, 578, 579, 579, 
-  578, 579, 579, 578, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 580, 581, 582, 583, 584, 526, 585, 
-  586, 0, 0, 587, 588, 589, 590, 591, 
-  592, 0, 0, 0, 0, 88, 593, 594, 
-  595, 596, 597, 598, 0, 599, 0, 600, 
-  601, 602, 603, 604, 605, 606, 607, 608, 
-  609, 610, 611, 612, 613, 614, 615, 616, 
-  617, 618, 619, 0, 620, 621, 622, 623, 
-  624, 625, 626, 627, 628, 629, 630, 631, 
-  632, 633, 634, 635, 636, 637, 638, 639, 
-  640, 641, 642, 643, 644, 645, 646, 647, 
-  648, 649, 650, 651, 652, 653, 654, 655, 
-  656, 657, 658, 659, 660, 661, 662, 663, 
-  664, 665, 666, 667, 668, 669, 670, 671, 
-  672, 673, 674, 675, 676, 677, 678, 679, 
-  680, 681, 682, 683, 684, 685, 686, 687, 
-  688, 689, 690, 691, 692, 693, 694, 695, 
-  696, 697, 698, 699, 700, 701, 702, 75, 
-  703, 704, 705, 706, 707, 215, 708, 709, 
-  710, 711, 712, 713, 714, 715, 716, 717, 
-  718, 719, 720, 721, 722, 723, 724, 725, 
-  726, 727, 728, 729, 730, 731, 732, 733, 
-  734, 735, 736, 737, 738, 739, 740, 741, 
-  742, 743, 744, 745, 746, 747, 748, 749, 
-  750, 751, 752, 753, 754, 755, 756, 757, 
-  758, 759, 760, 761, 762, 763, 764, 765, 
-  766, 767, 768, 769, 770, 771, 772, 773, 
-  774, 775, 776, 777, 778, 779, 780, 781, 
-  782, 783, 784, 785, 786, 787, 788, 789, 
-  790, 791, 792, 793, 794, 795, 796, 797, 
-  798, 799, 800, 801, 802, 803, 804, 805, 
-  806, 807, 808, 809, 810, 811, 812, 813, 
-  814, 815, 816, 817, 818, 819, 820, 821, 
-  822, 823, 824, 825, 826, 827, 828, 829, 
-  830, 831, 832, 833, 834, 835, 836, 837, 
-  838, 839, 840, 841, 543, 543, 543, 543, 
-  543, 842, 842, 843, 844, 845, 846, 847, 
-  848, 849, 850, 851, 852, 853, 854, 855, 
-  856, 857, 858, 859, 860, 861, 862, 863, 
-  864, 865, 866, 867, 868, 869, 870, 871, 
-  872, 873, 874, 875, 876, 877, 878, 879, 
-  880, 881, 882, 883, 884, 885, 886, 887, 
-  888, 889, 890, 891, 892, 893, 894, 895, 
-  896, 897, 898, 899, 900, 901, 902, 903, 
-  904, 905, 906, 907, 908, 909, 910, 911, 
-  912, 913, 914, 915, 916, 917, 918, 919, 
-  920, 921, 922, 923, 924, 925, 926, 927, 
-  928, 929, 930, 931, 932, 933, 934, 935, 
-  936, 937, 938, 939, 940, 941, 942, 943, 
-  944, 945, 946, 947, 948, 949, 950, 951, 
-  952, 953, 954, 955, 956, 957, 958, 959, 
-  960, 961, 962, 963, 964, 965, 966, 967, 
-  968, 969, 970, 971, 972, 973, 974, 975, 
-  976, 977, 978, 979, 980, 981, 982, 983, 
-  984, 985, 986, 987, 988, 989, 990, 991, 
-  992, 993, 994, 995, 996, 997, 998, 999, 
-  1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 
-  1008, 0, 1009, 1010, 1011, 1012, 1013, 1014, 
-  1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 
-  1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 
-  1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 
-  1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 
-  0, 0, 525, 1047, 1047, 1047, 1047, 1047, 
-  1047, 215, 1048, 1049, 1050, 1051, 1052, 1053, 
-  1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 
-  1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 
-  1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 
-  1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 
-  1086, 215, 1047, 1087, 0, 0, 77, 77, 
-  11, 0, 556, 543, 543, 543, 543, 556, 
-  543, 543, 543, 1088, 556, 543, 543, 543, 
-  543, 543, 543, 556, 556, 556, 556, 556, 
-  556, 543, 543, 556, 543, 543, 1088, 1089, 
-  543, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 
-  1097, 1098, 1099, 1099, 1100, 1101, 1102, 1103, 
-  1104, 1105, 1106, 1107, 1105, 543, 556, 1105, 
-  1098, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 0, 0, 0, 0, 
-  1108, 1108, 1108, 1108, 1105, 1105, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1109, 1109, 1109, 1109, 1109, 1109, 75, 
-  75, 1110, 10, 10, 1111, 15, 1112, 77, 
-  77, 543, 543, 543, 543, 543, 543, 543, 
-  543, 1113, 1114, 1115, 1112, 1116, 0, 1112, 
-  1112, 1117, 1117, 1118, 1119, 1120, 1121, 1122, 
-  1123, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1124, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1125, 1117, 1126, 1127, 1128, 1129, 1113, 
-  1114, 1115, 1130, 1131, 1132, 1133, 1134, 556, 
-  543, 543, 543, 543, 543, 556, 543, 543, 
-  556, 1135, 1135, 1135, 1135, 1135, 1135, 1135, 
-  1135, 1135, 1135, 10, 1136, 1136, 1112, 1117, 
-  1117, 1137, 1117, 1117, 1117, 1117, 1138, 1139, 
-  1140, 1141, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1142, 1143, 1144, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1145, 1146, 1112, 1147, 543, 
-  543, 543, 543, 543, 543, 543, 1109, 77, 
-  543, 543, 543, 543, 556, 543, 1124, 1124, 
-  543, 543, 77, 556, 543, 543, 556, 1117, 
-  1117, 17, 17, 17, 17, 17, 17, 17, 
-  17, 17, 17, 1117, 1117, 1117, 1148, 1148, 
-  1117, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 
-  1112, 1112, 1112, 1112, 1112, 1112, 1112, 0, 
-  1149, 1117, 1150, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 543, 556, 543, 543, 556, 543, 543, 
-  556, 556, 556, 543, 556, 556, 543, 556, 
-  543, 543, 543, 556, 543, 556, 543, 556, 
-  543, 556, 543, 543, 0, 0, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1117, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1152, 1152, 1152, 1152, 1152, 1152, 1152, 
-  1152, 1152, 1152, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 543, 543, 543, 543, 
-  543, 543, 543, 556, 543, 1153, 1153, 77, 
-  9, 9, 9, 1153, 0, 0, 556, 1154, 
-  1154, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 543, 
-  543, 543, 543, 1153, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 1153, 543, 543, 
-  543, 1153, 543, 543, 543, 543, 543, 0, 
-  0, 1105, 1105, 1105, 1105, 1105, 1105, 1105, 
-  1105, 1105, 1105, 1105, 1105, 1105, 1105, 1105, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 556, 556, 556, 0, 0, 1105, 
-  0, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 0, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 556, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 1109, 556, 543, 543, 556, 
-  543, 543, 556, 543, 543, 543, 556, 556, 
-  556, 1127, 1128, 1129, 543, 543, 543, 556, 
-  543, 543, 556, 556, 543, 543, 543, 543, 
-  543, 1151, 1151, 1151, 1155, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 1156, 1157, 341, 341, 341, 341, 341, 
-  341, 1158, 1159, 341, 1160, 1161, 341, 341, 
-  341, 341, 341, 1151, 1155, 1162, 341, 1155, 
-  1155, 1155, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1155, 1155, 1155, 1155, 1163, 1155, 
-  1155, 341, 543, 556, 543, 543, 1151, 1151, 
-  1151, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 
-  1171, 341, 341, 1151, 1151, 1047, 1047, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1047, 525, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1151, 1155, 1155, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 0, 
-  341, 341, 0, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 0, 0, 0, 341, 
-  341, 341, 341, 0, 0, 1173, 341, 1174, 
-  1155, 1155, 1151, 1151, 1151, 1151, 0, 0, 
-  1175, 1155, 0, 0, 1176, 1177, 1163, 341, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1178, 0, 0, 0, 0, 1179, 1180, 0, 
-  1181, 341, 341, 1151, 1151, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 341, 341, 11, 11, 1182, 1182, 1182, 
-  1182, 1182, 1182, 841, 11, 341, 1047, 543, 
-  0, 0, 1151, 1151, 1155, 0, 341, 341, 
-  341, 341, 341, 341, 0, 0, 0, 0, 
-  341, 341, 0, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 1183, 0, 341, 1184, 
-  0, 341, 341, 0, 0, 1173, 0, 1155, 
-  1155, 1155, 1151, 1151, 0, 0, 0, 0, 
-  1151, 1151, 0, 0, 1151, 1151, 1163, 0, 
-  0, 0, 1151, 0, 0, 0, 0, 0, 
-  0, 0, 1185, 1186, 1187, 341, 0, 1188, 
-  0, 0, 0, 0, 0, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1151, 1151, 341, 341, 341, 1151, 1047, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 1151, 1151, 1155, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  341, 341, 341, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 0, 341, 341, 
-  341, 341, 341, 0, 0, 1173, 341, 1155, 
-  1155, 1155, 1151, 1151, 1151, 1151, 1151, 0, 
-  1151, 1151, 1155, 0, 1155, 1155, 1163, 0, 
-  0, 341, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 1151, 1151, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1047, 11, 0, 0, 0, 0, 0, 
-  0, 0, 341, 1151, 1151, 1151, 1151, 1151, 
-  1151, 0, 1151, 1155, 1155, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 0, 
-  341, 341, 0, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 0, 341, 341, 
-  341, 341, 341, 0, 0, 1173, 341, 1189, 
-  1151, 1155, 1151, 1151, 1151, 1151, 0, 0, 
-  1190, 1191, 0, 0, 1192, 1193, 1163, 0, 
-  0, 0, 0, 0, 0, 0, 0, 1194, 
-  1195, 0, 0, 0, 0, 1196, 1197, 0, 
-  341, 341, 341, 1151, 1151, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 841, 341, 1182, 1182, 1182, 1182, 1182, 
-  1182, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 1151, 341, 0, 341, 341, 
-  341, 341, 341, 341, 0, 0, 0, 341, 
-  341, 341, 0, 1198, 341, 1199, 341, 0, 
-  0, 0, 341, 341, 0, 341, 0, 341, 
-  341, 0, 0, 0, 341, 341, 0, 0, 
-  0, 341, 341, 341, 0, 0, 0, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 0, 0, 0, 0, 1200, 
-  1155, 1151, 1155, 1155, 0, 0, 0, 1201, 
-  1202, 1155, 0, 1203, 1204, 1205, 1163, 0, 
-  0, 341, 0, 0, 0, 0, 0, 0, 
-  1206, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1182, 1182, 1182, 77, 77, 77, 77, 
-  77, 77, 11, 77, 0, 0, 0, 0, 
-  0, 1151, 1155, 1155, 1155, 1151, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 0, 0, 0, 341, 1151, 
-  1151, 1151, 1155, 1155, 1155, 1155, 0, 1207, 
-  1151, 1208, 0, 1151, 1151, 1151, 1163, 0, 
-  0, 0, 0, 0, 0, 0, 1209, 1210, 
-  0, 341, 341, 341, 0, 0, 0, 0, 
-  0, 341, 341, 1151, 1151, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 0, 0, 0, 0, 0, 0, 0, 
-  1047, 1211, 1211, 1211, 1211, 1211, 1211, 1211, 
-  841, 341, 1151, 1155, 1155, 1047, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 0, 341, 341, 
-  341, 341, 341, 0, 0, 1173, 341, 1155, 
-  1212, 1213, 1155, 1214, 1155, 1155, 0, 1215, 
-  1216, 1217, 0, 1218, 1219, 1151, 1163, 0, 
-  0, 0, 0, 0, 0, 0, 1220, 1221, 
-  0, 0, 0, 0, 0, 0, 0, 341, 
-  0, 341, 341, 1151, 1151, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 0, 341, 341, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1151, 1151, 1155, 1155, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1163, 1163, 341, 1222, 
-  1155, 1155, 1151, 1151, 1151, 1151, 0, 1223, 
-  1224, 1155, 0, 1225, 1226, 1227, 1163, 1228, 
-  841, 0, 0, 0, 0, 341, 341, 341, 
-  1229, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  341, 341, 341, 1151, 1151, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 841, 341, 341, 341, 341, 341, 
-  341, 0, 0, 1155, 1155, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 0, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 0, 341, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 0, 0, 1230, 0, 0, 0, 0, 
-  1231, 1155, 1155, 1151, 1151, 1151, 0, 1151, 
-  0, 1155, 1232, 1233, 1155, 1234, 1235, 1236, 
-  1237, 0, 0, 0, 0, 0, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 0, 0, 1155, 1155, 1047, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1151, 341, 1238, 1151, 1151, 1151, 
-  1151, 1239, 1239, 1163, 0, 0, 0, 0, 
-  11, 341, 341, 341, 341, 341, 341, 525, 
-  1151, 1240, 1240, 1240, 1240, 1151, 1151, 1151, 
-  1047, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1047, 1047, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 341, 341, 0, 341, 0, 341, 
-  341, 341, 341, 341, 0, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 0, 341, 0, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1151, 341, 1241, 1151, 1151, 1151, 
-  1151, 1242, 1242, 1163, 1151, 1151, 341, 0, 
-  0, 341, 341, 341, 341, 341, 0, 525, 
-  0, 1243, 1243, 1243, 1243, 1151, 1151, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 1244, 1245, 341, 
-  341, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 841, 841, 841, 1047, 1047, 1047, 
-  1047, 1047, 1047, 1047, 1047, 1246, 1047, 1047, 
-  1047, 1047, 1047, 1047, 841, 1047, 841, 841, 
-  841, 556, 556, 841, 841, 841, 841, 841, 
-  841, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 841, 556, 841, 
-  556, 841, 1247, 12, 13, 12, 13, 1155, 
-  1155, 341, 341, 341, 1248, 341, 341, 341, 
-  341, 0, 341, 341, 341, 341, 1249, 341, 
-  341, 341, 341, 1250, 341, 341, 341, 341, 
-  1251, 341, 341, 341, 341, 1252, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1253, 341, 341, 341, 0, 0, 
-  0, 0, 1254, 1255, 1256, 1257, 1258, 1259, 
-  1260, 1261, 1262, 1255, 1255, 1255, 1255, 1151, 
-  1155, 1255, 1263, 543, 543, 1163, 1047, 543, 
-  543, 341, 341, 341, 341, 341, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1264, 1151, 1151, 1151, 
-  1151, 0, 1151, 1151, 1151, 1151, 1265, 1151, 
-  1151, 1151, 1151, 1266, 1151, 1151, 1151, 1151, 
-  1267, 1151, 1151, 1151, 1151, 1268, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1269, 1151, 1151, 1151, 0, 841, 
-  841, 841, 841, 841, 841, 841, 841, 556, 
-  841, 841, 841, 841, 841, 841, 0, 841, 
-  841, 1047, 1047, 1047, 1047, 1047, 841, 841, 
-  841, 841, 1047, 1047, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 1270, 1271, 
-  341, 341, 341, 341, 1272, 1272, 1151, 1273, 
-  1151, 1151, 1155, 1151, 1151, 1151, 1151, 1151, 
-  1173, 1272, 1163, 1163, 1155, 1155, 1151, 1151, 
-  341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1047, 1047, 1047, 1047, 1047, 
-  1047, 341, 341, 341, 341, 341, 341, 1155, 
-  1155, 1151, 1151, 341, 341, 341, 341, 1151, 
-  1151, 1151, 341, 1272, 1272, 1272, 341, 341, 
-  1272, 1272, 1272, 1272, 1272, 1272, 1272, 341, 
-  341, 341, 1151, 1151, 1151, 1151, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 1151, 1272, 1155, 1151, 1151, 
-  1272, 1272, 1272, 1272, 1272, 1272, 556, 341, 
-  1272, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1272, 1272, 1272, 1151, 841, 
-  841, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 
-  1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 
-  1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 
-  1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 
-  1305, 1306, 1307, 1308, 1309, 1310, 1311, 0, 
-  1312, 0, 0, 0, 0, 0, 1313, 0, 
-  0, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 
-  1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 
-  1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 
-  1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 
-  1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 
-  1353, 1354, 1355, 1356, 1047, 1357, 1358, 1359, 
-  1360, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1362, 1363, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 0, 341, 341, 341, 341, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 0, 341, 341, 341, 341, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 0, 0, 543, 543, 
-  543, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 
-  1047, 1047, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 0, 0, 0, 0, 0, 
-  0, 1366, 1367, 1368, 1369, 1370, 1371, 1372, 
-  1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 
-  1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 
-  1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 
-  1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 
-  1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 
-  1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 
-  1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 
-  1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 
-  1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 
-  1445, 1446, 1447, 1448, 1449, 1450, 1451, 0, 
-  0, 1452, 1453, 1454, 1455, 1456, 1457, 0, 
-  0, 1087, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 841, 1047, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 8, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 12, 13, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1047, 1047, 1047, 1458, 
-  1458, 1458, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 341, 
-  341, 341, 341, 1151, 1151, 1163, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 1151, 1151, 1163, 1047, 1047, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 1151, 1151, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 341, 
-  341, 341, 0, 1151, 1151, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 577, 577, 1155, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1155, 1155, 1151, 
-  1155, 1155, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1163, 1151, 1047, 1047, 1047, 
-  525, 1047, 1047, 1047, 11, 341, 543, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 1211, 1211, 1211, 1211, 1211, 1211, 1211, 
-  1211, 1211, 1211, 0, 0, 0, 0, 0, 
-  0, 9, 9, 9, 9, 9, 9, 1087, 
-  9, 9, 9, 9, 577, 577, 577, 1459, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 525, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 1151, 1151, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1089, 341, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 1151, 1151, 1151, 1155, 1155, 1155, 1155, 
-  1151, 1151, 1155, 1155, 1155, 0, 0, 0, 
-  0, 1155, 1155, 1151, 1155, 1155, 1155, 1155, 
-  1155, 1155, 1088, 543, 556, 0, 0, 0, 
-  0, 77, 0, 0, 0, 9, 9, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  0, 341, 341, 341, 341, 341, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1182, 0, 0, 0, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  543, 556, 1155, 1155, 1151, 0, 0, 1047, 
-  1047, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 1155, 1151, 
-  1155, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  0, 1163, 1272, 1151, 1272, 1272, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1151, 1151, 543, 543, 
-  543, 543, 543, 543, 543, 543, 0, 0, 
-  556, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 
-  525, 1047, 1047, 1047, 1047, 1047, 1047, 0, 
-  0, 543, 543, 543, 543, 543, 556, 556, 
-  556, 556, 556, 556, 543, 543, 556, 842, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1151, 1151, 1151, 1151, 1155, 1460, 1461, 
-  1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 
-  341, 341, 1470, 1471, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 1173, 1472, 1151, 
-  1151, 1151, 1151, 1473, 1474, 1475, 1476, 1477, 
-  1478, 1479, 1480, 1481, 1482, 1483, 341, 341, 
-  341, 341, 341, 341, 341, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1047, 1047, 1047, 1047, 1047, 
-  1047, 1047, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 543, 556, 543, 543, 
-  543, 543, 543, 543, 543, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 0, 0, 
-  0, 1151, 1151, 1155, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1155, 1151, 1151, 1151, 1151, 1155, 
-  1155, 1151, 1151, 1483, 1163, 1151, 1151, 341, 
-  341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 1173, 
-  1155, 1151, 1151, 1155, 1155, 1155, 1151, 1155, 
-  1151, 1151, 1151, 1483, 1483, 0, 0, 0, 
-  0, 0, 0, 0, 0, 1047, 1047, 1047, 
-  1047, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1155, 1155, 1151, 
-  1173, 0, 0, 0, 1047, 1047, 1047, 1047, 
-  1047, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 341, 341, 
-  341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 525, 525, 525, 525, 525, 525, 1047, 
-  1047, 1484, 1485, 1486, 1487, 1488, 1488, 1489, 
-  1490, 1491, 0, 0, 0, 0, 0, 0, 
-  0, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 
-  1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 
-  1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 
-  1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 
-  1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 
-  1531, 1532, 1533, 1534, 0, 0, 1535, 1536, 
-  1537, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 
-  1047, 0, 0, 0, 0, 0, 0, 0, 
-  0, 543, 543, 543, 1047, 569, 556, 556, 
-  556, 556, 556, 543, 543, 556, 556, 556, 
-  556, 543, 1155, 569, 569, 569, 569, 569, 
-  569, 569, 341, 341, 341, 341, 556, 341, 
-  341, 341, 341, 341, 341, 543, 341, 341, 
-  1155, 543, 543, 341, 0, 0, 0, 0, 
-  0, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 1538, 1539, 1540, 
-  525, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 
-  1548, 1549, 1550, 1551, 525, 1552, 1553, 1554, 
-  1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 
-  1563, 1564, 1565, 1566, 1567, 1568, 1569, 525, 
-  1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 
-  1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 
-  1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 
-  1594, 1595, 1596, 1597, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 1598, 1599, 215, 215, 215, 1600, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 1601, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 1602, 1603, 1604, 1605, 
-  1568, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 
-  1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 
-  1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 
-  1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 
-  1637, 543, 543, 556, 543, 543, 543, 543, 
-  543, 543, 543, 556, 543, 543, 579, 1638, 
-  556, 558, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 555, 
-  1089, 1089, 556, 0, 543, 578, 556, 543, 
-  556, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 
-  1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 
-  1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 
-  1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 
-  1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 
-  1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 
-  1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 
-  1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 
-  1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 
-  1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 
-  1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 
-  1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 
-  1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 
-  1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 
-  1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 
-  1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 
-  1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 
-  1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 
-  1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 
-  1790, 1791, 1792, 1793, 1794, 215, 215, 1795, 
-  215, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 
-  1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 
-  1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 
-  1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 
-  1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 
-  1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 
-  1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 
-  1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 
-  1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 
-  1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 
-  1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 
-  1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 
-  1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 
-  1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 
-  1907, 1908, 1909, 1910, 1911, 1912, 1913, 0, 
-  0, 1914, 1915, 1916, 1917, 1918, 1919, 0, 
-  0, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 
-  1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 
-  1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 
-  1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 
-  1951, 1952, 1953, 1954, 1955, 1956, 1957, 0, 
-  0, 1958, 1959, 1960, 1961, 1962, 1963, 0, 
-  0, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 
-  1971, 0, 1972, 0, 1973, 0, 1974, 0, 
-  1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 
-  1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 
-  1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 
-  1999, 2000, 2001, 2002, 2003, 2004, 2005, 0, 
-  0, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 
-  2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 
-  2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 
-  2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 
-  2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 
-  2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 
-  2053, 2054, 2055, 2056, 2057, 2058, 0, 2059, 
-  2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 
-  2068, 2069, 2070, 2071, 2072, 2073, 0, 2074, 
-  2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 
-  2083, 2084, 2085, 2086, 2087, 0, 0, 2088, 
-  2089, 2090, 2091, 2092, 2093, 0, 2094, 2095, 
-  2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 
-  2104, 2105, 2106, 2107, 2108, 2109, 2110, 2111, 
-  2112, 0, 0, 2113, 2114, 2115, 0, 2116, 
-  2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, 
-  0, 2125, 2126, 2127, 2127, 2127, 2127, 2127, 
-  2128, 2127, 2127, 2127, 1459, 2129, 2130, 2131, 
-  2132, 1087, 2133, 1087, 1087, 1087, 1087, 9, 
-  2134, 2135, 2136, 2137, 2135, 2135, 2136, 2137, 
-  2135, 9, 9, 9, 9, 2138, 2139, 2140, 
-  9, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 
-  76, 10, 10, 10, 2148, 2149, 9, 2150, 
-  2151, 9, 81, 93, 9, 2152, 9, 2153, 
-  48, 48, 9, 9, 9, 2154, 12, 13, 
-  2155, 2156, 2157, 9, 9, 9, 9, 9, 
-  9, 9, 9, 75, 9, 48, 9, 9, 
-  2158, 9, 9, 9, 9, 9, 9, 9, 
-  2127, 1459, 1459, 1459, 1459, 1459, 0, 2159, 
-  2160, 2161, 2162, 1459, 1459, 1459, 1459, 1459, 
-  1459, 2163, 2164, 0, 0, 2165, 2166, 2167, 
-  2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 
-  2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 
-  2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, 
-  0, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 
-  2199, 2200, 2201, 2202, 2203, 2204, 0, 0, 
-  0, 11, 11, 11, 11, 11, 11, 11, 
-  11, 2205, 11, 11, 11, 11, 11, 11, 
-  11, 11, 11, 11, 11, 11, 11, 11, 
-  11, 11, 11, 11, 11, 11, 11, 11, 
-  11, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 543, 543, 569, 569, 543, 543, 543, 
-  543, 569, 569, 569, 543, 543, 842, 842, 
-  842, 842, 543, 842, 842, 842, 569, 569, 
-  543, 556, 543, 569, 569, 556, 556, 556, 
-  556, 543, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2206, 2207, 2208, 2209, 77, 2210, 2211, 
-  2212, 77, 2213, 2214, 2215, 2215, 2215, 2216, 
-  2217, 2218, 2218, 2219, 2220, 77, 2221, 2222, 
-  77, 75, 2223, 2224, 2225, 2225, 2225, 77, 
-  77, 2226, 2227, 2228, 77, 2229, 77, 2230, 
-  77, 2229, 77, 2231, 2232, 2233, 2208, 84, 
-  2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 
-  2242, 2243, 2244, 77, 2245, 2246, 2247, 2248, 
-  2249, 2250, 75, 75, 75, 75, 2251, 2252, 
-  2234, 2253, 2254, 77, 75, 77, 77, 2255, 
-  841, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 
-  2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 
-  2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 
-  2279, 2280, 2281, 2282, 2283, 2284, 2285, 2286, 
-  2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 
-  2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 
-  2303, 1458, 1458, 1458, 2304, 2305, 1458, 1458, 
-  1458, 1458, 2306, 77, 77, 0, 0, 0, 
-  0, 2307, 75, 2308, 75, 2309, 79, 79, 
-  79, 79, 79, 2310, 2311, 77, 77, 77, 
-  77, 75, 77, 77, 75, 77, 77, 75, 
-  77, 77, 79, 79, 77, 77, 77, 2312, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 2313, 2314, 
-  2315, 2316, 77, 2317, 77, 2318, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 2319, 2319, 2320, 2321, 75, 75, 
-  75, 2322, 2323, 2319, 2324, 2325, 2319, 75, 
-  75, 75, 2319, 14, 85, 75, 2319, 2319, 
-  75, 75, 75, 2319, 2319, 2319, 2319, 75, 
-  2319, 2319, 2319, 2319, 2326, 2327, 2328, 2329, 
-  75, 75, 75, 75, 2319, 2330, 2331, 2319, 
-  2332, 2333, 2319, 2319, 2319, 75, 75, 75, 
-  75, 75, 2319, 75, 2319, 2334, 2319, 2319, 
-  2319, 2319, 2335, 2319, 2336, 2337, 2338, 2319, 
-  2339, 2340, 2341, 2319, 2319, 2319, 2342, 75, 
-  75, 75, 75, 2319, 2319, 2319, 2319, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  2319, 2343, 2344, 2345, 75, 2346, 2347, 2319, 
-  2319, 2319, 2319, 2319, 2319, 75, 2348, 2349, 
-  2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 
-  2358, 2359, 2360, 2361, 2362, 2363, 2364, 2319, 
-  2319, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 
-  2372, 2373, 2374, 2319, 2319, 2319, 75, 75, 
-  2319, 2319, 2375, 2376, 75, 75, 75, 75, 
-  75, 2319, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 2377, 2319, 75, 75, 2319, 
-  2319, 2378, 2379, 2319, 2380, 2381, 2382, 2383, 
-  2384, 2319, 2319, 2385, 2386, 2387, 2388, 2319, 
-  2319, 2319, 75, 75, 75, 75, 75, 2319, 
-  2319, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 2319, 2319, 2319, 2319, 2319, 75, 
-  75, 2319, 2319, 75, 75, 75, 75, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2389, 2390, 2391, 2392, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2393, 2394, 2395, 2396, 75, 
-  75, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 77, 77, 77, 77, 77, 77, 77, 
-  77, 12, 13, 12, 13, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 2397, 2397, 77, 77, 77, 
-  77, 2319, 2319, 77, 77, 77, 77, 77, 
-  77, 79, 2398, 2399, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 77, 75, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 79, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 841, 77, 
-  77, 77, 77, 77, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  79, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 75, 75, 75, 
-  75, 75, 75, 77, 77, 77, 77, 77, 
-  77, 77, 2397, 2397, 2397, 2397, 79, 79, 
-  79, 2397, 79, 79, 2397, 77, 77, 77, 
-  77, 79, 79, 79, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 
-  2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 
-  2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 
-  2423, 2424, 2425, 2426, 2427, 2428, 2429, 2430, 
-  2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 
-  2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 
-  2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 
-  2455, 2456, 2457, 2458, 2459, 2460, 2461, 2462, 
-  2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 
-  2471, 2472, 2473, 2474, 2475, 2476, 2477, 2478, 
-  2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 
-  2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 
-  2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, 
-  2503, 2504, 2505, 2506, 2507, 2508, 2509, 2510, 
-  2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 
-  2519, 2520, 2521, 2522, 2523, 2524, 2525, 2526, 
-  2527, 2528, 2529, 2530, 2531, 2532, 2533, 2534, 
-  2535, 2536, 2537, 2538, 1211, 1211, 1211, 1211, 
-  1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, 
-  1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, 
-  1211, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 79, 79, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 79, 
-  75, 77, 77, 77, 77, 77, 77, 77, 
-  77, 79, 75, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 75, 75, 75, 2539, 2539, 2540, 2540, 
-  75, 79, 79, 79, 79, 79, 79, 77, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 77, 2397, 2397, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  2539, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  2397, 79, 79, 79, 79, 79, 79, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 79, 79, 79, 2397, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 2397, 79, 79, 79, 79, 79, 
-  79, 79, 79, 2397, 2397, 2541, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 2397, 2397, 
-  79, 79, 79, 79, 79, 2397, 2397, 79, 
-  79, 79, 79, 79, 79, 79, 79, 2397, 
-  79, 79, 79, 79, 79, 2397, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 2397, 79, 79, 79, 79, 
-  79, 79, 79, 2397, 2397, 79, 2397, 79, 
-  79, 79, 79, 2397, 79, 79, 2397, 79, 
-  79, 79, 79, 79, 79, 79, 2397, 77, 
-  77, 79, 79, 2397, 2397, 79, 79, 79, 
-  79, 79, 79, 79, 77, 79, 77, 79, 
-  77, 77, 77, 77, 77, 77, 79, 77, 
-  77, 77, 79, 77, 77, 77, 77, 77, 
-  77, 2397, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 79, 79, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 79, 77, 77, 
-  79, 77, 77, 77, 77, 2397, 77, 2397, 
-  77, 77, 77, 77, 2397, 2397, 2397, 77, 
-  2397, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 79, 79, 79, 79, 
-  79, 12, 13, 12, 13, 12, 13, 12, 
-  13, 12, 13, 12, 13, 12, 13, 1211, 
-  1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, 
-  1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, 
-  1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, 
-  1211, 1211, 1211, 1211, 1211, 77, 2397, 2397, 
-  2397, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 79, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 2397, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  2397, 2319, 75, 75, 2319, 2319, 12, 13, 
-  75, 2319, 2319, 75, 2319, 2319, 2319, 75, 
-  75, 75, 75, 75, 2319, 2319, 2319, 2319, 
-  75, 75, 75, 75, 75, 2319, 2319, 2319, 
-  75, 75, 75, 2319, 2319, 2319, 2319, 12, 
-  13, 12, 13, 12, 13, 12, 13, 12, 
-  13, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 2539, 2539, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 12, 13, 12, 13, 
-  12, 13, 12, 13, 12, 13, 12, 13, 
-  12, 13, 12, 13, 12, 13, 12, 13, 
-  12, 13, 75, 75, 2319, 2319, 2319, 2319, 
-  2319, 2319, 75, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 75, 75, 75, 75, 75, 75, 75, 
-  75, 2319, 75, 75, 75, 75, 75, 75, 
-  75, 2319, 2319, 2319, 2319, 2319, 2319, 75, 
-  75, 75, 2319, 75, 75, 75, 75, 2319, 
-  2319, 2319, 2319, 2319, 75, 2319, 2319, 75, 
-  75, 12, 13, 12, 13, 2319, 75, 75, 
-  75, 75, 2319, 75, 2319, 2319, 2319, 75, 
-  75, 2319, 2319, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 2319, 2319, 2319, 
-  2319, 2319, 2319, 75, 75, 12, 13, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 2319, 2319, 2542, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 75, 2319, 
-  2319, 2319, 2319, 75, 75, 2319, 75, 2319, 
-  75, 75, 2319, 75, 2319, 2319, 2319, 2319, 
-  75, 75, 75, 75, 75, 2319, 2319, 75, 
-  75, 75, 75, 75, 75, 2319, 2319, 2319, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  2319, 2319, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 2319, 2319, 75, 
-  75, 75, 75, 2319, 2319, 2319, 2319, 75, 
-  2319, 2319, 75, 75, 2319, 2543, 2544, 2545, 
-  75, 75, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 75, 75, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 75, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  2319, 2319, 2319, 2319, 2319, 2319, 2319, 2319, 
-  75, 75, 75, 75, 75, 2546, 2547, 2319, 
-  75, 75, 75, 2319, 2319, 2319, 2319, 2319, 
-  75, 75, 75, 75, 75, 2319, 2319, 2319, 
-  75, 75, 75, 75, 2319, 75, 75, 75, 
-  2319, 2319, 2319, 2319, 2319, 75, 2319, 75, 
-  75, 77, 77, 77, 77, 77, 79, 79, 
-  79, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 2397, 2397, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 75, 75, 
-  75, 75, 75, 75, 75, 75, 77, 77, 
-  75, 75, 75, 75, 75, 75, 77, 77, 
-  77, 2397, 77, 77, 77, 77, 2397, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 0, 0, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 2548, 
-  77, 2549, 2550, 2551, 2552, 2553, 2554, 2555, 
-  2556, 2557, 2558, 2559, 2560, 2561, 2562, 2563, 
-  2564, 2565, 2566, 2567, 2568, 2569, 2570, 2571, 
-  2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, 
-  2580, 2581, 2582, 2583, 2584, 2585, 2586, 2587, 
-  2588, 2589, 2590, 2591, 2592, 2593, 2594, 2595, 
-  0, 2596, 2597, 2598, 2599, 2600, 2601, 2602, 
-  2603, 2604, 2605, 2606, 2607, 2608, 2609, 2610, 
-  2611, 2612, 2613, 2614, 2615, 2616, 2617, 2618, 
-  2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 
-  2627, 2628, 2629, 2630, 2631, 2632, 2633, 2634, 
-  2635, 2636, 2637, 2638, 2639, 2640, 2641, 2642, 
-  0, 2643, 2644, 2645, 2646, 2647, 2648, 2649, 
-  2650, 2651, 2652, 2653, 2654, 2655, 2656, 2657, 
-  2658, 2659, 215, 2660, 2661, 215, 2662, 2663, 
-  215, 215, 215, 215, 215, 2664, 2665, 2666, 
-  2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 
-  2675, 2676, 2677, 2678, 2679, 2680, 2681, 2682, 
-  2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, 
-  2691, 2692, 2693, 2694, 2695, 2696, 2697, 2698, 
-  2699, 2700, 2701, 2702, 2703, 2704, 2705, 2706, 
-  2707, 2708, 2709, 2710, 2711, 2712, 2713, 2714, 
-  2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 
-  2723, 2724, 2725, 2726, 2727, 2728, 2729, 2730, 
-  2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 
-  2739, 2740, 2741, 2742, 2743, 2744, 2745, 2746, 
-  2747, 2748, 2749, 2750, 2751, 2752, 2753, 2754, 
-  2755, 2756, 2757, 2758, 2759, 2760, 2761, 2762, 
-  2763, 2764, 2765, 2766, 2767, 215, 77, 77, 
-  77, 77, 77, 77, 2768, 2769, 2770, 2771, 
-  543, 543, 543, 2772, 2773, 0, 0, 0, 
-  0, 0, 9, 9, 9, 9, 1211, 9, 
-  9, 2774, 2775, 2776, 2777, 2778, 2779, 2780, 
-  2781, 2782, 2783, 2784, 2785, 2786, 2787, 2788, 
-  2789, 2790, 2791, 2792, 2793, 2794, 2795, 2796, 
-  2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, 
-  2805, 2806, 2807, 2808, 2809, 2810, 2811, 0, 
-  2812, 0, 0, 0, 0, 0, 2813, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 0, 0, 0, 0, 0, 0, 0, 
-  2814, 1047, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1163, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 9, 9, 81, 93, 81, 93, 9, 
-  9, 9, 81, 93, 9, 81, 93, 9, 
-  9, 9, 9, 9, 9, 9, 9, 9, 
-  1087, 9, 9, 1087, 9, 81, 93, 9, 
-  9, 81, 93, 12, 13, 12, 13, 12, 
-  13, 12, 13, 9, 9, 9, 9, 9, 
-  524, 9, 9, 9, 9, 9, 9, 9, 
-  9, 9, 9, 1087, 1087, 9, 9, 9, 
-  9, 1087, 9, 2137, 9, 9, 9, 9, 
-  9, 9, 9, 9, 9, 9, 9, 9, 
-  9, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 0, 2815, 2815, 2815, 2815, 
-  2816, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2817, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2818, 2819, 2820, 2821, 2822, 2823, 2824, 
-  2825, 2826, 2827, 2828, 2829, 2830, 2831, 2832, 
-  2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, 
-  2841, 2842, 2843, 2844, 2845, 2846, 2847, 2848, 
-  2849, 2850, 2851, 2852, 2853, 2854, 2855, 2856, 
-  2857, 2858, 2859, 2860, 2861, 2862, 2863, 2864, 
-  2865, 2866, 2867, 2868, 2869, 2870, 2871, 2872, 
-  2873, 2874, 2875, 2876, 2877, 2878, 2879, 2880, 
-  2881, 2882, 2883, 2884, 2885, 2886, 2887, 2888, 
-  2889, 2890, 2891, 2892, 2893, 2894, 2895, 2896, 
-  2897, 2898, 2899, 2900, 2901, 2902, 2903, 2904, 
-  2905, 2906, 2907, 2908, 2909, 2910, 2911, 2912, 
-  2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, 
-  2921, 2922, 2923, 2924, 2925, 2926, 2927, 2928, 
-  2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 
-  2937, 2938, 2939, 2940, 2941, 2942, 2943, 2944, 
-  2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, 
-  2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, 
-  2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968, 
-  2969, 2970, 2971, 2972, 2973, 2974, 2975, 2976, 
-  2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 
-  2985, 2986, 2987, 2988, 2989, 2990, 2991, 2992, 
-  2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000, 
-  3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 
-  3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 
-  3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024, 
-  3025, 3026, 3027, 3028, 3029, 3030, 3031, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 0, 0, 0, 
-  0, 3032, 3033, 3033, 3033, 2815, 3034, 3035, 
-  3036, 3037, 3038, 3037, 3038, 3037, 3038, 3037, 
-  3038, 3037, 3038, 2815, 2815, 3037, 3038, 3037, 
-  3038, 3037, 3038, 3037, 3038, 3039, 3040, 3041, 
-  3041, 2815, 3036, 3036, 3036, 3036, 3036, 3036, 
-  3036, 3036, 3036, 3042, 1089, 555, 1088, 3043, 
-  3043, 3044, 3034, 3034, 3034, 3034, 3034, 3045, 
-  2815, 3046, 3047, 3048, 3034, 3035, 3049, 2815, 
-  77, 0, 3035, 3035, 3035, 3035, 3035, 3050, 
-  3035, 3035, 3035, 3035, 3051, 3052, 3053, 3054, 
-  3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 
-  3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, 
-  3071, 3072, 3073, 3074, 3035, 3075, 3076, 3077, 
-  3078, 3079, 3080, 3035, 3035, 3035, 3035, 3035, 
-  3081, 3082, 3083, 3084, 3085, 3086, 3087, 3088, 
-  3089, 3090, 3091, 3092, 3093, 3094, 3095, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3096, 3035, 3035, 
-  0, 0, 3097, 3098, 3099, 3100, 3101, 3102, 
-  3103, 3039, 3035, 3035, 3035, 3035, 3035, 3104, 
-  3035, 3035, 3035, 3035, 3105, 3106, 3107, 3108, 
-  3109, 3110, 3111, 3112, 3113, 3114, 3115, 3116, 
-  3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, 
-  3125, 3126, 3127, 3128, 3035, 3129, 3130, 3131, 
-  3132, 3133, 3134, 3035, 3035, 3035, 3035, 3035, 
-  3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, 
-  3143, 3144, 3145, 3146, 3147, 3148, 3149, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3150, 3151, 3152, 3153, 3035, 3154, 3035, 3035, 
-  3155, 3156, 3157, 3158, 3033, 3034, 3159, 3160, 
-  3161, 0, 0, 0, 0, 0, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 0, 3162, 3163, 3164, 3165, 3166, 3167, 
-  3168, 3169, 3170, 3171, 3172, 3173, 3174, 3175, 
-  3176, 3177, 3178, 3179, 3180, 3181, 3182, 3183, 
-  3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, 
-  3192, 3193, 3194, 3195, 3196, 3197, 3198, 3199, 
-  3200, 3201, 3202, 3203, 3204, 3205, 3206, 3207, 
-  3208, 3209, 3210, 3211, 3212, 3213, 3214, 3215, 
-  3216, 3217, 3218, 3219, 3220, 3221, 3222, 3223, 
-  3224, 3225, 3226, 3227, 3228, 3229, 3230, 3231, 
-  3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 
-  3240, 3241, 3242, 3243, 3244, 3245, 3246, 3247, 
-  3248, 3249, 3250, 3251, 3252, 3253, 3254, 3255, 
-  0, 3256, 3256, 3257, 3258, 3259, 3260, 3261, 
-  3262, 3263, 3264, 3265, 3266, 3267, 3268, 3269, 
-  3270, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 0, 0, 0, 0, 
-  0, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3271, 3272, 3273, 3274, 3275, 3276, 3277, 
-  3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, 
-  3286, 3287, 3288, 3289, 3290, 3291, 3292, 3293, 
-  3294, 3295, 3296, 3297, 3298, 3299, 3300, 3301, 
-  0, 3302, 3303, 3304, 3305, 3306, 3307, 3308, 
-  3309, 3310, 3311, 3312, 3313, 3314, 3315, 3316, 
-  3317, 3318, 3319, 3320, 3321, 3322, 3323, 3324, 
-  3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, 
-  3333, 3334, 3335, 3336, 3337, 3338, 3339, 3340, 
-  3341, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 3342, 3343, 3344, 3345, 3346, 3347, 3348, 
-  3349, 3350, 3351, 3352, 3353, 3354, 3355, 3356, 
-  3357, 3358, 3359, 3360, 3361, 3362, 3363, 3364, 
-  3365, 3366, 3367, 3368, 3369, 3370, 3371, 3372, 
-  3373, 3374, 3375, 3376, 3377, 3378, 3379, 3380, 
-  3381, 3382, 3383, 3384, 3385, 3386, 3387, 3388, 
-  3256, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 
-  3396, 3397, 3398, 3399, 3400, 3401, 3402, 3403, 
-  3404, 3405, 3406, 3407, 3408, 3409, 3410, 3411, 
-  3412, 3413, 3414, 3415, 3416, 3417, 3418, 3419, 
-  3420, 3421, 3422, 3423, 3424, 3425, 3426, 3427, 
-  3428, 3429, 3430, 3431, 3432, 3433, 3434, 3435, 
-  3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 
-  3444, 3445, 3446, 3447, 3448, 3449, 3450, 3451, 
-  3452, 3453, 3454, 3455, 3456, 3457, 3458, 3459, 
-  3460, 3461, 3462, 3463, 3464, 3465, 3466, 3467, 
-  3468, 3469, 3470, 3471, 3472, 3473, 3474, 3475, 
-  3476, 3477, 3478, 3479, 3480, 3481, 3482, 3483, 
-  3484, 3485, 3486, 3487, 3488, 3489, 3490, 3491, 
-  3492, 3493, 3494, 3495, 3496, 3497, 3498, 3499, 
-  3500, 3501, 3502, 3503, 3504, 3505, 3506, 3507, 
-  3508, 3509, 3510, 3511, 3512, 3513, 3514, 3515, 
-  3516, 3517, 3518, 3519, 3520, 3521, 3522, 3523, 
-  3524, 3525, 3526, 3527, 3528, 3529, 3530, 3531, 
-  3532, 3533, 3534, 3535, 3536, 3537, 3538, 3539, 
-  3540, 3541, 3542, 3543, 3544, 3545, 3546, 3547, 
-  3548, 3549, 3550, 3551, 3552, 3553, 3554, 3555, 
-  3556, 3557, 3558, 3559, 3560, 3561, 3562, 3563, 
-  3564, 3565, 3566, 3567, 3568, 3569, 3570, 3571, 
-  3572, 3573, 3574, 3575, 3576, 3577, 3578, 3579, 
-  3580, 3581, 3582, 3583, 3584, 3585, 3586, 3587, 
-  3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595, 
-  3596, 3597, 3598, 3599, 3600, 3601, 3602, 3603, 
-  3604, 3605, 3606, 3607, 3608, 3609, 3610, 3611, 
-  3612, 3613, 3614, 3615, 3616, 3617, 3618, 3619, 
-  3620, 3621, 3622, 3623, 3624, 3625, 3626, 3627, 
-  3628, 3629, 3630, 3631, 3632, 3633, 3634, 3635, 
-  3636, 3637, 3638, 3639, 3640, 3641, 3642, 3643, 
-  3644, 3645, 3646, 3647, 3648, 3649, 3650, 3651, 
-  3652, 3653, 3654, 3655, 3656, 3657, 3658, 3659, 
-  3660, 3661, 3662, 3663, 3664, 3665, 3666, 3667, 
-  3668, 3669, 3670, 3671, 3672, 3673, 3674, 3675, 
-  3676, 3677, 3678, 3679, 3680, 3681, 3682, 3683, 
-  3684, 3685, 3686, 3687, 3688, 3689, 3690, 3691, 
-  3692, 3693, 3694, 3695, 3696, 3697, 3698, 3699, 
-  3700, 3701, 3702, 3703, 3704, 3705, 3706, 3707, 
-  3708, 3709, 3710, 3711, 3712, 3713, 3714, 3715, 
-  3716, 3717, 3718, 3719, 3720, 3721, 3722, 3723, 
-  3724, 3725, 3726, 3727, 3728, 3729, 3730, 3731, 
-  3732, 3733, 3734, 3735, 3736, 3737, 3738, 3739, 
-  3740, 3741, 3742, 3743, 3744, 3745, 3746, 3747, 
-  3748, 3749, 3750, 3751, 3752, 3753, 3754, 3755, 
-  3756, 3757, 3758, 3759, 3760, 3761, 3762, 3763, 
-  3764, 3765, 3766, 3767, 3768, 3769, 3770, 3771, 
-  3772, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3034, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 0, 0, 
-  0, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  2815, 2815, 2815, 2815, 2815, 2815, 2815, 2815, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 525, 525, 525, 525, 525, 525, 1047, 
-  1047, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 525, 9, 9, 
-  9, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 341, 341, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3773, 3774, 3775, 3776, 3777, 3778, 3779, 
-  3780, 3781, 3782, 3783, 3784, 3785, 3786, 3787, 
-  3788, 3789, 3790, 3791, 3792, 3793, 3794, 3795, 
-  3796, 3797, 3798, 3799, 3800, 3801, 3802, 3803, 
-  3804, 3805, 3806, 3807, 3808, 3809, 3810, 3811, 
-  3812, 3813, 3814, 3815, 3816, 3817, 3818, 341, 
-  543, 842, 842, 842, 9, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 9, 
-  524, 3819, 3820, 3821, 3822, 3823, 3824, 3825, 
-  3826, 3827, 3828, 3829, 3830, 3831, 3832, 3833, 
-  3834, 3835, 3836, 3837, 3838, 3839, 3840, 3841, 
-  3842, 3843, 3844, 3845, 3846, 3847, 3848, 543, 
-  543, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 543, 543, 1047, 1047, 1047, 1047, 1047, 
-  1047, 0, 0, 0, 0, 0, 0, 0, 
-  0, 526, 526, 526, 526, 526, 526, 526, 
-  526, 526, 526, 526, 526, 526, 526, 526, 
-  526, 526, 526, 526, 526, 526, 526, 526, 
-  524, 524, 524, 524, 524, 524, 524, 524, 
-  524, 526, 526, 3849, 3850, 3851, 3852, 3853, 
-  3854, 3855, 3856, 3857, 3858, 3859, 3860, 3861, 
-  3862, 215, 215, 3863, 3864, 3865, 3866, 3867, 
-  3868, 3869, 3870, 3871, 3872, 3873, 3874, 3875, 
-  3876, 3877, 3878, 3879, 3880, 3881, 3882, 3883, 
-  3884, 3885, 3886, 3887, 3888, 3889, 3890, 3891, 
-  3892, 3893, 3894, 3895, 3896, 3897, 3898, 3899, 
-  3900, 3901, 3902, 3903, 3904, 3905, 3906, 3907, 
-  3908, 3909, 3910, 3911, 3912, 3913, 3914, 3915, 
-  3916, 3917, 3918, 3919, 3920, 3921, 3922, 3923, 
-  3924, 3925, 215, 215, 215, 215, 215, 215, 
-  215, 215, 3926, 3927, 3928, 3929, 3930, 3931, 
-  3932, 3933, 3934, 3935, 3936, 3937, 3938, 3939, 
-  3940, 524, 3941, 3941, 3942, 3943, 3944, 215, 
-  341, 3945, 3946, 3947, 3948, 3949, 215, 3950, 
-  3951, 3952, 3953, 3954, 3955, 3956, 3957, 3958, 
-  3959, 3960, 3961, 3962, 3963, 3964, 3965, 3966, 
-  3967, 3968, 3969, 3970, 3971, 3972, 3973, 3974, 
-  215, 3975, 3976, 3977, 3978, 3979, 3980, 3981, 
-  3982, 3983, 3984, 3985, 3986, 3987, 3988, 3989, 
-  3990, 0, 0, 3991, 3992, 3993, 3994, 3995, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  341, 3996, 3997, 215, 341, 341, 341, 341, 
-  341, 341, 341, 1151, 341, 341, 341, 1163, 
-  341, 341, 341, 341, 1151, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1155, 1155, 1151, 1151, 
-  1155, 77, 77, 77, 77, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 841, 
-  841, 11, 84, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 9, 9, 9, 
-  9, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1155, 1155, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1163, 1151, 0, 
-  0, 0, 0, 0, 0, 0, 0, 1047, 
-  1047, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 341, 341, 341, 341, 341, 
-  341, 1047, 1047, 1047, 341, 1047, 341, 341, 
-  1151, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 1151, 
-  1151, 1151, 1151, 1151, 556, 556, 556, 1047, 
-  1047, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1155, 1483, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1047, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 
-  1361, 1361, 1361, 1361, 1361, 1361, 0, 0, 
-  0, 1151, 1151, 1151, 1155, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1173, 1155, 1155, 1151, 
-  1151, 1151, 1151, 1155, 1155, 1151, 1151, 1155, 
-  1155, 1483, 1047, 1047, 1047, 1047, 1047, 1047, 
-  1047, 1047, 1047, 1047, 1047, 1047, 1047, 0, 
-  525, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 1047, 
-  1047, 341, 341, 341, 341, 341, 1151, 525, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1155, 1155, 1151, 1151, 1155, 1155, 1151, 1151, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 1151, 341, 341, 341, 
-  341, 341, 341, 341, 341, 1151, 1155, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 1047, 1047, 1047, 
-  1047, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 525, 341, 341, 341, 341, 341, 341, 
-  841, 841, 841, 341, 1272, 1151, 1272, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 543, 341, 543, 543, 556, 341, 341, 
-  543, 543, 341, 341, 341, 341, 341, 543, 
-  543, 341, 543, 341, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 341, 341, 525, 1047, 
-  1047, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1155, 1151, 1151, 1155, 
-  1155, 1047, 1047, 341, 525, 525, 1155, 1163, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 341, 341, 341, 341, 341, 341, 
-  0, 0, 341, 341, 341, 341, 341, 341, 
-  0, 0, 341, 341, 341, 341, 341, 341, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 215, 215, 215, 215, 
-  215, 215, 215, 215, 3998, 215, 215, 215, 
-  215, 215, 215, 215, 3941, 3999, 4000, 4001, 
-  4002, 215, 215, 215, 215, 215, 215, 215, 
-  215, 0, 0, 0, 0, 0, 0, 0, 
-  0, 4003, 4004, 4005, 4006, 4007, 4008, 4009, 
-  4010, 4011, 4012, 4013, 4014, 4015, 4016, 4017, 
-  4018, 4019, 4020, 4021, 4022, 4023, 4024, 4025, 
-  4026, 4027, 4028, 4029, 4030, 4031, 4032, 4033, 
-  4034, 4035, 4036, 4037, 4038, 4039, 4040, 4041, 
-  4042, 4043, 4044, 4045, 4046, 4047, 4048, 4049, 
-  4050, 4051, 4052, 4053, 4054, 4055, 4056, 4057, 
-  4058, 4059, 4060, 4061, 4062, 4063, 4064, 4065, 
-  4066, 4067, 4068, 4069, 4070, 4071, 4072, 4073, 
-  4074, 4075, 4076, 4077, 4078, 4079, 4080, 4081, 
-  4082, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1155, 1155, 1151, 1155, 
-  1155, 1151, 1155, 1155, 1047, 1155, 1163, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4083, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4083, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 4084, 4084, 4084, 
-  4084, 4084, 4084, 4084, 4084, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  1364, 1364, 1364, 1364, 1364, 1364, 1364, 1364, 
-  0, 0, 0, 0, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 
-  1365, 1365, 1365, 1365, 1365, 0, 0, 0, 
-  0, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4085, 4085, 4085, 4085, 4085, 4085, 4085, 
-  4085, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4087, 4088, 4089, 4090, 4091, 4092, 4093, 
-  4094, 4094, 4095, 4096, 4097, 4098, 4099, 4100, 
-  4101, 4102, 4103, 4104, 4105, 4106, 4107, 4108, 
-  4109, 4110, 4111, 4112, 4113, 4114, 4115, 4116, 
-  4117, 4118, 4119, 4120, 4121, 4122, 4123, 4124, 
-  4125, 4126, 4127, 4128, 4129, 4130, 4131, 4132, 
-  4133, 4134, 4135, 4136, 4137, 4138, 4139, 4140, 
-  4141, 4142, 4143, 4144, 4145, 4146, 4147, 4148, 
-  4149, 4150, 4151, 4152, 4153, 4154, 4155, 4156, 
-  4157, 4158, 4159, 4160, 4161, 4162, 4163, 4164, 
-  4165, 4166, 4167, 4168, 4169, 4170, 4171, 4172, 
-  4173, 4174, 4175, 4176, 4177, 4106, 4178, 4179, 
-  4180, 4181, 4182, 4183, 4184, 4185, 4186, 4187, 
-  4188, 4189, 4190, 4191, 4192, 4193, 4194, 4195, 
-  4196, 4197, 4198, 4199, 4200, 4201, 4202, 4203, 
-  4204, 4205, 4206, 4207, 4208, 4209, 4210, 4211, 
-  4212, 4213, 4214, 4215, 4216, 4217, 4218, 4219, 
-  4220, 4221, 4222, 4223, 4224, 4225, 4226, 4227, 
-  4228, 4229, 4230, 4231, 4232, 4233, 4234, 4235, 
-  4236, 4237, 4238, 4239, 4240, 4241, 4242, 4243, 
-  4244, 4245, 4196, 4246, 4247, 4248, 4249, 4250, 
-  4251, 4252, 4253, 4180, 4254, 4255, 4256, 4257, 
-  4258, 4259, 4260, 4261, 4262, 4263, 4264, 4265, 
-  4266, 4267, 4268, 4269, 4270, 4271, 4272, 4273, 
-  4106, 4274, 4275, 4276, 4277, 4278, 4279, 4280, 
-  4281, 4282, 4283, 4284, 4285, 4286, 4287, 4288, 
-  4289, 4290, 4291, 4292, 4293, 4294, 4295, 4296, 
-  4297, 4298, 4299, 4300, 4182, 4301, 4302, 4303, 
-  4304, 4305, 4306, 4307, 4308, 4309, 4310, 4311, 
-  4312, 4313, 4314, 4315, 4316, 4317, 4318, 4319, 
-  4320, 4321, 4322, 4323, 4324, 4325, 4326, 4327, 
-  4328, 4329, 4330, 4331, 4332, 4333, 4334, 4335, 
-  4336, 4337, 4338, 4339, 4340, 4341, 4342, 4343, 
-  4344, 4345, 4346, 4347, 4348, 4349, 4350, 3035, 
-  3035, 4351, 3035, 4352, 3035, 3035, 4353, 4354, 
-  4355, 4356, 4357, 4358, 4359, 4360, 4361, 4362, 
-  3035, 4363, 3035, 4364, 3035, 3035, 4365, 4366, 
-  3035, 3035, 3035, 4367, 4368, 4369, 4370, 4371, 
-  4372, 4373, 4374, 4375, 4376, 4377, 4378, 4379, 
-  4380, 4381, 4382, 4383, 4384, 4385, 4386, 4387, 
-  4388, 4389, 4390, 4391, 4392, 4393, 4394, 4395, 
-  4396, 4397, 4398, 4399, 4400, 4401, 4402, 4403, 
-  4404, 4405, 4406, 4407, 4408, 4409, 4410, 4411, 
-  4235, 4412, 4413, 4414, 4415, 4416, 4417, 4417, 
-  4418, 4419, 4420, 4421, 4422, 4423, 4424, 4425, 
-  4365, 4426, 4427, 4428, 4429, 4430, 4431, 0, 
-  0, 4432, 4433, 4434, 4435, 4436, 4437, 4438, 
-  4439, 4379, 4440, 4441, 4442, 4351, 4443, 4444, 
-  4445, 4446, 4447, 4448, 4449, 4450, 4451, 4452, 
-  4453, 4454, 4388, 4455, 4389, 4456, 4457, 4458, 
-  4459, 4460, 4352, 4127, 4461, 4462, 4463, 4197, 
-  4284, 4464, 4465, 4396, 4466, 4397, 4467, 4468, 
-  4469, 4354, 4470, 4471, 4472, 4473, 4474, 4355, 
-  4475, 4476, 4477, 4478, 4479, 4480, 4411, 4481, 
-  4482, 4235, 4483, 4415, 4484, 4485, 4486, 4487, 
-  4488, 4420, 4489, 4364, 4490, 4421, 4178, 4491, 
-  4422, 4492, 4424, 4493, 4494, 4495, 4496, 4497, 
-  4426, 4360, 4498, 4427, 4499, 4428, 4500, 4094, 
-  4501, 4502, 4503, 4504, 4505, 4506, 4507, 4508, 
-  4509, 4510, 4511, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 4512, 4513, 4514, 4515, 4516, 4517, 4518, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 4519, 4520, 4521, 4522, 
-  4523, 0, 0, 0, 0, 0, 4524, 4525, 
-  4526, 4527, 4528, 4529, 4530, 4531, 4532, 4533, 
-  4534, 4535, 4536, 4537, 4538, 4539, 4540, 4541, 
-  4542, 4543, 4544, 4545, 4546, 4547, 4548, 4549, 
-  0, 4550, 4551, 4552, 4553, 4554, 0, 4555, 
-  0, 4556, 4557, 0, 4558, 4559, 0, 4560, 
-  4561, 4562, 4563, 4564, 4565, 4566, 4567, 4568, 
-  4569, 4570, 4571, 4572, 4573, 4574, 4575, 4576, 
-  4577, 4578, 4579, 4580, 4581, 4582, 4583, 4584, 
-  4585, 4586, 4587, 4588, 4589, 4590, 4591, 4592, 
-  4593, 4594, 4595, 4596, 4597, 4598, 4599, 4600, 
-  4601, 4602, 4603, 4604, 4605, 4606, 4607, 4608, 
-  4609, 4610, 4611, 4612, 4613, 4614, 4615, 4616, 
-  4617, 4618, 4619, 4620, 4621, 4622, 4623, 4624, 
-  4625, 4626, 4627, 4628, 4629, 4630, 4631, 4632, 
-  4633, 4634, 4635, 4636, 4637, 4638, 4639, 4640, 
-  4641, 4642, 4643, 4644, 4645, 4646, 4647, 4648, 
-  4649, 4650, 4651, 4652, 4653, 4654, 4655, 4656, 
-  4657, 4658, 4659, 4660, 4661, 4662, 4663, 4664, 
-  4665, 4666, 4667, 4668, 4668, 4668, 4668, 4668, 
-  4668, 4668, 4668, 4668, 4668, 4668, 4668, 4668, 
-  4668, 4668, 4668, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 4669, 4670, 4671, 4672, 
-  4673, 4674, 4675, 4676, 4677, 4678, 4679, 4680, 
-  4681, 4682, 4683, 4684, 4685, 4686, 4687, 4688, 
-  4689, 4690, 4691, 4692, 4693, 4694, 4695, 4696, 
-  4697, 4698, 4699, 4700, 4701, 4702, 4703, 4704, 
-  4705, 4706, 4707, 4708, 4709, 4710, 4711, 4712, 
-  4713, 4714, 4715, 4716, 4707, 4717, 4718, 4719, 
-  4720, 4721, 4722, 4723, 4724, 4725, 4726, 4727, 
-  4728, 4729, 4730, 4731, 4732, 4733, 4734, 4735, 
-  4736, 4737, 4738, 4739, 4740, 4741, 4742, 4743, 
-  4744, 4745, 4746, 4747, 4748, 4749, 4750, 4751, 
-  4752, 4753, 4754, 4755, 4756, 4757, 4758, 4759, 
-  4760, 4761, 4762, 4763, 4764, 4765, 4766, 4767, 
-  4768, 4769, 4770, 4771, 4772, 4773, 4774, 4775, 
-  4776, 4777, 4778, 4779, 4780, 4781, 4782, 4783, 
-  4784, 4785, 4786, 4787, 4788, 4789, 4790, 4791, 
-  4792, 4793, 4794, 4795, 4796, 4797, 4798, 4799, 
-  4800, 4801, 4802, 4803, 4804, 4805, 4806, 4807, 
-  4808, 4809, 4810, 4811, 4812, 4813, 4814, 4815, 
-  4816, 4708, 4817, 4818, 4819, 4820, 4821, 4822, 
-  4823, 4824, 4825, 4826, 4827, 4828, 4829, 4830, 
-  4831, 4832, 4833, 4834, 4835, 4836, 4837, 4838, 
-  4839, 4840, 4841, 4842, 4843, 4844, 4845, 4846, 
-  4847, 4848, 4849, 4850, 4851, 4852, 4853, 4854, 
-  4855, 4856, 4857, 4858, 4859, 4860, 4861, 4862, 
-  4863, 4864, 4865, 4866, 4867, 4868, 4869, 4870, 
-  4871, 4872, 4873, 4874, 4875, 4876, 4877, 4878, 
-  4879, 4880, 4881, 4882, 4883, 4884, 4885, 4886, 
-  4887, 4888, 4889, 4890, 4891, 4892, 4893, 4894, 
-  4895, 4896, 4897, 4898, 4899, 4900, 4901, 4902, 
-  4903, 4904, 4905, 4906, 4907, 4908, 4909, 4910, 
-  4911, 4912, 4913, 4914, 4915, 4916, 4917, 4918, 
-  4919, 4920, 4921, 4922, 4923, 4924, 4925, 4926, 
-  4927, 4928, 4929, 4930, 4931, 4932, 4933, 4934, 
-  4935, 4936, 4937, 4938, 4939, 4940, 4941, 4942, 
-  4943, 4944, 4945, 4946, 4947, 4948, 4949, 4950, 
-  4951, 4952, 4953, 4954, 4955, 4956, 4957, 4958, 
-  4959, 4960, 4961, 4962, 4963, 4964, 4965, 4966, 
-  4967, 4968, 4969, 4970, 4971, 4972, 4973, 4974, 
-  4975, 4976, 4977, 4978, 4979, 4980, 4981, 4982, 
-  4983, 4984, 4985, 4986, 4987, 4988, 4989, 4990, 
-  4991, 4992, 4993, 4994, 4995, 4996, 4997, 4998, 
-  4999, 5000, 5001, 5002, 5003, 5004, 5005, 5006, 
-  5007, 5008, 5009, 5010, 5011, 5012, 5013, 5014, 
-  5015, 5016, 5017, 5018, 5019, 5020, 5021, 5022, 
-  5023, 5024, 5025, 5026, 5027, 5028, 5029, 5030, 
-  2137, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5031, 5032, 5033, 5034, 5035, 5036, 5037, 
-  5038, 5039, 5040, 5041, 5042, 5043, 5044, 5045, 
-  5046, 5047, 5048, 5049, 5050, 5051, 5052, 5053, 
-  5054, 5055, 5056, 5057, 5058, 5059, 5060, 5061, 
-  5062, 5063, 5064, 5065, 5066, 5067, 5068, 5069, 
-  5070, 5071, 5072, 5073, 5074, 5075, 5076, 5077, 
-  5078, 5079, 5080, 5081, 5082, 5083, 5084, 5085, 
-  5086, 5087, 5088, 5089, 5090, 5091, 5092, 5093, 
-  5094, 0, 0, 5095, 5096, 5097, 5098, 5099, 
-  5100, 5101, 5102, 5103, 5104, 5105, 5106, 5107, 
-  5108, 5109, 5110, 5111, 5112, 5113, 5114, 5115, 
-  5116, 5117, 5118, 5119, 5120, 5121, 5122, 5123, 
-  5124, 5125, 5126, 5127, 5128, 5129, 5130, 5131, 
-  5132, 5133, 5134, 5135, 5136, 5137, 5138, 5139, 
-  5140, 5141, 5142, 5143, 5144, 5145, 5146, 5147, 
-  5148, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5149, 5150, 5151, 5152, 5153, 5154, 5155, 
-  5156, 5157, 5158, 5159, 5160, 5161, 77, 0, 
-  0, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 5162, 5163, 5164, 5165, 5166, 5167, 5168, 
-  5169, 5170, 5171, 0, 0, 0, 0, 0, 
-  0, 543, 543, 543, 543, 543, 543, 543, 
-  556, 556, 556, 556, 556, 556, 556, 543, 
-  543, 5172, 5173, 5174, 5175, 5175, 5176, 5177, 
-  5178, 5179, 5180, 5181, 5182, 5183, 5184, 5185, 
-  5186, 5187, 5188, 5189, 5190, 5191, 3033, 3033, 
-  5192, 5193, 5194, 5194, 5194, 5194, 5195, 5195, 
-  5195, 5196, 5197, 5198, 0, 5199, 5200, 5201, 
-  5202, 5203, 5204, 5205, 5206, 5207, 5208, 5209, 
-  5210, 5211, 5212, 5213, 5214, 5215, 5216, 5217, 
-  0, 5218, 5219, 5220, 5221, 0, 0, 0, 
-  0, 5222, 5223, 5224, 1117, 5225, 0, 5226, 
-  5227, 5228, 5229, 5230, 5231, 5232, 5233, 5234, 
-  5235, 5236, 5237, 5238, 5239, 5240, 5241, 5242, 
-  5243, 5244, 5245, 5246, 5247, 5248, 5249, 5250, 
-  5251, 5252, 5253, 5254, 5255, 5256, 5257, 5258, 
-  5259, 5260, 5261, 5262, 5263, 5264, 5265, 5266, 
-  5267, 5268, 5269, 5270, 5271, 5272, 5273, 5274, 
-  5275, 5276, 5277, 5278, 5279, 5280, 5281, 5282, 
-  5283, 5284, 5285, 5286, 5287, 5288, 5289, 5290, 
-  5291, 5292, 5293, 5294, 5295, 5296, 5297, 5298, 
-  5299, 5300, 5301, 5302, 5303, 5304, 5305, 5306, 
-  5307, 5308, 5309, 5310, 5311, 5312, 5313, 5314, 
-  5315, 5316, 5317, 5318, 5319, 5320, 5321, 5322, 
-  5323, 5324, 5325, 5326, 5327, 5328, 5329, 5330, 
-  5331, 5332, 5333, 5334, 5335, 5336, 5337, 5338, 
-  5339, 5340, 5341, 5342, 5343, 5344, 5345, 5346, 
-  5347, 5348, 5349, 5350, 5351, 5352, 5353, 5354, 
-  5355, 5356, 5357, 5358, 5359, 5360, 0, 0, 
-  1459, 0, 5361, 5362, 5363, 5364, 5365, 5366, 
-  5367, 5368, 5369, 5370, 5371, 5372, 5373, 5374, 
-  5375, 5376, 5377, 5378, 5379, 5380, 5381, 5382, 
-  5383, 5384, 5385, 5386, 5387, 5388, 5389, 5390, 
-  5391, 5392, 5393, 5394, 5395, 5396, 5397, 5398, 
-  5399, 5400, 5401, 5402, 5403, 5404, 5405, 5406, 
-  5407, 5408, 5409, 5410, 5411, 5412, 5413, 5414, 
-  5415, 5416, 5417, 5418, 5419, 5420, 5421, 5422, 
-  5423, 5424, 5425, 5426, 5427, 5428, 5429, 5430, 
-  5431, 5432, 5433, 5434, 5435, 5436, 5437, 5438, 
-  5439, 5440, 5441, 5442, 5443, 5444, 5445, 5446, 
-  5447, 5448, 5449, 5450, 5451, 5452, 5453, 5454, 
-  5455, 5456, 5457, 5458, 5459, 5460, 5461, 5462, 
-  5463, 5464, 5465, 5466, 5467, 5468, 5469, 5470, 
-  5471, 5472, 5473, 5474, 5475, 5476, 5477, 5478, 
-  5479, 5480, 5481, 5482, 5483, 5484, 5485, 5486, 
-  5487, 5488, 5489, 5490, 5491, 5492, 5493, 5494, 
-  5495, 5496, 5497, 5498, 5499, 5500, 5501, 5502, 
-  5503, 5504, 5505, 5506, 5507, 5508, 5509, 5510, 
-  5511, 5512, 5513, 5514, 5515, 5516, 5517, 5518, 
-  5519, 5520, 5521, 5522, 5523, 5524, 5525, 5526, 
-  5527, 5528, 5529, 5530, 5531, 5532, 5533, 5534, 
-  5535, 5536, 5537, 5538, 5539, 5540, 5541, 5542, 
-  5543, 5544, 5545, 5546, 5547, 5548, 5549, 5550, 
-  0, 0, 0, 5551, 5552, 5553, 5554, 5555, 
-  5556, 0, 0, 5557, 5558, 5559, 5560, 5561, 
-  5562, 0, 0, 5563, 5564, 5565, 5566, 5567, 
-  5568, 0, 0, 5569, 5570, 5571, 0, 0, 
-  0, 5572, 5573, 5574, 5575, 5576, 5577, 5578, 
-  0, 5579, 5580, 5581, 5582, 5583, 5584, 5585, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 5586, 5586, 5586, 77, 77, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 0, 341, 341, 0, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 0, 0, 0, 0, 
-  0, 1047, 9, 1047, 0, 0, 0, 0, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 0, 0, 0, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 5587, 5587, 5587, 5587, 5587, 5587, 5587, 
-  5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, 
-  5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, 
-  5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, 
-  5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, 
-  5587, 5587, 5587, 5587, 5587, 5587, 5587, 5587, 
-  5587, 5587, 5587, 5587, 5587, 5587, 1211, 1211, 
-  1211, 1211, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 1211, 1211, 77, 841, 841, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 0, 0, 0, 
-  0, 77, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 556, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 556, 5588, 5588, 5588, 5588, 5588, 5588, 
-  5588, 5588, 5588, 5588, 5588, 5588, 5588, 5588, 
-  5588, 5588, 5588, 5588, 5588, 5588, 5588, 5588, 
-  5588, 5588, 5588, 5588, 5588, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 1182, 1182, 1182, 1182, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1458, 341, 341, 341, 341, 341, 
-  341, 341, 341, 1458, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 543, 
-  543, 543, 543, 543, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  1047, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 1047, 1458, 1458, 1458, 1458, 1458, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5589, 5590, 5591, 5592, 5593, 5594, 5595, 
-  5596, 5597, 5598, 5599, 5600, 5601, 5602, 5603, 
-  5604, 5605, 5606, 5607, 5608, 5609, 5610, 5611, 
-  5612, 5613, 5614, 5615, 5616, 5617, 5618, 5619, 
-  5620, 5621, 5622, 5623, 5624, 5625, 5626, 5627, 
-  5628, 5629, 5630, 5631, 5632, 5633, 5634, 5635, 
-  5636, 5637, 5638, 5639, 5640, 5641, 5642, 5643, 
-  5644, 5645, 5646, 5647, 5648, 5649, 5650, 5651, 
-  5652, 5653, 5654, 5655, 5656, 5657, 5658, 5659, 
-  5660, 5661, 5662, 5663, 5664, 5665, 5666, 5667, 
-  5668, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 5669, 5670, 5671, 5672, 5673, 5674, 5675, 
-  5676, 5677, 5678, 5679, 5680, 5681, 5682, 5683, 
-  5684, 5685, 5686, 5687, 5688, 5689, 5690, 5691, 
-  5692, 5693, 5694, 5695, 5696, 5697, 5698, 5699, 
-  5700, 5701, 5702, 5703, 5704, 0, 0, 0, 
-  0, 5705, 5706, 5707, 5708, 5709, 5710, 5711, 
-  5712, 5713, 5714, 5715, 5716, 5717, 5718, 5719, 
-  5720, 5721, 5722, 5723, 5724, 5725, 5726, 5727, 
-  5728, 5729, 5730, 5731, 5732, 5733, 5734, 5735, 
-  5736, 5737, 5738, 5739, 5740, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1047, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 0, 
-  0, 1108, 0, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, 
-  1108, 1108, 0, 0, 0, 1108, 0, 0, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, 
-  1105, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  5742, 5742, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 0, 1108, 1108, 0, 
-  0, 0, 0, 0, 5741, 5741, 5741, 5741, 
-  5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 5741, 
-  5741, 5741, 5741, 5741, 5741, 0, 0, 0, 
-  9, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 0, 0, 0, 0, 0, 
-  1105, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 0, 0, 0, 0, 5741, 5741, 1108, 
-  1108, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 0, 0, 5741, 5741, 5741, 5741, 5741, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 1108, 1151, 1151, 1151, 0, 1151, 1151, 
-  0, 0, 0, 0, 0, 1151, 556, 1151, 
-  543, 1108, 1108, 1108, 1108, 0, 1108, 1108, 
-  1108, 0, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, 
-  0, 543, 569, 556, 0, 0, 0, 0, 
-  1163, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 5741, 0, 0, 0, 0, 0, 0, 
-  0, 1105, 1105, 1105, 1105, 1105, 1105, 1105, 
-  1105, 1105, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 5741, 5741, 
-  1105, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 5741, 5741, 
-  5741, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 5742, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 543, 556, 
-  0, 0, 0, 0, 5741, 5741, 5741, 5741, 
-  5741, 1105, 1105, 1105, 1105, 1105, 1105, 1105, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, 
-  0, 0, 9, 9, 9, 9, 9, 9, 
-  9, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 0, 
-  0, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 0, 0, 0, 0, 
-  0, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 0, 0, 0, 0, 0, 
-  0, 0, 1105, 1105, 1105, 1105, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5743, 5744, 5745, 5746, 5747, 5748, 5749, 
-  5750, 5751, 5752, 5753, 5754, 5755, 5756, 5757, 
-  5758, 5759, 5760, 5761, 5762, 5763, 5764, 5765, 
-  5766, 5767, 5768, 5769, 5770, 5771, 5772, 5773, 
-  5774, 5775, 5776, 5777, 5778, 5779, 5780, 5781, 
-  5782, 5783, 5784, 5785, 5786, 5787, 5788, 5789, 
-  5790, 5791, 5792, 5793, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5794, 5795, 5796, 5797, 5798, 5799, 5800, 
-  5801, 5802, 5803, 5804, 5805, 5806, 5807, 5808, 
-  5809, 5810, 5811, 5812, 5813, 5814, 5815, 5816, 
-  5817, 5818, 5819, 5820, 5821, 5822, 5823, 5824, 
-  5825, 5826, 5827, 5828, 5829, 5830, 5831, 5832, 
-  5833, 5834, 5835, 5836, 5837, 5838, 5839, 5840, 
-  5841, 5842, 5843, 5844, 0, 0, 0, 0, 
-  0, 0, 0, 5741, 5741, 5741, 5741, 5741, 
-  5741, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 543, 543, 543, 
-  543, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1135, 1135, 1135, 1135, 1135, 1135, 1135, 
-  1135, 1135, 1135, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5845, 5845, 5845, 5845, 5845, 5845, 5845, 
-  5845, 5845, 5845, 5845, 5845, 5845, 5845, 5845, 
-  5845, 5845, 5845, 5845, 5845, 5845, 5845, 5845, 
-  5845, 5845, 5845, 5845, 5845, 5845, 5845, 5845, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 5741, 5741, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  1108, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 
-  1117, 1117, 1117, 1117, 1117, 1117, 1117, 556, 
-  556, 543, 543, 543, 556, 543, 556, 556, 
-  556, 556, 5846, 5846, 5846, 5846, 1112, 1112, 
-  1112, 1112, 1112, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1155, 1151, 1155, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1163, 
-  1047, 1047, 1047, 1047, 1047, 1047, 1047, 0, 
-  0, 0, 0, 1211, 1211, 1211, 1211, 1211, 
-  1211, 1211, 1211, 1211, 1211, 1211, 1211, 1211, 
-  1211, 1211, 1211, 1211, 1211, 1211, 1211, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1163, 1151, 1151, 1155, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 5847, 5848, 5849, 5850, 341, 341, 
-  341, 341, 341, 341, 341, 341, 5851, 341, 
-  341, 341, 341, 341, 5852, 341, 341, 341, 
-  341, 1155, 1155, 1155, 1151, 1151, 1151, 1151, 
-  1155, 1155, 1163, 5853, 1047, 1047, 5854, 1047, 
-  1047, 1047, 1047, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 5854, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 543, 543, 543, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  5855, 1151, 1151, 1151, 1151, 1155, 1151, 5856, 
-  5857, 1151, 5858, 5859, 1163, 1163, 0, 1172, 
-  1172, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1047, 1047, 1047, 1047, 341, 1155, 1155, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1173, 1047, 1047, 341, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1151, 1151, 1155, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1155, 1155, 1155, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1155, 1483, 341, 1228, 1228, 341, 1047, 1047, 
-  1047, 1047, 1151, 1173, 1151, 1151, 1047, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 341, 1047, 341, 1047, 1047, 
-  1047, 0, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 1155, 1155, 1155, 
-  1151, 1151, 1151, 1155, 1155, 1151, 1483, 1173, 
-  1151, 1047, 1047, 1047, 1047, 1047, 1047, 1151, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 0, 341, 341, 341, 341, 0, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1047, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  1151, 1155, 1155, 1155, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1173, 1163, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 1151, 1151, 1155, 1155, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 0, 
-  341, 341, 0, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 0, 341, 341, 
-  341, 341, 341, 0, 1173, 1173, 341, 5860, 
-  1155, 1151, 1155, 1155, 1155, 1155, 0, 0, 
-  5861, 1155, 0, 0, 5862, 5863, 1483, 0, 
-  0, 341, 0, 0, 0, 0, 0, 0, 
-  5864, 0, 0, 0, 0, 0, 341, 341, 
-  341, 341, 341, 1155, 1155, 0, 0, 543, 
-  543, 543, 543, 543, 543, 543, 0, 0, 
-  0, 543, 543, 543, 543, 543, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 1155, 1155, 
-  1155, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1155, 1155, 1163, 1151, 1151, 1155, 1173, 
-  341, 341, 341, 341, 1047, 1047, 1047, 1047, 
-  1047, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 1047, 0, 1047, 543, 
-  341, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 5865, 1155, 1155, 1151, 1151, 1151, 1151, 
-  1151, 1151, 5866, 5867, 5868, 5869, 5870, 5871, 
-  1151, 1151, 1155, 1163, 1173, 341, 341, 1047, 
-  341, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  5872, 1155, 1155, 1151, 1151, 1151, 1151, 0, 
-  0, 5873, 5874, 5875, 5876, 1151, 1151, 1155, 
-  1163, 1173, 1047, 1047, 1047, 1047, 1047, 1047, 
-  1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 
-  1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 
-  1047, 341, 341, 341, 341, 1151, 1151, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 1155, 1155, 1155, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1155, 1155, 1151, 1155, 
-  1163, 1151, 1047, 1047, 1047, 341, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 9, 9, 9, 9, 9, 9, 9, 
-  9, 9, 9, 9, 9, 9, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1151, 1155, 1151, 1155, 
-  1155, 1151, 1151, 1151, 1151, 1151, 1151, 1483, 
-  1173, 341, 0, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 0, 0, 1151, 1151, 
-  1151, 1155, 1155, 1151, 1151, 1151, 1151, 1155, 
-  1151, 1151, 1151, 1151, 1163, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1182, 1182, 1047, 1047, 1047, 
-  841, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 1155, 1155, 1155, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1155, 1163, 1173, 1047, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5877, 5878, 5879, 5880, 5881, 5882, 5883, 
-  5884, 5885, 5886, 5887, 5888, 5889, 5890, 5891, 
-  5892, 5893, 5894, 5895, 5896, 5897, 5898, 5899, 
-  5900, 5901, 5902, 5903, 5904, 5905, 5906, 5907, 
-  5908, 5909, 5910, 5911, 5912, 5913, 5914, 5915, 
-  5916, 5917, 5918, 5919, 5920, 5921, 5922, 5923, 
-  5924, 5925, 5926, 5927, 5928, 5929, 5930, 5931, 
-  5932, 5933, 5934, 5935, 5936, 5937, 5938, 5939, 
-  5940, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  341, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 0, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1155, 1155, 1155, 1151, 1151, 1151, 
-  1151, 0, 0, 1151, 1151, 1155, 1155, 1155, 
-  1155, 1163, 341, 1047, 341, 1155, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 1151, 1151, 1151, 1151, 1151, 1151, 
-  5941, 5941, 1151, 1151, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1151, 1163, 1151, 1151, 
-  1151, 1151, 1155, 1228, 1151, 1151, 1151, 1151, 
-  1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 
-  1163, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1155, 1155, 1151, 1151, 1151, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 1228, 1228, 1228, 
-  1228, 1228, 1228, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1155, 1151, 1163, 1047, 1047, 1047, 341, 1047, 
-  1047, 1047, 1047, 1047, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  1155, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  0, 1151, 1151, 1151, 1151, 1151, 1151, 1155, 
-  5942, 341, 1047, 1047, 1047, 1047, 1047, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 0, 0, 
-  0, 1047, 1047, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 0, 0, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 0, 1155, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1155, 1151, 1151, 1155, 1151, 1151, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  0, 341, 341, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 1151, 1151, 1151, 1151, 1151, 1151, 
-  0, 0, 0, 1151, 0, 1151, 1151, 0, 
-  1151, 1151, 1151, 1173, 1151, 1163, 1163, 1228, 
-  1151, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 0, 
-  341, 341, 0, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 1155, 1155, 1155, 1155, 1155, 
-  0, 1151, 1151, 0, 1155, 1155, 1151, 1155, 
-  1163, 341, 0, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 1151, 1151, 1155, 1155, 
-  1047, 1047, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 77, 77, 
-  77, 77, 77, 77, 77, 77, 11, 11, 
-  11, 11, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  1047, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  1458, 1458, 1458, 1458, 1458, 1458, 1458, 1458, 
-  0, 1047, 1047, 1047, 1047, 1047, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 5943, 5943, 5943, 5943, 5943, 5943, 5943, 
-  5943, 5943, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 1047, 
-  1047, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 0, 
-  0, 569, 569, 569, 569, 569, 1047, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 543, 543, 543, 543, 543, 543, 543, 
-  1047, 1047, 1047, 1047, 1047, 841, 841, 841, 
-  841, 525, 525, 525, 525, 1047, 841, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 0, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 0, 0, 0, 0, 0, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 5944, 5945, 5946, 5947, 5948, 5949, 5950, 
-  5951, 5952, 5953, 5954, 5955, 5956, 5957, 5958, 
-  5959, 5960, 5961, 5962, 5963, 5964, 5965, 5966, 
-  5967, 5968, 5969, 5970, 5971, 5972, 5973, 5974, 
-  5975, 5976, 5977, 5978, 5979, 5980, 5981, 5982, 
-  5983, 5984, 5985, 5986, 5987, 5988, 5989, 5990, 
-  5991, 5992, 5993, 5994, 5995, 5996, 5997, 5998, 
-  5999, 6000, 6001, 6002, 6003, 6004, 6005, 6006, 
-  6007, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1047, 1047, 1047, 1047, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 0, 0, 0, 0, 
-  1151, 341, 1155, 1155, 1155, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 
-  1155, 1155, 1155, 1155, 1155, 1155, 1155, 1155, 
-  1155, 0, 0, 0, 0, 0, 0, 0, 
-  1151, 1151, 1151, 1151, 525, 525, 525, 525, 
-  525, 525, 525, 525, 525, 525, 525, 525, 
-  525, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3034, 3034, 3033, 3034, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 3035, 3035, 3035, 
-  3035, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 0, 0, 841, 1151, 569, 
-  1047, 1459, 1459, 1459, 1459, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  0, 0, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  6008, 6009, 841, 841, 841, 841, 841, 6010, 
-  6011, 6012, 6013, 6014, 6015, 6016, 6017, 6018, 
-  569, 569, 569, 841, 841, 841, 6019, 6020, 
-  6021, 6022, 6023, 6024, 1459, 1459, 1459, 1459, 
-  1459, 1459, 1459, 1459, 556, 556, 556, 556, 
-  556, 556, 556, 556, 841, 841, 543, 543, 
-  543, 543, 543, 556, 556, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 543, 543, 543, 543, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 6025, 6026, 6027, 6028, 6029, 6030, 
-  6031, 6032, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 543, 543, 543, 77, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 1182, 1182, 1182, 1182, 1182, 1182, 
-  1182, 1182, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6033, 2233, 2208, 2251, 2235, 2236, 6034, 
-  2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, 
-  2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, 
-  6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, 
-  6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, 
-  6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, 
-  6058, 6059, 6060, 6061, 6062, 6033, 2233, 2208, 
-  2251, 2235, 2236, 6034, 2215, 2218, 6035, 6036, 
-  2219, 2238, 2221, 6037, 2223, 2224, 2225, 6038, 
-  6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, 
-  6046, 6047, 2252, 2234, 6048, 2214, 0, 2253, 
-  2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, 
-  6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, 
-  6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, 
-  2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, 
-  2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, 
-  6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, 
-  6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, 
-  6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, 
-  6058, 6059, 6060, 6061, 6062, 6033, 0, 2208, 
-  2251, 0, 0, 6034, 0, 0, 6035, 6036, 
-  0, 0, 2221, 6037, 2223, 2224, 0, 6038, 
-  6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, 
-  6046, 6047, 2252, 0, 6048, 0, 2216, 2253, 
-  2254, 6049, 2220, 6050, 6051, 0, 6052, 6053, 
-  6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, 
-  6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, 
-  2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, 
-  2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, 
-  6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, 
-  6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, 
-  6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, 
-  6058, 6059, 6060, 6061, 6062, 6033, 2233, 0, 
-  2251, 2235, 2236, 6034, 0, 0, 6035, 6036, 
-  2219, 2238, 2221, 6037, 2223, 2224, 0, 6038, 
-  6039, 6040, 6041, 6042, 6043, 6044, 0, 6045, 
-  6046, 6047, 2252, 2234, 6048, 2214, 2216, 2253, 
-  2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, 
-  6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, 
-  6062, 6033, 2233, 0, 2251, 2235, 2236, 6034, 
-  0, 2218, 6035, 6036, 2219, 2238, 0, 6037, 
-  0, 0, 0, 6038, 6039, 6040, 6041, 6042, 
-  6043, 6044, 0, 6045, 6046, 6047, 2252, 2234, 
-  6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, 
-  6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, 
-  6058, 6059, 6060, 6061, 6062, 6033, 2233, 2208, 
-  2251, 2235, 2236, 6034, 2215, 2218, 6035, 6036, 
-  2219, 2238, 2221, 6037, 2223, 2224, 2225, 6038, 
-  6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, 
-  6046, 6047, 2252, 2234, 6048, 2214, 2216, 2253, 
-  2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, 
-  6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, 
-  6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, 
-  2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, 
-  2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, 
-  6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, 
-  6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, 
-  6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, 
-  6058, 6059, 6060, 6061, 6062, 6033, 2233, 2208, 
-  2251, 2235, 2236, 6034, 2215, 2218, 6035, 6036, 
-  2219, 2238, 2221, 6037, 2223, 2224, 2225, 6038, 
-  6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, 
-  6046, 6047, 2252, 2234, 6048, 2214, 2216, 2253, 
-  2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, 
-  6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, 
-  6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, 
-  2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, 
-  2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, 
-  6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, 
-  6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, 
-  6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, 
-  6058, 6059, 6060, 6061, 6062, 6033, 2233, 2208, 
-  2251, 2235, 2236, 6034, 2215, 2218, 6035, 6036, 
-  2219, 2238, 2221, 6037, 2223, 2224, 2225, 6038, 
-  6039, 6040, 6041, 6042, 6043, 6044, 2229, 6045, 
-  6046, 6047, 2252, 2234, 6048, 2214, 2216, 2253, 
-  2254, 6049, 2220, 6050, 6051, 2239, 6052, 6053, 
-  6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, 
-  6062, 6033, 2233, 2208, 2251, 2235, 2236, 6034, 
-  2215, 2218, 6035, 6036, 2219, 2238, 2221, 6037, 
-  2223, 2224, 2225, 6038, 6039, 6040, 6041, 6042, 
-  6043, 6044, 2229, 6045, 6046, 6047, 2252, 2234, 
-  6048, 2214, 2216, 2253, 2254, 6049, 2220, 6050, 
-  6051, 2239, 6052, 6053, 6054, 6055, 6056, 6057, 
-  6058, 6059, 6060, 6061, 6062, 6063, 6064, 0, 
-  0, 6065, 6066, 2248, 6067, 6068, 6069, 6070, 
-  6071, 6072, 6073, 6074, 6075, 6076, 6077, 6078, 
-  2249, 6079, 6080, 6081, 6082, 6083, 6084, 6085, 
-  6086, 6087, 6088, 6089, 6090, 2247, 6091, 6092, 
-  6093, 6094, 6095, 6096, 6097, 6098, 6099, 6100, 
-  6101, 6102, 2246, 6103, 6104, 6105, 6106, 6107, 
-  6108, 6109, 6110, 6111, 6112, 6113, 6114, 6115, 
-  6116, 6117, 6118, 6065, 6066, 2248, 6067, 6068, 
-  6069, 6070, 6071, 6072, 6073, 6074, 6075, 6076, 
-  6077, 6078, 2249, 6079, 6080, 6081, 6082, 6083, 
-  6084, 6085, 6086, 6087, 6088, 6089, 6090, 2247, 
-  6091, 6092, 6093, 6094, 6095, 6096, 6097, 6098, 
-  6099, 6100, 6101, 6102, 2246, 6103, 6104, 6105, 
-  6106, 6107, 6108, 6109, 6110, 6111, 6112, 6113, 
-  6114, 6115, 6116, 6117, 6118, 6065, 6066, 2248, 
-  6067, 6068, 6069, 6070, 6071, 6072, 6073, 6074, 
-  6075, 6076, 6077, 6078, 2249, 6079, 6080, 6081, 
-  6082, 6083, 6084, 6085, 6086, 6087, 6088, 6089, 
-  6090, 2247, 6091, 6092, 6093, 6094, 6095, 6096, 
-  6097, 6098, 6099, 6100, 6101, 6102, 2246, 6103, 
-  6104, 6105, 6106, 6107, 6108, 6109, 6110, 6111, 
-  6112, 6113, 6114, 6115, 6116, 6117, 6118, 6065, 
-  6066, 2248, 6067, 6068, 6069, 6070, 6071, 6072, 
-  6073, 6074, 6075, 6076, 6077, 6078, 2249, 6079, 
-  6080, 6081, 6082, 6083, 6084, 6085, 6086, 6087, 
-  6088, 6089, 6090, 2247, 6091, 6092, 6093, 6094, 
-  6095, 6096, 6097, 6098, 6099, 6100, 6101, 6102, 
-  2246, 6103, 6104, 6105, 6106, 6107, 6108, 6109, 
-  6110, 6111, 6112, 6113, 6114, 6115, 6116, 6117, 
-  6118, 6065, 6066, 2248, 6067, 6068, 6069, 6070, 
-  6071, 6072, 6073, 6074, 6075, 6076, 6077, 6078, 
-  2249, 6079, 6080, 6081, 6082, 6083, 6084, 6085, 
-  6086, 6087, 6088, 6089, 6090, 2247, 6091, 6092, 
-  6093, 6094, 6095, 6096, 6097, 6098, 6099, 6100, 
-  6101, 6102, 2246, 6103, 6104, 6105, 6106, 6107, 
-  6108, 6109, 6110, 6111, 6112, 6113, 6114, 6115, 
-  6116, 6117, 6118, 6119, 6120, 0, 0, 6121, 
-  6122, 6123, 6124, 6125, 6126, 6127, 6128, 6129, 
-  6130, 6121, 6122, 6123, 6124, 6125, 6126, 6127, 
-  6128, 6129, 6130, 6121, 6122, 6123, 6124, 6125, 
-  6126, 6127, 6128, 6129, 6130, 6121, 6122, 6123, 
-  6124, 6125, 6126, 6127, 6128, 6129, 6130, 6121, 
-  6122, 6123, 6124, 6125, 6126, 6127, 6128, 6129, 
-  6130, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  841, 841, 841, 841, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 841, 841, 
-  841, 841, 841, 841, 841, 841, 1151, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 1151, 841, 841, 
-  1047, 1047, 1047, 1047, 1047, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 1151, 1151, 1151, 1151, 
-  1151, 0, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 
-  1151, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 543, 543, 543, 543, 543, 543, 543, 
-  0, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 543, 543, 543, 543, 543, 543, 
-  543, 543, 0, 0, 543, 543, 543, 543, 
-  543, 543, 543, 0, 543, 543, 0, 543, 
-  543, 543, 543, 543, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 0, 0, 
-  0, 543, 543, 543, 543, 543, 543, 543, 
-  525, 525, 525, 525, 525, 525, 525, 0, 
-  0, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 341, 
-  841, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 341, 341, 341, 
-  341, 341, 341, 341, 341, 543, 543, 543, 
-  543, 1172, 1172, 1172, 1172, 1172, 1172, 1172, 
-  1172, 1172, 1172, 0, 0, 0, 0, 0, 
-  11, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 1108, 1108, 
-  1108, 1108, 1108, 1108, 1108, 1108, 0, 0, 
-  5741, 5741, 5741, 5741, 5741, 5741, 5741, 5741, 
-  5741, 556, 556, 556, 556, 556, 556, 556, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6131, 6132, 6133, 6134, 6135, 6136, 6137, 
-  6138, 6139, 6140, 6141, 6142, 6143, 6144, 6145, 
-  6146, 6147, 6148, 6149, 6150, 6151, 6152, 6153, 
-  6154, 6155, 6156, 6157, 6158, 6159, 6160, 6161, 
-  6162, 6163, 6164, 6165, 6166, 6167, 6168, 6169, 
-  6170, 6171, 6172, 6173, 6174, 6175, 6176, 6177, 
-  6178, 6179, 6180, 6181, 6182, 6183, 6184, 6185, 
-  6186, 6187, 6188, 6189, 6190, 6191, 6192, 6193, 
-  6194, 6195, 6196, 6197, 6198, 543, 543, 543, 
-  543, 543, 543, 1173, 1153, 0, 0, 0, 
-  0, 1152, 1152, 1152, 1152, 1152, 1152, 1152, 
-  1152, 1152, 1152, 0, 0, 0, 0, 1105, 
-  1105, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 1148, 5846, 5846, 
-  5846, 1111, 5846, 5846, 5846, 5846, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 1148, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 5846, 
-  5846, 5846, 5846, 5846, 5846, 5846, 5846, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6199, 6200, 6201, 6202, 0, 6203, 6204, 
-  6205, 6206, 6207, 6208, 6209, 6210, 6211, 6212, 
-  6213, 6214, 6215, 6216, 6217, 6218, 6219, 6220, 
-  6221, 6222, 6223, 6224, 6225, 6226, 6227, 6228, 
-  6229, 0, 6200, 6201, 0, 6230, 0, 0, 
-  6205, 0, 6207, 6208, 6209, 6210, 6211, 6212, 
-  6213, 6214, 6215, 6216, 0, 6218, 6219, 6220, 
-  6221, 0, 6223, 0, 6225, 0, 0, 0, 
-  0, 0, 0, 6201, 0, 0, 0, 0, 
-  6205, 0, 6207, 0, 6209, 0, 6211, 6212, 
-  6213, 0, 6215, 6216, 0, 6218, 0, 0, 
-  6221, 0, 6223, 0, 6225, 0, 6227, 0, 
-  6229, 0, 6200, 6201, 0, 6230, 0, 0, 
-  6205, 6206, 6207, 6208, 0, 6210, 6211, 6212, 
-  6213, 6214, 6215, 6216, 0, 6218, 6219, 6220, 
-  6221, 0, 6223, 6224, 6225, 6226, 0, 6228, 
-  0, 6199, 6200, 6201, 6202, 6230, 6203, 6204, 
-  6205, 6206, 6207, 0, 6209, 6210, 6211, 6212, 
-  6213, 6214, 6215, 6216, 6217, 6218, 6219, 6220, 
-  6221, 6222, 6223, 6224, 6225, 0, 0, 0, 
-  0, 0, 6200, 6201, 6202, 0, 6203, 6204, 
-  6205, 6206, 6207, 0, 6209, 6210, 6211, 6212, 
-  6213, 6214, 6215, 6216, 6217, 6218, 6219, 6220, 
-  6221, 6222, 6223, 6224, 6225, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 75, 75, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 79, 79, 79, 79, 2397, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 0, 0, 0, 
-  0, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  0, 0, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 0, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  2397, 0, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6231, 6232, 6233, 6234, 6235, 6236, 6237, 
-  6238, 6239, 6240, 6241, 1211, 1211, 0, 0, 
-  0, 6242, 6243, 6244, 6245, 6246, 6247, 6248, 
-  6249, 6250, 6251, 6252, 6253, 6254, 6255, 6256, 
-  6257, 6258, 6259, 6260, 6261, 6262, 6263, 6264, 
-  6265, 6266, 6267, 6268, 6269, 6270, 6271, 6272, 
-  79, 6273, 6274, 6275, 6276, 6277, 6278, 6279, 
-  6280, 6281, 6282, 6283, 6284, 6285, 6286, 6287, 
-  6288, 6289, 6290, 6291, 6292, 6293, 6294, 6295, 
-  6296, 6297, 6298, 6299, 6300, 6301, 6302, 6303, 
-  6304, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 6305, 6306, 6307, 0, 0, 
-  0, 2541, 2541, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 2541, 
-  2541, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 6308, 
-  841, 6309, 6308, 6308, 6308, 6308, 6308, 6308, 
-  6308, 6308, 6308, 6308, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 841, 841, 
-  841, 841, 841, 841, 841, 841, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 6310, 
-  6310, 6310, 6310, 6310, 6310, 6310, 6310, 6310, 
-  6310, 6310, 6310, 6310, 6310, 6310, 6310, 6310, 
-  6310, 6310, 6310, 6310, 6310, 6310, 6310, 6310, 
-  6310, 6311, 6312, 6313, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6314, 6315, 6316, 6317, 6318, 6319, 6320, 
-  6321, 6322, 6323, 6324, 6325, 6326, 6327, 6328, 
-  6329, 6330, 6331, 6332, 6333, 6334, 6335, 6336, 
-  6337, 6338, 6339, 6340, 6341, 6342, 6343, 6344, 
-  6345, 6346, 6347, 6348, 6349, 6350, 6351, 6352, 
-  6353, 6354, 6355, 6356, 6357, 0, 0, 0, 
-  0, 6358, 6359, 6360, 6361, 6362, 6363, 6364, 
-  6365, 6366, 0, 0, 0, 0, 0, 0, 
-  0, 6367, 6368, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2397, 2397, 2397, 2397, 2397, 2397, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 79, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 79, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 79, 79, 79, 79, 
-  2397, 2397, 2397, 2397, 2397, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 79, 79, 79, 2397, 79, 79, 
-  79, 2397, 2397, 2397, 6369, 6369, 6369, 6369, 
-  6369, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  79, 2397, 79, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 79, 79, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 77, 
-  77, 77, 77, 77, 77, 77, 77, 79, 
-  79, 79, 79, 79, 2397, 2397, 2397, 2397, 
-  79, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 2397, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 2397, 2397, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 2397, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 79, 
-  79, 79, 79, 79, 79, 2397, 79, 79, 
-  79, 2397, 2397, 2397, 79, 79, 2397, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 2397, 2397, 0, 0, 
-  0, 79, 79, 79, 79, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 79, 79, 
-  79, 79, 0, 0, 0, 0, 0, 0, 
-  0, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 77, 77, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 77, 77, 77, 77, 77, 77, 77, 
-  77, 77, 77, 77, 77, 0, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2815, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2815, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 0, 2397, 2397, 2397, 2397, 
-  0, 0, 0, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 0, 0, 2397, 2397, 
-  2397, 2397, 2397, 2397, 0, 0, 0, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 0, 0, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 2397, 2397, 2397, 2397, 2397, 2397, 2397, 
-  2397, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 79, 79, 79, 79, 79, 79, 79, 
-  79, 79, 79, 79, 79, 79, 79, 0, 
-  0, 2397, 2397, 2397, 2397, 0, 0, 0, 
-  0, 2397, 2397, 2397, 0, 0, 0, 0, 
-  0, 2397, 2397, 2397, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2397, 2397, 2397, 2397, 2397, 2397, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 3035, 3035, 3035, 3035, 3035, 3035, 
-  3035, 3035, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 6370, 6371, 6372, 6373, 6374, 4373, 6375, 
-  6376, 6377, 6378, 4374, 6379, 6380, 6381, 4375, 
-  6382, 6383, 6384, 6385, 6386, 6387, 6388, 6389, 
-  6390, 6391, 6392, 6393, 4433, 6394, 6395, 6396, 
-  6397, 6398, 6399, 6400, 6401, 6402, 4438, 4376, 
-  4377, 4439, 6403, 6404, 4184, 6405, 4378, 6406, 
-  6407, 6408, 6409, 6409, 6409, 6410, 6411, 6412, 
-  6413, 6414, 6415, 6416, 6417, 6418, 6419, 6420, 
-  6421, 6422, 6423, 6424, 6425, 6426, 6427, 6427, 
-  4441, 6428, 6429, 6430, 6431, 4380, 6432, 6433, 
-  6434, 4337, 6435, 6436, 6437, 6438, 6439, 6440, 
-  6441, 6442, 6443, 6444, 6445, 6446, 6447, 6448, 
-  6449, 6450, 6451, 6452, 6453, 6454, 6455, 6456, 
-  6457, 6458, 6459, 6460, 6460, 6461, 6462, 6463, 
-  4180, 6464, 6465, 6466, 6467, 6468, 6469, 6470, 
-  6471, 4385, 6472, 6473, 6474, 6475, 6476, 6477, 
-  6478, 6479, 6480, 6481, 6482, 6483, 6484, 6485, 
-  6486, 6487, 6488, 6489, 6490, 6491, 6492, 4126, 
-  6493, 6494, 6495, 6495, 6496, 6497, 6497, 6498, 
-  6499, 6500, 6501, 6502, 6503, 6504, 6505, 6506, 
-  6507, 6508, 6509, 6510, 4386, 6511, 6512, 6513, 
-  6514, 4453, 6514, 6515, 4388, 6516, 6517, 6518, 
-  6519, 4389, 4099, 6520, 6521, 6522, 6523, 6524, 
-  6525, 6526, 6527, 6528, 6529, 6530, 6531, 6532, 
-  6533, 6534, 6535, 6536, 6537, 6538, 6539, 6540, 
-  6541, 4390, 6542, 6543, 6544, 6545, 6546, 6547, 
-  4392, 6548, 6549, 6550, 6551, 6552, 6553, 6554, 
-  6555, 4127, 4461, 6556, 6557, 6558, 6559, 6560, 
-  6561, 6562, 6563, 4393, 6564, 6565, 6566, 6567, 
-  4504, 6568, 6569, 6570, 6571, 6572, 6573, 6574, 
-  6575, 6576, 6577, 6578, 6579, 6580, 4197, 6581, 
-  6582, 6583, 6584, 6585, 6586, 6587, 6588, 6589, 
-  6590, 6591, 4394, 4284, 6592, 6593, 6594, 6595, 
-  6596, 6597, 6598, 6599, 4465, 6600, 6601, 6602, 
-  6603, 6604, 6605, 6606, 6607, 4466, 6608, 6609, 
-  6610, 6611, 6612, 6613, 6614, 6615, 6616, 6617, 
-  6618, 6619, 4468, 6620, 6621, 6622, 6623, 6624, 
-  6625, 6626, 6627, 6628, 6629, 6630, 6630, 6631, 
-  6632, 4470, 6633, 6634, 6635, 6636, 6637, 6638, 
-  6639, 4183, 6640, 6641, 6642, 6643, 6644, 6645, 
-  6646, 4476, 6647, 6648, 6649, 6650, 6651, 6652, 
-  6652, 4477, 4506, 6653, 6654, 6655, 6656, 6657, 
-  4145, 4479, 6658, 6659, 4405, 6660, 6661, 4359, 
-  6662, 6663, 4409, 6664, 6665, 6666, 6667, 6667, 
-  6668, 6669, 6670, 6671, 6672, 6673, 6674, 6675, 
-  6676, 6677, 6678, 6679, 6680, 6681, 6682, 6683, 
-  6684, 6685, 6686, 6687, 6688, 6689, 6690, 6691, 
-  6692, 6693, 6694, 4415, 6695, 6696, 6697, 6698, 
-  6699, 6700, 6701, 6702, 6703, 6704, 6705, 6706, 
-  6707, 6708, 6709, 6710, 6496, 6711, 6712, 6713, 
-  6714, 6715, 6716, 6717, 6718, 6719, 6720, 6721, 
-  6722, 4201, 6723, 6724, 6725, 6726, 6727, 6728, 
-  4418, 6729, 6730, 6731, 6732, 6733, 6734, 6735, 
-  6736, 6737, 6738, 6739, 6740, 6741, 6742, 6743, 
-  6744, 6745, 6746, 6747, 6748, 4140, 6749, 6750, 
-  6751, 6752, 6753, 6754, 4486, 6755, 6756, 6757, 
-  6758, 6759, 6760, 6761, 6762, 6763, 6764, 6765, 
-  6766, 6767, 6768, 6769, 6770, 6771, 6772, 6773, 
-  6774, 4491, 4492, 6775, 6776, 6777, 6778, 6779, 
-  6780, 6781, 6782, 6783, 6784, 6785, 6786, 6787, 
-  4493, 6788, 6789, 6790, 6791, 6792, 6793, 6794, 
-  6795, 6796, 6797, 6798, 6799, 6800, 6801, 6802, 
-  6803, 6804, 6805, 6806, 6807, 6808, 6809, 6810, 
-  6811, 6812, 6813, 6814, 6815, 6816, 6817, 4499, 
-  4499, 6818, 6819, 6820, 6821, 6822, 6823, 6824, 
-  6825, 6826, 6827, 4500, 6828, 6829, 6830, 6831, 
-  6832, 6833, 6834, 6835, 6836, 6837, 6838, 6839, 
-  6840, 6841, 6842, 6843, 6844, 6845, 6846, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 1459, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 2129, 2129, 2129, 2129, 2129, 2129, 2129, 
-  2129, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 577, 577, 577, 577, 577, 577, 577, 
-  577, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 4086, 
-  4086, 4086, 4086, 4086, 4086, 4086, 4086, 0, 
-  0, };
-
-static const utf8proc_property_t utf8proc_properties[] = {
-  {0, 0, 0, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX,  false,false,false,false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_S, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_LF},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CR},
-  {UTF8PROC_CATEGORY_CC, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5093, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5084, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5096, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1, UINT16_MAX, 1, UINT16_MAX, 2784, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2, UINT16_MAX, 2, UINT16_MAX, 49, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3, UINT16_MAX, 3, UINT16_MAX, 704, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 4, UINT16_MAX, 4, UINT16_MAX, 62, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5, UINT16_MAX, 5, UINT16_MAX, 2872, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6, UINT16_MAX, 6, UINT16_MAX, 782, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7, UINT16_MAX, 7, UINT16_MAX, 808, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8, UINT16_MAX, 8, UINT16_MAX, 111, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 9, UINT16_MAX, 9, UINT16_MAX, 898, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 10, UINT16_MAX, 10, UINT16_MAX, 913, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 11, UINT16_MAX, 11, UINT16_MAX, 999, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 12, UINT16_MAX, 12, UINT16_MAX, 2890, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 13, UINT16_MAX, 13, UINT16_MAX, 160, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 14, UINT16_MAX, 14, UINT16_MAX, 205, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 15, UINT16_MAX, 15, UINT16_MAX, 2982, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 16, UINT16_MAX, 16, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 17, UINT16_MAX, 17, UINT16_MAX, 1087, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 18, UINT16_MAX, 18, UINT16_MAX, 1173, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 19, UINT16_MAX, 19, UINT16_MAX, 1257, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 20, UINT16_MAX, 20, UINT16_MAX, 254, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 21, UINT16_MAX, 21, UINT16_MAX, 3042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 22, UINT16_MAX, 22, UINT16_MAX, 1337, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 23, UINT16_MAX, 23, UINT16_MAX, 3122, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 24, UINT16_MAX, 24, UINT16_MAX, 303, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 25, UINT16_MAX, 25, UINT16_MAX, 1423, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1491, UINT16_MAX, 1491, 352, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1493, UINT16_MAX, 1493, 2818, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2812, UINT16_MAX, 2812, 401, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1494, UINT16_MAX, 1494, 743, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1495, UINT16_MAX, 1495, 414, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2837, UINT16_MAX, 2837, 2875, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1497, UINT16_MAX, 1497, 795, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1498, UINT16_MAX, 1498, 853, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1499, UINT16_MAX, 1499, 463, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1500, UINT16_MAX, 1500, 901, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1501, UINT16_MAX, 1501, 956, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1502, UINT16_MAX, 1502, 1043, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1503, UINT16_MAX, 1503, 2932, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1504, UINT16_MAX, 1504, 512, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1505, UINT16_MAX, 1505, 557, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1507, UINT16_MAX, 1507, 2994, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2826, UINT16_MAX, 2826, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1508, UINT16_MAX, 1508, 1130, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3305, UINT16_MAX, 3305, 1215, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1509, UINT16_MAX, 1509, 1296, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1510, UINT16_MAX, 1510, 606, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2908, UINT16_MAX, 2908, 3082, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1511, UINT16_MAX, 1511, 1380, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2925, UINT16_MAX, 2925, 3131, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 3312, UINT16_MAX, 3312, 655, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2834, UINT16_MAX, 2834, 1466, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_NOBREAK, 26, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 1621, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PI, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 1, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ET, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 35, 35, 7220, UINT16_MAX, 7220, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 14, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 16423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 16426, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 16429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8240, 50, UINT16_MAX, 50, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8243, 53, UINT16_MAX, 53, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8246, 56, UINT16_MAX, 56, UINT16_MAX, 3143, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8249, 59, UINT16_MAX, 59, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8252, 62, UINT16_MAX, 62, UINT16_MAX, 1537, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8255, 65, UINT16_MAX, 65, UINT16_MAX, 1579, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 66, UINT16_MAX, 66, UINT16_MAX, 1549, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8259, 69, UINT16_MAX, 69, UINT16_MAX, 2852, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8262, 72, UINT16_MAX, 72, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8265, 75, UINT16_MAX, 75, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8268, 78, UINT16_MAX, 78, UINT16_MAX, 3357, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8271, 81, UINT16_MAX, 81, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8274, 84, UINT16_MAX, 84, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8277, 87, UINT16_MAX, 87, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8280, 90, UINT16_MAX, 90, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8283, 93, UINT16_MAX, 93, UINT16_MAX, 2878, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 94, UINT16_MAX, 94, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8287, 97, UINT16_MAX, 97, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8290, 100, UINT16_MAX, 100, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8293, 103, UINT16_MAX, 103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8296, 106, UINT16_MAX, 106, UINT16_MAX, 3461, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8299, 109, UINT16_MAX, 109, UINT16_MAX, 1597, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8302, 112, UINT16_MAX, 112, UINT16_MAX, 1591, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 113, UINT16_MAX, 113, UINT16_MAX, 1585, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8306, 116, UINT16_MAX, 116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8309, 119, UINT16_MAX, 119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8312, 122, UINT16_MAX, 122, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8315, 125, UINT16_MAX, 125, UINT16_MAX, 1509, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8318, 128, UINT16_MAX, 128, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 129, UINT16_MAX, 129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8322, 8069, UINT16_MAX, 8069, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8324, UINT16_MAX, 8070, UINT16_MAX, 8070, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8326, UINT16_MAX, 8071, UINT16_MAX, 8071, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8328, UINT16_MAX, 8072, UINT16_MAX, 8072, 3192, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8330, UINT16_MAX, 8073, UINT16_MAX, 8073, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8332, UINT16_MAX, 8074, UINT16_MAX, 8074, 1540, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8334, UINT16_MAX, 2836, UINT16_MAX, 2836, 1582, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1492, UINT16_MAX, 1492, 1558, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8336, UINT16_MAX, 8075, UINT16_MAX, 8075, 2855, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8338, UINT16_MAX, 8076, UINT16_MAX, 8076, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8340, UINT16_MAX, 8077, UINT16_MAX, 8077, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8342, UINT16_MAX, 8078, UINT16_MAX, 8078, 3406, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8344, UINT16_MAX, 8079, UINT16_MAX, 8079, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8346, UINT16_MAX, 8080, UINT16_MAX, 8080, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8348, UINT16_MAX, 8081, UINT16_MAX, 8081, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8350, UINT16_MAX, 8082, UINT16_MAX, 8082, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8352, UINT16_MAX, 8083, UINT16_MAX, 8083, 2881, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8084, UINT16_MAX, 8084, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8354, UINT16_MAX, 8085, UINT16_MAX, 8085, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8356, UINT16_MAX, 8086, UINT16_MAX, 8086, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8358, UINT16_MAX, 8087, UINT16_MAX, 8087, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8360, UINT16_MAX, 8088, UINT16_MAX, 8088, 3510, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8362, UINT16_MAX, 8089, UINT16_MAX, 8089, 1606, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8364, UINT16_MAX, 8090, UINT16_MAX, 8090, 1594, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8091, UINT16_MAX, 8091, 1588, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8366, UINT16_MAX, 8092, UINT16_MAX, 8092, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8368, UINT16_MAX, 8093, UINT16_MAX, 8093, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8370, UINT16_MAX, 8094, UINT16_MAX, 8094, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8372, UINT16_MAX, 8095, UINT16_MAX, 8095, 1523, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8374, UINT16_MAX, 8096, UINT16_MAX, 8096, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8097, UINT16_MAX, 8097, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8376, UINT16_MAX, 8098, UINT16_MAX, 8098, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8378, 188, UINT16_MAX, 188, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8381, UINT16_MAX, 8099, UINT16_MAX, 8099, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8383, 193, UINT16_MAX, 193, UINT16_MAX, 3259, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8386, UINT16_MAX, 8100, UINT16_MAX, 8100, 3308, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8388, 198, UINT16_MAX, 198, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8391, UINT16_MAX, 8101, UINT16_MAX, 8101, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8393, 203, UINT16_MAX, 203, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8396, UINT16_MAX, 8102, UINT16_MAX, 8102, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8398, 208, UINT16_MAX, 208, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8401, UINT16_MAX, 8103, UINT16_MAX, 8103, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8403, 213, UINT16_MAX, 213, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8406, UINT16_MAX, 8104, UINT16_MAX, 8104, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8408, 218, UINT16_MAX, 218, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8411, UINT16_MAX, 8105, UINT16_MAX, 8105, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8413, 223, UINT16_MAX, 223, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8416, UINT16_MAX, 8106, UINT16_MAX, 8106, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 226, UINT16_MAX, 226, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8107, UINT16_MAX, 8107, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8419, 229, UINT16_MAX, 229, UINT16_MAX, 2858, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8422, UINT16_MAX, 8108, UINT16_MAX, 8108, 2862, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8424, 234, UINT16_MAX, 234, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8427, UINT16_MAX, 8109, UINT16_MAX, 8109, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8429, 239, UINT16_MAX, 239, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8432, UINT16_MAX, 8110, UINT16_MAX, 8110, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8434, 244, UINT16_MAX, 244, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8437, UINT16_MAX, 8111, UINT16_MAX, 8111, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8439, 249, UINT16_MAX, 249, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8442, UINT16_MAX, 8112, UINT16_MAX, 8112, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8444, 254, UINT16_MAX, 254, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8447, UINT16_MAX, 8113, UINT16_MAX, 8113, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8449, 259, UINT16_MAX, 259, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8452, UINT16_MAX, 8114, UINT16_MAX, 8114, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8454, 264, UINT16_MAX, 264, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8457, UINT16_MAX, 8115, UINT16_MAX, 8115, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8459, 269, UINT16_MAX, 269, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8462, UINT16_MAX, 8116, UINT16_MAX, 8116, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8464, 274, UINT16_MAX, 274, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8467, UINT16_MAX, 8117, UINT16_MAX, 8117, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 277, UINT16_MAX, 277, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 5164, UINT16_MAX, 5164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8470, 280, UINT16_MAX, 280, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8473, UINT16_MAX, 8118, UINT16_MAX, 8118, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8475, 285, UINT16_MAX, 285, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8478, UINT16_MAX, 8119, UINT16_MAX, 8119, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8480, 290, UINT16_MAX, 290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8483, UINT16_MAX, 8120, UINT16_MAX, 8120, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8485, 295, UINT16_MAX, 295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8488, UINT16_MAX, 8121, UINT16_MAX, 8121, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8490, 8492, UINT16_MAX, 8, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1499, UINT16_MAX, 1499, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8494, 304, UINT16_MAX, 304, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8497, UINT16_MAX, 8122, UINT16_MAX, 8122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8499, 309, UINT16_MAX, 309, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8502, UINT16_MAX, 8123, UINT16_MAX, 8123, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8504, 314, UINT16_MAX, 314, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8507, UINT16_MAX, 8124, UINT16_MAX, 8124, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8509, 319, UINT16_MAX, 319, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8512, UINT16_MAX, 8125, UINT16_MAX, 8125, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8514, 324, UINT16_MAX, 324, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8517, UINT16_MAX, 8126, UINT16_MAX, 8126, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8519, 329, UINT16_MAX, 329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8522, UINT16_MAX, 8127, UINT16_MAX, 8127, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8524, 334, UINT16_MAX, 334, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8527, UINT16_MAX, 8128, UINT16_MAX, 8128, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 337, UINT16_MAX, 337, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8129, UINT16_MAX, 8129, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8530, 340, UINT16_MAX, 340, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8533, UINT16_MAX, 8130, UINT16_MAX, 8130, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8535, 345, UINT16_MAX, 345, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8538, UINT16_MAX, 8131, UINT16_MAX, 8131, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8540, 350, UINT16_MAX, 350, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8543, UINT16_MAX, 8132, UINT16_MAX, 8132, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8545, 8545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 355, UINT16_MAX, 355, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8133, UINT16_MAX, 8133, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8548, 358, UINT16_MAX, 358, UINT16_MAX, 2974, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8551, UINT16_MAX, 8134, UINT16_MAX, 8134, 2978, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8553, 363, UINT16_MAX, 363, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8556, UINT16_MAX, 8135, UINT16_MAX, 8135, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8558, 368, UINT16_MAX, 368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8561, UINT16_MAX, 8136, UINT16_MAX, 8136, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 371, UINT16_MAX, 371, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8137, UINT16_MAX, 8137, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8564, 374, UINT16_MAX, 374, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8567, UINT16_MAX, 8138, UINT16_MAX, 8138, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8569, 379, UINT16_MAX, 379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8572, UINT16_MAX, 8139, UINT16_MAX, 8139, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8574, 384, UINT16_MAX, 384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8577, UINT16_MAX, 8140, UINT16_MAX, 8140, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8579, 389, UINT16_MAX, 389, UINT16_MAX, 3012, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8582, UINT16_MAX, 8141, UINT16_MAX, 8141, 3015, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8584, 394, UINT16_MAX, 394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8587, UINT16_MAX, 8142, UINT16_MAX, 8142, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8589, 399, UINT16_MAX, 399, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8592, UINT16_MAX, 8143, UINT16_MAX, 8143, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8594, 404, UINT16_MAX, 404, UINT16_MAX, 3018, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8597, UINT16_MAX, 8144, UINT16_MAX, 8144, 3021, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8599, 409, UINT16_MAX, 409, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8602, UINT16_MAX, 8145, UINT16_MAX, 8145, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8604, 414, UINT16_MAX, 414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8607, UINT16_MAX, 8146, UINT16_MAX, 8146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 417, UINT16_MAX, 417, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8147, UINT16_MAX, 8147, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8610, 420, UINT16_MAX, 420, UINT16_MAX, 3030, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8613, UINT16_MAX, 8148, UINT16_MAX, 8148, 3033, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8615, 425, UINT16_MAX, 425, UINT16_MAX, 3036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8618, UINT16_MAX, 8149, UINT16_MAX, 8149, 3039, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8620, 430, UINT16_MAX, 430, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8623, UINT16_MAX, 8150, UINT16_MAX, 8150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8625, 435, UINT16_MAX, 435, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8628, UINT16_MAX, 8151, UINT16_MAX, 8151, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8630, 440, UINT16_MAX, 440, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8633, UINT16_MAX, 8152, UINT16_MAX, 8152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8635, 445, UINT16_MAX, 445, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8638, UINT16_MAX, 8153, UINT16_MAX, 8153, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8640, 450, UINT16_MAX, 450, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8643, UINT16_MAX, 8154, UINT16_MAX, 8154, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8645, 455, UINT16_MAX, 455, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8648, UINT16_MAX, 8155, UINT16_MAX, 8155, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8650, 460, UINT16_MAX, 460, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8653, 463, UINT16_MAX, 463, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8656, UINT16_MAX, 8156, UINT16_MAX, 8156, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8658, 468, UINT16_MAX, 468, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8661, UINT16_MAX, 8157, UINT16_MAX, 8157, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8663, 473, UINT16_MAX, 473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8666, UINT16_MAX, 8158, UINT16_MAX, 8158, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 18, 18, 3305, UINT16_MAX, 3305, 3140, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8159, UINT16_MAX, 8159, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 476, UINT16_MAX, 476, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 477, UINT16_MAX, 477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8160, UINT16_MAX, 8160, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 478, UINT16_MAX, 478, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8161, UINT16_MAX, 8161, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 479, UINT16_MAX, 479, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 480, UINT16_MAX, 480, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8162, UINT16_MAX, 8162, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 481, UINT16_MAX, 481, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 482, UINT16_MAX, 482, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 483, UINT16_MAX, 483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8163, UINT16_MAX, 8163, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 484, UINT16_MAX, 484, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 485, UINT16_MAX, 485, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 486, UINT16_MAX, 486, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 487, UINT16_MAX, 487, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8164, UINT16_MAX, 8164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 488, UINT16_MAX, 488, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 489, UINT16_MAX, 489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8165, UINT16_MAX, 8165, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 490, UINT16_MAX, 490, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 491, UINT16_MAX, 491, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 492, UINT16_MAX, 492, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8166, UINT16_MAX, 8166, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8167, UINT16_MAX, 8167, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 493, UINT16_MAX, 493, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 494, UINT16_MAX, 494, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8168, UINT16_MAX, 8168, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 495, UINT16_MAX, 495, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8688, 498, UINT16_MAX, 498, UINT16_MAX, 3565, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8691, UINT16_MAX, 8169, UINT16_MAX, 8169, 3614, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 501, UINT16_MAX, 501, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8170, UINT16_MAX, 8170, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 502, UINT16_MAX, 502, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8171, UINT16_MAX, 8171, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 503, UINT16_MAX, 503, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 504, UINT16_MAX, 504, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8172, UINT16_MAX, 8172, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 505, UINT16_MAX, 505, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 506, UINT16_MAX, 506, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8173, UINT16_MAX, 8173, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 507, UINT16_MAX, 507, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8700, 510, UINT16_MAX, 510, UINT16_MAX, 3663, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8703, UINT16_MAX, 8174, UINT16_MAX, 8174, 3712, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 513, UINT16_MAX, 513, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 514, UINT16_MAX, 514, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 515, UINT16_MAX, 515, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8175, UINT16_MAX, 8175, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 516, UINT16_MAX, 516, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8176, UINT16_MAX, 8176, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 517, UINT16_MAX, 517, UINT16_MAX, 1573, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 518, UINT16_MAX, 518, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8177, UINT16_MAX, 8177, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 519, UINT16_MAX, 519, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8178, UINT16_MAX, 8178, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8179, UINT16_MAX, 8179, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8712, 522, UINT16_MAX, 522, 8180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8715, 522, 8181, 522, 8180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8717, UINT16_MAX, 8181, UINT16_MAX, 8180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8719, 529, UINT16_MAX, 529, 8182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8722, 529, 8183, 529, 8182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8724, UINT16_MAX, 8183, UINT16_MAX, 8182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8726, 536, UINT16_MAX, 536, 8184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8729, 536, 8185, 536, 8184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8731, UINT16_MAX, 8185, UINT16_MAX, 8184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8733, 543, UINT16_MAX, 543, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8736, UINT16_MAX, 8186, UINT16_MAX, 8186, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8738, 548, UINT16_MAX, 548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8741, UINT16_MAX, 8187, UINT16_MAX, 8187, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8743, 553, UINT16_MAX, 553, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8746, UINT16_MAX, 8188, UINT16_MAX, 8188, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8748, 558, UINT16_MAX, 558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8751, UINT16_MAX, 8189, UINT16_MAX, 8189, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8753, 563, UINT16_MAX, 563, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8756, UINT16_MAX, 8190, UINT16_MAX, 8190, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8758, 568, UINT16_MAX, 568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8761, UINT16_MAX, 8191, UINT16_MAX, 8191, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8763, 573, UINT16_MAX, 573, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8766, UINT16_MAX, 8192, UINT16_MAX, 8192, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8768, 578, UINT16_MAX, 578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8771, UINT16_MAX, 8193, UINT16_MAX, 8193, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1496, UINT16_MAX, 1496, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8773, 583, UINT16_MAX, 583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8776, UINT16_MAX, 8194, UINT16_MAX, 8194, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8778, 588, UINT16_MAX, 588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8781, UINT16_MAX, 8195, UINT16_MAX, 8195, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8783, 593, UINT16_MAX, 593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8786, UINT16_MAX, 8196, UINT16_MAX, 8196, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 596, UINT16_MAX, 596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8197, UINT16_MAX, 8197, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8789, 599, UINT16_MAX, 599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8792, UINT16_MAX, 8198, UINT16_MAX, 8198, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8794, 604, UINT16_MAX, 604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8797, UINT16_MAX, 8199, UINT16_MAX, 8199, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8799, 609, UINT16_MAX, 609, UINT16_MAX, 1567, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8802, UINT16_MAX, 8200, UINT16_MAX, 8200, 1570, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8804, 614, UINT16_MAX, 614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8807, UINT16_MAX, 8201, UINT16_MAX, 8201, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8809, 619, UINT16_MAX, 619, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8812, UINT16_MAX, 8202, UINT16_MAX, 8202, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8814, 8814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8816, 626, UINT16_MAX, 626, 8203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8819, 626, 8204, 626, 8203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8821, UINT16_MAX, 8204, UINT16_MAX, 8203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8823, 633, UINT16_MAX, 633, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8826, UINT16_MAX, 8205, UINT16_MAX, 8205, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 636, UINT16_MAX, 636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 637, UINT16_MAX, 637, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8830, 640, UINT16_MAX, 640, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8833, UINT16_MAX, 8206, UINT16_MAX, 8206, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8835, 645, UINT16_MAX, 645, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8838, UINT16_MAX, 8207, UINT16_MAX, 8207, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8840, 650, UINT16_MAX, 650, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8843, UINT16_MAX, 8208, UINT16_MAX, 8208, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8845, 655, UINT16_MAX, 655, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8848, UINT16_MAX, 8209, UINT16_MAX, 8209, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8850, 660, UINT16_MAX, 660, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8853, UINT16_MAX, 8210, UINT16_MAX, 8210, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8855, 665, UINT16_MAX, 665, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8858, UINT16_MAX, 8211, UINT16_MAX, 8211, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8860, 670, UINT16_MAX, 670, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8863, UINT16_MAX, 8212, UINT16_MAX, 8212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8865, 675, UINT16_MAX, 675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8868, UINT16_MAX, 8213, UINT16_MAX, 8213, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8870, 680, UINT16_MAX, 680, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8873, UINT16_MAX, 8214, UINT16_MAX, 8214, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8875, 685, UINT16_MAX, 685, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8878, UINT16_MAX, 8215, UINT16_MAX, 8215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8880, 690, UINT16_MAX, 690, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8883, UINT16_MAX, 8216, UINT16_MAX, 8216, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8885, 695, UINT16_MAX, 695, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8888, UINT16_MAX, 8217, UINT16_MAX, 8217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8890, 700, UINT16_MAX, 700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8893, UINT16_MAX, 8218, UINT16_MAX, 8218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8895, 705, UINT16_MAX, 705, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8898, UINT16_MAX, 8219, UINT16_MAX, 8219, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8900, 710, UINT16_MAX, 710, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8903, UINT16_MAX, 8220, UINT16_MAX, 8220, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8905, 715, UINT16_MAX, 715, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8908, UINT16_MAX, 8221, UINT16_MAX, 8221, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8910, 720, UINT16_MAX, 720, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8913, UINT16_MAX, 8222, UINT16_MAX, 8222, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8915, 725, UINT16_MAX, 725, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8918, UINT16_MAX, 8223, UINT16_MAX, 8223, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 728, UINT16_MAX, 728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8224, UINT16_MAX, 8224, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8921, 731, UINT16_MAX, 731, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8924, UINT16_MAX, 8225, UINT16_MAX, 8225, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 734, UINT16_MAX, 734, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 735, UINT16_MAX, 735, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 1506, UINT16_MAX, 1506, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 736, UINT16_MAX, 736, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8226, UINT16_MAX, 8226, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8929, 739, UINT16_MAX, 739, UINT16_MAX, 1543, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8932, UINT16_MAX, 8227, UINT16_MAX, 8227, 1546, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8934, 744, UINT16_MAX, 744, UINT16_MAX, 2866, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8937, UINT16_MAX, 8228, UINT16_MAX, 8228, 2869, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8939, 749, UINT16_MAX, 749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8942, UINT16_MAX, 8229, UINT16_MAX, 8229, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8944, 754, UINT16_MAX, 754, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8947, UINT16_MAX, 8230, UINT16_MAX, 8230, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8949, 759, UINT16_MAX, 759, UINT16_MAX, 1615, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8952, UINT16_MAX, 8231, UINT16_MAX, 8231, 1618, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8954, 764, UINT16_MAX, 764, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8957, UINT16_MAX, 8232, UINT16_MAX, 8232, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 8959, 769, UINT16_MAX, 769, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 8962, UINT16_MAX, 8233, UINT16_MAX, 8233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 772, UINT16_MAX, 772, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 773, UINT16_MAX, 773, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8234, UINT16_MAX, 8234, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 774, UINT16_MAX, 774, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 775, UINT16_MAX, 775, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8235, UINT16_MAX, 8235, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8236, UINT16_MAX, 8236, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 776, UINT16_MAX, 776, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8237, UINT16_MAX, 8237, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 777, UINT16_MAX, 777, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 778, UINT16_MAX, 778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 779, UINT16_MAX, 779, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 780, UINT16_MAX, 780, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8238, UINT16_MAX, 8238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 781, UINT16_MAX, 781, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8239, UINT16_MAX, 8239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 782, UINT16_MAX, 782, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8240, UINT16_MAX, 8240, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 783, UINT16_MAX, 783, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8241, UINT16_MAX, 8241, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 784, UINT16_MAX, 784, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8242, UINT16_MAX, 8242, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8243, UINT16_MAX, 8243, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8244, UINT16_MAX, 8244, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8245, UINT16_MAX, 8245, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8246, UINT16_MAX, 8246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8247, UINT16_MAX, 8247, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8248, UINT16_MAX, 8248, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8249, UINT16_MAX, 8249, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8250, UINT16_MAX, 8250, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2821, UINT16_MAX, 2821, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8251, UINT16_MAX, 8251, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8252, UINT16_MAX, 8252, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8253, UINT16_MAX, 8253, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8254, UINT16_MAX, 8254, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8255, UINT16_MAX, 8255, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8256, UINT16_MAX, 8256, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8257, UINT16_MAX, 8257, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8258, UINT16_MAX, 8258, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8259, UINT16_MAX, 8259, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8260, UINT16_MAX, 8260, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8261, UINT16_MAX, 8261, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8262, UINT16_MAX, 8262, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8263, UINT16_MAX, 8263, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8264, UINT16_MAX, 8264, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8265, UINT16_MAX, 8265, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8266, UINT16_MAX, 8266, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8267, UINT16_MAX, 8267, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8268, UINT16_MAX, 8268, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8269, UINT16_MAX, 8269, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8270, UINT16_MAX, 8270, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8271, UINT16_MAX, 8271, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8272, UINT16_MAX, 8272, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8273, UINT16_MAX, 8273, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8274, UINT16_MAX, 8274, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8275, UINT16_MAX, 8275, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8276, UINT16_MAX, 8276, 1576, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8277, UINT16_MAX, 8277, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8278, UINT16_MAX, 8278, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 7, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 9, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 17, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 22, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 24, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8985, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8987, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 8991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 11, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 18, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 23, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32768, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32769, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32770, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32771, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32775, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32776, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32778, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32772, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32814, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32773, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32780, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32779, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32782, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32783, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32815, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32816, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 232, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 216, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32781, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32808, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32813, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32807, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32784, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32774, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 202, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32777, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32810, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32812, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32811, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32809, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 1, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 1, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32819, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32817, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, 8997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 240, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, 807, 7217, UINT16_MAX, 7217, 32818, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 233, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 234, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 808, UINT16_MAX, 808, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8279, UINT16_MAX, 8279, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 809, UINT16_MAX, 809, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8280, UINT16_MAX, 8280, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 811, UINT16_MAX, 811, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8281, UINT16_MAX, 8281, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8282, UINT16_MAX, 8282, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8283, UINT16_MAX, 8283, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8284, UINT16_MAX, 8284, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 815, UINT16_MAX, 815, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 9008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9010, 820, UINT16_MAX, 820, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9014, 824, UINT16_MAX, 824, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9017, 827, UINT16_MAX, 827, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9020, 830, UINT16_MAX, 830, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9023, 833, UINT16_MAX, 833, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9026, 836, UINT16_MAX, 836, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9029, 839, UINT16_MAX, 839, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9032, 17226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 845, UINT16_MAX, 845, UINT16_MAX, 1673, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 846, UINT16_MAX, 846, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 847, UINT16_MAX, 847, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 848, UINT16_MAX, 848, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 849, UINT16_MAX, 849, UINT16_MAX, 1726, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 850, UINT16_MAX, 850, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 851, UINT16_MAX, 851, UINT16_MAX, 1777, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 852, UINT16_MAX, 852, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 807, UINT16_MAX, 807, UINT16_MAX, 1830, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 853, UINT16_MAX, 853, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 854, UINT16_MAX, 854, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 35, UINT16_MAX, 35, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 855, UINT16_MAX, 855, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 856, UINT16_MAX, 856, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 857, UINT16_MAX, 857, UINT16_MAX, 1881, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 858, UINT16_MAX, 858, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 859, UINT16_MAX, 859, UINT16_MAX, 5027, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 860, UINT16_MAX, 860, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 861, UINT16_MAX, 861, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 862, UINT16_MAX, 862, UINT16_MAX, 1932, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 863, UINT16_MAX, 863, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 864, UINT16_MAX, 864, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 865, UINT16_MAX, 865, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 866, UINT16_MAX, 866, UINT16_MAX, 1983, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9059, 869, UINT16_MAX, 869, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9062, 872, UINT16_MAX, 872, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9065, UINT16_MAX, 2603, UINT16_MAX, 2603, 4904, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9067, UINT16_MAX, 2635, UINT16_MAX, 2635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9069, UINT16_MAX, 2640, UINT16_MAX, 2640, 4913, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9071, UINT16_MAX, 2676, UINT16_MAX, 2676, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9073, 17267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7211, UINT16_MAX, 7211, 2088, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7212, UINT16_MAX, 7212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2846, UINT16_MAX, 2846, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7213, UINT16_MAX, 7213, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7214, UINT16_MAX, 7214, 2141, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7215, UINT16_MAX, 7215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7216, UINT16_MAX, 7216, 2192, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 915, UINT16_MAX, 915, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7217, UINT16_MAX, 7217, 2245, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7218, UINT16_MAX, 7218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7219, UINT16_MAX, 7219, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7220, UINT16_MAX, 7220, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7221, UINT16_MAX, 7221, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7222, UINT16_MAX, 7222, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7223, UINT16_MAX, 7223, 2401, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2847, UINT16_MAX, 2847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7224, UINT16_MAX, 7224, 5023, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 860, 917, UINT16_MAX, 917, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 917, UINT16_MAX, 917, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7226, UINT16_MAX, 7226, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 897, UINT16_MAX, 897, 2349, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7227, UINT16_MAX, 7227, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7228, UINT16_MAX, 7228, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7229, UINT16_MAX, 7229, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 2835, UINT16_MAX, 2835, 2452, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9078, UINT16_MAX, 8285, UINT16_MAX, 8285, 2036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9080, UINT16_MAX, 8286, UINT16_MAX, 8286, 2297, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9082, UINT16_MAX, 2745, UINT16_MAX, 2745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9084, UINT16_MAX, 2714, UINT16_MAX, 2714, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9086, UINT16_MAX, 2750, UINT16_MAX, 2750, 5033, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 896, UINT16_MAX, 896, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 846, 846, 7212, UINT16_MAX, 7212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 852, 852, 915, UINT16_MAX, 915, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2505, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 863, 863, 7227, UINT16_MAX, 7227, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 858, 858, 2847, UINT16_MAX, 2847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8287, UINT16_MAX, 8287, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 902, UINT16_MAX, 902, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8288, UINT16_MAX, 8288, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 903, UINT16_MAX, 903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8289, UINT16_MAX, 8289, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 904, UINT16_MAX, 904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 7238, UINT16_MAX, 7238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 905, UINT16_MAX, 905, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8290, UINT16_MAX, 8290, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 906, UINT16_MAX, 906, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8291, UINT16_MAX, 8291, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 907, UINT16_MAX, 907, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8292, UINT16_MAX, 8292, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 908, UINT16_MAX, 908, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8293, UINT16_MAX, 8293, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 909, UINT16_MAX, 909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8294, UINT16_MAX, 8294, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 910, UINT16_MAX, 910, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8295, UINT16_MAX, 8295, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 911, UINT16_MAX, 911, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8296, UINT16_MAX, 8296, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 912, UINT16_MAX, 912, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8297, UINT16_MAX, 8297, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 913, UINT16_MAX, 913, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8298, UINT16_MAX, 8298, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 853, 853, 7218, UINT16_MAX, 7218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 859, 859, 7224, UINT16_MAX, 7224, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 914, UINT16_MAX, 8299, UINT16_MAX, 8299, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8300, UINT16_MAX, 8300, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 915, 852, UINT16_MAX, 852, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 849, 849, 7214, UINT16_MAX, 7214, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 916, UINT16_MAX, 916, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8301, UINT16_MAX, 8301, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 917, 918, UINT16_MAX, 918, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 919, UINT16_MAX, 919, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8302, UINT16_MAX, 8302, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 920, UINT16_MAX, 920, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 921, UINT16_MAX, 921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 922, UINT16_MAX, 922, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9115, 925, UINT16_MAX, 925, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9118, 928, UINT16_MAX, 928, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 929, UINT16_MAX, 929, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9122, 932, UINT16_MAX, 932, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 933, UINT16_MAX, 933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 934, UINT16_MAX, 934, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 935, UINT16_MAX, 935, UINT16_MAX, 2525, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9128, 938, UINT16_MAX, 938, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 939, UINT16_MAX, 939, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 940, UINT16_MAX, 940, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 941, UINT16_MAX, 941, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 942, UINT16_MAX, 942, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9135, 945, UINT16_MAX, 945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9138, 948, UINT16_MAX, 948, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9141, 951, UINT16_MAX, 951, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 952, UINT16_MAX, 952, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 953, UINT16_MAX, 953, UINT16_MAX, 2615, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 954, UINT16_MAX, 954, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 955, UINT16_MAX, 955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 956, UINT16_MAX, 956, UINT16_MAX, 2522, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 957, UINT16_MAX, 957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 958, UINT16_MAX, 958, UINT16_MAX, 2511, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 959, UINT16_MAX, 959, UINT16_MAX, 2601, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 960, UINT16_MAX, 960, UINT16_MAX, 2635, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 961, UINT16_MAX, 961, UINT16_MAX, 2531, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9154, 964, UINT16_MAX, 964, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 965, UINT16_MAX, 965, UINT16_MAX, 2528, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 966, UINT16_MAX, 966, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 967, UINT16_MAX, 967, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 968, UINT16_MAX, 968, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 969, UINT16_MAX, 969, UINT16_MAX, 2641, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 970, UINT16_MAX, 970, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 971, UINT16_MAX, 971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 972, UINT16_MAX, 972, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 973, UINT16_MAX, 973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 974, UINT16_MAX, 974, UINT16_MAX, 2542, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 975, UINT16_MAX, 975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 976, UINT16_MAX, 976, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 977, UINT16_MAX, 977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 978, UINT16_MAX, 978, UINT16_MAX, 2659, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 979, UINT16_MAX, 979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 980, UINT16_MAX, 980, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 981, UINT16_MAX, 981, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 982, UINT16_MAX, 982, UINT16_MAX, 2665, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 983, UINT16_MAX, 983, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 984, UINT16_MAX, 984, UINT16_MAX, 2653, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 985, UINT16_MAX, 985, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 986, UINT16_MAX, 986, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8303, UINT16_MAX, 8303, 2622, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8304, UINT16_MAX, 8304, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8305, UINT16_MAX, 8305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8306, UINT16_MAX, 8306, 2575, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8307, UINT16_MAX, 8307, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8308, UINT16_MAX, 8308, 2564, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8309, UINT16_MAX, 8309, 2608, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8310, UINT16_MAX, 8310, 2638, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8311, UINT16_MAX, 8311, 2553, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9179, UINT16_MAX, 8312, UINT16_MAX, 8312, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8313, UINT16_MAX, 8313, 2581, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8314, UINT16_MAX, 8314, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8315, UINT16_MAX, 8315, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8316, UINT16_MAX, 8316, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8317, UINT16_MAX, 8317, 2644, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8318, UINT16_MAX, 8318, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8319, UINT16_MAX, 8319, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8320, UINT16_MAX, 8320, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8321, UINT16_MAX, 8321, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8322, UINT16_MAX, 8322, 2584, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8323, UINT16_MAX, 8323, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8324, UINT16_MAX, 8324, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8325, UINT16_MAX, 8325, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8326, UINT16_MAX, 8326, 2662, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8327, UINT16_MAX, 8327, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8328, UINT16_MAX, 8328, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8329, UINT16_MAX, 8329, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8330, UINT16_MAX, 8330, 2668, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8331, UINT16_MAX, 8331, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8332, UINT16_MAX, 8332, 2656, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8333, UINT16_MAX, 8333, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8334, UINT16_MAX, 8334, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9181, UINT16_MAX, 8335, UINT16_MAX, 8335, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9183, UINT16_MAX, 8336, UINT16_MAX, 8336, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8337, UINT16_MAX, 8337, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9185, UINT16_MAX, 8338, UINT16_MAX, 8338, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8339, UINT16_MAX, 8339, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8340, UINT16_MAX, 8340, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8341, UINT16_MAX, 8341, 2578, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9187, UINT16_MAX, 8342, UINT16_MAX, 8342, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8343, UINT16_MAX, 8343, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8344, UINT16_MAX, 8344, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8345, UINT16_MAX, 8345, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8346, UINT16_MAX, 8346, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9189, UINT16_MAX, 8347, UINT16_MAX, 8347, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9191, UINT16_MAX, 8348, UINT16_MAX, 8348, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9193, UINT16_MAX, 8349, UINT16_MAX, 8349, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8350, UINT16_MAX, 8350, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1003, UINT16_MAX, 1003, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8351, UINT16_MAX, 8351, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1004, UINT16_MAX, 1004, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8352, UINT16_MAX, 8352, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1005, UINT16_MAX, 1005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8353, UINT16_MAX, 8353, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1006, UINT16_MAX, 1006, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8354, UINT16_MAX, 8354, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1007, UINT16_MAX, 1007, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8355, UINT16_MAX, 8355, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1008, UINT16_MAX, 1008, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8356, UINT16_MAX, 8356, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1009, UINT16_MAX, 1009, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8357, UINT16_MAX, 8357, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1010, UINT16_MAX, 1010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8358, UINT16_MAX, 8358, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1011, UINT16_MAX, 1011, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8359, UINT16_MAX, 8359, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1012, UINT16_MAX, 1012, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8360, UINT16_MAX, 8360, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1013, UINT16_MAX, 1013, UINT16_MAX, 2595, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8361, UINT16_MAX, 8361, 2598, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9206, 1016, UINT16_MAX, 1016, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9209, UINT16_MAX, 8362, UINT16_MAX, 8362, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1019, UINT16_MAX, 1019, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8363, UINT16_MAX, 8363, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1020, UINT16_MAX, 1020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8364, UINT16_MAX, 8364, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1021, UINT16_MAX, 1021, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8365, UINT16_MAX, 8365, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1022, UINT16_MAX, 1022, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8366, UINT16_MAX, 8366, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1023, UINT16_MAX, 1023, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8367, UINT16_MAX, 8367, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ME, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1024, UINT16_MAX, 1024, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8368, UINT16_MAX, 8368, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1025, UINT16_MAX, 1025, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8369, UINT16_MAX, 8369, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1026, UINT16_MAX, 1026, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8370, UINT16_MAX, 8370, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1027, UINT16_MAX, 1027, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8371, UINT16_MAX, 8371, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1028, UINT16_MAX, 1028, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8372, UINT16_MAX, 8372, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1029, UINT16_MAX, 1029, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8373, UINT16_MAX, 8373, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1030, UINT16_MAX, 1030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8374, UINT16_MAX, 8374, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1031, UINT16_MAX, 1031, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8375, UINT16_MAX, 8375, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1032, UINT16_MAX, 1032, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8376, UINT16_MAX, 8376, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1033, UINT16_MAX, 1033, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8377, UINT16_MAX, 8377, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1034, UINT16_MAX, 1034, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8378, UINT16_MAX, 8378, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1035, UINT16_MAX, 1035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8379, UINT16_MAX, 8379, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1036, UINT16_MAX, 1036, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8380, UINT16_MAX, 8380, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1037, UINT16_MAX, 1037, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8381, UINT16_MAX, 8381, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1038, UINT16_MAX, 1038, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8382, UINT16_MAX, 8382, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1039, UINT16_MAX, 1039, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8383, UINT16_MAX, 8383, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1040, UINT16_MAX, 1040, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8384, UINT16_MAX, 8384, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1041, UINT16_MAX, 1041, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8385, UINT16_MAX, 8385, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1042, UINT16_MAX, 1042, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8386, UINT16_MAX, 8386, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1043, UINT16_MAX, 1043, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8387, UINT16_MAX, 8387, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1044, UINT16_MAX, 1044, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8388, UINT16_MAX, 8388, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1045, UINT16_MAX, 1045, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8389, UINT16_MAX, 8389, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1046, UINT16_MAX, 1046, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8390, UINT16_MAX, 8390, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1047, UINT16_MAX, 1047, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8391, UINT16_MAX, 8391, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1048, UINT16_MAX, 1048, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8392, UINT16_MAX, 8392, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1049, UINT16_MAX, 1049, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8393, UINT16_MAX, 8393, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1050, UINT16_MAX, 1050, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8394, UINT16_MAX, 8394, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1051, UINT16_MAX, 1051, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9244, 1054, UINT16_MAX, 1054, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9247, UINT16_MAX, 8395, UINT16_MAX, 8395, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1057, UINT16_MAX, 1057, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8396, UINT16_MAX, 8396, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1058, UINT16_MAX, 1058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8397, UINT16_MAX, 8397, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1059, UINT16_MAX, 1059, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8398, UINT16_MAX, 8398, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1060, UINT16_MAX, 1060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8399, UINT16_MAX, 8399, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1061, UINT16_MAX, 1061, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8400, UINT16_MAX, 8400, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1062, UINT16_MAX, 1062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8401, UINT16_MAX, 8401, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8402, UINT16_MAX, 8402, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9255, 1065, UINT16_MAX, 1065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9258, UINT16_MAX, 8403, UINT16_MAX, 8403, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9260, 1070, UINT16_MAX, 1070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9263, UINT16_MAX, 8404, UINT16_MAX, 8404, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1073, UINT16_MAX, 1073, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8405, UINT16_MAX, 8405, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9266, 1076, UINT16_MAX, 1076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9269, UINT16_MAX, 8406, UINT16_MAX, 8406, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1079, UINT16_MAX, 1079, UINT16_MAX, 2629, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8407, UINT16_MAX, 8407, 2632, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9272, 1082, UINT16_MAX, 1082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9275, UINT16_MAX, 8408, UINT16_MAX, 8408, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9277, 1087, UINT16_MAX, 1087, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9280, UINT16_MAX, 8409, UINT16_MAX, 8409, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9282, 1092, UINT16_MAX, 1092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9285, UINT16_MAX, 8410, UINT16_MAX, 8410, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1095, UINT16_MAX, 1095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8411, UINT16_MAX, 8411, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9288, 1098, UINT16_MAX, 1098, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9291, UINT16_MAX, 8412, UINT16_MAX, 8412, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9293, 1103, UINT16_MAX, 1103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9296, UINT16_MAX, 8413, UINT16_MAX, 8413, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9298, 1108, UINT16_MAX, 1108, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9301, UINT16_MAX, 8414, UINT16_MAX, 8414, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1111, UINT16_MAX, 1111, UINT16_MAX, 2647, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8415, UINT16_MAX, 8415, 2650, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9304, 1114, UINT16_MAX, 1114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9307, UINT16_MAX, 8416, UINT16_MAX, 8416, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9309, 1119, UINT16_MAX, 1119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9312, UINT16_MAX, 8417, UINT16_MAX, 8417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9314, 1124, UINT16_MAX, 1124, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9317, UINT16_MAX, 8418, UINT16_MAX, 8418, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9319, 1129, UINT16_MAX, 1129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9322, UINT16_MAX, 8419, UINT16_MAX, 8419, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9324, 1134, UINT16_MAX, 1134, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9327, UINT16_MAX, 8420, UINT16_MAX, 8420, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9329, 1139, UINT16_MAX, 1139, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9332, UINT16_MAX, 8421, UINT16_MAX, 8421, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1142, UINT16_MAX, 1142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8422, UINT16_MAX, 8422, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9335, 1145, UINT16_MAX, 1145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9338, UINT16_MAX, 8423, UINT16_MAX, 8423, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1148, UINT16_MAX, 1148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8424, UINT16_MAX, 8424, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1149, UINT16_MAX, 1149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8425, UINT16_MAX, 8425, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1150, UINT16_MAX, 1150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8426, UINT16_MAX, 8426, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1151, UINT16_MAX, 1151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8427, UINT16_MAX, 8427, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1152, UINT16_MAX, 1152, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8428, UINT16_MAX, 8428, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1153, UINT16_MAX, 1153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8429, UINT16_MAX, 8429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1154, UINT16_MAX, 1154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8430, UINT16_MAX, 8430, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1155, UINT16_MAX, 1155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8431, UINT16_MAX, 8431, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1156, UINT16_MAX, 1156, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8432, UINT16_MAX, 8432, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1157, UINT16_MAX, 1157, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8433, UINT16_MAX, 8433, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1158, UINT16_MAX, 1158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8434, UINT16_MAX, 8434, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1159, UINT16_MAX, 1159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8435, UINT16_MAX, 8435, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1160, UINT16_MAX, 1160, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8436, UINT16_MAX, 8436, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1161, UINT16_MAX, 1161, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8437, UINT16_MAX, 8437, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1162, UINT16_MAX, 1162, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8438, UINT16_MAX, 8438, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1163, UINT16_MAX, 1163, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8439, UINT16_MAX, 8439, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1164, UINT16_MAX, 1164, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8440, UINT16_MAX, 8440, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1165, UINT16_MAX, 1165, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8441, UINT16_MAX, 8441, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1166, UINT16_MAX, 1166, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8442, UINT16_MAX, 8442, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1167, UINT16_MAX, 1167, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8443, UINT16_MAX, 8443, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1168, UINT16_MAX, 1168, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8444, UINT16_MAX, 8444, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1169, UINT16_MAX, 1169, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8445, UINT16_MAX, 8445, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1170, UINT16_MAX, 1170, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8446, UINT16_MAX, 8446, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1171, UINT16_MAX, 1171, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8447, UINT16_MAX, 8447, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1172, UINT16_MAX, 1172, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8448, UINT16_MAX, 8448, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1173, UINT16_MAX, 1173, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8449, UINT16_MAX, 8449, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1174, UINT16_MAX, 1174, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8450, UINT16_MAX, 8450, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1175, UINT16_MAX, 1175, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1176, UINT16_MAX, 1176, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1177, UINT16_MAX, 1177, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1178, UINT16_MAX, 1178, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1179, UINT16_MAX, 1179, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1180, UINT16_MAX, 1180, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1181, UINT16_MAX, 1181, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1182, UINT16_MAX, 1182, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1183, UINT16_MAX, 1183, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1184, UINT16_MAX, 1184, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1185, UINT16_MAX, 1185, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1186, UINT16_MAX, 1186, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1187, UINT16_MAX, 1187, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1188, UINT16_MAX, 1188, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1189, UINT16_MAX, 1189, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1190, UINT16_MAX, 1190, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1191, UINT16_MAX, 1191, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1192, UINT16_MAX, 1192, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1193, UINT16_MAX, 1193, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1194, UINT16_MAX, 1194, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1195, UINT16_MAX, 1195, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1196, UINT16_MAX, 1196, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1197, UINT16_MAX, 1197, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1198, UINT16_MAX, 1198, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1199, UINT16_MAX, 1199, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1200, UINT16_MAX, 1200, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1201, UINT16_MAX, 1201, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1202, UINT16_MAX, 1202, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1203, UINT16_MAX, 1203, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1204, UINT16_MAX, 1204, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1205, UINT16_MAX, 1205, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1206, UINT16_MAX, 1206, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1207, UINT16_MAX, 1207, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1208, UINT16_MAX, 1208, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1209, UINT16_MAX, 1209, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1210, UINT16_MAX, 1210, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1211, UINT16_MAX, 1211, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1212, UINT16_MAX, 1212, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8451, UINT16_MAX, 8451, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8452, UINT16_MAX, 8452, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8453, UINT16_MAX, 8453, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8454, UINT16_MAX, 8454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8455, UINT16_MAX, 8455, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8456, UINT16_MAX, 8456, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8457, UINT16_MAX, 8457, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8458, UINT16_MAX, 8458, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8459, UINT16_MAX, 8459, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8460, UINT16_MAX, 8460, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8461, UINT16_MAX, 8461, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8462, UINT16_MAX, 8462, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8463, UINT16_MAX, 8463, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8464, UINT16_MAX, 8464, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8465, UINT16_MAX, 8465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8466, UINT16_MAX, 8466, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8467, UINT16_MAX, 8467, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8468, UINT16_MAX, 8468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8469, UINT16_MAX, 8469, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8470, UINT16_MAX, 8470, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8471, UINT16_MAX, 8471, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8472, UINT16_MAX, 8472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8473, UINT16_MAX, 8473, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8474, UINT16_MAX, 8474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8475, UINT16_MAX, 8475, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8476, UINT16_MAX, 8476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8477, UINT16_MAX, 8477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8478, UINT16_MAX, 8478, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8479, UINT16_MAX, 8479, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8480, UINT16_MAX, 8480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8481, UINT16_MAX, 8481, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8482, UINT16_MAX, 8482, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8483, UINT16_MAX, 8483, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8484, UINT16_MAX, 8484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8485, UINT16_MAX, 8485, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8486, UINT16_MAX, 8486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8487, UINT16_MAX, 8487, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8488, UINT16_MAX, 8488, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9405, 9405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 222, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 228, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 10, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 11, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 12, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 13, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 14, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 15, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 16, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 17, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 18, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 19, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 20, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 21, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 22, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 23, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 24, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 25, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 30, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 31, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 32, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9409, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2671, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2676, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2679, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 27, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 28, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 29, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 33, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 34, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32785, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 230, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32786, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 220, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32787, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 35, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 9417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 9419, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 9421, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_COMPAT, 9423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2685, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2688, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, 9429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2682, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND},
-  {UTF8PROC_CATEGORY_MN, 36, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2691, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2694, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2697, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32788, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32789, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2700, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32790, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32792, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2704, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32791, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32793, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2709, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32795, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2712, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2716, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32794, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2719, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 84, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 91, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32796, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2722, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32799, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2725, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2730, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32797, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32798, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32800, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2733, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2737, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_PREPEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32801, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32802, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32803, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2740, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2745, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32804, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MN, 103, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 107, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MN, 118, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 122, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 9525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NOBREAK, 1335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 216, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 129, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 130, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 132, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9544, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, UTF8PROC_DECOMP_TYPE_COMPAT, 9546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9548, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, UTF8PROC_DECOMP_TYPE_COMPAT, 9550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 9564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2748, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32805, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1376, UINT16_MAX, 1376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1377, UINT16_MAX, 1377, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1378, UINT16_MAX, 1378, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1379, UINT16_MAX, 1379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1380, UINT16_MAX, 1380, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1381, UINT16_MAX, 1381, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1382, UINT16_MAX, 1382, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1383, UINT16_MAX, 1383, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1384, UINT16_MAX, 1384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1385, UINT16_MAX, 1385, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1386, UINT16_MAX, 1386, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1387, UINT16_MAX, 1387, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1388, UINT16_MAX, 1388, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1389, UINT16_MAX, 1389, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1390, UINT16_MAX, 1390, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1391, UINT16_MAX, 1391, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1392, UINT16_MAX, 1392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1393, UINT16_MAX, 1393, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1394, UINT16_MAX, 1394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1395, UINT16_MAX, 1395, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1396, UINT16_MAX, 1396, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1397, UINT16_MAX, 1397, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1398, UINT16_MAX, 1398, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1399, UINT16_MAX, 1399, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1400, UINT16_MAX, 1400, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1401, UINT16_MAX, 1401, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1402, UINT16_MAX, 1402, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1403, UINT16_MAX, 1403, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1404, UINT16_MAX, 1404, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1405, UINT16_MAX, 1405, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1406, UINT16_MAX, 1406, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1407, UINT16_MAX, 1407, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1408, UINT16_MAX, 1408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1409, UINT16_MAX, 1409, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1410, UINT16_MAX, 1410, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1411, UINT16_MAX, 1411, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1412, UINT16_MAX, 1412, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1413, UINT16_MAX, 1413, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1414, UINT16_MAX, 1414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1415, UINT16_MAX, 1415, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8489, UINT16_MAX, 1446, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8490, UINT16_MAX, 1447, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8491, UINT16_MAX, 1448, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8492, UINT16_MAX, 1449, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8493, UINT16_MAX, 1450, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8494, UINT16_MAX, 1451, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8495, UINT16_MAX, 1452, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8496, UINT16_MAX, 1453, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8497, UINT16_MAX, 1454, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8498, UINT16_MAX, 1455, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8499, UINT16_MAX, 1456, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8500, UINT16_MAX, 1457, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8501, UINT16_MAX, 1416, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8502, UINT16_MAX, 1458, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8503, UINT16_MAX, 1459, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8504, UINT16_MAX, 1460, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8505, UINT16_MAX, 1461, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8506, UINT16_MAX, 1462, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8507, UINT16_MAX, 1463, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8508, UINT16_MAX, 1464, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8509, UINT16_MAX, 1465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8510, UINT16_MAX, 1466, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8511, UINT16_MAX, 1467, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8512, UINT16_MAX, 1468, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8513, UINT16_MAX, 1469, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8514, UINT16_MAX, 1470, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8515, UINT16_MAX, 1471, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8516, UINT16_MAX, 1472, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8517, UINT16_MAX, 1473, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8518, UINT16_MAX, 1474, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8519, UINT16_MAX, 1475, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8520, UINT16_MAX, 1476, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8521, UINT16_MAX, 1477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8522, UINT16_MAX, 1478, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8523, UINT16_MAX, 1479, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8524, UINT16_MAX, 1480, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8525, UINT16_MAX, 1481, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8526, UINT16_MAX, 1482, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8527, UINT16_MAX, 1483, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8528, UINT16_MAX, 1484, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8529, UINT16_MAX, 1485, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8530, UINT16_MAX, 1486, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8531, UINT16_MAX, 1487, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8532, UINT16_MAX, 1488, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8533, UINT16_MAX, 1489, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8534, UINT16_MAX, 1490, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_L},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 2, 0, UTF8PROC_BOUNDCLASS_L},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 1, 0, UTF8PROC_BOUNDCLASS_V},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_V},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_T},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8535, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8536, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8537, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8538, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8539, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8540, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8541, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8542, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8543, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8544, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8545, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8546, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8547, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8549, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8550, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8551, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8552, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8553, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8554, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8555, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8556, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8557, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8559, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8560, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8561, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8562, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8563, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8564, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8565, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8566, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8567, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8569, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8570, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8571, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8572, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8573, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8574, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8575, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8576, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8577, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8579, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8580, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8581, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8582, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8584, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8585, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8586, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8587, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8589, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8590, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8591, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8592, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8594, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8595, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8597, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8600, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8601, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8605, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8606, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8607, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8609, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8610, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8611, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8612, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8613, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8614, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8615, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8616, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8617, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8618, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8619, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, 8620, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1417, 1417, UINT16_MAX, 1417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1418, 1418, UINT16_MAX, 1418, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1419, 1419, UINT16_MAX, 1419, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1420, 1420, UINT16_MAX, 1420, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1421, 1421, UINT16_MAX, 1421, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1422, 1422, UINT16_MAX, 1422, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2751, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2754, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2757, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2760, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2763, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2766, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 9625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32806, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2769, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2772, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2775, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2778, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 2781, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 9635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 9, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 955, 8305, UINT16_MAX, 8305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 957, 8307, UINT16_MAX, 8307, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 969, 8317, UINT16_MAX, 8317, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 972, 8320, UINT16_MAX, 8320, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 973, 8321, UINT16_MAX, 8321, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 981, 8329, UINT16_MAX, 8329, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1004, 8352, UINT16_MAX, 8352, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1445, 8621, UINT16_MAX, 8621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1446, UINT16_MAX, 1446, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1447, UINT16_MAX, 1447, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1448, UINT16_MAX, 1448, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1449, UINT16_MAX, 1449, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1450, UINT16_MAX, 1450, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1451, UINT16_MAX, 1451, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1452, UINT16_MAX, 1452, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1453, UINT16_MAX, 1453, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1454, UINT16_MAX, 1454, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1455, UINT16_MAX, 1455, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1456, UINT16_MAX, 1456, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1457, UINT16_MAX, 1457, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1416, UINT16_MAX, 1416, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1458, UINT16_MAX, 1458, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1459, UINT16_MAX, 1459, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1460, UINT16_MAX, 1460, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1461, UINT16_MAX, 1461, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1462, UINT16_MAX, 1462, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1463, UINT16_MAX, 1463, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1464, UINT16_MAX, 1464, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1465, UINT16_MAX, 1465, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1466, UINT16_MAX, 1466, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1467, UINT16_MAX, 1467, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1468, UINT16_MAX, 1468, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1469, UINT16_MAX, 1469, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1470, UINT16_MAX, 1470, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1471, UINT16_MAX, 1471, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1472, UINT16_MAX, 1472, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1473, UINT16_MAX, 1473, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1474, UINT16_MAX, 1474, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1475, UINT16_MAX, 1475, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1476, UINT16_MAX, 1476, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1477, UINT16_MAX, 1477, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1478, UINT16_MAX, 1478, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1479, UINT16_MAX, 1479, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1480, UINT16_MAX, 1480, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1481, UINT16_MAX, 1481, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1482, UINT16_MAX, 1482, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1483, UINT16_MAX, 1483, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1484, UINT16_MAX, 1484, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1485, UINT16_MAX, 1485, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1486, UINT16_MAX, 1486, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1487, UINT16_MAX, 1487, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1488, UINT16_MAX, 1488, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1489, UINT16_MAX, 1489, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1490, UINT16_MAX, 1490, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1496, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 4, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 6, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 10, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 12, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 14, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 15, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 19, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 20, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 21, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 8, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 17, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 20, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 21, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8622, UINT16_MAX, 8622, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8623, UINT16_MAX, 8623, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8624, UINT16_MAX, 8624, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 94, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 490, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 778, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 25, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 1540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 214, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9733, 1543, UINT16_MAX, 1543, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9736, UINT16_MAX, 8625, UINT16_MAX, 8625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9738, 1548, UINT16_MAX, 1548, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9741, UINT16_MAX, 8626, UINT16_MAX, 8626, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9743, 1553, UINT16_MAX, 1553, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9746, UINT16_MAX, 8627, UINT16_MAX, 8627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9748, 1558, UINT16_MAX, 1558, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9751, UINT16_MAX, 8628, UINT16_MAX, 8628, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9753, 1563, UINT16_MAX, 1563, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9756, UINT16_MAX, 8629, UINT16_MAX, 8629, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9758, 1568, UINT16_MAX, 1568, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9761, UINT16_MAX, 8630, UINT16_MAX, 8630, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9763, 1573, UINT16_MAX, 1573, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9766, UINT16_MAX, 8631, UINT16_MAX, 8631, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9768, 1578, UINT16_MAX, 1578, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9771, UINT16_MAX, 8632, UINT16_MAX, 8632, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9773, 1583, UINT16_MAX, 1583, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9776, UINT16_MAX, 8633, UINT16_MAX, 8633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9778, 1588, UINT16_MAX, 1588, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9781, UINT16_MAX, 8634, UINT16_MAX, 8634, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9783, 1593, UINT16_MAX, 1593, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9786, UINT16_MAX, 8635, UINT16_MAX, 8635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9788, 1598, UINT16_MAX, 1598, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9791, UINT16_MAX, 8636, UINT16_MAX, 8636, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9793, 1603, UINT16_MAX, 1603, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9796, UINT16_MAX, 8637, UINT16_MAX, 8637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9798, 1608, UINT16_MAX, 1608, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9801, UINT16_MAX, 8638, UINT16_MAX, 8638, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9803, 1613, UINT16_MAX, 1613, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9806, UINT16_MAX, 8639, UINT16_MAX, 8639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9808, 1618, UINT16_MAX, 1618, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9811, UINT16_MAX, 8640, UINT16_MAX, 8640, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9813, 1623, UINT16_MAX, 1623, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9816, UINT16_MAX, 8641, UINT16_MAX, 8641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9818, 1628, UINT16_MAX, 1628, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9821, UINT16_MAX, 8642, UINT16_MAX, 8642, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9823, 1633, UINT16_MAX, 1633, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9826, UINT16_MAX, 8643, UINT16_MAX, 8643, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9828, 1638, UINT16_MAX, 1638, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9831, UINT16_MAX, 8644, UINT16_MAX, 8644, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9833, 1643, UINT16_MAX, 1643, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9836, UINT16_MAX, 8645, UINT16_MAX, 8645, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9838, 1648, UINT16_MAX, 1648, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9841, UINT16_MAX, 8646, UINT16_MAX, 8646, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9843, 1653, UINT16_MAX, 1653, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9846, UINT16_MAX, 8647, UINT16_MAX, 8647, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9848, 1658, UINT16_MAX, 1658, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9851, UINT16_MAX, 8648, UINT16_MAX, 8648, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9853, 1663, UINT16_MAX, 1663, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9856, UINT16_MAX, 8649, UINT16_MAX, 8649, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9858, 1668, UINT16_MAX, 1668, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9861, UINT16_MAX, 8650, UINT16_MAX, 8650, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9863, 1673, UINT16_MAX, 1673, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9866, UINT16_MAX, 8651, UINT16_MAX, 8651, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9868, 1678, UINT16_MAX, 1678, UINT16_MAX, 2884, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9871, UINT16_MAX, 8652, UINT16_MAX, 8652, 2887, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9873, 1683, UINT16_MAX, 1683, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9876, UINT16_MAX, 8653, UINT16_MAX, 8653, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9878, 1688, UINT16_MAX, 1688, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9881, UINT16_MAX, 8654, UINT16_MAX, 8654, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9883, 1693, UINT16_MAX, 1693, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9886, UINT16_MAX, 8655, UINT16_MAX, 8655, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9888, 1698, UINT16_MAX, 1698, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9891, UINT16_MAX, 8656, UINT16_MAX, 8656, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9893, 1703, UINT16_MAX, 1703, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9896, UINT16_MAX, 8657, UINT16_MAX, 8657, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9898, 1708, UINT16_MAX, 1708, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9901, UINT16_MAX, 8658, UINT16_MAX, 8658, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9903, 1713, UINT16_MAX, 1713, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9906, UINT16_MAX, 8659, UINT16_MAX, 8659, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9908, 1718, UINT16_MAX, 1718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9911, UINT16_MAX, 8660, UINT16_MAX, 8660, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9913, 1723, UINT16_MAX, 1723, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9916, UINT16_MAX, 8661, UINT16_MAX, 8661, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9918, 1728, UINT16_MAX, 1728, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9921, UINT16_MAX, 8662, UINT16_MAX, 8662, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9923, 1733, UINT16_MAX, 1733, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9926, UINT16_MAX, 8663, UINT16_MAX, 8663, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9928, 1738, UINT16_MAX, 1738, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9931, UINT16_MAX, 8664, UINT16_MAX, 8664, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9933, 1743, UINT16_MAX, 1743, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9936, UINT16_MAX, 8665, UINT16_MAX, 8665, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9938, 1748, UINT16_MAX, 1748, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9941, UINT16_MAX, 8666, UINT16_MAX, 8666, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9943, 1753, UINT16_MAX, 1753, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9946, UINT16_MAX, 8667, UINT16_MAX, 8667, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9948, 1758, UINT16_MAX, 1758, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9951, UINT16_MAX, 8668, UINT16_MAX, 8668, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9953, 1763, UINT16_MAX, 1763, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9956, UINT16_MAX, 8669, UINT16_MAX, 8669, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9958, 1768, UINT16_MAX, 1768, UINT16_MAX, 3006, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9961, UINT16_MAX, 8670, UINT16_MAX, 8670, 3009, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9963, 1773, UINT16_MAX, 1773, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9966, UINT16_MAX, 8671, UINT16_MAX, 8671, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9968, 1778, UINT16_MAX, 1778, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9971, UINT16_MAX, 8672, UINT16_MAX, 8672, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9973, 1783, UINT16_MAX, 1783, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9976, UINT16_MAX, 8673, UINT16_MAX, 8673, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9978, 1788, UINT16_MAX, 1788, UINT16_MAX, 3024, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9981, UINT16_MAX, 8674, UINT16_MAX, 8674, 3027, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9983, 1793, UINT16_MAX, 1793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9986, UINT16_MAX, 8675, UINT16_MAX, 8675, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9988, 1798, UINT16_MAX, 1798, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9991, UINT16_MAX, 8676, UINT16_MAX, 8676, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9993, 1803, UINT16_MAX, 1803, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 9996, UINT16_MAX, 8677, UINT16_MAX, 8677, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 9998, 1808, UINT16_MAX, 1808, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10001, UINT16_MAX, 8678, UINT16_MAX, 8678, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10003, 1813, UINT16_MAX, 1813, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10006, UINT16_MAX, 8679, UINT16_MAX, 8679, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10008, 1818, UINT16_MAX, 1818, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10011, UINT16_MAX, 8680, UINT16_MAX, 8680, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10013, 1823, UINT16_MAX, 1823, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10016, UINT16_MAX, 8681, UINT16_MAX, 8681, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10018, 1828, UINT16_MAX, 1828, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10021, UINT16_MAX, 8682, UINT16_MAX, 8682, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10023, 1833, UINT16_MAX, 1833, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10026, UINT16_MAX, 8683, UINT16_MAX, 8683, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10028, 1838, UINT16_MAX, 1838, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10031, UINT16_MAX, 8684, UINT16_MAX, 8684, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10033, 1843, UINT16_MAX, 1843, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10036, UINT16_MAX, 8685, UINT16_MAX, 8685, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10038, 1848, UINT16_MAX, 1848, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10041, UINT16_MAX, 8686, UINT16_MAX, 8686, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10043, 1853, UINT16_MAX, 1853, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10046, UINT16_MAX, 8687, UINT16_MAX, 8687, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10048, 1858, UINT16_MAX, 1858, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10051, UINT16_MAX, 8688, UINT16_MAX, 8688, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10053, 1863, UINT16_MAX, 1863, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10056, UINT16_MAX, 8689, UINT16_MAX, 8689, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10058, 1868, UINT16_MAX, 1868, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10061, UINT16_MAX, 8690, UINT16_MAX, 8690, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10063, 1873, UINT16_MAX, 1873, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10066, UINT16_MAX, 8691, UINT16_MAX, 8691, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10068, 1878, UINT16_MAX, 1878, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10071, UINT16_MAX, 8692, UINT16_MAX, 8692, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10073, 1883, UINT16_MAX, 1883, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10076, UINT16_MAX, 8693, UINT16_MAX, 8693, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10078, 1888, UINT16_MAX, 1888, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10081, UINT16_MAX, 8694, UINT16_MAX, 8694, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10083, 1893, UINT16_MAX, 1893, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10086, UINT16_MAX, 8695, UINT16_MAX, 8695, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10088, 1898, UINT16_MAX, 1898, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10091, UINT16_MAX, 8696, UINT16_MAX, 8696, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10093, 1903, UINT16_MAX, 1903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10096, UINT16_MAX, 8697, UINT16_MAX, 8697, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10098, 1908, UINT16_MAX, 1908, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10101, UINT16_MAX, 8698, UINT16_MAX, 8698, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10103, 1913, UINT16_MAX, 1913, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10106, UINT16_MAX, 8699, UINT16_MAX, 8699, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10108, 10108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10110, 10110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10112, 10112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10114, 10114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 10116, 10116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10118, 1783, 8673, UINT16_MAX, 8673, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 8322, UINT16_MAX, 8700, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10120, 1930, UINT16_MAX, 1930, UINT16_MAX, 3241, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10123, UINT16_MAX, 8701, UINT16_MAX, 8701, 3250, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10125, 1935, UINT16_MAX, 1935, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10128, UINT16_MAX, 8702, UINT16_MAX, 8702, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10130, 1940, UINT16_MAX, 1940, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10133, UINT16_MAX, 8703, UINT16_MAX, 8703, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10135, 1945, UINT16_MAX, 1945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10138, UINT16_MAX, 8704, UINT16_MAX, 8704, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10140, 1950, UINT16_MAX, 1950, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10143, UINT16_MAX, 8705, UINT16_MAX, 8705, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10145, 1955, UINT16_MAX, 1955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10148, UINT16_MAX, 8706, UINT16_MAX, 8706, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10150, 1960, UINT16_MAX, 1960, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10153, UINT16_MAX, 8707, UINT16_MAX, 8707, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10155, 1965, UINT16_MAX, 1965, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10158, UINT16_MAX, 8708, UINT16_MAX, 8708, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10160, 1970, UINT16_MAX, 1970, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10163, UINT16_MAX, 8709, UINT16_MAX, 8709, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10165, 1975, UINT16_MAX, 1975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10168, UINT16_MAX, 8710, UINT16_MAX, 8710, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10170, 1980, UINT16_MAX, 1980, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10173, UINT16_MAX, 8711, UINT16_MAX, 8711, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10175, 1985, UINT16_MAX, 1985, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10178, UINT16_MAX, 8712, UINT16_MAX, 8712, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10180, 1990, UINT16_MAX, 1990, UINT16_MAX, 3455, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10183, UINT16_MAX, 8713, UINT16_MAX, 8713, 3458, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10185, 1995, UINT16_MAX, 1995, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10188, UINT16_MAX, 8714, UINT16_MAX, 8714, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10190, 2000, UINT16_MAX, 2000, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10193, UINT16_MAX, 8715, UINT16_MAX, 8715, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10195, 2005, UINT16_MAX, 2005, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10198, UINT16_MAX, 8716, UINT16_MAX, 8716, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10200, 2010, UINT16_MAX, 2010, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10203, UINT16_MAX, 8717, UINT16_MAX, 8717, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10205, 2015, UINT16_MAX, 2015, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10208, UINT16_MAX, 8718, UINT16_MAX, 8718, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10210, 2020, UINT16_MAX, 2020, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10213, UINT16_MAX, 8719, UINT16_MAX, 8719, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10215, 2025, UINT16_MAX, 2025, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10218, UINT16_MAX, 8720, UINT16_MAX, 8720, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10220, 2030, UINT16_MAX, 2030, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10223, UINT16_MAX, 8721, UINT16_MAX, 8721, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10225, 2035, UINT16_MAX, 2035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10228, UINT16_MAX, 8722, UINT16_MAX, 8722, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10230, 2040, UINT16_MAX, 2040, UINT16_MAX, 3559, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10233, UINT16_MAX, 8723, UINT16_MAX, 8723, 3562, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10235, 2045, UINT16_MAX, 2045, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10238, UINT16_MAX, 8724, UINT16_MAX, 8724, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10240, 2050, UINT16_MAX, 2050, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10243, UINT16_MAX, 8725, UINT16_MAX, 8725, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10245, 2055, UINT16_MAX, 2055, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10248, UINT16_MAX, 8726, UINT16_MAX, 8726, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10250, 2060, UINT16_MAX, 2060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10253, UINT16_MAX, 8727, UINT16_MAX, 8727, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10255, 2065, UINT16_MAX, 2065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10258, UINT16_MAX, 8728, UINT16_MAX, 8728, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10260, 2070, UINT16_MAX, 2070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10263, UINT16_MAX, 8729, UINT16_MAX, 8729, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10265, 2075, UINT16_MAX, 2075, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10268, UINT16_MAX, 8730, UINT16_MAX, 8730, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10270, 2080, UINT16_MAX, 2080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10273, UINT16_MAX, 8731, UINT16_MAX, 8731, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10275, 2085, UINT16_MAX, 2085, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10278, UINT16_MAX, 8732, UINT16_MAX, 8732, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10280, 2090, UINT16_MAX, 2090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10283, UINT16_MAX, 8733, UINT16_MAX, 8733, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10285, 2095, UINT16_MAX, 2095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10288, UINT16_MAX, 8734, UINT16_MAX, 8734, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10290, 2100, UINT16_MAX, 2100, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10293, UINT16_MAX, 8735, UINT16_MAX, 8735, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10295, 2105, UINT16_MAX, 2105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10298, UINT16_MAX, 8736, UINT16_MAX, 8736, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10300, 2110, UINT16_MAX, 2110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10303, UINT16_MAX, 8737, UINT16_MAX, 8737, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10305, 2115, UINT16_MAX, 2115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10308, UINT16_MAX, 8738, UINT16_MAX, 8738, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10310, 2120, UINT16_MAX, 2120, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10313, UINT16_MAX, 8739, UINT16_MAX, 8739, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10315, 2125, UINT16_MAX, 2125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10318, UINT16_MAX, 8740, UINT16_MAX, 8740, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10320, 2130, UINT16_MAX, 2130, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10323, UINT16_MAX, 8741, UINT16_MAX, 8741, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10325, 2135, UINT16_MAX, 2135, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10328, UINT16_MAX, 8742, UINT16_MAX, 8742, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10330, 2140, UINT16_MAX, 2140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10333, UINT16_MAX, 8743, UINT16_MAX, 8743, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10335, 2145, UINT16_MAX, 2145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10338, UINT16_MAX, 8744, UINT16_MAX, 8744, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10340, 2150, UINT16_MAX, 2150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10343, UINT16_MAX, 8745, UINT16_MAX, 8745, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2153, UINT16_MAX, 2153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8746, UINT16_MAX, 8746, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2154, UINT16_MAX, 2154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8747, UINT16_MAX, 8747, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2155, UINT16_MAX, 2155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8748, UINT16_MAX, 8748, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10348, UINT16_MAX, 8749, UINT16_MAX, 8749, 3761, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10350, UINT16_MAX, 8750, UINT16_MAX, 8750, 3814, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10352, UINT16_MAX, 8751, UINT16_MAX, 8751, 4793, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10354, UINT16_MAX, 8752, UINT16_MAX, 8752, 4796, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10356, UINT16_MAX, 8753, UINT16_MAX, 8753, 4799, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10358, UINT16_MAX, 8754, UINT16_MAX, 8754, 4802, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10360, UINT16_MAX, 8755, UINT16_MAX, 8755, 4805, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10362, UINT16_MAX, 8756, UINT16_MAX, 8756, 4808, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10364, 2174, UINT16_MAX, 2174, UINT16_MAX, 3867, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10367, 2177, UINT16_MAX, 2177, UINT16_MAX, 3920, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10370, 2180, UINT16_MAX, 2180, UINT16_MAX, 4811, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10373, 2183, UINT16_MAX, 2183, UINT16_MAX, 4814, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10376, 2186, UINT16_MAX, 2186, UINT16_MAX, 4817, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10379, 2189, UINT16_MAX, 2189, UINT16_MAX, 4820, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10382, 2192, UINT16_MAX, 2192, UINT16_MAX, 4823, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10385, 2195, UINT16_MAX, 2195, UINT16_MAX, 4826, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10388, UINT16_MAX, 8757, UINT16_MAX, 8757, 3973, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10390, UINT16_MAX, 8758, UINT16_MAX, 8758, 3977, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10392, UINT16_MAX, 8759, UINT16_MAX, 8759, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10394, UINT16_MAX, 8760, UINT16_MAX, 8760, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10396, UINT16_MAX, 8761, UINT16_MAX, 8761, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10398, UINT16_MAX, 8762, UINT16_MAX, 8762, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10400, 2210, UINT16_MAX, 2210, UINT16_MAX, 3981, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10403, 2213, UINT16_MAX, 2213, UINT16_MAX, 3985, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10406, 2216, UINT16_MAX, 2216, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10409, 2219, UINT16_MAX, 2219, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10412, 2222, UINT16_MAX, 2222, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10415, 2225, UINT16_MAX, 2225, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10418, UINT16_MAX, 8763, UINT16_MAX, 8763, 3989, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10420, UINT16_MAX, 8764, UINT16_MAX, 8764, 4042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10422, UINT16_MAX, 8765, UINT16_MAX, 8765, 4829, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10424, UINT16_MAX, 8766, UINT16_MAX, 8766, 4832, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10426, UINT16_MAX, 8767, UINT16_MAX, 8767, 4835, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10428, UINT16_MAX, 8768, UINT16_MAX, 8768, 4838, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10430, UINT16_MAX, 8769, UINT16_MAX, 8769, 4841, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10432, UINT16_MAX, 8770, UINT16_MAX, 8770, 4844, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10434, 2244, UINT16_MAX, 2244, UINT16_MAX, 4095, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10437, 2247, UINT16_MAX, 2247, UINT16_MAX, 4148, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10440, 2250, UINT16_MAX, 2250, UINT16_MAX, 4847, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10443, 2253, UINT16_MAX, 2253, UINT16_MAX, 4850, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10446, 2256, UINT16_MAX, 2256, UINT16_MAX, 4853, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10449, 2259, UINT16_MAX, 2259, UINT16_MAX, 4856, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10452, 2262, UINT16_MAX, 2262, UINT16_MAX, 4859, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10455, 2265, UINT16_MAX, 2265, UINT16_MAX, 4862, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10458, UINT16_MAX, 8771, UINT16_MAX, 8771, 4201, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10460, UINT16_MAX, 8772, UINT16_MAX, 8772, 4253, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10462, UINT16_MAX, 8773, UINT16_MAX, 8773, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10464, UINT16_MAX, 8774, UINT16_MAX, 8774, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10466, UINT16_MAX, 8775, UINT16_MAX, 8775, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10468, UINT16_MAX, 8776, UINT16_MAX, 8776, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10470, UINT16_MAX, 8777, UINT16_MAX, 8777, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10472, UINT16_MAX, 8778, UINT16_MAX, 8778, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10474, 2284, UINT16_MAX, 2284, UINT16_MAX, 4305, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10477, 2287, UINT16_MAX, 2287, UINT16_MAX, 4357, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10480, 2290, UINT16_MAX, 2290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10483, 2293, UINT16_MAX, 2293, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10486, 2296, UINT16_MAX, 2296, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10489, 2299, UINT16_MAX, 2299, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10492, 2302, UINT16_MAX, 2302, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10495, 2305, UINT16_MAX, 2305, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10498, UINT16_MAX, 8779, UINT16_MAX, 8779, 4409, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10500, UINT16_MAX, 8780, UINT16_MAX, 8780, 4413, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10502, UINT16_MAX, 8781, UINT16_MAX, 8781, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10504, UINT16_MAX, 8782, UINT16_MAX, 8782, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10506, UINT16_MAX, 8783, UINT16_MAX, 8783, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10508, UINT16_MAX, 8784, UINT16_MAX, 8784, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10510, 2320, UINT16_MAX, 2320, UINT16_MAX, 4417, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10513, 2323, UINT16_MAX, 2323, UINT16_MAX, 4421, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10516, 2326, UINT16_MAX, 2326, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10519, 2329, UINT16_MAX, 2329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10522, 2332, UINT16_MAX, 2332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10525, 2335, UINT16_MAX, 2335, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10528, 10528, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4425, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10530, UINT16_MAX, 8785, UINT16_MAX, 8785, 4477, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10532, 18726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10537, UINT16_MAX, 8786, UINT16_MAX, 8786, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10539, 18733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10544, UINT16_MAX, 8787, UINT16_MAX, 8787, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10546, 18740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10551, UINT16_MAX, 8788, UINT16_MAX, 8788, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10553, 2363, UINT16_MAX, 2363, UINT16_MAX, 4529, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10556, 2366, UINT16_MAX, 2366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10559, 2369, UINT16_MAX, 2369, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10562, 2372, UINT16_MAX, 2372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10565, UINT16_MAX, 8789, UINT16_MAX, 8789, 4581, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10567, UINT16_MAX, 8790, UINT16_MAX, 8790, 4634, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10569, UINT16_MAX, 8791, UINT16_MAX, 8791, 4865, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10571, UINT16_MAX, 8792, UINT16_MAX, 8792, 4868, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10573, UINT16_MAX, 8793, UINT16_MAX, 8793, 4871, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10575, UINT16_MAX, 8794, UINT16_MAX, 8794, 4874, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10577, UINT16_MAX, 8795, UINT16_MAX, 8795, 4877, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10579, UINT16_MAX, 8796, UINT16_MAX, 8796, 4880, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10581, 2391, UINT16_MAX, 2391, UINT16_MAX, 4687, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10584, 2394, UINT16_MAX, 2394, UINT16_MAX, 4740, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10587, 2397, UINT16_MAX, 2397, UINT16_MAX, 4883, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10590, 2400, UINT16_MAX, 2400, UINT16_MAX, 4886, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10593, 2403, UINT16_MAX, 2403, UINT16_MAX, 4889, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10596, 2406, UINT16_MAX, 2406, UINT16_MAX, 4892, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10599, 2409, UINT16_MAX, 2409, UINT16_MAX, 4895, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10602, 2412, UINT16_MAX, 2412, UINT16_MAX, 4898, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10605, UINT16_MAX, 8797, UINT16_MAX, 8797, 4901, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 820, UINT16_MAX, 8798, UINT16_MAX, 8798, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10607, UINT16_MAX, 8799, UINT16_MAX, 8799, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 824, UINT16_MAX, 8800, UINT16_MAX, 8800, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10609, UINT16_MAX, 8801, UINT16_MAX, 8801, 4910, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 827, UINT16_MAX, 8802, UINT16_MAX, 8802, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10611, UINT16_MAX, 8803, UINT16_MAX, 8803, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 830, UINT16_MAX, 8804, UINT16_MAX, 8804, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10613, UINT16_MAX, 8805, UINT16_MAX, 8805, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 833, UINT16_MAX, 8806, UINT16_MAX, 8806, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10615, UINT16_MAX, 8807, UINT16_MAX, 8807, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 836, UINT16_MAX, 8808, UINT16_MAX, 8808, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10617, UINT16_MAX, 8809, UINT16_MAX, 8809, 5030, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 839, UINT16_MAX, 8810, UINT16_MAX, 8810, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10619, 10621, 8811, UINT16_MAX, 8811, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10623, 10625, 8812, UINT16_MAX, 8812, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10627, 10629, 8813, UINT16_MAX, 8813, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10631, 10633, 8814, UINT16_MAX, 8814, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10635, 10637, 8815, UINT16_MAX, 8815, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10639, 10641, 8816, UINT16_MAX, 8816, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10643, 10645, 8817, UINT16_MAX, 8817, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10647, 10649, 8818, UINT16_MAX, 8818, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10651, 10621, UINT16_MAX, 8819, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10653, 10625, UINT16_MAX, 8820, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10655, 10629, UINT16_MAX, 8821, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10657, 10633, UINT16_MAX, 8822, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10659, 10637, UINT16_MAX, 8823, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10661, 10641, UINT16_MAX, 8824, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10663, 10645, UINT16_MAX, 8825, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10665, 10649, UINT16_MAX, 8826, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10667, 10669, 8827, UINT16_MAX, 8827, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10671, 10673, 8828, UINT16_MAX, 8828, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10675, 10677, 8829, UINT16_MAX, 8829, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10679, 10681, 8830, UINT16_MAX, 8830, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10683, 10685, 8831, UINT16_MAX, 8831, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10687, 10689, 8832, UINT16_MAX, 8832, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10691, 10693, 8833, UINT16_MAX, 8833, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10695, 10697, 8834, UINT16_MAX, 8834, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10699, 10669, UINT16_MAX, 8835, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10701, 10673, UINT16_MAX, 8836, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10703, 10677, UINT16_MAX, 8837, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10705, 10681, UINT16_MAX, 8838, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10707, 10685, UINT16_MAX, 8839, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10709, 10689, UINT16_MAX, 8840, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10711, 10693, UINT16_MAX, 8841, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10713, 10697, UINT16_MAX, 8842, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10715, 10717, 8843, UINT16_MAX, 8843, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10719, 10721, 8844, UINT16_MAX, 8844, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10723, 10725, 8845, UINT16_MAX, 8845, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10727, 10729, 8846, UINT16_MAX, 8846, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10731, 10733, 8847, UINT16_MAX, 8847, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10735, 10737, 8848, UINT16_MAX, 8848, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10739, 10741, 8849, UINT16_MAX, 8849, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10743, 10745, 8850, UINT16_MAX, 8850, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10747, 10717, UINT16_MAX, 8851, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10749, 10721, UINT16_MAX, 8852, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10751, 10725, UINT16_MAX, 8853, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10753, 10729, UINT16_MAX, 8854, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10755, 10733, UINT16_MAX, 8855, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10757, 10737, UINT16_MAX, 8856, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10759, 10741, UINT16_MAX, 8857, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10761, 10745, UINT16_MAX, 8858, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10763, UINT16_MAX, 8859, UINT16_MAX, 8859, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10765, UINT16_MAX, 8860, UINT16_MAX, 8860, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10767, 10769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10771, 10773, 8861, UINT16_MAX, 8861, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10775, 10777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10779, 10779, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4907, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10781, 18975, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10786, 2596, UINT16_MAX, 2596, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10789, 2599, UINT16_MAX, 2599, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10792, 2602, UINT16_MAX, 2602, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2603, 2604, UINT16_MAX, 2604, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10797, 10773, UINT16_MAX, 8862, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 807, 807, 7217, UINT16_MAX, 7217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4919, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10805, 10807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10809, 10811, 8863, UINT16_MAX, 8863, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10813, 10815, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10817, 10817, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4916, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10819, 19013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10824, 2634, UINT16_MAX, 2634, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2635, 2636, UINT16_MAX, 2636, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10829, 2639, UINT16_MAX, 2639, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2640, 2641, UINT16_MAX, 2641, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10834, 10811, UINT16_MAX, 8864, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10842, UINT16_MAX, 8865, UINT16_MAX, 8865, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10844, UINT16_MAX, 8866, UINT16_MAX, 8866, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10846, 19040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 2659, 17226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10852, 10852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10854, 19048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10859, 2669, UINT16_MAX, 2669, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10862, 2672, UINT16_MAX, 2672, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10865, 2675, UINT16_MAX, 2675, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2676, 2677, UINT16_MAX, 2677, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10876, UINT16_MAX, 8867, UINT16_MAX, 8867, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10878, UINT16_MAX, 8868, UINT16_MAX, 8868, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10880, 19074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 2693, 17267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10886, 10886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10888, UINT16_MAX, 8869, UINT16_MAX, 8869, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10890, 10890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10892, 19086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10897, 2707, UINT16_MAX, 2707, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10900, 2710, UINT16_MAX, 2710, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10903, 2713, UINT16_MAX, 2713, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2714, 2715, UINT16_MAX, 2715, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10908, 2718, UINT16_MAX, 2718, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 10911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 2721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 2722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10915, 10917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10919, 10921, 8870, UINT16_MAX, 8870, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10923, 10925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10927, 10927, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5036, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, 10929, 19123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10934, 2744, UINT16_MAX, 2744, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2745, 2746, UINT16_MAX, 2746, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 10939, 2749, UINT16_MAX, 2749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2750, 2751, UINT16_MAX, 2751, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LT, 0, UTF8PROC_BIDI_CLASS_L, 0, 10944, 10921, UINT16_MAX, 8871, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, 2754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 4971, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, 2757, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, 0, 2758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_COMPAT, 26, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_NOBREAK, 26, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_BN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_ZWJ},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NOBREAK, 2759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PI, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 2762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ZL, 0, UTF8PROC_BIDI_CLASS_WS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_ZP, 0, UTF8PROC_BIDI_CLASS_B, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRE, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLE, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_PDF, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRO, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLO, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 10960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 19154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_CS, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 10978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27364, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_LRI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_RLI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_FSI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_PDI, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 8, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUPER, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUPER, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUPER, 2800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 2801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 13, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_SUB, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUB, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SUB, 2800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 2801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUB, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 4, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 14, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 23, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 7, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 10, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 11, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 12, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 13, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 15, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 18, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 19, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_COMPAT, 10996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 6, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 11, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 11019, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 11024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2835, 866, UINT16_MAX, 866, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 1501, 10, UINT16_MAX, 10, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, 2836, 65, UINT16_MAX, 65, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 4, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2838, UINT16_MAX, 2838, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 14, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2841, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FONT, 2848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 8, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 9, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8872, UINT16_MAX, 8872, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 27431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 11087, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1499, 2897, UINT16_MAX, 2897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11090, 2900, UINT16_MAX, 2900, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19285, 2904, UINT16_MAX, 2904, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11097, 2907, UINT16_MAX, 2907, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2908, 2909, UINT16_MAX, 2909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11102, 2912, UINT16_MAX, 2912, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19297, 2916, UINT16_MAX, 2916, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 27493, 2921, UINT16_MAX, 2921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11114, 2924, UINT16_MAX, 2924, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2925, 2926, UINT16_MAX, 2926, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11119, 2929, UINT16_MAX, 2929, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19314, 2933, UINT16_MAX, 2933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1502, 2934, UINT16_MAX, 2934, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2812, 2935, UINT16_MAX, 2935, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1494, 2936, UINT16_MAX, 2936, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 1503, 2937, UINT16_MAX, 2937, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 8, UINT16_MAX, 8873, UINT16_MAX, 8873, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11130, UINT16_MAX, 8874, UINT16_MAX, 8874, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19324, UINT16_MAX, 8875, UINT16_MAX, 8875, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11135, UINT16_MAX, 8876, UINT16_MAX, 8876, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21, UINT16_MAX, 8877, UINT16_MAX, 8877, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11137, UINT16_MAX, 8878, UINT16_MAX, 8878, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19331, UINT16_MAX, 8879, UINT16_MAX, 8879, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 27526, UINT16_MAX, 8880, UINT16_MAX, 8880, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11146, UINT16_MAX, 8881, UINT16_MAX, 8881, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23, UINT16_MAX, 8882, UINT16_MAX, 8882, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11148, UINT16_MAX, 8883, UINT16_MAX, 8883, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19342, UINT16_MAX, 8884, UINT16_MAX, 8884, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 11, UINT16_MAX, 8885, UINT16_MAX, 8885, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 2, UINT16_MAX, 8886, UINT16_MAX, 8886, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3, UINT16_MAX, 8887, UINT16_MAX, 8887, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12, UINT16_MAX, 8888, UINT16_MAX, 8888, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 2961, UINT16_MAX, 2961, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8889, UINT16_MAX, 8889, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FRACTION, 19346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5039, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5042, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5045, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11157, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5048, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5054, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5051, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5057, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5060, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5063, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5066, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5069, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11179, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5072, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5075, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5078, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5081, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5090, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5087, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5099, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5102, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5105, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5108, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5111, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5114, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5117, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5120, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5147, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5150, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5123, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5126, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5129, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5132, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5153, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5156, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5135, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5138, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5141, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5144, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5159, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5162, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5165, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5168, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11239, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11241, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11243, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11245, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, 3064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 11277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27694, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27698, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11352, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11362, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11364, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 11366, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 19590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19641, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 19668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1491, 3287, UINT16_MAX, 3287, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1493, 3288, UINT16_MAX, 3288, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2812, 3289, UINT16_MAX, 3289, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1494, 3290, UINT16_MAX, 3290, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1495, 3291, UINT16_MAX, 3291, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2837, 3292, UINT16_MAX, 3292, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1497, 3293, UINT16_MAX, 3293, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1498, 3294, UINT16_MAX, 3294, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1499, 3295, UINT16_MAX, 3295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1500, 3296, UINT16_MAX, 3296, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1501, 3297, UINT16_MAX, 3297, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1502, 3298, UINT16_MAX, 3298, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1503, 3299, UINT16_MAX, 3299, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1504, 3300, UINT16_MAX, 3300, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1505, 3301, UINT16_MAX, 3301, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1507, 3302, UINT16_MAX, 3302, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2826, 3303, UINT16_MAX, 3303, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1508, 3304, UINT16_MAX, 3304, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3305, 3306, UINT16_MAX, 3306, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1509, 3307, UINT16_MAX, 3307, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1510, 3308, UINT16_MAX, 3308, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2908, 3309, UINT16_MAX, 3309, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1511, 3310, UINT16_MAX, 3310, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2925, 3311, UINT16_MAX, 3311, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3312, 3313, UINT16_MAX, 3313, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2834, 3314, UINT16_MAX, 3314, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 0, UINT16_MAX, 8890, UINT16_MAX, 8890, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1, UINT16_MAX, 8891, UINT16_MAX, 8891, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2, UINT16_MAX, 8892, UINT16_MAX, 8892, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3, UINT16_MAX, 8893, UINT16_MAX, 8893, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4, UINT16_MAX, 8894, UINT16_MAX, 8894, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 5, UINT16_MAX, 8895, UINT16_MAX, 8895, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 6, UINT16_MAX, 8896, UINT16_MAX, 8896, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 7, UINT16_MAX, 8897, UINT16_MAX, 8897, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 8, UINT16_MAX, 8898, UINT16_MAX, 8898, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 9, UINT16_MAX, 8899, UINT16_MAX, 8899, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 10, UINT16_MAX, 8900, UINT16_MAX, 8900, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 11, UINT16_MAX, 8901, UINT16_MAX, 8901, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12, UINT16_MAX, 8902, UINT16_MAX, 8902, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 13, UINT16_MAX, 8903, UINT16_MAX, 8903, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 14, UINT16_MAX, 8904, UINT16_MAX, 8904, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 15, UINT16_MAX, 8905, UINT16_MAX, 8905, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 16, UINT16_MAX, 8906, UINT16_MAX, 8906, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 17, UINT16_MAX, 8907, UINT16_MAX, 8907, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 18, UINT16_MAX, 8908, UINT16_MAX, 8908, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 19, UINT16_MAX, 8909, UINT16_MAX, 8909, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 20, UINT16_MAX, 8910, UINT16_MAX, 8910, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 21, UINT16_MAX, 8911, UINT16_MAX, 8911, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 22, UINT16_MAX, 8912, UINT16_MAX, 8912, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 23, UINT16_MAX, 8913, UINT16_MAX, 8913, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 24, UINT16_MAX, 8914, UINT16_MAX, 8914, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 25, UINT16_MAX, 8915, UINT16_MAX, 8915, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 27891, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 19708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, 11519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5171, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3329, UINT16_MAX, 3329, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3330, UINT16_MAX, 3330, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3331, UINT16_MAX, 3331, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3332, UINT16_MAX, 3332, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3333, UINT16_MAX, 3333, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3334, UINT16_MAX, 3334, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3335, UINT16_MAX, 3335, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3336, UINT16_MAX, 3336, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3337, UINT16_MAX, 3337, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3338, UINT16_MAX, 3338, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3339, UINT16_MAX, 3339, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3340, UINT16_MAX, 3340, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3341, UINT16_MAX, 3341, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3342, UINT16_MAX, 3342, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3343, UINT16_MAX, 3343, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3344, UINT16_MAX, 3344, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3345, UINT16_MAX, 3345, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3346, UINT16_MAX, 3346, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3347, UINT16_MAX, 3347, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3348, UINT16_MAX, 3348, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3349, UINT16_MAX, 3349, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3350, UINT16_MAX, 3350, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3351, UINT16_MAX, 3351, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3352, UINT16_MAX, 3352, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3353, UINT16_MAX, 3353, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3354, UINT16_MAX, 3354, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3355, UINT16_MAX, 3355, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3356, UINT16_MAX, 3356, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3357, UINT16_MAX, 3357, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3358, UINT16_MAX, 3358, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3359, UINT16_MAX, 3359, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3360, UINT16_MAX, 3360, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3361, UINT16_MAX, 3361, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3362, UINT16_MAX, 3362, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3363, UINT16_MAX, 3363, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3364, UINT16_MAX, 3364, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3365, UINT16_MAX, 3365, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3366, UINT16_MAX, 3366, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3367, UINT16_MAX, 3367, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3368, UINT16_MAX, 3368, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3369, UINT16_MAX, 3369, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3370, UINT16_MAX, 3370, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3371, UINT16_MAX, 3371, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3372, UINT16_MAX, 3372, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3373, UINT16_MAX, 3373, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3374, UINT16_MAX, 3374, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3375, UINT16_MAX, 3375, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8916, UINT16_MAX, 8916, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8917, UINT16_MAX, 8917, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8918, UINT16_MAX, 8918, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8919, UINT16_MAX, 8919, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8920, UINT16_MAX, 8920, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8921, UINT16_MAX, 8921, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8922, UINT16_MAX, 8922, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8923, UINT16_MAX, 8923, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8924, UINT16_MAX, 8924, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8925, UINT16_MAX, 8925, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8926, UINT16_MAX, 8926, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8927, UINT16_MAX, 8927, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8928, UINT16_MAX, 8928, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8929, UINT16_MAX, 8929, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8930, UINT16_MAX, 8930, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8931, UINT16_MAX, 8931, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8932, UINT16_MAX, 8932, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8933, UINT16_MAX, 8933, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8934, UINT16_MAX, 8934, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8935, UINT16_MAX, 8935, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8936, UINT16_MAX, 8936, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8937, UINT16_MAX, 8937, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8938, UINT16_MAX, 8938, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8939, UINT16_MAX, 8939, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8940, UINT16_MAX, 8940, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8941, UINT16_MAX, 8941, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8942, UINT16_MAX, 8942, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8943, UINT16_MAX, 8943, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8944, UINT16_MAX, 8944, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8945, UINT16_MAX, 8945, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8946, UINT16_MAX, 8946, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8947, UINT16_MAX, 8947, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8948, UINT16_MAX, 8948, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8949, UINT16_MAX, 8949, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8950, UINT16_MAX, 8950, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8951, UINT16_MAX, 8951, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8952, UINT16_MAX, 8952, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8953, UINT16_MAX, 8953, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8954, UINT16_MAX, 8954, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8955, UINT16_MAX, 8955, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8956, UINT16_MAX, 8956, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8957, UINT16_MAX, 8957, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8958, UINT16_MAX, 8958, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8959, UINT16_MAX, 8959, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8960, UINT16_MAX, 8960, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8961, UINT16_MAX, 8961, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8962, UINT16_MAX, 8962, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3376, UINT16_MAX, 3376, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8963, UINT16_MAX, 8963, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3377, UINT16_MAX, 3377, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3378, UINT16_MAX, 3378, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3379, UINT16_MAX, 3379, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8964, UINT16_MAX, 8964, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8965, UINT16_MAX, 8965, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3380, UINT16_MAX, 3380, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8966, UINT16_MAX, 8966, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3381, UINT16_MAX, 3381, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8967, UINT16_MAX, 8967, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3382, UINT16_MAX, 3382, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8968, UINT16_MAX, 8968, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1513, UINT16_MAX, 1513, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1531, UINT16_MAX, 1531, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1512, UINT16_MAX, 1512, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1520, UINT16_MAX, 1520, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3383, UINT16_MAX, 3383, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8969, UINT16_MAX, 8969, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3384, UINT16_MAX, 3384, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8970, UINT16_MAX, 8970, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUB, 9, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 2908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3385, UINT16_MAX, 3385, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3386, UINT16_MAX, 3386, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3387, UINT16_MAX, 3387, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8971, UINT16_MAX, 8971, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3388, UINT16_MAX, 3388, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8972, UINT16_MAX, 8972, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3389, UINT16_MAX, 3389, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8973, UINT16_MAX, 8973, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3390, UINT16_MAX, 3390, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8974, UINT16_MAX, 8974, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3391, UINT16_MAX, 3391, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8975, UINT16_MAX, 8975, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3392, UINT16_MAX, 3392, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8976, UINT16_MAX, 8976, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3393, UINT16_MAX, 3393, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8977, UINT16_MAX, 8977, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3394, UINT16_MAX, 3394, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8978, UINT16_MAX, 8978, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3395, UINT16_MAX, 3395, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8979, UINT16_MAX, 8979, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3396, UINT16_MAX, 3396, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8980, UINT16_MAX, 8980, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3397, UINT16_MAX, 3397, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8981, UINT16_MAX, 8981, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3398, UINT16_MAX, 3398, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8982, UINT16_MAX, 8982, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3399, UINT16_MAX, 3399, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8983, UINT16_MAX, 8983, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3400, UINT16_MAX, 3400, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8984, UINT16_MAX, 8984, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3401, UINT16_MAX, 3401, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8985, UINT16_MAX, 8985, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3402, UINT16_MAX, 3402, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8986, UINT16_MAX, 8986, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3403, UINT16_MAX, 3403, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8987, UINT16_MAX, 8987, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3404, UINT16_MAX, 3404, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8988, UINT16_MAX, 8988, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3405, UINT16_MAX, 3405, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8989, UINT16_MAX, 8989, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3406, UINT16_MAX, 3406, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8990, UINT16_MAX, 8990, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3407, UINT16_MAX, 3407, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8991, UINT16_MAX, 8991, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3408, UINT16_MAX, 3408, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8992, UINT16_MAX, 8992, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3409, UINT16_MAX, 3409, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8993, UINT16_MAX, 8993, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3410, UINT16_MAX, 3410, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8994, UINT16_MAX, 8994, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3411, UINT16_MAX, 3411, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8995, UINT16_MAX, 8995, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3412, UINT16_MAX, 3412, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8996, UINT16_MAX, 8996, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3413, UINT16_MAX, 3413, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8997, UINT16_MAX, 8997, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3414, UINT16_MAX, 3414, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8998, UINT16_MAX, 8998, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3415, UINT16_MAX, 3415, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8999, UINT16_MAX, 8999, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3416, UINT16_MAX, 3416, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9000, UINT16_MAX, 9000, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3417, UINT16_MAX, 3417, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9001, UINT16_MAX, 9001, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3418, UINT16_MAX, 3418, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9002, UINT16_MAX, 9002, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3419, UINT16_MAX, 3419, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9003, UINT16_MAX, 9003, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3420, UINT16_MAX, 3420, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9004, UINT16_MAX, 9004, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3421, UINT16_MAX, 3421, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9005, UINT16_MAX, 9005, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3422, UINT16_MAX, 3422, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9006, UINT16_MAX, 9006, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3423, UINT16_MAX, 3423, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9007, UINT16_MAX, 9007, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3424, UINT16_MAX, 3424, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9008, UINT16_MAX, 9008, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3425, UINT16_MAX, 3425, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9009, UINT16_MAX, 9009, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3426, UINT16_MAX, 3426, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9010, UINT16_MAX, 9010, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3427, UINT16_MAX, 3427, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9011, UINT16_MAX, 9011, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3428, UINT16_MAX, 3428, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9012, UINT16_MAX, 9012, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3429, UINT16_MAX, 3429, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9013, UINT16_MAX, 9013, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3430, UINT16_MAX, 3430, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9014, UINT16_MAX, 9014, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3431, UINT16_MAX, 3431, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9015, UINT16_MAX, 9015, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3432, UINT16_MAX, 3432, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9016, UINT16_MAX, 9016, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3433, UINT16_MAX, 3433, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9017, UINT16_MAX, 9017, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3434, UINT16_MAX, 3434, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9018, UINT16_MAX, 9018, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3435, UINT16_MAX, 3435, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9019, UINT16_MAX, 9019, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3436, UINT16_MAX, 3436, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9020, UINT16_MAX, 9020, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3437, UINT16_MAX, 3437, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9021, UINT16_MAX, 9021, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3438, UINT16_MAX, 3438, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9022, UINT16_MAX, 9022, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 3439, UINT16_MAX, 3439, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9023, UINT16_MAX, 9023, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9024, UINT16_MAX, 9024, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9025, UINT16_MAX, 9025, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9026, UINT16_MAX, 9026, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9027, UINT16_MAX, 9027, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9028, UINT16_MAX, 9028, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9029, UINT16_MAX, 9029, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9030, UINT16_MAX, 9030, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9031, UINT16_MAX, 9031, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9032, UINT16_MAX, 9032, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9033, UINT16_MAX, 9033, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9034, UINT16_MAX, 9034, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9035, UINT16_MAX, 9035, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9036, UINT16_MAX, 9036, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9037, UINT16_MAX, 9037, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9038, UINT16_MAX, 9038, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9039, UINT16_MAX, 9039, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9040, UINT16_MAX, 9040, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9041, UINT16_MAX, 9041, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9042, UINT16_MAX, 9042, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9043, UINT16_MAX, 9043, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9044, UINT16_MAX, 9044, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9045, UINT16_MAX, 9045, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9046, UINT16_MAX, 9046, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9047, UINT16_MAX, 9047, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9048, UINT16_MAX, 9048, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9049, UINT16_MAX, 9049, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9050, UINT16_MAX, 9050, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9051, UINT16_MAX, 9051, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9052, UINT16_MAX, 9052, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9053, UINT16_MAX, 9053, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9054, UINT16_MAX, 9054, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9055, UINT16_MAX, 9055, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9056, UINT16_MAX, 9056, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9057, UINT16_MAX, 9057, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9058, UINT16_MAX, 9058, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9059, UINT16_MAX, 9059, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9060, UINT16_MAX, 9060, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9061, UINT16_MAX, 9061, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9062, UINT16_MAX, 9062, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9063, UINT16_MAX, 9063, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3476, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3484, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3488, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3490, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3496, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3544, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3548, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3641, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3655, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ZS, 0, UTF8PROC_BIDI_CLASS_WS, UTF8PROC_DECOMP_TYPE_WIDE, 26, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 218, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 224, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 3657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5239, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5174, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5177, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5180, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5183, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5186, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5189, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5192, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5195, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5198, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5201, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5204, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5207, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5210, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5213, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5216, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5219, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5223, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5227, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11892, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5231, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5235, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11900, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11902, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 8, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32820, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 8, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 32821, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 11906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5242, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, 11908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_VERTICAL, 11910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5310, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5245, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5248, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5251, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5254, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5257, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5260, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5263, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5266, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5269, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5272, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5275, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5278, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5281, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5284, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5287, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5290, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11944, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5294, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11948, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5298, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11950, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5302, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5306, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5313, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5316, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5319, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5322, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11968, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 11970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5325, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, 0, 11972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_VERTICAL, 11974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3805, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3806, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3808, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3811, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3815, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3817, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3818, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3820, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3821, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3823, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3824, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3825, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3827, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3828, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3829, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3830, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3831, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3832, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3833, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3841, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3850, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3869, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3871, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 3877, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3883, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3884, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3885, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3887, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20284, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 28562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 53142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 44957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20387, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20390, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20408, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20426, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 20498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3806, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3811, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12345, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12347, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12351, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12363, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 12365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 36943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 28756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12376, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4195, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4199, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4200, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4202, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4203, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4206, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4207, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 3882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12412, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12418, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12424, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12426, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_CIRCLE, 12438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 20656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 12467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 20661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 12472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 20666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4316, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4318, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4320, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4326, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4328, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4330, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 4331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37127, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20755, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 28976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 45371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20806, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20823, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20829, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20885, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12698, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29089, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20906, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29141, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29159, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 20994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12818, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12828, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12830, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12832, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12836, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12838, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12840, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 12846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21043, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21055, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21061, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21073, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21079, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21085, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 12907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21101, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 12915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21137, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29332, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12982, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12988, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12990, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 12996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21198, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21204, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13015, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13027, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 37617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 45814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13105, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13107, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13109, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13111, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13113, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13115, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13117, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13119, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13121, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13123, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 29524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 21336, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13147, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13149, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13151, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13153, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21347, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13161, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13163, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13167, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13169, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13171, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13175, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21374, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21380, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21386, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21392, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21395, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21398, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21401, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21404, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21419, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 21434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SQUARE, 21437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5056, UINT16_MAX, 5056, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9064, UINT16_MAX, 9064, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5057, UINT16_MAX, 5057, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9065, UINT16_MAX, 9065, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5058, UINT16_MAX, 5058, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9066, UINT16_MAX, 9066, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5059, UINT16_MAX, 5059, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9067, UINT16_MAX, 9067, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5060, UINT16_MAX, 5060, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9068, UINT16_MAX, 9068, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1445, UINT16_MAX, 1445, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 8621, UINT16_MAX, 8621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5061, UINT16_MAX, 5061, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9069, UINT16_MAX, 9069, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5062, UINT16_MAX, 5062, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9070, UINT16_MAX, 9070, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5063, UINT16_MAX, 5063, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9071, UINT16_MAX, 9071, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5064, UINT16_MAX, 5064, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9072, UINT16_MAX, 9072, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5065, UINT16_MAX, 5065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9073, UINT16_MAX, 9073, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5066, UINT16_MAX, 5066, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9074, UINT16_MAX, 9074, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5067, UINT16_MAX, 5067, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9075, UINT16_MAX, 9075, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5068, UINT16_MAX, 5068, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9076, UINT16_MAX, 9076, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5069, UINT16_MAX, 5069, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9077, UINT16_MAX, 9077, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5070, UINT16_MAX, 5070, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9078, UINT16_MAX, 9078, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5071, UINT16_MAX, 5071, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9079, UINT16_MAX, 9079, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5072, UINT16_MAX, 5072, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9080, UINT16_MAX, 9080, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5073, UINT16_MAX, 5073, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9081, UINT16_MAX, 9081, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5074, UINT16_MAX, 5074, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9082, UINT16_MAX, 9082, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5075, UINT16_MAX, 5075, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9083, UINT16_MAX, 9083, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5076, UINT16_MAX, 5076, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9084, UINT16_MAX, 9084, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5077, UINT16_MAX, 5077, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9085, UINT16_MAX, 9085, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5078, UINT16_MAX, 5078, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9086, UINT16_MAX, 9086, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5079, UINT16_MAX, 5079, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9087, UINT16_MAX, 9087, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5080, UINT16_MAX, 5080, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9088, UINT16_MAX, 9088, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5081, UINT16_MAX, 5081, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9089, UINT16_MAX, 9089, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5082, UINT16_MAX, 5082, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9090, UINT16_MAX, 9090, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5083, UINT16_MAX, 5083, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9091, UINT16_MAX, 9091, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5084, UINT16_MAX, 5084, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9092, UINT16_MAX, 9092, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5085, UINT16_MAX, 5085, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9093, UINT16_MAX, 9093, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5086, UINT16_MAX, 5086, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9094, UINT16_MAX, 9094, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5087, UINT16_MAX, 5087, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9095, UINT16_MAX, 9095, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5088, UINT16_MAX, 5088, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9096, UINT16_MAX, 9096, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5089, UINT16_MAX, 5089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9097, UINT16_MAX, 9097, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5090, UINT16_MAX, 5090, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9098, UINT16_MAX, 9098, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5091, UINT16_MAX, 5091, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9099, UINT16_MAX, 9099, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5092, UINT16_MAX, 5092, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9100, UINT16_MAX, 9100, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5093, UINT16_MAX, 5093, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9101, UINT16_MAX, 9101, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5094, UINT16_MAX, 5094, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9102, UINT16_MAX, 9102, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5095, UINT16_MAX, 5095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9103, UINT16_MAX, 9103, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5096, UINT16_MAX, 5096, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9104, UINT16_MAX, 9104, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5097, UINT16_MAX, 5097, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9105, UINT16_MAX, 9105, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5098, UINT16_MAX, 5098, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9106, UINT16_MAX, 9106, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5099, UINT16_MAX, 5099, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9107, UINT16_MAX, 9107, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5100, UINT16_MAX, 5100, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9108, UINT16_MAX, 9108, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5101, UINT16_MAX, 5101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9109, UINT16_MAX, 9109, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5102, UINT16_MAX, 5102, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9110, UINT16_MAX, 9110, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5103, UINT16_MAX, 5103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9111, UINT16_MAX, 9111, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5104, UINT16_MAX, 5104, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9112, UINT16_MAX, 9112, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5105, UINT16_MAX, 5105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9113, UINT16_MAX, 9113, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5106, UINT16_MAX, 5106, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9114, UINT16_MAX, 9114, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5107, UINT16_MAX, 5107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9115, UINT16_MAX, 9115, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5108, UINT16_MAX, 5108, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9116, UINT16_MAX, 9116, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5109, UINT16_MAX, 5109, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9117, UINT16_MAX, 9117, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5110, UINT16_MAX, 5110, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9118, UINT16_MAX, 9118, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5111, UINT16_MAX, 5111, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9119, UINT16_MAX, 9119, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5112, UINT16_MAX, 5112, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9120, UINT16_MAX, 9120, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5113, UINT16_MAX, 5113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9121, UINT16_MAX, 9121, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5114, UINT16_MAX, 5114, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9122, UINT16_MAX, 9122, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5115, UINT16_MAX, 5115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9123, UINT16_MAX, 9123, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5116, UINT16_MAX, 5116, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9124, UINT16_MAX, 9124, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5117, UINT16_MAX, 5117, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9125, UINT16_MAX, 9125, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5118, UINT16_MAX, 5118, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9126, UINT16_MAX, 9126, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5119, UINT16_MAX, 5119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9127, UINT16_MAX, 9127, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5120, UINT16_MAX, 5120, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9128, UINT16_MAX, 9128, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5121, UINT16_MAX, 5121, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9129, UINT16_MAX, 9129, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5122, UINT16_MAX, 5122, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9130, UINT16_MAX, 9130, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5123, UINT16_MAX, 5123, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9131, UINT16_MAX, 9131, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5124, UINT16_MAX, 5124, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9132, UINT16_MAX, 9132, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5125, UINT16_MAX, 5125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9133, UINT16_MAX, 9133, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5126, UINT16_MAX, 5126, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9134, UINT16_MAX, 9134, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5127, UINT16_MAX, 5127, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9135, UINT16_MAX, 9135, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5128, UINT16_MAX, 5128, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9136, UINT16_MAX, 9136, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5129, UINT16_MAX, 5129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9137, UINT16_MAX, 9137, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5129, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5130, UINT16_MAX, 5130, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9138, UINT16_MAX, 9138, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5131, UINT16_MAX, 5131, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9139, UINT16_MAX, 9139, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5132, UINT16_MAX, 5132, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5133, UINT16_MAX, 5133, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9140, UINT16_MAX, 9140, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5134, UINT16_MAX, 5134, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9141, UINT16_MAX, 9141, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5135, UINT16_MAX, 5135, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9142, UINT16_MAX, 9142, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5136, UINT16_MAX, 5136, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9143, UINT16_MAX, 9143, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5137, UINT16_MAX, 5137, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9144, UINT16_MAX, 9144, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5138, UINT16_MAX, 5138, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9145, UINT16_MAX, 9145, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1524, UINT16_MAX, 1524, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5139, UINT16_MAX, 5139, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9146, UINT16_MAX, 9146, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5140, UINT16_MAX, 5140, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9147, UINT16_MAX, 9147, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9148, UINT16_MAX, 9148, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5141, UINT16_MAX, 5141, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9149, UINT16_MAX, 9149, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5142, UINT16_MAX, 5142, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9150, UINT16_MAX, 9150, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5143, UINT16_MAX, 5143, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9151, UINT16_MAX, 9151, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5144, UINT16_MAX, 5144, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9152, UINT16_MAX, 9152, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5145, UINT16_MAX, 5145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9153, UINT16_MAX, 9153, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5146, UINT16_MAX, 5146, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9154, UINT16_MAX, 9154, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5147, UINT16_MAX, 5147, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9155, UINT16_MAX, 9155, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5148, UINT16_MAX, 5148, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9156, UINT16_MAX, 9156, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5149, UINT16_MAX, 5149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9157, UINT16_MAX, 9157, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5150, UINT16_MAX, 5150, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9158, UINT16_MAX, 9158, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 785, UINT16_MAX, 785, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1515, UINT16_MAX, 1515, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1523, UINT16_MAX, 1523, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5151, UINT16_MAX, 5151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1525, UINT16_MAX, 1525, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5152, UINT16_MAX, 5152, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5153, UINT16_MAX, 5153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1527, UINT16_MAX, 1527, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5154, UINT16_MAX, 5154, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5155, UINT16_MAX, 5155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9159, UINT16_MAX, 9159, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5156, UINT16_MAX, 5156, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9160, UINT16_MAX, 9160, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5157, UINT16_MAX, 5157, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9161, UINT16_MAX, 9161, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5158, UINT16_MAX, 5158, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9162, UINT16_MAX, 9162, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5159, UINT16_MAX, 5159, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9163, UINT16_MAX, 9163, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5160, UINT16_MAX, 5160, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9164, UINT16_MAX, 9164, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5161, UINT16_MAX, 5161, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9165, UINT16_MAX, 9165, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5162, UINT16_MAX, 5162, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 1536, UINT16_MAX, 1536, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5163, UINT16_MAX, 5163, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9166, UINT16_MAX, 9166, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5165, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 3377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SUPER, 5166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5167, 5167, UINT16_MAX, 5167, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5168, 5168, UINT16_MAX, 5168, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5169, 5169, UINT16_MAX, 5169, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5170, 5170, UINT16_MAX, 5170, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5171, 5171, UINT16_MAX, 5171, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5172, 5172, UINT16_MAX, 5172, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5173, 5173, UINT16_MAX, 5173, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5174, 5174, UINT16_MAX, 5174, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5175, 5175, UINT16_MAX, 5175, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5176, 5176, UINT16_MAX, 5176, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5177, 5177, UINT16_MAX, 5177, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5178, 5178, UINT16_MAX, 5178, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5179, 5179, UINT16_MAX, 5179, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5180, 5180, UINT16_MAX, 5180, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5181, 5181, UINT16_MAX, 5181, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5182, 5182, UINT16_MAX, 5182, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5183, 5183, UINT16_MAX, 5183, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5184, 5184, UINT16_MAX, 5184, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5185, 5185, UINT16_MAX, 5185, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5186, 5186, UINT16_MAX, 5186, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5187, 5187, UINT16_MAX, 5187, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5188, 5188, UINT16_MAX, 5188, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5189, 5189, UINT16_MAX, 5189, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5190, 5190, UINT16_MAX, 5190, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5191, 5191, UINT16_MAX, 5191, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5192, 5192, UINT16_MAX, 5192, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5193, 5193, UINT16_MAX, 5193, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5194, 5194, UINT16_MAX, 5194, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5195, 5195, UINT16_MAX, 5195, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5196, 5196, UINT16_MAX, 5196, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5197, 5197, UINT16_MAX, 5197, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5198, 5198, UINT16_MAX, 5198, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5199, 5199, UINT16_MAX, 5199, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5200, 5200, UINT16_MAX, 5200, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5201, 5201, UINT16_MAX, 5201, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5202, 5202, UINT16_MAX, 5202, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5203, 5203, UINT16_MAX, 5203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5204, 5204, UINT16_MAX, 5204, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5205, 5205, UINT16_MAX, 5205, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5206, 5206, UINT16_MAX, 5206, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5207, 5207, UINT16_MAX, 5207, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5208, 5208, UINT16_MAX, 5208, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5209, 5209, UINT16_MAX, 5209, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5210, 5210, UINT16_MAX, 5210, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5211, 5211, UINT16_MAX, 5211, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5212, 5212, UINT16_MAX, 5212, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5213, 5213, UINT16_MAX, 5213, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5214, 5214, UINT16_MAX, 5214, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5215, 5215, UINT16_MAX, 5215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5216, 5216, UINT16_MAX, 5216, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5217, 5217, UINT16_MAX, 5217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5218, 5218, UINT16_MAX, 5218, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5219, 5219, UINT16_MAX, 5219, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5220, 5220, UINT16_MAX, 5220, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5221, 5221, UINT16_MAX, 5221, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5222, 5222, UINT16_MAX, 5222, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5223, 5223, UINT16_MAX, 5223, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5224, 5224, UINT16_MAX, 5224, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5225, 5225, UINT16_MAX, 5225, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5226, 5226, UINT16_MAX, 5226, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5227, 5227, UINT16_MAX, 5227, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5228, 5228, UINT16_MAX, 5228, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5229, 5229, UINT16_MAX, 5229, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5230, 5230, UINT16_MAX, 5230, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5231, 5231, UINT16_MAX, 5231, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5232, 5232, UINT16_MAX, 5232, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5233, 5233, UINT16_MAX, 5233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5234, 5234, UINT16_MAX, 5234, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5235, 5235, UINT16_MAX, 5235, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5236, 5236, UINT16_MAX, 5236, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5237, 5237, UINT16_MAX, 5237, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5238, 5238, UINT16_MAX, 5238, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5239, 5239, UINT16_MAX, 5239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5240, 5240, UINT16_MAX, 5240, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5241, 5241, UINT16_MAX, 5241, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5242, 5242, UINT16_MAX, 5242, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5243, 5243, UINT16_MAX, 5243, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5244, 5244, UINT16_MAX, 5244, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5245, 5245, UINT16_MAX, 5245, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 5246, 5246, UINT16_MAX, 5246, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_LV},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_LVT},
-  {UTF8PROC_CATEGORY_CS, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5247, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5249, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5251, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3655, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5253, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5255, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5257, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5259, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5261, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5263, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5265, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5267, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5269, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5271, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5273, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5275, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5277, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5279, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5280, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5281, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5282, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5283, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5284, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5316, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5318, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5320, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5326, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5328, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5330, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5332, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5334, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5336, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5338, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5340, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5342, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5344, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5345, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5346, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5347, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5348, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5350, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5351, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5352, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5354, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5355, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5356, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5358, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5359, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5360, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5362, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5363, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5364, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5366, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5367, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5368, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5369, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5370, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5371, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5372, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5374, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5375, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5376, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5378, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5379, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5380, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5381, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5382, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5383, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5384, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5385, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5386, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5387, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5388, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5390, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5391, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5392, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5394, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5395, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5397, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5398, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5400, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5401, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5403, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5404, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5406, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5407, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5408, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5409, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5410, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5411, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5412, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5413, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5414, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5415, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5416, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5417, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5418, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5419, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5420, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5421, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5422, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5423, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5424, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5426, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5427, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5428, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5429, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5430, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5431, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5432, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5433, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5434, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5435, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5436, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5437, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5438, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5439, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4187, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5471, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5473, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5474, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5476, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5477, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5479, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5480, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5481, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5482, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5483, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5484, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5486, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5488, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5489, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5490, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5492, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5496, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3487, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5544, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5548, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 4196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5634, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5641, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 5659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13852, 13852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13854, 13854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13856, 13856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22050, 22050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 22053, 22053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13864, 13866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13866, 13866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13868, 13868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13870, 13870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13872, 13872, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13874, 13874, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 13876, 13876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 26, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13880, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 2839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 2842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5691, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5692, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5694, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5695, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_FONT, 5696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_FONT, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13889, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13891, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13893, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13899, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13919, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13931, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13933, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13935, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13941, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, 0, 13951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_R, UTF8PROC_DECOMP_TYPE_COMPAT, 13953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5763, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5763, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5776, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5776, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5778, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5778, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5780, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5780, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5781, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5781, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5784, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5790, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 13995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 13995, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 13997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 13997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 13999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 13999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14005, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 5819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 5819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14098, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14100, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14106, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14136, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14140, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14146, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14148, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14156, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14158, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14162, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14170, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14176, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14178, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14192, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14194, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22390, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22396, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22399, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22402, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22405, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14108, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14110, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14116, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14118, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14120, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14132, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14134, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14144, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14146, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14240, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14242, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14244, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14246, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14168, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14170, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14196, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14248, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14250, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14252, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14188, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14190, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14014, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14254, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14032, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14054, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14074, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14262, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14078, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14080, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14082, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14084, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14086, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14092, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14094, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14096, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14098, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14100, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14102, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14104, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14106, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14112, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14114, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14122, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14124, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14126, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14136, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14138, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14140, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14264, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14148, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14150, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14152, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14154, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14160, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14162, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14164, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14172, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14174, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14268, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14180, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14182, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14184, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14256, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14258, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14038, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14260, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14272, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14072, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14128, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14130, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14142, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14166, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14266, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14186, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14270, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 22472, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 22475, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 22478, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14335, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14337, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14339, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14341, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14276, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14274, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14278, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 14088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14068, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14329, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14333, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14088, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14090, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14343, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22543, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22612, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22636, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22678, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22681, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22741, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22750, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22753, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22774, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22777, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22780, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 22588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22813, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 22816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22819, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31021, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31025, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 22853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 63816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 63835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 31076, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6513, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 3063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 3064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6528, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_VERTICAL, 6530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 6531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_COMPAT, 6516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 6504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 2762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_SMALL, 6507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 6532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SMALL, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_SMALL, 6535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 2801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 6539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_SMALL, 6540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SMALL, 6541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14736, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14738, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14748, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14750, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 14760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6578, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 5802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 5802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_INITIAL, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_MEDIAL, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_ISOLATED, 14803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FINAL, 14803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 2802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 2803, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_WIDE, 2799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 6504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PD, 0, UTF8PROC_BIDI_CLASS_ES, UTF8PROC_DECOMP_TYPE_WIDE, 6535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 2762, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 6615, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_WIDE, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_CS, UTF8PROC_DECOMP_TYPE_WIDE, 6507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 2801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1491, 6616, UINT16_MAX, 6616, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1493, 6617, UINT16_MAX, 6617, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2812, 6618, UINT16_MAX, 6618, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1494, 6619, UINT16_MAX, 6619, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1495, 6620, UINT16_MAX, 6620, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2837, 6621, UINT16_MAX, 6621, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1497, 6622, UINT16_MAX, 6622, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1498, 6623, UINT16_MAX, 6623, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1499, 6624, UINT16_MAX, 6624, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1500, 6625, UINT16_MAX, 6625, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1501, 6626, UINT16_MAX, 6626, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1502, 6627, UINT16_MAX, 6627, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1503, 6628, UINT16_MAX, 6628, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1504, 6629, UINT16_MAX, 6629, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1505, 6630, UINT16_MAX, 6630, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1507, 6631, UINT16_MAX, 6631, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2826, 6632, UINT16_MAX, 6632, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1508, 6633, UINT16_MAX, 6633, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 3305, 6634, UINT16_MAX, 6634, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1509, 6635, UINT16_MAX, 6635, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1510, 6636, UINT16_MAX, 6636, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2908, 6637, UINT16_MAX, 6637, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1511, 6638, UINT16_MAX, 6638, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2925, 6639, UINT16_MAX, 6639, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 3312, 6640, UINT16_MAX, 6640, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2834, 6641, UINT16_MAX, 6641, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PC, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 2722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 0, UINT16_MAX, 9167, UINT16_MAX, 9167, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 1, UINT16_MAX, 9168, UINT16_MAX, 9168, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 2, UINT16_MAX, 9169, UINT16_MAX, 9169, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 3, UINT16_MAX, 9170, UINT16_MAX, 9170, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 4, UINT16_MAX, 9171, UINT16_MAX, 9171, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 5, UINT16_MAX, 9172, UINT16_MAX, 9172, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 6, UINT16_MAX, 9173, UINT16_MAX, 9173, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 7, UINT16_MAX, 9174, UINT16_MAX, 9174, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 8, UINT16_MAX, 9175, UINT16_MAX, 9175, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 9, UINT16_MAX, 9176, UINT16_MAX, 9176, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 10, UINT16_MAX, 9177, UINT16_MAX, 9177, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 11, UINT16_MAX, 9178, UINT16_MAX, 9178, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 12, UINT16_MAX, 9179, UINT16_MAX, 9179, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 13, UINT16_MAX, 9180, UINT16_MAX, 9180, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 14, UINT16_MAX, 9181, UINT16_MAX, 9181, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 15, UINT16_MAX, 9182, UINT16_MAX, 9182, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 16, UINT16_MAX, 9183, UINT16_MAX, 9183, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 17, UINT16_MAX, 9184, UINT16_MAX, 9184, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 18, UINT16_MAX, 9185, UINT16_MAX, 9185, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 19, UINT16_MAX, 9186, UINT16_MAX, 9186, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 20, UINT16_MAX, 9187, UINT16_MAX, 9187, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 21, UINT16_MAX, 9188, UINT16_MAX, 9188, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 22, UINT16_MAX, 9189, UINT16_MAX, 9189, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 23, UINT16_MAX, 9190, UINT16_MAX, 9190, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 24, UINT16_MAX, 9191, UINT16_MAX, 9191, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_WIDE, 25, UINT16_MAX, 9192, UINT16_MAX, 9192, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6643, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PS, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PE, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_PO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4331, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6655, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4285, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4286, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4287, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4288, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4289, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4290, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4291, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4292, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4293, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4294, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4296, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4297, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4298, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4299, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4300, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4301, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4302, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4303, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4304, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4306, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4310, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4311, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4313, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4314, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4315, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4316, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4317, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4318, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4319, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4320, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4321, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4322, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4323, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4324, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4325, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4326, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4327, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 4328, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, true, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6667, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6670, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6671, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6673, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6674, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6676, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6677, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6678, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6680, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6681, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6682, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6683, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6685, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6686, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6688, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6689, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6690, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6691, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6692, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6694, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6695, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6697, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6698, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6704, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6707, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_NARROW, 6712, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6713, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_WIDE, 6717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SC, 0, UTF8PROC_BIDI_CLASS_ET, UTF8PROC_DECOMP_TYPE_WIDE, 6719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6724, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_NARROW, 6726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_NL, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6727, UINT16_MAX, 6727, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6729, UINT16_MAX, 6729, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6731, UINT16_MAX, 6731, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6733, UINT16_MAX, 6733, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6735, UINT16_MAX, 6735, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6737, UINT16_MAX, 6737, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6739, UINT16_MAX, 6739, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6741, UINT16_MAX, 6741, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6743, UINT16_MAX, 6743, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6745, UINT16_MAX, 6745, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6747, UINT16_MAX, 6747, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6749, UINT16_MAX, 6749, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6751, UINT16_MAX, 6751, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6753, UINT16_MAX, 6753, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6755, UINT16_MAX, 6755, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6757, UINT16_MAX, 6757, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6759, UINT16_MAX, 6759, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6761, UINT16_MAX, 6761, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6763, UINT16_MAX, 6763, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6765, UINT16_MAX, 6765, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6767, UINT16_MAX, 6767, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6769, UINT16_MAX, 6769, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6771, UINT16_MAX, 6771, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6773, UINT16_MAX, 6773, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6775, UINT16_MAX, 6775, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6777, UINT16_MAX, 6777, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6779, UINT16_MAX, 6779, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6781, UINT16_MAX, 6781, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6783, UINT16_MAX, 6783, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6785, UINT16_MAX, 6785, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6787, UINT16_MAX, 6787, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6789, UINT16_MAX, 6789, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6791, UINT16_MAX, 6791, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6793, UINT16_MAX, 6793, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6795, UINT16_MAX, 6795, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6797, UINT16_MAX, 6797, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6799, UINT16_MAX, 6799, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6801, UINT16_MAX, 6801, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6803, UINT16_MAX, 6803, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6805, UINT16_MAX, 6805, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9193, UINT16_MAX, 9193, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9195, UINT16_MAX, 9195, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9197, UINT16_MAX, 9197, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9199, UINT16_MAX, 9199, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9201, UINT16_MAX, 9201, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9203, UINT16_MAX, 9203, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9205, UINT16_MAX, 9205, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9207, UINT16_MAX, 9207, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9209, UINT16_MAX, 9209, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9211, UINT16_MAX, 9211, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9213, UINT16_MAX, 9213, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9215, UINT16_MAX, 9215, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9217, UINT16_MAX, 9217, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9219, UINT16_MAX, 9219, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9221, UINT16_MAX, 9221, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9223, UINT16_MAX, 9223, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9225, UINT16_MAX, 9225, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9227, UINT16_MAX, 9227, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9229, UINT16_MAX, 9229, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9231, UINT16_MAX, 9231, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9233, UINT16_MAX, 9233, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9235, UINT16_MAX, 9235, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9237, UINT16_MAX, 9237, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9239, UINT16_MAX, 9239, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9241, UINT16_MAX, 9241, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9243, UINT16_MAX, 9243, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9245, UINT16_MAX, 9245, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9247, UINT16_MAX, 9247, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9249, UINT16_MAX, 9249, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9251, UINT16_MAX, 9251, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9253, UINT16_MAX, 9253, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9255, UINT16_MAX, 9255, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9257, UINT16_MAX, 9257, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9259, UINT16_MAX, 9259, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9261, UINT16_MAX, 9261, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9263, UINT16_MAX, 9263, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9265, UINT16_MAX, 9265, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9267, UINT16_MAX, 9267, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9269, UINT16_MAX, 9269, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9271, UINT16_MAX, 9271, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6807, UINT16_MAX, 6807, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6809, UINT16_MAX, 6809, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6811, UINT16_MAX, 6811, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6813, UINT16_MAX, 6813, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6815, UINT16_MAX, 6815, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6817, UINT16_MAX, 6817, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6819, UINT16_MAX, 6819, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6821, UINT16_MAX, 6821, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6823, UINT16_MAX, 6823, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6825, UINT16_MAX, 6825, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6827, UINT16_MAX, 6827, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6829, UINT16_MAX, 6829, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6831, UINT16_MAX, 6831, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6833, UINT16_MAX, 6833, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6835, UINT16_MAX, 6835, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6837, UINT16_MAX, 6837, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6839, UINT16_MAX, 6839, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6841, UINT16_MAX, 6841, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6843, UINT16_MAX, 6843, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6845, UINT16_MAX, 6845, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6847, UINT16_MAX, 6847, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6849, UINT16_MAX, 6849, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6851, UINT16_MAX, 6851, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6853, UINT16_MAX, 6853, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6855, UINT16_MAX, 6855, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6857, UINT16_MAX, 6857, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6859, UINT16_MAX, 6859, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6861, UINT16_MAX, 6861, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6863, UINT16_MAX, 6863, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6865, UINT16_MAX, 6865, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6867, UINT16_MAX, 6867, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6869, UINT16_MAX, 6869, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6871, UINT16_MAX, 6871, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6873, UINT16_MAX, 6873, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6875, UINT16_MAX, 6875, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 6877, UINT16_MAX, 6877, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9273, UINT16_MAX, 9273, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9275, UINT16_MAX, 9275, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9277, UINT16_MAX, 9277, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9279, UINT16_MAX, 9279, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9281, UINT16_MAX, 9281, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9283, UINT16_MAX, 9283, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9285, UINT16_MAX, 9285, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9287, UINT16_MAX, 9287, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9289, UINT16_MAX, 9289, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9291, UINT16_MAX, 9291, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9293, UINT16_MAX, 9293, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9295, UINT16_MAX, 9295, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9297, UINT16_MAX, 9297, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9299, UINT16_MAX, 9299, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9301, UINT16_MAX, 9301, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9303, UINT16_MAX, 9303, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9305, UINT16_MAX, 9305, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9307, UINT16_MAX, 9307, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9309, UINT16_MAX, 9309, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9311, UINT16_MAX, 9311, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9313, UINT16_MAX, 9313, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9315, UINT16_MAX, 9315, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9317, UINT16_MAX, 9317, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9319, UINT16_MAX, 9319, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9321, UINT16_MAX, 9321, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9323, UINT16_MAX, 9323, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9325, UINT16_MAX, 9325, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9327, UINT16_MAX, 9327, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9329, UINT16_MAX, 9329, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9331, UINT16_MAX, 9331, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9333, UINT16_MAX, 9333, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9335, UINT16_MAX, 9335, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9337, UINT16_MAX, 9337, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9339, UINT16_MAX, 9339, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9341, UINT16_MAX, 9341, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9343, UINT16_MAX, 9343, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6879, UINT16_MAX, 6879, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6881, UINT16_MAX, 6881, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6883, UINT16_MAX, 6883, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6885, UINT16_MAX, 6885, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6887, UINT16_MAX, 6887, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6889, UINT16_MAX, 6889, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6891, UINT16_MAX, 6891, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6893, UINT16_MAX, 6893, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6895, UINT16_MAX, 6895, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6897, UINT16_MAX, 6897, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6899, UINT16_MAX, 6899, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6901, UINT16_MAX, 6901, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6903, UINT16_MAX, 6903, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6905, UINT16_MAX, 6905, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6907, UINT16_MAX, 6907, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6909, UINT16_MAX, 6909, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6911, UINT16_MAX, 6911, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6913, UINT16_MAX, 6913, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6915, UINT16_MAX, 6915, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6917, UINT16_MAX, 6917, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6919, UINT16_MAX, 6919, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6921, UINT16_MAX, 6921, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6923, UINT16_MAX, 6923, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6925, UINT16_MAX, 6925, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6927, UINT16_MAX, 6927, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6929, UINT16_MAX, 6929, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6931, UINT16_MAX, 6931, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6933, UINT16_MAX, 6933, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6935, UINT16_MAX, 6935, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6937, UINT16_MAX, 6937, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6939, UINT16_MAX, 6939, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6941, UINT16_MAX, 6941, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6943, UINT16_MAX, 6943, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6945, UINT16_MAX, 6945, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6947, UINT16_MAX, 6947, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6949, UINT16_MAX, 6949, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6951, UINT16_MAX, 6951, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6953, UINT16_MAX, 6953, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6955, UINT16_MAX, 6955, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6957, UINT16_MAX, 6957, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6959, UINT16_MAX, 6959, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6961, UINT16_MAX, 6961, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6963, UINT16_MAX, 6963, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6965, UINT16_MAX, 6965, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6967, UINT16_MAX, 6967, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6969, UINT16_MAX, 6969, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6971, UINT16_MAX, 6971, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6973, UINT16_MAX, 6973, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6975, UINT16_MAX, 6975, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6977, UINT16_MAX, 6977, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 6979, UINT16_MAX, 6979, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9345, UINT16_MAX, 9345, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9347, UINT16_MAX, 9347, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9349, UINT16_MAX, 9349, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9351, UINT16_MAX, 9351, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9353, UINT16_MAX, 9353, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9355, UINT16_MAX, 9355, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9357, UINT16_MAX, 9357, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9359, UINT16_MAX, 9359, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9361, UINT16_MAX, 9361, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9363, UINT16_MAX, 9363, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9365, UINT16_MAX, 9365, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9367, UINT16_MAX, 9367, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9369, UINT16_MAX, 9369, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9371, UINT16_MAX, 9371, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9373, UINT16_MAX, 9373, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9375, UINT16_MAX, 9375, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9377, UINT16_MAX, 9377, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9379, UINT16_MAX, 9379, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9381, UINT16_MAX, 9381, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9383, UINT16_MAX, 9383, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9385, UINT16_MAX, 9385, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9387, UINT16_MAX, 9387, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9389, UINT16_MAX, 9389, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9391, UINT16_MAX, 9391, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9393, UINT16_MAX, 9393, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9395, UINT16_MAX, 9395, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9397, UINT16_MAX, 9397, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9399, UINT16_MAX, 9399, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9401, UINT16_MAX, 9401, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9403, UINT16_MAX, 9403, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9405, UINT16_MAX, 9405, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9407, UINT16_MAX, 9407, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9409, UINT16_MAX, 9409, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9411, UINT16_MAX, 9411, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9413, UINT16_MAX, 9413, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9415, UINT16_MAX, 9415, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9417, UINT16_MAX, 9417, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9419, UINT16_MAX, 9419, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9421, UINT16_MAX, 9421, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9423, UINT16_MAX, 9423, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9425, UINT16_MAX, 9425, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9427, UINT16_MAX, 9427, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9429, UINT16_MAX, 9429, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9431, UINT16_MAX, 9431, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9433, UINT16_MAX, 9433, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9435, UINT16_MAX, 9435, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9437, UINT16_MAX, 9437, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9439, UINT16_MAX, 9439, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9441, UINT16_MAX, 9441, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9443, UINT16_MAX, 9443, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9445, UINT16_MAX, 9445, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_AN, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_AL, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5328, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15173, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5332, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15177, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5336, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15181, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 7, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49206, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_PREPEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49208, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 15185, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, 15189, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5340, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5344, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49210, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5348, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15193, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15197, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49212, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49216, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5354, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_NSM, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49214, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15201, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15205, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49218, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49220, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5362, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5366, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 0, UTF8PROC_BIDI_CLASS_L, 0, 15217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7029, UINT16_MAX, 7029, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7031, UINT16_MAX, 7031, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7033, UINT16_MAX, 7033, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7035, UINT16_MAX, 7035, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7037, UINT16_MAX, 7037, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7039, UINT16_MAX, 7039, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7041, UINT16_MAX, 7041, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7043, UINT16_MAX, 7043, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7045, UINT16_MAX, 7045, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7047, UINT16_MAX, 7047, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7049, UINT16_MAX, 7049, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7051, UINT16_MAX, 7051, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7053, UINT16_MAX, 7053, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7055, UINT16_MAX, 7055, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7057, UINT16_MAX, 7057, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7059, UINT16_MAX, 7059, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7061, UINT16_MAX, 7061, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7063, UINT16_MAX, 7063, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7065, UINT16_MAX, 7065, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7067, UINT16_MAX, 7067, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7069, UINT16_MAX, 7069, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7071, UINT16_MAX, 7071, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7073, UINT16_MAX, 7073, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7075, UINT16_MAX, 7075, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7077, UINT16_MAX, 7077, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7079, UINT16_MAX, 7079, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7081, UINT16_MAX, 7081, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7083, UINT16_MAX, 7083, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7085, UINT16_MAX, 7085, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7087, UINT16_MAX, 7087, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7089, UINT16_MAX, 7089, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7091, UINT16_MAX, 7091, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9447, UINT16_MAX, 9447, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9449, UINT16_MAX, 9449, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9451, UINT16_MAX, 9451, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9453, UINT16_MAX, 9453, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9455, UINT16_MAX, 9455, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9457, UINT16_MAX, 9457, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9459, UINT16_MAX, 9459, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9461, UINT16_MAX, 9461, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9463, UINT16_MAX, 9463, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9465, UINT16_MAX, 9465, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9467, UINT16_MAX, 9467, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9469, UINT16_MAX, 9469, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9471, UINT16_MAX, 9471, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9473, UINT16_MAX, 9473, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9475, UINT16_MAX, 9475, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9477, UINT16_MAX, 9477, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9479, UINT16_MAX, 9479, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9481, UINT16_MAX, 9481, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9483, UINT16_MAX, 9483, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9485, UINT16_MAX, 9485, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9487, UINT16_MAX, 9487, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9489, UINT16_MAX, 9489, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9491, UINT16_MAX, 9491, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9493, UINT16_MAX, 9493, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9495, UINT16_MAX, 9495, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9497, UINT16_MAX, 9497, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9499, UINT16_MAX, 9499, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9501, UINT16_MAX, 9501, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9503, UINT16_MAX, 9503, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9505, UINT16_MAX, 9505, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9507, UINT16_MAX, 9507, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9509, UINT16_MAX, 9509, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MN, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MN, 9, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_CF, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, true, 0, 0, UTF8PROC_BOUNDCLASS_CONTROL},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7093, UINT16_MAX, 7093, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7095, UINT16_MAX, 7095, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7097, UINT16_MAX, 7097, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7099, UINT16_MAX, 7099, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7101, UINT16_MAX, 7101, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7103, UINT16_MAX, 7103, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7105, UINT16_MAX, 7105, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7107, UINT16_MAX, 7107, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7109, UINT16_MAX, 7109, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7111, UINT16_MAX, 7111, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7113, UINT16_MAX, 7113, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7115, UINT16_MAX, 7115, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7117, UINT16_MAX, 7117, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7119, UINT16_MAX, 7119, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7121, UINT16_MAX, 7121, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7123, UINT16_MAX, 7123, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7125, UINT16_MAX, 7125, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7127, UINT16_MAX, 7127, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7129, UINT16_MAX, 7129, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7131, UINT16_MAX, 7131, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7133, UINT16_MAX, 7133, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7135, UINT16_MAX, 7135, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7137, UINT16_MAX, 7137, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7139, UINT16_MAX, 7139, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7141, UINT16_MAX, 7141, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7143, UINT16_MAX, 7143, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7145, UINT16_MAX, 7145, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7147, UINT16_MAX, 7147, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7149, UINT16_MAX, 7149, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7151, UINT16_MAX, 7151, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7153, UINT16_MAX, 7153, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, 7155, UINT16_MAX, 7155, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9511, UINT16_MAX, 9511, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9513, UINT16_MAX, 9513, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9515, UINT16_MAX, 9515, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9517, UINT16_MAX, 9517, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9519, UINT16_MAX, 9519, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9521, UINT16_MAX, 9521, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9523, UINT16_MAX, 9523, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9525, UINT16_MAX, 9525, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9527, UINT16_MAX, 9527, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9529, UINT16_MAX, 9529, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9531, UINT16_MAX, 9531, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9533, UINT16_MAX, 9533, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9535, UINT16_MAX, 9535, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9537, UINT16_MAX, 9537, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9539, UINT16_MAX, 9539, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9541, UINT16_MAX, 9541, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9543, UINT16_MAX, 9543, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9545, UINT16_MAX, 9545, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9547, UINT16_MAX, 9547, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9549, UINT16_MAX, 9549, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9551, UINT16_MAX, 9551, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9553, UINT16_MAX, 9553, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9555, UINT16_MAX, 9555, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9557, UINT16_MAX, 9557, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9559, UINT16_MAX, 9559, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9561, UINT16_MAX, 9561, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9563, UINT16_MAX, 9563, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9565, UINT16_MAX, 9565, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9567, UINT16_MAX, 9567, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9569, UINT16_MAX, 9569, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9571, UINT16_MAX, 9571, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, 9573, UINT16_MAX, 9573, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5370, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5374, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15349, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15353, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5378, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15357, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15361, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15365, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15369, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15373, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49222, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 226, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_SPACINGMARK},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49224, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49226, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49228, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49230, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_MC, 216, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 49232, false, false, false, false, 0, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5390, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5394, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15377, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5398, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15381, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, 5404, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15385, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15389, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15393, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, 15397, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, true, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 3312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 1, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 5, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 10, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 12, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 13, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 15, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 16, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 17, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 18, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 19, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 20, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 21, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 22, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 23, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 24, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 25, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7210, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7211, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7212, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7213, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7214, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7215, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7216, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7217, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7218, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7219, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7220, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7221, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7222, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7223, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7224, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7225, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7226, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7227, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7228, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7229, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 2835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7230, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 846, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 848, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 850, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 852, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 35, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 857, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SM, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_FONT, 7231, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, true, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7232, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7233, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7234, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7235, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7236, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7237, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 7238, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_FONT, 904, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 38, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 31, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 32, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_ND, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_FONT, 2798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7239, UINT16_MAX, 7239, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7241, UINT16_MAX, 7241, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7243, UINT16_MAX, 7243, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7245, UINT16_MAX, 7245, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7247, UINT16_MAX, 7247, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7249, UINT16_MAX, 7249, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7251, UINT16_MAX, 7251, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7253, UINT16_MAX, 7253, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7255, UINT16_MAX, 7255, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7257, UINT16_MAX, 7257, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7259, UINT16_MAX, 7259, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7261, UINT16_MAX, 7261, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7263, UINT16_MAX, 7263, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7265, UINT16_MAX, 7265, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7267, UINT16_MAX, 7267, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7269, UINT16_MAX, 7269, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7271, UINT16_MAX, 7271, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7273, UINT16_MAX, 7273, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7275, UINT16_MAX, 7275, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7277, UINT16_MAX, 7277, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7279, UINT16_MAX, 7279, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7281, UINT16_MAX, 7281, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7283, UINT16_MAX, 7283, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7285, UINT16_MAX, 7285, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7287, UINT16_MAX, 7287, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7289, UINT16_MAX, 7289, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7291, UINT16_MAX, 7291, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7293, UINT16_MAX, 7293, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7295, UINT16_MAX, 7295, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7297, UINT16_MAX, 7297, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7299, UINT16_MAX, 7299, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7301, UINT16_MAX, 7301, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7303, UINT16_MAX, 7303, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LU, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, 7305, UINT16_MAX, 7305, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9575, UINT16_MAX, 9575, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9577, UINT16_MAX, 9577, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9579, UINT16_MAX, 9579, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9581, UINT16_MAX, 9581, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9583, UINT16_MAX, 9583, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9585, UINT16_MAX, 9585, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9587, UINT16_MAX, 9587, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9589, UINT16_MAX, 9589, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9591, UINT16_MAX, 9591, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9593, UINT16_MAX, 9593, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9595, UINT16_MAX, 9595, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9597, UINT16_MAX, 9597, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9599, UINT16_MAX, 9599, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9601, UINT16_MAX, 9601, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9603, UINT16_MAX, 9603, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9605, UINT16_MAX, 9605, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9607, UINT16_MAX, 9607, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9609, UINT16_MAX, 9609, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9611, UINT16_MAX, 9611, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9613, UINT16_MAX, 9613, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9615, UINT16_MAX, 9615, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9617, UINT16_MAX, 9617, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9619, UINT16_MAX, 9619, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9621, UINT16_MAX, 9621, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9623, UINT16_MAX, 9623, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9625, UINT16_MAX, 9625, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9627, UINT16_MAX, 9627, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9629, UINT16_MAX, 9629, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9631, UINT16_MAX, 9631, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9633, UINT16_MAX, 9633, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9635, UINT16_MAX, 9635, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9637, UINT16_MAX, 9637, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9639, UINT16_MAX, 9639, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LL, 0, UTF8PROC_BIDI_CLASS_R, 0, UINT16_MAX, UINT16_MAX, 9641, UINT16_MAX, 9641, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6603, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6585, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 7307, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 5786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 7308, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 7309, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_AL, UTF8PROC_DECOMP_TYPE_FONT, 6602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15518, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_NO, 0, UTF8PROC_BIDI_CLASS_EN, UTF8PROC_DECOMP_TYPE_COMPAT, 15522, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23722, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23728, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23734, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23743, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23749, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23755, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23758, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23761, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23764, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23776, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23788, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 2812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 1508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 15605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 15607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1491, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1493, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1494, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1495, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1504, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3305, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 1511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3312, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 2834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 13070, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 23807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 15620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 15622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_ON, UTF8PROC_DECOMP_TYPE_SUPER, 15624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 1, 0, UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15628, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 15630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4295, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7440, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7441, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7442, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7444, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3886, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7445, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7446, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7447, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 5425, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7448, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7449, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7451, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7452, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7453, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7454, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7455, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7456, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7457, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7458, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7460, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4208, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4209, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7461, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3598, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7462, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7463, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7464, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7465, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7466, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 4191, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 3516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7467, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7469, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_SQUARE, 7470, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23864, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_COMPAT, 23879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 7498, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SO, 0, UTF8PROC_BIDI_CLASS_L, UTF8PROC_DECOMP_TYPE_CIRCLE, 7499, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC},
-  {UTF8PROC_CATEGORY_SK, 0, UTF8PROC_BIDI_CLASS_ON, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_EXTEND},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7500, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7501, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7502, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7503, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7505, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7506, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7507, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7508, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7509, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7510, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7511, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7512, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7514, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7515, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7516, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7517, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7519, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7520, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7450, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7521, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7523, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7524, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7525, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7526, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7527, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3459, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7529, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7530, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7531, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7532, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7468, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7533, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7534, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7535, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7536, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7537, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7538, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7539, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7540, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7541, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7542, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7544, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7545, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7546, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7547, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7549, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7550, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7551, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7552, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7553, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7554, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7555, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7556, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7557, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7558, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7559, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7560, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7561, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7562, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7563, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7564, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7565, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7566, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7567, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7568, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7569, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7570, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7571, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7572, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7573, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7574, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7575, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7576, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7577, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7579, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7580, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7581, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7443, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7582, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7583, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7584, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7586, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7588, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7589, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7590, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7591, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7592, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7593, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7595, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7596, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7597, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7599, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7600, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7601, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7602, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7604, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7605, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7606, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3485, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7607, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7608, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7609, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7610, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7611, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7613, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7614, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7616, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7617, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7618, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7619, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7620, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7621, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7622, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7623, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7624, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7625, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7626, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7627, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7629, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7630, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7631, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7632, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7633, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3497, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7635, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7637, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7638, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7639, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7640, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7644, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7645, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7647, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7648, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7649, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7650, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7652, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7653, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7654, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7656, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7657, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7658, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7659, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7660, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7661, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7662, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7663, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7664, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7665, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7666, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7667, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7668, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7669, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7670, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7672, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7673, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7674, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7675, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7676, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7677, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7679, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7680, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7681, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7682, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7683, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7684, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7685, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7686, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7687, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7688, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7689, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7691, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7692, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7693, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7694, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7695, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7696, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7697, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7698, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7699, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7700, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7701, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7702, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7703, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7704, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7705, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7706, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7708, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7709, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7710, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7711, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7712, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7714, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7715, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7716, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7717, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7718, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7719, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7720, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7721, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7723, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7724, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7725, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7726, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7728, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7729, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7730, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7731, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7732, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7733, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7735, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7737, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7739, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7740, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7742, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7743, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7744, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7745, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7746, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7747, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7748, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7749, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7750, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7752, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7753, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7754, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7755, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7756, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7757, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7759, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7760, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7761, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7763, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7765, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7766, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7767, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7768, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7769, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7770, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7771, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7772, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7773, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7775, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7776, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7778, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7779, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7781, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7782, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7783, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7785, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7786, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7787, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7789, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7791, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7792, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7793, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7794, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7795, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7796, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7797, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7798, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7799, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7800, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7801, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7802, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7804, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7805, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7807, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7809, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7810, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7812, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7814, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7816, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7817, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7818, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7820, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7822, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7824, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7826, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7827, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7828, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7829, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7830, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7831, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7833, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7834, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7835, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7837, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7839, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7841, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7842, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7843, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7844, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7845, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7847, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7849, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7850, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7851, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7853, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7854, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7855, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7856, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7858, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7859, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7860, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7861, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7862, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7863, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7865, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7866, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7867, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7868, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7869, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7870, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7871, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7873, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7875, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7876, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7878, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7879, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7881, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7882, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7883, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7885, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7887, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7888, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7890, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7891, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7893, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7894, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7895, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7896, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7897, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7898, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7899, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7901, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7903, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7905, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7907, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7908, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7909, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7910, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7911, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7912, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7913, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7914, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7915, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7916, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7917, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7918, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7920, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7921, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7922, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7923, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7924, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7925, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7926, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7927, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7928, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7929, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7930, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7932, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7934, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7936, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7937, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7938, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7939, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7940, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7942, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7943, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7945, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7946, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7947, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7949, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7951, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7952, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7953, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7954, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7955, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7956, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7957, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7958, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7959, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7960, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7961, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7962, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7963, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7964, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7965, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7966, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3587, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7967, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7969, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7970, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7971, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7972, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7973, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7974, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7976, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7978, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7979, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7980, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3594, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7981, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7983, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7984, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7985, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7986, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7987, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7989, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7991, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7992, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7993, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7994, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7996, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7997, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 7999, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8001, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8002, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8003, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8004, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8006, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8007, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8008, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8009, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8010, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8011, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8012, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8013, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8015, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8016, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8017, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8018, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8020, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8021, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8022, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8023, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8024, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8026, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8028, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8029, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8030, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8031, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8033, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8034, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8036, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8037, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8039, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8040, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8041, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8042, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8043, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8044, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8045, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8046, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8048, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8049, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8050, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8051, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8052, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8053, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8055, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8056, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8058, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8060, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3642, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8062, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3646, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8063, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8064, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8065, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8066, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 3651, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-  {UTF8PROC_CATEGORY_LO, 0, UTF8PROC_BIDI_CLASS_L, 0, 8067, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, false, false, false, false, 2, 0, UTF8PROC_BOUNDCLASS_OTHER},
-};
-
-static const utf8proc_uint16_t utf8proc_combinations[] = {
-  0, 46, 192, 193, 194, 195, 196, 197, 0, 
-  256, 258, 260, 550, 461, 0, 0, 512, 
-  514, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7680, 7840, 0, 0, 0, 0, 0, 7842, 
-1, 11, 
-  262, 264, 0, 0, 0, 199, 0, 0, 
-  0, 266, 268, 
-0, 46, 200, 201, 202, 7868, 203, 
-  0, 552, 274, 276, 280, 278, 282, 0, 
-  0, 516, 518, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7864, 0, 7704, 7706, 0, 
-  0, 7866, 
-0, 46, 204, 205, 206, 296, 207, 0, 
-  0, 298, 300, 302, 304, 463, 0, 0, 
-  520, 522, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7882, 0, 0, 7724, 0, 0, 
-  7880, 
-0, 42, 504, 323, 0, 209, 0, 0, 325, 
-  0, 0, 0, 7748, 327, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7750, 7752, 7754, 
-0, 46, 210, 211, 212, 213, 
-  214, 0, 0, 332, 334, 490, 558, 465, 
-  336, 416, 524, 526, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7884, 0, 0, 0, 
-  0, 0, 7886, 
-0, 46, 217, 218, 219, 360, 220, 
-  366, 0, 362, 364, 370, 0, 467, 368, 
-  431, 532, 534, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7908, 0, 7798, 7796, 0, 
-  7794, 7910, 
-0, 46, 7922, 221, 374, 7928, 376, 0, 
-  0, 562, 0, 0, 7822, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7924, 0, 0, 0, 0, 0, 
-  7926, 
-0, 46, 224, 225, 226, 227, 228, 229, 0, 
-  257, 259, 261, 551, 462, 0, 0, 513, 
-  515, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7681, 7841, 0, 0, 0, 0, 0, 7843, 
-1, 11, 
-  263, 265, 0, 0, 0, 231, 0, 0, 
-  0, 267, 269, 
-0, 46, 232, 233, 234, 7869, 235, 
-  0, 553, 275, 277, 281, 279, 283, 0, 
-  0, 517, 519, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7865, 0, 7705, 7707, 0, 
-  0, 7867, 
-0, 46, 236, 237, 238, 297, 239, 0, 
-  0, 299, 301, 303, 0, 464, 0, 0, 
-  521, 523, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7883, 0, 0, 7725, 0, 0, 
-  7881, 
-0, 42, 505, 324, 0, 241, 0, 0, 326, 
-  0, 0, 0, 7749, 328, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7751, 7753, 7755, 
-0, 46, 242, 243, 244, 245, 
-  246, 0, 0, 333, 335, 491, 559, 466, 
-  337, 417, 525, 527, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7885, 0, 0, 0, 
-  0, 0, 7887, 
-0, 46, 249, 250, 251, 361, 252, 
-  367, 0, 363, 365, 371, 0, 468, 369, 
-  432, 533, 535, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7909, 0, 7799, 7797, 0, 
-  7795, 7911, 
-0, 46, 7923, 253, 375, 7929, 255, 7833, 
-  0, 563, 0, 0, 7823, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7925, 0, 0, 0, 0, 0, 
-  7927, 
-6, 42, 7696, 0, 0, 0, 7690, 270, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7692, 7694, 7698, 
-6, 42, 7697, 0, 
-  0, 0, 7691, 271, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7693, 7695, 7699, 
-1, 11, 500, 284, 0, 0, 0, 
-  290, 7712, 286, 0, 288, 486, 
-1, 11, 501, 285, 
-  0, 0, 0, 291, 7713, 287, 0, 289, 
-  487, 
-2, 44, 292, 0, 7718, 0, 7720, 0, 0, 
-  0, 7714, 542, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7716, 
-  0, 0, 0, 7722, 
-2, 44, 293, 0, 7719, 0, 
-  7721, 0, 0, 0, 7715, 543, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7717, 7830, 0, 0, 7723, 
-2, 2, 308, 
-2, 11, 
-  309, 0, 0, 0, 0, 0, 0, 0, 
-  0, 496, 
-1, 41, 7728, 0, 0, 0, 0, 310, 
-  0, 0, 0, 0, 488, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7730, 7732, 
-1, 41, 7729, 0, 0, 0, 0, 
-  311, 0, 0, 0, 0, 489, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7731, 7733, 
-1, 42, 313, 0, 0, 0, 
-  0, 315, 0, 0, 0, 0, 317, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7734, 7738, 7740, 
-1, 42, 314, 0, 
-  0, 0, 0, 316, 0, 0, 0, 0, 
-  318, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7735, 7739, 7741, 
-1, 41, 
-  340, 0, 0, 0, 0, 342, 0, 0, 
-  0, 7768, 344, 0, 0, 528, 530, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7770, 
-  7774, 
-1, 41, 341, 0, 0, 0, 0, 343, 0, 
-  0, 0, 7769, 345, 0, 0, 529, 531, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7771, 7775, 
-1, 40, 346, 348, 0, 0, 0, 350, 
-  0, 0, 0, 7776, 352, 0, 0, 0, 
-  0, 536, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7778, 
-1, 40, 347, 349, 0, 0, 0, 351, 
-  0, 0, 0, 7777, 353, 0, 0, 0, 
-  0, 537, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7779, 
-6, 42, 354, 0, 0, 0, 7786, 356, 
-  0, 0, 0, 0, 538, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7788, 7790, 7792, 
-4, 42, 7831, 
-  0, 355, 0, 0, 0, 7787, 357, 0, 
-  0, 0, 0, 539, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7789, 7791, 7793, 
-0, 40, 7808, 7810, 
-  372, 0, 7812, 0, 0, 0, 0, 0, 
-  7814, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7816, 
-0, 40, 7809, 
-  7811, 373, 0, 7813, 7832, 0, 0, 0, 
-  0, 7815, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7817, 
-1, 41, 
-  377, 7824, 0, 0, 0, 0, 0, 0, 
-  0, 379, 381, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7826, 
-  7828, 
-1, 41, 378, 7825, 0, 0, 0, 0, 0, 
-  0, 0, 380, 382, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7827, 7829, 
-0, 11, 475, 471, 0, 0, 0, 0, 
-  0, 469, 0, 0, 0, 473, 
-0, 11, 476, 472, 
-  0, 0, 0, 0, 0, 470, 0, 0, 
-  0, 474, 
-7, 7, 478, 
-7, 7, 479, 
-7, 7, 480, 
-7, 7, 481, 
-1, 7, 508, 0, 
-  0, 0, 0, 0, 482, 
-1, 7, 509, 0, 0, 
-  0, 0, 0, 483, 
-7, 7, 492, 
-7, 7, 493, 
-11, 11, 494, 
-11, 11, 495, 
-1, 1, 
-  506, 
-1, 1, 507, 
-1, 1, 510, 
-1, 1, 511, 
-7, 7, 554, 
-7, 7, 555, 
-1, 7, 7756, 0, 
-  0, 7758, 0, 0, 556, 
-1, 7, 7757, 0, 0, 
-  7759, 0, 0, 557, 
-7, 7, 560, 
-7, 7, 561, 
-0, 49, 8173, 901, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 8129, 
-0, 50, 
-  8122, 902, 0, 0, 0, 0, 0, 8121, 
-  8120, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7944, 
-  7945, 0, 8124, 
-0, 48, 8136, 904, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7960, 7961, 
-0, 50, 8138, 905, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7976, 7977, 0, 8140, 
-0, 48, 8154, 
-  906, 0, 0, 938, 0, 0, 8153, 8152, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7992, 7993, 
-0, 48, 
-  8184, 908, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 8008, 
-  8009, 
-0, 48, 8170, 910, 0, 0, 939, 0, 0, 
-  8169, 8168, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8025, 
-0, 50, 8186, 911, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8040, 8041, 0, 8188, 
-0, 49, 8146, 912, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 8151, 
-0, 50, 8048, 
-  940, 0, 0, 0, 0, 0, 8113, 8112, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7936, 7937, 
-  8118, 8115, 
-0, 48, 8050, 941, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7952, 7953, 
-0, 50, 8052, 942, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7968, 7969, 8134, 8131, 
-0, 49, 8054, 943, 
-  0, 0, 970, 0, 0, 8145, 8144, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7984, 7985, 8150, 
-0, 49, 
-  8162, 944, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8167, 
-0, 49, 8058, 973, 0, 0, 971, 0, 
-  0, 8161, 8160, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8016, 8017, 8166, 
-0, 48, 8056, 972, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 8000, 8001, 
-0, 50, 8060, 974, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 8032, 8033, 8182, 8179, 
-1, 4, 
-  979, 0, 0, 980, 
-0, 8, 1024, 0, 0, 0, 
-  1025, 0, 0, 0, 1238, 
-1, 1, 1027, 
-4, 4, 1031, 
-1, 1, 1036, 
-0, 8, 
-  1037, 0, 0, 0, 1252, 0, 0, 1250, 
-  1049, 
-4, 12, 1264, 0, 0, 1262, 1038, 0, 0, 
-  0, 1266, 
-0, 8, 1117, 0, 0, 0, 1253, 0, 
-  0, 1251, 1081, 
-0, 8, 1104, 0, 0, 0, 1105, 
-  0, 0, 0, 1239, 
-1, 1, 1107, 
-4, 4, 1111, 
-1, 1, 1116, 
-4, 12, 1265, 
-  0, 0, 1263, 1118, 0, 0, 0, 1267, 
-14, 14, 
-  1142, 
-14, 14, 1143, 
-4, 8, 1244, 0, 0, 0, 1217, 
-4, 8, 1245, 
-  0, 0, 0, 1218, 
-4, 8, 1234, 0, 0, 0, 
-  1232, 
-4, 8, 1235, 0, 0, 0, 1233, 
-4, 4, 1242, 
-4, 4, 1243, 
-4, 4, 
-  1246, 
-4, 4, 1247, 
-4, 4, 1254, 
-4, 4, 1255, 
-4, 4, 1258, 
-4, 4, 1259, 
-4, 4, 1260, 
-4, 4, 1261, 
-4, 4, 
-  1268, 
-4, 4, 1269, 
-4, 4, 1272, 
-4, 4, 1273, 
-17, 19, 1570, 1571, 1573, 
-18, 18, 1572, 
-18, 18, 
-  1574, 
-18, 18, 1728, 
-18, 18, 1730, 
-18, 18, 1747, 
-20, 20, 2345, 
-20, 20, 2353, 
-20, 20, 2356, 
-21, 22, 2507, 
-  2508, 
-23, 25, 2888, 2891, 2892, 
-26, 26, 2964, 
-26, 27, 3020, 3018, 
-27, 27, 3019, 
-28, 28, 
-  3144, 
-29, 29, 3264, 
-29, 31, 3271, 3272, 3274, 
-29, 29, 3275, 
-32, 33, 3402, 3404, 
-32, 32, 
-  3403, 
-34, 36, 3546, 3548, 3550, 
-34, 34, 3549, 
-37, 37, 4134, 
-38, 38, 6918, 
-38, 38, 6920, 
-38, 38, 
-  6922, 
-38, 38, 6924, 
-38, 38, 6926, 
-38, 38, 6930, 
-38, 38, 6971, 
-38, 38, 6973, 
-38, 38, 6976, 
-38, 38, 6977, 
-38, 38, 
-  6979, 
-10, 41, 7682, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7684, 
-  7686, 
-10, 41, 7683, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7685, 
-  7687, 
-1, 1, 7688, 
-1, 1, 7689, 
-0, 1, 7700, 7702, 
-0, 1, 7701, 7703, 
-8, 8, 7708, 
-8, 8, 
-  7709, 
-10, 10, 7710, 
-10, 10, 7711, 
-1, 1, 7726, 
-1, 1, 7727, 
-7, 7, 7736, 
-7, 7, 7737, 
-1, 40, 7742, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7744, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7746, 
-1, 40, 7743, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7745, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7747, 
-0, 1, 7760, 
-  7762, 
-0, 1, 7761, 7763, 
-1, 10, 7764, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7766, 
-1, 10, 7765, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7767, 
-7, 7, 7772, 
-7, 7, 
-  7773, 
-10, 10, 7780, 
-10, 10, 7781, 
-10, 10, 7782, 
-10, 10, 7783, 
-10, 10, 7784, 
-10, 10, 7785, 
-1, 1, 7800, 
-1, 1, 
-  7801, 
-4, 4, 7802, 
-4, 4, 7803, 
-3, 40, 7804, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7806, 
-3, 40, 7805, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7807, 
-4, 10, 7820, 
-  0, 0, 0, 0, 0, 7818, 
-4, 10, 7821, 0, 
-  0, 0, 0, 0, 7819, 
-10, 10, 7835, 
-0, 46, 7846, 7844, 
-  0, 7850, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7848, 
-0, 46, 7847, 7845, 0, 
-  7851, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7849, 
-2, 8, 7852, 0, 0, 0, 
-  0, 0, 7862, 
-2, 8, 7853, 0, 0, 0, 0, 
-  0, 7863, 
-0, 46, 7856, 7854, 0, 7860, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7858, 
-0, 46, 7857, 7855, 0, 7861, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7859, 
-0, 46, 
-  7872, 7870, 0, 7876, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7874, 
-0, 46, 7873, 
-  7871, 0, 7877, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7875, 
-2, 2, 7878, 
-2, 2, 7879, 
-0, 46, 
-  7890, 7888, 0, 7894, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7892, 
-0, 46, 7891, 
-  7889, 0, 7895, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7893, 
-2, 2, 7896, 
-2, 2, 7897, 
-0, 46, 
-  7900, 7898, 0, 7904, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7906, 0, 0, 0, 0, 0, 7902, 
-0, 46, 7901, 
-  7899, 0, 7905, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7907, 
-  0, 0, 0, 0, 0, 7903, 
-0, 46, 7914, 7912, 
-  0, 7918, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7920, 0, 
-  0, 0, 0, 0, 7916, 
-0, 46, 7915, 7913, 0, 
-  7919, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7921, 0, 0, 
-  0, 0, 0, 7917, 
-0, 50, 7938, 7940, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7942, 8064, 
-0, 50, 7939, 
-  7941, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  7943, 8065, 
-0, 50, 7946, 7948, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7950, 8072, 
-0, 50, 7947, 7949, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 7951, 8073, 
-0, 1, 
-  7954, 7956, 
-0, 1, 7955, 7957, 
-0, 1, 7962, 7964, 
-0, 1, 7963, 7965, 
-0, 50, 
-  7970, 7972, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7974, 8080, 
-0, 50, 7971, 7973, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 7975, 8081, 
-0, 50, 7978, 7980, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7982, 
-  8088, 
-0, 50, 7979, 7981, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 7983, 8089, 
-0, 49, 7986, 7988, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 7990, 
-0, 49, 7987, 7989, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 7991, 
-0, 49, 
-  7994, 7996, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 7998, 
-0, 49, 7995, 7997, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 7999, 
-0, 1, 8002, 8004, 
-0, 1, 8003, 8005, 
-0, 1, 
-  8010, 8012, 
-0, 1, 8011, 8013, 
-0, 49, 8018, 8020, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 8022, 
-0, 49, 8019, 8021, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 8023, 
-0, 49, 
-  8027, 8029, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8031, 
-0, 50, 8034, 8036, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 8038, 8096, 
-0, 50, 8035, 8037, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 8039, 8097, 
-0, 50, 
-  8042, 8044, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8046, 8104, 
-0, 50, 8043, 8045, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 8047, 8105, 
-50, 50, 8066, 
-50, 50, 8067, 
-50, 50, 
-  8068, 
-50, 50, 8069, 
-50, 50, 8070, 
-50, 50, 8071, 
-50, 50, 8074, 
-50, 50, 8075, 
-50, 50, 8076, 
-50, 50, 8077, 
-50, 50, 
-  8078, 
-50, 50, 8079, 
-50, 50, 8082, 
-50, 50, 8083, 
-50, 50, 8084, 
-50, 50, 8085, 
-50, 50, 8086, 
-50, 50, 8087, 
-50, 50, 
-  8090, 
-50, 50, 8091, 
-50, 50, 8092, 
-50, 50, 8093, 
-50, 50, 8094, 
-50, 50, 8095, 
-50, 50, 8098, 
-50, 50, 8099, 
-50, 50, 
-  8100, 
-50, 50, 8101, 
-50, 50, 8102, 
-50, 50, 8103, 
-50, 50, 8106, 
-50, 50, 8107, 
-50, 50, 8108, 
-50, 50, 8109, 
-50, 50, 
-  8110, 
-50, 50, 8111, 
-50, 50, 8114, 
-50, 50, 8116, 
-50, 50, 8119, 
-50, 50, 8130, 
-50, 50, 8132, 
-50, 50, 8135, 
-0, 49, 
-  8141, 8142, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 8143, 
-0, 49, 8157, 8158, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 8159, 
-47, 48, 8164, 8165, 
-48, 48, 8172, 
-50, 50, 8178, 
-50, 50, 
-  8180, 
-50, 50, 8183, 
-51, 51, 8602, 
-51, 51, 8603, 
-51, 51, 8622, 
-51, 51, 8653, 
-51, 51, 8654, 
-51, 51, 8655, 
-51, 51, 
-  8708, 
-51, 51, 8713, 
-51, 51, 8716, 
-51, 51, 8740, 
-51, 51, 8742, 
-51, 51, 8769, 
-51, 51, 8772, 
-51, 51, 8775, 
-51, 51, 
-  8777, 
-51, 51, 8800, 
-51, 51, 8802, 
-51, 51, 8813, 
-51, 51, 8814, 
-51, 51, 8815, 
-51, 51, 8816, 
-51, 51, 8817, 
-51, 51, 
-  8820, 
-51, 51, 8821, 
-51, 51, 8824, 
-51, 51, 8825, 
-51, 51, 8832, 
-51, 51, 8833, 
-51, 51, 8836, 
-51, 51, 8837, 
-51, 51, 
-  8840, 
-51, 51, 8841, 
-51, 51, 8876, 
-51, 51, 8877, 
-51, 51, 8878, 
-51, 51, 8879, 
-51, 51, 8928, 
-51, 51, 8929, 
-51, 51, 
-  8930, 
-51, 51, 8931, 
-51, 51, 8938, 
-51, 51, 8939, 
-51, 51, 8940, 
-51, 51, 8941, 
-51, 51, 10972, 
-52, 52, 12364, 
-52, 52, 
-  12366, 
-52, 52, 12368, 
-52, 52, 12370, 
-52, 52, 12372, 
-52, 52, 12374, 
-52, 52, 12376, 
-52, 52, 12378, 
-52, 52, 12380, 
-52, 52, 
-  12382, 
-52, 52, 12384, 
-52, 52, 12386, 
-52, 52, 12389, 
-52, 52, 12391, 
-52, 52, 12393, 
-52, 53, 12400, 12401, 
-52, 53, 
-  12403, 12404, 
-52, 53, 12406, 12407, 
-52, 53, 12409, 12410, 
-52, 53, 12412, 12413, 
-52, 52, 
-  12436, 
-52, 52, 12446, 
-52, 52, 12460, 
-52, 52, 12462, 
-52, 52, 12464, 
-52, 52, 12466, 
-52, 52, 12468, 
-52, 52, 12470, 
-52, 52, 
-  12472, 
-52, 52, 12474, 
-52, 52, 12476, 
-52, 52, 12478, 
-52, 52, 12480, 
-52, 52, 12482, 
-52, 52, 12485, 
-52, 52, 12487, 
-52, 52, 
-  12489, 
-52, 53, 12496, 12497, 
-52, 53, 12499, 12500, 
-52, 53, 12502, 12503, 
-52, 53, 12505, 
-  12506, 
-52, 53, 12508, 12509, 
-52, 52, 12532, 
-52, 52, 12535, 
-52, 52, 12536, 
-52, 52, 12537, 
-52, 52, 12538, 
-52, 52, 
-  12542, 
-54, 55, 1, 4250, 
-54, 55, 1, 4252, 
-54, 55, 1, 4267, 
-56, 57, 1, 4398, 
-56, 57, 1, 4399, 
-58, 61, 1, 4939, 1, 4940, 
-62, 67, 
-  1, 5307, 1, 5308, 1, 5310, 
-68, 69, 1, 5562, 
-68, 69, 1, 5563, 
-70, 71, 1, 53598, 
-70, 71, 1, 53599, 
-72, 81, 1, 53600, 
-  1, 53601, 1, 53602, 1, 53603, 1, 53604, 
-70, 71, 1, 53691, 
-70, 71, 1, 53692, 
-72, 75, 1, 53693, 1, 53695, 
-72, 75, 
-  1, 53694, 1, 53696, 
-};
-
-
-
-// LICENSE_CHANGE_END
-
-
-
-// UTF8PROC_DLLEXPORT const utf8proc_int8_t utf8proc_utf8class[256] = {
-// 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-// 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-// 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-// 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-// 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-// 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-// 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-// 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-// 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-// 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-// 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-// 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-// 	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-// 	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-// 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-// 	4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-#define UTF8PROC_HANGUL_SBASE 0xAC00
-#define UTF8PROC_HANGUL_LBASE 0x1100
-#define UTF8PROC_HANGUL_VBASE 0x1161
-#define UTF8PROC_HANGUL_TBASE 0x11A7
-#define UTF8PROC_HANGUL_LCOUNT 19
-#define UTF8PROC_HANGUL_VCOUNT 21
-#define UTF8PROC_HANGUL_TCOUNT 28
-#define UTF8PROC_HANGUL_NCOUNT 588
-#define UTF8PROC_HANGUL_SCOUNT 11172
-/* END is exclusive */
-#define UTF8PROC_HANGUL_L_START  0x1100
-#define UTF8PROC_HANGUL_L_END    0x115A
-#define UTF8PROC_HANGUL_L_FILLER 0x115F
-#define UTF8PROC_HANGUL_V_START  0x1160
-#define UTF8PROC_HANGUL_V_END    0x11A3
-#define UTF8PROC_HANGUL_T_START  0x11A8
-#define UTF8PROC_HANGUL_T_END    0x11FA
-#define UTF8PROC_HANGUL_S_START  0xAC00
-#define UTF8PROC_HANGUL_S_END    0xD7A4
-
-/* Should follow semantic-versioning rules (semver.org) based on API
-	 compatibility.  (Note that the shared-library version number will
-	 be different, being based on ABI compatibility.): */
-#define STRINGIZEx(x) #x
-#define STRINGIZE(x) STRINGIZEx(x)
-UTF8PROC_DLLEXPORT const char *utf8proc_version(void) {
-	return STRINGIZE(UTF8PROC_VERSION_MAJOR) "." STRINGIZE(UTF8PROC_VERSION_MINOR) "." STRINGIZE(UTF8PROC_VERSION_PATCH) "";
-}
-
-UTF8PROC_DLLEXPORT const char *utf8proc_unicode_version(void) {
-	return "12.1.0";
-}
-
-UTF8PROC_DLLEXPORT const char *utf8proc_errmsg(utf8proc_ssize_t errcode) {
-	switch (errcode) {
-		case UTF8PROC_ERROR_NOMEM:
-		return "Memory for processing UTF-8 data could not be allocated.";
-		case UTF8PROC_ERROR_OVERFLOW:
-		return "UTF-8 string is too long to be processed.";
-		case UTF8PROC_ERROR_INVALIDUTF8:
-		return "Invalid UTF-8 string";
-		case UTF8PROC_ERROR_NOTASSIGNED:
-		return "Unassigned Unicode code point found in UTF-8 string.";
-		case UTF8PROC_ERROR_INVALIDOPTS:
-		return "Invalid options for UTF-8 processing chosen.";
-		default:
-		return "An unknown error occurred while processing UTF-8 data.";
-	}
-}
-
-#define utf_cont(ch)  (((ch) & 0xc0) == 0x80)
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_iterate(
-	const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_int32_t *dst
-) {
-	utf8proc_uint32_t uc;
-	const utf8proc_uint8_t *end;
-
-	*dst = -1;
-	if (!strlen) return 0;
-	end = str + ((strlen < 0) ? 4 : strlen);
-	uc = *str++;
-	if (uc < 0x80) {
-		*dst = uc;
-		return 1;
-	}
-	// Must be between 0xc2 and 0xf4 inclusive to be valid
-	if ((uc - 0xc2) > (0xf4-0xc2)) return UTF8PROC_ERROR_INVALIDUTF8;
-	if (uc < 0xe0) {         // 2-byte sequence
-		 // Must have valid continuation character
-		 if (str >= end || !utf_cont(*str)) return UTF8PROC_ERROR_INVALIDUTF8;
-		 *dst = ((uc & 0x1f)<<6) | (*str & 0x3f);
-		 return 2;
-	}
-	if (uc < 0xf0) {        // 3-byte sequence
-		 if ((str + 1 >= end) || !utf_cont(*str) || !utf_cont(str[1]))
-				return UTF8PROC_ERROR_INVALIDUTF8;
-		 // Check for surrogate chars
-		 if (uc == 0xed && *str > 0x9f)
-				 return UTF8PROC_ERROR_INVALIDUTF8;
-		 uc = ((uc & 0xf)<<12) | ((*str & 0x3f)<<6) | (str[1] & 0x3f);
-		 if (uc < 0x800)
-				 return UTF8PROC_ERROR_INVALIDUTF8;
-		 *dst = uc;
-		 return 3;
-	}
-	// 4-byte sequence
-	// Must have 3 valid continuation characters
-	if ((str + 2 >= end) || !utf_cont(*str) || !utf_cont(str[1]) || !utf_cont(str[2]))
-		 return UTF8PROC_ERROR_INVALIDUTF8;
-	// Make sure in correct range (0x10000 - 0x10ffff)
-	if (uc == 0xf0) {
-		if (*str < 0x90) return UTF8PROC_ERROR_INVALIDUTF8;
-	} else if (uc == 0xf4) {
-		if (*str > 0x8f) return UTF8PROC_ERROR_INVALIDUTF8;
-	}
-	*dst = ((uc & 7)<<18) | ((*str & 0x3f)<<12) | ((str[1] & 0x3f)<<6) | (str[2] & 0x3f);
-	return 4;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_codepoint_valid(utf8proc_int32_t uc) {
-		return (((utf8proc_uint32_t)uc)-0xd800 > 0x07ff) && ((utf8proc_uint32_t)uc < 0x110000);
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_encode_char(utf8proc_int32_t uc, utf8proc_uint8_t *dst) {
-	if (uc < 0x00) {
-		return 0;
-	} else if (uc < 0x80) {
-		dst[0] = (utf8proc_uint8_t) uc;
-		return 1;
-	} else if (uc < 0x800) {
-		dst[0] = (utf8proc_uint8_t)(0xC0 + (uc >> 6));
-		dst[1] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-		return 2;
-	// Note: we allow encoding 0xd800-0xdfff here, so as not to change
-	// the API, however, these are actually invalid in UTF-8
-	} else if (uc < 0x10000) {
-		dst[0] = (utf8proc_uint8_t)(0xE0 + (uc >> 12));
-		dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F));
-		dst[2] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-		return 3;
-	} else if (uc < 0x110000) {
-		dst[0] = (utf8proc_uint8_t)(0xF0 + (uc >> 18));
-		dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 12) & 0x3F));
-		dst[2] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F));
-		dst[3] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-		return 4;
-	} else return 0;
-}
-
-/* internal version used for inserting 0xff bytes between graphemes */
-static utf8proc_ssize_t charbound_encode_char(utf8proc_int32_t uc, utf8proc_uint8_t *dst) {
-	 if (uc < 0x00) {
-			if (uc == -1) { /* internal value used for grapheme breaks */
-				dst[0] = (utf8proc_uint8_t)0xFF;
-				return 1;
-			}
-			return 0;
-	 } else if (uc < 0x80) {
-			dst[0] = (utf8proc_uint8_t)uc;
-			return 1;
-	 } else if (uc < 0x800) {
-			dst[0] = (utf8proc_uint8_t)(0xC0 + (uc >> 6));
-			dst[1] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-			return 2;
-	 } else if (uc < 0x10000) {
-			dst[0] = (utf8proc_uint8_t)(0xE0 + (uc >> 12));
-			dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F));
-			dst[2] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-			return 3;
-	 } else if (uc < 0x110000) {
-			dst[0] = (utf8proc_uint8_t)(0xF0 + (uc >> 18));
-			dst[1] = (utf8proc_uint8_t)(0x80 + ((uc >> 12) & 0x3F));
-			dst[2] = (utf8proc_uint8_t)(0x80 + ((uc >> 6) & 0x3F));
-			dst[3] = (utf8proc_uint8_t)(0x80 + (uc & 0x3F));
-			return 4;
-	 } else return 0;
-}
-
-/* internal "unsafe" version that does not check whether uc is in range */
-static const utf8proc_property_t *unsafe_get_property(utf8proc_int32_t uc) {
-	/* ASSERT: uc >= 0 && uc < 0x110000 */
-	return utf8proc_properties + (
-		utf8proc_stage2table[
-			utf8proc_stage1table[uc >> 8] + (uc & 0xFF)
-		]
-	);
-}
-
-UTF8PROC_DLLEXPORT const utf8proc_property_t *utf8proc_get_property(utf8proc_int32_t uc) {
-	return uc < 0 || uc >= 0x110000 ? utf8proc_properties : unsafe_get_property(uc);
-}
-
-/* return whether there is a grapheme break between boundclasses lbc and tbc
-	 (according to the definition of extended grapheme clusters)
-
-	Rule numbering refers to TR29 Version 29 (Unicode 9.0.0):
-	http://www.unicode.org/reports/tr29/tr29-29.html
-
-	CAVEATS:
-	 Please note that evaluation of GB10 (grapheme breaks between emoji zwj sequences)
-	 and GB 12/13 (regional indicator code points) require knowledge of previous characters
-	 and are thus not handled by this function. This may result in an incorrect break before
-	 an E_Modifier class codepoint and an incorrectly missing break between two
-	 REGIONAL_INDICATOR class code points if such support does not exist in the caller.
-
-	 See the special support in grapheme_break_extended, for required bookkeeping by the caller.
-*/
-static utf8proc_bool grapheme_break_simple(int lbc, int tbc) {
-	return
-		(lbc == UTF8PROC_BOUNDCLASS_START) ? true :       // GB1
-		(lbc == UTF8PROC_BOUNDCLASS_CR &&                 // GB3
-		 tbc == UTF8PROC_BOUNDCLASS_LF) ? false :         // ---
-		(lbc >= UTF8PROC_BOUNDCLASS_CR && lbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true :  // GB4
-		(tbc >= UTF8PROC_BOUNDCLASS_CR && tbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true :  // GB5
-		(lbc == UTF8PROC_BOUNDCLASS_L &&                  // GB6
-		 (tbc == UTF8PROC_BOUNDCLASS_L ||                 // ---
-			tbc == UTF8PROC_BOUNDCLASS_V ||                 // ---
-			tbc == UTF8PROC_BOUNDCLASS_LV ||                // ---
-			tbc == UTF8PROC_BOUNDCLASS_LVT)) ? false :      // ---
-		((lbc == UTF8PROC_BOUNDCLASS_LV ||                // GB7
-			lbc == UTF8PROC_BOUNDCLASS_V) &&                // ---
-		 (tbc == UTF8PROC_BOUNDCLASS_V ||                 // ---
-			tbc == UTF8PROC_BOUNDCLASS_T)) ? false :        // ---
-		((lbc == UTF8PROC_BOUNDCLASS_LVT ||               // GB8
-			lbc == UTF8PROC_BOUNDCLASS_T) &&                // ---
-		 tbc == UTF8PROC_BOUNDCLASS_T) ? false :          // ---
-		(tbc == UTF8PROC_BOUNDCLASS_EXTEND ||             // GB9
-		 tbc == UTF8PROC_BOUNDCLASS_ZWJ ||                // ---
-		 tbc == UTF8PROC_BOUNDCLASS_SPACINGMARK ||        // GB9a
-		 lbc == UTF8PROC_BOUNDCLASS_PREPEND) ? false :    // GB9b
-		(lbc == UTF8PROC_BOUNDCLASS_E_ZWG &&              // GB11 (requires additional handling below)
-		 tbc == UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC) ? false : // ----
-		(lbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR &&          // GB12/13 (requires additional handling below)
-		 tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR) ? false :  // ----
-		true; // GB999
-}
-
-utf8proc_bool grapheme_break_extended(int lbc, int tbc, utf8proc_int32_t *state)
-{
-	int lbc_override = ((state && *state != UTF8PROC_BOUNDCLASS_START)
-											? *state : lbc);
-	utf8proc_bool break_permitted = grapheme_break_simple(lbc_override, tbc);
-	if (state) {
-		// Special support for GB 12/13 made possible by GB999. After two RI
-		// class codepoints we want to force a break. Do this by resetting the
-		// second RI's bound class to UTF8PROC_BOUNDCLASS_OTHER, to force a break
-		// after that character according to GB999 (unless of course such a break is
-		// forbidden by a different rule such as GB9).
-		if (*state == tbc && tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR)
-			*state = UTF8PROC_BOUNDCLASS_OTHER;
-		// Special support for GB11 (emoji extend* zwj / emoji)
-		else if (*state == UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC) {
-			if (tbc == UTF8PROC_BOUNDCLASS_EXTEND) // fold EXTEND codepoints into emoji
-				*state = UTF8PROC_BOUNDCLASS_EXTENDED_PICTOGRAPHIC;
-			else if (tbc == UTF8PROC_BOUNDCLASS_ZWJ)
-				*state = UTF8PROC_BOUNDCLASS_E_ZWG; // state to record emoji+zwg combo
-			else
-				*state = tbc;
-		}
-		else
-			*state = tbc;
-	}
-	return break_permitted;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break_stateful(
-		utf8proc_int32_t c1, utf8proc_int32_t c2, utf8proc_int32_t *state) {
-
-	return grapheme_break_extended(utf8proc_get_property(c1)->boundclass,
-																 utf8proc_get_property(c2)->boundclass,
-																 state);
-}
-
-
-UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break(
-		utf8proc_int32_t c1, utf8proc_int32_t c2) {
-	return utf8proc_grapheme_break_stateful(c1, c2, NULL);
-}
-
-// from http://www.zedwood.com/article/cpp-utf8-char-to-codepoint
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_codepoint(const char *u_input, int &sz) {
-	auto u = (const unsigned char *) u_input;
-	unsigned char u0 = u[0];
-	if (u0<=127) {
-		sz = 1;
-		return u0;
-	}
-	unsigned char u1 = u[1];
-	if (u0>=192 && u0<=223) {
-		sz = 2;
-		return (u0-192)*64 + (u1-128);
-	}
-	if (u[0]==0xed && (u[1] & 0xa0) == 0xa0) {
-		return -1; //code points, 0xd800 to 0xdfff
-	}
-	unsigned char u2 = u[2];
-	if (u0>=224 && u0<=239) {
-		sz = 3;
-		return (u0-224)*4096 + (u1-128)*64 + (u2-128);
-	}
-	unsigned char u3 = u[3];
-	if (u0>=240 && u0<=247) {
-		sz = 4;
-		return (u0-240)*262144 + (u1-128)*4096 + (u2-128)*64 + (u3-128);
-	}
-	return -1;
-}
-
-bool utf8proc_codepoint_to_utf8(int cp, int &sz, char *c) {
-	if (cp<=0x7F) {
-		sz = 1;
-		c[0] = cp;
-	} else if(cp<=0x7FF) {
-		sz = 2;
-		c[0] = (cp>>6)+192;
-		c[1] = (cp&63)+128;
-	} else if(0xd800<=cp && cp<=0xdfff) {
-		sz = -1;
-		// invalid block of utf
-		return false;
-	} else if(cp<=0xFFFF) {
-		sz = 3;
-		c[0] = (cp>>12)+224;
-		c[1]= ((cp>>6)&63)+128;
-		c[2]=(cp&63)+128;
-	} else if(cp<=0x10FFFF) {
-		sz = 4;
-		c[0] = (cp>>18)+240;
-		c[1] = ((cp>>12)&63)+128;
-		c[2] = ((cp>>6)&63)+128;
-		c[3]=(cp&63)+128;
-	} else {
-		sz = -1;
-		return false;
-	}
-	return true;
-}
-
-int utf8proc_codepoint_length(int cp) {
-	if (cp<=0x7F) {
-		return 1;
-	} else if(cp<=0x7FF) {
-		return 2;
-	} else if(0xd800<=cp && cp<=0xdfff) {
-		return -1;
-	} else if(cp<=0xFFFF) {
-		return 3;
-	} else if(cp<=0x10FFFF) {
-		return 4;
-	}
-	return -1;
-}
-
-size_t utf8proc_next_grapheme(const char *s, size_t len, size_t cpos) {
-	int sz;
-	int boundclass = UTF8PROC_BOUNDCLASS_START;
-	int initial = utf8proc_get_property(utf8proc_codepoint(s + cpos, sz))->boundclass;
-	grapheme_break_extended(boundclass, initial, &boundclass);
-	while(true) {
-		cpos += sz;
-		if (cpos >= len) {
-			return cpos;
-		}
-		int next = utf8proc_get_property(utf8proc_codepoint(s + cpos, sz))->boundclass;
-		if (grapheme_break_extended(boundclass, next, &boundclass)) {
-			return cpos;
-		}
-	}
-}
-
-static utf8proc_int32_t seqindex_decode_entry(const utf8proc_uint16_t **entry)
-{
-	utf8proc_int32_t entry_cp = **entry;
-	if ((entry_cp & 0xF800) == 0xD800) {
-		*entry = *entry + 1;
-		entry_cp = ((entry_cp & 0x03FF) << 10) | (**entry & 0x03FF);
-		entry_cp += 0x10000;
-	}
-	return entry_cp;
-}
-
-static utf8proc_int32_t seqindex_decode_index(const utf8proc_uint32_t seqindex)
-{
-	const utf8proc_uint16_t *entry = &utf8proc_sequences[seqindex];
-	return seqindex_decode_entry(&entry);
-}
-
-static utf8proc_ssize_t seqindex_write_char_decomposed(utf8proc_uint16_t seqindex, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize, utf8proc_option_t options, int *last_boundclass) {
-	utf8proc_ssize_t written = 0;
-	const utf8proc_uint16_t *entry = &utf8proc_sequences[seqindex & 0x1FFF];
-	int len = seqindex >> 13;
-	if (len >= 7) {
-		len = *entry;
-		entry++;
-	}
-	for (; len >= 0; entry++, len--) {
-		utf8proc_int32_t entry_cp = seqindex_decode_entry(&entry);
-		utf8proc_int32_t *dst_ptr = dst ? dst + written : nullptr;
-		written += utf8proc_decompose_char(entry_cp, dst_ptr,
-			(bufsize > written) ? (bufsize - written) : 0, options,
-		last_boundclass);
-		if (written < 0) return UTF8PROC_ERROR_OVERFLOW;
-	}
-	return written;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_tolower(utf8proc_int32_t c)
-{
-	utf8proc_int32_t cl = utf8proc_get_property(c)->lowercase_seqindex;
-	return cl != UINT16_MAX ? seqindex_decode_index(cl) : c;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_toupper(utf8proc_int32_t c)
-{
-	utf8proc_int32_t cu = utf8proc_get_property(c)->uppercase_seqindex;
-	return cu != UINT16_MAX ? seqindex_decode_index(cu) : c;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_int32_t utf8proc_totitle(utf8proc_int32_t c)
-{
-	utf8proc_int32_t cu = utf8proc_get_property(c)->titlecase_seqindex;
-	return cu != UINT16_MAX ? seqindex_decode_index(cu) : c;
-}
-
-/* return a character width analogous to wcwidth (except portable and
-	 hopefully less buggy than most system wcwidth functions). */
-UTF8PROC_DLLEXPORT int utf8proc_charwidth(utf8proc_int32_t c) {
-	return utf8proc_get_property(c)->charwidth;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_category_t utf8proc_category(utf8proc_int32_t c) {
-	return (utf8proc_category_t)utf8proc_get_property(c)->category;
-}
-
-UTF8PROC_DLLEXPORT const char *utf8proc_category_string(utf8proc_int32_t c) {
-	static const char s[][3] = {"Cn","Lu","Ll","Lt","Lm","Lo","Mn","Mc","Me","Nd","Nl","No","Pc","Pd","Ps","Pe","Pi","Pf","Po","Sm","Sc","Sk","So","Zs","Zl","Zp","Cc","Cf","Cs","Co"};
-	return s[utf8proc_category(c)];
-}
-
-#define utf8proc_decompose_lump(replacement_uc) \
-	return utf8proc_decompose_char((replacement_uc), dst, bufsize, \
-	(utf8proc_option_t) (options & ~UTF8PROC_LUMP), last_boundclass)
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_char(utf8proc_int32_t uc, utf8proc_int32_t *dst, utf8proc_ssize_t bufsize, utf8proc_option_t options, int *last_boundclass) {
-	const utf8proc_property_t *property;
-	utf8proc_propval_t category;
-	utf8proc_int32_t hangul_sindex;
-	if (uc < 0 || uc >= 0x110000) return UTF8PROC_ERROR_NOTASSIGNED;
-	property = unsafe_get_property(uc);
-	category = property->category;
-	hangul_sindex = uc - UTF8PROC_HANGUL_SBASE;
-	if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) {
-		if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT) {
-			utf8proc_int32_t hangul_tindex;
-			if (bufsize >= 1) {
-				dst[0] = UTF8PROC_HANGUL_LBASE +
-					hangul_sindex / UTF8PROC_HANGUL_NCOUNT;
-				if (bufsize >= 2) dst[1] = UTF8PROC_HANGUL_VBASE +
-					(hangul_sindex % UTF8PROC_HANGUL_NCOUNT) / UTF8PROC_HANGUL_TCOUNT;
-			}
-			hangul_tindex = hangul_sindex % UTF8PROC_HANGUL_TCOUNT;
-			if (!hangul_tindex) return 2;
-			if (bufsize >= 3) dst[2] = UTF8PROC_HANGUL_TBASE + hangul_tindex;
-			return 3;
-		}
-	}
-	if (options & UTF8PROC_REJECTNA) {
-		if (!category) return UTF8PROC_ERROR_NOTASSIGNED;
-	}
-	if (options & UTF8PROC_IGNORE) {
-		if (property->ignorable) return 0;
-	}
-	if (options & UTF8PROC_STRIPNA) {
-		if (!category) return 0;
-	}
-	if (options & UTF8PROC_LUMP) {
-		if (category == UTF8PROC_CATEGORY_ZS) utf8proc_decompose_lump(0x0020);
-		if (uc == 0x2018 || uc == 0x2019 || uc == 0x02BC || uc == 0x02C8)
-			utf8proc_decompose_lump(0x0027);
-		if (category == UTF8PROC_CATEGORY_PD || uc == 0x2212)
-			utf8proc_decompose_lump(0x002D);
-		if (uc == 0x2044 || uc == 0x2215) utf8proc_decompose_lump(0x002F);
-		if (uc == 0x2236) utf8proc_decompose_lump(0x003A);
-		if (uc == 0x2039 || uc == 0x2329 || uc == 0x3008)
-			utf8proc_decompose_lump(0x003C);
-		if (uc == 0x203A || uc == 0x232A || uc == 0x3009)
-			utf8proc_decompose_lump(0x003E);
-		if (uc == 0x2216) utf8proc_decompose_lump(0x005C);
-		if (uc == 0x02C4 || uc == 0x02C6 || uc == 0x2038 || uc == 0x2303)
-			utf8proc_decompose_lump(0x005E);
-		if (category == UTF8PROC_CATEGORY_PC || uc == 0x02CD)
-			utf8proc_decompose_lump(0x005F);
-		if (uc == 0x02CB) utf8proc_decompose_lump(0x0060);
-		if (uc == 0x2223) utf8proc_decompose_lump(0x007C);
-		if (uc == 0x223C) utf8proc_decompose_lump(0x007E);
-		if ((options & UTF8PROC_NLF2LS) && (options & UTF8PROC_NLF2PS)) {
-			if (category == UTF8PROC_CATEGORY_ZL ||
-					category == UTF8PROC_CATEGORY_ZP)
-				utf8proc_decompose_lump(0x000A);
-		}
-	}
-	if (options & UTF8PROC_STRIPMARK) {
-		if (category == UTF8PROC_CATEGORY_MN ||
-			category == UTF8PROC_CATEGORY_MC ||
-			category == UTF8PROC_CATEGORY_ME) return 0;
-	}
-	if (options & UTF8PROC_CASEFOLD) {
-		if (property->casefold_seqindex != UINT16_MAX) {
-			return seqindex_write_char_decomposed(property->casefold_seqindex, dst, bufsize, options, last_boundclass);
-		}
-	}
-	if (options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) {
-		if (property->decomp_seqindex != UINT16_MAX &&
-				(!property->decomp_type || (options & UTF8PROC_COMPAT))) {
-			return seqindex_write_char_decomposed(property->decomp_seqindex, dst, bufsize, options, last_boundclass);
-		}
-	}
-	if (options & UTF8PROC_CHARBOUND) {
-		utf8proc_bool boundary;
-		int tbc = property->boundclass;
-		boundary = grapheme_break_extended(*last_boundclass, tbc, last_boundclass);
-		if (boundary) {
-			if (bufsize >= 1) dst[0] = -1; /* sentinel value for grapheme break */
-			if (bufsize >= 2) dst[1] = uc;
-			return 2;
-		}
-	}
-	if (bufsize >= 1) *dst = uc;
-	return 1;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose(
-	const utf8proc_uint8_t *str, utf8proc_ssize_t strlen,
-	utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options
-) {
-		return utf8proc_decompose_custom(str, strlen, buffer, bufsize, options, NULL, NULL);
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom(
-	const utf8proc_uint8_t *str, utf8proc_ssize_t strlen,
-	utf8proc_int32_t *buffer, utf8proc_ssize_t bufsize, utf8proc_option_t options,
-	utf8proc_custom_func custom_func, void *custom_data
-) {
-	/* strlen will be ignored, if UTF8PROC_NULLTERM is set in options */
-	utf8proc_ssize_t wpos = 0;
-	if ((options & UTF8PROC_COMPOSE) && (options & UTF8PROC_DECOMPOSE))
-		return UTF8PROC_ERROR_INVALIDOPTS;
-	if ((options & UTF8PROC_STRIPMARK) &&
-			!(options & UTF8PROC_COMPOSE) && !(options & UTF8PROC_DECOMPOSE))
-		return UTF8PROC_ERROR_INVALIDOPTS;
-	{
-		utf8proc_int32_t uc;
-		utf8proc_ssize_t rpos = 0;
-		utf8proc_ssize_t decomp_result;
-		int boundclass = UTF8PROC_BOUNDCLASS_START;
-		while (1) {
-			if (options & UTF8PROC_NULLTERM) {
-				rpos += utf8proc_iterate(str + rpos, -1, &uc);
-				/* checking of return value is not necessary,
-					 as 'uc' is < 0 in case of error */
-				if (uc < 0) return UTF8PROC_ERROR_INVALIDUTF8;
-				if (rpos < 0) return UTF8PROC_ERROR_OVERFLOW;
-				if (uc == 0) break;
-			} else {
-				if (rpos >= strlen) break;
-				rpos += utf8proc_iterate(str + rpos, strlen - rpos, &uc);
-				if (uc < 0) return UTF8PROC_ERROR_INVALIDUTF8;
-			}
-			if (custom_func != NULL) {
-				uc = custom_func(uc, custom_data);   /* user-specified custom mapping */
-			}
-			utf8proc_int32_t *target_buffer = buffer ? buffer + wpos : nullptr;
-			decomp_result = utf8proc_decompose_char(
-				uc, target_buffer, (bufsize > wpos) ? (bufsize - wpos) : 0, options,
-				&boundclass
-			);
-			if (decomp_result < 0) return decomp_result;
-			wpos += decomp_result;
-			/* prohibiting integer overflows due to too long strings: */
-			if (wpos < 0 ||
-					wpos > (utf8proc_ssize_t)(SSIZE_MAX/sizeof(utf8proc_int32_t)/2))
-				return UTF8PROC_ERROR_OVERFLOW;
-		}
-	}
-	if ((options & (UTF8PROC_COMPOSE|UTF8PROC_DECOMPOSE)) && bufsize >= wpos) {
-		utf8proc_ssize_t pos = 0;
-		while (pos < wpos-1) {
-			utf8proc_int32_t uc1, uc2;
-			const utf8proc_property_t *property1, *property2;
-			uc1 = buffer[pos];
-			uc2 = buffer[pos+1];
-			property1 = unsafe_get_property(uc1);
-			property2 = unsafe_get_property(uc2);
-			if (property1->combining_class > property2->combining_class &&
-					property2->combining_class > 0) {
-				buffer[pos] = uc2;
-				buffer[pos+1] = uc1;
-				if (pos > 0) pos--; else pos++;
-			} else {
-				pos++;
-			}
-		}
-	}
-	return wpos;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_normalize_utf32(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options) {
-	/* UTF8PROC_NULLTERM option will be ignored, 'length' is never ignored */
-	if (options & (UTF8PROC_NLF2LS | UTF8PROC_NLF2PS | UTF8PROC_STRIPCC)) {
-		utf8proc_ssize_t rpos;
-		utf8proc_ssize_t wpos = 0;
-		utf8proc_int32_t uc;
-		for (rpos = 0; rpos < length; rpos++) {
-			uc = buffer[rpos];
-			if (uc == 0x000D && rpos < length-1 && buffer[rpos+1] == 0x000A) rpos++;
-			if (uc == 0x000A || uc == 0x000D || uc == 0x0085 ||
-					((options & UTF8PROC_STRIPCC) && (uc == 0x000B || uc == 0x000C))) {
-				if (options & UTF8PROC_NLF2LS) {
-					if (options & UTF8PROC_NLF2PS) {
-						buffer[wpos++] = 0x000A;
-					} else {
-						buffer[wpos++] = 0x2028;
-					}
-				} else {
-					if (options & UTF8PROC_NLF2PS) {
-						buffer[wpos++] = 0x2029;
-					} else {
-						buffer[wpos++] = 0x0020;
-					}
-				}
-			} else if ((options & UTF8PROC_STRIPCC) &&
-					(uc < 0x0020 || (uc >= 0x007F && uc < 0x00A0))) {
-				if (uc == 0x0009) buffer[wpos++] = 0x0020;
-			} else {
-				buffer[wpos++] = uc;
-			}
-		}
-		length = wpos;
-	}
-	if (options & UTF8PROC_COMPOSE) {
-		utf8proc_int32_t *starter = NULL;
-		utf8proc_int32_t current_char;
-		const utf8proc_property_t *starter_property = NULL, *current_property;
-		utf8proc_propval_t max_combining_class = -1;
-		utf8proc_ssize_t rpos;
-		utf8proc_ssize_t wpos = 0;
-		utf8proc_int32_t composition;
-		for (rpos = 0; rpos < length; rpos++) {
-			current_char = buffer[rpos];
-			current_property = unsafe_get_property(current_char);
-			if (starter && current_property->combining_class > max_combining_class) {
-				/* combination perhaps possible */
-				utf8proc_int32_t hangul_lindex;
-				utf8proc_int32_t hangul_sindex;
-				hangul_lindex = *starter - UTF8PROC_HANGUL_LBASE;
-				if (hangul_lindex >= 0 && hangul_lindex < UTF8PROC_HANGUL_LCOUNT) {
-					utf8proc_int32_t hangul_vindex;
-					hangul_vindex = current_char - UTF8PROC_HANGUL_VBASE;
-					if (hangul_vindex >= 0 && hangul_vindex < UTF8PROC_HANGUL_VCOUNT) {
-						*starter = UTF8PROC_HANGUL_SBASE +
-							(hangul_lindex * UTF8PROC_HANGUL_VCOUNT + hangul_vindex) *
-							UTF8PROC_HANGUL_TCOUNT;
-						starter_property = NULL;
-						continue;
-					}
-				}
-				hangul_sindex = *starter - UTF8PROC_HANGUL_SBASE;
-				if (hangul_sindex >= 0 && hangul_sindex < UTF8PROC_HANGUL_SCOUNT &&
-						(hangul_sindex % UTF8PROC_HANGUL_TCOUNT) == 0) {
-					utf8proc_int32_t hangul_tindex;
-					hangul_tindex = current_char - UTF8PROC_HANGUL_TBASE;
-					if (hangul_tindex >= 0 && hangul_tindex < UTF8PROC_HANGUL_TCOUNT) {
-						*starter += hangul_tindex;
-						starter_property = NULL;
-						continue;
-					}
-				}
-				if (!starter_property) {
-					starter_property = unsafe_get_property(*starter);
-				}
-				if (starter_property->comb_index < 0x8000 &&
-						current_property->comb_index != UINT16_MAX &&
-						current_property->comb_index >= 0x8000) {
-					int sidx = starter_property->comb_index;
-					int idx = current_property->comb_index & 0x3FFF;
-					if (idx >= utf8proc_combinations[sidx] && idx <= utf8proc_combinations[sidx + 1] ) {
-						idx += sidx + 2 - utf8proc_combinations[sidx];
-						if (current_property->comb_index & 0x4000) {
-							composition = (utf8proc_combinations[idx] << 16) | utf8proc_combinations[idx+1];
-						} else
-							composition = utf8proc_combinations[idx];
-
-						if (composition > 0 && (!(options & UTF8PROC_STABLE) ||
-								!(unsafe_get_property(composition)->comp_exclusion))) {
-							*starter = composition;
-							starter_property = NULL;
-							continue;
-						}
-					}
-				}
-			}
-			buffer[wpos] = current_char;
-			if (current_property->combining_class) {
-				if (current_property->combining_class > max_combining_class) {
-					max_combining_class = current_property->combining_class;
-				}
-			} else {
-				starter = buffer + wpos;
-				starter_property = NULL;
-				max_combining_class = -1;
-			}
-			wpos++;
-		}
-		length = wpos;
-	}
-	return length;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_reencode(utf8proc_int32_t *buffer, utf8proc_ssize_t length, utf8proc_option_t options) {
-	/* UTF8PROC_NULLTERM option will be ignored, 'length' is never ignored
-		 ASSERT: 'buffer' has one spare byte of free space at the end! */
-	length = utf8proc_normalize_utf32(buffer, length, options);
-	if (length < 0) return length;
-	{
-		utf8proc_ssize_t rpos, wpos = 0;
-		utf8proc_int32_t uc;
-		if (options & UTF8PROC_CHARBOUND) {
-				for (rpos = 0; rpos < length; rpos++) {
-						uc = buffer[rpos];
-						wpos += charbound_encode_char(uc, ((utf8proc_uint8_t *)buffer) + wpos);
-				}
-		} else {
-				for (rpos = 0; rpos < length; rpos++) {
-						uc = buffer[rpos];
-						wpos += utf8proc_encode_char(uc, ((utf8proc_uint8_t *)buffer) + wpos);
-				}
-		}
-		((utf8proc_uint8_t *)buffer)[wpos] = 0;
-		return wpos;
-	}
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map(
-	const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options
-) {
-		return utf8proc_map_custom(str, strlen, dstptr, options, NULL, NULL);
-}
-
-UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map_custom(
-	const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options,
-	utf8proc_custom_func custom_func, void *custom_data
-) {
-	utf8proc_int32_t *buffer;
-	utf8proc_ssize_t result;
-	*dstptr = NULL;
-	result = utf8proc_decompose_custom(str, strlen, NULL, 0, options, custom_func, custom_data);
-	if (result < 0) return result;
-	buffer = (utf8proc_int32_t *) malloc(result * sizeof(utf8proc_int32_t) + 1);
-	if (!buffer) return UTF8PROC_ERROR_NOMEM;
-	result = utf8proc_decompose_custom(str, strlen, buffer, result, options, custom_func, custom_data);
-	if (result < 0) {
-		free(buffer);
-		return result;
-	}
-	result = utf8proc_reencode(buffer, result, options);
-	if (result < 0) {
-		free(buffer);
-		return result;
-	}
-	{
-		utf8proc_int32_t *newptr;
-		newptr = (utf8proc_int32_t *) realloc(buffer, (size_t)result+1);
-		if (newptr) buffer = newptr;
-	}
-	*dstptr = (utf8proc_uint8_t *)buffer;
-	return result;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFD(const utf8proc_uint8_t *str, utf8proc_ssize_t len) {
-	utf8proc_uint8_t *retval;
-	utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE |
-		UTF8PROC_DECOMPOSE));
-	return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFC(const utf8proc_uint8_t *str, utf8proc_ssize_t len) {
-	utf8proc_uint8_t *retval;
-	utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE |
-		UTF8PROC_COMPOSE));
-	return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_remove_accents(const utf8proc_uint8_t *str, utf8proc_ssize_t len) {
-	utf8proc_uint8_t *retval;
-	utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE |
-		UTF8PROC_COMPOSE | UTF8PROC_STRIPMARK));
-	return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKD(const utf8proc_uint8_t *str, utf8proc_ssize_t len) {
-	utf8proc_uint8_t *retval;
-	utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE |
-		UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT));
-	return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC(const utf8proc_uint8_t *str, utf8proc_ssize_t len) {
-	utf8proc_uint8_t *retval;
-	utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE |
-		UTF8PROC_COMPOSE | UTF8PROC_COMPAT));
-	return retval;
-}
-
-UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8_t *str, utf8proc_ssize_t len) {
-	utf8proc_uint8_t *retval;
-	utf8proc_map(str, len, &retval, (utf8proc_option_t)(UTF8PROC_STABLE |
-		UTF8PROC_COMPOSE | UTF8PROC_COMPAT | UTF8PROC_CASEFOLD | UTF8PROC_IGNORE));
-	return retval;
-}
-
-}
-
-
-// LICENSE_CHANGE_END
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
-// See the end of this file for a list
-
-
-
-
-using namespace std;
-
-namespace duckdb {
-
-// This function efficiently checks if a string is valid UTF8.
-// It was originally written by Sjoerd Mullender.
-
-// Here is the table that makes it work:
-
-// B 		= Number of Bytes in UTF8 encoding
-// C_MIN 	= First Unicode code point
-// C_MAX 	= Last Unicode code point
-// B1 		= First Byte Prefix
-
-// 	B	C_MIN		C_MAX		B1
-//	1	U+000000	U+00007F		0xxxxxxx
-//	2	U+000080	U+0007FF		110xxxxx
-//	3	U+000800	U+00FFFF		1110xxxx
-//	4	U+010000	U+10FFFF		11110xxx
-
-static void AssignInvalidUTF8Reason(UnicodeInvalidReason *invalid_reason, size_t *invalid_pos, size_t pos, UnicodeInvalidReason reason) {
-	if (invalid_reason) {
-		*invalid_reason = reason;
-	}
-	if (invalid_pos) {
-		*invalid_pos = pos;
-	}
-}
-
-UnicodeType Utf8Proc::Analyze(const char *s, size_t len, UnicodeInvalidReason *invalid_reason, size_t *invalid_pos) {
-	UnicodeType type = UnicodeType::ASCII;
-	char c;
-	for (size_t i = 0; i < len; i++) {
-		c = s[i];
-		if (c == '\0') {
-			AssignInvalidUTF8Reason(invalid_reason, invalid_pos, i, UnicodeInvalidReason::NULL_BYTE);
-			return UnicodeType::INVALID;
-		}
-		// 1 Byte / ASCII
-		if ((c & 0x80) == 0) {
-			continue;
-		}
-		type = UnicodeType::UNICODE;
-		if ((s[++i] & 0xC0) != 0x80) {
-			AssignInvalidUTF8Reason(invalid_reason, invalid_pos, i, UnicodeInvalidReason::BYTE_MISMATCH);
-			return UnicodeType::INVALID;
-		}
-		if ((c & 0xE0) == 0xC0) {
-			continue;
-		}
-		if ((s[++i] & 0xC0) != 0x80) {
-			AssignInvalidUTF8Reason(invalid_reason, invalid_pos, i, UnicodeInvalidReason::BYTE_MISMATCH);
-			return UnicodeType::INVALID;
-		}
-		if ((c & 0xF0) == 0xE0) {
-			continue;
-		}
-		if ((s[++i] & 0xC0) != 0x80) {
-			AssignInvalidUTF8Reason(invalid_reason, invalid_pos, i, UnicodeInvalidReason::BYTE_MISMATCH);
-			return UnicodeType::INVALID;
-		}
-		if ((c & 0xF8) == 0xF0) {
-			continue;
-		}
-		AssignInvalidUTF8Reason(invalid_reason, invalid_pos, i, UnicodeInvalidReason::BYTE_MISMATCH);
-		return UnicodeType::INVALID;
-	}
-
-	return type;
-}
-
-
-char* Utf8Proc::Normalize(const char *s, size_t len) {
-	assert(s);
-	assert(Utf8Proc::Analyze(s, len) != UnicodeType::INVALID);
-	return (char*) utf8proc_NFC((const utf8proc_uint8_t*) s, len);
-}
-
-bool Utf8Proc::IsValid(const char *s, size_t len) {
-	return Utf8Proc::Analyze(s, len) != UnicodeType::INVALID;
-}
-
-size_t Utf8Proc::NextGraphemeCluster(const char *s, size_t len, size_t cpos) {
-	return utf8proc_next_grapheme(s, len, cpos);
-}
-
-size_t Utf8Proc::PreviousGraphemeCluster(const char *s, size_t len, size_t cpos) {
-	if (!Utf8Proc::IsValid(s, len)) {
-		return cpos - 1;
-	}
-	size_t current_pos = 0;
-	while(true) {
-		size_t new_pos = NextGraphemeCluster(s, len, current_pos);
-		if (new_pos <= current_pos || new_pos >= cpos) {
-			return current_pos;
-		}
-		current_pos = new_pos;
-	}
-}
-
-bool Utf8Proc::CodepointToUtf8(int cp, int &sz, char *c) {
-	return utf8proc_codepoint_to_utf8(cp, sz, c);
-}
-
-int Utf8Proc::CodepointLength(int cp) {
-	return utf8proc_codepoint_length(cp);
-}
-
-int32_t Utf8Proc::UTF8ToCodepoint(const char *c, int &sz) {
-	return utf8proc_codepoint(c, sz);
-}
-
-size_t Utf8Proc::RenderWidth(const char *s, size_t len, size_t pos) {
-    int sz;
-    auto codepoint = duckdb::utf8proc_codepoint(s + pos, sz);
-    auto properties = duckdb::utf8proc_get_property(codepoint);
-    return properties->charwidth;
-}
-
-}
-
-
-// LICENSE_CHANGE_END
diff --git a/velox/external/duckdb/duckdb.hpp b/velox/external/duckdb/duckdb.hpp
deleted file mode 100644
index 512262607e053..0000000000000
--- a/velox/external/duckdb/duckdb.hpp
+++ /dev/null
@@ -1,24812 +0,0 @@
-/*
-Copyright 2018-2022 Stichting DuckDB Foundation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#pragma once
-#define DUCKDB_AMALGAMATION 1
-#define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "001284c09"
-#define DUCKDB_VERSION "v0.4.1-dev344"
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/connection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/profiler_format.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/constants.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <memory>
-#include <cstdint>
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/string.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <string>
-#include <sstream>
-
-namespace duckdb {
-using std::string;
-}
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/winapi.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#ifndef DUCKDB_API
-#ifdef _WIN32
-#if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
-#define DUCKDB_API __declspec(dllexport)
-#else
-#define DUCKDB_API __declspec(dllimport)
-#endif
-#else
-#define DUCKDB_API
-#endif
-#endif
-
-#ifndef DUCKDB_EXTENSION_API
-#ifdef _WIN32
-#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
-#define DUCKDB_EXTENSION_API __declspec(dllexport)
-#else
-#define DUCKDB_EXTENSION_API
-#endif
-#else
-#define DUCKDB_EXTENSION_API __attribute__((visibility("default")))
-#endif
-#endif
-
-
-namespace duckdb {
-
-// API versions
-// if no explicit API version is defined, the latest API version is used
-// Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
-// These will not be supported long-term, and will be removed in future versions.
-
-#ifndef DUCKDB_API_0_3_1
-#define DUCKDB_API_0_3_1 1
-#endif
-#ifndef DUCKDB_API_0_3_2
-#define DUCKDB_API_0_3_2 2
-#endif
-#ifndef DUCKDB_API_LATEST
-#define DUCKDB_API_LATEST DUCKDB_API_0_3_2
-#endif
-
-#ifndef DUCKDB_API_VERSION
-#define DUCKDB_API_VERSION DUCKDB_API_LATEST
-#endif
-
-//! inline std directives that we use frequently
-using std::move;
-using std::shared_ptr;
-using std::unique_ptr;
-using std::weak_ptr;
-using data_ptr = unique_ptr<char[]>;
-using std::make_shared;
-
-// NOTE: there is a copy of this in the Postgres' parser grammar (gram.y)
-#define DEFAULT_SCHEMA "main"
-#define TEMP_SCHEMA    "temp"
-#define INVALID_SCHEMA ""
-
-//! a saner size_t for loop indices etc
-typedef uint64_t idx_t;
-
-//! The type used for row identifiers
-typedef int64_t row_t;
-
-//! The type used for hashes
-typedef uint64_t hash_t;
-
-//! data pointers
-typedef uint8_t data_t;
-typedef data_t *data_ptr_t;
-typedef const data_t *const_data_ptr_t;
-
-//! Type used for the selection vector
-typedef uint32_t sel_t;
-//! Type used for transaction timestamps
-typedef idx_t transaction_t;
-
-//! Type used for column identifiers
-typedef idx_t column_t;
-//! Type used for storage (column) identifiers
-typedef idx_t storage_t;
-//! Special value used to signify the ROW ID of a table
-extern const column_t COLUMN_IDENTIFIER_ROW_ID;
-
-//! The maximum row identifier used in tables
-extern const row_t MAX_ROW_ID;
-
-extern const transaction_t TRANSACTION_ID_START;
-extern const transaction_t MAX_TRANSACTION_ID;
-extern const transaction_t MAXIMUM_QUERY_ID;
-extern const transaction_t NOT_DELETED_ID;
-
-extern const double PI;
-
-struct DConstants {
-	//! The value used to signify an invalid index entry
-	static constexpr const idx_t INVALID_INDEX = idx_t(-1);
-};
-
-struct Storage {
-	//! The size of a hard disk sector, only really needed for Direct IO
-	constexpr static int SECTOR_SIZE = 4096;
-	//! Block header size for blocks written to the storage
-	constexpr static int BLOCK_HEADER_SIZE = sizeof(uint64_t);
-	// Size of a memory slot managed by the StorageManager. This is the quantum of allocation for Blocks on DuckDB. We
-	// default to 256KB. (1 << 18)
-	constexpr static int BLOCK_ALLOC_SIZE = 262144;
-	//! The actual memory space that is available within the blocks
-	constexpr static int BLOCK_SIZE = BLOCK_ALLOC_SIZE - BLOCK_HEADER_SIZE;
-	//! The size of the headers. This should be small and written more or less atomically by the hard disk. We default
-	//! to the page size, which is 4KB. (1 << 12)
-	constexpr static int FILE_HEADER_SIZE = 4096;
-};
-
-uint64_t NextPowerOfTwo(uint64_t v);
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-enum class ProfilerPrintFormat : uint8_t { QUERY_TREE, JSON, QUERY_TREE_OPTIMIZER };
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/buffered_file_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/common.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/helper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-#include <string.h>
-
-#ifdef _MSC_VER
-#define suint64_t int64_t
-#endif
-
-#if defined(_WIN32) || defined(_WIN64)
-#define DUCKDB_WINDOWS
-#elif defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
-#define DUCKDB_POSIX
-#endif
-
-namespace duckdb {
-
-// explicit fallthrough for switch_statementss
-#ifndef __has_cpp_attribute // For backwards compatibility
-#define __has_cpp_attribute(x) 0
-#endif
-#if __has_cpp_attribute(clang::fallthrough)
-#define DUCKDB_EXPLICIT_FALLTHROUGH [[clang::fallthrough]]
-#elif __has_cpp_attribute(gnu::fallthrough)
-#define DUCKDB_EXPLICIT_FALLTHROUGH [[gnu::fallthrough]]
-#else
-#define DUCKDB_EXPLICIT_FALLTHROUGH
-#endif
-
-#if !defined(_MSC_VER) && (__cplusplus < 201402L)
-template <typename T, typename... Args>
-unique_ptr<T> make_unique(Args &&... args) {
-	return unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-#else // Visual Studio has make_unique
-using std::make_unique;
-#endif
-template <typename S, typename T, typename... Args>
-unique_ptr<S> make_unique_base(Args &&... args) {
-	return unique_ptr<S>(new T(std::forward<Args>(args)...));
-}
-
-template <typename T, typename S>
-unique_ptr<S> unique_ptr_cast(unique_ptr<T> src) {
-	return unique_ptr<S>(static_cast<S *>(src.release()));
-}
-
-struct SharedConstructor {
-	template <class T, typename... ARGS>
-	static shared_ptr<T> Create(ARGS &&...args) {
-		return make_shared<T>(std::forward<ARGS>(args)...);
-	}
-};
-
-struct UniqueConstructor {
-	template <class T, typename... ARGS>
-	static unique_ptr<T> Create(ARGS &&...args) {
-		return make_unique<T>(std::forward<ARGS>(args)...);
-	}
-};
-
-template <typename T>
-T MaxValue(T a, T b) {
-	return a > b ? a : b;
-}
-
-template <typename T>
-T MinValue(T a, T b) {
-	return a < b ? a : b;
-}
-
-template <typename T>
-T AbsValue(T a) {
-	return a < 0 ? -a : a;
-}
-
-template<class T, T val=8>
-static inline T AlignValue(T n) {
-	return ((n + (val - 1)) / val) * val;
-}
-
-template<class T, T val=8>
-static inline bool ValueIsAligned(T n) {
-	return (n % val) == 0;
-}
-
-template <typename T>
-T SignValue(T a) {
-	return a < 0 ? -1 : 1;
-}
-
-template <typename T>
-const T Load(const_data_ptr_t ptr) {
-	T ret;
-	memcpy(&ret, ptr, sizeof(ret));
-	return ret;
-}
-
-template <typename T>
-void Store(const T val, data_ptr_t ptr) {
-	memcpy(ptr, (void *)&val, sizeof(val));
-}
-
-//! This assigns a shared pointer, but ONLY assigns if "target" is not equal to "source"
-//! If this is often the case, this manner of assignment is significantly faster (~20X faster)
-//! Since it avoids the need of an atomic incref/decref at the cost of a single pointer comparison
-//! Benchmark: https://gist.github.com/Mytherin/4db3faa8e233c4a9b874b21f62bb4b96
-//! If the shared pointers are not the same, the penalty is very low (on the order of 1%~ slower)
-//! This method should always be preferred if there is a (reasonable) chance that the pointers are the same
-template<class T>
-void AssignSharedPointer(shared_ptr<T> &target, const shared_ptr<T> &source) {
-	if (target.get() != source.get()) {
-		target = source;
-	}
-}
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/assert.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-#if (defined(DUCKDB_USE_STANDARD_ASSERT) || !defined(DEBUG)) && !defined(DUCKDB_FORCE_ASSERT)
-
-#include <assert.h>
-#define D_ASSERT assert
-#else
-namespace duckdb {
-DUCKDB_API void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr);
-}
-
-#define D_ASSERT(condition) duckdb::DuckDBAssertInternal(bool(condition), #condition, __FILE__, __LINE__)
-
-#endif
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/exception_format_value.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/single_thread_ptr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-class RefCounter {
-public:
-	uint32_t pn;
-	RefCounter() : pn(1) {
-	}
-	void inc() {
-		++pn;
-	}
-	void dec() {
-		--pn;
-	}
-	uint32_t getPn() const {
-		return pn;
-	}
-	virtual ~RefCounter() {
-	}
-};
-
-namespace duckdb {
-template <typename T>
-class single_thread_ptr {
-public:
-	T *ptr;                // contained pointer
-	RefCounter *ref_count; // reference counter
-
-public:
-	// Default constructor, constructs an empty single_thread_ptr.
-	constexpr single_thread_ptr() : ptr(nullptr), ref_count(nullptr) {
-	}
-	// Construct empty single_thread_ptr.
-	constexpr single_thread_ptr(std::nullptr_t) : ptr(nullptr), ref_count(nullptr) {
-	}
-	// Construct a single_thread_ptr that wraps raw pointer.
-
-	single_thread_ptr(RefCounter *r, T *p) {
-		ptr = p;
-		ref_count = r;
-	}
-
-	template <class U>
-	single_thread_ptr(RefCounter *r, U *p) {
-		ptr = p;
-		ref_count = r;
-	}
-
-	// Copy  constructor.
-	single_thread_ptr(const single_thread_ptr &sp) : ptr(nullptr), ref_count(nullptr) {
-		if (sp.ptr) {
-			ptr = sp.ptr;
-			ref_count = sp.ref_count;
-			ref_count->inc();
-		}
-	}
-
-	// Conversion constructor.
-	template <typename U>
-	single_thread_ptr(const single_thread_ptr<U> &sp) : ptr(nullptr), ref_count(nullptr) {
-		if (sp.ptr) {
-			ptr = sp.ptr;
-			ref_count = sp.ref_count;
-			ref_count->inc();
-		}
-	}
-
-	// move  constructor.
-	single_thread_ptr(single_thread_ptr &&sp) noexcept : ptr {sp.ptr}, ref_count {sp.ref_count} {
-		sp.ptr = nullptr;
-		sp.ref_count = nullptr;
-	}
-
-	// move  constructor.
-	template <class U>
-	single_thread_ptr(single_thread_ptr<U> &&sp) noexcept : ptr {sp.ptr}, ref_count {sp.ref_count} {
-		sp.ptr = nullptr;
-		sp.ref_count = nullptr;
-	}
-
-	// No effect if single_thread_ptr is empty or use_count() > 1, otherwise release the resources.
-	~single_thread_ptr() {
-		release();
-	}
-
-	void release() {
-		if (ptr && ref_count) {
-			ref_count->dec();
-			if ((ref_count->getPn()) == 0) {
-				delete ref_count;
-			}
-		}
-		ref_count = nullptr;
-		ptr = nullptr;
-	}
-
-	// Copy assignment.
-	single_thread_ptr &operator=(single_thread_ptr sp) noexcept {
-		std::swap(this->ptr, sp.ptr);
-		std::swap(this->ref_count, sp.ref_count);
-		return *this;
-	}
-
-	// Dereference pointer to managed object.
-	T &operator*() const noexcept {
-		return *ptr;
-	}
-	T *operator->() const noexcept {
-		return ptr;
-	}
-
-	// Return the contained pointer.
-	T *get() const noexcept {
-		return ptr;
-	}
-
-	// Return use count (use count == 0 if single_thread_ptr is empty).
-	long use_count() const noexcept {
-		if (ptr)
-			return ref_count->getPn();
-		else
-			return 0;
-	}
-
-	// Check if there is an associated managed object.
-	explicit operator bool() const noexcept {
-		return (ptr);
-	}
-
-	// Resets single_thread_ptr to empty.
-	void reset() noexcept {
-		release();
-	}
-};
-
-template <class T>
-struct _object_and_block : public RefCounter {
-	T object;
-
-	template <class... Args>
-	explicit _object_and_block(Args &&... args) : object(std::forward<Args>(args)...) {
-	}
-};
-
-// Operator overloading.
-template <typename T, typename U>
-inline bool operator==(const single_thread_ptr<T> &sp1, const single_thread_ptr<U> &sp2) {
-	return sp1.get() == sp2.get();
-}
-
-template <typename T>
-inline bool operator==(const single_thread_ptr<T> &sp, std::nullptr_t) noexcept {
-	return !sp;
-}
-
-template <typename T, typename U>
-inline bool operator!=(const single_thread_ptr<T> &sp1, const single_thread_ptr<U> &sp2) {
-	return sp1.get() != sp2.get();
-}
-
-template <typename T>
-inline bool operator!=(const single_thread_ptr<T> &sp, std::nullptr_t) noexcept {
-	return sp.get();
-}
-
-template <typename T>
-inline bool operator!=(std::nullptr_t, const single_thread_ptr<T> &sp) noexcept {
-	return sp.get();
-}
-
-template <class T, class... Args>
-single_thread_ptr<T> single_thread_make_shared(Args &&... args) {
-	auto tmp_object = new _object_and_block<T>(std::forward<Args>(args)...);
-	return single_thread_ptr<T>(tmp_object, &(tmp_object->object));
-}
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <vector>
-
-namespace duckdb {
-using std::vector;
-}
-
-
-#include <limits>
-
-namespace duckdb {
-
-class Serializer;
-class Deserializer;
-class Value;
-class TypeCatalogEntry;
-class Vector;
-//! Type used to represent dates (days since 1970-01-01)
-struct date_t { // NOLINT
-	int32_t days;
-
-	date_t() = default;
-	explicit inline date_t(int32_t days_p) : days(days_p) {}
-
-	// explicit conversion
-	explicit inline operator int32_t() const {return days;}
-
-	// comparison operators
-	inline bool operator==(const date_t &rhs) const {return days == rhs.days;};
-	inline bool operator!=(const date_t &rhs) const {return days != rhs.days;};
-	inline bool operator<=(const date_t &rhs) const {return days <= rhs.days;};
-	inline bool operator<(const date_t &rhs) const {return days < rhs.days;};
-	inline bool operator>(const date_t &rhs) const {return days > rhs.days;};
-	inline bool operator>=(const date_t &rhs) const {return days >= rhs.days;};
-
-	// arithmetic operators
-	inline date_t operator+(const int32_t &days) const {return date_t(this->days + days);};
-	inline date_t operator-(const int32_t &days) const {return date_t(this->days - days);};
-
-	// in-place operators
-	inline date_t &operator+=(const int32_t &days) {this->days += days; return *this;};
-	inline date_t &operator-=(const int32_t &days) {this->days -= days; return *this;};
-
-	// special values
-	static inline date_t infinity() {return date_t(std::numeric_limits<int32_t>::max()); } // NOLINT
-	static inline date_t ninfinity() {return date_t(-std::numeric_limits<int32_t>::max()); } // NOLINT
-	static inline date_t epoch() {return date_t(0); } // NOLINT
-};
-
-//! Type used to represent time (microseconds)
-struct dtime_t { // NOLINT
-    int64_t micros;
-
-	dtime_t() = default;
-	explicit inline dtime_t(int64_t micros_p) : micros(micros_p) {}
-	inline dtime_t& operator=(int64_t micros_p) {micros = micros_p; return *this;}
-
-	// explicit conversion
-	explicit inline operator int64_t() const {return micros;}
-	explicit inline operator double() const {return micros;}
-
-	// comparison operators
-	inline bool operator==(const dtime_t &rhs) const {return micros == rhs.micros;};
-	inline bool operator!=(const dtime_t &rhs) const {return micros != rhs.micros;};
-	inline bool operator<=(const dtime_t &rhs) const {return micros <= rhs.micros;};
-	inline bool operator<(const dtime_t &rhs) const {return micros < rhs.micros;};
-	inline bool operator>(const dtime_t &rhs) const {return micros > rhs.micros;};
-	inline bool operator>=(const dtime_t &rhs) const {return micros >= rhs.micros;};
-
-	// arithmetic operators
-	inline dtime_t operator+(const int64_t &micros) const {return dtime_t(this->micros + micros);};
-	inline dtime_t operator+(const double &micros) const {return dtime_t(this->micros + int64_t(micros));};
-	inline dtime_t operator-(const int64_t &micros) const {return dtime_t(this->micros - micros);};
-	inline dtime_t operator*(const idx_t &copies) const {return dtime_t(this->micros * copies);};
-	inline dtime_t operator/(const idx_t &copies) const {return dtime_t(this->micros / copies);};
-	inline int64_t operator-(const dtime_t &other) const {return this->micros - other.micros;};
-
-	// in-place operators
-	inline dtime_t &operator+=(const int64_t &micros) {this->micros += micros; return *this;};
-	inline dtime_t &operator-=(const int64_t &micros) {this->micros -= micros; return *this;};
-	inline dtime_t &operator+=(const dtime_t &other) {this->micros += other.micros; return *this;};
-
-	// special values
-	static inline dtime_t allballs() {return dtime_t(0); } // NOLINT
-};
-
-//! Type used to represent timestamps (seconds,microseconds,milliseconds or nanoseconds since 1970-01-01)
-struct timestamp_t { // NOLINT
-    int64_t value;
-
-	timestamp_t() = default;
-	explicit inline timestamp_t(int64_t value_p) : value(value_p) {}
-	inline timestamp_t& operator=(int64_t value_p) {value = value_p; return *this;}
-
-	// explicit conversion
-	explicit inline operator int64_t() const {return value;}
-
-	// comparison operators
-	inline bool operator==(const timestamp_t &rhs) const {return value == rhs.value;};
-	inline bool operator!=(const timestamp_t &rhs) const {return value != rhs.value;};
-	inline bool operator<=(const timestamp_t &rhs) const {return value <= rhs.value;};
-	inline bool operator<(const timestamp_t &rhs) const {return value < rhs.value;};
-	inline bool operator>(const timestamp_t &rhs) const {return value > rhs.value;};
-	inline bool operator>=(const timestamp_t &rhs) const {return value >= rhs.value;};
-
-	// arithmetic operators
-	inline timestamp_t operator+(const double &value) const {return timestamp_t(this->value + int64_t(value));};
-	inline int64_t operator-(const timestamp_t &other) const {return this->value - other.value;};
-
-	// in-place operators
-	inline timestamp_t &operator+=(const int64_t &value) {this->value += value; return *this;};
-	inline timestamp_t &operator-=(const int64_t &value) {this->value -= value; return *this;};
-
-	// special values
-	static inline timestamp_t infinity() {return timestamp_t(std::numeric_limits<int64_t>::max()); } // NOLINT
-	static inline timestamp_t ninfinity() {return timestamp_t(-std::numeric_limits<int64_t>::max()); } // NOLINT
-	static inline timestamp_t epoch() {return timestamp_t(0); } // NOLINT
-};
-
-struct interval_t {
-	int32_t months;
-	int32_t days;
-	int64_t micros;
-
-	inline bool operator==(const interval_t &rhs) const {
-		return this->days == rhs.days && this->months == rhs.months && this->micros == rhs.micros;
-	}
-};
-
-struct hugeint_t {
-public:
-	uint64_t lower;
-	int64_t upper;
-
-public:
-	hugeint_t() = default;
-	hugeint_t(int64_t value); // NOLINT: Allow implicit conversion from `int64_t`
-	hugeint_t(const hugeint_t &rhs) = default;
-	hugeint_t(hugeint_t &&rhs) = default;
-	hugeint_t &operator=(const hugeint_t &rhs) = default;
-	hugeint_t &operator=(hugeint_t &&rhs) = default;
-
-	DUCKDB_API string ToString() const;
-
-	// comparison operators
-	bool operator==(const hugeint_t &rhs) const;
-	bool operator!=(const hugeint_t &rhs) const;
-	bool operator<=(const hugeint_t &rhs) const;
-	bool operator<(const hugeint_t &rhs) const;
-	bool operator>(const hugeint_t &rhs) const;
-	bool operator>=(const hugeint_t &rhs) const;
-
-	// arithmetic operators
-	hugeint_t operator+(const hugeint_t &rhs) const;
-	hugeint_t operator-(const hugeint_t &rhs) const;
-	hugeint_t operator*(const hugeint_t &rhs) const;
-	hugeint_t operator/(const hugeint_t &rhs) const;
-	hugeint_t operator%(const hugeint_t &rhs) const;
-	hugeint_t operator-() const;
-
-	// bitwise operators
-	hugeint_t operator>>(const hugeint_t &rhs) const;
-	hugeint_t operator<<(const hugeint_t &rhs) const;
-	hugeint_t operator&(const hugeint_t &rhs) const;
-	hugeint_t operator|(const hugeint_t &rhs) const;
-	hugeint_t operator^(const hugeint_t &rhs) const;
-	hugeint_t operator~() const;
-
-	// in-place operators
-	hugeint_t &operator+=(const hugeint_t &rhs);
-	hugeint_t &operator-=(const hugeint_t &rhs);
-	hugeint_t &operator*=(const hugeint_t &rhs);
-	hugeint_t &operator/=(const hugeint_t &rhs);
-	hugeint_t &operator%=(const hugeint_t &rhs);
-	hugeint_t &operator>>=(const hugeint_t &rhs);
-	hugeint_t &operator<<=(const hugeint_t &rhs);
-	hugeint_t &operator&=(const hugeint_t &rhs);
-	hugeint_t &operator|=(const hugeint_t &rhs);
-	hugeint_t &operator^=(const hugeint_t &rhs);
-};
-
-struct string_t;
-
-template <class T>
-using child_list_t = std::vector<std::pair<std::string, T>>;
-// we should be using single_thread_ptr here but cross-thread access to ChunkCollections currently prohibits this.
-template <class T>
-using buffer_ptr = shared_ptr<T>;
-
-template <class T, typename... Args>
-buffer_ptr<T> make_buffer(Args &&...args) {
-	return make_shared<T>(std::forward<Args>(args)...);
-}
-
-struct list_entry_t {
-	list_entry_t() = default;
-	list_entry_t(uint64_t offset, uint64_t length) : offset(offset), length(length) {
-	}
-
-	uint64_t offset;
-	uint64_t length;
-};
-
-//===--------------------------------------------------------------------===//
-// Internal Types
-//===--------------------------------------------------------------------===//
-
-// taken from arrow's type.h
-enum class PhysicalType : uint8_t {
-	/// A NULL type having no physical storage
-	NA = 0,
-
-	/// Boolean as 8 bit "bool" value
-	BOOL = 1,
-
-	/// Unsigned 8-bit little-endian integer
-	UINT8 = 2,
-
-	/// Signed 8-bit little-endian integer
-	INT8 = 3,
-
-	/// Unsigned 16-bit little-endian integer
-	UINT16 = 4,
-
-	/// Signed 16-bit little-endian integer
-	INT16 = 5,
-
-	/// Unsigned 32-bit little-endian integer
-	UINT32 = 6,
-
-	/// Signed 32-bit little-endian integer
-	INT32 = 7,
-
-	/// Unsigned 64-bit little-endian integer
-	UINT64 = 8,
-
-	/// Signed 64-bit little-endian integer
-	INT64 = 9,
-
-	/// 2-byte floating point value
-	HALF_FLOAT = 10,
-
-	/// 4-byte floating point value
-	FLOAT = 11,
-
-	/// 8-byte floating point value
-	DOUBLE = 12,
-
-	/// UTF8 variable-length string as List<Char>
-	STRING = 13,
-
-	/// Variable-length bytes (no guarantee of UTF8-ness)
-	BINARY = 14,
-
-	/// Fixed-size binary. Each value occupies the same number of bytes
-	FIXED_SIZE_BINARY = 15,
-
-	/// int32_t days since the UNIX epoch
-	DATE32 = 16,
-
-	/// int64_t milliseconds since the UNIX epoch
-	DATE64 = 17,
-
-	/// Exact timestamp encoded with int64 since UNIX epoch
-	/// Default unit millisecond
-	TIMESTAMP = 18,
-
-	/// Time as signed 32-bit integer, representing either seconds or
-	/// milliseconds since midnight
-	TIME32 = 19,
-
-	/// Time as signed 64-bit integer, representing either microseconds or
-	/// nanoseconds since midnight
-	TIME64 = 20,
-
-	/// YEAR_MONTH or DAY_TIME interval in SQL style
-	INTERVAL = 21,
-
-	/// Precision- and scale-based decimal type. Storage type depends on the
-	/// parameters.
-	// DECIMAL = 22,
-
-	/// A list of some logical data type
-	LIST = 23,
-
-	/// Struct of logical types
-	STRUCT = 24,
-
-	/// Unions of logical types
-	UNION = 25,
-
-	/// Dictionary-encoded type, also called "categorical" or "factor"
-	/// in other programming languages. Holds the dictionary value
-	/// type but not the dictionary itself, which is part of the
-	/// ArrayData struct
-	DICTIONARY = 26,
-
-	/// Map, a repeated struct logical type
-	MAP = 27,
-
-	/// Custom data type, implemented by user
-	EXTENSION = 28,
-
-	/// Fixed size list of some logical type
-	FIXED_SIZE_LIST = 29,
-
-	/// Measure of elapsed time in either seconds, milliseconds, microseconds
-	/// or nanoseconds.
-	DURATION = 30,
-
-	/// Like STRING, but with 64-bit offsets
-	LARGE_STRING = 31,
-
-	/// Like BINARY, but with 64-bit offsets
-	LARGE_BINARY = 32,
-
-	/// Like LIST, but with 64-bit offsets
-	LARGE_LIST = 33,
-
-	/// DuckDB Extensions
-	VARCHAR = 200, // our own string representation, different from STRING and LARGE_STRING above
-	INT128 = 204, // 128-bit integers
-	UNKNOWN = 205, // Unknown physical type of user defined types
-	/// Boolean as 1 bit, LSB bit-packed ordering
-	BIT = 206,
-
-	INVALID = 255
-};
-
-//===--------------------------------------------------------------------===//
-// SQL Types
-//===--------------------------------------------------------------------===//
-enum class LogicalTypeId : uint8_t {
-	INVALID = 0,
-	SQLNULL = 1, /* NULL type, used for constant NULL */
-	UNKNOWN = 2, /* unknown type, used for parameter expressions */
-	ANY = 3,     /* ANY type, used for functions that accept any type as parameter */
-	USER = 4, /* A User Defined Type (e.g., ENUMs before the binder) */
-	BOOLEAN = 10,
-	TINYINT = 11,
-	SMALLINT = 12,
-	INTEGER = 13,
-	BIGINT = 14,
-	DATE = 15,
-	TIME = 16,
-	TIMESTAMP_SEC = 17,
-	TIMESTAMP_MS = 18,
-	TIMESTAMP = 19, //! us
-	TIMESTAMP_NS = 20,
-	DECIMAL = 21,
-	FLOAT = 22,
-	DOUBLE = 23,
-	CHAR = 24,
-	VARCHAR = 25,
-	BLOB = 26,
-	INTERVAL = 27,
-	UTINYINT = 28,
-	USMALLINT = 29,
-	UINTEGER = 30,
-	UBIGINT = 31,
-	TIMESTAMP_TZ = 32,
-	TIME_TZ = 34,
-	JSON = 35,
-
-	HUGEINT = 50,
-	POINTER = 51,
-	// HASH = 52, // deprecated, uses UBIGINT instead
-	VALIDITY = 53,
-	UUID = 54,
-
-	STRUCT = 100,
-	LIST = 101,
-	MAP = 102,
-	TABLE = 103,
-	ENUM = 104,
-	AGGREGATE_STATE = 105
-};
-
-struct ExtraTypeInfo;
-
-
-struct aggregate_state_t;
-
-struct LogicalType {
-	DUCKDB_API LogicalType();
-	DUCKDB_API LogicalType(LogicalTypeId id); // NOLINT: Allow implicit conversion from `LogicalTypeId`
-	DUCKDB_API LogicalType(LogicalTypeId id, shared_ptr<ExtraTypeInfo> type_info);
-	DUCKDB_API LogicalType(const LogicalType &other);
-	DUCKDB_API LogicalType(LogicalType &&other) noexcept;
-
-	DUCKDB_API ~LogicalType();
-
-	inline LogicalTypeId id() const {
-		return id_;
-	}
-	inline PhysicalType InternalType() const {
-		return physical_type_;
-	}
-	inline const ExtraTypeInfo *AuxInfo() const {
-		return type_info_.get();
-	}
-
-	// copy assignment
-	inline LogicalType& operator=(const LogicalType &other) {
-		id_ = other.id_;
-		physical_type_ = other.physical_type_;
-		type_info_ = other.type_info_;
-		return *this;
-	}
-	// move assignment
-	inline LogicalType& operator=(LogicalType&& other) noexcept {
-		id_ = other.id_;
-		physical_type_ = other.physical_type_;
-		type_info_ = std::move(other.type_info_);
-		return *this;
-	}
-
-	DUCKDB_API bool operator==(const LogicalType &rhs) const;
-	inline bool operator!=(const LogicalType &rhs) const {
-		return !(*this == rhs);
-	}
-
-	//! Serializes a LogicalType to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	//! Deserializes a blob back into an LogicalType
-	DUCKDB_API static LogicalType Deserialize(Deserializer &source);
-
-	DUCKDB_API string ToString() const;
-	DUCKDB_API bool IsIntegral() const;
-	DUCKDB_API bool IsNumeric() const;
-	DUCKDB_API hash_t Hash() const;
-	DUCKDB_API void SetAlias(string &alias);
-	DUCKDB_API string GetAlias() const;
-
-	DUCKDB_API static LogicalType MaxLogicalType(const LogicalType &left, const LogicalType &right);
-	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
-	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
-
-	//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
-	DUCKDB_API bool GetDecimalProperties(uint8_t &width, uint8_t &scale) const;
-
-	DUCKDB_API void Verify() const;
-
-private:
-	LogicalTypeId id_;
-	PhysicalType physical_type_;
-	shared_ptr<ExtraTypeInfo> type_info_;
-
-private:
-	PhysicalType GetInternalType();
-
-public:
-	static constexpr const LogicalTypeId SQLNULL = LogicalTypeId::SQLNULL;
-	static constexpr const LogicalTypeId BOOLEAN = LogicalTypeId::BOOLEAN;
-	static constexpr const LogicalTypeId TINYINT = LogicalTypeId::TINYINT;
-	static constexpr const LogicalTypeId UTINYINT = LogicalTypeId::UTINYINT;
-	static constexpr const LogicalTypeId SMALLINT = LogicalTypeId::SMALLINT;
-	static constexpr const LogicalTypeId USMALLINT = LogicalTypeId::USMALLINT;
-	static constexpr const LogicalTypeId INTEGER = LogicalTypeId::INTEGER;
-	static constexpr const LogicalTypeId UINTEGER = LogicalTypeId::UINTEGER;
-	static constexpr const LogicalTypeId BIGINT = LogicalTypeId::BIGINT;
-	static constexpr const LogicalTypeId UBIGINT = LogicalTypeId::UBIGINT;
-	static constexpr const LogicalTypeId FLOAT = LogicalTypeId::FLOAT;
-	static constexpr const LogicalTypeId DOUBLE = LogicalTypeId::DOUBLE;
-	static constexpr const LogicalTypeId DATE = LogicalTypeId::DATE;
-	static constexpr const LogicalTypeId TIMESTAMP = LogicalTypeId::TIMESTAMP;
-	static constexpr const LogicalTypeId TIMESTAMP_S = LogicalTypeId::TIMESTAMP_SEC;
-	static constexpr const LogicalTypeId TIMESTAMP_MS = LogicalTypeId::TIMESTAMP_MS;
-	static constexpr const LogicalTypeId TIMESTAMP_NS = LogicalTypeId::TIMESTAMP_NS;
-	static constexpr const LogicalTypeId TIME = LogicalTypeId::TIME;
-	static constexpr const LogicalTypeId TIMESTAMP_TZ = LogicalTypeId::TIMESTAMP_TZ;
-	static constexpr const LogicalTypeId TIME_TZ = LogicalTypeId::TIME_TZ;
-	static constexpr const LogicalTypeId VARCHAR = LogicalTypeId::VARCHAR;
-	static constexpr const LogicalTypeId ANY = LogicalTypeId::ANY;
-	static constexpr const LogicalTypeId BLOB = LogicalTypeId::BLOB;
-	static constexpr const LogicalTypeId INTERVAL = LogicalTypeId::INTERVAL;
-	static constexpr const LogicalTypeId HUGEINT = LogicalTypeId::HUGEINT;
-	static constexpr const LogicalTypeId UUID = LogicalTypeId::UUID;
-	static constexpr const LogicalTypeId HASH = LogicalTypeId::UBIGINT;
-	static constexpr const LogicalTypeId POINTER = LogicalTypeId::POINTER;
-	static constexpr const LogicalTypeId TABLE = LogicalTypeId::TABLE;
-	static constexpr const LogicalTypeId INVALID = LogicalTypeId::INVALID;
-	static constexpr const LogicalTypeId JSON = LogicalTypeId::JSON;
-	static constexpr const LogicalTypeId ROW_TYPE = LogicalTypeId::BIGINT;
-
-	// explicitly allowing these functions to be capitalized to be in-line with the remaining functions
-	DUCKDB_API static LogicalType DECIMAL(int width, int scale);                 // NOLINT
-	DUCKDB_API static LogicalType VARCHAR_COLLATION(string collation);           // NOLINT
-	DUCKDB_API static LogicalType LIST( LogicalType child);                       // NOLINT
-	DUCKDB_API static LogicalType STRUCT( child_list_t<LogicalType> children);    // NOLINT
-	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type);    // NOLINT
-	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT
-	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value); // NOLINT
-	DUCKDB_API static LogicalType ENUM(const string &enum_name, Vector &ordered_data, idx_t size); // NOLINT
-	DUCKDB_API static LogicalType DEDUP_POINTER_ENUM(); // NOLINT
-	DUCKDB_API static LogicalType USER(const string &user_type_name); // NOLINT
-	//! A list of all NUMERIC types (integral and floating point types)
-	DUCKDB_API static const vector<LogicalType> Numeric();
-	//! A list of all INTEGRAL types
-	DUCKDB_API static const vector<LogicalType> Integral();
-	//! A list of ALL SQL types
-	DUCKDB_API static const vector<LogicalType> AllTypes();
-};
-
-struct DecimalType {
-	DUCKDB_API static uint8_t GetWidth(const LogicalType &type);
-	DUCKDB_API static uint8_t GetScale(const LogicalType &type);
-	DUCKDB_API static uint8_t MaxWidth();
-};
-
-struct StringType {
-	DUCKDB_API static string GetCollation(const LogicalType &type);
-};
-
-struct ListType {
-	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type);
-};
-
-struct UserType{
-	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
-};
-
-struct EnumType{
-	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
-	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string& key);
-	DUCKDB_API static Vector &GetValuesInsertOrder(const LogicalType &type);
-	DUCKDB_API static idx_t GetSize(const LogicalType &type);
-	DUCKDB_API static const string GetValue(const Value &val);
-	DUCKDB_API static void SetCatalog(LogicalType &type, TypeCatalogEntry* catalog_entry);
-	DUCKDB_API static TypeCatalogEntry* GetCatalog(const LogicalType &type);
-	DUCKDB_API static PhysicalType GetPhysicalType(const LogicalType &type);
-};
-
-struct StructType {
-	DUCKDB_API static const child_list_t<LogicalType> &GetChildTypes(const LogicalType &type);
-	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type, idx_t index);
-	DUCKDB_API static const string &GetChildName(const LogicalType &type, idx_t index);
-	DUCKDB_API static idx_t GetChildCount(const LogicalType &type);
-};
-
-struct MapType {
-	DUCKDB_API static const LogicalType &KeyType(const LogicalType &type);
-	DUCKDB_API static const LogicalType &ValueType(const LogicalType &type);
-};
-
-struct AggregateStateType {
-	DUCKDB_API static const string GetTypeName(const LogicalType &type);
-	DUCKDB_API static const aggregate_state_t &GetStateType(const LogicalType &type);
-};
-
-
-DUCKDB_API string LogicalTypeIdToString(LogicalTypeId type);
-
-DUCKDB_API LogicalTypeId TransformStringToLogicalTypeId(const string &str);
-
-DUCKDB_API LogicalType TransformStringToLogicalType(const string &str);
-
-//! Returns the PhysicalType for the given type
-template <class T>
-PhysicalType GetTypeId() {
-	if (std::is_same<T, bool>()) {
-		return PhysicalType::BOOL;
-	} else if (std::is_same<T, int8_t>()) {
-		return PhysicalType::INT8;
-	} else if (std::is_same<T, int16_t>()) {
-		return PhysicalType::INT16;
-	} else if (std::is_same<T, int32_t>()) {
-		return PhysicalType::INT32;
-	} else if (std::is_same<T, int64_t>()) {
-		return PhysicalType::INT64;
-	} else if (std::is_same<T, uint8_t>()) {
-		return PhysicalType::UINT8;
-	} else if (std::is_same<T, uint16_t>()) {
-		return PhysicalType::UINT16;
-	} else if (std::is_same<T, uint32_t>()) {
-		return PhysicalType::UINT32;
-	} else if (std::is_same<T, uint64_t>()) {
-		return PhysicalType::UINT64;
-	} else if (std::is_same<T, hugeint_t>()) {
-		return PhysicalType::INT128;
-	} else if (std::is_same<T, date_t>()) {
-		return PhysicalType::DATE32;
-	} else if (std::is_same<T, dtime_t>()) {
-		return PhysicalType::TIME32;
-	} else if (std::is_same<T, timestamp_t>()) {
-		return PhysicalType::TIMESTAMP;
-	} else if (std::is_same<T, float>()) {
-		return PhysicalType::FLOAT;
-	} else if (std::is_same<T, double>()) {
-		return PhysicalType::DOUBLE;
-	} else if (std::is_same<T, const char *>() || std::is_same<T, char *>() || std::is_same<T, string_t>()) {
-		return PhysicalType::VARCHAR;
-	} else if (std::is_same<T, interval_t>()) {
-		return PhysicalType::INTERVAL;
-	} else {
-		return PhysicalType::INVALID;
-	}
-}
-
-template<class T>
-bool TypeIsNumber() {
-	return std::is_integral<T>() || std::is_floating_point<T>() || std::is_same<T, hugeint_t>();
-}
-
-template <class T>
-bool IsValidType() {
-	return GetTypeId<T>() != PhysicalType::INVALID;
-}
-
-//! The PhysicalType used by the row identifiers column
-extern const PhysicalType ROW_TYPE;
-
-DUCKDB_API string TypeIdToString(PhysicalType type);
-idx_t GetTypeIdSize(PhysicalType type);
-bool TypeIsConstantSize(PhysicalType type);
-bool TypeIsIntegral(PhysicalType type);
-bool TypeIsNumeric(PhysicalType type);
-bool TypeIsInteger(PhysicalType type);
-
-template <class T>
-bool IsIntegerType() {
-	return TypeIsIntegral(GetTypeId<T>());
-}
-
-bool ApproxEqual(float l, float r);
-bool ApproxEqual(double l, double r);
-
-struct aggregate_state_t {
-	aggregate_state_t(string function_name_p, LogicalType return_type_p, vector<LogicalType> bound_argument_types_p) : function_name(std::move(function_name_p)), return_type(std::move(return_type_p)), bound_argument_types(std::move(bound_argument_types_p)) {
-	}
-
-	string function_name;
-	LogicalType return_type;
-	vector<LogicalType> bound_argument_types;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-enum class ExceptionFormatValueType : uint8_t {
-	FORMAT_VALUE_TYPE_DOUBLE,
-	FORMAT_VALUE_TYPE_INTEGER,
-	FORMAT_VALUE_TYPE_STRING
-};
-
-struct ExceptionFormatValue {
-	DUCKDB_API ExceptionFormatValue(double dbl_val);   // NOLINT
-	DUCKDB_API ExceptionFormatValue(int64_t int_val);  // NOLINT
-	DUCKDB_API ExceptionFormatValue(string str_val);   // NOLINT
-	DUCKDB_API ExceptionFormatValue(hugeint_t hg_val); // NOLINT
-
-	ExceptionFormatValueType type;
-
-	double dbl_val = 0;
-	int64_t int_val = 0;
-	string str_val;
-
-public:
-	template <class T>
-	static ExceptionFormatValue CreateFormatValue(T value) {
-		return int64_t(value);
-	}
-	static string Format(const string &msg, vector<ExceptionFormatValue> &values);
-};
-
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(LogicalType value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(double value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(const char *value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(char *value);
-template <>
-DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value);
-
-} // namespace duckdb
-
-
-
-#include <stdexcept>
-
-namespace duckdb {
-enum class PhysicalType : uint8_t;
-struct LogicalType;
-struct hugeint_t;
-
-inline void assert_restrict_function(void *left_start, void *left_end, void *right_start, void *right_end,
-                                     const char *fname, int linenr) {
-	// assert that the two pointers do not overlap
-#ifdef DEBUG
-	if (!(left_end <= right_start || right_end <= left_start)) {
-		printf("ASSERT RESTRICT FAILED: %s:%d\n", fname, linenr);
-		D_ASSERT(0);
-	}
-#endif
-}
-
-#define ASSERT_RESTRICT(left_start, left_end, right_start, right_end)                                                  \
-	assert_restrict_function(left_start, left_end, right_start, right_end, __FILE__, __LINE__)
-
-//===--------------------------------------------------------------------===//
-// Exception Types
-//===--------------------------------------------------------------------===//
-
-enum class ExceptionType {
-	INVALID = 0,          // invalid type
-	OUT_OF_RANGE = 1,     // value out of range error
-	CONVERSION = 2,       // conversion/casting error
-	UNKNOWN_TYPE = 3,     // unknown type
-	DECIMAL = 4,          // decimal related
-	MISMATCH_TYPE = 5,    // type mismatch
-	DIVIDE_BY_ZERO = 6,   // divide by 0
-	OBJECT_SIZE = 7,      // object size exceeded
-	INVALID_TYPE = 8,     // incompatible for operation
-	SERIALIZATION = 9,    // serialization
-	TRANSACTION = 10,     // transaction management
-	NOT_IMPLEMENTED = 11, // method not implemented
-	EXPRESSION = 12,      // expression parsing
-	CATALOG = 13,         // catalog related
-	PARSER = 14,          // parser related
-	PLANNER = 15,         // planner related
-	SCHEDULER = 16,       // scheduler related
-	EXECUTOR = 17,        // executor related
-	CONSTRAINT = 18,      // constraint related
-	INDEX = 19,           // index related
-	STAT = 20,            // stat related
-	CONNECTION = 21,      // connection related
-	SYNTAX = 22,          // syntax related
-	SETTINGS = 23,        // settings related
-	BINDER = 24,          // binder related
-	NETWORK = 25,         // network related
-	OPTIMIZER = 26,       // optimizer related
-	NULL_POINTER = 27,    // nullptr exception
-	IO = 28,              // IO exception
-	INTERRUPT = 29,       // interrupt
-	FATAL = 30, // Fatal exception: fatal exceptions are non-recoverable, and render the entire DB in an unusable state
-	INTERNAL =
-	    31, // Internal exception: exception that indicates something went wrong internally (i.e. bug in the code base)
-	INVALID_INPUT = 32, // Input or arguments error
-	OUT_OF_MEMORY = 33, // out of memory
-	PERMISSION = 34     // insufficient permissions
-};
-
-class Exception : public std::exception {
-public:
-	DUCKDB_API explicit Exception(const string &msg);
-	DUCKDB_API Exception(ExceptionType exception_type, const string &message);
-
-	ExceptionType type;
-
-public:
-	DUCKDB_API const char *what() const noexcept override;
-
-	DUCKDB_API string ExceptionTypeToString(ExceptionType type);
-
-	template <typename... Args>
-	static string ConstructMessage(const string &msg, Args... params) {
-		vector<ExceptionFormatValue> values;
-		return ConstructMessageRecursive(msg, values, params...);
-	}
-
-	DUCKDB_API static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values);
-
-	template <class T, typename... Args>
-	static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values, T param,
-	                                        Args... params) {
-		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
-		return ConstructMessageRecursive(msg, values, params...);
-	}
-
-	DUCKDB_API static bool UncaughtException();
-
-private:
-	string exception_message_;
-};
-
-//===--------------------------------------------------------------------===//
-// Exception derived classes
-//===--------------------------------------------------------------------===//
-
-//! Exceptions that are StandardExceptions do NOT invalidate the current transaction when thrown
-class StandardException : public Exception {
-public:
-	DUCKDB_API StandardException(ExceptionType exception_type, const string &message);
-};
-
-class CatalogException : public StandardException {
-public:
-	DUCKDB_API explicit CatalogException(const string &msg);
-
-	template <typename... Args>
-	explicit CatalogException(const string &msg, Args... params) : CatalogException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class ParserException : public StandardException {
-public:
-	DUCKDB_API explicit ParserException(const string &msg);
-
-	template <typename... Args>
-	explicit ParserException(const string &msg, Args... params) : ParserException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class PermissionException : public StandardException {
-public:
-	DUCKDB_API explicit PermissionException(const string &msg);
-
-	template <typename... Args>
-	explicit PermissionException(const string &msg, Args... params)
-	    : PermissionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class BinderException : public StandardException {
-public:
-	DUCKDB_API explicit BinderException(const string &msg);
-
-	template <typename... Args>
-	explicit BinderException(const string &msg, Args... params) : BinderException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class ConversionException : public Exception {
-public:
-	DUCKDB_API explicit ConversionException(const string &msg);
-
-	template <typename... Args>
-	explicit ConversionException(const string &msg, Args... params)
-	    : ConversionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class TransactionException : public Exception {
-public:
-	DUCKDB_API explicit TransactionException(const string &msg);
-
-	template <typename... Args>
-	explicit TransactionException(const string &msg, Args... params)
-	    : TransactionException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class NotImplementedException : public Exception {
-public:
-	DUCKDB_API explicit NotImplementedException(const string &msg);
-
-	template <typename... Args>
-	explicit NotImplementedException(const string &msg, Args... params)
-	    : NotImplementedException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class OutOfRangeException : public Exception {
-public:
-	DUCKDB_API explicit OutOfRangeException(const string &msg);
-
-	template <typename... Args>
-	explicit OutOfRangeException(const string &msg, Args... params)
-	    : OutOfRangeException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class OutOfMemoryException : public Exception {
-public:
-	DUCKDB_API explicit OutOfMemoryException(const string &msg);
-
-	template <typename... Args>
-	explicit OutOfMemoryException(const string &msg, Args... params)
-	    : OutOfMemoryException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class SyntaxException : public Exception {
-public:
-	DUCKDB_API explicit SyntaxException(const string &msg);
-
-	template <typename... Args>
-	explicit SyntaxException(const string &msg, Args... params) : SyntaxException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class ConstraintException : public Exception {
-public:
-	DUCKDB_API explicit ConstraintException(const string &msg);
-
-	template <typename... Args>
-	explicit ConstraintException(const string &msg, Args... params)
-	    : ConstraintException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class IOException : public Exception {
-public:
-	DUCKDB_API explicit IOException(const string &msg);
-
-	template <typename... Args>
-	explicit IOException(const string &msg, Args... params) : IOException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class SerializationException : public Exception {
-public:
-	DUCKDB_API explicit SerializationException(const string &msg);
-
-	template <typename... Args>
-	explicit SerializationException(const string &msg, Args... params)
-	    : SerializationException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class SequenceException : public Exception {
-public:
-	DUCKDB_API explicit SequenceException(const string &msg);
-
-	template <typename... Args>
-	explicit SequenceException(const string &msg, Args... params)
-	    : SequenceException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class InterruptException : public Exception {
-public:
-	DUCKDB_API InterruptException();
-};
-
-class FatalException : public Exception {
-public:
-	DUCKDB_API explicit FatalException(const string &msg);
-
-	template <typename... Args>
-	explicit FatalException(const string &msg, Args... params) : FatalException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class InternalException : public Exception {
-public:
-	DUCKDB_API explicit InternalException(const string &msg);
-
-	template <typename... Args>
-	explicit InternalException(const string &msg, Args... params)
-	    : InternalException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class InvalidInputException : public Exception {
-public:
-	DUCKDB_API explicit InvalidInputException(const string &msg);
-
-	template <typename... Args>
-	explicit InvalidInputException(const string &msg, Args... params)
-	    : InvalidInputException(ConstructMessage(msg, params...)) {
-	}
-};
-
-class CastException : public Exception {
-public:
-	DUCKDB_API CastException(const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API CastException(const LogicalType &origType, const LogicalType &newType);
-};
-
-class InvalidTypeException : public Exception {
-public:
-	DUCKDB_API InvalidTypeException(PhysicalType type, const string &msg);
-	DUCKDB_API InvalidTypeException(const LogicalType &type, const string &msg);
-};
-
-class TypeMismatchException : public Exception {
-public:
-	DUCKDB_API TypeMismatchException(const PhysicalType type_1, const PhysicalType type_2, const string &msg);
-	DUCKDB_API TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg);
-};
-
-class ValueOutOfRangeException : public Exception {
-public:
-	DUCKDB_API ValueOutOfRangeException(const int64_t value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API ValueOutOfRangeException(const hugeint_t value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API ValueOutOfRangeException(const double value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API ValueOutOfRangeException(const PhysicalType varType, const idx_t length);
-};
-
-} // namespace duckdb
-
-
-#include <type_traits>
-
-namespace duckdb {
-
-//! The Serialize class is a base class that can be used to serializing objects into a binary buffer
-class Serializer {
-public:
-	virtual ~Serializer() {
-	}
-
-	virtual void WriteData(const_data_ptr_t buffer, idx_t write_size) = 0;
-
-	template <class T>
-	void Write(T element) {
-		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
-
-		WriteData((const_data_ptr_t)&element, sizeof(T));
-	}
-
-	//! Write data from a string buffer directly (without length prefix)
-	void WriteBufferData(const string &str) {
-		WriteData((const_data_ptr_t)str.c_str(), str.size());
-	}
-	//! Write a string with a length prefix
-	void WriteString(const string &val) {
-		WriteStringLen((const_data_ptr_t)val.c_str(), val.size());
-	}
-	void WriteStringLen(const_data_ptr_t val, idx_t len) {
-		Write<uint32_t>((uint32_t)len);
-		if (len > 0) {
-			WriteData(val, len);
-		}
-	}
-
-	template <class T>
-	void WriteList(const vector<unique_ptr<T>> &list) {
-		Write<uint32_t>((uint32_t)list.size());
-		for (auto &child : list) {
-			child->Serialize(*this);
-		}
-	}
-
-	void WriteStringVector(const vector<string> &list) {
-		Write<uint32_t>((uint32_t)list.size());
-		for (auto &child : list) {
-			WriteString(child);
-		}
-	}
-
-	template <class T>
-	void WriteOptional(const unique_ptr<T> &element) {
-		Write<bool>(element ? true : false);
-		if (element) {
-			element->Serialize(*this);
-		}
-	}
-};
-
-//! The Deserializer class assists in deserializing a binary blob back into an
-//! object
-class Deserializer {
-public:
-	virtual ~Deserializer() {
-	}
-
-	//! Reads [read_size] bytes into the buffer
-	virtual void ReadData(data_ptr_t buffer, idx_t read_size) = 0;
-
-	template <class T>
-	T Read() {
-		T value;
-		ReadData((data_ptr_t)&value, sizeof(T));
-		return value;
-	}
-	template <class T>
-	void ReadList(vector<unique_ptr<T>> &list) {
-		auto select_count = Read<uint32_t>();
-		for (uint32_t i = 0; i < select_count; i++) {
-			auto child = T::Deserialize(*this);
-			list.push_back(move(child));
-		}
-	}
-
-	template <class T, class RETURN_TYPE = T>
-	unique_ptr<RETURN_TYPE> ReadOptional() {
-		auto has_entry = Read<bool>();
-		if (has_entry) {
-			return T::Deserialize(*this);
-		}
-		return nullptr;
-	}
-
-	void ReadStringVector(vector<string> &list);
-};
-
-template <>
-string Deserializer::Read();
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/file_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class Allocator;
-struct FileHandle;
-
-enum class FileBufferType : uint8_t { BLOCK = 1, MANAGED_BUFFER = 2 };
-
-//! The FileBuffer represents a buffer that can be read or written to a Direct IO FileHandle.
-class FileBuffer {
-public:
-	//! Allocates a buffer of the specified size that is sector-aligned. bufsiz must be a multiple of
-	//! FileSystemConstants::FILE_BUFFER_BLOCK_SIZE. The content in this buffer can be written to FileHandles that have
-	//! been opened with DIRECT_IO on all operating systems, however, the entire buffer must be written to the file.
-	//! Note that the returned size is 8 bytes less than the allocation size to account for the checksum.
-	FileBuffer(Allocator &allocator, FileBufferType type, uint64_t bufsiz);
-	FileBuffer(FileBuffer &source, FileBufferType type);
-
-	virtual ~FileBuffer();
-
-	Allocator &allocator;
-	//! The type of the buffer
-	FileBufferType type;
-	//! The buffer that users can write to
-	data_ptr_t buffer;
-	//! The size of the portion that users can write to, this is equivalent to internal_size - BLOCK_HEADER_SIZE
-	uint64_t size;
-
-public:
-	//! Read into the FileBuffer from the specified location.
-	void Read(FileHandle &handle, uint64_t location);
-	//! Read into the FileBuffer from the specified location. Automatically verifies the checksum, and throws an
-	//! exception if the checksum does not match correctly.
-	void ReadAndChecksum(FileHandle &handle, uint64_t location);
-	//! Write the contents of the FileBuffer to the specified location.
-	void Write(FileHandle &handle, uint64_t location);
-	//! Write the contents of the FileBuffer to the specified location. Automatically adds a checksum of the contents of
-	//! the filebuffer in front of the written data.
-	void ChecksumAndWrite(FileHandle &handle, uint64_t location);
-
-	void Clear();
-
-	void Resize(uint64_t bufsiz);
-
-	uint64_t AllocSize() {
-		return internal_size;
-	}
-
-protected:
-	//! The pointer to the internal buffer that will be read or written, including the buffer header
-	data_ptr_t internal_buffer;
-	//! The aligned size as passed to the constructor. This is the size that is read or written to disk.
-	uint64_t internal_size;
-
-private:
-	//! The buffer that was actually malloc'd, i.e. the pointer that must be freed when the FileBuffer is destroyed
-	data_ptr_t malloced_buffer;
-	uint64_t malloced_size;
-
-protected:
-	uint64_t GetMallocedSize() {
-		return malloced_size;
-	}
-	//! Sets malloced_size given the requested buffer size
-	void SetMallocedSize(uint64_t &bufsiz);
-	//! Constructs the Filebuffer object
-	void Construct(uint64_t bufsiz);
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/unordered_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <unordered_map>
-
-namespace duckdb {
-using std::unordered_map;
-}
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/file_compression_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class FileCompressionType : uint8_t { AUTO_DETECT = 0, UNCOMPRESSED = 1, GZIP = 2, ZSTD = 3 };
-
-FileCompressionType FileCompressionTypeFromString(const string &input);
-
-} // namespace duckdb
-
-
-#include <functional>
-
-#undef CreateDirectory
-#undef MoveFile
-#undef RemoveDirectory
-
-namespace duckdb {
-class ClientContext;
-class DatabaseInstance;
-class FileOpener;
-class FileSystem;
-
-enum class FileType {
-	//! Regular file
-	FILE_TYPE_REGULAR,
-	//! Directory
-	FILE_TYPE_DIR,
-	//! FIFO named pipe
-	FILE_TYPE_FIFO,
-	//! Socket
-	FILE_TYPE_SOCKET,
-	//! Symbolic link
-	FILE_TYPE_LINK,
-	//! Block device
-	FILE_TYPE_BLOCKDEV,
-	//! Character device
-	FILE_TYPE_CHARDEV,
-	//! Unknown or invalid file handle
-	FILE_TYPE_INVALID,
-};
-
-struct FileHandle {
-public:
-	DUCKDB_API FileHandle(FileSystem &file_system, string path);
-	FileHandle(const FileHandle &) = delete;
-	DUCKDB_API virtual ~FileHandle();
-
-	DUCKDB_API int64_t Read(void *buffer, idx_t nr_bytes);
-	DUCKDB_API int64_t Write(void *buffer, idx_t nr_bytes);
-	DUCKDB_API void Read(void *buffer, idx_t nr_bytes, idx_t location);
-	DUCKDB_API void Write(void *buffer, idx_t nr_bytes, idx_t location);
-	DUCKDB_API void Seek(idx_t location);
-	DUCKDB_API void Reset();
-	DUCKDB_API idx_t SeekPosition();
-	DUCKDB_API void Sync();
-	DUCKDB_API void Truncate(int64_t new_size);
-	DUCKDB_API string ReadLine();
-
-	DUCKDB_API bool CanSeek();
-	DUCKDB_API bool OnDiskFile();
-	DUCKDB_API idx_t GetFileSize();
-	DUCKDB_API FileType GetType();
-
-	//! Closes the file handle.
-	DUCKDB_API virtual void Close() = 0;
-
-public:
-	FileSystem &file_system;
-	string path;
-};
-
-enum class FileLockType : uint8_t { NO_LOCK = 0, READ_LOCK = 1, WRITE_LOCK = 2 };
-
-class FileFlags {
-public:
-	//! Open file with read access
-	static constexpr uint8_t FILE_FLAGS_READ = 1 << 0;
-	//! Open file with write access
-	static constexpr uint8_t FILE_FLAGS_WRITE = 1 << 1;
-	//! Use direct IO when reading/writing to the file
-	static constexpr uint8_t FILE_FLAGS_DIRECT_IO = 1 << 2;
-	//! Create file if not exists, can only be used together with WRITE
-	static constexpr uint8_t FILE_FLAGS_FILE_CREATE = 1 << 3;
-	//! Always create a new file. If a file exists, the file is truncated. Cannot be used together with CREATE.
-	static constexpr uint8_t FILE_FLAGS_FILE_CREATE_NEW = 1 << 4;
-	//! Open file in append mode
-	static constexpr uint8_t FILE_FLAGS_APPEND = 1 << 5;
-};
-
-class FileSystem {
-public:
-	DUCKDB_API virtual ~FileSystem();
-
-public:
-	DUCKDB_API static constexpr FileLockType DEFAULT_LOCK = FileLockType::NO_LOCK;
-	DUCKDB_API static constexpr FileCompressionType DEFAULT_COMPRESSION = FileCompressionType::UNCOMPRESSED;
-	DUCKDB_API static FileSystem &GetFileSystem(ClientContext &context);
-	DUCKDB_API static FileSystem &GetFileSystem(DatabaseInstance &db);
-	DUCKDB_API static FileOpener *GetFileOpener(ClientContext &context);
-
-	DUCKDB_API virtual unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags,
-	                                                   FileLockType lock = DEFAULT_LOCK,
-	                                                   FileCompressionType compression = DEFAULT_COMPRESSION,
-	                                                   FileOpener *opener = nullptr);
-
-	//! Read exactly nr_bytes from the specified location in the file. Fails if nr_bytes could not be read. This is
-	//! equivalent to calling SetFilePointer(location) followed by calling Read().
-	DUCKDB_API virtual void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
-	//! Write exactly nr_bytes to the specified location in the file. Fails if nr_bytes could not be read. This is
-	//! equivalent to calling SetFilePointer(location) followed by calling Write().
-	DUCKDB_API virtual void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location);
-	//! Read nr_bytes from the specified file into the buffer, moving the file pointer forward by nr_bytes. Returns the
-	//! amount of bytes read.
-	DUCKDB_API virtual int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes);
-	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
-	DUCKDB_API virtual int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes);
-
-	//! Returns the file size of a file handle, returns -1 on error
-	DUCKDB_API virtual int64_t GetFileSize(FileHandle &handle);
-	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	DUCKDB_API virtual time_t GetLastModifiedTime(FileHandle &handle);
-	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
-	DUCKDB_API virtual FileType GetFileType(FileHandle &handle);
-	//! Truncate a file to a maximum size of new_size, new_size should be smaller than or equal to the current size of
-	//! the file
-	DUCKDB_API virtual void Truncate(FileHandle &handle, int64_t new_size);
-
-	//! Check if a directory exists
-	DUCKDB_API virtual bool DirectoryExists(const string &directory);
-	//! Create a directory if it does not exist
-	DUCKDB_API virtual void CreateDirectory(const string &directory);
-	//! Recursively remove a directory and all files in it
-	DUCKDB_API virtual void RemoveDirectory(const string &directory);
-	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
-	DUCKDB_API virtual bool ListFiles(const string &directory,
-	                                  const std::function<void(const string &, bool)> &callback);
-	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
-	//! properties
-	DUCKDB_API virtual void MoveFile(const string &source, const string &target);
-	//! Check if a file exists
-	DUCKDB_API virtual bool FileExists(const string &filename);
-	//! Check if path is pipe
-	DUCKDB_API virtual bool IsPipe(const string &filename);
-	//! Remove a file from disk
-	DUCKDB_API virtual void RemoveFile(const string &filename);
-	//! Sync a file handle to disk
-	DUCKDB_API virtual void FileSync(FileHandle &handle);
-	//! Sets the working directory
-	DUCKDB_API static void SetWorkingDirectory(const string &path);
-	//! Gets the working directory
-	DUCKDB_API static string GetWorkingDirectory();
-	//! Gets the users home directory
-	DUCKDB_API static string GetHomeDirectory();
-	//! Returns the system-available memory in bytes. Returns DConstants::INVALID_INDEX if the system function fails.
-	DUCKDB_API static idx_t GetAvailableMemory();
-	//! Path separator for the current file system
-	DUCKDB_API static string PathSeparator();
-	//! Join two paths together
-	DUCKDB_API static string JoinPath(const string &a, const string &path);
-	//! Convert separators in a path to the local separators (e.g. convert "/" into \\ on windows)
-	DUCKDB_API static string ConvertSeparators(const string &path);
-	//! Extract the base name of a file (e.g. if the input is lib/example.dll the base name is example)
-	DUCKDB_API static string ExtractBaseName(const string &path);
-
-	//! Runs a glob on the file system, returning a list of matching files
-	DUCKDB_API virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr);
-	DUCKDB_API virtual vector<string> Glob(const string &path, ClientContext &context);
-
-	//! registers a sub-file system to handle certain file name prefixes, e.g. http:// etc.
-	DUCKDB_API virtual void RegisterSubSystem(unique_ptr<FileSystem> sub_fs);
-	DUCKDB_API virtual void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs);
-
-	//! Whether or not a sub-system can handle a specific file path
-	DUCKDB_API virtual bool CanHandleFile(const string &fpath);
-
-	//! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location
-	DUCKDB_API virtual void Seek(FileHandle &handle, idx_t location);
-	//! Reset a file to the beginning (equivalent to Seek(handle, 0) for simple files)
-	DUCKDB_API virtual void Reset(FileHandle &handle);
-	DUCKDB_API virtual idx_t SeekPosition(FileHandle &handle);
-
-	//! Whether or not we can seek into the file
-	DUCKDB_API virtual bool CanSeek();
-	//! Whether or not the FS handles plain files on disk. This is relevant for certain optimizations, as random reads
-	//! in a file on-disk are much cheaper than e.g. random reads in a file over the network
-	DUCKDB_API virtual bool OnDiskFile(FileHandle &handle);
-
-	DUCKDB_API virtual unique_ptr<FileHandle> OpenCompressedFile(unique_ptr<FileHandle> handle, bool write);
-
-	//! Create a LocalFileSystem.
-	DUCKDB_API static unique_ptr<FileSystem> CreateLocal();
-
-protected:
-	//! Return the name of the filesytem. Used for forming diagnosis messages.
-	DUCKDB_API virtual std::string GetName() const = 0;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-#define FILE_BUFFER_SIZE 4096
-
-class BufferedFileWriter : public Serializer {
-public:
-	static constexpr uint8_t DEFAULT_OPEN_FLAGS = FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE;
-
-	//! Serializes to a buffer allocated by the serializer, will expand when
-	//! writing past the initial threshold
-	BufferedFileWriter(FileSystem &fs, const string &path, uint8_t open_flags = DEFAULT_OPEN_FLAGS,
-	                   FileOpener *opener = nullptr);
-
-	FileSystem &fs;
-	string path;
-	unique_ptr<data_t[]> data;
-	idx_t offset;
-	idx_t total_written;
-	unique_ptr<FileHandle> handle;
-
-public:
-	void WriteData(const_data_ptr_t buffer, uint64_t write_size) override;
-	//! Flush the buffer to disk and sync the file to ensure writing is completed
-	void Sync();
-	//! Flush the buffer to the file (without sync)
-	void Flush();
-	//! Returns the current size of the file
-	int64_t GetFileSize();
-	//! Truncate the size to a previous size (given that size <= GetFileSize())
-	void Truncate(int64_t size);
-
-	idx_t GetTotalWritten();
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/udf_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/binary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/vector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/bitset.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <bitset>
-
-namespace duckdb {
-using std::bitset;
-}
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/vector_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class VectorType : uint8_t {
-	FLAT_VECTOR,       // Flat vectors represent a standard uncompressed vector
-	CONSTANT_VECTOR,   // Constant vector represents a single constant
-	DICTIONARY_VECTOR, // Dictionary vector represents a selection vector on top of another vector
-	SEQUENCE_VECTOR    // Sequence vector represents a sequence with a start point and an increment
-};
-
-string VectorTypeToString(VectorType type);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/selection_vector.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_size.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The vector size used in the execution engine
-#ifndef STANDARD_VECTOR_SIZE
-#define STANDARD_VECTOR_SIZE 1024
-#endif
-
-#if ((STANDARD_VECTOR_SIZE & (STANDARD_VECTOR_SIZE - 1)) != 0)
-#error Vector size should be a power of two
-#endif
-
-//! Zero selection vector: completely filled with the value 0 [READ ONLY]
-extern const sel_t ZERO_VECTOR[STANDARD_VECTOR_SIZE];
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class VectorBuffer;
-
-struct SelectionData {
-	explicit SelectionData(idx_t count);
-
-	unique_ptr<sel_t[]> owned_data;
-};
-
-struct SelectionVector {
-	SelectionVector() : sel_vector(nullptr) {
-	}
-	explicit SelectionVector(sel_t *sel) {
-		Initialize(sel);
-	}
-	explicit SelectionVector(idx_t count) {
-		Initialize(count);
-	}
-	SelectionVector(idx_t start, idx_t count) {
-		Initialize(STANDARD_VECTOR_SIZE);
-		for (idx_t i = 0; i < count; i++) {
-			set_index(i, start + i);
-		}
-	}
-	SelectionVector(const SelectionVector &sel_vector) {
-		Initialize(sel_vector);
-	}
-	explicit SelectionVector(buffer_ptr<SelectionData> data) {
-		Initialize(std::move(data));
-	}
-
-public:
-	void Initialize(sel_t *sel) {
-		selection_data.reset();
-		sel_vector = sel;
-	}
-	void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
-		selection_data = make_buffer<SelectionData>(count);
-		sel_vector = selection_data->owned_data.get();
-	}
-	void Initialize(buffer_ptr<SelectionData> data) {
-		selection_data = std::move(data);
-		sel_vector = selection_data->owned_data.get();
-	}
-	void Initialize(const SelectionVector &other) {
-		selection_data = other.selection_data;
-		sel_vector = other.sel_vector;
-	}
-
-	void set_index(idx_t idx, idx_t loc) {
-		sel_vector[idx] = loc;
-	}
-	void swap(idx_t i, idx_t j) {
-		sel_t tmp = sel_vector[i];
-		sel_vector[i] = sel_vector[j];
-		sel_vector[j] = tmp;
-	}
-	idx_t get_index(idx_t idx) const {
-		return sel_vector ? sel_vector[idx] : idx;
-	}
-	sel_t *data() {
-		return sel_vector;
-	}
-	const sel_t *data() const {
-		return sel_vector;
-	}
-	buffer_ptr<SelectionData> sel_data() {
-		return selection_data;
-	}
-	buffer_ptr<SelectionData> Slice(const SelectionVector &sel, idx_t count) const;
-
-	string ToString(idx_t count = 0) const;
-	void Print(idx_t count = 0) const;
-
-	sel_t &operator[](idx_t index) {
-		return sel_vector[index];
-	}
-
-private:
-	sel_t *sel_vector;
-	buffer_ptr<SelectionData> selection_data;
-};
-
-class OptionalSelection {
-public:
-	explicit inline OptionalSelection(SelectionVector *sel_p) : sel(sel_p) {
-
-		if (sel) {
-			vec.Initialize(sel->data());
-			sel = &vec;
-		}
-	}
-
-	inline operator SelectionVector *() {
-		return sel;
-	}
-
-	inline void Append(idx_t &count, const idx_t idx) {
-		if (sel) {
-			sel->set_index(count, idx);
-		}
-		++count;
-	}
-
-	inline void Advance(idx_t completed) {
-		if (sel) {
-			sel->Initialize(sel->data() + completed);
-		}
-	}
-
-private:
-	SelectionVector *sel;
-	SelectionVector vec;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/validity_mask.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/to_string.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-namespace duckdb {
-using std::to_string;
-}
-
-
-namespace duckdb {
-struct ValidityMask;
-
-template <typename V>
-struct TemplatedValidityData {
-	static constexpr const int BITS_PER_VALUE = sizeof(V) * 8;
-	static constexpr const V MAX_ENTRY = ~V(0);
-
-public:
-	inline explicit TemplatedValidityData(idx_t count) {
-		auto entry_count = EntryCount(count);
-		owned_data = unique_ptr<V[]>(new V[entry_count]);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			owned_data[entry_idx] = MAX_ENTRY;
-		}
-	}
-	inline TemplatedValidityData(const V *validity_mask, idx_t count) {
-		D_ASSERT(validity_mask);
-		auto entry_count = EntryCount(count);
-		owned_data = unique_ptr<V[]>(new V[entry_count]);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			owned_data[entry_idx] = validity_mask[entry_idx];
-		}
-	}
-
-	unique_ptr<V[]> owned_data;
-
-public:
-	static inline idx_t EntryCount(idx_t count) {
-		return (count + (BITS_PER_VALUE - 1)) / BITS_PER_VALUE;
-	}
-};
-
-using validity_t = uint64_t;
-
-struct ValidityData : TemplatedValidityData<validity_t> {
-public:
-	DUCKDB_API explicit ValidityData(idx_t count);
-	DUCKDB_API ValidityData(const ValidityMask &original, idx_t count);
-};
-
-//! Type used for validity masks
-template <typename V>
-struct TemplatedValidityMask {
-	using ValidityBuffer = TemplatedValidityData<V>;
-
-public:
-	static constexpr const int BITS_PER_VALUE = ValidityBuffer::BITS_PER_VALUE;
-	static constexpr const int STANDARD_ENTRY_COUNT = (STANDARD_VECTOR_SIZE + (BITS_PER_VALUE - 1)) / BITS_PER_VALUE;
-	static constexpr const int STANDARD_MASK_SIZE = STANDARD_ENTRY_COUNT * sizeof(validity_t);
-
-public:
-	inline TemplatedValidityMask() : validity_mask(nullptr) {
-	}
-	inline explicit TemplatedValidityMask(idx_t max_count) {
-		Initialize(max_count);
-	}
-	inline explicit TemplatedValidityMask(V *ptr) : validity_mask(ptr) {
-	}
-	inline TemplatedValidityMask(const TemplatedValidityMask &original, idx_t count) {
-		Copy(original, count);
-	}
-
-	static inline idx_t ValidityMaskSize(idx_t count = STANDARD_VECTOR_SIZE) {
-		return ValidityBuffer::EntryCount(count) * sizeof(V);
-	}
-	inline bool AllValid() const {
-		return !validity_mask;
-	}
-	inline bool CheckAllValid(idx_t count) const {
-		if (AllValid()) {
-			return true;
-		}
-		idx_t entry_count = ValidityBuffer::EntryCount(count);
-		idx_t valid_count = 0;
-		for (idx_t i = 0; i < entry_count; i++) {
-			valid_count += validity_mask[i] == ValidityBuffer::MAX_ENTRY;
-		}
-		return valid_count == entry_count;
-	}
-
-	inline bool CheckAllValid(idx_t to, idx_t from) const {
-		if (AllValid()) {
-			return true;
-		}
-		for (idx_t i = from; i < to; i++) {
-			if (!RowIsValid(i)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	idx_t CountValid(const idx_t count) const {
-		if (AllValid() || count == 0) {
-			return count;
-		}
-
-		idx_t valid = 0;
-		const auto entry_count = EntryCount(count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count;) {
-			auto entry = GetValidityEntry(entry_idx++);
-			// Handle ragged end
-			if (entry_idx == entry_count) {
-				idx_t idx_in_entry;
-				GetEntryIndex(count, entry_idx, idx_in_entry);
-				for (idx_t i = 0; i < idx_in_entry; ++i) {
-					valid += idx_t(RowIsValid(entry, i));
-				}
-				break;
-			}
-
-			// Handle all set
-			if (AllValid(entry)) {
-				valid += BITS_PER_VALUE;
-				continue;
-			}
-
-			// Count partial entry (Kernighan's algorithm)
-			while (entry) {
-				entry &= (entry - 1);
-				++valid;
-			}
-		}
-
-		return valid;
-	}
-
-	inline V *GetData() const {
-		return validity_mask;
-	}
-	inline void Reset() {
-		validity_mask = nullptr;
-		validity_data.reset();
-	}
-
-	static inline idx_t EntryCount(idx_t count) {
-		return ValidityBuffer::EntryCount(count);
-	}
-	inline V GetValidityEntry(idx_t entry_idx) const {
-		if (!validity_mask) {
-			return ValidityBuffer::MAX_ENTRY;
-		}
-		return validity_mask[entry_idx];
-	}
-	static inline bool AllValid(V entry) {
-		return entry == ValidityBuffer::MAX_ENTRY;
-	}
-	static inline bool NoneValid(V entry) {
-		return entry == 0;
-	}
-	static inline bool RowIsValid(V entry, idx_t idx_in_entry) {
-		return entry & (V(1) << V(idx_in_entry));
-	}
-	static inline void GetEntryIndex(idx_t row_idx, idx_t &entry_idx, idx_t &idx_in_entry) {
-		entry_idx = row_idx / BITS_PER_VALUE;
-		idx_in_entry = row_idx % BITS_PER_VALUE;
-	}
-	//! Get an entry that has first-n bits set as valid and rest set as invalid
-	static inline V EntryWithValidBits(idx_t n) {
-		if (n == 0) {
-			return V(0);
-		}
-		return ValidityBuffer::MAX_ENTRY >> (BITS_PER_VALUE - n);
-	}
-
-	//! RowIsValidUnsafe should only be used if AllValid() is false: it achieves the same as RowIsValid but skips a
-	//! not-null check
-	inline bool RowIsValidUnsafe(idx_t row_idx) const {
-		D_ASSERT(validity_mask);
-		idx_t entry_idx, idx_in_entry;
-		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
-		auto entry = GetValidityEntry(entry_idx);
-		return RowIsValid(entry, idx_in_entry);
-	}
-
-	//! Returns true if a row is valid (i.e. not null), false otherwise
-	inline bool RowIsValid(idx_t row_idx) const {
-		if (!validity_mask) {
-			return true;
-		}
-		return RowIsValidUnsafe(row_idx);
-	}
-
-	//! Same as SetValid, but skips a null check on validity_mask
-	inline void SetValidUnsafe(idx_t row_idx) {
-		D_ASSERT(validity_mask);
-		idx_t entry_idx, idx_in_entry;
-		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
-		validity_mask[entry_idx] |= (V(1) << V(idx_in_entry));
-	}
-
-	//! Marks the entry at the specified row index as valid (i.e. not-null)
-	inline void SetValid(idx_t row_idx) {
-		if (!validity_mask) {
-			// if AllValid() we don't need to do anything
-			// the row is already valid
-			return;
-		}
-		SetValidUnsafe(row_idx);
-	}
-
-	//! Marks the bit at the specified entry as invalid (i.e. null)
-	inline void SetInvalidUnsafe(idx_t entry_idx, idx_t idx_in_entry) {
-		D_ASSERT(validity_mask);
-		validity_mask[entry_idx] &= ~(V(1) << V(idx_in_entry));
-	}
-
-	//! Marks the bit at the specified row index as invalid (i.e. null)
-	inline void SetInvalidUnsafe(idx_t row_idx) {
-		idx_t entry_idx, idx_in_entry;
-		GetEntryIndex(row_idx, entry_idx, idx_in_entry);
-		SetInvalidUnsafe(entry_idx, idx_in_entry);
-	}
-
-	//! Marks the entry at the specified row index as invalid (i.e. null)
-	inline void SetInvalid(idx_t row_idx) {
-		if (!validity_mask) {
-			D_ASSERT(row_idx <= STANDARD_VECTOR_SIZE);
-			Initialize(STANDARD_VECTOR_SIZE);
-		}
-		SetInvalidUnsafe(row_idx);
-	}
-
-	//! Mark the entry at the specified index as either valid or invalid (non-null or null)
-	inline void Set(idx_t row_idx, bool valid) {
-		if (valid) {
-			SetValid(row_idx);
-		} else {
-			SetInvalid(row_idx);
-		}
-	}
-
-	//! Ensure the validity mask is writable, allocating space if it is not initialized
-	inline void EnsureWritable() {
-		if (!validity_mask) {
-			Initialize();
-		}
-	}
-
-	//! Marks exactly "count" bits in the validity mask as invalid (null)
-	inline void SetAllInvalid(idx_t count) {
-		EnsureWritable();
-		if (count == 0) {
-			return;
-		}
-		auto last_entry_index = ValidityBuffer::EntryCount(count) - 1;
-		for (idx_t i = 0; i < last_entry_index; i++) {
-			validity_mask[i] = 0;
-		}
-		auto last_entry_bits = count % static_cast<idx_t>(BITS_PER_VALUE);
-		validity_mask[last_entry_index] = (last_entry_bits == 0) ? 0 : (ValidityBuffer::MAX_ENTRY << (last_entry_bits));
-	}
-
-	//! Marks exactly "count" bits in the validity mask as valid (not null)
-	inline void SetAllValid(idx_t count) {
-		EnsureWritable();
-		if (count == 0) {
-			return;
-		}
-		auto last_entry_index = ValidityBuffer::EntryCount(count) - 1;
-		for (idx_t i = 0; i < last_entry_index; i++) {
-			validity_mask[i] = ValidityBuffer::MAX_ENTRY;
-		}
-		auto last_entry_bits = count % static_cast<idx_t>(BITS_PER_VALUE);
-		validity_mask[last_entry_index] |=
-		    (last_entry_bits == 0) ? ValidityBuffer::MAX_ENTRY : ~(ValidityBuffer::MAX_ENTRY << (last_entry_bits));
-	}
-
-	inline bool IsMaskSet() const {
-		if (validity_mask) {
-			return true;
-		}
-		return false;
-	}
-
-public:
-	inline void Initialize(validity_t *validity) {
-		validity_data.reset();
-		validity_mask = validity;
-	}
-	inline void Initialize(const TemplatedValidityMask &other) {
-		validity_mask = other.validity_mask;
-		validity_data = other.validity_data;
-	}
-	inline void Initialize(idx_t count = STANDARD_VECTOR_SIZE) {
-		validity_data = make_buffer<ValidityBuffer>(count);
-		validity_mask = validity_data->owned_data.get();
-	}
-	inline void Copy(const TemplatedValidityMask &other, idx_t count) {
-		if (other.AllValid()) {
-			validity_data = nullptr;
-			validity_mask = nullptr;
-		} else {
-			validity_data = make_buffer<ValidityBuffer>(other.validity_mask, count);
-			validity_mask = validity_data->owned_data.get();
-		}
-	}
-
-protected:
-	V *validity_mask;
-	buffer_ptr<ValidityBuffer> validity_data;
-};
-
-struct ValidityMask : public TemplatedValidityMask<validity_t> {
-public:
-	inline ValidityMask() : TemplatedValidityMask(nullptr) {
-	}
-	inline explicit ValidityMask(idx_t max_count) : TemplatedValidityMask(max_count) {
-	}
-	inline explicit ValidityMask(validity_t *ptr) : TemplatedValidityMask(ptr) {
-	}
-	inline ValidityMask(const ValidityMask &original, idx_t count) : TemplatedValidityMask(original, count) {
-	}
-
-public:
-	DUCKDB_API void Resize(idx_t old_size, idx_t new_size);
-
-	DUCKDB_API void Slice(const ValidityMask &other, idx_t offset);
-	DUCKDB_API void Combine(const ValidityMask &other, idx_t count);
-	DUCKDB_API string ToString(idx_t count) const;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/value.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class Deserializer;
-class Serializer;
-
-//! The Value object holds a single arbitrary value of any type that can be
-//! stored in the database.
-class Value {
-	friend struct StringValue;
-	friend struct StructValue;
-	friend struct ListValue;
-
-public:
-	//! Create an empty NULL value of the specified type
-	DUCKDB_API explicit Value(LogicalType type = LogicalType::SQLNULL);
-	//! Create an INTEGER value
-	DUCKDB_API Value(int32_t val); // NOLINT: Allow implicit conversion from `int32_t`
-	//! Create a BIGINT value
-	DUCKDB_API Value(int64_t val); // NOLINT: Allow implicit conversion from `int64_t`
-	//! Create a FLOAT value
-	DUCKDB_API Value(float val); // NOLINT: Allow implicit conversion from `float`
-	//! Create a DOUBLE value
-	DUCKDB_API Value(double val); // NOLINT: Allow implicit conversion from `double`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(const char *val); // NOLINT: Allow implicit conversion from `const char *`
-	//! Create a NULL value
-	DUCKDB_API Value(std::nullptr_t val); // NOLINT: Allow implicit conversion from `nullptr_t`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(string_t val); // NOLINT: Allow implicit conversion from `string_t`
-	//! Create a VARCHAR value
-	DUCKDB_API Value(string val); // NOLINT: Allow implicit conversion from `string`
-	//! Copy constructor
-	DUCKDB_API Value(const Value &other);
-	//! Move constructor
-	DUCKDB_API Value(Value &&other) noexcept;
-	//! Destructor
-	DUCKDB_API ~Value();
-
-	// copy assignment
-	DUCKDB_API Value &operator=(const Value &other);
-	// move assignment
-	DUCKDB_API Value &operator=(Value &&other) noexcept;
-
-	inline const LogicalType &type() const {
-		return type_;
-	}
-	inline bool IsNull() const {
-		return is_null;
-	}
-
-	//! Create the lowest possible value of a given type (numeric only)
-	DUCKDB_API static Value MinimumValue(const LogicalType &type);
-	//! Create the highest possible value of a given type (numeric only)
-	DUCKDB_API static Value MaximumValue(const LogicalType &type);
-	//! Create a Numeric value of the specified type with the specified value
-	DUCKDB_API static Value Numeric(const LogicalType &type, int64_t value);
-	DUCKDB_API static Value Numeric(const LogicalType &type, hugeint_t value);
-
-	//! Create a tinyint Value from a specified value
-	DUCKDB_API static Value BOOLEAN(int8_t value);
-	//! Create a tinyint Value from a specified value
-	DUCKDB_API static Value TINYINT(int8_t value);
-	//! Create a smallint Value from a specified value
-	DUCKDB_API static Value SMALLINT(int16_t value);
-	//! Create an integer Value from a specified value
-	DUCKDB_API static Value INTEGER(int32_t value);
-	//! Create a bigint Value from a specified value
-	DUCKDB_API static Value BIGINT(int64_t value);
-	//! Create an unsigned tinyint Value from a specified value
-	DUCKDB_API static Value UTINYINT(uint8_t value);
-	//! Create an unsigned smallint Value from a specified value
-	DUCKDB_API static Value USMALLINT(uint16_t value);
-	//! Create an unsigned integer Value from a specified value
-	DUCKDB_API static Value UINTEGER(uint32_t value);
-	//! Create an unsigned bigint Value from a specified value
-	DUCKDB_API static Value UBIGINT(uint64_t value);
-	//! Create a hugeint Value from a specified value
-	DUCKDB_API static Value HUGEINT(hugeint_t value);
-	//! Create a uuid Value from a specified value
-	DUCKDB_API static Value UUID(const string &value);
-	//! Create a uuid Value from a specified value
-	DUCKDB_API static Value UUID(hugeint_t value);
-	//! Create a hash Value from a specified value
-	DUCKDB_API static Value HASH(hash_t value);
-	//! Create a pointer Value from a specified value
-	DUCKDB_API static Value POINTER(uintptr_t value);
-	//! Create a date Value from a specified date
-	DUCKDB_API static Value DATE(date_t date);
-	//! Create a date Value from a specified date
-	DUCKDB_API static Value DATE(int32_t year, int32_t month, int32_t day);
-	//! Create a time Value from a specified time
-	DUCKDB_API static Value TIME(dtime_t time);
-	DUCKDB_API static Value TIMETZ(dtime_t time);
-	//! Create a time Value from a specified time
-	DUCKDB_API static Value TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros);
-	//! Create a timestamp Value from a specified date/time combination
-	DUCKDB_API static Value TIMESTAMP(date_t date, dtime_t time);
-	//! Create a timestamp Value from a specified timestamp
-	DUCKDB_API static Value TIMESTAMP(timestamp_t timestamp);
-	DUCKDB_API static Value TIMESTAMPNS(timestamp_t timestamp);
-	DUCKDB_API static Value TIMESTAMPMS(timestamp_t timestamp);
-	DUCKDB_API static Value TIMESTAMPSEC(timestamp_t timestamp);
-	DUCKDB_API static Value TIMESTAMPTZ(timestamp_t timestamp);
-	//! Create a timestamp Value from a specified timestamp in separate values
-	DUCKDB_API static Value TIMESTAMP(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec,
-	                                  int32_t micros);
-	DUCKDB_API static Value INTERVAL(int32_t months, int32_t days, int64_t micros);
-	DUCKDB_API static Value INTERVAL(interval_t interval);
-	//! Creates a JSON Value
-	DUCKDB_API static Value JSON(const char *val);
-	DUCKDB_API static Value JSON(string_t val);
-	DUCKDB_API static Value JSON(string val);
-
-	// Create a enum Value from a specified uint value
-	DUCKDB_API static Value ENUM(uint64_t value, const LogicalType &original_type);
-
-	// Decimal values
-	DUCKDB_API static Value DECIMAL(int16_t value, uint8_t width, uint8_t scale);
-	DUCKDB_API static Value DECIMAL(int32_t value, uint8_t width, uint8_t scale);
-	DUCKDB_API static Value DECIMAL(int64_t value, uint8_t width, uint8_t scale);
-	DUCKDB_API static Value DECIMAL(hugeint_t value, uint8_t width, uint8_t scale);
-	//! Create a float Value from a specified value
-	DUCKDB_API static Value FLOAT(float value);
-	//! Create a double Value from a specified value
-	DUCKDB_API static Value DOUBLE(double value);
-	//! Create a struct value with given list of entries
-	DUCKDB_API static Value STRUCT(child_list_t<Value> values);
-	//! Create a list value with the given entries, list type is inferred from children
-	//! Cannot be called with an empty list, use either EMPTYLIST or LIST with a type instead
-	DUCKDB_API static Value LIST(vector<Value> values);
-	//! Create a list value with the given entries
-	DUCKDB_API static Value LIST(LogicalType child_type, vector<Value> values);
-	//! Create an empty list with the specified child-type
-	DUCKDB_API static Value EMPTYLIST(LogicalType child_type);
-	//! Create a map value from a (key, value) pair
-	DUCKDB_API static Value MAP(Value key, Value value);
-
-	//! Create a blob Value from a data pointer and a length: no bytes are interpreted
-	DUCKDB_API static Value BLOB(const_data_ptr_t data, idx_t len);
-	DUCKDB_API static Value BLOB_RAW(const string &data) {
-		return Value::BLOB((const_data_ptr_t)data.c_str(), data.size());
-	}
-	//! Creates a blob by casting a specified string to a blob (i.e. interpreting \x characters)
-	DUCKDB_API static Value BLOB(const string &data);
-
-	template <class T>
-	T GetValue() const {
-		throw InternalException("Unimplemented template type for Value::GetValue");
-	}
-	template <class T>
-	static Value CreateValue(T value) {
-		throw InternalException("Unimplemented template type for Value::CreateValue");
-	}
-	// Returns the internal value. Unlike GetValue(), this method does not perform casting, and assumes T matches the
-	// type of the value. Only use this if you know what you are doing.
-	template <class T>
-	T GetValueUnsafe() const {
-		throw InternalException("Unimplemented template type for Value::GetValueUnsafe");
-	}
-	//! Returns a reference to the internal value. This can only be used for primitive types.
-	template <class T>
-	T &GetReferenceUnsafe() {
-		throw InternalException("Unimplemented template type for Value::GetReferenceUnsafe");
-	}
-
-	//! Return a copy of this value
-	Value Copy() const {
-		return Value(*this);
-	}
-
-	//! Hashes the Value
-	DUCKDB_API hash_t Hash() const;
-	//! Convert this value to a string
-	DUCKDB_API string ToString() const;
-	//! Convert this value to a SQL-parseable string
-	DUCKDB_API string ToSQLString() const;
-
-	DUCKDB_API uintptr_t GetPointer() const;
-
-	//! Cast this value to another type, throws exception if its not possible
-	DUCKDB_API Value CastAs(const LogicalType &target_type, bool strict = false) const;
-	//! Tries to cast this value to another type, and stores the result in "new_value"
-	DUCKDB_API bool TryCastAs(const LogicalType &target_type, Value &new_value, string *error_message,
-	                          bool strict = false) const;
-	//! Tries to cast this value to another type, and stores the result in THIS value again
-	DUCKDB_API bool TryCastAs(const LogicalType &target_type, bool strict = false);
-
-	//! Serializes a Value to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	//! Deserializes a Value from a blob
-	DUCKDB_API static Value Deserialize(Deserializer &source);
-
-	//===--------------------------------------------------------------------===//
-	// Comparison Operators
-	//===--------------------------------------------------------------------===//
-	DUCKDB_API bool operator==(const Value &rhs) const;
-	DUCKDB_API bool operator!=(const Value &rhs) const;
-	DUCKDB_API bool operator<(const Value &rhs) const;
-	DUCKDB_API bool operator>(const Value &rhs) const;
-	DUCKDB_API bool operator<=(const Value &rhs) const;
-	DUCKDB_API bool operator>=(const Value &rhs) const;
-
-	DUCKDB_API bool operator==(const int64_t &rhs) const;
-	DUCKDB_API bool operator!=(const int64_t &rhs) const;
-	DUCKDB_API bool operator<(const int64_t &rhs) const;
-	DUCKDB_API bool operator>(const int64_t &rhs) const;
-	DUCKDB_API bool operator<=(const int64_t &rhs) const;
-	DUCKDB_API bool operator>=(const int64_t &rhs) const;
-
-	DUCKDB_API static bool FloatIsFinite(float value);
-	DUCKDB_API static bool DoubleIsFinite(double value);
-	template <class T>
-	static bool IsNan(T value) {
-		throw InternalException("Unimplemented template type for Value::IsNan");
-	}
-	template <class T>
-	static bool IsFinite(T value) {
-		return true;
-	}
-	DUCKDB_API static bool StringIsValid(const char *str, idx_t length);
-	static bool StringIsValid(const string &str) {
-		return StringIsValid(str.c_str(), str.size());
-	}
-
-	//! Returns true if the values are (approximately) equivalent. Note this is NOT the SQL equivalence. For this
-	//! function, NULL values are equivalent and floating point values that are close are equivalent.
-	DUCKDB_API static bool ValuesAreEqual(const Value &result_value, const Value &value);
-	//! Returns true if the values are not distinct from each other, following SQL semantics for NOT DISTINCT FROM.
-	DUCKDB_API static bool NotDistinctFrom(const Value &lvalue, const Value &rvalue);
-
-	friend std::ostream &operator<<(std::ostream &out, const Value &val) {
-		out << val.ToString();
-		return out;
-	}
-	DUCKDB_API void Print() const;
-
-private:
-	//! The logical of the value
-	LogicalType type_;
-
-#if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
-public:
-#endif
-	//! Whether or not the value is NULL
-	bool is_null;
-
-	//! The value of the object, if it is of a constant size Type
-	union Val {
-		int8_t boolean;
-		int8_t tinyint;
-		int16_t smallint;
-		int32_t integer;
-		int64_t bigint;
-		uint8_t utinyint;
-		uint16_t usmallint;
-		uint32_t uinteger;
-		uint64_t ubigint;
-		hugeint_t hugeint;
-		float float_;
-		double double_;
-		uintptr_t pointer;
-		uint64_t hash;
-		date_t date;
-		dtime_t time;
-		timestamp_t timestamp;
-		interval_t interval;
-	} value_;
-
-	//! The value of the object, if it is of a variable size type
-	string str_value;
-
-	vector<Value> struct_value;
-	vector<Value> list_value;
-
-private:
-	template <class T>
-	T GetValueInternal() const;
-};
-
-//===--------------------------------------------------------------------===//
-// Type-specific getters
-//===--------------------------------------------------------------------===//
-// Note that these are equivalent to calling GetValueUnsafe<X>, meaning no cast will be performed
-// instead, an assertion will be triggered if the value is not of the correct type
-struct BooleanValue {
-	DUCKDB_API static bool Get(const Value &value);
-};
-
-struct TinyIntValue {
-	DUCKDB_API static int8_t Get(const Value &value);
-};
-
-struct SmallIntValue {
-	DUCKDB_API static int16_t Get(const Value &value);
-};
-
-struct IntegerValue {
-	DUCKDB_API static int32_t Get(const Value &value);
-};
-
-struct BigIntValue {
-	DUCKDB_API static int64_t Get(const Value &value);
-};
-
-struct HugeIntValue {
-	DUCKDB_API static hugeint_t Get(const Value &value);
-};
-
-struct UTinyIntValue {
-	DUCKDB_API static uint8_t Get(const Value &value);
-};
-
-struct USmallIntValue {
-	DUCKDB_API static uint16_t Get(const Value &value);
-};
-
-struct UIntegerValue {
-	DUCKDB_API static uint32_t Get(const Value &value);
-};
-
-struct UBigIntValue {
-	DUCKDB_API static uint64_t Get(const Value &value);
-};
-
-struct FloatValue {
-	DUCKDB_API static float Get(const Value &value);
-};
-
-struct DoubleValue {
-	DUCKDB_API static double Get(const Value &value);
-};
-
-struct StringValue {
-	DUCKDB_API static const string &Get(const Value &value);
-};
-
-struct DateValue {
-	DUCKDB_API static date_t Get(const Value &value);
-};
-
-struct TimeValue {
-	DUCKDB_API static dtime_t Get(const Value &value);
-};
-
-struct TimestampValue {
-	DUCKDB_API static timestamp_t Get(const Value &value);
-};
-
-struct IntervalValue {
-	DUCKDB_API static interval_t Get(const Value &value);
-};
-
-struct StructValue {
-	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
-};
-
-struct ListValue {
-	DUCKDB_API static const vector<Value> &GetChildren(const Value &value);
-};
-
-//! Return the internal integral value for any type that is stored as an integral value internally
-//! This can be used on values of type integer, uinteger, but also date, timestamp, decimal, etc
-struct IntegralValue {
-	static hugeint_t Get(const Value &value);
-};
-
-template <>
-Value DUCKDB_API Value::CreateValue(bool value);
-template <>
-Value DUCKDB_API Value::CreateValue(uint8_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(uint16_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(uint32_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(uint64_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(int8_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(int16_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(int32_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(int64_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(hugeint_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(date_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(dtime_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(timestamp_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(const char *value);
-template <>
-Value DUCKDB_API Value::CreateValue(string value);
-template <>
-Value DUCKDB_API Value::CreateValue(string_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(float value);
-template <>
-Value DUCKDB_API Value::CreateValue(double value);
-template <>
-Value DUCKDB_API Value::CreateValue(interval_t value);
-template <>
-Value DUCKDB_API Value::CreateValue(Value value);
-
-template <>
-DUCKDB_API bool Value::GetValue() const;
-template <>
-DUCKDB_API int8_t Value::GetValue() const;
-template <>
-DUCKDB_API int16_t Value::GetValue() const;
-template <>
-DUCKDB_API int32_t Value::GetValue() const;
-template <>
-DUCKDB_API int64_t Value::GetValue() const;
-template <>
-DUCKDB_API uint8_t Value::GetValue() const;
-template <>
-DUCKDB_API uint16_t Value::GetValue() const;
-template <>
-DUCKDB_API uint32_t Value::GetValue() const;
-template <>
-DUCKDB_API uint64_t Value::GetValue() const;
-template <>
-DUCKDB_API hugeint_t Value::GetValue() const;
-template <>
-DUCKDB_API string Value::GetValue() const;
-template <>
-DUCKDB_API float Value::GetValue() const;
-template <>
-DUCKDB_API double Value::GetValue() const;
-template <>
-DUCKDB_API date_t Value::GetValue() const;
-template <>
-DUCKDB_API dtime_t Value::GetValue() const;
-template <>
-DUCKDB_API timestamp_t Value::GetValue() const;
-template <>
-DUCKDB_API interval_t Value::GetValue() const;
-template <>
-DUCKDB_API Value Value::GetValue() const;
-
-template <>
-DUCKDB_API bool Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API int8_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API int16_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API int32_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API int64_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API hugeint_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uint8_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uint16_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uint32_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API uint64_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API string Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API string_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API float Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API double Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API date_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API dtime_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API timestamp_t Value::GetValueUnsafe() const;
-template <>
-DUCKDB_API interval_t Value::GetValueUnsafe() const;
-
-template <>
-DUCKDB_API int8_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int16_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int32_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int64_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API hugeint_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint8_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint16_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint32_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint64_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API float &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API double &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API date_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API dtime_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API timestamp_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API interval_t &Value::GetReferenceUnsafe();
-
-template <>
-DUCKDB_API bool Value::IsNan(float input);
-template <>
-DUCKDB_API bool Value::IsNan(double input);
-
-template <>
-DUCKDB_API bool Value::IsFinite(float input);
-template <>
-DUCKDB_API bool Value::IsFinite(double input);
-template <>
-DUCKDB_API bool Value::IsFinite(date_t input);
-template <>
-DUCKDB_API bool Value::IsFinite(timestamp_t input);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/vector_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/string_heap.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/arena_allocator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/allocator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class Allocator;
-class ClientContext;
-class DatabaseInstance;
-class ExecutionContext;
-class ThreadContext;
-
-struct AllocatorDebugInfo;
-
-struct PrivateAllocatorData {
-	PrivateAllocatorData();
-	virtual ~PrivateAllocatorData();
-
-	unique_ptr<AllocatorDebugInfo> debug_info;
-};
-
-typedef data_ptr_t (*allocate_function_ptr_t)(PrivateAllocatorData *private_data, idx_t size);
-typedef void (*free_function_ptr_t)(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
-typedef data_ptr_t (*reallocate_function_ptr_t)(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-                                                idx_t size);
-
-class AllocatedData {
-public:
-	AllocatedData(Allocator &allocator, data_ptr_t pointer, idx_t allocated_size);
-	~AllocatedData();
-
-	data_ptr_t get() {
-		return pointer;
-	}
-	const_data_ptr_t get() const {
-		return pointer;
-	}
-	idx_t GetSize() const {
-		return allocated_size;
-	}
-	void Reset();
-
-private:
-	Allocator &allocator;
-	data_ptr_t pointer;
-	idx_t allocated_size;
-};
-
-class Allocator {
-public:
-	DUCKDB_API Allocator();
-	DUCKDB_API Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p,
-	                     reallocate_function_ptr_t reallocate_function_p,
-	                     unique_ptr<PrivateAllocatorData> private_data);
-	DUCKDB_API Allocator &operator=(Allocator &&allocator) noexcept = delete;
-	DUCKDB_API ~Allocator();
-
-	data_ptr_t AllocateData(idx_t size);
-	void FreeData(data_ptr_t pointer, idx_t size);
-	data_ptr_t ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t new_size);
-
-	unique_ptr<AllocatedData> Allocate(idx_t size) {
-		return make_unique<AllocatedData>(*this, AllocateData(size), size);
-	}
-
-	static data_ptr_t DefaultAllocate(PrivateAllocatorData *private_data, idx_t size) {
-		return (data_ptr_t)malloc(size);
-	}
-	static void DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
-		free(pointer);
-	}
-	static data_ptr_t DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-	                                    idx_t size) {
-		return (data_ptr_t)realloc(pointer, size);
-	}
-	static Allocator &Get(ClientContext &context);
-	static Allocator &Get(DatabaseInstance &db);
-
-	PrivateAllocatorData *GetPrivateData() {
-		return private_data.get();
-	}
-
-	static Allocator &DefaultAllocator();
-
-private:
-	allocate_function_ptr_t allocate_function;
-	free_function_ptr_t free_function;
-	reallocate_function_ptr_t reallocate_function;
-
-	unique_ptr<PrivateAllocatorData> private_data;
-};
-
-//! The BufferAllocator is a wrapper around the global allocator class that sends any allocations made through the
-//! buffer manager. This makes the buffer manager aware of the memory usage, allowing it to potentially free
-//! other blocks to make space in memory.
-//! Note that there is a cost to doing so (several atomic operations will be performed on allocation/free).
-//! As such this class should be used primarily for larger allocations.
-struct BufferAllocator {
-	static Allocator &Get(ClientContext &context);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct ArenaChunk {
-	ArenaChunk(Allocator &allocator, idx_t size);
-	~ArenaChunk();
-
-	unique_ptr<AllocatedData> data;
-	idx_t current_position;
-	idx_t maximum_size;
-	unique_ptr<ArenaChunk> next;
-	ArenaChunk *prev;
-};
-
-class ArenaAllocator {
-	static constexpr const idx_t ARENA_ALLOCATOR_INITIAL_CAPACITY = 2048;
-
-public:
-	ArenaAllocator(Allocator &allocator, idx_t initial_capacity = ARENA_ALLOCATOR_INITIAL_CAPACITY);
-	~ArenaAllocator();
-
-	data_ptr_t Allocate(idx_t size);
-	void Destroy();
-	void Move(ArenaAllocator &allocator);
-
-	ArenaChunk *GetHead();
-	ArenaChunk *GetTail();
-
-	bool IsEmpty();
-
-private:
-	//! Internal allocator that is used by the arena allocator
-	Allocator &allocator;
-	idx_t current_capacity;
-	unique_ptr<ArenaChunk> head;
-	ArenaChunk *tail;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-//! A string heap is the owner of a set of strings, strings can be inserted into
-//! it On every insert, a pointer to the inserted string is returned The
-//! returned pointer will remain valid until the StringHeap is destroyed
-class StringHeap {
-public:
-	StringHeap();
-
-	void Destroy();
-	void Move(StringHeap &other);
-
-	//! Add a string to the string heap, returns a pointer to the string
-	string_t AddString(const char *data, idx_t len);
-	//! Add a string to the string heap, returns a pointer to the string
-	string_t AddString(const char *data);
-	//! Add a string to the string heap, returns a pointer to the string
-	string_t AddString(const string &data);
-	//! Add a string to the string heap, returns a pointer to the string
-	string_t AddString(const string_t &data);
-	//! Add a blob to the string heap; blobs can be non-valid UTF8
-	string_t AddBlob(const string_t &data);
-	//! Add a blob to the string heap; blobs can be non-valid UTF8
-	string_t AddBlob(const char *data, idx_t len);
-	//! Allocates space for an empty string of size "len" on the heap
-	string_t EmptyString(idx_t len);
-
-private:
-	ArenaAllocator allocator;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/string_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-struct string_t {
-	friend struct StringComparisonOperators;
-	friend class StringSegment;
-
-public:
-	static constexpr idx_t PREFIX_LENGTH = 4 * sizeof(char);
-	static constexpr idx_t INLINE_LENGTH = 12;
-
-	string_t() = default;
-	explicit string_t(uint32_t len) {
-		value.inlined.length = len;
-	}
-	string_t(const char *data, uint32_t len) {
-		value.inlined.length = len;
-		D_ASSERT(data || GetSize() == 0);
-		if (IsInlined()) {
-			// zero initialize the prefix first
-			// this makes sure that strings with length smaller than 4 still have an equal prefix
-			memset(value.inlined.inlined, 0, INLINE_LENGTH);
-			if (GetSize() == 0) {
-				return;
-			}
-			// small string: inlined
-			memcpy(value.inlined.inlined, data, GetSize());
-		} else {
-			// large string: store pointer
-			memcpy(value.pointer.prefix, data, PREFIX_LENGTH);
-			value.pointer.ptr = (char *)data;
-		}
-	}
-	string_t(const char *data) : string_t(data, strlen(data)) { // NOLINT: Allow implicit conversion from `const char*`
-	}
-	string_t(const string &value)
-	    : string_t(value.c_str(), value.size()) { // NOLINT: Allow implicit conversion from `const char*`
-	}
-
-	bool IsInlined() const {
-		return GetSize() <= INLINE_LENGTH;
-	}
-
-	//! this is unsafe since the string will not be terminated at the end
-	const char *GetDataUnsafe() const {
-		return IsInlined() ? (const char *)value.inlined.inlined : value.pointer.ptr;
-	}
-
-	char *GetDataWriteable() const {
-		return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr;
-	}
-
-	const char *GetPrefix() const {
-		return value.pointer.prefix;
-	}
-
-	idx_t GetSize() const {
-		return value.inlined.length;
-	}
-
-	string GetString() const {
-		return string(GetDataUnsafe(), GetSize());
-	}
-
-	explicit operator string() const {
-		return GetString();
-	}
-
-	void Finalize() {
-		// set trailing NULL byte
-		auto dataptr = (char *)GetDataUnsafe();
-		if (GetSize() <= INLINE_LENGTH) {
-			// fill prefix with zeros if the length is smaller than the prefix length
-			for (idx_t i = GetSize(); i < INLINE_LENGTH; i++) {
-				value.inlined.inlined[i] = '\0';
-			}
-		} else {
-			// copy the data into the prefix
-			memcpy(value.pointer.prefix, dataptr, PREFIX_LENGTH);
-		}
-	}
-
-	void Verify();
-	void VerifyNull();
-	bool operator<(const string_t &r) const {
-		auto this_str = this->GetString();
-		auto r_str = r.GetString();
-		return this_str < r_str;
-	}
-
-private:
-	union {
-		struct {
-			uint32_t length;
-			char prefix[4];
-			char *ptr;
-		} pointer;
-		struct {
-			uint32_t length;
-			char inlined[12];
-		} inlined;
-	} value;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer/buffer_handle.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-struct FileHandle;
-
-//! The version number of the database storage format
-extern const uint64_t VERSION_NUMBER;
-
-using block_id_t = int64_t;
-
-#define INVALID_BLOCK (-1)
-
-// maximum block id, 2^62
-#define MAXIMUM_BLOCK 4611686018427388000LL
-
-//! The MainHeader is the first header in the storage file. The MainHeader is typically written only once for a database
-//! file.
-struct MainHeader {
-	static constexpr idx_t MAGIC_BYTE_SIZE = 4;
-	static constexpr idx_t MAGIC_BYTE_OFFSET = sizeof(uint64_t);
-	static constexpr idx_t FLAG_COUNT = 4;
-	// the magic bytes in front of the file
-	// should be "DUCK"
-	static const char MAGIC_BYTES[];
-	//! The version of the database
-	uint64_t version_number;
-	//! The set of flags used by the database
-	uint64_t flags[FLAG_COUNT];
-
-	static void CheckMagicBytes(FileHandle &handle);
-
-	void Serialize(Serializer &ser);
-	static MainHeader Deserialize(Deserializer &source);
-};
-
-//! The DatabaseHeader contains information about the current state of the database. Every storage file has two
-//! DatabaseHeaders. On startup, the DatabaseHeader with the highest iteration count is used as the active header. When
-//! a checkpoint is performed, the active DatabaseHeader is switched by increasing the iteration count of the
-//! DatabaseHeader.
-struct DatabaseHeader {
-	//! The iteration count, increases by 1 every time the storage is checkpointed.
-	uint64_t iteration;
-	//! A pointer to the initial meta block
-	block_id_t meta_block;
-	//! A pointer to the block containing the free list
-	block_id_t free_list;
-	//! The number of blocks that is in the file as of this database header. If the file is larger than BLOCK_SIZE *
-	//! block_count any blocks appearing AFTER block_count are implicitly part of the free_list.
-	uint64_t block_count;
-
-	void Serialize(Serializer &ser);
-	static DatabaseHeader Deserialize(Deserializer &source);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class BlockHandle;
-class FileBuffer;
-
-class BufferHandle {
-public:
-	DUCKDB_API BufferHandle();
-	DUCKDB_API BufferHandle(shared_ptr<BlockHandle> handle, FileBuffer *node);
-	DUCKDB_API ~BufferHandle();
-	// disable copy constructors
-	DUCKDB_API BufferHandle(const BufferHandle &other) = delete;
-	DUCKDB_API BufferHandle &operator=(const BufferHandle &) = delete;
-	//! enable move constructors
-	DUCKDB_API BufferHandle(BufferHandle &&other) noexcept;
-	DUCKDB_API BufferHandle &operator=(BufferHandle &&) noexcept;
-
-public:
-	//! Returns whether or not the BufferHandle is valid.
-	DUCKDB_API bool IsValid() const;
-	//! Returns a pointer to the buffer data. Handle must be valid.
-	DUCKDB_API data_ptr_t Ptr() const;
-	//! Returns a pointer to the buffer data. Handle must be valid.
-	DUCKDB_API data_ptr_t Ptr();
-	//! Gets the block id of the underlying block. Handle must be valid.
-	DUCKDB_API block_id_t GetBlockId() const;
-	//! Gets the underlying file buffer. Handle must be valid.
-	DUCKDB_API FileBuffer &GetFileBuffer();
-	//! Destroys the buffer handle
-	DUCKDB_API void Destroy();
-
-private:
-	//! The block handle
-	shared_ptr<BlockHandle> handle;
-	//! The managed buffer node
-	FileBuffer *node;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class BufferHandle;
-class VectorBuffer;
-class Vector;
-class ChunkCollection;
-
-enum class VectorBufferType : uint8_t {
-	STANDARD_BUFFER,     // standard buffer, holds a single array of data
-	DICTIONARY_BUFFER,   // dictionary buffer, holds a selection vector
-	VECTOR_CHILD_BUFFER, // vector child buffer: holds another vector
-	STRING_BUFFER,       // string buffer, holds a string heap
-	STRUCT_BUFFER,       // struct buffer, holds a ordered mapping from name to child vector
-	LIST_BUFFER,         // list buffer, holds a single flatvector child
-	MANAGED_BUFFER,      // managed buffer, holds a buffer managed by the buffermanager
-	OPAQUE_BUFFER        // opaque buffer, can be created for example by the parquet reader
-};
-
-enum class VectorAuxiliaryDataType : uint8_t {
-	ARROW_AUXILIARY // Holds Arrow Chunks that this vector depends on
-};
-
-struct VectorAuxiliaryData {
-	explicit VectorAuxiliaryData(VectorAuxiliaryDataType type_p)
-	    : type(type_p) {
-
-	      };
-	VectorAuxiliaryDataType type;
-
-	virtual ~VectorAuxiliaryData() {
-	}
-};
-
-//! The VectorBuffer is a class used by the vector to hold its data
-class VectorBuffer {
-public:
-	explicit VectorBuffer(VectorBufferType type) : buffer_type(type) {
-	}
-	explicit VectorBuffer(idx_t data_size) : buffer_type(VectorBufferType::STANDARD_BUFFER) {
-		if (data_size > 0) {
-			data = unique_ptr<data_t[]>(new data_t[data_size]);
-		}
-	}
-	explicit VectorBuffer(unique_ptr<data_t[]> data_p)
-	    : buffer_type(VectorBufferType::STANDARD_BUFFER), data(std::move(data_p)) {
-	}
-	virtual ~VectorBuffer() {
-	}
-	VectorBuffer() {
-	}
-
-public:
-	data_ptr_t GetData() {
-		return data.get();
-	}
-
-	void SetData(unique_ptr<data_t[]> new_data) {
-		data = std::move(new_data);
-	}
-
-	VectorAuxiliaryData *GetAuxiliaryData() {
-		return aux_data.get();
-	}
-
-	void SetAuxiliaryData(unique_ptr<VectorAuxiliaryData> aux_data_p) {
-		aux_data = std::move(aux_data_p);
-	}
-
-	static buffer_ptr<VectorBuffer> CreateStandardVector(PhysicalType type, idx_t capacity = STANDARD_VECTOR_SIZE);
-	static buffer_ptr<VectorBuffer> CreateConstantVector(PhysicalType type);
-	static buffer_ptr<VectorBuffer> CreateConstantVector(const LogicalType &logical_type);
-	static buffer_ptr<VectorBuffer> CreateStandardVector(const LogicalType &logical_type,
-	                                                     idx_t capacity = STANDARD_VECTOR_SIZE);
-
-	inline VectorBufferType GetBufferType() const {
-		return buffer_type;
-	}
-
-	inline VectorAuxiliaryDataType GetAuxiliaryDataType() const {
-		return aux_data->type;
-	}
-
-protected:
-	VectorBufferType buffer_type;
-	unique_ptr<VectorAuxiliaryData> aux_data;
-	unique_ptr<data_t[]> data;
-};
-
-//! The DictionaryBuffer holds a selection vector
-class DictionaryBuffer : public VectorBuffer {
-public:
-	explicit DictionaryBuffer(const SelectionVector &sel)
-	    : VectorBuffer(VectorBufferType::DICTIONARY_BUFFER), sel_vector(sel) {
-	}
-	explicit DictionaryBuffer(buffer_ptr<SelectionData> data)
-	    : VectorBuffer(VectorBufferType::DICTIONARY_BUFFER), sel_vector(std::move(data)) {
-	}
-	explicit DictionaryBuffer(idx_t count = STANDARD_VECTOR_SIZE)
-	    : VectorBuffer(VectorBufferType::DICTIONARY_BUFFER), sel_vector(count) {
-	}
-
-public:
-	const SelectionVector &GetSelVector() const {
-		return sel_vector;
-	}
-	SelectionVector &GetSelVector() {
-		return sel_vector;
-	}
-	void SetSelVector(const SelectionVector &vector) {
-		this->sel_vector.Initialize(vector);
-	}
-
-private:
-	SelectionVector sel_vector;
-};
-
-class VectorStringBuffer : public VectorBuffer {
-public:
-	VectorStringBuffer();
-
-public:
-	string_t AddString(const char *data, idx_t len) {
-		return heap.AddString(data, len);
-	}
-	string_t AddString(string_t data) {
-		return heap.AddString(data);
-	}
-	string_t AddBlob(string_t data) {
-		return heap.AddBlob(data.GetDataUnsafe(), data.GetSize());
-	}
-	string_t EmptyString(idx_t len) {
-		return heap.EmptyString(len);
-	}
-
-	void AddHeapReference(buffer_ptr<VectorBuffer> heap) {
-		references.push_back(std::move(heap));
-	}
-
-private:
-	//! The string heap of this buffer
-	StringHeap heap;
-	// References to additional vector buffers referenced by this string buffer
-	vector<buffer_ptr<VectorBuffer>> references;
-};
-
-class VectorStructBuffer : public VectorBuffer {
-public:
-	VectorStructBuffer();
-	VectorStructBuffer(const LogicalType &struct_type, idx_t capacity = STANDARD_VECTOR_SIZE);
-	VectorStructBuffer(Vector &other, const SelectionVector &sel, idx_t count);
-	~VectorStructBuffer() override;
-
-public:
-	const vector<unique_ptr<Vector>> &GetChildren() const {
-		return children;
-	}
-	vector<unique_ptr<Vector>> &GetChildren() {
-		return children;
-	}
-
-private:
-	//! child vectors used for nested data
-	vector<unique_ptr<Vector>> children;
-};
-
-class VectorListBuffer : public VectorBuffer {
-public:
-	VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity = STANDARD_VECTOR_SIZE);
-	VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity = STANDARD_VECTOR_SIZE);
-	~VectorListBuffer() override;
-
-public:
-	Vector &GetChild() {
-		return *child;
-	}
-	void Reserve(idx_t to_reserve);
-
-	void Append(const Vector &to_append, idx_t to_append_size, idx_t source_offset = 0);
-	void Append(const Vector &to_append, const SelectionVector &sel, idx_t to_append_size, idx_t source_offset = 0);
-
-	void PushBack(const Value &insert);
-
-	idx_t capacity = 0;
-	idx_t size = 0;
-
-private:
-	//! child vectors used for nested data
-	unique_ptr<Vector> child;
-};
-
-//! The ManagedVectorBuffer holds a buffer handle
-class ManagedVectorBuffer : public VectorBuffer {
-public:
-	explicit ManagedVectorBuffer(BufferHandle handle);
-	~ManagedVectorBuffer() override;
-
-private:
-	BufferHandle handle;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct VectorData {
-	const SelectionVector *sel;
-	data_ptr_t data;
-	ValidityMask validity;
-	SelectionVector owned_sel;
-};
-
-class VectorCache;
-class VectorStructBuffer;
-class VectorListBuffer;
-class ChunkCollection;
-
-struct SelCache;
-
-//!  Vector of values of a specified PhysicalType.
-class Vector {
-	friend struct ConstantVector;
-	friend struct DictionaryVector;
-	friend struct FlatVector;
-	friend struct ListVector;
-	friend struct StringVector;
-	friend struct StructVector;
-	friend struct SequenceVector;
-
-	friend class DataChunk;
-	friend class VectorCacheBuffer;
-
-public:
-	//! Create a vector that references the other vector
-	DUCKDB_API explicit Vector(Vector &other);
-	//! Create a vector that slices another vector
-	DUCKDB_API explicit Vector(Vector &other, const SelectionVector &sel, idx_t count);
-	//! Create a vector that slices another vector starting from a specific offset
-	DUCKDB_API explicit Vector(Vector &other, idx_t offset);
-	//! Create a vector of size one holding the passed on value
-	DUCKDB_API explicit Vector(const Value &value);
-	//! Create a vector of size tuple_count (non-standard)
-	DUCKDB_API explicit Vector(LogicalType type, idx_t capacity = STANDARD_VECTOR_SIZE);
-	//! Create an empty standard vector with a type, equivalent to calling Vector(type, true, false)
-	DUCKDB_API explicit Vector(const VectorCache &cache);
-	//! Create a non-owning vector that references the specified data
-	DUCKDB_API Vector(LogicalType type, data_ptr_t dataptr);
-	//! Create an owning vector that holds at most STANDARD_VECTOR_SIZE entries.
-	/*!
-	    Create a new vector
-	    If create_data is true, the vector will be an owning empty vector.
-	    If zero_data is true, the allocated data will be zero-initialized.
-	*/
-	DUCKDB_API Vector(LogicalType type, bool create_data, bool zero_data, idx_t capacity = STANDARD_VECTOR_SIZE);
-	// implicit copying of Vectors is not allowed
-	Vector(const Vector &) = delete;
-	// but moving of vectors is allowed
-	DUCKDB_API Vector(Vector &&other) noexcept;
-
-public:
-	//! Create a vector that references the specified value.
-	DUCKDB_API void Reference(const Value &value);
-	//! Causes this vector to reference the data held by the other vector.
-	//! The type of the "other" vector should match the type of this vector
-	DUCKDB_API void Reference(Vector &other);
-	//! Reinterpret the data of the other vector as the type of this vector
-	//! Note that this takes the data of the other vector as-is and places it in this vector
-	//! Without changing the type of this vector
-	DUCKDB_API void Reinterpret(Vector &other);
-
-	//! Causes this vector to reference the data held by the other vector, changes the type if required.
-	DUCKDB_API void ReferenceAndSetType(Vector &other);
-
-	//! Resets a vector from a vector cache.
-	//! This turns the vector back into an empty FlatVector with STANDARD_VECTOR_SIZE entries.
-	//! The VectorCache is used so this can be done without requiring any allocations.
-	DUCKDB_API void ResetFromCache(const VectorCache &cache);
-
-	//! Creates a reference to a slice of the other vector
-	DUCKDB_API void Slice(Vector &other, idx_t offset);
-	//! Creates a reference to a slice of the other vector
-	DUCKDB_API void Slice(Vector &other, const SelectionVector &sel, idx_t count);
-	//! Turns the vector into a dictionary vector with the specified dictionary
-	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count);
-	//! Slice the vector, keeping the result around in a cache or potentially using the cache instead of slicing
-	DUCKDB_API void Slice(const SelectionVector &sel, idx_t count, SelCache &cache);
-
-	//! Creates the data of this vector with the specified type. Any data that
-	//! is currently in the vector is destroyed.
-	DUCKDB_API void Initialize(bool zero_data = false, idx_t capacity = STANDARD_VECTOR_SIZE);
-
-	//! Converts this Vector to a printable string representation
-	DUCKDB_API string ToString(idx_t count) const;
-	DUCKDB_API void Print(idx_t count);
-
-	DUCKDB_API string ToString() const;
-	DUCKDB_API void Print();
-
-	//! Flatten the vector, removing any compression and turning it into a FLAT_VECTOR
-	DUCKDB_API void Normalify(idx_t count);
-	DUCKDB_API void Normalify(const SelectionVector &sel, idx_t count);
-	//! Obtains a selection vector and data pointer through which the data of this vector can be accessed
-	DUCKDB_API void Orrify(idx_t count, VectorData &data);
-
-	//! Turn the vector into a sequence vector
-	DUCKDB_API void Sequence(int64_t start, int64_t increment);
-
-	//! Verify that the Vector is in a consistent, not corrupt state. DEBUG
-	//! FUNCTION ONLY!
-	DUCKDB_API void Verify(idx_t count);
-	//! Asserts that the CheckMapValidity returns MapInvalidReason::VALID
-	DUCKDB_API static void VerifyMap(Vector &map, const SelectionVector &sel, idx_t count);
-	DUCKDB_API static void Verify(Vector &vector, const SelectionVector &sel, idx_t count);
-	DUCKDB_API void UTFVerify(idx_t count);
-	DUCKDB_API void UTFVerify(const SelectionVector &sel, idx_t count);
-
-	//! Returns the [index] element of the Vector as a Value.
-	DUCKDB_API Value GetValue(idx_t index) const;
-	//! Sets the [index] element of the Vector to the specified Value.
-	DUCKDB_API void SetValue(idx_t index, const Value &val);
-
-	inline void SetAuxiliary(buffer_ptr<VectorBuffer> new_buffer) {
-		auxiliary = std::move(new_buffer);
-	};
-
-	//! This functions resizes the vector
-	DUCKDB_API void Resize(idx_t cur_size, idx_t new_size);
-
-	//! Serializes a Vector to a stand-alone binary blob
-	DUCKDB_API void Serialize(idx_t count, Serializer &serializer);
-	//! Deserializes a blob back into a Vector
-	DUCKDB_API void Deserialize(idx_t count, Deserializer &source);
-
-	// Getters
-	inline VectorType GetVectorType() const {
-		return vector_type;
-	}
-	inline const LogicalType &GetType() const {
-		return type;
-	}
-	inline data_ptr_t GetData() {
-		return data;
-	}
-
-	inline buffer_ptr<VectorBuffer> GetAuxiliary() {
-		return auxiliary;
-	}
-
-	inline buffer_ptr<VectorBuffer> GetBuffer() {
-		return buffer;
-	}
-
-	// Setters
-	DUCKDB_API void SetVectorType(VectorType vector_type);
-
-private:
-	//! Returns the [index] element of the Vector as a Value.
-	DUCKDB_API static Value GetValue(const Vector &v, idx_t index);
-
-protected:
-	//! The vector type specifies how the data of the vector is physically stored (i.e. if it is a single repeated
-	//! constant, if it is compressed)
-	VectorType vector_type;
-	//! The type of the elements stored in the vector (e.g. integer, float)
-	LogicalType type;
-	//! A pointer to the data.
-	data_ptr_t data;
-	//! The validity mask of the vector
-	ValidityMask validity;
-	//! The main buffer holding the data of the vector
-	buffer_ptr<VectorBuffer> buffer;
-	//! The buffer holding auxiliary data of the vector
-	//! e.g. a string vector uses this to store strings
-	buffer_ptr<VectorBuffer> auxiliary;
-};
-
-//! The DictionaryBuffer holds a selection vector
-class VectorChildBuffer : public VectorBuffer {
-public:
-	VectorChildBuffer(Vector vector) : VectorBuffer(VectorBufferType::VECTOR_CHILD_BUFFER), data(std::move(vector)) {
-	}
-
-public:
-	Vector data;
-};
-
-struct ConstantVector {
-	static inline const_data_ptr_t GetData(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR ||
-		         vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return vector.data;
-	}
-	static inline data_ptr_t GetData(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR ||
-		         vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return vector.data;
-	}
-	template <class T>
-	static inline const T *GetData(const Vector &vector) {
-		return (const T *)ConstantVector::GetData(vector);
-	}
-	template <class T>
-	static inline T *GetData(Vector &vector) {
-		return (T *)ConstantVector::GetData(vector);
-	}
-	static inline bool IsNull(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-		return !vector.validity.RowIsValid(0);
-	}
-	DUCKDB_API static void SetNull(Vector &vector, bool is_null);
-	static inline ValidityMask &Validity(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
-		return vector.validity;
-	}
-	DUCKDB_API static const SelectionVector *ZeroSelectionVector(idx_t count, SelectionVector &owned_sel);
-	DUCKDB_API static const SelectionVector *ZeroSelectionVector();
-	//! Turns "vector" into a constant vector by referencing a value within the source vector
-	DUCKDB_API static void Reference(Vector &vector, Vector &source, idx_t position, idx_t count);
-
-	static const sel_t ZERO_VECTOR[STANDARD_VECTOR_SIZE];
-};
-
-struct DictionaryVector {
-	static inline const SelectionVector &SelVector(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-		return ((const DictionaryBuffer &)*vector.buffer).GetSelVector();
-	}
-	static inline SelectionVector &SelVector(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-		return ((DictionaryBuffer &)*vector.buffer).GetSelVector();
-	}
-	static inline const Vector &Child(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-		return ((const VectorChildBuffer &)*vector.auxiliary).data;
-	}
-	static inline Vector &Child(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-		return ((VectorChildBuffer &)*vector.auxiliary).data;
-	}
-};
-
-struct FlatVector {
-	static inline data_ptr_t GetData(Vector &vector) {
-		return ConstantVector::GetData(vector);
-	}
-	template <class T>
-	static inline const T *GetData(const Vector &vector) {
-		return ConstantVector::GetData<T>(vector);
-	}
-	template <class T>
-	static inline T *GetData(Vector &vector) {
-		return ConstantVector::GetData<T>(vector);
-	}
-	static inline void SetData(Vector &vector, data_ptr_t data) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		vector.data = data;
-	}
-	template <class T>
-	static inline T GetValue(Vector &vector, idx_t idx) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return FlatVector::GetData<T>(vector)[idx];
-	}
-	static inline const ValidityMask &Validity(const Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return vector.validity;
-	}
-	static inline ValidityMask &Validity(Vector &vector) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return vector.validity;
-	}
-	static inline void SetValidity(Vector &vector, ValidityMask &new_validity) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		vector.validity.Initialize(new_validity);
-	}
-	static void SetNull(Vector &vector, idx_t idx, bool is_null);
-	static inline bool IsNull(const Vector &vector, idx_t idx) {
-		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
-		return !vector.validity.RowIsValid(idx);
-	}
-	DUCKDB_API static const SelectionVector *IncrementalSelectionVector();
-};
-
-struct ListVector {
-	static inline list_entry_t *GetData(Vector &v) {
-		if (v.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
-			auto &child = DictionaryVector::Child(v);
-			return GetData(child);
-		}
-		return FlatVector::GetData<list_entry_t>(v);
-	}
-	//! Gets a reference to the underlying child-vector of a list
-	DUCKDB_API static const Vector &GetEntry(const Vector &vector);
-	//! Gets a reference to the underlying child-vector of a list
-	DUCKDB_API static Vector &GetEntry(Vector &vector);
-	//! Gets the total size of the underlying child-vector of a list
-	DUCKDB_API static idx_t GetListSize(const Vector &vector);
-	//! Sets the total size of the underlying child-vector of a list
-	DUCKDB_API static void SetListSize(Vector &vec, idx_t size);
-	DUCKDB_API static void Reserve(Vector &vec, idx_t required_capacity);
-	DUCKDB_API static void Append(Vector &target, const Vector &source, idx_t source_size, idx_t source_offset = 0);
-	DUCKDB_API static void Append(Vector &target, const Vector &source, const SelectionVector &sel, idx_t source_size,
-	                              idx_t source_offset = 0);
-	DUCKDB_API static void PushBack(Vector &target, const Value &insert);
-	DUCKDB_API static vector<idx_t> Search(Vector &list, const Value &key, idx_t row);
-	DUCKDB_API static Value GetValuesFromOffsets(Vector &list, vector<idx_t> &offsets);
-	//! Share the entry of the other list vector
-	DUCKDB_API static void ReferenceEntry(Vector &vector, Vector &other);
-};
-
-struct StringVector {
-	//! Add a string to the string heap of the vector (auxiliary data)
-	DUCKDB_API static string_t AddString(Vector &vector, const char *data, idx_t len);
-	//! Add a string or a blob to the string heap of the vector (auxiliary data)
-	//! This function is the same as ::AddString, except the added data does not need to be valid UTF8
-	DUCKDB_API static string_t AddStringOrBlob(Vector &vector, const char *data, idx_t len);
-	//! Add a string to the string heap of the vector (auxiliary data)
-	DUCKDB_API static string_t AddString(Vector &vector, const char *data);
-	//! Add a string to the string heap of the vector (auxiliary data)
-	DUCKDB_API static string_t AddString(Vector &vector, string_t data);
-	//! Add a string to the string heap of the vector (auxiliary data)
-	DUCKDB_API static string_t AddString(Vector &vector, const string &data);
-	//! Add a string or a blob to the string heap of the vector (auxiliary data)
-	//! This function is the same as ::AddString, except the added data does not need to be valid UTF8
-	DUCKDB_API static string_t AddStringOrBlob(Vector &vector, string_t data);
-	//! Allocates an empty string of the specified size, and returns a writable pointer that can be used to store the
-	//! result of an operation
-	DUCKDB_API static string_t EmptyString(Vector &vector, idx_t len);
-	//! Adds a reference to a handle that stores strings of this vector
-	DUCKDB_API static void AddHandle(Vector &vector, BufferHandle handle);
-	//! Adds a reference to an unspecified vector buffer that stores strings of this vector
-	DUCKDB_API static void AddBuffer(Vector &vector, buffer_ptr<VectorBuffer> buffer);
-	//! Add a reference from this vector to the string heap of the provided vector
-	DUCKDB_API static void AddHeapReference(Vector &vector, Vector &other);
-};
-
-struct StructVector {
-	DUCKDB_API static const vector<unique_ptr<Vector>> &GetEntries(const Vector &vector);
-	DUCKDB_API static vector<unique_ptr<Vector>> &GetEntries(Vector &vector);
-};
-
-struct SequenceVector {
-	static void GetSequence(const Vector &vector, int64_t &start, int64_t &increment) {
-		D_ASSERT(vector.GetVectorType() == VectorType::SEQUENCE_VECTOR);
-		auto data = (int64_t *)vector.buffer->GetData();
-		start = data[0];
-		increment = data[1];
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/vector_operations.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/data_chunk.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow_wrapper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef ARROW_FLAG_DICTIONARY_ORDERED
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef ARROW_C_DATA_INTERFACE
-#define ARROW_C_DATA_INTERFACE
-
-#define ARROW_FLAG_DICTIONARY_ORDERED 1
-#define ARROW_FLAG_NULLABLE           2
-#define ARROW_FLAG_MAP_KEYS_SORTED    4
-
-struct ArrowSchema {
-	// Array type description
-	const char *format;
-	const char *name;
-	const char *metadata;
-	int64_t flags;
-	int64_t n_children;
-	struct ArrowSchema **children;
-	struct ArrowSchema *dictionary;
-
-	// Release callback
-	void (*release)(struct ArrowSchema *);
-	// Opaque producer-specific data
-	void *private_data;
-};
-
-struct ArrowArray {
-	// Array data description
-	int64_t length;
-	int64_t null_count;
-	int64_t offset;
-	int64_t n_buffers;
-	int64_t n_children;
-	const void **buffers;
-	struct ArrowArray **children;
-	struct ArrowArray *dictionary;
-
-	// Release callback
-	void (*release)(struct ArrowArray *);
-	// Opaque producer-specific data
-	void *private_data;
-};
-#endif
-
-#ifndef ARROW_C_STREAM_INTERFACE
-#define ARROW_C_STREAM_INTERFACE
-// EXPERIMENTAL
-struct ArrowArrayStream {
-	// Callback to get the stream type
-	// (will be the same for all arrays in the stream).
-	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
-	int (*get_schema)(struct ArrowArrayStream *, struct ArrowSchema *out);
-	// Callback to get the next array
-	// (if no error and the array is released, the stream has ended)
-	// Return value: 0 if successful, an `errno`-compatible error code otherwise.
-	int (*get_next)(struct ArrowArrayStream *, struct ArrowArray *out);
-
-	// Callback to get optional detailed error information.
-	// This must only be called if the last stream operation failed
-	// with a non-0 return code.  The returned pointer is only valid until
-	// the next operation on this stream (including release).
-	// If unavailable, NULL is returned.
-	const char *(*get_last_error)(struct ArrowArrayStream *);
-
-	// Release callback: release the stream's own resources.
-	// Note that arrays returned by `get_next` must be individually released.
-	void (*release)(struct ArrowArrayStream *);
-	// Opaque producer-specific data
-	void *private_data;
-};
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-
-
-//! Here we have the internal duckdb classes that interact with Arrow's Internal Header (i.e., duckdb/commons/arrow.hpp)
-namespace duckdb {
-class QueryResult;
-class DataChunk;
-
-class ArrowSchemaWrapper {
-public:
-	ArrowSchema arrow_schema;
-
-	ArrowSchemaWrapper() {
-		arrow_schema.release = nullptr;
-	}
-
-	~ArrowSchemaWrapper();
-};
-class ArrowArrayWrapper {
-public:
-	ArrowArray arrow_array;
-	ArrowArrayWrapper() {
-		arrow_array.length = 0;
-		arrow_array.release = nullptr;
-	}
-	~ArrowArrayWrapper();
-};
-
-class ArrowArrayStreamWrapper {
-public:
-	ArrowArrayStream arrow_array_stream;
-	int64_t number_of_rows;
-	void GetSchema(ArrowSchemaWrapper &schema);
-
-	shared_ptr<ArrowArrayWrapper> GetNextChunk();
-
-	const char *GetError();
-
-	~ArrowArrayStreamWrapper();
-	ArrowArrayStreamWrapper() {
-		arrow_array_stream.release = nullptr;
-	}
-};
-
-class ArrowUtil {
-public:
-	static unique_ptr<DataChunk> FetchChunk(QueryResult *result, idx_t chunk_size);
-
-private:
-	static unique_ptr<DataChunk> FetchNext(QueryResult &result);
-};
-} // namespace duckdb
-
-
-struct ArrowArray;
-
-namespace duckdb {
-class Allocator;
-class ClientContext;
-class ExecutionContext;
-class VectorCache;
-
-//!  A Data Chunk represents a set of vectors.
-/*!
-    The data chunk class is the intermediate representation used by the
-   execution engine of DuckDB. It effectively represents a subset of a relation.
-   It holds a set of vectors that all have the same length.
-
-    DataChunk is initialized using the DataChunk::Initialize function by
-   providing it with a vector of TypeIds for the Vector members. By default,
-   this function will also allocate a chunk of memory in the DataChunk for the
-   vectors and all the vectors will be referencing vectors to the data owned by
-   the chunk. The reason for this behavior is that the underlying vectors can
-   become referencing vectors to other chunks as well (i.e. in the case an
-   operator does not alter the data, such as a Filter operator which only adds a
-   selection vector).
-
-    In addition to holding the data of the vectors, the DataChunk also owns the
-   selection vector that underlying vectors can point to.
-*/
-class DataChunk {
-public:
-	//! Creates an empty DataChunk
-	DUCKDB_API DataChunk();
-	DUCKDB_API ~DataChunk();
-
-	//! The vectors owned by the DataChunk.
-	vector<Vector> data;
-
-public:
-	inline idx_t size() const { // NOLINT
-		return count;
-	}
-	inline idx_t ColumnCount() const {
-		return data.size();
-	}
-	inline void SetCardinality(idx_t count_p) {
-		D_ASSERT(count_p <= capacity);
-		this->count = count_p;
-	}
-	inline void SetCardinality(const DataChunk &other) {
-		this->count = other.size();
-	}
-	inline void SetCapacity(const DataChunk &other) {
-		this->capacity = other.capacity;
-	}
-
-	DUCKDB_API Value GetValue(idx_t col_idx, idx_t index) const;
-	DUCKDB_API void SetValue(idx_t col_idx, idx_t index, const Value &val);
-
-	//! Set the DataChunk to reference another data chunk
-	DUCKDB_API void Reference(DataChunk &chunk);
-	//! Set the DataChunk to own the data of data chunk, destroying the other chunk in the process
-	DUCKDB_API void Move(DataChunk &chunk);
-
-	//! Initializes the DataChunk with the specified types to an empty DataChunk
-	//! This will create one vector of the specified type for each LogicalType in the
-	//! types list. The vector will be referencing vector to the data owned by
-	//! the DataChunk.
-	DUCKDB_API void Initialize(Allocator &allocator, const vector<LogicalType> &types);
-	DUCKDB_API void Initialize(ClientContext &context, const vector<LogicalType> &types);
-	//! Initializes an empty DataChunk with the given types. The vectors will *not* have any data allocated for them.
-	DUCKDB_API void InitializeEmpty(const vector<LogicalType> &types);
-	//! Append the other DataChunk to this one. The column count and types of
-	//! the two DataChunks have to match exactly. Throws an exception if there
-	//! is not enough space in the chunk and resize is not allowed.
-	DUCKDB_API void Append(const DataChunk &other, bool resize = false, SelectionVector *sel = nullptr,
-	                       idx_t count = 0);
-
-	//! Destroy all data and columns owned by this DataChunk
-	DUCKDB_API void Destroy();
-
-	//! Copies the data from this vector to another vector.
-	DUCKDB_API void Copy(DataChunk &other, idx_t offset = 0) const;
-	DUCKDB_API void Copy(DataChunk &other, const SelectionVector &sel, const idx_t source_count,
-	                     const idx_t offset = 0) const;
-
-	//! Splits the DataChunk in two
-	DUCKDB_API void Split(DataChunk &other, idx_t split_idx);
-
-	//! Fuses a DataChunk onto the right of this one, and destroys the other. Inverse of Split.
-	DUCKDB_API void Fuse(DataChunk &other);
-
-	//! Turn all the vectors from the chunk into flat vectors
-	DUCKDB_API void Normalify();
-
-	DUCKDB_API unique_ptr<VectorData[]> Orrify();
-
-	DUCKDB_API void Slice(const SelectionVector &sel_vector, idx_t count);
-	DUCKDB_API void Slice(DataChunk &other, const SelectionVector &sel, idx_t count, idx_t col_offset = 0);
-
-	//! Resets the DataChunk to its state right after the DataChunk::Initialize
-	//! function was called. This sets the count to 0, and resets each member
-	//! Vector to point back to the data owned by this DataChunk.
-	DUCKDB_API void Reset();
-
-	//! Serializes a DataChunk to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer);
-	//! Deserializes a blob back into a DataChunk
-	DUCKDB_API void Deserialize(Deserializer &source);
-
-	//! Hashes the DataChunk to the target vector
-	DUCKDB_API void Hash(Vector &result);
-
-	//! Returns a list of types of the vectors of this data chunk
-	DUCKDB_API vector<LogicalType> GetTypes();
-
-	//! Converts this DataChunk to a printable string representation
-	DUCKDB_API string ToString() const;
-	DUCKDB_API void Print();
-
-	DataChunk(const DataChunk &) = delete;
-
-	//! Verify that the DataChunk is in a consistent, not corrupt state. DEBUG
-	//! FUNCTION ONLY!
-	DUCKDB_API void Verify();
-
-	//! export data chunk as a arrow struct array that can be imported as arrow record batch
-	DUCKDB_API void ToArrowArray(ArrowArray *out_array);
-
-private:
-	//! The amount of tuples stored in the data chunk
-	idx_t count;
-	//! The amount of tuples that can be stored in the data chunk
-	idx_t capacity;
-	//! Vector caches, used to store data when ::Initialize is called
-	vector<VectorCache> vector_caches;
-};
-} // namespace duckdb
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-// VectorOperations contains a set of operations that operate on sets of
-// vectors. In general, the operators must all have the same type, otherwise an
-// exception is thrown. Note that the functions underneath use restrict
-// pointers, hence the data that the vectors point to (and hence the vector
-// themselves) should not be equal! For example, if you call the function Add(A,
-// B, A) then ASSERT_RESTRICT will be triggered. Instead call AddInPlace(A, B)
-// or Add(A, B, C)
-struct VectorOperations {
-	//===--------------------------------------------------------------------===//
-	// In-Place Operators
-	//===--------------------------------------------------------------------===//
-	//! left += delta
-	static void AddInPlace(Vector &left, int64_t delta, idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// NULL Operators
-	//===--------------------------------------------------------------------===//
-	//! result = IS NOT NULL(input)
-	static void IsNotNull(Vector &arg, Vector &result, idx_t count);
-	//! result = IS NULL (input)
-	static void IsNull(Vector &input, Vector &result, idx_t count);
-	// Returns whether or not arg vector has a NULL value
-	static bool HasNull(Vector &input, idx_t count);
-	static bool HasNotNull(Vector &input, idx_t count);
-	//! Count the number of not-NULL values.
-	static idx_t CountNotNull(Vector &input, const idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// Boolean Operations
-	//===--------------------------------------------------------------------===//
-	// result = left && right
-	static void And(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left || right
-	static void Or(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = NOT(left)
-	static void Not(Vector &left, Vector &result, idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// Comparison Operations
-	//===--------------------------------------------------------------------===//
-	// result = left == right
-	static void Equals(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left != right
-	static void NotEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left > right
-	static void GreaterThan(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left >= right
-	static void GreaterThanEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left < right
-	static void LessThan(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result = left <= right
-	static void LessThanEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-
-	// result = A != B with nulls being equal
-	static void DistinctFrom(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A == B with nulls being equal
-	static void NotDistinctFrom(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A > B with nulls being maximal
-	static void DistinctGreaterThan(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A >= B with nulls being maximal
-	static void DistinctGreaterThanEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A < B with nulls being maximal
-	static void DistinctLessThan(Vector &left, Vector &right, Vector &result, idx_t count);
-	// result := A <= B with nulls being maximal
-	static void DistinctLessThanEquals(Vector &left, Vector &right, Vector &result, idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// Select Comparisons
-	//===--------------------------------------------------------------------===//
-	static idx_t Equals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-	                    SelectionVector *false_sel);
-	static idx_t NotEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                       SelectionVector *true_sel, SelectionVector *false_sel);
-	static idx_t GreaterThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                         SelectionVector *true_sel, SelectionVector *false_sel);
-	static idx_t GreaterThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                               SelectionVector *true_sel, SelectionVector *false_sel);
-	static idx_t LessThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                      SelectionVector *true_sel, SelectionVector *false_sel);
-	static idx_t LessThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                            SelectionVector *true_sel, SelectionVector *false_sel);
-
-	// true := A != B with nulls being equal
-	static idx_t DistinctFrom(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                          SelectionVector *true_sel, SelectionVector *false_sel);
-	// true := A == B with nulls being equal
-	static idx_t NotDistinctFrom(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                             SelectionVector *true_sel, SelectionVector *false_sel);
-	// true := A > B with nulls being maximal
-	static idx_t DistinctGreaterThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                                 SelectionVector *true_sel, SelectionVector *false_sel);
-	// true := A >= B with nulls being maximal
-	static idx_t DistinctGreaterThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                                       SelectionVector *true_sel, SelectionVector *false_sel);
-	// true := A < B with nulls being maximal
-	static idx_t DistinctLessThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                              SelectionVector *true_sel, SelectionVector *false_sel);
-	// true := A <= B with nulls being maximal
-	static idx_t DistinctLessThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                                    SelectionVector *true_sel, SelectionVector *false_sel);
-
-	// true := A > B with nulls being minimal
-	static idx_t DistinctGreaterThanNullsFirst(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                                           SelectionVector *true_sel, SelectionVector *false_sel);
-	// true := A < B with nulls being minimal
-	static idx_t DistinctLessThanNullsFirst(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                                        SelectionVector *true_sel, SelectionVector *false_sel);
-
-	//===--------------------------------------------------------------------===//
-	// Nested Comparisons
-	//===--------------------------------------------------------------------===//
-	// true := A != B with nulls being equal
-	static idx_t NestedNotEquals(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-	                             SelectionVector *true_sel, SelectionVector *false_sel);
-	// true := A == B with nulls being equal
-	static idx_t NestedEquals(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-	                          SelectionVector *true_sel, SelectionVector *false_sel);
-
-	//===--------------------------------------------------------------------===//
-	// Hash functions
-	//===--------------------------------------------------------------------===//
-	// hashes = HASH(input)
-	static void Hash(Vector &input, Vector &hashes, idx_t count);
-	static void Hash(Vector &input, Vector &hashes, const SelectionVector &rsel, idx_t count);
-	// hashes ^= HASH(input)
-	static void CombineHash(Vector &hashes, Vector &input, idx_t count);
-	static void CombineHash(Vector &hashes, Vector &input, const SelectionVector &rsel, idx_t count);
-
-	//===--------------------------------------------------------------------===//
-	// Generate functions
-	//===--------------------------------------------------------------------===//
-	static void GenerateSequence(Vector &result, idx_t count, int64_t start = 0, int64_t increment = 1);
-	static void GenerateSequence(Vector &result, idx_t count, const SelectionVector &sel, int64_t start = 0,
-	                             int64_t increment = 1);
-	//===--------------------------------------------------------------------===//
-	// Helpers
-	//===--------------------------------------------------------------------===//
-	//! Cast the data from the source type to the target type. Any elements that could not be converted are turned into
-	//! NULLs. If any elements cannot be converted, returns false and fills in the error_message. If no error message is
-	//! provided, an exception is thrown instead.
-	DUCKDB_API static bool TryCast(Vector &source, Vector &result, idx_t count, string *error_message,
-	                               bool strict = false);
-	//! Cast the data from the source type to the target type. Throws an exception if the cast fails.
-	static void Cast(Vector &source, Vector &result, idx_t count, bool strict = false);
-
-	// Copy the data of <source> to the target vector
-	static void Copy(const Vector &source, Vector &target, idx_t source_count, idx_t source_offset,
-	                 idx_t target_offset);
-	static void Copy(const Vector &source, Vector &target, const SelectionVector &sel, idx_t source_count,
-	                 idx_t source_offset, idx_t target_offset);
-
-	// Copy the data of <source> to the target location, setting null values to
-	// NullValue<T>. Used to store data without separate NULL mask.
-	static void WriteToStorage(Vector &source, idx_t count, data_ptr_t target);
-	// Reads the data of <source> to the target vector, setting the nullmask
-	// for any NullValue<T> of source. Used to go back from storage to a proper vector
-	static void ReadFromStorage(data_ptr_t source, idx_t count, Vector &result);
-};
-} // namespace duckdb
-
-
-#include <functional>
-
-namespace duckdb {
-
-struct DefaultNullCheckOperator {
-	template <class LEFT_TYPE, class RIGHT_TYPE>
-	static inline bool Operation(LEFT_TYPE left, RIGHT_TYPE right) {
-		return false;
-	}
-};
-
-struct BinaryStandardOperatorWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		return OP::template Operation<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(left, right);
-	}
-
-	static bool AddsNulls() {
-		return false;
-	}
-};
-
-struct BinarySingleArgumentOperatorWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		return OP::template Operation<LEFT_TYPE>(left, right);
-	}
-
-	static bool AddsNulls() {
-		return false;
-	}
-};
-
-struct BinaryLambdaWrapper {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		return fun(left, right);
-	}
-
-	static bool AddsNulls() {
-		return false;
-	}
-};
-
-struct BinaryLambdaWrapperWithNulls {
-	template <class FUNC, class OP, class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUNC fun, LEFT_TYPE left, RIGHT_TYPE right, ValidityMask &mask, idx_t idx) {
-		return fun(left, right, mask, idx);
-	}
-
-	static bool AddsNulls() {
-		return true;
-	}
-};
-
-struct BinaryExecutor {
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC,
-	          bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static void ExecuteFlatLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-	                            RESULT_TYPE *__restrict result_data, idx_t count, ValidityMask &mask, FUNC fun) {
-		if (!LEFT_CONSTANT) {
-			ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
-		}
-		if (!RIGHT_CONSTANT) {
-			ASSERT_RESTRICT(rdata, rdata + count, result_data, result_data + count);
-		}
-
-		if (!mask.AllValid()) {
-			idx_t base_idx = 0;
-			auto entry_count = ValidityMask::EntryCount(count);
-			for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-				auto validity_entry = mask.GetValidityEntry(entry_idx);
-				idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-				if (ValidityMask::AllValid(validity_entry)) {
-					// all valid: perform operation
-					for (; base_idx < next; base_idx++) {
-						auto lentry = ldata[LEFT_CONSTANT ? 0 : base_idx];
-						auto rentry = rdata[RIGHT_CONSTANT ? 0 : base_idx];
-						result_data[base_idx] =
-						    OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-						        fun, lentry, rentry, mask, base_idx);
-					}
-				} else if (ValidityMask::NoneValid(validity_entry)) {
-					// nothing valid: skip all
-					base_idx = next;
-					continue;
-				} else {
-					// partially valid: need to check individual elements for validity
-					idx_t start = base_idx;
-					for (; base_idx < next; base_idx++) {
-						if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-							auto lentry = ldata[LEFT_CONSTANT ? 0 : base_idx];
-							auto rentry = rdata[RIGHT_CONSTANT ? 0 : base_idx];
-							result_data[base_idx] =
-							    OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-							        fun, lentry, rentry, mask, base_idx);
-						}
-					}
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto lentry = ldata[LEFT_CONSTANT ? 0 : i];
-				auto rentry = rdata[RIGHT_CONSTANT ? 0 : i];
-				result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-				    fun, lentry, rentry, mask, i);
-			}
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteConstant(Vector &left, Vector &right, Vector &result, FUNC fun) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-		auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
-		auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
-		auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
-
-		if (ConstantVector::IsNull(left) || ConstantVector::IsNull(right)) {
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-		*result_data = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-		    fun, *ldata, *rdata, ConstantVector::Validity(result), 0);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC,
-	          bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static void ExecuteFlat(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		auto ldata = FlatVector::GetData<LEFT_TYPE>(left);
-		auto rdata = FlatVector::GetData<RIGHT_TYPE>(right);
-
-		if ((LEFT_CONSTANT && ConstantVector::IsNull(left)) || (RIGHT_CONSTANT && ConstantVector::IsNull(right))) {
-			// either left or right is constant NULL: result is constant NULL
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ConstantVector::SetNull(result, true);
-			return;
-		}
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-		auto &result_validity = FlatVector::Validity(result);
-		if (LEFT_CONSTANT) {
-			if (OPWRAPPER::AddsNulls()) {
-				result_validity.Copy(FlatVector::Validity(right), count);
-			} else {
-				FlatVector::SetValidity(result, FlatVector::Validity(right));
-			}
-		} else if (RIGHT_CONSTANT) {
-			if (OPWRAPPER::AddsNulls()) {
-				result_validity.Copy(FlatVector::Validity(left), count);
-			} else {
-				FlatVector::SetValidity(result, FlatVector::Validity(left));
-			}
-		} else {
-			if (OPWRAPPER::AddsNulls()) {
-				result_validity.Copy(FlatVector::Validity(left), count);
-				if (result_validity.AllValid()) {
-					result_validity.Copy(FlatVector::Validity(right), count);
-				} else {
-					result_validity.Combine(FlatVector::Validity(right), count);
-				}
-			} else {
-				FlatVector::SetValidity(result, FlatVector::Validity(left));
-				result_validity.Combine(FlatVector::Validity(right), count);
-			}
-		}
-		ExecuteFlatLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, LEFT_CONSTANT, RIGHT_CONSTANT>(
-		    ldata, rdata, result_data, count, result_validity, fun);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-	                               RESULT_TYPE *__restrict result_data, const SelectionVector *__restrict lsel,
-	                               const SelectionVector *__restrict rsel, idx_t count, ValidityMask &lvalidity,
-	                               ValidityMask &rvalidity, ValidityMask &result_validity, FUNC fun) {
-		if (!lvalidity.AllValid() || !rvalidity.AllValid()) {
-			for (idx_t i = 0; i < count; i++) {
-				auto lindex = lsel->get_index(i);
-				auto rindex = rsel->get_index(i);
-				if (lvalidity.RowIsValid(lindex) && rvalidity.RowIsValid(rindex)) {
-					auto lentry = ldata[lindex];
-					auto rentry = rdata[rindex];
-					result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-					    fun, lentry, rentry, result_validity, i);
-				} else {
-					result_validity.SetInvalid(i);
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto lentry = ldata[lsel->get_index(i)];
-				auto rentry = rdata[rsel->get_index(i)];
-				result_data[i] = OPWRAPPER::template Operation<FUNC, OP, LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE>(
-				    fun, lentry, rentry, result_validity, i);
-			}
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteGeneric(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		VectorData ldata, rdata;
-
-		left.Orrify(count, ldata);
-		right.Orrify(count, rdata);
-
-		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-		ExecuteGenericLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(
-		    (LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data, result_data, ldata.sel, rdata.sel, count, ldata.validity,
-		    rdata.validity, FlatVector::Validity(result), fun);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteSwitch(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		auto left_vector_type = left.GetVectorType();
-		auto right_vector_type = right.GetVectorType();
-		if (left_vector_type == VectorType::CONSTANT_VECTOR && right_vector_type == VectorType::CONSTANT_VECTOR) {
-			ExecuteConstant<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(left, right, result, fun);
-		} else if (left_vector_type == VectorType::FLAT_VECTOR && right_vector_type == VectorType::CONSTANT_VECTOR) {
-			ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, false, true>(left, right, result,
-			                                                                                  count, fun);
-		} else if (left_vector_type == VectorType::CONSTANT_VECTOR && right_vector_type == VectorType::FLAT_VECTOR) {
-			ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, true, false>(left, right, result,
-			                                                                                  count, fun);
-		} else if (left_vector_type == VectorType::FLAT_VECTOR && right_vector_type == VectorType::FLAT_VECTOR) {
-			ExecuteFlat<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC, false, false>(left, right, result,
-			                                                                                   count, fun);
-		} else {
-			ExecuteGeneric<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(left, right, result, count, fun);
-		}
-	}
-
-public:
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE,
-	          class FUNC = std::function<RESULT_TYPE(LEFT_TYPE, RIGHT_TYPE)>>
-	static void Execute(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryLambdaWrapper, bool, FUNC>(left, right, result, count,
-		                                                                                   fun);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP,
-	          class OPWRAPPER = BinarySingleArgumentOperatorWrapper>
-	static void Execute(Vector &left, Vector &right, Vector &result, idx_t count) {
-		ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, bool>(left, right, result, count, false);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-	static void ExecuteStandard(Vector &left, Vector &right, Vector &result, idx_t count) {
-		ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryStandardOperatorWrapper, OP, bool>(left, right, result,
-		                                                                                           count, false);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE,
-	          class FUNC = std::function<RESULT_TYPE(LEFT_TYPE, RIGHT_TYPE, ValidityMask &, idx_t)>>
-	static void ExecuteWithNulls(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
-		ExecuteSwitch<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, BinaryLambdaWrapperWithNulls, bool, FUNC>(left, right, result,
-		                                                                                            count, fun);
-	}
-
-public:
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-	static idx_t SelectConstant(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                            SelectionVector *true_sel, SelectionVector *false_sel) {
-		auto ldata = ConstantVector::GetData<LEFT_TYPE>(left);
-		auto rdata = ConstantVector::GetData<RIGHT_TYPE>(right);
-
-		// both sides are constant, return either 0 or the count
-		// in this case we do not fill in the result selection vector at all
-		if (ConstantVector::IsNull(left) || ConstantVector::IsNull(right) || !OP::Operation(*ldata, *rdata)) {
-			if (false_sel) {
-				for (idx_t i = 0; i < count; i++) {
-					false_sel->set_index(i, sel->get_index(i));
-				}
-			}
-			return 0;
-		} else {
-			if (true_sel) {
-				for (idx_t i = 0; i < count; i++) {
-					true_sel->set_index(i, sel->get_index(i));
-				}
-			}
-			return count;
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool HAS_TRUE_SEL,
-	          bool HAS_FALSE_SEL>
-	static inline idx_t SelectFlatLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-	                                   const SelectionVector *sel, idx_t count, ValidityMask &validity_mask,
-	                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-		idx_t true_count = 0, false_count = 0;
-		idx_t base_idx = 0;
-		auto entry_count = ValidityMask::EntryCount(count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			auto validity_entry = validity_mask.GetValidityEntry(entry_idx);
-			idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-			if (ValidityMask::AllValid(validity_entry)) {
-				// all valid: perform operation
-				for (; base_idx < next; base_idx++) {
-					idx_t result_idx = sel->get_index(base_idx);
-					idx_t lidx = LEFT_CONSTANT ? 0 : base_idx;
-					idx_t ridx = RIGHT_CONSTANT ? 0 : base_idx;
-					bool comparison_result = OP::Operation(ldata[lidx], rdata[ridx]);
-					if (HAS_TRUE_SEL) {
-						true_sel->set_index(true_count, result_idx);
-						true_count += comparison_result;
-					}
-					if (HAS_FALSE_SEL) {
-						false_sel->set_index(false_count, result_idx);
-						false_count += !comparison_result;
-					}
-				}
-			} else if (ValidityMask::NoneValid(validity_entry)) {
-				// nothing valid: skip all
-				if (HAS_FALSE_SEL) {
-					for (; base_idx < next; base_idx++) {
-						idx_t result_idx = sel->get_index(base_idx);
-						false_sel->set_index(false_count, result_idx);
-						false_count++;
-					}
-				}
-				base_idx = next;
-				continue;
-			} else {
-				// partially valid: need to check individual elements for validity
-				idx_t start = base_idx;
-				for (; base_idx < next; base_idx++) {
-					idx_t result_idx = sel->get_index(base_idx);
-					idx_t lidx = LEFT_CONSTANT ? 0 : base_idx;
-					idx_t ridx = RIGHT_CONSTANT ? 0 : base_idx;
-					bool comparison_result = ValidityMask::RowIsValid(validity_entry, base_idx - start) &&
-					                         OP::Operation(ldata[lidx], rdata[ridx]);
-					if (HAS_TRUE_SEL) {
-						true_sel->set_index(true_count, result_idx);
-						true_count += comparison_result;
-					}
-					if (HAS_FALSE_SEL) {
-						false_sel->set_index(false_count, result_idx);
-						false_count += !comparison_result;
-					}
-				}
-			}
-		}
-		if (HAS_TRUE_SEL) {
-			return true_count;
-		} else {
-			return count - false_count;
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static inline idx_t SelectFlatLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-	                                         const SelectionVector *sel, idx_t count, ValidityMask &mask,
-	                                         SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (true_sel && false_sel) {
-			return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, true, true>(
-			    ldata, rdata, sel, count, mask, true_sel, false_sel);
-		} else if (true_sel) {
-			return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, true, false>(
-			    ldata, rdata, sel, count, mask, true_sel, false_sel);
-		} else {
-			D_ASSERT(false_sel);
-			return SelectFlatLoop<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT, false, true>(
-			    ldata, rdata, sel, count, mask, true_sel, false_sel);
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static idx_t SelectFlat(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                        SelectionVector *true_sel, SelectionVector *false_sel) {
-		auto ldata = FlatVector::GetData<LEFT_TYPE>(left);
-		auto rdata = FlatVector::GetData<RIGHT_TYPE>(right);
-
-		if (LEFT_CONSTANT && ConstantVector::IsNull(left)) {
-			return 0;
-		}
-		if (RIGHT_CONSTANT && ConstantVector::IsNull(right)) {
-			return 0;
-		}
-
-		if (LEFT_CONSTANT) {
-			return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-			    ldata, rdata, sel, count, FlatVector::Validity(right), true_sel, false_sel);
-		} else if (RIGHT_CONSTANT) {
-			return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-			    ldata, rdata, sel, count, FlatVector::Validity(left), true_sel, false_sel);
-		} else {
-			ValidityMask combined_mask = FlatVector::Validity(left);
-			combined_mask.Combine(FlatVector::Validity(right), count);
-			return SelectFlatLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP, LEFT_CONSTANT, RIGHT_CONSTANT>(
-			    ldata, rdata, sel, count, combined_mask, true_sel, false_sel);
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-	static inline idx_t
-	SelectGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata, const SelectionVector *__restrict lsel,
-	                  const SelectionVector *__restrict rsel, const SelectionVector *__restrict result_sel, idx_t count,
-	                  ValidityMask &lvalidity, ValidityMask &rvalidity, SelectionVector *true_sel,
-	                  SelectionVector *false_sel) {
-		idx_t true_count = 0, false_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto result_idx = result_sel->get_index(i);
-			auto lindex = lsel->get_index(i);
-			auto rindex = rsel->get_index(i);
-			if ((NO_NULL || (lvalidity.RowIsValid(lindex) && rvalidity.RowIsValid(rindex))) &&
-			    OP::Operation(ldata[lindex], rdata[rindex])) {
-				if (HAS_TRUE_SEL) {
-					true_sel->set_index(true_count++, result_idx);
-				}
-			} else {
-				if (HAS_FALSE_SEL) {
-					false_sel->set_index(false_count++, result_idx);
-				}
-			}
-		}
-		if (HAS_TRUE_SEL) {
-			return true_count;
-		} else {
-			return count - false_count;
-		}
-	}
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL>
-	static inline idx_t
-	SelectGenericLoopSelSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-	                           const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-	                           const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
-	                           ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (true_sel && false_sel) {
-			return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, true>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		} else if (true_sel) {
-			return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, true, false>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		} else {
-			D_ASSERT(false_sel);
-			return SelectGenericLoop<LEFT_TYPE, RIGHT_TYPE, OP, NO_NULL, false, true>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-	static inline idx_t
-	SelectGenericLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
-	                        const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
-	                        const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
-	                        ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (!lvalidity.AllValid() || !rvalidity.AllValid()) {
-			return SelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, false>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		} else {
-			return SelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, true>(
-			    ldata, rdata, lsel, rsel, result_sel, count, lvalidity, rvalidity, true_sel, false_sel);
-		}
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-	static idx_t SelectGeneric(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
-	                           SelectionVector *true_sel, SelectionVector *false_sel) {
-		VectorData ldata, rdata;
-
-		left.Orrify(count, ldata);
-		right.Orrify(count, rdata);
-
-		return SelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>((LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data,
-		                                                          ldata.sel, rdata.sel, sel, count, ldata.validity,
-		                                                          rdata.validity, true_sel, false_sel);
-	}
-
-	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
-	static idx_t Select(Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-	                    SelectionVector *false_sel) {
-		if (!sel) {
-			sel = FlatVector::IncrementalSelectionVector();
-		}
-		if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			return SelectConstant<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
-		} else if (left.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		           right.GetVectorType() == VectorType::FLAT_VECTOR) {
-			return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, true, false>(left, right, sel, count, true_sel, false_sel);
-		} else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
-		           right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, true>(left, right, sel, count, true_sel, false_sel);
-		} else if (left.GetVectorType() == VectorType::FLAT_VECTOR &&
-		           right.GetVectorType() == VectorType::FLAT_VECTOR) {
-			return SelectFlat<LEFT_TYPE, RIGHT_TYPE, OP, false, false>(left, right, sel, count, true_sel, false_sel);
-		} else {
-			return SelectGeneric<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
-		}
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/ternary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-struct TernaryLambdaWrapper {
-	template <class FUN, class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUN fun, A_TYPE a, B_TYPE b, C_TYPE c, ValidityMask &mask, idx_t idx) {
-		return fun(a, b, c);
-	}
-};
-
-struct TernaryLambdaWrapperWithNulls {
-	template <class FUN, class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(FUN fun, A_TYPE a, B_TYPE b, C_TYPE c, ValidityMask &mask, idx_t idx) {
-		return fun(a, b, c, mask, idx);
-	}
-};
-
-struct TernaryExecutor {
-private:
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class OPWRAPPER, class FUN>
-	static inline void ExecuteLoop(A_TYPE *__restrict adata, B_TYPE *__restrict bdata, C_TYPE *__restrict cdata,
-	                               RESULT_TYPE *__restrict result_data, idx_t count, const SelectionVector &asel,
-	                               const SelectionVector &bsel, const SelectionVector &csel, ValidityMask &avalidity,
-	                               ValidityMask &bvalidity, ValidityMask &cvalidity, ValidityMask &result_validity,
-	                               FUN fun) {
-		if (!avalidity.AllValid() || !bvalidity.AllValid() || !cvalidity.AllValid()) {
-			for (idx_t i = 0; i < count; i++) {
-				auto aidx = asel.get_index(i);
-				auto bidx = bsel.get_index(i);
-				auto cidx = csel.get_index(i);
-				if (avalidity.RowIsValid(aidx) && bvalidity.RowIsValid(bidx) && cvalidity.RowIsValid(cidx)) {
-					result_data[i] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
-					    fun, adata[aidx], bdata[bidx], cdata[cidx], result_validity, i);
-				} else {
-					result_validity.SetInvalid(i);
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				auto aidx = asel.get_index(i);
-				auto bidx = bsel.get_index(i);
-				auto cidx = csel.get_index(i);
-				result_data[i] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
-				    fun, adata[aidx], bdata[bidx], cdata[cidx], result_validity, i);
-			}
-		}
-	}
-
-public:
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class OPWRAPPER, class FUN>
-	static void ExecuteGeneric(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun) {
-		if (a.GetVectorType() == VectorType::CONSTANT_VECTOR && b.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    c.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			if (ConstantVector::IsNull(a) || ConstantVector::IsNull(b) || ConstantVector::IsNull(c)) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				auto adata = ConstantVector::GetData<A_TYPE>(a);
-				auto bdata = ConstantVector::GetData<B_TYPE>(b);
-				auto cdata = ConstantVector::GetData<C_TYPE>(c);
-				auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
-				auto &result_validity = ConstantVector::Validity(result);
-				result_data[0] = OPWRAPPER::template Operation<FUN, A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE>(
-				    fun, adata[0], bdata[0], cdata[0], result_validity, 0);
-			}
-		} else {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-
-			VectorData adata, bdata, cdata;
-			a.Orrify(count, adata);
-			b.Orrify(count, bdata);
-			c.Orrify(count, cdata);
-
-			ExecuteLoop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OPWRAPPER>(
-			    (A_TYPE *)adata.data, (B_TYPE *)bdata.data, (C_TYPE *)cdata.data,
-			    FlatVector::GetData<RESULT_TYPE>(result), count, *adata.sel, *bdata.sel, *cdata.sel, adata.validity,
-			    bdata.validity, cdata.validity, FlatVector::Validity(result), fun);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE,
-	          class FUN = std::function<RESULT_TYPE(A_TYPE, B_TYPE, C_TYPE)>>
-	static void Execute(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun) {
-		ExecuteGeneric<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, TernaryLambdaWrapper, FUN>(a, b, c, result, count, fun);
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE,
-	          class FUN = std::function<RESULT_TYPE(A_TYPE, B_TYPE, C_TYPE, ValidityMask &, idx_t)>>
-	static void ExecuteWithNulls(Vector &a, Vector &b, Vector &c, Vector &result, idx_t count, FUN fun) {
-		ExecuteGeneric<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, TernaryLambdaWrapperWithNulls, FUN>(a, b, c, result, count,
-		                                                                                        fun);
-	}
-
-private:
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-	static inline idx_t SelectLoop(A_TYPE *__restrict adata, B_TYPE *__restrict bdata, C_TYPE *__restrict cdata,
-	                               const SelectionVector *result_sel, idx_t count, const SelectionVector &asel,
-	                               const SelectionVector &bsel, const SelectionVector &csel, ValidityMask &avalidity,
-	                               ValidityMask &bvalidity, ValidityMask &cvalidity, SelectionVector *true_sel,
-	                               SelectionVector *false_sel) {
-		idx_t true_count = 0, false_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto result_idx = result_sel->get_index(i);
-			auto aidx = asel.get_index(i);
-			auto bidx = bsel.get_index(i);
-			auto cidx = csel.get_index(i);
-			bool comparison_result =
-			    (NO_NULL || (avalidity.RowIsValid(aidx) && bvalidity.RowIsValid(bidx) && cvalidity.RowIsValid(cidx))) &&
-			    OP::Operation(adata[aidx], bdata[bidx], cdata[cidx]);
-			if (HAS_TRUE_SEL) {
-				true_sel->set_index(true_count, result_idx);
-				true_count += comparison_result;
-			}
-			if (HAS_FALSE_SEL) {
-				false_sel->set_index(false_count, result_idx);
-				false_count += !comparison_result;
-			}
-		}
-		if (HAS_TRUE_SEL) {
-			return true_count;
-		} else {
-			return count - false_count;
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP, bool NO_NULL>
-	static inline idx_t SelectLoopSelSwitch(VectorData &adata, VectorData &bdata, VectorData &cdata,
-	                                        const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-	                                        SelectionVector *false_sel) {
-		if (true_sel && false_sel) {
-			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, true, true>(
-			    (A_TYPE *)adata.data, (B_TYPE *)bdata.data, (C_TYPE *)cdata.data, sel, count, *adata.sel, *bdata.sel,
-			    *cdata.sel, adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
-		} else if (true_sel) {
-			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, true, false>(
-			    (A_TYPE *)adata.data, (B_TYPE *)bdata.data, (C_TYPE *)cdata.data, sel, count, *adata.sel, *bdata.sel,
-			    *cdata.sel, adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
-		} else {
-			D_ASSERT(false_sel);
-			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, false, true>(
-			    (A_TYPE *)adata.data, (B_TYPE *)bdata.data, (C_TYPE *)cdata.data, sel, count, *adata.sel, *bdata.sel,
-			    *cdata.sel, adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
-		}
-	}
-
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP>
-	static inline idx_t SelectLoopSwitch(VectorData &adata, VectorData &bdata, VectorData &cdata,
-	                                     const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
-	                                     SelectionVector *false_sel) {
-		if (!adata.validity.AllValid() || !bdata.validity.AllValid() || !cdata.validity.AllValid()) {
-			return SelectLoopSelSwitch<A_TYPE, B_TYPE, C_TYPE, OP, false>(adata, bdata, cdata, sel, count, true_sel,
-			                                                              false_sel);
-		} else {
-			return SelectLoopSelSwitch<A_TYPE, B_TYPE, C_TYPE, OP, true>(adata, bdata, cdata, sel, count, true_sel,
-			                                                             false_sel);
-		}
-	}
-
-public:
-	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP>
-	static idx_t Select(Vector &a, Vector &b, Vector &c, const SelectionVector *sel, idx_t count,
-	                    SelectionVector *true_sel, SelectionVector *false_sel) {
-		if (!sel) {
-			sel = FlatVector::IncrementalSelectionVector();
-		}
-		VectorData adata, bdata, cdata;
-		a.Orrify(count, adata);
-		b.Orrify(count, bdata);
-		c.Orrify(count, cdata);
-
-		return SelectLoopSwitch<A_TYPE, B_TYPE, C_TYPE, OP>(adata, bdata, cdata, sel, count, true_sel, false_sel);
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/unary_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-struct UnaryOperatorWrapper {
-	template <class OP, class INPUT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input);
-	}
-};
-
-struct UnaryLambdaWrapper {
-	template <class FUNC, class INPUT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto fun = (FUNC *)dataptr;
-		return (*fun)(input);
-	}
-};
-
-struct GenericUnaryWrapper {
-	template <class OP, class INPUT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, mask, idx, dataptr);
-	}
-};
-
-struct UnaryLambdaWrapperWithNulls {
-	template <class FUNC, class INPUT_TYPE, class RESULT_TYPE>
-	static inline RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto fun = (FUNC *)dataptr;
-		return (*fun)(input, mask, idx);
-	}
-};
-
-template <class OP>
-struct UnaryStringOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto vector = (Vector *)dataptr;
-		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, *vector);
-	}
-};
-
-struct UnaryExecutor {
-private:
-	template <class INPUT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP>
-	static inline void ExecuteLoop(INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
-	                               const SelectionVector *__restrict sel_vector, ValidityMask &mask,
-	                               ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
-#ifdef DEBUG
-		// ldata may point to a compressed dictionary buffer which can be smaller than ldata + count
-		idx_t max_index = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel_vector->get_index(i);
-			max_index = MaxValue(max_index, idx);
-		}
-		ASSERT_RESTRICT(ldata, ldata + max_index, result_data, result_data + count);
-#endif
-
-		if (!mask.AllValid()) {
-			result_mask.EnsureWritable();
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel_vector->get_index(i);
-				if (mask.RowIsValidUnsafe(idx)) {
-					result_data[i] =
-					    OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(ldata[idx], result_mask, i, dataptr);
-				} else {
-					result_mask.SetInvalid(i);
-				}
-			}
-		} else {
-			if (adds_nulls) {
-				result_mask.EnsureWritable();
-			}
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel_vector->get_index(i);
-				result_data[i] =
-				    OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(ldata[idx], result_mask, i, dataptr);
-			}
-		}
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP>
-	static inline void ExecuteFlat(INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
-	                               ValidityMask &mask, ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
-		ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
-
-		if (!mask.AllValid()) {
-			if (!adds_nulls) {
-				result_mask.Initialize(mask);
-			} else {
-				result_mask.Copy(mask, count);
-			}
-			idx_t base_idx = 0;
-			auto entry_count = ValidityMask::EntryCount(count);
-			for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-				auto validity_entry = mask.GetValidityEntry(entry_idx);
-				idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-				if (ValidityMask::AllValid(validity_entry)) {
-					// all valid: perform operation
-					for (; base_idx < next; base_idx++) {
-						result_data[base_idx] = OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(
-						    ldata[base_idx], result_mask, base_idx, dataptr);
-					}
-				} else if (ValidityMask::NoneValid(validity_entry)) {
-					// nothing valid: skip all
-					base_idx = next;
-					continue;
-				} else {
-					// partially valid: need to check individual elements for validity
-					idx_t start = base_idx;
-					for (; base_idx < next; base_idx++) {
-						if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-							D_ASSERT(mask.RowIsValid(base_idx));
-							result_data[base_idx] = OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(
-							    ldata[base_idx], result_mask, base_idx, dataptr);
-						}
-					}
-				}
-			}
-		} else {
-			if (adds_nulls) {
-				result_mask.EnsureWritable();
-			}
-			for (idx_t i = 0; i < count; i++) {
-				result_data[i] =
-				    OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(ldata[i], result_mask, i, dataptr);
-			}
-		}
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP>
-	static inline void ExecuteStandard(Vector &input, Vector &result, idx_t count, void *dataptr, bool adds_nulls) {
-		switch (input.GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR: {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			auto result_data = ConstantVector::GetData<RESULT_TYPE>(result);
-			auto ldata = ConstantVector::GetData<INPUT_TYPE>(input);
-
-			if (ConstantVector::IsNull(input)) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				ConstantVector::SetNull(result, false);
-				*result_data = OPWRAPPER::template Operation<OP, INPUT_TYPE, RESULT_TYPE>(
-				    *ldata, ConstantVector::Validity(result), 0, dataptr);
-			}
-			break;
-		}
-		case VectorType::FLAT_VECTOR: {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-			auto ldata = FlatVector::GetData<INPUT_TYPE>(input);
-
-			ExecuteFlat<INPUT_TYPE, RESULT_TYPE, OPWRAPPER, OP>(ldata, result_data, count, FlatVector::Validity(input),
-			                                                    FlatVector::Validity(result), dataptr, adds_nulls);
-			break;
-		}
-		default: {
-			VectorData vdata;
-			input.Orrify(count, vdata);
-
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-			auto ldata = (INPUT_TYPE *)vdata.data;
-
-			ExecuteLoop<INPUT_TYPE, RESULT_TYPE, OPWRAPPER, OP>(ldata, result_data, count, vdata.sel, vdata.validity,
-			                                                    FlatVector::Validity(result), dataptr, adds_nulls);
-			break;
-		}
-		}
-	}
-
-public:
-	template <class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void Execute(Vector &input, Vector &result, idx_t count) {
-		ExecuteStandard<INPUT_TYPE, RESULT_TYPE, UnaryOperatorWrapper, OP>(input, result, count, nullptr, false);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class FUNC = std::function<RESULT_TYPE(INPUT_TYPE)>>
-	static void Execute(Vector &input, Vector &result, idx_t count, FUNC fun) {
-		ExecuteStandard<INPUT_TYPE, RESULT_TYPE, UnaryLambdaWrapper, FUNC>(input, result, count, (void *)&fun, false);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void GenericExecute(Vector &input, Vector &result, idx_t count, void *dataptr, bool adds_nulls = false) {
-		ExecuteStandard<INPUT_TYPE, RESULT_TYPE, GenericUnaryWrapper, OP>(input, result, count, dataptr, adds_nulls);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE,
-	          class FUNC = std::function<RESULT_TYPE(INPUT_TYPE, ValidityMask &, idx_t)>>
-	static void ExecuteWithNulls(Vector &input, Vector &result, idx_t count, FUNC fun) {
-		ExecuteStandard<INPUT_TYPE, RESULT_TYPE, UnaryLambdaWrapperWithNulls, FUNC>(input, result, count, (void *)&fun,
-		                                                                            true);
-	}
-
-	template <class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void ExecuteString(Vector &input, Vector &result, idx_t count) {
-		UnaryExecutor::GenericExecute<string_t, string_t, UnaryStringOperator<OP>>(input, result, count,
-		                                                                           (void *)&result);
-	}
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/expression_executor_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/cycle_counter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/chrono.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <chrono>
-
-namespace duckdb {
-using std::chrono::duration;
-using std::chrono::duration_cast;
-using std::chrono::high_resolution_clock;
-using std::chrono::system_clock;
-using std::chrono::time_point;
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//! The cycle counter can be used to measure elapsed cycles for a function, expression and ...
-//! Optimized by sampling mechanism. Once per 100 times.
-//! //Todo Can be optimized further by calling RDTSC once per sample
-class CycleCounter {
-	friend struct ExpressionInfo;
-	friend struct ExpressionRootInfo;
-	static constexpr int SAMPLING_RATE = 50;
-
-public:
-	CycleCounter() {
-	}
-	// Next_sample determines if a sample needs to be taken, if so start the profiler
-	void BeginSample() {
-		if (current_count >= next_sample) {
-			tmp = Tick();
-		}
-	}
-
-	// End the sample
-	void EndSample(int chunk_size) {
-		if (current_count >= next_sample) {
-			time += Tick() - tmp;
-		}
-		if (current_count >= next_sample) {
-			next_sample = SAMPLING_RATE;
-			++sample_count;
-			sample_tuples_count += chunk_size;
-			current_count = 0;
-		} else {
-			++current_count;
-		}
-		tuples_count += chunk_size;
-	}
-
-private:
-	uint64_t Tick() const;
-	// current number on RDT register
-	uint64_t tmp;
-	// Elapsed cycles
-	uint64_t time = 0;
-	//! Count the number of time the executor called since last sampling
-	uint64_t current_count = 0;
-	//! Show the next sample
-	uint64_t next_sample = 0;
-	//! Count the number of samples
-	uint64_t sample_count = 0;
-	//! Count the number of tuples sampled
-	uint64_t sample_tuples_count = 0;
-	//! Count the number of ALL tuples
-	uint64_t tuples_count = 0;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/named_parameter_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/case_insensitive_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/unordered_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <unordered_set>
-
-namespace duckdb {
-using std::unordered_set;
-}
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/string_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-/**
- * String Utility Functions
- * Note that these are not the most efficient implementations (i.e., they copy
- * memory) and therefore they should only be used for debug messages and other
- * such things.
- */
-class StringUtil {
-public:
-	DUCKDB_API static bool CharacterIsSpace(char c) {
-		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
-	}
-	DUCKDB_API static bool CharacterIsNewline(char c) {
-		return c == '\n' || c == '\r';
-	}
-	DUCKDB_API static bool CharacterIsDigit(char c) {
-		return c >= '0' && c <= '9';
-	}
-	DUCKDB_API static char CharacterToLower(char c) {
-		if (c >= 'A' && c <= 'Z') {
-			return c - ('A' - 'a');
-		}
-		return c;
-	}
-	DUCKDB_API static char CharacterIsAlpha(char c) {
-		return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
-	}
-
-	//! Returns true if the needle string exists in the haystack
-	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
-
-	//! Returns true if the target string starts with the given prefix
-	DUCKDB_API static bool StartsWith(string str, string prefix);
-
-	//! Returns true if the target string <b>ends</b> with the given suffix.
-	DUCKDB_API static bool EndsWith(const string &str, const string &suffix);
-
-	//! Repeat a string multiple times
-	DUCKDB_API static string Repeat(const string &str, const idx_t n);
-
-	//! Split the input string based on newline char
-	DUCKDB_API static vector<string> Split(const string &str, char delimiter);
-
-	//! Split the input string allong a quote. Note that any escaping is NOT supported.
-	DUCKDB_API static vector<string> SplitWithQuote(const string &str, char delimiter = ',', char quote = '"');
-
-	//! Join multiple strings into one string. Components are concatenated by the given separator
-	DUCKDB_API static string Join(const vector<string> &input, const string &separator);
-
-	//! Join multiple items of container with given size, transformed to string
-	//! using function, into one string using the given separator
-	template <typename C, typename S, typename Func>
-	static string Join(const C &input, S count, const string &separator, Func f) {
-		// The result
-		std::string result;
-
-		// If the input isn't empty, append the first element. We do this so we
-		// don't need to introduce an if into the loop.
-		if (count > 0) {
-			result += f(input[0]);
-		}
-
-		// Append the remaining input components, after the first
-		for (size_t i = 1; i < count; i++) {
-			result += separator + f(input[i]);
-		}
-
-		return result;
-	}
-
-	//! Return a string that formats the give number of bytes
-	DUCKDB_API static string BytesToHumanReadableString(idx_t bytes);
-
-	//! Convert a string to uppercase
-	DUCKDB_API static string Upper(const string &str);
-
-	//! Convert a string to lowercase
-	DUCKDB_API static string Lower(const string &str);
-
-	//! Format a string using printf semantics
-	template <typename... Args>
-	static string Format(const string fmt_str, Args... params) {
-		return Exception::ConstructMessage(fmt_str, params...);
-	}
-
-	//! Split the input string into a vector of strings based on the split string
-	DUCKDB_API static vector<string> Split(const string &input, const string &split);
-
-	//! Remove the whitespace char in the left end of the string
-	DUCKDB_API static void LTrim(string &str);
-	//! Remove the whitespace char in the right end of the string
-	DUCKDB_API static void RTrim(string &str);
-	//! Remove the whitespace char in the left and right end of the string
-	DUCKDB_API static void Trim(string &str);
-
-	DUCKDB_API static string Replace(string source, const string &from, const string &to);
-
-	//! Get the levenshtein distance from two strings
-	DUCKDB_API static idx_t LevenshteinDistance(const string &s1, const string &s2);
-
-	//! Get the top-n strings (sorted by the given score distance) from a set of scores.
-	//! At least one entry is returned (if there is one).
-	//! Strings are only returned if they have a score less than the threshold.
-	DUCKDB_API static vector<string> TopNStrings(vector<std::pair<string, idx_t>> scores, idx_t n = 5,
-	                                             idx_t threshold = 5);
-	//! Computes the levenshtein distance of each string in strings, and compares it to target, then returns TopNStrings
-	//! with the given params.
-	DUCKDB_API static vector<string> TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n = 5,
-	                                                 idx_t threshold = 5);
-	DUCKDB_API static string CandidatesMessage(const vector<string> &candidates,
-	                                           const string &candidate = "Candidate bindings");
-
-	//! Generate an error message in the form of "{message_prefix}: nearest_string, nearest_string2, ...
-	//! Equivalent to calling TopNLevenshtein followed by CandidatesMessage
-	DUCKDB_API static string CandidatesErrorMessage(const vector<string> &strings, const string &target,
-	                                                const string &message_prefix, idx_t n = 5);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct CaseInsensitiveStringHashFunction {
-	uint64_t operator()(const string &str) const {
-		std::hash<string> hasher;
-		return hasher(StringUtil::Lower(str));
-	}
-};
-
-struct CaseInsensitiveStringEquality {
-	bool operator()(const string &a, const string &b) const {
-		return StringUtil::Lower(a) == StringUtil::Lower(b);
-	}
-};
-
-template <typename T>
-using case_insensitive_map_t =
-    unordered_map<string, T, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
-
-using case_insensitive_set_t = unordered_set<string, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-using named_parameter_type_map_t = case_insensitive_map_t<LogicalType>;
-using named_parameter_map_t = case_insensitive_map_t<Value>;
-
-} // namespace duckdb
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/external_dependencies.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-namespace duckdb {
-
-enum ExternalDependenciesType { PYTHON_DEPENDENCY };
-class ExternalDependency {
-public:
-	explicit ExternalDependency(ExternalDependenciesType type_p) : type(type_p) {};
-	virtual ~ExternalDependency() {};
-	ExternalDependenciesType type;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/column_definition.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/base_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/expression_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Predicate Expression Operation Types
-//===--------------------------------------------------------------------===//
-enum class ExpressionType : uint8_t {
-	INVALID = 0,
-
-	// explicitly cast left as right (right is integer in ValueType enum)
-	OPERATOR_CAST = 12,
-	// logical not operator
-	OPERATOR_NOT = 13,
-	// is null operator
-	OPERATOR_IS_NULL = 14,
-	// is not null operator
-	OPERATOR_IS_NOT_NULL = 15,
-
-	// -----------------------------
-	// Comparison Operators
-	// -----------------------------
-	// equal operator between left and right
-	COMPARE_EQUAL = 25,
-	// compare initial boundary
-	COMPARE_BOUNDARY_START = COMPARE_EQUAL,
-	// inequal operator between left and right
-	COMPARE_NOTEQUAL = 26,
-	// less than operator between left and right
-	COMPARE_LESSTHAN = 27,
-	// greater than operator between left and right
-	COMPARE_GREATERTHAN = 28,
-	// less than equal operator between left and right
-	COMPARE_LESSTHANOREQUALTO = 29,
-	// greater than equal operator between left and right
-	COMPARE_GREATERTHANOREQUALTO = 30,
-	// IN operator [left IN (right1, right2, ...)]
-	COMPARE_IN = 35,
-	// NOT IN operator [left NOT IN (right1, right2, ...)]
-	COMPARE_NOT_IN = 36,
-	// IS DISTINCT FROM operator
-	COMPARE_DISTINCT_FROM = 37,
-
-	COMPARE_BETWEEN = 38,
-	COMPARE_NOT_BETWEEN = 39,
-	// IS NOT DISTINCT FROM operator
-	COMPARE_NOT_DISTINCT_FROM = 40,
-	// compare final boundary
-	COMPARE_BOUNDARY_END = COMPARE_NOT_DISTINCT_FROM,
-
-	// -----------------------------
-	// Conjunction Operators
-	// -----------------------------
-	CONJUNCTION_AND = 50,
-	CONJUNCTION_OR = 51,
-
-	// -----------------------------
-	// Values
-	// -----------------------------
-	VALUE_CONSTANT = 75,
-	VALUE_PARAMETER = 76,
-	VALUE_TUPLE = 77,
-	VALUE_TUPLE_ADDRESS = 78,
-	VALUE_NULL = 79,
-	VALUE_VECTOR = 80,
-	VALUE_SCALAR = 81,
-	VALUE_DEFAULT = 82,
-
-	// -----------------------------
-	// Aggregates
-	// -----------------------------
-	AGGREGATE = 100,
-	BOUND_AGGREGATE = 101,
-	GROUPING_FUNCTION = 102,
-
-	// -----------------------------
-	// Window Functions
-	// -----------------------------
-	WINDOW_AGGREGATE = 110,
-
-	WINDOW_RANK = 120,
-	WINDOW_RANK_DENSE = 121,
-	WINDOW_NTILE = 122,
-	WINDOW_PERCENT_RANK = 123,
-	WINDOW_CUME_DIST = 124,
-	WINDOW_ROW_NUMBER = 125,
-
-	WINDOW_FIRST_VALUE = 130,
-	WINDOW_LAST_VALUE = 131,
-	WINDOW_LEAD = 132,
-	WINDOW_LAG = 133,
-	WINDOW_NTH_VALUE = 134,
-
-	// -----------------------------
-	// Functions
-	// -----------------------------
-	FUNCTION = 140,
-	BOUND_FUNCTION = 141,
-
-	// -----------------------------
-	// Operators
-	// -----------------------------
-	CASE_EXPR = 150,
-	OPERATOR_NULLIF = 151,
-	OPERATOR_COALESCE = 152,
-	ARRAY_EXTRACT = 153,
-	ARRAY_SLICE = 154,
-	STRUCT_EXTRACT = 155,
-	ARRAY_CONSTRUCTOR = 156,
-	ARROW = 157,
-
-	// -----------------------------
-	// Subquery IN/EXISTS
-	// -----------------------------
-	SUBQUERY = 175,
-
-	// -----------------------------
-	// Parser
-	// -----------------------------
-	STAR = 200,
-	TABLE_STAR = 201,
-	PLACEHOLDER = 202,
-	COLUMN_REF = 203,
-	FUNCTION_REF = 204,
-	TABLE_REF = 205,
-
-	// -----------------------------
-	// Miscellaneous
-	// -----------------------------
-	CAST = 225,
-	BOUND_REF = 227,
-	BOUND_COLUMN_REF = 228,
-	BOUND_UNNEST = 229,
-	COLLATE = 230,
-	LAMBDA = 231,
-	POSITIONAL_REFERENCE = 232
-};
-
-//===--------------------------------------------------------------------===//
-// Expression Class
-//===--------------------------------------------------------------------===//
-enum class ExpressionClass : uint8_t {
-	INVALID = 0,
-	//===--------------------------------------------------------------------===//
-	// Parsed Expressions
-	//===--------------------------------------------------------------------===//
-	AGGREGATE = 1,
-	CASE = 2,
-	CAST = 3,
-	COLUMN_REF = 4,
-	COMPARISON = 5,
-	CONJUNCTION = 6,
-	CONSTANT = 7,
-	DEFAULT = 8,
-	FUNCTION = 9,
-	OPERATOR = 10,
-	STAR = 11,
-	SUBQUERY = 13,
-	WINDOW = 14,
-	PARAMETER = 15,
-	COLLATE = 16,
-	LAMBDA = 17,
-	POSITIONAL_REFERENCE = 18,
-	BETWEEN = 19,
-	//===--------------------------------------------------------------------===//
-	// Bound Expressions
-	//===--------------------------------------------------------------------===//
-	BOUND_AGGREGATE = 25,
-	BOUND_CASE = 26,
-	BOUND_CAST = 27,
-	BOUND_COLUMN_REF = 28,
-	BOUND_COMPARISON = 29,
-	BOUND_CONJUNCTION = 30,
-	BOUND_CONSTANT = 31,
-	BOUND_DEFAULT = 32,
-	BOUND_FUNCTION = 33,
-	BOUND_OPERATOR = 34,
-	BOUND_PARAMETER = 35,
-	BOUND_REF = 36,
-	BOUND_SUBQUERY = 37,
-	BOUND_WINDOW = 38,
-	BOUND_BETWEEN = 39,
-	BOUND_UNNEST = 40,
-	//===--------------------------------------------------------------------===//
-	// Miscellaneous
-	//===--------------------------------------------------------------------===//
-	BOUND_EXPRESSION = 50
-};
-
-DUCKDB_API string ExpressionTypeToString(ExpressionType type);
-string ExpressionTypeToOperator(ExpressionType type);
-
-// Operator String to ExpressionType (e.g. + => OPERATOR_ADD)
-ExpressionType OperatorToExpressionType(const string &op);
-
-//! Negate a comparison expression, turning e.g. = into !=, or < into >=
-ExpressionType NegateComparisionExpression(ExpressionType type);
-//! Flip a comparison expression, turning e.g. < into >, or = into =
-ExpressionType FlipComparisionExpression(ExpressionType type);
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//!  The BaseExpression class is a base class that can represent any expression
-//!  part of a SQL statement.
-class BaseExpression {
-public:
-	//! Create an Expression
-	BaseExpression(ExpressionType type, ExpressionClass expression_class)
-	    : type(type), expression_class(expression_class) {
-	}
-	virtual ~BaseExpression() {
-	}
-
-	//! Returns the type of the expression
-	ExpressionType GetExpressionType() const {
-		return type;
-	}
-	//! Returns the class of the expression
-	ExpressionClass GetExpressionClass() const {
-		return expression_class;
-	}
-
-	//! Type of the expression
-	ExpressionType type;
-	//! The expression class of the node
-	ExpressionClass expression_class;
-	//! The alias of the expression,
-	string alias;
-
-public:
-	//! Returns true if this expression is an aggregate or not.
-	/*!
-	 Examples:
-
-	 (1) SUM(a) + 1 -- True
-
-	 (2) a + 1 -- False
-	 */
-	virtual bool IsAggregate() const = 0;
-	//! Returns true if the expression has a window function or not
-	virtual bool IsWindow() const = 0;
-	//! Returns true if the query contains a subquery
-	virtual bool HasSubquery() const = 0;
-	//! Returns true if expression does not contain a group ref or col ref or parameter
-	virtual bool IsScalar() const = 0;
-	//! Returns true if the expression has a parameter
-	virtual bool HasParameter() const = 0;
-
-	//! Get the name of the expression
-	virtual string GetName() const;
-	//! Convert the Expression to a String
-	virtual string ToString() const = 0;
-	//! Print the expression to stdout
-	void Print() const;
-
-	//! Creates a hash value of this expression. It is important that if two expressions are identical (i.e.
-	//! Expression::Equals() returns true), that their hash value is identical as well.
-	virtual hash_t Hash() const = 0;
-	//! Returns true if this expression is equal to another expression
-	virtual bool Equals(const BaseExpression *other) const;
-
-	static bool Equals(BaseExpression *left, BaseExpression *right) {
-		if (left == right) {
-			return true;
-		}
-		if (!left || !right) {
-			return false;
-		}
-		return left->Equals(right);
-	}
-	bool operator==(const BaseExpression &rhs) const {
-		return this->Equals(&rhs);
-	}
-
-	virtual void Verify() const;
-};
-
-} // namespace duckdb
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/qualified_name.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/keyword_helper.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class KeywordHelper {
-public:
-	//! Returns true if the given text matches a keyword of the parser
-	static bool IsKeyword(const string &text);
-
-	//! Returns true if the given string needs to be quoted when written as an identifier
-	static bool RequiresQuotes(const string &text);
-
-	//! Writes a string that is optionally quoted + escaped so it can be used as an identifier
-	static string WriteOptionallyQuoted(const string &text, char quote = '"');
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct QualifiedName {
-	string schema;
-	string name;
-
-	//! Parse the (optional) schema and a name from a string in the format of e.g. "schema"."table"; if there is no dot
-	//! the schema will be set to INVALID_SCHEMA
-	static QualifiedName Parse(const string &input) {
-		string schema;
-		string name;
-		idx_t idx = 0;
-		vector<string> entries;
-		string entry;
-	normal:
-		//! quote
-		for (; idx < input.size(); idx++) {
-			if (input[idx] == '"') {
-				idx++;
-				goto quoted;
-			} else if (input[idx] == '.') {
-				goto separator;
-			}
-			entry += input[idx];
-		}
-		goto end;
-	separator:
-		entries.push_back(entry);
-		entry = "";
-		idx++;
-		goto normal;
-	quoted:
-		//! look for another quote
-		for (; idx < input.size(); idx++) {
-			if (input[idx] == '"') {
-				//! unquote
-				idx++;
-				goto normal;
-			}
-			entry += input[idx];
-		}
-		throw ParserException("Unterminated quote in qualified name!");
-	end:
-		if (entries.empty()) {
-			schema = INVALID_SCHEMA;
-			name = entry;
-		} else if (entries.size() == 1) {
-			schema = entries[0];
-			name = entry;
-		} else {
-			throw ParserException("Expected schema.entry or entry: too many entries found");
-		}
-		return QualifiedName {schema, name};
-	}
-};
-
-struct QualifiedColumnName {
-	QualifiedColumnName() {
-	}
-	QualifiedColumnName(string table_p, string column_p) : table(std::move(table_p)), column(std::move(column_p)) {
-	}
-
-	string schema;
-	string table;
-	string column;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression_util.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ParsedExpression;
-class Expression;
-
-class ExpressionUtil {
-public:
-	//! ListEquals: check if a list of two expressions is equal (order is important)
-	static bool ListEquals(const vector<unique_ptr<ParsedExpression>> &a,
-	                       const vector<unique_ptr<ParsedExpression>> &b);
-	static bool ListEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b);
-	//! SetEquals: check if two sets of expressions are equal (order is not important)
-	static bool SetEquals(const vector<unique_ptr<ParsedExpression>> &a, const vector<unique_ptr<ParsedExpression>> &b);
-	static bool SetEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b);
-
-private:
-	template <class T>
-	static bool ExpressionListEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b);
-	template <class T>
-	static bool ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-class FieldWriter;
-class FieldReader;
-
-//!  The ParsedExpression class is a base class that can represent any expression
-//!  part of a SQL statement.
-/*!
- The ParsedExpression class is a base class that can represent any expression
- part of a SQL statement. This is, for example, a column reference in a SELECT
- clause, but also operators, aggregates or filters. The Expression is emitted by the parser and does not contain any
- information about bindings to the catalog or to the types. ParsedExpressions are transformed into regular Expressions
- in the Binder.
- */
-class ParsedExpression : public BaseExpression {
-public:
-	//! Create an Expression
-	ParsedExpression(ExpressionType type, ExpressionClass expression_class) : BaseExpression(type, expression_class) {
-	}
-
-	//! The location in the query (if any)
-	idx_t query_location = DConstants::INVALID_INDEX;
-
-public:
-	bool IsAggregate() const override;
-	bool IsWindow() const override;
-	bool HasSubquery() const override;
-	bool IsScalar() const override;
-	bool HasParameter() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-	hash_t Hash() const override;
-
-	//! Create a copy of this expression
-	virtual unique_ptr<ParsedExpression> Copy() const = 0;
-
-	//! Serializes an Expression to a stand-alone binary blob
-	void Serialize(Serializer &serializer) const;
-	//! Serializes an Expression to a stand-alone binary blob
-	virtual void Serialize(FieldWriter &writer) const = 0;
-
-	//! Deserializes a blob back into an Expression [CAN THROW:
-	//! SerializationException]
-	static unique_ptr<ParsedExpression> Deserialize(Deserializer &source);
-
-protected:
-	//! Copy base Expression properties from another expression to this one,
-	//! used in Copy method
-	void CopyProperties(const ParsedExpression &other) {
-		type = other.type;
-		expression_class = other.expression_class;
-		alias = other.alias;
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/compression_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class CompressionType : uint8_t {
-	COMPRESSION_AUTO = 0,
-	COMPRESSION_UNCOMPRESSED = 1,
-	COMPRESSION_CONSTANT = 2,
-	COMPRESSION_RLE = 3,
-	COMPRESSION_DICTIONARY = 4,
-	COMPRESSION_PFOR_DELTA = 5,
-	COMPRESSION_BITPACKING = 6,
-	COMPRESSION_FSST = 7
-};
-
-CompressionType CompressionTypeFromString(const string &str);
-string CompressionTypeToString(CompressionType type);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/table_column_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class TableColumnType : uint8_t { STANDARD = 0, GENERATED = 1 };
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct RenameColumnInfo;
-struct RenameTableInfo;
-
-class ColumnDefinition;
-
-//! A column of a table.
-class ColumnDefinition {
-public:
-	DUCKDB_API ColumnDefinition(string name, LogicalType type);
-	DUCKDB_API ColumnDefinition(string name, LogicalType type, unique_ptr<ParsedExpression> expression,
-	                            TableColumnType category);
-
-	//! The default value of the column (if any)
-	unique_ptr<ParsedExpression> default_value;
-
-public:
-	//! default_value
-	const unique_ptr<ParsedExpression> &DefaultValue() const;
-	void SetDefaultValue(unique_ptr<ParsedExpression> default_value);
-
-	//! type
-	DUCKDB_API const LogicalType &Type() const;
-	LogicalType &TypeMutable();
-	void SetType(const LogicalType &type);
-
-	//! name
-	DUCKDB_API const string &Name() const;
-	void SetName(const string &name);
-
-	//! compression_type
-	const duckdb::CompressionType &CompressionType() const;
-	void SetCompressionType(duckdb::CompressionType compression_type);
-
-	//! storage_oid
-	const storage_t &StorageOid() const;
-	void SetStorageOid(storage_t storage_oid);
-
-	//! oid
-	const column_t &Oid() const;
-	void SetOid(column_t oid);
-
-	//! category
-	const TableColumnType &Category() const;
-	//! Whether this column is a Generated Column
-	bool Generated() const;
-	DUCKDB_API ColumnDefinition Copy() const;
-
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API static ColumnDefinition Deserialize(Deserializer &source);
-
-	//===--------------------------------------------------------------------===//
-	// Generated Columns (VIRTUAL)
-	//===--------------------------------------------------------------------===//
-
-	ParsedExpression &GeneratedExpressionMutable();
-	const ParsedExpression &GeneratedExpression() const;
-	void SetGeneratedExpression(unique_ptr<ParsedExpression> expression);
-	void ChangeGeneratedExpressionType(const LogicalType &type);
-	void GetListOfDependencies(vector<string> &dependencies) const;
-
-private:
-private:
-	//! The name of the entry
-	string name;
-	//! The type of the column
-	LogicalType type;
-	//! Compression Type used for this column
-	duckdb::CompressionType compression_type = duckdb::CompressionType::COMPRESSION_AUTO;
-	//! The index of the column in the storage of the table
-	storage_t storage_oid;
-	//! The index of the column in the table
-	idx_t oid;
-	//! The category of the column
-	TableColumnType category = TableColumnType::STANDARD;
-	//! Used by Generated Columns
-	unique_ptr<ParsedExpression> generated_expression;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class CatalogEntry;
-class Catalog;
-class ClientContext;
-class Expression;
-class ExpressionExecutor;
-class Transaction;
-
-class AggregateFunction;
-class AggregateFunctionSet;
-class CopyFunction;
-class PragmaFunction;
-class ScalarFunctionSet;
-class ScalarFunction;
-class TableFunctionSet;
-class TableFunction;
-
-struct PragmaInfo;
-
-struct FunctionData {
-	DUCKDB_API virtual ~FunctionData();
-
-	DUCKDB_API virtual unique_ptr<FunctionData> Copy() const = 0;
-	DUCKDB_API virtual bool Equals(const FunctionData &other) const = 0;
-	DUCKDB_API static bool Equals(const FunctionData *left, const FunctionData *right);
-};
-
-struct TableFunctionData : public FunctionData {
-	// used to pass on projections to table functions that support them. NB, can contain COLUMN_IDENTIFIER_ROW_ID
-	vector<idx_t> column_ids;
-
-	DUCKDB_API virtual ~TableFunctionData();
-
-	DUCKDB_API unique_ptr<FunctionData> Copy() const override;
-	DUCKDB_API bool Equals(const FunctionData &other) const override;
-};
-
-struct PyTableFunctionData : public TableFunctionData {
-	//! External dependencies of this table function
-	unique_ptr<ExternalDependency> external_dependency;
-};
-
-struct FunctionParameters {
-	vector<Value> values;
-	named_parameter_map_t named_parameters;
-};
-
-//! Function is the base class used for any type of function (scalar, aggregate or simple function)
-class Function {
-public:
-	DUCKDB_API explicit Function(string name);
-	DUCKDB_API virtual ~Function();
-
-	//! The name of the function
-	string name;
-
-public:
-	//! Returns the formatted string name(arg1, arg2, ...)
-	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments);
-	//! Returns the formatted string name(arg1, arg2..) -> return_type
-	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
-	                                      const LogicalType &return_type);
-	//! Returns the formatted string name(arg1, arg2.., np1=a, np2=b, ...)
-	DUCKDB_API static string CallToString(const string &name, const vector<LogicalType> &arguments,
-	                                      const named_parameter_type_map_t &named_parameters);
-
-	//! Bind a scalar function from the set of functions and input arguments. Returns the index of the chosen function,
-	//! returns DConstants::INVALID_INDEX and sets error if none could be found
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<ScalarFunction> &functions,
-	                                     vector<LogicalType> &arguments, string &error, bool &cast_parameters);
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<ScalarFunction> &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, string &error,
-	                                     bool &cast_parameters);
-	//! Bind an aggregate function from the set of functions and input arguments. Returns the index of the chosen
-	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
-	                                     vector<LogicalType> &arguments, string &error, bool &cast_parameters);
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
-	                                     vector<LogicalType> &arguments, string &error);
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, string &error);
-	//! Bind a table function from the set of functions and input arguments. Returns the index of the chosen
-	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<TableFunction> &functions,
-	                                     vector<LogicalType> &arguments, string &error);
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<TableFunction> &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, string &error);
-	//! Bind a pragma function from the set of functions and input arguments
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<PragmaFunction> &functions, PragmaInfo &info,
-	                                     string &error);
-};
-
-class SimpleFunction : public Function {
-public:
-	DUCKDB_API SimpleFunction(string name, vector<LogicalType> arguments,
-	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
-	DUCKDB_API ~SimpleFunction() override;
-
-	//! The set of arguments of the function
-	vector<LogicalType> arguments;
-	//! The type of varargs to support, or LogicalTypeId::INVALID if the function does not accept variable length
-	//! arguments
-	LogicalType varargs;
-
-public:
-	DUCKDB_API virtual string ToString();
-
-	DUCKDB_API bool HasVarArgs() const;
-};
-
-class SimpleNamedParameterFunction : public SimpleFunction {
-public:
-	DUCKDB_API SimpleNamedParameterFunction(string name, vector<LogicalType> arguments,
-	                                        LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
-	DUCKDB_API ~SimpleNamedParameterFunction() override;
-
-	//! The named parameters of the function
-	named_parameter_type_map_t named_parameters;
-
-public:
-	DUCKDB_API string ToString() override;
-	DUCKDB_API bool HasNamedParameters();
-};
-
-class BaseScalarFunction : public SimpleFunction {
-public:
-	DUCKDB_API BaseScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
-	                              bool has_side_effects, LogicalType varargs = LogicalType(LogicalTypeId::INVALID),
-	                              bool propagates_null_values = false);
-	DUCKDB_API ~BaseScalarFunction() override;
-
-	//! Return type of the function
-	LogicalType return_type;
-	//! Whether or not the function has side effects (e.g. sequence increments, random() functions, NOW()). Functions
-	//! with side-effects cannot be constant-folded.
-	bool has_side_effects;
-	//! Whether or not the function propagates null values
-	bool propagates_null_values;
-
-public:
-	DUCKDB_API hash_t Hash() const;
-
-	//! Cast a set of expressions to the arguments of this function
-	DUCKDB_API void CastToFunctionArguments(vector<unique_ptr<Expression>> &children,
-	                                        bool cast_parameter_expressions = true);
-
-	DUCKDB_API string ToString() override;
-};
-
-class BuiltinFunctions {
-public:
-	BuiltinFunctions(ClientContext &transaction, Catalog &catalog);
-
-	//! Initialize a catalog with all built-in functions
-	void Initialize();
-
-public:
-	void AddFunction(AggregateFunctionSet set);
-	void AddFunction(AggregateFunction function);
-	void AddFunction(ScalarFunctionSet set);
-	void AddFunction(PragmaFunction function);
-	void AddFunction(const string &name, vector<PragmaFunction> functions);
-	void AddFunction(ScalarFunction function);
-	void AddFunction(const vector<string> &names, ScalarFunction function);
-	void AddFunction(TableFunctionSet set);
-	void AddFunction(TableFunction function);
-	void AddFunction(CopyFunction function);
-
-	void AddCollation(string name, ScalarFunction function, bool combinable = false,
-	                  bool not_required_for_equality = false);
-
-private:
-	ClientContext &context;
-	Catalog &catalog;
-
-private:
-	template <class T>
-	void Register() {
-		T::RegisterFunction(*this);
-	}
-
-	// table-producing functions
-	void RegisterSQLiteFunctions();
-	void RegisterReadFunctions();
-	void RegisterTableFunctions();
-	void RegisterArrowFunctions();
-
-	// aggregates
-	void RegisterAlgebraicAggregates();
-	void RegisterDistributiveAggregates();
-	void RegisterNestedAggregates();
-	void RegisterHolisticAggregates();
-	void RegisterRegressiveAggregates();
-
-	// scalar functions
-	void RegisterDateFunctions();
-	void RegisterEnumFunctions();
-	void RegisterGenericFunctions();
-	void RegisterMathFunctions();
-	void RegisterOperators();
-	void RegisterStringFunctions();
-	void RegisterNestedFunctions();
-	void RegisterSequenceFunctions();
-	void RegisterTrigonometricsFunctions();
-
-	// pragmas
-	void RegisterPragmaFunctions();
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class Expression;
-class ExpressionExecutor;
-struct ExpressionExecutorState;
-struct FunctionLocalState;
-
-struct ExpressionState {
-	ExpressionState(const Expression &expr, ExpressionExecutorState &root);
-	virtual ~ExpressionState() {
-	}
-
-	const Expression &expr;
-	ExpressionExecutorState &root;
-	vector<unique_ptr<ExpressionState>> child_states;
-	vector<LogicalType> types;
-	DataChunk intermediate_chunk;
-	string name;
-	CycleCounter profiler;
-
-public:
-	void AddChild(Expression *expr);
-	void Finalize();
-};
-
-struct ExecuteFunctionState : public ExpressionState {
-	ExecuteFunctionState(const Expression &expr, ExpressionExecutorState &root);
-	~ExecuteFunctionState();
-
-	unique_ptr<FunctionLocalState> local_state;
-
-public:
-	static FunctionLocalState *GetFunctionState(ExpressionState &state) {
-		return ((ExecuteFunctionState &)state).local_state.get();
-	}
-};
-
-struct ExpressionExecutorState {
-	explicit ExpressionExecutorState(const string &name);
-	unique_ptr<ExpressionState> root_state;
-	ExpressionExecutor *executor;
-	CycleCounter profiler;
-	string name;
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/base_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/comparison_operators.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/hugeint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/limits.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-struct NumericLimits {
-	static T Minimum();
-	static T Maximum();
-	static bool IsSigned();
-	static idx_t Digits();
-};
-
-template <>
-struct NumericLimits<int8_t> {
-	static int8_t Minimum();
-	static int8_t Maximum();
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 3;
-	}
-};
-template <>
-struct NumericLimits<int16_t> {
-	static int16_t Minimum();
-	static int16_t Maximum();
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 5;
-	}
-};
-template <>
-struct NumericLimits<int32_t> {
-	static int32_t Minimum();
-	static int32_t Maximum();
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 10;
-	}
-};
-template <>
-struct NumericLimits<int64_t> {
-	static int64_t Minimum();
-	static int64_t Maximum();
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 19;
-	}
-};
-template <>
-struct NumericLimits<hugeint_t> {
-	static hugeint_t Minimum();
-	static hugeint_t Maximum();
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 39;
-	}
-};
-template <>
-struct NumericLimits<uint8_t> {
-	static uint8_t Minimum();
-	static uint8_t Maximum();
-	static bool IsSigned() {
-		return false;
-	}
-	static idx_t Digits() {
-		return 3;
-	}
-};
-template <>
-struct NumericLimits<uint16_t> {
-	static uint16_t Minimum();
-	static uint16_t Maximum();
-	static bool IsSigned() {
-		return false;
-	}
-	static idx_t Digits() {
-		return 5;
-	}
-};
-template <>
-struct NumericLimits<uint32_t> {
-	static uint32_t Minimum();
-	static uint32_t Maximum();
-	static bool IsSigned() {
-		return false;
-	}
-	static idx_t Digits() {
-		return 10;
-	}
-};
-template <>
-struct NumericLimits<uint64_t> {
-	static uint64_t Minimum();
-	static uint64_t Maximum();
-	static bool IsSigned() {
-		return false;
-	}
-	static idx_t Digits() {
-		return 20;
-	}
-};
-template <>
-struct NumericLimits<float> {
-	static float Minimum();
-	static float Maximum();
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 127;
-	}
-};
-template <>
-struct NumericLimits<double> {
-	static double Minimum();
-	static double Maximum();
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 250;
-	}
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-//! The Hugeint class contains static operations for the INT128 type
-class Hugeint {
-public:
-	//! Convert a string to a hugeint object
-	static bool FromString(string str, hugeint_t &result);
-	//! Convert a string to a hugeint object
-	static bool FromCString(const char *str, idx_t len, hugeint_t &result);
-	//! Convert a hugeint object to a string
-	static string ToString(hugeint_t input);
-
-	static hugeint_t FromString(string str) {
-		hugeint_t result;
-		FromString(str, result);
-		return result;
-	}
-
-	template <class T>
-	static bool TryCast(hugeint_t input, T &result);
-
-	template <class T>
-	static T Cast(hugeint_t input) {
-		T value;
-		TryCast(input, value);
-		return value;
-	}
-
-	template <class T>
-	static bool TryConvert(T value, hugeint_t &result);
-
-	template <class T>
-	static hugeint_t Convert(T value) {
-		hugeint_t result;
-		if (!TryConvert(value, result)) { // LCOV_EXCL_START
-			throw ValueOutOfRangeException(double(value), GetTypeId<T>(), GetTypeId<hugeint_t>());
-		} // LCOV_EXCL_STOP
-		return result;
-	}
-
-	static void NegateInPlace(hugeint_t &input) {
-		input.lower = NumericLimits<uint64_t>::Maximum() - input.lower + 1;
-		input.upper = -1 - input.upper + (input.lower == 0);
-	}
-	static hugeint_t Negate(hugeint_t input) {
-		NegateInPlace(input);
-		return input;
-	}
-
-	static bool TryMultiply(hugeint_t lhs, hugeint_t rhs, hugeint_t &result);
-
-	static hugeint_t Add(hugeint_t lhs, hugeint_t rhs);
-	static hugeint_t Subtract(hugeint_t lhs, hugeint_t rhs);
-	static hugeint_t Multiply(hugeint_t lhs, hugeint_t rhs);
-	static hugeint_t Divide(hugeint_t lhs, hugeint_t rhs);
-	static hugeint_t Modulo(hugeint_t lhs, hugeint_t rhs);
-
-	// DivMod -> returns the result of the division (lhs / rhs), and fills up the remainder
-	static hugeint_t DivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder);
-	// DivMod but lhs MUST be positive, and rhs is a uint64_t
-	static hugeint_t DivModPositive(hugeint_t lhs, uint64_t rhs, uint64_t &remainder);
-
-	static bool AddInPlace(hugeint_t &lhs, hugeint_t rhs);
-	static bool SubtractInPlace(hugeint_t &lhs, hugeint_t rhs);
-
-	// comparison operators
-	// note that everywhere here we intentionally use bitwise ops
-	// this is because they seem to be consistently much faster (benchmarked on a Macbook Pro)
-	static bool Equals(hugeint_t lhs, hugeint_t rhs) {
-		int lower_equals = lhs.lower == rhs.lower;
-		int upper_equals = lhs.upper == rhs.upper;
-		return lower_equals & upper_equals;
-	}
-	static bool NotEquals(hugeint_t lhs, hugeint_t rhs) {
-		int lower_not_equals = lhs.lower != rhs.lower;
-		int upper_not_equals = lhs.upper != rhs.upper;
-		return lower_not_equals | upper_not_equals;
-	}
-	static bool GreaterThan(hugeint_t lhs, hugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger = lhs.lower > rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger);
-	}
-	static bool GreaterThanEquals(hugeint_t lhs, hugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger_equals = lhs.lower >= rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger_equals);
-	}
-	static bool LessThan(hugeint_t lhs, hugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller = lhs.lower < rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller);
-	}
-	static bool LessThanEquals(hugeint_t lhs, hugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller_equals = lhs.lower <= rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller_equals);
-	}
-	static const hugeint_t POWERS_OF_TEN[40];
-};
-
-template <>
-bool Hugeint::TryCast(hugeint_t input, int8_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, int16_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, int32_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, int64_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint8_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint16_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint32_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, uint64_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, hugeint_t &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, float &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, double &result);
-template <>
-bool Hugeint::TryCast(hugeint_t input, long double &result);
-
-template <>
-bool Hugeint::TryConvert(int8_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(int16_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(int32_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(int64_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(uint8_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(uint16_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(uint32_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(uint64_t value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(float value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(double value, hugeint_t &result);
-template <>
-bool Hugeint::TryConvert(long double value, hugeint_t &result);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/interval.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The Interval class is a static class that holds helper functions for the Interval
-//! type.
-class Interval {
-public:
-	static constexpr const int32_t MONTHS_PER_MILLENIUM = 12000;
-	static constexpr const int32_t MONTHS_PER_CENTURY = 1200;
-	static constexpr const int32_t MONTHS_PER_DECADE = 120;
-	static constexpr const int32_t MONTHS_PER_YEAR = 12;
-	static constexpr const int32_t MONTHS_PER_QUARTER = 3;
-	static constexpr const int32_t DAYS_PER_WEEK = 7;
-	//! only used for interval comparison/ordering purposes, in which case a month counts as 30 days
-	static constexpr const int64_t DAYS_PER_MONTH = 30;
-	static constexpr const int64_t DAYS_PER_YEAR = 365;
-	static constexpr const int64_t MSECS_PER_SEC = 1000;
-	static constexpr const int32_t SECS_PER_MINUTE = 60;
-	static constexpr const int32_t MINS_PER_HOUR = 60;
-	static constexpr const int32_t HOURS_PER_DAY = 24;
-	static constexpr const int32_t SECS_PER_HOUR = SECS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int32_t SECS_PER_DAY = SECS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int32_t SECS_PER_WEEK = SECS_PER_DAY * DAYS_PER_WEEK;
-
-	static constexpr const int64_t MICROS_PER_MSEC = 1000;
-	static constexpr const int64_t MICROS_PER_SEC = MICROS_PER_MSEC * MSECS_PER_SEC;
-	static constexpr const int64_t MICROS_PER_MINUTE = MICROS_PER_SEC * SECS_PER_MINUTE;
-	static constexpr const int64_t MICROS_PER_HOUR = MICROS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int64_t MICROS_PER_DAY = MICROS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int64_t MICROS_PER_WEEK = MICROS_PER_DAY * DAYS_PER_WEEK;
-	static constexpr const int64_t MICROS_PER_MONTH = MICROS_PER_DAY * DAYS_PER_MONTH;
-
-	static constexpr const int64_t NANOS_PER_MICRO = 1000;
-	static constexpr const int64_t NANOS_PER_MSEC = NANOS_PER_MICRO * MICROS_PER_MSEC;
-	static constexpr const int64_t NANOS_PER_SEC = NANOS_PER_MSEC * MSECS_PER_SEC;
-	static constexpr const int64_t NANOS_PER_MINUTE = NANOS_PER_SEC * SECS_PER_MINUTE;
-	static constexpr const int64_t NANOS_PER_HOUR = NANOS_PER_MINUTE * MINS_PER_HOUR;
-	static constexpr const int64_t NANOS_PER_DAY = NANOS_PER_HOUR * HOURS_PER_DAY;
-	static constexpr const int64_t NANOS_PER_WEEK = NANOS_PER_DAY * DAYS_PER_WEEK;
-
-public:
-	//! Convert a string to an interval object
-	static bool FromString(const string &str, interval_t &result);
-	//! Convert a string to an interval object
-	static bool FromCString(const char *str, idx_t len, interval_t &result, string *error_message, bool strict);
-	//! Convert an interval object to a string
-	static string ToString(const interval_t &val);
-
-	//! Convert milliseconds to a normalised interval
-	DUCKDB_API static interval_t FromMicro(int64_t micros);
-
-	//! Get Interval in milliseconds
-	static int64_t GetMilli(const interval_t &val);
-
-	//! Get Interval in microseconds
-	static int64_t GetMicro(const interval_t &val);
-
-	//! Get Interval in Nanoseconds
-	static int64_t GetNanoseconds(const interval_t &val);
-
-	//! Returns the age between two timestamps (including 30 day months)
-	static interval_t GetAge(timestamp_t timestamp_1, timestamp_t timestamp_2);
-
-	//! Returns the exact difference between two timestamps (days and seconds)
-	static interval_t GetDifference(timestamp_t timestamp_1, timestamp_t timestamp_2);
-
-	//! Add an interval to a date
-	static date_t Add(date_t left, interval_t right);
-	//! Add an interval to a timestamp
-	static timestamp_t Add(timestamp_t left, interval_t right);
-	//! Add an interval to a time. In case the time overflows or underflows, modify the date by the overflow.
-	//! For example if we go from 23:00 to 02:00, we add a day to the date
-	static dtime_t Add(dtime_t left, interval_t right, date_t &date);
-
-	//! Comparison operators
-	static bool Equals(interval_t left, interval_t right);
-	static bool GreaterThan(interval_t left, interval_t right);
-	static bool GreaterThanEquals(interval_t left, interval_t right);
-};
-} // namespace duckdb
-
-
-
-#include <cstring>
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Comparison Operations
-//===--------------------------------------------------------------------===//
-struct Equals {
-	template <class T>
-	static inline bool Operation(T left, T right) {
-		return left == right;
-	}
-};
-struct NotEquals {
-	template <class T>
-	static inline bool Operation(T left, T right) {
-		return !Equals::Operation(left, right);
-	}
-};
-
-struct GreaterThan {
-	template <class T>
-	static inline bool Operation(T left, T right) {
-		return left > right;
-	}
-};
-
-struct GreaterThanEquals {
-	template <class T>
-	static inline bool Operation(T left, T right) {
-		return left >= right;
-	}
-};
-
-struct LessThan {
-	template <class T>
-	static inline bool Operation(T left, T right) {
-		return GreaterThan::Operation(right, left);
-	}
-};
-
-struct LessThanEquals {
-	template <class T>
-	static inline bool Operation(T left, T right) {
-		return GreaterThanEquals::Operation(right, left);
-	}
-};
-
-template <>
-bool Equals::Operation(float left, float right);
-template <>
-bool Equals::Operation(double left, double right);
-
-template <>
-bool GreaterThan::Operation(float left, float right);
-template <>
-bool GreaterThan::Operation(double left, double right);
-
-template <>
-bool GreaterThanEquals::Operation(float left, float right);
-template <>
-bool GreaterThanEquals::Operation(double left, double right);
-
-// Distinct semantics are from Postgres record sorting. NULL = NULL and not-NULL < NULL
-// Deferring to the non-distinct operations removes the need for further specialisation.
-// TODO: To reverse the semantics, swap left_null and right_null for comparisons
-struct DistinctFrom {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return (left_null != right_null) || (!left_null && !right_null && NotEquals::Operation(left, right));
-	}
-};
-
-struct NotDistinctFrom {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return (left_null && right_null) || (!left_null && !right_null && Equals::Operation(left, right));
-	}
-};
-
-struct DistinctGreaterThan {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return GreaterThan::Operation(left_null, right_null) ||
-		       (!left_null && !right_null && GreaterThan::Operation(left, right));
-	}
-};
-
-struct DistinctGreaterThanNullsFirst {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return GreaterThan::Operation(right_null, left_null) ||
-		       (!left_null && !right_null && GreaterThan::Operation(left, right));
-	}
-};
-
-struct DistinctGreaterThanEquals {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return left_null || (!left_null && !right_null && GreaterThanEquals::Operation(left, right));
-	}
-};
-
-struct DistinctLessThan {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return LessThan::Operation(left_null, right_null) ||
-		       (!left_null && !right_null && LessThan::Operation(left, right));
-	}
-};
-
-struct DistinctLessThanNullsFirst {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return LessThan::Operation(right_null, left_null) ||
-		       (!left_null && !right_null && LessThan::Operation(left, right));
-	}
-};
-
-struct DistinctLessThanEquals {
-	template <class T>
-	static inline bool Operation(T left, T right, bool left_null, bool right_null) {
-		return right_null || (!left_null && !right_null && LessThanEquals::Operation(left, right));
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Specialized Boolean Comparison Operators
-//===--------------------------------------------------------------------===//
-template <>
-inline bool GreaterThan::Operation(bool left, bool right) {
-	return !right && left;
-}
-template <>
-inline bool LessThan::Operation(bool left, bool right) {
-	return !left && right;
-}
-//===--------------------------------------------------------------------===//
-// Specialized String Comparison Operations
-//===--------------------------------------------------------------------===//
-struct StringComparisonOperators {
-	template <bool INVERSE>
-	static inline bool EqualsOrNot(const string_t a, const string_t b) {
-		if (a.IsInlined()) {
-			// small string: compare entire string
-			if (memcmp(&a, &b, sizeof(string_t)) == 0) {
-				// entire string is equal
-				return INVERSE ? false : true;
-			}
-		} else {
-			// large string: first check prefix and length
-			if (memcmp(&a, &b, sizeof(uint32_t) + string_t::PREFIX_LENGTH) == 0) {
-				// prefix and length are equal: check main string
-				if (memcmp(a.value.pointer.ptr, b.value.pointer.ptr, a.GetSize()) == 0) {
-					// entire string is equal
-					return INVERSE ? false : true;
-				}
-			}
-		}
-		// not equal
-		return INVERSE ? true : false;
-	}
-};
-
-template <>
-inline bool Equals::Operation(string_t left, string_t right) {
-	return StringComparisonOperators::EqualsOrNot<false>(left, right);
-}
-template <>
-inline bool NotEquals::Operation(string_t left, string_t right) {
-	return StringComparisonOperators::EqualsOrNot<true>(left, right);
-}
-
-template <>
-inline bool NotDistinctFrom::Operation(string_t left, string_t right, bool left_null, bool right_null) {
-	return (left_null && right_null) ||
-	       (!left_null && !right_null && StringComparisonOperators::EqualsOrNot<false>(left, right));
-}
-template <>
-inline bool DistinctFrom::Operation(string_t left, string_t right, bool left_null, bool right_null) {
-	return (left_null != right_null) ||
-	       (!left_null && !right_null && StringComparisonOperators::EqualsOrNot<true>(left, right));
-}
-
-// compare up to shared length. if still the same, compare lengths
-template <class OP>
-static bool templated_string_compare_op(string_t left, string_t right) {
-	auto memcmp_res =
-	    memcmp(left.GetDataUnsafe(), right.GetDataUnsafe(), MinValue<idx_t>(left.GetSize(), right.GetSize()));
-	auto final_res = memcmp_res == 0 ? OP::Operation(left.GetSize(), right.GetSize()) : OP::Operation(memcmp_res, 0);
-	return final_res;
-}
-
-template <>
-inline bool GreaterThan::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<GreaterThan>(left, right);
-}
-
-template <>
-inline bool GreaterThanEquals::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<GreaterThanEquals>(left, right);
-}
-
-template <>
-inline bool LessThan::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<LessThan>(left, right);
-}
-
-template <>
-inline bool LessThanEquals::Operation(string_t left, string_t right) {
-	return templated_string_compare_op<LessThanEquals>(left, right);
-}
-//===--------------------------------------------------------------------===//
-// Specialized Interval Comparison Operators
-//===--------------------------------------------------------------------===//
-template <>
-inline bool Equals::Operation(interval_t left, interval_t right) {
-	return Interval::Equals(left, right);
-}
-template <>
-inline bool NotEquals::Operation(interval_t left, interval_t right) {
-	return !Equals::Operation(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(interval_t left, interval_t right) {
-	return Interval::GreaterThan(left, right);
-}
-template <>
-inline bool GreaterThanEquals::Operation(interval_t left, interval_t right) {
-	return Interval::GreaterThanEquals(left, right);
-}
-template <>
-inline bool LessThan::Operation(interval_t left, interval_t right) {
-	return GreaterThan::Operation(right, left);
-}
-template <>
-inline bool LessThanEquals::Operation(interval_t left, interval_t right) {
-	return GreaterThanEquals::Operation(right, left);
-}
-
-template <>
-inline bool NotDistinctFrom::Operation(interval_t left, interval_t right, bool left_null, bool right_null) {
-	return (left_null && right_null) || (!left_null && !right_null && Interval::Equals(left, right));
-}
-template <>
-inline bool DistinctFrom::Operation(interval_t left, interval_t right, bool left_null, bool right_null) {
-	return (left_null != right_null) || (!left_null && !right_null && !Equals::Operation(left, right));
-}
-inline bool operator<(const interval_t &lhs, const interval_t &rhs) {
-	return LessThan::Operation(lhs, rhs);
-}
-
-//===--------------------------------------------------------------------===//
-// Specialized Hugeint Comparison Operators
-//===--------------------------------------------------------------------===//
-template <>
-inline bool Equals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::Equals(left, right);
-}
-template <>
-inline bool NotEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::NotEquals(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::GreaterThan(left, right);
-}
-template <>
-inline bool GreaterThanEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::GreaterThanEquals(left, right);
-}
-template <>
-inline bool LessThan::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::LessThan(left, right);
-}
-template <>
-inline bool LessThanEquals::Operation(hugeint_t left, hugeint_t right) {
-	return Hugeint::LessThanEquals(left, right);
-}
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-struct SelectionVector;
-
-class Serializer;
-class Deserializer;
-class FieldWriter;
-class FieldReader;
-class Vector;
-class ValidityStatistics;
-class DistinctStatistics;
-struct VectorData;
-
-enum StatisticsType { LOCAL_STATS = 0, GLOBAL_STATS = 1 };
-
-class BaseStatistics {
-public:
-	BaseStatistics(LogicalType type, StatisticsType stats_type);
-	virtual ~BaseStatistics();
-
-	//! The type of the logical segment
-	LogicalType type;
-	//! The validity stats of the column (if any)
-	unique_ptr<BaseStatistics> validity_stats;
-	//! The approximate count distinct stats of the column (if any)
-	unique_ptr<BaseStatistics> distinct_stats;
-	//! Whether these are 'global' stats, i.e., over a whole table, or just over a segment
-	//! Some statistics are more expensive to keep, therefore we only keep them globally
-	StatisticsType stats_type;
-
-public:
-	static unique_ptr<BaseStatistics> CreateEmpty(LogicalType type, StatisticsType stats_type);
-
-	bool CanHaveNull() const;
-	bool CanHaveNoNull() const;
-
-	void UpdateDistinctStatistics(Vector &v, idx_t count);
-
-	virtual bool IsConstant() const {
-		return false;
-	}
-
-	virtual void Merge(const BaseStatistics &other);
-
-	virtual unique_ptr<BaseStatistics> Copy() const;
-	void CopyBase(const BaseStatistics &orig);
-
-	virtual void Serialize(Serializer &serializer) const;
-	virtual void Serialize(FieldWriter &writer) const;
-
-	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
-
-	//! Verify that a vector does not violate the statistics
-	virtual void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
-	void Verify(Vector &vector, idx_t count) const;
-
-	virtual string ToString() const;
-
-protected:
-	void InitializeBase();
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct FunctionLocalState {
-	DUCKDB_API virtual ~FunctionLocalState();
-};
-
-enum class FunctionNullHandling : uint8_t { NULL_IN_NULL_OUT = 0, SPECIAL_HANDLING = 1 };
-
-class Binder;
-class BoundFunctionExpression;
-class ScalarFunctionCatalogEntry;
-
-struct FunctionStatisticsInput {
-	FunctionStatisticsInput(BoundFunctionExpression &expr_p, FunctionData *bind_data_p,
-	                        vector<unique_ptr<BaseStatistics>> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
-	    : expr(expr_p), bind_data(bind_data_p), child_stats(child_stats_p), expr_ptr(expr_ptr_p) {
-	}
-
-	BoundFunctionExpression &expr;
-	FunctionData *bind_data;
-	vector<unique_ptr<BaseStatistics>> &child_stats;
-	unique_ptr<Expression> *expr_ptr;
-};
-
-//! The type used for scalar functions
-typedef std::function<void(DataChunk &, ExpressionState &, Vector &)> scalar_function_t;
-//! Binds the scalar function and creates the function data
-typedef unique_ptr<FunctionData> (*bind_scalar_function_t)(ClientContext &context, ScalarFunction &bound_function,
-                                                           vector<unique_ptr<Expression>> &arguments);
-typedef unique_ptr<FunctionLocalState> (*init_local_state_t)(const BoundFunctionExpression &expr,
-                                                             FunctionData *bind_data);
-typedef unique_ptr<BaseStatistics> (*function_statistics_t)(ClientContext &context, FunctionStatisticsInput &input);
-//! Adds the dependencies of this BoundFunctionExpression to the set of dependencies
-typedef void (*dependency_function_t)(BoundFunctionExpression &expr, unordered_set<CatalogEntry *> &dependencies);
-
-class ScalarFunction : public BaseScalarFunction {
-public:
-	DUCKDB_API ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
-	                          scalar_function_t function, bool has_side_effects = false,
-	                          bind_scalar_function_t bind = nullptr, dependency_function_t dependency = nullptr,
-	                          function_statistics_t statistics = nullptr, init_local_state_t init_local_state = nullptr,
-	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID),
-	                          bool propagate_null_values = false,
-	                          FunctionNullHandling null_handling = FunctionNullHandling::NULL_IN_NULL_OUT);
-
-	DUCKDB_API ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
-	                          bool propagate_null_values = false, bool has_side_effects = false,
-	                          bind_scalar_function_t bind = nullptr, dependency_function_t dependency = nullptr,
-	                          function_statistics_t statistics = nullptr, init_local_state_t init_local_state = nullptr,
-	                          LogicalType varargs = LogicalType(LogicalTypeId::INVALID),
-	                          FunctionNullHandling null_handling = FunctionNullHandling::NULL_IN_NULL_OUT);
-
-	//! The main scalar function to execute
-	scalar_function_t function;
-	//! The bind function (if any)
-	bind_scalar_function_t bind;
-	//! Init thread local state for the function (if any)
-	init_local_state_t init_local_state;
-	//! The dependency function (if any)
-	dependency_function_t dependency;
-	//! The statistics propagation function (if any)
-	function_statistics_t statistics;
-	//! How this function handles NULL values
-	FunctionNullHandling null_handling;
-
-	DUCKDB_API static unique_ptr<Expression> BindScalarFunction(ClientContext &context, const string &schema,
-	                                                            const string &name,
-	                                                            vector<unique_ptr<Expression>> children, string &error,
-	                                                            bool is_operator = false, Binder *binder = nullptr);
-	DUCKDB_API static unique_ptr<Expression> BindScalarFunction(ClientContext &context,
-	                                                            ScalarFunctionCatalogEntry &function,
-	                                                            vector<unique_ptr<Expression>> children, string &error,
-	                                                            bool is_operator = false, Binder *binder = nullptr);
-
-	DUCKDB_API static unique_ptr<BoundFunctionExpression>
-	BindScalarFunction(ClientContext &context, ScalarFunction bound_function, vector<unique_ptr<Expression>> children,
-	                   bool is_operator = false, bool cast_parameters = true);
-
-	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
-	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;
-
-	DUCKDB_API bool Equal(const ScalarFunction &rhs) const;
-
-private:
-	bool CompareScalarFunctionT(const scalar_function_t &other) const;
-
-public:
-	DUCKDB_API static void NopFunction(DataChunk &input, ExpressionState &state, Vector &result);
-
-	template <class TA, class TR, class OP>
-	static void UnaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-		D_ASSERT(input.ColumnCount() >= 1);
-		UnaryExecutor::Execute<TA, TR, OP>(input.data[0], result, input.size());
-	}
-
-	template <class TA, class TB, class TR, class OP>
-	static void BinaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-		D_ASSERT(input.ColumnCount() == 2);
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, OP>(input.data[0], input.data[1], result, input.size());
-	}
-
-public:
-	template <class OP>
-	static scalar_function_t GetScalarUnaryFunction(LogicalType type) {
-		scalar_function_t function;
-		switch (type.id()) {
-		case LogicalTypeId::TINYINT:
-			function = &ScalarFunction::UnaryFunction<int8_t, int8_t, OP>;
-			break;
-		case LogicalTypeId::SMALLINT:
-			function = &ScalarFunction::UnaryFunction<int16_t, int16_t, OP>;
-			break;
-		case LogicalTypeId::INTEGER:
-			function = &ScalarFunction::UnaryFunction<int32_t, int32_t, OP>;
-			break;
-		case LogicalTypeId::BIGINT:
-			function = &ScalarFunction::UnaryFunction<int64_t, int64_t, OP>;
-			break;
-		case LogicalTypeId::UTINYINT:
-			function = &ScalarFunction::UnaryFunction<uint8_t, uint8_t, OP>;
-			break;
-		case LogicalTypeId::USMALLINT:
-			function = &ScalarFunction::UnaryFunction<uint16_t, uint16_t, OP>;
-			break;
-		case LogicalTypeId::UINTEGER:
-			function = &ScalarFunction::UnaryFunction<uint32_t, uint32_t, OP>;
-			break;
-		case LogicalTypeId::UBIGINT:
-			function = &ScalarFunction::UnaryFunction<uint64_t, uint64_t, OP>;
-			break;
-		case LogicalTypeId::HUGEINT:
-			function = &ScalarFunction::UnaryFunction<hugeint_t, hugeint_t, OP>;
-			break;
-		case LogicalTypeId::FLOAT:
-			function = &ScalarFunction::UnaryFunction<float, float, OP>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			function = &ScalarFunction::UnaryFunction<double, double, OP>;
-			break;
-		default:
-			throw InternalException("Unimplemented type for GetScalarUnaryFunction");
-		}
-		return function;
-	}
-
-	template <class TR, class OP>
-	static scalar_function_t GetScalarUnaryFunctionFixedReturn(LogicalType type) {
-		scalar_function_t function;
-		switch (type.id()) {
-		case LogicalTypeId::TINYINT:
-			function = &ScalarFunction::UnaryFunction<int8_t, TR, OP>;
-			break;
-		case LogicalTypeId::SMALLINT:
-			function = &ScalarFunction::UnaryFunction<int16_t, TR, OP>;
-			break;
-		case LogicalTypeId::INTEGER:
-			function = &ScalarFunction::UnaryFunction<int32_t, TR, OP>;
-			break;
-		case LogicalTypeId::BIGINT:
-			function = &ScalarFunction::UnaryFunction<int64_t, TR, OP>;
-			break;
-		case LogicalTypeId::UTINYINT:
-			function = &ScalarFunction::UnaryFunction<uint8_t, TR, OP>;
-			break;
-		case LogicalTypeId::USMALLINT:
-			function = &ScalarFunction::UnaryFunction<uint16_t, TR, OP>;
-			break;
-		case LogicalTypeId::UINTEGER:
-			function = &ScalarFunction::UnaryFunction<uint32_t, TR, OP>;
-			break;
-		case LogicalTypeId::UBIGINT:
-			function = &ScalarFunction::UnaryFunction<uint64_t, TR, OP>;
-			break;
-		case LogicalTypeId::HUGEINT:
-			function = &ScalarFunction::UnaryFunction<hugeint_t, TR, OP>;
-			break;
-		case LogicalTypeId::FLOAT:
-			function = &ScalarFunction::UnaryFunction<float, TR, OP>;
-			break;
-		case LogicalTypeId::DOUBLE:
-			function = &ScalarFunction::UnaryFunction<double, TR, OP>;
-			break;
-		default:
-			throw InternalException("Unimplemented type for GetScalarUnaryFunctionFixedReturn");
-		}
-		return function;
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/aggregate_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/node_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class NodeStatistics {
-public:
-	NodeStatistics() : has_estimated_cardinality(false), has_max_cardinality(false) {
-	}
-	explicit NodeStatistics(idx_t estimated_cardinality)
-	    : has_estimated_cardinality(true), estimated_cardinality(estimated_cardinality), has_max_cardinality(false) {
-	}
-	NodeStatistics(idx_t estimated_cardinality, idx_t max_cardinality)
-	    : has_estimated_cardinality(true), estimated_cardinality(estimated_cardinality), has_max_cardinality(true),
-	      max_cardinality(max_cardinality) {
-	}
-
-	//! Whether or not the node has an estimated cardinality specified
-	bool has_estimated_cardinality;
-	//! The estimated cardinality at the specified node
-	idx_t estimated_cardinality;
-	//! Whether or not the node has a maximum cardinality specified
-	bool has_max_cardinality;
-	//! The max possible cardinality at the specified node
-	idx_t max_cardinality;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_result_modifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/result_modifier.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/order_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class OrderType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, ASCENDING = 2, DESCENDING = 3 };
-enum class OrderByNullType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, NULLS_FIRST = 2, NULLS_LAST = 3 };
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class FieldWriter;
-class FieldReader;
-
-enum ResultModifierType : uint8_t {
-	LIMIT_MODIFIER = 1,
-	ORDER_MODIFIER = 2,
-	DISTINCT_MODIFIER = 3,
-	LIMIT_PERCENT_MODIFIER = 4
-};
-
-//! A ResultModifier
-class ResultModifier {
-public:
-	explicit ResultModifier(ResultModifierType type) : type(type) {
-	}
-	virtual ~ResultModifier() {
-	}
-
-	ResultModifierType type;
-
-public:
-	//! Returns true if the two result modifiers are equivalent
-	virtual bool Equals(const ResultModifier *other) const;
-
-	//! Create a copy of this ResultModifier
-	virtual unique_ptr<ResultModifier> Copy() const = 0;
-	//! Serializes a ResultModifier to a stand-alone binary blob
-	void Serialize(Serializer &serializer) const;
-	//! Serializes a ResultModifier to a stand-alone binary blob
-	virtual void Serialize(FieldWriter &writer) const = 0;
-	//! Deserializes a blob back into a ResultModifier
-	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
-};
-
-//! Single node in ORDER BY statement
-struct OrderByNode {
-	OrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<ParsedExpression> expression)
-	    : type(type), null_order(null_order), expression(std::move(expression)) {
-	}
-
-	//! Sort order, ASC or DESC
-	OrderType type;
-	//! The NULL sort order, NULLS_FIRST or NULLS_LAST
-	OrderByNullType null_order;
-	//! Expression to order by
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	void Serialize(Serializer &serializer) const;
-	string ToString() const;
-	static OrderByNode Deserialize(Deserializer &source);
-};
-
-class LimitModifier : public ResultModifier {
-public:
-	LimitModifier() : ResultModifier(ResultModifierType::LIMIT_MODIFIER) {
-	}
-
-	//! LIMIT count
-	unique_ptr<ParsedExpression> limit;
-	//! OFFSET
-	unique_ptr<ParsedExpression> offset;
-
-public:
-	bool Equals(const ResultModifier *other) const override;
-	unique_ptr<ResultModifier> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
-};
-
-class OrderModifier : public ResultModifier {
-public:
-	OrderModifier() : ResultModifier(ResultModifierType::ORDER_MODIFIER) {
-	}
-
-	//! List of order nodes
-	vector<OrderByNode> orders;
-
-public:
-	bool Equals(const ResultModifier *other) const override;
-	unique_ptr<ResultModifier> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
-};
-
-class DistinctModifier : public ResultModifier {
-public:
-	DistinctModifier() : ResultModifier(ResultModifierType::DISTINCT_MODIFIER) {
-	}
-
-	//! list of distinct on targets (if any)
-	vector<unique_ptr<ParsedExpression>> distinct_on_targets;
-
-public:
-	bool Equals(const ResultModifier *other) const override;
-	unique_ptr<ResultModifier> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
-};
-
-class LimitPercentModifier : public ResultModifier {
-public:
-	LimitPercentModifier() : ResultModifier(ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-	}
-
-	//! LIMIT %
-	unique_ptr<ParsedExpression> limit;
-	//! OFFSET
-	unique_ptr<ParsedExpression> offset;
-
-public:
-	bool Equals(const ResultModifier *other) const override;
-	unique_ptr<ResultModifier> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/logical_operator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/catalog_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Catalog Types
-//===--------------------------------------------------------------------===//
-enum class CatalogType : uint8_t {
-	INVALID = 0,
-	TABLE_ENTRY = 1,
-	SCHEMA_ENTRY = 2,
-	VIEW_ENTRY = 3,
-	INDEX_ENTRY = 4,
-	PREPARED_STATEMENT = 5,
-	SEQUENCE_ENTRY = 6,
-	COLLATION_ENTRY = 7,
-	TYPE_ENTRY = 8,
-
-	// functions
-	TABLE_FUNCTION_ENTRY = 25,
-	SCALAR_FUNCTION_ENTRY = 26,
-	AGGREGATE_FUNCTION_ENTRY = 27,
-	PRAGMA_FUNCTION_ENTRY = 28,
-	COPY_FUNCTION_ENTRY = 29,
-	MACRO_ENTRY = 30,
-	TABLE_MACRO_ENTRY = 31,
-
-	// version info
-	UPDATED_ENTRY = 50,
-	DELETED_ENTRY = 51,
-};
-
-string CatalogTypeToString(CatalogType type);
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/atomic.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <atomic>
-
-namespace duckdb {
-using std::atomic;
-}
-
-
-#include <memory>
-
-namespace duckdb {
-struct AlterInfo;
-class Catalog;
-class CatalogSet;
-class ClientContext;
-
-//! Abstract base class of an entry in the catalog
-class CatalogEntry {
-public:
-	CatalogEntry(CatalogType type, Catalog *catalog, string name);
-	virtual ~CatalogEntry();
-
-	//! The oid of the entry
-	idx_t oid;
-	//! The type of this catalog entry
-	CatalogType type;
-	//! Reference to the catalog this entry belongs to
-	Catalog *catalog;
-	//! Reference to the catalog set this entry is stored in
-	CatalogSet *set;
-	//! The name of the entry
-	string name;
-	//! Whether or not the object is deleted
-	bool deleted;
-	//! Whether or not the object is temporary and should not be added to the WAL
-	bool temporary;
-	//! Whether or not the entry is an internal entry (cannot be deleted, not dumped, etc)
-	bool internal;
-	//! Timestamp at which the catalog entry was created
-	atomic<transaction_t> timestamp;
-	//! Child entry
-	unique_ptr<CatalogEntry> child;
-	//! Parent entry (the node that dependents_map this node)
-	CatalogEntry *parent;
-
-public:
-	virtual unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info);
-
-	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context);
-
-	//! Sets the CatalogEntry as the new root entry (i.e. the newest entry)
-	// this is called on a rollback to an AlterEntry
-	virtual void SetAsRoot();
-
-	//! Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry
-	virtual string ToSQL();
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/mutex.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <mutex>
-
-namespace duckdb {
-using std::lock_guard;
-using std::mutex;
-using std::unique_lock;
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_error_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class SQLStatement;
-
-class QueryErrorContext {
-public:
-	explicit QueryErrorContext(SQLStatement *statement_ = nullptr, idx_t query_location_ = DConstants::INVALID_INDEX)
-	    : statement(statement_), query_location(query_location_) {
-	}
-
-	//! The query statement
-	SQLStatement *statement;
-	//! The location in which the error should be thrown
-	idx_t query_location;
-
-public:
-	static string Format(const string &query, const string &error_message, int error_location);
-
-	string FormatErrorRecursive(const string &msg, vector<ExceptionFormatValue> &values);
-	template <class T, typename... Args>
-	string FormatErrorRecursive(const string &msg, vector<ExceptionFormatValue> &values, T param, Args... params) {
-		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
-		return FormatErrorRecursive(msg, values, params...);
-	}
-
-	template <typename... Args>
-	string FormatError(const string &msg, Args... params) {
-		vector<ExceptionFormatValue> values;
-		return FormatErrorRecursive(msg, values, params...);
-	}
-};
-
-} // namespace duckdb
-
-
-#include <functional>
-
-
-namespace duckdb {
-struct CreateSchemaInfo;
-struct DropInfo;
-struct BoundCreateTableInfo;
-struct AlterTableInfo;
-struct CreateTableFunctionInfo;
-struct CreateCopyFunctionInfo;
-struct CreatePragmaFunctionInfo;
-struct CreateFunctionInfo;
-struct CreateViewInfo;
-struct CreateSequenceInfo;
-struct CreateCollationInfo;
-struct CreateTypeInfo;
-struct CreateTableInfo;
-
-class ClientContext;
-class Transaction;
-
-class AggregateFunctionCatalogEntry;
-class CollateCatalogEntry;
-class SchemaCatalogEntry;
-class TableCatalogEntry;
-class ViewCatalogEntry;
-class SequenceCatalogEntry;
-class TableFunctionCatalogEntry;
-class CopyFunctionCatalogEntry;
-class PragmaFunctionCatalogEntry;
-class CatalogSet;
-class DatabaseInstance;
-class DependencyManager;
-
-//! Return value of Catalog::LookupEntry
-struct CatalogEntryLookup {
-	SchemaCatalogEntry *schema;
-	CatalogEntry *entry;
-
-	DUCKDB_API bool Found() const {
-		return entry;
-	}
-};
-
-//! Return value of SimilarEntryInSchemas
-struct SimilarCatalogEntry {
-	//! The entry name. Empty if absent
-	string name;
-	//! The distance to the given name.
-	idx_t distance;
-	//! The schema of the entry.
-	SchemaCatalogEntry *schema;
-
-	DUCKDB_API bool Found() const {
-		return !name.empty();
-	}
-
-	DUCKDB_API string GetQualifiedName() const;
-};
-
-//! The Catalog object represents the catalog of the database.
-class Catalog {
-public:
-	explicit Catalog(DatabaseInstance &db);
-	~Catalog();
-
-	//! Reference to the database
-	DatabaseInstance &db;
-	//! The catalog set holding the schemas
-	unique_ptr<CatalogSet> schemas;
-	//! The DependencyManager manages dependencies between different catalog objects
-	unique_ptr<DependencyManager> dependency_manager;
-	//! Write lock for the catalog
-	mutex write_lock;
-
-public:
-	//! Get the Catalog from the ClientContext
-	DUCKDB_API static Catalog &GetCatalog(ClientContext &context);
-	//! Get the Catalog from the DatabaseInstance
-	DUCKDB_API static Catalog &GetCatalog(DatabaseInstance &db);
-
-	DUCKDB_API DependencyManager &GetDependencyManager() {
-		return *dependency_manager;
-	}
-
-	//! Returns the current version of the catalog (incremented whenever anything changes, not stored between restarts)
-	DUCKDB_API idx_t GetCatalogVersion();
-	//! Trigger a modification in the catalog, increasing the catalog version and returning the previous version
-	DUCKDB_API idx_t ModifyCatalog();
-
-	//! Creates a schema in the catalog.
-	DUCKDB_API CatalogEntry *CreateSchema(ClientContext &context, CreateSchemaInfo *info);
-	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, BoundCreateTableInfo *info);
-	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info);
-	//! Create a table function in the catalog
-	DUCKDB_API CatalogEntry *CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info);
-	//! Create a copy function in the catalog
-	DUCKDB_API CatalogEntry *CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info);
-	//! Create a pragma function in the catalog
-	DUCKDB_API CatalogEntry *CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info);
-	//! Create a scalar or aggregate function in the catalog
-	DUCKDB_API CatalogEntry *CreateFunction(ClientContext &context, CreateFunctionInfo *info);
-	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateView(ClientContext &context, CreateViewInfo *info);
-	//! Creates a sequence in the catalog.
-	DUCKDB_API CatalogEntry *CreateSequence(ClientContext &context, CreateSequenceInfo *info);
-	//! Creates a Enum in the catalog.
-	DUCKDB_API CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
-	//! Creates a collation in the catalog
-	DUCKDB_API CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
-
-	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, SchemaCatalogEntry *schema,
-	                                     BoundCreateTableInfo *info);
-	//! Create a table function in the catalog
-	DUCKDB_API CatalogEntry *CreateTableFunction(ClientContext &context, SchemaCatalogEntry *schema,
-	                                             CreateTableFunctionInfo *info);
-	//! Create a copy function in the catalog
-	DUCKDB_API CatalogEntry *CreateCopyFunction(ClientContext &context, SchemaCatalogEntry *schema,
-	                                            CreateCopyFunctionInfo *info);
-	//! Create a pragma function in the catalog
-	DUCKDB_API CatalogEntry *CreatePragmaFunction(ClientContext &context, SchemaCatalogEntry *schema,
-	                                              CreatePragmaFunctionInfo *info);
-	//! Create a scalar or aggregate function in the catalog
-	DUCKDB_API CatalogEntry *CreateFunction(ClientContext &context, SchemaCatalogEntry *schema,
-	                                        CreateFunctionInfo *info);
-	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateView(ClientContext &context, SchemaCatalogEntry *schema, CreateViewInfo *info);
-	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateSequence(ClientContext &context, SchemaCatalogEntry *schema,
-	                                        CreateSequenceInfo *info);
-	//! Creates a enum in the catalog.
-	DUCKDB_API CatalogEntry *CreateType(ClientContext &context, SchemaCatalogEntry *schema, CreateTypeInfo *info);
-	//! Creates a collation in the catalog
-	DUCKDB_API CatalogEntry *CreateCollation(ClientContext &context, SchemaCatalogEntry *schema,
-	                                         CreateCollationInfo *info);
-
-	//! Drops an entry from the catalog
-	DUCKDB_API void DropEntry(ClientContext &context, DropInfo *info);
-
-	//! Returns the schema object with the specified name, or throws an exception if it does not exist
-	DUCKDB_API SchemaCatalogEntry *GetSchema(ClientContext &context, const string &name = DEFAULT_SCHEMA,
-	                                         bool if_exists = false,
-	                                         QueryErrorContext error_context = QueryErrorContext());
-	//! Scans all the schemas in the system one-by-one, invoking the callback for each entry
-	DUCKDB_API void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback);
-	//! Gets the "schema.name" entry of the specified type, if if_exists=true returns nullptr if entry does not exist,
-	//! otherwise an exception is thrown
-	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &schema,
-	                                  const string &name, bool if_exists = false,
-	                                  QueryErrorContext error_context = QueryErrorContext());
-
-	//! Gets the "schema.name" entry without a specified type, if entry does not exist an exception is thrown
-	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, const string &schema, const string &name);
-
-	//! Fetches a logical type from the catalog
-	DUCKDB_API LogicalType GetType(ClientContext &context, const string &schema, const string &name);
-
-	template <class T>
-	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
-	            QueryErrorContext error_context = QueryErrorContext());
-
-	//! Append a scalar or aggregate function to the catalog
-	DUCKDB_API CatalogEntry *AddFunction(ClientContext &context, CreateFunctionInfo *info);
-	//! Append a scalar or aggregate function to the catalog
-	DUCKDB_API CatalogEntry *AddFunction(ClientContext &context, SchemaCatalogEntry *schema, CreateFunctionInfo *info);
-
-	//! Alter an existing entry in the catalog.
-	DUCKDB_API void Alter(ClientContext &context, AlterInfo *info);
-
-private:
-	//! The catalog version, incremented whenever anything changes in the catalog
-	atomic<idx_t> catalog_version;
-
-private:
-	//! A variation of GetEntry that returns an associated schema as well.
-	CatalogEntryLookup LookupEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
-	                               bool if_exists = false, QueryErrorContext error_context = QueryErrorContext());
-
-	//! Return an exception with did-you-mean suggestion.
-	CatalogException CreateMissingEntryException(ClientContext &context, const string &entry_name, CatalogType type,
-	                                             const vector<SchemaCatalogEntry *> &schemas,
-	                                             QueryErrorContext error_context);
-
-	//! Return the close entry name, the distance and the belonging schema.
-	SimilarCatalogEntry SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
-	                                          const vector<SchemaCatalogEntry *> &schemas);
-
-	void DropSchema(ClientContext &context, DropInfo *info);
-};
-
-template <>
-DUCKDB_API TableCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                                bool if_exists, QueryErrorContext error_context);
-template <>
-DUCKDB_API SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                   const string &name, bool if_exists, QueryErrorContext error_context);
-template <>
-DUCKDB_API TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                        const string &name, bool if_exists,
-                                                        QueryErrorContext error_context);
-template <>
-DUCKDB_API CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                       const string &name, bool if_exists,
-                                                       QueryErrorContext error_context);
-template <>
-DUCKDB_API PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                         const string &name, bool if_exists,
-                                                         QueryErrorContext error_context);
-template <>
-DUCKDB_API AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                            const string &name, bool if_exists,
-                                                            QueryErrorContext error_context);
-template <>
-DUCKDB_API CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                                  bool if_exists, QueryErrorContext error_context);
-template <>
-DUCKDB_API TypeCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                               bool if_exists, QueryErrorContext error_context);
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/logical_operator_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Logical Operator Types
-//===--------------------------------------------------------------------===//
-enum class LogicalOperatorType : uint8_t {
-	LOGICAL_INVALID = 0,
-	LOGICAL_PROJECTION = 1,
-	LOGICAL_FILTER = 2,
-	LOGICAL_AGGREGATE_AND_GROUP_BY = 3,
-	LOGICAL_WINDOW = 4,
-	LOGICAL_UNNEST = 5,
-	LOGICAL_LIMIT = 6,
-	LOGICAL_ORDER_BY = 7,
-	LOGICAL_TOP_N = 8,
-	LOGICAL_COPY_TO_FILE = 10,
-	LOGICAL_DISTINCT = 11,
-	LOGICAL_SAMPLE = 12,
-	LOGICAL_LIMIT_PERCENT = 13,
-
-	// -----------------------------
-	// Data sources
-	// -----------------------------
-	LOGICAL_GET = 25,
-	LOGICAL_CHUNK_GET = 26,
-	LOGICAL_DELIM_GET = 27,
-	LOGICAL_EXPRESSION_GET = 28,
-	LOGICAL_DUMMY_SCAN = 29,
-	LOGICAL_EMPTY_RESULT = 30,
-	LOGICAL_CTE_REF = 31,
-	// -----------------------------
-	// Joins
-	// -----------------------------
-	LOGICAL_JOIN = 50,
-	LOGICAL_DELIM_JOIN = 51,
-	LOGICAL_COMPARISON_JOIN = 52,
-	LOGICAL_ANY_JOIN = 53,
-	LOGICAL_CROSS_PRODUCT = 54,
-	// -----------------------------
-	// SetOps
-	// -----------------------------
-	LOGICAL_UNION = 75,
-	LOGICAL_EXCEPT = 76,
-	LOGICAL_INTERSECT = 77,
-	LOGICAL_RECURSIVE_CTE = 78,
-
-	// -----------------------------
-	// Updates
-	// -----------------------------
-	LOGICAL_INSERT = 100,
-	LOGICAL_DELETE = 101,
-	LOGICAL_UPDATE = 102,
-
-	// -----------------------------
-	// Schema
-	// -----------------------------
-	LOGICAL_ALTER = 125,
-	LOGICAL_CREATE_TABLE = 126,
-	LOGICAL_CREATE_INDEX = 127,
-	LOGICAL_CREATE_SEQUENCE = 128,
-	LOGICAL_CREATE_VIEW = 129,
-	LOGICAL_CREATE_SCHEMA = 130,
-	LOGICAL_CREATE_MACRO = 131,
-	LOGICAL_DROP = 132,
-	LOGICAL_PRAGMA = 133,
-	LOGICAL_TRANSACTION = 134,
-	LOGICAL_CREATE_TYPE = 135,
-
-	// -----------------------------
-	// Explain
-	// -----------------------------
-	LOGICAL_EXPLAIN = 150,
-
-	// -----------------------------
-	// Show
-	// -----------------------------
-	LOGICAL_SHOW = 160,
-
-	// -----------------------------
-	// Helpers
-	// -----------------------------
-	LOGICAL_PREPARE = 175,
-	LOGICAL_EXECUTE = 176,
-	LOGICAL_EXPORT = 177,
-	LOGICAL_VACUUM = 178,
-	LOGICAL_SET = 179,
-	LOGICAL_LOAD = 180
-};
-
-DUCKDB_API string LogicalOperatorToString(LogicalOperatorType type);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class BaseStatistics;
-
-//!  The Expression class represents a bound Expression with a return type
-class Expression : public BaseExpression {
-public:
-	Expression(ExpressionType type, ExpressionClass expression_class, LogicalType return_type);
-	~Expression() override;
-
-	//! The return type of the expression
-	LogicalType return_type;
-	//! Expression statistics (if any) - ONLY USED FOR VERIFICATION
-	unique_ptr<BaseStatistics> verification_stats;
-
-public:
-	bool IsAggregate() const override;
-	bool IsWindow() const override;
-	bool HasSubquery() const override;
-	bool IsScalar() const override;
-	bool HasParameter() const override;
-	virtual bool HasSideEffects() const;
-	virtual bool PropagatesNullValues() const;
-	virtual bool IsFoldable() const;
-
-	hash_t Hash() const override;
-
-	bool Equals(const BaseExpression *other) const override {
-		if (!BaseExpression::Equals(other)) {
-			return false;
-		}
-		return return_type == ((Expression *)other)->return_type;
-	}
-
-	static bool Equals(Expression *left, Expression *right) {
-		return BaseExpression::Equals((BaseExpression *)left, (BaseExpression *)right);
-	}
-	//! Create a copy of this expression
-	virtual unique_ptr<Expression> Copy() = 0;
-
-protected:
-	//! Copy base Expression properties from another expression to this one,
-	//! used in Copy method
-	void CopyProperties(Expression &other) {
-		type = other.type;
-		expression_class = other.expression_class;
-		alias = other.alias;
-		return_type = other.return_type;
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/logical_operator_visitor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_tokens.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Query Node
-//===--------------------------------------------------------------------===//
-class BoundQueryNode;
-class BoundSelectNode;
-class BoundSetOperationNode;
-class BoundRecursiveCTENode;
-
-//===--------------------------------------------------------------------===//
-// Expressions
-//===--------------------------------------------------------------------===//
-class Expression;
-
-class BoundAggregateExpression;
-class BoundBetweenExpression;
-class BoundCaseExpression;
-class BoundCastExpression;
-class BoundColumnRefExpression;
-class BoundComparisonExpression;
-class BoundConjunctionExpression;
-class BoundConstantExpression;
-class BoundDefaultExpression;
-class BoundFunctionExpression;
-class BoundOperatorExpression;
-class BoundParameterExpression;
-class BoundReferenceExpression;
-class BoundSubqueryExpression;
-class BoundUnnestExpression;
-class BoundWindowExpression;
-
-//===--------------------------------------------------------------------===//
-// TableRefs
-//===--------------------------------------------------------------------===//
-class BoundTableRef;
-
-class BoundBaseTableRef;
-class BoundCrossProductRef;
-class BoundJoinRef;
-class BoundSubqueryRef;
-class BoundTableFunction;
-class BoundEmptyTableRef;
-class BoundExpressionListRef;
-class BoundCTERef;
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/logical_tokens.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-namespace duckdb {
-
-class LogicalOperator;
-
-class LogicalAggregate;
-class LogicalAnyJoin;
-class LogicalChunkGet;
-class LogicalComparisonJoin;
-class LogicalCopyToFile;
-class LogicalCreate;
-class LogicalCreateTable;
-class LogicalCreateIndex;
-class LogicalCreateTable;
-class LogicalCrossProduct;
-class LogicalCTERef;
-class LogicalDelete;
-class LogicalDelimGet;
-class LogicalDelimJoin;
-class LogicalDistinct;
-class LogicalDummyScan;
-class LogicalEmptyResult;
-class LogicalExecute;
-class LogicalExplain;
-class LogicalExport;
-class LogicalExpressionGet;
-class LogicalFilter;
-class LogicalGet;
-class LogicalInsert;
-class LogicalJoin;
-class LogicalLimit;
-class LogicalOrder;
-class LogicalPragma;
-class LogicalPrepare;
-class LogicalProjection;
-class LogicalRecursiveCTE;
-class LogicalSetOperation;
-class LogicalSample;
-class LogicalShow;
-class LogicalSimple;
-class LogicalSet;
-class LogicalTopN;
-class LogicalUnnest;
-class LogicalUpdate;
-class LogicalWindow;
-
-} // namespace duckdb
-
-
-#include <functional>
-
-namespace duckdb {
-//! The LogicalOperatorVisitor is an abstract base class that implements the
-//! Visitor pattern on LogicalOperator.
-class LogicalOperatorVisitor {
-public:
-	virtual ~LogicalOperatorVisitor() {};
-
-	virtual void VisitOperator(LogicalOperator &op);
-	virtual void VisitExpression(unique_ptr<Expression> *expression);
-
-	static void EnumerateExpressions(LogicalOperator &op,
-	                                 const std::function<void(unique_ptr<Expression> *child)> &callback);
-
-protected:
-	//! Automatically calls the Visit method for LogicalOperator children of the current operator. Can be overloaded to
-	//! change this behavior.
-	void VisitOperatorChildren(LogicalOperator &op);
-	//! Automatically calls the Visit method for Expression children of the current operator. Can be overloaded to
-	//! change this behavior.
-	void VisitOperatorExpressions(LogicalOperator &op);
-
-	// The VisitExpressionChildren method is called at the end of every call to VisitExpression to recursively visit all
-	// expressions in an expression tree. It can be overloaded to prevent automatically visiting the entire tree.
-	virtual void VisitExpressionChildren(Expression &expression);
-
-	virtual unique_ptr<Expression> VisitReplace(BoundAggregateExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundBetweenExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundCaseExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundCastExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundComparisonExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundConjunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundConstantExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundDefaultExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundFunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundReferenceExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundParameterExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundWindowExpression &expr, unique_ptr<Expression> *expr_ptr);
-	virtual unique_ptr<Expression> VisitReplace(BoundUnnestExpression &expr, unique_ptr<Expression> *expr_ptr);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/column_binding.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-struct ColumnBinding {
-	idx_t table_index;
-	idx_t column_index;
-
-	ColumnBinding() : table_index(DConstants::INVALID_INDEX), column_index(DConstants::INVALID_INDEX) {
-	}
-	ColumnBinding(idx_t table, idx_t column) : table_index(table), column_index(column) {
-	}
-
-	bool operator==(const ColumnBinding &rhs) const {
-		return table_index == rhs.table_index && column_index == rhs.column_index;
-	}
-};
-
-} // namespace duckdb
-
-
-#include <functional>
-#include <algorithm>
-
-namespace duckdb {
-
-//! LogicalOperator is the base class of the logical operators present in the
-//! logical query tree
-class LogicalOperator {
-public:
-	explicit LogicalOperator(LogicalOperatorType type);
-	LogicalOperator(LogicalOperatorType type, vector<unique_ptr<Expression>> expressions);
-	virtual ~LogicalOperator();
-
-	//! The type of the logical operator
-	LogicalOperatorType type;
-	//! The set of children of the operator
-	vector<unique_ptr<LogicalOperator>> children;
-	//! The set of expressions contained within the operator, if any
-	vector<unique_ptr<Expression>> expressions;
-	//! The types returned by this logical operator. Set by calling LogicalOperator::ResolveTypes.
-	vector<LogicalType> types;
-	//! Estimated Cardinality
-	idx_t estimated_cardinality = 0;
-
-public:
-	virtual vector<ColumnBinding> GetColumnBindings();
-	static vector<ColumnBinding> GenerateColumnBindings(idx_t table_idx, idx_t column_count);
-	static vector<LogicalType> MapTypes(const vector<LogicalType> &types, const vector<idx_t> &projection_map);
-	static vector<ColumnBinding> MapBindings(const vector<ColumnBinding> &types, const vector<idx_t> &projection_map);
-
-	//! Resolve the types of the logical operator and its children
-	void ResolveOperatorTypes();
-
-	virtual string GetName() const;
-	virtual string ParamsToString() const;
-	virtual string ToString() const;
-	DUCKDB_API void Print();
-	//! Debug method: verify that the integrity of expressions & child nodes are maintained
-	virtual void Verify();
-
-	void AddChild(unique_ptr<LogicalOperator> child);
-
-	virtual idx_t EstimateCardinality(ClientContext &context);
-
-protected:
-	//! Resolve types for this specific operator
-	virtual void ResolveTypes() = 0;
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct BoundStatement {
-	unique_ptr<LogicalOperator> plan;
-	vector<LogicalType> types;
-	vector<string> names;
-};
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-//! A ResultModifier
-class BoundResultModifier {
-public:
-	explicit BoundResultModifier(ResultModifierType type);
-	virtual ~BoundResultModifier();
-
-	ResultModifierType type;
-};
-
-struct BoundOrderByNode {
-public:
-	BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression);
-	BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression,
-	                 unique_ptr<BaseStatistics> stats);
-
-	OrderType type;
-	OrderByNullType null_order;
-	unique_ptr<Expression> expression;
-	unique_ptr<BaseStatistics> stats;
-
-public:
-	BoundOrderByNode Copy() const;
-	string ToString() const;
-};
-
-class BoundLimitModifier : public BoundResultModifier {
-public:
-	BoundLimitModifier();
-
-	//! LIMIT
-	int64_t limit_val = NumericLimits<int64_t>::Maximum();
-	//! OFFSET
-	int64_t offset_val = 0;
-	//! Expression in case limit is not constant
-	unique_ptr<Expression> limit;
-	//! Expression in case limit is not constant
-	unique_ptr<Expression> offset;
-};
-
-class BoundOrderModifier : public BoundResultModifier {
-public:
-	BoundOrderModifier();
-
-	//! List of order nodes
-	vector<BoundOrderByNode> orders;
-};
-
-class BoundDistinctModifier : public BoundResultModifier {
-public:
-	BoundDistinctModifier();
-
-	//! list of distinct on targets (if any)
-	vector<unique_ptr<Expression>> target_distincts;
-};
-
-class BoundLimitPercentModifier : public BoundResultModifier {
-public:
-	BoundLimitPercentModifier();
-
-	//! LIMIT %
-	double limit_percent = 100.0;
-	//! OFFSET
-	int64_t offset_val = 0;
-	//! Expression in case limit is not constant
-	unique_ptr<Expression> limit;
-	//! Expression in case limit is not constant
-	unique_ptr<Expression> offset;
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/vector_operations/aggregate_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct AggregateInputData;
-
-typedef std::pair<idx_t, idx_t> FrameBounds;
-
-class AggregateExecutor {
-private:
-	template <class STATE_TYPE, class OP>
-	static inline void NullaryFlatLoop(STATE_TYPE **__restrict states, AggregateInputData &aggr_input_data,
-	                                   idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			OP::template Operation<STATE_TYPE, OP>(states[i], aggr_input_data, i);
-		}
-	}
-
-	template <class STATE_TYPE, class OP>
-	static inline void NullaryScatterLoop(STATE_TYPE **__restrict states, AggregateInputData &aggr_input_data,
-	                                      const SelectionVector &ssel, idx_t count) {
-
-		for (idx_t i = 0; i < count; i++) {
-			auto sidx = ssel.get_index(i);
-			OP::template Operation<STATE_TYPE, OP>(states[sidx], aggr_input_data, sidx);
-		}
-	}
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryFlatLoop(INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
-	                                 STATE_TYPE **__restrict states, ValidityMask &mask, idx_t count) {
-		if (!mask.AllValid()) {
-			idx_t base_idx = 0;
-			auto entry_count = ValidityMask::EntryCount(count);
-			for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-				auto validity_entry = mask.GetValidityEntry(entry_idx);
-				idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-				if (!OP::IgnoreNull() || ValidityMask::AllValid(validity_entry)) {
-					// all valid: perform operation
-					for (; base_idx < next; base_idx++) {
-						OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(states[base_idx], aggr_input_data, idata,
-						                                                   mask, base_idx);
-					}
-				} else if (ValidityMask::NoneValid(validity_entry)) {
-					// nothing valid: skip all
-					base_idx = next;
-					continue;
-				} else {
-					// partially valid: need to check individual elements for validity
-					idx_t start = base_idx;
-					for (; base_idx < next; base_idx++) {
-						if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-							OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(states[base_idx], aggr_input_data, idata,
-							                                                   mask, base_idx);
-						}
-					}
-				}
-			}
-		} else {
-			for (idx_t i = 0; i < count; i++) {
-				OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(states[i], aggr_input_data, idata, mask, i);
-			}
-		}
-	}
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryScatterLoop(INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
-	                                    STATE_TYPE **__restrict states, const SelectionVector &isel,
-	                                    const SelectionVector &ssel, ValidityMask &mask, idx_t count) {
-		if (OP::IgnoreNull() && !mask.AllValid()) {
-			// potential NULL values and NULL values are ignored
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = isel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				if (mask.RowIsValid(idx)) {
-					OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(states[sidx], aggr_input_data, idata, mask, idx);
-				}
-			}
-		} else {
-			// quick path: no NULL values or NULL values are not ignored
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = isel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(states[sidx], aggr_input_data, idata, mask, idx);
-			}
-		}
-	}
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryFlatUpdateLoop(INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
-	                                       STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask) {
-		idx_t base_idx = 0;
-		auto entry_count = ValidityMask::EntryCount(count);
-		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
-			auto validity_entry = mask.GetValidityEntry(entry_idx);
-			idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
-			if (!OP::IgnoreNull() || ValidityMask::AllValid(validity_entry)) {
-				// all valid: perform operation
-				for (; base_idx < next; base_idx++) {
-					OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(state, aggr_input_data, idata, mask, base_idx);
-				}
-			} else if (ValidityMask::NoneValid(validity_entry)) {
-				// nothing valid: skip all
-				base_idx = next;
-				continue;
-			} else {
-				// partially valid: need to check individual elements for validity
-				idx_t start = base_idx;
-				for (; base_idx < next; base_idx++) {
-					if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
-						OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(state, aggr_input_data, idata, mask,
-						                                                   base_idx);
-					}
-				}
-			}
-		}
-	}
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryUpdateLoop(INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
-	                                   STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask,
-	                                   const SelectionVector &__restrict sel_vector) {
-		if (OP::IgnoreNull() && !mask.AllValid()) {
-			// potential NULL values and NULL values are ignored
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel_vector.get_index(i);
-				if (mask.RowIsValid(idx)) {
-					OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(state, aggr_input_data, idata, mask, idx);
-				}
-			}
-		} else {
-			// quick path: no NULL values or NULL values are not ignored
-			for (idx_t i = 0; i < count; i++) {
-				auto idx = sel_vector.get_index(i);
-				OP::template Operation<INPUT_TYPE, STATE_TYPE, OP>(state, aggr_input_data, idata, mask, idx);
-			}
-		}
-	}
-
-	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static inline void BinaryScatterLoop(A_TYPE *__restrict adata, AggregateInputData &aggr_input_data,
-	                                     B_TYPE *__restrict bdata, STATE_TYPE **__restrict states, idx_t count,
-	                                     const SelectionVector &asel, const SelectionVector &bsel,
-	                                     const SelectionVector &ssel, ValidityMask &avalidity,
-	                                     ValidityMask &bvalidity) {
-		if (OP::IgnoreNull() && (!avalidity.AllValid() || !bvalidity.AllValid())) {
-			// potential NULL values and NULL values are ignored
-			for (idx_t i = 0; i < count; i++) {
-				auto aidx = asel.get_index(i);
-				auto bidx = bsel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				if (avalidity.RowIsValid(aidx) && bvalidity.RowIsValid(bidx)) {
-					OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(states[sidx], aggr_input_data, adata, bdata,
-					                                                       avalidity, bvalidity, aidx, bidx);
-				}
-			}
-		} else {
-			// quick path: no NULL values or NULL values are not ignored
-			for (idx_t i = 0; i < count; i++) {
-				auto aidx = asel.get_index(i);
-				auto bidx = bsel.get_index(i);
-				auto sidx = ssel.get_index(i);
-				OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(states[sidx], aggr_input_data, adata, bdata,
-				                                                       avalidity, bvalidity, aidx, bidx);
-			}
-		}
-	}
-
-	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static inline void BinaryUpdateLoop(A_TYPE *__restrict adata, AggregateInputData &aggr_input_data,
-	                                    B_TYPE *__restrict bdata, STATE_TYPE *__restrict state, idx_t count,
-	                                    const SelectionVector &asel, const SelectionVector &bsel,
-	                                    ValidityMask &avalidity, ValidityMask &bvalidity) {
-		if (OP::IgnoreNull() && (!avalidity.AllValid() || !bvalidity.AllValid())) {
-			// potential NULL values and NULL values are ignored
-			for (idx_t i = 0; i < count; i++) {
-				auto aidx = asel.get_index(i);
-				auto bidx = bsel.get_index(i);
-				if (avalidity.RowIsValid(aidx) && bvalidity.RowIsValid(bidx)) {
-					OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(state, aggr_input_data, adata, bdata,
-					                                                       avalidity, bvalidity, aidx, bidx);
-				}
-			}
-		} else {
-			// quick path: no NULL values or NULL values are not ignored
-			for (idx_t i = 0; i < count; i++) {
-				auto aidx = asel.get_index(i);
-				auto bidx = bsel.get_index(i);
-				OP::template Operation<A_TYPE, B_TYPE, STATE_TYPE, OP>(state, aggr_input_data, adata, bdata, avalidity,
-				                                                       bvalidity, aidx, bidx);
-			}
-		}
-	}
-
-public:
-	template <class STATE_TYPE, class OP>
-	static void NullaryScatter(Vector &states, AggregateInputData &aggr_input_data, idx_t count) {
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			OP::template ConstantOperation<STATE_TYPE, OP>(*sdata, aggr_input_data, count);
-		} else if (states.GetVectorType() == VectorType::FLAT_VECTOR) {
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			NullaryFlatLoop<STATE_TYPE, OP>(sdata, aggr_input_data, count);
-		} else {
-			VectorData sdata;
-			states.Orrify(count, sdata);
-			NullaryScatterLoop<STATE_TYPE, OP>((STATE_TYPE **)sdata.data, aggr_input_data, *sdata.sel, count);
-		}
-	}
-
-	template <class STATE_TYPE, class OP>
-	static void NullaryUpdate(data_ptr_t state, AggregateInputData &aggr_input_data, idx_t count) {
-		OP::template ConstantOperation<STATE_TYPE, OP>((STATE_TYPE *)state, aggr_input_data, count);
-	}
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static void UnaryScatter(Vector &input, Vector &states, AggregateInputData &aggr_input_data, idx_t count) {
-		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR &&
-		    states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			if (OP::IgnoreNull() && ConstantVector::IsNull(input)) {
-				// constant NULL input in function that ignores NULL values
-				return;
-			}
-			// regular constant: get first state
-			auto idata = ConstantVector::GetData<INPUT_TYPE>(input);
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			OP::template ConstantOperation<INPUT_TYPE, STATE_TYPE, OP>(*sdata, aggr_input_data, idata,
-			                                                           ConstantVector::Validity(input), count);
-		} else if (input.GetVectorType() == VectorType::FLAT_VECTOR &&
-		           states.GetVectorType() == VectorType::FLAT_VECTOR) {
-			auto idata = FlatVector::GetData<INPUT_TYPE>(input);
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			UnaryFlatLoop<STATE_TYPE, INPUT_TYPE, OP>(idata, aggr_input_data, sdata, FlatVector::Validity(input),
-			                                          count);
-		} else {
-			VectorData idata, sdata;
-			input.Orrify(count, idata);
-			states.Orrify(count, sdata);
-			UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP>((INPUT_TYPE *)idata.data, aggr_input_data,
-			                                             (STATE_TYPE **)sdata.data, *idata.sel, *sdata.sel,
-			                                             idata.validity, count);
-		}
-	}
-
-	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static void UnaryUpdate(Vector &input, AggregateInputData &aggr_input_data, data_ptr_t state, idx_t count) {
-		switch (input.GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR: {
-			if (OP::IgnoreNull() && ConstantVector::IsNull(input)) {
-				return;
-			}
-			auto idata = ConstantVector::GetData<INPUT_TYPE>(input);
-			OP::template ConstantOperation<INPUT_TYPE, STATE_TYPE, OP>((STATE_TYPE *)state, aggr_input_data, idata,
-			                                                           ConstantVector::Validity(input), count);
-			break;
-		}
-		case VectorType::FLAT_VECTOR: {
-			auto idata = FlatVector::GetData<INPUT_TYPE>(input);
-			UnaryFlatUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>(idata, aggr_input_data, (STATE_TYPE *)state, count,
-			                                                FlatVector::Validity(input));
-			break;
-		}
-		default: {
-			VectorData idata;
-			input.Orrify(count, idata);
-			UnaryUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>((INPUT_TYPE *)idata.data, aggr_input_data, (STATE_TYPE *)state,
-			                                            count, idata.validity, *idata.sel);
-			break;
-		}
-		}
-	}
-
-	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static void BinaryScatter(AggregateInputData &aggr_input_data, Vector &a, Vector &b, Vector &states, idx_t count) {
-		VectorData adata, bdata, sdata;
-
-		a.Orrify(count, adata);
-		b.Orrify(count, bdata);
-		states.Orrify(count, sdata);
-
-		BinaryScatterLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>((A_TYPE *)adata.data, aggr_input_data, (B_TYPE *)bdata.data,
-		                                                  (STATE_TYPE **)sdata.data, count, *adata.sel, *bdata.sel,
-		                                                  *sdata.sel, adata.validity, bdata.validity);
-	}
-
-	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static void BinaryUpdate(AggregateInputData &aggr_input_data, Vector &a, Vector &b, data_ptr_t state, idx_t count) {
-		VectorData adata, bdata;
-
-		a.Orrify(count, adata);
-		b.Orrify(count, bdata);
-
-		BinaryUpdateLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>((A_TYPE *)adata.data, aggr_input_data, (B_TYPE *)bdata.data,
-		                                                 (STATE_TYPE *)state, count, *adata.sel, *bdata.sel,
-		                                                 adata.validity, bdata.validity);
-	}
-
-	template <class STATE_TYPE, class OP>
-	static void Combine(Vector &source, Vector &target, AggregateInputData &aggr_input_data, idx_t count) {
-		D_ASSERT(source.GetType().id() == LogicalTypeId::POINTER && target.GetType().id() == LogicalTypeId::POINTER);
-		auto sdata = FlatVector::GetData<const STATE_TYPE *>(source);
-		auto tdata = FlatVector::GetData<STATE_TYPE *>(target);
-
-		for (idx_t i = 0; i < count; i++) {
-			OP::template Combine<STATE_TYPE, OP>(*sdata[i], tdata[i], aggr_input_data);
-		}
-	}
-
-	template <class STATE_TYPE, class RESULT_TYPE, class OP>
-	static void Finalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                     idx_t offset) {
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
-			OP::template Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, *sdata, rdata,
-			                                               ConstantVector::Validity(result), 0);
-		} else {
-			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-			for (idx_t i = 0; i < count; i++) {
-				OP::template Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata,
-				                                               FlatVector::Validity(result), i + offset);
-			}
-		}
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void UnaryWindow(Vector &input, const ValidityMask &ifilter, AggregateInputData &aggr_input_data,
-	                        data_ptr_t state, const FrameBounds &frame, const FrameBounds &prev, Vector &result,
-	                        idx_t rid, idx_t bias) {
-
-		auto idata = FlatVector::GetData<const INPUT_TYPE>(input) - bias;
-		const auto &ivalid = FlatVector::Validity(input);
-		OP::template Window<STATE, INPUT_TYPE, RESULT_TYPE>(idata, ifilter, ivalid, aggr_input_data, (STATE *)state,
-		                                                    frame, prev, result, rid, bias);
-	}
-
-	template <class STATE_TYPE, class OP>
-	static void Destroy(Vector &states, idx_t count) {
-		auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-		for (idx_t i = 0; i < count; i++) {
-			OP::template Destroy<STATE_TYPE>(sdata[i]);
-		}
-	}
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class BoundAggregateExpression;
-
-struct AggregateInputData {
-	AggregateInputData(FunctionData *bind_data_p) : bind_data(bind_data_p) {};
-	FunctionData *bind_data;
-};
-
-//! The type used for sizing hashed aggregate function states
-typedef idx_t (*aggregate_size_t)();
-//! The type used for initializing hashed aggregate function states
-typedef void (*aggregate_initialize_t)(data_ptr_t state);
-//! The type used for updating hashed aggregate functions
-typedef void (*aggregate_update_t)(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-                                   Vector &state, idx_t count);
-//! The type used for combining hashed aggregate states
-typedef void (*aggregate_combine_t)(Vector &state, Vector &combined, AggregateInputData &aggr_input_data, idx_t count);
-//! The type used for finalizing hashed aggregate function payloads
-typedef void (*aggregate_finalize_t)(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                                     idx_t offset);
-//! The type used for propagating statistics in aggregate functions (optional)
-typedef unique_ptr<BaseStatistics> (*aggregate_statistics_t)(ClientContext &context, BoundAggregateExpression &expr,
-                                                             FunctionData *bind_data,
-                                                             vector<unique_ptr<BaseStatistics>> &child_stats,
-                                                             NodeStatistics *node_stats);
-//! Binds the scalar function and creates the function data
-typedef unique_ptr<FunctionData> (*bind_aggregate_function_t)(ClientContext &context, AggregateFunction &function,
-                                                              vector<unique_ptr<Expression>> &arguments);
-//! The type used for the aggregate destructor method. NOTE: this method is used in destructors and MAY NOT throw.
-typedef void (*aggregate_destructor_t)(Vector &state, idx_t count);
-
-//! The type used for updating simple (non-grouped) aggregate functions
-typedef void (*aggregate_simple_update_t)(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-                                          data_ptr_t state, idx_t count);
-
-//! The type used for updating complex windowed aggregate functions (optional)
-typedef std::pair<idx_t, idx_t> FrameBounds;
-typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_mask,
-                                   AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-                                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid,
-                                   idx_t bias);
-
-class AggregateFunction : public BaseScalarFunction {
-public:
-	DUCKDB_API AggregateFunction(const string &name, const vector<LogicalType> &arguments,
-	                             const LogicalType &return_type, aggregate_size_t state_size,
-	                             aggregate_initialize_t initialize, aggregate_update_t update,
-	                             aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                             bool propagates_null_values = false, aggregate_simple_update_t simple_update = nullptr,
-	                             bind_aggregate_function_t bind = nullptr, aggregate_destructor_t destructor = nullptr,
-	                             aggregate_statistics_t statistics = nullptr, aggregate_window_t window = nullptr)
-	    : BaseScalarFunction(name, arguments, return_type, false, LogicalType(LogicalTypeId::INVALID),
-	                         propagates_null_values),
-	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
-	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics) {
-	}
-
-	DUCKDB_API AggregateFunction(const string &name, const vector<LogicalType> &arguments,
-	                             const LogicalType &return_type, aggregate_size_t state_size,
-	                             aggregate_initialize_t initialize, aggregate_update_t update,
-	                             aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                             aggregate_simple_update_t simple_update = nullptr,
-	                             bind_aggregate_function_t bind = nullptr, aggregate_destructor_t destructor = nullptr,
-	                             aggregate_statistics_t statistics = nullptr, aggregate_window_t window = nullptr)
-	    : BaseScalarFunction(name, arguments, return_type, false, LogicalType(LogicalTypeId::INVALID), false),
-	      state_size(state_size), initialize(initialize), update(update), combine(combine), finalize(finalize),
-	      simple_update(simple_update), window(window), bind(bind), destructor(destructor), statistics(statistics) {
-	}
-
-	DUCKDB_API AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type,
-	                             aggregate_size_t state_size, aggregate_initialize_t initialize,
-	                             aggregate_update_t update, aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                             bool propagates_null_values = false, aggregate_simple_update_t simple_update = nullptr,
-	                             bind_aggregate_function_t bind = nullptr, aggregate_destructor_t destructor = nullptr,
-	                             aggregate_statistics_t statistics = nullptr, aggregate_window_t window = nullptr)
-	    : AggregateFunction(string(), arguments, return_type, state_size, initialize, update, combine, finalize,
-	                        propagates_null_values, simple_update, bind, destructor, statistics, window) {
-	}
-
-	DUCKDB_API AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type,
-	                             aggregate_size_t state_size, aggregate_initialize_t initialize,
-	                             aggregate_update_t update, aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                             aggregate_simple_update_t simple_update = nullptr,
-	                             bind_aggregate_function_t bind = nullptr, aggregate_destructor_t destructor = nullptr,
-	                             aggregate_statistics_t statistics = nullptr, aggregate_window_t window = nullptr)
-	    : AggregateFunction(string(), arguments, return_type, state_size, initialize, update, combine, finalize, false,
-	                        simple_update, bind, destructor, statistics, window) {
-	}
-	//! The hashed aggregate state sizing function
-	aggregate_size_t state_size;
-	//! The hashed aggregate state initialization function
-	aggregate_initialize_t initialize;
-	//! The hashed aggregate update state function
-	aggregate_update_t update;
-	//! The hashed aggregate combine states function
-	aggregate_combine_t combine;
-	//! The hashed aggregate finalization function
-	aggregate_finalize_t finalize;
-	//! The simple aggregate update function (may be null)
-	aggregate_simple_update_t simple_update;
-	//! The windowed aggregate frame update function (may be null)
-	aggregate_window_t window;
-
-	//! The bind function (may be null)
-	bind_aggregate_function_t bind;
-	//! The destructor method (may be null)
-	aggregate_destructor_t destructor;
-
-	//! The statistics propagation function (may be null)
-	aggregate_statistics_t statistics;
-
-	DUCKDB_API bool operator==(const AggregateFunction &rhs) const {
-		return state_size == rhs.state_size && initialize == rhs.initialize && update == rhs.update &&
-		       combine == rhs.combine && finalize == rhs.finalize && window == rhs.window;
-	}
-	DUCKDB_API bool operator!=(const AggregateFunction &rhs) const {
-		return !(*this == rhs);
-	}
-
-	DUCKDB_API static unique_ptr<BoundAggregateExpression>
-	BindAggregateFunction(ClientContext &context, AggregateFunction bound_function,
-	                      vector<unique_ptr<Expression>> children, unique_ptr<Expression> filter = nullptr,
-	                      bool is_distinct = false, unique_ptr<BoundOrderModifier> order_bys = nullptr,
-	                      bool cast_parameters = true);
-
-	DUCKDB_API static unique_ptr<FunctionData> BindSortedAggregate(AggregateFunction &bound_function,
-	                                                               vector<unique_ptr<Expression>> &children,
-	                                                               unique_ptr<FunctionData> bind_info,
-	                                                               unique_ptr<BoundOrderModifier> order_bys);
-
-public:
-	template <class STATE, class RESULT_TYPE, class OP>
-	static AggregateFunction NullaryAggregate(LogicalType return_type) {
-		return AggregateFunction(
-		    {}, return_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
-		    AggregateFunction::NullaryScatterUpdate<STATE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-		    AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::NullaryUpdate<STATE, OP>);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static AggregateFunction UnaryAggregate(const LogicalType &input_type, LogicalType return_type,
-	                                        bool propagates_null_values = false) {
-		return AggregateFunction(
-		    {input_type}, return_type, AggregateFunction::StateSize<STATE>,
-		    AggregateFunction::StateInitialize<STATE, OP>, AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>,
-		    AggregateFunction::StateCombine<STATE, OP>, AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>,
-		    propagates_null_values, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static AggregateFunction UnaryAggregateDestructor(LogicalType input_type, LogicalType return_type) {
-		auto aggregate = UnaryAggregate<STATE, INPUT_TYPE, RESULT_TYPE, OP>(input_type, return_type);
-		aggregate.destructor = AggregateFunction::StateDestroy<STATE, OP>;
-		return aggregate;
-	}
-
-	template <class STATE, class A_TYPE, class B_TYPE, class RESULT_TYPE, class OP>
-	static AggregateFunction BinaryAggregate(const LogicalType &a_type, const LogicalType &b_type,
-	                                         LogicalType return_type) {
-		return AggregateFunction({a_type, b_type}, return_type, AggregateFunction::StateSize<STATE>,
-		                         AggregateFunction::StateInitialize<STATE, OP>,
-		                         AggregateFunction::BinaryScatterUpdate<STATE, A_TYPE, B_TYPE, OP>,
-		                         AggregateFunction::StateCombine<STATE, OP>,
-		                         AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>,
-		                         AggregateFunction::BinaryUpdate<STATE, A_TYPE, B_TYPE, OP>);
-	}
-
-public:
-	template <class STATE>
-	static idx_t StateSize() {
-		return sizeof(STATE);
-	}
-
-	template <class STATE, class OP>
-	static void StateInitialize(data_ptr_t state) {
-		OP::Initialize((STATE *)state);
-	}
-
-	template <class STATE, class OP>
-	static void NullaryScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-	                                 Vector &states, idx_t count) {
-		D_ASSERT(input_count == 0);
-		AggregateExecutor::NullaryScatter<STATE, OP>(states, aggr_input_data, count);
-	}
-
-	template <class STATE, class OP>
-	static void NullaryUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-	                          idx_t count) {
-		D_ASSERT(input_count == 0);
-		AggregateExecutor::NullaryUpdate<STATE, OP>(state, aggr_input_data, count);
-	}
-
-	template <class STATE, class T, class OP>
-	static void UnaryScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-	                               Vector &states, idx_t count) {
-		D_ASSERT(input_count == 1);
-		AggregateExecutor::UnaryScatter<STATE, T, OP>(inputs[0], states, aggr_input_data, count);
-	}
-
-	template <class STATE, class INPUT_TYPE, class OP>
-	static void UnaryUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-	                        idx_t count) {
-		D_ASSERT(input_count == 1);
-		AggregateExecutor::UnaryUpdate<STATE, INPUT_TYPE, OP>(inputs[0], aggr_input_data, state, count);
-	}
-
-	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
-	static void UnaryWindow(Vector inputs[], const ValidityMask &filter_mask, AggregateInputData &aggr_input_data,
-	                        idx_t input_count, data_ptr_t state, const FrameBounds &frame, const FrameBounds &prev,
-	                        Vector &result, idx_t rid, idx_t bias) {
-		D_ASSERT(input_count == 1);
-		AggregateExecutor::UnaryWindow<STATE, INPUT_TYPE, RESULT_TYPE, OP>(inputs[0], filter_mask, aggr_input_data,
-		                                                                   state, frame, prev, result, rid, bias);
-	}
-
-	template <class STATE, class A_TYPE, class B_TYPE, class OP>
-	static void BinaryScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
-	                                Vector &states, idx_t count) {
-		D_ASSERT(input_count == 2);
-		AggregateExecutor::BinaryScatter<STATE, A_TYPE, B_TYPE, OP>(aggr_input_data, inputs[0], inputs[1], states,
-		                                                            count);
-	}
-
-	template <class STATE, class A_TYPE, class B_TYPE, class OP>
-	static void BinaryUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
-	                         idx_t count) {
-		D_ASSERT(input_count == 2);
-		AggregateExecutor::BinaryUpdate<STATE, A_TYPE, B_TYPE, OP>(aggr_input_data, inputs[0], inputs[1], state, count);
-	}
-
-	template <class STATE, class OP>
-	static void StateCombine(Vector &source, Vector &target, AggregateInputData &aggr_input_data, idx_t count) {
-		AggregateExecutor::Combine<STATE, OP>(source, target, aggr_input_data, count);
-	}
-
-	template <class STATE, class RESULT_TYPE, class OP>
-	static void StateFinalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                          idx_t offset) {
-		AggregateExecutor::Finalize<STATE, RESULT_TYPE, OP>(states, aggr_input_data, result, count, offset);
-	}
-
-	template <class STATE, class OP>
-	static void StateDestroy(Vector &states, idx_t count) {
-		AggregateExecutor::Destroy<STATE, OP>(states, count);
-	}
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct UDFWrapper {
-public:
-	template <typename TR, typename... Args>
-	static scalar_function_t CreateScalarFunction(const string &name, TR (*udf_func)(Args...)) {
-		const std::size_t num_template_argc = sizeof...(Args);
-		switch (num_template_argc) {
-		case 1:
-			return CreateUnaryFunction<TR, Args...>(name, udf_func);
-		case 2:
-			return CreateBinaryFunction<TR, Args...>(name, udf_func);
-		case 3:
-			return CreateTernaryFunction<TR, Args...>(name, udf_func);
-		default: // LCOV_EXCL_START
-			throw std::runtime_error("UDF function only supported until ternary!");
-		} // LCOV_EXCL_STOP
-	}
-
-	template <typename TR, typename... Args>
-	static scalar_function_t CreateScalarFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                              TR (*udf_func)(Args...)) {
-		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
-			throw std::runtime_error("Return type doesn't match with the first template type.");
-		} // LCOV_EXCL_STOP
-
-		const std::size_t num_template_types = sizeof...(Args);
-		if (num_template_types != args.size()) { // LCOV_EXCL_START
-			throw std::runtime_error(
-			    "The number of templated types should be the same quantity of the LogicalType arguments.");
-		} // LCOV_EXCL_STOP
-
-		switch (num_template_types) {
-		case 1:
-			return CreateUnaryFunction<TR, Args...>(name, args, ret_type, udf_func);
-		case 2:
-			return CreateBinaryFunction<TR, Args...>(name, args, ret_type, udf_func);
-		case 3:
-			return CreateTernaryFunction<TR, Args...>(name, args, ret_type, udf_func);
-		default: // LCOV_EXCL_START
-			throw std::runtime_error("UDF function only supported until ternary!");
-		} // LCOV_EXCL_STOP
-	}
-
-	template <typename TR, typename... Args>
-	static void RegisterFunction(const string &name, scalar_function_t udf_function, ClientContext &context,
-	                             LogicalType varargs = LogicalType(LogicalTypeId::INVALID)) {
-		vector<LogicalType> arguments;
-		GetArgumentTypesRecursive<Args...>(arguments);
-
-		LogicalType ret_type = GetArgumentType<TR>();
-
-		RegisterFunction(name, arguments, ret_type, udf_function, context, varargs);
-	}
-
-	DUCKDB_API static void RegisterFunction(string name, vector<LogicalType> args, LogicalType ret_type,
-	                                        scalar_function_t udf_function, ClientContext &context,
-	                                        LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
-
-	//--------------------------------- Aggregate UDFs ------------------------------------//
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	static AggregateFunction CreateAggregateFunction(const string &name) {
-		return CreateUnaryAggregateFunction<UDF_OP, STATE, TR, TA>(name);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	static AggregateFunction CreateAggregateFunction(const string &name) {
-		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	static AggregateFunction CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_type) {
-		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
-			throw std::runtime_error("The return argument don't match!");
-		} // LCOV_EXCL_STOP
-
-		if (!TypesMatch<TA>(input_type)) { // LCOV_EXCL_START
-			throw std::runtime_error("The input argument don't match!");
-		} // LCOV_EXCL_STOP
-
-		return CreateUnaryAggregateFunction<UDF_OP, STATE, TR, TA>(name, ret_type, input_type);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	static AggregateFunction CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_typeA,
-	                                                 LogicalType input_typeB) {
-		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
-			throw std::runtime_error("The return argument don't match!");
-		}
-
-		if (!TypesMatch<TA>(input_typeA)) {
-			throw std::runtime_error("The first input argument don't match!");
-		}
-
-		if (!TypesMatch<TB>(input_typeB)) {
-			throw std::runtime_error("The second input argument don't match!");
-		} // LCOV_EXCL_STOP
-
-		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, ret_type, input_typeA, input_typeB);
-	}
-
-	//! A generic CreateAggregateFunction ---------------------------------------------------------------------------//
-	static AggregateFunction CreateAggregateFunction(string name, vector<LogicalType> arguments,
-	                                                 LogicalType return_type, aggregate_size_t state_size,
-	                                                 aggregate_initialize_t initialize, aggregate_update_t update,
-	                                                 aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                                                 aggregate_simple_update_t simple_update = nullptr,
-	                                                 bind_aggregate_function_t bind = nullptr,
-	                                                 aggregate_destructor_t destructor = nullptr) {
-
-		AggregateFunction aggr_function(std::move(name), std::move(arguments), std::move(return_type), state_size, initialize, update,
-		                                combine, finalize, simple_update, bind, destructor);
-		return aggr_function;
-	}
-
-	DUCKDB_API static void RegisterAggrFunction(AggregateFunction aggr_function, ClientContext &context,
-	                                            LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
-
-private:
-	//-------------------------------- Templated functions --------------------------------//
-	struct UnaryUDFExecutor {
-		template <class INPUT_TYPE, class RESULT_TYPE>
-		static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-			typedef RESULT_TYPE (*unary_function_t)(INPUT_TYPE);
-			auto udf = (unary_function_t)dataptr;
-			return udf(input);
-		}
-	};
-
-	template <typename TR, typename TA>
-	static scalar_function_t CreateUnaryFunction(const string &name, TR (*udf_func)(TA)) {
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			UnaryExecutor::GenericExecute<TA, TR, UnaryUDFExecutor>(input.data[0], result, input.size(),
-			                                                        (void *)udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename TA, typename TB>
-	static scalar_function_t CreateBinaryFunction(const string &name, TR (*udf_func)(TA, TB)) {
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			BinaryExecutor::Execute<TA, TB, TR>(input.data[0], input.data[1], result, input.size(), udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename TA, typename TB, typename TC>
-	static scalar_function_t CreateTernaryFunction(const string &name, TR (*udf_func)(TA, TB, TC)) {
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			TernaryExecutor::Execute<TA, TB, TC, TR>(input.data[0], input.data[1], input.data[2], result, input.size(),
-			                                         udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename... Args>
-	static scalar_function_t CreateUnaryFunction(const string &name, TR (*udf_func)(Args...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for unary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename... Args>
-	static scalar_function_t CreateBinaryFunction(const string &name, TR (*udf_func)(Args...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for binary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename... Args>
-	static scalar_function_t CreateTernaryFunction(const string &name, TR (*udf_func)(Args...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for ternary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename T>
-	static LogicalType GetArgumentType() {
-		if (std::is_same<T, bool>()) {
-			return LogicalType(LogicalTypeId::BOOLEAN);
-		} else if (std::is_same<T, int8_t>()) {
-			return LogicalType(LogicalTypeId::TINYINT);
-		} else if (std::is_same<T, int16_t>()) {
-			return LogicalType(LogicalTypeId::SMALLINT);
-		} else if (std::is_same<T, int32_t>()) {
-			return LogicalType(LogicalTypeId::INTEGER);
-		} else if (std::is_same<T, int64_t>()) {
-			return LogicalType(LogicalTypeId::BIGINT);
-		} else if (std::is_same<T, float>()) {
-			return LogicalType(LogicalTypeId::FLOAT);
-		} else if (std::is_same<T, double>()) {
-			return LogicalType(LogicalTypeId::DOUBLE);
-		} else if (std::is_same<T, string_t>()) {
-			return LogicalType(LogicalTypeId::VARCHAR);
-		} else { // LCOV_EXCL_START
-			throw std::runtime_error("Unrecognized type!");
-		} // LCOV_EXCL_STOP
-	}
-
-	template <typename TA, typename TB, typename... Args>
-	static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
-		arguments.push_back(GetArgumentType<TA>());
-		GetArgumentTypesRecursive<TB, Args...>(arguments);
-	}
-
-	template <typename TA>
-	static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
-		arguments.push_back(GetArgumentType<TA>());
-	}
-
-private:
-	//-------------------------------- Argumented functions --------------------------------//
-
-	template <typename TR, typename... Args>
-	static scalar_function_t CreateUnaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                             TR (*udf_func)(Args...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for unary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename TA>
-	static scalar_function_t CreateUnaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                             TR (*udf_func)(TA)) {
-		if (args.size() != 1) { // LCOV_EXCL_START
-			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 1!");
-		}
-		if (!TypesMatch<TA>(args[0])) {
-			throw std::runtime_error("The first arguments don't match!");
-		} // LCOV_EXCL_STOP
-
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			UnaryExecutor::GenericExecute<TA, TR, UnaryUDFExecutor>(input.data[0], result, input.size(),
-			                                                        (void *)udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename... Args>
-	static scalar_function_t CreateBinaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                              TR (*udf_func)(Args...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for binary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename TA, typename TB>
-	static scalar_function_t CreateBinaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                              TR (*udf_func)(TA, TB)) {
-		if (args.size() != 2) { // LCOV_EXCL_START
-			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 2!");
-		}
-		if (!TypesMatch<TA>(args[0])) {
-			throw std::runtime_error("The first arguments don't match!");
-		}
-		if (!TypesMatch<TB>(args[1])) {
-			throw std::runtime_error("The second arguments don't match!");
-		} // LCOV_EXCL_STOP
-
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) {
-			BinaryExecutor::Execute<TA, TB, TR>(input.data[0], input.data[1], result, input.size(), udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename TR, typename... Args>
-	static scalar_function_t CreateTernaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                               TR (*udf_func)(Args...)) { // LCOV_EXCL_START
-		throw std::runtime_error("Incorrect number of arguments for ternary function");
-	} // LCOV_EXCL_STOP
-
-	template <typename TR, typename TA, typename TB, typename TC>
-	static scalar_function_t CreateTernaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                               TR (*udf_func)(TA, TB, TC)) {
-		if (args.size() != 3) { // LCOV_EXCL_START
-			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 3!");
-		}
-		if (!TypesMatch<TA>(args[0])) {
-			throw std::runtime_error("The first arguments don't match!");
-		}
-		if (!TypesMatch<TB>(args[1])) {
-			throw std::runtime_error("The second arguments don't match!");
-		}
-		if (!TypesMatch<TC>(args[2])) {
-			throw std::runtime_error("The second arguments don't match!");
-		} // LCOV_EXCL_STOP
-
-		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
-			TernaryExecutor::Execute<TA, TB, TC, TR>(input.data[0], input.data[1], input.data[2], result, input.size(),
-			                                         udf_func);
-		};
-		return udf_function;
-	}
-
-	template <typename T>
-	static bool TypesMatch(const LogicalType &sql_type) {
-		switch (sql_type.id()) {
-		case LogicalTypeId::BOOLEAN:
-			return std::is_same<T, bool>();
-		case LogicalTypeId::TINYINT:
-			return std::is_same<T, int8_t>();
-		case LogicalTypeId::SMALLINT:
-			return std::is_same<T, int16_t>();
-		case LogicalTypeId::INTEGER:
-			return std::is_same<T, int32_t>();
-		case LogicalTypeId::BIGINT:
-			return std::is_same<T, int64_t>();
-		case LogicalTypeId::DATE:
-			return std::is_same<T, date_t>();
-		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIME_TZ:
-			return std::is_same<T, dtime_t>();
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			return std::is_same<T, timestamp_t>();
-		case LogicalTypeId::FLOAT:
-			return std::is_same<T, float>();
-		case LogicalTypeId::DOUBLE:
-			return std::is_same<T, double>();
-		case LogicalTypeId::VARCHAR:
-		case LogicalTypeId::CHAR:
-		case LogicalTypeId::BLOB:
-			return std::is_same<T, string_t>();
-		default: // LCOV_EXCL_START
-			throw std::runtime_error("Type is not supported!");
-		} // LCOV_EXCL_STOP
-	}
-
-private:
-	//-------------------------------- Aggregate functions --------------------------------//
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	static AggregateFunction CreateUnaryAggregateFunction(const string &name) {
-		LogicalType return_type = GetArgumentType<TR>();
-		LogicalType input_type = GetArgumentType<TA>();
-		return CreateUnaryAggregateFunction<UDF_OP, STATE, TR, TA>(name, return_type, input_type);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	static AggregateFunction CreateUnaryAggregateFunction(const string &name, LogicalType ret_type,
-	                                                      LogicalType input_type) {
-		AggregateFunction aggr_function =
-		    AggregateFunction::UnaryAggregate<STATE, TR, TA, UDF_OP>(input_type, ret_type);
-		aggr_function.name = name;
-		return aggr_function;
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	static AggregateFunction CreateBinaryAggregateFunction(const string &name) {
-		LogicalType return_type = GetArgumentType<TR>();
-		LogicalType input_typeA = GetArgumentType<TA>();
-		LogicalType input_typeB = GetArgumentType<TB>();
-		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, return_type, input_typeA, input_typeB);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	static AggregateFunction CreateBinaryAggregateFunction(const string &name, LogicalType ret_type,
-	                                                       LogicalType input_typeA, LogicalType input_typeB) {
-		AggregateFunction aggr_function =
-		    AggregateFunction::BinaryAggregate<STATE, TR, TA, TB, UDF_OP>(input_typeA, input_typeB, ret_type);
-		aggr_function.name = name;
-		return aggr_function;
-	}
-}; // end UDFWrapper
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/materialized_query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/chunk_collection.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Allocator;
-class ClientContext;
-
-//!  A ChunkCollection represents a set of DataChunks that all have the same
-//!  types
-/*!
-    A ChunkCollection represents a set of DataChunks concatenated together in a
-   list. Individual values of the collection can be iterated over using the
-   iterator. It is also possible to iterate directly over the chunks for more
-   direct access.
-*/
-class ChunkCollection {
-public:
-	ChunkCollection(Allocator &allocator);
-	ChunkCollection(ClientContext &context);
-
-	//! The amount of columns in the ChunkCollection
-	DUCKDB_API vector<LogicalType> &Types() {
-		return types;
-	}
-	const vector<LogicalType> &Types() const {
-		return types;
-	}
-
-	//! The amount of rows in the ChunkCollection
-	DUCKDB_API const idx_t &Count() const {
-		return count;
-	}
-
-	//! The amount of columns in the ChunkCollection
-	DUCKDB_API idx_t ColumnCount() const {
-		return types.size();
-	}
-
-	//! Append a new DataChunk directly to this ChunkCollection
-	DUCKDB_API void Append(DataChunk &new_chunk);
-
-	//! Append a new DataChunk directly to this ChunkCollection
-	DUCKDB_API void Append(unique_ptr<DataChunk> new_chunk);
-
-	//! Append another ChunkCollection directly to this ChunkCollection
-	DUCKDB_API void Append(ChunkCollection &other);
-
-	//! Merge is like Append but messes up the order and destroys the other collection
-	DUCKDB_API void Merge(ChunkCollection &other);
-
-	//! Fuse adds new columns to the right of the collection
-	DUCKDB_API void Fuse(ChunkCollection &other);
-
-	DUCKDB_API void Verify();
-
-	//! Gets the value of the column at the specified index
-	DUCKDB_API Value GetValue(idx_t column, idx_t index);
-	//! Sets the value of the column at the specified index
-	DUCKDB_API void SetValue(idx_t column, idx_t index, const Value &value);
-
-	//! Copy a single cell to a target vector
-	DUCKDB_API void CopyCell(idx_t column, idx_t index, Vector &target, idx_t target_offset);
-
-	DUCKDB_API string ToString() const;
-	DUCKDB_API void Print() const;
-
-	//! Gets a reference to the chunk at the given index
-	DUCKDB_API DataChunk &GetChunkForRow(idx_t row_index) {
-		return *chunks[LocateChunk(row_index)];
-	}
-
-	//! Gets a reference to the chunk at the given index
-	DUCKDB_API DataChunk &GetChunk(idx_t chunk_index) {
-		D_ASSERT(chunk_index < chunks.size());
-		return *chunks[chunk_index];
-	}
-	const DataChunk &GetChunk(idx_t chunk_index) const {
-		D_ASSERT(chunk_index < chunks.size());
-		return *chunks[chunk_index];
-	}
-
-	DUCKDB_API const vector<unique_ptr<DataChunk>> &Chunks() {
-		return chunks;
-	}
-
-	DUCKDB_API idx_t ChunkCount() const {
-		return chunks.size();
-	}
-
-	DUCKDB_API void Reset() {
-		count = 0;
-		chunks.clear();
-		types.clear();
-	}
-
-	DUCKDB_API unique_ptr<DataChunk> Fetch() {
-		if (ChunkCount() == 0) {
-			return nullptr;
-		}
-
-		auto res = std::move(chunks[0]);
-		chunks.erase(chunks.begin() + 0);
-		return res;
-	}
-
-	DUCKDB_API void Sort(vector<OrderType> &desc, vector<OrderByNullType> &null_order, idx_t result[]);
-	//! Reorders the rows in the collection according to the given indices.
-	DUCKDB_API void Reorder(idx_t order[]);
-
-	//! Returns true if the ChunkCollections are equivalent
-	DUCKDB_API bool Equals(ChunkCollection &other);
-
-	//! Locates the chunk that belongs to the specific index
-	DUCKDB_API idx_t LocateChunk(idx_t index) {
-		idx_t result = index / STANDARD_VECTOR_SIZE;
-		D_ASSERT(result < chunks.size());
-		return result;
-	}
-
-	Allocator &GetAllocator() {
-		return allocator;
-	}
-
-private:
-	Allocator &allocator;
-	//! The total amount of elements in the collection
-	idx_t count;
-	//! The set of data chunks in the collection
-	vector<unique_ptr<DataChunk>> chunks;
-	//! The types of the ChunkCollection
-	vector<LogicalType> types;
-};
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/statement_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Statement Types
-//===--------------------------------------------------------------------===//
-enum class StatementType : uint8_t {
-	INVALID_STATEMENT,      // invalid statement type
-	SELECT_STATEMENT,       // select statement type
-	INSERT_STATEMENT,       // insert statement type
-	UPDATE_STATEMENT,       // update statement type
-	CREATE_STATEMENT,       // create statement type
-	DELETE_STATEMENT,       // delete statement type
-	PREPARE_STATEMENT,      // prepare statement type
-	EXECUTE_STATEMENT,      // execute statement type
-	ALTER_STATEMENT,        // alter statement type
-	TRANSACTION_STATEMENT,  // transaction statement type,
-	COPY_STATEMENT,         // copy type
-	ANALYZE_STATEMENT,      // analyze type
-	VARIABLE_SET_STATEMENT, // variable set statement type
-	CREATE_FUNC_STATEMENT,  // create func statement type
-	EXPLAIN_STATEMENT,      // explain statement type
-	DROP_STATEMENT,         // DROP statement type
-	EXPORT_STATEMENT,       // EXPORT statement type
-	PRAGMA_STATEMENT,       // PRAGMA statement type
-	SHOW_STATEMENT,         // SHOW statement type
-	VACUUM_STATEMENT,       // VACUUM statement type
-	CALL_STATEMENT,         // CALL statement type
-	SET_STATEMENT,          // SET statement type
-	LOAD_STATEMENT,         // LOAD statement type
-	RELATION_STATEMENT,
-	EXTENSION_STATEMENT
-};
-
-string StatementTypeToString(StatementType type);
-
-enum class StatementReturnType : uint8_t {
-	QUERY_RESULT, // the statement returns a query result (e.g. for display to the user)
-	CHANGED_ROWS, // the statement returns a single row containing the number of changed rows (e.g. an insert stmt)
-	NOTHING       // the statement returns nothing
-};
-
-string StatementReturnTypeToString(StatementReturnType type);
-
-//! A struct containing various properties of a SQL statement
-struct StatementProperties {
-	StatementProperties()
-	    : read_only(true), requires_valid_transaction(true), allow_stream_result(false), bound_all_parameters(true),
-	      return_type(StatementReturnType::QUERY_RESULT), parameter_count(0) {
-	}
-
-	//! Whether or not the statement is a read-only statement, or whether it can result in changes to the database
-	bool read_only;
-	//! Whether or not the statement requires a valid transaction. Almost all statements require this, with the
-	//! exception of
-	bool requires_valid_transaction;
-	//! Whether or not the result can be streamed to the client
-	bool allow_stream_result;
-	//! Whether or not all parameters have successfully had their types determined
-	bool bound_all_parameters;
-	//! What type of data the statement returns
-	StatementReturnType return_type;
-	//! The number of prepared statement parameters
-	idx_t parameter_count;
-};
-
-} // namespace duckdb
-
-
-
-
-struct ArrowSchema;
-
-namespace duckdb {
-
-enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDING_RESULT };
-
-class BaseQueryResult {
-public:
-	//! Creates a successful query result with the specified names and types
-	DUCKDB_API BaseQueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
-	                           vector<LogicalType> types, vector<string> names);
-	//! Creates an unsuccessful query result with error condition
-	DUCKDB_API BaseQueryResult(QueryResultType type, string error);
-	DUCKDB_API virtual ~BaseQueryResult();
-
-	//! The type of the result (MATERIALIZED or STREAMING)
-	QueryResultType type;
-	//! The type of the statement that created this result
-	StatementType statement_type;
-	//! Properties of the statement
-	StatementProperties properties;
-	//! The SQL types of the result
-	vector<LogicalType> types;
-	//! The names of the result
-	vector<string> names;
-	//! Whether or not execution was successful
-	bool success;
-	//! The error string (in case execution was not successful)
-	string error;
-
-public:
-	DUCKDB_API bool HasError();
-	DUCKDB_API const string &GetError();
-	DUCKDB_API idx_t ColumnCount();
-};
-
-//! The QueryResult object holds the result of a query. It can either be a MaterializedQueryResult, in which case the
-//! result contains the entire result set, or a StreamQueryResult in which case the Fetch method can be called to
-//! incrementally fetch data from the database.
-class QueryResult : public BaseQueryResult {
-public:
-	//! Creates a successful query result with the specified names and types
-	DUCKDB_API QueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
-	                       vector<LogicalType> types, vector<string> names);
-	//! Creates an unsuccessful query result with error condition
-	DUCKDB_API QueryResult(QueryResultType type, string error);
-	DUCKDB_API virtual ~QueryResult() override;
-
-	//! The next result (if any)
-	unique_ptr<QueryResult> next;
-
-public:
-	//! Fetches a DataChunk of normalized (flat) vectors from the query result.
-	//! Returns nullptr if there are no more results to fetch.
-	DUCKDB_API virtual unique_ptr<DataChunk> Fetch();
-	//! Fetches a DataChunk from the query result. The vectors are not normalized and hence any vector types can be
-	//! returned.
-	DUCKDB_API virtual unique_ptr<DataChunk> FetchRaw() = 0;
-	//! Converts the QueryResult to a string
-	DUCKDB_API virtual string ToString() = 0;
-	//! Prints the QueryResult to the console
-	DUCKDB_API void Print();
-	//! Returns true if the two results are identical; false otherwise. Note that this method is destructive; it calls
-	//! Fetch() until both results are exhausted. The data in the results will be lost.
-	DUCKDB_API bool Equals(QueryResult &other);
-
-	DUCKDB_API bool TryFetch(unique_ptr<DataChunk> &result, string &error) {
-		try {
-			result = Fetch();
-			return success;
-		} catch (std::exception &ex) {
-			error = ex.what();
-			return false;
-		} catch (...) {
-			error = "Unknown error in Fetch";
-			return false;
-		}
-	}
-
-	DUCKDB_API static void ToArrowSchema(ArrowSchema *out_schema, vector<LogicalType> &types, vector<string> &names,
-	                                     string &config_timezone);
-
-	static string GetConfigTimezone(QueryResult &query_result);
-
-private:
-	//! The current chunk used by the iterator
-	unique_ptr<DataChunk> iterator_chunk;
-
-private:
-	class QueryResultIterator;
-	class QueryResultRow {
-	public:
-		explicit QueryResultRow(QueryResultIterator &iterator) : iterator(iterator), row(0) {
-		}
-
-		QueryResultIterator &iterator;
-		idx_t row;
-
-		template <class T>
-		T GetValue(idx_t col_idx) const {
-			return iterator.result->iterator_chunk->GetValue(col_idx, iterator.row_idx).GetValue<T>();
-		}
-	};
-	//! The row-based query result iterator. Invoking the
-	class QueryResultIterator {
-	public:
-		explicit QueryResultIterator(QueryResult *result) : current_row(*this), result(result), row_idx(0) {
-			if (result) {
-				result->iterator_chunk = result->Fetch();
-			}
-		}
-
-		QueryResultRow current_row;
-		QueryResult *result;
-		idx_t row_idx;
-
-	public:
-		void Next() {
-			if (!result->iterator_chunk) {
-				return;
-			}
-			current_row.row++;
-			row_idx++;
-			if (row_idx >= result->iterator_chunk->size()) {
-				result->iterator_chunk = result->Fetch();
-				row_idx = 0;
-			}
-		}
-
-		QueryResultIterator &operator++() {
-			Next();
-			return *this;
-		}
-		bool operator!=(const QueryResultIterator &other) const {
-			return result->iterator_chunk && result->iterator_chunk->ColumnCount() > 0;
-		}
-		const QueryResultRow &operator*() const {
-			return current_row;
-		}
-	};
-
-public:
-	DUCKDB_API QueryResultIterator begin() {
-		return QueryResultIterator(this);
-	}
-	DUCKDB_API QueryResultIterator end() {
-		return QueryResultIterator(nullptr);
-	}
-
-protected:
-	DUCKDB_API string HeaderToString();
-
-private:
-	QueryResult(const QueryResult &) = delete;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class ClientContext;
-
-class MaterializedQueryResult : public QueryResult {
-public:
-	friend class ClientContext;
-	//! Creates a successful query result with the specified names and types
-	DUCKDB_API MaterializedQueryResult(StatementType statement_type, StatementProperties properties,
-	                                   vector<LogicalType> types, vector<string> names,
-	                                   const shared_ptr<ClientContext> &context);
-	//! Creates an unsuccessful query result with error condition
-	DUCKDB_API explicit MaterializedQueryResult(string error);
-
-	ChunkCollection collection;
-
-	//! The client context this MaterializedQueryResult belongs to
-	std::weak_ptr<ClientContext> context;
-
-public:
-	//! Fetches a DataChunk from the query result.
-	//! This will consume the result (i.e. the chunks are taken directly from the ChunkCollection).
-	DUCKDB_API unique_ptr<DataChunk> Fetch() override;
-	DUCKDB_API unique_ptr<DataChunk> FetchRaw() override;
-	//! Converts the QueryResult to a string
-	DUCKDB_API string ToString() override;
-
-	//! Gets the (index) value of the (column index) column
-	DUCKDB_API Value GetValue(idx_t column, idx_t index);
-
-	template <class T>
-	T GetValue(idx_t column, idx_t index) {
-		auto value = GetValue(column, index);
-		return (T)value.GetValue<int64_t>();
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/pending_query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/pending_execution_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class PendingExecutionResult : uint8_t { RESULT_READY, RESULT_NOT_READY, EXECUTION_ERROR };
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/physical_operator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/physical_operator_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Physical Operator Types
-//===--------------------------------------------------------------------===//
-enum class PhysicalOperatorType : uint8_t {
-	INVALID,
-	ORDER_BY,
-	LIMIT,
-	STREAMING_LIMIT,
-	LIMIT_PERCENT,
-	TOP_N,
-	WINDOW,
-	UNNEST,
-	SIMPLE_AGGREGATE,
-	HASH_GROUP_BY,
-	PERFECT_HASH_GROUP_BY,
-	FILTER,
-	PROJECTION,
-	COPY_TO_FILE,
-	RESERVOIR_SAMPLE,
-	STREAMING_SAMPLE,
-	STREAMING_WINDOW,
-	// -----------------------------
-	// Scans
-	// -----------------------------
-	TABLE_SCAN,
-	DUMMY_SCAN,
-	CHUNK_SCAN,
-	RECURSIVE_CTE_SCAN,
-	DELIM_SCAN,
-	EXPRESSION_SCAN,
-	// -----------------------------
-	// Joins
-	// -----------------------------
-	BLOCKWISE_NL_JOIN,
-	NESTED_LOOP_JOIN,
-	HASH_JOIN,
-	CROSS_PRODUCT,
-	PIECEWISE_MERGE_JOIN,
-	IE_JOIN,
-	DELIM_JOIN,
-	INDEX_JOIN,
-	// -----------------------------
-	// SetOps
-	// -----------------------------
-	UNION,
-	RECURSIVE_CTE,
-
-	// -----------------------------
-	// Updates
-	// -----------------------------
-	INSERT,
-	DELETE_OPERATOR,
-	UPDATE,
-
-	// -----------------------------
-	// Schema
-	// -----------------------------
-	CREATE_TABLE,
-	CREATE_TABLE_AS,
-	CREATE_INDEX,
-	ALTER,
-	CREATE_SEQUENCE,
-	CREATE_VIEW,
-	CREATE_SCHEMA,
-	CREATE_MACRO,
-	DROP,
-	PRAGMA,
-	TRANSACTION,
-	CREATE_TYPE,
-
-	// -----------------------------
-	// Helpers
-	// -----------------------------
-	EXPLAIN,
-	EXPLAIN_ANALYZE,
-	EMPTY_RESULT,
-	EXECUTE,
-	PREPARE,
-	VACUUM,
-	EXPORT,
-	SET,
-	LOAD,
-	INOUT_FUNCTION,
-	RESULT_COLLECTOR
-};
-
-string PhysicalOperatorToString(PhysicalOperatorType type);
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/execution_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class ThreadContext;
-
-class ExecutionContext {
-public:
-	ExecutionContext(ClientContext &client_p, ThreadContext &thread_p) : client(client_p), thread(thread_p) {
-	}
-
-	//! The client-global context; caution needs to be taken when used in parallel situations
-	ClientContext &client;
-	//! The thread-local context for this execution
-	ThreadContext &thread;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/operator_result_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The OperatorResultType is used to indicate how data should flow around a regular (i.e. non-sink and non-source)
-//! physical operator
-//! There are three possible results:
-//! NEED_MORE_INPUT means the operator is done with the current input and can consume more input if available
-//! If there is more input the operator will be called with more input, otherwise the operator will not be called again.
-//! HAVE_MORE_OUTPUT means the operator is not finished yet with the current input.
-//! The operator will be called again with the same input.
-//! FINISHED means the operator has finished the entire pipeline and no more processing is necessary.
-//! The operator will not be called again, and neither will any other operators in this pipeline.
-enum class OperatorResultType : uint8_t { NEED_MORE_INPUT, HAVE_MORE_OUTPUT, FINISHED };
-
-//! The SinkResultType is used to indicate the result of data flowing into a sink
-//! There are two possible results:
-//! NEED_MORE_INPUT means the sink needs more input
-//! FINISHED means the sink is finished executing, and more input will not change the result any further
-enum class SinkResultType : uint8_t { NEED_MORE_INPUT, FINISHED };
-
-//! The SinkFinalizeType is used to indicate the result of a Finalize call on a sink
-//! There are two possible results:
-//! READY means the sink is ready for further processing
-//! NO_OUTPUT_POSSIBLE means the sink will never provide output, and any pipelines involving the sink can be skipped
-enum class SinkFinalizeType : uint8_t { READY, NO_OUTPUT_POSSIBLE };
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class Event;
-class Executor;
-class PhysicalOperator;
-class Pipeline;
-class PipelineBuildState;
-
-// LCOV_EXCL_START
-class OperatorState {
-public:
-	virtual ~OperatorState() {
-	}
-
-	virtual void Finalize(PhysicalOperator *op, ExecutionContext &context) {
-	}
-};
-
-class GlobalOperatorState {
-public:
-	virtual ~GlobalOperatorState() {
-	}
-};
-
-class GlobalSinkState {
-public:
-	GlobalSinkState() : state(SinkFinalizeType::READY) {
-	}
-	virtual ~GlobalSinkState() {
-	}
-
-	SinkFinalizeType state;
-};
-
-class LocalSinkState {
-public:
-	virtual ~LocalSinkState() {
-	}
-
-	//! The current batch index
-	//! This is only set in case RequiresBatchIndex() is true, and the source has support for it (SupportsBatchIndex())
-	//! Otherwise this is left on INVALID_INDEX
-	//! The batch index is a globally unique, increasing index that should be used to maintain insertion order
-	//! //! in conjunction with parallelism
-	idx_t batch_index = DConstants::INVALID_INDEX;
-};
-
-class GlobalSourceState {
-public:
-	virtual ~GlobalSourceState() {
-	}
-
-	virtual idx_t MaxThreads() {
-		return 1;
-	}
-};
-
-class LocalSourceState {
-public:
-	virtual ~LocalSourceState() {
-	}
-};
-
-// LCOV_EXCL_STOP
-
-//! PhysicalOperator is the base class of the physical operators present in the
-//! execution plan
-class PhysicalOperator {
-public:
-	PhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality)
-	    : type(type), types(std::move(types)), estimated_cardinality(estimated_cardinality) {
-	}
-	virtual ~PhysicalOperator() {
-	}
-
-	//! The physical operator type
-	PhysicalOperatorType type;
-	//! The set of children of the operator
-	vector<unique_ptr<PhysicalOperator>> children;
-	//! The types returned by this physical operator
-	vector<LogicalType> types;
-	//! The estimated cardinality of this physical operator
-	idx_t estimated_cardinality;
-	//! The global sink state of this operator
-	unique_ptr<GlobalSinkState> sink_state;
-	//! The global state of this operator
-	unique_ptr<GlobalOperatorState> op_state;
-
-public:
-	virtual string GetName() const;
-	virtual string ParamsToString() const {
-		return "";
-	}
-	virtual string ToString() const;
-	void Print() const;
-	virtual vector<PhysicalOperator *> GetChildren() const;
-
-	//! Return a vector of the types that will be returned by this operator
-	const vector<LogicalType> &GetTypes() const {
-		return types;
-	}
-
-	virtual bool Equals(const PhysicalOperator &other) const {
-		return false;
-	}
-
-	virtual void Verify();
-
-	//! Whether or not the operator depends on the order of the input chunks
-	//! If this is set to true, we cannot do things like caching intermediate vectors
-	virtual bool IsOrderDependent() const {
-		return false;
-	}
-
-public:
-	// Operator interface
-	virtual unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context) const;
-	virtual unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const;
-	virtual OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                   GlobalOperatorState &gstate, OperatorState &state) const;
-
-	virtual bool ParallelOperator() const {
-		return false;
-	}
-
-	virtual bool RequiresCache() const {
-		return false;
-	}
-
-public:
-	// Source interface
-	virtual unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
-	                                                         GlobalSourceState &gstate) const;
-	virtual unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const;
-	virtual void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	                     LocalSourceState &lstate) const;
-	virtual idx_t GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-	                            LocalSourceState &lstate) const;
-
-	virtual bool IsSource() const {
-		return false;
-	}
-
-	virtual bool ParallelSource() const {
-		return false;
-	}
-
-	virtual bool SupportsBatchIndex() const {
-		return false;
-	}
-
-	//! Returns the current progress percentage, or a negative value if progress bars are not supported
-	virtual double GetProgress(ClientContext &context, GlobalSourceState &gstate) const;
-
-public:
-	// Sink interface
-
-	//! The sink method is called constantly with new input, as long as new input is available. Note that this method
-	//! CAN be called in parallel, proper locking is needed when accessing data inside the GlobalSinkState.
-	virtual SinkResultType Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-	                            DataChunk &input) const;
-	// The combine is called when a single thread has completed execution of its part of the pipeline, it is the final
-	// time that a specific LocalSinkState is accessible. This method can be called in parallel while other Sink() or
-	// Combine() calls are active on the same GlobalSinkState.
-	virtual void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const;
-	//! The finalize is called when ALL threads are finished execution. It is called only once per pipeline, and is
-	//! entirely single threaded.
-	//! If Finalize returns SinkResultType::FINISHED, the sink is marked as finished
-	virtual SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                                  GlobalSinkState &gstate) const;
-
-	virtual unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const;
-	virtual unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const;
-
-	virtual bool IsSink() const {
-		return false;
-	}
-
-	virtual bool ParallelSink() const {
-		return false;
-	}
-
-	virtual bool RequiresBatchIndex() const {
-		return false;
-	}
-
-public:
-	// Pipeline construction
-	virtual vector<const PhysicalOperator *> GetSources() const;
-	bool AllSourcesSupportBatchIndex() const;
-
-	void AddPipeline(Executor &executor, shared_ptr<Pipeline> current, PipelineBuildState &state);
-	virtual void BuildPipelines(Executor &executor, Pipeline &current, PipelineBuildState &state);
-	void BuildChildPipeline(Executor &executor, Pipeline &current, PipelineBuildState &state,
-	                        PhysicalOperator *pipeline_child);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/table_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-
-class BaseStatistics;
-class LogicalGet;
-class TableFilterSet;
-
-struct TableFunctionInfo {
-	DUCKDB_API virtual ~TableFunctionInfo();
-};
-
-struct GlobalTableFunctionState {
-public:
-	// value returned from MaxThreads when as many threads as possible should be used
-	constexpr static const int64_t MAX_THREADS = 999999999;
-
-public:
-	DUCKDB_API virtual ~GlobalTableFunctionState();
-
-	DUCKDB_API virtual idx_t MaxThreads() const {
-		return 1;
-	}
-};
-
-struct LocalTableFunctionState {
-	DUCKDB_API virtual ~LocalTableFunctionState();
-};
-
-struct TableFunctionBindInput {
-	TableFunctionBindInput(vector<Value> &inputs, named_parameter_map_t &named_parameters,
-	                       vector<LogicalType> &input_table_types, vector<string> &input_table_names,
-	                       TableFunctionInfo *info)
-	    : inputs(inputs), named_parameters(named_parameters), input_table_types(input_table_types),
-	      input_table_names(input_table_names), info(info) {
-	}
-
-	vector<Value> &inputs;
-	named_parameter_map_t &named_parameters;
-	vector<LogicalType> &input_table_types;
-	vector<string> &input_table_names;
-	TableFunctionInfo *info;
-};
-
-struct TableFunctionInitInput {
-	TableFunctionInitInput(const FunctionData *bind_data_p, const vector<column_t> &column_ids_p,
-	                       TableFilterSet *filters_p)
-	    : bind_data(bind_data_p), column_ids(column_ids_p), filters(filters_p) {
-	}
-
-	const FunctionData *bind_data;
-	const vector<column_t> &column_ids;
-	TableFilterSet *filters;
-};
-
-struct TableFunctionInput {
-	TableFunctionInput(const FunctionData *bind_data_p, LocalTableFunctionState *local_state_p,
-	                   GlobalTableFunctionState *global_state_p)
-	    : bind_data(bind_data_p), local_state(local_state_p), global_state(global_state_p) {
-	}
-
-	const FunctionData *bind_data;
-	LocalTableFunctionState *local_state;
-	GlobalTableFunctionState *global_state;
-};
-
-typedef unique_ptr<FunctionData> (*table_function_bind_t)(ClientContext &context, TableFunctionBindInput &input,
-                                                          vector<LogicalType> &return_types, vector<string> &names);
-typedef unique_ptr<GlobalTableFunctionState> (*table_function_init_global_t)(ClientContext &context,
-                                                                             TableFunctionInitInput &input);
-typedef unique_ptr<LocalTableFunctionState> (*table_function_init_local_t)(ExecutionContext &context,
-                                                                           TableFunctionInitInput &input,
-                                                                           GlobalTableFunctionState *global_state);
-typedef unique_ptr<BaseStatistics> (*table_statistics_t)(ClientContext &context, const FunctionData *bind_data,
-                                                         column_t column_index);
-typedef void (*table_function_t)(ClientContext &context, TableFunctionInput &data, DataChunk &output);
-
-typedef OperatorResultType (*table_in_out_function_t)(ExecutionContext &context, TableFunctionInput &data,
-                                                      DataChunk &input, DataChunk &output);
-typedef idx_t (*table_function_get_batch_index_t)(ClientContext &context, const FunctionData *bind_data,
-                                                  LocalTableFunctionState *local_state,
-                                                  GlobalTableFunctionState *global_state);
-typedef double (*table_function_progress_t)(ClientContext &context, const FunctionData *bind_data,
-                                            const GlobalTableFunctionState *global_state);
-typedef void (*table_function_dependency_t)(unordered_set<CatalogEntry *> &dependencies, const FunctionData *bind_data);
-typedef unique_ptr<NodeStatistics> (*table_function_cardinality_t)(ClientContext &context,
-                                                                   const FunctionData *bind_data);
-typedef void (*table_function_pushdown_complex_filter_t)(ClientContext &context, LogicalGet &get,
-                                                         FunctionData *bind_data,
-                                                         vector<unique_ptr<Expression>> &filters);
-typedef string (*table_function_to_string_t)(const FunctionData *bind_data);
-
-class TableFunction : public SimpleNamedParameterFunction {
-public:
-	DUCKDB_API
-	TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
-	              table_function_bind_t bind = nullptr, table_function_init_global_t init_global = nullptr,
-	              table_function_init_local_t init_local = nullptr);
-	DUCKDB_API
-	TableFunction(const vector<LogicalType> &arguments, table_function_t function, table_function_bind_t bind = nullptr,
-	              table_function_init_global_t init_global = nullptr, table_function_init_local_t init_local = nullptr);
-	DUCKDB_API TableFunction();
-
-	//! Bind function
-	//! This function is used for determining the return type of a table producing function and returning bind data
-	//! The returned FunctionData object should be constant and should not be changed during execution.
-	table_function_bind_t bind;
-	//! (Optional) global init function
-	//! Initialize the global operator state of the function.
-	//! The global operator state is used to keep track of the progress in the table function and is shared between
-	//! all threads working on the table function.
-	table_function_init_global_t init_global;
-	//! (Optional) local init function
-	//! Initialize the local operator state of the function.
-	//! The local operator state is used to keep track of the progress in the table function and is thread-local.
-	table_function_init_local_t init_local;
-	//! The main function
-	table_function_t function;
-	//! The table in-out function (if this is an in-out function)
-	table_in_out_function_t in_out_function;
-	//! (Optional) statistics function
-	//! Returns the statistics of a specified column
-	table_statistics_t statistics;
-	//! (Optional) dependency function
-	//! Sets up which catalog entries this table function depend on
-	table_function_dependency_t dependency;
-	//! (Optional) cardinality function
-	//! Returns the expected cardinality of this scan
-	table_function_cardinality_t cardinality;
-	//! (Optional) pushdown a set of arbitrary filter expressions, rather than only simple comparisons with a constant
-	//! Any functions remaining in the expression list will be pushed as a regular filter after the scan
-	table_function_pushdown_complex_filter_t pushdown_complex_filter;
-	//! (Optional) function for rendering the operator to a string in profiling output
-	table_function_to_string_t to_string;
-	//! (Optional) return how much of the table we have scanned up to this point (% of the data)
-	table_function_progress_t table_scan_progress;
-	//! (Optional) returns the current batch index of the current scan operator
-	table_function_get_batch_index_t get_batch_index;
-	//! Whether or not the table function supports projection pushdown. If not supported a projection will be added
-	//! that filters out unused columns.
-	bool projection_pushdown;
-	//! Whether or not the table function supports filter pushdown. If not supported a filter will be added
-	//! that applies the table filter directly.
-	bool filter_pushdown;
-	//! Additional function info, passed to the bind
-	shared_ptr<TableFunctionInfo> function_info;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/task_scheduler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/task.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class Executor;
-
-enum class TaskExecutionMode : uint8_t { PROCESS_ALL, PROCESS_PARTIAL };
-
-enum class TaskExecutionResult : uint8_t { TASK_FINISHED, TASK_NOT_FINISHED, TASK_ERROR };
-
-//! Generic parallel task
-class Task {
-public:
-	virtual ~Task() {
-	}
-
-	//! Execute the task in the specified execution mode
-	//! If mode is PROCESS_ALL, Execute should always finish processing and return TASK_FINISHED
-	//! If mode is PROCESS_PARTIAL, Execute can return TASK_NOT_FINISHED, in which case Execute will be called again
-	//! In case of an error, TASK_ERROR is returned
-	virtual TaskExecutionResult Execute(TaskExecutionMode mode) = 0;
-};
-
-//! Execute a task within an executor, including exception handling
-//! This should be used within queries
-class ExecutorTask : public Task {
-public:
-	ExecutorTask(Executor &executor);
-	ExecutorTask(ClientContext &context);
-	virtual ~ExecutorTask();
-
-	Executor &executor;
-
-public:
-	virtual TaskExecutionResult ExecuteTask(TaskExecutionMode mode) = 0;
-	TaskExecutionResult Execute(TaskExecutionMode mode) override;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct ConcurrentQueue;
-struct QueueProducerToken;
-class ClientContext;
-class DatabaseInstance;
-class TaskScheduler;
-
-struct SchedulerThread;
-
-struct ProducerToken {
-	ProducerToken(TaskScheduler &scheduler, unique_ptr<QueueProducerToken> token);
-	~ProducerToken();
-
-	TaskScheduler &scheduler;
-	unique_ptr<QueueProducerToken> token;
-	mutex producer_lock;
-};
-
-//! The TaskScheduler is responsible for managing tasks and threads
-class TaskScheduler {
-	// timeout for semaphore wait, default 5ms
-	constexpr static int64_t TASK_TIMEOUT_USECS = 5000;
-
-public:
-	TaskScheduler(DatabaseInstance &db);
-	~TaskScheduler();
-
-	static TaskScheduler &GetScheduler(ClientContext &context);
-	static TaskScheduler &GetScheduler(DatabaseInstance &db);
-
-	unique_ptr<ProducerToken> CreateProducer();
-	//! Schedule a task to be executed by the task scheduler
-	void ScheduleTask(ProducerToken &producer, unique_ptr<Task> task);
-	//! Fetches a task from a specific producer, returns true if successful or false if no tasks were available
-	bool GetTaskFromProducer(ProducerToken &token, unique_ptr<Task> &task);
-	//! Run tasks forever until "marker" is set to false, "marker" must remain valid until the thread is joined
-	void ExecuteForever(atomic<bool> *marker);
-	//! Run tasks until `max_tasks` have been completed, or until there are no more tasks available
-	void ExecuteTasks(idx_t max_tasks);
-
-	//! Sets the amount of active threads executing tasks for the system; n-1 background threads will be launched.
-	//! The main thread will also be used for execution
-	void SetThreads(int32_t n);
-	//! Returns the number of threads
-	int32_t NumberOfThreads();
-
-private:
-	void SetThreadsInternal(int32_t n);
-
-private:
-	DatabaseInstance &db;
-	//! The task queue
-	unique_ptr<ConcurrentQueue> queue;
-	//! The active background threads of the task scheduler
-	vector<unique_ptr<SchedulerThread>> threads;
-	//! Markers used by the various threads, if the markers are set to "false" the thread execution is stopped
-	vector<unique_ptr<atomic<bool>>> markers;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class Executor;
-class Event;
-
-class PipelineBuildState {
-public:
-	//! How much to increment batch indexes when multiple pipelines share the same source
-	constexpr static idx_t BATCH_INCREMENT = 10000000000000;
-
-public:
-	//! The current recursive CTE node (if any)
-	PhysicalOperator *recursive_cte = nullptr;
-
-	//! Duplicate eliminated join scan dependencies
-	unordered_map<PhysicalOperator *, Pipeline *> delim_join_dependencies;
-
-	//! The number of pipelines that have each specific sink as their sink
-	unordered_map<PhysicalOperator *, idx_t> sink_pipeline_count;
-
-public:
-	void SetPipelineSource(Pipeline &pipeline, PhysicalOperator *op);
-	void SetPipelineSink(Pipeline &pipeline, PhysicalOperator *op);
-	void SetPipelineOperators(Pipeline &pipeline, vector<PhysicalOperator *> operators);
-	void AddPipelineOperator(Pipeline &pipeline, PhysicalOperator *op);
-	void AddPipeline(Executor &executor, shared_ptr<Pipeline> pipeline);
-	void AddChildPipeline(Executor &executor, Pipeline &pipeline);
-
-	unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> &GetUnionPipelines(Executor &executor);
-	unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> &GetChildPipelines(Executor &executor);
-	unordered_map<Pipeline *, vector<Pipeline *>> &GetChildDependencies(Executor &executor);
-
-	PhysicalOperator *GetPipelineSource(Pipeline &pipeline);
-	PhysicalOperator *GetPipelineSink(Pipeline &pipeline);
-	vector<PhysicalOperator *> GetPipelineOperators(Pipeline &pipeline);
-};
-
-//! The Pipeline class represents an execution pipeline
-class Pipeline : public std::enable_shared_from_this<Pipeline> {
-	friend class Executor;
-	friend class PipelineExecutor;
-	friend class PipelineEvent;
-	friend class PipelineFinishEvent;
-	friend class PipelineBuildState;
-
-public:
-	explicit Pipeline(Executor &execution_context);
-
-	Executor &executor;
-
-public:
-	ClientContext &GetClientContext();
-
-	void AddDependency(shared_ptr<Pipeline> &pipeline);
-
-	void Ready();
-	void Reset();
-	void ResetSource();
-	void Schedule(shared_ptr<Event> &event);
-
-	//! Finalize this pipeline
-	void Finalize(Event &event);
-
-	string ToString() const;
-	void Print() const;
-
-	//! Returns query progress
-	bool GetProgress(double &current_percentage, idx_t &estimated_cardinality);
-
-	//! Returns a list of all operators (including source and sink) involved in this pipeline
-	vector<PhysicalOperator *> GetOperators() const;
-
-	PhysicalOperator *GetSink() {
-		return sink;
-	}
-
-	//! Returns whether any of the operators in the pipeline care about preserving insertion order
-	bool IsOrderDependent() const;
-
-private:
-	//! Whether or not the pipeline has been readied
-	bool ready;
-	//! The source of this pipeline
-	PhysicalOperator *source;
-	//! The chain of intermediate operators
-	vector<PhysicalOperator *> operators;
-	//! The sink (i.e. destination) for data; this is e.g. a hash table to-be-built
-	PhysicalOperator *sink;
-
-	//! The global source state
-	unique_ptr<GlobalSourceState> source_state;
-
-	//! The parent pipelines (i.e. pipelines that are dependent on this pipeline to finish)
-	vector<weak_ptr<Pipeline>> parents;
-	//! The dependencies of this pipeline
-	vector<weak_ptr<Pipeline>> dependencies;
-
-	//! The base batch index of this pipeline
-	idx_t base_batch_index = 0;
-
-private:
-	void ScheduleSequentialTask(shared_ptr<Event> &event);
-	bool LaunchScanTasks(shared_ptr<Event> &event, idx_t max_threads);
-
-	bool ScheduleParallel(shared_ptr<Event> &event);
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/pair.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <utility>
-
-namespace duckdb {
-using std::make_pair;
-using std::pair;
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class ClientContext;
-class DataChunk;
-class PhysicalOperator;
-class PipelineExecutor;
-class OperatorState;
-class QueryProfiler;
-class ThreadContext;
-class Task;
-
-struct PipelineEventStack;
-struct ProducerToken;
-
-using event_map_t = unordered_map<const Pipeline *, PipelineEventStack>;
-
-class Executor {
-	friend class Pipeline;
-	friend class PipelineTask;
-	friend class PipelineBuildState;
-
-public:
-	explicit Executor(ClientContext &context);
-	~Executor();
-
-	ClientContext &context;
-
-public:
-	static Executor &Get(ClientContext &context);
-
-	void Initialize(PhysicalOperator *physical_plan);
-	void Initialize(unique_ptr<PhysicalOperator> physical_plan);
-
-	void CancelTasks();
-	PendingExecutionResult ExecuteTask();
-
-	void Reset();
-
-	vector<LogicalType> GetTypes();
-
-	unique_ptr<DataChunk> FetchChunk();
-
-	//! Push a new error
-	void PushError(ExceptionType type, const string &exception);
-	//! True if an error has been thrown
-	bool HasError();
-	//! Throw the exception that was pushed using PushError.
-	//! Should only be called if HasError returns true
-	void ThrowException();
-
-	//! Work on tasks for this specific executor, until there are no tasks remaining
-	void WorkOnTasks();
-
-	//! Flush a thread context into the client context
-	void Flush(ThreadContext &context);
-
-	//! Returns the progress of the pipelines
-	bool GetPipelinesProgress(double &current_progress);
-
-	void CompletePipeline() {
-		completed_pipelines++;
-	}
-	ProducerToken &GetToken() {
-		return *producer;
-	}
-	void AddEvent(shared_ptr<Event> event);
-
-	void ReschedulePipelines(const vector<shared_ptr<Pipeline>> &pipelines, vector<shared_ptr<Event>> &events);
-
-	//! Whether or not the root of the pipeline is a result collector object
-	bool HasResultCollector();
-	//! Returns the query result - can only be used if `HasResultCollector` returns true
-	unique_ptr<QueryResult> GetResult();
-
-private:
-	void InitializeInternal(PhysicalOperator *physical_plan);
-
-	void ScheduleEvents();
-	void ScheduleEventsInternal(const vector<shared_ptr<Pipeline>> &pipelines,
-	                            unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> &child_pipelines,
-	                            vector<shared_ptr<Event>> &events, bool main_schedule = true);
-
-	void SchedulePipeline(const shared_ptr<Pipeline> &pipeline, event_map_t &event_map,
-	                      vector<shared_ptr<Event>> &events, bool complete_pipeline);
-	Pipeline *ScheduleUnionPipeline(const shared_ptr<Pipeline> &pipeline, const Pipeline *parent,
-	                                event_map_t &event_map, vector<shared_ptr<Event>> &events);
-	void ScheduleChildPipeline(Pipeline *parent, const shared_ptr<Pipeline> &pipeline, event_map_t &event_map,
-	                           vector<shared_ptr<Event>> &events);
-	void ExtractPipelines(shared_ptr<Pipeline> &pipeline, vector<shared_ptr<Pipeline>> &result);
-	bool NextExecutor();
-
-	void AddChildPipeline(Pipeline *current);
-
-	void VerifyPipeline(Pipeline &pipeline);
-	void VerifyPipelines();
-	void ThrowExceptionInternal();
-
-private:
-	PhysicalOperator *physical_plan;
-	unique_ptr<PhysicalOperator> owned_plan;
-
-	mutex executor_lock;
-	//! The pipelines of the current query
-	vector<shared_ptr<Pipeline>> pipelines;
-	//! The root pipeline of the query
-	vector<shared_ptr<Pipeline>> root_pipelines;
-	//! The pipeline executor for the root pipeline
-	unique_ptr<PipelineExecutor> root_executor;
-	//! The current root pipeline index
-	idx_t root_pipeline_idx;
-	//! The producer of this query
-	unique_ptr<ProducerToken> producer;
-	//! Exceptions that occurred during the execution of the current query
-	vector<pair<ExceptionType, string>> exceptions;
-	//! List of events
-	vector<shared_ptr<Event>> events;
-	//! The query profiler
-	shared_ptr<QueryProfiler> profiler;
-
-	//! The amount of completed pipelines of the query
-	atomic<idx_t> completed_pipelines;
-	//! The total amount of pipelines in the query
-	idx_t total_pipelines;
-
-	//! The adjacent union pipelines of each pipeline
-	//! Union pipelines have the same sink, but can be run concurrently along with this pipeline
-	unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> union_pipelines;
-	//! Child pipelines of this pipeline
-	//! Like union pipelines, child pipelines share the same sink
-	//! Unlike union pipelines, child pipelines should be run AFTER their dependencies are completed
-	//! i.e. they should be run after the dependencies are completed, but before finalize is called on the sink
-	unordered_map<Pipeline *, vector<shared_ptr<Pipeline>>> child_pipelines;
-	//! Dependencies of child pipelines
-	unordered_map<Pipeline *, vector<Pipeline *>> child_dependencies;
-
-	//! The last pending execution result (if any)
-	PendingExecutionResult execution_result;
-	//! The current task in process (if any)
-	unique_ptr<Task> task;
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-class ClientContext;
-class ClientContextLock;
-class PreparedStatementData;
-
-class PendingQueryResult : public BaseQueryResult {
-	friend class ClientContext;
-
-public:
-	DUCKDB_API PendingQueryResult(shared_ptr<ClientContext> context, PreparedStatementData &statement,
-	                              vector<LogicalType> types, bool allow_stream_result);
-	DUCKDB_API explicit PendingQueryResult(string error_message);
-	DUCKDB_API ~PendingQueryResult();
-
-public:
-	//! Executes a single task within the query, returning whether or not the query is ready.
-	//! If this returns RESULT_READY, the Execute function can be called to obtain a pointer to the result.
-	//! If this returns RESULT_NOT_READY, the ExecuteTask function should be called again.
-	//! If this returns EXECUTION_ERROR, an error occurred during execution.
-	//! The error message can be obtained by calling GetError() on the PendingQueryResult.
-	DUCKDB_API PendingExecutionResult ExecuteTask();
-
-	//! Returns the result of the query as an actual query result.
-	//! This returns (mostly) instantly if ExecuteTask has been called until RESULT_READY was returned.
-	DUCKDB_API unique_ptr<QueryResult> Execute();
-
-	DUCKDB_API void Close();
-
-private:
-	shared_ptr<ClientContext> context;
-	bool allow_stream_result;
-
-private:
-	void CheckExecutableInternal(ClientContextLock &lock);
-
-	PendingExecutionResult ExecuteTaskInternal(ClientContextLock &lock);
-	unique_ptr<QueryResult> ExecuteInternal(ClientContextLock &lock);
-	unique_ptr<ClientContextLock> LockContext();
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/prepared_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class PreparedStatementData;
-
-//! A prepared statement
-class PreparedStatement {
-public:
-	//! Create a successfully prepared prepared statement object with the given name
-	DUCKDB_API PreparedStatement(shared_ptr<ClientContext> context, shared_ptr<PreparedStatementData> data,
-	                             string query, idx_t n_param);
-	//! Create a prepared statement that was not successfully prepared
-	DUCKDB_API explicit PreparedStatement(string error);
-
-	DUCKDB_API ~PreparedStatement();
-
-public:
-	//! The client context this prepared statement belongs to
-	shared_ptr<ClientContext> context;
-	//! The prepared statement data
-	shared_ptr<PreparedStatementData> data;
-	//! The query that is being prepared
-	string query;
-	//! Whether or not the statement was successfully prepared
-	bool success;
-	//! The error message (if success = false)
-	string error;
-	//! The amount of bound parameters
-	idx_t n_param;
-
-public:
-	//! Returns the number of columns in the result
-	idx_t ColumnCount();
-	//! Returns the statement type of the underlying prepared statement object
-	StatementType GetStatementType();
-	//! Returns the underlying statement properties
-	StatementProperties GetStatementProperties();
-	//! Returns the result SQL types of the prepared statement
-	const vector<LogicalType> &GetTypes();
-	//! Returns the result names of the prepared statement
-	const vector<string> &GetNames();
-
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	template <typename... Args>
-	unique_ptr<PendingQueryResult> PendingQuery(Args... args) {
-		vector<Value> values;
-		return PendingQueryRecursive(values, args...);
-	}
-
-	//! Execute the prepared statement with the given set of arguments
-	template <typename... Args>
-	unique_ptr<QueryResult> Execute(Args... args) {
-		vector<Value> values;
-		return ExecuteRecursive(values, args...);
-	}
-
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
-
-	//! Execute the prepared statement with the given set of values
-	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
-
-private:
-	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values) {
-		return PendingQuery(values);
-	}
-
-	template <typename T, typename... Args>
-	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values, T value, Args... args) {
-		values.push_back(Value::CreateValue<T>(value));
-		return PendingQueryRecursive(values, args...);
-	}
-
-	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values) {
-		return Execute(values);
-	}
-
-	template <typename T, typename... Args>
-	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values, T value, Args... args) {
-		values.push_back(Value::CreateValue<T>(value));
-		return ExecuteRecursive(values, args...);
-	}
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/join_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Join Types
-//===--------------------------------------------------------------------===//
-enum class JoinType : uint8_t {
-	INVALID = 0, // invalid join type
-	LEFT = 1,    // left
-	RIGHT = 2,   // right
-	INNER = 3,   // inner
-	OUTER = 4,   // outer
-	SEMI = 5,    // SEMI join returns left side row ONLY if it has a join partner, no duplicates
-	ANTI = 6,    // ANTI join returns left side row ONLY if it has NO join partner, no duplicates
-	MARK = 7,    // MARK join returns marker indicating whether or not there is a join partner (true), there is no join
-	             // partner (false)
-	SINGLE = 8   // SINGLE join is like LEFT OUTER JOIN, BUT returns at most one join partner per entry on the LEFT side
-	             // (and NULL if no partner is found)
-};
-
-//! Convert join type to string
-DUCKDB_API string JoinTypeToString(JoinType type);
-
-//! True if join is left or full outer join
-bool IsLeftOuterJoin(JoinType type);
-
-//! True if join is rght or full outer join
-bool IsRightOuterJoin(JoinType type);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/relation_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Catalog Types
-//===--------------------------------------------------------------------===//
-enum class RelationType : uint8_t {
-	INVALID_RELATION,
-	TABLE_RELATION,
-	PROJECTION_RELATION,
-	FILTER_RELATION,
-	EXPLAIN_RELATION,
-	CROSS_PRODUCT_RELATION,
-	JOIN_RELATION,
-	AGGREGATE_RELATION,
-	SET_OPERATION_RELATION,
-	DISTINCT_RELATION,
-	LIMIT_RELATION,
-	ORDER_RELATION,
-	CREATE_VIEW_RELATION,
-	CREATE_TABLE_RELATION,
-	INSERT_RELATION,
-	VALUE_LIST_RELATION,
-	DELETE_RELATION,
-	UPDATE_RELATION,
-	WRITE_CSV_RELATION,
-	READ_CSV_RELATION,
-	SUBQUERY_RELATION,
-	TABLE_FUNCTION_RELATION,
-	VIEW_RELATION,
-	QUERY_RELATION
-};
-
-string RelationTypeToString(RelationType type);
-
-} // namespace duckdb
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/schema_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_generator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-
-class DefaultGenerator {
-public:
-	explicit DefaultGenerator(Catalog &catalog) : catalog(catalog), created_all_entries(false) {
-	}
-	virtual ~DefaultGenerator() {
-	}
-
-	Catalog &catalog;
-	atomic<bool> created_all_entries;
-
-public:
-	//! Creates a default entry with the specified name, or returns nullptr if no such entry can be generated
-	virtual unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) = 0;
-	//! Get a list of all default entries in the generator
-	virtual vector<string> GetDefaultEntries() = 0;
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/table_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/standard_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-//! A StandardEntry is a catalog entry that is a member of a schema
-class StandardEntry : public CatalogEntry {
-public:
-	StandardEntry(CatalogType type, SchemaCatalogEntry *schema, Catalog *catalog, string name)
-	    : CatalogEntry(type, catalog, name), schema(schema) {
-	}
-	~StandardEntry() override {
-	}
-
-	//! The schema the entry belongs to
-	SchemaCatalogEntry *schema;
-};
-} // namespace duckdb
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class Serializer;
-class Deserializer;
-class FieldWriter;
-class FieldReader;
-
-//===--------------------------------------------------------------------===//
-// Constraint Types
-//===--------------------------------------------------------------------===//
-enum class ConstraintType : uint8_t {
-	INVALID = 0,     // invalid constraint type
-	NOT_NULL = 1,    // NOT NULL constraint
-	CHECK = 2,       // CHECK constraint
-	UNIQUE = 3,      // UNIQUE constraint
-	FOREIGN_KEY = 4, // FOREIGN KEY constraint
-};
-
-enum class ForeignKeyType : uint8_t {
-	FK_TYPE_PRIMARY_KEY_TABLE = 0,   // main table
-	FK_TYPE_FOREIGN_KEY_TABLE = 1,   // referencing table
-	FK_TYPE_SELF_REFERENCE_TABLE = 2 // self refrencing table
-};
-
-struct ForeignKeyInfo {
-	ForeignKeyType type;
-	string schema;
-	//! if type is FK_TYPE_FOREIGN_KEY_TABLE, means main key table, if type is FK_TYPE_PRIMARY_KEY_TABLE, means foreign
-	//! key table
-	string table;
-	//! The set of main key table's column's index
-	vector<storage_t> pk_keys;
-	//! The set of foreign key table's column's index
-	vector<idx_t> fk_keys;
-};
-
-//! Constraint is the base class of any type of table constraint.
-class Constraint {
-public:
-	DUCKDB_API explicit Constraint(ConstraintType type);
-	DUCKDB_API virtual ~Constraint();
-
-	ConstraintType type;
-
-public:
-	DUCKDB_API virtual string ToString() const = 0;
-	DUCKDB_API void Print() const;
-
-	DUCKDB_API virtual unique_ptr<Constraint> Copy() const = 0;
-	//! Serializes a Constraint to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	//! Serializes a Constraint to a stand-alone binary blob
-	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
-	//! Deserializes a blob back into a Constraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-//! Bound equivalent of Constraint
-class BoundConstraint {
-public:
-	explicit BoundConstraint(ConstraintType type) : type(type) {};
-	virtual ~BoundConstraint() {
-	}
-
-	ConstraintType type;
-};
-} // namespace duckdb
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/column_dependency_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <set>
-
-namespace duckdb {
-using std::set;
-}
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/stack.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <stack>
-
-namespace duckdb {
-using std::stack;
-}
-
-
-namespace duckdb {
-
-//! Dependency Manager local to a table, responsible for keeping track of generated column dependencies
-
-class ColumnDependencyManager {
-public:
-	DUCKDB_API ColumnDependencyManager();
-	DUCKDB_API ~ColumnDependencyManager();
-	DUCKDB_API ColumnDependencyManager(ColumnDependencyManager &&other) = default;
-	DUCKDB_API ColumnDependencyManager(const ColumnDependencyManager &other) = delete;
-
-public:
-	//! Get the bind order that ensures dependencies are resolved before dependents are
-	stack<column_t> GetBindOrder(const vector<ColumnDefinition> &columns);
-
-	//! Adds a connection between the dependent and its dependencies
-	void AddGeneratedColumn(column_t index, const vector<column_t> &indices, bool root = true);
-	//! Add a generated column from a column definition
-	void AddGeneratedColumn(const ColumnDefinition &column, const case_insensitive_map_t<column_t> &name_map);
-
-	//! Removes the column(s) and outputs the new column indices
-	vector<column_t> RemoveColumn(column_t index, column_t column_amount);
-
-	bool IsDependencyOf(column_t dependent, column_t dependency) const;
-	bool HasDependencies(column_t index) const;
-	const unordered_set<column_t> &GetDependencies(column_t index) const;
-
-	bool HasDependents(column_t index) const;
-	const unordered_set<column_t> &GetDependents(column_t index) const;
-
-private:
-	void RemoveStandardColumn(column_t index);
-	void RemoveGeneratedColumn(column_t index);
-
-	void AdjustSingle(column_t idx, idx_t offset);
-	// Clean up the gaps created by a Remove operation
-	vector<column_t> CleanupInternals(column_t column_amount);
-
-private:
-	//! A map of column dependency to generated column(s)
-	unordered_map<column_t, unordered_set<column_t>> dependencies_map;
-	//! A map of generated column name to (potentially generated)column dependencies
-	unordered_map<column_t, unordered_set<column_t>> dependents_map;
-	//! For resolve-order purposes, keep track of the 'direct' (not inherited) dependencies of a generated column
-	unordered_map<column_t, unordered_set<column_t>> direct_dependencies;
-	set<column_t> deleted_columns;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class DataTable;
-struct CreateTableInfo;
-struct BoundCreateTableInfo;
-
-struct RenameColumnInfo;
-struct AddColumnInfo;
-struct RemoveColumnInfo;
-struct SetDefaultInfo;
-struct ChangeColumnTypeInfo;
-struct AlterForeignKeyInfo;
-
-//! A table catalog entry
-class TableCatalogEntry : public StandardEntry {
-public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
-	                  std::shared_ptr<DataTable> inherited_storage = nullptr);
-
-	//! A reference to the underlying storage unit used for this table
-	std::shared_ptr<DataTable> storage;
-	//! A list of columns that are part of this table
-	vector<ColumnDefinition> columns;
-	//! A list of constraints that are part of this table
-	vector<unique_ptr<Constraint>> constraints;
-	//! A list of constraints that are part of this table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	ColumnDependencyManager column_dependency_manager;
-	//! A map of column name to column index
-	case_insensitive_map_t<column_t> name_map;
-
-public:
-	//! For debugging purposes, count how many columns are STANDARD
-	idx_t StandardColumnCount() const;
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
-	//! Returns whether or not a column with the given name exists
-	DUCKDB_API bool ColumnExists(const string &name);
-	//! Returns a reference to the column of the specified name. Throws an
-	//! exception if the column does not exist.
-	ColumnDefinition &GetColumn(const string &name);
-	//! Returns a list of types of the table
-	vector<LogicalType> GetTypes();
-	string ToSQL() override;
-
-	//! Serialize the meta information of the TableCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateTableInfo> Deserialize(Deserializer &source);
-
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
-
-	void SetAsRoot() override;
-
-	void CommitAlter(AlterInfo &info);
-	void CommitDrop();
-
-	//! Returns the column index of the specified column name.
-	//! If the column does not exist:
-	//! If if_exists is true, returns DConstants::INVALID_INDEX
-	//! If if_exists is false, throws an exception
-	column_t GetColumnIndex(string &name, bool if_exists = false);
-
-private:
-	const string &GetColumnName(column_t index);
-	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
-	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);
-	unique_ptr<CatalogEntry> RemoveColumn(ClientContext &context, RemoveColumnInfo &info);
-	unique_ptr<CatalogEntry> SetDefault(ClientContext &context, SetDefaultInfo &info);
-	unique_ptr<CatalogEntry> ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info);
-	unique_ptr<CatalogEntry> SetForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_sequence_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/parse_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct ParseInfo {
-	virtual ~ParseInfo() {
-	}
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-enum class OnCreateConflict : uint8_t {
-	// Standard: throw error
-	ERROR_ON_CONFLICT,
-	// CREATE IF NOT EXISTS, silently do nothing on conflict
-	IGNORE_ON_CONFLICT,
-	// CREATE OR REPLACE
-	REPLACE_ON_CONFLICT
-};
-
-struct CreateInfo : public ParseInfo {
-	explicit CreateInfo(CatalogType type, string schema = DEFAULT_SCHEMA)
-	    : type(type), schema(schema), on_conflict(OnCreateConflict::ERROR_ON_CONFLICT), temporary(false),
-	      internal(false) {
-	}
-	~CreateInfo() override {
-	}
-
-	//! The to-be-created catalog type
-	CatalogType type;
-	//! The schema name of the entry
-	string schema;
-	//! What to do on create conflict
-	OnCreateConflict on_conflict;
-	//! Whether or not the entry is temporary
-	bool temporary;
-	//! Whether or not the entry is an internal entry
-	bool internal;
-	//! The SQL string of the CREATE statement
-	string sql;
-
-public:
-	virtual unique_ptr<CreateInfo> Copy() const = 0;
-	void CopyProperties(CreateInfo &other) const {
-		other.type = type;
-		other.schema = schema;
-		other.on_conflict = on_conflict;
-		other.temporary = temporary;
-		other.internal = internal;
-		other.sql = sql;
-	}
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct CreateSequenceInfo : public CreateInfo {
-	CreateSequenceInfo()
-	    : CreateInfo(CatalogType::SEQUENCE_ENTRY, INVALID_SCHEMA), name(string()), usage_count(0), increment(1),
-	      min_value(1), max_value(NumericLimits<int64_t>::Maximum()), start_value(1), cycle(false) {
-	}
-
-	//! Sequence name to create
-	string name;
-	//! Usage count of the sequence
-	uint64_t usage_count;
-	//! The increment value
-	int64_t increment;
-	//! The minimum value of the sequence
-	int64_t min_value;
-	//! The maximum value of the sequence
-	int64_t max_value;
-	//! The start value of the sequence
-	int64_t start_value;
-	//! Whether or not the sequence cycles
-	bool cycle;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateSequenceInfo>();
-		CopyProperties(*result);
-		result->name = name;
-		result->schema = schema;
-		result->usage_count = usage_count;
-		result->increment = increment;
-		result->min_value = min_value;
-		result->max_value = max_value;
-		result->start_value = start_value;
-		result->cycle = cycle;
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/alter_table_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-enum class AlterType : uint8_t {
-	INVALID = 0,
-	ALTER_TABLE = 1,
-	ALTER_VIEW = 2,
-	ALTER_SEQUENCE = 3,
-	CHANGE_OWNERSHIP = 4
-};
-
-enum AlterForeignKeyType : uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };
-
-struct AlterInfo : public ParseInfo {
-	AlterInfo(AlterType type, string schema, string name);
-	~AlterInfo() override;
-
-	AlterType type;
-	//! Schema name to alter
-	string schema;
-	//! Entry name to alter
-	string name;
-
-public:
-	virtual CatalogType GetCatalogType() const = 0;
-	virtual unique_ptr<AlterInfo> Copy() const = 0;
-	void Serialize(Serializer &serializer) const;
-	virtual void Serialize(FieldWriter &writer) const = 0;
-	static unique_ptr<AlterInfo> Deserialize(Deserializer &source);
-};
-
-//===--------------------------------------------------------------------===//
-// Change Ownership
-//===--------------------------------------------------------------------===//
-struct ChangeOwnershipInfo : public AlterInfo {
-	ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_schema, string entry_name, string owner_schema,
-	                    string owner_name);
-
-	// Catalog type refers to the entry type, since this struct is usually built from an
-	// ALTER <TYPE> <schema>.<name> OWNED BY <owner_schema>.<owner_name> statement
-	// here it is only possible to know the type of who is to be owned
-	CatalogType entry_catalog_type;
-
-	string owner_schema;
-	string owner_name;
-
-public:
-	CatalogType GetCatalogType() const override;
-	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-};
-
-//===--------------------------------------------------------------------===//
-// Alter Table
-//===--------------------------------------------------------------------===//
-enum class AlterTableType : uint8_t {
-	INVALID = 0,
-	RENAME_COLUMN = 1,
-	RENAME_TABLE = 2,
-	ADD_COLUMN = 3,
-	REMOVE_COLUMN = 4,
-	ALTER_COLUMN_TYPE = 5,
-	SET_DEFAULT = 6,
-	FOREIGN_KEY_CONSTRAINT = 7,
-};
-
-struct AlterTableInfo : public AlterInfo {
-	AlterTableInfo(AlterTableType type, string schema, string table);
-	~AlterTableInfo() override;
-
-	AlterTableType alter_table_type;
-
-public:
-	CatalogType GetCatalogType() const override;
-	void Serialize(FieldWriter &writer) const override;
-	virtual void SerializeAlterTable(FieldWriter &writer) const = 0;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
-};
-
-//===--------------------------------------------------------------------===//
-// RenameColumnInfo
-//===--------------------------------------------------------------------===//
-struct RenameColumnInfo : public AlterTableInfo {
-	RenameColumnInfo(string schema, string table, string old_name_p, string new_name_p);
-	~RenameColumnInfo() override;
-
-	//! Column old name
-	string old_name;
-	//! Column new name
-	string new_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
-};
-
-//===--------------------------------------------------------------------===//
-// RenameTableInfo
-//===--------------------------------------------------------------------===//
-struct RenameTableInfo : public AlterTableInfo {
-	RenameTableInfo(string schema, string table, string new_name);
-	~RenameTableInfo() override;
-
-	//! Relation new name
-	string new_table_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
-};
-
-//===--------------------------------------------------------------------===//
-// AddColumnInfo
-//===--------------------------------------------------------------------===//
-struct AddColumnInfo : public AlterTableInfo {
-	AddColumnInfo(string schema, string table, ColumnDefinition new_column);
-	~AddColumnInfo() override;
-
-	//! New column
-	ColumnDefinition new_column;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
-};
-
-//===--------------------------------------------------------------------===//
-// RemoveColumnInfo
-//===--------------------------------------------------------------------===//
-struct RemoveColumnInfo : public AlterTableInfo {
-	RemoveColumnInfo(string schema, string table, string removed_column, bool if_exists, bool cascade);
-	~RemoveColumnInfo() override;
-
-	//! The column to remove
-	string removed_column;
-	//! Whether or not an error should be thrown if the column does not exist
-	bool if_exists;
-	//! Whether or not the column should be removed if a dependency conflict arises (used by GENERATED columns)
-	bool cascade;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
-};
-
-//===--------------------------------------------------------------------===//
-// ChangeColumnTypeInfo
-//===--------------------------------------------------------------------===//
-struct ChangeColumnTypeInfo : public AlterTableInfo {
-	ChangeColumnTypeInfo(string schema, string table, string column_name, LogicalType target_type,
-	                     unique_ptr<ParsedExpression> expression);
-	~ChangeColumnTypeInfo() override;
-
-	//! The column name to alter
-	string column_name;
-	//! The target type of the column
-	LogicalType target_type;
-	//! The expression used for data conversion
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
-};
-
-//===--------------------------------------------------------------------===//
-// SetDefaultInfo
-//===--------------------------------------------------------------------===//
-struct SetDefaultInfo : public AlterTableInfo {
-	SetDefaultInfo(string schema, string table, string column_name, unique_ptr<ParsedExpression> new_default);
-	~SetDefaultInfo() override;
-
-	//! The column name to alter
-	string column_name;
-	//! The expression used for data conversion
-	unique_ptr<ParsedExpression> expression;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
-};
-
-//===--------------------------------------------------------------------===//
-// AlterForeignKeyInfo
-//===--------------------------------------------------------------------===//
-struct AlterForeignKeyInfo : public AlterTableInfo {
-	AlterForeignKeyInfo(string schema, string table, string fk_table, vector<string> pk_columns,
-	                    vector<string> fk_columns, vector<idx_t> pk_keys, vector<idx_t> fk_keys,
-	                    AlterForeignKeyType type);
-	~AlterForeignKeyInfo() override;
-
-	string fk_table;
-	vector<string> pk_columns;
-	vector<string> fk_columns;
-	vector<idx_t> pk_keys;
-	vector<idx_t> fk_keys;
-	AlterForeignKeyType type;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterTable(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
-};
-
-//===--------------------------------------------------------------------===//
-// Alter View
-//===--------------------------------------------------------------------===//
-enum class AlterViewType : uint8_t { INVALID = 0, RENAME_VIEW = 1 };
-
-struct AlterViewInfo : public AlterInfo {
-	AlterViewInfo(AlterViewType type, string schema, string view);
-	~AlterViewInfo() override;
-
-	AlterViewType alter_view_type;
-
-public:
-	CatalogType GetCatalogType() const override;
-	void Serialize(FieldWriter &writer) const override;
-	virtual void SerializeAlterView(FieldWriter &writer) const = 0;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
-};
-
-//===--------------------------------------------------------------------===//
-// RenameViewInfo
-//===--------------------------------------------------------------------===//
-struct RenameViewInfo : public AlterViewInfo {
-	RenameViewInfo(string schema, string view, string new_name);
-	~RenameViewInfo() override;
-
-	//! Relation new name
-	string new_view_name;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void SerializeAlterView(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader, string schema, string table);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-
-struct SequenceValue {
-	SequenceValue() : usage_count(0), counter(-1) {
-	}
-	SequenceValue(uint64_t usage_count, int64_t counter) : usage_count(usage_count), counter(counter) {
-	}
-
-	uint64_t usage_count;
-	int64_t counter;
-};
-
-//! A sequence catalog entry
-class SequenceCatalogEntry : public StandardEntry {
-public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	SequenceCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateSequenceInfo *info);
-
-	//! Lock for getting a value on the sequence
-	mutex lock;
-	//! The amount of times the sequence has been used
-	uint64_t usage_count;
-	//! The sequence counter
-	int64_t counter;
-	//! The most recently returned value
-	int64_t last_value;
-	//! The increment value
-	int64_t increment;
-	//! The minimum value of the sequence
-	int64_t start_value;
-	//! The minimum value of the sequence
-	int64_t min_value;
-	//! The maximum value of the sequence
-	int64_t max_value;
-	//! Whether or not the sequence cycles
-	bool cycle;
-
-public:
-	//! Serialize the meta information of the SequenceCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateSequenceInfo> Deserialize(Deserializer &source);
-
-	string ToSQL() override;
-
-	CatalogEntry *AlterOwnership(ClientContext &context, AlterInfo *info);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/transaction.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/undo_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/undo_flags.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class UndoFlags : uint32_t { // far too big but aligned (TM)
-	EMPTY_ENTRY = 0,
-	CATALOG_ENTRY = 1,
-	INSERT_TUPLE = 2,
-	DELETE_TUPLE = 3,
-	UPDATE_TUPLE = 4
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-class WriteAheadLog;
-
-//! The undo buffer of a transaction is used to hold previous versions of tuples
-//! that might be required in the future (because of rollbacks or previous
-//! transactions accessing them)
-class UndoBuffer {
-public:
-	struct IteratorState {
-		ArenaChunk *current;
-		data_ptr_t start;
-		data_ptr_t end;
-	};
-
-public:
-	UndoBuffer(const shared_ptr<ClientContext> &context);
-
-	//! Reserve space for an entry of the specified type and length in the undo
-	//! buffer
-	data_ptr_t CreateEntry(UndoFlags type, idx_t len);
-
-	bool ChangesMade();
-	idx_t EstimatedSize();
-
-	//! Cleanup the undo buffer
-	void Cleanup();
-	//! Commit the changes made in the UndoBuffer: should be called on commit
-	void Commit(UndoBuffer::IteratorState &iterator_state, WriteAheadLog *log, transaction_t commit_id);
-	//! Revert committed changes made in the UndoBuffer up until the currently committed state
-	void RevertCommit(UndoBuffer::IteratorState &iterator_state, transaction_t transaction_id);
-	//! Rollback the changes made in this UndoBuffer: should be called on
-	//! rollback
-	void Rollback() noexcept;
-
-private:
-	ArenaAllocator allocator;
-
-private:
-	template <class T>
-	void IterateEntries(UndoBuffer::IteratorState &state, T &&callback);
-	template <class T>
-	void IterateEntries(UndoBuffer::IteratorState &state, UndoBuffer::IteratorState &end_state, T &&callback);
-	template <class T>
-	void ReverseIterateEntries(T &&callback);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/local_storage.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/scan_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/storage_lock.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class StorageLock;
-
-enum class StorageLockType { SHARED = 0, EXCLUSIVE = 1 };
-
-class StorageLockKey {
-public:
-	StorageLockKey(StorageLock &lock, StorageLockType type);
-	~StorageLockKey();
-
-private:
-	StorageLock &lock;
-	StorageLockType type;
-};
-
-class StorageLock {
-	friend class StorageLockKey;
-
-public:
-	StorageLock();
-
-	//! Get an exclusive lock
-	unique_ptr<StorageLockKey> GetExclusiveLock();
-	//! Get a shared lock
-	unique_ptr<StorageLockKey> GetSharedLock();
-
-private:
-	mutex exclusive_lock;
-	atomic<idx_t> read_count;
-
-private:
-	//! Release an exclusive lock
-	void ReleaseExclusiveLock();
-	//! Release a shared lock
-	void ReleaseSharedLock();
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/adaptive_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_aggregate_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-#include <memory>
-
-namespace duckdb {
-class BoundAggregateExpression : public Expression {
-public:
-	BoundAggregateExpression(AggregateFunction function, vector<unique_ptr<Expression>> children,
-	                         unique_ptr<Expression> filter, unique_ptr<FunctionData> bind_info, bool distinct);
-
-	//! The bound function expression
-	AggregateFunction function;
-	//! List of arguments to the function
-	vector<unique_ptr<Expression>> children;
-	//! The bound function data (if any)
-	unique_ptr<FunctionData> bind_info;
-	//! True to aggregate on distinct values
-	bool distinct;
-
-	//! Filter for this aggregate
-	unique_ptr<Expression> filter;
-
-public:
-	bool IsAggregate() const override {
-		return true;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-	bool PropagatesNullValues() const override;
-
-	string ToString() const override;
-
-	hash_t Hash() const override;
-	bool Equals(const BaseExpression *other) const override;
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_between_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BoundBetweenExpression : public Expression {
-public:
-	BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower, unique_ptr<Expression> upper,
-	                       bool lower_inclusive, bool upper_inclusive);
-
-	unique_ptr<Expression> input;
-	unique_ptr<Expression> lower;
-	unique_ptr<Expression> upper;
-	bool lower_inclusive;
-	bool upper_inclusive;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-
-public:
-	ExpressionType LowerComparisonType() {
-		return lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO : ExpressionType::COMPARE_GREATERTHAN;
-	}
-	ExpressionType UpperComparisonType() {
-		return upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO : ExpressionType::COMPARE_LESSTHAN;
-	}
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_case_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct BoundCaseCheck {
-	unique_ptr<Expression> when_expr;
-	unique_ptr<Expression> then_expr;
-};
-
-class BoundCaseExpression : public Expression {
-public:
-	BoundCaseExpression(LogicalType type);
-	BoundCaseExpression(unique_ptr<Expression> when_expr, unique_ptr<Expression> then_expr,
-	                    unique_ptr<Expression> else_expr);
-
-	vector<BoundCaseCheck> case_checks;
-	unique_ptr<Expression> else_expr;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_cast_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BoundCastExpression : public Expression {
-public:
-	BoundCastExpression(unique_ptr<Expression> child, LogicalType target_type, bool try_cast = false);
-
-	//! The child type
-	unique_ptr<Expression> child;
-	//! Whether to use try_cast or not. try_cast converts cast failures into NULLs instead of throwing an error.
-	bool try_cast;
-
-public:
-	LogicalType source_type() {
-		return child->return_type;
-	}
-
-	//! Cast an expression to the specified SQL type if required
-	static unique_ptr<Expression> AddCastToType(unique_ptr<Expression> expr, const LogicalType &target_type,
-	                                            bool try_cast = false);
-	//! Returns true if a cast is invertible (i.e. CAST(s -> t -> s) = s for all values of s). This is not true for e.g.
-	//! boolean casts, because that can be e.g. -1 -> TRUE -> 1. This is necessary to prevent some optimizer bugs.
-	static bool CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type);
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_columnref_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! A BoundColumnRef expression represents a ColumnRef expression that was bound to an actual table and column index. It
-//! is not yet executable, however. The ColumnBindingResolver transforms the BoundColumnRefExpressions into
-//! BoundExpressions, which refer to indexes into the physical chunks that pass through the executor.
-class BoundColumnRefExpression : public Expression {
-public:
-	BoundColumnRefExpression(LogicalType type, ColumnBinding binding, idx_t depth = 0);
-	BoundColumnRefExpression(string alias, LogicalType type, ColumnBinding binding, idx_t depth = 0);
-
-	//! Column index set by the binder, used to generate the final BoundExpression
-	ColumnBinding binding;
-	//! The subquery depth (i.e. depth 0 = current query, depth 1 = parent query, depth 2 = parent of parent, etc...).
-	//! This is only non-zero for correlated expressions inside subqueries.
-	idx_t depth;
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-	hash_t Hash() const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_comparison_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BoundComparisonExpression : public Expression {
-public:
-	BoundComparisonExpression(ExpressionType type, unique_ptr<Expression> left, unique_ptr<Expression> right);
-
-	unique_ptr<Expression> left;
-	unique_ptr<Expression> right;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-
-public:
-	static LogicalType BindComparison(LogicalType left_type, LogicalType right_type);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_conjunction_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BoundConjunctionExpression : public Expression {
-public:
-	explicit BoundConjunctionExpression(ExpressionType type);
-	BoundConjunctionExpression(ExpressionType type, unique_ptr<Expression> left, unique_ptr<Expression> right);
-
-	vector<unique_ptr<Expression>> children;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-
-	bool PropagatesNullValues() const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_constant_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundConstantExpression : public Expression {
-public:
-	explicit BoundConstantExpression(Value value);
-
-	Value value;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-	hash_t Hash() const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_default_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BoundDefaultExpression : public Expression {
-public:
-	explicit BoundDefaultExpression(LogicalType type = LogicalType())
-	    : Expression(ExpressionType::VALUE_DEFAULT, ExpressionClass::BOUND_DEFAULT, type) {
-	}
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override {
-		return "DEFAULT";
-	}
-
-	unique_ptr<Expression> Copy() override {
-		return make_unique<BoundDefaultExpression>(return_type);
-	}
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_function_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ScalarFunctionCatalogEntry;
-
-//! Represents a function call that has been bound to a base function
-class BoundFunctionExpression : public Expression {
-public:
-	BoundFunctionExpression(LogicalType return_type, ScalarFunction bound_function,
-	                        vector<unique_ptr<Expression>> arguments, unique_ptr<FunctionData> bind_info,
-	                        bool is_operator = false);
-
-	//! The bound function expression
-	ScalarFunction function;
-	//! List of child-expressions of the function
-	vector<unique_ptr<Expression>> children;
-	//! The bound function data (if any)
-	unique_ptr<FunctionData> bind_info;
-	//! Whether or not the function is an operator, only used for rendering
-	bool is_operator;
-
-public:
-	bool HasSideEffects() const override;
-	bool IsFoldable() const override;
-	string ToString() const override;
-	bool PropagatesNullValues() const override;
-	hash_t Hash() const override;
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-	void Verify() const override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_operator_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BoundOperatorExpression : public Expression {
-public:
-	BoundOperatorExpression(ExpressionType type, LogicalType return_type);
-
-	vector<unique_ptr<Expression>> children;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_parameter_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class BoundParameterExpression : public Expression {
-public:
-	explicit BoundParameterExpression(idx_t parameter_nr);
-
-	idx_t parameter_nr;
-	Value *value;
-
-public:
-	bool IsScalar() const override;
-	bool HasParameter() const override;
-	bool IsFoldable() const override;
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-	hash_t Hash() const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_reference_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! A BoundReferenceExpression represents a physical index into a DataChunk
-class BoundReferenceExpression : public Expression {
-public:
-	BoundReferenceExpression(string alias, LogicalType type, idx_t index);
-	BoundReferenceExpression(LogicalType type, storage_t index);
-
-	//! Index used to access data in the chunks
-	storage_t index;
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	hash_t Hash() const override;
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_subquery_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/subquery_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Subquery Types
-//===--------------------------------------------------------------------===//
-enum class SubqueryType : uint8_t {
-	INVALID = 0,
-	SCALAR = 1,     // Regular scalar subquery
-	EXISTS = 2,     // EXISTS (SELECT...)
-	NOT_EXISTS = 3, // NOT EXISTS(SELECT...)
-	ANY = 4,        // x = ANY(SELECT...) OR x IN (SELECT...)
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tokens.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Statements
-//===--------------------------------------------------------------------===//
-class SQLStatement;
-
-class AlterStatement;
-class CallStatement;
-class CopyStatement;
-class CreateStatement;
-class DeleteStatement;
-class DropStatement;
-class ExtensionStatement;
-class InsertStatement;
-class SelectStatement;
-class TransactionStatement;
-class UpdateStatement;
-class PrepareStatement;
-class ExecuteStatement;
-class PragmaStatement;
-class ShowStatement;
-class ExplainStatement;
-class ExportStatement;
-class VacuumStatement;
-class RelationStatement;
-class SetStatement;
-class LoadStatement;
-
-//===--------------------------------------------------------------------===//
-// Query Node
-//===--------------------------------------------------------------------===//
-class QueryNode;
-class SelectNode;
-class SetOperationNode;
-class RecursiveCTENode;
-
-//===--------------------------------------------------------------------===//
-// Expressions
-//===--------------------------------------------------------------------===//
-class ParsedExpression;
-
-class BetweenExpression;
-class CaseExpression;
-class CastExpression;
-class CollateExpression;
-class ColumnRefExpression;
-class ComparisonExpression;
-class ConjunctionExpression;
-class ConstantExpression;
-class DefaultExpression;
-class FunctionExpression;
-class LambdaExpression;
-class OperatorExpression;
-class ParameterExpression;
-class PositionalReferenceExpression;
-class StarExpression;
-class SubqueryExpression;
-class WindowExpression;
-
-//===--------------------------------------------------------------------===//
-// Constraints
-//===--------------------------------------------------------------------===//
-class Constraint;
-
-class NotNullConstraint;
-class CheckConstraint;
-class UniqueConstraint;
-class ForeignKeyConstraint;
-
-//===--------------------------------------------------------------------===//
-// TableRefs
-//===--------------------------------------------------------------------===//
-class TableRef;
-
-class BaseTableRef;
-class CrossProductRef;
-class JoinRef;
-class SubqueryRef;
-class TableFunctionRef;
-class EmptyTableRef;
-class ExpressionListRef;
-
-//===--------------------------------------------------------------------===//
-// Other
-//===--------------------------------------------------------------------===//
-struct SampleOptions;
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bind_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class Catalog;
-class Constraint;
-
-struct CreateTableFunctionInfo;
-
-//! A table function in the catalog
-class TableFunctionCatalogEntry : public StandardEntry {
-public:
-	TableFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTableFunctionInfo *info);
-
-	//! The table function
-	vector<TableFunction> functions;
-};
-} // namespace duckdb
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/columnref_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a reference to a column from either the FROM clause or from an
-//! alias
-class ColumnRefExpression : public ParsedExpression {
-public:
-	//! Specify both the column and table name
-	ColumnRefExpression(string column_name, string table_name);
-	//! Only specify the column name, the table name will be derived later
-	explicit ColumnRefExpression(string column_name);
-	//! Specify a set of names
-	explicit ColumnRefExpression(vector<string> column_names);
-
-	//! The stack of names in order of which they appear (column_names[0].column_names[1].column_names[2]....)
-	vector<string> column_names;
-
-public:
-	bool IsQualified() const;
-	const string &GetColumnName() const;
-	const string &GetTableName() const;
-	bool IsScalar() const override {
-		return false;
-	}
-
-	string GetName() const override;
-	string ToString() const override;
-
-	static bool Equals(const ColumnRefExpression *a, const ColumnRefExpression *b);
-	hash_t Hash() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/qualified_name_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/hash.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct string_t;
-
-// efficient hash function that maximizes the avalanche effect and minimizes
-// bias
-// see: https://nullprogram.com/blog/2018/07/31/
-
-inline hash_t murmurhash64(uint64_t x) {
-	return x * UINT64_C(0xbf58476d1ce4e5b9);
-}
-
-inline hash_t murmurhash32(uint32_t x) {
-	return murmurhash64(x);
-}
-
-template <class T>
-hash_t Hash(T value) {
-	return murmurhash32(value);
-}
-
-//! Combine two hashes by XORing them
-inline hash_t CombineHash(hash_t left, hash_t right) {
-	return left ^ right;
-}
-
-template <>
-hash_t Hash(uint64_t val);
-template <>
-hash_t Hash(int64_t val);
-template <>
-hash_t Hash(hugeint_t val);
-template <>
-hash_t Hash(float val);
-template <>
-hash_t Hash(double val);
-template <>
-hash_t Hash(const char *val);
-template <>
-hash_t Hash(char *val);
-template <>
-hash_t Hash(string_t val);
-template <>
-hash_t Hash(interval_t val);
-hash_t Hash(const char *val, size_t size);
-hash_t Hash(uint8_t *val, size_t size);
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct QualifiedColumnHashFunction {
-	uint64_t operator()(const QualifiedColumnName &a) const {
-		std::hash<std::string> str_hasher;
-		return str_hasher(a.schema) ^ str_hasher(a.table) ^ str_hasher(a.column);
-	}
-};
-
-struct QualifiedColumnEquality {
-	bool operator()(const QualifiedColumnName &a, const QualifiedColumnName &b) const {
-		return a.schema == b.schema && a.table == b.table && a.column == b.column;
-	}
-};
-
-using qualified_column_set_t = unordered_set<QualifiedColumnName, QualifiedColumnHashFunction, QualifiedColumnEquality>;
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/bound_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! BoundExpression is an intermediate dummy class used by the binder. It is a ParsedExpression but holds an Expression.
-//! It represents a successfully bound expression. It is used in the Binder to prevent re-binding of already bound parts
-//! when dealing with subqueries.
-class BoundExpression : public ParsedExpression {
-public:
-	BoundExpression(unique_ptr<Expression> expr)
-	    : ParsedExpression(ExpressionType::INVALID, ExpressionClass::BOUND_EXPRESSION), expr(std::move(expr)) {
-	}
-
-	unique_ptr<Expression> expr;
-
-public:
-	string ToString() const override {
-		if (!expr) {
-			throw InternalException("ToString(): BoundExpression does not have a child");
-		}
-		return expr->ToString();
-	}
-
-	bool Equals(const BaseExpression *other) const override {
-		return false;
-	}
-	hash_t Hash() const override {
-		return 0;
-	}
-
-	unique_ptr<ParsedExpression> Copy() const override {
-		throw SerializationException("Cannot copy or serialize bound expression");
-	}
-
-	void Serialize(FieldWriter &writer) const override {
-		throw SerializationException("Cannot copy or serialize bound expression");
-	}
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-namespace duckdb {
-
-class Binder;
-class ClientContext;
-class QueryNode;
-
-class ScalarFunctionCatalogEntry;
-class AggregateFunctionCatalogEntry;
-class ScalarMacroCatalogEntry;
-class CatalogEntry;
-class SimpleFunction;
-
-struct MacroBinding;
-
-struct BoundColumnReferenceInfo {
-	string name;
-	idx_t query_location;
-};
-
-struct BindResult {
-	BindResult() {
-	}
-	explicit BindResult(string error) : error(error) {
-	}
-	explicit BindResult(unique_ptr<Expression> expr) : expression(std::move(expr)) {
-	}
-
-	bool HasError() {
-		return !error.empty();
-	}
-
-	unique_ptr<Expression> expression;
-	string error;
-};
-
-class ExpressionBinder {
-public:
-	ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder = false);
-	virtual ~ExpressionBinder();
-
-	//! The target type that should result from the binder. If the result is not of this type, a cast to this type will
-	//! be added. Defaults to INVALID.
-	LogicalType target_type;
-
-	MacroBinding *macro_binding;
-
-public:
-	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> &expr, LogicalType *result_type = nullptr,
-	                            bool root_expression = true);
-
-	//! Returns whether or not any columns have been bound by the expression binder
-	bool HasBoundColumns() {
-		return !bound_columns.empty();
-	}
-	const vector<BoundColumnReferenceInfo> &GetBoundColumns() {
-		return bound_columns;
-	}
-
-	string Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false);
-
-	unique_ptr<ParsedExpression> CreateStructExtract(unique_ptr<ParsedExpression> base, string field_name);
-	unique_ptr<ParsedExpression> CreateStructPack(ColumnRefExpression &colref);
-	BindResult BindQualifiedColumnName(ColumnRefExpression &colref, const string &table_name);
-
-	unique_ptr<ParsedExpression> QualifyColumnName(const string &column_name, string &error_message);
-	unique_ptr<ParsedExpression> QualifyColumnName(ColumnRefExpression &colref, string &error_message);
-
-	// Bind table names to ColumnRefExpressions
-	void QualifyColumnNames(unique_ptr<ParsedExpression> &expr);
-	static void QualifyColumnNames(Binder &binder, unique_ptr<ParsedExpression> &expr);
-
-	static unique_ptr<Expression> PushCollation(ClientContext &context, unique_ptr<Expression> source,
-	                                            const string &collation, bool equality_only = false);
-	static void TestCollation(ClientContext &context, const string &collation);
-
-	bool BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr);
-
-	void BindChild(unique_ptr<ParsedExpression> &expr, idx_t depth, string &error);
-	static void ExtractCorrelatedExpressions(Binder &binder, Expression &expr);
-
-	static bool ContainsNullType(const LogicalType &type);
-	static LogicalType ExchangeNullType(const LogicalType &type);
-	static bool ContainsType(const LogicalType &type, LogicalTypeId target);
-	static LogicalType ExchangeType(const LogicalType &type, LogicalTypeId target, LogicalType new_type);
-
-	//! Bind the given expresion. Unlike Bind(), this does *not* mute the given ParsedExpression.
-	//! Exposed to be used from sub-binders that aren't subclasses of ExpressionBinder.
-	virtual BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                                  bool root_expression = false);
-
-	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
-
-protected:
-	BindResult BindExpression(BetweenExpression &expr, idx_t depth);
-	BindResult BindExpression(CaseExpression &expr, idx_t depth);
-	BindResult BindExpression(CollateExpression &expr, idx_t depth);
-	BindResult BindExpression(CastExpression &expr, idx_t depth);
-	BindResult BindExpression(ColumnRefExpression &expr, idx_t depth);
-	BindResult BindExpression(ComparisonExpression &expr, idx_t depth);
-	BindResult BindExpression(ConjunctionExpression &expr, idx_t depth);
-	BindResult BindExpression(ConstantExpression &expr, idx_t depth);
-	BindResult BindExpression(FunctionExpression &expr, idx_t depth, unique_ptr<ParsedExpression> *expr_ptr);
-	BindResult BindExpression(LambdaExpression &expr, idx_t depth);
-	BindResult BindExpression(OperatorExpression &expr, idx_t depth);
-	BindResult BindExpression(ParameterExpression &expr, idx_t depth);
-	BindResult BindExpression(PositionalReferenceExpression &ref, idx_t depth);
-	BindResult BindExpression(SubqueryExpression &expr, idx_t depth);
-
-protected:
-	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);
-	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry *function, idx_t depth);
-	virtual BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function, idx_t depth);
-	virtual BindResult BindUnnest(FunctionExpression &expr, idx_t depth);
-	virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry *macro, idx_t depth,
-	                             unique_ptr<ParsedExpression> *expr_ptr);
-
-	virtual string UnsupportedAggregateMessage();
-	virtual string UnsupportedUnnestMessage();
-
-	Binder &binder;
-	ClientContext &context;
-	ExpressionBinder *stored_binder;
-	vector<BoundColumnReferenceInfo> bound_columns;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/table_binding.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-class BindContext;
-class BoundQueryNode;
-class ColumnRefExpression;
-class SubqueryRef;
-class LogicalGet;
-class TableCatalogEntry;
-class TableFunctionCatalogEntry;
-class BoundTableFunction;
-class StandardEntry;
-
-enum class BindingType { BASE, TABLE, MACRO, CATALOG_ENTRY };
-
-//! A Binding represents a binding to a table, table-producing function or subquery with a specified table index.
-struct Binding {
-	Binding(BindingType binding_type, const string &alias, vector<LogicalType> types, vector<string> names,
-	        idx_t index);
-	virtual ~Binding() = default;
-
-	//! The type of Binding
-	BindingType binding_type;
-	//! The alias of the binding
-	string alias;
-	//! The table index of the binding
-	idx_t index;
-	vector<LogicalType> types;
-	//! Column names of the subquery
-	vector<string> names;
-	//! Name -> index for the names
-	case_insensitive_map_t<column_t> name_map;
-
-public:
-	bool TryGetBindingIndex(const string &column_name, column_t &column_index);
-	column_t GetBindingIndex(const string &column_name);
-	bool HasMatchingBinding(const string &column_name);
-	virtual string ColumnNotFoundError(const string &column_name) const;
-	virtual BindResult Bind(ColumnRefExpression &colref, idx_t depth);
-	virtual StandardEntry *GetStandardEntry();
-};
-
-struct EntryBinding : public Binding {
-public:
-	EntryBinding(const string &alias, vector<LogicalType> types, vector<string> names, idx_t index,
-	             StandardEntry &entry);
-	StandardEntry &entry;
-
-public:
-	StandardEntry *GetStandardEntry() override;
-};
-
-//! TableBinding is exactly like the Binding, except it keeps track of which columns were bound in the linked LogicalGet
-//! node for projection pushdown purposes.
-struct TableBinding : public Binding {
-	TableBinding(const string &alias, vector<LogicalType> types, vector<string> names, LogicalGet &get, idx_t index,
-	             bool add_row_id = false);
-
-	//! the underlying LogicalGet
-	LogicalGet &get;
-
-public:
-	unique_ptr<ParsedExpression> ExpandGeneratedColumn(const string &column_name);
-	BindResult Bind(ColumnRefExpression &colref, idx_t depth) override;
-	StandardEntry *GetStandardEntry() override;
-	string ColumnNotFoundError(const string &column_name) const override;
-};
-
-//! MacroBinding is like the Binding, except the alias and index are set by default. Used for binding Macro
-//! Params/Arguments.
-struct MacroBinding : public Binding {
-	static constexpr const char *MACRO_NAME = "0_macro_parameters";
-
-public:
-	MacroBinding(vector<LogicalType> types_p, vector<string> names_p, string macro_name);
-
-	//! Arguments
-	vector<unique_ptr<ParsedExpression>> arguments;
-	//! The name of the macro
-	string macro_name;
-
-public:
-	BindResult Bind(ColumnRefExpression &colref, idx_t depth) override;
-
-	//! Given the parameter colref, returns a copy of the argument that was supplied for this parameter
-	unique_ptr<ParsedExpression> ParamToArg(ColumnRefExpression &colref);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class Binder;
-class LogicalGet;
-class BoundQueryNode;
-
-class StarExpression;
-
-struct UsingColumnSet {
-	string primary_binding;
-	unordered_set<string> bindings;
-};
-
-//! The BindContext object keeps track of all the tables and columns that are
-//! encountered during the binding process.
-class BindContext {
-public:
-	//! Keep track of recursive CTE references
-	case_insensitive_map_t<std::shared_ptr<idx_t>> cte_references;
-
-public:
-	//! Given a column name, find the matching table it belongs to. Throws an
-	//! exception if no table has a column of the given name.
-	string GetMatchingBinding(const string &column_name);
-	//! Like GetMatchingBinding, but instead of throwing an error if multiple tables have the same binding it will
-	//! return a list of all the matching ones
-	unordered_set<string> GetMatchingBindings(const string &column_name);
-	//! Like GetMatchingBindings, but returns the top 3 most similar bindings (in levenshtein distance) instead of the
-	//! matching ones
-	vector<string> GetSimilarBindings(const string &column_name);
-
-	Binding *GetCTEBinding(const string &ctename);
-	//! Binds a column expression to the base table. Returns the bound expression
-	//! or throws an exception if the column could not be bound.
-	BindResult BindColumn(ColumnRefExpression &colref, idx_t depth);
-	string BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name);
-	BindResult BindColumn(PositionalReferenceExpression &ref, idx_t depth);
-
-	unique_ptr<ParsedExpression> ExpandGeneratedColumn(const string &table_name, const string &column_name);
-
-	unique_ptr<ParsedExpression> CreateColumnReference(const string &table_name, const string &column_name);
-	unique_ptr<ParsedExpression> CreateColumnReference(const string &schema_name, const string &table_name,
-	                                                   const string &column_name);
-
-	//! Generate column expressions for all columns that are present in the
-	//! referenced tables. This is used to resolve the * expression in a
-	//! selection list.
-	void GenerateAllColumnExpressions(StarExpression &expr, vector<unique_ptr<ParsedExpression>> &new_select_list);
-	//! Check if the given (binding, column_name) is in the exclusion/replacement lists.
-	//! Returns true if it is in one of these lists, and should therefore be skipped.
-	bool CheckExclusionList(StarExpression &expr, Binding *binding, const string &column_name,
-	                        vector<unique_ptr<ParsedExpression>> &new_select_list,
-	                        case_insensitive_set_t &excluded_columns);
-
-	const vector<std::pair<string, Binding *>> &GetBindingsList() {
-		return bindings_list;
-	}
-
-	//! Adds a base table with the given alias to the BindContext.
-	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
-	                  LogicalGet &get);
-	//! Adds a call to a table function with the given alias to the BindContext.
-	void AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
-	                      const vector<LogicalType> &types, LogicalGet &get);
-	//! Adds a table view with a given alias to the BindContext.
-	void AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery, ViewCatalogEntry *view);
-	//! Adds a subquery with a given alias to the BindContext.
-	void AddSubquery(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery);
-	//! Adds a subquery with a given alias to the BindContext.
-	void AddSubquery(idx_t index, const string &alias, TableFunctionRef &ref, BoundQueryNode &subquery);
-	//! Adds a binding to a catalog entry with a given alias to the BindContext.
-	void AddEntryBinding(idx_t index, const string &alias, const vector<string> &names,
-	                     const vector<LogicalType> &types, StandardEntry *entry);
-	//! Adds a base table with the given alias to the BindContext.
-	void AddGenericBinding(idx_t index, const string &alias, const vector<string> &names,
-	                       const vector<LogicalType> &types);
-
-	//! Adds a base table with the given alias to the CTE BindContext.
-	//! We need this to correctly bind recursive CTEs with multiple references.
-	void AddCTEBinding(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types);
-
-	//! Add an implicit join condition (e.g. USING (x))
-	void AddUsingBinding(const string &column_name, UsingColumnSet *set);
-
-	void AddUsingBindingSet(unique_ptr<UsingColumnSet> set);
-
-	//! Returns any using column set for the given column name, or nullptr if there is none. On conflict (multiple using
-	//! column sets with the same name) throw an exception.
-	UsingColumnSet *GetUsingBinding(const string &column_name);
-	//! Returns any using column set for the given column name, or nullptr if there is none
-	UsingColumnSet *GetUsingBinding(const string &column_name, const string &binding_name);
-	//! Erase a using binding from the set of using bindings
-	void RemoveUsingBinding(const string &column_name, UsingColumnSet *set);
-	//! Finds the using bindings for a given column. Returns true if any exists, false otherwise.
-	bool FindUsingBinding(const string &column_name, unordered_set<UsingColumnSet *> **using_columns);
-	//! Transfer a using binding from one bind context to this bind context
-	void TransferUsingBinding(BindContext &current_context, UsingColumnSet *current_set, UsingColumnSet *new_set,
-	                          const string &binding, const string &using_column);
-
-	//! Fetch the actual column name from the given binding, or throws if none exists
-	//! This can be different from "column_name" because of case insensitivity
-	//! (e.g. "column_name" might return "COLUMN_NAME")
-	string GetActualColumnName(const string &binding, const string &column_name);
-
-	case_insensitive_map_t<std::shared_ptr<Binding>> GetCTEBindings() {
-		return cte_bindings;
-	}
-	void SetCTEBindings(case_insensitive_map_t<std::shared_ptr<Binding>> bindings) {
-		cte_bindings = bindings;
-	}
-
-	//! Alias a set of column names for the specified table, using the original names if there are not enough aliases
-	//! specified.
-	static vector<string> AliasColumnNames(const string &table_name, const vector<string> &names,
-	                                       const vector<string> &column_aliases);
-
-	//! Add all the bindings from a BindContext to this BindContext. The other BindContext is destroyed in the process.
-	void AddContext(BindContext other);
-
-	//! Gets a binding of the specified name. Returns a nullptr and sets the out_error if the binding could not be
-	//! found.
-	Binding *GetBinding(const string &name, string &out_error);
-
-private:
-	void AddBinding(const string &alias, unique_ptr<Binding> binding);
-
-private:
-	//! The set of bindings
-	case_insensitive_map_t<unique_ptr<Binding>> bindings;
-	//! The list of bindings in insertion order
-	vector<std::pair<string, Binding *>> bindings_list;
-	//! The set of columns used in USING join conditions
-	case_insensitive_map_t<unordered_set<UsingColumnSet *>> using_columns;
-	//! Using column sets
-	vector<unique_ptr<UsingColumnSet>> using_column_sets;
-
-	//! The set of CTE bindings
-	case_insensitive_map_t<std::shared_ptr<Binding>> cte_bindings;
-};
-} // namespace duckdb
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/query_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/common_table_expression_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/select_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/sql_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/printer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! Printer is a static class that allows printing to logs or stdout/stderr
-class Printer {
-public:
-	//! Print the object to stderr
-	DUCKDB_API static void Print(const string &str);
-	//! Prints Progress
-	DUCKDB_API static void PrintProgress(int percentage, const char *pbstr, int pbwidth);
-	//! Prints an empty line when progress bar is done
-	DUCKDB_API static void FinishProgressBarPrint(const char *pbstr, int pbwidth);
-	//! Whether or not we are printing to a terminal
-	DUCKDB_API static bool IsTerminal();
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//! SQLStatement is the base class of any type of SQL statement.
-class SQLStatement {
-public:
-	explicit SQLStatement(StatementType type) : type(type) {};
-	virtual ~SQLStatement() {
-	}
-
-	//! The statement type
-	StatementType type;
-	//! The statement location within the query string
-	idx_t stmt_location = 0;
-	//! The statement length within the query string
-	idx_t stmt_length = 0;
-	//! The number of prepared statement parameters (if any)
-	idx_t n_param = 0;
-	//! The query text that corresponds to this SQL statement
-	string query;
-
-protected:
-	SQLStatement(const SQLStatement &other) = default;
-
-public:
-	virtual string ToString() const {
-		throw InternalException("ToString not supported for this type of SQLStatement");
-	}
-	//! Create a copy of this SelectStatement
-	virtual unique_ptr<SQLStatement> Copy() const = 0;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/tableref_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Table Reference Types
-//===--------------------------------------------------------------------===//
-enum class TableReferenceType : uint8_t {
-	INVALID = 0,         // invalid table reference type
-	BASE_TABLE = 1,      // base table reference
-	SUBQUERY = 2,        // output of a subquery
-	JOIN = 3,            // output of join
-	CROSS_PRODUCT = 4,   // out of cartesian product
-	TABLE_FUNCTION = 5,  // table producing function
-	EXPRESSION_LIST = 6, // expression list
-	CTE = 7,             // Recursive CTE
-	EMPTY = 8            // placeholder for empty FROM
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/sample_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-enum class SampleMethod : uint8_t { SYSTEM_SAMPLE = 0, BERNOULLI_SAMPLE = 1, RESERVOIR_SAMPLE = 2 };
-
-string SampleMethodToString(SampleMethod method);
-
-struct SampleOptions {
-	Value sample_size;
-	bool is_percentage;
-	SampleMethod method;
-	int64_t seed = -1;
-
-	unique_ptr<SampleOptions> Copy();
-	void Serialize(Serializer &serializer);
-	static unique_ptr<SampleOptions> Deserialize(Deserializer &source);
-	static bool Equals(SampleOptions *a, SampleOptions *b);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class Deserializer;
-class Serializer;
-
-//! Represents a generic expression that returns a table.
-class TableRef {
-public:
-	explicit TableRef(TableReferenceType type) : type(type) {
-	}
-	virtual ~TableRef() {
-	}
-
-	TableReferenceType type;
-	string alias;
-	//! Sample options (if any)
-	unique_ptr<SampleOptions> sample;
-	//! The location in the query (if any)
-	idx_t query_location = DConstants::INVALID_INDEX;
-
-public:
-	//! Convert the object to a string
-	virtual string ToString() const = 0;
-	string BaseToString(string result) const;
-	string BaseToString(string result, const vector<string> &column_name_alias) const;
-	void Print();
-
-	virtual bool Equals(const TableRef *other) const;
-
-	virtual unique_ptr<TableRef> Copy() = 0;
-
-	//! Serializes a TableRef to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	//! Serializes a TableRef to a stand-alone binary blob
-	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
-	//! Deserializes a blob back into a TableRef
-	DUCKDB_API static unique_ptr<TableRef> Deserialize(Deserializer &source);
-
-	//! Copy the properties of this table ref to the target
-	void CopyProperties(TableRef &target) const;
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class QueryNode;
-
-//! SelectStatement is a typical SELECT clause
-class SelectStatement : public SQLStatement {
-public:
-	SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
-	}
-
-	//! The main query node
-	unique_ptr<QueryNode> node;
-
-protected:
-	SelectStatement(const SelectStatement &other);
-
-public:
-	//! Convert the SELECT statement to a string
-	string ToString() const override;
-	//! Create a copy of this SelectStatement
-	unique_ptr<SQLStatement> Copy() const override;
-	//! Serializes a SelectStatement to a stand-alone binary blob
-	void Serialize(Serializer &serializer) const;
-	//! Deserializes a blob back into a SelectStatement, returns nullptr if
-	//! deserialization is not possible
-	static unique_ptr<SelectStatement> Deserialize(Deserializer &source);
-	//! Whether or not the statements are equivalent
-	bool Equals(const SQLStatement *other) const;
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class SelectStatement;
-
-struct CommonTableExpressionInfo {
-	vector<string> aliases;
-	unique_ptr<SelectStatement> query;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-enum QueryNodeType : uint8_t {
-	SELECT_NODE = 1,
-	SET_OPERATION_NODE = 2,
-	BOUND_SUBQUERY_NODE = 3,
-	RECURSIVE_CTE_NODE = 4
-};
-
-struct CommonTableExpressionInfo;
-
-class CommonTableExpressionMap {
-public:
-	CommonTableExpressionMap();
-
-	unordered_map<string, unique_ptr<CommonTableExpressionInfo>> map;
-
-public:
-	string ToString() const;
-	CommonTableExpressionMap Copy() const;
-};
-
-class QueryNode {
-public:
-	explicit QueryNode(QueryNodeType type) : type(type) {
-	}
-	virtual ~QueryNode() {
-	}
-
-	//! The type of the query node, either SetOperation or Select
-	QueryNodeType type;
-	//! The set of result modifiers associated with this query node
-	vector<unique_ptr<ResultModifier>> modifiers;
-	//! CTEs (used by SelectNode and SetOperationNode)
-	CommonTableExpressionMap cte_map;
-
-	virtual const vector<unique_ptr<ParsedExpression>> &GetSelectList() const = 0;
-
-public:
-	//! Convert the query node to a string
-	virtual string ToString() const = 0;
-
-	virtual bool Equals(const QueryNode *other) const;
-
-	//! Create a copy of this QueryNode
-	virtual unique_ptr<QueryNode> Copy() const = 0;
-	//! Serializes a QueryNode to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	//! Serializes a QueryNode to a stand-alone binary blob
-	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
-	//! Deserializes a blob back into a QueryNode
-	DUCKDB_API static unique_ptr<QueryNode> Deserialize(Deserializer &source);
-
-	string ResultModifiersToString() const;
-
-protected:
-	//! Copy base QueryNode properties from another expression to this one,
-	//! used in Copy method
-	void CopyProperties(QueryNode &other) const;
-};
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-class BoundResultModifier;
-class BoundSelectNode;
-class ClientContext;
-class ExpressionBinder;
-class LimitModifier;
-class OrderBinder;
-class TableCatalogEntry;
-class ViewCatalogEntry;
-class TableMacroCatalogEntry;
-
-struct CreateInfo;
-struct BoundCreateTableInfo;
-struct BoundCreateFunctionInfo;
-struct CommonTableExpressionInfo;
-
-enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES };
-
-struct CorrelatedColumnInfo {
-	ColumnBinding binding;
-	LogicalType type;
-	string name;
-	idx_t depth;
-
-	CorrelatedColumnInfo(ColumnBinding binding, LogicalType type_p, string name_p, idx_t depth)
-	    : binding(binding), type(std::move(type_p)), name(std::move(name_p)), depth(depth) {
-	}
-	explicit CorrelatedColumnInfo(BoundColumnRefExpression &expr)
-	    : CorrelatedColumnInfo(expr.binding, expr.return_type, expr.GetName(), expr.depth) {
-	}
-
-	bool operator==(const CorrelatedColumnInfo &rhs) const {
-		return binding == rhs.binding;
-	}
-};
-
-//! Bind the parsed query tree to the actual columns present in the catalog.
-/*!
-  The binder is responsible for binding tables and columns to actual physical
-  tables and columns in the catalog. In the process, it also resolves types of
-  all expressions.
-*/
-class Binder : public std::enable_shared_from_this<Binder> {
-	friend class ExpressionBinder;
-	friend class SelectBinder;
-	friend class RecursiveSubqueryPlanner;
-
-public:
-	static shared_ptr<Binder> CreateBinder(ClientContext &context, Binder *parent = nullptr, bool inherit_ctes = true);
-
-	//! The client context
-	ClientContext &context;
-	//! A mapping of names to common table expressions
-	case_insensitive_map_t<CommonTableExpressionInfo *> CTE_bindings;
-	//! The CTEs that have already been bound
-	unordered_set<CommonTableExpressionInfo *> bound_ctes;
-	//! The bind context
-	BindContext bind_context;
-	//! The set of correlated columns bound by this binder (FIXME: this should probably be an unordered_set and not a
-	//! vector)
-	vector<CorrelatedColumnInfo> correlated_columns;
-	//! The set of parameter expressions bound by this binder
-	vector<BoundParameterExpression *> *parameters;
-	//! The types of the prepared statement parameters, if any
-	vector<LogicalType> *parameter_types;
-	//! Statement properties
-	StatementProperties properties;
-	//! The alias for the currently processing subquery, if it exists
-	string alias;
-	//! Macro parameter bindings (if any)
-	MacroBinding *macro_binding = nullptr;
-
-public:
-	BoundStatement Bind(SQLStatement &statement);
-	BoundStatement Bind(QueryNode &node);
-
-	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info);
-	void BindCreateViewInfo(CreateViewInfo &base);
-	SchemaCatalogEntry *BindSchema(CreateInfo &info);
-	SchemaCatalogEntry *BindCreateFunctionInfo(CreateInfo &info);
-
-	//! Check usage, and cast named parameters to their types
-	static void BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
-	                                QueryErrorContext &error_context, string &func_name);
-
-	unique_ptr<BoundTableRef> Bind(TableRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundTableRef &ref);
-
-	//! Generates an unused index for a table
-	idx_t GenerateTableIndex();
-
-	//! Add a common table expression to the binder
-	void AddCTE(const string &name, CommonTableExpressionInfo *cte);
-	//! Find a common table expression by name; returns nullptr if none exists
-	CommonTableExpressionInfo *FindCTE(const string &name, bool skip = false);
-
-	bool CTEIsAlreadyBound(CommonTableExpressionInfo *cte);
-
-	//! Add the view to the set of currently bound views - used for detecting recursive view definitions
-	void AddBoundView(ViewCatalogEntry *view);
-
-	void PushExpressionBinder(ExpressionBinder *binder);
-	void PopExpressionBinder();
-	void SetActiveBinder(ExpressionBinder *binder);
-	ExpressionBinder *GetActiveBinder();
-	bool HasActiveBinder();
-
-	vector<ExpressionBinder *> &GetActiveBinders();
-
-	void MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other);
-	//! Add a correlated column to this binder (if it does not exist)
-	void AddCorrelatedColumn(const CorrelatedColumnInfo &info);
-
-	string FormatError(ParsedExpression &expr_context, const string &message);
-	string FormatError(TableRef &ref_context, const string &message);
-
-	string FormatErrorRecursive(idx_t query_location, const string &message, vector<ExceptionFormatValue> &values);
-	template <class T, typename... Args>
-	string FormatErrorRecursive(idx_t query_location, const string &msg, vector<ExceptionFormatValue> &values, T param,
-	                            Args... params) {
-		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
-		return FormatErrorRecursive(query_location, msg, values, params...);
-	}
-
-	template <typename... Args>
-	string FormatError(idx_t query_location, const string &msg, Args... params) {
-		vector<ExceptionFormatValue> values;
-		return FormatErrorRecursive(query_location, msg, values, params...);
-	}
-
-	static void BindLogicalType(ClientContext &context, LogicalType &type, const string &schema = "");
-
-	bool HasMatchingBinding(const string &table_name, const string &column_name, string &error_message);
-	bool HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
-	                        string &error_message);
-
-	void SetBindingMode(BindingMode mode);
-	BindingMode GetBindingMode();
-	void AddTableName(string table_name);
-	const unordered_set<string> &GetTableNames();
-
-	//! Removes the BoundParameterExpressions from Binder::parameters if they occur in 'expressions'
-	void RemoveParameters(vector<unique_ptr<Expression>> &expressions);
-
-private:
-	//! The parent binder (if any)
-	shared_ptr<Binder> parent;
-	//! The vector of active binders
-	vector<ExpressionBinder *> active_binders;
-	//! The count of bound_tables
-	idx_t bound_tables;
-	//! Whether or not the binder has any unplanned subqueries that still need to be planned
-	bool has_unplanned_subqueries = false;
-	//! Whether or not subqueries should be planned already
-	bool plan_subquery = true;
-	//! Whether CTEs should reference the parent binder (if it exists)
-	bool inherit_ctes = true;
-	//! Whether or not the binder can contain NULLs as the root of expressions
-	bool can_contain_nulls = false;
-	//! The root statement of the query that is currently being parsed
-	SQLStatement *root_statement = nullptr;
-	//! Binding mode
-	BindingMode mode = BindingMode::STANDARD_BINDING;
-	//! Table names extracted for BindingMode::EXTRACT_NAMES
-	unordered_set<string> table_names;
-	//! The set of bound views
-	unordered_set<ViewCatalogEntry *> bound_views;
-
-private:
-	//! Bind the expressions of generated columns to check for errors
-	void BindGeneratedColumns(BoundCreateTableInfo &info);
-	//! Bind the default values of the columns of a table
-	void BindDefaultValues(vector<ColumnDefinition> &columns, vector<unique_ptr<Expression>> &bound_defaults);
-	//! Bind a limit value (LIMIT or OFFSET)
-	unique_ptr<Expression> BindDelimiter(ClientContext &context, OrderBinder &order_binder,
-	                                     unique_ptr<ParsedExpression> delimiter, const LogicalType &type,
-	                                     Value &delimiter_value);
-
-	//! Move correlated expressions from the child binder to this binder
-	void MoveCorrelatedExpressions(Binder &other);
-
-	BoundStatement Bind(SelectStatement &stmt);
-	BoundStatement Bind(InsertStatement &stmt);
-	BoundStatement Bind(CopyStatement &stmt);
-	BoundStatement Bind(DeleteStatement &stmt);
-	BoundStatement Bind(UpdateStatement &stmt);
-	BoundStatement Bind(CreateStatement &stmt);
-	BoundStatement Bind(DropStatement &stmt);
-	BoundStatement Bind(AlterStatement &stmt);
-	BoundStatement Bind(TransactionStatement &stmt);
-	BoundStatement Bind(PragmaStatement &stmt);
-	BoundStatement Bind(ExplainStatement &stmt);
-	BoundStatement Bind(VacuumStatement &stmt);
-	BoundStatement Bind(RelationStatement &stmt);
-	BoundStatement Bind(ShowStatement &stmt);
-	BoundStatement Bind(CallStatement &stmt);
-	BoundStatement Bind(ExportStatement &stmt);
-	BoundStatement Bind(ExtensionStatement &stmt);
-	BoundStatement Bind(SetStatement &stmt);
-	BoundStatement Bind(LoadStatement &stmt);
-	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
-	                             idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
-	                             BoundStatement result);
-
-	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func, idx_t depth);
-
-	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
-	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);
-	unique_ptr<BoundQueryNode> BindNode(RecursiveCTENode &node);
-	unique_ptr<BoundQueryNode> BindNode(QueryNode &node);
-
-	unique_ptr<LogicalOperator> VisitQueryNode(BoundQueryNode &node, unique_ptr<LogicalOperator> root);
-	unique_ptr<LogicalOperator> CreatePlan(BoundRecursiveCTENode &node);
-	unique_ptr<LogicalOperator> CreatePlan(BoundSelectNode &statement);
-	unique_ptr<LogicalOperator> CreatePlan(BoundSetOperationNode &node);
-	unique_ptr<LogicalOperator> CreatePlan(BoundQueryNode &node);
-
-	unique_ptr<BoundTableRef> Bind(BaseTableRef &ref);
-	unique_ptr<BoundTableRef> Bind(CrossProductRef &ref);
-	unique_ptr<BoundTableRef> Bind(JoinRef &ref);
-	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, CommonTableExpressionInfo *cte = nullptr);
-	unique_ptr<BoundTableRef> Bind(TableFunctionRef &ref);
-	unique_ptr<BoundTableRef> Bind(EmptyTableRef &ref);
-	unique_ptr<BoundTableRef> Bind(ExpressionListRef &ref);
-
-	bool BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
-	                                 vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
-	                                 vector<Value> &parameters, named_parameter_map_t &named_parameters,
-	                                 unique_ptr<BoundSubqueryRef> &subquery, string &error);
-	bool BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
-	                                 unique_ptr<BoundSubqueryRef> &subquery, string &error);
-	unique_ptr<LogicalOperator> BindTableFunction(TableFunction &function, vector<Value> parameters);
-	unique_ptr<LogicalOperator>
-	BindTableFunctionInternal(TableFunction &table_function, const string &function_name, vector<Value> parameters,
-	                          named_parameter_map_t named_parameters, vector<LogicalType> input_table_types,
-	                          vector<string> input_table_names, const vector<string> &column_name_alias,
-	                          unique_ptr<ExternalDependency> external_dependency);
-
-	unique_ptr<LogicalOperator> CreatePlan(BoundBaseTableRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundCrossProductRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundJoinRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundSubqueryRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundTableFunction &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundEmptyTableRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundExpressionListRef &ref);
-	unique_ptr<LogicalOperator> CreatePlan(BoundCTERef &ref);
-
-	BoundStatement BindCopyTo(CopyStatement &stmt);
-	BoundStatement BindCopyFrom(CopyStatement &stmt);
-
-	void BindModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result);
-	void BindModifierTypes(BoundQueryNode &result, const vector<LogicalType> &sql_types, idx_t projection_index);
-
-	BoundStatement BindSummarize(ShowStatement &stmt);
-	unique_ptr<BoundResultModifier> BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod);
-	unique_ptr<BoundResultModifier> BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod);
-	unique_ptr<Expression> BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr);
-
-	unique_ptr<LogicalOperator> PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root);
-
-	void PlanSubqueries(unique_ptr<Expression> *expr, unique_ptr<LogicalOperator> *root);
-	unique_ptr<Expression> PlanSubquery(BoundSubqueryExpression &expr, unique_ptr<LogicalOperator> &root);
-
-	unique_ptr<LogicalOperator> CastLogicalOperatorToTypes(vector<LogicalType> &source_types,
-	                                                       vector<LogicalType> &target_types,
-	                                                       unique_ptr<LogicalOperator> op);
-
-	string FindBinding(const string &using_column, const string &join_side);
-	bool TryFindBinding(const string &using_column, const string &join_side, string &result);
-
-	void AddUsingBindingSet(unique_ptr<UsingColumnSet> set);
-	string RetrieveUsingBinding(Binder &current_binder, UsingColumnSet *current_set, const string &column_name,
-	                            const string &join_side, UsingColumnSet *new_set);
-
-	void AddCTEMap(CommonTableExpressionMap &cte_map);
-
-public:
-	// This should really be a private constructor, but make_shared does not allow it...
-	// If you are thinking about calling this, you should probably call Binder::CreateBinder
-	Binder(bool I_know_what_I_am_doing, ClientContext &context, shared_ptr<Binder> parent, bool inherit_ctes);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_query_node.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Bound equivalent of QueryNode
-class BoundQueryNode {
-public:
-	explicit BoundQueryNode(QueryNodeType type) : type(type) {
-	}
-	virtual ~BoundQueryNode() {
-	}
-
-	//! The type of the query node, either SetOperation or Select
-	QueryNodeType type;
-	//! The result modifiers that should be applied to this query node
-	vector<unique_ptr<BoundResultModifier>> modifiers;
-
-	//! The names returned by this QueryNode.
-	vector<string> names;
-	//! The types returned by this QueryNode.
-	vector<LogicalType> types;
-
-public:
-	virtual idx_t GetRootIndex() = 0;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-class BoundSubqueryExpression : public Expression {
-public:
-	explicit BoundSubqueryExpression(LogicalType return_type);
-
-	bool IsCorrelated() {
-		return binder->correlated_columns.size() > 0;
-	}
-
-	//! The binder used to bind the subquery node
-	shared_ptr<Binder> binder;
-	//! The bound subquery node
-	unique_ptr<BoundQueryNode> subquery;
-	//! The subquery type
-	SubqueryType subquery_type;
-	//! the child expression to compare with (in case of IN, ANY, ALL operators)
-	unique_ptr<Expression> child;
-	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators)
-	ExpressionType comparison_type;
-	//! The LogicalType of the subquery result. Only used for ANY expressions.
-	LogicalType child_type;
-	//! The target LogicalType of the subquery result (i.e. to which type it should be casted, if child_type <>
-	//! child_target). Only used for ANY expressions.
-	LogicalType child_target;
-
-public:
-	bool HasSubquery() const override {
-		return true;
-	}
-	bool IsScalar() const override {
-		return false;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-
-	bool PropagatesNullValues() const override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_unnest_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a function call that has been bound to a base function
-class BoundUnnestExpression : public Expression {
-public:
-	explicit BoundUnnestExpression(LogicalType return_type);
-
-	unique_ptr<Expression> child;
-
-public:
-	bool IsFoldable() const override;
-	string ToString() const override;
-
-	hash_t Hash() const override;
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression/bound_window_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/window_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-enum class WindowBoundary : uint8_t {
-	INVALID = 0,
-	UNBOUNDED_PRECEDING = 1,
-	UNBOUNDED_FOLLOWING = 2,
-	CURRENT_ROW_RANGE = 3,
-	CURRENT_ROW_ROWS = 4,
-	EXPR_PRECEDING_ROWS = 5,
-	EXPR_FOLLOWING_ROWS = 6,
-	EXPR_PRECEDING_RANGE = 7,
-	EXPR_FOLLOWING_RANGE = 8
-};
-
-//! The WindowExpression represents a window function in the query. They are a special case of aggregates which is why
-//! they inherit from them.
-class WindowExpression : public ParsedExpression {
-public:
-	WindowExpression(ExpressionType type, string schema_name, const string &function_name);
-
-	//! Schema of the aggregate function
-	string schema;
-	//! Name of the aggregate function
-	string function_name;
-	//! The child expression of the main window function
-	vector<unique_ptr<ParsedExpression>> children;
-	//! The set of expressions to partition by
-	vector<unique_ptr<ParsedExpression>> partitions;
-	//! The set of ordering clauses
-	vector<OrderByNode> orders;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<ParsedExpression> filter_expr;
-	//! True to ignore NULL values
-	bool ignore_nulls;
-	//! The window boundaries
-	WindowBoundary start = WindowBoundary::INVALID;
-	WindowBoundary end = WindowBoundary::INVALID;
-
-	unique_ptr<ParsedExpression> start_expr;
-	unique_ptr<ParsedExpression> end_expr;
-	//! Offset and default expressions for WINDOW_LEAD and WINDOW_LAG functions
-	unique_ptr<ParsedExpression> offset_expr;
-	unique_ptr<ParsedExpression> default_expr;
-
-public:
-	bool IsWindow() const override {
-		return true;
-	}
-
-	//! Convert the Expression to a String
-	string ToString() const override;
-
-	static bool Equals(const WindowExpression *a, const WindowExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE, class ORDER_NODE>
-	static string ToString(const T &entry, const string &schema, const string &function_name) {
-		// Start with function call
-		string result = schema.empty() ? function_name : schema + "." + function_name;
-		result += "(";
-		result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-		                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
-		// Lead/Lag extra arguments
-		if (entry.offset_expr.get()) {
-			result += ", ";
-			result += entry.offset_expr->ToString();
-		}
-		if (entry.default_expr.get()) {
-			result += ", ";
-			result += entry.default_expr->ToString();
-		}
-		// IGNORE NULLS
-		if (entry.ignore_nulls) {
-			result += " IGNORE NULLS";
-		}
-		// FILTER
-		if (entry.filter_expr) {
-			result += ") FILTER (WHERE " + entry.filter_expr->ToString();
-		}
-
-		// Over clause
-		result += ") OVER (";
-		string sep;
-
-		// Partitions
-		if (!entry.partitions.empty()) {
-			result += "PARTITION BY ";
-			result += StringUtil::Join(entry.partitions, entry.partitions.size(), ", ",
-			                           [](const unique_ptr<BASE> &partition) { return partition->ToString(); });
-			sep = " ";
-		}
-
-		// Orders
-		if (!entry.orders.empty()) {
-			result += sep;
-			result += "ORDER BY ";
-			result += StringUtil::Join(entry.orders, entry.orders.size(), ", ",
-			                           [](const ORDER_NODE &order) { return order.ToString(); });
-			sep = " ";
-		}
-
-		// Rows/Range
-		string units = "ROWS";
-		string from;
-		switch (entry.start) {
-		case WindowBoundary::CURRENT_ROW_RANGE:
-		case WindowBoundary::CURRENT_ROW_ROWS:
-			from = "CURRENT ROW";
-			units = (entry.start == WindowBoundary::CURRENT_ROW_RANGE) ? "RANGE" : "ROWS";
-			break;
-		case WindowBoundary::UNBOUNDED_PRECEDING:
-			if (entry.end != WindowBoundary::CURRENT_ROW_RANGE) {
-				from = "UNBOUNDED PRECEDING";
-			}
-			break;
-		case WindowBoundary::EXPR_PRECEDING_ROWS:
-		case WindowBoundary::EXPR_PRECEDING_RANGE:
-			from = entry.start_expr->ToString() + " PRECEDING";
-			units = (entry.start == WindowBoundary::EXPR_PRECEDING_RANGE) ? "RANGE" : "ROWS";
-			break;
-		case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		case WindowBoundary::EXPR_FOLLOWING_RANGE:
-			from = entry.start_expr->ToString() + " FOLLOWING";
-			units = (entry.start == WindowBoundary::EXPR_FOLLOWING_RANGE) ? "RANGE" : "ROWS";
-			break;
-		default:
-			throw InternalException("Unrecognized FROM in WindowExpression");
-		}
-
-		string to;
-		switch (entry.end) {
-		case WindowBoundary::CURRENT_ROW_RANGE:
-			if (entry.start != WindowBoundary::UNBOUNDED_PRECEDING) {
-				to = "CURRENT ROW";
-				units = "RANGE";
-			}
-			break;
-		case WindowBoundary::CURRENT_ROW_ROWS:
-			to = "CURRENT ROW";
-			units = "ROWS";
-			break;
-		case WindowBoundary::UNBOUNDED_PRECEDING:
-			to = "UNBOUNDED PRECEDING";
-			break;
-		case WindowBoundary::UNBOUNDED_FOLLOWING:
-			to = "UNBOUNDED FOLLOWING";
-			break;
-		case WindowBoundary::EXPR_PRECEDING_ROWS:
-		case WindowBoundary::EXPR_PRECEDING_RANGE:
-			to = entry.end_expr->ToString() + " PRECEDING";
-			units = (entry.end == WindowBoundary::EXPR_PRECEDING_RANGE) ? "RANGE" : "ROWS";
-			break;
-		case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		case WindowBoundary::EXPR_FOLLOWING_RANGE:
-			to = entry.end_expr->ToString() + " FOLLOWING";
-			units = (entry.end == WindowBoundary::EXPR_FOLLOWING_RANGE) ? "RANGE" : "ROWS";
-			break;
-		default:
-			throw InternalException("Unrecognized TO in WindowExpression");
-		}
-
-		if (!from.empty() || !to.empty()) {
-			result += sep + units;
-		}
-		if (!from.empty() && !to.empty()) {
-			result += " BETWEEN ";
-			result += from;
-			result += " AND ";
-			result += to;
-		} else if (!from.empty()) {
-			result += " ";
-			result += from;
-		} else if (!to.empty()) {
-			result += " ";
-			result += to;
-		}
-
-		result += ")";
-
-		return result;
-	}
-};
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-class AggregateFunction;
-
-class BoundWindowExpression : public Expression {
-public:
-	BoundWindowExpression(ExpressionType type, LogicalType return_type, unique_ptr<AggregateFunction> aggregate,
-	                      unique_ptr<FunctionData> bind_info);
-
-	//! The bound aggregate function
-	unique_ptr<AggregateFunction> aggregate;
-	//! The bound function info
-	unique_ptr<FunctionData> bind_info;
-	//! The child expressions of the main window function
-	vector<unique_ptr<Expression>> children;
-	//! The set of expressions to partition by
-	vector<unique_ptr<Expression>> partitions;
-	//! Statistics belonging to the partitions expressions
-	vector<unique_ptr<BaseStatistics>> partitions_stats;
-	//! The set of ordering clauses
-	vector<BoundOrderByNode> orders;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<Expression> filter_expr;
-	//! True to ignore NULL values
-	bool ignore_nulls;
-	//! The window boundaries
-	WindowBoundary start = WindowBoundary::INVALID;
-	WindowBoundary end = WindowBoundary::INVALID;
-
-	unique_ptr<Expression> start_expr;
-	unique_ptr<Expression> end_expr;
-	//! Offset and default expressions for WINDOW_LEAD and WINDOW_LAG functions
-	unique_ptr<Expression> offset_expr;
-	unique_ptr<Expression> default_expr;
-
-public:
-	bool IsWindow() const override {
-		return true;
-	}
-	bool IsFoldable() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	bool KeysAreCompatible(const BoundWindowExpression *other) const;
-	bool Equals(const BaseExpression *other) const override;
-
-	unique_ptr<Expression> Copy() override;
-};
-} // namespace duckdb
-
-
-
-#include <random>
-namespace duckdb {
-
-class AdaptiveFilter {
-public:
-	explicit AdaptiveFilter(const Expression &expr);
-	explicit AdaptiveFilter(TableFilterSet *table_filters);
-	void AdaptRuntimeStatistics(double duration);
-	vector<idx_t> permutation;
-
-private:
-	//! used for adaptive expression reordering
-	idx_t iteration_count;
-	idx_t swap_idx;
-	idx_t right_random_border;
-	idx_t observe_interval;
-	idx_t execute_interval;
-	double runtime_sum;
-	double prev_mean;
-	bool observe;
-	bool warmup;
-	vector<idx_t> swap_likeliness;
-	std::default_random_engine generator;
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-class ColumnSegment;
-class LocalTableStorage;
-class Index;
-class RowGroup;
-class UpdateSegment;
-class TableScanState;
-class ColumnSegment;
-class ValiditySegment;
-class TableFilterSet;
-
-struct SegmentScanState {
-	virtual ~SegmentScanState() {
-	}
-};
-
-struct IndexScanState {
-	virtual ~IndexScanState() {
-	}
-};
-
-typedef unordered_map<block_id_t, BufferHandle> buffer_handle_set_t;
-
-struct ColumnScanState {
-	//! The column segment that is currently being scanned
-	ColumnSegment *current = nullptr;
-	//! The current row index of the scan
-	idx_t row_index = 0;
-	//! The internal row index (i.e. the position of the SegmentScanState)
-	idx_t internal_index = 0;
-	//! Segment scan state
-	unique_ptr<SegmentScanState> scan_state;
-	//! Child states of the vector
-	vector<ColumnScanState> child_states;
-	//! Whether or not InitializeState has been called for this segment
-	bool initialized = false;
-	//! If this segment has already been checked for skipping purposes
-	bool segment_checked = false;
-
-public:
-	//! Move the scan state forward by "count" rows (including all child states)
-	void Next(idx_t count);
-	//! Move ONLY this state forward by "count" rows (i.e. not the child states)
-	void NextInternal(idx_t count);
-	//! Move the scan state forward by STANDARD_VECTOR_SIZE rows
-	void NextVector();
-};
-
-struct ColumnFetchState {
-	//! The set of pinned block handles for this set of fetches
-	buffer_handle_set_t handles;
-	//! Any child states of the fetch
-	vector<unique_ptr<ColumnFetchState>> child_states;
-
-	BufferHandle &GetOrInsertHandle(ColumnSegment &segment);
-};
-
-struct LocalScanState {
-	~LocalScanState();
-
-	void SetStorage(shared_ptr<LocalTableStorage> storage);
-	LocalTableStorage *GetStorage() {
-		return storage.get();
-	}
-
-	idx_t chunk_index = 0;
-	idx_t max_index = 0;
-	idx_t last_chunk_count = 0;
-	TableFilterSet *table_filters = nullptr;
-
-private:
-	shared_ptr<LocalTableStorage> storage;
-};
-
-class RowGroupScanState {
-public:
-	RowGroupScanState(TableScanState &parent_p) : parent(parent_p), vector_index(0), max_row(0) {
-	}
-
-	//! The parent scan state
-	TableScanState &parent;
-	//! The current row_group we are scanning
-	RowGroup *row_group = nullptr;
-	//! The vector index within the row_group
-	idx_t vector_index = 0;
-	//! The maximum row index of this row_group scan
-	idx_t max_row = 0;
-	//! Child column scans
-	unique_ptr<ColumnScanState[]> column_scans;
-};
-
-class TableScanState {
-public:
-	TableScanState() : row_group_scan_state(*this), max_row(0) {};
-
-	//! The row_group scan state
-	RowGroupScanState row_group_scan_state;
-	//! The total maximum row index
-	idx_t max_row = 0;
-	//! The column identifiers of the scan
-	vector<column_t> column_ids;
-	//! The table filters (if any)
-	TableFilterSet *table_filters = nullptr;
-	//! Adaptive filter info (if any)
-	unique_ptr<AdaptiveFilter> adaptive_filter;
-	//! Transaction-local scan state
-	LocalScanState local_state;
-};
-
-class CreateIndexScanState : public TableScanState {
-public:
-	vector<unique_ptr<StorageLockKey>> locks;
-	unique_lock<mutex> append_lock;
-	unique_lock<mutex> delete_lock;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class DataTable;
-class WriteAheadLog;
-struct TableAppendState;
-
-class LocalTableStorage : public std::enable_shared_from_this<LocalTableStorage> {
-public:
-	explicit LocalTableStorage(DataTable &table);
-	~LocalTableStorage();
-
-	DataTable &table;
-
-	Allocator &allocator;
-	//! The main chunk collection holding the data
-	ChunkCollection collection;
-	//! The set of unique indexes
-	vector<unique_ptr<Index>> indexes;
-	//! The set of deleted entries
-	unordered_map<idx_t, unique_ptr<bool[]>> deleted_entries;
-	//! The number of deleted rows
-	idx_t deleted_rows;
-	//! The number of active scans
-	atomic<idx_t> active_scans;
-
-public:
-	void InitializeScan(LocalScanState &state, TableFilterSet *table_filters = nullptr);
-	idx_t EstimatedSize();
-
-	void Clear();
-};
-
-//! The LocalStorage class holds appends that have not been committed yet
-class LocalStorage {
-public:
-	struct CommitState {
-		unordered_map<DataTable *, unique_ptr<TableAppendState>> append_states;
-	};
-
-public:
-	explicit LocalStorage(Transaction &transaction) : transaction(transaction) {
-	}
-
-	//! Initialize a scan of the local storage
-	void InitializeScan(DataTable *table, LocalScanState &state, TableFilterSet *table_filters);
-	//! Scan
-	void Scan(LocalScanState &state, const vector<column_t> &column_ids, DataChunk &result);
-
-	//! Append a chunk to the local storage
-	void Append(DataTable *table, DataChunk &chunk);
-	//! Delete a set of rows from the local storage
-	idx_t Delete(DataTable *table, Vector &row_ids, idx_t count);
-	//! Update a set of rows in the local storage
-	void Update(DataTable *table, Vector &row_ids, const vector<column_t> &column_ids, DataChunk &data);
-
-	//! Commits the local storage, writing it to the WAL and completing the commit
-	void Commit(LocalStorage::CommitState &commit_state, Transaction &transaction, WriteAheadLog *log,
-	            transaction_t commit_id);
-
-	bool ChangesMade() noexcept {
-		return table_storage.size() > 0;
-	}
-	idx_t EstimatedSize();
-
-	bool Find(DataTable *table) {
-		return table_storage.find(table) != table_storage.end();
-	}
-
-	idx_t AddedRows(DataTable *table) {
-		auto entry = table_storage.find(table);
-		if (entry == table_storage.end()) {
-			return 0;
-		}
-		return entry->second->collection.Count() - entry->second->deleted_rows;
-	}
-
-	void AddColumn(DataTable *old_dt, DataTable *new_dt, ColumnDefinition &new_column, Expression *default_value);
-	void ChangeType(DataTable *old_dt, DataTable *new_dt, idx_t changed_idx, const LogicalType &target_type,
-	                const vector<column_t> &bound_columns, Expression &cast_expr);
-
-	void FetchChunk(DataTable *table, Vector &row_ids, idx_t count, DataChunk &chunk);
-	vector<unique_ptr<Index>> &GetIndexes(DataTable *table);
-
-private:
-	LocalTableStorage *GetStorage(DataTable *table);
-
-	template <class T>
-	bool ScanTableStorage(DataTable &table, LocalTableStorage &storage, T &&fun);
-
-private:
-	Transaction &transaction;
-	unordered_map<DataTable *, shared_ptr<LocalTableStorage>> table_storage;
-
-	void Flush(DataTable &table, LocalTableStorage &storage);
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class SequenceCatalogEntry;
-
-class ColumnData;
-class ClientContext;
-class CatalogEntry;
-class DataTable;
-class DatabaseInstance;
-class WriteAheadLog;
-
-class ChunkVectorInfo;
-
-struct DeleteInfo;
-struct UpdateInfo;
-
-//! The transaction object holds information about a currently running or past
-//! transaction
-
-class Transaction {
-public:
-	Transaction(weak_ptr<ClientContext> context, transaction_t start_time, transaction_t transaction_id,
-	            timestamp_t start_timestamp, idx_t catalog_version);
-
-	weak_ptr<ClientContext> context;
-	//! The start timestamp of this transaction
-	transaction_t start_time;
-	//! The transaction id of this transaction
-	transaction_t transaction_id;
-	//! The commit id of this transaction, if it has successfully been committed
-	transaction_t commit_id;
-	//! Highest active query when the transaction finished, used for cleaning up
-	transaction_t highest_active_query;
-	//! The current active query for the transaction. Set to MAXIMUM_QUERY_ID if
-	//! no query is active.
-	atomic<transaction_t> active_query;
-	//! The timestamp when the transaction started
-	timestamp_t start_timestamp;
-	//! The catalog version when the transaction was started
-	idx_t catalog_version;
-	//! The set of uncommitted appends for the transaction
-	LocalStorage storage;
-	//! Map of all sequences that were used during the transaction and the value they had in this transaction
-	unordered_map<SequenceCatalogEntry *, SequenceValue> sequence_usage;
-	//! Whether or not the transaction has been invalidated
-	bool is_invalidated;
-
-public:
-	static Transaction &GetTransaction(ClientContext &context);
-
-	void PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data = nullptr, idx_t extra_data_size = 0);
-
-	//! Commit the current transaction with the given commit identifier. Returns an error message if the transaction
-	//! commit failed, or an empty string if the commit was sucessful
-	string Commit(DatabaseInstance &db, transaction_t commit_id, bool checkpoint) noexcept;
-	//! Returns whether or not a commit of this transaction should trigger an automatic checkpoint
-	bool AutomaticCheckpoint(DatabaseInstance &db);
-
-	//! Rollback
-	void Rollback() noexcept {
-		undo_buffer.Rollback();
-	}
-	//! Cleanup the undo buffer
-	void Cleanup() {
-		undo_buffer.Cleanup();
-	}
-
-	void Invalidate() {
-		is_invalidated = true;
-	}
-	bool IsInvalidated() {
-		return is_invalidated;
-	}
-	bool ChangesMade();
-
-	timestamp_t GetCurrentTransactionStartTimestamp() {
-		return start_timestamp;
-	}
-
-	void PushDelete(DataTable *table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row);
-	void PushAppend(DataTable *table, idx_t row_start, idx_t row_count);
-	UpdateInfo *CreateUpdateInfo(idx_t type_size, idx_t entries);
-
-private:
-	//! The undo buffer is used to store old versions of rows that are updated
-	//! or deleted
-	UndoBuffer undo_buffer;
-
-	Transaction(const Transaction &) = delete;
-};
-
-} // namespace duckdb
-
-#include <functional>
-#include <memory>
-
-namespace duckdb {
-struct AlterInfo;
-
-class ClientContext;
-
-typedef unordered_map<CatalogSet *, unique_lock<mutex>> set_lock_map_t;
-
-struct MappingValue {
-	explicit MappingValue(idx_t index_) : index(index_), timestamp(0), deleted(false), parent(nullptr) {
-	}
-
-	idx_t index;
-	transaction_t timestamp;
-	bool deleted;
-	unique_ptr<MappingValue> child;
-	MappingValue *parent;
-};
-
-//! The Catalog Set stores (key, value) map of a set of CatalogEntries
-class CatalogSet {
-	friend class DependencyManager;
-	friend class EntryDropper;
-
-public:
-	DUCKDB_API explicit CatalogSet(Catalog &catalog, unique_ptr<DefaultGenerator> defaults = nullptr);
-
-	//! Create an entry in the catalog set. Returns whether or not it was
-	//! successful.
-	DUCKDB_API bool CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-	                            unordered_set<CatalogEntry *> &dependencies);
-
-	DUCKDB_API bool AlterEntry(ClientContext &context, const string &name, AlterInfo *alter_info);
-
-	DUCKDB_API bool DropEntry(ClientContext &context, const string &name, bool cascade);
-
-	bool AlterOwnership(ClientContext &context, ChangeOwnershipInfo *info);
-
-	void CleanupEntry(CatalogEntry *catalog_entry);
-
-	//! Returns the entry with the specified name
-	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, const string &name);
-
-	//! Gets the entry that is most similar to the given name (i.e. smallest levenshtein distance), or empty string if
-	//! none is found. The returned pair consists of the entry name and the distance (smaller means closer).
-	pair<string, idx_t> SimilarEntry(ClientContext &context, const string &name);
-
-	//! Rollback <entry> to be the currently valid entry for a certain catalog
-	//! entry
-	void Undo(CatalogEntry *entry);
-
-	//! Scan the catalog set, invoking the callback method for every committed entry
-	DUCKDB_API void Scan(const std::function<void(CatalogEntry *)> &callback);
-	//! Scan the catalog set, invoking the callback method for every entry
-	DUCKDB_API void Scan(ClientContext &context, const std::function<void(CatalogEntry *)> &callback);
-
-	template <class T>
-	vector<T *> GetEntries(ClientContext &context) {
-		vector<T *> result;
-		Scan(context, [&](CatalogEntry *entry) { result.push_back((T *)entry); });
-		return result;
-	}
-
-	DUCKDB_API static bool HasConflict(ClientContext &context, transaction_t timestamp);
-	DUCKDB_API static bool UseTimestamp(ClientContext &context, transaction_t timestamp);
-
-	CatalogEntry *GetEntryFromIndex(idx_t index);
-	void UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp);
-
-private:
-	//! Adjusts table dependencies on the event of an UNDO
-	void AdjustTableDependencies(CatalogEntry *entry);
-	//! Adjust one dependency
-	void AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table, ColumnDefinition &column, bool remove);
-	//! Adjust User dependency
-	void AdjustUserDependency(CatalogEntry *entry, ColumnDefinition &column, bool remove);
-	//! Given a root entry, gets the entry valid for this transaction
-	CatalogEntry *GetEntryForTransaction(ClientContext &context, CatalogEntry *current);
-	CatalogEntry *GetCommittedEntry(CatalogEntry *current);
-	bool GetEntryInternal(ClientContext &context, const string &name, idx_t &entry_index, CatalogEntry *&entry);
-	bool GetEntryInternal(ClientContext &context, idx_t entry_index, CatalogEntry *&entry);
-	//! Drops an entry from the catalog set; must hold the catalog_lock to safely call this
-	void DropEntryInternal(ClientContext &context, idx_t entry_index, CatalogEntry &entry, bool cascade);
-	CatalogEntry *CreateEntryInternal(ClientContext &context, unique_ptr<CatalogEntry> entry);
-	MappingValue *GetMapping(ClientContext &context, const string &name, bool get_latest = false);
-	void PutMapping(ClientContext &context, const string &name, idx_t entry_index);
-	void DeleteMapping(ClientContext &context, const string &name);
-	void DropEntryDependencies(ClientContext &context, idx_t entry_index, CatalogEntry &entry, bool cascade);
-
-	//! Create all default entries
-	void CreateDefaultEntries(ClientContext &context, unique_lock<mutex> &lock);
-	//! Attempt to create a default entry with the specified name. Returns the entry if successful, nullptr otherwise.
-	CatalogEntry *CreateDefaultEntry(ClientContext &context, const string &name, unique_lock<mutex> &lock);
-
-private:
-	Catalog &catalog;
-	//! The catalog lock is used to make changes to the data
-	mutex catalog_lock;
-	//! Mapping of string to catalog entry
-	case_insensitive_map_t<unique_ptr<MappingValue>> mapping;
-	//! The set of catalog entries
-	unordered_map<idx_t, unique_ptr<CatalogEntry>> entries;
-	//! The current catalog entry index
-	idx_t current_entry = 0;
-	//! The generator used to generate default internal entries
-	unique_ptr<DefaultGenerator> defaults;
-};
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class ClientContext;
-
-class StandardEntry;
-class TableCatalogEntry;
-class TableFunctionCatalogEntry;
-class SequenceCatalogEntry;
-class Serializer;
-class Deserializer;
-
-enum class OnCreateConflict : uint8_t;
-
-struct AlterTableInfo;
-struct CreateIndexInfo;
-struct CreateFunctionInfo;
-struct CreateCollationInfo;
-struct CreateViewInfo;
-struct BoundCreateTableInfo;
-struct CreatePragmaFunctionInfo;
-struct CreateSequenceInfo;
-struct CreateSchemaInfo;
-struct CreateTableFunctionInfo;
-struct CreateCopyFunctionInfo;
-struct CreateTypeInfo;
-
-struct DropInfo;
-
-//! A schema in the catalog
-class SchemaCatalogEntry : public CatalogEntry {
-	friend class Catalog;
-
-public:
-	SchemaCatalogEntry(Catalog *catalog, string name, bool is_internal);
-
-private:
-	//! The catalog set holding the tables
-	CatalogSet tables;
-	//! The catalog set holding the indexes
-	CatalogSet indexes;
-	//! The catalog set holding the table functions
-	CatalogSet table_functions;
-	//! The catalog set holding the copy functions
-	CatalogSet copy_functions;
-	//! The catalog set holding the pragma functions
-	CatalogSet pragma_functions;
-	//! The catalog set holding the scalar and aggregate functions
-	CatalogSet functions;
-	//! The catalog set holding the sequences
-	CatalogSet sequences;
-	//! The catalog set holding the collations
-	CatalogSet collations;
-	//! The catalog set holding the types
-	CatalogSet types;
-
-public:
-	//! Scan the specified catalog set, invoking the callback method for every entry
-	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry *)> &callback);
-	//! Scan the specified catalog set, invoking the callback method for every committed entry
-	void Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback);
-
-	//! Serialize the meta information of the SchemaCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
-	//! Deserializes to a CreateSchemaInfo
-	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &source);
-
-	string ToSQL() override;
-
-	//! Creates an index with the given name in the schema
-	CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table);
-
-private:
-	//! Create a scalar or aggregate function within the given schema
-	CatalogEntry *CreateFunction(ClientContext &context, CreateFunctionInfo *info);
-	//! Creates a table with the given name in the schema
-	CatalogEntry *CreateTable(ClientContext &context, BoundCreateTableInfo *info);
-	//! Creates a view with the given name in the schema
-	CatalogEntry *CreateView(ClientContext &context, CreateViewInfo *info);
-	//! Creates a sequence with the given name in the schema
-	CatalogEntry *CreateSequence(ClientContext &context, CreateSequenceInfo *info);
-	//! Create a table function within the given schema
-	CatalogEntry *CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info);
-	//! Create a copy function within the given schema
-	CatalogEntry *CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info);
-	//! Create a pragma function within the given schema
-	CatalogEntry *CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info);
-	//! Create a collation within the given schema
-	CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
-	//! Create a enum within the given schema
-	CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
-
-	//! Drops an entry from the schema
-	void DropEntry(ClientContext &context, DropInfo *info);
-
-	//! Append a scalar or aggregate function within the given schema
-	CatalogEntry *AddFunction(ClientContext &context, CreateFunctionInfo *info);
-
-	//! Alters a catalog entry
-	void Alter(ClientContext &context, AlterInfo *info);
-
-	//! Add a catalog entry to this schema
-	CatalogEntry *AddEntry(ClientContext &context, unique_ptr<StandardEntry> entry, OnCreateConflict on_conflict);
-	//! Add a catalog entry to this schema
-	CatalogEntry *AddEntry(ClientContext &context, unique_ptr<StandardEntry> entry, OnCreateConflict on_conflict,
-	                       unordered_set<CatalogEntry *> dependencies);
-
-	//! Get the catalog set for the specified type
-	CatalogSet &GetCatalogSet(CatalogType type);
-};
-} // namespace duckdb
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/deque.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <deque>
-
-namespace duckdb {
-using std::deque;
-}
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/progress_bar.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//
-//                         DuckDB
-//
-// duckdb.h
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-// duplicate of duckdb/main/winapi.hpp
-#ifndef DUCKDB_API
-#ifdef _WIN32
-#if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
-#define DUCKDB_API __declspec(dllexport)
-#else
-#define DUCKDB_API __declspec(dllimport)
-#endif
-#else
-#define DUCKDB_API
-#endif
-#endif
-
-// duplicate of duckdb/main/winapi.hpp
-#ifndef DUCKDB_EXTENSION_API
-#ifdef _WIN32
-#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
-#define DUCKDB_EXTENSION_API __declspec(dllexport)
-#else
-#define DUCKDB_EXTENSION_API
-#endif
-#else
-#define DUCKDB_EXTENSION_API __attribute__((visibility("default")))
-#endif
-#endif
-
-// duplicate of duckdb/common/constants.hpp
-#ifndef DUCKDB_API_0_3_1
-#define DUCKDB_API_0_3_1 1
-#endif
-#ifndef DUCKDB_API_0_3_2
-#define DUCKDB_API_0_3_2 2
-#endif
-#ifndef DUCKDB_API_LATEST
-#define DUCKDB_API_LATEST DUCKDB_API_0_3_2
-#endif
-
-#ifndef DUCKDB_API_VERSION
-#define DUCKDB_API_VERSION DUCKDB_API_LATEST
-#endif
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//===--------------------------------------------------------------------===//
-// Type Information
-//===--------------------------------------------------------------------===//
-typedef uint64_t idx_t;
-
-typedef enum DUCKDB_TYPE {
-	DUCKDB_TYPE_INVALID = 0,
-	// bool
-	DUCKDB_TYPE_BOOLEAN,
-	// int8_t
-	DUCKDB_TYPE_TINYINT,
-	// int16_t
-	DUCKDB_TYPE_SMALLINT,
-	// int32_t
-	DUCKDB_TYPE_INTEGER,
-	// int64_t
-	DUCKDB_TYPE_BIGINT,
-	// uint8_t
-	DUCKDB_TYPE_UTINYINT,
-	// uint16_t
-	DUCKDB_TYPE_USMALLINT,
-	// uint32_t
-	DUCKDB_TYPE_UINTEGER,
-	// uint64_t
-	DUCKDB_TYPE_UBIGINT,
-	// float
-	DUCKDB_TYPE_FLOAT,
-	// double
-	DUCKDB_TYPE_DOUBLE,
-	// duckdb_timestamp, in microseconds
-	DUCKDB_TYPE_TIMESTAMP,
-	// duckdb_date
-	DUCKDB_TYPE_DATE,
-	// duckdb_time
-	DUCKDB_TYPE_TIME,
-	// duckdb_interval
-	DUCKDB_TYPE_INTERVAL,
-	// duckdb_hugeint
-	DUCKDB_TYPE_HUGEINT,
-	// const char*
-	DUCKDB_TYPE_VARCHAR,
-	// duckdb_blob
-	DUCKDB_TYPE_BLOB,
-	// decimal
-	DUCKDB_TYPE_DECIMAL,
-	// duckdb_timestamp, in seconds
-	DUCKDB_TYPE_TIMESTAMP_S,
-	// duckdb_timestamp, in milliseconds
-	DUCKDB_TYPE_TIMESTAMP_MS,
-	// duckdb_timestamp, in nanoseconds
-	DUCKDB_TYPE_TIMESTAMP_NS,
-	// enum type, only useful as logical type
-	DUCKDB_TYPE_ENUM,
-	// list type, only useful as logical type
-	DUCKDB_TYPE_LIST,
-	// struct type, only useful as logical type
-	DUCKDB_TYPE_STRUCT,
-	// map type, only useful as logical type
-	DUCKDB_TYPE_MAP,
-	// duckdb_hugeint
-	DUCKDB_TYPE_UUID,
-	// const char*
-	DUCKDB_TYPE_JSON,
-} duckdb_type;
-
-//! Days are stored as days since 1970-01-01
-//! Use the duckdb_from_date/duckdb_to_date function to extract individual information
-typedef struct {
-	int32_t days;
-} duckdb_date;
-
-typedef struct {
-	int32_t year;
-	int8_t month;
-	int8_t day;
-} duckdb_date_struct;
-
-//! Time is stored as microseconds since 00:00:00
-//! Use the duckdb_from_time/duckdb_to_time function to extract individual information
-typedef struct {
-	int64_t micros;
-} duckdb_time;
-
-typedef struct {
-	int8_t hour;
-	int8_t min;
-	int8_t sec;
-	int32_t micros;
-} duckdb_time_struct;
-
-//! Timestamps are stored as microseconds since 1970-01-01
-//! Use the duckdb_from_timestamp/duckdb_to_timestamp function to extract individual information
-typedef struct {
-	int64_t micros;
-} duckdb_timestamp;
-
-typedef struct {
-	duckdb_date_struct date;
-	duckdb_time_struct time;
-} duckdb_timestamp_struct;
-
-typedef struct {
-	int32_t months;
-	int32_t days;
-	int64_t micros;
-} duckdb_interval;
-
-//! Hugeints are composed in a (lower, upper) component
-//! The value of the hugeint is upper * 2^64 + lower
-//! For easy usage, the functions duckdb_hugeint_to_double/duckdb_double_to_hugeint are recommended
-typedef struct {
-	uint64_t lower;
-	int64_t upper;
-} duckdb_hugeint;
-
-typedef struct {
-	uint8_t width;
-	uint8_t scale;
-
-	duckdb_hugeint value;
-} duckdb_decimal;
-
-typedef struct {
-	void *data;
-	idx_t size;
-} duckdb_blob;
-
-typedef struct {
-#if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
-	void *data;
-	bool *nullmask;
-	duckdb_type type;
-	char *name;
-#else
-	// deprecated, use duckdb_column_data
-	void *__deprecated_data;
-	// deprecated, use duckdb_nullmask_data
-	bool *__deprecated_nullmask;
-	// deprecated, use duckdb_column_type
-	duckdb_type __deprecated_type;
-	// deprecated, use duckdb_column_name
-	char *__deprecated_name;
-#endif
-	void *internal_data;
-} duckdb_column;
-
-typedef struct {
-#if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
-	idx_t column_count;
-	idx_t row_count;
-	idx_t rows_changed;
-	duckdb_column *columns;
-	char *error_message;
-#else
-	// deprecated, use duckdb_column_count
-	idx_t __deprecated_column_count;
-	// deprecated, use duckdb_row_count
-	idx_t __deprecated_row_count;
-	// deprecated, use duckdb_rows_changed
-	idx_t __deprecated_rows_changed;
-	// deprecated, use duckdb_column_ family of functions
-	duckdb_column *__deprecated_columns;
-	// deprecated, use duckdb_result_error
-	char *__deprecated_error_message;
-#endif
-	void *internal_data;
-} duckdb_result;
-
-typedef void *duckdb_database;
-typedef void *duckdb_connection;
-typedef void *duckdb_prepared_statement;
-typedef void *duckdb_appender;
-typedef void *duckdb_arrow;
-typedef void *duckdb_config;
-typedef void *duckdb_arrow_schema;
-typedef void *duckdb_arrow_array;
-typedef void *duckdb_logical_type;
-typedef void *duckdb_data_chunk;
-typedef void *duckdb_vector;
-typedef void *duckdb_value;
-
-typedef enum { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;
-
-//===--------------------------------------------------------------------===//
-// Open/Connect
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a new database or opens an existing database file stored at the the given path.
-If no path is given a new in-memory database is created instead.
-
-* path: Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
-* out_database: The result database object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_open(const char *path, duckdb_database *out_database);
-
-/*!
-Extended version of duckdb_open. Creates a new database or opens an existing database file stored at the the given path.
-
-* path: Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
-* out_database: The result database object.
-* config: (Optional) configuration used to start up the database system.
-* out_error: If set and the function returns DuckDBError, this will contain the reason why the start-up failed.
-Note that the error must be freed using `duckdb_free`.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_open_ext(const char *path, duckdb_database *out_database, duckdb_config config,
-                                        char **out_error);
-
-/*!
-Closes the specified database and de-allocates all memory allocated for that database.
-This should be called after you are done with any database allocated through `duckdb_open`.
-Note that failing to call `duckdb_close` (in case of e.g. a program crash) will not cause data corruption.
-Still it is recommended to always correctly close a database object after you are done with it.
-
-* database: The database object to shut down.
-*/
-DUCKDB_API void duckdb_close(duckdb_database *database);
-
-/*!
-Opens a connection to a database. Connections are required to query the database, and store transactional state
-associated with the connection.
-
-* database: The database file to connect to.
-* out_connection: The result connection object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);
-
-/*!
-Closes the specified connection and de-allocates all memory allocated for that connection.
-
-* connection: The connection to close.
-*/
-DUCKDB_API void duckdb_disconnect(duckdb_connection *connection);
-
-//===--------------------------------------------------------------------===//
-// Configuration
-//===--------------------------------------------------------------------===//
-/*!
-Initializes an empty configuration object that can be used to provide start-up options for the DuckDB instance
-through `duckdb_open_ext`.
-
-This will always succeed unless there is a malloc failure.
-
-* out_config: The result configuration object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_create_config(duckdb_config *out_config);
-
-/*!
-This returns the total amount of configuration options available for usage with `duckdb_get_config_flag`.
-
-This should not be called in a loop as it internally loops over all the options.
-
-* returns: The amount of config options available.
-*/
-DUCKDB_API size_t duckdb_config_count();
-
-/*!
-Obtains a human-readable name and description of a specific configuration option. This can be used to e.g.
-display configuration options. This will succeed unless `index` is out of range (i.e. `>= duckdb_config_count`).
-
-The result name or description MUST NOT be freed.
-
-* index: The index of the configuration option (between 0 and `duckdb_config_count`)
-* out_name: A name of the configuration flag.
-* out_description: A description of the configuration flag.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description);
-
-/*!
-Sets the specified option for the specified configuration. The configuration option is indicated by name.
-To obtain a list of config options, see `duckdb_get_config_flag`.
-
-In the source code, configuration options are defined in `config.cpp`.
-
-This can fail if either the name is invalid, or if the value provided for the option is invalid.
-
-* duckdb_config: The configuration object to set the option on.
-* name: The name of the configuration flag to set.
-* option: The value to set the configuration flag to.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_set_config(duckdb_config config, const char *name, const char *option);
-
-/*!
-Destroys the specified configuration option and de-allocates all memory allocated for the object.
-
-* config: The configuration object to destroy.
-*/
-DUCKDB_API void duckdb_destroy_config(duckdb_config *config);
-
-//===--------------------------------------------------------------------===//
-// Query Execution
-//===--------------------------------------------------------------------===//
-/*!
-Executes a SQL query within a connection and stores the full (materialized) result in the out_result pointer.
-If the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling
-`duckdb_result_error`.
-
-Note that after running `duckdb_query`, `duckdb_destroy_result` must be called on the result object even if the
-query fails, otherwise the error stored within the result will not be freed correctly.
-
-* connection: The connection to perform the query in.
-* query: The SQL query to run.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out_result);
-
-/*!
-Closes the result and de-allocates all memory allocated for that connection.
-
-* result: The result to destroy.
-*/
-DUCKDB_API void duckdb_destroy_result(duckdb_result *result);
-
-/*!
-Returns the column name of the specified column. The result should not need be freed; the column names will
-automatically be destroyed when the result is destroyed.
-
-Returns `NULL` if the column is out of range.
-
-* result: The result object to fetch the column name from.
-* col: The column index.
-* returns: The column name of the specified column.
-*/
-DUCKDB_API const char *duckdb_column_name(duckdb_result *result, idx_t col);
-
-/*!
-Returns the column type of the specified column.
-
-Returns `DUCKDB_TYPE_INVALID` if the column is out of range.
-
-* result: The result object to fetch the column type from.
-* col: The column index.
-* returns: The column type of the specified column.
-*/
-DUCKDB_API duckdb_type duckdb_column_type(duckdb_result *result, idx_t col);
-
-/*!
-Returns the logical column type of the specified column.
-
-The return type of this call should be destroyed with `duckdb_destroy_logical_type`.
-
-Returns `NULL` if the column is out of range.
-
-* result: The result object to fetch the column type from.
-* col: The column index.
-* returns: The logical column type of the specified column.
-*/
-DUCKDB_API duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col);
-
-/*!
-Returns the number of columns present in a the result object.
-
-* result: The result object.
-* returns: The number of columns present in the result object.
-*/
-DUCKDB_API idx_t duckdb_column_count(duckdb_result *result);
-
-/*!
-Returns the number of rows present in a the result object.
-
-* result: The result object.
-* returns: The number of rows present in the result object.
-*/
-DUCKDB_API idx_t duckdb_row_count(duckdb_result *result);
-
-/*!
-Returns the number of rows changed by the query stored in the result. This is relevant only for INSERT/UPDATE/DELETE
-queries. For other queries the rows_changed will be 0.
-
-* result: The result object.
-* returns: The number of rows changed.
-*/
-DUCKDB_API idx_t duckdb_rows_changed(duckdb_result *result);
-
-/*!
-**DEPRECATED**: Prefer using `duckdb_result_get_chunk` instead.
-
-Returns the data of a specific column of a result in columnar format.
-
-The function returns a dense array which contains the result data. The exact type stored in the array depends on the
-corresponding duckdb_type (as provided by `duckdb_column_type`). For the exact type by which the data should be
-accessed, see the comments in [the types section](types) or the `DUCKDB_TYPE` enum.
-
-For example, for a column of type `DUCKDB_TYPE_INTEGER`, rows can be accessed in the following manner:
-```c
-int32_t *data = (int32_t *) duckdb_column_data(&result, 0);
-printf("Data for row %d: %d\n", row, data[row]);
-```
-
-* result: The result object to fetch the column data from.
-* col: The column index.
-* returns: The column data of the specified column.
-*/
-DUCKDB_API void *duckdb_column_data(duckdb_result *result, idx_t col);
-
-/*!
-**DEPRECATED**: Prefer using `duckdb_result_get_chunk` instead.
-
-Returns the nullmask of a specific column of a result in columnar format. The nullmask indicates for every row
-whether or not the corresponding row is `NULL`. If a row is `NULL`, the values present in the array provided
-by `duckdb_column_data` are undefined.
-
-```c
-int32_t *data = (int32_t *) duckdb_column_data(&result, 0);
-bool *nullmask = duckdb_nullmask_data(&result, 0);
-if (nullmask[row]) {
-    printf("Data for row %d: NULL\n", row);
-} else {
-    printf("Data for row %d: %d\n", row, data[row]);
-}
-```
-
-* result: The result object to fetch the nullmask from.
-* col: The column index.
-* returns: The nullmask of the specified column.
-*/
-DUCKDB_API bool *duckdb_nullmask_data(duckdb_result *result, idx_t col);
-
-/*!
-Returns the error message contained within the result. The error is only set if `duckdb_query` returns `DuckDBError`.
-
-The result of this function must not be freed. It will be cleaned up when `duckdb_destroy_result` is called.
-
-* result: The result object to fetch the error from.
-* returns: The error of the result.
-*/
-DUCKDB_API const char *duckdb_result_error(duckdb_result *result);
-
-//===--------------------------------------------------------------------===//
-// Result Functions
-//===--------------------------------------------------------------------===//
-
-/*!
-Fetches a data chunk from the duckdb_result. This function should be called repeatedly until the result is exhausted.
-
-This function supersedes all `duckdb_value` functions, as well as the `duckdb_column_data` and `duckdb_nullmask_data`
-functions. It results in significantly better performance, and should be preferred in newer code-bases.
-
-If this function is used, none of the other result functions can be used and vice versa (i.e. this function cannot be
-mixed with the legacy result functions).
-
-Use `duckdb_result_chunk_count` to figure out how many chunks there are in the result.
-
-* result: The result object to fetch the data chunk from.
-* chunk_index: The chunk index to fetch from.
-* returns: The resulting data chunk. Returns `NULL` if the chunk index is out of bounds.
-*/
-DUCKDB_API duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_index);
-
-/*!
-Returns the number of data chunks present in the result.
-
-* result: The result object
-* returns: The resulting data chunk. Returns `NULL` if the chunk index is out of bounds.
-*/
-DUCKDB_API idx_t duckdb_result_chunk_count(duckdb_result result);
-
-// Safe fetch functions
-// These functions will perform conversions if necessary.
-// On failure (e.g. if conversion cannot be performed or if the value is NULL) a default value is returned.
-// Note that these functions are slow since they perform bounds checking and conversion
-// For fast access of values prefer using `duckdb_result_get_chunk`
-
-/*!
- * returns: The boolean value at the specified location, or false if the value cannot be converted.
- */
-DUCKDB_API bool duckdb_value_boolean(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The int8_t value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API int8_t duckdb_value_int8(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The int16_t value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API int16_t duckdb_value_int16(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The int32_t value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API int32_t duckdb_value_int32(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The int64_t value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The duckdb_hugeint value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The duckdb_decimal value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The uint8_t value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API uint8_t duckdb_value_uint8(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The uint16_t value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API uint16_t duckdb_value_uint16(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The uint32_t value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API uint32_t duckdb_value_uint32(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The uint64_t value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API uint64_t duckdb_value_uint64(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The float value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API float duckdb_value_float(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The double value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API double duckdb_value_double(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The duckdb_date value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API duckdb_date duckdb_value_date(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The duckdb_time value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API duckdb_time duckdb_value_time(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The duckdb_timestamp value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API duckdb_timestamp duckdb_value_timestamp(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: The duckdb_interval value at the specified location, or 0 if the value cannot be converted.
- */
-DUCKDB_API duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-* returns: The char* value at the specified location, or nullptr if the value cannot be converted.
-The result must be freed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-* returns: The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.
-If the column is NOT a VARCHAR column this function will return NULL.
-
-The result must NOT be freed.
-*/
-DUCKDB_API char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
-* returns: The duckdb_blob value at the specified location. Returns a blob with blob.data set to nullptr if the
-value cannot be converted. The resulting "blob.data" must be freed with `duckdb_free.`
-*/
-DUCKDB_API duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row);
-
-/*!
- * returns: Returns true if the value at the specified index is NULL, and false otherwise.
- */
-DUCKDB_API bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row);
-
-//===--------------------------------------------------------------------===//
-// Helpers
-//===--------------------------------------------------------------------===//
-/*!
-Allocate `size` bytes of memory using the duckdb internal malloc function. Any memory allocated in this manner
-should be freed using `duckdb_free`.
-
-* size: The number of bytes to allocate.
-* returns: A pointer to the allocated memory region.
-*/
-DUCKDB_API void *duckdb_malloc(size_t size);
-
-/*!
-Free a value returned from `duckdb_malloc`, `duckdb_value_varchar` or `duckdb_value_blob`.
-
-* ptr: The memory region to de-allocate.
-*/
-DUCKDB_API void duckdb_free(void *ptr);
-
-/*!
-The internal vector size used by DuckDB.
-This is the amount of tuples that will fit into a data chunk created by `duckdb_create_data_chunk`.
-
-* returns: The vector size.
-*/
-DUCKDB_API idx_t duckdb_vector_size();
-
-//===--------------------------------------------------------------------===//
-// Date/Time/Timestamp Helpers
-//===--------------------------------------------------------------------===//
-/*!
-Decompose a `duckdb_date` object into year, month and date (stored as `duckdb_date_struct`).
-
-* date: The date object, as obtained from a `DUCKDB_TYPE_DATE` column.
-* returns: The `duckdb_date_struct` with the decomposed elements.
-*/
-DUCKDB_API duckdb_date_struct duckdb_from_date(duckdb_date date);
-
-/*!
-Re-compose a `duckdb_date` from year, month and date (`duckdb_date_struct`).
-
-* date: The year, month and date stored in a `duckdb_date_struct`.
-* returns: The `duckdb_date` element.
-*/
-DUCKDB_API duckdb_date duckdb_to_date(duckdb_date_struct date);
-
-/*!
-Decompose a `duckdb_time` object into hour, minute, second and microsecond (stored as `duckdb_time_struct`).
-
-* time: The time object, as obtained from a `DUCKDB_TYPE_TIME` column.
-* returns: The `duckdb_time_struct` with the decomposed elements.
-*/
-DUCKDB_API duckdb_time_struct duckdb_from_time(duckdb_time time);
-
-/*!
-Re-compose a `duckdb_time` from hour, minute, second and microsecond (`duckdb_time_struct`).
-
-* time: The hour, minute, second and microsecond in a `duckdb_time_struct`.
-* returns: The `duckdb_time` element.
-*/
-DUCKDB_API duckdb_time duckdb_to_time(duckdb_time_struct time);
-
-/*!
-Decompose a `duckdb_timestamp` object into a `duckdb_timestamp_struct`.
-
-* ts: The ts object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.
-* returns: The `duckdb_timestamp_struct` with the decomposed elements.
-*/
-DUCKDB_API duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts);
-
-/*!
-Re-compose a `duckdb_timestamp` from a duckdb_timestamp_struct.
-
-* ts: The de-composed elements in a `duckdb_timestamp_struct`.
-* returns: The `duckdb_timestamp` element.
-*/
-DUCKDB_API duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts);
-
-//===--------------------------------------------------------------------===//
-// Hugeint Helpers
-//===--------------------------------------------------------------------===//
-/*!
-Converts a duckdb_hugeint object (as obtained from a `DUCKDB_TYPE_HUGEINT` column) into a double.
-
-* val: The hugeint value.
-* returns: The converted `double` element.
-*/
-DUCKDB_API double duckdb_hugeint_to_double(duckdb_hugeint val);
-
-/*!
-Converts a double value to a duckdb_hugeint object.
-
-If the conversion fails because the double value is too big the result will be 0.
-
-* val: The double value.
-* returns: The converted `duckdb_hugeint` element.
-*/
-DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);
-
-//===--------------------------------------------------------------------===//
-// Decimal Helpers
-//===--------------------------------------------------------------------===//
-/*!
-Converts a duckdb_decimal object (as obtained from a `DUCKDB_TYPE_DECIMAL` column) into a double.
-
-* val: The decimal value.
-* returns: The converted `double` element.
-*/
-DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);
-
-//===--------------------------------------------------------------------===//
-// Prepared Statements
-//===--------------------------------------------------------------------===//
-// A prepared statement is a parameterized query that allows you to bind parameters to it.
-// * This is useful to easily supply parameters to functions and avoid SQL injection attacks.
-// * This is useful to speed up queries that you will execute several times with different parameters.
-// Because the query will only be parsed, bound, optimized and planned once during the prepare stage,
-// rather than once per execution.
-// For example:
-//   SELECT * FROM tbl WHERE id=?
-// Or a query with multiple parameters:
-//   SELECT * FROM tbl WHERE id=$1 OR name=$2
-
-/*!
-Create a prepared statement object from a query.
-
-Note that after calling `duckdb_prepare`, the prepared statement should always be destroyed using
-`duckdb_destroy_prepare`, even if the prepare fails.
-
-If the prepare fails, `duckdb_prepare_error` can be called to obtain the reason why the prepare failed.
-
-* connection: The connection object
-* query: The SQL query to prepare
-* out_prepared_statement: The resulting prepared statement object
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,
-                                       duckdb_prepared_statement *out_prepared_statement);
-
-/*!
-Closes the prepared statement and de-allocates all memory allocated for the statement.
-
-* prepared_statement: The prepared statement to destroy.
-*/
-DUCKDB_API void duckdb_destroy_prepare(duckdb_prepared_statement *prepared_statement);
-
-/*!
-Returns the error message associated with the given prepared statement.
-If the prepared statement has no error message, this returns `nullptr` instead.
-
-The error message should not be freed. It will be de-allocated when `duckdb_destroy_prepare` is called.
-
-* prepared_statement: The prepared statement to obtain the error from.
-* returns: The error message, or `nullptr` if there is none.
-*/
-DUCKDB_API const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement);
-
-/*!
-Returns the number of parameters that can be provided to the given prepared statement.
-
-Returns 0 if the query was not successfully prepared.
-
-* prepared_statement: The prepared statement to obtain the number of parameters for.
-*/
-DUCKDB_API idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement);
-
-/*!
-Returns the parameter type for the parameter at the given index.
-
-Returns `DUCKDB_TYPE_INVALID` if the parameter index is out of range or the statement was not successfully prepared.
-
-* prepared_statement: The prepared statement.
-* param_idx: The parameter index.
-* returns: The parameter type
-*/
-DUCKDB_API duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-
-/*!
-Binds a bool value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_boolean(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val);
-
-/*!
-Binds an int8_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_int8(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val);
-
-/*!
-Binds an int16_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_int16(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val);
-
-/*!
-Binds an int32_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_int32(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val);
-
-/*!
-Binds an int64_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val);
-
-/*!
-Binds an duckdb_hugeint value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                            duckdb_hugeint val);
-
-/*!
-Binds an uint8_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val);
-
-/*!
-Binds an uint16_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uint16(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val);
-
-/*!
-Binds an uint32_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uint32(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val);
-
-/*!
-Binds an uint64_t value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val);
-
-/*!
-Binds an float value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val);
-
-/*!
-Binds an double value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val);
-
-/*!
-Binds a duckdb_date value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_date(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                         duckdb_date val);
-
-/*!
-Binds a duckdb_time value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_time(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                         duckdb_time val);
-
-/*!
-Binds a duckdb_timestamp value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                              duckdb_timestamp val);
-
-/*!
-Binds a duckdb_interval value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                             duckdb_interval val);
-
-/*!
-Binds a null-terminated varchar value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                            const char *val);
-
-/*!
-Binds a varchar value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                                   const char *val, idx_t length);
-
-/*!
-Binds a blob value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx,
-                                         const void *data, idx_t length);
-
-/*!
-Binds a NULL value to the prepared statement at the specified index.
-*/
-DUCKDB_API duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx);
-
-/*!
-Executes the prepared statement with the given bound parameters, and returns a materialized query result.
-
-This method can be called multiple times for each prepared statement, and the parameters can be modified
-between calls to this function.
-
-* prepared_statement: The prepared statement to execute.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement,
-                                                duckdb_result *out_result);
-
-/*!
-Executes the prepared statement with the given bound parameters, and returns an arrow query result.
-
-* prepared_statement: The prepared statement to execute.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement,
-                                                      duckdb_arrow *out_result);
-
-//===--------------------------------------------------------------------===//
-// Value Interface
-//===--------------------------------------------------------------------===//
-/*!
-Destroys the value and de-allocates all memory allocated for that type.
-
-* value: The value to destroy.
-*/
-DUCKDB_API void duckdb_destroy_value(duckdb_value *value);
-
-/*!
-Creates a value from a null-terminated string
-
-* value: The null-terminated string
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_varchar(const char *text);
-
-/*!
-Creates a value from a string
-
-* value: The text
-* length: The length of the text
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_varchar_length(const char *text, idx_t length);
-
-/*!
-Creates a value from an int64
-
-* value: The bigint value
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_create_int64(int64_t val);
-
-/*!
-Obtains a string representation of the given value.
-The result must be destroyed with `duckdb_free`.
-
-* value: The value
-* returns: The string value. This must be destroyed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_get_varchar(duckdb_value value);
-
-/*!
-Obtains an int64 of the given value.
-
-* value: The value
-* returns: The int64 value, or 0 if no conversion is possible
-*/
-DUCKDB_API int64_t duckdb_get_int64(duckdb_value value);
-
-//===--------------------------------------------------------------------===//
-// Logical Type Interface
-//===--------------------------------------------------------------------===//
-
-/*!
-Creates a `duckdb_logical_type` from a standard primitive type.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
-
-This should not be used with `DUCKDB_TYPE_DECIMAL`.
-
-* type: The primitive type to create.
-* returns: The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_logical_type(duckdb_type type);
-
-/*!
-Creates a list type from its child type.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
-
-* type: The child type of list type to create.
-* returns: The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type);
-
-/*!
-Creates a map type from its key type and value type.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
-
-* type: The key type and value type of map type to create.
-* returns: The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type);
-
-/*!
-Creates a `duckdb_logical_type` of type decimal with the specified width and scale
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
-
-* width: The width of the decimal type
-* scale: The scale of the decimal type
-* returns: The logical type.
-*/
-DUCKDB_API duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale);
-
-/*!
-Retrieves the type class of a `duckdb_logical_type`.
-
-* type: The logical type object
-* returns: The type id
-*/
-DUCKDB_API duckdb_type duckdb_get_type_id(duckdb_logical_type type);
-
-/*!
-Retrieves the width of a decimal type.
-
-* type: The logical type object
-* returns: The width of the decimal type
-*/
-DUCKDB_API uint8_t duckdb_decimal_width(duckdb_logical_type type);
-
-/*!
-Retrieves the scale of a decimal type.
-
-* type: The logical type object
-* returns: The scale of the decimal type
-*/
-DUCKDB_API uint8_t duckdb_decimal_scale(duckdb_logical_type type);
-
-/*!
-Retrieves the internal storage type of a decimal type.
-
-* type: The logical type object
-* returns: The internal type of the decimal type
-*/
-DUCKDB_API duckdb_type duckdb_decimal_internal_type(duckdb_logical_type type);
-
-/*!
-Retrieves the internal storage type of an enum type.
-
-* type: The logical type object
-* returns: The internal type of the enum type
-*/
-DUCKDB_API duckdb_type duckdb_enum_internal_type(duckdb_logical_type type);
-
-/*!
-Retrieves the dictionary size of the enum type
-
-* type: The logical type object
-* returns: The dictionary size of the enum type
-*/
-DUCKDB_API uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type);
-
-/*!
-Retrieves the dictionary value at the specified position from the enum.
-
-The result must be freed with `duckdb_free`
-
-* type: The logical type object
-* index: The index in the dictionary
-* returns: The string value of the enum type. Must be freed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index);
-
-/*!
-Retrieves the child type of the given list type.
-
-The result must be freed with `duckdb_destroy_logical_type`
-
-* type: The logical type object
-* returns: The child type of the list type. Must be destroyed with `duckdb_destroy_logical_type`.
-*/
-DUCKDB_API duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type);
-
-/*!
-Retrieves the key type of the given map type.
-
-The result must be freed with `duckdb_destroy_logical_type`
-
-* type: The logical type object
-* returns: The key type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
-*/
-DUCKDB_API duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type);
-
-/*!
-Retrieves the value type of the given map type.
-
-The result must be freed with `duckdb_destroy_logical_type`
-
-* type: The logical type object
-* returns: The value type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
-*/
-DUCKDB_API duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type);
-
-/*!
-Returns the number of children of a struct type.
-
-* type: The logical type object
-* returns: The number of children of a struct type.
-*/
-DUCKDB_API idx_t duckdb_struct_type_child_count(duckdb_logical_type type);
-
-/*!
-Retrieves the name of the struct child.
-
-The result must be freed with `duckdb_free`
-
-* type: The logical type object
-* index: The child index
-* returns: The name of the struct type. Must be freed with `duckdb_free`.
-*/
-DUCKDB_API char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t index);
-
-/*!
-Retrieves the child type of the given struct type at the specified index.
-
-The result must be freed with `duckdb_destroy_logical_type`
-
-* type: The logical type object
-* index: The child index
-* returns: The child type of the struct type. Must be destroyed with `duckdb_destroy_logical_type`.
-*/
-DUCKDB_API duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_t index);
-
-/*!
-Destroys the logical type and de-allocates all memory allocated for that type.
-
-* type: The logical type to destroy.
-*/
-DUCKDB_API void duckdb_destroy_logical_type(duckdb_logical_type *type);
-
-//===--------------------------------------------------------------------===//
-// Data Chunk Interface
-//===--------------------------------------------------------------------===//
-/*!
-Creates an empty DataChunk with the specified set of types.
-
-* types: An array of types of the data chunk.
-* column_count: The number of columns.
-* returns: The data chunk.
-*/
-DUCKDB_API duckdb_data_chunk duckdb_create_data_chunk(duckdb_logical_type *types, idx_t column_count);
-
-/*!
-Destroys the data chunk and de-allocates all memory allocated for that chunk.
-
-* chunk: The data chunk to destroy.
-*/
-DUCKDB_API void duckdb_destroy_data_chunk(duckdb_data_chunk *chunk);
-
-/*!
-Resets a data chunk, clearing the validity masks and setting the cardinality of the data chunk to 0.
-
-* chunk: The data chunk to reset.
-*/
-DUCKDB_API void duckdb_data_chunk_reset(duckdb_data_chunk chunk);
-
-/*!
-Retrieves the number of columns in a data chunk.
-
-* chunk: The data chunk to get the data from
-* returns: The number of columns in the data chunk
-*/
-DUCKDB_API idx_t duckdb_data_chunk_get_column_count(duckdb_data_chunk chunk);
-
-/*!
-Retrieves the vector at the specified column index in the data chunk.
-
-The pointer to the vector is valid for as long as the chunk is alive.
-It does NOT need to be destroyed.
-
-* chunk: The data chunk to get the data from
-* returns: The vector
-*/
-DUCKDB_API duckdb_vector duckdb_data_chunk_get_vector(duckdb_data_chunk chunk, idx_t col_idx);
-
-/*!
-Retrieves the current number of tuples in a data chunk.
-
-* chunk: The data chunk to get the data from
-* returns: The number of tuples in the data chunk
-*/
-DUCKDB_API idx_t duckdb_data_chunk_get_size(duckdb_data_chunk chunk);
-
-/*!
-Sets the current number of tuples in a data chunk.
-
-* chunk: The data chunk to set the size in
-* size: The number of tuples in the data chunk
-*/
-DUCKDB_API void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size);
-
-//===--------------------------------------------------------------------===//
-// Vector Interface
-//===--------------------------------------------------------------------===//
-/*!
-Retrieves the column type of the specified vector.
-
-The result must be destroyed with `duckdb_destroy_logical_type`.
-
-* vector: The vector get the data from
-* returns: The type of the vector
-*/
-DUCKDB_API duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector);
-
-/*!
-Retrieves the data pointer of the vector.
-
-The data pointer can be used to read or write values from the vector.
-How to read or write values depends on the type of the vector.
-
-* vector: The vector to get the data from
-* returns: The data pointer
-*/
-DUCKDB_API void *duckdb_vector_get_data(duckdb_vector vector);
-
-/*!
-Retrieves the validity mask pointer of the specified vector.
-
-If all values are valid, this function MIGHT return NULL!
-
-The validity mask is a bitset that signifies null-ness within the data chunk.
-It is a series of uint64_t values, where each uint64_t value contains validity for 64 tuples.
-The bit is set to 1 if the value is valid (i.e. not NULL) or 0 if the value is invalid (i.e. NULL).
-
-Validity of a specific value can be obtained like this:
-
-idx_t entry_idx = row_idx / 64;
-idx_t idx_in_entry = row_idx % 64;
-bool is_valid = validity_mask[entry_idx] & (1 << idx_in_entry);
-
-Alternatively, the (slower) duckdb_validity_row_is_valid function can be used.
-
-* vector: The vector to get the data from
-* returns: The pointer to the validity mask, or NULL if no validity mask is present
-*/
-DUCKDB_API uint64_t *duckdb_vector_get_validity(duckdb_vector vector);
-
-/*!
-Ensures the validity mask is writable by allocating it.
-
-After this function is called, `duckdb_vector_get_validity` will ALWAYS return non-NULL.
-This allows null values to be written to the vector, regardless of whether a validity mask was present before.
-
-* vector: The vector to alter
-*/
-DUCKDB_API void duckdb_vector_ensure_validity_writable(duckdb_vector vector);
-
-/*!
-Assigns a string element in the vector at the specified location.
-
-* vector: The vector to alter
-* index: The row position in the vector to assign the string to
-* str: The null-terminated string
-*/
-DUCKDB_API void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str);
-
-/*!
-Assigns a string element in the vector at the specified location.
-
-* vector: The vector to alter
-* index: The row position in the vector to assign the string to
-* str: The string
-* str_len: The length of the string (in bytes)
-*/
-DUCKDB_API void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index, const char *str,
-                                                        idx_t str_len);
-
-/*!
-Retrieves the child vector of a list vector.
-
-The resulting vector is valid as long as the parent vector is valid.
-
-* vector: The vector
-* returns: The child vector
-*/
-DUCKDB_API duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector);
-
-/*!
-Returns the size of the child vector of the list
-
-* vector: The vector
-* returns: The size of the child list
-*/
-DUCKDB_API idx_t duckdb_list_vector_get_size(duckdb_vector vector);
-
-/*!
-Retrieves the child vector of a struct vector.
-
-The resulting vector is valid as long as the parent vector is valid.
-
-* vector: The vector
-* index: The child index
-* returns: The child vector
-*/
-DUCKDB_API duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index);
-
-//===--------------------------------------------------------------------===//
-// Validity Mask Functions
-//===--------------------------------------------------------------------===//
-/*!
-Returns whether or not a row is valid (i.e. not NULL) in the given validity mask.
-
-* validity: The validity mask, as obtained through `duckdb_data_chunk_get_validity`
-* row: The row index
-* returns: true if the row is valid, false otherwise
-*/
-DUCKDB_API bool duckdb_validity_row_is_valid(uint64_t *validity, idx_t row);
-
-/*!
-In a validity mask, sets a specific row to either valid or invalid.
-
-Note that `duckdb_data_chunk_ensure_validity_writable` should be called before calling `duckdb_data_chunk_get_validity`,
-to ensure that there is a validity mask to write to.
-
-* validity: The validity mask, as obtained through `duckdb_data_chunk_get_validity`.
-* row: The row index
-* valid: Whether or not to set the row to valid, or invalid
-*/
-DUCKDB_API void duckdb_validity_set_row_validity(uint64_t *validity, idx_t row, bool valid);
-
-/*!
-In a validity mask, sets a specific row to invalid.
-
-Equivalent to `duckdb_validity_set_row_validity` with valid set to false.
-
-* validity: The validity mask
-* row: The row index
-*/
-DUCKDB_API void duckdb_validity_set_row_invalid(uint64_t *validity, idx_t row);
-
-/*!
-In a validity mask, sets a specific row to valid.
-
-Equivalent to `duckdb_validity_set_row_validity` with valid set to true.
-
-* validity: The validity mask
-* row: The row index
-*/
-DUCKDB_API void duckdb_validity_set_row_valid(uint64_t *validity, idx_t row);
-
-//===--------------------------------------------------------------------===//
-// Table Functions
-//===--------------------------------------------------------------------===//
-typedef void *duckdb_table_function;
-typedef void *duckdb_bind_info;
-typedef void *duckdb_init_info;
-typedef void *duckdb_function_info;
-
-typedef void (*duckdb_table_function_bind_t)(duckdb_bind_info info);
-typedef void (*duckdb_table_function_init_t)(duckdb_init_info info);
-typedef void (*duckdb_table_function_t)(duckdb_function_info info, duckdb_data_chunk output);
-typedef void (*duckdb_delete_callback_t)(void *data);
-
-/*!
-Creates a new empty table function.
-
-The return value should be destroyed with `duckdb_destroy_table_function`.
-
-* returns: The table function object.
-*/
-DUCKDB_API duckdb_table_function duckdb_create_table_function();
-
-/*!
-Destroys the given table function object.
-
-* table_function: The table function to destroy
-*/
-DUCKDB_API void duckdb_destroy_table_function(duckdb_table_function *table_function);
-
-/*!
-Sets the name of the given table function.
-
-* table_function: The table function
-* name: The name of the table function
-*/
-DUCKDB_API void duckdb_table_function_set_name(duckdb_table_function table_function, const char *name);
-
-/*!
-Adds a parameter to the table function.
-
-* table_function: The table function
-* type: The type of the parameter to add.
-*/
-DUCKDB_API void duckdb_table_function_add_parameter(duckdb_table_function table_function, duckdb_logical_type type);
-
-/*!
-Assigns extra information to the table function that can be fetched during binding, etc.
-
-* table_function: The table function
-* extra_info: The extra information
-* destroy: The callback that will be called to destroy the bind data (if any)
-*/
-DUCKDB_API void duckdb_table_function_set_extra_info(duckdb_table_function table_function, void *extra_info,
-                                                     duckdb_delete_callback_t destroy);
-
-/*!
-Sets the bind function of the table function
-
-* table_function: The table function
-* bind: The bind function
-*/
-DUCKDB_API void duckdb_table_function_set_bind(duckdb_table_function table_function, duckdb_table_function_bind_t bind);
-
-/*!
-Sets the init function of the table function
-
-* table_function: The table function
-* init: The init function
-*/
-DUCKDB_API void duckdb_table_function_set_init(duckdb_table_function table_function, duckdb_table_function_init_t init);
-
-/*!
-Sets the thread-local init function of the table function
-
-* table_function: The table function
-* init: The init function
-*/
-DUCKDB_API void duckdb_table_function_set_local_init(duckdb_table_function table_function,
-                                                     duckdb_table_function_init_t init);
-
-/*!
-Sets the main function of the table function
-
-* table_function: The table function
-* function: The function
-*/
-DUCKDB_API void duckdb_table_function_set_function(duckdb_table_function table_function,
-                                                   duckdb_table_function_t function);
-
-/*!
-Sets whether or not the given table function supports projection pushdown.
-
-If this is set to true, the system will provide a list of all required columns in the `init` stage through
-the `duckdb_init_get_column_count` and `duckdb_init_get_column_index` functions.
-If this is set to false (the default), the system will expect all columns to be projected.
-
-* table_function: The table function
-* pushdown: True if the table function supports projection pushdown, false otherwise.
-*/
-DUCKDB_API void duckdb_table_function_supports_projection_pushdown(duckdb_table_function table_function, bool pushdown);
-
-/*!
-Register the table function object within the given connection.
-
-The function requires at least a name, a bind function, an init function and a main function.
-
-If the function is incomplete or a function with this name already exists DuckDBError is returned.
-
-* con: The connection to register it in.
-* function: The function pointer
-* returns: Whether or not the registration was successful.
-*/
-DUCKDB_API duckdb_state duckdb_register_table_function(duckdb_connection con, duckdb_table_function function);
-
-//===--------------------------------------------------------------------===//
-// Table Function Bind
-//===--------------------------------------------------------------------===//
-/*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`
-
-* info: The info object
-* returns: The extra info
-*/
-DUCKDB_API void *duckdb_bind_get_extra_info(duckdb_bind_info info);
-
-/*!
-Adds a result column to the output of the table function.
-
-* info: The info object
-* name: The name of the column
-* type: The logical type of the column
-*/
-DUCKDB_API void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duckdb_logical_type type);
-
-/*!
-Retrieves the number of regular (non-named) parameters to the function.
-
-* info: The info object
-* returns: The number of parameters
-*/
-DUCKDB_API idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info);
-
-/*!
-Retrieves the parameter at the given index.
-
-The result must be destroyed with `duckdb_destroy_value`.
-
-* info: The info object
-* index: The index of the parameter to get
-* returns: The value of the parameter. Must be destroyed with `duckdb_destroy_value`.
-*/
-DUCKDB_API duckdb_value duckdb_bind_get_parameter(duckdb_bind_info info, idx_t index);
-
-/*!
-Sets the user-provided bind data in the bind object. This object can be retrieved again during execution.
-
-* info: The info object
-* extra_data: The bind data object.
-* destroy: The callback that will be called to destroy the bind data (if any)
-*/
-DUCKDB_API void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
-
-/*!
-Report that an error has occurred while calling bind.
-
-* info: The info object
-* error: The error message
-*/
-DUCKDB_API void duckdb_bind_set_error(duckdb_bind_info info, const char *error);
-
-//===--------------------------------------------------------------------===//
-// Table Function Init
-//===--------------------------------------------------------------------===//
-
-/*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`
-
-* info: The info object
-* returns: The extra info
-*/
-DUCKDB_API void *duckdb_init_get_extra_info(duckdb_init_info info);
-
-/*!
-Gets the bind data set by `duckdb_bind_set_bind_data` during the bind.
-
-Note that the bind data should be considered as read-only.
-For tracking state, use the init data instead.
-
-* info: The info object
-* returns: The bind data object
-*/
-DUCKDB_API void *duckdb_init_get_bind_data(duckdb_init_info info);
-
-/*!
-Sets the user-provided init data in the init object. This object can be retrieved again during execution.
-
-* info: The info object
-* extra_data: The init data object.
-* destroy: The callback that will be called to destroy the init data (if any)
-*/
-DUCKDB_API void duckdb_init_set_init_data(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy);
-
-/*!
-Returns the number of projected columns.
-
-This function must be used if projection pushdown is enabled to figure out which columns to emit.
-
-* info: The info object
-* returns: The number of projected columns.
-*/
-DUCKDB_API idx_t duckdb_init_get_column_count(duckdb_init_info info);
-
-/*!
-Returns the column index of the projected column at the specified position.
-
-This function must be used if projection pushdown is enabled to figure out which columns to emit.
-
-* info: The info object
-* column_index: The index at which to get the projected column index, from 0..duckdb_init_get_column_count(info)
-* returns: The column index of the projected column.
-*/
-DUCKDB_API idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index);
-
-/*!
-Sets how many threads can process this table function in parallel (default: 1)
-
-* info: The info object
-* max_threads: The maximum amount of threads that can process this table function
-*/
-DUCKDB_API void duckdb_init_set_max_threads(duckdb_init_info info, idx_t max_threads);
-
-/*!
-Report that an error has occurred while calling init.
-
-* info: The info object
-* error: The error message
-*/
-DUCKDB_API void duckdb_init_set_error(duckdb_init_info info, const char *error);
-
-//===--------------------------------------------------------------------===//
-// Table Function
-//===--------------------------------------------------------------------===//
-
-/*!
-Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`
-
-* info: The info object
-* returns: The extra info
-*/
-DUCKDB_API void *duckdb_function_get_extra_info(duckdb_function_info info);
-/*!
-Gets the bind data set by `duckdb_bind_set_bind_data` during the bind.
-
-Note that the bind data should be considered as read-only.
-For tracking state, use the init data instead.
-
-* info: The info object
-* returns: The bind data object
-*/
-DUCKDB_API void *duckdb_function_get_bind_data(duckdb_function_info info);
-
-/*!
-Gets the init data set by `duckdb_init_set_init_data` during the init.
-
-* info: The info object
-* returns: The init data object
-*/
-DUCKDB_API void *duckdb_function_get_init_data(duckdb_function_info info);
-
-/*!
-Gets the thread-local init data set by `duckdb_init_set_init_data` during the local_init.
-
-* info: The info object
-* returns: The init data object
-*/
-DUCKDB_API void *duckdb_function_get_local_init_data(duckdb_function_info info);
-
-/*!
-Report that an error has occurred while executing the function.
-
-* info: The info object
-* error: The error message
-*/
-DUCKDB_API void duckdb_function_set_error(duckdb_function_info info, const char *error);
-
-//===--------------------------------------------------------------------===//
-// Replacement Scans
-//===--------------------------------------------------------------------===//
-typedef void *duckdb_replacement_scan_info;
-
-typedef void (*duckdb_replacement_callback_t)(duckdb_replacement_scan_info info, const char *table_name, void *data);
-
-/*!
-Add a replacement scan definition to the specified database
-
-* db: The database object to add the replacement scan to
-* replacement: The replacement scan callback
-* extra_data: Extra data that is passed back into the specified callback
-* delete_callback: The delete callback to call on the extra data, if any
-*/
-DUCKDB_API void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback_t replacement,
-                                            void *extra_data, duckdb_delete_callback_t delete_callback);
-
-/*!
-Sets the replacement function name to use. If this function is called in the replacement callback,
- the replacement scan is performed. If it is not called, the replacement callback is not performed.
-
-* info: The info object
-* function_name: The function name to substitute.
-*/
-DUCKDB_API void duckdb_replacement_scan_set_function_name(duckdb_replacement_scan_info info, const char *function_name);
-
-/*!
-Adds a parameter to the replacement scan function.
-
-* info: The info object
-* parameter: The parameter to add.
-*/
-DUCKDB_API void duckdb_replacement_scan_add_parameter(duckdb_replacement_scan_info info, duckdb_value parameter);
-
-//===--------------------------------------------------------------------===//
-// Appender
-//===--------------------------------------------------------------------===//
-
-// Appenders are the most efficient way of loading data into DuckDB from within the C interface, and are recommended for
-// fast data loading. The appender is much faster than using prepared statements or individual `INSERT INTO` statements.
-
-// Appends are made in row-wise format. For every column, a `duckdb_append_[type]` call should be made, after which
-// the row should be finished by calling `duckdb_appender_end_row`. After all rows have been appended,
-// `duckdb_appender_destroy` should be used to finalize the appender and clean up the resulting memory.
-
-// Note that `duckdb_appender_destroy` should always be called on the resulting appender, even if the function returns
-// `DuckDBError`.
-
-/*!
-Creates an appender object.
-
-* connection: The connection context to create the appender in.
-* schema: The schema of the table to append to, or `nullptr` for the default schema.
-* table: The table name to append to.
-* out_appender: The resulting appender object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_create(duckdb_connection connection, const char *schema, const char *table,
-                                               duckdb_appender *out_appender);
-
-/*!
-Returns the error message associated with the given appender.
-If the appender has no error message, this returns `nullptr` instead.
-
-The error message should not be freed. It will be de-allocated when `duckdb_appender_destroy` is called.
-
-* appender: The appender to get the error from.
-* returns: The error message, or `nullptr` if there is none.
-*/
-DUCKDB_API const char *duckdb_appender_error(duckdb_appender appender);
-
-/*!
-Flush the appender to the table, forcing the cache of the appender to be cleared and the data to be appended to the
-base table.
-
-This should generally not be used unless you know what you are doing. Instead, call `duckdb_appender_destroy` when you
-are done with the appender.
-
-* appender: The appender to flush.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_flush(duckdb_appender appender);
-
-/*!
-Close the appender, flushing all intermediate state in the appender to the table and closing it for further appends.
-
-This is generally not necessary. Call `duckdb_appender_destroy` instead.
-
-* appender: The appender to flush and close.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_close(duckdb_appender appender);
-
-/*!
-Close the appender and destroy it. Flushing all intermediate state in the appender to the table, and de-allocating
-all memory associated with the appender.
-
-* appender: The appender to flush, close and destroy.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_destroy(duckdb_appender *appender);
-
-/*!
-A nop function, provided for backwards compatibility reasons. Does nothing. Only `duckdb_appender_end_row` is required.
-*/
-DUCKDB_API duckdb_state duckdb_appender_begin_row(duckdb_appender appender);
-
-/*!
-Finish the current row of appends. After end_row is called, the next row can be appended.
-
-* appender: The appender.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_appender_end_row(duckdb_appender appender);
-
-/*!
-Append a bool value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_bool(duckdb_appender appender, bool value);
-
-/*!
-Append an int8_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_int8(duckdb_appender appender, int8_t value);
-/*!
-Append an int16_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_int16(duckdb_appender appender, int16_t value);
-/*!
-Append an int32_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_int32(duckdb_appender appender, int32_t value);
-/*!
-Append an int64_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_int64(duckdb_appender appender, int64_t value);
-/*!
-Append a duckdb_hugeint value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_hugeint(duckdb_appender appender, duckdb_hugeint value);
-
-/*!
-Append a uint8_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uint8(duckdb_appender appender, uint8_t value);
-/*!
-Append a uint16_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uint16(duckdb_appender appender, uint16_t value);
-/*!
-Append a uint32_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uint32(duckdb_appender appender, uint32_t value);
-/*!
-Append a uint64_t value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_uint64(duckdb_appender appender, uint64_t value);
-
-/*!
-Append a float value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_float(duckdb_appender appender, float value);
-/*!
-Append a double value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_double(duckdb_appender appender, double value);
-
-/*!
-Append a duckdb_date value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_date(duckdb_appender appender, duckdb_date value);
-/*!
-Append a duckdb_time value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_time(duckdb_appender appender, duckdb_time value);
-/*!
-Append a duckdb_timestamp value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_timestamp(duckdb_appender appender, duckdb_timestamp value);
-/*!
-Append a duckdb_interval value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_interval(duckdb_appender appender, duckdb_interval value);
-
-/*!
-Append a varchar value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val);
-/*!
-Append a varchar value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *val, idx_t length);
-/*!
-Append a blob value to the appender.
-*/
-DUCKDB_API duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length);
-/*!
-Append a NULL value to the appender (of any type).
-*/
-DUCKDB_API duckdb_state duckdb_append_null(duckdb_appender appender);
-
-/*!
-Appends a pre-filled data chunk to the specified appender.
-
-The types of the data chunk must exactly match the types of the table, no casting is performed.
-If the types do not match or the appender is in an invalid state, DuckDBError is returned.
-If the append is successful, DuckDBSuccess is returned.
-
-* appender: The appender to append to.
-* chunk: The data chunk to append.
-* returns: The return state.
-*/
-DUCKDB_API duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk);
-
-//===--------------------------------------------------------------------===//
-// Arrow Interface
-//===--------------------------------------------------------------------===//
-/*!
-Executes a SQL query within a connection and stores the full (materialized) result in an arrow structure.
-If the query fails to execute, DuckDBError is returned and the error message can be retrieved by calling
-`duckdb_query_arrow_error`.
-
-Note that after running `duckdb_query_arrow`, `duckdb_destroy_arrow` must be called on the result object even if the
-query fails, otherwise the error stored within the result will not be freed correctly.
-
-* connection: The connection to perform the query in.
-* query: The SQL query to run.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_query_arrow(duckdb_connection connection, const char *query, duckdb_arrow *out_result);
-
-/*!
-Fetch the internal arrow schema from the arrow result.
-
-* result: The result to fetch the schema from.
-* out_schema: The output schema.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema *out_schema);
-
-/*!
-Fetch an internal arrow array from the arrow result.
-
-This function can be called multiple time to get next chunks, which will free the previous out_array.
-So consume the out_array before calling this function again.
-
-* result: The result to fetch the array from.
-* out_array: The output array.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
-*/
-DUCKDB_API duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *out_array);
-
-/*!
-Returns the number of columns present in a the arrow result object.
-
-* result: The result object.
-* returns: The number of columns present in the result object.
-*/
-DUCKDB_API idx_t duckdb_arrow_column_count(duckdb_arrow result);
-
-/*!
-Returns the number of rows present in a the arrow result object.
-
-* result: The result object.
-* returns: The number of rows present in the result object.
-*/
-DUCKDB_API idx_t duckdb_arrow_row_count(duckdb_arrow result);
-
-/*!
-Returns the number of rows changed by the query stored in the arrow result. This is relevant only for
-INSERT/UPDATE/DELETE queries. For other queries the rows_changed will be 0.
-
-* result: The result object.
-* returns: The number of rows changed.
-*/
-DUCKDB_API idx_t duckdb_arrow_rows_changed(duckdb_arrow result);
-
-/*!
-Returns the error message contained within the result. The error is only set if `duckdb_query_arrow` returns
-`DuckDBError`.
-
-The error message should not be freed. It will be de-allocated when `duckdb_destroy_arrow` is called.
-
-* result: The result object to fetch the nullmask from.
-* returns: The error of the result.
-*/
-DUCKDB_API const char *duckdb_query_arrow_error(duckdb_arrow result);
-
-/*!
-Closes the result and de-allocates all memory allocated for the arrow result.
-
-* result: The result to destroy.
-*/
-DUCKDB_API void duckdb_destroy_arrow(duckdb_arrow *result);
-
-//===--------------------------------------------------------------------===//
-// Threading Information
-//===--------------------------------------------------------------------===//
-/*!
-Execute DuckDB tasks on this thread.
-
-Will return after `max_tasks` have been executed, or if there are no more tasks present.
-
-* database: The database object to execute tasks for
-* max_tasks: The maximum amount of tasks to execute
-*/
-DUCKDB_API void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/profiler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! The profiler can be used to measure elapsed time
-template <typename T>
-class BaseProfiler {
-public:
-	//! Starts the timer
-	void Start() {
-		finished = false;
-		start = Tick();
-	}
-	//! Finishes timing
-	void End() {
-		end = Tick();
-		finished = true;
-	}
-
-	//! Returns the elapsed time in seconds. If End() has been called, returns
-	//! the total elapsed time. Otherwise returns how far along the timer is
-	//! right now.
-	double Elapsed() const {
-		auto _end = finished ? end : Tick();
-		return std::chrono::duration_cast<std::chrono::duration<double>>(_end - start).count();
-	}
-
-private:
-	time_point<T> Tick() const {
-		return T::now();
-	}
-	time_point<T> start;
-	time_point<T> end;
-	bool finished = false;
-};
-
-using Profiler = BaseProfiler<system_clock>;
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class ProgressBar {
-public:
-	explicit ProgressBar(Executor &executor, idx_t show_progress_after, bool print_progress);
-
-	//! Starts the thread
-	void Start();
-	//! Updates the progress bar and prints it to the screen
-	void Update(bool final);
-	//! Gets current percentage
-	double GetCurrentPercentage();
-
-private:
-	const string PROGRESS_BAR_STRING = "============================================================";
-	static constexpr const idx_t PROGRESS_BAR_WIDTH = 60;
-
-private:
-	//! The executor
-	Executor &executor;
-	//! The profiler used to measure the time since the progress bar was started
-	Profiler profiler;
-	//! The time in ms after which to start displaying the progress bar
-	idx_t show_progress_after;
-	//! The current progress percentage
-	double current_percentage;
-	//! Whether or not we print the progress bar
-	bool print_progress;
-	//! Whether or not profiling is supported for the current query
-	bool supported = true;
-};
-} // namespace duckdb
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/stream_query_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class ClientContext;
-class ClientContextLock;
-class Executor;
-class MaterializedQueryResult;
-class PreparedStatementData;
-
-class StreamQueryResult : public QueryResult {
-	friend class ClientContext;
-
-public:
-	//! Create a successful StreamQueryResult. StreamQueryResults should always be successful initially (it makes no
-	//! sense to stream an error).
-	DUCKDB_API StreamQueryResult(StatementType statement_type, StatementProperties properties,
-	                             shared_ptr<ClientContext> context, vector<LogicalType> types, vector<string> names);
-	DUCKDB_API ~StreamQueryResult() override;
-
-public:
-	//! Fetches a DataChunk from the query result.
-	DUCKDB_API unique_ptr<DataChunk> FetchRaw() override;
-	//! Converts the QueryResult to a string
-	DUCKDB_API string ToString() override;
-	//! Materializes the query result and turns it into a materialized query result
-	DUCKDB_API unique_ptr<MaterializedQueryResult> Materialize();
-
-	DUCKDB_API bool IsOpen();
-
-	//! Closes the StreamQueryResult
-	DUCKDB_API void Close();
-
-	//! The client context this StreamQueryResult belongs to
-	shared_ptr<ClientContext> context;
-
-private:
-	unique_ptr<ClientContextLock> LockContext();
-	void CheckExecutableInternal(ClientContextLock &lock);
-	bool IsOpenInternal(ClientContextLock &lock);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/table_description.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct TableDescription {
-	//! The schema of the table
-	string schema;
-	//! The table name of the table
-	string table;
-	//! The columns of the table
-	vector<ColumnDefinition> columns;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/transaction/transaction_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class ClientContext;
-class Transaction;
-class TransactionManager;
-
-//! The transaction context keeps track of all the information relating to the
-//! current transaction
-class TransactionContext {
-public:
-	TransactionContext(TransactionManager &transaction_manager, ClientContext &context)
-	    : transaction_manager(transaction_manager), context(context), auto_commit(true), current_transaction(nullptr) {
-	}
-	~TransactionContext();
-
-	Transaction &ActiveTransaction() {
-		D_ASSERT(current_transaction);
-		return *current_transaction;
-	}
-
-	bool HasActiveTransaction() {
-		return !!current_transaction;
-	}
-
-	void RecordQuery(string query);
-	void BeginTransaction();
-	void Commit();
-	void Rollback();
-	void ClearTransaction();
-
-	void SetAutoCommit(bool value);
-	bool IsAutoCommit() {
-		return auto_commit;
-	}
-
-private:
-	TransactionManager &transaction_manager;
-	ClientContext &context;
-	bool auto_commit;
-
-	Transaction *current_transaction;
-
-	TransactionContext(const TransactionContext &) = delete;
-};
-
-} // namespace duckdb
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_config.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/output_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class ExplainOutputType : uint8_t { ALL = 0, OPTIMIZED_ONLY = 1, PHYSICAL_ONLY = 2 };
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class PhysicalResultCollector;
-class PreparedStatementData;
-
-typedef std::function<unique_ptr<PhysicalResultCollector>(ClientContext &context, PreparedStatementData &data)>
-    get_result_collector_t;
-
-struct ClientConfig {
-	//! If the query profiler is enabled or not.
-	bool enable_profiler = false;
-	//! If detailed query profiling is enabled
-	bool enable_detailed_profiling = false;
-	//! The format to print query profiling information in (default: query_tree), if enabled.
-	ProfilerPrintFormat profiler_print_format = ProfilerPrintFormat::QUERY_TREE;
-	//! The file to save query profiling information to, instead of printing it to the console
-	//! (empty = print to console)
-	string profiler_save_location;
-
-	//! Allows suppressing profiler output, even if enabled. We turn on the profiler on all test runs but don't want
-	//! to output anything
-	bool emit_profiler_output = true;
-
-	//! If the progress bar is enabled or not.
-	bool enable_progress_bar = false;
-	//! If the print of the progress bar is enabled
-	bool print_progress_bar = true;
-	//! The wait time before showing the progress bar
-	int wait_time = 2000;
-
-	//! Preserve identifier case while parsing.
-	//! If false, all unquoted identifiers are lower-cased (e.g. "MyTable" -> "mytable").
-	bool preserve_identifier_case = true;
-	//! The maximum expression depth limit in the parser
-	idx_t max_expression_depth = 1000;
-
-	// Whether or not aggressive query verification is enabled
-	bool query_verification_enabled = false;
-	//! Enable the running of optimizers
-	bool enable_optimizer = true;
-	//! Force parallelism of small tables, used for testing
-	bool verify_parallelism = false;
-	//! Force index join independent of table cardinality, used for testing
-	bool force_index_join = false;
-	//! Force out-of-core computation for operators that support it, used for testing
-	bool force_external = false;
-	//! Force disable cross product generation when hyper graph isn't connected, used for testing
-	bool force_no_cross_product = false;
-	//! Maximum bits allowed for using a perfect hash table (i.e. the perfect HT can hold up to 2^perfect_ht_threshold
-	//! elements)
-	idx_t perfect_ht_threshold = 12;
-
-	//! The explain output type used when none is specified (default: PHYSICAL_ONLY)
-	ExplainOutputType explain_output_type = ExplainOutputType::PHYSICAL_ONLY;
-
-	//! Generic options
-	case_insensitive_map_t<Value> set_variables;
-
-	//! Function that is used to create the result collector for a materialized result
-	//! Defaults to PhysicalMaterializedCollector
-	get_result_collector_t result_collector = nullptr;
-
-public:
-	static ClientConfig &GetConfig(ClientContext &context);
-
-	static string ExtractTimezoneFromConfig(ClientConfig &config);
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class Appender;
-class Catalog;
-class CatalogSearchPath;
-class ChunkCollection;
-class DatabaseInstance;
-class FileOpener;
-class LogicalOperator;
-class PreparedStatementData;
-class Relation;
-class BufferedFileWriter;
-class QueryProfiler;
-class ClientContextLock;
-struct CreateScalarFunctionInfo;
-class ScalarFunctionCatalogEntry;
-struct ActiveQueryContext;
-struct ParserOptions;
-struct ClientData;
-
-struct PendingQueryParameters {
-	//! Prepared statement parameters (if any)
-	vector<Value> *parameters = nullptr;
-	//! Whether or not a stream result should be allowed
-	bool allow_stream_result = false;
-};
-
-//! The ClientContext holds information relevant to the current client session
-//! during execution
-class ClientContext : public std::enable_shared_from_this<ClientContext> {
-	friend class PendingQueryResult;
-	friend class StreamQueryResult;
-	friend class TransactionManager;
-
-public:
-	DUCKDB_API explicit ClientContext(shared_ptr<DatabaseInstance> db);
-	DUCKDB_API ~ClientContext();
-
-	//! The database that this client is connected to
-	shared_ptr<DatabaseInstance> db;
-	//! Data for the currently running transaction
-	TransactionContext transaction;
-	//! Whether or not the query is interrupted
-	atomic<bool> interrupted;
-	//! External Objects (e.g., Python objects) that views depend of
-	unordered_map<string, vector<shared_ptr<ExternalDependency>>> external_dependencies;
-
-	//! The client configuration
-	ClientConfig config;
-	//! The set of client-specific data
-	unique_ptr<ClientData> client_data;
-
-public:
-	DUCKDB_API Transaction &ActiveTransaction() {
-		return transaction.ActiveTransaction();
-	}
-
-	//! Interrupt execution of a query
-	DUCKDB_API void Interrupt();
-	//! Enable query profiling
-	DUCKDB_API void EnableProfiling();
-	//! Disable query profiling
-	DUCKDB_API void DisableProfiling();
-
-	//! Issue a query, returning a QueryResult. The QueryResult can be either a StreamQueryResult or a
-	//! MaterializedQueryResult. The StreamQueryResult will only be returned in the case of a successful SELECT
-	//! statement.
-	DUCKDB_API unique_ptr<QueryResult> Query(const string &query, bool allow_stream_result);
-	DUCKDB_API unique_ptr<QueryResult> Query(unique_ptr<SQLStatement> statement, bool allow_stream_result);
-
-	//! Issues a query to the database and returns a Pending Query Result. Note that "query" may only contain
-	//! a single statement.
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query, bool allow_stream_result);
-	//! Issues a query to the database and returns a Pending Query Result
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(unique_ptr<SQLStatement> statement,
-	                                                       bool allow_stream_result);
-
-	//! Destroy the client context
-	DUCKDB_API void Destroy();
-
-	//! Get the table info of a specific table, or nullptr if it cannot be found
-	DUCKDB_API unique_ptr<TableDescription> TableInfo(const string &schema_name, const string &table_name);
-	//! Appends a DataChunk to the specified table. Returns whether or not the append was successful.
-	DUCKDB_API void Append(TableDescription &description, ChunkCollection &collection);
-	//! Try to bind a relation in the current client context; either throws an exception or fills the result_columns
-	//! list with the set of returned columns
-	DUCKDB_API void TryBindRelation(Relation &relation, vector<ColumnDefinition> &result_columns);
-
-	//! Execute a relation
-	DUCKDB_API unique_ptr<QueryResult> Execute(const shared_ptr<Relation> &relation);
-
-	//! Prepare a query
-	DUCKDB_API unique_ptr<PreparedStatement> Prepare(const string &query);
-	//! Directly prepare a SQL statement
-	DUCKDB_API unique_ptr<PreparedStatement> Prepare(unique_ptr<SQLStatement> statement);
-
-	//! Create a pending query result from a prepared statement with the given name and set of parameters
-	//! It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is
-	//! modified in between the prepared statement being bound and the prepared statement being run.
-	DUCKDB_API unique_ptr<PendingQueryResult>
-	PendingQuery(const string &query, shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters);
-
-	//! Execute a prepared statement with the given name and set of parameters
-	//! It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is
-	//! modified in between the prepared statement being bound and the prepared statement being run.
-	DUCKDB_API unique_ptr<QueryResult> Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-	                                           vector<Value> &values, bool allow_stream_result = true);
-	DUCKDB_API unique_ptr<QueryResult> Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-	                                           PendingQueryParameters parameters);
-
-	//! Gets current percentage of the query's progress, returns 0 in case the progress bar is disabled.
-	DUCKDB_API double GetProgress();
-
-	//! Register function in the temporary schema
-	DUCKDB_API void RegisterFunction(CreateFunctionInfo *info);
-
-	//! Parse statements from a query
-	DUCKDB_API vector<unique_ptr<SQLStatement>> ParseStatements(const string &query);
-
-	//! Extract the logical plan of a query
-	DUCKDB_API unique_ptr<LogicalOperator> ExtractPlan(const string &query);
-	DUCKDB_API void HandlePragmaStatements(vector<unique_ptr<SQLStatement>> &statements);
-
-	//! Runs a function with a valid transaction context, potentially starting a transaction if the context is in auto
-	//! commit mode.
-	DUCKDB_API void RunFunctionInTransaction(const std::function<void(void)> &fun,
-	                                         bool requires_valid_transaction = true);
-	//! Same as RunFunctionInTransaction, but does not obtain a lock on the client context or check for validation
-	DUCKDB_API void RunFunctionInTransactionInternal(ClientContextLock &lock, const std::function<void(void)> &fun,
-	                                                 bool requires_valid_transaction = true);
-
-	//! Equivalent to CURRENT_SETTING(key) SQL function.
-	DUCKDB_API bool TryGetCurrentSetting(const std::string &key, Value &result);
-
-	//! Returns the parser options for this client context
-	DUCKDB_API ParserOptions GetParserOptions();
-
-	DUCKDB_API unique_ptr<DataChunk> Fetch(ClientContextLock &lock, StreamQueryResult &result);
-
-	//! Whether or not the given result object (streaming query result or pending query result) is active
-	DUCKDB_API bool IsActiveResult(ClientContextLock &lock, BaseQueryResult *result);
-
-	//! Returns the current executor
-	Executor &GetExecutor();
-
-	//! Returns the current query string (if any)
-	const string &GetCurrentQuery();
-
-	//! Fetch a list of table names that are required for a given query
-	DUCKDB_API unordered_set<string> GetTableNames(const string &query);
-
-private:
-	//! Parse statements and resolve pragmas from a query
-	bool ParseStatements(ClientContextLock &lock, const string &query, vector<unique_ptr<SQLStatement>> &result,
-	                     string &error);
-	//! Issues a query to the database and returns a Pending Query Result
-	unique_ptr<PendingQueryResult> PendingQueryInternal(ClientContextLock &lock, unique_ptr<SQLStatement> statement,
-	                                                    PendingQueryParameters parameters, bool verify = true);
-	unique_ptr<QueryResult> ExecutePendingQueryInternal(ClientContextLock &lock, PendingQueryResult &query);
-
-	//! Parse statements from a query
-	vector<unique_ptr<SQLStatement>> ParseStatementsInternal(ClientContextLock &lock, const string &query);
-	//! Perform aggressive query verification of a SELECT statement. Only called when query_verification_enabled is
-	//! true.
-	string VerifyQuery(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement);
-
-	void InitialCleanup(ClientContextLock &lock);
-	//! Internal clean up, does not lock. Caller must hold the context_lock.
-	void CleanupInternal(ClientContextLock &lock, BaseQueryResult *result = nullptr,
-	                     bool invalidate_transaction = false);
-	unique_ptr<PendingQueryResult> PendingStatementOrPreparedStatement(ClientContextLock &lock, const string &query,
-	                                                                   unique_ptr<SQLStatement> statement,
-	                                                                   shared_ptr<PreparedStatementData> &prepared,
-	                                                                   PendingQueryParameters parameters);
-	unique_ptr<PendingQueryResult> PendingPreparedStatement(ClientContextLock &lock,
-	                                                        shared_ptr<PreparedStatementData> statement_p,
-	                                                        PendingQueryParameters parameters);
-
-	//! Internally prepare a SQL statement. Caller must hold the context_lock.
-	shared_ptr<PreparedStatementData> CreatePreparedStatement(ClientContextLock &lock, const string &query,
-	                                                          unique_ptr<SQLStatement> statement,
-	                                                          vector<Value> *values = nullptr);
-	unique_ptr<PendingQueryResult> PendingStatementInternal(ClientContextLock &lock, const string &query,
-	                                                        unique_ptr<SQLStatement> statement,
-	                                                        PendingQueryParameters parameters);
-	unique_ptr<QueryResult> RunStatementInternal(ClientContextLock &lock, const string &query,
-	                                             unique_ptr<SQLStatement> statement, bool allow_stream_result,
-	                                             bool verify = true);
-	unique_ptr<PreparedStatement> PrepareInternal(ClientContextLock &lock, unique_ptr<SQLStatement> statement);
-	void LogQueryInternal(ClientContextLock &lock, const string &query);
-
-	unique_ptr<QueryResult> FetchResultInternal(ClientContextLock &lock, PendingQueryResult &pending);
-	unique_ptr<DataChunk> FetchInternal(ClientContextLock &lock, Executor &executor, BaseQueryResult &result);
-
-	unique_ptr<ClientContextLock> LockContext();
-
-	bool UpdateFunctionInfoFromEntry(ScalarFunctionCatalogEntry *existing_function, CreateScalarFunctionInfo *new_info);
-
-	void BeginTransactionInternal(ClientContextLock &lock, bool requires_valid_transaction);
-	void BeginQueryInternal(ClientContextLock &lock, const string &query);
-	string EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction);
-
-	PendingExecutionResult ExecuteTaskInternal(ClientContextLock &lock, PendingQueryResult &result);
-
-	unique_ptr<PendingQueryResult> PendingStatementOrPreparedStatementInternal(
-	    ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-	    shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters);
-
-	unique_ptr<PendingQueryResult> PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
-	                                                            shared_ptr<PreparedStatementData> &prepared,
-	                                                            PendingQueryParameters parameters);
-
-private:
-	//! Lock on using the ClientContext in parallel
-	mutex context_lock;
-	//! The currently active query context
-	unique_ptr<ActiveQueryContext> active_query;
-	//! The current query progress
-	atomic<double> query_progress;
-};
-
-class ClientContextLock {
-public:
-	explicit ClientContextLock(mutex &context_lock) : client_guard(context_lock) {
-	}
-
-	~ClientContextLock() {
-	}
-
-private:
-	lock_guard<mutex> client_guard;
-};
-
-class ClientContextWrapper {
-public:
-	DUCKDB_API explicit ClientContextWrapper(const shared_ptr<ClientContext> &context)
-	    : client_context(context) {
-
-	      };
-	shared_ptr<ClientContext> GetContext() {
-		auto actual_context = client_context.lock();
-		if (!actual_context) {
-			throw std::runtime_error("This connection is closed");
-		}
-		return actual_context;
-	}
-
-private:
-	std::weak_ptr<ClientContext> client_context;
-};
-
-} // namespace duckdb
-
-
-
-#include <memory>
-
-namespace duckdb {
-struct BoundStatement;
-
-class ClientContextWrapper;
-class Binder;
-class LogicalOperator;
-class QueryNode;
-class TableRef;
-
-class Relation : public std::enable_shared_from_this<Relation> {
-public:
-	DUCKDB_API Relation(const std::shared_ptr<ClientContext> &context, RelationType type)
-	    : context(context), type(type) {
-	}
-	DUCKDB_API Relation(ClientContextWrapper &context, RelationType type) : context(context.GetContext()), type(type) {
-	}
-	DUCKDB_API virtual ~Relation() {
-	}
-
-	ClientContextWrapper context;
-
-	RelationType type;
-
-	shared_ptr<ExternalDependency> extra_dependencies;
-
-public:
-	DUCKDB_API virtual const vector<ColumnDefinition> &Columns() = 0;
-	DUCKDB_API virtual unique_ptr<QueryNode> GetQueryNode();
-	DUCKDB_API virtual BoundStatement Bind(Binder &binder);
-	DUCKDB_API virtual string GetAlias();
-
-	DUCKDB_API unique_ptr<QueryResult> Execute();
-	DUCKDB_API string ToString();
-	DUCKDB_API virtual string ToString(idx_t depth) = 0;
-
-	DUCKDB_API void Print();
-	DUCKDB_API void Head(idx_t limit = 10);
-
-	DUCKDB_API shared_ptr<Relation> CreateView(const string &name, bool replace = true, bool temporary = false);
-	DUCKDB_API unique_ptr<QueryResult> Query(const string &sql);
-	DUCKDB_API unique_ptr<QueryResult> Query(const string &name, const string &sql);
-
-	//! Explain the query plan of this relation
-	DUCKDB_API unique_ptr<QueryResult> Explain();
-
-	DUCKDB_API virtual unique_ptr<TableRef> GetTableRef();
-	DUCKDB_API virtual bool IsReadOnly() {
-		return true;
-	}
-
-public:
-	// PROJECT
-	DUCKDB_API shared_ptr<Relation> Project(const string &select_list);
-	DUCKDB_API shared_ptr<Relation> Project(const string &expression, const string &alias);
-	DUCKDB_API shared_ptr<Relation> Project(const string &select_list, const vector<string> &aliases);
-	DUCKDB_API shared_ptr<Relation> Project(const vector<string> &expressions);
-	DUCKDB_API shared_ptr<Relation> Project(const vector<string> &expressions, const vector<string> &aliases);
-
-	// FILTER
-	DUCKDB_API shared_ptr<Relation> Filter(const string &expression);
-	DUCKDB_API shared_ptr<Relation> Filter(const vector<string> &expressions);
-
-	// LIMIT
-	DUCKDB_API shared_ptr<Relation> Limit(int64_t n, int64_t offset = 0);
-
-	// ORDER
-	DUCKDB_API shared_ptr<Relation> Order(const string &expression);
-	DUCKDB_API shared_ptr<Relation> Order(const vector<string> &expressions);
-
-	// JOIN operation
-	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,
-	                                     JoinType type = JoinType::INNER);
-
-	// CROSS PRODUCT operation
-	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other);
-
-	// SET operations
-	DUCKDB_API shared_ptr<Relation> Union(const shared_ptr<Relation> &other);
-	DUCKDB_API shared_ptr<Relation> Except(const shared_ptr<Relation> &other);
-	DUCKDB_API shared_ptr<Relation> Intersect(const shared_ptr<Relation> &other);
-
-	// DISTINCT operation
-	DUCKDB_API shared_ptr<Relation> Distinct();
-
-	// AGGREGATES
-	DUCKDB_API shared_ptr<Relation> Aggregate(const string &aggregate_list);
-	DUCKDB_API shared_ptr<Relation> Aggregate(const vector<string> &aggregates);
-	DUCKDB_API shared_ptr<Relation> Aggregate(const string &aggregate_list, const string &group_list);
-	DUCKDB_API shared_ptr<Relation> Aggregate(const vector<string> &aggregates, const vector<string> &groups);
-
-	// ALIAS
-	DUCKDB_API shared_ptr<Relation> Alias(const string &alias);
-
-	//! Insert the data from this relation into a table
-	DUCKDB_API void Insert(const string &table_name);
-	DUCKDB_API void Insert(const string &schema_name, const string &table_name);
-	//! Insert a row (i.e.,list of values) into a table
-	DUCKDB_API void Insert(const vector<vector<Value>> &values);
-	//! Create a table and insert the data from this relation into that table
-	DUCKDB_API void Create(const string &table_name);
-	DUCKDB_API void Create(const string &schema_name, const string &table_name);
-
-	//! Write a relation to a CSV file
-	DUCKDB_API void WriteCSV(const string &csv_file);
-
-	//! Update a table, can only be used on a TableRelation
-	DUCKDB_API virtual void Update(const string &update, const string &condition = string());
-	//! Delete from a table, can only be used on a TableRelation
-	DUCKDB_API virtual void Delete(const string &condition = string());
-	//! Create a relation from calling a table in/out function on the input relation
-	//! Create a relation from calling a table in/out function on the input relation
-	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values);
-	DUCKDB_API shared_ptr<Relation> TableFunction(const std::string &fname, const vector<Value> &values,
-	                                              const named_parameter_map_t &named_parameters);
-
-public:
-	//! Whether or not the relation inherits column bindings from its child or not, only relevant for binding
-	DUCKDB_API virtual bool InheritsColumnBindings() {
-		return false;
-	}
-	DUCKDB_API virtual Relation *ChildRelation() {
-		return nullptr;
-	}
-	DUCKDB_API vector<shared_ptr<ExternalDependency>> GetAllDependencies();
-
-protected:
-	DUCKDB_API string RenderWhitespace(idx_t depth);
-};
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-class ChunkCollection;
-class ClientContext;
-
-class DatabaseInstance;
-class DuckDB;
-class LogicalOperator;
-class SelectStatement;
-
-typedef void (*warning_callback)(std::string);
-
-//! A connection to a database. This represents a (client) connection that can
-//! be used to query the database.
-class Connection {
-public:
-	DUCKDB_API explicit Connection(DuckDB &database);
-	DUCKDB_API explicit Connection(DatabaseInstance &database);
-	DUCKDB_API ~Connection();
-
-	shared_ptr<ClientContext> context;
-	warning_callback warning_cb;
-
-public:
-	//! Returns query profiling information for the current query
-	DUCKDB_API string GetProfilingInformation(ProfilerPrintFormat format = ProfilerPrintFormat::QUERY_TREE);
-
-	//! Interrupt execution of the current query
-	DUCKDB_API void Interrupt();
-
-	//! Enable query profiling
-	DUCKDB_API void EnableProfiling();
-	//! Disable query profiling
-	DUCKDB_API void DisableProfiling();
-
-	DUCKDB_API void SetWarningCallback(warning_callback);
-
-	//! Enable aggressive verification/testing of queries, should only be used in testing
-	DUCKDB_API void EnableQueryVerification();
-	DUCKDB_API void DisableQueryVerification();
-	//! Force parallel execution, even for smaller tables. Should only be used in testing.
-	DUCKDB_API void ForceParallelism();
-
-	//! Issues a query to the database and returns a QueryResult. This result can be either a StreamQueryResult or a
-	//! MaterializedQueryResult. The result can be stepped through with calls to Fetch(). Note that there can only be
-	//! one active StreamQueryResult per Connection object. Calling SendQuery() will invalidate any previously existing
-	//! StreamQueryResult.
-	DUCKDB_API unique_ptr<QueryResult> SendQuery(const string &query);
-	//! Issues a query to the database and materializes the result (if necessary). Always returns a
-	//! MaterializedQueryResult.
-	DUCKDB_API unique_ptr<MaterializedQueryResult> Query(const string &query);
-	//! Issues a query to the database and materializes the result (if necessary). Always returns a
-	//! MaterializedQueryResult.
-	DUCKDB_API unique_ptr<MaterializedQueryResult> Query(unique_ptr<SQLStatement> statement);
-	// prepared statements
-	template <typename... Args>
-	unique_ptr<QueryResult> Query(const string &query, Args... args) {
-		vector<Value> values;
-		return QueryParamsRecursive(query, values, args...);
-	}
-
-	//! Issues a query to the database and returns a Pending Query Result. Note that "query" may only contain
-	//! a single statement.
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query, bool allow_stream_result = false);
-	//! Issues a query to the database and returns a Pending Query Result
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(unique_ptr<SQLStatement> statement,
-	                                                       bool allow_stream_result = false);
-
-	//! Prepare the specified query, returning a prepared statement object
-	DUCKDB_API unique_ptr<PreparedStatement> Prepare(const string &query);
-	//! Prepare the specified statement, returning a prepared statement object
-	DUCKDB_API unique_ptr<PreparedStatement> Prepare(unique_ptr<SQLStatement> statement);
-
-	//! Get the table info of a specific table (in the default schema), or nullptr if it cannot be found
-	DUCKDB_API unique_ptr<TableDescription> TableInfo(const string &table_name);
-	//! Get the table info of a specific table, or nullptr if it cannot be found
-	DUCKDB_API unique_ptr<TableDescription> TableInfo(const string &schema_name, const string &table_name);
-
-	//! Extract a set of SQL statements from a specific query
-	DUCKDB_API vector<unique_ptr<SQLStatement>> ExtractStatements(const string &query);
-	//! Extract the logical plan that corresponds to a query
-	DUCKDB_API unique_ptr<LogicalOperator> ExtractPlan(const string &query);
-
-	//! Appends a DataChunk to the specified table
-	DUCKDB_API void Append(TableDescription &description, DataChunk &chunk);
-	//! Appends a ChunkCollection to the specified table
-	DUCKDB_API void Append(TableDescription &description, ChunkCollection &collection);
-
-	//! Returns a relation that produces a table from this connection
-	DUCKDB_API shared_ptr<Relation> Table(const string &tname);
-	DUCKDB_API shared_ptr<Relation> Table(const string &schema_name, const string &table_name);
-	//! Returns a relation that produces a view from this connection
-	DUCKDB_API shared_ptr<Relation> View(const string &tname);
-	DUCKDB_API shared_ptr<Relation> View(const string &schema_name, const string &table_name);
-	//! Returns a relation that calls a specified table function
-	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname);
-	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values,
-	                                              const named_parameter_map_t &named_parameters);
-	DUCKDB_API shared_ptr<Relation> TableFunction(const string &tname, const vector<Value> &values);
-	//! Returns a relation that produces values
-	DUCKDB_API shared_ptr<Relation> Values(const vector<vector<Value>> &values);
-	DUCKDB_API shared_ptr<Relation> Values(const vector<vector<Value>> &values, const vector<string> &column_names,
-	                                       const string &alias = "values");
-	DUCKDB_API shared_ptr<Relation> Values(const string &values);
-	DUCKDB_API shared_ptr<Relation> Values(const string &values, const vector<string> &column_names,
-	                                       const string &alias = "values");
-	//! Reads CSV file
-	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file);
-	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, const vector<string> &columns);
-	//! Returns a relation from a query
-	DUCKDB_API shared_ptr<Relation> RelationFromQuery(const string &query, const string &alias = "queryrelation",
-	                                                  const string &error = "Expected a single SELECT statement");
-	DUCKDB_API shared_ptr<Relation> RelationFromQuery(unique_ptr<SelectStatement> select_stmt,
-	                                                  const string &alias = "queryrelation");
-
-	DUCKDB_API void BeginTransaction();
-	DUCKDB_API void Commit();
-	DUCKDB_API void Rollback();
-	DUCKDB_API void SetAutoCommit(bool auto_commit);
-	DUCKDB_API bool IsAutoCommit();
-
-	//! Fetch a list of table names that are required for a given query
-	DUCKDB_API unordered_set<string> GetTableNames(const string &query);
-
-	template <typename TR, typename... Args>
-	void CreateScalarFunction(const string &name, TR (*udf_func)(Args...)) {
-		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, Args...>(name, udf_func);
-		UDFWrapper::RegisterFunction<TR, Args...>(name, function, *context);
-	}
-
-	template <typename TR, typename... Args>
-	void CreateScalarFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                          TR (*udf_func)(Args...)) {
-		scalar_function_t function =
-		    UDFWrapper::CreateScalarFunction<TR, Args...>(name, args, std::move(ret_type), udf_func);
-		UDFWrapper::RegisterFunction(name, args, ret_type, function, *context);
-	}
-
-	template <typename TR, typename... Args>
-	void CreateVectorizedFunction(const string &name, scalar_function_t udf_func,
-	                              LogicalType varargs = LogicalType::INVALID) {
-		UDFWrapper::RegisterFunction<TR, Args...>(name, udf_func, *context, std::move(varargs));
-	}
-
-	DUCKDB_API void CreateVectorizedFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                         scalar_function_t udf_func, LogicalType varargs = LogicalType::INVALID) {
-		UDFWrapper::RegisterFunction(name, std::move(args), std::move(ret_type), udf_func, *context, std::move(varargs));
-	}
-
-	//------------------------------------- Aggreate Functions ----------------------------------------//
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	void CreateAggregateFunction(const string &name) {
-		AggregateFunction function = UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA>(name);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	void CreateAggregateFunction(const string &name) {
-		AggregateFunction function = UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	void CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_typeA) {
-		AggregateFunction function =
-		    UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA>(name, ret_type, input_typeA);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	void CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_typeA,
-	                             LogicalType input_typeB) {
-		AggregateFunction function =
-		    UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, ret_type, input_typeA, input_typeB);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-	DUCKDB_API void CreateAggregateFunction(const string &name, vector<LogicalType> arguments, LogicalType return_type,
-	                                        aggregate_size_t state_size, aggregate_initialize_t initialize,
-	                                        aggregate_update_t update, aggregate_combine_t combine,
-	                                        aggregate_finalize_t finalize,
-	                                        aggregate_simple_update_t simple_update = nullptr,
-	                                        bind_aggregate_function_t bind = nullptr,
-	                                        aggregate_destructor_t destructor = nullptr) {
-		AggregateFunction function =
-		    UDFWrapper::CreateAggregateFunction(name, arguments, return_type, state_size, initialize, update, combine,
-		                                        finalize, simple_update, bind, destructor);
-		UDFWrapper::RegisterAggrFunction(function, *context);
-	}
-
-private:
-	unique_ptr<QueryResult> QueryParamsRecursive(const string &query, vector<Value> &values);
-
-	template <typename T, typename... Args>
-	unique_ptr<QueryResult> QueryParamsRecursive(const string &query, vector<Value> &values, T value, Args... args) {
-		values.push_back(Value::CreateValue<T>(value));
-		return QueryParamsRecursive(query, values, args...);
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/database.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/config.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/replacement_scan.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ClientContext;
-class TableFunctionRef;
-
-struct ReplacementScanData {
-	virtual ~ReplacementScanData() {
-	}
-};
-
-typedef unique_ptr<TableFunctionRef> (*replacement_scan_t)(ClientContext &context, const string &table_name,
-                                                           ReplacementScanData *data);
-
-//! Replacement table scans are automatically attempted when a table name cannot be found in the schema
-//! This allows you to do e.g. SELECT * FROM 'filename.csv', and automatically convert this into a CSV scan
-struct ReplacementScan {
-	explicit ReplacementScan(replacement_scan_t function, unique_ptr<ReplacementScanData> data_p = nullptr)
-	    : function(function), data(std::move(data_p)) {
-	}
-
-	replacement_scan_t function;
-	unique_ptr<ReplacementScanData> data;
-};
-
-} // namespace duckdb
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/optimizer_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class OptimizerType : uint32_t {
-	INVALID = 0,
-	EXPRESSION_REWRITER,
-	FILTER_PULLUP,
-	FILTER_PUSHDOWN,
-	REGEX_RANGE,
-	IN_CLAUSE,
-	JOIN_ORDER,
-	DELIMINATOR,
-	UNUSED_COLUMNS,
-	STATISTICS_PROPAGATION,
-	COMMON_SUBEXPRESSIONS,
-	COMMON_AGGREGATE,
-	COLUMN_LIFETIME,
-	TOP_N,
-	REORDER_FILTER
-};
-
-string OptimizerTypeToString(OptimizerType type);
-OptimizerType OptimizerTypeFromString(const string &str);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/window_aggregation_mode.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class WindowAggregationMode : uint32_t {
-	//! Use the window aggregate API if available
-	WINDOW = 0,
-	//! Don't use window, but use combine if available
-	COMBINE,
-	//! Don't use combine or window (compute each frame separately)
-	SEPARATE
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/set_scope.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class SetScope : uint8_t {
-	AUTOMATIC = 0,
-	LOCAL = 1, /* unused */
-	SESSION = 2,
-	GLOBAL = 3
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parser_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The ParserExtensionInfo holds static information relevant to the parser extension
-//! It is made available in the parse_function, and will be kept alive as long as the database system is kept alive
-struct ParserExtensionInfo {
-	DUCKDB_API virtual ~ParserExtensionInfo() {
-	}
-};
-
-//===--------------------------------------------------------------------===//
-// Parse
-//===--------------------------------------------------------------------===//
-enum class ParserExtensionResultType : uint8_t { PARSE_SUCCESSFUL, DISPLAY_ORIGINAL_ERROR, DISPLAY_EXTENSION_ERROR };
-
-//! The ParserExtensionParseData holds the result of a successful parse step
-//! It will be passed along to the subsequent plan function
-struct ParserExtensionParseData {
-	DUCKDB_API virtual ~ParserExtensionParseData() {
-	}
-
-	virtual unique_ptr<ParserExtensionParseData> Copy() const = 0;
-};
-
-struct ParserExtensionParseResult {
-	ParserExtensionParseResult() : type(ParserExtensionResultType::DISPLAY_ORIGINAL_ERROR) {
-	}
-	ParserExtensionParseResult(string error_p)
-	    : type(ParserExtensionResultType::DISPLAY_EXTENSION_ERROR), error(std::move(error_p)) {
-	}
-	ParserExtensionParseResult(unique_ptr<ParserExtensionParseData> parse_data_p)
-	    : type(ParserExtensionResultType::PARSE_SUCCESSFUL), parse_data(std::move(parse_data_p)) {
-	}
-
-	//! Whether or not parsing was successful
-	ParserExtensionResultType type;
-	//! The parse data (if successful)
-	unique_ptr<ParserExtensionParseData> parse_data;
-	//! The error message (if unsuccessful)
-	string error;
-};
-
-typedef ParserExtensionParseResult (*parse_function_t)(ParserExtensionInfo *info, const string &query);
-//===--------------------------------------------------------------------===//
-// Plan
-//===--------------------------------------------------------------------===//
-struct ParserExtensionPlanResult {
-	//! The table function to execute
-	TableFunction function;
-	//! Parameters to the function
-	vector<Value> parameters;
-	//! Whether or not the statement is read_only (i.e. can be executed in a read_only database)
-	bool read_only = false;
-	//! Whether or not the statement requires a valid transaction to be executed
-	bool requires_valid_transaction = true;
-	//! What type of result set the statement returns
-	StatementReturnType return_type = StatementReturnType::NOTHING;
-};
-
-typedef ParserExtensionPlanResult (*plan_function_t)(ParserExtensionInfo *info, ClientContext &context,
-                                                     unique_ptr<ParserExtensionParseData> parse_data);
-
-//===--------------------------------------------------------------------===//
-// ParserExtension
-//===--------------------------------------------------------------------===//
-class ParserExtension {
-public:
-	//! The parse function of the parser extension.
-	//! Takes a query string as input and returns ParserExtensionParseData (on success) or an error
-	parse_function_t parse_function;
-
-	//! The plan function of the parser extension
-	//! Takes as input the result of the parse_function, and outputs various properties of the resulting plan
-	plan_function_t plan_function;
-
-	//! Additional parser info passed to the parse function
-	shared_ptr<ParserExtensionInfo> parser_info;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class ClientContext;
-class TableFunctionRef;
-class CompressionFunction;
-
-struct CompressionFunctionSet;
-struct DBConfig;
-
-enum class AccessMode : uint8_t { UNDEFINED = 0, AUTOMATIC = 1, READ_ONLY = 2, READ_WRITE = 3 };
-
-enum class CheckpointAbort : uint8_t {
-	NO_ABORT = 0,
-	DEBUG_ABORT_BEFORE_TRUNCATE = 1,
-	DEBUG_ABORT_BEFORE_HEADER = 2,
-	DEBUG_ABORT_AFTER_FREE_LIST_WRITE = 3
-};
-
-typedef void (*set_global_function_t)(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-typedef void (*set_local_function_t)(ClientContext &context, const Value &parameter);
-typedef Value (*get_setting_function_t)(ClientContext &context);
-
-struct ConfigurationOption {
-	const char *name;
-	const char *description;
-	LogicalTypeId parameter_type;
-	set_global_function_t set_global;
-	set_local_function_t set_local;
-	get_setting_function_t get_setting;
-};
-
-typedef void (*set_option_callback_t)(ClientContext &context, SetScope scope, Value &parameter);
-
-struct ExtensionOption {
-	ExtensionOption(string description_p, LogicalType type_p, set_option_callback_t set_function_p)
-	    : description(std::move(description_p)), type(std::move(type_p)), set_function(set_function_p) {
-	}
-
-	string description;
-	LogicalType type;
-	set_option_callback_t set_function;
-};
-
-struct DBConfig {
-	friend class DatabaseInstance;
-	friend class StorageManager;
-
-public:
-	DUCKDB_API DBConfig();
-	DUCKDB_API ~DBConfig();
-
-	//! Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)
-	AccessMode access_mode = AccessMode::AUTOMATIC;
-	//! The allocator used by the system
-	unique_ptr<Allocator> allocator;
-	// Checkpoint when WAL reaches this size (default: 16MB)
-	idx_t checkpoint_wal_size = 1 << 24;
-	//! Whether or not to use Direct IO, bypassing operating system buffers
-	bool use_direct_io = false;
-	//! Whether extensions should be loaded on start-up
-	bool load_extensions = true;
-	//! The FileSystem to use, can be overwritten to allow for injecting custom file systems for testing purposes (e.g.
-	//! RamFS or something similar)
-	unique_ptr<FileSystem> file_system;
-	//! The maximum memory used by the database system (in bytes). Default: 80% of System available memory
-	idx_t maximum_memory = (idx_t)-1;
-	//! The maximum amount of CPU threads used by the database system. Default: all available.
-	idx_t maximum_threads = (idx_t)-1;
-	//! The number of external threads that work on DuckDB tasks. Default: none.
-	idx_t external_threads = 0;
-	//! Whether or not to create and use a temporary directory to store intermediates that do not fit in memory
-	bool use_temporary_directory = true;
-	//! Directory to store temporary structures that do not fit in memory
-	string temporary_directory;
-	//! The collation type of the database
-	string collation = string();
-	//! The order type used when none is specified (default: ASC)
-	OrderType default_order_type = OrderType::ASCENDING;
-	//! Null ordering used when none is specified (default: NULLS FIRST)
-	OrderByNullType default_null_order = OrderByNullType::NULLS_FIRST;
-	//! enable COPY and related commands
-	bool enable_external_access = true;
-	//! Whether or not object cache is used
-	bool object_cache_enable = false;
-	//! Force checkpoint when CHECKPOINT is called or on shutdown, even if no changes have been made
-	bool force_checkpoint = false;
-	//! Run a checkpoint on successful shutdown and delete the WAL, to leave only a single database file behind
-	bool checkpoint_on_shutdown = true;
-	//! Debug flag that decides when a checkpoing should be aborted. Only used for testing purposes.
-	CheckpointAbort checkpoint_abort = CheckpointAbort::NO_ABORT;
-	//! Replacement table scans are automatically attempted when a table name cannot be found in the schema
-	vector<ReplacementScan> replacement_scans;
-	//! Initialize the database with the standard set of DuckDB functions
-	//! You should probably not touch this unless you know what you are doing
-	bool initialize_default_database = true;
-	//! The set of disabled optimizers (default empty)
-	set<OptimizerType> disabled_optimizers;
-	//! Force a specific compression method to be used when checkpointing (if available)
-	CompressionType force_compression = CompressionType::COMPRESSION_AUTO;
-	//! Debug flag that adds additional (unnecessary) free_list blocks to the storage
-	bool debug_many_free_list_blocks = false;
-	//! Debug setting for window aggregation mode: (window, combine, separate)
-	WindowAggregationMode window_mode = WindowAggregationMode::WINDOW;
-	//! Whether or not preserving insertion order should be preserved
-	bool preserve_insertion_order = true;
-	//! Extensions made to the parser
-	vector<ParserExtension> parser_extensions;
-
-	//! Extra parameters that can be SET for loaded extensions
-	case_insensitive_map_t<ExtensionOption> extension_parameters;
-	//! Database configuration variables as controlled by SET
-	case_insensitive_map_t<Value> set_variables;
-
-	DUCKDB_API void AddExtensionOption(string name, string description, LogicalType parameter,
-	                                   set_option_callback_t function = nullptr);
-
-public:
-	DUCKDB_API static DBConfig &GetConfig(ClientContext &context);
-	DUCKDB_API static DBConfig &GetConfig(DatabaseInstance &db);
-	DUCKDB_API static vector<ConfigurationOption> GetOptions();
-	DUCKDB_API static idx_t GetOptionCount();
-
-	//! Fetch an option by index. Returns a pointer to the option, or nullptr if out of range
-	DUCKDB_API static ConfigurationOption *GetOptionByIndex(idx_t index);
-	//! Fetch an option by name. Returns a pointer to the option, or nullptr if none exists.
-	DUCKDB_API static ConfigurationOption *GetOptionByName(const string &name);
-
-	DUCKDB_API void SetOption(const ConfigurationOption &option, const Value &value);
-
-	DUCKDB_API static idx_t ParseMemoryLimit(const string &arg);
-
-	//! Return the list of possible compression functions for the specific physical type
-	DUCKDB_API vector<CompressionFunction *> GetCompressionFunctions(PhysicalType data_type);
-	//! Return the compression function for the specified compression type/physical type combo
-	DUCKDB_API CompressionFunction *GetCompressionFunction(CompressionType type, PhysicalType data_type);
-
-private:
-	unique_ptr<CompressionFunctionSet> compression_functions;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class DuckDB;
-
-//! The Extension class is the base class used to define extensions
-class Extension {
-public:
-	DUCKDB_API virtual ~Extension();
-
-	DUCKDB_API virtual void Load(DuckDB &db) = 0;
-	DUCKDB_API virtual std::string Name() = 0;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class StorageManager;
-class Catalog;
-class TransactionManager;
-class ConnectionManager;
-class FileSystem;
-class TaskScheduler;
-class ObjectCache;
-
-class DatabaseInstance : public std::enable_shared_from_this<DatabaseInstance> {
-	friend class DuckDB;
-
-public:
-	DUCKDB_API DatabaseInstance();
-	DUCKDB_API ~DatabaseInstance();
-
-	DBConfig config;
-
-public:
-	DUCKDB_API StorageManager &GetStorageManager();
-	DUCKDB_API Catalog &GetCatalog();
-	DUCKDB_API FileSystem &GetFileSystem();
-	DUCKDB_API TransactionManager &GetTransactionManager();
-	DUCKDB_API TaskScheduler &GetScheduler();
-	DUCKDB_API ObjectCache &GetObjectCache();
-	DUCKDB_API ConnectionManager &GetConnectionManager();
-
-	idx_t NumberOfThreads();
-
-	DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context);
-
-	DUCKDB_API const unordered_set<std::string> &LoadedExtensions();
-
-private:
-	void Initialize(const char *path, DBConfig *config);
-
-	void Configure(DBConfig &config);
-
-private:
-	unique_ptr<StorageManager> storage;
-	unique_ptr<Catalog> catalog;
-	unique_ptr<TransactionManager> transaction_manager;
-	unique_ptr<TaskScheduler> scheduler;
-	unique_ptr<ObjectCache> object_cache;
-	unique_ptr<ConnectionManager> connection_manager;
-	unordered_set<std::string> loaded_extensions;
-};
-
-//! The database object. This object holds the catalog and all the
-//! database-specific meta information.
-class DuckDB {
-public:
-	DUCKDB_API explicit DuckDB(const char *path = nullptr, DBConfig *config = nullptr);
-	DUCKDB_API explicit DuckDB(const string &path, DBConfig *config = nullptr);
-	DUCKDB_API explicit DuckDB(DatabaseInstance &instance);
-
-	DUCKDB_API ~DuckDB();
-
-	//! Reference to the actual database instance
-	shared_ptr<DatabaseInstance> instance;
-
-public:
-	template <class T>
-	void LoadExtension() {
-		T extension;
-		if (ExtensionIsLoaded(extension.Name())) {
-			return;
-		}
-		extension.Load(*this);
-		SetExtensionLoaded(extension.Name());
-	}
-
-	DUCKDB_API FileSystem &GetFileSystem();
-
-	DUCKDB_API idx_t NumberOfThreads();
-	DUCKDB_API static const char *SourceID();
-	DUCKDB_API static const char *LibraryVersion();
-	DUCKDB_API static string Platform();
-	DUCKDB_API bool ExtensionIsLoaded(const std::string &name);
-	DUCKDB_API void SetExtensionLoaded(const std::string &name);
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/loadable_extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#if defined(DUCKDB_BUILD_LOADABLE_EXTENSION) && defined(DUCKDB_EXTENSION_MAIN)
-#ifdef _WIN32
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-
-#ifndef _WINSOCKAPI_
-#define _WINSOCKAPI_
-#endif
-#include <windows.h>
-
-#undef CreateDirectory
-#undef MoveFile
-#undef RemoveDirectory
-
-#include <delayimp.h>
-
-extern "C" {
-/*
-This is interesting: Windows would normally require a duckdb.dll being on the DLL search path when we load an extension
-using LoadLibrary(). However, there is likely no such dll, because DuckDB was statically linked, or is running as part
-of an R or Python module with a completely different name (that we don't know) or something of the sorts. Amazingly,
-Windows supports lazy-loading DLLs by linking them with /DELAYLOAD. Then a callback will be triggered whenever we access
-symbols in the extension. Since DuckDB is already running in the host process (hopefully), we can use
-GetModuleHandle(NULL) to return the current process so the symbols are looked for there. See here for another
-explanation of this crazy process:
-
-* https://docs.microsoft.com/en-us/cpp/build/reference/linker-support-for-delay-loaded-dlls?view=msvc-160
-* https://docs.microsoft.com/en-us/cpp/build/reference/understanding-the-helper-function?view=msvc-160
-*/
-FARPROC WINAPI duckdb_dllimport_delay_hook(unsigned dliNotify, PDelayLoadInfo pdli) {
-	switch (dliNotify) {
-	case dliNotePreLoadLibrary:
-		if (strcmp(pdli->szDll, "duckdb.dll") != 0) {
-			return NULL;
-		}
-		return (FARPROC)GetModuleHandle(NULL);
-	default:
-		return NULL;
-	}
-
-	return NULL;
-}
-
-ExternC const PfnDliHook __pfnDliNotifyHook2 = duckdb_dllimport_delay_hook;
-ExternC const PfnDliHook __pfnDliFailureHook2 = duckdb_dllimport_delay_hook;
-}
-#endif
-#endif
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/date.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The Date class is a static class that holds helper functions for the Date type.
-class Date {
-public:
-	static const char *PINF;  // NOLINT
-	static const char *NINF;  // NOLINT
-	static const char *EPOCH; // NOLINT
-
-	static const string_t MONTH_NAMES[12];
-	static const string_t MONTH_NAMES_ABBREVIATED[12];
-	static const string_t DAY_NAMES[7];
-	static const string_t DAY_NAMES_ABBREVIATED[7];
-	static const int32_t NORMAL_DAYS[13];
-	static const int32_t CUMULATIVE_DAYS[13];
-	static const int32_t LEAP_DAYS[13];
-	static const int32_t CUMULATIVE_LEAP_DAYS[13];
-	static const int32_t CUMULATIVE_YEAR_DAYS[401];
-	static const int8_t MONTH_PER_DAY_OF_YEAR[365];
-	static const int8_t LEAP_MONTH_PER_DAY_OF_YEAR[366];
-
-	// min date is 5877642-06-25 (BC) (-2^31+2)
-	constexpr static const int32_t DATE_MIN_YEAR = -5877641;
-	constexpr static const int32_t DATE_MIN_MONTH = 6;
-	constexpr static const int32_t DATE_MIN_DAY = 25;
-	// max date is 5881580-07-10 (2^31-2)
-	constexpr static const int32_t DATE_MAX_YEAR = 5881580;
-	constexpr static const int32_t DATE_MAX_MONTH = 7;
-	constexpr static const int32_t DATE_MAX_DAY = 10;
-	constexpr static const int32_t EPOCH_YEAR = 1970;
-
-	constexpr static const int32_t YEAR_INTERVAL = 400;
-	constexpr static const int32_t DAYS_PER_YEAR_INTERVAL = 146097;
-
-public:
-	//! Convert a string in the format "YYYY-MM-DD" to a date object
-	DUCKDB_API static date_t FromString(const string &str, bool strict = false);
-	//! Convert a string in the format "YYYY-MM-DD" to a date object
-	DUCKDB_API static date_t FromCString(const char *str, idx_t len, bool strict = false);
-	//! Convert a date object to a string in the format "YYYY-MM-DD"
-	DUCKDB_API static string ToString(date_t date);
-	//! Try to convert text in a buffer to a date; returns true if parsing was successful
-	DUCKDB_API static bool TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool strict = false);
-
-	//! Create a string "YYYY-MM-DD" from a specified (year, month, day)
-	//! combination
-	DUCKDB_API static string Format(int32_t year, int32_t month, int32_t day);
-
-	//! Extract the year, month and day from a given date object
-	DUCKDB_API static void Convert(date_t date, int32_t &out_year, int32_t &out_month, int32_t &out_day);
-	//! Create a Date object from a specified (year, month, day) combination
-	DUCKDB_API static date_t FromDate(int32_t year, int32_t month, int32_t day);
-	DUCKDB_API static bool TryFromDate(int32_t year, int32_t month, int32_t day, date_t &result);
-
-	//! Returns true if (year) is a leap year, and false otherwise
-	DUCKDB_API static bool IsLeapYear(int32_t year);
-
-	//! Returns true if the specified (year, month, day) combination is a valid
-	//! date
-	DUCKDB_API static bool IsValid(int32_t year, int32_t month, int32_t day);
-
-	//! Returns true if the specified date is finite
-	static inline bool IsFinite(date_t date) {
-		return date != date_t::infinity() && date != date_t::ninfinity();
-	}
-
-	//! The max number of days in a month of a given year
-	DUCKDB_API static int32_t MonthDays(int32_t year, int32_t month);
-
-	//! Extract the epoch from the date (seconds since 1970-01-01)
-	DUCKDB_API static int64_t Epoch(date_t date);
-	//! Extract the epoch from the date (nanoseconds since 1970-01-01)
-	DUCKDB_API static int64_t EpochNanoseconds(date_t date);
-	//! Convert the epoch (seconds since 1970-01-01) to a date_t
-	DUCKDB_API static date_t EpochToDate(int64_t epoch);
-
-	//! Extract the number of days since epoch (days since 1970-01-01)
-	DUCKDB_API static int32_t EpochDays(date_t date);
-	//! Convert the epoch number of days to a date_t
-	DUCKDB_API static date_t EpochDaysToDate(int32_t epoch);
-
-	//! Extract year of a date entry
-	DUCKDB_API static int32_t ExtractYear(date_t date);
-	//! Extract year of a date entry, but optimized to first try the last year found
-	DUCKDB_API static int32_t ExtractYear(date_t date, int32_t *last_year);
-	DUCKDB_API static int32_t ExtractYear(timestamp_t ts, int32_t *last_year);
-	//! Extract month of a date entry
-	DUCKDB_API static int32_t ExtractMonth(date_t date);
-	//! Extract day of a date entry
-	DUCKDB_API static int32_t ExtractDay(date_t date);
-	//! Extract the day of the week (1-7)
-	DUCKDB_API static int32_t ExtractISODayOfTheWeek(date_t date);
-	//! Extract the day of the year
-	DUCKDB_API static int32_t ExtractDayOfTheYear(date_t date);
-	//! Extract the ISO week number
-	//! ISO weeks start on Monday and the first week of a year
-	//! contains January 4 of that year.
-	//! In the ISO week-numbering system, it is possible for early-January dates
-	//! to be part of the 52nd or 53rd week of the previous year.
-	DUCKDB_API static void ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week);
-	DUCKDB_API static int32_t ExtractISOWeekNumber(date_t date);
-	DUCKDB_API static int32_t ExtractISOYearNumber(date_t date);
-	//! Extract the week number as Python handles it.
-	//! Either Monday or Sunday is the first day of the week,
-	//! and any date before the first Monday/Sunday returns week 0
-	//! This is a bit more consistent because week numbers in a year are always incrementing
-	DUCKDB_API static int32_t ExtractWeekNumberRegular(date_t date, bool monday_first = true);
-	//! Returns the date of the monday of the current week.
-	DUCKDB_API static date_t GetMondayOfCurrentWeek(date_t date);
-
-	//! Helper function to parse two digits from a string (e.g. "30" -> 30, "03" -> 3, "3" -> 3)
-	DUCKDB_API static bool ParseDoubleDigit(const char *buf, idx_t len, idx_t &pos, int32_t &result);
-
-	DUCKDB_API static string ConversionError(const string &str);
-	DUCKDB_API static string ConversionError(string_t str);
-
-private:
-	static void ExtractYearOffset(int32_t &n, int32_t &year, int32_t &year_offset);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/blob.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! The Blob class is a static class that holds helper functions for the Blob type.
-class Blob {
-public:
-	// map of integer -> hex value
-	static constexpr const char *HEX_TABLE = "0123456789ABCDEF";
-	// reverse map of byte -> integer value, or -1 for invalid hex values
-	static const int HEX_MAP[256];
-	//! map of index -> base64 character
-	static constexpr const char *BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-	//! padding character used in base64 encoding
-	static constexpr const char BASE64_PADDING = '=';
-
-public:
-	//! Returns the string size of a blob -> string conversion
-	static idx_t GetStringSize(string_t blob);
-	//! Converts a blob to a string, writing the output to the designated output string.
-	//! The string needs to have space for at least GetStringSize(blob) bytes.
-	static void ToString(string_t blob, char *output);
-	//! Convert a blob object to a string
-	static string ToString(string_t blob);
-
-	//! Returns the blob size of a string -> blob conversion
-	static bool TryGetBlobSize(string_t str, idx_t &result_size, string *error_message);
-	static idx_t GetBlobSize(string_t str);
-	//! Convert a string to a blob. This function should ONLY be called after calling GetBlobSize, since it does NOT
-	//! perform data validation.
-	static void ToBlob(string_t str, data_ptr_t output);
-	//! Convert a string object to a blob
-	static string ToBlob(string_t str);
-
-	// base 64 conversion functions
-	//! Returns the string size of a blob -> base64 conversion
-	static idx_t ToBase64Size(string_t blob);
-	//! Converts a blob to a base64 string, output should have space for at least ToBase64Size(blob) bytes
-	static void ToBase64(string_t blob, char *output);
-
-	//! Returns the string size of a base64 string -> blob conversion
-	static idx_t FromBase64Size(string_t str);
-	//! Converts a base64 string to a blob, output should have space for at least FromBase64Size(blob) bytes
-	static void FromBase64(string_t str, data_ptr_t output, idx_t output_size);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/decimal.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The Decimal class is a static class that holds helper functions for the Decimal type
-class Decimal {
-public:
-	static constexpr uint8_t MAX_WIDTH_INT16 = 4;
-	static constexpr uint8_t MAX_WIDTH_INT32 = 9;
-	static constexpr uint8_t MAX_WIDTH_INT64 = 18;
-	static constexpr uint8_t MAX_WIDTH_INT128 = 38;
-	static constexpr uint8_t MAX_WIDTH_DECIMAL = MAX_WIDTH_INT128;
-
-public:
-	static string ToString(int16_t value, uint8_t scale);
-	static string ToString(int32_t value, uint8_t scale);
-	static string ToString(int64_t value, uint8_t scale);
-	static string ToString(hugeint_t value, uint8_t scale);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/uuid.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-struct RandomEngine;
-
-//! The UUID class contains static operations for the UUID type
-class UUID {
-public:
-	constexpr static const uint8_t STRING_SIZE = 36;
-	//! Convert a uuid string to a hugeint object
-	static bool FromString(string str, hugeint_t &result);
-	//! Convert a uuid string to a hugeint object
-	static bool FromCString(const char *str, idx_t len, hugeint_t &result) {
-		return FromString(string(str, 0, len), result);
-	}
-	//! Convert a hugeint object to a uuid style string
-	static void ToString(hugeint_t input, char *buf);
-
-	//! Convert a hugeint object to a uuid style string
-	static hugeint_t GenerateRandomUUID(RandomEngine &engine);
-	static hugeint_t GenerateRandomUUID();
-
-	//! Convert a hugeint object to a uuid style string
-	static string ToString(hugeint_t input) {
-		char buff[STRING_SIZE];
-		ToString(input, buff);
-		return string(buff, STRING_SIZE);
-	}
-
-	static hugeint_t FromString(string str) {
-		hugeint_t result;
-		FromString(str, result);
-		return result;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/timestamp.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The Timestamp class is a static class that holds helper functions for the Timestamp
-//! type.
-class Timestamp {
-public:
-	// min timestamp is 290308-12-22 (BC)
-	constexpr static const int32_t MIN_YEAR = -290308;
-	constexpr static const int32_t MIN_MONTH = 12;
-	constexpr static const int32_t MIN_DAY = 22;
-
-public:
-	//! Convert a string in the format "YYYY-MM-DD hh:mm:ss" to a timestamp object
-	DUCKDB_API static timestamp_t FromString(const string &str);
-	DUCKDB_API static bool TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result);
-	DUCKDB_API static timestamp_t FromCString(const char *str, idx_t len);
-	//! Convert a date object to a string in the format "YYYY-MM-DD hh:mm:ss"
-	DUCKDB_API static string ToString(timestamp_t timestamp);
-
-	DUCKDB_API static date_t GetDate(timestamp_t timestamp);
-
-	DUCKDB_API static dtime_t GetTime(timestamp_t timestamp);
-	//! Create a Timestamp object from a specified (date, time) combination
-	DUCKDB_API static timestamp_t FromDatetime(date_t date, dtime_t time);
-	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_t time, timestamp_t &result);
-
-	//! Is the timestamp finite or infinite?
-	static inline bool IsFinite(timestamp_t timestamp) {
-		return timestamp != timestamp_t::infinity() && timestamp != timestamp_t::ninfinity();
-	}
-
-	//! Extract the date and time from a given timestamp object
-	DUCKDB_API static void Convert(timestamp_t date, date_t &out_date, dtime_t &out_time);
-	//! Returns current timestamp
-	DUCKDB_API static timestamp_t GetCurrentTimestamp();
-
-	//! Convert the epoch (in sec) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochSeconds(int64_t ms);
-	//! Convert the epoch (in ms) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochMs(int64_t ms);
-	//! Convert the epoch (in microseconds) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochMicroSeconds(int64_t micros);
-	//! Convert the epoch (in nanoseconds) to a timestamp
-	DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t micros);
-
-	//! Convert the epoch (in seconds) to a timestamp
-	DUCKDB_API static int64_t GetEpochSeconds(timestamp_t timestamp);
-	//! Convert the epoch (in ms) to a timestamp
-	DUCKDB_API static int64_t GetEpochMs(timestamp_t timestamp);
-	//! Convert a timestamp to epoch (in microseconds)
-	DUCKDB_API static int64_t GetEpochMicroSeconds(timestamp_t timestamp);
-	//! Convert a timestamp to epoch (in nanoseconds)
-	DUCKDB_API static int64_t GetEpochNanoSeconds(timestamp_t timestamp);
-
-	DUCKDB_API static bool TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset,
-	                                         int &minute_offset);
-
-	DUCKDB_API static string ConversionError(const string &str);
-	DUCKDB_API static string ConversionError(string_t str);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/time.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! The Time class is a static class that holds helper functions for the Time
-//! type.
-class Time {
-public:
-	//! Convert a string in the format "hh:mm:ss" to a time object
-	DUCKDB_API static dtime_t FromString(const string &str, bool strict = false);
-	DUCKDB_API static dtime_t FromCString(const char *buf, idx_t len, bool strict = false);
-	DUCKDB_API static bool TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict = false);
-
-	//! Convert a time object to a string in the format "hh:mm:ss"
-	DUCKDB_API static string ToString(dtime_t time);
-	//! Convert a UTC offset to ±HH[:MM]
-	DUCKDB_API static string ToUTCOffset(int hour_offset, int minute_offset);
-
-	DUCKDB_API static dtime_t FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds = 0);
-
-	//! Extract the time from a given timestamp object
-	DUCKDB_API static void Convert(dtime_t time, int32_t &out_hour, int32_t &out_min, int32_t &out_sec,
-	                               int32_t &out_micros);
-
-	DUCKDB_API static string ConversionError(const string &str);
-	DUCKDB_API static string ConversionError(string_t str);
-
-private:
-	static bool TryConvertInternal(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/buffered_serializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-#define SERIALIZER_DEFAULT_SIZE 1024
-
-struct BinaryData {
-	unique_ptr<data_t[]> data;
-	idx_t size;
-};
-
-class BufferedSerializer : public Serializer {
-public:
-	//! Serializes to a buffer allocated by the serializer, will expand when
-	//! writing past the initial threshold
-	explicit BufferedSerializer(idx_t maximum_size = SERIALIZER_DEFAULT_SIZE);
-	//! Serializes to a provided (owned) data pointer
-	BufferedSerializer(unique_ptr<data_t[]> data, idx_t size);
-	BufferedSerializer(data_ptr_t data, idx_t size);
-
-	idx_t maximum_size;
-	data_ptr_t data;
-
-	BinaryData blob;
-
-public:
-	void WriteData(const_data_ptr_t buffer, uint64_t write_size) override;
-
-	//! Retrieves the data after the writing has been completed
-	BinaryData GetData() {
-		return std::move(blob);
-	}
-
-	void Reset() {
-		blob.size = 0;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/appender.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-class ClientContext;
-class DuckDB;
-class TableCatalogEntry;
-class Connection;
-
-//! The Appender class can be used to append elements to a table.
-class BaseAppender {
-protected:
-	//! The amount of chunks that will be gathered in the chunk collection before flushing
-	static constexpr const idx_t FLUSH_COUNT = 100;
-
-	Allocator &allocator;
-	//! The append types
-	vector<LogicalType> types;
-	//! The buffered data for the append
-	ChunkCollection collection;
-	//! Internal chunk used for appends
-	unique_ptr<DataChunk> chunk;
-	//! The current column to append to
-	idx_t column = 0;
-
-public:
-	DUCKDB_API BaseAppender(Allocator &allocator);
-	DUCKDB_API BaseAppender(Allocator &allocator, vector<LogicalType> types);
-	DUCKDB_API virtual ~BaseAppender();
-
-	//! Begins a new row append, after calling this the other AppendX() functions
-	//! should be called the correct amount of times. After that,
-	//! EndRow() should be called.
-	DUCKDB_API void BeginRow();
-	//! Finishes appending the current row.
-	DUCKDB_API void EndRow();
-
-	// Append functions
-	template <class T>
-	void Append(T value) {
-		throw Exception("Undefined type for Appender::Append!");
-	}
-
-	DUCKDB_API void Append(const char *value, uint32_t length);
-
-	// prepared statements
-	template <typename... Args>
-	void AppendRow(Args... args) {
-		BeginRow();
-		AppendRowRecursive(args...);
-	}
-
-	//! Commit the changes made by the appender.
-	DUCKDB_API void Flush();
-	//! Flush the changes made by the appender and close it. The appender cannot be used after this point
-	DUCKDB_API void Close();
-
-	DUCKDB_API vector<LogicalType> &GetTypes() {
-		return types;
-	}
-	DUCKDB_API idx_t CurrentColumn() {
-		return column;
-	}
-	DUCKDB_API void AppendDataChunk(DataChunk &value);
-
-protected:
-	void Destructor();
-	virtual void FlushInternal(ChunkCollection &collection) = 0;
-	void InitializeChunk();
-	void FlushChunk();
-
-	template <class T>
-	void AppendValueInternal(T value);
-	template <class SRC, class DST>
-	void AppendValueInternal(Vector &vector, SRC input);
-
-	void AppendRowRecursive() {
-		EndRow();
-	}
-
-	template <typename T, typename... Args>
-	void AppendRowRecursive(T value, Args... args) {
-		Append<T>(value);
-		AppendRowRecursive(args...);
-	}
-
-	void AppendValue(const Value &value);
-};
-
-class Appender : public BaseAppender {
-	//! A reference to a database connection that created this appender
-	shared_ptr<ClientContext> context;
-	//! The table description (including column names)
-	unique_ptr<TableDescription> description;
-
-public:
-	DUCKDB_API Appender(Connection &con, const string &schema_name, const string &table_name);
-	DUCKDB_API Appender(Connection &con, const string &table_name);
-	DUCKDB_API ~Appender() override;
-
-protected:
-	void FlushInternal(ChunkCollection &collection) override;
-};
-
-class InternalAppender : public BaseAppender {
-	//! The client context
-	ClientContext &context;
-	//! The internal table entry to append to
-	TableCatalogEntry &table;
-
-public:
-	DUCKDB_API InternalAppender(ClientContext &context, TableCatalogEntry &table);
-	DUCKDB_API ~InternalAppender() override;
-
-protected:
-	void FlushInternal(ChunkCollection &collection) override;
-};
-
-template <>
-DUCKDB_API void BaseAppender::Append(bool value);
-template <>
-DUCKDB_API void BaseAppender::Append(int8_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(int16_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(int32_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(int64_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(hugeint_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uint8_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uint16_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uint32_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(uint64_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(float value);
-template <>
-DUCKDB_API void BaseAppender::Append(double value);
-template <>
-DUCKDB_API void BaseAppender::Append(date_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(dtime_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(timestamp_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(interval_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(const char *value);
-template <>
-DUCKDB_API void BaseAppender::Append(string_t value);
-template <>
-DUCKDB_API void BaseAppender::Append(Value value);
-template <>
-DUCKDB_API void BaseAppender::Append(std::nullptr_t value);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_table_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreateFunctionInfo : public CreateInfo {
-	explicit CreateFunctionInfo(CatalogType type, string schema = DEFAULT_SCHEMA) : CreateInfo(type, schema) {
-		D_ASSERT(type == CatalogType::SCALAR_FUNCTION_ENTRY || type == CatalogType::AGGREGATE_FUNCTION_ENTRY ||
-		         type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY ||
-		         type == CatalogType::MACRO_ENTRY || type == CatalogType::TABLE_MACRO_ENTRY);
-	}
-
-	//! Function name
-	string name;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/function_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-template <class T>
-class FunctionSet {
-public:
-	explicit FunctionSet(string name) : name(name) {
-	}
-
-	//! The name of the function set
-	string name;
-	//! The set of functions
-	vector<T> functions;
-
-public:
-	void AddFunction(T function) {
-		function.name = name;
-		functions.push_back(function);
-	}
-};
-
-class ScalarFunctionSet : public FunctionSet<ScalarFunction> {
-public:
-	explicit ScalarFunctionSet(string name) : FunctionSet(std::move(name)) {
-	}
-};
-
-class AggregateFunctionSet : public FunctionSet<AggregateFunction> {
-public:
-	explicit AggregateFunctionSet(string name) : FunctionSet(std::move(name)) {
-	}
-};
-
-class TableFunctionSet : public FunctionSet<TableFunction> {
-public:
-	explicit TableFunctionSet(string name) : FunctionSet(std::move(name)) {
-	}
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct CreateTableFunctionInfo : public CreateFunctionInfo {
-	explicit CreateTableFunctionInfo(TableFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY), functions(std::move(set.functions)) {
-		this->name = set.name;
-	}
-	explicit CreateTableFunctionInfo(TableFunction function) : CreateFunctionInfo(CatalogType::TABLE_FUNCTION_ENTRY) {
-		this->name = function.name;
-		functions.push_back(std::move(function));
-	}
-
-	//! The table functions
-	vector<TableFunction> functions;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		TableFunctionSet set(name);
-		set.functions = functions;
-		auto result = make_unique<CreateTableFunctionInfo>(std::move(set));
-		CopyProperties(*result);
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_copy_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/copy_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/copy_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CopyInfo : public ParseInfo {
-	CopyInfo() : schema(DEFAULT_SCHEMA) {
-	}
-
-	//! The schema name to copy to/from
-	string schema;
-	//! The table name to copy to/from
-	string table;
-	//! List of columns to copy to/from
-	vector<string> select_list;
-	//! The file path to copy to/from
-	string file_path;
-	//! Whether or not this is a copy to file (false) or copy from a file (true)
-	bool is_from;
-	//! The file format of the external file
-	string format;
-	//! Set of (key, value) options
-	unordered_map<string, vector<Value>> options;
-
-public:
-	unique_ptr<CopyInfo> Copy() const {
-		auto result = make_unique<CopyInfo>();
-		result->schema = schema;
-		result->table = table;
-		result->select_list = select_list;
-		result->file_path = file_path;
-		result->is_from = is_from;
-		result->format = format;
-		result->options = options;
-		return result;
-	}
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class ExecutionContext;
-
-struct LocalFunctionData {
-	virtual ~LocalFunctionData() {
-	}
-};
-
-struct GlobalFunctionData {
-	virtual ~GlobalFunctionData() {
-	}
-};
-
-typedef unique_ptr<FunctionData> (*copy_to_bind_t)(ClientContext &context, CopyInfo &info, vector<string> &names,
-                                                   vector<LogicalType> &sql_types);
-typedef unique_ptr<LocalFunctionData> (*copy_to_initialize_local_t)(ExecutionContext &context, FunctionData &bind_data);
-typedef unique_ptr<GlobalFunctionData> (*copy_to_initialize_global_t)(ClientContext &context, FunctionData &bind_data,
-                                                                      const string &file_path);
-typedef void (*copy_to_sink_t)(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                               LocalFunctionData &lstate, DataChunk &input);
-typedef void (*copy_to_combine_t)(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
-                                  LocalFunctionData &lstate);
-typedef void (*copy_to_finalize_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate);
-
-typedef unique_ptr<FunctionData> (*copy_from_bind_t)(ClientContext &context, CopyInfo &info,
-                                                     vector<string> &expected_names,
-                                                     vector<LogicalType> &expected_types);
-
-class CopyFunction : public Function {
-public:
-	explicit CopyFunction(string name)
-	    : Function(name), copy_to_bind(nullptr), copy_to_initialize_local(nullptr), copy_to_initialize_global(nullptr),
-	      copy_to_sink(nullptr), copy_to_combine(nullptr), copy_to_finalize(nullptr), copy_from_bind(nullptr) {
-	}
-
-	copy_to_bind_t copy_to_bind;
-	copy_to_initialize_local_t copy_to_initialize_local;
-	copy_to_initialize_global_t copy_to_initialize_global;
-	copy_to_sink_t copy_to_sink;
-	copy_to_combine_t copy_to_combine;
-	copy_to_finalize_t copy_to_finalize;
-
-	copy_from_bind_t copy_from_bind;
-	TableFunction copy_from_function;
-
-	string extension;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct CreateCopyFunctionInfo : public CreateInfo {
-	explicit CreateCopyFunctionInfo(CopyFunction function)
-	    : CreateInfo(CatalogType::COPY_FUNCTION_ENTRY), function(function) {
-		this->name = function.name;
-	}
-
-	//! Function name
-	string name;
-	//! The table function
-	CopyFunction function;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateCopyFunctionInfo>(function);
-		CopyProperties(*result);
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_scalar_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreateScalarFunctionInfo : public CreateFunctionInfo {
-	explicit CreateScalarFunctionInfo(ScalarFunction function)
-	    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY) {
-		this->name = function.name;
-		functions.push_back(function);
-	}
-	explicit CreateScalarFunctionInfo(ScalarFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(std::move(set.functions)) {
-		this->name = set.name;
-		for (auto &func : functions) {
-			func.name = set.name;
-		}
-	}
-
-	vector<ScalarFunction> functions;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		ScalarFunctionSet set(name);
-		set.functions = functions;
-		auto result = make_unique<CreateScalarFunctionInfo>(std::move(set));
-		CopyProperties(*result);
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-//! A table function in the catalog
-class ScalarFunctionCatalogEntry : public StandardEntry {
-public:
-	ScalarFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateScalarFunctionInfo *info)
-	    : StandardEntry(CatalogType::SCALAR_FUNCTION_ENTRY, schema, catalog, info->name), functions(info->functions) {
-	}
-
-	//! The scalar functions
-	vector<ScalarFunction> functions;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_table_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreateTableInfo : public CreateInfo {
-	CreateTableInfo() : CreateInfo(CatalogType::TABLE_ENTRY, INVALID_SCHEMA) {
-	}
-	CreateTableInfo(string schema, string name) : CreateInfo(CatalogType::TABLE_ENTRY, schema), table(name) {
-	}
-
-	//! Table name to insert to
-	string table;
-	//! List of columns of the table
-	vector<ColumnDefinition> columns;
-	//! List of constraints on the table
-	vector<unique_ptr<Constraint>> constraints;
-	//! CREATE TABLE from QUERY
-	unique_ptr<SelectStatement> query;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateTableInfo>(schema, table);
-		CopyProperties(*result);
-		for (auto &column : columns) {
-			result->columns.push_back(column.Copy());
-		}
-		for (auto &constraint : constraints) {
-			result->constraints.push_back(constraint->Copy());
-		}
-		if (query) {
-			result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-		}
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/parsed_data/bound_create_table_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/persistent_table_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/segment_tree.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/segment_base.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class SegmentBase {
-public:
-	SegmentBase(idx_t start, idx_t count) : start(start), count(count) {
-	}
-	virtual ~SegmentBase() {
-		// destroy the chain of segments iteratively (rather than recursively)
-		while (next && next->next) {
-			next = std::move(next->next);
-		}
-	}
-
-	//! The start row id of this chunk
-	const idx_t start;
-	//! The amount of entries in this storage chunk
-	atomic<idx_t> count;
-	//! The next segment after this one
-	unique_ptr<SegmentBase> next;
-};
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-struct SegmentNode {
-	idx_t row_start;
-	SegmentBase *node;
-};
-
-//! The SegmentTree maintains a list of all segments of a specific column in a table, and allows searching for a segment
-//! by row number
-class SegmentTree {
-public:
-	//! The initial segment of the tree
-	unique_ptr<SegmentBase> root_node;
-	//! The nodes in the tree, can be binary searched
-	vector<SegmentNode> nodes;
-	//! Lock to access or modify the nodes
-	mutex node_lock;
-
-public:
-	//! Gets a pointer to the first segment. Useful for scans.
-	SegmentBase *GetRootSegment();
-	//! Gets a pointer to the last segment. Useful for appends.
-	SegmentBase *GetLastSegment();
-	//! Gets a pointer to a specific column segment for the given row
-	SegmentBase *GetSegment(idx_t row_number);
-	//! Append a column segment to the tree
-	void AppendSegment(unique_ptr<SegmentBase> segment);
-
-	//! Replace this tree with another tree, taking over its nodes in-place
-	void Replace(SegmentTree &other);
-
-	//! Get the segment index of the column segment for the given row (does not lock the segment tree!)
-	idx_t GetSegmentIndex(idx_t row_number);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/data_pointer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/block.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class Block : public FileBuffer {
-public:
-	Block(Allocator &allocator, block_id_t id);
-	Block(FileBuffer &source, block_id_t id);
-
-	block_id_t id;
-};
-
-struct BlockPointer {
-	block_id_t block_id;
-	uint32_t offset;
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/row_group.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/chunk_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class RowGroup;
-struct SelectionVector;
-class Transaction;
-
-enum class ChunkInfoType : uint8_t { CONSTANT_INFO, VECTOR_INFO, EMPTY_INFO };
-
-class ChunkInfo {
-public:
-	ChunkInfo(idx_t start, ChunkInfoType type) : start(start), type(type) {
-	}
-	virtual ~ChunkInfo() {
-	}
-
-	//! The row index of the first row
-	idx_t start;
-	//! The ChunkInfo type
-	ChunkInfoType type;
-
-public:
-	//! Gets up to max_count entries from the chunk info. If the ret is 0>ret>max_count, the selection vector is filled
-	//! with the tuples
-	virtual idx_t GetSelVector(Transaction &transaction, SelectionVector &sel_vector, idx_t max_count) = 0;
-	virtual idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-	                                    SelectionVector &sel_vector, idx_t max_count) = 0;
-	//! Returns whether or not a single row in the ChunkInfo should be used or not for the given transaction
-	virtual bool Fetch(Transaction &transaction, row_t row) = 0;
-	virtual void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) = 0;
-
-	virtual void Serialize(Serializer &serialize) = 0;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
-};
-
-class ChunkConstantInfo : public ChunkInfo {
-public:
-	ChunkConstantInfo(idx_t start);
-
-	atomic<transaction_t> insert_id;
-	atomic<transaction_t> delete_id;
-
-public:
-	idx_t GetSelVector(Transaction &transaction, SelectionVector &sel_vector, idx_t max_count) override;
-	idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-	                            SelectionVector &sel_vector, idx_t max_count) override;
-	bool Fetch(Transaction &transaction, row_t row) override;
-	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
-
-	void Serialize(Serializer &serialize) override;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
-
-private:
-	template <class OP>
-	idx_t TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                            idx_t max_count);
-};
-
-class ChunkVectorInfo : public ChunkInfo {
-public:
-	ChunkVectorInfo(idx_t start);
-
-	//! The transaction ids of the transactions that inserted the tuples (if any)
-	atomic<transaction_t> inserted[STANDARD_VECTOR_SIZE];
-	atomic<transaction_t> insert_id;
-	atomic<bool> same_inserted_id;
-
-	//! The transaction ids of the transactions that deleted the tuples (if any)
-	atomic<transaction_t> deleted[STANDARD_VECTOR_SIZE];
-	atomic<bool> any_deleted;
-
-public:
-	idx_t GetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                   idx_t max_count);
-	idx_t GetSelVector(Transaction &transaction, SelectionVector &sel_vector, idx_t max_count) override;
-	idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
-	                            SelectionVector &sel_vector, idx_t max_count) override;
-	bool Fetch(Transaction &transaction, row_t row) override;
-	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
-
-	void Append(idx_t start, idx_t end, transaction_t commit_id);
-	idx_t Delete(Transaction &transaction, row_t rows[], idx_t count);
-	void CommitDelete(transaction_t commit_id, row_t rows[], idx_t count);
-
-	void Serialize(Serializer &serialize) override;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
-
-private:
-	template <class OP>
-	idx_t TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                            idx_t max_count);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/append_state.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class ColumnSegment;
-class DataTable;
-class RowGroup;
-class UpdateSegment;
-class ValiditySegment;
-
-struct TableAppendState;
-
-struct ColumnAppendState {
-	//! The current segment of the append
-	ColumnSegment *current;
-	//! Child append states
-	vector<ColumnAppendState> child_appends;
-	//! The write lock that is held by the append
-	unique_ptr<StorageLockKey> lock;
-};
-
-struct RowGroupAppendState {
-	RowGroupAppendState(TableAppendState &parent_p) : parent(parent_p) {
-	}
-
-	//! The parent append state
-	TableAppendState &parent;
-	//! The current row_group we are appending to
-	RowGroup *row_group;
-	//! The column append states
-	unique_ptr<ColumnAppendState[]> states;
-	//! Offset within the row_group
-	idx_t offset_in_row_group;
-};
-
-struct IndexLock {
-	unique_lock<mutex> index_lock;
-};
-
-struct TableAppendState {
-	TableAppendState() : row_group_append_state(*this) {
-	}
-
-	RowGroupAppendState row_group_append_state;
-	unique_lock<mutex> append_lock;
-	row_t row_start;
-	row_t current_row;
-	idx_t remaining_append_count;
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/segment_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class SegmentStatistics {
-public:
-	SegmentStatistics(LogicalType type);
-	SegmentStatistics(LogicalType type, unique_ptr<BaseStatistics> statistics);
-
-	LogicalType type;
-
-	//! Type-specific statistics of the segment
-	unique_ptr<BaseStatistics> statistics;
-
-public:
-	void Reset();
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/scan_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class TableScanType : uint8_t {
-	//! Regular table scan: scan all tuples that are relevant for the current transaction
-	TABLE_SCAN_REGULAR = 0,
-	//! Scan all rows, including any deleted rows. Committed updates are merged in.
-	TABLE_SCAN_COMMITTED_ROWS = 1,
-	//! Scan all rows, including any deleted rows. Throws an exception if there are any uncommitted updates.
-	TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES = 2,
-	//! Scan all rows, excluding any permanently deleted rows.
-	//! Permanently deleted rows are rows which no transaction will ever need again.
-	TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED = 3
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class ColumnData;
-class DatabaseInstance;
-class DataTable;
-struct DataTableInfo;
-class ExpressionExecutor;
-class TableDataWriter;
-class UpdateSegment;
-class Vector;
-struct RowGroupPointer;
-struct VersionNode;
-
-class RowGroup : public SegmentBase {
-public:
-	friend class ColumnData;
-	friend class VersionDeleteState;
-
-public:
-	static constexpr const idx_t ROW_GROUP_VECTOR_COUNT = 120;
-	static constexpr const idx_t ROW_GROUP_SIZE = STANDARD_VECTOR_SIZE * ROW_GROUP_VECTOR_COUNT;
-
-public:
-	RowGroup(DatabaseInstance &db, DataTableInfo &table_info, idx_t start, idx_t count);
-	RowGroup(DatabaseInstance &db, DataTableInfo &table_info, const vector<LogicalType> &types,
-	         RowGroupPointer &pointer);
-	~RowGroup();
-
-private:
-	//! The database instance
-	DatabaseInstance &db;
-	//! The table info of this row_group
-	DataTableInfo &table_info;
-	//! The version info of the row_group (inserted and deleted tuple info)
-	shared_ptr<VersionNode> version_info;
-	//! The column data of the row_group
-	vector<shared_ptr<ColumnData>> columns;
-	//! The segment statistics for each of the columns
-	vector<shared_ptr<SegmentStatistics>> stats;
-
-public:
-	DatabaseInstance &GetDatabase() {
-		return db;
-	}
-	DataTableInfo &GetTableInfo() {
-		return table_info;
-	}
-	idx_t GetColumnIndex(ColumnData *data) {
-		for (idx_t i = 0; i < columns.size(); i++) {
-			if (columns[i].get() == data) {
-				return i;
-			}
-		}
-		return 0;
-	}
-
-	unique_ptr<RowGroup> AlterType(ClientContext &context, const LogicalType &target_type, idx_t changed_idx,
-	                               ExpressionExecutor &executor, TableScanState &scan_state, DataChunk &scan_chunk);
-	unique_ptr<RowGroup> AddColumn(ClientContext &context, ColumnDefinition &new_column, ExpressionExecutor &executor,
-	                               Expression *default_value, Vector &intermediate);
-	unique_ptr<RowGroup> RemoveColumn(idx_t removed_column);
-
-	void CommitDrop();
-	void CommitDropColumn(idx_t index);
-
-	void InitializeEmpty(const vector<LogicalType> &types);
-
-	//! Initialize a scan over this row_group
-	bool InitializeScan(RowGroupScanState &state);
-	bool InitializeScanWithOffset(RowGroupScanState &state, idx_t vector_offset);
-	//! Checks the given set of table filters against the row-group statistics. Returns false if the entire row group
-	//! can be skipped.
-	bool CheckZonemap(TableFilterSet &filters, const vector<column_t> &column_ids);
-	//! Checks the given set of table filters against the per-segment statistics. Returns false if any segments were
-	//! skipped.
-	bool CheckZonemapSegments(RowGroupScanState &state);
-	void Scan(Transaction &transaction, RowGroupScanState &state, DataChunk &result);
-	void ScanCommitted(RowGroupScanState &state, DataChunk &result, TableScanType type);
-
-	idx_t GetSelVector(Transaction &transaction, idx_t vector_idx, SelectionVector &sel_vector, idx_t max_count);
-	idx_t GetCommittedSelVector(transaction_t start_time, transaction_t transaction_id, idx_t vector_idx,
-	                            SelectionVector &sel_vector, idx_t max_count);
-
-	//! For a specific row, returns true if it should be used for the transaction and false otherwise.
-	bool Fetch(Transaction &transaction, idx_t row);
-	//! Fetch a specific row from the row_group and insert it into the result at the specified index
-	void FetchRow(Transaction &transaction, ColumnFetchState &state, const vector<column_t> &column_ids, row_t row_id,
-	              DataChunk &result, idx_t result_idx);
-
-	//! Append count rows to the version info
-	void AppendVersionInfo(Transaction &transaction, idx_t start, idx_t count, transaction_t commit_id);
-	//! Commit a previous append made by RowGroup::AppendVersionInfo
-	void CommitAppend(transaction_t commit_id, idx_t start, idx_t count);
-	//! Revert a previous append made by RowGroup::AppendVersionInfo
-	void RevertAppend(idx_t start);
-
-	//! Delete the given set of rows in the version manager
-	idx_t Delete(Transaction &transaction, DataTable *table, row_t *row_ids, idx_t count);
-
-	RowGroupPointer Checkpoint(TableDataWriter &writer, vector<unique_ptr<BaseStatistics>> &global_stats);
-	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
-	static RowGroupPointer Deserialize(Deserializer &source, const vector<ColumnDefinition> &columns);
-
-	void InitializeAppend(Transaction &transaction, RowGroupAppendState &append_state, idx_t remaining_append_count);
-	void Append(RowGroupAppendState &append_state, DataChunk &chunk, idx_t append_count);
-
-	void Update(Transaction &transaction, DataChunk &updates, row_t *ids, idx_t offset, idx_t count,
-	            const vector<column_t> &column_ids);
-	//! Update a single column; corresponds to DataTable::UpdateColumn
-	//! This method should only be called from the WAL
-	void UpdateColumn(Transaction &transaction, DataChunk &updates, Vector &row_ids,
-	                  const vector<column_t> &column_path);
-
-	void MergeStatistics(idx_t column_idx, const BaseStatistics &other);
-	void MergeIntoStatistics(idx_t column_idx, BaseStatistics &other);
-	unique_ptr<BaseStatistics> GetStatistics(idx_t column_idx);
-
-	void GetStorageInfo(idx_t row_group_index, vector<vector<Value>> &result);
-
-	void Verify();
-
-	void NextVector(RowGroupScanState &state);
-
-private:
-	ChunkInfo *GetChunkInfo(idx_t vector_idx);
-
-	template <TableScanType TYPE>
-	void TemplatedScan(Transaction *transaction, RowGroupScanState &state, DataChunk &result);
-
-	static void CheckpointDeletes(VersionNode *versions, Serializer &serializer);
-	static shared_ptr<VersionNode> DeserializeDeletes(Deserializer &source);
-
-private:
-	mutex row_group_lock;
-	mutex stats_lock;
-};
-
-struct VersionNode {
-	unique_ptr<ChunkInfo> info[RowGroup::ROW_GROUP_VECTOR_COUNT];
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct DataPointer {
-	uint64_t row_start;
-	uint64_t tuple_count;
-	BlockPointer block_pointer;
-	CompressionType compression_type;
-	//! Type-specific statistics of the segment
-	unique_ptr<BaseStatistics> statistics;
-};
-
-struct RowGroupPointer {
-	uint64_t row_start;
-	uint64_t tuple_count;
-	//! The data pointers of the column segments stored in the row group
-	vector<BlockPointer> data_pointers;
-	//! The per-column statistics of the row group
-	vector<unique_ptr<BaseStatistics>> statistics;
-	//! The versions information of the row group (if any)
-	shared_ptr<VersionNode> versions;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class BaseStatistics;
-
-class PersistentTableData {
-public:
-	explicit PersistentTableData(idx_t column_count);
-	~PersistentTableData();
-
-	vector<RowGroupPointer> row_groups;
-	vector<unique_ptr<BaseStatistics>> column_stats;
-};
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-class CatalogEntry;
-
-struct BoundCreateTableInfo {
-	explicit BoundCreateTableInfo(unique_ptr<CreateInfo> base_p) : base(std::move(base_p)) {
-		D_ASSERT(base);
-	}
-
-	//! The schema to create the table in
-	SchemaCatalogEntry *schema;
-	//! The base CreateInfo object
-	unique_ptr<CreateInfo> base;
-	//! The map of column names -> column index, used during binding
-	case_insensitive_map_t<column_t> name_map;
-	//! Column dependency manager of the table
-	ColumnDependencyManager column_dependency_manager;
-	//! List of constraints on the table
-	vector<unique_ptr<Constraint>> constraints;
-	//! List of bound constraints on the table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	//! Bound default values
-	vector<unique_ptr<Expression>> bound_defaults;
-	//! Dependents of the table (in e.g. default values)
-	unordered_set<CatalogEntry *> dependencies;
-	//! The existing table data on disk (if any)
-	unique_ptr<PersistentTableData> data;
-	//! CREATE TABLE from QUERY
-	unique_ptr<LogicalOperator> query;
-
-	CreateTableInfo &Base() {
-		D_ASSERT(base);
-		return (CreateTableInfo &)*base;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/constraints/not_null_constraint.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class NotNullConstraint : public Constraint {
-public:
-	DUCKDB_API explicit NotNullConstraint(column_t index);
-	DUCKDB_API ~NotNullConstraint() override;
-
-	//! Column index this constraint pertains to
-	column_t index;
-
-public:
-	DUCKDB_API string ToString() const override;
-
-	DUCKDB_API unique_ptr<Constraint> Copy() const override;
-
-	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(FieldWriter &writer) const override;
-	//! Deserializes a NotNullConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/data_table.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/index_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Index Types
-//===--------------------------------------------------------------------===//
-enum class IndexType {
-	INVALID = 0, // invalid index type
-	ART = 1      // Adaptive Radix Tree
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/index.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/expression_executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class Allocator;
-class ExecutionContext;
-
-//! ExpressionExecutor is responsible for executing a set of expressions and storing the result in a data chunk
-class ExpressionExecutor {
-public:
-	DUCKDB_API ExpressionExecutor(Allocator &allocator);
-	DUCKDB_API explicit ExpressionExecutor(Allocator &allocator, const Expression *expression);
-	DUCKDB_API explicit ExpressionExecutor(Allocator &allocator, const Expression &expression);
-	DUCKDB_API explicit ExpressionExecutor(Allocator &allocator, const vector<unique_ptr<Expression>> &expressions);
-
-	Allocator &allocator;
-	//! The expressions of the executor
-	vector<const Expression *> expressions;
-	//! The data chunk of the current physical operator, used to resolve
-	//! column references and determines the output cardinality
-	DataChunk *chunk = nullptr;
-
-public:
-	//! Add an expression to the set of to-be-executed expressions of the executor
-	DUCKDB_API void AddExpression(const Expression &expr);
-
-	//! Execute the set of expressions with the given input chunk and store the result in the output chunk
-	DUCKDB_API void Execute(DataChunk *input, DataChunk &result);
-	inline void Execute(DataChunk &input, DataChunk &result) {
-		Execute(&input, result);
-	}
-	inline void Execute(DataChunk &result) {
-		Execute(nullptr, result);
-	}
-
-	//! Execute the ExpressionExecutor and put the result in the result vector; this should only be used for expression
-	//! executors with a single expression
-	DUCKDB_API void ExecuteExpression(DataChunk &input, Vector &result);
-	//! Execute the ExpressionExecutor and put the result in the result vector; this should only be used for expression
-	//! executors with a single expression
-	DUCKDB_API void ExecuteExpression(Vector &result);
-	//! Execute the ExpressionExecutor and generate a selection vector from all true values in the result; this should
-	//! only be used with a single boolean expression
-	DUCKDB_API idx_t SelectExpression(DataChunk &input, SelectionVector &sel);
-
-	//! Execute the expression with index `expr_idx` and store the result in the result vector
-	DUCKDB_API void ExecuteExpression(idx_t expr_idx, Vector &result);
-	//! Evaluate a scalar expression and fold it into a single value
-	DUCKDB_API static Value EvaluateScalar(const Expression &expr);
-	//! Try to evaluate a scalar expression and fold it into a single value, returns false if an exception is thrown
-	DUCKDB_API static bool TryEvaluateScalar(const Expression &expr, Value &result);
-
-	//! Initialize the state of a given expression
-	static unique_ptr<ExpressionState> InitializeState(const Expression &expr, ExpressionExecutorState &state);
-
-	inline void SetChunk(DataChunk *chunk) {
-		this->chunk = chunk;
-	}
-	inline void SetChunk(DataChunk &chunk) {
-		SetChunk(&chunk);
-	}
-
-	DUCKDB_API vector<unique_ptr<ExpressionExecutorState>> &GetStates();
-
-protected:
-	void Initialize(const Expression &expr, ExpressionExecutorState &state);
-
-	static unique_ptr<ExpressionState> InitializeState(const BoundReferenceExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundBetweenExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundCaseExpression &expr, ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundCastExpression &expr, ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundComparisonExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundConjunctionExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundConstantExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundFunctionExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundOperatorExpression &expr,
-	                                                   ExpressionExecutorState &state);
-	static unique_ptr<ExpressionState> InitializeState(const BoundParameterExpression &expr,
-	                                                   ExpressionExecutorState &state);
-
-	void Execute(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-
-	void Execute(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundCaseExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundCastExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-
-	void Execute(const BoundComparisonExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundConjunctionExpression &expr, ExpressionState *state, const SelectionVector *sel,
-	             idx_t count, Vector &result);
-	void Execute(const BoundConstantExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundFunctionExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundOperatorExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundParameterExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-	void Execute(const BoundReferenceExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             Vector &result);
-
-	//! Execute the (boolean-returning) expression and generate a selection vector with all entries that are "true" in
-	//! the result
-	idx_t Select(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             SelectionVector *true_sel, SelectionVector *false_sel);
-	idx_t DefaultSelect(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	                    SelectionVector *true_sel, SelectionVector *false_sel);
-
-	idx_t Select(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             SelectionVector *true_sel, SelectionVector *false_sel);
-	idx_t Select(const BoundComparisonExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
-	             SelectionVector *true_sel, SelectionVector *false_sel);
-	idx_t Select(const BoundConjunctionExpression &expr, ExpressionState *state, const SelectionVector *sel,
-	             idx_t count, SelectionVector *true_sel, SelectionVector *false_sel);
-
-	//! Verify that the output of a step in the ExpressionExecutor is correct
-	void Verify(const Expression &expr, Vector &result, idx_t count);
-
-	void FillSwitch(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count);
-
-private:
-	//! The states of the expression executor; this holds any intermediates and temporary states of expressions
-	vector<unique_ptr<ExpressionExecutorState>> states;
-};
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class ClientContext;
-class Transaction;
-
-struct IndexLock;
-
-enum IndexConstraintType : uint8_t {
-	NONE = 0,    // index is an index don't built to any constraint
-	UNIQUE = 1,  // index is an index built to enforce a UNIQUE constraint
-	PRIMARY = 2, // index is an index built to enforce a PRIMARY KEY constraint
-	FOREIGN = 3  // index is an index built to enforce a FOREIGN KEY constraint
-};
-
-//! The index is an abstract base class that serves as the basis for indexes
-class Index {
-public:
-	Index(IndexType type, const vector<column_t> &column_ids, const vector<unique_ptr<Expression>> &unbound_expressions,
-	      IndexConstraintType constraint_type);
-	virtual ~Index() = default;
-
-	//! The type of the index
-	IndexType type;
-	//! Column identifiers to extract from the base table
-	vector<column_t> column_ids;
-	//! unordered_set of column_ids used by the index
-	unordered_set<column_t> column_id_set;
-	//! Unbound expressions used by the index
-	vector<unique_ptr<Expression>> unbound_expressions;
-	//! The physical types stored in the index
-	vector<PhysicalType> types;
-	//! The logical types of the expressions
-	vector<LogicalType> logical_types;
-	// ! constraint type
-	IndexConstraintType constraint_type;
-
-public:
-	//! Initialize a scan on the index with the given expression and column ids
-	//! to fetch from the base table when we only have one query predicate
-	virtual unique_ptr<IndexScanState> InitializeScanSinglePredicate(Transaction &transaction, Value value,
-	                                                                 ExpressionType expressionType) = 0;
-	//! Initialize a scan on the index with the given expression and column ids
-	//! to fetch from the base table for two query predicates
-	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, Value low_value,
-	                                                               ExpressionType low_expression_type, Value high_value,
-	                                                               ExpressionType high_expression_type) = 0;
-	//! Perform a lookup on the index, fetching up to max_count result ids. Returns true if all row ids were fetched,
-	//! and false otherwise.
-	virtual bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
-	                  vector<row_t> &result_ids) = 0;
-
-	//! Obtain a lock on the index
-	virtual void InitializeLock(IndexLock &state);
-	//! Called when data is appended to the index. The lock obtained from InitializeAppend must be held
-	virtual bool Append(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
-	bool Append(DataChunk &entries, Vector &row_identifiers);
-	//! Verify that data can be appended to the index
-	virtual void VerifyAppend(DataChunk &chunk) = 0;
-	//! Verify that data can be appended to the index for foreign key constraint
-	virtual void VerifyAppendForeignKey(DataChunk &chunk, string *err_msg_ptr) = 0;
-	//! Verify that data can be delete from the index for foreign key constraint
-	virtual void VerifyDeleteForeignKey(DataChunk &chunk, string *err_msg_ptr) = 0;
-
-	//! Called when data inside the index is Deleted
-	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
-	void Delete(DataChunk &entries, Vector &row_identifiers);
-
-	//! Insert data into the index. Does not lock the index.
-	virtual bool Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
-
-	//! Returns true if the index is affected by updates on the specified column ids, and false otherwise
-	bool IndexIsUpdated(const vector<column_t> &column_ids) const;
-
-	//! Returns unique flag
-	bool IsUnique() {
-		return (constraint_type == IndexConstraintType::UNIQUE || constraint_type == IndexConstraintType::PRIMARY);
-	}
-	//! Returns primary flag
-	bool IsPrimary() {
-		return (constraint_type == IndexConstraintType::PRIMARY);
-	}
-	//! Returns foreign flag
-	bool IsForeign() {
-		return (constraint_type == IndexConstraintType::FOREIGN);
-	}
-
-protected:
-	void ExecuteExpressions(DataChunk &input, DataChunk &result);
-
-	//! Lock used for updating the index
-	mutex lock;
-
-private:
-	//! Bound expressions used by the index
-	vector<unique_ptr<Expression>> bound_expressions;
-	//! Expression executor for the index expressions
-	ExpressionExecutor executor;
-
-	unique_ptr<Expression> BindExpression(unique_ptr<Expression> expr);
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct TableStatistics {
-	idx_t estimated_cardinality;
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/column_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/block_manager.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class DatabaseInstance;
-
-//! BlockManager is an abstract representation to manage blocks on DuckDB. When writing or reading blocks, the
-//! BlockManager creates and accesses blocks. The concrete types implements how blocks are stored.
-class BlockManager {
-public:
-	virtual ~BlockManager() = default;
-
-	virtual void StartCheckpoint() = 0;
-	//! Creates a new block inside the block manager
-	virtual unique_ptr<Block> CreateBlock(block_id_t block_id) = 0;
-	//! Return the next free block id
-	virtual block_id_t GetFreeBlockId() = 0;
-	//! Returns whether or not a specified block is the root block
-	virtual bool IsRootBlock(block_id_t root) = 0;
-	//! Mark a block as "modified"; modified blocks are added to the free list after a checkpoint (i.e. their data is
-	//! assumed to be rewritten)
-	virtual void MarkBlockAsModified(block_id_t block_id) = 0;
-	//! Increase the reference count of a block. The block should hold at least one reference before this method is
-	//! called.
-	virtual void IncreaseBlockReferenceCount(block_id_t block_id) = 0;
-	//! Get the first meta block id
-	virtual block_id_t GetMetaBlock() = 0;
-	//! Read the content of the block from disk
-	virtual void Read(Block &block) = 0;
-	//! Writes the block to disk
-	virtual void Write(FileBuffer &block, block_id_t block_id) = 0;
-	//! Writes the block to disk
-	void Write(Block &block) {
-		Write(block, block.id);
-	}
-	//! Write the header; should be the final step of a checkpoint
-	virtual void WriteHeader(DatabaseHeader header) = 0;
-
-	//! Returns the number of total blocks
-	virtual idx_t TotalBlocks() = 0;
-	//! Returns the number of free blocks
-	virtual idx_t FreeBlocks() = 0;
-
-	static BlockManager &GetBlockManager(ClientContext &context);
-	static BlockManager &GetBlockManager(DatabaseInstance &db);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer/block_handle.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-class BufferHandle;
-class BufferManager;
-class DatabaseInstance;
-class FileBuffer;
-
-enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 };
-
-class BlockHandle {
-	friend struct BufferEvictionNode;
-	friend class BufferHandle;
-	friend class BufferManager;
-
-public:
-	BlockHandle(DatabaseInstance &db, block_id_t block_id);
-	BlockHandle(DatabaseInstance &db, block_id_t block_id, unique_ptr<FileBuffer> buffer, bool can_destroy,
-	            idx_t block_size);
-	~BlockHandle();
-
-	DatabaseInstance &db;
-
-public:
-	block_id_t BlockId() {
-		return block_id;
-	}
-
-	int32_t Readers() const {
-		return readers;
-	}
-
-private:
-	static BufferHandle Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileBuffer> buffer = nullptr);
-	unique_ptr<FileBuffer> UnloadAndTakeBlock();
-	void Unload();
-	bool CanUnload();
-
-	//! The block-level lock
-	mutex lock;
-	//! Whether or not the block is loaded/unloaded
-	BlockState state;
-	//! Amount of concurrent readers
-	atomic<int32_t> readers;
-	//! The block id of the block
-	const block_id_t block_id;
-	//! Pointer to loaded data (if any)
-	unique_ptr<FileBuffer> buffer;
-	//! Internal eviction timestamp
-	atomic<idx_t> eviction_timestamp;
-	//! Whether or not the buffer can be destroyed (only used for temporary buffers)
-	const bool can_destroy;
-	//! The memory usage of the block
-	idx_t memory_usage;
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/buffer/managed_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class DatabaseInstance;
-
-//! Managed buffer is an arbitrarily-sized buffer that is at least of size >= BLOCK_SIZE
-class ManagedBuffer : public FileBuffer {
-public:
-	ManagedBuffer(DatabaseInstance &db, idx_t size, bool can_destroy, block_id_t id);
-	ManagedBuffer(DatabaseInstance &db, FileBuffer &source, bool can_destroy, block_id_t id);
-
-	DatabaseInstance &db;
-	//! Whether or not the managed buffer can be freely destroyed when unpinned.
-	//! - If can_destroy is true, the buffer can be destroyed when unpinned and hence be unrecoverable. After being
-	//! destroyed, Pin() will return false.
-	//! - If can_destroy is false, the buffer will instead be written to a temporary file on disk when unloaded from
-	//! memory, and read back into memory when Pin() is called.
-	bool can_destroy;
-	//! The internal id of the buffer
-	block_id_t id;
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class DatabaseInstance;
-class TemporaryDirectoryHandle;
-struct EvictionQueue;
-
-//! The buffer manager is in charge of handling memory management for the database. It hands out memory buffers that can
-//! be used by the database internally.
-class BufferManager {
-	friend class BufferHandle;
-	friend class BlockHandle;
-
-public:
-	BufferManager(DatabaseInstance &db, string temp_directory, idx_t maximum_memory);
-	~BufferManager();
-
-	//! Register a block with the given block id in the base file
-	shared_ptr<BlockHandle> RegisterBlock(block_id_t block_id);
-
-	//! Register an in-memory buffer of arbitrary size, as long as it is >= BLOCK_SIZE. can_destroy signifies whether or
-	//! not the buffer can be destroyed when unpinned, or whether or not it needs to be written to a temporary file so
-	//! it can be reloaded. The resulting buffer will already be allocated, but needs to be pinned in order to be used.
-	shared_ptr<BlockHandle> RegisterMemory(idx_t block_size, bool can_destroy);
-
-	//! Convert an existing in-memory buffer into a persistent disk-backed block
-	shared_ptr<BlockHandle> ConvertToPersistent(BlockManager &block_manager, block_id_t block_id,
-	                                            shared_ptr<BlockHandle> old_block);
-
-	//! Allocate an in-memory buffer with a single pin.
-	//! The allocated memory is released when the buffer handle is destroyed.
-	DUCKDB_API BufferHandle Allocate(idx_t block_size);
-
-	//! Reallocate an in-memory buffer that is pinned.
-	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size);
-
-	BufferHandle Pin(shared_ptr<BlockHandle> &handle);
-	void Unpin(shared_ptr<BlockHandle> &handle);
-
-	void UnregisterBlock(block_id_t block_id, bool can_destroy);
-
-	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted
-	void SetLimit(idx_t limit = (idx_t)-1);
-
-	static BufferManager &GetBufferManager(ClientContext &context);
-	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
-
-	idx_t GetUsedMemory() {
-		return current_memory;
-	}
-	idx_t GetMaxMemory() {
-		return maximum_memory;
-	}
-
-	const string &GetTemporaryDirectory() {
-		return temp_directory;
-	}
-
-	void SetTemporaryDirectory(string new_dir);
-
-	DUCKDB_API Allocator &GetBufferAllocator();
-
-private:
-	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
-	//! (i.e. not enough blocks could be evicted)
-	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
-	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
-	bool EvictBlocks(idx_t extra_memory, idx_t memory_limit, unique_ptr<FileBuffer> *buffer = nullptr);
-
-	//! Garbage collect eviction queue
-	void PurgeQueue();
-
-	//! Write a temporary buffer to disk
-	void WriteTemporaryBuffer(ManagedBuffer &buffer);
-	//! Read a temporary buffer from disk
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> buffer = nullptr);
-	//! Get the path of the temporary buffer
-	string GetTemporaryPath(block_id_t id);
-
-	void DeleteTemporaryFile(block_id_t id);
-
-	void RequireTemporaryDirectory();
-
-	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
-
-	string InMemoryWarning();
-
-	static data_ptr_t BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size);
-	static void BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
-	static data_ptr_t BufferAllocatorRealloc(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-	                                         idx_t size);
-
-private:
-	//! The database instance
-	DatabaseInstance &db;
-	//! The lock for changing the memory limit
-	mutex limit_lock;
-	//! The current amount of memory that is occupied by the buffer manager (in bytes)
-	atomic<idx_t> current_memory;
-	//! The maximum amount of memory that the buffer manager can keep (in bytes)
-	atomic<idx_t> maximum_memory;
-	//! The directory name where temporary files are stored
-	string temp_directory;
-	//! Lock for creating the temp handle
-	mutex temp_handle_lock;
-	//! Handle for the temporary directory
-	unique_ptr<TemporaryDirectoryHandle> temp_directory_handle;
-	//! The lock for the set of blocks
-	mutex blocks_lock;
-	//! A mapping of block id -> BlockHandle
-	unordered_map<block_id_t, weak_ptr<BlockHandle>> blocks;
-	//! Eviction queue
-	unique_ptr<EvictionQueue> queue;
-	//! The temporary id used for managed buffers
-	atomic<block_id_t> temporary_id;
-	//! Allocator associated with the buffer manager, that passes all allocations through this buffer manager
-	Allocator buffer_allocator;
-};
-} // namespace duckdb
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/compression_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <map>
-
-namespace duckdb {
-using std::map;
-using std::multimap;
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class DatabaseInstance;
-class ColumnData;
-class ColumnDataCheckpointer;
-class ColumnSegment;
-class SegmentStatistics;
-
-struct ColumnFetchState;
-struct ColumnScanState;
-struct SegmentScanState;
-
-struct AnalyzeState {
-	virtual ~AnalyzeState() {
-	}
-};
-
-struct CompressionState {
-	virtual ~CompressionState() {
-	}
-};
-
-struct CompressedSegmentState {
-	virtual ~CompressedSegmentState() {
-	}
-};
-
-struct UncompressedCompressState : public CompressionState {
-	explicit UncompressedCompressState(ColumnDataCheckpointer &checkpointer);
-
-	ColumnDataCheckpointer &checkpointer;
-	unique_ptr<ColumnSegment> current_segment;
-
-	virtual void CreateEmptySegment(idx_t row_start);
-	void FlushSegment(idx_t segment_size);
-	void Finalize(idx_t segment_size);
-};
-
-//===--------------------------------------------------------------------===//
-// Analyze
-//===--------------------------------------------------------------------===//
-//! The analyze functions are used to determine whether or not to use this compression method
-//! The system first determines the potential compression methods to use based on the physical type of the column
-//! After that the following steps are taken:
-//! 1. The init_analyze is called to initialize the analyze state of every candidate compression method
-//! 2. The analyze method is called with all of the input data in the order in which it must be stored.
-//!    analyze can return "false". In that case, the compression method is taken out of consideration early.
-//! 3. The final_analyze method is called, which should return a score for the compression method
-
-//! The system then decides which compression function to use based on the analyzed score (returned from final_analyze)
-typedef unique_ptr<AnalyzeState> (*compression_init_analyze_t)(ColumnData &col_data, PhysicalType type);
-typedef bool (*compression_analyze_t)(AnalyzeState &state, Vector &input, idx_t count);
-typedef idx_t (*compression_final_analyze_t)(AnalyzeState &state);
-
-//===--------------------------------------------------------------------===//
-// Compress
-//===--------------------------------------------------------------------===//
-typedef unique_ptr<CompressionState> (*compression_init_compression_t)(ColumnDataCheckpointer &checkpointer,
-                                                                       unique_ptr<AnalyzeState> state);
-typedef void (*compression_compress_data_t)(CompressionState &state, Vector &scan_vector, idx_t count);
-typedef void (*compression_compress_finalize_t)(CompressionState &state);
-
-//===--------------------------------------------------------------------===//
-// Uncompress / Scan
-//===--------------------------------------------------------------------===//
-typedef unique_ptr<SegmentScanState> (*compression_init_segment_scan_t)(ColumnSegment &segment);
-typedef void (*compression_scan_vector_t)(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                          Vector &result);
-typedef void (*compression_scan_partial_t)(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
-                                           Vector &result, idx_t result_offset);
-typedef void (*compression_fetch_row_t)(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
-                                        idx_t result_idx);
-typedef void (*compression_skip_t)(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count);
-
-//===--------------------------------------------------------------------===//
-// Append (optional)
-//===--------------------------------------------------------------------===//
-typedef unique_ptr<CompressedSegmentState> (*compression_init_segment_t)(ColumnSegment &segment, block_id_t block_id);
-typedef idx_t (*compression_append_t)(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset,
-                                      idx_t count);
-typedef idx_t (*compression_finalize_append_t)(ColumnSegment &segment, SegmentStatistics &stats);
-typedef void (*compression_revert_append_t)(ColumnSegment &segment, idx_t start_row);
-
-class CompressionFunction {
-public:
-	CompressionFunction(CompressionType type, PhysicalType data_type, compression_init_analyze_t init_analyze,
-	                    compression_analyze_t analyze, compression_final_analyze_t final_analyze,
-	                    compression_init_compression_t init_compression, compression_compress_data_t compress,
-	                    compression_compress_finalize_t compress_finalize, compression_init_segment_scan_t init_scan,
-	                    compression_scan_vector_t scan_vector, compression_scan_partial_t scan_partial,
-	                    compression_fetch_row_t fetch_row, compression_skip_t skip,
-	                    compression_init_segment_t init_segment = nullptr, compression_append_t append = nullptr,
-	                    compression_finalize_append_t finalize_append = nullptr,
-	                    compression_revert_append_t revert_append = nullptr)
-	    : type(type), data_type(data_type), init_analyze(init_analyze), analyze(analyze), final_analyze(final_analyze),
-	      init_compression(init_compression), compress(compress), compress_finalize(compress_finalize),
-	      init_scan(init_scan), scan_vector(scan_vector), scan_partial(scan_partial), fetch_row(fetch_row), skip(skip),
-	      init_segment(init_segment), append(append), finalize_append(finalize_append), revert_append(revert_append) {
-	}
-
-	//! Compression type
-	CompressionType type;
-	//! The data type this function can compress
-	PhysicalType data_type;
-
-	//! Analyze step: determine which compression function is the most effective
-	//! init_analyze is called once to set up the analyze state
-	compression_init_analyze_t init_analyze;
-	//! analyze is called several times (once per vector in the row group)
-	//! analyze should return true, unless compression is no longer possible with this compression method
-	//! in that case false should be returned
-	compression_analyze_t analyze;
-	//! final_analyze should return the score of the compression function
-	//! ideally this is the exact number of bytes required to store the data
-	//! this is not required/enforced: it can be an estimate as well
-	compression_final_analyze_t final_analyze;
-
-	//! Compression step: actually compress the data
-	//! init_compression is called once to set up the comperssion state
-	compression_init_compression_t init_compression;
-	//! compress is called several times (once per vector in the row group)
-	compression_compress_data_t compress;
-	//! compress_finalize is called after
-	compression_compress_finalize_t compress_finalize;
-
-	//! init_scan is called to set up the scan state
-	compression_init_segment_scan_t init_scan;
-	//! scan_vector scans an entire vector using the scan state
-	compression_scan_vector_t scan_vector;
-	//! scan_partial scans a subset of a vector
-	//! this can request > vector_size as well
-	//! this is used if a vector crosses segment boundaries, or for child columns of lists
-	compression_scan_partial_t scan_partial;
-	//! fetch an individual row from the compressed vector
-	//! used for index lookups
-	compression_fetch_row_t fetch_row;
-	//! Skip forward in the compressed segment
-	compression_skip_t skip;
-
-	// Append functions
-	//! This only really needs to be defined for uncompressed segments
-
-	//! Initialize a compressed segment (optional)
-	compression_init_segment_t init_segment;
-	//! Append to the compressed segment (optional)
-	compression_append_t append;
-	//! Finalize an append to the segment
-	compression_finalize_append_t finalize_append;
-	//! Revert append (optional)
-	compression_revert_append_t revert_append;
-};
-
-//! The set of compression functions
-struct CompressionFunctionSet {
-	map<CompressionType, map<PhysicalType, CompressionFunction>> functions;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class ColumnSegment;
-class BlockManager;
-class ColumnSegment;
-class ColumnData;
-class DatabaseInstance;
-class Transaction;
-class BaseStatistics;
-class UpdateSegment;
-class TableFilter;
-struct ColumnFetchState;
-struct ColumnScanState;
-struct ColumnAppendState;
-
-enum class ColumnSegmentType : uint8_t { TRANSIENT, PERSISTENT };
-//! TableFilter represents a filter pushed down into the table scan.
-
-class ColumnSegment : public SegmentBase {
-public:
-	~ColumnSegment() override;
-
-	//! The database instance
-	DatabaseInstance &db;
-	//! The type stored in the column
-	LogicalType type;
-	//! The size of the type
-	idx_t type_size;
-	//! The column segment type (transient or persistent)
-	ColumnSegmentType segment_type;
-	//! The compression function
-	CompressionFunction *function;
-	//! The statistics for the segment
-	SegmentStatistics stats;
-	//! The block that this segment relates to
-	shared_ptr<BlockHandle> block;
-
-	static unique_ptr<ColumnSegment> CreatePersistentSegment(DatabaseInstance &db, block_id_t id, idx_t offset,
-	                                                         const LogicalType &type_p, idx_t start, idx_t count,
-	                                                         CompressionType compression_type,
-	                                                         unique_ptr<BaseStatistics> statistics);
-	static unique_ptr<ColumnSegment> CreateTransientSegment(DatabaseInstance &db, const LogicalType &type, idx_t start);
-
-public:
-	void InitializeScan(ColumnScanState &state);
-	//! Scan one vector from this segment
-	void Scan(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset, bool entire_vector);
-	//! Fetch a value of the specific row id and append it to the result
-	void FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx);
-
-	static idx_t FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
-	                             idx_t &approved_tuple_count, ValidityMask &mask);
-
-	//! Skip a scan forward to the row_index specified in the scan state
-	void Skip(ColumnScanState &state);
-
-	//! Initialize an append of this segment. Appends are only supported on transient segments.
-	void InitializeAppend(ColumnAppendState &state);
-	//! Appends a (part of) vector to the segment, returns the amount of entries successfully appended
-	idx_t Append(ColumnAppendState &state, VectorData &data, idx_t offset, idx_t count);
-	//! Finalize the segment for appending - no more appends can follow on this segment
-	//! The segment should be compacted as much as possible
-	//! Returns the number of bytes occupied within the segment
-	idx_t FinalizeAppend();
-	//! Revert an append made to this segment
-	void RevertAppend(idx_t start_row);
-
-	//! Convert a transient in-memory segment into a persistent segment blocked by an on-disk block.
-	//! Only used during checkpointing.
-	void ConvertToPersistent(block_id_t block_id);
-	//! Convert a transient in-memory segment into a persistent segment blocked by an on-disk block.
-	void ConvertToPersistent(shared_ptr<BlockHandle> block, block_id_t block_id, uint32_t offset_in_block);
-
-	block_id_t GetBlockId() {
-		D_ASSERT(segment_type == ColumnSegmentType::PERSISTENT);
-		return block_id;
-	}
-
-	idx_t GetBlockOffset() {
-		D_ASSERT(segment_type == ColumnSegmentType::PERSISTENT || offset == 0);
-		return offset;
-	}
-
-	idx_t GetRelativeIndex(idx_t row_index) {
-		D_ASSERT(row_index >= this->start);
-		D_ASSERT(row_index <= this->start + this->count);
-		return row_index - this->start;
-	}
-
-	CompressedSegmentState *GetSegmentState() {
-		return segment_state.get();
-	}
-
-public:
-	ColumnSegment(DatabaseInstance &db, LogicalType type, ColumnSegmentType segment_type, idx_t start, idx_t count,
-	              CompressionFunction *function, unique_ptr<BaseStatistics> statistics, block_id_t block_id,
-	              idx_t offset);
-
-private:
-	void Scan(ColumnScanState &state, idx_t scan_count, Vector &result);
-	void ScanPartial(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset);
-
-private:
-	//! The block id that this segment relates to (persistent segment only)
-	block_id_t block_id;
-	//! The offset into the block (persistent segment only)
-	idx_t offset;
-	//! Storage associated with the compressed segment
-	unique_ptr<CompressedSegmentState> segment_state;
-};
-
-} // namespace duckdb
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/column_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class ColumnStatistics {
-public:
-	explicit ColumnStatistics(unique_ptr<BaseStatistics> stats_p);
-
-	unique_ptr<BaseStatistics> stats;
-
-public:
-	static shared_ptr<ColumnStatistics> CreateEmptyStats(const LogicalType &type);
-};
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class ColumnDefinition;
-class DataTable;
-class RowGroup;
-class StorageManager;
-class TableCatalogEntry;
-class Transaction;
-class WriteAheadLog;
-class TableDataWriter;
-
-class TableIndexList {
-public:
-	//! Scan the catalog set, invoking the callback method for every entry
-	template <class T>
-	void Scan(T &&callback) {
-		// lock the catalog set
-		lock_guard<mutex> lock(indexes_lock);
-		for (auto &index : indexes) {
-			if (callback(*index)) {
-				break;
-			}
-		}
-	}
-
-	void AddIndex(unique_ptr<Index> index) {
-		D_ASSERT(index);
-		lock_guard<mutex> lock(indexes_lock);
-		indexes.push_back(std::move(index));
-	}
-
-	void RemoveIndex(Index *index) {
-		D_ASSERT(index);
-		lock_guard<mutex> lock(indexes_lock);
-
-		for (idx_t index_idx = 0; index_idx < indexes.size(); index_idx++) {
-			auto &index_entry = indexes[index_idx];
-			if (index_entry.get() == index) {
-				indexes.erase(indexes.begin() + index_idx);
-				break;
-			}
-		}
-	}
-
-	bool Empty() {
-		lock_guard<mutex> lock(indexes_lock);
-		return indexes.empty();
-	}
-
-	idx_t Count() {
-		lock_guard<mutex> lock(indexes_lock);
-		return indexes.size();
-	}
-
-	Index *FindForeignKeyIndex(const vector<idx_t> &fk_keys, ForeignKeyType fk_type);
-
-private:
-	//! Indexes associated with the current table
-	mutex indexes_lock;
-	vector<unique_ptr<Index>> indexes;
-};
-
-struct DataTableInfo {
-	DataTableInfo(DatabaseInstance &db, string schema, string table)
-	    : db(db), cardinality(0), schema(std::move(schema)), table(std::move(table)) {
-	}
-
-	//! The database instance of the table
-	DatabaseInstance &db;
-	//! The amount of elements in the table. Note that this number signifies the amount of COMMITTED entries in the
-	//! table. It can be inaccurate inside of transactions. More work is needed to properly support that.
-	atomic<idx_t> cardinality;
-	// schema of the table
-	string schema;
-	// name of the table
-	string table;
-
-	TableIndexList indexes;
-
-	bool IsTemporary() {
-		return schema == TEMP_SCHEMA;
-	}
-};
-
-struct ParallelTableScanState {
-	RowGroup *current_row_group;
-	idx_t vector_index;
-	idx_t max_row;
-	LocalScanState local_state;
-	bool transaction_local_data;
-};
-
-//! DataTable represents a physical table on disk
-class DataTable {
-public:
-	//! Constructs a new data table from an (optional) set of persistent segments
-	DataTable(DatabaseInstance &db, const string &schema, const string &table,
-	          vector<ColumnDefinition> column_definitions_p, unique_ptr<PersistentTableData> data = nullptr);
-	//! Constructs a DataTable as a delta on an existing data table with a newly added column
-	DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression *default_value);
-	//! Constructs a DataTable as a delta on an existing data table but with one column removed
-	DataTable(ClientContext &context, DataTable &parent, idx_t removed_column);
-	//! Constructs a DataTable as a delta on an existing data table but with one column changed type
-	DataTable(ClientContext &context, DataTable &parent, idx_t changed_idx, const LogicalType &target_type,
-	          vector<column_t> bound_columns, Expression &cast_expr);
-
-	shared_ptr<DataTableInfo> info;
-
-	vector<ColumnDefinition> column_definitions;
-
-	//! A reference to the database instance
-	DatabaseInstance &db;
-
-public:
-	//! Returns a list of types of the table
-	vector<LogicalType> GetTypes();
-
-	void InitializeScan(TableScanState &state, const vector<column_t> &column_ids,
-	                    TableFilterSet *table_filter = nullptr);
-	void InitializeScan(Transaction &transaction, TableScanState &state, const vector<column_t> &column_ids,
-	                    TableFilterSet *table_filters = nullptr);
-
-	//! Returns the maximum amount of threads that should be assigned to scan this data table
-	idx_t MaxThreads(ClientContext &context);
-	void InitializeParallelScan(ClientContext &context, ParallelTableScanState &state);
-	bool NextParallelScan(ClientContext &context, ParallelTableScanState &state, TableScanState &scan_state,
-	                      const vector<column_t> &column_ids);
-
-	//! Scans up to STANDARD_VECTOR_SIZE elements from the table starting
-	//! from offset and store them in result. Offset is incremented with how many
-	//! elements were returned.
-	//! Returns true if all pushed down filters were executed during data fetching
-	void Scan(Transaction &transaction, DataChunk &result, TableScanState &state, vector<column_t> &column_ids);
-
-	//! Fetch data from the specific row identifiers from the base table
-	void Fetch(Transaction &transaction, DataChunk &result, const vector<column_t> &column_ids, Vector &row_ids,
-	           idx_t fetch_count, ColumnFetchState &state);
-
-	//! Append a DataChunk to the table. Throws an exception if the columns don't match the tables' columns.
-	void Append(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
-	//! Delete the entries with the specified row identifier from the table
-	idx_t Delete(TableCatalogEntry &table, ClientContext &context, Vector &row_ids, idx_t count);
-	//! Update the entries with the specified row identifier from the table
-	void Update(TableCatalogEntry &table, ClientContext &context, Vector &row_ids, const vector<column_t> &column_ids,
-	            DataChunk &data);
-	//! Update a single (sub-)column along a column path
-	//! The column_path vector is a *path* towards a column within the table
-	//! i.e. if we have a table with a single column S STRUCT(A INT, B INT)
-	//! and we update the validity mask of "S.B"
-	//! the column path is:
-	//! 0 (first column of table)
-	//! -> 1 (second subcolumn of struct)
-	//! -> 0 (first subcolumn of INT)
-	//! This method should only be used from the WAL replay. It does not verify update constraints.
-	void UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
-	                  const vector<column_t> &column_path, DataChunk &updates);
-
-	//! Add an index to the DataTable
-	void AddIndex(unique_ptr<Index> index, const vector<unique_ptr<Expression>> &expressions);
-
-	//! Begin appending structs to this table, obtaining necessary locks, etc
-	void InitializeAppend(Transaction &transaction, TableAppendState &state, idx_t append_count);
-	//! Append a chunk to the table using the AppendState obtained from BeginAppend
-	void Append(Transaction &transaction, DataChunk &chunk, TableAppendState &state);
-	//! Commit the append
-	void CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count);
-	//! Write a segment of the table to the WAL
-	void WriteToLog(WriteAheadLog &log, idx_t row_start, idx_t count);
-	//! Revert a set of appends made by the given AppendState, used to revert appends in the event of an error during
-	//! commit (e.g. because of an I/O exception)
-	void RevertAppend(idx_t start_row, idx_t count);
-	void RevertAppendInternal(idx_t start_row, idx_t count);
-
-	void ScanTableSegment(idx_t start_row, idx_t count, const std::function<void(DataChunk &chunk)> &function);
-
-	//! Append a chunk with the row ids [row_start, ..., row_start + chunk.size()] to all indexes of the table, returns
-	//! whether or not the append succeeded
-	bool AppendToIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start);
-	//! Remove a chunk with the row ids [row_start, ..., row_start + chunk.size()] from all indexes of the table
-	void RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start);
-	//! Remove the chunk with the specified set of row identifiers from all indexes of the table
-	void RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, Vector &row_identifiers);
-	//! Remove the row identifiers from all the indexes of the table
-	void RemoveFromIndexes(Vector &row_identifiers, idx_t count);
-
-	void SetAsRoot() {
-		this->is_root = true;
-	}
-
-	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id);
-
-	//! Checkpoint the table to the specified table data writer
-	BlockPointer Checkpoint(TableDataWriter &writer);
-	void CommitDropTable();
-	void CommitDropColumn(idx_t index);
-
-	idx_t GetTotalRows();
-
-	//! Appends an empty row_group to the table
-	void AppendRowGroup(idx_t start_row);
-
-	vector<vector<Value>> GetStorageInfo();
-
-private:
-	//! Verify constraints with a chunk from the Append containing all columns of the table
-	void VerifyAppendConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
-	//! Verify constraints with a chunk from the Update containing only the specified column_ids
-	void VerifyUpdateConstraints(TableCatalogEntry &table, DataChunk &chunk, const vector<column_t> &column_ids);
-	//! Verify constraints with a chunk from the Delete containing all columns of the table
-	void VerifyDeleteConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
-
-	void InitializeScanWithOffset(TableScanState &state, const vector<column_t> &column_ids, idx_t start_row,
-	                              idx_t end_row);
-	bool InitializeScanInRowGroup(TableScanState &state, const vector<column_t> &column_ids,
-	                              TableFilterSet *table_filters, RowGroup *row_group, idx_t vector_index,
-	                              idx_t max_row);
-	bool ScanBaseTable(Transaction &transaction, DataChunk &result, TableScanState &state);
-
-	//! The CreateIndexScan is a special scan that is used to create an index on the table, it keeps locks on the table
-	void InitializeCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids);
-	bool ScanCreateIndex(CreateIndexScanState &state, DataChunk &result, TableScanType type);
-
-private:
-	//! Lock for appending entries to the table
-	mutex append_lock;
-	//! The number of rows in the table
-	atomic<idx_t> total_rows;
-	//! The segment trees holding the various row_groups of the table
-	shared_ptr<SegmentTree> row_groups;
-	//! Column statistics
-	vector<shared_ptr<ColumnStatistics>> column_stats;
-	//! The statistics lock
-	mutex stats_lock;
-	//! Whether or not the data table is the root DataTable for this table; the root DataTable is the newest version
-	//! that can be appended to
-	atomic<bool> is_root;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/pragma_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/pragma_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-enum class PragmaType : uint8_t { PRAGMA_STATEMENT, PRAGMA_CALL };
-
-struct PragmaInfo : public ParseInfo {
-	//! Name of the PRAGMA statement
-	string name;
-	//! Parameter list (if any)
-	vector<Value> parameters;
-	//! Named parameter list (if any)
-	named_parameter_map_t named_parameters;
-
-public:
-	unique_ptr<PragmaInfo> Copy() const {
-		auto result = make_unique<PragmaInfo>();
-		result->name = name;
-		result->parameters = parameters;
-		result->named_parameters = named_parameters;
-		return result;
-	}
-};
-
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class ClientContext;
-
-//! Return a substitute query to execute instead of this pragma statement
-typedef string (*pragma_query_t)(ClientContext &context, const FunctionParameters &parameters);
-//! Execute the main pragma function
-typedef void (*pragma_function_t)(ClientContext &context, const FunctionParameters &parameters);
-
-//! Pragma functions are invoked by calling PRAGMA x
-//! Pragma functions come in three types:
-//! * Call: function call, e.g. PRAGMA table_info('tbl')
-//!   -> call statements can take multiple parameters
-//! * Statement: statement without parameters, e.g. PRAGMA show_tables
-//!   -> this is similar to a call pragma but without parameters
-//! Pragma functions can either return a new query to execute (pragma_query_t)
-//! or they can
-class PragmaFunction : public SimpleNamedParameterFunction {
-public:
-	// Call
-	DUCKDB_API static PragmaFunction PragmaCall(const string &name, pragma_query_t query, vector<LogicalType> arguments,
-	                                            LogicalType varargs = LogicalType::INVALID);
-	DUCKDB_API static PragmaFunction PragmaCall(const string &name, pragma_function_t function,
-	                                            vector<LogicalType> arguments,
-	                                            LogicalType varargs = LogicalType::INVALID);
-	// Statement
-	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_query_t query);
-	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_function_t function);
-
-	DUCKDB_API string ToString() override;
-
-public:
-	PragmaType type;
-
-	pragma_query_t query;
-	pragma_function_t function;
-	named_parameter_type_map_t named_parameters;
-
-private:
-	PragmaFunction(string name, PragmaType pragma_type, pragma_query_t query, pragma_function_t function,
-	               vector<LogicalType> arguments, LogicalType varargs);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parser.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/simplified_token.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! Simplified tokens are a simplified (dense) representation of the lexer
-//! Used for simple syntax highlighting in the tests
-enum class SimplifiedTokenType : uint8_t {
-	SIMPLIFIED_TOKEN_IDENTIFIER,
-	SIMPLIFIED_TOKEN_NUMERIC_CONSTANT,
-	SIMPLIFIED_TOKEN_STRING_CONSTANT,
-	SIMPLIFIED_TOKEN_OPERATOR,
-	SIMPLIFIED_TOKEN_KEYWORD,
-	SIMPLIFIED_TOKEN_COMMENT
-};
-
-struct SimplifiedToken {
-	SimplifiedTokenType type;
-	idx_t start;
-};
-
-enum class KeywordCategory : uint8_t { KEYWORD_RESERVED, KEYWORD_UNRESERVED, KEYWORD_TYPE_FUNC, KEYWORD_COL_NAME };
-
-struct ParserKeyword {
-	string name;
-	KeywordCategory category;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb_libpgquery {
-struct PGNode;
-struct PGList;
-} // namespace duckdb_libpgquery
-
-namespace duckdb {
-class ParserExtension;
-
-struct ParserOptions {
-	bool preserve_identifier_case = true;
-	idx_t max_expression_depth = 1000;
-	vector<ParserExtension> *extensions = nullptr;
-};
-
-//! The parser is responsible for parsing the query and converting it into a set
-//! of parsed statements. The parsed statements can then be converted into a
-//! plan and executed.
-class Parser {
-public:
-	Parser(ParserOptions options = ParserOptions());
-
-	//! The parsed SQL statements from an invocation to ParseQuery.
-	vector<unique_ptr<SQLStatement>> statements;
-
-public:
-	//! Attempts to parse a query into a series of SQL statements. Returns
-	//! whether or not the parsing was successful. If the parsing was
-	//! successful, the parsed statements will be stored in the statements
-	//! variable.
-	void ParseQuery(const string &query);
-
-	//! Tokenize a query, returning the raw tokens together with their locations
-	static vector<SimplifiedToken> Tokenize(const string &query);
-
-	//! Returns true if the given text matches a keyword of the parser
-	static bool IsKeyword(const string &text);
-	//! Returns a list of all keywords in the parser
-	static vector<ParserKeyword> KeywordList();
-
-	//! Parses a list of expressions (i.e. the list found in a SELECT clause)
-	DUCKDB_API static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list,
-	                                                                           ParserOptions options = ParserOptions());
-	//! Parses a list as found in an ORDER BY expression (i.e. including optional ASCENDING/DESCENDING modifiers)
-	static vector<OrderByNode> ParseOrderList(const string &select_list, ParserOptions options = ParserOptions());
-	//! Parses an update list (i.e. the list found in the SET clause of an UPDATE statement)
-	static void ParseUpdateList(const string &update_list, vector<string> &update_columns,
-	                            vector<unique_ptr<ParsedExpression>> &expressions,
-	                            ParserOptions options = ParserOptions());
-	//! Parses a VALUES list (i.e. the list of expressions after a VALUES clause)
-	static vector<vector<unique_ptr<ParsedExpression>>> ParseValuesList(const string &value_list,
-	                                                                    ParserOptions options = ParserOptions());
-	//! Parses a column list (i.e. as found in a CREATE TABLE statement)
-	static vector<ColumnDefinition> ParseColumnList(const string &column_list, ParserOptions options = ParserOptions());
-
-private:
-	ParserOptions options;
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/object_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-class ClientContext;
-
-//! ObjectCache is the base class for objects caches in DuckDB
-class ObjectCacheEntry {
-public:
-	virtual ~ObjectCacheEntry() {
-	}
-
-	virtual string GetObjectType() = 0;
-};
-
-class ObjectCache {
-public:
-	shared_ptr<ObjectCacheEntry> GetObject(const string &key) {
-		lock_guard<mutex> glock(lock);
-		auto entry = cache.find(key);
-		if (entry == cache.end()) {
-			return nullptr;
-		}
-		return entry->second;
-	}
-
-	template <class T>
-	shared_ptr<T> Get(const string &key) {
-		shared_ptr<ObjectCacheEntry> object = GetObject(key);
-		if (!object || object->GetObjectType() != T::ObjectType()) {
-			return nullptr;
-		}
-		return std::static_pointer_cast<T, ObjectCacheEntry>(object);
-	}
-
-	void Put(string key, shared_ptr<ObjectCacheEntry> value) {
-		lock_guard<mutex> glock(lock);
-		cache[key] = std::move(value);
-	}
-
-	static ObjectCache &GetObjectCache(ClientContext &context);
-	static bool ObjectCacheEnabled(ClientContext &context);
-
-private:
-	//! Object Cache
-	unordered_map<string, shared_ptr<ObjectCacheEntry>> cache;
-	mutex lock;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/table_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/filter_propagate_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class FilterPropagateResult : uint8_t {
-	NO_PRUNING_POSSIBLE = 0,
-	FILTER_ALWAYS_TRUE = 1,
-	FILTER_ALWAYS_FALSE = 2,
-	FILTER_TRUE_OR_NULL = 3,
-	FILTER_FALSE_OR_NULL = 4
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class BaseStatistics;
-
-enum class TableFilterType : uint8_t {
-	CONSTANT_COMPARISON = 0, // constant comparison (e.g. =C, >C, >=C, <C, <=C)
-	IS_NULL = 1,
-	IS_NOT_NULL = 2,
-	CONJUNCTION_OR = 3,
-	CONJUNCTION_AND = 4
-};
-
-//! TableFilter represents a filter pushed down into the table scan.
-class TableFilter {
-public:
-	TableFilter(TableFilterType filter_type_p) : filter_type(filter_type_p) {
-	}
-	virtual ~TableFilter() {
-	}
-
-	TableFilterType filter_type;
-
-public:
-	//! Returns true if the statistics indicate that the segment can contain values that satisfy that filter
-	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
-	virtual string ToString(const string &column_name) = 0;
-	virtual bool Equals(const TableFilter &other) const {
-		return filter_type != other.filter_type;
-	}
-};
-
-class TableFilterSet {
-public:
-	unordered_map<idx_t, unique_ptr<TableFilter>> filters;
-
-public:
-	void PushFilter(idx_t table_index, unique_ptr<TableFilter> filter);
-
-	bool Equals(TableFilterSet &other) {
-		if (filters.size() != other.filters.size()) {
-			return false;
-		}
-		for (auto &entry : filters) {
-			auto other_entry = other.filters.find(entry.first);
-			if (other_entry == other.filters.end()) {
-				return false;
-			}
-			if (!entry.second->Equals(*other_entry->second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	static bool Equals(TableFilterSet *left, TableFilterSet *right) {
-		if (left == right) {
-			return true;
-		}
-		if (!left || !right) {
-			return false;
-		}
-		return left->Equals(*right);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/string_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/validity_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-class Vector;
-
-class ValidityStatistics : public BaseStatistics {
-public:
-	explicit ValidityStatistics(bool has_null = false, bool has_no_null = true);
-
-	//! Whether or not the segment can contain NULL values
-	bool has_null;
-	//! Whether or not the segment can contain values that are not null
-	bool has_no_null;
-
-public:
-	void Merge(const BaseStatistics &other) override;
-
-	bool IsConstant() const override;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ValidityStatistics> Deserialize(FieldReader &reader);
-
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	static unique_ptr<BaseStatistics> Combine(const unique_ptr<BaseStatistics> &lstats,
-	                                          const unique_ptr<BaseStatistics> &rstats);
-
-	string ToString() const override;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-class StringStatistics : public BaseStatistics {
-public:
-	constexpr static uint32_t MAX_STRING_MINMAX_SIZE = 8;
-
-public:
-	explicit StringStatistics(LogicalType type, StatisticsType stats_type);
-
-	//! The minimum value of the segment, potentially truncated
-	data_t min[MAX_STRING_MINMAX_SIZE];
-	//! The maximum value of the segment, potentially truncated
-	data_t max[MAX_STRING_MINMAX_SIZE];
-	//! Whether or not the column can contain unicode characters
-	bool has_unicode;
-	//! The maximum string length in bytes
-	uint32_t max_string_length;
-	//! Whether or not the segment contains any big strings in overflow blocks
-	bool has_overflow_strings;
-
-public:
-	void Update(const string_t &value);
-	void Merge(const BaseStatistics &other) override;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const string &value) const;
-
-	string ToString() const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/numeric_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/windows_undefs.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#ifdef WIN32
-
-#ifdef min
-#undef min
-#endif
-
-#ifdef max
-#undef max
-#endif
-
-#ifdef ERROR
-#undef ERROR
-#endif
-
-#ifdef small
-#undef small
-#endif
-
-#ifdef CreateDirectory
-#undef CreateDirectory
-#endif
-
-#ifdef MoveFile
-#undef MoveFile
-#endif
-
-#ifdef RemoveDirectory
-#undef RemoveDirectory
-#endif
-
-#endif
-
-
-
-namespace duckdb {
-
-class NumericStatistics : public BaseStatistics {
-public:
-	explicit NumericStatistics(LogicalType type, StatisticsType stats_type);
-	NumericStatistics(LogicalType type, Value min, Value max, StatisticsType stats_type);
-
-	//! The minimum value of the segment
-	Value min;
-	//! The maximum value of the segment
-	Value max;
-
-public:
-	void Merge(const BaseStatistics &other) override;
-
-	bool IsConstant() const override;
-
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	string ToString() const override;
-
-private:
-	template <class T>
-	void TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count) const;
-
-public:
-	template <class T>
-	static inline void UpdateValue(T new_value, T &min, T &max) {
-		if (LessThan::Operation(new_value, min)) {
-			min = new_value;
-		}
-		if (GreaterThan::Operation(new_value, max)) {
-			max = new_value;
-		}
-	}
-
-	template <class T>
-	static inline void Update(SegmentStatistics &stats, T new_value) {
-		auto &nstats = (NumericStatistics &)*stats.statistics;
-		UpdateValue<T>(new_value, nstats.min.GetReferenceUnsafe<T>(), nstats.max.GetReferenceUnsafe<T>());
-	}
-};
-
-template <>
-void NumericStatistics::Update<interval_t>(SegmentStatistics &stats, interval_t new_value);
-template <>
-void NumericStatistics::Update<list_entry_t>(SegmentStatistics &stats, list_entry_t new_value);
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/conjunction_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class ConjunctionFilter : public TableFilter {
-public:
-	ConjunctionFilter(TableFilterType filter_type_p) : TableFilter(filter_type_p) {
-	}
-
-	virtual ~ConjunctionFilter() {
-	}
-
-	//! The filters of this conjunction
-	vector<unique_ptr<TableFilter>> child_filters;
-
-public:
-	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
-	virtual string ToString(const string &column_name) = 0;
-
-	virtual bool Equals(const TableFilter &other) const {
-		return TableFilter::Equals(other);
-	}
-};
-
-class ConjunctionOrFilter : public ConjunctionFilter {
-public:
-	ConjunctionOrFilter();
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-};
-
-class ConjunctionAndFilter : public ConjunctionFilter {
-public:
-	ConjunctionAndFilter();
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/constant_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class ConstantFilter : public TableFilter {
-public:
-	ConstantFilter(ExpressionType comparison_type, Value constant);
-
-	//! The comparison type (e.g. COMPARE_EQUAL, COMPARE_GREATERTHAN, COMPARE_LESSTHAN, ...)
-	ExpressionType comparison_type;
-	//! The constant value to filter on
-	Value constant;
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-	bool Equals(const TableFilter &other) const override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/buffered_csv_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/strftime.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-#include <algorithm>
-
-namespace duckdb {
-
-enum class StrTimeSpecifier : uint8_t {
-	ABBREVIATED_WEEKDAY_NAME = 0,    // %a - Abbreviated weekday name. (Sun, Mon, ...)
-	FULL_WEEKDAY_NAME = 1,           // %A Full weekday name. (Sunday, Monday, ...)
-	WEEKDAY_DECIMAL = 2,             // %w - Weekday as a decimal number. (0, 1, ..., 6)
-	DAY_OF_MONTH_PADDED = 3,         // %d - Day of the month as a zero-padded decimal. (01, 02, ..., 31)
-	DAY_OF_MONTH = 4,                // %-d - Day of the month as a decimal number. (1, 2, ..., 30)
-	ABBREVIATED_MONTH_NAME = 5,      // %b - Abbreviated month name. (Jan, Feb, ..., Dec)
-	FULL_MONTH_NAME = 6,             // %B - Full month name. (January, February, ...)
-	MONTH_DECIMAL_PADDED = 7,        // %m - Month as a zero-padded decimal number. (01, 02, ..., 12)
-	MONTH_DECIMAL = 8,               // %-m - Month as a decimal number. (1, 2, ..., 12)
-	YEAR_WITHOUT_CENTURY_PADDED = 9, // %y - Year without century as a zero-padded decimal number. (00, 01, ..., 99)
-	YEAR_WITHOUT_CENTURY = 10,       // %-y - Year without century as a decimal number. (0, 1, ..., 99)
-	YEAR_DECIMAL = 11,               // %Y - Year with century as a decimal number. (2013, 2019 etc.)
-	HOUR_24_PADDED = 12,             // %H - Hour (24-hour clock) as a zero-padded decimal number. (00, 01, ..., 23)
-	HOUR_24_DECIMAL = 13,            // %-H - Hour (24-hour clock) as a decimal number. (0, 1, ..., 23)
-	HOUR_12_PADDED = 14,             // %I - Hour (12-hour clock) as a zero-padded decimal number. (01, 02, ..., 12)
-	HOUR_12_DECIMAL = 15,            // %-I - Hour (12-hour clock) as a decimal number. (1, 2, ... 12)
-	AM_PM = 16,                      // %p - Locale’s AM or PM. (AM, PM)
-	MINUTE_PADDED = 17,              // %M - Minute as a zero-padded decimal number. (00, 01, ..., 59)
-	MINUTE_DECIMAL = 18,             // %-M - Minute as a decimal number. (0, 1, ..., 59)
-	SECOND_PADDED = 19,              // %S - Second as a zero-padded decimal number. (00, 01, ..., 59)
-	SECOND_DECIMAL = 20,             // %-S - Second as a decimal number. (0, 1, ..., 59)
-	MICROSECOND_PADDED = 21,         // %f - Microsecond as a decimal number, zero-padded on the left. (000000 - 999999)
-	MILLISECOND_PADDED = 22,         // %g - Millisecond as a decimal number, zero-padded on the left. (000 - 999)
-	UTC_OFFSET = 23,                 // %z - UTC offset in the form +HHMM or -HHMM. ( )
-	TZ_NAME = 24,                    // %Z - Time zone name. ( )
-	DAY_OF_YEAR_PADDED = 25,         // %j - Day of the year as a zero-padded decimal number. (001, 002, ..., 366)
-	DAY_OF_YEAR_DECIMAL = 26,        // %-j - Day of the year as a decimal number. (1, 2, ..., 366)
-	WEEK_NUMBER_PADDED_SUN_FIRST =
-	    27, // %U - Week number of the year (Sunday as the first day of the week). All days in a new year preceding the
-	        // first Sunday are considered to be in week 0. (00, 01, ..., 53)
-	WEEK_NUMBER_PADDED_MON_FIRST =
-	    28, // %W - Week number of the year (Monday as the first day of the week). All days in a new year preceding the
-	        // first Monday are considered to be in week 0. (00, 01, ..., 53)
-	LOCALE_APPROPRIATE_DATE_AND_TIME =
-	    29, // %c - Locale’s appropriate date and time representation. (Mon Sep 30 07:06:05 2013)
-	LOCALE_APPROPRIATE_DATE = 30, // %x - Locale’s appropriate date representation. (09/30/13)
-	LOCALE_APPROPRIATE_TIME = 31  // %X - Locale’s appropriate time representation. (07:06:05)
-};
-
-struct StrTimeFormat {
-public:
-	virtual ~StrTimeFormat() {
-	}
-
-	DUCKDB_API static string ParseFormatSpecifier(const string &format_string, StrTimeFormat &format);
-
-	inline bool HasFormatSpecifier(StrTimeSpecifier s) const {
-		return std::find(specifiers.begin(), specifiers.end(), s) != specifiers.end();
-	}
-
-protected:
-	//! The format specifiers
-	vector<StrTimeSpecifier> specifiers;
-	//! The literals that appear in between the format specifiers
-	//! The following must hold: literals.size() = specifiers.size() + 1
-	//! Format is literals[0], specifiers[0], literals[1], ..., specifiers[n - 1], literals[n]
-	vector<string> literals;
-	//! The constant size that appears in the format string
-	idx_t constant_size = 0;
-	//! The max numeric width of the specifier (if it is parsed as a number), or -1 if it is not a number
-	vector<int> numeric_width;
-
-protected:
-	void AddLiteral(string literal);
-	DUCKDB_API virtual void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier);
-};
-
-struct StrfTimeFormat : public StrTimeFormat {
-	DUCKDB_API idx_t GetLength(date_t date, dtime_t time, int32_t utc_offset, const char *tz_name);
-
-	DUCKDB_API void FormatString(date_t date, int32_t data[8], const char *tz_name, char *target);
-	void FormatString(date_t date, dtime_t time, char *target);
-
-	DUCKDB_API static string Format(timestamp_t timestamp, const string &format);
-
-	DUCKDB_API void ConvertDateVector(Vector &input, Vector &result, idx_t count);
-	DUCKDB_API void ConvertTimestampVector(Vector &input, Vector &result, idx_t count);
-
-protected:
-	//! The variable-length specifiers. To determine total string size, these need to be checked.
-	vector<StrTimeSpecifier> var_length_specifiers;
-	//! Whether or not the current specifier is a special "date" specifier (i.e. one that requires a date_t object to
-	//! generate)
-	vector<bool> is_date_specifier;
-
-protected:
-	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
-	static idx_t GetSpecifierLength(StrTimeSpecifier specifier, date_t date, dtime_t time, int32_t utc_offset,
-	                                const char *tz_name);
-	char *WriteString(char *target, const string_t &str);
-	char *Write2(char *target, uint8_t value);
-	char *WritePadded2(char *target, uint32_t value);
-	char *WritePadded3(char *target, uint32_t value);
-	char *WritePadded(char *target, uint32_t value, size_t padding);
-	bool IsDateSpecifier(StrTimeSpecifier specifier);
-	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target);
-	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name, char *target);
-};
-
-struct StrpTimeFormat : public StrTimeFormat {
-public:
-	//! Type-safe parsing argument
-	struct ParseResult {
-		int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
-		string tz;
-		string error_message;
-		idx_t error_position = DConstants::INVALID_INDEX;
-
-		date_t ToDate();
-		timestamp_t ToTimestamp();
-		DUCKDB_API string FormatError(string_t input, const string &format_specifier);
-	};
-
-public:
-	//! The full format specifier, for error messages
-	string format_specifier;
-
-public:
-	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
-
-	DUCKDB_API bool Parse(string_t str, ParseResult &result);
-
-	bool TryParseDate(string_t str, date_t &result, string &error_message);
-	bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message);
-
-	date_t ParseDate(string_t str);
-	timestamp_t ParseTimestamp(string_t str);
-
-protected:
-	static string FormatStrpTimeError(const string &input, idx_t position);
-	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
-	int NumericSpecifierWidth(StrTimeSpecifier specifier);
-	int32_t TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
-	                           idx_t collection_count);
-};
-
-} // namespace duckdb
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/queue.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <queue>
-
-namespace duckdb {
-using std::queue;
-}
-
-
-#include <sstream>
-
-namespace duckdb {
-struct CopyInfo;
-struct CSVFileHandle;
-struct FileHandle;
-struct StrpTimeFormat;
-
-class FileOpener;
-class FileSystem;
-
-//! The shifts array allows for linear searching of multi-byte values. For each position, it determines the next
-//! position given that we encounter a byte with the given value.
-/*! For example, if we have a string "ABAC", the shifts array will have the following values:
- *  [0] --> ['A'] = 1, all others = 0
- *  [1] --> ['B'] = 2, ['A'] = 1, all others = 0
- *  [2] --> ['A'] = 3, all others = 0
- *  [3] --> ['C'] = 4 (match), 'B' = 2, 'A' = 1, all others = 0
- * Suppose we then search in the following string "ABABAC", our progression will be as follows:
- * 'A' -> [1], 'B' -> [2], 'A' -> [3], 'B' -> [2], 'A' -> [3], 'C' -> [4] (match!)
- */
-struct TextSearchShiftArray {
-	TextSearchShiftArray();
-	explicit TextSearchShiftArray(string search_term);
-
-	inline bool Match(uint8_t &position, uint8_t byte_value) {
-		if (position >= length) {
-			return false;
-		}
-		position = shifts[position * 255 + byte_value];
-		return position == length;
-	}
-
-	idx_t length;
-	unique_ptr<uint8_t[]> shifts;
-};
-
-struct BufferedCSVReaderOptions {
-	//===--------------------------------------------------------------------===//
-	// CommonCSVOptions
-	//===--------------------------------------------------------------------===//
-
-	//! Whether or not a delimiter was defined by the user
-	bool has_delimiter = false;
-	//! Delimiter to separate columns within each line
-	string delimiter = ",";
-	//! Whether or not a quote sign was defined by the user
-	bool has_quote = false;
-	//! Quote used for columns that contain reserved characters, e.g., delimiter
-	string quote = "\"";
-	//! Whether or not an escape character was defined by the user
-	bool has_escape = false;
-	//! Escape character to escape quote character
-	string escape;
-	//! Whether or not a header information was given by the user
-	bool has_header = false;
-	//! Whether or not the file has a header line
-	bool header = false;
-	//! Whether or not we should ignore InvalidInput errors
-	bool ignore_errors = false;
-	//! Expected number of columns
-	idx_t num_cols = 0;
-	//! Number of samples to buffer
-	idx_t buffer_size = STANDARD_VECTOR_SIZE * 100;
-	//! Specifies the string that represents a null value
-	string null_str;
-	//! Whether file is compressed or not, and if so which compression type
-	//! AUTO_DETECT (default; infer from file extension)
-	FileCompressionType compression = FileCompressionType::AUTO_DETECT;
-
-	//===--------------------------------------------------------------------===//
-	// ReadCSVOptions
-	//===--------------------------------------------------------------------===//
-
-	//! How many leading rows to skip
-	idx_t skip_rows = 0;
-	//! Maximum CSV line size: specified because if we reach this amount, we likely have wrong delimiters (default: 2MB)
-	//! note that this is the guaranteed line length that will succeed, longer lines may be accepted if slightly above
-	idx_t maximum_line_size = 2097152;
-	//! Whether or not header names shall be normalized
-	bool normalize_names = false;
-	//! True, if column with that index must skip null check
-	vector<bool> force_not_null;
-	//! Consider all columns to be of type varchar
-	bool all_varchar = false;
-	//! Size of sample chunk used for dialect and type detection
-	idx_t sample_chunk_size = STANDARD_VECTOR_SIZE;
-	//! Number of sample chunks used for type detection
-	idx_t sample_chunks = 10;
-	//! Whether or not to automatically detect dialect and datatypes
-	bool auto_detect = false;
-	//! The file path of the CSV file to read
-	string file_path;
-	//! Whether or not to include a file name column
-	bool include_file_name = false;
-
-	//===--------------------------------------------------------------------===//
-	// WriteCSVOptions
-	//===--------------------------------------------------------------------===//
-
-	//! The column names of the columns to write
-	vector<string> names;
-	//! True, if column with that index must be quoted
-	vector<bool> force_quote;
-
-	//! The date format to use (if any is specified)
-	std::map<LogicalTypeId, StrpTimeFormat> date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
-	//! The date format to use for writing (if any is specified)
-	std::map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}},
-	                                                             {LogicalTypeId::TIMESTAMP, {}}};
-	//! Whether or not a type format is specified
-	std::map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
-
-	void SetDelimiter(const string &delimiter);
-	//! Set an option that is supported by both reading and writing functions, called by
-	//! the SetReadOption and SetWriteOption methods
-	bool SetBaseOption(const string &loption, const Value &value);
-
-	//! loption - lowercase string
-	//! set - argument(s) to the option
-	//! expected_names - names expected if the option is "columns"
-	void SetReadOption(const string &loption, const Value &value, vector<string> &expected_names);
-
-	void SetWriteOption(const string &loption, const Value &value);
-	void SetDateFormat(LogicalTypeId type, const string &format, bool read_format);
-
-	std::string ToString() const;
-};
-
-enum class ParserMode : uint8_t { PARSING = 0, SNIFFING_DIALECT = 1, SNIFFING_DATATYPES = 2, PARSING_HEADER = 3 };
-
-//! Buffered CSV reader is a class that reads values from a stream and parses them as a CSV file
-class BufferedCSVReader {
-	//! Initial buffer read size; can be extended for long lines
-	static constexpr idx_t INITIAL_BUFFER_SIZE = 16384;
-	//! Larger buffer size for non disk files
-	static constexpr idx_t INITIAL_BUFFER_SIZE_LARGE = 10000000; // 10MB
-	ParserMode mode;
-
-public:
-	BufferedCSVReader(ClientContext &context, BufferedCSVReaderOptions options,
-	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
-
-	BufferedCSVReader(FileSystem &fs, Allocator &allocator, FileOpener *opener, BufferedCSVReaderOptions options,
-	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
-	~BufferedCSVReader();
-
-	FileSystem &fs;
-	Allocator &allocator;
-	FileOpener *opener;
-	BufferedCSVReaderOptions options;
-	vector<LogicalType> sql_types;
-	vector<string> col_names;
-	unique_ptr<CSVFileHandle> file_handle;
-
-	unique_ptr<char[]> buffer;
-	idx_t buffer_size;
-	idx_t position;
-	idx_t start = 0;
-
-	idx_t linenr = 0;
-	bool linenr_estimated = false;
-
-	vector<idx_t> sniffed_column_counts;
-	bool row_empty = false;
-	idx_t sample_chunk_idx = 0;
-	bool jumping_samples = false;
-	bool end_of_file_reached = false;
-	bool bom_checked = false;
-
-	idx_t bytes_in_chunk = 0;
-	double bytes_per_line_avg = 0;
-
-	vector<unique_ptr<char[]>> cached_buffers;
-
-	TextSearchShiftArray delimiter_search, escape_search, quote_search;
-
-	DataChunk parse_chunk;
-
-	std::queue<unique_ptr<DataChunk>> cached_chunks;
-
-public:
-	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
-	void ParseCSV(DataChunk &insert_chunk);
-
-	idx_t GetFileSize();
-
-private:
-	//! Initialize Parser
-	void Initialize(const vector<LogicalType> &requested_types);
-	//! Initializes the parse_chunk with varchar columns and aligns info with new number of cols
-	void InitParseChunk(idx_t num_cols);
-	//! Initializes the TextSearchShiftArrays for complex parser
-	void PrepareComplexParser();
-	//! Try to parse a single datachunk from the file. Throws an exception if anything goes wrong.
-	void ParseCSV(ParserMode mode);
-	//! Try to parse a single datachunk from the file. Returns whether or not the parsing is successful
-	bool TryParseCSV(ParserMode mode);
-	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
-	bool TryParseCSV(ParserMode mode, DataChunk &insert_chunk, string &error_message);
-	//! Sniffs CSV dialect and determines skip rows, header row, column types and column names
-	vector<LogicalType> SniffCSV(const vector<LogicalType> &requested_types);
-	//! Change the date format for the type to the string
-	void SetDateFormat(const string &format_specifier, const LogicalTypeId &sql_type);
-	//! Try to cast a string value to the specified sql type
-	bool TryCastValue(const Value &value, const LogicalType &sql_type);
-	//! Try to cast a vector of values to the specified sql type
-	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type);
-	//! Skips skip_rows, reads header row from input stream
-	void SkipRowsAndReadHeader(idx_t skip_rows, bool skip_header);
-	//! Jumps back to the beginning of input stream and resets necessary internal states
-	void JumpToBeginning(idx_t skip_rows, bool skip_header);
-	//! Jumps back to the beginning of input stream and resets necessary internal states
-	bool JumpToNextSample();
-	//! Resets the buffer
-	void ResetBuffer();
-	//! Resets the steam
-	void ResetStream();
-
-	//! Parses a CSV file with a one-byte delimiter, escape and quote character
-	bool TryParseSimpleCSV(DataChunk &insert_chunk, string &error_message);
-	//! Parses more complex CSV files with multi-byte delimiters, escapes or quotes
-	bool TryParseComplexCSV(DataChunk &insert_chunk, string &error_message);
-
-	//! Adds a value to the current row
-	void AddValue(char *str_val, idx_t length, idx_t &column, vector<idx_t> &escape_positions);
-	//! Adds a row to the insert_chunk, returns true if the chunk is filled as a result of this row being added
-	bool AddRow(DataChunk &insert_chunk, idx_t &column);
-	//! Finalizes a chunk, parsing all values that have been added so far and adding them to the insert_chunk
-	void Flush(DataChunk &insert_chunk);
-	//! Reads a new buffer from the CSV file if the current one has been exhausted
-	bool ReadBuffer(idx_t &start);
-
-	unique_ptr<CSVFileHandle> OpenCSV(const BufferedCSVReaderOptions &options);
-
-	//! First phase of auto detection: detect CSV dialect (i.e. delimiter, quote rules, etc)
-	void DetectDialect(const vector<LogicalType> &requested_types, BufferedCSVReaderOptions &original_options,
-	                   vector<BufferedCSVReaderOptions> &info_candidates, idx_t &best_num_cols);
-	//! Second phase of auto detection: detect candidate types for each column
-	void DetectCandidateTypes(const vector<LogicalType> &type_candidates,
-	                          const map<LogicalTypeId, vector<const char *>> &format_template_candidates,
-	                          const vector<BufferedCSVReaderOptions> &info_candidates,
-	                          BufferedCSVReaderOptions &original_options, idx_t best_num_cols,
-	                          vector<vector<LogicalType>> &best_sql_types_candidates,
-	                          std::map<LogicalTypeId, vector<string>> &best_format_candidates,
-	                          DataChunk &best_header_row);
-	//! Third phase of auto detection: detect header of CSV file
-	void DetectHeader(const vector<vector<LogicalType>> &best_sql_types_candidates, const DataChunk &best_header_row);
-	//! Fourth phase of auto detection: refine the types of each column and select which types to use for each column
-	vector<LogicalType> RefineTypeDetection(const vector<LogicalType> &type_candidates,
-	                                        const vector<LogicalType> &requested_types,
-	                                        vector<vector<LogicalType>> &best_sql_types_candidates,
-	                                        map<LogicalTypeId, vector<string>> &best_format_candidates);
-
-private:
-	//! Whether or not the current row's columns have overflown sql_types.size()
-	bool error_column_overflow = false;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/vector_cache.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Allocator;
-class Vector;
-
-//! The VectorCache holds cached data that allows for re-use of the same memory by vectors
-class VectorCache {
-public:
-	//! Instantiate a vector cache with the given type
-	explicit VectorCache(Allocator &allocator, const LogicalType &type);
-
-	buffer_ptr<VectorBuffer> buffer;
-
-public:
-	void ResetFromCache(Vector &result) const;
-
-	const LogicalType &GetType() const;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/filter/null_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class IsNullFilter : public TableFilter {
-public:
-	IsNullFilter();
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-};
-
-class IsNotNullFilter : public TableFilter {
-public:
-	IsNotNullFilter();
-
-public:
-	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
-	string ToString(const string &column_name) override;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/compressed_file_system.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-class CompressedFile;
-
-struct StreamData {
-	// various buffers & pointers
-	bool write = false;
-	unique_ptr<data_t[]> in_buff;
-	unique_ptr<data_t[]> out_buff;
-	data_ptr_t out_buff_start = nullptr;
-	data_ptr_t out_buff_end = nullptr;
-	data_ptr_t in_buff_start = nullptr;
-	data_ptr_t in_buff_end = nullptr;
-
-	idx_t in_buf_size = 0;
-	idx_t out_buf_size = 0;
-};
-
-struct StreamWrapper {
-	DUCKDB_API virtual ~StreamWrapper();
-
-	DUCKDB_API virtual void Initialize(CompressedFile &file, bool write) = 0;
-	DUCKDB_API virtual bool Read(StreamData &stream_data) = 0;
-	DUCKDB_API virtual void Write(CompressedFile &file, StreamData &stream_data, data_ptr_t buffer,
-	                              int64_t nr_bytes) = 0;
-	DUCKDB_API virtual void Close() = 0;
-};
-
-class CompressedFileSystem : public FileSystem {
-public:
-	DUCKDB_API int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-	DUCKDB_API int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
-
-	DUCKDB_API void Reset(FileHandle &handle) override;
-
-	DUCKDB_API int64_t GetFileSize(FileHandle &handle) override;
-
-	DUCKDB_API bool OnDiskFile(FileHandle &handle) override;
-	DUCKDB_API bool CanSeek() override;
-
-	DUCKDB_API virtual unique_ptr<StreamWrapper> CreateStream() = 0;
-	DUCKDB_API virtual idx_t InBufferSize() = 0;
-	DUCKDB_API virtual idx_t OutBufferSize() = 0;
-};
-
-class CompressedFile : public FileHandle {
-public:
-	DUCKDB_API CompressedFile(CompressedFileSystem &fs, unique_ptr<FileHandle> child_handle_p, const string &path);
-	DUCKDB_API virtual ~CompressedFile() override;
-
-	CompressedFileSystem &compressed_fs;
-	unique_ptr<FileHandle> child_handle;
-	//! Whether the file is opened for reading or for writing
-	bool write = false;
-	StreamData stream_data;
-
-public:
-	DUCKDB_API void Initialize(bool write);
-	DUCKDB_API int64_t ReadData(void *buffer, int64_t nr_bytes);
-	DUCKDB_API int64_t WriteData(data_ptr_t buffer, int64_t nr_bytes);
-	DUCKDB_API void Close() override;
-
-private:
-	unique_ptr<StreamWrapper> stream_wrapper;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/between_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-class BetweenExpression : public ParsedExpression {
-public:
-	DUCKDB_API BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
-	                             unique_ptr<ParsedExpression> upper);
-
-	unique_ptr<ParsedExpression> input;
-	unique_ptr<ParsedExpression> lower;
-	unique_ptr<ParsedExpression> upper;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return entry.input->ToString() + " BETWEEN " + entry.lower->ToString() + " AND " + entry.upper->ToString();
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/case_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct CaseCheck {
-	unique_ptr<ParsedExpression> when_expr;
-	unique_ptr<ParsedExpression> then_expr;
-};
-
-//! The CaseExpression represents a CASE expression in the query
-class CaseExpression : public ParsedExpression {
-public:
-	DUCKDB_API CaseExpression();
-
-	vector<CaseCheck> case_checks;
-	unique_ptr<ParsedExpression> else_expr;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const CaseExpression *a, const CaseExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string case_str = "CASE ";
-		for (auto &check : entry.case_checks) {
-			case_str += " WHEN (" + check.when_expr->ToString() + ")";
-			case_str += " THEN (" + check.then_expr->ToString() + ")";
-		}
-		case_str += " ELSE " + entry.else_expr->ToString();
-		case_str += " END";
-		return case_str;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/cast_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! CastExpression represents a type cast from one SQL type to another SQL type
-class CastExpression : public ParsedExpression {
-public:
-	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
-
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The type to cast to
-	LogicalType cast_type;
-	//! Whether or not this is a try_cast expression
-	bool try_cast;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const CastExpression *a, const CastExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
-		       entry.cast_type.ToString() + ")";
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/collate_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! CollateExpression represents a COLLATE statement
-class CollateExpression : public ParsedExpression {
-public:
-	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
-
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The collation clause
-	string collation;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const CollateExpression *a, const CollateExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/comparison_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
-//! and has two children.
-class ComparisonExpression : public ParsedExpression {
-public:
-	DUCKDB_API ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                unique_ptr<ParsedExpression> right);
-
-	unique_ptr<ParsedExpression> left;
-	unique_ptr<ParsedExpression> right;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return entry.left->ToString() + " " + ExpressionTypeToOperator(entry.type) + " " + entry.right->ToString();
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/conjunction_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a conjunction (AND/OR)
-class ConjunctionExpression : public ParsedExpression {
-public:
-	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                 unique_ptr<ParsedExpression> right);
-
-	vector<unique_ptr<ParsedExpression>> children;
-
-public:
-	void AddExpression(unique_ptr<ParsedExpression> expr);
-
-	string ToString() const override;
-
-	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string result = "(" + entry.children[0]->ToString();
-		for (idx_t i = 1; i < entry.children.size(); i++) {
-			result += " " + ExpressionTypeToOperator(entry.type) + " " + entry.children[i]->ToString();
-		}
-		return result + ")";
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/constant_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! ConstantExpression represents a constant value in the query
-class ConstantExpression : public ParsedExpression {
-public:
-	DUCKDB_API explicit ConstantExpression(Value val);
-
-	//! The constant value referenced
-	Value value;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
-	hash_t Hash() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/default_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-//! Represents the default value of a column
-class DefaultExpression : public ParsedExpression {
-public:
-	DefaultExpression();
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/function_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-//! Represents a function call
-class FunctionExpression : public ParsedExpression {
-public:
-	DUCKDB_API FunctionExpression(string schema_name, const string &function_name,
-	                              vector<unique_ptr<ParsedExpression>> children,
-	                              unique_ptr<ParsedExpression> filter = nullptr,
-	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
-	                              bool is_operator = false, bool export_state = false);
-	DUCKDB_API FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                              unique_ptr<ParsedExpression> filter = nullptr,
-	                              unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
-	                              bool is_operator = false, bool export_state = false);
-
-	//! Schema of the function
-	string schema;
-	//! Function name
-	string function_name;
-	//! Whether or not the function is an operator, only used for rendering
-	bool is_operator;
-	//! List of arguments to the function
-	vector<unique_ptr<ParsedExpression>> children;
-	//! Whether or not the aggregate function is distinct, only used for aggregates
-	bool distinct;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<ParsedExpression> filter;
-	//! Modifier representing an ORDER BY, only used for aggregates
-	unique_ptr<OrderModifier> order_bys;
-	//! whether this function should export its state or not
-	bool export_state;
-
-public:
-	string ToString() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
-	hash_t Hash() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-	void Verify() const override;
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
-	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
-	                       bool export_state = false, bool add_alias = false) {
-		if (is_operator) {
-			// built-in operator
-			D_ASSERT(!distinct);
-			if (entry.children.size() == 1) {
-				if (StringUtil::Contains(function_name, "__postfix")) {
-					return "(" + entry.children[0]->ToString() + ")" +
-					       StringUtil::Replace(function_name, "__postfix", "");
-				} else {
-					return function_name + "(" + entry.children[0]->ToString() + ")";
-				}
-			} else if (entry.children.size() == 2) {
-				return "(" + entry.children[0]->ToString() + " " + function_name + " " + entry.children[1]->ToString() +
-				       ")";
-			}
-		}
-		// standard function call
-		string result = schema.empty() ? function_name : schema + "." + function_name;
-		result += "(";
-		if (distinct) {
-			result += "DISTINCT ";
-		}
-		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
-			return child->alias.empty() || !add_alias
-			           ? child->ToString()
-			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
-		});
-		// ordered aggregate
-		if (order_bys && !order_bys->orders.empty()) {
-			if (entry.children.empty()) {
-				result += ") WITHIN GROUP (";
-			}
-			result += " ORDER BY ";
-			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
-				if (i > 0) {
-					result += ", ";
-				}
-				result += order_bys->orders[i].ToString();
-			}
-		}
-		result += ")";
-
-		// filtered aggregate
-		if (filter) {
-			result += " FILTER (WHERE " + filter->ToString() + ")";
-		}
-
-		if (export_state) {
-			result += " EXPORT_STATE";
-		}
-
-		return result;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/lambda_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! LambdaExpression represents either:
-//!  1. A lambda operator that can be used for e.g. mapping an expression to a list
-//!  2. An OperatorExpression with the "->" operator
-//! Lambda expressions are written in the form of "capture -> expr", e.g. "x -> x + 1"
-class LambdaExpression : public ParsedExpression {
-public:
-	LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> rhs);
-
-	unique_ptr<ParsedExpression> lhs;
-	unique_ptr<ParsedExpression> rhs;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
-	hash_t Hash() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/operator_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-//! Represents a built-in operator expression
-class OperatorExpression : public ParsedExpression {
-public:
-	DUCKDB_API explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
-	                                       unique_ptr<ParsedExpression> right = nullptr);
-	DUCKDB_API OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-
-	vector<unique_ptr<ParsedExpression>> children;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		auto op = ExpressionTypeToOperator(entry.type);
-		if (!op.empty()) {
-			// use the operator string to represent the operator
-			D_ASSERT(entry.children.size() == 2);
-			return entry.children[0]->ToString() + " " + op + " " + entry.children[1]->ToString();
-		}
-		switch (entry.type) {
-		case ExpressionType::COMPARE_IN:
-		case ExpressionType::COMPARE_NOT_IN: {
-			string op_type = entry.type == ExpressionType::COMPARE_IN ? " IN " : " NOT IN ";
-			string in_child = entry.children[0]->ToString();
-			string child_list = "(";
-			for (idx_t i = 1; i < entry.children.size(); i++) {
-				if (i > 1) {
-					child_list += ", ";
-				}
-				child_list += entry.children[i]->ToString();
-			}
-			child_list += ")";
-			return "(" + in_child + op_type + child_list + ")";
-		}
-		case ExpressionType::OPERATOR_NOT:
-		case ExpressionType::GROUPING_FUNCTION:
-		case ExpressionType::OPERATOR_COALESCE: {
-			string result = ExpressionTypeToString(entry.type);
-			result += "(";
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
-			result += ")";
-			return result;
-		}
-		case ExpressionType::OPERATOR_IS_NULL:
-			return "(" + entry.children[0]->ToString() + " IS NULL)";
-		case ExpressionType::OPERATOR_IS_NOT_NULL:
-			return "(" + entry.children[0]->ToString() + " IS NOT NULL)";
-		case ExpressionType::ARRAY_EXTRACT:
-			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + "]";
-		case ExpressionType::ARRAY_SLICE:
-			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + ":" +
-			       entry.children[2]->ToString() + "]";
-		case ExpressionType::STRUCT_EXTRACT: {
-			D_ASSERT(entry.children[1]->type == ExpressionType::VALUE_CONSTANT);
-			auto child_string = entry.children[1]->ToString();
-			D_ASSERT(child_string.size() >= 3);
-			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
-			return "(" + entry.children[0]->ToString() + ")." +
-			       KeywordHelper::WriteOptionallyQuoted(child_string.substr(1, child_string.size() - 2));
-		}
-		case ExpressionType::ARRAY_CONSTRUCTOR: {
-			string result = "(ARRAY[";
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
-			result += "])";
-			return result;
-		}
-		default:
-			throw InternalException("Unrecognized operator type");
-		}
-	}
-};
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/parameter_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class ParameterExpression : public ParsedExpression {
-public:
-	ParameterExpression();
-
-	idx_t parameter_nr;
-
-public:
-	bool IsScalar() const override {
-		return true;
-	}
-	bool HasParameter() const override {
-		return true;
-	}
-
-	string ToString() const override;
-
-	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/positional_reference_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class PositionalReferenceExpression : public ParsedExpression {
-public:
-	DUCKDB_API PositionalReferenceExpression(idx_t index);
-
-	idx_t index;
-
-public:
-	bool IsScalar() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
-	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/star_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a * expression in the SELECT clause
-class StarExpression : public ParsedExpression {
-public:
-	StarExpression(string relation_name = string());
-
-	//! The relation name in case of tbl.*, or empty if this is a normal *
-	string relation_name;
-	//! List of columns to exclude from the STAR expression
-	case_insensitive_set_t exclude_list;
-	//! List of columns to replace with another expression
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
-
-public:
-	string ToString() const override;
-
-	static bool Equals(const StarExpression *a, const StarExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/subquery_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//! Represents a subquery
-class SubqueryExpression : public ParsedExpression {
-public:
-	SubqueryExpression();
-
-	//! The actual subquery
-	unique_ptr<SelectStatement> subquery;
-	//! The subquery type
-	SubqueryType subquery_type;
-	//! the child expression to compare with (in case of IN, ANY, ALL operators, empty for EXISTS queries and scalar
-	//! subquery)
-	unique_ptr<ParsedExpression> child;
-	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators), empty otherwise
-	ExpressionType comparison_type;
-
-public:
-	bool HasSubquery() const override {
-		return true;
-	}
-	bool IsScalar() const override {
-		return false;
-	}
-
-	string ToString() const override;
-
-	static bool Equals(const SubqueryExpression *a, const SubqueryExpression *b);
-
-	unique_ptr<ParsedExpression> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
-	explicit CreateAggregateFunctionInfo(AggregateFunction function)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
-		this->name = function.name;
-		functions.AddFunction(std::move(function));
-	}
-
-	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(std::move(set)) {
-		this->name = functions.name;
-		for (auto &func : functions.functions) {
-			func.name = functions.name;
-		}
-	}
-
-	AggregateFunctionSet functions;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
-		CopyProperties(*result);
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_collation_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreateCollationInfo : public CreateInfo {
-	CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p, bool not_required_for_equality_p)
-	    : CreateInfo(CatalogType::COLLATION_ENTRY), function(std::move(function_p)), combinable(combinable_p),
-	      not_required_for_equality(not_required_for_equality_p) {
-		this->name = std::move(name_p);
-	}
-
-	//! The name of the collation
-	string name;
-	//! The collation function to push in case collation is required
-	ScalarFunction function;
-	//! Whether or not the collation can be combined with other collations.
-	bool combinable;
-	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
-	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
-	//! speeds up processing.
-	bool not_required_for_equality;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
-		CopyProperties(*result);
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_index_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/basetableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-//! Represents a TableReference to a base table in the schema
-class BaseTableRef : public TableRef {
-public:
-	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
-	}
-
-	//! Schema name
-	string schema_name;
-	//! Table name
-	string table_name;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a BaseTableRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a BaseTableRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
-};
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct CreateIndexInfo : public CreateInfo {
-	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
-	}
-
-	//! Index Type (e.g., B+-tree, Skip-List, ...)
-	IndexType index_type;
-	//! Name of the Index
-	string index_name;
-	//! If it is an unique index
-	bool unique = false;
-	//! The table to create the index on
-	unique_ptr<BaseTableRef> table;
-	//! Set of expressions to index by
-	vector<unique_ptr<ParsedExpression>> expressions;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateIndexInfo>();
-		CopyProperties(*result);
-		result->index_type = index_type;
-		result->index_name = index_name;
-		result->unique = unique;
-		result->table = unique_ptr_cast<TableRef, BaseTableRef>(table->Copy());
-		for (auto &expr : expressions) {
-			result->expressions.push_back(expr->Copy());
-		}
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_macro_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/macro_function.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-enum class MacroType : uint8_t { VOID_MACRO = 0, TABLE_MACRO = 1, SCALAR_MACRO = 2 };
-
-class MacroFunction {
-public:
-	MacroFunction(MacroType type);
-
-	//! The type
-	MacroType type;
-	//! The positional parameters
-	vector<unique_ptr<ParsedExpression>> parameters;
-	//! The default parameters and their associated values
-	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
-
-public:
-	virtual ~MacroFunction() {
-	}
-
-	void CopyProperties(MacroFunction &other);
-
-	virtual unique_ptr<MacroFunction> Copy() = 0;
-
-	static string ValidateArguments(MacroFunction &macro_function, const string &name,
-	                                FunctionExpression &function_expr,
-	                                vector<unique_ptr<ParsedExpression>> &positionals,
-	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
-
-	virtual string ToSQL(const string &schema, const string &name);
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-struct CreateMacroInfo : public CreateFunctionInfo {
-	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
-	}
-
-	CreateMacroInfo(CatalogType type) : CreateFunctionInfo(type, INVALID_SCHEMA) {
-	}
-
-	unique_ptr<MacroFunction> function;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateMacroInfo>();
-		result->function = function->Copy();
-		result->name = name;
-		CopyProperties(*result);
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_pragma_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreatePragmaFunctionInfo : public CreateFunctionInfo {
-	explicit CreatePragmaFunctionInfo(PragmaFunction function)
-	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY) {
-		functions.push_back(std::move(function));
-		this->name = function.name;
-	}
-	CreatePragmaFunctionInfo(string name, vector<PragmaFunction> functions_)
-	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(std::move(functions_)) {
-		this->name = name;
-		for (auto &function : functions) {
-			function.name = name;
-		}
-	}
-
-	vector<PragmaFunction> functions;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreatePragmaFunctionInfo>(functions[0].name, functions);
-		CopyProperties(*result);
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_schema_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct CreateSchemaInfo : public CreateInfo {
-	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
-	}
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateSchemaInfo>();
-		CopyProperties(*result);
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_type_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreateTypeInfo : public CreateInfo {
-
-	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
-	}
-
-	//! Name of the Type
-	string name;
-	//! Logical Type
-	LogicalType type;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateTypeInfo>();
-		CopyProperties(*result);
-		result->name = name;
-		result->type = type;
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_view_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreateViewInfo : public CreateInfo {
-	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
-	}
-	CreateViewInfo(string schema, string view_name)
-	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
-	}
-
-	//! Table name to insert to
-	string view_name;
-	//! Aliases of the view
-	vector<string> aliases;
-	//! Return types
-	vector<LogicalType> types;
-	//! The SelectStatement of the view
-	unique_ptr<SelectStatement> query;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateViewInfo>(schema, view_name);
-		CopyProperties(*result);
-		result->aliases = aliases;
-		result->types = types;
-		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-		return std::move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/drop_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct DropInfo : public ParseInfo {
-	DropInfo() : schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
-	}
-
-	//! The catalog type to drop
-	CatalogType type;
-	//! Schema name to drop from, if any
-	string schema;
-	//! Element name to drop
-	string name;
-	//! Ignore if the entry does not exist instead of failing
-	bool if_exists = false;
-	//! Cascade drop (drop all dependents instead of throwing an error if there
-	//! are any)
-	bool cascade = false;
-
-public:
-	unique_ptr<DropInfo> Copy() const {
-		auto result = make_unique<DropInfo>();
-		result->type = type;
-		result->schema = schema;
-		result->name = name;
-		result->if_exists = if_exists;
-		result->cascade = cascade;
-		return result;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/export_table_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct ExportedTableData {
-	//! Name of the exported table
-	string table_name;
-
-	//! Name of the schema
-	string schema_name;
-
-	//! Path to be exported
-	string file_path;
-};
-
-struct ExportedTableInfo {
-	TableCatalogEntry *entry;
-	ExportedTableData table_data;
-};
-
-struct BoundExportData : public ParseInfo {
-	std::vector<ExportedTableInfo> data;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/vacuum_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class LoadType { LOAD, INSTALL, FORCE_INSTALL };
-
-struct LoadInfo : public ParseInfo {
-	std::string filename;
-	LoadType load_type;
-
-public:
-	unique_ptr<LoadInfo> Copy() const {
-		auto result = make_unique<LoadInfo>();
-		result->filename = filename;
-		result->load_type = load_type;
-		return result;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/show_select_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct ShowSelectInfo : public ParseInfo {
-	//! Types of projected columns
-	vector<LogicalType> types;
-	//! The QueryNode of select query
-	unique_ptr<QueryNode> query;
-	//! Aliases of projected columns
-	vector<string> aliases;
-	//! Whether or not we are requesting a summary or a describe
-	bool is_summary;
-
-	unique_ptr<ShowSelectInfo> Copy() {
-		auto result = make_unique<ShowSelectInfo>();
-		result->types = types;
-		result->query = query->Copy();
-		result->aliases = aliases;
-		result->is_summary = is_summary;
-		return result;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/transaction_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
-
-struct TransactionInfo : public ParseInfo {
-	explicit TransactionInfo(TransactionType type) : type(type) {
-	}
-
-	//! The type of transaction statement
-	TransactionType type;
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/vacuum_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct VacuumInfo : public ParseInfo {
-	// nothing for now
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/crossproductref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-//! Represents a cross product
-class CrossProductRef : public TableRef {
-public:
-	CrossProductRef() : TableRef(TableReferenceType::CROSS_PRODUCT) {
-	}
-
-	//! The left hand side of the cross product
-	unique_ptr<TableRef> left;
-	//! The right hand side of the cross product
-	unique_ptr<TableRef> right;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a CrossProductRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a CrossProductRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/emptytableref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-//! Represents a cross product
-class EmptyTableRef : public TableRef {
-public:
-	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
-	}
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a DummyTableRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a DummyTableRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/expressionlistref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-//! Represents an expression list as generated by a VALUES statement
-class ExpressionListRef : public TableRef {
-public:
-	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
-	}
-
-	//! Value list, only used for VALUES statement
-	vector<vector<unique_ptr<ParsedExpression>>> values;
-	//! Expected SQL types
-	vector<LogicalType> expected_types;
-	//! The set of expected names
-	vector<string> expected_names;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a ExpressionListRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a ExpressionListRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/joinref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-//! Represents a JOIN between two expressions
-class JoinRef : public TableRef {
-public:
-	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
-	}
-
-	//! The left hand side of the join
-	unique_ptr<TableRef> left;
-	//! The right hand side of the join
-	unique_ptr<TableRef> right;
-	//! The join condition
-	unique_ptr<ParsedExpression> condition;
-	//! The join type
-	JoinType type;
-	//! Natural join
-	bool is_natural;
-	//! The set of USING columns (if any)
-	vector<string> using_columns;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a JoinRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a JoinRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
-};
-} // namespace duckdb
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/subqueryref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-//! Represents a subquery
-class SubqueryRef : public TableRef {
-public:
-	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
-
-	//! The subquery
-	unique_ptr<SelectStatement> subquery;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
-
-public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a SubqueryRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a SubqueryRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
-};
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/table_function_ref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-namespace duckdb {
-//! Represents a Table producing function
-class TableFunctionRef : public TableRef {
-public:
-	DUCKDB_API TableFunctionRef();
-
-	unique_ptr<ParsedExpression> function;
-	vector<string> column_name_alias;
-
-	// if the function takes a subquery as argument its in here
-	unique_ptr<SelectStatement> subquery;
-
-	// External dependencies of this table funcion
-	unique_ptr<ExternalDependency> external_dependency;
-
-public:
-	string ToString() const override;
-
-	bool Equals(const TableRef *other_p) const override;
-
-	unique_ptr<TableRef> Copy() override;
-
-	//! Serializes a blob into a BaseTableRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a BaseTableRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
-};
-} // namespace duckdb
-
diff --git a/velox/external/duckdb/tpch/CMakeLists.txt b/velox/external/duckdb/tpch/CMakeLists.txt
deleted file mode 100644
index 981d46276eaff..0000000000000
--- a/velox/external/duckdb/tpch/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-cmake_minimum_required(VERSION 3.0.0)
-cmake_policy(SET CMP0063 NEW)
-
-project(TPCHExtension)
-
-include_directories(dbgen/include)
-include_directories(include)
-include_directories(..)
-add_subdirectory(dbgen)
-
-add_library(tpch_extension STATIC tpch-extension.cpp)
-target_link_libraries(tpch_extension dbgen)
diff --git a/velox/external/duckdb/tpch/LICENSE b/velox/external/duckdb/tpch/LICENSE
deleted file mode 100644
index 10a906f25237f..0000000000000
--- a/velox/external/duckdb/tpch/LICENSE
+++ /dev/null
@@ -1,320 +0,0 @@
-END USER LICENSE AGREEMENT
-VERSION 2.2
-
-READ THE TERMS AND CONDITIONS OF THIS AGREEMENT ("AGREEMENT") CAREFULLY
-BEFORE INSTALLING OR USING THE ACCOMPANYING SOFTWARE. BY INSTALLING OR
-USING THE SOFTWARE OR RELATED DOCUMENTATION, YOU AGREE TO BE BOUND BY
-THE TERMS OF THIS AGREEMENT. IF YOU DO NOT AGREE TO THE TERMS OF THIS
-AGREEMENT, DO NOT INSTALL OR USE THE SOFTWARE. IF YOU ARE ACCESSING THE
-SOFTWARE ON BEHALF OF YOUR ORGANIZATION, YOU REPRESENT AND WARRANT THAT
-YOU HAVE SUFFICIENT AUTHORITY TO BIND YOUR ORGANIZATION TO THIS
-AGREEMENT.
-
-USE AND RE-EXPORT OF THE SOFTWARE IS SUBJECT TO THE UNITED STATES EXPORT
-CONTROL ADMINISTRATION REGULATIONS. THE SOFTWARE MAY NOT BE USED BY
-UNLICENSED PERSONS OR ENTITIES, AND MAY NOT BE RE- EXPORTED TO ANOTHER
-COUNTRY. SEE EXPORT ASSURANCE (CLAUSE 13) OF THIS LICENSE.
-
-This is a legal agreement between you (or, if you are accessing the
-software on behalf of your organization, your organization) ("You" or
-"User") and the Transaction Processing Performance Council ("TPC"). This
-Agreement states the terms and conditions upon which TPC offers to
-license the Software, including, but not limited to, the source code,
-scripts, executable programs, drivers, libraries and data files
-associated with such programs, and modifications thereof (the
-"Software"), and online, electronic or printed documentation
-("Documentation," together with the Software, "Materials").
-
-LICENSE
-
-1. Definitions
-
-"Executive Summary" shall mean a short summary of a TPC Benchmark Result
-that shows the configuration, primary metrics, performance data, and
-pricing details. The exact requirements for the Executive Summary are
-defined in each TPC Benchmark Standard.
-"Full Disclosure Report (FDR)" shall mean a document that describes The
-TPC Benchmark Result in sufficient detail such that the Result could be
-recreated. The exact requirements for the FDR are defined in each TPC
-Benchmark Standard.
-"TPC Benchmark Result (Result)" shall mean a performance test submitted
-to the TPC attested to meet the requirements of a TPC Benchmark Standard
-at the time of submission. A Result is documented by an Executive
-Summary and, if required, a FDR.
-"TPC Benchmark Standard" shall mean a TPC Benchmark Specification and
-any associated code or binaries approved by the TPC. The various TPC
-Benchmark Standards can be found at
-http://www.tpc.org/information/current_specifications.asp.
-"TPC Policies" shall mean the guiding principles for how the TPC
-conducts its operations and business. The current TPC Policies can be
-found at http://www.tpc.org/information/current_specifications.asp.
-
-2. Ownership. The Materials are licensed, not sold, to You for use only
-under the terms of this Agreement. As between You and TPC (and, to the
-extent applicable, its licensors), TPC retains all rights, title and
-interest to and ownership of the Materials and reserves all rights not
-expressly granted to You.
-
-3. License Grant. Subject to Your compliance in all material respects
-with the terms and conditions of this Agreement, TPC grants You a
-restricted, non-exclusive, revocable license to install and use the
-Materials, but only as expressly permitted herein. You may only use the
-Software on computer systems under Your direct control. You may download
-multiple copies of the Materials and make verbatim copies of the
-original of the Software so long as Your use of such copies complies
-with the terms of this Agreement.
-a. Use by Individual. If You are accessing the Materials as an
-individual, only You (as an individual) may access and use the
-Materials.
-b. Use by Organization. If You are accessing the Materials on behalf of
-Your organization, only You and those within Your organization may use
-the Materials. Your organization must identify a contact person to TPC
-and conduct communications with TPC through that contact person.
-
-4. Restrictions. The following restrictions apply to all use of the
-Materials by You.
-a. General: You may not:
-(1) use, copy, print, modify, adapt, create derivative works from,
-market, deliver, rent, lease, sublicense, make, have made, assign,
-pledge, transfer, sell, offer to sell, import, reproduce, distribute,
-publicly perform, publicly display or otherwise grant rights to the
-Materials, or any copy thereof, in whole or in part, except as expressly
-permitted under this Agreement; or
-(2) use the Materials in any way that does not comply with all
-applicable laws and regulations.
-b. Modification: You may modify the Software.
-c. Public Disclosure: You may not publicly disclose any performance
-results produced while using the Software except in the following
-circumstances:
-(1) as part of a TPC Benchmark Result. For purposes of this Agreement, a
-"TPC Benchmark Result" is a performance test submitted to the TPC,
-documented by a Full Disclosure Report and Executive Summary, claiming
-to meet the requirements of an official TPC Benchmark Standard. You
-agree that TPC Benchmark Results may only be published in accordance
-with the TPC Policies. viewable at http: //www.tpc.org
-(2) as part of an academic or research effort that does not imply or
-state a marketing position
-(3) any other use of the Software, provided that any performance results
-must be clearly identified as not being comparable to TPC Benchmark
-Results unless specifically authorized by TPC.
-
-5. License Modification. Requests for modification of this license shall
-be addressed to info@tpc.org. You may not remove or modify this license
-without permission.
-
-6. Copyright. The Materials are owned by TPC and/or its licensors, and
-are protected by United States copyright laws and international treaty
-provisions. You may not remove the copyright notice from the original or
-any copy of the Materials, and You must apply the notice if You extract
-part of the Materials not bearing a notice.
-
-7. Use of Name. You acknowledge and agree that TPC owns all trademark
-and trade name rights in the names, trademarks and logos used by TPC in
-the Materials. User shall preserve any notices regarding such ownership.
-User may only use such names, trademarks and logos in accordance with
-the usage guidelines specified by the TPC Policies.
-
-8. Merger or Integration. Any portion of the Materials merged into or
-integrated with other software or documentation will continue to be
-subject to the terms and conditions of this Agreement.
-
-9. Limited Grants of Sublicense. You may distribute the Software as
-provided or as modified as permitted under clause 4 b. of this
-Agreement, provided You comply with all of the terms of this Agreement
-and the following conditions:
-
-a. If You distribute any portion of the Software in its original form
-You may do so only under this Agreement by including a complete copy of
-this Agreement with Your distribution, and if You distribute the
-Software in modified form, You may only do so under a license that at a
-minimum provides all of the protections and conditions of use contained
-within this Agreement;
-
-b. You must include on each copy of the Software that You distribute the
-following legend in all caps, at the top of the label and license, and
-in a font not less than 12 point and no less prominent than any other
-printing: "THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.";
-
-c. You must retain all copyright, patent, trademark, and attribution
-notices that are present in the Software; and
-
-d. You may not charge a fee for the distribution of this Software,
-including any modifications permitted under clause 4.b.
-
-10. Term and Termination.
-a. Term. The license granted to You is effective until terminated.
-b. Termination.
-(1) By You. You may terminate this Agreement at any time by returning
-the Materials (including any portions or copies thereof) to TPC or
-providing written notice to the TPC that all copies of the Materials
-within Your custody or control have been deleted or destroyed.
-(2) By TPC. In the event You materially fail to comply with any term or
-condition of this Agreement, and You fail to remedy such non-compliance
-within 30 days after the receipt of notice to that effect, then TPC
-shall have the right to terminate this Agreement immediately upon
-written notice at the end of such 30-day period.
-c. Effect of Termination. Termination of this Agreement in accordance
-with this clause 10 will not terminate the rights of end users
-sublicensed by You pursuant to this Agreement. Moreover, upon
-termination and at TPC's written request, You agree to either (1) return
-the Materials (including any portions or copies thereof) to TPC or (2)
-immediately destroy all copies of the Materials within Your custody or
-control and inform the TPC of the destruction of the Materials. Upon
-termination, TPC may also enforce any rights provided by law. The
-provisions of this Agreement that protect the proprietary rights of TPC
-and its Licensors will continue in force after termination.
-
-11. No Warranty; Materials Provided "As Is". TO THE MAXIMUM EXTENT
-PERMITTED BY APPLICABLE LAW, THE MATERIALS ARE PROVIDED "AS IS" AND WITH
-ALL FAULTS, AND TPC (AND ITS LICENSORS) AND THE AUTHORS AND DEVELOPERS
-OF THE MATERIALS HEREBY DISCLAIM ALL WARRANTIES, REPRESENTATIONS AND
-CONDITIONS, EITHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT
-LIMITED TO, ANY IMPLIED WARRANTIES, DUTIES OR CONDITIONS RELATING TO
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, ACCURACY OR
-COMPLETENESS OF RESPONSES, RESULTS, WORKMANLIKE EFFORT, LACK OF VIRUSES,
-LACK OF NEGLIGENCE, TITLE, QUIET ENJOYMENT, QUIET POSSESSION,
-CORRESPONDENCE TO DESCRIPTION OR NONINFRINGEMENT. USER RECOGNIZES THAT
-THE MATERIALS ARE THE RESULT OF A COOPERATIVE, NON-PROFIT EFFORT AND
-THAT TPC DOES NOT CONDUCT A TYPICAL BUSINESS. USER ACCEPTS THE MATERIALS
-"AS IS" AND WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED.
-
-Without limitation, TPC (and its licensors) do not warrant that the
-functions contained in the Software or Materials will meet Your
-requirements or that the operation of the Software will be
-uninterrupted, error-free or free from malicious code. For purposes of
-this paragraph, "malicious code" means any program code designed to
-contaminate other computer programs or computer data, consume computer
-resources, modify, destroy, record, or transmit data, or in some other
-fashion usurp the normal operation of the computer, computer system, or
-computer network, including viruses, Trojan horses, droppers, worms,
-logic bombs, and the like. TPC (and its licensors) shall not be liable
-for the accuracy of any information provided by TPC or third-party
-technical support personnel, or any damages caused, either directly or
-indirectly, by acts taken or omissions made by You as a result of such
-technical support.
-
-You assume full responsibility for the selection of the Materials to
-achieve Your intended results, and for the installation, use and results
-obtained from the Materials. You also assume the entire risk as it
-applies to the quality and performance of the Materials. Should the
-Materials prove defective, You (and not TPC) assume the entire liability
-of any and all necessary servicing, repair or correction. Some
-countries/states do not allow the exclusion of implied warranties, so
-the above exclusion may not apply to You. TPC (and its licensors)
-further disclaims all warranties of any kind if the Materials were
-customized, repackaged or altered in any way by any party other than TPC
-(or its licensors).
-
-12. Disclaimer of Liability. TPC (and its licensors) assumes no
-liability with respect to the Materials, including liability for
-infringement of intellectual property rights, negligence, or any other
-liability. TPC is not aware of any infringement of copyright or patent
-that may result from its grant of rights to User of the Materials. If
-User receives any notice of infringement, such notice shall be
-immediately communicated to TPC who will have sole discretion to take
-action to evaluate the claim and, if practicable, modify the Materials
-as necessary to avoid infringement. In the event that TPC determines
-that the Materials cannot be modified to avoid such infringement (or any
-other infringement claim communicated to TPC), TPC may terminate this
-Agreement immediately. User shall suspend use of the Materials until
-modifications to avoid claims of infringement have been completed. User
-waives any claim against TPC in the event of such infringement claims by
-others.
-
-13. Export Assurance. Use and re-export of the Materials and related
-technical information is subject to the Export Administration
-Regulations (EAR) of the United States Department of Commerce. User
-hereby agrees that User (a) assumes responsibility for compliance with
-the EAR in its use of the Materials and technical information, and (b)
-will not export, re-export, or otherwise disclose directly or
-indirectly, the Materials, technical data, or any direct product of the
-Materials or technical data in violation of the EAR.
-
-14. Limitation of Remedies And Damages. IN NO EVENT WILL TPC OR ITS
-LICENSORS OR LICENSEE BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL OR
-CONSEQUENTIAL DAMAGES OR FOR ANY LOST PROFITS, LOST SAVINGS, LOST
-REVENUES OR LOST DATA ARISING FROM OR RELATING TO THE MATERIALS OR THIS
-AGREEMENT, EVEN IF TPC OR ITS LICENSORS OR LICENSEE HAVE BEEN ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES. IN NO EVENT WILL TPC'S OR ITS
-LICENSORS' LIABILITY OR DAMAGES TO YOU OR ANY OTHER PERSON EVER EXCEED
-U.S. ONE HUNDRED DOLLARS (US $100), REGARDLESS OF THE FORM OF THE CLAIM.
-IN NO EVENT WILL LICENSEE'S LIABILITY OR DAMAGES TO TPC OR ANY OTHER
-PERSON EVER EXCEED $1,000,000, REGARDLESS OF THE FORM OF THE CLAIM. Some
-countries/states do not allow the limitation or exclusion of liability
-for incidental or consequential damages, so the above limitation or
-exclusion may not apply to You.
-
-15. U.S. Government Restricted Rights. All Software and related
-documentation are provided with restricted rights. Use, duplication or
-disclosure by the U.S. Government is subject to restrictions as set
-forth in subdivision (b)(3)(ii) of the Rights in Technical Data and
-Computer Software Clause at 252.227-7013. If You are using the Software
-outside of the United States, You will comply with the applicable local
-laws of Your country, U.S. export control law, and the English version
-of this Agreement.
-
-16. Contractor/Manufacturer. The Contractor/Manufacturer for the
-Software is:
-
-Transaction Processing Performance Council
-572B Ruger Street, P.O. Box 29920
-San Francisco, CA 94129
-
-17. General. This Agreement is binding on You as well as Your employees,
-employers, contractors and agents, and on any successors and assignees.
-This Agreement is governed by the laws of the State of California
-(except to the extent federal law governs copyrights and trademarks)
-without respect to any provisions of California law that would cause
-application of the law of another state or country. The parties agree
-that the United Nations Convention on Contracts for the International
-Sale of Goods will not govern this Agreement. This Agreement is the
-entire agreement between us regarding the subject matter hereof and
-supersedes any other understandings or agreements with respect to the
-Materials or the subject matter hereof. If any provision of this
-Agreement is deemed invalid or unenforceable by any court having
-jurisdiction, that particular provision will be deemed modified to the
-extent necessary to make the provision valid and enforceable, and the
-remaining provisions will remain in full force and effect.
-
-SPECIAL PROVISIONS APPLICABLE TO THE EUROPEAN UNION
-
-If You acquired the Materials in the European Union (EU), the following
-provisions also apply to You. If there is any inconsistency between the
-terms of the Software License Agreement set out earlier and the
-following provisions, the following provisions shall take precedence.
-
-1. Distribution. You may sublicense modifications of the Software
-covered in this Agreement if they meet the requirements of clause 9
-above.
-
-2. Limited Warranty. EXCEPT AS STATED EARLIER IN THIS AGREEMENT, AND AS
-PROVIDED UNDER THE HEADING "STATUTORY RIGHTS", THE SOFTWARE IS PROVIDED
-AS-IS WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
-INCLUDING, BUT NOT LIMITED TO, ANY IMPLIED WARRANTIES, NONINFRINGEMENT,
-OR CONDITIONS OF MERCHANTABILITY, QUALITY AND FITNESS FOR A PARTICULAR
-PURPOSE.
-
-3. Limitation of Remedy and Damages. THE LIMITATIONS OF REMEDIES AND
-DAMAGES IN THE SOFTWARE LICENSE AGREEMENT SHALL NOT APPLY TO PERSONAL
-INJURY (INCLUDING DEATH) TO ANY PERSON CAUSED BY TPC'S NEGLIGENCE AND
-ARE SUBJECT TO THE PROVISION SET OUT UNDER THE HEADING "STATUTORY
-RIGHTS".
-
-4. Statutory Rights: Irish law provides that certain conditions and
-warranties may be implied in contracts for the sale of goods and in
-contracts for the supply of services. Such conditions and warranties are
-hereby excluded, to the extent such exclusion, in the context of this
-transaction, is lawful under Irish law. Conversely, such conditions and
-warranties, insofar as they may not be lawfully excluded, shall apply.
-Accordingly nothing in this Agreement shall prejudice any rights that
-You may enjoy by virtue of Sections 12, 13, 14 or 15 of the Irish Sale
-of Goods Act 1893 (as amended).
-
-5. General. This Agreement is governed by the laws of the Republic of
-Ireland. The local language version of this agreement shall apply to
-Materials acquired in the EU. This Agreement is the entire agreement
-between us with respect to the subject matter hereof and You agree that
-TPC will not have any liability for any untrue statement or
-representation made by it, its agents or anyone else (whether innocently
-or negligently) upon which You relied upon entering this Agreement,
-unless such untrue statement or representation was made fraudulently.
\ No newline at end of file
diff --git a/velox/external/duckdb/tpch/dbgen/CMakeLists.txt b/velox/external/duckdb/tpch/dbgen/CMakeLists.txt
deleted file mode 100644
index 37b6c36c1a4cd..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/CMakeLists.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-cmake_minimum_required(VERSION 3.0.0)
-cmake_policy(SET CMP0063 NEW)
-
-project(dbgen CXX C)
-
-include_directories(include)
-
-add_definitions(-DDBNAME=dss -DMAC -DORACLE -DTPCH)
-
-add_library(
-  dbgen STATIC
-  dbgen.cpp
-  dbgen_gunk.cpp
-  bm_utils.cpp
-  build.cpp
-  permute.cpp
-  rnd.cpp
-  rng64.cpp
-  speed_seed.cpp
-  text.cpp)
-
-# Suppress warnings when compiling dbgen.
-target_compile_options(dbgen PRIVATE -w)
diff --git a/velox/external/duckdb/tpch/dbgen/bm_utils.cpp b/velox/external/duckdb/tpch/dbgen/bm_utils.cpp
deleted file mode 100644
index 80c1575a3df3a..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/bm_utils.cpp
+++ /dev/null
@@ -1,454 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-/*
- *
- * Various routines that handle distributions, value selections and
- * seed value management for the DSS benchmark. Current functions:
- * tpch_env_config -- set config vars with optional environment override
- * yes_no -- ask simple yes/no question and return boolean result
- * tpch_a_rnd(min, max) -- random alphanumeric within length range
- * pick_str(size, set) -- select a string from the set of size
- * read_dist(file, name, distribution *) -- read named dist from file
- * tbl_open(path, mode) -- std fopen with lifenoise
- * julian(date) -- julian date correction
- * rowcnt(tbl) -- proper scaling of given table
- * e_str(set, min, max) -- build an embedded str
- * agg_str() -- build a string from the named set
- * dsscasecmp() -- version of strcasecmp()
- * dssncasecmp() -- version of strncasecmp()
- * getopt()
- * set_state() -- initialize the RNG
- */
-
-#include "dbgen/config.h"
-#include "dbgen/dss.h"
-
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <time.h>
-#ifdef HP
-#include <strings.h>
-#endif /* HP */
-#include <ctype.h>
-#include <math.h>
-#ifndef _POSIX_SOURCE
-//#include <malloc.h>
-#endif /* POSIX_SOURCE */
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-/* Lines added by Chuck McDevitt for WIN32 support */
-#ifdef WIN32
-#ifndef _POSIX_
-#include <io.h>
-#ifndef S_ISREG
-#define S_ISREG(m) (((m)&_S_IFMT) == _S_IFREG)
-#define S_ISFIFO(m) (((m)&_S_IFMT) == _S_IFIFO)
-#endif
-#endif
-#ifndef stat
-#define stat _stat
-#endif
-#ifndef fdopen
-#define fdopen _fdopen
-#endif
-#ifndef open
-#define open _open
-#endif
-#ifndef O_RDONLY
-#define O_RDONLY _O_RDONLY
-#endif
-#ifndef O_WRONLY
-#define O_WRONLY _O_WRONLY
-#endif
-#ifndef O_CREAT
-#define O_CREAT _O_CREAT
-#endif
-#endif
-/* End of lines added by Chuck McDevitt for WIN32 support */
-#include "dbgen/dsstypes.h"
-
-static char alpha_num[65] = "0123456789abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ,";
-
-#if defined(__STDC__) || defined(__cplusplus)
-#define PROTO(s) s
-#else
-#define PROTO(s) ()
-#endif
-
-#ifndef WIN32
-char *getenv PROTO((const char *name));
-#endif
-void usage();
-void permute_dist(distribution *d, seed_t *seed);
-
-/*
- * tpch_env_config: look for a environmental variable setting and return its
- * value; otherwise return the default supplied
- */
-const char *tpch_env_config(const char *var, const char *dflt) {
-	static char *evar;
-
-	if ((evar = getenv(var)) != NULL)
-		return (evar);
-	else
-		return (dflt);
-}
-
-/*
- * return the answer to a yes/no question as a boolean
- */
-long yes_no(char *prompt) {
-	char reply[128];
-	(void)prompt;
-#ifdef WIN32
-/* Disable warning about conditional expression is constant */
-#pragma warning(disable : 4127)
-#endif
-
-	while (1) {
-#ifdef WIN32
-#pragma warning(default : 4127)
-#endif
-		printf("%s [Y/N]: ", prompt);
-		fgets(reply, 128, stdin);
-		switch (*reply) {
-		case 'y':
-		case 'Y':
-			return (1);
-		case 'n':
-		case 'N':
-			return (0);
-		default:
-			printf("Please answer 'yes' or 'no'.\n");
-		}
-	}
-}
-
-/*
- * generate a random string with length randomly selected in [min, max]
- * and using the characters in alphanum (currently includes a space
- * and comma)
- */
-void tpch_a_rnd(int min, int max, seed_t *seed, char *dest) {
-	DSS_HUGE i, len, char_int;
-
-	RANDOM(len, min, max, seed);
-	for (i = 0; i < len; i++) {
-		if (i % 5 == 0)
-			RANDOM(char_int, 0, MAX_LONG, seed);
-		*(dest + i) = alpha_num[char_int & 077];
-		char_int >>= 6;
-	}
-	*(dest + len) = '\0';
-	return;
-}
-
-/*
- * embed a randomly selected member of distribution d in alpha-numeric
- * noise of a length rendomly selected between min and max at a random
- * position
- */
-void e_str(distribution *d, int min, int max, seed_t *seed, char *dest) {
-	char strtmp[MAXAGG_LEN + 1];
-	DSS_HUGE loc;
-	int len;
-
-	tpch_a_rnd(min, max, seed, dest);
-	pick_str(d, seed, strtmp);
-	len = (int)strlen(strtmp);
-	RANDOM(loc, 0, ((int)strlen(dest) - 1 - len), seed);
-	memcpy(dest + loc, strtmp, sizeof(char) * len);
-
-	return;
-}
-
-/*
- * return the string associate with the LSB of a uniformly selected
- * long in [1, max] where max is determined by the distribution
- * being queried
- */
-int pick_str(distribution *s, seed_t *seed, char *target) {
-	long i = 0;
-	DSS_HUGE j;
-
-	RANDOM(j, 1, s->list[s->count - 1].weight, seed);
-	while (s->list[i].weight < j)
-		i++;
-	strcpy(target, s->list[i].text);
-	return (i);
-}
-
-/*
- * unjulian (long date) -- return(date - STARTDATE)
- */
-long unjulian(long date) {
-	int i;
-	long res = 0;
-
-	for (i = STARTDATE / 1000; i < date / 1000; i++)
-		res += 365 + LEAP(i);
-	res += date % 1000 - 1;
-
-	return (res);
-}
-
-long julian(long date) {
-	long offset;
-	long result;
-	long yr;
-	long yend;
-
-	offset = date - STARTDATE;
-	result = STARTDATE;
-
-#ifdef WIN32
-/* Disable warning about conditional expression is constant */
-#pragma warning(disable : 4127)
-#endif
-
-	while (1) {
-#ifdef WIN32
-#pragma warning(default : 4127)
-#endif
-		yr = result / 1000;
-		yend = yr * 1000 + 365 + LEAP(yr);
-		if (result + offset > yend) /* overflow into next year */
-		{
-			offset -= yend - result + 1;
-			result += 1000;
-			continue;
-		} else
-			break;
-	}
-	return (result + offset);
-}
-
-#include "dbgen/dists_dss.h"
-
-static char read_line_into_buffer(char *buffer, size_t bufsiz, const char **src) {
-	size_t count = 0;
-	while (**src && count < bufsiz - 1) {
-		buffer[count++] = **src;
-		if (**src == '\n') {
-			(*src)++;
-			break;
-		}
-		(*src)++;
-	}
-	buffer[count] = '\0';
-	return **src;
-}
-
-/*
- * load a distribution from a flat file into the target structure;
- * should be rewritten to allow multiple dists in a file
- */
-void read_dist(const char *path, const char *name, distribution *target) {
-	const char *src = dists_dss;
-	char line[256], token[256], *c;
-	long weight, count = 0, name_set = 0;
-
-	while (read_line_into_buffer(line, sizeof(line), &src)) {
-		if ((c = strchr(line, '\n')) != NULL)
-			*c = '\0';
-		if ((c = strchr(line, '#')) != NULL)
-			*c = '\0';
-		if (*line == '\0')
-			continue;
-
-		if (!name_set) {
-			if (dsscasecmp(strtok(line, "\n\t "), "BEGIN"))
-				continue;
-			if (dsscasecmp(strtok(NULL, "\n\t "), name))
-				continue;
-			name_set = 1;
-			continue;
-		} else {
-			if (!dssncasecmp(line, "END", 3)) {
-				return;
-			}
-		}
-
-		if (sscanf(line, "%[^|]|%ld", token, &weight) != 2)
-			continue;
-
-		if (!dsscasecmp(token, "count")) {
-			target->count = weight;
-			target->list = (set_member *)malloc((size_t)(weight * sizeof(set_member)));
-			MALLOC_CHECK(target->list);
-			target->max = 0;
-			continue;
-		}
-		target->list[count].text = (char *)malloc((size_t)((int)strlen(token) + 1));
-		MALLOC_CHECK(target->list[count].text);
-		strcpy(target->list[count].text, token);
-		target->max += weight;
-		target->list[count].weight = target->max;
-
-		count += 1;
-	} /* while fgets() */
-
-	if (count != target->count) {
-		fprintf(stderr, "Read error on dist '%s'\n", name);
-		exit(1);
-	}
-	target->permute = (long *)NULL;
-	return;
-}
-
-/*
- * agg_str(set, count) build an aggregated string from count unique
- * selections taken from set
- */
-void agg_str(distribution *set, long count, seed_t *seed, char *dest) {
-	distribution *d;
-	int i;
-
-	d = set;
-	*dest = '\0';
-
-	permute_dist(d, seed);
-	for (i = 0; i < count; i++) {
-		strcat(dest, DIST_MEMBER(set, DIST_PERMUTE(d, i)));
-		strcat(dest, " ");
-	}
-	*(dest + (int)strlen(dest) - 1) = '\0';
-
-	return;
-}
-
-long dssncasecmp(const char *s1, const char *s2, int n) {
-	for (; n > 0; ++s1, ++s2, --n)
-		if (tolower(*s1) != tolower(*s2))
-			return ((tolower(*s1) < tolower(*s2)) ? -1 : 1);
-		else if (*s1 == '\0')
-			return (0);
-	return (0);
-}
-
-long dsscasecmp(const char *s1, const char *s2) {
-	for (; tolower(*s1) == tolower(*s2); ++s1, ++s2)
-		if (*s1 == '\0')
-			return (0);
-	return ((tolower(*s1) < tolower(*s2)) ? -1 : 1);
-}
-
-#ifndef STDLIB_HAS_GETOPT
-int optind = 0;
-int opterr = 0;
-char *optarg = NULL;
-
-int getopt(int ac, char **av, char *opt) {
-	static char *nextchar = NULL;
-	char *cp;
-	char hold;
-
-	if (optarg == NULL) {
-		optarg = (char *)malloc(BUFSIZ);
-		MALLOC_CHECK(optarg);
-	}
-
-	if (!nextchar || *nextchar == '\0') {
-		optind++;
-		if (optind == ac)
-			return (-1);
-		nextchar = av[optind];
-		if (*nextchar != '-')
-			return (-1);
-		nextchar += 1;
-	}
-
-	if (nextchar && *nextchar == '-') /* -- termination */
-	{
-		optind++;
-		return (-1);
-	} else /* found an option */
-	{
-		cp = strchr(opt, *nextchar);
-		nextchar += 1;
-		if (cp == NULL) /* not defined for this run */
-			return ('?');
-		if (*(cp + 1) == ':') /* option takes an argument */
-		{
-			if (*nextchar) {
-				hold = *cp;
-				cp = optarg;
-				while (*nextchar)
-					*cp++ = *nextchar++;
-				*cp = '\0';
-				*cp = hold;
-			} else /* white space separated, use next arg */
-			{
-				if (++optind == ac)
-					return ('?');
-				strcpy(optarg, av[optind]);
-			}
-			nextchar = NULL;
-		}
-		return (*cp);
-	}
-}
-#endif /* STDLIB_HAS_GETOPT */
-
-char **mk_ascdate(void) {
-	char **m;
-	dss_time_t t;
-	DSS_HUGE i;
-
-	m = (char **)malloc((size_t)(TOTDATE * sizeof(char *)));
-	MALLOC_CHECK(m);
-	for (i = 0; i < TOTDATE; i++) {
-		mk_time(i + 1, &t);
-		m[i] = strdup(t.alpha);
-	}
-
-	return (m);
-}
-
-/*
- * set_state() -- initialize the RNG so that
- * appropriate data sets can be generated.
- * For each table that is to be generated, calculate the number of rows/child,
- * and send that to the seed generation routine in speed_seed.c. Note: assumes
- * that tables are completely independent. Returns the number of rows to be
- * generated by the named step.
- */
-DSS_HUGE
-set_state(int table, long sf, long procs, long step, DSS_HUGE *extra_rows, DBGenContext *ctx) {
-	int i;
-	DSS_HUGE rowcount, result;
-
-	if (sf == 0 || step == 0)
-		return (0);
-
-	rowcount = ctx->tdefs[table].base;
-	rowcount *= sf;
-	*extra_rows = rowcount % procs;
-	rowcount /= procs;
-	result = rowcount;
-	for (i = 0; i < step - 1; i++) {
-		if (table == LINE) /* special case for shared seeds */
-			ctx->tdefs[table].gen_seed(1, rowcount);
-		else
-			ctx->tdefs[table].gen_seed(0, rowcount);
-		/* need to set seeds of child in case there's a dependency */
-		/* NOTE: this assumes that the parent and child have the same base row
-		 * count */
-		if (ctx->tdefs[table].child != NONE)
-			ctx->tdefs[ctx->tdefs[table].child].gen_seed(0, rowcount);
-	}
-	if (step > procs) /* moving to the end to generate updates */
-		ctx->tdefs[table].gen_seed(0, *extra_rows);
-
-	return (result);
-}
diff --git a/velox/external/duckdb/tpch/dbgen/build.cpp b/velox/external/duckdb/tpch/dbgen/build.cpp
deleted file mode 100644
index 1b2331887cdbc..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/build.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-#include <stdio.h>
-#include <string.h>
-#ifndef VMS
-#include <sys/types.h>
-#endif
-#if defined(SUN)
-#include <unistd.h>
-#endif
-#include "dbgen/dss.h"
-#include "dbgen/dsstypes.h"
-
-#include <math.h>
-#include "dbgen/rng64.h"
-
-#define LEAP_ADJ(yr, mnth) ((LEAP(yr) && (mnth) >= 2) ? 1 : 0)
-#define JDAY_BASE 8035        /* start from 1/1/70 a la unix */
-#define JMNTH_BASE (-70 * 12) /* start from 1/1/70 a la unix */
-#define JDAY(date) ((date)-STARTDATE + JDAY_BASE + 1)
-#define PART_SUPP_BRIDGE(tgt, p, s)                                                                                    \
-	{                                                                                                                  \
-		DSS_HUGE tot_scnt = ctx->tdefs[SUPP].base * ctx->scale_factor;                                                       \
-		tgt = (p + s * (tot_scnt / SUPP_PER_PART + (long)((p - 1) / tot_scnt))) % tot_scnt + 1;                        \
-	}
-#define V_STR(avg, seed, tgt) tpch_a_rnd((int)(avg * V_STR_LOW), (int)(avg * V_STR_HGH), seed, tgt)
-#define TEXT(avg, seed, tgt) dbg_text(tgt, (int)(avg * V_STR_LOW), (int)(avg * V_STR_HGH), seed)
-static void gen_phone PROTO((DSS_HUGE ind, char *target, seed_t *seed));
-
-DSS_HUGE
-rpb_routine(DSS_HUGE p) {
-	DSS_HUGE price;
-
-	price = 90000;
-	price += (p / 10) % 20001; /* limit contribution to $200 */
-	price += (p % 1000) * 100;
-
-	return (price);
-}
-
-static void gen_phone(DSS_HUGE ind, char *target, seed_t *seed) {
-	DSS_HUGE acode, exchg, number;
-
-	RANDOM(acode, 100, 999, seed);
-	RANDOM(exchg, 100, 999, seed);
-	RANDOM(number, 1000, 9999, seed);
-
-	sprintf(target, "%02d", (int)(10 + (ind % NATIONS_MAX)));
-	sprintf(target + 3, "%03d", (int)acode);
-	sprintf(target + 7, "%03d", (int)exchg);
-	sprintf(target + 11, "%04d", (int)number);
-	target[2] = target[6] = target[10] = '-';
-
-	return;
-}
-
-long mk_cust(DSS_HUGE n_cust, customer_t *c, DBGenContext *ctx) {
-	DSS_HUGE i;
-	static int bInit = 0;
-	static char szFormat[100];
-
-	if (!bInit) {
-		sprintf(szFormat, C_NAME_FMT, 9, &HUGE_FORMAT[1]);
-		bInit = 1;
-	}
-	c->custkey = n_cust;
-	sprintf(c->name, szFormat, C_NAME_TAG, n_cust);
-	V_STR(C_ADDR_LEN, &ctx->Seed[C_ADDR_SD], c->address);
-	c->alen = (int)strlen(c->address);
-	RANDOM(i, 0, (nations.count - 1), &ctx->Seed[C_NTRG_SD]);
-	c->nation_code = i;
-	gen_phone(i, c->phone, &ctx->Seed[C_PHNE_SD]);
-	RANDOM(c->acctbal, C_ABAL_MIN, C_ABAL_MAX, &ctx->Seed[C_ABAL_SD]);
-	pick_str(&c_mseg_set, &ctx->Seed[C_MSEG_SD], c->mktsegment);
-	TEXT(C_CMNT_LEN, &ctx->Seed[C_CMNT_SD], c->comment);
-	c->clen = (int)strlen(c->comment);
-
-	return (0);
-}
-
-/*
- * generate the numbered order and its associated lineitems
- */
-void mk_sparse(DSS_HUGE i, DSS_HUGE *ok, long seq) {
-	long low_bits;
-
-	*ok = i;
-	low_bits = (long)(i & ((1 << SPARSE_KEEP) - 1));
-	*ok = *ok >> SPARSE_KEEP;
-	*ok = *ok << SPARSE_BITS;
-	*ok += seq;
-	*ok = *ok << SPARSE_KEEP;
-	*ok += low_bits;
-
-	return;
-}
-
-long mk_order(DSS_HUGE index, order_t *o, DBGenContext *ctx, long upd_num) {
-	DSS_HUGE lcnt;
-	DSS_HUGE rprice;
-	long ocnt;
-	DSS_HUGE tmp_date;
-	DSS_HUGE s_date;
-	DSS_HUGE r_date;
-	DSS_HUGE c_date;
-	DSS_HUGE clk_num;
-	DSS_HUGE supp_num;
-	static char **asc_date = NULL;
-	char tmp_str[2];
-	char **mk_ascdate PROTO((void));
-	int delta = 1;
-	static int bInit = 0;
-	static char szFormat[100];
-
-	if (!bInit) {
-		sprintf(szFormat, O_CLRK_FMT, 9, &HUGE_FORMAT[1]);
-		bInit = 1;
-	}
-	if (asc_date == NULL)
-		asc_date = mk_ascdate();
-	mk_sparse(index, &o->okey, (upd_num == 0) ? 0 : 1 + upd_num / (10000 / UPD_PCT));
-	if (ctx->scale_factor >= 30000)
-		RANDOM64(o->custkey, O_CKEY_MIN, O_CKEY_MAX, &ctx->Seed[O_CKEY_SD]);
-	else
-		RANDOM(o->custkey, O_CKEY_MIN, O_CKEY_MAX, &ctx->Seed[O_CKEY_SD]);
-	while (o->custkey % CUST_MORTALITY == 0) {
-		o->custkey += delta;
-		o->custkey = MIN(o->custkey, O_CKEY_MAX);
-		delta *= -1;
-	}
-
-	RANDOM(tmp_date, O_ODATE_MIN, O_ODATE_MAX, &ctx->Seed[O_ODATE_SD]);
-	strcpy(o->odate, asc_date[tmp_date - STARTDATE]);
-
-	pick_str(&o_priority_set, &ctx->Seed[O_PRIO_SD], o->opriority);
-	RANDOM(clk_num, 1, MAX((ctx->scale_factor * O_CLRK_SCL), O_CLRK_SCL), &ctx->Seed[O_CLRK_SD]);
-	sprintf(o->clerk, szFormat, O_CLRK_TAG, clk_num);
-	TEXT(O_CMNT_LEN, &ctx->Seed[O_CMNT_SD], o->comment);
-	o->clen = (int)strlen(o->comment);
-#ifdef DEBUG
-	if (o->clen > O_CMNT_MAX)
-		fprintf(stderr, "comment error: O%d\n", index);
-#endif /* DEBUG */
-	o->spriority = 0;
-
-	o->totalprice = 0;
-	o->orderstatus = 'O';
-	ocnt = 0;
-
-	RANDOM(o->lines, O_LCNT_MIN, O_LCNT_MAX, &ctx->Seed[O_LCNT_SD]);
-	for (lcnt = 0; lcnt < o->lines; lcnt++) {
-		o->l[lcnt].okey = o->okey;
-		;
-		o->l[lcnt].lcnt = lcnt + 1;
-		RANDOM(o->l[lcnt].quantity, L_QTY_MIN, L_QTY_MAX, &ctx->Seed[L_QTY_SD]);
-		RANDOM(o->l[lcnt].discount, L_DCNT_MIN, L_DCNT_MAX, &ctx->Seed[L_DCNT_SD]);
-		RANDOM(o->l[lcnt].tax, L_TAX_MIN, L_TAX_MAX, &ctx->Seed[L_TAX_SD]);
-		pick_str(&l_instruct_set, &ctx->Seed[L_SHIP_SD], o->l[lcnt].shipinstruct);
-		pick_str(&l_smode_set, &ctx->Seed[L_SMODE_SD], o->l[lcnt].shipmode);
-		TEXT(L_CMNT_LEN, &ctx->Seed[L_CMNT_SD], o->l[lcnt].comment);
-		o->l[lcnt].clen = (int)strlen(o->l[lcnt].comment);
-		if (ctx->scale_factor >= 30000)
-			RANDOM64(o->l[lcnt].partkey, L_PKEY_MIN, L_PKEY_MAX, &ctx->Seed[L_PKEY_SD]);
-		else
-			RANDOM(o->l[lcnt].partkey, L_PKEY_MIN, L_PKEY_MAX, &ctx->Seed[L_PKEY_SD]);
-		rprice = rpb_routine(o->l[lcnt].partkey);
-		RANDOM(supp_num, 0, 3, &ctx->Seed[L_SKEY_SD]);
-		PART_SUPP_BRIDGE(o->l[lcnt].suppkey, o->l[lcnt].partkey, supp_num);
-		o->l[lcnt].eprice = rprice * o->l[lcnt].quantity;
-
-		o->totalprice += ((o->l[lcnt].eprice * ((long)100 - o->l[lcnt].discount)) / (long)PENNIES) *
-		                 ((long)100 + o->l[lcnt].tax) / (long)PENNIES;
-
-		RANDOM(s_date, L_SDTE_MIN, L_SDTE_MAX, &ctx->Seed[L_SDTE_SD]);
-		s_date += tmp_date;
-		RANDOM(c_date, L_CDTE_MIN, L_CDTE_MAX, &ctx->Seed[L_CDTE_SD]);
-		c_date += tmp_date;
-		RANDOM(r_date, L_RDTE_MIN, L_RDTE_MAX, &ctx->Seed[L_RDTE_SD]);
-		r_date += s_date;
-
-		strcpy(o->l[lcnt].sdate, asc_date[s_date - STARTDATE]);
-		strcpy(o->l[lcnt].cdate, asc_date[c_date - STARTDATE]);
-		strcpy(o->l[lcnt].rdate, asc_date[r_date - STARTDATE]);
-
-		if (julian(r_date) <= CURRENTDATE) {
-			pick_str(&l_rflag_set, &ctx->Seed[L_RFLG_SD], tmp_str);
-			o->l[lcnt].rflag[0] = *tmp_str;
-		} else
-			o->l[lcnt].rflag[0] = 'N';
-
-		if (julian(s_date) <= CURRENTDATE) {
-			ocnt++;
-			o->l[lcnt].lstatus[0] = 'F';
-		} else
-			o->l[lcnt].lstatus[0] = 'O';
-	}
-
-	if (ocnt > 0)
-		o->orderstatus = 'P';
-	if (ocnt == o->lines)
-		o->orderstatus = 'F';
-
-	return (0);
-}
-
-long mk_part(DSS_HUGE index, part_t *p, DBGenContext *ctx) {
-	DSS_HUGE temp;
-	long snum;
-	DSS_HUGE brnd;
-	static int bInit = 0;
-	static char szFormat[100];
-	static char szBrandFormat[100];
-
-	if (!bInit) {
-		sprintf(szFormat, P_MFG_FMT, 1, &HUGE_FORMAT[1]);
-		sprintf(szBrandFormat, P_BRND_FMT, 2, &HUGE_FORMAT[1]);
-		bInit = 1;
-	}
-	p->partkey = index;
-	agg_str(&colors, (long)P_NAME_SCL, &ctx->Seed[P_NAME_SD], p->name);
-	RANDOM(temp, P_MFG_MIN, P_MFG_MAX, &ctx->Seed[P_MFG_SD]);
-	sprintf(p->mfgr, szFormat, P_MFG_TAG, temp);
-	RANDOM(brnd, P_BRND_MIN, P_BRND_MAX, &ctx->Seed[P_BRND_SD]);
-	sprintf(p->brand, szBrandFormat, P_BRND_TAG, (temp * 10 + brnd));
-	p->tlen = pick_str(&p_types_set, &ctx->Seed[P_TYPE_SD], p->type);
-	p->tlen = (int)strlen(p_types_set.list[p->tlen].text);
-	RANDOM(p->size, P_SIZE_MIN, P_SIZE_MAX, &ctx->Seed[P_SIZE_SD]);
-	pick_str(&p_cntr_set, &ctx->Seed[P_CNTR_SD], p->container);
-	p->retailprice = rpb_routine(index);
-	TEXT(P_CMNT_LEN, &ctx->Seed[P_CMNT_SD], p->comment);
-	p->clen = (int)strlen(p->comment);
-
-	for (snum = 0; snum < SUPP_PER_PART; snum++) {
-		p->s[snum].partkey = p->partkey;
-		PART_SUPP_BRIDGE(p->s[snum].suppkey, index, snum);
-		RANDOM(p->s[snum].qty, PS_QTY_MIN, PS_QTY_MAX, &ctx->Seed[PS_QTY_SD]);
-		RANDOM(p->s[snum].scost, PS_SCST_MIN, PS_SCST_MAX, &ctx->Seed[PS_SCST_SD]);
-		TEXT(PS_CMNT_LEN, &ctx->Seed[PS_CMNT_SD], p->s[snum].comment);
-		p->s[snum].clen = (int)strlen(p->s[snum].comment);
-	}
-	return (0);
-}
-
-long mk_supp(DSS_HUGE index, supplier_t *s, DBGenContext *ctx) {
-	DSS_HUGE i, bad_press, noise, offset, type;
-	static int bInit = 0;
-	static char szFormat[100];
-
-	if (!bInit) {
-		sprintf(szFormat, S_NAME_FMT, 9, &HUGE_FORMAT[1]);
-		bInit = 1;
-	}
-	s->suppkey = index;
-	sprintf(s->name, szFormat, S_NAME_TAG, index);
-	V_STR(S_ADDR_LEN, &ctx->Seed[S_ADDR_SD], s->address);
-	s->alen = (int)strlen(s->address);
-	RANDOM(i, 0, nations.count - 1, &ctx->Seed[S_NTRG_SD]);
-	s->nation_code = i;
-	gen_phone(i, s->phone, &ctx->Seed[S_PHNE_SD]);
-	RANDOM(s->acctbal, S_ABAL_MIN, S_ABAL_MAX, &ctx->Seed[S_ABAL_SD]);
-
-	TEXT(S_CMNT_LEN, &ctx->Seed[S_CMNT_SD], s->comment);
-	s->clen = (int)strlen(s->comment);
-	/*
-	 * these calls should really move inside the if stmt below, but this
-	 * will simplify seedless parallel load
-	 */
-	RANDOM(bad_press, 1, 10000, &ctx->Seed[BBB_CMNT_SD]);
-	RANDOM(type, 0, 100, &ctx->Seed[BBB_TYPE_SD]);
-	RANDOM(noise, 0, (s->clen - BBB_CMNT_LEN), &ctx->Seed[BBB_JNK_SD]);
-	RANDOM(offset, 0, (s->clen - (BBB_CMNT_LEN + noise)), &ctx->Seed[BBB_OFFSET_SD]);
-	if (bad_press <= S_CMNT_BBB) {
-		type = (type < BBB_DEADBEATS) ? 0 : 1;
-		memcpy(s->comment + offset, BBB_BASE, BBB_BASE_LEN);
-		if (type == 0)
-			memcpy(s->comment + BBB_BASE_LEN + offset + noise, BBB_COMPLAIN, BBB_TYPE_LEN);
-		else
-			memcpy(s->comment + BBB_BASE_LEN + offset + noise, BBB_COMMEND, BBB_TYPE_LEN);
-	}
-	return (0);
-}
-
-struct {
-	char *mdes;
-	long days;
-	long dcnt;
-} months[] =
-
-    {{NULL, 0, 0},     {"JAN", 31, 31},  {"FEB", 28, 59},  {"MAR", 31, 90},  {"APR", 30, 120},
-     {"MAY", 31, 151}, {"JUN", 30, 181}, {"JUL", 31, 212}, {"AUG", 31, 243}, {"SEP", 30, 273},
-     {"OCT", 31, 304}, {"NOV", 30, 334}, {"DEC", 31, 365}};
-
-long mk_time(DSS_HUGE index, dss_time_t *t) {
-	long m = 0;
-	long y;
-	long d;
-
-	t->timekey = index + JDAY_BASE;
-	y = julian(index + STARTDATE - 1) / 1000;
-	d = julian(index + STARTDATE - 1) % 1000;
-	while (d > months[m].dcnt + LEAP_ADJ(y, m))
-		m++;
-	PR_DATE(t->alpha, y, m, d - months[m - 1].dcnt - ((LEAP(y) && m > 2) ? 1 : 0));
-	t->year = 1900 + y;
-	t->month = m + 12 * y + JMNTH_BASE;
-	t->week = (d + T_START_DAY - 1) / 7 + 1;
-	t->day = d - months[m - 1].dcnt - LEAP_ADJ(y, m - 1);
-
-	return (0);
-}
-
-int mk_nation(DSS_HUGE index, code_t *c, DBGenContext *ctx) {
-	c->code = index - 1;
-	c->text = nations.list[index - 1].text;
-	c->join = nations.list[index - 1].weight;
-	TEXT(N_CMNT_LEN, &ctx->Seed[N_CMNT_SD], c->comment);
-	c->clen = (int)strlen(c->comment);
-	return (0);
-}
-
-int mk_region(DSS_HUGE index, code_t *c, DBGenContext *ctx) {
-
-	c->code = index - 1;
-	c->text = regions.list[index - 1].text;
-	c->join = 0; /* for completeness */
-	TEXT(R_CMNT_LEN, &ctx->Seed[R_CMNT_SD], c->comment);
-	c->clen = (int)strlen(c->comment);
-	return (0);
-}
diff --git a/velox/external/duckdb/tpch/dbgen/dbgen.cpp b/velox/external/duckdb/tpch/dbgen/dbgen.cpp
deleted file mode 100644
index 57e94793ebb90..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/dbgen.cpp
+++ /dev/null
@@ -1,558 +0,0 @@
-#include "dbgen/dbgen.hpp"
-#include "dbgen/dbgen_gunk.hpp"
-#include "tpch_constants.hpp"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/parser/column_definition.hpp"
-#include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/parser/constraints/not_null_constraint.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/main/appender.hpp"
-#endif
-
-#define DECLARER /* EXTERN references get defined here */
-
-#include "dbgen/dss.h"
-#include "dbgen/dsstypes.h"
-
-#include <cassert>
-#include <mutex>
-
-using namespace duckdb;
-
-namespace tpch {
-
-struct tpch_append_information {
-	unique_ptr<InternalAppender> appender;
-};
-
-void append_value(tpch_append_information &info, int32_t value) {
-	info.appender->Append<int32_t>(value);
-}
-
-void append_string(tpch_append_information &info, const char *value) {
-	info.appender->Append<const char *>(value);
-}
-
-void append_decimal(tpch_append_information &info, int64_t value) {
-	info.appender->Append<int64_t>(value);
-}
-
-void append_date(tpch_append_information &info, string value) {
-	info.appender->Append<date_t>(Date::FromString(value));
-}
-
-void append_char(tpch_append_information &info, char value) {
-	char val[2];
-	val[0] = value;
-	val[1] = '\0';
-	append_string(info, val);
-}
-
-static void append_order(order_t *o, tpch_append_information *info) {
-	auto &append_info = info[ORDER];
-
-	// fill the current row with the order information
-	append_info.appender->BeginRow();
-	// o_orderkey
-	append_value(append_info, o->okey);
-	// o_custkey
-	append_value(append_info, o->custkey);
-	// o_orderstatus
-	append_char(append_info, o->orderstatus);
-	// o_totalprice
-	append_decimal(append_info, o->totalprice);
-	// o_orderdate
-	append_date(append_info, o->odate);
-	// o_orderpriority
-	append_string(append_info, o->opriority);
-	// o_clerk
-	append_string(append_info, o->clerk);
-	// o_shippriority
-	append_value(append_info, o->spriority);
-	// o_comment
-	append_string(append_info, o->comment);
-	append_info.appender->EndRow();
-}
-
-static void append_line(order_t *o, tpch_append_information *info) {
-	auto &append_info = info[LINE];
-
-	// fill the current row with the order information
-	for (DSS_HUGE i = 0; i < o->lines; i++) {
-		append_info.appender->BeginRow();
-		// l_orderkey
-		append_value(append_info, o->l[i].okey);
-		// l_partkey
-		append_value(append_info, o->l[i].partkey);
-		// l_suppkey
-		append_value(append_info, o->l[i].suppkey);
-		// l_linenumber
-		append_value(append_info, o->l[i].lcnt);
-		// l_quantity
-		append_value(append_info, o->l[i].quantity);
-		// l_extendedprice
-		append_decimal(append_info, o->l[i].eprice);
-		// l_discount
-		append_decimal(append_info, o->l[i].discount);
-		// l_tax
-		append_decimal(append_info, o->l[i].tax);
-		// l_returnflag
-		append_char(append_info, o->l[i].rflag[0]);
-		// l_linestatus
-		append_char(append_info, o->l[i].lstatus[0]);
-		// l_shipdate
-		append_date(append_info, o->l[i].sdate);
-		// l_commitdate
-		append_date(append_info, o->l[i].cdate);
-		// l_receiptdate
-		append_date(append_info, o->l[i].rdate);
-		// l_shipinstruct
-		append_string(append_info, o->l[i].shipinstruct);
-		// l_shipmode
-		append_string(append_info, o->l[i].shipmode);
-		// l_comment
-		append_string(append_info, o->l[i].comment);
-		append_info.appender->EndRow();
-	}
-}
-
-static void append_order_line(order_t *o, tpch_append_information *info) {
-	append_order(o, info);
-	append_line(o, info);
-}
-
-static void append_supp(supplier_t *supp, tpch_append_information *info) {
-	auto &append_info = info[SUPP];
-
-	append_info.appender->BeginRow();
-	// s_suppkey
-	append_value(append_info, supp->suppkey);
-	// s_name
-	append_string(append_info, supp->name);
-	// s_address
-	append_string(append_info, supp->address);
-	// s_nationkey
-	append_value(append_info, supp->nation_code);
-	// s_phone
-	append_string(append_info, supp->phone);
-	// s_acctbal
-	append_decimal(append_info, supp->acctbal);
-	// s_comment
-	append_string(append_info, supp->comment);
-	append_info.appender->EndRow();
-}
-
-static void append_cust(customer_t *c, tpch_append_information *info) {
-	auto &append_info = info[CUST];
-
-	append_info.appender->BeginRow();
-	// c_custkey
-	append_value(append_info, c->custkey);
-	// c_name
-	append_string(append_info, c->name);
-	// c_address
-	append_string(append_info, c->address);
-	// c_nationkey
-	append_value(append_info, c->nation_code);
-	// c_phone
-	append_string(append_info, c->phone);
-	// c_acctbal
-	append_decimal(append_info, c->acctbal);
-	// c_mktsegment
-	append_string(append_info, c->mktsegment);
-	// c_comment
-	append_string(append_info, c->comment);
-	append_info.appender->EndRow();
-}
-
-static void append_part(part_t *part, tpch_append_information *info) {
-	auto &append_info = info[PART];
-
-	append_info.appender->BeginRow();
-	// p_partkey
-	append_value(append_info, part->partkey);
-	// p_name
-	append_string(append_info, part->name);
-	// p_mfgr
-	append_string(append_info, part->mfgr);
-	// p_brand
-	append_string(append_info, part->brand);
-	// p_type
-	append_string(append_info, part->type);
-	// p_size
-	append_value(append_info, part->size);
-	// p_container
-	append_string(append_info, part->container);
-	// p_retailprice
-	append_decimal(append_info, part->retailprice);
-	// p_comment
-	append_string(append_info, part->comment);
-	append_info.appender->EndRow();
-}
-
-static void append_psupp(part_t *part, tpch_append_information *info) {
-	auto &append_info = info[PSUPP];
-	for (size_t i = 0; i < SUPP_PER_PART; i++) {
-		append_info.appender->BeginRow();
-		// ps_partkey
-		append_value(append_info, part->s[i].partkey);
-		// ps_suppkey
-		append_value(append_info, part->s[i].suppkey);
-		// ps_availqty
-		append_value(append_info, part->s[i].qty);
-		// ps_supplycost
-		append_decimal(append_info, part->s[i].scost);
-		// ps_comment
-		append_string(append_info, part->s[i].comment);
-		append_info.appender->EndRow();
-	}
-}
-
-static void append_part_psupp(part_t *part, tpch_append_information *info) {
-	append_part(part, info);
-	append_psupp(part, info);
-}
-
-static void append_nation(code_t *c, tpch_append_information *info) {
-	auto &append_info = info[NATION];
-
-	append_info.appender->BeginRow();
-	// n_nationkey
-	append_value(append_info, c->code);
-	// n_name
-	append_string(append_info, c->text);
-	// n_regionkey
-	append_value(append_info, c->join);
-	// n_comment
-	append_string(append_info, c->comment);
-	append_info.appender->EndRow();
-}
-
-static void append_region(code_t *c, tpch_append_information *info) {
-	auto &append_info = info[REGION];
-
-	append_info.appender->BeginRow();
-	// r_regionkey
-	append_value(append_info, c->code);
-	// r_name
-	append_string(append_info, c->text);
-	// r_comment
-	append_string(append_info, c->comment);
-	append_info.appender->EndRow();
-}
-
-static void gen_tbl(int tnum, DSS_HUGE count, tpch_append_information *info, DBGenContext *dbgen_ctx) {
-	order_t o;
-	supplier_t supp;
-	customer_t cust;
-	part_t part;
-	code_t code;
-
-	for (DSS_HUGE i = 1; count; count--, i++) {
-		row_start(tnum, dbgen_ctx);
-		switch (tnum) {
-		case LINE:
-		case ORDER:
-		case ORDER_LINE:
-			mk_order(i, &o, dbgen_ctx, 0);
-			append_order_line(&o, info);
-			break;
-		case SUPP:
-			mk_supp(i, &supp, dbgen_ctx);
-			append_supp(&supp, info);
-			break;
-		case CUST:
-			mk_cust(i, &cust, dbgen_ctx);
-			append_cust(&cust, info);
-			break;
-		case PSUPP:
-		case PART:
-		case PART_PSUPP:
-			mk_part(i, &part, dbgen_ctx);
-			append_part_psupp(&part, info);
-			break;
-		case NATION:
-			mk_nation(i, &code, dbgen_ctx);
-			append_nation(&code, info);
-			break;
-		case REGION:
-			mk_region(i, &code, dbgen_ctx);
-			append_region(&code, info);
-			break;
-		}
-		row_stop_h(tnum, dbgen_ctx);
-	}
-}
-
-string get_table_name(int num) {
-	switch (num) {
-	case PART:
-		return "part";
-	case PSUPP:
-		return "partsupp";
-	case SUPP:
-		return "supplier";
-	case CUST:
-		return "customer";
-	case ORDER:
-		return "orders";
-	case LINE:
-		return "lineitem";
-	case NATION:
-		return "nation";
-	case REGION:
-		return "region";
-	default:
-		return "";
-	}
-}
-
-struct RegionInfo {
-	static constexpr char *Name = "region";
-	static constexpr idx_t ColumnCount = 3;
-	static const char *Columns[];
-	static const LogicalType Types[];
-};
-const char *RegionInfo::Columns[] = {"r_regionkey", "r_name", "r_comment"};
-const LogicalType RegionInfo::Types[] = {LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::VARCHAR),
-                                         LogicalType(LogicalTypeId::VARCHAR)};
-
-struct NationInfo {
-	static constexpr char *Name = "nation";
-	static const char *Columns[];
-	static constexpr idx_t ColumnCount = 4;
-	static const LogicalType Types[];
-};
-const char *NationInfo::Columns[] = {"n_nationkey", "n_name", "n_regionkey", "n_comment"};
-const LogicalType NationInfo::Types[] = {LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::VARCHAR),
-                                         LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::VARCHAR)};
-
-struct SupplierInfo {
-	static constexpr char *Name = "supplier";
-	static const char *Columns[];
-	static constexpr idx_t ColumnCount = 7;
-	static const LogicalType Types[];
-};
-const char *SupplierInfo::Columns[] = {"s_suppkey", "s_name",    "s_address", "s_nationkey",
-                                       "s_phone",   "s_acctbal", "s_comment"};
-const LogicalType SupplierInfo::Types[] = {LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::VARCHAR),
-                                           LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::INTEGER),
-                                           LogicalType(LogicalTypeId::VARCHAR), LogicalType::DECIMAL(15, 2),
-                                           LogicalType(LogicalTypeId::VARCHAR)};
-
-struct CustomerInfo {
-	static constexpr char *Name = "customer";
-	static const char *Columns[];
-	static constexpr idx_t ColumnCount = 8;
-	static const LogicalType Types[];
-};
-const char *CustomerInfo::Columns[] = {"c_custkey", "c_name",    "c_address",    "c_nationkey",
-                                       "c_phone",   "c_acctbal", "c_mktsegment", "c_comment"};
-const LogicalType CustomerInfo::Types[] = {LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::VARCHAR),
-                                           LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::INTEGER),
-                                           LogicalType(LogicalTypeId::VARCHAR), LogicalType::DECIMAL(15, 2),
-                                           LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::VARCHAR)};
-
-struct PartInfo {
-	static constexpr char *Name = "part";
-	static const char *Columns[];
-	static constexpr idx_t ColumnCount = 9;
-	static const LogicalType Types[];
-};
-const char *PartInfo::Columns[] = {"p_partkey", "p_name",      "p_mfgr",        "p_brand",  "p_type",
-                                   "p_size",    "p_container", "p_retailprice", "p_comment"};
-const LogicalType PartInfo::Types[] = {
-    LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::VARCHAR),
-    LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::INTEGER),
-    LogicalType(LogicalTypeId::VARCHAR), LogicalType::DECIMAL(15, 2),         LogicalType(LogicalTypeId::VARCHAR)};
-
-struct PartsuppInfo {
-	static constexpr char *Name = "partsupp";
-	static const char *Columns[];
-	static constexpr idx_t ColumnCount = 5;
-	static const LogicalType Types[];
-};
-const char *PartsuppInfo::Columns[] = {"ps_partkey", "ps_suppkey", "ps_availqty", "ps_supplycost", "ps_comment"};
-const LogicalType PartsuppInfo::Types[] = {LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::INTEGER),
-                                           LogicalType(LogicalTypeId::INTEGER), LogicalType::DECIMAL(15, 2),
-                                           LogicalType(LogicalTypeId::VARCHAR)};
-
-struct OrdersInfo {
-	static constexpr char *Name = "orders";
-	static const char *Columns[];
-	static constexpr idx_t ColumnCount = 9;
-	static const LogicalType Types[];
-};
-const char *OrdersInfo::Columns[] = {"o_orderkey",      "o_custkey", "o_orderstatus",  "o_totalprice", "o_orderdate",
-                                     "o_orderpriority", "o_clerk",   "o_shippriority", "o_comment"};
-const LogicalType OrdersInfo::Types[] = {
-    LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::VARCHAR),
-    LogicalType::DECIMAL(15, 2),         LogicalType(LogicalTypeId::DATE),    LogicalType(LogicalTypeId::VARCHAR),
-    LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::VARCHAR)};
-
-struct LineitemInfo {
-	static constexpr char *Name = "lineitem";
-	static const char *Columns[];
-	static constexpr idx_t ColumnCount = 16;
-	static const LogicalType Types[];
-};
-const char *LineitemInfo::Columns[] = {"l_orderkey",    "l_partkey",       "l_suppkey",  "l_linenumber",
-                                       "l_quantity",    "l_extendedprice", "l_discount", "l_tax",
-                                       "l_returnflag",  "l_linestatus",    "l_shipdate", "l_commitdate",
-                                       "l_receiptdate", "l_shipinstruct",  "l_shipmode", "l_comment"};
-const LogicalType LineitemInfo::Types[] = {
-    LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::INTEGER),
-    LogicalType(LogicalTypeId::INTEGER), LogicalType(LogicalTypeId::INTEGER), LogicalType::DECIMAL(15, 2),
-    LogicalType::DECIMAL(15, 2),         LogicalType::DECIMAL(15, 2),         LogicalType(LogicalTypeId::VARCHAR),
-    LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::DATE),    LogicalType(LogicalTypeId::DATE),
-    LogicalType(LogicalTypeId::DATE),    LogicalType(LogicalTypeId::VARCHAR), LogicalType(LogicalTypeId::VARCHAR),
-    LogicalType(LogicalTypeId::VARCHAR)};
-
-template <class T>
-static void CreateTPCHTable(ClientContext &context, string schema, string suffix) {
-	auto info = make_unique<CreateTableInfo>();
-	info->schema = schema;
-	info->table = T::Name + suffix;
-	info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
-	info->temporary = false;
-	for (idx_t i = 0; i < T::ColumnCount; i++) {
-		info->columns.push_back(ColumnDefinition(T::Columns[i], T::Types[i]));
-		info->constraints.push_back(make_unique<NotNullConstraint>(i));
-	}
-	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateTable(context, std::move(info));
-}
-
-void DBGenWrapper::CreateTPCHSchema(ClientContext &context, string schema, string suffix) {
-	CreateTPCHTable<RegionInfo>(context, schema, suffix);
-	CreateTPCHTable<NationInfo>(context, schema, suffix);
-	CreateTPCHTable<SupplierInfo>(context, schema, suffix);
-	CreateTPCHTable<CustomerInfo>(context, schema, suffix);
-	CreateTPCHTable<PartInfo>(context, schema, suffix);
-	CreateTPCHTable<PartsuppInfo>(context, schema, suffix);
-	CreateTPCHTable<OrdersInfo>(context, schema, suffix);
-	CreateTPCHTable<LineitemInfo>(context, schema, suffix);
-}
-
-void DBGenWrapper::LoadTPCHData(ClientContext &context, double flt_scale, string schema, string suffix) {
-	if (flt_scale == 0) {
-		return;
-	}
-
-	// generate the actual data
-	DSS_HUGE rowcnt = 0;
-	DSS_HUGE i;
-	// all tables
-	table = (1 << CUST) | (1 << SUPP) | (1 << NATION) | (1 << REGION) | (1 << PART_PSUPP) | (1 << ORDER_LINE);
-	force = 0;
-	insert_segments = 0;
-	delete_segments = 0;
-	insert_orders_segment = 0;
-	insert_lineitem_segment = 0;
-	delete_segment = 0;
-	verbose = 0;
-	set_seeds = 0;
-	updates = 0;
-
-  DBGenContext dbgen_ctx;
-
-  tdef* tdefs = dbgen_ctx.tdefs;
-	tdefs[PART].base = 200000;
-	tdefs[PSUPP].base = 200000;
-	tdefs[SUPP].base = 10000;
-	tdefs[CUST].base = 150000;
-	tdefs[ORDER].base = 150000 * ORDERS_PER_CUST;
-	tdefs[LINE].base = 150000 * ORDERS_PER_CUST;
-	tdefs[ORDER_LINE].base = 150000 * ORDERS_PER_CUST;
-	tdefs[PART_PSUPP].base = 200000;
-	tdefs[NATION].base = NATIONS_MAX;
-	tdefs[REGION].base = NATIONS_MAX;
-
-	children = 1;
-	d_path = NULL;
-
-	if (flt_scale < MIN_SCALE) {
-		int i;
-		int int_scale;
-
-		dbgen_ctx.scale_factor = 1;
-		int_scale = (int)(1000 * flt_scale);
-		for (i = PART; i < REGION; i++) {
-			tdefs[i].base = (DSS_HUGE)(int_scale * tdefs[i].base) / 1000;
-			if (tdefs[i].base < 1) {
-				tdefs[i].base = 1;
-			}
-		}
-	} else {
-		dbgen_ctx.scale_factor = (long)flt_scale;
-	}
-
-	load_dists(300 * 1024 * 1024, &dbgen_ctx); // 300MiB
-
-	/* have to do this after init */
-	tdefs[NATION].base = nations.count;
-	tdefs[REGION].base = regions.count;
-
-	auto &catalog = Catalog::GetCatalog(context);
-
-	auto append_info = unique_ptr<tpch_append_information[]>(new tpch_append_information[REGION + 1]);
-	memset(append_info.get(), 0, sizeof(tpch_append_information) * REGION + 1);
-	for (size_t i = PART; i <= REGION; i++) {
-		auto tname = get_table_name(i);
-		if (!tname.empty()) {
-			string full_tname = string(tname) + string(suffix);
-			auto tbl_catalog = catalog.GetEntry<TableCatalogEntry>(context, schema, full_tname);
-			append_info[i].appender = make_unique<InternalAppender>(context, *tbl_catalog);
-		}
-	}
-
-	for (i = PART; i <= REGION; i++) {
-		if (table & (1 << i)) {
-			if (i < NATION) {
-				rowcnt = tdefs[i].base * dbgen_ctx.scale_factor;
-			} else {
-				rowcnt = tdefs[i].base;
-			}
-			// actually doing something
-			gen_tbl((int)i, rowcnt, append_info.get(), &dbgen_ctx);
-		}
-	}
-	// flush any incomplete chunks
-	for (size_t i = PART; i <= REGION; i++) {
-		if (append_info[i].appender) {
-			append_info[i].appender->Flush();
-			append_info[i].appender.reset();
-		}
-	}
-
-	cleanup_dists();
-}
-
-string DBGenWrapper::GetQuery(int query) {
-	if (query <= 0 || query > TPCH_QUERIES_COUNT) {
-		throw SyntaxException("Out of range TPC-H query number %d", query);
-	}
-	return TPCH_QUERIES[query - 1];
-}
-
-string DBGenWrapper::GetAnswer(double sf, int query) {
-	if (query <= 0 || query > TPCH_QUERIES_COUNT) {
-		throw SyntaxException("Out of range TPC-H query number %d", query);
-	}
-	const char *answer;
-	if (sf == 0.01) {
-		answer = TPCH_ANSWERS_SF0_01[query - 1];
-	} else if (sf == 0.1) {
-		answer = TPCH_ANSWERS_SF0_1[query - 1];
-	} else if (sf == 1) {
-		answer = TPCH_ANSWERS_SF1[query - 1];
-	} else {
-		throw NotImplementedException("Don't have TPC-H answers for SF %llf!", sf);
-	}
-	return answer;
-}
-
-} // namespace tpch
diff --git a/velox/external/duckdb/tpch/dbgen/dbgen_gunk.cpp b/velox/external/duckdb/tpch/dbgen/dbgen_gunk.cpp
deleted file mode 100644
index f69a7bb603c23..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/dbgen_gunk.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-#include "dbgen/dbgen_gunk.hpp"
-
-#include "dbgen/dss.h"
-#include "dbgen/dsstypes.h"
-
-void load_dists(long textBufferSize, DBGenContext *ctx) {
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "p_cntr", &p_cntr_set);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "colors", &colors);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "p_types", &p_types_set);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "nations", &nations);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "regions", &regions);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "o_oprio", &o_priority_set);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "instruct", &l_instruct_set);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "smode", &l_smode_set);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "category", &l_category_set);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "rflag", &l_rflag_set);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "msegmnt", &c_mseg_set);
-
-	/* load the distributions that contain text generation */
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "nouns", &nouns);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "verbs", &verbs);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "adjectives", &adjectives);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "adverbs", &adverbs);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "auxillaries", &auxillaries);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "terminators", &terminators);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "articles", &articles);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "prepositions", &prepositions);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "grammar", &grammar);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "np", &np);
-	read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "vp", &vp);
-
-  /* populate the text buffer used to generate random text */
-  init_text_pool(textBufferSize, ctx);
-}
-
-static void cleanup_dist(distribution *target) {
-	if (!target) {
-		return;
-	}
-	if (target->list) {
-		for (int i = 0; i < target->count; i++) {
-			if (target->list[i].text) {
-				free(target->list[i].text);
-			}
-		}
-		free(target->list);
-	}
-}
-
-void cleanup_dists(void) {
-	cleanup_dist(&p_cntr_set);
-	cleanup_dist(&colors);
-	cleanup_dist(&p_types_set);
-	cleanup_dist(&nations);
-	cleanup_dist(&regions);
-	cleanup_dist(&o_priority_set);
-	cleanup_dist(&l_instruct_set);
-	cleanup_dist(&l_smode_set);
-	cleanup_dist(&l_category_set);
-	cleanup_dist(&l_rflag_set);
-	cleanup_dist(&c_mseg_set);
-	cleanup_dist(&nouns);
-	cleanup_dist(&verbs);
-	cleanup_dist(&adjectives);
-	cleanup_dist(&adverbs);
-	cleanup_dist(&auxillaries);
-	cleanup_dist(&terminators);
-	cleanup_dist(&articles);
-	cleanup_dist(&prepositions);
-	cleanup_dist(&grammar);
-	cleanup_dist(&np);
-	cleanup_dist(&vp);
-
-  free_text_pool();
-}
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/dbgen.hpp b/velox/external/duckdb/tpch/dbgen/include/dbgen/dbgen.hpp
deleted file mode 100644
index 806979094cc11..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/include/dbgen/dbgen.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                         DuckDB
-//
-// dbgen.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb.hpp"
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#endif
-
-namespace duckdb {
-class ClientContext;
-}
-
-namespace tpch {
-
-struct DBGenWrapper {
-	//! Create the TPC-H tables in the given schema with the given suffix
-	static void CreateTPCHSchema(duckdb::ClientContext &context, std::string schema, std::string suffix);
-	//! Load the TPC-H data of the given scale factor
-	static void LoadTPCHData(duckdb::ClientContext &context, double sf, std::string schema, std::string suffix);
-
-	//! Gets the specified TPC-H Query number as a string
-	static std::string GetQuery(int query);
-	//! Returns the CSV answer of a TPC-H query
-	static std::string GetAnswer(double sf, int query);
-};
-
-} // namespace tpch
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/dists_dss.h b/velox/external/duckdb/tpch/dbgen/include/dbgen/dists_dss.h
deleted file mode 100644
index 0d81e60b2959d..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/include/dbgen/dists_dss.h
+++ /dev/null
@@ -1,850 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-const char *dists_dss = "#\n"
-                        "# $Id: dists.dss,v 1.2 2005/01/03 20:08:58 jms Exp $\n"
-                        "#\n"
-                        "# Revision History\n"
-                        "# ===================\n"
-                        "# $Log: dists.dss,v $\n"
-                        "# Revision 1.2  2005/01/03 20:08:58  jms\n"
-                        "# change line terminations\n"
-                        "#\n"
-                        "# Revision 1.1.1.1  2004/11/24 23:31:46  jms\n"
-                        "# re-establish external server\n"
-                        "#\n"
-                        "# Revision 1.1.1.1  2003/04/03 18:54:21  jms\n"
-                        "# recreation after CVS crash\n"
-                        "#\n"
-                        "# Revision 1.1.1.1  2003/04/03 18:54:21  jms\n"
-                        "# initial checkin\n"
-                        "#\n"
-                        "#\n"
-                        "#\n"
-                        "#\n"
-                        "# distributions have the following format:\n"
-                        "#\n"
-                        "# <token> | <weight> # comment\n"
-                        "#\n"
-                        "# Distributions are used to bias the selection of a token \n"
-                        "# based on its associated weight. The list of tokens and values \n"
-                        "# between the keywords BEGIN and END define the distribution named after\n"
-                        "# the BEGIN. A uniformly random value from [0, sum(weights)]\n"
-                        "# will be chosen and the first token whose cumulative weight is greater "
-                        "than\n"
-                        "# or equal to the result will be returned. In essence, the weights for "
-                        "each\n"
-                        "# token represent its relative weight within a distribution.\n"
-                        "#\n"
-                        "# one special token is defined: count (number of data points in the \n"
-                        "#  distribution). It MUST be defined for each named distribution.\n"
-                        "#-----------------------------------------------------------------------\n"
-                        "# currently defined distributions and their use:\n"
-                        "#  NAME       FIELD/NOTES\n"
-                        "#  ========   ==============\n"
-                        "#  category   parts.category\n"
-                        "#  container  parts.container\n"
-                        "#  instruct   shipping instructions\n"
-                        "#  msegmnt    market segment\n"
-                        "#  names      parts.name\n"
-                        "#  nations    must be ordered along with regions\n"
-                        "#  nations2   stand alone nations set for use with qgen\n"
-                        "#  o_prio     order priority\n"
-                        "#  regions    must be ordered along with nations\n"
-                        "#  rflag      lineitems.returnflag\n"
-                        "#  types      parts.type\n"
-                        "#  colors     embedded string creation; CANNOT BE USED FOR pick_str(), "
-                        "agg_str() perturbs order\n"
-                        "#  articles   comment generation \n"
-                        "#  nouns      \n"
-                        "#  verbs      \n"
-                        "#  adverbs    \n"
-                        "#  auxillaries \n"
-                        "#  prepositions\n"
-                        "#  terminators\n"
-                        "#  grammar    sentence formation\n"
-                        "#  np\n"
-                        "#  vp\n"
-                        "###\n"
-                        "# category\n"
-                        "###\n"
-                        "BEGIN category\n"
-                        "COUNT|5\n"
-                        "FURNITURE|1\n"
-                        "STORAGE EQUIP|1\n"
-                        "TOOLS|1\n"
-                        "MACHINE TOOLS|1\n"
-                        "OTHER|1\n"
-                        "END category\n"
-                        "###\n"
-                        "# container\n"
-                        "###\n"
-                        "begin p_cntr\n"
-                        "count|40\n"
-                        "SM CASE|1\n"
-                        "SM BOX|1\n"
-                        "SM BAG|1\n"
-                        "SM JAR|1\n"
-                        "SM PACK|1\n"
-                        "SM PKG|1\n"
-                        "SM CAN|1\n"
-                        "SM DRUM|1\n"
-                        "LG CASE|1\n"
-                        "LG BOX|1\n"
-                        "LG BAG|1\n"
-                        "LG JAR|1\n"
-                        "LG PACK|1\n"
-                        "LG PKG|1\n"
-                        "LG CAN|1\n"
-                        "LG DRUM|1\n"
-                        "MED CASE|1\n"
-                        "MED BOX|1\n"
-                        "MED BAG|1\n"
-                        "MED JAR|1\n"
-                        "MED PACK|1\n"
-                        "MED PKG|1\n"
-                        "MED CAN|1\n"
-                        "MED DRUM|1\n"
-                        "JUMBO CASE|1\n"
-                        "JUMBO BOX|1\n"
-                        "JUMBO BAG|1\n"
-                        "JUMBO JAR|1\n"
-                        "JUMBO PACK|1\n"
-                        "JUMBO PKG|1\n"
-                        "JUMBO CAN|1\n"
-                        "JUMBO DRUM|1\n"
-                        "WRAP CASE|1\n"
-                        "WRAP BOX|1\n"
-                        "WRAP BAG|1\n"
-                        "WRAP JAR|1\n"
-                        "WRAP PACK|1\n"
-                        "WRAP PKG|1\n"
-                        "WRAP CAN|1\n"
-                        "WRAP DRUM|1\n"
-                        "end p_cntr\n"
-                        "###\n"
-                        "# instruct\n"
-                        "###\n"
-                        "begin instruct\n"
-                        "count|4\n"
-                        "DELIVER IN PERSON|1\n"
-                        "COLLECT COD|1\n"
-                        "TAKE BACK RETURN|1\n"
-                        "NONE|1\n"
-                        "end instruct\n"
-                        "###\n"
-                        "# msegmnt\n"
-                        "###\n"
-                        "begin msegmnt\n"
-                        "count|5\n"
-                        "AUTOMOBILE|1\n"
-                        "BUILDING|1\n"
-                        "FURNITURE|1\n"
-                        "HOUSEHOLD|1\n"
-                        "MACHINERY|1\n"
-                        "end msegmnt\n"
-                        "###\n"
-                        "# names\n"
-                        "###\n"
-                        "begin p_names\n"
-                        "COUNT|4\n"
-                        "CLEANER|1\n"
-                        "SOAP|1\n"
-                        "DETERGENT|1\n"
-                        "EXTRA|1\n"
-                        "end p_names\n"
-                        "###\n"
-                        "# nations\n"
-                        "# NOTE: this is a special case; the weights here are adjustments to\n"
-                        "#       map correctly into the regions table, and are *NOT* cummulative\n"
-                        "#       values to mimic a distribution\n"
-                        "###\n"
-                        "begin nations\n"
-                        "count|25\n"
-                        "ALGERIA|0\n"
-                        "ARGENTINA|1\n"
-                        "BRAZIL|0\n"
-                        "CANADA|0\n"
-                        "EGYPT|3\n"
-                        "ETHIOPIA|-4\n"
-                        "FRANCE|3\n"
-                        "GERMANY|0\n"
-                        "INDIA|-1\n"
-                        "INDONESIA|0\n"
-                        "IRAN|2\n"
-                        "IRAQ|0\n"
-                        "JAPAN|-2\n"
-                        "JORDAN|2\n"
-                        "KENYA|-4\n"
-                        "MOROCCO|0\n"
-                        "MOZAMBIQUE|0\n"
-                        "PERU|1\n"
-                        "CHINA|1\n"
-                        "ROMANIA|1\n"
-                        "SAUDI ARABIA|1\n"
-                        "VIETNAM|-2\n"
-                        "RUSSIA|1\n"
-                        "UNITED KINGDOM|0\n"
-                        "UNITED STATES|-2\n"
-                        "end nations\n"
-                        "###\n"
-                        "# nations2\n"
-                        "###\n"
-                        "begin nations2\n"
-                        "count|25\n"
-                        "ALGERIA|1\n"
-                        "ARGENTINA|1\n"
-                        "BRAZIL|1\n"
-                        "CANADA|1\n"
-                        "EGYPT|1\n"
-                        "ETHIOPIA|1\n"
-                        "FRANCE|1\n"
-                        "GERMANY|1\n"
-                        "INDIA|1\n"
-                        "INDONESIA|1\n"
-                        "IRAN|1\n"
-                        "IRAQ|1\n"
-                        "JAPAN|1\n"
-                        "JORDAN|1\n"
-                        "KENYA|1\n"
-                        "MOROCCO|1\n"
-                        "MOZAMBIQUE|1\n"
-                        "PERU|1\n"
-                        "CHINA|1\n"
-                        "ROMANIA|1\n"
-                        "SAUDI ARABIA|1\n"
-                        "VIETNAM|1\n"
-                        "RUSSIA|1\n"
-                        "UNITED KINGDOM|1\n"
-                        "UNITED STATES|1\n"
-                        "end nations2\n"
-                        "###\n"
-                        "# regions\n"
-                        "###\n"
-                        "begin regions\n"
-                        "count|5\n"
-                        "AFRICA|1\n"
-                        "AMERICA|1\n"
-                        "ASIA|1\n"
-                        "EUROPE|1\n"
-                        "MIDDLE EAST|1\n"
-                        "end regions\n"
-                        "###\n"
-                        "# o_prio\n"
-                        "###\n"
-                        "begin o_oprio\n"
-                        "count|5\n"
-                        "1-URGENT|1\n"
-                        "2-HIGH|1\n"
-                        "3-MEDIUM|1\n"
-                        "4-NOT SPECIFIED|1\n"
-                        "5-LOW|1\n"
-                        "end o_oprio\n"
-                        "###\n"
-                        "# rflag\n"
-                        "###\n"
-                        "begin rflag\n"
-                        "count|2\n"
-                        "R|1\n"
-                        "A|1\n"
-                        "end rflag\n"
-                        "###\n"
-                        "# smode\n"
-                        "###\n"
-                        "begin smode\n"
-                        "count|7\n"
-                        "REG AIR|1\n"
-                        "AIR|1\n"
-                        "RAIL|1\n"
-                        "TRUCK|1\n"
-                        "MAIL|1\n"
-                        "FOB|1\n"
-                        "SHIP|1\n"
-                        "end smode\n"
-                        "###\n"
-                        "# types\n"
-                        "###\n"
-                        "begin p_types\n"
-                        "COUNT|150\n"
-                        "STANDARD ANODIZED TIN|1\n"
-                        "STANDARD ANODIZED NICKEL|1\n"
-                        "STANDARD ANODIZED BRASS|1\n"
-                        "STANDARD ANODIZED STEEL|1\n"
-                        "STANDARD ANODIZED COPPER|1\n"
-                        "STANDARD BURNISHED TIN|1\n"
-                        "STANDARD BURNISHED NICKEL|1\n"
-                        "STANDARD BURNISHED BRASS|1\n"
-                        "STANDARD BURNISHED STEEL|1\n"
-                        "STANDARD BURNISHED COPPER|1\n"
-                        "STANDARD PLATED TIN|1\n"
-                        "STANDARD PLATED NICKEL|1\n"
-                        "STANDARD PLATED BRASS|1\n"
-                        "STANDARD PLATED STEEL|1\n"
-                        "STANDARD PLATED COPPER|1\n"
-                        "STANDARD POLISHED TIN|1\n"
-                        "STANDARD POLISHED NICKEL|1\n"
-                        "STANDARD POLISHED BRASS|1\n"
-                        "STANDARD POLISHED STEEL|1\n"
-                        "STANDARD POLISHED COPPER|1\n"
-                        "STANDARD BRUSHED TIN|1\n"
-                        "STANDARD BRUSHED NICKEL|1\n"
-                        "STANDARD BRUSHED BRASS|1\n"
-                        "STANDARD BRUSHED STEEL|1\n"
-                        "STANDARD BRUSHED COPPER|1\n"
-                        "SMALL ANODIZED TIN|1\n"
-                        "SMALL ANODIZED NICKEL|1\n"
-                        "SMALL ANODIZED BRASS|1\n"
-                        "SMALL ANODIZED STEEL|1\n"
-                        "SMALL ANODIZED COPPER|1\n"
-                        "SMALL BURNISHED TIN|1\n"
-                        "SMALL BURNISHED NICKEL|1\n"
-                        "SMALL BURNISHED BRASS|1\n"
-                        "SMALL BURNISHED STEEL|1\n"
-                        "SMALL BURNISHED COPPER|1\n"
-                        "SMALL PLATED TIN|1\n"
-                        "SMALL PLATED NICKEL|1\n"
-                        "SMALL PLATED BRASS|1\n"
-                        "SMALL PLATED STEEL|1\n"
-                        "SMALL PLATED COPPER|1\n"
-                        "SMALL POLISHED TIN|1\n"
-                        "SMALL POLISHED NICKEL|1\n"
-                        "SMALL POLISHED BRASS|1\n"
-                        "SMALL POLISHED STEEL|1\n"
-                        "SMALL POLISHED COPPER|1\n"
-                        "SMALL BRUSHED TIN|1\n"
-                        "SMALL BRUSHED NICKEL|1\n"
-                        "SMALL BRUSHED BRASS|1\n"
-                        "SMALL BRUSHED STEEL|1\n"
-                        "SMALL BRUSHED COPPER|1\n"
-                        "MEDIUM ANODIZED TIN|1\n"
-                        "MEDIUM ANODIZED NICKEL|1\n"
-                        "MEDIUM ANODIZED BRASS|1\n"
-                        "MEDIUM ANODIZED STEEL|1\n"
-                        "MEDIUM ANODIZED COPPER|1\n"
-                        "MEDIUM BURNISHED TIN|1\n"
-                        "MEDIUM BURNISHED NICKEL|1\n"
-                        "MEDIUM BURNISHED BRASS|1\n"
-                        "MEDIUM BURNISHED STEEL|1\n"
-                        "MEDIUM BURNISHED COPPER|1\n"
-                        "MEDIUM PLATED TIN|1\n"
-                        "MEDIUM PLATED NICKEL|1\n"
-                        "MEDIUM PLATED BRASS|1\n"
-                        "MEDIUM PLATED STEEL|1\n"
-                        "MEDIUM PLATED COPPER|1\n"
-                        "MEDIUM POLISHED TIN|1\n"
-                        "MEDIUM POLISHED NICKEL|1\n"
-                        "MEDIUM POLISHED BRASS|1\n"
-                        "MEDIUM POLISHED STEEL|1\n"
-                        "MEDIUM POLISHED COPPER|1\n"
-                        "MEDIUM BRUSHED TIN|1\n"
-                        "MEDIUM BRUSHED NICKEL|1\n"
-                        "MEDIUM BRUSHED BRASS|1\n"
-                        "MEDIUM BRUSHED STEEL|1\n"
-                        "MEDIUM BRUSHED COPPER|1\n"
-                        "LARGE ANODIZED TIN|1\n"
-                        "LARGE ANODIZED NICKEL|1\n"
-                        "LARGE ANODIZED BRASS|1\n"
-                        "LARGE ANODIZED STEEL|1\n"
-                        "LARGE ANODIZED COPPER|1\n"
-                        "LARGE BURNISHED TIN|1\n"
-                        "LARGE BURNISHED NICKEL|1\n"
-                        "LARGE BURNISHED BRASS|1\n"
-                        "LARGE BURNISHED STEEL|1\n"
-                        "LARGE BURNISHED COPPER|1\n"
-                        "LARGE PLATED TIN|1\n"
-                        "LARGE PLATED NICKEL|1\n"
-                        "LARGE PLATED BRASS|1\n"
-                        "LARGE PLATED STEEL|1\n"
-                        "LARGE PLATED COPPER|1\n"
-                        "LARGE POLISHED TIN|1\n"
-                        "LARGE POLISHED NICKEL|1\n"
-                        "LARGE POLISHED BRASS|1\n"
-                        "LARGE POLISHED STEEL|1\n"
-                        "LARGE POLISHED COPPER|1\n"
-                        "LARGE BRUSHED TIN|1\n"
-                        "LARGE BRUSHED NICKEL|1\n"
-                        "LARGE BRUSHED BRASS|1\n"
-                        "LARGE BRUSHED STEEL|1\n"
-                        "LARGE BRUSHED COPPER|1\n"
-                        "ECONOMY ANODIZED TIN|1\n"
-                        "ECONOMY ANODIZED NICKEL|1\n"
-                        "ECONOMY ANODIZED BRASS|1\n"
-                        "ECONOMY ANODIZED STEEL|1\n"
-                        "ECONOMY ANODIZED COPPER|1\n"
-                        "ECONOMY BURNISHED TIN|1\n"
-                        "ECONOMY BURNISHED NICKEL|1\n"
-                        "ECONOMY BURNISHED BRASS|1\n"
-                        "ECONOMY BURNISHED STEEL|1\n"
-                        "ECONOMY BURNISHED COPPER|1\n"
-                        "ECONOMY PLATED TIN|1\n"
-                        "ECONOMY PLATED NICKEL|1\n"
-                        "ECONOMY PLATED BRASS|1\n"
-                        "ECONOMY PLATED STEEL|1\n"
-                        "ECONOMY PLATED COPPER|1\n"
-                        "ECONOMY POLISHED TIN|1\n"
-                        "ECONOMY POLISHED NICKEL|1\n"
-                        "ECONOMY POLISHED BRASS|1\n"
-                        "ECONOMY POLISHED STEEL|1\n"
-                        "ECONOMY POLISHED COPPER|1\n"
-                        "ECONOMY BRUSHED TIN|1\n"
-                        "ECONOMY BRUSHED NICKEL|1\n"
-                        "ECONOMY BRUSHED BRASS|1\n"
-                        "ECONOMY BRUSHED STEEL|1\n"
-                        "ECONOMY BRUSHED COPPER|1\n"
-                        "PROMO ANODIZED TIN|1\n"
-                        "PROMO ANODIZED NICKEL|1\n"
-                        "PROMO ANODIZED BRASS|1\n"
-                        "PROMO ANODIZED STEEL|1\n"
-                        "PROMO ANODIZED COPPER|1\n"
-                        "PROMO BURNISHED TIN|1\n"
-                        "PROMO BURNISHED NICKEL|1\n"
-                        "PROMO BURNISHED BRASS|1\n"
-                        "PROMO BURNISHED STEEL|1\n"
-                        "PROMO BURNISHED COPPER|1\n"
-                        "PROMO PLATED TIN|1\n"
-                        "PROMO PLATED NICKEL|1\n"
-                        "PROMO PLATED BRASS|1\n"
-                        "PROMO PLATED STEEL|1\n"
-                        "PROMO PLATED COPPER|1\n"
-                        "PROMO POLISHED TIN|1\n"
-                        "PROMO POLISHED NICKEL|1\n"
-                        "PROMO POLISHED BRASS|1\n"
-                        "PROMO POLISHED STEEL|1\n"
-                        "PROMO POLISHED COPPER|1\n"
-                        "PROMO BRUSHED TIN|1\n"
-                        "PROMO BRUSHED NICKEL|1\n"
-                        "PROMO BRUSHED BRASS|1\n"
-                        "PROMO BRUSHED STEEL|1\n"
-                        "PROMO BRUSHED COPPER|1\n"
-                        "end p_types\n"
-                        "###\n"
-                        "# colors\n"
-                        "# NOTE: This distribution CANNOT be used by pick_str(), since agg_str() "
-                        "perturbs its order\n"
-                        "###\n"
-                        "begin colors\n"
-                        "COUNT|92\n"
-                        "almond|1\n"
-                        "antique|1\n"
-                        "aquamarine|1\n"
-                        "azure|1\n"
-                        "beige|1\n"
-                        "bisque|1\n"
-                        "black|1\n"
-                        "blanched|1\n"
-                        "blue|1\n"
-                        "blush|1\n"
-                        "brown|1\n"
-                        "burlywood|1\n"
-                        "burnished|1\n"
-                        "chartreuse|1\n"
-                        "chiffon|1\n"
-                        "chocolate|1\n"
-                        "coral|1\n"
-                        "cornflower|1\n"
-                        "cornsilk|1\n"
-                        "cream|1\n"
-                        "cyan|1\n"
-                        "dark|1\n"
-                        "deep|1\n"
-                        "dim|1\n"
-                        "dodger|1\n"
-                        "drab|1\n"
-                        "firebrick|1\n"
-                        "floral|1\n"
-                        "forest|1\n"
-                        "frosted|1\n"
-                        "gainsboro|1\n"
-                        "ghost|1\n"
-                        "goldenrod|1\n"
-                        "green|1\n"
-                        "grey|1\n"
-                        "honeydew|1\n"
-                        "hot|1\n"
-                        "indian|1\n"
-                        "ivory|1\n"
-                        "khaki|1\n"
-                        "lace|1\n"
-                        "lavender|1\n"
-                        "lawn|1\n"
-                        "lemon|1\n"
-                        "light|1\n"
-                        "lime|1\n"
-                        "linen|1\n"
-                        "magenta|1\n"
-                        "maroon|1\n"
-                        "medium|1\n"
-                        "metallic|1\n"
-                        "midnight|1\n"
-                        "mint|1\n"
-                        "misty|1\n"
-                        "moccasin|1\n"
-                        "navajo|1\n"
-                        "navy|1\n"
-                        "olive|1\n"
-                        "orange|1\n"
-                        "orchid|1\n"
-                        "pale|1\n"
-                        "papaya|1\n"
-                        "peach|1\n"
-                        "peru|1\n"
-                        "pink|1\n"
-                        "plum|1\n"
-                        "powder|1\n"
-                        "puff|1\n"
-                        "purple|1\n"
-                        "red|1\n"
-                        "rose|1\n"
-                        "rosy|1\n"
-                        "royal|1\n"
-                        "saddle|1\n"
-                        "salmon|1\n"
-                        "sandy|1\n"
-                        "seashell|1\n"
-                        "sienna|1\n"
-                        "sky|1\n"
-                        "slate|1\n"
-                        "smoke|1\n"
-                        "snow|1\n"
-                        "spring|1\n"
-                        "steel|1\n"
-                        "tan|1\n"
-                        "thistle|1\n"
-                        "tomato|1\n"
-                        "turquoise|1\n"
-                        "violet|1\n"
-                        "wheat|1\n"
-                        "white|1\n"
-                        "yellow|1\n"
-                        "end colors\n"
-                        "################\n"
-                        "################\n"
-                        "## psuedo text distributions\n"
-                        "################\n"
-                        "################\n"
-                        "###\n"
-                        "# nouns\n"
-                        "###\n"
-                        "BEGIN nouns\n"
-                        "COUNT|45\n"
-                        "packages|40\n"
-                        "requests|40\n"
-                        "accounts|40\n"
-                        "deposits|40\n"
-                        "foxes|20\n"
-                        "ideas|20\n"
-                        "theodolites|20\n"
-                        "pinto beans|20\n"
-                        "instructions|20\n"
-                        "dependencies|10\n"
-                        "excuses|10\n"
-                        "platelets|10\n"
-                        "asymptotes|10\n"
-                        "courts|5\n"
-                        "dolphins|5\n"
-                        "multipliers|1\n"
-                        "sauternes|1\n"
-                        "warthogs|1\n"
-                        "frets|1\n"
-                        "dinos|1\n"
-                        "attainments|1\n"
-                        "somas|1\n"
-                        "Tiresias|1\n"
-                        "patterns|1\n"
-                        "forges|1\n"
-                        "braids|1\n"
-                        "frays|1\n"
-                        "warhorses|1\n"
-                        "dugouts|1\n"
-                        "notornis|1\n"
-                        "epitaphs|1\n"
-                        "pearls|1\n"
-                        "tithes|1\n"
-                        "waters|1\n"
-                        "orbits|1\n"
-                        "gifts|1\n"
-                        "sheaves|1\n"
-                        "depths|1\n"
-                        "sentiments|1\n"
-                        "decoys|1\n"
-                        "realms|1\n"
-                        "pains|1\n"
-                        "grouches|1\n"
-                        "escapades|1\n"
-                        "hockey players|1\n"
-                        "END nouns\n"
-                        "###\n"
-                        "# verbs\n"
-                        "###\n"
-                        "BEGIN verbs\n"
-                        "COUNT|40\n"
-                        "sleep|20\n"
-                        "wake|20\n"
-                        "are|20\n"
-                        "cajole|20\n"
-                        "haggle|20\n"
-                        "nag|10\n"
-                        "use|10\n"
-                        "boost|10\n"
-                        "affix|5\n"
-                        "detect|5\n"
-                        "integrate|5\n"
-                        "maintain|1\n"
-                        "nod|1\n"
-                        "was|1\n"
-                        "lose|1\n"
-                        "sublate|1\n"
-                        "solve|1\n"
-                        "thrash|1\n"
-                        "promise|1\n"
-                        "engage|1\n"
-                        "hinder|1\n"
-                        "print|1\n"
-                        "x-ray|1\n"
-                        "breach|1\n"
-                        "eat|1\n"
-                        "grow|1\n"
-                        "impress|1\n"
-                        "mold|1\n"
-                        "poach|1\n"
-                        "serve|1\n"
-                        "run|1\n"
-                        "dazzle|1\n"
-                        "snooze|1\n"
-                        "doze|1\n"
-                        "unwind|1\n"
-                        "kindle|1\n"
-                        "play|1\n"
-                        "hang|1\n"
-                        "believe|1\n"
-                        "doubt|1\n"
-                        "END verbs\n"
-                        "###\n"
-                        "# adverbs\n"
-                        "##\n"
-                        "BEGIN adverbs\n"
-                        "COUNT|28\n"
-                        "sometimes|1\n"
-                        "always|1\n"
-                        "never|1\n"
-                        "furiously|50\n"
-                        "slyly|50\n"
-                        "carefully|50\n"
-                        "blithely|40\n"
-                        "quickly|30\n"
-                        "fluffily|20\n"
-                        "slowly|1\n"
-                        "quietly|1\n"
-                        "ruthlessly|1\n"
-                        "thinly|1\n"
-                        "closely|1\n"
-                        "doggedly|1\n"
-                        "daringly|1\n"
-                        "bravely|1\n"
-                        "stealthily|1\n"
-                        "permanently|1\n"
-                        "enticingly|1\n"
-                        "idly|1\n"
-                        "busily|1\n"
-                        "regularly|1\n"
-                        "finally|1\n"
-                        "ironically|1\n"
-                        "evenly|1\n"
-                        "boldly|1\n"
-                        "silently|1\n"
-                        "END adverbs\n"
-                        "###\n"
-                        "# articles\n"
-                        "##\n"
-                        "BEGIN articles\n"
-                        "COUNT|3\n"
-                        "the|50\n"
-                        "a|20\n"
-                        "an|5\n"
-                        "END articles\n"
-                        "###\n"
-                        "# prepositions\n"
-                        "##\n"
-                        "BEGIN prepositions\n"
-                        "COUNT|47\n"
-                        "about|50\n"
-                        "above|50\n"
-                        "according to|50\n"
-                        "across|50\n"
-                        "after|50\n"
-                        "against|40\n"
-                        "along|40\n"
-                        "alongside of|30\n"
-                        "among|30\n"
-                        "around|20\n"
-                        "at|10\n"
-                        "atop|1\n"
-                        "before|1\n"
-                        "behind|1\n"
-                        "beneath|1\n"
-                        "beside|1\n"
-                        "besides|1\n"
-                        "between|1\n"
-                        "beyond|1\n"
-                        "by|1\n"
-                        "despite|1\n"
-                        "during|1\n"
-                        "except|1\n"
-                        "for|1\n"
-                        "from|1\n"
-                        "in place of|1\n"
-                        "inside|1\n"
-                        "instead of|1\n"
-                        "into|1\n"
-                        "near|1\n"
-                        "of|1\n"
-                        "on|1\n"
-                        "outside|1\n"
-                        "over|1 \n"
-                        "past|1\n"
-                        "since|1\n"
-                        "through|1\n"
-                        "throughout|1\n"
-                        "to|1\n"
-                        "toward|1\n"
-                        "under|1\n"
-                        "until|1\n"
-                        "up|1 \n"
-                        "upon|1\n"
-                        "whithout|1\n"
-                        "with|1\n"
-                        "within|1\n"
-                        "END prepositions\n"
-                        "###\n"
-                        "# auxillaries\n"
-                        "##\n"
-                        "BEGIN auxillaries\n"
-                        "COUNT|18\n"
-                        "do|1\n"
-                        "may|1\n"
-                        "might|1\n"
-                        "shall|1\n"
-                        "will|1\n"
-                        "would|1\n"
-                        "can|1\n"
-                        "could|1\n"
-                        "should|1\n"
-                        "ought to|1\n"
-                        "must|1\n"
-                        "will have to|1\n"
-                        "shall have to|1\n"
-                        "could have to|1\n"
-                        "should have to|1\n"
-                        "must have to|1\n"
-                        "need to|1\n"
-                        "try to|1\n"
-                        "END auxiallaries\n"
-                        "###\n"
-                        "# terminators\n"
-                        "##\n"
-                        "BEGIN terminators\n"
-                        "COUNT|6\n"
-                        ".|50\n"
-                        ";|1\n"
-                        ":|1\n"
-                        "?|1\n"
-                        "!|1\n"
-                        "--|1\n"
-                        "END terminators\n"
-                        "###\n"
-                        "# adjectives\n"
-                        "##\n"
-                        "BEGIN adjectives\n"
-                        "COUNT|29\n"
-                        "special|20\n"
-                        "pending|20\n"
-                        "unusual|20\n"
-                        "express|20\n"
-                        "furious|1\n"
-                        "sly|1\n"
-                        "careful|1\n"
-                        "blithe|1\n"
-                        "quick|1\n"
-                        "fluffy|1\n"
-                        "slow|1\n"
-                        "quiet|1\n"
-                        "ruthless|1\n"
-                        "thin|1\n"
-                        "close|1\n"
-                        "dogged|1\n"
-                        "daring|1\n"
-                        "brave|1\n"
-                        "stealthy|1\n"
-                        "permanent|1\n"
-                        "enticing|1\n"
-                        "idle|1\n"
-                        "busy|1\n"
-                        "regular|50\n"
-                        "final|40\n"
-                        "ironic|40\n"
-                        "even|30\n"
-                        "bold|20\n"
-                        "silent|10\n"
-                        "END adjectives\n"
-                        "###\n"
-                        "# grammar\n"
-                        "# first level grammar. N=noun phrase, V=verb phrase,\n"
-                        "# P=prepositional phrase, T=setence termination\n"
-                        "##\n"
-                        "BEGIN grammar\n"
-                        "COUNT|5\n"
-                        "N V T|3\n"
-                        "N V P T|3\n"
-                        "N V N T|3\n"
-                        "N P V N T|1\n"
-                        "N P V P T|1\n"
-                        "END grammar\n"
-                        "###\n"
-                        "# NP\n"
-                        "# second level grammar. Noun phrases. N=noun, A=article, \n"
-                        "# J=adjective, D=adverb\n"
-                        "##\n"
-                        "BEGIN np\n"
-                        "COUNT|4\n"
-                        "N|10\n"
-                        "J N|20\n"
-                        "J, J N|10\n"
-                        "D J N|50\n"
-                        "END np\n"
-                        "###\n"
-                        "# VP\n"
-                        "# second level grammar. Verb phrases. V=verb, X=auxiallary, \n"
-                        "# D=adverb\n"
-                        "##\n"
-                        "BEGIN vp\n"
-                        "COUNT|4\n"
-                        "V|30\n"
-                        "X V|1\n"
-                        "V D|40\n"
-                        "X V D|1\n"
-                        "END vp\n"
-                        "###\n"
-                        "# Q13\n"
-                        "# Substitution parameters for Q13 \n"
-                        "##\n"
-                        "BEGIN Q13a\n"
-                        "COUNT|4\n"
-                        "special|20\n"
-                        "pending|20\n"
-                        "unusual|20\n"
-                        "express|20\n"
-                        "END Q13a\n"
-                        "BEGIN Q13b\n"
-                        "COUNT|4\n"
-                        "packages|40\n"
-                        "requests|40\n"
-                        "accounts|40\n"
-                        "deposits|40\n"
-                        "END Q13b";
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/dss.h b/velox/external/duckdb/tpch/dbgen/include/dbgen/dss.h
deleted file mode 100644
index 2f88ca1ac5642..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/include/dbgen/dss.h
+++ /dev/null
@@ -1,555 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-/*
- * general definitions and control information for the DSS code
- * generator; if it controls the data set, it's here
- */
-#ifndef DSS_H
-#define DSS_H
-
-#include "dbgen/config.h"
-
-#ifdef TPCH
-#define NAME "TPC-H"
-#endif
-#ifdef TPCR
-#define NAME "TPC-R"
-#endif
-#ifndef NAME
-#error Benchmark version must be defined in config.h
-#endif
-#define TPC "Transaction Processing Performance Council"
-#define C_DATES "1994 - 2010"
-
-#include "dbgen/config.h"
-#include "dbgen/shared.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-// some defines to avoid r warnings
-#define exit(status)
-#define printf(...)
-#define fprintf(...)
-
-#define NONE -1
-#define PART 0
-#define PSUPP 1
-#define SUPP 2
-#define CUST 3
-#define ORDER 4
-#define LINE 5
-#define ORDER_LINE 6
-#define PART_PSUPP 7
-#define NATION 8
-#define REGION 9
-#define UPDATE 10
-#define MAX_TABLE 11
-#define ONE_STREAM 1
-#define ADD_AT_END 2
-
-#ifdef MAX
-#undef MAX
-#endif
-#ifdef MIN
-#undef MIN
-#endif
-#define MAX(a, b) ((a > b) ? a : b)
-#define MIN(A, B) ((A) < (B) ? (A) : (B))
-
-#define INTERNAL_ERROR(p) // {fprintf(stderr,"%s", p);abort();}
-#define LN_CNT 4
-// static char lnoise[4] = {'|', '/', '-', '\\' };
-#define LIFENOISE(n, var) // if (verbose > 0) fprintf(stderr, "%c\b", lnoise[(var%LN_CNT)])
-
-#define MALLOC_CHECK(var)                                                                                              \
-	if ((var) == NULL) {                                                                                               \
-		fprintf(stderr, "Malloc failed at %s:%d\n", __FILE__, __LINE__);                                               \
-		exit(1);                                                                                                       \
-	}
-#define OPEN_CHECK(var, path)                                                                                          \
-	if ((var) == NULL) {                                                                                               \
-		fprintf(stderr, "Open failed for %s at %s:%d\n", path, __FILE__, __LINE__);                                    \
-		exit(1);                                                                                                       \
-	}
-#ifndef MAX_CHILDREN
-#define MAX_CHILDREN 1000
-#endif
-
-/*
- * macros that control sparse keys
- *
- * refer to Porting.Notes for a complete explanation
- */
-#ifndef BITS_PER_LONG
-#define BITS_PER_LONG 32
-#define MAX_LONG 0x7FFFFFFF
-#endif /* BITS_PER_LONG */
-#define SPARSE_BITS 2
-#define SPARSE_KEEP 3
-#define MK_SPARSE(key, seq) (((((key >> 3) << 2) | (seq & 0x0003)) << 3) | (key & 0x0007))
-
-#define RANDOM(tgt, lower, upper, seed) dss_random(&tgt, lower, upper, seed)
-#define RANDOM64(tgt, lower, upper, seed) dss_random64(&tgt, lower, upper, seed)
-
-typedef struct {
-	long weight;
-	char *text;
-} set_member;
-
-typedef struct {
-	int count;
-	int max;
-	set_member *list;
-	long *permute;
-} distribution;
-/*
- * some handy access functions
- */
-#define DIST_SIZE(d) d->count
-#define DIST_MEMBER(d, i) ((set_member *)((d)->list + i))->text
-#define DIST_PERMUTE(d, i) (d->permute[i])
-
-typedef struct {
-	const char *name;
-	const char *comment;
-	DSS_HUGE base;
-	int (*loader)();
-	long (*gen_seed)(int, int);
-	int child;
-	DSS_HUGE vtotal;
-} tdef;
-
-typedef struct SEED_T {
-	long table;
-	DSS_HUGE value;
-	DSS_HUGE usage;
-	DSS_HUGE boundary;
-#ifdef RNG_TEST
-	DSS_HUGE nCalls;
-#endif
-} seed_t;
-
-#define PROTO(s) s
-
-struct DBGenContext;
-
-/* bm_utils.c */
-const char *tpch_env_config PROTO((const char *var, const char *dflt));
-long yes_no PROTO((char *prompt));
-void tpch_a_rnd PROTO((int min, int max, seed_t *seed, char *dest));
-int tx_rnd PROTO((long min, long max, long column, char *tgt));
-long julian PROTO((long date));
-long unjulian PROTO((long date));
-long dssncasecmp PROTO((const char *s1, const char *s2, int n));
-long dsscasecmp PROTO((const char *s1, const char *s2));
-int pick_str PROTO((distribution * s, seed_t *seed, char *target));
-void agg_str PROTO((distribution * set, long count, seed_t *seed, char *dest));
-void read_dist PROTO((const char *path, const char *name, distribution *target));
-void embed_str PROTO((distribution * d, int min, int max, int stream, char *dest));
-#ifndef STDLIB_HAS_GETOPT
-int getopt PROTO((int arg_cnt, char **arg_vect, char *oprions));
-#endif /* STDLIB_HAS_GETOPT */
-DSS_HUGE set_state PROTO((int t, long scale, long procs, long step, DSS_HUGE *e, DBGenContext *ctx));
-
-/* rnd.c */
-DSS_HUGE NextRand PROTO((DSS_HUGE nSeed));
-DSS_HUGE UnifInt PROTO((DSS_HUGE nLow, DSS_HUGE nHigh, seed_t *seed));
-void dss_random(DSS_HUGE *tgt, DSS_HUGE min, DSS_HUGE max, seed_t *seed);
-void row_start(int t, DBGenContext *ctx);
-void row_stop_h(int t, DBGenContext *ctx);
-void dump_seeds_ds(int t, seed_t *seeds);
-
-/* text.c */
-#define MAX_GRAMMAR_LEN 12 /* max length of grammar component */
-#define MAX_SENT_LEN 256   /* max length of populated sentence */
-#define RNG_PER_SENT 27    /* max number of RNG calls per sentence */
-
-void init_text_pool PROTO((long bSize, DBGenContext *ctx));
-void free_text_pool PROTO(());
-
-void dbg_text PROTO((char *t, int min, int max, seed_t *seed));
-
-#ifdef DECLARER
-#define EXTERN
-#else
-#define EXTERN extern
-#endif /* DECLARER */
-
-EXTERN distribution nations;
-EXTERN distribution nations2;
-EXTERN distribution regions;
-EXTERN distribution o_priority_set;
-EXTERN distribution l_instruct_set;
-EXTERN distribution l_smode_set;
-EXTERN distribution l_category_set;
-EXTERN distribution l_rflag_set;
-EXTERN distribution c_mseg_set;
-EXTERN distribution colors;
-EXTERN distribution p_types_set;
-EXTERN distribution p_cntr_set;
-
-/* distributions that control text generation */
-EXTERN distribution articles;
-EXTERN distribution nouns;
-EXTERN distribution adjectives;
-EXTERN distribution adverbs;
-EXTERN distribution prepositions;
-EXTERN distribution verbs;
-EXTERN distribution terminators;
-EXTERN distribution auxillaries;
-EXTERN distribution np;
-EXTERN distribution vp;
-EXTERN distribution grammar;
-
-EXTERN int refresh;
-EXTERN int resume;
-EXTERN long verbose;
-EXTERN long force;
-EXTERN long updates;
-EXTERN long table;
-EXTERN long children;
-EXTERN int step;
-EXTERN int set_seeds;
-EXTERN char *d_path;
-
-/* added for segmented updates */
-EXTERN int insert_segments;
-EXTERN int delete_segments;
-EXTERN int insert_orders_segment;
-EXTERN int insert_lineitem_segment;
-EXTERN int delete_segment;
-
-/*****************************************************************
- ** table level defines use the following naming convention: t_ccc_xxx
- ** with: t, a table identifier
- **       ccc, a column identifier
- **       xxx, a limit type
- ****************************************************************
- */
-
-/*
- * defines which control the parts table
- */
-#define P_SIZE 126
-#define P_NAME_SCL 5
-#define P_MFG_TAG "Manufacturer#"
-#define P_MFG_FMT "%%s%%0%d%s"
-#define P_MFG_MIN 1
-#define P_MFG_MAX 5
-#define P_BRND_TAG "Brand#"
-#define P_BRND_FMT "%%s%%0%d%s"
-#define P_BRND_MIN 1
-#define P_BRND_MAX 5
-#define P_SIZE_MIN 1
-#define P_SIZE_MAX 50
-#define P_MCST_MIN 100
-#define P_MCST_MAX 99900
-#define P_MCST_SCL 100.0
-#define P_RCST_MIN 90000
-#define P_RCST_MAX 200000
-#define P_RCST_SCL 100.0
-/*
- * defines which control the suppliers table
- */
-#define S_SIZE 145
-#define S_NAME_TAG "Supplier#"
-#define S_NAME_FMT "%%s%%0%d%s"
-#define S_ABAL_MIN -99999
-#define S_ABAL_MAX 999999
-#define S_CMNT_MAX 101
-#define S_CMNT_BBB 10    /* number of BBB comments/SF */
-#define BBB_DEADBEATS 50 /* % that are complaints */
-#define BBB_BASE "Customer "
-#define BBB_COMPLAIN "Complaints"
-#define BBB_COMMEND "Recommends"
-#define BBB_CMNT_LEN 19
-#define BBB_BASE_LEN 9
-#define BBB_TYPE_LEN 10
-
-/*
- * defines which control the partsupp table
- */
-#define PS_SIZE 145
-#define PS_SKEY_MIN 0
-#define PS_SKEY_MAX ((ctx->tdefs[SUPP].base - 1) * ctx->scale_factor)
-#define PS_SCST_MIN 100
-#define PS_SCST_MAX 100000
-#define PS_QTY_MIN 1
-#define PS_QTY_MAX 9999
-/*
- * defines which control the customers table
- */
-#define C_SIZE 165
-#define C_NAME_TAG "Customer#"
-#define C_NAME_FMT "%%s%%0%d%s"
-#define C_MSEG_MAX 5
-#define C_ABAL_MIN -99999
-#define C_ABAL_MAX 999999
-/*
- * defines which control the order table
- */
-#define O_SIZE 109
-#define O_CKEY_MIN 1
-#define O_CKEY_MAX (ctx->tdefs[CUST].base * ctx->scale_factor)
-#define O_ODATE_MIN STARTDATE
-#define O_ODATE_MAX (STARTDATE + TOTDATE - (L_SDTE_MAX + L_RDTE_MAX) - 1)
-#define O_CLRK_TAG "Clerk#"
-#define O_CLRK_FMT "%%s%%0%d%s"
-#define O_CLRK_SCL 1000
-#define O_LCNT_MIN 1
-#define O_LCNT_MAX 7
-
-/*
- * defines which control the lineitem table
- */
-#define L_SIZE 144L
-#define L_QTY_MIN 1
-#define L_QTY_MAX 50
-#define L_TAX_MIN 0
-#define L_TAX_MAX 8
-#define L_DCNT_MIN 0
-#define L_DCNT_MAX 10
-#define L_PKEY_MIN 1
-#define L_PKEY_MAX (ctx->tdefs[PART].base * ctx->scale_factor)
-#define L_SDTE_MIN 1
-#define L_SDTE_MAX 121
-#define L_CDTE_MIN 30
-#define L_CDTE_MAX 90
-#define L_RDTE_MIN 1
-#define L_RDTE_MAX 30
-/*
- * defines which control the time table
- */
-#define T_SIZE 30
-#define T_START_DAY 3 /* wednesday ? */
-#define LEAP(y) ((!(y % 4) && (y % 100)) ? 1 : 0)
-
-/*******************************************************************
- *******************************************************************
- ***
- *** general or inter table defines
- ***
- *******************************************************************
- *******************************************************************/
-#define SUPP_PER_PART 4
-#define ORDERS_PER_CUST 10 /* sync this with CUST_MORTALITY */
-#define CUST_MORTALITY 3   /* portion with have no orders */
-#define NATIONS_MAX 90     /* limited by country codes in phone numbers */
-#define PHONE_FMT "%02d-%03d-%03d-%04d"
-#define STARTDATE 92001
-#define CURRENTDATE 95168
-#define ENDDATE 98365
-#define TOTDATE 2557
-#define UPD_PCT 10
-#define MAX_STREAM 47
-#define V_STR_LOW 0.4
-#define PENNIES 100 /* for scaled int money arithmetic */
-#define Q11_FRACTION (double)0.0001
-/*
- * max and min SF in GB; Larger SF will require changes to the build routines
- */
-#define MIN_SCALE 1.0
-#define MAX_SCALE 100000.0
-/*
- * beyond this point we need to allow for BCD calculations
- */
-#define MAX_32B_SCALE 1000.0
-#define LONG2HUGE(src, dst) *dst = (DSS_HUGE)src
-#define HUGE2LONG(src, dst) *dst = (long)src
-#define HUGE_SET(src, dst) *dst = *src
-#define HUGE_MUL(op1, op2) *op1 *= op2
-#define HUGE_DIV(op1, op2) *op1 /= op2
-#define HUGE_ADD(op1, op2, dst) *dst = *op1 + op2
-#define HUGE_SUB(op1, op2, dst) *dst = *op1 - op2
-#define HUGE_MOD(op1, op2) *op1 % op2
-#define HUGE_CMP(op1, op2) (*op1 == *op2) ? 0 : (*op1 < *op2) - 1 : 1
-
-/******** environmental variables and defaults ***************/
-#define DIST_TAG "DSS_DIST"     /* environment var to override ... */
-#define DIST_DFLT "dists.dss"   /* default file to hold distributions */
-#define PATH_TAG "DSS_PATH"     /* environment var to override ... */
-#define PATH_DFLT "."           /* default directory to hold tables */
-#define CONFIG_TAG "DSS_CONFIG" /* environment var to override ... */
-#define CONFIG_DFLT "."         /* default directory to config files */
-#define ADHOC_TAG "DSS_ADHOC"   /* environment var to override ... */
-#define ADHOC_DFLT "adhoc.dss"  /* default file name for adhoc vars */
-
-/******* output macros ********/
-#ifndef SEPARATOR
-#define SEPARATOR '|' /* field spearator for generated flat files */
-#endif
-/* Data type flags for a single print routine */
-#define DT_STR 0
-#ifndef MVS
-#define DT_VSTR DT_STR
-#else
-#define DT_VSTR 1
-#endif /* MVS */
-#define DT_INT 2
-#define DT_HUGE 3
-#define DT_KEY 4
-#define DT_MONEY 5
-#define DT_CHR 6
-
-int dbg_print(int dt, FILE *tgt, void *data, int len, int eol);
-#define PR_STR(f, str, len) dbg_print(DT_STR, f, (void *)str, len, 1)
-#define PR_VSTR(f, str, len) dbg_print(DT_VSTR, f, (void *)str, len, 1)
-#define PR_VSTR_LAST(f, str, len) dbg_print(DT_VSTR, f, (void *)str, len, 0)
-#define PR_INT(f, str) dbg_print(DT_INT, f, (void *)str, 0, 1)
-#define PR_HUGE(f, str) dbg_print(DT_HUGE, f, (void *)str, 0, 1)
-#define PR_HUGE_LAST(f, str) dbg_print(DT_HUGE, f, (void *)str, 0, 0)
-#define PR_KEY(f, str) dbg_print(DT_KEY, f, (void *)str, 0, -1)
-#define PR_MONEY(f, str) dbg_print(DT_MONEY, f, (void *)str, 0, 1)
-#define PR_CHR(f, str) dbg_print(DT_CHR, f, (void *)str, 0, 1)
-#define PR_STRT(fp)                  /* any line prep for a record goes here */
-#define PR_END(fp) fprintf(fp, "\n") /* finish the record here */
-#ifdef MDY_DATE
-#define PR_DATE(tgt, yr, mn, dy) sprintf(tgt, "%02d-%02d-19%02d", mn, dy, yr)
-#else
-#define PR_DATE(tgt, yr, mn, dy) sprintf(tgt, "19%02ld-%02ld-%02ld", yr, mn, dy)
-#endif /* DATE_FORMAT */
-
-/*
- * verification macros
- */
-#define VRF_STR(t, d)                                                                                                  \
-	{                                                                                                                  \
-		char *xx = d;                                                                                                  \
-		while (*xx)                                                                                                    \
-			ctx->tdefs[t].vtotal += *xx++;                                                                                  \
-	}
-#define VRF_INT(t, d) ctx->tdefs[t].vtotal += d
-#define VRF_HUGE(t, d) ctx->tdefs[t].vtotal = *((long *)&d) + *((long *)(&d + 1))
-/* assume float is a 64 bit quantity */
-#define VRF_MONEY(t, d) ctx->tdefs[t].vtotal = *((long *)&d) + *((long *)(&d + 1))
-#define VRF_CHR(t, d) ctx->tdefs[t].vtotal += d
-#define VRF_STRT(t)
-#define VRF_END(t)
-
-/*********** distribuitons currently defined *************/
-#define UNIFORM 0
-
-/*
- * seed indexes; used to separate the generation of individual columns
- */
-#define P_MFG_SD 0
-#define P_BRND_SD 1
-#define P_TYPE_SD 2
-#define P_SIZE_SD 3
-#define P_CNTR_SD 4
-#define P_RCST_SD 5
-#define PS_QTY_SD 7
-#define PS_SCST_SD 8
-#define O_SUPP_SD 10
-#define O_CLRK_SD 11
-#define O_ODATE_SD 13
-#define L_QTY_SD 14
-#define L_DCNT_SD 15
-#define L_TAX_SD 16
-#define L_SHIP_SD 17
-#define L_SMODE_SD 18
-#define L_PKEY_SD 19
-#define L_SKEY_SD 20
-#define L_SDTE_SD 21
-#define L_CDTE_SD 22
-#define L_RDTE_SD 23
-#define L_RFLG_SD 24
-#define C_NTRG_SD 27
-#define C_PHNE_SD 28
-#define C_ABAL_SD 29
-#define C_MSEG_SD 30
-#define S_NTRG_SD 33
-#define S_PHNE_SD 34
-#define S_ABAL_SD 35
-#define P_NAME_SD 37
-#define O_PRIO_SD 38
-#define HVAR_SD 39
-#define O_CKEY_SD 40
-#define N_CMNT_SD 41
-#define R_CMNT_SD 42
-#define O_LCNT_SD 43
-#define BBB_JNK_SD 44
-#define BBB_TYPE_SD 45
-#define BBB_CMNT_SD 46
-#define BBB_OFFSET_SD 47
-
-struct DBGenContext {
-  seed_t Seed[MAX_STREAM + 1] = {
-      {PART, 1, 0, 1}, /* P_MFG_SD     0 */
-      {PART, 46831694, 0, 1}, /* P_BRND_SD    1 */
-      {PART, 1841581359, 0, 1}, /* P_TYPE_SD    2 */
-      {PART, 1193163244, 0, 1}, /* P_SIZE_SD    3 */
-      {PART, 727633698, 0, 1}, /* P_CNTR_SD    4 */
-      {NONE, 933588178, 0, 1}, /* text pregeneration  5 */
-      {PART, 804159733, 0, 2}, /* P_CMNT_SD    6 */
-      {PSUPP, 1671059989, 0, SUPP_PER_PART}, /* PS_QTY_SD    7 */
-      {PSUPP, 1051288424, 0, SUPP_PER_PART}, /* PS_SCST_SD   8 */
-      {PSUPP, 1961692154, 0, SUPP_PER_PART * 2}, /* PS_CMNT_SD   9 */
-      {ORDER, 1227283347, 0, 1}, /* O_SUPP_SD    10 */
-      {ORDER, 1171034773, 0, 1}, /* O_CLRK_SD    11 */
-      {ORDER, 276090261, 0, 2}, /* O_CMNT_SD    12 */
-      {ORDER, 1066728069, 0, 1}, /* O_ODATE_SD   13 */
-      {LINE, 209208115, 0, O_LCNT_MAX}, /* L_QTY_SD     14 */
-      {LINE, 554590007, 0, O_LCNT_MAX}, /* L_DCNT_SD    15 */
-      {LINE, 721958466, 0, O_LCNT_MAX}, /* L_TAX_SD     16 */
-      {LINE, 1371272478, 0, O_LCNT_MAX}, /* L_SHIP_SD    17 */
-      {LINE, 675466456, 0, O_LCNT_MAX}, /* L_SMODE_SD   18 */
-      {LINE, 1808217256, 0, O_LCNT_MAX}, /* L_PKEY_SD    19 */
-      {LINE, 2095021727, 0, O_LCNT_MAX}, /* L_SKEY_SD    20 */
-      {LINE, 1769349045, 0, O_LCNT_MAX}, /* L_SDTE_SD    21 */
-      {LINE, 904914315, 0, O_LCNT_MAX}, /* L_CDTE_SD    22 */
-      {LINE, 373135028, 0, O_LCNT_MAX}, /* L_RDTE_SD    23 */
-      {LINE, 717419739, 0, O_LCNT_MAX}, /* L_RFLG_SD    24 */
-      {LINE, 1095462486, 0, O_LCNT_MAX * 2}, /* L_CMNT_SD    25 */
-      {CUST, 881155353, 0, 9}, /* C_ADDR_SD    26 */
-      {CUST, 1489529863, 0, 1}, /* C_NTRG_SD    27 */
-      {CUST, 1521138112, 0, 3}, /* C_PHNE_SD    28 */
-      {CUST, 298370230, 0, 1}, /* C_ABAL_SD    29 */
-      {CUST, 1140279430, 0, 1}, /* C_MSEG_SD    30 */
-      {CUST, 1335826707, 0, 2}, /* C_CMNT_SD    31 */
-      {SUPP, 706178559, 0, 9}, /* S_ADDR_SD    32 */
-      {SUPP, 110356601, 0, 1}, /* S_NTRG_SD    33 */
-      {SUPP, 884434366, 0, 3}, /* S_PHNE_SD    34 */
-      {SUPP, 962338209, 0, 1}, /* S_ABAL_SD    35 */
-      {SUPP, 1341315363, 0, 2}, /* S_CMNT_SD    36 */
-      {PART, 709314158, 0, 92}, /* P_NAME_SD    37 */
-      {ORDER, 591449447, 0, 1}, /* O_PRIO_SD    38 */
-      {LINE, 431918286, 0, 1}, /* HVAR_SD      39 */
-      {ORDER, 851767375, 0, 1}, /* O_CKEY_SD    40 */
-      {NATION, 606179079, 0, 2}, /* N_CMNT_SD    41 */
-      {REGION, 1500869201, 0, 2}, /* R_CMNT_SD    42 */
-      {ORDER, 1434868289, 0, 1}, /* O_LCNT_SD    43 */
-      {SUPP, 263032577, 0, 1}, /* BBB offset   44 */
-      {SUPP, 753643799, 0, 1}, /* BBB type     45 */
-      {SUPP, 202794285, 0, 1}, /* BBB comment  46 */
-      {SUPP, 715851524, 0, 1} /* BBB junk     47 */
-  };
-
-  static constexpr double dM = 2147483647.0;
-
-  tdef tdefs[10] = {
-      {"part.tbl", "part table", 200000, NULL, NULL, PSUPP, 0},
-      {"partsupp.tbl", "partsupplier table", 200000, NULL, NULL, NONE, 0},
-      {"supplier.tbl", "suppliers table", 10000, NULL, NULL, NONE, 0},
-      {"customer.tbl", "customers table", 150000, NULL, NULL, NONE, 0},
-      {"orders.tbl", "order table", 150000, NULL, NULL, LINE, 0},
-      {"lineitem.tbl", "lineitem table", 150000, NULL, NULL, NONE, 0},
-      {"orders.tbl", "orders/lineitem tables", 150000, NULL, NULL, LINE, 0},
-      {"part.tbl", "part/partsupplier tables", 200000, NULL, NULL, PSUPP, 0},
-      {"nation.tbl", "nation table", NATIONS_MAX, NULL, NULL, NONE, 0},
-      {"region.tbl", "region table", NATIONS_MAX, NULL, NULL, NONE, 0},
-  };
-
-  long scale_factor = 1;
-};
-
-#endif /* DSS_H */
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/dsstypes.h b/velox/external/duckdb/tpch/dbgen/include/dbgen/dsstypes.h
deleted file mode 100644
index 52c9f82accf72..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/include/dbgen/dsstypes.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-/*
- * general definitions and control information for the DSS data types
- * and function prototypes
- */
-
-#pragma once
-
-/*
- * typedefs
- */
-typedef struct {
-	DSS_HUGE custkey;
-	char name[C_NAME_LEN + 3];
-	char address[C_ADDR_MAX + 1];
-	int alen;
-	DSS_HUGE nation_code;
-	char phone[PHONE_LEN + 1];
-	DSS_HUGE acctbal;
-	char mktsegment[MAXAGG_LEN + 1];
-	char comment[C_CMNT_MAX + 1];
-	int clen;
-} customer_t;
-/* customers.c */
-long mk_cust PROTO((DSS_HUGE n_cust, customer_t *c, DBGenContext *ctx));
-int pr_cust PROTO((customer_t * c, int mode));
-int ld_cust PROTO((customer_t * c, int mode));
-
-typedef struct {
-	DSS_HUGE okey;
-	DSS_HUGE partkey;
-	DSS_HUGE suppkey;
-	DSS_HUGE lcnt;
-	DSS_HUGE quantity;
-	DSS_HUGE eprice;
-	DSS_HUGE discount;
-	DSS_HUGE tax;
-	char rflag[1];
-	char lstatus[1];
-	char cdate[DATE_LEN];
-	char sdate[DATE_LEN];
-	char rdate[DATE_LEN];
-	char shipinstruct[MAXAGG_LEN + 1];
-	char shipmode[MAXAGG_LEN + 1];
-	char comment[L_CMNT_MAX + 1];
-	int clen;
-} line_t;
-
-typedef struct {
-	DSS_HUGE okey;
-	DSS_HUGE custkey;
-	char orderstatus;
-	DSS_HUGE totalprice;
-	char odate[DATE_LEN];
-	char opriority[MAXAGG_LEN + 1];
-	char clerk[O_CLRK_LEN + 1];
-	long spriority;
-	DSS_HUGE lines;
-	char comment[O_CMNT_MAX + 1];
-	int clen;
-	line_t l[O_LCNT_MAX];
-} order_t;
-
-/* order.c */
-long mk_order PROTO((DSS_HUGE index, order_t *o, DBGenContext *ctx, long upd_num));
-int pr_order PROTO((order_t * o, int mode));
-int ld_order PROTO((order_t * o, int mode));
-void mk_sparse PROTO((DSS_HUGE index, DSS_HUGE *ok, long seq));
-
-typedef struct {
-	DSS_HUGE partkey;
-	DSS_HUGE suppkey;
-	DSS_HUGE qty;
-	DSS_HUGE scost;
-	char comment[PS_CMNT_MAX + 1];
-	int clen;
-} partsupp_t;
-
-typedef struct {
-	DSS_HUGE partkey;
-	char name[P_NAME_LEN + 1];
-	int nlen;
-	char mfgr[P_MFG_LEN + 1];
-	char brand[P_BRND_LEN + 1];
-	char type[P_TYPE_LEN + 1];
-	int tlen;
-	DSS_HUGE size;
-	char container[P_CNTR_LEN + 1];
-	DSS_HUGE retailprice;
-	char comment[P_CMNT_MAX + 1];
-	int clen;
-	partsupp_t s[SUPP_PER_PART];
-} part_t;
-
-/* parts.c */
-long mk_part PROTO((DSS_HUGE index, part_t *p, DBGenContext *ctx));
-int pr_part PROTO((part_t * part, int mode));
-int ld_part PROTO((part_t * part, int mode));
-
-typedef struct {
-	DSS_HUGE suppkey;
-	char name[S_NAME_LEN + 1];
-	char address[S_ADDR_MAX + 1];
-	int alen;
-	DSS_HUGE nation_code;
-	char phone[PHONE_LEN + 1];
-	DSS_HUGE acctbal;
-	char comment[S_CMNT_MAX + 1];
-	int clen;
-} supplier_t;
-/* supplier.c */
-long mk_supp PROTO((DSS_HUGE index, supplier_t *s, DBGenContext *ctx));
-int pr_supp PROTO((supplier_t * supp, int mode));
-int ld_supp PROTO((supplier_t * supp, int mode));
-
-typedef struct {
-	DSS_HUGE timekey;
-	char alpha[DATE_LEN];
-	long year;
-	long month;
-	long week;
-	long day;
-} dss_time_t;
-
-/* time.c */
-long mk_time PROTO((DSS_HUGE h, dss_time_t *t));
-
-/*
- * this assumes that N_CMNT_LEN >= R_CMNT_LEN
- */
-typedef struct {
-	DSS_HUGE code;
-	char *text;
-	long join;
-	char comment[N_CMNT_MAX + 1];
-	int clen;
-} code_t;
-
-/* code table */
-int mk_nation PROTO((DSS_HUGE i, code_t *c, DBGenContext *ctx));
-int pr_nation PROTO((code_t * c, int mode));
-int ld_nation PROTO((code_t * c, int mode));
-int mk_region PROTO((DSS_HUGE i, code_t *c, DBGenContext *ctx));
-int pr_region PROTO((code_t * c, int mode));
-int ld_region PROTO((code_t * c, int mode));
-
-/* speed seed - advances seeds `skip_count` times */
-long sd_nation(int child, DSS_HUGE skip_count, DBGenContext *ctx);
-long sd_region(int child, DSS_HUGE skip_coun, DBGenContext *ctx);
-long sd_order(int child, DSS_HUGE skip_count, DBGenContext *ctx);
-long sd_line(int child, DSS_HUGE skip_count, DBGenContext *ctx);
-long sd_supp(int child, DSS_HUGE skip_count, DBGenContext *ctx);
-long sd_part(int child, DSS_HUGE skip_count, DBGenContext *ctx);
-long sd_psupp(int child, DSS_HUGE skip_count, DBGenContext *ctx);
-long sd_cust(int child, DSS_HUGE skip_count, DBGenContext *ctx);
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/permute.h b/velox/external/duckdb/tpch/dbgen/include/dbgen/permute.h
deleted file mode 100644
index 523557b9a4433..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/include/dbgen/permute.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-long permutation[41][22] = {{14, 2, 9, 20, 6, 17, 18, 8, 21, 13, 3, 22, 16, 4, 11, 15, 1, 10, 19, 5, 7, 12},
-                            {21, 3, 18, 5, 11, 7, 6, 20, 17, 12, 16, 15, 13, 10, 2, 8, 14, 19, 9, 22, 1, 4},
-                            {6, 17, 14, 16, 19, 10, 9, 2, 15, 8, 5, 22, 12, 7, 13, 18, 1, 4, 20, 3, 11, 21},
-                            {8, 5, 4, 6, 17, 7, 1, 18, 22, 14, 9, 10, 15, 11, 20, 2, 21, 19, 13, 16, 12, 3},
-                            {5, 21, 14, 19, 15, 17, 12, 6, 4, 9, 8, 16, 11, 2, 10, 18, 1, 13, 7, 22, 3, 20},
-                            {21, 15, 4, 6, 7, 16, 19, 18, 14, 22, 11, 13, 3, 1, 2, 5, 8, 20, 12, 17, 10, 9},
-                            {10, 3, 15, 13, 6, 8, 9, 7, 4, 11, 22, 18, 12, 1, 5, 16, 2, 14, 19, 20, 17, 21},
-                            {18, 8, 20, 21, 2, 4, 22, 17, 1, 11, 9, 19, 3, 13, 5, 7, 10, 16, 6, 14, 15, 12},
-                            {19, 1, 15, 17, 5, 8, 9, 12, 14, 7, 4, 3, 20, 16, 6, 22, 10, 13, 2, 21, 18, 11},
-                            {8, 13, 2, 20, 17, 3, 6, 21, 18, 11, 19, 10, 15, 4, 22, 1, 7, 12, 9, 14, 5, 16},
-                            {6, 15, 18, 17, 12, 1, 7, 2, 22, 13, 21, 10, 14, 9, 3, 16, 20, 19, 11, 4, 8, 5},
-                            {15, 14, 18, 17, 10, 20, 16, 11, 1, 8, 4, 22, 5, 12, 3, 9, 21, 2, 13, 6, 19, 7},
-                            {1, 7, 16, 17, 18, 22, 12, 6, 8, 9, 11, 4, 2, 5, 20, 21, 13, 10, 19, 3, 14, 15},
-                            {21, 17, 7, 3, 1, 10, 12, 22, 9, 16, 6, 11, 2, 4, 5, 14, 8, 20, 13, 18, 15, 19},
-                            {2, 9, 5, 4, 18, 1, 20, 15, 16, 17, 7, 21, 13, 14, 19, 8, 22, 11, 10, 3, 12, 6},
-                            {16, 9, 17, 8, 14, 11, 10, 12, 6, 21, 7, 3, 15, 5, 22, 20, 1, 13, 19, 2, 4, 18},
-                            {1, 3, 6, 5, 2, 16, 14, 22, 17, 20, 4, 9, 10, 11, 15, 8, 12, 19, 18, 13, 7, 21},
-                            {3, 16, 5, 11, 21, 9, 2, 15, 10, 18, 17, 7, 8, 19, 14, 13, 1, 4, 22, 20, 6, 12},
-                            {14, 4, 13, 5, 21, 11, 8, 6, 3, 17, 2, 20, 1, 19, 10, 9, 12, 18, 15, 7, 22, 16},
-                            {4, 12, 22, 14, 5, 15, 16, 2, 8, 10, 17, 9, 21, 7, 3, 6, 13, 18, 11, 20, 19, 1},
-                            {16, 15, 14, 13, 4, 22, 18, 19, 7, 1, 12, 17, 5, 10, 20, 3, 9, 21, 11, 2, 6, 8},
-                            {20, 14, 21, 12, 15, 17, 4, 19, 13, 10, 11, 1, 16, 5, 18, 7, 8, 22, 9, 6, 3, 2},
-                            {16, 14, 13, 2, 21, 10, 11, 4, 1, 22, 18, 12, 19, 5, 7, 8, 6, 3, 15, 20, 9, 17},
-                            {18, 15, 9, 14, 12, 2, 8, 11, 22, 21, 16, 1, 6, 17, 5, 10, 19, 4, 20, 13, 3, 7},
-                            {7, 3, 10, 14, 13, 21, 18, 6, 20, 4, 9, 8, 22, 15, 2, 1, 5, 12, 19, 17, 11, 16},
-                            {18, 1, 13, 7, 16, 10, 14, 2, 19, 5, 21, 11, 22, 15, 8, 17, 20, 3, 4, 12, 6, 9},
-                            {13, 2, 22, 5, 11, 21, 20, 14, 7, 10, 4, 9, 19, 18, 6, 3, 1, 8, 15, 12, 17, 16},
-                            {14, 17, 21, 8, 2, 9, 6, 4, 5, 13, 22, 7, 15, 3, 1, 18, 16, 11, 10, 12, 20, 19},
-                            {10, 22, 1, 12, 13, 18, 21, 20, 2, 14, 16, 7, 15, 3, 4, 17, 5, 19, 6, 8, 9, 11},
-                            {10, 8, 9, 18, 12, 6, 1, 5, 20, 11, 17, 22, 16, 3, 13, 2, 15, 21, 14, 19, 7, 4},
-                            {7, 17, 22, 5, 3, 10, 13, 18, 9, 1, 14, 15, 21, 19, 16, 12, 8, 6, 11, 20, 4, 2},
-                            {2, 9, 21, 3, 4, 7, 1, 11, 16, 5, 20, 19, 18, 8, 17, 13, 10, 12, 15, 6, 14, 22},
-                            {15, 12, 8, 4, 22, 13, 16, 17, 18, 3, 7, 5, 6, 1, 9, 11, 21, 10, 14, 20, 19, 2},
-                            {15, 16, 2, 11, 17, 7, 5, 14, 20, 4, 21, 3, 10, 9, 12, 8, 13, 6, 18, 19, 22, 1},
-                            {1, 13, 11, 3, 4, 21, 6, 14, 15, 22, 18, 9, 7, 5, 10, 20, 12, 16, 17, 8, 19, 2},
-                            {14, 17, 22, 20, 8, 16, 5, 10, 1, 13, 2, 21, 12, 9, 4, 18, 3, 7, 6, 19, 15, 11},
-                            {9, 17, 7, 4, 5, 13, 21, 18, 11, 3, 22, 1, 6, 16, 20, 14, 15, 10, 8, 2, 12, 19},
-                            {13, 14, 5, 22, 19, 11, 9, 6, 18, 15, 8, 10, 7, 4, 17, 16, 3, 1, 12, 2, 21, 20},
-                            {20, 5, 4, 14, 11, 1, 6, 16, 8, 22, 7, 3, 2, 12, 21, 19, 17, 13, 10, 15, 18, 9},
-                            {3, 7, 14, 15, 6, 5, 21, 20, 18, 10, 4, 16, 19, 1, 13, 9, 8, 17, 11, 12, 22, 2},
-                            {13, 15, 17, 1, 22, 11, 3, 4, 7, 20, 14, 21, 9, 8, 2, 18, 16, 6, 10, 12, 5, 19}};
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/rng64.h b/velox/external/duckdb/tpch/dbgen/include/dbgen/rng64.h
deleted file mode 100644
index 8e7890a5d5b0c..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/include/dbgen/rng64.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-#pragma once
-
-#include "dbgen/config.h"
-#include "dbgen/dss.h"
-
-DSS_HUGE AdvanceRand64(DSS_HUGE nSeed, DSS_HUGE nCount);
-void dss_random64(DSS_HUGE *tgt, DSS_HUGE nLow, DSS_HUGE nHigh, seed_t *seed);
-DSS_HUGE NextRand64(DSS_HUGE nSeed);
diff --git a/velox/external/duckdb/tpch/dbgen/include/tpch_constants.hpp b/velox/external/duckdb/tpch/dbgen/include/tpch_constants.hpp
deleted file mode 100644
index b434611dfa2fe..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/include/tpch_constants.hpp
+++ /dev/null
@@ -1,189 +0,0 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED BY generate_csv_header.py */
-
-#pragma once
-
-const int TPCH_QUERIES_COUNT = 22;
-const uint8_t TPCH_QUERIES_q01[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 108, 95, 114, 101, 116, 117, 114, 110, 102, 108, 97, 103, 44, 10, 32, 32, 32, 32, 108, 95, 108, 105, 110, 101, 115, 116, 97, 116, 117, 115, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 41, 32, 65, 83, 32, 115, 117, 109, 95, 113, 116, 121, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 41, 32, 65, 83, 32, 115, 117, 109, 95, 98, 97, 115, 101, 95, 112, 114, 105, 99, 101, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 41, 32, 65, 83, 32, 115, 117, 109, 95, 100, 105, 115, 99, 95, 112, 114, 105, 99, 101, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 32, 42, 32, 40, 49, 32, 43, 32, 108, 95, 116, 97, 120, 41, 41, 32, 65, 83, 32, 115, 117, 109, 95, 99, 104, 97, 114, 103, 101, 44, 10, 32, 32, 32, 32, 97, 118, 103, 40, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 41, 32, 65, 83, 32, 97, 118, 103, 95, 113, 116, 121, 44, 10, 32, 32, 32, 32, 97, 118, 103, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 41, 32, 65, 83, 32, 97, 118, 103, 95, 112, 114, 105, 99, 101, 44, 10, 32, 32, 32, 32, 97, 118, 103, 40, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 32, 65, 83, 32, 97, 118, 103, 95, 100, 105, 115, 99, 44, 10, 32, 32, 32, 32, 99, 111, 117, 110, 116, 40, 42, 41, 32, 65, 83, 32, 99, 111, 117, 110, 116, 95, 111, 114, 100, 101, 114, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 60, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 56, 45, 48, 57, 45, 48, 50, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 108, 95, 114, 101, 116, 117, 114, 110, 102, 108, 97, 103, 44, 10, 32, 32, 32, 32, 108, 95, 108, 105, 110, 101, 115, 116, 97, 116, 117, 115, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 108, 95, 114, 101, 116, 117, 114, 110, 102, 108, 97, 103, 44, 10, 32, 32, 32, 32, 108, 95, 108, 105, 110, 101, 115, 116, 97, 116, 117, 115, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q02[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 115, 95, 97, 99, 99, 116, 98, 97, 108, 44, 10, 32, 32, 32, 32, 115, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 110, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 44, 10, 32, 32, 32, 32, 112, 95, 109, 102, 103, 114, 44, 10, 32, 32, 32, 32, 115, 95, 97, 100, 100, 114, 101, 115, 115, 44, 10, 32, 32, 32, 32, 115, 95, 112, 104, 111, 110, 101, 44, 10, 32, 32, 32, 32, 115, 95, 99, 111, 109, 109, 101, 110, 116, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 112, 97, 114, 116, 44, 10, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 112, 97, 114, 116, 115, 117, 112, 112, 44, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 114, 101, 103, 105, 111, 110, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 115, 105, 122, 101, 32, 61, 32, 49, 53, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 116, 121, 112, 101, 32, 76, 73, 75, 69, 32, 39, 37, 66, 82, 65, 83, 83, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 110, 95, 114, 101, 103, 105, 111, 110, 107, 101, 121, 32, 61, 32, 114, 95, 114, 101, 103, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 114, 95, 110, 97, 109, 101, 32, 61, 32, 39, 69, 85, 82, 79, 80, 69, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 115, 95, 115, 117, 112, 112, 108, 121, 99, 111, 115, 116, 32, 61, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 109, 105, 110, 40, 112, 115, 95, 115, 117, 112, 112, 108, 121, 99, 111, 115, 116, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 97, 114, 116, 115, 117, 112, 112, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 114, 101, 103, 105, 111, 110, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 110, 95, 114, 101, 103, 105, 111, 110, 107, 101, 121, 32, 61, 32, 114, 95, 114, 101, 103, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 114, 95, 110, 97, 109, 101, 32, 61, 32, 39, 69, 85, 82, 79, 80, 69, 39, 41, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 115, 95, 97, 99, 99, 116, 98, 97, 108, 32, 68, 69, 83, 67, 44, 10, 32, 32, 32, 32, 110, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 115, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 10, 76, 73, 77, 73, 84, 32, 49, 48, 48, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q03[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 41, 32, 65, 83, 32, 114, 101, 118, 101, 110, 117, 101, 44, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 44, 10, 32, 32, 32, 32, 111, 95, 115, 104, 105, 112, 112, 114, 105, 111, 114, 105, 116, 121, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 44, 10, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 99, 95, 109, 107, 116, 115, 101, 103, 109, 101, 110, 116, 32, 61, 32, 39, 66, 85, 73, 76, 68, 73, 78, 71, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 32, 61, 32, 111, 95, 99, 117, 115, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 48, 51, 45, 49, 53, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 62, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 48, 51, 45, 49, 53, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 44, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 44, 10, 32, 32, 32, 32, 111, 95, 115, 104, 105, 112, 112, 114, 105, 111, 114, 105, 116, 121, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 114, 101, 118, 101, 110, 117, 101, 32, 68, 69, 83, 67, 44, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 10, 76, 73, 77, 73, 84, 32, 49, 48, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q04[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 44, 10, 32, 32, 32, 32, 99, 111, 117, 110, 116, 40, 42, 41, 32, 65, 83, 32, 111, 114, 100, 101, 114, 95, 99, 111, 117, 110, 116, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 32, 62, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 51, 45, 48, 55, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 51, 45, 49, 48, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 69, 88, 73, 83, 84, 83, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 99, 111, 109, 109, 105, 116, 100, 97, 116, 101, 32, 60, 32, 108, 95, 114, 101, 99, 101, 105, 112, 116, 100, 97, 116, 101, 41, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q05[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 110, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 41, 32, 65, 83, 32, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 44, 10, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 44, 10, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 114, 101, 103, 105, 111, 110, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 32, 61, 32, 111, 95, 99, 117, 115, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 99, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 110, 95, 114, 101, 103, 105, 111, 110, 107, 101, 121, 32, 61, 32, 114, 95, 114, 101, 103, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 114, 95, 110, 97, 109, 101, 32, 61, 32, 39, 65, 83, 73, 65, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 32, 62, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 52, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 110, 95, 110, 97, 109, 101, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 114, 101, 118, 101, 110, 117, 101, 32, 68, 69, 83, 67, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q06[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 32, 65, 83, 32, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 62, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 52, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 32, 66, 69, 84, 87, 69, 69, 78, 32, 48, 46, 48, 53, 10, 32, 32, 32, 32, 65, 78, 68, 32, 48, 46, 48, 55, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 60, 32, 50, 52, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q07[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 115, 117, 112, 112, 95, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 99, 117, 115, 116, 95, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 108, 95, 121, 101, 97, 114, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 118, 111, 108, 117, 109, 101, 41, 32, 65, 83, 32, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 79, 77, 32, 40, 10, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 49, 46, 110, 95, 110, 97, 109, 101, 32, 65, 83, 32, 115, 117, 112, 112, 95, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 50, 46, 110, 95, 110, 97, 109, 101, 32, 65, 83, 32, 99, 117, 115, 116, 95, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 101, 120, 116, 114, 97, 99, 116, 40, 121, 101, 97, 114, 32, 70, 82, 79, 77, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 41, 32, 65, 83, 32, 108, 95, 121, 101, 97, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 32, 65, 83, 32, 118, 111, 108, 117, 109, 101, 10, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 32, 110, 49, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 32, 110, 50, 10, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 108, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 32, 61, 32, 111, 95, 99, 117, 115, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 49, 46, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 99, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 50, 46, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 40, 40, 110, 49, 46, 110, 95, 110, 97, 109, 101, 32, 61, 32, 39, 70, 82, 65, 78, 67, 69, 39, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 110, 50, 46, 110, 95, 110, 97, 109, 101, 32, 61, 32, 39, 71, 69, 82, 77, 65, 78, 89, 39, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 79, 82, 32, 40, 110, 49, 46, 110, 95, 110, 97, 109, 101, 32, 61, 32, 39, 71, 69, 82, 77, 65, 78, 89, 39, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 110, 50, 46, 110, 95, 110, 97, 109, 101, 32, 61, 32, 39, 70, 82, 65, 78, 67, 69, 39, 41, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 66, 69, 84, 87, 69, 69, 78, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 54, 45, 49, 50, 45, 51, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 41, 32, 65, 83, 32, 115, 104, 105, 112, 112, 105, 110, 103, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 115, 117, 112, 112, 95, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 99, 117, 115, 116, 95, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 108, 95, 121, 101, 97, 114, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 115, 117, 112, 112, 95, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 99, 117, 115, 116, 95, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 108, 95, 121, 101, 97, 114, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q08[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 111, 95, 121, 101, 97, 114, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 67, 65, 83, 69, 32, 87, 72, 69, 78, 32, 110, 97, 116, 105, 111, 110, 32, 61, 32, 39, 66, 82, 65, 90, 73, 76, 39, 32, 84, 72, 69, 78, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 118, 111, 108, 117, 109, 101, 10, 32, 32, 32, 32, 32, 32, 32, 32, 69, 76, 83, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 69, 78, 68, 41, 32, 47, 32, 115, 117, 109, 40, 118, 111, 108, 117, 109, 101, 41, 32, 65, 83, 32, 109, 107, 116, 95, 115, 104, 97, 114, 101, 10, 70, 82, 79, 77, 32, 40, 10, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 101, 120, 116, 114, 97, 99, 116, 40, 121, 101, 97, 114, 32, 70, 82, 79, 77, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 41, 32, 65, 83, 32, 111, 95, 121, 101, 97, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 32, 65, 83, 32, 118, 111, 108, 117, 109, 101, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 50, 46, 110, 95, 110, 97, 109, 101, 32, 65, 83, 32, 110, 97, 116, 105, 111, 110, 10, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 112, 97, 114, 116, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 32, 110, 49, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 32, 110, 50, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 114, 101, 103, 105, 111, 110, 10, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 108, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 99, 117, 115, 116, 107, 101, 121, 32, 61, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 99, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 49, 46, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 110, 49, 46, 110, 95, 114, 101, 103, 105, 111, 110, 107, 101, 121, 32, 61, 32, 114, 95, 114, 101, 103, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 114, 95, 110, 97, 109, 101, 32, 61, 32, 39, 65, 77, 69, 82, 73, 67, 65, 39, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 50, 46, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 32, 66, 69, 84, 87, 69, 69, 78, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 54, 45, 49, 50, 45, 51, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 116, 121, 112, 101, 32, 61, 32, 39, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 39, 41, 32, 65, 83, 32, 97, 108, 108, 95, 110, 97, 116, 105, 111, 110, 115, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 111, 95, 121, 101, 97, 114, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 111, 95, 121, 101, 97, 114, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q09[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 111, 95, 121, 101, 97, 114, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 97, 109, 111, 117, 110, 116, 41, 32, 65, 83, 32, 115, 117, 109, 95, 112, 114, 111, 102, 105, 116, 10, 70, 82, 79, 77, 32, 40, 10, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 95, 110, 97, 109, 101, 32, 65, 83, 32, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 101, 120, 116, 114, 97, 99, 116, 40, 121, 101, 97, 114, 32, 70, 82, 79, 77, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 41, 32, 65, 83, 32, 111, 95, 121, 101, 97, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 32, 45, 32, 112, 115, 95, 115, 117, 112, 112, 108, 121, 99, 111, 115, 116, 32, 42, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 65, 83, 32, 97, 109, 111, 117, 110, 116, 10, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 112, 97, 114, 116, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 112, 97, 114, 116, 115, 117, 112, 112, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 10, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 108, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 108, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 110, 97, 109, 101, 32, 76, 73, 75, 69, 32, 39, 37, 103, 114, 101, 101, 110, 37, 39, 41, 32, 65, 83, 32, 112, 114, 111, 102, 105, 116, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 111, 95, 121, 101, 97, 114, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 44, 10, 32, 32, 32, 32, 111, 95, 121, 101, 97, 114, 32, 68, 69, 83, 67, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q10[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 44, 10, 32, 32, 32, 32, 99, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 41, 32, 65, 83, 32, 114, 101, 118, 101, 110, 117, 101, 44, 10, 32, 32, 32, 32, 99, 95, 97, 99, 99, 116, 98, 97, 108, 44, 10, 32, 32, 32, 32, 110, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 99, 95, 97, 100, 100, 114, 101, 115, 115, 44, 10, 32, 32, 32, 32, 99, 95, 112, 104, 111, 110, 101, 44, 10, 32, 32, 32, 32, 99, 95, 99, 111, 109, 109, 101, 110, 116, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 44, 10, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 44, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 32, 61, 32, 111, 95, 99, 117, 115, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 32, 62, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 51, 45, 49, 48, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 52, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 114, 101, 116, 117, 114, 110, 102, 108, 97, 103, 32, 61, 32, 39, 82, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 99, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 44, 10, 32, 32, 32, 32, 99, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 99, 95, 97, 99, 99, 116, 98, 97, 108, 44, 10, 32, 32, 32, 32, 99, 95, 112, 104, 111, 110, 101, 44, 10, 32, 32, 32, 32, 110, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 99, 95, 97, 100, 100, 114, 101, 115, 115, 44, 10, 32, 32, 32, 32, 99, 95, 99, 111, 109, 109, 101, 110, 116, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 114, 101, 118, 101, 110, 117, 101, 32, 68, 69, 83, 67, 10, 76, 73, 77, 73, 84, 32, 50, 48, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q11[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 112, 115, 95, 115, 117, 112, 112, 108, 121, 99, 111, 115, 116, 32, 42, 32, 112, 115, 95, 97, 118, 97, 105, 108, 113, 116, 121, 41, 32, 65, 83, 32, 118, 97, 108, 117, 101, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 112, 97, 114, 116, 115, 117, 112, 112, 44, 10, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 110, 95, 110, 97, 109, 101, 32, 61, 32, 39, 71, 69, 82, 77, 65, 78, 89, 39, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 10, 72, 65, 86, 73, 78, 71, 10, 32, 32, 32, 32, 115, 117, 109, 40, 112, 115, 95, 115, 117, 112, 112, 108, 121, 99, 111, 115, 116, 32, 42, 32, 112, 115, 95, 97, 118, 97, 105, 108, 113, 116, 121, 41, 32, 62, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 109, 40, 112, 115, 95, 115, 117, 112, 112, 108, 121, 99, 111, 115, 116, 32, 42, 32, 112, 115, 95, 97, 118, 97, 105, 108, 113, 116, 121, 41, 32, 42, 32, 48, 46, 48, 48, 48, 49, 48, 48, 48, 48, 48, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 97, 114, 116, 115, 117, 112, 112, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 110, 95, 110, 97, 109, 101, 32, 61, 32, 39, 71, 69, 82, 77, 65, 78, 89, 39, 41, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 118, 97, 108, 117, 101, 32, 68, 69, 83, 67, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q12[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 67, 65, 83, 69, 32, 87, 72, 69, 78, 32, 111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 32, 61, 32, 39, 49, 45, 85, 82, 71, 69, 78, 84, 39, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 79, 82, 32, 111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 32, 61, 32, 39, 50, 45, 72, 73, 71, 72, 39, 32, 84, 72, 69, 78, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 49, 10, 32, 32, 32, 32, 32, 32, 32, 32, 69, 76, 83, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 69, 78, 68, 41, 32, 65, 83, 32, 104, 105, 103, 104, 95, 108, 105, 110, 101, 95, 99, 111, 117, 110, 116, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 67, 65, 83, 69, 32, 87, 72, 69, 78, 32, 111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 32, 60, 62, 32, 39, 49, 45, 85, 82, 71, 69, 78, 84, 39, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 32, 60, 62, 32, 39, 50, 45, 72, 73, 71, 72, 39, 32, 84, 72, 69, 78, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 49, 10, 32, 32, 32, 32, 32, 32, 32, 32, 69, 76, 83, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 69, 78, 68, 41, 32, 65, 83, 32, 108, 111, 119, 95, 108, 105, 110, 101, 95, 99, 111, 117, 110, 116, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 32, 73, 78, 32, 40, 39, 77, 65, 73, 76, 39, 44, 32, 39, 83, 72, 73, 80, 39, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 99, 111, 109, 109, 105, 116, 100, 97, 116, 101, 32, 60, 32, 108, 95, 114, 101, 99, 101, 105, 112, 116, 100, 97, 116, 101, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 60, 32, 108, 95, 99, 111, 109, 109, 105, 116, 100, 97, 116, 101, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 114, 101, 99, 101, 105, 112, 116, 100, 97, 116, 101, 32, 62, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 52, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 114, 101, 99, 101, 105, 112, 116, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q13[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 99, 95, 99, 111, 117, 110, 116, 44, 10, 32, 32, 32, 32, 99, 111, 117, 110, 116, 40, 42, 41, 32, 65, 83, 32, 99, 117, 115, 116, 100, 105, 115, 116, 10, 70, 82, 79, 77, 32, 40, 10, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 111, 117, 110, 116, 40, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 41, 10, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 10, 32, 32, 32, 32, 76, 69, 70, 84, 32, 79, 85, 84, 69, 82, 32, 74, 79, 73, 78, 32, 111, 114, 100, 101, 114, 115, 32, 79, 78, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 32, 61, 32, 111, 95, 99, 117, 115, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 99, 111, 109, 109, 101, 110, 116, 32, 78, 79, 84, 32, 76, 73, 75, 69, 32, 39, 37, 115, 112, 101, 99, 105, 97, 108, 37, 114, 101, 113, 117, 101, 115, 116, 115, 37, 39, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 41, 32, 65, 83, 32, 99, 95, 111, 114, 100, 101, 114, 115, 32, 40, 99, 95, 99, 117, 115, 116, 107, 101, 121, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 95, 99, 111, 117, 110, 116, 41, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 99, 95, 99, 111, 117, 110, 116, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 99, 117, 115, 116, 100, 105, 115, 116, 32, 68, 69, 83, 67, 44, 10, 32, 32, 32, 32, 99, 95, 99, 111, 117, 110, 116, 32, 68, 69, 83, 67, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q14[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 49, 48, 48, 46, 48, 48, 32, 42, 32, 115, 117, 109, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 67, 65, 83, 69, 32, 87, 72, 69, 78, 32, 112, 95, 116, 121, 112, 101, 32, 76, 73, 75, 69, 32, 39, 80, 82, 79, 77, 79, 37, 39, 32, 84, 72, 69, 78, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 69, 76, 83, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 69, 78, 68, 41, 32, 47, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 41, 32, 65, 83, 32, 112, 114, 111, 109, 111, 95, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 44, 10, 32, 32, 32, 32, 112, 97, 114, 116, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 62, 61, 32, 100, 97, 116, 101, 32, 39, 49, 57, 57, 53, 45, 48, 57, 45, 48, 49, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 49, 48, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q15[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 44, 10, 32, 32, 32, 32, 115, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 115, 95, 97, 100, 100, 114, 101, 115, 115, 44, 10, 32, 32, 32, 32, 115, 95, 112, 104, 111, 110, 101, 44, 10, 32, 32, 32, 32, 116, 111, 116, 97, 108, 95, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 115, 117, 112, 112, 107, 101, 121, 32, 65, 83, 32, 115, 117, 112, 112, 108, 105, 101, 114, 95, 110, 111, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 41, 32, 65, 83, 32, 116, 111, 116, 97, 108, 95, 114, 101, 118, 101, 110, 117, 101, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 62, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 54, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 54, 45, 48, 52, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 95, 110, 111, 41, 32, 114, 101, 118, 101, 110, 117, 101, 48, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 115, 117, 112, 112, 108, 105, 101, 114, 95, 110, 111, 10, 32, 32, 32, 32, 65, 78, 68, 32, 116, 111, 116, 97, 108, 95, 114, 101, 118, 101, 110, 117, 101, 32, 61, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 109, 97, 120, 40, 116, 111, 116, 97, 108, 95, 114, 101, 118, 101, 110, 117, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 115, 117, 112, 112, 107, 101, 121, 32, 65, 83, 32, 115, 117, 112, 112, 108, 105, 101, 114, 95, 110, 111, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 41, 32, 65, 83, 32, 116, 111, 116, 97, 108, 95, 114, 101, 118, 101, 110, 117, 101, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 62, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 54, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 54, 45, 48, 52, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 95, 110, 111, 41, 32, 114, 101, 118, 101, 110, 117, 101, 49, 41, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q16[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 112, 95, 98, 114, 97, 110, 100, 44, 10, 32, 32, 32, 32, 112, 95, 116, 121, 112, 101, 44, 10, 32, 32, 32, 32, 112, 95, 115, 105, 122, 101, 44, 10, 32, 32, 32, 32, 99, 111, 117, 110, 116, 40, 68, 73, 83, 84, 73, 78, 67, 84, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 41, 32, 65, 83, 32, 115, 117, 112, 112, 108, 105, 101, 114, 95, 99, 110, 116, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 112, 97, 114, 116, 115, 117, 112, 112, 44, 10, 32, 32, 32, 32, 112, 97, 114, 116, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 98, 114, 97, 110, 100, 32, 60, 62, 32, 39, 66, 114, 97, 110, 100, 35, 52, 53, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 116, 121, 112, 101, 32, 78, 79, 84, 32, 76, 73, 75, 69, 32, 39, 77, 69, 68, 73, 85, 77, 32, 80, 79, 76, 73, 83, 72, 69, 68, 37, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 115, 105, 122, 101, 32, 73, 78, 32, 40, 52, 57, 44, 32, 49, 52, 44, 32, 50, 51, 44, 32, 52, 53, 44, 32, 49, 57, 44, 32, 51, 44, 32, 51, 54, 44, 32, 57, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 78, 79, 84, 32, 73, 78, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 95, 99, 111, 109, 109, 101, 110, 116, 32, 76, 73, 75, 69, 32, 39, 37, 67, 117, 115, 116, 111, 109, 101, 114, 37, 67, 111, 109, 112, 108, 97, 105, 110, 116, 115, 37, 39, 41, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 112, 95, 98, 114, 97, 110, 100, 44, 10, 32, 32, 32, 32, 112, 95, 116, 121, 112, 101, 44, 10, 32, 32, 32, 32, 112, 95, 115, 105, 122, 101, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 95, 99, 110, 116, 32, 68, 69, 83, 67, 44, 10, 32, 32, 32, 32, 112, 95, 98, 114, 97, 110, 100, 44, 10, 32, 32, 32, 32, 112, 95, 116, 121, 112, 101, 44, 10, 32, 32, 32, 32, 112, 95, 115, 105, 122, 101, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q17[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 41, 32, 47, 32, 55, 46, 48, 32, 65, 83, 32, 97, 118, 103, 95, 121, 101, 97, 114, 108, 121, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 44, 10, 32, 32, 32, 32, 112, 97, 114, 116, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 98, 114, 97, 110, 100, 32, 61, 32, 39, 66, 114, 97, 110, 100, 35, 50, 51, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 99, 111, 110, 116, 97, 105, 110, 101, 114, 32, 61, 32, 39, 77, 69, 68, 32, 66, 79, 88, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 60, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 48, 46, 50, 32, 42, 32, 97, 118, 103, 40, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 41, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q18[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 99, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 44, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 44, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 44, 10, 32, 32, 32, 32, 111, 95, 116, 111, 116, 97, 108, 112, 114, 105, 99, 101, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 41, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 44, 10, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 73, 78, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 32, 32, 32, 32, 32, 32, 32, 32, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 72, 65, 86, 73, 78, 71, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 41, 32, 62, 32, 51, 48, 48, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 32, 61, 32, 111, 95, 99, 117, 115, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 99, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 44, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 44, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 44, 10, 32, 32, 32, 32, 111, 95, 116, 111, 116, 97, 108, 112, 114, 105, 99, 101, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 111, 95, 116, 111, 116, 97, 108, 112, 114, 105, 99, 101, 32, 68, 69, 83, 67, 44, 10, 32, 32, 32, 32, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 10, 76, 73, 77, 73, 84, 32, 49, 48, 48, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q19[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 115, 117, 109, 40, 108, 95, 101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99, 101, 32, 42, 32, 40, 49, 32, 45, 32, 108, 95, 100, 105, 115, 99, 111, 117, 110, 116, 41, 41, 32, 65, 83, 32, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 44, 10, 32, 32, 32, 32, 112, 97, 114, 116, 10, 87, 72, 69, 82, 69, 32, 40, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 98, 114, 97, 110, 100, 32, 61, 32, 39, 66, 114, 97, 110, 100, 35, 49, 50, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 99, 111, 110, 116, 97, 105, 110, 101, 114, 32, 73, 78, 32, 40, 39, 83, 77, 32, 67, 65, 83, 69, 39, 44, 32, 39, 83, 77, 32, 66, 79, 88, 39, 44, 32, 39, 83, 77, 32, 80, 65, 67, 75, 39, 44, 32, 39, 83, 77, 32, 80, 75, 71, 39, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 62, 61, 32, 49, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 60, 61, 32, 49, 32, 43, 32, 49, 48, 10, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 115, 105, 122, 101, 32, 66, 69, 84, 87, 69, 69, 78, 32, 49, 32, 65, 78, 68, 32, 53, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 32, 73, 78, 32, 40, 39, 65, 73, 82, 39, 44, 32, 39, 65, 73, 82, 32, 82, 69, 71, 39, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 105, 110, 115, 116, 114, 117, 99, 116, 32, 61, 32, 39, 68, 69, 76, 73, 86, 69, 82, 32, 73, 78, 32, 80, 69, 82, 83, 79, 78, 39, 41, 10, 32, 32, 32, 32, 79, 82, 32, 40, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 98, 114, 97, 110, 100, 32, 61, 32, 39, 66, 114, 97, 110, 100, 35, 50, 51, 39, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 99, 111, 110, 116, 97, 105, 110, 101, 114, 32, 73, 78, 32, 40, 39, 77, 69, 68, 32, 66, 65, 71, 39, 44, 32, 39, 77, 69, 68, 32, 66, 79, 88, 39, 44, 32, 39, 77, 69, 68, 32, 80, 75, 71, 39, 44, 32, 39, 77, 69, 68, 32, 80, 65, 67, 75, 39, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 62, 61, 32, 49, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 60, 61, 32, 49, 48, 32, 43, 32, 49, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 115, 105, 122, 101, 32, 66, 69, 84, 87, 69, 69, 78, 32, 49, 32, 65, 78, 68, 32, 49, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 32, 73, 78, 32, 40, 39, 65, 73, 82, 39, 44, 32, 39, 65, 73, 82, 32, 82, 69, 71, 39, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 105, 110, 115, 116, 114, 117, 99, 116, 32, 61, 32, 39, 68, 69, 76, 73, 86, 69, 82, 32, 73, 78, 32, 80, 69, 82, 83, 79, 78, 39, 41, 10, 32, 32, 32, 32, 79, 82, 32, 40, 112, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 98, 114, 97, 110, 100, 32, 61, 32, 39, 66, 114, 97, 110, 100, 35, 51, 52, 39, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 99, 111, 110, 116, 97, 105, 110, 101, 114, 32, 73, 78, 32, 40, 39, 76, 71, 32, 67, 65, 83, 69, 39, 44, 32, 39, 76, 71, 32, 66, 79, 88, 39, 44, 32, 39, 76, 71, 32, 80, 65, 67, 75, 39, 44, 32, 39, 76, 71, 32, 80, 75, 71, 39, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 62, 61, 32, 50, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 32, 60, 61, 32, 50, 48, 32, 43, 32, 49, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 95, 115, 105, 122, 101, 32, 66, 69, 84, 87, 69, 69, 78, 32, 49, 32, 65, 78, 68, 32, 49, 53, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 32, 73, 78, 32, 40, 39, 65, 73, 82, 39, 44, 32, 39, 65, 73, 82, 32, 82, 69, 71, 39, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 105, 110, 115, 116, 114, 117, 99, 116, 32, 61, 32, 39, 68, 69, 76, 73, 86, 69, 82, 32, 73, 78, 32, 80, 69, 82, 83, 79, 78, 39, 41, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q20[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 115, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 115, 95, 97, 100, 100, 114, 101, 115, 115, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 73, 78, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 97, 114, 116, 115, 117, 112, 112, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 32, 73, 78, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 97, 114, 116, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 112, 95, 110, 97, 109, 101, 32, 76, 73, 75, 69, 32, 39, 102, 111, 114, 101, 115, 116, 37, 39, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 112, 115, 95, 97, 118, 97, 105, 108, 113, 116, 121, 32, 62, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 48, 46, 53, 32, 42, 32, 115, 117, 109, 40, 108, 95, 113, 117, 97, 110, 116, 105, 116, 121, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 95, 112, 97, 114, 116, 107, 101, 121, 32, 61, 32, 112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 112, 115, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 62, 61, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 52, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 95, 115, 104, 105, 112, 100, 97, 116, 101, 32, 60, 32, 67, 65, 83, 84, 40, 39, 49, 57, 57, 53, 45, 48, 49, 45, 48, 49, 39, 32, 65, 83, 32, 100, 97, 116, 101, 41, 41, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 110, 95, 110, 97, 109, 101, 32, 61, 32, 39, 67, 65, 78, 65, 68, 65, 39, 10, 32, 32, 32, 32, 32, 32, 32, 32, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 115, 95, 110, 97, 109, 101, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q21[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 115, 95, 110, 97, 109, 101, 44, 10, 32, 32, 32, 32, 99, 111, 117, 110, 116, 40, 42, 41, 32, 65, 83, 32, 110, 117, 109, 119, 97, 105, 116, 10, 70, 82, 79, 77, 10, 32, 32, 32, 32, 115, 117, 112, 112, 108, 105, 101, 114, 44, 10, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 32, 108, 49, 44, 10, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 44, 10, 32, 32, 32, 32, 110, 97, 116, 105, 111, 110, 10, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 115, 95, 115, 117, 112, 112, 107, 101, 121, 32, 61, 32, 108, 49, 46, 108, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 108, 49, 46, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 111, 95, 111, 114, 100, 101, 114, 115, 116, 97, 116, 117, 115, 32, 61, 32, 39, 70, 39, 10, 32, 32, 32, 32, 65, 78, 68, 32, 108, 49, 46, 108, 95, 114, 101, 99, 101, 105, 112, 116, 100, 97, 116, 101, 32, 62, 32, 108, 49, 46, 108, 95, 99, 111, 109, 109, 105, 116, 100, 97, 116, 101, 10, 32, 32, 32, 32, 65, 78, 68, 32, 69, 88, 73, 83, 84, 83, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 32, 108, 50, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 50, 46, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 108, 49, 46, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 50, 46, 108, 95, 115, 117, 112, 112, 107, 101, 121, 32, 60, 62, 32, 108, 49, 46, 108, 95, 115, 117, 112, 112, 107, 101, 121, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 78, 79, 84, 32, 69, 88, 73, 83, 84, 83, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 10, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 105, 110, 101, 105, 116, 101, 109, 32, 108, 51, 10, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 108, 51, 46, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 32, 61, 32, 108, 49, 46, 108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 51, 46, 108, 95, 115, 117, 112, 112, 107, 101, 121, 32, 60, 62, 32, 108, 49, 46, 108, 95, 115, 117, 112, 112, 107, 101, 121, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 108, 51, 46, 108, 95, 114, 101, 99, 101, 105, 112, 116, 100, 97, 116, 101, 32, 62, 32, 108, 51, 46, 108, 95, 99, 111, 109, 109, 105, 116, 100, 97, 116, 101, 41, 10, 32, 32, 32, 32, 65, 78, 68, 32, 115, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 32, 61, 32, 110, 95, 110, 97, 116, 105, 111, 110, 107, 101, 121, 10, 32, 32, 32, 32, 65, 78, 68, 32, 110, 95, 110, 97, 109, 101, 32, 61, 32, 39, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 39, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 115, 95, 110, 97, 109, 101, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 110, 117, 109, 119, 97, 105, 116, 32, 68, 69, 83, 67, 44, 10, 32, 32, 32, 32, 115, 95, 110, 97, 109, 101, 10, 76, 73, 77, 73, 84, 32, 49, 48, 48, 59, 10, 0};
-const uint8_t TPCH_QUERIES_q22[] = {83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 99, 110, 116, 114, 121, 99, 111, 100, 101, 44, 10, 32, 32, 32, 32, 99, 111, 117, 110, 116, 40, 42, 41, 32, 65, 83, 32, 110, 117, 109, 99, 117, 115, 116, 44, 10, 32, 32, 32, 32, 115, 117, 109, 40, 99, 95, 97, 99, 99, 116, 98, 97, 108, 41, 32, 65, 83, 32, 116, 111, 116, 97, 99, 99, 116, 98, 97, 108, 10, 70, 82, 79, 77, 32, 40, 10, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 98, 115, 116, 114, 105, 110, 103, 40, 99, 95, 112, 104, 111, 110, 101, 32, 70, 82, 79, 77, 32, 49, 32, 70, 79, 82, 32, 50, 41, 32, 65, 83, 32, 99, 110, 116, 114, 121, 99, 111, 100, 101, 44, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 95, 97, 99, 99, 116, 98, 97, 108, 10, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 10, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 115, 117, 98, 115, 116, 114, 105, 110, 103, 40, 99, 95, 112, 104, 111, 110, 101, 32, 70, 82, 79, 77, 32, 49, 32, 70, 79, 82, 32, 50, 41, 32, 73, 78, 32, 40, 39, 49, 51, 39, 44, 32, 39, 51, 49, 39, 44, 32, 39, 50, 51, 39, 44, 32, 39, 50, 57, 39, 44, 32, 39, 51, 48, 39, 44, 32, 39, 49, 56, 39, 44, 32, 39, 49, 55, 39, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 99, 95, 97, 99, 99, 116, 98, 97, 108, 32, 62, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 97, 118, 103, 40, 99, 95, 97, 99, 99, 116, 98, 97, 108, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 99, 117, 115, 116, 111, 109, 101, 114, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 99, 95, 97, 99, 99, 116, 98, 97, 108, 32, 62, 32, 48, 46, 48, 48, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 115, 117, 98, 115, 116, 114, 105, 110, 103, 40, 99, 95, 112, 104, 111, 110, 101, 32, 70, 82, 79, 77, 32, 49, 32, 70, 79, 82, 32, 50, 41, 32, 73, 78, 32, 40, 39, 49, 51, 39, 44, 32, 39, 51, 49, 39, 44, 32, 39, 50, 51, 39, 44, 32, 39, 50, 57, 39, 44, 32, 39, 51, 48, 39, 44, 32, 39, 49, 56, 39, 44, 32, 39, 49, 55, 39, 41, 41, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 65, 78, 68, 32, 78, 79, 84, 32, 69, 88, 73, 83, 84, 83, 32, 40, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 83, 69, 76, 69, 67, 84, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 70, 82, 79, 77, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 111, 114, 100, 101, 114, 115, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 87, 72, 69, 82, 69, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 111, 95, 99, 117, 115, 116, 107, 101, 121, 32, 61, 32, 99, 95, 99, 117, 115, 116, 107, 101, 121, 41, 41, 32, 65, 83, 32, 99, 117, 115, 116, 115, 97, 108, 101, 10, 71, 82, 79, 85, 80, 32, 66, 89, 10, 32, 32, 32, 32, 99, 110, 116, 114, 121, 99, 111, 100, 101, 10, 79, 82, 68, 69, 82, 32, 66, 89, 10, 32, 32, 32, 32, 99, 110, 116, 114, 121, 99, 111, 100, 101, 59, 10, 0};
-const char *TPCH_QUERIES[] = {
-	(const char*) TPCH_QUERIES_q01,
-	(const char*) TPCH_QUERIES_q02,
-	(const char*) TPCH_QUERIES_q03,
-	(const char*) TPCH_QUERIES_q04,
-	(const char*) TPCH_QUERIES_q05,
-	(const char*) TPCH_QUERIES_q06,
-	(const char*) TPCH_QUERIES_q07,
-	(const char*) TPCH_QUERIES_q08,
-	(const char*) TPCH_QUERIES_q09,
-	(const char*) TPCH_QUERIES_q10,
-	(const char*) TPCH_QUERIES_q11,
-	(const char*) TPCH_QUERIES_q12,
-	(const char*) TPCH_QUERIES_q13,
-	(const char*) TPCH_QUERIES_q14,
-	(const char*) TPCH_QUERIES_q15,
-	(const char*) TPCH_QUERIES_q16,
-	(const char*) TPCH_QUERIES_q17,
-	(const char*) TPCH_QUERIES_q18,
-	(const char*) TPCH_QUERIES_q19,
-	(const char*) TPCH_QUERIES_q20,
-	(const char*) TPCH_QUERIES_q21,
-	(const char*) TPCH_QUERIES_q22
-};
-const uint8_t TPCH_ANSWERS_SF0_01_q01[] = {108, 95, 114, 101, 116, 117, 114, 110, 102, 108, 97, 103, 124, 108, 95, 108, 105, 110, 101, 115, 116, 97, 116, 117, 115, 124, 115, 117, 109, 95, 113, 116, 121, 124, 115, 117, 109, 95, 98, 97, 115, 101, 95, 112, 114, 105, 99, 101, 124, 115, 117, 109, 95, 100, 105, 115, 99, 95, 112, 114, 105, 99, 101, 124, 115, 117, 109, 95, 99, 104, 97, 114, 103, 101, 124, 97, 118, 103, 95, 113, 116, 121, 124, 97, 118, 103, 95, 112, 114, 105, 99, 101, 124, 97, 118, 103, 95, 100, 105, 115, 99, 124, 99, 111, 117, 110, 116, 95, 111, 114, 100, 101, 114, 10, 65, 124, 70, 124, 51, 56, 48, 52, 53, 54, 124, 53, 51, 50, 51, 52, 56, 50, 49, 49, 46, 54, 53, 124, 53, 48, 53, 56, 50, 50, 52, 52, 49, 46, 52, 56, 54, 49, 124, 53, 50, 54, 49, 54, 53, 57, 51, 52, 46, 48, 48, 48, 56, 51, 57, 124, 50, 53, 46, 53, 55, 53, 49, 53, 52, 54, 49, 49, 52, 53, 52, 54, 57, 50, 49, 124, 51, 53, 55, 56, 53, 46, 55, 48, 57, 51, 48, 54, 57, 51, 55, 51, 52, 57, 124, 48, 46, 48, 53, 48, 48, 56, 49, 51, 51, 57, 48, 54, 57, 54, 52, 50, 51, 55, 54, 57, 56, 124, 49, 52, 56, 55, 54, 10, 78, 124, 70, 124, 56, 57, 55, 49, 124, 49, 50, 51, 56, 52, 56, 48, 49, 46, 51, 55, 124, 49, 49, 55, 57, 56, 50, 53, 55, 46, 50, 48, 56, 48, 124, 49, 50, 50, 56, 50, 52, 56, 53, 46, 48, 53, 54, 57, 51, 51, 124, 50, 53, 46, 55, 55, 56, 55, 51, 53, 54, 51, 50, 49, 56, 51, 57, 48, 56, 48, 124, 51, 53, 53, 56, 56, 46, 53, 48, 57, 54, 56, 51, 57, 48, 56, 48, 52, 54, 124, 48, 46, 48, 52, 55, 55, 53, 56, 54, 50, 48, 54, 56, 57, 54, 53, 53, 49, 55, 50, 52, 49, 124, 51, 52, 56, 10, 78, 124, 79, 124, 55, 52, 50, 56, 48, 50, 124, 49, 48, 52, 49, 53, 48, 50, 56, 52, 49, 46, 52, 53, 124, 57, 56, 57, 55, 51, 55, 53, 49, 56, 46, 54, 51, 52, 54, 124, 49, 48, 50, 57, 52, 49, 56, 53, 51, 49, 46, 53, 50, 51, 51, 53, 48, 124, 50, 53, 46, 52, 53, 52, 57, 56, 55, 56, 51, 52, 53, 52, 57, 56, 55, 56, 51, 124, 51, 53, 54, 57, 49, 46, 49, 50, 57, 50, 48, 57, 48, 55, 52, 51, 57, 56, 124, 48, 46, 48, 52, 57, 57, 51, 49, 49, 49, 57, 53, 54, 52, 48, 57, 57, 57, 50, 56, 48, 52, 124, 50, 57, 49, 56, 49, 10, 82, 124, 70, 124, 51, 56, 49, 52, 52, 57, 124, 53, 51, 52, 53, 57, 52, 52, 52, 53, 46, 51, 53, 124, 53, 48, 55, 57, 57, 54, 52, 53, 52, 46, 52, 48, 54, 55, 124, 53, 50, 56, 53, 50, 52, 50, 49, 57, 46, 51, 53, 56, 57, 48, 51, 124, 50, 53, 46, 53, 57, 55, 49, 54, 56, 49, 54, 53, 51, 52, 54, 57, 51, 51, 51, 124, 51, 53, 56, 55, 52, 46, 48, 48, 54, 53, 51, 50, 54, 56, 48, 49, 55, 55, 124, 48, 46, 48, 52, 57, 56, 50, 55, 53, 51, 57, 57, 50, 55, 53, 50, 54, 53, 48, 54, 53, 49, 124, 49, 52, 57, 48, 50, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q02[] = {115, 95, 97, 99, 99, 116, 98, 97, 108, 124, 115, 95, 110, 97, 109, 101, 124, 110, 95, 110, 97, 109, 101, 124, 112, 95, 112, 97, 114, 116, 107, 101, 121, 124, 112, 95, 109, 102, 103, 114, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 124, 115, 95, 112, 104, 111, 110, 101, 124, 115, 95, 99, 111, 109, 109, 101, 110, 116, 10, 52, 49, 56, 54, 46, 57, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 55, 55, 124, 71, 69, 82, 77, 65, 78, 89, 124, 50, 52, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 119, 53, 121, 79, 32, 48, 121, 106, 88, 111, 117, 32, 56, 73, 52, 102, 102, 122, 65, 68, 113, 44, 82, 56, 116, 68, 48, 54, 120, 49, 118, 98, 101, 77, 112, 76, 74, 70, 50, 124, 49, 55, 45, 50, 56, 49, 45, 51, 52, 53, 45, 52, 56, 54, 51, 124, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 116, 104, 101, 111, 100, 111, 108, 105, 10, 49, 56, 56, 51, 46, 51, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 56, 54, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 48, 49, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 105, 90, 76, 75, 75, 87, 97, 81, 65, 68, 101, 124, 50, 57, 45, 57, 48, 51, 45, 54, 54, 53, 45, 55, 48, 54, 53, 124, 99, 97, 106, 111, 108, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 44, 32, 102, 105, 110, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 58, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 112, 101, 99, 10, 49, 54, 56, 55, 46, 56, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 49, 55, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 54, 51, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 80, 89, 78, 48, 109, 57, 106, 57, 56, 71, 104, 88, 52, 50, 68, 118, 66, 75, 118, 85, 82, 99, 65, 100, 44, 66, 124, 50, 57, 45, 54, 48, 49, 45, 56, 56, 52, 45, 57, 50, 49, 57, 124, 101, 101, 112, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 98, 111, 108, 100, 32, 105, 100, 101, 97, 115, 46, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 98, 111, 108, 100, 32, 112, 97, 99, 107, 97, 10, 50, 56, 55, 46, 49, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 53, 50, 124, 82, 79, 77, 65, 78, 73, 65, 124, 51, 50, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 53, 111, 71, 114, 51, 112, 106, 50, 115, 112, 114, 90, 78, 119, 104, 111, 56, 67, 70, 87, 50, 104, 97, 97, 79, 98, 100, 48, 124, 50, 57, 45, 57, 55, 52, 45, 57, 51, 52, 45, 52, 55, 49, 51, 124, 100, 111, 108, 105, 116, 101, 115, 32, 97, 114, 101, 32, 115, 108, 121, 108, 121, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 97, 99, 107, 97, 103, 101, 115, 46, 32, 105, 114, 111, 110, 105, 99, 44, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 113, 117, 105, 99, 107, 108, 121, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q03[] = {108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 124, 114, 101, 118, 101, 110, 117, 101, 124, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 124, 111, 95, 115, 104, 105, 112, 112, 114, 105, 111, 114, 105, 116, 121, 10, 52, 55, 55, 49, 52, 124, 50, 54, 55, 48, 49, 48, 46, 53, 56, 57, 52, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 49, 124, 48, 10, 50, 50, 50, 55, 54, 124, 50, 54, 54, 51, 53, 49, 46, 53, 53, 54, 50, 124, 49, 57, 57, 53, 45, 48, 49, 45, 50, 57, 124, 48, 10, 51, 50, 57, 54, 53, 124, 50, 54, 51, 55, 54, 56, 46, 51, 52, 49, 52, 124, 49, 57, 57, 53, 45, 48, 50, 45, 50, 53, 124, 48, 10, 50, 49, 57, 53, 54, 124, 50, 53, 52, 53, 52, 49, 46, 49, 50, 56, 53, 124, 49, 57, 57, 53, 45, 48, 50, 45, 48, 50, 124, 48, 10, 49, 54, 51, 55, 124, 50, 52, 51, 53, 49, 50, 46, 55, 57, 56, 49, 124, 49, 57, 57, 53, 45, 48, 50, 45, 48, 56, 124, 48, 10, 49, 48, 57, 49, 54, 124, 50, 52, 49, 51, 50, 48, 46, 48, 56, 49, 52, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 49, 124, 48, 10, 51, 48, 52, 57, 55, 124, 50, 48, 56, 53, 54, 54, 46, 54, 57, 54, 57, 124, 49, 57, 57, 53, 45, 48, 50, 45, 48, 55, 124, 48, 10, 52, 53, 48, 124, 50, 48, 53, 52, 52, 55, 46, 52, 50, 51, 50, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 53, 124, 48, 10, 52, 55, 50, 48, 52, 124, 50, 48, 52, 52, 55, 56, 46, 53, 50, 49, 51, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 51, 124, 48, 10, 57, 54, 57, 54, 124, 50, 48, 49, 53, 48, 50, 46, 50, 49, 56, 56, 124, 49, 57, 57, 53, 45, 48, 50, 45, 50, 48, 124, 48, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q04[] = {111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 124, 111, 114, 100, 101, 114, 95, 99, 111, 117, 110, 116, 10, 49, 45, 85, 82, 71, 69, 78, 84, 124, 57, 51, 10, 50, 45, 72, 73, 71, 72, 124, 49, 48, 51, 10, 51, 45, 77, 69, 68, 73, 85, 77, 124, 49, 48, 57, 10, 52, 45, 78, 79, 84, 32, 83, 80, 69, 67, 73, 70, 73, 69, 68, 124, 49, 48, 50, 10, 53, 45, 76, 79, 87, 124, 49, 50, 56, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q05[] = {110, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 48, 48, 48, 57, 50, 54, 46, 54, 57, 57, 57, 10, 67, 72, 73, 78, 65, 124, 55, 52, 48, 50, 49, 48, 46, 55, 53, 55, 48, 10, 74, 65, 80, 65, 78, 124, 54, 54, 48, 54, 53, 49, 46, 50, 52, 50, 53, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 53, 54, 54, 51, 55, 57, 46, 53, 50, 55, 54, 10, 73, 78, 68, 73, 65, 124, 52, 50, 50, 56, 55, 52, 46, 54, 56, 52, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q06[] = {114, 101, 118, 101, 110, 117, 101, 10, 49, 49, 57, 51, 48, 53, 51, 46, 50, 50, 53, 51, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q07[] = {115, 117, 112, 112, 95, 110, 97, 116, 105, 111, 110, 124, 99, 117, 115, 116, 95, 110, 97, 116, 105, 111, 110, 124, 108, 95, 121, 101, 97, 114, 124, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 65, 78, 67, 69, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 53, 124, 50, 54, 56, 48, 54, 56, 46, 53, 55, 55, 52, 10, 70, 82, 65, 78, 67, 69, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 54, 124, 51, 48, 51, 56, 54, 50, 46, 50, 57, 56, 48, 10, 71, 69, 82, 77, 65, 78, 89, 124, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 53, 124, 54, 50, 49, 49, 53, 57, 46, 52, 56, 56, 50, 10, 71, 69, 82, 77, 65, 78, 89, 124, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 54, 124, 51, 55, 57, 48, 57, 53, 46, 56, 56, 53, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q08[] = {111, 95, 121, 101, 97, 114, 124, 109, 107, 116, 95, 115, 104, 97, 114, 101, 10, 49, 57, 57, 53, 124, 48, 46, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 10, 49, 57, 57, 54, 124, 48, 46, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q09[] = {110, 97, 116, 105, 111, 110, 124, 111, 95, 121, 101, 97, 114, 124, 115, 117, 109, 95, 112, 114, 111, 102, 105, 116, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 56, 124, 57, 55, 56, 54, 52, 46, 53, 54, 56, 50, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 55, 124, 51, 54, 56, 50, 51, 49, 46, 54, 54, 57, 53, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 54, 124, 49, 57, 54, 53, 50, 53, 46, 56, 48, 52, 54, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 53, 124, 51, 52, 49, 52, 51, 56, 46, 54, 56, 56, 53, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 52, 124, 54, 55, 55, 52, 52, 52, 46, 48, 49, 54, 48, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 51, 124, 52, 53, 56, 55, 53, 54, 46, 57, 49, 53, 55, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 50, 124, 53, 52, 57, 50, 52, 51, 46, 57, 53, 49, 49, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 56, 124, 56, 48, 52, 52, 56, 46, 55, 54, 56, 48, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 55, 124, 49, 56, 54, 50, 55, 57, 46, 49, 54, 49, 56, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 54, 124, 49, 53, 52, 48, 52, 49, 46, 56, 56, 50, 50, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 53, 124, 49, 49, 51, 49, 52, 51, 46, 51, 49, 49, 57, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 52, 124, 49, 54, 57, 54, 56, 48, 46, 52, 50, 51, 57, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 51, 124, 49, 49, 54, 53, 49, 51, 46, 56, 49, 52, 49, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 50, 124, 50, 48, 50, 52, 48, 52, 46, 55, 54, 48, 56, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 56, 124, 55, 53, 57, 53, 50, 46, 53, 57, 52, 54, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 55, 124, 49, 57, 48, 53, 52, 56, 46, 49, 49, 48, 52, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 54, 124, 50, 49, 57, 48, 53, 57, 46, 48, 54, 57, 50, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 53, 124, 49, 56, 54, 52, 51, 53, 46, 50, 48, 50, 51, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 52, 124, 57, 54, 56, 51, 53, 46, 49, 56, 55, 48, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 51, 124, 49, 56, 54, 51, 54, 53, 46, 52, 49, 48, 57, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 50, 124, 49, 53, 50, 53, 52, 54, 46, 52, 52, 51, 57, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 56, 124, 49, 48, 49, 48, 51, 48, 46, 51, 51, 51, 54, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 55, 124, 49, 48, 49, 49, 57, 55, 46, 51, 52, 52, 49, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 54, 124, 50, 53, 55, 54, 57, 55, 46, 49, 51, 53, 53, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 53, 124, 57, 49, 52, 55, 52, 46, 56, 56, 50, 48, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 52, 124, 50, 52, 57, 49, 56, 50, 46, 55, 53, 52, 56, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 51, 124, 49, 56, 53, 55, 51, 55, 46, 56, 51, 55, 57, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 50, 124, 49, 52, 51, 51, 55, 49, 46, 55, 52, 54, 53, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 56, 124, 53, 48, 56, 51, 54, 52, 46, 53, 52, 52, 52, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 55, 124, 54, 53, 48, 50, 51, 53, 46, 49, 54, 52, 54, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 54, 124, 57, 49, 49, 51, 54, 54, 46, 48, 54, 57, 56, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 53, 124, 55, 57, 55, 50, 54, 56, 46, 52, 48, 55, 54, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 52, 124, 53, 50, 57, 57, 56, 57, 46, 51, 48, 57, 53, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 51, 124, 53, 55, 51, 56, 54, 52, 46, 51, 57, 55, 50, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 50, 124, 55, 53, 49, 54, 56, 56, 46, 55, 54, 49, 51, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 56, 124, 51, 48, 54, 51, 50, 53, 46, 50, 56, 52, 50, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 55, 124, 53, 54, 56, 52, 54, 49, 46, 54, 54, 57, 57, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 54, 124, 52, 54, 53, 48, 56, 49, 46, 57, 50, 51, 50, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 53, 124, 53, 52, 50, 56, 56, 54, 46, 53, 48, 56, 55, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 52, 124, 55, 52, 53, 56, 48, 55, 46, 56, 49, 50, 51, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 51, 124, 51, 56, 49, 53, 48, 51, 46, 50, 48, 48, 56, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 50, 124, 54, 52, 49, 56, 54, 54, 46, 52, 51, 54, 55, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 56, 124, 50, 50, 54, 48, 53, 52, 46, 53, 55, 49, 54, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 55, 124, 53, 56, 53, 49, 57, 51, 46, 50, 56, 48, 50, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 54, 124, 52, 48, 53, 52, 49, 50, 46, 55, 55, 52, 49, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 53, 124, 50, 55, 48, 52, 53, 53, 46, 55, 54, 51, 55, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 52, 124, 53, 54, 55, 56, 55, 53, 46, 52, 50, 55, 57, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 51, 124, 52, 49, 50, 51, 48, 50, 46, 50, 56, 55, 49, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 50, 124, 53, 53, 49, 50, 56, 52, 46, 53, 56, 50, 49, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 56, 124, 49, 51, 53, 55, 50, 51, 46, 52, 48, 53, 48, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 55, 124, 50, 52, 57, 54, 54, 52, 46, 55, 53, 55, 56, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 54, 124, 49, 55, 53, 56, 56, 50, 46, 56, 57, 51, 52, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 53, 124, 49, 49, 54, 51, 57, 52, 46, 55, 56, 54, 54, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 52, 124, 49, 57, 55, 54, 57, 53, 46, 50, 52, 51, 56, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 51, 124, 50, 51, 49, 56, 55, 56, 46, 54, 50, 48, 49, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 50, 124, 49, 57, 57, 49, 51, 49, 46, 50, 48, 51, 55, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 56, 124, 49, 55, 50, 55, 52, 49, 46, 49, 48, 50, 52, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 55, 124, 51, 57, 51, 56, 51, 51, 46, 52, 54, 54, 48, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 54, 124, 51, 51, 53, 54, 51, 52, 46, 53, 57, 51, 54, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 53, 124, 51, 55, 56, 49, 48, 54, 46, 48, 55, 54, 51, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 52, 124, 50, 53, 48, 49, 48, 55, 46, 54, 54, 53, 51, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 51, 124, 51, 50, 55, 49, 53, 52, 46, 57, 51, 54, 53, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 50, 124, 51, 56, 55, 50, 52, 48, 46, 48, 56, 56, 53, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 56, 124, 51, 52, 55, 53, 52, 56, 46, 55, 54, 48, 52, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 55, 124, 54, 53, 54, 55, 57, 55, 46, 57, 54, 55, 48, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 54, 124, 53, 50, 50, 55, 53, 57, 46, 51, 53, 50, 57, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 53, 124, 53, 55, 52, 52, 50, 56, 46, 54, 54, 57, 51, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 52, 124, 55, 52, 49, 57, 56, 51, 46, 55, 56, 52, 54, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 51, 124, 55, 50, 57, 57, 52, 56, 46, 53, 51, 52, 49, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 50, 124, 54, 54, 49, 48, 54, 49, 46, 49, 52, 49, 53, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 56, 124, 57, 49, 55, 57, 49, 46, 53, 48, 57, 54, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 55, 124, 49, 56, 51, 57, 53, 54, 46, 52, 54, 49, 51, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 54, 124, 52, 49, 53, 50, 51, 52, 46, 55, 56, 52, 56, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 53, 124, 52, 50, 55, 49, 53, 53, 46, 51, 56, 48, 52, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 52, 124, 50, 56, 54, 50, 55, 49, 46, 50, 56, 55, 53, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 51, 124, 53, 53, 49, 49, 55, 56, 46, 56, 56, 50, 51, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 50, 124, 50, 55, 52, 53, 49, 51, 46, 50, 54, 56, 53, 10, 73, 82, 65, 78, 124, 49, 57, 57, 56, 124, 52, 55, 57, 53, 57, 46, 56, 50, 49, 57, 10, 73, 82, 65, 78, 124, 49, 57, 57, 55, 124, 49, 56, 52, 51, 51, 53, 46, 48, 54, 49, 53, 10, 73, 82, 65, 78, 124, 49, 57, 57, 54, 124, 50, 50, 51, 49, 49, 53, 46, 50, 52, 54, 52, 10, 73, 82, 65, 78, 124, 49, 57, 57, 53, 124, 49, 50, 53, 51, 51, 57, 46, 48, 57, 50, 55, 10, 73, 82, 65, 78, 124, 49, 57, 57, 52, 124, 49, 49, 55, 50, 50, 56, 46, 51, 49, 50, 50, 10, 73, 82, 65, 78, 124, 49, 57, 57, 51, 124, 50, 48, 56, 48, 51, 48, 46, 51, 50, 50, 57, 10, 73, 82, 65, 78, 124, 49, 57, 57, 50, 124, 49, 54, 49, 56, 51, 53, 46, 53, 52, 55, 53, 10, 73, 82, 65, 81, 124, 49, 57, 57, 56, 124, 49, 54, 49, 55, 57, 55, 46, 52, 57, 50, 52, 10, 73, 82, 65, 81, 124, 49, 57, 57, 55, 124, 50, 50, 52, 56, 55, 54, 46, 53, 52, 51, 54, 10, 73, 82, 65, 81, 124, 49, 57, 57, 54, 124, 49, 52, 53, 50, 55, 55, 46, 56, 57, 56, 48, 10, 73, 82, 65, 81, 124, 49, 57, 57, 53, 124, 52, 54, 55, 57, 53, 53, 46, 50, 53, 48, 53, 10, 73, 82, 65, 81, 124, 49, 57, 57, 52, 124, 57, 55, 52, 53, 53, 46, 50, 57, 57, 48, 10, 73, 82, 65, 81, 124, 49, 57, 57, 51, 124, 49, 49, 52, 56, 50, 49, 46, 54, 52, 52, 48, 10, 73, 82, 65, 81, 124, 49, 57, 57, 50, 124, 50, 49, 51, 51, 48, 55, 46, 49, 53, 55, 52, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 56, 124, 51, 48, 55, 53, 57, 52, 46, 53, 57, 56, 48, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 55, 124, 51, 51, 57, 48, 49, 56, 46, 49, 52, 56, 56, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 54, 124, 54, 52, 57, 53, 55, 56, 46, 51, 51, 54, 56, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 53, 124, 54, 55, 49, 54, 52, 52, 46, 48, 57, 49, 49, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 52, 124, 53, 55, 54, 50, 54, 54, 46, 50, 51, 56, 54, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 51, 124, 53, 49, 52, 49, 57, 48, 46, 56, 52, 51, 55, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 50, 124, 53, 51, 52, 57, 49, 52, 46, 57, 51, 51, 57, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 54, 124, 51, 51, 52, 54, 48, 46, 50, 52, 52, 55, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 53, 124, 50, 48, 51, 54, 52, 46, 49, 54, 50, 51, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 52, 124, 49, 53, 53, 50, 56, 46, 54, 48, 56, 56, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 51, 124, 49, 52, 54, 52, 48, 46, 57, 56, 56, 57, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 50, 124, 49, 48, 57, 48, 52, 46, 50, 57, 51, 49, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 56, 124, 53, 50, 49, 57, 50, 54, 46, 53, 49, 57, 56, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 55, 124, 53, 53, 57, 54, 51, 50, 46, 51, 52, 48, 56, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 54, 124, 55, 55, 50, 56, 53, 53, 46, 55, 57, 51, 57, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 53, 124, 53, 49, 54, 52, 53, 50, 46, 53, 48, 54, 55, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 52, 124, 53, 52, 51, 54, 54, 53, 46, 56, 49, 53, 52, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 51, 124, 56, 54, 54, 57, 50, 52, 46, 56, 55, 53, 52, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 50, 124, 53, 54, 55, 52, 49, 48, 46, 53, 53, 48, 50, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 56, 124, 50, 49, 55, 55, 57, 52, 46, 52, 57, 55, 51, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 55, 124, 52, 51, 57, 50, 52, 48, 46, 57, 50, 56, 55, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 54, 124, 51, 57, 57, 57, 54, 57, 46, 52, 54, 56, 48, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 53, 124, 50, 53, 56, 49, 51, 49, 46, 57, 51, 57, 56, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 52, 124, 51, 56, 54, 57, 55, 50, 46, 49, 52, 50, 52, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 51, 124, 49, 52, 53, 52, 54, 56, 46, 48, 51, 56, 49, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 50, 124, 50, 56, 52, 51, 49, 52, 46, 50, 56, 49, 51, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 56, 124, 53, 49, 56, 54, 57, 51, 46, 50, 50, 51, 56, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 55, 124, 54, 49, 51, 56, 55, 51, 46, 50, 57, 54, 49, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 54, 124, 57, 51, 54, 55, 57, 51, 46, 53, 54, 49, 50, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 53, 124, 55, 50, 55, 50, 48, 52, 46, 55, 55, 49, 56, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 52, 124, 49, 49, 48, 52, 54, 49, 56, 46, 49, 56, 48, 55, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 51, 124, 56, 57, 51, 50, 54, 54, 46, 48, 53, 51, 48, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 50, 124, 49, 48, 54, 50, 52, 51, 50, 46, 48, 56, 56, 52, 10, 80, 69, 82, 85, 124, 49, 57, 57, 56, 124, 50, 56, 55, 50, 52, 50, 46, 57, 55, 57, 55, 10, 80, 69, 82, 85, 124, 49, 57, 57, 55, 124, 53, 51, 50, 51, 53, 56, 46, 51, 54, 54, 48, 10, 80, 69, 82, 85, 124, 49, 57, 57, 54, 124, 51, 57, 56, 52, 51, 53, 46, 55, 53, 48, 55, 10, 80, 69, 82, 85, 124, 49, 57, 57, 53, 124, 52, 54, 50, 48, 51, 49, 46, 54, 50, 53, 49, 10, 80, 69, 82, 85, 124, 49, 57, 57, 52, 124, 51, 48, 52, 50, 51, 53, 46, 52, 49, 49, 56, 10, 80, 69, 82, 85, 124, 49, 57, 57, 51, 124, 53, 48, 53, 56, 56, 53, 46, 52, 56, 57, 48, 10, 80, 69, 82, 85, 124, 49, 57, 57, 50, 124, 51, 56, 50, 50, 57, 48, 46, 48, 57, 52, 55, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 56, 124, 51, 53, 55, 56, 50, 52, 46, 53, 53, 50, 56, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 55, 124, 53, 54, 57, 56, 48, 54, 46, 53, 53, 54, 52, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 54, 124, 55, 51, 50, 48, 48, 49, 46, 53, 53, 54, 56, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 53, 124, 52, 48, 56, 54, 53, 55, 46, 49, 49, 53, 52, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 52, 124, 53, 52, 48, 55, 48, 50, 46, 53, 52, 54, 51, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 51, 124, 56, 56, 51, 49, 53, 56, 46, 53, 48, 53, 54, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 50, 124, 53, 48, 53, 52, 56, 56, 46, 57, 53, 48, 49, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 56, 124, 51, 52, 52, 52, 56, 46, 54, 51, 53, 55, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 55, 124, 51, 49, 52, 57, 55, 50, 46, 48, 52, 52, 54, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 54, 124, 52, 51, 48, 48, 52, 57, 46, 53, 56, 50, 49, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 53, 124, 51, 54, 48, 53, 51, 56, 46, 48, 53, 56, 54, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 52, 124, 51, 48, 49, 55, 57, 49, 46, 48, 49, 49, 52, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 51, 124, 51, 48, 56, 57, 57, 51, 46, 57, 54, 50, 50, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 50, 124, 50, 56, 57, 56, 54, 56, 46, 54, 53, 54, 52, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 56, 124, 49, 54, 53, 48, 50, 46, 52, 49, 48, 48, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 55, 124, 54, 49, 56, 51, 48, 46, 57, 53, 53, 54, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 54, 124, 50, 49, 51, 54, 53, 48, 46, 50, 56, 48, 57, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 53, 124, 54, 50, 54, 54, 56, 46, 55, 50, 53, 48, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 52, 124, 57, 52, 54, 50, 57, 46, 49, 53, 51, 56, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 51, 124, 53, 55, 55, 54, 56, 46, 51, 48, 55, 49, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 50, 124, 54, 54, 53, 50, 48, 46, 49, 48, 57, 51, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 56, 124, 56, 48, 52, 51, 55, 46, 54, 53, 50, 51, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 55, 124, 50, 53, 50, 53, 48, 57, 46, 55, 51, 53, 49, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 54, 124, 50, 51, 49, 49, 53, 50, 46, 56, 53, 56, 50, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 53, 124, 49, 56, 49, 51, 49, 48, 46, 56, 56, 48, 56, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 52, 124, 50, 51, 57, 49, 54, 49, 46, 50, 48, 54, 49, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 51, 124, 49, 50, 50, 49, 48, 51, 46, 49, 49, 52, 50, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 50, 124, 54, 48, 56, 56, 50, 46, 51, 48, 56, 48, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 56, 124, 52, 52, 48, 51, 52, 55, 46, 54, 54, 53, 56, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 55, 124, 54, 53, 50, 57, 53, 56, 46, 57, 51, 55, 49, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 54, 124, 49, 48, 48, 52, 53, 57, 51, 46, 56, 50, 56, 50, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 53, 124, 56, 54, 48, 49, 52, 52, 46, 49, 48, 50, 57, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 52, 124, 56, 48, 55, 55, 57, 55, 46, 52, 56, 55, 55, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 51, 124, 55, 51, 54, 54, 54, 57, 46, 52, 55, 49, 49, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 50, 124, 56, 55, 55, 56, 53, 49, 46, 52, 49, 48, 51, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 56, 124, 51, 53, 56, 50, 52, 56, 46, 48, 49, 53, 57, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 55, 124, 51, 57, 52, 56, 49, 55, 46, 50, 56, 52, 50, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 54, 124, 52, 51, 57, 51, 57, 48, 46, 48, 56, 51, 54, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 53, 124, 52, 49, 56, 54, 50, 54, 46, 54, 51, 50, 53, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 52, 124, 52, 50, 50, 54, 52, 52, 46, 56, 49, 54, 56, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 51, 124, 51, 48, 57, 48, 54, 51, 46, 52, 48, 50, 48, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 50, 124, 55, 49, 54, 49, 50, 54, 46, 53, 51, 55, 56, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q10[] = {99, 95, 99, 117, 115, 116, 107, 101, 121, 124, 99, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 124, 99, 95, 97, 99, 99, 116, 98, 97, 108, 124, 110, 95, 110, 97, 109, 101, 124, 99, 95, 97, 100, 100, 114, 101, 115, 115, 124, 99, 95, 112, 104, 111, 110, 101, 124, 99, 95, 99, 111, 109, 109, 101, 110, 116, 10, 54, 55, 57, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 55, 57, 124, 51, 55, 56, 50, 49, 49, 46, 51, 50, 53, 50, 124, 49, 51, 57, 52, 46, 52, 52, 124, 73, 82, 65, 78, 124, 106, 104, 76, 90, 108, 71, 49, 102, 82, 105, 83, 69, 48, 32, 119, 68, 76, 79, 67, 103, 117, 86, 66, 57, 54, 100, 72, 54, 97, 53, 124, 50, 48, 45, 49, 52, 54, 45, 54, 57, 54, 45, 57, 53, 48, 56, 124, 101, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 102, 114, 97, 121, 115, 32, 98, 111, 111, 115, 116, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 10, 49, 50, 48, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 50, 48, 49, 124, 51, 55, 52, 51, 51, 49, 46, 53, 51, 52, 48, 124, 53, 49, 54, 53, 46, 51, 57, 124, 73, 82, 65, 78, 124, 103, 76, 111, 56, 53, 104, 52, 67, 115, 116, 53, 99, 107, 110, 52, 48, 90, 75, 82, 54, 52, 48, 51, 75, 106, 87, 50, 54, 89, 67, 87, 65, 70, 90, 115, 113, 32, 100, 124, 50, 48, 45, 56, 50, 53, 45, 52, 48, 48, 45, 49, 49, 56, 55, 124, 108, 121, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 112, 97, 99, 107, 97, 103, 101, 115, 46, 32, 115, 112, 101, 99, 105, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 115, 108, 101, 101, 112, 45, 45, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 117, 115, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 46, 32, 115, 111, 109, 101, 116, 105, 109, 101, 115, 32, 101, 118, 101, 110, 32, 105, 100, 10, 52, 50, 50, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 50, 50, 124, 51, 54, 54, 52, 53, 49, 46, 48, 49, 50, 54, 124, 45, 50, 55, 50, 46, 49, 52, 124, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 114, 116, 100, 115, 49, 113, 119, 69, 105, 110, 68, 87, 89, 104, 121, 73, 98, 82, 117, 115, 82, 103, 88, 66, 68, 120, 71, 74, 114, 97, 80, 44, 67, 44, 83, 32, 122, 68, 119, 65, 124, 49, 57, 45, 50, 57, 57, 45, 50, 52, 55, 45, 50, 52, 52, 52, 124, 101, 112, 111, 115, 105, 116, 115, 59, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 99, 99, 111, 114, 100, 105, 10, 51, 51, 52, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 51, 52, 124, 51, 54, 48, 51, 55, 48, 46, 55, 53, 53, 48, 124, 45, 52, 48, 53, 46, 57, 49, 124, 69, 71, 89, 80, 84, 124, 100, 98, 100, 90, 100, 85, 121, 87, 81, 97, 90, 88, 55, 68, 111, 67, 79, 124, 49, 52, 45, 57, 52, 55, 45, 50, 57, 49, 45, 53, 48, 48, 50, 124, 102, 117, 108, 108, 121, 32, 98, 117, 115, 105, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 105, 100, 101, 97, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 105, 110, 97, 108, 32, 101, 120, 99, 117, 115, 101, 115, 32, 108, 111, 115, 101, 32, 115, 108, 121, 108, 121, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 101, 118, 101, 110, 44, 32, 105, 114, 111, 110, 105, 99, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 97, 114, 10, 56, 48, 53, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 48, 53, 124, 51, 53, 57, 52, 52, 56, 46, 57, 48, 51, 54, 124, 53, 49, 49, 46, 54, 57, 124, 73, 82, 65, 78, 124, 119, 111, 103, 117, 86, 116, 79, 106, 119, 118, 67, 56, 76, 76, 116, 80, 82, 65, 76, 73, 83, 78, 119, 65, 79, 70, 82, 102, 55, 48, 80, 102, 113, 107, 124, 50, 48, 45, 55, 51, 50, 45, 57, 56, 57, 45, 53, 54, 53, 51, 124, 98, 117, 115, 121, 32, 115, 101, 110, 116, 105, 109, 101, 110, 116, 115, 46, 32, 112, 101, 110, 100, 105, 110, 103, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 104, 97, 103, 103, 108, 101, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 101, 120, 112, 114, 101, 115, 115, 32, 114, 101, 113, 117, 101, 115, 116, 115, 45, 45, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 101, 120, 99, 117, 115, 101, 115, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 115, 108, 121, 108, 10, 57, 51, 50, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 51, 50, 124, 51, 52, 49, 54, 48, 56, 46, 50, 55, 53, 51, 124, 54, 53, 53, 51, 46, 51, 55, 124, 74, 79, 82, 68, 65, 78, 124, 107, 100, 82, 113, 66, 48, 101, 122, 104, 107, 85, 101, 80, 83, 99, 124, 50, 51, 45, 51, 48, 48, 45, 55, 48, 56, 45, 55, 57, 50, 55, 124, 112, 97, 99, 107, 97, 103, 101, 115, 32, 98, 111, 111, 115, 116, 32, 115, 108, 121, 108, 121, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 102, 111, 120, 101, 115, 46, 32, 101, 118, 10, 56, 53, 51, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 53, 51, 124, 51, 52, 49, 50, 51, 54, 46, 54, 50, 52, 54, 124, 45, 52, 52, 52, 46, 55, 51, 124, 66, 82, 65, 90, 73, 76, 124, 55, 44, 114, 82, 98, 65, 118, 113, 75, 52, 104, 83, 113, 109, 44, 108, 106, 69, 68, 111, 108, 121, 106, 82, 112, 56, 77, 117, 52, 52, 120, 83, 84, 71, 124, 49, 50, 45, 56, 54, 57, 45, 49, 54, 49, 45, 51, 52, 54, 56, 124, 121, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 119, 97, 107, 101, 32, 97, 108, 111, 110, 103, 115, 105, 100, 101, 32, 111, 102, 10, 56, 55, 50, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 55, 50, 124, 51, 51, 56, 51, 50, 56, 46, 55, 56, 48, 56, 124, 45, 56, 53, 56, 46, 54, 49, 124, 80, 69, 82, 85, 124, 120, 102, 98, 84, 73, 101, 49, 112, 103, 87, 113, 48, 106, 113, 100, 109, 55, 103, 81, 80, 54, 105, 88, 113, 99, 115, 50, 82, 99, 83, 107, 124, 50, 55, 45, 51, 53, 55, 45, 49, 51, 57, 45, 55, 49, 54, 52, 124, 32, 100, 101, 116, 101, 99, 116, 46, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 119, 97, 107, 101, 32, 115, 108, 121, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 102, 111, 120, 101, 115, 46, 32, 101, 118, 101, 110, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 114, 117, 10, 55, 51, 55, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 51, 55, 124, 51, 51, 56, 49, 56, 53, 46, 51, 51, 54, 53, 124, 50, 53, 48, 49, 46, 55, 52, 124, 67, 72, 73, 78, 65, 124, 101, 78, 72, 107, 90, 72, 89, 87, 88, 73, 112, 102, 56, 67, 116, 44, 70, 50, 65, 101, 106, 32, 66, 119, 120, 107, 90, 54, 76, 84, 87, 124, 50, 56, 45, 54, 53, 56, 45, 57, 51, 56, 45, 49, 49, 48, 50, 124, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 102, 105, 110, 97, 108, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 46, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 105, 110, 97, 108, 32, 105, 100, 101, 97, 115, 32, 104, 97, 103, 10, 49, 49, 49, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 49, 49, 56, 124, 51, 49, 57, 56, 55, 53, 46, 55, 50, 56, 48, 124, 52, 49, 51, 48, 46, 49, 56, 124, 73, 82, 65, 81, 124, 98, 106, 75, 48, 110, 101, 119, 109, 53, 51, 82, 50, 67, 111, 78, 65, 116, 118, 81, 115, 73, 113, 104, 124, 50, 49, 45, 53, 56, 51, 45, 55, 49, 53, 45, 56, 54, 50, 55, 124, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 117, 115, 101, 32, 115, 108, 121, 108, 121, 32, 98, 111, 108, 100, 32, 112, 97, 99, 107, 97, 103, 101, 115, 58, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 32, 101, 97, 116, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 115, 112, 101, 10, 50, 50, 51, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 50, 51, 124, 51, 49, 57, 53, 54, 52, 46, 50, 55, 53, 48, 124, 55, 52, 55, 54, 46, 50, 48, 124, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 77, 121, 81, 120, 85, 99, 71, 48, 80, 32, 81, 67, 101, 116, 109, 71, 48, 48, 71, 108, 70, 124, 51, 48, 45, 49, 57, 51, 45, 54, 52, 51, 45, 49, 53, 49, 55, 124, 97, 108, 44, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 114, 117, 110, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 115, 105, 108, 101, 110, 116, 32, 112, 97, 99, 107, 97, 103, 101, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 10, 56, 48, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 48, 56, 124, 51, 49, 52, 55, 55, 52, 46, 54, 49, 54, 55, 124, 53, 53, 54, 49, 46, 57, 51, 124, 82, 79, 77, 65, 78, 73, 65, 124, 57, 89, 52, 71, 56, 104, 111, 107, 121, 68, 81, 74, 79, 108, 99, 67, 85, 101, 52, 79, 121, 112, 88, 32, 115, 109, 70, 108, 77, 69, 54, 100, 32, 75, 114, 124, 50, 57, 45, 53, 51, 49, 45, 51, 49, 57, 45, 55, 55, 50, 54, 124, 32, 117, 110, 117, 115, 117, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 101, 118, 101, 110, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 101, 118, 101, 110, 32, 97, 99, 10, 52, 55, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 55, 56, 124, 50, 57, 57, 54, 53, 49, 46, 56, 48, 50, 54, 124, 45, 50, 49, 48, 46, 52, 48, 124, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 80, 70, 116, 65, 87, 87, 83, 110, 105, 71, 52, 51, 121, 87, 65, 103, 116, 106, 70, 80, 78, 48, 68, 114, 104, 121, 77, 67, 68, 73, 109, 124, 49, 49, 45, 54, 53, 53, 45, 50, 57, 49, 45, 50, 54, 57, 52, 124, 111, 32, 116, 104, 101, 32, 102, 111, 120, 101, 115, 46, 32, 105, 114, 111, 110, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 115, 108, 101, 101, 112, 46, 32, 99, 10, 49, 52, 52, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 52, 52, 49, 124, 50, 57, 52, 55, 48, 53, 46, 51, 57, 51, 53, 124, 57, 52, 54, 53, 46, 49, 53, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 121, 44, 50, 50, 49, 81, 87, 85, 118, 48, 67, 118, 103, 67, 86, 107, 82, 119, 115, 114, 79, 85, 112, 82, 115, 104, 87, 112, 99, 106, 75, 107, 114, 72, 117, 124, 51, 51, 45, 54, 56, 49, 45, 51, 51, 52, 45, 52, 52, 57, 57, 124, 110, 116, 115, 32, 104, 97, 103, 103, 108, 101, 32, 113, 117, 105, 101, 116, 108, 121, 32, 113, 117, 105, 99, 107, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 115, 108, 10, 49, 52, 55, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 52, 55, 56, 124, 50, 57, 52, 52, 51, 49, 46, 57, 49, 55, 56, 124, 57, 55, 48, 49, 46, 53, 52, 124, 71, 69, 82, 77, 65, 78, 89, 124, 118, 84, 106, 110, 119, 105, 110, 110, 66, 57, 89, 101, 65, 49, 86, 120, 75, 89, 111, 81, 69, 76, 97, 90, 74, 109, 44, 72, 87, 124, 49, 55, 45, 52, 50, 48, 45, 52, 56, 52, 45, 53, 57, 53, 57, 124, 110, 103, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 98, 111, 108, 100, 32, 102, 111, 120, 101, 115, 46, 32, 101, 118, 101, 110, 32, 110, 111, 116, 111, 114, 110, 105, 115, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 117, 110, 117, 115, 117, 97, 108, 32, 10, 50, 49, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 49, 49, 124, 50, 56, 55, 57, 48, 53, 46, 54, 51, 54, 56, 124, 52, 49, 57, 56, 46, 55, 50, 124, 74, 79, 82, 68, 65, 78, 124, 55, 57, 74, 70, 53, 99, 115, 115, 87, 108, 66, 51, 77, 69, 124, 50, 51, 45, 57, 54, 53, 45, 51, 51, 53, 45, 57, 52, 55, 49, 124, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 102, 111, 120, 101, 115, 32, 98, 111, 111, 115, 116, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 105, 100, 101, 97, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 32, 97, 114, 101, 46, 32, 115, 108, 121, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 10, 49, 57, 55, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 57, 55, 124, 50, 56, 51, 49, 57, 48, 46, 52, 56, 48, 55, 124, 57, 56, 54, 48, 46, 50, 50, 124, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 55, 77, 53, 65, 122, 32, 77, 66, 100, 120, 52, 69, 121, 49, 88, 84, 110, 124, 49, 49, 45, 49, 48, 55, 45, 51, 49, 50, 45, 54, 53, 56, 53, 124, 105, 99, 107, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 99, 97, 106, 111, 108, 101, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 10, 49, 48, 51, 48, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 48, 51, 48, 124, 50, 56, 50, 53, 53, 55, 46, 51, 53, 54, 54, 124, 54, 51, 53, 57, 46, 50, 55, 124, 73, 78, 68, 73, 65, 124, 52, 66, 121, 90, 112, 74, 112, 86, 74, 82, 68, 124, 49, 56, 45, 55, 53, 57, 45, 56, 55, 55, 45, 49, 56, 55, 48, 124, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 101, 118, 101, 110, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 101, 118, 101, 110, 108, 121, 10, 49, 48, 52, 57, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 48, 52, 57, 124, 50, 56, 49, 49, 51, 52, 46, 49, 49, 49, 55, 124, 56, 55, 52, 55, 46, 57, 57, 124, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 81, 49, 90, 99, 79, 109, 74, 106, 81, 105, 50, 86, 75, 101, 73, 107, 124, 49, 57, 45, 52, 57, 57, 45, 50, 53, 56, 45, 50, 56, 53, 49, 124, 117, 114, 105, 111, 117, 115, 108, 121, 32, 97, 99, 99, 111, 114, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 105, 108, 101, 110, 116, 32, 112, 97, 99, 107, 97, 103, 101, 115, 10, 49, 48, 57, 52, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 48, 57, 52, 124, 50, 55, 52, 56, 55, 55, 46, 52, 52, 52, 48, 124, 50, 53, 52, 52, 46, 52, 57, 124, 66, 82, 65, 90, 73, 76, 124, 100, 108, 115, 44, 77, 78, 78, 55, 69, 98, 70, 51, 71, 89, 114, 89, 51, 101, 82, 119, 83, 101, 79, 66, 90, 89, 100, 53, 111, 44, 99, 103, 124, 49, 50, 45, 50, 51, 52, 45, 55, 50, 49, 45, 57, 56, 55, 49, 124, 116, 101, 115, 32, 115, 101, 114, 118, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 113, 117, 105, 99, 107, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 102, 111, 120, 101, 115, 46, 32, 101, 120, 112, 114, 101, 115, 115, 44, 32, 113, 117, 105, 99, 107, 32, 97, 99, 99, 111, 117, 110, 116, 115, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q11[] = {112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 124, 118, 97, 108, 117, 101, 10, 49, 51, 55, 54, 124, 49, 51, 50, 55, 49, 50, 52, 57, 46, 56, 57, 10, 55, 56, 56, 124, 57, 52, 57, 56, 54, 52, 56, 46, 48, 54, 10, 49, 48, 55, 49, 124, 57, 51, 56, 56, 50, 54, 52, 46, 52, 48, 10, 49, 55, 54, 56, 124, 57, 50, 48, 55, 49, 57, 57, 46, 55, 53, 10, 49, 49, 54, 56, 124, 56, 56, 56, 49, 57, 48, 56, 46, 57, 54, 10, 49, 48, 56, 52, 124, 56, 55, 48, 57, 52, 57, 52, 46, 49, 54, 10, 49, 52, 49, 53, 124, 56, 52, 55, 49, 52, 56, 57, 46, 53, 54, 10, 49, 51, 51, 56, 124, 56, 50, 57, 51, 56, 52, 49, 46, 49, 50, 10, 49, 50, 52, 124, 56, 50, 48, 51, 50, 48, 57, 46, 51, 48, 10, 49, 50, 51, 50, 124, 56, 49, 49, 49, 54, 54, 51, 46, 51, 52, 10, 49, 54, 52, 51, 124, 55, 57, 55, 53, 56, 54, 50, 46, 55, 53, 10, 49, 57, 53, 50, 124, 55, 57, 51, 54, 57, 52, 55, 46, 54, 49, 10, 49, 57, 52, 52, 124, 55, 56, 56, 48, 48, 49, 56, 46, 54, 48, 10, 49, 56, 56, 52, 124, 55, 53, 49, 51, 52, 50, 50, 46, 56, 52, 10, 57, 52, 50, 124, 55, 53, 49, 49, 48, 49, 56, 46, 55, 54, 10, 54, 55, 48, 124, 55, 50, 57, 57, 57, 53, 54, 46, 56, 48, 10, 49, 53, 51, 50, 124, 55, 50, 50, 50, 51, 52, 55, 46, 50, 48, 10, 49, 48, 53, 50, 124, 55, 49, 53, 56, 53, 56, 54, 46, 48, 48, 10, 52, 53, 53, 124, 55, 48, 54, 52, 50, 56, 53, 46, 56, 52, 10, 49, 49, 55, 54, 124, 55, 48, 54, 48, 54, 55, 48, 46, 56, 57, 10, 49, 52, 51, 124, 55, 48, 51, 55, 54, 52, 56, 46, 54, 52, 10, 49, 54, 53, 51, 124, 54, 57, 52, 57, 53, 51, 51, 46, 55, 48, 10, 49, 49, 52, 48, 124, 54, 57, 50, 57, 52, 54, 52, 46, 48, 56, 10, 49, 48, 55, 54, 124, 54, 56, 55, 55, 52, 55, 50, 46, 57, 54, 10, 50, 48, 48, 48, 124, 54, 55, 50, 48, 48, 48, 57, 46, 51, 56, 10, 51, 52, 56, 124, 54, 54, 56, 49, 51, 48, 55, 46, 51, 52, 10, 56, 49, 48, 124, 54, 53, 55, 54, 54, 52, 48, 46, 57, 53, 10, 57, 52, 51, 124, 54, 52, 53, 56, 54, 52, 49, 46, 55, 48, 10, 55, 50, 48, 124, 54, 51, 57, 49, 51, 51, 48, 46, 50, 55, 10, 49, 55, 52, 56, 124, 54, 51, 52, 49, 53, 51, 48, 46, 52, 48, 10, 49, 50, 52, 49, 124, 54, 51, 48, 52, 57, 52, 52, 46, 54, 54, 10, 49, 51, 56, 52, 124, 54, 50, 55, 57, 50, 54, 49, 46, 49, 50, 10, 49, 55, 56, 52, 124, 54, 50, 52, 55, 56, 54, 51, 46, 50, 53, 10, 57, 56, 52, 124, 54, 49, 51, 54, 57, 50, 55, 46, 48, 48, 10, 52, 52, 53, 124, 54, 49, 50, 55, 55, 56, 52, 46, 50, 56, 10, 49, 57, 55, 54, 124, 54, 48, 55, 57, 50, 51, 55, 46, 48, 56, 10, 49, 54, 48, 57, 124, 54, 48, 50, 50, 55, 50, 48, 46, 56, 48, 10, 49, 53, 54, 51, 124, 53, 57, 55, 56, 49, 57, 53, 46, 48, 56, 10, 52, 53, 50, 124, 53, 56, 51, 56, 48, 53, 50, 46, 48, 48, 10, 50, 50, 50, 124, 53, 55, 51, 55, 49, 54, 50, 46, 50, 52, 10, 49, 54, 50, 57, 124, 53, 55, 48, 51, 49, 49, 55, 46, 49, 50, 10, 49, 52, 53, 52, 124, 53, 54, 57, 52, 56, 48, 52, 46, 49, 56, 10, 49, 48, 56, 50, 124, 53, 54, 56, 49, 57, 56, 49, 46, 50, 53, 10, 54, 57, 49, 124, 53, 54, 51, 51, 53, 56, 57, 46, 55, 50, 10, 49, 52, 55, 52, 124, 53, 54, 49, 52, 54, 55, 51, 46, 54, 52, 10, 49, 57, 48, 48, 124, 53, 53, 57, 49, 57, 48, 53, 46, 51, 54, 10, 50, 54, 50, 124, 53, 53, 53, 51, 50, 56, 53, 46, 51, 50, 10, 49, 56, 55, 54, 124, 53, 53, 49, 55, 57, 57, 55, 46, 53, 57, 10, 49, 48, 50, 55, 124, 53, 52, 57, 48, 57, 49, 54, 46, 48, 48, 10, 49, 56, 51, 51, 124, 53, 52, 53, 49, 52, 57, 53, 46, 48, 48, 10, 53, 49, 51, 124, 53, 51, 55, 52, 52, 50, 54, 46, 50, 50, 10, 55, 53, 50, 124, 53, 51, 53, 56, 57, 49, 57, 46, 55, 48, 10, 49, 51, 54, 55, 124, 53, 51, 53, 50, 55, 55, 51, 46, 50, 53, 10, 53, 52, 51, 124, 53, 49, 56, 57, 49, 48, 49, 46, 54, 56, 10, 49, 49, 52, 52, 124, 53, 49, 55, 52, 51, 56, 56, 46, 53, 54, 10, 52, 48, 51, 124, 53, 49, 50, 54, 49, 49, 56, 46, 49, 53, 10, 49, 52, 48, 54, 124, 53, 49, 50, 49, 56, 56, 54, 46, 52, 52, 10, 51, 50, 48, 124, 53, 48, 55, 50, 48, 57, 57, 46, 55, 54, 10, 49, 57, 52, 48, 124, 53, 48, 54, 57, 49, 55, 56, 46, 52, 48, 10, 49, 53, 48, 51, 124, 53, 48, 53, 48, 56, 57, 53, 46, 53, 48, 10, 49, 52, 51, 55, 124, 53, 48, 51, 57, 53, 57, 48, 46, 54, 48, 10, 55, 52, 51, 124, 53, 48, 51, 57, 50, 55, 49, 46, 52, 50, 10, 56, 50, 124, 52, 57, 57, 53, 57, 51, 57, 46, 48, 48, 10, 57, 49, 54, 124, 52, 57, 57, 52, 55, 51, 48, 46, 49, 48, 10, 55, 51, 50, 124, 52, 57, 51, 50, 56, 48, 57, 46, 56, 50, 10, 51, 53, 54, 124, 52, 56, 55, 57, 56, 54, 48, 46, 48, 57, 10, 49, 53, 57, 50, 124, 52, 56, 51, 49, 50, 52, 50, 46, 54, 48, 10, 49, 48, 52, 51, 124, 52, 56, 50, 53, 57, 50, 49, 46, 51, 49, 10, 49, 51, 50, 124, 52, 55, 56, 49, 57, 56, 52, 46, 49, 52, 10, 49, 48, 48, 54, 124, 52, 55, 51, 51, 57, 53, 52, 46, 54, 52, 10, 52, 57, 55, 124, 52, 55, 49, 49, 49, 55, 51, 46, 54, 48, 10, 49, 48, 48, 56, 124, 52, 53, 54, 53, 53, 56, 56, 46, 56, 53, 10, 49, 51, 55, 48, 124, 52, 53, 54, 51, 56, 51, 48, 46, 49, 48, 10, 50, 49, 54, 124, 52, 53, 54, 49, 49, 52, 51, 46, 56, 48, 10, 51, 52, 124, 52, 53, 48, 49, 57, 56, 50, 46, 55, 49, 10, 49, 57, 48, 56, 124, 52, 52, 49, 55, 57, 51, 49, 46, 56, 48, 10, 57, 56, 50, 124, 52, 51, 57, 49, 52, 57, 53, 46, 52, 54, 10, 49, 54, 53, 50, 124, 52, 51, 53, 56, 55, 57, 51, 46, 49, 52, 10, 54, 49, 52, 124, 52, 51, 53, 54, 54, 53, 55, 46, 52, 53, 10, 49, 53, 53, 50, 124, 52, 51, 53, 53, 53, 52, 49, 46, 55, 48, 10, 51, 53, 57, 124, 52, 51, 53, 51, 53, 54, 54, 46, 56, 55, 10, 49, 49, 48, 52, 124, 52, 51, 52, 55, 53, 49, 53, 46, 57, 48, 10, 49, 57, 56, 124, 52, 51, 49, 53, 48, 52, 57, 46, 48, 48, 10, 57, 57, 56, 124, 52, 49, 54, 55, 55, 56, 52, 46, 56, 56, 10, 49, 53, 52, 51, 124, 52, 49, 53, 57, 53, 54, 56, 46, 49, 54, 10, 49, 51, 48, 56, 124, 52, 49, 53, 51, 49, 50, 52, 46, 57, 53, 10, 52, 55, 52, 124, 52, 49, 50, 51, 56, 49, 57, 46, 50, 48, 10, 49, 51, 57, 52, 124, 52, 49, 50, 50, 55, 50, 57, 46, 51, 51, 10, 50, 55, 49, 124, 52, 48, 57, 53, 49, 56, 48, 46, 57, 54, 10, 57, 48, 56, 124, 52, 48, 56, 56, 56, 53, 54, 46, 50, 48, 10, 49, 49, 51, 53, 124, 52, 48, 52, 53, 48, 49, 52, 46, 49, 51, 10, 49, 54, 51, 50, 124, 52, 48, 49, 48, 55, 57, 52, 46, 57, 48, 10, 49, 51, 54, 50, 124, 51, 57, 56, 50, 48, 54, 48, 46, 49, 54, 10, 49, 53, 56, 124, 51, 57, 52, 49, 56, 56, 49, 46, 54, 53, 10, 49, 56, 53, 50, 124, 51, 57, 50, 51, 48, 51, 53, 46, 48, 50, 10, 49, 53, 53, 54, 124, 51, 56, 57, 54, 55, 48, 57, 46, 53, 52, 10, 53, 56, 52, 124, 51, 56, 52, 51, 56, 52, 56, 46, 51, 48, 10, 56, 56, 53, 124, 51, 56, 50, 54, 48, 50, 49, 46, 49, 54, 10, 51, 55, 54, 124, 51, 55, 56, 49, 50, 48, 49, 46, 57, 54, 10, 55, 49, 50, 124, 51, 55, 52, 57, 54, 57, 54, 46, 56, 48, 10, 50, 124, 51, 55, 52, 51, 50, 52, 49, 46, 52, 51, 10, 54, 55, 54, 124, 51, 55, 51, 53, 55, 49, 53, 46, 50, 48, 10, 49, 56, 51, 50, 124, 51, 55, 48, 57, 48, 48, 56, 46, 54, 48, 10, 49, 57, 53, 53, 124, 51, 55, 48, 50, 55, 57, 52, 46, 55, 48, 10, 54, 56, 124, 51, 54, 57, 48, 55, 48, 50, 46, 52, 49, 10, 49, 52, 51, 53, 124, 51, 54, 53, 57, 49, 49, 52, 46, 49, 48, 10, 49, 52, 52, 51, 124, 51, 54, 53, 54, 55, 54, 50, 46, 56, 52, 10, 49, 50, 55, 56, 124, 51, 54, 53, 51, 49, 48, 48, 46, 54, 54, 10, 49, 57, 50, 48, 124, 51, 54, 52, 55, 56, 57, 50, 46, 53, 52, 10, 52, 50, 51, 124, 51, 54, 48, 50, 48, 51, 49, 46, 56, 48, 10, 56, 49, 56, 124, 51, 53, 56, 57, 48, 52, 55, 46, 54, 48, 10, 55, 55, 57, 124, 51, 53, 53, 57, 53, 57, 55, 46, 53, 51, 10, 52, 56, 53, 124, 51, 53, 53, 56, 53, 49, 49, 46, 52, 52, 10, 53, 53, 50, 124, 51, 53, 53, 53, 52, 55, 48, 46, 49, 48, 10, 49, 50, 54, 57, 124, 51, 53, 49, 48, 52, 50, 55, 46, 54, 53, 10, 49, 54, 48, 50, 124, 51, 52, 57, 50, 49, 49, 55, 46, 55, 48, 10, 52, 50, 54, 124, 51, 52, 56, 54, 56, 56, 56, 46, 48, 50, 10, 49, 52, 53, 50, 124, 51, 52, 56, 48, 56, 50, 53, 46, 54, 48, 10, 55, 53, 54, 124, 51, 52, 54, 57, 51, 55, 51, 46, 55, 48, 10, 56, 51, 50, 124, 51, 52, 52, 55, 55, 52, 54, 46, 52, 54, 10, 49, 52, 57, 51, 124, 51, 52, 52, 54, 56, 54, 55, 46, 52, 48, 10, 49, 54, 53, 48, 124, 51, 52, 49, 55, 55, 53, 50, 46, 53, 56, 10, 50, 48, 53, 124, 51, 52, 48, 51, 48, 52, 54, 46, 50, 53, 10, 57, 51, 124, 51, 51, 54, 49, 52, 50, 53, 46, 56, 57, 10, 55, 54, 124, 51, 51, 52, 50, 48, 56, 49, 46, 56, 50, 10, 49, 55, 53, 57, 124, 51, 51, 48, 51, 48, 53, 48, 46, 52, 48, 10, 56, 56, 54, 124, 51, 51, 48, 50, 49, 56, 48, 46, 55, 48, 10, 49, 53, 52, 52, 124, 51, 50, 56, 56, 53, 55, 51, 46, 49, 54, 10, 49, 57, 51, 50, 124, 51, 50, 55, 48, 57, 48, 48, 46, 52, 48, 10, 52, 56, 57, 124, 51, 50, 53, 51, 51, 54, 56, 46, 51, 48, 10, 53, 57, 52, 124, 51, 49, 55, 55, 52, 48, 56, 46, 53, 55, 10, 49, 56, 52, 124, 51, 49, 55, 55, 49, 54, 50, 46, 48, 53, 10, 57, 53, 48, 124, 51, 49, 54, 53, 50, 49, 51, 46, 48, 49, 10, 49, 49, 50, 52, 124, 51, 49, 52, 51, 50, 55, 57, 46, 51, 54, 10, 49, 48, 54, 124, 51, 48, 57, 57, 48, 50, 49, 46, 57, 56, 10, 49, 57, 54, 52, 124, 51, 48, 49, 54, 53, 53, 51, 46, 49, 48, 10, 51, 56, 52, 124, 50, 57, 54, 52, 50, 54, 50, 46, 55, 55, 10, 57, 55, 52, 124, 50, 57, 53, 57, 52, 57, 55, 46, 49, 48, 10, 57, 54, 52, 124, 50, 57, 53, 49, 51, 50, 57, 46, 52, 53, 10, 49, 57, 56, 52, 124, 50, 57, 48, 55, 51, 52, 53, 46, 51, 54, 10, 50, 48, 48, 124, 50, 56, 57, 53, 54, 56, 56, 46, 51, 50, 10, 54, 56, 51, 124, 50, 56, 50, 57, 52, 55, 54, 46, 57, 53, 10, 49, 53, 54, 52, 124, 50, 56, 49, 54, 53, 48, 54, 46, 53, 54, 10, 53, 52, 54, 124, 50, 55, 56, 56, 48, 53, 57, 46, 54, 52, 10, 53, 48, 50, 124, 50, 55, 56, 48, 56, 50, 56, 46, 54, 52, 10, 51, 57, 54, 124, 50, 55, 55, 56, 52, 50, 49, 46, 51, 57, 10, 50, 48, 51, 124, 50, 55, 54, 49, 52, 51, 57, 46, 56, 56, 10, 56, 54, 54, 124, 50, 55, 53, 51, 48, 51, 49, 46, 50, 48, 10, 49, 55, 52, 51, 124, 50, 55, 52, 51, 56, 56, 57, 46, 52, 57, 10, 49, 48, 52, 49, 124, 50, 55, 51, 56, 48, 56, 51, 46, 57, 50, 10, 49, 52, 51, 50, 124, 50, 55, 49, 51, 52, 49, 50, 46, 49, 54, 10, 52, 51, 124, 50, 53, 56, 55, 51, 53, 57, 46, 53, 56, 10, 57, 52, 49, 124, 50, 53, 56, 55, 48, 57, 49, 46, 53, 50, 10, 49, 56, 57, 48, 124, 50, 53, 53, 56, 55, 51, 57, 46, 54, 57, 10, 49, 56, 54, 54, 124, 50, 53, 52, 53, 56, 51, 56, 46, 52, 48, 10, 55, 52, 55, 124, 50, 53, 49, 49, 55, 52, 53, 46, 51, 50, 10, 55, 55, 54, 124, 50, 53, 48, 54, 52, 56, 57, 46, 56, 57, 10, 53, 53, 52, 124, 50, 53, 48, 53, 52, 49, 55, 46, 50, 53, 10, 49, 50, 49, 48, 124, 50, 52, 57, 48, 56, 50, 48, 46, 57, 50, 10, 49, 50, 51, 57, 124, 50, 52, 48, 53, 50, 48, 54, 46, 51, 48, 10, 52, 52, 51, 124, 50, 51, 56, 50, 49, 53, 48, 46, 48, 53, 10, 49, 54, 54, 49, 124, 50, 51, 55, 48, 53, 55, 52, 46, 49, 54, 10, 49, 48, 55, 57, 124, 50, 51, 54, 51, 53, 48, 53, 46, 49, 49, 10, 49, 51, 50, 57, 124, 50, 51, 48, 53, 56, 55, 48, 46, 52, 50, 10, 49, 54, 57, 49, 124, 50, 50, 54, 49, 49, 53, 57, 46, 57, 50, 10, 49, 50, 52, 55, 124, 50, 50, 51, 57, 53, 53, 51, 46, 50, 56, 10, 49, 55, 53, 50, 124, 50, 50, 51, 48, 48, 53, 53, 46, 55, 54, 10, 49, 53, 48, 124, 50, 50, 49, 55, 48, 52, 51, 46, 53, 57, 10, 49, 56, 49, 52, 124, 50, 50, 49, 51, 54, 51, 53, 46, 50, 48, 10, 50, 56, 57, 124, 50, 49, 56, 55, 49, 54, 48, 46, 52, 53, 10, 49, 52, 48, 48, 124, 50, 49, 51, 57, 56, 52, 53, 46, 49, 48, 10, 49, 56, 57, 56, 124, 50, 49, 51, 48, 49, 49, 52, 46, 57, 54, 10, 49, 56, 48, 57, 124, 50, 49, 50, 50, 55, 53, 56, 46, 55, 50, 10, 56, 56, 52, 124, 50, 49, 48, 55, 52, 55, 57, 46, 53, 54, 10, 49, 48, 51, 56, 124, 50, 48, 57, 54, 56, 54, 56, 46, 57, 55, 10, 49, 51, 49, 56, 124, 50, 48, 53, 49, 51, 48, 50, 46, 52, 52, 10, 53, 50, 52, 124, 50, 48, 51, 53, 50, 54, 50, 46, 50, 50, 10, 52, 49, 52, 124, 50, 48, 50, 57, 54, 57, 50, 46, 52, 53, 10, 50, 57, 56, 124, 50, 48, 50, 54, 57, 56, 49, 46, 55, 52, 10, 49, 57, 57, 54, 124, 50, 48, 50, 48, 57, 53, 51, 46, 53, 52, 10, 49, 55, 52, 50, 124, 50, 48, 49, 57, 49, 57, 48, 46, 56, 48, 10, 49, 54, 50, 48, 124, 50, 48, 49, 48, 49, 49, 50, 46, 48, 48, 10, 56, 55, 55, 124, 49, 57, 53, 54, 52, 50, 57, 46, 49, 56, 10, 49, 51, 51, 50, 124, 49, 57, 49, 57, 48, 50, 57, 46, 53, 54, 10, 49, 53, 51, 54, 124, 49, 56, 53, 57, 51, 49, 56, 46, 49, 53, 10, 49, 49, 49, 54, 124, 49, 56, 53, 50, 53, 56, 56, 46, 50, 56, 10, 52, 52, 55, 124, 49, 56, 49, 55, 57, 53, 49, 46, 51, 50, 10, 49, 54, 55, 54, 124, 49, 56, 48, 50, 51, 48, 54, 46, 48, 56, 10, 49, 57, 49, 49, 124, 49, 55, 55, 57, 54, 52, 54, 46, 52, 52, 10, 49, 52, 53, 57, 124, 49, 55, 54, 55, 54, 48, 50, 46, 51, 48, 10, 53, 55, 54, 124, 49, 55, 54, 49, 56, 51, 56, 46, 55, 53, 10, 49, 50, 55, 51, 124, 49, 55, 53, 52, 50, 51, 53, 46, 48, 49, 10, 53, 56, 51, 124, 49, 55, 50, 53, 54, 52, 57, 46, 57, 50, 10, 53, 51, 50, 124, 49, 54, 56, 50, 51, 49, 49, 46, 52, 56, 10, 49, 55, 51, 50, 124, 49, 54, 53, 50, 56, 51, 49, 46, 50, 48, 10, 49, 53, 55, 50, 124, 49, 54, 53, 48, 57, 53, 51, 46, 53, 50, 10, 49, 56, 56, 57, 124, 49, 54, 51, 56, 52, 52, 51, 46, 55, 50, 10, 52, 55, 54, 124, 49, 54, 51, 49, 49, 53, 52, 46, 48, 54, 10, 49, 50, 50, 49, 124, 49, 54, 50, 57, 56, 56, 51, 46, 52, 54, 10, 49, 55, 57, 50, 124, 49, 54, 48, 54, 51, 52, 54, 46, 49, 48, 10, 50, 52, 51, 124, 49, 54, 48, 51, 50, 51, 53, 46, 49, 54, 10, 51, 50, 56, 124, 49, 53, 54, 57, 56, 50, 54, 46, 55, 50, 10, 49, 57, 57, 57, 124, 49, 53, 53, 51, 55, 48, 54, 46, 48, 48, 10, 49, 54, 49, 49, 124, 49, 53, 50, 57, 56, 53, 55, 46, 48, 49, 10, 54, 52, 51, 124, 49, 53, 49, 50, 56, 51, 56, 46, 56, 48, 10, 49, 50, 55, 54, 124, 49, 52, 54, 55, 53, 54, 55, 46, 50, 56, 10, 49, 56, 50, 51, 124, 49, 52, 54, 50, 50, 57, 51, 46, 48, 48, 10, 49, 124, 49, 52, 53, 54, 48, 53, 48, 46, 57, 54, 10, 50, 55, 124, 49, 52, 50, 53, 56, 51, 50, 46, 52, 48, 10, 54, 51, 50, 124, 49, 52, 48, 56, 48, 56, 55, 46, 50, 54, 10, 49, 49, 56, 52, 124, 49, 52, 48, 54, 49, 48, 49, 46, 55, 56, 10, 50, 53, 50, 124, 49, 51, 55, 57, 49, 56, 54, 46, 51, 53, 10, 51, 57, 50, 124, 49, 51, 53, 52, 56, 49, 51, 46, 49, 56, 10, 49, 50, 49, 53, 124, 49, 51, 52, 52, 51, 56, 51, 46, 50, 48, 10, 50, 54, 124, 49, 51, 51, 55, 48, 48, 50, 46, 56, 57, 10, 56, 52, 124, 49, 51, 51, 52, 49, 52, 54, 46, 55, 49, 10, 55, 56, 52, 124, 49, 51, 50, 55, 50, 57, 55, 46, 48, 49, 10, 49, 56, 48, 51, 124, 49, 51, 50, 55, 48, 52, 53, 46, 48, 54, 10, 51, 53, 50, 124, 49, 51, 50, 54, 49, 48, 50, 46, 51, 52, 10, 49, 54, 53, 124, 49, 50, 56, 57, 48, 55, 53, 46, 55, 54, 10, 49, 55, 54, 124, 49, 50, 56, 53, 56, 54, 54, 46, 50, 48, 10, 49, 51, 49, 52, 124, 49, 50, 52, 52, 49, 55, 51, 46, 50, 54, 10, 49, 55, 48, 49, 124, 49, 50, 51, 57, 48, 57, 53, 46, 52, 52, 10, 56, 52, 52, 124, 49, 50, 50, 53, 54, 57, 54, 46, 48, 53, 10, 49, 57, 56, 56, 124, 49, 50, 49, 54, 55, 57, 56, 46, 51, 51, 10, 49, 56, 52, 55, 124, 49, 50, 48, 50, 48, 49, 50, 46, 49, 51, 10, 49, 55, 48, 54, 124, 49, 49, 56, 52, 49, 50, 53, 46, 49, 48, 10, 55, 52, 52, 124, 49, 49, 56, 50, 56, 50, 48, 46, 56, 48, 10, 50, 51, 48, 124, 49, 49, 54, 53, 57, 51, 50, 46, 51, 48, 10, 52, 49, 56, 124, 49, 48, 55, 56, 51, 50, 49, 46, 52, 52, 10, 49, 55, 52, 124, 49, 48, 54, 48, 53, 56, 52, 46, 56, 48, 10, 49, 48, 55, 51, 124, 49, 48, 50, 56, 52, 52, 57, 46, 56, 57, 10, 49, 55, 50, 54, 124, 49, 48, 49, 56, 54, 55, 51, 46, 48, 52, 10, 49, 50, 48, 54, 124, 49, 48, 48, 50, 51, 49, 57, 46, 52, 57, 10, 49, 51, 52, 51, 124, 57, 57, 56, 49, 48, 53, 46, 55, 54, 10, 57, 53, 50, 124, 57, 57, 55, 54, 56, 52, 46, 50, 52, 10, 52, 56, 52, 124, 57, 57, 49, 53, 51, 48, 46, 57, 51, 10, 57, 51, 50, 124, 57, 56, 48, 54, 50, 48, 46, 54, 56, 10, 56, 52, 51, 124, 57, 55, 56, 56, 54, 50, 46, 57, 50, 10, 49, 56, 52, 49, 124, 57, 54, 50, 49, 51, 49, 46, 56, 54, 10, 52, 57, 52, 124, 57, 53, 55, 53, 55, 53, 46, 51, 52, 10, 54, 53, 57, 124, 57, 53, 52, 50, 57, 49, 46, 48, 53, 10, 50, 53, 49, 124, 57, 51, 57, 55, 54, 52, 46, 55, 48, 10, 49, 52, 49, 51, 124, 57, 51, 54, 57, 53, 49, 46, 57, 52, 10, 53, 55, 50, 124, 57, 48, 54, 49, 49, 49, 46, 57, 57, 10, 51, 50, 124, 56, 57, 52, 52, 56, 52, 46, 48, 57, 10, 57, 124, 56, 57, 51, 57, 48, 53, 46, 57, 50, 10, 49, 52, 57, 56, 124, 56, 57, 48, 56, 56, 55, 46, 56, 53, 10, 49, 55, 57, 48, 124, 56, 55, 56, 57, 50, 51, 46, 54, 52, 10, 49, 54, 55, 48, 124, 56, 53, 52, 48, 52, 54, 46, 52, 51, 10, 56, 55, 54, 124, 56, 52, 50, 50, 52, 53, 46, 54, 55, 10, 49, 55, 53, 56, 124, 56, 52, 49, 50, 55, 53, 46, 52, 50, 10, 57, 51, 48, 124, 56, 51, 50, 57, 54, 51, 46, 54, 56, 10, 50, 56, 52, 124, 56, 50, 54, 54, 52, 50, 46, 54, 48, 10, 49, 55, 49, 48, 124, 56, 49, 49, 53, 48, 52, 46, 51, 56, 10, 49, 48, 52, 55, 124, 55, 57, 49, 50, 49, 52, 46, 52, 53, 10, 54, 53, 51, 124, 55, 56, 56, 57, 55, 52, 46, 50, 49, 10, 51, 49, 53, 124, 55, 55, 48, 53, 50, 54, 46, 48, 53, 10, 49, 55, 51, 52, 124, 55, 54, 51, 53, 54, 57, 46, 52, 48, 10, 49, 48, 49, 55, 124, 55, 49, 53, 51, 48, 50, 46, 55, 50, 10, 49, 51, 48, 53, 124, 55, 49, 51, 51, 53, 49, 46, 52, 51, 10, 55, 55, 124, 54, 56, 56, 56, 54, 53, 46, 56, 50, 10, 49, 53, 49, 50, 124, 54, 56, 50, 52, 51, 52, 46, 49, 53, 10, 50, 55, 54, 124, 54, 56, 48, 50, 51, 57, 46, 48, 52, 10, 49, 50, 56, 52, 124, 54, 55, 49, 50, 50, 53, 46, 57, 52, 10, 49, 51, 53, 54, 124, 54, 54, 53, 55, 49, 54, 46, 56, 51, 10, 56, 48, 48, 124, 54, 54, 51, 52, 49, 52, 46, 54, 53, 10, 49, 49, 55, 124, 54, 51, 57, 54, 53, 48, 46, 56, 56, 10, 54, 53, 50, 124, 54, 51, 53, 54, 50, 57, 46, 50, 56, 10, 53, 55, 124, 54, 51, 48, 57, 56, 55, 46, 52, 52, 10, 49, 52, 50, 54, 124, 54, 50, 56, 50, 52, 49, 46, 50, 53, 10, 49, 49, 57, 54, 124, 54, 50, 50, 52, 50, 55, 46, 49, 54, 10, 53, 49, 124, 54, 50, 50, 50, 52, 57, 46, 53, 52, 10, 49, 56, 52, 54, 124, 54, 50, 49, 48, 54, 56, 46, 56, 48, 10, 54, 48, 49, 124, 54, 49, 53, 57, 52, 50, 46, 54, 48, 10, 54, 52, 53, 124, 54, 48, 55, 57, 56, 53, 46, 56, 52, 10, 54, 56, 52, 124, 53, 55, 49, 52, 57, 48, 46, 55, 48, 10, 52, 54, 53, 124, 53, 55, 48, 51, 51, 55, 46, 52, 48, 10, 53, 54, 50, 124, 53, 54, 55, 54, 53, 49, 46, 50, 52, 10, 51, 56, 55, 124, 53, 53, 54, 54, 51, 52, 46, 55, 54, 10, 49, 49, 53, 50, 124, 53, 53, 53, 57, 56, 57, 46, 50, 56, 10, 49, 50, 48, 50, 124, 53, 53, 51, 56, 49, 56, 46, 49, 56, 10, 49, 49, 49, 50, 124, 53, 53, 50, 54, 53, 56, 46, 54, 56, 10, 51, 48, 52, 124, 53, 51, 53, 56, 54, 56, 46, 49, 54, 10, 51, 54, 56, 124, 53, 50, 54, 57, 57, 53, 46, 56, 52, 10, 49, 56, 48, 48, 124, 53, 50, 54, 55, 49, 49, 46, 49, 49, 10, 49, 49, 52, 56, 124, 53, 49, 53, 55, 48, 50, 46, 49, 54, 10, 50, 50, 53, 124, 53, 49, 51, 53, 56, 55, 46, 53, 55, 10, 51, 50, 52, 124, 53, 48, 48, 57, 53, 52, 46, 53, 56, 10, 53, 56, 54, 124, 52, 57, 57, 52, 55, 53, 46, 53, 56, 10, 49, 53, 55, 54, 124, 52, 57, 52, 52, 48, 49, 46, 48, 53, 10, 49, 52, 56, 52, 124, 52, 54, 50, 51, 57, 54, 46, 50, 55, 10, 49, 50, 54, 124, 52, 54, 49, 50, 54, 51, 46, 55, 52, 10, 49, 49, 51, 50, 124, 52, 53, 53, 52, 57, 50, 46, 50, 52, 10, 54, 50, 50, 124, 52, 52, 57, 54, 56, 53, 46, 54, 48, 10, 49, 49, 54, 48, 124, 52, 52, 56, 49, 56, 51, 46, 48, 54, 10, 49, 51, 53, 50, 124, 52, 51, 57, 57, 54, 55, 46, 48, 52, 10, 49, 56, 124, 52, 50, 54, 52, 52, 50, 46, 48, 56, 10, 55, 124, 52, 49, 52, 53, 53, 56, 46, 50, 48, 10, 56, 51, 51, 124, 51, 57, 56, 53, 52, 48, 46, 56, 55, 10, 49, 54, 57, 52, 124, 51, 55, 54, 52, 52, 51, 46, 57, 56, 10, 54, 53, 48, 124, 51, 55, 48, 57, 48, 48, 46, 57, 57, 10, 49, 53, 48, 52, 124, 51, 55, 48, 56, 49, 53, 46, 57, 48, 10, 52, 51, 50, 124, 51, 55, 48, 53, 50, 56, 46, 53, 50, 10, 54, 49, 50, 124, 51, 54, 55, 56, 57, 52, 46, 53, 48, 10, 53, 52, 50, 124, 51, 54, 55, 54, 53, 51, 46, 54, 54, 10, 52, 53, 54, 124, 51, 54, 48, 57, 49, 49, 46, 51, 50, 10, 53, 50, 124, 51, 53, 56, 55, 57, 50, 46, 51, 54, 10, 49, 51, 52, 54, 124, 51, 53, 48, 54, 51, 55, 46, 52, 51, 10, 53, 57, 124, 51, 52, 50, 50, 50, 49, 46, 52, 56, 10, 49, 49, 48, 55, 124, 51, 52, 49, 56, 48, 53, 46, 50, 48, 10, 49, 49, 55, 49, 124, 51, 51, 52, 57, 51, 56, 46, 48, 52, 10, 49, 48, 54, 50, 124, 51, 50, 54, 52, 52, 53, 46, 57, 48, 10, 53, 57, 50, 124, 51, 49, 51, 48, 56, 49, 46, 55, 53, 10, 49, 55, 53, 48, 124, 51, 49, 50, 50, 50, 57, 46, 51, 51, 10, 49, 56, 52, 51, 124, 51, 48, 57, 52, 53, 54, 46, 57, 53, 10, 49, 56, 48, 124, 51, 48, 56, 53, 51, 57, 46, 56, 52, 10, 56, 57, 57, 124, 51, 48, 49, 57, 56, 57, 46, 53, 48, 10, 49, 49, 56, 48, 124, 50, 57, 51, 52, 53, 50, 46, 53, 48, 10, 53, 50, 50, 124, 50, 57, 49, 54, 48, 49, 46, 55, 53, 10, 50, 52, 57, 124, 50, 56, 50, 53, 50, 48, 46, 51, 50, 10, 49, 53, 56, 52, 124, 50, 55, 56, 53, 53, 57, 46, 51, 56, 10, 49, 52, 48, 52, 124, 50, 55, 54, 48, 53, 55, 46, 57, 48, 10, 49, 50, 54, 53, 124, 50, 55, 49, 48, 55, 57, 46, 55, 54, 10, 49, 53, 52, 124, 50, 54, 57, 54, 52, 49, 46, 52, 50, 10, 49, 50, 57, 53, 124, 50, 54, 53, 53, 54, 54, 46, 53, 54, 10, 49, 53, 50, 51, 124, 50, 54, 51, 49, 53, 56, 46, 57, 48, 10, 49, 54, 51, 53, 124, 50, 53, 52, 56, 51, 52, 46, 53, 54, 10, 49, 55, 55, 54, 124, 50, 51, 52, 49, 56, 49, 46, 50, 48, 10, 49, 48, 57, 55, 124, 50, 51, 52, 49, 49, 51, 46, 53, 53, 10, 49, 50, 53, 56, 124, 50, 51, 51, 53, 48, 48, 46, 54, 49, 10, 54, 50, 49, 124, 50, 51, 51, 52, 51, 49, 46, 51, 48, 10, 49, 53, 50, 124, 50, 50, 57, 55, 56, 49, 46, 54, 48, 10, 50, 55, 56, 124, 50, 49, 54, 51, 55, 50, 46, 56, 52, 10, 50, 51, 50, 124, 50, 49, 49, 56, 55, 57, 46, 57, 50, 10, 49, 54, 56, 52, 124, 50, 48, 49, 51, 56, 54, 46, 50, 50, 10, 49, 50, 52, 51, 124, 49, 57, 57, 53, 56, 55, 46, 53, 52, 10, 57, 55, 54, 124, 49, 57, 55, 52, 51, 50, 46, 49, 48, 10, 56, 49, 57, 124, 49, 57, 49, 52, 55, 53, 46, 57, 48, 10, 49, 57, 52, 51, 124, 49, 57, 49, 50, 52, 55, 46, 55, 54, 10, 56, 53, 51, 124, 49, 56, 57, 50, 51, 50, 46, 54, 52, 10, 52, 48, 48, 124, 49, 56, 56, 57, 52, 49, 46, 50, 48, 10, 54, 51, 57, 124, 49, 56, 54, 53, 51, 51, 46, 50, 56, 10, 56, 53, 49, 124, 49, 56, 52, 49, 48, 51, 46, 49, 54, 10, 57, 48, 57, 124, 49, 55, 53, 48, 57, 57, 46, 48, 48, 10, 50, 53, 55, 124, 49, 54, 57, 48, 51, 51, 46, 52, 52, 10, 49, 52, 52, 53, 124, 49, 54, 52, 56, 56, 56, 46, 54, 56, 10, 49, 56, 53, 53, 124, 49, 54, 52, 54, 49, 52, 46, 56, 49, 10, 49, 50, 53, 50, 124, 49, 53, 56, 54, 56, 48, 46, 57, 48, 10, 49, 48, 49, 52, 124, 49, 53, 54, 52, 54, 53, 46, 56, 50, 10, 49, 55, 49, 55, 124, 49, 52, 56, 51, 50, 53, 46, 55, 53, 10, 49, 48, 51, 50, 124, 49, 52, 54, 52, 48, 56, 46, 52, 48, 10, 55, 56, 48, 124, 49, 51, 54, 50, 57, 54, 46, 50, 54, 10, 57, 49, 56, 124, 49, 51, 53, 50, 54, 56, 46, 51, 50, 10, 54, 57, 48, 124, 49, 51, 51, 56, 50, 54, 46, 56, 56, 10, 55, 49, 49, 124, 49, 49, 51, 50, 54, 56, 46, 56, 52, 10, 51, 51, 50, 124, 49, 49, 50, 49, 56, 49, 46, 51, 48, 10, 49, 53, 57, 54, 124, 49, 49, 48, 53, 54, 53, 46, 48, 48, 10, 50, 57, 53, 124, 57, 55, 54, 48, 52, 46, 50, 53, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q12[] = {108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 124, 104, 105, 103, 104, 95, 108, 105, 110, 101, 95, 99, 111, 117, 110, 116, 124, 108, 111, 119, 95, 108, 105, 110, 101, 95, 99, 111, 117, 110, 116, 10, 77, 65, 73, 76, 124, 54, 52, 124, 56, 54, 10, 83, 72, 73, 80, 124, 54, 49, 124, 57, 54, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q13[] = {99, 95, 99, 111, 117, 110, 116, 124, 99, 117, 115, 116, 100, 105, 115, 116, 10, 48, 124, 53, 48, 48, 10, 49, 49, 124, 54, 56, 10, 49, 48, 124, 54, 52, 10, 49, 50, 124, 54, 50, 10, 57, 124, 54, 50, 10, 56, 124, 54, 49, 10, 49, 52, 124, 53, 52, 10, 49, 51, 124, 53, 50, 10, 55, 124, 52, 57, 10, 50, 48, 124, 52, 56, 10, 50, 49, 124, 52, 55, 10, 49, 54, 124, 52, 54, 10, 49, 53, 124, 52, 53, 10, 49, 57, 124, 52, 52, 10, 49, 55, 124, 52, 49, 10, 49, 56, 124, 51, 56, 10, 50, 50, 124, 51, 51, 10, 54, 124, 51, 51, 10, 50, 52, 124, 51, 48, 10, 50, 51, 124, 50, 55, 10, 50, 53, 124, 50, 49, 10, 50, 55, 124, 49, 55, 10, 50, 54, 124, 49, 53, 10, 53, 124, 49, 52, 10, 50, 56, 124, 54, 10, 52, 124, 54, 10, 51, 50, 124, 53, 10, 50, 57, 124, 53, 10, 51, 48, 124, 50, 10, 51, 124, 50, 10, 51, 49, 124, 49, 10, 50, 124, 49, 10, 49, 124, 49, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q14[] = {112, 114, 111, 109, 111, 95, 114, 101, 118, 101, 110, 117, 101, 10, 49, 53, 46, 52, 56, 54, 53, 52, 53, 56, 49, 50, 50, 56, 52, 48, 55, 49, 53, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q15[] = {115, 95, 115, 117, 112, 112, 107, 101, 121, 124, 115, 95, 110, 97, 109, 101, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 124, 115, 95, 112, 104, 111, 110, 101, 124, 116, 111, 116, 97, 108, 95, 114, 101, 118, 101, 110, 117, 101, 10, 50, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 50, 49, 124, 84, 90, 111, 81, 119, 78, 70, 70, 79, 32, 105, 44, 98, 97, 88, 112, 98, 112, 105, 110, 48, 50, 44, 104, 118, 117, 104, 69, 44, 71, 82, 86, 73, 75, 109, 32, 124, 49, 50, 45, 50, 53, 51, 45, 53, 57, 48, 45, 53, 56, 49, 54, 124, 49, 49, 54, 49, 48, 57, 57, 46, 52, 54, 51, 54, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q16[] = {112, 95, 98, 114, 97, 110, 100, 124, 112, 95, 116, 121, 112, 101, 124, 112, 95, 115, 105, 122, 101, 124, 115, 117, 112, 112, 108, 105, 101, 114, 95, 99, 110, 116, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q17[] = {97, 118, 103, 95, 121, 101, 97, 114, 108, 121, 10, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q18[] = {99, 95, 110, 97, 109, 101, 124, 99, 95, 99, 117, 115, 116, 107, 101, 121, 124, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 124, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 124, 111, 95, 116, 111, 116, 97, 108, 112, 114, 105, 99, 101, 124, 115, 117, 109, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 54, 55, 124, 54, 54, 55, 124, 50, 57, 49, 53, 56, 124, 49, 57, 57, 53, 45, 49, 48, 45, 50, 49, 124, 52, 51, 57, 54, 56, 55, 46, 50, 51, 124, 51, 48, 53, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 55, 56, 124, 49, 55, 56, 124, 54, 56, 56, 50, 124, 49, 57, 57, 55, 45, 48, 52, 45, 48, 57, 124, 52, 50, 50, 51, 53, 57, 46, 54, 53, 124, 51, 48, 51, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q19[] = {114, 101, 118, 101, 110, 117, 101, 10, 50, 50, 57, 50, 51, 46, 48, 50, 56, 48, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q20[] = {115, 95, 110, 97, 109, 101, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 49, 51, 124, 107, 103, 84, 90, 106, 98, 116, 52, 67, 65, 97, 52, 99, 51, 83, 108, 105, 114, 108, 66, 76, 113, 73, 76, 52, 49, 89, 98, 67, 106, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q21[] = {115, 95, 110, 97, 109, 101, 124, 110, 117, 109, 119, 97, 105, 116, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 55, 52, 124, 57, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_01_q22[] = {99, 110, 116, 114, 121, 99, 111, 100, 101, 124, 110, 117, 109, 99, 117, 115, 116, 124, 116, 111, 116, 97, 99, 99, 116, 98, 97, 108, 10, 49, 51, 124, 49, 48, 124, 55, 53, 51, 53, 57, 46, 50, 57, 10, 49, 55, 124, 56, 124, 54, 50, 50, 56, 56, 46, 57, 56, 10, 49, 56, 124, 49, 52, 124, 49, 49, 49, 48, 55, 50, 46, 52, 53, 10, 50, 51, 124, 53, 124, 52, 48, 52, 53, 56, 46, 56, 54, 10, 50, 57, 124, 49, 49, 124, 56, 56, 55, 50, 50, 46, 56, 53, 10, 51, 48, 124, 49, 55, 124, 49, 50, 50, 49, 56, 57, 46, 51, 51, 10, 51, 49, 124, 56, 124, 54, 54, 51, 49, 51, 46, 49, 54, 10, 0};
-const char *TPCH_ANSWERS_SF0_01[] = {
-	(const char*) TPCH_ANSWERS_SF0_01_q01,
-	(const char*) TPCH_ANSWERS_SF0_01_q02,
-	(const char*) TPCH_ANSWERS_SF0_01_q03,
-	(const char*) TPCH_ANSWERS_SF0_01_q04,
-	(const char*) TPCH_ANSWERS_SF0_01_q05,
-	(const char*) TPCH_ANSWERS_SF0_01_q06,
-	(const char*) TPCH_ANSWERS_SF0_01_q07,
-	(const char*) TPCH_ANSWERS_SF0_01_q08,
-	(const char*) TPCH_ANSWERS_SF0_01_q09,
-	(const char*) TPCH_ANSWERS_SF0_01_q10,
-	(const char*) TPCH_ANSWERS_SF0_01_q11,
-	(const char*) TPCH_ANSWERS_SF0_01_q12,
-	(const char*) TPCH_ANSWERS_SF0_01_q13,
-	(const char*) TPCH_ANSWERS_SF0_01_q14,
-	(const char*) TPCH_ANSWERS_SF0_01_q15,
-	(const char*) TPCH_ANSWERS_SF0_01_q16,
-	(const char*) TPCH_ANSWERS_SF0_01_q17,
-	(const char*) TPCH_ANSWERS_SF0_01_q18,
-	(const char*) TPCH_ANSWERS_SF0_01_q19,
-	(const char*) TPCH_ANSWERS_SF0_01_q20,
-	(const char*) TPCH_ANSWERS_SF0_01_q21,
-	(const char*) TPCH_ANSWERS_SF0_01_q22
-};
-const uint8_t TPCH_ANSWERS_SF0_1_q01[] = {108, 95, 114, 101, 116, 117, 114, 110, 102, 108, 97, 103, 124, 108, 95, 108, 105, 110, 101, 115, 116, 97, 116, 117, 115, 124, 115, 117, 109, 95, 113, 116, 121, 124, 115, 117, 109, 95, 98, 97, 115, 101, 95, 112, 114, 105, 99, 101, 124, 115, 117, 109, 95, 100, 105, 115, 99, 95, 112, 114, 105, 99, 101, 124, 115, 117, 109, 95, 99, 104, 97, 114, 103, 101, 124, 97, 118, 103, 95, 113, 116, 121, 124, 97, 118, 103, 95, 112, 114, 105, 99, 101, 124, 97, 118, 103, 95, 100, 105, 115, 99, 124, 99, 111, 117, 110, 116, 95, 111, 114, 100, 101, 114, 10, 65, 124, 70, 124, 51, 55, 55, 52, 50, 48, 48, 124, 53, 51, 50, 48, 55, 53, 51, 56, 56, 48, 46, 54, 57, 124, 53, 48, 53, 52, 48, 57, 54, 50, 54, 54, 46, 54, 56, 50, 56, 124, 53, 50, 53, 54, 55, 53, 49, 51, 51, 49, 46, 52, 52, 57, 50, 51, 52, 124, 50, 53, 46, 53, 51, 55, 53, 56, 55, 49, 49, 54, 56, 53, 52, 57, 57, 55, 48, 124, 51, 54, 48, 48, 50, 46, 49, 50, 51, 56, 50, 57, 48, 49, 52, 49, 52, 50, 124, 48, 46, 48, 53, 48, 49, 52, 52, 53, 57, 55, 48, 54, 51, 52, 48, 48, 55, 55, 49, 51, 54, 124, 49, 52, 55, 55, 57, 48, 10, 78, 124, 70, 124, 57, 53, 50, 53, 55, 124, 49, 51, 51, 55, 51, 55, 55, 57, 53, 46, 56, 52, 124, 49, 50, 55, 49, 51, 50, 51, 55, 50, 46, 54, 53, 49, 50, 124, 49, 51, 50, 50, 56, 54, 50, 57, 49, 46, 50, 50, 57, 52, 52, 53, 124, 50, 53, 46, 51, 48, 48, 54, 54, 52, 48, 49, 48, 54, 50, 52, 49, 55, 48, 48, 124, 51, 53, 53, 50, 49, 46, 51, 50, 54, 57, 49, 54, 51, 51, 52, 54, 54, 49, 124, 48, 46, 48, 52, 57, 51, 57, 52, 52, 50, 50, 51, 49, 48, 55, 53, 54, 57, 55, 50, 49, 49, 124, 51, 55, 54, 53, 10, 78, 124, 79, 124, 55, 52, 53, 57, 50, 57, 55, 124, 49, 48, 53, 49, 50, 50, 55, 48, 48, 48, 56, 46, 57, 48, 124, 57, 57, 56, 54, 50, 51, 56, 51, 51, 56, 46, 51, 56, 52, 55, 124, 49, 48, 51, 56, 53, 53, 55, 56, 51, 55, 54, 46, 53, 56, 53, 52, 54, 55, 124, 50, 53, 46, 53, 52, 53, 53, 51, 55, 54, 55, 49, 50, 51, 50, 56, 55, 54, 55, 124, 51, 54, 48, 48, 48, 46, 57, 50, 52, 54, 56, 56, 48, 49, 51, 54, 57, 57, 124, 48, 46, 48, 53, 48, 48, 57, 53, 57, 53, 56, 57, 48, 52, 49, 48, 57, 53, 56, 57, 48, 52, 124, 50, 57, 50, 48, 48, 48, 10, 82, 124, 70, 124, 51, 55, 56, 53, 53, 50, 51, 124, 53, 51, 51, 55, 57, 53, 48, 53, 50, 54, 46, 52, 55, 124, 53, 48, 55, 49, 56, 49, 56, 53, 51, 50, 46, 57, 52, 50, 48, 124, 53, 50, 55, 52, 52, 48, 53, 53, 48, 51, 46, 48, 52, 57, 51, 54, 55, 124, 50, 53, 46, 53, 50, 53, 57, 52, 51, 56, 53, 55, 52, 50, 53, 49, 48, 49, 55, 124, 51, 53, 57, 57, 52, 46, 48, 50, 57, 50, 49, 52, 48, 51, 48, 57, 50, 52, 124, 48, 46, 48, 52, 57, 57, 56, 57, 50, 55, 56, 53, 54, 49, 56, 52, 51, 56, 49, 55, 54, 52, 124, 49, 52, 56, 51, 48, 49, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q02[] = {115, 95, 97, 99, 99, 116, 98, 97, 108, 124, 115, 95, 110, 97, 109, 101, 124, 110, 95, 110, 97, 109, 101, 124, 112, 95, 112, 97, 114, 116, 107, 101, 121, 124, 112, 95, 109, 102, 103, 114, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 124, 115, 95, 112, 104, 111, 110, 101, 124, 115, 95, 99, 111, 109, 109, 101, 110, 116, 10, 57, 56, 50, 56, 46, 50, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 52, 55, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 51, 49, 50, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 118, 86, 54, 84, 101, 113, 49, 69, 118, 76, 108, 82, 124, 51, 51, 45, 50, 53, 56, 45, 50, 48, 50, 45, 52, 55, 56, 50, 124, 115, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 101, 118, 101, 110, 32, 105, 100, 101, 97, 115, 32, 112, 111, 97, 99, 104, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 10, 57, 53, 48, 56, 46, 51, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 55, 48, 124, 70, 82, 65, 78, 67, 69, 124, 51, 53, 54, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 106, 100, 52, 100, 106, 90, 118, 48, 99, 99, 53, 75, 100, 110, 65, 48, 113, 57, 111, 79, 113, 118, 99, 101, 97, 80, 85, 98, 78, 108, 111, 79, 87, 124, 49, 54, 45, 56, 50, 49, 45, 54, 48, 56, 45, 49, 49, 54, 54, 124, 101, 115, 116, 115, 32, 115, 108, 101, 101, 112, 32, 113, 117, 105, 99, 107, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 105, 100, 101, 97, 115, 46, 32, 105, 114, 111, 110, 105, 99, 32, 105, 100, 101, 97, 115, 32, 104, 97, 103, 103, 108, 101, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 102, 105, 110, 97, 108, 32, 84, 10, 57, 53, 48, 56, 46, 51, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 55, 48, 124, 70, 82, 65, 78, 67, 69, 124, 49, 55, 50, 54, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 106, 100, 52, 100, 106, 90, 118, 48, 99, 99, 53, 75, 100, 110, 65, 48, 113, 57, 111, 79, 113, 118, 99, 101, 97, 80, 85, 98, 78, 108, 111, 79, 87, 124, 49, 54, 45, 56, 50, 49, 45, 54, 48, 56, 45, 49, 49, 54, 54, 124, 101, 115, 116, 115, 32, 115, 108, 101, 101, 112, 32, 113, 117, 105, 99, 107, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 105, 100, 101, 97, 115, 46, 32, 105, 114, 111, 110, 105, 99, 32, 105, 100, 101, 97, 115, 32, 104, 97, 103, 103, 108, 101, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 102, 105, 110, 97, 108, 32, 84, 10, 57, 52, 53, 51, 46, 48, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 48, 50, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 48, 48, 50, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 49, 85, 106, 50, 51, 81, 87, 120, 81, 106, 106, 55, 69, 121, 101, 113, 72, 87, 113, 71, 87, 84, 98, 78, 124, 50, 57, 45, 51, 52, 50, 45, 56, 56, 50, 45, 54, 52, 54, 51, 124, 103, 117, 108, 97, 114, 32, 102, 114, 101, 116, 115, 46, 32, 112, 101, 114, 109, 97, 110, 101, 110, 116, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 109, 117, 108, 116, 105, 112, 108, 105, 101, 114, 115, 32, 98, 101, 108, 105, 101, 118, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 108, 111, 110, 103, 115, 10, 57, 52, 53, 51, 46, 48, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 48, 50, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 51, 50, 55, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 49, 85, 106, 50, 51, 81, 87, 120, 81, 106, 106, 55, 69, 121, 101, 113, 72, 87, 113, 71, 87, 84, 98, 78, 124, 50, 57, 45, 51, 52, 50, 45, 56, 56, 50, 45, 54, 52, 54, 51, 124, 103, 117, 108, 97, 114, 32, 102, 114, 101, 116, 115, 46, 32, 112, 101, 114, 109, 97, 110, 101, 110, 116, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 109, 117, 108, 116, 105, 112, 108, 105, 101, 114, 115, 32, 98, 101, 108, 105, 101, 118, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 108, 111, 110, 103, 115, 10, 57, 49, 57, 50, 46, 49, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 49, 53, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 51, 51, 50, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 69, 104, 114, 89, 121, 48, 77, 84, 53, 77, 49, 118, 102, 90, 48, 86, 52, 115, 107, 112, 105, 102, 100, 112, 54, 112, 103, 70, 122, 53, 124, 51, 51, 45, 53, 57, 55, 45, 50, 52, 56, 45, 49, 50, 50, 48, 124, 101, 115, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 98, 111, 111, 115, 116, 32, 99, 97, 114, 101, 102, 10, 57, 48, 51, 50, 46, 49, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 53, 57, 124, 71, 69, 82, 77, 65, 78, 89, 124, 52, 57, 53, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 84, 75, 32, 113, 114, 110, 106, 112, 68, 118, 100, 49, 74, 99, 124, 49, 55, 45, 49, 48, 56, 45, 54, 52, 50, 45, 51, 49, 48, 54, 124, 110, 100, 105, 110, 103, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 32, 110, 97, 103, 32, 102, 117, 114, 105, 111, 117, 10, 56, 55, 48, 50, 46, 48, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 51, 51, 124, 82, 85, 83, 83, 73, 65, 124, 49, 49, 56, 49, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 102, 81, 53, 76, 114, 52, 75, 118, 98, 78, 72, 73, 51, 87, 68, 77, 104, 107, 99, 73, 32, 83, 54, 120, 89, 116, 103, 73, 105, 49, 107, 124, 51, 50, 45, 53, 48, 56, 45, 50, 48, 50, 45, 54, 49, 51, 54, 124, 111, 115, 115, 32, 116, 104, 101, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 118, 101, 110, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 46, 32, 114, 101, 103, 117, 108, 97, 114, 32, 102, 111, 120, 101, 115, 32, 100, 101, 116, 101, 99, 116, 32, 97, 108, 111, 10, 56, 54, 49, 53, 46, 53, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 49, 50, 124, 70, 82, 65, 78, 67, 69, 124, 49, 48, 53, 53, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 84, 65, 74, 87, 121, 78, 115, 116, 56, 79, 71, 86, 80, 73, 78, 103, 113, 116, 122, 119, 121, 121, 112, 48, 48, 50, 105, 89, 78, 68, 86, 117, 98, 124, 49, 54, 45, 53, 56, 53, 45, 55, 50, 52, 45, 54, 54, 51, 51, 124, 121, 32, 113, 117, 105, 99, 107, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 111, 115, 105, 116, 115, 63, 32, 113, 117, 105, 99, 107, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 10, 56, 54, 49, 53, 46, 53, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 49, 50, 124, 70, 82, 65, 78, 67, 69, 124, 49, 51, 56, 49, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 84, 65, 74, 87, 121, 78, 115, 116, 56, 79, 71, 86, 80, 73, 78, 103, 113, 116, 122, 119, 121, 121, 112, 48, 48, 50, 105, 89, 78, 68, 86, 117, 98, 124, 49, 54, 45, 53, 56, 53, 45, 55, 50, 52, 45, 54, 54, 51, 51, 124, 121, 32, 113, 117, 105, 99, 107, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 111, 115, 105, 116, 115, 63, 32, 113, 117, 105, 99, 107, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 10, 56, 52, 56, 56, 46, 53, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 54, 55, 124, 82, 85, 83, 83, 73, 65, 124, 54, 56, 53, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 110, 114, 56, 119, 82, 81, 32, 97, 53, 76, 88, 88, 101, 115, 115, 124, 51, 50, 45, 52, 53, 56, 45, 49, 57, 56, 45, 57, 53, 53, 55, 124, 97, 103, 101, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 105, 110, 97, 108, 32, 101, 120, 99, 117, 115, 101, 115, 32, 110, 97, 103, 32, 102, 105, 110, 97, 108, 108, 121, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 97, 98, 111, 118, 10, 56, 52, 51, 48, 46, 53, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 52, 54, 124, 70, 82, 65, 78, 67, 69, 124, 49, 49, 51, 56, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 106, 54, 115, 122, 69, 56, 48, 89, 67, 112, 76, 72, 74, 52, 98, 90, 55, 70, 51, 55, 103, 85, 105, 71, 104, 107, 48, 87, 74, 48, 44, 56, 104, 57, 121, 124, 49, 54, 45, 54, 48, 49, 45, 50, 50, 48, 45, 53, 52, 56, 57, 124, 105, 116, 101, 115, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 97, 108, 119, 97, 121, 115, 32, 102, 105, 110, 97, 108, 32, 105, 100, 101, 97, 115, 32, 107, 105, 110, 100, 108, 101, 32, 97, 99, 99, 111, 114, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46, 32, 110, 111, 116, 111, 114, 110, 105, 115, 32, 105, 110, 10, 56, 50, 55, 49, 46, 51, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 52, 54, 124, 82, 85, 83, 83, 73, 65, 124, 52, 54, 51, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 65, 112, 110, 100, 75, 112, 32, 44, 87, 117, 48, 32, 76, 78, 115, 111, 86, 48, 75, 108, 100, 120, 121, 111, 73, 108, 89, 124, 51, 50, 45, 55, 57, 50, 45, 54, 49, 57, 45, 51, 49, 53, 53, 124, 115, 32, 99, 97, 106, 111, 108, 101, 32, 113, 117, 105, 99, 107, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 101, 110, 116, 105, 99, 105, 110, 103, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 32, 104, 10, 56, 48, 57, 54, 46, 57, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 55, 52, 124, 82, 85, 83, 83, 73, 65, 124, 51, 50, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 90, 99, 83, 114, 122, 117, 82, 75, 89, 69, 71, 112, 99, 120, 109, 73, 115, 72, 44, 66, 114, 89, 66, 77, 119, 72, 48, 124, 51, 50, 45, 56, 54, 54, 45, 50, 52, 54, 45, 56, 55, 53, 50, 124, 117, 108, 108, 121, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 32, 119, 97, 107, 101, 32, 115, 108, 121, 108, 121, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 98, 117, 115, 121, 32, 100, 101, 112, 111, 115, 105, 116, 10, 55, 51, 57, 50, 46, 55, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 55, 48, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 55, 54, 53, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 97, 121, 122, 51, 97, 49, 56, 120, 68, 71, 114, 114, 51, 106, 116, 83, 124, 51, 51, 45, 56, 48, 51, 45, 51, 52, 48, 45, 53, 51, 57, 56, 124, 97, 107, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 113, 117, 105, 99, 107, 108, 121, 10, 55, 50, 48, 53, 46, 50, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 55, 55, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 48, 57, 53, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 54, 121, 81, 100, 103, 101, 86, 101, 65, 120, 74, 86, 116, 74, 84, 73, 89, 70, 78, 78, 87, 118, 81, 76, 124, 49, 55, 45, 49, 56, 48, 45, 49, 52, 52, 45, 55, 57, 57, 49, 124, 32, 101, 120, 99, 117, 115, 101, 115, 32, 119, 97, 107, 101, 32, 101, 120, 112, 114, 101, 115, 115, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 99, 97, 114, 101, 102, 117, 108, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 32, 97, 99, 99, 111, 114, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 10, 54, 56, 50, 48, 46, 51, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 48, 55, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 51, 50, 49, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 32, 48, 87, 55, 73, 80, 100, 107, 112, 87, 121, 99, 85, 98, 81, 57, 65, 100, 112, 54, 66, 124, 51, 51, 45, 57, 57, 48, 45, 57, 54, 53, 45, 50, 50, 48, 49, 124, 115, 32, 117, 110, 119, 105, 110, 100, 32, 115, 105, 108, 101, 110, 116, 108, 121, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 99, 111, 117, 114, 116, 115, 46, 32, 102, 105, 110, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 97, 114, 101, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 119, 97, 107, 101, 32, 113, 117, 105, 101, 116, 108, 121, 32, 98, 108, 105, 116, 10, 54, 55, 50, 49, 46, 55, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 53, 52, 124, 70, 82, 65, 78, 67, 69, 124, 52, 49, 57, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 99, 88, 99, 86, 66, 115, 54, 108, 115, 90, 98, 122, 102, 69, 49, 52, 124, 49, 54, 45, 53, 51, 55, 45, 51, 52, 49, 45, 56, 53, 49, 55, 124, 101, 99, 116, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 10, 54, 51, 50, 57, 46, 57, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 57, 54, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 48, 55, 51, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 53, 117, 87, 78, 97, 119, 99, 113, 118, 52, 73, 76, 56, 111, 107, 121, 66, 76, 32, 101, 124, 49, 55, 45, 52, 52, 55, 45, 56, 49, 49, 45, 51, 50, 56, 50, 124, 32, 105, 114, 111, 110, 105, 99, 32, 102, 111, 114, 103, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 103, 97, 105, 10, 54, 49, 55, 51, 46, 56, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 48, 56, 124, 82, 85, 83, 83, 73, 65, 124, 49, 56, 49, 51, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 66, 79, 67, 32, 90, 121, 48, 119, 104, 51, 114, 67, 71, 72, 68, 103, 86, 48, 78, 73, 71, 116, 50, 100, 69, 75, 124, 51, 50, 45, 56, 53, 56, 45, 55, 50, 52, 45, 50, 57, 53, 48, 124, 98, 108, 105, 116, 104, 101, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 108, 121, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 110, 111, 116, 111, 114, 110, 105, 115, 46, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 108, 32, 10, 53, 51, 54, 52, 46, 57, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 56, 53, 124, 82, 85, 83, 83, 73, 65, 124, 49, 51, 55, 56, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 53, 114, 53, 71, 106, 113, 66, 97, 116, 110, 89, 65, 72, 97, 72, 53, 107, 66, 52, 73, 80, 99, 66, 69, 105, 103, 108, 77, 74, 69, 110, 78, 52, 116, 85, 85, 71, 54, 107, 50, 124, 51, 50, 45, 50, 57, 55, 45, 54, 53, 51, 45, 50, 50, 48, 51, 124, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 98, 111, 111, 115, 116, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 46, 32, 101, 120, 112, 114, 101, 115, 115, 32, 105, 100, 101, 97, 115, 32, 97, 108, 111, 110, 103, 10, 53, 48, 54, 57, 46, 50, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 50, 56, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 54, 51, 50, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 57, 101, 69, 89, 87, 79, 114, 52, 107, 85, 90, 124, 49, 55, 45, 50, 51, 49, 45, 53, 49, 51, 45, 53, 55, 50, 49, 124, 104, 101, 32, 117, 110, 117, 115, 117, 97, 108, 32, 105, 100, 101, 97, 115, 46, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 108, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 10, 52, 57, 52, 49, 46, 56, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 50, 49, 124, 82, 79, 77, 65, 78, 73, 65, 124, 55, 51, 50, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 67, 102, 68, 75, 108, 71, 86, 116, 77, 101, 80, 106, 116, 67, 119, 124, 50, 57, 45, 53, 55, 51, 45, 50, 55, 57, 45, 49, 52, 48, 54, 124, 121, 32, 102, 105, 110, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 105, 109, 112, 114, 101, 115, 115, 32, 115, 10, 52, 54, 55, 50, 46, 50, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 51, 57, 124, 82, 85, 83, 83, 73, 65, 124, 49, 50, 50, 51, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 52, 99, 90, 44, 90, 72, 75, 106, 32, 104, 82, 75, 103, 89, 108, 103, 90, 54, 85, 97, 112, 81, 55, 109, 114, 69, 79, 111, 122, 101, 81, 77, 120, 55, 75, 104, 85, 67, 83, 124, 51, 50, 45, 51, 57, 54, 45, 54, 53, 52, 45, 54, 56, 50, 54, 124, 97, 114, 108, 115, 32, 119, 97, 107, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 101, 118, 101, 110, 44, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 101, 110, 10, 52, 53, 56, 54, 46, 52, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 56, 48, 124, 82, 85, 83, 83, 73, 65, 124, 53, 54, 55, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 55, 74, 119, 110, 76, 79, 109, 76, 104, 74, 49, 97, 80, 77, 84, 54, 49, 80, 83, 120, 57, 107, 99, 89, 55, 55, 114, 44, 72, 109, 82, 85, 68, 51, 49, 52, 109, 124, 51, 50, 45, 53, 50, 50, 45, 51, 56, 50, 45, 49, 54, 50, 48, 124, 32, 116, 104, 101, 32, 114, 101, 103, 117, 108, 97, 114, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 98, 111, 108, 100, 32, 101, 120, 99, 117, 115, 101, 115, 32, 117, 110, 100, 101, 114, 32, 116, 104, 10, 52, 53, 49, 56, 46, 51, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 52, 57, 124, 70, 82, 65, 78, 67, 69, 124, 49, 56, 51, 52, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 67, 53, 116, 52, 122, 73, 99, 73, 78, 66, 107, 103, 66, 87, 100, 77, 103, 54, 87, 116, 103, 77, 116, 69, 124, 49, 54, 45, 54, 54, 48, 45, 53, 53, 51, 45, 50, 52, 53, 54, 124, 116, 115, 32, 100, 101, 116, 101, 99, 116, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 102, 111, 120, 101, 115, 46, 32, 102, 105, 110, 97, 108, 32, 84, 105, 114, 101, 115, 105, 97, 115, 32, 97, 114, 101, 46, 32, 105, 100, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 104, 97, 103, 103, 108, 101, 59, 32, 101, 118, 101, 110, 44, 32, 98, 108, 105, 116, 104, 101, 32, 112, 105, 110, 10, 52, 51, 49, 53, 46, 49, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 48, 57, 124, 70, 82, 65, 78, 67, 69, 124, 49, 56, 57, 55, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 57, 108, 84, 78, 57, 84, 53, 86, 66, 103, 124, 49, 54, 45, 50, 57, 56, 45, 49, 53, 52, 45, 51, 51, 54, 53, 124, 114, 111, 110, 105, 99, 32, 111, 114, 98, 105, 116, 115, 32, 97, 114, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 105, 100, 101, 97, 115, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 115, 112, 101, 99, 105, 97, 108, 44, 32, 98, 111, 108, 100, 10, 51, 53, 50, 54, 46, 53, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 53, 51, 124, 70, 82, 65, 78, 67, 69, 124, 56, 48, 51, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 82, 48, 70, 73, 53, 68, 76, 51, 80, 111, 105, 124, 49, 54, 45, 53, 57, 57, 45, 53, 53, 50, 45, 51, 55, 53, 53, 124, 108, 97, 114, 32, 100, 105, 110, 111, 115, 32, 110, 97, 103, 32, 115, 108, 121, 108, 121, 32, 98, 114, 97, 118, 101, 10, 51, 53, 50, 54, 46, 53, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 53, 51, 124, 70, 82, 65, 78, 67, 69, 124, 49, 55, 48, 49, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 82, 48, 70, 73, 53, 68, 76, 51, 80, 111, 105, 124, 49, 54, 45, 53, 57, 57, 45, 53, 53, 50, 45, 51, 55, 53, 53, 124, 108, 97, 114, 32, 100, 105, 110, 111, 115, 32, 110, 97, 103, 32, 115, 108, 121, 108, 121, 32, 98, 114, 97, 118, 101, 10, 51, 50, 57, 52, 46, 54, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 53, 48, 124, 71, 69, 82, 77, 65, 78, 89, 124, 52, 56, 52, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 104, 105, 108, 117, 53, 85, 88, 77, 67, 119, 70, 118, 74, 74, 124, 49, 55, 45, 49, 49, 51, 45, 49, 56, 49, 45, 52, 48, 49, 55, 124, 101, 32, 115, 108, 121, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 102, 111, 120, 101, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 100, 101, 116, 101, 99, 116, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 114, 117, 116, 104, 108, 101, 115, 115, 32, 102, 111, 120, 101, 115, 46, 32, 113, 117, 105, 99, 107, 10, 50, 57, 55, 50, 46, 50, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 49, 54, 124, 82, 85, 83, 83, 73, 65, 124, 49, 48, 49, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 51, 72, 98, 86, 111, 87, 86, 115, 106, 110, 52, 102, 84, 102, 81, 71, 103, 89, 84, 115, 77, 97, 68, 118, 77, 73, 78, 66, 73, 68, 88, 113, 101, 66, 119, 75, 124, 51, 50, 45, 56, 50, 50, 45, 53, 48, 50, 45, 52, 50, 49, 53, 124, 111, 117, 115, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 105, 100, 101, 97, 115, 32, 104, 97, 103, 103, 108, 101, 32, 113, 117, 105, 99, 107, 108, 121, 32, 100, 117, 103, 111, 117, 116, 115, 63, 32, 102, 117, 10, 50, 57, 54, 51, 46, 48, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 52, 48, 124, 82, 79, 77, 65, 78, 73, 65, 124, 51, 48, 56, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 74, 50, 115, 54, 105, 117, 66, 103, 74, 111, 48, 51, 124, 50, 57, 45, 55, 56, 49, 45, 51, 51, 55, 45, 53, 53, 56, 52, 124, 101, 101, 112, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 115, 117, 98, 108, 97, 116, 101, 32, 97, 108, 111, 110, 103, 115, 105, 100, 101, 32, 111, 10, 50, 50, 50, 49, 46, 50, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 55, 49, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 51, 57, 56, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 71, 118, 49, 114, 105, 44, 86, 32, 65, 82, 72, 69, 49, 51, 54, 101, 74, 70, 124, 50, 57, 45, 57, 56, 54, 45, 51, 48, 52, 45, 57, 48, 48, 54, 124, 110, 97, 108, 32, 102, 111, 120, 101, 115, 32, 101, 97, 116, 32, 115, 108, 121, 108, 121, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 112, 101, 114, 109, 97, 110, 101, 110, 116, 32, 105, 100, 10, 49, 51, 56, 49, 46, 57, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 48, 52, 124, 70, 82, 65, 78, 67, 69, 124, 49, 56, 49, 48, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 111, 79, 70, 87, 116, 108, 32, 115, 65, 119, 89, 99, 98, 77, 57, 100, 87, 82, 80, 103, 75, 84, 83, 51, 69, 98, 109, 110, 57, 84, 99, 112, 51, 105, 122, 48, 70, 124, 49, 54, 45, 52, 51, 52, 45, 57, 55, 50, 45, 54, 57, 50, 50, 124, 103, 117, 108, 97, 114, 32, 105, 100, 101, 97, 115, 46, 32, 98, 114, 97, 118, 101, 108, 121, 32, 98, 111, 108, 100, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 104, 97, 103, 103, 108, 101, 32, 116, 104, 114, 111, 117, 103, 104, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 115, 108, 121, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 105, 100, 101, 97, 10, 57, 48, 54, 46, 48, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 51, 56, 124, 82, 79, 77, 65, 78, 73, 65, 124, 56, 51, 54, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 121, 121, 80, 66, 70, 114, 69, 114, 75, 84, 97, 69, 117, 53, 76, 51, 67, 100, 78, 74, 80, 32, 97, 107, 52, 121, 115, 57, 65, 98, 78, 44, 65, 106, 56, 119, 80, 103, 118, 124, 50, 57, 45, 53, 51, 51, 45, 52, 51, 52, 45, 54, 55, 55, 54, 124, 105, 99, 107, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 99, 97, 106, 111, 108, 101, 46, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 101, 120, 99, 117, 115, 101, 115, 32, 10, 55, 54, 53, 46, 54, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 57, 57, 124, 82, 85, 83, 83, 73, 65, 124, 49, 49, 50, 55, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 73, 118, 108, 100, 84, 50, 112, 88, 55, 82, 32, 101, 108, 124, 51, 50, 45, 53, 55, 57, 45, 51, 51, 57, 45, 49, 52, 57, 53, 124, 110, 117, 115, 117, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 101, 112, 105, 116, 97, 112, 104, 115, 32, 105, 110, 116, 101, 103, 114, 97, 116, 101, 46, 32, 115, 108, 121, 108, 121, 32, 10, 55, 50, 55, 46, 56, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 55, 48, 124, 82, 79, 77, 65, 78, 73, 65, 124, 54, 50, 49, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 52, 79, 71, 80, 115, 32, 113, 75, 112, 102, 81, 54, 71, 78, 76, 73, 75, 104, 109, 98, 73, 69, 54, 101, 55, 102, 83, 77, 80, 56, 102, 109, 119, 105, 124, 50, 57, 45, 49, 54, 53, 45, 50, 56, 57, 45, 49, 53, 50, 51, 124, 103, 117, 108, 97, 114, 32, 101, 120, 99, 117, 115, 101, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 101, 120, 99, 117, 115, 101, 115, 32, 115, 108, 101, 101, 112, 32, 115, 108, 121, 108, 121, 32, 99, 97, 114, 101, 102, 10, 54, 56, 51, 46, 48, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 53, 49, 124, 82, 85, 83, 83, 73, 65, 124, 52, 56, 56, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 68, 52, 77, 71, 73, 113, 53, 85, 122, 48, 44, 75, 124, 51, 50, 45, 49, 56, 49, 45, 52, 50, 54, 45, 52, 52, 57, 48, 124, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 97, 98, 111, 117, 10, 49, 54, 55, 46, 53, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 57, 48, 124, 70, 82, 65, 78, 67, 69, 124, 50, 48, 51, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 86, 112, 71, 44, 85, 108, 53, 121, 118, 49, 82, 103, 65, 75, 44, 44, 124, 49, 54, 45, 54, 55, 53, 45, 50, 56, 54, 45, 53, 49, 48, 50, 124, 32, 116, 104, 101, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46, 32, 105, 114, 111, 110, 105, 99, 44, 32, 105, 114, 111, 110, 105, 99, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 97, 98, 111, 118, 101, 32, 10, 57, 49, 46, 51, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 52, 57, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 57, 52, 51, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 82, 48, 54, 109, 48, 86, 68, 57, 53, 70, 90, 76, 111, 66, 74, 72, 99, 67, 77, 121, 97, 90, 81, 72, 105, 116, 113, 109, 104, 90, 114, 81, 90, 107, 90, 107, 53, 124, 51, 51, 45, 51, 51, 50, 45, 54, 57, 55, 45, 50, 55, 54, 56, 124, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 104, 97, 103, 103, 10, 45, 51, 49, 52, 46, 48, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 49, 48, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 55, 50, 52, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 54, 69, 51, 97, 70, 115, 48, 119, 50, 83, 105, 73, 109, 122, 77, 68, 83, 101, 119, 87, 116, 122, 79, 119, 100, 112, 76, 122, 50, 124, 50, 57, 45, 50, 48, 55, 45, 56, 53, 50, 45, 51, 52, 53, 52, 124, 32, 98, 111, 108, 100, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 118, 101, 110, 32, 100, 10, 45, 56, 50, 48, 46, 56, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 48, 57, 124, 71, 69, 82, 77, 65, 78, 89, 124, 50, 49, 53, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 103, 116, 51, 54, 50, 109, 115, 84, 81, 51, 65, 119, 116, 85, 86, 72, 103, 113, 80, 55, 82, 121, 107, 115, 107, 57, 48, 100, 110, 112, 80, 78, 121, 110, 124, 49, 55, 45, 55, 49, 57, 45, 53, 49, 55, 45, 57, 56, 51, 54, 124, 121, 32, 102, 105, 110, 97, 108, 44, 32, 115, 108, 111, 119, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 10, 45, 56, 52, 53, 46, 52, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 48, 52, 124, 82, 79, 77, 65, 78, 73, 65, 124, 57, 57, 50, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 75, 97, 119, 70, 112, 66, 80, 65, 65, 68, 114, 86, 110, 75, 67, 44, 112, 76, 76, 57, 113, 51, 84, 83, 121, 72, 71, 57, 120, 124, 50, 57, 45, 51, 48, 48, 45, 56, 57, 54, 45, 53, 57, 57, 49, 124, 99, 116, 105, 111, 110, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 115, 108, 121, 32, 114, 101, 113, 117, 10, 45, 57, 52, 50, 46, 55, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 54, 51, 124, 71, 69, 82, 77, 65, 78, 89, 124, 53, 55, 57, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 97, 79, 84, 54, 90, 80, 57, 54, 74, 50, 32, 44, 88, 104, 110, 124, 49, 55, 45, 49, 48, 56, 45, 53, 51, 55, 45, 50, 54, 57, 49, 124, 115, 108, 121, 108, 121, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 99, 111, 121, 115, 59, 32, 115, 105, 108, 101, 110, 116, 44, 32, 115, 112, 101, 99, 105, 97, 108, 32, 114, 101, 97, 108, 109, 115, 32, 112, 111, 97, 99, 104, 32, 102, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q03[] = {108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 124, 114, 101, 118, 101, 110, 117, 101, 124, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 124, 111, 95, 115, 104, 105, 112, 112, 114, 105, 111, 114, 105, 116, 121, 10, 50, 50, 51, 49, 52, 48, 124, 51, 53, 53, 51, 54, 57, 46, 48, 54, 57, 56, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 52, 124, 48, 10, 53, 56, 52, 50, 57, 49, 124, 51, 53, 52, 52, 57, 52, 46, 55, 51, 49, 56, 124, 49, 57, 57, 53, 45, 48, 50, 45, 50, 49, 124, 48, 10, 52, 48, 53, 48, 54, 51, 124, 51, 53, 51, 49, 50, 53, 46, 52, 53, 55, 55, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 51, 124, 48, 10, 53, 55, 51, 56, 54, 49, 124, 51, 53, 49, 50, 51, 56, 46, 50, 55, 55, 48, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 57, 124, 48, 10, 53, 53, 52, 55, 53, 55, 124, 51, 52, 57, 49, 56, 49, 46, 55, 52, 50, 54, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 52, 124, 48, 10, 53, 48, 54, 48, 50, 49, 124, 51, 50, 49, 48, 55, 53, 46, 53, 56, 49, 48, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 48, 124, 48, 10, 49, 50, 49, 54, 48, 52, 124, 51, 49, 56, 53, 55, 54, 46, 52, 49, 53, 52, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 55, 124, 48, 10, 49, 48, 56, 53, 49, 52, 124, 51, 49, 52, 57, 54, 55, 46, 48, 55, 53, 52, 124, 49, 57, 57, 53, 45, 48, 50, 45, 50, 48, 124, 48, 10, 52, 54, 50, 53, 48, 50, 124, 51, 49, 50, 54, 48, 52, 46, 53, 52, 50, 48, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 56, 124, 48, 10, 49, 55, 56, 55, 50, 55, 124, 51, 48, 57, 55, 50, 56, 46, 57, 51, 48, 54, 124, 49, 57, 57, 53, 45, 48, 50, 45, 50, 53, 124, 48, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q04[] = {111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 124, 111, 114, 100, 101, 114, 95, 99, 111, 117, 110, 116, 10, 49, 45, 85, 82, 71, 69, 78, 84, 124, 57, 57, 57, 10, 50, 45, 72, 73, 71, 72, 124, 57, 57, 55, 10, 51, 45, 77, 69, 68, 73, 85, 77, 124, 49, 48, 51, 49, 10, 52, 45, 78, 79, 84, 32, 83, 80, 69, 67, 73, 70, 73, 69, 68, 124, 57, 56, 57, 10, 53, 45, 76, 79, 87, 124, 49, 48, 55, 55, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q05[] = {110, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 10, 67, 72, 73, 78, 65, 124, 55, 56, 50, 50, 49, 48, 51, 46, 48, 48, 48, 48, 10, 73, 78, 68, 73, 65, 124, 54, 51, 55, 54, 49, 50, 49, 46, 53, 48, 56, 53, 10, 74, 65, 80, 65, 78, 124, 54, 48, 48, 48, 48, 55, 55, 46, 50, 49, 56, 52, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 53, 53, 56, 48, 52, 55, 53, 46, 52, 48, 50, 55, 10, 86, 73, 69, 84, 78, 65, 77, 124, 52, 52, 57, 55, 56, 52, 48, 46, 53, 52, 54, 54, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q06[] = {114, 101, 118, 101, 110, 117, 101, 10, 49, 49, 56, 48, 51, 52, 50, 48, 46, 50, 53, 51, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q07[] = {115, 117, 112, 112, 95, 110, 97, 116, 105, 111, 110, 124, 99, 117, 115, 116, 95, 110, 97, 116, 105, 111, 110, 124, 108, 95, 121, 101, 97, 114, 124, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 65, 78, 67, 69, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 53, 124, 52, 54, 51, 55, 50, 51, 53, 46, 49, 53, 48, 49, 10, 70, 82, 65, 78, 67, 69, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 54, 124, 53, 50, 50, 52, 55, 55, 57, 46, 53, 55, 51, 54, 10, 71, 69, 82, 77, 65, 78, 89, 124, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 53, 124, 54, 50, 51, 50, 56, 49, 56, 46, 55, 48, 51, 55, 10, 71, 69, 82, 77, 65, 78, 89, 124, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 54, 124, 53, 53, 53, 55, 51, 49, 50, 46, 49, 49, 50, 49, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q08[] = {111, 95, 121, 101, 97, 114, 124, 109, 107, 116, 95, 115, 104, 97, 114, 101, 10, 49, 57, 57, 53, 124, 48, 46, 48, 50, 56, 54, 52, 56, 55, 52, 49, 51, 48, 53, 54, 49, 55, 53, 53, 50, 55, 53, 10, 49, 57, 57, 54, 124, 48, 46, 48, 49, 56, 50, 53, 48, 50, 55, 57, 49, 48, 55, 57, 54, 50, 49, 52, 53, 48, 54, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q09[] = {110, 97, 116, 105, 111, 110, 124, 111, 95, 121, 101, 97, 114, 124, 115, 117, 109, 95, 112, 114, 111, 102, 105, 116, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 56, 124, 50, 51, 50, 49, 55, 56, 53, 46, 51, 54, 56, 50, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 55, 124, 51, 54, 56, 53, 48, 49, 54, 46, 56, 53, 56, 57, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 54, 124, 52, 50, 55, 54, 53, 57, 55, 46, 52, 50, 53, 51, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 53, 124, 52, 52, 49, 56, 51, 55, 48, 46, 52, 49, 53, 52, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 52, 124, 51, 56, 54, 52, 56, 52, 57, 46, 57, 53, 50, 49, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 51, 124, 51, 53, 52, 49, 48, 53, 49, 46, 51, 56, 54, 53, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 50, 124, 52, 51, 49, 48, 48, 49, 51, 46, 51, 52, 56, 50, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 56, 124, 50, 54, 56, 53, 57, 56, 51, 46, 56, 48, 48, 53, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 55, 124, 52, 50, 52, 50, 49, 52, 55, 46, 56, 49, 50, 52, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 54, 124, 51, 57, 48, 55, 56, 54, 55, 46, 48, 49, 48, 51, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 53, 124, 52, 54, 48, 53, 57, 50, 49, 46, 53, 48, 49, 49, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 52, 124, 51, 53, 52, 50, 48, 57, 54, 46, 49, 53, 54, 52, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 51, 124, 51, 57, 52, 57, 57, 54, 53, 46, 57, 51, 56, 56, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 50, 124, 52, 53, 50, 49, 49, 56, 48, 46, 52, 54, 57, 53, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 56, 124, 50, 55, 55, 56, 55, 51, 48, 46, 51, 57, 51, 49, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 55, 124, 52, 54, 52, 50, 48, 51, 55, 46, 52, 54, 56, 55, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 54, 124, 52, 53, 51, 48, 51, 48, 52, 46, 54, 48, 51, 52, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 53, 124, 52, 53, 48, 50, 51, 52, 52, 46, 56, 54, 53, 55, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 52, 124, 52, 56, 55, 53, 56, 48, 54, 46, 53, 48, 49, 53, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 51, 124, 52, 54, 56, 55, 52, 55, 56, 46, 54, 53, 51, 49, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 50, 124, 53, 48, 51, 53, 50, 48, 48, 46, 48, 52, 54, 52, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 56, 124, 50, 49, 57, 52, 53, 48, 57, 46, 48, 52, 54, 53, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 55, 124, 51, 52, 56, 50, 49, 57, 55, 46, 57, 53, 50, 49, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 54, 124, 51, 55, 49, 50, 50, 51, 49, 46, 50, 56, 49, 52, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 53, 124, 52, 48, 49, 52, 56, 49, 52, 46, 56, 52, 55, 54, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 52, 124, 52, 49, 52, 53, 51, 48, 52, 46, 52, 56, 53, 53, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 51, 124, 51, 55, 56, 55, 48, 54, 57, 46, 54, 48, 52, 53, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 50, 124, 52, 49, 54, 56, 48, 48, 57, 46, 52, 50, 48, 49, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 56, 124, 51, 51, 57, 56, 53, 55, 56, 46, 48, 48, 48, 49, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 55, 124, 54, 51, 53, 56, 57, 53, 57, 46, 51, 51, 51, 56, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 54, 124, 54, 52, 51, 53, 49, 53, 56, 46, 51, 50, 50, 57, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 53, 124, 54, 49, 55, 52, 55, 55, 54, 46, 50, 49, 49, 51, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 52, 124, 54, 51, 56, 53, 55, 53, 49, 46, 48, 56, 49, 50, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 51, 124, 53, 55, 54, 53, 48, 51, 52, 46, 49, 49, 57, 52, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 50, 124, 54, 51, 50, 52, 48, 51, 52, 46, 50, 51, 55, 57, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 56, 124, 50, 51, 51, 51, 49, 52, 56, 46, 51, 51, 51, 52, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 55, 124, 51, 54, 54, 49, 50, 52, 52, 46, 50, 55, 51, 49, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 54, 124, 51, 55, 54, 53, 51, 55, 49, 46, 50, 51, 54, 56, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 53, 124, 52, 48, 57, 52, 55, 52, 52, 46, 50, 57, 50, 53, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 52, 124, 51, 53, 54, 54, 53, 48, 56, 46, 48, 56, 49, 56, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 51, 124, 51, 55, 50, 53, 50, 56, 51, 46, 55, 55, 52, 55, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 50, 124, 51, 51, 55, 51, 55, 54, 50, 46, 51, 51, 51, 53, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 56, 124, 49, 57, 53, 51, 57, 50, 55, 46, 50, 54, 56, 50, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 55, 124, 51, 50, 56, 53, 55, 56, 54, 46, 51, 50, 54, 54, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 54, 124, 51, 53, 50, 53, 48, 50, 56, 46, 55, 57, 53, 50, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 53, 124, 51, 55, 56, 49, 54, 55, 52, 46, 56, 57, 49, 49, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 52, 124, 51, 48, 51, 55, 52, 48, 57, 46, 52, 51, 54, 48, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 51, 124, 51, 48, 48, 56, 57, 55, 56, 46, 50, 54, 55, 55, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 50, 124, 50, 55, 50, 49, 50, 48, 51, 46, 50, 51, 53, 53, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 56, 124, 50, 54, 48, 52, 51, 55, 51, 46, 56, 56, 48, 53, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 55, 124, 51, 57, 56, 50, 56, 55, 50, 46, 48, 52, 56, 56, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 54, 124, 51, 54, 50, 50, 52, 55, 57, 46, 50, 52, 49, 51, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 53, 124, 52, 52, 55, 57, 57, 51, 57, 46, 55, 48, 50, 48, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 52, 124, 51, 53, 51, 49, 48, 49, 51, 46, 49, 57, 56, 49, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 51, 124, 52, 48, 56, 54, 52, 51, 55, 46, 51, 49, 48, 50, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 50, 124, 51, 54, 51, 55, 55, 57, 50, 46, 49, 51, 51, 51, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 56, 124, 51, 50, 57, 49, 48, 50, 51, 46, 50, 57, 54, 53, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 55, 124, 53, 49, 51, 57, 51, 51, 55, 46, 51, 52, 52, 51, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 54, 124, 52, 55, 57, 57, 56, 49, 48, 46, 52, 53, 55, 55, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 53, 124, 53, 52, 48, 53, 55, 56, 53, 46, 55, 57, 55, 56, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 52, 124, 52, 53, 53, 53, 53, 53, 54, 46, 52, 53, 57, 50, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 51, 124, 52, 52, 50, 56, 49, 57, 53, 46, 49, 48, 49, 57, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 50, 124, 52, 54, 53, 54, 49, 52, 56, 46, 52, 50, 48, 52, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 56, 124, 50, 53, 57, 49, 50, 56, 56, 46, 49, 56, 55, 52, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 55, 124, 53, 49, 53, 57, 53, 54, 50, 46, 55, 48, 51, 51, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 54, 124, 53, 51, 48, 55, 50, 53, 56, 46, 51, 48, 52, 57, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 53, 124, 53, 49, 52, 56, 50, 48, 56, 46, 55, 57, 48, 50, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 52, 124, 53, 49, 54, 52, 48, 48, 49, 46, 57, 53, 56, 50, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 51, 124, 52, 51, 50, 49, 51, 57, 56, 46, 52, 51, 56, 56, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 50, 124, 53, 50, 57, 55, 55, 48, 51, 46, 54, 57, 51, 53, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 56, 124, 51, 48, 57, 52, 57, 48, 48, 46, 49, 53, 57, 55, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 55, 124, 53, 55, 49, 57, 55, 55, 51, 46, 48, 51, 53, 56, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 54, 124, 54, 48, 51, 55, 50, 51, 56, 46, 53, 57, 57, 51, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 53, 124, 53, 50, 54, 54, 55, 56, 51, 46, 52, 56, 57, 57, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 52, 124, 53, 52, 55, 48, 55, 54, 50, 46, 56, 55, 50, 57, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 51, 124, 54, 49, 56, 57, 56, 50, 54, 46, 54, 54, 49, 51, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 50, 124, 52, 52, 49, 52, 54, 50, 51, 46, 49, 53, 52, 57, 10, 73, 82, 65, 78, 124, 49, 57, 57, 56, 124, 51, 50, 49, 52, 56, 54, 52, 46, 49, 50, 48, 57, 10, 73, 82, 65, 78, 124, 49, 57, 57, 55, 124, 51, 54, 56, 56, 48, 52, 57, 46, 48, 54, 57, 49, 10, 73, 82, 65, 78, 124, 49, 57, 57, 54, 124, 51, 54, 50, 49, 54, 52, 57, 46, 50, 50, 52, 55, 10, 73, 82, 65, 78, 124, 49, 57, 57, 53, 124, 52, 52, 50, 48, 55, 56, 51, 46, 52, 50, 48, 53, 10, 73, 82, 65, 78, 124, 49, 57, 57, 52, 124, 52, 51, 55, 51, 57, 56, 52, 46, 54, 53, 50, 51, 10, 73, 82, 65, 78, 124, 49, 57, 57, 51, 124, 51, 55, 51, 49, 51, 48, 49, 46, 55, 56, 49, 52, 10, 73, 82, 65, 78, 124, 49, 57, 57, 50, 124, 52, 52, 49, 55, 49, 51, 51, 46, 51, 54, 54, 50, 10, 73, 82, 65, 81, 124, 49, 57, 57, 56, 124, 50, 51, 51, 56, 56, 53, 57, 46, 52, 48, 57, 57, 10, 73, 82, 65, 81, 124, 49, 57, 57, 55, 124, 51, 54, 50, 50, 54, 56, 49, 46, 53, 54, 52, 51, 10, 73, 82, 65, 81, 124, 49, 57, 57, 54, 124, 52, 55, 54, 50, 50, 57, 49, 46, 56, 55, 50, 50, 10, 73, 82, 65, 81, 124, 49, 57, 57, 53, 124, 52, 53, 53, 56, 48, 57, 50, 46, 55, 51, 53, 57, 10, 73, 82, 65, 81, 124, 49, 57, 57, 52, 124, 52, 57, 53, 49, 54, 48, 52, 46, 49, 54, 57, 57, 10, 73, 82, 65, 81, 124, 49, 57, 57, 51, 124, 51, 56, 51, 48, 48, 55, 55, 46, 57, 57, 49, 49, 10, 73, 82, 65, 81, 124, 49, 57, 57, 50, 124, 51, 57, 51, 56, 54, 51, 54, 46, 52, 56, 55, 52, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 56, 124, 49, 56, 52, 57, 53, 51, 53, 46, 48, 56, 48, 50, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 55, 124, 52, 48, 54, 56, 54, 56, 56, 46, 56, 53, 51, 55, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 54, 124, 52, 48, 52, 52, 55, 55, 52, 46, 55, 53, 57, 55, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 53, 124, 52, 55, 57, 51, 48, 48, 53, 46, 56, 48, 50, 55, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 52, 124, 52, 49, 49, 52, 55, 49, 55, 46, 48, 53, 54, 56, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 51, 124, 51, 54, 49, 52, 52, 54, 56, 46, 55, 52, 56, 53, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 50, 124, 52, 50, 54, 54, 54, 57, 52, 46, 52, 55, 48, 48, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 56, 124, 49, 56, 49, 49, 52, 56, 56, 46, 48, 55, 49, 57, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 55, 124, 50, 57, 53, 49, 50, 57, 55, 46, 56, 54, 55, 56, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 54, 124, 51, 51, 48, 50, 53, 50, 56, 46, 51, 48, 54, 55, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 53, 124, 51, 50, 50, 49, 56, 49, 51, 46, 57, 57, 57, 48, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 52, 124, 50, 52, 49, 55, 56, 57, 50, 46, 48, 57, 50, 49, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 51, 124, 51, 49, 48, 55, 54, 52, 49, 46, 55, 54, 54, 49, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 50, 124, 51, 51, 49, 54, 51, 55, 57, 46, 48, 53, 56, 53, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 56, 124, 50, 53, 55, 57, 48, 55, 53, 46, 52, 49, 57, 48, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 55, 124, 50, 57, 50, 57, 49, 57, 52, 46, 50, 51, 49, 55, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 54, 124, 51, 53, 54, 57, 49, 50, 57, 46, 53, 54, 49, 57, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 53, 124, 51, 53, 52, 50, 56, 56, 57, 46, 49, 48, 56, 55, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 52, 124, 51, 57, 56, 51, 48, 57, 53, 46, 51, 57, 57, 52, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 51, 124, 51, 55, 49, 51, 57, 56, 56, 46, 57, 55, 48, 56, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 50, 124, 51, 51, 48, 52, 54, 52, 49, 46, 56, 51, 52, 48, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 56, 124, 49, 56, 49, 53, 51, 51, 52, 46, 56, 49, 56, 48, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 55, 124, 51, 54, 57, 51, 50, 49, 52, 46, 56, 52, 52, 55, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 54, 124, 52, 49, 49, 54, 49, 55, 53, 46, 57, 50, 51, 48, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 53, 124, 51, 53, 49, 53, 49, 50, 55, 46, 49, 52, 48, 50, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 52, 124, 52, 48, 48, 51, 48, 55, 50, 46, 49, 49, 50, 48, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 51, 124, 51, 53, 57, 57, 49, 57, 57, 46, 54, 54, 55, 57, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 50, 124, 51, 57, 53, 56, 51, 51, 53, 46, 52, 50, 50, 52, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 56, 124, 49, 54, 50, 48, 52, 50, 56, 46, 55, 51, 52, 54, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 55, 124, 50, 56, 48, 50, 49, 54, 54, 46, 54, 52, 55, 51, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 54, 124, 50, 52, 48, 57, 57, 53, 53, 46, 49, 55, 53, 53, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 53, 124, 50, 55, 55, 49, 54, 48, 50, 46, 54, 50, 55, 52, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 52, 124, 50, 53, 52, 56, 50, 50, 54, 46, 50, 49, 53, 56, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 51, 124, 50, 56, 52, 51, 55, 52, 56, 46, 57, 48, 53, 51, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 50, 124, 50, 53, 53, 54, 53, 48, 49, 46, 48, 57, 52, 51, 10, 80, 69, 82, 85, 124, 49, 57, 57, 56, 124, 50, 48, 51, 54, 52, 51, 48, 46, 51, 54, 48, 50, 10, 80, 69, 82, 85, 124, 49, 57, 57, 55, 124, 52, 48, 54, 52, 49, 52, 50, 46, 52, 48, 57, 49, 10, 80, 69, 82, 85, 124, 49, 57, 57, 54, 124, 52, 48, 54, 56, 54, 55, 56, 46, 53, 54, 55, 49, 10, 80, 69, 82, 85, 124, 49, 57, 57, 53, 124, 52, 54, 53, 55, 54, 57, 52, 46, 56, 52, 49, 50, 10, 80, 69, 82, 85, 124, 49, 57, 57, 52, 124, 52, 55, 51, 49, 57, 53, 57, 46, 52, 54, 53, 53, 10, 80, 69, 82, 85, 124, 49, 57, 57, 51, 124, 52, 49, 52, 52, 48, 48, 54, 46, 54, 54, 49, 48, 10, 80, 69, 82, 85, 124, 49, 57, 57, 50, 124, 51, 55, 53, 52, 54, 51, 53, 46, 48, 48, 55, 56, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 56, 124, 49, 57, 57, 50, 55, 55, 51, 46, 54, 56, 49, 49, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 55, 124, 50, 56, 53, 52, 54, 51, 57, 46, 56, 54, 56, 48, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 54, 124, 51, 49, 51, 57, 51, 51, 55, 46, 51, 48, 50, 57, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 53, 124, 51, 50, 50, 50, 49, 53, 51, 46, 51, 55, 55, 54, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 52, 124, 51, 50, 50, 50, 56, 52, 52, 46, 51, 49, 57, 48, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 51, 124, 51, 52, 56, 56, 57, 57, 52, 46, 48, 50, 56, 56, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 50, 124, 51, 48, 50, 57, 50, 55, 52, 46, 52, 52, 50, 48, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 56, 124, 50, 51, 51, 57, 56, 54, 53, 46, 54, 54, 51, 53, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 55, 124, 52, 49, 53, 51, 54, 49, 57, 46, 53, 52, 50, 52, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 54, 124, 51, 55, 55, 50, 48, 54, 55, 46, 52, 48, 52, 49, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 53, 124, 52, 55, 48, 52, 57, 56, 56, 46, 56, 54, 48, 55, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 52, 124, 52, 52, 55, 57, 48, 56, 50, 46, 56, 54, 57, 52, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 51, 124, 52, 55, 54, 55, 55, 49, 57, 46, 57, 55, 57, 49, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 50, 124, 52, 53, 51, 51, 52, 54, 53, 46, 53, 53, 57, 48, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 56, 124, 51, 51, 56, 54, 57, 52, 56, 46, 57, 53, 54, 52, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 55, 124, 53, 52, 50, 53, 57, 56, 48, 46, 51, 51, 55, 51, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 54, 124, 53, 50, 50, 55, 54, 48, 55, 46, 49, 54, 55, 55, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 53, 124, 52, 53, 48, 54, 55, 51, 49, 46, 54, 52, 49, 49, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 52, 124, 52, 54, 57, 56, 54, 53, 56, 46, 55, 52, 50, 53, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 51, 124, 53, 52, 57, 51, 54, 50, 54, 46, 53, 50, 56, 53, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 50, 124, 52, 53, 55, 51, 53, 54, 48, 46, 48, 49, 53, 48, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 56, 124, 50, 50, 53, 50, 48, 50, 49, 46, 53, 49, 51, 55, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 55, 124, 52, 51, 52, 51, 57, 50, 54, 46, 56, 48, 50, 54, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 54, 124, 52, 49, 56, 57, 52, 55, 54, 46, 51, 48, 54, 53, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 53, 124, 52, 52, 54, 57, 53, 54, 57, 46, 56, 56, 50, 57, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 52, 124, 52, 52, 49, 48, 48, 57, 52, 46, 54, 50, 54, 52, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 51, 124, 52, 48, 53, 52, 54, 55, 55, 46, 49, 48, 53, 48, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 50, 124, 51, 57, 55, 56, 54, 56, 56, 46, 56, 56, 51, 49, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 56, 124, 50, 50, 51, 56, 55, 55, 49, 46, 53, 53, 56, 49, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 55, 124, 52, 49, 51, 53, 53, 56, 49, 46, 53, 55, 51, 52, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 54, 124, 51, 54, 50, 52, 48, 49, 51, 46, 50, 54, 54, 48, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 53, 124, 51, 56, 57, 50, 50, 52, 52, 46, 53, 49, 55, 50, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 52, 124, 51, 50, 56, 57, 50, 50, 52, 46, 49, 49, 51, 56, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 51, 124, 51, 54, 50, 54, 49, 55, 48, 46, 50, 48, 50, 56, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 50, 124, 51, 57, 57, 51, 57, 55, 51, 46, 52, 57, 57, 55, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 56, 124, 49, 57, 50, 52, 51, 49, 51, 46, 52, 56, 54, 50, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 55, 124, 51, 52, 51, 54, 49, 57, 53, 46, 51, 55, 48, 57, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 54, 124, 52, 48, 49, 55, 50, 56, 56, 46, 56, 57, 50, 55, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 53, 124, 51, 54, 52, 52, 48, 53, 52, 46, 49, 51, 55, 50, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 52, 124, 52, 49, 52, 49, 50, 55, 55, 46, 54, 54, 54, 53, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 51, 124, 50, 53, 53, 54, 49, 49, 52, 46, 49, 54, 57, 51, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 50, 124, 52, 48, 57, 48, 53, 50, 52, 46, 52, 57, 48, 53, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q10[] = {99, 95, 99, 117, 115, 116, 107, 101, 121, 124, 99, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 124, 99, 95, 97, 99, 99, 116, 98, 97, 108, 124, 110, 95, 110, 97, 109, 101, 124, 99, 95, 97, 100, 100, 114, 101, 115, 115, 124, 99, 95, 112, 104, 111, 110, 101, 124, 99, 95, 99, 111, 109, 109, 101, 110, 116, 10, 56, 50, 52, 50, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 56, 50, 52, 50, 124, 54, 50, 50, 55, 56, 54, 46, 55, 50, 57, 55, 124, 54, 51, 50, 50, 46, 48, 57, 124, 69, 84, 72, 73, 79, 80, 73, 65, 124, 99, 89, 68, 87, 68, 105, 74, 116, 48, 54, 66, 56, 67, 89, 122, 88, 88, 50, 76, 56, 120, 50, 104, 110, 49, 86, 70, 71, 124, 49, 53, 45, 55, 57, 50, 45, 54, 55, 54, 45, 49, 49, 56, 52, 124, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 104, 97, 103, 103, 108, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 105, 100, 101, 97, 115, 46, 32, 99, 111, 117, 114, 116, 115, 32, 97, 114, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 32, 99, 97, 106, 111, 108, 101, 46, 32, 105, 10, 55, 55, 49, 52, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 55, 55, 49, 52, 124, 53, 53, 55, 52, 48, 48, 46, 51, 48, 53, 51, 124, 57, 55, 57, 57, 46, 57, 56, 124, 73, 82, 65, 78, 124, 57, 68, 68, 105, 107, 113, 48, 56, 71, 69, 69, 52, 66, 51, 88, 124, 50, 48, 45, 57, 50, 50, 45, 52, 49, 56, 45, 54, 48, 50, 52, 124, 97, 114, 104, 111, 114, 115, 101, 115, 32, 97, 99, 99, 111, 114, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 114, 101, 10, 49, 49, 48, 51, 50, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 49, 48, 51, 50, 124, 53, 49, 50, 53, 48, 48, 46, 57, 54, 52, 49, 124, 56, 52, 57, 54, 46, 57, 51, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 53, 105, 103, 106, 111, 85, 103, 88, 111, 68, 85, 90, 86, 85, 73, 101, 99, 116, 76, 53, 108, 88, 79, 49, 84, 51, 65, 71, 75, 122, 97, 48, 102, 116, 124, 51, 51, 45, 49, 48, 50, 45, 55, 55, 50, 45, 51, 53, 51, 51, 124, 112, 111, 115, 105, 116, 115, 45, 45, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 97, 114, 101, 32, 97, 103, 97, 105, 110, 10, 50, 52, 53, 53, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 50, 52, 53, 53, 124, 52, 56, 49, 53, 57, 50, 46, 52, 48, 53, 51, 124, 50, 48, 55, 48, 46, 57, 57, 124, 71, 69, 82, 77, 65, 78, 89, 124, 97, 53, 68, 90, 49, 57, 57, 121, 102, 65, 99, 70, 104, 102, 105, 50, 117, 119, 66, 69, 32, 80, 75, 111, 44, 90, 124, 49, 55, 45, 57, 52, 54, 45, 50, 50, 53, 45, 57, 57, 55, 55, 124, 97, 108, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 46, 32, 102, 105, 110, 97, 108, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 46, 32, 112, 101, 114, 109, 97, 110, 101, 110, 116, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 32, 97, 114, 111, 10, 49, 50, 49, 48, 54, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 50, 49, 48, 54, 124, 52, 55, 57, 52, 49, 52, 46, 50, 49, 51, 51, 124, 53, 51, 52, 50, 46, 49, 49, 124, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 119, 121, 74, 88, 121, 119, 99, 69, 120, 85, 120, 116, 124, 51, 52, 45, 57, 48, 53, 45, 51, 52, 54, 45, 52, 52, 55, 50, 124, 108, 121, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 102, 111, 120, 101, 115, 46, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 104, 97, 103, 103, 108, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 97, 108, 111, 110, 103, 115, 105, 100, 101, 32, 111, 102, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 101, 118, 101, 110, 32, 105, 100, 101, 97, 115, 46, 10, 56, 53, 51, 48, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 56, 53, 51, 48, 124, 52, 53, 55, 56, 53, 53, 46, 57, 52, 54, 55, 124, 57, 55, 51, 52, 46, 57, 53, 124, 77, 79, 82, 79, 67, 67, 79, 124, 108, 101, 97, 116, 121, 78, 82, 87, 67, 110, 102, 84, 77, 110, 84, 78, 117, 68, 71, 72, 115, 87, 74, 106, 82, 117, 65, 88, 124, 50, 53, 45, 55, 51, 54, 45, 57, 51, 50, 45, 53, 56, 53, 48, 124, 115, 108, 121, 108, 121, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 105, 110, 10, 49, 51, 57, 56, 52, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 51, 57, 56, 52, 124, 52, 52, 54, 51, 49, 54, 46, 53, 49, 48, 52, 124, 51, 52, 56, 50, 46, 50, 56, 124, 73, 82, 65, 78, 124, 66, 49, 51, 118, 120, 82, 66, 111, 106, 119, 118, 80, 51, 124, 50, 48, 45, 57, 56, 49, 45, 50, 54, 52, 45, 50, 57, 53, 50, 124, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 99, 111, 117, 114, 116, 115, 32, 99, 111, 117, 108, 100, 32, 119, 97, 107, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 10, 49, 57, 54, 54, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 57, 54, 54, 124, 52, 52, 52, 48, 53, 57, 46, 48, 51, 56, 50, 124, 49, 57, 51, 55, 46, 55, 50, 124, 65, 76, 71, 69, 82, 73, 65, 124, 73, 98, 119, 90, 114, 55, 106, 32, 81, 86, 105, 102, 113, 102, 57, 87, 105, 122, 79, 73, 87, 120, 44, 85, 88, 86, 57, 67, 113, 120, 85, 121, 114, 119, 106, 124, 49, 48, 45, 57, 55, 51, 45, 50, 54, 57, 45, 56, 56, 56, 54, 124, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 101, 118, 101, 110, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 97, 114, 111, 117, 110, 100, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 102, 105, 110, 97, 108, 32, 112, 97, 99, 107, 97, 103, 101, 115, 46, 32, 10, 49, 49, 48, 50, 54, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 49, 48, 50, 54, 124, 52, 49, 55, 57, 49, 51, 46, 52, 49, 52, 50, 124, 55, 55, 51, 56, 46, 55, 54, 124, 65, 76, 71, 69, 82, 73, 65, 124, 52, 67, 32, 105, 71, 122, 67, 104, 99, 113, 110, 104, 71, 66, 100, 101, 101, 117, 124, 49, 48, 45, 49, 56, 52, 45, 49, 54, 51, 45, 52, 54, 51, 50, 124, 108, 121, 32, 101, 118, 101, 110, 32, 100, 111, 108, 112, 104, 105, 110, 115, 32, 101, 97, 116, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 101, 118, 101, 110, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 46, 32, 101, 120, 112, 114, 101, 115, 115, 32, 97, 116, 116, 97, 105, 110, 109, 101, 110, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 115, 108, 121, 108, 121, 46, 32, 98, 117, 115, 121, 32, 100, 111, 108, 112, 104, 105, 110, 115, 32, 105, 110, 10, 56, 53, 48, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 56, 53, 48, 49, 124, 52, 49, 50, 55, 57, 55, 46, 53, 49, 48, 48, 124, 54, 57, 48, 54, 46, 55, 48, 124, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 85, 84, 85, 81, 76, 88, 32, 99, 81, 114, 70, 49, 85, 85, 74, 80, 115, 122, 124, 49, 49, 45, 51, 49, 55, 45, 53, 53, 50, 45, 53, 56, 52, 48, 124, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 101, 118, 101, 110, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 97, 114, 101, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 108, 44, 32, 114, 101, 103, 117, 108, 97, 114, 10, 49, 53, 54, 53, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 53, 54, 53, 124, 52, 49, 50, 53, 48, 54, 46, 48, 48, 54, 50, 124, 49, 56, 50, 48, 46, 48, 51, 124, 66, 82, 65, 90, 73, 76, 124, 110, 52, 97, 99, 86, 112, 71, 48, 68, 101, 121, 106, 53, 97, 73, 70, 65, 102, 83, 78, 103, 32, 73, 117, 57, 99, 85, 97, 103, 119, 78, 51, 79, 115, 82, 98, 75, 67, 32, 52, 124, 49, 50, 45, 52, 48, 50, 45, 49, 55, 56, 45, 50, 48, 48, 55, 124, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 119, 97, 107, 101, 32, 115, 108, 121, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 105, 100, 101, 97, 10, 49, 52, 51, 57, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 52, 51, 57, 56, 124, 52, 48, 56, 53, 55, 53, 46, 51, 54, 48, 48, 124, 45, 54, 48, 50, 46, 50, 52, 124, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 108, 52, 57, 111, 75, 106, 98, 106, 81, 72, 122, 54, 89, 90, 119, 106, 111, 53, 119, 80, 105, 104, 77, 32, 108, 121, 89, 79, 54, 71, 124, 51, 52, 45, 56, 49, 52, 45, 49, 49, 49, 45, 53, 52, 50, 52, 124, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 101, 118, 101, 110, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 46, 32, 101, 118, 101, 110, 32, 102, 111, 120, 101, 115, 32, 100, 111, 117, 98, 116, 45, 45, 32, 10, 49, 52, 54, 53, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 52, 54, 53, 124, 52, 48, 53, 48, 53, 53, 46, 51, 52, 53, 55, 124, 57, 51, 54, 53, 46, 57, 51, 124, 73, 78, 68, 73, 65, 124, 122, 110, 57, 81, 55, 112, 84, 54, 75, 108, 81, 112, 51, 84, 53, 109, 85, 79, 53, 51, 51, 97, 113, 44, 124, 49, 56, 45, 56, 48, 55, 45, 52, 56, 55, 45, 49, 48, 55, 52, 124, 115, 32, 108, 111, 115, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 105, 114, 111, 110, 105, 99, 44, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 97, 99, 107, 97, 103, 101, 115, 46, 32, 114, 101, 103, 117, 108, 97, 114, 44, 32, 102, 105, 110, 97, 108, 32, 102, 111, 120, 101, 115, 32, 104, 97, 103, 103, 108, 101, 32, 99, 10, 49, 50, 53, 57, 53, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 50, 53, 57, 53, 124, 52, 48, 49, 52, 48, 50, 46, 50, 51, 57, 49, 124, 45, 54, 46, 57, 50, 124, 73, 78, 68, 73, 65, 124, 103, 69, 77, 81, 51, 87, 79, 57, 48, 118, 83, 100, 65, 103, 120, 76, 70, 114, 116, 57, 70, 82, 83, 124, 49, 56, 45, 49, 56, 54, 45, 49, 51, 50, 45, 51, 51, 53, 50, 124, 111, 32, 116, 104, 101, 32, 98, 117, 115, 121, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 103, 105, 102, 116, 115, 32, 109, 97, 105, 110, 116, 97, 105, 110, 32, 97, 10, 57, 54, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 54, 49, 124, 52, 48, 49, 49, 57, 56, 46, 49, 55, 51, 55, 124, 54, 57, 54, 51, 46, 54, 56, 124, 74, 65, 80, 65, 78, 124, 87, 48, 83, 90, 50, 111, 102, 108, 120, 57, 97, 87, 84, 103, 103, 116, 119, 83, 107, 51, 79, 69, 73, 88, 115, 117, 98, 88, 84, 98, 71, 98, 68, 124, 50, 50, 45, 57, 56, 57, 45, 52, 54, 51, 45, 54, 48, 56, 57, 124, 101, 32, 102, 105, 110, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 58, 32, 98, 117, 115, 105, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 98, 101, 108, 105, 101, 118, 101, 32, 97, 10, 49, 52, 50, 57, 57, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 52, 50, 57, 57, 124, 52, 48, 48, 57, 54, 56, 46, 51, 55, 53, 49, 124, 54, 53, 57, 53, 46, 57, 55, 124, 82, 85, 83, 83, 73, 65, 124, 85, 70, 108, 79, 115, 56, 116, 81, 44, 73, 102, 90, 80, 74, 109, 53, 55, 124, 51, 50, 45, 49, 53, 54, 45, 54, 49, 56, 45, 49, 50, 50, 52, 124, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 114, 117, 10, 54, 50, 51, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 50, 51, 124, 51, 57, 57, 56, 56, 51, 46, 52, 50, 53, 55, 124, 55, 56, 56, 55, 46, 54, 48, 124, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 107, 51, 73, 108, 80, 83, 67, 52, 70, 75, 66, 49, 51, 32, 104, 99, 54, 111, 109, 104, 86, 115, 49, 105, 98, 118, 113, 101, 87, 69, 86, 124, 49, 57, 45, 49, 49, 51, 45, 50, 48, 50, 45, 55, 48, 56, 53, 124, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 100, 111, 108, 112, 104, 105, 110, 115, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 98, 117, 115, 105, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 97, 102, 116, 101, 114, 10, 57, 49, 53, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 57, 49, 53, 49, 124, 51, 57, 54, 53, 54, 50, 46, 48, 50, 57, 53, 124, 53, 54, 57, 49, 46, 57, 53, 124, 73, 82, 65, 81, 124, 85, 75, 105, 78, 57, 79, 81, 117, 112, 82, 44, 109, 53, 78, 116, 118, 83, 110, 116, 98, 73, 56, 74, 66, 101, 111, 124, 50, 49, 45, 56, 51, 52, 45, 49, 52, 55, 45, 52, 57, 48, 54, 124, 97, 106, 111, 108, 101, 32, 102, 108, 117, 102, 102, 105, 108, 121, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 97, 114, 101, 32, 115, 112, 101, 99, 105, 97, 108, 44, 32, 115, 105, 108, 101, 110, 116, 32, 97, 99, 99, 111, 117, 110, 116, 10, 49, 52, 56, 49, 57, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 52, 56, 49, 57, 124, 51, 57, 54, 50, 55, 49, 46, 49, 48, 51, 54, 124, 55, 51, 48, 56, 46, 51, 57, 124, 70, 82, 65, 78, 67, 69, 124, 119, 83, 56, 121, 105, 81, 116, 69, 54, 51, 70, 102, 111, 79, 54, 82, 75, 85, 122, 117, 86, 102, 54, 105, 66, 84, 109, 88, 66, 113, 49, 54, 117, 124, 49, 54, 45, 55, 54, 57, 45, 51, 57, 56, 45, 55, 57, 50, 54, 124, 115, 115, 44, 32, 102, 105, 110, 97, 108, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 32, 117, 115, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 108, 121, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 46, 32, 115, 112, 101, 99, 105, 97, 108, 44, 32, 101, 120, 112, 114, 101, 115, 115, 32, 100, 117, 103, 111, 117, 116, 115, 32, 97, 99, 99, 111, 114, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 100, 101, 112, 10, 49, 51, 52, 55, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 51, 52, 55, 56, 124, 51, 57, 53, 53, 49, 51, 46, 49, 51, 53, 56, 124, 45, 55, 55, 56, 46, 49, 49, 124, 75, 69, 78, 89, 65, 124, 83, 53, 105, 122, 119, 106, 77, 49, 32, 104, 67, 111, 85, 99, 99, 79, 50, 74, 77, 101, 112, 89, 119, 78, 121, 66, 83, 113, 73, 44, 97, 121, 124, 50, 52, 45, 57, 56, 51, 45, 50, 48, 50, 45, 56, 50, 52, 48, 124, 114, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46, 32, 115, 108, 121, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 32, 115, 108, 101, 101, 112, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 114, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q11[] = {112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 124, 118, 97, 108, 117, 101, 10, 49, 50, 48, 57, 56, 124, 49, 54, 50, 50, 55, 54, 56, 49, 46, 50, 49, 10, 53, 49, 51, 52, 124, 49, 53, 55, 48, 57, 51, 51, 56, 46, 53, 50, 10, 49, 51, 51, 51, 52, 124, 49, 53, 48, 50, 51, 54, 54, 50, 46, 52, 49, 10, 49, 55, 48, 53, 50, 124, 49, 52, 51, 53, 49, 54, 52, 52, 46, 50, 48, 10, 51, 52, 53, 50, 124, 49, 52, 48, 55, 48, 56, 55, 48, 46, 49, 52, 10, 49, 50, 53, 53, 50, 124, 49, 51, 51, 51, 50, 52, 54, 57, 46, 49, 56, 10, 49, 48, 56, 52, 124, 49, 51, 49, 55, 48, 52, 50, 56, 46, 50, 57, 10, 53, 55, 57, 55, 124, 49, 51, 48, 51, 56, 54, 50, 50, 46, 55, 50, 10, 49, 50, 54, 51, 51, 124, 49, 50, 56, 57, 50, 53, 54, 49, 46, 54, 49, 10, 52, 48, 51, 124, 49, 50, 56, 53, 54, 50, 49, 55, 46, 51, 52, 10, 49, 56, 51, 51, 124, 49, 50, 48, 50, 52, 53, 56, 49, 46, 55, 50, 10, 50, 48, 56, 52, 124, 49, 49, 53, 48, 50, 56, 55, 53, 46, 51, 54, 10, 49, 55, 51, 52, 57, 124, 49, 49, 51, 53, 52, 50, 49, 51, 46, 48, 53, 10, 49, 56, 52, 50, 55, 124, 49, 49, 50, 56, 50, 51, 56, 53, 46, 50, 52, 10, 50, 56, 54, 48, 124, 49, 49, 50, 54, 50, 53, 50, 57, 46, 57, 53, 10, 49, 55, 56, 53, 50, 124, 49, 48, 57, 51, 52, 55, 49, 49, 46, 57, 51, 10, 57, 56, 55, 49, 124, 49, 48, 56, 56, 57, 50, 53, 51, 46, 54, 56, 10, 49, 50, 50, 51, 49, 124, 49, 48, 56, 52, 49, 49, 51, 49, 46, 51, 57, 10, 54, 51, 54, 54, 124, 49, 48, 55, 53, 57, 55, 56, 54, 46, 56, 49, 10, 49, 50, 49, 52, 54, 124, 49, 48, 50, 53, 55, 51, 54, 50, 46, 54, 54, 10, 53, 48, 52, 51, 124, 49, 48, 50, 50, 54, 51, 57, 53, 46, 56, 56, 10, 49, 50, 57, 54, 57, 124, 49, 48, 49, 50, 53, 55, 55, 55, 46, 57, 51, 10, 49, 53, 48, 52, 124, 49, 48, 48, 48, 52, 51, 57, 55, 46, 48, 56, 10, 49, 52, 51, 50, 55, 124, 57, 57, 56, 49, 54, 57, 55, 46, 48, 56, 10, 49, 51, 52, 124, 57, 57, 54, 53, 49, 53, 48, 46, 54, 54, 10, 54, 56, 54, 48, 124, 57, 56, 48, 53, 56, 55, 49, 46, 50, 54, 10, 49, 48, 54, 50, 52, 124, 57, 55, 55, 54, 49, 51, 56, 46, 52, 48, 10, 49, 53, 56, 49, 57, 124, 57, 55, 55, 53, 55, 48, 53, 46, 51, 49, 10, 51, 50, 57, 51, 124, 57, 54, 55, 52, 57, 50, 56, 46, 49, 50, 10, 49, 57, 56, 54, 53, 124, 57, 54, 53, 51, 55, 54, 54, 46, 56, 51, 10, 56, 56, 55, 48, 124, 57, 54, 52, 56, 57, 56, 49, 46, 56, 55, 10, 49, 53, 55, 55, 56, 124, 57, 54, 51, 54, 51, 51, 50, 46, 56, 50, 10, 49, 50, 51, 54, 48, 124, 57, 54, 51, 53, 48, 50, 51, 46, 57, 50, 10, 49, 52, 51, 56, 57, 124, 57, 52, 55, 53, 53, 56, 56, 46, 51, 52, 10, 51, 50, 53, 55, 124, 57, 52, 53, 49, 48, 50, 57, 46, 50, 52, 10, 57, 52, 55, 54, 124, 57, 52, 51, 53, 50, 48, 55, 46, 50, 56, 10, 49, 57, 54, 50, 57, 124, 57, 51, 57, 49, 50, 51, 54, 46, 52, 48, 10, 55, 49, 55, 57, 124, 57, 51, 56, 54, 50, 50, 50, 46, 50, 53, 10, 49, 53, 55, 50, 51, 124, 57, 51, 56, 51, 57, 48, 48, 46, 56, 48, 10, 52, 48, 53, 52, 124, 57, 51, 49, 51, 56, 49, 48, 46, 48, 50, 10, 50, 51, 56, 48, 124, 57, 51, 48, 55, 55, 53, 49, 46, 50, 50, 10, 49, 57, 48, 56, 52, 124, 57, 51, 48, 50, 57, 49, 54, 46, 56, 48, 10, 52, 55, 48, 51, 124, 57, 50, 56, 48, 56, 48, 52, 46, 56, 48, 10, 49, 56, 55, 57, 49, 124, 57, 50, 54, 55, 48, 49, 55, 46, 57, 55, 10, 49, 57, 57, 57, 52, 124, 57, 50, 51, 53, 57, 55, 50, 46, 57, 50, 10, 57, 49, 52, 57, 124, 57, 49, 50, 49, 56, 48, 51, 46, 57, 48, 10, 49, 53, 49, 49, 56, 124, 57, 49, 50, 48, 56, 49, 57, 46, 53, 48, 10, 54, 49, 49, 54, 124, 57, 48, 55, 57, 51, 54, 57, 46, 50, 48, 10, 55, 48, 53, 50, 124, 57, 48, 55, 55, 52, 54, 56, 46, 57, 50, 10, 49, 52, 49, 52, 55, 124, 57, 48, 54, 57, 49, 57, 51, 46, 55, 56, 10, 55, 51, 48, 53, 124, 57, 48, 51, 53, 50, 50, 56, 46, 53, 51, 10, 57, 49, 51, 48, 124, 57, 48, 50, 52, 51, 55, 57, 46, 50, 53, 10, 49, 54, 54, 57, 56, 124, 56, 57, 57, 49, 51, 51, 55, 46, 57, 53, 10, 49, 53, 53, 51, 124, 56, 57, 55, 55, 50, 50, 54, 46, 49, 48, 10, 49, 54, 55, 55, 55, 124, 56, 57, 54, 49, 51, 53, 53, 46, 54, 50, 10, 49, 52, 48, 50, 124, 56, 57, 53, 51, 55, 55, 57, 46, 49, 50, 10, 49, 56, 57, 54, 51, 124, 56, 57, 51, 52, 48, 54, 51, 46, 52, 48, 10, 56, 51, 53, 56, 124, 56, 57, 51, 48, 54, 49, 49, 46, 52, 56, 10, 49, 55, 53, 52, 55, 124, 56, 56, 54, 48, 49, 49, 55, 46, 48, 48, 10, 53, 49, 50, 56, 124, 56, 56, 52, 52, 50, 50, 50, 46, 55, 53, 10, 49, 55, 48, 54, 51, 124, 56, 56, 52, 48, 54, 52, 57, 46, 54, 48, 10, 49, 53, 52, 57, 48, 124, 56, 56, 51, 51, 53, 56, 49, 46, 52, 48, 10, 49, 52, 55, 54, 49, 124, 56, 56, 49, 55, 50, 52, 48, 46, 53, 54, 10, 49, 57, 54, 48, 49, 124, 56, 55, 57, 49, 51, 52, 49, 46, 48, 50, 10, 49, 54, 49, 54, 48, 124, 56, 55, 52, 48, 50, 54, 50, 46, 55, 54, 10, 49, 51, 53, 57, 55, 124, 56, 55, 48, 50, 54, 54, 57, 46, 56, 50, 10, 49, 51, 54, 53, 51, 124, 56, 54, 57, 51, 49, 55, 48, 46, 49, 54, 10, 49, 54, 51, 56, 51, 124, 56, 54, 57, 49, 53, 48, 53, 46, 57, 50, 10, 51, 50, 53, 124, 56, 54, 54, 55, 55, 52, 49, 46, 50, 56, 10, 56, 56, 55, 57, 124, 56, 54, 54, 55, 53, 56, 52, 46, 51, 56, 10, 49, 48, 53, 54, 52, 124, 56, 54, 54, 55, 48, 57, 56, 46, 50, 50, 10, 49, 55, 52, 50, 57, 124, 56, 54, 54, 49, 56, 50, 55, 46, 57, 48, 10, 49, 55, 52, 48, 51, 124, 56, 54, 52, 51, 51, 53, 48, 46, 51, 48, 10, 49, 56, 50, 57, 52, 124, 56, 54, 49, 54, 53, 56, 51, 46, 52, 51, 10, 52, 49, 56, 49, 124, 56, 53, 57, 50, 54, 56, 52, 46, 54, 54, 10, 49, 51, 48, 48, 56, 124, 56, 53, 54, 55, 52, 56, 48, 46, 54, 52, 10, 49, 51, 50, 49, 49, 124, 56, 53, 51, 55, 48, 48, 48, 46, 48, 49, 10, 49, 56, 56, 52, 124, 56, 53, 51, 50, 54, 52, 52, 46, 51, 52, 10, 49, 49, 49, 48, 49, 124, 56, 53, 51, 48, 57, 52, 53, 46, 51, 50, 10, 49, 49, 53, 54, 50, 124, 56, 53, 50, 56, 48, 50, 56, 46, 53, 55, 10, 49, 53, 56, 55, 56, 124, 56, 53, 50, 51, 53, 57, 49, 46, 56, 52, 10, 56, 51, 52, 124, 56, 53, 50, 50, 49, 51, 53, 46, 50, 55, 10, 50, 52, 50, 51, 124, 56, 53, 49, 55, 57, 48, 50, 46, 56, 53, 10, 49, 53, 51, 56, 51, 124, 56, 53, 49, 51, 52, 51, 51, 46, 49, 49, 10, 49, 56, 49, 49, 57, 124, 56, 53, 48, 55, 54, 49, 49, 46, 56, 48, 10, 55, 51, 56, 57, 124, 56, 53, 48, 54, 48, 57, 57, 46, 50, 48, 10, 53, 48, 49, 54, 124, 56, 52, 56, 57, 55, 56, 52, 46, 49, 53, 10, 49, 55, 52, 55, 51, 124, 56, 52, 52, 52, 55, 54, 54, 46, 50, 52, 10, 54, 54, 54, 57, 124, 56, 52, 50, 56, 54, 49, 56, 46, 52, 54, 10, 51, 56, 52, 124, 56, 52, 49, 56, 52, 55, 50, 46, 50, 55, 10, 49, 50, 48, 53, 50, 124, 56, 52, 49, 49, 53, 49, 57, 46, 50, 56, 10, 49, 55, 53, 54, 50, 124, 56, 52, 48, 57, 48, 50, 50, 46, 56, 51, 10, 56, 49, 50, 56, 124, 56, 51, 55, 57, 49, 52, 57, 46, 52, 55, 10, 49, 51, 56, 49, 51, 124, 56, 51, 55, 52, 56, 51, 48, 46, 56, 52, 10, 49, 50, 56, 48, 48, 124, 56, 51, 49, 56, 54, 50, 54, 46, 55, 56, 10, 49, 48, 56, 56, 55, 124, 56, 51, 49, 53, 48, 49, 57, 46, 51, 54, 10, 49, 54, 52, 52, 124, 56, 50, 56, 53, 52, 53, 51, 46, 48, 56, 10, 49, 54, 54, 51, 56, 124, 56, 50, 55, 52, 53, 54, 56, 46, 48, 48, 10, 49, 51, 57, 52, 124, 56, 50, 53, 53, 49, 52, 48, 46, 54, 48, 10, 55, 50, 49, 57, 124, 56, 50, 53, 52, 57, 56, 53, 46, 51, 48, 10, 49, 51, 51, 53, 56, 124, 56, 50, 53, 51, 56, 50, 57, 46, 56, 48, 10, 53, 53, 54, 50, 124, 56, 50, 53, 50, 51, 54, 53, 46, 49, 54, 10, 49, 52, 56, 54, 49, 124, 56, 50, 52, 50, 50, 57, 54, 46, 49, 53, 10, 49, 53, 52, 49, 54, 124, 56, 49, 57, 54, 54, 50, 49, 46, 53, 51, 10, 49, 57, 54, 51, 124, 56, 49, 57, 50, 50, 48, 54, 46, 54, 49, 10, 50, 56, 52, 49, 124, 56, 49, 52, 56, 54, 55, 56, 46, 52, 53, 10, 54, 54, 51, 53, 124, 56, 49, 50, 50, 57, 49, 56, 46, 50, 56, 10, 51, 54, 48, 57, 124, 56, 48, 57, 57, 56, 49, 50, 46, 48, 53, 10, 54, 51, 55, 50, 124, 56, 48, 57, 51, 54, 57, 53, 46, 48, 54, 10, 53, 50, 51, 49, 124, 56, 48, 57, 49, 55, 48, 52, 46, 49, 56, 10, 56, 55, 53, 53, 124, 56, 48, 56, 53, 48, 49, 55, 46, 48, 51, 10, 52, 48, 55, 49, 124, 56, 48, 56, 51, 55, 53, 53, 46, 49, 56, 10, 52, 57, 55, 55, 124, 56, 48, 53, 56, 53, 48, 49, 46, 55, 50, 10, 49, 49, 56, 55, 51, 124, 56, 48, 53, 55, 53, 52, 48, 46, 51, 48, 10, 49, 50, 49, 50, 55, 124, 56, 48, 53, 49, 49, 52, 50, 46, 57, 52, 10, 50, 52, 48, 49, 124, 56, 48, 52, 57, 53, 50, 53, 46, 57, 52, 10, 49, 53, 57, 54, 52, 124, 56, 48, 51, 55, 53, 52, 55, 46, 55, 53, 10, 49, 48, 49, 50, 57, 124, 56, 48, 51, 48, 56, 53, 53, 46, 48, 52, 10, 55, 54, 48, 53, 124, 56, 48, 50, 56, 54, 50, 50, 46, 52, 50, 10, 57, 51, 50, 55, 124, 56, 48, 50, 50, 50, 57, 49, 46, 51, 48, 10, 49, 49, 56, 49, 52, 124, 55, 57, 56, 51, 53, 56, 57, 46, 53, 57, 10, 52, 54, 52, 54, 124, 55, 57, 56, 49, 54, 54, 48, 46, 54, 48, 10, 54, 48, 51, 50, 124, 55, 57, 56, 49, 53, 49, 49, 46, 50, 56, 10, 49, 48, 55, 54, 124, 55, 57, 55, 55, 48, 55, 52, 46, 55, 53, 10, 52, 48, 52, 51, 124, 55, 57, 55, 49, 57, 50, 57, 46, 57, 48, 10, 56, 57, 51, 50, 124, 55, 57, 54, 55, 50, 50, 50, 46, 49, 57, 10, 49, 51, 55, 48, 53, 124, 55, 57, 53, 51, 51, 52, 52, 46, 53, 50, 10, 49, 54, 56, 53, 53, 124, 55, 57, 50, 51, 56, 49, 57, 46, 48, 48, 10, 51, 50, 51, 52, 124, 55, 57, 50, 48, 48, 50, 50, 46, 48, 48, 10, 49, 55, 55, 53, 50, 124, 55, 57, 48, 49, 51, 54, 50, 46, 55, 55, 10, 50, 48, 57, 55, 124, 55, 56, 57, 50, 57, 57, 51, 46, 49, 55, 10, 49, 56, 53, 57, 57, 124, 55, 56, 57, 48, 55, 55, 52, 46, 52, 48, 10, 49, 57, 53, 57, 54, 124, 55, 56, 55, 52, 53, 54, 52, 46, 53, 57, 10, 49, 49, 51, 57, 50, 124, 55, 56, 54, 49, 49, 55, 50, 46, 52, 56, 10, 49, 56, 49, 50, 49, 124, 55, 56, 53, 55, 53, 56, 49, 46, 54, 48, 10, 49, 55, 52, 53, 50, 124, 55, 56, 51, 56, 52, 54, 53, 46, 51, 54, 10, 54, 48, 55, 54, 124, 55, 56, 50, 49, 51, 49, 54, 46, 56, 48, 10, 49, 53, 49, 51, 52, 124, 55, 56, 48, 52, 55, 54, 48, 46, 50, 53, 10, 56, 54, 52, 49, 124, 55, 56, 48, 50, 57, 49, 55, 46, 49, 53, 10, 50, 49, 51, 52, 124, 55, 56, 48, 48, 49, 56, 53, 46, 52, 51, 10, 49, 54, 51, 53, 50, 124, 55, 55, 57, 55, 49, 49, 50, 46, 48, 48, 10, 49, 57, 51, 49, 50, 124, 55, 55, 55, 53, 57, 53, 50, 46, 50, 52, 10, 50, 56, 57, 53, 124, 55, 55, 53, 57, 51, 50, 55, 46, 50, 51, 10, 49, 50, 56, 54, 48, 124, 55, 55, 53, 56, 49, 51, 53, 46, 50, 49, 10, 49, 53, 51, 124, 55, 55, 53, 53, 54, 56, 49, 46, 50, 56, 10, 49, 53, 48, 56, 57, 124, 55, 55, 51, 53, 52, 51, 56, 46, 50, 54, 10, 49, 52, 55, 57, 55, 124, 55, 55, 50, 53, 51, 53, 51, 46, 49, 54, 10, 49, 53, 57, 52, 54, 124, 55, 55, 50, 50, 55, 55, 51, 46, 56, 56, 10, 49, 48, 57, 49, 57, 124, 55, 55, 50, 50, 52, 50, 53, 46, 51, 54, 10, 57, 56, 54, 55, 124, 55, 55, 50, 49, 53, 57, 55, 46, 55, 56, 10, 49, 49, 56, 56, 49, 124, 55, 55, 49, 51, 49, 51, 54, 46, 52, 50, 10, 49, 54, 53, 53, 50, 124, 55, 55, 48, 56, 53, 49, 56, 46, 49, 53, 10, 54, 57, 50, 53, 124, 55, 55, 48, 51, 57, 57, 57, 46, 54, 56, 10, 49, 50, 49, 52, 55, 124, 55, 55, 48, 51, 56, 50, 54, 46, 57, 56, 10, 56, 57, 50, 51, 124, 55, 55, 48, 50, 54, 57, 48, 46, 50, 56, 10, 49, 54, 49, 49, 54, 124, 55, 54, 57, 55, 57, 55, 48, 46, 56, 52, 10, 49, 48, 54, 54, 49, 124, 55, 54, 55, 51, 56, 51, 48, 46, 50, 48, 10, 49, 55, 48, 57, 52, 124, 55, 54, 54, 53, 51, 54, 56, 46, 49, 54, 10, 49, 56, 54, 52, 56, 124, 55, 54, 53, 48, 56, 54, 50, 46, 48, 50, 10, 49, 50, 49, 55, 50, 124, 55, 54, 52, 49, 51, 50, 54, 46, 52, 48, 10, 49, 53, 49, 50, 51, 124, 55, 54, 51, 51, 48, 51, 50, 46, 53, 48, 10, 52, 57, 57, 51, 124, 55, 54, 48, 48, 53, 55, 48, 46, 56, 48, 10, 49, 55, 49, 54, 50, 124, 55, 53, 57, 50, 48, 54, 50, 46, 53, 54, 10, 49, 51, 53, 48, 54, 124, 55, 53, 56, 48, 56, 48, 57, 46, 56, 51, 10, 51, 52, 51, 54, 124, 55, 53, 55, 53, 54, 49, 54, 46, 51, 51, 10, 54, 50, 55, 49, 124, 55, 53, 53, 57, 55, 57, 51, 46, 57, 51, 10, 49, 51, 51, 49, 52, 124, 55, 53, 53, 53, 49, 53, 54, 46, 54, 51, 10, 49, 55, 50, 52, 50, 124, 55, 53, 53, 48, 57, 52, 57, 46, 53, 48, 10, 50, 55, 53, 51, 124, 55, 53, 52, 57, 53, 55, 52, 46, 48, 54, 10, 55, 51, 57, 49, 124, 55, 53, 52, 51, 49, 53, 57, 46, 54, 56, 10, 55, 52, 49, 56, 124, 55, 53, 52, 49, 52, 52, 57, 46, 54, 53, 10, 49, 49, 54, 124, 55, 53, 50, 48, 56, 55, 52, 46, 50, 52, 10, 49, 50, 52, 51, 54, 124, 55, 53, 50, 48, 50, 51, 52, 46, 53, 52, 10, 49, 49, 56, 49, 124, 55, 52, 57, 52, 55, 57, 56, 46, 50, 56, 10, 49, 50, 57, 54, 51, 124, 55, 52, 57, 49, 50, 52, 56, 46, 49, 48, 10, 50, 49, 51, 124, 55, 52, 55, 57, 52, 55, 48, 46, 50, 56, 10, 55, 49, 49, 52, 124, 55, 52, 55, 55, 54, 56, 49, 46, 50, 48, 10, 49, 56, 53, 50, 49, 124, 55, 52, 55, 54, 52, 55, 56, 46, 51, 48, 10, 56, 57, 55, 51, 124, 55, 52, 53, 56, 54, 48, 51, 46, 54, 55, 10, 52, 50, 48, 50, 124, 55, 52, 53, 52, 48, 57, 53, 46, 55, 52, 10, 49, 50, 48, 48, 57, 124, 55, 52, 52, 50, 49, 48, 53, 46, 52, 48, 10, 49, 48, 54, 48, 57, 124, 55, 52, 50, 57, 51, 52, 54, 46, 52, 48, 10, 53, 54, 50, 50, 124, 55, 52, 50, 52, 49, 52, 50, 46, 54, 54, 10, 53, 49, 52, 51, 124, 55, 52, 50, 50, 55, 54, 48, 46, 50, 56, 10, 56, 57, 56, 124, 55, 52, 49, 52, 49, 51, 51, 46, 56, 48, 10, 49, 50, 50, 53, 55, 124, 55, 52, 48, 56, 49, 57, 48, 46, 54, 51, 10, 54, 55, 52, 48, 124, 55, 52, 48, 48, 51, 53, 48, 46, 51, 53, 10, 49, 49, 52, 54, 124, 55, 51, 57, 52, 51, 57, 52, 46, 52, 56, 10, 53, 52, 56, 53, 124, 55, 51, 55, 56, 49, 56, 49, 46, 57, 52, 10, 56, 52, 51, 55, 124, 55, 51, 55, 54, 51, 53, 51, 46, 53, 57, 10, 54, 53, 51, 49, 124, 55, 51, 54, 50, 51, 54, 54, 46, 55, 56, 10, 49, 54, 52, 54, 51, 124, 55, 51, 54, 50, 49, 48, 54, 46, 56, 48, 10, 49, 48, 52, 49, 50, 124, 55, 51, 53, 57, 53, 53, 50, 46, 52, 50, 10, 49, 50, 56, 53, 55, 124, 55, 51, 52, 48, 56, 48, 49, 46, 53, 56, 10, 49, 50, 51, 53, 52, 124, 55, 51, 51, 50, 51, 52, 51, 46, 50, 48, 10, 55, 54, 49, 54, 124, 55, 51, 50, 48, 48, 51, 50, 46, 51, 55, 10, 51, 52, 50, 54, 124, 55, 51, 49, 50, 51, 52, 48, 46, 52, 49, 10, 56, 54, 50, 50, 124, 55, 51, 48, 55, 50, 54, 54, 46, 51, 51, 10, 54, 56, 49, 56, 124, 55, 51, 48, 52, 55, 56, 50, 46, 49, 48, 10, 51, 55, 48, 53, 124, 55, 50, 57, 57, 51, 56, 48, 46, 49, 48, 10, 49, 50, 55, 51, 51, 124, 55, 50, 57, 56, 51, 57, 56, 46, 49, 55, 10, 49, 53, 55, 52, 124, 55, 50, 57, 51, 52, 52, 54, 46, 48, 52, 10, 49, 48, 53, 53, 52, 124, 55, 50, 56, 57, 57, 51, 51, 46, 55, 50, 10, 57, 51, 54, 51, 124, 55, 50, 56, 52, 54, 52, 55, 46, 55, 48, 10, 52, 54, 49, 49, 124, 55, 50, 56, 50, 49, 49, 53, 46, 48, 48, 10, 55, 56, 53, 55, 124, 55, 50, 54, 54, 57, 52, 56, 46, 57, 50, 10, 57, 54, 49, 54, 124, 55, 50, 54, 53, 48, 48, 53, 46, 51, 48, 10, 49, 53, 56, 54, 48, 124, 55, 50, 53, 52, 52, 54, 54, 46, 54, 54, 10, 49, 53, 53, 53, 52, 124, 55, 50, 52, 55, 53, 57, 50, 46, 53, 49, 10, 51, 52, 50, 50, 124, 55, 50, 52, 55, 53, 56, 54, 46, 52, 53, 10, 57, 49, 51, 52, 124, 55, 50, 51, 54, 52, 48, 52, 46, 54, 55, 10, 49, 55, 52, 48, 56, 124, 55, 50, 50, 48, 48, 56, 51, 46, 54, 48, 10, 49, 53, 56, 53, 51, 124, 55, 50, 49, 57, 57, 56, 52, 46, 57, 48, 10, 57, 50, 54, 54, 124, 55, 50, 49, 56, 53, 49, 55, 46, 49, 49, 10, 49, 56, 56, 49, 124, 55, 50, 48, 56, 51, 52, 54, 46, 52, 53, 10, 49, 48, 49, 52, 56, 124, 55, 50, 48, 53, 51, 51, 53, 46, 56, 51, 10, 56, 56, 54, 48, 124, 55, 50, 48, 50, 52, 48, 49, 46, 52, 52, 10, 56, 51, 55, 51, 124, 55, 49, 56, 57, 48, 51, 57, 46, 53, 48, 10, 49, 48, 56, 53, 57, 124, 55, 49, 56, 56, 57, 57, 48, 46, 54, 57, 10, 49, 50, 54, 55, 48, 124, 55, 49, 56, 56, 49, 55, 55, 46, 50, 50, 10, 50, 53, 53, 51, 124, 55, 49, 56, 48, 48, 48, 54, 46, 48, 50, 10, 49, 57, 51, 52, 54, 124, 55, 49, 55, 54, 55, 57, 55, 46, 50, 53, 10, 49, 54, 56, 49, 124, 55, 49, 54, 48, 49, 54, 57, 46, 56, 52, 10, 49, 53, 50, 50, 53, 124, 55, 49, 53, 56, 56, 54, 49, 46, 51, 50, 10, 49, 48, 53, 50, 124, 55, 49, 53, 56, 53, 56, 54, 46, 48, 48, 10, 55, 55, 124, 55, 49, 53, 53, 53, 51, 49, 46, 49, 48, 10, 55, 50, 51, 49, 124, 55, 49, 53, 53, 50, 53, 48, 46, 51, 56, 10, 49, 50, 54, 50, 50, 124, 55, 49, 51, 55, 52, 48, 56, 46, 52, 50, 10, 57, 56, 49, 52, 124, 55, 49, 48, 53, 51, 54, 51, 46, 49, 52, 10, 56, 54, 57, 53, 124, 55, 49, 48, 51, 49, 56, 55, 46, 48, 48, 10, 49, 51, 49, 55, 52, 124, 55, 48, 57, 57, 49, 56, 50, 46, 53, 51, 10, 54, 49, 55, 57, 124, 55, 48, 57, 53, 49, 51, 52, 46, 48, 53, 10, 54, 52, 53, 49, 124, 55, 48, 56, 50, 52, 57, 53, 46, 51, 54, 10, 49, 57, 56, 54, 48, 124, 55, 48, 55, 51, 50, 48, 54, 46, 56, 51, 10, 57, 51, 48, 55, 124, 55, 48, 53, 57, 57, 55, 51, 46, 54, 56, 10, 55, 56, 49, 57, 124, 55, 48, 53, 53, 57, 54, 51, 46, 48, 52, 10, 49, 48, 53, 53, 54, 124, 55, 48, 53, 51, 52, 57, 49, 46, 48, 55, 10, 57, 51, 54, 54, 124, 55, 48, 52, 56, 54, 57, 48, 46, 55, 52, 10, 49, 50, 49, 50, 52, 124, 55, 48, 52, 48, 48, 50, 49, 46, 51, 49, 10, 49, 49, 52, 55, 54, 124, 55, 48, 51, 55, 57, 48, 54, 46, 55, 54, 10, 49, 57, 50, 52, 53, 124, 55, 48, 51, 52, 48, 52, 53, 46, 50, 52, 10, 55, 53, 54, 50, 124, 55, 48, 51, 48, 50, 55, 53, 46, 55, 57, 10, 49, 50, 50, 57, 48, 124, 55, 48, 50, 48, 51, 55, 50, 46, 48, 54, 10, 49, 56, 49, 49, 56, 124, 55, 48, 48, 51, 51, 57, 54, 46, 56, 48, 10, 49, 50, 53, 51, 124, 55, 48, 48, 49, 53, 54, 57, 46, 54, 50, 10, 56, 54, 54, 50, 124, 54, 57, 57, 57, 56, 51, 52, 46, 50, 55, 10, 49, 55, 55, 57, 124, 54, 57, 57, 55, 51, 56, 53, 46, 55, 51, 10, 49, 53, 51, 56, 54, 124, 54, 57, 57, 54, 56, 55, 49, 46, 55, 57, 10, 49, 52, 55, 124, 54, 57, 56, 57, 48, 55, 57, 46, 56, 56, 10, 57, 53, 54, 50, 124, 54, 57, 56, 51, 48, 55, 54, 46, 57, 48, 10, 51, 57, 53, 56, 124, 54, 57, 54, 57, 56, 51, 51, 46, 50, 50, 10, 55, 50, 49, 49, 124, 54, 57, 54, 54, 54, 48, 54, 46, 54, 55, 10, 49, 50, 56, 52, 50, 124, 54, 57, 50, 51, 50, 55, 55, 46, 54, 54, 10, 52, 51, 54, 56, 124, 54, 57, 49, 56, 55, 56, 51, 46, 57, 53, 10, 49, 49, 49, 51, 49, 124, 54, 57, 49, 56, 54, 53, 54, 46, 55, 56, 10, 52, 54, 50, 56, 124, 54, 56, 57, 52, 56, 57, 51, 46, 56, 50, 10, 53, 56, 55, 57, 124, 54, 56, 56, 49, 51, 54, 55, 46, 49, 52, 10, 49, 54, 53, 56, 54, 124, 54, 56, 54, 53, 57, 51, 49, 46, 56, 48, 10, 51, 50, 124, 54, 56, 53, 50, 57, 50, 53, 46, 53, 57, 10, 49, 50, 49, 49, 57, 124, 54, 56, 52, 50, 55, 55, 51, 46, 55, 48, 10, 49, 51, 55, 49, 124, 54, 56, 51, 49, 49, 51, 55, 46, 53, 50, 10, 54, 49, 51, 54, 124, 54, 56, 50, 55, 57, 49, 55, 46, 48, 49, 10, 49, 51, 56, 53, 55, 124, 54, 56, 50, 52, 50, 52, 48, 46, 54, 48, 10, 49, 48, 55, 52, 124, 54, 56, 50, 49, 55, 52, 55, 46, 56, 56, 10, 49, 56, 54, 51, 124, 54, 56, 50, 49, 53, 50, 50, 46, 49, 57, 10, 49, 52, 53, 57, 55, 124, 54, 56, 49, 55, 51, 56, 53, 46, 54, 54, 10, 57, 50, 55, 49, 124, 54, 55, 56, 51, 48, 54, 56, 46, 56, 56, 10, 54, 51, 56, 57, 124, 54, 55, 56, 49, 48, 55, 53, 46, 54, 56, 10, 49, 49, 55, 48, 51, 124, 54, 55, 55, 54, 53, 51, 56, 46, 51, 54, 10, 49, 51, 55, 48, 49, 124, 54, 55, 54, 56, 56, 56, 48, 46, 53, 54, 10, 49, 52, 56, 56, 48, 124, 54, 55, 54, 51, 55, 56, 56, 46, 50, 52, 10, 49, 56, 52, 50, 56, 124, 54, 55, 54, 51, 54, 55, 48, 46, 53, 52, 10, 49, 48, 48, 54, 124, 54, 55, 54, 50, 48, 54, 53, 46, 57, 52, 10, 52, 57, 50, 55, 124, 54, 55, 53, 54, 55, 54, 53, 46, 50, 49, 10, 49, 49, 54, 53, 57, 124, 54, 55, 53, 53, 50, 52, 54, 46, 54, 56, 10, 54, 56, 49, 53, 124, 54, 55, 51, 56, 57, 50, 56, 46, 51, 53, 10, 49, 52, 51, 54, 55, 124, 54, 55, 51, 51, 56, 53, 55, 46, 50, 48, 10, 49, 48, 55, 48, 51, 124, 54, 55, 51, 48, 57, 51, 54, 46, 52, 54, 10, 51, 49, 53, 48, 124, 54, 55, 50, 55, 57, 50, 48, 46, 52, 48, 10, 57, 57, 54, 51, 124, 54, 55, 50, 53, 57, 49, 57, 46, 51, 53, 10, 49, 48, 52, 51, 56, 124, 54, 55, 49, 48, 49, 53, 51, 46, 54, 50, 10, 52, 55, 52, 53, 124, 54, 54, 56, 50, 49, 53, 51, 46, 54, 55, 10, 49, 53, 50, 57, 55, 124, 54, 54, 56, 49, 55, 49, 49, 46, 50, 56, 10, 49, 48, 56, 52, 56, 124, 54, 54, 55, 56, 54, 54, 54, 46, 50, 53, 10, 49, 49, 55, 52, 57, 124, 54, 54, 55, 55, 56, 57, 53, 46, 55, 51, 10, 49, 54, 55, 51, 57, 124, 54, 54, 55, 53, 53, 52, 57, 46, 49, 50, 10, 49, 52, 57, 49, 53, 124, 54, 54, 55, 50, 50, 52, 56, 46, 54, 54, 10, 49, 57, 56, 52, 49, 124, 54, 54, 54, 57, 49, 57, 49, 46, 50, 48, 10, 54, 50, 56, 124, 54, 54, 54, 54, 56, 57, 50, 46, 57, 48, 10, 49, 54, 53, 48, 124, 54, 54, 53, 55, 49, 55, 56, 46, 51, 50, 10, 55, 48, 54, 57, 124, 54, 54, 52, 56, 54, 55, 50, 46, 50, 52, 10, 55, 49, 48, 56, 124, 54, 54, 52, 54, 52, 52, 53, 46, 57, 54, 10, 56, 56, 56, 55, 124, 54, 54, 52, 49, 54, 53, 53, 46, 57, 48, 10, 49, 56, 55, 51, 53, 124, 54, 54, 51, 54, 52, 53, 55, 46, 53, 54, 10, 51, 55, 49, 49, 124, 54, 54, 51, 50, 54, 54, 53, 46, 51, 56, 10, 50, 51, 50, 53, 124, 54, 54, 51, 48, 52, 55, 53, 46, 57, 50, 10, 54, 52, 56, 52, 124, 54, 54, 50, 50, 57, 54, 53, 46, 50, 48, 10, 50, 54, 52, 51, 124, 54, 54, 49, 55, 51, 48, 52, 46, 57, 56, 10, 55, 56, 57, 53, 124, 54, 54, 49, 53, 48, 54, 49, 46, 50, 54, 10, 49, 50, 56, 52, 48, 124, 54, 54, 48, 52, 56, 52, 56, 46, 53, 52, 10, 52, 51, 49, 52, 124, 54, 54, 48, 48, 57, 48, 53, 46, 55, 49, 10, 49, 57, 48, 55, 55, 124, 54, 53, 57, 49, 48, 57, 49, 46, 57, 55, 10, 49, 55, 52, 55, 54, 124, 54, 53, 55, 54, 48, 50, 57, 46, 48, 48, 10, 55, 48, 51, 57, 124, 54, 53, 53, 57, 56, 51, 56, 46, 57, 48, 10, 56, 49, 48, 54, 124, 54, 53, 53, 56, 50, 50, 51, 46, 48, 50, 10, 50, 51, 57, 49, 124, 54, 53, 53, 55, 49, 50, 48, 46, 48, 56, 10, 55, 55, 49, 55, 124, 54, 53, 52, 55, 55, 48, 54, 46, 56, 56, 10, 49, 50, 52, 55, 54, 124, 54, 53, 52, 54, 57, 56, 56, 46, 49, 53, 10, 57, 49, 53, 53, 124, 54, 53, 52, 48, 55, 57, 51, 46, 54, 48, 10, 51, 54, 48, 124, 54, 53, 51, 48, 50, 57, 55, 46, 52, 49, 10, 54, 51, 56, 51, 124, 54, 53, 50, 57, 51, 51, 54, 46, 48, 50, 10, 52, 56, 51, 48, 124, 54, 53, 49, 56, 57, 57, 56, 46, 57, 50, 10, 49, 50, 54, 48, 48, 124, 54, 53, 49, 49, 53, 52, 57, 46, 52, 54, 10, 49, 51, 55, 52, 48, 124, 54, 53, 48, 56, 48, 53, 55, 46, 57, 50, 10, 52, 54, 55, 56, 124, 54, 53, 48, 55, 56, 52, 55, 46, 57, 56, 10, 49, 55, 56, 49, 53, 124, 54, 53, 48, 50, 50, 56, 52, 46, 55, 54, 10, 55, 51, 50, 57, 124, 54, 52, 57, 48, 56, 49, 49, 46, 57, 53, 10, 49, 51, 56, 56, 52, 124, 54, 52, 57, 48, 48, 54, 51, 46, 49, 48, 10, 53, 49, 52, 55, 124, 54, 52, 56, 55, 48, 54, 57, 46, 48, 48, 10, 49, 54, 53, 52, 56, 124, 54, 52, 56, 50, 48, 50, 52, 46, 53, 48, 10, 49, 52, 49, 52, 52, 124, 54, 52, 55, 54, 52, 49, 51, 46, 52, 48, 10, 49, 48, 49, 56, 49, 124, 54, 52, 55, 52, 57, 56, 52, 46, 56, 56, 10, 49, 49, 48, 51, 49, 124, 54, 52, 54, 51, 51, 48, 56, 46, 48, 50, 10, 49, 57, 57, 53, 56, 124, 54, 52, 54, 49, 53, 48, 54, 46, 51, 56, 10, 54, 48, 52, 51, 124, 54, 52, 53, 56, 49, 55, 55, 46, 54, 52, 10, 49, 48, 48, 54, 48, 124, 54, 52, 53, 53, 52, 55, 54, 46, 56, 57, 10, 57, 49, 52, 52, 124, 54, 52, 53, 52, 48, 52, 50, 46, 48, 53, 10, 55, 48, 52, 51, 124, 54, 52, 52, 56, 48, 49, 57, 46, 57, 56, 10, 49, 55, 51, 52, 54, 124, 54, 52, 52, 52, 51, 48, 55, 46, 53, 50, 10, 49, 51, 57, 54, 51, 124, 54, 52, 52, 50, 48, 49, 52, 46, 52, 56, 10, 55, 49, 49, 49, 124, 54, 52, 52, 49, 57, 52, 55, 46, 48, 55, 10, 49, 52, 49, 52, 48, 124, 54, 52, 51, 57, 57, 53, 53, 46, 53, 52, 10, 50, 51, 50, 55, 124, 54, 52, 51, 56, 57, 55, 55, 46, 50, 56, 10, 49, 52, 56, 49, 50, 124, 54, 52, 51, 55, 49, 53, 50, 46, 53, 52, 10, 49, 54, 55, 53, 53, 124, 54, 52, 51, 48, 56, 57, 53, 46, 51, 54, 10, 49, 52, 56, 52, 48, 124, 54, 52, 51, 48, 53, 52, 57, 46, 49, 52, 10, 49, 52, 49, 51, 52, 124, 54, 52, 50, 50, 48, 55, 57, 46, 50, 54, 10, 49, 50, 54, 53, 53, 124, 54, 52, 48, 53, 52, 57, 54, 46, 55, 57, 10, 49, 53, 49, 56, 124, 54, 51, 57, 48, 49, 52, 56, 46, 50, 50, 10, 57, 56, 56, 56, 124, 54, 51, 56, 53, 48, 51, 51, 46, 48, 50, 10, 55, 51, 56, 55, 124, 54, 51, 56, 52, 48, 48, 53, 46, 49, 56, 10, 53, 51, 57, 51, 124, 54, 51, 56, 49, 48, 56, 51, 46, 48, 52, 10, 49, 49, 48, 53, 55, 124, 54, 51, 55, 53, 57, 55, 52, 46, 50, 50, 10, 49, 54, 56, 49, 56, 124, 54, 51, 54, 56, 56, 50, 56, 46, 56, 48, 10, 52, 53, 55, 54, 124, 54, 51, 54, 52, 57, 50, 53, 46, 55, 49, 10, 49, 57, 54, 52, 52, 124, 54, 51, 53, 48, 48, 48, 48, 46, 51, 51, 10, 49, 51, 57, 124, 54, 51, 51, 54, 48, 54, 53, 46, 53, 53, 10, 49, 49, 55, 51, 53, 124, 54, 51, 51, 52, 51, 48, 53, 46, 57, 48, 10, 49, 48, 49, 48, 56, 124, 54, 51, 51, 50, 48, 53, 53, 46, 57, 57, 10, 49, 53, 54, 50, 56, 124, 54, 51, 50, 57, 56, 48, 49, 46, 51, 52, 10, 52, 51, 52, 57, 124, 54, 51, 49, 52, 57, 52, 57, 46, 54, 56, 10, 55, 48, 52, 56, 124, 54, 51, 49, 51, 56, 54, 56, 46, 53, 53, 10, 49, 55, 49, 49, 57, 124, 54, 50, 57, 56, 57, 51, 53, 46, 51, 56, 10, 49, 56, 53, 57, 55, 124, 54, 50, 57, 49, 52, 49, 54, 46, 51, 49, 10, 50, 52, 56, 56, 124, 54, 50, 56, 54, 51, 55, 50, 46, 48, 53, 10, 50, 50, 57, 54, 124, 54, 50, 55, 53, 53, 49, 57, 46, 50, 53, 10, 52, 51, 52, 51, 124, 54, 50, 55, 50, 56, 51, 52, 46, 50, 48, 10, 57, 57, 53, 56, 124, 54, 50, 54, 55, 55, 49, 52, 46, 54, 49, 10, 50, 49, 52, 55, 124, 54, 50, 54, 55, 52, 55, 53, 46, 51, 50, 10, 57, 51, 54, 56, 124, 54, 50, 53, 52, 53, 55, 56, 46, 57, 50, 10, 49, 51, 49, 51, 52, 124, 54, 50, 53, 50, 52, 51, 50, 46, 55, 54, 10, 49, 48, 49, 49, 57, 124, 54, 50, 53, 49, 52, 53, 54, 46, 50, 53, 10, 50, 48, 57, 51, 124, 54, 50, 52, 57, 51, 52, 50, 46, 51, 54, 10, 50, 51, 57, 50, 124, 54, 50, 51, 55, 52, 55, 54, 46, 53, 54, 10, 49, 55, 50, 51, 49, 124, 54, 50, 51, 51, 53, 48, 57, 46, 49, 56, 10, 51, 55, 55, 51, 124, 54, 50, 50, 54, 54, 53, 52, 46, 54, 56, 10, 57, 56, 51, 57, 124, 54, 50, 49, 52, 48, 52, 52, 46, 49, 48, 10, 49, 57, 51, 52, 57, 124, 54, 50, 49, 51, 57, 54, 57, 46, 51, 48, 10, 55, 56, 54, 57, 124, 54, 50, 49, 50, 55, 53, 49, 46, 48, 48, 10, 56, 49, 53, 56, 124, 54, 50, 49, 48, 50, 55, 57, 46, 50, 52, 10, 49, 51, 49, 55, 57, 124, 54, 50, 48, 53, 55, 55, 51, 46, 54, 53, 10, 50, 51, 52, 57, 124, 54, 50, 48, 53, 53, 56, 57, 46, 50, 54, 10, 57, 48, 53, 50, 124, 54, 50, 48, 48, 55, 50, 57, 46, 55, 48, 10, 49, 55, 52, 52, 124, 54, 49, 56, 57, 57, 54, 55, 46, 51, 54, 10, 53, 57, 55, 124, 54, 49, 56, 51, 49, 48, 51, 46, 52, 55, 10, 49, 54, 55, 50, 49, 124, 54, 49, 55, 54, 54, 48, 54, 46, 54, 48, 10, 55, 52, 57, 56, 124, 54, 49, 55, 54, 50, 55, 55, 46, 50, 53, 10, 49, 53, 49, 53, 55, 124, 54, 49, 55, 54, 50, 50, 50, 46, 53, 48, 10, 49, 55, 53, 50, 52, 124, 54, 49, 55, 49, 49, 48, 55, 46, 51, 54, 10, 55, 57, 50, 50, 124, 54, 49, 55, 48, 57, 48, 54, 46, 48, 55, 10, 54, 54, 49, 53, 124, 54, 49, 55, 48, 55, 51, 56, 46, 52, 50, 10, 50, 55, 48, 54, 124, 54, 49, 54, 53, 57, 57, 49, 46, 54, 53, 10, 49, 54, 52, 51, 50, 124, 54, 49, 54, 50, 55, 52, 48, 46, 54, 56, 10, 49, 54, 52, 55, 51, 124, 54, 49, 54, 50, 52, 50, 55, 46, 57, 54, 10, 49, 50, 56, 50, 53, 124, 54, 49, 54, 49, 53, 57, 53, 46, 54, 48, 10, 49, 56, 56, 49, 51, 124, 54, 49, 53, 52, 54, 55, 56, 46, 53, 53, 10, 49, 48, 51, 48, 124, 54, 49, 52, 54, 53, 48, 48, 46, 50, 56, 10, 50, 53, 55, 49, 124, 54, 49, 52, 53, 55, 55, 50, 46, 52, 51, 10, 55, 55, 48, 55, 124, 54, 49, 52, 52, 55, 53, 52, 46, 55, 49, 10, 49, 48, 51, 50, 55, 124, 54, 49, 51, 55, 54, 49, 50, 46, 48, 48, 10, 52, 55, 49, 48, 124, 54, 49, 51, 50, 51, 52, 54, 46, 53, 54, 10, 51, 54, 52, 57, 124, 54, 49, 51, 48, 54, 48, 50, 46, 54, 51, 10, 52, 56, 57, 51, 124, 54, 49, 50, 56, 52, 54, 49, 46, 50, 52, 10, 49, 50, 56, 52, 52, 124, 54, 49, 50, 56, 49, 57, 49, 46, 50, 52, 10, 56, 55, 57, 52, 124, 54, 49, 50, 50, 54, 57, 48, 46, 50, 56, 10, 49, 49, 53, 55, 124, 54, 49, 49, 55, 55, 52, 57, 46, 50, 50, 10, 49, 48, 56, 57, 53, 124, 54, 49, 49, 50, 48, 49, 55, 46, 54, 56, 10, 49, 54, 49, 54, 54, 124, 54, 49, 48, 56, 50, 53, 48, 46, 57, 56, 10, 49, 49, 57, 50, 48, 124, 54, 49, 48, 55, 49, 50, 50, 46, 53, 54, 10, 53, 54, 50, 49, 124, 54, 49, 48, 50, 49, 50, 51, 46, 53, 54, 10, 54, 49, 52, 49, 124, 54, 48, 57, 51, 56, 50, 54, 46, 53, 54, 10, 49, 52, 48, 55, 54, 124, 54, 48, 56, 54, 54, 55, 49, 46, 48, 56, 10, 49, 53, 56, 56, 52, 124, 54, 48, 56, 48, 52, 56, 53, 46, 53, 57, 10, 52, 56, 49, 52, 124, 54, 48, 56, 48, 51, 51, 55, 46, 57, 54, 10, 53, 56, 49, 52, 124, 54, 48, 55, 57, 56, 52, 50, 46, 57, 54, 10, 49, 49, 51, 52, 124, 54, 48, 55, 56, 54, 56, 53, 46, 50, 48, 10, 49, 57, 48, 52, 56, 124, 54, 48, 55, 49, 56, 49, 51, 46, 50, 56, 10, 51, 48, 51, 124, 54, 48, 55, 48, 54, 48, 49, 46, 51, 53, 10, 49, 53, 50, 49, 49, 124, 54, 48, 54, 53, 54, 55, 56, 46, 48, 54, 10, 49, 48, 50, 48, 124, 54, 48, 53, 52, 49, 54, 56, 46, 48, 48, 10, 49, 49, 50, 57, 50, 124, 54, 48, 53, 50, 53, 50, 50, 46, 56, 51, 10, 55, 49, 51, 52, 124, 54, 48, 52, 57, 56, 54, 53, 46, 50, 53, 10, 49, 52, 49, 49, 57, 124, 54, 48, 52, 57, 54, 49, 57, 46, 53, 53, 10, 50, 51, 56, 57, 124, 54, 48, 52, 50, 52, 50, 57, 46, 49, 50, 10, 53, 57, 50, 54, 124, 54, 48, 51, 52, 50, 54, 57, 46, 53, 50, 10, 56, 53, 53, 51, 124, 54, 48, 51, 48, 57, 50, 50, 46, 57, 53, 10, 49, 56, 56, 49, 52, 124, 54, 48, 50, 51, 50, 53, 53, 46, 49, 55, 10, 49, 50, 55, 48, 50, 124, 54, 48, 50, 51, 49, 57, 48, 46, 57, 57, 10, 50, 54, 52, 52, 124, 54, 48, 50, 48, 57, 51, 49, 46, 51, 51, 10, 49, 57, 54, 50, 56, 124, 54, 48, 49, 48, 55, 48, 52, 46, 48, 48, 10, 49, 56, 49, 49, 50, 124, 54, 48, 48, 56, 55, 48, 55, 46, 53, 50, 10, 49, 51, 56, 54, 48, 124, 54, 48, 48, 56, 49, 55, 48, 46, 50, 57, 10, 49, 52, 53, 54, 124, 54, 48, 48, 53, 48, 57, 50, 46, 49, 52, 10, 49, 54, 51, 51, 124, 54, 48, 48, 50, 48, 54, 56, 46, 56, 53, 10, 50, 51, 48, 49, 124, 54, 48, 48, 48, 51, 48, 50, 46, 50, 57, 10, 49, 48, 55, 52, 48, 124, 53, 57, 57, 57, 56, 48, 57, 46, 48, 53, 10, 50, 54, 51, 48, 124, 53, 57, 57, 55, 48, 48, 56, 46, 52, 51, 10, 56, 56, 49, 56, 124, 53, 57, 57, 50, 50, 57, 54, 46, 57, 48, 10, 49, 48, 48, 52, 51, 124, 53, 57, 57, 48, 53, 57, 52, 46, 48, 50, 10, 54, 53, 51, 124, 53, 57, 56, 55, 57, 52, 50, 46, 56, 51, 10, 54, 56, 50, 57, 124, 53, 57, 56, 53, 57, 57, 48, 46, 54, 54, 10, 49, 53, 49, 55, 57, 124, 53, 57, 55, 55, 55, 50, 55, 46, 53, 50, 10, 57, 54, 54, 51, 124, 53, 57, 55, 51, 53, 50, 51, 46, 57, 50, 10, 53, 56, 54, 51, 124, 53, 57, 55, 51, 51, 50, 56, 46, 57, 50, 10, 51, 54, 50, 56, 124, 53, 57, 54, 54, 51, 52, 48, 46, 48, 57, 10, 55, 54, 49, 56, 124, 53, 57, 54, 48, 49, 53, 53, 46, 56, 54, 10, 50, 53, 56, 56, 124, 53, 57, 53, 50, 54, 52, 56, 46, 53, 54, 10, 52, 56, 54, 53, 124, 53, 57, 52, 57, 51, 56, 51, 46, 52, 48, 10, 52, 50, 51, 51, 124, 53, 57, 52, 52, 54, 57, 57, 46, 54, 48, 10, 49, 51, 51, 57, 48, 124, 53, 57, 52, 52, 49, 48, 52, 46, 54, 57, 10, 49, 54, 51, 50, 49, 124, 53, 57, 52, 50, 55, 49, 52, 46, 55, 48, 10, 57, 54, 53, 51, 124, 53, 57, 52, 49, 51, 48, 56, 46, 53, 48, 10, 49, 56, 56, 56, 52, 124, 53, 57, 50, 53, 53, 52, 56, 46, 50, 52, 10, 52, 51, 57, 52, 124, 53, 57, 50, 48, 57, 50, 55, 46, 49, 52, 10, 49, 57, 55, 55, 52, 124, 53, 57, 49, 54, 55, 50, 51, 46, 49, 50, 10, 49, 50, 53, 55, 124, 53, 57, 49, 52, 48, 53, 50, 46, 51, 54, 10, 50, 57, 54, 51, 124, 53, 57, 49, 49, 57, 49, 55, 46, 55, 55, 10, 49, 55, 49, 53, 55, 124, 53, 56, 57, 57, 53, 55, 51, 46, 48, 50, 10, 51, 56, 51, 124, 53, 56, 56, 52, 54, 57, 51, 46, 51, 54, 10, 49, 49, 55, 48, 57, 124, 53, 56, 56, 52, 49, 51, 52, 46, 52, 56, 10, 49, 56, 49, 51, 53, 124, 53, 56, 55, 49, 52, 51, 49, 46, 54, 49, 10, 49, 51, 49, 54, 57, 124, 53, 56, 54, 57, 55, 51, 54, 46, 56, 56, 10, 50, 57, 51, 50, 124, 53, 56, 54, 56, 57, 57, 53, 46, 56, 48, 10, 50, 56, 56, 56, 124, 53, 56, 54, 51, 50, 50, 57, 46, 51, 48, 10, 54, 56, 50, 48, 124, 53, 56, 53, 51, 49, 48, 54, 46, 56, 48, 10, 49, 56, 54, 50, 50, 124, 53, 56, 53, 48, 57, 53, 49, 46, 54, 48, 10, 57, 48, 54, 54, 124, 53, 56, 52, 54, 48, 53, 50, 46, 55, 50, 10, 49, 57, 56, 52, 48, 124, 53, 56, 51, 50, 50, 53, 49, 46, 52, 48, 10, 54, 51, 50, 53, 124, 53, 56, 50, 55, 50, 57, 56, 46, 52, 51, 10, 49, 52, 48, 57, 50, 124, 53, 56, 50, 51, 55, 49, 49, 46, 55, 50, 10, 49, 49, 53, 51, 50, 124, 53, 56, 50, 51, 50, 55, 55, 46, 49, 50, 10, 49, 56, 48, 52, 51, 124, 53, 56, 49, 53, 50, 52, 56, 46, 55, 48, 10, 51, 57, 51, 50, 124, 53, 56, 48, 57, 49, 51, 52, 46, 54, 48, 10, 49, 48, 51, 54, 52, 124, 53, 56, 48, 56, 51, 55, 49, 46, 52, 48, 10, 49, 49, 55, 57, 124, 53, 56, 48, 56, 51, 48, 51, 46, 50, 52, 10, 49, 49, 52, 52, 49, 124, 53, 55, 57, 57, 51, 55, 56, 46, 51, 51, 10, 49, 53, 55, 54, 55, 124, 53, 55, 57, 56, 50, 54, 51, 46, 50, 54, 10, 49, 52, 48, 54, 51, 124, 53, 55, 57, 55, 50, 48, 52, 46, 48, 48, 10, 49, 49, 51, 56, 51, 124, 53, 55, 57, 51, 56, 57, 51, 46, 49, 50, 10, 49, 48, 48, 54, 53, 124, 53, 55, 56, 49, 55, 54, 52, 46, 52, 53, 10, 49, 55, 55, 56, 53, 124, 53, 55, 54, 54, 56, 51, 56, 46, 55, 54, 10, 49, 56, 51, 52, 57, 124, 53, 55, 54, 49, 55, 54, 53, 46, 55, 55, 10, 49, 52, 56, 50, 52, 124, 53, 55, 54, 48, 51, 51, 57, 46, 55, 56, 10, 49, 52, 54, 57, 57, 124, 53, 55, 53, 57, 52, 57, 48, 46, 49, 56, 10, 49, 49, 54, 50, 56, 124, 53, 55, 53, 53, 49, 51, 55, 46, 50, 48, 10, 52, 52, 48, 51, 124, 53, 55, 53, 50, 51, 55, 54, 46, 54, 52, 10, 49, 51, 48, 57, 48, 124, 53, 55, 53, 49, 57, 52, 57, 46, 50, 53, 10, 49, 53, 51, 51, 50, 124, 53, 55, 52, 52, 54, 48, 54, 46, 50, 56, 10, 49, 55, 53, 55, 51, 124, 53, 55, 52, 52, 51, 56, 52, 46, 49, 53, 10, 49, 50, 56, 57, 53, 124, 53, 55, 52, 49, 48, 48, 55, 46, 48, 50, 10, 49, 51, 53, 55, 55, 124, 53, 55, 51, 57, 50, 48, 57, 46, 57, 52, 10, 49, 54, 53, 57, 52, 124, 53, 55, 51, 50, 53, 50, 51, 46, 54, 52, 10, 56, 52, 57, 55, 124, 53, 55, 50, 55, 53, 48, 57, 46, 56, 52, 10, 50, 56, 55, 50, 124, 53, 55, 50, 52, 48, 54, 56, 46, 55, 50, 10, 49, 54, 49, 56, 49, 124, 53, 55, 50, 49, 55, 56, 56, 46, 49, 54, 10, 54, 54, 51, 57, 124, 53, 55, 49, 50, 48, 52, 49, 46, 50, 50, 10, 49, 51, 48, 57, 53, 124, 53, 55, 48, 56, 55, 57, 56, 46, 50, 53, 10, 52, 53, 51, 53, 124, 53, 54, 57, 51, 51, 52, 49, 46, 50, 48, 10, 49, 48, 57, 53, 54, 124, 53, 54, 57, 50, 53, 56, 53, 46, 53, 48, 10, 49, 57, 55, 53, 53, 124, 53, 54, 56, 54, 57, 49, 51, 46, 51, 55, 10, 49, 50, 57, 57, 53, 124, 53, 54, 56, 50, 50, 48, 48, 46, 52, 49, 10, 49, 51, 49, 53, 55, 124, 53, 54, 56, 49, 52, 53, 52, 46, 57, 52, 10, 49, 56, 56, 55, 124, 53, 54, 56, 49, 51, 52, 49, 46, 50, 52, 10, 49, 56, 52, 55, 50, 124, 53, 54, 56, 48, 51, 53, 54, 46, 48, 48, 10, 49, 57, 56, 49, 52, 124, 53, 54, 55, 57, 51, 54, 48, 46, 48, 48, 10, 49, 56, 53, 56, 51, 124, 53, 54, 54, 57, 51, 54, 48, 46, 53, 50, 10, 51, 56, 57, 52, 124, 53, 54, 54, 52, 51, 56, 53, 46, 52, 57, 10, 49, 55, 52, 48, 124, 53, 54, 53, 57, 53, 53, 50, 46, 48, 52, 10, 54, 50, 124, 53, 54, 53, 57, 52, 55, 48, 46, 49, 54, 10, 49, 54, 53, 51, 50, 124, 53, 54, 53, 51, 55, 55, 57, 46, 52, 54, 10, 57, 57, 53, 124, 53, 54, 52, 56, 57, 55, 51, 46, 52, 53, 10, 55, 52, 56, 54, 124, 53, 54, 52, 54, 56, 53, 49, 46, 56, 55, 10, 49, 57, 48, 48, 55, 124, 53, 54, 52, 50, 55, 49, 48, 46, 57, 51, 10, 49, 51, 48, 54, 48, 124, 53, 54, 52, 50, 48, 50, 52, 46, 54, 52, 10, 49, 50, 51, 55, 49, 124, 53, 54, 51, 53, 55, 49, 48, 46, 52, 53, 10, 50, 50, 56, 48, 124, 53, 54, 51, 52, 48, 55, 55, 46, 52, 48, 10, 51, 49, 49, 53, 124, 53, 54, 51, 49, 51, 53, 50, 46, 51, 50, 10, 49, 49, 49, 48, 55, 124, 53, 54, 51, 49, 50, 53, 50, 46, 52, 54, 10, 53, 56, 55, 51, 124, 53, 54, 50, 57, 49, 50, 53, 46, 55, 53, 10, 49, 52, 55, 52, 51, 124, 53, 54, 50, 56, 55, 51, 50, 46, 56, 48, 10, 50, 50, 50, 52, 124, 53, 54, 50, 52, 55, 52, 54, 46, 54, 50, 10, 50, 54, 53, 51, 124, 53, 54, 50, 51, 56, 53, 57, 46, 57, 57, 10, 49, 55, 54, 50, 50, 124, 53, 54, 50, 51, 48, 53, 55, 46, 52, 52, 10, 49, 52, 55, 48, 48, 124, 53, 54, 49, 53, 51, 52, 52, 46, 48, 48, 10, 49, 52, 55, 52, 48, 124, 53, 54, 49, 51, 57, 50, 57, 46, 51, 57, 10, 54, 52, 48, 51, 124, 53, 54, 49, 49, 57, 50, 52, 46, 53, 49, 10, 54, 56, 57, 54, 124, 53, 54, 48, 57, 49, 54, 57, 46, 56, 56, 10, 49, 48, 51, 56, 52, 124, 53, 54, 48, 55, 51, 51, 55, 46, 53, 50, 10, 49, 54, 52, 51, 51, 124, 53, 54, 48, 53, 55, 48, 55, 46, 48, 51, 10, 53, 56, 57, 56, 124, 53, 54, 48, 52, 57, 51, 55, 46, 55, 54, 10, 52, 55, 56, 57, 124, 53, 54, 48, 48, 52, 56, 56, 46, 51, 54, 10, 56, 49, 51, 50, 124, 53, 53, 57, 51, 49, 48, 55, 46, 53, 48, 10, 51, 56, 51, 56, 124, 53, 53, 57, 50, 51, 49, 51, 46, 50, 48, 10, 49, 51, 54, 51, 49, 124, 53, 53, 56, 54, 52, 50, 52, 46, 56, 48, 10, 49, 49, 50, 51, 51, 124, 53, 53, 56, 53, 50, 52, 55, 46, 48, 49, 10, 56, 52, 57, 124, 53, 53, 56, 51, 53, 49, 54, 46, 52, 53, 10, 49, 52, 54, 53, 51, 124, 53, 53, 56, 49, 53, 53, 48, 46, 52, 53, 10, 49, 52, 55, 56, 56, 124, 53, 53, 56, 48, 52, 51, 51, 46, 48, 48, 10, 49, 56, 49, 56, 49, 124, 53, 53, 55, 56, 53, 54, 50, 46, 56, 56, 10, 49, 57, 56, 49, 53, 124, 53, 53, 55, 55, 49, 48, 50, 46, 54, 50, 10, 53, 53, 56, 52, 124, 53, 53, 55, 54, 54, 57, 50, 46, 50, 48, 10, 53, 51, 56, 53, 124, 53, 53, 55, 54, 52, 50, 48, 46, 49, 57, 10, 49, 51, 55, 56, 48, 124, 53, 53, 54, 57, 48, 50, 56, 46, 54, 49, 10, 57, 51, 52, 50, 124, 53, 53, 54, 54, 55, 56, 51, 46, 55, 49, 10, 49, 57, 48, 53, 54, 124, 53, 53, 54, 54, 53, 50, 52, 46, 49, 50, 10, 56, 49, 56, 57, 124, 53, 53, 54, 53, 54, 57, 52, 46, 55, 52, 10, 49, 51, 56, 48, 56, 124, 53, 53, 54, 48, 55, 50, 49, 46, 57, 54, 10, 49, 48, 54, 51, 53, 124, 53, 53, 54, 48, 48, 53, 56, 46, 53, 53, 10, 56, 51, 48, 52, 124, 53, 53, 53, 48, 55, 56, 52, 46, 52, 49, 10, 49, 52, 50, 53, 55, 124, 53, 53, 52, 57, 49, 54, 52, 46, 48, 54, 10, 56, 57, 57, 57, 124, 53, 53, 52, 50, 49, 48, 48, 46, 49, 48, 10, 49, 57, 49, 51, 52, 124, 53, 53, 51, 57, 51, 49, 50, 46, 53, 54, 10, 56, 51, 54, 48, 124, 53, 53, 51, 56, 48, 51, 49, 46, 49, 48, 10, 54, 51, 57, 55, 124, 53, 53, 51, 54, 54, 53, 49, 46, 57, 50, 10, 50, 53, 57, 55, 124, 53, 53, 50, 53, 51, 49, 55, 46, 55, 54, 10, 56, 54, 51, 49, 124, 53, 53, 49, 53, 57, 48, 57, 46, 51, 56, 10, 49, 54, 55, 50, 57, 124, 53, 53, 49, 50, 54, 54, 51, 46, 54, 53, 10, 49, 49, 56, 54, 49, 124, 53, 53, 49, 49, 55, 56, 53, 46, 57, 51, 10, 49, 54, 56, 53, 51, 124, 53, 53, 49, 49, 54, 56, 57, 46, 57, 49, 10, 54, 51, 52, 49, 124, 53, 53, 48, 50, 55, 57, 48, 46, 48, 56, 10, 49, 51, 49, 50, 124, 53, 52, 57, 54, 54, 52, 57, 46, 52, 48, 10, 53, 53, 54, 54, 124, 53, 52, 57, 53, 56, 56, 53, 46, 56, 55, 10, 49, 50, 53, 49, 57, 124, 53, 52, 57, 48, 54, 52, 57, 46, 57, 55, 10, 49, 57, 48, 51, 50, 124, 53, 52, 56, 56, 49, 48, 53, 46, 48, 50, 10, 56, 50, 51, 49, 124, 53, 52, 55, 57, 51, 49, 50, 46, 53, 48, 10, 51, 48, 50, 54, 124, 53, 52, 54, 54, 55, 51, 50, 46, 51, 50, 10, 54, 51, 56, 56, 124, 53, 52, 54, 54, 49, 54, 56, 46, 56, 48, 10, 49, 53, 51, 52, 57, 124, 53, 52, 54, 52, 53, 55, 49, 46, 53, 50, 10, 49, 56, 57, 56, 53, 124, 53, 52, 54, 51, 56, 57, 55, 46, 49, 51, 10, 49, 57, 56, 52, 56, 124, 53, 52, 53, 52, 50, 54, 54, 46, 52, 48, 10, 49, 55, 51, 55, 56, 124, 53, 52, 53, 51, 50, 56, 52, 46, 55, 52, 10, 52, 48, 48, 48, 124, 53, 52, 52, 56, 54, 57, 48, 46, 51, 57, 10, 51, 55, 49, 48, 124, 53, 52, 52, 53, 56, 50, 50, 46, 53, 51, 10, 49, 51, 49, 56, 49, 124, 53, 52, 51, 57, 55, 55, 52, 46, 48, 54, 10, 54, 52, 50, 48, 124, 53, 52, 51, 56, 51, 50, 53, 46, 51, 50, 10, 51, 54, 52, 52, 124, 53, 52, 51, 55, 55, 55, 50, 46, 49, 52, 10, 49, 49, 49, 55, 124, 53, 52, 51, 55, 48, 50, 52, 46, 57, 55, 10, 49, 51, 48, 50, 55, 124, 53, 52, 51, 54, 57, 54, 56, 46, 52, 54, 10, 49, 50, 56, 56, 52, 124, 53, 52, 51, 50, 54, 51, 50, 46, 51, 52, 10, 49, 50, 55, 56, 49, 124, 53, 52, 50, 57, 49, 54, 49, 46, 48, 56, 10, 49, 48, 48, 56, 52, 124, 53, 52, 50, 56, 50, 51, 49, 46, 54, 50, 10, 53, 54, 52, 48, 124, 53, 52, 50, 51, 51, 49, 56, 46, 53, 56, 10, 49, 54, 50, 48, 56, 124, 53, 52, 50, 50, 57, 48, 49, 46, 52, 48, 10, 55, 53, 51, 124, 53, 52, 49, 54, 56, 57, 57, 46, 55, 52, 10, 52, 49, 50, 48, 124, 53, 52, 49, 51, 56, 50, 50, 46, 52, 54, 10, 49, 50, 51, 52, 56, 124, 53, 52, 49, 50, 48, 54, 49, 46, 55, 49, 10, 49, 53, 56, 54, 124, 53, 52, 49, 49, 49, 57, 56, 46, 53, 53, 10, 50, 53, 48, 51, 124, 53, 52, 49, 49, 49, 50, 53, 46, 56, 48, 10, 49, 51, 56, 49, 124, 53, 51, 57, 55, 55, 57, 48, 46, 49, 48, 10, 49, 57, 54, 55, 51, 124, 53, 51, 57, 55, 55, 52, 54, 46, 55, 55, 10, 49, 57, 51, 56, 57, 124, 53, 51, 57, 52, 52, 50, 54, 46, 52, 48, 10, 49, 53, 53, 51, 50, 124, 53, 51, 56, 54, 51, 54, 49, 46, 51, 56, 10, 51, 53, 54, 50, 124, 53, 51, 56, 48, 51, 51, 53, 46, 48, 56, 10, 49, 57, 49, 49, 52, 124, 53, 51, 55, 53, 49, 51, 51, 46, 48, 48, 10, 51, 50, 48, 52, 124, 53, 51, 55, 50, 50, 49, 53, 46, 52, 54, 10, 54, 54, 53, 51, 124, 53, 51, 54, 53, 49, 55, 56, 46, 48, 48, 10, 51, 53, 53, 51, 124, 53, 51, 54, 51, 54, 57, 48, 46, 50, 57, 10, 49, 50, 54, 56, 55, 124, 53, 51, 54, 49, 54, 56, 50, 46, 49, 50, 10, 51, 50, 55, 57, 124, 53, 51, 53, 55, 53, 48, 53, 46, 54, 53, 10, 57, 56, 52, 48, 124, 53, 51, 53, 48, 49, 49, 50, 46, 49, 56, 10, 56, 50, 53, 56, 124, 53, 51, 52, 55, 48, 54, 52, 46, 54, 55, 10, 49, 49, 51, 56, 55, 124, 53, 51, 52, 53, 50, 56, 52, 46, 48, 48, 10, 49, 53, 50, 49, 48, 124, 53, 51, 52, 49, 49, 49, 55, 46, 57, 50, 10, 49, 53, 48, 57, 50, 124, 53, 51, 52, 48, 56, 57, 54, 46, 56, 48, 10, 54, 48, 53, 50, 124, 53, 51, 51, 57, 55, 54, 50, 46, 49, 56, 10, 49, 52, 48, 52, 51, 124, 53, 51, 51, 57, 53, 56, 55, 46, 54, 56, 10, 54, 50, 56, 52, 124, 53, 51, 51, 54, 49, 53, 51, 46, 48, 48, 10, 54, 50, 57, 55, 124, 53, 51, 51, 50, 51, 53, 55, 46, 55, 52, 10, 49, 54, 50, 53, 52, 124, 53, 51, 50, 54, 54, 48, 55, 46, 56, 51, 10, 49, 56, 52, 51, 54, 124, 53, 51, 50, 54, 49, 57, 56, 46, 53, 48, 10, 49, 52, 52, 51, 54, 124, 53, 51, 50, 53, 53, 49, 55, 46, 49, 52, 10, 49, 48, 51, 54, 56, 124, 53, 51, 49, 57, 57, 56, 51, 46, 48, 56, 10, 54, 51, 52, 57, 124, 53, 51, 49, 55, 57, 52, 51, 46, 52, 48, 10, 49, 57, 57, 56, 52, 124, 53, 51, 49, 55, 54, 50, 48, 46, 48, 48, 10, 49, 57, 48, 56, 48, 124, 53, 51, 49, 48, 54, 55, 56, 46, 54, 48, 10, 49, 52, 48, 51, 124, 53, 51, 48, 54, 55, 55, 49, 46, 51, 50, 10, 53, 57, 57, 53, 124, 53, 51, 48, 53, 48, 53, 54, 46, 49, 50, 10, 49, 51, 50, 49, 52, 124, 53, 50, 57, 57, 52, 50, 48, 46, 52, 53, 10, 49, 57, 50, 57, 51, 124, 53, 50, 57, 55, 48, 53, 52, 46, 52, 48, 10, 55, 49, 51, 48, 124, 53, 50, 56, 57, 55, 54, 49, 46, 52, 56, 10, 57, 56, 48, 57, 124, 53, 50, 56, 54, 55, 56, 52, 46, 56, 48, 10, 57, 50, 55, 51, 124, 53, 50, 55, 55, 57, 50, 52, 46, 55, 55, 10, 49, 54, 55, 56, 54, 124, 53, 50, 54, 48, 48, 51, 53, 46, 48, 48, 10, 49, 49, 48, 51, 50, 124, 53, 50, 53, 54, 51, 53, 52, 46, 51, 53, 10, 49, 55, 55, 49, 57, 124, 53, 50, 52, 54, 51, 50, 50, 46, 50, 48, 10, 51, 52, 48, 48, 124, 53, 50, 52, 52, 50, 48, 51, 46, 54, 56, 10, 56, 50, 55, 56, 124, 53, 50, 52, 51, 55, 49, 56, 46, 52, 56, 10, 55, 56, 55, 51, 124, 53, 50, 52, 49, 49, 54, 56, 46, 56, 48, 10, 57, 51, 53, 55, 124, 53, 50, 51, 57, 54, 57, 53, 46, 55, 55, 10, 50, 50, 51, 57, 124, 53, 50, 51, 53, 55, 54, 55, 46, 56, 51, 10, 49, 56, 54, 57, 53, 124, 53, 50, 50, 51, 57, 54, 48, 46, 51, 53, 10, 49, 57, 50, 55, 49, 124, 53, 50, 49, 54, 52, 57, 56, 46, 50, 57, 10, 52, 53, 54, 51, 124, 53, 50, 49, 52, 54, 55, 51, 46, 55, 48, 10, 49, 56, 57, 54, 124, 53, 50, 49, 48, 54, 57, 57, 46, 55, 57, 10, 49, 53, 55, 53, 53, 124, 53, 50, 49, 48, 52, 56, 49, 46, 50, 52, 10, 49, 55, 54, 50, 56, 124, 53, 50, 48, 57, 56, 56, 50, 46, 51, 55, 10, 53, 55, 52, 55, 124, 53, 50, 48, 54, 56, 57, 50, 46, 50, 52, 10, 49, 56, 48, 53, 55, 124, 53, 50, 48, 52, 57, 48, 55, 46, 52, 48, 10, 53, 48, 55, 53, 124, 53, 50, 48, 52, 52, 49, 50, 46, 56, 49, 10, 53, 51, 50, 53, 124, 53, 49, 57, 48, 49, 54, 50, 46, 55, 53, 10, 49, 55, 54, 55, 53, 124, 53, 49, 56, 51, 49, 51, 53, 46, 51, 54, 10, 49, 56, 56, 49, 56, 124, 53, 49, 56, 49, 50, 57, 53, 46, 51, 48, 10, 49, 49, 48, 54, 52, 124, 53, 49, 56, 48, 54, 54, 55, 46, 53, 55, 10, 49, 50, 53, 55, 56, 124, 53, 49, 55, 55, 50, 50, 50, 46, 51, 51, 10, 51, 55, 50, 53, 124, 53, 49, 54, 57, 49, 56, 51, 46, 55, 53, 10, 49, 49, 49, 49, 50, 124, 53, 49, 54, 49, 53, 52, 54, 46, 48, 48, 10, 52, 55, 52, 57, 124, 53, 49, 54, 49, 52, 57, 57, 46, 52, 52, 10, 55, 54, 51, 50, 124, 53, 49, 53, 57, 49, 56, 48, 46, 53, 48, 10, 49, 51, 49, 49, 57, 124, 53, 49, 53, 49, 54, 54, 53, 46, 53, 49, 10, 53, 54, 53, 51, 124, 53, 49, 52, 48, 51, 50, 52, 46, 54, 52, 10, 49, 54, 49, 51, 52, 124, 53, 49, 51, 55, 52, 56, 50, 46, 53, 49, 10, 53, 54, 55, 49, 124, 53, 49, 51, 54, 56, 49, 53, 46, 53, 53, 10, 49, 56, 51, 52, 56, 124, 53, 49, 51, 50, 57, 56, 49, 46, 48, 55, 10, 53, 54, 50, 124, 53, 49, 51, 50, 52, 56, 55, 46, 50, 53, 10, 50, 53, 54, 50, 124, 53, 49, 50, 54, 55, 54, 51, 46, 56, 51, 10, 49, 48, 51, 48, 52, 124, 53, 49, 50, 53, 49, 56, 48, 46, 48, 48, 10, 55, 54, 50, 50, 124, 53, 49, 50, 48, 55, 49, 57, 46, 57, 56, 10, 49, 50, 55, 53, 53, 124, 53, 49, 49, 56, 50, 49, 51, 46, 57, 50, 10, 49, 56, 49, 52, 124, 53, 49, 48, 48, 55, 48, 53, 46, 53, 56, 10, 49, 49, 50, 54, 57, 124, 53, 48, 57, 54, 54, 55, 49, 46, 51, 51, 10, 50, 57, 54, 52, 124, 53, 48, 57, 53, 50, 53, 51, 46, 55, 50, 10, 49, 54, 49, 54, 124, 53, 48, 57, 49, 56, 51, 52, 46, 48, 48, 10, 57, 50, 57, 52, 124, 53, 48, 57, 48, 55, 53, 51, 46, 53, 51, 10, 49, 54, 55, 57, 51, 124, 53, 48, 56, 53, 51, 51, 48, 46, 53, 52, 10, 52, 57, 57, 57, 124, 53, 48, 56, 49, 54, 53, 49, 46, 55, 53, 10, 49, 55, 50, 48, 57, 124, 53, 48, 55, 57, 48, 50, 57, 46, 50, 56, 10, 55, 49, 53, 49, 124, 53, 48, 55, 56, 57, 51, 55, 46, 54, 48, 10, 49, 53, 53, 50, 50, 124, 53, 48, 55, 50, 52, 54, 57, 46, 54, 48, 10, 51, 48, 53, 54, 124, 53, 48, 55, 50, 51, 50, 57, 46, 53, 53, 10, 55, 54, 49, 50, 124, 53, 48, 54, 56, 51, 50, 50, 46, 56, 55, 10, 49, 56, 52, 53, 51, 124, 53, 48, 54, 51, 56, 57, 50, 46, 57, 50, 10, 49, 56, 51, 50, 52, 124, 53, 48, 53, 56, 57, 48, 49, 46, 50, 50, 10, 49, 50, 50, 54, 54, 124, 53, 48, 53, 56, 49, 56, 54, 46, 55, 53, 10, 49, 57, 51, 57, 52, 124, 53, 48, 53, 54, 50, 51, 53, 46, 55, 51, 10, 49, 55, 49, 51, 124, 53, 48, 53, 52, 57, 54, 56, 46, 48, 53, 10, 49, 53, 54, 56, 49, 124, 53, 48, 53, 49, 53, 54, 57, 46, 54, 51, 10, 56, 50, 55, 52, 124, 53, 48, 52, 51, 51, 50, 56, 46, 48, 48, 10, 49, 56, 49, 54, 48, 124, 53, 48, 52, 51, 48, 55, 52, 46, 56, 51, 10, 49, 56, 50, 53, 51, 124, 53, 48, 52, 49, 53, 55, 50, 46, 48, 48, 10, 49, 49, 56, 52, 48, 124, 53, 48, 52, 48, 53, 57, 48, 46, 48, 52, 10, 49, 53, 51, 50, 124, 53, 48, 51, 51, 49, 55, 49, 46, 48, 48, 10, 53, 56, 52, 124, 53, 48, 51, 49, 54, 48, 50, 46, 54, 52, 10, 49, 50, 51, 56, 50, 124, 53, 48, 50, 56, 57, 48, 49, 46, 48, 48, 10, 49, 52, 56, 49, 52, 124, 53, 48, 50, 50, 50, 48, 48, 46, 48, 55, 10, 49, 57, 48, 53, 56, 124, 53, 48, 49, 57, 48, 48, 49, 46, 57, 50, 10, 52, 52, 56, 55, 124, 53, 48, 49, 54, 54, 52, 48, 46, 56, 54, 10, 56, 52, 56, 50, 124, 53, 48, 49, 53, 52, 52, 52, 46, 50, 53, 10, 49, 56, 52, 55, 54, 124, 53, 48, 49, 49, 49, 51, 54, 46, 51, 54, 10, 49, 50, 51, 51, 53, 124, 53, 48, 48, 51, 53, 56, 49, 46, 52, 48, 10, 52, 52, 53, 53, 124, 52, 57, 57, 55, 57, 51, 51, 46, 51, 49, 10, 49, 52, 51, 53, 53, 124, 52, 57, 57, 50, 56, 50, 50, 46, 57, 50, 10, 49, 53, 50, 53, 51, 124, 52, 57, 57, 50, 54, 52, 50, 46, 50, 48, 10, 49, 52, 48, 54, 57, 124, 52, 57, 56, 51, 50, 52, 52, 46, 50, 48, 10, 49, 55, 56, 52, 51, 124, 52, 57, 55, 55, 50, 57, 52, 46, 51, 55, 10, 57, 51, 56, 57, 124, 52, 57, 55, 53, 56, 56, 53, 46, 56, 51, 10, 49, 52, 52, 51, 53, 124, 52, 57, 55, 49, 52, 52, 50, 46, 49, 57, 10, 49, 51, 50, 53, 52, 124, 52, 57, 53, 57, 52, 56, 49, 46, 52, 53, 10, 57, 55, 55, 51, 124, 52, 57, 53, 53, 56, 56, 55, 46, 56, 48, 10, 55, 54, 49, 53, 124, 52, 57, 53, 50, 52, 50, 49, 46, 53, 52, 10, 54, 52, 55, 54, 124, 52, 57, 52, 55, 50, 53, 48, 46, 48, 53, 10, 57, 50, 53, 51, 124, 52, 57, 52, 53, 49, 53, 57, 46, 55, 48, 10, 49, 52, 57, 51, 50, 124, 52, 57, 51, 52, 51, 57, 53, 46, 52, 56, 10, 49, 51, 50, 53, 51, 124, 52, 57, 51, 50, 56, 54, 55, 46, 52, 53, 10, 49, 57, 51, 50, 50, 124, 52, 57, 51, 49, 53, 50, 53, 46, 55, 56, 10, 49, 54, 57, 52, 53, 124, 52, 57, 51, 49, 52, 52, 48, 46, 54, 49, 10, 55, 51, 49, 124, 52, 57, 51, 48, 49, 57, 49, 46, 57, 51, 10, 54, 53, 52, 48, 124, 52, 57, 50, 53, 49, 49, 52, 46, 53, 49, 10, 53, 49, 52, 56, 124, 52, 57, 50, 51, 48, 52, 56, 46, 48, 48, 10, 49, 57, 51, 52, 124, 52, 57, 50, 49, 49, 57, 54, 46, 57, 48, 10, 49, 53, 52, 48, 50, 124, 52, 57, 50, 48, 56, 52, 48, 46, 55, 50, 10, 49, 55, 57, 49, 52, 124, 52, 57, 49, 57, 54, 48, 55, 46, 48, 52, 10, 53, 52, 49, 54, 124, 52, 57, 49, 54, 48, 52, 49, 46, 57, 50, 10, 49, 54, 55, 51, 52, 124, 52, 57, 49, 52, 50, 48, 53, 46, 50, 55, 10, 49, 52, 57, 54, 55, 124, 52, 57, 48, 48, 50, 54, 50, 46, 48, 56, 10, 56, 55, 48, 54, 124, 52, 56, 57, 52, 53, 57, 53, 46, 53, 56, 10, 49, 51, 54, 124, 52, 56, 57, 49, 57, 54, 48, 46, 57, 50, 10, 49, 57, 52, 57, 52, 124, 52, 56, 56, 54, 48, 50, 56, 46, 51, 48, 10, 56, 55, 51, 55, 124, 52, 56, 56, 48, 54, 52, 48, 46, 52, 52, 10, 55, 54, 53, 51, 124, 52, 56, 55, 57, 52, 50, 51, 46, 54, 52, 10, 52, 49, 52, 57, 124, 52, 56, 55, 53, 55, 56, 50, 46, 52, 48, 10, 55, 56, 57, 48, 124, 52, 56, 55, 50, 52, 50, 52, 46, 52, 48, 10, 49, 49, 49, 52, 50, 124, 52, 56, 55, 49, 52, 49, 53, 46, 52, 50, 10, 49, 48, 51, 56, 54, 124, 52, 56, 54, 51, 54, 50, 51, 46, 53, 48, 10, 56, 54, 48, 51, 124, 52, 56, 54, 49, 56, 49, 52, 46, 54, 49, 10, 50, 54, 56, 48, 124, 52, 56, 54, 49, 50, 50, 51, 46, 55, 52, 10, 52, 56, 57, 49, 124, 52, 56, 53, 56, 49, 48, 51, 46, 56, 56, 10, 49, 57, 50, 51, 54, 124, 52, 56, 53, 53, 48, 57, 55, 46, 54, 57, 10, 49, 52, 50, 53, 49, 124, 52, 56, 53, 52, 55, 51, 57, 46, 56, 54, 10, 49, 56, 56, 57, 53, 124, 52, 56, 53, 51, 51, 54, 53, 46, 49, 48, 10, 49, 55, 49, 51, 52, 124, 52, 56, 53, 50, 48, 52, 49, 46, 48, 52, 10, 52, 57, 51, 50, 124, 52, 56, 52, 51, 55, 48, 49, 46, 52, 53, 10, 49, 48, 48, 51, 51, 124, 52, 56, 52, 49, 54, 52, 55, 46, 55, 50, 10, 49, 51, 56, 51, 124, 52, 56, 51, 57, 49, 52, 52, 46, 51, 49, 10, 49, 56, 55, 50, 49, 124, 52, 56, 51, 55, 57, 56, 51, 46, 51, 54, 10, 56, 54, 49, 56, 124, 52, 56, 51, 51, 49, 50, 53, 46, 52, 50, 10, 49, 55, 51, 56, 54, 124, 52, 56, 51, 49, 53, 52, 53, 46, 56, 52, 10, 51, 55, 57, 48, 124, 52, 56, 51, 48, 50, 56, 50, 46, 51, 54, 10, 49, 48, 52, 51, 124, 52, 56, 50, 53, 57, 50, 49, 46, 51, 49, 10, 49, 50, 52, 51, 52, 124, 52, 56, 50, 50, 53, 57, 55, 46, 55, 56, 10, 49, 56, 51, 56, 53, 124, 52, 56, 49, 57, 54, 52, 51, 46, 52, 48, 10, 54, 48, 52, 54, 124, 52, 56, 49, 55, 52, 54, 48, 46, 48, 54, 10, 53, 56, 50, 49, 124, 52, 56, 49, 52, 52, 50, 51, 46, 52, 53, 10, 49, 48, 56, 51, 54, 124, 52, 56, 49, 52, 51, 48, 51, 46, 50, 52, 10, 54, 56, 52, 56, 124, 52, 56, 49, 51, 57, 53, 52, 46, 48, 56, 10, 54, 56, 56, 48, 124, 52, 56, 48, 52, 54, 48, 48, 46, 51, 53, 10, 49, 49, 50, 52, 57, 124, 52, 56, 48, 48, 49, 49, 54, 46, 56, 50, 10, 49, 49, 57, 55, 48, 124, 52, 55, 57, 57, 55, 51, 57, 46, 54, 54, 10, 49, 52, 50, 53, 51, 124, 52, 55, 57, 54, 53, 50, 49, 46, 50, 57, 10, 55, 55, 56, 50, 124, 52, 55, 57, 51, 50, 50, 55, 46, 49, 51, 10, 55, 53, 124, 52, 55, 57, 48, 48, 52, 50, 46, 56, 56, 10, 55, 48, 55, 54, 124, 52, 55, 56, 57, 51, 52, 55, 46, 51, 52, 10, 57, 53, 54, 54, 124, 52, 55, 56, 50, 53, 51, 49, 46, 56, 48, 10, 50, 49, 51, 55, 124, 52, 55, 54, 55, 57, 51, 49, 46, 55, 52, 10, 50, 51, 51, 54, 124, 52, 55, 54, 51, 56, 55, 48, 46, 55, 57, 10, 49, 53, 51, 54, 50, 124, 52, 55, 53, 57, 48, 52, 51, 46, 51, 56, 10, 51, 50, 56, 52, 124, 52, 55, 53, 53, 48, 52, 56, 46, 55, 54, 10, 49, 50, 57, 54, 52, 124, 52, 55, 53, 51, 54, 50, 55, 46, 52, 56, 10, 49, 55, 56, 49, 124, 52, 55, 53, 50, 56, 51, 53, 46, 50, 48, 10, 53, 52, 53, 52, 124, 52, 55, 52, 56, 51, 52, 50, 46, 57, 56, 10, 49, 50, 53, 57, 55, 124, 52, 55, 52, 50, 48, 55, 55, 46, 56, 52, 10, 49, 57, 49, 50, 48, 124, 52, 55, 51, 51, 52, 53, 57, 46, 57, 54, 10, 49, 52, 56, 56, 52, 124, 52, 55, 51, 49, 52, 57, 57, 46, 52, 52, 10, 56, 50, 53, 124, 52, 55, 51, 48, 55, 50, 48, 46, 50, 56, 10, 49, 52, 54, 56, 51, 124, 52, 55, 51, 48, 52, 56, 50, 46, 51, 50, 10, 53, 51, 54, 49, 124, 52, 55, 50, 54, 49, 49, 51, 46, 48, 48, 10, 49, 50, 49, 55, 57, 124, 52, 55, 50, 53, 48, 49, 56, 46, 49, 48, 10, 49, 52, 54, 49, 124, 52, 55, 49, 48, 57, 53, 52, 46, 54, 57, 10, 57, 56, 57, 48, 124, 52, 55, 48, 57, 54, 53, 56, 46, 52, 48, 10, 49, 51, 51, 54, 57, 124, 52, 55, 48, 53, 48, 56, 53, 46, 51, 57, 10, 49, 49, 54, 49, 50, 124, 52, 55, 48, 49, 54, 50, 55, 46, 57, 57, 10, 51, 48, 57, 54, 124, 52, 54, 57, 57, 52, 49, 52, 46, 52, 48, 10, 49, 48, 51, 56, 51, 124, 52, 54, 57, 55, 56, 54, 54, 46, 52, 55, 10, 49, 49, 50, 57, 51, 124, 52, 54, 57, 55, 51, 51, 54, 46, 48, 54, 10, 51, 51, 56, 51, 124, 52, 54, 57, 53, 56, 50, 53, 46, 50, 48, 10, 54, 50, 51, 49, 124, 52, 54, 57, 52, 51, 56, 49, 46, 55, 50, 10, 55, 51, 57, 54, 124, 52, 54, 57, 49, 51, 49, 57, 46, 48, 54, 10, 49, 55, 56, 50, 55, 124, 52, 54, 56, 56, 55, 57, 55, 46, 52, 52, 10, 49, 53, 56, 53, 54, 124, 52, 54, 56, 51, 51, 54, 56, 46, 50, 49, 10, 56, 50, 53, 51, 124, 52, 54, 55, 56, 53, 54, 48, 46, 56, 54, 10, 49, 50, 51, 50, 55, 124, 52, 54, 55, 55, 57, 56, 52, 46, 55, 52, 10, 52, 51, 57, 53, 124, 52, 54, 55, 54, 56, 50, 57, 46, 56, 50, 10, 52, 50, 51, 50, 124, 52, 54, 55, 54, 54, 52, 54, 46, 52, 48, 10, 49, 52, 50, 54, 48, 124, 52, 54, 55, 48, 53, 50, 50, 46, 56, 48, 10, 49, 53, 50, 56, 56, 124, 52, 54, 54, 57, 50, 55, 51, 46, 57, 57, 10, 49, 55, 53, 50, 54, 124, 52, 54, 54, 56, 53, 52, 53, 46, 54, 52, 10, 57, 56, 56, 52, 124, 52, 54, 54, 50, 54, 57, 51, 46, 56, 52, 10, 50, 49, 49, 56, 124, 52, 54, 54, 48, 51, 53, 50, 46, 55, 56, 10, 52, 53, 50, 52, 124, 52, 54, 53, 51, 57, 53, 54, 46, 54, 48, 10, 49, 57, 48, 57, 48, 124, 52, 54, 53, 48, 56, 55, 50, 46, 57, 52, 10, 51, 57, 50, 56, 124, 52, 54, 52, 57, 51, 53, 57, 46, 52, 52, 10, 49, 52, 51, 50, 53, 124, 52, 54, 52, 55, 55, 54, 50, 46, 49, 55, 10, 49, 53, 52, 55, 54, 124, 52, 54, 52, 51, 52, 54, 57, 46, 48, 52, 10, 52, 49, 55, 57, 124, 52, 54, 51, 57, 57, 51, 49, 46, 55, 54, 10, 49, 52, 52, 48, 56, 124, 52, 54, 51, 57, 54, 51, 49, 46, 50, 56, 10, 49, 57, 52, 50, 52, 124, 52, 54, 51, 52, 56, 49, 55, 46, 52, 52, 10, 51, 51, 51, 52, 124, 52, 54, 51, 51, 49, 48, 50, 46, 53, 48, 10, 57, 52, 55, 55, 124, 52, 54, 50, 56, 48, 55, 51, 46, 53, 49, 10, 49, 49, 56, 48, 51, 124, 52, 54, 50, 53, 51, 57, 54, 46, 56, 48, 10, 49, 52, 56, 48, 53, 124, 52, 54, 49, 56, 52, 53, 50, 46, 49, 56, 10, 52, 54, 51, 124, 52, 54, 49, 54, 51, 48, 55, 46, 50, 56, 10, 49, 54, 54, 50, 56, 124, 52, 54, 48, 55, 52, 57, 48, 46, 57, 54, 10, 51, 49, 49, 54, 124, 52, 54, 48, 52, 52, 54, 51, 46, 49, 48, 10, 49, 57, 57, 54, 50, 124, 52, 54, 48, 50, 57, 52, 57, 46, 52, 55, 10, 49, 50, 56, 53, 57, 124, 52, 54, 48, 50, 56, 55, 48, 46, 53, 53, 10, 49, 50, 48, 54, 51, 124, 52, 54, 48, 48, 55, 48, 56, 46, 52, 53, 10, 53, 54, 52, 56, 124, 52, 53, 57, 50, 50, 55, 51, 46, 50, 53, 10, 56, 53, 53, 54, 124, 52, 53, 57, 48, 55, 50, 54, 46, 56, 54, 10, 49, 53, 50, 56, 49, 124, 52, 53, 56, 57, 52, 50, 53, 46, 52, 49, 10, 57, 52, 49, 52, 124, 52, 53, 56, 55, 52, 50, 54, 46, 57, 48, 10, 49, 51, 57, 53, 49, 124, 52, 53, 56, 54, 50, 56, 49, 46, 50, 53, 10, 49, 57, 51, 50, 56, 124, 52, 53, 56, 50, 54, 50, 52, 46, 56, 50, 10, 49, 53, 57, 54, 51, 124, 52, 53, 55, 57, 55, 48, 53, 46, 53, 48, 10, 49, 48, 55, 55, 51, 124, 52, 53, 55, 51, 50, 55, 54, 46, 50, 48, 10, 49, 52, 49, 55, 57, 124, 52, 53, 54, 56, 56, 49, 54, 46, 48, 48, 10, 49, 56, 57, 53, 124, 52, 53, 54, 51, 57, 56, 56, 46, 49, 54, 10, 54, 52, 48, 56, 124, 52, 53, 54, 49, 52, 57, 54, 46, 51, 57, 10, 53, 57, 53, 56, 124, 52, 53, 53, 52, 48, 48, 48, 46, 48, 48, 10, 51, 54, 53, 51, 124, 52, 53, 52, 56, 49, 51, 52, 46, 52, 48, 10, 49, 49, 50, 49, 56, 124, 52, 53, 52, 54, 50, 51, 55, 46, 57, 50, 10, 49, 57, 51, 50, 55, 124, 52, 53, 52, 51, 57, 56, 55, 46, 55, 55, 10, 57, 53, 55, 50, 124, 52, 53, 51, 53, 57, 52, 49, 46, 49, 54, 10, 49, 52, 53, 53, 54, 124, 52, 53, 51, 49, 52, 54, 52, 46, 55, 53, 10, 50, 52, 55, 53, 124, 52, 53, 50, 57, 55, 54, 49, 46, 53, 48, 10, 57, 54, 51, 49, 124, 52, 53, 50, 57, 50, 54, 49, 46, 53, 54, 10, 49, 57, 48, 49, 124, 52, 53, 50, 56, 53, 57, 50, 46, 53, 53, 10, 56, 54, 124, 52, 53, 50, 56, 52, 55, 53, 46, 51, 56, 10, 57, 53, 56, 54, 124, 52, 53, 50, 55, 49, 52, 54, 46, 50, 50, 10, 49, 55, 51, 54, 49, 124, 52, 53, 49, 57, 48, 57, 56, 46, 56, 55, 10, 56, 49, 49, 50, 124, 52, 53, 49, 52, 57, 52, 57, 46, 52, 53, 10, 49, 51, 52, 54, 56, 124, 52, 52, 57, 57, 55, 50, 56, 46, 50, 48, 10, 49, 56, 50, 51, 57, 124, 52, 52, 57, 55, 54, 51, 51, 46, 54, 52, 10, 49, 48, 50, 49, 53, 124, 52, 52, 57, 52, 53, 53, 51, 46, 54, 48, 10, 54, 50, 49, 49, 124, 52, 52, 57, 50, 50, 54, 52, 46, 57, 54, 10, 56, 51, 54, 124, 52, 52, 57, 48, 57, 52, 53, 46, 49, 48, 10, 56, 57, 53, 124, 52, 52, 56, 57, 49, 52, 49, 46, 53, 48, 10, 49, 57, 53, 52, 50, 124, 52, 52, 56, 56, 51, 57, 51, 46, 55, 53, 10, 52, 51, 50, 50, 124, 52, 52, 56, 55, 56, 56, 52, 46, 50, 51, 10, 50, 49, 49, 54, 124, 52, 52, 56, 54, 57, 52, 52, 46, 54, 53, 10, 53, 53, 51, 124, 52, 52, 56, 54, 48, 55, 53, 46, 52, 56, 10, 50, 53, 49, 53, 124, 52, 52, 56, 53, 49, 56, 56, 46, 50, 54, 10, 49, 54, 50, 56, 54, 124, 52, 52, 56, 49, 52, 55, 48, 46, 52, 55, 10, 49, 50, 50, 55, 49, 124, 52, 52, 55, 56, 50, 50, 52, 46, 57, 53, 10, 49, 54, 53, 55, 48, 124, 52, 52, 54, 53, 56, 49, 56, 46, 48, 48, 10, 55, 57, 57, 53, 124, 52, 52, 53, 55, 53, 55, 52, 46, 54, 54, 10, 49, 56, 51, 57, 54, 124, 52, 52, 53, 55, 50, 50, 57, 46, 54, 48, 10, 49, 54, 51, 51, 49, 124, 52, 52, 53, 53, 55, 51, 53, 46, 52, 56, 10, 49, 56, 49, 53, 55, 124, 52, 52, 53, 50, 49, 57, 54, 46, 54, 51, 10, 53, 50, 55, 49, 124, 52, 52, 53, 50, 48, 52, 48, 46, 48, 49, 10, 49, 49, 54, 50, 50, 124, 52, 52, 53, 49, 50, 52, 52, 46, 56, 52, 10, 52, 48, 53, 50, 124, 52, 52, 52, 54, 51, 57, 55, 46, 51, 52, 10, 50, 56, 54, 52, 124, 52, 52, 52, 54, 48, 48, 56, 46, 51, 56, 10, 52, 57, 48, 124, 52, 52, 52, 50, 56, 57, 50, 46, 51, 48, 10, 49, 57, 56, 51, 55, 124, 52, 52, 51, 52, 49, 55, 50, 46, 51, 57, 10, 52, 49, 49, 52, 124, 52, 52, 51, 51, 54, 53, 55, 46, 56, 53, 10, 49, 49, 52, 51, 54, 124, 52, 52, 51, 51, 48, 55, 48, 46, 49, 53, 10, 54, 48, 56, 53, 124, 52, 52, 51, 49, 51, 48, 54, 46, 53, 55, 10, 57, 55, 51, 53, 124, 52, 52, 51, 48, 52, 52, 53, 46, 54, 48, 10, 49, 55, 56, 51, 52, 124, 52, 52, 49, 54, 50, 56, 54, 46, 51, 51, 10, 56, 49, 53, 55, 124, 52, 52, 49, 54, 49, 49, 54, 46, 54, 53, 10, 49, 56, 56, 52, 48, 124, 52, 52, 49, 52, 57, 50, 53, 46, 51, 50, 10, 49, 51, 53, 53, 51, 124, 52, 52, 49, 50, 50, 54, 49, 46, 55, 48, 10, 49, 50, 53, 54, 50, 124, 52, 52, 49, 49, 49, 56, 51, 46, 48, 52, 10, 49, 52, 48, 50, 53, 124, 52, 52, 48, 51, 52, 52, 50, 46, 49, 54, 10, 49, 55, 57, 54, 52, 124, 52, 52, 48, 48, 51, 54, 48, 46, 48, 57, 10, 54, 51, 54, 124, 52, 51, 57, 57, 56, 54, 51, 46, 56, 52, 10, 56, 51, 57, 48, 124, 52, 51, 56, 57, 48, 50, 52, 46, 51, 51, 10, 50, 51, 49, 124, 52, 51, 56, 55, 51, 57, 55, 46, 51, 48, 10, 57, 54, 57, 57, 124, 52, 51, 56, 53, 56, 57, 49, 46, 48, 50, 10, 49, 48, 54, 50, 50, 124, 52, 51, 56, 52, 48, 48, 53, 46, 51, 50, 10, 49, 52, 51, 54, 52, 124, 52, 51, 56, 51, 50, 51, 54, 46, 57, 48, 10, 49, 48, 53, 56, 48, 124, 52, 51, 56, 49, 53, 51, 51, 46, 50, 51, 10, 49, 48, 49, 50, 52, 124, 52, 51, 54, 57, 56, 48, 48, 46, 57, 54, 10, 49, 48, 52, 53, 49, 124, 52, 51, 54, 56, 56, 54, 55, 46, 53, 48, 10, 52, 54, 55, 51, 124, 52, 51, 54, 55, 49, 49, 51, 46, 52, 52, 10, 49, 49, 51, 53, 49, 124, 52, 51, 54, 50, 54, 49, 54, 46, 53, 48, 10, 52, 55, 55, 48, 124, 52, 51, 54, 50, 51, 57, 55, 46, 51, 50, 10, 49, 50, 57, 51, 50, 124, 52, 51, 54, 50, 48, 52, 50, 46, 54, 48, 10, 49, 48, 54, 48, 51, 124, 52, 51, 53, 55, 50, 49, 54, 46, 53, 48, 10, 49, 57, 55, 51, 51, 124, 52, 51, 52, 56, 57, 51, 49, 46, 55, 53, 10, 52, 50, 50, 50, 124, 52, 51, 52, 56, 56, 55, 49, 46, 57, 49, 10, 49, 55, 51, 49, 57, 124, 52, 51, 52, 55, 54, 56, 55, 46, 54, 57, 10, 51, 51, 55, 53, 124, 52, 51, 52, 54, 53, 50, 57, 46, 52, 56, 10, 49, 52, 57, 57, 53, 124, 52, 51, 51, 56, 50, 57, 53, 46, 54, 53, 10, 55, 54, 55, 53, 124, 52, 51, 51, 55, 52, 57, 57, 46, 54, 48, 10, 49, 53, 48, 52, 51, 124, 52, 51, 51, 51, 57, 50, 49, 46, 50, 48, 10, 52, 56, 51, 53, 124, 52, 51, 51, 50, 54, 52, 56, 46, 48, 48, 10, 52, 52, 48, 56, 124, 52, 51, 51, 50, 53, 56, 56, 46, 57, 48, 10, 53, 53, 53, 57, 124, 52, 51, 51, 48, 53, 55, 55, 46, 48, 57, 10, 55, 51, 55, 54, 124, 52, 51, 50, 56, 57, 51, 54, 46, 53, 52, 10, 49, 56, 48, 54, 49, 124, 52, 51, 50, 56, 55, 57, 51, 46, 57, 56, 10, 50, 55, 52, 57, 124, 52, 51, 50, 56, 54, 55, 49, 46, 53, 51, 10, 54, 54, 50, 56, 124, 52, 51, 50, 56, 53, 48, 49, 46, 56, 56, 10, 53, 56, 56, 56, 124, 52, 51, 50, 51, 48, 52, 57, 46, 55, 50, 10, 49, 56, 56, 55, 50, 124, 52, 51, 50, 50, 53, 57, 53, 46, 54, 50, 10, 53, 52, 55, 54, 124, 52, 51, 49, 57, 54, 52, 50, 46, 53, 56, 10, 49, 55, 53, 53, 124, 52, 51, 49, 56, 57, 51, 53, 46, 54, 51, 10, 49, 48, 54, 50, 51, 124, 52, 51, 49, 53, 56, 50, 50, 46, 53, 54, 10, 49, 56, 55, 55, 53, 124, 52, 51, 49, 52, 54, 55, 55, 46, 54, 52, 10, 51, 53, 55, 48, 124, 52, 51, 49, 50, 54, 57, 55, 46, 56, 55, 10, 49, 49, 49, 52, 55, 124, 52, 51, 49, 48, 55, 52, 48, 46, 53, 55, 10, 54, 48, 55, 49, 124, 52, 51, 48, 55, 54, 49, 50, 46, 52, 48, 10, 49, 48, 56, 48, 55, 124, 52, 51, 48, 54, 48, 48, 54, 46, 48, 48, 10, 57, 53, 53, 48, 124, 52, 50, 57, 57, 52, 55, 56, 46, 53, 54, 10, 54, 53, 55, 124, 52, 50, 57, 54, 55, 57, 52, 46, 49, 57, 10, 49, 57, 54, 54, 57, 124, 52, 50, 57, 52, 54, 52, 48, 46, 57, 48, 10, 56, 53, 51, 50, 124, 52, 50, 57, 48, 54, 53, 49, 46, 54, 48, 10, 49, 51, 52, 54, 57, 124, 52, 50, 56, 49, 55, 49, 53, 46, 54, 50, 10, 56, 56, 48, 57, 124, 52, 50, 56, 48, 55, 55, 56, 46, 56, 48, 10, 49, 49, 51, 48, 49, 124, 52, 50, 55, 54, 56, 52, 55, 46, 57, 53, 10, 54, 49, 52, 55, 124, 52, 50, 54, 54, 56, 55, 57, 46, 57, 50, 10, 50, 54, 49, 50, 124, 52, 50, 54, 53, 57, 54, 50, 46, 51, 53, 10, 49, 53, 54, 57, 57, 124, 52, 50, 53, 54, 49, 49, 56, 46, 55, 50, 10, 49, 50, 51, 48, 48, 124, 52, 50, 53, 52, 52, 48, 57, 46, 49, 49, 10, 51, 52, 57, 52, 124, 52, 50, 53, 48, 56, 49, 48, 46, 54, 48, 10, 49, 49, 48, 52, 48, 124, 52, 50, 53, 48, 48, 51, 48, 46, 50, 48, 10, 54, 49, 57, 48, 124, 52, 50, 52, 52, 48, 52, 54, 46, 56, 48, 10, 49, 55, 54, 49, 54, 124, 52, 50, 51, 57, 57, 51, 55, 46, 53, 48, 10, 55, 50, 55, 49, 124, 52, 50, 51, 52, 52, 48, 55, 46, 48, 48, 10, 49, 52, 48, 52, 56, 124, 52, 50, 50, 54, 57, 55, 55, 46, 52, 52, 10, 52, 52, 53, 54, 124, 52, 50, 50, 52, 54, 56, 52, 46, 57, 56, 10, 49, 48, 48, 49, 50, 124, 52, 50, 50, 51, 56, 52, 49, 46, 50, 49, 10, 49, 49, 49, 55, 53, 124, 52, 50, 50, 51, 55, 48, 52, 46, 49, 52, 10, 49, 56, 54, 55, 53, 124, 52, 50, 49, 53, 52, 48, 54, 46, 56, 54, 10, 49, 48, 55, 57, 50, 124, 52, 50, 49, 52, 56, 57, 56, 46, 53, 55, 10, 49, 48, 56, 48, 54, 124, 52, 50, 48, 57, 54, 55, 56, 46, 51, 50, 10, 49, 56, 55, 52, 57, 124, 52, 50, 48, 52, 55, 56, 55, 46, 48, 48, 10, 49, 55, 52, 49, 48, 124, 52, 49, 57, 56, 48, 50, 53, 46, 50, 56, 10, 56, 48, 51, 50, 124, 52, 49, 57, 53, 52, 51, 48, 46, 48, 48, 10, 49, 49, 48, 57, 52, 124, 52, 49, 57, 50, 51, 48, 52, 46, 57, 52, 10, 49, 55, 53, 56, 50, 124, 52, 49, 56, 55, 51, 52, 49, 46, 52, 52, 10, 49, 50, 50, 52, 54, 124, 52, 49, 56, 51, 50, 51, 48, 46, 57, 53, 10, 54, 54, 52, 48, 124, 52, 49, 56, 50, 57, 54, 56, 46, 56, 48, 10, 55, 51, 52, 54, 124, 52, 49, 55, 52, 55, 48, 55, 46, 54, 48, 10, 49, 50, 55, 52, 55, 124, 52, 49, 54, 57, 56, 54, 53, 46, 56, 49, 10, 51, 56, 54, 57, 124, 52, 49, 54, 52, 57, 53, 55, 46, 52, 52, 10, 49, 51, 49, 48, 54, 124, 52, 49, 54, 49, 57, 48, 50, 46, 48, 56, 10, 49, 48, 53, 52, 55, 124, 52, 49, 53, 57, 53, 52, 49, 46, 51, 54, 10, 49, 53, 50, 56, 57, 124, 52, 49, 53, 54, 50, 48, 53, 46, 55, 54, 10, 49, 54, 55, 57, 124, 52, 49, 53, 54, 49, 53, 54, 46, 54, 52, 10, 49, 49, 50, 54, 124, 52, 49, 53, 53, 53, 57, 51, 46, 48, 56, 10, 49, 57, 49, 48, 54, 124, 52, 49, 52, 55, 52, 51, 57, 46, 53, 50, 10, 57, 55, 48, 53, 124, 52, 49, 52, 52, 48, 50, 52, 46, 50, 48, 10, 49, 53, 51, 50, 52, 124, 52, 49, 52, 50, 53, 49, 56, 46, 53, 54, 10, 49, 54, 53, 52, 52, 124, 52, 49, 52, 48, 51, 55, 53, 46, 55, 50, 10, 56, 56, 49, 50, 124, 52, 49, 51, 57, 51, 50, 50, 46, 56, 49, 10, 49, 48, 55, 55, 50, 124, 52, 49, 51, 52, 49, 48, 49, 46, 54, 52, 10, 50, 56, 48, 48, 124, 52, 49, 50, 55, 49, 53, 48, 46, 48, 56, 10, 49, 53, 53, 52, 57, 124, 52, 49, 50, 52, 55, 48, 52, 46, 54, 52, 10, 51, 54, 48, 55, 124, 52, 49, 49, 56, 54, 57, 55, 46, 53, 55, 10, 49, 57, 56, 48, 124, 52, 49, 49, 55, 54, 51, 51, 46, 55, 50, 10, 50, 49, 52, 124, 52, 49, 49, 51, 49, 49, 55, 46, 51, 54, 10, 49, 57, 50, 49, 55, 124, 52, 49, 48, 52, 50, 49, 55, 46, 54, 48, 10, 50, 52, 54, 48, 124, 52, 48, 57, 56, 53, 55, 55, 46, 52, 54, 10, 49, 57, 49, 53, 54, 124, 52, 48, 57, 51, 56, 54, 52, 46, 52, 54, 10, 49, 56, 51, 53, 57, 124, 52, 48, 57, 50, 55, 50, 55, 46, 50, 57, 10, 49, 50, 56, 54, 53, 124, 52, 48, 57, 50, 53, 50, 54, 46, 56, 52, 10, 49, 52, 54, 49, 54, 124, 52, 48, 57, 50, 52, 51, 52, 46, 53, 52, 10, 57, 48, 56, 124, 52, 48, 56, 56, 56, 53, 54, 46, 50, 48, 10, 49, 49, 55, 57, 49, 124, 52, 48, 56, 51, 56, 48, 52, 46, 57, 55, 10, 52, 49, 53, 55, 124, 52, 48, 55, 56, 51, 52, 53, 46, 54, 48, 10, 51, 56, 53, 55, 124, 52, 48, 55, 48, 56, 55, 50, 46, 56, 55, 10, 49, 53, 49, 49, 52, 124, 52, 48, 53, 54, 49, 49, 50, 46, 53, 48, 10, 51, 57, 53, 124, 52, 48, 53, 50, 57, 57, 55, 46, 55, 54, 10, 49, 55, 52, 53, 54, 124, 52, 48, 53, 49, 52, 53, 55, 46, 50, 56, 10, 49, 48, 53, 54, 50, 124, 52, 48, 53, 48, 56, 57, 52, 46, 49, 57, 10, 49, 48, 56, 56, 52, 124, 52, 48, 53, 48, 51, 51, 48, 46, 55, 54, 10, 49, 50, 49, 55, 55, 124, 52, 48, 52, 57, 56, 52, 50, 46, 54, 56, 10, 49, 53, 53, 57, 53, 124, 52, 48, 52, 48, 53, 55, 55, 46, 53, 54, 10, 49, 53, 57, 49, 54, 124, 52, 48, 51, 54, 48, 52, 52, 46, 53, 48, 10, 55, 48, 56, 52, 124, 52, 48, 51, 53, 49, 48, 50, 46, 55, 50, 10, 52, 52, 50, 52, 124, 52, 48, 51, 52, 55, 54, 49, 46, 53, 54, 10, 49, 48, 56, 55, 52, 124, 52, 48, 51, 49, 48, 49, 53, 46, 56, 53, 10, 52, 55, 52, 48, 124, 52, 48, 51, 48, 52, 48, 51, 46, 55, 54, 10, 49, 54, 53, 56, 53, 124, 52, 48, 51, 48, 48, 49, 48, 46, 50, 54, 10, 49, 56, 56, 50, 52, 124, 52, 48, 50, 56, 57, 56, 52, 46, 49, 48, 10, 49, 52, 56, 55, 53, 124, 52, 48, 50, 56, 52, 53, 50, 46, 48, 56, 10, 49, 51, 56, 53, 53, 124, 52, 48, 50, 52, 56, 50, 56, 46, 51, 52, 10, 49, 48, 57, 51, 50, 124, 52, 48, 50, 52, 48, 48, 50, 46, 52, 48, 10, 57, 48, 56, 52, 124, 52, 48, 50, 49, 51, 54, 50, 46, 52, 53, 10, 49, 52, 51, 53, 50, 124, 52, 48, 49, 56, 48, 56, 57, 46, 55, 52, 10, 49, 56, 48, 56, 54, 124, 52, 48, 49, 53, 49, 56, 48, 46, 54, 56, 10, 57, 53, 49, 52, 124, 52, 48, 49, 51, 54, 54, 54, 46, 54, 55, 10, 49, 53, 55, 56, 55, 124, 52, 48, 49, 51, 49, 53, 52, 46, 53, 54, 10, 55, 49, 52, 124, 52, 48, 49, 48, 50, 52, 57, 46, 52, 52, 10, 56, 56, 49, 49, 124, 52, 48, 48, 57, 53, 56, 56, 46, 57, 48, 10, 49, 52, 51, 56, 54, 124, 52, 48, 48, 55, 50, 49, 48, 46, 56, 56, 10, 54, 49, 54, 124, 52, 48, 48, 52, 48, 53, 55, 46, 50, 54, 10, 55, 52, 54, 48, 124, 52, 48, 48, 51, 52, 49, 50, 46, 52, 56, 10, 56, 54, 54, 124, 52, 48, 48, 51, 49, 56, 50, 46, 53, 52, 10, 55, 56, 50, 124, 52, 48, 48, 49, 50, 57, 57, 46, 57, 52, 10, 56, 53, 54, 50, 124, 51, 57, 57, 57, 52, 52, 49, 46, 54, 50, 10, 49, 51, 54, 54, 124, 51, 57, 57, 52, 48, 54, 48, 46, 56, 54, 10, 50, 56, 55, 57, 124, 51, 57, 57, 51, 48, 53, 54, 46, 53, 53, 10, 49, 54, 54, 55, 57, 124, 51, 57, 57, 50, 52, 51, 52, 46, 57, 57, 10, 49, 55, 51, 48, 54, 124, 51, 57, 57, 48, 55, 50, 51, 46, 51, 48, 10, 49, 51, 49, 52, 48, 124, 51, 57, 56, 50, 56, 49, 55, 46, 51, 57, 10, 49, 55, 57, 52, 50, 124, 51, 57, 56, 48, 56, 53, 55, 46, 48, 52, 10, 54, 53, 55, 50, 124, 51, 57, 55, 55, 54, 55, 54, 46, 50, 56, 10, 51, 53, 55, 56, 124, 51, 57, 55, 55, 53, 50, 51, 46, 57, 52, 10, 49, 53, 56, 48, 50, 124, 51, 57, 54, 57, 57, 52, 54, 46, 57, 48, 10, 51, 51, 54, 124, 51, 57, 54, 55, 57, 51, 56, 46, 51, 56, 10, 57, 56, 48, 55, 124, 51, 57, 54, 52, 52, 54, 57, 46, 54, 48, 10, 49, 50, 49, 48, 52, 124, 51, 57, 54, 52, 50, 55, 51, 46, 52, 48, 10, 52, 50, 55, 49, 124, 51, 57, 54, 50, 51, 53, 57, 46, 50, 56, 10, 54, 55, 48, 50, 124, 51, 57, 54, 49, 54, 53, 55, 46, 52, 52, 10, 49, 57, 55, 54, 51, 124, 51, 57, 53, 53, 53, 56, 50, 46, 55, 53, 10, 51, 54, 57, 124, 51, 57, 53, 51, 55, 48, 50, 46, 56, 56, 10, 52, 48, 56, 57, 124, 51, 57, 53, 51, 52, 53, 53, 46, 54, 56, 10, 50, 53, 57, 51, 124, 51, 57, 52, 54, 49, 53, 51, 46, 56, 48, 10, 53, 57, 48, 124, 51, 57, 52, 51, 56, 52, 49, 46, 49, 54, 10, 56, 51, 50, 53, 124, 51, 57, 52, 50, 49, 49, 56, 46, 55, 53, 10, 49, 53, 56, 124, 51, 57, 52, 49, 56, 56, 49, 46, 54, 53, 10, 49, 50, 48, 53, 52, 124, 51, 57, 51, 56, 51, 54, 50, 46, 54, 57, 10, 49, 56, 51, 51, 48, 124, 51, 57, 51, 56, 51, 48, 51, 46, 56, 56, 10, 53, 51, 53, 52, 124, 51, 57, 51, 54, 50, 51, 57, 46, 53, 56, 10, 56, 49, 53, 48, 124, 51, 57, 50, 53, 55, 57, 51, 46, 52, 54, 10, 56, 51, 52, 52, 124, 51, 57, 50, 49, 50, 57, 51, 46, 54, 48, 10, 54, 48, 54, 57, 124, 51, 57, 50, 49, 49, 51, 48, 46, 53, 53, 10, 52, 48, 51, 50, 124, 51, 57, 50, 48, 48, 48, 56, 46, 53, 57, 10, 49, 55, 57, 51, 57, 124, 51, 57, 49, 55, 55, 53, 48, 46, 50, 55, 10, 55, 48, 49, 52, 124, 51, 57, 49, 52, 52, 55, 49, 46, 50, 48, 10, 50, 56, 52, 48, 124, 51, 57, 49, 51, 49, 51, 49, 46, 53, 56, 10, 49, 56, 54, 56, 124, 51, 57, 49, 50, 57, 56, 55, 46, 53, 52, 10, 49, 48, 57, 55, 53, 124, 51, 57, 49, 49, 57, 50, 48, 46, 52, 56, 10, 53, 51, 55, 52, 124, 51, 57, 49, 48, 56, 48, 50, 46, 55, 52, 10, 49, 49, 49, 50, 56, 124, 51, 57, 48, 56, 49, 53, 54, 46, 52, 54, 10, 49, 56, 52, 52, 57, 124, 51, 57, 48, 55, 53, 56, 57, 46, 52, 48, 10, 49, 49, 55, 52, 48, 124, 51, 57, 48, 55, 52, 53, 57, 46, 56, 52, 10, 50, 51, 53, 54, 124, 51, 57, 48, 55, 49, 56, 57, 46, 48, 48, 10, 53, 55, 50, 49, 124, 51, 57, 48, 49, 53, 56, 53, 46, 57, 55, 10, 52, 50, 51, 49, 124, 51, 57, 48, 48, 55, 55, 57, 46, 48, 53, 10, 52, 51, 53, 50, 124, 51, 56, 57, 57, 57, 51, 51, 46, 52, 52, 10, 52, 51, 50, 124, 51, 56, 57, 57, 56, 51, 54, 46, 52, 52, 10, 49, 53, 51, 50, 49, 124, 51, 56, 57, 57, 53, 49, 54, 46, 53, 56, 10, 49, 48, 50, 57, 54, 124, 51, 56, 57, 55, 48, 49, 53, 46, 49, 52, 10, 53, 54, 52, 55, 124, 51, 56, 57, 53, 48, 56, 56, 46, 49, 54, 10, 55, 51, 56, 54, 124, 51, 56, 57, 49, 57, 49, 54, 46, 53, 49, 10, 53, 48, 55, 124, 51, 56, 57, 49, 52, 56, 55, 46, 54, 56, 10, 51, 57, 57, 53, 124, 51, 56, 56, 55, 51, 56, 55, 46, 48, 55, 10, 52, 50, 55, 56, 124, 51, 56, 56, 50, 50, 57, 52, 46, 48, 50, 10, 49, 56, 52, 48, 55, 124, 51, 56, 56, 48, 50, 54, 55, 46, 56, 54, 10, 54, 49, 50, 55, 124, 51, 56, 55, 57, 49, 54, 54, 46, 55, 49, 10, 49, 52, 53, 124, 51, 56, 55, 53, 50, 55, 55, 46, 50, 52, 10, 49, 57, 50, 54, 57, 124, 51, 56, 55, 52, 54, 56, 53, 46, 55, 54, 10, 49, 56, 50, 53, 55, 124, 51, 56, 55, 52, 52, 53, 52, 46, 56, 57, 10, 57, 48, 54, 56, 124, 51, 56, 54, 57, 55, 54, 55, 46, 55, 52, 10, 53, 55, 54, 124, 51, 56, 54, 48, 48, 48, 55, 46, 55, 57, 10, 52, 56, 54, 48, 124, 51, 56, 53, 50, 56, 54, 50, 46, 48, 50, 10, 49, 56, 55, 57, 51, 124, 51, 56, 52, 57, 56, 51, 56, 46, 49, 54, 10, 49, 53, 57, 56, 56, 124, 51, 56, 52, 55, 50, 53, 55, 46, 48, 53, 10, 54, 56, 57, 49, 124, 51, 56, 52, 54, 51, 56, 54, 46, 55, 53, 10, 51, 50, 51, 49, 124, 51, 56, 52, 54, 51, 52, 52, 46, 51, 48, 10, 49, 53, 50, 51, 55, 124, 51, 56, 52, 53, 52, 50, 49, 46, 48, 48, 10, 57, 48, 51, 53, 124, 51, 56, 52, 52, 49, 54, 54, 46, 56, 53, 10, 55, 53, 57, 55, 124, 51, 56, 51, 56, 54, 52, 51, 46, 51, 53, 10, 49, 54, 51, 52, 57, 124, 51, 56, 51, 55, 49, 50, 49, 46, 54, 53, 10, 50, 52, 57, 55, 124, 51, 56, 50, 55, 56, 53, 48, 46, 50, 48, 10, 51, 54, 49, 54, 124, 51, 56, 50, 55, 51, 57, 48, 46, 57, 53, 10, 49, 49, 53, 54, 54, 124, 51, 56, 50, 54, 49, 50, 50, 46, 52, 55, 10, 49, 56, 52, 48, 51, 124, 51, 56, 50, 50, 48, 51, 51, 46, 48, 50, 10, 50, 57, 55, 50, 124, 51, 56, 50, 49, 57, 48, 51, 46, 53, 53, 10, 56, 49, 50, 124, 51, 56, 50, 49, 53, 50, 51, 46, 55, 50, 10, 50, 48, 52, 51, 124, 51, 56, 50, 48, 53, 54, 49, 46, 51, 54, 10, 53, 48, 53, 124, 51, 56, 49, 56, 57, 50, 50, 46, 48, 51, 10, 56, 50, 53, 55, 124, 51, 56, 49, 53, 48, 55, 49, 46, 57, 50, 10, 54, 48, 56, 52, 124, 51, 56, 49, 52, 49, 57, 52, 46, 57, 53, 10, 49, 49, 50, 53, 51, 124, 51, 56, 49, 51, 57, 49, 55, 46, 50, 52, 10, 51, 54, 54, 124, 51, 56, 49, 50, 50, 53, 55, 46, 56, 56, 10, 49, 51, 54, 51, 50, 124, 51, 56, 49, 49, 54, 48, 49, 46, 51, 50, 10, 49, 52, 50, 57, 56, 124, 51, 56, 48, 49, 52, 49, 50, 46, 52, 50, 10, 55, 48, 57, 50, 124, 51, 55, 57, 56, 55, 50, 57, 46, 52, 56, 10, 50, 48, 53, 56, 124, 51, 55, 57, 54, 49, 48, 57, 46, 48, 52, 10, 49, 52, 56, 50, 48, 124, 51, 55, 57, 49, 49, 57, 53, 46, 56, 54, 10, 55, 49, 53, 55, 124, 51, 55, 56, 56, 54, 57, 48, 46, 56, 50, 10, 49, 55, 50, 49, 49, 124, 51, 55, 56, 54, 48, 51, 48, 46, 49, 55, 10, 49, 54, 54, 52, 52, 124, 51, 55, 56, 54, 48, 49, 57, 46, 50, 53, 10, 49, 53, 54, 57, 51, 124, 51, 55, 56, 51, 54, 54, 50, 46, 49, 57, 10, 50, 54, 50, 55, 124, 51, 55, 56, 50, 51, 57, 52, 46, 54, 48, 10, 49, 49, 50, 51, 49, 124, 51, 55, 56, 50, 48, 55, 55, 46, 54, 48, 10, 49, 50, 54, 57, 54, 124, 51, 55, 56, 49, 55, 54, 49, 46, 54, 54, 10, 56, 55, 48, 53, 124, 51, 55, 55, 56, 48, 55, 55, 46, 48, 48, 10, 49, 54, 48, 53, 50, 124, 51, 55, 55, 49, 53, 55, 55, 46, 48, 52, 10, 57, 57, 124, 51, 55, 54, 48, 50, 54, 57, 46, 51, 49, 10, 50, 48, 56, 50, 124, 51, 55, 53, 55, 53, 49, 55, 46, 53, 48, 10, 56, 55, 50, 124, 51, 55, 53, 48, 48, 48, 53, 46, 51, 52, 10, 55, 49, 50, 54, 124, 51, 55, 52, 57, 49, 51, 56, 46, 57, 50, 10, 49, 48, 51, 48, 50, 124, 51, 55, 52, 52, 52, 55, 53, 46, 50, 53, 10, 49, 55, 49, 50, 50, 124, 51, 55, 52, 49, 48, 49, 50, 46, 57, 56, 10, 49, 48, 48, 56, 48, 124, 51, 55, 52, 48, 49, 48, 55, 46, 49, 48, 10, 49, 54, 48, 50, 49, 124, 51, 55, 51, 57, 54, 49, 49, 46, 50, 48, 10, 51, 48, 55, 52, 124, 51, 55, 51, 57, 50, 50, 52, 46, 57, 54, 10, 51, 49, 52, 50, 124, 51, 55, 51, 56, 56, 49, 49, 46, 48, 50, 10, 49, 51, 50, 49, 51, 124, 51, 55, 51, 53, 49, 49, 54, 46, 50, 53, 10, 49, 51, 52, 52, 50, 124, 51, 55, 51, 51, 49, 51, 50, 46, 49, 52, 10, 49, 49, 53, 52, 50, 124, 51, 55, 51, 49, 48, 48, 48, 46, 49, 50, 10, 49, 51, 55, 51, 50, 124, 51, 55, 51, 48, 52, 52, 52, 46, 57, 48, 10, 50, 54, 48, 56, 124, 51, 55, 50, 57, 51, 55, 50, 46, 52, 48, 10, 53, 124, 51, 55, 50, 53, 53, 49, 49, 46, 53, 48, 10, 49, 57, 49, 53, 55, 124, 51, 55, 50, 51, 56, 52, 52, 46, 55, 50, 10, 49, 56, 50, 51, 49, 124, 51, 55, 50, 49, 55, 48, 55, 46, 57, 57, 10, 56, 49, 55, 57, 124, 51, 55, 49, 52, 49, 53, 53, 46, 48, 52, 10, 49, 50, 55, 52, 48, 124, 51, 55, 48, 56, 54, 52, 54, 46, 57, 49, 10, 49, 49, 53, 57, 55, 124, 51, 55, 48, 54, 53, 50, 56, 46, 53, 57, 10, 49, 51, 57, 54, 56, 124, 51, 55, 48, 50, 51, 55, 54, 46, 48, 56, 10, 54, 52, 51, 54, 124, 51, 54, 56, 55, 51, 52, 54, 46, 52, 52, 10, 57, 49, 56, 49, 124, 51, 54, 56, 55, 49, 51, 52, 46, 48, 56, 10, 53, 54, 52, 124, 51, 54, 56, 48, 50, 48, 48, 46, 56, 48, 10, 49, 51, 52, 54, 52, 124, 51, 54, 55, 56, 52, 48, 54, 46, 50, 48, 10, 49, 52, 48, 56, 52, 124, 51, 54, 55, 51, 55, 57, 48, 46, 51, 56, 10, 50, 55, 53, 53, 124, 51, 54, 55, 48, 53, 57, 51, 46, 54, 57, 10, 49, 52, 50, 56, 52, 124, 51, 54, 54, 56, 54, 52, 48, 46, 56, 48, 10, 49, 50, 49, 55, 56, 124, 51, 54, 53, 51, 51, 57, 50, 46, 52, 56, 10, 49, 53, 55, 51, 48, 124, 51, 54, 53, 48, 50, 53, 56, 46, 51, 48, 10, 53, 53, 54, 48, 124, 51, 54, 52, 57, 53, 54, 57, 46, 53, 57, 10, 56, 53, 57, 52, 124, 51, 54, 52, 55, 49, 52, 48, 46, 53, 54, 10, 55, 48, 51, 50, 124, 51, 54, 52, 54, 52, 51, 57, 46, 53, 52, 10, 49, 54, 56, 52, 54, 124, 51, 54, 52, 52, 56, 52, 51, 46, 49, 48, 10, 49, 53, 51, 48, 124, 51, 54, 52, 50, 56, 51, 56, 46, 48, 56, 10, 51, 57, 55, 56, 124, 51, 54, 51, 57, 55, 49, 50, 46, 48, 53, 10, 50, 56, 57, 55, 124, 51, 54, 51, 57, 52, 52, 50, 46, 51, 50, 10, 49, 54, 54, 50, 53, 124, 51, 54, 51, 54, 53, 50, 55, 46, 53, 52, 10, 49, 50, 48, 50, 57, 124, 51, 54, 51, 54, 51, 51, 57, 46, 55, 50, 10, 49, 54, 56, 51, 48, 124, 51, 54, 51, 51, 52, 52, 56, 46, 53, 55, 10, 57, 53, 57, 55, 124, 51, 54, 51, 50, 54, 54, 50, 46, 49, 49, 10, 53, 53, 51, 51, 124, 51, 54, 51, 48, 51, 51, 56, 46, 54, 55, 10, 53, 49, 56, 49, 124, 51, 54, 50, 53, 57, 54, 53, 46, 57, 51, 10, 56, 49, 51, 49, 124, 51, 54, 50, 53, 55, 51, 56, 46, 54, 50, 10, 56, 53, 54, 48, 124, 51, 54, 50, 48, 55, 54, 49, 46, 50, 54, 10, 49, 49, 56, 54, 48, 124, 51, 54, 49, 56, 55, 52, 54, 46, 50, 53, 10, 49, 50, 48, 48, 56, 124, 51, 54, 49, 52, 54, 48, 52, 46, 52, 48, 10, 49, 48, 55, 51, 55, 124, 51, 54, 49, 49, 57, 57, 48, 46, 54, 52, 10, 49, 56, 50, 48, 56, 124, 51, 54, 49, 49, 53, 57, 54, 46, 49, 48, 10, 53, 49, 49, 57, 124, 51, 54, 49, 49, 48, 51, 56, 46, 50, 48, 10, 49, 49, 57, 53, 56, 124, 51, 54, 48, 49, 54, 53, 52, 46, 54, 53, 10, 49, 53, 49, 50, 52, 124, 51, 53, 57, 56, 50, 55, 56, 46, 50, 48, 10, 49, 52, 48, 53, 56, 124, 51, 53, 57, 55, 52, 57, 48, 46, 48, 50, 10, 49, 50, 50, 55, 48, 124, 51, 53, 57, 51, 57, 49, 50, 46, 49, 48, 10, 49, 55, 55, 57, 51, 124, 51, 53, 57, 51, 51, 49, 56, 46, 57, 53, 10, 57, 51, 56, 53, 124, 51, 53, 56, 55, 51, 50, 55, 46, 56, 52, 10, 49, 50, 56, 49, 52, 124, 51, 53, 56, 55, 48, 56, 51, 46, 56, 52, 10, 53, 51, 48, 52, 124, 51, 53, 56, 54, 50, 51, 48, 46, 54, 49, 10, 51, 54, 51, 49, 124, 51, 53, 56, 50, 56, 52, 49, 46, 54, 53, 10, 54, 49, 48, 124, 51, 53, 56, 49, 57, 49, 55, 46, 51, 48, 10, 49, 57, 51, 49, 55, 124, 51, 53, 56, 48, 52, 49, 50, 46, 52, 51, 10, 49, 50, 56, 124, 51, 53, 54, 55, 48, 48, 52, 46, 53, 54, 10, 49, 49, 54, 49, 54, 124, 51, 53, 54, 54, 49, 53, 52, 46, 56, 48, 10, 49, 48, 49, 55, 54, 124, 51, 53, 54, 53, 51, 57, 50, 46, 49, 53, 10, 55, 51, 52, 57, 124, 51, 53, 54, 52, 49, 49, 48, 46, 54, 52, 10, 49, 55, 49, 50, 124, 51, 53, 54, 48, 52, 48, 56, 46, 52, 51, 10, 49, 56, 56, 54, 48, 124, 51, 53, 53, 57, 51, 52, 48, 46, 54, 48, 10, 49, 55, 54, 49, 55, 124, 51, 53, 53, 55, 53, 49, 54, 46, 48, 48, 10, 54, 52, 52, 51, 124, 51, 53, 53, 54, 50, 57, 54, 46, 57, 54, 10, 49, 53, 52, 48, 56, 124, 51, 53, 53, 52, 56, 49, 52, 46, 53, 54, 10, 49, 54, 51, 53, 48, 124, 51, 53, 53, 52, 51, 56, 56, 46, 54, 51, 10, 49, 55, 52, 51, 54, 124, 51, 53, 53, 52, 49, 48, 53, 46, 49, 51, 10, 53, 55, 52, 48, 124, 51, 53, 53, 49, 51, 50, 52, 46, 54, 56, 10, 49, 50, 49, 56, 49, 124, 51, 53, 53, 48, 50, 49, 56, 46, 53, 52, 10, 49, 54, 56, 57, 53, 124, 51, 53, 53, 48, 49, 49, 57, 46, 51, 48, 10, 49, 57, 57, 57, 53, 124, 51, 53, 52, 56, 56, 51, 57, 46, 55, 48, 10, 52, 57, 54, 56, 124, 51, 53, 52, 56, 51, 48, 54, 46, 56, 55, 10, 50, 50, 53, 55, 124, 51, 53, 52, 54, 54, 57, 50, 46, 50, 57, 10, 49, 56, 50, 53, 124, 51, 53, 52, 51, 49, 57, 56, 46, 55, 56, 10, 49, 56, 57, 56, 57, 124, 51, 53, 51, 57, 48, 51, 56, 46, 48, 56, 10, 49, 56, 55, 50, 55, 124, 51, 53, 51, 54, 48, 56, 49, 46, 52, 48, 10, 49, 54, 49, 54, 53, 124, 51, 53, 51, 51, 55, 56, 57, 46, 56, 52, 10, 51, 50, 52, 57, 124, 51, 53, 51, 51, 55, 48, 57, 46, 56, 55, 10, 49, 49, 55, 51, 49, 124, 51, 53, 51, 50, 56, 55, 53, 46, 48, 48, 10, 49, 51, 48, 51, 50, 124, 51, 53, 51, 50, 52, 49, 53, 46, 55, 57, 10, 57, 51, 55, 55, 124, 51, 53, 51, 49, 53, 56, 50, 46, 48, 56, 10, 53, 56, 56, 51, 124, 51, 53, 51, 49, 52, 55, 57, 46, 48, 48, 10, 49, 50, 49, 49, 124, 51, 53, 50, 56, 56, 51, 51, 46, 52, 48, 10, 49, 50, 48, 54, 53, 124, 51, 53, 50, 54, 57, 52, 56, 46, 49, 48, 10, 49, 48, 56, 54, 54, 124, 51, 53, 50, 54, 49, 52, 54, 46, 54, 54, 10, 50, 48, 55, 51, 124, 51, 53, 50, 48, 49, 51, 49, 46, 51, 48, 10, 50, 51, 55, 56, 124, 51, 53, 49, 50, 49, 56, 54, 46, 50, 48, 10, 49, 54, 56, 54, 48, 124, 51, 53, 48, 57, 54, 57, 51, 46, 48, 55, 10, 51, 56, 57, 124, 51, 53, 48, 55, 56, 49, 52, 46, 54, 52, 10, 49, 53, 54, 48, 52, 124, 51, 53, 48, 53, 54, 53, 51, 46, 50, 55, 10, 49, 49, 50, 53, 55, 124, 51, 53, 48, 50, 56, 51, 49, 46, 56, 48, 10, 49, 51, 50, 55, 124, 51, 53, 48, 50, 48, 50, 50, 46, 54, 48, 10, 49, 54, 54, 48, 50, 124, 51, 53, 48, 49, 48, 55, 52, 46, 56, 56, 10, 49, 52, 57, 51, 124, 51, 52, 57, 56, 56, 48, 56, 46, 57, 53, 10, 56, 50, 50, 52, 124, 51, 52, 57, 56, 49, 55, 57, 46, 53, 50, 10, 54, 50, 50, 124, 51, 52, 57, 55, 49, 53, 56, 46, 51, 54, 10, 51, 48, 55, 50, 124, 51, 52, 57, 53, 57, 53, 56, 46, 55, 50, 10, 49, 52, 55, 56, 124, 51, 52, 57, 52, 56, 56, 48, 46, 52, 56, 10, 51, 49, 50, 53, 124, 51, 52, 57, 52, 49, 54, 57, 46, 57, 48, 10, 50, 48, 53, 50, 124, 51, 52, 56, 56, 52, 51, 56, 46, 48, 56, 10, 56, 52, 55, 54, 124, 51, 52, 56, 55, 49, 57, 49, 46, 50, 56, 10, 49, 48, 55, 51, 53, 124, 51, 52, 55, 55, 55, 52, 48, 46, 55, 54, 10, 49, 52, 56, 54, 48, 124, 51, 52, 55, 54, 50, 51, 53, 46, 56, 52, 10, 54, 53, 56, 54, 124, 51, 52, 55, 53, 55, 52, 53, 46, 49, 48, 10, 53, 49, 51, 48, 124, 51, 52, 55, 50, 48, 50, 52, 46, 53, 48, 10, 55, 49, 56, 49, 124, 51, 52, 55, 49, 51, 48, 54, 46, 51, 48, 10, 54, 49, 56, 124, 51, 52, 54, 55, 57, 48, 54, 46, 53, 50, 10, 49, 53, 54, 57, 56, 124, 51, 52, 54, 52, 56, 53, 57, 46, 52, 55, 10, 49, 55, 53, 56, 53, 124, 51, 52, 54, 50, 52, 53, 48, 46, 52, 54, 10, 50, 53, 52, 56, 124, 51, 52, 53, 54, 56, 53, 54, 46, 57, 54, 10, 50, 54, 51, 50, 124, 51, 52, 53, 54, 50, 51, 48, 46, 55, 52, 10, 50, 56, 56, 50, 124, 51, 52, 53, 51, 57, 56, 54, 46, 56, 54, 10, 49, 50, 50, 49, 54, 124, 51, 52, 53, 50, 57, 48, 55, 46, 49, 53, 10, 52, 57, 50, 53, 124, 51, 52, 53, 50, 57, 48, 52, 46, 54, 51, 10, 57, 48, 49, 50, 124, 51, 52, 52, 50, 53, 56, 49, 46, 51, 54, 10, 54, 54, 54, 55, 124, 51, 52, 51, 48, 48, 55, 54, 46, 52, 48, 10, 49, 55, 57, 53, 56, 124, 51, 52, 50, 52, 57, 54, 50, 46, 53, 54, 10, 54, 48, 57, 51, 124, 51, 52, 50, 52, 50, 52, 49, 46, 57, 50, 10, 49, 48, 54, 52, 56, 124, 51, 52, 49, 55, 52, 49, 52, 46, 48, 48, 10, 49, 52, 54, 50, 124, 51, 52, 49, 51, 50, 52, 56, 46, 54, 49, 10, 50, 53, 54, 57, 124, 51, 52, 49, 50, 51, 56, 56, 46, 56, 50, 10, 49, 56, 54, 49, 54, 124, 51, 52, 48, 57, 56, 56, 48, 46, 57, 49, 10, 55, 51, 54, 56, 124, 51, 52, 48, 56, 48, 51, 54, 46, 52, 53, 10, 51, 49, 49, 48, 124, 51, 52, 48, 55, 51, 55, 52, 46, 54, 48, 10, 49, 48, 56, 50, 52, 124, 51, 52, 48, 54, 56, 49, 57, 46, 50, 57, 10, 49, 49, 53, 49, 48, 124, 51, 52, 48, 52, 55, 48, 49, 46, 57, 54, 10, 52, 56, 52, 48, 124, 51, 51, 57, 55, 50, 51, 54, 46, 52, 48, 10, 52, 52, 52, 57, 124, 51, 51, 57, 54, 57, 57, 51, 46, 54, 48, 10, 49, 51, 53, 56, 124, 51, 51, 57, 54, 54, 49, 54, 46, 51, 50, 10, 51, 56, 56, 53, 124, 51, 51, 57, 53, 56, 49, 55, 46, 54, 48, 10, 49, 51, 51, 56, 49, 124, 51, 51, 57, 49, 57, 53, 51, 46, 53, 50, 10, 49, 54, 53, 53, 124, 51, 51, 56, 51, 48, 53, 49, 46, 53, 49, 10, 50, 56, 50, 124, 51, 51, 56, 49, 55, 56, 53, 46, 52, 50, 10, 52, 57, 50, 56, 124, 51, 51, 55, 52, 50, 55, 48, 46, 52, 56, 10, 51, 49, 57, 57, 124, 51, 51, 55, 50, 52, 56, 56, 46, 56, 48, 10, 49, 54, 48, 56, 54, 124, 51, 51, 55, 48, 55, 49, 48, 46, 54, 53, 10, 56, 54, 49, 50, 124, 51, 51, 54, 50, 57, 50, 50, 46, 53, 48, 10, 49, 57, 53, 57, 55, 124, 51, 51, 54, 48, 55, 54, 52, 46, 48, 48, 10, 56, 56, 54, 55, 124, 51, 51, 53, 52, 52, 48, 48, 46, 49, 49, 10, 52, 48, 57, 56, 124, 51, 51, 53, 51, 53, 55, 52, 46, 50, 56, 10, 49, 50, 54, 49, 55, 124, 51, 51, 53, 49, 52, 57, 57, 46, 48, 53, 10, 49, 52, 51, 54, 53, 124, 51, 51, 52, 55, 50, 57, 54, 46, 48, 48, 10, 49, 48, 52, 52, 51, 124, 51, 51, 52, 53, 52, 57, 51, 46, 49, 48, 10, 55, 54, 124, 51, 51, 52, 50, 48, 56, 49, 46, 56, 50, 10, 49, 49, 53, 56, 53, 124, 51, 51, 52, 49, 57, 52, 49, 46, 50, 50, 10, 52, 51, 56, 51, 124, 51, 51, 51, 56, 57, 54, 48, 46, 50, 55, 10, 49, 51, 57, 49, 48, 124, 51, 51, 51, 53, 57, 54, 52, 46, 49, 54, 10, 56, 48, 55, 54, 124, 51, 51, 51, 50, 52, 52, 57, 46, 56, 57, 10, 49, 54, 48, 48, 53, 124, 51, 51, 51, 50, 49, 57, 48, 46, 52, 48, 10, 50, 54, 50, 50, 124, 51, 51, 50, 57, 51, 54, 52, 46, 52, 53, 10, 49, 50, 56, 50, 50, 124, 51, 51, 50, 49, 49, 56, 51, 46, 53, 50, 10, 49, 55, 48, 55, 54, 124, 51, 51, 50, 48, 51, 57, 56, 46, 48, 54, 10, 53, 51, 57, 50, 124, 51, 51, 50, 48, 51, 53, 55, 46, 49, 53, 10, 49, 56, 54, 50, 56, 124, 51, 51, 49, 57, 54, 49, 53, 46, 56, 52, 10, 49, 51, 54, 57, 53, 124, 51, 51, 49, 56, 53, 50, 53, 46, 57, 57, 10, 49, 48, 51, 50, 54, 124, 51, 51, 49, 56, 50, 55, 52, 46, 49, 54, 10, 57, 49, 48, 57, 124, 51, 51, 49, 55, 56, 51, 51, 46, 57, 48, 10, 49, 52, 56, 57, 124, 51, 51, 49, 55, 54, 50, 48, 46, 56, 48, 10, 51, 51, 55, 56, 124, 51, 51, 49, 53, 57, 52, 56, 46, 48, 48, 10, 55, 55, 51, 56, 124, 51, 51, 49, 50, 57, 55, 57, 46, 50, 48, 10, 49, 56, 52, 52, 124, 51, 51, 49, 50, 50, 55, 55, 46, 51, 54, 10, 49, 57, 57, 54, 51, 124, 51, 51, 48, 55, 53, 48, 48, 46, 48, 48, 10, 50, 52, 51, 54, 124, 51, 51, 48, 54, 52, 49, 57, 46, 48, 53, 10, 56, 56, 54, 124, 51, 51, 48, 50, 49, 56, 48, 46, 55, 48, 10, 49, 53, 52, 55, 53, 124, 51, 51, 48, 49, 54, 57, 51, 46, 53, 48, 10, 54, 51, 50, 55, 124, 51, 51, 48, 48, 54, 56, 48, 46, 55, 56, 10, 54, 48, 53, 48, 124, 51, 50, 57, 57, 52, 54, 48, 46, 50, 48, 10, 57, 56, 55, 54, 124, 51, 50, 57, 56, 52, 49, 48, 46, 48, 53, 10, 49, 57, 53, 56, 54, 124, 51, 50, 57, 49, 49, 51, 49, 46, 50, 53, 10, 49, 52, 51, 52, 57, 124, 51, 50, 56, 57, 56, 54, 50, 46, 53, 50, 10, 49, 48, 57, 57, 51, 124, 51, 50, 56, 55, 57, 56, 48, 46, 53, 55, 10, 49, 56, 55, 56, 52, 124, 51, 50, 56, 54, 55, 53, 50, 46, 49, 50, 10, 49, 56, 48, 48, 124, 51, 50, 56, 53, 52, 54, 54, 46, 50, 52, 10, 57, 57, 48, 124, 51, 50, 56, 52, 53, 57, 53, 46, 53, 48, 10, 51, 56, 50, 51, 124, 51, 50, 56, 49, 57, 57, 50, 46, 57, 52, 10, 49, 53, 55, 51, 55, 124, 51, 50, 55, 57, 51, 48, 53, 46, 57, 54, 10, 49, 57, 53, 49, 56, 124, 51, 50, 55, 54, 55, 53, 57, 46, 54, 51, 10, 57, 48, 51, 50, 124, 51, 50, 55, 50, 52, 52, 48, 46, 51, 50, 10, 55, 55, 56, 54, 124, 51, 50, 55, 49, 50, 49, 55, 46, 50, 56, 10, 56, 54, 52, 56, 124, 51, 50, 55, 49, 49, 54, 50, 46, 52, 52, 10, 53, 53, 51, 50, 124, 51, 50, 55, 48, 49, 56, 55, 46, 57, 55, 10, 49, 53, 57, 49, 52, 124, 51, 50, 54, 56, 53, 50, 48, 46, 57, 56, 10, 49, 54, 48, 54, 53, 124, 51, 50, 54, 53, 48, 54, 56, 46, 56, 52, 10, 49, 49, 50, 49, 50, 124, 51, 50, 54, 52, 54, 53, 55, 46, 48, 51, 10, 49, 51, 50, 50, 57, 124, 51, 50, 54, 50, 48, 50, 50, 46, 50, 56, 10, 49, 53, 56, 50, 55, 124, 51, 50, 54, 48, 56, 54, 50, 46, 55, 50, 10, 49, 53, 56, 50, 124, 51, 50, 54, 48, 51, 52, 48, 46, 48, 48, 10, 51, 56, 50, 55, 124, 51, 50, 54, 48, 48, 57, 51, 46, 55, 54, 10, 51, 53, 52, 54, 124, 51, 50, 53, 57, 50, 52, 52, 46, 48, 55, 10, 49, 53, 56, 52, 57, 124, 51, 50, 53, 56, 57, 49, 56, 46, 48, 48, 10, 49, 52, 56, 53, 54, 124, 51, 50, 53, 56, 51, 55, 57, 46, 52, 48, 10, 50, 48, 50, 56, 124, 51, 50, 53, 53, 48, 49, 51, 46, 57, 54, 10, 54, 54, 49, 56, 124, 51, 50, 53, 52, 53, 56, 49, 46, 57, 53, 10, 49, 55, 52, 54, 49, 124, 51, 50, 53, 50, 57, 50, 54, 46, 56, 56, 10, 49, 51, 53, 53, 49, 124, 51, 50, 52, 49, 54, 48, 50, 46, 50, 48, 10, 49, 57, 53, 54, 49, 124, 51, 50, 51, 57, 55, 57, 53, 46, 51, 50, 10, 50, 50, 55, 54, 124, 51, 50, 51, 54, 49, 55, 50, 46, 51, 48, 10, 49, 52, 50, 48, 51, 124, 51, 50, 51, 52, 54, 52, 57, 46, 51, 57, 10, 55, 55, 53, 55, 124, 51, 50, 51, 49, 51, 53, 49, 46, 56, 52, 10, 49, 50, 50, 124, 51, 50, 50, 54, 50, 49, 51, 46, 56, 56, 10, 49, 50, 57, 53, 52, 124, 51, 50, 50, 53, 57, 52, 51, 46, 48, 48, 10, 54, 52, 55, 124, 51, 50, 50, 52, 55, 56, 51, 46, 55, 54, 10, 49, 50, 51, 56, 51, 124, 51, 50, 50, 51, 57, 56, 57, 46, 52, 52, 10, 51, 56, 51, 49, 124, 51, 50, 50, 51, 49, 50, 54, 46, 54, 48, 10, 49, 54, 56, 51, 54, 124, 51, 50, 50, 50, 50, 54, 48, 46, 55, 51, 10, 52, 53, 54, 53, 124, 51, 50, 50, 49, 53, 57, 55, 46, 52, 52, 10, 49, 57, 52, 50, 54, 124, 51, 50, 49, 56, 49, 48, 54, 46, 53, 52, 10, 49, 55, 56, 53, 53, 124, 51, 50, 49, 55, 56, 49, 51, 46, 48, 50, 10, 53, 54, 50, 52, 124, 51, 50, 48, 55, 55, 55, 55, 46, 51, 54, 10, 56, 51, 54, 56, 124, 51, 50, 48, 51, 51, 55, 54, 46, 52, 53, 10, 57, 52, 56, 48, 124, 51, 50, 48, 48, 57, 48, 52, 46, 48, 48, 10, 49, 49, 49, 56, 49, 124, 51, 49, 57, 57, 53, 48, 48, 46, 53, 51, 10, 56, 57, 56, 49, 124, 51, 49, 57, 55, 56, 54, 52, 46, 48, 48, 10, 49, 54, 52, 50, 54, 124, 51, 49, 57, 53, 57, 57, 53, 46, 57, 55, 10, 49, 54, 52, 56, 124, 51, 49, 57, 53, 53, 53, 56, 46, 57, 48, 10, 49, 52, 52, 48, 52, 124, 51, 49, 57, 50, 55, 50, 57, 46, 54, 48, 10, 49, 55, 56, 54, 55, 124, 51, 49, 56, 56, 53, 55, 49, 46, 48, 48, 10, 49, 56, 49, 49, 55, 124, 51, 49, 56, 51, 50, 50, 57, 46, 48, 52, 10, 49, 52, 50, 56, 57, 124, 51, 49, 56, 50, 50, 54, 49, 46, 54, 48, 10, 53, 51, 124, 51, 49, 56, 50, 50, 53, 54, 46, 48, 48, 10, 49, 53, 53, 52, 54, 124, 51, 49, 56, 48, 49, 56, 48, 46, 48, 52, 10, 49, 54, 50, 52, 53, 124, 51, 49, 55, 56, 50, 55, 55, 46, 52, 54, 10, 49, 53, 57, 55, 124, 51, 49, 55, 54, 50, 52, 55, 46, 52, 56, 10, 49, 54, 53, 51, 124, 51, 49, 55, 51, 52, 53, 54, 46, 54, 52, 10, 50, 56, 52, 53, 124, 51, 49, 55, 49, 54, 49, 57, 46, 54, 49, 10, 49, 53, 57, 48, 54, 124, 51, 49, 55, 49, 49, 56, 55, 46, 53, 52, 10, 49, 56, 51, 48, 52, 124, 51, 49, 54, 56, 53, 55, 49, 46, 53, 48, 10, 49, 52, 48, 54, 56, 124, 51, 49, 54, 55, 51, 54, 55, 46, 54, 48, 10, 54, 56, 51, 55, 124, 51, 49, 54, 53, 48, 49, 50, 46, 52, 56, 10, 57, 52, 52, 54, 124, 51, 49, 54, 52, 52, 52, 54, 46, 53, 50, 10, 49, 56, 56, 56, 57, 124, 51, 49, 53, 54, 49, 52, 48, 46, 57, 54, 10, 49, 54, 53, 56, 55, 124, 51, 49, 53, 52, 50, 49, 48, 46, 50, 48, 10, 55, 55, 48, 53, 124, 51, 49, 53, 50, 57, 55, 55, 46, 51, 56, 10, 49, 49, 50, 48, 124, 51, 49, 53, 49, 53, 57, 49, 46, 49, 55, 10, 49, 55, 54, 54, 53, 124, 51, 49, 52, 56, 56, 52, 56, 46, 48, 48, 10, 53, 51, 49, 49, 124, 51, 49, 52, 54, 55, 50, 49, 46, 56, 54, 10, 49, 52, 49, 53, 55, 124, 51, 49, 52, 52, 55, 48, 55, 46, 51, 50, 10, 55, 57, 57, 54, 124, 51, 49, 51, 49, 51, 53, 49, 46, 48, 52, 10, 56, 54, 54, 51, 124, 51, 49, 51, 48, 53, 50, 54, 46, 51, 50, 10, 49, 56, 50, 55, 49, 124, 51, 49, 50, 55, 56, 48, 48, 46, 57, 54, 10, 54, 52, 52, 54, 124, 51, 49, 50, 53, 54, 56, 53, 46, 57, 54, 10, 54, 57, 55, 50, 124, 51, 49, 50, 53, 48, 48, 55, 46, 48, 54, 10, 50, 53, 55, 50, 124, 51, 49, 50, 51, 49, 56, 54, 46, 56, 51, 10, 49, 51, 53, 51, 54, 124, 51, 49, 50, 50, 53, 50, 55, 46, 53, 52, 10, 54, 49, 57, 54, 124, 51, 49, 50, 50, 49, 55, 50, 46, 52, 56, 10, 57, 51, 51, 56, 124, 51, 49, 50, 49, 50, 54, 50, 46, 52, 48, 10, 49, 49, 57, 57, 50, 124, 51, 49, 49, 56, 54, 52, 55, 46, 53, 53, 10, 50, 53, 56, 48, 124, 51, 49, 49, 56, 50, 56, 52, 46, 51, 55, 10, 57, 48, 57, 56, 124, 51, 49, 49, 55, 52, 57, 52, 46, 49, 48, 10, 53, 49, 49, 56, 124, 51, 49, 49, 50, 54, 54, 49, 46, 57, 54, 10, 49, 48, 49, 56, 52, 124, 51, 49, 48, 57, 50, 57, 51, 46, 52, 48, 10, 57, 57, 51, 50, 124, 51, 49, 48, 53, 56, 49, 56, 46, 50, 52, 10, 49, 56, 53, 52, 53, 124, 51, 49, 48, 50, 50, 55, 51, 46, 51, 50, 10, 49, 48, 57, 54, 51, 124, 51, 48, 57, 57, 51, 49, 52, 46, 53, 48, 10, 56, 52, 48, 53, 124, 51, 48, 57, 55, 49, 50, 49, 46, 49, 50, 10, 57, 48, 51, 55, 124, 51, 48, 57, 53, 49, 57, 53, 46, 48, 48, 10, 49, 55, 57, 124, 51, 48, 57, 49, 49, 48, 55, 46, 50, 56, 10, 49, 57, 51, 48, 124, 51, 48, 57, 48, 57, 49, 53, 46, 56, 48, 10, 49, 55, 55, 50, 51, 124, 51, 48, 57, 48, 54, 50, 52, 46, 54, 54, 10, 52, 51, 48, 56, 124, 51, 48, 56, 57, 52, 55, 50, 46, 55, 53, 10, 56, 55, 48, 50, 124, 51, 48, 56, 48, 49, 50, 57, 46, 57, 50, 10, 49, 56, 54, 50, 49, 124, 51, 48, 55, 57, 57, 56, 52, 46, 56, 48, 10, 52, 53, 48, 49, 124, 51, 48, 55, 57, 55, 56, 49, 46, 49, 48, 10, 51, 53, 57, 48, 124, 51, 48, 55, 57, 48, 52, 57, 46, 52, 50, 10, 49, 56, 50, 54, 52, 124, 51, 48, 55, 56, 56, 53, 56, 46, 52, 52, 10, 49, 53, 54, 52, 56, 124, 51, 48, 55, 56, 53, 54, 52, 46, 48, 54, 10, 53, 57, 57, 56, 124, 51, 48, 55, 51, 50, 54, 52, 46, 48, 48, 10, 49, 54, 57, 48, 52, 124, 51, 48, 55, 50, 54, 49, 48, 46, 56, 48, 10, 51, 55, 57, 52, 124, 51, 48, 55, 49, 51, 51, 51, 46, 48, 57, 10, 51, 49, 52, 55, 124, 51, 48, 54, 56, 52, 56, 53, 46, 51, 50, 10, 49, 55, 50, 50, 49, 124, 51, 48, 54, 56, 51, 51, 55, 46, 50, 50, 10, 52, 55, 48, 57, 124, 51, 48, 54, 55, 53, 50, 51, 46, 51, 49, 10, 49, 56, 48, 49, 55, 124, 51, 48, 54, 54, 55, 52, 51, 46, 52, 49, 10, 49, 53, 54, 49, 51, 124, 51, 48, 54, 51, 57, 56, 55, 46, 56, 54, 10, 49, 54, 50, 55, 49, 124, 51, 48, 53, 55, 48, 53, 49, 46, 51, 52, 10, 49, 51, 54, 50, 49, 124, 51, 48, 53, 52, 55, 55, 52, 46, 53, 57, 10, 49, 50, 57, 49, 57, 124, 51, 48, 53, 52, 53, 49, 56, 46, 53, 48, 10, 49, 50, 52, 57, 51, 124, 51, 48, 53, 48, 56, 51, 54, 46, 51, 48, 10, 49, 53, 56, 51, 56, 124, 51, 48, 53, 48, 54, 52, 53, 46, 57, 53, 10, 51, 50, 55, 51, 124, 51, 48, 52, 56, 57, 53, 53, 46, 49, 53, 10, 56, 51, 50, 52, 124, 51, 48, 52, 54, 48, 49, 49, 46, 50, 53, 10, 49, 51, 54, 50, 56, 124, 51, 48, 52, 53, 51, 50, 52, 46, 53, 48, 10, 53, 53, 50, 50, 124, 51, 48, 52, 52, 52, 48, 56, 46, 53, 48, 10, 50, 50, 48, 50, 124, 51, 48, 52, 51, 49, 51, 50, 46, 48, 53, 10, 49, 57, 48, 53, 50, 124, 51, 48, 52, 50, 53, 54, 54, 46, 53, 53, 10, 53, 55, 54, 55, 124, 51, 48, 52, 49, 56, 55, 49, 46, 55, 48, 10, 49, 55, 56, 57, 53, 124, 51, 48, 51, 54, 52, 53, 50, 46, 50, 50, 10, 49, 50, 53, 56, 54, 124, 51, 48, 51, 54, 51, 56, 54, 46, 51, 48, 10, 49, 50, 52, 50, 53, 124, 51, 48, 51, 53, 48, 52, 49, 46, 53, 50, 10, 49, 51, 53, 49, 55, 124, 51, 48, 51, 52, 51, 53, 49, 46, 52, 55, 10, 50, 51, 54, 51, 124, 51, 48, 51, 51, 51, 51, 54, 46, 54, 48, 10, 49, 53, 48, 54, 48, 124, 51, 48, 51, 50, 53, 57, 56, 46, 53, 49, 10, 54, 55, 54, 52, 124, 51, 48, 51, 50, 53, 57, 49, 46, 49, 48, 10, 51, 52, 48, 124, 51, 48, 51, 48, 53, 50, 50, 46, 48, 48, 10, 52, 55, 50, 51, 124, 51, 48, 50, 56, 57, 49, 48, 46, 50, 53, 10, 51, 53, 54, 54, 124, 51, 48, 50, 55, 56, 53, 56, 46, 54, 49, 10, 49, 55, 55, 57, 54, 124, 51, 48, 50, 54, 56, 51, 56, 46, 57, 54, 10, 49, 53, 51, 56, 52, 124, 51, 48, 50, 51, 55, 57, 50, 46, 54, 52, 10, 49, 54, 51, 51, 54, 124, 51, 48, 49, 48, 56, 49, 51, 46, 53, 54, 10, 54, 55, 57, 124, 51, 48, 49, 48, 55, 49, 51, 46, 51, 48, 10, 55, 53, 53, 52, 124, 51, 48, 49, 48, 54, 54, 55, 46, 56, 48, 10, 49, 52, 53, 53, 51, 124, 51, 48, 48, 57, 55, 53, 54, 46, 57, 54, 10, 56, 51, 55, 57, 124, 51, 48, 48, 57, 55, 52, 53, 46, 49, 55, 10, 49, 53, 52, 51, 54, 124, 51, 48, 48, 55, 52, 57, 57, 46, 55, 55, 10, 49, 50, 52, 55, 49, 124, 51, 48, 48, 51, 57, 57, 49, 46, 56, 54, 10, 49, 56, 48, 53, 57, 124, 51, 48, 48, 51, 48, 51, 55, 46, 53, 51, 10, 56, 53, 51, 54, 124, 51, 48, 48, 48, 55, 52, 54, 46, 48, 48, 10, 49, 57, 48, 51, 51, 124, 50, 57, 57, 57, 51, 55, 51, 46, 50, 56, 10, 49, 56, 49, 55, 57, 124, 50, 57, 57, 54, 49, 53, 49, 46, 50, 48, 10, 49, 48, 55, 49, 49, 124, 50, 57, 57, 54, 49, 52, 51, 46, 49, 55, 10, 49, 55, 50, 55, 49, 124, 50, 57, 57, 52, 50, 54, 52, 46, 55, 57, 10, 49, 51, 57, 51, 50, 124, 50, 57, 56, 57, 48, 50, 51, 46, 53, 56, 10, 51, 49, 48, 49, 124, 50, 57, 56, 55, 55, 56, 56, 46, 49, 54, 10, 49, 52, 53, 53, 48, 124, 50, 57, 55, 55, 56, 53, 51, 46, 54, 53, 10, 51, 48, 56, 48, 124, 50, 57, 55, 55, 50, 51, 50, 46, 53, 56, 10, 49, 52, 53, 51, 51, 124, 50, 57, 55, 54, 52, 57, 48, 46, 52, 57, 10, 49, 52, 52, 51, 57, 124, 50, 57, 55, 53, 51, 49, 51, 46, 50, 52, 10, 57, 50, 51, 55, 124, 50, 57, 55, 51, 49, 50, 52, 46, 55, 56, 10, 49, 50, 48, 53, 124, 50, 57, 55, 49, 52, 55, 48, 46, 50, 56, 10, 49, 50, 51, 54, 49, 124, 50, 57, 54, 51, 52, 49, 57, 46, 52, 55, 10, 52, 50, 57, 124, 50, 57, 54, 50, 54, 51, 49, 46, 56, 56, 10, 51, 57, 55, 48, 124, 50, 57, 54, 48, 52, 49, 56, 46, 52, 53, 10, 56, 52, 48, 51, 124, 50, 57, 53, 55, 54, 57, 56, 46, 52, 53, 10, 49, 48, 57, 56, 124, 50, 57, 53, 55, 53, 49, 52, 46, 48, 48, 10, 55, 57, 51, 50, 124, 50, 57, 53, 53, 48, 52, 54, 46, 49, 52, 10, 49, 54, 50, 54, 54, 124, 50, 57, 53, 50, 50, 57, 56, 46, 51, 56, 10, 49, 57, 51, 56, 54, 124, 50, 57, 52, 56, 56, 53, 52, 46, 52, 56, 10, 49, 51, 49, 52, 55, 124, 50, 57, 52, 55, 48, 51, 55, 46, 57, 49, 10, 50, 55, 50, 48, 124, 50, 57, 52, 55, 48, 49, 49, 46, 48, 56, 10, 51, 56, 52, 48, 124, 50, 57, 52, 52, 50, 49, 57, 46, 51, 53, 10, 49, 51, 52, 56, 50, 124, 50, 57, 52, 50, 52, 55, 52, 46, 56, 56, 10, 57, 52, 51, 54, 124, 50, 57, 52, 48, 51, 57, 54, 46, 50, 49, 10, 49, 57, 55, 55, 57, 124, 50, 57, 51, 55, 49, 48, 53, 46, 57, 54, 10, 49, 56, 48, 51, 50, 124, 50, 57, 51, 51, 50, 50, 52, 46, 51, 56, 10, 55, 55, 52, 51, 124, 50, 57, 51, 50, 55, 51, 51, 46, 55, 55, 10, 49, 52, 54, 50, 48, 124, 50, 57, 51, 48, 55, 54, 54, 46, 56, 57, 10, 52, 54, 48, 54, 124, 50, 57, 50, 55, 56, 51, 50, 46, 53, 57, 10, 49, 56, 48, 55, 54, 124, 50, 57, 50, 52, 49, 51, 52, 46, 56, 51, 10, 49, 57, 50, 55, 54, 124, 50, 57, 49, 56, 49, 55, 54, 46, 50, 48, 10, 55, 52, 56, 51, 124, 50, 57, 49, 53, 57, 49, 56, 46, 57, 53, 10, 56, 53, 55, 53, 124, 50, 57, 49, 53, 49, 51, 50, 46, 54, 52, 10, 49, 49, 48, 53, 50, 124, 50, 57, 49, 51, 49, 52, 48, 46, 56, 56, 10, 49, 55, 50, 53, 49, 124, 50, 57, 48, 56, 51, 52, 53, 46, 56, 48, 10, 56, 55, 56, 56, 124, 50, 57, 48, 55, 57, 51, 53, 46, 57, 51, 10, 49, 48, 57, 54, 48, 124, 50, 57, 48, 54, 53, 49, 49, 46, 49, 52, 10, 49, 56, 55, 56, 50, 124, 50, 57, 48, 51, 54, 52, 51, 46, 55, 56, 10, 49, 57, 57, 56, 56, 124, 50, 56, 57, 55, 52, 54, 49, 46, 53, 51, 10, 55, 50, 54, 124, 50, 56, 57, 54, 48, 48, 57, 46, 50, 55, 10, 49, 57, 57, 52, 50, 124, 50, 56, 57, 52, 50, 53, 49, 46, 51, 54, 10, 49, 48, 56, 54, 52, 124, 50, 56, 57, 50, 50, 53, 50, 46, 52, 56, 10, 49, 55, 56, 52, 48, 124, 50, 56, 57, 49, 53, 54, 51, 46, 50, 50, 10, 49, 56, 55, 49, 55, 124, 50, 56, 56, 56, 57, 51, 57, 46, 57, 54, 10, 49, 50, 51, 57, 49, 124, 50, 56, 56, 54, 48, 53, 49, 46, 51, 48, 10, 49, 56, 50, 49, 57, 124, 50, 56, 56, 53, 57, 50, 49, 46, 48, 54, 10, 49, 53, 49, 48, 48, 124, 50, 56, 56, 51, 51, 52, 50, 46, 51, 51, 10, 50, 52, 57, 49, 124, 50, 56, 56, 48, 51, 56, 53, 46, 55, 52, 10, 49, 50, 51, 56, 57, 124, 50, 56, 55, 57, 54, 57, 54, 46, 57, 54, 10, 51, 56, 56, 48, 124, 50, 56, 55, 55, 55, 55, 48, 46, 50, 52, 10, 49, 56, 53, 55, 57, 124, 50, 56, 55, 52, 53, 52, 50, 46, 52, 56, 10, 49, 51, 54, 52, 55, 124, 50, 56, 55, 51, 56, 51, 56, 46, 51, 52, 10, 49, 53, 55, 53, 56, 124, 50, 56, 55, 51, 56, 48, 52, 46, 57, 50, 10, 49, 50, 57, 49, 55, 124, 50, 56, 55, 51, 54, 53, 57, 46, 54, 48, 10, 49, 56, 56, 54, 54, 124, 50, 56, 55, 51, 54, 49, 54, 46, 50, 54, 10, 49, 51, 56, 57, 52, 124, 50, 56, 55, 50, 57, 56, 54, 46, 49, 50, 10, 49, 53, 50, 48, 48, 124, 50, 56, 55, 50, 53, 55, 49, 46, 57, 51, 10, 57, 54, 50, 56, 124, 50, 56, 55, 50, 52, 48, 52, 46, 53, 54, 10, 56, 53, 54, 56, 124, 50, 56, 55, 49, 53, 57, 56, 46, 48, 56, 10, 56, 51, 56, 57, 124, 50, 56, 55, 48, 50, 51, 55, 46, 56, 56, 10, 53, 55, 56, 56, 124, 50, 56, 54, 55, 50, 49, 48, 46, 49, 56, 10, 49, 57, 52, 53, 48, 124, 50, 56, 54, 51, 51, 49, 48, 46, 54, 54, 10, 57, 52, 52, 48, 124, 50, 56, 54, 51, 49, 54, 50, 46, 57, 50, 10, 49, 54, 55, 57, 53, 124, 50, 56, 54, 48, 49, 51, 53, 46, 52, 49, 10, 49, 57, 54, 52, 51, 124, 50, 56, 53, 56, 57, 56, 55, 46, 56, 48, 10, 49, 57, 55, 52, 124, 50, 56, 53, 54, 56, 50, 53, 46, 56, 52, 10, 49, 52, 54, 50, 50, 124, 50, 56, 53, 50, 48, 56, 57, 46, 49, 50, 10, 54, 56, 56, 53, 124, 50, 56, 53, 49, 52, 51, 55, 46, 54, 50, 10, 49, 50, 53, 51, 50, 124, 50, 56, 52, 56, 57, 57, 50, 46, 54, 52, 10, 49, 48, 56, 55, 124, 50, 56, 52, 55, 56, 53, 56, 46, 56, 48, 10, 53, 55, 55, 55, 124, 50, 56, 52, 54, 52, 48, 55, 46, 52, 49, 10, 53, 54, 50, 57, 124, 50, 56, 52, 54, 48, 55, 54, 46, 49, 50, 10, 54, 51, 49, 54, 124, 50, 56, 52, 48, 53, 52, 52, 46, 54, 53, 10, 49, 50, 55, 54, 55, 124, 50, 56, 52, 48, 53, 49, 52, 46, 49, 50, 10, 49, 50, 49, 51, 52, 124, 50, 56, 52, 48, 48, 51, 54, 46, 57, 49, 10, 49, 52, 52, 55, 54, 124, 50, 56, 51, 57, 56, 53, 51, 46, 48, 49, 10, 56, 48, 51, 124, 50, 56, 51, 56, 51, 56, 56, 46, 49, 54, 10, 49, 56, 57, 54, 52, 124, 50, 56, 51, 54, 57, 52, 50, 46, 52, 52, 10, 54, 48, 50, 48, 124, 50, 56, 51, 51, 52, 53, 57, 46, 50, 48, 10, 49, 48, 52, 48, 49, 124, 50, 56, 51, 50, 54, 56, 56, 46, 55, 52, 10, 49, 51, 50, 51, 124, 50, 56, 50, 57, 57, 54, 52, 46, 53, 48, 10, 49, 49, 53, 49, 124, 50, 56, 50, 57, 54, 54, 50, 46, 52, 52, 10, 49, 52, 53, 56, 124, 50, 56, 50, 52, 48, 51, 52, 46, 52, 51, 10, 50, 50, 55, 49, 124, 50, 56, 50, 48, 55, 53, 54, 46, 53, 51, 10, 49, 56, 55, 52, 48, 124, 50, 56, 49, 52, 49, 52, 48, 46, 56, 48, 10, 55, 51, 52, 56, 124, 50, 56, 49, 49, 55, 51, 48, 46, 57, 53, 10, 52, 50, 56, 49, 124, 50, 56, 48, 55, 49, 57, 48, 46, 53, 50, 10, 56, 48, 52, 51, 124, 50, 56, 48, 52, 55, 48, 54, 46, 50, 52, 10, 51, 56, 52, 51, 124, 50, 56, 48, 52, 50, 49, 55, 46, 57, 54, 10, 55, 56, 49, 51, 124, 50, 56, 48, 50, 51, 53, 48, 46, 56, 56, 10, 51, 52, 55, 124, 50, 56, 48, 50, 50, 52, 53, 46, 53, 50, 10, 55, 52, 53, 124, 50, 56, 48, 49, 55, 50, 53, 46, 49, 48, 10, 49, 48, 51, 56, 56, 124, 50, 55, 57, 57, 49, 55, 48, 46, 53, 56, 10, 49, 56, 49, 48, 48, 124, 50, 55, 57, 51, 51, 53, 56, 46, 53, 48, 10, 49, 57, 48, 52, 51, 124, 50, 55, 56, 57, 48, 49, 51, 46, 56, 48, 10, 49, 48, 54, 52, 52, 124, 50, 55, 56, 55, 55, 57, 55, 46, 48, 49, 10, 49, 54, 49, 55, 48, 124, 50, 55, 56, 55, 52, 48, 50, 46, 56, 48, 10, 51, 57, 56, 124, 50, 55, 56, 50, 55, 50, 57, 46, 48, 53, 10, 57, 51, 55, 48, 124, 50, 55, 56, 48, 48, 55, 56, 46, 49, 51, 10, 49, 52, 53, 48, 52, 124, 50, 55, 56, 48, 48, 51, 54, 46, 48, 52, 10, 49, 50, 49, 48, 124, 50, 55, 55, 56, 52, 56, 53, 46, 55, 54, 10, 49, 51, 51, 56, 53, 124, 50, 55, 55, 55, 52, 52, 53, 46, 54, 50, 10, 51, 55, 57, 57, 124, 50, 55, 55, 53, 50, 50, 51, 46, 54, 48, 10, 49, 49, 51, 50, 53, 124, 50, 55, 54, 57, 55, 54, 54, 46, 48, 50, 10, 51, 52, 56, 57, 124, 50, 55, 54, 57, 53, 53, 52, 46, 53, 50, 10, 49, 55, 49, 56, 49, 124, 50, 55, 54, 57, 48, 50, 56, 46, 53, 48, 10, 54, 57, 54, 52, 124, 50, 55, 54, 54, 54, 53, 51, 46, 55, 56, 10, 55, 51, 56, 49, 124, 50, 55, 54, 52, 56, 57, 56, 46, 56, 48, 10, 54, 50, 53, 51, 124, 50, 55, 54, 52, 51, 57, 52, 46, 54, 52, 10, 53, 57, 55, 53, 124, 50, 55, 54, 48, 56, 49, 57, 46, 55, 50, 10, 49, 49, 57, 57, 54, 124, 50, 55, 54, 48, 54, 56, 55, 46, 56, 54, 10, 55, 53, 55, 48, 124, 50, 55, 53, 56, 57, 55, 55, 46, 49, 50, 10, 52, 51, 56, 55, 124, 50, 55, 53, 55, 54, 55, 50, 46, 48, 48, 10, 57, 48, 49, 52, 124, 50, 55, 53, 53, 51, 54, 55, 46, 52, 50, 10, 57, 52, 48, 51, 124, 50, 55, 52, 56, 48, 50, 49, 46, 54, 54, 10, 49, 49, 54, 53, 51, 124, 50, 55, 51, 57, 55, 51, 49, 46, 48, 55, 10, 49, 55, 54, 57, 55, 124, 50, 55, 51, 57, 51, 49, 50, 46, 50, 57, 10, 57, 53, 56, 124, 50, 55, 51, 56, 48, 51, 50, 46, 48, 48, 10, 49, 56, 56, 49, 54, 124, 50, 55, 51, 55, 49, 52, 48, 46, 48, 48, 10, 49, 52, 49, 48, 52, 124, 50, 55, 51, 53, 48, 48, 56, 46, 54, 52, 10, 49, 53, 57, 54, 54, 124, 50, 55, 51, 50, 50, 53, 48, 46, 50, 48, 10, 49, 55, 57, 49, 50, 124, 50, 55, 50, 52, 49, 54, 48, 46, 57, 53, 10, 55, 48, 56, 57, 124, 50, 55, 50, 48, 49, 55, 48, 46, 48, 52, 10, 49, 54, 48, 51, 50, 124, 50, 55, 49, 56, 57, 55, 54, 46, 49, 56, 10, 49, 54, 56, 57, 49, 124, 50, 55, 49, 55, 50, 57, 51, 46, 51, 50, 10, 49, 57, 53, 55, 57, 124, 50, 55, 49, 54, 57, 48, 57, 46, 56, 54, 10, 49, 55, 52, 55, 48, 124, 50, 55, 49, 53, 48, 52, 56, 46, 56, 52, 10, 49, 50, 52, 48, 56, 124, 50, 55, 49, 50, 53, 53, 54, 46, 53, 50, 10, 52, 55, 54, 51, 124, 50, 55, 49, 49, 56, 48, 48, 46, 57, 48, 10, 49, 49, 51, 56, 124, 50, 55, 48, 57, 55, 48, 57, 46, 56, 49, 10, 55, 51, 54, 51, 124, 50, 55, 48, 56, 52, 49, 52, 46, 52, 48, 10, 55, 56, 55, 55, 124, 50, 55, 48, 53, 52, 51, 57, 46, 52, 53, 10, 49, 55, 53, 51, 50, 124, 50, 55, 48, 51, 54, 57, 56, 46, 54, 56, 10, 49, 48, 53, 49, 50, 124, 50, 55, 48, 49, 50, 51, 53, 46, 57, 50, 10, 49, 49, 57, 53, 55, 124, 50, 55, 48, 48, 49, 51, 51, 46, 50, 50, 10, 50, 52, 53, 53, 124, 50, 54, 57, 57, 53, 57, 51, 46, 56, 56, 10, 49, 53, 49, 49, 57, 124, 50, 54, 57, 54, 56, 54, 48, 46, 56, 48, 10, 57, 56, 54, 56, 124, 50, 54, 57, 54, 56, 48, 49, 46, 53, 50, 10, 49, 52, 49, 55, 50, 124, 50, 54, 57, 53, 51, 48, 55, 46, 52, 56, 10, 49, 54, 49, 50, 48, 124, 50, 54, 56, 57, 51, 51, 55, 46, 56, 50, 10, 49, 51, 57, 53, 56, 124, 50, 54, 55, 57, 48, 50, 53, 46, 50, 56, 10, 49, 53, 49, 54, 57, 124, 50, 54, 55, 54, 54, 56, 54, 46, 48, 52, 10, 50, 54, 52, 56, 124, 50, 54, 55, 50, 50, 51, 50, 46, 48, 48, 10, 54, 49, 54, 52, 124, 50, 54, 55, 49, 51, 49, 55, 46, 51, 50, 10, 49, 50, 55, 48, 49, 124, 50, 54, 54, 57, 50, 49, 54, 46, 52, 48, 10, 49, 54, 51, 56, 50, 124, 50, 54, 54, 57, 48, 51, 52, 46, 53, 52, 10, 49, 53, 53, 56, 56, 124, 50, 54, 54, 55, 50, 49, 50, 46, 49, 48, 10, 49, 52, 56, 51, 48, 124, 50, 54, 54, 54, 55, 53, 56, 46, 49, 53, 10, 57, 49, 49, 57, 124, 50, 54, 54, 53, 56, 49, 50, 46, 50, 52, 10, 49, 54, 50, 50, 124, 50, 54, 54, 53, 50, 48, 54, 46, 53, 48, 10, 56, 55, 56, 124, 50, 54, 54, 52, 48, 52, 53, 46, 55, 57, 10, 49, 51, 50, 54, 57, 124, 50, 54, 54, 50, 55, 56, 52, 46, 49, 50, 10, 54, 49, 57, 124, 50, 54, 53, 53, 52, 49, 55, 46, 54, 51, 10, 49, 56, 51, 56, 54, 124, 50, 54, 53, 51, 55, 57, 53, 46, 48, 50, 10, 50, 53, 48, 49, 124, 50, 54, 53, 50, 50, 54, 48, 46, 52, 48, 10, 50, 51, 49, 48, 124, 50, 54, 53, 49, 54, 51, 49, 46, 48, 57, 10, 49, 57, 52, 50, 48, 124, 50, 54, 52, 57, 51, 57, 53, 46, 54, 49, 10, 52, 56, 57, 53, 124, 50, 54, 52, 53, 49, 53, 50, 46, 50, 55, 10, 55, 53, 53, 51, 124, 50, 54, 52, 51, 54, 56, 50, 46, 48, 55, 10, 49, 55, 56, 49, 52, 124, 50, 54, 52, 50, 55, 56, 49, 46, 52, 52, 10, 49, 54, 48, 57, 55, 124, 50, 54, 52, 50, 53, 48, 48, 46, 48, 48, 10, 49, 48, 57, 57, 53, 124, 50, 54, 52, 48, 56, 49, 49, 46, 49, 54, 10, 49, 52, 56, 57, 53, 124, 50, 54, 51, 55, 55, 51, 51, 46, 55, 50, 10, 49, 56, 53, 52, 54, 124, 50, 54, 51, 55, 48, 50, 54, 46, 55, 49, 10, 57, 56, 55, 53, 124, 50, 54, 51, 49, 51, 53, 56, 46, 56, 48, 10, 57, 53, 57, 49, 124, 50, 54, 50, 54, 56, 57, 57, 46, 53, 52, 10, 54, 48, 48, 49, 124, 50, 54, 50, 53, 56, 57, 51, 46, 55, 54, 10, 55, 55, 51, 57, 124, 50, 54, 50, 52, 53, 55, 51, 46, 50, 56, 10, 49, 48, 52, 51, 49, 124, 50, 54, 50, 52, 51, 55, 57, 46, 53, 52, 10, 52, 53, 52, 52, 124, 50, 54, 49, 53, 51, 49, 51, 46, 55, 53, 10, 49, 54, 51, 56, 55, 124, 50, 54, 48, 51, 49, 57, 53, 46, 55, 54, 10, 49, 56, 51, 55, 53, 124, 50, 54, 48, 49, 52, 48, 55, 46, 56, 51, 10, 56, 51, 57, 53, 124, 50, 53, 57, 56, 55, 50, 56, 46, 52, 52, 10, 49, 56, 56, 53, 51, 124, 50, 53, 57, 51, 51, 53, 54, 46, 51, 54, 10, 52, 57, 48, 48, 124, 50, 53, 57, 50, 56, 49, 51, 46, 49, 53, 10, 49, 51, 48, 50, 124, 50, 53, 57, 50, 49, 57, 55, 46, 55, 54, 10, 49, 55, 48, 51, 50, 124, 50, 53, 56, 57, 56, 48, 54, 46, 52, 48, 10, 49, 52, 50, 57, 50, 124, 50, 53, 56, 57, 55, 52, 57, 46, 53, 54, 10, 52, 51, 124, 50, 53, 56, 55, 51, 53, 57, 46, 53, 56, 10, 53, 50, 50, 49, 124, 50, 53, 56, 55, 48, 50, 52, 46, 48, 52, 10, 51, 57, 55, 124, 50, 53, 55, 57, 55, 53, 49, 46, 52, 54, 10, 49, 55, 56, 57, 48, 124, 50, 53, 55, 57, 54, 55, 52, 46, 50, 52, 10, 49, 50, 49, 53, 55, 124, 50, 53, 55, 53, 53, 49, 48, 46, 52, 56, 10, 55, 51, 52, 48, 124, 50, 53, 55, 52, 54, 52, 53, 46, 56, 51, 10, 49, 57, 51, 54, 56, 124, 50, 53, 55, 50, 54, 49, 56, 46, 57, 53, 10, 56, 56, 52, 56, 124, 50, 53, 55, 48, 56, 49, 57, 46, 49, 53, 10, 49, 51, 55, 56, 57, 124, 50, 53, 55, 48, 50, 52, 51, 46, 50, 54, 10, 49, 52, 53, 57, 54, 124, 50, 53, 54, 56, 50, 51, 52, 46, 50, 52, 10, 56, 52, 48, 56, 124, 50, 53, 54, 55, 52, 51, 52, 46, 52, 49, 10, 49, 57, 55, 50, 54, 124, 50, 53, 54, 53, 55, 53, 48, 46, 52, 50, 10, 49, 51, 57, 54, 52, 124, 50, 53, 54, 53, 53, 55, 57, 46, 49, 50, 10, 55, 55, 52, 48, 124, 50, 53, 54, 51, 48, 50, 55, 46, 53, 48, 10, 49, 52, 55, 54, 56, 124, 50, 53, 54, 48, 51, 57, 50, 46, 54, 48, 10, 49, 49, 55, 51, 52, 124, 50, 53, 53, 57, 48, 54, 50, 46, 50, 50, 10, 49, 48, 50, 57, 52, 124, 50, 53, 53, 56, 50, 53, 55, 46, 57, 55, 10, 49, 53, 48, 51, 50, 124, 50, 53, 53, 55, 57, 50, 54, 46, 50, 50, 10, 57, 49, 50, 55, 124, 50, 53, 53, 54, 51, 55, 57, 46, 56, 48, 10, 50, 49, 56, 49, 124, 50, 53, 53, 51, 49, 55, 53, 46, 48, 48, 10, 49, 54, 54, 53, 51, 124, 50, 53, 53, 50, 50, 50, 57, 46, 54, 56, 10, 51, 56, 54, 54, 124, 50, 53, 52, 57, 57, 57, 52, 46, 55, 57, 10, 49, 54, 56, 49, 52, 124, 50, 53, 52, 56, 55, 49, 48, 46, 55, 54, 10, 49, 56, 54, 54, 124, 50, 53, 52, 53, 56, 51, 56, 46, 52, 48, 10, 51, 53, 49, 50, 124, 50, 53, 51, 50, 54, 50, 54, 46, 56, 48, 10, 52, 49, 52, 53, 124, 50, 53, 50, 57, 55, 56, 54, 46, 49, 53, 10, 49, 50, 49, 50, 48, 124, 50, 53, 50, 56, 50, 57, 56, 46, 55, 50, 10, 54, 52, 52, 124, 50, 53, 50, 56, 49, 50, 51, 46, 48, 53, 10, 49, 53, 51, 55, 57, 124, 50, 53, 50, 53, 49, 56, 49, 46, 48, 49, 10, 54, 51, 57, 50, 124, 50, 53, 50, 52, 48, 54, 51, 46, 48, 56, 10, 50, 54, 53, 50, 124, 50, 53, 50, 49, 52, 53, 54, 46, 56, 48, 10, 51, 51, 54, 51, 124, 50, 53, 49, 57, 50, 48, 50, 46, 50, 51, 10, 49, 57, 49, 54, 55, 124, 50, 53, 49, 55, 57, 57, 51, 46, 49, 56, 10, 49, 54, 48, 52, 50, 124, 50, 53, 49, 54, 53, 57, 57, 46, 57, 50, 10, 50, 56, 57, 50, 124, 50, 53, 49, 49, 56, 53, 52, 46, 52, 48, 10, 53, 55, 49, 49, 124, 50, 53, 48, 57, 52, 48, 49, 46, 55, 50, 10, 49, 52, 53, 57, 49, 124, 50, 53, 48, 54, 51, 52, 52, 46, 54, 57, 10, 54, 53, 54, 52, 124, 50, 53, 48, 54, 50, 55, 55, 46, 51, 52, 10, 49, 50, 51, 49, 124, 50, 53, 48, 53, 52, 50, 49, 46, 50, 52, 10, 53, 48, 52, 57, 124, 50, 53, 48, 50, 54, 48, 51, 46, 48, 48, 10, 49, 52, 53, 55, 54, 124, 50, 53, 48, 49, 54, 48, 54, 46, 54, 57, 10, 49, 48, 50, 49, 49, 124, 50, 53, 48, 48, 56, 53, 50, 46, 50, 48, 10, 50, 57, 51, 124, 50, 52, 57, 51, 49, 54, 56, 46, 52, 56, 10, 55, 51, 55, 49, 124, 50, 52, 57, 49, 49, 51, 52, 46, 54, 53, 10, 49, 56, 49, 53, 52, 124, 50, 52, 57, 49, 48, 52, 55, 46, 50, 48, 10, 57, 52, 57, 52, 124, 50, 52, 56, 57, 56, 50, 53, 46, 53, 50, 10, 49, 52, 56, 51, 54, 124, 50, 52, 56, 48, 52, 51, 50, 46, 52, 48, 10, 49, 57, 52, 55, 49, 124, 50, 52, 56, 48, 52, 48, 51, 46, 55, 53, 10, 56, 48, 50, 124, 50, 52, 55, 56, 57, 57, 56, 46, 51, 51, 10, 49, 50, 53, 52, 49, 124, 50, 52, 55, 55, 50, 52, 50, 46, 54, 48, 10, 49, 53, 48, 54, 53, 124, 50, 52, 55, 51, 53, 54, 51, 46, 57, 52, 10, 49, 53, 57, 57, 53, 124, 50, 52, 55, 50, 56, 48, 51, 46, 50, 48, 10, 57, 52, 48, 56, 124, 50, 52, 55, 49, 57, 53, 51, 46, 53, 54, 10, 57, 55, 55, 54, 124, 50, 52, 55, 48, 52, 52, 55, 46, 57, 48, 10, 49, 55, 51, 50, 53, 124, 50, 52, 54, 56, 57, 56, 57, 46, 48, 53, 10, 51, 51, 57, 49, 124, 50, 52, 54, 56, 51, 49, 55, 46, 55, 50, 10, 49, 54, 49, 50, 51, 124, 50, 52, 54, 55, 48, 50, 50, 46, 50, 50, 10, 49, 56, 55, 53, 56, 124, 50, 52, 54, 51, 55, 57, 56, 46, 48, 54, 10, 52, 48, 55, 124, 50, 52, 54, 48, 51, 48, 52, 46, 52, 55, 10, 54, 56, 52, 48, 124, 50, 52, 53, 54, 49, 55, 48, 46, 55, 56, 10, 57, 57, 57, 53, 124, 50, 52, 53, 53, 49, 53, 53, 46, 51, 54, 10, 51, 56, 55, 55, 124, 50, 52, 53, 51, 54, 57, 54, 46, 54, 53, 10, 53, 56, 49, 55, 124, 50, 52, 53, 50, 52, 57, 51, 46, 49, 51, 10, 49, 52, 49, 50, 50, 124, 50, 52, 53, 50, 50, 50, 54, 46, 50, 50, 10, 49, 54, 54, 57, 57, 124, 50, 52, 53, 48, 50, 55, 51, 46, 57, 56, 10, 56, 57, 50, 49, 124, 50, 52, 53, 48, 49, 49, 54, 46, 52, 56, 10, 49, 53, 49, 48, 51, 124, 50, 52, 52, 57, 56, 54, 49, 46, 50, 48, 10, 55, 54, 51, 55, 124, 50, 52, 52, 57, 54, 50, 56, 46, 55, 50, 10, 51, 48, 55, 54, 124, 50, 52, 52, 51, 57, 50, 55, 46, 51, 56, 10, 54, 54, 52, 56, 124, 50, 52, 52, 51, 50, 52, 56, 46, 57, 53, 10, 49, 55, 49, 49, 54, 124, 50, 52, 52, 50, 50, 54, 51, 46, 55, 50, 10, 49, 54, 52, 53, 124, 50, 52, 52, 48, 56, 51, 56, 46, 52, 48, 10, 51, 49, 56, 49, 124, 50, 52, 52, 48, 48, 49, 55, 46, 54, 48, 10, 53, 57, 54, 54, 124, 50, 52, 51, 49, 53, 53, 56, 46, 48, 56, 10, 49, 53, 56, 56, 50, 124, 50, 52, 50, 56, 57, 52, 55, 46, 51, 48, 10, 55, 53, 50, 57, 124, 50, 52, 50, 56, 51, 56, 49, 46, 50, 56, 10, 49, 50, 56, 51, 54, 124, 50, 52, 50, 55, 56, 57, 55, 46, 51, 51, 10, 49, 56, 48, 53, 50, 124, 50, 52, 50, 55, 54, 51, 55, 46, 55, 54, 10, 49, 51, 54, 49, 54, 124, 50, 52, 50, 54, 54, 51, 56, 46, 53, 48, 10, 49, 54, 54, 49, 53, 124, 50, 52, 50, 52, 55, 55, 53, 46, 48, 56, 10, 49, 56, 49, 52, 55, 124, 50, 52, 50, 52, 52, 49, 50, 46, 54, 56, 10, 52, 53, 56, 54, 124, 50, 52, 50, 52, 49, 50, 51, 46, 57, 48, 10, 49, 52, 52, 48, 51, 124, 50, 52, 50, 51, 49, 52, 49, 46, 57, 54, 10, 49, 49, 54, 48, 54, 124, 50, 52, 50, 50, 55, 57, 52, 46, 51, 49, 10, 49, 51, 53, 50, 54, 124, 50, 52, 50, 50, 50, 49, 50, 46, 56, 48, 10, 51, 54, 55, 55, 124, 50, 52, 50, 49, 52, 48, 52, 46, 52, 54, 10, 53, 53, 53, 51, 124, 50, 52, 49, 56, 53, 48, 54, 46, 50, 49, 10, 49, 50, 49, 48, 57, 124, 50, 52, 49, 54, 53, 49, 52, 46, 49, 55, 10, 49, 51, 49, 49, 56, 124, 50, 52, 49, 53, 57, 51, 49, 46, 56, 48, 10, 49, 53, 54, 51, 124, 50, 52, 48, 56, 56, 53, 53, 46, 52, 48, 10, 49, 54, 53, 57, 49, 124, 50, 52, 48, 56, 48, 52, 53, 46, 51, 57, 10, 54, 52, 49, 49, 124, 50, 52, 48, 52, 57, 49, 56, 46, 53, 51, 10, 49, 48, 50, 55, 50, 124, 50, 52, 48, 50, 56, 51, 52, 46, 52, 56, 10, 49, 48, 53, 57, 55, 124, 50, 52, 48, 48, 50, 52, 55, 46, 54, 56, 10, 49, 51, 55, 48, 48, 124, 50, 51, 57, 56, 48, 51, 53, 46, 56, 54, 10, 57, 53, 52, 56, 124, 50, 51, 57, 55, 49, 52, 55, 46, 57, 48, 10, 49, 52, 57, 54, 51, 124, 50, 51, 57, 53, 55, 56, 49, 46, 48, 57, 10, 49, 51, 51, 50, 53, 124, 50, 51, 57, 48, 54, 51, 55, 46, 53, 56, 10, 49, 51, 56, 54, 52, 124, 50, 51, 56, 56, 48, 54, 55, 46, 56, 56, 10, 55, 52, 53, 48, 124, 50, 51, 56, 51, 52, 52, 55, 46, 55, 49, 10, 57, 50, 55, 53, 124, 50, 51, 56, 50, 56, 54, 56, 46, 52, 48, 10, 53, 56, 50, 57, 124, 50, 51, 55, 56, 48, 51, 55, 46, 57, 50, 10, 49, 51, 52, 51, 55, 124, 50, 51, 55, 55, 56, 48, 54, 46, 53, 52, 10, 49, 51, 53, 57, 52, 124, 50, 51, 55, 53, 48, 52, 54, 46, 51, 48, 10, 49, 49, 52, 52, 50, 124, 50, 51, 55, 52, 53, 57, 49, 46, 48, 56, 10, 49, 53, 54, 49, 57, 124, 50, 51, 55, 52, 48, 53, 50, 46, 51, 56, 10, 57, 48, 54, 51, 124, 50, 51, 55, 52, 48, 51, 53, 46, 56, 52, 10, 53, 57, 57, 48, 124, 50, 51, 54, 56, 54, 56, 54, 46, 53, 48, 10, 55, 56, 49, 49, 124, 50, 51, 54, 51, 56, 50, 57, 46, 50, 54, 10, 57, 53, 50, 53, 124, 50, 51, 54, 50, 57, 55, 52, 46, 53, 51, 10, 53, 53, 57, 55, 124, 50, 51, 54, 49, 48, 51, 49, 46, 56, 52, 10, 56, 57, 54, 51, 124, 50, 51, 54, 48, 55, 55, 52, 46, 48, 48, 10, 49, 55, 48, 57, 124, 50, 51, 53, 57, 56, 51, 57, 46, 50, 57, 10, 49, 53, 56, 49, 52, 124, 50, 51, 53, 56, 54, 53, 54, 46, 54, 52, 10, 49, 55, 54, 49, 51, 124, 50, 51, 53, 55, 53, 49, 57, 46, 48, 52, 10, 53, 48, 50, 50, 124, 50, 51, 53, 52, 53, 53, 48, 46, 52, 53, 10, 49, 55, 55, 52, 48, 124, 50, 51, 53, 52, 50, 52, 50, 46, 56, 51, 10, 51, 51, 56, 56, 124, 50, 51, 53, 49, 48, 52, 50, 46, 50, 54, 10, 49, 51, 55, 55, 51, 124, 50, 51, 52, 56, 55, 51, 57, 46, 49, 50, 10, 49, 52, 52, 54, 55, 124, 50, 51, 52, 56, 54, 54, 53, 46, 48, 52, 10, 49, 49, 53, 52, 52, 124, 50, 51, 52, 53, 51, 50, 52, 46, 52, 53, 10, 51, 52, 57, 124, 50, 51, 52, 52, 54, 54, 52, 46, 49, 51, 10, 49, 48, 51, 53, 54, 124, 50, 51, 52, 48, 56, 54, 50, 46, 55, 50, 10, 49, 56, 50, 55, 50, 124, 50, 51, 51, 56, 55, 53, 52, 46, 54, 48, 10, 52, 54, 50, 55, 124, 50, 51, 51, 55, 52, 51, 48, 46, 56, 52, 10, 51, 50, 55, 124, 50, 51, 51, 53, 50, 57, 56, 46, 52, 54, 10, 49, 57, 56, 52, 54, 124, 50, 51, 51, 50, 50, 50, 52, 46, 55, 51, 10, 49, 48, 56, 49, 52, 124, 50, 51, 51, 48, 51, 49, 57, 46, 54, 48, 10, 49, 51, 49, 48, 50, 124, 50, 51, 50, 54, 49, 50, 50, 46, 55, 53, 10, 49, 56, 56, 54, 55, 124, 50, 51, 50, 51, 57, 55, 50, 46, 48, 48, 10, 50, 56, 50, 52, 124, 50, 51, 50, 51, 51, 49, 53, 46, 48, 56, 10, 49, 57, 49, 49, 55, 124, 50, 51, 49, 57, 57, 49, 49, 46, 49, 48, 10, 49, 57, 48, 54, 124, 50, 51, 49, 57, 55, 53, 55, 46, 54, 48, 10, 50, 52, 53, 124, 50, 51, 49, 57, 52, 53, 48, 46, 57, 48, 10, 49, 55, 51, 49, 56, 124, 50, 51, 49, 55, 56, 54, 48, 46, 51, 57, 10, 51, 56, 54, 50, 124, 50, 51, 49, 54, 52, 53, 51, 46, 55, 50, 10, 56, 49, 48, 48, 124, 50, 51, 49, 51, 56, 55, 52, 46, 49, 50, 10, 50, 57, 53, 56, 124, 50, 51, 49, 50, 50, 51, 57, 46, 52, 55, 10, 49, 48, 50, 54, 51, 124, 50, 51, 48, 56, 53, 49, 52, 46, 48, 54, 10, 49, 51, 56, 49, 52, 124, 50, 51, 48, 52, 57, 52, 48, 46, 52, 48, 10, 57, 51, 57, 52, 124, 50, 51, 48, 51, 49, 54, 49, 46, 55, 52, 10, 49, 56, 48, 56, 48, 124, 50, 50, 57, 57, 52, 49, 54, 46, 55, 56, 10, 49, 50, 55, 49, 124, 50, 50, 56, 57, 53, 50, 54, 46, 57, 56, 10, 51, 51, 50, 55, 124, 50, 50, 55, 56, 52, 55, 52, 46, 52, 56, 10, 56, 55, 52, 48, 124, 50, 50, 55, 56, 52, 48, 53, 46, 57, 50, 10, 56, 49, 49, 57, 124, 50, 50, 55, 54, 52, 50, 56, 46, 49, 55, 10, 51, 51, 54, 56, 124, 50, 50, 55, 52, 51, 55, 51, 46, 54, 50, 10, 55, 57, 54, 51, 124, 50, 50, 55, 50, 51, 48, 48, 46, 56, 48, 10, 50, 49, 53, 49, 124, 50, 50, 55, 48, 57, 51, 50, 46, 55, 50, 10, 49, 54, 57, 57, 53, 124, 50, 50, 55, 48, 50, 54, 52, 46, 54, 56, 10, 57, 57, 49, 56, 124, 50, 50, 54, 57, 55, 51, 51, 46, 48, 55, 10, 53, 48, 51, 124, 50, 50, 54, 56, 53, 51, 53, 46, 50, 53, 10, 49, 54, 54, 57, 50, 124, 50, 50, 53, 54, 52, 56, 52, 46, 53, 48, 10, 55, 57, 51, 124, 50, 50, 53, 52, 49, 57, 56, 46, 55, 50, 10, 49, 54, 52, 53, 53, 124, 50, 50, 53, 50, 51, 54, 49, 46, 56, 54, 10, 54, 54, 52, 52, 124, 50, 50, 52, 57, 53, 50, 49, 46, 56, 50, 10, 49, 55, 50, 56, 48, 124, 50, 50, 52, 57, 52, 51, 55, 46, 53, 48, 10, 54, 56, 49, 51, 124, 50, 50, 52, 56, 57, 56, 50, 46, 48, 48, 10, 52, 54, 55, 52, 124, 50, 50, 52, 54, 57, 49, 53, 46, 51, 50, 10, 49, 54, 51, 50, 53, 124, 50, 50, 52, 52, 51, 54, 57, 46, 56, 48, 10, 49, 56, 50, 124, 50, 50, 52, 51, 50, 57, 48, 46, 48, 48, 10, 52, 54, 50, 54, 124, 50, 50, 52, 50, 52, 55, 52, 46, 51, 53, 10, 49, 48, 56, 54, 48, 124, 50, 50, 52, 49, 50, 57, 49, 46, 54, 48, 10, 49, 52, 48, 51, 52, 124, 50, 50, 52, 49, 50, 50, 48, 46, 56, 48, 10, 50, 52, 55, 54, 124, 50, 50, 52, 48, 56, 53, 53, 46, 50, 48, 10, 52, 50, 53, 51, 124, 50, 50, 51, 57, 57, 56, 53, 46, 54, 52, 10, 51, 50, 49, 49, 124, 50, 50, 51, 57, 56, 55, 49, 46, 48, 50, 10, 49, 50, 57, 48, 124, 50, 50, 51, 51, 51, 49, 51, 46, 48, 48, 10, 56, 52, 55, 57, 124, 50, 50, 51, 50, 49, 56, 57, 46, 48, 52, 10, 49, 49, 56, 57, 53, 124, 50, 50, 51, 49, 54, 48, 55, 46, 48, 48, 10, 51, 52, 56, 55, 124, 50, 50, 51, 48, 49, 55, 49, 46, 54, 50, 10, 49, 52, 56, 55, 48, 124, 50, 50, 50, 57, 57, 49, 53, 46, 51, 55, 10, 49, 54, 51, 50, 56, 124, 50, 50, 50, 57, 52, 56, 51, 46, 57, 54, 10, 49, 56, 53, 56, 53, 124, 50, 50, 50, 56, 50, 49, 53, 46, 53, 48, 10, 55, 54, 51, 56, 124, 50, 50, 50, 56, 50, 48, 56, 46, 48, 56, 10, 53, 52, 51, 54, 124, 50, 50, 50, 53, 54, 55, 50, 46, 50, 56, 10, 49, 52, 53, 57, 52, 124, 50, 50, 50, 51, 48, 48, 53, 46, 48, 55, 10, 52, 53, 51, 50, 124, 50, 50, 49, 53, 55, 49, 49, 46, 48, 50, 10, 55, 53, 56, 54, 124, 50, 50, 49, 48, 53, 54, 50, 46, 53, 49, 10, 49, 49, 56, 55, 48, 124, 50, 50, 48, 53, 49, 56, 50, 46, 56, 50, 10, 49, 56, 52, 56, 55, 124, 50, 50, 48, 51, 54, 53, 51, 46, 54, 48, 10, 57, 49, 55, 57, 124, 50, 50, 48, 50, 55, 50, 48, 46, 53, 50, 10, 49, 54, 53, 48, 48, 124, 50, 50, 48, 49, 49, 56, 53, 46, 51, 49, 10, 51, 54, 55, 57, 124, 50, 50, 48, 48, 53, 57, 50, 46, 55, 48, 10, 49, 50, 56, 48, 51, 124, 50, 49, 57, 56, 50, 57, 53, 46, 48, 48, 10, 49, 56, 48, 53, 54, 124, 50, 49, 57, 54, 55, 52, 49, 46, 57, 48, 10, 49, 49, 51, 57, 54, 124, 50, 49, 57, 53, 54, 52, 53, 46, 54, 52, 10, 53, 48, 56, 55, 124, 50, 49, 57, 52, 49, 50, 48, 46, 55, 50, 10, 56, 48, 54, 55, 124, 50, 49, 57, 50, 48, 52, 56, 46, 54, 52, 10, 49, 53, 51, 53, 55, 124, 50, 49, 57, 49, 54, 52, 54, 46, 53, 56, 10, 52, 52, 57, 49, 124, 50, 49, 56, 57, 55, 49, 51, 46, 53, 48, 10, 50, 48, 56, 124, 50, 49, 56, 57, 48, 52, 54, 46, 56, 48, 10, 49, 48, 57, 53, 56, 124, 50, 49, 56, 56, 55, 54, 54, 46, 56, 50, 10, 57, 49, 50, 54, 124, 50, 49, 56, 56, 52, 49, 48, 46, 53, 48, 10, 49, 53, 48, 56, 52, 124, 50, 49, 56, 52, 51, 50, 55, 46, 48, 50, 10, 49, 56, 56, 53, 48, 124, 50, 49, 56, 51, 51, 48, 57, 46, 53, 50, 10, 51, 51, 57, 56, 124, 50, 49, 56, 48, 50, 53, 48, 46, 48, 48, 10, 49, 54, 49, 51, 55, 124, 50, 49, 55, 55, 51, 49, 56, 46, 55, 54, 10, 50, 49, 49, 124, 50, 49, 55, 52, 56, 48, 56, 46, 57, 54, 10, 49, 56, 52, 50, 50, 124, 50, 49, 55, 52, 51, 56, 49, 46, 48, 48, 10, 49, 53, 56, 52, 48, 124, 50, 49, 55, 51, 53, 49, 48, 46, 52, 48, 10, 49, 57, 53, 53, 51, 124, 50, 49, 55, 51, 48, 55, 57, 46, 55, 55, 10, 56, 50, 50, 49, 124, 50, 49, 54, 57, 57, 57, 50, 46, 49, 54, 10, 49, 55, 48, 48, 48, 124, 50, 49, 54, 57, 54, 49, 49, 46, 49, 54, 10, 54, 55, 53, 53, 124, 50, 49, 54, 56, 53, 48, 53, 46, 49, 53, 10, 49, 48, 56, 49, 55, 124, 50, 49, 54, 55, 55, 49, 48, 46, 54, 56, 10, 56, 51, 50, 55, 124, 50, 49, 54, 55, 54, 53, 48, 46, 54, 48, 10, 53, 52, 51, 124, 50, 49, 54, 55, 51, 54, 56, 46, 48, 48, 10, 52, 53, 53, 51, 124, 50, 49, 54, 51, 51, 55, 49, 46, 53, 50, 10, 49, 53, 48, 49, 57, 124, 50, 49, 54, 50, 50, 56, 56, 46, 48, 48, 10, 51, 51, 52, 124, 50, 49, 54, 50, 49, 55, 56, 46, 52, 56, 10, 56, 53, 49, 54, 124, 50, 49, 54, 49, 52, 55, 57, 46, 48, 52, 10, 49, 49, 51, 52, 57, 124, 50, 49, 53, 56, 57, 52, 49, 46, 56, 56, 10, 51, 57, 48, 50, 124, 50, 49, 53, 55, 48, 50, 55, 46, 56, 54, 10, 49, 52, 55, 51, 49, 124, 50, 49, 53, 53, 51, 48, 50, 46, 50, 52, 10, 51, 50, 54, 124, 50, 49, 53, 51, 51, 56, 48, 46, 48, 56, 10, 49, 49, 52, 48, 51, 124, 50, 49, 53, 49, 50, 52, 50, 46, 51, 48, 10, 49, 49, 54, 53, 55, 124, 50, 49, 53, 48, 52, 52, 54, 46, 48, 56, 10, 57, 52, 57, 54, 124, 50, 49, 52, 57, 50, 49, 57, 46, 48, 49, 10, 56, 49, 49, 48, 124, 50, 49, 52, 57, 49, 50, 48, 46, 49, 51, 10, 53, 49, 53, 51, 124, 50, 49, 52, 56, 53, 50, 55, 46, 50, 53, 10, 56, 56, 52, 124, 50, 49, 52, 56, 51, 50, 52, 46, 57, 56, 10, 56, 54, 51, 55, 124, 50, 49, 52, 54, 49, 56, 53, 46, 49, 48, 10, 50, 51, 54, 52, 124, 50, 49, 52, 53, 55, 57, 48, 46, 55, 50, 10, 49, 50, 51, 56, 54, 124, 50, 49, 52, 53, 48, 48, 49, 46, 52, 55, 10, 49, 48, 49, 51, 51, 124, 50, 49, 52, 52, 57, 48, 51, 46, 57, 54, 10, 57, 56, 57, 53, 124, 50, 49, 52, 51, 51, 50, 52, 46, 56, 48, 10, 49, 51, 55, 53, 53, 124, 50, 49, 52, 50, 53, 51, 57, 46, 52, 48, 10, 52, 51, 50, 55, 124, 50, 49, 51, 56, 53, 48, 49, 46, 52, 48, 10, 51, 51, 54, 57, 124, 50, 49, 51, 55, 52, 48, 56, 46, 55, 54, 10, 53, 56, 49, 53, 124, 50, 49, 51, 54, 57, 56, 53, 46, 48, 48, 10, 49, 57, 51, 53, 55, 124, 50, 49, 51, 50, 54, 53, 55, 46, 50, 56, 10, 50, 54, 55, 53, 124, 50, 49, 50, 52, 49, 53, 56, 46, 55, 50, 10, 49, 55, 56, 54, 57, 124, 50, 49, 50, 51, 57, 57, 49, 46, 55, 50, 10, 49, 49, 55, 48, 50, 124, 50, 49, 50, 50, 49, 51, 50, 46, 57, 57, 10, 49, 55, 50, 53, 55, 124, 50, 49, 49, 55, 56, 53, 48, 46, 54, 52, 10, 57, 57, 53, 50, 124, 50, 49, 49, 54, 54, 56, 54, 46, 51, 50, 10, 51, 56, 56, 49, 124, 50, 49, 49, 49, 52, 53, 55, 46, 49, 53, 10, 49, 48, 57, 53, 49, 124, 50, 49, 49, 49, 49, 56, 53, 46, 53, 56, 10, 50, 49, 50, 56, 124, 50, 49, 48, 57, 55, 48, 50, 46, 51, 48, 10, 54, 54, 57, 57, 124, 50, 49, 48, 54, 53, 55, 56, 46, 52, 48, 10, 51, 49, 53, 53, 124, 50, 49, 48, 51, 54, 51, 54, 46, 54, 52, 10, 49, 54, 54, 52, 57, 124, 50, 49, 48, 49, 57, 53, 54, 46, 50, 48, 10, 49, 53, 50, 53, 55, 124, 50, 49, 48, 48, 50, 57, 55, 46, 55, 53, 10, 57, 57, 55, 56, 124, 50, 48, 57, 57, 53, 54, 54, 46, 53, 54, 10, 49, 54, 56, 49, 48, 124, 50, 48, 57, 56, 51, 48, 49, 46, 52, 52, 10, 49, 48, 54, 53, 51, 124, 50, 48, 57, 51, 51, 56, 56, 46, 55, 48, 10, 49, 48, 52, 55, 54, 124, 50, 48, 57, 50, 55, 54, 54, 46, 52, 56, 10, 49, 48, 56, 56, 51, 124, 50, 48, 56, 55, 52, 57, 53, 46, 50, 56, 10, 57, 55, 48, 52, 124, 50, 48, 56, 54, 57, 54, 55, 46, 54, 49, 10, 49, 49, 49, 57, 124, 50, 48, 56, 53, 49, 56, 50, 46, 56, 52, 10, 49, 57, 49, 51, 57, 124, 50, 48, 55, 57, 55, 56, 56, 46, 51, 52, 10, 50, 49, 52, 52, 124, 50, 48, 55, 56, 51, 57, 49, 46, 49, 52, 10, 57, 49, 51, 53, 124, 50, 48, 55, 54, 51, 55, 55, 46, 56, 48, 10, 49, 56, 53, 52, 56, 124, 50, 48, 55, 53, 53, 56, 52, 46, 51, 50, 10, 49, 48, 53, 52, 53, 124, 50, 48, 55, 53, 50, 51, 48, 46, 51, 53, 10, 54, 50, 50, 48, 124, 50, 48, 55, 52, 51, 52, 49, 46, 55, 50, 10, 56, 54, 49, 54, 124, 50, 48, 55, 50, 56, 56, 55, 46, 54, 53, 10, 53, 50, 51, 48, 124, 50, 48, 55, 50, 49, 54, 49, 46, 55, 52, 10, 49, 51, 57, 49, 54, 124, 50, 48, 55, 48, 53, 48, 52, 46, 55, 50, 10, 52, 50, 57, 57, 124, 50, 48, 54, 57, 57, 50, 50, 46, 57, 54, 10, 56, 57, 52, 124, 50, 48, 54, 57, 54, 56, 56, 46, 49, 54, 10, 49, 55, 56, 52, 55, 124, 50, 48, 54, 51, 51, 54, 55, 46, 48, 52, 10, 49, 56, 56, 55, 57, 124, 50, 48, 54, 49, 57, 48, 50, 46, 50, 53, 10, 49, 51, 48, 51, 54, 124, 50, 48, 54, 49, 54, 48, 48, 46, 49, 55, 10, 49, 48, 54, 48, 54, 124, 50, 48, 54, 48, 52, 57, 50, 46, 52, 48, 10, 57, 52, 53, 52, 124, 50, 48, 54, 48, 48, 49, 54, 46, 52, 56, 10, 49, 49, 56, 124, 50, 48, 53, 57, 56, 48, 56, 46, 56, 54, 10, 57, 54, 48, 49, 124, 50, 48, 53, 57, 55, 49, 53, 46, 55, 54, 10, 49, 51, 55, 54, 57, 124, 50, 48, 53, 55, 54, 54, 56, 46, 48, 56, 10, 49, 57, 56, 55, 124, 50, 48, 53, 55, 50, 56, 57, 46, 50, 55, 10, 49, 51, 56, 54, 51, 124, 50, 48, 53, 53, 51, 54, 56, 46, 48, 48, 10, 49, 51, 53, 54, 50, 124, 50, 48, 53, 52, 55, 53, 52, 46, 50, 52, 10, 49, 56, 52, 48, 124, 50, 48, 53, 52, 49, 56, 51, 46, 57, 50, 10, 49, 55, 57, 57, 53, 124, 50, 48, 53, 51, 50, 50, 49, 46, 57, 48, 10, 49, 55, 51, 56, 57, 124, 50, 48, 53, 49, 49, 50, 56, 46, 50, 48, 10, 49, 53, 49, 54, 56, 124, 50, 48, 52, 53, 57, 56, 55, 46, 52, 57, 10, 50, 49, 51, 57, 124, 50, 48, 52, 53, 51, 54, 53, 46, 52, 48, 10, 52, 48, 50, 52, 124, 50, 48, 52, 52, 50, 52, 51, 46, 49, 48, 10, 56, 57, 54, 52, 124, 50, 48, 52, 49, 54, 52, 56, 46, 56, 53, 10, 49, 56, 49, 124, 50, 48, 52, 48, 49, 54, 55, 46, 48, 52, 10, 55, 54, 50, 56, 124, 50, 48, 51, 57, 53, 52, 56, 46, 57, 50, 10, 51, 124, 50, 48, 51, 56, 56, 52, 54, 46, 48, 57, 10, 49, 53, 53, 53, 51, 124, 50, 48, 51, 54, 57, 53, 56, 46, 57, 49, 10, 49, 49, 51, 53, 53, 124, 50, 48, 51, 53, 52, 48, 53, 46, 54, 48, 10, 49, 51, 48, 48, 54, 124, 50, 48, 51, 52, 57, 57, 49, 46, 50, 48, 10, 51, 48, 57, 49, 124, 50, 48, 51, 49, 51, 57, 51, 46, 53, 49, 10, 49, 50, 56, 49, 124, 50, 48, 51, 48, 54, 50, 56, 46, 52, 56, 10, 49, 52, 48, 56, 124, 50, 48, 50, 56, 54, 50, 49, 46, 54, 54, 10, 49, 56, 50, 49, 49, 124, 50, 48, 50, 52, 53, 51, 56, 46, 54, 55, 10, 50, 50, 56, 55, 124, 50, 48, 50, 48, 55, 53, 52, 46, 51, 50, 10, 54, 50, 50, 56, 124, 50, 48, 49, 57, 49, 57, 56, 46, 56, 50, 10, 52, 51, 54, 50, 124, 50, 48, 49, 56, 52, 57, 53, 46, 50, 53, 10, 49, 48, 56, 55, 51, 124, 50, 48, 49, 51, 50, 56, 48, 46, 51, 50, 10, 55, 51, 56, 51, 124, 50, 48, 48, 57, 53, 56, 49, 46, 57, 50, 10, 49, 51, 56, 54, 124, 50, 48, 48, 54, 53, 52, 52, 46, 50, 54, 10, 57, 56, 50, 48, 124, 50, 48, 48, 53, 56, 49, 53, 46, 55, 54, 10, 49, 56, 49, 51, 52, 124, 50, 48, 48, 51, 52, 48, 57, 46, 55, 51, 10, 49, 53, 55, 50, 55, 124, 50, 48, 48, 48, 54, 53, 52, 46, 53, 48, 10, 49, 53, 55, 124, 50, 48, 48, 48, 49, 52, 56, 46, 49, 54, 10, 49, 57, 53, 55, 49, 124, 49, 57, 57, 57, 56, 57, 49, 46, 49, 49, 10, 49, 55, 55, 50, 56, 124, 49, 57, 57, 55, 57, 52, 52, 46, 52, 48, 10, 53, 50, 55, 56, 124, 49, 57, 57, 54, 54, 52, 52, 46, 50, 49, 10, 49, 55, 55, 51, 55, 124, 49, 57, 57, 52, 54, 53, 51, 46, 55, 54, 10, 49, 48, 50, 50, 48, 124, 49, 57, 56, 57, 56, 57, 48, 46, 57, 56, 10, 49, 51, 57, 55, 124, 49, 57, 56, 52, 53, 48, 57, 46, 50, 50, 10, 54, 49, 57, 53, 124, 49, 57, 56, 51, 57, 50, 56, 46, 50, 54, 10, 52, 50, 55, 48, 124, 49, 57, 56, 51, 55, 50, 54, 46, 57, 53, 10, 49, 54, 57, 54, 53, 124, 49, 57, 56, 51, 50, 56, 54, 46, 50, 53, 10, 49, 54, 56, 51, 124, 49, 57, 56, 48, 54, 51, 56, 46, 54, 52, 10, 49, 51, 48, 56, 54, 124, 49, 57, 55, 56, 54, 48, 57, 46, 52, 48, 10, 55, 49, 50, 52, 124, 49, 57, 55, 52, 48, 51, 57, 46, 51, 56, 10, 53, 50, 49, 49, 124, 49, 57, 55, 51, 56, 52, 51, 46, 55, 54, 10, 54, 55, 57, 52, 124, 49, 57, 55, 51, 49, 52, 57, 46, 52, 55, 10, 50, 53, 55, 124, 49, 57, 55, 51, 48, 51, 53, 46, 52, 52, 10, 54, 57, 57, 53, 124, 49, 57, 54, 56, 50, 56, 49, 46, 53, 53, 10, 56, 52, 52, 55, 124, 49, 57, 54, 55, 50, 57, 50, 46, 55, 48, 10, 49, 53, 56, 55, 51, 124, 49, 57, 54, 55, 50, 53, 55, 46, 56, 57, 10, 49, 50, 56, 54, 50, 124, 49, 57, 54, 52, 48, 49, 52, 46, 49, 51, 10, 56, 50, 57, 53, 124, 49, 57, 54, 49, 52, 54, 55, 46, 48, 56, 10, 57, 51, 49, 124, 49, 57, 53, 56, 56, 50, 53, 46, 50, 50, 10, 54, 56, 55, 54, 124, 49, 57, 53, 55, 51, 53, 57, 46, 52, 56, 10, 49, 57, 51, 50, 124, 49, 57, 53, 52, 53, 57, 50, 46, 52, 48, 10, 49, 48, 54, 49, 124, 49, 57, 53, 50, 54, 56, 56, 46, 48, 54, 10, 49, 56, 49, 48, 56, 124, 49, 57, 53, 49, 49, 52, 51, 46, 54, 55, 10, 53, 49, 51, 56, 124, 49, 57, 53, 48, 56, 54, 49, 46, 48, 48, 10, 49, 50, 53, 57, 56, 124, 49, 57, 53, 48, 50, 49, 49, 46, 54, 49, 10, 49, 48, 56, 50, 57, 124, 49, 57, 52, 51, 57, 50, 52, 46, 54, 50, 10, 49, 49, 57, 53, 48, 124, 49, 57, 52, 49, 50, 49, 49, 46, 48, 48, 10, 49, 50, 48, 55, 54, 124, 49, 57, 51, 57, 51, 50, 51, 46, 57, 54, 10, 50, 49, 55, 54, 124, 49, 57, 51, 56, 54, 57, 49, 46, 51, 55, 10, 54, 54, 49, 54, 124, 49, 57, 51, 55, 52, 48, 49, 46, 56, 56, 10, 53, 56, 57, 51, 124, 49, 57, 51, 52, 51, 53, 56, 46, 53, 56, 10, 57, 55, 54, 124, 49, 57, 51, 51, 48, 54, 54, 46, 56, 48, 10, 49, 51, 49, 55, 51, 124, 49, 57, 51, 50, 53, 53, 55, 46, 53, 50, 10, 49, 52, 57, 52, 55, 124, 49, 57, 50, 57, 50, 50, 57, 46, 57, 56, 10, 49, 54, 56, 53, 55, 124, 49, 57, 50, 56, 56, 49, 52, 46, 56, 48, 10, 49, 51, 52, 48, 51, 124, 49, 57, 50, 56, 55, 48, 50, 46, 56, 56, 10, 52, 56, 49, 57, 124, 49, 57, 50, 54, 57, 54, 57, 46, 54, 56, 10, 49, 51, 49, 50, 55, 124, 49, 57, 50, 54, 57, 50, 57, 46, 56, 51, 10, 54, 56, 55, 49, 124, 49, 57, 50, 54, 55, 56, 55, 46, 54, 56, 10, 49, 53, 52, 54, 53, 124, 49, 57, 50, 53, 49, 52, 53, 46, 48, 57, 10, 49, 49, 51, 49, 124, 49, 57, 50, 48, 48, 48, 53, 46, 53, 48, 10, 49, 49, 56, 52, 53, 124, 49, 57, 49, 51, 53, 55, 54, 46, 52, 48, 10, 56, 51, 54, 52, 124, 49, 57, 48, 57, 49, 50, 50, 46, 50, 48, 10, 49, 54, 53, 56, 56, 124, 49, 57, 48, 52, 50, 55, 50, 46, 51, 55, 10, 54, 55, 53, 57, 124, 49, 57, 48, 51, 57, 48, 54, 46, 50, 57, 10, 49, 49, 53, 56, 54, 124, 49, 57, 48, 49, 56, 57, 53, 46, 54, 53, 10, 56, 49, 52, 53, 124, 49, 57, 48, 49, 55, 56, 55, 46, 54, 54, 10, 49, 55, 51, 51, 51, 124, 49, 56, 57, 55, 50, 57, 55, 46, 50, 48, 10, 49, 51, 50, 57, 48, 124, 49, 56, 57, 48, 54, 51, 51, 46, 55, 53, 10, 54, 52, 57, 57, 124, 49, 56, 56, 55, 54, 50, 49, 46, 48, 48, 10, 52, 56, 56, 49, 124, 49, 56, 56, 55, 53, 51, 53, 46, 57, 50, 10, 55, 49, 52, 55, 124, 49, 56, 56, 54, 55, 49, 48, 46, 50, 48, 10, 51, 56, 56, 51, 124, 49, 56, 56, 54, 53, 54, 55, 46, 55, 56, 10, 49, 56, 57, 49, 49, 124, 49, 56, 56, 53, 53, 57, 55, 46, 49, 50, 10, 49, 49, 51, 51, 54, 124, 49, 56, 56, 51, 53, 55, 51, 46, 54, 48, 10, 56, 54, 53, 51, 124, 49, 56, 56, 51, 50, 55, 53, 46, 55, 54, 10, 49, 57, 52, 55, 54, 124, 49, 56, 56, 49, 52, 57, 50, 46, 52, 56, 10, 49, 52, 55, 57, 57, 124, 49, 56, 56, 48, 53, 52, 51, 46, 52, 48, 10, 49, 52, 52, 57, 49, 124, 49, 56, 55, 57, 50, 49, 57, 46, 57, 50, 10, 49, 49, 56, 49, 53, 124, 49, 56, 55, 55, 52, 51, 52, 46, 51, 52, 10, 51, 49, 55, 51, 124, 49, 56, 55, 52, 51, 48, 50, 46, 49, 48, 10, 55, 49, 54, 49, 124, 49, 56, 55, 51, 48, 50, 51, 46, 52, 53, 10, 49, 52, 54, 51, 49, 124, 49, 56, 55, 51, 48, 49, 53, 46, 51, 48, 10, 52, 50, 52, 55, 124, 49, 56, 54, 57, 57, 49, 50, 46, 57, 54, 10, 51, 53, 54, 56, 124, 49, 56, 54, 53, 56, 50, 52, 46, 52, 48, 10, 49, 53, 48, 48, 124, 49, 56, 54, 53, 52, 53, 49, 46, 48, 51, 10, 49, 49, 56, 51, 51, 124, 49, 56, 54, 51, 54, 54, 53, 46, 50, 51, 10, 52, 57, 53, 124, 49, 56, 54, 48, 55, 55, 49, 46, 51, 48, 10, 54, 55, 55, 54, 124, 49, 56, 53, 53, 53, 56, 57, 46, 49, 55, 10, 49, 49, 51, 55, 52, 124, 49, 56, 53, 53, 50, 50, 49, 46, 49, 50, 10, 53, 54, 51, 55, 124, 49, 56, 53, 51, 55, 56, 50, 46, 49, 55, 10, 51, 53, 57, 55, 124, 49, 56, 53, 50, 56, 50, 54, 46, 56, 48, 10, 57, 56, 49, 124, 49, 56, 53, 50, 48, 56, 51, 46, 54, 48, 10, 49, 54, 48, 55, 54, 124, 49, 56, 53, 48, 51, 52, 57, 46, 54, 57, 10, 49, 55, 53, 57, 55, 124, 49, 56, 52, 53, 52, 50, 48, 46, 57, 53, 10, 49, 57, 54, 48, 57, 124, 49, 56, 52, 51, 49, 56, 53, 46, 52, 56, 10, 49, 48, 57, 57, 55, 124, 49, 56, 52, 51, 48, 55, 50, 46, 48, 50, 10, 51, 52, 48, 51, 124, 49, 56, 52, 50, 57, 55, 53, 46, 48, 48, 10, 56, 57, 55, 124, 49, 56, 52, 50, 56, 52, 53, 46, 49, 48, 10, 49, 54, 54, 57, 55, 124, 49, 56, 52, 48, 54, 51, 48, 46, 54, 56, 10, 49, 55, 54, 52, 52, 124, 49, 56, 52, 48, 53, 57, 55, 46, 56, 48, 10, 54, 52, 56, 53, 124, 49, 56, 51, 56, 56, 49, 50, 46, 48, 50, 10, 53, 52, 57, 50, 124, 49, 56, 51, 54, 50, 48, 50, 46, 56, 56, 10, 49, 50, 48, 51, 56, 124, 49, 56, 51, 53, 48, 55, 53, 46, 48, 54, 10, 57, 51, 50, 53, 124, 49, 56, 51, 50, 54, 51, 52, 46, 56, 52, 10, 49, 48, 54, 51, 55, 124, 49, 56, 51, 50, 51, 52, 55, 46, 52, 52, 10, 49, 49, 51, 49, 56, 124, 49, 56, 51, 48, 49, 53, 56, 46, 51, 57, 10, 52, 51, 53, 55, 124, 49, 56, 50, 56, 55, 51, 48, 46, 48, 48, 10, 49, 56, 53, 53, 51, 124, 49, 56, 50, 54, 51, 51, 53, 46, 50, 48, 10, 49, 50, 54, 50, 51, 124, 49, 56, 50, 53, 57, 53, 48, 46, 56, 53, 10, 57, 54, 49, 124, 49, 56, 50, 53, 56, 54, 57, 46, 54, 48, 10, 49, 54, 55, 55, 124, 49, 56, 50, 49, 56, 49, 54, 46, 57, 48, 10, 56, 50, 49, 49, 124, 49, 56, 50, 48, 52, 51, 50, 46, 53, 50, 10, 49, 57, 55, 49, 57, 124, 49, 56, 49, 57, 51, 51, 51, 46, 53, 53, 10, 49, 57, 54, 54, 51, 124, 49, 56, 49, 57, 48, 55, 52, 46, 51, 53, 10, 49, 54, 50, 57, 54, 124, 49, 56, 49, 56, 51, 53, 51, 46, 55, 55, 10, 49, 54, 53, 50, 55, 124, 49, 56, 49, 55, 56, 51, 52, 46, 52, 50, 10, 52, 57, 54, 52, 124, 49, 56, 49, 53, 52, 48, 48, 46, 48, 50, 10, 49, 55, 54, 57, 124, 49, 56, 49, 50, 57, 50, 57, 46, 50, 48, 10, 49, 51, 49, 50, 54, 124, 49, 56, 48, 56, 55, 57, 57, 46, 57, 54, 10, 55, 56, 53, 52, 124, 49, 56, 48, 55, 54, 48, 56, 46, 48, 54, 10, 49, 56, 51, 56, 48, 124, 49, 56, 48, 51, 54, 52, 49, 46, 50, 50, 10, 54, 53, 56, 52, 124, 49, 56, 48, 50, 51, 52, 54, 46, 57, 56, 10, 55, 54, 54, 53, 124, 49, 56, 48, 49, 55, 54, 53, 46, 51, 53, 10, 49, 54, 53, 53, 51, 124, 49, 55, 57, 54, 49, 52, 54, 46, 55, 56, 10, 49, 55, 55, 54, 49, 124, 49, 55, 57, 53, 48, 57, 53, 46, 55, 50, 10, 49, 49, 49, 55, 57, 124, 49, 55, 57, 52, 56, 57, 48, 46, 51, 48, 10, 49, 53, 49, 55, 49, 124, 49, 55, 57, 52, 49, 52, 56, 46, 55, 50, 10, 51, 48, 49, 56, 124, 49, 55, 57, 51, 49, 56, 51, 46, 56, 56, 10, 49, 53, 55, 52, 49, 124, 49, 55, 56, 56, 54, 49, 50, 46, 48, 48, 10, 53, 51, 51, 49, 124, 49, 55, 56, 51, 57, 48, 49, 46, 51, 53, 10, 57, 56, 54, 48, 124, 49, 55, 55, 53, 48, 55, 49, 46, 50, 54, 10, 55, 57, 56, 52, 124, 49, 55, 55, 52, 51, 48, 50, 46, 55, 53, 10, 49, 53, 51, 53, 52, 124, 49, 55, 55, 52, 50, 55, 48, 46, 55, 55, 10, 49, 55, 56, 56, 52, 124, 49, 55, 55, 52, 50, 49, 50, 46, 52, 52, 10, 49, 54, 50, 53, 55, 124, 49, 55, 55, 49, 56, 54, 57, 46, 55, 49, 10, 49, 48, 54, 57, 54, 124, 49, 55, 54, 56, 54, 52, 53, 46, 50, 48, 10, 50, 49, 48, 52, 124, 49, 55, 54, 55, 57, 48, 50, 46, 54, 52, 10, 49, 52, 52, 54, 53, 124, 49, 55, 54, 52, 57, 52, 54, 46, 52, 48, 10, 49, 48, 48, 56, 57, 124, 49, 55, 54, 52, 54, 57, 50, 46, 51, 50, 10, 54, 55, 49, 57, 124, 49, 55, 54, 50, 54, 57, 57, 46, 53, 52, 10, 51, 54, 52, 56, 124, 49, 55, 54, 48, 53, 57, 52, 46, 52, 50, 10, 55, 50, 52, 49, 124, 49, 55, 53, 57, 57, 49, 51, 46, 53, 57, 10, 49, 49, 49, 50, 50, 124, 49, 55, 53, 55, 52, 51, 48, 46, 48, 52, 10, 49, 55, 48, 49, 57, 124, 49, 55, 53, 50, 53, 54, 48, 46, 54, 53, 10, 49, 51, 56, 55, 55, 124, 49, 55, 52, 52, 50, 55, 49, 46, 49, 48, 10, 49, 53, 51, 50, 53, 124, 49, 55, 52, 51, 56, 50, 54, 46, 50, 54, 10, 49, 55, 56, 54, 48, 124, 49, 55, 51, 57, 56, 55, 48, 46, 52, 52, 10, 50, 50, 51, 54, 124, 49, 55, 51, 57, 55, 57, 53, 46, 56, 48, 10, 52, 52, 51, 54, 124, 49, 55, 51, 56, 55, 54, 48, 46, 51, 50, 10, 55, 55, 48, 49, 124, 49, 55, 51, 56, 54, 55, 48, 46, 52, 48, 10, 56, 49, 52, 55, 124, 49, 55, 51, 54, 56, 53, 53, 46, 49, 54, 10, 54, 54, 55, 54, 124, 49, 55, 51, 54, 51, 52, 49, 46, 52, 52, 10, 49, 57, 53, 48, 53, 124, 49, 55, 51, 53, 52, 49, 51, 46, 52, 51, 10, 57, 56, 56, 53, 124, 49, 55, 51, 49, 51, 54, 54, 46, 50, 54, 10, 50, 49, 49, 50, 124, 49, 55, 50, 53, 57, 51, 52, 46, 48, 56, 10, 53, 51, 51, 48, 124, 49, 55, 50, 50, 49, 57, 54, 46, 57, 56, 10, 51, 53, 54, 49, 124, 49, 55, 50, 48, 51, 55, 55, 46, 57, 54, 10, 49, 48, 49, 48, 52, 124, 49, 55, 49, 52, 52, 49, 57, 46, 49, 54, 10, 49, 54, 51, 54, 50, 124, 49, 55, 49, 50, 52, 53, 55, 46, 51, 56, 10, 49, 53, 53, 55, 51, 124, 49, 55, 49, 50, 51, 54, 53, 46, 52, 52, 10, 49, 53, 48, 48, 54, 124, 49, 55, 49, 49, 51, 56, 49, 46, 51, 53, 10, 49, 52, 54, 50, 57, 124, 49, 55, 48, 57, 57, 52, 50, 46, 48, 53, 10, 57, 54, 49, 50, 124, 49, 55, 48, 57, 53, 50, 56, 46, 51, 56, 10, 49, 57, 57, 49, 48, 124, 49, 55, 48, 57, 50, 49, 49, 46, 49, 53, 10, 49, 51, 49, 52, 53, 124, 49, 55, 48, 56, 57, 48, 55, 46, 52, 54, 10, 49, 49, 52, 57, 52, 124, 49, 55, 48, 55, 57, 55, 51, 46, 54, 56, 10, 49, 53, 56, 57, 53, 124, 49, 55, 48, 54, 57, 57, 57, 46, 52, 53, 10, 56, 50, 51, 57, 124, 49, 55, 48, 53, 52, 55, 57, 46, 49, 48, 10, 50, 52, 48, 51, 124, 49, 55, 48, 53, 51, 51, 49, 46, 49, 48, 10, 49, 57, 52, 51, 54, 124, 49, 55, 48, 50, 55, 48, 54, 46, 48, 48, 10, 51, 52, 55, 54, 124, 49, 55, 48, 50, 51, 51, 53, 46, 56, 48, 10, 54, 56, 50, 56, 124, 49, 55, 48, 50, 50, 57, 50, 46, 48, 56, 10, 55, 55, 49, 124, 49, 55, 48, 49, 53, 56, 57, 46, 53, 48, 10, 56, 52, 52, 56, 124, 49, 55, 48, 48, 51, 49, 50, 46, 52, 52, 10, 51, 55, 53, 53, 124, 49, 54, 57, 57, 48, 52, 55, 46, 48, 51, 10, 49, 51, 56, 57, 53, 124, 49, 54, 57, 56, 54, 55, 57, 46, 48, 51, 10, 57, 55, 56, 53, 124, 49, 54, 57, 56, 48, 53, 54, 46, 51, 55, 10, 54, 49, 56, 48, 124, 49, 54, 57, 53, 53, 55, 49, 46, 53, 51, 10, 53, 51, 50, 124, 49, 54, 57, 52, 51, 53, 54, 46, 49, 53, 10, 54, 55, 52, 49, 124, 49, 54, 57, 50, 53, 53, 50, 46, 52, 50, 10, 49, 57, 57, 54, 52, 124, 49, 54, 57, 50, 51, 54, 55, 46, 54, 52, 10, 51, 55, 52, 55, 124, 49, 54, 57, 49, 50, 52, 52, 46, 54, 48, 10, 51, 50, 53, 51, 124, 49, 54, 57, 48, 55, 49, 57, 46, 52, 50, 10, 49, 54, 49, 49, 57, 124, 49, 54, 56, 56, 51, 51, 57, 46, 50, 53, 10, 55, 49, 49, 51, 124, 49, 54, 56, 49, 57, 49, 49, 46, 48, 48, 10, 49, 50, 51, 54, 56, 124, 49, 54, 56, 49, 50, 49, 57, 46, 56, 48, 10, 49, 54, 51, 55, 56, 124, 49, 54, 55, 57, 55, 48, 53, 46, 54, 48, 10, 49, 51, 57, 51, 124, 49, 54, 55, 53, 53, 52, 53, 46, 51, 53, 10, 49, 49, 49, 49, 57, 124, 49, 54, 55, 53, 52, 53, 51, 46, 52, 52, 10, 52, 52, 54, 57, 124, 49, 54, 55, 52, 48, 50, 51, 46, 52, 57, 10, 54, 57, 53, 53, 124, 49, 54, 55, 50, 54, 49, 56, 46, 57, 48, 10, 49, 49, 53, 55, 57, 124, 49, 54, 55, 50, 51, 52, 53, 46, 51, 50, 10, 49, 57, 56, 57, 56, 124, 49, 54, 55, 49, 55, 56, 49, 46, 55, 48, 10, 49, 53, 51, 53, 49, 124, 49, 54, 53, 57, 50, 48, 52, 46, 51, 48, 10, 54, 49, 51, 51, 124, 49, 54, 53, 56, 50, 49, 53, 46, 52, 54, 10, 57, 49, 49, 48, 124, 49, 54, 53, 56, 48, 53, 52, 46, 54, 56, 10, 50, 57, 55, 57, 124, 49, 54, 53, 54, 48, 49, 54, 46, 55, 52, 10, 49, 56, 55, 54, 52, 124, 49, 54, 53, 51, 55, 48, 56, 46, 52, 56, 10, 56, 57, 57, 53, 124, 49, 54, 53, 51, 54, 50, 55, 46, 53, 56, 10, 49, 51, 48, 57, 54, 124, 49, 54, 53, 49, 52, 48, 56, 46, 54, 55, 10, 49, 53, 48, 54, 50, 124, 49, 54, 53, 48, 53, 52, 56, 46, 48, 50, 10, 55, 57, 50, 52, 124, 49, 54, 53, 48, 50, 48, 50, 46, 52, 48, 10, 49, 48, 48, 55, 54, 124, 49, 54, 52, 55, 57, 55, 48, 46, 50, 52, 10, 49, 53, 56, 53, 57, 124, 49, 54, 52, 54, 48, 51, 54, 46, 50, 56, 10, 49, 55, 57, 51, 50, 124, 49, 54, 52, 50, 54, 52, 48, 46, 54, 54, 10, 49, 57, 54, 57, 52, 124, 49, 54, 52, 50, 48, 56, 57, 46, 53, 48, 10, 49, 51, 56, 50, 55, 124, 49, 54, 52, 50, 48, 48, 49, 46, 51, 49, 10, 49, 55, 57, 54, 51, 124, 49, 54, 51, 57, 54, 56, 57, 46, 48, 48, 10, 49, 48, 54, 57, 56, 124, 49, 54, 51, 53, 56, 52, 56, 46, 50, 54, 10, 49, 56, 48, 48, 51, 124, 49, 54, 51, 51, 53, 51, 48, 46, 55, 56, 10, 56, 52, 49, 54, 124, 49, 54, 51, 51, 51, 54, 54, 46, 55, 55, 10, 52, 55, 54, 124, 49, 54, 51, 49, 49, 53, 52, 46, 48, 54, 10, 50, 56, 48, 54, 124, 49, 54, 51, 48, 55, 56, 50, 46, 56, 48, 10, 49, 50, 49, 50, 57, 124, 49, 54, 50, 56, 54, 49, 53, 46, 52, 55, 10, 49, 49, 50, 49, 53, 124, 49, 54, 50, 54, 54, 50, 52, 46, 55, 48, 10, 49, 52, 48, 54, 49, 124, 49, 54, 50, 52, 57, 51, 51, 46, 52, 52, 10, 53, 57, 53, 54, 124, 49, 54, 50, 51, 53, 56, 54, 46, 49, 48, 10, 57, 48, 52, 51, 124, 49, 54, 50, 50, 54, 55, 48, 46, 52, 48, 10, 49, 51, 50, 56, 55, 124, 49, 54, 50, 49, 57, 56, 48, 46, 51, 54, 10, 49, 49, 52, 49, 48, 124, 49, 54, 50, 49, 52, 50, 48, 46, 57, 48, 10, 49, 51, 57, 57, 48, 124, 49, 54, 50, 49, 50, 54, 56, 46, 50, 48, 10, 49, 50, 57, 53, 50, 124, 49, 54, 49, 57, 50, 49, 53, 46, 49, 56, 10, 49, 53, 49, 56, 49, 124, 49, 54, 49, 57, 48, 56, 56, 46, 54, 56, 10, 57, 55, 56, 52, 124, 49, 54, 49, 56, 49, 50, 48, 46, 53, 51, 10, 49, 48, 55, 51, 51, 124, 49, 54, 49, 54, 49, 54, 56, 46, 56, 56, 10, 49, 54, 48, 53, 52, 124, 49, 54, 49, 52, 53, 51, 49, 46, 50, 51, 10, 53, 56, 54, 52, 124, 49, 54, 49, 52, 51, 57, 55, 46, 56, 51, 10, 49, 56, 55, 53, 124, 49, 54, 49, 49, 57, 50, 55, 46, 48, 48, 10, 49, 55, 51, 56, 49, 124, 49, 54, 49, 49, 54, 54, 52, 46, 56, 48, 10, 49, 52, 53, 54, 50, 124, 49, 54, 48, 55, 52, 54, 55, 46, 57, 50, 10, 53, 55, 53, 124, 49, 54, 48, 53, 57, 52, 49, 46, 55, 51, 10, 50, 48, 48, 53, 124, 49, 54, 48, 53, 53, 57, 49, 46, 55, 50, 10, 52, 51, 51, 50, 124, 49, 54, 48, 53, 52, 52, 56, 46, 56, 51, 10, 52, 54, 53, 51, 124, 49, 54, 48, 50, 53, 57, 54, 46, 51, 48, 10, 49, 53, 52, 48, 51, 124, 49, 54, 48, 49, 56, 51, 48, 46, 52, 52, 10, 49, 55, 52, 51, 48, 124, 49, 53, 57, 57, 54, 56, 49, 46, 52, 50, 10, 52, 55, 57, 56, 124, 49, 53, 57, 51, 54, 51, 48, 46, 53, 48, 10, 49, 50, 57, 57, 49, 124, 49, 53, 57, 51, 51, 50, 49, 46, 53, 50, 10, 49, 53, 54, 53, 51, 124, 49, 53, 57, 51, 49, 51, 56, 46, 54, 54, 10, 49, 48, 48, 54, 54, 124, 49, 53, 57, 51, 48, 52, 57, 46, 48, 54, 10, 56, 56, 57, 50, 124, 49, 53, 57, 50, 49, 48, 48, 46, 57, 48, 10, 54, 55, 48, 56, 124, 49, 53, 57, 48, 49, 53, 57, 46, 49, 50, 10, 57, 56, 50, 53, 124, 49, 53, 56, 57, 52, 48, 51, 46, 57, 50, 10, 56, 50, 55, 49, 124, 49, 53, 56, 56, 52, 55, 53, 46, 52, 49, 10, 49, 55, 48, 56, 52, 124, 49, 53, 56, 52, 50, 56, 48, 46, 56, 56, 10, 52, 48, 48, 51, 124, 49, 53, 56, 51, 54, 51, 49, 46, 48, 48, 10, 56, 54, 57, 124, 49, 53, 56, 50, 54, 52, 51, 46, 49, 54, 10, 49, 54, 52, 48, 48, 124, 49, 53, 56, 50, 51, 49, 51, 46, 50, 48, 10, 49, 57, 48, 56, 56, 124, 49, 53, 56, 49, 55, 48, 56, 46, 53, 54, 10, 54, 53, 56, 49, 124, 49, 53, 56, 49, 51, 52, 54, 46, 56, 48, 10, 57, 52, 56, 49, 124, 49, 53, 56, 49, 48, 52, 56, 46, 54, 48, 10, 54, 48, 57, 50, 124, 49, 53, 56, 48, 56, 52, 54, 46, 52, 57, 10, 51, 54, 50, 52, 124, 49, 53, 55, 56, 55, 55, 55, 46, 51, 48, 10, 54, 53, 48, 51, 124, 49, 53, 55, 56, 53, 48, 55, 46, 55, 56, 10, 49, 52, 53, 53, 55, 124, 49, 53, 55, 56, 50, 56, 48, 46, 57, 54, 10, 50, 52, 50, 56, 124, 49, 53, 55, 55, 53, 52, 51, 46, 57, 50, 10, 49, 53, 53, 49, 51, 124, 49, 53, 55, 51, 53, 54, 48, 46, 50, 49, 10, 52, 54, 52, 49, 124, 49, 53, 55, 51, 51, 54, 51, 46, 53, 52, 10, 49, 48, 49, 53, 50, 124, 49, 53, 55, 48, 50, 49, 51, 46, 54, 48, 10, 53, 57, 51, 50, 124, 49, 53, 54, 54, 57, 48, 50, 46, 53, 50, 10, 55, 52, 56, 50, 124, 49, 53, 54, 49, 51, 50, 51, 46, 53, 48, 10, 49, 51, 55, 52, 53, 124, 49, 53, 53, 56, 51, 53, 56, 46, 51, 52, 10, 50, 50, 53, 49, 124, 49, 53, 53, 56, 50, 55, 52, 46, 55, 48, 10, 57, 56, 52, 53, 124, 49, 53, 53, 56, 48, 54, 56, 46, 49, 50, 10, 55, 54, 48, 51, 124, 49, 53, 53, 55, 51, 56, 56, 46, 50, 48, 10, 49, 56, 48, 57, 124, 49, 53, 53, 51, 56, 51, 55, 46, 50, 48, 10, 49, 56, 49, 50, 56, 124, 49, 53, 52, 55, 54, 52, 51, 46, 51, 54, 10, 56, 48, 56, 54, 124, 49, 53, 52, 51, 49, 57, 57, 46, 48, 52, 10, 49, 52, 57, 52, 56, 124, 49, 53, 52, 49, 55, 50, 49, 46, 53, 55, 10, 49, 54, 55, 50, 53, 124, 49, 53, 52, 48, 57, 52, 56, 46, 53, 48, 10, 50, 57, 57, 57, 124, 49, 53, 52, 48, 51, 49, 55, 46, 54, 54, 10, 56, 56, 54, 49, 124, 49, 53, 52, 48, 48, 48, 56, 46, 52, 55, 10, 49, 57, 54, 52, 124, 49, 53, 51, 56, 56, 49, 53, 46, 50, 53, 10, 49, 57, 51, 55, 52, 124, 49, 53, 51, 55, 56, 56, 52, 46, 55, 56, 10, 49, 53, 52, 50, 56, 124, 49, 53, 51, 53, 57, 57, 52, 46, 51, 54, 10, 55, 52, 52, 57, 124, 49, 53, 51, 52, 55, 56, 50, 46, 52, 56, 10, 49, 54, 56, 56, 52, 124, 49, 53, 51, 52, 53, 48, 57, 46, 49, 54, 10, 49, 48, 50, 55, 49, 124, 49, 53, 51, 52, 51, 57, 55, 46, 51, 52, 10, 49, 49, 55, 56, 50, 124, 49, 53, 50, 57, 57, 54, 51, 46, 50, 50, 10, 56, 49, 56, 52, 124, 49, 53, 50, 57, 55, 53, 48, 46, 55, 48, 10, 52, 53, 54, 48, 124, 49, 53, 50, 55, 52, 51, 51, 46, 50, 52, 10, 52, 54, 49, 54, 124, 49, 53, 50, 53, 51, 55, 52, 46, 52, 54, 10, 51, 56, 49, 52, 124, 49, 53, 50, 52, 48, 55, 55, 46, 48, 52, 10, 49, 55, 50, 54, 53, 124, 49, 53, 50, 51, 57, 51, 50, 46, 48, 56, 10, 49, 54, 53, 50, 48, 124, 49, 53, 50, 50, 57, 48, 54, 46, 50, 56, 10, 49, 48, 52, 55, 53, 124, 49, 53, 49, 56, 55, 48, 53, 46, 48, 54, 10, 53, 48, 57, 52, 124, 49, 53, 49, 55, 51, 49, 55, 46, 56, 51, 10, 56, 54, 50, 54, 124, 49, 53, 49, 53, 49, 52, 50, 46, 48, 55, 10, 49, 57, 56, 57, 53, 124, 49, 53, 49, 50, 50, 56, 54, 46, 54, 56, 10, 49, 57, 57, 51, 51, 124, 49, 53, 48, 54, 50, 51, 53, 46, 51, 54, 10, 54, 56, 53, 52, 124, 49, 53, 48, 53, 54, 50, 54, 46, 48, 48, 10, 49, 51, 57, 57, 53, 124, 49, 53, 48, 53, 53, 54, 50, 46, 49, 56, 10, 55, 49, 48, 50, 124, 49, 53, 48, 52, 57, 52, 53, 46, 54, 55, 10, 57, 48, 55, 57, 124, 49, 53, 48, 49, 50, 51, 55, 46, 50, 48, 10, 49, 56, 51, 50, 57, 124, 49, 53, 48, 48, 49, 52, 54, 46, 57, 48, 10, 51, 55, 52, 50, 124, 49, 52, 57, 54, 57, 57, 48, 46, 55, 55, 10, 49, 50, 51, 57, 53, 124, 49, 52, 57, 54, 57, 48, 52, 46, 52, 51, 10, 49, 50, 50, 49, 52, 124, 49, 52, 57, 54, 52, 56, 57, 46, 52, 48, 10, 49, 50, 50, 57, 56, 124, 49, 52, 57, 53, 53, 53, 52, 46, 51, 48, 10, 52, 57, 55, 56, 124, 49, 52, 57, 53, 51, 56, 57, 46, 53, 48, 10, 50, 57, 50, 55, 124, 49, 52, 57, 52, 50, 56, 48, 46, 49, 48, 10, 50, 49, 49, 57, 124, 49, 52, 57, 52, 49, 53, 49, 46, 49, 52, 10, 49, 53, 49, 52, 51, 124, 49, 52, 57, 50, 48, 51, 57, 46, 55, 53, 10, 49, 52, 53, 52, 56, 124, 49, 52, 56, 55, 52, 48, 54, 46, 54, 48, 10, 56, 52, 48, 124, 49, 52, 56, 54, 49, 50, 56, 46, 57, 56, 10, 53, 57, 48, 50, 124, 49, 52, 56, 54, 48, 57, 55, 46, 50, 56, 10, 49, 48, 54, 49, 52, 124, 49, 52, 56, 50, 49, 52, 52, 46, 55, 50, 10, 53, 56, 57, 53, 124, 49, 52, 56, 49, 51, 53, 54, 46, 56, 48, 10, 49, 53, 57, 53, 56, 124, 49, 52, 56, 48, 57, 53, 49, 46, 54, 48, 10, 49, 49, 52, 48, 56, 124, 49, 52, 55, 57, 57, 52, 56, 46, 57, 54, 10, 56, 52, 48, 55, 124, 49, 52, 55, 52, 50, 51, 54, 46, 48, 48, 10, 54, 50, 52, 51, 124, 49, 52, 55, 49, 48, 48, 55, 46, 56, 53, 10, 49, 48, 51, 56, 57, 124, 49, 52, 54, 57, 48, 48, 52, 46, 52, 54, 10, 49, 51, 56, 55, 49, 124, 49, 52, 54, 56, 57, 51, 56, 46, 54, 52, 10, 49, 57, 56, 49, 49, 124, 49, 52, 54, 52, 53, 57, 55, 46, 48, 57, 10, 49, 48, 52, 57, 53, 124, 49, 52, 54, 52, 50, 57, 48, 46, 52, 57, 10, 52, 51, 56, 57, 124, 49, 52, 54, 51, 48, 49, 48, 46, 56, 51, 10, 49, 51, 49, 49, 124, 49, 52, 54, 49, 55, 48, 51, 46, 51, 54, 10, 49, 55, 56, 55, 52, 124, 49, 52, 53, 57, 52, 48, 56, 46, 56, 56, 10, 54, 53, 57, 55, 124, 49, 52, 53, 56, 55, 54, 49, 46, 56, 55, 10, 49, 57, 50, 49, 49, 124, 49, 52, 53, 54, 55, 52, 49, 46, 54, 51, 10, 49, 50, 56, 55, 57, 124, 49, 52, 53, 54, 49, 55, 56, 46, 50, 52, 10, 56, 56, 52, 48, 124, 49, 52, 53, 53, 55, 51, 49, 46, 52, 54, 10, 49, 52, 55, 53, 53, 124, 49, 52, 53, 52, 56, 57, 48, 46, 54, 48, 10, 49, 54, 57, 53, 55, 124, 49, 52, 53, 52, 52, 54, 53, 46, 57, 54, 10, 57, 50, 53, 55, 124, 49, 52, 53, 52, 51, 56, 56, 46, 55, 54, 10, 53, 49, 57, 51, 124, 49, 52, 53, 52, 48, 49, 49, 46, 51, 50, 10, 54, 56, 56, 52, 124, 49, 52, 53, 50, 52, 55, 52, 46, 54, 48, 10, 49, 57, 57, 52, 56, 124, 49, 52, 53, 50, 48, 50, 52, 46, 48, 48, 10, 49, 53, 48, 55, 54, 124, 49, 52, 52, 56, 51, 57, 53, 46, 48, 48, 10, 49, 54, 48, 49, 54, 124, 49, 52, 52, 55, 53, 53, 55, 46, 52, 53, 10, 49, 49, 54, 57, 51, 124, 49, 52, 52, 53, 56, 51, 57, 46, 54, 56, 10, 54, 57, 55, 53, 124, 49, 52, 52, 48, 53, 49, 54, 46, 57, 54, 10, 52, 50, 57, 48, 124, 49, 52, 51, 57, 55, 54, 56, 46, 52, 54, 10, 49, 56, 57, 48, 48, 124, 49, 52, 51, 56, 55, 50, 50, 46, 49, 48, 10, 49, 52, 51, 56, 51, 124, 49, 52, 51, 56, 52, 55, 55, 46, 57, 50, 10, 49, 53, 48, 57, 56, 124, 49, 52, 51, 53, 57, 52, 49, 46, 55, 56, 10, 57, 51, 50, 50, 124, 49, 52, 51, 53, 50, 56, 50, 46, 56, 48, 10, 52, 53, 56, 124, 49, 52, 51, 51, 48, 52, 48, 46, 52, 53, 10, 49, 48, 48, 52, 50, 124, 49, 52, 51, 50, 57, 48, 54, 46, 51, 53, 10, 53, 48, 53, 50, 124, 49, 52, 51, 49, 57, 48, 48, 46, 57, 48, 10, 54, 54, 48, 48, 124, 49, 52, 51, 49, 49, 49, 54, 46, 53, 53, 10, 51, 54, 51, 48, 124, 49, 52, 50, 56, 54, 54, 53, 46, 48, 52, 10, 57, 54, 51, 54, 124, 49, 52, 50, 56, 49, 57, 51, 46, 56, 52, 10, 49, 54, 53, 49, 49, 124, 49, 52, 50, 55, 51, 48, 56, 46, 55, 52, 10, 52, 48, 52, 53, 124, 49, 52, 50, 55, 50, 52, 56, 46, 51, 53, 10, 49, 57, 53, 54, 50, 124, 49, 52, 50, 54, 51, 52, 56, 46, 56, 50, 10, 56, 56, 49, 52, 124, 49, 52, 50, 53, 54, 57, 48, 46, 48, 57, 10, 50, 54, 49, 54, 124, 49, 52, 50, 53, 49, 55, 56, 46, 48, 52, 10, 52, 53, 56, 55, 124, 49, 52, 50, 53, 49, 48, 57, 46, 52, 48, 10, 49, 52, 56, 124, 49, 52, 50, 52, 50, 51, 55, 46, 51, 55, 10, 50, 55, 49, 50, 124, 49, 52, 50, 51, 55, 56, 48, 46, 50, 54, 10, 49, 48, 56, 54, 51, 124, 49, 52, 50, 51, 51, 56, 54, 46, 49, 54, 10, 49, 54, 48, 57, 54, 124, 49, 52, 50, 49, 57, 52, 50, 46, 48, 57, 10, 49, 56, 57, 51, 54, 124, 49, 52, 50, 49, 57, 51, 56, 46, 54, 53, 10, 49, 56, 51, 50, 55, 124, 49, 52, 49, 57, 56, 55, 50, 46, 57, 50, 10, 49, 49, 54, 50, 48, 124, 49, 52, 49, 57, 48, 53, 48, 46, 49, 48, 10, 51, 55, 52, 48, 124, 49, 52, 49, 56, 54, 48, 57, 46, 56, 53, 10, 51, 52, 53, 55, 124, 49, 52, 49, 56, 54, 48, 51, 46, 53, 48, 10, 49, 49, 56, 53, 124, 49, 52, 49, 55, 54, 51, 55, 46, 52, 55, 10, 56, 49, 55, 56, 124, 49, 52, 49, 55, 51, 53, 55, 46, 50, 54, 10, 49, 55, 55, 57, 49, 124, 49, 52, 49, 51, 50, 57, 51, 46, 49, 51, 10, 49, 51, 54, 48, 56, 124, 49, 52, 49, 49, 51, 50, 51, 46, 49, 50, 10, 49, 55, 56, 52, 57, 124, 49, 52, 48, 57, 54, 49, 51, 46, 53, 48, 10, 54, 56, 49, 52, 124, 49, 52, 48, 54, 50, 50, 56, 46, 52, 48, 10, 49, 52, 48, 50, 50, 124, 49, 52, 48, 54, 49, 51, 56, 46, 48, 52, 10, 49, 52, 50, 51, 49, 124, 49, 52, 48, 51, 55, 55, 49, 46, 53, 50, 10, 49, 57, 53, 52, 54, 124, 49, 52, 48, 50, 56, 53, 52, 46, 54, 48, 10, 49, 57, 54, 49, 57, 124, 49, 52, 48, 50, 51, 56, 57, 46, 49, 54, 10, 53, 54, 48, 57, 124, 49, 52, 48, 50, 51, 48, 50, 46, 53, 52, 10, 53, 51, 52, 50, 124, 49, 52, 48, 49, 53, 54, 55, 46, 53, 57, 10, 51, 48, 56, 52, 124, 49, 52, 48, 49, 48, 57, 54, 46, 49, 48, 10, 53, 55, 48, 56, 124, 49, 52, 48, 48, 51, 51, 52, 46, 57, 48, 10, 49, 55, 57, 57, 56, 124, 49, 51, 57, 57, 56, 54, 50, 46, 52, 53, 10, 49, 57, 56, 53, 48, 124, 49, 51, 57, 55, 54, 51, 48, 46, 51, 51, 10, 49, 52, 48, 48, 52, 124, 49, 51, 57, 53, 52, 52, 51, 46, 49, 48, 10, 49, 51, 48, 55, 49, 124, 49, 51, 57, 52, 54, 53, 51, 46, 50, 52, 10, 50, 55, 57, 55, 124, 49, 51, 57, 51, 55, 52, 55, 46, 53, 56, 10, 50, 56, 54, 54, 124, 49, 51, 57, 50, 57, 52, 55, 46, 50, 53, 10, 49, 57, 56, 48, 57, 124, 49, 51, 56, 57, 48, 54, 55, 46, 54, 56, 10, 49, 51, 54, 48, 48, 124, 49, 51, 56, 48, 56, 54, 53, 46, 56, 48, 10, 49, 51, 54, 49, 52, 124, 49, 51, 56, 48, 54, 53, 52, 46, 51, 54, 10, 53, 56, 56, 52, 124, 49, 51, 56, 48, 51, 49, 57, 46, 55, 52, 10, 57, 52, 48, 52, 124, 49, 51, 55, 56, 54, 50, 51, 46, 54, 54, 10, 49, 48, 54, 53, 54, 124, 49, 51, 55, 54, 57, 53, 52, 46, 51, 50, 10, 49, 50, 51, 50, 52, 124, 49, 51, 55, 54, 53, 48, 50, 46, 52, 48, 10, 55, 51, 50, 53, 124, 49, 51, 55, 53, 48, 51, 48, 46, 52, 51, 10, 49, 51, 50, 57, 53, 124, 49, 51, 55, 51, 57, 56, 55, 46, 51, 52, 10, 49, 49, 56, 54, 52, 124, 49, 51, 55, 51, 53, 53, 53, 46, 54, 56, 10, 54, 57, 56, 55, 124, 49, 51, 55, 51, 52, 56, 49, 46, 53, 49, 10, 56, 51, 56, 54, 124, 49, 51, 55, 49, 56, 53, 52, 46, 52, 49, 10, 49, 48, 57, 49, 54, 124, 49, 51, 55, 48, 51, 55, 52, 46, 51, 50, 10, 49, 50, 56, 54, 55, 124, 49, 51, 54, 57, 48, 53, 56, 46, 49, 49, 10, 49, 52, 54, 54, 56, 124, 49, 51, 54, 57, 48, 52, 48, 46, 51, 52, 10, 49, 51, 51, 56, 51, 124, 49, 51, 54, 55, 51, 52, 50, 46, 51, 48, 10, 49, 56, 53, 55, 50, 124, 49, 51, 54, 54, 57, 53, 51, 46, 57, 54, 10, 49, 49, 53, 50, 124, 49, 51, 54, 54, 56, 54, 49, 46, 51, 56, 10, 54, 48, 49, 53, 124, 49, 51, 54, 54, 52, 53, 50, 46, 49, 56, 10, 51, 51, 52, 52, 124, 49, 51, 54, 54, 49, 56, 53, 46, 49, 53, 10, 55, 56, 56, 57, 124, 49, 51, 54, 53, 53, 50, 49, 46, 57, 50, 10, 49, 51, 51, 52, 53, 124, 49, 51, 54, 52, 48, 56, 56, 46, 56, 56, 10, 54, 50, 55, 54, 124, 49, 51, 54, 51, 52, 50, 49, 46, 54, 50, 10, 56, 48, 54, 57, 124, 49, 51, 54, 49, 56, 50, 52, 46, 50, 48, 10, 49, 55, 53, 48, 57, 124, 49, 51, 54, 48, 56, 57, 50, 46, 52, 57, 10, 49, 53, 49, 51, 55, 124, 49, 51, 53, 56, 54, 55, 56, 46, 48, 55, 10, 49, 55, 49, 54, 51, 124, 49, 51, 53, 55, 51, 57, 49, 46, 53, 50, 10, 52, 55, 48, 52, 124, 49, 51, 53, 54, 54, 57, 50, 46, 52, 48, 10, 56, 54, 48, 57, 124, 49, 51, 53, 54, 53, 55, 56, 46, 49, 57, 10, 49, 50, 54, 52, 52, 124, 49, 51, 53, 54, 48, 56, 56, 46, 49, 52, 10, 49, 55, 49, 52, 49, 124, 49, 51, 53, 54, 48, 50, 50, 46, 51, 56, 10, 49, 49, 56, 48, 53, 124, 49, 51, 53, 52, 56, 50, 54, 46, 55, 56, 10, 54, 51, 56, 54, 124, 49, 51, 53, 52, 49, 56, 55, 46, 50, 50, 10, 51, 48, 48, 52, 124, 49, 51, 53, 50, 49, 55, 51, 46, 52, 52, 10, 56, 54, 51, 52, 124, 49, 51, 53, 48, 50, 49, 49, 46, 56, 48, 10, 52, 51, 57, 57, 124, 49, 51, 52, 57, 56, 56, 49, 46, 50, 48, 10, 49, 48, 51, 54, 50, 124, 49, 51, 52, 57, 52, 49, 49, 46, 51, 52, 10, 49, 53, 55, 50, 124, 49, 51, 52, 56, 56, 51, 53, 46, 50, 48, 10, 55, 51, 53, 57, 124, 49, 51, 52, 56, 50, 50, 52, 46, 49, 48, 10, 49, 49, 56, 56, 52, 124, 49, 51, 52, 54, 54, 57, 54, 46, 56, 50, 10, 49, 49, 54, 55, 49, 124, 49, 51, 52, 54, 52, 50, 52, 46, 49, 53, 10, 53, 51, 53, 48, 124, 49, 51, 52, 54, 51, 53, 57, 46, 50, 56, 10, 51, 49, 49, 57, 124, 49, 51, 52, 53, 57, 57, 54, 46, 52, 56, 10, 53, 51, 48, 55, 124, 49, 51, 52, 53, 51, 53, 54, 46, 48, 48, 10, 49, 54, 49, 49, 55, 124, 49, 51, 52, 53, 48, 52, 53, 46, 49, 50, 10, 56, 55, 49, 53, 124, 49, 51, 52, 50, 54, 54, 53, 46, 55, 50, 10, 53, 51, 57, 56, 124, 49, 51, 52, 49, 49, 55, 57, 46, 50, 56, 10, 55, 54, 50, 55, 124, 49, 51, 51, 56, 56, 50, 48, 46, 53, 54, 10, 56, 52, 53, 55, 124, 49, 51, 51, 55, 55, 49, 52, 46, 54, 56, 10, 52, 57, 53, 56, 124, 49, 51, 51, 52, 55, 51, 50, 46, 55, 49, 10, 56, 52, 124, 49, 51, 51, 52, 49, 52, 54, 46, 55, 49, 10, 54, 57, 51, 50, 124, 49, 51, 51, 51, 50, 51, 53, 46, 51, 54, 10, 55, 53, 55, 124, 49, 51, 51, 50, 57, 50, 49, 46, 48, 55, 10, 52, 48, 55, 54, 124, 49, 51, 51, 50, 52, 52, 49, 46, 48, 48, 10, 49, 55, 53, 49, 124, 49, 51, 50, 57, 49, 49, 50, 46, 51, 50, 10, 49, 53, 55, 48, 49, 124, 49, 51, 50, 55, 48, 53, 50, 46, 49, 54, 10, 52, 49, 49, 57, 124, 49, 51, 50, 54, 53, 52, 57, 46, 57, 48, 10, 49, 53, 54, 50, 124, 49, 51, 50, 53, 54, 48, 52, 46, 50, 56, 10, 56, 55, 52, 49, 124, 49, 51, 50, 53, 53, 49, 55, 46, 54, 48, 10, 49, 49, 51, 53, 124, 49, 51, 50, 53, 52, 50, 50, 46, 55, 49, 10, 49, 48, 48, 50, 124, 49, 51, 50, 51, 52, 49, 56, 46, 54, 53, 10, 53, 56, 51, 50, 124, 49, 51, 50, 51, 48, 56, 53, 46, 55, 49, 10, 53, 51, 54, 56, 124, 49, 51, 50, 50, 55, 57, 51, 46, 57, 54, 10, 53, 51, 56, 50, 124, 49, 51, 50, 50, 54, 50, 56, 46, 56, 52, 10, 53, 54, 49, 54, 124, 49, 51, 49, 57, 48, 56, 50, 46, 50, 54, 10, 50, 56, 51, 50, 124, 49, 51, 49, 56, 54, 57, 49, 46, 57, 53, 10, 51, 56, 57, 53, 124, 49, 51, 49, 55, 56, 53, 56, 46, 52, 52, 10, 56, 54, 50, 57, 124, 49, 51, 49, 55, 55, 53, 54, 46, 53, 49, 10, 53, 55, 48, 57, 124, 49, 51, 49, 55, 48, 53, 56, 46, 54, 56, 10, 49, 56, 51, 56, 51, 124, 49, 51, 49, 54, 52, 53, 49, 46, 48, 53, 10, 49, 53, 55, 57, 55, 124, 49, 51, 49, 52, 56, 48, 54, 46, 54, 52, 10, 49, 57, 48, 48, 124, 49, 51, 49, 51, 54, 54, 48, 46, 52, 48, 10, 49, 51, 56, 56, 50, 124, 49, 51, 49, 48, 52, 53, 53, 46, 56, 54, 10, 54, 55, 56, 53, 124, 49, 51, 48, 57, 56, 55, 55, 46, 56, 48, 10, 49, 52, 56, 53, 53, 124, 49, 51, 48, 57, 50, 56, 48, 46, 55, 54, 10, 55, 55, 54, 49, 124, 49, 51, 48, 56, 54, 48, 50, 46, 50, 52, 10, 49, 52, 50, 54, 56, 124, 49, 51, 48, 54, 56, 49, 48, 46, 52, 48, 10, 54, 50, 53, 55, 124, 49, 51, 48, 54, 48, 53, 54, 46, 57, 54, 10, 49, 57, 48, 48, 50, 124, 49, 51, 48, 53, 53, 48, 57, 46, 53, 50, 10, 53, 48, 57, 53, 124, 49, 51, 48, 51, 55, 50, 57, 46, 48, 50, 10, 49, 48, 51, 50, 48, 124, 49, 51, 48, 49, 54, 53, 55, 46, 53, 56, 10, 55, 56, 50, 54, 124, 49, 50, 57, 57, 53, 54, 49, 46, 54, 56, 10, 49, 51, 51, 53, 57, 124, 49, 50, 57, 56, 55, 49, 55, 46, 49, 52, 10, 55, 52, 51, 54, 124, 49, 50, 57, 56, 49, 50, 55, 46, 51, 54, 10, 53, 54, 52, 52, 124, 49, 50, 57, 53, 48, 53, 53, 46, 55, 55, 10, 49, 49, 51, 50, 55, 124, 49, 50, 57, 48, 53, 50, 54, 46, 52, 49, 10, 53, 50, 55, 55, 124, 49, 50, 56, 57, 51, 50, 57, 46, 54, 53, 10, 49, 53, 57, 51, 50, 124, 49, 50, 56, 54, 50, 51, 53, 46, 56, 52, 10, 49, 52, 51, 50, 50, 124, 49, 50, 56, 52, 56, 48, 57, 46, 51, 54, 10, 49, 52, 52, 124, 49, 50, 56, 52, 50, 55, 48, 46, 49, 50, 10, 51, 48, 52, 51, 124, 49, 50, 56, 49, 49, 54, 50, 46, 55, 57, 10, 49, 54, 55, 56, 56, 124, 49, 50, 56, 48, 57, 53, 53, 46, 51, 52, 10, 49, 55, 49, 51, 54, 124, 49, 50, 56, 48, 52, 52, 51, 46, 49, 50, 10, 49, 50, 53, 54, 48, 124, 49, 50, 55, 57, 49, 49, 55, 46, 57, 53, 10, 49, 51, 56, 51, 51, 124, 49, 50, 55, 56, 56, 51, 52, 46, 55, 53, 10, 53, 52, 49, 52, 124, 49, 50, 55, 55, 56, 57, 51, 46, 50, 54, 10, 49, 50, 53, 56, 50, 124, 49, 50, 55, 55, 53, 57, 50, 46, 51, 50, 10, 52, 54, 52, 52, 124, 49, 50, 55, 55, 53, 51, 53, 46, 48, 48, 10, 49, 52, 48, 51, 50, 124, 49, 50, 55, 55, 48, 55, 55, 46, 56, 56, 10, 49, 56, 51, 50, 53, 124, 49, 50, 55, 49, 55, 49, 57, 46, 54, 56, 10, 55, 48, 55, 50, 124, 49, 50, 55, 49, 50, 50, 56, 46, 52, 56, 10, 49, 54, 56, 54, 56, 124, 49, 50, 54, 55, 52, 54, 57, 46, 52, 50, 10, 56, 49, 51, 55, 124, 49, 50, 54, 55, 52, 50, 53, 46, 56, 49, 10, 53, 57, 55, 54, 124, 49, 50, 54, 54, 50, 48, 54, 46, 56, 53, 10, 49, 52, 49, 50, 53, 124, 49, 50, 54, 53, 53, 54, 57, 46, 48, 53, 10, 49, 51, 50, 57, 57, 124, 49, 50, 54, 53, 50, 56, 55, 46, 53, 53, 10, 49, 56, 51, 55, 54, 124, 49, 50, 54, 52, 50, 52, 57, 46, 51, 48, 10, 54, 49, 53, 55, 124, 49, 50, 54, 49, 55, 53, 57, 46, 57, 50, 10, 53, 48, 48, 50, 124, 49, 50, 54, 49, 54, 54, 57, 46, 54, 52, 10, 49, 51, 51, 54, 56, 124, 49, 50, 54, 48, 57, 49, 56, 46, 54, 48, 10, 49, 53, 53, 56, 57, 124, 49, 50, 54, 48, 48, 53, 57, 46, 55, 54, 10, 50, 49, 52, 57, 124, 49, 50, 53, 56, 57, 56, 49, 46, 52, 52, 10, 57, 54, 51, 57, 124, 49, 50, 53, 54, 50, 56, 51, 46, 51, 56, 10, 49, 49, 54, 56, 57, 124, 49, 50, 53, 54, 48, 50, 55, 46, 57, 50, 10, 57, 48, 56, 51, 124, 49, 50, 52, 53, 57, 50, 52, 46, 50, 52, 10, 49, 54, 50, 51, 49, 124, 49, 50, 52, 50, 54, 50, 53, 46, 54, 53, 10, 53, 48, 56, 52, 124, 49, 50, 52, 50, 51, 56, 53, 46, 50, 56, 10, 49, 49, 54, 51, 52, 124, 49, 50, 52, 48, 55, 54, 48, 46, 49, 56, 10, 49, 53, 54, 49, 55, 124, 49, 50, 51, 57, 55, 51, 49, 46, 50, 53, 10, 57, 56, 54, 53, 124, 49, 50, 51, 55, 49, 56, 49, 46, 54, 50, 10, 49, 52, 50, 49, 50, 124, 49, 50, 51, 54, 51, 54, 53, 46, 53, 50, 10, 49, 48, 51, 50, 53, 124, 49, 50, 51, 53, 50, 50, 51, 46, 51, 54, 10, 49, 57, 53, 56, 50, 124, 49, 50, 51, 53, 49, 48, 53, 46, 55, 54, 10, 55, 52, 48, 124, 49, 50, 51, 52, 55, 52, 54, 46, 56, 49, 10, 49, 57, 50, 51, 49, 124, 49, 50, 51, 51, 54, 50, 51, 46, 49, 48, 10, 49, 54, 56, 52, 48, 124, 49, 50, 51, 51, 48, 54, 51, 46, 56, 53, 10, 53, 55, 48, 51, 124, 49, 50, 51, 49, 55, 52, 52, 46, 51, 51, 10, 53, 55, 54, 49, 124, 49, 50, 50, 57, 52, 51, 53, 46, 50, 48, 10, 49, 53, 54, 51, 48, 124, 49, 50, 50, 54, 54, 49, 49, 46, 54, 50, 10, 49, 48, 52, 48, 56, 124, 49, 50, 50, 52, 54, 57, 56, 46, 52, 48, 10, 57, 49, 55, 55, 124, 49, 50, 50, 49, 57, 52, 50, 46, 53, 49, 10, 49, 51, 51, 56, 57, 124, 49, 50, 50, 49, 54, 54, 54, 46, 55, 53, 10, 54, 49, 48, 52, 124, 49, 50, 50, 49, 53, 55, 55, 46, 57, 50, 10, 57, 54, 55, 51, 124, 49, 50, 49, 56, 56, 50, 54, 46, 54, 52, 10, 50, 55, 48, 55, 124, 49, 50, 49, 55, 49, 50, 52, 46, 52, 56, 10, 49, 56, 54, 55, 50, 124, 49, 50, 49, 52, 50, 48, 56, 46, 56, 48, 10, 53, 49, 49, 50, 124, 49, 50, 48, 57, 53, 57, 48, 46, 50, 48, 10, 54, 50, 54, 52, 124, 49, 50, 48, 56, 51, 49, 56, 46, 53, 48, 10, 49, 56, 52, 57, 54, 124, 49, 50, 48, 55, 56, 56, 49, 46, 55, 53, 10, 49, 48, 57, 55, 49, 124, 49, 50, 48, 55, 49, 56, 51, 46, 53, 50, 10, 49, 57, 48, 53, 57, 124, 49, 50, 48, 54, 55, 50, 57, 46, 57, 48, 10, 52, 51, 49, 124, 49, 50, 48, 53, 57, 51, 56, 46, 52, 52, 10, 51, 56, 50, 49, 124, 49, 50, 48, 49, 49, 57, 50, 46, 55, 53, 10, 56, 50, 54, 124, 49, 50, 48, 48, 52, 53, 52, 46, 54, 50, 10, 51, 51, 49, 55, 124, 49, 50, 48, 48, 52, 52, 48, 46, 57, 48, 10, 49, 57, 54, 56, 57, 124, 49, 49, 57, 56, 56, 57, 57, 46, 53, 50, 10, 49, 57, 54, 52, 49, 124, 49, 49, 57, 56, 55, 57, 55, 46, 57, 57, 10, 54, 51, 55, 57, 124, 49, 49, 57, 55, 49, 57, 53, 46, 53, 48, 10, 56, 49, 52, 124, 49, 49, 57, 52, 52, 49, 55, 46, 52, 48, 10, 49, 56, 54, 52, 51, 124, 49, 49, 57, 52, 48, 48, 48, 46, 55, 56, 10, 49, 49, 56, 54, 53, 124, 49, 49, 57, 51, 57, 54, 53, 46, 55, 54, 10, 49, 50, 51, 57, 51, 124, 49, 49, 57, 51, 56, 57, 54, 46, 56, 48, 10, 57, 50, 49, 56, 124, 49, 49, 57, 51, 54, 54, 48, 46, 53, 56, 10, 56, 54, 55, 52, 124, 49, 49, 57, 49, 56, 56, 49, 46, 51, 50, 10, 56, 53, 56, 50, 124, 49, 49, 57, 49, 56, 48, 52, 46, 48, 50, 10, 49, 51, 48, 56, 52, 124, 49, 49, 57, 49, 53, 48, 56, 46, 48, 48, 10, 49, 56, 56, 52, 52, 124, 49, 49, 57, 48, 50, 51, 57, 46, 57, 54, 10, 49, 54, 48, 54, 49, 124, 49, 49, 56, 57, 57, 51, 53, 46, 48, 48, 10, 54, 49, 51, 52, 124, 49, 49, 56, 53, 53, 53, 48, 46, 56, 48, 10, 56, 54, 50, 56, 124, 49, 49, 56, 51, 50, 52, 53, 46, 54, 48, 10, 56, 56, 56, 52, 124, 49, 49, 56, 49, 53, 52, 55, 46, 52, 56, 10, 55, 54, 57, 55, 124, 49, 49, 56, 49, 48, 51, 50, 46, 53, 48, 10, 57, 48, 52, 52, 124, 49, 49, 56, 48, 57, 50, 50, 46, 54, 48, 10, 49, 51, 50, 53, 55, 124, 49, 49, 56, 48, 49, 53, 56, 46, 53, 55, 10, 56, 48, 54, 54, 124, 49, 49, 55, 56, 56, 48, 56, 46, 49, 50, 10, 53, 56, 55, 54, 124, 49, 49, 55, 55, 51, 55, 54, 46, 56, 48, 10, 49, 52, 54, 57, 52, 124, 49, 49, 55, 55, 48, 53, 57, 46, 51, 49, 10, 49, 54, 48, 54, 50, 124, 49, 49, 55, 53, 51, 57, 49, 46, 48, 48, 10, 57, 49, 48, 52, 124, 49, 49, 55, 53, 49, 55, 56, 46, 57, 48, 10, 49, 49, 54, 48, 48, 124, 49, 49, 55, 53, 48, 57, 49, 46, 48, 54, 10, 49, 48, 51, 51, 55, 124, 49, 49, 55, 50, 54, 56, 52, 46, 57, 50, 10, 49, 57, 49, 56, 56, 124, 49, 49, 55, 50, 51, 52, 57, 46, 55, 56, 10, 56, 56, 51, 51, 124, 49, 49, 55, 49, 51, 55, 50, 46, 57, 51, 10, 54, 56, 57, 53, 124, 49, 49, 55, 48, 54, 48, 50, 46, 48, 55, 10, 49, 52, 49, 48, 48, 124, 49, 49, 54, 56, 56, 55, 56, 46, 52, 48, 10, 49, 51, 53, 51, 56, 124, 49, 49, 54, 56, 53, 53, 52, 46, 50, 56, 10, 51, 52, 48, 56, 124, 49, 49, 54, 54, 54, 52, 53, 46, 49, 54, 10, 49, 56, 54, 48, 124, 49, 49, 54, 53, 54, 55, 51, 46, 54, 56, 10, 49, 51, 52, 51, 54, 124, 49, 49, 54, 52, 50, 55, 56, 46, 55, 48, 10, 49, 57, 51, 50, 53, 124, 49, 49, 54, 50, 55, 51, 51, 46, 55, 48, 10, 55, 52, 48, 51, 124, 49, 49, 54, 49, 57, 56, 50, 46, 48, 48, 10, 52, 56, 56, 50, 124, 49, 49, 54, 49, 52, 48, 52, 46, 56, 49, 10, 49, 51, 49, 48, 53, 124, 49, 49, 54, 49, 51, 50, 48, 46, 53, 56, 10, 49, 55, 56, 56, 48, 124, 49, 49, 54, 49, 50, 53, 54, 46, 48, 50, 10, 49, 57, 50, 56, 52, 124, 49, 49, 54, 48, 57, 50, 55, 46, 54, 48, 10, 49, 51, 52, 55, 54, 124, 49, 49, 53, 57, 48, 51, 53, 46, 49, 53, 10, 49, 56, 57, 49, 51, 124, 49, 49, 53, 56, 50, 48, 56, 46, 51, 48, 10, 49, 56, 53, 50, 51, 124, 49, 49, 53, 56, 49, 51, 53, 46, 48, 48, 10, 49, 50, 53, 48, 56, 124, 49, 49, 53, 55, 53, 51, 56, 46, 52, 53, 10, 57, 48, 57, 48, 124, 49, 49, 53, 54, 51, 54, 50, 46, 54, 52, 10, 49, 55, 54, 53, 51, 124, 49, 49, 53, 52, 51, 51, 56, 46, 48, 56, 10, 51, 57, 50, 54, 124, 49, 49, 53, 50, 54, 53, 50, 46, 53, 50, 10, 49, 48, 49, 56, 51, 124, 49, 49, 52, 56, 51, 50, 52, 46, 53, 55, 10, 55, 53, 53, 54, 124, 49, 49, 52, 54, 50, 54, 56, 46, 49, 52, 10, 49, 54, 52, 51, 54, 124, 49, 49, 52, 50, 54, 53, 54, 46, 52, 55, 10, 52, 55, 52, 49, 124, 49, 49, 52, 49, 54, 49, 52, 46, 48, 48, 10, 49, 53, 54, 53, 49, 124, 49, 49, 52, 49, 52, 57, 55, 46, 57, 51, 10, 51, 49, 56, 51, 124, 49, 49, 52, 48, 48, 56, 49, 46, 51, 54, 10, 57, 53, 51, 50, 124, 49, 49, 51, 57, 57, 48, 50, 46, 53, 48, 10, 49, 54, 52, 48, 51, 124, 49, 49, 51, 57, 51, 48, 54, 46, 51, 55, 10, 50, 51, 54, 56, 124, 49, 49, 51, 55, 52, 50, 49, 46, 49, 54, 10, 51, 56, 56, 57, 124, 49, 49, 51, 54, 51, 57, 53, 46, 53, 48, 10, 50, 56, 56, 53, 124, 49, 49, 51, 53, 56, 51, 56, 46, 49, 52, 10, 55, 56, 53, 49, 124, 49, 49, 51, 53, 49, 49, 48, 46, 55, 54, 10, 49, 54, 50, 51, 52, 124, 49, 49, 51, 53, 48, 49, 55, 46, 50, 52, 10, 49, 50, 55, 52, 54, 124, 49, 49, 51, 52, 53, 51, 49, 46, 48, 52, 10, 50, 54, 52, 55, 124, 49, 49, 51, 50, 57, 52, 49, 46, 49, 50, 10, 53, 51, 55, 51, 124, 49, 49, 51, 50, 49, 53, 56, 46, 48, 49, 10, 49, 48, 51, 52, 48, 124, 49, 49, 51, 50, 48, 48, 52, 46, 50, 52, 10, 56, 56, 55, 51, 124, 49, 49, 51, 49, 57, 52, 57, 46, 50, 56, 10, 49, 49, 51, 50, 124, 49, 49, 51, 49, 51, 51, 56, 46, 56, 56, 10, 49, 53, 53, 57, 52, 124, 49, 49, 51, 49, 51, 50, 56, 46, 54, 50, 10, 52, 51, 55, 54, 124, 49, 49, 51, 48, 50, 56, 50, 46, 50, 48, 10, 50, 52, 48, 124, 49, 49, 50, 54, 54, 56, 50, 46, 52, 56, 10, 50, 50, 51, 49, 124, 49, 49, 50, 52, 52, 52, 55, 46, 49, 53, 10, 57, 50, 57, 124, 49, 49, 50, 49, 51, 56, 51, 46, 57, 50, 10, 49, 49, 53, 57, 57, 124, 49, 49, 49, 57, 51, 48, 55, 46, 50, 55, 10, 51, 55, 54, 53, 124, 49, 49, 49, 57, 48, 57, 51, 46, 53, 48, 10, 49, 55, 54, 51, 53, 124, 49, 49, 49, 56, 52, 50, 48, 46, 49, 54, 10, 55, 49, 49, 57, 124, 49, 49, 49, 56, 50, 56, 53, 46, 48, 56, 10, 49, 53, 49, 50, 49, 124, 49, 49, 49, 55, 55, 49, 53, 46, 51, 52, 10, 49, 49, 56, 53, 56, 124, 49, 49, 49, 54, 57, 54, 51, 46, 53, 52, 10, 49, 54, 57, 54, 51, 124, 49, 49, 49, 54, 57, 50, 57, 46, 52, 53, 10, 49, 54, 51, 53, 54, 124, 49, 49, 49, 51, 54, 52, 56, 46, 57, 56, 10, 54, 57, 50, 52, 124, 49, 49, 49, 50, 49, 57, 56, 46, 52, 48, 10, 49, 54, 50, 50, 51, 124, 49, 49, 49, 49, 50, 53, 55, 46, 48, 48, 10, 49, 56, 48, 57, 49, 124, 49, 49, 49, 48, 48, 52, 51, 46, 48, 50, 10, 49, 50, 54, 50, 56, 124, 49, 49, 48, 56, 57, 53, 52, 46, 56, 48, 10, 49, 54, 48, 52, 51, 124, 49, 49, 48, 56, 56, 51, 49, 46, 48, 53, 10, 57, 52, 48, 50, 124, 49, 49, 48, 56, 50, 57, 48, 46, 52, 56, 10, 55, 48, 56, 124, 49, 49, 48, 55, 48, 56, 52, 46, 48, 48, 10, 52, 48, 55, 56, 124, 49, 49, 48, 53, 57, 57, 51, 46, 57, 54, 10, 49, 55, 53, 57, 51, 124, 49, 49, 48, 52, 55, 49, 51, 46, 52, 48, 10, 49, 50, 55, 55, 54, 124, 49, 49, 48, 52, 51, 54, 50, 46, 53, 57, 10, 55, 53, 56, 51, 124, 49, 49, 48, 50, 56, 49, 51, 46, 53, 51, 10, 49, 52, 54, 49, 57, 124, 49, 49, 48, 50, 54, 55, 53, 46, 56, 48, 10, 56, 56, 52, 50, 124, 49, 49, 48, 48, 49, 49, 48, 46, 50, 54, 10, 52, 49, 57, 54, 124, 49, 48, 57, 57, 55, 50, 54, 46, 53, 53, 10, 50, 48, 49, 57, 124, 49, 48, 57, 56, 49, 55, 56, 46, 54, 52, 10, 54, 56, 54, 51, 124, 49, 48, 57, 55, 50, 52, 54, 46, 51, 54, 10, 54, 52, 56, 57, 124, 49, 48, 57, 54, 53, 48, 51, 46, 48, 55, 10, 50, 52, 53, 57, 124, 49, 48, 57, 52, 56, 49, 51, 46, 48, 52, 10, 49, 49, 57, 54, 52, 124, 49, 48, 57, 52, 52, 56, 53, 46, 48, 50, 10, 51, 50, 51, 54, 124, 49, 48, 57, 51, 57, 54, 57, 46, 56, 48, 10, 49, 55, 54, 52, 55, 124, 49, 48, 57, 51, 56, 48, 57, 46, 49, 53, 10, 49, 55, 54, 52, 56, 124, 49, 48, 57, 51, 49, 49, 52, 46, 54, 50, 10, 49, 49, 57, 124, 49, 48, 57, 50, 54, 56, 55, 46, 52, 56, 10, 57, 54, 50, 54, 124, 49, 48, 57, 50, 48, 56, 48, 46, 48, 48, 10, 57, 49, 50, 52, 124, 49, 48, 57, 49, 53, 54, 57, 46, 54, 56, 10, 49, 51, 49, 55, 53, 124, 49, 48, 56, 57, 56, 53, 49, 46, 55, 54, 10, 50, 53, 51, 50, 124, 49, 48, 56, 56, 55, 48, 54, 46, 51, 53, 10, 49, 54, 48, 56, 51, 124, 49, 48, 56, 56, 50, 57, 53, 46, 51, 57, 10, 56, 56, 55, 52, 124, 49, 48, 56, 54, 48, 49, 49, 46, 51, 52, 10, 49, 50, 56, 55, 50, 124, 49, 48, 56, 50, 57, 55, 48, 46, 51, 48, 10, 49, 57, 56, 50, 49, 124, 49, 48, 56, 50, 53, 50, 48, 46, 56, 52, 10, 52, 56, 48, 48, 124, 49, 48, 56, 48, 51, 56, 57, 46, 55, 48, 10, 49, 56, 54, 57, 54, 124, 49, 48, 55, 57, 54, 56, 53, 46, 51, 54, 10, 49, 57, 53, 52, 53, 124, 49, 48, 55, 57, 49, 56, 52, 46, 51, 51, 10, 49, 51, 49, 50, 48, 124, 49, 48, 55, 55, 55, 52, 50, 46, 50, 56, 10, 49, 48, 53, 56, 56, 124, 49, 48, 55, 54, 50, 48, 51, 46, 56, 51, 10, 49, 55, 54, 57, 54, 124, 49, 48, 55, 53, 48, 57, 50, 46, 55, 50, 10, 49, 52, 54, 53, 49, 124, 49, 48, 55, 51, 50, 50, 50, 46, 50, 51, 10, 57, 48, 51, 124, 49, 48, 55, 49, 49, 52, 54, 46, 55, 54, 10, 53, 56, 53, 56, 124, 49, 48, 55, 48, 50, 53, 57, 46, 52, 56, 10, 56, 51, 48, 50, 124, 49, 48, 54, 57, 53, 48, 52, 46, 56, 48, 10, 49, 56, 55, 50, 56, 124, 49, 48, 54, 57, 50, 50, 53, 46, 53, 49, 10, 49, 56, 48, 50, 54, 124, 49, 48, 54, 56, 53, 54, 57, 46, 48, 48, 10, 49, 57, 51, 56, 51, 124, 49, 48, 54, 54, 57, 48, 55, 46, 53, 56, 10, 49, 56, 54, 57, 48, 124, 49, 48, 54, 53, 57, 51, 48, 46, 57, 48, 10, 53, 57, 50, 52, 124, 49, 48, 54, 53, 49, 52, 51, 46, 49, 50, 10, 52, 56, 56, 48, 124, 49, 48, 54, 53, 48, 49, 49, 46, 55, 53, 10, 49, 50, 52, 51, 57, 124, 49, 48, 54, 52, 51, 56, 49, 46, 49, 57, 10, 49, 54, 53, 50, 57, 124, 49, 48, 54, 50, 51, 55, 49, 46, 55, 48, 10, 49, 57, 54, 53, 51, 124, 49, 48, 53, 55, 54, 56, 51, 46, 53, 54, 10, 51, 49, 51, 54, 124, 49, 48, 53, 54, 56, 49, 48, 46, 52, 52, 10, 49, 56, 57, 51, 50, 124, 49, 48, 53, 54, 49, 57, 51, 46, 54, 53, 10, 50, 49, 50, 52, 124, 49, 48, 53, 52, 49, 54, 48, 46, 53, 50, 10, 49, 54, 56, 53, 49, 124, 49, 48, 53, 50, 54, 52, 54, 46, 56, 52, 10, 49, 48, 49, 50, 51, 124, 49, 48, 53, 49, 54, 50, 52, 46, 48, 48, 10, 53, 54, 49, 56, 124, 49, 48, 52, 56, 52, 52, 55, 46, 57, 51, 10, 49, 57, 56, 53, 49, 124, 49, 48, 52, 53, 49, 56, 55, 46, 56, 53, 10, 49, 54, 50, 55, 56, 124, 49, 48, 52, 52, 56, 48, 56, 46, 51, 56, 10, 49, 49, 52, 55, 57, 124, 49, 48, 52, 52, 50, 55, 54, 46, 50, 50, 10, 49, 51, 50, 54, 51, 124, 49, 48, 52, 50, 48, 52, 54, 46, 50, 48, 10, 54, 48, 52, 49, 124, 49, 48, 52, 49, 49, 50, 51, 46, 51, 56, 10, 55, 49, 57, 51, 124, 49, 48, 52, 48, 52, 53, 53, 46, 51, 50, 10, 49, 57, 52, 48, 56, 124, 49, 48, 51, 57, 52, 51, 48, 46, 48, 49, 10, 49, 49, 50, 54, 48, 124, 49, 48, 51, 54, 56, 50, 56, 46, 53, 50, 10, 53, 49, 55, 57, 124, 49, 48, 51, 53, 54, 51, 51, 46, 52, 52, 10, 49, 51, 51, 49, 124, 49, 48, 51, 52, 51, 57, 56, 46, 48, 48, 10, 55, 55, 48, 54, 124, 49, 48, 51, 52, 50, 52, 57, 46, 52, 48, 10, 56, 52, 51, 54, 124, 49, 48, 51, 51, 53, 52, 57, 46, 51, 53, 10, 49, 56, 48, 49, 124, 49, 48, 51, 49, 56, 56, 54, 46, 48, 48, 10, 52, 49, 55, 48, 124, 49, 48, 51, 49, 54, 52, 50, 46, 57, 48, 10, 49, 49, 56, 50, 55, 124, 49, 48, 51, 49, 49, 51, 57, 46, 51, 57, 10, 49, 55, 49, 49, 52, 124, 49, 48, 50, 55, 57, 56, 53, 46, 56, 56, 10, 49, 56, 50, 55, 56, 124, 49, 48, 50, 54, 53, 56, 51, 46, 49, 49, 10, 49, 57, 57, 53, 124, 49, 48, 50, 53, 49, 54, 53, 46, 54, 56, 10, 55, 54, 54, 55, 124, 49, 48, 50, 50, 57, 56, 48, 46, 49, 53, 10, 54, 53, 53, 57, 124, 49, 48, 50, 49, 54, 51, 53, 46, 52, 53, 10, 49, 55, 52, 56, 56, 124, 49, 48, 50, 49, 54, 49, 50, 46, 49, 51, 10, 49, 54, 48, 53, 57, 124, 49, 48, 49, 57, 55, 56, 49, 46, 49, 57, 10, 55, 54, 51, 51, 124, 49, 48, 49, 56, 55, 56, 50, 46, 53, 55, 10, 49, 48, 48, 51, 50, 124, 49, 48, 49, 54, 56, 48, 57, 46, 53, 48, 10, 50, 56, 57, 57, 124, 49, 48, 49, 54, 52, 51, 56, 46, 55, 54, 10, 49, 52, 54, 50, 56, 124, 49, 48, 49, 54, 48, 51, 51, 46, 50, 48, 10, 49, 48, 49, 50, 54, 124, 49, 48, 49, 53, 56, 52, 54, 46, 55, 56, 10, 51, 56, 56, 52, 124, 49, 48, 49, 52, 52, 49, 51, 46, 53, 48, 10, 49, 54, 57, 49, 51, 124, 49, 48, 49, 51, 54, 48, 52, 46, 52, 48, 10, 49, 56, 54, 52, 52, 124, 49, 48, 49, 48, 50, 56, 56, 46, 49, 48, 10, 49, 57, 56, 55, 48, 124, 49, 48, 48, 55, 57, 49, 57, 46, 51, 54, 10, 49, 56, 53, 54, 52, 124, 49, 48, 48, 55, 52, 49, 54, 46, 50, 48, 10, 49, 48, 49, 55, 57, 124, 49, 48, 48, 52, 57, 50, 48, 46, 48, 48, 10, 56, 56, 51, 124, 49, 48, 48, 52, 54, 53, 48, 46, 54, 56, 10, 51, 54, 50, 55, 124, 49, 48, 48, 52, 52, 54, 49, 46, 48, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q12[] = {108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 124, 104, 105, 103, 104, 95, 108, 105, 110, 101, 95, 99, 111, 117, 110, 116, 124, 108, 111, 119, 95, 108, 105, 110, 101, 95, 99, 111, 117, 110, 116, 10, 77, 65, 73, 76, 124, 54, 52, 55, 124, 57, 52, 53, 10, 83, 72, 73, 80, 124, 54, 50, 48, 124, 57, 52, 51, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q13[] = {99, 95, 99, 111, 117, 110, 116, 124, 99, 117, 115, 116, 100, 105, 115, 116, 10, 48, 124, 53, 48, 48, 48, 10, 49, 48, 124, 54, 54, 53, 10, 57, 124, 54, 53, 55, 10, 49, 49, 124, 54, 50, 49, 10, 49, 50, 124, 53, 54, 55, 10, 56, 124, 53, 54, 52, 10, 49, 51, 124, 52, 57, 50, 10, 49, 56, 124, 52, 56, 50, 10, 55, 124, 52, 56, 48, 10, 50, 48, 124, 52, 53, 54, 10, 49, 52, 124, 52, 53, 54, 10, 49, 54, 124, 52, 52, 57, 10, 49, 57, 124, 52, 52, 55, 10, 49, 53, 124, 52, 51, 50, 10, 49, 55, 124, 52, 50, 51, 10, 50, 49, 124, 52, 49, 50, 10, 50, 50, 124, 51, 55, 49, 10, 54, 124, 51, 51, 55, 10, 50, 51, 124, 51, 50, 51, 10, 50, 52, 124, 50, 53, 54, 10, 50, 53, 124, 50, 48, 52, 10, 53, 124, 50, 48, 52, 10, 50, 54, 124, 49, 53, 53, 10, 50, 55, 124, 49, 52, 49, 10, 50, 56, 124, 57, 55, 10, 52, 124, 57, 52, 10, 50, 57, 124, 54, 52, 10, 51, 124, 52, 56, 10, 51, 48, 124, 50, 55, 10, 51, 49, 124, 50, 54, 10, 51, 50, 124, 49, 52, 10, 51, 51, 124, 49, 49, 10, 50, 124, 49, 49, 10, 51, 52, 124, 54, 10, 51, 53, 124, 53, 10, 49, 124, 50, 10, 51, 54, 124, 49, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q14[] = {112, 114, 111, 109, 111, 95, 114, 101, 118, 101, 110, 117, 101, 10, 49, 54, 46, 50, 56, 51, 56, 53, 53, 54, 56, 57, 48, 48, 53, 57, 55, 57, 53, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q15[] = {115, 95, 115, 117, 112, 112, 107, 101, 121, 124, 115, 95, 110, 97, 109, 101, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 124, 115, 95, 112, 104, 111, 110, 101, 124, 116, 111, 116, 97, 108, 95, 114, 101, 118, 101, 110, 117, 101, 10, 54, 55, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 55, 55, 124, 84, 69, 74, 32, 76, 77, 107, 84, 110, 89, 53, 104, 112, 56, 97, 81, 99, 107, 122, 121, 98, 124, 50, 51, 45, 50, 57, 48, 45, 54, 51, 57, 45, 51, 51, 49, 53, 124, 49, 54, 49, 52, 52, 49, 48, 46, 50, 57, 50, 56, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q16[] = {112, 95, 98, 114, 97, 110, 100, 124, 112, 95, 116, 121, 112, 101, 124, 112, 95, 115, 105, 122, 101, 124, 115, 117, 112, 112, 108, 105, 101, 114, 95, 99, 110, 116, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 55, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 55, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 51, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 51, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 51, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 51, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 51, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q17[] = {97, 118, 103, 95, 121, 101, 97, 114, 108, 121, 10, 50, 51, 53, 49, 50, 46, 55, 53, 50, 56, 53, 55, 49, 52, 50, 56, 53, 55, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q18[] = {99, 95, 110, 97, 109, 101, 124, 99, 95, 99, 117, 115, 116, 107, 101, 121, 124, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 124, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 124, 111, 95, 116, 111, 116, 97, 108, 112, 114, 105, 99, 101, 124, 115, 117, 109, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 54, 51, 57, 124, 49, 54, 51, 57, 124, 53, 48, 50, 56, 56, 54, 124, 49, 57, 57, 52, 45, 48, 52, 45, 49, 50, 124, 52, 53, 54, 52, 50, 51, 46, 56, 56, 124, 51, 49, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 54, 54, 53, 53, 124, 54, 54, 53, 53, 124, 50, 57, 49, 53, 56, 124, 49, 57, 57, 53, 45, 49, 48, 45, 50, 49, 124, 52, 53, 50, 56, 48, 53, 46, 48, 50, 124, 51, 48, 53, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 52, 49, 49, 48, 124, 49, 52, 49, 49, 48, 124, 53, 54, 53, 53, 55, 52, 124, 49, 57, 57, 53, 45, 48, 57, 45, 50, 52, 124, 52, 50, 53, 48, 57, 57, 46, 56, 53, 124, 51, 48, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 49, 55, 55, 53, 124, 49, 55, 55, 53, 124, 54, 56, 56, 50, 124, 49, 57, 57, 55, 45, 48, 52, 45, 48, 57, 124, 52, 48, 56, 51, 54, 56, 46, 49, 48, 124, 51, 48, 51, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 49, 52, 53, 57, 124, 49, 49, 52, 53, 57, 124, 53, 53, 49, 49, 51, 54, 124, 49, 57, 57, 51, 45, 48, 53, 45, 49, 57, 124, 51, 56, 54, 56, 49, 50, 46, 55, 52, 124, 51, 48, 56, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q19[] = {114, 101, 118, 101, 110, 117, 101, 10, 49, 54, 56, 53, 57, 55, 46, 50, 56, 54, 48, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q20[] = {115, 95, 110, 97, 109, 101, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 53, 55, 124, 49, 69, 109, 107, 67, 65, 112, 76, 53, 105, 70, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 57, 55, 124, 51, 111, 89, 113, 79, 68, 68, 85, 71, 72, 51, 88, 115, 72, 88, 109, 80, 117, 122, 89, 72, 87, 53, 78, 76, 85, 51, 44, 79, 78, 90, 108, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 56, 55, 124, 85, 81, 82, 56, 98, 85, 65, 52, 86, 50, 72, 120, 86, 98, 119, 57, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 55, 56, 124, 109, 76, 80, 74, 116, 112, 117, 52, 119, 79, 99, 32, 99, 83, 70, 122, 66, 82, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 51, 48, 124, 48, 66, 118, 111, 101, 119, 67, 80, 103, 50, 115, 99, 79, 69, 102, 117, 76, 57, 51, 70, 82, 75, 113, 83, 120, 72, 109, 100, 104, 119, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 53, 53, 124, 56, 76, 112, 48, 81, 87, 80, 76, 70, 88, 114, 74, 114, 88, 49, 115, 84, 87, 107, 65, 69, 100, 122, 85, 115, 104, 53, 107, 101, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 53, 55, 124, 73, 72, 44, 118, 54, 51, 74, 82, 103, 88, 77, 107, 86, 104, 74, 79, 74, 32, 71, 120, 117, 114, 48, 87, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 50, 57, 124, 67, 65, 79, 71, 89, 67, 66, 116, 84, 86, 84, 55, 97, 66, 49, 112, 54, 113, 72, 98, 120, 70, 54, 86, 86, 104, 88, 97, 72, 76, 103, 84, 112, 73, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 51, 53, 124, 74, 72, 82, 83, 79, 116, 101, 114, 89, 103, 116, 52, 77, 84, 78, 111, 55, 99, 117, 112, 84, 122, 65, 44, 54, 77, 111, 78, 119, 32, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q21[] = {115, 95, 110, 97, 109, 101, 124, 110, 117, 109, 119, 97, 105, 116, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 52, 53, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 50, 53, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 48, 57, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 54, 50, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 53, 55, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 57, 57, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 57, 54, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 55, 55, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 52, 52, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 56, 56, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 49, 53, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 55, 50, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 51, 51, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 48, 56, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 56, 57, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 56, 48, 124, 49, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 48, 50, 124, 49, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 53, 57, 124, 49, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 50, 49, 124, 49, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 50, 57, 124, 49, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 54, 50, 124, 49, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 54, 48, 124, 49, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 56, 54, 124, 49, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 54, 57, 124, 49, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 49, 56, 124, 49, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 55, 56, 124, 49, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 54, 55, 124, 57, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 55, 56, 124, 57, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 55, 51, 124, 57, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 56, 55, 124, 57, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 55, 52, 124, 56, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 54, 53, 124, 56, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 52, 56, 124, 56, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 49, 56, 124, 56, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 50, 55, 124, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 48, 51, 124, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 49, 48, 124, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 55, 48, 124, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 49, 49, 124, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 49, 52, 124, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 55, 57, 124, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 51, 54, 124, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 48, 48, 124, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 54, 48, 124, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 56, 56, 124, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 52, 54, 124, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 50, 48, 124, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF0_1_q22[] = {99, 110, 116, 114, 121, 99, 111, 100, 101, 124, 110, 117, 109, 99, 117, 115, 116, 124, 116, 111, 116, 97, 99, 99, 116, 98, 97, 108, 10, 49, 51, 124, 57, 52, 124, 55, 49, 52, 48, 51, 53, 46, 48, 53, 10, 49, 55, 124, 57, 54, 124, 55, 50, 50, 53, 54, 48, 46, 49, 53, 10, 49, 56, 124, 57, 57, 124, 55, 51, 56, 48, 49, 50, 46, 53, 50, 10, 50, 51, 124, 57, 51, 124, 55, 48, 56, 50, 56, 53, 46, 50, 53, 10, 50, 57, 124, 56, 53, 124, 54, 51, 50, 54, 57, 51, 46, 52, 54, 10, 51, 48, 124, 56, 55, 124, 54, 52, 54, 55, 52, 56, 46, 48, 50, 10, 51, 49, 124, 56, 55, 124, 54, 52, 55, 51, 55, 50, 46, 53, 48, 10, 0};
-const char *TPCH_ANSWERS_SF0_1[] = {
-	(const char*) TPCH_ANSWERS_SF0_1_q01,
-	(const char*) TPCH_ANSWERS_SF0_1_q02,
-	(const char*) TPCH_ANSWERS_SF0_1_q03,
-	(const char*) TPCH_ANSWERS_SF0_1_q04,
-	(const char*) TPCH_ANSWERS_SF0_1_q05,
-	(const char*) TPCH_ANSWERS_SF0_1_q06,
-	(const char*) TPCH_ANSWERS_SF0_1_q07,
-	(const char*) TPCH_ANSWERS_SF0_1_q08,
-	(const char*) TPCH_ANSWERS_SF0_1_q09,
-	(const char*) TPCH_ANSWERS_SF0_1_q10,
-	(const char*) TPCH_ANSWERS_SF0_1_q11,
-	(const char*) TPCH_ANSWERS_SF0_1_q12,
-	(const char*) TPCH_ANSWERS_SF0_1_q13,
-	(const char*) TPCH_ANSWERS_SF0_1_q14,
-	(const char*) TPCH_ANSWERS_SF0_1_q15,
-	(const char*) TPCH_ANSWERS_SF0_1_q16,
-	(const char*) TPCH_ANSWERS_SF0_1_q17,
-	(const char*) TPCH_ANSWERS_SF0_1_q18,
-	(const char*) TPCH_ANSWERS_SF0_1_q19,
-	(const char*) TPCH_ANSWERS_SF0_1_q20,
-	(const char*) TPCH_ANSWERS_SF0_1_q21,
-	(const char*) TPCH_ANSWERS_SF0_1_q22
-};
-const uint8_t TPCH_ANSWERS_SF1_q01[] = {108, 95, 114, 101, 116, 117, 114, 110, 102, 108, 97, 103, 124, 108, 95, 108, 105, 110, 101, 115, 116, 97, 116, 117, 115, 124, 115, 117, 109, 95, 113, 116, 121, 124, 115, 117, 109, 95, 98, 97, 115, 101, 95, 112, 114, 105, 99, 101, 124, 115, 117, 109, 95, 100, 105, 115, 99, 95, 112, 114, 105, 99, 101, 124, 115, 117, 109, 95, 99, 104, 97, 114, 103, 101, 124, 97, 118, 103, 95, 113, 116, 121, 124, 97, 118, 103, 95, 112, 114, 105, 99, 101, 124, 97, 118, 103, 95, 100, 105, 115, 99, 124, 99, 111, 117, 110, 116, 95, 111, 114, 100, 101, 114, 10, 65, 124, 70, 124, 51, 55, 55, 51, 52, 49, 48, 55, 124, 53, 54, 53, 56, 54, 53, 53, 52, 52, 48, 48, 46, 55, 51, 124, 53, 51, 55, 53, 56, 50, 53, 55, 49, 51, 52, 46, 56, 55, 48, 48, 124, 53, 53, 57, 48, 57, 48, 54, 53, 50, 50, 50, 46, 56, 50, 55, 54, 57, 50, 124, 50, 53, 46, 53, 50, 50, 48, 124, 51, 56, 50, 55, 51, 46, 49, 50, 57, 55, 124, 48, 46, 48, 53, 48, 48, 124, 49, 52, 55, 56, 52, 57, 51, 10, 78, 124, 70, 124, 57, 57, 49, 52, 49, 55, 124, 49, 52, 56, 55, 53, 48, 52, 55, 49, 48, 46, 51, 56, 124, 49, 52, 49, 51, 48, 56, 50, 49, 54, 56, 46, 48, 53, 52, 49, 124, 49, 52, 54, 57, 54, 52, 57, 50, 50, 51, 46, 49, 57, 52, 51, 55, 53, 124, 50, 53, 46, 53, 49, 54, 53, 124, 51, 56, 50, 56, 52, 46, 52, 54, 55, 56, 124, 48, 46, 48, 53, 48, 49, 124, 51, 56, 56, 53, 52, 10, 78, 124, 79, 124, 55, 52, 52, 55, 54, 48, 52, 48, 124, 49, 49, 49, 55, 48, 49, 55, 50, 57, 54, 57, 55, 46, 55, 52, 124, 49, 48, 54, 49, 49, 56, 50, 51, 48, 51, 48, 55, 46, 54, 48, 53, 54, 124, 49, 49, 48, 51, 54, 55, 48, 52, 51, 56, 55, 50, 46, 52, 57, 55, 48, 49, 48, 124, 50, 53, 46, 53, 48, 50, 50, 124, 51, 56, 50, 52, 57, 46, 49, 49, 56, 48, 124, 48, 46, 48, 53, 48, 48, 124, 50, 57, 50, 48, 51, 55, 52, 10, 82, 124, 70, 124, 51, 55, 55, 49, 57, 55, 53, 51, 124, 53, 54, 53, 54, 56, 48, 52, 49, 51, 56, 48, 46, 57, 48, 124, 53, 51, 55, 52, 49, 50, 57, 50, 54, 56, 52, 46, 54, 48, 52, 48, 124, 53, 53, 56, 56, 57, 54, 49, 57, 49, 49, 57, 46, 56, 51, 49, 57, 51, 50, 124, 50, 53, 46, 53, 48, 53, 56, 124, 51, 56, 50, 53, 48, 46, 56, 53, 52, 54, 124, 48, 46, 48, 53, 48, 48, 124, 49, 52, 55, 56, 56, 55, 48, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q02[] = {115, 95, 97, 99, 99, 116, 98, 97, 108, 124, 115, 95, 110, 97, 109, 101, 124, 110, 95, 110, 97, 109, 101, 124, 112, 95, 112, 97, 114, 116, 107, 101, 121, 124, 112, 95, 109, 102, 103, 114, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 124, 115, 95, 112, 104, 111, 110, 101, 124, 115, 95, 99, 111, 109, 109, 101, 110, 116, 10, 57, 57, 51, 56, 46, 53, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 51, 53, 57, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 56, 53, 51, 53, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 98, 103, 120, 106, 50, 75, 48, 119, 49, 107, 74, 118, 120, 89, 108, 53, 109, 104, 67, 102, 111, 117, 44, 87, 124, 51, 51, 45, 52, 50, 57, 45, 55, 57, 48, 45, 54, 49, 51, 49, 124, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 104, 97, 103, 10, 57, 57, 51, 55, 46, 56, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 57, 54, 57, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 48, 56, 52, 51, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 114, 100, 110, 109, 100, 57, 99, 56, 69, 71, 49, 69, 73, 65, 89, 89, 51, 76, 80, 86, 97, 52, 121, 85, 78, 120, 54, 79, 119, 121, 86, 97, 81, 124, 50, 57, 45, 53, 50, 48, 45, 54, 57, 50, 45, 51, 53, 51, 55, 124, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 46, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 10, 57, 57, 51, 54, 46, 50, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 50, 53, 48, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 50, 52, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 113, 88, 32, 65, 66, 48, 118, 80, 56, 109, 74, 69, 87, 101, 66, 117, 89, 57, 106, 114, 105, 124, 51, 51, 45, 51, 50, 48, 45, 50, 50, 56, 45, 50, 57, 53, 55, 124, 101, 116, 101, 99, 116, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 115, 108, 121, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 32, 115, 108, 101, 101, 112, 32, 105, 110, 115, 105, 100, 101, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 10, 57, 57, 50, 51, 46, 55, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 50, 52, 124, 71, 69, 82, 77, 65, 78, 89, 124, 50, 57, 56, 50, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 117, 88, 99, 110, 82, 55, 116, 118, 56, 55, 100, 71, 124, 49, 55, 45, 55, 55, 57, 45, 50, 57, 57, 45, 49, 56, 51, 57, 124, 97, 99, 107, 97, 103, 101, 115, 32, 98, 111, 111, 115, 116, 32, 98, 108, 105, 116, 104, 101, 108, 121, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 99, 10, 57, 56, 55, 49, 46, 50, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 51, 55, 51, 124, 71, 69, 82, 77, 65, 78, 89, 124, 52, 51, 56, 54, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 105, 83, 76, 79, 51, 53, 122, 55, 65, 101, 124, 49, 55, 45, 56, 49, 51, 45, 52, 56, 53, 45, 56, 54, 51, 55, 124, 101, 116, 101, 99, 116, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 98, 111, 108, 100, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 46, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 119, 97, 107, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 59, 32, 98, 108, 105, 116, 10, 57, 56, 55, 48, 46, 55, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 50, 56, 54, 124, 71, 69, 82, 77, 65, 78, 89, 124, 56, 49, 50, 56, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 51, 103, 113, 48, 109, 90, 76, 72, 73, 53, 79, 84, 77, 54, 32, 116, 66, 89, 109, 76, 84, 72, 90, 97, 117, 108, 67, 89, 110, 108, 69, 67, 122, 81, 55, 110, 106, 124, 49, 55, 45, 53, 49, 54, 45, 57, 50, 52, 45, 52, 53, 55, 52, 124, 32, 114, 101, 103, 117, 108, 97, 114, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 99, 111, 117, 114, 116, 115, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 102, 105, 10, 57, 56, 55, 48, 46, 55, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 50, 56, 54, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 56, 49, 50, 56, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 51, 103, 113, 48, 109, 90, 76, 72, 73, 53, 79, 84, 77, 54, 32, 116, 66, 89, 109, 76, 84, 72, 90, 97, 117, 108, 67, 89, 110, 108, 69, 67, 122, 81, 55, 110, 106, 124, 49, 55, 45, 53, 49, 54, 45, 57, 50, 52, 45, 52, 53, 55, 52, 124, 32, 114, 101, 103, 117, 108, 97, 114, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 99, 111, 117, 114, 116, 115, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 102, 105, 10, 57, 56, 53, 50, 46, 53, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 57, 55, 51, 124, 82, 85, 83, 83, 73, 65, 124, 49, 56, 57, 55, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 122, 86, 102, 85, 84, 51, 78, 112, 50, 50, 107, 85, 67, 48, 53, 116, 89, 87, 72, 66, 111, 116, 97, 82, 124, 51, 50, 45, 49, 56, 56, 45, 53, 57, 52, 45, 55, 48, 51, 56, 124, 114, 110, 115, 32, 119, 97, 107, 101, 32, 102, 105, 110, 97, 108, 32, 102, 111, 120, 101, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 100, 101, 112, 101, 110, 100, 101, 10, 57, 56, 52, 55, 46, 56, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 48, 57, 55, 124, 82, 85, 83, 83, 73, 65, 124, 49, 51, 48, 53, 53, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 118, 101, 77, 82, 84, 81, 66, 109, 85, 82, 101, 115, 78, 118, 102, 68, 51, 124, 51, 50, 45, 51, 55, 53, 45, 54, 52, 48, 45, 51, 53, 57, 51, 124, 32, 116, 104, 101, 32, 115, 112, 101, 99, 105, 97, 108, 32, 101, 120, 99, 117, 115, 101, 115, 46, 32, 115, 105, 108, 101, 110, 116, 32, 115, 101, 110, 116, 105, 109, 101, 110, 116, 115, 32, 115, 101, 114, 118, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 10, 57, 56, 52, 55, 46, 53, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 51, 52, 53, 124, 70, 82, 65, 78, 67, 69, 124, 56, 54, 51, 52, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 54, 56, 121, 88, 32, 116, 71, 88, 65, 107, 86, 82, 83, 120, 85, 71, 78, 83, 106, 74, 100, 112, 116, 119, 32, 56, 79, 56, 55, 56, 120, 97, 70, 110, 97, 111, 81, 75, 124, 49, 54, 45, 56, 56, 54, 45, 55, 54, 54, 45, 55, 57, 52, 53, 124, 103, 101, 115, 46, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 97, 114, 101, 46, 32, 114, 117, 116, 104, 108, 101, 115, 115, 44, 32, 101, 120, 112, 114, 101, 115, 115, 32, 101, 120, 99, 117, 115, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 117, 110, 117, 10, 57, 56, 52, 55, 46, 53, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 51, 52, 53, 124, 70, 82, 65, 78, 67, 69, 124, 49, 55, 51, 56, 50, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 54, 56, 121, 88, 32, 116, 71, 88, 65, 107, 86, 82, 83, 120, 85, 71, 78, 83, 106, 74, 100, 112, 116, 119, 32, 56, 79, 56, 55, 56, 120, 97, 70, 110, 97, 111, 81, 75, 124, 49, 54, 45, 56, 56, 54, 45, 55, 54, 54, 45, 55, 57, 52, 53, 124, 103, 101, 115, 46, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 97, 114, 101, 46, 32, 114, 117, 116, 104, 108, 101, 115, 115, 44, 32, 101, 120, 112, 114, 101, 115, 115, 32, 101, 120, 99, 117, 115, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 117, 110, 117, 10, 57, 56, 51, 54, 46, 57, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 51, 52, 50, 124, 82, 85, 83, 83, 73, 65, 124, 52, 56, 52, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 105, 99, 70, 103, 84, 112, 90, 48, 84, 117, 65, 109, 49, 56, 56, 100, 118, 124, 51, 50, 45, 51, 57, 57, 45, 52, 49, 52, 45, 53, 51, 56, 53, 124, 98, 108, 105, 116, 104, 101, 108, 121, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 98, 111, 108, 100, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46, 32, 102, 117, 114, 10, 57, 56, 49, 55, 46, 49, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 53, 50, 124, 82, 85, 83, 83, 73, 65, 124, 49, 50, 52, 56, 49, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 88, 102, 76, 67, 106, 55, 49, 72, 75, 72, 110, 80, 113, 103, 118, 115, 55, 75, 78, 103, 80, 75, 99, 79, 87, 111, 87, 120, 111, 50, 119, 124, 51, 50, 45, 53, 53, 49, 45, 56, 51, 49, 45, 49, 52, 51, 55, 124, 119, 97, 107, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 97, 108, 111, 110, 103, 115, 105, 100, 101, 32, 111, 102, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 105, 110, 97, 108, 32, 101, 120, 10, 57, 56, 49, 55, 46, 49, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 53, 50, 124, 82, 85, 83, 83, 73, 65, 124, 49, 53, 50, 51, 53, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 88, 102, 76, 67, 106, 55, 49, 72, 75, 72, 110, 80, 113, 103, 118, 115, 55, 75, 78, 103, 80, 75, 99, 79, 87, 111, 87, 120, 111, 50, 119, 124, 51, 50, 45, 53, 53, 49, 45, 56, 51, 49, 45, 49, 52, 51, 55, 124, 119, 97, 107, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 97, 108, 111, 110, 103, 115, 105, 100, 101, 32, 111, 102, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 105, 110, 97, 108, 32, 101, 120, 10, 57, 55, 51, 57, 46, 56, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 51, 56, 52, 124, 70, 82, 65, 78, 67, 69, 124, 49, 51, 56, 51, 53, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 68, 48, 49, 88, 119, 88, 98, 99, 73, 76, 78, 119, 109, 114, 71, 83, 54, 90, 80, 114, 86, 104, 90, 120, 79, 52, 48, 105, 124, 49, 54, 45, 52, 57, 52, 45, 57, 49, 51, 45, 53, 57, 50, 53, 124, 115, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 98, 111, 108, 100, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 115, 108, 101, 101, 112, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 105, 100, 108, 121, 32, 102, 105, 110, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 58, 32, 113, 117, 105, 99, 107, 108, 121, 32, 102, 105, 110, 97, 108, 10, 57, 55, 50, 49, 46, 57, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 55, 53, 55, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 53, 54, 50, 52, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 114, 121, 75, 85, 107, 69, 101, 87, 78, 55, 90, 124, 51, 51, 45, 56, 50, 49, 45, 52, 48, 55, 45, 50, 57, 57, 53, 124, 101, 101, 112, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 97, 117, 116, 101, 114, 110, 101, 115, 59, 32, 113, 117, 105, 99, 107, 108, 10, 57, 54, 56, 49, 46, 51, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 52, 48, 54, 124, 82, 85, 83, 83, 73, 65, 124, 55, 56, 52, 48, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 49, 65, 54, 120, 51, 80, 76, 121, 54, 70, 124, 51, 50, 45, 49, 51, 57, 45, 56, 55, 51, 45, 56, 53, 55, 49, 124, 104, 97, 103, 103, 108, 101, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 101, 120, 99, 117, 115, 101, 115, 46, 32, 113, 117, 105, 99, 10, 57, 54, 52, 51, 46, 53, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 49, 52, 56, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 48, 55, 54, 49, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 72, 55, 87, 79, 73, 54, 108, 122, 70, 117, 83, 115, 87, 122, 84, 83, 66, 114, 104, 122, 84, 89, 86, 124, 50, 57, 45, 50, 53, 50, 45, 54, 49, 55, 45, 52, 56, 53, 48, 124, 102, 105, 110, 97, 108, 32, 101, 120, 99, 117, 115, 101, 115, 46, 32, 102, 105, 110, 97, 108, 32, 105, 100, 101, 97, 115, 32, 98, 111, 111, 115, 116, 32, 113, 117, 105, 99, 107, 108, 121, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 112, 101, 99, 105, 10, 57, 54, 50, 52, 46, 56, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 56, 49, 54, 124, 70, 82, 65, 78, 67, 69, 124, 51, 52, 51, 48, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 78, 84, 119, 81, 80, 83, 90, 119, 102, 104, 99, 52, 117, 117, 49, 69, 77, 118, 69, 68, 111, 112, 66, 110, 69, 118, 50, 106, 32, 80, 124, 49, 54, 45, 51, 57, 50, 45, 50, 51, 55, 45, 54, 55, 50, 54, 124, 101, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 114, 101, 32, 97, 114, 111, 117, 110, 100, 32, 116, 104, 101, 32, 115, 112, 101, 99, 105, 97, 108, 32, 105, 100, 101, 97, 115, 46, 32, 115, 112, 101, 99, 105, 97, 108, 44, 32, 112, 101, 110, 100, 105, 110, 103, 32, 102, 111, 120, 101, 115, 32, 117, 115, 10, 57, 54, 50, 52, 46, 55, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 54, 53, 56, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 56, 57, 54, 53, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 68, 109, 82, 120, 112, 76, 109, 76, 56, 56, 88, 67, 66, 105, 79, 78, 66, 51, 116, 113, 51, 101, 48, 117, 124, 50, 57, 45, 55, 52, 56, 45, 56, 55, 54, 45, 50, 48, 49, 52, 124, 114, 111, 110, 105, 99, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 32, 119, 97, 107, 101, 32, 98, 114, 97, 118, 101, 108, 121, 32, 102, 105, 110, 97, 108, 10, 57, 54, 49, 50, 46, 57, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 50, 56, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 50, 48, 55, 49, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 104, 110, 78, 66, 100, 104, 100, 88, 79, 52, 121, 84, 49, 56, 32, 81, 78, 65, 66, 84, 114, 76, 56, 102, 117, 118, 48, 65, 52, 112, 124, 50, 57, 45, 51, 50, 53, 45, 55, 56, 52, 45, 56, 49, 56, 55, 124, 119, 97, 114, 104, 111, 114, 115, 101, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 101, 118, 101, 110, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 115, 117, 98, 108, 97, 116, 101, 32, 100, 97, 114, 105, 110, 103, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 46, 32, 115, 108, 121, 108, 121, 32, 98, 108, 105, 116, 104, 101, 32, 116, 10, 57, 54, 49, 50, 46, 57, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 50, 56, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 56, 49, 56, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 104, 110, 78, 66, 100, 104, 100, 88, 79, 52, 121, 84, 49, 56, 32, 81, 78, 65, 66, 84, 114, 76, 56, 102, 117, 118, 48, 65, 52, 112, 124, 50, 57, 45, 51, 50, 53, 45, 55, 56, 52, 45, 56, 49, 56, 55, 124, 119, 97, 114, 104, 111, 114, 115, 101, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 101, 118, 101, 110, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 115, 117, 98, 108, 97, 116, 101, 32, 100, 97, 114, 105, 110, 103, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 46, 32, 115, 108, 121, 108, 121, 32, 98, 108, 105, 116, 104, 101, 32, 116, 10, 57, 53, 55, 49, 46, 56, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 51, 48, 53, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 55, 57, 50, 55, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 66, 100, 106, 49, 84, 53, 69, 111, 115, 116, 76, 118, 101, 98, 57, 111, 99, 82, 98, 122, 124, 50, 57, 45, 57, 55, 51, 45, 52, 56, 49, 45, 49, 56, 51, 49, 124, 107, 108, 121, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 46, 32, 102, 117, 114, 105, 111, 117, 10, 57, 53, 53, 56, 46, 49, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 53, 51, 50, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 56, 56, 53, 49, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 110, 99, 77, 120, 73, 74, 99, 68, 89, 90, 100, 53, 66, 55, 70, 108, 75, 120, 120, 76, 109, 110, 108, 122, 80, 101, 90, 66, 44, 70, 75, 66, 117, 106, 66, 124, 51, 51, 45, 49, 53, 50, 45, 51, 48, 49, 45, 50, 49, 54, 52, 124, 32, 102, 111, 120, 101, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 101, 118, 101, 110, 32, 101, 120, 99, 117, 115, 101, 115, 32, 117, 115, 101, 46, 32, 115, 108, 121, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 102, 111, 120, 101, 115, 32, 110, 97, 103, 32, 98, 108, 10, 57, 52, 57, 50, 46, 55, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 57, 55, 53, 124, 71, 69, 82, 77, 65, 78, 89, 124, 50, 53, 57, 55, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 57, 85, 69, 105, 73, 112, 55, 117, 83, 89, 116, 84, 70, 53, 124, 49, 55, 45, 57, 57, 50, 45, 53, 55, 57, 45, 52, 56, 51, 57, 124, 97, 114, 101, 102, 117, 108, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 101, 120, 99, 117, 115, 101, 115, 32, 98, 111, 111, 115, 116, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 112, 10, 57, 52, 54, 49, 46, 48, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 53, 51, 54, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 50, 48, 48, 51, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 84, 69, 69, 107, 80, 117, 115, 81, 54, 114, 85, 49, 56, 89, 118, 105, 120, 69, 55, 73, 81, 116, 66, 68, 79, 121, 82, 66, 100, 71, 111, 79, 87, 108, 50, 114, 124, 51, 51, 45, 53, 53, 54, 45, 57, 55, 51, 45, 53, 53, 50, 50, 124, 46, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 119, 97, 107, 101, 32, 115, 108, 121, 108, 121, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 119, 97, 114, 116, 104, 111, 103, 115, 32, 97, 114, 101, 46, 10, 57, 52, 53, 51, 46, 48, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 48, 50, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 55, 53, 55, 54, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 49, 85, 106, 50, 51, 81, 87, 120, 81, 106, 106, 55, 69, 121, 101, 113, 72, 87, 113, 71, 87, 84, 98, 78, 124, 50, 57, 45, 51, 52, 50, 45, 56, 56, 50, 45, 54, 52, 54, 51, 124, 103, 117, 108, 97, 114, 32, 102, 114, 101, 116, 115, 46, 32, 112, 101, 114, 109, 97, 110, 101, 110, 116, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 109, 117, 108, 116, 105, 112, 108, 105, 101, 114, 115, 32, 98, 101, 108, 105, 101, 118, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 108, 111, 110, 103, 115, 10, 57, 52, 48, 56, 46, 54, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 55, 55, 50, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 49, 55, 55, 55, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 114, 73, 111, 86, 50, 114, 106, 48, 75, 78, 121, 44, 73, 84, 124, 51, 51, 45, 49, 53, 50, 45, 52, 57, 49, 45, 49, 49, 50, 54, 124, 110, 97, 103, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 102, 105, 110, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 98, 108, 105, 116, 10, 57, 51, 53, 57, 46, 54, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 56, 53, 54, 124, 82, 79, 77, 65, 78, 73, 65, 124, 54, 50, 51, 52, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 107, 50, 67, 75, 79, 109, 88, 104, 80, 114, 117, 74, 90, 124, 50, 57, 45, 51, 51, 52, 45, 56, 55, 48, 45, 57, 55, 51, 49, 124, 121, 32, 105, 114, 111, 110, 105, 99, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 115, 105, 108, 101, 10, 57, 51, 53, 55, 46, 52, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 49, 56, 56, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 51, 56, 54, 52, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 76, 83, 44, 90, 48, 32, 122, 98, 83, 118, 67, 55, 71, 87, 106, 70, 124, 51, 51, 45, 53, 56, 51, 45, 54, 48, 55, 45, 49, 54, 51, 51, 124, 111, 117, 115, 108, 121, 32, 97, 108, 119, 97, 121, 115, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 97, 99, 107, 97, 103, 101, 115, 46, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 101, 118, 101, 110, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 98, 101, 110, 101, 97, 116, 104, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 102, 105, 110, 97, 108, 32, 112, 97, 99, 107, 10, 57, 51, 53, 50, 46, 48, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 52, 51, 57, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 55, 48, 57, 50, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 66, 50, 98, 110, 75, 68, 73, 112, 107, 74, 112, 50, 117, 72, 75, 112, 124, 49, 55, 45, 49, 50, 56, 45, 57, 57, 54, 45, 52, 54, 53, 48, 124, 32, 97, 99, 99, 111, 114, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 98, 111, 108, 100, 32, 105, 100, 101, 97, 115, 10, 57, 51, 49, 50, 46, 57, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 56, 48, 55, 124, 82, 85, 83, 83, 73, 65, 124, 57, 48, 50, 55, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 68, 107, 50, 101, 98, 112, 71, 82, 51, 106, 108, 112, 89, 98, 112, 77, 103, 57, 68, 106, 114, 124, 51, 50, 45, 54, 55, 51, 45, 56, 55, 50, 45, 53, 56, 53, 52, 124, 101, 99, 105, 97, 108, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 112, 101, 110, 100, 105, 110, 103, 44, 32, 101, 118, 101, 110, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 117, 115, 101, 32, 114, 101, 103, 117, 108, 97, 10, 57, 51, 49, 50, 46, 57, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 56, 48, 55, 124, 82, 85, 83, 83, 73, 65, 124, 49, 48, 48, 50, 55, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 68, 107, 50, 101, 98, 112, 71, 82, 51, 106, 108, 112, 89, 98, 112, 77, 103, 57, 68, 106, 114, 124, 51, 50, 45, 54, 55, 51, 45, 56, 55, 50, 45, 53, 56, 53, 52, 124, 101, 99, 105, 97, 108, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 112, 101, 110, 100, 105, 110, 103, 44, 32, 101, 118, 101, 110, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 117, 115, 101, 32, 114, 101, 103, 117, 108, 97, 10, 57, 50, 56, 48, 46, 50, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 49, 57, 52, 124, 82, 79, 77, 65, 78, 73, 65, 124, 52, 55, 49, 57, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 116, 74, 57, 54, 97, 72, 112, 56, 32, 108, 51, 117, 105, 113, 51, 56, 76, 105, 68, 72, 115, 119, 116, 107, 57, 98, 72, 77, 103, 124, 50, 57, 45, 51, 49, 56, 45, 52, 53, 52, 45, 50, 49, 51, 51, 124, 111, 32, 98, 101, 97, 110, 115, 32, 104, 97, 103, 103, 108, 101, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 115, 105, 108, 101, 110, 116, 32, 100, 111, 108, 112, 104, 105, 110, 115, 32, 99, 97, 106, 111, 108, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 10, 57, 50, 55, 52, 46, 56, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 56, 53, 52, 124, 82, 85, 83, 83, 73, 65, 124, 55, 54, 51, 52, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 44, 117, 74, 102, 67, 100, 54, 101, 84, 105, 89, 69, 49, 90, 69, 104, 68, 77, 32, 118, 115, 99, 56, 65, 78, 81, 80, 87, 97, 80, 108, 81, 124, 51, 50, 45, 53, 50, 52, 45, 49, 52, 56, 45, 53, 50, 50, 49, 124, 121, 46, 32, 99, 111, 117, 114, 116, 115, 32, 100, 111, 32, 119, 97, 107, 101, 32, 115, 108, 121, 108, 121, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 104, 97, 103, 103, 108, 101, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 116, 104, 101, 10, 57, 50, 52, 57, 46, 51, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 57, 55, 51, 124, 70, 82, 65, 78, 67, 69, 124, 50, 54, 52, 54, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 79, 90, 83, 107, 73, 111, 122, 102, 85, 52, 70, 89, 105, 122, 107, 52, 101, 48, 57, 49, 77, 90, 72, 111, 122, 76, 49, 113, 99, 72, 101, 50, 53, 55, 74, 56, 57, 98, 87, 124, 49, 54, 45, 55, 50, 50, 45, 56, 54, 54, 45, 49, 54, 53, 56, 124, 117, 101, 115, 116, 115, 32, 97, 114, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 46, 32, 114, 101, 103, 117, 108, 97, 114, 32, 116, 105, 116, 104, 101, 115, 32, 116, 104, 114, 111, 117, 103, 104, 32, 116, 104, 101, 32, 114, 101, 103, 117, 108, 97, 114, 44, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 113, 10, 57, 50, 52, 57, 46, 51, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 57, 55, 51, 124, 70, 82, 65, 78, 67, 69, 124, 51, 51, 57, 55, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 79, 90, 83, 107, 73, 111, 122, 102, 85, 52, 70, 89, 105, 122, 107, 52, 101, 48, 57, 49, 77, 90, 72, 111, 122, 76, 49, 113, 99, 72, 101, 50, 53, 55, 74, 56, 57, 98, 87, 124, 49, 54, 45, 55, 50, 50, 45, 56, 54, 54, 45, 49, 54, 53, 56, 124, 117, 101, 115, 116, 115, 32, 97, 114, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 46, 32, 114, 101, 103, 117, 108, 97, 114, 32, 116, 105, 116, 104, 101, 115, 32, 116, 104, 114, 111, 117, 103, 104, 32, 116, 104, 101, 32, 114, 101, 103, 117, 108, 97, 114, 44, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 113, 10, 57, 50, 48, 56, 46, 55, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 55, 54, 57, 124, 82, 79, 77, 65, 78, 73, 65, 124, 52, 48, 50, 53, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 65, 122, 73, 69, 78, 116, 77, 114, 86, 67, 83, 98, 114, 106, 121, 85, 117, 56, 124, 50, 57, 45, 57, 54, 52, 45, 52, 50, 52, 45, 57, 54, 52, 57, 124, 108, 105, 116, 101, 115, 32, 119, 97, 115, 32, 113, 117, 105, 99, 107, 108, 121, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 115, 108, 121, 108, 121, 32, 101, 118, 101, 110, 32, 102, 111, 120, 101, 115, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 98, 111, 108, 100, 32, 10, 57, 50, 48, 49, 46, 52, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 54, 57, 48, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 54, 55, 49, 56, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 112, 112, 114, 112, 68, 55, 55, 70, 69, 73, 87, 115, 78, 77, 109, 71, 84, 57, 84, 124, 51, 51, 45, 49, 50, 49, 45, 50, 54, 55, 45, 57, 53, 50, 57, 124, 101, 32, 101, 118, 101, 110, 44, 32, 101, 118, 101, 110, 32, 102, 111, 120, 101, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 97, 99, 107, 97, 103, 101, 115, 46, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 108, 32, 105, 100, 101, 10, 57, 49, 57, 50, 46, 49, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 49, 49, 53, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 56, 53, 48, 57, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 69, 104, 114, 89, 121, 48, 77, 84, 53, 77, 49, 118, 102, 90, 48, 86, 52, 115, 107, 112, 105, 102, 100, 112, 54, 112, 103, 70, 122, 53, 124, 51, 51, 45, 53, 57, 55, 45, 50, 52, 56, 45, 49, 50, 50, 48, 124, 101, 115, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 98, 111, 111, 115, 116, 32, 99, 97, 114, 101, 102, 10, 57, 49, 56, 57, 46, 57, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 50, 50, 54, 124, 71, 69, 82, 77, 65, 78, 89, 124, 50, 49, 50, 50, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 66, 122, 102, 111, 65, 57, 119, 102, 116, 49, 77, 120, 51, 105, 66, 73, 115, 124, 49, 55, 45, 55, 50, 53, 45, 57, 48, 51, 45, 49, 51, 56, 49, 124, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 98, 111, 108, 100, 32, 101, 120, 99, 117, 115, 101, 115, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 98, 111, 108, 100, 32, 102, 111, 114, 103, 101, 115, 32, 119, 97, 107, 101, 32, 10, 57, 49, 50, 56, 46, 57, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 51, 49, 49, 124, 82, 85, 83, 83, 73, 65, 124, 49, 52, 54, 55, 54, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 106, 83, 105, 72, 68, 52, 78, 84, 100, 56, 105, 57, 122, 86, 82, 88, 57, 117, 122, 57, 97, 44, 124, 51, 50, 45, 49, 53, 53, 45, 52, 52, 48, 45, 55, 49, 50, 48, 124, 114, 101, 102, 117, 108, 108, 121, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 32, 104, 97, 103, 103, 108, 101, 32, 10, 57, 49, 48, 52, 46, 56, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 53, 50, 48, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 53, 48, 57, 55, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 97, 65, 57, 53, 110, 76, 110, 44, 109, 57, 115, 104, 82, 114, 80, 88, 90, 119, 57, 89, 49, 88, 124, 49, 55, 45, 55, 50, 56, 45, 56, 48, 52, 45, 49, 55, 57, 51, 124, 108, 121, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 100, 101, 112, 116, 104, 115, 46, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 108, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 98, 111, 108, 100, 32, 105, 100, 101, 97, 115, 32, 112, 114, 105, 110, 116, 10, 57, 49, 48, 49, 46, 48, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 55, 57, 49, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 50, 56, 50, 53, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 116, 120, 80, 89, 115, 112, 53, 48, 72, 74, 107, 98, 98, 97, 65, 74, 48, 98, 89, 105, 101, 113, 72, 109, 90, 116, 105, 114, 68, 85, 86, 79, 99, 109, 67, 52, 108, 107, 124, 50, 57, 45, 53, 52, 57, 45, 50, 53, 49, 45, 53, 51, 56, 52, 124, 116, 115, 46, 32, 110, 111, 116, 111, 114, 110, 105, 115, 32, 100, 101, 116, 101, 99, 116, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 98, 111, 108, 100, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 101, 118, 101, 110, 32, 112, 97, 99, 107, 97, 103, 101, 10, 57, 48, 57, 52, 46, 53, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 53, 56, 50, 124, 82, 85, 83, 83, 73, 65, 124, 51, 57, 53, 55, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 53, 112, 44, 51, 71, 112, 56, 107, 88, 32, 49, 69, 68, 97, 114, 69, 48, 74, 82, 53, 106, 117, 72, 72, 32, 83, 113, 57, 106, 108, 120, 103, 75, 101, 110, 77, 124, 51, 50, 45, 53, 56, 55, 45, 53, 55, 55, 45, 49, 51, 53, 49, 124, 106, 111, 108, 101, 46, 32, 114, 101, 103, 117, 108, 97, 114, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 115, 108, 101, 101, 112, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 102, 114, 101, 116, 115, 46, 32, 102, 105, 110, 97, 108, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 32, 112, 108, 97, 121, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 112, 97, 115, 116, 32, 116, 104, 101, 32, 10, 56, 57, 57, 54, 46, 56, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 55, 48, 50, 124, 70, 82, 65, 78, 67, 69, 124, 49, 48, 50, 49, 57, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 84, 51, 53, 79, 97, 104, 89, 88, 81, 71, 67, 124, 49, 54, 45, 56, 49, 49, 45, 50, 54, 57, 45, 56, 57, 52, 54, 124, 105, 99, 107, 108, 121, 32, 102, 105, 110, 97, 108, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 101, 120, 112, 114, 101, 115, 115, 32, 112, 108, 97, 116, 10, 56, 57, 57, 54, 46, 49, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 56, 49, 52, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 51, 57, 56, 49, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 82, 76, 44, 99, 86, 67, 75, 83, 88, 70, 99, 54, 87, 105, 110, 54, 69, 109, 116, 70, 52, 49, 53, 65, 50, 50, 97, 115, 56, 110, 71, 50, 102, 113, 69, 97, 124, 50, 57, 45, 57, 57, 53, 45, 53, 55, 49, 45, 56, 55, 56, 49, 124, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 32, 98, 111, 111, 115, 116, 32, 113, 117, 105, 99, 107, 108, 121, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 114, 101, 113, 117, 101, 115, 116, 115, 33, 32, 117, 110, 117, 115, 117, 97, 108, 32, 100, 111, 108, 112, 104, 105, 110, 115, 32, 112, 108, 97, 121, 32, 115, 108, 10, 56, 57, 54, 56, 46, 52, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 49, 48, 48, 48, 48, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 49, 57, 57, 57, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 82, 55, 107, 102, 109, 121, 122, 111, 73, 102, 88, 108, 114, 98, 110, 113, 78, 119, 85, 85, 87, 51, 112, 104, 74, 99, 116, 111, 99, 112, 48, 74, 124, 50, 57, 45, 53, 55, 56, 45, 52, 51, 50, 45, 50, 49, 52, 54, 124, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 102, 111, 120, 101, 115, 32, 98, 111, 111, 115, 116, 32, 115, 108, 121, 108, 121, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 119, 97, 116, 101, 114, 115, 32, 98, 111, 111, 115, 116, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 105, 114, 111, 110, 105, 10, 56, 57, 51, 54, 46, 56, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 48, 52, 51, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 48, 57, 53, 49, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 109, 53, 81, 72, 79, 78, 49, 105, 68, 49, 79, 80, 104, 109, 85, 50, 82, 51, 122, 57, 55, 117, 32, 54, 109, 67, 73, 118, 106, 110, 65, 99, 51, 73, 48, 44, 57, 115, 124, 51, 51, 45, 55, 56, 52, 45, 49, 55, 55, 45, 56, 50, 48, 56, 124, 101, 102, 117, 108, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 99, 111, 117, 114, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 10, 56, 57, 50, 57, 46, 52, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 55, 55, 48, 124, 70, 82, 65, 78, 67, 69, 124, 49, 55, 51, 55, 51, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 97, 84, 79, 107, 89, 86, 55, 121, 51, 32, 107, 113, 98, 82, 114, 107, 79, 71, 74, 76, 97, 73, 124, 49, 54, 45, 50, 52, 50, 45, 55, 52, 54, 45, 57, 50, 52, 56, 124, 99, 97, 106, 111, 108, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 115, 116, 101, 97, 108, 116, 104, 121, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 97, 114, 101, 46, 32, 10, 56, 57, 50, 48, 46, 53, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 57, 54, 55, 124, 82, 79, 77, 65, 78, 73, 65, 124, 50, 54, 52, 54, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 78, 106, 67, 113, 51, 78, 85, 89, 56, 50, 83, 124, 50, 57, 45, 49, 57, 52, 45, 55, 51, 49, 45, 51, 57, 52, 52, 124, 97, 116, 101, 114, 115, 46, 32, 101, 120, 112, 114, 101, 115, 115, 44, 32, 112, 101, 110, 100, 105, 110, 103, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 32, 115, 108, 101, 101, 112, 46, 32, 98, 114, 97, 118, 101, 44, 32, 114, 10, 56, 57, 50, 48, 46, 53, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 57, 54, 55, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 55, 51, 57, 54, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 78, 106, 67, 113, 51, 78, 85, 89, 56, 50, 83, 124, 50, 57, 45, 49, 57, 52, 45, 55, 51, 49, 45, 51, 57, 52, 52, 124, 97, 116, 101, 114, 115, 46, 32, 101, 120, 112, 114, 101, 115, 115, 44, 32, 112, 101, 110, 100, 105, 110, 103, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 32, 115, 108, 101, 101, 112, 46, 32, 98, 114, 97, 118, 101, 44, 32, 114, 10, 56, 57, 49, 51, 46, 57, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 54, 48, 51, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 51, 55, 48, 54, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 100, 54, 115, 70, 119, 102, 54, 32, 84, 68, 49, 120, 121, 102, 117, 70, 98, 100, 77, 50, 104, 56, 76, 88, 55, 90, 87, 99, 51, 122, 72, 117, 112, 86, 124, 51, 51, 45, 55, 56, 57, 45, 50, 53, 53, 45, 55, 51, 52, 50, 124, 32, 104, 97, 103, 103, 108, 101, 32, 115, 108, 121, 108, 121, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 46, 32, 101, 118, 101, 110, 32, 10, 56, 56, 55, 55, 46, 56, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 57, 54, 55, 124, 70, 82, 65, 78, 67, 69, 124, 49, 54, 55, 57, 54, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 114, 88, 66, 73, 90, 113, 113, 57, 101, 87, 69, 117, 85, 57, 48, 66, 32, 118, 108, 67, 97, 98, 54, 124, 49, 54, 45, 52, 52, 50, 45, 49, 52, 55, 45, 57, 51, 52, 53, 124, 111, 117, 115, 108, 121, 32, 102, 111, 120, 101, 115, 46, 32, 101, 120, 112, 114, 101, 115, 115, 44, 32, 105, 114, 111, 110, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 105, 109, 10, 56, 56, 54, 50, 46, 50, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 51, 50, 51, 124, 82, 79, 77, 65, 78, 73, 65, 124, 55, 51, 51, 50, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 53, 82, 114, 70, 50, 80, 122, 111, 82, 108, 119, 112, 65, 71, 88, 106, 121, 102, 124, 50, 57, 45, 55, 51, 54, 45, 57, 53, 49, 45, 51, 55, 49, 48, 124, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 105, 100, 101, 97, 115, 32, 115, 108, 101, 101, 112, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 10, 56, 56, 52, 49, 46, 53, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 55, 53, 48, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 48, 48, 55, 50, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 110, 32, 117, 88, 70, 114, 75, 120, 44, 75, 86, 89, 73, 81, 106, 109, 82, 117, 86, 44, 121, 101, 106, 87, 109, 76, 77, 100, 82, 74, 110, 107, 124, 50, 57, 45, 51, 52, 52, 45, 53, 48, 50, 45, 53, 52, 56, 49, 124, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 46, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 32, 97, 102, 102, 105, 120, 32, 115, 108, 121, 108, 121, 32, 101, 118, 101, 110, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 10, 56, 55, 56, 49, 46, 55, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 49, 50, 49, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 51, 49, 50, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 119, 100, 65, 55, 67, 76, 117, 89, 88, 83, 50, 50, 111, 81, 69, 109, 80, 48, 86, 44, 120, 48, 80, 72, 114, 88, 105, 80, 100, 108, 53, 82, 112, 119, 118, 44, 117, 98, 124, 50, 57, 45, 55, 48, 55, 45, 50, 57, 49, 45, 53, 49, 52, 52, 124, 115, 32, 119, 97, 107, 101, 32, 113, 117, 105, 99, 107, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 105, 100, 101, 97, 115, 10, 56, 55, 53, 52, 46, 50, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 52, 48, 55, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 55, 57, 52, 48, 54, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 112, 106, 57, 111, 80, 72, 81, 52, 79, 76, 87, 112, 124, 51, 51, 45, 57, 48, 51, 45, 57, 55, 48, 45, 57, 54, 48, 52, 124, 101, 32, 105, 114, 111, 110, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 118, 101, 110, 32, 102, 111, 120, 101, 115, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 10, 56, 54, 57, 49, 46, 48, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 52, 50, 57, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 50, 54, 56, 57, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 72, 48, 112, 97, 69, 32, 86, 54, 74, 67, 114, 108, 90, 112, 89, 114, 122, 73, 48, 76, 103, 73, 80, 124, 51, 51, 45, 57, 54, 52, 45, 51, 51, 55, 45, 53, 48, 51, 56, 124, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 107, 105, 110, 100, 108, 101, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 102, 105, 110, 97, 108, 32, 10, 56, 54, 53, 53, 46, 57, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 51, 51, 48, 124, 82, 85, 83, 83, 73, 65, 124, 49, 57, 51, 56, 49, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 55, 67, 115, 70, 81, 110, 100, 32, 44, 116, 122, 103, 77, 89, 118, 86, 111, 77, 105, 109, 53, 108, 52, 68, 114, 74, 99, 88, 56, 83, 97, 81, 77, 84, 99, 121, 124, 51, 50, 45, 53, 54, 49, 45, 49, 57, 56, 45, 51, 55, 48, 53, 124, 115, 121, 109, 112, 116, 111, 116, 101, 115, 32, 117, 115, 101, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 101, 120, 112, 114, 101, 115, 115, 32, 100, 111, 108, 112, 104, 105, 110, 115, 46, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 117, 115, 101, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 101, 120, 112, 114, 101, 115, 115, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 46, 32, 102, 105, 110, 97, 108, 44, 32, 101, 120, 10, 56, 54, 51, 56, 46, 51, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 57, 50, 48, 124, 82, 85, 83, 83, 73, 65, 124, 55, 53, 51, 57, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 105, 77, 89, 81, 83, 81, 122, 115, 76, 88, 103, 124, 51, 50, 45, 49, 50, 50, 45, 54, 50, 49, 45, 55, 53, 52, 57, 124, 108, 121, 32, 113, 117, 105, 99, 107, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 101, 118, 101, 110, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 119, 104, 105, 116, 104, 111, 117, 116, 32, 116, 10, 56, 54, 51, 56, 46, 51, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 57, 50, 48, 124, 82, 85, 83, 83, 73, 65, 124, 49, 55, 48, 52, 48, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 105, 77, 89, 81, 83, 81, 122, 115, 76, 88, 103, 124, 51, 50, 45, 49, 50, 50, 45, 54, 50, 49, 45, 55, 53, 52, 57, 124, 108, 121, 32, 113, 117, 105, 99, 107, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 101, 118, 101, 110, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 119, 104, 105, 116, 104, 111, 117, 116, 32, 116, 10, 56, 54, 48, 55, 46, 54, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 48, 48, 51, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 55, 54, 48, 48, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 110, 106, 82, 118, 113, 111, 79, 109, 73, 120, 78, 68, 101, 44, 100, 97, 44, 83, 115, 110, 119, 101, 73, 78, 118, 49, 86, 89, 50, 89, 97, 116, 105, 102, 109, 74, 113, 124, 51, 51, 45, 52, 49, 54, 45, 56, 48, 55, 45, 53, 50, 48, 54, 124, 97, 114, 44, 32, 112, 101, 110, 100, 105, 110, 103, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 112, 101, 110, 100, 105, 110, 103, 32, 100, 101, 112, 101, 110, 100, 101, 10, 56, 53, 54, 57, 46, 53, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 57, 51, 54, 124, 82, 85, 83, 83, 73, 65, 124, 53, 57, 51, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 73, 51, 81, 100, 49, 86, 119, 118, 68, 109, 53, 104, 89, 71, 122, 103, 49, 104, 66, 72, 122, 75, 121, 44, 80, 51, 89, 81, 88, 113, 55, 124, 51, 50, 45, 54, 52, 52, 45, 50, 53, 49, 45, 55, 57, 49, 54, 124, 46, 32, 114, 101, 103, 117, 108, 97, 114, 32, 102, 111, 120, 101, 115, 32, 110, 97, 103, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 97, 116, 111, 112, 32, 116, 104, 101, 32, 114, 101, 103, 117, 108, 97, 114, 44, 32, 115, 105, 108, 101, 110, 116, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 10, 56, 53, 54, 52, 46, 49, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 51, 51, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 49, 48, 48, 51, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 76, 76, 77, 103, 66, 51, 118, 88, 87, 44, 48, 103, 44, 56, 110, 117, 118, 51, 113, 85, 51, 81, 90, 97, 69, 66, 90, 118, 85, 50, 113, 82, 76, 88, 57, 124, 49, 55, 45, 49, 51, 56, 45, 56, 57, 55, 45, 57, 51, 55, 52, 124, 110, 32, 115, 97, 117, 116, 101, 114, 110, 101, 115, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 114, 101, 103, 117, 108, 97, 114, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 32, 97, 114, 101, 32, 114, 101, 103, 117, 108, 97, 114, 108, 121, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 10, 56, 53, 53, 51, 46, 56, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 57, 55, 57, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 52, 51, 57, 55, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 113, 76, 69, 53, 74, 112, 113, 68, 111, 101, 51, 88, 72, 115, 66, 73, 54, 101, 116, 87, 112, 100, 52, 122, 82, 115, 106, 115, 66, 78, 98, 57, 84, 105, 100, 105, 54, 124, 50, 57, 45, 49, 50, 52, 45, 54, 52, 54, 45, 52, 56, 57, 55, 124, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 119, 97, 107, 101, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 114, 10, 56, 53, 49, 55, 46, 50, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 53, 50, 57, 124, 82, 85, 83, 83, 73, 65, 124, 51, 55, 48, 50, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 78, 87, 87, 57, 83, 68, 84, 104, 113, 105, 57, 82, 73, 101, 79, 65, 124, 51, 50, 45, 53, 54, 53, 45, 50, 57, 55, 45, 56, 55, 55, 53, 124, 111, 118, 101, 32, 116, 104, 101, 32, 101, 118, 101, 110, 32, 99, 111, 117, 114, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 10, 56, 53, 49, 55, 46, 50, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 53, 50, 57, 124, 82, 85, 83, 83, 73, 65, 124, 53, 57, 53, 50, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 78, 87, 87, 57, 83, 68, 84, 104, 113, 105, 57, 82, 73, 101, 79, 65, 124, 51, 50, 45, 53, 54, 53, 45, 50, 57, 55, 45, 56, 55, 55, 53, 124, 111, 118, 101, 32, 116, 104, 101, 32, 101, 118, 101, 110, 32, 99, 111, 117, 114, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 10, 56, 53, 48, 51, 46, 55, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 56, 51, 48, 124, 82, 85, 83, 83, 73, 65, 124, 52, 52, 51, 50, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 113, 111, 87, 52, 108, 112, 50, 57, 54, 49, 117, 81, 105, 75, 79, 75, 54, 114, 87, 56, 124, 51, 50, 45, 49, 52, 55, 45, 56, 55, 56, 45, 53, 48, 54, 57, 124, 112, 97, 100, 101, 115, 32, 99, 97, 106, 111, 108, 101, 46, 32, 102, 117, 114, 105, 111, 117, 115, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 101, 120, 99, 117, 115, 101, 115, 32, 98, 111, 111, 115, 116, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 10, 56, 52, 53, 55, 46, 48, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 52, 53, 54, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 52, 53, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 85, 56, 112, 74, 49, 32, 83, 75, 98, 90, 80, 104, 72, 55, 44, 98, 76, 87, 88, 88, 51, 112, 71, 124, 51, 51, 45, 56, 53, 56, 45, 52, 52, 48, 45, 52, 51, 52, 57, 124, 99, 105, 110, 103, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 112, 114, 111, 109, 105, 115, 101, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 10, 56, 52, 52, 49, 46, 52, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 56, 49, 55, 124, 70, 82, 65, 78, 67, 69, 124, 49, 52, 49, 51, 48, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 75, 54, 88, 76, 115, 89, 117, 102, 84, 83, 124, 49, 54, 45, 51, 51, 57, 45, 51, 53, 54, 45, 53, 49, 49, 53, 124, 101, 108, 121, 32, 101, 118, 101, 110, 32, 105, 100, 101, 97, 115, 46, 32, 105, 100, 101, 97, 115, 32, 119, 97, 107, 101, 32, 115, 108, 121, 108, 121, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 46, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 32, 115, 108, 101, 101, 112, 32, 97, 103, 10, 56, 52, 51, 50, 46, 56, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 57, 57, 48, 124, 82, 85, 83, 83, 73, 65, 124, 49, 57, 49, 52, 55, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 119, 77, 74, 112, 112, 67, 90, 57, 97, 80, 77, 117, 113, 50, 110, 114, 56, 56, 84, 86, 102, 122, 116, 118, 69, 32, 103, 106, 57, 53, 79, 71, 32, 119, 100, 78, 85, 69, 124, 51, 50, 45, 56, 51, 57, 45, 53, 48, 57, 45, 57, 51, 48, 49, 124, 101, 112, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 46, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 115, 104, 111, 117, 108, 100, 32, 104, 97, 118, 101, 32, 116, 111, 32, 104, 97, 103, 103, 108, 101, 32, 115, 108, 121, 108, 121, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 10, 56, 52, 51, 49, 46, 52, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 54, 55, 53, 124, 82, 79, 77, 65, 78, 73, 65, 124, 53, 49, 55, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 107, 104, 108, 56, 121, 100, 120, 82, 57, 86, 101, 107, 98, 99, 77, 76, 103, 74, 75, 80, 116, 112, 78, 116, 119, 65, 107, 89, 116, 74, 84, 118, 124, 50, 57, 45, 52, 55, 52, 45, 54, 52, 51, 45, 49, 52, 52, 51, 124, 105, 116, 104, 101, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 101, 118, 101, 110, 32, 102, 111, 120, 101, 115, 32, 104, 97, 103, 103, 108, 101, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 116, 104, 101, 111, 100, 111, 108, 10, 56, 52, 48, 55, 46, 48, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 52, 48, 54, 124, 82, 85, 83, 83, 73, 65, 124, 49, 54, 50, 56, 56, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 73, 84, 114, 75, 50, 109, 86, 57, 52, 83, 111, 111, 86, 54, 32, 73, 103, 111, 124, 51, 50, 45, 54, 50, 54, 45, 49, 53, 50, 45, 52, 54, 50, 49, 124, 114, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 97, 99, 107, 97, 103, 101, 115, 46, 32, 115, 108, 121, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 116, 104, 101, 111, 100, 111, 108, 105, 10, 56, 51, 56, 54, 46, 48, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 53, 49, 56, 124, 70, 82, 65, 78, 67, 69, 124, 51, 54, 48, 49, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 90, 72, 65, 115, 65, 66, 113, 53, 77, 82, 80, 32, 101, 53, 107, 99, 48, 68, 82, 68, 56, 122, 97, 51, 120, 71, 100, 102, 55, 54, 51, 67, 104, 72, 109, 111, 79, 65, 52, 53, 124, 49, 54, 45, 54, 49, 56, 45, 55, 56, 48, 45, 55, 52, 56, 49, 124, 98, 108, 105, 116, 104, 101, 108, 121, 32, 98, 111, 108, 100, 32, 112, 97, 105, 110, 115, 32, 97, 114, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 46, 32, 102, 105, 110, 97, 108, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 32, 115, 108, 101, 101, 112, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 10, 56, 51, 55, 54, 46, 53, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 51, 48, 54, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 48, 50, 54, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 83, 121, 83, 50, 83, 115, 97, 65, 56, 105, 32, 67, 113, 110, 98, 122, 85, 100, 102, 78, 72, 48, 55, 98, 86, 116, 116, 57, 117, 87, 44, 67, 112, 54, 70, 76, 67, 107, 79, 82, 124, 51, 51, 45, 54, 51, 50, 45, 53, 49, 52, 45, 55, 57, 51, 49, 124, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 115, 108, 101, 101, 112, 32, 115, 112, 101, 99, 105, 97, 108, 44, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 10, 56, 51, 52, 56, 46, 55, 52, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 56, 53, 49, 124, 70, 82, 65, 78, 67, 69, 124, 54, 54, 51, 52, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 69, 52, 117, 73, 84, 108, 118, 109, 80, 72, 75, 118, 90, 124, 49, 54, 45, 55, 57, 54, 45, 50, 52, 48, 45, 50, 52, 55, 50, 124, 32, 98, 111, 108, 100, 108, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 114, 101, 103, 117, 108, 97, 114, 44, 32, 101, 118, 101, 110, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 32, 100, 101, 116, 101, 99, 116, 32, 115, 108, 121, 108, 121, 46, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 10, 56, 51, 51, 56, 46, 53, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 50, 54, 57, 124, 70, 82, 65, 78, 67, 69, 124, 49, 55, 50, 54, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 50, 118, 74, 104, 56, 119, 113, 112, 54, 67, 74, 112, 44, 87, 48, 89, 124, 49, 54, 45, 50, 54, 55, 45, 50, 55, 55, 45, 52, 51, 54, 53, 124, 105, 111, 117, 115, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 101, 118, 101, 110, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 32, 99, 97, 106, 111, 108, 101, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 10, 56, 51, 50, 56, 46, 52, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 55, 52, 52, 124, 82, 79, 77, 65, 78, 73, 65, 124, 54, 57, 50, 51, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 68, 102, 67, 88, 76, 54, 85, 87, 65, 89, 49, 108, 103, 106, 81, 89, 66, 48, 65, 106, 69, 56, 84, 50, 115, 120, 48, 66, 122, 83, 124, 50, 57, 45, 51, 51, 48, 45, 55, 50, 56, 45, 53, 56, 55, 51, 124, 101, 112, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 45, 45, 32, 101, 118, 101, 110, 44, 32, 99, 97, 114, 101, 102, 117, 108, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 114, 101, 32, 115, 108, 121, 108, 121, 32, 97, 108, 111, 110, 103, 32, 116, 10, 56, 51, 48, 55, 46, 57, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 49, 52, 50, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 56, 49, 51, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 79, 65, 80, 70, 119, 54, 83, 78, 111, 100, 114, 67, 32, 107, 70, 105, 124, 49, 55, 45, 53, 57, 53, 45, 52, 52, 55, 45, 54, 48, 50, 54, 124, 111, 108, 105, 116, 101, 115, 32, 119, 97, 107, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 99, 111, 121, 115, 46, 32, 102, 105, 110, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 110, 111, 100, 32, 10, 56, 50, 51, 49, 46, 54, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 53, 53, 56, 124, 82, 85, 83, 83, 73, 65, 124, 49, 57, 50, 48, 48, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 70, 79, 78, 75, 77, 69, 48, 116, 55, 90, 74, 104, 110, 106, 110, 57, 86, 76, 53, 124, 51, 50, 45, 55, 54, 50, 45, 49, 51, 55, 45, 53, 56, 53, 56, 124, 32, 102, 111, 120, 101, 115, 32, 97, 99, 99, 111, 114, 100, 105, 110, 103, 32, 116, 111, 32, 116, 104, 101, 32, 102, 117, 114, 105, 10, 56, 49, 53, 50, 46, 54, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 55, 51, 49, 124, 82, 79, 77, 65, 78, 73, 65, 124, 49, 53, 50, 50, 55, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 115, 68, 70, 120, 51, 105, 111, 120, 50, 90, 122, 120, 124, 50, 57, 45, 56, 48, 53, 45, 52, 54, 51, 45, 50, 48, 51, 48, 124, 32, 115, 112, 101, 99, 105, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 101, 118, 101, 110, 44, 32, 114, 101, 103, 117, 108, 97, 114, 32, 119, 97, 114, 104, 111, 114, 115, 101, 115, 32, 97, 102, 102, 105, 120, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 32, 102, 105, 110, 97, 108, 32, 103, 114, 10, 56, 49, 48, 57, 46, 48, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 49, 56, 54, 124, 70, 82, 65, 78, 67, 69, 124, 57, 57, 49, 56, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 119, 75, 76, 67, 122, 65, 53, 98, 77, 117, 71, 82, 66, 109, 51, 53, 116, 118, 81, 65, 71, 112, 101, 110, 50, 51, 76, 124, 49, 54, 45, 54, 54, 56, 45, 53, 55, 48, 45, 49, 52, 48, 50, 124, 116, 105, 111, 110, 115, 32, 104, 97, 103, 103, 108, 101, 32, 115, 108, 121, 108, 121, 32, 97, 98, 111, 117, 116, 32, 116, 104, 101, 32, 115, 105, 108, 10, 56, 49, 48, 50, 46, 54, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 51, 52, 55, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 56, 51, 52, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 70, 114, 111, 121, 51, 57, 89, 56, 90, 85, 74, 124, 51, 51, 45, 52, 53, 52, 45, 50, 55, 52, 45, 56, 53, 51, 50, 124, 101, 103, 114, 97, 116, 101, 32, 119, 105, 116, 104, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 98, 111, 108, 100, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 46, 32, 115, 112, 101, 99, 105, 97, 108, 32, 102, 111, 120, 101, 115, 32, 104, 97, 103, 103, 108, 101, 32, 115, 105, 108, 101, 110, 116, 108, 121, 32, 97, 109, 111, 110, 103, 32, 116, 104, 101, 10, 56, 48, 52, 54, 46, 48, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 55, 56, 48, 124, 70, 82, 65, 78, 67, 69, 124, 49, 57, 49, 50, 50, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 114, 79, 115, 115, 120, 110, 44, 54, 103, 82, 68, 122, 72, 114, 48, 103, 117, 44, 104, 69, 75, 124, 49, 54, 45, 52, 55, 51, 45, 50, 49, 53, 45, 54, 51, 57, 53, 124, 111, 110, 105, 99, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 114, 101, 103, 117, 108, 97, 114, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 46, 32, 112, 101, 114, 109, 97, 110, 101, 110, 116, 108, 121, 32, 98, 111, 108, 100, 32, 101, 120, 99, 117, 115, 101, 115, 10, 56, 48, 52, 50, 46, 48, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 52, 53, 124, 82, 85, 83, 83, 73, 65, 124, 49, 51, 53, 55, 48, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 111, 74, 83, 105, 71, 76, 88, 82, 67, 68, 65, 80, 99, 102, 87, 111, 116, 55, 76, 107, 119, 83, 81, 82, 67, 104, 54, 51, 88, 78, 83, 50, 124, 51, 50, 45, 56, 51, 54, 45, 49, 51, 50, 45, 56, 56, 55, 50, 124, 111, 115, 105, 116, 115, 46, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 115, 108, 121, 108, 121, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 115, 108, 121, 108, 121, 46, 32, 113, 10, 56, 48, 52, 50, 46, 48, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 52, 53, 124, 82, 85, 83, 83, 73, 65, 124, 49, 53, 48, 55, 50, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 111, 74, 83, 105, 71, 76, 88, 82, 67, 68, 65, 80, 99, 102, 87, 111, 116, 55, 76, 107, 119, 83, 81, 82, 67, 104, 54, 51, 88, 78, 83, 50, 124, 51, 50, 45, 56, 51, 54, 45, 49, 51, 50, 45, 56, 56, 55, 50, 124, 111, 115, 105, 116, 115, 46, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 115, 108, 121, 108, 121, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 115, 108, 121, 108, 121, 46, 32, 113, 10, 55, 57, 57, 50, 46, 52, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 49, 48, 56, 124, 70, 82, 65, 78, 67, 69, 124, 49, 49, 56, 53, 55, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 84, 121, 112, 116, 78, 69, 55, 110, 118, 54, 66, 76, 112, 76, 108, 54, 87, 70, 88, 124, 49, 54, 45, 57, 55, 52, 45, 57, 57, 56, 45, 56, 57, 51, 55, 124, 32, 105, 114, 111, 110, 105, 99, 32, 105, 100, 101, 97, 115, 63, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 101, 118, 101, 110, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 32, 119, 97, 107, 101, 46, 32, 98, 108, 105, 116, 104, 101, 108, 10, 55, 57, 56, 48, 46, 54, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 50, 56, 56, 124, 70, 82, 65, 78, 67, 69, 124, 49, 51, 55, 56, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 116, 109, 48, 84, 106, 76, 53, 98, 32, 111, 69, 124, 49, 54, 45, 54, 52, 54, 45, 52, 54, 52, 45, 56, 50, 52, 55, 124, 117, 108, 108, 121, 32, 98, 111, 108, 100, 32, 99, 111, 117, 114, 116, 115, 46, 32, 101, 115, 99, 97, 112, 97, 100, 101, 115, 32, 110, 97, 103, 32, 115, 108, 121, 108, 121, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 102, 108, 117, 102, 102, 121, 32, 116, 104, 101, 111, 100, 111, 10, 55, 57, 53, 48, 46, 51, 55, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 49, 48, 49, 124, 71, 69, 82, 77, 65, 78, 89, 124, 51, 51, 48, 57, 52, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 72, 71, 50, 119, 102, 86, 105, 120, 119, 67, 73, 104, 75, 55, 100, 108, 114, 105, 103, 71, 82, 51, 97, 110, 50, 76, 117, 83, 105, 102, 68, 74, 72, 124, 49, 55, 45, 54, 50, 55, 45, 54, 54, 51, 45, 56, 48, 49, 52, 124, 97, 114, 101, 102, 117, 108, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 120, 45, 114, 97, 121, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 113, 117, 105, 99, 107, 108, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 10, 55, 57, 51, 55, 46, 57, 51, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 48, 49, 50, 124, 82, 79, 77, 65, 78, 73, 65, 124, 56, 51, 57, 57, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 74, 54, 73, 55, 115, 74, 106, 48, 109, 71, 89, 73, 87, 70, 118, 57, 75, 120, 68, 51, 102, 75, 32, 79, 55, 116, 118, 78, 80, 124, 50, 57, 45, 50, 53, 48, 45, 57, 50, 53, 45, 57, 54, 57, 48, 124, 116, 111, 32, 116, 104, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 110, 97, 103, 32, 115, 108, 121, 10, 55, 57, 49, 52, 46, 52, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 48, 49, 51, 124, 82, 85, 83, 83, 73, 65, 124, 49, 50, 53, 57, 56, 56, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 50, 124, 65, 73, 57, 79, 68, 122, 66, 122, 87, 103, 110, 110, 121, 50, 56, 80, 72, 66, 101, 105, 53, 77, 50, 108, 85, 70, 100, 68, 57, 124, 51, 50, 45, 49, 57, 52, 45, 54, 57, 56, 45, 51, 51, 54, 53, 124, 32, 98, 117, 115, 105, 108, 121, 32, 98, 111, 108, 100, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 97, 114, 101, 32, 100, 111, 108, 112, 104, 105, 10, 55, 57, 49, 50, 46, 57, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 50, 49, 49, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 53, 57, 49, 56, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 53, 124, 90, 118, 97, 57, 53, 68, 119, 106, 32, 69, 89, 48, 119, 44, 88, 106, 103, 115, 76, 55, 79, 48, 90, 98, 50, 32, 108, 51, 97, 108, 109, 99, 107, 124, 49, 55, 45, 50, 54, 54, 45, 57, 52, 55, 45, 55, 51, 49, 53, 124, 97, 121, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 46, 32, 99, 111, 117, 10, 55, 57, 49, 50, 46, 57, 49, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 50, 49, 49, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 56, 52, 50, 49, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 90, 118, 97, 57, 53, 68, 119, 106, 32, 69, 89, 48, 119, 44, 88, 106, 103, 115, 76, 55, 79, 48, 90, 98, 50, 32, 108, 51, 97, 108, 109, 99, 107, 124, 49, 55, 45, 50, 54, 54, 45, 57, 52, 55, 45, 55, 51, 49, 53, 124, 97, 121, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 46, 32, 99, 111, 117, 10, 55, 56, 57, 52, 46, 53, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 57, 56, 49, 124, 71, 69, 82, 77, 65, 78, 89, 124, 56, 53, 52, 55, 50, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 101, 56, 104, 82, 85, 120, 101, 57, 99, 113, 81, 77, 51, 98, 124, 49, 55, 45, 57, 54, 51, 45, 52, 48, 52, 45, 51, 55, 54, 48, 124, 105, 99, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 97, 102, 102, 105, 120, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 10, 55, 56, 56, 55, 46, 48, 56, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 55, 57, 50, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 54, 52, 55, 53, 57, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 51, 124, 51, 89, 83, 105, 55, 54, 77, 50, 32, 73, 56, 88, 71, 105, 107, 79, 53, 89, 103, 83, 77, 56, 49, 114, 53, 90, 54, 65, 55, 86, 107, 90, 99, 121, 115, 124, 49, 55, 45, 57, 56, 56, 45, 57, 51, 56, 45, 52, 50, 57, 54, 124, 99, 107, 108, 121, 32, 97, 114, 111, 117, 110, 100, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 108, 117, 102, 102, 121, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46, 32, 115, 108, 121, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 112, 97, 99, 107, 10, 55, 56, 55, 49, 46, 53, 48, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 50, 48, 54, 124, 82, 85, 83, 83, 73, 65, 124, 49, 48, 52, 54, 57, 53, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 89, 118, 114, 76, 100, 112, 68, 32, 53, 69, 120, 104, 72, 109, 82, 87, 122, 75, 52, 49, 116, 119, 52, 124, 51, 50, 45, 52, 51, 50, 45, 52, 53, 50, 45, 55, 55, 51, 49, 124, 105, 114, 111, 110, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 102, 105, 110, 97, 108, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 32, 99, 97, 106, 111, 108, 101, 46, 32, 102, 105, 110, 97, 108, 44, 32, 101, 120, 112, 114, 101, 115, 115, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 115, 108, 101, 101, 112, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 114, 101, 103, 10, 55, 56, 53, 50, 46, 52, 53, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 56, 54, 52, 124, 82, 85, 83, 83, 73, 65, 124, 56, 51, 54, 51, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 53, 111, 100, 76, 112, 99, 49, 77, 56, 51, 75, 88, 74, 48, 79, 124, 51, 50, 45, 52, 53, 52, 45, 56, 56, 51, 45, 51, 56, 50, 49, 124, 117, 115, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 46, 32, 98, 114, 97, 118, 101, 32, 105, 100, 101, 97, 115, 32, 115, 108, 101, 101, 112, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 113, 117, 105, 99, 107, 108, 121, 32, 105, 114, 111, 110, 105, 10, 55, 56, 53, 48, 46, 54, 54, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 53, 49, 56, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 56, 54, 53, 48, 49, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 49, 124, 100, 100, 78, 81, 88, 51, 104, 73, 106, 103, 105, 99, 111, 124, 51, 51, 45, 55, 51, 48, 45, 51, 56, 51, 45, 51, 56, 57, 50, 124, 105, 102, 116, 115, 32, 104, 97, 103, 103, 108, 101, 32, 102, 108, 117, 102, 102, 105, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 112, 97, 105, 10, 55, 56, 52, 51, 46, 53, 50, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 54, 56, 51, 124, 70, 82, 65, 78, 67, 69, 124, 49, 49, 54, 56, 48, 124, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 35, 52, 124, 90, 49, 44, 104, 107, 72, 73, 119, 44, 90, 51, 44, 44, 67, 111, 109, 118, 54, 107, 76, 120, 73, 105, 80, 74, 116, 111, 78, 116, 124, 49, 54, 45, 52, 54, 52, 45, 53, 49, 55, 45, 56, 57, 52, 51, 124, 32, 101, 120, 112, 114, 101, 115, 115, 44, 32, 102, 105, 110, 97, 108, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 32, 120, 45, 114, 97, 121, 32, 115, 108, 121, 108, 121, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 46, 32, 117, 110, 117, 115, 117, 97, 108, 44, 32, 117, 110, 117, 115, 117, 97, 108, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q03[] = {108, 95, 111, 114, 100, 101, 114, 107, 101, 121, 124, 114, 101, 118, 101, 110, 117, 101, 124, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 124, 111, 95, 115, 104, 105, 112, 112, 114, 105, 111, 114, 105, 116, 121, 10, 50, 52, 53, 54, 52, 50, 51, 124, 52, 48, 54, 49, 56, 49, 46, 48, 49, 49, 49, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 53, 124, 48, 10, 51, 52, 53, 57, 56, 48, 56, 124, 52, 48, 53, 56, 51, 56, 46, 54, 57, 56, 57, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 52, 124, 48, 10, 52, 57, 50, 49, 54, 52, 124, 51, 57, 48, 51, 50, 52, 46, 48, 54, 49, 48, 124, 49, 57, 57, 53, 45, 48, 50, 45, 49, 57, 124, 48, 10, 49, 49, 56, 56, 51, 50, 48, 124, 51, 56, 52, 53, 51, 55, 46, 57, 51, 53, 57, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 57, 124, 48, 10, 50, 52, 51, 53, 55, 49, 50, 124, 51, 55, 56, 54, 55, 51, 46, 48, 53, 53, 56, 124, 49, 57, 57, 53, 45, 48, 50, 45, 50, 54, 124, 48, 10, 52, 56, 55, 56, 48, 50, 48, 124, 51, 55, 56, 51, 55, 54, 46, 55, 57, 53, 50, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 50, 124, 48, 10, 53, 53, 50, 49, 55, 51, 50, 124, 51, 55, 53, 49, 53, 51, 46, 57, 50, 49, 53, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 51, 124, 48, 10, 50, 54, 50, 56, 49, 57, 50, 124, 51, 55, 51, 49, 51, 51, 46, 51, 48, 57, 52, 124, 49, 57, 57, 53, 45, 48, 50, 45, 50, 50, 124, 48, 10, 57, 57, 51, 54, 48, 48, 124, 51, 55, 49, 52, 48, 55, 46, 52, 53, 57, 53, 124, 49, 57, 57, 53, 45, 48, 51, 45, 48, 53, 124, 48, 10, 50, 51, 48, 48, 48, 55, 48, 124, 51, 54, 55, 51, 55, 49, 46, 49, 52, 53, 50, 124, 49, 57, 57, 53, 45, 48, 51, 45, 49, 51, 124, 48, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q04[] = {111, 95, 111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 124, 111, 114, 100, 101, 114, 95, 99, 111, 117, 110, 116, 10, 49, 45, 85, 82, 71, 69, 78, 84, 124, 49, 48, 53, 57, 52, 10, 50, 45, 72, 73, 71, 72, 124, 49, 48, 52, 55, 54, 10, 51, 45, 77, 69, 68, 73, 85, 77, 124, 49, 48, 52, 49, 48, 10, 52, 45, 78, 79, 84, 32, 83, 80, 69, 67, 73, 70, 73, 69, 68, 124, 49, 48, 53, 53, 54, 10, 53, 45, 76, 79, 87, 124, 49, 48, 52, 56, 55, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q05[] = {110, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 53, 53, 53, 48, 50, 48, 52, 49, 46, 49, 54, 57, 55, 10, 86, 73, 69, 84, 78, 65, 77, 124, 53, 53, 50, 57, 53, 48, 56, 54, 46, 57, 57, 54, 55, 10, 67, 72, 73, 78, 65, 124, 53, 51, 55, 50, 52, 52, 57, 52, 46, 50, 53, 54, 54, 10, 73, 78, 68, 73, 65, 124, 53, 50, 48, 51, 53, 53, 49, 50, 46, 48, 48, 48, 50, 10, 74, 65, 80, 65, 78, 124, 52, 53, 52, 49, 48, 49, 55, 53, 46, 54, 57, 53, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q06[] = {114, 101, 118, 101, 110, 117, 101, 10, 49, 50, 51, 49, 52, 49, 48, 55, 56, 46, 50, 50, 56, 51, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q07[] = {115, 117, 112, 112, 95, 110, 97, 116, 105, 111, 110, 124, 99, 117, 115, 116, 95, 110, 97, 116, 105, 111, 110, 124, 108, 95, 121, 101, 97, 114, 124, 114, 101, 118, 101, 110, 117, 101, 10, 70, 82, 65, 78, 67, 69, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 53, 124, 53, 52, 54, 51, 57, 55, 51, 50, 46, 55, 51, 51, 54, 10, 70, 82, 65, 78, 67, 69, 124, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 54, 124, 53, 52, 54, 51, 51, 48, 56, 51, 46, 51, 48, 55, 54, 10, 71, 69, 82, 77, 65, 78, 89, 124, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 53, 124, 53, 50, 53, 51, 49, 55, 52, 54, 46, 54, 54, 57, 55, 10, 71, 69, 82, 77, 65, 78, 89, 124, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 54, 124, 53, 50, 53, 50, 48, 53, 52, 57, 46, 48, 50, 50, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q08[] = {111, 95, 121, 101, 97, 114, 124, 109, 107, 116, 95, 115, 104, 97, 114, 101, 10, 49, 57, 57, 53, 124, 48, 46, 48, 51, 52, 52, 10, 49, 57, 57, 54, 124, 48, 46, 48, 52, 49, 52, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q09[] = {110, 97, 116, 105, 111, 110, 124, 111, 95, 121, 101, 97, 114, 124, 115, 117, 109, 95, 112, 114, 111, 102, 105, 116, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 56, 124, 50, 55, 49, 51, 54, 57, 48, 48, 46, 49, 56, 48, 51, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 55, 124, 52, 56, 54, 49, 49, 56, 51, 51, 46, 52, 57, 54, 50, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 54, 124, 52, 56, 50, 56, 53, 52, 56, 50, 46, 54, 55, 56, 50, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 53, 124, 52, 52, 52, 48, 50, 50, 55, 51, 46, 53, 57, 57, 57, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 52, 124, 52, 56, 54, 57, 52, 48, 48, 56, 46, 48, 54, 54, 56, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 51, 124, 52, 54, 48, 52, 52, 50, 48, 55, 46, 55, 56, 51, 56, 10, 65, 76, 71, 69, 82, 73, 65, 124, 49, 57, 57, 50, 124, 52, 53, 54, 51, 54, 56, 52, 57, 46, 52, 56, 56, 49, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 56, 124, 50, 56, 51, 52, 49, 54, 54, 51, 46, 55, 56, 52, 56, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 55, 124, 52, 55, 49, 52, 51, 57, 54, 52, 46, 49, 49, 55, 54, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 54, 124, 52, 53, 50, 53, 53, 50, 55, 56, 46, 54, 48, 50, 49, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 53, 124, 52, 53, 54, 51, 49, 55, 54, 57, 46, 50, 48, 53, 52, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 52, 124, 52, 56, 50, 54, 56, 56, 53, 54, 46, 51, 53, 52, 55, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 51, 124, 52, 56, 54, 48, 53, 53, 57, 51, 46, 54, 49, 54, 50, 10, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 49, 57, 57, 50, 124, 52, 54, 54, 53, 52, 50, 52, 48, 46, 55, 52, 56, 55, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 56, 124, 50, 54, 53, 50, 55, 55, 51, 54, 46, 51, 57, 54, 48, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 55, 124, 52, 53, 54, 52, 48, 54, 54, 48, 46, 55, 54, 55, 55, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 54, 124, 52, 53, 48, 57, 48, 54, 52, 55, 46, 49, 54, 51, 48, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 53, 124, 52, 52, 48, 49, 53, 56, 56, 56, 46, 53, 49, 51, 50, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 52, 124, 52, 52, 56, 53, 52, 50, 49, 56, 46, 56, 57, 51, 50, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 51, 124, 52, 53, 55, 54, 54, 54, 48, 51, 46, 55, 51, 55, 57, 10, 66, 82, 65, 90, 73, 76, 124, 49, 57, 57, 50, 124, 52, 53, 50, 56, 48, 50, 49, 54, 46, 56, 48, 50, 55, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 56, 124, 50, 54, 56, 50, 56, 57, 56, 53, 46, 51, 57, 52, 52, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 55, 124, 52, 52, 56, 52, 57, 57, 53, 52, 46, 51, 49, 56, 54, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 54, 124, 52, 54, 51, 48, 55, 57, 51, 54, 46, 49, 49, 48, 56, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 53, 124, 52, 55, 51, 49, 49, 57, 57, 51, 46, 48, 52, 52, 49, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 52, 124, 52, 54, 54, 57, 49, 52, 57, 49, 46, 57, 53, 57, 54, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 51, 124, 52, 54, 54, 51, 52, 55, 57, 49, 46, 49, 49, 50, 49, 10, 67, 65, 78, 65, 68, 65, 124, 49, 57, 57, 50, 124, 52, 53, 56, 55, 51, 56, 52, 57, 46, 54, 56, 56, 50, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 56, 124, 50, 55, 53, 49, 48, 49, 56, 48, 46, 49, 54, 53, 55, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 55, 124, 52, 54, 49, 50, 51, 56, 54, 53, 46, 52, 48, 57, 55, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 54, 124, 52, 57, 53, 51, 50, 56, 48, 55, 46, 48, 54, 48, 49, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 53, 124, 52, 54, 55, 51, 52, 54, 53, 49, 46, 52, 56, 51, 56, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 52, 124, 52, 54, 51, 57, 55, 56, 57, 54, 46, 54, 48, 57, 55, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 51, 124, 52, 57, 54, 51, 52, 54, 55, 51, 46, 57, 52, 54, 51, 10, 67, 72, 73, 78, 65, 124, 49, 57, 57, 50, 124, 52, 54, 57, 52, 57, 52, 53, 55, 46, 54, 52, 50, 54, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 56, 124, 50, 56, 52, 48, 49, 52, 57, 49, 46, 55, 57, 54, 56, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 55, 124, 52, 55, 54, 55, 52, 56, 53, 55, 46, 54, 55, 56, 51, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 54, 124, 52, 55, 55, 52, 53, 55, 50, 55, 46, 53, 52, 53, 48, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 53, 124, 52, 53, 56, 57, 55, 49, 54, 48, 46, 54, 55, 56, 51, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 52, 124, 52, 55, 49, 57, 52, 56, 57, 53, 46, 50, 50, 56, 48, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 51, 124, 52, 57, 49, 51, 51, 54, 50, 55, 46, 54, 52, 55, 49, 10, 69, 71, 89, 80, 84, 124, 49, 57, 57, 50, 124, 52, 55, 48, 48, 48, 53, 55, 52, 46, 53, 48, 50, 55, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 56, 124, 50, 53, 49, 51, 53, 48, 52, 54, 46, 49, 51, 55, 55, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 55, 124, 52, 51, 48, 49, 48, 53, 57, 54, 46, 48, 56, 51, 56, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 54, 124, 52, 51, 54, 51, 54, 50, 56, 55, 46, 49, 57, 50, 50, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 53, 124, 52, 51, 53, 55, 53, 55, 53, 55, 46, 51, 51, 52, 51, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 52, 124, 52, 49, 53, 57, 55, 50, 48, 56, 46, 53, 50, 56, 51, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 51, 124, 52, 50, 54, 50, 50, 56, 48, 52, 46, 49, 54, 49, 54, 10, 69, 84, 72, 73, 79, 80, 73, 65, 124, 49, 57, 57, 50, 124, 52, 52, 51, 56, 53, 55, 51, 53, 46, 54, 56, 49, 51, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 56, 124, 50, 54, 50, 49, 48, 51, 57, 50, 46, 50, 56, 48, 52, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 55, 124, 52, 50, 51, 57, 50, 57, 54, 57, 46, 52, 55, 51, 49, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 54, 124, 52, 51, 51, 48, 54, 51, 49, 55, 46, 57, 55, 52, 57, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 53, 124, 52, 54, 51, 55, 55, 52, 48, 56, 46, 52, 51, 50, 56, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 52, 124, 52, 51, 52, 52, 55, 51, 53, 50, 46, 57, 57, 50, 50, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 51, 124, 52, 51, 55, 50, 57, 57, 54, 49, 46, 48, 54, 51, 57, 10, 70, 82, 65, 78, 67, 69, 124, 49, 57, 57, 50, 124, 52, 52, 48, 53, 50, 51, 48, 56, 46, 52, 50, 57, 48, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 56, 124, 50, 53, 57, 57, 49, 50, 53, 55, 46, 49, 48, 55, 49, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 55, 124, 52, 51, 57, 54, 56, 51, 53, 53, 46, 56, 48, 55, 57, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 54, 124, 52, 53, 56, 56, 50, 48, 55, 52, 46, 56, 48, 52, 57, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 53, 124, 52, 51, 51, 49, 52, 51, 51, 56, 46, 51, 48, 55, 55, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 52, 124, 52, 52, 54, 49, 54, 57, 57, 53, 46, 52, 51, 54, 57, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 51, 124, 52, 53, 49, 50, 54, 54, 52, 53, 46, 57, 49, 49, 51, 10, 71, 69, 82, 77, 65, 78, 89, 124, 49, 57, 57, 50, 124, 52, 52, 51, 54, 49, 49, 52, 49, 46, 50, 49, 48, 55, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 56, 124, 50, 57, 54, 50, 54, 52, 49, 55, 46, 50, 51, 55, 57, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 55, 124, 53, 49, 51, 56, 54, 49, 49, 49, 46, 51, 52, 52, 56, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 54, 124, 52, 55, 53, 55, 49, 48, 49, 56, 46, 53, 49, 50, 50, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 53, 124, 52, 57, 51, 52, 52, 48, 54, 50, 46, 50, 56, 50, 57, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 52, 124, 53, 48, 49, 48, 54, 57, 53, 50, 46, 52, 50, 54, 49, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 51, 124, 52, 56, 49, 49, 50, 55, 54, 54, 46, 54, 57, 56, 55, 10, 73, 78, 68, 73, 65, 124, 49, 57, 57, 50, 124, 52, 55, 57, 49, 52, 51, 48, 51, 46, 49, 50, 51, 52, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 56, 124, 50, 55, 55, 51, 52, 57, 48, 57, 46, 54, 55, 54, 51, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 55, 124, 52, 52, 53, 57, 51, 56, 49, 50, 46, 57, 56, 54, 51, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 54, 124, 52, 52, 55, 52, 54, 55, 50, 57, 46, 56, 48, 55, 56, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 53, 124, 52, 53, 53, 57, 51, 54, 50, 50, 46, 54, 57, 57, 51, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 52, 124, 52, 53, 57, 56, 56, 52, 56, 51, 46, 56, 55, 55, 50, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 51, 124, 52, 54, 49, 52, 55, 57, 54, 51, 46, 55, 56, 57, 53, 10, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 49, 57, 57, 50, 124, 52, 53, 49, 56, 53, 55, 55, 55, 46, 48, 54, 56, 56, 10, 73, 82, 65, 78, 124, 49, 57, 57, 56, 124, 50, 54, 54, 54, 49, 54, 48, 56, 46, 57, 51, 48, 49, 10, 73, 82, 65, 78, 124, 49, 57, 57, 55, 124, 52, 53, 48, 49, 57, 49, 49, 52, 46, 49, 54, 57, 54, 10, 73, 82, 65, 78, 124, 49, 57, 57, 54, 124, 52, 53, 56, 57, 49, 51, 57, 55, 46, 48, 57, 57, 50, 10, 73, 82, 65, 78, 124, 49, 57, 57, 53, 124, 52, 52, 52, 49, 52, 50, 56, 53, 46, 50, 51, 52, 56, 10, 73, 82, 65, 78, 124, 49, 57, 57, 52, 124, 52, 51, 54, 57, 54, 51, 54, 48, 46, 52, 55, 57, 53, 10, 73, 82, 65, 78, 124, 49, 57, 57, 51, 124, 52, 53, 51, 54, 50, 55, 55, 53, 46, 56, 48, 57, 52, 10, 73, 82, 65, 78, 124, 49, 57, 57, 50, 124, 52, 51, 48, 53, 50, 51, 51, 56, 46, 52, 49, 52, 51, 10, 73, 82, 65, 81, 124, 49, 57, 57, 56, 124, 51, 49, 49, 56, 56, 52, 57, 56, 46, 49, 57, 49, 52, 10, 73, 82, 65, 81, 124, 49, 57, 57, 55, 124, 52, 56, 53, 56, 53, 51, 48, 55, 46, 53, 50, 50, 50, 10, 73, 82, 65, 81, 124, 49, 57, 57, 54, 124, 53, 48, 48, 51, 54, 53, 57, 51, 46, 56, 52, 48, 52, 10, 73, 82, 65, 81, 124, 49, 57, 57, 53, 124, 52, 56, 55, 55, 52, 56, 48, 49, 46, 55, 50, 55, 53, 10, 73, 82, 65, 81, 124, 49, 57, 57, 52, 124, 52, 56, 55, 57, 53, 56, 52, 55, 46, 50, 51, 49, 48, 10, 73, 82, 65, 81, 124, 49, 57, 57, 51, 124, 52, 55, 52, 51, 53, 54, 57, 49, 46, 53, 48, 56, 50, 10, 73, 82, 65, 81, 124, 49, 57, 57, 50, 124, 52, 55, 53, 54, 50, 51, 53, 53, 46, 54, 53, 55, 49, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 56, 124, 50, 52, 54, 57, 52, 49, 48, 50, 46, 49, 55, 50, 48, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 55, 124, 52, 50, 51, 55, 55, 48, 53, 50, 46, 51, 52, 53, 52, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 54, 124, 52, 48, 50, 54, 55, 55, 55, 56, 46, 57, 48, 57, 52, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 53, 124, 52, 48, 57, 50, 53, 51, 49, 55, 46, 52, 54, 53, 48, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 52, 124, 52, 49, 49, 53, 57, 53, 49, 56, 46, 51, 48, 53, 56, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 51, 124, 51, 57, 53, 56, 57, 48, 55, 52, 46, 50, 55, 55, 49, 10, 74, 65, 80, 65, 78, 124, 49, 57, 57, 50, 124, 51, 57, 49, 49, 51, 52, 57, 51, 46, 57, 48, 53, 50, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 56, 124, 50, 51, 52, 56, 57, 56, 54, 55, 46, 55, 56, 57, 51, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 55, 124, 52, 49, 54, 49, 53, 57, 54, 50, 46, 54, 54, 49, 57, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 54, 124, 52, 49, 56, 54, 48, 56, 53, 53, 46, 52, 54, 56, 52, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 53, 124, 51, 57, 57, 51, 49, 54, 55, 50, 46, 48, 57, 48, 56, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 52, 124, 52, 48, 55, 48, 55, 53, 53, 53, 46, 52, 54, 51, 56, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 51, 124, 51, 57, 48, 54, 48, 52, 48, 53, 46, 52, 54, 53, 56, 10, 74, 79, 82, 68, 65, 78, 124, 49, 57, 57, 50, 124, 52, 49, 54, 53, 55, 54, 48, 52, 46, 50, 54, 56, 52, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 56, 124, 50, 53, 53, 54, 54, 51, 51, 55, 46, 52, 51, 48, 51, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 55, 124, 52, 51, 49, 48, 56, 56, 52, 55, 46, 57, 48, 50, 52, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 54, 124, 52, 51, 52, 56, 50, 57, 53, 51, 46, 53, 52, 51, 48, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 53, 124, 52, 50, 53, 49, 55, 57, 56, 56, 46, 57, 56, 49, 52, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 52, 124, 52, 51, 54, 49, 50, 52, 55, 57, 46, 52, 53, 50, 51, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 51, 124, 52, 50, 55, 50, 52, 48, 51, 56, 46, 55, 53, 55, 49, 10, 75, 69, 78, 89, 65, 124, 49, 57, 57, 50, 124, 52, 51, 50, 49, 55, 49, 48, 54, 46, 50, 48, 54, 56, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 56, 124, 50, 52, 57, 49, 53, 52, 57, 54, 46, 56, 55, 53, 54, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 55, 124, 52, 50, 54, 57, 56, 51, 56, 50, 46, 56, 53, 53, 48, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 54, 124, 52, 50, 57, 56, 54, 49, 49, 51, 46, 53, 48, 52, 57, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 53, 124, 52, 50, 51, 49, 54, 48, 56, 57, 46, 49, 53, 57, 51, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 52, 124, 52, 51, 52, 53, 56, 54, 48, 52, 46, 54, 48, 50, 57, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 51, 124, 52, 50, 54, 55, 50, 50, 56, 56, 46, 48, 54, 57, 57, 10, 77, 79, 82, 79, 67, 67, 79, 124, 49, 57, 57, 50, 124, 52, 50, 56, 48, 48, 55, 56, 49, 46, 54, 52, 49, 53, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 56, 124, 50, 56, 50, 55, 57, 56, 55, 54, 46, 48, 51, 48, 49, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 55, 124, 53, 49, 49, 53, 57, 50, 49, 54, 46, 50, 50, 57, 56, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 54, 124, 52, 56, 48, 55, 50, 53, 50, 53, 46, 48, 54, 52, 53, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 53, 124, 52, 56, 57, 48, 53, 50, 48, 48, 46, 54, 48, 48, 55, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 52, 124, 52, 54, 48, 57, 50, 48, 55, 54, 46, 50, 56, 48, 53, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 51, 124, 52, 56, 53, 53, 53, 57, 50, 54, 46, 50, 54, 54, 57, 10, 77, 79, 90, 65, 77, 66, 73, 81, 85, 69, 124, 49, 57, 57, 50, 124, 52, 55, 56, 48, 57, 48, 55, 53, 46, 49, 49, 57, 50, 10, 80, 69, 82, 85, 124, 49, 57, 57, 56, 124, 50, 54, 55, 49, 51, 57, 54, 54, 46, 50, 54, 55, 56, 10, 80, 69, 82, 85, 124, 49, 57, 57, 55, 124, 52, 56, 51, 50, 52, 48, 48, 56, 46, 54, 48, 49, 49, 10, 80, 69, 82, 85, 124, 49, 57, 57, 54, 124, 53, 48, 51, 49, 48, 48, 48, 56, 46, 56, 54, 50, 57, 10, 80, 69, 82, 85, 124, 49, 57, 57, 53, 124, 52, 57, 54, 52, 55, 48, 56, 48, 46, 57, 54, 50, 57, 10, 80, 69, 82, 85, 124, 49, 57, 57, 52, 124, 52, 54, 52, 50, 48, 57, 49, 48, 46, 50, 55, 55, 51, 10, 80, 69, 82, 85, 124, 49, 57, 57, 51, 124, 53, 49, 53, 51, 54, 57, 48, 54, 46, 50, 52, 56, 55, 10, 80, 69, 82, 85, 124, 49, 57, 57, 50, 124, 52, 55, 55, 49, 49, 54, 54, 53, 46, 51, 49, 51, 55, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 56, 124, 50, 55, 50, 55, 49, 57, 57, 51, 46, 49, 48, 49, 48, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 55, 124, 52, 53, 48, 54, 51, 48, 53, 57, 46, 49, 57, 53, 51, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 54, 124, 52, 55, 52, 57, 50, 51, 51, 53, 46, 48, 51, 50, 51, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 53, 124, 52, 53, 55, 49, 48, 54, 51, 54, 46, 50, 57, 48, 57, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 52, 124, 52, 54, 48, 56, 56, 48, 52, 49, 46, 49, 48, 54, 54, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 51, 124, 52, 55, 53, 49, 53, 48, 57, 50, 46, 53, 54, 49, 51, 10, 82, 79, 77, 65, 78, 73, 65, 124, 49, 57, 57, 50, 124, 52, 52, 49, 49, 49, 52, 51, 57, 46, 56, 48, 52, 52, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 56, 124, 50, 55, 57, 51, 53, 51, 50, 51, 46, 55, 50, 55, 49, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 55, 124, 52, 56, 50, 50, 50, 51, 52, 55, 46, 50, 57, 50, 52, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 54, 124, 52, 55, 53, 53, 51, 53, 53, 57, 46, 52, 57, 51, 50, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 53, 124, 52, 54, 55, 53, 53, 57, 57, 48, 46, 48, 57, 55, 54, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 52, 124, 52, 56, 48, 48, 48, 53, 49, 53, 46, 54, 49, 57, 49, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 51, 124, 52, 56, 53, 54, 57, 54, 50, 52, 46, 53, 48, 56, 50, 10, 82, 85, 83, 83, 73, 65, 124, 49, 57, 57, 50, 124, 52, 55, 54, 55, 50, 56, 51, 49, 46, 53, 51, 50, 57, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 56, 124, 50, 55, 49, 49, 51, 53, 49, 54, 46, 56, 52, 50, 52, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 55, 124, 52, 54, 54, 57, 48, 52, 54, 56, 46, 57, 54, 52, 57, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 54, 124, 52, 55, 55, 55, 53, 55, 56, 50, 46, 54, 54, 55, 48, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 53, 124, 52, 54, 54, 53, 55, 49, 48, 55, 46, 56, 50, 56, 55, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 52, 124, 52, 56, 49, 56, 49, 54, 55, 50, 46, 56, 49, 48, 48, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 51, 124, 52, 53, 54, 57, 50, 53, 53, 54, 46, 52, 52, 51, 56, 10, 83, 65, 85, 68, 73, 32, 65, 82, 65, 66, 73, 65, 124, 49, 57, 57, 50, 124, 52, 56, 57, 50, 52, 57, 49, 51, 46, 50, 55, 49, 55, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 56, 124, 50, 54, 51, 54, 54, 54, 56, 50, 46, 56, 55, 56, 54, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 55, 124, 52, 52, 53, 49, 56, 49, 51, 48, 46, 49, 56, 53, 49, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 54, 124, 52, 53, 53, 51, 57, 55, 50, 57, 46, 54, 49, 54, 54, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 53, 124, 52, 54, 56, 52, 53, 56, 55, 57, 46, 51, 51, 57, 48, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 52, 124, 52, 51, 48, 56, 49, 54, 48, 57, 46, 53, 55, 51, 55, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 51, 124, 52, 52, 55, 55, 48, 49, 52, 54, 46, 55, 53, 53, 53, 10, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 49, 57, 57, 50, 124, 52, 52, 49, 50, 51, 52, 48, 50, 46, 53, 52, 56, 52, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 56, 124, 50, 55, 56, 50, 54, 53, 57, 51, 46, 54, 56, 50, 53, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 55, 124, 52, 54, 54, 51, 56, 53, 55, 50, 46, 51, 54, 52, 56, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 54, 124, 52, 54, 54, 56, 56, 50, 56, 48, 46, 53, 52, 55, 52, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 53, 124, 52, 56, 57, 53, 49, 53, 57, 49, 46, 54, 49, 53, 54, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 52, 124, 52, 53, 48, 57, 57, 48, 57, 50, 46, 48, 53, 57, 56, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 51, 124, 52, 54, 49, 56, 49, 54, 48, 48, 46, 53, 50, 55, 56, 10, 85, 78, 73, 84, 69, 68, 32, 83, 84, 65, 84, 69, 83, 124, 49, 57, 57, 50, 124, 52, 54, 49, 54, 56, 50, 49, 52, 46, 48, 57, 48, 49, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 56, 124, 50, 55, 50, 56, 49, 57, 51, 49, 46, 48, 48, 49, 49, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 55, 124, 52, 56, 55, 51, 53, 57, 49, 52, 46, 49, 55, 57, 54, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 54, 124, 52, 55, 56, 50, 52, 53, 57, 53, 46, 57, 48, 52, 48, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 53, 124, 52, 56, 50, 51, 53, 49, 51, 53, 46, 56, 48, 49, 54, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 52, 124, 52, 55, 55, 50, 57, 50, 53, 54, 46, 51, 51, 50, 52, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 51, 124, 52, 53, 51, 53, 50, 54, 55, 54, 46, 56, 54, 55, 50, 10, 86, 73, 69, 84, 78, 65, 77, 124, 49, 57, 57, 50, 124, 52, 55, 56, 52, 54, 51, 53, 53, 46, 54, 52, 56, 53, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q10[] = {99, 95, 99, 117, 115, 116, 107, 101, 121, 124, 99, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 124, 99, 95, 97, 99, 99, 116, 98, 97, 108, 124, 110, 95, 110, 97, 109, 101, 124, 99, 95, 97, 100, 100, 114, 101, 115, 115, 124, 99, 95, 112, 104, 111, 110, 101, 124, 99, 95, 99, 111, 109, 109, 101, 110, 116, 10, 53, 55, 48, 52, 48, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 53, 55, 48, 52, 48, 124, 55, 51, 52, 50, 51, 53, 46, 50, 52, 53, 53, 124, 54, 51, 50, 46, 56, 55, 124, 74, 65, 80, 65, 78, 124, 110, 73, 67, 116, 115, 73, 76, 87, 66, 66, 124, 50, 50, 45, 56, 57, 53, 45, 54, 52, 49, 45, 51, 52, 54, 54, 124, 115, 105, 116, 115, 46, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 113, 117, 101, 115, 116, 115, 32, 115, 108, 101, 101, 112, 32, 97, 108, 111, 110, 103, 115, 105, 100, 101, 32, 111, 102, 32, 116, 104, 101, 32, 114, 101, 103, 117, 108, 97, 114, 32, 105, 110, 115, 116, 10, 49, 52, 51, 51, 52, 55, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 51, 51, 52, 55, 124, 55, 50, 49, 48, 48, 50, 46, 54, 57, 52, 56, 124, 50, 53, 53, 55, 46, 52, 55, 124, 69, 71, 89, 80, 84, 124, 44, 81, 57, 77, 108, 51, 119, 48, 103, 118, 88, 124, 49, 52, 45, 55, 52, 50, 45, 57, 51, 53, 45, 51, 55, 49, 56, 124, 103, 103, 108, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 110, 116, 105, 99, 105, 110, 103, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 117, 115, 101, 32, 98, 111, 108, 100, 44, 32, 98, 111, 108, 100, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 46, 32, 105, 114, 111, 110, 105, 99, 44, 32, 105, 100, 108, 101, 32, 114, 101, 10, 54, 48, 56, 51, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 54, 48, 56, 51, 56, 124, 54, 55, 57, 49, 50, 55, 46, 51, 48, 55, 55, 124, 50, 52, 53, 52, 46, 55, 55, 124, 66, 82, 65, 90, 73, 76, 124, 86, 87, 109, 81, 104, 87, 119, 101, 113, 106, 53, 104, 70, 112, 99, 118, 104, 71, 70, 66, 101, 79, 89, 57, 104, 74, 52, 109, 124, 49, 50, 45, 57, 49, 51, 45, 52, 57, 52, 45, 57, 56, 49, 51, 124, 32, 110, 101, 101, 100, 32, 116, 111, 32, 98, 111, 111, 115, 116, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 97, 99, 99, 111, 117, 110, 116, 10, 49, 48, 49, 57, 57, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 48, 49, 57, 57, 56, 124, 54, 51, 55, 48, 50, 57, 46, 53, 54, 54, 55, 124, 51, 55, 57, 48, 46, 56, 57, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 48, 44, 79, 82, 111, 106, 102, 68, 100, 121, 77, 99, 97, 50, 69, 50, 72, 124, 51, 51, 45, 53, 57, 51, 45, 56, 54, 53, 45, 54, 51, 55, 56, 124, 114, 101, 115, 115, 32, 102, 111, 120, 101, 115, 32, 119, 97, 107, 101, 32, 115, 108, 121, 108, 121, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 98, 111, 108, 100, 32, 101, 120, 99, 117, 115, 101, 115, 46, 32, 105, 114, 111, 110, 105, 99, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 97, 114, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 98, 111, 108, 100, 32, 116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 10, 49, 50, 53, 51, 52, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 50, 53, 51, 52, 49, 124, 54, 51, 51, 53, 48, 56, 46, 48, 56, 54, 48, 124, 52, 57, 56, 51, 46, 53, 49, 124, 71, 69, 82, 77, 65, 78, 89, 124, 57, 89, 82, 99, 110, 111, 85, 80, 79, 77, 55, 83, 97, 56, 120, 121, 109, 104, 115, 68, 72, 100, 81, 103, 124, 49, 55, 45, 53, 56, 50, 45, 54, 57, 53, 45, 53, 57, 54, 50, 124, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 118, 101, 110, 32, 100, 101, 112, 116, 104, 115, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 101, 118, 101, 110, 32, 101, 120, 99, 117, 115, 101, 115, 32, 115, 108, 101, 101, 112, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 46, 32, 102, 111, 120, 101, 115, 32, 117, 115, 101, 32, 101, 120, 99, 101, 112, 116, 32, 116, 104, 101, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 46, 32, 99, 97, 10, 50, 53, 53, 48, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 50, 53, 53, 48, 49, 124, 54, 50, 48, 50, 54, 57, 46, 55, 56, 52, 57, 124, 55, 55, 50, 53, 46, 48, 52, 124, 69, 84, 72, 73, 79, 80, 73, 65, 124, 115, 114, 52, 86, 86, 86, 101, 51, 120, 67, 74, 81, 50, 111, 111, 50, 81, 69, 104, 105, 49, 57, 68, 44, 112, 88, 113, 111, 54, 107, 79, 71, 97, 83, 110, 50, 124, 49, 53, 45, 56, 55, 52, 45, 56, 48, 56, 45, 54, 55, 57, 51, 124, 104, 101, 32, 112, 101, 110, 100, 105, 110, 103, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 32, 119, 97, 107, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 97, 116, 32, 116, 104, 101, 32, 112, 105, 110, 116, 111, 32, 98, 101, 97, 110, 115, 46, 32, 114, 101, 103, 117, 108, 97, 114, 44, 32, 102, 105, 110, 97, 108, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 10, 49, 49, 53, 56, 51, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 53, 56, 51, 49, 124, 53, 57, 54, 52, 50, 51, 46, 56, 54, 55, 50, 124, 53, 48, 57, 56, 46, 49, 48, 124, 70, 82, 65, 78, 67, 69, 124, 65, 108, 77, 112, 80, 110, 109, 116, 71, 114, 79, 70, 114, 68, 77, 85, 115, 53, 86, 76, 111, 32, 69, 73, 65, 44, 67, 103, 44, 82, 119, 53, 84, 66, 117, 66, 111, 75, 105, 79, 124, 49, 54, 45, 55, 49, 53, 45, 51, 56, 54, 45, 51, 55, 56, 56, 124, 108, 32, 115, 111, 109, 97, 115, 32, 115, 108, 101, 101, 112, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 119, 97, 107, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 112, 105, 110, 116, 111, 32, 98, 10, 56, 52, 50, 50, 51, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 56, 52, 50, 50, 51, 124, 53, 57, 52, 57, 57, 56, 46, 48, 50, 51, 57, 124, 53, 50, 56, 46, 54, 53, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 69, 113, 53, 49, 111, 32, 85, 112, 81, 52, 82, 66, 114, 32, 32, 102, 89, 84, 100, 114, 90, 65, 112, 68, 115, 80, 86, 52, 112, 81, 121, 117, 80, 113, 124, 51, 51, 45, 52, 52, 50, 45, 56, 50, 52, 45, 56, 49, 57, 49, 124, 32, 115, 108, 121, 108, 121, 32, 102, 105, 110, 97, 108, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 104, 97, 103, 103, 108, 101, 32, 114, 101, 103, 117, 108, 97, 114, 44, 32, 112, 101, 110, 100, 105, 110, 103, 32, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 46, 32, 112, 101, 110, 100, 105, 110, 103, 32, 101, 115, 99, 97, 112, 97, 100, 101, 115, 32, 119, 97, 107, 101, 32, 10, 53, 52, 50, 56, 57, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 53, 52, 50, 56, 57, 124, 53, 56, 53, 54, 48, 51, 46, 51, 57, 49, 56, 124, 53, 53, 56, 51, 46, 48, 50, 124, 73, 82, 65, 78, 124, 120, 51, 111, 117, 67, 112, 122, 54, 44, 112, 82, 78, 86, 104, 97, 106, 114, 48, 67, 67, 81, 71, 49, 124, 50, 48, 45, 56, 51, 52, 45, 50, 57, 50, 45, 52, 55, 48, 55, 124, 101, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 102, 111, 120, 101, 115, 32, 97, 114, 101, 32, 113, 117, 105, 99, 107, 108, 121, 32, 102, 105, 110, 97, 108, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 112, 10, 51, 57, 57, 50, 50, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 51, 57, 57, 50, 50, 124, 53, 56, 52, 56, 55, 56, 46, 49, 49, 51, 52, 124, 55, 51, 50, 49, 46, 49, 49, 124, 71, 69, 82, 77, 65, 78, 89, 124, 50, 75, 116, 87, 122, 87, 44, 70, 89, 107, 104, 100, 87, 66, 102, 111, 98, 112, 54, 83, 70, 88, 87, 89, 75, 106, 118, 85, 57, 124, 49, 55, 45, 49, 52, 55, 45, 55, 53, 55, 45, 56, 48, 51, 54, 124, 121, 32, 102, 105, 110, 97, 108, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 102, 105, 110, 97, 108, 32, 102, 111, 120, 101, 115, 32, 99, 97, 106, 111, 108, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 115, 112, 101, 99, 105, 97, 108, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 46, 32, 102, 10, 54, 50, 50, 54, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 54, 50, 50, 54, 124, 53, 55, 54, 55, 56, 51, 46, 55, 54, 48, 54, 124, 50, 50, 51, 48, 46, 48, 57, 124, 85, 78, 73, 84, 69, 68, 32, 75, 73, 78, 71, 68, 79, 77, 124, 84, 75, 98, 120, 83, 49, 100, 98, 107, 71, 77, 116, 97, 97, 44, 75, 79, 105, 50, 54, 108, 98, 105, 112, 52, 80, 48, 116, 80, 98, 87, 75, 48, 124, 51, 51, 45, 54, 53, 55, 45, 55, 48, 49, 45, 51, 51, 57, 49, 124, 101, 110, 100, 105, 110, 103, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 101, 120, 112, 114, 101, 115, 115, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 102, 105, 110, 97, 108, 32, 10, 57, 50, 50, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 50, 50, 124, 53, 55, 54, 55, 54, 55, 46, 53, 51, 51, 51, 124, 51, 56, 54, 57, 46, 50, 53, 124, 71, 69, 82, 77, 65, 78, 89, 124, 114, 115, 82, 57, 108, 82, 120, 121, 84, 100, 72, 98, 68, 79, 86, 116, 56, 110, 89, 98, 119, 106, 75, 53, 118, 65, 87, 72, 57, 115, 66, 124, 49, 55, 45, 57, 52, 53, 45, 57, 49, 54, 45, 57, 54, 52, 56, 124, 108, 117, 102, 102, 105, 108, 121, 32, 102, 108, 117, 102, 102, 121, 32, 100, 101, 112, 111, 115, 105, 116, 115, 46, 32, 112, 97, 99, 107, 97, 103, 101, 115, 32, 99, 10, 49, 52, 55, 57, 52, 54, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 55, 57, 52, 54, 124, 53, 55, 54, 52, 53, 53, 46, 49, 51, 50, 48, 124, 50, 48, 51, 48, 46, 49, 51, 124, 65, 76, 71, 69, 82, 73, 65, 124, 74, 113, 100, 116, 49, 107, 72, 65, 74, 116, 117, 84, 113, 72, 81, 75, 44, 66, 55, 32, 51, 116, 74, 104, 124, 49, 48, 45, 56, 56, 54, 45, 57, 53, 54, 45, 51, 49, 52, 51, 124, 105, 116, 104, 101, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 104, 97, 103, 103, 108, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 105, 114, 111, 110, 105, 99, 32, 114, 101, 113, 117, 101, 115, 116, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 114, 101, 103, 117, 10, 49, 49, 53, 54, 52, 48, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 53, 54, 52, 48, 124, 53, 54, 57, 51, 52, 49, 46, 49, 57, 51, 51, 124, 54, 52, 51, 54, 46, 49, 48, 124, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 54, 121, 75, 76, 73, 82, 82, 65, 105, 114, 85, 109, 66, 106, 75, 78, 79, 54, 90, 51, 124, 49, 49, 45, 52, 49, 49, 45, 53, 52, 51, 45, 52, 57, 48, 49, 124, 111, 115, 116, 32, 115, 108, 121, 108, 121, 32, 97, 108, 111, 110, 103, 32, 116, 104, 101, 32, 112, 97, 116, 116, 101, 114, 110, 115, 59, 32, 112, 105, 110, 116, 111, 32, 98, 101, 10, 55, 51, 54, 48, 54, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 55, 51, 54, 48, 54, 124, 53, 54, 56, 54, 53, 54, 46, 56, 53, 55, 56, 124, 49, 55, 56, 53, 46, 54, 55, 124, 74, 65, 80, 65, 78, 124, 118, 120, 57, 44, 55, 65, 67, 86, 116, 111, 75, 110, 76, 99, 111, 65, 72, 71, 78, 89, 68, 70, 124, 50, 50, 45, 52, 51, 55, 45, 54, 53, 51, 45, 54, 57, 54, 54, 124, 104, 101, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 105, 100, 101, 97, 115, 46, 32, 115, 108, 111, 119, 108, 121, 10, 49, 49, 48, 50, 52, 54, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 48, 50, 52, 54, 124, 53, 54, 54, 56, 52, 50, 46, 57, 56, 49, 53, 124, 55, 55, 54, 51, 46, 51, 53, 124, 86, 73, 69, 84, 78, 65, 77, 124, 85, 103, 115, 76, 70, 76, 51, 114, 101, 110, 100, 65, 84, 122, 99, 72, 105, 124, 51, 49, 45, 57, 52, 51, 45, 52, 50, 54, 45, 57, 56, 51, 55, 124, 101, 103, 117, 108, 97, 114, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 115, 101, 114, 118, 101, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 97, 98, 111, 118, 101, 32, 116, 104, 101, 32, 102, 108, 10, 49, 52, 50, 53, 52, 57, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 50, 53, 52, 57, 124, 53, 54, 51, 53, 51, 55, 46, 50, 51, 54, 56, 124, 53, 48, 56, 53, 46, 57, 57, 124, 73, 78, 68, 79, 78, 69, 83, 73, 65, 124, 112, 74, 65, 109, 67, 104, 87, 88, 99, 116, 32, 72, 78, 106, 80, 122, 103, 111, 66, 85, 79, 103, 65, 72, 100, 117, 119, 119, 73, 82, 124, 49, 57, 45, 57, 53, 53, 45, 53, 54, 50, 45, 50, 51, 57, 56, 124, 115, 108, 101, 101, 112, 32, 112, 101, 110, 100, 105, 110, 103, 32, 99, 111, 117, 114, 116, 115, 46, 32, 105, 114, 111, 110, 105, 99, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 97, 103, 97, 105, 110, 115, 116, 32, 116, 104, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 117, 110, 117, 115, 117, 97, 108, 32, 112, 108, 97, 116, 101, 108, 101, 116, 115, 32, 99, 97, 106, 111, 108, 101, 32, 99, 97, 114, 101, 102, 117, 108, 108, 121, 32, 101, 120, 112, 114, 101, 115, 115, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 10, 49, 52, 54, 49, 52, 57, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 54, 49, 52, 57, 124, 53, 53, 55, 50, 53, 52, 46, 57, 56, 54, 53, 124, 49, 55, 57, 49, 46, 53, 53, 124, 82, 79, 77, 65, 78, 73, 65, 124, 32, 83, 84, 76, 119, 116, 108, 97, 66, 54, 124, 50, 57, 45, 55, 52, 52, 45, 49, 54, 52, 45, 54, 52, 56, 55, 124, 32, 111, 102, 32, 116, 104, 101, 32, 115, 108, 121, 108, 121, 32, 115, 105, 108, 101, 110, 116, 32, 97, 99, 99, 111, 117, 110, 116, 115, 46, 32, 113, 117, 105, 99, 107, 108, 121, 32, 102, 105, 110, 97, 108, 32, 97, 99, 99, 111, 117, 110, 116, 115, 32, 97, 99, 114, 111, 115, 115, 32, 116, 104, 101, 32, 10, 53, 50, 53, 50, 56, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 53, 50, 53, 50, 56, 124, 53, 53, 54, 51, 57, 55, 46, 51, 53, 48, 57, 124, 53, 53, 49, 46, 55, 57, 124, 65, 82, 71, 69, 78, 84, 73, 78, 65, 124, 101, 108, 115, 121, 116, 56, 99, 57, 90, 44, 55, 99, 104, 124, 49, 49, 45, 50, 48, 56, 45, 49, 57, 50, 45, 51, 50, 48, 53, 124, 32, 100, 101, 112, 111, 115, 105, 116, 115, 32, 104, 105, 110, 100, 101, 114, 46, 32, 98, 108, 105, 116, 104, 101, 108, 121, 32, 112, 101, 110, 100, 105, 110, 103, 32, 97, 115, 121, 109, 112, 116, 111, 116, 101, 115, 32, 98, 114, 101, 97, 99, 104, 32, 115, 108, 121, 108, 121, 32, 114, 101, 103, 117, 108, 97, 114, 32, 114, 101, 10, 50, 51, 52, 51, 49, 124, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 50, 51, 52, 51, 49, 124, 53, 53, 52, 50, 54, 57, 46, 53, 51, 54, 48, 124, 51, 51, 56, 49, 46, 56, 54, 124, 82, 79, 77, 65, 78, 73, 65, 124, 107, 75, 73, 53, 44, 67, 74, 65, 74, 81, 106, 81, 82, 81, 116, 79, 100, 67, 105, 70, 81, 124, 50, 57, 45, 57, 49, 53, 45, 52, 53, 56, 45, 50, 54, 53, 52, 124, 110, 117, 115, 117, 97, 108, 44, 32, 101, 118, 101, 110, 32, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 115, 58, 32, 102, 117, 114, 105, 111, 117, 115, 108, 121, 32, 115, 116, 101, 97, 108, 116, 104, 121, 32, 110, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q11[] = {112, 115, 95, 112, 97, 114, 116, 107, 101, 121, 124, 118, 97, 108, 117, 101, 10, 49, 50, 57, 55, 54, 48, 124, 49, 55, 53, 51, 56, 52, 53, 54, 46, 56, 54, 10, 49, 54, 54, 55, 50, 54, 124, 49, 54, 53, 48, 51, 51, 53, 51, 46, 57, 50, 10, 49, 57, 49, 50, 56, 55, 124, 49, 54, 52, 55, 52, 56, 48, 49, 46, 57, 55, 10, 49, 54, 49, 55, 53, 56, 124, 49, 54, 49, 48, 49, 55, 53, 53, 46, 53, 52, 10, 51, 52, 52, 53, 50, 124, 49, 53, 57, 56, 51, 56, 52, 52, 46, 55, 50, 10, 49, 51, 57, 48, 51, 53, 124, 49, 53, 57, 48, 55, 48, 55, 56, 46, 51, 52, 10, 57, 52, 48, 51, 124, 49, 53, 52, 53, 49, 55, 53, 53, 46, 54, 50, 10, 49, 53, 52, 51, 53, 56, 124, 49, 53, 50, 49, 50, 57, 51, 55, 46, 56, 56, 10, 51, 56, 56, 50, 51, 124, 49, 53, 48, 54, 52, 56, 48, 50, 46, 56, 54, 10, 56, 53, 54, 48, 54, 124, 49, 53, 48, 53, 51, 57, 53, 55, 46, 49, 53, 10, 51, 51, 51, 53, 52, 124, 49, 52, 52, 48, 56, 50, 57, 55, 46, 52, 48, 10, 49, 53, 52, 55, 52, 55, 124, 49, 52, 52, 48, 55, 53, 56, 48, 46, 54, 56, 10, 56, 50, 56, 54, 53, 124, 49, 52, 50, 51, 53, 52, 56, 57, 46, 55, 56, 10, 55, 54, 48, 57, 52, 124, 49, 52, 48, 57, 52, 50, 52, 55, 46, 48, 52, 10, 50, 50, 50, 124, 49, 51, 57, 51, 55, 55, 55, 55, 46, 55, 52, 10, 49, 50, 49, 50, 55, 49, 124, 49, 51, 57, 48, 56, 51, 51, 54, 46, 48, 48, 10, 53, 53, 50, 50, 49, 124, 49, 51, 55, 49, 54, 49, 50, 48, 46, 52, 55, 10, 50, 50, 56, 49, 57, 124, 49, 51, 54, 54, 54, 52, 51, 52, 46, 50, 56, 10, 55, 54, 50, 56, 49, 124, 49, 51, 54, 52, 54, 56, 53, 51, 46, 54, 56, 10, 56, 53, 50, 57, 56, 124, 49, 51, 53, 56, 49, 49, 53, 52, 46, 57, 51, 10, 56, 53, 49, 53, 56, 124, 49, 51, 53, 53, 52, 57, 48, 52, 46, 48, 48, 10, 49, 51, 57, 54, 56, 52, 124, 49, 51, 53, 51, 53, 53, 51, 56, 46, 55, 50, 10, 51, 49, 48, 51, 52, 124, 49, 51, 52, 57, 56, 48, 50, 53, 46, 50, 53, 10, 56, 55, 51, 48, 53, 124, 49, 51, 52, 56, 50, 56, 52, 55, 46, 48, 52, 10, 49, 48, 49, 56, 49, 124, 49, 51, 52, 52, 53, 49, 52, 56, 46, 55, 53, 10, 54, 50, 51, 50, 51, 124, 49, 51, 52, 49, 49, 56, 50, 52, 46, 51, 48, 10, 50, 54, 52, 56, 57, 124, 49, 51, 51, 55, 55, 50, 53, 54, 46, 51, 56, 10, 57, 54, 52, 57, 51, 124, 49, 51, 51, 51, 57, 48, 53, 55, 46, 56, 51, 10, 53, 54, 53, 52, 56, 124, 49, 51, 51, 50, 57, 48, 49, 52, 46, 57, 55, 10, 53, 53, 53, 55, 54, 124, 49, 51, 51, 48, 54, 56, 52, 51, 46, 51, 53, 10, 49, 53, 57, 55, 53, 49, 124, 49, 51, 51, 48, 54, 54, 49, 52, 46, 52, 56, 10, 57, 50, 52, 48, 54, 124, 49, 51, 50, 56, 55, 52, 49, 52, 46, 53, 48, 10, 49, 56, 50, 54, 51, 54, 124, 49, 51, 50, 50, 51, 55, 50, 54, 46, 55, 52, 10, 49, 57, 57, 57, 54, 57, 124, 49, 51, 49, 51, 53, 50, 56, 56, 46, 50, 49, 10, 54, 50, 56, 54, 53, 124, 49, 51, 48, 48, 49, 57, 50, 54, 46, 57, 52, 10, 55, 50, 56, 52, 124, 49, 50, 57, 52, 53, 50, 57, 56, 46, 49, 57, 10, 49, 57, 55, 56, 54, 55, 124, 49, 50, 57, 52, 52, 53, 49, 48, 46, 53, 50, 10, 49, 49, 53, 54, 50, 124, 49, 50, 57, 51, 49, 53, 55, 53, 46, 53, 49, 10, 55, 53, 49, 54, 53, 124, 49, 50, 57, 49, 54, 57, 49, 56, 46, 49, 50, 10, 57, 55, 49, 55, 53, 124, 49, 50, 57, 49, 49, 50, 56, 51, 46, 53, 48, 10, 49, 52, 48, 56, 52, 48, 124, 49, 50, 56, 57, 54, 53, 54, 50, 46, 50, 51, 10, 54, 53, 50, 52, 49, 124, 49, 50, 56, 57, 48, 54, 48, 48, 46, 52, 54, 10, 49, 54, 54, 49, 50, 48, 124, 49, 50, 56, 55, 54, 57, 50, 55, 46, 50, 50, 10, 57, 48, 51, 53, 124, 49, 50, 56, 54, 51, 56, 50, 56, 46, 55, 48, 10, 49, 52, 52, 54, 49, 54, 124, 49, 50, 56, 53, 51, 53, 52, 57, 46, 51, 48, 10, 49, 55, 54, 55, 50, 51, 124, 49, 50, 56, 51, 50, 51, 48, 57, 46, 55, 52, 10, 49, 55, 48, 56, 56, 52, 124, 49, 50, 55, 57, 50, 49, 51, 54, 46, 53, 56, 10, 50, 57, 55, 57, 48, 124, 49, 50, 55, 50, 51, 51, 48, 48, 46, 51, 51, 10, 57, 53, 50, 49, 51, 124, 49, 50, 53, 53, 53, 52, 56, 51, 46, 55, 51, 10, 49, 56, 51, 56, 55, 51, 124, 49, 50, 53, 53, 48, 53, 51, 51, 46, 48, 53, 10, 49, 55, 49, 50, 51, 53, 124, 49, 50, 52, 55, 54, 53, 51, 56, 46, 51, 48, 10, 50, 49, 53, 51, 51, 124, 49, 50, 52, 51, 55, 56, 50, 49, 46, 51, 50, 10, 49, 55, 50, 57, 48, 124, 49, 50, 52, 51, 50, 49, 53, 57, 46, 53, 48, 10, 49, 53, 54, 51, 57, 55, 124, 49, 50, 50, 54, 48, 54, 50, 51, 46, 53, 48, 10, 49, 50, 50, 54, 49, 49, 124, 49, 50, 50, 50, 50, 56, 49, 50, 46, 57, 56, 10, 49, 51, 57, 49, 53, 53, 124, 49, 50, 50, 50, 48, 51, 49, 57, 46, 50, 53, 10, 49, 52, 54, 51, 49, 54, 124, 49, 50, 50, 49, 53, 56, 48, 48, 46, 54, 49, 10, 49, 55, 49, 51, 56, 49, 124, 49, 50, 49, 57, 57, 55, 51, 52, 46, 53, 50, 10, 49, 57, 56, 54, 51, 51, 124, 49, 50, 48, 55, 56, 50, 50, 54, 46, 57, 53, 10, 49, 54, 55, 52, 49, 55, 124, 49, 50, 48, 52, 54, 54, 51, 55, 46, 54, 50, 10, 53, 57, 53, 49, 50, 124, 49, 50, 48, 52, 51, 52, 54, 56, 46, 55, 54, 10, 51, 49, 54, 56, 56, 124, 49, 50, 48, 51, 52, 56, 57, 51, 46, 54, 52, 10, 49, 53, 57, 53, 56, 54, 124, 49, 50, 48, 48, 49, 53, 48, 53, 46, 56, 52, 10, 56, 57, 57, 51, 124, 49, 49, 57, 54, 51, 56, 49, 52, 46, 51, 48, 10, 49, 50, 48, 51, 48, 50, 124, 49, 49, 56, 53, 55, 55, 48, 55, 46, 53, 53, 10, 52, 51, 53, 51, 54, 124, 49, 49, 55, 55, 57, 51, 52, 48, 46, 53, 50, 10, 57, 53, 53, 50, 124, 49, 49, 55, 55, 54, 57, 48, 57, 46, 49, 54, 10, 56, 54, 50, 50, 51, 124, 49, 49, 55, 55, 50, 50, 48, 53, 46, 48, 56, 10, 53, 51, 55, 55, 54, 124, 49, 49, 55, 53, 56, 54, 54, 57, 46, 54, 53, 10, 49, 51, 49, 50, 56, 53, 124, 49, 49, 54, 49, 54, 57, 53, 51, 46, 55, 52, 10, 57, 49, 54, 50, 56, 124, 49, 49, 54, 49, 49, 49, 49, 52, 46, 56, 51, 10, 49, 54, 57, 54, 52, 52, 124, 49, 49, 53, 54, 55, 57, 53, 57, 46, 55, 50, 10, 49, 56, 50, 50, 57, 57, 124, 49, 49, 53, 54, 55, 52, 54, 50, 46, 48, 53, 10, 51, 51, 49, 48, 55, 124, 49, 49, 52, 53, 51, 56, 49, 56, 46, 55, 54, 10, 49, 48, 52, 49, 56, 52, 124, 49, 49, 52, 51, 54, 54, 53, 55, 46, 52, 52, 10, 54, 55, 48, 50, 55, 124, 49, 49, 52, 49, 57, 49, 50, 55, 46, 49, 52, 10, 49, 55, 54, 56, 54, 57, 124, 49, 49, 51, 55, 49, 52, 53, 49, 46, 55, 49, 10, 51, 48, 56, 56, 53, 124, 49, 49, 51, 54, 57, 54, 55, 52, 46, 55, 57, 10, 53, 52, 52, 50, 48, 124, 49, 49, 51, 52, 53, 48, 55, 54, 46, 56, 56, 10, 55, 50, 50, 52, 48, 124, 49, 49, 51, 49, 51, 57, 53, 49, 46, 48, 53, 10, 49, 55, 56, 55, 48, 56, 124, 49, 49, 50, 57, 52, 54, 51, 53, 46, 49, 55, 10, 56, 49, 50, 57, 56, 124, 49, 49, 50, 55, 51, 54, 56, 54, 46, 49, 51, 10, 49, 53, 56, 51, 50, 52, 124, 49, 49, 50, 52, 51, 52, 52, 50, 46, 55, 50, 10, 49, 49, 55, 48, 57, 53, 124, 49, 49, 50, 52, 50, 53, 51, 53, 46, 50, 52, 10, 49, 55, 54, 55, 57, 51, 124, 49, 49, 50, 51, 55, 55, 51, 51, 46, 51, 56, 10, 56, 54, 48, 57, 49, 124, 49, 49, 49, 55, 55, 55, 57, 51, 46, 55, 57, 10, 49, 49, 54, 48, 51, 51, 124, 49, 49, 49, 52, 53, 52, 51, 52, 46, 51, 54, 10, 49, 50, 57, 48, 53, 56, 124, 49, 49, 49, 49, 57, 49, 49, 50, 46, 50, 48, 10, 49, 57, 51, 55, 49, 52, 124, 49, 49, 49, 48, 52, 55, 48, 54, 46, 51, 57, 10, 49, 49, 55, 49, 57, 53, 124, 49, 49, 48, 55, 55, 50, 49, 55, 46, 57, 54, 10, 52, 57, 56, 53, 49, 124, 49, 49, 48, 52, 51, 55, 48, 49, 46, 55, 56, 10, 49, 57, 55, 57, 49, 124, 49, 49, 48, 51, 48, 54, 54, 50, 46, 54, 50, 10, 55, 53, 56, 48, 48, 124, 49, 49, 48, 49, 50, 52, 48, 49, 46, 54, 50, 10, 49, 54, 49, 53, 54, 50, 124, 49, 48, 57, 57, 54, 51, 55, 49, 46, 54, 57, 10, 49, 48, 49, 49, 57, 124, 49, 48, 57, 56, 48, 48, 49, 53, 46, 55, 53, 10, 51, 57, 49, 56, 53, 124, 49, 48, 57, 55, 48, 48, 52, 50, 46, 53, 54, 10, 52, 55, 50, 50, 51, 124, 49, 48, 57, 53, 48, 48, 50, 50, 46, 49, 51, 10, 49, 55, 53, 53, 57, 52, 124, 49, 48, 57, 52, 50, 57, 50, 51, 46, 48, 53, 10, 49, 49, 49, 50, 57, 53, 124, 49, 48, 56, 57, 51, 54, 55, 53, 46, 54, 49, 10, 49, 53, 53, 52, 52, 54, 124, 49, 48, 56, 53, 50, 55, 54, 52, 46, 53, 55, 10, 49, 53, 54, 51, 57, 49, 124, 49, 48, 56, 51, 57, 56, 49, 48, 46, 51, 56, 10, 52, 48, 56, 56, 52, 124, 49, 48, 56, 51, 55, 50, 51, 52, 46, 49, 57, 10, 49, 52, 49, 50, 56, 56, 124, 49, 48, 56, 51, 55, 49, 51, 48, 46, 50, 49, 10, 49, 53, 50, 51, 56, 56, 124, 49, 48, 56, 51, 48, 57, 55, 55, 46, 56, 50, 10, 51, 51, 52, 52, 57, 124, 49, 48, 56, 51, 48, 56, 53, 56, 46, 55, 50, 10, 49, 52, 57, 48, 51, 53, 124, 49, 48, 56, 50, 54, 49, 51, 48, 46, 48, 50, 10, 49, 54, 50, 54, 50, 48, 124, 49, 48, 56, 49, 52, 50, 55, 53, 46, 54, 56, 10, 49, 49, 56, 51, 50, 52, 124, 49, 48, 55, 57, 49, 55, 56, 56, 46, 49, 48, 10, 51, 56, 57, 51, 50, 124, 49, 48, 55, 55, 55, 53, 52, 49, 46, 55, 53, 10, 49, 50, 49, 50, 57, 52, 124, 49, 48, 55, 54, 52, 50, 50, 53, 46, 50, 50, 10, 52, 56, 55, 50, 49, 124, 49, 48, 55, 54, 50, 53, 56, 50, 46, 52, 57, 10, 54, 51, 51, 52, 50, 124, 49, 48, 55, 52, 48, 49, 51, 50, 46, 54, 48, 10, 53, 54, 49, 52, 124, 49, 48, 55, 50, 52, 54, 54, 56, 46, 56, 48, 10, 54, 50, 50, 54, 54, 124, 49, 48, 55, 49, 49, 49, 52, 51, 46, 49, 48, 10, 49, 48, 48, 50, 48, 50, 124, 49, 48, 54, 57, 54, 54, 55, 53, 46, 53, 53, 10, 49, 57, 55, 55, 52, 49, 124, 49, 48, 54, 56, 56, 53, 54, 48, 46, 55, 50, 10, 49, 54, 57, 49, 55, 56, 124, 49, 48, 54, 52, 56, 53, 50, 50, 46, 56, 48, 10, 53, 50, 55, 49, 124, 49, 48, 54, 51, 57, 51, 57, 50, 46, 54, 53, 10, 51, 52, 52, 57, 57, 124, 49, 48, 53, 56, 52, 49, 55, 55, 46, 49, 48, 10, 55, 49, 49, 48, 56, 124, 49, 48, 53, 54, 57, 49, 49, 55, 46, 53, 54, 10, 49, 51, 55, 49, 51, 50, 124, 49, 48, 53, 51, 57, 56, 56, 48, 46, 52, 55, 10, 55, 56, 52, 53, 49, 124, 49, 48, 53, 50, 52, 56, 55, 51, 46, 50, 52, 10, 49, 53, 48, 56, 50, 55, 124, 49, 48, 53, 48, 51, 56, 49, 48, 46, 52, 56, 10, 49, 48, 55, 50, 51, 55, 124, 49, 48, 52, 56, 56, 48, 51, 48, 46, 56, 52, 10, 49, 48, 49, 55, 50, 55, 124, 49, 48, 52, 55, 51, 53, 53, 56, 46, 49, 48, 10, 53, 56, 55, 48, 56, 124, 49, 48, 52, 54, 54, 50, 56, 48, 46, 52, 52, 10, 56, 57, 55, 54, 56, 124, 49, 48, 52, 54, 53, 52, 55, 55, 46, 50, 50, 10, 49, 52, 54, 52, 57, 51, 124, 49, 48, 52, 52, 52, 50, 57, 49, 46, 53, 56, 10, 53, 53, 52, 50, 52, 124, 49, 48, 52, 52, 52, 48, 48, 54, 46, 52, 56, 10, 49, 54, 53, 54, 48, 124, 49, 48, 52, 50, 53, 53, 55, 52, 46, 55, 52, 10, 49, 51, 51, 49, 49, 52, 124, 49, 48, 52, 49, 53, 48, 57, 55, 46, 57, 48, 10, 49, 57, 53, 56, 49, 48, 124, 49, 48, 52, 49, 51, 54, 50, 53, 46, 50, 48, 10, 55, 54, 54, 55, 51, 124, 49, 48, 51, 57, 49, 57, 55, 55, 46, 49, 56, 10, 57, 55, 51, 48, 53, 124, 49, 48, 51, 57, 48, 56, 57, 48, 46, 53, 55, 10, 49, 51, 52, 50, 49, 48, 124, 49, 48, 51, 56, 55, 50, 49, 48, 46, 48, 50, 10, 49, 56, 56, 53, 51, 54, 124, 49, 48, 51, 56, 54, 53, 50, 57, 46, 57, 50, 10, 49, 50, 50, 50, 53, 53, 124, 49, 48, 51, 51, 53, 55, 54, 48, 46, 51, 50, 10, 50, 54, 56, 50, 124, 49, 48, 51, 49, 50, 57, 54, 54, 46, 49, 48, 10, 52, 51, 56, 49, 52, 124, 49, 48, 51, 48, 51, 48, 56, 54, 46, 54, 49, 10, 51, 52, 55, 54, 55, 124, 49, 48, 50, 57, 48, 52, 48, 53, 46, 49, 56, 10, 49, 54, 53, 53, 56, 52, 124, 49, 48, 50, 55, 51, 55, 48, 53, 46, 56, 57, 10, 50, 50, 51, 49, 124, 49, 48, 50, 55, 48, 52, 49, 53, 46, 53, 53, 10, 49, 49, 49, 50, 53, 57, 124, 49, 48, 50, 54, 51, 50, 53, 54, 46, 53, 54, 10, 49, 57, 53, 53, 55, 56, 124, 49, 48, 50, 51, 57, 55, 57, 53, 46, 56, 50, 10, 50, 49, 48, 57, 51, 124, 49, 48, 50, 49, 55, 53, 51, 49, 46, 51, 48, 10, 50, 57, 56, 53, 54, 124, 49, 48, 50, 49, 54, 57, 51, 50, 46, 53, 52, 10, 49, 51, 51, 54, 56, 54, 124, 49, 48, 50, 49, 51, 51, 52, 53, 46, 55, 54, 10, 56, 55, 55, 52, 53, 124, 49, 48, 49, 56, 53, 53, 48, 57, 46, 52, 48, 10, 49, 51, 53, 49, 53, 51, 124, 49, 48, 49, 55, 57, 51, 55, 57, 46, 55, 48, 10, 49, 49, 55, 55, 51, 124, 49, 48, 49, 54, 55, 52, 49, 48, 46, 56, 52, 10, 55, 54, 51, 49, 54, 124, 49, 48, 49, 54, 53, 49, 53, 49, 46, 55, 48, 10, 49, 50, 51, 48, 55, 54, 124, 49, 48, 49, 54, 49, 50, 50, 53, 46, 55, 56, 10, 57, 49, 56, 57, 52, 124, 49, 48, 49, 51, 48, 52, 54, 50, 46, 49, 57, 10, 51, 57, 55, 52, 49, 124, 49, 48, 49, 50, 56, 51, 56, 55, 46, 53, 50, 10, 49, 49, 49, 55, 53, 51, 124, 49, 48, 49, 49, 57, 55, 56, 48, 46, 57, 56, 10, 49, 52, 50, 55, 50, 57, 124, 49, 48, 49, 48, 52, 55, 52, 56, 46, 56, 57, 10, 49, 49, 54, 55, 55, 53, 124, 49, 48, 48, 57, 55, 55, 53, 48, 46, 52, 50, 10, 49, 48, 50, 53, 56, 57, 124, 49, 48, 48, 51, 52, 55, 56, 52, 46, 51, 54, 10, 49, 56, 54, 50, 54, 56, 124, 49, 48, 48, 49, 50, 49, 56, 49, 46, 53, 55, 10, 52, 52, 53, 52, 53, 124, 49, 48, 48, 48, 48, 50, 56, 54, 46, 52, 56, 10, 50, 51, 51, 48, 55, 124, 57, 57, 54, 54, 53, 55, 55, 46, 53, 48, 10, 49, 50, 52, 50, 56, 49, 124, 57, 57, 51, 48, 48, 49, 56, 46, 57, 48, 10, 54, 57, 54, 48, 52, 124, 57, 57, 50, 53, 55, 51, 48, 46, 54, 52, 10, 50, 49, 57, 55, 49, 124, 57, 57, 48, 56, 57, 56, 50, 46, 48, 51, 10, 53, 56, 49, 52, 56, 124, 57, 56, 57, 53, 56, 57, 52, 46, 52, 48, 10, 49, 54, 53, 51, 50, 124, 57, 56, 56, 54, 53, 50, 57, 46, 57, 48, 10, 49, 53, 57, 49, 56, 48, 124, 57, 56, 56, 51, 55, 52, 52, 46, 52, 51, 10, 55, 52, 55, 51, 51, 124, 57, 56, 55, 55, 53, 56, 50, 46, 56, 56, 10, 51, 53, 49, 55, 51, 124, 57, 56, 53, 56, 50, 55, 53, 46, 57, 50, 10, 55, 49, 49, 54, 124, 57, 56, 53, 54, 56, 56, 49, 46, 48, 50, 10, 49, 50, 52, 54, 50, 48, 124, 57, 56, 51, 56, 53, 56, 57, 46, 49, 52, 10, 49, 50, 50, 49, 48, 56, 124, 57, 56, 50, 57, 57, 52, 57, 46, 51, 53, 10, 54, 55, 50, 48, 48, 124, 57, 56, 50, 56, 54, 57, 48, 46, 54, 57, 10, 49, 54, 52, 55, 55, 53, 124, 57, 56, 50, 49, 52, 50, 52, 46, 52, 52, 10, 57, 48, 51, 57, 124, 57, 56, 49, 54, 52, 52, 55, 46, 55, 50, 10, 49, 52, 57, 49, 50, 124, 57, 56, 48, 51, 49, 48, 50, 46, 50, 48, 10, 49, 57, 48, 57, 48, 54, 124, 57, 55, 57, 49, 51, 49, 53, 46, 55, 48, 10, 49, 51, 48, 51, 57, 56, 124, 57, 55, 56, 49, 54, 55, 52, 46, 50, 55, 10, 49, 49, 57, 51, 49, 48, 124, 57, 55, 55, 54, 57, 50, 55, 46, 50, 49, 10, 49, 48, 49, 51, 50, 124, 57, 55, 55, 48, 57, 51, 48, 46, 55, 56, 10, 49, 48, 55, 50, 49, 49, 124, 57, 55, 53, 55, 53, 56, 54, 46, 50, 53, 10, 49, 49, 51, 57, 53, 56, 124, 57, 55, 53, 55, 48, 54, 53, 46, 53, 48, 10, 51, 55, 48, 48, 57, 124, 57, 55, 52, 56, 51, 54, 50, 46, 54, 57, 10, 54, 54, 55, 52, 54, 124, 57, 55, 52, 51, 53, 50, 56, 46, 55, 54, 10, 49, 51, 52, 52, 56, 54, 124, 57, 55, 51, 49, 57, 50, 50, 46, 48, 48, 10, 49, 53, 57, 52, 53, 124, 57, 55, 51, 49, 48, 57, 54, 46, 52, 53, 10, 53, 53, 51, 48, 55, 124, 57, 55, 49, 55, 55, 52, 53, 46, 56, 48, 10, 53, 54, 51, 54, 50, 124, 57, 55, 49, 52, 57, 50, 50, 46, 56, 51, 10, 53, 55, 55, 50, 54, 124, 57, 55, 49, 49, 55, 57, 50, 46, 49, 48, 10, 53, 55, 50, 53, 54, 124, 57, 55, 48, 56, 54, 50, 49, 46, 48, 48, 10, 49, 49, 50, 50, 57, 50, 124, 57, 55, 48, 49, 54, 53, 51, 46, 48, 56, 10, 56, 55, 53, 49, 52, 124, 57, 54, 57, 57, 52, 57, 50, 46, 53, 51, 10, 49, 55, 52, 50, 48, 54, 124, 57, 54, 56, 48, 53, 54, 50, 46, 48, 50, 10, 55, 50, 56, 54, 53, 124, 57, 54, 55, 57, 48, 52, 51, 46, 51, 52, 10, 49, 49, 52, 51, 53, 55, 124, 57, 54, 55, 49, 48, 49, 55, 46, 52, 52, 10, 49, 49, 50, 56, 48, 55, 124, 57, 54, 54, 53, 48, 49, 57, 46, 50, 49, 10, 49, 49, 53, 50, 48, 51, 124, 57, 54, 54, 49, 48, 49, 56, 46, 55, 51, 10, 49, 55, 55, 52, 53, 52, 124, 57, 54, 53, 56, 57, 48, 54, 46, 51, 53, 10, 49, 54, 49, 50, 55, 53, 124, 57, 54, 51, 52, 51, 49, 51, 46, 55, 49, 10, 54, 49, 56, 57, 51, 124, 57, 54, 49, 55, 48, 57, 53, 46, 52, 52, 10, 49, 50, 50, 50, 49, 57, 124, 57, 54, 48, 52, 56, 56, 56, 46, 50, 48, 10, 49, 56, 51, 52, 50, 55, 124, 57, 54, 48, 49, 51, 54, 50, 46, 53, 56, 10, 53, 57, 49, 53, 56, 124, 57, 53, 57, 57, 55, 48, 53, 46, 57, 54, 10, 54, 49, 57, 51, 49, 124, 57, 53, 56, 52, 57, 49, 56, 46, 57, 56, 10, 53, 53, 51, 50, 124, 57, 53, 55, 57, 57, 54, 52, 46, 49, 52, 10, 50, 48, 49, 53, 56, 124, 57, 53, 55, 54, 55, 49, 52, 46, 51, 56, 10, 49, 54, 55, 49, 57, 57, 124, 57, 53, 53, 55, 52, 49, 51, 46, 48, 56, 10, 51, 56, 56, 54, 57, 124, 57, 53, 53, 48, 50, 55, 57, 46, 53, 51, 10, 56, 54, 57, 52, 57, 124, 57, 53, 52, 49, 57, 52, 51, 46, 55, 48, 10, 49, 57, 56, 53, 52, 52, 124, 57, 53, 51, 56, 54, 49, 51, 46, 57, 50, 10, 49, 57, 51, 55, 54, 50, 124, 57, 53, 51, 56, 50, 51, 56, 46, 57, 52, 10, 49, 48, 56, 56, 48, 55, 124, 57, 53, 51, 54, 50, 52, 55, 46, 49, 54, 10, 49, 54, 56, 51, 50, 52, 124, 57, 53, 51, 53, 54, 52, 55, 46, 57, 57, 10, 49, 49, 53, 53, 56, 56, 124, 57, 53, 51, 50, 49, 57, 53, 46, 48, 52, 10, 49, 52, 49, 51, 55, 50, 124, 57, 53, 50, 57, 55, 48, 50, 46, 49, 52, 10, 49, 55, 53, 49, 50, 48, 124, 57, 53, 50, 54, 48, 54, 56, 46, 54, 54, 10, 49, 54, 51, 56, 53, 49, 124, 57, 53, 50, 50, 56, 48, 56, 46, 56, 51, 10, 49, 54, 48, 57, 53, 52, 124, 57, 53, 50, 48, 51, 53, 57, 46, 52, 53, 10, 49, 49, 55, 55, 53, 55, 124, 57, 53, 49, 55, 56, 56, 50, 46, 56, 48, 10, 53, 50, 53, 57, 52, 124, 57, 53, 48, 56, 51, 50, 53, 46, 55, 54, 10, 54, 48, 57, 54, 48, 124, 57, 52, 57, 56, 56, 52, 51, 46, 48, 54, 10, 55, 48, 50, 55, 50, 124, 57, 52, 57, 53, 55, 55, 53, 46, 54, 50, 10, 52, 52, 48, 53, 48, 124, 57, 52, 57, 53, 53, 49, 53, 46, 51, 54, 10, 49, 53, 50, 50, 49, 51, 124, 57, 52, 57, 52, 55, 53, 54, 46, 57, 54, 10, 49, 50, 49, 50, 48, 51, 124, 57, 52, 57, 50, 54, 48, 49, 46, 51, 48, 10, 55, 48, 49, 49, 52, 124, 57, 52, 57, 49, 48, 49, 50, 46, 51, 48, 10, 49, 54, 55, 53, 56, 56, 124, 57, 52, 56, 52, 55, 52, 49, 46, 49, 49, 10, 49, 51, 54, 52, 53, 53, 124, 57, 52, 55, 54, 50, 52, 49, 46, 55, 56, 10, 52, 51, 53, 55, 124, 57, 52, 54, 52, 51, 53, 53, 46, 54, 52, 10, 54, 55, 56, 54, 124, 57, 52, 54, 51, 54, 51, 50, 46, 53, 55, 10, 54, 49, 51, 52, 53, 124, 57, 52, 53, 53, 51, 51, 54, 46, 55, 48, 10, 49, 54, 48, 56, 50, 54, 124, 57, 52, 52, 54, 55, 53, 52, 46, 56, 52, 10, 55, 49, 50, 55, 53, 124, 57, 52, 52, 48, 49, 51, 56, 46, 52, 48, 10, 55, 55, 55, 52, 54, 124, 57, 52, 51, 57, 49, 49, 56, 46, 51, 53, 10, 57, 49, 50, 56, 57, 124, 57, 52, 51, 55, 52, 55, 50, 46, 48, 48, 10, 53, 54, 55, 50, 51, 124, 57, 52, 51, 53, 49, 48, 50, 46, 49, 54, 10, 56, 54, 54, 52, 55, 124, 57, 52, 51, 52, 54, 48, 52, 46, 49, 56, 10, 49, 51, 49, 50, 51, 52, 124, 57, 52, 51, 50, 49, 50, 48, 46, 48, 48, 10, 49, 57, 56, 49, 50, 57, 124, 57, 52, 50, 55, 54, 53, 49, 46, 51, 54, 10, 49, 54, 53, 53, 51, 48, 124, 57, 52, 50, 54, 49, 57, 51, 46, 54, 56, 10, 54, 57, 50, 51, 51, 124, 57, 52, 50, 53, 48, 53, 51, 46, 57, 50, 10, 54, 50, 52, 51, 124, 57, 52, 50, 51, 51, 48, 52, 46, 54, 54, 10, 57, 48, 49, 49, 48, 124, 57, 52, 50, 48, 52, 50, 50, 46, 55, 48, 10, 49, 57, 49, 57, 56, 48, 124, 57, 52, 49, 57, 51, 54, 56, 46, 51, 54, 10, 51, 56, 52, 54, 49, 124, 57, 52, 49, 57, 51, 49, 54, 46, 48, 55, 10, 49, 54, 55, 56, 55, 51, 124, 57, 52, 49, 57, 48, 50, 52, 46, 52, 57, 10, 49, 53, 57, 51, 55, 51, 124, 57, 52, 49, 54, 57, 53, 48, 46, 49, 53, 10, 49, 50, 56, 55, 48, 55, 124, 57, 52, 49, 51, 52, 50, 56, 46, 53, 48, 10, 52, 53, 50, 54, 55, 124, 57, 52, 49, 48, 56, 54, 51, 46, 55, 56, 10, 52, 56, 52, 54, 48, 124, 57, 52, 48, 57, 55, 57, 51, 46, 57, 51, 10, 49, 57, 55, 54, 55, 50, 124, 57, 52, 48, 54, 56, 56, 55, 46, 54, 56, 10, 54, 48, 56, 56, 52, 124, 57, 52, 48, 51, 52, 52, 50, 46, 52, 48, 10, 49, 53, 50, 48, 57, 124, 57, 52, 48, 51, 50, 52, 53, 46, 51, 49, 10, 49, 51, 56, 48, 52, 57, 124, 57, 52, 48, 49, 50, 54, 50, 46, 49, 48, 10, 49, 57, 57, 50, 56, 54, 124, 57, 51, 57, 49, 55, 55, 48, 46, 55, 48, 10, 49, 57, 54, 50, 57, 124, 57, 51, 57, 49, 50, 51, 54, 46, 52, 48, 10, 49, 51, 52, 48, 49, 57, 124, 57, 51, 57, 48, 54, 49, 53, 46, 49, 53, 10, 49, 54, 57, 52, 55, 53, 124, 57, 51, 56, 55, 54, 51, 57, 46, 53, 56, 10, 49, 54, 53, 57, 49, 56, 124, 57, 51, 55, 57, 53, 49, 48, 46, 52, 52, 10, 49, 51, 53, 54, 48, 50, 124, 57, 51, 55, 52, 50, 53, 49, 46, 53, 52, 10, 49, 54, 50, 51, 50, 51, 124, 57, 51, 54, 55, 53, 54, 54, 46, 53, 49, 10, 57, 54, 50, 55, 55, 124, 57, 51, 54, 48, 56, 53, 48, 46, 54, 56, 10, 57, 56, 51, 51, 54, 124, 57, 51, 53, 57, 54, 55, 49, 46, 50, 57, 10, 49, 49, 57, 55, 56, 49, 124, 57, 51, 53, 54, 51, 57, 53, 46, 55, 51, 10, 51, 52, 52, 52, 48, 124, 57, 51, 53, 53, 51, 54, 53, 46, 48, 48, 10, 53, 55, 51, 54, 50, 124, 57, 51, 53, 53, 49, 56, 48, 46, 49, 48, 10, 49, 54, 55, 50, 51, 54, 124, 57, 51, 53, 50, 57, 55, 51, 46, 56, 52, 10, 51, 56, 52, 54, 51, 124, 57, 51, 52, 55, 53, 51, 48, 46, 57, 52, 10, 56, 54, 55, 52, 57, 124, 57, 51, 52, 54, 56, 50, 54, 46, 52, 52, 10, 49, 55, 48, 48, 48, 55, 124, 57, 51, 52, 53, 54, 57, 57, 46, 57, 48, 10, 49, 57, 51, 48, 56, 55, 124, 57, 51, 52, 51, 55, 52, 52, 46, 48, 48, 10, 49, 53, 48, 51, 56, 51, 124, 57, 51, 51, 50, 53, 55, 54, 46, 55, 53, 10, 54, 48, 57, 51, 50, 124, 57, 51, 50, 57, 53, 56, 50, 46, 48, 50, 10, 49, 50, 56, 52, 50, 48, 124, 57, 51, 50, 56, 50, 48, 54, 46, 51, 53, 10, 49, 54, 50, 49, 52, 53, 124, 57, 51, 50, 55, 55, 50, 50, 46, 56, 56, 10, 53, 53, 54, 56, 54, 124, 57, 51, 50, 48, 51, 48, 52, 46, 52, 48, 10, 49, 54, 51, 48, 56, 48, 124, 57, 51, 48, 52, 57, 49, 54, 46, 57, 54, 10, 49, 54, 48, 53, 56, 51, 124, 57, 51, 48, 51, 53, 49, 53, 46, 57, 50, 10, 49, 49, 56, 49, 53, 51, 124, 57, 50, 57, 56, 54, 48, 54, 46, 53, 54, 10, 49, 53, 50, 54, 51, 52, 124, 57, 50, 56, 50, 49, 56, 52, 46, 53, 55, 10, 56, 52, 55, 51, 49, 124, 57, 50, 55, 54, 53, 56, 54, 46, 57, 50, 10, 49, 49, 57, 57, 56, 57, 124, 57, 50, 55, 51, 56, 49, 52, 46, 50, 48, 10, 49, 49, 52, 53, 56, 52, 124, 57, 50, 54, 57, 54, 57, 56, 46, 54, 53, 10, 49, 51, 49, 56, 49, 55, 124, 57, 50, 54, 56, 53, 55, 48, 46, 48, 56, 10, 50, 57, 48, 54, 56, 124, 57, 50, 53, 54, 53, 56, 51, 46, 56, 56, 10, 52, 52, 49, 49, 54, 124, 57, 50, 53, 53, 57, 50, 50, 46, 48, 48, 10, 49, 49, 53, 56, 49, 56, 124, 57, 50, 53, 51, 51, 49, 49, 46, 57, 49, 10, 49, 48, 51, 51, 56, 56, 124, 57, 50, 51, 57, 50, 49, 56, 46, 48, 56, 10, 49, 56, 54, 49, 49, 56, 124, 57, 50, 51, 54, 50, 48, 57, 46, 49, 50, 10, 49, 53, 53, 56, 48, 57, 124, 57, 50, 51, 53, 52, 49, 48, 46, 56, 52, 10, 49, 52, 55, 48, 48, 51, 124, 57, 50, 51, 52, 56, 52, 55, 46, 57, 57, 10, 50, 55, 55, 54, 57, 124, 57, 50, 51, 50, 53, 49, 49, 46, 54, 52, 10, 49, 49, 50, 55, 55, 57, 124, 57, 50, 51, 49, 57, 50, 55, 46, 51, 54, 10, 49, 50, 52, 56, 53, 49, 124, 57, 50, 50, 56, 57, 56, 50, 46, 54, 56, 10, 49, 53, 56, 52, 56, 56, 124, 57, 50, 50, 55, 50, 49, 54, 46, 52, 48, 10, 56, 51, 51, 50, 56, 124, 57, 50, 50, 52, 55, 57, 50, 46, 50, 48, 10, 49, 51, 54, 55, 57, 55, 124, 57, 50, 50, 50, 57, 50, 55, 46, 48, 57, 10, 49, 52, 49, 55, 51, 48, 124, 57, 50, 49, 54, 51, 55, 48, 46, 54, 56, 10, 56, 55, 51, 48, 52, 124, 57, 50, 49, 53, 54, 57, 53, 46, 53, 48, 10, 49, 53, 54, 48, 48, 52, 124, 57, 50, 49, 53, 53, 53, 55, 46, 57, 48, 10, 49, 52, 48, 55, 52, 48, 124, 57, 50, 49, 53, 51, 50, 57, 46, 50, 48, 10, 49, 48, 48, 54, 52, 56, 124, 57, 50, 49, 50, 49, 56, 53, 46, 48, 56, 10, 49, 55, 52, 55, 55, 52, 124, 57, 50, 49, 49, 55, 49, 56, 46, 48, 48, 10, 51, 55, 54, 52, 52, 124, 57, 50, 49, 49, 53, 55, 56, 46, 54, 48, 10, 52, 56, 56, 48, 55, 124, 57, 50, 48, 57, 52, 57, 54, 46, 50, 52, 10, 57, 53, 57, 52, 48, 124, 57, 50, 48, 55, 57, 52, 56, 46, 52, 48, 10, 49, 52, 49, 53, 56, 54, 124, 57, 50, 48, 54, 54, 57, 57, 46, 50, 50, 10, 49, 52, 55, 50, 52, 56, 124, 57, 50, 48, 53, 54, 53, 52, 46, 57, 53, 10, 54, 49, 51, 55, 50, 124, 57, 50, 48, 53, 50, 50, 56, 46, 55, 54, 10, 53, 50, 57, 55, 48, 124, 57, 50, 48, 52, 52, 49, 53, 46, 57, 53, 10, 50, 54, 52, 51, 48, 124, 57, 50, 48, 51, 55, 49, 48, 46, 53, 49, 10, 50, 56, 53, 48, 52, 124, 57, 50, 48, 49, 54, 54, 57, 46, 50, 48, 10, 50, 53, 56, 49, 48, 124, 57, 49, 57, 56, 56, 55, 56, 46, 53, 48, 10, 49, 50, 53, 51, 50, 57, 124, 57, 49, 57, 56, 54, 56, 56, 46, 53, 48, 10, 49, 54, 55, 56, 54, 55, 124, 57, 49, 57, 52, 48, 50, 50, 46, 55, 50, 10, 49, 51, 52, 55, 54, 55, 124, 57, 49, 57, 49, 52, 52, 52, 46, 55, 50, 10, 49, 50, 55, 55, 52, 53, 124, 57, 49, 57, 49, 50, 55, 49, 46, 53, 54, 10, 54, 57, 50, 48, 56, 124, 57, 49, 56, 55, 49, 49, 48, 46, 48, 48, 10, 49, 53, 53, 50, 50, 50, 124, 57, 49, 56, 54, 52, 54, 57, 46, 49, 54, 10, 49, 57, 54, 57, 49, 54, 124, 57, 49, 56, 50, 57, 57, 53, 46, 56, 50, 10, 49, 57, 53, 53, 57, 48, 124, 57, 49, 55, 54, 51, 53, 51, 46, 49, 50, 10, 49, 54, 57, 49, 53, 53, 124, 57, 49, 55, 53, 49, 55, 54, 46, 48, 57, 10, 56, 49, 53, 53, 56, 124, 57, 49, 55, 49, 57, 52, 54, 46, 53, 48, 10, 49, 56, 53, 49, 51, 54, 124, 57, 49, 55, 49, 50, 57, 51, 46, 48, 52, 10, 49, 49, 52, 55, 57, 48, 124, 57, 49, 54, 56, 53, 48, 57, 46, 49, 48, 10, 49, 57, 52, 49, 52, 50, 124, 57, 49, 54, 53, 56, 51, 54, 46, 54, 49, 10, 49, 54, 55, 54, 51, 57, 124, 57, 49, 54, 49, 49, 54, 53, 46, 48, 48, 10, 49, 49, 50, 52, 49, 124, 57, 49, 54, 48, 55, 56, 57, 46, 52, 54, 10, 56, 50, 54, 50, 56, 124, 57, 49, 54, 48, 49, 53, 53, 46, 53, 52, 10, 52, 49, 51, 57, 57, 124, 57, 49, 52, 56, 51, 51, 56, 46, 48, 48, 10, 51, 48, 55, 53, 53, 124, 57, 49, 52, 54, 49, 57, 54, 46, 56, 52, 10, 54, 57, 52, 52, 124, 57, 49, 52, 51, 53, 55, 52, 46, 53, 56, 10, 54, 51, 50, 54, 124, 57, 49, 51, 56, 56, 48, 51, 46, 49, 54, 10, 49, 48, 49, 50, 57, 54, 124, 57, 49, 51, 53, 54, 53, 55, 46, 54, 50, 10, 49, 56, 49, 52, 55, 57, 124, 57, 49, 50, 49, 48, 57, 51, 46, 51, 48, 10, 55, 54, 56, 57, 56, 124, 57, 49, 50, 48, 57, 56, 51, 46, 49, 48, 10, 54, 52, 50, 55, 52, 124, 57, 49, 49, 56, 55, 52, 53, 46, 50, 53, 10, 49, 55, 53, 56, 50, 54, 124, 57, 49, 49, 55, 51, 56, 55, 46, 57, 57, 10, 49, 52, 50, 50, 49, 53, 124, 57, 49, 49, 54, 56, 55, 54, 46, 56, 56, 10, 49, 48, 51, 52, 49, 53, 124, 57, 49, 49, 51, 49, 50, 56, 46, 54, 50, 10, 49, 49, 57, 55, 54, 53, 124, 57, 49, 49, 48, 55, 54, 56, 46, 55, 57, 10, 49, 48, 55, 54, 50, 52, 124, 57, 49, 48, 56, 56, 51, 55, 46, 52, 53, 10, 56, 52, 50, 49, 53, 124, 57, 49, 48, 53, 50, 53, 55, 46, 51, 54, 10, 55, 51, 55, 55, 52, 124, 57, 49, 48, 50, 54, 53, 49, 46, 57, 50, 10, 49, 55, 51, 57, 55, 50, 124, 57, 49, 48, 50, 48, 54, 57, 46, 48, 48, 10, 54, 57, 56, 49, 55, 124, 57, 48, 57, 53, 53, 49, 51, 46, 56, 56, 10, 56, 54, 57, 52, 51, 124, 57, 48, 57, 50, 50, 53, 51, 46, 48, 48, 10, 49, 51, 56, 56, 53, 57, 124, 57, 48, 56, 55, 55, 49, 57, 46, 51, 48, 10, 49, 54, 50, 50, 55, 51, 124, 57, 48, 56, 53, 50, 57, 54, 46, 52, 56, 10, 49, 55, 53, 57, 52, 53, 124, 57, 48, 56, 48, 52, 48, 49, 46, 50, 49, 10, 49, 54, 56, 51, 54, 124, 57, 48, 55, 53, 55, 49, 53, 46, 52, 52, 10, 55, 48, 50, 50, 52, 124, 57, 48, 55, 53, 50, 54, 53, 46, 57, 53, 10, 49, 51, 57, 55, 54, 53, 124, 57, 48, 55, 52, 55, 53, 53, 46, 56, 57, 10, 51, 48, 51, 49, 57, 124, 57, 48, 55, 51, 50, 51, 51, 46, 49, 48, 10, 51, 56, 53, 49, 124, 57, 48, 55, 50, 54, 53, 55, 46, 50, 52, 10, 49, 56, 49, 50, 55, 49, 124, 57, 48, 55, 48, 54, 51, 49, 46, 53, 50, 10, 49, 54, 50, 49, 56, 52, 124, 57, 48, 54, 56, 56, 51, 53, 46, 55, 56, 10, 56, 49, 54, 56, 51, 124, 57, 48, 54, 55, 50, 53, 56, 46, 52, 55, 10, 49, 53, 51, 48, 50, 56, 124, 57, 48, 54, 55, 48, 49, 48, 46, 53, 49, 10, 49, 50, 51, 51, 50, 52, 124, 57, 48, 54, 49, 56, 55, 48, 46, 57, 53, 10, 49, 56, 54, 52, 56, 49, 124, 57, 48, 53, 56, 54, 48, 56, 46, 51, 48, 10, 49, 54, 55, 54, 56, 48, 124, 57, 48, 53, 50, 57, 48, 56, 46, 55, 54, 10, 49, 54, 53, 50, 57, 51, 124, 57, 48, 53, 48, 53, 52, 53, 46, 55, 48, 10, 49, 50, 50, 49, 52, 56, 124, 57, 48, 52, 54, 50, 57, 56, 46, 49, 55, 10, 49, 51, 56, 54, 48, 52, 124, 57, 48, 52, 53, 56, 52, 48, 46, 56, 48, 10, 55, 56, 56, 53, 49, 124, 57, 48, 52, 52, 56, 50, 50, 46, 54, 48, 10, 49, 51, 55, 50, 56, 48, 124, 57, 48, 52, 50, 51, 53, 53, 46, 51, 52, 10, 56, 56, 50, 51, 124, 57, 48, 52, 48, 56, 53, 53, 46, 49, 48, 10, 49, 54, 51, 57, 48, 48, 124, 57, 48, 52, 48, 56, 52, 56, 46, 52, 56, 10, 55, 53, 54, 48, 48, 124, 57, 48, 51, 53, 51, 57, 50, 46, 52, 53, 10, 56, 49, 54, 55, 54, 124, 57, 48, 51, 49, 57, 57, 57, 46, 52, 48, 10, 52, 54, 48, 51, 51, 124, 57, 48, 51, 49, 52, 54, 48, 46, 53, 56, 10, 49, 57, 52, 57, 49, 55, 124, 57, 48, 50, 56, 53, 48, 48, 46, 48, 48, 10, 49, 51, 51, 57, 51, 54, 124, 57, 48, 50, 54, 57, 52, 57, 46, 48, 50, 10, 51, 51, 49, 56, 50, 124, 57, 48, 50, 52, 57, 55, 49, 46, 49, 48, 10, 51, 52, 50, 50, 48, 124, 57, 48, 50, 49, 52, 56, 53, 46, 51, 57, 10, 50, 48, 49, 49, 56, 124, 57, 48, 49, 57, 57, 52, 50, 46, 54, 48, 10, 49, 55, 56, 50, 53, 56, 124, 57, 48, 49, 57, 56, 56, 49, 46, 54, 54, 10, 49, 53, 53, 54, 48, 124, 57, 48, 49, 55, 54, 56, 55, 46, 50, 56, 10, 49, 49, 49, 52, 50, 53, 124, 57, 48, 49, 54, 49, 57, 56, 46, 53, 54, 10, 57, 53, 57, 52, 50, 124, 57, 48, 49, 53, 53, 56, 53, 46, 49, 50, 10, 49, 51, 50, 55, 48, 57, 124, 57, 48, 49, 53, 50, 52, 48, 46, 49, 53, 10, 51, 57, 55, 51, 49, 124, 57, 48, 49, 52, 55, 52, 54, 46, 57, 53, 10, 49, 53, 52, 51, 48, 55, 124, 57, 48, 49, 50, 53, 55, 49, 46, 50, 48, 10, 50, 51, 55, 54, 57, 124, 57, 48, 48, 56, 49, 53, 55, 46, 54, 48, 10, 57, 51, 51, 50, 56, 124, 57, 48, 48, 55, 50, 49, 49, 46, 50, 48, 10, 49, 52, 50, 56, 50, 54, 124, 56, 57, 57, 56, 50, 57, 55, 46, 52, 52, 10, 49, 56, 56, 55, 57, 50, 124, 56, 57, 57, 54, 48, 49, 52, 46, 48, 48, 10, 54, 56, 55, 48, 51, 124, 56, 57, 57, 52, 57, 56, 50, 46, 50, 50, 10, 49, 52, 53, 50, 56, 48, 124, 56, 57, 57, 48, 57, 52, 49, 46, 48, 53, 10, 49, 53, 48, 55, 50, 53, 124, 56, 57, 56, 53, 54, 56, 54, 46, 49, 54, 10, 49, 55, 50, 48, 52, 54, 124, 56, 57, 56, 50, 52, 54, 57, 46, 53, 50, 10, 55, 48, 52, 55, 54, 124, 56, 57, 54, 55, 54, 50, 57, 46, 53, 48, 10, 49, 50, 52, 57, 56, 56, 124, 56, 57, 54, 54, 56, 48, 53, 46, 50, 50, 10, 49, 55, 57, 51, 55, 124, 56, 57, 54, 51, 51, 49, 57, 46, 55, 54, 10, 49, 55, 55, 51, 55, 50, 124, 56, 57, 53, 52, 56, 55, 51, 46, 54, 52, 10, 49, 51, 55, 57, 57, 52, 124, 56, 57, 53, 48, 57, 49, 54, 46, 55, 57, 10, 56, 52, 48, 49, 57, 124, 56, 57, 53, 48, 48, 51, 57, 46, 57, 56, 10, 52, 48, 51, 56, 57, 124, 56, 57, 52, 54, 49, 53, 56, 46, 50, 48, 10, 54, 57, 49, 56, 55, 124, 56, 57, 52, 49, 48, 53, 52, 46, 49, 52, 10, 52, 56, 54, 51, 124, 56, 57, 51, 57, 48, 52, 52, 46, 57, 50, 10, 53, 48, 52, 54, 53, 124, 56, 57, 51, 48, 53, 48, 51, 46, 49, 52, 10, 52, 51, 54, 56, 54, 124, 56, 57, 49, 53, 53, 52, 51, 46, 56, 52, 10, 49, 51, 49, 51, 53, 50, 124, 56, 57, 48, 57, 48, 53, 51, 46, 53, 57, 10, 49, 57, 56, 57, 49, 54, 124, 56, 57, 48, 54, 57, 52, 48, 46, 48, 51, 10, 49, 51, 53, 57, 51, 50, 124, 56, 57, 48, 53, 50, 56, 50, 46, 57, 53, 10, 49, 48, 52, 54, 55, 51, 124, 56, 57, 48, 51, 54, 56, 50, 46, 48, 48, 10, 49, 53, 50, 51, 48, 56, 124, 56, 57, 48, 51, 50, 52, 52, 46, 48, 56, 10, 49, 51, 53, 50, 57, 56, 124, 56, 57, 48, 48, 51, 50, 51, 46, 50, 48, 10, 49, 53, 54, 56, 55, 51, 124, 56, 56, 57, 57, 52, 50, 57, 46, 49, 48, 10, 49, 53, 55, 52, 53, 52, 124, 56, 56, 57, 55, 51, 51, 57, 46, 50, 48, 10, 55, 53, 52, 49, 53, 124, 56, 56, 57, 55, 48, 54, 56, 46, 48, 57, 10, 52, 54, 51, 50, 53, 124, 56, 56, 57, 53, 53, 54, 57, 46, 48, 57, 10, 49, 57, 54, 54, 124, 56, 56, 57, 53, 49, 49, 55, 46, 48, 54, 10, 50, 52, 53, 55, 54, 124, 56, 56, 57, 53, 48, 51, 52, 46, 55, 53, 10, 49, 57, 52, 50, 53, 124, 56, 56, 57, 48, 49, 53, 54, 46, 54, 48, 10, 49, 54, 57, 55, 51, 53, 124, 56, 56, 57, 48, 48, 56, 53, 46, 53, 54, 10, 51, 50, 50, 50, 53, 124, 56, 56, 56, 57, 56, 50, 57, 46, 50, 56, 10, 49, 50, 52, 53, 51, 55, 124, 56, 56, 56, 57, 55, 55, 48, 46, 55, 49, 10, 49, 52, 54, 51, 50, 55, 124, 56, 56, 56, 55, 56, 51, 54, 46, 50, 51, 10, 49, 50, 49, 53, 54, 50, 124, 56, 56, 56, 55, 55, 52, 48, 46, 52, 48, 10, 52, 52, 55, 51, 49, 124, 56, 56, 56, 50, 52, 52, 52, 46, 57, 53, 10, 57, 51, 49, 52, 49, 124, 56, 56, 56, 49, 56, 53, 48, 46, 56, 56, 10, 49, 56, 55, 56, 55, 49, 124, 56, 56, 55, 51, 53, 48, 54, 46, 49, 56, 10, 55, 49, 55, 48, 57, 124, 56, 56, 55, 51, 48, 53, 55, 46, 50, 56, 10, 49, 53, 49, 57, 49, 51, 124, 56, 56, 54, 57, 51, 50, 49, 46, 49, 55, 10, 51, 51, 55, 56, 54, 124, 56, 56, 54, 56, 57, 53, 53, 46, 51, 57, 10, 51, 53, 57, 48, 50, 124, 56, 56, 54, 56, 49, 50, 54, 46, 48, 54, 10, 50, 51, 53, 56, 56, 124, 56, 56, 54, 55, 55, 54, 57, 46, 57, 48, 10, 50, 52, 53, 48, 56, 124, 56, 56, 54, 55, 54, 49, 54, 46, 48, 48, 10, 49, 54, 49, 50, 56, 50, 124, 56, 56, 54, 54, 54, 54, 49, 46, 52, 51, 10, 49, 56, 56, 48, 54, 49, 124, 56, 56, 54, 50, 51, 48, 52, 46, 48, 48, 10, 49, 51, 50, 56, 52, 55, 124, 56, 56, 54, 50, 48, 56, 50, 46, 48, 48, 10, 49, 54, 54, 56, 52, 51, 124, 56, 56, 54, 49, 50, 48, 48, 46, 56, 48, 10, 51, 48, 54, 48, 57, 124, 56, 56, 54, 48, 50, 49, 52, 46, 55, 51, 10, 53, 54, 49, 57, 49, 124, 56, 56, 53, 54, 53, 52, 54, 46, 57, 54, 10, 49, 54, 48, 55, 52, 48, 124, 56, 56, 53, 50, 54, 56, 53, 46, 52, 51, 10, 55, 49, 50, 50, 57, 124, 56, 56, 52, 54, 49, 48, 54, 46, 57, 57, 10, 57, 49, 50, 48, 56, 124, 56, 56, 52, 53, 53, 52, 49, 46, 50, 56, 10, 49, 48, 57, 57, 53, 124, 56, 56, 52, 53, 51, 48, 54, 46, 53, 54, 10, 55, 56, 48, 57, 52, 124, 56, 56, 51, 57, 57, 51, 56, 46, 50, 57, 10, 51, 54, 52, 56, 57, 124, 56, 56, 51, 56, 53, 51, 56, 46, 49, 48, 10, 49, 57, 56, 52, 51, 55, 124, 56, 56, 51, 54, 52, 57, 52, 46, 56, 52, 10, 49, 53, 49, 54, 57, 51, 124, 56, 56, 51, 51, 56, 48, 55, 46, 54, 52, 10, 49, 56, 53, 51, 54, 55, 124, 56, 56, 50, 57, 55, 57, 49, 46, 51, 55, 10, 54, 53, 54, 56, 50, 124, 56, 56, 50, 48, 54, 50, 50, 46, 56, 57, 10, 54, 53, 52, 50, 49, 124, 56, 56, 49, 57, 51, 50, 57, 46, 50, 52, 10, 49, 50, 50, 50, 50, 53, 124, 56, 56, 49, 54, 56, 50, 49, 46, 56, 54, 10, 56, 53, 51, 51, 48, 124, 56, 56, 49, 49, 48, 49, 51, 46, 49, 54, 10, 54, 52, 53, 53, 53, 124, 56, 56, 49, 48, 54, 52, 51, 46, 49, 50, 10, 49, 48, 52, 49, 56, 56, 124, 56, 56, 48, 56, 50, 49, 49, 46, 48, 50, 10, 53, 52, 52, 49, 49, 124, 56, 56, 48, 53, 55, 48, 51, 46, 52, 48, 10, 51, 57, 52, 51, 56, 124, 56, 56, 48, 53, 50, 56, 50, 46, 53, 54, 10, 55, 48, 55, 57, 53, 124, 56, 56, 48, 48, 48, 54, 48, 46, 57, 50, 10, 50, 48, 51, 56, 51, 124, 56, 55, 57, 57, 48, 55, 51, 46, 50, 56, 10, 50, 49, 57, 53, 50, 124, 56, 55, 57, 56, 54, 50, 52, 46, 49, 57, 10, 54, 51, 53, 56, 52, 124, 56, 55, 57, 54, 53, 57, 48, 46, 48, 48, 10, 49, 53, 56, 55, 54, 56, 124, 56, 55, 57, 54, 52, 50, 50, 46, 57, 53, 10, 49, 54, 54, 53, 56, 56, 124, 56, 55, 57, 54, 50, 49, 52, 46, 51, 56, 10, 49, 50, 48, 54, 48, 48, 124, 56, 55, 57, 51, 53, 53, 56, 46, 48, 54, 10, 49, 53, 55, 50, 48, 50, 124, 56, 55, 56, 56, 50, 56, 55, 46, 56, 56, 10, 53, 53, 51, 53, 56, 124, 56, 55, 56, 54, 56, 50, 48, 46, 55, 53, 10, 49, 54, 56, 51, 50, 50, 124, 56, 55, 56, 54, 54, 55, 48, 46, 55, 51, 10, 50, 53, 49, 52, 51, 124, 56, 55, 56, 54, 51, 50, 52, 46, 56, 48, 10, 53, 51, 54, 56, 124, 56, 55, 56, 54, 50, 55, 52, 46, 49, 52, 10, 49, 49, 52, 48, 50, 53, 124, 56, 55, 56, 54, 50, 48, 49, 46, 49, 50, 10, 57, 55, 55, 52, 52, 124, 56, 55, 56, 53, 51, 49, 53, 46, 57, 52, 10, 49, 54, 52, 51, 50, 55, 124, 56, 55, 56, 52, 53, 48, 51, 46, 56, 54, 10, 55, 54, 53, 52, 50, 124, 56, 55, 56, 50, 54, 49, 51, 46, 50, 56, 10, 52, 55, 51, 49, 124, 56, 55, 55, 50, 56, 52, 54, 46, 55, 48, 10, 49, 53, 55, 53, 57, 48, 124, 56, 55, 55, 50, 48, 48, 54, 46, 52, 53, 10, 49, 53, 52, 50, 55, 54, 124, 56, 55, 55, 49, 55, 51, 51, 46, 57, 49, 10, 50, 56, 55, 48, 53, 124, 56, 55, 55, 49, 53, 55, 54, 46, 54, 52, 10, 49, 48, 48, 50, 50, 54, 124, 56, 55, 54, 57, 52, 53, 53, 46, 48, 48, 10, 49, 55, 57, 49, 57, 53, 124, 56, 55, 54, 57, 49, 56, 53, 46, 49, 54, 10, 49, 56, 52, 51, 53, 53, 124, 56, 55, 54, 56, 49, 49, 56, 46, 48, 53, 10, 49, 50, 48, 52, 48, 56, 124, 56, 55, 54, 56, 48, 49, 49, 46, 49, 50, 10, 54, 51, 49, 52, 53, 124, 56, 55, 54, 49, 57, 57, 49, 46, 57, 54, 10, 53, 51, 49, 51, 53, 124, 56, 55, 53, 51, 52, 57, 49, 46, 56, 48, 10, 49, 55, 51, 48, 55, 49, 124, 56, 55, 53, 48, 53, 48, 56, 46, 56, 48, 10, 52, 49, 48, 56, 55, 124, 56, 55, 52, 57, 52, 51, 54, 46, 55, 57, 10, 49, 57, 52, 56, 51, 48, 124, 56, 55, 52, 55, 52, 51, 56, 46, 52, 48, 10, 52, 51, 52, 57, 54, 124, 56, 55, 52, 51, 51, 53, 57, 46, 51, 48, 10, 51, 48, 50, 51, 53, 124, 56, 55, 52, 49, 54, 49, 49, 46, 48, 48, 10, 50, 54, 51, 57, 49, 124, 56, 55, 52, 49, 51, 57, 57, 46, 54, 52, 10, 49, 57, 49, 56, 49, 54, 124, 56, 55, 52, 48, 50, 53, 56, 46, 55, 50, 10, 52, 55, 54, 49, 54, 124, 56, 55, 51, 55, 50, 50, 57, 46, 54, 56, 10, 49, 53, 50, 49, 48, 49, 124, 56, 55, 51, 52, 52, 51, 50, 46, 55, 54, 10, 49, 54, 51, 55, 56, 52, 124, 56, 55, 51, 48, 53, 49, 52, 46, 51, 52, 10, 53, 49, 51, 52, 124, 56, 55, 50, 56, 52, 50, 52, 46, 54, 52, 10, 49, 53, 53, 50, 52, 49, 124, 56, 55, 50, 53, 52, 50, 57, 46, 56, 54, 10, 49, 56, 56, 56, 49, 52, 124, 56, 55, 50, 52, 49, 56, 50, 46, 52, 48, 10, 49, 52, 48, 55, 56, 50, 124, 56, 55, 50, 48, 51, 55, 56, 46, 55, 53, 10, 49, 53, 51, 49, 52, 49, 124, 56, 55, 49, 57, 52, 48, 55, 46, 53, 49, 10, 49, 54, 57, 51, 55, 51, 124, 56, 55, 49, 56, 54, 48, 57, 46, 48, 54, 10, 52, 49, 51, 51, 53, 124, 56, 55, 49, 52, 55, 55, 51, 46, 56, 48, 10, 49, 57, 55, 52, 53, 48, 124, 56, 55, 49, 52, 54, 49, 55, 46, 51, 50, 10, 56, 55, 48, 48, 52, 124, 56, 55, 49, 52, 48, 49, 55, 46, 55, 57, 10, 49, 56, 49, 56, 48, 52, 124, 56, 55, 49, 50, 50, 53, 55, 46, 55, 54, 10, 49, 50, 50, 56, 49, 52, 124, 56, 55, 49, 49, 49, 49, 57, 46, 49, 52, 10, 49, 48, 57, 57, 51, 57, 124, 56, 55, 48, 57, 49, 57, 51, 46, 49, 54, 10, 57, 56, 48, 57, 52, 124, 56, 55, 48, 56, 55, 56, 48, 46, 48, 52, 10, 55, 52, 54, 51, 48, 124, 56, 55, 48, 56, 48, 52, 48, 46, 55, 53, 10, 49, 57, 55, 50, 57, 49, 124, 56, 55, 48, 54, 53, 49, 57, 46, 48, 57, 10, 49, 56, 52, 49, 55, 51, 124, 56, 55, 48, 53, 52, 54, 55, 46, 52, 53, 10, 49, 57, 50, 49, 55, 53, 124, 56, 55, 48, 53, 52, 49, 49, 46, 49, 50, 10, 49, 57, 52, 55, 49, 124, 56, 55, 48, 50, 53, 51, 54, 46, 49, 50, 10, 49, 56, 48, 53, 50, 124, 56, 55, 48, 50, 49, 53, 53, 46, 55, 48, 10, 49, 51, 53, 53, 54, 48, 124, 56, 54, 57, 56, 49, 51, 55, 46, 55, 50, 10, 49, 53, 50, 55, 57, 49, 124, 56, 54, 57, 55, 51, 50, 53, 46, 56, 48, 10, 49, 55, 48, 57, 53, 51, 124, 56, 54, 57, 54, 57, 48, 57, 46, 49, 57, 10, 49, 49, 54, 49, 51, 55, 124, 56, 54, 57, 54, 54, 56, 55, 46, 49, 55, 10, 55, 55, 50, 50, 124, 56, 54, 57, 54, 53, 56, 57, 46, 52, 48, 10, 52, 57, 55, 56, 56, 124, 56, 54, 57, 52, 56, 52, 54, 46, 55, 49, 10, 49, 51, 50, 53, 50, 124, 56, 54, 57, 52, 56, 50, 50, 46, 52, 50, 10, 49, 50, 54, 51, 51, 124, 56, 54, 57, 52, 53, 53, 57, 46, 51, 54, 10, 49, 57, 51, 52, 51, 56, 124, 56, 54, 57, 48, 52, 50, 54, 46, 55, 50, 10, 49, 55, 51, 50, 54, 124, 56, 54, 56, 57, 51, 50, 57, 46, 49, 54, 10, 57, 54, 49, 50, 52, 124, 56, 54, 55, 57, 55, 57, 52, 46, 53, 56, 10, 49, 52, 51, 56, 48, 50, 124, 56, 54, 55, 54, 54, 50, 54, 46, 52, 56, 10, 51, 48, 51, 56, 57, 124, 56, 54, 55, 53, 56, 50, 54, 46, 54, 48, 10, 55, 53, 50, 53, 48, 124, 56, 54, 55, 53, 50, 53, 55, 46, 49, 52, 10, 55, 50, 54, 49, 51, 124, 56, 54, 55, 51, 53, 50, 52, 46, 57, 52, 10, 49, 50, 51, 53, 50, 48, 124, 56, 54, 55, 50, 52, 53, 54, 46, 50, 53, 10, 51, 50, 53, 124, 56, 54, 54, 55, 55, 52, 49, 46, 50, 56, 10, 49, 54, 55, 50, 57, 49, 124, 56, 54, 54, 55, 53, 53, 54, 46, 49, 56, 10, 49, 53, 48, 49, 49, 57, 124, 56, 54, 54, 51, 52, 48, 51, 46, 53, 52, 10, 56, 56, 52, 50, 48, 124, 56, 54, 54, 51, 51, 53, 53, 46, 52, 48, 10, 49, 55, 57, 55, 56, 52, 124, 56, 54, 53, 51, 48, 50, 49, 46, 51, 52, 10, 49, 51, 48, 56, 56, 52, 124, 56, 54, 53, 49, 57, 55, 48, 46, 48, 48, 10, 49, 55, 50, 54, 49, 49, 124, 56, 54, 52, 56, 50, 49, 55, 46, 48, 48, 10, 56, 53, 51, 55, 51, 124, 56, 54, 52, 55, 55, 57, 54, 46, 50, 50, 10, 49, 50, 50, 55, 49, 55, 124, 56, 54, 52, 54, 55, 53, 56, 46, 53, 52, 10, 49, 49, 51, 52, 51, 49, 124, 56, 54, 52, 54, 51, 52, 56, 46, 51, 52, 10, 54, 54, 48, 49, 53, 124, 56, 54, 52, 51, 51, 52, 57, 46, 52, 48, 10, 51, 51, 49, 52, 49, 124, 56, 54, 52, 51, 50, 52, 51, 46, 49, 56, 10, 54, 57, 55, 56, 54, 124, 56, 54, 51, 55, 51, 57, 54, 46, 57, 50, 10, 49, 56, 49, 56, 53, 55, 124, 56, 54, 51, 55, 51, 57, 51, 46, 50, 56, 10, 49, 50, 50, 57, 51, 57, 124, 56, 54, 51, 54, 51, 55, 56, 46, 48, 48, 10, 49, 57, 54, 50, 50, 51, 124, 56, 54, 51, 53, 51, 57, 49, 46, 48, 50, 10, 53, 48, 53, 51, 50, 124, 56, 54, 51, 50, 54, 52, 56, 46, 50, 52, 10, 53, 56, 49, 48, 50, 124, 56, 54, 51, 50, 54, 49, 52, 46, 53, 52, 10, 57, 51, 53, 56, 49, 124, 56, 54, 51, 50, 51, 55, 50, 46, 51, 54, 10, 53, 50, 56, 48, 52, 124, 56, 54, 51, 50, 49, 48, 57, 46, 50, 53, 10, 55, 53, 53, 124, 56, 54, 50, 55, 48, 57, 49, 46, 54, 56, 10, 49, 54, 53, 57, 55, 124, 56, 54, 50, 51, 51, 53, 55, 46, 48, 53, 10, 49, 49, 57, 48, 52, 49, 124, 56, 54, 50, 50, 51, 57, 55, 46, 48, 48, 10, 56, 57, 48, 53, 48, 124, 56, 54, 50, 49, 49, 56, 53, 46, 57, 56, 10, 57, 56, 54, 57, 54, 124, 56, 54, 50, 48, 55, 56, 52, 46, 56, 50, 10, 57, 52, 51, 57, 57, 124, 56, 54, 50, 48, 53, 50, 52, 46, 48, 48, 10, 49, 53, 49, 50, 57, 53, 124, 56, 54, 49, 54, 54, 55, 49, 46, 48, 50, 10, 53, 54, 52, 49, 55, 124, 56, 54, 49, 51, 52, 53, 48, 46, 51, 53, 10, 49, 50, 49, 51, 50, 50, 124, 56, 54, 49, 50, 57, 52, 56, 46, 50, 51, 10, 49, 50, 54, 56, 56, 51, 124, 56, 54, 49, 49, 51, 55, 51, 46, 52, 50, 10, 50, 57, 49, 53, 53, 124, 56, 54, 49, 48, 49, 54, 51, 46, 54, 52, 10, 49, 49, 52, 53, 51, 48, 124, 56, 54, 48, 56, 52, 55, 49, 46, 55, 52, 10, 49, 51, 49, 48, 48, 55, 124, 56, 54, 48, 55, 51, 57, 52, 46, 56, 50, 10, 49, 50, 56, 55, 49, 53, 124, 56, 54, 48, 54, 56, 51, 51, 46, 54, 50, 10, 55, 50, 53, 50, 50, 124, 56, 54, 48, 49, 52, 55, 57, 46, 57, 56, 10, 49, 52, 52, 48, 54, 49, 124, 56, 53, 57, 53, 55, 49, 56, 46, 55, 52, 10, 56, 51, 53, 48, 51, 124, 56, 53, 57, 53, 48, 51, 52, 46, 50, 48, 10, 49, 49, 50, 49, 57, 57, 124, 56, 53, 57, 48, 55, 49, 55, 46, 52, 52, 10, 57, 50, 50, 55, 124, 56, 53, 56, 55, 51, 53, 48, 46, 52, 50, 10, 49, 49, 54, 51, 49, 56, 124, 56, 53, 56, 53, 57, 49, 48, 46, 54, 54, 10, 52, 49, 50, 52, 56, 124, 56, 53, 56, 53, 53, 53, 57, 46, 54, 52, 10, 49, 53, 57, 51, 57, 56, 124, 56, 53, 56, 52, 56, 50, 49, 46, 48, 48, 10, 49, 48, 53, 57, 54, 54, 124, 56, 53, 56, 50, 51, 48, 56, 46, 55, 57, 10, 49, 51, 55, 56, 55, 54, 124, 56, 53, 56, 48, 54, 52, 49, 46, 51, 48, 10, 49, 50, 50, 50, 55, 50, 124, 56, 53, 56, 48, 52, 48, 48, 46, 55, 55, 10, 49, 57, 53, 55, 49, 55, 124, 56, 53, 55, 55, 50, 55, 56, 46, 49, 48, 10, 49, 54, 53, 50, 57, 53, 124, 56, 53, 55, 49, 49, 50, 49, 46, 57, 50, 10, 53, 56, 52, 48, 124, 56, 53, 55, 48, 55, 50, 56, 46, 55, 52, 10, 49, 50, 48, 56, 54, 48, 124, 56, 53, 55, 48, 54, 49, 48, 46, 52, 52, 10, 54, 54, 54, 57, 50, 124, 56, 53, 54, 55, 53, 52, 48, 46, 53, 50, 10, 49, 51, 53, 53, 57, 54, 124, 56, 53, 54, 51, 50, 55, 54, 46, 51, 49, 10, 49, 53, 48, 53, 55, 54, 124, 56, 53, 54, 50, 55, 57, 52, 46, 49, 48, 10, 55, 53, 48, 48, 124, 56, 53, 54, 50, 51, 57, 51, 46, 56, 52, 10, 49, 48, 55, 55, 49, 54, 124, 56, 53, 54, 49, 53, 52, 49, 46, 53, 54, 10, 49, 48, 48, 54, 49, 49, 124, 56, 53, 53, 57, 57, 57, 53, 46, 56, 53, 10, 49, 55, 49, 49, 57, 50, 124, 56, 53, 53, 55, 51, 57, 48, 46, 48, 56, 10, 49, 48, 55, 54, 54, 48, 124, 56, 53, 53, 54, 54, 57, 54, 46, 54, 48, 10, 49, 51, 52, 54, 49, 124, 56, 53, 53, 54, 53, 52, 53, 46, 49, 50, 10, 57, 48, 51, 49, 48, 124, 56, 53, 53, 53, 49, 51, 49, 46, 53, 49, 10, 49, 52, 49, 52, 57, 51, 124, 56, 53, 53, 51, 55, 56, 50, 46, 57, 51, 10, 55, 49, 50, 56, 54, 124, 56, 53, 53, 50, 54, 56, 50, 46, 48, 48, 10, 49, 51, 54, 52, 50, 51, 124, 56, 53, 53, 49, 51, 48, 48, 46, 55, 54, 10, 53, 52, 50, 52, 49, 124, 56, 53, 53, 48, 55, 56, 53, 46, 50, 53, 10, 49, 50, 48, 51, 50, 53, 124, 56, 53, 52, 57, 57, 55, 54, 46, 54, 48, 10, 52, 50, 52, 124, 56, 53, 52, 55, 53, 50, 55, 46, 49, 48, 10, 49, 57, 54, 53, 52, 51, 124, 56, 53, 52, 53, 57, 48, 55, 46, 48, 57, 10, 49, 51, 48, 52, 50, 124, 56, 53, 52, 50, 55, 49, 55, 46, 49, 56, 10, 53, 56, 51, 51, 50, 124, 56, 53, 51, 54, 48, 55, 52, 46, 54, 57, 10, 57, 49, 57, 49, 124, 56, 53, 51, 53, 54, 54, 51, 46, 57, 50, 10, 49, 51, 52, 51, 53, 55, 124, 56, 53, 51, 53, 52, 50, 57, 46, 57, 48, 10, 57, 54, 50, 48, 55, 124, 56, 53, 51, 52, 57, 48, 48, 46, 54, 48, 10, 57, 50, 50, 57, 50, 124, 56, 53, 51, 48, 54, 49, 56, 46, 55, 56, 10, 49, 56, 49, 48, 57, 51, 124, 56, 53, 50, 56, 51, 48, 51, 46, 53, 50, 10, 49, 48, 53, 48, 54, 52, 124, 56, 53, 50, 55, 52, 57, 49, 46, 54, 48, 10, 53, 57, 54, 51, 53, 124, 56, 53, 50, 54, 56, 53, 52, 46, 48, 56, 10, 49, 51, 54, 57, 55, 52, 124, 56, 53, 50, 52, 51, 53, 49, 46, 53, 54, 10, 49, 50, 54, 54, 57, 52, 124, 56, 53, 50, 50, 55, 56, 51, 46, 51, 55, 10, 54, 50, 52, 55, 124, 56, 53, 50, 50, 54, 48, 54, 46, 57, 48, 10, 49, 51, 57, 52, 52, 55, 124, 56, 53, 50, 50, 53, 50, 49, 46, 57, 50, 10, 57, 54, 51, 49, 51, 124, 56, 53, 50, 48, 57, 52, 57, 46, 57, 50, 10, 49, 48, 56, 52, 53, 52, 124, 56, 53, 50, 48, 57, 49, 54, 46, 50, 53, 10, 49, 56, 49, 50, 53, 52, 124, 56, 53, 49, 57, 52, 57, 54, 46, 49, 48, 10, 55, 49, 49, 49, 55, 124, 56, 53, 49, 57, 50, 50, 51, 46, 48, 48, 10, 49, 51, 49, 55, 48, 51, 124, 56, 53, 49, 55, 50, 49, 53, 46, 50, 56, 10, 53, 57, 51, 49, 50, 124, 56, 53, 49, 48, 53, 54, 56, 46, 51, 54, 10, 50, 57, 48, 51, 124, 56, 53, 48, 57, 57, 54, 48, 46, 51, 53, 10, 49, 48, 50, 56, 51, 56, 124, 56, 53, 48, 57, 53, 50, 55, 46, 54, 57, 10, 49, 54, 50, 56, 48, 54, 124, 56, 53, 48, 56, 57, 48, 54, 46, 48, 53, 10, 52, 49, 53, 50, 55, 124, 56, 53, 48, 56, 50, 50, 50, 46, 51, 54, 10, 49, 49, 56, 52, 49, 54, 124, 56, 53, 48, 53, 56, 53, 56, 46, 51, 54, 10, 49, 56, 48, 50, 48, 51, 124, 56, 53, 48, 53, 48, 50, 52, 46, 49, 54, 10, 49, 52, 55, 55, 51, 124, 56, 53, 48, 48, 53, 57, 56, 46, 50, 56, 10, 49, 52, 48, 52, 52, 54, 124, 56, 52, 57, 57, 53, 49, 52, 46, 50, 52, 10, 49, 57, 57, 54, 52, 49, 124, 56, 52, 57, 55, 51, 54, 50, 46, 53, 57, 10, 49, 48, 57, 50, 52, 48, 124, 56, 52, 57, 52, 54, 49, 55, 46, 49, 50, 10, 49, 53, 48, 50, 54, 56, 124, 56, 52, 57, 52, 49, 56, 56, 46, 51, 56, 10, 52, 53, 51, 49, 48, 124, 56, 52, 57, 50, 51, 56, 48, 46, 54, 53, 10, 51, 54, 53, 53, 50, 124, 56, 52, 57, 48, 55, 51, 51, 46, 54, 48, 10, 49, 57, 57, 54, 57, 48, 124, 56, 52, 57, 48, 49, 52, 53, 46, 56, 48, 10, 49, 56, 53, 51, 53, 51, 124, 56, 52, 56, 56, 55, 50, 54, 46, 54, 56, 10, 49, 54, 51, 54, 49, 53, 124, 56, 52, 56, 52, 57, 56, 53, 46, 48, 49, 10, 49, 57, 54, 53, 50, 48, 124, 56, 52, 56, 51, 53, 52, 53, 46, 48, 52, 10, 49, 51, 51, 52, 51, 56, 124, 56, 52, 56, 51, 52, 56, 50, 46, 51, 53, 10, 55, 55, 50, 56, 53, 124, 56, 52, 56, 49, 52, 52, 50, 46, 51, 50, 10, 53, 53, 56, 50, 52, 124, 56, 52, 55, 54, 56, 57, 51, 46, 57, 48, 10, 55, 54, 55, 53, 51, 124, 56, 52, 55, 53, 53, 50, 50, 46, 49, 50, 10, 52, 54, 49, 50, 57, 124, 56, 52, 55, 50, 55, 49, 55, 46, 57, 54, 10, 50, 56, 51, 53, 56, 124, 56, 52, 55, 50, 53, 49, 53, 46, 53, 48, 10, 57, 51, 49, 55, 124, 56, 52, 55, 50, 49, 52, 53, 46, 51, 50, 10, 51, 51, 56, 50, 51, 124, 56, 52, 54, 57, 55, 50, 49, 46, 52, 52, 10, 51, 57, 48, 53, 53, 124, 56, 52, 54, 57, 49, 52, 53, 46, 48, 55, 10, 57, 49, 52, 55, 49, 124, 56, 52, 54, 56, 56, 55, 52, 46, 53, 54, 10, 49, 52, 50, 50, 57, 57, 124, 56, 52, 54, 54, 48, 51, 57, 46, 53, 53, 10, 57, 55, 54, 55, 50, 124, 56, 52, 54, 52, 49, 49, 57, 46, 56, 48, 10, 49, 51, 52, 55, 49, 50, 124, 56, 52, 54, 49, 55, 56, 49, 46, 55, 57, 10, 49, 53, 55, 57, 56, 56, 124, 56, 52, 54, 48, 49, 50, 51, 46, 50, 48, 10, 49, 48, 50, 50, 56, 52, 124, 56, 52, 53, 56, 54, 53, 50, 46, 52, 52, 10, 55, 51, 53, 51, 51, 124, 56, 52, 53, 56, 52, 53, 51, 46, 51, 50, 10, 57, 48, 53, 57, 57, 124, 56, 52, 53, 55, 56, 55, 52, 46, 56, 54, 10, 49, 49, 50, 49, 54, 48, 124, 56, 52, 53, 55, 56, 54, 51, 46, 51, 54, 10, 49, 50, 52, 55, 57, 50, 124, 56, 52, 53, 55, 54, 51, 51, 46, 55, 48, 10, 54, 54, 48, 57, 55, 124, 56, 52, 53, 55, 53, 55, 51, 46, 49, 53, 10, 49, 54, 53, 50, 55, 49, 124, 56, 52, 53, 54, 57, 54, 57, 46, 48, 49, 10, 49, 52, 54, 57, 50, 53, 124, 56, 52, 53, 52, 56, 56, 55, 46, 57, 49, 10, 49, 54, 52, 50, 55, 55, 124, 56, 52, 53, 52, 56, 51, 56, 46, 53, 48, 10, 49, 51, 49, 50, 57, 48, 124, 56, 52, 53, 52, 56, 49, 49, 46, 50, 48, 10, 49, 55, 57, 51, 56, 54, 124, 56, 52, 53, 48, 57, 48, 57, 46, 57, 48, 10, 57, 48, 52, 56, 54, 124, 56, 52, 52, 55, 56, 55, 51, 46, 56, 54, 10, 49, 55, 53, 57, 50, 52, 124, 56, 52, 52, 52, 52, 50, 49, 46, 54, 54, 10, 49, 56, 53, 57, 50, 50, 124, 56, 52, 52, 50, 51, 57, 52, 46, 56, 56, 10, 51, 56, 52, 57, 50, 124, 56, 52, 51, 54, 52, 51, 56, 46, 51, 50, 10, 49, 55, 50, 53, 49, 49, 124, 56, 52, 51, 54, 50, 56, 55, 46, 51, 52, 10, 49, 51, 57, 53, 51, 57, 124, 56, 52, 51, 52, 49, 56, 48, 46, 50, 57, 10, 49, 49, 57, 50, 54, 124, 56, 52, 51, 51, 49, 57, 57, 46, 53, 50, 10, 53, 53, 56, 56, 57, 124, 56, 52, 51, 49, 52, 52, 57, 46, 56, 56, 10, 49, 54, 51, 48, 54, 56, 124, 56, 52, 51, 49, 49, 49, 54, 46, 52, 48, 10, 49, 51, 56, 55, 55, 50, 124, 56, 52, 50, 56, 52, 48, 54, 46, 51, 54, 10, 49, 50, 54, 56, 50, 49, 124, 56, 52, 50, 53, 49, 56, 48, 46, 54, 56, 10, 50, 50, 48, 57, 49, 124, 56, 52, 50, 48, 54, 56, 55, 46, 56, 56, 10, 53, 53, 57, 56, 49, 124, 56, 52, 49, 57, 52, 51, 52, 46, 51, 56, 10, 49, 48, 48, 57, 54, 48, 124, 56, 52, 49, 57, 52, 48, 51, 46, 52, 54, 10, 49, 55, 50, 53, 54, 56, 124, 56, 52, 49, 55, 57, 53, 53, 46, 50, 49, 10, 54, 51, 49, 51, 53, 124, 56, 52, 49, 53, 57, 52, 53, 46, 53, 51, 10, 49, 51, 55, 54, 53, 49, 124, 56, 52, 49, 51, 49, 55, 48, 46, 51, 53, 10, 49, 57, 49, 51, 53, 51, 124, 56, 52, 49, 51, 48, 51, 57, 46, 56, 52, 10, 54, 50, 57, 56, 56, 124, 56, 52, 49, 49, 53, 55, 49, 46, 52, 56, 10, 49, 48, 51, 52, 49, 55, 124, 56, 52, 49, 49, 53, 52, 49, 46, 49, 50, 10, 49, 50, 48, 53, 50, 124, 56, 52, 49, 49, 53, 49, 57, 46, 50, 56, 10, 49, 48, 52, 50, 54, 48, 124, 56, 52, 48, 56, 53, 49, 54, 46, 53, 53, 10, 49, 53, 55, 49, 50, 57, 124, 56, 52, 48, 53, 55, 51, 48, 46, 48, 56, 10, 55, 55, 50, 53, 52, 124, 56, 52, 48, 53, 53, 51, 55, 46, 50, 50, 10, 49, 49, 50, 57, 54, 54, 124, 56, 52, 48, 51, 53, 49, 50, 46, 56, 57, 10, 49, 54, 56, 49, 49, 52, 124, 56, 52, 48, 50, 55, 54, 52, 46, 53, 54, 10, 52, 57, 57, 52, 48, 124, 56, 52, 48, 50, 51, 50, 56, 46, 50, 48, 10, 53, 50, 48, 49, 55, 124, 56, 51, 57, 56, 55, 53, 51, 46, 54, 48, 10, 49, 55, 54, 49, 55, 57, 124, 56, 51, 57, 56, 48, 56, 55, 46, 48, 48, 10, 49, 48, 48, 50, 49, 53, 124, 56, 51, 57, 53, 57, 48, 54, 46, 54, 49, 10, 54, 49, 50, 53, 54, 124, 56, 51, 57, 50, 56, 49, 49, 46, 50, 48, 10, 49, 53, 51, 54, 54, 124, 56, 51, 56, 56, 57, 48, 55, 46, 56, 48, 10, 49, 48, 57, 52, 55, 57, 124, 56, 51, 56, 56, 48, 50, 55, 46, 50, 48, 10, 54, 54, 50, 48, 50, 124, 56, 51, 56, 54, 53, 50, 50, 46, 56, 51, 10, 56, 49, 55, 48, 55, 124, 56, 51, 56, 53, 55, 54, 49, 46, 49, 57, 10, 53, 49, 55, 50, 55, 124, 56, 51, 56, 53, 52, 50, 54, 46, 52, 48, 10, 57, 57, 56, 48, 124, 56, 51, 56, 50, 55, 53, 52, 46, 54, 50, 10, 49, 55, 52, 52, 48, 51, 124, 56, 51, 55, 56, 53, 55, 53, 46, 55, 51, 10, 53, 52, 53, 53, 56, 124, 56, 51, 55, 56, 48, 52, 49, 46, 57, 50, 10, 51, 49, 52, 49, 124, 56, 51, 55, 55, 51, 55, 56, 46, 50, 50, 10, 49, 51, 52, 56, 50, 57, 124, 56, 51, 55, 55, 49, 48, 53, 46, 53, 50, 10, 49, 52, 53, 48, 53, 54, 124, 56, 51, 55, 54, 57, 50, 48, 46, 55, 54, 10, 49, 57, 52, 48, 50, 48, 124, 56, 51, 55, 53, 49, 53, 55, 46, 54, 52, 10, 55, 49, 49, 55, 124, 56, 51, 55, 51, 57, 56, 50, 46, 50, 55, 10, 49, 50, 48, 49, 52, 54, 124, 56, 51, 55, 51, 55, 57, 54, 46, 50, 48, 10, 49, 50, 54, 56, 52, 51, 124, 56, 51, 55, 48, 55, 54, 49, 46, 50, 56, 10, 54, 50, 49, 49, 55, 124, 56, 51, 54, 57, 52, 57, 51, 46, 52, 52, 10, 49, 49, 49, 50, 50, 49, 124, 56, 51, 54, 55, 53, 50, 53, 46, 56, 49, 10, 49, 53, 57, 51, 51, 55, 124, 56, 51, 54, 54, 48, 57, 50, 46, 50, 54, 10, 49, 55, 51, 57, 48, 51, 124, 56, 51, 54, 53, 52, 50, 56, 46, 52, 56, 10, 49, 51, 54, 52, 51, 56, 124, 56, 51, 54, 52, 48, 54, 53, 46, 52, 53, 10, 53, 54, 54, 56, 52, 124, 56, 51, 54, 51, 49, 57, 56, 46, 48, 48, 10, 49, 51, 55, 53, 57, 55, 124, 56, 51, 54, 51, 49, 56, 53, 46, 57, 52, 10, 50, 48, 48, 51, 57, 124, 56, 51, 54, 49, 49, 51, 56, 46, 50, 52, 10, 49, 50, 49, 51, 50, 54, 124, 56, 51, 53, 57, 54, 51, 53, 46, 53, 50, 10, 52, 56, 52, 51, 53, 124, 56, 51, 53, 50, 56, 54, 51, 46, 49, 48, 10, 49, 55, 49, 50, 124, 56, 51, 52, 57, 49, 48, 55, 46, 48, 48, 10, 49, 54, 55, 49, 57, 48, 124, 56, 51, 52, 55, 50, 51, 56, 46, 55, 48, 10, 51, 50, 49, 49, 51, 124, 56, 51, 52, 54, 52, 53, 50, 46, 48, 52, 10, 52, 48, 53, 56, 48, 124, 56, 51, 52, 50, 57, 56, 51, 46, 51, 50, 10, 55, 52, 55, 56, 53, 124, 56, 51, 52, 50, 53, 49, 57, 46, 49, 51, 10, 49, 52, 55, 57, 57, 124, 56, 51, 52, 50, 50, 51, 54, 46, 55, 53, 10, 49, 55, 55, 50, 57, 49, 124, 56, 51, 52, 49, 55, 51, 54, 46, 56, 51, 10, 49, 57, 56, 57, 53, 54, 124, 56, 51, 52, 48, 51, 55, 48, 46, 54, 53, 10, 54, 57, 49, 55, 57, 124, 56, 51, 51, 56, 52, 54, 53, 46, 57, 57, 10, 49, 49, 56, 55, 54, 52, 124, 56, 51, 51, 55, 54, 49, 54, 46, 53, 54, 10, 49, 50, 56, 56, 49, 52, 124, 56, 51, 51, 54, 52, 51, 53, 46, 53, 54, 10, 56, 50, 55, 50, 57, 124, 56, 51, 51, 49, 55, 54, 54, 46, 56, 56, 10, 49, 53, 50, 48, 52, 56, 124, 56, 51, 51, 48, 54, 51, 56, 46, 57, 57, 10, 49, 55, 49, 48, 56, 53, 124, 56, 51, 50, 54, 50, 53, 57, 46, 53, 48, 10, 49, 50, 54, 55, 51, 48, 124, 56, 51, 50, 53, 57, 55, 52, 46, 52, 48, 10, 55, 55, 53, 50, 53, 124, 56, 51, 50, 51, 50, 56, 50, 46, 53, 48, 10, 49, 55, 48, 54, 53, 51, 124, 56, 51, 50, 50, 56, 52, 48, 46, 53, 48, 10, 53, 50, 53, 55, 124, 56, 51, 50, 48, 51, 53, 48, 46, 55, 56, 10, 54, 55, 51, 53, 48, 124, 56, 51, 49, 56, 57, 56, 55, 46, 53, 54, 10, 49, 48, 57, 48, 48, 56, 124, 56, 51, 49, 55, 56, 51, 54, 46, 53, 52, 10, 49, 57, 57, 48, 52, 51, 124, 56, 51, 49, 54, 54, 48, 51, 46, 53, 52, 10, 49, 51, 57, 57, 54, 57, 124, 56, 51, 49, 54, 53, 53, 49, 46, 53, 52, 10, 50, 50, 54, 51, 52, 124, 56, 51, 49, 54, 53, 51, 49, 46, 50, 52, 10, 49, 55, 51, 51, 48, 57, 124, 56, 51, 49, 53, 55, 53, 48, 46, 50, 53, 10, 49, 48, 56, 56, 55, 124, 56, 51, 49, 53, 48, 49, 57, 46, 51, 54, 10, 52, 50, 51, 57, 50, 124, 56, 51, 49, 50, 56, 57, 53, 46, 57, 54, 10, 49, 50, 54, 48, 52, 48, 124, 56, 51, 49, 50, 54, 50, 51, 46, 50, 48, 10, 49, 48, 49, 53, 57, 48, 124, 56, 51, 48, 52, 53, 53, 53, 46, 52, 50, 10, 52, 54, 56, 57, 49, 124, 56, 51, 48, 50, 49, 57, 50, 46, 49, 50, 10, 49, 51, 56, 55, 50, 49, 124, 56, 51, 48, 49, 55, 52, 53, 46, 54, 50, 10, 49, 49, 51, 55, 49, 53, 124, 56, 51, 48, 49, 53, 51, 51, 46, 50, 48, 10, 55, 56, 55, 55, 56, 124, 56, 50, 57, 57, 54, 56, 53, 46, 54, 52, 10, 49, 52, 50, 57, 48, 56, 124, 56, 50, 57, 57, 52, 52, 55, 46, 55, 55, 10, 54, 52, 52, 49, 57, 124, 56, 50, 57, 55, 54, 51, 49, 46, 56, 48, 10, 50, 49, 51, 57, 54, 124, 56, 50, 57, 54, 50, 55, 50, 46, 50, 55, 10, 52, 49, 56, 48, 124, 56, 50, 57, 53, 54, 52, 54, 46, 57, 50, 10, 54, 51, 53, 51, 52, 124, 56, 50, 57, 53, 51, 56, 51, 46, 54, 55, 10, 49, 51, 53, 57, 53, 55, 124, 56, 50, 57, 52, 51, 56, 57, 46, 56, 54, 10, 51, 48, 49, 50, 54, 124, 56, 50, 57, 49, 57, 50, 48, 46, 51, 50, 10, 49, 53, 56, 52, 50, 55, 124, 56, 50, 56, 56, 57, 51, 56, 46, 48, 48, 10, 49, 52, 53, 52, 53, 124, 56, 50, 56, 56, 51, 57, 53, 46, 57, 50, 10, 55, 53, 53, 52, 56, 124, 56, 50, 56, 56, 50, 56, 55, 46, 50, 48, 10, 54, 52, 52, 55, 51, 124, 56, 50, 56, 54, 49, 51, 55, 46, 52, 52, 10, 49, 52, 57, 53, 53, 51, 124, 56, 50, 56, 53, 55, 49, 52, 46, 56, 56, 10, 49, 53, 49, 50, 56, 52, 124, 56, 50, 56, 51, 53, 50, 54, 46, 54, 53, 10, 49, 55, 49, 48, 57, 49, 124, 56, 50, 56, 50, 57, 51, 52, 46, 51, 54, 10, 49, 57, 52, 50, 53, 54, 124, 56, 50, 55, 56, 57, 56, 53, 46, 51, 52, 10, 57, 53, 50, 124, 56, 50, 55, 54, 49, 51, 54, 46, 48, 48, 10, 49, 50, 49, 53, 52, 49, 124, 56, 50, 55, 53, 51, 57, 48, 46, 50, 54, 10, 49, 55, 55, 54, 54, 52, 124, 56, 50, 55, 53, 51, 49, 53, 46, 50, 48, 10, 53, 49, 49, 49, 55, 124, 56, 50, 55, 52, 53, 48, 52, 46, 51, 48, 10, 54, 54, 55, 55, 48, 124, 56, 50, 55, 51, 52, 48, 55, 46, 56, 48, 10, 51, 55, 50, 51, 56, 124, 56, 50, 55, 50, 55, 50, 56, 46, 48, 54, 10, 52, 54, 54, 55, 57, 124, 56, 50, 55, 48, 52, 56, 54, 46, 53, 53, 10, 49, 54, 53, 56, 53, 50, 124, 56, 50, 54, 56, 51, 49, 50, 46, 54, 48, 10, 57, 57, 52, 53, 56, 124, 56, 50, 54, 54, 53, 54, 52, 46, 52, 55, 10, 49, 49, 52, 53, 49, 57, 124, 56, 50, 54, 53, 52, 57, 51, 46, 53, 52, 10, 55, 50, 51, 49, 124, 56, 50, 54, 52, 56, 56, 49, 46, 53, 48, 10, 49, 57, 48, 51, 51, 124, 56, 50, 54, 52, 56, 50, 54, 46, 53, 54, 10, 49, 50, 53, 49, 50, 51, 124, 56, 50, 54, 50, 55, 51, 50, 46, 54, 53, 10, 49, 56, 54, 52, 50, 124, 56, 50, 54, 49, 53, 55, 56, 46, 57, 57, 10, 53, 48, 51, 56, 54, 124, 56, 50, 54, 49, 51, 56, 48, 46, 48, 53, 10, 49, 57, 51, 55, 55, 48, 124, 56, 50, 53, 57, 53, 55, 56, 46, 56, 50, 10, 55, 50, 55, 54, 124, 56, 50, 53, 56, 49, 48, 49, 46, 54, 48, 10, 49, 55, 56, 48, 52, 53, 124, 56, 50, 53, 51, 57, 48, 52, 46, 49, 53, 10, 52, 57, 48, 51, 51, 124, 56, 50, 53, 51, 54, 57, 54, 46, 50, 51, 10, 49, 56, 55, 49, 57, 53, 124, 56, 50, 53, 49, 51, 51, 52, 46, 53, 56, 10, 49, 48, 53, 57, 48, 124, 56, 50, 52, 57, 50, 50, 55, 46, 52, 48, 10, 49, 52, 51, 55, 55, 57, 124, 56, 50, 52, 55, 48, 53, 55, 46, 55, 48, 10, 51, 53, 50, 48, 53, 124, 56, 50, 52, 53, 54, 55, 53, 46, 49, 55, 10, 49, 57, 55, 50, 57, 124, 56, 50, 52, 53, 48, 56, 49, 46, 54, 48, 10, 49, 52, 52, 57, 52, 54, 124, 56, 50, 52, 48, 52, 55, 57, 46, 56, 48, 10, 49, 50, 51, 55, 56, 54, 124, 56, 50, 51, 57, 53, 56, 49, 46, 50, 52, 10, 55, 48, 56, 52, 51, 124, 56, 50, 51, 55, 57, 55, 51, 46, 50, 48, 10, 49, 49, 50, 52, 51, 55, 124, 56, 50, 51, 54, 57, 48, 55, 46, 53, 50, 10, 53, 52, 51, 54, 124, 56, 50, 51, 54, 48, 51, 57, 46, 53, 55, 10, 49, 54, 51, 55, 53, 52, 124, 56, 50, 51, 53, 52, 55, 49, 46, 49, 54, 10, 49, 49, 53, 57, 52, 53, 124, 56, 50, 51, 52, 56, 49, 49, 46, 51, 54, 10, 50, 55, 57, 49, 56, 124, 56, 50, 51, 51, 57, 53, 55, 46, 56, 56, 10, 49, 48, 53, 55, 49, 50, 124, 56, 50, 51, 51, 53, 55, 49, 46, 56, 54, 10, 52, 49, 48, 48, 55, 124, 56, 50, 50, 57, 52, 51, 49, 46, 55, 57, 10, 52, 48, 52, 55, 54, 124, 56, 50, 50, 54, 54, 52, 48, 46, 52, 49, 10, 49, 52, 53, 54, 50, 48, 124, 56, 50, 50, 49, 51, 55, 49, 46, 54, 48, 10, 55, 55, 55, 49, 124, 56, 50, 50, 48, 52, 49, 51, 46, 51, 51, 10, 56, 54, 52, 50, 52, 124, 56, 50, 49, 53, 53, 55, 50, 46, 54, 49, 10, 49, 50, 57, 49, 51, 55, 124, 56, 50, 49, 53, 52, 55, 56, 46, 52, 48, 10, 55, 54, 48, 50, 48, 124, 56, 50, 49, 48, 52, 57, 53, 46, 51, 54, 10, 49, 52, 48, 50, 49, 51, 124, 56, 50, 48, 57, 56, 51, 49, 46, 56, 48, 10, 51, 50, 51, 55, 57, 124, 56, 50, 48, 56, 51, 51, 56, 46, 56, 56, 10, 49, 51, 48, 54, 49, 54, 124, 56, 50, 48, 55, 55, 49, 53, 46, 55, 53, 10, 49, 57, 53, 52, 54, 57, 124, 56, 50, 48, 54, 54, 48, 57, 46, 56, 48, 10, 49, 57, 49, 56, 48, 53, 124, 56, 50, 48, 53, 49, 52, 55, 46, 55, 53, 10, 57, 48, 57, 48, 54, 124, 56, 50, 48, 48, 57, 53, 49, 46, 50, 48, 10, 49, 55, 48, 57, 49, 48, 124, 56, 49, 57, 53, 53, 53, 56, 46, 48, 49, 10, 49, 48, 53, 51, 57, 57, 124, 56, 49, 57, 51, 49, 50, 50, 46, 54, 51, 10, 49, 50, 51, 55, 57, 56, 124, 56, 49, 57, 50, 51, 56, 53, 46, 57, 55, 10, 57, 48, 50, 49, 56, 124, 56, 49, 57, 49, 54, 56, 57, 46, 49, 54, 10, 49, 49, 52, 55, 54, 54, 124, 56, 49, 56, 57, 51, 51, 57, 46, 53, 52, 10, 49, 49, 50, 56, 57, 124, 56, 49, 56, 55, 51, 53, 52, 46, 55, 50, 10, 49, 55, 56, 51, 48, 56, 124, 56, 49, 56, 53, 55, 53, 48, 46, 53, 48, 10, 55, 49, 50, 55, 49, 124, 56, 49, 56, 53, 53, 49, 57, 46, 50, 52, 10, 49, 49, 49, 53, 124, 56, 49, 56, 52, 57, 48, 51, 46, 51, 56, 10, 49, 53, 50, 54, 51, 54, 124, 56, 49, 56, 52, 53, 51, 48, 46, 55, 50, 10, 49, 53, 49, 54, 49, 57, 124, 56, 49, 56, 50, 57, 48, 57, 46, 48, 53, 10, 49, 49, 54, 57, 52, 51, 124, 56, 49, 56, 49, 48, 55, 50, 46, 54, 57, 10, 50, 56, 56, 57, 49, 124, 56, 49, 56, 49, 48, 53, 49, 46, 53, 52, 10, 52, 55, 48, 52, 57, 124, 56, 49, 56, 48, 57, 53, 53, 46, 48, 48, 10, 49, 53, 56, 56, 50, 55, 124, 56, 49, 56, 48, 52, 55, 48, 46, 57, 48, 10, 57, 50, 54, 50, 48, 124, 56, 49, 55, 57, 54, 55, 49, 46, 53, 53, 10, 50, 48, 56, 49, 52, 124, 56, 49, 55, 54, 57, 53, 51, 46, 53, 52, 10, 49, 55, 57, 51, 50, 51, 124, 56, 49, 55, 54, 55, 57, 53, 46, 53, 53, 10, 49, 57, 51, 52, 53, 51, 124, 56, 49, 55, 52, 51, 52, 51, 46, 57, 52, 10, 53, 54, 56, 56, 56, 124, 56, 49, 55, 51, 51, 52, 50, 46, 48, 48, 10, 50, 56, 48, 56, 55, 124, 56, 49, 54, 57, 56, 55, 54, 46, 51, 48, 10, 49, 54, 52, 50, 53, 52, 124, 56, 49, 54, 57, 54, 51, 50, 46, 51, 53, 10, 53, 55, 54, 54, 49, 124, 56, 49, 54, 56, 56, 52, 56, 46, 49, 54, 10, 55, 51, 54, 51, 124, 56, 49, 54, 55, 53, 51, 56, 46, 48, 53, 10, 49, 54, 52, 52, 57, 57, 124, 56, 49, 54, 55, 53, 49, 50, 46, 48, 56, 10, 49, 57, 55, 53, 53, 55, 124, 56, 49, 54, 53, 57, 52, 48, 46, 52, 53, 10, 53, 52, 57, 53, 124, 56, 49, 54, 52, 56, 48, 53, 46, 50, 50, 10, 57, 54, 54, 124, 56, 49, 54, 51, 56, 50, 52, 46, 55, 57, 10, 57, 56, 52, 51, 53, 124, 56, 49, 54, 49, 55, 55, 49, 46, 52, 53, 10, 49, 50, 55, 50, 50, 55, 124, 56, 49, 54, 49, 51, 52, 52, 46, 57, 50, 10, 49, 57, 52, 49, 48, 48, 124, 56, 49, 54, 48, 57, 55, 56, 46, 55, 56, 10, 52, 48, 49, 51, 52, 124, 56, 49, 54, 48, 51, 53, 56, 46, 48, 56, 10, 49, 48, 55, 51, 52, 49, 124, 56, 49, 53, 57, 57, 53, 50, 46, 48, 53, 10, 54, 55, 57, 48, 124, 56, 49, 53, 56, 55, 57, 50, 46, 54, 54, 10, 52, 51, 56, 53, 49, 124, 56, 49, 53, 55, 49, 48, 49, 46, 52, 48, 10, 53, 49, 50, 57, 53, 124, 56, 49, 53, 54, 52, 49, 57, 46, 50, 48, 10, 54, 57, 53, 49, 50, 124, 56, 49, 53, 49, 53, 51, 55, 46, 48, 48, 10, 49, 54, 52, 50, 55, 52, 124, 56, 49, 52, 57, 56, 54, 57, 46, 57, 51, 10, 49, 51, 48, 56, 53, 52, 124, 56, 49, 52, 53, 51, 51, 56, 46, 56, 53, 10, 49, 56, 54, 56, 54, 53, 124, 56, 49, 52, 51, 53, 56, 54, 46, 56, 50, 10, 49, 55, 54, 54, 50, 57, 124, 56, 49, 52, 49, 52, 49, 49, 46, 50, 48, 10, 49, 57, 51, 55, 51, 57, 124, 56, 49, 52, 49, 51, 55, 55, 46, 55, 55, 10, 54, 56, 49, 48, 124, 56, 49, 51, 57, 56, 50, 50, 46, 54, 48, 10, 50, 55, 55, 51, 50, 124, 56, 49, 51, 54, 55, 50, 52, 46, 57, 54, 10, 53, 48, 54, 49, 54, 124, 56, 49, 51, 52, 48, 56, 57, 46, 56, 50, 10, 49, 50, 51, 57, 48, 56, 124, 56, 49, 50, 56, 57, 50, 48, 46, 53, 52, 10, 49, 52, 48, 57, 57, 52, 124, 56, 49, 50, 56, 52, 55, 48, 46, 56, 50, 10, 57, 57, 48, 51, 57, 124, 56, 49, 50, 56, 50, 57, 48, 46, 55, 56, 10, 54, 50, 55, 51, 53, 124, 56, 49, 50, 52, 57, 52, 48, 46, 53, 48, 10, 52, 55, 56, 50, 57, 124, 56, 49, 50, 50, 55, 57, 54, 46, 53, 48, 10, 49, 57, 50, 54, 51, 53, 124, 56, 49, 50, 50, 54, 56, 55, 46, 53, 55, 10, 49, 57, 50, 52, 50, 57, 124, 56, 49, 49, 57, 50, 54, 56, 46, 48, 48, 10, 49, 52, 53, 56, 49, 50, 124, 56, 49, 49, 57, 49, 54, 53, 46, 54, 51, 10, 52, 50, 56, 57, 54, 124, 56, 49, 49, 56, 53, 50, 57, 46, 56, 48, 10, 49, 52, 54, 56, 55, 55, 124, 56, 49, 49, 56, 50, 54, 54, 46, 49, 54, 10, 54, 48, 56, 56, 50, 124, 56, 49, 49, 54, 48, 57, 53, 46, 48, 52, 10, 49, 56, 50, 53, 52, 124, 56, 49, 49, 52, 55, 56, 51, 46, 48, 52, 10, 49, 54, 53, 52, 54, 52, 124, 56, 49, 49, 52, 53, 55, 49, 46, 56, 48, 10, 53, 55, 57, 51, 54, 124, 56, 49, 49, 49, 57, 50, 55, 46, 50, 53, 10, 53, 50, 50, 50, 54, 124, 56, 49, 49, 48, 55, 50, 51, 46, 51, 50, 10, 49, 50, 56, 53, 55, 49, 124, 56, 49, 48, 54, 55, 56, 56, 46, 56, 48, 10, 49, 48, 48, 51, 48, 56, 124, 56, 49, 48, 53, 56, 51, 55, 46, 48, 52, 10, 56, 56, 55, 50, 124, 56, 49, 48, 50, 51, 57, 53, 46, 54, 50, 10, 53, 56, 56, 54, 55, 124, 56, 49, 48, 50, 48, 51, 51, 46, 49, 57, 10, 49, 52, 53, 49, 53, 51, 124, 56, 49, 48, 48, 50, 50, 50, 46, 56, 52, 10, 49, 55, 50, 48, 56, 56, 124, 56, 48, 57, 56, 49, 51, 56, 46, 50, 48, 10, 53, 57, 51, 57, 56, 124, 56, 48, 57, 53, 56, 52, 53, 46, 52, 53, 10, 56, 57, 51, 57, 53, 124, 56, 48, 57, 51, 53, 55, 54, 46, 49, 48, 10, 49, 55, 49, 57, 54, 49, 124, 56, 48, 57, 51, 53, 51, 56, 46, 48, 48, 10, 56, 56, 55, 51, 54, 124, 56, 48, 57, 48, 55, 54, 50, 46, 49, 54, 10, 49, 55, 52, 48, 53, 51, 124, 56, 48, 57, 48, 51, 53, 48, 46, 49, 49, 10, 49, 48, 50, 50, 51, 55, 124, 56, 48, 56, 57, 49, 48, 51, 46, 50, 50, 10, 52, 51, 48, 52, 49, 124, 56, 48, 56, 54, 53, 51, 55, 46, 57, 48, 10, 49, 49, 48, 50, 49, 57, 124, 56, 48, 56, 53, 50, 57, 54, 46, 57, 48, 10, 49, 50, 54, 55, 51, 56, 124, 56, 48, 56, 52, 49, 57, 57, 46, 50, 48, 10, 52, 52, 55, 56, 55, 124, 56, 48, 56, 51, 54, 50, 56, 46, 52, 48, 10, 51, 49, 50, 55, 55, 124, 56, 48, 56, 51, 53, 56, 48, 46, 55, 54, 10, 57, 51, 53, 57, 53, 124, 56, 48, 56, 50, 49, 56, 56, 46, 56, 48, 10, 49, 56, 57, 48, 52, 48, 124, 56, 48, 56, 48, 50, 53, 55, 46, 50, 49, 10, 53, 57, 56, 53, 49, 124, 56, 48, 55, 57, 48, 50, 52, 46, 50, 52, 10, 49, 55, 53, 49, 48, 48, 124, 56, 48, 55, 55, 57, 48, 52, 46, 48, 49, 10, 52, 51, 52, 50, 57, 124, 56, 48, 55, 54, 55, 50, 57, 46, 57, 54, 10, 49, 53, 52, 49, 57, 57, 124, 56, 48, 55, 52, 57, 52, 48, 46, 55, 54, 10, 54, 48, 57, 54, 51, 124, 56, 48, 55, 51, 56, 57, 52, 46, 52, 48, 10, 56, 55, 54, 56, 124, 56, 48, 55, 50, 55, 54, 48, 46, 57, 54, 10, 54, 54, 48, 57, 53, 124, 56, 48, 55, 49, 52, 50, 49, 46, 55, 48, 10, 49, 49, 49, 53, 53, 50, 124, 56, 48, 54, 56, 49, 56, 52, 46, 52, 56, 10, 50, 52, 53, 54, 51, 124, 56, 48, 54, 55, 53, 48, 48, 46, 52, 48, 10, 49, 54, 49, 54, 55, 124, 56, 48, 54, 55, 52, 57, 53, 46, 50, 52, 10, 49, 50, 54, 54, 50, 124, 56, 48, 54, 55, 50, 52, 56, 46, 56, 53, 10, 57, 52, 53, 52, 48, 124, 56, 48, 54, 51, 55, 50, 55, 46, 49, 54, 10, 50, 51, 51, 48, 56, 124, 56, 48, 54, 51, 52, 54, 51, 46, 49, 56, 10, 50, 55, 51, 57, 48, 124, 56, 48, 54, 50, 56, 50, 51, 46, 50, 53, 10, 49, 51, 48, 54, 54, 48, 124, 56, 48, 54, 50, 55, 56, 55, 46, 52, 56, 10, 56, 54, 48, 56, 124, 56, 48, 54, 50, 52, 49, 49, 46, 49, 54, 10, 49, 56, 49, 53, 53, 50, 124, 56, 48, 54, 50, 48, 48, 56, 46, 51, 48, 10, 49, 57, 57, 51, 49, 57, 124, 56, 48, 54, 48, 50, 52, 56, 46, 53, 54, 10, 53, 53, 52, 55, 53, 124, 56, 48, 53, 56, 56, 53, 48, 46, 57, 50, 10, 49, 52, 50, 55, 49, 49, 124, 56, 48, 53, 55, 57, 50, 54, 46, 53, 56, 10, 49, 48, 51, 52, 57, 57, 124, 56, 48, 53, 54, 57, 55, 56, 46, 48, 48, 10, 49, 48, 53, 57, 52, 51, 124, 56, 48, 53, 54, 54, 57, 56, 46, 55, 53, 10, 56, 52, 51, 50, 124, 56, 48, 53, 51, 48, 53, 50, 46, 49, 54, 10, 49, 52, 57, 51, 57, 50, 124, 56, 48, 52, 57, 54, 55, 53, 46, 54, 57, 10, 49, 48, 49, 50, 52, 56, 124, 56, 48, 52, 56, 56, 53, 53, 46, 52, 57, 10, 49, 52, 48, 57, 54, 50, 124, 56, 48, 52, 55, 50, 54, 48, 46, 55, 48, 10, 56, 55, 49, 48, 49, 124, 56, 48, 52, 54, 54, 53, 49, 46, 56, 51, 10, 49, 51, 51, 49, 48, 55, 124, 56, 48, 52, 54, 52, 55, 54, 46, 55, 51, 10, 52, 53, 49, 50, 54, 124, 56, 48, 52, 53, 57, 50, 52, 46, 52, 48, 10, 56, 55, 53, 48, 56, 124, 56, 48, 52, 50, 57, 54, 54, 46, 51, 57, 10, 49, 50, 52, 55, 49, 49, 124, 56, 48, 52, 50, 55, 50, 50, 46, 55, 50, 10, 49, 55, 51, 49, 54, 57, 124, 56, 48, 52, 50, 50, 50, 52, 46, 52, 49, 10, 49, 55, 53, 49, 54, 49, 124, 56, 48, 52, 49, 51, 51, 49, 46, 57, 56, 10, 49, 54, 55, 55, 56, 55, 124, 56, 48, 52, 48, 48, 55, 53, 46, 55, 56, 10, 51, 50, 52, 50, 124, 56, 48, 51, 56, 56, 53, 53, 46, 53, 51, 10, 49, 49, 52, 55, 56, 57, 124, 56, 48, 51, 56, 54, 50, 56, 46, 51, 53, 10, 52, 51, 56, 51, 51, 124, 56, 48, 51, 56, 53, 52, 53, 46, 56, 51, 10, 49, 52, 49, 49, 57, 56, 124, 56, 48, 51, 53, 49, 49, 48, 46, 55, 50, 10, 49, 51, 55, 50, 52, 56, 124, 56, 48, 51, 52, 49, 48, 57, 46, 51, 53, 10, 57, 54, 54, 55, 51, 124, 56, 48, 51, 51, 52, 57, 49, 46, 50, 48, 10, 51, 50, 49, 56, 48, 124, 56, 48, 51, 50, 51, 56, 48, 46, 55, 50, 10, 49, 54, 54, 52, 57, 51, 124, 56, 48, 51, 49, 57, 48, 50, 46, 52, 48, 10, 54, 54, 57, 53, 57, 124, 56, 48, 51, 49, 56, 51, 57, 46, 52, 48, 10, 56, 53, 54, 50, 56, 124, 56, 48, 50, 57, 54, 57, 51, 46, 52, 52, 10, 49, 49, 48, 57, 55, 49, 124, 56, 48, 50, 57, 52, 54, 57, 46, 55, 48, 10, 49, 51, 48, 51, 57, 53, 124, 56, 48, 50, 55, 52, 54, 51, 46, 57, 50, 10, 55, 55, 53, 55, 124, 56, 48, 50, 54, 56, 52, 48, 46, 51, 55, 10, 49, 55, 56, 52, 52, 54, 124, 56, 48, 50, 53, 51, 55, 57, 46, 48, 57, 10, 52, 49, 50, 57, 53, 124, 56, 48, 50, 52, 55, 56, 53, 46, 53, 51, 10, 49, 48, 48, 57, 53, 54, 124, 56, 48, 50, 52, 49, 55, 57, 46, 51, 48, 10, 49, 51, 49, 57, 49, 55, 124, 56, 48, 50, 49, 54, 48, 52, 46, 55, 56, 10, 50, 52, 50, 50, 52, 124, 56, 48, 50, 48, 52, 54, 51, 46, 53, 50, 10, 50, 48, 55, 51, 124, 56, 48, 50, 48, 48, 48, 57, 46, 54, 52, 10, 49, 50, 49, 54, 50, 50, 124, 56, 48, 49, 56, 52, 54, 50, 46, 49, 55, 10, 49, 52, 51, 53, 55, 124, 56, 48, 49, 54, 57, 48, 54, 46, 51, 48, 10, 49, 51, 53, 54, 48, 49, 124, 56, 48, 49, 54, 50, 48, 57, 46, 52, 52, 10, 53, 56, 52, 53, 56, 124, 56, 48, 49, 54, 49, 57, 50, 46, 53, 50, 10, 55, 51, 48, 51, 54, 124, 56, 48, 49, 53, 55, 57, 57, 46, 48, 48, 10, 49, 56, 52, 55, 50, 50, 124, 56, 48, 49, 53, 54, 56, 48, 46, 51, 49, 10, 49, 53, 49, 54, 54, 52, 124, 56, 48, 49, 52, 56, 50, 49, 46, 57, 54, 10, 49, 57, 53, 48, 57, 48, 124, 56, 48, 49, 50, 54, 56, 48, 46, 50, 48, 10, 49, 54, 50, 54, 48, 57, 124, 56, 48, 49, 49, 50, 52, 49, 46, 48, 48, 10, 56, 51, 53, 51, 50, 124, 56, 48, 48, 57, 55, 53, 51, 46, 56, 53, 10, 53, 48, 49, 54, 54, 124, 56, 48, 48, 55, 49, 51, 55, 46, 56, 57, 10, 49, 56, 49, 53, 54, 50, 124, 56, 48, 48, 54, 56, 48, 53, 46, 57, 54, 10, 49, 55, 53, 49, 54, 53, 124, 56, 48, 48, 53, 51, 49, 57, 46, 55, 54, 10, 54, 50, 53, 48, 48, 124, 56, 48, 48, 53, 51, 49, 54, 46, 50, 56, 10, 51, 54, 51, 52, 50, 124, 56, 48, 48, 52, 51, 51, 51, 46, 52, 48, 10, 49, 50, 56, 52, 51, 53, 124, 56, 48, 48, 52, 50, 52, 50, 46, 56, 56, 10, 57, 50, 53, 49, 54, 124, 56, 48, 48, 51, 56, 51, 54, 46, 56, 48, 10, 51, 48, 56, 48, 50, 124, 56, 48, 48, 51, 55, 49, 48, 46, 56, 56, 10, 49, 48, 55, 52, 49, 56, 124, 56, 48, 48, 48, 52, 51, 48, 46, 51, 48, 10, 52, 54, 54, 50, 48, 124, 55, 57, 57, 57, 55, 55, 56, 46, 51, 53, 10, 49, 57, 49, 56, 48, 51, 124, 55, 57, 57, 52, 55, 51, 52, 46, 49, 53, 10, 49, 48, 54, 51, 52, 51, 124, 55, 57, 57, 51, 48, 56, 55, 46, 55, 54, 10, 53, 57, 51, 54, 50, 124, 55, 57, 57, 48, 51, 57, 55, 46, 52, 54, 10, 56, 51, 50, 57, 124, 55, 57, 57, 48, 48, 53, 50, 46, 57, 48, 10, 55, 53, 49, 51, 51, 124, 55, 57, 56, 56, 50, 52, 52, 46, 48, 48, 10, 49, 55, 57, 48, 50, 51, 124, 55, 57, 56, 54, 56, 50, 57, 46, 54, 50, 10, 49, 51, 53, 56, 57, 57, 124, 55, 57, 56, 53, 55, 50, 54, 46, 54, 52, 10, 53, 56, 50, 52, 124, 55, 57, 56, 53, 51, 52, 48, 46, 48, 50, 10, 49, 52, 56, 53, 55, 57, 124, 55, 57, 56, 52, 56, 56, 57, 46, 53, 54, 10, 57, 53, 56, 56, 56, 124, 55, 57, 56, 52, 55, 51, 53, 46, 55, 50, 10, 57, 55, 57, 49, 124, 55, 57, 56, 50, 54, 57, 57, 46, 55, 57, 10, 49, 55, 48, 52, 51, 55, 124, 55, 57, 56, 50, 51, 55, 48, 46, 55, 50, 10, 51, 57, 55, 56, 50, 124, 55, 57, 55, 55, 56, 53, 56, 46, 50, 52, 10, 50, 48, 54, 48, 53, 124, 55, 57, 55, 55, 53, 53, 54, 46, 48, 48, 10, 50, 56, 54, 56, 50, 124, 55, 57, 55, 54, 57, 54, 48, 46, 48, 48, 10, 52, 50, 49, 55, 50, 124, 55, 57, 55, 51, 51, 57, 57, 46, 48, 48, 10, 53, 54, 49, 51, 55, 124, 55, 57, 55, 49, 52, 48, 53, 46, 52, 48, 10, 54, 52, 55, 50, 57, 124, 55, 57, 55, 48, 55, 54, 57, 46, 55, 50, 10, 57, 56, 54, 52, 51, 124, 55, 57, 54, 56, 54, 48, 51, 46, 55, 51, 10, 49, 53, 51, 55, 56, 55, 124, 55, 57, 54, 55, 53, 51, 53, 46, 53, 56, 10, 56, 57, 51, 50, 124, 55, 57, 54, 55, 50, 50, 50, 46, 49, 57, 10, 50, 48, 49, 51, 52, 124, 55, 57, 54, 53, 55, 49, 51, 46, 50, 56, 10, 49, 57, 55, 54, 51, 53, 124, 55, 57, 54, 51, 53, 48, 55, 46, 53, 56, 10, 56, 48, 52, 48, 56, 124, 55, 57, 54, 51, 51, 49, 50, 46, 49, 55, 10, 51, 55, 55, 50, 56, 124, 55, 57, 54, 49, 56, 55, 53, 46, 54, 56, 10, 50, 54, 54, 50, 52, 124, 55, 57, 54, 49, 55, 55, 50, 46, 51, 49, 10, 52, 52, 55, 51, 54, 124, 55, 57, 54, 49, 49, 52, 52, 46, 49, 48, 10, 50, 57, 55, 54, 51, 124, 55, 57, 54, 48, 54, 48, 53, 46, 48, 51, 10, 51, 54, 49, 52, 55, 124, 55, 57, 53, 57, 52, 54, 51, 46, 54, 56, 10, 49, 52, 54, 48, 52, 48, 124, 55, 57, 53, 55, 53, 56, 55, 46, 54, 54, 10, 49, 49, 53, 52, 54, 57, 124, 55, 57, 53, 55, 52, 56, 53, 46, 49, 52, 10, 49, 52, 50, 50, 55, 54, 124, 55, 57, 53, 54, 55, 57, 48, 46, 54, 51, 10, 49, 56, 49, 50, 56, 48, 124, 55, 57, 53, 52, 48, 51, 55, 46, 51, 53, 10, 49, 49, 53, 48, 57, 54, 124, 55, 57, 53, 51, 48, 52, 55, 46, 53, 53, 10, 49, 48, 57, 54, 53, 48, 124, 55, 57, 53, 50, 50, 53, 56, 46, 55, 51, 10, 57, 51, 56, 54, 50, 124, 55, 57, 53, 49, 57, 57, 50, 46, 50, 52, 10, 49, 53, 56, 51, 50, 53, 124, 55, 57, 53, 48, 55, 50, 56, 46, 51, 48, 10, 53, 53, 57, 53, 50, 124, 55, 57, 53, 48, 51, 56, 55, 46, 48, 54, 10, 49, 50, 50, 51, 57, 55, 124, 55, 57, 52, 55, 49, 48, 54, 46, 50, 55, 10, 50, 56, 49, 49, 52, 124, 55, 57, 52, 54, 57, 52, 53, 46, 55, 50, 10, 49, 49, 57, 54, 54, 124, 55, 57, 52, 53, 49, 57, 55, 46, 52, 56, 10, 52, 55, 56, 49, 52, 124, 55, 57, 52, 52, 48, 56, 51, 46, 48, 48, 10, 56, 53, 48, 57, 54, 124, 55, 57, 52, 51, 54, 57, 49, 46, 48, 54, 10, 53, 49, 54, 53, 55, 124, 55, 57, 52, 51, 53, 57, 51, 46, 55, 55, 10, 49, 57, 54, 54, 56, 48, 124, 55, 57, 52, 51, 53, 55, 56, 46, 56, 57, 10, 49, 51, 49, 52, 49, 124, 55, 57, 52, 50, 55, 51, 48, 46, 51, 52, 10, 49, 57, 51, 51, 50, 55, 124, 55, 57, 52, 49, 48, 51, 54, 46, 50, 53, 10, 49, 53, 50, 54, 49, 50, 124, 55, 57, 52, 48, 54, 54, 51, 46, 55, 49, 10, 49, 51, 57, 54, 56, 48, 124, 55, 57, 51, 57, 50, 52, 50, 46, 51, 54, 10, 51, 49, 49, 51, 52, 124, 55, 57, 51, 56, 51, 49, 56, 46, 51, 48, 10, 52, 53, 54, 51, 54, 124, 55, 57, 51, 55, 50, 52, 48, 46, 56, 53, 10, 53, 54, 54, 57, 52, 124, 55, 57, 51, 54, 48, 49, 53, 46, 57, 53, 10, 56, 49, 49, 52, 124, 55, 57, 51, 51, 57, 50, 49, 46, 56, 56, 10, 55, 49, 53, 49, 56, 124, 55, 57, 51, 50, 50, 54, 49, 46, 54, 57, 10, 55, 50, 57, 50, 50, 124, 55, 57, 51, 48, 52, 48, 48, 46, 54, 52, 10, 49, 52, 54, 54, 57, 57, 124, 55, 57, 50, 57, 49, 54, 55, 46, 52, 48, 10, 57, 50, 51, 56, 55, 124, 55, 57, 50, 56, 57, 55, 50, 46, 54, 55, 10, 49, 56, 54, 50, 56, 57, 124, 55, 57, 50, 56, 55, 56, 54, 46, 49, 57, 10, 57, 53, 57, 53, 50, 124, 55, 57, 50, 55, 57, 55, 50, 46, 55, 56, 10, 49, 57, 54, 53, 49, 52, 124, 55, 57, 50, 55, 49, 56, 48, 46, 55, 48, 10, 52, 52, 48, 51, 124, 55, 57, 50, 53, 55, 50, 57, 46, 48, 52, 10, 50, 50, 54, 55, 124, 55, 57, 50, 53, 54, 52, 57, 46, 51, 55, 10, 52, 53, 57, 50, 52, 124, 55, 57, 50, 53, 48, 52, 55, 46, 54, 56, 10, 49, 49, 52, 57, 51, 124, 55, 57, 49, 54, 55, 50, 50, 46, 50, 51, 10, 49, 48, 52, 52, 55, 56, 124, 55, 57, 49, 54, 50, 53, 51, 46, 54, 48, 10, 49, 54, 54, 55, 57, 52, 124, 55, 57, 49, 51, 56, 52, 50, 46, 48, 48, 10, 49, 54, 49, 57, 57, 53, 124, 55, 57, 49, 48, 56, 55, 52, 46, 50, 55, 10, 50, 51, 53, 51, 56, 124, 55, 57, 48, 57, 55, 53, 50, 46, 48, 54, 10, 52, 49, 48, 57, 51, 124, 55, 57, 48, 57, 53, 55, 57, 46, 57, 50, 10, 49, 49, 50, 48, 55, 51, 124, 55, 57, 48, 56, 54, 49, 55, 46, 53, 55, 10, 57, 50, 56, 49, 52, 124, 55, 57, 48, 56, 50, 54, 50, 46, 53, 48, 10, 56, 56, 57, 49, 57, 124, 55, 57, 48, 55, 57, 57, 50, 46, 53, 48, 10, 55, 57, 55, 53, 51, 124, 55, 57, 48, 55, 57, 51, 51, 46, 56, 56, 10, 49, 48, 56, 55, 54, 53, 124, 55, 57, 48, 53, 51, 51, 56, 46, 57, 56, 10, 49, 52, 54, 53, 51, 48, 124, 55, 57, 48, 53, 51, 51, 54, 46, 54, 48, 10, 55, 49, 52, 55, 53, 124, 55, 57, 48, 51, 51, 54, 55, 46, 53, 56, 10, 51, 54, 50, 56, 57, 124, 55, 57, 48, 49, 57, 52, 54, 46, 53, 48, 10, 54, 49, 55, 51, 57, 124, 55, 57, 48, 48, 55, 57, 52, 46, 48, 48, 10, 53, 50, 51, 51, 56, 124, 55, 56, 57, 56, 54, 51, 56, 46, 48, 56, 10, 49, 57, 52, 50, 57, 57, 124, 55, 56, 57, 56, 52, 50, 49, 46, 50, 52, 10, 49, 48, 53, 50, 51, 53, 124, 55, 56, 57, 55, 56, 50, 57, 46, 57, 52, 10, 55, 55, 50, 48, 55, 124, 55, 56, 57, 55, 55, 53, 50, 46, 55, 50, 10, 57, 54, 55, 49, 50, 124, 55, 56, 57, 55, 53, 55, 53, 46, 50, 55, 10, 49, 48, 49, 53, 55, 124, 55, 56, 57, 55, 48, 52, 54, 46, 50, 53, 10, 49, 55, 49, 49, 53, 52, 124, 55, 56, 57, 54, 56, 49, 52, 46, 53, 48, 10, 55, 57, 51, 55, 51, 124, 55, 56, 57, 54, 49, 56, 54, 46, 48, 48, 10, 49, 49, 51, 56, 48, 56, 124, 55, 56, 57, 51, 51, 53, 51, 46, 56, 56, 10, 50, 55, 57, 48, 49, 124, 55, 56, 57, 50, 57, 53, 50, 46, 48, 48, 10, 49, 50, 56, 56, 50, 48, 124, 55, 56, 57, 50, 56, 56, 50, 46, 55, 50, 10, 50, 53, 56, 57, 49, 124, 55, 56, 57, 48, 53, 49, 49, 46, 50, 48, 10, 49, 50, 50, 56, 49, 57, 124, 55, 56, 56, 56, 56, 56, 49, 46, 48, 50, 10, 49, 53, 52, 55, 51, 49, 124, 55, 56, 56, 56, 51, 48, 49, 46, 51, 51, 10, 49, 48, 49, 54, 55, 52, 124, 55, 56, 55, 57, 51, 50, 52, 46, 54, 48, 10, 53, 49, 57, 54, 56, 124, 55, 56, 55, 57, 49, 48, 50, 46, 50, 49, 10, 55, 50, 48, 55, 51, 124, 55, 56, 55, 55, 55, 51, 54, 46, 49, 49, 10, 53, 49, 56, 50, 124, 55, 56, 55, 52, 53, 50, 49, 46, 55, 51, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q12[] = {108, 95, 115, 104, 105, 112, 109, 111, 100, 101, 124, 104, 105, 103, 104, 95, 108, 105, 110, 101, 95, 99, 111, 117, 110, 116, 124, 108, 111, 119, 95, 108, 105, 110, 101, 95, 99, 111, 117, 110, 116, 10, 77, 65, 73, 76, 124, 54, 50, 48, 50, 124, 57, 51, 50, 52, 10, 83, 72, 73, 80, 124, 54, 50, 48, 48, 124, 57, 50, 54, 50, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q13[] = {99, 95, 99, 111, 117, 110, 116, 124, 99, 117, 115, 116, 100, 105, 115, 116, 10, 48, 124, 53, 48, 48, 48, 53, 10, 57, 124, 54, 54, 52, 49, 10, 49, 48, 124, 54, 53, 51, 50, 10, 49, 49, 124, 54, 48, 49, 52, 10, 56, 124, 53, 57, 51, 55, 10, 49, 50, 124, 53, 54, 51, 57, 10, 49, 51, 124, 53, 48, 50, 52, 10, 49, 57, 124, 52, 55, 57, 51, 10, 55, 124, 52, 54, 56, 55, 10, 49, 55, 124, 52, 53, 56, 55, 10, 49, 56, 124, 52, 53, 50, 57, 10, 50, 48, 124, 52, 53, 49, 54, 10, 49, 53, 124, 52, 53, 48, 53, 10, 49, 52, 124, 52, 52, 52, 54, 10, 49, 54, 124, 52, 50, 55, 51, 10, 50, 49, 124, 52, 49, 57, 48, 10, 50, 50, 124, 51, 54, 50, 51, 10, 54, 124, 51, 50, 54, 53, 10, 50, 51, 124, 51, 50, 50, 53, 10, 50, 52, 124, 50, 55, 52, 50, 10, 50, 53, 124, 50, 48, 56, 54, 10, 53, 124, 49, 57, 52, 56, 10, 50, 54, 124, 49, 54, 49, 50, 10, 50, 55, 124, 49, 49, 55, 57, 10, 52, 124, 49, 48, 48, 55, 10, 50, 56, 124, 56, 57, 51, 10, 50, 57, 124, 53, 57, 51, 10, 51, 124, 52, 49, 53, 10, 51, 48, 124, 51, 55, 54, 10, 51, 49, 124, 50, 50, 54, 10, 51, 50, 124, 49, 52, 56, 10, 50, 124, 49, 51, 52, 10, 51, 51, 124, 55, 53, 10, 51, 52, 124, 53, 48, 10, 51, 53, 124, 51, 55, 10, 49, 124, 49, 55, 10, 51, 54, 124, 49, 52, 10, 51, 56, 124, 53, 10, 51, 55, 124, 53, 10, 52, 48, 124, 52, 10, 52, 49, 124, 50, 10, 51, 57, 124, 49, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q14[] = {112, 114, 111, 109, 111, 95, 114, 101, 118, 101, 110, 117, 101, 10, 49, 54, 46, 51, 56, 48, 55, 55, 56, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q15[] = {115, 95, 115, 117, 112, 112, 107, 101, 121, 124, 115, 95, 110, 97, 109, 101, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 124, 115, 95, 112, 104, 111, 110, 101, 124, 116, 111, 116, 97, 108, 95, 114, 101, 118, 101, 110, 117, 101, 10, 56, 52, 52, 57, 124, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 52, 52, 57, 124, 53, 66, 88, 87, 115, 74, 69, 82, 65, 50, 109, 80, 53, 79, 121, 79, 52, 124, 50, 48, 45, 52, 54, 57, 45, 56, 53, 54, 45, 56, 56, 55, 51, 124, 49, 55, 55, 50, 54, 50, 55, 46, 50, 48, 56, 55, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q16[] = {112, 95, 98, 114, 97, 110, 100, 124, 112, 95, 116, 121, 112, 101, 124, 112, 95, 115, 105, 122, 101, 124, 115, 117, 112, 112, 108, 105, 101, 114, 95, 99, 110, 116, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 50, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 50, 55, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 50, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 50, 51, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 50, 51, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 50, 51, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 50, 48, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 57, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 54, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 53, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 53, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 53, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 53, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 49, 50, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 49, 49, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 56, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 56, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 55, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 55, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 55, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 55, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 55, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 55, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 55, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 55, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 55, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 55, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 55, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 55, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 55, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 55, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 55, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 55, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 55, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 55, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 54, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 52, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 77, 69, 68, 73, 85, 77, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 77, 65, 76, 76, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 52, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 52, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 84, 73, 78, 124, 51, 54, 124, 52, 10, 66, 114, 97, 110, 100, 35, 49, 49, 124, 83, 77, 65, 76, 76, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 52, 53, 124, 51, 10, 66, 114, 97, 110, 100, 35, 49, 53, 124, 76, 65, 82, 71, 69, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 78, 73, 67, 75, 69, 76, 124, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 50, 49, 124, 80, 82, 79, 77, 79, 32, 66, 85, 82, 78, 73, 83, 72, 69, 68, 32, 83, 84, 69, 69, 76, 124, 52, 53, 124, 51, 10, 66, 114, 97, 110, 100, 35, 50, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 50, 51, 124, 51, 10, 66, 114, 97, 110, 100, 35, 50, 53, 124, 76, 65, 82, 71, 69, 32, 80, 76, 65, 84, 69, 68, 32, 83, 84, 69, 69, 76, 124, 49, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 51, 50, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 67, 79, 80, 80, 69, 82, 124, 50, 51, 124, 51, 10, 66, 114, 97, 110, 100, 35, 51, 51, 124, 83, 77, 65, 76, 76, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 51, 53, 124, 77, 69, 68, 73, 85, 77, 32, 65, 78, 79, 68, 73, 90, 69, 68, 32, 84, 73, 78, 124, 49, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 53, 49, 124, 83, 77, 65, 76, 76, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 50, 51, 124, 51, 10, 66, 114, 97, 110, 100, 35, 53, 50, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 52, 53, 124, 51, 10, 66, 114, 97, 110, 100, 35, 53, 51, 124, 77, 69, 68, 73, 85, 77, 32, 66, 82, 85, 83, 72, 69, 68, 32, 84, 73, 78, 124, 52, 53, 124, 51, 10, 66, 114, 97, 110, 100, 35, 53, 52, 124, 69, 67, 79, 78, 79, 77, 89, 32, 80, 79, 76, 73, 83, 72, 69, 68, 32, 66, 82, 65, 83, 83, 124, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 80, 82, 79, 77, 79, 32, 80, 76, 65, 84, 69, 68, 32, 66, 82, 65, 83, 83, 124, 49, 57, 124, 51, 10, 66, 114, 97, 110, 100, 35, 53, 53, 124, 83, 84, 65, 78, 68, 65, 82, 68, 32, 80, 76, 65, 84, 69, 68, 32, 84, 73, 78, 124, 52, 57, 124, 51, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q17[] = {97, 118, 103, 95, 121, 101, 97, 114, 108, 121, 10, 51, 52, 56, 52, 48, 54, 46, 48, 53, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q18[] = {99, 95, 110, 97, 109, 101, 124, 99, 95, 99, 117, 115, 116, 107, 101, 121, 124, 111, 95, 111, 114, 100, 101, 114, 107, 101, 121, 124, 111, 95, 111, 114, 100, 101, 114, 100, 97, 116, 101, 124, 111, 95, 116, 111, 116, 97, 108, 112, 114, 105, 99, 101, 124, 115, 117, 109, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 50, 56, 49, 50, 48, 124, 49, 50, 56, 49, 50, 48, 124, 52, 55, 50, 50, 48, 50, 49, 124, 49, 57, 57, 52, 45, 48, 52, 45, 48, 55, 124, 53, 52, 52, 48, 56, 57, 46, 48, 57, 124, 51, 50, 51, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 52, 54, 49, 55, 124, 49, 52, 52, 54, 49, 55, 124, 51, 48, 52, 51, 50, 55, 48, 124, 49, 57, 57, 55, 45, 48, 50, 45, 49, 50, 124, 53, 51, 48, 54, 48, 52, 46, 52, 52, 124, 51, 49, 55, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 51, 57, 52, 48, 124, 49, 51, 57, 52, 48, 124, 50, 50, 51, 50, 57, 51, 50, 124, 49, 57, 57, 55, 45, 48, 52, 45, 49, 51, 124, 53, 50, 50, 55, 50, 48, 46, 54, 49, 124, 51, 48, 52, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 54, 54, 55, 57, 48, 124, 54, 54, 55, 57, 48, 124, 50, 49, 57, 57, 55, 49, 50, 124, 49, 57, 57, 54, 45, 48, 57, 45, 51, 48, 124, 53, 49, 53, 53, 51, 49, 46, 56, 50, 124, 51, 50, 55, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 52, 54, 52, 51, 53, 124, 52, 54, 52, 51, 53, 124, 52, 55, 52, 53, 54, 48, 55, 124, 49, 57, 57, 55, 45, 48, 55, 45, 48, 51, 124, 53, 48, 56, 48, 52, 55, 46, 57, 57, 124, 51, 48, 57, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 53, 50, 55, 50, 124, 49, 53, 50, 55, 50, 124, 51, 56, 56, 51, 55, 56, 51, 124, 49, 57, 57, 51, 45, 48, 55, 45, 50, 56, 124, 53, 48, 48, 50, 52, 49, 46, 51, 51, 124, 51, 48, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 54, 54, 48, 56, 124, 49, 52, 54, 54, 48, 56, 124, 51, 51, 52, 50, 52, 54, 56, 124, 49, 57, 57, 52, 45, 48, 54, 45, 49, 50, 124, 52, 57, 57, 55, 57, 52, 46, 53, 56, 124, 51, 48, 51, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 57, 54, 49, 48, 51, 124, 57, 54, 49, 48, 51, 124, 53, 57, 56, 52, 53, 56, 50, 124, 49, 57, 57, 50, 45, 48, 51, 45, 49, 54, 124, 52, 57, 52, 51, 57, 56, 46, 55, 57, 124, 51, 49, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 50, 52, 51, 52, 49, 124, 50, 52, 51, 52, 49, 124, 49, 52, 55, 52, 56, 49, 56, 124, 49, 57, 57, 50, 45, 49, 49, 45, 49, 53, 124, 52, 57, 49, 51, 52, 56, 46, 50, 54, 124, 51, 48, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 51, 55, 52, 52, 54, 124, 49, 51, 55, 52, 52, 54, 124, 53, 52, 56, 57, 52, 55, 53, 124, 49, 57, 57, 55, 45, 48, 53, 45, 50, 51, 124, 52, 56, 55, 55, 54, 51, 46, 50, 53, 124, 51, 49, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 48, 55, 53, 57, 48, 124, 49, 48, 55, 53, 57, 48, 124, 52, 50, 54, 55, 55, 53, 49, 124, 49, 57, 57, 52, 45, 49, 49, 45, 48, 52, 124, 52, 56, 53, 49, 52, 49, 46, 51, 56, 124, 51, 48, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 53, 48, 48, 48, 56, 124, 53, 48, 48, 48, 56, 124, 50, 51, 54, 54, 55, 53, 53, 124, 49, 57, 57, 54, 45, 49, 50, 45, 48, 57, 124, 52, 56, 51, 56, 57, 49, 46, 50, 54, 124, 51, 48, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 53, 54, 49, 57, 124, 49, 53, 54, 49, 57, 124, 51, 55, 54, 55, 50, 55, 49, 124, 49, 57, 57, 54, 45, 48, 56, 45, 48, 55, 124, 52, 56, 48, 48, 56, 51, 46, 57, 54, 124, 51, 49, 56, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 55, 55, 50, 54, 48, 124, 55, 55, 50, 54, 48, 124, 49, 52, 51, 54, 53, 52, 52, 124, 49, 57, 57, 50, 45, 48, 57, 45, 49, 50, 124, 52, 55, 57, 52, 57, 57, 46, 52, 51, 124, 51, 48, 55, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 48, 57, 51, 55, 57, 124, 49, 48, 57, 51, 55, 57, 124, 53, 55, 52, 54, 51, 49, 49, 124, 49, 57, 57, 54, 45, 49, 48, 45, 49, 48, 124, 52, 55, 56, 48, 54, 52, 46, 49, 49, 124, 51, 48, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 53, 52, 54, 48, 50, 124, 53, 52, 54, 48, 50, 124, 53, 56, 51, 50, 51, 50, 49, 124, 49, 57, 57, 55, 45, 48, 50, 45, 48, 57, 124, 52, 55, 49, 50, 50, 48, 46, 48, 56, 124, 51, 48, 55, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 48, 53, 57, 57, 53, 124, 49, 48, 53, 57, 57, 53, 124, 50, 48, 57, 54, 55, 48, 53, 124, 49, 57, 57, 52, 45, 48, 55, 45, 48, 51, 124, 52, 54, 57, 54, 57, 50, 46, 53, 56, 124, 51, 48, 55, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 56, 56, 56, 53, 124, 49, 52, 56, 56, 56, 53, 124, 50, 57, 52, 50, 52, 54, 57, 124, 49, 57, 57, 50, 45, 48, 53, 45, 51, 49, 124, 52, 54, 57, 54, 51, 48, 46, 52, 52, 124, 51, 49, 51, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 52, 53, 56, 54, 124, 49, 49, 52, 53, 56, 54, 124, 53, 53, 49, 49, 51, 54, 124, 49, 57, 57, 51, 45, 48, 53, 45, 49, 57, 124, 52, 54, 57, 54, 48, 53, 46, 53, 57, 124, 51, 48, 56, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 48, 53, 50, 54, 48, 124, 49, 48, 53, 50, 54, 48, 124, 53, 50, 57, 54, 49, 54, 55, 124, 49, 57, 57, 54, 45, 48, 57, 45, 48, 54, 124, 52, 54, 57, 51, 54, 48, 46, 53, 55, 124, 51, 48, 51, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 55, 49, 57, 55, 124, 49, 52, 55, 49, 57, 55, 124, 49, 50, 54, 51, 48, 49, 53, 124, 49, 57, 57, 55, 45, 48, 50, 45, 48, 50, 124, 52, 54, 55, 49, 52, 57, 46, 54, 55, 124, 51, 50, 48, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 54, 52, 52, 56, 51, 124, 54, 52, 52, 56, 51, 124, 50, 55, 52, 53, 56, 57, 52, 124, 49, 57, 57, 54, 45, 48, 55, 45, 48, 52, 124, 52, 54, 54, 57, 57, 49, 46, 51, 53, 124, 51, 48, 52, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 51, 54, 53, 55, 51, 124, 49, 51, 54, 53, 55, 51, 124, 50, 55, 54, 49, 51, 55, 56, 124, 49, 57, 57, 54, 45, 48, 53, 45, 51, 49, 124, 52, 54, 49, 50, 56, 50, 46, 55, 51, 124, 51, 48, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 54, 51, 56, 52, 124, 49, 54, 51, 56, 52, 124, 53, 48, 50, 56, 56, 54, 124, 49, 57, 57, 52, 45, 48, 52, 45, 49, 50, 124, 52, 53, 56, 51, 55, 56, 46, 57, 50, 124, 51, 49, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 55, 57, 49, 57, 124, 49, 49, 55, 57, 49, 57, 124, 50, 56, 54, 57, 49, 53, 50, 124, 49, 57, 57, 54, 45, 48, 54, 45, 50, 48, 124, 52, 53, 54, 56, 49, 53, 46, 57, 50, 124, 51, 49, 55, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 50, 50, 53, 49, 124, 49, 50, 50, 53, 49, 124, 55, 51, 53, 51, 54, 54, 124, 49, 57, 57, 51, 45, 49, 49, 45, 50, 52, 124, 52, 53, 53, 49, 48, 55, 46, 50, 54, 124, 51, 48, 57, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 50, 48, 48, 57, 56, 124, 49, 50, 48, 48, 57, 56, 124, 49, 57, 55, 49, 54, 56, 48, 124, 49, 57, 57, 53, 45, 48, 54, 45, 49, 52, 124, 52, 53, 51, 52, 53, 49, 46, 50, 51, 124, 51, 48, 56, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 54, 54, 48, 57, 56, 124, 54, 54, 48, 57, 56, 124, 53, 48, 48, 55, 52, 57, 48, 124, 49, 57, 57, 50, 45, 48, 56, 45, 48, 55, 124, 52, 53, 51, 52, 51, 54, 46, 49, 54, 124, 51, 48, 52, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 55, 48, 55, 54, 124, 49, 49, 55, 48, 55, 54, 124, 52, 50, 57, 48, 54, 53, 54, 124, 49, 57, 57, 55, 45, 48, 50, 45, 48, 53, 124, 52, 52, 57, 53, 52, 53, 46, 56, 53, 124, 51, 48, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 50, 57, 51, 55, 57, 124, 49, 50, 57, 51, 55, 57, 124, 52, 55, 50, 48, 52, 53, 52, 124, 49, 57, 57, 55, 45, 48, 54, 45, 48, 55, 124, 52, 52, 56, 54, 54, 53, 46, 55, 57, 124, 51, 48, 51, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 50, 54, 56, 54, 53, 124, 49, 50, 54, 56, 54, 53, 124, 52, 55, 48, 50, 55, 53, 57, 124, 49, 57, 57, 52, 45, 49, 49, 45, 48, 55, 124, 52, 52, 55, 54, 48, 54, 46, 54, 53, 124, 51, 50, 48, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 56, 56, 56, 55, 54, 124, 56, 56, 56, 55, 54, 124, 57, 56, 51, 50, 48, 49, 124, 49, 57, 57, 51, 45, 49, 50, 45, 51, 48, 124, 52, 52, 54, 55, 49, 55, 46, 52, 54, 124, 51, 48, 52, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 51, 54, 54, 49, 57, 124, 51, 54, 54, 49, 57, 124, 52, 56, 48, 54, 55, 50, 54, 124, 49, 57, 57, 53, 45, 48, 49, 45, 49, 55, 124, 52, 52, 54, 55, 48, 52, 46, 48, 57, 124, 51, 50, 56, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 49, 56, 50, 51, 124, 49, 52, 49, 56, 50, 51, 124, 50, 56, 48, 54, 50, 52, 53, 124, 49, 57, 57, 54, 45, 49, 50, 45, 50, 57, 124, 52, 52, 54, 50, 54, 57, 46, 49, 50, 124, 51, 49, 48, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 53, 51, 48, 50, 57, 124, 53, 51, 48, 50, 57, 124, 50, 54, 54, 50, 50, 49, 52, 124, 49, 57, 57, 51, 45, 48, 56, 45, 49, 51, 124, 52, 52, 54, 49, 52, 52, 46, 52, 57, 124, 51, 48, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 56, 49, 56, 56, 124, 49, 56, 49, 56, 56, 124, 51, 48, 51, 55, 52, 49, 52, 124, 49, 57, 57, 53, 45, 48, 49, 45, 50, 53, 124, 52, 52, 51, 56, 48, 55, 46, 50, 50, 124, 51, 48, 56, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 54, 54, 53, 51, 51, 124, 54, 54, 53, 51, 51, 124, 50, 57, 49, 53, 56, 124, 49, 57, 57, 53, 45, 49, 48, 45, 50, 49, 124, 52, 52, 51, 53, 55, 54, 46, 53, 48, 124, 51, 48, 53, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 51, 55, 55, 50, 57, 124, 51, 55, 55, 50, 57, 124, 52, 49, 51, 52, 51, 52, 49, 124, 49, 57, 57, 53, 45, 48, 54, 45, 50, 57, 124, 52, 52, 49, 48, 56, 50, 46, 57, 55, 124, 51, 48, 57, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 51, 53, 54, 54, 124, 51, 53, 54, 54, 124, 50, 51, 50, 57, 49, 56, 55, 124, 49, 57, 57, 56, 45, 48, 49, 45, 48, 52, 124, 52, 51, 57, 56, 48, 51, 46, 51, 54, 124, 51, 48, 52, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 52, 53, 53, 51, 56, 124, 52, 53, 53, 51, 56, 124, 52, 53, 50, 55, 53, 53, 51, 124, 49, 57, 57, 52, 45, 48, 53, 45, 50, 50, 124, 52, 51, 54, 50, 55, 53, 46, 51, 49, 124, 51, 48, 53, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 56, 49, 53, 56, 49, 124, 56, 49, 53, 56, 49, 124, 52, 55, 51, 57, 54, 53, 48, 124, 49, 57, 57, 53, 45, 49, 49, 45, 48, 52, 124, 52, 51, 53, 52, 48, 53, 46, 57, 48, 124, 51, 48, 53, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 57, 57, 56, 57, 124, 49, 49, 57, 57, 56, 57, 124, 49, 53, 52, 52, 54, 52, 51, 124, 49, 57, 57, 55, 45, 48, 57, 45, 50, 48, 124, 52, 51, 52, 53, 54, 56, 46, 50, 53, 124, 51, 50, 48, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 48, 51, 54, 56, 48, 124, 51, 54, 56, 48, 124, 51, 56, 54, 49, 49, 50, 51, 124, 49, 57, 57, 56, 45, 48, 55, 45, 48, 51, 124, 52, 51, 51, 53, 50, 53, 46, 57, 55, 124, 51, 48, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 51, 49, 51, 49, 124, 49, 49, 51, 49, 51, 49, 124, 57, 54, 55, 51, 51, 52, 124, 49, 57, 57, 53, 45, 49, 50, 45, 49, 53, 124, 52, 51, 50, 57, 53, 55, 46, 55, 53, 124, 51, 48, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 49, 48, 57, 56, 124, 49, 52, 49, 48, 57, 56, 124, 53, 54, 53, 53, 55, 52, 124, 49, 57, 57, 53, 45, 48, 57, 45, 50, 52, 124, 52, 51, 48, 57, 56, 54, 46, 54, 57, 124, 51, 48, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 57, 51, 51, 57, 50, 124, 57, 51, 51, 57, 50, 124, 53, 50, 48, 48, 49, 48, 50, 124, 49, 57, 57, 55, 45, 48, 49, 45, 50, 50, 124, 52, 50, 53, 52, 56, 55, 46, 53, 49, 124, 51, 48, 52, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 53, 54, 51, 49, 124, 49, 53, 54, 51, 49, 124, 49, 56, 52, 53, 48, 53, 55, 124, 49, 57, 57, 52, 45, 48, 53, 45, 49, 50, 124, 52, 49, 57, 56, 55, 57, 46, 53, 57, 124, 51, 48, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 49, 50, 57, 56, 55, 124, 49, 49, 50, 57, 56, 55, 124, 52, 52, 51, 57, 54, 56, 54, 124, 49, 57, 57, 54, 45, 48, 57, 45, 49, 55, 124, 52, 49, 56, 49, 54, 49, 46, 52, 57, 124, 51, 48, 53, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 50, 53, 57, 57, 124, 49, 50, 53, 57, 57, 124, 52, 50, 53, 57, 53, 50, 52, 124, 49, 57, 57, 56, 45, 48, 50, 45, 49, 50, 124, 52, 49, 53, 50, 48, 48, 46, 54, 49, 124, 51, 48, 52, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 48, 53, 52, 49, 48, 124, 49, 48, 53, 52, 49, 48, 124, 52, 52, 55, 56, 51, 55, 49, 124, 49, 57, 57, 54, 45, 48, 51, 45, 48, 53, 124, 52, 49, 50, 55, 53, 52, 46, 53, 49, 124, 51, 48, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 49, 52, 57, 56, 52, 50, 124, 49, 52, 57, 56, 52, 50, 124, 53, 49, 53, 54, 53, 56, 49, 124, 49, 57, 57, 52, 45, 48, 53, 45, 51, 48, 124, 52, 49, 49, 51, 50, 57, 46, 51, 53, 124, 51, 48, 50, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 48, 49, 50, 57, 124, 49, 48, 49, 50, 57, 124, 53, 56, 52, 57, 52, 52, 52, 124, 49, 57, 57, 52, 45, 48, 51, 45, 50, 49, 124, 52, 48, 57, 49, 50, 57, 46, 56, 53, 124, 51, 48, 57, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 54, 57, 57, 48, 52, 124, 54, 57, 57, 48, 52, 124, 49, 55, 52, 50, 52, 48, 51, 124, 49, 57, 57, 54, 45, 49, 48, 45, 49, 57, 124, 52, 48, 56, 53, 49, 51, 46, 48, 48, 124, 51, 48, 53, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 55, 55, 52, 54, 124, 49, 55, 55, 52, 54, 124, 54, 56, 56, 50, 124, 49, 57, 57, 55, 45, 48, 52, 45, 48, 57, 124, 52, 48, 56, 52, 52, 54, 46, 57, 51, 124, 51, 48, 51, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 49, 51, 48, 55, 50, 124, 49, 51, 48, 55, 50, 124, 49, 52, 56, 49, 57, 50, 53, 124, 49, 57, 57, 56, 45, 48, 51, 45, 49, 53, 124, 51, 57, 57, 49, 57, 53, 46, 52, 55, 124, 51, 48, 49, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 56, 50, 52, 52, 49, 124, 56, 50, 52, 52, 49, 124, 56, 53, 55, 57, 53, 57, 124, 49, 57, 57, 52, 45, 48, 50, 45, 48, 55, 124, 51, 56, 50, 53, 55, 57, 46, 55, 52, 124, 51, 48, 53, 10, 67, 117, 115, 116, 111, 109, 101, 114, 35, 48, 48, 48, 48, 56, 56, 55, 48, 51, 124, 56, 56, 55, 48, 51, 124, 50, 57, 57, 53, 48, 55, 54, 124, 49, 57, 57, 52, 45, 48, 49, 45, 51, 48, 124, 51, 54, 51, 56, 49, 50, 46, 49, 50, 124, 51, 48, 50, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q19[] = {114, 101, 118, 101, 110, 117, 101, 10, 51, 48, 56, 51, 56, 52, 51, 46, 48, 53, 55, 56, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q20[] = {115, 95, 110, 97, 109, 101, 124, 115, 95, 97, 100, 100, 114, 101, 115, 115, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 50, 48, 124, 74, 116, 80, 113, 109, 49, 57, 69, 55, 116, 70, 32, 49, 53, 50, 82, 108, 49, 119, 81, 90, 56, 106, 48, 72, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 48, 57, 49, 124, 51, 53, 87, 86, 110, 85, 55, 71, 76, 78, 98, 81, 68, 99, 99, 50, 84, 65, 82, 97, 118, 71, 116, 107, 54, 82, 66, 54, 90, 67, 100, 52, 54, 85, 65, 89, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 48, 53, 124, 65, 108, 114, 120, 53, 84, 78, 44, 104, 100, 110, 71, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 56, 53, 124, 113, 32, 84, 77, 90, 69, 68, 121, 90, 116, 118, 32, 118, 85, 105, 70, 75, 66, 104, 84, 51, 78, 74, 108, 110, 73, 120, 112, 76, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 56, 55, 124, 85, 81, 82, 56, 98, 85, 65, 52, 86, 50, 72, 120, 86, 98, 119, 57, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 53, 52, 124, 119, 83, 76, 99, 67, 87, 52, 48, 81, 56, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 55, 56, 124, 109, 76, 80, 74, 116, 112, 117, 52, 119, 79, 99, 32, 99, 83, 70, 122, 66, 82, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 48, 50, 124, 74, 82, 56, 118, 87, 111, 67, 116, 101, 74, 116, 74, 103, 51, 111, 107, 82, 112, 116, 48, 114, 50, 56, 75, 69, 111, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 51, 48, 124, 48, 66, 118, 111, 101, 119, 67, 80, 103, 50, 115, 99, 79, 69, 102, 117, 76, 57, 51, 70, 82, 75, 113, 83, 120, 72, 109, 100, 104, 119, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 53, 53, 124, 56, 76, 112, 48, 81, 87, 80, 76, 70, 88, 114, 74, 114, 88, 49, 115, 84, 87, 107, 65, 69, 100, 122, 85, 115, 104, 53, 107, 101, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 52, 48, 124, 70, 119, 119, 121, 70, 98, 103, 122, 55, 99, 32, 104, 72, 86, 105, 75, 71, 84, 48, 79, 66, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 50, 57, 124, 67, 65, 79, 71, 89, 67, 66, 116, 84, 86, 84, 55, 97, 66, 49, 112, 54, 113, 72, 98, 120, 70, 54, 86, 86, 104, 88, 97, 72, 76, 103, 84, 112, 73, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 51, 54, 124, 71, 85, 73, 89, 68, 102, 118, 53, 120, 67, 120, 76, 103, 68, 120, 54, 75, 81, 56, 107, 104, 89, 32, 110, 116, 86, 86, 110, 70, 113, 109, 102, 77, 75, 73, 103, 84, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 54, 49, 124, 116, 70, 56, 102, 77, 71, 97, 54, 72, 89, 52, 32, 119, 55, 55, 109, 68, 119, 84, 52, 114, 79, 50, 49, 107, 120, 119, 101, 55, 117, 84, 83, 89, 78, 87, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 56, 55, 124, 121, 32, 109, 81, 55, 78, 72, 106, 86, 98, 100, 113, 110, 98, 89, 114, 57, 32, 76, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 51, 53, 124, 74, 72, 82, 83, 79, 116, 101, 114, 89, 103, 116, 52, 77, 84, 78, 111, 55, 99, 117, 112, 84, 122, 65, 44, 54, 77, 111, 78, 119, 32, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 57, 55, 53, 124, 49, 113, 111, 114, 77, 49, 121, 112, 66, 100, 119, 103, 80, 86, 117, 102, 54, 115, 77, 67, 75, 117, 70, 57, 68, 49, 114, 74, 78, 49, 105, 67, 84, 88, 75, 109, 97, 108, 83, 116, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 50, 54, 51, 124, 65, 97, 52, 32, 85, 69, 76, 83, 49, 74, 113, 89, 55, 113, 73, 106, 110, 105, 119, 67, 87, 105, 67, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 51, 54, 55, 124, 88, 89, 50, 56, 71, 109, 79, 113, 51, 101, 102, 79, 120, 79, 122, 66, 77, 109, 77, 76, 100, 109, 87, 106, 77, 112, 111, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 52, 50, 54, 124, 81, 98, 99, 111, 79, 48, 84, 85, 67, 108, 70, 83, 122, 102, 121, 57, 48, 76, 107, 32, 107, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 52, 52, 54, 124, 71, 79, 74, 82, 106, 102, 100, 54, 90, 57, 85, 81, 44, 102, 105, 117, 80, 122, 54, 67, 79, 53, 71, 68, 71, 86, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 53, 48, 48, 124, 119, 110, 69, 108, 86, 118, 102, 117, 121, 97, 80, 74, 82, 79, 121, 54, 120, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 54, 48, 50, 124, 121, 103, 100, 52, 105, 78, 81, 76, 81, 101, 86, 87, 87, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 54, 50, 54, 124, 55, 74, 117, 100, 57, 116, 54, 120, 90, 78, 122, 108, 69, 66, 44, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 54, 56, 50, 124, 67, 51, 55, 71, 107, 118, 32, 55, 97, 53, 117, 106, 90, 57, 32, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 55, 48, 48, 124, 85, 74, 101, 70, 111, 68, 76, 90, 50, 86, 116, 102, 108, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 55, 50, 54, 124, 56, 77, 57, 50, 84, 56, 121, 55, 106, 89, 88, 122, 109, 118, 67, 65, 78, 84, 116, 113, 82, 56, 71, 72, 117, 84, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 55, 51, 48, 124, 97, 79, 83, 77, 48, 44, 98, 116, 80, 68, 115, 32, 85, 115, 67, 48, 54, 104, 105, 109, 74, 110, 44, 54, 110, 115, 119, 74, 71, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 55, 52, 54, 124, 66, 52, 122, 77, 68, 79, 70, 99, 77, 71, 98, 107, 90, 81, 52, 88, 120, 65, 44, 85, 121, 97, 81, 111, 69, 87, 90, 122, 77, 83, 71, 73, 32, 119, 84, 115, 74, 112, 57, 78, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 56, 48, 54, 124, 102, 82, 88, 87, 76, 121, 49, 56, 68, 102, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 56, 53, 53, 124, 102, 52, 71, 85, 109, 114, 77, 67, 115, 51, 81, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 57, 51, 49, 124, 109, 66, 104, 80, 101, 55, 89, 74, 85, 49, 97, 89, 77, 112, 119, 84, 105, 82, 100, 105, 118, 108, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 48, 50, 50, 124, 115, 78, 118, 77, 80, 108, 51, 84, 105, 78, 90, 66, 79, 89, 86, 51, 119, 50, 88, 88, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 48, 51, 54, 124, 90, 44, 116, 121, 55, 122, 53, 99, 80, 72, 104, 54, 54, 105, 89, 53, 111, 112, 44, 113, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 48, 57, 54, 124, 72, 120, 117, 122, 77, 117, 102, 121, 65, 114, 98, 98, 102, 51, 117, 70, 82, 49, 54, 32, 69, 112, 85, 103, 71, 75, 82, 89, 104, 121, 104, 86, 79, 97, 115, 116, 51, 100, 54, 114, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 49, 49, 55, 124, 102, 57, 121, 71, 75, 104, 67, 70, 106, 104, 83, 52, 74, 114, 51, 83, 104, 48, 120, 32, 114, 100, 106, 103, 110, 116, 119, 72, 32, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 50, 48, 52, 124, 121, 50, 69, 70, 32, 88, 85, 111, 44, 85, 121, 78, 111, 65, 81, 69, 72, 44, 103, 73, 97, 122, 67, 55, 97, 82, 71, 49, 122, 109, 117, 122, 122, 102, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 50, 49, 56, 124, 69, 99, 110, 49, 118, 87, 65, 87, 78, 117, 115, 71, 66, 44, 103, 87, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 50, 52, 51, 124, 69, 56, 99, 109, 53, 89, 104, 77, 99, 54, 85, 82, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 50, 52, 53, 124, 75, 115, 89, 65, 52, 52, 52, 53, 72, 99, 117, 103, 74, 65, 98, 51, 101, 67, 109, 118, 116, 85, 115, 108, 71, 65, 55, 81, 110, 101, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 50, 56, 50, 124, 110, 56, 89, 90, 103, 83, 78, 117, 67, 52, 44, 105, 90, 55, 115, 53, 111, 72, 84, 77, 72, 78, 70, 100, 118, 57, 52, 68, 119, 90, 50, 114, 114, 85, 69, 98, 48, 112, 103, 68, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 48, 51, 124, 69, 111, 67, 52, 76, 67, 112, 85, 50, 99, 117, 69, 80, 75, 99, 75, 121, 84, 70, 121, 77, 71, 70, 66, 71, 107, 70, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 51, 49, 124, 53, 57, 74, 89, 118, 87, 52, 108, 119, 57, 76, 84, 49, 44, 56, 44, 113, 119, 56, 119, 107, 111, 102, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 55, 51, 124, 97, 115, 106, 56, 117, 100, 55, 97, 69, 109, 71, 111, 72, 117, 105, 113, 73, 53, 113, 86, 90, 49, 114, 104, 112, 87, 83, 32, 104, 74, 99, 57, 116, 70, 57, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 52, 49, 57, 124, 66, 116, 78, 112, 97, 79, 90, 87, 105, 86, 71, 86, 69, 53, 51, 82, 87, 76, 50, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 53, 55, 49, 124, 105, 49, 54, 120, 75, 116, 44, 87, 79, 114, 74, 104, 108, 102, 32, 71, 107, 122, 115, 82, 100, 114, 100, 48, 52, 115, 90, 32, 53, 106, 101, 105, 57, 77, 116, 66, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 53, 56, 53, 124, 112, 122, 98, 67, 103, 67, 118, 89, 97, 120, 56, 50, 87, 113, 53, 44, 100, 71, 52, 120, 122, 121, 68, 77, 105, 82, 87, 56, 100, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 54, 50, 57, 124, 48, 113, 118, 48, 65, 87, 49, 66, 83, 122, 121, 82, 51, 32, 115, 68, 111, 68, 75, 49, 89, 79, 113, 109, 51, 50, 118, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 55, 50, 49, 124, 107, 53, 78, 108, 113, 101, 89, 104, 106, 101, 98, 56, 66, 103, 69, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 55, 51, 48, 124, 71, 105, 108, 117, 57, 88, 76, 115, 69, 88, 44, 111, 85, 48, 69, 121, 115, 104, 118, 70, 84, 87, 115, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 55, 55, 53, 124, 117, 110, 79, 70, 81, 111, 81, 112, 110, 87, 74, 74, 106, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 55, 57, 57, 124, 71, 118, 32, 48, 114, 86, 102, 88, 75, 78, 77, 79, 84, 82, 98, 98, 120, 121, 48, 87, 52, 99, 85, 68, 97, 32, 55, 104, 50, 85, 89, 79, 113, 116, 50, 100, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 57, 51, 52, 124, 70, 48, 121, 32, 112, 110, 100, 116, 118, 56, 114, 32, 118, 75, 88, 111, 74, 112, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 57, 52, 49, 124, 101, 81, 78, 78, 80, 82, 114, 83, 50, 55, 110, 103, 77, 71, 49, 117, 98, 44, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 48, 50, 56, 124, 73, 67, 120, 115, 75, 52, 44, 52, 49, 72, 75, 100, 101, 52, 102, 82, 106, 87, 76, 116, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 48, 57, 53, 124, 107, 117, 99, 100, 88, 73, 104, 74, 54, 73, 89, 115, 72, 121, 48, 65, 114, 69, 55, 110, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 49, 52, 51, 124, 75, 78, 67, 70, 75, 75, 85, 44, 83, 120, 56, 71, 106, 74, 84, 122, 85, 65, 76, 56, 66, 71, 73, 76, 103, 82, 73, 108, 72, 68, 112, 106, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 49, 56, 53, 124, 75, 101, 81, 86, 88, 87, 111, 80, 76, 89, 70, 72, 90, 100, 118, 88, 99, 52, 99, 103, 53, 53, 32, 122, 103, 48, 54, 78, 110, 71, 105, 54, 57, 32, 78, 73, 56, 105, 104, 77, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 49, 56, 57, 124, 111, 52, 78, 98, 117, 122, 84, 114, 57, 68, 72, 49, 119, 85, 53, 100, 112, 116, 57, 44, 78, 69, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 48, 49, 124, 110, 83, 84, 116, 118, 32, 85, 105, 48, 121, 48, 66, 100, 122, 87, 98, 52, 84, 54, 115, 110, 117, 103, 73, 104, 69, 104, 110, 49, 52, 121, 77, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 49, 51, 124, 67, 117, 32, 57, 98, 88, 73, 32, 97, 90, 54, 67, 116, 76, 97, 49, 78, 55, 76, 88, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 55, 53, 124, 83, 117, 99, 87, 68, 117, 104, 89, 97, 104, 80, 51, 85, 119, 107, 77, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 56, 56, 124, 110, 110, 78, 76, 100, 122, 84, 109, 86, 54, 80, 48, 117, 102, 55, 121, 66, 67, 105, 75, 51, 102, 87, 116, 50, 85, 120, 72, 74, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 51, 49, 52, 124, 73, 68, 73, 122, 54, 84, 101, 115, 65, 99, 88, 73, 54, 112, 88, 116, 122, 98, 79, 32, 117, 122, 101, 118, 88, 111, 110, 54, 67, 72, 57, 87, 65, 84, 102, 111, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 51, 55, 51, 124, 74, 116, 83, 53, 101, 88, 83, 116, 68, 66, 80, 88, 100, 89, 99, 32, 112, 118, 113, 119, 75, 50, 81, 71, 99, 90, 120, 122, 82, 57, 44, 80, 73, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 52, 50, 49, 124, 57, 74, 88, 78, 121, 83, 52, 86, 67, 77, 68, 76, 108, 52, 67, 120, 68, 108, 74, 32, 76, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 52, 50, 50, 124, 111, 104, 67, 111, 109, 82, 66, 54, 77, 112, 52, 67, 53, 90, 73, 51, 73, 111, 79, 98, 109, 97, 119, 115, 122, 56, 119, 89, 49, 105, 83, 85, 44, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 52, 52, 49, 124, 116, 119, 108, 104, 105, 116, 56, 48, 67, 54, 121, 56, 74, 106, 72, 67, 79, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 53, 57, 48, 124, 32, 116, 84, 82, 111, 102, 102, 117, 65, 80, 49, 111, 80, 67, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 54, 48, 55, 124, 71, 100, 65, 108, 106, 98, 50, 72, 118, 56, 114, 71, 76, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 54, 50, 53, 124, 66, 50, 86, 83, 83, 53, 44, 50, 71, 86, 74, 81, 54, 116, 90, 97, 51, 55, 75, 100, 65, 109, 103, 32, 101, 114, 72, 112, 50, 106, 80, 103, 122, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 55, 50, 51, 124, 73, 49, 109, 66, 44, 100, 109, 116, 121, 74, 112, 102, 79, 56, 114, 100, 69, 104, 56, 32, 109, 121, 117, 104, 85, 86, 80, 101, 70, 115, 57, 66, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 56, 52, 57, 124, 104, 75, 80, 49, 109, 82, 57, 71, 48, 85, 98, 88, 69, 52, 119, 119, 74, 85, 120, 66, 122, 32, 122, 90, 103, 97, 54, 106, 75, 114, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 56, 57, 52, 124, 120, 119, 107, 111, 114, 65, 81, 69, 77, 102, 100, 71, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 57, 52, 49, 124, 99, 69, 80, 44, 86, 70, 97, 76, 112, 101, 57, 85, 90, 83, 99, 85, 52, 103, 65, 49, 105, 114, 82, 119, 116, 120, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 48, 53, 57, 124, 121, 69, 109, 50, 49, 57, 65, 82, 57, 104, 90, 52, 109, 115, 78, 32, 119, 82, 69, 77, 55, 83, 32, 69, 65, 119, 115, 53, 102, 57, 76, 73, 49, 118, 111, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 50, 48, 55, 124, 122, 108, 85, 87, 66, 119, 73, 99, 101, 87, 106, 71, 52, 72, 100, 89, 69, 56, 48, 77, 48, 86, 52, 120, 113, 73, 102, 117, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 50, 51, 54, 124, 79, 70, 48, 106, 98, 122, 104, 69, 107, 73, 67, 117, 50, 122, 56, 66, 68, 82, 118, 69, 66, 71, 120, 52, 72, 32, 121, 48, 69, 111, 78, 104, 83, 99, 85, 56, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 50, 55, 56, 124, 81, 112, 78, 78, 80, 67, 112, 117, 105, 53, 67, 114, 110, 73, 82, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 50, 56, 49, 124, 44, 99, 118, 98, 106, 75, 114, 98, 75, 73, 117, 77, 120, 122, 48, 74, 49, 56, 86, 77, 114, 89, 88, 104, 110, 100, 73, 66, 118, 71, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 51, 48, 52, 124, 75, 97, 111, 113, 115, 87, 82, 71, 48, 106, 103, 70, 66, 89, 111, 104, 54, 32, 79, 112, 106, 102, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 51, 52, 54, 124, 57, 88, 44, 84, 85, 103, 109, 99, 118, 67, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 52, 48, 54, 124, 114, 74, 44, 49, 81, 103, 120, 85, 53, 118, 121, 76, 98, 52, 54, 116, 48, 84, 71, 80, 52, 75, 50, 49, 74, 82, 120, 109, 81, 106, 66, 107, 105, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 52, 51, 48, 124, 117, 119, 56, 122, 103, 101, 56, 55, 102, 86, 107, 102, 51, 112, 109, 56, 87, 70, 120, 99, 32, 98, 100, 102, 117, 104, 115, 113, 101, 71, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 53, 50, 55, 124, 67, 114, 66, 53, 51, 112, 68, 117, 75, 79, 72, 70, 52, 108, 85, 114, 90, 67, 88, 99, 107, 50, 88, 65, 52, 86, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 54, 53, 53, 124, 86, 84, 100, 65, 112, 80, 87, 114, 121, 88, 99, 107, 88, 108, 83, 82, 99, 114, 105, 122, 66, 52, 100, 65, 87, 72, 107, 81, 98, 67, 119, 50, 102, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 56, 53, 49, 124, 97, 72, 48, 117, 85, 106, 75, 102, 55, 84, 72, 112, 102, 82, 82, 69, 65, 66, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 56, 55, 49, 124, 49, 66, 74, 66, 121, 86, 113, 52, 109, 68, 55, 56, 83, 121, 87, 114, 119, 80, 86, 44, 65, 108, 76, 78, 75, 85, 99, 82, 79, 85, 69, 54, 83, 117, 117, 120, 83, 77, 111, 86, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 56, 56, 52, 124, 88, 89, 49, 90, 120, 103, 116, 77, 82, 68, 32, 68, 85, 81, 55, 108, 112, 100, 78, 114, 79, 105, 83, 114, 117, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 57, 55, 53, 124, 108, 98, 65, 86, 98, 102, 103, 50, 85, 52, 117, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 48, 55, 54, 124, 52, 70, 84, 74, 82, 74, 76, 75, 119, 105, 107, 69, 65, 117, 108, 103, 75, 52, 76, 106, 104, 87, 107, 72, 81, 120, 114, 112, 71, 98, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 49, 57, 53, 124, 53, 67, 73, 88, 80, 90, 49, 81, 73, 79, 99, 74, 114, 49, 56, 77, 120, 90, 109, 76, 52, 74, 109, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 50, 53, 54, 124, 100, 68, 79, 88, 121, 87, 84, 53, 113, 101, 80, 74, 69, 48, 66, 70, 67, 53, 102, 81, 55, 83, 80, 99, 100, 69, 73, 82, 100, 122, 121, 81, 101, 114, 98, 116, 101, 101, 108, 115, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 50, 53, 55, 124, 77, 82, 75, 83, 56, 110, 106, 112, 84, 67, 81, 101, 72, 88, 97, 52, 113, 72, 51, 56, 90, 119, 76, 50, 50, 90, 89, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 51, 48, 48, 124, 76, 51, 107, 89, 83, 51, 65, 66, 117, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 51, 50, 51, 124, 122, 101, 111, 71, 78, 66, 80, 110, 67, 116, 101, 67, 83, 119, 101, 106, 71, 115, 72, 112, 66, 50, 77, 117, 67, 97, 113, 120, 119, 48, 56, 85, 114, 65, 115, 80, 120, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 51, 56, 54, 124, 55, 80, 85, 113, 113, 77, 106, 66, 52, 102, 53, 98, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 52, 50, 54, 124, 83, 110, 115, 89, 99, 54, 55, 90, 65, 114, 32, 80, 87, 112, 103, 85, 90, 70, 72, 97, 44, 51, 72, 98, 112, 51, 57, 98, 119, 99, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 52, 54, 53, 124, 86, 88, 79, 50, 49, 78, 68, 49, 112, 57, 50, 85, 90, 88, 97, 44, 108, 81, 67, 107, 48, 49, 122, 69, 68, 112, 86, 115, 70, 82, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 52, 56, 52, 124, 32, 81, 108, 78, 99, 97, 114, 65, 52, 84, 114, 108, 50, 48, 88, 82, 122, 98, 65, 73, 74, 113, 81, 90, 90, 102, 67, 89, 89, 66, 112, 67, 100, 44, 112, 122, 98, 32, 103, 67, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 53, 48, 53, 124, 79, 89, 122, 80, 72, 108, 87, 88, 103, 118, 102, 98, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 53, 48, 54, 124, 100, 68, 114, 76, 86, 117, 66, 115, 67, 52, 76, 112, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 54, 51, 49, 124, 44, 87, 55, 53, 32, 73, 70, 115, 67, 89, 57, 104, 109, 112, 50, 112, 110, 75, 66, 101, 119, 55, 70, 119, 118, 57, 65, 111, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 54, 52, 50, 124, 50, 118, 103, 117, 113, 120, 88, 53, 87, 44, 122, 52, 114, 109, 83, 99, 84, 97, 118, 120, 49, 115, 70, 120, 48, 72, 98, 122, 102, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 54, 56, 54, 124, 77, 89, 57, 112, 103, 78, 79, 89, 55, 90, 101, 105, 73, 84, 116, 57, 114, 101, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 55, 51, 48, 124, 87, 32, 71, 80, 44, 99, 56, 77, 118, 122, 115, 106, 119, 117, 71, 103, 83, 104, 81, 110, 88, 90, 54, 66, 68, 57, 108, 89, 79, 75, 84, 106, 90, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 55, 51, 54, 124, 90, 78, 65, 114, 51, 56, 50, 74, 121, 50, 53, 56, 76, 66, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 55, 51, 55, 124, 79, 69, 109, 52, 79, 57, 88, 89, 111, 88, 72, 117, 48, 78, 48, 113, 82, 86, 114, 99, 70, 50, 68, 87, 83, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 55, 57, 55, 124, 49, 67, 48, 99, 77, 81, 118, 57, 80, 56, 111, 69, 53, 70, 82, 76, 100, 82, 76, 66, 53, 98, 111, 73, 65, 113, 114, 54, 67, 75, 120, 70, 56, 57, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 56, 55, 53, 124, 71, 103, 48, 122, 50, 74, 107, 115, 112, 82, 88, 74, 56, 116, 106, 117, 82, 117, 119, 56, 50, 108, 80, 53, 97, 101, 111, 49, 77, 89, 103, 51, 49, 120, 107, 81, 56, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 57, 55, 52, 124, 97, 109, 74, 57, 86, 73, 109, 48, 70, 102, 121, 122, 97, 51, 119, 77, 86, 87, 56, 118, 51, 116, 56, 75, 122, 57, 56, 53, 108, 74, 121, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 48, 53, 57, 124, 88, 69, 44, 79, 119, 84, 101, 118, 104, 82, 117, 51, 89, 119, 70, 119, 105, 114, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 48, 54, 53, 124, 55, 73, 105, 89, 111, 117, 88, 52, 87, 55, 121, 86, 122, 102, 71, 115, 102, 120, 119, 51, 103, 57, 116, 85, 103, 74, 74, 70, 107, 119, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 48, 57, 51, 124, 104, 104, 100, 54, 75, 44, 67, 78, 54, 55, 90, 118, 121, 111, 56, 90, 122, 85, 98, 32, 107, 88, 110, 85, 76, 79, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 48, 57, 57, 124, 82, 49, 73, 70, 118, 98, 103, 50, 110, 55, 54, 98, 67, 103, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 49, 48, 57, 124, 65, 50, 86, 75, 80, 77, 74, 88, 78, 103, 107, 68, 116, 70, 79, 98, 54, 55, 98, 107, 112, 118, 68, 80, 77, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 50, 49, 55, 124, 97, 53, 100, 89, 88, 57, 50, 55, 82, 72, 78, 68, 54, 77, 81, 53, 107, 51, 54, 78, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 50, 57, 55, 124, 85, 88, 53, 57, 110, 100, 99, 86, 85, 107, 55, 111, 116, 119, 79, 88, 44, 67, 50, 104, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 52, 51, 53, 124, 118, 105, 75, 109, 85, 83, 51, 122, 115, 50, 81, 68, 99, 87, 109, 68, 68, 84, 79, 106, 107, 99, 83, 116, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 52, 54, 51, 124, 85, 114, 118, 71, 78, 73, 89, 109, 99, 87, 83, 73, 67, 121, 70, 78, 116, 89, 71, 69, 106, 101, 114, 113, 110, 67, 102, 56, 122, 115, 108, 53, 88, 57, 100, 53, 72, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 52, 55, 56, 124, 81, 97, 50, 98, 68, 73, 82, 70, 66, 69, 53, 88, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 53, 50, 49, 124, 81, 82, 114, 89, 115, 73, 106, 115, 117, 57, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 54, 52, 50, 124, 101, 48, 111, 54, 79, 71, 56, 65, 57, 102, 105, 79, 56, 83, 115, 98, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 54, 53, 57, 124, 74, 55, 102, 122, 68, 120, 110, 83, 110, 89, 108, 115, 52, 100, 54, 120, 114, 71, 57, 105, 69, 118, 57, 72, 71, 87, 32, 110, 77, 109, 70, 76, 120, 66, 90, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 54, 54, 57, 124, 101, 97, 87, 50, 32, 117, 72, 85, 89, 87, 67, 84, 103, 86, 88, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 55, 52, 56, 124, 65, 111, 48, 89, 32, 110, 68, 83, 75, 103, 111, 105, 56, 86, 97, 48, 79, 104, 109, 67, 74, 108, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 55, 54, 49, 124, 69, 87, 72, 74, 117, 108, 101, 65, 112, 86, 67, 32, 110, 90, 106, 75, 66, 102, 119, 118, 65, 52, 56, 121, 99, 103, 70, 70, 81, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 56, 48, 56, 124, 107, 107, 78, 89, 51, 68, 114, 82, 68, 109, 80, 106, 104, 74, 49, 120, 51, 72, 51, 117, 53, 103, 105, 66, 113, 67, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 56, 53, 56, 124, 77, 68, 70, 105, 100, 56, 83, 83, 86, 119, 113, 112, 74, 122, 52, 119, 55, 107, 73, 49, 48, 68, 89, 89, 121, 75, 118, 107, 50, 90, 86, 74, 114, 107, 106, 105, 72, 89, 90, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 57, 52, 54, 124, 56, 67, 85, 56, 70, 68, 44, 107, 104, 55, 66, 79, 105, 119, 110, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 57, 52, 57, 124, 70, 102, 117, 50, 54, 105, 74, 122, 107, 79, 103, 121, 103, 77, 114, 49, 107, 108, 73, 32, 101, 120, 90, 83, 88, 114, 119, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 48, 55, 50, 124, 90, 121, 57, 116, 51, 83, 101, 90, 81, 114, 88, 57, 79, 69, 86, 85, 122, 84, 84, 82, 109, 90, 113, 100, 107, 83, 72, 70, 66, 103, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 48, 57, 56, 124, 108, 88, 72, 83, 75, 48, 104, 111, 87, 99, 80, 80, 113, 120, 89, 100, 53, 67, 98, 106, 65, 51, 97, 52, 101, 112, 54, 78, 72, 65, 84, 118, 75, 111, 106, 100, 109, 117, 120, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 49, 51, 50, 124, 118, 67, 68, 119, 68, 48, 104, 113, 97, 105, 103, 88, 66, 83, 71, 51, 71, 114, 106, 111, 44, 108, 56, 56, 110, 57, 54, 56, 55, 111, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 49, 51, 53, 124, 71, 122, 114, 110, 67, 104, 53, 84, 53, 86, 121, 70, 76, 97, 116, 83, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 49, 52, 55, 124, 52, 115, 80, 90, 85, 72, 111, 85, 88, 118, 70, 102, 53, 50, 77, 118, 54, 109, 75, 112, 48, 75, 51, 108, 119, 107, 71, 72, 55, 86, 74, 98, 66, 65, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 49, 54, 48, 124, 56, 65, 110, 107, 112, 55, 102, 112, 88, 79, 56, 65, 105, 55, 85, 109, 103, 110, 119, 69, 83, 112, 56, 87, 77, 88, 119, 48, 115, 118, 51, 73, 97, 98, 80, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 49, 54, 57, 124, 122, 109, 79, 82, 86, 111, 89, 69, 67, 100, 83, 56, 83, 87, 68, 79, 86, 86, 99, 48, 79, 70, 68, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 50, 55, 56, 124, 106, 89, 81, 77, 88, 65, 56, 84, 103, 53, 109, 83, 107, 53, 106, 122, 112, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 51, 54, 53, 124, 87, 90, 117, 74, 57, 100, 102, 119, 97, 101, 105, 44, 86, 110, 68, 79, 121, 49, 52, 121, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 51, 57, 56, 124, 54, 83, 77, 109, 85, 68, 49, 44, 44, 99, 109, 100, 54, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 52, 48, 50, 124, 88, 54, 53, 119, 86, 84, 77, 32, 116, 90, 65, 72, 69, 65, 56, 97, 86, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 52, 52, 56, 124, 117, 74, 74, 66, 52, 74, 104, 73, 84, 109, 105, 85, 97, 86, 53, 112, 81, 97, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 52, 53, 56, 124, 113, 50, 120, 120, 79, 82, 66, 50, 71, 66, 122, 49, 70, 85, 76, 69, 78, 89, 97, 81, 111, 116, 49, 69, 105, 83, 75, 57, 90, 105, 75, 90, 85, 77, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 52, 55, 55, 124, 83, 69, 82, 72, 44, 119, 76, 74, 52, 115, 112, 119, 53, 106, 117, 72, 54, 48, 98, 66, 114, 117, 118, 56, 106, 48, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 53, 48, 57, 124, 66, 83, 48, 53, 85, 103, 104, 57, 67, 106, 105, 72, 106, 79, 99, 121, 56, 107, 84, 81, 103, 55, 101, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 53, 54, 49, 124, 65, 101, 79, 108, 75, 90, 86, 88, 44, 53, 112, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 54, 49, 54, 124, 97, 114, 105, 67, 119, 106, 65, 115, 110, 73, 89, 48, 97, 106, 68, 82, 65, 49, 71, 90, 118, 56, 87, 74, 107, 114, 75, 77, 70, 74, 99, 87, 116, 72, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 55, 54, 48, 124, 105, 122, 98, 109, 90, 84, 98, 119, 79, 78, 109, 55, 103, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 56, 48, 49, 124, 86, 82, 76, 73, 48, 55, 90, 32, 85, 77, 69, 54, 80, 114, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 56, 54, 53, 124, 87, 79, 110, 107, 111, 57, 48, 55, 85, 100, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 56, 56, 53, 124, 121, 88, 122, 73, 79, 80, 74, 74, 86, 49, 67, 116, 55, 54, 66, 101, 90, 79, 104, 103, 101, 79, 113, 67, 81, 81, 105, 52, 75, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 57, 50, 54, 124, 110, 32, 115, 111, 108, 84, 44, 103, 82, 54, 117, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 57, 57, 56, 124, 103, 68, 113, 56, 108, 113, 76, 50, 57, 108, 100, 67, 82, 78, 85, 79, 48, 81, 122, 112, 120, 53, 65, 82, 102, 68, 89, 98, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 48, 57, 48, 124, 78, 67, 68, 80, 104, 50, 119, 67, 110, 108, 51, 112, 100, 54, 73, 69, 50, 76, 66, 85, 117, 109, 57, 105, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 50, 50, 52, 124, 56, 52, 117, 121, 82, 77, 48, 102, 53, 109, 97, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 50, 51, 49, 124, 106, 103, 84, 77, 107, 119, 114, 50, 72, 82, 48, 32, 55, 78, 66, 32, 98, 48, 119, 79, 66, 52, 117, 102, 112, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 50, 52, 51, 124, 90, 113, 116, 77, 98, 102, 71, 110, 65, 69, 116, 53, 115, 72, 107, 56, 73, 115, 51, 121, 75, 108, 102, 67, 83, 75, 114, 109, 73, 120, 79, 111, 101, 117, 99, 70, 105, 105, 107, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 51, 50, 51, 124, 85, 86, 105, 90, 83, 32, 49, 69, 113, 56, 119, 69, 114, 98, 99, 78, 74, 77, 57, 101, 79, 72, 82, 121, 69, 67, 116, 77, 97, 48, 113, 76, 111, 51, 100, 87, 112, 105, 113, 80, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 51, 54, 54, 124, 75, 84, 84, 83, 79, 110, 72, 90, 87, 112, 121, 52, 82, 99, 109, 104, 70, 119, 98, 55, 53, 65, 87, 73, 118, 114, 56, 57, 85, 109, 113, 112, 51, 100, 84, 116, 77, 56, 83, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 53, 51, 50, 124, 55, 79, 89, 82, 65, 88, 48, 86, 117, 53, 79, 110, 99, 108, 83, 85, 54, 49, 32, 117, 75, 32, 87, 117, 52, 57, 44, 73, 74, 109, 55, 51, 120, 74, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 53, 57, 53, 124, 102, 106, 44, 73, 112, 85, 88, 107, 97, 88, 116, 114, 54, 52, 88, 100, 114, 110, 80, 111, 81, 65, 69, 79, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 54, 49, 48, 124, 57, 75, 53, 75, 98, 83, 44, 119, 98, 87, 87, 89, 122, 54, 100, 56, 75, 115, 102, 82, 116, 103, 118, 51, 106, 52, 113, 115, 53, 85, 122, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 54, 56, 51, 124, 76, 102, 120, 107, 79, 121, 75, 76, 66, 104, 57, 77, 107, 97, 113, 97, 68, 81, 106, 100, 112, 81, 52, 68, 107, 82, 65, 122, 100, 68, 73, 116, 70, 89, 44, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 55, 48, 53, 124, 82, 109, 48, 121, 32, 97, 100, 78, 98, 117, 49, 87, 116, 73, 68, 56, 110, 82, 99, 88, 111, 77, 80, 110, 105, 67, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 55, 52, 50, 124, 107, 69, 98, 70, 97, 110, 115, 103, 111, 98, 110, 79, 55, 54, 102, 44, 87, 48, 71, 103, 66, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 56, 52, 49, 124, 106, 114, 83, 86, 102, 121, 90, 122, 77, 71, 81, 75, 89, 117, 32, 57, 105, 115, 69, 44, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 56, 55, 50, 124, 84, 110, 114, 87, 86, 108, 75, 117, 104, 99, 90, 99, 118, 118, 50, 99, 82, 56, 87, 113, 82, 51, 104, 103, 119, 111, 118, 98, 76, 102, 102, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 56, 55, 57, 124, 65, 110, 56, 113, 48, 111, 82, 67, 98, 101, 49, 85, 86, 100, 101, 53, 109, 108, 32, 69, 108, 103, 113, 120, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 57, 54, 55, 124, 90, 71, 118, 109, 106, 117, 101, 107, 114, 84, 109, 118, 67, 115, 100, 106, 69, 113, 54, 109, 86, 69, 106, 44, 74, 51, 121, 65, 50, 79, 121, 70, 104, 101, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 57, 55, 50, 124, 119, 89, 119, 108, 85, 115, 110, 86, 50, 49, 100, 88, 119, 73, 122, 99, 51, 122, 65, 53, 77, 102, 113, 110, 55, 104, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 48, 51, 50, 124, 66, 103, 48, 121, 32, 113, 85, 56, 78, 116, 88, 110, 115, 90, 112, 97, 54, 108, 100, 116, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 48, 52, 51, 124, 87, 84, 99, 98, 119, 104, 106, 87, 65, 116, 52, 105, 49, 84, 105, 116, 50, 77, 111, 81, 119, 90, 90, 81, 86, 101, 90, 103, 73, 82, 77, 90, 52, 52, 69, 54, 97, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 50, 55, 56, 124, 97, 65, 50, 55, 115, 76, 117, 72, 82, 88, 112, 102, 51, 114, 44, 70, 79, 50, 76, 111, 110, 100, 99, 77, 76, 111, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 51, 50, 54, 124, 52, 69, 73, 111, 48, 121, 116, 88, 85, 112, 83, 48, 76, 80, 44, 116, 74, 79, 72, 81, 82, 75, 73, 51, 97, 121, 121, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 52, 51, 48, 124, 74, 75, 57, 65, 69, 69, 77, 108, 121, 114, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 53, 52, 57, 124, 75, 88, 57, 53, 79, 75, 54, 76, 83, 101, 116, 50, 87, 85, 105, 116, 80, 49, 44, 68, 76, 44, 82, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 54, 48, 49, 124, 87, 90, 69, 85, 88, 85, 80, 99, 48, 57, 119, 86, 110, 68, 106, 53, 108, 54, 119, 102, 82, 79, 57, 117, 82, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 55, 48, 57, 124, 65, 57, 68, 111, 80, 107, 50, 75, 110, 75, 71, 82, 98, 49, 50, 69, 116, 52, 103, 53, 51, 56, 54, 52, 44, 120, 103, 75, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 55, 53, 51, 124, 119, 102, 74, 53, 109, 80, 57, 69, 78, 84, 99, 71, 104, 108, 87, 109, 112, 68, 107, 103, 85, 49, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 55, 57, 57, 124, 115, 87, 118, 100, 72, 52, 107, 81, 87, 99, 104, 52, 70, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 56, 49, 49, 124, 110, 88, 73, 120, 116, 66, 84, 54, 68, 49, 118, 54, 84, 67, 98, 50, 105, 77, 89, 107, 121, 85, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 56, 49, 50, 124, 114, 98, 108, 57, 101, 117, 88, 70, 111, 80, 76, 108, 75, 81, 86, 89, 68, 86, 121, 82, 111, 117, 115, 108, 98, 98, 98, 75, 68, 72, 65, 107, 121, 88, 89, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 56, 52, 54, 124, 87, 84, 122, 100, 118, 105, 104, 88, 98, 121, 113, 110, 120, 48, 74, 102, 98, 98, 86, 97, 120, 66, 79, 99, 79, 57, 100, 57, 51, 68, 89, 98, 116, 66, 104, 105, 32, 74, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 56, 57, 57, 124, 85, 51, 78, 66, 113, 107, 32, 115, 32, 90, 122, 48, 54, 97, 108, 50, 109, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 57, 55, 52, 124, 85, 118, 104, 48, 104, 87, 110, 103, 79, 117, 57, 54, 87, 103, 66, 44, 79, 97, 102, 66, 81, 79, 113, 119, 112, 87, 113, 122, 119, 103, 56, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q21[] = {115, 95, 110, 97, 109, 101, 124, 110, 117, 109, 119, 97, 105, 116, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 56, 50, 57, 124, 50, 48, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 56, 48, 56, 124, 49, 56, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 50, 54, 50, 124, 49, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 57, 54, 124, 49, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 49, 54, 48, 124, 49, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 48, 49, 124, 49, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 53, 52, 48, 124, 49, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 48, 54, 51, 124, 49, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 49, 55, 56, 124, 49, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 51, 51, 49, 124, 49, 55, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 48, 48, 53, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 48, 57, 53, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 55, 57, 57, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 56, 52, 50, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 52, 53, 48, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 57, 51, 57, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 50, 48, 48, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 55, 50, 55, 124, 49, 54, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 56, 54, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 53, 54, 53, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 48, 52, 54, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 48, 52, 55, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 49, 54, 49, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 51, 51, 54, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 52, 51, 53, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 48, 55, 53, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 51, 51, 53, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 54, 52, 57, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 48, 50, 55, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 55, 57, 53, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 56, 48, 48, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 56, 50, 52, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 49, 51, 49, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 51, 56, 50, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 57, 49, 51, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 55, 56, 55, 124, 49, 53, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 51, 51, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 57, 54, 48, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 50, 51, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 52, 57, 48, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 57, 57, 51, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 49, 48, 49, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 52, 56, 57, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 52, 51, 53, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 53, 56, 51, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 55, 55, 52, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 53, 55, 57, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 49, 56, 48, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 54, 57, 53, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 50, 50, 52, 124, 49, 52, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 53, 55, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 52, 51, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 49, 48, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 56, 56, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 56, 57, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 48, 54, 50, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 52, 57, 56, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 48, 53, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 49, 50, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 52, 52, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 53, 57, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 54, 49, 53, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 57, 55, 56, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 48, 52, 56, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 50, 51, 52, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 55, 50, 55, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 51, 56, 48, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 52, 52, 55, 50, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 50, 51, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 53, 57, 48, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 50, 52, 49, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 51, 50, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 51, 56, 52, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 51, 57, 52, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 54, 50, 52, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 54, 50, 57, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 54, 56, 50, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 55, 51, 55, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 54, 56, 50, 53, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 48, 50, 49, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 52, 49, 55, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 52, 57, 55, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 55, 54, 48, 50, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 49, 51, 52, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 56, 50, 51, 52, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 52, 51, 53, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 52, 51, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 53, 54, 52, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 57, 56, 57, 54, 124, 49, 51, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 51, 55, 57, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 54, 55, 51, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 55, 54, 50, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 49, 49, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 48, 56, 50, 49, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 51, 51, 55, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 57, 49, 54, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 49, 57, 50, 53, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 48, 51, 57, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 51, 53, 55, 124, 49, 50, 10, 83, 117, 112, 112, 108, 105, 101, 114, 35, 48, 48, 48, 48, 48, 50, 52, 56, 51, 124, 49, 50, 10, 0};
-const uint8_t TPCH_ANSWERS_SF1_q22[] = {99, 110, 116, 114, 121, 99, 111, 100, 101, 124, 110, 117, 109, 99, 117, 115, 116, 124, 116, 111, 116, 97, 99, 99, 116, 98, 97, 108, 10, 49, 51, 124, 56, 56, 56, 124, 54, 55, 51, 55, 55, 49, 51, 46, 57, 57, 10, 49, 55, 124, 56, 54, 49, 124, 54, 52, 54, 48, 53, 55, 51, 46, 55, 50, 10, 49, 56, 124, 57, 54, 52, 124, 55, 50, 51, 54, 54, 56, 55, 46, 52, 48, 10, 50, 51, 124, 56, 57, 50, 124, 54, 55, 48, 49, 52, 53, 55, 46, 57, 53, 10, 50, 57, 124, 57, 52, 56, 124, 55, 49, 53, 56, 56, 54, 54, 46, 54, 51, 10, 51, 48, 124, 57, 48, 57, 124, 54, 56, 48, 56, 52, 51, 54, 46, 49, 51, 10, 51, 49, 124, 57, 50, 50, 124, 54, 56, 48, 54, 54, 55, 48, 46, 49, 56, 10, 0};
-const char *TPCH_ANSWERS_SF1[] = {
-	(const char*) TPCH_ANSWERS_SF1_q01,
-	(const char*) TPCH_ANSWERS_SF1_q02,
-	(const char*) TPCH_ANSWERS_SF1_q03,
-	(const char*) TPCH_ANSWERS_SF1_q04,
-	(const char*) TPCH_ANSWERS_SF1_q05,
-	(const char*) TPCH_ANSWERS_SF1_q06,
-	(const char*) TPCH_ANSWERS_SF1_q07,
-	(const char*) TPCH_ANSWERS_SF1_q08,
-	(const char*) TPCH_ANSWERS_SF1_q09,
-	(const char*) TPCH_ANSWERS_SF1_q10,
-	(const char*) TPCH_ANSWERS_SF1_q11,
-	(const char*) TPCH_ANSWERS_SF1_q12,
-	(const char*) TPCH_ANSWERS_SF1_q13,
-	(const char*) TPCH_ANSWERS_SF1_q14,
-	(const char*) TPCH_ANSWERS_SF1_q15,
-	(const char*) TPCH_ANSWERS_SF1_q16,
-	(const char*) TPCH_ANSWERS_SF1_q17,
-	(const char*) TPCH_ANSWERS_SF1_q18,
-	(const char*) TPCH_ANSWERS_SF1_q19,
-	(const char*) TPCH_ANSWERS_SF1_q20,
-	(const char*) TPCH_ANSWERS_SF1_q21,
-	(const char*) TPCH_ANSWERS_SF1_q22
-};
diff --git a/velox/external/duckdb/tpch/dbgen/permute.cpp b/velox/external/duckdb/tpch/dbgen/permute.cpp
deleted file mode 100644
index 6ef80d1afd6c0..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/permute.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- *//*
- * permute.c -- a permutation generator for the query
- *              sequences in TPC-H and TPC-R
- */
-
-#include "dbgen/config.h"
-#include "dbgen/dss.h"
-
-DSS_HUGE NextRand(DSS_HUGE seed);
-void permute(long *set, int cnt, seed_t *seed);
-void permute_dist(distribution *d, seed_t *seed);
-long seed;
-char *eol[2] = {" ", "},"};
-
-#define MAX_QUERY 22
-#define ITERATIONS 1000
-#define UNSET 0
-
-void permute(long *a, int c, seed_t *seed) {
-	int i;
-	static DSS_HUGE source;
-	static long temp;
-
-	if (a != (long *)NULL) {
-		for (i = 0; i < c; i++) {
-			RANDOM(source, (long)i, (long)(c - 1), seed);
-			temp = *(a + source);
-			*(a + source) = *(a + i);
-			*(a + i) = temp;
-		}
-	}
-
-	return;
-}
-
-void permute_dist(distribution *d, seed_t *seed) {
-	int i;
-
-	if (d != NULL) {
-		if (d->permute == (long *)NULL) {
-			d->permute = (long *)malloc(sizeof(long) * DIST_SIZE(d));
-			MALLOC_CHECK(d->permute);
-		}
-		for (i = 0; i < DIST_SIZE(d); i++)
-			*(d->permute + i) = i;
-		permute(d->permute, DIST_SIZE(d), seed);
-	} else
-		INTERNAL_ERROR("Bad call to permute_dist");
-
-	return;
-}
diff --git a/velox/external/duckdb/tpch/dbgen/rnd.cpp b/velox/external/duckdb/tpch/dbgen/rnd.cpp
deleted file mode 100644
index 68a1cfca40195..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/rnd.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- *//*
- * RANDOM.C -- Implements Park & Miller's "Minimum Standard" RNG
- *
- * (Reference:  CACM, Oct 1988, pp 1192-1201)
- *
- * NextRand:  Computes next random integer
- * UnifInt:   Yields an long uniformly distributed between given bounds
- * UnifReal: ields a real uniformly distributed between given bounds
- * Exponential: Yields a real exponentially distributed with given mean
- *
- */
-
-#include "dbgen/config.h"
-
-#include <math.h>
-#include <stdio.h>
-#include <stdint.h>
-#include "dbgen/dss.h"
-#include "dbgen/rnd.h"
-
-const char *tpch_env_config PROTO((const char *tag, const char *dflt));
-void NthElement(DSS_HUGE, DSS_HUGE *);
-
-void dss_random(DSS_HUGE *tgt, DSS_HUGE lower, DSS_HUGE upper, seed_t *seed) {
-	*tgt = UnifInt(lower, upper, seed);
-	seed->usage += 1;
-
-	return;
-}
-
-void row_start(int t, DBGenContext *ctx) {
-	(void)t;
-	int i;
-	for (i = 0; i <= MAX_STREAM; i++)
-		ctx->Seed[i].usage = 0;
-
-	return;
-}
-
-void row_stop_h(int t, DBGenContext *ctx) {
-	int i;
-
-	/* need to allow for handling the master and detail together */
-	if (t == ORDER_LINE)
-		t = ORDER;
-	if (t == PART_PSUPP)
-		t = PART;
-
-	for (i = 0; i <= MAX_STREAM; i++)
-		if ((ctx->Seed[i].table == t) || (ctx->Seed[i].table == ctx->tdefs[t].child)) {
-			if (set_seeds && (ctx->Seed[i].usage > ctx->Seed[i].boundary)) {
-				fprintf(stderr, "\nSEED CHANGE: seed[%d].usage = " HUGE_FORMAT "\n", i, ctx->Seed[i].usage);
-				ctx->Seed[i].boundary = ctx->Seed[i].usage;
-			} else {
-				NthElement((ctx->Seed[i].boundary - ctx->Seed[i].usage), &ctx->Seed[i].value);
-#ifdef RNG_TEST
-				ctx->Seed[i].nCalls += ctx->Seed[i].boundary - ctx->Seed[i].usage;
-#endif
-			}
-		}
-	return;
-}
-
-void dump_seeds(int tbl, seed_t *seeds) {
-	int i;
-
-	for (i = 0; i <= MAX_STREAM; i++)
-		if (seeds[i].table == tbl)
-#ifdef RNG_TEST
-			printf("%d(" HUGE_FORMAT "):\t" HUGE_FORMAT "\n", i, seeds[i].nCalls, seeds[i].value);
-#else
-			printf("%d:\t" HUGE_FORMAT "\n", i, seeds[i].value);
-#endif
-	return;
-}
-
-/******************************************************************
-
-   NextRand:  Computes next random integer
-
-*******************************************************************/
-
-/*
- * long NextRand( long nSeed )
- */
-DSS_HUGE
-NextRand(DSS_HUGE nSeed)
-
-/*
- * nSeed is the previous random number; the returned value is the
- * next random number. The routine generates all numbers in the
- * range 1 .. nM-1.
- */
-
-{
-	nSeed = (nSeed * 16807) % 2147483647;
-	return (nSeed);
-}
-
-/******************************************************************
-
-   UnifInt:  Yields an long uniformly distributed between given bounds
-
-*******************************************************************/
-
-/*
- * long UnifInt( long nLow, long nHigh, seed_t *seed )
- */
-DSS_HUGE
-UnifInt(DSS_HUGE nLow, DSS_HUGE nHigh, seed_t *seed)
-
-/*
- * Returns an integer uniformly distributed between nLow and nHigh,
- * including * the endpoints. Seed points to the random number stream.
- */
-
-{
-	double dRange;
-	DSS_HUGE nTemp;
-	int32_t nLow32 = (int32_t)nLow, nHigh32 = (int32_t)nHigh;
-
-	if ((nHigh == MAX_LONG) && (nLow == 0)) {
-		dRange = (double)((DSS_HUGE)(nHigh32 - nLow32) + 1);
-	} else {
-		dRange = (double)(nHigh - nLow + 1);
-	}
-
-	seed->value = NextRand(seed->value);
-#ifdef RNG_TEST
-	seed->nCalls += 1;
-#endif
-	nTemp = (DSS_HUGE)(((double)seed->value / DBGenContext::dM) * (dRange));
-	return (nLow + nTemp);
-}
diff --git a/velox/external/duckdb/tpch/dbgen/rng64.cpp b/velox/external/duckdb/tpch/dbgen/rng64.cpp
deleted file mode 100644
index c0ca0ccf4ccc2..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/rng64.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-/*
- * $Id: rng64.c,v 1.7 2008/03/21 17:38:39 jms Exp $
- *
- * This software contains proprietary and confidential information of Gradient
- * Systems Inc.  By accepting transfer of this copy, Recipient agrees
- * to retain this software in confidence, to prevent disclosure to others, and
- * to make no use of this software other than that for which it was delivered.
- * This is an unpublished copyright work Gradient Systems, Inc.  Execpt as
- * permitted by federal law, 17 USC 117, copying is strictly prohibited.
- *
- * Gradient Systems Inc. CONFIDENTIAL - (Gradient Systems Inc. Confidential
- * when combined with the aggregated modules for this product)
- * OBJECT CODE ONLY SOURCE MATERIALS
- * (C) COPYRIGHT Gradient Systems Inc. 2003
- *
- * All Rights Reserved
- * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF GRADIENT SYSTEMS, INC.
- * The copyright notice above does not evidence any
- * actual or intended publication of such source code.
- *
- * Revision History
- * ===================
- * $Log: rng64.c,v $
- * Revision 1.7  2008/03/21 17:38:39  jms
- * changes for 2.6.3
- *
- * Revision 1.6  2006/04/26 23:20:05  jms
- * Data type clenaup for qgen
- *
- * Revision 1.5  2006/03/08 21:25:27  jms
- * change to RNG64 to address overflow/underflow issues
- *
- * Revision 1.4  2005/10/25 17:26:38  jms
- * check in integration between microsoft changes and baseline code
- *
- * Revision 1.3  2005/03/04 19:48:39  jms
- * Changes from Doug Johnson to address very large scale factors
- *
- * Revision 1.2  2005/01/03 20:08:59  jms
- * change line terminations
- *
- * Revision 1.1.1.1  2004/11/24 23:31:47  jms
- * re-establish external server
- *
- * Revision 1.2  2004/02/18 16:45:30  jms
- * remove C++ style comments for AIX compiler
- *
- * Revision 1.1.1.1  2003/08/08 21:57:34  jms
- * recreation after CVS crash
- *
- * Revision 1.1  2003/08/08 21:57:34  jms
- * first integration of rng64 for o_custkey and l_partkey
- *
- */
-#include "dbgen/rng64.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-void dss_random64(DSS_HUGE *tgt, DSS_HUGE nLow, DSS_HUGE nHigh, seed_t *seed) {
-	DSS_HUGE nTemp;
-
-	if (nLow > nHigh) {
-		nTemp = nLow;
-		nLow = nHigh;
-		nHigh = nTemp;
-	}
-
-	seed->value = NextRand64(seed->value);
-	nTemp = seed->value;
-	if (nTemp < 0)
-		nTemp = -nTemp;
-	nTemp %= (nHigh - nLow + 1);
-	*tgt = nLow + nTemp;
-	seed->usage += 1;
-#ifdef RNG_TEST
-	seed->nCalls += 1;
-#endif
-
-	return;
-}
-
-DSS_HUGE
-NextRand64(DSS_HUGE nSeed) {
-
-	DSS_HUGE a = (unsigned DSS_HUGE)RNG_A;
-	DSS_HUGE c = (unsigned DSS_HUGE)RNG_C;
-	nSeed = (nSeed * a + c); /* implicitely truncated to 64bits */
-
-	return (nSeed);
-}
-
-DSS_HUGE AdvanceRand64(DSS_HUGE nSeed, DSS_HUGE nCount) {
-	unsigned DSS_HUGE a = RNG_A;
-	unsigned DSS_HUGE c = RNG_C;
-	int nBit;
-	unsigned DSS_HUGE Apow = a, Dsum = c;
-
-	/* if nothing to do, do nothing ! */
-	if (nCount == 0)
-		return nSeed;
-
-	/* Recursively compute X(n) = A * X(n-1) + C */
-	/* */
-	/* explicitely: */
-	/* X(n) = A^n * X(0) + { A^(n-1) + A^(n-2) + ... A + 1 } * C */
-	/* */
-	/* we write this as: */
-	/* X(n) = Apow(n) * X(0) + Dsum(n) * C */
-	/* */
-	/* we use the following relations: */
-	/* Apow(n) = A^(n%2)*Apow(n/2)*Apow(n/2) */
-	/* Dsum(n) =   (n%2)*Apow(n/2)*Apow(n/2) + (Apow(n/2) + 1) * Dsum(n/2) */
-	/* */
-
-	/* first get the highest non-zero bit */
-	for (nBit = 0; (nCount >> nBit) != RNG_C; nBit++) {
-	}
-
-	/* go 1 bit at the time */
-	while (--nBit >= 0) {
-		Dsum *= (Apow + 1);
-		Apow = Apow * Apow;
-		if (((nCount >> nBit) % 2) == 1) { /* odd value */
-			Dsum += Apow;
-			Apow *= a;
-		}
-	}
-	nSeed = nSeed * Apow + Dsum * c;
-	return nSeed;
-}
diff --git a/velox/external/duckdb/tpch/dbgen/speed_seed.cpp b/velox/external/duckdb/tpch/dbgen/speed_seed.cpp
deleted file mode 100644
index 62dc83bb3c434..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/speed_seed.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-#include "dbgen/config.h"
-#include "dbgen/dss.h"
-#include "dbgen/rng64.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-/*  _tal long RandSeed = "Random^SeedFromTimestamp" (void); */
-
-#define ADVANCE_STREAM(stream, num_calls)   advanceStream(stream, num_calls, 0)
-#define ADVANCE_STREAM64(stream, num_calls) advanceStream(stream, num_calls, 1)
-#define MAX_COLOR                              92
-long name_bits[MAX_COLOR / BITS_PER_LONG];
-void fakeVStr(int nAvg, long nSeed, DSS_HUGE nCount);
-void NthElement(DSS_HUGE N, DSS_HUGE *StartSeed);
-
-void advanceStream(seed_t *seed, DSS_HUGE nCalls, int bUse64Bit) {
-	if (bUse64Bit)
-		seed->value = AdvanceRand64(seed->value, nCalls);
-	else
-		NthElement(nCalls, &seed->value);
-
-#ifdef RNG_TEST
-	seed->nCalls += nCalls;
-#endif
-
-	return;
-}
-
-/* WARNING!  This routine assumes the existence of 64-bit                 */
-/* integers.  The notation used here- "HUGE" is *not* ANSI standard. */
-/* Hopefully, you have this extension as well.  If not, use whatever      */
-/* nonstandard trick you need to in order to get 64 bit integers.         */
-/* The book says that this will work if MAXINT for the type you choose    */
-/* is at least 2**46  - 1, so 64 bits is more than you *really* need      */
-
-static DSS_HUGE Multiplier = 16807;   /* or whatever nonstandard */
-static DSS_HUGE Modulus = 2147483647; /* trick you use to get 64 bit int */
-
-/* Advances value of Seed after N applications of the random number generator
-   with multiplier Mult and given Modulus.
-   NthElement(Seed[],count);
-
-   Theory:  We are using a generator of the form
-        X_n = [Mult * X_(n-1)]  mod Modulus.    It turns out that
-        X_n = [(Mult ** n) X_0] mod Modulus.
-   This can be computed using a divide-and-conquer technique, see
-   the code below.
-
-   In words, this means that if you want the value of the Seed after n
-   applications of the generator,  you multiply the initial value of the
-   Seed by the "super multiplier" which is the basic multiplier raised
-   to the nth power, and then take mod Modulus.
-*/
-
-/* Nth Element of sequence starting with StartSeed */
-void NthElement(DSS_HUGE N, DSS_HUGE *StartSeed) {
-	DSS_HUGE Z;
-	DSS_HUGE Mult;
-	static int ln = -1;
-	int i;
-
-	if ((verbose > 0) && ++ln % 1000 == 0) {
-		i = ln % LN_CNT;
-		fprintf(stderr, "%c\b", lnoise[i]);
-	}
-	Mult = Multiplier;
-	Z = (DSS_HUGE)*StartSeed;
-	while (N > 0) {
-		if (N % 2 != 0) /* testing for oddness, this seems portable */
-			Z = (Mult * Z) % Modulus;
-		N = N / 2; /* integer division, truncates */
-		Mult = (Mult * Mult) % Modulus;
-	}
-	*StartSeed = Z;
-
-	return;
-}
-
-/* updates 'seed' using the tpch_a_rnd algorithm */
-void fake_tpch_a_rnd(int min, int max, seed_t *seed) {
-	DSS_HUGE len;
-	DSS_HUGE itcount;
-
-	RANDOM(len, min, max, seed);
-	if (len % 5L == 0)
-		itcount = len / 5;
-	else
-		itcount = len / 5 + 1L;
-	NthElement(itcount, &seed->usage);
-#ifdef RNG_TEST
-	seed->nCalls += itcount;
-#endif
-	return;
-}
-
-long sd_part(int child, DSS_HUGE skip_count, DBGenContext *ctx) {
-	(void)child;
-	int i;
-
-	for (i = P_MFG_SD; i <= P_CNTR_SD; i++)
-		ADVANCE_STREAM(&ctx->Seed[i], skip_count);
-
-	ADVANCE_STREAM(&ctx->Seed[P_CMNT_SD], skip_count * 2);
-	ADVANCE_STREAM(&ctx->Seed[P_NAME_SD], skip_count * 92);
-
-	return (0L);
-}
-
-long sd_line(int child, DSS_HUGE skip_count, DBGenContext *ctx) {
-	int i, j;
-
-	for (j = 0; j < O_LCNT_MAX; j++) {
-		for (i = L_QTY_SD; i <= L_RFLG_SD; i++)
-			/*
-			            if (ctx->scale_factor >= 30000 && i == L_PKEY_SD)
-			                ADVANCE_STREAM64(&ctx->Seed[i], skip_count);
-			            else
-			*/
-			ADVANCE_STREAM(&ctx->Seed[i], skip_count);
-		ADVANCE_STREAM(&ctx->Seed[L_CMNT_SD], skip_count * 2);
-	}
-
-	/* need to special case this as the link between master and detail */
-	if (child == 1) {
-		ADVANCE_STREAM(&ctx->Seed[O_ODATE_SD], skip_count);
-		ADVANCE_STREAM(&ctx->Seed[O_LCNT_SD], skip_count);
-	}
-
-	return (0L);
-}
-
-long sd_order(int child, DSS_HUGE skip_count, DBGenContext *ctx) {
-	(void)child;
-	ADVANCE_STREAM(&ctx->Seed[O_LCNT_SD], skip_count);
-	/*
-	    if (ctx->scale_factor >= 30000)
-	        ADVANCE_STREAM64(&ctx->Seed[O_CKEY_SD], skip_count);
-	    else
-	*/
-	ADVANCE_STREAM(&ctx->Seed[O_CKEY_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[O_CMNT_SD], skip_count * 2);
-	ADVANCE_STREAM(&ctx->Seed[O_SUPP_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[O_CLRK_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[O_PRIO_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[O_ODATE_SD], skip_count);
-
-	return (0L);
-}
-
-long sd_psupp(int child, DSS_HUGE skip_count, DBGenContext *ctx) {
-	(void)child;
-
-	int j;
-
-	for (j = 0; j < SUPP_PER_PART; j++) {
-		ADVANCE_STREAM(&ctx->Seed[PS_QTY_SD], skip_count);
-		ADVANCE_STREAM(&ctx->Seed[PS_SCST_SD], skip_count);
-		ADVANCE_STREAM(&ctx->Seed[PS_CMNT_SD], skip_count * 2);
-	}
-
-	return (0L);
-}
-
-long sd_cust(int child, DSS_HUGE skip_count, DBGenContext *ctx) {
-	(void)child;
-
-	ADVANCE_STREAM(&ctx->Seed[C_ADDR_SD], skip_count * 9);
-	ADVANCE_STREAM(&ctx->Seed[C_CMNT_SD], skip_count * 2);
-	ADVANCE_STREAM(&ctx->Seed[C_NTRG_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[C_PHNE_SD], 3L * skip_count);
-	ADVANCE_STREAM(&ctx->Seed[C_ABAL_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[C_MSEG_SD], skip_count);
-	return (0L);
-}
-
-long sd_supp(int child, DSS_HUGE skip_count, DBGenContext *ctx) {
-	(void)child;
-
-	ADVANCE_STREAM(&ctx->Seed[S_NTRG_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[S_PHNE_SD], 3L * skip_count);
-	ADVANCE_STREAM(&ctx->Seed[S_ABAL_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[S_ADDR_SD], skip_count * 9);
-	ADVANCE_STREAM(&ctx->Seed[S_CMNT_SD], skip_count * 2);
-	ADVANCE_STREAM(&ctx->Seed[BBB_CMNT_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[BBB_JNK_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[BBB_OFFSET_SD], skip_count);
-	ADVANCE_STREAM(&ctx->Seed[BBB_TYPE_SD], skip_count); /* avoid one trudge */
-
-	return (0L);
-}
-
-long sd_nation(int child, DSS_HUGE skip_count, DBGenContext *ctx) {
-	(void)child;
-
-	ADVANCE_STREAM(&ctx->Seed[N_CMNT_SD], skip_count * 2);
-
-	return (0L);
-}
-
-long sd_region(int child, DSS_HUGE skip_count, DBGenContext *ctx) {
-	(void)child;
-
-	ADVANCE_STREAM(&ctx->Seed[R_CMNT_SD], skip_count * 2);
-
-	return (0L);
-}
diff --git a/velox/external/duckdb/tpch/dbgen/text.cpp b/velox/external/duckdb/tpch/dbgen/text.cpp
deleted file mode 100644
index b2fabf9729694..0000000000000
--- a/velox/external/duckdb/tpch/dbgen/text.cpp
+++ /dev/null
@@ -1,442 +0,0 @@
-/*
- * Copyright owned by the Transaction Processing Performance Council.
- *
- * A copy of the license is included under extension/tpch/dbgen/LICENSE
- * in this repository.
- *
- * You may not use this file except in compliance with the License.
- *
- * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
- */
-/*
- * text.c --- pseaudo text generator for use in DBGEN 2.0
- *
- * Defined Routines:
- *		dbg_text() -- select and translate a sentance form
- */
-
-#ifdef TEXT_TEST
-#define DECLARER
-#endif /* TEST */
-
-#include "dbgen/config.h"
-
-#include <stdlib.h>
-#ifndef WIN32
- /* Change for Windows NT */
-#include <unistd.h>
-#endif /* WIN32 */
-#include <ctype.h>
-#include <errno.h>
-#include <limits.h>
-#include <math.h>
-#include <signal.h>
-#include <stdio.h> /* */
-#include <string.h>
-#ifdef HP
-#include <strings.h>
-#endif
-#if (defined(WIN32) && !defined(_POSIX_))
-#include <process.h>
-#pragma warning(disable : 4201)
-#pragma warning(disable : 4214)
-#pragma warning(disable : 4514)
-#define WIN32_LEAN_AND_MEAN
-#define NOATOM
-#define NOGDICAPMASKS
-#define NOMETAFILE
-#define NOMINMAX
-#define NOMSG
-#define NOOPENFILE
-#define NORASTEROPS
-#define NOSCROLL
-#define NOSOUND
-#define NOSYSMETRICS
-#define NOTEXTMETRIC
-#define NOWH
-#define NOCOMM
-#define NOKANJI
-#define NOMCX
-#include <windows.h>
-#pragma warning(default : 4201)
-#pragma warning(default : 4214)
-#endif
-
-#include "dbgen/dss.h"
-#include "dbgen/dsstypes.h"
-
-/*
- * txt_vp() --
- *		generate a verb phrase by
- *		1) selecting a verb phrase form
- *		2) parsing it to select parts of speech
- *		3) selecting appropriate words
- *		4) adding punctuation as required
- *
- *	Returns: length of generated phrase
- *	Called By: txt_sentence()
- *	Calls: pick_str()
- */
-static int txt_vp(char *dest, seed_t *seed) {
-	char syntax[MAX_GRAMMAR_LEN + 1], *cptr, *parse_target;
-	distribution *src;
-	int i, res = 0;
-
-	pick_str(&vp, seed, &syntax[0]);
-	parse_target = syntax;
-	while ((cptr = strtok(parse_target, " ")) != NULL) {
-		src = NULL;
-		switch (*cptr) {
-		case 'D':
-			src = &adverbs;
-			break;
-		case 'V':
-			src = &verbs;
-			break;
-		case 'X':
-			src = &auxillaries;
-			break;
-		} /* end of POS switch statement */
-		i = pick_str(src, seed, dest);
-		i = (int)strlen(DIST_MEMBER(src, i));
-		dest += i;
-		res += i;
-		if (*(++cptr)) /* miscelaneous fillagree, like punctuation */
-		{
-			dest += 1;
-			res += 1;
-			*dest = *cptr;
-		}
-		*dest = ' ';
-		dest++;
-		res++;
-		parse_target = NULL;
-	} /* end of while loop */
-
-	return (res);
-}
-
-/*
- * txt_np() --
- *		generate a noun phrase by
- *		1) selecting a noun phrase form
- *		2) parsing it to select parts of speech
- *		3) selecting appropriate words
- *		4) adding punctuation as required
- *
- *	Returns: length of generated phrase
- *	Called By: txt_sentence()
- *	Calls: pick_str(),
- */
-static int txt_np(char *dest, seed_t *seed) {
-	char syntax[MAX_GRAMMAR_LEN + 1], *cptr, *parse_target;
-	distribution *src;
-	int i, res = 0;
-
-	pick_str(&np, seed, &syntax[0]);
-	parse_target = syntax;
-	while ((cptr = strtok(parse_target, " ")) != NULL) {
-		src = NULL;
-		switch (*cptr) {
-		case 'A':
-			src = &articles;
-			break;
-		case 'J':
-			src = &adjectives;
-			break;
-		case 'D':
-			src = &adverbs;
-			break;
-		case 'N':
-			src = &nouns;
-			break;
-		} /* end of POS switch statement */
-		i = pick_str(src, seed, dest);
-		i = (int)strlen(DIST_MEMBER(src, i));
-		dest += i;
-		res += i;
-		if (*(++cptr)) /* miscelaneous fillagree, like punctuation */
-		{
-			*dest = *cptr;
-			dest += 1;
-			res += 1;
-		}
-		*dest = ' ';
-		dest++;
-		res++;
-		parse_target = NULL;
-	} /* end of while loop */
-
-	return (res);
-}
-
-/*
- * txt_sentence() --
- *		generate a sentence by
- *		1) selecting a sentence form
- *		2) parsing it to select parts of speech or phrase types
- *		3) selecting appropriate words
- *		4) adding punctuation as required
- *
- *	Returns: length of generated sentence
- *	Called By: dbg_text()
- *	Calls: pick_str(), txt_np(), txt_vp()
- */
-static int txt_sentence(char *dest, seed_t *seed) {
-	char syntax[MAX_GRAMMAR_LEN + 1], *cptr;
-	int i, res = 0, len = 0;
-
-	pick_str(&grammar, seed, syntax);
-	cptr = syntax;
-
-next_token: /* I hate goto's, but can't seem to have parent and child use strtok() */
-	while (*cptr && *cptr == ' ')
-		cptr++;
-	if (*cptr == '\0')
-		goto done;
-	switch (*cptr) {
-	case 'V':
-		len = txt_vp(dest, seed);
-		break;
-	case 'N':
-		len = txt_np(dest, seed);
-		break;
-	case 'P':
-		i = pick_str(&prepositions, seed, dest);
-		len = (int)strlen(DIST_MEMBER(&prepositions, i));
-		strcpy((dest + len), " the ");
-		len += 5;
-		len += txt_np(dest + len, seed);
-		break;
-	case 'T':
-		i = pick_str(&terminators, seed, --dest); /*terminators should abut previous word */
-		len = (int)strlen(DIST_MEMBER(&terminators, i));
-		break;
-	} /* end of POS switch statement */
-	dest += len;
-	res += len;
-	cptr++;
-	if (*cptr && *cptr != ' ') /* miscelaneous fillagree, like punctuation */
-	{
-		dest += 1;
-		res += 1;
-		*dest = *cptr;
-	}
-	goto next_token;
-done:
-	*dest = '\0';
-	return (--res);
-}
-
-static char *gen_text(char *dest, seed_t *seed, distribution *s) {
-	long i = 0;
-	DSS_HUGE j;
-
-	RANDOM(j, 1, s->list[s->count - 1].weight, seed);
-	while (s->list[i].weight < j)
-		i++;
-	char *src = s->list[i].text;
-	int ind = 0;
-	while (src[ind]) {
-		dest[ind] = src[ind];
-		ind++;
-	}
-	dest[ind] = ' ';
-	return dest + ind + 1;
-}
-
-#define NOUN_MAX_WEIGHT 340
-#define ADJECTIVES_MAX_WEIGHT 289
-#define ADVERBS_MAX_WEIGHT 262
-#define AUXILLARIES_MAX_WEIGHT 18
-#define VERBS_MAX_WEIGHT 174
-#define PREPOSITIONS_MAX_WEIGHT 456
-
-static char *noun_index[NOUN_MAX_WEIGHT + 1];
-static char *adjectives_index[ADJECTIVES_MAX_WEIGHT + 1];
-static char *adverbs_index[ADVERBS_MAX_WEIGHT + 1];
-static char *auxillaries_index[AUXILLARIES_MAX_WEIGHT + 1];
-static char *verbs_index[VERBS_MAX_WEIGHT + 1];
-static char *prepositions_index[PREPOSITIONS_MAX_WEIGHT + 1];
-
-static char *szTextPool;
-static long txtBufferSize = 0;
-
-// generate a lookup table for weight -> str
-static void gen_index(char **index, distribution *s) {
-	for (size_t w = 0; w <= s->list[s->count - 1].weight; w++) {
-		long i = 0;
-		while (s->list[i].weight < w)
-			i++;
-		index[w] = s->list[i].text;
-	}
-}
-
-static char *gen_text_index(char *dest, seed_t *seed, char **index, distribution *s) {
-	long i = 0;
-	DSS_HUGE j;
-
-	RANDOM(j, 1, s->list[s->count - 1].weight, seed);
-	char *src = index[j];
-	int ind = 0;
-	while (src[ind]) {
-		dest[ind] = src[ind];
-		ind++;
-	}
-	dest[ind] = ' ';
-	return dest + ind + 1;
-}
-
-static char *gen_vp(char *dest, seed_t *seed) {
-	DSS_HUGE j;
-	RANDOM(j, 1, vp.list[vp.count - 1].weight, seed);
-	int index = 0;
-	index += vp.list[0].weight < j;
-	index += vp.list[1].weight < j;
-	index += vp.list[2].weight < j;
-
-	if (index == 0) {
-		dest = gen_text_index(dest, seed, verbs_index, &verbs);
-	} else if (index == 1) {
-		dest = gen_text_index(dest, seed, auxillaries_index, &auxillaries);
-		dest = gen_text_index(dest, seed, verbs_index, &verbs);
-	} else if (index == 2) {
-		dest = gen_text_index(dest, seed, verbs_index, &verbs);
-		dest = gen_text_index(dest, seed, adverbs_index, &adverbs);
-	} else {
-		dest = gen_text_index(dest, seed, auxillaries_index, &auxillaries);
-		dest = gen_text_index(dest, seed, verbs_index, &verbs);
-		dest = gen_text_index(dest, seed, adverbs_index, &adverbs);
-	}
-	return dest;
-}
-
-static char *gen_np(char *dest, seed_t *seed) {
-	DSS_HUGE j;
-	RANDOM(j, 1, np.list[np.count - 1].weight, seed);
-	int index = 0;
-	index += np.list[0].weight < j;
-	index += np.list[1].weight < j;
-	index += np.list[2].weight < j;
-
-	if (index == 0) {
-		dest = gen_text_index(dest, seed, noun_index, &nouns);
-	} else if (index == 1) {
-		dest = gen_text_index(dest, seed, adjectives_index, &adjectives);
-		dest = gen_text_index(dest, seed, noun_index, &nouns);
-	} else if (index == 2) {
-		dest = gen_text_index(dest, seed, adjectives_index, &adjectives);
-		dest[-1] = ',';
-		*(dest++) = ' ';
-		dest = gen_text_index(dest, seed, adjectives_index, &adjectives);
-		dest = gen_text_index(dest, seed, noun_index, &nouns);
-	} else {
-		dest = gen_text_index(dest, seed, adverbs_index, &adverbs);
-		dest = gen_text_index(dest, seed, adjectives_index, &adjectives);
-		dest = gen_text_index(dest, seed, noun_index, &nouns);
-	}
-	return dest;
-}
-
-static char *gen_preposition(char *dest, seed_t *seed) {
-	dest = gen_text_index(dest, seed, prepositions_index, &prepositions);
-	*(dest++) = 't';
-	*(dest++) = 'h';
-	*(dest++) = 'e';
-	*(dest++) = ' ';
-	return gen_np(dest, seed);
-}
-
-static char *gen_terminator(char *dest, seed_t *seed) {
-	dest = gen_text(--dest, seed, &terminators);
-	return dest - 1;
-}
-
-static char *gen_sentence(char *dest, seed_t *seed) {
-	const char *cptr;
-	int i;
-
-	DSS_HUGE j;
-	RANDOM(j, 1, grammar.list[grammar.count - 1].weight, seed);
-	int index = 0;
-	index += grammar.list[0].weight < j;
-	index += grammar.list[1].weight < j;
-	index += grammar.list[2].weight < j;
-	index += grammar.list[3].weight < j;
-	cptr = grammar.list[index].text;
-
-	if (index == 0) {
-		dest = gen_np(dest, seed);
-		dest = gen_vp(dest, seed);
-		dest = gen_terminator(dest, seed);
-	} else if (index == 1) {
-		dest = gen_np(dest, seed);
-		dest = gen_vp(dest, seed);
-		dest = gen_preposition(dest, seed);
-		dest = gen_terminator(dest, seed);
-	} else if (index == 2) {
-		dest = gen_np(dest, seed);
-		dest = gen_vp(dest, seed);
-		dest = gen_np(dest, seed);
-		dest = gen_terminator(dest, seed);
-	} else if (index == 3) {
-		dest = gen_np(dest, seed);
-		dest = gen_preposition(dest, seed);
-		dest = gen_vp(dest, seed);
-		dest = gen_np(dest, seed);
-		dest = gen_terminator(dest, seed);
-	} else {
-		dest = gen_np(dest, seed);
-		dest = gen_preposition(dest, seed);
-		dest = gen_vp(dest, seed);
-		dest = gen_preposition(dest, seed);
-		dest = gen_terminator(dest, seed);
-	}
-	*dest = ' ';
-	return dest + 1;
-}
-
-/*
- * init_text_pool() --
- *    allocate and initialize the internal text pool buffer (szTextPool).
- *    Make sure to call it before using dbg_text().
- */
-void init_text_pool(long bSize, DBGenContext *ctx) {
-	gen_index(noun_index, &nouns);
-	gen_index(adjectives_index, &adjectives);
-	gen_index(adverbs_index, &adverbs);
-	gen_index(auxillaries_index, &auxillaries);
-	gen_index(verbs_index, &verbs);
-	gen_index(prepositions_index, &prepositions);
-
-  txtBufferSize = bSize;
-  szTextPool = (char*)malloc(bSize + 1 + 100);
-
-	char *ptr = szTextPool;
-	char *endptr = szTextPool + bSize + 1;
-	while (ptr < endptr) {
-		ptr = gen_sentence(ptr, &ctx->Seed[5]);
-	}
-	szTextPool[bSize] = '\0';
-}
-
-void free_text_pool() {
-  free(szTextPool);
-}
-
-/*
- * dbg_text() --
- *		produce ELIZA-like text of random, bounded length, truncating the last
- *		generated sentence as required
- */
-void dbg_text(char *tgt, int min, int max, seed_t *seed) {
-	DSS_HUGE hgLength = 0, hgOffset, wordlen = 0, s_len, needed;
-	char sentence[MAX_SENT_LEN + 1], *cp;
-
-	RANDOM(hgOffset, 0, txtBufferSize - max, seed);
-	RANDOM(hgLength, min, max, seed);
-	strncpy(&tgt[0], &szTextPool[hgOffset], (int)hgLength);
-	tgt[hgLength] = '\0';
-
-	return;
-}
diff --git a/velox/external/duckdb/tpch/include/tpch-extension.hpp b/velox/external/duckdb/tpch/include/tpch-extension.hpp
deleted file mode 100644
index 16fa70156c6ae..0000000000000
--- a/velox/external/duckdb/tpch/include/tpch-extension.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// tpch-extension.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "velox/external/duckdb/duckdb.hpp"
-
-namespace duckdb {
-
-class TPCHExtension : public Extension {
-public:
-	void Load(DuckDB &db) override;
-	std::string Name() override;
-
-	//! Gets the specified TPC-H Query number as a string
-	static std::string GetQuery(int query);
-	//! Returns the CSV answer of a TPC-H query
-	static std::string GetAnswer(double sf, int query);
-};
-
-} // namespace duckdb
diff --git a/velox/external/duckdb/tpch/tpch-extension.cpp b/velox/external/duckdb/tpch/tpch-extension.cpp
deleted file mode 100644
index 38458e978c81f..0000000000000
--- a/velox/external/duckdb/tpch/tpch-extension.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-#define DUCKDB_EXTENSION_MAIN
-
-#include "tpch-extension.hpp"
-
-#ifndef DUCKDB_AMALGAMATION
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-#include "duckdb/main/client_context.hpp"
-#endif
-
-#include "dbgen/dbgen.hpp"
-
-namespace duckdb {
-
-struct DBGenFunctionData : public TableFunctionData {
-	DBGenFunctionData() {
-	}
-
-	bool finished = false;
-	double sf = 0;
-	string schema = DEFAULT_SCHEMA;
-	string suffix;
-	bool overwrite = false;
-};
-
-static unique_ptr<FunctionData> DbgenBind(ClientContext &context, TableFunctionBindInput &input,
-                                          vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_unique<DBGenFunctionData>();
-	for (auto &kv : input.named_parameters) {
-		if (kv.first == "sf") {
-			result->sf = DoubleValue::Get(kv.second);
-		} else if (kv.first == "schema") {
-			result->schema = StringValue::Get(kv.second);
-		} else if (kv.first == "suffix") {
-			result->suffix = StringValue::Get(kv.second);
-		} else if (kv.first == "overwrite") {
-			result->overwrite = BooleanValue::Get(kv.second);
-		}
-	}
-	return_types.emplace_back(LogicalType::BOOLEAN);
-	names.emplace_back("Success");
-	return std::move(result);
-}
-
-static void DbgenFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DBGenFunctionData &)*data_p.bind_data;
-	if (data.finished) {
-		return;
-	}
-	tpch::DBGenWrapper::CreateTPCHSchema(context, data.schema, data.suffix);
-	tpch::DBGenWrapper::LoadTPCHData(context, data.sf, data.schema, data.suffix);
-
-	data.finished = true;
-}
-
-struct TPCHData : public GlobalTableFunctionState {
-	TPCHData() : offset(0) {
-	}
-	idx_t offset;
-};
-
-unique_ptr<GlobalTableFunctionState> TPCHInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<TPCHData>();
-	return std::move(result);
-}
-
-static unique_ptr<FunctionData> TPCHQueryBind(ClientContext &context, TableFunctionBindInput &input,
-                                              vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("query_nr");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("query");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-static void TPCHQueryFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (TPCHData &)*data_p.global_state;
-	idx_t tpch_queries = 22;
-	if (data.offset >= tpch_queries) {
-		// finished returning values
-		return;
-	}
-	idx_t chunk_count = 0;
-	while (data.offset < tpch_queries && chunk_count < STANDARD_VECTOR_SIZE) {
-		auto query = tpch::DBGenWrapper::GetQuery(data.offset + 1);
-		// "query_nr", PhysicalType::INT32
-		output.SetValue(0, chunk_count, Value::INTEGER((int32_t)data.offset + 1));
-		// "query", PhysicalType::VARCHAR
-		output.SetValue(1, chunk_count, Value(query));
-		data.offset++;
-		chunk_count++;
-	}
-	output.SetCardinality(chunk_count);
-}
-
-static unique_ptr<FunctionData> TPCHQueryAnswerBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("query_nr");
-	return_types.emplace_back(LogicalType::INTEGER);
-
-	names.emplace_back("scale_factor");
-	return_types.emplace_back(LogicalType::DOUBLE);
-
-	names.emplace_back("answer");
-	return_types.emplace_back(LogicalType::VARCHAR);
-
-	return nullptr;
-}
-
-static void TPCHQueryAnswerFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (TPCHData &)*data_p.global_state;
-	idx_t tpch_queries = 22;
-	vector<double> scale_factors {0.01, 0.1, 1};
-	idx_t total_answers = tpch_queries * scale_factors.size();
-	if (data.offset >= total_answers) {
-		// finished returning values
-		return;
-	}
-	idx_t chunk_count = 0;
-	while (data.offset < total_answers && chunk_count < STANDARD_VECTOR_SIZE) {
-		idx_t cur_query = data.offset % tpch_queries;
-		idx_t cur_sf = data.offset / tpch_queries;
-		auto answer = tpch::DBGenWrapper::GetAnswer(scale_factors[cur_sf], cur_query + 1);
-		// "query_nr", PhysicalType::INT32
-		output.SetValue(0, chunk_count, Value::INTEGER((int32_t)cur_query + 1));
-		// "scale_factor", PhysicalType::INT32
-		output.SetValue(1, chunk_count, Value::DOUBLE(scale_factors[cur_sf]));
-		// "query", PhysicalType::VARCHAR
-		output.SetValue(2, chunk_count, Value(answer));
-		data.offset++;
-		chunk_count++;
-	}
-	output.SetCardinality(chunk_count);
-}
-
-static string PragmaTpchQuery(ClientContext &context, const FunctionParameters &parameters) {
-	auto index = parameters.values[0].GetValue<int32_t>();
-	return tpch::DBGenWrapper::GetQuery(index);
-}
-
-void TPCHExtension::Load(DuckDB &db) {
-	Connection con(db);
-	con.BeginTransaction();
-	auto &catalog = Catalog::GetCatalog(*con.context);
-
-	TableFunction dbgen_func("dbgen", {}, DbgenFunction, DbgenBind);
-	dbgen_func.named_parameters["sf"] = LogicalType::DOUBLE;
-	dbgen_func.named_parameters["overwrite"] = LogicalType::BOOLEAN;
-	dbgen_func.named_parameters["schema"] = LogicalType::VARCHAR;
-	dbgen_func.named_parameters["suffix"] = LogicalType::VARCHAR;
-	CreateTableFunctionInfo dbgen_info(dbgen_func);
-
-	// create the dbgen function
-	catalog.CreateTableFunction(*con.context, &dbgen_info);
-
-	// create the TPCH pragma that allows us to run the query
-	auto tpch_func = PragmaFunction::PragmaCall("tpch", PragmaTpchQuery, {LogicalType::BIGINT});
-	CreatePragmaFunctionInfo info(tpch_func);
-	catalog.CreatePragmaFunction(*con.context, &info);
-
-	// create the TPCH_QUERIES function that returns the query
-	TableFunction tpch_query_func("tpch_queries", {}, TPCHQueryFunction, TPCHQueryBind, TPCHInit);
-	CreateTableFunctionInfo tpch_query_info(tpch_query_func);
-	catalog.CreateTableFunction(*con.context, &tpch_query_info);
-
-	// create the TPCH_ANSWERS that returns the query result
-	TableFunction tpch_query_answer_func("tpch_answers", {}, TPCHQueryAnswerFunction, TPCHQueryAnswerBind, TPCHInit);
-	CreateTableFunctionInfo tpch_query_asnwer_info(tpch_query_answer_func);
-	catalog.CreateTableFunction(*con.context, &tpch_query_asnwer_info);
-
-	con.Commit();
-}
-
-std::string TPCHExtension::GetQuery(int query) {
-	return tpch::DBGenWrapper::GetQuery(query);
-}
-
-std::string TPCHExtension::GetAnswer(double sf, int query) {
-	return tpch::DBGenWrapper::GetAnswer(sf, query);
-}
-
-std::string TPCHExtension::Name() {
-	return "tpch";
-}
-
-} // namespace duckdb
-
-extern "C" {
-
-DUCKDB_EXTENSION_API void tpch_init(duckdb::DatabaseInstance &db) {
-	duckdb::DuckDB db_wrapper(db);
-	db_wrapper.LoadExtension<duckdb::TPCHExtension>();
-}
-
-DUCKDB_EXTENSION_API const char *tpch_version() {
-	return duckdb::DuckDB::LibraryVersion();
-}
-}
-
-#ifndef DUCKDB_EXTENSION_MAIN
-#error DUCKDB_EXTENSION_MAIN not defined
-#endif
diff --git a/velox/external/md5/CMakeLists.txt b/velox/external/md5/CMakeLists.txt
index a066f336ca810..b953447b54f66 100644
--- a/velox/external/md5/CMakeLists.txt
+++ b/velox/external/md5/CMakeLists.txt
@@ -9,9 +9,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(md5 md5.cpp)
+velox_add_library(velox_external_md5 md5.cpp)
 
-add_compile_definitions(FOLLY_HAVE_INT128_T=1)
-target_link_libraries(
-        md5
+velox_link_libraries(
+        velox_external_md5
+        PRIVATE
         Folly::folly)
diff --git a/velox/external/timsort/TimSort.hpp b/velox/external/timsort/TimSort.hpp
new file mode 100644
index 0000000000000..501ca3c0df82a
--- /dev/null
+++ b/velox/external/timsort/TimSort.hpp
@@ -0,0 +1,814 @@
+/*
+ * C++ implementation of timsort
+ *
+ * ported from Python's and OpenJDK's:
+ * - http://svn.python.org/projects/python/trunk/Objects/listobject.c
+ * -
+ * http://cr.openjdk.java.net/~martin/webrevs/openjdk7/timsort/raw_files/new/src/share/classes/java/util/TimSort.java
+ *
+ * Copyright (c) 2011 Fuji, Goro (gfx) <gfuji@cpan.org>.
+ * Copyright (c) 2019-2022 Morwenn.
+ * Copyright (c) 2021 Igor Kushnir <igorkuo@gmail.com>.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef GFX_TIMSORT_HPP
+#define GFX_TIMSORT_HPP
+
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <utility>
+#include <vector>
+
+// Semantic versioning macros
+
+#define GFX_TIMSORT_VERSION_MAJOR 2
+#define GFX_TIMSORT_VERSION_MINOR 1
+#define GFX_TIMSORT_VERSION_PATCH 0
+
+// Diagnostic selection macros
+
+#if defined(GFX_TIMSORT_ENABLE_ASSERT) || defined(GFX_TIMSORT_ENABLE_AUDIT)
+#include <cassert>
+#endif
+
+#ifdef GFX_TIMSORT_ENABLE_ASSERT
+#define GFX_TIMSORT_ASSERT(expr) assert(expr)
+#else
+#define GFX_TIMSORT_ASSERT(expr) ((void)0)
+#endif
+
+#ifdef GFX_TIMSORT_ENABLE_AUDIT
+#define GFX_TIMSORT_AUDIT(expr) assert(expr)
+#else
+#define GFX_TIMSORT_AUDIT(expr) ((void)0)
+#endif
+
+#ifdef GFX_TIMSORT_ENABLE_LOG
+#include <iostream>
+#define GFX_TIMSORT_LOG(expr) \
+  (std::clog << "# " << __func__ << ": " << expr << std::endl)
+#else
+#define GFX_TIMSORT_LOG(expr) ((void)0)
+#endif
+
+namespace gfx {
+
+// ---------------------------------------
+// Implementation details
+// ---------------------------------------
+
+namespace detail {
+
+// Equivalent to C++20 std::identity
+struct identity {
+  template <typename T>
+  constexpr T&& operator()(T&& value) const noexcept {
+    return std::forward<T>(value);
+  }
+};
+
+// Merge a predicate and a projection function
+template <typename Compare, typename Projection>
+struct projection_compare {
+  projection_compare(Compare comp, Projection proj)
+      : compare(comp), projection(proj) {}
+
+  template <typename T, typename U>
+  bool operator()(T&& lhs, U&& rhs) {
+#ifdef __cpp_lib_invoke
+    return static_cast<bool>(std::invoke(
+        compare,
+        std::invoke(projection, std::forward<T>(lhs)),
+        std::invoke(projection, std::forward<U>(rhs))));
+#else
+    return static_cast<bool>(compare(
+        projection(std::forward<T>(lhs)), projection(std::forward<U>(rhs))));
+#endif
+  }
+
+  Compare compare;
+  Projection projection;
+};
+
+template <typename Iterator>
+struct run {
+  typedef typename std::iterator_traits<Iterator>::difference_type diff_t;
+
+  Iterator base;
+  diff_t len;
+
+  run(Iterator b, diff_t l) : base(b), len(l) {}
+};
+
+template <typename RandomAccessIterator, typename Compare>
+class TimSort {
+  typedef RandomAccessIterator iter_t;
+  typedef typename std::iterator_traits<iter_t>::value_type value_t;
+  typedef typename std::iterator_traits<iter_t>::reference ref_t;
+  typedef typename std::iterator_traits<iter_t>::difference_type diff_t;
+
+  static constexpr int MIN_MERGE = 32;
+  static constexpr int MIN_GALLOP = 7;
+
+  int minGallop_; // default to MIN_GALLOP
+
+  std::vector<value_t> tmp_; // temp storage for merges
+  typedef typename std::vector<value_t>::iterator tmp_iter_t;
+
+  std::vector<run<RandomAccessIterator>> pending_;
+
+  static void
+  binarySort(iter_t const lo, iter_t const hi, iter_t start, Compare compare) {
+    GFX_TIMSORT_ASSERT(lo <= start);
+    GFX_TIMSORT_ASSERT(start <= hi);
+    if (start == lo) {
+      ++start;
+    }
+    for (; start < hi; ++start) {
+      GFX_TIMSORT_ASSERT(lo <= start);
+      value_t pivot = std::move(*start);
+
+      iter_t const pos = std::upper_bound(lo, start, pivot, compare);
+      for (iter_t p = start; p > pos; --p) {
+        *p = std::move(*std::prev(p));
+      }
+      *pos = std::move(pivot);
+    }
+  }
+
+  static diff_t
+  countRunAndMakeAscending(iter_t const lo, iter_t const hi, Compare compare) {
+    GFX_TIMSORT_ASSERT(lo < hi);
+
+    auto runHi = std::next(lo);
+    if (runHi == hi) {
+      return 1;
+    }
+
+    if (compare(*runHi, *lo)) { // decreasing
+      do {
+        ++runHi;
+      } while (runHi < hi && compare(*runHi, *std::prev(runHi)));
+      std::reverse(lo, runHi);
+    } else { // non-decreasing
+      do {
+        ++runHi;
+      } while (runHi < hi && !compare(*runHi, *std::prev(runHi)));
+    }
+
+    return runHi - lo;
+  }
+
+  static diff_t minRunLength(diff_t n) {
+    GFX_TIMSORT_ASSERT(n >= 0);
+
+    diff_t r = 0;
+    while (n >= 2 * MIN_MERGE) {
+      r |= (n & 1);
+      n >>= 1;
+    }
+    return n + r;
+  }
+
+  TimSort() : minGallop_(MIN_GALLOP) {}
+
+  // Silence GCC -Winline warning
+  ~TimSort() {}
+
+  void pushRun(iter_t const runBase, diff_t const runLen) {
+    pending_.emplace_back(runBase, runLen);
+  }
+
+  void mergeCollapse(Compare compare) {
+    while (pending_.size() > 1) {
+      diff_t n = pending_.size() - 2;
+
+      if ((n > 0 &&
+           pending_[n - 1].len <= pending_[n].len + pending_[n + 1].len) ||
+          (n > 1 &&
+           pending_[n - 2].len <= pending_[n - 1].len + pending_[n].len)) {
+        if (pending_[n - 1].len < pending_[n + 1].len) {
+          --n;
+        }
+        mergeAt(n, compare);
+      } else if (pending_[n].len <= pending_[n + 1].len) {
+        mergeAt(n, compare);
+      } else {
+        break;
+      }
+    }
+  }
+
+  void mergeForceCollapse(Compare compare) {
+    while (pending_.size() > 1) {
+      diff_t n = pending_.size() - 2;
+
+      if (n > 0 && pending_[n - 1].len < pending_[n + 1].len) {
+        --n;
+      }
+      mergeAt(n, compare);
+    }
+  }
+
+  void mergeAt(diff_t const i, Compare compare) {
+    diff_t const stackSize = pending_.size();
+    GFX_TIMSORT_ASSERT(stackSize >= 2);
+    GFX_TIMSORT_ASSERT(i >= 0);
+    GFX_TIMSORT_ASSERT(i == stackSize - 2 || i == stackSize - 3);
+
+    iter_t base1 = pending_[i].base;
+    diff_t len1 = pending_[i].len;
+    iter_t base2 = pending_[i + 1].base;
+    diff_t len2 = pending_[i + 1].len;
+
+    pending_[i].len = len1 + len2;
+
+    if (i == stackSize - 3) {
+      pending_[i + 1] = pending_[i + 2];
+    }
+
+    pending_.pop_back();
+
+    mergeConsecutiveRuns(base1, len1, base2, len2, std::move(compare));
+  }
+
+  void mergeConsecutiveRuns(
+      iter_t base1,
+      diff_t len1,
+      iter_t base2,
+      diff_t len2,
+      Compare compare) {
+    GFX_TIMSORT_ASSERT(len1 > 0);
+    GFX_TIMSORT_ASSERT(len2 > 0);
+    GFX_TIMSORT_ASSERT(base1 + len1 == base2);
+
+    diff_t const k = gallopRight(*base2, base1, len1, 0, compare);
+    GFX_TIMSORT_ASSERT(k >= 0);
+
+    base1 += k;
+    len1 -= k;
+
+    if (len1 == 0) {
+      return;
+    }
+
+    len2 = gallopLeft(*(base1 + (len1 - 1)), base2, len2, len2 - 1, compare);
+    GFX_TIMSORT_ASSERT(len2 >= 0);
+    if (len2 == 0) {
+      return;
+    }
+
+    if (len1 <= len2) {
+      mergeLo(base1, len1, base2, len2, compare);
+    } else {
+      mergeHi(base1, len1, base2, len2, compare);
+    }
+  }
+
+  template <typename Iter>
+  static diff_t gallopLeft(
+      ref_t key,
+      Iter const base,
+      diff_t const len,
+      diff_t const hint,
+      Compare compare) {
+    GFX_TIMSORT_ASSERT(len > 0);
+    GFX_TIMSORT_ASSERT(hint >= 0);
+    GFX_TIMSORT_ASSERT(hint < len);
+
+    diff_t lastOfs = 0;
+    diff_t ofs = 1;
+
+    if (compare(*(base + hint), key)) {
+      diff_t const maxOfs = len - hint;
+      while (ofs < maxOfs && compare(*(base + (hint + ofs)), key)) {
+        lastOfs = ofs;
+        ofs = (ofs << 1) + 1;
+
+        if (ofs <= 0) { // int overflow
+          ofs = maxOfs;
+        }
+      }
+      if (ofs > maxOfs) {
+        ofs = maxOfs;
+      }
+
+      lastOfs += hint;
+      ofs += hint;
+    } else {
+      diff_t const maxOfs = hint + 1;
+      while (ofs < maxOfs && !compare(*(base + (hint - ofs)), key)) {
+        lastOfs = ofs;
+        ofs = (ofs << 1) + 1;
+
+        if (ofs <= 0) {
+          ofs = maxOfs;
+        }
+      }
+      if (ofs > maxOfs) {
+        ofs = maxOfs;
+      }
+
+      diff_t const tmp = lastOfs;
+      lastOfs = hint - ofs;
+      ofs = hint - tmp;
+    }
+    GFX_TIMSORT_ASSERT(-1 <= lastOfs);
+    GFX_TIMSORT_ASSERT(lastOfs < ofs);
+    GFX_TIMSORT_ASSERT(ofs <= len);
+
+    return std::lower_bound(base + (lastOfs + 1), base + ofs, key, compare) -
+        base;
+  }
+
+  template <typename Iter>
+  static diff_t gallopRight(
+      ref_t key,
+      Iter const base,
+      diff_t const len,
+      diff_t const hint,
+      Compare compare) {
+    GFX_TIMSORT_ASSERT(len > 0);
+    GFX_TIMSORT_ASSERT(hint >= 0);
+    GFX_TIMSORT_ASSERT(hint < len);
+
+    diff_t ofs = 1;
+    diff_t lastOfs = 0;
+
+    if (compare(key, *(base + hint))) {
+      diff_t const maxOfs = hint + 1;
+      while (ofs < maxOfs && compare(key, *(base + (hint - ofs)))) {
+        lastOfs = ofs;
+        ofs = (ofs << 1) + 1;
+
+        if (ofs <= 0) {
+          ofs = maxOfs;
+        }
+      }
+      if (ofs > maxOfs) {
+        ofs = maxOfs;
+      }
+
+      diff_t const tmp = lastOfs;
+      lastOfs = hint - ofs;
+      ofs = hint - tmp;
+    } else {
+      diff_t const maxOfs = len - hint;
+      while (ofs < maxOfs && !compare(key, *(base + (hint + ofs)))) {
+        lastOfs = ofs;
+        ofs = (ofs << 1) + 1;
+
+        if (ofs <= 0) { // int overflow
+          ofs = maxOfs;
+        }
+      }
+      if (ofs > maxOfs) {
+        ofs = maxOfs;
+      }
+
+      lastOfs += hint;
+      ofs += hint;
+    }
+    GFX_TIMSORT_ASSERT(-1 <= lastOfs);
+    GFX_TIMSORT_ASSERT(lastOfs < ofs);
+    GFX_TIMSORT_ASSERT(ofs <= len);
+
+    return std::upper_bound(base + (lastOfs + 1), base + ofs, key, compare) -
+        base;
+  }
+
+  static void rotateLeft(iter_t first, iter_t last) {
+    value_t tmp = std::move(*first);
+    auto last_1 = std::move(std::next(first), last, first);
+    *last_1 = std::move(tmp);
+  }
+
+  static void rotateRight(iter_t first, iter_t last) {
+    auto last_1 = std::prev(last);
+    value_t tmp = std::move(*last_1);
+    std::move_backward(first, last_1, last);
+    *first = std::move(tmp);
+  }
+
+  void mergeLo(
+      iter_t const base1,
+      diff_t len1,
+      iter_t const base2,
+      diff_t len2,
+      Compare compare) {
+    GFX_TIMSORT_ASSERT(len1 > 0);
+    GFX_TIMSORT_ASSERT(len2 > 0);
+    GFX_TIMSORT_ASSERT(base1 + len1 == base2);
+
+    if (len1 == 1) {
+      return rotateLeft(base1, base2 + len2);
+    }
+    if (len2 == 1) {
+      return rotateRight(base1, base2 + len2);
+    }
+
+    copy_to_tmp(base1, len1);
+
+    tmp_iter_t cursor1 = tmp_.begin();
+    iter_t cursor2 = base2;
+    iter_t dest = base1;
+
+    *dest = std::move(*cursor2);
+    ++cursor2;
+    ++dest;
+    --len2;
+
+    int minGallop(minGallop_);
+
+    // outer:
+    while (true) {
+      diff_t count1 = 0;
+      diff_t count2 = 0;
+
+      do {
+        GFX_TIMSORT_ASSERT(len1 > 1);
+        GFX_TIMSORT_ASSERT(len2 > 0);
+
+        if (compare(*cursor2, *cursor1)) {
+          *dest = std::move(*cursor2);
+          ++cursor2;
+          ++dest;
+          ++count2;
+          count1 = 0;
+          if (--len2 == 0) {
+            goto epilogue;
+          }
+        } else {
+          *dest = std::move(*cursor1);
+          ++cursor1;
+          ++dest;
+          ++count1;
+          count2 = 0;
+          if (--len1 == 1) {
+            goto epilogue;
+          }
+        }
+      } while ((count1 | count2) < minGallop);
+
+      do {
+        GFX_TIMSORT_ASSERT(len1 > 1);
+        GFX_TIMSORT_ASSERT(len2 > 0);
+
+        count1 = gallopRight(*cursor2, cursor1, len1, 0, compare);
+        if (count1 != 0) {
+          std::move_backward(cursor1, cursor1 + count1, dest + count1);
+          dest += count1;
+          cursor1 += count1;
+          len1 -= count1;
+
+          if (len1 <= 1) {
+            goto epilogue;
+          }
+        }
+        *dest = std::move(*cursor2);
+        ++cursor2;
+        ++dest;
+        if (--len2 == 0) {
+          goto epilogue;
+        }
+
+        count2 = gallopLeft(*cursor1, cursor2, len2, 0, compare);
+        if (count2 != 0) {
+          std::move(cursor2, cursor2 + count2, dest);
+          dest += count2;
+          cursor2 += count2;
+          len2 -= count2;
+          if (len2 == 0) {
+            goto epilogue;
+          }
+        }
+        *dest = std::move(*cursor1);
+        ++cursor1;
+        ++dest;
+        if (--len1 == 1) {
+          goto epilogue;
+        }
+
+        --minGallop;
+      } while ((count1 >= MIN_GALLOP) | (count2 >= MIN_GALLOP));
+
+      if (minGallop < 0) {
+        minGallop = 0;
+      }
+      minGallop += 2;
+    } // end of "outer" loop
+
+  epilogue: // merge what is left from either cursor1 or cursor2
+
+    minGallop_ = (std::min)(minGallop, 1);
+
+    if (len1 == 1) {
+      GFX_TIMSORT_ASSERT(len2 > 0);
+      std::move(cursor2, cursor2 + len2, dest);
+      *(dest + len2) = std::move(*cursor1);
+    } else {
+      GFX_TIMSORT_ASSERT(
+          len1 != 0 && "Comparison function violates its general contract");
+      GFX_TIMSORT_ASSERT(len2 == 0);
+      GFX_TIMSORT_ASSERT(len1 > 1);
+      std::move(cursor1, cursor1 + len1, dest);
+    }
+  }
+
+  void mergeHi(
+      iter_t const base1,
+      diff_t len1,
+      iter_t const base2,
+      diff_t len2,
+      Compare compare) {
+    GFX_TIMSORT_ASSERT(len1 > 0);
+    GFX_TIMSORT_ASSERT(len2 > 0);
+    GFX_TIMSORT_ASSERT(base1 + len1 == base2);
+
+    if (len1 == 1) {
+      return rotateLeft(base1, base2 + len2);
+    }
+    if (len2 == 1) {
+      return rotateRight(base1, base2 + len2);
+    }
+
+    copy_to_tmp(base2, len2);
+
+    iter_t cursor1 = base1 + len1;
+    tmp_iter_t cursor2 = tmp_.begin() + (len2 - 1);
+    iter_t dest = base2 + (len2 - 1);
+
+    *dest = std::move(*(--cursor1));
+    --dest;
+    --len1;
+
+    int minGallop(minGallop_);
+
+    // outer:
+    while (true) {
+      diff_t count1 = 0;
+      diff_t count2 = 0;
+
+      // The next loop is a hot path of the algorithm, so we decrement
+      // eagerly the cursor so that it always points directly to the value
+      // to compare, but we have to implement some trickier logic to make
+      // sure that it points to the next value again by the end of said loop
+      --cursor1;
+
+      do {
+        GFX_TIMSORT_ASSERT(len1 > 0);
+        GFX_TIMSORT_ASSERT(len2 > 1);
+
+        if (compare(*cursor2, *cursor1)) {
+          *dest = std::move(*cursor1);
+          --dest;
+          ++count1;
+          count2 = 0;
+          if (--len1 == 0) {
+            goto epilogue;
+          }
+          --cursor1;
+        } else {
+          *dest = std::move(*cursor2);
+          --cursor2;
+          --dest;
+          ++count2;
+          count1 = 0;
+          if (--len2 == 1) {
+            ++cursor1; // See comment before the loop
+            goto epilogue;
+          }
+        }
+      } while ((count1 | count2) < minGallop);
+      ++cursor1; // See comment before the loop
+
+      do {
+        GFX_TIMSORT_ASSERT(len1 > 0);
+        GFX_TIMSORT_ASSERT(len2 > 1);
+
+        count1 = len1 - gallopRight(*cursor2, base1, len1, len1 - 1, compare);
+        if (count1 != 0) {
+          dest -= count1;
+          cursor1 -= count1;
+          len1 -= count1;
+          std::move_backward(cursor1, cursor1 + count1, dest + (1 + count1));
+
+          if (len1 == 0) {
+            goto epilogue;
+          }
+        }
+        *dest = std::move(*cursor2);
+        --cursor2;
+        --dest;
+        if (--len2 == 1) {
+          goto epilogue;
+        }
+
+        count2 =
+            len2 -
+            gallopLeft(
+                *std::prev(cursor1), tmp_.begin(), len2, len2 - 1, compare);
+        if (count2 != 0) {
+          dest -= count2;
+          cursor2 -= count2;
+          len2 -= count2;
+          std::move(
+              std::next(cursor2), cursor2 + (1 + count2), std::next(dest));
+          if (len2 <= 1) {
+            goto epilogue;
+          }
+        }
+        *dest = std::move(*(--cursor1));
+        --dest;
+        if (--len1 == 0) {
+          goto epilogue;
+        }
+
+        --minGallop;
+      } while ((count1 >= MIN_GALLOP) | (count2 >= MIN_GALLOP));
+
+      if (minGallop < 0) {
+        minGallop = 0;
+      }
+      minGallop += 2;
+    } // end of "outer" loop
+
+  epilogue: // merge what is left from either cursor1 or cursor2
+
+    minGallop_ = (std::min)(minGallop, 1);
+
+    if (len2 == 1) {
+      GFX_TIMSORT_ASSERT(len1 > 0);
+      dest -= len1;
+      std::move_backward(cursor1 - len1, cursor1, dest + (1 + len1));
+      *dest = std::move(*cursor2);
+    } else {
+      GFX_TIMSORT_ASSERT(
+          len2 != 0 && "Comparison function violates its general contract");
+      GFX_TIMSORT_ASSERT(len1 == 0);
+      GFX_TIMSORT_ASSERT(len2 > 1);
+      std::move(tmp_.begin(), tmp_.begin() + len2, dest - (len2 - 1));
+    }
+  }
+
+  void copy_to_tmp(iter_t const begin, diff_t len) {
+    tmp_.assign(
+        std::make_move_iterator(begin), std::make_move_iterator(begin + len));
+  }
+
+ public:
+  static void
+  merge(iter_t const lo, iter_t const mid, iter_t const hi, Compare compare) {
+    GFX_TIMSORT_ASSERT(lo <= mid);
+    GFX_TIMSORT_ASSERT(mid <= hi);
+
+    if (lo == mid || mid == hi) {
+      return; // nothing to do
+    }
+
+    TimSort ts;
+    ts.mergeConsecutiveRuns(lo, mid - lo, mid, hi - mid, std::move(compare));
+
+    GFX_TIMSORT_LOG(
+        "1st size: " << (mid - lo) << "; 2nd size: " << (hi - mid)
+                     << "; tmp_.size(): " << ts.tmp_.size());
+  }
+
+  static void sort(iter_t const lo, iter_t const hi, Compare compare) {
+    GFX_TIMSORT_ASSERT(lo <= hi);
+
+    diff_t nRemaining = (hi - lo);
+    if (nRemaining < 2) {
+      return; // nothing to do
+    }
+
+    if (nRemaining < MIN_MERGE) {
+      diff_t const initRunLen = countRunAndMakeAscending(lo, hi, compare);
+      GFX_TIMSORT_LOG("initRunLen: " << initRunLen);
+      binarySort(lo, hi, lo + initRunLen, compare);
+      return;
+    }
+
+    TimSort ts;
+    diff_t const minRun = minRunLength(nRemaining);
+    iter_t cur = lo;
+    do {
+      diff_t runLen = countRunAndMakeAscending(cur, hi, compare);
+
+      if (runLen < minRun) {
+        diff_t const force = (std::min)(nRemaining, minRun);
+        binarySort(cur, cur + force, cur + runLen, compare);
+        runLen = force;
+      }
+
+      ts.pushRun(cur, runLen);
+      ts.mergeCollapse(compare);
+
+      cur += runLen;
+      nRemaining -= runLen;
+    } while (nRemaining != 0);
+
+    GFX_TIMSORT_ASSERT(cur == hi);
+    ts.mergeForceCollapse(compare);
+    GFX_TIMSORT_ASSERT(ts.pending_.size() == 1);
+
+    GFX_TIMSORT_LOG(
+        "size: " << (hi - lo) << " tmp_.size(): " << ts.tmp_.size()
+                 << " pending_.size(): " << ts.pending_.size());
+  }
+};
+
+} // namespace detail
+
+// ---------------------------------------
+// Public interface implementation
+// ---------------------------------------
+
+/**
+ * Stably merges two consecutive sorted ranges [first, middle) and [middle,
+ * last) into one sorted range [first, last) with a comparison function and a
+ * projection function.
+ */
+template <
+    typename RandomAccessIterator,
+    typename Compare = std::less<
+        typename std::iterator_traits<RandomAccessIterator>::value_type>,
+    typename Projection = detail::identity>
+void timmerge(
+    RandomAccessIterator first,
+    RandomAccessIterator middle,
+    RandomAccessIterator last,
+    Compare compare = {},
+    Projection projection = {}) {
+  typedef detail::projection_compare<Compare, Projection> compare_t;
+  compare_t comp(std::move(compare), std::move(projection));
+  GFX_TIMSORT_AUDIT(std::is_sorted(first, middle, comp) && "Precondition");
+  GFX_TIMSORT_AUDIT(std::is_sorted(middle, last, comp) && "Precondition");
+  detail::TimSort<RandomAccessIterator, compare_t>::merge(
+      first, middle, last, comp);
+  GFX_TIMSORT_AUDIT(std::is_sorted(first, last, comp) && "Postcondition");
+}
+
+/**
+ * Stably sorts a range with a comparison function and a projection function.
+ */
+template <
+    typename RandomAccessIterator,
+    typename Compare = std::less<
+        typename std::iterator_traits<RandomAccessIterator>::value_type>,
+    typename Projection = detail::identity>
+void timsort(
+    RandomAccessIterator const first,
+    RandomAccessIterator const last,
+    Compare compare = {},
+    Projection projection = {}) {
+  typedef detail::projection_compare<Compare, Projection> compare_t;
+  compare_t comp(std::move(compare), std::move(projection));
+  detail::TimSort<RandomAccessIterator, compare_t>::sort(first, last, comp);
+  GFX_TIMSORT_AUDIT(std::is_sorted(first, last, comp) && "Postcondition");
+}
+
+/**
+ * Stably sorts a range with a comparison function and a projection function.
+ */
+template <
+    typename RandomAccessRange,
+    typename Compare = std::less<typename std::iterator_traits<
+        decltype(std::begin(std::declval<RandomAccessRange>()))>::value_type>,
+    typename Projection = detail::identity>
+void timsort(
+    RandomAccessRange& range,
+    Compare compare = {},
+    Projection projection = {}) {
+  gfx::timsort(std::begin(range), std::end(range), compare, projection);
+}
+
+} // namespace gfx
+
+#undef GFX_TIMSORT_ENABLE_ASSERT
+#undef GFX_TIMSORT_ASSERT
+#undef GFX_TIMSORT_ENABLE_AUDIT
+#undef GFX_TIMSORT_AUDIT
+#undef GFX_TIMSORT_ENABLE_LOG
+#undef GFX_TIMSORT_LOG
+
+#endif // GFX_TIMSORT_HPP
diff --git a/velox/external/utf8proc/utf8proc.h b/velox/external/utf8proc/utf8proc.h
index 9a76d2ae12141..17a13d1b6be25 100644
--- a/velox/external/utf8proc/utf8proc.h
+++ b/velox/external/utf8proc/utf8proc.h
@@ -229,16 +229,16 @@ typedef enum {
  */
 /** @{ */
 /** Memory could not be allocated. */
-#define UTF8PROC_ERROR_NOMEM -1
+#define UTF8PROC_ERROR_NOMEM (-1)
 /** The given string is too long to be processed. */
-#define UTF8PROC_ERROR_OVERFLOW -2
+#define UTF8PROC_ERROR_OVERFLOW (-2)
 /** The given string is not a legal UTF-8 string. */
-#define UTF8PROC_ERROR_INVALIDUTF8 -3
+#define UTF8PROC_ERROR_INVALIDUTF8 (-3)
 /** The @ref UTF8PROC_REJECTNA flag was set and an unassigned codepoint was
  * found. */
-#define UTF8PROC_ERROR_NOTASSIGNED -4
+#define UTF8PROC_ERROR_NOTASSIGNED (-4)
 /** Invalid options have been used. */
-#define UTF8PROC_ERROR_INVALIDOPTS -5
+#define UTF8PROC_ERROR_INVALIDOPTS (-5)
 /** @} */
 
 /* @name Types */
diff --git a/velox/external/utf8proc/utf8procImpl.h b/velox/external/utf8proc/utf8procImpl.h
index dc9a4d2a766f0..8be8ff72f3e3a 100644
--- a/velox/external/utf8proc/utf8procImpl.h
+++ b/velox/external/utf8proc/utf8procImpl.h
@@ -384,7 +384,7 @@ UTF8PROC_DLLEXPORT utf8proc_bool utf8proc_grapheme_break_stateful(
 
 UTF8PROC_DLLEXPORT utf8proc_bool
 utf8proc_grapheme_break(utf8proc_int32_t c1, utf8proc_int32_t c2) {
-  return utf8proc_grapheme_break_stateful(c1, c2, NULL);
+  return utf8proc_grapheme_break_stateful(c1, c2, nullptr);
 }
 
 static utf8proc_int32_t seqindex_decode_entry(const utf8proc_uint16_t** entry) {
@@ -421,7 +421,7 @@ static utf8proc_ssize_t seqindex_write_char_decomposed(
 
     written += utf8proc_decompose_char(
         entry_cp,
-        dst + written,
+        dst ? dst + written : dst,
         (bufsize > written) ? (bufsize - written) : 0,
         options,
         last_boundclass);
@@ -589,7 +589,7 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose(
     utf8proc_ssize_t bufsize,
     utf8proc_int16_t options) {
   return utf8proc_decompose_custom(
-      str, strlen, buffer, bufsize, options, NULL, NULL);
+      str, strlen, buffer, bufsize, options, nullptr, nullptr);
 }
 
 UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom(
@@ -635,7 +635,7 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_decompose_custom(
       }
       decomp_result = utf8proc_decompose_char(
           uc,
-          buffer + wpos,
+          buffer ? buffer + wpos : buffer,
           (bufsize > wpos) ? (bufsize - wpos) : 0,
           options,
           &boundclass);
diff --git a/velox/flag_definitions/CMakeLists.txt b/velox/flag_definitions/CMakeLists.txt
index 276f4bf4bbbe4..8569cc3f997d8 100644
--- a/velox/flag_definitions/CMakeLists.txt
+++ b/velox/flag_definitions/CMakeLists.txt
@@ -11,5 +11,5 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_flag_definitions OBJECT flags.cpp)
-target_link_libraries(velox_flag_definitions PRIVATE gflags::gflags)
+velox_add_library(velox_flag_definitions OBJECT flags.cpp)
+velox_link_libraries(velox_flag_definitions PRIVATE gflags::gflags)
diff --git a/velox/flag_definitions/flags.cpp b/velox/flag_definitions/flags.cpp
index d25ae44713f1b..ee308964ac7ba 100644
--- a/velox/flag_definitions/flags.cpp
+++ b/velox/flag_definitions/flags.cpp
@@ -16,12 +16,7 @@
 
 #include <gflags/gflags.h>
 
-// Used in velox/common/memory/MappedMemory.cpp
-
-DEFINE_int32(
-    velox_memory_pool_mb,
-    4 * 1024,
-    "Size of file cache/operator working memory in MB");
+// Used in velox/common/memory/Memory.cpp
 
 DEFINE_int32(
     velox_memory_num_shared_leaf_pools,
@@ -30,7 +25,7 @@ DEFINE_int32(
 
 DEFINE_bool(
     velox_time_allocations,
-    true,
+    false,
     "Record time and volume for large allocation/free");
 
 // Used in common/base/VeloxException.cpp
diff --git a/velox/functions/CMakeLists.txt b/velox/functions/CMakeLists.txt
index 6afd4edbccf21..77e5f83428d5e 100644
--- a/velox/functions/CMakeLists.txt
+++ b/velox/functions/CMakeLists.txt
@@ -11,12 +11,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_function_registry FunctionRegistry.cpp)
-add_library(velox_coverage_util CoverageUtil.cpp)
+velox_add_library(velox_function_registry FunctionRegistry.cpp)
+velox_add_library(velox_coverage_util CoverageUtil.cpp)
 
-target_link_libraries(velox_function_registry velox_expression velox_type
-                      velox_core velox_exception)
-target_link_libraries(velox_coverage_util velox_function_registry)
+velox_link_libraries(
+  velox_function_registry
+  velox_expression
+  velox_type
+  velox_core
+  velox_exception)
+velox_link_libraries(velox_coverage_util velox_function_registry)
 add_subdirectory(lib)
 if(${VELOX_ENABLE_PRESTO_FUNCTIONS})
   add_subdirectory(prestosql)
diff --git a/velox/functions/CoverageUtil.cpp b/velox/functions/CoverageUtil.cpp
index b9877b4f0a717..9f941790bee78 100644
--- a/velox/functions/CoverageUtil.cpp
+++ b/velox/functions/CoverageUtil.cpp
@@ -49,10 +49,9 @@ class TablePrinter {
         columnSize_ * numScalarColumns_ + 2 * (numScalarColumns_ - 1);
 
     out_ << indent_ << std::left << std::setw(scalarFunctionsColumnWidth)
-         << "Scalar Functions"
-         << "      " << std::setw(columnSize_) << "Aggregate Functions"
-         << "      "
-         << "Window Functions" << std::endl;
+         << "Scalar Functions" << "      " << std::setw(columnSize_)
+         << "Aggregate Functions" << "      " << "Window Functions"
+         << std::endl;
     out_ << indent_ << std::string(scalarFunctionsColumnWidth, '=')
          << "  ==  " << line << "  ==  " << line << std::endl;
   }
@@ -166,16 +165,13 @@ void printTableCss(
   out << "    div.body {max-width: 1300px;}" << std::endl;
   out << "    table.coverage th {background-color: lightblue; text-align: center;}"
       << std::endl;
-  out << "    table.coverage "
-      << "td:nth-child(" << numScalarColumns + 1 << ") "
-      << "{background-color: lightblue;}" << std::endl;
-  out << "    table.coverage "
-      << "td:nth-child(" << numScalarColumns + 3 << ") "
-      << "{background-color: lightblue;}" << std::endl;
+  out << "    table.coverage " << "td:nth-child(" << numScalarColumns + 1
+      << ") " << "{background-color: lightblue;}" << std::endl;
+  out << "    table.coverage " << "td:nth-child(" << numScalarColumns + 3
+      << ") " << "{background-color: lightblue;}" << std::endl;
 
   for (const auto& entry : cellTracker.cells()) {
-    out << "    table.coverage "
-        << "tr:nth-child(" << entry.first + 1 << ") "
+    out << "    table.coverage " << "tr:nth-child(" << entry.first + 1 << ") "
         << "td:nth-child(" << entry.second + 1 << ") "
         << "{background-color: #6BA81E;}" << std::endl;
   }
diff --git a/velox/functions/FunctionRegistry.cpp b/velox/functions/FunctionRegistry.cpp
index ba9411cc3d26c..5ee951c80c1e3 100644
--- a/velox/functions/FunctionRegistry.cpp
+++ b/velox/functions/FunctionRegistry.cpp
@@ -32,19 +32,6 @@
 namespace facebook::velox {
 namespace {
 
-exec::TypeSignature typeToTypeSignature(std::shared_ptr<const Type> type) {
-  std::vector<exec::TypeSignature> children;
-  if (type->size()) {
-    children.reserve(type->size());
-    for (auto i = 0; i < type->size(); i++) {
-      children.emplace_back(typeToTypeSignature(type->childAt(i)));
-    }
-  }
-  const std::string& kindName = type->kindName();
-  return exec::TypeSignature(
-      boost::algorithm::to_lower_copy(kindName), std::move(children));
-}
-
 void populateSimpleFunctionSignatures(FunctionSignatureMap& map) {
   const auto& simpleFunctions = exec::simpleFunctions();
   for (const auto& functionName : simpleFunctions.getFunctionNames()) {
@@ -77,13 +64,38 @@ FunctionSignatureMap getFunctionSignatures() {
   return result;
 }
 
+FunctionSignatureMap getVectorFunctionSignatures() {
+  FunctionSignatureMap result;
+  populateVectorFunctionSignatures(result);
+  return result;
+}
+
 void clearFunctionRegistry() {
   exec::mutableSimpleFunctions().clearRegistry();
   exec::vectorFunctionFactories().withWLock(
       [](auto& functionMap) { functionMap.clear(); });
 }
 
-std::shared_ptr<const Type> resolveFunction(
+std::optional<bool> isDeterministic(const std::string& functionName) {
+  const auto simpleFunctions =
+      exec::simpleFunctions().getFunctionSignaturesAndMetadata(functionName);
+  const auto metadata = exec::getVectorFunctionMetadata(functionName);
+  if (simpleFunctions.empty() && !metadata.has_value()) {
+    return std::nullopt;
+  }
+
+  for (const auto& [metadata, _] : simpleFunctions) {
+    if (!metadata.deterministic) {
+      return false;
+    }
+  }
+  if (metadata.has_value() && !metadata.value().deterministic) {
+    return false;
+  }
+  return true;
+}
+
+TypePtr resolveFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
   // Check if this is a simple function.
@@ -95,7 +107,20 @@ std::shared_ptr<const Type> resolveFunction(
   return resolveVectorFunction(functionName, argTypes);
 }
 
-std::shared_ptr<const Type> resolveFunctionOrCallableSpecialForm(
+std::optional<std::pair<TypePtr, exec::VectorFunctionMetadata>>
+resolveFunctionWithMetadata(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes) {
+  if (auto resolvedFunction =
+          exec::simpleFunctions().resolveFunction(functionName, argTypes)) {
+    return std::pair<TypePtr, exec::VectorFunctionMetadata>{
+        resolvedFunction->type(), resolvedFunction->metadata()};
+  }
+
+  return exec::resolveVectorFunctionWithMetadata(functionName, argTypes);
+}
+
+TypePtr resolveFunctionOrCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
   if (auto returnType = resolveCallableSpecialForm(functionName, argTypes)) {
@@ -105,13 +130,13 @@ std::shared_ptr<const Type> resolveFunctionOrCallableSpecialForm(
   return resolveFunction(functionName, argTypes);
 }
 
-std::shared_ptr<const Type> resolveCallableSpecialForm(
+TypePtr resolveCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
   return exec::resolveTypeForSpecialForm(functionName, argTypes);
 }
 
-std::shared_ptr<const Type> resolveSimpleFunction(
+TypePtr resolveSimpleFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
   if (auto resolvedFunction =
@@ -122,10 +147,17 @@ std::shared_ptr<const Type> resolveSimpleFunction(
   return nullptr;
 }
 
-std::shared_ptr<const Type> resolveVectorFunction(
+TypePtr resolveVectorFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
   return exec::resolveVectorFunction(functionName, argTypes);
 }
 
+std::optional<std::pair<TypePtr, exec::VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadata(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes) {
+  return exec::resolveVectorFunctionWithMetadata(functionName, argTypes);
+}
+
 } // namespace facebook::velox
diff --git a/velox/functions/FunctionRegistry.h b/velox/functions/FunctionRegistry.h
index 4543d2d569feb..04b86cfb49d5b 100644
--- a/velox/functions/FunctionRegistry.h
+++ b/velox/functions/FunctionRegistry.h
@@ -18,6 +18,7 @@
 #include <string>
 #include <vector>
 
+#include "velox/expression/FunctionMetadata.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/type/Type.h"
 
@@ -25,20 +26,38 @@ namespace facebook::velox {
 
 using FunctionSignatureMap = std::
     unordered_map<std::string, std::vector<const exec::FunctionSignature*>>;
+
 /// Returns a mapping of all Simple and Vector functions registered in Velox
 /// The mapping is function name -> list of function signatures
 FunctionSignatureMap getFunctionSignatures();
 
+/// Returns a mapping of all Vector functions registered in Velox
+/// The mapping is function name -> list of function signatures
+FunctionSignatureMap getVectorFunctionSignatures();
+
+/// Returns if a function is deterministic by fetching all registry entries for
+/// the given function name and checking if all of them are deterministic.
+/// Returns std::nullopt if the function is not found. Returns false if any of
+/// the entries are not deterministic.
+std::optional<bool> isDeterministic(const std::string& functionName);
+
 /// Given a function name and argument types, returns
 /// the return type if function exists otherwise returns nullptr
-std::shared_ptr<const Type> resolveFunction(
+TypePtr resolveFunction(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes);
+
+/// Given a function name and argument types, returns a pair of return
+/// type and metadata if function exists. Otherwise, returns std::nullopt.
+std::optional<std::pair<TypePtr, exec::VectorFunctionMetadata>>
+resolveFunctionWithMetadata(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
 /// Given a function name and argument types, returns the return type if the
 /// function exists or is a special form that supports type resolution (see
 /// resolveCallableSpecialForm), otherwise returns nullptr.
-std::shared_ptr<const Type> resolveFunctionOrCallableSpecialForm(
+TypePtr resolveFunctionOrCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
@@ -50,22 +69,30 @@ std::shared_ptr<const Type> resolveFunctionOrCallableSpecialForm(
 /// or
 /// 2) their return types cannot be inferred from their argument types, e.g.
 ///    Cast.
-std::shared_ptr<const Type> resolveCallableSpecialForm(
+TypePtr resolveCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
 /// Given name of simple function and argument types, returns
 /// the return type if function exists otherwise returns nullptr
-std::shared_ptr<const Type> resolveSimpleFunction(
+TypePtr resolveSimpleFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
 /// Given name of vector function and argument types, returns
 /// the return type if function exists otherwise returns nullptr
-std::shared_ptr<const Type> resolveVectorFunction(
+TypePtr resolveVectorFunction(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes);
+
+/// Given name of a vector function and argument types, returns a pair of return
+/// type and metadata if function exists. Otherwise, returns std::nullopt.
+std::optional<std::pair<TypePtr, exec::VectorFunctionMetadata>>
+resolveVectorFunctionWithMetadata(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
 /// Clears the function registry.
 void clearFunctionRegistry();
+
 } // namespace facebook::velox
diff --git a/velox/functions/Macros.h b/velox/functions/Macros.h
index e131cdec4f5f6..79c506072fa1b 100644
--- a/velox/functions/Macros.h
+++ b/velox/functions/Macros.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "velox/core/Metaprogramming.h"
+#include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 
 #define VELOX_DEFINE_FUNCTION_TYPES(__Velox_ExecParams)                 \
diff --git a/velox/functions/Registerer.h b/velox/functions/Registerer.h
index 16b53a3eaa177..7d29ef59f688b 100644
--- a/velox/functions/Registerer.h
+++ b/velox/functions/Registerer.h
@@ -34,12 +34,25 @@ struct TempWrapper {
 template <template <class...> typename T, typename... TArgs>
 using ParameterBinder = TempWrapper<T<exec::VectorExec, TArgs...>>;
 
+// Register a UDF with the given aliases. If an alias already
+// exists and 'overwrite' is true, the existing entry in the function
+// registry is overwritten by the current UDF. If an alias already exists and
+// 'overwrite' is false, the current UDF is not registered with this alias.
+// This method returns true if all 'aliases' are registered successfully. It
+// returns false if any alias in 'aliases' already exists in the registry and
+// is not overwritten.
 template <typename Func, typename TReturn, typename... TArgs>
-void registerFunction(const std::vector<std::string>& aliases = {}) {
+bool registerFunction(
+    const std::vector<std::string>& aliases = {},
+    bool overwrite = true) {
   using funcClass = typename Func::template udf<exec::VectorExec>;
-  using holderClass =
-      core::UDFHolder<funcClass, exec::VectorExec, TReturn, TArgs...>;
-  exec::registerSimpleFunction<holderClass>(aliases);
+  using holderClass = core::UDFHolder<
+      funcClass,
+      exec::VectorExec,
+      TReturn,
+      ConstantChecker<TArgs...>,
+      typename UnwrapConstantType<TArgs>::type...>;
+  return exec::registerSimpleFunction<holderClass>(aliases, {}, overwrite);
 }
 
 // New registration function; mostly a copy from the function above, but taking
@@ -47,11 +60,19 @@ void registerFunction(const std::vector<std::string>& aliases = {}) {
 // a while to maintain backwards compatibility, but the idea is to remove the
 // one above eventually.
 template <template <class> typename Func, typename TReturn, typename... TArgs>
-void registerFunction(const std::vector<std::string>& aliases = {}) {
+bool registerFunction(
+    const std::vector<std::string>& aliases = {},
+    const std::vector<exec::SignatureVariable>& constraints = {},
+    bool overwrite = true) {
   using funcClass = Func<exec::VectorExec>;
-  using holderClass =
-      core::UDFHolder<funcClass, exec::VectorExec, TReturn, TArgs...>;
-  exec::registerSimpleFunction<holderClass>(aliases);
+  using holderClass = core::UDFHolder<
+      funcClass,
+      exec::VectorExec,
+      TReturn,
+      ConstantChecker<TArgs...>,
+      typename UnwrapConstantType<TArgs>::type...>;
+  return exec::registerSimpleFunction<holderClass>(
+      aliases, constraints, overwrite);
 }
 
 } // namespace facebook::velox
diff --git a/velox/functions/lib/ArrayShuffle.cpp b/velox/functions/lib/ArrayShuffle.cpp
new file mode 100644
index 0000000000000..b0f9c3685e1c0
--- /dev/null
+++ b/velox/functions/lib/ArrayShuffle.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <random>
+#include "velox/expression/EvalCtx.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::functions {
+namespace {
+// See documentation at
+// https://prestodb.io/docs/current/functions/array.html#shuffle
+//
+// This function will shuffle identical arrays independently, i.e. even when
+// the input has duplicate rows represented using constant and dictionary
+// encoding, the output is flat and likely yields different values.
+//
+// E.g.1: constant encoding
+// Input: ConstantVector(base=ArrayVector[{1,2,3}], length=3, index=0)
+// Possible Output: ArrayVector[{1,3,2},{2,3,1},{3,2,1}]
+//
+// E.g.2: dict encoding
+// Input: DictionaryVector(
+//   dictionaryValues=ArrayVector[{1,2,3},{4,5},{1,2,3}],
+//   dictionaryIndices=[1,2,0])
+// Possible Output: ArrayVector[{5,4},{2,1,3},{1,3,2}]
+//
+class ArrayShuffleFunction : public exec::VectorFunction {
+ public:
+  explicit ArrayShuffleFunction(int32_t seed)
+      : randGen_(std::make_unique<std::mt19937>(seed)) {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /*outputType*/,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VELOX_CHECK_GE(args.size(), 1);
+
+    // This is a non-deterministic function, which violates the guarantee on a
+    // deterministic single-arg function that the expression evaluation will
+    // peel off encodings, and we will only see flat or constant inputs. Hence,
+    // we need to use DecodedVector to handle ALL encodings.
+    exec::DecodedArgs decodedArgs(rows, args, context);
+    auto decodedArg = decodedArgs.at(0);
+    auto arrayVector = decodedArg->base()->as<ArrayVector>();
+    auto elementsVector = arrayVector->elements();
+
+    vector_size_t numElements = 0;
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto size = arrayVector->sizeAt(decodedArg->index(row));
+      numElements += size;
+    });
+
+    // Allocate new buffer to hold shuffled indices.
+    BufferPtr shuffledIndices = allocateIndices(numElements, context.pool());
+    BufferPtr offsets = allocateOffsets(rows.end(), context.pool());
+    BufferPtr sizes = allocateSizes(rows.end(), context.pool());
+
+    vector_size_t* rawIndices = shuffledIndices->asMutable<vector_size_t>();
+    vector_size_t* rawOffsets = offsets->asMutable<vector_size_t>();
+    vector_size_t* rawSizes = sizes->asMutable<vector_size_t>();
+
+    vector_size_t newOffset = 0;
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      vector_size_t arrayRow = decodedArg->index(row);
+      vector_size_t size = arrayVector->sizeAt(arrayRow);
+      vector_size_t offset = arrayVector->offsetAt(arrayRow);
+
+      std::iota(rawIndices + newOffset, rawIndices + newOffset + size, offset);
+      std::shuffle(
+          rawIndices + newOffset, rawIndices + newOffset + size, *randGen_);
+
+      rawSizes[row] = size;
+      rawOffsets[row] = newOffset;
+      newOffset += size;
+    });
+
+    auto resultElements = BaseVector::wrapInDictionary(
+        nullptr, shuffledIndices, numElements, elementsVector);
+    auto localResult = std::make_shared<ArrayVector>(
+        context.pool(),
+        arrayVector->type(),
+        nullptr,
+        rows.end(),
+        std::move(offsets),
+        std::move(sizes),
+        std::move(resultElements));
+
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+ private:
+  std::unique_ptr<std::mt19937> randGen_;
+};
+} // namespace
+
+exec::VectorFunctionMetadata getMetadataForArrayShuffle() {
+  return exec::VectorFunctionMetadataBuilder().deterministic(false).build();
+}
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> arrayShuffleSignatures() {
+  return {// array(T) -> array(T)
+          exec::FunctionSignatureBuilder()
+              .typeVariable("T")
+              .returnType("array(T)")
+              .argumentType("array(T)")
+              .build()};
+}
+
+std::shared_ptr<exec::VectorFunction> makeArrayShuffle(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  return std::make_unique<ArrayShuffleFunction>(std::random_device{}());
+}
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+arrayShuffleWithCustomSeedSignatures() {
+  return {exec::FunctionSignatureBuilder()
+              .typeVariable("T")
+              .returnType("array(T)")
+              .argumentType("array(T)")
+              .constantArgumentType("bigint")
+              .build()};
+}
+
+std::shared_ptr<exec::VectorFunction> makeArrayShuffleWithCustomSeed(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  VELOX_USER_CHECK_EQ(inputArgs.size(), 2);
+  VELOX_USER_CHECK_EQ(inputArgs[1].type->kind(), TypeKind::BIGINT);
+  VELOX_USER_CHECK_NOT_NULL(inputArgs[1].constantValue);
+  VELOX_CHECK(!inputArgs[1].constantValue->isNullAt(0));
+
+  const auto seed = inputArgs[1]
+                        .constantValue->template as<ConstantVector<int64_t>>()
+                        ->valueAt(0);
+  return std::make_shared<ArrayShuffleFunction>(
+      seed + config.sparkPartitionId());
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/ArrayShuffle.h b/velox/functions/lib/ArrayShuffle.h
new file mode 100644
index 0000000000000..07d77fb0a39ab
--- /dev/null
+++ b/velox/functions/lib/ArrayShuffle.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::functions {
+
+/// Function metadata with 'deterministic' as false, it is used for both
+/// 'makeArrayShuffle' and 'makeArrayShuffleWithCustomSeed'.
+/// To ensure 'makeArrayShuffleWithCustomSeed' generates different sequences
+/// for constant inputs, We need to set 'deterministic' to false to prevent
+/// constant folding.
+exec::VectorFunctionMetadata getMetadataForArrayShuffle();
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> arrayShuffleSignatures();
+
+/// Shuffle with rand seed.
+std::shared_ptr<exec::VectorFunction> makeArrayShuffle(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+arrayShuffleWithCustomSeedSignatures();
+
+/// Shuffle with custom seed (Spark's behavior).
+std::shared_ptr<exec::VectorFunction> makeArrayShuffleWithCustomSeed(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/CMakeLists.txt b/velox/functions/lib/CMakeLists.txt
index 98f119992d650..bdff97bba2d95 100644
--- a/velox/functions/lib/CMakeLists.txt
+++ b/velox/functions/lib/CMakeLists.txt
@@ -12,27 +12,42 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_is_null_functions IsNull.cpp)
+velox_add_library(velox_is_null_functions IsNull.cpp)
 
-target_link_libraries(velox_is_null_functions velox_expression)
+velox_link_libraries(velox_is_null_functions velox_expression)
 
-add_library(velox_functions_util LambdaFunctionUtil.cpp RowsTranslationUtil.cpp)
+velox_add_library(velox_functions_util LambdaFunctionUtil.cpp
+                  RowsTranslationUtil.cpp)
 
-target_link_libraries(velox_functions_util velox_vector velox_common_base)
+velox_link_libraries(velox_functions_util velox_vector velox_common_base)
 
-add_library(
+velox_add_library(velox_functions_lib_date_time_formatter DateTimeFormatter.cpp
+                  DateTimeFormatterBuilder.cpp)
+
+velox_link_libraries(velox_functions_lib_date_time_formatter velox_type_tz)
+
+velox_add_library(
   velox_functions_lib
+  ArrayShuffle.cpp
   CheckDuplicateKeys.cpp
-  DateTimeFormatter.cpp
-  DateTimeFormatterBuilder.cpp
+  CheckNestedNulls.cpp
   KllSketch.cpp
   MapConcat.cpp
   Re2Functions.cpp
+  Repeat.cpp
+  Slice.cpp
   StringEncodingUtils.cpp
-  SubscriptUtil.cpp)
+  SubscriptUtil.cpp
+  TimeUtils.cpp
+  Utf8Utils.cpp)
 
-target_link_libraries(velox_functions_lib velox_functions_util velox_vector
-                      re2::re2 Folly::folly)
+velox_link_libraries(
+  velox_functions_lib
+  velox_functions_util
+  velox_vector
+  velox_type_tz
+  re2::re2
+  Folly::folly)
 
 add_subdirectory(aggregates)
 add_subdirectory(string)
diff --git a/velox/functions/lib/CheckDuplicateKeys.cpp b/velox/functions/lib/CheckDuplicateKeys.cpp
index ac8ddf6361432..346fcc11d59da 100644
--- a/velox/functions/lib/CheckDuplicateKeys.cpp
+++ b/velox/functions/lib/CheckDuplicateKeys.cpp
@@ -32,6 +32,9 @@ void checkDuplicateKeys(
   auto sizes = mapVector->rawSizes();
   auto mapKeys = mapVector->mapKeys();
   context.applyToSelectedNoThrow(rows, [&](auto row) {
+    if (mapVector->isNullAt(row)) {
+      return;
+    }
     auto offset = offsets[row];
     auto size = sizes[row];
     for (auto i = 1; i < size; i++) {
diff --git a/velox/functions/lib/CheckNestedNulls.cpp b/velox/functions/lib/CheckNestedNulls.cpp
new file mode 100644
index 0000000000000..348535c9ce6b8
--- /dev/null
+++ b/velox/functions/lib/CheckNestedNulls.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/CheckNestedNulls.h"
+
+namespace facebook::velox::functions {
+
+/// Checks nested nulls in a complex type vector. Returns true if value at
+/// specified index is null. Throws an exception if the base vector contains
+/// nulls if 'throwOnNestedNulls' is true.
+bool checkNestedNulls(
+    const DecodedVector& decoded,
+    const vector_size_t* indices,
+    vector_size_t index,
+    bool throwOnNestedNulls) {
+  if (decoded.isNullAt(index)) {
+    return true;
+  }
+
+  if (throwOnNestedNulls) {
+    VELOX_USER_CHECK(
+        !decoded.base()->containsNullAt(indices[index]),
+        "{} comparison not supported for values that contain nulls",
+        mapTypeKindToName(decoded.base()->typeKind()));
+  }
+
+  return false;
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/CheckNestedNulls.h b/velox/functions/lib/CheckNestedNulls.h
new file mode 100644
index 0000000000000..eafbbe95c7368
--- /dev/null
+++ b/velox/functions/lib/CheckNestedNulls.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox::functions {
+
+/// Checks nested nulls in a complex type vector. Returns true if value at
+/// specified index is null. Throws an exception if the base vector contains
+/// nulls if 'throwOnNestedNulls' is true.
+bool checkNestedNulls(
+    const DecodedVector& decoded,
+    const vector_size_t* indices,
+    vector_size_t index,
+    bool throwOnNestedNulls = false);
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/CheckedArithmetic.h b/velox/functions/lib/CheckedArithmetic.h
similarity index 97%
rename from velox/functions/prestosql/CheckedArithmetic.h
rename to velox/functions/lib/CheckedArithmetic.h
index fb7876b2c3f8a..1f18ed9125b20 100644
--- a/velox/functions/prestosql/CheckedArithmetic.h
+++ b/velox/functions/lib/CheckedArithmetic.h
@@ -17,9 +17,9 @@
 
 #include <functional>
 #include <limits>
-#include "CheckedArithmeticImpl.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/functions/Macros.h"
+#include "velox/functions/lib/CheckedArithmeticImpl.h"
 
 namespace facebook::velox::functions {
 
diff --git a/velox/functions/prestosql/CheckedArithmeticImpl.h b/velox/functions/lib/CheckedArithmeticImpl.h
similarity index 100%
rename from velox/functions/prestosql/CheckedArithmeticImpl.h
rename to velox/functions/lib/CheckedArithmeticImpl.h
diff --git a/velox/functions/lib/DateTimeFormatter.cpp b/velox/functions/lib/DateTimeFormatter.cpp
index 52737c178f56d..515ba2e444433 100644
--- a/velox/functions/lib/DateTimeFormatter.cpp
+++ b/velox/functions/lib/DateTimeFormatter.cpp
@@ -16,10 +16,12 @@
 
 #include "velox/functions/lib/DateTimeFormatter.h"
 #include <folly/String.h>
-#include <velox/common/base/Exceptions.h>
+#include <charconv>
 #include <cstring>
 #include <stdexcept>
+#include "velox/common/base/CountBits.h"
 #include "velox/external/date/date.h"
+#include "velox/external/date/iso_week.h"
 #include "velox/external/date/tz.h"
 #include "velox/functions/lib/DateTimeFormatterBuilder.h"
 #include "velox/type/TimestampConversion.h"
@@ -59,7 +61,7 @@ struct Date {
 
   bool isClockHour = false; // Whether most recent hour specifier is clockhour
   bool isHourOfHalfDay =
-      false; // Whether most recent hour specifier is of half day.
+      true; // Whether most recent hour specifier is of half day.
 
   std::vector<int32_t> dayOfMonthValues;
   std::vector<int32_t> dayOfYearValues;
@@ -152,7 +154,7 @@ static std::
             // Lower case.
             {"jan", {"uary", 1}},
             {"feb", {"ruary", 2}},
-            {"mar", {"rch", 3}},
+            {"mar", {"ch", 3}},
             {"apr", {"il", 4}},
             {"may", {"", 5}},
             {"jun", {"e", 6}},
@@ -166,7 +168,7 @@ static std::
             // Upper case.
             {"JAN", {"UARY", 1}},
             {"FEB", {"RUARY", 2}},
-            {"MAR", {"RCH", 3}},
+            {"MAR", {"CH", 3}},
             {"APR", {"IL", 4}},
             {"MAY", {"", 5}},
             {"JUN", {"E", 6}},
@@ -177,40 +179,56 @@ static std::
             {"NOV", {"EMBER", 11}},
             {"DEC", {"EMBER", 12}},
         };
-constexpr int monthsFullLength[] = {7, 8, 5, 5, 3, 4, 4, 6, 9, 7, 8, 8};
-
-/// Pads the content with desired padding characters. E.g. if we need to pad 999
-/// with three 0s in front, the result will be '000999'
-/// \param content the content that is going to be padded.
-/// \param padding the padding that is going to be used to pad the content.
-/// \param totalDigits the total number of digits the padded result is desired
-/// to be. If totalDigits is already smaller than content length, the original
-/// content will be returned with no padding
-/// \param padFront if the padding is in front of the content or back of the
-/// content.
+
+// Pads the content with desired padding characters. E.g. if we need to pad 999
+// with three 0s in front, the result will be '000999'.
+// @param content the content that is going to be padded.
+// @param padding the padding that is going to be used to pad the content.
+// @param totalDigits the total number of digits the padded result is desired
+// to be. If totalDigits is already smaller than content length, the original
+// content will be returned with no padding.
+// @param maxResultEnd the end pointer to result.
+// @param result the pointer to string result.
+// @param padFront if the padding is in front of the content or back of the
+// content.
 template <typename T>
-std::string padContent(
+int32_t padContent(
     const T& content,
     char padding,
-    size_t totalDigits,
-    bool padFront = true) {
-  std::string strContent = folly::to<std::string>(content);
-  auto contentLength = strContent.size();
+    const size_t totalDigits,
+    char* maxResultEnd,
+    char* result,
+    const bool padFront = true) {
+  const bool isNegative = content < 0;
+  const auto digitLength =
+      isNegative ? countDigits(-(__int128_t)content) : countDigits(content);
+  const auto contentLength = isNegative ? digitLength + 1 : digitLength;
   if (contentLength == 0) {
-    return std::string(totalDigits, padding);
+    std::fill(result, result + totalDigits, padding);
+    return totalDigits;
   }
 
-  bool isNegative = strContent[0] == '-';
-  auto digitLength = contentLength - (isNegative ? 1 : 0);
+  std::to_chars_result toStatus;
   if (digitLength >= totalDigits) {
-    return strContent;
+    toStatus = std::to_chars(result, maxResultEnd, content);
+    return toStatus.ptr - result;
   }
-  std::string paddingStr(totalDigits - digitLength, padding);
+  const auto paddingSize = totalDigits - digitLength;
   if (padFront) {
-    return strContent.insert((isNegative ? 1 : 0), paddingStr);
-  } else {
-    return strContent.append(paddingStr);
+    if (isNegative) {
+      *result = '-';
+      std::fill(result + 1, result + 1 + paddingSize, padding);
+      toStatus =
+          std::to_chars(result + 1 + paddingSize, maxResultEnd, -content);
+    } else {
+      std::fill(result, result + paddingSize, padding);
+      toStatus = std::to_chars(result + paddingSize, maxResultEnd, content);
+    }
+    return toStatus.ptr - result;
   }
+  toStatus = std::to_chars(result, maxResultEnd, content);
+  std::fill(toStatus.ptr, toStatus.ptr + paddingSize, padding);
+  return toStatus.ptr - result + paddingSize;
 }
 
 size_t countOccurence(const std::string_view& base, const std::string& target) {
@@ -277,15 +295,16 @@ bool specAllowsPlusSign(DateTimeFormatSpecifier s, bool specifierNext) {
   }
 }
 
-void parseFail(
-    const std::string_view& input,
-    const char* cur,
-    const char* end) {
-  VELOX_DCHECK(cur <= end);
-  VELOX_USER_FAIL(
-      "Invalid format: \"{}\" is malformed at \"{}\"",
+Expected<DateTimeResult>
+parseFail(const std::string_view& input, const char* cur, const char* end) {
+  VELOX_DCHECK_LE(cur, end);
+  if (threadSkipErrorDetails()) {
+    return folly::makeUnexpected(Status::UserError());
+  }
+  return folly::makeUnexpected(Status::UserError(
+      "Invalid date format: '{}' is malformed at '{}'",
       input,
-      std::string_view(cur, end - cur));
+      std::string_view(cur, end - cur)));
 }
 
 // Joda only supports parsing a few three-letter prefixes. The list is available
@@ -302,14 +321,14 @@ int64_t parseTimezone(const char* cur, const char* end, Date& date) {
       static std::unordered_map<std::string_view, int64_t> defaultTzNames{
           {"UTC", 0},
           {"GMT", 0},
-          {"EST", util::getTimeZoneID("America/New_York")},
-          {"EDT", util::getTimeZoneID("America/New_York")},
-          {"CST", util::getTimeZoneID("America/Chicago")},
-          {"CDT", util::getTimeZoneID("America/Chicago")},
-          {"MST", util::getTimeZoneID("America/Denver")},
-          {"MDT", util::getTimeZoneID("America/Denver")},
-          {"PST", util::getTimeZoneID("America/Los_Angeles")},
-          {"PDT", util::getTimeZoneID("America/Los_Angeles")},
+          {"EST", tz::getTimeZoneID("America/New_York")},
+          {"EDT", tz::getTimeZoneID("America/New_York")},
+          {"CST", tz::getTimeZoneID("America/Chicago")},
+          {"CDT", tz::getTimeZoneID("America/Chicago")},
+          {"MST", tz::getTimeZoneID("America/Denver")},
+          {"MDT", tz::getTimeZoneID("America/Denver")},
+          {"PST", tz::getTimeZoneID("America/Los_Angeles")},
+          {"PDT", tz::getTimeZoneID("America/Los_Angeles")},
       };
 
       auto it = defaultTzNames.find(std::string_view(cur, 3));
@@ -324,7 +343,7 @@ int64_t parseTimezone(const char* cur, const char* end, Date& date) {
       return 2;
     }
   }
-  throw std::runtime_error("Unable to parse timezone.");
+  return -1;
 }
 
 int64_t parseTimezoneOffset(const char* cur, const char* end, Date& date) {
@@ -344,7 +363,10 @@ int64_t parseTimezoneOffset(const char* cur, const char* end, Date& date) {
         if (std::strncmp(cur + 1, "00:00", 5) == 0) {
           date.timezoneId = 0;
         } else {
-          date.timezoneId = util::getTimeZoneID(std::string_view(cur, 6));
+          date.timezoneId = tz::getTimeZoneID(std::string_view(cur, 6), false);
+          if (date.timezoneId == -1) {
+            return -1;
+          }
         }
         return 6;
       }
@@ -359,8 +381,10 @@ int64_t parseTimezoneOffset(const char* cur, const char* end, Date& date) {
           // thread_local buffer to prevent extra allocations.
           std::memcpy(&timezoneBuffer[0], cur, 3);
           std::memcpy(&timezoneBuffer[4], cur + 3, 2);
-
-          date.timezoneId = util::getTimeZoneID(timezoneBuffer);
+          date.timezoneId = tz::getTimeZoneID(timezoneBuffer, false);
+          if (date.timezoneId == -1) {
+            return -1;
+          }
         }
         return 5;
       }
@@ -375,18 +399,35 @@ int64_t parseTimezoneOffset(const char* cur, const char* end, Date& date) {
           // buffer to prevent extra allocations.
           std::memcpy(&timezoneBuffer[0], cur, 3);
           std::memcpy(&timezoneBuffer[4], defaultTrailingOffset, 2);
-          date.timezoneId = util::getTimeZoneID(timezoneBuffer);
+          date.timezoneId = tz::getTimeZoneID(timezoneBuffer, false);
+          if (date.timezoneId == -1) {
+            return -1;
+          }
         }
         return 3;
       }
     }
-    // Single 'Z' character maps to GMT
+    // Single 'Z' character maps to GMT.
     else if (*cur == 'Z') {
       date.timezoneId = 0;
       return 1;
     }
+    // "UTC", "UCT", "GMT" and "GMT0" are also acceptable by joda.
+    else if ((end - cur) >= 3) {
+      if (std::strncmp(cur, "UTC", 3) == 0 ||
+          std::strncmp(cur, "UCT", 3) == 0) {
+        date.timezoneId = 0;
+        return 3;
+      } else if (std::strncmp(cur, "GMT", 3) == 0) {
+        date.timezoneId = 0;
+        if ((end - cur) >= 4 && *(cur + 3) == '0') {
+          return 4;
+        }
+        return 3;
+      }
+    }
   }
-  throw std::runtime_error("Unable to parse timezone offset id.");
+  return -1;
 }
 
 int64_t parseEra(const char* cur, const char* end, Date& date) {
@@ -399,10 +440,10 @@ int64_t parseEra(const char* cur, const char* end, Date& date) {
       date.isAd = false;
       return 2;
     } else {
-      throw std::runtime_error("Unable to parse era.");
+      return -1;
     }
   } else {
-    throw std::runtime_error("Unable to parse era.");
+    return -1;
   }
 }
 
@@ -422,8 +463,7 @@ int64_t parseMonthText(const char* cur, const char* end, Date& date) {
       return 3;
     }
   }
-  throw std::runtime_error("Unable to parse month.");
-  return 0;
+  return -1;
 }
 
 int64_t parseDayOfWeekText(const char* cur, const char* end, Date& date) {
@@ -441,8 +481,7 @@ int64_t parseDayOfWeekText(const char* cur, const char* end, Date& date) {
       return 3;
     }
   }
-  throw std::runtime_error("Unable to parse day of week.");
-  return 0;
+  return -1;
 }
 
 int64_t parseHalfDayOfDay(const char* cur, const char* end, Date& date) {
@@ -455,10 +494,10 @@ int64_t parseHalfDayOfDay(const char* cur, const char* end, Date& date) {
       date.isAm = false;
       return 2;
     } else {
-      throw std::runtime_error("Unable to parse halfday of day.");
+      return -1;
     }
   } else {
-    throw std::runtime_error("Unable to parse halfday of day.");
+    return -1;
   }
 }
 
@@ -489,59 +528,109 @@ std::string formatFractionOfSecond(
   return toAdd;
 }
 
+int32_t appendTimezoneOffset(int64_t offset, char* result) {
+  int pos = 0;
+  if (offset >= 0) {
+    result[pos++] = '+';
+  } else {
+    result[pos++] = '-';
+    offset = -offset;
+  }
+
+  const auto hours = offset / 60 / 60;
+  if (hours < 10) {
+    result[pos++] = '0';
+    result[pos++] = char(hours + '0');
+  } else {
+    result[pos++] = char(hours / 10 + '0');
+    result[pos++] = char(hours % 10 + '0');
+  }
+
+  result[pos++] = ':';
+
+  const auto minutes = (offset / 60) % 60;
+  if LIKELY (minutes == 0) {
+    result[pos++] = '0';
+    result[pos++] = '0';
+  } else if (minutes < 10) {
+    result[pos++] = '0';
+    result[pos++] = char(minutes + '0');
+  } else {
+    result[pos++] = char(minutes / 10 + '0');
+    result[pos++] = char(minutes % 10 + '0');
+  }
+
+  const auto seconds = offset % 60;
+  if (seconds > 0) {
+    result[pos++] = ':';
+
+    if (seconds < 10) {
+      result[pos++] = '0';
+      result[pos++] = char(seconds + '0');
+    } else {
+      result[pos++] = char(seconds / 10 + '0');
+      result[pos++] = char(seconds % 10 + '0');
+    }
+  }
+
+  return pos;
+}
+
 // According to DateTimeFormatSpecifier enum class
-std::string getSpecifierName(int enumInt) {
-  switch (enumInt) {
-    case 0:
+std::string_view getSpecifierName(DateTimeFormatSpecifier specifier) {
+  switch (specifier) {
+    case DateTimeFormatSpecifier::ERA:
       return "ERA";
-    case 1:
+    case DateTimeFormatSpecifier::CENTURY_OF_ERA:
       return "CENTURY_OF_ERA";
-    case 2:
+    case DateTimeFormatSpecifier::YEAR_OF_ERA:
       return "YEAR_OF_ERA";
-    case 3:
+    case DateTimeFormatSpecifier::WEEK_YEAR:
       return "WEEK_YEAR";
-    case 4:
+    case DateTimeFormatSpecifier::WEEK_OF_WEEK_YEAR:
       return "WEEK_OF_WEEK_YEAR";
-    case 5:
+    case DateTimeFormatSpecifier::DAY_OF_WEEK_0_BASED:
       return "DAY_OF_WEEK_0_BASED";
-    case 6:
+    case DateTimeFormatSpecifier::DAY_OF_WEEK_1_BASED:
       return "DAY_OF_WEEK_1_BASED";
-    case 7:
+    case DateTimeFormatSpecifier::DAY_OF_WEEK_TEXT:
       return "DAY_OF_WEEK_TEXT";
-    case 8:
+    case DateTimeFormatSpecifier::YEAR:
       return "YEAR";
-    case 9:
+    case DateTimeFormatSpecifier::DAY_OF_YEAR:
       return "DAY_OF_YEAR";
-    case 10:
+    case DateTimeFormatSpecifier::MONTH_OF_YEAR:
       return "MONTH_OF_YEAR";
-    case 11:
+    case DateTimeFormatSpecifier::MONTH_OF_YEAR_TEXT:
       return "MONTH_OF_YEAR_TEXT";
-    case 12:
+    case DateTimeFormatSpecifier::DAY_OF_MONTH:
       return "DAY_OF_MONTH";
-    case 13:
+    case DateTimeFormatSpecifier::HALFDAY_OF_DAY:
       return "HALFDAY_OF_DAY";
-    case 14:
+    case DateTimeFormatSpecifier::HOUR_OF_HALFDAY:
       return "HOUR_OF_HALFDAY";
-    case 15:
+    case DateTimeFormatSpecifier::CLOCK_HOUR_OF_HALFDAY:
       return "CLOCK_HOUR_OF_HALFDAY";
-    case 16:
+    case DateTimeFormatSpecifier::HOUR_OF_DAY:
       return "HOUR_OF_DAY";
-    case 17:
+    case DateTimeFormatSpecifier::CLOCK_HOUR_OF_DAY:
       return "CLOCK_HOUR_OF_DAY";
-    case 18:
+    case DateTimeFormatSpecifier::MINUTE_OF_HOUR:
       return "MINUTE_OF_HOUR";
-    case 19:
+    case DateTimeFormatSpecifier::SECOND_OF_MINUTE:
       return "SECOND_OF_MINUTE";
-    case 20:
+    case DateTimeFormatSpecifier::FRACTION_OF_SECOND:
       return "FRACTION_OF_SECOND";
-    case 21:
+    case DateTimeFormatSpecifier::TIMEZONE:
       return "TIMEZONE";
-    case 22:
+    case DateTimeFormatSpecifier::TIMEZONE_OFFSET_ID:
       return "TIMEZONE_OFFSET_ID";
-    case 23:
+    case DateTimeFormatSpecifier::LITERAL_PERCENT:
       return "LITERAL_PERCENT";
-    default:
-      return "[Specifier not updated to conversion function yet]";
+    default: {
+      VELOX_UNREACHABLE("[Unexpected date format specifier]");
+      return ""; // Make compiler happy.
+    }
   }
 }
 
@@ -594,7 +683,9 @@ int getMaxDigitConsume(
   }
 }
 
-void parseFromPattern(
+// If failOnError is true, throws exception for parsing error. Otherwise,
+// returns -1. Returns 0 if no parsing error.
+int32_t parseFromPattern(
     FormatPattern curPattern,
     const std::string_view& input,
     const char*& cur,
@@ -603,52 +694,52 @@ void parseFromPattern(
     bool specifierNext,
     DateTimeFormatterType type) {
   if (curPattern.specifier == DateTimeFormatSpecifier::TIMEZONE_OFFSET_ID) {
-    try {
-      cur += parseTimezoneOffset(cur, end, date);
-    } catch (...) {
-      parseFail(input, cur, end);
+    auto size = parseTimezoneOffset(cur, end, date);
+    if (size == -1) {
+      return -1;
     }
+    cur += size;
   } else if (curPattern.specifier == DateTimeFormatSpecifier::TIMEZONE) {
-    try {
-      cur += parseTimezone(cur, end, date);
-    } catch (...) {
-      parseFail(input, cur, end);
+    auto size = parseTimezone(cur, end, date);
+    if (size == -1) {
+      return -1;
     }
+    cur += size;
   } else if (curPattern.specifier == DateTimeFormatSpecifier::ERA) {
-    try {
-      cur += parseEra(cur, end, date);
-    } catch (...) {
-      parseFail(input, cur, end);
+    auto size = parseEra(cur, end, date);
+    if (size == -1) {
+      return -1;
     }
+    cur += size;
   } else if (
       curPattern.specifier == DateTimeFormatSpecifier::MONTH_OF_YEAR_TEXT) {
-    try {
-      cur += parseMonthText(cur, end, date);
-      if (!date.hasYear) {
-        date.hasYear = true;
-        date.year = 2000;
-      }
-    } catch (...) {
-      parseFail(input, cur, end);
+    auto size = parseMonthText(cur, end, date);
+    if (size == -1) {
+      return -1;
+    }
+    cur += size;
+    if (!date.hasYear) {
+      date.hasYear = true;
+      date.year = 2000;
     }
   } else if (curPattern.specifier == DateTimeFormatSpecifier::HALFDAY_OF_DAY) {
-    try {
-      cur += parseHalfDayOfDay(cur, end, date);
-    } catch (...) {
-      parseFail(input, cur, end);
+    auto size = parseHalfDayOfDay(cur, end, date);
+    if (size == -1) {
+      return -1;
     }
+    cur += size;
   } else if (
       curPattern.specifier == DateTimeFormatSpecifier::DAY_OF_WEEK_TEXT) {
-    try {
-      cur += parseDayOfWeekText(cur, end, date);
-      date.weekDateFormat = true;
-      date.dayOfYearFormat = false;
-      if (!date.hasYear) {
-        date.hasYear = true;
-        date.year = 2000;
-      }
-    } catch (...) {
-      parseFail(input, cur, end);
+    auto size = parseDayOfWeekText(cur, end, date);
+    if (size == -1) {
+      return -1;
+    }
+    cur += size;
+    date.weekDateFormat = true;
+    date.dayOfYearFormat = false;
+    if (!date.hasYear) {
+      date.hasYear = true;
+      date.year = 2000;
     }
   } else {
     // Numeric specifier case
@@ -705,13 +796,15 @@ void parseFromPattern(
         }
       } else if (type == DateTimeFormatterType::MYSQL) {
         // In MySQL format, year read in must have exactly two digits, otherwise
-        // throw an error
+        // return -1 to indicate parsing error.
         if (count > 2) {
           // Larger than expected, print suffix.
-          parseFail(input, cur - count + 2, end);
+          cur = cur - count + 2;
+          return -1;
         } else {
           // Smaller than expected, print prefix.
-          parseFail(input, cur - count, end);
+          cur = cur - count;
+          return -1;
         }
       }
     } else {
@@ -724,7 +817,7 @@ void parseFromPattern(
 
     // Need to have read at least one digit.
     if (cur <= startPos) {
-      parseFail(input, cur, end);
+      return -1;
     }
 
     if (negative) {
@@ -735,8 +828,7 @@ void parseFromPattern(
       case DateTimeFormatSpecifier::CENTURY_OF_ERA:
         // Enforce Joda's year range if year was specified as "century of year".
         if (number < 0 || number > 2922789) {
-          VELOX_USER_FAIL(
-              "Value {} for year must be in the range [0,2922789]", number);
+          return -1;
         }
         date.centuryFormat = true;
         date.year = number * 100;
@@ -750,15 +842,11 @@ void parseFromPattern(
             (curPattern.specifier == DateTimeFormatSpecifier::YEAR_OF_ERA);
         // Enforce Joda's year range if year was specified as "year of era".
         if (date.isYearOfEra && (number > 292278993 || number < 1)) {
-          VELOX_USER_FAIL(
-              "Value {} for yearOfEra must be in the range [1,292278993]",
-              number);
+          return -1;
         }
         // Enforce Joda's year range if year was specified as "year".
         if (!date.isYearOfEra && (number > 292278994 || number < -292275055)) {
-          VELOX_USER_FAIL(
-              "Value {} for year must be in the range [-292275055,292278994]",
-              number);
+          return -1;
         }
         date.hasYear = true;
         date.year = number;
@@ -766,8 +854,7 @@ void parseFromPattern(
 
       case DateTimeFormatSpecifier::MONTH_OF_YEAR:
         if (number < 1 || number > 12) {
-          VELOX_USER_FAIL(
-              "Value {} for monthOfYear must be in the range [1,12]", number);
+          return -1;
         }
         date.month = number;
         date.weekDateFormat = false;
@@ -811,9 +898,7 @@ void parseFromPattern(
 
       case DateTimeFormatSpecifier::CLOCK_HOUR_OF_DAY:
         if (number > 24 || number < 1) {
-          VELOX_USER_FAIL(
-              "Value {} for clockHourOfDay must be in the range [1,24]",
-              number);
+          return -1;
         }
         date.isClockHour = true;
         date.isHourOfHalfDay = false;
@@ -822,9 +907,7 @@ void parseFromPattern(
 
       case DateTimeFormatSpecifier::HOUR_OF_DAY:
         if (number > 23 || number < 0) {
-          VELOX_USER_FAIL(
-              "Value {} for clockHourOfDay must be in the range [0,23]",
-              number);
+          return -1;
         }
         date.isClockHour = false;
         date.isHourOfHalfDay = false;
@@ -833,9 +916,7 @@ void parseFromPattern(
 
       case DateTimeFormatSpecifier::CLOCK_HOUR_OF_HALFDAY:
         if (number > 12 || number < 1) {
-          VELOX_USER_FAIL(
-              "Value {} for clockHourOfHalfDay must be in the range [1,12]",
-              number);
+          return -1;
         }
         date.isClockHour = true;
         date.isHourOfHalfDay = true;
@@ -844,8 +925,7 @@ void parseFromPattern(
 
       case DateTimeFormatSpecifier::HOUR_OF_HALFDAY:
         if (number > 11 || number < 0) {
-          VELOX_USER_FAIL(
-              "Value {} for hourOfHalfDay must be in the range [0,11]", number);
+          return -1;
         }
         date.isClockHour = false;
         date.isHourOfHalfDay = true;
@@ -854,17 +934,14 @@ void parseFromPattern(
 
       case DateTimeFormatSpecifier::MINUTE_OF_HOUR:
         if (number > 59 || number < 0) {
-          VELOX_USER_FAIL(
-              "Value {} for minuteOfHour must be in the range [0,59]", number);
+          return -1;
         }
         date.minute = number;
         break;
 
       case DateTimeFormatSpecifier::SECOND_OF_MINUTE:
         if (number > 59 || number < 0) {
-          VELOX_USER_FAIL(
-              "Value {} for secondOfMinute must be in the range [0,59]",
-              number);
+          return -1;
         }
         date.second = number;
         break;
@@ -876,9 +953,7 @@ void parseFromPattern(
       case DateTimeFormatSpecifier::WEEK_YEAR:
         // Enforce Joda's year range if year was specified as "week year".
         if (number < -292275054 || number > 292278993) {
-          VELOX_USER_FAIL(
-              "Value {} for year must be in the range [-292275054,292278993]",
-              number);
+          return -1;
         }
         date.year = number;
         date.weekDateFormat = true;
@@ -889,9 +964,7 @@ void parseFromPattern(
 
       case DateTimeFormatSpecifier::WEEK_OF_WEEK_YEAR:
         if (number < 1 || number > 52) {
-          VELOX_USER_FAIL(
-              "Value {} for weekOfWeekYear must be in the range [1,52]",
-              number);
+          return -1;
         }
         date.week = number;
         date.weekDateFormat = true;
@@ -904,8 +977,7 @@ void parseFromPattern(
 
       case DateTimeFormatSpecifier::DAY_OF_WEEK_1_BASED:
         if (number < 1 || number > 7) {
-          VELOX_USER_FAIL(
-              "Value {} for weekOfWeekYear must be in the range [1,7]", number);
+          return -1;
         }
         date.dayOfWeek = number;
         date.weekDateFormat = true;
@@ -918,53 +990,153 @@ void parseFromPattern(
 
       default:
         VELOX_NYI(
-            "Numeric Joda specifier DateTimeFormatSpecifier::" +
-            getSpecifierName(static_cast<int>(curPattern.specifier)) +
-            " not implemented yet.");
+            "Numeric Joda specifier DateTimeFormatSpecifier::{} not implemented yet.",
+            getSpecifierName(curPattern.specifier));
     }
   }
+  return 0;
 }
 
 } // namespace
 
-std::string DateTimeFormatter::format(
+uint32_t DateTimeFormatter::maxResultSize(const tz::TimeZone* timezone) const {
+  uint32_t size = 0;
+  for (const auto& token : tokens_) {
+    if (token.type == DateTimeToken::Type::kLiteral) {
+      size += token.literal.size();
+      continue;
+    }
+    switch (token.pattern.specifier) {
+      case DateTimeFormatSpecifier::ERA:
+      case DateTimeFormatSpecifier::HALFDAY_OF_DAY:
+        // Fixed size.
+        size += 2;
+        break;
+      case DateTimeFormatSpecifier::YEAR_OF_ERA:
+        // Timestamp is in [-32767-01-01, 32767-12-31] range.
+        size += std::max((int)token.pattern.minRepresentDigits, 6);
+        break;
+      case DateTimeFormatSpecifier::DAY_OF_WEEK_0_BASED:
+      case DateTimeFormatSpecifier::DAY_OF_WEEK_1_BASED:
+        size += std::max((int)token.pattern.minRepresentDigits, 1);
+        break;
+      case DateTimeFormatSpecifier::DAY_OF_WEEK_TEXT:
+      case DateTimeFormatSpecifier::MONTH_OF_YEAR_TEXT:
+        // 9 is the max size of elements in weekdaysFull or monthsFull.
+        size += token.pattern.minRepresentDigits <= 3 ? 3 : 9;
+        break;
+      case DateTimeFormatSpecifier::YEAR:
+        // Timestamp is in [-32767-01-01, 32767-12-31] range.
+        size += token.pattern.minRepresentDigits == 2
+            ? 2
+            : std::max((int)token.pattern.minRepresentDigits, 6);
+        break;
+      case DateTimeFormatSpecifier::CENTURY_OF_ERA:
+      case DateTimeFormatSpecifier::DAY_OF_YEAR:
+        size += std::max((int)token.pattern.minRepresentDigits, 3);
+        break;
+      case DateTimeFormatSpecifier::MONTH_OF_YEAR:
+      case DateTimeFormatSpecifier::DAY_OF_MONTH:
+      case DateTimeFormatSpecifier::HOUR_OF_HALFDAY:
+      case DateTimeFormatSpecifier::CLOCK_HOUR_OF_HALFDAY:
+      case DateTimeFormatSpecifier::WEEK_OF_WEEK_YEAR:
+      case DateTimeFormatSpecifier::HOUR_OF_DAY:
+      case DateTimeFormatSpecifier::CLOCK_HOUR_OF_DAY:
+      case DateTimeFormatSpecifier::MINUTE_OF_HOUR:
+      case DateTimeFormatSpecifier::SECOND_OF_MINUTE:
+        size += std::max((int)token.pattern.minRepresentDigits, 2);
+        break;
+      case DateTimeFormatSpecifier::FRACTION_OF_SECOND:
+        // Nanosecond is considered.
+        size += std::max((int)token.pattern.minRepresentDigits, 9);
+        break;
+      case DateTimeFormatSpecifier::TIMEZONE:
+        if (timezone == nullptr) {
+          VELOX_USER_FAIL("Timezone unknown");
+        }
+        size += std::max(
+            token.pattern.minRepresentDigits, timezone->name().length());
+        break;
+      case DateTimeFormatSpecifier::TIMEZONE_OFFSET_ID:
+        if (token.pattern.minRepresentDigits != 2) {
+          VELOX_UNSUPPORTED(
+              "Date format specifier is not supported: {} ({})",
+              getSpecifierName(token.pattern.specifier),
+              token.pattern.minRepresentDigits);
+        }
+        size += 9;
+        break;
+      // Not supported.
+      case DateTimeFormatSpecifier::WEEK_YEAR:
+      default:
+        VELOX_UNSUPPORTED(
+            "Date format specifier is not supported: {}",
+            getSpecifierName(token.pattern.specifier));
+    }
+  }
+  return size;
+}
+
+int32_t DateTimeFormatter::format(
     const Timestamp& timestamp,
-    const date::time_zone* timezone) const {
+    const tz::TimeZone* timezone,
+    const uint32_t maxResultSize,
+    char* result,
+    bool allowOverflow) const {
+  int64_t offset = 0;
   Timestamp t = timestamp;
   if (timezone != nullptr) {
+    const auto utcSeconds = timestamp.getSeconds();
     t.toTimezone(*timezone);
+
+    offset = t.getSeconds() - utcSeconds;
   }
-  const auto timePoint = t.toTimePoint();
+  const auto timePoint = t.toTimePointMs(allowOverflow);
   const auto daysTimePoint = date::floor<date::days>(timePoint);
 
   const auto durationInTheDay = date::make_time(timePoint - daysTimePoint);
   const date::year_month_day calDate(daysTimePoint);
   const date::weekday weekday(daysTimePoint);
 
-  std::string result;
+  const char* resultStart = result;
+  char* maxResultEnd = result + maxResultSize;
   for (auto& token : tokens_) {
     if (token.type == DateTimeToken::Type::kLiteral) {
-      result += token.literal;
+      std::memcpy(result, token.literal.data(), token.literal.size());
+      result += token.literal.size();
     } else {
       switch (token.pattern.specifier) {
-        case DateTimeFormatSpecifier::ERA:
-          result += static_cast<signed>(calDate.year()) > 0 ? "AD" : "BC";
-          break;
-
+        case DateTimeFormatSpecifier::ERA: {
+          const std::string_view piece =
+              static_cast<signed>(calDate.year()) > 0 ? "AD" : "BC";
+          std::memcpy(result, piece.data(), piece.length());
+          result += piece.length();
+        } break;
         case DateTimeFormatSpecifier::CENTURY_OF_ERA: {
           auto year = static_cast<signed>(calDate.year());
           year = (year < 0 ? -year : year);
           auto century = year / 100;
-          result += padContent(century, '0', token.pattern.minRepresentDigits);
+          result += padContent(
+              century,
+              '0',
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
         } break;
 
         case DateTimeFormatSpecifier::YEAR_OF_ERA: {
           auto year = static_cast<signed>(calDate.year());
           if (token.pattern.minRepresentDigits == 2) {
-            result += padContent(std::abs(year) % 100, '0', 2);
+            result +=
+                padContent(std::abs(year) % 100, '0', 2, maxResultEnd, result);
           } else {
             year = year <= 0 ? std::abs(year - 1) : year;
-            result += padContent(year, '0', token.pattern.minRepresentDigits);
+            result += padContent(
+                year,
+                '0',
+                token.pattern.minRepresentDigits,
+                maxResultEnd,
+                result);
           }
         } break;
 
@@ -976,17 +1148,24 @@ std::string DateTimeFormatter::format(
                   DateTimeFormatSpecifier::DAY_OF_WEEK_1_BASED) {
             weekdayNum = 7;
           }
-          result +=
-              padContent(weekdayNum, '0', token.pattern.minRepresentDigits);
+          result += padContent(
+              weekdayNum,
+              '0',
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
         } break;
 
         case DateTimeFormatSpecifier::DAY_OF_WEEK_TEXT: {
           auto weekdayNum = weekday.c_encoding();
+          std::string_view piece;
           if (token.pattern.minRepresentDigits <= 3) {
-            result += weekdaysShort[weekdayNum];
+            piece = weekdaysShort[weekdayNum];
           } else {
-            result += weekdaysFull[weekdayNum];
+            piece = weekdaysFull[weekdayNum];
           }
+          std::memcpy(result, piece.data(), piece.length());
+          result += piece.length();
         } break;
 
         case DateTimeFormatSpecifier::YEAR: {
@@ -994,13 +1173,19 @@ std::string DateTimeFormatter::format(
           if (token.pattern.minRepresentDigits == 2) {
             year = std::abs(year);
             auto twoDigitYear = year % 100;
-            result +=
-                padContent(twoDigitYear, '0', token.pattern.minRepresentDigits);
+            result += padContent(
+                twoDigitYear,
+                '0',
+                token.pattern.minRepresentDigits,
+                maxResultEnd,
+                result);
           } else {
             result += padContent(
                 static_cast<signed>(calDate.year()),
                 '0',
-                token.pattern.minRepresentDigits);
+                token.pattern.minRepresentDigits,
+                maxResultEnd,
+                result);
           }
         } break;
 
@@ -1011,34 +1196,49 @@ std::string DateTimeFormatter::format(
               (date::sys_days{calDate} - date::sys_days{firstDayOfTheYear})
                   .count();
           delta += 1;
-          result += padContent(delta, '0', token.pattern.minRepresentDigits);
+          result += padContent(
+              delta,
+              '0',
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
         } break;
 
         case DateTimeFormatSpecifier::MONTH_OF_YEAR:
           result += padContent(
               static_cast<unsigned>(calDate.month()),
               '0',
-              token.pattern.minRepresentDigits);
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
           break;
 
-        case DateTimeFormatSpecifier::MONTH_OF_YEAR_TEXT:
+        case DateTimeFormatSpecifier::MONTH_OF_YEAR_TEXT: {
+          std::string_view piece;
           if (token.pattern.minRepresentDigits <= 3) {
-            result += monthsShort[static_cast<unsigned>(calDate.month()) - 1];
+            piece = monthsShort[static_cast<unsigned>(calDate.month()) - 1];
           } else {
-            result += monthsFull[static_cast<unsigned>(calDate.month()) - 1];
+            piece = monthsFull[static_cast<unsigned>(calDate.month()) - 1];
           }
-          break;
+          std::memcpy(result, piece.data(), piece.length());
+          result += piece.length();
+        } break;
 
         case DateTimeFormatSpecifier::DAY_OF_MONTH:
           result += padContent(
               static_cast<unsigned>(calDate.day()),
               '0',
-              token.pattern.minRepresentDigits);
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
           break;
 
-        case DateTimeFormatSpecifier::HALFDAY_OF_DAY:
-          result += durationInTheDay.hours().count() < 12 ? "AM" : "PM";
-          break;
+        case DateTimeFormatSpecifier::HALFDAY_OF_DAY: {
+          const std::string_view piece =
+              durationInTheDay.hours().count() < 12 ? "AM" : "PM";
+          std::memcpy(result, piece.data(), piece.length());
+          result += piece.length();
+        } break;
 
         case DateTimeFormatSpecifier::HOUR_OF_HALFDAY:
         case DateTimeFormatSpecifier::CLOCK_HOUR_OF_HALFDAY:
@@ -1057,47 +1257,78 @@ std::string DateTimeFormatter::format(
               DateTimeFormatSpecifier::CLOCK_HOUR_OF_DAY) {
             hourNum = (hourNum + 23) % 24 + 1;
           }
-          result += padContent(hourNum, '0', token.pattern.minRepresentDigits);
+          result += padContent(
+              hourNum,
+              '0',
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
         } break;
 
         case DateTimeFormatSpecifier::MINUTE_OF_HOUR:
           result += padContent(
               durationInTheDay.minutes().count() % 60,
               '0',
-              token.pattern.minRepresentDigits);
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
           break;
 
         case DateTimeFormatSpecifier::SECOND_OF_MINUTE:
           result += padContent(
               durationInTheDay.seconds().count() % 60,
               '0',
-              token.pattern.minRepresentDigits);
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
           break;
 
         case DateTimeFormatSpecifier::FRACTION_OF_SECOND: {
-          result += formatFractionOfSecond(
+          const auto& piece = formatFractionOfSecond(
               durationInTheDay.subseconds().count(),
               token.pattern.minRepresentDigits);
-          break;
-        }
+          std::memcpy(result, piece.data(), piece.length());
+          result += piece.length();
+        } break;
 
-        case DateTimeFormatSpecifier::TIMEZONE:
+        case DateTimeFormatSpecifier::TIMEZONE: {
           // TODO: implement short name time zone, need a map from full name to
           // short name
           if (token.pattern.minRepresentDigits <= 3) {
-            VELOX_UNSUPPORTED("short name time zone is not yet supported")
+            VELOX_UNSUPPORTED("short name time zone is not yet supported");
           }
           if (timezone == nullptr) {
-            VELOX_USER_FAIL("Timezone unknown")
+            VELOX_USER_FAIL("Timezone unknown");
           }
-          result += timezone->name();
-          break;
+          const auto& piece = timezone->name();
+          std::memcpy(result, piece.data(), piece.length());
+          result += piece.length();
+        } break;
 
-        case DateTimeFormatSpecifier::TIMEZONE_OFFSET_ID:
-          // TODO: implement timezone offset id formatting, need a map from full
-          // name to offset time
+        case DateTimeFormatSpecifier::TIMEZONE_OFFSET_ID: {
+          // Zone: 'Z' outputs offset without a colon, 'ZZ' outputs the offset
+          // with a colon, 'ZZZ' or more outputs the zone id.
+          // TODO Add support for 'Z' and 'ZZZ'.
+          if (token.pattern.minRepresentDigits != 2) {
+            VELOX_UNSUPPORTED(
+                "format is not supported for specifier {} ({})",
+                getSpecifierName(token.pattern.specifier),
+                token.pattern.minRepresentDigits);
+          }
+          result += appendTimezoneOffset(offset, result);
+          break;
+        }
+        case DateTimeFormatSpecifier::WEEK_OF_WEEK_YEAR: {
+          auto isoWeek = date::iso_week::year_weeknum_weekday{calDate};
+          result += padContent(
+              unsigned(isoWeek.weeknum()),
+              '0',
+              token.pattern.minRepresentDigits,
+              maxResultEnd,
+              result);
+          break;
+        }
         case DateTimeFormatSpecifier::WEEK_YEAR:
-        case DateTimeFormatSpecifier::WEEK_OF_WEEK_YEAR:
         default:
           VELOX_UNSUPPORTED(
               "format is not supported for specifier {}",
@@ -1105,10 +1336,13 @@ std::string DateTimeFormatter::format(
       }
     }
   }
-  return result;
+  auto resultSize = result - resultStart;
+  VELOX_CHECK_LE(resultSize, maxResultSize, "Bad allocation size for result.");
+  return resultSize;
 }
 
-DateTimeResult DateTimeFormatter::parse(const std::string_view& input) const {
+Expected<DateTimeResult> DateTimeFormatter::parse(
+    const std::string_view& input) const {
   Date date;
   const char* cur = input.data();
   const char* end = cur + input.size();
@@ -1119,16 +1353,22 @@ DateTimeResult DateTimeFormatter::parse(const std::string_view& input) const {
       case DateTimeToken::Type::kLiteral:
         if (tok.literal.size() > end - cur ||
             std::memcmp(cur, tok.literal.data(), tok.literal.size()) != 0) {
-          parseFail(input, cur, end);
+          return parseFail(input, cur, end);
         }
         cur += tok.literal.size();
         break;
       case DateTimeToken::Type::kPattern:
         if (i + 1 < tokens_.size() &&
             tokens_[i + 1].type == DateTimeToken::Type::kPattern) {
-          parseFromPattern(tok.pattern, input, cur, end, date, true, type_);
+          if (parseFromPattern(
+                  tok.pattern, input, cur, end, date, true, type_) == -1) {
+            return parseFail(input, cur, end);
+          }
         } else {
-          parseFromPattern(tok.pattern, input, cur, end, date, false, type_);
+          if (parseFromPattern(
+                  tok.pattern, input, cur, end, date, false, type_) == -1) {
+            return parseFail(input, cur, end);
+          }
         }
         break;
     }
@@ -1136,7 +1376,7 @@ DateTimeResult DateTimeFormatter::parse(const std::string_view& input) const {
 
   // Ensure all input was consumed.
   if (cur < end) {
-    parseFail(input, cur, end);
+    return parseFail(input, cur, end);
   }
 
   // Era is BC and year of era is provided
@@ -1153,25 +1393,37 @@ DateTimeResult DateTimeFormatter::parse(const std::string_view& input) const {
   // Ensure all day of month values are valid for ending month value
   for (int i = 0; i < date.dayOfMonthValues.size(); i++) {
     if (!util::isValidDate(date.year, date.month, date.dayOfMonthValues[i])) {
-      VELOX_USER_FAIL(
-          "Value {} for dayOfMonth must be in the range [1,{}]",
+      if (threadSkipErrorDetails()) {
+        return folly::makeUnexpected(Status::UserError());
+      }
+      return folly::makeUnexpected(Status::UserError(
+          "Value {} for dayOfMonth must be in the range [1,{}] "
+          "for year {} and month {}.",
           date.dayOfMonthValues[i],
-          util::getMaxDayOfMonth(date.year, date.month));
+          util::getMaxDayOfMonth(date.year, date.month),
+          date.year,
+          date.month));
     }
   }
 
   // Ensure all day of year values are valid for ending year value
   for (int i = 0; i < date.dayOfYearValues.size(); i++) {
     if (!util::isValidDayOfYear(date.year, date.dayOfYearValues[i])) {
-      VELOX_USER_FAIL(
-          "Value {} for dayOfMonth must be in the range [1,{}]",
+      if (threadSkipErrorDetails()) {
+        return folly::makeUnexpected(Status::UserError());
+      }
+      return folly::makeUnexpected(Status::UserError(
+          "Value {} for dayOfMonth must be in the range [1,{}] "
+          "for year {} and month {}.",
           date.dayOfYearValues[i],
-          util::isLeapYear(date.year) ? 366 : 365);
+          util::isLeapYear(date.year) ? 366 : 365,
+          date.year,
+          date.month));
     }
   }
 
   // Convert the parsed date/time into a timestamp.
-  int64_t daysSinceEpoch;
+  Expected<int64_t> daysSinceEpoch;
   if (date.weekDateFormat) {
     daysSinceEpoch =
         util::daysSinceEpochFromWeekDate(date.year, date.week, date.dayOfWeek);
@@ -1182,11 +1434,16 @@ DateTimeResult DateTimeFormatter::parse(const std::string_view& input) const {
     daysSinceEpoch =
         util::daysSinceEpochFromDate(date.year, date.month, date.day);
   }
+  if (daysSinceEpoch.hasError()) {
+    VELOX_DCHECK(daysSinceEpoch.error().isUserError());
+    return folly::makeUnexpected(daysSinceEpoch.error());
+  }
 
   int64_t microsSinceMidnight =
       util::fromTime(date.hour, date.minute, date.second, date.microsecond);
-  return {
-      util::fromDatetime(daysSinceEpoch, microsSinceMidnight), date.timezoneId};
+  return DateTimeResult{
+      util::fromDatetime(daysSinceEpoch.value(), microsSinceMidnight),
+      date.timezoneId};
 }
 
 std::shared_ptr<DateTimeFormatter> buildMysqlDateTimeFormatter(
@@ -1300,7 +1557,8 @@ std::shared_ptr<DateTimeFormatter> buildMysqlDateTimeFormatter(
         case 'V':
         case 'w':
         case 'X':
-          VELOX_UNSUPPORTED("Specifier {} is not supported.", *tokenEnd)
+          VELOX_UNSUPPORTED(
+              "Date format specifier is not supported: %{}", *tokenEnd);
         default:
           builder.appendLiteral(tokenEnd, 1);
           break;
diff --git a/velox/functions/lib/DateTimeFormatter.h b/velox/functions/lib/DateTimeFormatter.h
index 179a642ad09a6..ef3c982554043 100644
--- a/velox/functions/lib/DateTimeFormatter.h
+++ b/velox/functions/lib/DateTimeFormatter.h
@@ -18,6 +18,7 @@
 #include <string>
 #include <vector>
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/Status.h"
 #include "velox/type/Timestamp.h"
 
 namespace facebook::velox::functions {
@@ -173,11 +174,27 @@ class DateTimeFormatter {
     return tokens_;
   }
 
-  DateTimeResult parse(const std::string_view& input) const;
-
-  std::string format(
+  // Returns an Expected<DateTimeResult> object containing the parsed
+  // Timestamp and timezone information if parsing succeeded. Otherwise,
+  // Returns Unexpected with UserError status if parsing failed.
+  Expected<DateTimeResult> parse(const std::string_view& input) const;
+
+  /// Returns max size of the formatted string. Can be used to preallocate
+  /// memory before calling format() to avoid extra copy.
+  uint32_t maxResultSize(const tz::TimeZone* timezone) const;
+
+  /// Result buffer is pre-allocated according to maxResultSize.
+  /// Returns actual size.
+  ///
+  /// The timestamp will be firstly converted to millisecond then to
+  /// std::chrono::time_point. If allowOverflow is true, integer overflow is
+  /// allowed in converting to milliseconds.
+  int32_t format(
       const Timestamp& timestamp,
-      const date::time_zone* timezone) const;
+      const tz::TimeZone* timezone,
+      const uint32_t maxResultSize,
+      char* result,
+      bool allowOverflow = false) const;
 
  private:
   std::unique_ptr<char[]> literalBuf_;
@@ -193,3 +210,23 @@ std::shared_ptr<DateTimeFormatter> buildJodaDateTimeFormatter(
     const std::string_view& format);
 
 } // namespace facebook::velox::functions
+
+template <>
+struct fmt::formatter<facebook::velox::functions::DateTimeFormatterType>
+    : formatter<int> {
+  auto format(
+      facebook::velox::functions::DateTimeFormatterType s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::functions::DateTimeFormatSpecifier>
+    : formatter<int> {
+  auto format(
+      facebook::velox::functions::DateTimeFormatSpecifier s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/functions/lib/IsNull.cpp b/velox/functions/lib/IsNull.cpp
index b14a60eeeef79..24c867d5c909e 100644
--- a/velox/functions/lib/IsNull.cpp
+++ b/velox/functions/lib/IsNull.cpp
@@ -23,10 +23,6 @@ namespace {
 template <bool IsNotNULL>
 class IsNullFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -69,7 +65,7 @@ class IsNullFunction : public exec::VectorFunction {
       isNull = AlignedBuffer::allocate<bool>(rows.end(), pool);
       memcpy(
           isNull->asMutable<int64_t>(),
-          decodedArgs.at(0)->nulls(),
+          decodedArgs.at(0)->nulls(&rows),
           bits::nbytes(rows.end()));
 
       if (!IsNotNULL) {
@@ -93,18 +89,20 @@ class IsNullFunction : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_is_null,
     IsNullFunction<false>::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<IsNullFunction</*IsNotNUll=*/false>>());
 
 void registerIsNullFunction(const std::string& name) {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_is_null, name);
 }
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_is_not_null,
     IsNullFunction<true>::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<IsNullFunction</*IsNotNUll=*/true>>());
 
 void registerIsNotNullFunction(const std::string& name) {
diff --git a/velox/functions/lib/KllSketch-inl.h b/velox/functions/lib/KllSketch-inl.h
index f46b0f8f39534..78bd7b5bfada7 100644
--- a/velox/functions/lib/KllSketch-inl.h
+++ b/velox/functions/lib/KllSketch-inl.h
@@ -253,6 +253,20 @@ void readRange(const char* data, size_t& offset, folly::Range<const T*>& out) {
   offset += bytes;
 }
 
+template <typename T>
+void View<T>::deserialize(const char* data) {
+  size_t i = 0;
+  int16_t version;
+  detail::read(data, i, version);
+  VELOX_CHECK_EQ(version, detail::kVersion, "Unsupported version: {}", version);
+  detail::read(data, i, k);
+  detail::read(data, i, n);
+  detail::read(data, i, minValue);
+  detail::read(data, i, maxValue);
+  detail::readRange(data, i, items);
+  detail::readRange(data, i, levels);
+}
+
 } // namespace detail
 
 template <typename T, typename A, typename C>
@@ -565,7 +579,8 @@ void KllSketch<T, A, C>::estimateQuantiles(
 }
 
 template <typename T, typename A, typename C>
-void KllSketch<T, A, C>::mergeViews(const folly::Range<const View*>& others) {
+void KllSketch<T, A, C>::mergeViews(
+    const folly::Range<const detail::View<T>*>& others) {
   auto newN = n_;
   for (auto& other : others) {
     if (other.n == 0) {
@@ -683,14 +698,14 @@ void KllSketch<T, A, C>::mergeViews(const folly::Range<const View*>& others) {
 
 template <typename T, typename A, typename C>
 void KllSketch<T, A, C>::merge(const KllSketch<T, A, C>& other) {
-  View view = other.toView();
+  detail::View<T> view = other.toView();
   mergeViews(folly::Range(&view, 1));
 }
 
 template <typename T, typename A, typename C>
 template <typename Iter>
 void KllSketch<T, A, C>::merge(const folly::Range<Iter>& others) {
-  std::vector<View> views;
+  std::vector<detail::View<T>> views;
   views.reserve(others.size());
   for (auto& other : others) {
     views.push_back(other.toView());
@@ -700,7 +715,7 @@ void KllSketch<T, A, C>::merge(const folly::Range<Iter>& others) {
 
 template <typename T, typename A, typename C>
 void KllSketch<T, A, C>::mergeDeserialized(const char* data) {
-  View view;
+  detail::View<T> view;
   view.deserialize(data);
   return mergeViews(folly::Range(&view, 1));
 }
@@ -708,7 +723,7 @@ void KllSketch<T, A, C>::mergeDeserialized(const char* data) {
 template <typename T, typename A, typename C>
 template <typename Iter>
 void KllSketch<T, A, C>::mergeDeserialized(const folly::Range<Iter>& others) {
-  std::vector<View> views;
+  std::vector<detail::View<T>> views;
   views.reserve(others.size());
   for (auto& other : others) {
     views.emplace_back();
@@ -718,7 +733,7 @@ void KllSketch<T, A, C>::mergeDeserialized(const folly::Range<Iter>& others) {
 }
 
 template <typename T, typename A, typename C>
-typename KllSketch<T, A, C>::View KllSketch<T, A, C>::toView() const {
+typename detail::View<T> KllSketch<T, A, C>::toView() const {
   return {
       .k = k_,
       .n = n_,
@@ -731,7 +746,7 @@ typename KllSketch<T, A, C>::View KllSketch<T, A, C>::toView() const {
 
 template <typename T, typename A, typename C>
 KllSketch<T, A, C> KllSketch<T, A, C>::fromView(
-    const typename KllSketch<T, A, C>::View& view,
+    const detail::View<T>& view,
     const A& allocator,
     uint32_t seed) {
   KllSketch<T, A, C> ans(allocator, seed);
@@ -770,26 +785,12 @@ void KllSketch<T, A, C>::serialize(char* out) const {
   VELOX_DCHECK_EQ(i, serializedByteSize());
 }
 
-template <typename T, typename A, typename C>
-void KllSketch<T, A, C>::View::deserialize(const char* data) {
-  size_t i = 0;
-  int16_t version;
-  detail::read(data, i, version);
-  VELOX_CHECK_EQ(version, detail::kVersion, "Unsupported version: {}", version);
-  detail::read(data, i, k);
-  detail::read(data, i, n);
-  detail::read(data, i, minValue);
-  detail::read(data, i, maxValue);
-  detail::readRange(data, i, items);
-  detail::readRange(data, i, levels);
-}
-
 template <typename T, typename A, typename C>
 KllSketch<T, A, C> KllSketch<T, A, C>::deserialize(
     const char* data,
     const A& allocator,
     uint32_t seed) {
-  View view;
+  detail::View<T> view;
   view.deserialize(data);
   return fromView(view, allocator, seed);
 }
diff --git a/velox/functions/lib/KllSketch.h b/velox/functions/lib/KllSketch.h
index 7d549ba81ee56..80ef278eccbbf 100644
--- a/velox/functions/lib/KllSketch.h
+++ b/velox/functions/lib/KllSketch.h
@@ -23,6 +23,28 @@
 #include "folly/Range.h"
 
 namespace facebook::velox::functions::kll {
+namespace detail {
+/// Internal API, do not use outside Velox.
+template <typename T>
+struct View {
+  uint32_t k;
+  size_t n;
+  T minValue;
+  T maxValue;
+  folly::Range<const T*> items;
+  folly::Range<const uint32_t*> levels;
+
+  uint8_t numLevels() const {
+    return levels.size() - 1;
+  }
+
+  uint32_t safeLevelSize(uint8_t level) const {
+    return level < numLevels() ? levels[level + 1] - levels[level] : 0;
+  }
+
+  void deserialize(const char* FOLLY_NONNULL);
+};
+} // namespace detail
 
 constexpr uint32_t kDefaultK = 200;
 
@@ -95,9 +117,7 @@ struct KllSketch {
   /// @param out Pre-allocated memory to hold the result, must be at least as
   ///  large as `quantiles`
   template <typename Iter>
-  void estimateQuantiles(
-      const folly::Range<Iter>& quantiles,
-      T* FOLLY_NONNULL out) const;
+  void estimateQuantiles(const folly::Range<Iter>& quantiles, T* out) const;
 
   /// The total number of values being added to the sketch.
   size_t totalCount() const {
@@ -107,13 +127,16 @@ struct KllSketch {
   /// Calculate the size needed for serialization.
   size_t serializedByteSize() const;
 
-  /// Serialize the sketch into bytes.
+  /// Serialize the sketch into bytes.  The serialzation is versioned, and newer
+  /// version of code should be able to read all previous versions.
+  ///
   /// @param out Pre-allocated memory at least serializedByteSize() in size
-  void serialize(char* FOLLY_NONNULL out) const;
+  void serialize(char* out) const;
 
-  /// Deserialize a sketch from bytes.
+  /// Deserialize a sketch from bytes.  Newer version of code should be able to
+  /// read all previous versions.
   static KllSketch<T, Allocator, Compare> deserialize(
-      const char* FOLLY_NONNULL data,
+      const char* data,
       const Allocator& = Allocator(),
       uint32_t seed = folly::Random::rand32());
 
@@ -135,36 +158,19 @@ struct KllSketch {
 
   /// Merge with another deserialized sketch.  This is more efficient
   /// than deserialize then merge.
-  void mergeDeserialized(const char* FOLLY_NONNULL data);
+  void mergeDeserialized(const char* data);
 
   /// Get frequencies of items being tracked.  The result is sorted by item.
   std::vector<std::pair<T, uint64_t>> getFrequencies() const;
 
   /// Internal API, do not use outside Velox.
-  struct View {
-    uint32_t k;
-    size_t n;
-    T minValue;
-    T maxValue;
-    folly::Range<const T*> items;
-    folly::Range<const uint32_t*> levels;
-
-    uint8_t numLevels() const {
-      return levels.size() - 1;
-    }
-
-    uint32_t safeLevelSize(uint8_t level) const {
-      return level < numLevels() ? levels[level + 1] - levels[level] : 0;
-    }
-
-    void deserialize(const char* FOLLY_NONNULL);
-  };
+  void mergeViews(const folly::Range<const detail::View<T>*>& views);
 
   /// Internal API, do not use outside Velox.
-  void mergeViews(const folly::Range<const View*>& views);
+  detail::View<T> toView() const;
 
-  /// Internal API, do not use outside Velox.
-  View toView() const;
+  static KllSketch<T, Allocator, Compare>
+  fromView(const detail::View<T>&, const Allocator& allocator, uint32_t seed);
 
  private:
   KllSketch(const Allocator&, uint32_t seed);
@@ -186,9 +192,6 @@ struct KllSketch {
     return level < numLevels() ? levels_[level + 1] - levels_[level] : 0;
   }
 
-  static KllSketch<T, Allocator, Compare>
-  fromView(const View&, const Allocator&, uint32_t seed);
-
   using AllocU32 = typename std::allocator_traits<
       Allocator>::template rebind_alloc<uint32_t>;
 
diff --git a/velox/functions/lib/LambdaFunctionUtil.cpp b/velox/functions/lib/LambdaFunctionUtil.cpp
index e073867a58cb6..7fca2c8d377c4 100644
--- a/velox/functions/lib/LambdaFunctionUtil.cpp
+++ b/velox/functions/lib/LambdaFunctionUtil.cpp
@@ -158,11 +158,17 @@ BufferPtr addNullsForUnselectedRows(
     const VectorPtr& vector,
     const SelectivityVector& rows) {
   // Set nulls for rows not present in 'rows'.
-  BufferPtr nulls = allocateNulls(vector->size(), vector->pool(), bits::kNull);
-  memcpy(
+  BufferPtr nulls = allocateNulls(rows.size(), vector->pool(), bits::kNull);
+
+  // bits::kNull is 0. Hence, bits::orBits() simply copies the bits from the
+  // selectivity vector into the nulls buffer. We cannot use memcpy because it
+  // will copy extra bits at the tail if rows.end() is not a multiple of 8.
+  bits::orBits(
       nulls->asMutable<uint64_t>(),
       rows.asRange().bits(),
-      bits::nbytes(rows.end()));
+      rows.begin(),
+      rows.end());
+
   if (vector->nulls() != nullptr) {
     // Transfer original nulls
     bits::andBits(
diff --git a/velox/functions/lib/LambdaFunctionUtil.h b/velox/functions/lib/LambdaFunctionUtil.h
index c8a66eee79e15..6f92ec9f2ed99 100644
--- a/velox/functions/lib/LambdaFunctionUtil.h
+++ b/velox/functions/lib/LambdaFunctionUtil.h
@@ -88,8 +88,9 @@ MapVectorPtr flattenMap(
     const VectorPtr& vector,
     DecodedVector& decodedVector);
 
-// Makes a copy of the original nulls in 'vector' and adds nulls for unselected
-// rows in 'rows'
+// Creates a nulls buffer to hold rows.size() nulls. Copies the original nulls
+// in 'vector' for positions [rows.begin(), rows.end()) and sets nulls for
+// unselected rows in 'rows'.
 BufferPtr addNullsForUnselectedRows(
     const VectorPtr& vector,
     const SelectivityVector& rows);
diff --git a/velox/functions/lib/MapConcat.cpp b/velox/functions/lib/MapConcat.cpp
index 4d7da0ca759c0..c11b9ae19579f 100644
--- a/velox/functions/lib/MapConcat.cpp
+++ b/velox/functions/lib/MapConcat.cpp
@@ -25,10 +25,6 @@ namespace {
 template <bool EmptyForNull>
 class MapConcatFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return !EmptyForNull;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -161,12 +157,11 @@ class MapConcatFunction : public exec::VectorFunction {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // map(K,V), map(K,V), ... -> map(K,V)
     return {exec::FunctionSignatureBuilder()
-                .knownTypeVariable("K")
+                .typeVariable("K")
                 .typeVariable("V")
                 .returnType("map(K,V)")
                 .argumentType("map(K,V)")
-                .argumentType("map(K,V)")
-                .variableArity()
+                .variableArity("map(K,V)")
                 .build()};
   }
 };
@@ -183,6 +178,7 @@ void registerMapConcatEmptyNullsFunction(const std::string& name) {
   exec::registerVectorFunction(
       name,
       MapConcatFunction</*EmptyForNull=*/true>::signatures(),
-      std::make_unique<MapConcatFunction</*EmptyForNull=*/true>>());
+      std::make_unique<MapConcatFunction</*EmptyForNull=*/true>>(),
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Re2Functions.cpp b/velox/functions/lib/Re2Functions.cpp
index e0ca73d5ceaf8..dbdc76c05217d 100644
--- a/velox/functions/lib/Re2Functions.cpp
+++ b/velox/functions/lib/Re2Functions.cpp
@@ -14,26 +14,61 @@
  * limitations under the License.
  */
 #include "velox/functions/lib/Re2Functions.h"
-
-#include <re2/re2.h>
-#include <memory>
-#include <optional>
-#include <string>
-
-#include "velox/expression/VectorWriters.h"
-#include "velox/type/StringView.h"
-#include "velox/vector/BaseVector.h"
+#include "velox/functions/lib/string/StringImpl.h"
+#include "velox/vector/FunctionVector.h"
 
 namespace facebook::velox::functions {
 namespace {
 
-using ::facebook::velox::exec::EvalCtx;
-using ::facebook::velox::exec::Expr;
-using ::facebook::velox::exec::VectorFunction;
-using ::facebook::velox::exec::VectorFunctionArg;
-using ::re2::RE2;
+void checkForBadPattern(const RE2& re) {
+  if (UNLIKELY(!re.ok())) {
+    VELOX_USER_FAIL("invalid regular expression:{}", re.error());
+  }
+}
 
-static const int kMaxCompiledRegexes = 20;
+template <typename T>
+re2::StringPiece toStringPiece(const T& s) {
+  return re2::StringPiece(s.data(), s.size());
+}
+
+} // namespace
+
+namespace detail {
+
+Expected<RE2*> ReCache::tryFindOrCompile(const StringView& pattern) {
+  const std::string key = pattern;
+
+  auto reIt = cache_.find(key);
+  if (reIt != cache_.end()) {
+    return reIt->second.get();
+  }
+
+  if (cache_.size() >= kMaxCompiledRegexes) {
+    return folly::makeUnexpected(
+        Status::UserError("Max number of regex reached"));
+  }
+
+  auto re = std::make_unique<RE2>(toStringPiece(pattern), RE2::Quiet);
+  if (!re->ok()) {
+    return folly::makeUnexpected(
+        Status::UserError("invalid regular expression:{}", re->error()));
+  }
+
+  auto [it, inserted] = cache_.emplace(key, std::move(re));
+  VELOX_CHECK(inserted);
+
+  return it->second.get();
+}
+
+RE2* ReCache::findOrCompile(const StringView& pattern) {
+  return tryFindOrCompile(pattern).thenOrThrow(
+      folly::identity,
+      [&](const Status& status) { VELOX_USER_FAIL("{}", status.message()); });
+}
+
+} // namespace detail
+
+namespace {
 
 std::string printTypesCsv(
     const std::vector<exec::VectorFunctionArg>& inputArgs) {
@@ -46,11 +81,6 @@ std::string printTypesCsv(
   return result;
 }
 
-template <typename T>
-re2::StringPiece toStringPiece(const T& s) {
-  return re2::StringPiece(s.data(), s.size());
-}
-
 // If v is a non-null constant vector, returns the constant value. Otherwise
 // returns nullopt.
 template <typename T>
@@ -62,15 +92,9 @@ std::optional<T> getIfConstant(const BaseVector& v) {
   return std::nullopt;
 }
 
-void checkForBadPattern(const RE2& re) {
-  if (UNLIKELY(!re.ok())) {
-    VELOX_USER_FAIL("invalid regular expression:{}", re.error());
-  }
-}
-
 FlatVector<bool>& ensureWritableBool(
     const SelectivityVector& rows,
-    EvalCtx& context,
+    exec::EvalCtx& context,
     VectorPtr& result) {
   context.ensureWritable(rows, BOOLEAN(), result);
   return *result->as<FlatVector<bool>>();
@@ -78,7 +102,7 @@ FlatVector<bool>& ensureWritableBool(
 
 FlatVector<StringView>& ensureWritableStringView(
     const SelectivityVector& rows,
-    EvalCtx& context,
+    exec::EvalCtx& context,
     VectorPtr& result) {
   context.ensureWritable(rows, VARCHAR(), result);
   auto* flat = result->as<FlatVector<StringView>>();
@@ -182,7 +206,7 @@ std::string likePatternToRe2(
 }
 
 template <bool (*Fn)(StringView, const RE2&)>
-class Re2MatchConstantPattern final : public VectorFunction {
+class Re2MatchConstantPattern final : public exec::VectorFunction {
  public:
   explicit Re2MatchConstantPattern(StringView pattern)
       : re_(toStringPiece(pattern), RE2::Quiet) {}
@@ -191,14 +215,14 @@ class Re2MatchConstantPattern final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     VELOX_CHECK_EQ(args.size(), 2);
     FlatVector<bool>& result = ensureWritableBool(rows, context, resultRef);
     exec::LocalDecodedVector toSearch(context, *args[0], rows);
     try {
       checkForBadPattern(re_);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       context.setErrors(rows, std::current_exception());
       return;
     }
@@ -213,13 +237,13 @@ class Re2MatchConstantPattern final : public VectorFunction {
 };
 
 template <bool (*Fn)(StringView, const RE2&)>
-class Re2Match final : public VectorFunction {
+class Re2Match final : public exec::VectorFunction {
  public:
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& resultRef) const override {
     VELOX_CHECK_EQ(args.size(), 2);
     if (auto pattern = getIfConstant<StringView>(*args[1])) {
@@ -232,21 +256,23 @@ class Re2Match final : public VectorFunction {
     exec::LocalDecodedVector toSearch(context, *args[0], rows);
     exec::LocalDecodedVector pattern(context, *args[1], rows);
     context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
-      RE2 re(toStringPiece(pattern->valueAt<StringView>(row)), RE2::Quiet);
-      checkForBadPattern(re);
+      auto& re = *cache_.findOrCompile(pattern->valueAt<StringView>(row));
       result.set(row, Fn(toSearch->valueAt<StringView>(row), re));
     });
   }
+
+ private:
+  mutable detail::ReCache cache_;
 };
 
-void checkForBadGroupId(int groupId, const RE2& re) {
+void checkForBadGroupId(int64_t groupId, const RE2& re) {
   if (UNLIKELY(groupId < 0 || groupId > re.NumberOfCapturingGroups())) {
     VELOX_USER_FAIL("No group {} in regex '{}'", groupId, re.pattern());
   }
 }
 
 template <typename T>
-class Re2SearchAndExtractConstantPattern final : public VectorFunction {
+class Re2SearchAndExtractConstantPattern final : public exec::VectorFunction {
  public:
   explicit Re2SearchAndExtractConstantPattern(
       StringView pattern,
@@ -257,7 +283,7 @@ class Re2SearchAndExtractConstantPattern final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
     // TODO: Potentially re-use the string vector, not just the buffer.
@@ -267,7 +293,7 @@ class Re2SearchAndExtractConstantPattern final : public VectorFunction {
     // apply() will not be invoked if the selection is empty.
     try {
       checkForBadPattern(re_);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       context.setErrors(rows, std::current_exception());
       return;
     }
@@ -291,7 +317,7 @@ class Re2SearchAndExtractConstantPattern final : public VectorFunction {
     if (const auto groupId = getIfConstant<T>(*args[2])) {
       try {
         checkForBadGroupId(*groupId, re_);
-      } catch (const std::exception& e) {
+      } catch (const std::exception&) {
         context.setErrors(rows, std::current_exception());
         return;
       }
@@ -326,12 +352,12 @@ class Re2SearchAndExtractConstantPattern final : public VectorFunction {
  private:
   RE2 re_;
   const bool emptyNoMatch_;
-}; // namespace
+};
 
 // The factory function we provide returns a unique instance for each call, so
 // this is safe.
 template <typename T>
-class Re2SearchAndExtract final : public VectorFunction {
+class Re2SearchAndExtract final : public exec::VectorFunction {
  public:
   explicit Re2SearchAndExtract(bool emptyNoMatch)
       : emptyNoMatch_(emptyNoMatch) {}
@@ -339,7 +365,7 @@ class Re2SearchAndExtract final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
     // Handle the common case of a constant pattern.
@@ -360,8 +386,7 @@ class Re2SearchAndExtract final : public VectorFunction {
     if (args.size() == 2) {
       groups.resize(1);
       context.applyToSelectedNoThrow(rows, [&](vector_size_t i) {
-        RE2 re(toStringPiece(pattern->valueAt<StringView>(i)), RE2::Quiet);
-        checkForBadPattern(re);
+        auto& re = *cache_.findOrCompile(pattern->valueAt<StringView>(i));
         mustRefSourceStrings |=
             re2Extract(result, i, re, toSearch, groups, 0, emptyNoMatch_);
       });
@@ -369,8 +394,7 @@ class Re2SearchAndExtract final : public VectorFunction {
       exec::LocalDecodedVector groupIds(context, *args[2], rows);
       context.applyToSelectedNoThrow(rows, [&](vector_size_t i) {
         const auto groupId = groupIds->valueAt<T>(i);
-        RE2 re(toStringPiece(pattern->valueAt<StringView>(i)), RE2::Quiet);
-        checkForBadPattern(re);
+        auto& re = *cache_.findOrCompile(pattern->valueAt<StringView>(i));
         checkForBadGroupId(groupId, re);
         groups.resize(groupId + 1);
         mustRefSourceStrings |=
@@ -384,22 +408,224 @@ class Re2SearchAndExtract final : public VectorFunction {
 
  private:
   const bool emptyNoMatch_;
+  mutable detail::ReCache cache_;
 };
 
+namespace {
+
+// Sub-pattern's stats in a top-level pattern.
+struct SubPatternStats {
+  SubPatternKind kind;
+
+  // Number of times this sub-pattern occurs in the overall pattern.
+  size_t count = 0;
+
+  // First index of this pattern kind.
+  std::optional<size_t> firstIndex = std::nullopt;
+
+  // Last index of this pattern kind. lastIndex will be set as the same value as
+  // firstIndex if the kind of sub-pattern only occur once.
+  std::optional<size_t> lastIndex = std::nullopt;
+
+  void update(size_t index) {
+    count++;
+    if (!firstIndex.has_value()) {
+      firstIndex = index;
+    }
+
+    lastIndex = index;
+  }
+};
+
+// Construct SubPatternMetadata from subPatternKinds, subPatternRanges.
+// Caller need to make sure the specified range only contains
+// fixed(kLiteralString, kSingleWildcard) patterns.
+size_t buildFixedSubPatterns(
+    const std::vector<SubPatternKind>& subPatternKinds,
+    const std::vector<std::pair<size_t, size_t>>& subPatternRanges,
+    size_t start,
+    size_t end,
+    std::vector<SubPatternMetadata>& subPatterns) {
+  size_t indexInFixedPattern = 0;
+  for (auto i = start; i < end; i++) {
+    const auto kind = subPatternKinds[i];
+    if (kind == SubPatternKind::kLiteralString ||
+        kind == SubPatternKind::kSingleCharWildcard) {
+      subPatterns.push_back(
+          {kind, indexInFixedPattern, subPatternRanges[i].second});
+    } else {
+      VELOX_UNREACHABLE();
+    }
+    indexInFixedPattern += subPatternRanges[i].second;
+  }
+
+  return indexInFixedPattern;
+}
+
+// Return the length of the fixed part(literal chars or single char wildcard) of
+// the pattern, it is mainly used to get the length of the fixed part in a
+// pattern, so we can extract the fixed part out.
+size_t fixedLength(
+    const std::vector<SubPatternKind>& subPatternKinds,
+    const std::vector<std::pair<size_t, size_t>>& subPatternRanges) {
+  size_t result = 0;
+  for (auto i = 0; i < subPatternKinds.size(); i++) {
+    if (subPatternKinds[i] != SubPatternKind::kAnyCharsWildcard) {
+      result += subPatternRanges[i].second;
+    }
+  }
+
+  return result;
+}
+
+// Return the number of bytes in the specified unicode character. Returns 1 if
+// specified character is not a valid UTF-8.
+size_t unicodeCharLength(const char* str) {
+  auto size = utf8proc_char_length(str);
+  // Skip bad byte if we get utf length < 0.
+  return UNLIKELY(size < 0) ? 1 : size;
+}
+
+} // namespace
+
 // Match string 'input' with a fixed pattern (with no wildcard characters).
 bool matchExactPattern(
     StringView input,
-    StringView pattern,
-    vector_size_t length) {
-  return input.size() == pattern.size() &&
-      std::memcmp(input.data(), pattern.data(), length) == 0;
+    const std::string& pattern,
+    size_t length) {
+  if (FOLLY_LIKELY(pattern.size() > 0)) {
+    return input.size() == pattern.size() &&
+        std::memcmp(input.data(), pattern.data(), length) == 0;
+  }
+
+  return input.size() == 0;
+}
+
+std::pair<bool, int32_t> matchRelaxedFixedForwardAscii(
+    StringView input,
+    const PatternMetadata& patternMetadata,
+    size_t start) {
+  if (input.size() - start < patternMetadata.length()) {
+    return std::make_pair(false, -1);
+  }
+
+  for (const auto& subPattern : patternMetadata.subPatterns()) {
+    if (subPattern.kind == SubPatternKind::kLiteralString &&
+        std::memcmp(
+            input.data() + start + subPattern.start,
+            patternMetadata.fixedPattern().data() + subPattern.start,
+            subPattern.length) != 0) {
+      return std::make_pair(false, -1);
+    }
+  }
+
+  return std::make_pair(true, start + patternMetadata.length());
+}
+
+std::pair<bool, int32_t> matchRelaxedFixedForwardUnicode(
+    StringView input,
+    const PatternMetadata& patternMetadata,
+    size_t start) {
+  // Compare the length first.
+  if (input.size() - start < patternMetadata.length()) {
+    return std::make_pair(false, -1);
+  }
+
+  auto cursor = start;
+  for (const auto& subPattern : patternMetadata.subPatterns()) {
+    if (subPattern.kind == SubPatternKind::kSingleCharWildcard) {
+      // Match every single char wildcard.
+      for (auto i = 0; i < subPattern.length; i++) {
+        if (cursor >= input.size()) {
+          return std::make_pair(false, -1);
+        }
+
+        auto numBytes = unicodeCharLength(input.data() + cursor);
+        cursor += numBytes;
+      }
+    } else {
+      const auto currentLength = subPattern.length;
+      if (cursor + currentLength > input.size() ||
+          std::memcmp(
+              input.data() + cursor,
+              patternMetadata.fixedPattern().data() + subPattern.start,
+              currentLength) != 0) {
+        return std::make_pair(false, -1);
+      }
+
+      cursor += currentLength;
+    }
+  }
+
+  return std::make_pair(true, cursor);
+}
+
+// Match the input(from the position of start) with relaxed pattern forward.
+// Returns a pair:
+// - first: a bool indicates whether matches the pattern.
+// - second: an integer indicates where is cursor in the input when we finished
+// matching if 'first' is true, -1 otherwise.
+template <bool isAscii>
+std::pair<bool, int32_t> matchRelaxedFixedForward(
+    StringView input,
+    const PatternMetadata& patternMetadata,
+    size_t start) {
+  if constexpr (isAscii) {
+    return matchRelaxedFixedForwardAscii(input, patternMetadata, start);
+  } else {
+    return matchRelaxedFixedForwardUnicode(input, patternMetadata, start);
+  }
+}
+
+// Match the input(from the position of start) with relaxed pattern backward.
+// Unlike matchRelaxedFixedForward which has different path for utf8 and
+// ascii, this function only has implementation for utf8 because only utf8
+// input use this function.
+bool matchRelaxedFixedBackwardUnicode(
+    StringView input,
+    const PatternMetadata& patternMetadata,
+    size_t start) {
+  // Compare the length first.
+  if ((start + 1) < patternMetadata.length()) {
+    return false;
+  }
+
+  const auto& subPatterns = patternMetadata.subPatterns();
+  auto cursor = start;
+  for (int32_t i = subPatterns.size() - 1; i >= 0; i--) {
+    const auto subPattern = subPatterns[i];
+    if (subPattern.kind == SubPatternKind::kSingleCharWildcard) {
+      int32_t charsToSkip = subPattern.length;
+      while (charsToSkip > 0) {
+        // We need to skip the number of 'first byte' -- skip one 'first byte'
+        // means skip one character.
+        if (utf8proc_char_first_byte(input.data() + cursor)) {
+          charsToSkip--;
+        }
+        cursor--;
+      }
+    } else {
+      const auto currentLength = subPattern.length;
+      const auto startIdx = cursor - (currentLength - 1);
+      if (std::memcmp(
+              input.data() + startIdx,
+              patternMetadata.fixedPattern().data() + subPattern.start,
+              currentLength) != 0) {
+        return false;
+      }
+
+      cursor -= currentLength;
+    }
+  }
+
+  return true;
 }
 
 // Match the first 'length' characters of string 'input' and prefix pattern.
 bool matchPrefixPattern(
     StringView input,
-    StringView pattern,
-    vector_size_t length) {
+    const std::string& pattern,
+    size_t length) {
   return input.size() >= length &&
       std::memcmp(input.data(), pattern.data(), length) == 0;
 }
@@ -407,8 +633,8 @@ bool matchPrefixPattern(
 // Match the last 'length' characters of string 'input' and suffix pattern.
 bool matchSuffixPattern(
     StringView input,
-    StringView pattern,
-    vector_size_t length) {
+    const std::string& pattern,
+    size_t length) {
   return input.size() >= length &&
       std::memcmp(
           input.data() + input.size() - length,
@@ -416,29 +642,104 @@ bool matchSuffixPattern(
           length) == 0;
 }
 
+bool matchSubstringPattern(
+    const StringView& input,
+    const std::string& fixedPattern) {
+  return (
+      std::string_view(input).find(std::string_view(fixedPattern)) !=
+      std::string::npos);
+}
+
+// Return true if the input VARCHAR argument is all-ASCII for the specified
+// rows.
+FOLLY_ALWAYS_INLINE static bool isAsciiArg(
+    const SelectivityVector& rows,
+    const VectorPtr& arg) {
+  VELOX_DCHECK(
+      arg->type()->isVarchar(), "Input vector is expected to be VARCHAR type.");
+
+  return arg->asUnchecked<SimpleVector<StringView>>()->computeAndSetIsAscii(
+      rows);
+}
+
 template <PatternKind P>
-class OptimizedLikeWithMemcmp final : public VectorFunction {
+class OptimizedLike final : public exec::VectorFunction {
  public:
-  OptimizedLikeWithMemcmp(
-      StringView pattern,
-      vector_size_t reducedPatternLength)
-      : pattern_{pattern}, reducedPatternLength_{reducedPatternLength} {}
+  explicit OptimizedLike(PatternMetadata patternMetadata)
+      : patternMetadata_(std::move(patternMetadata)) {}
 
+  template <bool isAscii>
   static bool match(
       const StringView& input,
-      const StringView& pattern,
-      vector_size_t reducedPatternLength) {
-    switch (P) {
-      case PatternKind::kExactlyN:
-        return input.size() == reducedPatternLength;
-      case PatternKind::kAtLeastN:
-        return input.size() >= reducedPatternLength;
-      case PatternKind::kFixed:
-        return matchExactPattern(input, pattern, reducedPatternLength);
-      case PatternKind::kPrefix:
-        return matchPrefixPattern(input, pattern, reducedPatternLength);
-      case PatternKind::kSuffix:
-        return matchSuffixPattern(input, pattern, reducedPatternLength);
+      const PatternMetadata& patternMetadata) {
+    if constexpr (isAscii) {
+      switch (P) {
+        case PatternKind::kExactlyN:
+          return input.size() == patternMetadata.length();
+        case PatternKind::kAtLeastN:
+          return input.size() >= patternMetadata.length();
+        case PatternKind::kFixed:
+          return matchExactPattern(
+              input, patternMetadata.fixedPattern(), patternMetadata.length());
+        case PatternKind::kRelaxedFixed: {
+          auto pair = matchRelaxedFixedForward<true>(input, patternMetadata, 0);
+          return pair.first && pair.second == input.size();
+        }
+        case PatternKind::kPrefix:
+          return matchPrefixPattern(
+              input, patternMetadata.fixedPattern(), patternMetadata.length());
+        case PatternKind::kRelaxedPrefix:
+          return matchRelaxedFixedForward<true>(input, patternMetadata, 0)
+              .first;
+        case PatternKind::kSuffix:
+          return matchSuffixPattern(
+              input, patternMetadata.fixedPattern(), patternMetadata.length());
+        case PatternKind::kRelaxedSuffix:
+          if (input.size() < patternMetadata.length()) {
+            return false;
+          }
+          return matchRelaxedFixedForward<true>(
+                     input,
+                     patternMetadata,
+                     input.size() - patternMetadata.length())
+              .first;
+        case PatternKind::kSubstring:
+          return matchSubstringPattern(input, patternMetadata.fixedPattern());
+      }
+    } else {
+      switch (P) {
+        case PatternKind::kExactlyN:
+          return stringImpl::cappedLength<false>(
+                     input, patternMetadata.length() + 1) ==
+              patternMetadata.length();
+        case PatternKind::kAtLeastN:
+          return stringImpl::cappedLength<isAscii>(
+                     input, patternMetadata.length() + 1) >=
+              patternMetadata.length();
+        case PatternKind::kFixed:
+          return matchExactPattern(
+              input, patternMetadata.fixedPattern(), patternMetadata.length());
+        case PatternKind::kRelaxedFixed: {
+          auto pair =
+              matchRelaxedFixedForward<false>(input, patternMetadata, 0);
+          return pair.first && pair.second == input.size();
+        }
+        case PatternKind::kPrefix:
+          return matchPrefixPattern(
+              input, patternMetadata.fixedPattern(), patternMetadata.length());
+        case PatternKind::kRelaxedPrefix: {
+          return matchRelaxedFixedForward<false>(input, patternMetadata, 0)
+              .first;
+        }
+        case PatternKind::kSuffix:
+          return matchSuffixPattern(
+              input, patternMetadata.fixedPattern(), patternMetadata.length());
+        case PatternKind::kRelaxedSuffix:
+          return matchRelaxedFixedBackwardUnicode(
+              input, patternMetadata, input.size() - 1);
+        case PatternKind::kSubstring:
+          return matchSubstringPattern(input, patternMetadata.fixedPattern());
+      }
     }
   }
 
@@ -446,23 +747,44 @@ class OptimizedLikeWithMemcmp final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
+
+    constexpr bool isUtf8SensitivePattern =
+        (P == PatternKind::kExactlyN || P == PatternKind::kAtLeastN ||
+         P == PatternKind::kRelaxedFixed || P == PatternKind::kRelaxedPrefix ||
+         P == PatternKind::kRelaxedSuffix);
+
+    bool needsUtf8Processing =
+        isUtf8SensitivePattern && !isAsciiArg(rows, args[0]);
     FlatVector<bool>& result = ensureWritableBool(rows, context, resultRef);
     exec::DecodedArgs decodedArgs(rows, args, context);
     auto toSearch = decodedArgs.at(0);
 
     if (toSearch->isIdentityMapping()) {
       auto input = toSearch->data<StringView>();
-      context.applyToSelectedNoThrow(rows, [&](vector_size_t i) {
-        result.set(i, match(input[i], pattern_, reducedPatternLength_));
-      });
+      if (!needsUtf8Processing) {
+        context.applyToSelectedNoThrow(rows, [&](vector_size_t i) {
+          result.set(i, match</*isAscii*/ true>(input[i], patternMetadata_));
+        });
+      } else {
+        context.applyToSelectedNoThrow(rows, [&](vector_size_t i) {
+          result.set(i, match</*isAscii*/ false>(input[i], patternMetadata_));
+        });
+      }
       return;
     }
+
     if (toSearch->isConstantMapping()) {
       auto input = toSearch->valueAt<StringView>(0);
-      bool matchResult = match(input, pattern_, reducedPatternLength_);
+
+      bool matchResult;
+      if (!needsUtf8Processing) {
+        matchResult = match</*isAscii*/ true>(input, patternMetadata_);
+      } else {
+        matchResult = match</*isAscii*/ false>(input, patternMetadata_);
+      }
       context.applyToSelectedNoThrow(
           rows, [&](vector_size_t i) { result.set(i, matchResult); });
       return;
@@ -475,13 +797,12 @@ class OptimizedLikeWithMemcmp final : public VectorFunction {
   }
 
  private:
-  StringView pattern_;
-  vector_size_t reducedPatternLength_;
+  const PatternMetadata patternMetadata_;
 };
 
 // This function is used when pattern and escape are constants. And there is not
 // fast path that avoids compiling the regular expression.
-class LikeWithRe2 final : public VectorFunction {
+class LikeWithRe2 final : public exec::VectorFunction {
  public:
   LikeWithRe2(StringView pattern, std::optional<char> escapeChar) {
     RE2::Options opt{RE2::Quiet};
@@ -495,7 +816,7 @@ class LikeWithRe2 final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
 
@@ -509,7 +830,7 @@ class LikeWithRe2 final : public VectorFunction {
     // apply() will not be invoked if the selection is empty.
     try {
       checkForBadPattern(*re_);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       context.setErrors(rows, std::current_exception());
       return;
     }
@@ -546,70 +867,78 @@ class LikeWithRe2 final : public VectorFunction {
 
 // This function is constructed when pattern or escape are not constants.
 // It allows up to kMaxCompiledRegexes different regular expressions to be
-// compiled throughout the query life per function, note that optimized regular
-// expressions that are not compiled are not counted.
-class LikeGeneric final : public VectorFunction {
+// compiled throughout the query lifetime per expression and thread of
+// execution, note that optimized regular expressions that are not compiled are
+// not counted.
+class LikeGeneric final : public exec::VectorFunction {
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& type,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& result) const final {
     VectorPtr localResult;
-
+    bool isAscii = isAsciiArg(rows, args[0]);
     auto applyWithRegex = [&](const StringView& input,
                               const StringView& pattern,
                               const std::optional<char>& escapeChar) -> bool {
-      RE2::Options opt{RE2::Quiet};
-      opt.set_dot_nl(true);
-      bool validEscapeUsage;
-      auto regex = likePatternToRe2(pattern, escapeChar, validEscapeUsage);
-      VELOX_USER_CHECK(
-          validEscapeUsage,
-          "Escape character must be followed by '%', '_' or the escape character itself");
-
-      auto key =
-          std::pair<StringView, std::optional<char>>{pattern, escapeChar};
-
-      auto [it, inserted] = compiledRegularExpressions_.emplace(
-          key, std::make_unique<RE2>(toStringPiece(regex), opt));
-      VELOX_CHECK_LE(
-          compiledRegularExpressions_.size(),
-          kMaxCompiledRegexes,
-          "Max number of regex reached");
-      checkForBadPattern(*it->second);
-      return re2FullMatch(input, *it->second);
+      auto* re = findOrCompileRegex(pattern, escapeChar);
+      return re2FullMatch(input, *re);
     };
 
     auto applyRow = [&](const StringView& input,
                         const StringView& pattern,
                         const std::optional<char>& escapeChar) -> bool {
-      if (!escapeChar) {
-        PatternKind patternKind;
-        vector_size_t reducedLength;
-        std::tie(patternKind, reducedLength) = determinePatternKind(pattern);
+      PatternMetadata patternMetadata =
+          determinePatternKind(std::string_view(pattern), escapeChar);
 
-        switch (patternKind) {
+      if (isAscii) {
+        switch (patternMetadata.patternKind()) {
+          case PatternKind::kExactlyN:
+            return OptimizedLike<PatternKind::kExactlyN>::match<
+                /*isAscii*/ true>(input, patternMetadata);
+          case PatternKind::kAtLeastN:
+            return OptimizedLike<PatternKind::kAtLeastN>::match<
+                /*isAscii*/ true>(input, patternMetadata);
+          case PatternKind::kFixed:
+            return OptimizedLike<PatternKind::kFixed>::match</*isAscii*/ true>(
+                input, patternMetadata);
+          case PatternKind::kPrefix:
+            return OptimizedLike<PatternKind::kPrefix>::match</*isAscii*/ true>(
+                input, patternMetadata);
+          case PatternKind::kSuffix:
+            return OptimizedLike<PatternKind::kSuffix>::match</*isAscii*/ true>(
+                input, patternMetadata);
+          case PatternKind::kSubstring:
+            return OptimizedLike<PatternKind::kSubstring>::match<
+                /*isAscii*/ true>(input, patternMetadata);
+          default:
+            return applyWithRegex(input, pattern, escapeChar);
+        }
+      } else {
+        switch (patternMetadata.patternKind()) {
           case PatternKind::kExactlyN:
-            return OptimizedLikeWithMemcmp<PatternKind::kExactlyN>::match(
-                input, pattern, reducedLength);
+            return OptimizedLike<PatternKind::kExactlyN>::match<
+                /*isAscii*/ false>(input, patternMetadata);
           case PatternKind::kAtLeastN:
-            return OptimizedLikeWithMemcmp<PatternKind::kAtLeastN>::match(
-                input, pattern, reducedLength);
+            return OptimizedLike<PatternKind::kAtLeastN>::match<
+                /*isAscii*/ false>(input, patternMetadata);
           case PatternKind::kFixed:
-            return OptimizedLikeWithMemcmp<PatternKind::kFixed>::match(
-                input, pattern, reducedLength);
+            return OptimizedLike<PatternKind::kFixed>::match</*isAscii*/ false>(
+                input, patternMetadata);
           case PatternKind::kPrefix:
-            return OptimizedLikeWithMemcmp<PatternKind::kPrefix>::match(
-                input, pattern, reducedLength);
+            return OptimizedLike<PatternKind::kPrefix>::match<
+                /*isAscii*/ false>(input, patternMetadata);
           case PatternKind::kSuffix:
-            return OptimizedLikeWithMemcmp<PatternKind::kSuffix>::match(
-                input, pattern, reducedLength);
+            return OptimizedLike<PatternKind::kSuffix>::match<
+                /*isAscii*/ false>(input, patternMetadata);
+          case PatternKind::kSubstring:
+            return OptimizedLike<PatternKind::kSubstring>::match<
+                /*isAscii*/ false>(input, patternMetadata);
           default:
             return applyWithRegex(input, pattern, escapeChar);
         }
       }
-      return applyWithRegex(input, pattern, escapeChar);
     };
 
     context.ensureWritable(rows, type, localResult);
@@ -646,6 +975,40 @@ class LikeGeneric final : public VectorFunction {
   }
 
  private:
+  RE2* findOrCompileRegex(
+      const StringView& pattern,
+      std::optional<char> escapeChar) const {
+    const auto key =
+        std::pair<std::string, std::optional<char>>{pattern, escapeChar};
+
+    auto reIt = compiledRegularExpressions_.find(key);
+    if (reIt != compiledRegularExpressions_.end()) {
+      return reIt->second.get();
+    }
+
+    VELOX_USER_CHECK_LT(
+        compiledRegularExpressions_.size(),
+        kMaxCompiledRegexes,
+        "Max number of regex reached");
+
+    bool validEscapeUsage;
+    auto regex = likePatternToRe2(pattern, escapeChar, validEscapeUsage);
+    VELOX_USER_CHECK(
+        validEscapeUsage,
+        "Escape character must be followed by '%', '_' or the escape character itself");
+
+    RE2::Options opt{RE2::Quiet};
+    opt.set_dot_nl(true);
+    auto re = std::make_unique<RE2>(toStringPiece(regex), opt);
+    checkForBadPattern(*re);
+
+    auto [it, inserted] =
+        compiledRegularExpressions_.emplace(key, std::move(re));
+    VELOX_CHECK(inserted);
+
+    return it->second.get();
+  }
+
   mutable folly::F14FastMap<
       std::pair<std::string, std::optional<char>>,
       std::unique_ptr<RE2>>
@@ -686,7 +1049,7 @@ void re2ExtractAll(
 }
 
 template <typename T>
-class Re2ExtractAllConstantPattern final : public VectorFunction {
+class Re2ExtractAllConstantPattern final : public exec::VectorFunction {
  public:
   explicit Re2ExtractAllConstantPattern(StringView pattern)
       : re_(toStringPiece(pattern), RE2::Quiet) {}
@@ -695,12 +1058,12 @@ class Re2ExtractAllConstantPattern final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
     try {
       checkForBadPattern(re_);
-    } catch (const std::exception& e) {
+    } catch (const std::exception&) {
       context.setErrors(rows, std::current_exception());
       return;
     }
@@ -725,7 +1088,7 @@ class Re2ExtractAllConstantPattern final : public VectorFunction {
       //
       try {
         checkForBadGroupId(*_groupId, re_);
-      } catch (const std::exception& e) {
+      } catch (const std::exception&) {
         context.setErrors(rows, std::current_exception());
         return;
       }
@@ -760,13 +1123,13 @@ class Re2ExtractAllConstantPattern final : public VectorFunction {
 };
 
 template <typename T>
-class Re2ExtractAll final : public VectorFunction {
+class Re2ExtractAll final : public exec::VectorFunction {
  public:
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx& context,
+      exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
     // Use Re2ExtractAllConstantPattern if it's constant regexp pattern.
@@ -791,8 +1154,7 @@ class Re2ExtractAll final : public VectorFunction {
       //
       groups.resize(1);
       context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
-        RE2 re(toStringPiece(pattern->valueAt<StringView>(row)), RE2::Quiet);
-        checkForBadPattern(re);
+        auto& re = *cache_.findOrCompile(pattern->valueAt<StringView>(row));
         re2ExtractAll(resultWriter, re, inputStrs, row, groups, 0);
       });
     } else {
@@ -801,8 +1163,7 @@ class Re2ExtractAll final : public VectorFunction {
       exec::LocalDecodedVector groupIds(context, *args[2], rows);
       context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
         const T groupId = groupIds->valueAt<T>(row);
-        RE2 re(toStringPiece(pattern->valueAt<StringView>(row)), RE2::Quiet);
-        checkForBadPattern(re);
+        auto& re = *cache_.findOrCompile(pattern->valueAt<StringView>(row));
         checkForBadGroupId(groupId, re);
         groups.resize(groupId + 1);
         re2ExtractAll(resultWriter, re, inputStrs, row, groups, groupId);
@@ -815,12 +1176,15 @@ class Re2ExtractAll final : public VectorFunction {
         ->asFlatVector<StringView>()
         ->acquireSharedStringBuffers(inputStrs->base());
   }
+
+ private:
+  mutable detail::ReCache cache_;
 };
 
 template <bool (*Fn)(StringView, const RE2&)>
-std::shared_ptr<VectorFunction> makeRe2MatchImpl(
+std::shared_ptr<exec::VectorFunction> makeRe2MatchImpl(
     const std::string& name,
-    const std::vector<VectorFunctionArg>& inputArgs) {
+    const std::vector<exec::VectorFunctionArg>& inputArgs) {
   if (inputArgs.size() != 2 || !inputArgs[0].type->isVarchar() ||
       !inputArgs[1].type->isVarchar()) {
     VELOX_UNSUPPORTED(
@@ -835,16 +1199,379 @@ std::shared_ptr<VectorFunction> makeRe2MatchImpl(
     return std::make_shared<Re2MatchConstantPattern<Fn>>(
         constantPattern->as<ConstantVector<StringView>>()->valueAt(0));
   }
-  static std::shared_ptr<Re2Match<Fn>> kMatchExpr =
-      std::make_shared<Re2Match<Fn>>();
-  return kMatchExpr;
+
+  return std::make_shared<Re2Match<Fn>>();
 }
 
+class RegexpReplaceWithLambdaFunction : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    exec::LocalDecodedVector strings(context, *args[0], rows);
+    exec::LocalDecodedVector patterns(context, *args[1], rows);
+
+    auto resultWriter = createResultWriter(rows, context, result);
+
+    auto* transforms = args[2]->asUnchecked<FunctionVector>();
+
+    // Exclude rows with NULL string or pattern from evaluation.
+    exec::LocalSelectivityVector nonNullRows(context, rows);
+    if (strings->mayHaveNulls()) {
+      nonNullRows->deselectNulls(strings->nulls(), 0, rows.end());
+    }
+    if (patterns->mayHaveNulls()) {
+      nonNullRows->deselectNulls(patterns->nulls(), 0, rows.end());
+    }
+
+    auto it = transforms->iterator(nonNullRows.get());
+    while (auto entry = it.next()) {
+      // For each input row, apply regex pattern to the string and identify
+      // matches and matching groups. Total number of matches may be less or
+      // more than number of input rows. Some strings may have no matches, some
+      // may have more than one match.
+      exec::LocalSelectivityVector remainingRows(context, *entry.rows);
+      const auto matches =
+          findMatches(*strings, *patterns, *remainingRows, context);
+
+      // Exclude rows with invalid regex from further processing.
+      context.deselectErrors(*remainingRows);
+
+      // Total number of matches across all input rows. Each match has a list of
+      // matching groups.
+      const auto totalMatches = matches.matches->size();
+
+      // Number of matches per input row.
+      auto* rawNumMatches = matches.rawNumMatches;
+
+      // If lambda is using captures, make sure to 'replicate' captures for all
+      // matches of a given input row.
+      BufferPtr wrapCapture = makeWrapCapture(
+          *remainingRows, totalMatches, rawNumMatches, context.pool());
+
+      // Lambda is applied to an ArrayVector, where each row contains a list of
+      // matching groups from a single match.
+      const std::vector<VectorPtr> lambdaArgs = {matches.matches};
+
+      // Lambda function takes an array of matching groups and returns a single
+      // replacement string.
+      auto replacements =
+          BaseVector::create(VARCHAR(), totalMatches, context.pool());
+
+      SelectivityVector matchesRows(totalMatches);
+
+      entry.callable->apply(
+          matchesRows,
+          nullptr, // No need to preserve any values in 'replacements'.
+          wrapCapture,
+          &context,
+          lambdaArgs,
+          wrapCapture,
+          &replacements);
+
+      exec::LocalDecodedVector decodedReplacements(
+          context, *replacements, matchesRows);
+      auto* rawOffsets = matches.rawOffsets;
+      auto* rawSizes = matches.rawSizes;
+
+      vector_size_t matchRow = 0;
+      remainingRows->applyToSelected([&](auto row) {
+        const auto original = strings->valueAt<StringView>(row);
+
+        bool resultIsNull = false;
+
+        // Calculate string length after replacing all matches.
+        size_t resultSize = original.size();
+        for (auto i = 0; i < rawNumMatches[row]; ++i) {
+          if (decodedReplacements->isNullAt(matchRow + i)) {
+            // If one of the replacements is NULL, the result is NULL.
+            resultIsNull = true;
+            break;
+          }
+
+          const auto replacementSize =
+              decodedReplacements->valueAt<StringView>(matchRow + i).size();
+
+          resultSize -= rawSizes[matchRow + i];
+          resultSize += replacementSize;
+        }
+
+        resultWriter.setOffset(row);
+        if (resultIsNull) {
+          resultWriter.commitNull();
+          matchRow += rawNumMatches[row];
+        } else {
+          auto stringWriter = resultWriter.current();
+          stringWriter.resize(resultSize);
+
+          Replacer replacer{original, stringWriter};
+          for (auto i = 0; i < rawNumMatches[row]; ++i) {
+            replacer.replace(
+                rawOffsets[matchRow],
+                rawSizes[matchRow],
+                decodedReplacements->valueAt<StringView>(matchRow));
+            ++matchRow;
+          }
+          replacer.finalize();
+        }
+      });
+    }
+
+    resultWriter.finish();
+
+    // Set NULL results for 'rows' that have NULL 'string' or 'pattern'.
+    if (strings->mayHaveNulls()) {
+      exec::EvalCtx::addNulls(
+          rows, strings->nulls(&rows), context, outputType, result);
+    }
+    if (patterns->mayHaveNulls()) {
+      exec::EvalCtx::addNulls(
+          rows, patterns->nulls(&rows), context, outputType, result);
+    }
+  }
+
+ private:
+  static exec::VectorWriter<Varchar> createResultWriter(
+      const SelectivityVector& rows,
+      exec::EvalCtx& context,
+      VectorPtr& result) {
+    context.ensureWritable(rows, VARCHAR(), result);
+    auto* flatResult = result->asFlatVector<StringView>();
+
+    exec::VectorWriter<Varchar> resultWriter;
+    resultWriter.init(*flatResult);
+    return resultWriter;
+  }
+
+  // Helper struct to replace sections of an input string.
+  // The caller must call 'replace' for each section in the order of their
+  // appearance in the string, then call 'finalize'.
+  // Sections being replaced should not overlap.
+  struct Replacer {
+    const StringView& original;
+    exec::StringWriter<false>& writer;
+    char* result;
+    size_t start = 0;
+
+    Replacer(const StringView& _original, exec::StringWriter<false>& _writer)
+        : original{_original}, writer{_writer}, result{writer.data()} {}
+
+    void replace(size_t offset, size_t size, const StringView& replacement) {
+      VELOX_DCHECK_GE(offset, start);
+
+      // Copy 'original' string from 'start' to 'offset' into result. Then
+      // copy replacement.
+      if (offset > start) {
+        std::memcpy(result, original.data() + start, offset - start);
+        result += offset - start;
+      }
+
+      if (replacement.size() > 0) {
+        std::memcpy(result, replacement.data(), replacement.size());
+        result += replacement.size();
+      }
+
+      start = offset + size;
+    }
+
+    void finalize() {
+      // Copy the tail of the 'original' string.
+      if (start < original.size()) {
+        std::memcpy(result, original.data() + start, original.size() - start);
+      }
+
+      writer.finalize();
+    }
+  };
+
+  static BufferPtr makeWrapCapture(
+      const SelectivityVector& rows,
+      vector_size_t totalMatches,
+      const vector_size_t* numMatchesPerRow,
+      memory::MemoryPool* pool) {
+    BufferPtr wrapCapture = allocateIndices(totalMatches, pool);
+    auto* rawWrapCapture = wrapCapture->asMutable<vector_size_t>();
+
+    vector_size_t matchRow = 0;
+    rows.applyToSelected([&](auto row) {
+      for (auto i = 0; i < numMatchesPerRow[row]; ++i) {
+        rawWrapCapture[matchRow++] = row;
+      }
+    });
+    return wrapCapture;
+  }
+
+  // The result of 'findMatches'.
+  //
+  // Example:
+  //
+  // Input to 'findMatches':
+  //  - 2 top-level rows - 'new york' and 'los angeles'.
+  //  - Constant pattern '(\w)(\w*)' that matches whole words and separates each
+  //  word into
+  //    first latter and the rest.
+  //
+  // Result:
+  //
+  // numMatches = [2, 2]
+  // matches = [['n', 'ew'], ['y', 'ork'], ['l', 'os'], ['a', 'ngeles']]
+  // offsets = [0, 4, 0, 4]
+  // sizes   = [3, 4, 3, 7]
+  struct Matches {
+    // Number of matches per top-level row. Each match has one row in 'matches'
+    // vector.
+    BufferPtr numMatches;
+    vector_size_t* rawNumMatches;
+
+    // Each row correctsponds to a single match in a top-level row and contains
+    // an array of matching groups. Number of rows in this vector equals the sum
+    // of matches across all top-level rows.
+    ArrayVectorPtr matches;
+
+    // Starting position of a match in top-level string. Number of
+    // entries is equal to the size of 'matches'.
+    BufferPtr offsets;
+    vector_size_t* rawOffsets;
+
+    // Size of a match in top-level string. Aligned with 'offsets'.
+    BufferPtr sizes;
+    vector_size_t* rawSizes;
+
+    Matches(vector_size_t maxInputStrings, memory::MemoryPool* pool) {
+      // Each input string may have 0..N matches. Each match has 0..M matching
+      // groups. This array has one row per match (N rows), each row is an array
+      // of 0..M matching groups. When regex is non-constant, the number of
+      // matching groups can vary from row to row. Hence, the number of array
+      // elements is not known up front. Even with constant regex, the number of
+      // matches per row can vary. Hence, the number of array rows is not known
+      // up front. We choose number of input strings as the initial size for the
+      // Array vector somewhat arbitrary.
+      const auto initialNumMatches = maxInputStrings;
+      matches = BaseVector::create<ArrayVector>(
+          ARRAY(VARCHAR()), initialNumMatches, pool);
+
+      numMatches = allocateSizes(maxInputStrings, pool);
+      rawNumMatches = numMatches->asMutable<vector_size_t>();
+
+      offsets = allocateOffsets(initialNumMatches, pool);
+      rawOffsets = offsets->asMutable<vector_size_t>();
+
+      sizes = allocateSizes(initialNumMatches, pool);
+      rawSizes = sizes->asMutable<vector_size_t>();
+    }
+
+    void ensureSize(vector_size_t matchRow) {
+      if (matches->size() < matchRow + 1) {
+        const auto newSize = (matchRow + 1) * 2;
+        matches->resize(newSize);
+
+        AlignedBuffer::reallocate<vector_size_t>(&offsets, newSize, 0);
+        rawOffsets = offsets->asMutable<vector_size_t>();
+
+        AlignedBuffer::reallocate<vector_size_t>(&sizes, newSize, 0);
+        rawSizes = sizes->asMutable<vector_size_t>();
+      }
+    }
+
+    void setMatchOffsetAndSize(
+        vector_size_t matchRow,
+        vector_size_t offset,
+        size_t size) {
+      rawOffsets[matchRow] = offset;
+      rawSizes[matchRow] = size;
+    }
+  };
+
+  Matches findMatches(
+      DecodedVector& strings,
+      DecodedVector& patterns,
+      const SelectivityVector& rows,
+      exec::EvalCtx& context) const {
+    auto* pool = context.pool();
+
+    Matches matches(rows.end(), pool);
+
+    exec::VectorWriter<Array<Varchar>> matchesArrayWriter;
+    matchesArrayWriter.init(*matches.matches);
+
+    auto* rawNumMatches = matches.rawNumMatches;
+
+    vector_size_t matchRow = 0;
+
+    rows.applyToSelected([&](auto row) {
+      auto reOrError =
+          cache_.tryFindOrCompile(patterns.valueAt<StringView>(row));
+      if (reOrError.hasError()) {
+        context.setStatus(row, reOrError.error());
+        return;
+      }
+
+      auto* re = reOrError.value();
+
+      const auto numGroups = re->NumberOfCapturingGroups();
+
+      const auto hay = strings.valueAt<StringView>(row);
+
+      vector_size_t numMatchesPerRow = 0;
+
+      size_t pos = 0;
+      re2::StringPiece subMatches[numGroups + 1];
+      while (re->Match(
+          toStringPiece(hay),
+          pos,
+          hay.size(),
+          RE2::Anchor::UNANCHORED,
+          subMatches,
+          numGroups + 1)) {
+        ++numMatchesPerRow;
+        matches.ensureSize(matchRow + 1);
+        matchesArrayWriter.setOffset(matchRow);
+        auto& arrayWriter = matchesArrayWriter.current();
+        for (auto i = 0; i < numGroups; i++) {
+          const auto subMatch = subMatches[i + 1];
+          if (subMatch.data() != nullptr) {
+            arrayWriter.add_item().setNoCopy(
+                StringView(subMatch.data(), subMatch.size()));
+          } else {
+            arrayWriter.add_null();
+          }
+        }
+        matchesArrayWriter.commit();
+
+        const auto fullMatch = subMatches[0];
+
+        const auto offset = fullMatch.data() - hay.data();
+        const auto size = fullMatch.size();
+        matches.setMatchOffsetAndSize(matchRow, offset, size);
+
+        pos = offset + size;
+        if (UNLIKELY(size == 0)) {
+          ++pos;
+        }
+
+        ++matchRow;
+      }
+
+      rawNumMatches[row] = numMatchesPerRow;
+    });
+
+    matchesArrayWriter.finish();
+    matches.matches->resize(matchRow);
+
+    return matches;
+  }
+
+  mutable detail::ReCache cache_;
+};
+
 } // namespace
 
-std::shared_ptr<VectorFunction> makeRe2Match(
+std::shared_ptr<exec::VectorFunction> makeRe2Match(
     const std::string& name,
-    const std::vector<VectorFunctionArg>& inputArgs,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/) {
   return makeRe2MatchImpl<re2FullMatch>(name, inputArgs);
 }
@@ -858,9 +1585,9 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> re2MatchSignatures() {
               .build()};
 }
 
-std::shared_ptr<VectorFunction> makeRe2Search(
+std::shared_ptr<exec::VectorFunction> makeRe2Search(
     const std::string& name,
-    const std::vector<VectorFunctionArg>& inputArgs,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/) {
   return makeRe2MatchImpl<re2PartialMatch>(name, inputArgs);
 }
@@ -874,9 +1601,9 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> re2SearchSignatures() {
               .build()};
 }
 
-std::shared_ptr<VectorFunction> makeRe2Extract(
+std::shared_ptr<exec::VectorFunction> makeRe2Extract(
     const std::string& name,
-    const std::vector<VectorFunctionArg>& inputArgs,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/,
     const bool emptyNoMatch) {
   auto numArgs = inputArgs.size();
@@ -960,71 +1687,425 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> re2ExtractSignatures() {
   };
 }
 
-std::pair<PatternKind, vector_size_t> determinePatternKind(StringView pattern) {
-  vector_size_t patternLength = pattern.size();
-  vector_size_t i = 0;
-  // Index of the first % or _ character.
-  vector_size_t wildcardStart = -1;
-  // Index of the first character that is not % and not _.
-  vector_size_t fixedPatternStart = -1;
-  // Total number of % characters.
-  vector_size_t anyCharacterWildcardCount = 0;
-  // Total number of _ characters.
-  vector_size_t singleCharacterWildcardCount = 0;
-  auto patternStr = pattern.data();
-
-  while (i < patternLength) {
-    if (patternStr[i] == '%' || patternStr[i] == '_') {
-      // Ensures that pattern has a single contiguous stream of wildcard
-      // characters.
-      if (wildcardStart != -1) {
-        return std::make_pair(PatternKind::kGeneric, 0);
-      }
-      // Look till the last contiguous wildcard character, starting from this
-      // index, is found, or the end of pattern is reached.
-      wildcardStart = i;
-      while (i < patternLength &&
-             (patternStr[i] == '%' || patternStr[i] == '_')) {
-        singleCharacterWildcardCount += (patternStr[i] == '_');
-        anyCharacterWildcardCount += (patternStr[i] == '%');
-        i++;
+PatternMetadata PatternMetadata::generic() {
+  return {PatternKind::kGeneric, 0, "", {}};
+}
+
+PatternMetadata PatternMetadata::atLeastN(size_t length) {
+  return {PatternKind::kAtLeastN, length, "", {}};
+}
+
+PatternMetadata PatternMetadata::exactlyN(size_t length) {
+  return {PatternKind::kExactlyN, length, "", {}};
+}
+
+PatternMetadata PatternMetadata::fixed(const std::string& fixedPattern) {
+  return {PatternKind::kFixed, fixedPattern.length(), fixedPattern, {}};
+}
+
+PatternMetadata PatternMetadata::relaxedFixed(
+    std::string fixedPattern,
+    std::vector<SubPatternMetadata> subPatterns) {
+  const auto fixedLength = fixedPattern.length();
+  return {
+      PatternKind::kRelaxedFixed,
+      fixedLength,
+      std::move(fixedPattern),
+      std::move(subPatterns)};
+}
+
+PatternMetadata PatternMetadata::prefix(const std::string& fixedPattern) {
+  return {PatternKind::kPrefix, fixedPattern.length(), fixedPattern, {}};
+}
+
+PatternMetadata PatternMetadata::relaxedPrefix(
+    std::string fixedPattern,
+    std::vector<SubPatternMetadata> subPatterns) {
+  const auto fixedLength = fixedPattern.length();
+  return {
+      PatternKind::kRelaxedPrefix,
+      fixedLength,
+      std::move(fixedPattern),
+      std::move(subPatterns)};
+}
+
+PatternMetadata PatternMetadata::suffix(const std::string& fixedPattern) {
+  return {PatternKind::kSuffix, fixedPattern.length(), fixedPattern, {}};
+}
+
+PatternMetadata PatternMetadata::relaxedSuffix(
+    std::string fixedPattern,
+    std::vector<SubPatternMetadata> subPatterns) {
+  const auto fixedLength = fixedPattern.length();
+  return {
+      PatternKind::kRelaxedSuffix,
+      fixedLength,
+      std::move(fixedPattern),
+      std::move(subPatterns)};
+}
+
+PatternMetadata PatternMetadata::substring(const std::string& fixedPattern) {
+  return {PatternKind::kSubstring, fixedPattern.length(), fixedPattern, {}};
+}
+
+PatternMetadata::PatternMetadata(
+    PatternKind patternKind,
+    size_t length,
+    std::string fixedPattern,
+    std::vector<SubPatternMetadata> subPatterns)
+    : patternKind_{patternKind},
+      length_{length},
+      fixedPattern_(std::move(fixedPattern)),
+      subPatterns_(std::move(subPatterns)) {}
+
+// Iterates through a pattern string. Transparently handles escape sequences.
+class PatternStringIterator {
+ public:
+  PatternStringIterator(
+      std::string_view pattern,
+      std::optional<char> escapeChar)
+      : pattern_(pattern), escapeChar_(escapeChar) {}
+
+  // Advance the cursor to next char, escape char is automatically handled.
+  // Return true if the cursor is advanced successfully, false otherwise(reached
+  // the end of the pattern string).
+  bool next() {
+    if (nextStart_ == pattern_.size()) {
+      return false;
+    }
+
+    currentStart_ = nextStart_;
+    auto currentChar = charAt(currentStart_);
+    if (currentChar == escapeChar_) {
+      // Escape char should be followed by another char.
+      VELOX_USER_CHECK_LT(
+          currentStart_ + 1,
+          pattern_.size(),
+          "Escape character must be followed by '%', '_' or the escape character itself: {}, escape {}",
+          pattern_,
+          escapeChar_.value());
+
+      currentChar = charAt(currentStart_ + 1);
+      // The char follows escapeChar can only be one of (%, _, escapeChar).
+      if (currentChar == escapeChar_ || currentChar == '_' ||
+          currentChar == '%') {
+        charKind_ = CharKind::kNormal;
+      } else {
+        VELOX_USER_FAIL(
+            "Escape character must be followed by '%', '_' or the escape character itself: {}, escape {}",
+            pattern_,
+            escapeChar_.value());
       }
+      // One escape char plus the current char.
+      nextStart_ = currentStart_ + 2;
     } else {
-      // Ensure that pattern has a single fixed pattern.
-      if (fixedPatternStart != -1) {
-        return std::make_pair(PatternKind::kGeneric, 0);
-      }
-      // Look till the end of fixed pattern, starting from this index, is found,
-      // or the end of pattern is reached.
-      fixedPatternStart = i;
-      while (i < patternLength &&
-             (patternStr[i] != '%' && patternStr[i] != '_')) {
-        i++;
+      if (currentChar == '_') {
+        charKind_ = CharKind::kSingleCharWildcard;
+        nextStart_ = currentStart_ + 1;
+      } else if (currentChar == '%') {
+        charKind_ = CharKind::kAnyCharsWildcard;
+        nextStart_ = currentStart_ + 1;
+      } else {
+        charKind_ = CharKind::kNormal;
+
+        // Unicode.
+        if (currentChar & 0x80) {
+          auto numBytes = unicodeCharLength(pattern_.data() + currentStart_);
+          nextStart_ = currentStart_ + numBytes;
+        } else {
+          nextStart_ = currentStart_ + 1;
+        }
       }
     }
+
+    return true;
+  }
+
+  // Char at current cursor, since it can be a multibyte character, here we use
+  // a string_view to represent.
+  std::string_view current() const {
+    // Escaped.
+    if (charAt(currentStart_) == escapeChar_) {
+      return std::string_view(pattern_.data() + currentStart_ + 1, 1);
+    } else {
+      return std::string_view(
+          pattern_.data() + currentStart_, nextStart_ - currentStart_);
+    }
+  }
+
+  bool isAnyCharsWildcard() const {
+    return charKind_ == CharKind::kAnyCharsWildcard;
+  }
+
+  bool isSingleCharWildcard() const {
+    return charKind_ == CharKind::kSingleCharWildcard;
+  }
+
+ private:
+  // Represents the state of current cursor/char.
+  enum class CharKind {
+    // Wildcard char: %.
+    // NOTE: If escape char is set as '\', for pattern '\%%', the first '%' is
+    // not a wildcard, just a literal '%', the second '%' is a wildcard.
+    kAnyCharsWildcard,
+    // Wildcard char: _.
+    // NOTE: If escape char is set as '\', for pattern '\__', the first '_' is
+    // not a wildcard, just a literal '_', the second '_' is a wildcard.
+    kSingleCharWildcard,
+    // Chars that are not escape char & not wildcard char.
+    kNormal
+  };
+
+  // Char at current cursor.
+  char charAt(size_t index) const {
+    VELOX_DCHECK(index < pattern_.size());
+    return pattern_.data()[index];
+  }
+
+  std::string_view pattern_;
+  const std::optional<char> escapeChar_;
+
+  // Index of current char(including the escape char if there is).
+  size_t currentStart_{0};
+  // Index of next char.
+  size_t nextStart_{0};
+  CharKind charKind_{CharKind::kNormal};
+};
+
+// Is the specified sub-patterns an optimization candidate?
+// Return true if it *might* be optimized, return false if it is not
+// optimize-able.
+bool isOptimizedLikeCandidate(
+    const std::array<SubPatternStats, 3>& stats,
+    int numSubPatterns,
+    SubPatternKind firstPatternKind,
+    SubPatternKind lastPatternKind) {
+  if (stats[kLiteralString].count == 0) {
+    return true;
+  }
+
+  // More than 2 '%' , no fast path for it.
+  if (stats[kAnyCharsWildcard].count > 2) {
+    return false;
+  }
+
+  // Only 2 '%', but the '%' is not at the beginning and end of the pattern, no
+  // fast path for it.
+  if (stats[kAnyCharsWildcard].count == 2 &&
+      (firstPatternKind != SubPatternKind::kAnyCharsWildcard ||
+       lastPatternKind != SubPatternKind::kAnyCharsWildcard)) {
+    return false;
   }
 
-  // Pattern contains wildcard characters only.
-  if (fixedPatternStart == -1) {
-    if (!anyCharacterWildcardCount) {
-      return {PatternKind::kExactlyN, singleCharacterWildcardCount};
+  // Only one '%', but it is not the first/last pattern, no fast path for it.
+  if (stats[kAnyCharsWildcard].count == 1 &&
+      (stats[kAnyCharsWildcard].firstIndex > 0 &&
+       stats[kAnyCharsWildcard].firstIndex < numSubPatterns - 1)) {
+    return false;
+  }
+
+  return true;
+}
+
+// Parse the pattern into sub-patterns.
+std::optional<std::string> parsePattern(
+    std::string_view pattern,
+    std::optional<char> escapeChar,
+    std::vector<SubPatternKind>& subPatternKinds,
+    std::vector<std::pair<size_t, size_t>>& subPatternRanges) {
+  PatternStringIterator iterator{pattern, escapeChar};
+
+  // Iterate through the pattern string to collect the stats for the simple
+  // patterns that we can optimize.
+  std::ostringstream os;
+  std::optional<SubPatternKind> previousKind;
+  size_t currentSubPatternStart = 0;
+  size_t cursor = 0;
+
+  while (iterator.next()) {
+    SubPatternKind currentKind;
+    if (iterator.isSingleCharWildcard()) {
+      currentKind = SubPatternKind::kSingleCharWildcard;
+    } else if (iterator.isAnyCharsWildcard()) {
+      currentKind = SubPatternKind::kAnyCharsWildcard;
+    } else {
+      currentKind = SubPatternKind::kLiteralString;
+    }
+
+    // Set the 'previousKind' to currentKind if it has not been set yet, which
+    // only occur once(the first char) during parsing.
+    if (FOLLY_UNLIKELY(!previousKind.has_value())) {
+      previousKind = currentKind;
+    }
+
+    // New sub pattern occurs.
+    if (currentKind != previousKind) {
+      subPatternKinds.push_back(previousKind.value());
+      subPatternRanges.push_back(
+          {currentSubPatternStart, cursor - currentSubPatternStart});
+      currentSubPatternStart = cursor;
+      previousKind = currentKind;
+    }
+
+    // Advance the cursor.
+    std::string_view currentChar = iterator.current();
+    cursor += currentChar.size();
+
+    // We only need to collect the unescaped chars if user specified escape
+    // char.
+    if (escapeChar.has_value()) {
+      os << iterator.current();
     }
-    return {PatternKind::kAtLeastN, singleCharacterWildcardCount};
   }
-  // Pattern contains no wildcard characters (is a fixed pattern).
-  if (wildcardStart == -1) {
-    return {PatternKind::kFixed, patternLength};
+
+  // Handle the last sub-pattern.
+  subPatternKinds.push_back(previousKind.value());
+  subPatternRanges.push_back(
+      {currentSubPatternStart, cursor - currentSubPatternStart});
+
+  return escapeChar.has_value() ? std::make_optional(os.str()) : std::nullopt;
+}
+
+PatternMetadata determinePatternKind(
+    std::string_view pattern,
+    std::optional<char> escapeChar) {
+  if (FOLLY_UNLIKELY(pattern.empty())) {
+    return PatternMetadata::fixed("");
+  }
+
+  // Parse the pattern into sub-patterns.
+  std::vector<SubPatternKind> subPatternKinds;
+  std::vector<std::pair<size_t, size_t>> subPatternRanges;
+
+  std::optional<std::string> parsedPattern =
+      parsePattern(pattern, escapeChar, subPatternKinds, subPatternRanges);
+  std::string_view unescapedPattern =
+      escapeChar.has_value() ? parsedPattern.value() : pattern;
+
+  const auto numSubPatterns = subPatternKinds.size();
+  std::array<SubPatternStats, 3> stats = {
+      SubPatternStats{kSingleCharWildcard},
+      SubPatternStats{kAnyCharsWildcard},
+      SubPatternStats{kLiteralString}};
+
+  // Collect the sub-pattern stats.
+  for (auto i = 0; i < numSubPatterns; i++) {
+    stats[subPatternKinds[i]].update(i);
   }
-  // Pattern is generic if it has '_' wildcard characters and a fixed pattern.
-  if (singleCharacterWildcardCount) {
-    return {PatternKind::kGeneric, 0};
+
+  // Determine optimized pattern base on stats we have.
+  const auto firstSubPatternKind = subPatternKinds[0];
+  const auto firstSubPatternLength = subPatternRanges[0].second;
+
+  const auto lastSubPatternKind = subPatternKinds[numSubPatterns - 1];
+  const auto lastSubPatternStart = subPatternRanges[numSubPatterns - 1].first;
+  const auto lastSubPatternLength = subPatternRanges[numSubPatterns - 1].second;
+
+  // Fail fast if we have no fast path for it.
+  if (!isOptimizedLikeCandidate(
+          stats, numSubPatterns, firstSubPatternKind, lastSubPatternKind)) {
+    return PatternMetadata::generic();
   }
-  // Classify pattern as prefix pattern or suffix pattern based on the
-  // positions of the fixed pattern and contiguous wildcard character stream.
-  if (fixedPatternStart < wildcardStart) {
-    return {PatternKind::kPrefix, wildcardStart};
+
+  // Single sub-pattern.
+  if (numSubPatterns == 1) {
+    if (firstSubPatternKind == SubPatternKind::kSingleCharWildcard) {
+      return PatternMetadata::exactlyN(firstSubPatternLength);
+    } else if (firstSubPatternKind == SubPatternKind::kAnyCharsWildcard) {
+      return PatternMetadata::atLeastN(0);
+    }
+
+    return PatternMetadata::fixed(std::string(unescapedPattern));
+  } else { // Multiple sub-patterns.
+    // No kLiteralString sub-pattern.
+    if (stats[kLiteralString].count == 0) {
+      const auto singleCharacterWildcardCount =
+          fixedLength(subPatternKinds, subPatternRanges);
+      return PatternMetadata::atLeastN(singleCharacterWildcardCount);
+    } else {
+      // At this point, the pattern contains at least one kLiteralString
+      // sub-pattern.
+
+      // If there are only one literal sub-pattern and several any-wildcard
+      // sub-patterns.
+      if (stats[kSingleCharWildcard].count == 0 &&
+          stats[kLiteralString].count == 1 &&
+          stats[kAnyCharsWildcard].count > 0) {
+        if (firstSubPatternKind == SubPatternKind::kLiteralString) {
+          return PatternMetadata::prefix(
+              std::string(unescapedPattern, 0, firstSubPatternLength));
+        } else if (lastSubPatternKind == SubPatternKind::kLiteralString) {
+          return PatternMetadata::suffix(std::string(
+              unescapedPattern, lastSubPatternStart, lastSubPatternLength));
+        } else if (
+            numSubPatterns == 3 &&
+            firstSubPatternKind == SubPatternKind::kAnyCharsWildcard &&
+            lastSubPatternKind == SubPatternKind::kAnyCharsWildcard) {
+          return PatternMetadata::substring(std::string(
+              unescapedPattern,
+              subPatternRanges[1].first,
+              subPatternRanges[1].second));
+        }
+      }
+
+      // No any-wildcard sub-pattern.
+      if (stats[kAnyCharsWildcard].count == 0 &&
+          stats[kSingleCharWildcard].count > 0) {
+        std::vector<SubPatternMetadata> subPatterns;
+        buildFixedSubPatterns(
+            subPatternKinds, subPatternRanges, 0, numSubPatterns, subPatterns);
+        return PatternMetadata::relaxedFixed(
+            std::string(unescapedPattern), std::move(subPatterns));
+      }
+
+      // Pattern contains kAnyCharsWildcard, kSingleCharWildcard &
+      // kLiteralString.
+      if (stats[kSingleCharWildcard].count > 0 &&
+          stats[kAnyCharsWildcard].count > 0) {
+        const auto firstOfLiteralOrSingleWildcard = std::min(
+            stats[kLiteralString].firstIndex.value(),
+            stats[kSingleCharWildcard].firstIndex.value());
+        const auto lastOfLiteralOrSingleWildcard = std::max(
+            stats[kLiteralString].lastIndex.value(),
+            stats[kSingleCharWildcard].lastIndex.value());
+
+        if (lastOfLiteralOrSingleWildcard <
+            stats[kAnyCharsWildcard].firstIndex) {
+          std::vector<SubPatternMetadata> subPatterns;
+          size_t fixedLength = buildFixedSubPatterns(
+              subPatternKinds,
+              subPatternRanges,
+              firstOfLiteralOrSingleWildcard,
+              lastOfLiteralOrSingleWildcard + 1,
+              subPatterns);
+          return PatternMetadata::relaxedPrefix(
+              std::string(
+                  unescapedPattern,
+                  subPatternRanges[firstOfLiteralOrSingleWildcard].first,
+                  fixedLength),
+              std::move(subPatterns));
+        } else if (
+            firstOfLiteralOrSingleWildcard >
+            stats[kAnyCharsWildcard].lastIndex) {
+          std::vector<SubPatternMetadata> subPatterns;
+          const auto fixedLength = buildFixedSubPatterns(
+              subPatternKinds,
+              subPatternRanges,
+              firstOfLiteralOrSingleWildcard,
+              lastOfLiteralOrSingleWildcard + 1,
+              subPatterns);
+          return PatternMetadata::relaxedSuffix(
+              std::string(
+                  unescapedPattern,
+                  subPatternRanges[firstOfLiteralOrSingleWildcard].first,
+                  fixedLength),
+              std::move(subPatterns));
+        }
+      }
+    }
   }
-  return {PatternKind::kSuffix, patternLength - fixedPatternStart};
+
+  return PatternMetadata::generic();
 }
 
 std::shared_ptr<exec::VectorFunction> makeLike(
@@ -1045,6 +2126,10 @@ std::shared_ptr<exec::VectorFunction> makeLike(
       return std::make_shared<exec::ApplyNeverCalled>();
     }
 
+    // TODO(xumingming) Presto actually support multi-byte escape char(see [1]),
+    // we should support too.
+    //
+    // [1].https://github.com/facebookincubator/velox/issues/8363
     try {
       VELOX_USER_CHECK_EQ(
           constantEscape->valueAt(0).size(),
@@ -1067,36 +2152,46 @@ std::shared_ptr<exec::VectorFunction> makeLike(
   }
   auto pattern = constantPattern->as<ConstantVector<StringView>>()->valueAt(0);
 
-  if (!escapeChar) {
-    PatternKind patternKind;
-    vector_size_t reducedLength;
-    std::tie(patternKind, reducedLength) = determinePatternKind(pattern);
-
-    switch (patternKind) {
-      case PatternKind::kExactlyN:
-        return std::make_shared<
-            OptimizedLikeWithMemcmp<PatternKind::kExactlyN>>(
-            pattern, reducedLength);
-      case PatternKind::kAtLeastN:
-        return std::make_shared<
-            OptimizedLikeWithMemcmp<PatternKind::kAtLeastN>>(
-            pattern, reducedLength);
-      case PatternKind::kFixed:
-        return std::make_shared<OptimizedLikeWithMemcmp<PatternKind::kFixed>>(
-            pattern, reducedLength);
-      case PatternKind::kPrefix:
-        return std::make_shared<OptimizedLikeWithMemcmp<PatternKind::kPrefix>>(
-            pattern, reducedLength);
-      case PatternKind::kSuffix:
-        return std::make_shared<OptimizedLikeWithMemcmp<PatternKind::kSuffix>>(
-            pattern, reducedLength);
-      default:
-
-        return std::make_shared<LikeWithRe2>(pattern, escapeChar);
-    }
+  PatternMetadata patternMetadata = PatternMetadata::generic();
+  try {
+    patternMetadata =
+        determinePatternKind(std::string_view(pattern), escapeChar);
+  } catch (...) {
+    return std::make_shared<exec::AlwaysFailingVectorFunction>(
+        std::current_exception());
   }
 
-  return std::make_shared<LikeWithRe2>(pattern, escapeChar);
+  switch (patternMetadata.patternKind()) {
+    case PatternKind::kExactlyN:
+      return std::make_shared<OptimizedLike<PatternKind::kExactlyN>>(
+          patternMetadata);
+    case PatternKind::kAtLeastN:
+      return std::make_shared<OptimizedLike<PatternKind::kAtLeastN>>(
+          patternMetadata);
+    case PatternKind::kFixed:
+      return std::make_shared<OptimizedLike<PatternKind::kFixed>>(
+          patternMetadata);
+    case PatternKind::kRelaxedFixed:
+      return std::make_shared<OptimizedLike<PatternKind::kRelaxedFixed>>(
+          patternMetadata);
+    case PatternKind::kPrefix:
+      return std::make_shared<OptimizedLike<PatternKind::kPrefix>>(
+          patternMetadata);
+    case PatternKind::kRelaxedPrefix:
+      return std::make_shared<OptimizedLike<PatternKind::kRelaxedPrefix>>(
+          patternMetadata);
+    case PatternKind::kSuffix:
+      return std::make_shared<OptimizedLike<PatternKind::kSuffix>>(
+          patternMetadata);
+    case PatternKind::kRelaxedSuffix:
+      return std::make_shared<OptimizedLike<PatternKind::kRelaxedSuffix>>(
+          patternMetadata);
+    case PatternKind::kSubstring:
+      return std::make_shared<OptimizedLike<PatternKind::kSubstring>>(
+          patternMetadata);
+    default:
+      return std::make_shared<LikeWithRe2>(pattern, escapeChar);
+  }
 }
 
 std::vector<std::shared_ptr<exec::FunctionSignature>> likeSignatures() {
@@ -1117,9 +2212,9 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> likeSignatures() {
   };
 }
 
-std::shared_ptr<VectorFunction> makeRe2ExtractAll(
+std::shared_ptr<exec::VectorFunction> makeRe2ExtractAll(
     const std::string& name,
-    const std::vector<VectorFunctionArg>& inputArgs,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/) {
   auto numArgs = inputArgs.size();
   VELOX_USER_CHECK(
@@ -1200,4 +2295,20 @@ re2ExtractAllSignatures() {
   };
 }
 
+std::shared_ptr<exec::VectorFunction> makeRegexpReplaceWithLambda(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  return std::make_shared<RegexpReplaceWithLambdaFunction>();
+}
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+regexpReplaceWithLambdaSignatures() {
+  return {exec::FunctionSignatureBuilder()
+              .returnType("varchar")
+              .argumentType("varchar")
+              .argumentType("varchar")
+              .argumentType("function(array(varchar), varchar)")
+              .build()};
+}
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Re2Functions.h b/velox/functions/lib/Re2Functions.h
index 3869c032d0a11..da65caefdc04e 100644
--- a/velox/functions/lib/Re2Functions.h
+++ b/velox/functions/lib/Re2Functions.h
@@ -30,20 +30,120 @@ namespace facebook::velox::functions {
 enum class PatternKind {
   /// Pattern containing wildcard character '_' only, such as _, __, ____.
   kExactlyN,
-  /// Pattern containing wildcard characters ('_' or '%') only with atleast one
+  /// Pattern containing wildcard characters ('_' or '%') only with at least one
   /// '%', such as ___%, _%__.
   kAtLeastN,
   /// Pattern with no wildcard characters, such as 'presto', 'foo'.
   kFixed,
+  /// Pattern with single wildcard chars(_) & normal chars, such as
+  /// '_pr_es_to_'.
+  kRelaxedFixed,
   /// Fixed pattern followed by one or more '%', such as 'hello%', 'foo%%%%'.
   kPrefix,
+  /// kRelaxedFixed pattern followed by one or more '%', such as '_pr_es_to_%',
+  /// '_pr_es_to_%%%%'.
+  kRelaxedPrefix,
   /// Fixed pattern preceded by one or more '%', such as '%foo', '%%%hello'.
   kSuffix,
+  /// kRelaxedFixed preceded by one or more '%', such as '%_pr_es_to_',
+  /// '%%%_pr_es_to_'.
+  kRelaxedSuffix,
+  /// Patterns matching '%{c0}%', such as '%foo%%', '%%%hello%'.
+  kSubstring,
   /// Patterns which do not fit any of the above types, such as 'hello_world',
   /// '_presto%'.
   kGeneric,
 };
 
+// Kind of sub-pattern.
+enum SubPatternKind {
+  /// e.g. '___'.
+  kSingleCharWildcard = 0,
+  // e.g. '%%'.
+  kAnyCharsWildcard = 1,
+  // e.g. 'abc'.
+  kLiteralString = 2
+};
+
+struct SubPatternMetadata {
+  SubPatternKind kind;
+  // The index of current pattern in terms of 'bytes'.
+  size_t start;
+  // Length in terms of bytes.
+  size_t length;
+};
+
+class PatternMetadata {
+ public:
+  static PatternMetadata generic();
+
+  static PatternMetadata atLeastN(size_t length);
+
+  static PatternMetadata exactlyN(size_t length);
+
+  static PatternMetadata fixed(const std::string& fixedPattern);
+
+  static PatternMetadata relaxedFixed(
+      std::string fixedPattern,
+      std::vector<SubPatternMetadata> subPatterns);
+
+  static PatternMetadata prefix(const std::string& fixedPattern);
+
+  static PatternMetadata relaxedPrefix(
+      std::string fixedPattern,
+      std::vector<SubPatternMetadata> subPatterns);
+
+  static PatternMetadata suffix(const std::string& fixedPattern);
+
+  static PatternMetadata relaxedSuffix(
+      std::string fixedPattern,
+      std::vector<SubPatternMetadata> subPatterns);
+
+  static PatternMetadata substring(const std::string& fixedPattern);
+
+  PatternKind patternKind() const {
+    return patternKind_;
+  }
+
+  size_t length() const {
+    return length_;
+  }
+
+  const std::vector<SubPatternMetadata>& subPatterns() const {
+    return subPatterns_;
+  }
+
+  const std::string& fixedPattern() const {
+    return fixedPattern_;
+  }
+
+ private:
+  PatternMetadata(
+      PatternKind patternKind,
+      size_t length,
+      std::string fixedPattern,
+      std::vector<SubPatternMetadata> subPatterns);
+
+  PatternKind patternKind_;
+
+  /// Contains the length of the unescaped fixed pattern for patterns of kind
+  /// k[Relaxed]Fixed, k[Relaxed]Prefix, k[Relaxed]Suffix and
+  /// k[Relaxed]Substring. Contains the count of wildcard character '_' for
+  /// patterns of kind kExactlyN and kAtLeastN. Contains 0 otherwise.
+  size_t length_;
+
+  /// Contains the fixed pattern in patterns of kind k[Relaxed]Fixed,
+  /// k[Relaxed]Prefix, k[Relaxed]Suffix and k[Relaxed]Substring.
+  std::string fixedPattern_;
+
+  /// Contains the literal/single char wildcard sub patterns, it is only
+  /// used for kRelaxedXxx patterns. e.g. If the pattern is: _pr_sto%, we will
+  /// have four sub-patterns here: _, pr, _ and sto.
+  std::vector<SubPatternMetadata> subPatterns_;
+};
+
+inline const int kMaxCompiledRegexes = 20;
+
 /// The functions in this file use RE2 as the regex engine. RE2 is fast, but
 /// supports only a subset of PCRE syntax and in particular does not support
 /// backtracking and associated features (e.g. backreferences).
@@ -102,7 +202,9 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> re2ExtractSignatures();
 /// prefix, and suffix patterns. Return the pair {pattern kind, number of '_'
 /// characters} for patterns with wildcard characters only. Return
 /// {kGenericPattern, 0} for generic patterns).
-std::pair<PatternKind, vector_size_t> determinePatternKind(StringView pattern);
+PatternMetadata determinePatternKind(
+    std::string_view pattern,
+    std::optional<char> escapeChar);
 
 std::shared_ptr<exec::VectorFunction> makeLike(
     const std::string& name,
@@ -135,6 +237,25 @@ std::shared_ptr<exec::VectorFunction> makeRe2ExtractAll(
 
 std::vector<std::shared_ptr<exec::FunctionSignature>> re2ExtractAllSignatures();
 
+namespace detail {
+
+// A cache of compiled regular expressions (RE2 instances). Allows up to
+// 'kMaxCompiledRegexes' different expressions.
+//
+// Compiling regular expressions is expensive. It can take up to 200 times
+// more CPU time to compile a regex vs. evaluate it.
+class ReCache {
+ public:
+  RE2* findOrCompile(const StringView& pattern);
+
+  Expected<RE2*> tryFindOrCompile(const StringView& pattern);
+
+ private:
+  folly::F14FastMap<std::string, std::unique_ptr<RE2>> cache_;
+};
+
+} // namespace detail
+
 /// regexp_replace(string, pattern, replacement) -> string
 /// regexp_replace(string, pattern) -> string
 ///
@@ -153,53 +274,152 @@ template <
 struct Re2RegexpReplace {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  std::string processedReplacement_;
-  std::string result_;
-  std::optional<RE2> re_;
-
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* /*string*/,
       const arg_type<Varchar>* pattern,
       const arg_type<Varchar>* replacement) {
-    VELOX_USER_CHECK(
-        pattern != nullptr, "Pattern of regexp_replace must be constant.");
-    VELOX_USER_CHECK(
-        replacement != nullptr,
-        "Replacement sequence of regexp_replace must be constant.");
-
-    auto processedPattern = prepareRegexpPattern(*pattern);
-
-    re_.emplace(processedPattern, RE2::Quiet);
-    if (UNLIKELY(!re_->ok())) {
-      VELOX_USER_FAIL(
-          "Invalid regular expression {}: {}.", processedPattern, re_->error());
+    if (pattern != nullptr) {
+      const auto processedPattern = prepareRegexpPattern(*pattern);
+      re_.emplace(processedPattern, RE2::Quiet);
+      VELOX_USER_CHECK(
+          re_->ok(),
+          "Invalid regular expression {}: {}.",
+          processedPattern,
+          re_->error());
     }
 
-    processedReplacement_ = prepareRegexpReplacement(*re_, *replacement);
+    if (replacement != nullptr) {
+      // Constant 'replacement' with non-constant 'pattern' needs to be
+      // processed separately for each row.
+      if (pattern != nullptr) {
+        ensureProcessedReplacement(re_.value(), *replacement);
+        constantReplacement_ = true;
+      }
+    }
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
       const arg_type<Varchar>* string,
       const arg_type<Varchar>* pattern) {
-    StringView emptyReplacement;
-
-    initialize(config, string, pattern, &emptyReplacement);
+    initialize(inputTypes, config, string, pattern, nullptr);
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& out,
       const arg_type<Varchar>& string,
-      const arg_type<Varchar>& /*pattern*/,
-      const arg_type<Varchar>& /*replacement*/ = StringView{}) {
+      const arg_type<Varchar>& pattern,
+      const arg_type<Varchar>& replacement = StringView{}) {
+    auto& re = ensurePattern(pattern);
+    const auto& processedReplacement =
+        ensureProcessedReplacement(re, replacement);
+
     result_.assign(string.data(), string.size());
-    RE2::GlobalReplace(&result_, *re_, processedReplacement_);
+    RE2::GlobalReplace(&result_, re, processedReplacement);
 
     UDFOutputString::assign(out, result_);
+  }
+
+ private:
+  RE2& ensurePattern(const arg_type<Varchar>& pattern) {
+    if (!re_.has_value()) {
+      auto processedPattern = prepareRegexpPattern(pattern);
+      return *cache_.findOrCompile(StringView(processedPattern));
+    } else {
+      return re_.value();
+    }
+  }
 
-    return true;
+  const std::string& ensureProcessedReplacement(
+      RE2& re,
+      const arg_type<Varchar>& replacement) {
+    if (!constantReplacement_) {
+      processedReplacement_ = prepareRegexpReplacement(re, replacement);
+    }
+
+    return processedReplacement_;
   }
+
+  // Used when pattern is constant.
+  std::optional<RE2> re_;
+
+  // True if replacement is constant.
+  bool constantReplacement_{false};
+
+  // Constant replacement if 'constantReplacement_' is true, or 'current'
+  // replacement.
+  std::string processedReplacement_;
+
+  // Used when pattern is not constant.
+  detail::ReCache cache_;
+
+  // Scratch memory to store result of replacement.
+  std::string result_;
 };
 
+template <typename TExec>
+struct Re2RegexpSplit {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  void call(
+      out_type<Array<Varchar>>& out,
+      const arg_type<Varchar>& string,
+      const arg_type<Varchar>& pattern) {
+    auto* re = cache_.findOrCompile(pattern);
+
+    const auto re2String = re2::StringPiece(string.data(), string.size());
+
+    size_t pos = 0;
+    const char* start = string.data();
+
+    re2::StringPiece subMatches[1];
+    while (re->Match(
+        re2String,
+        pos,
+        string.size(),
+        RE2::Anchor::UNANCHORED,
+        subMatches,
+        1)) {
+      const auto fullMatch = subMatches[0];
+      const auto offset = fullMatch.data() - start;
+      const auto size = fullMatch.size();
+
+      out.add_item().setNoCopy(StringView(string.data() + pos, offset - pos));
+
+      pos = offset + size;
+      if (UNLIKELY(size == 0)) {
+        ++pos;
+      }
+    }
+
+    out.add_item().setNoCopy(
+        StringView(string.data() + pos, string.size() - pos));
+  }
+
+ private:
+  detail::ReCache cache_;
+};
+
+std::shared_ptr<exec::VectorFunction> makeRegexpReplaceWithLambda(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+regexpReplaceWithLambdaSignatures();
+
 } // namespace facebook::velox::functions
+
+template <>
+struct fmt::formatter<facebook::velox::functions::PatternKind>
+    : formatter<int> {
+  auto format(facebook::velox::functions::PatternKind s, format_context& ctx)
+      const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/functions/lib/RegistrationHelpers.h b/velox/functions/lib/RegistrationHelpers.h
index 1251eca5b4571..3b7f55c55b7b2 100644
--- a/velox/functions/lib/RegistrationHelpers.h
+++ b/velox/functions/lib/RegistrationHelpers.h
@@ -16,7 +16,6 @@
 #pragma once
 
 #include "velox/functions/Registerer.h"
-#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
 namespace facebook::velox::functions {
 namespace {
@@ -56,17 +55,6 @@ void registerBinaryScalar(const std::vector<std::string>& aliases) {
   registerFunction<T, TReturn, Date, Date>(aliases);
 }
 
-template <template <class> class T, typename TReturn>
-void registerNonSimdizableScalar(const std::vector<std::string>& aliases) {
-  registerFunction<T, TReturn, Varchar, Varchar>(aliases);
-  registerFunction<T, TReturn, Varbinary, Varbinary>(aliases);
-  registerFunction<T, TReturn, bool, bool>(aliases);
-  registerFunction<T, TReturn, Timestamp, Timestamp>(aliases);
-  registerFunction<T, TReturn, Date, Date>(aliases);
-  registerFunction<T, TReturn, TimestampWithTimezone, TimestampWithTimezone>(
-      aliases);
-}
-
 template <template <class> class T>
 void registerUnaryIntegral(const std::vector<std::string>& aliases) {
   registerFunction<T, int8_t, int8_t>(aliases);
@@ -75,6 +63,14 @@ void registerUnaryIntegral(const std::vector<std::string>& aliases) {
   registerFunction<T, int64_t, int64_t>(aliases);
 }
 
+template <template <class> class T, typename TReturn>
+void registerUnaryIntegralWithTReturn(const std::vector<std::string>& aliases) {
+  registerFunction<T, TReturn, int8_t>(aliases);
+  registerFunction<T, TReturn, int16_t>(aliases);
+  registerFunction<T, TReturn, int32_t>(aliases);
+  registerFunction<T, TReturn, int64_t>(aliases);
+}
+
 template <template <class> class T>
 void registerUnaryFloatingPoint(const std::vector<std::string>& aliases) {
   registerFunction<T, double, double>(aliases);
diff --git a/velox/functions/lib/Repeat.cpp b/velox/functions/lib/Repeat.cpp
new file mode 100644
index 0000000000000..fc02f4ad0d95a
--- /dev/null
+++ b/velox/functions/lib/Repeat.cpp
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/DecodedArgs.h"
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::functions {
+namespace {
+// See documentation at https://prestodb.io/docs/current/functions/array.html
+class RepeatFunction : public exec::VectorFunction {
+ public:
+  // @param allowNegativeCount If true, negative 'count' is allowed
+  // and treated the same as zero (Spark's behavior).
+  explicit RepeatFunction(bool allowNegativeCount)
+      : allowNegativeCount_(allowNegativeCount) {}
+
+  static constexpr int32_t kMaxResultEntries = 10'000;
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VectorPtr localResult;
+    if (args[1]->isConstantEncoding()) {
+      localResult = applyConstantCount(rows, args, outputType, context);
+      if (localResult == nullptr) {
+        return;
+      }
+    } else {
+      localResult = applyNonConstantCount(rows, args, outputType, context);
+    }
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+ private:
+  // Check count to make sure it is in valid range.
+  static int32_t checkCount(int32_t count, bool allowNegativeCount) {
+    if (count < 0) {
+      if (allowNegativeCount) {
+        return 0;
+      }
+      VELOX_USER_FAIL(
+          "({} vs. {}) Count argument of repeat function must be greater than or equal to 0",
+          count,
+          0);
+    }
+    VELOX_USER_CHECK_LE(
+        count,
+        kMaxResultEntries,
+        "Count argument of repeat function must be less than or equal to 10000");
+    return count;
+  }
+
+  VectorPtr applyConstantCount(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context) const {
+    const auto numRows = rows.end();
+    auto pool = context.pool();
+
+    auto* constantCount = args[1]->as<ConstantVector<int32_t>>();
+    if (constantCount->isNullAt(0)) {
+      // If count is a null constant, the result should be all nulls.
+      return BaseVector::createNullConstant(outputType, numRows, pool);
+    }
+
+    auto count = constantCount->valueAt(0);
+    try {
+      count = checkCount(count, allowNegativeCount_);
+    } catch (const VeloxUserError&) {
+      context.setErrors(rows, std::current_exception());
+      return nullptr;
+    }
+    const auto totalCount = count * numRows;
+
+    // Allocate new vectors for indices, lengths and offsets.
+    BufferPtr indices = allocateIndices(totalCount, pool);
+    BufferPtr sizes = allocateSizes(numRows, pool);
+    BufferPtr offsets = allocateOffsets(numRows, pool);
+    auto rawIndices = indices->asMutable<vector_size_t>();
+    auto rawSizes = sizes->asMutable<vector_size_t>();
+    auto rawOffsets = offsets->asMutable<vector_size_t>();
+
+    vector_size_t offset = 0;
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      rawSizes[row] = count;
+      rawOffsets[row] = offset;
+      std::fill(rawIndices + offset, rawIndices + offset + count, row);
+      offset += count;
+    });
+
+    return std::make_shared<ArrayVector>(
+        pool,
+        outputType,
+        nullptr,
+        numRows,
+        offsets,
+        sizes,
+        BaseVector::wrapInDictionary(nullptr, indices, totalCount, args[0]));
+  }
+
+  VectorPtr applyNonConstantCount(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context) const {
+    exec::DecodedArgs decodedArgs(rows, args, context);
+    auto countDecoded = decodedArgs.at(1);
+    int32_t totalCount = 0;
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      auto count =
+          countDecoded->isNullAt(row) ? 0 : countDecoded->valueAt<int32_t>(row);
+      count = checkCount(count, allowNegativeCount_);
+      totalCount += count;
+    });
+
+    const auto numRows = rows.end();
+    auto pool = context.pool();
+
+    // Allocate new vector for nulls if necessary.
+    BufferPtr nulls;
+    uint64_t* rawNulls = nullptr;
+    if (countDecoded->mayHaveNulls()) {
+      nulls = allocateNulls(numRows, pool);
+      rawNulls = nulls->asMutable<uint64_t>();
+    }
+
+    // Allocate new vectors for indices, lengths and offsets.
+    BufferPtr indices = allocateIndices(totalCount, pool);
+    BufferPtr sizes = allocateSizes(numRows, pool);
+    BufferPtr offsets = allocateOffsets(numRows, pool);
+    auto rawIndices = indices->asMutable<vector_size_t>();
+    auto rawSizes = sizes->asMutable<vector_size_t>();
+    auto rawOffsets = offsets->asMutable<vector_size_t>();
+
+    // When context.throwOnError is false, rows with invalid count argument
+    // should be deselected and not be processed further.
+    SelectivityVector remainingRows = rows;
+    context.deselectErrors(remainingRows);
+    vector_size_t offset = 0;
+    context.applyToSelectedNoThrow(remainingRows, [&](auto row) {
+      if (rawNulls && countDecoded->isNullAt(row)) {
+        // Returns null if count argument is null.
+        // e.g. repeat('a', null) -> null
+        bits::setNull(rawNulls, row);
+        return;
+      }
+      auto count = countDecoded->valueAt<int32_t>(row);
+      if (count < 0) {
+        count = 0;
+      }
+      rawSizes[row] = count;
+      rawOffsets[row] = offset;
+      std::fill(rawIndices + offset, rawIndices + offset + count, row);
+      offset += count;
+    });
+
+    return std::make_shared<ArrayVector>(
+        pool,
+        outputType,
+        nulls,
+        numRows,
+        offsets,
+        sizes,
+        BaseVector::wrapInDictionary(nullptr, indices, totalCount, args[0]));
+  }
+
+  const bool allowNegativeCount_;
+};
+} // namespace
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> repeatSignatures() {
+  // T, integer -> array(T)
+  return {exec::FunctionSignatureBuilder()
+              .typeVariable("T")
+              .returnType("array(T)")
+              .argumentType("T")
+              .argumentType("integer")
+              .build()};
+}
+
+exec::VectorFunctionMetadata repeatMetadata() {
+  // repeat(null, n) returns an array of n nulls.
+  return exec::VectorFunctionMetadataBuilder()
+      .defaultNullBehavior(false)
+      .build();
+}
+
+std::shared_ptr<exec::VectorFunction> makeRepeat(
+    const std::string& /* name */,
+    const std::vector<exec::VectorFunctionArg>& /* inputArgs */,
+    const core::QueryConfig& /*config*/) {
+  return std::make_unique<RepeatFunction>(false);
+}
+
+std::shared_ptr<exec::VectorFunction> makeRepeatAllowNegativeCount(
+    const std::string& /* name */,
+    const std::vector<exec::VectorFunctionArg>& /* inputArgs */,
+    const core::QueryConfig& /*config*/) {
+  return std::make_unique<RepeatFunction>(true);
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Repeat.h b/velox/functions/lib/Repeat.h
new file mode 100644
index 0000000000000..2a6d3539aba0b
--- /dev/null
+++ b/velox/functions/lib/Repeat.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <vector>
+
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::functions {
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> repeatSignatures();
+
+exec::VectorFunctionMetadata repeatMetadata();
+
+// Does not allow negative count.
+std::shared_ptr<exec::VectorFunction> makeRepeat(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
+
+// Allows negative count (Spark's behavior).
+std::shared_ptr<exec::VectorFunction> makeRepeatAllowNegativeCount(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/RowsTranslationUtil.h b/velox/functions/lib/RowsTranslationUtil.h
index bd374bb9529b2..97185203ba28c 100644
--- a/velox/functions/lib/RowsTranslationUtil.h
+++ b/velox/functions/lib/RowsTranslationUtil.h
@@ -22,26 +22,40 @@
 
 namespace facebook::velox::functions {
 
-/// Returns SelectivityVector for the nested vector with all rows corresponding
-/// to specified top-level rows selected. The optional topLevelRowMapping is
-/// used to pass the dictionary indices if the topLevelVector is dictionary
-/// encoded.
+/// This function returns a SelectivityVector for ARRAY/MAP vectors that selects
+/// all rows corresponding to the specified rows. If the base vector was
+/// dictionary encoded, an optional rowMapping parameter can be used to pass
+/// the dictionary indices. In this case, it is important to ensure that the
+/// topLevelRows parameter has already filtered out any null rows added by the
+/// dictionary encoding.
 template <typename T>
 SelectivityVector toElementRows(
     vector_size_t size,
-    const SelectivityVector& topLevelRows,
-    const T* topLevelVector,
-    const vector_size_t* topLevelRowMapping = nullptr) {
-  auto rawNulls = topLevelVector->rawNulls();
-  auto rawSizes = topLevelVector->rawSizes();
-  auto rawOffsets = topLevelVector->rawOffsets();
+    const SelectivityVector& topLevelNonNullRows,
+    const T* arrayBaseVector,
+    const vector_size_t* rowMapping = nullptr) {
+  VELOX_CHECK(
+      arrayBaseVector->encoding() == VectorEncoding::Simple::MAP ||
+      arrayBaseVector->encoding() == VectorEncoding::Simple::ARRAY);
+
+  auto rawNulls = arrayBaseVector->rawNulls();
+  auto rawSizes = arrayBaseVector->rawSizes();
+  auto rawOffsets = arrayBaseVector->rawOffsets();
+  const auto sizeRange =
+      arrayBaseVector->sizes()->template asRange<vector_size_t>().end();
+  const auto offsetRange =
+      arrayBaseVector->offsets()->template asRange<vector_size_t>().end();
 
   SelectivityVector elementRows(size, false);
-  topLevelRows.applyToSelected([&](vector_size_t row) {
-    auto index = topLevelRowMapping ? topLevelRowMapping[row] : row;
+  topLevelNonNullRows.applyToSelected([&](vector_size_t row) {
+    auto index = rowMapping ? rowMapping[row] : row;
     if (rawNulls && bits::isBitNull(rawNulls, index)) {
       return;
     }
+
+    VELOX_DCHECK_LE(index, sizeRange);
+    VELOX_DCHECK_LE(index, offsetRange);
+
     auto size = rawSizes[index];
     auto offset = rawOffsets[index];
     elementRows.setValidRange(offset, offset + size, true);
diff --git a/velox/functions/lib/SIMDComparisonUtil.h b/velox/functions/lib/SIMDComparisonUtil.h
new file mode 100644
index 0000000000000..a27b51f192bf7
--- /dev/null
+++ b/velox/functions/lib/SIMDComparisonUtil.h
@@ -0,0 +1,364 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::functions {
+
+namespace detail {
+
+template <typename T, bool kIsConstant>
+inline auto loadSimdData(const T* rawData, vector_size_t offset) {
+  using d_type = xsimd::batch<T>;
+  if constexpr (kIsConstant) {
+    return xsimd::broadcast<T>(rawData[0]);
+  }
+  return d_type::load_unaligned(rawData + offset);
+}
+
+inline uint64_t to64Bits(const int8_t* resultData) {
+  using d_type = xsimd::batch<int8_t>;
+  constexpr auto numScalarElements = d_type::size;
+  static_assert(
+      numScalarElements == 16 || numScalarElements == 32 ||
+          numScalarElements == 64,
+      "Unsupported number of scalar elements");
+  uint64_t res = 0UL;
+  if constexpr (numScalarElements == 64) {
+    res = simd::toBitMask(xsimd::batch_bool<int8_t>(
+        simd::reinterpretBatch<uint8_t>(d_type::load_unaligned(resultData))));
+  } else if constexpr (numScalarElements == 32) {
+    auto* addr = reinterpret_cast<uint32_t*>(&res);
+    *(addr) = simd::toBitMask(xsimd::batch_bool<int8_t>(
+        simd::reinterpretBatch<uint8_t>(d_type::load_unaligned(resultData))));
+    *(addr + 1) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(simd::reinterpretBatch<uint8_t>(
+            d_type::load_unaligned(resultData + 32))));
+  } else if constexpr (numScalarElements == 16) {
+    auto* addr = reinterpret_cast<uint16_t*>(&res);
+    *(addr) = simd::toBitMask(xsimd::batch_bool<int8_t>(
+        simd::reinterpretBatch<uint8_t>(d_type::load_unaligned(resultData))));
+    *(addr + 1) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(simd::reinterpretBatch<uint8_t>(
+            d_type::load_unaligned(resultData + 16))));
+    *(addr + 2) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(simd::reinterpretBatch<uint8_t>(
+            d_type::load_unaligned(resultData + 32))));
+    *(addr + 3) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(simd::reinterpretBatch<uint8_t>(
+            d_type::load_unaligned(resultData + 48))));
+  }
+  return res;
+}
+
+template <typename A, typename B, typename Compare>
+void applyAutoSimdComparisonInternal(
+    const SelectivityVector& rows,
+    const A* __restrict rawA,
+    const B* __restrict rawB,
+    Compare cmp,
+    VectorPtr& result) {
+  int8_t tempBuffer[64];
+  int8_t* __restrict resultData = tempBuffer;
+  const vector_size_t rowsBegin = rows.begin();
+  const vector_size_t rowsEnd = rows.end();
+  auto* rowsData = reinterpret_cast<const uint64_t*>(rows.allBits());
+  auto* resultVector = result->asUnchecked<FlatVector<bool>>();
+  auto* rawResult = resultVector->mutableRawValues<uint64_t>();
+  if (rows.isAllSelected()) {
+    auto i = 0;
+    for (; i + 64 <= rowsEnd; i += 64) {
+      for (auto j = 0; j < 64; ++j) {
+        resultData[j] = cmp(rawA, rawB, i + j) ? -1 : 0;
+      }
+      rawResult[i / 64] = to64Bits(resultData);
+    }
+    for (; i < rowsEnd; ++i) {
+      bits::setBit(rawResult, i, cmp(rawA, rawB, i));
+    }
+  } else {
+    static constexpr uint64_t kAllSet = -1ULL;
+    bits::forEachWord(
+        rowsBegin,
+        rowsEnd,
+        [&](int32_t idx, uint64_t mask) {
+          auto word = rowsData[idx] & mask;
+          if (!word) {
+            return;
+          }
+          const size_t start = idx * 64;
+          while (word) {
+            auto index = start + __builtin_ctzll(word);
+            bits::setBit(rawResult, index, cmp(rawA, rawB, index));
+            word &= word - 1;
+          }
+        },
+        [&](int32_t idx) {
+          auto word = rowsData[idx];
+          const size_t start = idx * 64;
+          if (kAllSet == word) {
+            // Do 64 comparisons in a batch, set results by SIMD.
+            for (size_t row = 0; row < 64; ++row) {
+              resultData[row] = cmp(rawA, rawB, row + start) ? -1 : 0;
+            }
+            rawResult[idx] = to64Bits(resultData);
+          } else {
+            while (word) {
+              auto index = __builtin_ctzll(word);
+              resultData[index] = cmp(rawA, rawB, start + index) ? -1 : 0;
+              word &= word - 1;
+            }
+            // Set results only for selected rows.
+            uint64_t mask = rowsData[idx];
+            rawResult[idx] =
+                (rawResult[idx] & ~mask) | (to64Bits(resultData) & mask);
+          }
+        });
+  }
+}
+
+inline bool isDictEncoding(const VectorPtr& arg) {
+  return arg->encoding() == VectorEncoding::Simple::DICTIONARY;
+}
+} // namespace detail
+
+template <
+    typename T,
+    bool kIsLeftConstant,
+    bool kIsRightConstant,
+    typename ComparisonOp>
+void applySimdComparison(
+    const vector_size_t begin,
+    const vector_size_t end,
+    const T* rawLhs,
+    const T* rawRhs,
+    uint8_t* rawResult) {
+  using d_type = xsimd::batch<T>;
+  constexpr auto numScalarElements = d_type::size;
+  const auto vectorEnd = (end - begin) - (end - begin) % numScalarElements;
+  static_assert(
+      numScalarElements == 2 || numScalarElements == 4 ||
+          numScalarElements == 8 || numScalarElements == 16 ||
+          numScalarElements == 32,
+      "Unsupported number of scalar elements");
+  if constexpr (numScalarElements == 2 || numScalarElements == 4) {
+    for (auto i = begin; i < vectorEnd; i += 8) {
+      rawResult[i / 8] = 0;
+      for (auto j = 0; j < 8 && (i + j) < vectorEnd; j += numScalarElements) {
+        auto left = detail::loadSimdData<T, kIsLeftConstant>(rawLhs, i + j);
+        auto right = detail::loadSimdData<T, kIsRightConstant>(rawRhs, i + j);
+
+        uint8_t res = simd::toBitMask(ComparisonOp()(left, right));
+        rawResult[i / 8] |= res << j;
+      }
+    }
+  } else {
+    for (auto i = begin; i < vectorEnd; i += numScalarElements) {
+      auto left = detail::loadSimdData<T, kIsLeftConstant>(rawLhs, i);
+      auto right = detail::loadSimdData<T, kIsRightConstant>(rawRhs, i);
+
+      auto res = simd::toBitMask(ComparisonOp()(left, right));
+      if constexpr (numScalarElements == 8) {
+        rawResult[i / 8] = res;
+      } else if constexpr (numScalarElements == 16) {
+        uint16_t* addr = reinterpret_cast<uint16_t*>(rawResult + i / 8);
+        *addr = res;
+      } else if constexpr (numScalarElements == 32) {
+        uint32_t* addr = reinterpret_cast<uint32_t*>(rawResult + i / 8);
+        *addr = res;
+      }
+    }
+  }
+
+  // Evaluate remaining values.
+  for (auto i = vectorEnd; i < end; i++) {
+    if constexpr (kIsRightConstant && kIsLeftConstant) {
+      bits::setBit(rawResult, i, ComparisonOp()(rawLhs[0], rawRhs[0]));
+    } else if constexpr (kIsRightConstant) {
+      bits::setBit(rawResult, i, ComparisonOp()(rawLhs[i], rawRhs[0]));
+    } else if constexpr (kIsLeftConstant) {
+      bits::setBit(rawResult, i, ComparisonOp()(rawLhs[0], rawRhs[i]));
+    } else {
+      bits::setBit(rawResult, i, ComparisonOp()(rawLhs[i], rawRhs[i]));
+    }
+  }
+}
+
+template <typename T, typename ComparisonOp>
+void applySimdComparison(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    VectorPtr& result) {
+  auto resultVector = result->asUnchecked<FlatVector<bool>>();
+  auto rawResult = resultVector->mutableRawValues<uint8_t>();
+  if (args[0]->isConstantEncoding() && args[1]->isConstantEncoding()) {
+    auto l = args[0]->asUnchecked<ConstantVector<T>>()->valueAt(0);
+    auto r = args[1]->asUnchecked<ConstantVector<T>>()->valueAt(0);
+    applySimdComparison<T, true, true, ComparisonOp>(
+        rows.begin(), rows.end(), &l, &r, rawResult);
+  } else if (args[0]->isConstantEncoding()) {
+    auto l = args[0]->asUnchecked<ConstantVector<T>>()->valueAt(0);
+    auto rawRhs = args[1]->asUnchecked<FlatVector<T>>()->rawValues();
+    applySimdComparison<T, true, false, ComparisonOp>(
+        rows.begin(), rows.end(), &l, rawRhs, rawResult);
+  } else if (args[1]->isConstantEncoding()) {
+    auto rawLhs = args[0]->asUnchecked<FlatVector<T>>()->rawValues();
+    auto r = args[1]->asUnchecked<ConstantVector<T>>()->valueAt(0);
+    applySimdComparison<T, false, true, ComparisonOp>(
+        rows.begin(), rows.end(), rawLhs, &r, rawResult);
+  } else {
+    auto rawLhs = args[0]->asUnchecked<FlatVector<T>>()->rawValues();
+    auto rawRhs = args[1]->asUnchecked<FlatVector<T>>()->rawValues();
+    applySimdComparison<T, false, false, ComparisonOp>(
+        rows.begin(), rows.end(), rawLhs, rawRhs, rawResult);
+  }
+}
+
+template <typename A, typename B, typename Compare, typename... Args>
+void applyAutoSimdComparison(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    exec::EvalCtx& context,
+    VectorPtr& result,
+    Args... cmpArgs) {
+  const Compare cmp;
+  if (args[0]->isFlatEncoding() && args[1]->isFlatEncoding()) {
+    const A* __restrict rawA =
+        args[0]->asUnchecked<FlatVector<A>>()->template rawValues<A>();
+    const B* __restrict rawB =
+        args[1]->asUnchecked<FlatVector<B>>()->template rawValues<B>();
+    detail::applyAutoSimdComparisonInternal(
+        rows,
+        rawA,
+        rawB,
+        [&](const A* __restrict rawA, const B* __restrict rawB, int i) {
+          if constexpr (sizeof...(cmpArgs) > 0) {
+            return Compare::apply(rawA[i], rawB[i], cmpArgs...);
+          } else {
+            return cmp(rawA[i], rawB[i]);
+          }
+        },
+        result);
+  } else if (args[0]->isConstantEncoding() && args[1]->isFlatEncoding()) {
+    const A constA = args[0]->asUnchecked<ConstantVector<A>>()->valueAt(0);
+    const A* __restrict rawA = &constA;
+    const B* __restrict rawB =
+        args[1]->asUnchecked<FlatVector<B>>()->template rawValues<B>();
+    detail::applyAutoSimdComparisonInternal(
+        rows,
+        rawA,
+        rawB,
+        [&](const A* __restrict rawA, const B* __restrict rawB, int i) {
+          if constexpr (sizeof...(cmpArgs) > 0) {
+            return Compare::apply(rawA[0], rawB[i], cmpArgs...);
+          } else {
+            return cmp(rawA[0], rawB[i]);
+          }
+        },
+        result);
+  } else if (args[0]->isFlatEncoding() && args[1]->isConstantEncoding()) {
+    const A* __restrict rawA =
+        args[0]->asUnchecked<FlatVector<A>>()->template rawValues<A>();
+    const B constB = args[1]->asUnchecked<ConstantVector<B>>()->valueAt(0);
+    const B* __restrict rawB = &constB;
+    detail::applyAutoSimdComparisonInternal(
+        rows,
+        rawA,
+        rawB,
+        [&](const A* __restrict rawA, const B* __restrict rawB, int i) {
+          if constexpr (sizeof...(cmpArgs) > 0) {
+            return Compare::apply(rawA[i], rawB[0], cmpArgs...);
+          } else {
+            return cmp(rawA[i], rawB[0]);
+          }
+        },
+        result);
+  } else if (args[0]->isConstantEncoding() && args[1]->isConstantEncoding()) {
+    const A constA = args[0]->asUnchecked<ConstantVector<A>>()->valueAt(0);
+    const A* __restrict rawA = &constA;
+    const B constB = args[1]->asUnchecked<ConstantVector<B>>()->valueAt(0);
+    const B* __restrict rawB = &constB;
+    detail::applyAutoSimdComparisonInternal(
+        rows,
+        rawA,
+        rawB,
+        [&](const A* __restrict rawA, const B* __restrict rawB, int i) {
+          if constexpr (sizeof...(cmpArgs) > 0) {
+            return Compare::apply(rawA[0], rawB[0], cmpArgs...);
+          } else {
+            return cmp(rawA[0], rawB[0]);
+          }
+        },
+        result);
+  } else if (args[0]->isFlatEncoding() && detail::isDictEncoding(args[1])) {
+    const A* __restrict rawA =
+        args[0]->asUnchecked<FlatVector<A>>()->rawValues();
+    exec::LocalDecodedVector localBDecoded(context, *args[1], rows);
+    const B* __restrict rawB = localBDecoded.get()->data<B>();
+    const vector_size_t* __restrict indexB = localBDecoded.get()->indices();
+    detail::applyAutoSimdComparisonInternal(
+        rows,
+        rawA,
+        rawB,
+        [&](const A* __restrict rawA, const B* __restrict rawB, int i) {
+          if constexpr (sizeof...(cmpArgs) > 0) {
+            return Compare::apply(rawA[i], rawB[indexB[i]], cmpArgs...);
+          } else {
+            return cmp(rawA[i], rawB[indexB[i]]);
+          }
+        },
+        result);
+  } else if (detail::isDictEncoding(args[0]) && args[1]->isFlatEncoding()) {
+    exec::LocalDecodedVector localADecoded(context, *args[0], rows);
+    const A* __restrict rawA = localADecoded.get()->data<A>();
+    const vector_size_t* __restrict indexA = localADecoded.get()->indices();
+    const B* __restrict rawB =
+        args[1]->asUnchecked<FlatVector<B>>()->rawValues();
+    detail::applyAutoSimdComparisonInternal(
+        rows,
+        rawA,
+        rawB,
+        [&](const A* __restrict rawA, const B* __restrict rawB, int i) {
+          if constexpr (sizeof...(cmpArgs) > 0) {
+            return Compare::apply(rawA[indexA[i]], rawB[i], cmpArgs...);
+          } else {
+            return cmp(rawA[indexA[i]], rawB[i]);
+          }
+        },
+        result);
+  } else {
+    VELOX_UNREACHABLE();
+  }
+}
+
+template <typename A, typename B>
+bool shouldApplyAutoSimdComparison(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args) {
+  if (rows.end() - rows.begin() > 64) {
+    if ((args[0]->isFlatEncoding() || args[0]->isConstantEncoding()) &&
+        (args[1]->isFlatEncoding() || args[1]->isConstantEncoding())) {
+      return true;
+    } else if (args[0]->isFlatEncoding() && detail::isDictEncoding(args[1])) {
+      return true;
+    } else if (detail::isDictEncoding(args[0]) && args[1]->isFlatEncoding()) {
+      return true;
+    }
+  }
+  return false;
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Slice.cpp b/velox/functions/lib/Slice.cpp
similarity index 81%
rename from velox/functions/prestosql/Slice.cpp
rename to velox/functions/lib/Slice.cpp
index 896d73b85b215..0067a21ff6e37 100644
--- a/velox/functions/prestosql/Slice.cpp
+++ b/velox/functions/lib/Slice.cpp
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
+#include "velox/functions/lib/Slice.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
-#include "velox/type/Type.h"
 
 namespace facebook::velox::functions {
 namespace {
@@ -50,6 +50,13 @@ namespace {
 /// rawSizes vector   [2, 2, 2]
 class SliceFunction : public exec::VectorFunction {
  public:
+  SliceFunction(TypeKind kind) : kind_(kind) {
+    VELOX_CHECK(
+        kind == TypeKind::BIGINT || kind == TypeKind::INTEGER,
+        "Unsupported parameter type {} to register slice function",
+        mapTypeKindToName(kind));
+  }
+
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -62,8 +69,9 @@ class SliceFunction : public exec::VectorFunction {
         "Function slice() requires first argument of type ARRAY");
     VELOX_USER_CHECK_EQ(
         args[1]->typeKind(),
-        TypeKind::BIGINT,
-        "Function slice() requires second argument of type BIGINT");
+        kind_,
+        "Function slice() requires second argument of type {}",
+        mapTypeKindToName(kind_));
     VELOX_USER_CHECK_EQ(
         args[1]->typeKind(),
         args[2]->typeKind(),
@@ -77,12 +85,15 @@ class SliceFunction : public exec::VectorFunction {
       BaseVector::flattenVector(args[0]);
     }
 
-    VectorPtr localResult =
-        applyArray<int64_t>(rows, args, context, outputType);
+    VectorPtr localResult = kind_ == TypeKind::INTEGER
+        ? applyArray<int32_t>(rows, args, context, outputType)
+        : applyArray<int64_t>(rows, args, context, outputType);
     context.moveOrCopyResult(localResult, rows, result);
   }
 
  private:
+  // The type kind of start and length.
+  TypeKind kind_;
   // Use template parameter rather than hard-coded TypeKind to specify array
   // data type.
   template <typename T>
@@ -201,21 +212,29 @@ class SliceFunction : public exec::VectorFunction {
   }
 };
 
-static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-  return {// array(T, bigint, bigint) -> array(T)
-          exec::FunctionSignatureBuilder()
-              .typeVariable("T")
-              .returnType("array(T)")
-              .argumentType("array(T)")
-              .argumentType("bigint")
-              .argumentType("bigint")
-              .build()};
+// @param kind The type kind of start and length.
+void registerSliceFunction(const std::string& prefix, TypeKind kind) {
+  auto kindName = exec::sanitizeName(mapTypeKindToName(kind));
+
+  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("array(T)")
+          .argumentType("array(T)")
+          .argumentType(kindName)
+          .argumentType(kindName)
+          .build()};
+  exec::registerVectorFunction(
+      prefix + "slice", signatures, std::make_unique<SliceFunction>(kind));
 }
-
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_slice,
-    signatures(),
-    std::make_unique<SliceFunction>());
+void registerBigintSliceFunction(const std::string& prefix) {
+  registerSliceFunction(prefix, TypeKind::BIGINT);
+}
+
+void registerIntegerSliceFunction(const std::string& prefix) {
+  registerSliceFunction(prefix, TypeKind::INTEGER);
+}
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Slice.h b/velox/functions/lib/Slice.h
new file mode 100644
index 0000000000000..041e07dbeaab7
--- /dev/null
+++ b/velox/functions/lib/Slice.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions {
+
+// BIGINT type for start and length (Presto's behavior).
+void registerBigintSliceFunction(const std::string& prefix);
+
+// INTEGER type for start and length (Spark's behavior).
+void registerIntegerSliceFunction(const std::string& prefix);
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/StringEncodingUtils.cpp b/velox/functions/lib/StringEncodingUtils.cpp
index 4f3856d5067e5..1c09d57cb2a0f 100644
--- a/velox/functions/lib/StringEncodingUtils.cpp
+++ b/velox/functions/lib/StringEncodingUtils.cpp
@@ -35,23 +35,36 @@ bool prepareFlatResultsVector(
     VectorPtr& result,
     const SelectivityVector& rows,
     exec::EvalCtx& context,
-    VectorPtr& argToReuse) {
+    VectorPtr& argToReuse,
+    const TypePtr& resultType) {
+  VELOX_CHECK(resultType->isVarbinary() || resultType->isVarchar());
+
   if (!result && BaseVector::isVectorWritable(argToReuse) &&
       argToReuse->isFlatEncoding() &&
       hasSingleReferencedBuffers(*argToReuse->asFlatVector<StringView>())) {
     // Move input vector to result
     VELOX_CHECK(
         VectorEncoding::isFlat(argToReuse.get()->encoding()) &&
-        argToReuse.get()->typeKind() == TypeKind::VARCHAR);
+        argToReuse.get()->typeKind() == resultType->kind());
 
     result = std::move(argToReuse);
     return true;
   }
   // This will allocate results if not allocated
-  BaseVector::ensureWritable(rows, VARCHAR(), context.pool(), result);
+  BaseVector::ensureWritable(rows, resultType, context.pool(), result);
 
   VELOX_CHECK(VectorEncoding::isFlat(result->encoding()));
   return false;
 }
 
+/// Return the string encoding of a vector, if not set UTF8 is returned
+bool isAscii(BaseVector* vector, const SelectivityVector& rows) {
+  if (auto simpleVector = vector->template as<SimpleVector<StringView>>()) {
+    auto ascii = simpleVector->isAscii(rows);
+    return ascii.has_value() && ascii.value();
+  }
+  VELOX_UNREACHABLE();
+  return false;
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/StringEncodingUtils.h b/velox/functions/lib/StringEncodingUtils.h
index eeacd155d5fe5..f11de8ffe9362 100644
--- a/velox/functions/lib/StringEncodingUtils.h
+++ b/velox/functions/lib/StringEncodingUtils.h
@@ -24,21 +24,17 @@ namespace facebook::velox::functions {
 /// Helper function that prepares a string result vector and initializes it.
 /// It will use the input argToReuse vector instead of creating new one when
 /// possible. Returns true if argToReuse vector was moved to results
+///
+/// @param resultType VARCHAR() or VARBINARY().
 bool prepareFlatResultsVector(
     VectorPtr& result,
     const SelectivityVector& rows,
     exec::EvalCtx& context,
-    VectorPtr& argToReuse);
+    VectorPtr& argToReuse,
+    const TypePtr& resultType = VARCHAR());
 
 /// Return the string encoding of a vector, if not set UTF8 is returned
-static bool isAscii(BaseVector* vector, const SelectivityVector& rows) {
-  if (auto simpleVector = vector->template as<SimpleVector<StringView>>()) {
-    auto ascii = simpleVector->isAscii(rows);
-    return ascii.has_value() && ascii.value();
-  }
-  VELOX_UNREACHABLE();
-  return false;
-};
+bool isAscii(BaseVector* vector, const SelectivityVector& rows);
 
 /// Wrap an input function with the appropriate ascii instantiation.
 /// Func is a struct templated on boolean with a static function
diff --git a/velox/functions/lib/SubscriptUtil.cpp b/velox/functions/lib/SubscriptUtil.cpp
index 0c37a76813192..51931384855f3 100644
--- a/velox/functions/lib/SubscriptUtil.cpp
+++ b/velox/functions/lib/SubscriptUtil.cpp
@@ -14,15 +14,326 @@
  * limitations under the License.
  */
 
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "velox/common/memory/MemoryPool.h"
 #include "velox/functions/lib/SubscriptUtil.h"
+#include "velox/type/Type.h"
+#include "velox/vector/TypeAliases.h"
 
 namespace facebook::velox::functions {
 
+namespace {
+
+template <typename T>
+inline bool isPrimitiveEqual(const T& lhs, const T& rhs) {
+  if constexpr (std::is_floating_point_v<T>) {
+    return util::floating_point::NaNAwareEquals<T>{}(lhs, rhs);
+  } else {
+    return lhs == rhs;
+  }
+}
+
+template <TypeKind Kind>
+struct SimpleType {
+  using type = typename TypeTraits<Kind>::NativeType;
+};
+
+template <>
+struct SimpleType<TypeKind::VARBINARY> {
+  using type = Varbinary;
+};
+
+template <>
+struct SimpleType<TypeKind::VARCHAR> {
+  using type = Varchar;
+};
+
+/// Decode arguments and transform result into a dictionaryVector where the
+/// dictionary maintains a mapping from a given row to the index of the input
+/// map value vector. This allows us to ensure that element_at is zero-copy.
+template <TypeKind kind>
+VectorPtr applyMapTyped(
+    bool triggerCaching,
+    std::shared_ptr<detail::LookupTableBase>& cachedLookupTablePtr,
+    const SelectivityVector& rows,
+    const VectorPtr& mapArg,
+    const VectorPtr& indexArg,
+    exec::EvalCtx& context) {
+  static constexpr vector_size_t kMinCachedMapSize = 100;
+  using TKey = typename TypeTraits<kind>::NativeType;
+
+  detail::LookupTable<TKey>* typedLookupTable = nullptr;
+  if (triggerCaching) {
+    if (!cachedLookupTablePtr) {
+      cachedLookupTablePtr =
+          std::make_shared<detail::LookupTable<TKey>>(*context.pool());
+    }
+
+    typedLookupTable = cachedLookupTablePtr->typedTable<TKey>();
+  }
+
+  auto* pool = context.pool();
+  BufferPtr indices = allocateIndices(rows.end(), pool);
+  auto rawIndices = indices->asMutable<vector_size_t>();
+
+  // Create nulls for lazy initialization.
+  NullsBuilder nullsBuilder(rows.end(), pool);
+
+  // Get base MapVector.
+  // TODO: Optimize the case when indices are identity.
+  exec::LocalDecodedVector mapHolder(context, *mapArg, rows);
+  auto decodedMap = mapHolder.get();
+  auto baseMap = decodedMap->base()->as<MapVector>();
+  auto mapIndices = decodedMap->indices();
+
+  // Get map keys.
+  auto mapKeys = baseMap->mapKeys();
+  exec::LocalSelectivityVector allElementRows(context, mapKeys->size());
+  allElementRows->setAll();
+  exec::LocalDecodedVector mapKeysHolder(context, *mapKeys, *allElementRows);
+  auto decodedMapKeys = mapKeysHolder.get();
+
+  // Get index vector (second argument).
+  exec::LocalDecodedVector indexHolder(context, *indexArg, rows);
+  auto decodedIndices = indexHolder.get();
+
+  auto rawSizes = baseMap->rawSizes();
+  auto rawOffsets = baseMap->rawOffsets();
+
+  // Lambda that does the search for a key, for each row.
+  auto processRow = [&](vector_size_t row, TKey searchKey) {
+    size_t mapIndex = mapIndices[row];
+    auto size = rawSizes[mapIndex];
+    size_t offsetStart = rawOffsets[mapIndex];
+    size_t offsetEnd = offsetStart + size;
+    bool found = false;
+
+    if (triggerCaching && size >= kMinCachedMapSize) {
+      VELOX_DCHECK_NOT_NULL(typedLookupTable);
+
+      // Create map for mapIndex if not created.
+      if (!typedLookupTable->containsMapAtIndex(mapIndex)) {
+        typedLookupTable->ensureMapAtIndex(mapIndex);
+        // Materialize the map at index row.
+        auto& map = typedLookupTable->getMapAtIndex(mapIndex);
+        for (size_t offset = offsetStart; offset < offsetEnd; ++offset) {
+          map.emplace(decodedMapKeys->valueAt<TKey>(offset), offset);
+        }
+      }
+
+      auto& map = typedLookupTable->getMapAtIndex(mapIndex);
+
+      // Fast lookup.
+      auto value = map.find(searchKey);
+      if (value != map.end()) {
+        rawIndices[row] = value->second;
+        found = true;
+      }
+
+    } else {
+      // Search map without caching.
+      for (size_t offset = offsetStart; offset < offsetEnd; ++offset) {
+        if (isPrimitiveEqual<TKey>(
+                decodedMapKeys->valueAt<TKey>(offset), searchKey)) {
+          rawIndices[row] = offset;
+          found = true;
+          break;
+        }
+      }
+    }
+
+    // Handle NULLs.
+    if (!found) {
+      nullsBuilder.setNull(row);
+    }
+  };
+
+  // When second argument ("at") is a constant.
+  if (decodedIndices->isConstantMapping()) {
+    auto searchKey = decodedIndices->valueAt<TKey>(0);
+    rows.applyToSelected(
+        [&](vector_size_t row) { processRow(row, searchKey); });
+  }
+
+  // When the second argument ("at") is also a variable vector.
+  else {
+    rows.applyToSelected([&](vector_size_t row) {
+      auto searchKey = decodedIndices->valueAt<TKey>(row);
+      processRow(row, searchKey);
+    });
+  }
+
+  // Subscript into empty maps always returns NULLs. Check added at the end to
+  // ensure user error checks for indices are not skipped.
+  if (baseMap->mapValues()->size() == 0) {
+    return BaseVector::createNullConstant(
+        baseMap->mapValues()->type(), rows.end(), context.pool());
+  }
+
+  return BaseVector::wrapInDictionary(
+      nullsBuilder.build(), indices, rows.end(), baseMap->mapValues());
+}
+
+VectorPtr applyMapComplexType(
+    const SelectivityVector& rows,
+    const VectorPtr& mapArg,
+    const VectorPtr& indexArg,
+    exec::EvalCtx& context,
+    bool triggerCaching,
+    std::shared_ptr<detail::LookupTableBase>& cachedLookupTablePtr) {
+  auto* pool = context.pool();
+
+  // Use indices with the mapValues wrapped in a dictionary vector.
+  BufferPtr indices = allocateIndices(rows.end(), pool);
+  auto rawIndices = indices->asMutable<vector_size_t>();
+
+  // Create nulls for lazy initialization.
+  NullsBuilder nullsBuilder(rows.end(), pool);
+
+  // Get base MapVector.
+  exec::LocalDecodedVector mapHolder(context, *mapArg, rows);
+  auto decodedMap = mapHolder.get();
+  auto baseMap = decodedMap->base()->as<MapVector>();
+  auto mapIndices = decodedMap->indices();
+
+  // Get map keys.
+  auto mapKeys = baseMap->mapKeys();
+  exec::LocalSelectivityVector allElementRows(context, mapKeys->size());
+  allElementRows->setAll();
+  exec::LocalDecodedVector mapKeysHolder(context, *mapKeys, *allElementRows);
+  auto mapKeysDecoded = mapKeysHolder.get();
+  auto mapKeysBase = mapKeysDecoded->base();
+  auto mapKeysIndices = mapKeysDecoded->indices();
+
+  // Get index vector (second argument).
+  exec::LocalDecodedVector indexHolder(context, *indexArg, rows);
+  auto decodedIndices = indexHolder.get();
+  auto searchBase = decodedIndices->base();
+  auto searchIndices = decodedIndices->indices();
+
+  auto rawSizes = baseMap->rawSizes();
+  auto rawOffsets = baseMap->rawOffsets();
+
+  // Fast path for the case of a single map. It may be constant or dictionary
+  // encoded. Use hash table for quick search.
+  if (baseMap->size() == 1) {
+    detail::ComplexKeyHashMap hashMap{detail::MapKeyAllocator(*pool)};
+    detail::ComplexKeyHashMap* hashMapPtr = &hashMap;
+
+    if (triggerCaching) {
+      if (!cachedLookupTablePtr) {
+        cachedLookupTablePtr =
+            std::make_shared<detail::LookupTable<void>>(*context.pool());
+      }
+
+      detail::LookupTable<void>* typedLookupTable =
+          cachedLookupTablePtr->typedTable<void>();
+
+      static constexpr vector_size_t kMapIndex = 0;
+
+      if (!typedLookupTable->containsMapAtIndex(kMapIndex)) {
+        typedLookupTable->ensureMapAtIndex(kMapIndex);
+      }
+
+      auto& map = typedLookupTable->getMapAtIndex(kMapIndex);
+      hashMapPtr = &map;
+    }
+
+    if (hashMapPtr->empty()) {
+      auto numKeys = rawSizes[0];
+      hashMapPtr->reserve(numKeys * 1.3);
+      for (auto i = 0; i < numKeys; ++i) {
+        hashMapPtr->insert(detail::MapKey{mapKeysBase, mapKeysIndices[i], i});
+      }
+    }
+
+    rows.applyToSelected([&](vector_size_t row) {
+      VELOX_CHECK_EQ(0, mapIndices[row]);
+
+      auto searchIndex = searchIndices[row];
+      auto it = hashMapPtr->find(detail::MapKey{searchBase, searchIndex, row});
+      if (it != hashMapPtr->end()) {
+        rawIndices[row] = it->index;
+      } else {
+        nullsBuilder.setNull(row);
+      }
+    });
+
+  } else {
+    // Search the key in each row.
+    rows.applyToSelected([&](vector_size_t row) {
+      size_t mapIndex = mapIndices[row];
+      size_t size = rawSizes[mapIndex];
+      size_t offset = rawOffsets[mapIndex];
+
+      bool found = false;
+      auto searchIndex = searchIndices[row];
+      for (auto i = 0; i < size; i++) {
+        if (mapKeysBase->equalValueAt(
+                searchBase, mapKeysIndices[offset + i], searchIndex)) {
+          rawIndices[row] = offset + i;
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        nullsBuilder.setNull(row);
+      }
+    });
+  }
+
+  // Subscript into empty maps always returns NULLs. Check added at the end to
+  // ensure user error checks for indices are not skipped.
+  if (baseMap->mapValues()->size() == 0) {
+    return BaseVector::createNullConstant(
+        baseMap->mapValues()->type(), rows.end(), context.pool());
+  }
+
+  return BaseVector::wrapInDictionary(
+      nullsBuilder.build(), indices, rows.end(), baseMap->mapValues());
+}
+
+} // namespace
+
+namespace detail {
+
+VectorPtr MapSubscript::applyMap(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    exec::EvalCtx& context) const {
+  auto& mapArg = args[0];
+  auto& indexArg = args[1];
+
+  // Ensure map key type and second argument are the same.
+  VELOX_CHECK(mapArg->type()->childAt(0)->equivalent(*indexArg->type()));
+
+  bool triggerCaching = shouldTriggerCaching(mapArg);
+  if (indexArg->type()->isPrimitiveType()) {
+    return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        applyMapTyped,
+        indexArg->typeKind(),
+        triggerCaching,
+        lookupTable_,
+        rows,
+        mapArg,
+        indexArg,
+        context);
+  } else {
+    return applyMapComplexType(
+        rows, mapArg, indexArg, context, triggerCaching, lookupTable_);
+  }
+}
+
 namespace {
 std::exception_ptr makeZeroSubscriptError() {
   try {
     VELOX_USER_FAIL("SQL array indices start at 1");
-  } catch (const std::exception& e) {
+  } catch (const std::exception&) {
     return std::current_exception();
   }
 }
@@ -30,7 +341,7 @@ std::exception_ptr makeZeroSubscriptError() {
 std::exception_ptr makeBadSubscriptError() {
   try {
     VELOX_USER_FAIL("Array subscript out of bounds.");
-  } catch (const std::exception& e) {
+  } catch (const std::exception&) {
     return std::current_exception();
   }
 }
@@ -38,7 +349,7 @@ std::exception_ptr makeBadSubscriptError() {
 std::exception_ptr makeNegativeSubscriptError() {
   try {
     VELOX_USER_FAIL("Array subscript is negative.");
-  } catch (const std::exception& e) {
+  } catch (const std::exception&) {
     return std::current_exception();
   }
 }
@@ -58,5 +369,6 @@ const std::exception_ptr& negativeSubscriptError() {
   static std::exception_ptr error = makeNegativeSubscriptError();
   return error;
 }
+} // namespace detail
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/SubscriptUtil.h b/velox/functions/lib/SubscriptUtil.h
index c3425c2ceaa71..2700d0c1bf070 100644
--- a/velox/functions/lib/SubscriptUtil.h
+++ b/velox/functions/lib/SubscriptUtil.h
@@ -16,24 +16,202 @@
 
 #pragma once
 
+#include <memory>
+#include "velox/expression/ComplexViewTypes.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/expression/VectorReaders.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
 #include "velox/vector/NullsBuilder.h"
+#include "velox/vector/TypeAliases.h"
 
 namespace facebook::velox::functions {
 
+namespace detail {
 // Below functions return a stock instance of each of the possible errors in
 // SubscriptImpl
 const std::exception_ptr& zeroSubscriptError();
 const std::exception_ptr& badSubscriptError();
 const std::exception_ptr& negativeSubscriptError();
 
+// A flat vector of map keys, an index into that vector and an index into
+// the original map keys vector that may have encodings.
+struct MapKey {
+  const BaseVector* baseVector;
+  const vector_size_t baseIndex;
+  const vector_size_t index;
+
+  size_t hash() const {
+    return baseVector->hashValueAt(baseIndex);
+  }
+
+  bool operator==(const MapKey& other) const {
+    return baseVector->equalValueAt(
+        other.baseVector, baseIndex, other.baseIndex);
+  }
+
+  bool operator<(const MapKey& other) const {
+    return baseVector->compare(other.baseVector, baseIndex, other.baseIndex) <
+        0;
+  }
+};
+
+struct MapKeyHasher {
+  size_t operator()(const MapKey& key) const {
+    return key.hash();
+  }
+};
+
+using MapKeyAllocator = memory::StlAllocator<detail::MapKey>;
+
+using ComplexKeyHashMap = folly::F14FastSet<
+    detail::MapKey,
+    detail::MapKeyHasher,
+    folly::f14::DefaultKeyEqual<detail::MapKey>,
+    MapKeyAllocator>;
+
+template <typename NativeType>
+class LookupTable;
+
+class LookupTableBase {
+ public:
+  template <typename NativeType>
+  LookupTable<NativeType>* typedTable() {
+    return static_cast<LookupTable<NativeType>*>(this);
+  }
+  virtual ~LookupTableBase() {}
+};
+
+// NativeType should by TypeTraits<TypeKind>::NativeType for the key's TypeKind.
+template <typename NativeType>
+class LookupTable : public LookupTableBase {
+ public:
+  LookupTable(memory::MemoryPool& pool)
+      : pool_(pool),
+        map_(std::make_unique<outer_map_t>(outer_allocator_t(pool))) {}
+
+  auto& map() {
+    return map_;
+  }
+
+  bool containsMapAtIndex(vector_size_t rowIndex) const {
+    return map_->count(rowIndex) != 0;
+  }
+
+  void ensureMapAtIndex(vector_size_t rowIndex) const {
+    map_->emplace(rowIndex, pool_);
+  }
+
+  auto& getMapAtIndex(vector_size_t rowIndex) {
+    VELOX_DCHECK(containsMapAtIndex(rowIndex));
+    return map_->find(rowIndex)->second;
+  }
+
+ private:
+  // If the NativeType is not void, we can materialize the key in memory
+  // directly, so we can use a HashMap keyed on the native value.  If it is void
+  // then we have to use MapKey as the key to wrap the Vector and avoid
+  // materializing the key in memory.
+  using inner_allocator_t = std::conditional_t<
+      std::is_same_v<NativeType, void>,
+      MapKeyAllocator,
+      memory::StlAllocator<std::pair<NativeType const, vector_size_t>>>;
+
+  using inner_map_t = std::conditional_t<
+      std::is_same_v<NativeType, void>,
+      ComplexKeyHashMap,
+      typename util::floating_point::HashMapNaNAwareTypeTraits<
+          NativeType,
+          vector_size_t,
+          inner_allocator_t>::Type>;
+
+  using outer_allocator_t =
+      memory::StlAllocator<std::pair<vector_size_t const, inner_map_t>>;
+
+  // [rowindex][key] -> offset of value.
+  using outer_map_t = folly::F14FastMap<
+      vector_size_t,
+      inner_map_t,
+      folly::f14::DefaultHasher<vector_size_t>,
+      folly::f14::DefaultKeyEqual<vector_size_t>,
+      outer_allocator_t>;
+
+  memory::MemoryPool& pool_;
+  std::unique_ptr<outer_map_t> map_;
+};
+
+class MapSubscript {
+ public:
+  explicit MapSubscript(bool allowCaching) : allowCaching_(allowCaching) {}
+
+  VectorPtr applyMap(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      exec::EvalCtx& context) const;
+
+  bool cachingEnabled() const {
+    return allowCaching_;
+  }
+
+  auto& lookupTable() const {
+    return lookupTable_;
+  }
+
+  auto& firstSeenMap() const {
+    return firstSeenMap_;
+  }
+
+ private:
+  bool shouldTriggerCaching(const VectorPtr& mapArg) const {
+    if (!allowCaching_) {
+      return false;
+    }
+
+    if (mapArg->type()->childAt(0)->isBoolean()) {
+      // Disable caching if the key type is boolean.
+      allowCaching_ = false;
+      return false;
+    }
+
+    if (!firstSeenMap_) {
+      firstSeenMap_ = mapArg;
+      return false;
+    }
+
+    if (firstSeenMap_->wrappedVector() == mapArg->wrappedVector()) {
+      return true;
+    }
+
+    // Disable caching forever.
+    allowCaching_ = false;
+    lookupTable_.reset();
+    firstSeenMap_.reset();
+    return false;
+  }
+
+  // When true the function is allowed to cache a materialized version of the
+  // processed map.
+  mutable bool allowCaching_;
+
+  // This is used to check if the same base map is being passed over and over
+  // in the function. A shared_ptr is used to guarantee that if the map is
+  // seen again then it was not modified.
+  mutable VectorPtr firstSeenMap_;
+
+  // Materialized cached version of firstSeenMap_ used to optimize the lookup.
+  mutable std::shared_ptr<LookupTableBase> lookupTable_;
+};
+} // namespace detail
+
 /// Generic subscript/element_at implementation for both array and map data
 /// types.
 ///
 /// Provides four template parameters to configure the behavior:
-/// - allowNegativeIndices: if allowed, negative indices accesses elements from
+/// - allowNegativeIndices: if allowed, negative indices accesses elements
+/// from
 ///   last to the first; otherwise, throws.
 /// - nullOnNegativeIndices: returns NULL for negative indices instead of the
 ///   behavior described above.
@@ -47,6 +225,9 @@ template <
     bool indexStartsAtOne>
 class SubscriptImpl : public exec::Subscript {
  public:
+  explicit SubscriptImpl(bool allowCaching)
+      : mapSubscript_(detail::MapSubscript(allowCaching)) {}
+
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -62,7 +243,7 @@ class SubscriptImpl : public exec::Subscript {
         break;
 
       case TypeKind::MAP:
-        localResult = applyMap(rows, args, context);
+        localResult = mapSubscript_.applyMap(rows, args, context);
         break;
 
       default:
@@ -71,32 +252,6 @@ class SubscriptImpl : public exec::Subscript {
     context.moveOrCopyResult(localResult, rows, result);
   }
 
-  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
-
-    // array(T), integer|bigint -> T
-    for (const auto& indexType : {"integer", "bigint"}) {
-      signatures.push_back(exec::FunctionSignatureBuilder()
-                               .typeVariable("T")
-                               .returnType("T")
-                               .argumentType("array(T)")
-                               .argumentType(indexType)
-                               .build());
-    }
-
-    // map(K,V), K -> V
-    signatures.push_back(exec::FunctionSignatureBuilder()
-                             .typeVariable("K")
-                             .typeVariable("V")
-                             .returnType("V")
-                             .argumentType("map(K,V)")
-                             .argumentType("K")
-                             .build());
-
-    return signatures;
-  }
-
- private:
   VectorPtr applyArray(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -120,54 +275,31 @@ class SubscriptImpl : public exec::Subscript {
     }
   }
 
-  VectorPtr applyMap(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      exec::EvalCtx& context) const {
-    VELOX_CHECK_EQ(args[0]->typeKind(), TypeKind::MAP);
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
 
-    auto mapArg = args[0];
-    auto indexArg = args[1];
+    // array(T), integer|bigint -> T
+    for (const auto& indexType : {"integer", "bigint"}) {
+      signatures.push_back(exec::FunctionSignatureBuilder()
+                               .typeVariable("T")
+                               .returnType("T")
+                               .argumentType("array(T)")
+                               .argumentType(indexType)
+                               .build());
+    }
 
-    // Ensure map key type and second argument are the same.
-    VELOX_CHECK(mapArg->type()->childAt(0)->equivalent(*indexArg->type()));
+    // map(K,V), K -> V
+    signatures.push_back(exec::FunctionSignatureBuilder()
+                             .typeVariable("K")
+                             .typeVariable("V")
+                             .returnType("V")
+                             .argumentType("map(K,V)")
+                             .argumentType("K")
+                             .build());
 
-    switch (indexArg->typeKind()) {
-      case TypeKind::HUGEINT:
-        return applyMapTyped<int128_t>(rows, mapArg, indexArg, context);
-      case TypeKind::BIGINT:
-        return applyMapTyped<int64_t>(rows, mapArg, indexArg, context);
-      case TypeKind::INTEGER:
-        return applyMapTyped<int32_t>(rows, mapArg, indexArg, context);
-      case TypeKind::SMALLINT:
-        return applyMapTyped<int16_t>(rows, mapArg, indexArg, context);
-      case TypeKind::TINYINT:
-        return applyMapTyped<int8_t>(rows, mapArg, indexArg, context);
-      case TypeKind::REAL:
-        return applyMapTyped<float>(rows, mapArg, indexArg, context);
-      case TypeKind::DOUBLE:
-        return applyMapTyped<double>(rows, mapArg, indexArg, context);
-      case TypeKind::BOOLEAN:
-        return applyMapTyped<bool>(rows, mapArg, indexArg, context);
-      case TypeKind::TIMESTAMP:
-        return applyMapTyped<Timestamp>(rows, mapArg, indexArg, context);
-      case TypeKind::VARCHAR:
-      case TypeKind::VARBINARY:
-        return applyMapTyped<StringView>(rows, mapArg, indexArg, context);
-      case TypeKind::ARRAY:
-      case TypeKind::MAP:
-      case TypeKind::ROW:
-        return applyMapComplexType(rows, mapArg, indexArg, context);
-      default:
-        VELOX_UNSUPPORTED(
-            "Unsupported map key type for element_at: {}",
-            mapTypeKindToName(indexArg->typeKind()));
-    }
+    return signatures;
   }
 
-  /// Decode arguments and transform result into a dictionaryVector where the
-  /// dictionary maintains a mapping from a given row to the index of the input
-  /// elements vector. This allows us to ensure that element_at is zero-copy.
   template <typename I>
   VectorPtr applyArrayTyped(
       const SelectivityVector& rows,
@@ -201,7 +333,7 @@ class SubscriptImpl : public exec::Subscript {
       const auto adjustedIndex =
           adjustIndex(decodedIndices->valueAt<I>(0), isZeroSubscriptError);
       if (isZeroSubscriptError) {
-        context.setErrors(rows, zeroSubscriptError());
+        context.setErrors(rows, detail::zeroSubscriptError());
         allFailed = true;
       }
 
@@ -222,7 +354,7 @@ class SubscriptImpl : public exec::Subscript {
         const auto adjustedIndex =
             adjustIndex(originalIndex, isZeroSubscriptError);
         if (isZeroSubscriptError) {
-          context.setError(row, zeroSubscriptError());
+          context.setVeloxExceptionError(row, detail::zeroSubscriptError());
           return;
         }
         const auto elementIndex = getIndex(
@@ -266,7 +398,8 @@ class SubscriptImpl : public exec::Subscript {
 
   // Returns the actual Vector index given an array index. Checks and adjusts
   // negative indices, in addition to bound checks.
-  // `index` is always a 0-based array index (see `adjustIndex` function above).
+  // `index` is always a 0-based array index (see `adjustIndex` function
+  // above).
   template <typename I>
   vector_size_t getIndex(
       I index,
@@ -286,7 +419,7 @@ class SubscriptImpl : public exec::Subscript {
           index += arraySize;
         }
       } else {
-        context.setError(row, negativeSubscriptError());
+        context.setVeloxExceptionError(row, detail::negativeSubscriptError());
         return -1;
       }
     }
@@ -297,7 +430,7 @@ class SubscriptImpl : public exec::Subscript {
       if constexpr (allowOutOfBound) {
         return -1;
       } else {
-        context.setError(row, badSubscriptError());
+        context.setVeloxExceptionError(row, detail::badSubscriptError());
         return -1;
       }
     }
@@ -307,168 +440,8 @@ class SubscriptImpl : public exec::Subscript {
     return rawOffsets[indices[row]] + index;
   }
 
-  /// Decode arguments and transform result into a dictionaryVector where the
-  /// dictionary maintains a mapping from a given row to the index of the input
-  /// map value vector. This allows us to ensure that element_at is zero-copy.
-  template <typename TKey>
-  VectorPtr applyMapTyped(
-      const SelectivityVector& rows,
-      const VectorPtr& mapArg,
-      const VectorPtr& indexArg,
-      exec::EvalCtx& context) const {
-    auto* pool = context.pool();
-
-    BufferPtr indices = allocateIndices(rows.end(), pool);
-    auto rawIndices = indices->asMutable<vector_size_t>();
-
-    // Create nulls for lazy initialization.
-    NullsBuilder nullsBuilder(rows.end(), pool);
-
-    // Get base MapVector.
-    // TODO: Optimize the case when indices are identity.
-    exec::LocalDecodedVector mapHolder(context, *mapArg, rows);
-    auto decodedMap = mapHolder.get();
-    auto baseMap = decodedMap->base()->as<MapVector>();
-    auto mapIndices = decodedMap->indices();
-
-    // Get map keys.
-    auto mapKeys = baseMap->mapKeys();
-    exec::LocalSelectivityVector allElementRows(context, mapKeys->size());
-    allElementRows->setAll();
-    exec::LocalDecodedVector mapKeysHolder(context, *mapKeys, *allElementRows);
-    auto decodedMapKeys = mapKeysHolder.get();
-
-    // Get index vector (second argument).
-    exec::LocalDecodedVector indexHolder(context, *indexArg, rows);
-    auto decodedIndices = indexHolder.get();
-
-    auto rawSizes = baseMap->rawSizes();
-    auto rawOffsets = baseMap->rawOffsets();
-
-    // Lambda that does the search for a key, for each row.
-    auto processRow = [&](vector_size_t row, TKey searchKey) {
-      size_t mapIndex = mapIndices[row];
-      size_t offsetStart = rawOffsets[mapIndex];
-      size_t offsetEnd = offsetStart + rawSizes[mapIndex];
-      bool found = false;
-
-      // Sequentially check each key on this map for a match. We use a
-      // sequential scan over the keys because it's easier to express (and
-      // likely has good memory locality), but if we find that this is slow
-      // for large maps we could try to canonicalize the whole vector and binary
-      // search `searchKey`.
-      for (size_t offset = offsetStart; offset < offsetEnd; ++offset) {
-        if (decodedMapKeys->valueAt<TKey>(offset) == searchKey) {
-          rawIndices[row] = offset;
-          found = true;
-          break;
-        }
-      }
-
-      // NB: We still allow non-existent map keys, even if out of bounds is
-      // disabled for arrays.
-
-      // Handle NULLs.
-      if (!found) {
-        nullsBuilder.setNull(row);
-      }
-    };
-
-    // When second argument ("at") is a constant.
-    if (decodedIndices->isConstantMapping()) {
-      auto searchKey = decodedIndices->valueAt<TKey>(0);
-      rows.applyToSelected(
-          [&](vector_size_t row) { processRow(row, searchKey); });
-    }
-    // When the second argument ("at") is also a variable vector.
-    else {
-      rows.applyToSelected([&](vector_size_t row) {
-        auto searchKey = decodedIndices->valueAt<TKey>(row);
-        processRow(row, searchKey);
-      });
-    }
-
-    // Subscript into empty maps always returns NULLs. Check added at the end to
-    // ensure user error checks for indices are not skipped.
-    if (baseMap->mapValues()->size() == 0) {
-      return BaseVector::createNullConstant(
-          baseMap->mapValues()->type(), rows.end(), context.pool());
-    }
-
-    return BaseVector::wrapInDictionary(
-        nullsBuilder.build(), indices, rows.end(), baseMap->mapValues());
-  }
-
-  VectorPtr applyMapComplexType(
-      const SelectivityVector& rows,
-      const VectorPtr& mapArg,
-      const VectorPtr& indexArg,
-      exec::EvalCtx& context) const {
-    auto* pool = context.pool();
-
-    // Use indices with the mapValues wrapped in a dictionary vector.
-    BufferPtr indices = allocateIndices(rows.end(), pool);
-    auto rawIndices = indices->asMutable<vector_size_t>();
-
-    // Create nulls for lazy initialization.
-    NullsBuilder nullsBuilder(rows.end(), pool);
-
-    // Get base MapVector.
-    exec::LocalDecodedVector mapHolder(context, *mapArg, rows);
-    auto decodedMap = mapHolder.get();
-    auto baseMap = decodedMap->base()->as<MapVector>();
-    auto mapIndices = decodedMap->indices();
-
-    // Get map keys.
-    auto mapKeys = baseMap->mapKeys();
-    exec::LocalSelectivityVector allElementRows(context, mapKeys->size());
-    allElementRows->setAll();
-    exec::LocalDecodedVector mapKeysHolder(context, *mapKeys, *allElementRows);
-    auto mapKeysDecoded = mapKeysHolder.get();
-    auto mapKeysBase = mapKeysDecoded->base();
-    auto mapKeysIndices = mapKeysDecoded->indices();
-
-    // Get index vector (second argument).
-    exec::LocalDecodedVector indexHolder(context, *indexArg, rows);
-    auto decodedIndices = indexHolder.get();
-    auto searchBase = decodedIndices->base();
-    auto searchIndices = decodedIndices->indices();
-
-    auto rawSizes = baseMap->rawSizes();
-    auto rawOffsets = baseMap->rawOffsets();
-
-    // Search the key in each row.
-    rows.applyToSelected([&](vector_size_t row) {
-      size_t mapIndex = mapIndices[row];
-      size_t size = rawSizes[mapIndex];
-      size_t offset = rawOffsets[mapIndex];
-
-      bool found = false;
-      auto searchIndex = searchIndices[row];
-      for (auto i = 0; i < size; i++) {
-        if (mapKeysBase->equalValueAt(
-                searchBase, mapKeysIndices[offset + i], searchIndex)) {
-          rawIndices[row] = offset + i;
-          found = true;
-          break;
-        }
-      }
-
-      if (!found) {
-        nullsBuilder.setNull(row);
-      };
-    });
-
-    // Subscript into empty maps always returns NULLs. Check added at the end to
-    // ensure user error checks for indices are not skipped.
-    if (baseMap->mapValues()->size() == 0) {
-      return BaseVector::createNullConstant(
-          baseMap->mapValues()->type(), rows.end(), context.pool());
-    }
-
-    return BaseVector::wrapInDictionary(
-        nullsBuilder.build(), indices, rows.end(), baseMap->mapValues());
-  }
+ private:
+  detail::MapSubscript mapSubscript_;
 };
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/TimeUtils.cpp b/velox/functions/lib/TimeUtils.cpp
new file mode 100644
index 0000000000000..953ffc500ea5a
--- /dev/null
+++ b/velox/functions/lib/TimeUtils.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/TimeUtils.h"
+
+namespace facebook::velox::functions {
+
+const folly::F14FastMap<std::string, int8_t> kDayOfWeekNames{
+    {"th", 0},       {"fr", 1},     {"sa", 2},       {"su", 3},
+    {"mo", 4},       {"tu", 5},     {"we", 6},       {"thu", 0},
+    {"fri", 1},      {"sat", 2},    {"sun", 3},      {"mon", 4},
+    {"tue", 5},      {"wed", 6},    {"thursday", 0}, {"friday", 1},
+    {"saturday", 2}, {"sunday", 3}, {"monday", 4},   {"tuesday", 5},
+    {"wednesday", 6}};
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/TimeUtils.h b/velox/functions/lib/TimeUtils.h
index b6d838cd676a5..39892124e0a77 100644
--- a/velox/functions/lib/TimeUtils.h
+++ b/velox/functions/lib/TimeUtils.h
@@ -17,27 +17,28 @@
 
 #include <velox/type/Timestamp.h>
 #include "velox/core/QueryConfig.h"
-#include "velox/external/date/tz.h"
 #include "velox/functions/Macros.h"
+#include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::functions {
-namespace {
+
 inline constexpr int64_t kSecondsInDay = 86'400;
 inline constexpr int64_t kDaysInWeek = 7;
+extern const folly::F14FastMap<std::string, int8_t> kDayOfWeekNames;
 
-FOLLY_ALWAYS_INLINE const date::time_zone* getTimeZoneFromConfig(
+FOLLY_ALWAYS_INLINE const tz::TimeZone* getTimeZoneFromConfig(
     const core::QueryConfig& config) {
   if (config.adjustTimestampToTimezone()) {
     auto sessionTzName = config.sessionTimezone();
     if (!sessionTzName.empty()) {
-      return date::locate_zone(sessionTzName);
+      return tz::locateZone(sessionTzName);
     }
   }
   return nullptr;
 }
 
 FOLLY_ALWAYS_INLINE int64_t
-getSeconds(Timestamp timestamp, const date::time_zone* timeZone) {
+getSeconds(Timestamp timestamp, const tz::TimeZone* timeZone) {
   if (timeZone != nullptr) {
     timestamp.toTimezone(*timeZone);
     return timestamp.getSeconds();
@@ -45,14 +46,13 @@ getSeconds(Timestamp timestamp, const date::time_zone* timeZone) {
     return timestamp.getSeconds();
   }
 }
-} // namespace
 
 FOLLY_ALWAYS_INLINE
-std::tm getDateTime(Timestamp timestamp, const date::time_zone* timeZone) {
+std::tm getDateTime(Timestamp timestamp, const tz::TimeZone* timeZone) {
   int64_t seconds = getSeconds(timestamp, timeZone);
   std::tm dateTime;
   VELOX_USER_CHECK(
-      epochToUtc(seconds, dateTime),
+      Timestamp::epochToCalendarUtc(seconds, dateTime),
       "Timestamp is too large: {} seconds since epoch",
       seconds);
   return dateTime;
@@ -64,16 +64,41 @@ std::tm getDateTime(int32_t days) {
   int64_t seconds = days * kSecondsInDay;
   std::tm dateTime;
   VELOX_USER_CHECK(
-      epochToUtc(seconds, dateTime), "Date is too large: {} days", days);
+      Timestamp::epochToCalendarUtc(seconds, dateTime),
+      "Date is too large: {} days",
+      days);
   return dateTime;
 }
 
+FOLLY_ALWAYS_INLINE int getYear(const std::tm& time) {
+  // tm_year: years since 1900.
+  return 1900 + time.tm_year;
+}
+
+FOLLY_ALWAYS_INLINE int getMonth(const std::tm& time) {
+  // tm_mon: months since January – [0, 11].
+  return 1 + time.tm_mon;
+}
+
+FOLLY_ALWAYS_INLINE int getDay(const std::tm& time) {
+  return time.tm_mday;
+}
+
+FOLLY_ALWAYS_INLINE int32_t getQuarter(const std::tm& time) {
+  return time.tm_mon / 3 + 1;
+}
+
+FOLLY_ALWAYS_INLINE int32_t getDayOfYear(const std::tm& time) {
+  return time.tm_yday + 1;
+}
+
 template <typename T>
 struct InitSessionTimezone {
   VELOX_DEFINE_FUNCTION_TYPES(T);
-  const date::time_zone* timeZone_{nullptr};
+  const tz::TimeZone* timeZone_{nullptr};
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Timestamp>* /*timestamp*/) {
     timeZone_ = getTimeZoneFromConfig(config);
diff --git a/velox/functions/lib/ToHex.h b/velox/functions/lib/ToHex.h
new file mode 100644
index 0000000000000..14b714f811570
--- /dev/null
+++ b/velox/functions/lib/ToHex.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/StringWriter.h"
+
+namespace facebook::velox::functions {
+
+struct ToHexUtil {
+  FOLLY_ALWAYS_INLINE static void toHex(
+      StringView input,
+      exec::StringWriter<false>& result) {
+    // Lookup table to translate unsigned char to its hexadecimal format.
+    static const char* const kHexTable =
+        "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"
+        "202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F"
+        "404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F"
+        "606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F"
+        "808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F"
+        "A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF"
+        "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF"
+        "E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF";
+
+    const int64_t inputSize = input.size();
+    const unsigned char* inputBuffer =
+        reinterpret_cast<const unsigned char*>(input.data());
+    result.resize(inputSize * 2);
+    char* resultBuffer = result.data();
+
+    for (auto i = 0; i < inputSize; ++i) {
+      resultBuffer[i * 2] = kHexTable[inputBuffer[i] * 2];
+      resultBuffer[i * 2 + 1] = kHexTable[inputBuffer[i] * 2 + 1];
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE static void toHex(
+      uint64_t input,
+      exec::StringWriter<false>& result) {
+    static const char* const kHexTable = "0123456789ABCDEF";
+    if (input == 0) {
+      result = "0";
+      return;
+    }
+
+    const auto resultSize = ((64 - bits::countLeadingZeros(input)) + 3) / 4;
+    result.resize(resultSize);
+    char* buffer = result.data();
+
+    int32_t len = 0;
+    do {
+      len += 1;
+      buffer[resultSize - len] = kHexTable[input & 0xF];
+      input >>= 4;
+    } while (input != 0);
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Utf8Utils.cpp b/velox/functions/lib/Utf8Utils.cpp
new file mode 100644
index 0000000000000..17a26a633f5fb
--- /dev/null
+++ b/velox/functions/lib/Utf8Utils.cpp
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/lib/Utf8Utils.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/external/utf8proc/utf8procImpl.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+// Returns the length of a UTF-8 character indicated by the first byte. Returns
+// -1 for invalid UTF-8 first byte.
+int firstByteCharLength(const char* u_input) {
+  auto u = (const unsigned char*)u_input;
+  unsigned char u0 = u[0];
+  if (u0 < 0b10000000) {
+    // normal ASCII
+    // 0xxx_xxxx
+    return 1;
+  }
+  if (u0 < 0b11000000) {
+    // illegal bytes
+    // 10xx_xxxx
+    return -1;
+  }
+  if (u0 < 0b11100000) {
+    // 110x_xxxx 10xx_xxxx
+    return 2;
+  }
+  if (u0 < 0b11110000) {
+    // 1110_xxxx 10xx_xxxx 10xx_xxxx
+    return 3;
+  }
+  if (u0 < 0b11111000) {
+    // 1111_0xxx 10xx_xxxx 10xx_xxxx 10xx_xxxx
+    return 4;
+  }
+  if (u0 < 0b11111100) {
+    // 1111_10xx 10xx_xxxx 10xx_xxxx 10xx_xxxx 10xx_xxxx
+    return 5;
+  }
+  if (u0 < 0b11111110) {
+    // 1111_10xx 10xx_xxxx 10xx_xxxx 10xx_xxxx 10xx_xxxx
+    return 6;
+  }
+  // No unicode codepoint can be longer than 6 bytes.
+  return -1;
+}
+
+} // namespace
+
+int32_t tryGetCharLength(const char* input, int64_t size) {
+  VELOX_DCHECK_NOT_NULL(input);
+  VELOX_DCHECK_GT(size, 0);
+
+  auto charLength = firstByteCharLength(input);
+  if (charLength < 0) {
+    return -1;
+  }
+
+  if (charLength == 1) {
+    // Normal ASCII: 0xxx_xxxx.
+    return 1;
+  }
+
+  auto firstByte = input[0];
+
+  // Process second byte.
+  if (size < 2) {
+    return -1;
+  }
+
+  auto secondByte = input[1];
+  if (!utf_cont(secondByte)) {
+    return -1;
+  }
+
+  if (charLength == 2) {
+    // 110x_xxxx 10xx_xxxx
+    int codePoint = ((firstByte & 0b00011111) << 6) | (secondByte & 0b00111111);
+    // Fail if overlong encoding.
+    return codePoint < 0x80 ? -2 : 2;
+  }
+
+  // Process third byte.
+  if (size < 3) {
+    return -2;
+  }
+
+  auto thirdByte = input[2];
+  if (!utf_cont(thirdByte)) {
+    return -2;
+  }
+
+  if (charLength == 3) {
+    // 1110_xxxx 10xx_xxxx 10xx_xxxx
+    int codePoint = ((firstByte & 0b00001111) << 12) |
+        ((secondByte & 0b00111111) << 6) | (thirdByte & 0b00111111);
+
+    // Surrogates are invalid.
+    static const int kMinSurrogate = 0xd800;
+    static const int kMaxSurrogate = 0xdfff;
+    if (kMinSurrogate <= codePoint && codePoint <= kMaxSurrogate) {
+      return -3;
+    }
+
+    // Fail if overlong encoding.
+    return codePoint < 0x800 ? -3 : 3;
+  }
+
+  // Process forth byte.
+  if (size < 4) {
+    return -3;
+  }
+
+  auto forthByte = input[3];
+  if (!utf_cont(forthByte)) {
+    return -3;
+  }
+
+  if (charLength == 4) {
+    // 1111_0xxx 10xx_xxxx 10xx_xxxx 10xx_xxxx
+    int codePoint = ((firstByte & 0b00000111) << 18) |
+        ((secondByte & 0b00111111) << 12) | ((thirdByte & 0b00111111) << 6) |
+        (forthByte & 0b00111111);
+    // Fail if overlong encoding or above upper bound of Unicode.
+    if (codePoint < 0x110000 && codePoint >= 0x10000) {
+      return 4;
+    }
+    return -4;
+  }
+
+  if (size < 5) {
+    return -4;
+  }
+
+  auto fifthByte = input[4];
+  if (!utf_cont(fifthByte)) {
+    return -4;
+  }
+
+  if (charLength == 5) {
+    // Per RFC3629, UTF-8 is limited to 4 bytes, so more bytes are illegal.
+    return -5;
+  }
+
+  if (size < 6) {
+    return -5;
+  }
+
+  auto sixthByte = input[5];
+  if (!utf_cont(sixthByte)) {
+    return -5;
+  }
+
+  if (charLength == 6) {
+    // Per RFC3629, UTF-8 is limited to 4 bytes, so more bytes are illegal.
+    return -6;
+  }
+  // for longer sequence, which can't happen.
+  return -1;
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Utf8Utils.h b/velox/functions/lib/Utf8Utils.h
new file mode 100644
index 0000000000000..369e1151e93fa
--- /dev/null
+++ b/velox/functions/lib/Utf8Utils.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cstdint>
+
+#include "folly/CPortability.h"
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::functions {
+
+/// This function is not part of the original utf8proc.
+/// Tries to get the length of UTF-8 encoded code point. A
+/// positive return value means the UTF-8 sequence is valid, and
+/// the result is the length of the code point. A negative return value means
+/// the UTF-8 sequence at the position is invalid, and the length of the invalid
+/// sequence is the absolute value of the result. A byte sequence is recognized
+/// as an invalid UTF-8 code point of length N in either of the folllowing
+/// situations:
+///   1. The first byte is a continuation byte or indicates the length of the
+///      code point is greater than 6. N is 1 in this situation.
+///   2. The first byte indicates a length of M > N, but there are only N-1
+///      bytes left afterwards in the buffer of the given `size`.
+///   3. The first byte indicates a length of M > N, but only the subsequent
+///      N-1 bytes are continuation bytes.
+///   4. The first byte indicates a length of N, but the code point is
+///      overlong-encoded, a surrogate character not allowed in UTF-8, or above
+///      the Unicode upper bound 0x10FFFF.
+///   5. The first byte indicates a length of N > 4. Code points of more
+///      than 4 bytes are no longer allowed per RFC3629.
+///
+/// @param input Pointer to the first byte of the code point. Must not be null.
+/// @param size Number of available bytes. Must be greater than zero.
+/// @return the length of the code point or negative the number of bytes in the
+/// invalid UTF-8 sequence.
+///
+/// Adapted from tryGetCodePointAt in
+/// https://github.com/airlift/slice/blob/master/src/main/java/io/airlift/slice/SliceUtf8.java
+int32_t tryGetCharLength(const char* input, int64_t size);
+
+/// Return the length in byte of the next UTF-8 encoded character at the
+/// beginning of `string`. If the beginning of `string` is not valid UTF-8
+/// encoding, return -1.
+FOLLY_ALWAYS_INLINE int validateAndGetNextUtf8Length(
+    const unsigned char* string,
+    const unsigned char* end) {
+  VELOX_DCHECK(string < end, "Expect non-empty string.");
+
+  if ((*string & 0x80u) == 0) {
+    return 1;
+  }
+  if ((*string & 0xE0u) == 0xC0u && (string + 1) < end &&
+      (*(string + 1) & 0xC0u) == 0x80u) {
+    return 2;
+  }
+  if ((*string & 0xF0u) == 0xE0u && (string + 2) < end &&
+      (*(string + 1) & 0xC0u) == 0x80u && (*(string + 2) & 0xC0u) == 0x80u) {
+    return 3;
+  }
+  if ((*string & 0xF8u) == 0xF0u && (string + 3) < end &&
+      (*(string + 1) & 0xC0u) == 0x80u && (*(string + 2) & 0xC0u) == 0x80u &&
+      (*(string + 3) & 0xC0u) == 0x80u) {
+    return 4;
+  }
+  return -1;
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/aggregates/AverageAggregateBase.cpp b/velox/functions/lib/aggregates/AverageAggregateBase.cpp
index efef798b62029..047d48cbf2705 100644
--- a/velox/functions/lib/aggregates/AverageAggregateBase.cpp
+++ b/velox/functions/lib/aggregates/AverageAggregateBase.cpp
@@ -28,7 +28,7 @@ void checkAvgIntermediateType(const TypePtr& type) {
   VELOX_USER_CHECK(
       type->childAt(0)->kind() == TypeKind::DOUBLE ||
           type->childAt(0)->isLongDecimal(),
-      "Input type for sum in final average must be double or long decimal type.")
+      "Input type for sum in final average must be double or long decimal type.");
   VELOX_USER_CHECK_EQ(
       type->childAt(1)->kind(),
       TypeKind::BIGINT,
diff --git a/velox/functions/lib/aggregates/AverageAggregateBase.h b/velox/functions/lib/aggregates/AverageAggregateBase.h
index d2ea2273cdbfe..bb0166450592b 100644
--- a/velox/functions/lib/aggregates/AverageAggregateBase.h
+++ b/velox/functions/lib/aggregates/AverageAggregateBase.h
@@ -83,15 +83,6 @@ class AverageAggregateBase : public exec::Aggregate {
     return sizeof(SumCount<TAccumulator>);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) SumCount<TAccumulator>();
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto vector = (*result)->as<FlatVector<TResult>>();
@@ -385,6 +376,15 @@ class AverageAggregateBase : public exec::Aggregate {
     }
   }
 
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) SumCount<TAccumulator>();
+    }
+  }
+
   DecodedVector decodedRaw_;
   DecodedVector decodedPartial_;
 };
diff --git a/velox/functions/lib/aggregates/BitwiseAggregateBase.h b/velox/functions/lib/aggregates/BitwiseAggregateBase.h
index 428b905ea83ca..cb9405d2c3d6d 100644
--- a/velox/functions/lib/aggregates/BitwiseAggregateBase.h
+++ b/velox/functions/lib/aggregates/BitwiseAggregateBase.h
@@ -33,15 +33,6 @@ class BitwiseAggregateBase : public SimpleNumericAggregate<T, T, T> {
     return sizeof(T);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      *exec::Aggregate::value<T>(groups[i]) = initialValue_;
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     BaseAggregate::doExtractValues(groups, numGroups, result, [&](char* group) {
@@ -66,13 +57,30 @@ class BitwiseAggregateBase : public SimpleNumericAggregate<T, T, T> {
   }
 
  protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      *exec::Aggregate::value<T>(groups[i]) = initialValue_;
+    }
+  }
+
   const T initialValue_;
 };
 
 template <template <typename U> class T>
-exec::AggregateRegistrationResult registerBitwise(const std::string& name) {
+exec::AggregateRegistrationResult registerBitwise(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  for (const auto& inputType : {"tinyint", "smallint", "integer", "bigint"}) {
+  std::vector<std::string> typeList{"tinyint", "smallint", "integer", "bigint"};
+  if (onlyPrestoSignatures) {
+    typeList = {"bigint"};
+  }
+  for (const auto& inputType : typeList) {
     signatures.push_back(exec::AggregateFunctionSignatureBuilder()
                              .returnType(inputType)
                              .intermediateType(inputType)
@@ -100,13 +108,15 @@ exec::AggregateRegistrationResult registerBitwise(const std::string& name) {
           case TypeKind::BIGINT:
             return std::make_unique<T<int64_t>>(resultType);
           default:
-            VELOX_CHECK(
-                false,
+            VELOX_UNREACHABLE(
                 "Unknown input type for {} aggregation {}",
                 name,
                 inputType->kindName());
         }
-      });
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/CMakeLists.txt b/velox/functions/lib/aggregates/CMakeLists.txt
index 7345da14bdb36..4322a1ac5720b 100644
--- a/velox/functions/lib/aggregates/CMakeLists.txt
+++ b/velox/functions/lib/aggregates/CMakeLists.txt
@@ -12,12 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_functions_aggregates SingleValueAccumulator.cpp
-                                       AverageAggregateBase.cpp ValueSet.cpp)
+velox_add_library(
+  velox_functions_aggregates
+  AverageAggregateBase.cpp
+  CentralMomentsAggregatesBase.cpp
+  Compare.cpp
+  MinMaxAggregateBase.cpp
+  SingleValueAccumulator.cpp
+  ValueList.cpp
+  ValueSet.cpp)
 
-target_link_libraries(velox_functions_aggregates velox_exec
-                      velox_presto_serializer Folly::folly)
+velox_link_libraries(velox_functions_aggregates velox_exec
+                     velox_presto_serializer Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
+elseif(${VELOX_BUILD_TEST_UTILS})
+  add_subdirectory(tests/utils)
 endif()
diff --git a/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.cpp b/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.cpp
new file mode 100644
index 0000000000000..4e972fb24795a
--- /dev/null
+++ b/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h"
+
+namespace facebook::velox::functions::aggregate {
+
+void checkAccumulatorRowType(
+    const TypePtr& type,
+    const std::string& errorMessage) {
+  VELOX_CHECK_EQ(type->kind(), TypeKind::ROW, "{}", errorMessage);
+  VELOX_CHECK_EQ(
+      type->childAt(kCentralMomentsIndices.count)->kind(),
+      TypeKind::BIGINT,
+      "{}",
+      errorMessage);
+  VELOX_CHECK_EQ(
+      type->childAt(kCentralMomentsIndices.m1)->kind(),
+      TypeKind::DOUBLE,
+      "{}",
+      errorMessage);
+  VELOX_CHECK_EQ(
+      type->childAt(kCentralMomentsIndices.m2)->kind(),
+      TypeKind::DOUBLE,
+      "{}",
+      errorMessage);
+  VELOX_CHECK_EQ(
+      type->childAt(kCentralMomentsIndices.m3)->kind(),
+      TypeKind::DOUBLE,
+      "{}",
+      errorMessage);
+  VELOX_CHECK_EQ(
+      type->childAt(kCentralMomentsIndices.m4)->kind(),
+      TypeKind::DOUBLE,
+      "{}",
+      errorMessage);
+}
+
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h b/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h
new file mode 100644
index 0000000000000..e44d0077e41d5
--- /dev/null
+++ b/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h
@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/Aggregate.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::functions::aggregate {
+
+// Indices into RowType representing intermediate results of skewness and
+// kurtosis. Columns appear in alphabetical order.
+struct CentralMomentsIndices {
+  int32_t count;
+  int32_t m1;
+  int32_t m2;
+  int32_t m3;
+  int32_t m4;
+};
+constexpr CentralMomentsIndices kCentralMomentsIndices{0, 1, 2, 3, 4};
+
+struct CentralMomentsAccumulator {
+  int64_t count() const {
+    return count_;
+  }
+
+  double m1() const {
+    return m1_;
+  }
+
+  double m2() const {
+    return m2_;
+  }
+
+  double m3() const {
+    return m3_;
+  }
+
+  double m4() const {
+    return m4_;
+  }
+
+  void update(double value) {
+    double oldCount = count();
+    count_ += 1;
+    double oldM1 = m1();
+    double oldM2 = m2();
+    double oldM3 = m3();
+    double delta = value - oldM1;
+    double deltaN = delta / count();
+    double deltaN2 = deltaN * deltaN;
+    double dm2 = delta * deltaN * oldCount;
+
+    m1_ += deltaN;
+    m2_ += dm2;
+    m3_ += dm2 * deltaN * (count() - 2) - 3 * deltaN * oldM2;
+    m4_ += dm2 * deltaN2 * (1.0 * count() * count() - 3.0 * count() + 3) +
+        6 * deltaN2 * oldM2 - 4 * deltaN * oldM3;
+  }
+
+  inline void merge(const CentralMomentsAccumulator& other) {
+    merge(other.count(), other.m1(), other.m2(), other.m3(), other.m4());
+  }
+
+  void merge(
+      double otherCount,
+      double otherM1,
+      double otherM2,
+      double otherM3,
+      double otherM4) {
+    if (otherCount == 0) {
+      return;
+    }
+    if (count_ == 0) {
+      count_ = otherCount;
+      m1_ = otherM1;
+      m2_ = otherM2;
+      m3_ = otherM3;
+      m4_ = otherM4;
+      return;
+    }
+
+    double oldCount = count();
+    count_ += otherCount;
+
+    double oldM1 = m1();
+    double oldM2 = m2();
+    double oldM3 = m3();
+    double delta = otherM1 - oldM1;
+    double delta2 = delta * delta;
+    double delta3 = delta * delta2;
+    double delta4 = delta2 * delta2;
+
+    m1_ = (oldCount * oldM1 + otherCount * otherM1) / count();
+    m2_ += otherM2 + delta2 * oldCount * otherCount / count();
+    m3_ += otherM3 +
+        delta3 * oldCount * otherCount * (oldCount - otherCount) /
+            (1.0 * count() * count()) +
+        3 * delta * (oldCount * otherM2 - otherCount * oldM2) / count();
+    m4_ += otherM4 +
+        delta4 * oldCount * otherCount *
+            (oldCount * oldCount - oldCount * otherCount +
+             otherCount * otherCount) /
+            (1.0 * count() * count() * count()) +
+        6 * delta2 *
+            (oldCount * oldCount * otherM2 + otherCount * otherCount * oldM2) /
+            (1.0 * count() * count()) +
+        4 * delta * (oldCount * otherM3 - otherCount * oldM3) / count();
+  }
+
+ private:
+  int64_t count_{0};
+  double m1_{0};
+  double m2_{0};
+  double m3_{0};
+  double m4_{0};
+};
+
+template <typename T>
+SimpleVector<T>* asSimpleVector(
+    const RowVector* rowVector,
+    int32_t childIndex) {
+  auto result = rowVector->childAt(childIndex)->as<SimpleVector<T>>();
+  VELOX_CHECK_NOT_NULL(result);
+  return result;
+}
+
+class CentralMomentsIntermediateInput {
+ public:
+  explicit CentralMomentsIntermediateInput(
+      const RowVector* rowVector,
+      const CentralMomentsIndices& indices = kCentralMomentsIndices)
+      : count_{asSimpleVector<int64_t>(rowVector, indices.count)},
+        m1_{asSimpleVector<double>(rowVector, indices.m1)},
+        m2_{asSimpleVector<double>(rowVector, indices.m2)},
+        m3_{asSimpleVector<double>(rowVector, indices.m3)},
+        m4_{asSimpleVector<double>(rowVector, indices.m4)} {}
+
+  void mergeInto(CentralMomentsAccumulator& accumulator, vector_size_t row) {
+    accumulator.merge(
+        count_->valueAt(row),
+        m1_->valueAt(row),
+        m2_->valueAt(row),
+        m3_->valueAt(row),
+        m4_->valueAt(row));
+  }
+
+ protected:
+  SimpleVector<int64_t>* count_;
+  SimpleVector<double>* m1_;
+  SimpleVector<double>* m2_;
+  SimpleVector<double>* m3_;
+  SimpleVector<double>* m4_;
+};
+
+template <typename T>
+T* mutableRawValues(const RowVector* rowVector, int32_t childIndex) {
+  return rowVector->childAt(childIndex)
+      ->as<FlatVector<T>>()
+      ->mutableRawValues();
+}
+
+class CentralMomentsIntermediateResult {
+ public:
+  explicit CentralMomentsIntermediateResult(
+      const RowVector* rowVector,
+      const CentralMomentsIndices& indices = kCentralMomentsIndices)
+      : count_{mutableRawValues<int64_t>(rowVector, indices.count)},
+        m1_{mutableRawValues<double>(rowVector, indices.m1)},
+        m2_{mutableRawValues<double>(rowVector, indices.m2)},
+        m3_{mutableRawValues<double>(rowVector, indices.m3)},
+        m4_{mutableRawValues<double>(rowVector, indices.m4)} {}
+
+  static std::string type() {
+    return "row(bigint,double,double,double,double)";
+  }
+
+  void set(vector_size_t row, const CentralMomentsAccumulator& accumulator) {
+    count_[row] = accumulator.count();
+    m1_[row] = accumulator.m1();
+    m2_[row] = accumulator.m2();
+    m3_[row] = accumulator.m3();
+    m4_[row] = accumulator.m4();
+  }
+
+ private:
+  int64_t* count_;
+  double* m1_;
+  double* m2_;
+  double* m3_;
+  double* m4_;
+};
+
+// T is the input type for partial aggregation, it can be integer, double or
+// float. Not used for final aggregation. TResultAccessor is the type of the
+// static struct that will access the result in a certain way from the
+// CentralMoments Accumulator.
+template <typename T, typename TResultAccessor>
+class CentralMomentsAggregatesBase : public exec::Aggregate {
+ public:
+  explicit CentralMomentsAggregatesBase(TypePtr resultType)
+      : exec::Aggregate(resultType) {}
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(CentralMomentsAccumulator);
+  }
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(CentralMomentsAccumulator);
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /* mayPushdown */) override {
+    decodedRaw_.decode(*args[0], rows);
+    if (decodedRaw_.isConstantMapping()) {
+      if (!decodedRaw_.isNullAt(0)) {
+        auto value = decodedRaw_.valueAt<T>(0);
+        rows.applyToSelected(
+            [&](vector_size_t i) { updateNonNullValue(groups[i], value); });
+      }
+    } else if (decodedRaw_.mayHaveNulls()) {
+      rows.applyToSelected([&](vector_size_t i) {
+        if (decodedRaw_.isNullAt(i)) {
+          return;
+        }
+        updateNonNullValue(groups[i], decodedRaw_.valueAt<T>(i));
+      });
+    } else if (!exec::Aggregate::numNulls_ && decodedRaw_.isIdentityMapping()) {
+      auto data = decodedRaw_.data<T>();
+      rows.applyToSelected([&](vector_size_t i) {
+        updateNonNullValue<false>(groups[i], data[i]);
+      });
+    } else {
+      rows.applyToSelected([&](vector_size_t i) {
+        updateNonNullValue(groups[i], decodedRaw_.valueAt<T>(i));
+      });
+    }
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedRaw_.decode(*args[0], rows);
+
+    if (decodedRaw_.isConstantMapping()) {
+      if (!decodedRaw_.isNullAt(0)) {
+        auto value = decodedRaw_.valueAt<T>(0);
+        rows.applyToSelected(
+            [&](vector_size_t i) { updateNonNullValue(group, value); });
+      }
+    } else if (decodedRaw_.mayHaveNulls()) {
+      rows.applyToSelected([&](vector_size_t i) {
+        if (!decodedRaw_.isNullAt(i)) {
+          updateNonNullValue(group, decodedRaw_.valueAt<T>(i));
+        }
+      });
+    } else if (!exec::Aggregate::numNulls_ && decodedRaw_.isIdentityMapping()) {
+      auto data = decodedRaw_.data<T>();
+      CentralMomentsAccumulator accData;
+      rows.applyToSelected([&](vector_size_t i) { accData.update(data[i]); });
+      updateNonNullValue<false>(group, accData);
+    } else {
+      CentralMomentsAccumulator accData;
+      rows.applyToSelected(
+          [&](vector_size_t i) { accData.update(decodedRaw_.valueAt<T>(i)); });
+      updateNonNullValue(group, accData);
+    }
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /* mayPushdown */) override {
+    decodedPartial_.decode(*args[0], rows);
+
+    auto baseRowVector = dynamic_cast<const RowVector*>(decodedPartial_.base());
+    CentralMomentsIntermediateInput input{baseRowVector};
+
+    if (decodedPartial_.isConstantMapping()) {
+      if (!decodedPartial_.isNullAt(0)) {
+        auto decodedIndex = decodedPartial_.index(0);
+        rows.applyToSelected([&](vector_size_t i) {
+          exec::Aggregate::clearNull(groups[i]);
+          input.mergeInto(*accumulator(groups[i]), decodedIndex);
+        });
+      }
+    } else if (decodedPartial_.mayHaveNulls()) {
+      rows.applyToSelected([&](vector_size_t i) {
+        if (decodedPartial_.isNullAt(i)) {
+          return;
+        }
+        auto decodedIndex = decodedPartial_.index(i);
+        exec::Aggregate::clearNull(groups[i]);
+        input.mergeInto(*accumulator(groups[i]), decodedIndex);
+      });
+    } else {
+      rows.applyToSelected([&](vector_size_t i) {
+        auto decodedIndex = decodedPartial_.index(i);
+        exec::Aggregate::clearNull(groups[i]);
+        input.mergeInto(*accumulator(groups[i]), decodedIndex);
+      });
+    }
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /* mayPushdown */) override {
+    decodedPartial_.decode(*args[0], rows);
+    auto baseRowVector = dynamic_cast<const RowVector*>(decodedPartial_.base());
+    CentralMomentsIntermediateInput input{baseRowVector};
+
+    if (decodedPartial_.isConstantMapping()) {
+      if (!decodedPartial_.isNullAt(0)) {
+        auto decodedIndex = decodedPartial_.index(0);
+        CentralMomentsAccumulator accData;
+        rows.applyToSelected(
+            [&](vector_size_t i) { input.mergeInto(accData, decodedIndex); });
+        updateNonNullValue(group, accData);
+      }
+    } else if (decodedPartial_.mayHaveNulls()) {
+      rows.applyToSelected([&](vector_size_t i) {
+        if (decodedPartial_.isNullAt(i)) {
+          return;
+        }
+        auto decodedIndex = decodedPartial_.index(i);
+        exec::Aggregate::clearNull(group);
+        input.mergeInto(*accumulator(group), decodedIndex);
+      });
+    } else {
+      CentralMomentsAccumulator accData;
+      rows.applyToSelected([&](vector_size_t i) {
+        auto decodedIndex = decodedPartial_.index(i);
+        input.mergeInto(accData, decodedIndex);
+      });
+      updateNonNullValue(group, accData);
+    }
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto vector = (*result)->as<FlatVector<double>>();
+    VELOX_CHECK(vector);
+    vector->resize(numGroups);
+    uint64_t* rawNulls = getRawNulls(vector);
+
+    double* rawValues = vector->mutableRawValues();
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        vector->setNull(i, true);
+      } else {
+        auto* accData = accumulator(group);
+        if (TResultAccessor::hasResult(*accData)) {
+          clearNull(rawNulls, i);
+          rawValues[i] = TResultAccessor::result(*accData);
+        } else {
+          vector->setNull(i, true);
+        }
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto rowVector = (*result)->as<RowVector>();
+    rowVector->resize(numGroups);
+    for (auto& child : rowVector->children()) {
+      child->resize(numGroups);
+    }
+
+    uint64_t* rawNulls = getRawNulls(rowVector);
+
+    CentralMomentsIntermediateResult centralMomentsResult{rowVector};
+
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        rowVector->setNull(i, true);
+      } else {
+        clearNull(rawNulls, i);
+        centralMomentsResult.set(i, *accumulator(group));
+      }
+    }
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) CentralMomentsAccumulator();
+    }
+  }
+
+ private:
+  template <bool tableHasNulls = true>
+  inline void updateNonNullValue(char* group, T value) {
+    if constexpr (tableHasNulls) {
+      exec::Aggregate::clearNull(group);
+    }
+    CentralMomentsAccumulator* accData = accumulator(group);
+    accData->update((double)value);
+  }
+
+  template <bool tableHasNulls = true>
+  inline void updateNonNullValue(
+      char* group,
+      const CentralMomentsAccumulator& accData) {
+    if constexpr (tableHasNulls) {
+      exec::Aggregate::clearNull(group);
+    }
+    CentralMomentsAccumulator* thisAccData = accumulator(group);
+    thisAccData->merge(accData);
+  }
+
+  inline CentralMomentsAccumulator* accumulator(char* group) {
+    return exec::Aggregate::value<CentralMomentsAccumulator>(group);
+  }
+
+  DecodedVector decodedRaw_;
+  DecodedVector decodedPartial_;
+};
+
+void checkAccumulatorRowType(
+    const TypePtr& type,
+    const std::string& errorMessage);
+
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/Compare.cpp b/velox/functions/lib/aggregates/Compare.cpp
new file mode 100644
index 0000000000000..5595be2105c1e
--- /dev/null
+++ b/velox/functions/lib/aggregates/Compare.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/aggregates/Compare.h"
+
+namespace facebook::velox::functions::aggregate {
+
+int32_t compare(
+    const SingleValueAccumulator* accumulator,
+    const DecodedVector& decoded,
+    vector_size_t index,
+    CompareFlags::NullHandlingMode nullHandlingMode) {
+  static const CompareFlags kCompareFlags{
+      true, // nullsFirst
+      true, // ascending
+      false, // equalsOnly
+      nullHandlingMode};
+
+  auto result = accumulator->compare(decoded, index, kCompareFlags);
+  VELOX_USER_CHECK(
+      result.has_value(),
+      fmt::format(
+          "{} comparison not supported for values that contain nulls",
+          mapTypeKindToName(decoded.base()->typeKind())));
+  return result.value();
+}
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/Compare.h b/velox/functions/lib/aggregates/Compare.h
new file mode 100644
index 0000000000000..7b648d09dd08b
--- /dev/null
+++ b/velox/functions/lib/aggregates/Compare.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/aggregates/SingleValueAccumulator.h"
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox::functions::aggregate {
+
+/// Compare the new value of the DecodedVector at the given index with the value
+/// stored in the SingleValueAccumulator. Returns 0 if stored and new values are
+/// equal; <0 if stored value is less then new value; >0 if stored value is
+/// greater than new value.
+///
+/// If nullHandlingMode is NullAsValue, nested nulls are handled as value. If
+/// nullHandlingMode is StopAtNull, it will throw an exception when complex
+/// type values contain nulls.
+/// Note, The default nullHandlingMode in Presto is StopAtNull while the
+/// default nullHandlingMode is NullAsValue in Spark.
+int32_t compare(
+    const velox::functions::aggregate::SingleValueAccumulator* accumulator,
+    const DecodedVector& decoded,
+    vector_size_t index,
+    CompareFlags::NullHandlingMode nullHandlingMode);
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/DecimalAggregate.h b/velox/functions/lib/aggregates/DecimalAggregate.h
index 695ec8f5d8ab7..def5c81b52e0e 100644
--- a/velox/functions/lib/aggregates/DecimalAggregate.h
+++ b/velox/functions/lib/aggregates/DecimalAggregate.h
@@ -74,22 +74,13 @@ class DecimalAggregate : public exec::Aggregate {
   explicit DecimalAggregate(TypePtr resultType) : exec::Aggregate(resultType) {}
 
   int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(DecimalAggregate);
+    return sizeof(LongDecimalWithOverflowState);
   }
 
   int32_t accumulatorAlignmentSize() const override {
     return static_cast<int32_t>(sizeof(int128_t));
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) LongDecimalWithOverflowState();
-    }
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -132,9 +123,6 @@ class DecimalAggregate : public exec::Aggregate {
     decodedRaw_.decode(*args[0], rows);
     if (decodedRaw_.isConstantMapping()) {
       if (!decodedRaw_.isNullAt(0)) {
-        const auto numRows = rows.countSelected();
-        int64_t overflow = 0;
-        int128_t totalSum{0};
         auto value = decodedRaw_.valueAt<TInputType>(0);
         rows.template applyToSelected([&](vector_size_t i) {
           updateNonNullValue(group, TResultType(value));
@@ -329,6 +317,16 @@ class DecimalAggregate : public exec::Aggregate {
     accumulator->count += 1;
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) LongDecimalWithOverflowState();
+    }
+  }
+
  private:
   inline LongDecimalWithOverflowState* decimalAccumulator(char* group) {
     return exec::Aggregate::value<LongDecimalWithOverflowState>(group);
diff --git a/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp b/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp
new file mode 100644
index 0000000000000..1499cbd74fefb
--- /dev/null
+++ b/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp
@@ -0,0 +1,639 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/aggregates/MinMaxAggregateBase.h"
+
+#include <limits>
+#include "velox/exec/AggregationHook.h"
+#include "velox/functions/lib/CheckNestedNulls.h"
+#include "velox/functions/lib/aggregates/Compare.h"
+#include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
+#include "velox/functions/lib/aggregates/SingleValueAccumulator.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions::aggregate {
+
+namespace {
+
+template <typename T>
+struct MinMaxTrait : public std::numeric_limits<T> {};
+
+template <typename T>
+class MinMaxAggregate : public SimpleNumericAggregate<T, T, T> {
+  using BaseAggregate = SimpleNumericAggregate<T, T, T>;
+
+ public:
+  explicit MinMaxAggregate(TypePtr resultType, TimestampPrecision precision)
+      : BaseAggregate(resultType), timestampPrecision_(precision) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(T);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    if constexpr (std::is_same_v<T, int128_t>) {
+      // Override 'accumulatorAlignmentSize' for UnscaledLongDecimal values as
+      // it uses int128_t type. Some CPUs don't support misaligned access to
+      // int128_t type.
+      return static_cast<int32_t>(sizeof(int128_t));
+    } else {
+      return 1;
+    }
+  }
+
+  bool supportsToIntermediate() const override {
+    return true;
+  }
+
+  void toIntermediate(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      VectorPtr& result) const override {
+    this->singleInputAsIntermediate(rows, args, result);
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    if constexpr (std::is_same_v<T, Timestamp>) {
+      // Truncate timestamps to corresponding precision.
+      BaseAggregate::template doExtractValues<Timestamp>(
+          groups, numGroups, result, [&](char* group) {
+            auto ts =
+                *BaseAggregate::Aggregate::template value<Timestamp>(group);
+            return Timestamp::truncate(ts, timestampPrecision_);
+          });
+    } else {
+      BaseAggregate::template doExtractValues<T>(
+          groups, numGroups, result, [&](char* group) {
+            return *BaseAggregate::Aggregate::template value<T>(group);
+          });
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    BaseAggregate::template doExtractValues<T>(
+        groups, numGroups, result, [&](char* group) {
+          return *BaseAggregate::Aggregate::template value<T>(group);
+        });
+  }
+
+ private:
+  const TimestampPrecision timestampPrecision_;
+};
+
+template <typename T>
+class MaxAggregate : public MinMaxAggregate<T> {
+  using BaseAggregate = SimpleNumericAggregate<T, T, T>;
+
+ public:
+  explicit MaxAggregate(
+      TypePtr resultType,
+      TimestampPrecision precision = TimestampPrecision::kMilliseconds)
+      : MinMaxAggregate<T>(resultType, precision) {}
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    if constexpr (BaseAggregate::template kMayPushdown<T>) {
+      if (mayPushdown && args[0]->isLazy()) {
+        BaseAggregate::template pushdown<
+            velox::aggregate::MinMaxHook<T, false>>(groups, rows, args[0]);
+        return;
+      }
+    } else {
+      mayPushdown = false;
+    }
+    BaseAggregate::template updateGroups<true, T>(
+        groups, rows, args[0], updateGroup, mayPushdown);
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    addRawInput(groups, rows, args, mayPushdown);
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    BaseAggregate::updateOneGroup(
+        group,
+        rows,
+        args[0],
+        updateGroup,
+        [](T& result, T value, int /* unused */) { result = value; },
+        mayPushdown,
+        kInitialValue_);
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    addSingleGroupRawInput(group, rows, args, mayPushdown);
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      *exec::Aggregate::value<T>(groups[i]) = kInitialValue_;
+    }
+  }
+
+  static inline void updateGroup(T& result, T value) {
+    if constexpr (std::is_floating_point_v<T>) {
+      if (util::floating_point::NaNAwareLessThan<T>{}(result, value)) {
+        result = value;
+      }
+    } else {
+      if (result < value) {
+        result = value;
+      }
+    }
+  }
+
+ private:
+  static const T kInitialValue_;
+};
+
+template <typename T>
+const T MaxAggregate<T>::kInitialValue_ = MinMaxTrait<T>::lowest();
+
+// Negative INF is the smallest value of floating point type.
+template <>
+const float MaxAggregate<float>::kInitialValue_ =
+    -1 * MinMaxTrait<float>::infinity();
+
+template <>
+const double MaxAggregate<double>::kInitialValue_ =
+    -1 * MinMaxTrait<double>::infinity();
+
+template <typename T>
+class MinAggregate : public MinMaxAggregate<T> {
+  using BaseAggregate = SimpleNumericAggregate<T, T, T>;
+
+ public:
+  explicit MinAggregate(
+      TypePtr resultType,
+      TimestampPrecision precision = TimestampPrecision::kMilliseconds)
+      : MinMaxAggregate<T>(resultType, precision) {}
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    if constexpr (BaseAggregate::template kMayPushdown<T>) {
+      if (mayPushdown && args[0]->isLazy()) {
+        BaseAggregate::template pushdown<velox::aggregate::MinMaxHook<T, true>>(
+            groups, rows, args[0]);
+        return;
+      }
+    } else {
+      mayPushdown = false;
+    }
+    BaseAggregate::template updateGroups<true, T>(
+        groups, rows, args[0], updateGroup, mayPushdown);
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    addRawInput(groups, rows, args, mayPushdown);
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    BaseAggregate::updateOneGroup(
+        group,
+        rows,
+        args[0],
+        updateGroup,
+        [](T& result, T value, int /* unused */) { result = value; },
+        mayPushdown,
+        kInitialValue_);
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    addSingleGroupRawInput(group, rows, args, mayPushdown);
+  }
+
+ protected:
+  static inline void updateGroup(T& result, T value) {
+    if constexpr (std::is_floating_point_v<T>) {
+      if (util::floating_point::NaNAwareGreaterThan<T>{}(result, value)) {
+        result = value;
+      }
+    } else {
+      if (result > value) {
+        result = value;
+      }
+    }
+  }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      *exec::Aggregate::value<T>(groups[i]) = kInitialValue_;
+    }
+  }
+
+ private:
+  static const T kInitialValue_;
+};
+
+template <typename T>
+const T MinAggregate<T>::kInitialValue_ = MinMaxTrait<T>::max();
+
+// In velox, NaN is considered larger than infinity for floating point types.
+template <>
+const float MinAggregate<float>::kInitialValue_ =
+    MinMaxTrait<float>::quiet_NaN();
+
+template <>
+const double MinAggregate<double>::kInitialValue_ =
+    MinMaxTrait<double>::quiet_NaN();
+
+class NonNumericMinMaxAggregateBase : public exec::Aggregate {
+ public:
+  explicit NonNumericMinMaxAggregateBase(
+      const TypePtr& resultType,
+      bool throwOnNestedNulls)
+      : exec::Aggregate(resultType), throwOnNestedNulls_(throwOnNestedNulls) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(SingleValueAccumulator);
+  }
+
+  bool supportsToIntermediate() const override {
+    return true;
+  }
+
+  void toIntermediate(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      VectorPtr& result) const override {
+    const auto& input = args[0];
+
+    if (throwOnNestedNulls_) {
+      DecodedVector decoded(*input, rows, true);
+      auto indices = decoded.indices();
+      rows.applyToSelected([&](vector_size_t i) {
+        velox::functions::checkNestedNulls(
+            decoded, indices, i, throwOnNestedNulls_);
+      });
+    }
+
+    if (rows.isAllSelected()) {
+      result = input;
+      return;
+    }
+
+    auto* pool = allocator_->pool();
+
+    // Set result to NULL for rows that are masked out.
+    BufferPtr nulls = allocateNulls(rows.size(), pool, bits::kNull);
+    rows.clearNulls(nulls);
+
+    BufferPtr indices = allocateIndices(rows.size(), pool);
+    auto* rawIndices = indices->asMutable<vector_size_t>();
+    std::iota(rawIndices, rawIndices + rows.size(), 0);
+
+    result = BaseVector::wrapInDictionary(nulls, indices, rows.size(), input);
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    VELOX_CHECK(result);
+    (*result)->resize(numGroups);
+
+    uint64_t* rawNulls = nullptr;
+    if ((*result)->mayHaveNulls()) {
+      BufferPtr& nulls = (*result)->mutableNulls((*result)->size());
+      rawNulls = nulls->asMutable<uint64_t>();
+    }
+
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      auto accumulator = value<SingleValueAccumulator>(group);
+      if (!accumulator->hasValue()) {
+        (*result)->setNull(i, true);
+      } else {
+        if (rawNulls) {
+          bits::clearBit(rawNulls, i);
+        }
+        accumulator->read(*result, i);
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    // partial and final aggregations are the same
+    extractValues(groups, numGroups, result);
+  }
+
+ protected:
+  template <
+      typename TCompareTest,
+      CompareFlags::NullHandlingMode nullHandlingMode>
+  void doUpdate(
+      char** groups,
+      const SelectivityVector& rows,
+      const VectorPtr& arg,
+      TCompareTest compareTest) {
+    DecodedVector decoded(*arg, rows, true);
+    auto indices = decoded.indices();
+    auto baseVector = decoded.base();
+
+    if (decoded.isConstantMapping() && decoded.isNullAt(0)) {
+      // nothing to do; all values are nulls
+      return;
+    }
+
+    rows.applyToSelected([&](vector_size_t i) {
+      if (velox::functions::checkNestedNulls(
+              decoded, indices, i, throwOnNestedNulls_)) {
+        return;
+      }
+
+      auto accumulator = value<SingleValueAccumulator>(groups[i]);
+      if (!accumulator->hasValue() ||
+          compareTest(compare(accumulator, decoded, i, nullHandlingMode))) {
+        accumulator->write(baseVector, indices[i], allocator_);
+      }
+    });
+  }
+
+  template <
+      typename TCompareTest,
+      CompareFlags::NullHandlingMode nullHandlingMode>
+  void doUpdateSingleGroup(
+      char* group,
+      const SelectivityVector& rows,
+      const VectorPtr& arg,
+      TCompareTest compareTest) {
+    DecodedVector decoded(*arg, rows, true);
+    auto indices = decoded.indices();
+    auto baseVector = decoded.base();
+
+    if (decoded.isConstantMapping()) {
+      if (velox::functions::checkNestedNulls(
+              decoded, indices, 0, throwOnNestedNulls_)) {
+        return;
+      }
+
+      auto accumulator = value<SingleValueAccumulator>(group);
+      if (!accumulator->hasValue() ||
+          compareTest(compare(accumulator, decoded, 0, nullHandlingMode))) {
+        accumulator->write(baseVector, indices[0], allocator_);
+      }
+      return;
+    }
+
+    auto accumulator = value<SingleValueAccumulator>(group);
+    rows.applyToSelected([&](vector_size_t i) {
+      if (velox::functions::checkNestedNulls(
+              decoded, indices, i, throwOnNestedNulls_)) {
+        return;
+      }
+      if (!accumulator->hasValue() ||
+          compareTest(compare(accumulator, decoded, i, nullHandlingMode))) {
+        accumulator->write(baseVector, indices[i], allocator_);
+      }
+    });
+  }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) SingleValueAccumulator();
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        value<SingleValueAccumulator>(group)->destroy(allocator_);
+      }
+    }
+  }
+
+ private:
+  const bool throwOnNestedNulls_;
+};
+
+template <CompareFlags::NullHandlingMode nullHandlingMode>
+class NonNumericMaxAggregate : public NonNumericMinMaxAggregateBase {
+ public:
+  explicit NonNumericMaxAggregate(
+      const TypePtr& resultType,
+      bool throwOnNestedNulls)
+      : NonNumericMinMaxAggregateBase(resultType, throwOnNestedNulls) {}
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    doUpdate<std::function<bool(int32_t)>, nullHandlingMode>(
+        groups, rows, args[0], [](int32_t compareResult) {
+          return compareResult < 0;
+        });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    addRawInput(groups, rows, args, mayPushdown);
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    doUpdateSingleGroup<std::function<bool(int32_t)>, nullHandlingMode>(
+        group, rows, args[0], [](int32_t compareResult) {
+          return compareResult < 0;
+        });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    addSingleGroupRawInput(group, rows, args, mayPushdown);
+  }
+};
+
+template <CompareFlags::NullHandlingMode nullHandlingMode>
+class NonNumericMinAggregate : public NonNumericMinMaxAggregateBase {
+ public:
+  explicit NonNumericMinAggregate(
+      const TypePtr& resultType,
+      bool throwOnNestedNulls)
+      : NonNumericMinMaxAggregateBase(resultType, throwOnNestedNulls) {}
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    doUpdate<std::function<bool(int32_t)>, nullHandlingMode>(
+        groups, rows, args[0], [](int32_t compareResult) {
+          return compareResult > 0;
+        });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    addRawInput(groups, rows, args, mayPushdown);
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    doUpdateSingleGroup<std::function<bool(int32_t)>, nullHandlingMode>(
+        group, rows, args[0], [](int32_t compareResult) {
+          return compareResult > 0;
+        });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    addSingleGroupRawInput(group, rows, args, mayPushdown);
+  }
+};
+
+template <
+    template <typename T>
+    class TNumeric,
+    template <CompareFlags::NullHandlingMode nullHandlingMode>
+    typename TNonNumeric>
+exec::AggregateFunctionFactory getMinMaxFunctionFactoryInternal(
+    const std::string& name,
+    CompareFlags::NullHandlingMode nullHandlingMode,
+    TimestampPrecision precision) {
+  auto factory = [name, nullHandlingMode, precision](
+                     core::AggregationNode::Step step,
+                     std::vector<TypePtr> argTypes,
+                     const TypePtr& resultType,
+                     const core::QueryConfig& /*config*/)
+      -> std::unique_ptr<exec::Aggregate> {
+    auto inputType = argTypes[0];
+    switch (inputType->kind()) {
+      case TypeKind::BOOLEAN:
+        return std::make_unique<TNumeric<bool>>(resultType);
+      case TypeKind::TINYINT:
+        return std::make_unique<TNumeric<int8_t>>(resultType);
+      case TypeKind::SMALLINT:
+        return std::make_unique<TNumeric<int16_t>>(resultType);
+      case TypeKind::INTEGER:
+        return std::make_unique<TNumeric<int32_t>>(resultType);
+      case TypeKind::BIGINT:
+        return std::make_unique<TNumeric<int64_t>>(resultType);
+      case TypeKind::REAL:
+        return std::make_unique<TNumeric<float>>(resultType);
+      case TypeKind::DOUBLE:
+        return std::make_unique<TNumeric<double>>(resultType);
+      case TypeKind::TIMESTAMP:
+        return std::make_unique<TNumeric<Timestamp>>(resultType, precision);
+      case TypeKind::HUGEINT:
+        return std::make_unique<TNumeric<int128_t>>(resultType);
+      case TypeKind::VARBINARY:
+        [[fallthrough]];
+      case TypeKind::VARCHAR:
+        return std::make_unique<
+            TNonNumeric<CompareFlags::NullHandlingMode::kNullAsIndeterminate>>(
+            inputType, false);
+      case TypeKind::ARRAY:
+        [[fallthrough]];
+      case TypeKind::ROW:
+        if (nullHandlingMode == CompareFlags::NullHandlingMode::kNullAsValue) {
+          return std::make_unique<
+              TNonNumeric<CompareFlags::NullHandlingMode::kNullAsValue>>(
+              inputType, false);
+        } else {
+          return std::make_unique<TNonNumeric<
+              CompareFlags::NullHandlingMode::kNullAsIndeterminate>>(
+              inputType, true);
+        }
+      case TypeKind::UNKNOWN:
+        return std::make_unique<TNumeric<UnknownValue>>(resultType);
+      default:
+        VELOX_UNREACHABLE(
+            "Unknown input type for {} aggregation {}",
+            name,
+            inputType->kindName());
+    }
+  };
+  return factory;
+}
+
+} // namespace
+
+exec::AggregateFunctionFactory getMinFunctionFactory(
+    const std::string& name,
+    CompareFlags::NullHandlingMode nullHandlingMode,
+    TimestampPrecision precision) {
+  return getMinMaxFunctionFactoryInternal<MinAggregate, NonNumericMinAggregate>(
+      name, nullHandlingMode, precision);
+}
+
+exec::AggregateFunctionFactory getMaxFunctionFactory(
+    const std::string& name,
+    CompareFlags::NullHandlingMode nullHandlingMode,
+    TimestampPrecision precision) {
+  return getMinMaxFunctionFactoryInternal<MaxAggregate, NonNumericMaxAggregate>(
+      name, nullHandlingMode, precision);
+}
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/MinMaxAggregateBase.h b/velox/functions/lib/aggregates/MinMaxAggregateBase.h
new file mode 100644
index 0000000000000..d7524bda95bdb
--- /dev/null
+++ b/velox/functions/lib/aggregates/MinMaxAggregateBase.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/Aggregate.h"
+
+namespace facebook::velox::functions::aggregate {
+
+/// Min and max functions in Presto and Spark have different semantics:
+/// 1. Nested NULLs are compared as values in Spark and as "unknown value" in
+/// Presto.
+/// 2. The timestamp type represents a time instant in microsecond precision in
+/// Spark, but millisecond precision in Presto.
+/// Parameters 'nullHandlingMode' and 'precision' allow to register min and max
+/// functions with different behaviors.
+exec::AggregateFunctionFactory getMinFunctionFactory(
+    const std::string& name,
+    CompareFlags::NullHandlingMode nullHandlingMode,
+    TimestampPrecision precision);
+
+exec::AggregateFunctionFactory getMaxFunctionFactory(
+    const std::string& name,
+    CompareFlags::NullHandlingMode nullHandlingMode,
+    TimestampPrecision precision);
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h b/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
index 32ada3e873e29..e2ad9b682c836 100644
--- a/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
+++ b/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
@@ -17,29 +17,18 @@
 
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/ContainerRowSerde.h"
+#include "velox/functions/lib/CheckNestedNulls.h"
 #include "velox/functions/lib/aggregates/SingleValueAccumulator.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::functions::aggregate {
 
-namespace {
-inline void resizeRowVectorAndChildren(
-    RowVector& rowVector,
-    vector_size_t size) {
-  rowVector.resize(size);
-  for (auto& child : rowVector.children()) {
-    child->resize(size);
-  }
-}
-} // namespace
-
 template <typename T>
 constexpr bool isNumeric() {
   return std::is_same_v<T, bool> || std::is_same_v<T, int8_t> ||
       std::is_same_v<T, int16_t> || std::is_same_v<T, int32_t> ||
       std::is_same_v<T, int64_t> || std::is_same_v<T, float> ||
-      std::is_same_v<T, double> || std::is_same_v<T, Date> ||
-      std::is_same_v<T, Timestamp>;
+      std::is_same_v<T, double> || std::is_same_v<T, Timestamp>;
 }
 
 template <typename T, typename TAccumulator>
@@ -106,37 +95,16 @@ class MinMaxByAggregateBase : public exec::Aggregate {
   using ComparisonAccumulatorType =
       typename AccumulatorTypeTraits<U>::AccumulatorType;
 
-  explicit MinMaxByAggregateBase(TypePtr resultType)
-      : exec::Aggregate(resultType) {}
+  explicit MinMaxByAggregateBase(
+      TypePtr resultType,
+      bool throwOnNestedNulls = false)
+      : exec::Aggregate(resultType), throwOnNestedNulls_(throwOnNestedNulls) {}
 
   int32_t accumulatorFixedWidthSize() const override {
     return sizeof(ValueAccumulatorType) + sizeof(ComparisonAccumulatorType) +
         sizeof(bool);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (const vector_size_t i : indices) {
-      auto group = groups[i];
-      valueIsNull(group) = true;
-
-      if constexpr (!isNumeric<T>()) {
-        new (group + offset_) SingleValueAccumulator();
-      } else {
-        *value(group) = ValueAccumulatorType();
-      }
-
-      if constexpr (isNumeric<U>()) {
-        *comparisonValue(group) = ComparisonAccumulatorType();
-      } else {
-        new (group + offset_ + sizeof(ValueAccumulatorType))
-            SingleValueAccumulator();
-      }
-    }
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -242,10 +210,10 @@ class MinMaxByAggregateBase : public exec::Aggregate {
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto rowVector = (*result)->as<RowVector>();
+    rowVector->resize(numGroups);
+
     auto valueVector = rowVector->childAt(0);
     auto comparisonVector = rowVector->childAt(1);
-
-    resizeRowVectorAndChildren(*rowVector, numGroups);
     uint64_t* rawNulls = getRawNulls(rowVector);
 
     T* rawValues = nullptr;
@@ -295,17 +263,6 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     }
   }
 
-  void destroy(folly::Range<char**> groups) override {
-    for (auto group : groups) {
-      if constexpr (!isNumeric<T>()) {
-        value(group)->destroy(allocator_);
-      }
-      if constexpr (!isNumeric<U>()) {
-        comparisonValue(group)->destroy(allocator_);
-      }
-    }
-  }
-
  protected:
   template <typename MayUpdate>
   void addRawInput(
@@ -324,9 +281,12 @@ class MinMaxByAggregateBase : public exec::Aggregate {
         decodedComparison_.isNullAt(0)) {
       return;
     }
+
+    const auto* indices = decodedComparison_.indices();
     if (decodedValue_.mayHaveNulls() || decodedComparison_.mayHaveNulls()) {
       rows.applyToSelected([&](vector_size_t i) {
-        if (decodedComparison_.isNullAt(i)) {
+        if (checkNestedNulls(
+                decodedComparison_, indices, i, throwOnNestedNulls_)) {
           return;
         }
         updateValues(
@@ -339,6 +299,9 @@ class MinMaxByAggregateBase : public exec::Aggregate {
       });
     } else {
       rows.applyToSelected([&](vector_size_t i) {
+        if (throwOnNestedNulls_) {
+          checkNestedNulls(decodedComparison_, indices, i, throwOnNestedNulls_);
+        }
         updateValues(
             groups[i], decodedValue_, decodedComparison_, i, false, mayUpdate);
       });
@@ -401,9 +364,12 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     // the maximum.
     decodedValue_.decode(*args[0], rows);
     decodedComparison_.decode(*args[1], rows);
+    const auto* indices = decodedComparison_.indices();
+
     if (decodedValue_.isConstantMapping() &&
         decodedComparison_.isConstantMapping()) {
-      if (decodedComparison_.isNullAt(0)) {
+      if (checkNestedNulls(
+              decodedComparison_, indices, 0, throwOnNestedNulls_)) {
         return;
       }
       updateValues(
@@ -416,7 +382,8 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     } else if (
         decodedValue_.mayHaveNulls() || decodedComparison_.mayHaveNulls()) {
       rows.applyToSelected([&](vector_size_t i) {
-        if (decodedComparison_.isNullAt(i)) {
+        if (checkNestedNulls(
+                decodedComparison_, indices, i, throwOnNestedNulls_)) {
           return;
         }
         updateValues(
@@ -429,6 +396,9 @@ class MinMaxByAggregateBase : public exec::Aggregate {
       });
     } else {
       rows.applyToSelected([&](vector_size_t i) {
+        if (throwOnNestedNulls_) {
+          checkNestedNulls(decodedComparison_, indices, i, throwOnNestedNulls_);
+        }
         updateValues(
             group, decodedValue_, decodedComparison_, i, false, mayUpdate);
       });
@@ -492,6 +462,42 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     }
   }
 
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (const vector_size_t i : indices) {
+      auto group = groups[i];
+      valueIsNull(group) = true;
+
+      if constexpr (!isNumeric<T>()) {
+        new (group + offset_) SingleValueAccumulator();
+      } else {
+        *value(group) = ValueAccumulatorType();
+      }
+
+      if constexpr (isNumeric<U>()) {
+        *comparisonValue(group) = ComparisonAccumulatorType();
+      } else {
+        new (group + offset_ + sizeof(ValueAccumulatorType))
+            SingleValueAccumulator();
+      }
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        if constexpr (!isNumeric<T>()) {
+          value(group)->destroy(allocator_);
+        }
+        if constexpr (!isNumeric<U>()) {
+          comparisonValue(group)->destroy(allocator_);
+        }
+      }
+    }
+  }
+
  private:
   template <typename MayUpdate>
   inline void updateValues(
@@ -530,6 +536,7 @@ class MinMaxByAggregateBase : public exec::Aggregate {
         sizeof(ComparisonAccumulatorType));
   }
 
+  const bool throwOnNestedNulls_;
   DecodedVector decodedValue_;
   DecodedVector decodedComparison_;
   DecodedVector decodedIntermediateResult_;
@@ -550,7 +557,8 @@ template <
 std::unique_ptr<exec::Aggregate> create(
     TypePtr resultType,
     TypePtr compareType,
-    const std::string& errorMessage) {
+    const std::string& errorMessage,
+    bool throwOnNestedNulls = false) {
   switch (compareType->kind()) {
     case TypeKind::BOOLEAN:
       return std::make_unique<Aggregate<W, bool, isMaxFunc, Comparator>>(
@@ -573,6 +581,9 @@ std::unique_ptr<exec::Aggregate> create(
     case TypeKind::DOUBLE:
       return std::make_unique<Aggregate<W, double, isMaxFunc, Comparator>>(
           resultType);
+    case TypeKind::HUGEINT:
+      return std::make_unique<Aggregate<W, int128_t, isMaxFunc, Comparator>>(
+          resultType);
     case TypeKind::VARBINARY:
       [[fallthrough]];
     case TypeKind::VARCHAR:
@@ -587,7 +598,10 @@ std::unique_ptr<exec::Aggregate> create(
       [[fallthrough]];
     case TypeKind::ROW:
       return std::make_unique<Aggregate<W, ComplexType, isMaxFunc, Comparator>>(
-          resultType);
+          resultType, throwOnNestedNulls);
+    case TypeKind::UNKNOWN:
+      return std::make_unique<
+          Aggregate<W, UnknownValue, isMaxFunc, Comparator>>(resultType);
     default:
       VELOX_FAIL("{}", errorMessage);
       return nullptr;
@@ -609,44 +623,51 @@ std::unique_ptr<exec::Aggregate> create(
     TypePtr resultType,
     TypePtr valueType,
     TypePtr compareType,
-    const std::string& errorMessage) {
+    const std::string& errorMessage,
+    bool throwOnNestedNulls = false) {
   switch (valueType->kind()) {
     case TypeKind::BOOLEAN:
       return create<Aggregate, isMaxFunc, Comparator, bool>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     case TypeKind::TINYINT:
       return create<Aggregate, isMaxFunc, Comparator, int8_t>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     case TypeKind::SMALLINT:
       return create<Aggregate, isMaxFunc, Comparator, int16_t>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     case TypeKind::INTEGER:
       return create<Aggregate, isMaxFunc, Comparator, int32_t>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     case TypeKind::BIGINT:
       return create<Aggregate, isMaxFunc, Comparator, int64_t>(
+          resultType, compareType, errorMessage, throwOnNestedNulls);
+    case TypeKind::HUGEINT:
+      return create<Aggregate, isMaxFunc, Comparator, int128_t>(
           resultType, compareType, errorMessage);
     case TypeKind::REAL:
       return create<Aggregate, isMaxFunc, Comparator, float>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     case TypeKind::DOUBLE:
       return create<Aggregate, isMaxFunc, Comparator, double>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     case TypeKind::VARCHAR:
       [[fallthrough]];
     case TypeKind::VARBINARY:
       return create<Aggregate, isMaxFunc, Comparator, StringView>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     case TypeKind::TIMESTAMP:
       return create<Aggregate, isMaxFunc, Comparator, Timestamp>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     case TypeKind::ARRAY:
       [[fallthrough]];
     case TypeKind::MAP:
       [[fallthrough]];
     case TypeKind::ROW:
       return create<Aggregate, isMaxFunc, Comparator, ComplexType>(
-          resultType, compareType, errorMessage);
+          resultType, compareType, errorMessage, throwOnNestedNulls);
+    case TypeKind::UNKNOWN:
+      return create<Aggregate, isMaxFunc, Comparator, UnknownValue>(
+          resultType, compareType, errorMessage, throwOnNestedNulls);
     default:
       VELOX_FAIL(errorMessage);
   }
diff --git a/velox/functions/lib/aggregates/SetBaseAggregate.h b/velox/functions/lib/aggregates/SetBaseAggregate.h
new file mode 100644
index 0000000000000..78c51064dfbac
--- /dev/null
+++ b/velox/functions/lib/aggregates/SetBaseAggregate.h
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/SetAccumulator.h"
+#include "velox/functions/lib/CheckNestedNulls.h"
+
+namespace facebook::velox::functions::aggregate {
+
+/// @tparam ignoreNulls Whether null inputs are ignored.
+/// @tparam nullForEmpty When true, nulls are returned for empty groups.
+/// Otherwise, empty arrays.
+template <typename T, bool ignoreNulls = false, bool nullForEmpty = true>
+class SetBaseAggregate : public exec::Aggregate {
+ public:
+  explicit SetBaseAggregate(const TypePtr& resultType)
+      : exec::Aggregate(resultType) {}
+
+  using AccumulatorType = velox::aggregate::prestosql::SetAccumulator<T>;
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(AccumulatorType);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto arrayVector = (*result)->as<ArrayVector>();
+    arrayVector->resize(numGroups);
+
+    auto* rawOffsets = arrayVector->offsets()->asMutable<vector_size_t>();
+    auto* rawSizes = arrayVector->sizes()->asMutable<vector_size_t>();
+
+    vector_size_t numValues = 0;
+    uint64_t* rawNulls = getRawNulls(arrayVector);
+    for (auto i = 0; i < numGroups; ++i) {
+      auto* group = groups[i];
+      if (isNull(group)) {
+        if constexpr (nullForEmpty) {
+          arrayVector->setNull(i, true);
+        } else {
+          // If the group's accumulator is null, the corresponding result is an
+          // empty array.
+          clearNull(rawNulls, i);
+          rawOffsets[i] = 0;
+          rawSizes[i] = 0;
+        }
+      } else {
+        clearNull(rawNulls, i);
+
+        const auto size = value(group)->size();
+
+        rawOffsets[i] = numValues;
+        rawSizes[i] = size;
+
+        numValues += size;
+      }
+    }
+
+    if constexpr (std::is_same_v<T, ComplexType>) {
+      auto values = arrayVector->elements();
+      values->resize(numValues);
+
+      vector_size_t offset = 0;
+      for (auto i = 0; i < numGroups; ++i) {
+        auto* group = groups[i];
+        if (!isNull(group)) {
+          offset += value(group)->extractValues(*values, offset);
+        }
+      }
+    } else {
+      auto values = arrayVector->elements()->as<FlatVector<T>>();
+      values->resize(numValues);
+
+      vector_size_t offset = 0;
+      for (auto i = 0; i < numGroups; ++i) {
+        auto* group = groups[i];
+        if (!isNull(group)) {
+          offset += value(group)->extractValues(*values, offset);
+        }
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    return extractValues(groups, numGroups, result);
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediateResultsInt(groups, rows, args, false);
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addSingleGroupIntermediateResultsInt(group, rows, args, false);
+  }
+
+ protected:
+  inline AccumulatorType* value(char* group) {
+    return reinterpret_cast<AccumulatorType*>(group + Aggregate::offset_);
+  }
+
+  void addIntermediateResultsInt(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool clearNullForAllInputs) {
+    decoded_.decode(*args[0], rows);
+
+    auto baseArray = decoded_.base()->template as<ArrayVector>();
+    decodedElements_.decode(*baseArray->elements());
+
+    rows.applyToSelected([&](vector_size_t i) {
+      if (decoded_.isNullAt(i)) {
+        if (clearNullForAllInputs) {
+          clearNull(groups[i]);
+        }
+        return;
+      }
+
+      auto* group = groups[i];
+      clearNull(group);
+
+      auto tracker = trackRowSize(group);
+
+      auto decodedIndex = decoded_.index(i);
+      if constexpr (ignoreNulls) {
+        value(group)->addNonNullValues(
+            *baseArray, decodedIndex, decodedElements_, allocator_);
+      } else {
+        value(group)->addValues(
+            *baseArray, decodedIndex, decodedElements_, allocator_);
+      }
+    });
+  }
+
+  void addSingleGroupIntermediateResultsInt(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool clearNullForAllInputs) {
+    decoded_.decode(*args[0], rows);
+
+    auto baseArray = decoded_.base()->template as<ArrayVector>();
+
+    decodedElements_.decode(*baseArray->elements());
+
+    auto* accumulator = value(group);
+
+    auto tracker = trackRowSize(group);
+    rows.applyToSelected([&](vector_size_t i) {
+      if (decoded_.isNullAt(i)) {
+        if (clearNullForAllInputs) {
+          clearNull(group);
+        }
+        return;
+      }
+
+      clearNull(group);
+
+      auto decodedIndex = decoded_.index(i);
+      if constexpr (ignoreNulls) {
+        accumulator->addNonNullValues(
+            *baseArray, decodedIndex, decodedElements_, allocator_);
+      } else {
+        accumulator->addValues(
+            *baseArray, decodedIndex, decodedElements_, allocator_);
+      }
+    });
+  }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    const auto& type = resultType()->childAt(0);
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) AccumulatorType(type, allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto* group : groups) {
+      if (isInitialized(group) && !isNull(group)) {
+        value(group)->free(*allocator_);
+      }
+    }
+  }
+
+  DecodedVector decoded_;
+  DecodedVector decodedElements_;
+};
+
+template <typename T, bool ignoreNulls = false, bool nullForEmpty = true>
+class SetAggAggregate : public SetBaseAggregate<T, ignoreNulls, nullForEmpty> {
+ public:
+  explicit SetAggAggregate(
+      const TypePtr& resultType,
+      const bool throwOnNestedNulls = false)
+      : SetBaseAggregate<T, ignoreNulls, nullForEmpty>(resultType),
+        throwOnNestedNulls_(throwOnNestedNulls) {}
+
+  using Base = SetBaseAggregate<T, ignoreNulls, nullForEmpty>;
+
+  bool supportsToIntermediate() const override {
+    return true;
+  }
+
+  void toIntermediate(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      VectorPtr& result) const override {
+    const auto& elements = args[0];
+
+    if (throwOnNestedNulls_) {
+      DecodedVector decodedElements(*elements, rows);
+      auto indices = decodedElements.indices();
+      rows.applyToSelected([&](vector_size_t i) {
+        velox::functions::checkNestedNulls(
+            decodedElements, indices, i, throwOnNestedNulls_);
+      });
+    }
+
+    const auto numRows = rows.size();
+
+    // Convert input to a single-entry array.
+
+    // Set nulls for rows not present in 'rows'.
+    auto* pool = Base::allocator_->pool();
+    BufferPtr nulls = allocateNulls(numRows, pool);
+    memcpy(
+        nulls->asMutable<uint64_t>(),
+        rows.asRange().bits(),
+        bits::nbytes(numRows));
+
+    // Set offsets to 0, 1, 2, 3...
+    BufferPtr offsets = allocateOffsets(numRows, pool);
+    auto* rawOffsets = offsets->asMutable<vector_size_t>();
+    std::iota(rawOffsets, rawOffsets + numRows, 0);
+
+    // Set sizes to 1.
+    BufferPtr sizes = allocateSizes(numRows, pool);
+    auto* rawSizes = sizes->asMutable<vector_size_t>();
+    std::fill(rawSizes, rawSizes + numRows, 1);
+
+    result = std::make_shared<ArrayVector>(
+        pool,
+        ARRAY(elements->type()),
+        nulls,
+        numRows,
+        offsets,
+        sizes,
+        BaseVector::loadedVectorShared(elements));
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    Base::decoded_.decode(*args[0], rows);
+    auto indices = Base::decoded_.indices();
+    rows.applyToSelected([&](vector_size_t i) {
+      auto* group = groups[i];
+      Base::clearNull(group);
+
+      if (throwOnNestedNulls_) {
+        velox::functions::checkNestedNulls(
+            Base::decoded_, indices, i, throwOnNestedNulls_);
+      }
+
+      auto tracker = Base::trackRowSize(group);
+      if constexpr (ignoreNulls) {
+        Base::value(group)->addNonNullValue(
+            Base::decoded_, i, Base::allocator_);
+      } else {
+        Base::value(group)->addValue(Base::decoded_, i, Base::allocator_);
+      }
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    Base::decoded_.decode(*args[0], rows);
+
+    Base::clearNull(group);
+    auto* accumulator = Base::value(group);
+
+    auto tracker = Base::trackRowSize(group);
+    auto indices = Base::decoded_.indices();
+    rows.applyToSelected([&](vector_size_t i) {
+      if (throwOnNestedNulls_) {
+        velox::functions::checkNestedNulls(
+            Base::decoded_, indices, i, throwOnNestedNulls_);
+      }
+
+      if constexpr (ignoreNulls) {
+        accumulator->addNonNullValue(Base::decoded_, i, Base::allocator_);
+      } else {
+        accumulator->addValue(Base::decoded_, i, Base::allocator_);
+      }
+    });
+  }
+
+ private:
+  const bool throwOnNestedNulls_;
+};
+
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/SimpleNumericAggregate.h b/velox/functions/lib/aggregates/SimpleNumericAggregate.h
index e5be2883ae1db..b5a35ae0757e6 100644
--- a/velox/functions/lib/aggregates/SimpleNumericAggregate.h
+++ b/velox/functions/lib/aggregates/SimpleNumericAggregate.h
@@ -35,6 +35,10 @@ class SimpleNumericAggregate : public exec::Aggregate {
   }
 
  protected:
+  template <typename T>
+  static constexpr bool kMayPushdown = !std::is_same_v<T, int128_t> &&
+      !std::is_same_v<T, Timestamp> && !std::is_same_v<T, UnknownValue>;
+
   // TData is either TAccumulator or TResult, which in most cases are the same,
   // but for sum(real) can differ.
   template <typename TData = TResult, typename ExtractOneValue>
@@ -95,20 +99,21 @@ class SimpleNumericAggregate : public exec::Aggregate {
       bool mayPushdown) {
     DecodedVector decoded(*arg, rows, !mayPushdown);
     auto encoding = decoded.base()->encoding();
-    if (encoding == VectorEncoding::Simple::LAZY) {
-      velox::aggregate::SimpleCallableHook<TValue, TData, UpdateSingleValue>
-          hook(
-              exec::Aggregate::offset_,
-              exec::Aggregate::nullByte_,
-              exec::Aggregate::nullMask_,
-              groups,
-              &this->exec::Aggregate::numNulls_,
-              updateSingleValue);
+    if constexpr (kMayPushdown<TData>) {
+      if (encoding == VectorEncoding::Simple::LAZY) {
+        velox::aggregate::SimpleCallableHook<TData, UpdateSingleValue> hook(
+            exec::Aggregate::offset_,
+            exec::Aggregate::nullByte_,
+            exec::Aggregate::nullMask_,
+            groups,
+            &this->exec::Aggregate::numNulls_,
+            updateSingleValue);
 
-      auto indices = decoded.indices();
-      decoded.base()->as<const LazyVector>()->load(
-          RowSet(indices, arg->size()), &hook);
-      return;
+        auto indices = decoded.indices();
+        decoded.base()->as<const LazyVector>()->load(
+            RowSet(indices, arg->size()), &hook);
+        return;
+      }
     }
 
     if (decoded.isConstantMapping()) {
diff --git a/velox/functions/lib/aggregates/SingleValueAccumulator.cpp b/velox/functions/lib/aggregates/SingleValueAccumulator.cpp
index 772c6ac480f4c..2e47cbf382b3a 100644
--- a/velox/functions/lib/aggregates/SingleValueAccumulator.cpp
+++ b/velox/functions/lib/aggregates/SingleValueAccumulator.cpp
@@ -25,14 +25,15 @@ void SingleValueAccumulator::write(
     const BaseVector* vector,
     vector_size_t index,
     HashStringAllocator* allocator) {
-  ByteStream stream(allocator);
+  ByteOutputStream stream(allocator);
   if (start_.header == nullptr) {
     start_ = allocator->newWrite(stream);
   } else {
     allocator->extendWrite(start_, stream);
   }
 
-  exec::ContainerRowSerde::serialize(*vector, index, stream);
+  static const exec::ContainerRowSerdeOptions options{};
+  exec::ContainerRowSerde::serialize(*vector, index, stream, options);
   allocator->finishWrite(stream, 0);
 }
 
@@ -40,9 +41,8 @@ void SingleValueAccumulator::read(const VectorPtr& vector, vector_size_t index)
     const {
   VELOX_CHECK_NOT_NULL(start_.header);
 
-  ByteStream stream;
-  HashStringAllocator::prepareRead(start_.header, stream);
-  exec::ContainerRowSerde::deserialize(stream, index, vector.get());
+  auto stream = HashStringAllocator::prepareRead(start_.header);
+  exec::ContainerRowSerde::deserialize(*stream, index, vector.get());
 }
 
 bool SingleValueAccumulator::hasValue() const {
@@ -55,10 +55,9 @@ std::optional<int32_t> SingleValueAccumulator::compare(
     CompareFlags compareFlags) const {
   VELOX_CHECK_NOT_NULL(start_.header);
 
-  ByteStream stream;
-  HashStringAllocator::prepareRead(start_.header, stream);
+  auto stream = HashStringAllocator::prepareRead(start_.header);
   return exec::ContainerRowSerde::compareWithNulls(
-      stream, decoded, index, compareFlags);
+      *stream, decoded, index, compareFlags);
 }
 
 void SingleValueAccumulator::destroy(HashStringAllocator* allocator) {
diff --git a/velox/functions/lib/aggregates/SingleValueAccumulator.h b/velox/functions/lib/aggregates/SingleValueAccumulator.h
index 7a2db7cd9d56f..31e41be468a0c 100644
--- a/velox/functions/lib/aggregates/SingleValueAccumulator.h
+++ b/velox/functions/lib/aggregates/SingleValueAccumulator.h
@@ -37,7 +37,8 @@ struct SingleValueAccumulator {
   /// then new value; >0 if stored value is greater than new value. If
   /// flags.nullHandlingMode is StopAtNull, returns std::nullopt
   /// in case of null array elements, map values, and struct fields.
-  /// If flags.nullHandlingMode is NoStop then NULL is considered equal to NULL.
+  /// If flags.nullHandlingMode is NullAsValue then NULL is considered equal to
+  /// NULL.
   std::optional<int32_t> compare(
       const DecodedVector& decoded,
       vector_size_t index,
diff --git a/velox/functions/lib/aggregates/SumAggregateBase.h b/velox/functions/lib/aggregates/SumAggregateBase.h
new file mode 100644
index 0000000000000..dd44cd3c87266
--- /dev/null
+++ b/velox/functions/lib/aggregates/SumAggregateBase.h
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "folly/CPortability.h"
+
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/CheckedArithmeticImpl.h"
+#include "velox/functions/lib/aggregates/DecimalAggregate.h"
+#include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
+
+namespace facebook::velox::functions::aggregate {
+
+template <
+    typename TInput,
+    typename TAccumulator,
+    typename ResultType,
+    bool Overflow>
+class SumAggregateBase
+    : public SimpleNumericAggregate<TInput, TAccumulator, ResultType> {
+  using BaseAggregate =
+      SimpleNumericAggregate<TInput, TAccumulator, ResultType>;
+
+ public:
+  explicit SumAggregateBase(TypePtr resultType) : BaseAggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(TAccumulator);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return 1;
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    BaseAggregate::template doExtractValues<ResultType>(
+        groups, numGroups, result, [&](char* group) {
+          // 'ResultType' and 'TAccumulator' might not be same such as sum(real)
+          // and we do an explicit type conversion here.
+          return (ResultType)(*BaseAggregate::Aggregate::template value<
+                              TAccumulator>(group));
+        });
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    BaseAggregate::template doExtractValues<TAccumulator>(
+        groups, numGroups, result, [&](char* group) {
+          return *BaseAggregate::Aggregate::template value<TAccumulator>(group);
+        });
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    updateInternal<TAccumulator>(groups, rows, args, mayPushdown);
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    updateInternal<TAccumulator, TAccumulator>(groups, rows, args, mayPushdown);
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    BaseAggregate::template updateOneGroup<TAccumulator>(
+        group,
+        rows,
+        args[0],
+        &updateSingleValue<TAccumulator>,
+        &updateDuplicateValues<TAccumulator>,
+        mayPushdown,
+        TAccumulator(0));
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) override {
+    BaseAggregate::template updateOneGroup<TAccumulator, TAccumulator>(
+        group,
+        rows,
+        args[0],
+        &updateSingleValue<TAccumulator>,
+        &updateDuplicateValues<TAccumulator>,
+        mayPushdown,
+        TAccumulator(0));
+  }
+
+ protected:
+  // TData is used to store the updated sum state. It can be either
+  // TAccumulator or TResult, which in most cases are the same, but for
+  // sum(real) can differ. TValue is used to decode the sum input 'args'.
+  // It can be either TAccumulator or TInput, which is most cases are the same
+  // but for sum(real) can differ.
+  template <typename TData, typename TValue = TInput>
+  void updateInternal(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) {
+    const auto& arg = args[0];
+
+    if (mayPushdown && arg->isLazy()) {
+      BaseAggregate::template pushdown<
+          facebook::velox::aggregate::SumHook<TData, Overflow>>(
+          groups, rows, arg);
+      return;
+    }
+
+    if (exec::Aggregate::numNulls_) {
+      BaseAggregate::template updateGroups<true, TData, TValue>(
+          groups, rows, arg, &updateSingleValue<TData>, false);
+    } else {
+      BaseAggregate::template updateGroups<false, TData, TValue>(
+          groups, rows, arg, &updateSingleValue<TData>, false);
+    }
+  }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      *exec::Aggregate::value<TAccumulator>(groups[i]) = 0;
+    }
+  }
+
+ private:
+  template <typename TData>
+  static void updateSingleValue(TData& result, TData value) {
+    velox::aggregate::SumHook<TData, Overflow>::add(result, value);
+  }
+
+  // Disable undefined behavior sanitizer to not fail on signed integer
+  // overflow.
+  template <typename TData>
+#if defined(FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER)
+  FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER("signed-integer-overflow")
+#endif
+  static void updateDuplicateValues(TData& result, TData value, int n) {
+    if constexpr (
+        (std::is_same_v<TData, int64_t> && Overflow) ||
+        std::is_same_v<TData, double> || std::is_same_v<TData, float>) {
+      result += n * value;
+    } else {
+      result = functions::checkedPlus<TData>(
+          result, functions::checkedMultiply<TData>(TData(n), value));
+    }
+  }
+};
+
+template <typename TInputType>
+class DecimalSumAggregate
+    : public functions::aggregate::DecimalAggregate<int128_t, TInputType> {
+ public:
+  explicit DecimalSumAggregate(TypePtr resultType)
+      : functions::aggregate::DecimalAggregate<int128_t, TInputType>(
+            resultType) {}
+
+  virtual int128_t computeFinalValue(
+      functions::aggregate::LongDecimalWithOverflowState* accumulator) final {
+    auto sum = DecimalUtil::adjustSumForOverflow(
+        accumulator->sum, accumulator->overflow);
+    VELOX_USER_CHECK(sum.has_value(), "Decimal overflow");
+    DecimalUtil::valueInRange(sum.value());
+    return sum.value();
+  }
+};
+
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/prestosql/aggregates/ValueList.cpp b/velox/functions/lib/aggregates/ValueList.cpp
similarity index 78%
rename from velox/functions/prestosql/aggregates/ValueList.cpp
rename to velox/functions/lib/aggregates/ValueList.cpp
index cdcb1e0938312..c3e7e97a421a2 100644
--- a/velox/functions/prestosql/aggregates/ValueList.cpp
+++ b/velox/functions/lib/aggregates/ValueList.cpp
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/functions/prestosql/aggregates/ValueList.h"
+#include "velox/functions/lib/aggregates/ValueList.h"
 #include "velox/exec/ContainerRowSerde.h"
 
 namespace facebook::velox::aggregate {
@@ -39,7 +39,7 @@ void ValueList::prepareAppend(HashStringAllocator* allocator) {
 }
 
 void ValueList::writeLastNulls(HashStringAllocator* allocator) {
-  ByteStream stream(allocator);
+  ByteOutputStream stream(allocator);
   if (nullsBegin_) {
     allocator->extendWrite(nullsCurrent_, stream);
   } else {
@@ -61,12 +61,19 @@ void ValueList::appendNonNull(
     vector_size_t index,
     HashStringAllocator* allocator) {
   prepareAppend(allocator);
-  ByteStream stream(allocator);
+  ByteOutputStream stream(allocator);
   allocator->extendWrite(dataCurrent_, stream);
-  exec::ContainerRowSerde::serialize(values, index, stream);
+  // The stream may have a tail of a previous write.
+  const auto initialSize = stream.size();
+  static const exec::ContainerRowSerdeOptions options{};
+  exec::ContainerRowSerde::serialize(values, index, stream, options);
   ++size_;
+  bytes_ += stream.size() - initialSize;
 
-  dataCurrent_ = allocator->finishWrite(stream, 1024).second;
+  // Leave space up to half the size appended so far, at least 24 but no more
+  // than 1024.
+  dataCurrent_ =
+      allocator->finishWrite(stream, std::clamp(bytes_ / 2, 24, 1024)).second;
 }
 
 void ValueList::appendValue(
@@ -98,22 +105,21 @@ void ValueList::appendRange(
 ValueListReader::ValueListReader(ValueList& values)
     : size_{values.size()},
       lastNullsStart_{size_ % 64 == 0 ? size_ - 64 : size_ - size_ % 64},
-      lastNulls_{values.lastNulls()} {
-  HashStringAllocator::prepareRead(values.dataBegin(), dataStream_);
-  HashStringAllocator::prepareRead(values.nullsBegin(), nullsStream_);
-}
+      lastNulls_{values.lastNulls()},
+      dataStream_{HashStringAllocator::prepareRead(values.dataBegin())},
+      nullsStream_{HashStringAllocator::prepareRead(values.nullsBegin())} {}
 
 bool ValueListReader::next(BaseVector& output, vector_size_t outputIndex) {
   if (pos_ == lastNullsStart_) {
     nulls_ = lastNulls_;
   } else if (pos_ % 64 == 0) {
-    nulls_ = nullsStream_.read<uint64_t>();
+    nulls_ = nullsStream_->read<uint64_t>();
   }
 
   if (nulls_ & (1UL << (pos_ % 64))) {
     output.setNull(outputIndex, true);
   } else {
-    exec::ContainerRowSerde::deserialize(dataStream_, outputIndex, &output);
+    exec::ContainerRowSerde::deserialize(*dataStream_, outputIndex, &output);
   }
 
   pos_++;
diff --git a/velox/functions/prestosql/aggregates/ValueList.h b/velox/functions/lib/aggregates/ValueList.h
similarity index 82%
rename from velox/functions/prestosql/aggregates/ValueList.h
rename to velox/functions/lib/aggregates/ValueList.h
index 5c2475a14615a..74aa4731e921a 100644
--- a/velox/functions/prestosql/aggregates/ValueList.h
+++ b/velox/functions/lib/aggregates/ValueList.h
@@ -19,6 +19,7 @@
 #include "velox/common/memory/HashStringAllocator.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/ComplexViewTypes.h"
+#include "velox/expression/ComplexWriterTypes.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DecodedVector.h"
 
@@ -108,6 +109,9 @@ class ValueList {
   // Number of values added, including nulls.
   uint32_t size_{0};
 
+  // Bytes added. Used to control allocation of reserve for future appends.
+  int32_t bytes_{0};
+
   // Last nulls word. 'size_ % 64' is the null bit for the next element.
   uint64_t lastNulls_{0};
 };
@@ -123,10 +127,31 @@ class ValueListReader {
   const vector_size_t size_;
   const vector_size_t lastNullsStart_;
   const uint64_t lastNulls_;
-  ByteStream dataStream_;
-  ByteStream nullsStream_;
+  std::unique_ptr<ByteInputStream> dataStream_;
+  std::unique_ptr<ByteInputStream> nullsStream_;
   uint64_t nulls_;
   vector_size_t pos_{0};
 };
 
+// Write ValueList accumulators to Array-typed intermediate or final result
+// vectors.
+// TODO: This API only works if it is the only logic writing to `writer`.
+template <typename T>
+void copyValueListToArrayWriter(
+    facebook::velox::exec::ArrayWriter<T>& writer,
+    ValueList& elements) {
+  writer.resetLength();
+  auto size = elements.size();
+  if (size == 0) {
+    return;
+  }
+  writer.reserve(size);
+
+  ValueListReader reader(elements);
+  for (vector_size_t i = 0; i < size; ++i) {
+    reader.next(*writer.elementsVector(), writer.valuesOffset() + i);
+  }
+  writer.resize(size);
+}
+
 } // namespace facebook::velox::aggregate
diff --git a/velox/functions/lib/aggregates/ValueSet.cpp b/velox/functions/lib/aggregates/ValueSet.cpp
index e0910c46bb137..24450a0868669 100644
--- a/velox/functions/lib/aggregates/ValueSet.cpp
+++ b/velox/functions/lib/aggregates/ValueSet.cpp
@@ -22,14 +22,15 @@ void ValueSet::write(
     const BaseVector& vector,
     vector_size_t index,
     HashStringAllocator::Position& position) const {
-  ByteStream stream(allocator_);
+  ByteOutputStream stream(allocator_);
   if (position.header == nullptr) {
     position = allocator_->newWrite(stream);
   } else {
     allocator_->extendWrite(position, stream);
   }
 
-  exec::ContainerRowSerde::serialize(vector, index, stream);
+  static const exec::ContainerRowSerdeOptions options{};
+  exec::ContainerRowSerde::serialize(vector, index, stream, options);
   allocator_->finishWrite(stream, 0);
 }
 
@@ -53,9 +54,8 @@ void ValueSet::read(
     const HashStringAllocator::Header* header) const {
   VELOX_CHECK_NOT_NULL(header);
 
-  ByteStream stream;
-  HashStringAllocator::prepareRead(header, stream);
-  exec::ContainerRowSerde::deserialize(stream, index, vector);
+  auto stream = HashStringAllocator::prepareRead(header);
+  exec::ContainerRowSerde::deserialize(*stream, index, vector);
 }
 
 void ValueSet::free(HashStringAllocator::Header* header) const {
diff --git a/velox/functions/lib/aggregates/tests/AggregationTestBase.cpp b/velox/functions/lib/aggregates/tests/AggregationTestBase.cpp
deleted file mode 100644
index 1d0e6e43e9516..0000000000000
--- a/velox/functions/lib/aggregates/tests/AggregationTestBase.cpp
+++ /dev/null
@@ -1,1146 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
-#include "velox/common/base/tests/GTestUtils.h"
-
-#include "velox/common/file/FileSystems.h"
-#include "velox/connectors/hive/HiveConnector.h"
-#include "velox/dwio/common/tests/utils/BatchMaker.h"
-#include "velox/dwio/dwrf/reader/DwrfReader.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
-#include "velox/exec/AggregateCompanionSignatures.h"
-#include "velox/exec/PlanNodeStats.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
-#include "velox/expression/SignatureBinder.h"
-
-#ifndef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-#include "velox/connectors/hive/HiveConnectorSplit.h"
-#else
-#include "velox/vector/tests/utils/VectorMaker.h"
-#endif
-
-using facebook::velox::exec::Spiller;
-using facebook::velox::exec::test::AssertQueryBuilder;
-using facebook::velox::exec::test::CursorParameters;
-using facebook::velox::exec::test::PlanBuilder;
-using facebook::velox::test::VectorMaker;
-
-namespace facebook::velox::functions::aggregate::test {
-
-namespace {
-constexpr const char* kHiveConnectorId = "test-hive";
-
-void enableAbandonPartialAggregation(AssertQueryBuilder& queryBuilder) {
-  queryBuilder.config(core::QueryConfig::kAbandonPartialAggregationMinRows, "1")
-      .config(core::QueryConfig::kAbandonPartialAggregationMinPct, "0")
-      .config(core::QueryConfig::kMaxPartialAggregationMemory, "0")
-      .config(core::QueryConfig::kMaxExtendedPartialAggregationMemory, "0")
-      .maxDrivers(1);
-}
-
-} // namespace
-
-std::vector<RowVectorPtr> AggregationTestBase::makeVectors(
-    const RowTypePtr& rowType,
-    vector_size_t size,
-    int numVectors) {
-  std::vector<RowVectorPtr> vectors;
-  for (int32_t i = 0; i < numVectors; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        velox::test::BatchMaker::createBatch(rowType, size, *pool_));
-    vectors.push_back(vector);
-  }
-  return vectors;
-}
-
-void AggregationTestBase::SetUp() {
-  OperatorTestBase::SetUp();
-  filesystems::registerLocalFileSystem();
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(kHiveConnectorId, nullptr);
-  connector::registerConnector(hiveConnector);
-}
-
-void AggregationTestBase::TearDown() {
-  connector::unregisterConnector(kHiveConnectorId);
-  OperatorTestBase::TearDown();
-}
-
-void AggregationTestBase::testAggregations(
-    const std::vector<RowVectorPtr>& data,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::string& duckDbSql,
-    const std::unordered_map<std::string, std::string>& config,
-    bool testWithTableScan) {
-  SCOPED_TRACE(duckDbSql);
-  testAggregations(
-      data, groupingKeys, aggregates, {}, duckDbSql, config, testWithTableScan);
-}
-
-void AggregationTestBase::testAggregations(
-    const std::vector<RowVectorPtr>& data,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<RowVectorPtr>& expectedResult,
-    const std::unordered_map<std::string, std::string>& config,
-    bool testWithTableScan) {
-  testAggregations(
-      data,
-      groupingKeys,
-      aggregates,
-      {},
-      expectedResult,
-      config,
-      testWithTableScan);
-}
-
-void AggregationTestBase::testAggregations(
-    const std::vector<RowVectorPtr>& data,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& postAggregationProjections,
-    const std::string& duckDbSql,
-    const std::unordered_map<std::string, std::string>& config,
-    bool testWithTableScan) {
-  SCOPED_TRACE(duckDbSql);
-  testAggregations(
-      [&](PlanBuilder& builder) { builder.values(data); },
-      groupingKeys,
-      aggregates,
-      postAggregationProjections,
-      [&](auto& builder) { return builder.assertResults(duckDbSql); },
-      config,
-      testWithTableScan);
-}
-
-namespace {
-// Returns total spilled bytes inside 'task'.
-int64_t spilledBytes(const exec::Task& task) {
-  auto stats = task.taskStats();
-  int64_t spilledBytes = 0;
-  for (auto& pipeline : stats.pipelineStats) {
-    for (auto op : pipeline.operatorStats) {
-      spilledBytes += op.spilledBytes;
-    }
-  }
-
-  return spilledBytes;
-}
-
-// Add a BIGINT column of 4 distinct values to data.
-RowVectorPtr addExtraGroupingKeyImpl(
-    const RowVectorPtr& data,
-    const std::vector<std::string>& fieldNames,
-    VectorMaker& vectorMaker) {
-  auto children = data->children();
-  children.push_back(vectorMaker.flatVector<int64_t>(
-      data->size(), [](auto row) { return row % 4; }));
-  return vectorMaker.rowVector(fieldNames, children);
-}
-
-// Add a BIGINT column of 4 distinct values to every RowVector in data.
-std::vector<RowVectorPtr> addExtraGroupingKey(
-    const std::vector<RowVectorPtr>& data,
-    const std::string& extraKeyName) {
-  VELOX_CHECK(!data.empty());
-  auto names = asRowType(data[0]->type())->names();
-  names.push_back(extraKeyName);
-
-  std::vector<RowVectorPtr> newData{data.size()};
-  VectorMaker vectorMaker{data[0]->pool()};
-  std::transform(
-      data.begin(),
-      data.end(),
-      newData.begin(),
-      [&names, &vectorMaker](const RowVectorPtr& vector) {
-        return addExtraGroupingKeyImpl(vector, names, vectorMaker);
-      });
-  return newData;
-}
-
-// Given the name of the original aggregation function and the argument types,
-// return the name of the extract companion function with a suffix of the result
-// type. Extract function names with suffixes should only be used when the
-// original aggregation function has multiple signatures with the same
-// intermediate type.
-std::string getExtractFunctionNameWithSuffix(
-    const std::string& name,
-    const std::vector<TypePtr>& argTypes) {
-  auto signatures = exec::getAggregateFunctionSignatures(name);
-  VELOX_CHECK(signatures.has_value());
-
-  for (const auto& signature : signatures.value()) {
-    exec::SignatureBinder binder{*signature, argTypes};
-    if (binder.tryBind()) {
-      if (auto resultType = binder.tryResolveReturnType()) {
-        return exec::CompanionSignatures::extractFunctionNameWithSuffix(
-            name, signature->returnType());
-      }
-    }
-  }
-  VELOX_UNREACHABLE("Could not find a function bound to argTypes.");
-}
-
-// Given the `index`-th aggregation expression, e.g., "avg(c0)", return three
-// strings of its partial companion aggregation expression, merge companion
-// aggregation expression, and extract companion expression, e.g.,
-// {"avg_partial(c0)", "avg_merge(a0)", "avg_extract_double(a0)"} when `index`
-// is 0.
-std::tuple<std::string, std::string, std::string> getCompanionAggregates(
-    column_index_t index,
-    const exec::CompanionFunctionSignatureMap& companionFunctions,
-    const std::string& functionName,
-    const std::string& aggregateArgs,
-    const std::vector<TypePtr>& argTypes) {
-  VELOX_CHECK_EQ(companionFunctions.partial.size(), 1);
-  auto partialAggregate = fmt::format(
-      "{}({})", companionFunctions.partial.front().functionName, aggregateArgs);
-
-  VELOX_CHECK_EQ(companionFunctions.merge.size(), 1);
-  auto mergeAggregate = fmt::format(
-      "{}(a{})", companionFunctions.merge.front().functionName, index);
-
-  // Construct the extract expression. Rename the result of the extract
-  // expression to be the same as the original aggregation result, so that
-  // post-aggregation proejctions, if exist, can apply with no change.
-  std::string extractExpression;
-  if (companionFunctions.extract.size() == 1) {
-    extractExpression = fmt::format(
-        "{0}(a{1}) as a{1}",
-        companionFunctions.extract.front().functionName,
-        index);
-  } else {
-    VELOX_CHECK_GT(companionFunctions.extract.size(), 1);
-    auto extractFunctionName =
-        getExtractFunctionNameWithSuffix(functionName, argTypes);
-    extractExpression =
-        fmt::format("{0}(a{1}) as a{1}", extractFunctionName, index);
-  }
-  return std::make_tuple(partialAggregate, mergeAggregate, extractExpression);
-}
-
-// Given a list of aggregation expressions, e.g., {"avg(c0)"}, return a list of
-// aggregate function names and a list of arguments in these expressions, e.g.,
-// {{"avg"}, {"c0"}}.
-std::tuple<std::vector<std::string>, std::vector<std::string>>
-getFunctionNamesAndArgs(const std::vector<std::string>& aggregates) {
-  std::vector<std::string> functionNames;
-  std::vector<std::string> aggregateArgs;
-  for (const auto& aggregate : aggregates) {
-    std::vector<std::string> tokens;
-    folly::split('(', aggregate, tokens);
-    VELOX_CHECK_EQ(tokens.size(), 2);
-    functionNames.push_back(tokens[0]);
-    aggregateArgs.push_back(tokens[1].substr(0, tokens[1].find(')')));
-  }
-  return std::make_pair(functionNames, aggregateArgs);
-}
-} // namespace
-
-void AggregationTestBase::testAggregationsWithCompanion(
-    const std::vector<RowVectorPtr>& data,
-    const std::function<void(PlanBuilder&)>& preAggregationProcessing,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::vector<TypePtr>>& aggregatesArgTypes,
-    const std::vector<std::string>& postAggregationProjections,
-    const std::string& duckDbSql,
-    const std::unordered_map<std::string, std::string>& config) {
-  testAggregationsWithCompanion(
-      data,
-      preAggregationProcessing,
-      groupingKeys,
-      aggregates,
-      aggregatesArgTypes,
-      postAggregationProjections,
-      [&](auto& builder) { return builder.assertResults(duckDbSql); },
-      config);
-}
-
-void AggregationTestBase::testAggregationsWithCompanion(
-    const std::vector<RowVectorPtr>& data,
-    const std::function<void(PlanBuilder&)>& preAggregationProcessing,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::vector<TypePtr>>& aggregatesArgTypes,
-    const std::vector<std::string>& postAggregationProjections,
-    const std::vector<RowVectorPtr>& expectedResult,
-    const std::unordered_map<std::string, std::string>& config) {
-  testAggregationsWithCompanion(
-      data,
-      preAggregationProcessing,
-      groupingKeys,
-      aggregates,
-      aggregatesArgTypes,
-      postAggregationProjections,
-      [&](auto& builder) { return builder.assertResults(expectedResult); },
-      config);
-}
-
-void AggregationTestBase::testAggregationsWithCompanion(
-    const std::vector<RowVectorPtr>& data,
-    const std::function<void(PlanBuilder&)>& preAggregationProcessing,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::vector<TypePtr>>& aggregatesArgTypes,
-    const std::vector<std::string>& postAggregationProjections,
-    std::function<std::shared_ptr<exec::Task>(exec::test::AssertQueryBuilder&)>
-        assertResults,
-    const std::unordered_map<std::string, std::string>& config) {
-  auto dataWithExtraGroupingKey = addExtraGroupingKey(data, "k0");
-  auto groupingKeysWithPartialKey = groupingKeys;
-  groupingKeysWithPartialKey.push_back("k0");
-
-  std::vector<std::string> paritialAggregates;
-  std::vector<std::string> mergeAggregates;
-  std::vector<std::string> extractExpressions;
-  extractExpressions.insert(
-      extractExpressions.end(), groupingKeys.begin(), groupingKeys.end());
-
-  auto [functionNames, aggregateArgs] = getFunctionNamesAndArgs(aggregates);
-  for (size_t i = 0, size = functionNames.size(); i < size; ++i) {
-    const auto& companionSignatures =
-        exec::getCompanionFunctionSignatures(functionNames[i]);
-    VELOX_CHECK(companionSignatures.has_value());
-
-    const auto& [paritialAggregate, mergeAggregate, extractAggregate] =
-        getCompanionAggregates(
-            i,
-            *companionSignatures,
-            functionNames[i],
-            aggregateArgs[i],
-            aggregatesArgTypes[i]);
-    paritialAggregates.push_back(paritialAggregate);
-    mergeAggregates.push_back(mergeAggregate);
-    extractExpressions.push_back(extractAggregate);
-  }
-
-  {
-    SCOPED_TRACE("Run partial + final");
-    PlanBuilder builder(pool());
-    builder.values(dataWithExtraGroupingKey);
-    preAggregationProcessing(builder);
-    builder.partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
-        .finalAggregation()
-        .partialAggregation(groupingKeys, mergeAggregates)
-        .finalAggregation()
-        .project(extractExpressions);
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    assertResults(queryBuilder);
-  }
-
-  if (!groupingKeys.empty() && allowInputShuffle_) {
-    SCOPED_TRACE("Run partial + final with spilling");
-    PlanBuilder builder(pool());
-    builder.values(dataWithExtraGroupingKey);
-    preAggregationProcessing(builder);
-
-    // Spilling needs at least 2 batches of input. Use round-robin
-    // repartitioning to split input into multiple batches.
-    core::PlanNodeId partialNodeId;
-    builder.localPartitionRoundRobinRow()
-        .partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
-        .capturePlanNodeId(partialNodeId)
-        .localPartition(groupingKeysWithPartialKey)
-        .finalAggregation()
-        .partialAggregation(groupingKeys, mergeAggregates)
-        .capturePlanNodeId(partialNodeId)
-        .localPartition(groupingKeys)
-        .finalAggregation()
-        .project(extractExpressions);
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config)
-        .config(core::QueryConfig::kTestingSpillPct, "100")
-        .config(core::QueryConfig::kSpillEnabled, "true")
-        .config(core::QueryConfig::kAggregationSpillEnabled, "true")
-        .spillDirectory(spillDirectory->path)
-        .maxDrivers(4);
-
-    auto task = assertResults(queryBuilder);
-
-    // Expect > 0 spilled bytes unless there was no input.
-    auto inputRows = toPlanStats(task->taskStats()).at(partialNodeId).inputRows;
-    if (inputRows > 1) {
-      EXPECT_LT(0, spilledBytes(*task));
-    } else {
-      EXPECT_EQ(0, spilledBytes(*task));
-    }
-  }
-
-  {
-    SCOPED_TRACE("Run single");
-    PlanBuilder builder(pool());
-    builder.values(dataWithExtraGroupingKey);
-    preAggregationProcessing(builder);
-    builder.singleAggregation(groupingKeysWithPartialKey, paritialAggregates)
-        .singleAggregation(groupingKeys, mergeAggregates)
-        .project(extractExpressions);
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    assertResults(queryBuilder);
-  }
-
-  {
-    SCOPED_TRACE("Run partial + intermediate + final");
-    PlanBuilder builder(pool());
-    builder.values(dataWithExtraGroupingKey);
-    preAggregationProcessing(builder);
-    builder.partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
-        .intermediateAggregation()
-        .finalAggregation()
-        .partialAggregation(groupingKeys, mergeAggregates)
-        .intermediateAggregation()
-        .finalAggregation()
-        .project(extractExpressions);
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    assertResults(queryBuilder);
-  }
-
-  if (!groupingKeys.empty()) {
-    SCOPED_TRACE("Run partial + local exchange + final");
-    PlanBuilder builder(pool());
-    builder.values(dataWithExtraGroupingKey);
-    preAggregationProcessing(builder);
-    builder.partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
-        .localPartition(groupingKeysWithPartialKey)
-        .finalAggregation()
-        .partialAggregation(groupingKeys, mergeAggregates)
-        .localPartition(groupingKeys)
-        .finalAggregation()
-        .project(extractExpressions);
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config).maxDrivers(4);
-    assertResults(queryBuilder);
-  }
-
-  {
-    SCOPED_TRACE(
-        "Run partial + local exchange + intermediate + local exchange + final");
-    PlanBuilder builder(pool());
-    builder.values(dataWithExtraGroupingKey);
-    preAggregationProcessing(builder);
-    builder.partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
-        .localPartition(groupingKeysWithPartialKey)
-        .intermediateAggregation()
-        .localPartition(groupingKeysWithPartialKey)
-        .finalAggregation()
-        .partialAggregation(groupingKeys, mergeAggregates);
-
-    if (groupingKeys.empty()) {
-      builder.localPartitionRoundRobinRow();
-    } else {
-      builder.localPartition(groupingKeys);
-    }
-
-    builder.intermediateAggregation()
-        .localPartition(groupingKeys)
-        .finalAggregation()
-        .project(extractExpressions);
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config).maxDrivers(2);
-    assertResults(queryBuilder);
-  }
-
-  if (testStreaming_ && groupingKeys.empty() &&
-      postAggregationProjections.empty()) {
-    {
-      SCOPED_TRACE("Streaming partial");
-      auto partialResult = validateStreamingInTestAggregations(
-          [&](auto& builder) { builder.values(dataWithExtraGroupingKey); },
-          paritialAggregates,
-          config);
-
-      validateStreamingInTestAggregations(
-          [&](auto& builder) { builder.values({partialResult}); },
-          mergeAggregates,
-          config);
-    }
-  }
-}
-
-namespace {
-
-void writeToFile(
-    const std::string& path,
-    const VectorPtr& vector,
-    memory::MemoryPool* pool) {
-  dwrf::WriterOptions options;
-  options.schema = vector->type();
-  options.memoryPool = pool;
-  auto writeFile = std::make_unique<LocalWriteFile>(path, true, false);
-  auto sink =
-      std::make_unique<dwio::common::WriteFileSink>(std::move(writeFile), path);
-  dwrf::Writer writer(std::move(sink), options);
-  writer.write(vector);
-  writer.close();
-}
-
-template <typename T>
-class ScopedChange {
- public:
-  ScopedChange(T* value, const T& newValue) : value_(value) {
-    oldValue_ = *value_;
-    *value_ = newValue;
-  }
-
-  ~ScopedChange() {
-    *value_ = oldValue_;
-  }
-
- private:
-  T oldValue_;
-  T* value_;
-};
-
-} // namespace
-
-void AggregationTestBase::testReadFromFiles(
-    std::function<void(exec::test::PlanBuilder&)> makeSource,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& postAggregationProjections,
-    std::function<std::shared_ptr<exec::Task>(exec::test::AssertQueryBuilder&)>
-        assertResults,
-    const std::unordered_map<std::string, std::string>& config) {
-  PlanBuilder builder(pool());
-  makeSource(builder);
-  auto input = AssertQueryBuilder(builder.planNode()).copyResults(pool());
-  if (input->size() < 2) {
-    return;
-  }
-  auto size1 = input->size() / 2;
-  auto size2 = input->size() - size1;
-  auto input1 = input->slice(0, size1);
-  auto input2 = input->slice(size1, size2);
-  std::vector<std::shared_ptr<exec::test::TempFilePath>> files;
-  std::vector<exec::Split> splits;
-  auto writerPool = rootPool_->addAggregateChild("AggregationTestBase.writer");
-  for (auto& vector : {input1, input2}) {
-    auto file = exec::test::TempFilePath::create();
-    writeToFile(file->path, vector, writerPool.get());
-    files.push_back(file);
-    splits.emplace_back(std::make_shared<connector::hive::HiveConnectorSplit>(
-        kHiveConnectorId, file->path, dwio::common::FileFormat::DWRF));
-  }
-  // No need to test streaming as the streaming test generates its own inputs,
-  // so it would be the same as the original test.
-  {
-    ScopedChange<bool> disableTestStreaming(&testStreaming_, false);
-    testAggregationsImpl(
-        [&](auto& builder) { builder.tableScan(asRowType(input->type())); },
-        groupingKeys,
-        aggregates,
-        postAggregationProjections,
-        [&](auto& builder) { return assertResults(builder.splits(splits)); },
-        config);
-  }
-
-  for (const auto& file : files) {
-    remove(file->path.c_str());
-  }
-}
-
-void AggregationTestBase::testAggregations(
-    const std::vector<RowVectorPtr>& data,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& postAggregationProjections,
-    const std::vector<RowVectorPtr>& expectedResult,
-    const std::unordered_map<std::string, std::string>& config,
-    bool testWithTableScan) {
-  testAggregations(
-      [&](PlanBuilder& builder) { builder.values(data); },
-      groupingKeys,
-      aggregates,
-      postAggregationProjections,
-      [&](auto& builder) { return builder.assertResults(expectedResult); },
-      config,
-      testWithTableScan);
-}
-
-void AggregationTestBase::testAggregations(
-    std::function<void(PlanBuilder&)> makeSource,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::string& duckDbSql,
-    const std::unordered_map<std::string, std::string>& config,
-    bool testWithTableScan) {
-  testAggregations(
-      makeSource,
-      groupingKeys,
-      aggregates,
-      {},
-      [&](auto& builder) { return builder.assertResults(duckDbSql); },
-      config,
-      testWithTableScan);
-}
-
-RowVectorPtr AggregationTestBase::validateStreamingInTestAggregations(
-    const std::function<void(PlanBuilder&)>& makeSource,
-    const std::vector<std::string>& aggregates,
-    const std::unordered_map<std::string, std::string>& config) {
-  PlanBuilder builder(pool());
-  makeSource(builder);
-  auto input = AssertQueryBuilder(builder.planNode())
-                   .configs(config)
-                   .copyResults(pool());
-  if (input->size() < 2) {
-    return nullptr;
-  }
-  auto size1 = input->size() / 2;
-  auto size2 = input->size() - size1;
-  builder.singleAggregation({}, aggregates);
-  auto expected = AssertQueryBuilder(builder.planNode())
-                      .configs(config)
-                      .copyResults(pool());
-  EXPECT_EQ(expected->size(), 1);
-  auto& aggregationNode =
-      static_cast<const core::AggregationNode&>(*builder.planNode());
-  EXPECT_EQ(expected->childrenSize(), aggregationNode.aggregates().size());
-  for (int i = 0; i < aggregationNode.aggregates().size(); ++i) {
-    const auto& aggregate = aggregationNode.aggregates()[i];
-    if (aggregate.distinct || !aggregate.sortingKeys.empty() ||
-        aggregate.mask != nullptr) {
-      // TODO Add support for all these cases.
-      return nullptr;
-    }
-
-    const auto& aggregateExpr = aggregate.call;
-    const auto& name = aggregateExpr->name();
-
-    SCOPED_TRACE(name);
-    std::vector<VectorPtr> rawInput1, rawInput2;
-    for (const auto& arg : aggregateExpr->inputs()) {
-      VectorPtr column;
-      auto channel = exec::exprToChannel(arg.get(), input->type());
-      if (channel == kConstantChannel) {
-        auto constant = dynamic_cast<const core::ConstantTypedExpr*>(arg.get());
-        column = constant->toConstantVector(pool());
-      } else {
-        column = input->childAt(channel);
-      }
-      rawInput1.push_back(column->slice(0, size1));
-      rawInput2.push_back(column->slice(size1, size2));
-    }
-
-    auto actualResult1 =
-        testStreaming(name, true, rawInput1, size1, rawInput2, size2, config);
-    velox::exec::test::assertEqualResults(
-        {makeRowVector({expected->childAt(i)})},
-        {makeRowVector({actualResult1})});
-    auto actualResult2 =
-        testStreaming(name, false, rawInput1, size1, rawInput2, size2, config);
-    velox::exec::test::assertEqualResults(
-        {makeRowVector({expected->childAt(i)})},
-        {makeRowVector({actualResult2})});
-  }
-  return expected;
-}
-
-void AggregationTestBase::testAggregationsImpl(
-    std::function<void(PlanBuilder&)> makeSource,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& postAggregationProjections,
-    std::function<std::shared_ptr<exec::Task>(AssertQueryBuilder&)>
-        assertResults,
-    const std::unordered_map<std::string, std::string>& config) {
-  {
-    SCOPED_TRACE("Run partial + final");
-    PlanBuilder builder(pool());
-    makeSource(builder);
-    builder.partialAggregation(groupingKeys, aggregates).finalAggregation();
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    assertResults(queryBuilder);
-  }
-
-  if (!groupingKeys.empty() && allowInputShuffle_) {
-    SCOPED_TRACE("Run partial + final with spilling");
-    PlanBuilder builder(pool());
-    makeSource(builder);
-
-    // Spilling needs at least 2 batches of input. Use round-robin
-    // repartitioning to split input into multiple batches.
-    core::PlanNodeId partialNodeId;
-    builder.localPartitionRoundRobinRow()
-        .partialAggregation(groupingKeys, aggregates)
-        .capturePlanNodeId(partialNodeId)
-        .localPartition(groupingKeys)
-        .finalAggregation();
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
-
-    ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
-    const auto peakSpillMemoryUsage = Spiller::pool()->stats().peakBytes;
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config)
-        .config(core::QueryConfig::kTestingSpillPct, "100")
-        .config(core::QueryConfig::kSpillEnabled, "true")
-        .config(core::QueryConfig::kAggregationSpillEnabled, "true")
-        .spillDirectory(spillDirectory->path)
-        .maxDrivers(4);
-
-    auto task = assertResults(queryBuilder);
-
-    // Expect > 0 spilled bytes unless there was no input.
-    auto inputRows = toPlanStats(task->taskStats()).at(partialNodeId).inputRows;
-    if (inputRows > 1) {
-      EXPECT_LT(0, spilledBytes(*task));
-      ASSERT_EQ(Spiller::pool()->stats().currentBytes, 0);
-      ASSERT_GT(Spiller::pool()->stats().peakBytes, 0);
-      ASSERT_GE(Spiller::pool()->stats().peakBytes, peakSpillMemoryUsage);
-    } else {
-      EXPECT_EQ(0, spilledBytes(*task));
-    }
-  }
-
-  if (!groupingKeys.empty()) {
-    SCOPED_TRACE("Run partial + final with abandon partial agg");
-    PlanBuilder builder(pool());
-    makeSource(builder);
-
-    core::PlanNodeId partialNodeId;
-    core::PlanNodeId intermediateNodeId;
-    builder.partialAggregation(groupingKeys, aggregates)
-        .capturePlanNodeId(partialNodeId)
-        .intermediateAggregation()
-        .capturePlanNodeId(intermediateNodeId)
-        .finalAggregation();
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    enableAbandonPartialAggregation(queryBuilder);
-
-    auto task = assertResults(queryBuilder);
-
-    // Expect partial aggregation was turned off if there were more than 1 input
-    // batches.
-    auto taskStats = toPlanStats(task->taskStats());
-    auto inputVectors = taskStats.at(partialNodeId).inputVectors;
-    auto partialStats = taskStats.at(partialNodeId).customStats;
-    auto intermediateStats = taskStats.at(intermediateNodeId).customStats;
-    if (inputVectors > 1) {
-      EXPECT_LT(0, partialStats.at("abandonedPartialAggregation").count);
-      EXPECT_LT(0, intermediateStats.at("abandonedPartialAggregation").count);
-    }
-  }
-
-  {
-    SCOPED_TRACE("Run single");
-    PlanBuilder builder(pool());
-    makeSource(builder);
-    builder.singleAggregation(groupingKeys, aggregates);
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    assertResults(queryBuilder);
-  }
-
-  // TODO: turn on this after spilling for VarianceAggregationTest pass.
-#if 0
-  if (!groupingKeys.empty() && allowInputShuffle_) {
-    SCOPED_TRACE("Run single with spilling");
-    PlanBuilder builder(pool());
-    makeSource(builder);
-    core::PlanNodeId aggregationNodeId;
-    builder.singleAggregation(groupingKeys, aggregates)
-        .capturePlanNodeId(aggregationNodeId);
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    auto spillDirectory = exec::test::TempDirectoryPath::create();
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config).config(core::QueryConfig::kTestingSpillPct, "100")
-        .config(core::QueryConfig::kSpillEnabled, "true")
-        .config(core::QueryConfig::kAggregationSpillEnabled, "true")
-        .spillDirectory(spillDirectory->path);
-
-    auto task = assertResults(queryBuilder);
-
-    // Expect > 0 spilled bytes unless there was no input.
-    auto inputRows =
-        toPlanStats(task->taskStats()).at(aggregationNodeId).inputRows;
-    if (inputRows > 1) {
-      EXPECT_LT(0, spilledBytes(*task));
-    } else {
-      EXPECT_EQ(0, spilledBytes(*task));
-    }
-  }
-#endif
-
-  {
-    SCOPED_TRACE("Run partial + intermediate + final");
-    PlanBuilder builder(pool());
-    makeSource(builder);
-
-    builder.partialAggregation(groupingKeys, aggregates)
-        .intermediateAggregation()
-        .finalAggregation();
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    assertResults(queryBuilder);
-  }
-
-  if (!groupingKeys.empty()) {
-    SCOPED_TRACE("Run partial + local exchange + final");
-    PlanBuilder builder(pool());
-    makeSource(builder);
-
-    builder.partialAggregation(groupingKeys, aggregates)
-        .localPartition(groupingKeys)
-        .finalAggregation();
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    assertResults(queryBuilder.maxDrivers(4));
-  }
-
-  {
-    SCOPED_TRACE(
-        "Run partial + local exchange + intermediate + local exchange + final");
-    PlanBuilder builder(pool());
-    makeSource(builder);
-
-    builder.partialAggregation(groupingKeys, aggregates);
-
-    if (groupingKeys.empty()) {
-      builder.localPartitionRoundRobinRow();
-    } else {
-      builder.localPartition(groupingKeys);
-    }
-
-    builder.intermediateAggregation()
-        .localPartition(groupingKeys)
-        .finalAggregation();
-
-    if (!postAggregationProjections.empty()) {
-      builder.project(postAggregationProjections);
-    }
-
-    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
-    queryBuilder.configs(config);
-    assertResults(queryBuilder.maxDrivers(2));
-  }
-
-  if (testStreaming_ && groupingKeys.empty() &&
-      postAggregationProjections.empty()) {
-    SCOPED_TRACE("Streaming");
-    validateStreamingInTestAggregations(makeSource, aggregates, config);
-  }
-}
-
-void AggregationTestBase::testAggregations(
-    std::function<void(PlanBuilder&)> makeSource,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::vector<std::string>& postAggregationProjections,
-    std::function<std::shared_ptr<exec::Task>(AssertQueryBuilder&)>
-        assertResults,
-    const std::unordered_map<std::string, std::string>& config,
-    bool testWithTableScan) {
-  testAggregationsImpl(
-      makeSource,
-      groupingKeys,
-      aggregates,
-      postAggregationProjections,
-      assertResults,
-      config);
-
-  if (testWithTableScan) {
-    SCOPED_TRACE("Test reading input from table scan");
-    testReadFromFiles(
-        makeSource,
-        groupingKeys,
-        aggregates,
-        postAggregationProjections,
-        assertResults,
-        config);
-  }
-}
-
-namespace {
-std::pair<TypePtr, TypePtr> getResultTypes(
-    const std::string& name,
-    const std::vector<TypePtr>& rawInputTypes) {
-  auto signatures = exec::getAggregateFunctionSignatures(name);
-  if (!signatures.has_value()) {
-    VELOX_FAIL("Aggregate {} not registered", name);
-  }
-  for (auto& signature : signatures.value()) {
-    exec::SignatureBinder binder(*signature, rawInputTypes);
-    if (binder.tryBind()) {
-      auto intermediateType =
-          binder.tryResolveType(signature->intermediateType());
-      VELOX_CHECK(
-          intermediateType, "failed to resolve intermediate type for {}", name);
-      auto finalType = binder.tryResolveType(signature->returnType());
-      VELOX_CHECK(finalType, "failed to resolve final type for {}", name);
-      return {intermediateType, finalType};
-    }
-  }
-  VELOX_FAIL("Could not infer intermediate type for aggregate {}", name);
-}
-} // namespace
-
-VectorPtr AggregationTestBase::testStreaming(
-    const std::string& functionName,
-    bool testGlobal,
-    const std::vector<VectorPtr>& rawInput1,
-    const std::vector<VectorPtr>& rawInput2,
-    const std::unordered_map<std::string, std::string>& config) {
-  VELOX_CHECK(!rawInput1.empty());
-  VELOX_CHECK(!rawInput2.empty());
-  return testStreaming(
-      functionName,
-      testGlobal,
-      rawInput1,
-      rawInput1[0]->size(),
-      rawInput2,
-      rawInput2[0]->size(),
-      config);
-}
-
-VectorPtr AggregationTestBase::testStreaming(
-    const std::string& functionName,
-    bool testGlobal,
-    const std::vector<VectorPtr>& rawInput1,
-    vector_size_t rawInput1Size,
-    const std::vector<VectorPtr>& rawInput2,
-    vector_size_t rawInput2Size,
-    const std::unordered_map<std::string, std::string>& config) {
-  constexpr int kRowSizeOffset = 8;
-  constexpr int kOffset = kRowSizeOffset + 8;
-  HashStringAllocator allocator(pool());
-  std::vector<TypePtr> rawInputTypes;
-  for (auto& vec : rawInput1) {
-    rawInputTypes.push_back(vec->type());
-  }
-  auto [intermediateType, finalType] =
-      getResultTypes(functionName, rawInputTypes);
-  auto createFunction = [&, &finalType = finalType] {
-    core::QueryConfig queryConfig({config});
-    auto func = exec::Aggregate::create(
-        functionName,
-        core::AggregationNode::Step::kSingle,
-        rawInputTypes,
-        finalType,
-        queryConfig);
-    func->setAllocator(&allocator);
-    func->setOffsets(kOffset, 0, 1, kRowSizeOffset);
-    return func;
-  };
-  auto func = createFunction();
-  int maxRowCount = std::max(rawInput1Size, rawInput2Size);
-  std::vector<char> group(kOffset + func->accumulatorFixedWidthSize());
-  std::vector<char*> groups(maxRowCount, group.data());
-  std::vector<vector_size_t> indices(maxRowCount, 0);
-  func->initializeNewGroups(groups.data(), indices);
-  if (testGlobal) {
-    func->addSingleGroupRawInput(
-        group.data(), SelectivityVector(rawInput1Size), rawInput1, false);
-  } else {
-    func->addRawInput(
-        groups.data(), SelectivityVector(rawInput1Size), rawInput1, false);
-  }
-  auto intermediate = BaseVector::create(intermediateType, 1, pool());
-  func->extractAccumulators(groups.data(), 1, &intermediate);
-  // Destroy accumulators to avoid memory leak.
-  if (func->accumulatorUsesExternalMemory()) {
-    func->destroy(folly::Range(groups.data(), 1));
-  }
-
-  // Create a new function picking up the intermediate result.
-  auto func2 = createFunction();
-  func2->initializeNewGroups(groups.data(), indices);
-  if (testGlobal) {
-    func2->addSingleGroupIntermediateResults(
-        group.data(), SelectivityVector(1), {intermediate}, false);
-  } else {
-    func2->addIntermediateResults(
-        groups.data(), SelectivityVector(1), {intermediate}, false);
-  }
-  // Add more raw input.
-  if (testGlobal) {
-    func2->addSingleGroupRawInput(
-        group.data(), SelectivityVector(rawInput2Size), rawInput2, false);
-  } else {
-    func2->addRawInput(
-        groups.data(), SelectivityVector(rawInput2Size), rawInput2, false);
-  }
-  auto result = BaseVector::create(finalType, 1, pool());
-  func2->extractValues(groups.data(), 1, &result);
-  // Destroy accumulators to avoid memory leak.
-  if (func2->accumulatorUsesExternalMemory()) {
-    func2->destroy(folly::Range(groups.data(), 1));
-  }
-
-  return result;
-}
-
-void AggregationTestBase::testFailingAggregations(
-    const std::vector<RowVectorPtr>& data,
-    const std::vector<std::string>& groupingKeys,
-    const std::vector<std::string>& aggregates,
-    const std::string& expectedMessage,
-    const std::unordered_map<std::string, std::string>& config) {
-  {
-    SCOPED_TRACE("Run single");
-    auto builder = PlanBuilder().values(data);
-    builder.singleAggregation(groupingKeys, aggregates);
-    AssertQueryBuilder queryBuilder(builder.planNode());
-    queryBuilder.configs(config);
-    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
-  }
-
-  {
-    SCOPED_TRACE("Run partial + final");
-    auto builder = PlanBuilder().values(data);
-    builder.partialAggregation(groupingKeys, aggregates).finalAggregation();
-    AssertQueryBuilder queryBuilder(builder.planNode());
-    queryBuilder.configs(config);
-    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
-  }
-
-  {
-    SCOPED_TRACE("Run partial + final with abandon partial agg");
-    auto builder = PlanBuilder().values(data);
-    builder.partialAggregation(groupingKeys, aggregates)
-        .intermediateAggregation()
-        .finalAggregation();
-    AssertQueryBuilder queryBuilder(builder.planNode());
-    queryBuilder.configs(config);
-    enableAbandonPartialAggregation(queryBuilder);
-    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
-  }
-
-  {
-    SCOPED_TRACE("Run partial + intermediate + final");
-    auto builder = PlanBuilder().values(data);
-    builder.partialAggregation(groupingKeys, aggregates)
-        .intermediateAggregation()
-        .finalAggregation();
-    AssertQueryBuilder queryBuilder(builder.planNode());
-    queryBuilder.configs(config);
-    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
-  }
-
-  if (!groupingKeys.empty()) {
-    SCOPED_TRACE("Run partial + local exchange + final");
-    auto builder = PlanBuilder().values(data);
-    builder.partialAggregation(groupingKeys, aggregates)
-        .localPartition(groupingKeys)
-        .finalAggregation();
-    AssertQueryBuilder queryBuilder(builder.planNode());
-    queryBuilder.configs(config);
-    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
-  }
-
-  {
-    SCOPED_TRACE(
-        "Run partial + local exchange + intermediate + local exchange + final");
-    auto builder = PlanBuilder().values(data);
-    builder.partialAggregation(groupingKeys, aggregates);
-
-    if (groupingKeys.empty()) {
-      builder.localPartitionRoundRobinRow();
-    } else {
-      builder.localPartition(groupingKeys);
-    }
-
-    builder.intermediateAggregation()
-        .localPartition(groupingKeys)
-        .finalAggregation();
-
-    AssertQueryBuilder queryBuilder(builder.planNode());
-    queryBuilder.configs(config);
-    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
-  }
-
-  if (testStreaming_ && groupingKeys.empty()) {
-    SCOPED_TRACE("Streaming");
-    auto makeSource = [&](PlanBuilder& builder) { builder.values(data); };
-    VELOX_ASSERT_THROW(
-        validateStreamingInTestAggregations(makeSource, aggregates, config),
-        expectedMessage);
-  }
-}
-} // namespace facebook::velox::functions::aggregate::test
diff --git a/velox/functions/lib/aggregates/tests/CMakeLists.txt b/velox/functions/lib/aggregates/tests/CMakeLists.txt
index 8bc20099e91b9..cd51532cc277e 100644
--- a/velox/functions/lib/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/lib/aggregates/tests/CMakeLists.txt
@@ -12,7 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_functions_aggregates_test_lib AggregationTestBase.cpp)
+add_subdirectory(utils)
 
-target_link_libraries(velox_functions_aggregates_test_lib velox_exec_test_lib
-                      velox_vector_test_lib)
+add_executable(velox_functions_aggregates_test ValueListTest.cpp)
+
+add_test(NAME velox_functions_aggregates_test
+         COMMAND velox_functions_aggregates_test)
+
+target_link_libraries(
+  velox_functions_aggregates_test
+  velox_functions_aggregates
+  velox_functions_test_lib
+  Folly::folly
+  GTest::gtest
+  GTest::gtest_main
+  glog::glog)
diff --git a/velox/functions/lib/aggregates/tests/SumTestBase.h b/velox/functions/lib/aggregates/tests/SumTestBase.h
new file mode 100644
index 0000000000000..4ddf57515f8ca
--- /dev/null
+++ b/velox/functions/lib/aggregates/tests/SumTestBase.h
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "folly/CPortability.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/AggregationHook.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+namespace facebook::velox::functions::aggregate::test {
+
+template <typename Type>
+struct SumRow {
+  char nulls;
+  Type sum;
+};
+
+template <typename InputType, typename ResultType, bool Overflow = false>
+#if defined(FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER)
+FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER("signed-integer-overflow")
+#endif
+void testHookLimits(bool expectOverflow = false) {
+  // Pair of <limit, value to overflow>.
+  std::vector<std::pair<InputType, InputType>> limits = {
+      {std::numeric_limits<InputType>::min(), -1},
+      {std::numeric_limits<InputType>::max(), 1}};
+
+  for (const auto& [limit, overflow] : limits) {
+    SumRow<ResultType> sumRow;
+    sumRow.sum = 0;
+    ResultType expected = 0;
+    char* row = reinterpret_cast<char*>(&sumRow);
+    uint64_t numNulls = 0;
+    facebook::velox::aggregate::SumHook<ResultType, Overflow> hook(
+        offsetof(SumRow<ResultType>, sum),
+        offsetof(SumRow<ResultType>, nulls),
+        0,
+        &row,
+        &numNulls);
+
+    // Adding limit should not overflow.
+    ASSERT_NO_THROW(hook.addValueTyped(0, limit));
+    expected += limit;
+    EXPECT_EQ(expected, sumRow.sum);
+    // Adding overflow based on the ResultType should throw.
+    if (expectOverflow) {
+      VELOX_ASSERT_THROW(hook.addValueTyped(0, overflow), "overflow");
+    } else {
+      ASSERT_NO_THROW(hook.addValueTyped(0, overflow));
+      expected += overflow;
+      EXPECT_EQ(expected, sumRow.sum);
+    }
+  }
+}
+
+class SumTestBase : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+
+  template <
+      typename InputType,
+      typename ResultType,
+      typename IntermediateType = ResultType>
+  void testAggregateOverflow(
+      const std::string& function,
+      bool expectOverflow = false,
+      const TypePtr& type = CppToType<InputType>::create());
+};
+
+template <typename ResultType>
+void verifyAggregates(
+    const std::vector<std::pair<core::PlanNodePtr, ResultType>>& aggsToTest,
+    bool expectOverflow) {
+  for (const auto& [agg, expectedResult] : aggsToTest) {
+    if (expectOverflow) {
+      VELOX_ASSERT_THROW(
+          facebook::velox::exec::test::readSingleValue(agg), "overflow");
+    } else {
+      auto result = facebook::velox::exec::test::readSingleValue(agg);
+      if constexpr (std::is_same_v<ResultType, float>) {
+        ASSERT_FLOAT_EQ(
+            result.template value<TypeKind::REAL>(), expectedResult);
+      } else if constexpr (std::is_same_v<ResultType, double>) {
+        ASSERT_FLOAT_EQ(
+            result.template value<TypeKind::DOUBLE>(), expectedResult);
+      } else {
+        ASSERT_EQ(result, expectedResult);
+      }
+    }
+  }
+}
+
+template <typename InputType, typename ResultType, typename IntermediateType>
+#if defined(FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER)
+FOLLY_DISABLE_UNDEFINED_BEHAVIOR_SANITIZER("signed-integer-overflow")
+#endif
+void SumTestBase::testAggregateOverflow(
+    const std::string& function,
+    bool expectOverflow,
+    const TypePtr& type) {
+  const InputType maxLimit = std::numeric_limits<InputType>::max();
+  const InputType overflow = InputType(1);
+  const InputType zero = InputType(0);
+
+  // Intermediate type size is always >= result type size. Hence, use
+  // intermediate type to calculate the expected output.
+  IntermediateType limitResult = IntermediateType(maxLimit);
+  IntermediateType overflowResult = IntermediateType(overflow);
+
+  // Single max limit value. 0's to induce dummy calculations.
+  auto limitVector =
+      makeRowVector({makeFlatVector<InputType>({maxLimit, zero, zero}, type)});
+
+  // Test code path for single values with possible overflow hit in add.
+  auto overflowFlatVector =
+      makeRowVector({makeFlatVector<InputType>({maxLimit, overflow}, type)});
+  IntermediateType expectedFlatSum = limitResult + overflowResult;
+
+  // Test code path for duplicate values with possible overflow hit in
+  // multiply.
+  auto overflowConstantVector =
+      makeRowVector({makeConstant<InputType>(maxLimit / 3, 4, type)});
+  IntermediateType expectedConstantSum = (limitResult / 3) * 4;
+
+  // Test code path for duplicate values with possible overflow hit in add.
+  auto overflowHybridVector = {limitVector, overflowConstantVector};
+  IntermediateType expectedHybridSum = limitResult + expectedConstantSum;
+
+  // Vector with element pairs of a partial aggregate node, expected result.
+  std::vector<std::pair<core::PlanNodePtr, IntermediateType>> partialAggsToTest;
+  // Partial Aggregation (raw input in - partial result out).
+  partialAggsToTest.push_back(
+      {facebook::velox::exec::test::PlanBuilder()
+           .values({overflowFlatVector})
+           .partialAggregation({}, {fmt::format("{}(c0)", function)})
+           .planNode(),
+       expectedFlatSum});
+  partialAggsToTest.push_back(
+      {facebook::velox::exec::test::PlanBuilder()
+           .values({overflowConstantVector})
+           .partialAggregation({}, {fmt::format("{}(c0)", function)})
+           .planNode(),
+       expectedConstantSum});
+  partialAggsToTest.push_back(
+      {facebook::velox::exec::test::PlanBuilder()
+           .values(overflowHybridVector)
+           .partialAggregation({}, {fmt::format("{}(c0)", function)})
+           .planNode(),
+       expectedHybridSum});
+
+  // Vector with element pairs of a full aggregate node, expected result.
+  std::vector<std::pair<core::PlanNodePtr, ResultType>> aggsToTest;
+  // Single Aggregation (raw input in - final result out).
+  aggsToTest.push_back(
+      {facebook::velox::exec::test::PlanBuilder()
+           .values({overflowFlatVector})
+           .singleAggregation({}, {fmt::format("{}(c0)", function)})
+           .planNode(),
+       expectedFlatSum});
+  aggsToTest.push_back(
+      {facebook::velox::exec::test::PlanBuilder()
+           .values({overflowConstantVector})
+           .singleAggregation({}, {fmt::format("{}(c0)", function)})
+           .planNode(),
+       expectedConstantSum});
+  aggsToTest.push_back(
+      {facebook::velox::exec::test::PlanBuilder()
+           .values(overflowHybridVector)
+           .singleAggregation({}, {fmt::format("{}(c0)", function)})
+           .planNode(),
+       expectedHybridSum});
+  // Final Aggregation (partial result in - final result out):
+  // To make sure that the overflow occurs in the final aggregation step, we
+  // create 2 plan fragments and plugging their partially aggregated
+  // output into a final aggregate plan node. Each of those input fragments
+  // only have a single input value under the max limit which when added in
+  // the final step causes a potential overflow.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  aggsToTest.push_back(
+      {facebook::velox::exec::test::PlanBuilder(planNodeIdGenerator)
+           .localPartition(
+               {},
+               {facebook::velox::exec::test::PlanBuilder(planNodeIdGenerator)
+                    .values({limitVector})
+                    .partialAggregation({}, {fmt::format("{}(c0)", function)})
+                    .planNode(),
+                facebook::velox::exec::test::PlanBuilder(planNodeIdGenerator)
+                    .values({limitVector})
+                    .partialAggregation({}, {fmt::format("{}(c0)", function)})
+                    .planNode()})
+           .finalAggregation()
+           .planNode(),
+       limitResult + limitResult});
+
+  // Verify all partial aggregates.
+  verifyAggregates<IntermediateType>(partialAggsToTest, expectOverflow);
+  // Verify all aggregates.
+  verifyAggregates<ResultType>(aggsToTest, expectOverflow);
+}
+
+} // namespace facebook::velox::functions::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ValueListTest.cpp b/velox/functions/lib/aggregates/tests/ValueListTest.cpp
similarity index 89%
rename from velox/functions/prestosql/aggregates/tests/ValueListTest.cpp
rename to velox/functions/lib/aggregates/tests/ValueListTest.cpp
index d8119d0ee4cef..4cab4463a56e2 100644
--- a/velox/functions/prestosql/aggregates/tests/ValueListTest.cpp
+++ b/velox/functions/lib/aggregates/tests/ValueListTest.cpp
@@ -13,10 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/functions/prestosql/aggregates/ValueList.h"
+#include "velox/functions/lib/aggregates/ValueList.h"
 #include <gtest/gtest.h>
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::test;
@@ -79,7 +78,8 @@ class ValueListTest : public functions::test::FunctionBaseTest {
     return allocator_.get();
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   std::unique_ptr<HashStringAllocator> allocator_{
       std::make_unique<HashStringAllocator>(pool_.get())};
 };
@@ -112,13 +112,20 @@ TEST_F(ValueListTest, integers) {
 
 TEST_F(ValueListTest, arrays) {
   // No nulls.
+  int32_t kSizeCaps[] = {730, 4000, 7500, 50000};
+  int32_t counter = 0;
   for (auto size : kTestSizes) {
     auto data = makeArrayVector<int32_t>(
         size,
         [](auto row) { return row % 7; },
         [](auto row) { return row % 11; });
 
+    auto previousBytes = allocator()->currentBytes();
     testRoundTrip(data);
+    if (counter < sizeof(kSizeCaps) / sizeof(kSizeCaps[0])) {
+      auto cap = kSizeCaps[counter++];
+      EXPECT_GT(cap, allocator()->currentBytes() - previousBytes);
+    }
   }
 
   // Different percentage of nulls.
diff --git a/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp b/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp
new file mode 100644
index 0000000000000..dd24e110cc673
--- /dev/null
+++ b/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp
@@ -0,0 +1,1499 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/exec/AggregateCompanionSignatures.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/Spill.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/SignatureBinder.h"
+
+using facebook::velox::exec::Spiller;
+using facebook::velox::exec::test::AssertQueryBuilder;
+using facebook::velox::exec::test::CursorParameters;
+using facebook::velox::exec::test::PlanBuilder;
+using facebook::velox::test::VectorMaker;
+
+namespace facebook::velox::functions::aggregate::test {
+
+namespace {
+constexpr const char* kHiveConnectorId = "test-hive";
+
+void enableAbandonPartialAggregation(AssertQueryBuilder& queryBuilder) {
+  queryBuilder.config(core::QueryConfig::kAbandonPartialAggregationMinRows, 1)
+      .config(core::QueryConfig::kAbandonPartialAggregationMinPct, 0)
+      .config(core::QueryConfig::kMaxPartialAggregationMemory, 0)
+      .config(core::QueryConfig::kMaxExtendedPartialAggregationMemory, 0)
+      .maxDrivers(1);
+}
+
+} // namespace
+
+std::vector<RowVectorPtr> AggregationTestBase::makeVectors(
+    const RowTypePtr& rowType,
+    vector_size_t size,
+    int numVectors) {
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < numVectors; ++i) {
+    auto vector = std::dynamic_pointer_cast<RowVector>(
+        velox::test::BatchMaker::createBatch(rowType, size, *pool_));
+    vectors.push_back(vector);
+  }
+  return vectors;
+}
+
+void AggregationTestBase::SetUp() {
+  OperatorTestBase::SetUp();
+  filesystems::registerLocalFileSystem();
+  auto hiveConnector =
+      connector::getConnectorFactory(
+          connector::hive::HiveConnectorFactory::kHiveConnectorName)
+          ->newConnector(
+              kHiveConnectorId,
+              std::make_shared<config::ConfigBase>(
+                  std::unordered_map<std::string, std::string>()));
+  connector::registerConnector(hiveConnector);
+}
+
+void AggregationTestBase::TearDown() {
+  connector::unregisterConnector(kHiveConnectorId);
+  OperatorTestBase::TearDown();
+}
+
+void AggregationTestBase::testAggregations(
+    const std::vector<RowVectorPtr>& data,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::string& duckDbSql,
+    const std::unordered_map<std::string, std::string>& config) {
+  SCOPED_TRACE(duckDbSql);
+  testAggregations(data, groupingKeys, aggregates, {}, duckDbSql, config);
+}
+
+void AggregationTestBase::testAggregations(
+    const std::vector<RowVectorPtr>& data,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<RowVectorPtr>& expectedResult,
+    const std::unordered_map<std::string, std::string>& config) {
+  testAggregations(data, groupingKeys, aggregates, {}, expectedResult, config);
+}
+
+void AggregationTestBase::testAggregations(
+    const std::vector<RowVectorPtr>& data,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& postAggregationProjections,
+    const std::string& duckDbSql,
+    const std::unordered_map<std::string, std::string>& config) {
+  SCOPED_TRACE(duckDbSql);
+  testAggregations(
+      [&](PlanBuilder& builder) { builder.values(data); },
+      groupingKeys,
+      aggregates,
+      postAggregationProjections,
+      [&](auto& builder) { return builder.assertResults(duckDbSql); },
+      config);
+}
+
+namespace {
+// Returns total spilled bytes inside 'task'.
+int64_t spilledBytes(const exec::Task& task) {
+  auto stats = task.taskStats();
+  int64_t spilledBytes = 0;
+  for (auto& pipeline : stats.pipelineStats) {
+    for (auto op : pipeline.operatorStats) {
+      spilledBytes += op.spilledBytes;
+    }
+  }
+  return spilledBytes;
+}
+
+// Returns total spilled rows inside 'task'.
+int64_t spilledRows(const exec::Task& task) {
+  auto stats = task.taskStats();
+  int64_t spilledRows = 0;
+  for (auto& pipeline : stats.pipelineStats) {
+    for (auto op : pipeline.operatorStats) {
+      spilledRows += op.spilledRows;
+    }
+  }
+  return spilledRows;
+}
+
+// Returns total spilled input bytes inside 'task'.
+int64_t spilledInputBytes(const exec::Task& task) {
+  auto stats = task.taskStats();
+  int64_t spilledInputBytes = 0;
+  for (auto& pipeline : stats.pipelineStats) {
+    for (auto op : pipeline.operatorStats) {
+      spilledInputBytes += op.spilledInputBytes;
+    }
+  }
+  return spilledInputBytes;
+}
+
+// Returns total spilled files inside 'task'.
+int64_t spilledFiles(const exec::Task& task) {
+  auto stats = task.taskStats();
+  int64_t spilledFiles = 0;
+  for (auto& pipeline : stats.pipelineStats) {
+    for (auto op : pipeline.operatorStats) {
+      spilledFiles += op.spilledFiles;
+    }
+  }
+  return spilledFiles;
+}
+
+// Add a BIGINT column of 4 distinct values to data.
+RowVectorPtr addExtraGroupingKeyImpl(
+    const RowVectorPtr& data,
+    const std::vector<std::string>& fieldNames,
+    VectorMaker& vectorMaker) {
+  auto children = data->children();
+  children.push_back(vectorMaker.flatVector<int64_t>(
+      data->size(), [](auto row) { return row % 4; }));
+  return vectorMaker.rowVector(fieldNames, children);
+}
+
+// Add a BIGINT column of 4 distinct values to every RowVector in data.
+std::vector<RowVectorPtr> addExtraGroupingKey(
+    const std::vector<RowVectorPtr>& data,
+    const std::string& extraKeyName) {
+  VELOX_CHECK(!data.empty());
+  auto names = asRowType(data[0]->type())->names();
+  names.push_back(extraKeyName);
+
+  std::vector<RowVectorPtr> newData{data.size()};
+  VectorMaker vectorMaker{data[0]->pool()};
+  std::transform(
+      data.begin(),
+      data.end(),
+      newData.begin(),
+      [&names, &vectorMaker](const RowVectorPtr& vector) {
+        return addExtraGroupingKeyImpl(vector, names, vectorMaker);
+      });
+  return newData;
+}
+
+// Given the name of the original aggregation function and the argument types,
+// return the name of the extract companion function with a suffix of the result
+// type. Extract function names with suffixes should only be used when the
+// original aggregation function has multiple signatures with the same
+// intermediate type.
+std::string getExtractFunctionNameWithSuffix(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes) {
+  auto signatures = exec::getAggregateFunctionSignatures(name);
+  VELOX_CHECK(signatures.has_value());
+
+  for (const auto& signature : signatures.value()) {
+    exec::SignatureBinder binder{*signature, argTypes};
+    if (binder.tryBind()) {
+      if (auto resultType = binder.tryResolveReturnType()) {
+        return exec::CompanionSignatures::extractFunctionNameWithSuffix(
+            name, signature->returnType());
+      }
+    }
+  }
+  VELOX_UNREACHABLE("Could not find a function bound to argTypes.");
+}
+
+// Given the `index`-th aggregation expression, e.g., "avg(c0)", return three
+// strings of its partial companion aggregation expression, merge companion
+// aggregation expression, and extract companion expression, e.g.,
+// {"avg_partial(c0)", "avg_merge(a0)", "avg_extract_double(a0)"} when `index`
+// is 0.
+std::tuple<std::string, std::string, std::string> getCompanionAggregates(
+    column_index_t index,
+    const exec::CompanionFunctionSignatureMap& companionFunctions,
+    const std::string& functionName,
+    const std::string& aggregateArgs,
+    const std::vector<TypePtr>& argTypes) {
+  VELOX_CHECK_EQ(companionFunctions.partial.size(), 1);
+  auto partialAggregate = fmt::format(
+      "{}({})", companionFunctions.partial.front().functionName, aggregateArgs);
+
+  VELOX_CHECK_EQ(companionFunctions.merge.size(), 1);
+  auto mergeAggregate = fmt::format(
+      "{}(a{})", companionFunctions.merge.front().functionName, index);
+
+  // Construct the extract expression. Rename the result of the extract
+  // expression to be the same as the original aggregation result, so that
+  // post-aggregation proejctions, if exist, can apply with no change.
+  std::string extractExpression;
+  if (companionFunctions.extract.size() == 1) {
+    extractExpression = fmt::format(
+        "{0}(a{1}) as a{1}",
+        companionFunctions.extract.front().functionName,
+        index);
+  } else {
+    VELOX_CHECK_GT(companionFunctions.extract.size(), 1);
+    auto extractFunctionName =
+        getExtractFunctionNameWithSuffix(functionName, argTypes);
+    extractExpression =
+        fmt::format("{0}(a{1}) as a{1}", extractFunctionName, index);
+  }
+  return std::make_tuple(partialAggregate, mergeAggregate, extractExpression);
+}
+
+// Given a list of aggregation expressions, e.g., {"avg(c0)"}, return a list of
+// aggregate function names and a list of arguments in these expressions, e.g.,
+// {{"avg"}, {"c0"}}.
+std::tuple<std::vector<std::string>, std::vector<std::string>>
+getFunctionNamesAndArgs(const std::vector<std::string>& aggregates) {
+  std::vector<std::string> functionNames;
+  std::vector<std::string> aggregateArgs;
+  for (const auto& aggregate : aggregates) {
+    std::vector<std::string> tokens;
+    folly::split('(', aggregate, tokens);
+    VELOX_CHECK_EQ(tokens.size(), 2);
+    functionNames.push_back(tokens[0]);
+    aggregateArgs.push_back(tokens[1].substr(0, tokens[1].find(')')));
+  }
+  return std::make_pair(functionNames, aggregateArgs);
+}
+
+// Given a list of aggregation expressions, e.g., {"avg(c0)",
+// "\"$internal$count_distinct\"(c1)"}, fetch the function names from
+// AggregationNode of builder.planNode().
+std::vector<std::string> getFunctionNames(
+    std::function<void(exec::test::PlanBuilder&)> makeSource,
+    const std::vector<std::string>& aggregates,
+    memory::MemoryPool* pool) {
+  std::vector<std::string> functionNames;
+
+  PlanBuilder builder(pool);
+  makeSource(builder);
+
+  builder.singleAggregation({}, aggregates);
+  auto& aggregationNode =
+      static_cast<const core::AggregationNode&>(*builder.planNode());
+
+  for (const auto& aggregate : aggregationNode.aggregates()) {
+    const auto& aggregateExpr = aggregate.call;
+    const auto& name = aggregateExpr->name();
+
+    functionNames.push_back(name);
+  }
+
+  return functionNames;
+}
+
+// Given a list of aggregation expressions, check if any of aggregate functions
+// are order sensitive with metadata.
+bool hasOrderSensitive(
+    std::function<void(exec::test::PlanBuilder&)> makeSource,
+    const std::vector<std::string>& aggregates,
+    memory::MemoryPool* pool) {
+  auto functionNames = getFunctionNames(makeSource, aggregates, pool);
+  return std::any_of(
+      functionNames.begin(), functionNames.end(), [](const auto& functionName) {
+        auto* entry = exec::getAggregateFunctionEntry(functionName);
+        const auto& metadata = entry->metadata;
+        return metadata.orderSensitive;
+      });
+}
+// Same as above, but allows to specify input data instead of a function.
+bool hasOrderSensitive(
+    const std::vector<RowVectorPtr>& data,
+    const std::vector<std::string>& aggregates,
+    memory::MemoryPool* pool) {
+  return hasOrderSensitive(
+      [&](PlanBuilder& builder) { builder.values(data); }, aggregates, pool);
+}
+} // namespace
+
+void AggregationTestBase::testAggregationsWithCompanion(
+    const std::vector<RowVectorPtr>& data,
+    const std::function<void(PlanBuilder&)>& preAggregationProcessing,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::vector<TypePtr>>& aggregatesArgTypes,
+    const std::vector<std::string>& postAggregationProjections,
+    const std::string& duckDbSql,
+    const std::unordered_map<std::string, std::string>& config) {
+  testAggregationsWithCompanion(
+      data,
+      preAggregationProcessing,
+      groupingKeys,
+      aggregates,
+      aggregatesArgTypes,
+      postAggregationProjections,
+      [&](auto& builder) { return builder.assertResults(duckDbSql); },
+      config);
+}
+
+void AggregationTestBase::testAggregationsWithCompanion(
+    const std::vector<RowVectorPtr>& data,
+    const std::function<void(PlanBuilder&)>& preAggregationProcessing,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::vector<TypePtr>>& aggregatesArgTypes,
+    const std::vector<std::string>& postAggregationProjections,
+    const std::vector<RowVectorPtr>& expectedResult,
+    const std::unordered_map<std::string, std::string>& config) {
+  testAggregationsWithCompanion(
+      data,
+      preAggregationProcessing,
+      groupingKeys,
+      aggregates,
+      aggregatesArgTypes,
+      postAggregationProjections,
+      [&](auto& builder) { return builder.assertResults(expectedResult); },
+      config);
+}
+
+void AggregationTestBase::testAggregationsWithCompanion(
+    const std::vector<RowVectorPtr>& data,
+    const std::function<void(PlanBuilder&)>& preAggregationProcessing,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::vector<TypePtr>>& aggregatesArgTypes,
+    const std::vector<std::string>& postAggregationProjections,
+    std::function<std::shared_ptr<exec::Task>(exec::test::AssertQueryBuilder&)>
+        assertResults,
+    const std::unordered_map<std::string, std::string>& config) {
+  auto dataWithExtraGroupingKey = addExtraGroupingKey(data, "k0");
+  auto groupingKeysWithPartialKey = groupingKeys;
+  groupingKeysWithPartialKey.push_back("k0");
+
+  std::vector<std::string> paritialAggregates;
+  std::vector<std::string> mergeAggregates;
+  std::vector<std::string> extractExpressions;
+  extractExpressions.insert(
+      extractExpressions.end(), groupingKeys.begin(), groupingKeys.end());
+
+  auto [functionNames, aggregateArgs] = getFunctionNamesAndArgs(aggregates);
+  for (size_t i = 0, size = functionNames.size(); i < size; ++i) {
+    const auto& companionSignatures =
+        exec::getCompanionFunctionSignatures(functionNames[i]);
+    VELOX_CHECK(companionSignatures.has_value());
+
+    const auto& [paritialAggregate, mergeAggregate, extractAggregate] =
+        getCompanionAggregates(
+            i,
+            *companionSignatures,
+            functionNames[i],
+            aggregateArgs[i],
+            aggregatesArgTypes[i]);
+    paritialAggregates.push_back(paritialAggregate);
+    mergeAggregates.push_back(mergeAggregate);
+    extractExpressions.push_back(extractAggregate);
+  }
+
+  {
+    SCOPED_TRACE("Run partial + final");
+    PlanBuilder builder(pool());
+    builder.values(dataWithExtraGroupingKey);
+    preAggregationProcessing(builder);
+    builder.partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
+        .finalAggregation()
+        .partialAggregation(groupingKeys, mergeAggregates)
+        .finalAggregation()
+        .project(extractExpressions);
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
+  if (!groupingKeys.empty() && !hasOrderSensitive(data, aggregates, pool())) {
+    SCOPED_TRACE("Run partial + final with spilling");
+    PlanBuilder builder(pool());
+    builder.values(dataWithExtraGroupingKey);
+    preAggregationProcessing(builder);
+
+    // Spilling needs at least 2 batches of input. Use round-robin
+    // repartitioning to split input into multiple batches.
+    core::PlanNodeId partialNodeId;
+    core::PlanNodeId finalNodeId;
+    builder.localPartitionRoundRobinRow()
+        .partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
+        .capturePlanNodeId(partialNodeId)
+        .localPartition(groupingKeysWithPartialKey)
+        .finalAggregation()
+        .partialAggregation(groupingKeys, mergeAggregates)
+        .capturePlanNodeId(partialNodeId)
+        .localPartition(groupingKeys)
+        .finalAggregation()
+        .capturePlanNodeId(finalNodeId)
+        .project(extractExpressions);
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config)
+        .config(core::QueryConfig::kSpillEnabled, true)
+        .config(core::QueryConfig::kAggregationSpillEnabled, true)
+        .spillDirectory(spillDirectory->getPath())
+        .maxDrivers(4);
+
+    exec::TestScopedSpillInjection scopedSpillInjection(100);
+    auto task = assertResults(queryBuilder);
+
+    // Expect > 0 spilled bytes unless there was no input.
+    const auto partialInputRows =
+        toPlanStats(task->taskStats()).at(partialNodeId).inputRows;
+    const auto finalInputRows =
+        toPlanStats(task->taskStats()).at(finalNodeId).inputRows;
+    if (exec::injectedSpillCount() > 0) {
+      EXPECT_LT(0, spilledBytes(*task))
+          << "partial inputRows: " << partialInputRows
+          << " final inputRows: " << finalInputRows
+          << " spilledRows: " << spilledRows(*task)
+          << " spilledInputBytes: " << spilledInputBytes(*task)
+          << " spilledFiles: " << spilledFiles(*task)
+          << " injectedSpills: " << exec::injectedSpillCount();
+    } else {
+      EXPECT_EQ(0, spilledBytes(*task))
+          << "partial inputRows: " << partialInputRows
+          << " final inputRows: " << finalInputRows
+          << " spilledRows: " << spilledRows(*task)
+          << " spilledInputBytes: " << spilledInputBytes(*task)
+          << " spilledFiles: " << spilledFiles(*task)
+          << " injectedSpills: " << exec::injectedSpillCount();
+    }
+  }
+
+  {
+    SCOPED_TRACE("Run single");
+    PlanBuilder builder(pool());
+    builder.values(dataWithExtraGroupingKey);
+    preAggregationProcessing(builder);
+    builder.singleAggregation(groupingKeysWithPartialKey, paritialAggregates)
+        .singleAggregation(groupingKeys, mergeAggregates)
+        .project(extractExpressions);
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
+  {
+    SCOPED_TRACE("Run partial + intermediate + final");
+    PlanBuilder builder(pool());
+    builder.values(dataWithExtraGroupingKey);
+    preAggregationProcessing(builder);
+    builder.partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
+        .intermediateAggregation()
+        .finalAggregation()
+        .partialAggregation(groupingKeys, mergeAggregates)
+        .intermediateAggregation()
+        .finalAggregation()
+        .project(extractExpressions);
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
+  if (!groupingKeys.empty()) {
+    SCOPED_TRACE("Run partial + local exchange + final");
+    PlanBuilder builder(pool());
+    builder.values(dataWithExtraGroupingKey);
+    preAggregationProcessing(builder);
+    builder.partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
+        .localPartition(groupingKeysWithPartialKey)
+        .finalAggregation()
+        .partialAggregation(groupingKeys, mergeAggregates)
+        .localPartition(groupingKeys)
+        .finalAggregation()
+        .project(extractExpressions);
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config).maxDrivers(4);
+    assertResults(queryBuilder);
+  }
+
+  {
+    SCOPED_TRACE(
+        "Run partial + local exchange + intermediate + local exchange + final");
+    PlanBuilder builder(pool());
+    builder.values(dataWithExtraGroupingKey);
+    preAggregationProcessing(builder);
+    builder.partialAggregation(groupingKeysWithPartialKey, paritialAggregates)
+        .localPartition(groupingKeysWithPartialKey)
+        .intermediateAggregation()
+        .localPartition(groupingKeysWithPartialKey)
+        .finalAggregation()
+        .partialAggregation(groupingKeys, mergeAggregates);
+
+    if (groupingKeys.empty()) {
+      builder.localPartitionRoundRobinRow();
+    } else {
+      builder.localPartition(groupingKeys);
+    }
+
+    builder.intermediateAggregation()
+        .localPartition(groupingKeys)
+        .finalAggregation()
+        .project(extractExpressions);
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config).maxDrivers(2);
+    assertResults(queryBuilder);
+  }
+
+  if (testStreaming_ && groupingKeys.empty() &&
+      postAggregationProjections.empty()) {
+    {
+      SCOPED_TRACE("Streaming partial");
+      auto partialResult = validateStreamingInTestAggregations(
+          [&](auto& builder) { builder.values(dataWithExtraGroupingKey); },
+          paritialAggregates,
+          config);
+
+      validateStreamingInTestAggregations(
+          [&](auto& builder) { builder.values({partialResult}); },
+          mergeAggregates,
+          config);
+    }
+  }
+}
+
+namespace {
+
+void writeToFile(
+    const std::string& path,
+    const VectorPtr& vector,
+    memory::MemoryPool* pool) {
+  dwrf::WriterOptions options;
+  options.schema = vector->type();
+  options.memoryPool = pool;
+  auto writeFile = std::make_unique<LocalWriteFile>(path, true, false);
+  auto sink =
+      std::make_unique<dwio::common::WriteFileSink>(std::move(writeFile), path);
+  dwrf::Writer writer(std::move(sink), options);
+  writer.write(vector);
+  writer.close();
+}
+
+template <typename T>
+class ScopedChange {
+ public:
+  ScopedChange(T* value, const T& newValue) : value_(value) {
+    oldValue_ = *value_;
+    *value_ = newValue;
+  }
+
+  ~ScopedChange() {
+    *value_ = oldValue_;
+  }
+
+ private:
+  T oldValue_;
+  T* value_;
+};
+
+bool isTableScanSupported(const TypePtr& type) {
+  if (type->kind() == TypeKind::ROW && type->size() == 0) {
+    return false;
+  }
+  if (type->kind() == TypeKind::UNKNOWN) {
+    return false;
+  }
+  if (type->kind() == TypeKind::HUGEINT) {
+    return false;
+  }
+  // Disable testing with TableScan when input contains TIMESTAMP type, due to
+  // the issue #8127.
+  if (type->kind() == TypeKind::TIMESTAMP) {
+    return false;
+  }
+
+  for (auto i = 0; i < type->size(); ++i) {
+    if (!isTableScanSupported(type->childAt(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+} // namespace
+
+void AggregationTestBase::testReadFromFiles(
+    std::function<void(exec::test::PlanBuilder&)> makeSource,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& postAggregationProjections,
+    std::function<std::shared_ptr<exec::Task>(exec::test::AssertQueryBuilder&)>
+        assertResults,
+    const std::unordered_map<std::string, std::string>& config) {
+  PlanBuilder builder(pool());
+  makeSource(builder);
+
+  if (!isTableScanSupported(builder.planNode()->outputType())) {
+    return;
+  }
+
+  auto input = AssertQueryBuilder(builder.planNode()).copyResults(pool());
+  if (input->size() == 0) {
+    return;
+  }
+
+  std::vector<std::shared_ptr<exec::test::TempFilePath>> files;
+  std::vector<exec::Split> splits;
+  std::vector<VectorPtr> inputs;
+  auto writerPool = rootPool_->addAggregateChild("AggregationTestBase.writer");
+
+  // Splits and writes the input vectors into two files, to some extent,
+  // involves shuffling of the inputs. So only split input if aggregate
+  // is non-orderSensitive. Otherwise, only write into a single file.
+  if (!hasOrderSensitive(makeSource, aggregates, pool()) &&
+      input->size() >= 2) {
+    auto size1 = input->size() / 2;
+    auto size2 = input->size() - size1;
+    auto input1 = input->slice(0, size1);
+    auto input2 = input->slice(size1, size2);
+    inputs = {input1, input2};
+  } else {
+    inputs.push_back(input);
+  }
+
+  for (auto& vector : inputs) {
+    auto file = exec::test::TempFilePath::create();
+    writeToFile(file->getPath(), vector, writerPool.get());
+    files.push_back(file);
+    splits.emplace_back(std::make_shared<connector::hive::HiveConnectorSplit>(
+        kHiveConnectorId, file->getPath(), dwio::common::FileFormat::DWRF));
+  }
+  // No need to test streaming as the streaming test generates its own inputs,
+  // so it would be the same as the original test.
+  {
+    ScopedChange<bool> disableTestStreaming(&testStreaming_, false);
+    testAggregationsImpl(
+        [&](auto& builder) { builder.tableScan(asRowType(input->type())); },
+        groupingKeys,
+        aggregates,
+        postAggregationProjections,
+        [&](auto& builder) { return assertResults(builder.splits(splits)); },
+        config);
+  }
+
+  for (const auto& file : files) {
+    remove(file->getPath().c_str());
+  }
+}
+
+void AggregationTestBase::testAggregations(
+    const std::vector<RowVectorPtr>& data,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& postAggregationProjections,
+    const std::vector<RowVectorPtr>& expectedResult,
+    const std::unordered_map<std::string, std::string>& config) {
+  testAggregations(
+      [&](PlanBuilder& builder) { builder.values(data); },
+      groupingKeys,
+      aggregates,
+      postAggregationProjections,
+      [&](auto& builder) { return builder.assertResults(expectedResult); },
+      config);
+}
+
+void AggregationTestBase::testAggregations(
+    std::function<void(PlanBuilder&)> makeSource,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::string& duckDbSql,
+    const std::unordered_map<std::string, std::string>& config) {
+  testAggregations(
+      makeSource,
+      groupingKeys,
+      aggregates,
+      {},
+      [&](auto& builder) { return builder.assertResults(duckDbSql); },
+      config);
+}
+
+namespace {
+
+std::vector<VectorPtr> extractArgColumns(
+    const core::CallTypedExprPtr& aggregateExpr,
+    const RowVectorPtr& input,
+    memory::MemoryPool* pool) {
+  auto& type = input->type()->asRow();
+  std::vector<VectorPtr> columns;
+  for (const auto& arg : aggregateExpr->inputs()) {
+    if (auto field = core::TypedExprs::asFieldAccess(arg)) {
+      columns.push_back(input->childAt(field->name()));
+    }
+    if (core::TypedExprs::isConstant(arg)) {
+      auto constant = core::TypedExprs::asConstant(arg);
+      columns.push_back(constant->toConstantVector(pool));
+    }
+    if (auto lambda = core::TypedExprs::asLambda(arg)) {
+      for (const auto& name : lambda->signature()->names()) {
+        if (auto captureIndex = type.getChildIdxIfExists(name)) {
+          columns.push_back(input->childAt(captureIndex.value()));
+        }
+      }
+    }
+  }
+  return columns;
+}
+
+} // namespace
+
+RowVectorPtr AggregationTestBase::validateStreamingInTestAggregations(
+    const std::function<void(PlanBuilder&)>& makeSource,
+    const std::vector<std::string>& aggregates,
+    const std::unordered_map<std::string, std::string>& config) {
+  PlanBuilder builder(pool());
+  makeSource(builder);
+  auto input = AssertQueryBuilder(builder.planNode())
+                   .configs(config)
+                   .copyResults(pool());
+  if (input->size() < 2) {
+    return nullptr;
+  }
+  auto size1 = input->size() / 2;
+  auto size2 = input->size() - size1;
+  builder.singleAggregation({}, aggregates);
+  auto expected = AssertQueryBuilder(builder.planNode())
+                      .configs(config)
+                      .copyResults(pool());
+  EXPECT_EQ(expected->size(), 1);
+  auto& aggregationNode =
+      static_cast<const core::AggregationNode&>(*builder.planNode());
+  EXPECT_EQ(expected->childrenSize(), aggregationNode.aggregates().size());
+  for (int i = 0; i < aggregationNode.aggregates().size(); ++i) {
+    const auto& aggregate = aggregationNode.aggregates()[i];
+    if (aggregate.distinct || !aggregate.sortingKeys.empty() ||
+        aggregate.mask != nullptr) {
+      // TODO Add support for all these cases.
+      return nullptr;
+    }
+
+    const auto& aggregateExpr = aggregate.call;
+    const auto& name = aggregateExpr->name();
+
+    SCOPED_TRACE(name);
+    std::vector<VectorPtr> rawInput1, rawInput2;
+    for (const auto& arg : aggregateExpr->inputs()) {
+      VectorPtr column;
+      auto channel = exec::exprToChannel(arg.get(), input->type());
+      if (channel == kConstantChannel) {
+        auto constant = dynamic_cast<const core::ConstantTypedExpr*>(arg.get());
+        column = constant->toConstantVector(pool());
+      } else {
+        column = input->childAt(channel);
+      }
+      rawInput1.push_back(column->slice(0, size1));
+      rawInput2.push_back(column->slice(size1, size2));
+    }
+
+    auto actualResult1 =
+        testStreaming(name, true, rawInput1, size1, rawInput2, size2, config);
+    velox::exec::test::assertEqualResults(
+        {makeRowVector({expected->childAt(i)})},
+        {makeRowVector({actualResult1})});
+    auto actualResult2 =
+        testStreaming(name, false, rawInput1, size1, rawInput2, size2, config);
+    velox::exec::test::assertEqualResults(
+        {makeRowVector({expected->childAt(i)})},
+        {makeRowVector({actualResult2})});
+  }
+  return expected;
+}
+
+void AggregationTestBase::testAggregationsImpl(
+    std::function<void(PlanBuilder&)> makeSource,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& postAggregationProjections,
+    std::function<std::shared_ptr<exec::Task>(AssertQueryBuilder&)>
+        assertResults,
+    const std::unordered_map<std::string, std::string>& config) {
+  {
+    SCOPED_TRACE("Run partial + final");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+    builder.partialAggregation(groupingKeys, aggregates).finalAggregation();
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
+  if (!groupingKeys.empty() &&
+      !hasOrderSensitive(makeSource, aggregates, pool())) {
+    SCOPED_TRACE("Run partial + final with spilling");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+
+    // Spilling needs at least 2 batches of input. Use round-robin
+    // repartitioning to split input into multiple batches.
+    core::PlanNodeId partialNodeId;
+    core::PlanNodeId finalNodeId;
+    builder.localPartitionRoundRobinRow()
+        .partialAggregation(groupingKeys, aggregates)
+        .capturePlanNodeId(partialNodeId)
+        .localPartition(groupingKeys)
+        .finalAggregation()
+        .capturePlanNodeId(finalNodeId);
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+
+    ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
+    const auto peakSpillMemoryUsage =
+        memory::spillMemoryPool()->stats().peakBytes;
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config)
+        .config(core::QueryConfig::kSpillEnabled, true)
+        .config(core::QueryConfig::kAggregationSpillEnabled, true)
+        .spillDirectory(spillDirectory->getPath())
+        .maxDrivers(4);
+
+    exec::TestScopedSpillInjection scopedSpillInjection(100);
+    auto task = assertResults(queryBuilder);
+
+    // Expect > 0 spilled bytes unless there was no input.
+    const auto partialInputRows =
+        toPlanStats(task->taskStats()).at(partialNodeId).inputRows;
+    const auto finalInputRows =
+        toPlanStats(task->taskStats()).at(finalNodeId).inputRows;
+    if (exec::injectedSpillCount() > 0) {
+      EXPECT_LT(0, spilledBytes(*task))
+          << "partial inputRows: " << partialInputRows
+          << " final inputRows: " << finalInputRows
+          << " spilledRows: " << spilledRows(*task)
+          << " spilledInputBytes: " << spilledInputBytes(*task)
+          << " spilledFiles: " << spilledFiles(*task)
+          << " injectedSpills: " << exec::injectedSpillCount();
+      ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
+      ASSERT_GT(memory::spillMemoryPool()->stats().peakBytes, 0);
+      ASSERT_GE(
+          memory::spillMemoryPool()->stats().peakBytes, peakSpillMemoryUsage);
+    } else {
+      EXPECT_EQ(0, spilledBytes(*task))
+          << "partial inputRows: " << partialInputRows
+          << " final inputRows: " << finalInputRows
+          << " spilledRows: " << spilledRows(*task)
+          << " spilledInputBytes: " << spilledInputBytes(*task)
+          << " spilledFiles: " << spilledFiles(*task)
+          << " injectedSpills: " << exec::injectedSpillCount();
+    }
+  }
+
+  if (!groupingKeys.empty()) {
+    SCOPED_TRACE("Run partial + final with abandon partial agg");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+
+    core::PlanNodeId partialNodeId;
+    core::PlanNodeId intermediateNodeId;
+    builder.partialAggregation(groupingKeys, aggregates)
+        .capturePlanNodeId(partialNodeId)
+        .intermediateAggregation()
+        .capturePlanNodeId(intermediateNodeId)
+        .finalAggregation();
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    enableAbandonPartialAggregation(queryBuilder);
+
+    auto task = assertResults(queryBuilder);
+
+    // Expect partial aggregation was turned off if there were more than 1 input
+    // batches.
+    auto taskStats = toPlanStats(task->taskStats());
+    auto inputVectors = taskStats.at(partialNodeId).inputVectors;
+    auto partialStats = taskStats.at(partialNodeId).customStats;
+    auto intermediateStats = taskStats.at(intermediateNodeId).customStats;
+    if (inputVectors > 1) {
+      EXPECT_LT(0, partialStats.at("abandonedPartialAggregation").count);
+      EXPECT_LT(0, intermediateStats.at("abandonedPartialAggregation").count);
+    }
+  }
+
+  {
+    SCOPED_TRACE("Run single");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+    builder.singleAggregation(groupingKeys, aggregates);
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
+  if (!groupingKeys.empty() &&
+      !hasOrderSensitive(makeSource, aggregates, pool())) {
+    SCOPED_TRACE("Run single with spilling");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+    core::PlanNodeId aggregationNodeId;
+    builder.singleAggregation(groupingKeys, aggregates)
+        .capturePlanNodeId(aggregationNodeId);
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    auto spillDirectory = exec::test::TempDirectoryPath::create();
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config)
+        .config(core::QueryConfig::kSpillEnabled, "true")
+        .config(core::QueryConfig::kAggregationSpillEnabled, "true")
+        .spillDirectory(spillDirectory->getPath());
+
+    exec::TestScopedSpillInjection scopedSpillInjection(100);
+    auto task = assertResults(queryBuilder);
+    if (exec::injectedSpillCount() > 0) {
+      EXPECT_LT(0, spilledBytes(*task))
+          << " spilledRows: " << spilledRows(*task)
+          << " spilledInputBytes: " << spilledInputBytes(*task)
+          << " spilledFiles: " << spilledFiles(*task)
+          << " injectedSpills: " << exec::injectedSpillCount();
+    } else {
+      EXPECT_EQ(0, spilledBytes(*task))
+          << " spilledRows: " << spilledRows(*task)
+          << " spilledInputBytes: " << spilledInputBytes(*task)
+          << " spilledFiles: " << spilledFiles(*task)
+          << " injectedSpills: " << exec::injectedSpillCount();
+    }
+  }
+
+  {
+    SCOPED_TRACE("Run partial + intermediate + final");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+
+    builder.partialAggregation(groupingKeys, aggregates)
+        .intermediateAggregation()
+        .finalAggregation();
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
+  if (!groupingKeys.empty()) {
+    SCOPED_TRACE("Run partial + local exchange + final");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+
+    builder.partialAggregation(groupingKeys, aggregates)
+        .localPartition(groupingKeys)
+        .finalAggregation();
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder.maxDrivers(4));
+  }
+
+  {
+    SCOPED_TRACE(
+        "Run partial + local exchange + intermediate + local exchange + final");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+
+    builder.partialAggregation(groupingKeys, aggregates);
+
+    if (groupingKeys.empty()) {
+      builder.localPartitionRoundRobinRow();
+    } else {
+      builder.localPartition(groupingKeys);
+    }
+
+    builder.intermediateAggregation()
+        .localPartition(groupingKeys)
+        .finalAggregation();
+
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder.maxDrivers(2));
+  }
+
+  if (testStreaming_ && groupingKeys.empty() &&
+      postAggregationProjections.empty()) {
+    SCOPED_TRACE("Streaming");
+    validateStreamingInTestAggregations(makeSource, aggregates, config);
+  }
+}
+
+void AggregationTestBase::testStreamingAggregationsImpl(
+    std::function<void(PlanBuilder&)> makeSource,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& postAggregationProjections,
+    std::function<std::shared_ptr<exec::Task>(AssertQueryBuilder&)>
+        assertResults,
+    const std::unordered_map<std::string, std::string>& config) {
+  {
+    SCOPED_TRACE("Test StreamingAggregation: run single");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+    builder.orderBy(groupingKeys, false)
+        .streamingAggregation(
+            groupingKeys,
+            aggregates,
+            {},
+            core::AggregationNode::Step::kSingle,
+            false);
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
+  {
+    SCOPED_TRACE(
+        "Test StreamingAggregation: run partial + final StreamingAggregation");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+    builder.orderBy(groupingKeys, false)
+        .partialStreamingAggregation(groupingKeys, aggregates)
+        .finalAggregation();
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+
+  {
+    SCOPED_TRACE(
+        "Test StreamingAggregation: run partial + intermediate + final");
+    PlanBuilder builder(pool());
+    makeSource(builder);
+    builder.orderBy(groupingKeys, false)
+        .partialStreamingAggregation(groupingKeys, aggregates)
+        .intermediateAggregation()
+        .finalAggregation();
+    if (!postAggregationProjections.empty()) {
+      builder.project(postAggregationProjections);
+    }
+
+    AssertQueryBuilder queryBuilder(builder.planNode(), duckDbQueryRunner_);
+    queryBuilder.configs(config);
+    assertResults(queryBuilder);
+  }
+}
+
+void AggregationTestBase::testAggregations(
+    std::function<void(PlanBuilder&)> makeSource,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::vector<std::string>& postAggregationProjections,
+    std::function<std::shared_ptr<exec::Task>(AssertQueryBuilder&)>
+        assertResults,
+    const std::unordered_map<std::string, std::string>& config) {
+  testAggregationsImpl(
+      makeSource,
+      groupingKeys,
+      aggregates,
+      postAggregationProjections,
+      assertResults,
+      config);
+
+  if (testIncremental_) {
+    SCOPED_TRACE("testIncrementalAggregation");
+    testIncrementalAggregation(makeSource, aggregates, config);
+  }
+
+  if (!hasOrderSensitive(makeSource, aggregates, pool()) &&
+      !groupingKeys.empty()) {
+    testStreamingAggregationsImpl(
+        makeSource,
+        groupingKeys,
+        aggregates,
+        postAggregationProjections,
+        assertResults,
+        config);
+  }
+
+  {
+    SCOPED_TRACE("Test reading input from table scan");
+    testReadFromFiles(
+        makeSource,
+        groupingKeys,
+        aggregates,
+        postAggregationProjections,
+        assertResults,
+        config);
+  }
+}
+
+namespace {
+std::pair<TypePtr, TypePtr> getResultTypes(
+    const std::string& name,
+    const std::vector<TypePtr>& rawInputTypes) {
+  auto signatures = exec::getAggregateFunctionSignatures(name);
+  if (!signatures.has_value()) {
+    VELOX_FAIL("Aggregate {} not registered", name);
+  }
+  for (auto& signature : signatures.value()) {
+    exec::SignatureBinder binder(*signature, rawInputTypes);
+    if (binder.tryBind()) {
+      auto intermediateType =
+          binder.tryResolveType(signature->intermediateType());
+      VELOX_CHECK(
+          intermediateType, "failed to resolve intermediate type for {}", name);
+      auto finalType = binder.tryResolveType(signature->returnType());
+      VELOX_CHECK(finalType, "failed to resolve final type for {}", name);
+      return {intermediateType, finalType};
+    }
+  }
+  VELOX_FAIL("Could not infer intermediate type for aggregate {}", name);
+}
+} // namespace
+
+VectorPtr AggregationTestBase::testStreaming(
+    const std::string& functionName,
+    bool testGlobal,
+    const std::vector<VectorPtr>& rawInput1,
+    const std::vector<VectorPtr>& rawInput2,
+    const std::unordered_map<std::string, std::string>& config) {
+  VELOX_CHECK(!rawInput1.empty());
+  VELOX_CHECK(!rawInput2.empty());
+  return testStreaming(
+      functionName,
+      testGlobal,
+      rawInput1,
+      rawInput1[0]->size(),
+      rawInput2,
+      rawInput2[0]->size(),
+      config);
+}
+
+namespace {
+
+constexpr int kRowSizeOffset = 8;
+constexpr int kOffset = kRowSizeOffset + 8;
+
+std::unique_ptr<exec::Aggregate> createAggregateFunction(
+    const std::string& functionName,
+    const std::vector<TypePtr>& inputTypes,
+    HashStringAllocator& allocator,
+    const std::unordered_map<std::string, std::string>& config) {
+  auto [intermediateType, finalType] = getResultTypes(functionName, inputTypes);
+  core::QueryConfig queryConfig({config});
+  auto func = exec::Aggregate::create(
+      functionName,
+      core::AggregationNode::Step::kSingle,
+      inputTypes,
+      finalType,
+      queryConfig);
+  func->setAllocator(&allocator);
+  func->setOffsets(kOffset, 0, 1, 0, 2, kRowSizeOffset);
+
+  VELOX_CHECK(intermediateType->equivalent(
+      *func->intermediateType(functionName, inputTypes)));
+  VELOX_CHECK(finalType->equivalent(*func->resultType()));
+
+  return func;
+}
+
+} // namespace
+
+void AggregationTestBase::testIncrementalAggregation(
+    const std::function<void(exec::test::PlanBuilder&)>& makeSource,
+    const std::vector<std::string>& aggregates,
+    const std::unordered_map<std::string, std::string>& config) {
+  PlanBuilder builder(pool());
+  makeSource(builder);
+  auto data = AssertQueryBuilder(builder.planNode())
+                  .configs(config)
+                  .copyResults(pool());
+  auto inputSize = data->size();
+  if (inputSize == 0) {
+    return;
+  }
+
+  auto& aggregationNode = static_cast<const core::AggregationNode&>(
+      *builder.singleAggregation({}, aggregates).planNode());
+  for (int i = 0; i < aggregationNode.aggregates().size(); ++i) {
+    const auto& aggregate = aggregationNode.aggregates()[i];
+    const auto& aggregateExpr = aggregate.call;
+    const auto& functionName = aggregateExpr->name();
+    auto input = extractArgColumns(aggregateExpr, data, pool());
+
+    HashStringAllocator allocator(pool());
+    std::vector<core::LambdaTypedExprPtr> lambdas;
+    for (const auto& arg : aggregate.call->inputs()) {
+      if (auto lambda =
+              std::dynamic_pointer_cast<const core::LambdaTypedExpr>(arg)) {
+        lambdas.push_back(lambda);
+      }
+    }
+    auto queryCtxConfig = config;
+    auto func = createAggregateFunction(
+        functionName, aggregate.rawInputTypes, allocator, config);
+    auto queryCtx =
+        core::QueryCtx::create(nullptr, core::QueryConfig{queryCtxConfig});
+
+    std::shared_ptr<core::ExpressionEvaluator> expressionEvaluator;
+    if (!lambdas.empty()) {
+      expressionEvaluator = std::make_shared<exec::SimpleExpressionEvaluator>(
+          queryCtx.get(), allocator.pool());
+      func->setLambdaExpressions(lambdas, expressionEvaluator);
+    }
+
+    std::vector<char> group(kOffset + func->accumulatorFixedWidthSize());
+    std::vector<char*> groups(inputSize, group.data());
+    std::vector<vector_size_t> indices(1, 0);
+    func->initializeNewGroups(groups.data(), indices);
+    func->addSingleGroupRawInput(
+        group.data(), SelectivityVector(inputSize), input, false);
+
+    // Extract intermediate result from the same accumulator twice and expect
+    // results to be the same.
+    auto intermediateType =
+        func->intermediateType(functionName, aggregate.rawInputTypes);
+    auto intermediateResult1 = BaseVector::create(intermediateType, 1, pool());
+    auto intermediateResult2 = BaseVector::create(intermediateType, 1, pool());
+    func->extractAccumulators(groups.data(), 1, &intermediateResult1);
+    func->extractAccumulators(groups.data(), 1, &intermediateResult2);
+    velox::test::assertEqualVectors(intermediateResult1, intermediateResult2);
+
+    // Extract values from the same accumulator twice and expect results to be
+    // the same.
+    auto result1 = BaseVector::create(func->resultType(), 1, pool());
+    auto result2 = BaseVector::create(func->resultType(), 1, pool());
+    func->extractValues(groups.data(), 1, &result1);
+    func->extractValues(groups.data(), 1, &result2);
+
+    // Destroy accumulators to avoid memory leak.
+    if (func->accumulatorUsesExternalMemory()) {
+      func->destroy(folly::Range(groups.data(), 1));
+    }
+
+    velox::test::assertEqualVectors(result1, result2);
+  }
+}
+
+VectorPtr AggregationTestBase::testStreaming(
+    const std::string& functionName,
+    bool testGlobal,
+    const std::vector<VectorPtr>& rawInput1,
+    vector_size_t rawInput1Size,
+    const std::vector<VectorPtr>& rawInput2,
+    vector_size_t rawInput2Size,
+    const std::unordered_map<std::string, std::string>& config) {
+  std::vector<TypePtr> rawInputTypes(rawInput1.size());
+  std::transform(
+      rawInput1.begin(),
+      rawInput1.end(),
+      rawInputTypes.begin(),
+      [](const VectorPtr& vec) { return vec->type(); });
+
+  HashStringAllocator allocator(pool());
+  auto func =
+      createAggregateFunction(functionName, rawInputTypes, allocator, config);
+  int maxRowCount = std::max(rawInput1Size, rawInput2Size);
+  std::vector<char> group(kOffset + func->accumulatorFixedWidthSize());
+  std::vector<char*> groups(maxRowCount, group.data());
+  std::vector<vector_size_t> indices(maxRowCount, 0);
+  func->initializeNewGroups(groups.data(), indices);
+  if (testGlobal) {
+    func->addSingleGroupRawInput(
+        group.data(), SelectivityVector(rawInput1Size), rawInput1, false);
+  } else {
+    func->addRawInput(
+        groups.data(), SelectivityVector(rawInput1Size), rawInput1, false);
+  }
+  auto intermediateType = func->intermediateType(functionName, rawInputTypes);
+  auto intermediate = BaseVector::create(intermediateType, 1, pool());
+  func->extractAccumulators(groups.data(), 1, &intermediate);
+  // Destroy accumulators to avoid memory leak.
+  if (func->accumulatorUsesExternalMemory()) {
+    func->destroy(folly::Range(groups.data(), 1));
+  }
+
+  // Create a new function picking up the intermediate result.
+  auto func2 =
+      createAggregateFunction(functionName, rawInputTypes, allocator, config);
+  func2->initializeNewGroups(groups.data(), indices);
+  if (testGlobal) {
+    func2->addSingleGroupIntermediateResults(
+        group.data(), SelectivityVector(1), {intermediate}, false);
+  } else {
+    func2->addIntermediateResults(
+        groups.data(), SelectivityVector(1), {intermediate}, false);
+  }
+  // Add more raw input.
+  if (testGlobal) {
+    func2->addSingleGroupRawInput(
+        group.data(), SelectivityVector(rawInput2Size), rawInput2, false);
+  } else {
+    func2->addRawInput(
+        groups.data(), SelectivityVector(rawInput2Size), rawInput2, false);
+  }
+  auto result = BaseVector::create(func2->resultType(), 1, pool());
+  func2->extractValues(groups.data(), 1, &result);
+  // Destroy accumulators to avoid memory leak.
+  if (func2->accumulatorUsesExternalMemory()) {
+    func2->destroy(folly::Range(groups.data(), 1));
+  }
+
+  return result;
+}
+
+void AggregationTestBase::testFailingAggregations(
+    const std::vector<RowVectorPtr>& data,
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregates,
+    const std::string& expectedMessage,
+    const std::unordered_map<std::string, std::string>& config) {
+  {
+    SCOPED_TRACE("Run single");
+    auto builder = PlanBuilder().values(data);
+    builder.singleAggregation(groupingKeys, aggregates);
+    AssertQueryBuilder queryBuilder(builder.planNode());
+    queryBuilder.configs(config);
+    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
+  }
+
+  {
+    SCOPED_TRACE("Run partial + final");
+    auto builder = PlanBuilder().values(data);
+    builder.partialAggregation(groupingKeys, aggregates).finalAggregation();
+    AssertQueryBuilder queryBuilder(builder.planNode());
+    queryBuilder.configs(config);
+    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
+  }
+
+  {
+    SCOPED_TRACE("Run partial + final with abandon partial agg");
+    auto builder = PlanBuilder().values(data);
+    builder.partialAggregation(groupingKeys, aggregates)
+        .intermediateAggregation()
+        .finalAggregation();
+    AssertQueryBuilder queryBuilder(builder.planNode());
+    queryBuilder.configs(config);
+    enableAbandonPartialAggregation(queryBuilder);
+    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
+  }
+
+  {
+    SCOPED_TRACE("Run partial + intermediate + final");
+    auto builder = PlanBuilder().values(data);
+    builder.partialAggregation(groupingKeys, aggregates)
+        .intermediateAggregation()
+        .finalAggregation();
+    AssertQueryBuilder queryBuilder(builder.planNode());
+    queryBuilder.configs(config);
+    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
+  }
+
+  if (!groupingKeys.empty()) {
+    SCOPED_TRACE("Run partial + local exchange + final");
+    auto builder = PlanBuilder().values(data);
+    builder.partialAggregation(groupingKeys, aggregates)
+        .localPartition(groupingKeys)
+        .finalAggregation();
+    AssertQueryBuilder queryBuilder(builder.planNode());
+    queryBuilder.configs(config);
+    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
+  }
+
+  {
+    SCOPED_TRACE(
+        "Run partial + local exchange + intermediate + local exchange + final");
+    auto builder = PlanBuilder().values(data);
+    builder.partialAggregation(groupingKeys, aggregates);
+
+    if (groupingKeys.empty()) {
+      builder.localPartitionRoundRobinRow();
+    } else {
+      builder.localPartition(groupingKeys);
+    }
+
+    builder.intermediateAggregation()
+        .localPartition(groupingKeys)
+        .finalAggregation();
+
+    AssertQueryBuilder queryBuilder(builder.planNode());
+    queryBuilder.configs(config);
+    VELOX_ASSERT_THROW(queryBuilder.copyResults(pool()), expectedMessage);
+  }
+
+  if (testStreaming_ && groupingKeys.empty()) {
+    SCOPED_TRACE("Streaming");
+    auto makeSource = [&](PlanBuilder& builder) { builder.values(data); };
+    VELOX_ASSERT_THROW(
+        validateStreamingInTestAggregations(makeSource, aggregates, config),
+        expectedMessage);
+  }
+}
+} // namespace facebook::velox::functions::aggregate::test
diff --git a/velox/functions/lib/aggregates/tests/AggregationTestBase.h b/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h
similarity index 90%
rename from velox/functions/lib/aggregates/tests/AggregationTestBase.h
rename to velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h
index 36fb8819289ad..595183bcc77a3 100644
--- a/velox/functions/lib/aggregates/tests/AggregationTestBase.h
+++ b/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h
@@ -68,8 +68,7 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
       const std::vector<std::string>& groupingKeys,
       const std::vector<std::string>& aggregates,
       const std::string& duckDbSql,
-      const std::unordered_map<std::string, std::string>& config = {},
-      bool testWithTableScan = true);
+      const std::unordered_map<std::string, std::string>& config = {});
 
   /// Same as above, but allows to specify a set of projections to apply after
   /// the aggregation.
@@ -80,8 +79,7 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
       const std::vector<std::string>& postAggregationProjections,
       std::function<std::shared_ptr<exec::Task>(
           exec::test::AssertQueryBuilder& builder)> assertResults,
-      const std::unordered_map<std::string, std::string>& config = {},
-      bool testWithTableScan = true);
+      const std::unordered_map<std::string, std::string>& config = {});
 
   /// Convenience version that allows to specify input data instead of a
   /// function to build Values plan node.
@@ -90,8 +88,7 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
       const std::vector<std::string>& groupingKeys,
       const std::vector<std::string>& aggregates,
       const std::string& duckDbSql,
-      const std::unordered_map<std::string, std::string>& config = {},
-      bool testWithTableScan = true);
+      const std::unordered_map<std::string, std::string>& config = {});
 
   /// Convenience version that allows to specify input data instead of a
   /// function to build Values plan node.
@@ -101,8 +98,7 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
       const std::vector<std::string>& aggregates,
       const std::vector<std::string>& postAggregationProjections,
       const std::string& duckDbSql,
-      const std::unordered_map<std::string, std::string>& config = {},
-      bool testWithTableScan = true);
+      const std::unordered_map<std::string, std::string>& config = {});
 
   /// Convenience version that allows to specify input data instead of a
   /// function to build Values plan node, and the expected result instead of a
@@ -112,8 +108,7 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
       const std::vector<std::string>& groupingKeys,
       const std::vector<std::string>& aggregates,
       const std::vector<RowVectorPtr>& expectedResult,
-      const std::unordered_map<std::string, std::string>& config = {},
-      bool testWithTableScan = true);
+      const std::unordered_map<std::string, std::string>& config = {});
 
   /// Convenience version that allows to specify input data instead of a
   /// function to build Values plan node, and the expected result instead of a
@@ -124,8 +119,7 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
       const std::vector<std::string>& aggregates,
       const std::vector<std::string>& postAggregationProjections,
       const std::vector<RowVectorPtr>& expectedResult,
-      const std::unordered_map<std::string, std::string>& config = {},
-      bool testWithTableScan = true);
+      const std::unordered_map<std::string, std::string>& config = {});
 
   /// Ensure the function is working in streaming use case.  Create a first
   /// aggregation function, add the rawInput1, then extract the accumulator,
@@ -226,17 +220,6 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
       const std::string& expectedMessage,
       const std::unordered_map<std::string, std::string>& config = {});
 
-  /// Specifies that aggregate functions used in this test are not sensitive
-  /// to the order of inputs.
-  void allowInputShuffle() {
-    allowInputShuffle_ = true;
-  }
-  /// Specifies that aggregate functions used in this test are sensitive
-  /// to the order of inputs.
-  void disallowInputShuffle() {
-    allowInputShuffle_ = false;
-  }
-
   void disableTestStreaming() {
     testStreaming_ = false;
   }
@@ -245,9 +228,20 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
     testStreaming_ = true;
   }
 
+  void disableTestIncremental() {
+    testIncremental_ = false;
+  }
+
+  void enableTestIncremental() {
+    testIncremental_ = true;
+  }
+
   /// Whether testStreaming should be called in testAggregations.
   bool testStreaming_{true};
 
+  /// Whether testIncrementalAggregation should be called in testAggregations.
+  bool testIncremental_{true};
+
  private:
   // Test streaming use case where raw inputs are added after intermediate
   // results. Return the result of aggregates if successful.
@@ -265,6 +259,15 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
       vector_size_t rawInput2Size,
       const std::unordered_map<std::string, std::string>& config = {});
 
+  // Test to ensure that when extractValues() or extractAccumulators() is called
+  // twice on the same accumulator, the extracted results are the same. This
+  // ensures that extractValues() and extractAccumulators() are free of side
+  // effects.
+  void testIncrementalAggregation(
+      const std::function<void(exec::test::PlanBuilder&)>& makeSource,
+      const std::vector<std::string>& aggregates,
+      const std::unordered_map<std::string, std::string>& config = {});
+
   void testAggregationsImpl(
       std::function<void(exec::test::PlanBuilder&)> makeSource,
       const std::vector<std::string>& groupingKeys,
@@ -274,7 +277,14 @@ class AggregationTestBase : public exec::test::OperatorTestBase {
           exec::test::AssertQueryBuilder&)> assertResults,
       const std::unordered_map<std::string, std::string>& config);
 
-  bool allowInputShuffle_{false};
+  void testStreamingAggregationsImpl(
+      std::function<void(exec::test::PlanBuilder&)> makeSource,
+      const std::vector<std::string>& groupingKeys,
+      const std::vector<std::string>& aggregates,
+      const std::vector<std::string>& postAggregationProjections,
+      std::function<std::shared_ptr<exec::Task>(
+          exec::test::AssertQueryBuilder&)> assertResults,
+      const std::unordered_map<std::string, std::string>& config);
 };
 
 } // namespace facebook::velox::functions::aggregate::test
diff --git a/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt b/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt
new file mode 100644
index 0000000000000..13845ff4f9bdb
--- /dev/null
+++ b/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_functions_aggregates_test_lib AggregationTestBase.cpp)
+
+target_link_libraries(
+  velox_functions_aggregates_test_lib velox_exec_test_lib velox_vector_test_lib)
diff --git a/velox/functions/lib/benchmarks/ApproxMostFrequentStreamSummaryBenchmark.cpp b/velox/functions/lib/benchmarks/ApproxMostFrequentStreamSummaryBenchmark.cpp
index b9dd530d822f5..bd1236d523daa 100644
--- a/velox/functions/lib/benchmarks/ApproxMostFrequentStreamSummaryBenchmark.cpp
+++ b/velox/functions/lib/benchmarks/ApproxMostFrequentStreamSummaryBenchmark.cpp
@@ -115,7 +115,7 @@ BENCHMARK_NAMED_PARAM(merge, capacity2048, 1e6, 2048)
 } // namespace facebook::velox::functions
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/lib/benchmarks/FunctionBenchmarkBase.h b/velox/functions/lib/benchmarks/FunctionBenchmarkBase.h
index 2a75e1062134d..f9f20ab98d722 100644
--- a/velox/functions/lib/benchmarks/FunctionBenchmarkBase.h
+++ b/velox/functions/lib/benchmarks/FunctionBenchmarkBase.h
@@ -51,14 +51,28 @@ class FunctionBenchmarkBase {
     return exec::ExprSet({typed}, &execCtx_);
   }
 
-  VectorPtr evaluate(
+  void evaluate(
       exec::ExprSet& exprSet,
       const RowVectorPtr& data,
-      const SelectivityVector& rows) {
+      const SelectivityVector& rows,
+      VectorPtr& result) {
     exec::EvalCtx evalCtx(&execCtx_, &exprSet, data.get());
-    std::vector<VectorPtr> results(1);
+    std::vector<VectorPtr> results{result};
     exprSet.eval(rows, evalCtx, results);
-    return results[0];
+
+    // If result was nullptr, we need to pick up the value that was created.
+    if (!result) {
+      result = results[0];
+    }
+  }
+
+  VectorPtr evaluate(
+      exec::ExprSet& exprSet,
+      const RowVectorPtr& data,
+      const SelectivityVector& rows) {
+    VectorPtr result;
+    evaluate(exprSet, data, rows, result);
+    return result;
   }
 
   VectorPtr evaluate(exec::ExprSet& exprSet, const RowVectorPtr& data) {
@@ -80,8 +94,9 @@ class FunctionBenchmarkBase {
   }
 
  protected:
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   core::ExecCtx execCtx_{pool_.get(), queryCtx_.get()};
   facebook::velox::test::VectorMaker vectorMaker_{execCtx_.pool()};
   parse::ParseOptions options_;
diff --git a/velox/functions/lib/benchmarks/KllSketchBenchmark.cpp b/velox/functions/lib/benchmarks/KllSketchBenchmark.cpp
index 2b78ec7edf80d..9257e8df583fb 100644
--- a/velox/functions/lib/benchmarks/KllSketchBenchmark.cpp
+++ b/velox/functions/lib/benchmarks/KllSketchBenchmark.cpp
@@ -188,7 +188,7 @@ BENCHMARK_RELATIVE_NAMED_PARAM(mergeKllSketch, 1e6x80, 1e6, 80);
 } // namespace facebook::velox::functions::kll::test
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/lib/benchmarks/Re2FunctionsBenchmarks.cpp b/velox/functions/lib/benchmarks/Re2FunctionsBenchmarks.cpp
index 99fce0c412542..50f7c6f43ef76 100644
--- a/velox/functions/lib/benchmarks/Re2FunctionsBenchmarks.cpp
+++ b/velox/functions/lib/benchmarks/Re2FunctionsBenchmarks.cpp
@@ -103,8 +103,9 @@ void registerRe2Functions() {
 } // namespace facebook::velox::functions::test
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   facebook::velox::functions::test::registerRe2Functions();
+  facebook::velox::memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/functions/lib/string/CMakeLists.txt b/velox/functions/lib/string/CMakeLists.txt
index 8fcd0f490dfa6..c24c196c6dfc0 100644
--- a/velox/functions/lib/string/CMakeLists.txt
+++ b/velox/functions/lib/string/CMakeLists.txt
@@ -11,10 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_functions_string INTERFACE)
+velox_add_library(velox_functions_string INTERFACE)
 
-target_link_libraries(velox_functions_string INTERFACE velox_exception
-                                                       Folly::folly)
+velox_link_libraries(velox_functions_string INTERFACE velox_common_base
+                                                      Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/lib/string/StringCore.h b/velox/functions/lib/string/StringCore.h
index 42550584e5541..d81842d073b87 100644
--- a/velox/functions/lib/string/StringCore.h
+++ b/velox/functions/lib/string/StringCore.h
@@ -20,6 +20,7 @@
 #include <string_view>
 #include "folly/CPortability.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/SimdUtil.h"
 #include "velox/external/utf8proc/utf8procImpl.h"
 
 #if (ENABLE_VECTORIZATION > 0) && !defined(_DEBUG) && !defined(DEBUG)
@@ -48,7 +49,21 @@ namespace stringCore {
 static bool isAscii(const char* str, size_t length);
 
 FOLLY_ALWAYS_INLINE bool isAscii(const char* str, size_t length) {
-  for (auto i = 0; i < length; i++) {
+  const auto mask = xsimd::broadcast<uint8_t>(0x80);
+  size_t i = 0;
+  for (; i + mask.size <= length; i += mask.size) {
+    auto batch =
+        xsimd::load_unaligned(reinterpret_cast<const uint8_t*>(str) + i);
+#if XSIMD_WITH_AVX
+    // 1 instruction instead of 2 on AVX.
+    if (!_mm256_testz_si256(batch, mask)) {
+#else
+    if (xsimd::any(batch >= mask)) {
+#endif
+      return false;
+    }
+  }
+  for (; i < length; ++i) {
     if (str[i] & 0x80) {
       return false;
     }
@@ -212,7 +227,7 @@ applyAppendersRecursive(TOutStr& output, Func appenderFunc, Funcs... funcs) {
 /**
  * Return the length in chars of a utf8 string stored in the input buffer
  * @param inputBuffer input buffer that hold the string
- * @param numBytes size of input buffer
+ * @param bufferLength size of input buffer
  * @return the number of characters represented by the input utf8 string
  */
 FOLLY_ALWAYS_INLINE int64_t
@@ -222,19 +237,85 @@ lengthUnicode(const char* inputBuffer, size_t bufferLength) {
   auto currentChar = inputBuffer;
   int64_t size = 0;
   while (currentChar < buffEndAddress) {
-    auto chrOffset = utf8proc_char_length(currentChar);
-    // Skip bad byte if we get utf length < 0.
-    currentChar += UNLIKELY(chrOffset < 0) ? 1 : chrOffset;
-    size++;
+    // This function detects bytes that come after the first byte in a
+    // multi-byte UTF-8 character (provided that the string is valid UTF-8). We
+    // increment size only for the first byte so that we treat all bytes as part
+    // of a single character.
+    if (!utf_cont(*currentChar)) {
+      size++;
+    }
+
+    currentChar++;
   }
   return size;
 }
 
+/**
+ * Return an capped length(controlled by maxChars) of a unicode string. The
+ * returned length is not greater than maxChars.
+ *
+ * This method is used to tell whether a string is longer or the same length of
+ * another string, in these scenarios we don't need accurate length, by
+ * providing maxChars we can get better performance by avoid calculating whole
+ * length of a string which might be very long.
+ *
+ * @param input input buffer that hold the string
+ * @param size size of input buffer
+ * @param maxChars stop counting characters if the string is longer
+ * than this value
+ * @return the number of characters represented by the input utf8 string
+ */
+FOLLY_ALWAYS_INLINE int64_t
+cappedLengthUnicode(const char* input, size_t size, size_t maxChars) {
+  // First address after the last byte in the input
+  auto end = input + size;
+  auto currentChar = input;
+  int64_t numChars = 0;
+
+  // Use maxChars to early stop to avoid calculating the whole
+  // length of long string.
+  while (currentChar < end && numChars < maxChars) {
+    auto charSize = utf8proc_char_length(currentChar);
+    // Skip bad byte if we get utf length < 0.
+    currentChar += UNLIKELY(charSize < 0) ? 1 : charSize;
+    numChars++;
+  }
+
+  return numChars;
+}
+
+///
+/// Return an capped length in bytes(controlled by maxChars) of a unicode
+/// string. The returned length may be greater than maxCharacters if there are
+/// multi-byte characters present in the input string.
+///
+/// This method is used to help with indexing unicode strings by byte position.
+/// It is used to find the byte position of the Nth character in a string.
+///
+/// @param input input buffer that hold the string
+/// @param size size of input buffer
+/// @param maxChars stop counting characters if the string is longer
+/// than this value
+/// @return the number of bytes represented by the input utf8 string up to
+/// maxChars
+///
+FOLLY_ALWAYS_INLINE int64_t
+cappedByteLengthUnicode(const char* input, size_t size, int64_t maxChars) {
+  size_t utf8Position = 0;
+  size_t numCharacters = 0;
+  while (utf8Position < size && numCharacters < maxChars) {
+    auto charSize = utf8proc_char_length(input + utf8Position);
+    utf8Position += UNLIKELY(charSize < 0) ? 1 : charSize;
+    numCharacters++;
+  }
+  return utf8Position;
+}
+
 /// Returns the start byte index of the Nth instance of subString in
 /// string. Search starts from startPosition. Positions start with 0. If not
 /// found, -1 is returned. To facilitate finding overlapping strings, the
 /// nextStartPosition is incremented by 1
-static int64_t findNthInstanceByteIndexFromStart(
+static inline int64_t findNthInstanceByteIndexFromStart(
     const std::string_view& string,
     const std::string_view subString,
     const size_t instance = 1,
@@ -293,10 +374,14 @@ inline int64_t findNthInstanceByteIndexFromEnd(
 
 /// Replace replaced with replacement in inputString and write results in
 /// outputString. If inPlace=true inputString and outputString are assumed to
-/// tbe the same. When replaced is empty, replacement is added before and after
-/// each charecter. When inputString is empty results is empty.
+/// be the same. When replaced is empty and ignoreEmptyReplaced is false,
+/// replacement is added before and after each charecter. When replaced is
+/// empty and ignoreEmptyReplaced is true, the result is the inputString value.
+/// When inputString is empty results is empty.
 /// replace("", "", "x") = ""
-/// replace("aa", "", "x") = "xaxax"
+/// replace("aa", "", "x") = "xaxax" -- when ignoreEmptyReplaced is false
+/// replace("aa", "", "x") = "aa" -- when ignoreEmptyReplaced is true
+template <bool ignoreEmptyReplaced = false>
 inline static size_t replace(
     char* outputString,
     const std::string_view& inputString,
@@ -307,6 +392,15 @@ inline static size_t replace(
     return 0;
   }
 
+  if constexpr (ignoreEmptyReplaced) {
+    if (replaced.size() == 0) {
+      if (!inPlace) {
+        std::memcpy(outputString, inputString.data(), inputString.size());
+      }
+      return inputString.size();
+    }
+  }
+
   size_t readPosition = 0;
   size_t writePosition = 0;
   // Copy needed in out of place replace, and when replaced and replacement are
@@ -400,12 +494,30 @@ inline static size_t replace(
 /// If a bad unicode byte is encountered, then we skip that bad byte and
 /// count that as one codepoint.
 template <bool isAscii>
-static inline std::pair<size_t, size_t>
-getByteRange(const char* str, size_t startCharPosition, size_t length) {
-  if (startCharPosition < 1 && length > 0) {
-    throw std::invalid_argument(
-        "start position must be >= 1 and length must be > 0");
+static inline std::pair<size_t, size_t> getByteRange(
+    const char* str,
+    size_t strLength,
+    size_t startCharPosition,
+    size_t length) {
+  // If the length is 0, then we return an empty range directly.
+  if (length == 0) {
+    return std::make_pair(0, 0);
+  }
+
+  if (startCharPosition < 1) {
+    throw std::invalid_argument("start position must be >= 1");
   }
+
+  VELOX_CHECK_GE(
+      strLength,
+      length,
+      "The length of the string must be at least as large as the length of the substring requested.");
+
+  VELOX_CHECK_GE(
+      strLength,
+      startCharPosition,
+      "The offset of the substring requested must be within the string.");
+
   if constexpr (isAscii) {
     return std::make_pair(
         startCharPosition - 1, startCharPosition + length - 1);
@@ -413,20 +525,44 @@ getByteRange(const char* str, size_t startCharPosition, size_t length) {
     size_t startByteIndex = 0;
     size_t nextCharOffset = 0;
 
+    // Skips any Unicode continuation bytes. These are bytes that appear after
+    // the first byte in a multi-byte Unicode character.  They do not count
+    // towards the position in or length of a string.
+    auto skipContBytes = [&]() {
+      while (nextCharOffset < strLength && utf_cont(str[nextCharOffset])) {
+        nextCharOffset++;
+      }
+    };
+
+    // Skip any invalid continuation bytes at the beginning of the string.
+    skipContBytes();
+
     // Find startByteIndex
-    for (auto i = 0; i < startCharPosition - 1; i++) {
-      auto increment = utf8proc_char_length(&str[nextCharOffset]);
-      nextCharOffset += UNLIKELY(increment < 0) ? 1 : increment;
+    for (auto i = 0; nextCharOffset < strLength && i < startCharPosition - 1;
+         i++) {
+      nextCharOffset++;
+
+      skipContBytes();
     }
 
     startByteIndex = nextCharOffset;
+    size_t charCountInRange = 0;
 
     // Find endByteIndex
-    for (auto i = 0; i < length; i++) {
-      auto increment = utf8proc_char_length(&str[nextCharOffset]);
-      nextCharOffset += UNLIKELY(increment < 0) ? 1 : increment;
+    for (auto i = 0; nextCharOffset < strLength && i < length; i++) {
+      nextCharOffset++;
+      charCountInRange++;
+
+      skipContBytes();
     }
 
+    VELOX_CHECK_EQ(
+        charCountInRange,
+        length,
+        "The substring requested at {} of length {} exceeds the bounds of the string.",
+        startCharPosition,
+        length);
+
     return std::make_pair(startByteIndex, nextCharOffset);
   }
 }
diff --git a/velox/functions/lib/string/StringImpl.h b/velox/functions/lib/string/StringImpl.h
index 681cee524c740..4058bfb2e480a 100644
--- a/velox/functions/lib/string/StringImpl.h
+++ b/velox/functions/lib/string/StringImpl.h
@@ -111,6 +111,30 @@ FOLLY_ALWAYS_INLINE int64_t length(const T& input) {
   }
 }
 
+/// Return a capped length in characters(controlled by maxLength) of a string.
+/// The returned length is not greater than maxLength.
+template <bool isAscii, typename T>
+FOLLY_ALWAYS_INLINE int64_t cappedLength(const T& input, size_t maxLength) {
+  if constexpr (isAscii) {
+    return input.size() > maxLength ? maxLength : input.size();
+  } else {
+    return cappedLengthUnicode(input.data(), input.size(), maxLength);
+  }
+}
+
+/// Return a capped length in bytes(controlled by maxCharacters) of a string.
+/// The returned length may be greater than maxCharacters if there are
+/// multi-byte characters present in the input string.
+template <bool isAscii, typename TString>
+FOLLY_ALWAYS_INLINE int64_t
+cappedByteLength(const TString& input, size_t maxCharacters) {
+  if constexpr (isAscii) {
+    return input.size() > maxCharacters ? maxCharacters : input.size();
+  } else {
+    return cappedByteLengthUnicode(input.data(), input.size(), maxCharacters);
+  }
+}
+
 /// Write the Unicode codePoint as string to the output string. The function
 /// behavior is undefined when code point it invalid. Implements the logic of
 /// presto chr function.
@@ -285,7 +309,7 @@ FOLLY_ALWAYS_INLINE bool md5_radix(
 
 namespace {
 FOLLY_ALWAYS_INLINE int64_t asciiWhitespaces() {
-  std::vector<int32_t> codes = {9, 10, 11, 12, 13, 28, 29, 30, 31, 32};
+  int8_t codes[] = {9, 10, 11, 12, 13, 28, 29, 30, 31, 32};
   int64_t bitMask = 0;
   for (auto code : codes) {
     bits::setBit(&bitMask, code, true);
@@ -294,7 +318,7 @@ FOLLY_ALWAYS_INLINE int64_t asciiWhitespaces() {
 }
 
 FOLLY_ALWAYS_INLINE int64_t asciiWhitespaceCodes() {
-  std::vector<int32_t> codes = {9, 10, 11, 12, 13, 28, 29, 30, 31, 32};
+  int8_t codes[] = {9, 10, 11, 12, 13, 28, 29, 30, 31, 32};
   int64_t bitMask = 0;
   for (auto code : codes) {
     bits::setBit(&bitMask, code, true);
@@ -303,7 +327,7 @@ FOLLY_ALWAYS_INLINE int64_t asciiWhitespaceCodes() {
 }
 
 FOLLY_ALWAYS_INLINE std::array<int64_t, 2> unicodeWhitespaceCodes() {
-  std::vector<int32_t> codes = {
+  int16_t codes[] = {
       8192,
       8193,
       8194,
@@ -482,8 +506,15 @@ template <
 FOLLY_ALWAYS_INLINE void trimUnicodeWhiteSpace(
     TOutString& output,
     const TInString& input) {
+  auto emptyOutput = [&]() {
+    if constexpr (std::is_same_v<TOutString, StringView>) {
+      output = StringView("");
+    } else {
+      output.setEmpty();
+    }
+  };
   if (input.empty()) {
-    output.setEmpty();
+    emptyOutput();
     return;
   }
 
@@ -502,7 +533,7 @@ FOLLY_ALWAYS_INLINE void trimUnicodeWhiteSpace(
     }
 
     if (curStartPos >= input.size()) {
-      output.setEmpty();
+      emptyOutput();
       return;
     }
   }
@@ -524,12 +555,17 @@ FOLLY_ALWAYS_INLINE void trimUnicodeWhiteSpace(
     }
 
     if (endIndex < startIndex) {
-      output.setEmpty();
+      emptyOutput();
       return;
     }
   }
 
-  output.setNoCopy(StringView(stringStart, endIndex - startIndex + 1));
+  auto view = StringView(stringStart, endIndex - startIndex + 1);
+  if constexpr (std::is_same_v<TOutString, StringView>) {
+    output = view;
+  } else {
+    output.setNoCopy(view);
+  }
 }
 
 template <bool ascii, typename TOutString, typename TInString>
@@ -557,13 +593,16 @@ FOLLY_ALWAYS_INLINE void pad(
       "pad size must be in the range [0..{})",
       padMaxSize);
   VELOX_USER_CHECK(padString.size() > 0, "padString must not be empty");
+  int64_t padStringCharLength = length<isAscii>(padString);
+  VELOX_USER_CHECK(padStringCharLength > 0, "padString must be a valid string");
 
   int64_t stringCharLength = length<isAscii>(string);
   // If string has at most size characters, truncate it if necessary
   // and return it as the result.
   if (UNLIKELY(stringCharLength >= size)) {
     size_t prefixByteSize =
-        stringCore::getByteRange<isAscii>(string.data(), 1, size).second;
+        stringCore::getByteRange<isAscii>(string.data(), string.size(), 1, size)
+            .second;
     output.resize(prefixByteSize);
     if (LIKELY(prefixByteSize > 0)) {
       std::memcpy(output.data(), string.data(), prefixByteSize);
@@ -571,7 +610,6 @@ FOLLY_ALWAYS_INLINE void pad(
     return;
   }
 
-  int64_t padStringCharLength = length<isAscii>(padString);
   // How many characters do we need to add to string.
   int64_t fullPaddingCharLength = size - stringCharLength;
   // How many full copies of padString need to be added.
@@ -579,10 +617,12 @@ FOLLY_ALWAYS_INLINE void pad(
   // If the length of padString does not evenly divide the length of the
   // padding we need to add, how long of a prefix of padString needs to be
   // added at the end of the padding.  Will be 0 if it is evenly divisible.
-  size_t padPrefixByteLength =
-      stringCore::getByteRange<isAscii>(
-          padString.data(), 1, fullPaddingCharLength % padStringCharLength)
-          .second;
+  size_t padPrefixByteLength = stringCore::getByteRange<isAscii>(
+                                   padString.data(),
+                                   padString.size(),
+                                   1,
+                                   fullPaddingCharLength % padStringCharLength)
+                                   .second;
   int64_t fullPaddingByteLength =
       padString.size() * fullPadCopies + padPrefixByteLength;
   // The final size of the output string in bytes.
diff --git a/velox/functions/lib/string/tests/CMakeLists.txt b/velox/functions/lib/string/tests/CMakeLists.txt
index 4bf7b67676e24..54b2302de5d25 100644
--- a/velox/functions/lib/string/tests/CMakeLists.txt
+++ b/velox/functions/lib/string/tests/CMakeLists.txt
@@ -19,7 +19,7 @@ target_link_libraries(
   velox_functions_string_test
   velox_functions_string
   Folly::folly
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
diff --git a/velox/functions/lib/string/tests/StringImplTest.cpp b/velox/functions/lib/string/tests/StringImplTest.cpp
index 2d26e448befc2..f5c83140e97e0 100644
--- a/velox/functions/lib/string/tests/StringImplTest.cpp
+++ b/velox/functions/lib/string/tests/StringImplTest.cpp
@@ -177,6 +177,119 @@ TEST_F(StringImplTest, length) {
   }
 }
 
+TEST_F(StringImplTest, cappedLength) {
+  auto input = std::string("abcd");
+  ASSERT_EQ(cappedLength</*isAscii*/ true>(input, 1), 1);
+  ASSERT_EQ(cappedLength</*isAscii*/ true>(input, 2), 2);
+  ASSERT_EQ(cappedLength</*isAscii*/ true>(input, 3), 3);
+  ASSERT_EQ(cappedLength</*isAscii*/ true>(input, 4), 4);
+  ASSERT_EQ(cappedLength</*isAscii*/ true>(input, 5), 4);
+  ASSERT_EQ(cappedLength</*isAscii*/ true>(input, 6), 4);
+
+  input = std::string("你好a世界");
+  ASSERT_EQ(cappedLength</*isAscii*/ false>(input, 1), 1);
+  ASSERT_EQ(cappedLength</*isAscii*/ false>(input, 2), 2);
+  ASSERT_EQ(cappedLength</*isAscii*/ false>(input, 3), 3);
+  ASSERT_EQ(cappedLength</*isAscii*/ false>(input, 4), 4);
+  ASSERT_EQ(cappedLength</*isAscii*/ false>(input, 5), 5);
+  ASSERT_EQ(cappedLength</*isAscii*/ false>(input, 6), 5);
+  ASSERT_EQ(cappedLength</*isAscii*/ false>(input, 7), 5);
+}
+
+TEST_F(StringImplTest, cappedUnicodeBytes) {
+  // Test functions use case for indexing
+  // UTF strings.
+  std::string stringInput = "\xF4\x90\x80\x80Hello";
+  ASSERT_EQ('H', stringInput[cappedByteLength<false>(stringInput, 2) - 1]);
+  ASSERT_EQ('e', stringInput[cappedByteLength<false>(stringInput, 3) - 1]);
+  ASSERT_EQ('l', stringInput[cappedByteLength<false>(stringInput, 4) - 1]);
+  ASSERT_EQ('l', stringInput[cappedByteLength<false>(stringInput, 5) - 1]);
+  ASSERT_EQ('o', stringInput[cappedByteLength<false>(stringInput, 6) - 1]);
+  ASSERT_EQ('o', stringInput[cappedByteLength<false>(stringInput, 7) - 1]);
+
+  // Multi-byte chars
+  stringInput = "♫¡Singing is fun!♫";
+  auto sPos = cappedByteLength<false>(stringInput, 2);
+  auto exPos = cappedByteLength<false>(stringInput, 17);
+  ASSERT_EQ("Singing is fun!♫", stringInput.substr(sPos));
+  ASSERT_EQ("♫¡Singing is fun!", stringInput.substr(0, exPos));
+  ASSERT_EQ("Singing is fun!", stringInput.substr(sPos, exPos - sPos));
+
+  stringInput = std::string("abcd");
+  auto stringViewInput = std::string_view(stringInput);
+  ASSERT_EQ(cappedByteLength<true>(stringInput, 1), 1);
+  ASSERT_EQ(cappedByteLength<true>(stringInput, 2), 2);
+  ASSERT_EQ(cappedByteLength<true>(stringInput, 3), 3);
+  ASSERT_EQ(cappedByteLength<true>(stringInput, 4), 4);
+  ASSERT_EQ(cappedByteLength<true>(stringInput, 5), 4);
+  ASSERT_EQ(cappedByteLength<true>(stringInput, 6), 4);
+
+  ASSERT_EQ(cappedByteLength<true>(stringViewInput, 1), 1);
+  ASSERT_EQ(cappedByteLength<true>(stringViewInput, 2), 2);
+  ASSERT_EQ(cappedByteLength<true>(stringViewInput, 3), 3);
+  ASSERT_EQ(cappedByteLength<true>(stringViewInput, 4), 4);
+  ASSERT_EQ(cappedByteLength<true>(stringViewInput, 5), 4);
+  ASSERT_EQ(cappedByteLength<true>(stringViewInput, 6), 4);
+
+  stringInput = std::string("你好a世界");
+  stringViewInput = std::string_view(stringInput);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 1), 3);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 2), 6);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 3), 7);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 4), 10);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 5), 13);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 6), 13);
+
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 1), 3);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 2), 6);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 3), 7);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 4), 10);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 5), 13);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 6), 13);
+
+  stringInput = std::string("\x80");
+  stringViewInput = std::string_view(stringInput);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 1), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 2), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 3), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 4), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 5), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 6), 1);
+
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 1), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 2), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 3), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 4), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 5), 1);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 6), 1);
+
+  stringInput.resize(2);
+  // Create corrupt data below.
+  char16_t c = u'\u04FF';
+  stringInput[0] = (char)c;
+  stringInput[1] = (char)c;
+
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 1), 1);
+
+  stringInput.resize(4);
+  c = u'\u04F4';
+  char16_t c2 = u'\u048F';
+  char16_t c3 = u'\u04BF';
+  stringInput[0] = (char)c;
+  stringInput[1] = (char)c2;
+  stringInput[2] = (char)c3;
+  stringInput[3] = (char)c3;
+
+  stringViewInput = std::string_view(stringInput);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 1), 4);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 2), 4);
+  ASSERT_EQ(cappedByteLength<false>(stringInput, 3), 4);
+
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 1), 4);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 2), 4);
+  ASSERT_EQ(cappedByteLength<false>(stringViewInput, 3), 4);
+}
+
 TEST_F(StringImplTest, badUnicodeLength) {
   ASSERT_EQ(0, length</*isAscii*/ false>(std::string("")));
   ASSERT_EQ(2, length</*isAscii*/ false>(std::string("ab")));
@@ -470,12 +583,13 @@ TEST_F(StringImplTest, getByteRange) {
     auto expectedEndByteIndex = strlen(unicodeString);
 
     // Find the byte range of unicodeString[i, end]
-    auto range = getByteRange</*isAscii*/ false>(unicodeString, i, 6 - i + 1);
+    auto range =
+        getByteRange</*isAscii*/ false>(unicodeString, 12, i, 6 - i + 1);
 
     EXPECT_EQ(expectedStartByteIndex, range.first);
     EXPECT_EQ(expectedEndByteIndex, range.second);
 
-    range = getByteRange</*isAscii*/ false>(unicodeString, i, 6 - i + 1);
+    range = getByteRange</*isAscii*/ false>(unicodeString, 12, i, 6 - i + 1);
 
     EXPECT_EQ(expectedStartByteIndex, range.first);
     EXPECT_EQ(expectedEndByteIndex, range.second);
@@ -485,13 +599,14 @@ TEST_F(StringImplTest, getByteRange) {
 
   // This exercises bad unicode byte in determining startByteIndex.
   std::string badUnicode = "aa\xff  ";
-  auto range = getByteRange<false>(badUnicode.data(), 4, 3);
+  auto range =
+      getByteRange<false>(badUnicode.data(), badUnicode.length(), 4, 2);
   EXPECT_EQ(range.first, 3);
-  EXPECT_EQ(range.second, 6);
+  EXPECT_EQ(range.second, 5);
 
   // This exercises bad unicode byte in determining endByteIndex.
   badUnicode = "\xff aa";
-  range = getByteRange<false>(badUnicode.data(), 1, 3);
+  range = getByteRange<false>(badUnicode.data(), badUnicode.length(), 1, 3);
   EXPECT_EQ(range.first, 0);
   EXPECT_EQ(range.second, 3);
 }
@@ -537,10 +652,18 @@ TEST_F(StringImplTest, pad) {
                              const std::string& padString) {
     core::StringWriter output;
 
-    EXPECT_THROW(
-        (facebook::velox::functions::stringImpl::pad<true, true>(
-            output, StringView(string), size, StringView(padString))),
-        VeloxUserError);
+    bool padStringIsAscii = isAscii(padString.c_str(), padString.size());
+    if (padStringIsAscii) {
+      EXPECT_THROW(
+          (facebook::velox::functions::stringImpl::pad<true, true>(
+              output, StringView(string), size, StringView(padString))),
+          VeloxUserError);
+    } else {
+      EXPECT_THROW(
+          (facebook::velox::functions::stringImpl::pad<true, false>(
+              output, StringView(string), size, StringView(padString))),
+          VeloxUserError);
+    }
   };
 
   // ASCII string with various values for size and padString
@@ -597,6 +720,9 @@ TEST_F(StringImplTest, pad) {
   runTest(
       "abcd\xff \xff ef", 11, "0", "0abcd\xff \xff ef", "abcd\xff \xff ef0");
   runTest("abcd\xff ef", 6, "0", "abcd\xff ", "abcd\xff ");
+  // Testcase for when padString is a sequence of unicode continuation bytes
+  // for which effective length is 0.
+  runTestUserError(/*string=*/"\u4FE1", /*size=*/6, /*padString=*/"\xBF\xBF");
 }
 
 // Make sure that utf8proc_codepoint returns invalid codepoint (-1) for
@@ -643,3 +769,13 @@ TEST_F(StringImplTest, utf8proc_codepoint) {
 TEST_F(StringImplTest, isUnicodeWhiteSpace) {
   EXPECT_FALSE(isUnicodeWhiteSpace(-1));
 }
+
+TEST_F(StringImplTest, isAscii) {
+  std::string s(101, 'a');
+  ASSERT_TRUE(isAscii(s.data(), 1));
+  ASSERT_TRUE(isAscii(s.data(), s.size()));
+  const char* alpha = "\u03b1";
+  memcpy(&s[0], alpha, strlen(alpha));
+  ASSERT_FALSE(isAscii(s.data(), strlen(alpha)));
+  ASSERT_FALSE(isAscii(s.data(), s.size()));
+}
diff --git a/velox/functions/lib/tests/CMakeLists.txt b/velox/functions/lib/tests/CMakeLists.txt
index dc338895e7449..c3486a6687295 100644
--- a/velox/functions/lib/tests/CMakeLists.txt
+++ b/velox/functions/lib/tests/CMakeLists.txt
@@ -14,12 +14,16 @@
 add_executable(
   velox_functions_lib_test
   ApproxMostFrequentStreamSummaryTest.cpp
+  CheckNestedNullsTest.cpp
   DateTimeFormatterTest.cpp
   IsNullTest.cpp
   IsNotNullTest.cpp
   KllSketchTest.cpp
+  LambdaFunctionUtilTest.cpp
   MapConcatTest.cpp
   Re2FunctionsTest.cpp
+  RepeatTest.cpp
+  Utf8Test.cpp
   ZetaDistributionTest.cpp)
 
 add_test(
@@ -36,7 +40,7 @@ target_link_libraries(
   velox_expression
   velox_memory
   velox_dwio_common_test_utils
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   gflags::gflags)
diff --git a/velox/functions/lib/tests/CheckNestedNullsTest.cpp b/velox/functions/lib/tests/CheckNestedNullsTest.cpp
new file mode 100644
index 0000000000000..e2d10eb77816f
--- /dev/null
+++ b/velox/functions/lib/tests/CheckNestedNullsTest.cpp
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+
+#include "velox/functions/lib/CheckNestedNulls.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::functions::test {
+class CheckNestedNullsTest : public testing::Test,
+                             public facebook::velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(CheckNestedNullsTest, array) {
+  auto baseVector = makeArrayVectorFromJson<int32_t>({
+      "null",
+      "[6, 7]",
+      "[2, null]",
+  });
+  DecodedVector decodedVector(*baseVector);
+  const auto* indices = decodedVector.indices();
+
+  for (bool throwOnNestedNulls : {true, false}) {
+    ASSERT_TRUE(
+        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+    ASSERT_FALSE(
+        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+  }
+
+  VELOX_ASSERT_THROW(
+      checkNestedNulls(decodedVector, indices, 2, true),
+      "ARRAY comparison not supported for values that contain nulls");
+  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+}
+
+TEST_F(CheckNestedNullsTest, map) {
+  auto baseVector = makeMapVectorFromJson<int32_t, int32_t>({
+      "null",
+      "{4: 7, 1: 2}",
+      "{6: 8, 8: null}",
+  });
+  DecodedVector decodedVector(*baseVector);
+  const auto* indices = decodedVector.indices();
+
+  for (bool throwOnNestedNulls : {true, false}) {
+    ASSERT_TRUE(
+        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+    ASSERT_FALSE(
+        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+  }
+
+  VELOX_ASSERT_THROW(
+      checkNestedNulls(decodedVector, indices, 2, true),
+      "MAP comparison not supported for values that contain nulls");
+  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+}
+
+TEST_F(CheckNestedNullsTest, row) {
+  auto baseVector = makeRowVector(
+      {
+          makeFlatVector<StringView>({
+              "a"_sv,
+              "b"_sv,
+              "c"_sv,
+          }),
+          makeNullableFlatVector<StringView>({
+              "aa"_sv,
+              "bb"_sv,
+              std::nullopt,
+          }),
+      },
+      [](vector_size_t row) { return row == 0; });
+  DecodedVector decodedVector(*baseVector);
+  const auto* indices = decodedVector.indices();
+
+  for (bool throwOnNestedNulls : {true, false}) {
+    ASSERT_TRUE(
+        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+    ASSERT_FALSE(
+        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+  }
+
+  VELOX_ASSERT_THROW(
+      checkNestedNulls(decodedVector, indices, 2, true),
+      "ROW comparison not supported for values that contain nulls");
+  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+}
+} // namespace facebook::velox::functions::test
diff --git a/velox/functions/lib/tests/DateTimeFormatterTest.cpp b/velox/functions/lib/tests/DateTimeFormatterTest.cpp
index 659164f91693f..1066bf6cbebad 100644
--- a/velox/functions/lib/tests/DateTimeFormatterTest.cpp
+++ b/velox/functions/lib/tests/DateTimeFormatterTest.cpp
@@ -14,16 +14,12 @@
  * limitations under the License.
  */
 #include "velox/functions/lib/DateTimeFormatter.h"
-#include <velox/common/base/VeloxException.h>
-#include <velox/type/StringView.h>
-#include "velox/common/base/Exceptions.h"
-#include "velox/external/date/tz.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/lib/DateTimeFormatterBuilder.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 #include <gtest/gtest.h>
-#include <string>
 
 using namespace facebook::velox;
 
@@ -61,6 +57,14 @@ class DateTimeFormatterTest : public testing::Test {
       "Dec",
   };
 
+  static Timestamp fromTimestampString(const StringView& timestamp) {
+    return util::fromTimestampString(
+               timestamp, util::TimestampParseMode::kPrestoCast)
+        .thenOrThrow(folly::identity, [&](const Status& status) {
+          VELOX_USER_FAIL("{}", status.message());
+        });
+  }
+
   void testTokenRange(
       char specifier,
       int numTokenStart,
@@ -74,16 +78,27 @@ class DateTimeFormatterTest : public testing::Test {
     }
   }
 
+  DateTimeResult dateTimeResult(
+      Expected<DateTimeResult> dateTimeResultExpected) {
+    return dateTimeResultExpected.thenOrThrow(
+        folly::identity,
+        [&](const Status& status) { VELOX_USER_FAIL("{}", status.message()); });
+  }
+
   DateTimeResult parseJoda(
       const std::string_view& input,
       const std::string_view& format) {
-    return buildJodaDateTimeFormatter(format)->parse(input);
+    auto dateTimeResultExpected =
+        buildJodaDateTimeFormatter(format)->parse(input);
+    return dateTimeResult(dateTimeResultExpected);
   }
 
   Timestamp parseMysql(
       const std::string_view& input,
       const std::string_view& format) {
-    return buildMysqlDateTimeFormatter(format)->parse(input).timestamp;
+    auto dateTimeResultExpected =
+        buildMysqlDateTimeFormatter(format)->parse(input);
+    return dateTimeResult(dateTimeResultExpected).timestamp;
   }
 
   // Parses and returns the timezone converted back to string, to ease
@@ -91,11 +106,26 @@ class DateTimeFormatterTest : public testing::Test {
   std::string parseTZ(
       const std::string_view& input,
       const std::string_view& format) {
-    auto result = buildJodaDateTimeFormatter(format)->parse(input);
+    auto dateTimeResultExpected =
+        buildJodaDateTimeFormatter(format)->parse(input);
+    auto result = dateTimeResult(dateTimeResultExpected);
     if (result.timezoneId == 0) {
       return "+00:00";
     }
-    return util::getTimeZoneName(result.timezoneId);
+    return tz::getTimeZoneName(result.timezoneId);
+  }
+
+  std::string formatMysqlDateTime(
+      const std::string& format,
+      const Timestamp& timestamp,
+      const tz::TimeZone* timezone) const {
+    auto formatter = buildMysqlDateTimeFormatter(format);
+    const auto maxSize = formatter->maxResultSize(timezone);
+    std::string result(maxSize, '\0');
+    auto resultSize =
+        formatter->format(timestamp, timezone, maxSize, result.data());
+    result.resize(resultSize);
+    return result;
   }
 };
 
@@ -380,51 +410,45 @@ TEST_F(JodaDateTimeFormatterTest, invalid) {
 TEST_F(JodaDateTimeFormatterTest, parseJodaEra) {
   // Normal era cases
   EXPECT_EQ(
-      util::fromTimestampString("-100-01-01"),
-      parseJoda("BC 101", "G Y").timestamp);
+      fromTimestampString("-100-01-01"), parseJoda("BC 101", "G Y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("101-01-01"),
-      parseJoda("AD 101", "G Y").timestamp);
+      fromTimestampString("101-01-01"), parseJoda("AD 101", "G Y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-100-01-01"),
-      parseJoda("bc 101", "G Y").timestamp);
+      fromTimestampString("-100-01-01"), parseJoda("bc 101", "G Y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("101-01-01"),
-      parseJoda("ad 101", "G Y").timestamp);
+      fromTimestampString("101-01-01"), parseJoda("ad 101", "G Y").timestamp);
 
   // Era specifier with 'y' specifier
   EXPECT_EQ(
-      util::fromTimestampString("101-01-01"),
-      parseJoda("BC 101", "G y").timestamp);
+      fromTimestampString("101-01-01"), parseJoda("BC 101", "G y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-01"),
-      parseJoda("BC 2012", "G y").timestamp);
+      fromTimestampString("2012-01-01"), parseJoda("BC 2012", "G y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-101-01-01"),
+      fromTimestampString("-101-01-01"),
       parseJoda("AD 2012 -101", "G Y y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-01"),
+      fromTimestampString("2012-01-01"),
       parseJoda("BC 101 2012", "G Y y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-2011-01-01"),
+      fromTimestampString("-2011-01-01"),
       parseJoda("BC 2000 2012", "G y Y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-2011-01-01"),
+      fromTimestampString("-2011-01-01"),
       parseJoda("BC 2000 2012 BC", "G y Y G").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-2014-01-01"),
+      fromTimestampString("-2014-01-01"),
       parseJoda("BC 1 BC 2015", "G y G Y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2015-01-01"),
+      fromTimestampString("2015-01-01"),
       parseJoda("BC 0 BC 2015 AD", "G y G Y G").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2015-01-01"),
+      fromTimestampString("2015-01-01"),
       parseJoda("AD 0 AD 2015", "G y G Y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-2011-01-01"),
+      fromTimestampString("-2011-01-01"),
       parseJoda("BC 0 BC 2015 2 2012 BC", "G y G Y y Y G").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-01"),
+      fromTimestampString("2012-01-01"),
       parseJoda("AD 0 AD 2015 2 2012 AD", "G y G Y y Y G").timestamp);
 
   // Invalid cases
@@ -439,23 +463,19 @@ TEST_F(JodaDateTimeFormatterTest, parseJodaEra) {
 
 TEST_F(JodaDateTimeFormatterTest, parseYearOfEra) {
   // By the default, assume epoch.
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01"), parseJoda(" ", " ").timestamp);
+  EXPECT_EQ(fromTimestampString("1970-01-01"), parseJoda(" ", " ").timestamp);
 
   // Number of times the token is repeated doesn't change the parsing behavior.
   EXPECT_EQ(
-      util::fromTimestampString("2134-01-01"),
-      parseJoda("2134", "Y").timestamp);
+      fromTimestampString("2134-01-01"), parseJoda("2134", "Y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2134-01-01"),
+      fromTimestampString("2134-01-01"),
       parseJoda("2134", "YYYYYYYY").timestamp);
 
   // Probe the year of era range. Joda only supports positive years.
   EXPECT_EQ(
-      util::fromTimestampString("294247-01-01"),
-      parseJoda("294247", "Y").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0001-01-01"), parseJoda("1", "Y").timestamp);
+      fromTimestampString("294247-01-01"), parseJoda("294247", "Y").timestamp);
+  EXPECT_EQ(fromTimestampString("0001-01-01"), parseJoda("1", "Y").timestamp);
   EXPECT_THROW(parseJoda("292278994", "Y"), VeloxUserError);
   EXPECT_THROW(parseJoda("0", "Y"), VeloxUserError);
   EXPECT_THROW(parseJoda("-1", "Y"), VeloxUserError);
@@ -463,27 +483,19 @@ TEST_F(JodaDateTimeFormatterTest, parseYearOfEra) {
   EXPECT_THROW(parseJoda(" 1 2", "Y Y"), VeloxUserError);
 
   // 2 'Y' token case
+  EXPECT_EQ(fromTimestampString("2012-01-01"), parseJoda("12", "YY").timestamp);
+  EXPECT_EQ(fromTimestampString("2069-01-01"), parseJoda("69", "YY").timestamp);
+  EXPECT_EQ(fromTimestampString("1970-01-01"), parseJoda("70", "YY").timestamp);
+  EXPECT_EQ(fromTimestampString("1999-01-01"), parseJoda("99", "YY").timestamp);
+  EXPECT_EQ(fromTimestampString("0002-01-01"), parseJoda("2", "YY").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-01"), parseJoda("12", "YY").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2069-01-01"), parseJoda("69", "YY").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01"), parseJoda("70", "YY").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("1999-01-01"), parseJoda("99", "YY").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0002-01-01"), parseJoda("2", "YY").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0210-01-01"),
-      parseJoda("210", "YY").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0001-01-01"), parseJoda("1", "YY").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2001-01-01"), parseJoda("01", "YY").timestamp);
+      fromTimestampString("0210-01-01"), parseJoda("210", "YY").timestamp);
+  EXPECT_EQ(fromTimestampString("0001-01-01"), parseJoda("1", "YY").timestamp);
+  EXPECT_EQ(fromTimestampString("2001-01-01"), parseJoda("01", "YY").timestamp);
 
   // Last token read overwrites:
   EXPECT_EQ(
-      util::fromTimestampString("0005-01-01"),
+      fromTimestampString("0005-01-01"),
       parseJoda("1 2 3 4 5", "Y Y Y Y Y").timestamp);
 
   // Throws on consumption of plus sign
@@ -492,57 +504,39 @@ TEST_F(JodaDateTimeFormatterTest, parseYearOfEra) {
 
 // Same semantic as YEAR_OF_ERA, except that it accepts zero and negative years.
 TEST_F(JodaDateTimeFormatterTest, parseYear) {
+  EXPECT_EQ(fromTimestampString("123-01-01"), parseJoda("123", "y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("123-01-01"), parseJoda("123", "y").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("321-01-01"),
-      parseJoda("321", "yyyyyyyy").timestamp);
+      fromTimestampString("321-01-01"), parseJoda("321", "yyyyyyyy").timestamp);
 
+  EXPECT_EQ(fromTimestampString("0-01-01"), parseJoda("0", "y").timestamp);
+  EXPECT_EQ(fromTimestampString("-1-01-01"), parseJoda("-1", "y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("0-01-01"), parseJoda("0", "y").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("-1-01-01"), parseJoda("-1", "y").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("-1234-01-01"),
-      parseJoda("-1234", "y").timestamp);
+      fromTimestampString("-1234-01-01"), parseJoda("-1234", "y").timestamp);
 
   // Last token read overwrites:
   EXPECT_EQ(
-      util::fromTimestampString("0-01-01"),
-      parseJoda("123 0", "Y y").timestamp);
+      fromTimestampString("0-01-01"), parseJoda("123 0", "Y y").timestamp);
 
   // 2 'y' token case
+  EXPECT_EQ(fromTimestampString("2012-01-01"), parseJoda("12", "yy").timestamp);
+  EXPECT_EQ(fromTimestampString("2069-01-01"), parseJoda("69", "yy").timestamp);
+  EXPECT_EQ(fromTimestampString("1970-01-01"), parseJoda("70", "yy").timestamp);
+  EXPECT_EQ(fromTimestampString("1999-01-01"), parseJoda("99", "yy").timestamp);
+  EXPECT_EQ(fromTimestampString("0002-01-01"), parseJoda("2", "yy").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-01"), parseJoda("12", "yy").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2069-01-01"), parseJoda("69", "yy").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01"), parseJoda("70", "yy").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("1999-01-01"), parseJoda("99", "yy").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0002-01-01"), parseJoda("2", "yy").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0210-01-01"),
-      parseJoda("210", "yy").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0001-01-01"), parseJoda("1", "yy").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2001-01-01"), parseJoda("01", "yy").timestamp);
+      fromTimestampString("0210-01-01"), parseJoda("210", "yy").timestamp);
+  EXPECT_EQ(fromTimestampString("0001-01-01"), parseJoda("1", "yy").timestamp);
+  EXPECT_EQ(fromTimestampString("2001-01-01"), parseJoda("01", "yy").timestamp);
 
   // Plus sign consumption valid when y operator is not followed by another
   // specifier
+  EXPECT_EQ(fromTimestampString("10-01-01"), parseJoda("+10", "y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("10-01-01"), parseJoda("+10", "y").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("99-02-01"),
-      parseJoda("+99 02", "y M").timestamp);
+      fromTimestampString("99-02-01"), parseJoda("+99 02", "y M").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("10-10-01"),
-      parseJoda("10 +10", "M y").timestamp);
+      fromTimestampString("10-10-01"), parseJoda("10 +10", "M y").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("100-02-01"),
-      parseJoda("2+100", "My").timestamp);
+      fromTimestampString("100-02-01"), parseJoda("2+100", "My").timestamp);
   EXPECT_THROW(parseJoda("+10001", "yM"), VeloxUserError);
   EXPECT_THROW(parseJoda("++100", "y"), VeloxUserError);
 
@@ -550,72 +544,59 @@ TEST_F(JodaDateTimeFormatterTest, parseYear) {
   EXPECT_THROW(parseJoda("-292275056", "y"), VeloxUserError);
   EXPECT_THROW(parseJoda("292278995", "y"), VeloxUserError);
   EXPECT_EQ(
-      util::fromTimestampString("292278994-01-01"),
+      fromTimestampString("292278994-01-01"),
       parseJoda("292278994", "y").timestamp);
 }
 
 TEST_F(JodaDateTimeFormatterTest, parseWeekYear) {
   // Covers entire range of possible week year start dates (12-29 to 01-04)
   EXPECT_EQ(
-      util::fromTimestampString("1969-12-29 00:00:00"),
+      fromTimestampString("1969-12-29 00:00:00"),
       parseJoda("1970", "x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2024-12-30 00:00:00"),
+      fromTimestampString("2024-12-30 00:00:00"),
       parseJoda("2025", "x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1934-12-31 00:00:00"),
+      fromTimestampString("1934-12-31 00:00:00"),
       parseJoda("1935", "x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1990-01-01 00:00:00"),
+      fromTimestampString("1990-01-01 00:00:00"),
       parseJoda("1990", "x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("0204-01-02 00:00:00"),
+      fromTimestampString("0204-01-02 00:00:00"),
       parseJoda("204", "x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-0102-01-03 00:00:00"),
+      fromTimestampString("-0102-01-03 00:00:00"),
       parseJoda("-102", "x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-0108-01-04 00:00:00"),
+      fromTimestampString("-0108-01-04 00:00:00"),
       parseJoda("-108", "x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-1002-12-31 00:00:00"),
+      fromTimestampString("-1002-12-31 00:00:00"),
       parseJoda("-1001", "x").timestamp);
 
   // 2 'x' token case
+  EXPECT_EQ(fromTimestampString("2012-01-02"), parseJoda("12", "xx").timestamp);
+  EXPECT_EQ(fromTimestampString("2068-12-31"), parseJoda("69", "xx").timestamp);
+  EXPECT_EQ(fromTimestampString("1969-12-29"), parseJoda("70", "xx").timestamp);
+  EXPECT_EQ(fromTimestampString("1999-01-04"), parseJoda("99", "xx").timestamp);
+  EXPECT_EQ(fromTimestampString("0001-12-31"), parseJoda("2", "xx").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-02"), parseJoda("12", "xx").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2068-12-31"), parseJoda("69", "xx").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("1969-12-29"), parseJoda("70", "xx").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("1999-01-04"), parseJoda("99", "xx").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0001-12-31"), parseJoda("2", "xx").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0210-01-01"),
-      parseJoda("210", "xx").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("0001-01-01"), parseJoda("1", "xx").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2001-01-01"), parseJoda("01", "xx").timestamp);
+      fromTimestampString("0210-01-01"), parseJoda("210", "xx").timestamp);
+  EXPECT_EQ(fromTimestampString("0001-01-01"), parseJoda("1", "xx").timestamp);
+  EXPECT_EQ(fromTimestampString("2001-01-01"), parseJoda("01", "xx").timestamp);
 
   // Plus sign consumption valid when x operator is not followed by another
   // specifier
+  EXPECT_EQ(fromTimestampString("10-01-04"), parseJoda("+10", "x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("10-01-04"), parseJoda("+10", "x").timestamp);
+      fromTimestampString("0098-12-29"), parseJoda("+99 01", "x w").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("0098-12-29"),
-      parseJoda("+99 01", "x w").timestamp);
+      fromTimestampString("0099-01-05"), parseJoda("+99 02", "x w").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("0099-01-05"),
-      parseJoda("+99 02", "x w").timestamp);
+      fromTimestampString("10-03-08"), parseJoda("10 +10", "w x").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("10-03-08"),
-      parseJoda("10 +10", "w x").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("100-01-11"),
-      parseJoda("2+100", "wx").timestamp);
+      fromTimestampString("100-01-11"), parseJoda("2+100", "wx").timestamp);
   EXPECT_THROW(parseJoda("+10001", "xM"), VeloxUserError);
   EXPECT_THROW(parseJoda("++100", "x"), VeloxUserError);
 
@@ -627,11 +608,10 @@ TEST_F(JodaDateTimeFormatterTest, parseWeekYear) {
 TEST_F(JodaDateTimeFormatterTest, parseCenturyOfEra) {
   // Probe century range
   EXPECT_EQ(
-      util::fromTimestampString("292278900-01-01 00:00:00"),
+      fromTimestampString("292278900-01-01 00:00:00"),
       parseJoda("2922789", "CCCCCCC").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("00-01-01 00:00:00"),
-      parseJoda("0", "C").timestamp);
+      fromTimestampString("00-01-01 00:00:00"), parseJoda("0", "C").timestamp);
 
   // Invalid century values
   EXPECT_THROW(parseJoda("-1", "CCCCCCC"), VeloxUserError);
@@ -641,17 +621,13 @@ TEST_F(JodaDateTimeFormatterTest, parseCenturyOfEra) {
 TEST_F(JodaDateTimeFormatterTest, parseJodaMonth) {
   // Joda has this weird behavior where if minute or hour is specified, year
   // falls back to 2000, instead of epoch (1970)  ¯\_(ツ)_/¯
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseJoda("1", "M").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-01-01"), parseJoda("1", "M").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2000-07-01"),
-      parseJoda(" 7", " MM").timestamp);
+      fromTimestampString("2000-07-01"), parseJoda(" 7", " MM").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-11-01"),
-      parseJoda("11-", "M-").timestamp);
+      fromTimestampString("2000-11-01"), parseJoda("11-", "M-").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-12-01"),
-      parseJoda("-12-", "-M-").timestamp);
+      fromTimestampString("2000-12-01"), parseJoda("-12-", "-M-").timestamp);
 
   EXPECT_THROW(parseJoda("0", "M"), VeloxUserError);
   EXPECT_THROW(parseJoda("13", "M"), VeloxUserError);
@@ -660,19 +636,12 @@ TEST_F(JodaDateTimeFormatterTest, parseJodaMonth) {
   // Ensure MMM and MMMM specifiers consume both short- and long-form month
   // names
   for (int i = 0; i < 12; i++) {
-    std::string buildString("2000-" + std::to_string(i + 1) + "-01");
-    EXPECT_EQ(
-        util::fromTimestampString(StringView{buildString}),
-        parseJoda(monthsShort[i], "MMM").timestamp);
-    EXPECT_EQ(
-        util::fromTimestampString(StringView{buildString}),
-        parseJoda(monthsFull[i], "MMM").timestamp);
-    EXPECT_EQ(
-        util::fromTimestampString(StringView{buildString}),
-        parseJoda(monthsShort[i], "MMMM").timestamp);
-    EXPECT_EQ(
-        util::fromTimestampString(StringView{buildString}),
-        parseJoda(monthsFull[i], "MMMM").timestamp);
+    const auto timestampString = fmt::format("2000-{}-01", i + 1);
+    const auto timestamp = fromTimestampString(StringView(timestampString));
+    EXPECT_EQ(timestamp, parseJoda(monthsShort[i], "MMM").timestamp);
+    EXPECT_EQ(timestamp, parseJoda(monthsFull[i], "MMM").timestamp);
+    EXPECT_EQ(timestamp, parseJoda(monthsShort[i], "MMMM").timestamp);
+    EXPECT_EQ(timestamp, parseJoda(monthsFull[i], "MMMM").timestamp);
   }
 
   // Month name invalid parse
@@ -685,17 +654,13 @@ TEST_F(JodaDateTimeFormatterTest, parseJodaMonth) {
 }
 
 TEST_F(JodaDateTimeFormatterTest, parseDayOfMonth) {
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseJoda("1", "d").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-01-01"), parseJoda("1", "d").timestamp);
+      fromTimestampString("2000-01-07"), parseJoda("7 ", "dd ").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-01-07"),
-      parseJoda("7 ", "dd ").timestamp);
+      fromTimestampString("2000-01-11"), parseJoda("/11", "/dd").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-01-11"),
-      parseJoda("/11", "/dd").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2000-01-31"),
-      parseJoda("/31/", "/d/").timestamp);
+      fromTimestampString("2000-01-31"), parseJoda("/31/", "/d/").timestamp);
 
   EXPECT_THROW(parseJoda("0", "d"), VeloxUserError);
   EXPECT_THROW(parseJoda("32", "d"), VeloxUserError);
@@ -708,12 +673,12 @@ TEST_F(JodaDateTimeFormatterTest, parseDayOfMonth) {
   EXPECT_THROW(parseJoda("1 31 20 2", "M d d M"), VeloxUserError);
   EXPECT_THROW(parseJoda("2 31 20 4", "M d d M"), VeloxUserError);
   EXPECT_EQ(
-      util::fromTimestampString("2000-01-31"),
+      fromTimestampString("2000-01-31"),
       parseJoda("2 31 1", "M d M").timestamp);
 
   // Probe around leap year.
   EXPECT_EQ(
-      util::fromTimestampString("2000-02-29"),
+      fromTimestampString("2000-02-29"),
       parseJoda("2000-02-29", "Y-M-d").timestamp);
   EXPECT_THROW(parseJoda("2001-02-29", "Y-M-d"), VeloxUserError);
 }
@@ -721,78 +686,67 @@ TEST_F(JodaDateTimeFormatterTest, parseDayOfMonth) {
 TEST_F(JodaDateTimeFormatterTest, parseDayOfYear) {
   // Just day of year specifier should default to 2000. Also covers leap year
   // case
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseJoda("1", "D").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-01-01"), parseJoda("1", "D").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2000-01-07"),
-      parseJoda("7 ", "DD ").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2000-01-11"),
-      parseJoda("/11", "/DD").timestamp);
+      fromTimestampString("2000-01-07"), parseJoda("7 ", "DD ").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-01-31"),
-      parseJoda("/31/", "/DDD/").timestamp);
+      fromTimestampString("2000-01-11"), parseJoda("/11", "/DD").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("2000-02-01"), parseJoda("32", "D").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2000-02-29"), parseJoda("60", "D").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2000-12-30"), parseJoda("365", "D").timestamp);
-  EXPECT_EQ(
-      util::fromTimestampString("2000-12-31"), parseJoda("366", "D").timestamp);
+      fromTimestampString("2000-01-31"), parseJoda("/31/", "/DDD/").timestamp);
+  EXPECT_EQ(fromTimestampString("2000-02-01"), parseJoda("32", "D").timestamp);
+  EXPECT_EQ(fromTimestampString("2000-02-29"), parseJoda("60", "D").timestamp);
+  EXPECT_EQ(fromTimestampString("2000-12-30"), parseJoda("365", "D").timestamp);
+  EXPECT_EQ(fromTimestampString("2000-12-31"), parseJoda("366", "D").timestamp);
 
   // Year specified cases
   EXPECT_EQ(
-      util::fromTimestampString("1950-01-01"),
-      parseJoda("1950 1", "y D").timestamp);
+      fromTimestampString("1950-01-01"), parseJoda("1950 1", "y D").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1950-01-07"),
+      fromTimestampString("1950-01-07"),
       parseJoda("1950 7 ", "y DD ").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1950-01-11"),
+      fromTimestampString("1950-01-11"),
       parseJoda("1950 /11", "y /DD").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1950-01-31"),
+      fromTimestampString("1950-01-31"),
       parseJoda("1950 /31/", "y /DDD/").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1950-02-01"),
-      parseJoda("1950 32", "y D").timestamp);
+      fromTimestampString("1950-02-01"), parseJoda("1950 32", "y D").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1950-03-01"),
-      parseJoda("1950 60", "y D").timestamp);
+      fromTimestampString("1950-03-01"), parseJoda("1950 60", "y D").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1950-12-31"),
+      fromTimestampString("1950-12-31"),
       parseJoda("1950 365", "y D").timestamp);
   EXPECT_THROW(parseJoda("1950 366", "Y D"), VeloxUserError);
 
   // Negative year specified cases
   EXPECT_EQ(
-      util::fromTimestampString("-1950-01-01"),
+      fromTimestampString("-1950-01-01"),
       parseJoda("-1950 1", "y D").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-1950-01-07"),
+      fromTimestampString("-1950-01-07"),
       parseJoda("-1950 7 ", "y DD ").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-1950-01-11"),
+      fromTimestampString("-1950-01-11"),
       parseJoda("-1950 /11", "y /DD").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-1950-01-31"),
+      fromTimestampString("-1950-01-31"),
       parseJoda("-1950 /31/", "y /DDD/").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-1950-02-01"),
+      fromTimestampString("-1950-02-01"),
       parseJoda("-1950 32", "y D").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-1950-03-01"),
+      fromTimestampString("-1950-03-01"),
       parseJoda("-1950 60", "y D").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("-1950-12-31"),
+      fromTimestampString("-1950-12-31"),
       parseJoda("-1950 365", "y D").timestamp);
   EXPECT_THROW(parseJoda("-1950 366", "Y D"), VeloxUserError);
 
   // Ensure all days of year are checked against final selected year
   EXPECT_THROW(parseJoda("2000 366 2001", "y D y"), VeloxUserError);
   EXPECT_EQ(
-      util::fromTimestampString("2000-12-31"),
+      fromTimestampString("2000-12-31"),
       parseJoda("2001 366 2000", "y D y").timestamp);
 
   EXPECT_THROW(parseJoda("0", "d"), VeloxUserError);
@@ -801,16 +755,16 @@ TEST_F(JodaDateTimeFormatterTest, parseDayOfYear) {
 
 TEST_F(JodaDateTimeFormatterTest, parseHourOfDay) {
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7", "H").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 23:00:00"),
+      fromTimestampString("1970-01-01 23:00:00"),
       parseJoda("23", "HH").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0", "HHH").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"),
+      fromTimestampString("1970-01-01 10:00:00"),
       parseJoda("10", "HHHHHHHH").timestamp);
 
   // Hour of day invalid
@@ -821,16 +775,16 @@ TEST_F(JodaDateTimeFormatterTest, parseHourOfDay) {
 
 TEST_F(JodaDateTimeFormatterTest, parseClockHourOfDay) {
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7", "k").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("24", "kk").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"),
+      fromTimestampString("1970-01-01 01:00:00"),
       parseJoda("1", "kkk").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"),
+      fromTimestampString("1970-01-01 10:00:00"),
       parseJoda("10", "kkkkkkkk").timestamp);
 
   // Clock hour of day invalid
@@ -841,16 +795,16 @@ TEST_F(JodaDateTimeFormatterTest, parseClockHourOfDay) {
 
 TEST_F(JodaDateTimeFormatterTest, parseHourOfHalfDay) {
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7", "K").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 11:00:00"),
+      fromTimestampString("1970-01-01 11:00:00"),
       parseJoda("11", "KK").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0", "KKK").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"),
+      fromTimestampString("1970-01-01 10:00:00"),
       parseJoda("10", "KKKKKKKK").timestamp);
 
   // Hour of half day invalid
@@ -861,16 +815,16 @@ TEST_F(JodaDateTimeFormatterTest, parseHourOfHalfDay) {
 
 TEST_F(JodaDateTimeFormatterTest, parseClockHourOfHalfDay) {
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7", "h").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("12", "hh").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"),
+      fromTimestampString("1970-01-01 01:00:00"),
       parseJoda("1", "hhh").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"),
+      fromTimestampString("1970-01-01 10:00:00"),
       parseJoda("10", "hhhhhhhh").timestamp);
 
   // Clock hour of half day invalid
@@ -883,121 +837,132 @@ TEST_F(JodaDateTimeFormatterTest, parseHalfOfDay) {
   // Half of day has no effect if hour or clockhour of day is provided
   // hour of day tests
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7 PM", "H a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7 AM", "H a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7 pm", "H a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7 am", "H a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0 PM", "H a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0 AM", "H a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0 pm", "H a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0 am", "H a").timestamp);
 
   // clock hour of day tests
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7 PM", "k a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7 AM", "k a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7 pm", "k a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
+      fromTimestampString("1970-01-01 07:00:00"),
       parseJoda("7 am", "k a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("24 PM", "k a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("24 AM", "k a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("24 pm", "k a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("24 am", "k a").timestamp);
 
   // Half of day has effect if hour or clockhour of halfday is provided
   // hour of halfday tests
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 12:00:00"),
+      fromTimestampString("1970-01-01 12:00:00"),
       parseJoda("0 PM", "K a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0 AM", "K a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 18:00:00"),
+      fromTimestampString("1970-01-01 18:00:00"),
       parseJoda("6 PM", "K a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 06:00:00"),
+      fromTimestampString("1970-01-01 06:00:00"),
       parseJoda("6 AM", "K a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 23:00:00"),
+      fromTimestampString("1970-01-01 23:00:00"),
       parseJoda("11 PM", "K a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 11:00:00"),
+      fromTimestampString("1970-01-01 11:00:00"),
       parseJoda("11 AM", "K a").timestamp);
 
   // clockhour of halfday tests
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 13:00:00"),
+      fromTimestampString("1970-01-01 13:00:00"),
       parseJoda("1 PM", "h a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"),
+      fromTimestampString("1970-01-01 01:00:00"),
       parseJoda("1 AM", "h a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 18:00:00"),
+      fromTimestampString("1970-01-01 18:00:00"),
       parseJoda("6 PM", "h a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 06:00:00"),
+      fromTimestampString("1970-01-01 06:00:00"),
       parseJoda("6 AM", "h a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 12:00:00"),
+      fromTimestampString("1970-01-01 12:00:00"),
       parseJoda("12 PM", "h a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("12 AM", "h a").timestamp);
 
   // time gives precendent to most recent time specifier
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"),
+      fromTimestampString("1970-01-01 01:00:00"),
       parseJoda("0 1 AM", "H h a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 13:00:00"),
+      fromTimestampString("1970-01-01 13:00:00"),
       parseJoda("12 1 PM", "H h a").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("1 AM 0", "h a H").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 12:00:00"),
+      fromTimestampString("1970-01-01 12:00:00"),
       parseJoda("1 AM 12", "h a H").timestamp);
+
+  // Half of day still has effect even though hour or clockhour is not provided.
+  EXPECT_EQ(
+      fromTimestampString("1970-01-01 12:00:00"),
+      parseJoda("PM", "a").timestamp);
+  EXPECT_EQ(
+      fromTimestampString("1970-01-01 12:11:11"),
+      parseJoda("11:11 PM", "mm:ss a").timestamp);
+  EXPECT_EQ(
+      fromTimestampString("2018-04-28 12:59:30"),
+      parseJoda("2018-04-28 59:30 PM", "yyyy-MM-dd mm:ss a").timestamp);
 }
 
 TEST_F(JodaDateTimeFormatterTest, parseMinute) {
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:08:00"),
+      fromTimestampString("1970-01-01 00:08:00"),
       parseJoda("8", "m").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:59:00"),
+      fromTimestampString("1970-01-01 00:59:00"),
       parseJoda("59", "mm").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0/", "mmm/").timestamp);
 
   EXPECT_THROW(parseJoda("60", "m"), VeloxUserError);
@@ -1007,13 +972,13 @@ TEST_F(JodaDateTimeFormatterTest, parseMinute) {
 
 TEST_F(JodaDateTimeFormatterTest, parseSecond) {
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:09"),
+      fromTimestampString("1970-01-01 00:00:09"),
       parseJoda("9", "s").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:58"),
+      fromTimestampString("1970-01-01 00:00:58"),
       parseJoda("58", "ss").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseJoda("0/", "s/").timestamp);
 
   EXPECT_THROW(parseJoda("60", "s"), VeloxUserError);
@@ -1102,143 +1067,143 @@ TEST_F(JodaDateTimeFormatterTest, parseTimezone) {
 TEST_F(JodaDateTimeFormatterTest, parseMixedYMDFormat) {
   // Common patterns found.
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 23:00:00"),
+      fromTimestampString("2021-01-04 23:00:00"),
       parseJoda("2021-01-04+23:00", "YYYY-MM-dd+HH:mm").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2019-07-03 11:04:10"),
+      fromTimestampString("2019-07-03 11:04:10"),
       parseJoda("2019-07-03 11:04:10", "YYYY-MM-dd HH:mm:ss").timestamp);
 
   // Backwards, just for fun:
   EXPECT_EQ(
-      util::fromTimestampString("2019-07-03 11:04:10"),
+      fromTimestampString("2019-07-03 11:04:10"),
       parseJoda("10:04:11 03-07-2019", "ss:mm:HH dd-MM-YYYY").timestamp);
 
   // Include timezone.
   auto result = parseJoda("2021-11-05+01:00+09:00", "YYYY-MM-dd+HH:mmZZ");
-  EXPECT_EQ(util::fromTimestampString("2021-11-05 01:00:00"), result.timestamp);
-  EXPECT_EQ("+09:00", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2021-11-05 01:00:00"), result.timestamp);
+  EXPECT_EQ("+09:00", tz::getTimeZoneName(result.timezoneId));
 
   // Timezone offset in -hh:mm format.
   result = parseJoda("-07:232021-11-05+01:00", "ZZYYYY-MM-dd+HH:mm");
-  EXPECT_EQ(util::fromTimestampString("2021-11-05 01:00:00"), result.timestamp);
-  EXPECT_EQ("-07:23", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2021-11-05 01:00:00"), result.timestamp);
+  EXPECT_EQ("-07:23", tz::getTimeZoneName(result.timezoneId));
 
   // Timezone offset in +hhmm format.
   result = parseJoda("+01332022-03-08+13:00", "ZZYYYY-MM-dd+HH:mm");
-  EXPECT_EQ(util::fromTimestampString("2022-03-08 13:00:00"), result.timestamp);
-  EXPECT_EQ("+01:33", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2022-03-08 13:00:00"), result.timestamp);
+  EXPECT_EQ("+01:33", tz::getTimeZoneName(result.timezoneId));
 
   // Z in the input means GMT in Joda.
   EXPECT_EQ(
-      util::fromTimestampString("2022-07-29 20:03:54.667"),
+      fromTimestampString("2022-07-29 20:03:54.667"),
       parseJoda("2022-07-29T20:03:54.667Z", "yyyy-MM-dd'T'HH:mm:ss.SSSZ")
           .timestamp);
 
   // Timezone in string format.
   result = parseJoda("2021-11-05+01:00 PST", "YYYY-MM-dd+HH:mm zz");
-  EXPECT_EQ(util::fromTimestampString("2021-11-05 01:00:00"), result.timestamp);
-  EXPECT_EQ("America/Los_Angeles", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2021-11-05 01:00:00"), result.timestamp);
+  EXPECT_EQ("America/Los_Angeles", tz::getTimeZoneName(result.timezoneId));
 }
 
 TEST_F(JodaDateTimeFormatterTest, parseMixedWeekFormat) {
   // Common patterns found.
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseJoda("2021 1 1 13:29:21.213", "x w e HH:mm:ss.SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseJoda("2021 22 1 13:29:21.213", "x w e HH:mm:ss.SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseJoda("2021 22 4 13:29:21.213", "x w e HH:mm:ss.SSS").timestamp);
 
   // Day of week short text normal capitlization
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseJoda("2021 1 Mon 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseJoda("2021 22 Mon 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseJoda("2021 22 Thu 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   // Day of week long text normal capitlization
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseJoda("2021 1 Monday 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseJoda("2021 22 Monday 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseJoda("2021 22 Thursday 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
   // Day of week short text upper case
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseJoda("2021 1 MON 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseJoda("2021 22 MON 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseJoda("2021 22 THU 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   // Day of week long text upper case
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseJoda("2021 1 MONDAY 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseJoda("2021 22 MONDAY 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseJoda("2021 22 THURSDAY 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
   // Day of week short text lower case
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseJoda("2021 1 mon 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseJoda("2021 22 mon 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseJoda("2021 22 thu 13:29:21.213", "x w E HH:mm:ss.SSS").timestamp);
 
   // Day of week long text lower case
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseJoda("2021 1 monday 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseJoda("2021 22 monday 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseJoda("2021 22 thursday 13:29:21.213", "x w EEE HH:mm:ss.SSS")
           .timestamp);
 
@@ -1253,79 +1218,74 @@ TEST_F(JodaDateTimeFormatterTest, parseMixedWeekFormat) {
 
   // Backwards, just for fun:
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseJoda("213.21:29:13 1 22 2021", "SSS.ss:mm:HH e w x").timestamp);
 
   // Include timezone.
   auto result =
       parseJoda("2021 22 1 13:29:21.213+09:00", "x w e HH:mm:ss.SSSZZ");
-  EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"), result.timestamp);
-  EXPECT_EQ("+09:00", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2021-05-31 13:29:21.213"), result.timestamp);
+  EXPECT_EQ("+09:00", tz::getTimeZoneName(result.timezoneId));
 
   // Timezone offset in -hh:mm format.
   result = parseJoda("-07:232021 22 1 13:29:21.213", "ZZx w e HH:mm:ss.SSS");
-  EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"), result.timestamp);
-  EXPECT_EQ("-07:23", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2021-05-31 13:29:21.213"), result.timestamp);
+  EXPECT_EQ("-07:23", tz::getTimeZoneName(result.timezoneId));
 
   // Timezone offset in +hhmm format.
   result = parseJoda("+01332021 22 1 13:29:21.213", "ZZx w e HH:mm:ss.SSS");
-  EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"), result.timestamp);
-  EXPECT_EQ("+01:33", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2021-05-31 13:29:21.213"), result.timestamp);
+  EXPECT_EQ("+01:33", tz::getTimeZoneName(result.timezoneId));
 }
 
 TEST_F(JodaDateTimeFormatterTest, parseFractionOfSecond) {
   // Valid milliseconds and timezone with positive offset.
   auto result =
       parseJoda("2022-02-23T12:15:00.364+04:00", "yyyy-MM-dd'T'HH:mm:ss.SSSZ");
-  EXPECT_EQ(
-      util::fromTimestampString("2022-02-23 12:15:00.364"), result.timestamp);
-  EXPECT_EQ("+04:00", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2022-02-23 12:15:00.364"), result.timestamp);
+  EXPECT_EQ("+04:00", tz::getTimeZoneName(result.timezoneId));
 
   // Valid milliseconds and timezone with negative offset.
   result =
       parseJoda("2022-02-23T12:15:00.776-14:00", "yyyy-MM-dd'T'HH:mm:ss.SSSZ");
-  EXPECT_EQ(
-      util::fromTimestampString("2022-02-23 12:15:00.776"), result.timestamp);
-  EXPECT_EQ("-14:00", util::getTimeZoneName(result.timezoneId));
+  EXPECT_EQ(fromTimestampString("2022-02-23 12:15:00.776"), result.timestamp);
+  EXPECT_EQ("-14:00", tz::getTimeZoneName(result.timezoneId));
 
   // Valid milliseconds.
   EXPECT_EQ(
-      util::fromTimestampString("2022-02-24 02:19:33.283"),
+      fromTimestampString("2022-02-24 02:19:33.283"),
       parseJoda("2022-02-24 02:19:33.283", "yyyy-MM-dd HH:mm:ss.SSS")
           .timestamp);
 
   // Test without milliseconds.
   EXPECT_EQ(
-      util::fromTimestampString("2022-02-23 20:30:00"),
+      fromTimestampString("2022-02-23 20:30:00"),
       parseJoda("2022-02-23T20:30:00", "yyyy-MM-dd'T'HH:mm:ss").timestamp);
 
   // Assert on difference in milliseconds.
   EXPECT_NE(
-      util::fromTimestampString("2022-02-23 12:15:00.223"),
+      fromTimestampString("2022-02-23 12:15:00.223"),
       parseJoda("2022-02-23T12:15:00.776", "yyyy-MM-dd'T'HH:mm:ss.SSS")
           .timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.000"),
+      fromTimestampString("1970-01-01 00:00:00.000"),
       parseJoda("000", "SSS").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.001"),
+      fromTimestampString("1970-01-01 00:00:00.001"),
       parseJoda("001", "SSS").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.999"),
+      fromTimestampString("1970-01-01 00:00:00.999"),
       parseJoda("999", "SSS").timestamp);
 
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.045"),
+      fromTimestampString("1970-01-01 00:00:00.045"),
       parseJoda("045", "SSS").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.450"),
+      fromTimestampString("1970-01-01 00:00:00.450"),
       parseJoda("45", "SS").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.450"),
+      fromTimestampString("1970-01-01 00:00:00.450"),
       parseJoda("45", "SSSS").timestamp);
 
   EXPECT_THROW(parseJoda("-1", "S"), VeloxUserError);
@@ -1334,27 +1294,55 @@ TEST_F(JodaDateTimeFormatterTest, parseFractionOfSecond) {
 
 TEST_F(JodaDateTimeFormatterTest, parseConsecutiveSpecifiers) {
   EXPECT_EQ(
-      util::fromTimestampString("2012-12-01"),
-      parseJoda("1212", "YYM").timestamp);
+      fromTimestampString("2012-12-01"), parseJoda("1212", "YYM").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("0012-12-01"),
-      parseJoda("1212", "MY").timestamp);
+      fromTimestampString("0012-12-01"), parseJoda("1212", "MY").timestamp);
   EXPECT_THROW(parseJoda("1212", "YM"), VeloxUserError);
 
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-01 12:00:00"),
+      fromTimestampString("2012-01-01 12:00:00"),
       parseJoda("1212", "YYH").timestamp);
   EXPECT_EQ(
-      util::fromTimestampString("0012-01-01 12:00:00"),
+      fromTimestampString("0012-01-01 12:00:00"),
       parseJoda("1212", "HY").timestamp);
   EXPECT_THROW(parseJoda("1212", "YH"), VeloxUserError);
 
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-01 12:00:00"),
+      fromTimestampString("2012-01-01 12:00:00"),
       parseJoda("1212", "yyH").timestamp);
   EXPECT_THROW(parseJoda("12312", "yyH"), VeloxUserError);
 }
 
+TEST_F(JodaDateTimeFormatterTest, formatResultSize) {
+  auto* timezone = tz::locateZone("GMT");
+
+  EXPECT_EQ(
+      buildJodaDateTimeFormatter("yyyy-MM-dd")->maxResultSize(timezone), 12);
+  EXPECT_EQ(buildJodaDateTimeFormatter("yyyy-MM")->maxResultSize(timezone), 9);
+  EXPECT_EQ(buildJodaDateTimeFormatter("y")->maxResultSize(timezone), 6);
+  EXPECT_EQ(
+      buildJodaDateTimeFormatter("yyyy////MM////dd")->maxResultSize(timezone),
+      18);
+  EXPECT_EQ(
+      buildJodaDateTimeFormatter("yyyy-MM-dd HH:mm:ss.SSS")
+          ->maxResultSize(timezone),
+      31);
+  // No padding. CENTURY_OF_ERA can be at most 3 digits.
+  EXPECT_EQ(buildJodaDateTimeFormatter("C")->maxResultSize(timezone), 3);
+  // Needs to pad to make result contain 4 digits.
+  EXPECT_EQ(buildJodaDateTimeFormatter("CCCC")->maxResultSize(timezone), 4);
+}
+
+TEST_F(JodaDateTimeFormatterTest, betterErrorMessaging) {
+  VELOX_ASSERT_THROW(
+      parseJoda("2057-02-29T14:48:14.891Z", "yyyy-MM-dd'T'HH:mm:ss.SSSZ"),
+      "Value 29 for dayOfMonth must be in the range [1,28] for year 2057 and month 2.");
+
+  VELOX_ASSERT_THROW(
+      parseJoda("2057-02-429T14:48:14.891Z", "yyyy-MM-D'T'HH:mm:ss.SSSZ"),
+      "Value 429 for dayOfMonth must be in the range [1,365] for year 2057 and month 2.");
+}
+
 class MysqlDateTimeTest : public DateTimeFormatterTest {};
 
 TEST_F(MysqlDateTimeTest, validBuild) {
@@ -1432,482 +1420,450 @@ TEST_F(MysqlDateTimeTest, invalidBuild) {
 }
 
 TEST_F(MysqlDateTimeTest, formatYear) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("0-01-01"), timezone),
+      formatMysqlDateTime("%Y", fromTimestampString("0-01-01"), timezone),
       "0000");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("1-01-01"), timezone),
+      formatMysqlDateTime("%Y", fromTimestampString("1-01-01"), timezone),
       "0001");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("199-01-01"), timezone),
+      formatMysqlDateTime("%Y", fromTimestampString("199-01-01"), timezone),
       "0199");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("9999-01-01"), timezone),
+      formatMysqlDateTime("%Y", fromTimestampString("9999-01-01"), timezone),
       "9999");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("-1-01-01"), timezone),
+      formatMysqlDateTime("%Y", fromTimestampString("-1-01-01"), timezone),
       "-0001");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("19999-01-01"), timezone),
+      formatMysqlDateTime("%Y", fromTimestampString("19999-01-01"), timezone),
       "19999");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("-19999-01-01"), timezone),
+      formatMysqlDateTime("%Y", fromTimestampString("-19999-01-01"), timezone),
       "-19999");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("-1-01-01"), timezone),
+      formatMysqlDateTime("%Y", fromTimestampString("-1-01-01"), timezone),
       "-0001");
   EXPECT_THROW(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("-99999-01-01"), timezone),
-      VeloxUserError);
+      formatMysqlDateTime("%Y", fromTimestampString("-99999-01-01"), timezone),
+      VeloxRuntimeError);
   EXPECT_THROW(
-      buildMysqlDateTimeFormatter("%Y")->format(
-          util::fromTimestampString("99999-01-01"), timezone),
-      VeloxUserError);
+      formatMysqlDateTime("%Y", fromTimestampString("99999-01-01"), timezone),
+      VeloxRuntimeError);
 }
 
 TEST_F(MysqlDateTimeTest, formatMonthDay) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("0-01-01"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("0-01-01"), timezone),
       "01~01");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("1-10-24"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("1-10-24"), timezone),
       "10~24");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("199-09-30"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("199-09-30"), timezone),
       "09~30");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("9999-01-01"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("9999-01-01"), timezone),
       "01~01");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("-1-01-01"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("-1-01-01"), timezone),
       "01~01");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("19999-01-01"), timezone),
+      formatMysqlDateTime(
+          "%m~%d", fromTimestampString("19999-01-01"), timezone),
       "01~01");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("-19999-01-01"), timezone),
+      formatMysqlDateTime(
+          "%m~%d", fromTimestampString("-19999-01-01"), timezone),
       "01~01");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("-1-01-01"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("-1-01-01"), timezone),
       "01~01");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("2000-02-29"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("2000-02-29"), timezone),
       "02~29");
   EXPECT_THROW(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("-1-13-01"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("-1-13-01"), timezone),
       VeloxUserError);
   EXPECT_THROW(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("1999-02-50"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("1999-02-50"), timezone),
       VeloxUserError);
   EXPECT_THROW(
-      buildMysqlDateTimeFormatter("%m~%d")->format(
-          util::fromTimestampString("1999-02-29"), timezone),
+      formatMysqlDateTime("%m~%d", fromTimestampString("1999-02-29"), timezone),
       VeloxUserError);
 }
 
 TEST_F(MysqlDateTimeTest, formatWeekday) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%a..->%W")
-          ->format(util::fromTimestampString("1999-01-04"), timezone),
+      formatMysqlDateTime(
+          "%a..->%W", fromTimestampString("1999-01-04"), timezone),
       "Mon..->Monday");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%a..->%W")
-          ->format(util::fromTimestampString("1999-01-05"), timezone),
+      formatMysqlDateTime(
+          "%a..->%W", fromTimestampString("1999-01-05"), timezone),
       "Tue..->Tuesday");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%a..->%W")
-          ->format(util::fromTimestampString("1999-01-06"), timezone),
+      formatMysqlDateTime(
+          "%a..->%W", fromTimestampString("1999-01-06"), timezone),
       "Wed..->Wednesday");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%a..->%W")
-          ->format(util::fromTimestampString("1999-01-07"), timezone),
+      formatMysqlDateTime(
+          "%a..->%W", fromTimestampString("1999-01-07"), timezone),
       "Thu..->Thursday");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%a..->%W")
-          ->format(util::fromTimestampString("1999-01-08"), timezone),
+      formatMysqlDateTime(
+          "%a..->%W", fromTimestampString("1999-01-08"), timezone),
       "Fri..->Friday");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%a..->%W")
-          ->format(util::fromTimestampString("1999-01-09"), timezone),
+      formatMysqlDateTime(
+          "%a..->%W", fromTimestampString("1999-01-09"), timezone),
       "Sat..->Saturday");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%a..->%W")
-          ->format(util::fromTimestampString("1999-01-10"), timezone),
+      formatMysqlDateTime(
+          "%a..->%W", fromTimestampString("1999-01-10"), timezone),
       "Sun..->Sunday");
 }
 
 TEST_F(MysqlDateTimeTest, formatMonth) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-01-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-01-04"), timezone),
       "1-01-January");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-02-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-02-04"), timezone),
       "2-02-February");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-03-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-03-04"), timezone),
       "3-03-March");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-04-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-04-04"), timezone),
       "4-04-April");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-05-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-05-04"), timezone),
       "5-05-May");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-06-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-06-04"), timezone),
       "6-06-June");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-07-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-07-04"), timezone),
       "7-07-July");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-08-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-08-04"), timezone),
       "8-08-August");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-09-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-09-04"), timezone),
       "9-09-September");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-10-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-10-04"), timezone),
       "10-10-October");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-11-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-11-04"), timezone),
       "11-11-November");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%c-%m-%M")
-          ->format(util::fromTimestampString("1999-12-04"), timezone),
+      formatMysqlDateTime(
+          "%c-%m-%M", fromTimestampString("1999-12-04"), timezone),
       "12-12-December");
 }
 
 TEST_F(MysqlDateTimeTest, formatDayOfMonth) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%d-%e")->format(
-          util::fromTimestampString("2000-02-01"), timezone),
+      formatMysqlDateTime("%d-%e", fromTimestampString("2000-02-01"), timezone),
       "01-1");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%d-%e")->format(
-          util::fromTimestampString("2000-02-29"), timezone),
+      formatMysqlDateTime("%d-%e", fromTimestampString("2000-02-29"), timezone),
       "29-29");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%d-%e")->format(
-          util::fromTimestampString("2000-12-31"), timezone),
+      formatMysqlDateTime("%d-%e", fromTimestampString("2000-12-31"), timezone),
       "31-31");
 }
 
 TEST_F(MysqlDateTimeTest, formatFractionOfSecond) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%f")->format(
-          util::fromTimestampString("2000-02-01 00:00:00.987"), timezone),
+      formatMysqlDateTime(
+          "%f", fromTimestampString("2000-02-01 00:00:00.987"), timezone),
       "987000");
 
   // As our current precision is 3 decimal places.
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%f")->format(
-          util::fromTimestampString("2000-02-01 00:00:00.987654"), timezone),
+      formatMysqlDateTime(
+          "%f", fromTimestampString("2000-02-01 00:00:00.987654"), timezone),
       "987000");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%f")->format(
-          util::fromTimestampString("2000-02-01 00:00:00.900654"), timezone),
+      formatMysqlDateTime(
+          "%f", fromTimestampString("2000-02-01 00:00:00.900654"), timezone),
       "900000");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%f")->format(
-          util::fromTimestampString("2000-02-01 00:00:00.090654"), timezone),
+      formatMysqlDateTime(
+          "%f", fromTimestampString("2000-02-01 00:00:00.090654"), timezone),
       "090000");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%f")->format(
-          util::fromTimestampString("2000-02-01 00:00:00.009654"), timezone),
+      formatMysqlDateTime(
+          "%f", fromTimestampString("2000-02-01 00:00:00.009654"), timezone),
       "009000");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%f")->format(
-          util::fromTimestampString("2000-02-01 00:00:00.000654"), timezone),
+      formatMysqlDateTime(
+          "%f", fromTimestampString("2000-02-01 00:00:00.000654"), timezone),
       "000000");
 }
 
 TEST_F(MysqlDateTimeTest, formatHour) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%h--%H--%I--%k--%l")
-          ->format(util::fromTimestampString("2000-02-01 00:00:00"), timezone),
+      formatMysqlDateTime(
+          "%h--%H--%I--%k--%l",
+          fromTimestampString("2000-02-01 00:00:00"),
+          timezone),
       "12--00--12--0--12");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%h--%H--%I--%k--%l")
-          ->format(util::fromTimestampString("2000-02-01 12:12:01"), timezone),
+      formatMysqlDateTime(
+          "%h--%H--%I--%k--%l",
+          fromTimestampString("2000-02-01 12:12:01"),
+          timezone),
       "12--12--12--12--12");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%h--%H--%I--%k--%l")
-          ->format(util::fromTimestampString("2000-02-01 23:23:01"), timezone),
+      formatMysqlDateTime(
+          "%h--%H--%I--%k--%l",
+          fromTimestampString("2000-02-01 23:23:01"),
+          timezone),
       "11--23--11--23--11");
 }
 
 TEST_F(MysqlDateTimeTest, formatMinute) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%i")->format(
-          util::fromTimestampString("2000-02-01 00:00:00"), timezone),
+      formatMysqlDateTime(
+          "%i", fromTimestampString("2000-02-01 00:00:00"), timezone),
       "00");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%i")->format(
-          util::fromTimestampString("2000-02-01 00:09:00"), timezone),
+      formatMysqlDateTime(
+          "%i", fromTimestampString("2000-02-01 00:09:00"), timezone),
       "09");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%i")->format(
-          util::fromTimestampString("2000-02-01 00:31:00"), timezone),
+      formatMysqlDateTime(
+          "%i", fromTimestampString("2000-02-01 00:31:00"), timezone),
       "31");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%i")->format(
-          util::fromTimestampString("2000-02-01 00:59:00"), timezone),
+      formatMysqlDateTime(
+          "%i", fromTimestampString("2000-02-01 00:59:00"), timezone),
       "59");
 }
 
 TEST_F(MysqlDateTimeTest, formatDayOfYear) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%j")->format(
-          util::fromTimestampString("2000-01-01 00:00:00"), timezone),
+      formatMysqlDateTime(
+          "%j", fromTimestampString("2000-01-01 00:00:00"), timezone),
       "001");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%j")->format(
-          util::fromTimestampString("2000-12-31 00:09:00"), timezone),
+      formatMysqlDateTime(
+          "%j", fromTimestampString("2000-12-31 00:09:00"), timezone),
       "366");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%j")->format(
-          util::fromTimestampString("1999-12-31 00:31:00"), timezone),
+      formatMysqlDateTime(
+          "%j", fromTimestampString("1999-12-31 00:31:00"), timezone),
       "365");
 }
 
 TEST_F(MysqlDateTimeTest, formatAmPm) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%p")->format(
-          util::fromTimestampString("2000-01-01 00:00:00"), timezone),
+      formatMysqlDateTime(
+          "%p", fromTimestampString("2000-01-01 00:00:00"), timezone),
       "AM");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%p")->format(
-          util::fromTimestampString("2000-01-01 11:59:59"), timezone),
+      formatMysqlDateTime(
+          "%p", fromTimestampString("2000-01-01 11:59:59"), timezone),
       "AM");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%p")->format(
-          util::fromTimestampString("2000-01-01 12:00:00"), timezone),
+      formatMysqlDateTime(
+          "%p", fromTimestampString("2000-01-01 12:00:00"), timezone),
       "PM");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%p")->format(
-          util::fromTimestampString("2000-01-01 23:59:59"), timezone),
+      formatMysqlDateTime(
+          "%p", fromTimestampString("2000-01-01 23:59:59"), timezone),
       "PM");
 }
 
 TEST_F(MysqlDateTimeTest, formatSecond) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%s-%S")->format(
-          util::fromTimestampString("2000-01-01 00:00:00"), timezone),
+      formatMysqlDateTime(
+          "%s-%S", fromTimestampString("2000-01-01 00:00:00"), timezone),
       "00-00");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%s-%S")->format(
-          util::fromTimestampString("2000-01-01 00:00:30"), timezone),
+      formatMysqlDateTime(
+          "%s-%S", fromTimestampString("2000-01-01 00:00:30"), timezone),
       "30-30");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%s-%S")->format(
-          util::fromTimestampString("2000-01-01 00:00:59"), timezone),
+      formatMysqlDateTime(
+          "%s-%S", fromTimestampString("2000-01-01 00:00:59"), timezone),
       "59-59");
 }
 
 TEST_F(MysqlDateTimeTest, formatCompositeTime) {
-  auto* timezone = date::locate_zone("GMT");
+  auto* timezone = tz::locateZone("GMT");
 
   // 12 hour %r
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%r")->format(
-          util::fromTimestampString("2000-01-01 00:00:00"), timezone),
+      formatMysqlDateTime(
+          "%r", fromTimestampString("2000-01-01 00:00:00"), timezone),
       "12:00:00 AM");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%r")->format(
-          util::fromTimestampString("2000-01-01 11:59:59"), timezone),
+      formatMysqlDateTime(
+          "%r", fromTimestampString("2000-01-01 11:59:59"), timezone),
       "11:59:59 AM");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%r")->format(
-          util::fromTimestampString("2000-01-01 12:00:00"), timezone),
+      formatMysqlDateTime(
+          "%r", fromTimestampString("2000-01-01 12:00:00"), timezone),
       "12:00:00 PM");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%r")->format(
-          util::fromTimestampString("2000-01-01 23:59:59"), timezone),
+      formatMysqlDateTime(
+          "%r", fromTimestampString("2000-01-01 23:59:59"), timezone),
       "11:59:59 PM");
 
   // 24 hour %T
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%T")->format(
-          util::fromTimestampString("2000-01-01 00:00:00"), timezone),
+      formatMysqlDateTime(
+          "%T", fromTimestampString("2000-01-01 00:00:00"), timezone),
+
       "00:00:00");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%T")->format(
-          util::fromTimestampString("2000-01-01 11:59:59"), timezone),
+      formatMysqlDateTime(
+          "%T", fromTimestampString("2000-01-01 11:59:59"), timezone),
       "11:59:59");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%T")->format(
-          util::fromTimestampString("2000-01-01 12:00:00"), timezone),
+      formatMysqlDateTime(
+          "%T", fromTimestampString("2000-01-01 12:00:00"), timezone),
       "12:00:00");
   EXPECT_EQ(
-      buildMysqlDateTimeFormatter("%T")->format(
-          util::fromTimestampString("2000-01-01 23:59:59"), timezone),
+      formatMysqlDateTime(
+          "%T", fromTimestampString("2000-01-01 23:59:59"), timezone),
       "23:59:59");
 }
 
 // Same semantic as YEAR_OF_ERA, except that it accepts zero and negative years.
 TEST_F(MysqlDateTimeTest, parseFourDigitYear) {
-  EXPECT_EQ(util::fromTimestampString("123-01-01"), parseMysql("123", "%Y"));
-  EXPECT_EQ(util::fromTimestampString("321-01-01"), parseMysql("321", "%Y"));
+  EXPECT_EQ(fromTimestampString("123-01-01"), parseMysql("123", "%Y"));
+  EXPECT_EQ(fromTimestampString("321-01-01"), parseMysql("321", "%Y"));
 
-  EXPECT_EQ(util::fromTimestampString("0-01-01"), parseMysql("0", "%Y"));
-  EXPECT_EQ(util::fromTimestampString("-1-01-01"), parseMysql("-1", "%Y"));
-  EXPECT_EQ(
-      util::fromTimestampString("-1234-01-01"), parseMysql("-1234", "%Y"));
+  EXPECT_EQ(fromTimestampString("0-01-01"), parseMysql("0", "%Y"));
+  EXPECT_EQ(fromTimestampString("-1-01-01"), parseMysql("-1", "%Y"));
+  EXPECT_EQ(fromTimestampString("-1234-01-01"), parseMysql("-1234", "%Y"));
 
   // Last token read overwrites:
-  EXPECT_EQ(util::fromTimestampString("0-01-01"), parseMysql("123 0", "%Y %Y"));
+  EXPECT_EQ(fromTimestampString("0-01-01"), parseMysql("123 0", "%Y %Y"));
 
   // Plus sign consumption valid when %Y operator is not followed by another
   // specifier
-  EXPECT_EQ(util::fromTimestampString("10-01-01"), parseMysql("+10", "%Y"));
-  EXPECT_EQ(
-      util::fromTimestampString("99-02-01"), parseMysql("+99 02", "%Y %m"));
-  EXPECT_EQ(
-      util::fromTimestampString("10-10-01"), parseMysql("10 +10", "%m %Y"));
-  EXPECT_EQ(
-      util::fromTimestampString("100-02-01"), parseMysql("2+100", "%m%Y"));
+  EXPECT_EQ(fromTimestampString("10-01-01"), parseMysql("+10", "%Y"));
+  EXPECT_EQ(fromTimestampString("99-02-01"), parseMysql("+99 02", "%Y %m"));
+  EXPECT_EQ(fromTimestampString("10-10-01"), parseMysql("10 +10", "%m %Y"));
+  EXPECT_EQ(fromTimestampString("100-02-01"), parseMysql("2+100", "%m%Y"));
   EXPECT_THROW(parseMysql("+10001", "%Y%m"), VeloxUserError);
   EXPECT_THROW(parseMysql("++100", "%Y"), VeloxUserError);
 
   // Probe the year range
   EXPECT_THROW(parseMysql("-10000", "%Y"), VeloxUserError);
   EXPECT_THROW(parseMysql("10000", "%Y"), VeloxUserError);
-  EXPECT_EQ(util::fromTimestampString("9999-01-01"), parseMysql("9999", "%Y"));
+  EXPECT_EQ(fromTimestampString("9999-01-01"), parseMysql("9999", "%Y"));
 }
 
 TEST_F(MysqlDateTimeTest, parseTwoDigitYear) {
-  EXPECT_EQ(util::fromTimestampString("1970-01-01"), parseMysql("70", "%y"));
-  EXPECT_EQ(util::fromTimestampString("2069-01-01"), parseMysql("69", "%y"));
-  EXPECT_EQ(util::fromTimestampString("2000-01-01"), parseMysql("00", "%y"));
+  EXPECT_EQ(fromTimestampString("1970-01-01"), parseMysql("70", "%y"));
+  EXPECT_EQ(fromTimestampString("2069-01-01"), parseMysql("69", "%y"));
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseMysql("00", "%y"));
 
   // Last token read overwrites:
-  EXPECT_EQ(
-      util::fromTimestampString("2030-01-01"), parseMysql("80 30", "%y %y"));
+  EXPECT_EQ(fromTimestampString("2030-01-01"), parseMysql("80 30", "%y %y"));
 }
 
 TEST_F(MysqlDateTimeTest, parseWeekYear) {
   // Covers entire range of possible week year start dates (12-29 to 01-04)
   EXPECT_EQ(
-      util::fromTimestampString("1969-12-29 00:00:00"),
-      parseMysql("1970", "%x"));
+      fromTimestampString("1969-12-29 00:00:00"), parseMysql("1970", "%x"));
   EXPECT_EQ(
-      util::fromTimestampString("2024-12-30 00:00:00"),
-      parseMysql("2025", "%x"));
+      fromTimestampString("2024-12-30 00:00:00"), parseMysql("2025", "%x"));
   EXPECT_EQ(
-      util::fromTimestampString("1934-12-31 00:00:00"),
-      parseMysql("1935", "%x"));
+      fromTimestampString("1934-12-31 00:00:00"), parseMysql("1935", "%x"));
   EXPECT_EQ(
-      util::fromTimestampString("1990-01-01 00:00:00"),
-      parseMysql("1990", "%x"));
+      fromTimestampString("1990-01-01 00:00:00"), parseMysql("1990", "%x"));
   EXPECT_EQ(
-      util::fromTimestampString("0204-01-02 00:00:00"),
-      parseMysql("204", "%x"));
+      fromTimestampString("0204-01-02 00:00:00"), parseMysql("204", "%x"));
   EXPECT_EQ(
-      util::fromTimestampString("-0102-01-03 00:00:00"),
-      parseMysql("-102", "%x"));
+      fromTimestampString("-0102-01-03 00:00:00"), parseMysql("-102", "%x"));
   EXPECT_EQ(
-      util::fromTimestampString("-0108-01-04 00:00:00"),
-      parseMysql("-108", "%x"));
+      fromTimestampString("-0108-01-04 00:00:00"), parseMysql("-108", "%x"));
   EXPECT_EQ(
-      util::fromTimestampString("-1002-12-31 00:00:00"),
-      parseMysql("-1001", "%x"));
+      fromTimestampString("-1002-12-31 00:00:00"), parseMysql("-1001", "%x"));
 
   // Plus sign consumption valid when %x operator is not followed by another
   // specifier
-  EXPECT_EQ(util::fromTimestampString("10-01-04"), parseMysql("+10", "%x"));
-  EXPECT_EQ(
-      util::fromTimestampString("0098-12-29"), parseMysql("+99 01", "%x %v"));
-  EXPECT_EQ(
-      util::fromTimestampString("0099-01-05"), parseMysql("+99 02", "%x %v"));
-  EXPECT_EQ(
-      util::fromTimestampString("10-03-08"), parseMysql("10 +10", "%v %x"));
-  EXPECT_EQ(
-      util::fromTimestampString("100-01-11"), parseMysql("2+100", "%v%x"));
-  EXPECT_THROW(parseMysql("+10001", "%x%m"), VeloxUserError);
-  EXPECT_THROW(parseMysql("++100", "%x"), VeloxUserError);
+  EXPECT_EQ(fromTimestampString("10-01-04"), parseMysql("+10", "%x"));
+  EXPECT_EQ(fromTimestampString("0098-12-29"), parseMysql("+99 01", "%x %v"));
+  EXPECT_EQ(fromTimestampString("0099-01-05"), parseMysql("+99 02", "%x %v"));
+  EXPECT_EQ(fromTimestampString("10-03-08"), parseMysql("10 +10", "%v %x"));
+  EXPECT_EQ(fromTimestampString("100-01-11"), parseMysql("2+100", "%v%x"));
+  VELOX_ASSERT_THROW(
+      parseMysql("+10001", "%x%m"), "Invalid date format: '+10001'");
+  VELOX_ASSERT_THROW(parseMysql("++100", "%x"), "Invalid date format: '++100'");
 
   // Probe week year range
-  EXPECT_THROW(parseMysql("-292275055", "%x"), VeloxUserError);
-  EXPECT_THROW(parseMysql("292278994", "%x"), VeloxUserError);
+  VELOX_ASSERT_THROW(
+      parseMysql("-292275055", "%x"), "Invalid date format: '-292275055'");
+  VELOX_ASSERT_THROW(
+      parseMysql("292278994", "%x"), "Invalid date format: '292278994'");
 }
 
 TEST_F(MysqlDateTimeTest, parseMonth) {
   // Joda has this weird behavior where if minute or hour is specified, year
   // falls back to 2000, instead of epoch (1970)  ¯\_(ツ)_/¯
-  EXPECT_EQ(util::fromTimestampString("2000-01-01"), parseMysql("1", "%m"));
-  EXPECT_EQ(util::fromTimestampString("2000-07-01"), parseMysql(" 7", " %m"));
-  EXPECT_EQ(util::fromTimestampString("2000-01-01"), parseMysql("01", "%m"));
-  EXPECT_EQ(util::fromTimestampString("2000-07-01"), parseMysql(" 07", " %m"));
-  EXPECT_EQ(util::fromTimestampString("2000-11-01"), parseMysql("11-", "%m-"));
-  EXPECT_EQ(
-      util::fromTimestampString("2000-12-01"), parseMysql("-12-", "-%m-"));
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseMysql("1", "%m"));
+  EXPECT_EQ(fromTimestampString("2000-07-01"), parseMysql(" 7", " %m"));
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseMysql("01", "%m"));
+  EXPECT_EQ(fromTimestampString("2000-07-01"), parseMysql(" 07", " %m"));
+  EXPECT_EQ(fromTimestampString("2000-11-01"), parseMysql("11-", "%m-"));
+  EXPECT_EQ(fromTimestampString("2000-12-01"), parseMysql("-12-", "-%m-"));
 
   EXPECT_THROW(parseMysql("0", "%m"), VeloxUserError);
   EXPECT_THROW(parseMysql("13", "%m"), VeloxUserError);
   EXPECT_THROW(parseMysql("12345", "%m"), VeloxUserError);
 
-  EXPECT_EQ(util::fromTimestampString("2000-01-01"), parseMysql("1", "%c"));
-  EXPECT_EQ(util::fromTimestampString("2000-07-01"), parseMysql(" 7", " %c"));
-  EXPECT_EQ(util::fromTimestampString("2000-01-01"), parseMysql("01", "%c"));
-  EXPECT_EQ(util::fromTimestampString("2000-07-01"), parseMysql(" 07", " %c"));
-  EXPECT_EQ(util::fromTimestampString("2000-11-01"), parseMysql("11-", "%c-"));
-  EXPECT_EQ(
-      util::fromTimestampString("2000-12-01"), parseMysql("-12-", "-%c-"));
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseMysql("1", "%c"));
+  EXPECT_EQ(fromTimestampString("2000-07-01"), parseMysql(" 7", " %c"));
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseMysql("01", "%c"));
+  EXPECT_EQ(fromTimestampString("2000-07-01"), parseMysql(" 07", " %c"));
+  EXPECT_EQ(fromTimestampString("2000-11-01"), parseMysql("11-", "%c-"));
+  EXPECT_EQ(fromTimestampString("2000-12-01"), parseMysql("-12-", "-%c-"));
 
   EXPECT_THROW(parseMysql("0", "%c"), VeloxUserError);
   EXPECT_THROW(parseMysql("13", "%c"), VeloxUserError);
@@ -1918,16 +1874,16 @@ TEST_F(MysqlDateTimeTest, parseMonth) {
   for (int i = 0; i < 12; i++) {
     std::string buildString("2000-" + std::to_string(i + 1) + "-01");
     EXPECT_EQ(
-        util::fromTimestampString(StringView{buildString}),
+        fromTimestampString(StringView{buildString}),
         parseMysql(monthsShort[i], "%b"));
     EXPECT_EQ(
-        util::fromTimestampString(StringView{buildString}),
+        fromTimestampString(StringView{buildString}),
         parseMysql(monthsFull[i], "%b"));
     EXPECT_EQ(
-        util::fromTimestampString(StringView{buildString}),
+        fromTimestampString(StringView{buildString}),
         parseMysql(monthsShort[i], "%M"));
     EXPECT_EQ(
-        util::fromTimestampString(StringView{buildString}),
+        fromTimestampString(StringView{buildString}),
         parseMysql(monthsFull[i], "%M"));
   }
 
@@ -1941,11 +1897,10 @@ TEST_F(MysqlDateTimeTest, parseMonth) {
 }
 
 TEST_F(MysqlDateTimeTest, parseDayOfMonth) {
-  EXPECT_EQ(util::fromTimestampString("2000-01-01"), parseMysql("1", "%d"));
-  EXPECT_EQ(util::fromTimestampString("2000-01-07"), parseMysql("7 ", "%d "));
-  EXPECT_EQ(util::fromTimestampString("2000-01-11"), parseMysql("/11", "/%d"));
-  EXPECT_EQ(
-      util::fromTimestampString("2000-01-31"), parseMysql("/31/", "/%d/"));
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseMysql("1", "%d"));
+  EXPECT_EQ(fromTimestampString("2000-01-07"), parseMysql("7 ", "%d "));
+  EXPECT_EQ(fromTimestampString("2000-01-11"), parseMysql("/11", "/%d"));
+  EXPECT_EQ(fromTimestampString("2000-01-31"), parseMysql("/31/", "/%d/"));
 
   EXPECT_THROW(parseMysql("0", "%d"), VeloxUserError);
   EXPECT_THROW(parseMysql("32", "%d"), VeloxUserError);
@@ -1958,75 +1913,58 @@ TEST_F(MysqlDateTimeTest, parseDayOfMonth) {
   EXPECT_THROW(parseMysql("1 31 20 2", "%m %d %d %m"), VeloxUserError);
   EXPECT_THROW(parseMysql("2 31 20 4", "%m %d %d %m"), VeloxUserError);
   EXPECT_EQ(
-      util::fromTimestampString("2000-01-31"),
-      parseMysql("2 31 1", "%m %d %m"));
+      fromTimestampString("2000-01-31"), parseMysql("2 31 1", "%m %d %m"));
 
   // Probe around leap year.
   EXPECT_EQ(
-      util::fromTimestampString("2000-02-29"),
-      parseMysql("2000-02-29", "%Y-%m-%d"));
+      fromTimestampString("2000-02-29"), parseMysql("2000-02-29", "%Y-%m-%d"));
   EXPECT_THROW(parseMysql("2001-02-29", "%Y-%m-%d"), VeloxUserError);
 }
 
 TEST_F(MysqlDateTimeTest, parseDayOfYear) {
   // Just day of year specifier should default to 2000. Also covers leap year
   // case
-  EXPECT_EQ(util::fromTimestampString("2000-01-01"), parseMysql("1", "%j"));
-  EXPECT_EQ(util::fromTimestampString("2000-01-07"), parseMysql("7 ", "%j "));
-  EXPECT_EQ(util::fromTimestampString("2000-01-11"), parseMysql("/11", "/%j"));
-  EXPECT_EQ(
-      util::fromTimestampString("2000-01-31"), parseMysql("/31/", "/%j/"));
-  EXPECT_EQ(util::fromTimestampString("2000-02-01"), parseMysql("32", "%j"));
-  EXPECT_EQ(util::fromTimestampString("2000-02-29"), parseMysql("60", "%j"));
-  EXPECT_EQ(util::fromTimestampString("2000-12-30"), parseMysql("365", "%j"));
-  EXPECT_EQ(util::fromTimestampString("2000-12-31"), parseMysql("366", "%j"));
+  EXPECT_EQ(fromTimestampString("2000-01-01"), parseMysql("1", "%j"));
+  EXPECT_EQ(fromTimestampString("2000-01-07"), parseMysql("7 ", "%j "));
+  EXPECT_EQ(fromTimestampString("2000-01-11"), parseMysql("/11", "/%j"));
+  EXPECT_EQ(fromTimestampString("2000-01-31"), parseMysql("/31/", "/%j/"));
+  EXPECT_EQ(fromTimestampString("2000-02-01"), parseMysql("32", "%j"));
+  EXPECT_EQ(fromTimestampString("2000-02-29"), parseMysql("60", "%j"));
+  EXPECT_EQ(fromTimestampString("2000-12-30"), parseMysql("365", "%j"));
+  EXPECT_EQ(fromTimestampString("2000-12-31"), parseMysql("366", "%j"));
 
   // Year specified cases
+  EXPECT_EQ(fromTimestampString("1950-01-01"), parseMysql("1950 1", "%Y %j"));
+  EXPECT_EQ(fromTimestampString("1950-01-07"), parseMysql("1950 7 ", "%Y %j "));
   EXPECT_EQ(
-      util::fromTimestampString("1950-01-01"), parseMysql("1950 1", "%Y %j"));
-  EXPECT_EQ(
-      util::fromTimestampString("1950-01-07"), parseMysql("1950 7 ", "%Y %j "));
-  EXPECT_EQ(
-      util::fromTimestampString("1950-01-11"),
-      parseMysql("1950 /11", "%Y /%j"));
-  EXPECT_EQ(
-      util::fromTimestampString("1950-01-31"),
-      parseMysql("1950 /31/", "%Y /%j/"));
+      fromTimestampString("1950-01-11"), parseMysql("1950 /11", "%Y /%j"));
   EXPECT_EQ(
-      util::fromTimestampString("1950-02-01"), parseMysql("1950 32", "%Y %j"));
-  EXPECT_EQ(
-      util::fromTimestampString("1950-03-01"), parseMysql("1950 60", "%Y %j"));
-  EXPECT_EQ(
-      util::fromTimestampString("1950-12-31"), parseMysql("1950 365", "%Y %j"));
+      fromTimestampString("1950-01-31"), parseMysql("1950 /31/", "%Y /%j/"));
+  EXPECT_EQ(fromTimestampString("1950-02-01"), parseMysql("1950 32", "%Y %j"));
+  EXPECT_EQ(fromTimestampString("1950-03-01"), parseMysql("1950 60", "%Y %j"));
+  EXPECT_EQ(fromTimestampString("1950-12-31"), parseMysql("1950 365", "%Y %j"));
   EXPECT_THROW(parseMysql("1950 366", "%Y %j"), VeloxUserError);
 
   // Negative year specified cases
+  EXPECT_EQ(fromTimestampString("-1950-01-01"), parseMysql("-1950 1", "%Y %j"));
   EXPECT_EQ(
-      util::fromTimestampString("-1950-01-01"), parseMysql("-1950 1", "%Y %j"));
-  EXPECT_EQ(
-      util::fromTimestampString("-1950-01-07"),
-      parseMysql("-1950 7 ", "%Y %j "));
+      fromTimestampString("-1950-01-07"), parseMysql("-1950 7 ", "%Y %j "));
   EXPECT_EQ(
-      util::fromTimestampString("-1950-01-11"),
-      parseMysql("-1950 /11", "%Y /%j"));
+      fromTimestampString("-1950-01-11"), parseMysql("-1950 /11", "%Y /%j"));
   EXPECT_EQ(
-      util::fromTimestampString("-1950-01-31"),
-      parseMysql("-1950 /31/", "%Y /%j/"));
+      fromTimestampString("-1950-01-31"), parseMysql("-1950 /31/", "%Y /%j/"));
   EXPECT_EQ(
-      util::fromTimestampString("-1950-02-01"),
-      parseMysql("-1950 32", "%Y %j"));
+      fromTimestampString("-1950-02-01"), parseMysql("-1950 32", "%Y %j"));
   EXPECT_EQ(
-      util::fromTimestampString("-1950-03-01"),
-      parseMysql("-1950 60", "%Y %j"));
+      fromTimestampString("-1950-03-01"), parseMysql("-1950 60", "%Y %j"));
   EXPECT_EQ(
-      util::fromTimestampString("-1950-12-31"),
-      parseMysql("-1950 365", "%Y %j"));
+      fromTimestampString("-1950-12-31"), parseMysql("-1950 365", "%Y %j"));
   EXPECT_THROW(parseMysql("-1950 366", "%Y %j"), VeloxUserError);
 
   // Ensure all days of year are checked against final selected year
   EXPECT_THROW(parseMysql("2000 366 2001", "%Y %j %Y"), VeloxUserError);
   EXPECT_EQ(
-      util::fromTimestampString("2000-12-31"),
+      fromTimestampString("2000-12-31"),
       parseMysql("2001 366 2000", "%Y %j %Y"));
 
   EXPECT_THROW(parseMysql("0", "%j"), VeloxUserError);
@@ -2034,28 +1972,20 @@ TEST_F(MysqlDateTimeTest, parseDayOfYear) {
 }
 
 TEST_F(MysqlDateTimeTest, parseHourOfDay) {
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%H"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 23:00:00"), parseMysql("23", "%H"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"), parseMysql("0", "%H"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%H"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%H"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 23:00:00"), parseMysql("23", "%H"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:00"), parseMysql("0", "%H"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%H"));
 
   // Hour of day invalid
   EXPECT_THROW(parseMysql("24", "%H"), VeloxUserError);
   EXPECT_THROW(parseMysql("-1", "%H"), VeloxUserError);
   EXPECT_THROW(parseMysql("123456789", "%H"), VeloxUserError);
 
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%k"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 23:00:00"), parseMysql("23", "%k"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"), parseMysql("0", "%k"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%k"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%k"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 23:00:00"), parseMysql("23", "%k"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:00"), parseMysql("0", "%k"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%k"));
 
   // Hour of day invalid
   EXPECT_THROW(parseMysql("24", "%k"), VeloxUserError);
@@ -2064,42 +1994,30 @@ TEST_F(MysqlDateTimeTest, parseHourOfDay) {
 }
 
 TEST_F(MysqlDateTimeTest, parseClockHourOfHalfDay) {
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%h"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"), parseMysql("12", "%h"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"), parseMysql("1", "%h"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%h"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%h"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:00"), parseMysql("12", "%h"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 01:00:00"), parseMysql("1", "%h"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%h"));
 
   // Clock hour of half day invalid
   EXPECT_THROW(parseMysql("13", "%h"), VeloxUserError);
   EXPECT_THROW(parseMysql("0", "%h"), VeloxUserError);
   EXPECT_THROW(parseMysql("123456789", "%h"), VeloxUserError);
 
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%I"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"), parseMysql("12", "%I"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"), parseMysql("1", "%I"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%I"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%I"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:00"), parseMysql("12", "%I"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 01:00:00"), parseMysql("1", "%I"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%I"));
 
   // Clock hour of half day invalid
   EXPECT_THROW(parseMysql("13", "%l"), VeloxUserError);
   EXPECT_THROW(parseMysql("0", "%l"), VeloxUserError);
   EXPECT_THROW(parseMysql("123456789", "%l"), VeloxUserError);
 
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%l"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"), parseMysql("12", "%l"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"), parseMysql("1", "%l"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%l"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 07:00:00"), parseMysql("7", "%l"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:00"), parseMysql("12", "%l"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 01:00:00"), parseMysql("1", "%l"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 10:00:00"), parseMysql("10", "%l"));
 
   // Clock hour of half day invalid
   EXPECT_THROW(parseMysql("13", "%l"), VeloxUserError);
@@ -2111,136 +2029,99 @@ TEST_F(MysqlDateTimeTest, parseHalfOfDay) {
   // Half of day has no effect if hour of day is provided
   // hour of day tests
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
-      parseMysql("7 PM", "%H %p"));
+      fromTimestampString("1970-01-01 07:00:00"), parseMysql("7 PM", "%H %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
-      parseMysql("7 AM", "%H %p"));
+      fromTimestampString("1970-01-01 07:00:00"), parseMysql("7 AM", "%H %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
-      parseMysql("7 pm", "%H %p"));
+      fromTimestampString("1970-01-01 07:00:00"), parseMysql("7 pm", "%H %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
-      parseMysql("7 am", "%H %p"));
+      fromTimestampString("1970-01-01 07:00:00"), parseMysql("7 am", "%H %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0 PM", "%H %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0 PM", "%H %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0 AM", "%H %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0 AM", "%H %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0 pm", "%H %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0 pm", "%H %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0 am", "%H %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0 am", "%H %p"));
 
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
-      parseMysql("7 PM", "%k %p"));
+      fromTimestampString("1970-01-01 07:00:00"), parseMysql("7 PM", "%k %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
-      parseMysql("7 AM", "%k %p"));
+      fromTimestampString("1970-01-01 07:00:00"), parseMysql("7 AM", "%k %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
-      parseMysql("7 pm", "%k %p"));
+      fromTimestampString("1970-01-01 07:00:00"), parseMysql("7 pm", "%k %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 07:00:00"),
-      parseMysql("7 am", "%k %p"));
+      fromTimestampString("1970-01-01 07:00:00"), parseMysql("7 am", "%k %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0 PM", "%k %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0 PM", "%k %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0 AM", "%k %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0 AM", "%k %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0 pm", "%k %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0 pm", "%k %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0 am", "%k %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0 am", "%k %p"));
 
   // Half of day has effect if clockhour of halfday is provided
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 13:00:00"),
-      parseMysql("1 PM", "%h %p"));
+      fromTimestampString("1970-01-01 13:00:00"), parseMysql("1 PM", "%h %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"),
-      parseMysql("1 AM", "%h %p"));
+      fromTimestampString("1970-01-01 01:00:00"), parseMysql("1 AM", "%h %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 18:00:00"),
-      parseMysql("6 PM", "%h %p"));
+      fromTimestampString("1970-01-01 18:00:00"), parseMysql("6 PM", "%h %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 06:00:00"),
-      parseMysql("6 AM", "%h %p"));
+      fromTimestampString("1970-01-01 06:00:00"), parseMysql("6 AM", "%h %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 12:00:00"),
-      parseMysql("12 PM", "%h %p"));
+      fromTimestampString("1970-01-01 12:00:00"), parseMysql("12 PM", "%h %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("12 AM", "%h %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("12 AM", "%h %p"));
 
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 13:00:00"),
-      parseMysql("1 PM", "%I %p"));
+      fromTimestampString("1970-01-01 13:00:00"), parseMysql("1 PM", "%I %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"),
-      parseMysql("1 AM", "%I %p"));
+      fromTimestampString("1970-01-01 01:00:00"), parseMysql("1 AM", "%I %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 18:00:00"),
-      parseMysql("6 PM", "%I %p"));
+      fromTimestampString("1970-01-01 18:00:00"), parseMysql("6 PM", "%I %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 06:00:00"),
-      parseMysql("6 AM", "%I %p"));
+      fromTimestampString("1970-01-01 06:00:00"), parseMysql("6 AM", "%I %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 12:00:00"),
-      parseMysql("12 PM", "%I %p"));
+      fromTimestampString("1970-01-01 12:00:00"), parseMysql("12 PM", "%I %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("12 AM", "%I %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("12 AM", "%I %p"));
 
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 13:00:00"),
-      parseMysql("1 PM", "%l %p"));
+      fromTimestampString("1970-01-01 13:00:00"), parseMysql("1 PM", "%l %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"),
-      parseMysql("1 AM", "%l %p"));
+      fromTimestampString("1970-01-01 01:00:00"), parseMysql("1 AM", "%l %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 18:00:00"),
-      parseMysql("6 PM", "%l %p"));
+      fromTimestampString("1970-01-01 18:00:00"), parseMysql("6 PM", "%l %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 06:00:00"),
-      parseMysql("6 AM", "%l %p"));
+      fromTimestampString("1970-01-01 06:00:00"), parseMysql("6 AM", "%l %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 12:00:00"),
-      parseMysql("12 PM", "%l %p"));
+      fromTimestampString("1970-01-01 12:00:00"), parseMysql("12 PM", "%l %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("12 AM", "%l %p"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("12 AM", "%l %p"));
 
   // time gives precendent to most recent time specifier
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 01:00:00"),
+      fromTimestampString("1970-01-01 01:00:00"),
       parseMysql("0 1 AM", "%H %h %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 13:00:00"),
+      fromTimestampString("1970-01-01 13:00:00"),
       parseMysql("12 1 PM", "%H %h %p"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
+      fromTimestampString("1970-01-01 00:00:00"),
       parseMysql("1 AM 0", "%h %p %H"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 12:00:00"),
+      fromTimestampString("1970-01-01 12:00:00"),
       parseMysql("1 AM 12", "%h %p %H"));
 }
 
 TEST_F(MysqlDateTimeTest, parseMinute) {
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:08:00"), parseMysql("8", "%i"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:59:00"), parseMysql("59", "%i"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:08:00"), parseMysql("8", "%i"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:59:00"), parseMysql("59", "%i"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0/", "%i/"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0/", "%i/"));
 
   EXPECT_THROW(parseMysql("60", "%i"), VeloxUserError);
   EXPECT_THROW(parseMysql("-1", "%i"), VeloxUserError);
@@ -2248,25 +2129,19 @@ TEST_F(MysqlDateTimeTest, parseMinute) {
 }
 
 TEST_F(MysqlDateTimeTest, parseSecond) {
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:09"), parseMysql("9", "%s"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:58"), parseMysql("58", "%s"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:09"), parseMysql("9", "%s"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:58"), parseMysql("58", "%s"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0/", "%s/"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0/", "%s/"));
 
   EXPECT_THROW(parseMysql("60", "%s"), VeloxUserError);
   EXPECT_THROW(parseMysql("-1", "%s"), VeloxUserError);
   EXPECT_THROW(parseMysql("123456789", "%s"), VeloxUserError);
 
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:09"), parseMysql("9", "%S"));
+  EXPECT_EQ(fromTimestampString("1970-01-01 00:00:58"), parseMysql("58", "%S"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:09"), parseMysql("9", "%S"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:58"), parseMysql("58", "%S"));
-  EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00"),
-      parseMysql("0/", "%S/"));
+      fromTimestampString("1970-01-01 00:00:00"), parseMysql("0/", "%S/"));
 
   EXPECT_THROW(parseMysql("60", "%S"), VeloxUserError);
   EXPECT_THROW(parseMysql("-1", "%S"), VeloxUserError);
@@ -2276,105 +2151,105 @@ TEST_F(MysqlDateTimeTest, parseSecond) {
 TEST_F(MysqlDateTimeTest, parseMixedYMDFormat) {
   // Common patterns found.
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 23:00:00"),
+      fromTimestampString("2021-01-04 23:00:00"),
       parseMysql("2021-01-04+23:00:00", "%Y-%m-%d+%H:%i:%s"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2019-07-03 11:04:10"),
+      fromTimestampString("2019-07-03 11:04:10"),
       parseMysql("2019-07-03 11:04:10", "%Y-%m-%d %H:%i:%s"));
 
   // Backwards, just for fun:
   EXPECT_EQ(
-      util::fromTimestampString("2019-07-03 11:04:10"),
+      fromTimestampString("2019-07-03 11:04:10"),
       parseMysql("10:04:11 03-07-2019", "%s:%i:%H %d-%m-%Y"));
 }
 
 TEST_F(MysqlDateTimeTest, parseMixedWeekFormat) {
   // Common patterns found.
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseMysql("2021 1 13:29:21.213", "%x %v %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseMysql("2021 22 13:29:21.213", "%x %v %H:%i:%s.%f"));
 
   // Day of week short text normal capitlization
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseMysql("2021 1 Mon 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseMysql("2021 22 Mon 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseMysql("2021 22 Thu 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   // Day of week long text normal capitlization
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseMysql("2021 1 Monday 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseMysql("2021 22 Monday 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseMysql("2021 22 Thursday 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   // Day of week short text upper case
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseMysql("2021 1 MON 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseMysql("2021 22 MON 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseMysql("2021 22 THU 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   // Day of week long text upper case
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseMysql("2021 1 MONDAY 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseMysql("2021 22 MONDAY 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseMysql("2021 22 THURSDAY 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   // Day of week short text lower case
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseMysql("2021 1 mon 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseMysql("2021 22 mon 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseMysql("2021 22 thu 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   // Day of week long text lower case
   EXPECT_EQ(
-      util::fromTimestampString("2021-01-04 13:29:21.213"),
+      fromTimestampString("2021-01-04 13:29:21.213"),
       parseMysql("2021 1 monday 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseMysql("2021 22 monday 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("2021-06-03 13:29:21.213"),
+      fromTimestampString("2021-06-03 13:29:21.213"),
       parseMysql("2021 22 thursday 13:29:21.213", "%x %v %W %H:%i:%s.%f"));
 
   // Invalid day of week throw cases
@@ -2388,53 +2263,43 @@ TEST_F(MysqlDateTimeTest, parseMixedWeekFormat) {
 
   // Backwards, just for fun:
   EXPECT_EQ(
-      util::fromTimestampString("2021-05-31 13:29:21.213"),
+      fromTimestampString("2021-05-31 13:29:21.213"),
       parseMysql("213.21:29:13 22 2021", "%f.%s:%i:%H %v %x"));
 }
 
 TEST_F(MysqlDateTimeTest, parseFractionOfSecond) {
   // Assert on difference in milliseconds.
   EXPECT_NE(
-      util::fromTimestampString("2022-02-23 12:15:00.223"),
+      fromTimestampString("2022-02-23 12:15:00.223"),
       parseMysql("2022-02-23T12:15:00.776", "%Y-%m-%dT%H:%i:%s.%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.000"),
-      parseMysql("000", "%f"));
+      fromTimestampString("1970-01-01 00:00:00.000"), parseMysql("000", "%f"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.001"),
-      parseMysql("001", "%f"));
+      fromTimestampString("1970-01-01 00:00:00.001"), parseMysql("001", "%f"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.999"),
-      parseMysql("999", "%f"));
+      fromTimestampString("1970-01-01 00:00:00.999"), parseMysql("999", "%f"));
 
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.045"),
-      parseMysql("045", "%f"));
+      fromTimestampString("1970-01-01 00:00:00.045"), parseMysql("045", "%f"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.450"),
-      parseMysql("45", "%f"));
+      fromTimestampString("1970-01-01 00:00:00.450"), parseMysql("45", "%f"));
   EXPECT_EQ(
-      util::fromTimestampString("1970-01-01 00:00:00.450"),
-      parseMysql("45", "%f"));
+      fromTimestampString("1970-01-01 00:00:00.450"), parseMysql("45", "%f"));
 
   EXPECT_THROW(parseMysql("-1", "%f"), VeloxUserError);
   EXPECT_THROW(parseMysql("9999999", "%f"), VeloxUserError);
 }
 
 TEST_F(MysqlDateTimeTest, parseConsecutiveSpecifiers) {
-  EXPECT_EQ(
-      util::fromTimestampString("2012-12-01"), parseMysql("1212", "%y%m"));
-  EXPECT_EQ(
-      util::fromTimestampString("0012-12-01"), parseMysql("1212", "%m%Y"));
+  EXPECT_EQ(fromTimestampString("2012-12-01"), parseMysql("1212", "%y%m"));
+  EXPECT_EQ(fromTimestampString("0012-12-01"), parseMysql("1212", "%m%Y"));
   EXPECT_THROW(parseMysql("1212", "%Y%m"), VeloxUserError);
 
   EXPECT_EQ(
-      util::fromTimestampString("2012-01-01 12:00:00"),
-      parseMysql("1212", "%y%H"));
+      fromTimestampString("2012-01-01 12:00:00"), parseMysql("1212", "%y%H"));
   EXPECT_EQ(
-      util::fromTimestampString("0012-01-01 12:00:00"),
-      parseMysql("1212", "%H%Y"));
+      fromTimestampString("0012-01-01 12:00:00"), parseMysql("1212", "%H%Y"));
   EXPECT_THROW(parseMysql("1212", "%Y%H"), VeloxUserError);
 }
 
diff --git a/velox/functions/lib/tests/IsNotNullTest.cpp b/velox/functions/lib/tests/IsNotNullTest.cpp
index 84f8c0154d2a7..55b8187ccce6d 100644
--- a/velox/functions/lib/tests/IsNotNullTest.cpp
+++ b/velox/functions/lib/tests/IsNotNullTest.cpp
@@ -26,7 +26,7 @@ void registerIsNotNull() {
   registerIsNotNullFunction("isnotnull");
 }
 
-}; // namespace facebook::velox::functions
+} // namespace facebook::velox::functions
 
 using namespace facebook::velox;
 using namespace facebook::velox::test;
@@ -35,6 +35,7 @@ class IsNotNullTest : public functions::test::FunctionBaseTest {
  public:
   static void SetUpTestCase() {
     functions::registerIsNotNull();
+    memory::MemoryManager::testingSetInstance({});
   }
 
   template <typename T>
diff --git a/velox/functions/lib/tests/KllSketchTest.cpp b/velox/functions/lib/tests/KllSketchTest.cpp
index 29212049e541c..8023ccc53a4ac 100644
--- a/velox/functions/lib/tests/KllSketchTest.cpp
+++ b/velox/functions/lib/tests/KllSketchTest.cpp
@@ -55,7 +55,14 @@ void insertRandomData(int seed, int n, KllSketch<double>& kll, double* values) {
   }
 }
 
-TEST(KllSketchTest, oneItem) {
+class KllSketchTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(KllSketchTest, oneItem) {
   KllSketch<double> kll;
   EXPECT_EQ(kll.totalCount(), 0);
   kll.insert(1.0);
@@ -66,7 +73,7 @@ TEST(KllSketchTest, oneItem) {
   EXPECT_EQ(kll.estimateQuantile(1.0), 1.0);
 }
 
-TEST(KllSketchTest, exactMode) {
+TEST_F(KllSketchTest, exactMode) {
   constexpr int N = 128;
   KllSketch<int> kll(N);
   for (int i = 0; i < N; ++i) {
@@ -84,7 +91,7 @@ TEST(KllSketchTest, exactMode) {
   }
 }
 
-TEST(KllSketchTest, estimationMode) {
+TEST_F(KllSketchTest, estimationMode) {
   constexpr int N = 1e5;
   constexpr int M = 1001;
   KllSketch<double> kll(200, {}, 0);
@@ -103,7 +110,7 @@ TEST(KllSketchTest, estimationMode) {
   }
 }
 
-TEST(KllSketchTest, randomInput) {
+TEST_F(KllSketchTest, randomInput) {
   constexpr int N = 1e5;
   constexpr int M = 1001;
   KllSketch<double> kll(kDefaultK, {}, 0);
@@ -122,7 +129,7 @@ TEST(KllSketchTest, randomInput) {
   }
 }
 
-TEST(KllSketchTest, merge) {
+TEST_F(KllSketchTest, merge) {
   constexpr int N = 1e4;
   constexpr int M = 1001;
   KllSketch<double> kll1(kDefaultK, {}, 0);
@@ -142,7 +149,7 @@ TEST(KllSketchTest, merge) {
   }
 }
 
-TEST(KllSketchTest, mergeRandom) {
+TEST_F(KllSketchTest, mergeRandom) {
   constexpr int N = 1e4;
   constexpr int M = 1001;
   std::default_random_engine gen(0);
@@ -177,7 +184,7 @@ TEST(KllSketchTest, mergeRandom) {
   }
 }
 
-TEST(KllSketchTest, mergeMultiple) {
+TEST_F(KllSketchTest, mergeMultiple) {
   constexpr int N = 1e4;
   constexpr int M = 1001;
   constexpr int kSketchCount = 10;
@@ -201,7 +208,7 @@ TEST(KllSketchTest, mergeMultiple) {
   }
 }
 
-TEST(KllSketchTest, mergeEmpty) {
+TEST_F(KllSketchTest, mergeEmpty) {
   KllSketch<double> kll, kll2;
   kll.insert(1.0);
   kll.merge(kll2);
@@ -214,11 +221,11 @@ TEST(KllSketchTest, mergeEmpty) {
   EXPECT_EQ(kll2.estimateQuantile(0.5), 1.0);
 }
 
-TEST(KllSketchTest, kFromEpsilon) {
+TEST_F(KllSketchTest, kFromEpsilon) {
   EXPECT_EQ(kFromEpsilon(kEpsilon), kDefaultK);
 }
 
-TEST(KllSketchTest, serialize) {
+TEST_F(KllSketchTest, serialize) {
   constexpr int N = 1e5;
   constexpr int M = 1001;
   KllSketch<double> kll(kDefaultK, {}, 0);
@@ -241,7 +248,7 @@ TEST(KllSketchTest, serialize) {
   EXPECT_EQ(v, v2);
 }
 
-TEST(KllSketchTest, deserialize) {
+TEST_F(KllSketchTest, deserialize) {
   constexpr int N = 1e5;
   constexpr int M = 1001;
   auto readFile = [](const std::string& path) {
@@ -266,7 +273,7 @@ TEST(KllSketchTest, deserialize) {
   }
 }
 
-TEST(KllSketchTest, deserializeSmall) {
+TEST_F(KllSketchTest, deserializeSmall) {
   constexpr int N = 128;
   KllSketch<double> kll(kDefaultK, {}, 0);
   insertRandomData(0, N, kll, nullptr);
@@ -280,7 +287,7 @@ TEST(KllSketchTest, deserializeSmall) {
   EXPECT_EQ(v, v2);
 }
 
-TEST(KllSketchTest, compact) {
+TEST_F(KllSketchTest, compact) {
   constexpr int N = 1e5;
   KllSketch<double> kll(kFromEpsilon(0.001));
   for (int i = 0; i < N; ++i) {
@@ -299,7 +306,7 @@ TEST(KllSketchTest, compact) {
   }
 }
 
-TEST(KllSketchTest, growCompacted) {
+TEST_F(KllSketchTest, growCompacted) {
   constexpr int N = 1000;
   constexpr int M = 101;
   KllSketch<double> kll(kDefaultK, {}, 0);
@@ -317,7 +324,7 @@ TEST(KllSketchTest, growCompacted) {
   }
 }
 
-TEST(KllSketchTest, fromRepeatedValue) {
+TEST_F(KllSketchTest, fromRepeatedValue) {
   constexpr int N = 1000;
   constexpr int kTotal = (1 + N) * N / 2;
   constexpr int M = 1001;
@@ -346,7 +353,7 @@ TEST(KllSketchTest, fromRepeatedValue) {
   }
 }
 
-TEST(KllSketchTest, mergeDeserialized) {
+TEST_F(KllSketchTest, mergeDeserialized) {
   constexpr int N = 1e4;
   constexpr int M = 1001;
   KllSketch<double> kll1(kDefaultK, {}, 0);
@@ -372,8 +379,8 @@ TEST(KllSketchTest, mergeDeserialized) {
 // 1. When N < K, the memory usage should be O(N).
 // 2. Otherwise it's \f$ K \sum_i \(\frac{2}{3}\)^i \f$ and it converges to
 //    about O(3K).
-TEST(KllSketchTest, memoryUsage) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+TEST_F(KllSketchTest, memoryUsage) {
+  auto pool = memory::memoryManager()->addLeafPool();
   HashStringAllocator alloc(pool.get());
   KllSketch<int64_t, StlAllocator<int64_t>> kll(
       1024, StlAllocator<int64_t>(&alloc));
diff --git a/velox/functions/lib/tests/LambdaFunctionUtilTest.cpp b/velox/functions/lib/tests/LambdaFunctionUtilTest.cpp
new file mode 100644
index 0000000000000..b5739940b0ec3
--- /dev/null
+++ b/velox/functions/lib/tests/LambdaFunctionUtilTest.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/LambdaFunctionUtil.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+class LambdaFunctionUtilTest : public testing::Test,
+                               public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
+
+TEST_F(LambdaFunctionUtilTest, addNullsForUnselectedRows) {
+  auto vector = makeFlatVector<int64_t>({1, 2, 3, 4, 5});
+
+  SelectivityVector rows(3);
+  auto nulls = addNullsForUnselectedRows(vector, rows);
+
+  auto* rawNulls = nulls->as<uint64_t>();
+
+  EXPECT_FALSE(bits::isBitNull(rawNulls, 0));
+  EXPECT_FALSE(bits::isBitNull(rawNulls, 1));
+  EXPECT_FALSE(bits::isBitNull(rawNulls, 2));
+  EXPECT_TRUE(bits::isBitNull(rawNulls, 3));
+  EXPECT_TRUE(bits::isBitNull(rawNulls, 4));
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/tests/MapConcatTest.cpp b/velox/functions/lib/tests/MapConcatTest.cpp
index 9a46d90b5c946..c269391e1252c 100644
--- a/velox/functions/lib/tests/MapConcatTest.cpp
+++ b/velox/functions/lib/tests/MapConcatTest.cpp
@@ -283,3 +283,14 @@ TEST_F(MapConcatTest, nullEntry) {
   ASSERT_EQ(result->size(), 1);
   EXPECT_EQ(result->sizeAt(0), 0);
 }
+
+TEST_F(MapConcatTest, unknownType) {
+  // MAP_CONCAT(MAP[], MAP[])
+  auto emptyMapVector =
+      VectorTestBase::makeMapVector<UnknownValue, UnknownValue>({{}});
+  auto expectedMap =
+      VectorTestBase::makeMapVector<UnknownValue, UnknownValue>({{}});
+  auto result = evaluate(
+      "map_concat(c0, c1)", makeRowVector({emptyMapVector, emptyMapVector}));
+  facebook::velox::test::assertEqualVectors(expectedMap, result);
+}
diff --git a/velox/functions/lib/tests/Re2FunctionsTest.cpp b/velox/functions/lib/tests/Re2FunctionsTest.cpp
index b27343a46dc04..94d02b27b7157 100644
--- a/velox/functions/lib/tests/Re2FunctionsTest.cpp
+++ b/velox/functions/lib/tests/Re2FunctionsTest.cpp
@@ -101,6 +101,8 @@ class Re2FunctionsTest : public test::FunctionBaseTest {
       std::optional<bool> expected,
       const std::string& errorMessage = "") {
     {
+      SCOPED_TRACE(fmt::format("Input: '{}', pattern: '{}'", input, pattern));
+
       // Test literal path.
       auto eval = [&]() {
         return evaluateOnce<bool>(
@@ -462,40 +464,155 @@ TEST_F(Re2FunctionsTest, likePattern) {
 
 TEST_F(Re2FunctionsTest, likeDeterminePatternKind) {
   auto testPattern =
-      [&](StringView pattern, PatternKind patternKind, vector_size_t length) {
-        EXPECT_EQ(
-            determinePatternKind(pattern), std::make_pair(patternKind, length));
+      [&](std::string_view pattern, PatternKind patternKind, size_t length) {
+        PatternMetadata patternMetadata =
+            determinePatternKind(pattern, std::nullopt);
+
+        SCOPED_TRACE(fmt::format(
+            "pattern: '{}', length: {}, actualLength: {}",
+            pattern,
+            length,
+            patternMetadata.length()));
+        EXPECT_EQ(patternMetadata.patternKind(), patternKind);
+        EXPECT_EQ(patternMetadata.length(), length);
       };
 
+  auto testPatternString = [&](std::string_view pattern,
+                               PatternKind patternKind,
+                               std::string_view fixedPattern) {
+    SCOPED_TRACE(fmt::format(
+        "pattern: '{}', fixedPattern: '{}'", pattern, fixedPattern));
+
+    PatternMetadata patternMetadata =
+        determinePatternKind(pattern, std::nullopt);
+    EXPECT_EQ(patternMetadata.patternKind(), patternKind);
+    EXPECT_EQ(patternMetadata.length(), fixedPattern.size());
+    EXPECT_EQ(patternMetadata.fixedPattern(), fixedPattern);
+  };
+
+  testPattern("", PatternKind::kFixed, 0);
   testPattern("_", PatternKind::kExactlyN, 1);
   testPattern("____", PatternKind::kExactlyN, 4);
   testPattern("%", PatternKind::kAtLeastN, 0);
+  testPattern("%%%", PatternKind::kAtLeastN, 0);
   testPattern("__%%__", PatternKind::kAtLeastN, 4);
   testPattern("%_%%", PatternKind::kAtLeastN, 1);
-  testPattern("_b%%__", PatternKind::kGeneric, 0);
-  testPattern("%_%p", PatternKind::kGeneric, 0);
-
-  testPattern("presto", PatternKind::kFixed, 6);
-  testPattern("hello", PatternKind::kFixed, 5);
-  testPattern("a", PatternKind::kFixed, 1);
-  testPattern("helloPrestoWorld", PatternKind::kFixed, 16);
-  testPattern("aBcD_", PatternKind::kGeneric, 0);
-  testPattern("%aBc_D%", PatternKind::kGeneric, 0);
+  testPattern("%%%%%%%%%%%%", PatternKind::kAtLeastN, 0);
+
+  testPatternString("presto", PatternKind::kFixed, "presto");
+  testPatternString("hello", PatternKind::kFixed, "hello");
+  testPatternString("a", PatternKind::kFixed, "a");
+  testPatternString(
+      "helloPrestoWorld", PatternKind::kFixed, "helloPrestoWorld");
+  testPatternString("aBcD", PatternKind::kFixed, "aBcD");
+
+  testPatternString("_pr_es_to_", PatternKind::kRelaxedFixed, "_pr_es_to_");
+  testPatternString("_presto", PatternKind::kRelaxedFixed, "_presto");
+  testPatternString("presto_", PatternKind::kRelaxedFixed, "presto_");
+  testPatternString("_a", PatternKind::kRelaxedFixed, "_a");
+  testPatternString("a_", PatternKind::kRelaxedFixed, "a_");
+  testPatternString("_a_", PatternKind::kRelaxedFixed, "_a_");
 
   testPattern("presto%", PatternKind::kPrefix, 6);
   testPattern("hello%%", PatternKind::kPrefix, 5);
   testPattern("a%", PatternKind::kPrefix, 1);
   testPattern("helloPrestoWorld%%%", PatternKind::kPrefix, 16);
-  testPattern("aBcD%%e%", PatternKind::kGeneric, 0);
-  testPattern("aBc_D%%", PatternKind::kGeneric, 0);
+  testPattern("aBcD%", PatternKind::kPrefix, 4);
+
+  testPatternString("_pr_es_to_%", PatternKind::kRelaxedPrefix, "_pr_es_to_");
+  testPatternString("_presto%", PatternKind::kRelaxedPrefix, "_presto");
+  testPatternString("presto_%%", PatternKind::kRelaxedPrefix, "presto_");
+  testPatternString("_a%", PatternKind::kRelaxedPrefix, "_a");
+  testPatternString("a_%%", PatternKind::kRelaxedPrefix, "a_");
+  testPatternString("_a_%", PatternKind::kRelaxedPrefix, "_a_");
 
   testPattern("%presto", PatternKind::kSuffix, 6);
   testPattern("%%hello", PatternKind::kSuffix, 5);
   testPattern("%a", PatternKind::kSuffix, 1);
   testPattern("%%%helloPrestoWorld", PatternKind::kSuffix, 16);
+  testPattern("%aBcD", PatternKind::kSuffix, 4);
+
+  testPatternString("%_pr_es_to_", PatternKind::kRelaxedSuffix, "_pr_es_to_");
+  testPatternString("%_presto", PatternKind::kRelaxedSuffix, "_presto");
+  testPatternString("%%presto_", PatternKind::kRelaxedSuffix, "presto_");
+  testPatternString("%_a", PatternKind::kRelaxedSuffix, "_a");
+  testPatternString("%%a_", PatternKind::kRelaxedSuffix, "a_");
+  testPatternString("%_a_", PatternKind::kRelaxedSuffix, "_a_");
+
+  testPatternString("%presto%%", PatternKind::kSubstring, "presto");
+  testPatternString("%%hello%", PatternKind::kSubstring, "hello");
+  testPatternString("%%%aAb\n%", PatternKind::kSubstring, "aAb\n");
+  testPatternString(
+      "%helloPrestoWorld%%%", PatternKind::kSubstring, "helloPrestoWorld");
+
+  testPattern("_b%%__", PatternKind::kGeneric, 0);
+  testPattern("%_%p", PatternKind::kGeneric, 0);
+  testPattern("aBcD%%e%", PatternKind::kGeneric, 0);
   testPattern("%%_%aBcD", PatternKind::kGeneric, 0);
   testPattern("%%a%%BcD", PatternKind::kGeneric, 0);
+  testPattern("%%aBcD%_%", PatternKind::kGeneric, 0);
+  testPattern("aBcD%_%", PatternKind::kGeneric, 0);
   testPattern("foo%bar", PatternKind::kGeneric, 0);
+
+  // Test for pattern with unicode.
+  testPattern("_b%%__", PatternKind::kGeneric, 0);
+}
+
+TEST_F(Re2FunctionsTest, likeDeterminePatternKindUnicode) {
+  auto testPattern = [&](std::string_view pattern,
+                         PatternKind patternKind,
+                         std::string_view fixedPattern) {
+    PatternMetadata patternMetadata = determinePatternKind(pattern, '\\');
+    EXPECT_EQ(patternMetadata.patternKind(), patternKind);
+    EXPECT_EQ(patternMetadata.length(), fixedPattern.size());
+    EXPECT_EQ(patternMetadata.fixedPattern(), fixedPattern);
+  };
+
+  // '你好' is 'hello' in Chinese, '世界' is 'world' in Chinese.
+  testPattern("你好%", PatternKind::kPrefix, "你好");
+  testPattern("a你好%", PatternKind::kPrefix, "a你好");
+  testPattern("你好a%", PatternKind::kPrefix, "你好a");
+  testPattern("%%你好", PatternKind::kSuffix, "你好");
+  testPattern("%%你好%", PatternKind::kSubstring, "你好");
+  testPattern("%%你好%世界", PatternKind::kGeneric, "");
+}
+
+TEST_F(Re2FunctionsTest, likeDeterminePatternKindWithEscapeChar) {
+  auto testPattern = [&](std::string_view pattern,
+                         PatternKind patternKind,
+                         std::string_view fixedPattern) {
+    PatternMetadata patternMetadata = determinePatternKind(pattern, '\\');
+    EXPECT_EQ(patternMetadata.patternKind(), patternKind);
+    EXPECT_EQ(patternMetadata.length(), fixedPattern.size());
+    EXPECT_EQ(patternMetadata.fixedPattern(), fixedPattern);
+  };
+
+  testPattern(R"(\_)", PatternKind::kFixed, "_");
+  testPattern(R"(\_\_\_\_)", PatternKind::kFixed, "____");
+  testPattern(R"(a\_\_b\_\_c)", PatternKind::kFixed, "a__b__c");
+
+  testPattern(R"(_a\_\_b_\_\_c_)", PatternKind::kRelaxedFixed, "_a__b___c_");
+
+  testPattern(R"(\%)", PatternKind::kFixed, "%");
+  testPattern(R"(\%\%\%)", PatternKind::kFixed, "%%%");
+  testPattern(R"(a\%b\%c\%d)", PatternKind::kFixed, "a%b%c%d");
+
+  testPattern(R"(_a\%b\%c_\%d_)", PatternKind::kRelaxedFixed, "_a%b%c_%d_");
+
+  testPattern(R"(\_\_%%)", PatternKind::kPrefix, "__");
+  testPattern(R"(a\_b\_c%%)", PatternKind::kPrefix, "a_b_c");
+
+  testPattern(R"(_a\__b\_c%%)", PatternKind::kRelaxedPrefix, "_a__b_c");
+
+  testPattern(R"(%%\_\_)", PatternKind::kSuffix, "__");
+  testPattern(R"(%%a\_b\_c)", PatternKind::kSuffix, "a_b_c");
+  testPattern(R"(%\_\%)", PatternKind::kSuffix, "_%");
+
+  testPattern(R"(%%a\_b_\_c_)", PatternKind::kRelaxedSuffix, "a_b__c_");
+
+  testPattern(R"(%\_%%)", PatternKind::kSubstring, "_");
+  testPattern(R"(%\_\%%%)", PatternKind::kSubstring, "_%");
+  testPattern(R"(%\_ab\%%%)", PatternKind::kSubstring, "_ab%");
 }
 
 TEST_F(Re2FunctionsTest, likePatternWildcard) {
@@ -534,6 +651,18 @@ TEST_F(Re2FunctionsTest, likePatternWildcard) {
   testLike("\nabcde\n", "%bcf%", false);
 }
 
+TEST_F(Re2FunctionsTest, likePatternEscapingEscapeChar) {
+  testLike(R"(\)", R"(\\)", '\\', true);
+  testLike(R"(\abc)", R"(\\%)", '\\', true);
+  testLike(R"(\abc)", R"(\\abc)", '\\', true);
+  testLike(R"(abc\abc)", R"(abc\\abc)", '\\', true);
+  testLike(R"(\abcdef)", R"(\\abc%)", '\\', true);
+  testLike(R"(\abcdefghijkl)", R"(\\abc%gh%)", '\\', true);
+  testLike(R"(abc\abc)", R"(%\\%)", '\\', true);
+  testLike(R"(abcdef\abcdef)", R"(%\\abc%)", '\\', true);
+  testLike(R"(abcdef\\\abcdef)", R"(%\\\\\\abc%)", '\\', true);
+}
+
 TEST_F(Re2FunctionsTest, likePatternFixed) {
   testLike("", "", true);
   testLike("abcde", "abcde", true);
@@ -556,10 +685,47 @@ TEST_F(Re2FunctionsTest, likePatternFixed) {
   testLike("\nabcd\n", "\nabc\nd\n", false);
   testLike("\nab\tcd\b", "\nabcd\b", false);
 
+  // Test literal '_' & '%' in pattern.
+  testLike("a", R"(\_)", '\\', false);
+  testLike("_b", R"(\_b)", '\\', true);
+  testLike("abc_d", R"(abc\_d)", '\\', true);
+
+  testLike("a", R"(\%)", '\\', false);
+  testLike("abc%d", R"(abc\%d)", '\\', true);
+  testLike("abc%d", R"(a\%d)", '\\', false);
+
   std::string input = generateString(kLikePatternCharacterSet, 66);
   testLike(input, input, true);
 }
 
+TEST_F(Re2FunctionsTest, likePatternRelaxedFixed) {
+  testLike("_ab_cde_", "_ab_cde_", true);
+  testLike("xabxcdex", "_ab_cde_", true);
+  testLike("xacxcdex", "_ab_cde_", false);
+
+  testLike("ABCDEx", "ABCDE_", true);
+  testLike("ABCDEy", "ABCDE_", true);
+  testLike("ABCDCy", "ABCDE_", false);
+  testLike("abcdey", "ABCDE_", false);
+
+  testLike("ABCDE_FGH", "ABCDE_", false);
+  testLike("ABCDE", "ABCDE_", false);
+  testLike("ABCDE_", "ABCDE_", true);
+
+  testLike("你好_世界", "你好_", false);
+  testLike("你好", "你好_", false);
+  testLike("你好_", "你好_", true);
+
+  // Test literal '_' & '%' in pattern.
+  testLike("_x", R"(\__)", '\\', true);
+  testLike("xx", R"(\__)", '\\', false);
+  testLike("abc_dx", R"(abc\_d_)", '\\', true);
+
+  testLike("aa", R"(\%_)", '\\', false);
+  testLike("%a", R"(\%_)", '\\', true);
+  testLike("xabc%d", R"(_abc\%d)", '\\', true);
+}
+
 TEST_F(Re2FunctionsTest, likePatternPrefix) {
   testLike("", "%", true);
   testLike("", "%%", true);
@@ -588,10 +754,48 @@ TEST_F(Re2FunctionsTest, likePatternPrefix) {
   testLike("\nabc\nde\n", "ab\nc%", false);
   testLike("\nabc\nde\n", "abc%", false);
 
+  // Test literal '_' & '%' in pattern.
+  testLike("_", R"(\_%)", '\\', true);
+  testLike("_bcd", R"(\_b%)", '\\', true);
+  testLike("abc_defg", R"(abc\_d%)", '\\', true);
+
+  testLike("%ab", R"(\%%)", '\\', true);
+  testLike("abc%defg", R"(abc\%d%)", '\\', true);
+  testLike("abc%defg", R"(a\%d%)", '\\', false);
+
   std::string input = generateString(kLikePatternCharacterSet, 66);
   testLike(input, input + generateString(kAnyWildcardCharacter), true);
 }
 
+TEST_F(Re2FunctionsTest, likePatternRelaxedPrefix) {
+  testLike("abcdef", "abcd_%", true);
+  testLike("abcdef", "abcd_%%%", true);
+  testLike("abcdef", "_b_d_%", true);
+  testLike("abcdef", "bb_d_%", false);
+
+  testLike("ABCDE", "ABC_%", true);
+  testLike("ABCDE", "A_C_%", true);
+  testLike("ABCDE", "__C_%", true);
+  testLike("ABCDE", "BBC_%", false);
+  testLike("abcde", "__C_%", false);
+
+  testLike("ABCDE_FGH", "ABCDE_%", true);
+  testLike("ABCDE", "ABCDE_%", false);
+  testLike("ABCDE_", "ABCDE_%", true);
+
+  testLike("你好_世界", "你好_%", true);
+  testLike("你好", "你好_%", false);
+  testLike("你好_", "你好_%", true);
+
+  // Test literal '_' & '%' in pattern.
+  testLike("a_b", R"(_\_%)", '\\', true);
+  testLike("b_b", R"(_\_%)", '\\', true);
+  testLike("bbb", R"(_\_%)", '\\', false);
+
+  testLike("%ab", R"(\%_b%)", '\\', true);
+  testLike("a_c%defg", R"(a_c\%d%)", '\\', true);
+}
+
 TEST_F(Re2FunctionsTest, likePatternSuffix) {
   testLike("", "%", true);
   testLike("abcde", "%bcde", true);
@@ -620,10 +824,100 @@ TEST_F(Re2FunctionsTest, likePatternSuffix) {
   testLike("\nabcde\n", "%d\n", false);
   testLike("\nabcde\n", "%e_\n", false);
 
+  // Test literal '_' & '%' in pattern.
+  testLike("_", R"(%\_)", '\\', true);
+  testLike("cd_b", R"(%\_b)", '\\', true);
+  testLike("efgabc_d", R"(%abc\_d)", '\\', true);
+
+  testLike("ab%", R"(%\%)", '\\', true);
+  testLike("efgabc%d", R"(%abc\%d)", '\\', true);
+  testLike("abc%defg", R"(%a\%d)", '\\', false);
+
   std::string input = generateString(kLikePatternCharacterSet, 65);
   testLike(input, generateString(kAnyWildcardCharacter) + input, true);
 }
 
+TEST_F(Re2FunctionsTest, likeRelaxedSuffixPattern) {
+  testLike("abcde", "%_cde", true);
+  testLike("ABCDE", "%_DE", true);
+  testLike("abcde", "%%_d_", true);
+  testLike("ABCDE", "%%D_", true);
+  testLike("abcde", "%%_e", true);
+  testLike("ABCDE", "%%_E", true);
+
+  testLike("abcde", "%cc_e", false);
+  testLike("ABCDE", "%BD_", false);
+  testLike("abcde", "%%cc_e", false);
+  testLike("ABCDE", "%%BD_", false);
+  testLike("abcde", "%be_", false);
+  testLike("ABCDE", "%_de", false);
+  testLike("abcde", "%%_ce", false);
+  testLike("ABCDE", "%%e", false);
+  testLike("\nabc\nde\n", "%_\nde\n", true);
+  testLike("\nabcde\n", "%%_de\n", true);
+  testLike("\nabc\tde\b", "%_\tde\b", true);
+  testLike("\nabcde\t", "%%_de\t", true);
+  testLike("\nabcde\n", "%d_\b", false);
+  testLike("\nabcde\n", "%_d\n", false);
+  testLike("\nabcde\n", "%e_\n", false);
+
+  testLike("FGH_ABCDE", "%_ABCDE", true);
+  testLike("ABCDE", "%_ABCDE", false);
+  testLike("_ABCDE", "%_ABCDE", true);
+
+  testLike("世界_你好", "%_你好", true);
+  testLike("你好", "%_你好", false);
+  testLike("_你好", "%_你好", true);
+
+  // Test literal '_' & '%' in pattern.
+  testLike("a_b", R"(%\__)", '\\', true);
+  testLike("cd_bc", R"(%\_b_)", '\\', true);
+  testLike("efgabc_d", R"(%a_c\_d)", '\\', true);
+}
+
+TEST_F(Re2FunctionsTest, likeSubstringPattern) {
+  testLike("abcde", "%abcde%%", true);
+  testLike("abcde", "%%bcde%", true);
+  testLike("ABCDE", "%%CD%%%", true);
+  testLike("abcde", "%%%c%", true);
+  testLike("ABCDE", "%%E%%", true);
+  testLike("abcde", "%a%", true);
+  testLike("ABCDE", "%DE%%", true);
+  testLike("abcde", "%%%%c%%%%", true);
+  testLike("ABCDE", "%%A%%%", true);
+  testLike("", "%_%", false);
+  testLike("abcde", "%cc%", false);
+  testLike("ABCDE", "%BD%%", false);
+  testLike("abcde", "%%ccd%%%", false);
+  testLike("ABCDE", "%%BDE%", false);
+  testLike("abcde", "%%be%", false);
+  testLike("ABCDE", "%de%%", false);
+  testLike("abcde", "%cb%%", false);
+  testLike("ABCDE", "%%Ab%", false);
+  testLike("\nabc\nde\n", "%\nde%%", true);
+  testLike("\nabcde\n", "%%de%", true);
+  testLike("\nabc\tde\b", "%%%d%%", true);
+  testLike("\nabcde\t", "%%e\t%%", true);
+  testLike("\nabcde\n", "%d_e\b%%", false);
+  testLike("\nabcde\n", "%%d\n%", false);
+  testLike("\nabcde\n", "%%e_\n%%", false);
+
+  // Test literal '_' & '%' in pattern.
+  testLike("cd_be", R"(%\_b%)", '\\', true);
+  testLike("efgabc_dhi", R"(%abc\_d%)", '\\', true);
+
+  testLike("ab%cd", R"(%\%%)", '\\', true);
+  testLike("efgabc%dhi", R"(%abc\%d%)", '\\', true);
+  testLike("abc%defg", R"(%a\%d%)", '\\', false);
+
+  std::string input = generateString(kLikePatternCharacterSet, 65);
+  testLike(
+      input,
+      generateString(kAnyWildcardCharacter) + input +
+          generateString(kAnyWildcardCharacter),
+      true);
+}
+
 TEST_F(Re2FunctionsTest, nullConstantPatternOrEscape) {
   // Test null pattern.
   ASSERT_TRUE(
@@ -651,6 +945,29 @@ TEST_F(Re2FunctionsTest, likePatternAndEscape) {
       "Escape character must be followed by '%', '_' or the escape character itself");
 }
 
+TEST_F(Re2FunctionsTest, likePatternUnicode) {
+  // Input contains unicode.
+  testLike("你abc", "______", false);
+  testLike("你abc好", "_____", true);
+  testLike("你abc好", "______", false);
+
+  // Long string.
+  testLike("你abc好好好好好好好好好好好好好好好好", "______", false);
+
+  testLike("你abc好", "_abc%", true);
+  testLike("你abc好", "%abc_", true);
+  testLike("你好", "__%", true);
+  testLike("你好a", "__%", true);
+
+  // Pattern contains unicode.
+  testLike("你好吗?", "你好%", true);
+  testLike("你好吗?", "你%", true);
+  testLike("你abc?", "你%", true);
+  testLike("你abc?", "我%", false);
+  testLike("你好a世界", "你好_世界%", true);
+  testLike("你好吗世界", "你好_世界%", true);
+}
+
 template <typename T>
 void Re2FunctionsTest::testRe2ExtractAll(
     const std::vector<std::optional<std::string>>& inputs,
@@ -993,24 +1310,57 @@ TEST_F(Re2FunctionsTest, tryException) {
 
 // Make sure we do not compile more than kMaxCompiledRegexes.
 TEST_F(Re2FunctionsTest, likeRegexLimit) {
-  VectorPtr pattern = makeFlatVector<StringView>(26);
-  VectorPtr input = makeFlatVector<StringView>(26);
+  int count = 26;
+  VectorPtr pattern = makeFlatVector<StringView>(count);
+  VectorPtr input = makeFlatVector<StringView>(count);
+  VectorPtr result;
 
   auto flatInput = input->asFlatVector<StringView>();
-  for (int i = 0; i < 26; i++) {
+  for (int i = 0; i < count; i++) {
     flatInput->set(i, "");
   }
 
   auto flatPattern = pattern->asFlatVector<StringView>();
+  auto getPatternAtIdx = [&](PatternKind patternKind,
+                             vector_size_t idx) -> std::string {
+    switch (patternKind) {
+      case PatternKind::kExactlyN:
+        return fmt::format("{:_<{}}", "", idx + 1);
+      case PatternKind::kAtLeastN:
+        return fmt::format("{:%<{}}", "", idx + 1);
+      case PatternKind::kFixed:
+        return fmt::format("abc{}", idx);
+      case PatternKind::kPrefix:
+        return fmt::format("abc{}%%", idx);
+      case PatternKind::kSuffix:
+        return fmt::format("%%{}abc", idx);
+      case PatternKind::kSubstring:
+        return fmt::format("%%abc{}%%%", idx);
+      default:
+        VELOX_UNREACHABLE("like is not optimized for pattern {}", patternKind);
+    }
+  };
 
-  // Over 20 all optimized, will pass.
-  for (int i = 0; i < 26; i++) {
-    std::string localPattern = fmt::format("{}.*{}", 'c' + i, 'c' + i);
-    flatPattern->set(i, StringView(localPattern));
-  }
+  auto verifyNoRegexCompilationForPattern = [&](PatternKind patternKind) {
+    // Over 20 all optimized, will pass.
+    for (int i = 0; i < count; i++) {
+      std::string patternAtIdx = getPatternAtIdx(patternKind, i);
+      flatPattern->set(i, StringView(patternAtIdx));
+    }
+    result = evaluate("like(c0 , c1)", makeRowVector({input, pattern}));
+    // Pattern '%%%', of type kAtleastN, matches with empty input.
+    assertEqualVectors(
+        makeConstant((patternKind == PatternKind::kAtLeastN), count), result);
+  };
 
-  auto result = evaluate("like(c0 , c1)", makeRowVector({input, pattern}));
-  assertEqualVectors(makeConstant(false, 26), result);
+  // Infer regex compilation does not happen for optimized patterns by verifying
+  // less than kMaxCompiledRegexes are compiled for each optimized pattern type.
+  verifyNoRegexCompilationForPattern(PatternKind::kExactlyN);
+  verifyNoRegexCompilationForPattern(PatternKind::kAtLeastN);
+  verifyNoRegexCompilationForPattern(PatternKind::kFixed);
+  verifyNoRegexCompilationForPattern(PatternKind::kPrefix);
+  verifyNoRegexCompilationForPattern(PatternKind::kSuffix);
+  verifyNoRegexCompilationForPattern(PatternKind::kSubstring);
 
   // Over 20, all require regex, will fail.
   for (int i = 0; i < 26; i++) {
@@ -1020,20 +1370,24 @@ TEST_F(Re2FunctionsTest, likeRegexLimit) {
   }
 
   VELOX_ASSERT_THROW(
-      evaluate("like(c0 , c1)", makeRowVector({input, pattern})),
+      evaluate("like(c0, c1)", makeRowVector({input, pattern})),
       "Max number of regex reached");
 
-  // Make sure try does not suppress that faluire.
-  VELOX_ASSERT_THROW(
-      evaluate("try(like(c0 , c1))", makeRowVector({input, pattern})),
-      "Max number of regex reached");
+  // First 20 rows should return false, the rest raise and error and become
+  // null.
+  result = evaluate("try(like(c0, c1))", makeRowVector({input, pattern}));
+  auto expected = makeFlatVector<bool>(
+      26,
+      [](auto /*row*/) { return false; },
+      [](auto row) { return row >= 20; });
+  assertEqualVectors(expected, result);
 
   // All are complex but the same, should pass.
   for (int i = 0; i < 26; i++) {
     flatPattern->set(i, "b%[0-9]+.*{}.*{}.*[0-9]+");
   }
-  assertEqualVectors(
-      BaseVector::createConstant(BOOLEAN(), false, 26, pool()), result);
+  result = evaluate("like(c0, c1)", makeRowVector({input, pattern}));
+  assertEqualVectors(makeConstant(false, 26), result);
 }
 
 TEST_F(Re2FunctionsTest, invalidEscapeChar) {
@@ -1066,5 +1420,85 @@ TEST_F(Re2FunctionsTest, invalidEscapeChar) {
   }
 }
 
+TEST_F(Re2FunctionsTest, regexExtractAllLarge) {
+  auto input = makeRowVector({});
+  input->resize(1);
+
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', CAST('4611686018427387904' AS BIGINT))",
+          input),
+      "No group 4611686018427387904 in regex '(\\d+)([a-z]+)")
+}
+
+// Make sure we do not compile more than kMaxCompiledRegexes.
+TEST_F(Re2FunctionsTest, limit) {
+  auto data = makeRowVector({
+      makeFlatVector<std::string>(
+          100,
+          [](auto row) { return fmt::format("Apples and oranges {}", row); }),
+      makeFlatVector<std::string>(
+          100,
+          [](auto row) { return fmt::format("Apples (.*) oranges {}", row); }),
+      makeFlatVector<std::string>(
+          100,
+          [](auto row) {
+            return fmt::format("Apples (.*) oranges {}", row % 20);
+          }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("regexp_extract(c0, c1)", data), "Max number of regex reached");
+  ASSERT_NO_THROW(evaluate("regexp_extract(c0, c2)", data));
+
+  VELOX_ASSERT_THROW(
+      evaluate("regexp_extract(c0, c1, 1)", data),
+      "Max number of regex reached");
+  ASSERT_NO_THROW(evaluate("regexp_extract(c0, c2, 1)", data));
+
+  VELOX_ASSERT_THROW(
+      evaluate("regexp_extract_all(c0, c1)", data),
+      "Max number of regex reached");
+  ASSERT_NO_THROW(evaluate("regexp_extract_all(c0, c2)", data));
+
+  VELOX_ASSERT_THROW(
+      evaluate("regexp_extract_all(c0, c1, 1)", data),
+      "Max number of regex reached");
+  ASSERT_NO_THROW(evaluate("regexp_extract_all(c0, c2, 1)", data));
+
+  VELOX_ASSERT_THROW(
+      evaluate("regexp_like(c0, c1)", data), "Max number of regex reached");
+  ASSERT_NO_THROW(evaluate("regexp_like(c0, c2)", data));
+}
+
+TEST_F(Re2FunctionsTest, split) {
+  auto input = makeRowVector({
+      makeFlatVector<std::string>({
+          "1a 2b 14m",
+          "1a 2b 14",
+          "",
+          "a123b",
+      }),
+  });
+  auto result = evaluate("regexp_split(c0, '\\s*[a-z]+\\s*')", input);
+
+  auto expected = makeArrayVector<std::string>({
+      {"1", "2", "14", ""},
+      {"1", "2", "14"},
+      {""},
+      {"", "123", ""},
+  });
+  assertEqualVectors(expected, result);
+
+  result = evaluate("regexp_split(c0, '\\s*\\d+\\s*')", input);
+  expected = makeArrayVector<std::string>({
+      {"", "a", "b", "m"},
+      {"", "a", "b", ""},
+      {""},
+      {"a", "b"},
+  });
+  assertEqualVectors(expected, result);
+}
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/tests/RepeatTest.cpp b/velox/functions/lib/tests/RepeatTest.cpp
new file mode 100644
index 0000000000000..8e7b637aba7f5
--- /dev/null
+++ b/velox/functions/lib/tests/RepeatTest.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/Repeat.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class RepeatTest : public functions::test::FunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    FunctionBaseTest::SetUpTestCase();
+    exec::registerStatefulVectorFunction(
+        "repeat",
+        functions::repeatSignatures(),
+        functions::makeRepeat,
+        functions::repeatMetadata());
+    exec::registerStatefulVectorFunction(
+        "repeat_allow_negative_count",
+        functions::repeatSignatures(),
+        functions::makeRepeatAllowNegativeCount,
+        functions::repeatMetadata());
+  }
+
+  void testExpression(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+
+  void testExpressionWithError(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const std::string& expectedError) {
+    VELOX_ASSERT_THROW(
+        evaluate(expression, makeRowVector(input)), expectedError);
+  }
+};
+
+TEST_F(RepeatTest, repeat) {
+  const auto elementVector = makeNullableFlatVector<float>(
+      {0.0, -2.0, 3.333333, 4.0004, std::nullopt, 5.12345});
+  const auto countVector =
+      makeNullableFlatVector<int32_t>({1, 2, 3, 0, 4, std::nullopt});
+  VectorPtr expected;
+
+  expected = makeNullableArrayVector<float>({
+      {{0.0}},
+      {{-2.0, -2.0}},
+      {{3.333333, 3.333333, 3.333333}},
+      {{}},
+      {{std::nullopt, std::nullopt, std::nullopt, std::nullopt}},
+      std::nullopt,
+  });
+  testExpression("repeat(C0, C1)", {elementVector, countVector}, expected);
+  testExpression("try(repeat(C0, C1))", {elementVector, countVector}, expected);
+
+  // Test using a null constant as the count argument.
+  expected = BaseVector::createNullConstant(ARRAY(REAL()), 6, pool());
+  testExpression("repeat(C0, null::INTEGER)", {elementVector}, expected);
+  testExpression("try(repeat(C0, null::INTEGER))", {elementVector}, expected);
+
+  // Test using a non-null constant as the count argument.
+  expected = makeNullableArrayVector<float>({
+      {0.0, 0.0, 0.0},
+      {-2.0, -2.0, -2.0},
+      {3.333333, 3.333333, 3.333333},
+      {4.0004, 4.0004, 4.0004},
+      {std::nullopt, std::nullopt, std::nullopt},
+      {5.12345, 5.12345, 5.12345},
+  });
+  testExpression("repeat(C0, '3'::INTEGER)", {elementVector}, expected);
+  testExpression("try(repeat(C0, '3'::INTEGER))", {elementVector}, expected);
+
+  expected = makeArrayVector<float>({{}, {}, {}, {}, {}, {}});
+  testExpression("repeat(C0, '0'::INTEGER)", {elementVector}, expected);
+  testExpression("try(repeat(C0, '0'::INTEGER))", {elementVector}, expected);
+}
+
+TEST_F(RepeatTest, repeatWithInvalidCount) {
+  const auto elementVector =
+      makeNullableFlatVector<float>({0.0, 2.0, 3.333333});
+
+  VectorPtr countVector;
+  VectorPtr expected;
+
+  expected = makeNullableArrayVector<float>({
+      {{0.0}},
+      std::nullopt,
+      {{3.333333, 3.333333, 3.333333}},
+  });
+  countVector = makeNullableFlatVector<int32_t>({1, -2, 3});
+  testExpression("try(repeat(C0, C1))", {elementVector, countVector}, expected);
+  testExpressionWithError(
+      "repeat(C0, C1)",
+      {elementVector, countVector},
+      "(-2 vs. 0) Count argument of repeat function must be greater than or equal to 0");
+
+  countVector = makeNullableFlatVector<int32_t>({1, 123456, 3});
+  testExpression("try(repeat(C0, C1))", {elementVector, countVector}, expected);
+  testExpressionWithError(
+      "repeat(C0, C1)",
+      {elementVector, countVector},
+      "(123456 vs. 10000) Count argument of repeat function must be less than or equal to 10000");
+
+  // Test using a constant as the count argument.
+  expected = BaseVector::createNullConstant(ARRAY(REAL()), 3, pool());
+  testExpression("try(repeat(C0, '-5'::INTEGER))", {elementVector}, expected);
+  testExpressionWithError(
+      "repeat(C0, '-5'::INTEGER)",
+      {elementVector},
+      "(-5 vs. 0) Count argument of repeat function must be greater than or equal to 0");
+
+  testExpression(
+      "try(repeat(C0, '10001'::INTEGER))", {elementVector}, expected);
+  testExpressionWithError(
+      "repeat(C0, '10001'::INTEGER)",
+      {elementVector},
+      "(10001 vs. 10000) Count argument of repeat function must be less than or equal to 10000");
+}
+
+TEST_F(RepeatTest, repeatAllowNegativeCount) {
+  const auto elementVector = makeNullableFlatVector<float>(
+      {0.0, -2.0, 3.333333, 4.0004, std::nullopt, 5.12345});
+  auto expected = makeArrayVector<float>({{}, {}, {}, {}, {}, {}});
+
+  // Test negative count.
+  auto countVector =
+      makeNullableFlatVector<int32_t>({-1, -2, -3, -5, -10, -100});
+  testExpression(
+      "repeat_allow_negative_count(C0, C1)",
+      {elementVector, countVector},
+      expected);
+
+  // Test using a constant as the count argument.
+  testExpression(
+      "repeat_allow_negative_count(C0, '-5'::INTEGER)",
+      {elementVector},
+      expected);
+
+  // Test mixed case.
+  expected = makeArrayVector<float>(
+      {{0.0}, {-2.0, -2.0}, {}, {}, {}, {5.12345, 5.12345, 5.12345}});
+  countVector = makeNullableFlatVector<int32_t>({1, 2, -1, 0, -10, 3});
+  testExpression(
+      "repeat_allow_negative_count(C0, C1)",
+      {elementVector, countVector},
+      expected);
+}
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/tests/SliceTestBase.h b/velox/functions/lib/tests/SliceTestBase.h
new file mode 100644
index 0000000000000..bdb54550fbe68
--- /dev/null
+++ b/velox/functions/lib/tests/SliceTestBase.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/parse/TypeResolver.h"
+
+namespace facebook::velox::functions::test {
+
+class SliceTestBase : public FunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    parse::registerTypeResolver();
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  virtual void testSlice(
+      const std::string& expression,
+      const std::vector<VectorPtr>& parameters,
+      const ArrayVectorPtr& expectedArrayVector) {
+    auto result = evaluate<ArrayVector>(expression, makeRowVector(parameters));
+    ::facebook::velox::test::assertEqualVectors(expectedArrayVector, result);
+    EXPECT_FALSE(expectedArrayVector->hasOverlappingRanges());
+  }
+
+  void basicTestCases() {
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4, 5}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      testSlice("slice(C0, 1, 4)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{1, 2}});
+      testSlice("slice(C0, 1, 4)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4, 5}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{3, 4}});
+      testSlice("slice(C0, 3, 2)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{3, 4}});
+      testSlice("slice(C0, 3, 3)", {arrayVector}, expectedArrayVector);
+    }
+    // Negative start index.
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{2, 3, 4}});
+      testSlice("slice(C0, -3, 3)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{2, 3, 4}});
+      testSlice("slice(C0, -3, 5)", {arrayVector}, expectedArrayVector);
+    }
+    // Negative length.
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{}});
+      VELOX_ASSERT_THROW(
+          testSlice(
+              "slice(C0, 1, -1)",
+              {arrayVector, arrayVector, expectedArrayVector},
+              expectedArrayVector),
+          "The value of length argument of slice() function should not be negative");
+    }
+    // 0 start index.
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{}});
+      VELOX_ASSERT_THROW(
+          testSlice(
+              "slice(C0, 0, 1)",
+              {arrayVector, arrayVector, expectedArrayVector},
+              expectedArrayVector),
+          "SQL array indices start at 1");
+    }
+    // 0 length.
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{}});
+      testSlice("slice(C0, 1, 0)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{}});
+      testSlice("slice(C0, -2, 0)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{}});
+      testSlice("slice(C0, -2, 0)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{}});
+      testSlice("slice(C0, -5, 5)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{}});
+      testSlice("slice(C0, -6, 5)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+      auto expectedArrayVector = makeArrayVector<int64_t>({{}});
+      testSlice("slice(C0, -6, 5)", {arrayVector}, expectedArrayVector);
+    }
+    {
+      // The implementation is zero-copy, so floating point number comparison
+      // won't have issue here since numerical representation remains the same.
+      auto arrayVector = makeArrayVector<double>({{2.3, 2.3, 2.2}});
+      auto expectedArrayVector = makeArrayVector<double>({{2.3, 2.2}});
+      testSlice("slice(C0, 2, 3)", {arrayVector}, expectedArrayVector);
+    }
+    // String array.
+    {
+      auto arrayVector = makeArrayVector<StringView>({{"a", "b", "c", "d"}});
+      auto expectedArrayVector = makeArrayVector<StringView>({{"b", "c"}});
+      testSlice("slice(C0, 2, 2)", {arrayVector}, expectedArrayVector);
+    }
+    // Out of bound start index.
+    {
+      auto arrayVector = makeArrayVector<StringView>({{"a", "b", "c", "d"}});
+      auto expectedArrayVector = makeArrayVector<StringView>({{}});
+      testSlice("slice(C0, 5, 2)", {arrayVector}, expectedArrayVector);
+    }
+    // Out of bound length.
+    {
+      auto arrayVector = makeArrayVector<StringView>({{"a", "b", "c", "d"}});
+      auto expectedArrayVector = makeArrayVector<StringView>({{"b", "c", "d"}});
+      testSlice("slice(C0, 2, 5)", {arrayVector}, expectedArrayVector);
+    }
+  }
+};
+
+} // namespace facebook::velox::functions::test
diff --git a/velox/functions/prestosql/tests/Utf8Test.cpp b/velox/functions/lib/tests/Utf8Test.cpp
similarity index 98%
rename from velox/functions/prestosql/tests/Utf8Test.cpp
rename to velox/functions/lib/tests/Utf8Test.cpp
index 19c59ad781f1d..4330d1d9bbd2c 100644
--- a/velox/functions/prestosql/tests/Utf8Test.cpp
+++ b/velox/functions/lib/tests/Utf8Test.cpp
@@ -15,7 +15,7 @@
  */
 
 #include <gtest/gtest.h>
-#include "velox/functions/prestosql/Utf8Utils.h"
+#include "velox/functions/lib/Utf8Utils.h"
 
 namespace facebook::velox::functions {
 namespace {
diff --git a/velox/functions/lib/window/CMakeLists.txt b/velox/functions/lib/window/CMakeLists.txt
index 687472181e790..9594f3814569a 100644
--- a/velox/functions/lib/window/CMakeLists.txt
+++ b/velox/functions/lib/window/CMakeLists.txt
@@ -12,10 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_functions_window NthValue.cpp Rank.cpp RowNumber.cpp)
+velox_add_library(
+  velox_functions_window
+  NthValue.cpp
+  Ntile.cpp
+  Rank.cpp
+  RowNumber.cpp)
 
-target_link_libraries(velox_functions_window velox_buffer velox_exec
-                      Folly::folly)
+velox_link_libraries(velox_functions_window velox_buffer velox_exec
+                     Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/lib/window/NthValue.cpp b/velox/functions/lib/window/NthValue.cpp
index d1707f806af71..5ef33fc303cd0 100644
--- a/velox/functions/lib/window/NthValue.cpp
+++ b/velox/functions/lib/window/NthValue.cpp
@@ -32,34 +32,35 @@ class NthValueFunction : public exec::WindowFunction {
       : WindowFunction(resultType, pool, nullptr), ignoreNulls_(ignoreNulls) {
     VELOX_CHECK_EQ(args.size(), 2);
     VELOX_CHECK_NULL(args[0].constantValue);
+    auto offsetType = args[1].type;
+    VELOX_USER_CHECK(
+        (offsetType->isInteger() || offsetType->isBigint()),
+        "Invalid offset type: {}",
+        offsetType->toString());
     valueIndex_ = args[0].index.value();
-    if (args[1].type->isInteger()) {
-      VELOX_USER_CHECK(
-          args[1].constantValue, "Offset must be literal for spark");
+    if (args[1].constantValue) {
       if (args[1].constantValue->isNullAt(0)) {
         isConstantOffsetNull_ = true;
         return;
       }
-      constantOffset_ =
-          args[1]
-              .constantValue->template as<ConstantVector<int32_t>>()
-              ->valueAt(0);
-      VELOX_USER_CHECK_GE(
-          constantOffset_.value(), 1, "Offset must be at least 1");
-    } else {
-      if (args[1].constantValue) {
-        if (args[1].constantValue->isNullAt(0)) {
-          isConstantOffsetNull_ = true;
-          return;
-        }
+      if (offsetType->isInteger()) {
+        constantOffset_ =
+            args[1]
+                .constantValue->template as<ConstantVector<int32_t>>()
+                ->valueAt(0);
+      } else {
         constantOffset_ =
             args[1]
                 .constantValue->template as<ConstantVector<int64_t>>()
                 ->valueAt(0);
-        VELOX_USER_CHECK_GE(
-            constantOffset_.value(), 1, "Offset must be at least 1");
+      }
+      VELOX_USER_CHECK_GE(
+          constantOffset_.value(), 1, "Offset must be at least 1");
+    } else {
+      offsetIndex_ = args[1].index.value();
+      if (offsetType->isInteger()) {
+        offsets_ = BaseVector::create<FlatVector<int32_t>>(INTEGER(), 0, pool);
       } else {
-        offsetIndex_ = args[1].index.value();
         offsets_ = BaseVector::create<FlatVector<int64_t>>(BIGINT(), 0, pool);
       }
     }
@@ -149,8 +150,7 @@ class NthValueFunction : public exec::WindowFunction {
       const vector_size_t* frameStarts,
       const vector_size_t* frameEnds,
       vector_size_t leastFrame) {
-    vector_size_t constantOffsetValue =
-        static_cast<vector_size_t>(constantOffset_.value());
+    auto constantOffsetValue = constantOffset_.value();
     if (ignoreNulls) {
       auto rawNulls = nulls_->as<uint64_t>();
       validRows.applyToSelected([&](auto i) {
@@ -169,18 +169,19 @@ class NthValueFunction : public exec::WindowFunction {
     }
   }
 
-  template <bool ignoreNulls>
+  template <bool ignoreNulls, typename T>
   void setRowNumbersApplyLoop(
       const SelectivityVector& validRows,
       const vector_size_t* frameStarts,
       const vector_size_t* frameEnds,
       vector_size_t leastFrame = 0) {
     auto rawNulls = nulls_->as<uint64_t>();
+    auto offsetsVector = offsets_->as<FlatVector<T>>();
     validRows.applyToSelected([&](auto i) {
-      if (offsets_->isNullAt(i)) {
+      if (offsetsVector->isNullAt(i)) {
         rowNumbers_[i] = kNullRow;
       } else {
-        vector_size_t offset = offsets_->valueAt(i);
+        T offset = offsetsVector->valueAt(i);
         VELOX_USER_CHECK_GE(offset, 1, "Offset must be at least 1");
         if constexpr (ignoreNulls) {
           setRowNumberIgnoreNulls(
@@ -204,10 +205,21 @@ class NthValueFunction : public exec::WindowFunction {
         offsetIndex_, partitionOffset_, numRows, 0, offsets_);
 
     if (ignoreNulls) {
-      setRowNumbersApplyLoop<true>(
-          validRows, frameStarts, frameEnds, leastFrame);
+      if (offsets_->type()->isInteger()) {
+        setRowNumbersApplyLoop<true, int32_t>(
+            validRows, frameStarts, frameEnds, leastFrame);
+      } else {
+        setRowNumbersApplyLoop<true, int64_t>(
+            validRows, frameStarts, frameEnds, leastFrame);
+      }
     } else {
-      setRowNumbersApplyLoop<false>(validRows, frameStarts, frameEnds);
+      if (offsets_->type()->isInteger()) {
+        setRowNumbersApplyLoop<false, int32_t>(
+            validRows, frameStarts, frameEnds);
+      } else {
+        setRowNumbersApplyLoop<false, int64_t>(
+            validRows, frameStarts, frameEnds);
+      }
     }
   }
 
@@ -222,27 +234,29 @@ class NthValueFunction : public exec::WindowFunction {
     invalidRows_.applyToSelected([&](auto i) { rowNumbers_[i] = kNullRow; });
   }
 
+  template <typename T>
   inline void setRowNumber(
       vector_size_t i,
       const vector_size_t* frameStarts,
       const vector_size_t* frameEnds,
-      vector_size_t offset) {
+      T offset) {
     auto frameStart = frameStarts[i];
     auto frameEnd = frameEnds[i];
     auto rowNumber = frameStart + offset - 1;
     rowNumbers_[i] = rowNumber <= frameEnd ? rowNumber : kNullRow;
   }
 
+  template <typename T>
   inline void setRowNumberIgnoreNulls(
       vector_size_t i,
       const uint64_t* rawNulls,
       vector_size_t leastFrame,
       const vector_size_t* frameStarts,
       const vector_size_t* frameEnds,
-      vector_size_t offset) {
+      T offset) {
     auto frameStart = frameStarts[i];
     auto frameEnd = frameEnds[i];
-    vector_size_t nonNullCount = 0;
+    T nonNullCount = 0;
     for (auto j = frameStart; j <= frameEnd; j++) {
       if (!bits::isBitSet(rawNulls, j - leastFrame)) {
         ++nonNullCount;
@@ -271,7 +285,7 @@ class NthValueFunction : public exec::WindowFunction {
 
   // This vector is used to extract values of the offset argument column
   // (if not a constant offset value).
-  FlatVectorPtr<int64_t> offsets_;
+  VectorPtr offsets_ = nullptr;
 
   // This offset tracks how far along the partition rows have been output.
   // This can be used to optimize reading offset column values corresponding
@@ -305,6 +319,7 @@ void registerNthValue(const std::string& name, TypeKind offsetTypeKind) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& args,
           const TypePtr& resultType,
diff --git a/velox/functions/prestosql/window/Ntile.cpp b/velox/functions/lib/window/Ntile.cpp
similarity index 83%
rename from velox/functions/prestosql/window/Ntile.cpp
rename to velox/functions/lib/window/Ntile.cpp
index 99f542facfa72..8b4460b90b42c 100644
--- a/velox/functions/prestosql/window/Ntile.cpp
+++ b/velox/functions/lib/window/Ntile.cpp
@@ -19,21 +19,23 @@
 #include "velox/expression/FunctionSignature.h"
 #include "velox/vector/FlatVector.h"
 
-namespace facebook::velox::window::prestosql {
+namespace facebook::velox::functions::window {
 
 namespace {
 
+template <typename TResult>
 class NtileFunction : public exec::WindowFunction {
  public:
   explicit NtileFunction(
       const std::vector<exec::WindowFunctionArg>& args,
+      const TypePtr& resultType,
       velox::memory::MemoryPool* pool)
-      : WindowFunction(BIGINT(), pool, nullptr) {
+      : WindowFunction(resultType, pool, nullptr) {
     if (args[0].constantValue) {
       auto argBuckets = args[0].constantValue;
       if (!argBuckets->isNullAt(0)) {
         numFixedBuckets_ =
-            argBuckets->as<ConstantVector<int64_t>>()->valueAt(0);
+            argBuckets->as<ConstantVector<TResult>>()->valueAt(0);
         VELOX_USER_CHECK_GE(
             numFixedBuckets_.value(), 1, "{}", kBucketErrorString);
       }
@@ -41,8 +43,8 @@ class NtileFunction : public exec::WindowFunction {
     }
 
     bucketColumn_ = args[0].index;
-    bucketVector_ = BaseVector::create(BIGINT(), 0, pool);
-    bucketFlatVector_ = bucketVector_->asFlatVector<int64_t>();
+    bucketVector_ = BaseVector::create(resultType_, 0, pool);
+    bucketFlatVector_ = bucketVector_->asFlatVector<TResult>();
   }
 
   void resetPartition(const exec::WindowPartition* partition) override {
@@ -87,21 +89,21 @@ class NtileFunction : public exec::WindowFunction {
   struct BucketMetrics {
     // To compute the bucket number for a row, we find the number of rows in
     // a bucket as the (number of rows in partition) / (number of buckets).
-    int64_t rowsPerBucket;
+    TResult rowsPerBucket;
     // There could be some buckets with rowsPerBucket + 1 number of rows,
     // as the partition rows might not be exactly divisible
     // by the number of buckets. There are
     // (number of rows in partition) % (number of buckets) such buckets.
-    int64_t bucketsWithExtraRow;
+    TResult bucketsWithExtraRow;
     // When assigning bucket numbers, the first 'bucketsWithExtraRow' buckets
     // will have (rowsPerBucket + 1) rows. This row number at this boundary is
     // extraBucketsBoundary = bucketsWithExtraRow * (rowsPerBucket + 1). Beyond
     // this row number in the partition, the buckets will have only
     // rowsPerBucket number of rows. This boundary is useful when computing the
     // bucket value.
-    int64_t extraBucketsBoundary;
+    TResult extraBucketsBoundary;
 
-    int64_t computeBucketValue(vector_size_t rowNumber) const {
+    TResult computeBucketValue(vector_size_t rowNumber) const {
       if (rowNumber < extraBucketsBoundary) {
         return rowNumber / (rowsPerBucket + 1) + 1;
       }
@@ -115,7 +117,7 @@ class NtileFunction : public exec::WindowFunction {
         vector_size_t numRows,
         int64_t partitionOffset,
         vector_size_t resultOffset,
-        int64_t* rawResultValues) {
+        TResult* rawResultValues) {
       int64_t i = 0;
       // This loop terminates if it reaches extraBucketBoundary or numRows
       // in the result vector are filled.
@@ -130,7 +132,7 @@ class NtileFunction : public exec::WindowFunction {
     }
   };
 
-  BucketMetrics computeBucketMetrics(int64_t numBuckets) const {
+  BucketMetrics computeBucketMetrics(TResult numBuckets) const {
     auto rowsPerBucket = numPartitionRows_ / numBuckets;
     auto bucketsWithExtraRow = numPartitionRows_ % numBuckets;
     auto extraBucketsBoundary = (rowsPerBucket + 1) * bucketsWithExtraRow;
@@ -145,7 +147,7 @@ class NtileFunction : public exec::WindowFunction {
     partition_->extractColumn(
         bucketColumn_.value(), partitionOffset_, numRows, 0, bucketVector_);
 
-    auto* resultFlatVector = result->asFlatVector<int64_t>();
+    auto* resultFlatVector = result->asFlatVector<TResult>();
     auto* rawValues = resultFlatVector->mutableRawValues();
     for (auto i = 0; i < numRows; i++) {
       if (bucketFlatVector_->isNullAt(i)) {
@@ -170,7 +172,7 @@ class NtileFunction : public exec::WindowFunction {
       vector_size_t resultOffset,
       const VectorPtr& result) {
     if (numFixedBuckets_.has_value()) {
-      auto rawValues = result->asFlatVector<int64_t>()->mutableRawValues();
+      auto rawValues = result->asFlatVector<TResult>()->mutableRawValues();
       if (fixedBucketsMoreThanPartition_) {
         std::iota(
             rawValues + resultOffset,
@@ -183,7 +185,7 @@ class NtileFunction : public exec::WindowFunction {
     } else {
       // This is a function call with a constant null value. Set all result
       // rows to null.
-      auto* resultVector = result->asFlatVector<int64_t>();
+      auto* resultVector = result->asFlatVector<TResult>();
       auto mutableRawNulls = resultVector->mutableRawNulls();
       bits::fillBits(
           mutableRawNulls, resultOffset, resultOffset + numRows, bits::kNull);
@@ -195,7 +197,7 @@ class NtileFunction : public exec::WindowFunction {
 
   // Number of buckets if a constant value. Is optional as the value could
   // be null.
-  std::optional<int64_t> numFixedBuckets_;
+  std::optional<TResult> numFixedBuckets_;
 
   // If number of buckets is greater than the partition rows, then the output
   // bucket number is simply row number + 1. So bucket computation can be
@@ -209,44 +211,54 @@ class NtileFunction : public exec::WindowFunction {
 
   // Current WindowPartition used for accessing rows in the apply method.
   const exec::WindowPartition* partition_;
-  int64_t numPartitionRows_ = 0;
+  TResult numPartitionRows_ = 0;
 
   // Denotes how far along the partition rows are output already.
   int64_t partitionOffset_ = 0;
 
   // Vector used to read the bucket column values.
   VectorPtr bucketVector_;
-  FlatVector<int64_t>* bucketFlatVector_;
+  FlatVector<TResult>* bucketFlatVector_;
 
   static const std::string kBucketErrorString;
 };
 
-const std::string NtileFunction::kBucketErrorString =
+template <typename TResult>
+const std::string NtileFunction<TResult>::kBucketErrorString =
     "Buckets must be greater than 0";
 
 } // namespace
 
-void registerNtile(const std::string& name) {
-  // ntile(bigint) -> bigint.
+template <typename TResult>
+void registerNtile(const std::string& name, const std::string& type) {
   std::vector<exec::FunctionSignaturePtr> signatures{
       exec::FunctionSignatureBuilder()
-          .returnType("bigint")
-          .argumentType("bigint")
+          .returnType(type)
+          .argumentType(type)
           .build(),
   };
 
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& args,
-          const TypePtr& /*resultType*/,
+          const TypePtr& resultType,
           bool /*ignoreNulls*/,
           velox::memory::MemoryPool* pool,
           HashStringAllocator* /*stringAllocator*/,
           const core::QueryConfig& /*queryConfig*/)
           -> std::unique_ptr<exec::WindowFunction> {
-        return std::make_unique<NtileFunction>(args, pool);
+        return std::make_unique<NtileFunction<TResult>>(args, resultType, pool);
       });
 }
-} // namespace facebook::velox::window::prestosql
+
+void registerNtileBigint(const std::string& name) {
+  registerNtile<int64_t>(name, "bigint");
+}
+void registerNtileInteger(const std::string& name) {
+  registerNtile<int32_t>(name, "integer");
+}
+
+} // namespace facebook::velox::functions::window
diff --git a/velox/functions/lib/window/Rank.cpp b/velox/functions/lib/window/Rank.cpp
index 646557a2e30ce..625d2bd3b977f 100644
--- a/velox/functions/lib/window/Rank.cpp
+++ b/velox/functions/lib/window/Rank.cpp
@@ -97,9 +97,7 @@ void registerRankInternal(
       exec::FunctionSignatureBuilder().returnType(returnType).build(),
   };
 
-  exec::registerWindowFunction(
-      name,
-      std::move(signatures),
+  auto windowFunctionFactory =
       [name](
           const std::vector<exec::WindowFunctionArg>& /*args*/,
           const TypePtr& resultType,
@@ -107,9 +105,23 @@ void registerRankInternal(
           velox::memory::MemoryPool* /*pool*/,
           HashStringAllocator* /*stringAllocator*/,
           const core::QueryConfig& /*queryConfig*/)
-          -> std::unique_ptr<exec::WindowFunction> {
-        return std::make_unique<RankFunction<TRank, TResult>>(resultType);
-      });
+      -> std::unique_ptr<exec::WindowFunction> {
+    return std::make_unique<RankFunction<TRank, TResult>>(resultType);
+  };
+
+  if constexpr (TRank == RankType::kRank || TRank == RankType::kDenseRank) {
+    exec::registerWindowFunction(
+        name,
+        std::move(signatures),
+        {exec::WindowFunction::ProcessMode::kRows, false},
+        std::move(windowFunctionFactory));
+  } else {
+    exec::registerWindowFunction(
+        name,
+        std::move(signatures),
+        exec::WindowFunction::Metadata::defaultMetadata(),
+        std::move(windowFunctionFactory));
+  }
 }
 
 void registerRankBigint(const std::string& name) {
diff --git a/velox/functions/lib/window/RegistrationFunctions.h b/velox/functions/lib/window/RegistrationFunctions.h
index 726b495518371..17dc185d777c1 100644
--- a/velox/functions/lib/window/RegistrationFunctions.h
+++ b/velox/functions/lib/window/RegistrationFunctions.h
@@ -54,4 +54,12 @@ void registerDenseRankInteger(const std::string& name);
 // Returns the percentage ranking of a value in a group of values.
 void registerPercentRank(const std::string& name);
 
+// Register the Presto function ntile() with the bigint data type
+// for the return and input value.
+void registerNtileBigint(const std::string& name);
+
+// Register the Spark function ntile() with the integer data type
+// for the return and input value.
+void registerNtileInteger(const std::string& name);
+
 } // namespace facebook::velox::functions::window
diff --git a/velox/functions/lib/window/RowNumber.cpp b/velox/functions/lib/window/RowNumber.cpp
index 16b7feb0a5431..81fc7e5e0c6d4 100644
--- a/velox/functions/lib/window/RowNumber.cpp
+++ b/velox/functions/lib/window/RowNumber.cpp
@@ -75,6 +75,7 @@ void registerRowNumber(const std::string& name, TypeKind resultTypeKind) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      {exec::WindowFunction::ProcessMode::kRows, false},
       [name](
           const std::vector<exec::WindowFunctionArg>& /*args*/,
           const TypePtr& resultType,
diff --git a/velox/functions/lib/window/tests/CMakeLists.txt b/velox/functions/lib/window/tests/CMakeLists.txt
index 2f77cde2c98ec..309e415e5772d 100644
--- a/velox/functions/lib/window/tests/CMakeLists.txt
+++ b/velox/functions/lib/window/tests/CMakeLists.txt
@@ -15,5 +15,9 @@
 add_library(velox_functions_window_test_lib WindowTestBase.cpp)
 
 target_link_libraries(
-  velox_functions_window_test_lib velox_exec_test_lib velox_vector_fuzzer
-  velox_vector_test_lib gflags::gflags gtest)
+  velox_functions_window_test_lib
+  velox_exec_test_lib
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  gflags::gflags
+  GTest::gtest)
diff --git a/velox/functions/lib/window/tests/WindowTestBase.cpp b/velox/functions/lib/window/tests/WindowTestBase.cpp
index 3f8e06035dcaa..9e8c0d5466386 100644
--- a/velox/functions/lib/window/tests/WindowTestBase.cpp
+++ b/velox/functions/lib/window/tests/WindowTestBase.cpp
@@ -139,7 +139,7 @@ RowVectorPtr WindowTestBase::makeRandomInputVector(vector_size_t size) {
       {makeRandomInputVector(BIGINT(), size, 0.2),
        makeRandomInputVector(VARCHAR(), size, 0.3),
        makeFlatVector<int64_t>(size, genRandomFrameValue),
-       makeFlatVector<int64_t>(size, genRandomFrameValue)});
+       makeFlatVector<int32_t>(size, genRandomFrameValue)});
 }
 
 void WindowTestBase::testWindowFunction(
@@ -158,12 +158,16 @@ void WindowTestBase::testWindowFunction(
   std::mt19937 gen(rd());
   std::uniform_int_distribution<int> dis(0, 1);
 
+  int n = 0;
   for (const auto& overClause : overClauses) {
-    WindowTestBase::QueryInfo queryInfo;
     for (const auto& frameClause : frameClauses) {
+      ++n;
+
       auto resolvedWindowStyle = windowStyle == WindowStyle::kRandom
           ? static_cast<int>(dis(gen))
           : static_cast<int>(windowStyle);
+
+      WindowTestBase::QueryInfo queryInfo;
       if (resolvedWindowStyle == static_cast<int>(WindowStyle::kSort)) {
         queryInfo = buildWindowQuery(input, function, overClause, frameClause);
       } else {
@@ -171,12 +175,200 @@ void WindowTestBase::testWindowFunction(
             buildStreamingWindowQuery(input, function, overClause, frameClause);
       }
 
-      SCOPED_TRACE(queryInfo.functionSql);
+      SCOPED_TRACE(fmt::format("Query #{}: {}", n, queryInfo.functionSql));
       assertQuery(queryInfo.planNode, queryInfo.querySql);
     }
   }
 }
 
+void WindowTestBase::testWindowFunction(
+    const std::vector<RowVectorPtr>& input,
+    const std::string& function,
+    const std::string& overClause,
+    const std::string& frameClause,
+    const RowVectorPtr& expectedResult) {
+  auto queryInfo = buildWindowQuery(input, function, overClause, frameClause);
+  SCOPED_TRACE(queryInfo.functionSql);
+  assertQuery(queryInfo.planNode, expectedResult);
+}
+
+void WindowTestBase::rangeFrameTestImpl(
+    bool ascending,
+    const std::string& function,
+    const RangeFrameBound& startBound,
+    const RangeFrameBound& endBound,
+    bool unorderedColumns) {
+  auto size = 25;
+  // For frames with k RANGE PRECEDING/FOLLOWING, Velox requires the application
+  // to add columns with the range frame boundary value computed according
+  // to the frame type.
+  // If the frame is k PRECEDING :
+  // frame_boundary_value = current_order_by - k (for ascending ORDER BY)
+  // frame_boundary_value = current_order_by + k (for descending ORDER BY)
+  // If the frame is k FOLLOWING :
+  // frame_boundary_value = current_order_by + k (for ascending ORDER BY)
+  // frame_boundary_value = current_order_by - k (for descending ORDER BY)
+  auto computeOffset = [&](const RangeFrameBound& frame) -> int64_t {
+    if (frame.bound == BoundType::kCurrentRow) {
+      return 0;
+    }
+    VELOX_CHECK(frame.value.has_value());
+    if (frame.bound == BoundType::kPreceding) {
+      return ascending ? -frame.value.value() : frame.value.value();
+    } else {
+      return ascending ? frame.value.value() : -frame.value.value();
+    }
+  };
+
+  // Compute frame boundary columns for asc/desc ORDER BY.
+  auto offset = computeOffset(startBound);
+  auto startColumn = makeFlatVector<int64_t>(
+      size, [offset](auto row) { return row + offset; });
+  offset = computeOffset(endBound);
+  auto endColumn = makeFlatVector<int64_t>(
+      size, [offset](auto row) { return row + offset; });
+
+  RowVectorPtr vectors;
+  // Velox frames require the column bounds.
+  auto veloxFrameBound = [](const RangeFrameBound& frame,
+                            const std::string& colName) -> std::string {
+    if (frame.bound == BoundType::kCurrentRow) {
+      return "CURRENT ROW";
+    }
+    if (frame.bound == BoundType::kPreceding) {
+      return colName + " PRECEDING";
+    }
+    return colName + " FOLLOWING";
+  };
+  std::string veloxFrame;
+  std::string overClause;
+  if (unorderedColumns) {
+    vectors = makeRowVector({
+        endColumn,
+        startColumn,
+        makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+        makeFlatVector<int32_t>(size, [](auto row) { return row % 5; }),
+    });
+    veloxFrame = "range between " + veloxFrameBound(startBound, "c1") +
+        " and " + veloxFrameBound(endBound, "c0");
+    overClause = "partition by c3 order by c2";
+  } else {
+    vectors = makeRowVector({
+        makeFlatVector<int32_t>(size, [](auto row) { return row % 5; }),
+        makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+        startColumn,
+        endColumn,
+    });
+    veloxFrame = "range between " + veloxFrameBound(startBound, "c2") +
+        " and " + veloxFrameBound(endBound, "c3");
+    overClause = "partition by c0 order by c1";
+  }
+  if (!ascending) {
+    overClause += " desc";
+  }
+  createDuckDbTable({vectors});
+
+  // DuckDB frames uses the constant bounds.
+  auto duckFrameBound = [](const RangeFrameBound& frame) -> std::string {
+    if (frame.bound == BoundType::kCurrentRow) {
+      return "CURRENT ROW";
+    }
+    VELOX_CHECK(frame.value.has_value());
+    if (frame.bound == BoundType::kPreceding) {
+      return fmt::format("{} PRECEDING", frame.value.value());
+    }
+    return fmt::format("{} FOLLOWING", frame.value.value());
+  };
+  std::string duckFrame = "range between " + duckFrameBound(startBound) +
+      " and " + duckFrameBound(endBound);
+
+  std::string veloxFunction =
+      fmt::format("{} over ({} {})", function, overClause, veloxFrame);
+  std::string duckFunction =
+      fmt::format("{} over ({} {})", function, overClause, duckFrame);
+  auto op = PlanBuilder()
+                .setParseOptions(options_)
+                .values({vectors})
+                .window({veloxFunction})
+                .planNode();
+
+  auto rowType = asRowType(vectors->type());
+  std::string columnsString = folly::join(", ", rowType->names());
+  std::string querySql =
+      fmt::format("SELECT {}, {} FROM tmp", columnsString, duckFunction);
+  SCOPED_TRACE(veloxFunction);
+  assertQuery(op, querySql);
+}
+
+void WindowTestBase::rangeFrameTest(
+    bool ascending,
+    const std::string& function,
+    const RangeFrameBound& startBound,
+    const RangeFrameBound& endBound) {
+  rangeFrameTestImpl(ascending, function, startBound, endBound, false);
+  rangeFrameTestImpl(ascending, function, startBound, endBound, true);
+}
+
+void WindowTestBase::testKRangeFrames(const std::string& function) {
+  // RANGE BETWEEN 4 PRECEDING AND 2 FOLLOWING.
+  rangeFrameTest(
+      true, function, {4, BoundType::kPreceding}, {2, BoundType::kFollowing});
+  rangeFrameTest(
+      false, function, {4, BoundType::kPreceding}, {2, BoundType::kFollowing});
+
+  // RANGE BETWEEN 4 PRECEDING AND CURRENT ROW.
+  rangeFrameTest(
+      true,
+      function,
+      {4, BoundType::kPreceding},
+      {std::nullopt, BoundType::kCurrentRow});
+  rangeFrameTest(
+      false,
+      function,
+      {4, BoundType::kPreceding},
+      {std::nullopt, BoundType::kCurrentRow});
+
+  // RANGE BETWEEN 4 PRECEDING AND 2 PRECEDING. There are no rows in that range.
+  // So this tests empty frames.
+  rangeFrameTest(
+      true, function, {4, BoundType::kPreceding}, {2, BoundType::kPreceding});
+  rangeFrameTest(
+      false, function, {4, BoundType::kPreceding}, {2, BoundType::kPreceding});
+
+  // RANGE BETWEEN 6 PRECEDING AND 2 PRECEDING. There is exactly one row in that
+  // range.
+  rangeFrameTest(
+      true, function, {6, BoundType::kPreceding}, {2, BoundType::kPreceding});
+  rangeFrameTest(
+      false, function, {6, BoundType::kPreceding}, {2, BoundType::kPreceding});
+
+  // RANGE BETWEEN 2 FOLLOWING AND 4 FOLLOWING. There are no rows in that range.
+  // So this tests empty frames.
+  rangeFrameTest(
+      true, function, {2, BoundType::kFollowing}, {4, BoundType::kFollowing});
+  rangeFrameTest(
+      false, function, {2, BoundType::kFollowing}, {4, BoundType::kFollowing});
+
+  // RANGE BETWEEN CURRENT ROW AND 4 FOLLOWING.
+  rangeFrameTest(
+      true,
+      function,
+      {std::nullopt, BoundType::kCurrentRow},
+      {4, BoundType::kFollowing});
+  rangeFrameTest(
+      false,
+      function,
+      {std::nullopt, BoundType::kCurrentRow},
+      {4, BoundType::kFollowing});
+
+  // RANGE BETWEEN 2 FOLLOWING AND 6 FOLLOWING. There is exactly one row in that
+  // range.
+  rangeFrameTest(
+      true, function, {2, BoundType::kFollowing}, {6, BoundType::kFollowing});
+  rangeFrameTest(
+      false, function, {2, BoundType::kFollowing}, {6, BoundType::kFollowing});
+}
+
 void WindowTestBase::assertWindowFunctionError(
     const std::vector<RowVectorPtr>& input,
     const std::string& function,
@@ -198,4 +390,4 @@ void WindowTestBase::assertWindowFunctionError(
       assertQuery(queryInfo.planNode, queryInfo.querySql), errorMessage);
 }
 
-}; // namespace facebook::velox::window::test
+} // namespace facebook::velox::window::test
diff --git a/velox/functions/lib/window/tests/WindowTestBase.h b/velox/functions/lib/window/tests/WindowTestBase.h
index 7765d9d4dbd38..50d6124c6f632 100644
--- a/velox/functions/lib/window/tests/WindowTestBase.h
+++ b/velox/functions/lib/window/tests/WindowTestBase.h
@@ -142,7 +142,7 @@ class WindowTestBase : public exec::test::OperatorTestBase {
       const std::string& overClause,
       const std::string& frameClause);
 
-  /// This function tests SQL queries for the window function and
+  /// Tests SQL queries for the window function and
   /// the specified overClauses and frameClauses with the input RowVectors.
   /// Note : 'function' should be a full window function invocation string
   /// including input parameters and open/close braces. e.g. rank(), ntile(5).
@@ -157,7 +157,16 @@ class WindowTestBase : public exec::test::OperatorTestBase {
       bool createTable = true,
       WindowStyle windowStyle = WindowStyle::kRandom);
 
-  /// This function tests the SQL query for the window function and overClause
+  /// Tests the window function with the {overClause, frameClause} pair and
+  /// asserts that the result is equal to expectedResult.
+  void testWindowFunction(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& function,
+      const std::string& overClause,
+      const std::string& frameClause,
+      const RowVectorPtr& expectedResult);
+
+  /// Tests the SQL query for the window function and overClause
   /// combination with the input RowVectors. It is expected that query execution
   /// will throw an exception with the errorMessage specified.
   void assertWindowFunctionError(
@@ -166,7 +175,7 @@ class WindowTestBase : public exec::test::OperatorTestBase {
       const std::string& overClause,
       const std::string& errorMessage);
 
-  /// This function tests the SQL query for the window function, overClause,
+  /// Tests the SQL query for the window function, overClause,
   /// and frameClause combination with the input RowVectors. It is expected that
   /// query execution will throw an exception with the errorMessage specified.
   void assertWindowFunctionError(
@@ -176,9 +185,38 @@ class WindowTestBase : public exec::test::OperatorTestBase {
       const std::string& frameClause,
       const std::string& errorMessage);
 
+  /// Tests different combinations of k range frame columns.
+  /// These are special as they require generating frame bound value columns.
+  void testKRangeFrames(const std::string& function);
+
   /// ParseOptions for the DuckDB Parser. nth_value in Spark expects to parse
-  /// integer as bigint vs bigint in Presto. The default is to parse integer
+  /// integer as int vs bigint in Presto. The default is to parse integer
   /// as bigint (Presto behavior).
   parse::ParseOptions options_;
+
+ private:
+  enum class BoundType {
+    kPreceding,
+    kFollowing,
+    kCurrentRow,
+  };
+
+  struct RangeFrameBound {
+    std::optional<int64_t> value;
+    BoundType bound;
+  };
+
+  void rangeFrameTest(
+      bool ascending,
+      const std::string& function,
+      const RangeFrameBound& startBound,
+      const RangeFrameBound& endBound);
+
+  void rangeFrameTestImpl(
+      bool ascending,
+      const std::string& function,
+      const RangeFrameBound& startBound,
+      const RangeFrameBound& endBound,
+      bool unorderedColumns);
 };
-}; // namespace facebook::velox::window::test
+} // namespace facebook::velox::window::test
diff --git a/velox/functions/prestosql/Arithmetic.h b/velox/functions/prestosql/Arithmetic.h
index 552d8a9cf26eb..7d3c44d894c40 100644
--- a/velox/functions/prestosql/Arithmetic.h
+++ b/velox/functions/prestosql/Arithmetic.h
@@ -24,8 +24,10 @@
 #include <functional>
 #include <limits>
 #include <system_error>
+#include <type_traits>
 
 #include "folly/CPortability.h"
+#include "velox/common/base/Doubles.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/prestosql/ArithmeticImpl.h"
@@ -34,6 +36,8 @@ namespace facebook::velox::functions {
 
 inline constexpr int kMinRadix = 2;
 inline constexpr int kMaxRadix = 36;
+inline constexpr long kLongMax = std::numeric_limits<int64_t>::max();
+inline constexpr long kLongMin = std::numeric_limits<int64_t>::min();
 
 inline constexpr char digits[36] = {
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',
@@ -69,6 +73,40 @@ struct MultiplyFunction {
   }
 };
 
+// Multiply function for IntervalDayTime * Double and Double * IntervalDayTime.
+template <typename T>
+struct IntervalMultiplyFunction {
+  FOLLY_ALWAYS_INLINE double sanitizeInput(double d) {
+    if UNLIKELY (std::isnan(d)) {
+      return 0;
+    }
+    return d;
+  }
+
+  template <
+      typename T1,
+      typename T2,
+      typename = std::enable_if_t<
+          (std::is_same_v<T1, int64_t> && std::is_same_v<T2, double>) ||
+          (std::is_same_v<T1, double> && std::is_same_v<T2, int64_t>)>>
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, T1 a, T2 b) {
+    double resultDouble;
+    if constexpr (std::is_same_v<T1, double>) {
+      resultDouble = sanitizeInput(a) * b;
+    } else {
+      resultDouble = sanitizeInput(b) * a;
+    }
+
+    if LIKELY (
+        std::isfinite(resultDouble) && resultDouble >= kLongMin &&
+        resultDouble <= kMaxDoubleBelowInt64Max) {
+      result = int64_t(resultDouble);
+    } else {
+      result = resultDouble > 0 ? kLongMax : kLongMin;
+    }
+  }
+};
+
 template <typename T>
 struct DivideFunction {
   template <typename TInput>
@@ -85,6 +123,32 @@ struct DivideFunction {
   }
 };
 
+template <typename T>
+struct IntervalDivideFunction {
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, int64_t a, double b)
+// Depend on compiler have correct behaviour for divide by zero
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("float-divide-by-zero")))
+      __attribute__((__no_sanitize__("float-cast-overflow")))
+#endif
+#endif
+  {
+    if UNLIKELY (a == 0 || std::isnan(b) || !std::isfinite(b)) {
+      result = 0;
+      return;
+    }
+    double resultDouble = a / b;
+    if LIKELY (
+        std::isfinite(resultDouble) && resultDouble >= kLongMin &&
+        resultDouble <= kMaxDoubleBelowInt64Max) {
+      result = int64_t(resultDouble);
+    } else {
+      result = resultDouble > 0 ? kLongMax : kLongMin;
+    }
+  }
+};
+
 template <typename T>
 struct ModulusFunction {
   template <typename TInput>
@@ -118,14 +182,31 @@ struct FloorFunction {
   }
 };
 
-template <typename T>
+template <typename TExec>
 struct AbsFunction {
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE void call(TInput& result, const TInput& a) {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void call(T& result, const T& a) {
     result = abs(a);
   }
 };
 
+template <typename TExec>
+struct DecimalAbsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<ShortDecimal<P1, S1>>& result,
+      const arg_type<ShortDecimal<P1, S1>>& a) {
+    result = (a < 0) ? -a : a;
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<LongDecimal<P1, S1>>& result,
+      const arg_type<LongDecimal<P1, S1>>& a) {
+    result = (a < 0) ? -a : a;
+  }
+};
+
 template <typename T>
 struct NegateFunction {
   template <typename TInput>
@@ -320,7 +401,8 @@ struct WidthBucketFunction {
       result = bucketCount + 1;
     } else {
       result =
-          (int64_t)((double)bucketCount * (operand - lower) / (upper - lower) + 1);
+          (int64_t)((double)bucketCount * (operand - lower) / (upper - lower) +
+                    1);
     }
 
     if (bound1 > bound2) {
@@ -369,7 +451,7 @@ struct InfinityFunction {
 template <typename T>
 struct IsFiniteFunction {
   FOLLY_ALWAYS_INLINE void call(bool& result, double a) {
-    result = !std::isinf(a);
+    result = std::isfinite(a);
   }
 };
 
@@ -498,15 +580,23 @@ struct EulerConstantFunction {
   }
 };
 
-template <typename T>
+template <typename TExec>
 struct TruncateFunction {
   FOLLY_ALWAYS_INLINE void call(double& result, double a) {
     result = std::trunc(a);
   }
 
+  FOLLY_ALWAYS_INLINE void call(float& result, float a) {
+    result = std::trunc(a);
+  }
+
   FOLLY_ALWAYS_INLINE void call(double& result, double a, int32_t n) {
     result = truncate(a, n);
   }
+
+  FOLLY_ALWAYS_INLINE void call(float& result, float a, int32_t n) {
+    result = truncate(a, n);
+  }
 };
 
 template <typename T>
@@ -531,5 +621,56 @@ struct WilsonIntervalLowerFunction {
   }
 };
 
+template <typename T>
+struct CosineSimilarityFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  double normalizeMap(const null_free_arg_type<Map<Varchar, double>>& map) {
+    double norm = 0.0;
+    for (const auto& [key, value] : map) {
+      norm += (value * value);
+    }
+    return std::sqrt(norm);
+  }
+
+  double mapDotProduct(
+      const null_free_arg_type<Map<Varchar, double>>& leftMap,
+      const null_free_arg_type<Map<Varchar, double>>& rightMap) {
+    double result = 0.0;
+    for (const auto& [key, value] : leftMap) {
+      auto it = rightMap.find(key);
+      if (it != rightMap.end()) {
+        result += value * it->second;
+      }
+    }
+    return result;
+  }
+
+  void callNullFree(
+      out_type<double>& result,
+      const null_free_arg_type<Map<Varchar, double>>& leftMap,
+      const null_free_arg_type<Map<Varchar, double>>& rightMap) {
+    if (leftMap.empty() || rightMap.empty()) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+
+    double normLeftMap = normalizeMap(leftMap);
+    if (normLeftMap == 0.0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+
+    double normRightMap = normalizeMap(rightMap);
+    if (normRightMap == 0.0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+
+    double dotProduct = mapDotProduct(leftMap, rightMap);
+    result = dotProduct / (normLeftMap * normRightMap);
+  }
+};
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArithmeticImpl.h b/velox/functions/prestosql/ArithmeticImpl.h
index 11fe000d7265d..2e9bb325f668c 100644
--- a/velox/functions/prestosql/ArithmeticImpl.h
+++ b/velox/functions/prestosql/ArithmeticImpl.h
@@ -19,13 +19,19 @@
 #include <cmath>
 #include <type_traits>
 #include "folly/CPortability.h"
-#include "velox/type/DoubleUtil.h"
+#include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::functions {
 
 /// Round function
-/// when AlwaysRoundNegDec is false, presto semantics is followed which does not
+/// When AlwaysRoundNegDec is false, presto semantics is followed which does not
 /// round negative decimals for integrals and round it otherwise
+/// Note that is is likely techinically impossible for this function to return
+/// expected results in all cases as the loss of precision plagues it on both
+/// paths: factor multiplication for large numbers and addition of truncated
+/// number to the rounded fraction for small numbers.
+/// We are trying to minimize the loss of precision by using the best path for
+/// the number, but the journey is likely not over yet.
 template <typename TNum, typename TDecimals, bool alwaysRoundNegDec = false>
 FOLLY_ALWAYS_INLINE TNum
 round(const TNum& number, const TDecimals& decimals = 0) {
@@ -43,11 +49,45 @@ round(const TNum& number, const TDecimals& decimals = 0) {
     return number;
   }
 
-  double factor = std::pow(10, decimals);
-  if (number < 0) {
-    return (std::round(number * factor * -1) / factor) * -1;
+  // If we just need to get rid of all the decimals.
+  if (decimals == 0) {
+    return std::round(number);
   }
-  return std::round(number * factor) / factor;
+
+  // For negative 'decimals', we aren't going to lose any precision - we divide
+  // first (multiply by factor which is < 1.0).
+  if (decimals < 0) {
+    const double factor = std::pow(10, decimals);
+    return std::round(number * factor) / factor;
+  }
+
+  // Get the fraction part and return number 'as is' if fraction part is 0.
+  const TNum trancated = std::trunc(number);
+  const TNum fraction = number - trancated;
+  if (fraction == 0.0)
+    return number;
+
+  const double factor = std::pow(10, decimals);
+
+  // Smaller numbers are less affected by precision loss being multiplied by the
+  // factor, but more affected by precision loss by adding truncated number to
+  // the rounded fraction in the end. Because of that, we use factor
+  // multiplication path on the smaller numbers.
+  // The threshold is a somewhat arbitrary/empirical number taking up 44 bits in
+  // the integer form.
+  if constexpr (!std::is_integral_v<TNum>) {
+    if (fabs(number) < 17592186044415) {
+      return std::round(number * factor) / factor;
+    }
+  }
+
+  // We implement the algorithm below for positive 'decimals' nd the large
+  // numbers because on the large numbers we would have precision loss when
+  // multiplying number by the factor, which would lose or gain some [power of
+  // 2] whole units.
+
+  const TNum roundedFractions = std::round(fraction * factor) / factor;
+  return trancated + roundedFractions;
 }
 
 // This is used by Velox for floating points plus.
@@ -133,16 +173,14 @@ T ceil(const T& arg) {
   return results;
 }
 
-FOLLY_ALWAYS_INLINE double truncate(
-    const double& number,
-    const int32_t& decimals = 0) {
+FOLLY_ALWAYS_INLINE double truncate(double number, int32_t decimals) {
   const bool decNegative = (decimals < 0);
   const auto log10Size = DoubleUtil::kPowersOfTen.size(); // 309
   if (decNegative && decimals <= -log10Size) {
     return 0.0;
   }
 
-  const uint64_t absDec = decNegative ? -decimals : decimals;
+  const uint64_t absDec = std::abs(decimals);
   const double tmp = (absDec < log10Size) ? DoubleUtil::kPowersOfTen[absDec]
                                           : std::pow(10.0, (double)absDec);
 
diff --git a/velox/functions/prestosql/ArrayAndMapMatch.cpp b/velox/functions/prestosql/ArrayAndMapMatch.cpp
index 0e84fcaf083b5..873fb41f81553 100644
--- a/velox/functions/prestosql/ArrayAndMapMatch.cpp
+++ b/velox/functions/prestosql/ArrayAndMapMatch.cpp
@@ -36,16 +36,6 @@ class MatchFunction : public exec::VectorFunction {
   virtual const VectorPtr& lambdaArgument(
       const std::shared_ptr<TContainer>& flatContainer) const = 0;
 
-  bool isDefaultNullBehavior() const override {
-    // Match functions are null preserving for the array/map argument, but
-    // predicate expression may use other fields and may not preserve nulls in
-    // these.
-    //
-    // For example, all_match(array[1, 2, 3], x -> x > coalesce(a, 0)) should
-    // not return null when 'a' is null.
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -77,7 +67,7 @@ class MatchFunction : public exec::VectorFunction {
       auto wrapCapture = toWrapCapture<TContainer>(
           numElements, entry.callable, *entry.rows, flatContainer);
 
-      ErrorVectorPtr elementErrors;
+      exec::EvalErrorsPtr elementErrors;
       entry.callable->applyNoThrow(
           elementRows,
           nullptr, // No need to preserve any values in 'matchBits'.
@@ -105,19 +95,13 @@ class MatchFunction : public exec::VectorFunction {
     }
   }
 
-  static FOLLY_ALWAYS_INLINE bool hasError(
-      const ErrorVectorPtr& errors,
-      vector_size_t row) {
-    return errors && row < errors->size() && !errors->isNullAt(row);
-  }
-
   void applyInternal(
       FlatVector<bool>& flatResult,
       exec::EvalCtx& context,
       vector_size_t arrayRow,
       vector_size_t offset,
       vector_size_t size,
-      const ErrorVectorPtr& elementErrors,
+      const exec::EvalErrorsPtr& elementErrors,
       const exec::LocalDecodedVector& bitsDecoder) const {
     // all_match, none_match and any_match need to loop over predicate results
     // for element arrays and check for results, nulls and errors.
@@ -187,10 +171,11 @@ class MatchFunction : public exec::VectorFunction {
     std::exception_ptr errorPtr{nullptr};
     for (auto i = 0; i < size; ++i) {
       auto idx = offset + i;
-      if (hasError(elementErrors, idx)) {
-        errorPtr = *std::static_pointer_cast<std::exception_ptr>(
-            elementErrors->valueAt(idx));
-        continue;
+      if (elementErrors) {
+        if (auto error = elementErrors->errorAt(idx)) {
+          errorPtr = *error.value();
+          continue;
+        }
       }
 
       if (bitsDecoder->isNullAt(idx)) {
@@ -309,44 +294,59 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> valuesSignatures() {
 
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+/// Match functions are null preserving for the array/map argument, but
+/// predicate expression may use other fields and may not preserve nulls in
+/// these.
+///
+/// For example, all_match(array[1, 2, 3], x -> x > coalesce(a, 0)) should
+/// not return null when 'a' is null.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_all_match,
     signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<AllMatchFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_any_match,
     signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<AnyMatchFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_none_match,
     signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<NoneMatchFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_all_keys_match,
     keysSignatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<AllKeysMatchFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_any_keys_match,
     keysSignatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<AnyKeysMatchFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_no_keys_match,
     keysSignatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<NoKeysMatchFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_any_values_match,
     valuesSignatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<AnyValuesMatchFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_no_values_match,
     valuesSignatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<NoValuesMatchFunction>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArrayConstructor.cpp b/velox/functions/prestosql/ArrayConstructor.cpp
index 37902a86d5c46..3dccc36707eb6 100644
--- a/velox/functions/prestosql/ArrayConstructor.cpp
+++ b/velox/functions/prestosql/ArrayConstructor.cpp
@@ -22,10 +22,6 @@ namespace {
 
 class ArrayConstructor : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -95,11 +91,11 @@ class ArrayConstructor : public exec::VectorFunction {
         for (int i = 1; i < numArgs; i++) {
           targetRows.clearAll();
 
-          vector_size_t offset = baseOffset;
+          vector_size_t offset_2 = baseOffset;
           rows.applyToSelected([&](vector_size_t row) {
-            targetRows.setValid(offset + i, true);
-            toSourceRow[offset + i] = row;
-            offset += numArgs;
+            targetRows.setValid(offset_2 + i, true);
+            toSourceRow[offset_2 + i] = row;
+            offset_2 += numArgs;
           });
 
           targetRows.updateBounds();
@@ -117,8 +113,7 @@ class ArrayConstructor : public exec::VectorFunction {
         exec::FunctionSignatureBuilder()
             .typeVariable("T")
             .returnType("array(T)")
-            .argumentType("T")
-            .variableArity()
+            .variableArity("T")
             .build(),
     };
   }
@@ -147,9 +142,10 @@ class ArrayConstructor : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_array_constructor,
     ArrayConstructor::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<ArrayConstructor>());
 
 void registerArrayConstructor(const std::string& name) {
diff --git a/velox/functions/prestosql/ArrayContains.cpp b/velox/functions/prestosql/ArrayContains.cpp
index aeb9b397f9adf..27306ecad4f08 100644
--- a/velox/functions/prestosql/ArrayContains.cpp
+++ b/velox/functions/prestosql/ArrayContains.cpp
@@ -14,18 +14,30 @@
  * limitations under the License.
  */
 #include "velox/expression/VectorFunction.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/vector/DecodedVector.h"
 
 namespace facebook::velox::functions {
 namespace {
 
+template <typename T>
+inline bool isPrimitiveEqual(const T& lhs, const T& rhs) {
+  if constexpr (std::is_floating_point_v<T>) {
+    return util::floating_point::NaNAwareEquals<T>{}(lhs, rhs);
+  } else {
+    return lhs == rhs;
+  }
+}
+
 template <TypeKind kind>
 void applyTyped(
     const SelectivityVector& rows,
     DecodedVector& arrayDecoded,
     DecodedVector& elementsDecoded,
     DecodedVector& searchDecoded,
-    FlatVector<bool>& flatResult) {
+    exec::EvalCtx& /*context*/,
+    FlatVector<bool>& flatResult,
+    bool /*throwOnNestedNull*/) {
   using T = typename TypeTraits<kind>::NativeType;
 
   auto baseArray = arrayDecoded.base()->as<ArrayVector>();
@@ -45,12 +57,11 @@ void applyTyped(
       auto offset = rawOffsets[indices[row]];
 
       for (auto i = 0; i < size; i++) {
-        if (rawElements[offset + i] == search) {
+        if (isPrimitiveEqual<T>(rawElements[offset + i], search)) {
           flatResult.set(row, true);
           return;
         }
       }
-
       flatResult.set(row, false);
     });
   } else {
@@ -65,7 +76,8 @@ void applyTyped(
       for (auto i = 0; i < size; i++) {
         if (elementsDecoded.isNullAt(offset + i)) {
           foundNull = true;
-        } else if (elementsDecoded.valueAt<T>(offset + i) == search) {
+        } else if (isPrimitiveEqual<T>(
+                       elementsDecoded.valueAt<T>(offset + i), search)) {
           flatResult.set(row, true);
           return;
         }
@@ -85,7 +97,9 @@ void applyComplexType(
     DecodedVector& arrayDecoded,
     DecodedVector& elementsDecoded,
     DecodedVector& searchDecoded,
-    FlatVector<bool>& flatResult) {
+    exec::EvalCtx& context,
+    FlatVector<bool>& flatResult,
+    bool throwOnNestedNull) {
   auto baseArray = arrayDecoded.base()->as<ArrayVector>();
   auto rawSizes = baseArray->rawSizes();
   auto rawOffsets = baseArray->rawOffsets();
@@ -96,20 +110,32 @@ void applyComplexType(
   auto searchBase = searchDecoded.base();
   auto searchIndices = searchDecoded.indices();
 
-  rows.applyToSelected([&](auto row) {
+  const auto nullHandlingMode = throwOnNestedNull
+      ? CompareFlags::NullHandlingMode::kNullAsIndeterminate
+      : CompareFlags::NullHandlingMode::kNullAsValue;
+
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
     auto size = rawSizes[indices[row]];
     auto offset = rawOffsets[indices[row]];
-
     bool foundNull = false;
-
     auto searchIndex = searchIndices[row];
+
     for (auto i = 0; i < size; i++) {
       if (elementsDecoded.isNullAt(offset + i)) {
         foundNull = true;
-      } else if (elementsBase->equalValueAt(
-                     searchBase, elementIndices[offset + i], searchIndex)) {
-        flatResult.set(row, true);
-        return;
+      } else {
+        std::optional<bool> result = elementsBase->equalValueAt(
+            searchBase,
+            elementIndices[offset + i],
+            searchIndex,
+            nullHandlingMode);
+        VELOX_USER_CHECK(
+            result.has_value(),
+            "contains does not support arrays with elements that contain null");
+        if (result.value()) {
+          flatResult.set(row, true);
+          return;
+        }
       }
     }
 
@@ -127,9 +153,17 @@ void applyTyped<TypeKind::ARRAY>(
     DecodedVector& arrayDecoded,
     DecodedVector& elementsDecoded,
     DecodedVector& searchDecoded,
-    FlatVector<bool>& flatResult) {
+    exec::EvalCtx& context,
+    FlatVector<bool>& flatResult,
+    bool throwOnNestedNull) {
   applyComplexType(
-      rows, arrayDecoded, elementsDecoded, searchDecoded, flatResult);
+      rows,
+      arrayDecoded,
+      elementsDecoded,
+      searchDecoded,
+      context,
+      flatResult,
+      throwOnNestedNull);
 }
 
 template <>
@@ -138,9 +172,17 @@ void applyTyped<TypeKind::MAP>(
     DecodedVector& arrayDecoded,
     DecodedVector& elementsDecoded,
     DecodedVector& searchDecoded,
-    FlatVector<bool>& flatResult) {
+    exec::EvalCtx& context,
+    FlatVector<bool>& flatResult,
+    bool throwOnNestedNull) {
   applyComplexType(
-      rows, arrayDecoded, elementsDecoded, searchDecoded, flatResult);
+      rows,
+      arrayDecoded,
+      elementsDecoded,
+      searchDecoded,
+      context,
+      flatResult,
+      throwOnNestedNull);
 }
 
 template <>
@@ -149,13 +191,24 @@ void applyTyped<TypeKind::ROW>(
     DecodedVector& arrayDecoded,
     DecodedVector& elementsDecoded,
     DecodedVector& searchDecoded,
-    FlatVector<bool>& flatResult) {
+    exec::EvalCtx& context,
+    FlatVector<bool>& flatResult,
+    bool throwOnNestedNull) {
   applyComplexType(
-      rows, arrayDecoded, elementsDecoded, searchDecoded, flatResult);
+      rows,
+      arrayDecoded,
+      elementsDecoded,
+      searchDecoded,
+      context,
+      flatResult,
+      throwOnNestedNull);
 }
 
 class ArrayContainsFunction : public exec::VectorFunction {
  public:
+  explicit ArrayContainsFunction(bool throwOnNestedNull)
+      : throwOnNestedNull_(throwOnNestedNull) {}
+
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -191,7 +244,9 @@ class ArrayContainsFunction : public exec::VectorFunction {
         *arrayHolder.get(),
         *elementsHolder.get(),
         *searchHolder.get(),
-        *flatResult);
+        context,
+        *flatResult,
+        throwOnNestedNull_);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -203,6 +258,9 @@ class ArrayContainsFunction : public exec::VectorFunction {
                 .argumentType("T")
                 .build()};
   }
+
+ private:
+  bool throwOnNestedNull_;
 };
 
 } // namespace
@@ -210,6 +268,13 @@ class ArrayContainsFunction : public exec::VectorFunction {
 VELOX_DECLARE_VECTOR_FUNCTION(
     udf_array_contains,
     ArrayContainsFunction::signatures(),
-    std::make_unique<ArrayContainsFunction>());
+    std::make_unique<ArrayContainsFunction>(true));
+
+// Internal function only used for testing. This function allows the array to
+// have null elements and considers null as a value, i.e., null == null.
+VELOX_DECLARE_VECTOR_FUNCTION(
+    udf_$internal$contains,
+    ArrayContainsFunction::signatures(),
+    std::make_unique<ArrayContainsFunction>(false));
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArrayDistinct.cpp b/velox/functions/prestosql/ArrayDistinct.cpp
index 81525b3711b04..0ac831285f45e 100644
--- a/velox/functions/prestosql/ArrayDistinct.cpp
+++ b/velox/functions/prestosql/ArrayDistinct.cpp
@@ -14,16 +14,62 @@
  * limitations under the License.
  */
 
-#include <folly/container/F14Set.h>
-
 #include "velox/expression/EvalCtx.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::functions {
 namespace {
 
+template <typename T>
+struct ValueSet {
+  util::floating_point::HashSetNaNAware<T> values;
+
+  bool insert(const T& value) {
+    return values.insert(value).second;
+  }
+
+  void reset() {
+    values.clear();
+  }
+};
+
+template <>
+struct ValueSet<ComplexType> {
+  using TKey = std::tuple<uint64_t, const BaseVector*, vector_size_t>;
+
+  struct Hash {
+    size_t operator()(const TKey& key) const {
+      return std::get<0>(key);
+    }
+  };
+
+  struct EqualTo {
+    bool operator()(const TKey& left, const TKey& right) const {
+      return std::get<1>(left)
+          ->equalValueAt(
+              std::get<1>(right),
+              std::get<2>(left),
+              std::get<2>(right),
+              CompareFlags::NullHandlingMode::kNullAsValue)
+          .value();
+    }
+  };
+
+  folly::F14FastSet<TKey, Hash, EqualTo> values;
+
+  bool insert(const BaseVector* vector, vector_size_t index) {
+    const uint64_t hash = vector->hashValueAt(index);
+    return values.insert(std::make_tuple(hash, vector, index)).second;
+  }
+
+  void reset() {
+    values.clear();
+  }
+};
+
 /// See documentation at https://prestodb.io/docs/current/functions/array.html
 ///
 /// array_distinct SQL function.
@@ -93,17 +139,17 @@ class ArrayDistinctFunction : public exec::VectorFunction {
     // Pointers and cursors to the raw data.
     vector_size_t indicesCursor = 0;
     auto* rawNewIndices = newIndices->asMutable<vector_size_t>();
-    auto* rawSizes = newLengths->asMutable<vector_size_t>();
-    auto* rawOffsets = newOffsets->asMutable<vector_size_t>();
+    auto* rawNewSizes = newLengths->asMutable<vector_size_t>();
+    auto* rawNewOffsets = newOffsets->asMutable<vector_size_t>();
 
     // Process the rows: store unique values in the hash table.
-    folly::F14FastSet<T> uniqueSet;
+    ValueSet<T> uniqueSet;
 
     rows.applyToSelected([&](vector_size_t row) {
       auto size = arrayVector->sizeAt(row);
       auto offset = arrayVector->offsetAt(row);
 
-      rawOffsets[row] = indicesCursor;
+      rawNewOffsets[row] = indicesCursor;
       bool hasNulls = false;
       for (vector_size_t i = offset; i < offset + size; ++i) {
         if (elements->isNullAt(i)) {
@@ -112,16 +158,22 @@ class ArrayDistinctFunction : public exec::VectorFunction {
             rawNewIndices[indicesCursor++] = i;
           }
         } else {
-          auto value = elements->valueAt<T>(i);
+          bool unique;
+          if constexpr (std::is_same_v<ComplexType, T>) {
+            unique = uniqueSet.insert(elements->base(), elements->index(i));
+          } else {
+            auto value = elements->valueAt<T>(i);
+            unique = uniqueSet.insert(value);
+          }
 
-          if (uniqueSet.insert(value).second) {
+          if (unique) {
             rawNewIndices[indicesCursor++] = i;
           }
         }
       }
 
-      uniqueSet.clear();
-      rawSizes[row] = indicesCursor - rawOffsets[row];
+      uniqueSet.reset();
+      rawNewSizes[row] = indicesCursor - rawNewOffsets[row];
     });
 
     newIndices->setSize(indicesCursor * sizeof(vector_size_t));
@@ -140,6 +192,58 @@ class ArrayDistinctFunction : public exec::VectorFunction {
   }
 };
 
+template <>
+VectorPtr ArrayDistinctFunction<UnknownType>::applyFlat(
+    const SelectivityVector& rows,
+    const VectorPtr& arg,
+    exec::EvalCtx& context) const {
+  auto arrayVector = arg->as<ArrayVector>();
+  auto elementsVector = arrayVector->elements();
+  vector_size_t rowCount = rows.end();
+
+  // Allocate new vectors for indices, length and offsets.
+  memory::MemoryPool* pool = context.pool();
+  BufferPtr newIndices = allocateIndices(rowCount, pool);
+  BufferPtr newLengths = allocateSizes(rowCount, pool);
+  BufferPtr newOffsets = allocateOffsets(rowCount, pool);
+
+  // Pointers and cursors to the raw data.
+  vector_size_t indicesCursor = 0;
+  auto* rawNewIndices = newIndices->asMutable<vector_size_t>();
+  auto* rawNewSizes = newLengths->asMutable<vector_size_t>();
+  auto* rawNewOffsets = newOffsets->asMutable<vector_size_t>();
+
+  rows.applyToSelected([&](vector_size_t row) {
+    auto size = arrayVector->sizeAt(row);
+    auto offset = arrayVector->offsetAt(row);
+
+    rawNewOffsets[row] = indicesCursor;
+    if (size > 0) {
+      if (FOLLY_UNLIKELY(indicesCursor == 0)) {
+        rawNewIndices[0] = offset;
+      }
+      rawNewSizes[row] = 1;
+      rawNewIndices[indicesCursor++] = rawNewIndices[0];
+    } else {
+      rawNewSizes[row] = 0;
+    }
+  });
+
+  newIndices->setSize(indicesCursor * sizeof(vector_size_t));
+  auto newElements =
+      BaseVector::transpose(newIndices, std::move(elementsVector));
+
+  return std::make_shared<ArrayVector>(
+      pool,
+      arrayVector->type(),
+      nullptr,
+      rowCount,
+      std::move(newOffsets),
+      std::move(newLengths),
+      std::move(newElements),
+      0);
+}
+
 // Validate number of parameters and types.
 void validateType(const std::vector<exec::VectorFunctionArg>& inputArgs) {
   VELOX_USER_CHECK_EQ(
@@ -169,6 +273,13 @@ std::shared_ptr<exec::VectorFunction> create(
     const core::QueryConfig& /*config*/) {
   validateType(inputArgs);
   auto elementType = inputArgs.front().type->childAt(0);
+  if (elementType->isUnKnown()) {
+    return std::make_shared<ArrayDistinctFunction<UnknownType>>();
+  }
+
+  if (elementType->isArray() || elementType->isMap() || elementType->isRow()) {
+    return std::make_shared<ArrayDistinctFunction<ComplexType>>();
+  }
 
   return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
       createTyped, elementType->kind(), inputArgs);
@@ -177,14 +288,13 @@ std::shared_ptr<exec::VectorFunction> create(
 // Define function signature.
 std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
   // array(T) -> array(T)
-  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
-  for (const auto& type : exec::primitiveTypeNames()) {
-    signatures.push_back(exec::FunctionSignatureBuilder()
-                             .returnType(fmt::format("array({})", type))
-                             .argumentType(fmt::format("array({})", type))
-                             .build());
-  }
-  return signatures;
+  return std::vector<std::shared_ptr<exec::FunctionSignature>>{
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("array(T)")
+          .argumentType("array(T)")
+          .build(),
+  };
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/ArrayFunctions.h b/velox/functions/prestosql/ArrayFunctions.h
index 64e4a31622416..adc96d1b7025b 100644
--- a/velox/functions/prestosql/ArrayFunctions.h
+++ b/velox/functions/prestosql/ArrayFunctions.h
@@ -15,10 +15,14 @@
  */
 #pragma once
 
+#include <type_traits>
+
 #include "velox/expression/ComplexViewTypes.h"
+#include "velox/expression/PrestoCastHooks.h"
 #include "velox/functions/Udf.h"
-#include "velox/functions/prestosql/CheckedArithmetic.h"
+#include "velox/functions/lib/CheckedArithmetic.h"
 #include "velox/type/Conversions.h"
+#include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::functions {
 
@@ -26,15 +30,31 @@ template <typename TExecCtx, bool isMax>
 struct ArrayMinMaxFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExecCtx);
 
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
   template <typename T>
   void update(T& currentValue, const T& candidateValue) {
-    if constexpr (isMax) {
-      if (candidateValue > currentValue) {
-        currentValue = candidateValue;
+    if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+      if constexpr (isMax) {
+        if (util::floating_point::NaNAwareGreaterThan<T>{}(
+                candidateValue, currentValue)) {
+          currentValue = candidateValue;
+        }
+      } else {
+        if (util::floating_point::NaNAwareLessThan<T>{}(
+                candidateValue, currentValue)) {
+          currentValue = candidateValue;
+        }
       }
     } else {
-      if (candidateValue < currentValue) {
-        currentValue = candidateValue;
+      if constexpr (isMax) {
+        if (candidateValue > currentValue) {
+          currentValue = candidateValue;
+        }
+      } else {
+        if (candidateValue < currentValue) {
+          currentValue = candidateValue;
+        }
       }
     }
   }
@@ -45,11 +65,7 @@ struct ArrayMinMaxFunction {
   }
 
   void assign(out_type<Varchar>& out, const arg_type<Varchar>& value) {
-    // TODO: reuse strings once support landed.
-    out.resize(value.size());
-    if (value.size() != 0) {
-      std::memcpy(out.data(), value.data(), value.size());
-    }
+    out.setNoCopy(value);
   }
 
   template <typename TReturn, typename TInput>
@@ -88,6 +104,51 @@ struct ArrayMinMaxFunction {
     assign(out, currentValue);
     return true;
   }
+
+  bool compare(
+      exec::GenericView currentValue,
+      exec::GenericView candidateValue) {
+    static constexpr CompareFlags kFlags = {
+        .nullHandlingMode =
+            CompareFlags::NullHandlingMode::kNullAsIndeterminate};
+
+    // We'll either get a result or throw.
+    auto compareResult = candidateValue.compare(currentValue, kFlags).value();
+    if constexpr (isMax) {
+      return compareResult > 0;
+    } else {
+      return compareResult < 0;
+    }
+  }
+
+  bool call(
+      out_type<Orderable<T1>>& out,
+      const arg_type<Array<Orderable<T1>>>& array) {
+    // Result is null if array is empty.
+    if (array.size() == 0) {
+      return false;
+    }
+
+    // Result is null if any element is null.
+    if (!array[0].has_value()) {
+      return false;
+    }
+
+    int currentIndex = 0;
+    for (auto i = 1; i < array.size(); i++) {
+      if (!array[i].has_value()) {
+        return false;
+      }
+
+      auto currentValue = array[currentIndex].value();
+      auto candidateValue = array[i].value();
+      if (compare(currentValue, candidateValue)) {
+        currentIndex = i;
+      }
+    }
+    out.copy_from(array[currentIndex].value());
+    return true;
+  }
 };
 
 template <typename TExecCtx>
@@ -100,9 +161,50 @@ template <typename TExecCtx, typename T>
 struct ArrayJoinFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExecCtx);
 
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      const arg_type<velox::Array<T>>* /*arr*/,
+      const arg_type<Varchar>* /*delimiter*/) {
+    initialize(inputTypes, config, nullptr, nullptr, nullptr);
+  }
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      const arg_type<velox::Array<T>>* /*arr*/,
+      const arg_type<Varchar>* /*delimiter*/,
+      const arg_type<Varchar>* /*nullReplacement*/) {
+    const exec::PrestoCastHooks hooks{config};
+    options_ = hooks.timestampToStringOptions();
+    VELOX_CHECK(
+        inputTypes[0]->isArray(),
+        "Array join's first parameter type has to be array");
+    arrayElementType_ = inputTypes[0]->asArray().elementType();
+  }
+
   template <typename C>
   void writeValue(out_type<velox::Varchar>& result, const C& value) {
-    result += util::Converter<TypeKind::VARCHAR, void, false>::cast(value);
+    // To VARCHAR converter never throws.
+    result += util::Converter<TypeKind::VARCHAR>::tryCast(value).value();
+  }
+
+  void writeValue(out_type<velox::Varchar>& result, const int32_t& value) {
+    if (arrayElementType_->isDate()) {
+      result += util::Converter<TypeKind::VARCHAR>::tryCast(
+                    DateType::get()->toString(value))
+                    .value();
+      return;
+    }
+    result += util::Converter<TypeKind::VARCHAR>::tryCast(value).value();
+  }
+
+  void writeValue(out_type<velox::Varchar>& result, const Timestamp& value) {
+    Timestamp inputValue{value};
+    if (options_.timeZone) {
+      inputValue.toTimezone(*(options_.timeZone));
+    }
+    result += inputValue.toString(options_);
   }
 
   template <typename C>
@@ -153,6 +255,10 @@ struct ArrayJoinFunction {
     createOutputString(result, inputArray, delim, nullReplacement.getString());
     return true;
   }
+
+ private:
+  TimestampToStringOptions options_;
+  TypePtr arrayElementType_;
 };
 
 /// Function Signature: combinations(array(T), n) -> array(array(T))
@@ -217,10 +323,11 @@ struct CombinationsFunction {
         innerArray.add_null();
         continue;
       }
+
       if constexpr (std::is_same_v<T, Varchar>) {
         innerArray.add_item().setNoCopy(array[idx].value());
       } else {
-        innerArray.add_item() = array[idx].value();
+        innerArray.push_back(array[idx].value());
       }
     }
   }
@@ -313,6 +420,51 @@ struct ArraySumFunction {
   }
 };
 
+template <typename TExecCtx, typename T>
+struct ArrayCumSumFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExecCtx)
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<velox::Array<T>>& out,
+      const arg_type<velox::Array<T>>& in) {
+    T sum = 0;
+    auto len = in.size();
+
+    for (auto i = 0; i < len; ++i) {
+      if (in[i].has_value()) {
+        if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+          sum += in[i].value();
+        } else {
+          sum = checkedPlus<T>(sum, in[i].value());
+        }
+        out.add_item() = sum;
+      } else {
+        for (auto j = i; j < len; ++j) {
+          out.add_null();
+        }
+        break;
+      }
+    }
+    return;
+  }
+
+  FOLLY_ALWAYS_INLINE void callNullFree(
+      out_type<velox::Array<T>>& out,
+      const null_free_arg_type<velox::Array<T>>& in) {
+    T sum = 0;
+
+    for (const auto& item : in) {
+      if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+        sum += item;
+      } else {
+        sum = checkedPlus<T>(sum, item);
+      }
+      out.add_item() = sum;
+    }
+    return;
+  }
+};
+
 template <typename T>
 struct ArrayAverageFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -487,16 +639,16 @@ struct ArrayNormalizeFunction {
 ///
 ///  Note:
 ///   - For compatibility with Presto a maximum arity of 254 is enforced.
-template <typename T>
+template <typename TExec, typename T>
 struct ArrayConcatFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T)
+  VELOX_DEFINE_FUNCTION_TYPES(TExec)
 
   static constexpr int32_t kMinArity = 2;
   static constexpr int32_t kMaxArity = 254;
 
-  FOLLY_ALWAYS_INLINE void call(
-      out_type<Array<Generic<T1>>>& out,
-      const arg_type<Variadic<Array<Generic<T1>>>>& arrays) {
+  void call(
+      out_type<Array<T>>& out,
+      const arg_type<Variadic<Array<T>>>& arrays) {
     VELOX_USER_CHECK_GE(
         arrays.size(),
         kMinArity,
@@ -515,22 +667,20 @@ struct ArrayConcatFunction {
   }
 
   void call(
-      out_type<Array<Generic<T1>>>& out,
-      const arg_type<Array<Generic<T1>>>& array,
-      const arg_type<Generic<T1>>& element) {
+      out_type<Array<T>>& out,
+      const arg_type<Array<T>>& array,
+      const arg_type<T>& element) {
     out.reserve(array.size() + 1);
     out.add_items(array);
-    auto& newItem = out.add_item();
-    newItem.copy_from(element);
+    out.push_back(element);
   }
 
   void call(
-      out_type<Array<Generic<T1>>>& out,
-      const arg_type<Generic<T1>>& element,
-      const arg_type<Array<Generic<T1>>>& array) {
+      out_type<Array<T>>& out,
+      const arg_type<T>& element,
+      const arg_type<Array<T>>& array) {
     out.reserve(array.size() + 1);
-    auto& newItem = out.add_item();
-    newItem.copy_from(element);
+    out.push_back(element);
     out.add_items(array);
   }
 };
@@ -559,12 +709,7 @@ struct ArrayTrimFunction {
 
     int64_t end = inputArray.size() - size;
     for (int i = 0; i < end; ++i) {
-      if (inputArray[i].has_value()) {
-        auto& newItem = out.add_item();
-        newItem = inputArray[i].value();
-      } else {
-        out.add_null();
-      }
+      out.push_back(inputArray[i]);
     }
   }
 
@@ -577,12 +722,7 @@ struct ArrayTrimFunction {
 
     int64_t end = inputArray.size() - size;
     for (int i = 0; i < end; ++i) {
-      if (inputArray[i].has_value()) {
-        auto& newItem = out.add_item();
-        newItem.copy_from(inputArray[i].value());
-      } else {
-        out.add_null();
-      }
+      out.push_back(inputArray[i]);
     }
   }
 };
@@ -612,6 +752,139 @@ struct ArrayTrimFunctionString {
   }
 };
 
+template <typename T>
+struct ArrayRemoveNullFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Fast path for primitives.
+  template <typename Out, typename In>
+  FOLLY_ALWAYS_INLINE void call(Out& out, const In& inputArray) {
+    for (int i = 0; i < inputArray.size(); ++i) {
+      if (inputArray[i].has_value()) {
+        out.push_back(inputArray[i].value());
+      }
+    }
+  }
+
+  // Generic implementation.
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Array<Generic<T1>>>& out,
+      const arg_type<Array<Generic<T1>>>& inputArray) {
+    for (int i = 0; i < inputArray.size(); ++i) {
+      if (inputArray[i].has_value()) {
+        out.push_back(inputArray[i].value());
+      }
+    }
+  }
+};
+
+template <typename T>
+struct ArrayRemoveNullFunctionString {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  // String version that avoids copy of strings.
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Array<Varchar>>& out,
+      const arg_type<Array<Varchar>>& inputArray) {
+    for (int i = 0; i < inputArray.size(); ++i) {
+      if (inputArray[i].has_value()) {
+        auto& newItem = out.add_item();
+        newItem.setNoCopy(inputArray[i].value());
+      }
+    }
+  }
+};
+
+template <typename T>
+struct ArrayNGramsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T)
+
+  // Fast path for primitives.
+  template <typename Out, typename In>
+  void call(Out& out, const In& input, int32_t n) {
+    VELOX_USER_CHECK_GT(n, 0, "N must be greater than zero.");
+
+    if (n > input.size()) {
+      auto& newItem = out.add_item();
+      newItem.copy_from(input);
+      return;
+    }
+
+    for (auto i = 0; i <= input.size() - n; ++i) {
+      auto& newItem = out.add_item();
+      for (auto j = 0; j < n; ++j) {
+        if (input[i + j].has_value()) {
+          auto& newGranularItem = newItem.add_item();
+          newGranularItem = input[i + j].value();
+        } else {
+          newItem.add_null();
+        }
+      }
+    }
+  }
+
+  // Generic implementation.
+  void call(
+      out_type<Array<Array<Generic<T1>>>>& out,
+      const arg_type<Array<Generic<T1>>>& input,
+      int32_t n) {
+    VELOX_USER_CHECK_GT(n, 0, "N must be greater than zero.");
+
+    if (n > input.size()) {
+      auto& newItem = out.add_item();
+      newItem.copy_from(input);
+      return;
+    }
+
+    for (auto i = 0; i <= input.size() - n; ++i) {
+      auto& newItem = out.add_item();
+      for (auto j = 0; j < n; ++j) {
+        if (input[i + j].has_value()) {
+          auto& newGranularItem = newItem.add_item();
+          newGranularItem.copy_from(input[i + j].value());
+        } else {
+          newItem.add_null();
+        }
+      }
+    }
+  }
+};
+
+template <typename T>
+struct ArrayNGramsFunctionString {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  // String version that avoids copy of strings.
+  void call(
+      out_type<Array<Array<Varchar>>>& out,
+      const arg_type<Array<Varchar>>& input,
+      int32_t n) {
+    VELOX_USER_CHECK_GT(n, 0, "N must be greater than zero.");
+
+    if (n > input.size()) {
+      auto& newItem = out.add_item();
+      newItem.copy_from(input);
+      return;
+    }
+
+    for (auto i = 0; i <= input.size() - n; ++i) {
+      auto& newItem = out.add_item();
+      for (auto j = 0; j < n; ++j) {
+        if (input[i + j].has_value()) {
+          auto& newGranularItem = newItem.add_item();
+          newGranularItem.setNoCopy(input[i + j].value());
+        } else {
+          newItem.add_null();
+        }
+      }
+    }
+  }
+};
+
 /// This class implements the array flatten function.
 ///
 /// DEFINITION:
@@ -650,40 +923,15 @@ template <typename T>
 struct ArrayUnionFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T)
 
-  // Fast path for primitives.
   template <typename Out, typename In>
   void call(Out& out, const In& inputArray1, const In& inputArray2) {
-    folly::F14FastSet<typename In::element_t> elementSet;
-    bool nullAdded = false;
-    auto addItems = [&](auto& inputArray) {
-      for (const auto& item : inputArray) {
-        if (item.has_value()) {
-          if (elementSet.insert(item.value()).second) {
-            auto& newItem = out.add_item();
-            newItem = item.value();
-          }
-        } else if (!nullAdded) {
-          nullAdded = true;
-          out.add_null();
-        }
-      }
-    };
-    addItems(inputArray1);
-    addItems(inputArray2);
-  }
-
-  void call(
-      out_type<Array<Generic<T1>>>& out,
-      const arg_type<Array<Generic<T1>>>& inputArray1,
-      const arg_type<Array<Generic<T1>>>& inputArray2) {
-    folly::F14FastSet<exec::GenericView> elementSet;
+    util::floating_point::HashSetNaNAware<typename In::element_t> elementSet;
     bool nullAdded = false;
     auto addItems = [&](auto& inputArray) {
       for (const auto& item : inputArray) {
         if (item.has_value()) {
           if (elementSet.insert(item.value()).second) {
-            auto& newItem = out.add_item();
-            newItem.copy_from(item.value());
+            out.push_back(item.value());
           }
         } else if (!nullAdded) {
           nullAdded = true;
@@ -710,9 +958,15 @@ struct ArrayRemoveFunction {
   void call(Out& out, const In& inputArray, E element) {
     for (const auto& item : inputArray) {
       if (item.has_value()) {
-        if (element != item.value()) {
-          auto& newItem = out.add_item();
-          newItem = item.value();
+        if constexpr (std::is_floating_point_v<E>) {
+          if (!util::floating_point::NaNAwareEquals<E>{}(
+                  element, item.value())) {
+            out.push_back(item.value());
+          }
+        } else {
+          if (element != item.value()) {
+            out.push_back(item.value());
+          }
         }
       } else {
         out.add_null();
@@ -725,30 +979,26 @@ struct ArrayRemoveFunction {
       out_type<Array<Generic<T1>>>& out,
       const arg_type<Array<Generic<T1>>>& array,
       const arg_type<Generic<T1>>& element) {
-    static constexpr CompareFlags kFlags = {
-        false, false, true, CompareFlags::NullHandlingMode::StopAtNull};
+    static constexpr CompareFlags kFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
     std::vector<std::optional<exec::GenericView>> toCopyItems;
     for (const auto& item : array) {
-      if (item.has_value()) {
-        auto result = element.compare(item.value(), kFlags);
-        VELOX_USER_CHECK(
-            result.has_value(),
-            "array_remove does not support arrays with elements that are null or contain null")
-        if (result.value()) {
-          toCopyItems.push_back(item.value());
-        }
-      } else {
+      if (!item.has_value()) {
         toCopyItems.push_back(std::nullopt);
+        continue;
+      }
+
+      auto result = element.compare(item.value(), kFlags);
+      VELOX_USER_CHECK(
+          result.has_value(),
+          "array_remove does not support arrays with elements that are null or contain null");
+      if (result.value()) {
+        toCopyItems.push_back(item.value());
       }
     }
 
     for (const auto& item : toCopyItems) {
-      if (item.has_value()) {
-        auto& newItem = out.add_item();
-        newItem.copy_from(item.value());
-      } else {
-        out.add_null();
-      }
+      out.push_back(item);
     }
   }
 };
@@ -768,8 +1018,7 @@ struct ArrayRemoveFunctionString {
       if (item.has_value()) {
         auto result = element.compare(item.value());
         if (result) {
-          auto& newItem = out.add_item();
-          newItem.setNoCopy(item.value());
+          out.push_back(item.value());
         }
       } else {
         out.add_null();
diff --git a/velox/functions/prestosql/ArrayIntersectExcept.cpp b/velox/functions/prestosql/ArrayIntersectExcept.cpp
index 1336ff2a0fe3b..2dfcef7f3feac 100644
--- a/velox/functions/prestosql/ArrayIntersectExcept.cpp
+++ b/velox/functions/prestosql/ArrayIntersectExcept.cpp
@@ -16,32 +16,106 @@
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::functions {
 namespace {
-template <typename T>
+constexpr vector_size_t kInitialSetSize{128};
 
+template <typename T>
 struct SetWithNull {
   SetWithNull(vector_size_t initialSetSize = kInitialSetSize) {
     set.reserve(initialSetSize);
   }
 
+  bool insert(const DecodedVector* decodedElements, vector_size_t offset) {
+    return set.insert(decodedElements->valueAt<T>(offset)).second;
+  }
+
+  size_t count(const DecodedVector* decodedElements, vector_size_t offset)
+      const {
+    return set.count(decodedElements->valueAt<T>(offset));
+  }
+
   void reset() {
     set.clear();
     hasNull = false;
   }
 
-  folly::F14FastSet<T> set;
+  bool empty() const {
+    return !hasNull && set.empty();
+  }
+
+  util::floating_point::HashSetNaNAware<T> set;
+  bool hasNull{false};
+};
+
+struct ComplexTypeEntry {
+  const uint64_t hash;
+  const BaseVector* baseVector;
+  const vector_size_t index;
+};
+
+template <>
+struct SetWithNull<ComplexTypeEntry> {
+  struct Hash {
+    size_t operator()(const ComplexTypeEntry& entry) const {
+      return entry.hash;
+    }
+  };
+
+  struct EqualTo {
+    bool operator()(const ComplexTypeEntry& left, const ComplexTypeEntry& right)
+        const {
+      return left.baseVector
+          ->equalValueAt(
+              right.baseVector,
+              left.index,
+              right.index,
+              CompareFlags::NullHandlingMode::kNullAsValue)
+          .value();
+    }
+  };
+
+  folly::F14FastSet<ComplexTypeEntry, Hash, EqualTo> set;
   bool hasNull{false};
-  static constexpr vector_size_t kInitialSetSize{128};
+
+  SetWithNull(vector_size_t initialSetSize = kInitialSetSize) {
+    set.reserve(initialSetSize);
+  }
+
+  bool insert(const DecodedVector* decodedElements, vector_size_t offset) {
+    const auto vector = decodedElements->base();
+    const auto index = decodedElements->index(offset);
+    const uint64_t hash = vector->hashValueAt(index);
+    return set.insert(ComplexTypeEntry{hash, vector, index}).second;
+  }
+
+  size_t count(const DecodedVector* decodedElements, vector_size_t offset)
+      const {
+    const auto vector = decodedElements->base();
+    const auto index = decodedElements->index(offset);
+    const uint64_t hash = vector->hashValueAt(index);
+    return set.count(ComplexTypeEntry{hash, vector, index});
+  }
+
+  void reset() {
+    set.clear();
+    hasNull = false;
+  }
+
+  bool empty() const {
+    return !hasNull && set.empty();
+  }
 };
+
 // Generates a set based on the elements of an ArrayVector. Note that we take
 // rightSet as a parameter (instead of returning a new one) to reuse the
 // allocated memory.
-template <typename T, typename TVector>
+template <typename T>
 void generateSet(
     const ArrayVector* arrayVector,
-    const TVector* arrayElements,
+    const DecodedVector* arrayElements,
     vector_size_t idx,
     SetWithNull<T>& rightSet) {
   auto size = arrayVector->sizeAt(idx);
@@ -52,13 +126,7 @@ void generateSet(
     if (arrayElements->isNullAt(i)) {
       rightSet.hasNull = true;
     } else {
-      // Function can be called with either FlatVector or DecodedVector, but
-      // their APIs are slightly different.
-      if constexpr (std::is_same_v<TVector, DecodedVector>) {
-        rightSet.set.insert(arrayElements->template valueAt<T>(i));
-      } else {
-        rightSet.set.insert(arrayElements->valueAt(i));
-      }
+      rightSet.insert(arrayElements, i);
     }
   }
 }
@@ -168,7 +236,6 @@ class ArrayIntersectExceptFunction : public exec::VectorFunction {
 
       outputSet.reset();
       rawNewOffsets[row] = indicesCursor;
-
       // Scans the array elements on the left-hand side.
       for (vector_size_t i = offset; i < (offset + size); ++i) {
         if (decodedLeftElements->isNullAt(i)) {
@@ -188,19 +255,17 @@ class ArrayIntersectExceptFunction : public exec::VectorFunction {
             }
           }
         } else {
-          auto val = decodedLeftElements->valueAt<T>(i);
           // For array_intersect, add the element if it is found (not found
           // for array_except) in the right-hand side, and wasn't added already
           // (check outputSet).
           bool addValue = false;
           if constexpr (isIntersect) {
-            addValue = rightSet.set.count(val) > 0;
+            addValue = rightSet.count(decodedLeftElements, i) > 0;
           } else {
-            addValue = rightSet.set.count(val) == 0;
+            addValue = rightSet.count(decodedLeftElements, i) == 0;
           }
           if (addValue) {
-            auto it = outputSet.set.insert(val);
-            if (it.second) {
+            if (outputSet.insert(decodedLeftElements, i)) {
               rawNewIndices[indicesCursor++] = i;
             }
           }
@@ -285,6 +350,10 @@ class ArraysOverlapFunction : public exec::VectorFunction {
       auto offset = baseLeftArray->offsetAt(idx);
       auto size = baseLeftArray->sizeAt(idx);
       bool hasNull = rightSet.hasNull;
+      if (size == 0 || rightSet.empty()) {
+        resultBoolVector->set(row, false);
+        return;
+      }
       for (auto i = offset; i < (offset + size); ++i) {
         // For each element in the current row search for it in the rightSet.
         if (decodedLeftElements->isNullAt(i)) {
@@ -292,7 +361,7 @@ class ArraysOverlapFunction : public exec::VectorFunction {
           hasNull = true;
           continue;
         }
-        if (rightSet.set.count(decodedLeftElements->valueAt<T>(i)) > 0) {
+        if (rightSet.count(decodedLeftElements, i) > 0) {
           // Found an overlapping element. Add to result set.
           resultBoolVector->set(row, true);
           return;
@@ -394,7 +463,10 @@ SetWithNull<T> validateConstantVectorAndGenerateSet(
 template <bool isIntersect, TypeKind kind>
 std::shared_ptr<exec::VectorFunction> createTypedArraysIntersectExcept(
     const std::vector<exec::VectorFunctionArg>& inputArgs) {
-  using T = typename TypeTraits<kind>::NativeType;
+  using T = std::conditional_t<
+      TypeTraits<kind>::isPrimitiveType,
+      typename TypeTraits<kind>::NativeType,
+      ComplexTypeEntry>;
 
   VELOX_CHECK_EQ(inputArgs.size(), 2);
   BaseVector* rhs = inputArgs[1].constantValue.get();
@@ -422,7 +494,7 @@ std::shared_ptr<exec::VectorFunction> createArrayIntersect(
   validateMatchingArrayTypes(inputArgs, name, 2);
   auto elementType = inputArgs.front().type->childAt(0);
 
-  return VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
+  return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
       createTypedArraysIntersectExcept,
       /* isIntersect */ true,
       elementType->kind(),
@@ -436,7 +508,7 @@ std::shared_ptr<exec::VectorFunction> createArrayExcept(
   validateMatchingArrayTypes(inputArgs, name, 2);
   auto elementType = inputArgs.front().type->childAt(0);
 
-  return VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
+  return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
       createTypedArraysIntersectExcept,
       /* isIntersect */ false,
       elementType->kind(),
@@ -444,18 +516,15 @@ std::shared_ptr<exec::VectorFunction> createArrayExcept(
 }
 
 std::vector<std::shared_ptr<exec::FunctionSignature>> signatures(
-    const std::string& returnTypeTemplate) {
-  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
-  for (const auto& type : exec::primitiveTypeNames()) {
-    signatures.push_back(
-        exec::FunctionSignatureBuilder()
-            .returnType(
-                fmt::format(fmt::runtime(returnTypeTemplate.c_str()), type))
-            .argumentType(fmt::format("array({})", type))
-            .argumentType(fmt::format("array({})", type))
-            .build());
-  }
-  return signatures;
+    const std::string& returnType) {
+  return std::vector<std::shared_ptr<exec::FunctionSignature>>{
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType(returnType)
+          .argumentType("array(T)")
+          .argumentType("array(T)")
+          .build(),
+  };
 }
 
 template <TypeKind kind>
@@ -464,7 +533,11 @@ const std::shared_ptr<exec::VectorFunction> createTypedArraysOverlap(
   VELOX_CHECK_EQ(inputArgs.size(), 2);
   auto left = inputArgs[0].constantValue.get();
   auto right = inputArgs[1].constantValue.get();
-  using T = typename TypeTraits<kind>::NativeType;
+  using T = std::conditional_t<
+      TypeTraits<kind>::isPrimitiveType,
+      typename TypeTraits<kind>::NativeType,
+      ComplexTypeEntry>;
+
   if (left == nullptr && right == nullptr) {
     return std::make_shared<ArraysOverlapFunction<T>>();
   }
@@ -482,7 +555,7 @@ std::shared_ptr<exec::VectorFunction> createArraysOverlapFunction(
   validateMatchingArrayTypes(inputArgs, name, 2);
   auto elementType = inputArgs.front().type->childAt(0);
 
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+  return VELOX_DYNAMIC_TYPE_DISPATCH(
       createTypedArraysOverlap, elementType->kind(), inputArgs);
 }
 } // namespace
@@ -494,11 +567,11 @@ VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
 
 VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
     udf_array_intersect,
-    signatures("array({})"),
+    signatures("array(T)"),
     createArrayIntersect);
 
 VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
     udf_array_except,
-    signatures("array({})"),
+    signatures("array(T)"),
     createArrayExcept);
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArrayPosition.cpp b/velox/functions/prestosql/ArrayPosition.cpp
index e01ed76452037..dba479cc69b2f 100644
--- a/velox/functions/prestosql/ArrayPosition.cpp
+++ b/velox/functions/prestosql/ArrayPosition.cpp
@@ -17,11 +17,21 @@
 
 #include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/vector/DecodedVector.h"
 
 namespace facebook::velox::functions {
 namespace {
 
+template <typename T>
+inline bool isPrimitiveEqual(const T& lhs, const T& rhs) {
+  if constexpr (std::is_floating_point_v<T>) {
+    return util::floating_point::NaNAwareEquals<T>{}(lhs, rhs);
+  } else {
+    return lhs == rhs;
+  }
+}
+
 // Find the index of the first match for primitive types.
 template <
     TypeKind kind,
@@ -76,7 +86,7 @@ void applyTypedFirstMatch(
 
       int i;
       for (i = 0; i < size; i++) {
-        if (rawElements[offset + i] == search) {
+        if (isPrimitiveEqual<T>(rawElements[offset + i], search)) {
           flatResult.set(row, i + 1);
           break;
         }
@@ -99,7 +109,7 @@ void applyTypedFirstMatch(
     int i;
     for (i = 0; i < size; i++) {
       if (!elementsDecoded.isNullAt(offset + i) &&
-          elementsDecoded.valueAt<T>(offset + i) == search) {
+          isPrimitiveEqual<T>(elementsDecoded.valueAt<T>(offset + i), search)) {
         flatResult.set(row, i + 1);
         break;
       }
@@ -246,7 +256,7 @@ void applyTypedWithInstance(
 
       int i;
       for (i = startIndex; i != endIndex; i += step) {
-        if (rawElements[offset + i] == search) {
+        if (isPrimitiveEqual<T>(rawElements[offset + i], search)) {
           if (--remaining == 0) {
             flatResult.set(row, i + 1);
             break;
@@ -278,7 +288,7 @@ void applyTypedWithInstance(
     int i;
     for (i = startIndex; i != endIndex; i += step) {
       if (!elementsDecoded.isNullAt(offset + i) &&
-          elementsDecoded.valueAt<T>(offset + i) == search) {
+          isPrimitiveEqual<T>(elementsDecoded.valueAt<T>(offset + i), search)) {
         --instance;
         if (instance == 0) {
           flatResult.set(row, i + 1);
diff --git a/velox/functions/prestosql/ArrayShuffle.cpp b/velox/functions/prestosql/ArrayShuffle.cpp
deleted file mode 100644
index 03c35e7926668..0000000000000
--- a/velox/functions/prestosql/ArrayShuffle.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <numeric>
-#include <random>
-#include "velox/expression/EvalCtx.h"
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
-
-namespace facebook::velox::functions {
-namespace {
-// See documentation at
-// https://prestodb.io/docs/current/functions/array.html#shuffle
-//
-// This function will shuffle identical arrays independently, i.e. even when
-// the input has duplicate rows represented using constant and dictionary
-// encoding, the output is flat and likely yields different values.
-//
-// E.g.1: constant encoding
-// Input: ConstantVector(base=ArrayVector[{1,2,3}], length=3, index=0)
-// Possible Output: ArrayVector[{1,3,2},{2,3,1},{3,2,1}]
-//
-// E.g.2: dict encoding
-// Input: DictionaryVector(
-//   dictionaryValues=ArrayVector[{1,2,3},{4,5},{1,2,3}],
-//   dictionaryIndices=[1,2,0])
-// Possible Output: ArrayVector[{5,4},{2,1,3},{1,3,2}]
-//
-class ArrayShuffleFunction : public exec::VectorFunction {
- public:
-  bool isDeterministic() const override {
-    return false;
-  }
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /*outputType*/,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    VELOX_CHECK_EQ(args.size(), 1);
-
-    // This is a non-deterministic function, which violates the guarantee on a
-    // deterministic single-arg function that the expression evaluation will
-    // peel off encodings, and we will only see flat or constant inputs. Hence,
-    // we need to use DecodedVector to handle ALL encodings.
-    exec::DecodedArgs decodedArgs(rows, args, context);
-    auto decodedArg = decodedArgs.at(0);
-    auto arrayVector = decodedArg->base()->as<ArrayVector>();
-    auto elementsVector = arrayVector->elements();
-
-    vector_size_t numElements = 0;
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      const auto size = arrayVector->sizeAt(decodedArg->index(row));
-      numElements += size;
-    });
-
-    // Allocate new buffer to hold shuffled indices.
-    BufferPtr shuffledIndices = allocateIndices(numElements, context.pool());
-    BufferPtr offsets = allocateOffsets(rows.end(), context.pool());
-    BufferPtr sizes = allocateSizes(rows.end(), context.pool());
-
-    vector_size_t* rawIndices = shuffledIndices->asMutable<vector_size_t>();
-    vector_size_t* rawOffsets = offsets->asMutable<vector_size_t>();
-    vector_size_t* rawSizes = sizes->asMutable<vector_size_t>();
-
-    vector_size_t newOffset = 0;
-    std::mt19937 randGen(std::random_device{}());
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      vector_size_t arrayRow = decodedArg->index(row);
-      vector_size_t size = arrayVector->sizeAt(arrayRow);
-      vector_size_t offset = arrayVector->offsetAt(arrayRow);
-
-      std::iota(rawIndices + newOffset, rawIndices + newOffset + size, offset);
-      std::shuffle(
-          rawIndices + newOffset, rawIndices + newOffset + size, randGen);
-
-      rawSizes[row] = size;
-      rawOffsets[row] = newOffset;
-      newOffset += size;
-    });
-
-    auto resultElements = BaseVector::wrapInDictionary(
-        nullptr, shuffledIndices, numElements, elementsVector);
-    auto localResult = std::make_shared<ArrayVector>(
-        context.pool(),
-        arrayVector->type(),
-        nullptr,
-        rows.end(),
-        std::move(offsets),
-        std::move(sizes),
-        std::move(resultElements));
-
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-};
-
-std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-  return {// array(T) -> array(T)
-          exec::FunctionSignatureBuilder()
-              .typeVariable("T")
-              .returnType("array(T)")
-              .argumentType("array(T)")
-              .build()};
-}
-
-} // namespace
-
-// Register function.
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_array_shuffle,
-    signatures(),
-    std::make_unique<ArrayShuffleFunction>());
-} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArraySort.cpp b/velox/functions/prestosql/ArraySort.cpp
index bdeb1c23f98e8..2e2d2ee4f01e3 100644
--- a/velox/functions/prestosql/ArraySort.cpp
+++ b/velox/functions/prestosql/ArraySort.cpp
@@ -22,6 +22,7 @@
 #include "velox/functions/lib/LambdaFunctionUtil.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
 #include "velox/functions/prestosql/SimpleComparisonMatcher.h"
+#include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::functions {
 namespace {
@@ -31,7 +32,8 @@ BufferPtr sortElements(
     const ArrayVector& inputArray,
     const BaseVector& inputElements,
     bool ascending,
-    exec::EvalCtx& context) {
+    exec::EvalCtx& context,
+    bool throwOnNestedNull) {
   const SelectivityVector inputElementRows =
       toElementRows(inputElements.size(), rows, &inputArray);
   exec::LocalDecodedVector decodedElements(
@@ -42,20 +44,28 @@ BufferPtr sortElements(
   BufferPtr indices = allocateIndices(inputElements.size(), context.pool());
   vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
 
-  const CompareFlags flags{.nullsFirst = false, .ascending = ascending};
-  auto decodedIndices = decodedElements->indices();
+  CompareFlags flags{.nullsFirst = false, .ascending = ascending};
+  if (throwOnNestedNull) {
+    flags.nullHandlingMode =
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate;
+  }
 
-  rows.applyToSelected([&](vector_size_t row) {
+  auto decodedIndices = decodedElements->indices();
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
     const auto size = inputArray.sizeAt(row);
     const auto offset = inputArray.offsetAt(row);
 
     for (auto i = offset; i < offset + size; ++i) {
       rawIndices[i] = i;
     }
+
     std::sort(
         rawIndices + offset,
         rawIndices + offset + size,
         [&](vector_size_t& a, vector_size_t& b) {
+          if (a == b) {
+            return false;
+          }
           bool aNull = decodedElements->isNullAt(a);
           bool bNull = decodedElements->isNullAt(b);
           if (aNull) {
@@ -64,11 +74,15 @@ BufferPtr sortElements(
           if (bNull) {
             return true;
           }
-          return baseElementsVector->compare(
-                     baseElementsVector,
-                     decodedIndices[a],
-                     decodedIndices[b],
-                     flags) < 0;
+
+          std::optional<int32_t> result = baseElementsVector->compare(
+              baseElementsVector, decodedIndices[a], decodedIndices[b], flags);
+
+          if (!result.has_value()) {
+            VELOX_USER_FAIL("Ordering nulls is not supported");
+          }
+
+          return result.value() < 0;
         });
   });
 
@@ -80,10 +94,11 @@ void applyComplexType(
     ArrayVector* inputArray,
     bool ascending,
     exec::EvalCtx& context,
-    VectorPtr& resultElements) {
+    VectorPtr& resultElements,
+    bool throwOnNestedNull) {
   auto inputElements = inputArray->elements();
-  auto indices =
-      sortElements(rows, *inputArray, *inputElements, ascending, context);
+  auto indices = sortElements(
+      rows, *inputArray, *inputElements, ascending, context, throwOnNestedNull);
   resultElements = BaseVector::transpose(indices, std::move(inputElements));
 }
 
@@ -158,6 +173,19 @@ void applyScalarType(
         bits::fillBits(rawBits, startRow, startRow + numOneBits, true);
         bits::fillBits(rawBits, endZeroRow, endRow, false);
       }
+    } else if constexpr (kind == TypeKind::REAL || kind == TypeKind::DOUBLE) {
+      T* resultRawValues = flatResults->mutableRawValues();
+      if (ascending) {
+        std::sort(
+            resultRawValues + startRow,
+            resultRawValues + endRow,
+            util::floating_point::NaNAwareLessThan<T>());
+      } else {
+        std::sort(
+            resultRawValues + startRow,
+            resultRawValues + endRow,
+            util::floating_point::NaNAwareGreaterThan<T>());
+      }
     } else {
       T* resultRawValues = flatResults->mutableRawValues();
       if (ascending) {
@@ -174,7 +202,7 @@ void applyScalarType(
 }
 
 // See documentation at https://prestodb.io/docs/current/functions/array.html
-template <TypeKind T>
+template <TypeKind Kind>
 class ArraySortFunction : public exec::VectorFunction {
  public:
   /// This class implements the array_sort query function. Takes an array as
@@ -193,7 +221,8 @@ class ArraySortFunction : public exec::VectorFunction {
   /// and 'offsets' vectors that control where output arrays start and end
   /// remain the same in the output ArrayVector.
 
-  explicit ArraySortFunction(bool ascending) : ascending_{ascending} {}
+  explicit ArraySortFunction(bool ascending, bool throwOnNestedNull)
+      : ascending_{ascending}, throwOnNestedNull_(throwOnNestedNull) {}
 
   // Execute function.
   void apply(
@@ -208,7 +237,10 @@ class ArraySortFunction : public exec::VectorFunction {
     VectorPtr localResult;
 
     // Input can be constant or flat.
-    if (arg->isConstantEncoding()) {
+    if constexpr (Kind == TypeKind::UNKNOWN) {
+      // All elements are NULL. Hence, sorting doesn't change anything.
+      localResult = arg;
+    } else if (arg->isConstantEncoding()) {
       auto* constantArray = arg->as<ConstantVector<ComplexType>>();
       const auto& flatArray = constantArray->valueVector();
       const auto flatIndex = constantArray->index();
@@ -233,10 +265,10 @@ class ArraySortFunction : public exec::VectorFunction {
     auto inputArray = arg->as<ArrayVector>();
     VectorPtr resultElements;
 
-    if (velox::TypeTraits<T>::isPrimitiveType) {
+    if constexpr (velox::TypeTraits<Kind>::isPrimitiveType) {
       VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
           applyScalarType,
-          T,
+          Kind,
           rows,
           inputArray,
           ascending_,
@@ -244,7 +276,13 @@ class ArraySortFunction : public exec::VectorFunction {
           resultElements);
 
     } else {
-      applyComplexType(rows, inputArray, ascending_, context, resultElements);
+      applyComplexType(
+          rows,
+          inputArray,
+          ascending_,
+          context,
+          resultElements,
+          throwOnNestedNull_);
     }
 
     return std::make_shared<ArrayVector>(
@@ -259,11 +297,13 @@ class ArraySortFunction : public exec::VectorFunction {
   }
 
   const bool ascending_;
+  const bool throwOnNestedNull_;
 };
 
 class ArraySortLambdaFunction : public exec::VectorFunction {
  public:
-  explicit ArraySortLambdaFunction(bool ascending) : ascending_{ascending} {}
+  explicit ArraySortLambdaFunction(bool ascending, bool throwOnNestedNull)
+      : ascending_{ascending}, throwOnNestedNull_(throwOnNestedNull) {}
 
   void apply(
       const SelectivityVector& rows,
@@ -309,10 +349,18 @@ class ArraySortLambdaFunction : public exec::VectorFunction {
     }
 
     // Sort 'newElements'.
-    auto indices =
-        sortElements(rows, *flatArray, *newElements, ascending_, context);
+    auto indices = sortElements(
+        rows,
+        *flatArray,
+        *newElements,
+        ascending_,
+        context,
+        throwOnNestedNull_);
     auto sortedElements = BaseVector::wrapInDictionary(
-        nullptr, indices, newNumElements, flatArray->elements());
+        nullptr,
+        indices,
+        indices->size() / sizeof(vector_size_t),
+        flatArray->elements());
 
     // Set nulls for rows not present in 'rows'.
     BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
@@ -321,7 +369,7 @@ class ArraySortLambdaFunction : public exec::VectorFunction {
         flatArray->pool(),
         flatArray->type(),
         std::move(newNulls),
-        flatArray->size(),
+        rows.end(),
         flatArray->offsets(),
         flatArray->sizes(),
         sortedElements);
@@ -330,42 +378,56 @@ class ArraySortLambdaFunction : public exec::VectorFunction {
 
  private:
   const bool ascending_;
+  const bool throwOnNestedNull_;
 };
 
 // Create function template based on type.
 template <TypeKind kind>
 std::shared_ptr<exec::VectorFunction> createTyped(
     const std::vector<exec::VectorFunctionArg>& inputArgs,
-    bool ascending) {
+    bool ascending,
+    bool throwOnNestedNull = true) {
   VELOX_CHECK_EQ(inputArgs.size(), 1);
-  return std::make_shared<ArraySortFunction<kind>>(ascending);
+  return std::make_shared<ArraySortFunction<kind>>(
+      ascending, throwOnNestedNull);
 }
 
 // Create function.
 std::shared_ptr<exec::VectorFunction> create(
     const std::vector<exec::VectorFunctionArg>& inputArgs,
-    bool ascending) {
+    bool ascending,
+    bool throwOnNestedNull = true) {
   if (inputArgs.size() == 2) {
-    return std::make_shared<ArraySortLambdaFunction>(ascending);
+    return std::make_shared<ArraySortLambdaFunction>(
+        ascending, throwOnNestedNull);
+  }
+
+  const auto elementType = inputArgs.front().type->childAt(0);
+  if (elementType->isUnKnown()) {
+    return createTyped<TypeKind::UNKNOWN>(
+        inputArgs, ascending, throwOnNestedNull);
   }
 
-  auto elementType = inputArgs.front().type->childAt(0);
   return VELOX_DYNAMIC_TYPE_DISPATCH(
-      createTyped, elementType->kind(), inputArgs, ascending);
+      createTyped,
+      elementType->kind(),
+      inputArgs,
+      ascending,
+      throwOnNestedNull);
 }
 
 std::shared_ptr<exec::VectorFunction> createAsc(
     const std::string& /* name */,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/) {
-  return create(inputArgs, true);
+  return create(inputArgs, true, true);
 }
 
 std::shared_ptr<exec::VectorFunction> createDesc(
     const std::string& /* name */,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/) {
-  return create(inputArgs, false);
+  return create(inputArgs, false, true);
 }
 
 // Define function signature.
@@ -374,14 +436,14 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> signatures(
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
       // array(T) -> array(T)
       exec::FunctionSignatureBuilder()
-          .typeVariable("T")
+          .orderableTypeVariable("T")
           .returnType("array(T)")
           .argumentType("array(T)")
           .build(),
       // array(T), function(T,U), boolean -> array(T)
       exec::FunctionSignatureBuilder()
           .typeVariable("T")
-          .typeVariable("U")
+          .orderableTypeVariable("U")
           .returnType("array(T)")
           .argumentType("array(T)")
           .constantArgumentType("function(T,U)")
@@ -401,6 +463,25 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> signatures(
   return signatures;
 }
 
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+internalCanonicalizeSignatures() {
+  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
+      // array(T) -> array(T)
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("array(T)")
+          .argumentType("array(T)")
+          .build()};
+  return signatures;
+}
+
+std::shared_ptr<exec::VectorFunction> createAscNoThrowOnNestedNull(
+    const std::string& /* name */,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& /*config*/) {
+  return create(inputArgs, true, false);
+}
+
 core::CallTypedExprPtr asArraySortCall(
     const std::string& prefix,
     const core::TypedExprPtr& expr) {
@@ -432,10 +513,19 @@ core::TypedExprPtr rewriteArraySortCall(
     return nullptr;
   }
 
+  static const std::string kNotSupported =
+      "array_sort with comparator lambda that cannot be rewritten "
+      "into a transform is not supported: {}";
+
   if (auto comparison =
           functions::prestosql::isSimpleComparison(prefix, *lambda)) {
     std::string name = comparison->isLessThen ? prefix + "array_sort"
                                               : prefix + "array_sort_desc";
+
+    if (!comparison->expr->type()->isOrderable()) {
+      VELOX_USER_FAIL(kNotSupported, lambda->toString());
+    }
+
     auto rewritten = std::make_shared<core::CallTypedExpr>(
         call->type(),
         std::vector<core::TypedExprPtr>{
@@ -450,7 +540,7 @@ core::TypedExprPtr rewriteArraySortCall(
     return rewritten;
   }
 
-  return nullptr;
+  VELOX_USER_FAIL(kNotSupported, lambda->toString());
 }
 
 // Register function.
@@ -464,4 +554,12 @@ VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
     signatures(false),
     createDesc);
 
+// An internal function to canonicalize an array to allow for comparisons. Used
+// in AggregationFuzzerTest. Details in
+// https://github.com/facebookincubator/velox/issues/6999.
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_$internal$canonicalize,
+    internalCanonicalizeSignatures(),
+    createAscNoThrowOnNestedNull);
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArraySum.cpp b/velox/functions/prestosql/ArraySum.cpp
index 2c27c64b20cd9..1021137323f24 100644
--- a/velox/functions/prestosql/ArraySum.cpp
+++ b/velox/functions/prestosql/ArraySum.cpp
@@ -20,8 +20,8 @@
 #include "velox/expression/EvalCtx.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/CheckedArithmetic.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
-#include "velox/functions/prestosql/CheckedArithmetic.h"
 
 namespace facebook::velox::functions {
 namespace {
@@ -30,7 +30,7 @@ namespace {
 /// See documentation at https://prestodb.io/docs/current/functions/array.html
 ///
 
-template <typename TInput, typename TOutput>
+template <typename TInput, typename TOutput, bool kPropagateElementNull>
 class ArraySumFunction : public exec::VectorFunction {
  public:
   template <bool mayHaveNulls, typename DataAtFunc, typename IsNullFunc>
@@ -38,7 +38,8 @@ class ArraySumFunction : public exec::VectorFunction {
       vector_size_t row,
       const ArrayVector* arrayVector,
       DataAtFunc&& dataAtFunc,
-      IsNullFunc&& isNullFunc) const {
+      IsNullFunc&& isNullFunc,
+      bool& nullResult) const {
     auto start = arrayVector->offsetAt(row);
     auto end = start + arrayVector->sizeAt(row);
     TOutput sum = 0;
@@ -53,14 +54,21 @@ class ArraySumFunction : public exec::VectorFunction {
 
     for (auto i = start; i < end; i++) {
       if constexpr (mayHaveNulls) {
-        bool isNull = isNullFunc(i);
-        if (!isNull) {
+        if (isNullFunc(i)) {
+          if constexpr (kPropagateElementNull) {
+            nullResult = true;
+            return 0;
+          }
+        } else {
           addElement(sum, dataAtFunc(i));
         }
       } else {
         addElement(sum, dataAtFunc(i));
       }
     }
+    if constexpr (mayHaveNulls && kPropagateElementNull) {
+      nullResult = false;
+    }
     return sum;
   }
 
@@ -73,9 +81,18 @@ class ArraySumFunction : public exec::VectorFunction {
       DataAtFunc&& dataAtFunc,
       IsNullFunc&& isNullFunc) const {
     context.applyToSelectedNoThrow(rows, [&](auto row) {
-      resultValues->set(
-          row,
-          applyCore<mayHaveNulls>(row, arrayVector, dataAtFunc, isNullFunc));
+      bool nullResult;
+      auto sum = applyCore<mayHaveNulls>(
+          row, arrayVector, dataAtFunc, isNullFunc, nullResult);
+      if constexpr (mayHaveNulls && kPropagateElementNull) {
+        if (nullResult) {
+          resultValues->setNull(row, true);
+        } else {
+          resultValues->set(row, sum);
+        }
+      } else {
+        resultValues->set(row, sum);
+      }
     });
   }
 
@@ -132,19 +149,22 @@ class ArraySumFunction : public exec::VectorFunction {
       exec::LocalDecodedVector elements(context, *elementsVector, elementsRows);
 
       TOutput sum;
+      bool nullResult = false;
       try {
         if (elementsVector->mayHaveNulls()) {
           sum = applyCore<true>(
               arrayRow,
               arrayVector,
               [&](auto index) { return elements->valueAt<TInput>(index); },
-              [&](auto index) { return elements->isNullAt(index); });
+              [&](auto index) { return elements->isNullAt(index); },
+              nullResult);
         } else {
           sum = applyCore<false>(
               arrayRow,
               arrayVector,
               [&](auto index) { return elements->valueAt<TInput>(index); },
-              [&](auto index) { return elements->isNullAt(index); });
+              [&](auto index) { return elements->isNullAt(index); },
+              nullResult);
         }
       } catch (...) {
         context.setErrors(rows, std::current_exception());
@@ -154,7 +174,7 @@ class ArraySumFunction : public exec::VectorFunction {
           std::make_shared<ConstantVector<TOutput>>(
               context.pool(),
               rows.end(),
-              false /*isNull*/,
+              nullResult,
               outputType,
               std::move(sum)),
           rows,
@@ -201,6 +221,7 @@ class ArraySumFunction : public exec::VectorFunction {
 };
 
 // Create function.
+template <bool kPropagateElementNull>
 std::shared_ptr<exec::VectorFunction> create(
     const std::string& /* name */,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
@@ -211,33 +232,41 @@ std::shared_ptr<exec::VectorFunction> create(
     case TypeKind::TINYINT: {
       return std::make_shared<ArraySumFunction<
           TypeTraits<TypeKind::TINYINT>::NativeType,
-          int64_t>>();
+          int64_t,
+          kPropagateElementNull>>();
     }
     case TypeKind::SMALLINT: {
       return std::make_shared<ArraySumFunction<
           TypeTraits<TypeKind::SMALLINT>::NativeType,
-          int64_t>>();
+          int64_t,
+          kPropagateElementNull>>();
     }
     case TypeKind::INTEGER: {
       return std::make_shared<ArraySumFunction<
           TypeTraits<TypeKind::INTEGER>::NativeType,
-          int64_t>>();
+          int64_t,
+          kPropagateElementNull>>();
     }
     case TypeKind::BIGINT: {
       return std::make_shared<ArraySumFunction<
           TypeTraits<TypeKind::BIGINT>::NativeType,
-          int64_t>>();
+          int64_t,
+          kPropagateElementNull>>();
     }
     case TypeKind::REAL: {
-      return std::make_shared<
-          ArraySumFunction<TypeTraits<TypeKind::REAL>::NativeType, double>>();
+      return std::make_shared<ArraySumFunction<
+          TypeTraits<TypeKind::REAL>::NativeType,
+          double,
+          kPropagateElementNull>>();
     }
     case TypeKind::DOUBLE: {
-      return std::make_shared<
-          ArraySumFunction<TypeTraits<TypeKind::DOUBLE>::NativeType, double>>();
+      return std::make_shared<ArraySumFunction<
+          TypeTraits<TypeKind::DOUBLE>::NativeType,
+          double,
+          kPropagateElementNull>>();
     }
     default: {
-      VELOX_FAIL("Unsupported Type")
+      VELOX_FAIL("Unsupported Type");
     }
   }
 }
@@ -266,6 +295,11 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
 } // namespace
 
 // Register function.
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(udf_array_sum, signatures(), create);
+void registerVectorFunction_udf_array_sum(const std::string& name) {
+  facebook::velox::exec::registerStatefulVectorFunction(
+      name, signatures(), create<false>);
+  facebook::velox::exec::registerStatefulVectorFunction(
+      name + "_propagate_element_null", signatures(), create<true>);
+}
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/BinaryFunctions.h b/velox/functions/prestosql/BinaryFunctions.h
index 8e436ab94fa60..ce153ee349fc4 100644
--- a/velox/functions/prestosql/BinaryFunctions.h
+++ b/velox/functions/prestosql/BinaryFunctions.h
@@ -19,14 +19,13 @@
 #define XXH_INLINE_ALL
 #include <xxhash.h>
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #include "folly/ssl/OpenSSLHash.h"
-#pragma GCC diagnostic pop
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/encode/Base64.h"
 #include "velox/external/md5/md5.h"
 #include "velox/functions/Udf.h"
+#include "velox/functions/lib/ToHex.h"
+#include "velox/functions/lib/string/StringImpl.h"
 
 namespace facebook::velox::functions {
 
@@ -160,6 +159,7 @@ struct HmacSha1Function {
   template <typename TOutput, typename TInput>
   FOLLY_ALWAYS_INLINE void
   call(TOutput& result, const TInput& data, const TInput& key) {
+    VELOX_USER_CHECK_GT(key.size(), 0, "Empty key is not allowed");
     result.resize(20);
     folly::ssl::OpenSSLHash::hmac_sha1(
         folly::MutableByteRange((uint8_t*)result.data(), result.size()),
@@ -176,6 +176,7 @@ struct HmacSha256Function {
   template <typename TTo, typename TFrom>
   FOLLY_ALWAYS_INLINE void
   call(TTo& result, const TFrom& data, const TFrom& key) {
+    VELOX_USER_CHECK_GT(key.size(), 0, "Empty key is not allowed");
     result.resize(32);
     folly::ssl::OpenSSLHash::hmac_sha256(
         folly::MutableByteRange((uint8_t*)result.data(), result.size()),
@@ -192,6 +193,7 @@ struct HmacSha512Function {
   template <typename TTo, typename TFrom>
   FOLLY_ALWAYS_INLINE void
   call(TTo& result, const TFrom& data, const TFrom& key) {
+    VELOX_USER_CHECK_GT(key.size(), 0, "Empty key is not allowed");
     result.resize(64);
     folly::ssl::OpenSSLHash::hmac_sha512(
         folly::MutableByteRange((uint8_t*)result.data(), result.size()),
@@ -209,6 +211,7 @@ struct HmacMd5Function {
       out_type<Varbinary>& result,
       const arg_type<Varbinary>& data,
       const arg_type<Varbinary>& key) {
+    VELOX_USER_CHECK_GT(key.size(), 0, "Empty key is not allowed");
     result.resize(16);
     folly::ssl::OpenSSLHash::hmac(
         folly::MutableByteRange((uint8_t*)result.data(), result.size()),
@@ -218,10 +221,6 @@ struct HmacMd5Function {
   }
 };
 
-FOLLY_ALWAYS_INLINE unsigned char toHex(unsigned char c) {
-  return c < 10 ? (c + '0') : (c + 'A' - 10);
-}
-
 template <typename T>
 struct ToHexFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -229,27 +228,7 @@ struct ToHexFunction {
   FOLLY_ALWAYS_INLINE void call(
       out_type<Varbinary>& result,
       const arg_type<Varchar>& input) {
-    static const char* const kHexTable =
-        "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"
-        "202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F"
-        "404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F"
-        "606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F"
-        "808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F"
-        "A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF"
-        "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF"
-        "E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF";
-
-    const auto inputSize = input.size();
-    result.resize(inputSize * 2);
-
-    const unsigned char* inputBuffer =
-        reinterpret_cast<const unsigned char*>(input.data());
-    char* resultBuffer = result.data();
-
-    for (auto i = 0; i < inputSize; ++i) {
-      resultBuffer[i * 2] = kHexTable[inputBuffer[i] * 2];
-      resultBuffer[i * 2 + 1] = kHexTable[inputBuffer[i] * 2 + 1];
-    }
+    ToHexUtil::toHex(input, result);
   }
 };
 
@@ -307,40 +286,33 @@ struct ToBase64Function {
   }
 };
 
-template <typename T>
+template <typename TExec>
 struct FromBase64Function {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
-  FOLLY_ALWAYS_INLINE void call(
-      out_type<Varbinary>& result,
-      const arg_type<Varchar>& input) {
-    try {
-      auto inputSize = input.size();
-      result.resize(
-          encoding::Base64::calculateDecodedSize(input.data(), inputSize));
-      encoding::Base64::decode(input.data(), input.size(), result.data());
-    } catch (const encoding::Base64Exception& e) {
-      VELOX_USER_FAIL(e.what());
-    }
+  // T can be either arg_type<Varchar> or arg_type<Varbinary>. These are the
+  // same, but hard-coding one of them might be confusing.
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void call(out_type<Varbinary>& result, const T& input) {
+    auto inputSize = input.size();
+    result.resize(
+        encoding::Base64::calculateDecodedSize(input.data(), inputSize));
+    encoding::Base64::decode(
+        input.data(), inputSize, result.data(), result.size());
   }
 };
 
 template <typename T>
 struct FromBase64UrlFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
-
   FOLLY_ALWAYS_INLINE void call(
       out_type<Varbinary>& result,
       const arg_type<Varchar>& input) {
-    auto inputData = input.data();
     auto inputSize = input.size();
-    bool hasPad =
-        inputSize > 0 && (*(input.end() - 1) == encoding::Base64::kBase64Pad);
     result.resize(
-        encoding::Base64::calculateDecodedSize(inputData, inputSize, hasPad));
-    hasPad = false; // calculateDecodedSize() updated inputSize to exclude pad.
+        encoding::Base64::calculateDecodedSize(input.data(), inputSize));
     encoding::Base64::decodeUrl(
-        inputData, inputSize, result.data(), result.size(), hasPad);
+        input.data(), inputSize, result.data(), result.size());
   }
 };
 
@@ -422,4 +394,76 @@ struct ToIEEE754Bits64 {
   }
 };
 
+template <typename T>
+struct FromIEEE754Bits64 {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<double>& result,
+      const arg_type<Varbinary>& input) {
+    static constexpr auto kTypeLength = sizeof(int64_t);
+    VELOX_USER_CHECK_EQ(input.size(), kTypeLength, "Expected 8-byte input");
+    memcpy(&result, input.data(), kTypeLength);
+    result = folly::Endian::big(result);
+  }
+};
+
+template <typename T>
+struct ToIEEE754Bits32 {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varbinary>& result,
+      const arg_type<float>& input) {
+    static constexpr auto kTypeLength = sizeof(int32_t);
+    auto value = folly::Endian::big(input);
+    result.setNoCopy(
+        StringView(reinterpret_cast<const char*>(&value), kTypeLength));
+  }
+};
+
+template <typename T>
+struct FromIEEE754Bits32 {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<float>& result,
+      const arg_type<Varbinary>& input) {
+    static constexpr auto kTypeLength = sizeof(int32_t);
+    VELOX_USER_CHECK_EQ(
+        input.size(),
+        kTypeLength,
+        "Input floating-point value must be exactly 4 bytes long");
+    memcpy(&result, input.data(), kTypeLength);
+    result = folly::Endian::big(result);
+  }
+};
+
+/// lpad(binary, size, padbinary) -> varbinary
+///     Left pads input to size characters with padding.  If size is
+///     less than the length of input, the result is truncated to size
+///     characters.  size must not be negative and padding must be non-empty.
+/// rpad(binary, size, padbinary) -> varbinary
+///     Right pads input to size characters with padding.  If size is
+///     less than the length of input, the result is truncated to size
+///     characters.  size must not be negative and padding must be non-empty.
+template <typename T, bool lpad>
+struct PadFunctionVarbinaryBase {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varbinary>& result,
+      const arg_type<Varbinary>& binary,
+      const arg_type<int64_t>& size,
+      const arg_type<Varbinary>& padbinary) {
+    stringImpl::pad<lpad, false /*isAscii*/>(result, binary, size, padbinary);
+  }
+};
+
+template <typename T>
+struct LPadVarbinaryFunction : public PadFunctionVarbinaryBase<T, true> {};
+
+template <typename T>
+struct RPadVarbinaryFunction : public PadFunctionVarbinaryBase<T, false> {};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Bitwise.h b/velox/functions/prestosql/Bitwise.h
index 6501855362558..37723c14be9f4 100644
--- a/velox/functions/prestosql/Bitwise.h
+++ b/velox/functions/prestosql/Bitwise.h
@@ -34,7 +34,7 @@ struct BitCountFunction {
     VELOX_USER_CHECK(
         bits >= 2 && bits <= kMaxBits,
         "Bits specified in bit_count must be between 2 and 64, got {}",
-        bits)
+        bits);
     // Check if input "num" falls within the limits of max and min that
     // can be represented with "bits".
     const uint64_t lowBitsMask = 1L << (bits - 1);
@@ -82,7 +82,7 @@ struct BitwiseArithmeticShiftRightFunction {
   // Only support bigint inputs.
   FOLLY_ALWAYS_INLINE void
   call(int64_t& result, int64_t number, int64_t shift) {
-    VELOX_USER_CHECK_GE(shift, 0, "Shift must be positive")
+    VELOX_USER_CHECK_GE(shift, 0, "Shift must be non-negative");
     if (shift >= 63) {
       if (number >= 0) {
         result = 0;
@@ -95,67 +95,37 @@ struct BitwiseArithmeticShiftRightFunction {
   }
 };
 
-namespace {
-template <typename T, int MAX_SHIFT>
-#if defined(__clang__)
-__attribute__((no_sanitize("integer")))
-#endif
-FOLLY_ALWAYS_INLINE bool
-bitwiseLeftShift(int64_t& result, T number, T shift) {
-  if ((uint64_t)shift >= MAX_SHIFT) {
-    result = 0;
-  } else {
-    result = (number << shift);
-  }
-  return true;
-}
-} // namespace
-
-template <typename T>
+template <typename TExec>
 struct BitwiseLeftShiftFunction {
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE bool call(int64_t& result, TInput number, TInput shift) {
-    if constexpr (std::is_same_v<TInput, int8_t>) {
-      return bitwiseLeftShift<TInput, 8>(result, number, shift);
-    } else if constexpr (std::is_same_v<TInput, int16_t>) {
-      return bitwiseLeftShift<TInput, 16>(result, number, shift);
-    } else if constexpr (std::is_same_v<TInput, int32_t>) {
-      return bitwiseLeftShift<TInput, 32>(result, number, shift);
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void call(T& result, T number, int32_t shift) {
+    static constexpr uint32_t kMaxShift = sizeof(T) * 8;
+
+    // Return zero if 'shift' is negative or exceeds number of bits in T.
+    if ((uint32_t)shift >= kMaxShift) {
+      result = 0;
     } else {
-      return bitwiseLeftShift<TInput, 64>(result, number, shift);
+      result = (number << shift);
     }
   }
 };
 
-namespace {
-template <typename T, typename UT, int MAX_SHIFT>
-FOLLY_ALWAYS_INLINE bool bitwiseRightShift(int64_t& result, T number, T shift) {
-  if ((uint64_t)shift >= MAX_SHIFT) {
-    result = 0;
-  } else {
-    result = ((UT)number >> shift);
-  }
-  return true;
-}
-} // namespace
-
-template <typename T>
+template <typename TExec>
 struct BitwiseRightShiftFunction {
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE bool call(int64_t& result, TInput number, TInput shift) {
-    if constexpr (std::is_same_v<TInput, int8_t>) {
-      return bitwiseRightShift<int8_t, uint8_t, 8>(result, number, shift);
-    } else if constexpr (std::is_same_v<TInput, int16_t>) {
-      return bitwiseRightShift<int16_t, uint16_t, 16>(result, number, shift);
-    } else if constexpr (std::is_same_v<TInput, int32_t>) {
-      return bitwiseRightShift<int32_t, uint32_t, 32>(result, number, shift);
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void call(T& result, T number, int32_t shift) {
+    static constexpr uint32_t kMaxShift = sizeof(T) * 8;
+
+    // Return zero if 'shift' is negative or exceeds number of bits in T.
+    if ((uint32_t)shift >= kMaxShift) {
+      result = 0;
     } else {
-      return bitwiseRightShift<int64_t, uint64_t, 64>(result, number, shift);
+      result = ((std::make_unsigned_t<T>)number) >> shift;
     }
   }
 };
 
-namespace {
+namespace detail {
 template <typename T, uint64_t MASK, uint64_t SIGNED_BIT>
 FOLLY_ALWAYS_INLINE int64_t preserveSign(T number) {
   if ((number & SIGNED_BIT) != 0) {
@@ -164,42 +134,40 @@ FOLLY_ALWAYS_INLINE int64_t preserveSign(T number) {
     return (number & MASK);
   }
 }
-} // namespace
+} // namespace detail
 
-template <typename T>
+template <typename TExec>
 struct BitwiseRightShiftArithmeticFunction {
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE bool call(int64_t& result, TInput number, TInput shift) {
-    if ((uint64_t)shift >= 64) {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void call(T& result, T number, int32_t shift) {
+    if ((uint32_t)shift >= 64) {
       if (number >= 0) {
         result = 0L;
       } else {
         result = -1L;
       }
-      return true;
+      return;
     }
 
     // clang-format off
-    if constexpr (std::is_same_v<TInput, int8_t>) {
-      result = preserveSign<int8_t, 0b11111111L, 0b10000000L>(number) >> shift;
-    } else if constexpr (std::is_same_v<TInput, int16_t>) {
-      result = preserveSign<int16_t, 0b1111111111111111L, 0b1000000000000000L>(number)
+    if constexpr (std::is_same_v<T, int8_t>) {
+      result = detail::preserveSign<int8_t, 0b11111111L, 0b10000000L>(number) >> shift;
+    } else if constexpr (std::is_same_v<T, int16_t>) {
+      result = detail::preserveSign<int16_t, 0b1111111111111111L, 0b1000000000000000L>(number)
                 >> shift;
-    } else if constexpr (std::is_same_v<TInput, int32_t>) {
-      result = preserveSign<int32_t, 0x00000000ffffffffL, 0x000000000080000000L>(number)
+    } else if constexpr (std::is_same_v<T, int32_t>) {
+      result = detail::preserveSign<int32_t, 0x00000000ffffffffL, 0x000000000080000000L>(number)
                 >> shift;
     } else {
       result = number >> shift;
     }
     // clang-format on
-
-    return true;
   }
 };
 
 template <typename T>
 struct BitwiseLogicalShiftRightFunction {
-  FOLLY_ALWAYS_INLINE bool
+  FOLLY_ALWAYS_INLINE void
 #if defined(__clang__)
       __attribute__((no_sanitize("integer")))
 #endif
@@ -207,16 +175,25 @@ struct BitwiseLogicalShiftRightFunction {
     // Presto defines this only for bigint, thus we will define this only for
     // int64_t.
     if (bits == 64) {
+      if (number < 0) {
+        // >> operator may perform an arithmetic shift right for signed
+        // integers, depending on the compiler, which gives wrong result when
+        // the input is negative. To ensure a logical shift, we cast it to
+        // uint64_t.
+        uint64_t unsignedNumber = static_cast<uint64_t>(number) >> shift;
+        result = static_cast<int64_t>(unsignedNumber);
+        return;
+      }
       result = number >> shift;
-      return true;
+      return;
     }
 
     VELOX_USER_CHECK(
         !(bits <= 1 || bits > 64), "Bits must be between 2 and 64");
-    VELOX_USER_CHECK_GT(shift, 0, "Shift must be positive");
+    VELOX_USER_CHECK_GE(shift, 0, "Shift must be non-negative");
 
     result = (number & ((1LL << bits) - 1)) >> shift;
-    return true;
+    return;
   }
 };
 
@@ -230,13 +207,13 @@ struct BitwiseShiftLeftFunction {
     // Presto defines this only for bigint, thus we will define this only for
     // int64_t.
     if (bits == 64) {
-      result = number >> shift;
+      result = number << shift;
       return true;
     }
 
     VELOX_USER_CHECK(
         !(bits <= 1 || bits > 64), "Bits must be between 2 and 64");
-    VELOX_USER_CHECK_GT(shift, 0, "Shift must be positive");
+    VELOX_USER_CHECK_GE(shift, 0, "Shift must be non-negative");
 
     if (shift > 64) {
       result = 0;
diff --git a/velox/functions/prestosql/CMakeLists.txt b/velox/functions/prestosql/CMakeLists.txt
index 9ea227de4b1cc..fb08d3217793e 100644
--- a/velox/functions/prestosql/CMakeLists.txt
+++ b/velox/functions/prestosql/CMakeLists.txt
@@ -15,7 +15,7 @@ add_subdirectory(json)
 add_subdirectory(types)
 add_subdirectory(window)
 
-add_library(
+velox_add_library(
   velox_functions_prestosql_impl
   ArrayConstructor.cpp
   ArrayContains.cpp
@@ -24,17 +24,14 @@ add_library(
   ArrayIntersectExcept.cpp
   ArrayAndMapMatch.cpp
   ArrayPosition.cpp
-  ArrayShuffle.cpp
   ArraySort.cpp
   ArraySum.cpp
   Comparisons.cpp
-  DecimalVectorFunctions.cpp
+  DecimalFunctions.cpp
   ElementAt.cpp
   FilterFunctions.cpp
   FindFirst.cpp
-  FromUnixTime.cpp
   FromUtf8.cpp
-  GreatestLeast.cpp
   InPredicate.cpp
   JsonFunctions.cpp
   Map.cpp
@@ -44,40 +41,42 @@ add_library(
   MapZipWith.cpp
   Not.cpp
   Reduce.cpp
-  Repeat.cpp
   Reverse.cpp
   RowFunction.cpp
   Sequence.cpp
   SimpleComparisonMatcher.cpp
-  Slice.cpp
   Split.cpp
+  SplitToMap.cpp
   StringFunctions.cpp
   Subscript.cpp
   ToUtf8.cpp
   Transform.cpp
   TransformKeys.cpp
   TransformValues.cpp
+  TypeOf.cpp
   URLFunctions.cpp
-  Utf8Utils.cpp
   VectorArithmetic.cpp
   WidthBucketArray.cpp
   Zip.cpp
   ZipWith.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_functions_prestosql_impl
   velox_common_hyperloglog
   velox_functions_json
   velox_functions_lib
   velox_expression
-  md5
+  velox_external_md5
   velox_type_tz
   velox_presto_types
   velox_functions_util
-  Folly::folly)
+  Folly::folly
+  stemmer::stemmer)
 
-set_property(TARGET velox_functions_prestosql_impl PROPERTY JOB_POOL_COMPILE
-                                                            high_memory_pool)
+if(NOT VELOX_MONO_LIBRARY)
+  set_property(TARGET velox_functions_prestosql_impl PROPERTY JOB_POOL_COMPILE
+                                                              high_memory_pool)
+endif()
 
 if(${VELOX_ENABLE_AGGREGATES})
   add_subdirectory(aggregates)
@@ -86,6 +85,7 @@ endif()
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
   add_subdirectory(coverage)
+  add_subdirectory(fuzzer)
 elseif(${VELOX_BUILD_TEST_UTILS})
   add_subdirectory(tests/utils)
 endif()
diff --git a/velox/functions/prestosql/Cardinality.h b/velox/functions/prestosql/Cardinality.h
index d2dfc07851aef..28fde43cae53d 100644
--- a/velox/functions/prestosql/Cardinality.h
+++ b/velox/functions/prestosql/Cardinality.h
@@ -23,11 +23,13 @@ template <typename T>
 struct CardinalityFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  void call(int64_t& out, const arg_type<Array<Any>>& input) {
+  void call(int64_t& out, const arg_type<Array<Generic<T1>>>& input) {
     out = input.size();
   }
 
-  void call(int64_t& out, const arg_type<Map<Any, Any>>& input) {
+  void call(
+      int64_t& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& input) {
     out = input.size();
   }
 };
diff --git a/velox/functions/prestosql/Comparisons.cpp b/velox/functions/prestosql/Comparisons.cpp
index 61dc49ced966a..ef5e76d773a5b 100644
--- a/velox/functions/prestosql/Comparisons.cpp
+++ b/velox/functions/prestosql/Comparisons.cpp
@@ -17,10 +17,18 @@
 #include "velox/functions/prestosql/Comparisons.h"
 #include <velox/common/base/Exceptions.h>
 #include "velox/functions/Udf.h"
+#include "velox/functions/lib/SIMDComparisonUtil.h"
 #include "velox/vector/BaseVector.h"
 
 namespace facebook::velox::functions {
 
+using Eq = std::equal_to<>;
+using Neq = std::not_equal_to<>;
+using Lt = std::less<>;
+using Lte = std::less_equal<>;
+using Gt = std::greater<>;
+using Gte = std::greater_equal<>;
+
 namespace {
 
 /// This class implements comparison for vectors of primitive types using SIMD.
@@ -29,68 +37,26 @@ namespace {
 /// If the vector encoding is not flat, we revert to non simd approach.
 template <typename ComparisonOp, typename Arch = xsimd::default_arch>
 struct SimdComparator {
-  template <typename T, bool isConstant>
-  inline auto loadSimdData(const T* rawData, vector_size_t offset) {
-    using d_type = xsimd::batch<T>;
-    if constexpr (isConstant) {
-      return xsimd::broadcast<T>(rawData[0]);
-    }
-    return d_type::load_unaligned(rawData + offset);
-  }
-
-  template <typename T, bool isLeftConstant, bool isRightConstant>
-  void applySimdComparison(
-      const vector_size_t begin,
-      const vector_size_t end,
-      const T* rawLhs,
-      const T* rawRhs,
-      uint8_t* rawResult) {
-    using d_type = xsimd::batch<T>;
-    constexpr auto numScalarElements = d_type::size;
-    const auto vectorEnd = (end - begin) - (end - begin) % numScalarElements;
-
-    if constexpr (numScalarElements == 2 || numScalarElements == 4) {
-      for (auto i = begin; i < vectorEnd; i += 8) {
-        rawResult[i / 8] = 0;
-        for (auto j = 0; j < 8 && j < vectorEnd; j += numScalarElements) {
-          auto left = loadSimdData<T, isLeftConstant>(rawLhs, i + j);
-          auto right = loadSimdData<T, isRightConstant>(rawRhs, i + j);
-
-          uint8_t res = simd::toBitMask(ComparisonOp()(left, right));
-          rawResult[i / 8] |= res << j;
-        }
+  template <typename T>
+  inline bool compare(T& l, T& r) const {
+    if constexpr (std::is_floating_point_v<T>) {
+      bool filtered = false;
+      if constexpr (std::is_same_v<ComparisonOp, Eq>) {
+        filtered = util::floating_point::NaNAwareEquals<T>{}(l, r);
+      } else if constexpr (std::is_same_v<ComparisonOp, Neq>) {
+        filtered = !util::floating_point::NaNAwareEquals<T>{}(l, r);
+      } else if constexpr (std::is_same_v<ComparisonOp, Lt>) {
+        filtered = util::floating_point::NaNAwareLessThan<T>{}(l, r);
+      } else if constexpr (std::is_same_v<ComparisonOp, Lte>) {
+        filtered = util::floating_point::NaNAwareLessThanEqual<T>{}(l, r);
+      } else if constexpr (std::is_same_v<ComparisonOp, Gt>) {
+        filtered = util::floating_point::NaNAwareGreaterThan<T>{}(l, r);
+      } else if constexpr (std::is_same_v<ComparisonOp, Gte>) {
+        filtered = util::floating_point::NaNAwareGreaterThanEqual<T>{}(l, r);
       }
+      return filtered;
     } else {
-      for (auto i = begin; i < vectorEnd; i += numScalarElements) {
-        auto left = loadSimdData<T, isLeftConstant>(rawLhs, i);
-        auto right = loadSimdData<T, isRightConstant>(rawRhs, i);
-
-        auto res = simd::toBitMask(ComparisonOp()(left, right));
-        if constexpr (numScalarElements == 8) {
-          rawResult[i / 8] = res;
-        } else if constexpr (numScalarElements == 16) {
-          uint16_t* addr = reinterpret_cast<uint16_t*>(rawResult + i / 8);
-          *addr = res;
-        } else if constexpr (numScalarElements == 32) {
-          uint32_t* addr = reinterpret_cast<uint32_t*>(rawResult + i / 8);
-          *addr = res;
-        } else {
-          VELOX_FAIL("Unsupported number of scalar elements");
-        }
-      }
-    }
-
-    // Evaluate remaining values.
-    for (auto i = vectorEnd; i < end; i++) {
-      if constexpr (isRightConstant && isLeftConstant) {
-        bits::setBit(rawResult, i, ComparisonOp()(rawLhs[0], rawRhs[0]));
-      } else if constexpr (isRightConstant) {
-        bits::setBit(rawResult, i, ComparisonOp()(rawLhs[i], rawRhs[0]));
-      } else if constexpr (isLeftConstant) {
-        bits::setBit(rawResult, i, ComparisonOp()(rawLhs[0], rawRhs[i]));
-      } else {
-        bits::setBit(rawResult, i, ComparisonOp()(rawLhs[i], rawRhs[i]));
-      }
+      return ComparisonOp()(l, r);
     }
   }
 
@@ -113,43 +79,46 @@ struct SimdComparator {
     auto resultVector = result->asUnchecked<FlatVector<bool>>();
     auto rawResult = resultVector->mutableRawValues<uint8_t>();
 
-    auto isSimdizable = (lhs.isConstantEncoding() || lhs.isFlatEncoding()) &&
+    bool isSimdizable = (lhs.isConstantEncoding() || lhs.isFlatEncoding()) &&
         (rhs.isConstantEncoding() || rhs.isFlatEncoding()) &&
         rows.isAllSelected();
 
-    if (!isSimdizable || std::is_same_v<T, int128_t>) {
+    static const bool isTypeNotSupported =
+        std::is_same_v<T, int128_t> || std::is_floating_point_v<T>;
+
+    if (!isSimdizable || isTypeNotSupported) {
       exec::LocalDecodedVector lhsDecoded(context, lhs, rows);
       exec::LocalDecodedVector rhsDecoded(context, rhs, rows);
 
       context.template applyToSelectedNoThrow(rows, [&](auto row) {
         auto l = lhsDecoded->template valueAt<T>(row);
         auto r = rhsDecoded->template valueAt<T>(row);
-        auto filtered = ComparisonOp()(l, r);
+        auto filtered = compare(l, r);
         resultVector->set(row, filtered);
       });
       return;
     }
 
-    if constexpr (!std::is_same_v<T, int128_t>) {
+    if constexpr (!isTypeNotSupported) {
       if (lhs.isConstantEncoding() && rhs.isConstantEncoding()) {
         auto l = lhs.asUnchecked<ConstantVector<T>>()->valueAt(0);
         auto r = rhs.asUnchecked<ConstantVector<T>>()->valueAt(0);
-        applySimdComparison<T, true, true>(
+        applySimdComparison<T, true, true, ComparisonOp>(
             rows.begin(), rows.end(), &l, &r, rawResult);
       } else if (lhs.isConstantEncoding()) {
         auto l = lhs.asUnchecked<ConstantVector<T>>()->valueAt(0);
         auto rawRhs = rhs.asUnchecked<FlatVector<T>>()->rawValues();
-        applySimdComparison<T, true, false>(
+        applySimdComparison<T, true, false, ComparisonOp>(
             rows.begin(), rows.end(), &l, rawRhs, rawResult);
       } else if (rhs.isConstantEncoding()) {
         auto rawLhs = lhs.asUnchecked<FlatVector<T>>()->rawValues();
         auto r = rhs.asUnchecked<ConstantVector<T>>()->valueAt(0);
-        applySimdComparison<T, false, true>(
+        applySimdComparison<T, false, true, ComparisonOp>(
             rows.begin(), rows.end(), rawLhs, &r, rawResult);
       } else {
         auto rawLhs = lhs.asUnchecked<FlatVector<T>>()->rawValues();
         auto rawRhs = rhs.asUnchecked<FlatVector<T>>()->rawValues();
-        applySimdComparison<T, false, false>(
+        applySimdComparison<T, false, false, ComparisonOp>(
             rows.begin(), rows.end(), rawLhs, rawRhs, rawResult);
       }
 
@@ -210,8 +179,17 @@ class ComparisonSimdFunction : public exec::VectorFunction {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
 
-    for (const auto& inputType :
-         {"tinyint", "smallint", "integer", "bigint", "real", "double"}) {
+    for (const auto& inputType : {
+             "tinyint",
+             "smallint",
+             "integer",
+             "bigint",
+             "real",
+             "double",
+             "date",
+             "interval day to second",
+             "interval year to month",
+         }) {
       signatures.push_back(exec::FunctionSignatureBuilder()
                                .returnType("boolean")
                                .argumentType(inputType)
@@ -231,38 +209,44 @@ class ComparisonSimdFunction : public exec::VectorFunction {
   bool supportsFlatNoNullsFastPath() const override {
     return true;
   }
+
+  exec::FunctionCanonicalName getCanonicalName() const override {
+    return std::is_same_v<ComparisonOp, Lt>
+        ? exec::FunctionCanonicalName::kLt
+        : exec::FunctionCanonicalName::kUnknown;
+  }
 };
 
 } // namespace
 
 VELOX_DECLARE_VECTOR_FUNCTION(
     udf_simd_comparison_eq,
-    (ComparisonSimdFunction<std::equal_to<>>::signatures()),
-    (std::make_unique<ComparisonSimdFunction<std::equal_to<>>>()));
+    (ComparisonSimdFunction<Eq>::signatures()),
+    (std::make_unique<ComparisonSimdFunction<Eq>>()));
 
 VELOX_DECLARE_VECTOR_FUNCTION(
     udf_simd_comparison_neq,
-    (ComparisonSimdFunction<std::not_equal_to<>>::signatures()),
-    (std::make_unique<ComparisonSimdFunction<std::not_equal_to<>>>()));
+    (ComparisonSimdFunction<Neq>::signatures()),
+    (std::make_unique<ComparisonSimdFunction<Neq>>()));
 
 VELOX_DECLARE_VECTOR_FUNCTION(
     udf_simd_comparison_lt,
-    (ComparisonSimdFunction<std::less<>>::signatures()),
-    (std::make_unique<ComparisonSimdFunction<std::less<>>>()));
+    (ComparisonSimdFunction<Lt>::signatures()),
+    (std::make_unique<ComparisonSimdFunction<Lt>>()));
 
 VELOX_DECLARE_VECTOR_FUNCTION(
     udf_simd_comparison_gt,
-    (ComparisonSimdFunction<std::greater<>>::signatures()),
-    (std::make_unique<ComparisonSimdFunction<std::greater<>>>()));
+    (ComparisonSimdFunction<Gt>::signatures()),
+    (std::make_unique<ComparisonSimdFunction<Gt>>()));
 
 VELOX_DECLARE_VECTOR_FUNCTION(
     udf_simd_comparison_lte,
-    (ComparisonSimdFunction<std::less_equal<>>::signatures()),
-    (std::make_unique<ComparisonSimdFunction<std::less_equal<>>>()));
+    (ComparisonSimdFunction<Lte>::signatures()),
+    (std::make_unique<ComparisonSimdFunction<Lte>>()));
 
 VELOX_DECLARE_VECTOR_FUNCTION(
     udf_simd_comparison_gte,
-    (ComparisonSimdFunction<std::greater_equal<>>::signatures()),
-    (std::make_unique<ComparisonSimdFunction<std::greater_equal<>>>()));
+    (ComparisonSimdFunction<Gte>::signatures()),
+    (std::make_unique<ComparisonSimdFunction<Gte>>()));
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Comparisons.h b/velox/functions/prestosql/Comparisons.h
index a75b4ce4dc54a..9550524063202 100644
--- a/velox/functions/prestosql/Comparisons.h
+++ b/velox/functions/prestosql/Comparisons.h
@@ -18,119 +18,119 @@
 #include "velox/common/base/CompareFlags.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::functions {
 
-namespace {
-template <typename T>
-struct TimestampWithTimezoneComparisonSupport {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  // Convert TimestampWithTimezone from original timezone to GMT in milliseconds
-  FOLLY_ALWAYS_INLINE
-  int64_t toGMTMillis(
-      const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
-    const int64_t milliseconds = *timestampWithTimezone.template at<0>();
-    const int16_t timezone = *timestampWithTimezone.template at<1>();
-    Timestamp inputTimeStamp = Timestamp::fromMillis(milliseconds);
-    inputTimeStamp.toGMT(timezone);
-    return inputTimeStamp.toMillis();
-  }
-};
+#define VELOX_GEN_BINARY_EXPR(Name, Expr, ExprForFloats)       \
+  template <typename T>                                        \
+  struct Name {                                                \
+    VELOX_DEFINE_FUNCTION_TYPES(T);                            \
+    template <typename TInput>                                 \
+    FOLLY_ALWAYS_INLINE void                                   \
+    call(bool& result, const TInput& lhs, const TInput& rhs) { \
+      if constexpr (std::is_floating_point_v<TInput>) {        \
+        result = (ExprForFloats);                              \
+        return;                                                \
+      }                                                        \
+      result = (Expr);                                         \
+    }                                                          \
+  };
 
-} // namespace
-
-#define VELOX_GEN_BINARY_EXPR(Name, Expr, tsExpr, TResult)         \
-  template <typename T>                                            \
-  struct Name : public TimestampWithTimezoneComparisonSupport<T> { \
-    VELOX_DEFINE_FUNCTION_TYPES(T);                                \
-    template <typename TInput>                                     \
-    FOLLY_ALWAYS_INLINE void                                       \
-    call(TResult& result, const TInput& lhs, const TInput& rhs) {  \
-      result = (Expr);                                             \
-    }                                                              \
-                                                                   \
-    FOLLY_ALWAYS_INLINE void call(                                 \
-        bool& result,                                              \
-        const arg_type<TimestampWithTimezone>& lhs,                \
-        const arg_type<TimestampWithTimezone>& rhs) {              \
-      result = (tsExpr);                                           \
-    }                                                              \
+#define VELOX_GEN_BINARY_EXPR_TIMESTAMP_WITH_TIME_ZONE(Name, tsExpr, TResult) \
+  template <typename T>                                                       \
+  struct Name##TimestampWithTimezone {                                        \
+    VELOX_DEFINE_FUNCTION_TYPES(T);                                           \
+    FOLLY_ALWAYS_INLINE void call(                                            \
+        bool& result,                                                         \
+        const arg_type<TimestampWithTimezone>& lhs,                           \
+        const arg_type<TimestampWithTimezone>& rhs) {                         \
+      result = (tsExpr);                                                      \
+    }                                                                         \
   };
 
 VELOX_GEN_BINARY_EXPR(
     LtFunction,
     lhs < rhs,
-    this->toGMTMillis(lhs) < this->toGMTMillis(rhs),
-    bool);
+    util::floating_point::NaNAwareLessThan<TInput>{}(lhs, rhs));
 VELOX_GEN_BINARY_EXPR(
     GtFunction,
     lhs > rhs,
-    this->toGMTMillis(lhs) > this->toGMTMillis(rhs),
-    bool);
+    util::floating_point::NaNAwareGreaterThan<TInput>{}(lhs, rhs));
 VELOX_GEN_BINARY_EXPR(
     LteFunction,
     lhs <= rhs,
-    this->toGMTMillis(lhs) <= this->toGMTMillis(rhs),
-    bool);
+    util::floating_point::NaNAwareLessThanEqual<TInput>{}(lhs, rhs));
 VELOX_GEN_BINARY_EXPR(
     GteFunction,
     lhs >= rhs,
-    this->toGMTMillis(lhs) >= this->toGMTMillis(rhs),
+    util::floating_point::NaNAwareGreaterThanEqual<TInput>{}(lhs, rhs));
+
+VELOX_GEN_BINARY_EXPR_TIMESTAMP_WITH_TIME_ZONE(
+    LtFunction,
+    unpackMillisUtc(lhs) < unpackMillisUtc(rhs),
+    bool);
+VELOX_GEN_BINARY_EXPR_TIMESTAMP_WITH_TIME_ZONE(
+    GtFunction,
+    unpackMillisUtc(lhs) > unpackMillisUtc(rhs),
+    bool);
+VELOX_GEN_BINARY_EXPR_TIMESTAMP_WITH_TIME_ZONE(
+    LteFunction,
+    unpackMillisUtc(lhs) <= unpackMillisUtc(rhs),
+    bool);
+VELOX_GEN_BINARY_EXPR_TIMESTAMP_WITH_TIME_ZONE(
+    GteFunction,
+    unpackMillisUtc(lhs) >= unpackMillisUtc(rhs),
     bool);
 
 #undef VELOX_GEN_BINARY_EXPR
+#undef VELOX_GEN_BINARY_EXPR_TIMESTAMP_WITH_TIME_ZONE
 
-template <typename T>
+template <typename TExec>
 struct DistinctFromFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE void
-  call(bool& result, const TInput& lhs, const TInput& rhs) {
-    result = (lhs != rhs); // Return true if distinct.
-  }
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE void
-  callNullable(bool& result, const TInput* lhs, const TInput* rhs) {
-    if (!lhs and !rhs) { // Both nulls -> not distinct -> false.
+  void callNullable(
+      bool& result,
+      const arg_type<Generic<T1>>* lhs,
+      const arg_type<Generic<T1>>* rhs) {
+    if (!lhs and !rhs) {
+      // Both nulls -> not distinct.
       result = false;
-    } else if (!lhs or !rhs) { // Only one is null -> distinct -> true.
+    } else if (!lhs or !rhs) {
+      // Only one is null -> distinct.
       result = true;
     } else { // Both not nulls - use usual comparison.
-      call(result, *lhs, *rhs);
+      static constexpr CompareFlags kCompareFlags =
+          CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
+
+      result = lhs->compare(*rhs, kCompareFlags).value();
     }
   }
 };
 
 template <typename T>
-struct EqFunction : public TimestampWithTimezoneComparisonSupport<T> {
+struct EqFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   // Used for primitive inputs.
   template <typename TInput>
   void call(bool& out, const TInput& lhs, const TInput& rhs) {
+    if constexpr (std::is_floating_point_v<TInput>) {
+      out = util::floating_point::NaNAwareEquals<TInput>{}(lhs, rhs);
+      return;
+    }
     out = (lhs == rhs);
   }
 
-  // For TimestampWithTimezone.
-  void call(
-      bool& result,
-      const arg_type<TimestampWithTimezone>& lhs,
-      const arg_type<TimestampWithTimezone>& rhs) {
-    result = this->toGMTMillis(lhs) == this->toGMTMillis(rhs);
-  }
-
   // For arbitrary nested complex types. Can return null.
   bool call(
       bool& out,
       const arg_type<Generic<T1>>& lhs,
       const arg_type<Generic<T1>>& rhs) {
-    static constexpr CompareFlags kFlags = {
-        false,
-        false,
-        /*euqalsOnly*/ true,
-        CompareFlags::NullHandlingMode::StopAtNull /*nullHandlingMode*/};
+    static constexpr CompareFlags kFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
     auto result = lhs.compare(rhs, kFlags);
     if (!result.has_value()) {
       return false;
@@ -141,21 +141,29 @@ struct EqFunction : public TimestampWithTimezoneComparisonSupport<T> {
 };
 
 template <typename T>
-struct NeqFunction : public TimestampWithTimezoneComparisonSupport<T> {
+struct EqFunctionTimestampWithTimezone {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  // Used for primitive inputs.
-  template <typename TInput>
-  void call(bool& out, const TInput& lhs, const TInput& rhs) {
-    out = (lhs != rhs);
-  }
-
-  // For TimestampWithTimezone.
   void call(
       bool& result,
       const arg_type<TimestampWithTimezone>& lhs,
       const arg_type<TimestampWithTimezone>& rhs) {
-    result = this->toGMTMillis(lhs) != this->toGMTMillis(rhs);
+    result = unpackMillisUtc(lhs) == unpackMillisUtc(rhs);
+  }
+};
+
+template <typename T>
+struct NeqFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Used for primitive inputs.
+  template <typename TInput>
+  void call(bool& out, const TInput& lhs, const TInput& rhs) {
+    if constexpr (std::is_floating_point_v<TInput>) {
+      out = !util::floating_point::NaNAwareEquals<TInput>{}(lhs, rhs);
+      return;
+    }
+    out = (lhs != rhs);
   }
 
   // For arbitrary nested complex types. Can return null.
@@ -173,15 +181,45 @@ struct NeqFunction : public TimestampWithTimezoneComparisonSupport<T> {
 };
 
 template <typename T>
-struct BetweenFunction {
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE void call(
+struct NeqFunctionTimestampWithTimezone {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(
       bool& result,
-      const TInput& value,
-      const TInput& low,
-      const TInput& high) {
+      const arg_type<TimestampWithTimezone>& lhs,
+      const arg_type<TimestampWithTimezone>& rhs) {
+    result = unpackMillisUtc(lhs) != unpackMillisUtc(rhs);
+  }
+};
+
+template <typename TExec>
+struct BetweenFunction {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void
+  call(bool& result, const T& value, const T& low, const T& high) {
+    if constexpr (std::is_floating_point_v<T>) {
+      result =
+          util::floating_point::NaNAwareGreaterThanEqual<T>{}(value, low) &&
+          util::floating_point::NaNAwareLessThanEqual<T>{}(value, high);
+      return;
+    }
     result = value >= low && value <= high;
   }
 };
 
+template <typename TExec>
+struct BetweenFunctionTimestampWithTimezone {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      bool& result,
+      const arg_type<TimestampWithTimezone>& value,
+      const arg_type<TimestampWithTimezone>& low,
+      const arg_type<TimestampWithTimezone>& high) {
+    const auto millis = unpackMillisUtc(value);
+    result =
+        (millis >= unpackMillisUtc(low)) && (millis <= unpackMillisUtc(high));
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/DateTimeFunctions.h b/velox/functions/prestosql/DateTimeFunctions.h
index 2f45618cf8417..7672a2184bcbc 100644
--- a/velox/functions/prestosql/DateTimeFunctions.h
+++ b/velox/functions/prestosql/DateTimeFunctions.h
@@ -30,19 +30,17 @@ template <typename T>
 struct ToUnixtimeFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       double& result,
       const arg_type<Timestamp>& timestamp) {
     result = toUnixtime(timestamp);
-    return true;
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       double& result,
       const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
-    const auto milliseconds = *timestampWithTimezone.template at<0>();
+    const auto milliseconds = unpackMillisUtc(timestampWithTimezone);
     result = (double)milliseconds / kMillisecondsInSecond;
-    return true;
   }
 };
 
@@ -50,16 +48,57 @@ template <typename T>
 struct FromUnixtimeFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  FOLLY_ALWAYS_INLINE bool call(
+  // (double) -> timestamp
+  FOLLY_ALWAYS_INLINE void call(
       Timestamp& result,
       const arg_type<double>& unixtime) {
-    auto resultOptional = fromUnixtime(unixtime);
-    if (LIKELY(resultOptional.has_value())) {
-      result = resultOptional.value();
-      return true;
+    result = fromUnixtime(unixtime);
+  }
+
+  // (double, varchar) -> timestamp with time zone
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<double>* /*unixtime*/,
+      const arg_type<Varchar>* timezone) {
+    if (timezone != nullptr) {
+      tzID_ = tz::getTimeZoneID((std::string_view)(*timezone));
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<double>& unixtime,
+      const arg_type<Varchar>& timezone) {
+    int16_t timezoneId =
+        tzID_.value_or(tz::getTimeZoneID((std::string_view)timezone));
+    result = pack(fromUnixtime(unixtime).toMillis(), timezoneId);
+  }
+
+  // (double, bigint, bigint) -> timestamp with time zone
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<double>* /*unixtime*/,
+      const arg_type<int64_t>* hours,
+      const arg_type<int64_t>* minutes) {
+    if (hours != nullptr && minutes != nullptr) {
+      tzID_ = tz::getTimeZoneID(*hours * 60 + *minutes);
     }
-    return false;
   }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<double>& unixtime,
+      const arg_type<int64_t>& hours,
+      const arg_type<int64_t>& minutes) {
+    int16_t timezoneId =
+        tzID_.value_or(tz::getTimeZoneID(hours * 60 + minutes));
+    result = pack(fromUnixtime(unixtime).toMillis(), timezoneId);
+  }
+
+ private:
+  std::optional<int64_t> tzID_;
 };
 
 namespace {
@@ -69,29 +108,30 @@ struct TimestampWithTimezoneSupport {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   // Convert timestampWithTimezone to a timestamp representing the moment at the
-  // zone in timestampWithTimezone.
+  // zone in timestampWithTimezone. If `asGMT` is set to true, return the GMT
+  // time at the same moment.
   FOLLY_ALWAYS_INLINE
   Timestamp toTimestamp(
-      const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
-    const auto milliseconds = *timestampWithTimezone.template at<0>();
-    Timestamp timestamp = Timestamp::fromMillis(milliseconds);
-    timestamp.toTimezone(*timestampWithTimezone.template at<1>());
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone,
+      bool asGMT = false) {
+    auto timestamp = unpackTimestampUtc(timestampWithTimezone);
+    if (!asGMT) {
+      timestamp.toTimezone(
+          *tz::locateZone(unpackZoneKeyId(timestampWithTimezone)));
+    }
 
     return timestamp;
   }
 
-  // Get offset in seconds with GMT from timestampWithTimezone
+  // Get offset in seconds with GMT from timestampWithTimezone.
   FOLLY_ALWAYS_INLINE
   int64_t getGMTOffsetSec(
       const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
     Timestamp inputTimeStamp = this->toTimestamp(timestampWithTimezone);
-    // Get the given timezone name
-    auto timezone =
-        util::getTimeZoneName(*timestampWithTimezone.template at<1>());
-    auto* timezonePtr = date::locate_zone(timezone);
     // Create a copy of inputTimeStamp and convert it to GMT
     auto gmtTimeStamp = inputTimeStamp;
-    gmtTimeStamp.toGMT(*timezonePtr);
+    gmtTimeStamp.toGMT(*tz::locateZone(unpackZoneKeyId(timestampWithTimezone)));
+
     // Get offset in seconds with GMT and convert to hour
     return (inputTimeStamp.getSeconds() - gmtTimeStamp.getSeconds());
   }
@@ -103,65 +143,52 @@ template <typename T>
 struct DateFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  const date::time_zone* timeZone_ = nullptr;
-
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* date) {
     timeZone_ = getTimeZoneFromConfig(config);
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Timestamp>* timestamp) {
     timeZone_ = getTimeZoneFromConfig(config);
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<TimestampWithTimezone>* timestampWithTimezone) {
-    timeZone_ = getTimeZoneFromConfig(config);
+    // Do nothing. Session timezone doesn't affect the result.
   }
 
-  FOLLY_ALWAYS_INLINE void call(
-      out_type<Date>& result,
-      const arg_type<Varchar>& date) {
-    result = DATE()->toDays(date);
-  }
-
-  int32_t timestampToDate(const Timestamp& input) {
-    auto convertToDate = [](const Timestamp& t) -> int32_t {
-      static const int32_t kSecsPerDay{86'400};
-      auto seconds = t.getSeconds();
-      if (seconds >= 0 || seconds % kSecsPerDay == 0) {
-        return seconds / kSecsPerDay;
-      }
-      // For division with negatives, minus 1 to compensate the discarded
-      // fractional part. e.g. -1/86'400 yields 0, yet it should be considered
-      // as -1 day.
-      return seconds / kSecsPerDay - 1;
-    };
-
-    if (timeZone_ != nullptr) {
-      Timestamp t = input;
-      t.toTimezone(*timeZone_);
-      return convertToDate(t);
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Date>& result, const arg_type<Varchar>& date) {
+    auto days = util::fromDateString(date, util::ParseMode::kPrestoCast);
+    if (days.hasError()) {
+      return days.error();
     }
 
-    return convertToDate(input);
+    result = days.value();
+    return Status::OK();
   }
 
   FOLLY_ALWAYS_INLINE void call(
       out_type<Date>& result,
       const arg_type<Timestamp>& timestamp) {
-    result = timestampToDate(timestamp);
+    result = util::toDate(timestamp, timeZone_);
   }
 
   FOLLY_ALWAYS_INLINE void call(
       out_type<Date>& result,
       const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
-    result = timestampToDate(this->toTimestamp(timestampWithTimezone));
+    result = util::toDate(this->toTimestamp(timestampWithTimezone), nullptr);
   }
+
+ private:
+  const tz::TimeZone* timeZone_ = nullptr;
 };
 
 template <typename T>
@@ -187,9 +214,11 @@ struct WeekFunction : public InitSessionTimezone<T>,
       auto firstMondayOfYear =
           1 + (mondayOfWeek + kDaysInWeek - 1) % kDaysInWeek;
 
+      // A long year is any year ending on Thursday and any leap year ending on
+      // Friday.
       if ((util::isLeapYear(time.tm_year + 1900 - 1) &&
-           firstMondayOfYear == 2) ||
-          firstMondayOfYear == 3 || firstMondayOfYear == 4) {
+           firstMondayOfYear == 3) ||
+          firstMondayOfYear == 4) {
         week = 53;
       } else {
         week = 52;
@@ -253,6 +282,17 @@ struct YearFunction : public InitSessionTimezone<T>,
   }
 };
 
+template <typename T>
+struct YearFromIntervalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<IntervalYearMonth>& months) {
+    result = months / 12;
+  }
+};
+
 template <typename T>
 struct QuarterFunction : public InitSessionTimezone<T>,
                          public TimestampWithTimezoneSupport<T> {
@@ -307,6 +347,17 @@ struct MonthFunction : public InitSessionTimezone<T>,
   }
 };
 
+template <typename T>
+struct MonthFromIntervalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<IntervalYearMonth>& months) {
+    result = months % 12;
+  }
+};
+
 template <typename T>
 struct DayFunction : public InitSessionTimezone<T>,
                      public TimestampWithTimezoneSupport<T> {
@@ -330,6 +381,17 @@ struct DayFunction : public InitSessionTimezone<T>,
   }
 };
 
+template <typename T>
+struct DayFromIntervalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<IntervalDayTime>& interval) {
+    result = interval / kMillisInDay;
+  }
+};
+
 template <typename T>
 struct LastDayOfMonthFunction : public InitSessionTimezone<T>,
                                 public TimestampWithTimezoneSupport<T> {
@@ -339,14 +401,26 @@ struct LastDayOfMonthFunction : public InitSessionTimezone<T>,
       out_type<Date>& result,
       const arg_type<Timestamp>& timestamp) {
     auto dt = getDateTime(timestamp, this->timeZone_);
-    result = util::lastDayOfMonthSinceEpochFromDate(dt);
+    Expected<int64_t> daysSinceEpochFromDate =
+        util::lastDayOfMonthSinceEpochFromDate(dt);
+    if (daysSinceEpochFromDate.hasError()) {
+      VELOX_DCHECK(daysSinceEpochFromDate.error().isUserError());
+      VELOX_USER_FAIL(daysSinceEpochFromDate.error().message());
+    }
+    result = daysSinceEpochFromDate.value();
   }
 
   FOLLY_ALWAYS_INLINE void call(
       out_type<Date>& result,
       const arg_type<Date>& date) {
     auto dt = getDateTime(date);
-    result = util::lastDayOfMonthSinceEpochFromDate(dt);
+    Expected<int64_t> lastDayOfMonthSinceEpoch =
+        util::lastDayOfMonthSinceEpochFromDate(dt);
+    if (lastDayOfMonthSinceEpoch.hasError()) {
+      VELOX_DCHECK(lastDayOfMonthSinceEpoch.error().isUserError());
+      VELOX_USER_FAIL(lastDayOfMonthSinceEpoch.error().message());
+    }
+    result = lastDayOfMonthSinceEpoch.value();
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -354,7 +428,13 @@ struct LastDayOfMonthFunction : public InitSessionTimezone<T>,
       const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     auto dt = getDateTime(timestamp, nullptr);
-    result = util::lastDayOfMonthSinceEpochFromDate(dt);
+    Expected<int64_t> lastDayOfMonthSinceEpoch =
+        util::lastDayOfMonthSinceEpochFromDate(dt);
+    if (lastDayOfMonthSinceEpoch.hasError()) {
+      VELOX_DCHECK(lastDayOfMonthSinceEpoch.error().isUserError());
+      VELOX_USER_FAIL(lastDayOfMonthSinceEpoch.error().message());
+    }
+    result = lastDayOfMonthSinceEpoch.value();
   }
 };
 
@@ -371,7 +451,7 @@ int64_t intervalDays(int64_t milliseconds) {
 } // namespace
 
 template <typename T>
-struct DateMinusIntervalDayTime {
+struct DateMinusInterval {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void call(
@@ -383,10 +463,17 @@ struct DateMinusIntervalDayTime {
         "Cannot subtract hours, minutes, seconds or milliseconds from a date");
     result = addToDate(date, DateTimeUnit::kDay, -intervalDays(interval));
   }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Date>& result,
+      const arg_type<Date>& date,
+      const arg_type<IntervalYearMonth>& interval) {
+    result = addToDate(date, DateTimeUnit::kMonth, -interval);
+  }
 };
 
 template <typename T>
-struct DatePlusIntervalDayTime {
+struct DatePlusInterval {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void call(
@@ -398,10 +485,17 @@ struct DatePlusIntervalDayTime {
         "Cannot add hours, minutes, seconds or milliseconds to a date");
     result = addToDate(date, DateTimeUnit::kDay, intervalDays(interval));
   }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Date>& result,
+      const arg_type<Date>& date,
+      const arg_type<IntervalYearMonth>& interval) {
+    result = addToDate(date, DateTimeUnit::kMonth, interval);
+  }
 };
 
 template <typename T>
-struct TimestampMinusIntervalDayTime {
+struct TimestampMinusFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void call(
@@ -410,6 +504,181 @@ struct TimestampMinusIntervalDayTime {
       const arg_type<Timestamp>& b) {
     result = a.toMillis() - b.toMillis();
   }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<IntervalDayTime>& result,
+      const arg_type<TimestampWithTimezone>& a,
+      const arg_type<TimestampWithTimezone>& b) {
+    result = unpackMillisUtc(a) - unpackMillisUtc(b);
+  }
+};
+
+template <typename T>
+struct TimestampPlusInterval {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<Timestamp>& a,
+      const arg_type<IntervalDayTime>& b)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+  {
+    result = Timestamp::fromMillisNoError(a.toMillis() + b);
+  }
+
+  // We only need to capture the time zone session config if we are operating on
+  // a timestamp and a IntervalYearMonth.
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Timestamp>*,
+      const arg_type<IntervalYearMonth>*) {
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<Timestamp>& timestamp,
+      const arg_type<IntervalYearMonth>& interval) {
+    result = addToTimestamp(
+        timestamp, DateTimeUnit::kMonth, interval, sessionTimeZone_);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone,
+      const arg_type<IntervalDayTime>& interval) {
+    result = addToTimestampWithTimezone(
+        timestampWithTimezone, DateTimeUnit::kMillisecond, interval);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone,
+      const arg_type<IntervalYearMonth>& interval) {
+    result = addToTimestampWithTimezone(
+        timestampWithTimezone, DateTimeUnit::kMonth, interval);
+  }
+
+ private:
+  // Only set if the parameters are timestamp and IntervalYearMonth.
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
+};
+
+template <typename T>
+struct IntervalPlusTimestamp {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<IntervalDayTime>& a,
+      const arg_type<Timestamp>& b)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+  {
+    result = Timestamp::fromMillisNoError(a + b.toMillis());
+  }
+
+  // We only need to capture the time zone session config if we are operating on
+  // a timestamp and a IntervalYearMonth.
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<IntervalYearMonth>*,
+      const arg_type<Timestamp>*) {
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<IntervalYearMonth>& interval,
+      const arg_type<Timestamp>& timestamp) {
+    result = addToTimestamp(
+        timestamp, DateTimeUnit::kMonth, interval, sessionTimeZone_);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<IntervalDayTime>& interval,
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
+    result = addToTimestampWithTimezone(
+        timestampWithTimezone, DateTimeUnit::kMillisecond, interval);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<IntervalYearMonth>& interval,
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
+    result = addToTimestampWithTimezone(
+        timestampWithTimezone, DateTimeUnit::kMonth, interval);
+  }
+
+ private:
+  // Only set if the parameters are timestamp and IntervalYearMonth.
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
+};
+
+template <typename T>
+struct TimestampMinusInterval {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<Timestamp>& a,
+      const arg_type<IntervalDayTime>& b)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+  {
+    result = Timestamp::fromMillisNoError(a.toMillis() - b);
+  }
+
+  // We only need to capture the time zone session config if we are operating on
+  // a timestamp and a IntervalYearMonth.
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Timestamp>*,
+      const arg_type<IntervalYearMonth>*) {
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<Timestamp>& timestamp,
+      const arg_type<IntervalYearMonth>& interval) {
+    result = addToTimestamp(
+        timestamp, DateTimeUnit::kMonth, -interval, sessionTimeZone_);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone,
+      const arg_type<IntervalDayTime>& interval) {
+    result = addToTimestampWithTimezone(
+        timestampWithTimezone, DateTimeUnit::kMillisecond, -interval);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone,
+      const arg_type<IntervalYearMonth>& interval) {
+    result = addToTimestampWithTimezone(
+        timestampWithTimezone, DateTimeUnit::kMonth, -interval);
+  }
+
+ private:
+  // Only set if the parameters are timestamp and IntervalYearMonth.
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
 };
 
 template <typename T>
@@ -533,6 +802,17 @@ struct HourFunction : public InitSessionTimezone<T>,
   }
 };
 
+template <typename T>
+struct HourFromIntervalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<IntervalDayTime>& millis) {
+    result = (millis % kMillisInDay) / kMillisInHour;
+  }
+};
+
 template <typename T>
 struct MinuteFunction : public InitSessionTimezone<T>,
                         public TimestampWithTimezoneSupport<T> {
@@ -556,6 +836,17 @@ struct MinuteFunction : public InitSessionTimezone<T>,
   }
 };
 
+template <typename T>
+struct MinuteFromIntervalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<IntervalDayTime>& millis) {
+    result = (millis % kMillisInHour) / kMillisInMinute;
+  }
+};
+
 template <typename T>
 struct SecondFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -578,6 +869,17 @@ struct SecondFunction : public TimestampWithTimezoneSupport<T> {
   }
 };
 
+template <typename T>
+struct SecondFromIntervalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<IntervalDayTime>& millis) {
+    result = (millis % kMillisInMinute) / kMillisInSecond;
+  }
+};
+
 template <typename T>
 struct MillisecondFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -603,6 +905,17 @@ struct MillisecondFunction : public TimestampWithTimezoneSupport<T> {
   }
 };
 
+template <typename T>
+struct MillisecondFromIntervalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<IntervalDayTime>& millis) {
+    result = millis % kMillisecondsInSecond;
+  }
+};
+
 namespace {
 inline std::optional<DateTimeUnit> fromDateTimeUnitString(
     const StringView& unitString,
@@ -646,7 +959,6 @@ inline std::optional<DateTimeUnit> fromDateTimeUnitString(
   if (unit == kYear) {
     return DateTimeUnit::kYear;
   }
-  // TODO Add support for "week".
   if (throwIfInvalid) {
     VELOX_UNSUPPORTED("Unsupported datetime unit: {}", unitString);
   }
@@ -696,10 +1008,11 @@ template <typename T>
 struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  const date::time_zone* timeZone_ = nullptr;
+  const tz::TimeZone* timeZone_ = nullptr;
   std::optional<DateTimeUnit> unit_;
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* unitString,
       const arg_type<Timestamp>* /*timestamp*/) {
@@ -711,6 +1024,7 @@ struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<Varchar>* unitString,
       const arg_type<Date>* /*date*/) {
@@ -720,6 +1034,7 @@ struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<Varchar>* unitString,
       const arg_type<TimestampWithTimezone>* /*timestamp*/) {
@@ -807,15 +1122,45 @@ struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
       unit = getTimestampUnit(unitString).value();
     }
 
-    if (unit == DateTimeUnit::kSecond) {
-      result = Timestamp(timestamp.getSeconds(), 0);
-      return;
-    }
+    switch (unit) {
+      // For seconds, we just truncate the nanoseconds part of the timestamp; no
+      // timezone conversion required.
+      case DateTimeUnit::kSecond:
+        result = Timestamp(timestamp.getSeconds(), 0);
+        return;
+
+      // Same for minutes; timezones and daylight savings time are at least in
+      // the granularity of 30 mins, so we can just truncate the epoch directly.
+      case DateTimeUnit::kMinute:
+        result = adjustEpoch(timestamp.getSeconds(), 60);
+        return;
+
+      // Hour truncation has to handle the corner case of daylight savings time
+      // boundaries. Since conversions from local timezone to UTC may be
+      // ambiguous, we need to be carefull about the roundtrip of converting to
+      // local time and back. So what we do is to calculate the truncation delta
+      // in UTC, then applying it to the input timestamp.
+      case DateTimeUnit::kHour: {
+        auto epochToAdjust = getSeconds(timestamp, timeZone_);
+        auto secondsDelta =
+            epochToAdjust - adjustEpoch(epochToAdjust, 60 * 60).getSeconds();
+        result = Timestamp(timestamp.getSeconds() - secondsDelta, 0);
+        return;
+      }
 
-    auto dateTime = getDateTime(timestamp, timeZone_);
-    adjustDateTime(dateTime, unit);
+      // For the truncations below, we may first need to convert to the local
+      // timestamp, truncate, then convert back to GMT.
+      case DateTimeUnit::kDay:
+        result = adjustEpoch(getSeconds(timestamp, timeZone_), 24 * 60 * 60);
+        break;
+
+      default:
+        auto dateTime = getDateTime(timestamp, timeZone_);
+        adjustDateTime(dateTime, unit);
+        result = Timestamp(Timestamp::calendarUtcToEpoch(dateTime), 0);
+        break;
+    }
 
-    result = Timestamp(timegm(&dateTime), 0);
     if (timeZone_ != nullptr) {
       result.toGMT(*timeZone_);
     }
@@ -837,7 +1182,7 @@ struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
     auto dateTime = getDateTime(date);
     adjustDateTime(dateTime, unit);
 
-    result = timegm(&dateTime) / kSecondsInDay;
+    result = Timestamp::calendarUtcToEpoch(dateTime) / kSecondsInDay;
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -852,23 +1197,35 @@ struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
     }
 
     if (unit == DateTimeUnit::kSecond) {
-      auto utcTimestamp =
-          Timestamp::fromMillis(*timestampWithTimezone.template at<0>());
-      result.template get_writer_at<0>() = utcTimestamp.getSeconds() * 1000;
-      result.template get_writer_at<1>() =
-          *timestampWithTimezone.template at<1>();
+      auto utcTimestamp = unpackTimestampUtc(timestampWithTimezone);
+      result = pack(
+          utcTimestamp.getSeconds() * 1000,
+          unpackZoneKeyId(timestampWithTimezone));
       return;
     }
 
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     auto dateTime = getDateTime(timestamp, nullptr);
     adjustDateTime(dateTime, unit);
-    timestamp = Timestamp::fromMillis(timegm(&dateTime) * 1000);
-    timestamp.toGMT(*timestampWithTimezone.template at<1>());
-
-    result.template get_writer_at<0>() = timestamp.toMillis();
-    result.template get_writer_at<1>() =
-        *timestampWithTimezone.template at<1>();
+    timestamp =
+        Timestamp::fromMillis(Timestamp::calendarUtcToEpoch(dateTime) * 1000);
+    timestamp.toGMT(*tz::locateZone(unpackZoneKeyId(timestampWithTimezone)));
+
+    result = pack(timestamp, unpackZoneKeyId(timestampWithTimezone));
+  }
+
+ private:
+  /// For fixed interval like second, minute, hour, day and week
+  /// we can truncate date by a simple arithmetic expression:
+  /// floor(seconds / intervalSeconds) * intervalSeconds.
+  FOLLY_ALWAYS_INLINE Timestamp
+  adjustEpoch(int64_t seconds, int64_t intervalSeconds) {
+    int64_t s = seconds / intervalSeconds;
+    if (seconds < 0 && seconds % intervalSeconds) {
+      s = s - 1;
+    }
+    int64_t truncedSeconds = s * intervalSeconds;
+    return Timestamp(truncedSeconds, 0);
   }
 };
 
@@ -876,10 +1233,11 @@ template <typename T>
 struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  const date::time_zone* sessionTimeZone_ = nullptr;
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
   std::optional<DateTimeUnit> unit_ = std::nullopt;
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* unitString,
       const int64_t* /*value*/,
@@ -891,6 +1249,7 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<Varchar>* unitString,
       const int64_t* /*value*/,
@@ -900,7 +1259,7 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       out_type<Timestamp>& result,
       const arg_type<Varchar>& unitString,
       const int64_t value,
@@ -934,33 +1293,25 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
     } else {
       result = addToTimestamp(timestamp, unit, (int32_t)value);
     }
-
-    return true;
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       out_type<TimestampWithTimezone>& result,
       const arg_type<Varchar>& unitString,
       const int64_t value,
       const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
-    const auto unit = unit_.has_value()
-        ? unit_.value()
-        : fromDateTimeUnitString(unitString, true /*throwIfInvalid*/).value();
+    const auto unit = unit_.value_or(
+        fromDateTimeUnitString(unitString, true /*throwIfInvalid*/).value());
 
     if (value != (int32_t)value) {
       VELOX_UNSUPPORTED("integer overflow");
     }
 
-    auto finalTimeStamp = addToTimestamp(
-        this->toTimestamp(timestampWithTimezone), unit, (int32_t)value);
-    finalTimeStamp.toGMT(*timestampWithTimezone.template at<1>());
-    result = std::make_tuple(
-        finalTimeStamp.toMillis(), *timestampWithTimezone.template at<1>());
-
-    return true;
+    result =
+        addToTimestampWithTimezone(timestampWithTimezone, unit, (int32_t)value);
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       out_type<Date>& result,
       const arg_type<Varchar>& unitString,
       const int64_t value,
@@ -974,7 +1325,6 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
     }
 
     result = addToDate(date, unit, (int32_t)value);
-    return true;
   }
 };
 
@@ -982,10 +1332,11 @@ template <typename T>
 struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  const date::time_zone* sessionTimeZone_ = nullptr;
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
   std::optional<DateTimeUnit> unit_ = std::nullopt;
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* unitString,
       const arg_type<Timestamp>* /*timestamp1*/,
@@ -998,6 +1349,7 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<Varchar>* unitString,
       const arg_type<Date>* /*date1*/,
@@ -1008,6 +1360,7 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* unitString,
       const arg_type<TimestampWithTimezone>* /*timestampWithTimezone1*/,
@@ -1017,14 +1370,13 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       int64_t& result,
       const arg_type<Varchar>& unitString,
       const arg_type<Timestamp>& timestamp1,
       const arg_type<Timestamp>& timestamp2) {
-    const auto unit = unit_.has_value()
-        ? unit_.value()
-        : fromDateTimeUnitString(unitString, true /*throwIfInvalid*/).value();
+    const auto unit = unit_.value_or(
+        fromDateTimeUnitString(unitString, true /*throwIfInvalid*/).value());
 
     if (LIKELY(sessionTimeZone_ != nullptr)) {
       // sessionTimeZone not null means that the config
@@ -1046,10 +1398,9 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
     } else {
       result = diffTimestamp(unit, timestamp1, timestamp2);
     }
-    return true;
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       int64_t& result,
       const arg_type<Varchar>& unitString,
       const arg_type<Date>& date1,
@@ -1059,19 +1410,24 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
         : getDateUnit(unitString, true).value();
 
     result = diffDate(unit, date1, date2);
-    return true;
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       int64_t& result,
       const arg_type<Varchar>& unitString,
-      const arg_type<TimestampWithTimezone>& timestamp1,
-      const arg_type<TimestampWithTimezone>& timestamp2) {
-    return call(
-        result,
-        unitString,
-        this->toTimestamp(timestamp1),
-        this->toTimestamp(timestamp2));
+      const arg_type<TimestampWithTimezone>& timestampWithTz1,
+      const arg_type<TimestampWithTimezone>& timestampWithTz2) {
+    const auto unit = unit_.value_or(
+        fromDateTimeUnitString(unitString, true /*throwIfInvalid*/).value());
+
+    // Presto's behavior is to use the time zone of the first parameter to
+    // perform the calculation. Note that always normalizing to UTC is not
+    // correct as calculations may cross daylight savings boundaries.
+    auto timestamp1 = this->toTimestamp(timestampWithTz1, false);
+    auto timestamp2 = this->toTimestamp(timestampWithTz2, true);
+    timestamp2.toTimezone(*tz::locateZone(unpackZoneKeyId(timestampWithTz1)));
+
+    result = diffTimestamp(unit, timestamp1, timestamp2);
   }
 };
 
@@ -1079,58 +1435,117 @@ template <typename T>
 struct DateFormatFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  const date::time_zone* sessionTimeZone_ = nullptr;
-  std::shared_ptr<DateTimeFormatter> mysqlDateTime_;
-  bool isConstFormat_ = false;
-
-  FOLLY_ALWAYS_INLINE void setFormatter(const arg_type<Varchar>* formatString) {
-    if (formatString != nullptr) {
-      mysqlDateTime_ = buildMysqlDateTimeFormatter(
-          std::string_view(formatString->data(), formatString->size()));
-      isConstFormat_ = true;
-    }
-  }
-
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Timestamp>* /*timestamp*/,
       const arg_type<Varchar>* formatString) {
     sessionTimeZone_ = getTimeZoneFromConfig(config);
-    setFormatter(formatString);
+    if (formatString != nullptr) {
+      setFormatter(*formatString);
+      isConstFormat_ = true;
+    }
   }
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<TimestampWithTimezone>* /*timestamp*/,
       const arg_type<Varchar>* formatString) {
-    setFormatter(formatString);
+    if (formatString != nullptr) {
+      setFormatter(*formatString);
+      isConstFormat_ = true;
+    }
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
       const arg_type<Timestamp>& timestamp,
       const arg_type<Varchar>& formatString) {
     if (!isConstFormat_) {
-      mysqlDateTime_ = buildMysqlDateTimeFormatter(
-          std::string_view(formatString.data(), formatString.size()));
+      setFormatter(formatString);
     }
 
-    auto formattedResult = mysqlDateTime_->format(timestamp, sessionTimeZone_);
-    auto resultSize = formattedResult.size();
+    result.reserve(maxResultSize_);
+    const auto resultSize = mysqlDateTime_->format(
+        timestamp, sessionTimeZone_, maxResultSize_, result.data());
     result.resize(resultSize);
-    if (resultSize != 0) {
-      std::memcpy(result.data(), formattedResult.data(), resultSize);
-    }
-    return true;
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
       const arg_type<TimestampWithTimezone>& timestampWithTimezone,
       const arg_type<Varchar>& formatString) {
     auto timestamp = this->toTimestamp(timestampWithTimezone);
-    return call(result, timestamp, formatString);
+    call(result, timestamp, formatString);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE void setFormatter(const arg_type<Varchar> formatString) {
+    mysqlDateTime_ = buildMysqlDateTimeFormatter(
+        std::string_view(formatString.data(), formatString.size()));
+    maxResultSize_ = mysqlDateTime_->maxResultSize(sessionTimeZone_);
+  }
+
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
+  std::shared_ptr<DateTimeFormatter> mysqlDateTime_;
+  uint32_t maxResultSize_;
+  bool isConstFormat_ = false;
+};
+
+template <typename T>
+struct FromIso8601Date {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Date>& result, const arg_type<Varchar>& input) {
+    const auto castResult = util::fromDateString(
+        input.data(), input.size(), util::ParseMode::kIso8601);
+    if (castResult.hasError()) {
+      return castResult.error();
+    }
+
+    result = castResult.value();
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct FromIso8601Timestamp {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Varchar>* /*input*/) {
+    auto sessionTzName = config.sessionTimezone();
+    if (!sessionTzName.empty()) {
+      sessionTimeZone_ = tz::locateZone(sessionTzName);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<Varchar>& input) {
+    const auto castResult = util::fromTimestampWithTimezoneString(
+        input.data(), input.size(), util::TimestampParseMode::kIso8601);
+    if (castResult.hasError()) {
+      return castResult.error();
+    }
+
+    auto [ts, timeZone] = castResult.value();
+    // Input string may not contain a timezone - if so, it is interpreted in
+    // session timezone.
+    if (timeZone == nullptr) {
+      timeZone = sessionTimeZone_;
+    }
+    ts.toGMT(*timeZone);
+    result = pack(ts, timeZone->id());
+    return Status::OK();
   }
+
+ private:
+  const tz::TimeZone* sessionTimeZone_{tz::locateZone(0)}; // default to GMT.
 };
 
 template <typename T>
@@ -1138,10 +1553,13 @@ struct DateParseFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   std::shared_ptr<DateTimeFormatter> format_;
-  std::optional<int64_t> sessionTzID_;
+
+  // By default, assume 0 (GMT).
+  const tz::TimeZone* sessionTimeZone_{tz::locateZone(0)};
   bool isConstFormat_ = false;
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* /*input*/,
       const arg_type<Varchar>* formatString) {
@@ -1153,11 +1571,11 @@ struct DateParseFunction {
 
     auto sessionTzName = config.sessionTimezone();
     if (!sessionTzName.empty()) {
-      sessionTzID_ = util::getTimeZoneID(sessionTzName);
+      sessionTimeZone_ = tz::locateZone(sessionTzName);
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE Status call(
       out_type<Timestamp>& result,
       const arg_type<Varchar>& input,
       const arg_type<Varchar>& format) {
@@ -1166,15 +1584,14 @@ struct DateParseFunction {
           std::string_view(format.data(), format.size()));
     }
 
-    auto dateTimeResult =
-        format_->parse(std::string_view(input.data(), input.size()));
+    auto dateTimeResult = format_->parse((std::string_view)(input));
+    if (dateTimeResult.hasError()) {
+      return dateTimeResult.error();
+    }
 
-    // Since MySql format has no timezone specifier, simply check if session
-    // timezone was provided. If not, fallback to 0 (GMT).
-    int16_t timezoneId = sessionTzID_.value_or(0);
-    dateTimeResult.timestamp.toGMT(timezoneId);
-    result = dateTimeResult.timestamp;
-    return true;
+    dateTimeResult->timestamp.toGMT(*sessionTimeZone_);
+    result = dateTimeResult->timestamp;
+    return Status::OK();
   }
 };
 
@@ -1182,39 +1599,70 @@ template <typename T>
 struct FormatDateTimeFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  const date::time_zone* sessionTimeZone_ = nullptr;
-  std::shared_ptr<DateTimeFormatter> jodaDateTime_;
-  bool isConstFormat_ = false;
-
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Timestamp>* /*timestamp*/,
       const arg_type<Varchar>* formatString) {
     sessionTimeZone_ = getTimeZoneFromConfig(config);
     if (formatString != nullptr) {
-      jodaDateTime_ = buildJodaDateTimeFormatter(
-          std::string_view(formatString->data(), formatString->size()));
+      setFormatter(*formatString);
       isConstFormat_ = true;
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
       const arg_type<Timestamp>& timestamp,
       const arg_type<Varchar>& formatString) {
+    ensureFormatter(formatString);
+
+    format(timestamp, sessionTimeZone_, maxResultSize_, result);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone,
+      const arg_type<Varchar>& formatString) {
+    ensureFormatter(formatString);
+
+    const auto timestamp = unpackTimestampUtc(timestampWithTimezone);
+    const auto timeZoneId = unpackZoneKeyId(timestampWithTimezone);
+    auto* timezonePtr = tz::locateZone(tz::getTimeZoneName(timeZoneId));
+
+    const auto maxResultSize = jodaDateTime_->maxResultSize(timezonePtr);
+    format(timestamp, timezonePtr, maxResultSize, result);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE void ensureFormatter(
+      const arg_type<Varchar>& formatString) {
     if (!isConstFormat_) {
-      jodaDateTime_ = buildJodaDateTimeFormatter(
-          std::string_view(formatString.data(), formatString.size()));
+      setFormatter(formatString);
     }
+  }
+
+  FOLLY_ALWAYS_INLINE void setFormatter(const arg_type<Varchar>& formatString) {
+    jodaDateTime_ = buildJodaDateTimeFormatter(
+        std::string_view(formatString.data(), formatString.size()));
+    maxResultSize_ = jodaDateTime_->maxResultSize(sessionTimeZone_);
+  }
 
-    auto formattedResult = jodaDateTime_->format(timestamp, sessionTimeZone_);
-    auto resultSize = formattedResult.size();
+  void format(
+      const Timestamp& timestamp,
+      const tz::TimeZone* timeZone,
+      uint32_t maxResultSize,
+      out_type<Varchar>& result) const {
+    result.reserve(maxResultSize);
+    const auto resultSize = jodaDateTime_->format(
+        timestamp, timeZone, maxResultSize, result.data());
     result.resize(resultSize);
-    if (resultSize != 0) {
-      std::memcpy(result.data(), formattedResult.data(), resultSize);
-    }
-    return true;
   }
+
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
+  std::shared_ptr<DateTimeFormatter> jodaDateTime_;
+  uint32_t maxResultSize_;
+  bool isConstFormat_ = false;
 };
 
 template <typename T>
@@ -1222,10 +1670,11 @@ struct ParseDateTimeFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   std::shared_ptr<DateTimeFormatter> format_;
-  std::optional<int64_t> sessionTzID_;
+  const tz::TimeZone* sessionTimeZone_{tz::locateZone(0)}; // GMT
   bool isConstFormat_ = false;
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* /*input*/,
       const arg_type<Varchar>* format) {
@@ -1237,11 +1686,11 @@ struct ParseDateTimeFunction {
 
     auto sessionTzName = config.sessionTimezone();
     if (!sessionTzName.empty()) {
-      sessionTzID_ = util::getTimeZoneID(sessionTzName);
+      sessionTimeZone_ = tz::locateZone(sessionTzName);
     }
   }
 
-  FOLLY_ALWAYS_INLINE bool call(
+  FOLLY_ALWAYS_INLINE Status call(
       out_type<TimestampWithTimezone>& result,
       const arg_type<Varchar>& input,
       const arg_type<Varchar>& format) {
@@ -1251,15 +1700,18 @@ struct ParseDateTimeFunction {
     }
     auto dateTimeResult =
         format_->parse(std::string_view(input.data(), input.size()));
+    if (dateTimeResult.hasError()) {
+      return dateTimeResult.error();
+    }
 
     // If timezone was not parsed, fallback to the session timezone. If there's
     // no session timezone, fallback to 0 (GMT).
-    int16_t timezoneId = dateTimeResult.timezoneId != -1
-        ? dateTimeResult.timezoneId
-        : sessionTzID_.value_or(0);
-    dateTimeResult.timestamp.toGMT(timezoneId);
-    result = std::make_tuple(dateTimeResult.timestamp.toMillis(), timezoneId);
-    return true;
+    const auto* timeZone = dateTimeResult->timezoneId != -1
+        ? tz::locateZone(dateTimeResult->timezoneId)
+        : sessionTimeZone_;
+    dateTimeResult->timestamp.toGMT(*timeZone);
+    result = pack(dateTimeResult->timestamp, timeZone->id());
+    return Status::OK();
   }
 };
 
@@ -1267,9 +1719,11 @@ template <typename T>
 struct CurrentDateFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  const date::time_zone* timeZone_ = nullptr;
+  const tz::TimeZone* timeZone_ = nullptr;
 
-  FOLLY_ALWAYS_INLINE void initialize(const core::QueryConfig& config) {
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config) {
     timeZone_ = getTimeZoneFromConfig(config);
   }
 
@@ -1312,4 +1766,101 @@ struct TimeZoneMinuteFunction : public TimestampWithTimezoneSupport<T> {
   }
 };
 
+template <typename T>
+struct ToISO8601Function {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      const arg_type<Timestamp>* /*input*/) {
+    if (inputTypes[0]->isTimestamp()) {
+      timeZone_ = getTimeZoneFromConfig(config);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Date>& date) {
+    result = DateType::toIso8601(date);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Timestamp>& timestamp) {
+    toIso8601(timestamp, timeZone_, result);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
+    const auto timestamp = unpackTimestampUtc(timestampWithTimezone);
+    const auto timeZoneId = unpackZoneKeyId(timestampWithTimezone);
+    const auto* timeZone = tz::locateZone(tz::getTimeZoneName(timeZoneId));
+
+    toIso8601(timestamp, timeZone, result);
+  }
+
+ private:
+  void toIso8601(
+      const Timestamp& timestamp,
+      const tz::TimeZone* timeZone,
+      out_type<Varchar>& result) const {
+    const auto maxResultSize = formatter_->maxResultSize(timeZone);
+    result.reserve(maxResultSize);
+    const auto resultSize =
+        formatter_->format(timestamp, timeZone, maxResultSize, result.data());
+    result.resize(resultSize);
+  }
+
+  const tz::TimeZone* timeZone_{nullptr};
+  std::shared_ptr<DateTimeFormatter> formatter_ =
+      functions::buildJodaDateTimeFormatter("yyyy-MM-dd'T'HH:mm:ss.SSSZZ");
+};
+
+template <typename T>
+struct AtTimezoneFunction : public TimestampWithTimezoneSupport<T> {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::optional<int64_t> targetTimezoneID_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<TimestampWithTimezone>* /*tsWithTz*/,
+      const arg_type<Varchar>* timezone) {
+    if (timezone != nullptr) {
+      targetTimezoneID_ = tz::getTimeZoneID(
+          std::string_view(timezone->data(), timezone->size()));
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<TimestampWithTimezone>& tsWithTz,
+      const arg_type<Varchar>& timezone) {
+    const auto inputMs = unpackMillisUtc(tsWithTz);
+    const auto targetTimezoneID = targetTimezoneID_.has_value()
+        ? targetTimezoneID_.value()
+        : tz::getTimeZoneID(std::string_view(timezone.data(), timezone.size()));
+
+    // Input and output TimestampWithTimezones should not contain
+    // different timestamp values - solely timezone ID should differ between the
+    // two, as timestamp is stored as a UTC offset. The timestamp is then
+    // resolved to the respective timezone at the time of display.
+    result = pack(inputMs, targetTimezoneID);
+  }
+};
+
+template <typename TExec>
+struct ToMillisecondFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int64_t>& result,
+      const arg_type<IntervalDayTime>& millis) {
+    result = millis;
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/DateTimeImpl.h b/velox/functions/prestosql/DateTimeImpl.h
index cadc27da05ae0..1f0b61933a247 100644
--- a/velox/functions/prestosql/DateTimeImpl.h
+++ b/velox/functions/prestosql/DateTimeImpl.h
@@ -17,7 +17,10 @@
 
 #include <chrono>
 #include <optional>
+
+#include "velox/common/base/Doubles.h"
 #include "velox/external/date/date.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/type/Timestamp.h"
 #include "velox/type/TimestampConversion.h"
 
@@ -34,33 +37,32 @@ FOLLY_ALWAYS_INLINE double toUnixtime(const Timestamp& timestamp) {
   return result;
 }
 
-FOLLY_ALWAYS_INLINE std::optional<Timestamp> fromUnixtime(double unixtime) {
-  if (UNLIKELY(std::isnan(unixtime))) {
+FOLLY_ALWAYS_INLINE Timestamp fromUnixtime(double unixtime) {
+  if (FOLLY_UNLIKELY(std::isnan(unixtime))) {
     return Timestamp(0, 0);
   }
 
-  static const int64_t kMax = std::numeric_limits<int64_t>::max();
   static const int64_t kMin = std::numeric_limits<int64_t>::min();
 
-  // On some compilers if we cast kMax to a double, we can get a number larger
-  // than 'kMax'. This will allow 'unixtime' values > 'kMax'. The workaround
-  // here is to use uint64_t to represent ('kMax' + 1), which can be represented
-  // exactly as double. We then check if the difference with 'unixtime' <= 1.
-  if (UNLIKELY((static_cast<uint64_t>(kMax) + 1) - unixtime <= 1)) {
+  if (FOLLY_UNLIKELY(unixtime >= kMinDoubleAboveInt64Max)) {
     return Timestamp::maxMillis();
   }
 
-  if (UNLIKELY(unixtime <= kMin)) {
+  if (FOLLY_UNLIKELY(unixtime <= kMin)) {
     return Timestamp::minMillis();
   }
 
-  if (UNLIKELY(std::isinf(unixtime))) {
+  if (FOLLY_UNLIKELY(std::isinf(unixtime))) {
     return unixtime < 0 ? Timestamp::minMillis() : Timestamp::maxMillis();
   }
 
   auto seconds = std::floor(unixtime);
-  auto nanos = unixtime - seconds;
-  return Timestamp(seconds, nanos * kNanosecondsInSecond);
+  auto milliseconds = std::llround((unixtime - seconds) * kMillisInSecond);
+  if (FOLLY_UNLIKELY(milliseconds == kMillisInSecond)) {
+    ++seconds;
+    milliseconds = 0;
+  }
+  return Timestamp(seconds, milliseconds * kNanosecondsInMillisecond);
 }
 
 namespace {
@@ -105,6 +107,8 @@ addToDate(const int32_t input, const DateTimeUnit unit, const int32_t value) {
 
   if (unit == DateTimeUnit::kDay) {
     outDate = inDate + date::days(value);
+  } else if (unit == DateTimeUnit::kWeek) {
+    outDate = inDate + date::days(value * 7);
   } else {
     const date::year_month_day inCalDate(inDate);
     date::year_month_day outCalDate;
@@ -174,8 +178,17 @@ FOLLY_ALWAYS_INLINE Timestamp addToTimestamp(
       outTimestamp = inTimestamp + std::chrono::milliseconds(value);
       break;
     }
+    case DateTimeUnit::kWeek: {
+      const int32_t inDate =
+          std::chrono::duration_cast<date::days>(inTimestamp.time_since_epoch())
+              .count();
+      const int32_t outDate = addToDate(inDate, DateTimeUnit::kDay, 7 * value);
+
+      outTimestamp = inTimestamp + date::days(outDate - inDate);
+      break;
+    }
     default:
-      VELOX_UNREACHABLE();
+      VELOX_UNREACHABLE("Unsupported datetime unit");
   }
 
   Timestamp milliTimestamp =
@@ -186,6 +199,33 @@ FOLLY_ALWAYS_INLINE Timestamp addToTimestamp(
           timestamp.getNanos() % kNanosecondsInMillisecond);
 }
 
+// If time zone is provided, use it for the arithmetic operation (convert to it,
+// apply operation, then convert back to UTC).
+FOLLY_ALWAYS_INLINE Timestamp addToTimestamp(
+    const Timestamp& timestamp,
+    const DateTimeUnit unit,
+    const int32_t value,
+    const tz::TimeZone* timeZone) {
+  if (timeZone == nullptr) {
+    return addToTimestamp(timestamp, unit, value);
+  } else {
+    Timestamp zonedTimestamp = timestamp;
+    zonedTimestamp.toTimezone(*timeZone);
+    auto resultTimestamp = addToTimestamp(zonedTimestamp, unit, value);
+    resultTimestamp.toGMT(*timeZone);
+    return resultTimestamp;
+  }
+}
+
+FOLLY_ALWAYS_INLINE int64_t addToTimestampWithTimezone(
+    int64_t timestampWithTimezone,
+    const DateTimeUnit unit,
+    const int32_t value) {
+  auto timestamp = unpackTimestampUtc(timestampWithTimezone);
+  auto finalTimeStamp = addToTimestamp(timestamp, unit, (int32_t)value);
+  return pack(finalTimeStamp, unpackZoneKeyId(timestampWithTimezone));
+}
+
 FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
     const DateTimeUnit unit,
     const Timestamp& fromTimestamp,
@@ -195,7 +235,7 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
     return 0;
   }
 
-  int8_t sign = fromTimestamp < toTimestamp ? 1 : -1;
+  const int8_t sign = fromTimestamp < toTimestamp ? 1 : -1;
 
   // fromTimepoint is less than or equal to toTimepoint
   const std::chrono::
@@ -238,6 +278,12 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
           std::chrono::duration_cast<date::days>(toTimepoint - fromTimepoint)
               .count();
     }
+    case DateTimeUnit::kWeek: {
+      return sign *
+          std::chrono::duration_cast<date::days>(toTimepoint - fromTimepoint)
+              .count() /
+          7;
+    }
     default:
       break;
   }
@@ -254,10 +300,25 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
       std::chrono::duration_cast<std::chrono::milliseconds>(
           fromTimepoint - fromDaysTimepoint)
           .count();
-  const uint64_t toTimeInstantOfDay =
-      std::chrono::duration_cast<std::chrono::milliseconds>(
-          toTimepoint - toDaysTimepoint)
-          .count();
+
+  uint64_t toTimeInstantOfDay = 0;
+  uint64_t toTimePointMillis = toTimepoint.time_since_epoch().count();
+  uint64_t toDaysTimepointMillis =
+      std::chrono::
+          time_point<std::chrono::system_clock, std::chrono::milliseconds>(
+              toDaysTimepoint)
+              .time_since_epoch()
+              .count();
+  bool overflow = __builtin_sub_overflow(
+      toTimePointMillis, toDaysTimepointMillis, &toTimeInstantOfDay);
+  VELOX_USER_CHECK_EQ(
+      overflow,
+      false,
+      "{} - {} Causes arithmetic overflow: {} - {}",
+      fromTimestamp.toString(),
+      toTimestamp.toString(),
+      toTimePointMillis,
+      toDaysTimepointMillis);
   const uint8_t fromDay = static_cast<unsigned>(fromCalDate.day()),
                 fromMonth = static_cast<unsigned>(fromCalDate.month());
   const uint8_t toDay = static_cast<unsigned>(toCalDate.day()),
@@ -267,9 +328,8 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
   const uint8_t toLastYearMonthDay =
       static_cast<unsigned>(toCalLastYearMonthDay.day());
 
-  int64_t diff;
   if (unit == DateTimeUnit::kMonth || unit == DateTimeUnit::kQuarter) {
-    diff = (int(toCalDate.year()) - int(fromCalDate.year())) * 12 +
+    int64_t diff = (int(toCalDate.year()) - int(fromCalDate.year())) * 12 +
         int(toMonth) - int(fromMonth);
 
     if ((toDay != toLastYearMonthDay && fromDay > toDay) ||
@@ -282,7 +342,7 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
   }
 
   if (unit == DateTimeUnit::kYear) {
-    diff = (toCalDate.year() - fromCalDate.year()).count();
+    int64_t diff = (toCalDate.year() - fromCalDate.year()).count();
 
     if (fromMonth > toMonth ||
         (fromMonth == toMonth && fromDay > toDay &&
@@ -294,7 +354,7 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
     return sign * diff;
   }
 
-  VELOX_UNREACHABLE();
+  VELOX_UNREACHABLE("Unsupported datetime unit");
 }
 
 FOLLY_ALWAYS_INLINE
diff --git a/velox/functions/prestosql/DecimalFunctions.cpp b/velox/functions/prestosql/DecimalFunctions.cpp
new file mode 100644
index 0000000000000..283d5e7ad9f68
--- /dev/null
+++ b/velox/functions/prestosql/DecimalFunctions.cpp
@@ -0,0 +1,667 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/DecodedArgs.h"
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/ArithmeticImpl.h"
+#include "velox/type/DecimalUtil.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+template <typename TExec>
+struct DecimalPlusFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    auto aType = inputTypes[0];
+    auto bType = inputTypes[1];
+    auto aScale = getDecimalPrecisionScale(*aType).second;
+    auto bScale = getDecimalPrecisionScale(*bType).second;
+    aRescale_ = computeRescaleFactor(aScale, bScale);
+    bRescale_ = computeRescaleFactor(bScale, aScale);
+  }
+
+  template <typename R, typename A, typename B>
+  void call(R& out, const A& a, const B& b)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+  {
+    int128_t aRescaled;
+    int128_t bRescaled;
+    if (__builtin_mul_overflow(
+            a, DecimalUtil::kPowersOfTen[aRescale_], &aRescaled) ||
+        __builtin_mul_overflow(
+            b, DecimalUtil::kPowersOfTen[bRescale_], &bRescaled)) {
+      VELOX_ARITHMETIC_ERROR("Decimal overflow: {} + {}", a, b);
+    }
+    out = checkedPlus<R>(R(aRescaled), R(bRescaled));
+    DecimalUtil::valueInRange(out);
+  }
+
+ private:
+  inline static uint8_t computeRescaleFactor(
+      uint8_t fromScale,
+      uint8_t toScale) {
+    return std::max(0, toScale - fromScale);
+  }
+
+  uint8_t aRescale_;
+  uint8_t bRescale_;
+};
+
+template <typename TExec>
+struct DecimalMinusFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    const auto& aType = inputTypes[0];
+    const auto& bType = inputTypes[1];
+    auto aScale = getDecimalPrecisionScale(*aType).second;
+    auto bScale = getDecimalPrecisionScale(*bType).second;
+    aRescale_ = computeRescaleFactor(aScale, bScale);
+    bRescale_ = computeRescaleFactor(bScale, aScale);
+  }
+
+  template <typename R, typename A, typename B>
+  void call(R& out, const A& a, const B& b)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+  {
+    int128_t aRescaled;
+    int128_t bRescaled;
+    if (__builtin_mul_overflow(
+            a, DecimalUtil::kPowersOfTen[aRescale_], &aRescaled) ||
+        __builtin_mul_overflow(
+            b, DecimalUtil::kPowersOfTen[bRescale_], &bRescaled)) {
+      VELOX_ARITHMETIC_ERROR("Decimal overflow: {} - {}", a, b);
+    }
+    out = checkedMinus<R>(R(aRescaled), R(bRescaled));
+    DecimalUtil::valueInRange(out);
+  }
+
+ private:
+  inline static uint8_t computeRescaleFactor(
+      uint8_t fromScale,
+      uint8_t toScale) {
+    return std::max(0, toScale - fromScale);
+  }
+
+  uint8_t aRescale_;
+  uint8_t bRescale_;
+};
+
+template <typename TExec>
+struct DecimalMultiplyFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename R, typename A, typename B>
+  void call(R& out, const A& a, const B& b) {
+    out = checkedMultiply<R>(checkedMultiply<R>(R(a), R(b)), R(1));
+    DecimalUtil::valueInRange(out);
+  }
+};
+
+template <typename TExec>
+struct DecimalDivideFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    auto aType = inputTypes[0];
+    auto bType = inputTypes[1];
+    auto aScale = getDecimalPrecisionScale(*aType).second;
+    auto bScale = getDecimalPrecisionScale(*bType).second;
+    auto rScale = std::max(aScale, bScale);
+    aRescale_ = rScale - aScale + bScale;
+    VELOX_USER_CHECK_LE(
+        aRescale_, LongDecimalType::kMaxPrecision, "Decimal overflow");
+  }
+
+  template <typename R, typename A, typename B>
+  void call(R& out, const A& a, const B& b) {
+    DecimalUtil::divideWithRoundUp<R, A, B>(out, a, b, false, aRescale_, 0);
+    DecimalUtil::valueInRange(out);
+  }
+
+ private:
+  uint8_t aRescale_;
+};
+
+template <typename TExec>
+struct DecimalModulusFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    const auto& aType = inputTypes[0];
+    const auto& bType = inputTypes[1];
+    auto [aPrecision, aScale] = getDecimalPrecisionScale(*aType);
+    auto [bPrecision, bScale] = getDecimalPrecisionScale(*bType);
+    aRescale_ = std::max(0, bScale - aScale);
+    bRescale_ = std::max(0, aScale - bScale);
+  }
+
+  template <typename R, typename A, typename B>
+  void call(R& out, const A& a, const B& b) {
+    VELOX_USER_CHECK_NE(b, 0, "Modulus by zero");
+    int remainderSign = 1;
+    R unsignedDividendRescaled(a);
+    if (a < 0) {
+      remainderSign *= -1;
+      unsignedDividendRescaled *= -1;
+    }
+    unsignedDividendRescaled = checkedMultiply<R>(
+        unsignedDividendRescaled,
+        R(DecimalUtil::kPowersOfTen[aRescale_]),
+        "Decimal");
+
+    R unsignedDivisorRescaled(b);
+    if (b < 0) {
+      unsignedDivisorRescaled *= -1;
+    }
+    unsignedDivisorRescaled = checkedMultiply<B>(
+        unsignedDivisorRescaled,
+        R(DecimalUtil::kPowersOfTen[bRescale_]),
+        "Decimal");
+
+    R remainder = unsignedDividendRescaled % unsignedDivisorRescaled;
+    out = remainder * remainderSign;
+  }
+
+ private:
+  uint8_t aRescale_;
+  uint8_t bRescale_;
+};
+
+template <typename TExec>
+struct DecimalRoundFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      A* a) {
+    initialize(inputTypes, config, a, nullptr);
+  }
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      const int32_t* /*n*/) {
+    const auto [precision, scale] = getDecimalPrecisionScale(*inputTypes[0]);
+    precision_ = precision;
+    scale_ = scale;
+  }
+
+  template <typename R, typename A>
+  void call(R& out, const A& a) {
+    DecimalUtil::divideWithRoundUp<R, A, int128_t>(
+        out, a, DecimalUtil::kPowersOfTen[scale_], false, 0, 0);
+  }
+
+  template <typename R, typename A>
+  void call(R& out, const A& a, int32_t n) {
+    if (a == 0 || precision_ - scale_ + n <= 0) {
+      out = 0;
+      return;
+    }
+    if (n >= scale_) {
+      out = a;
+      return;
+    }
+    auto reScaleFactor = DecimalUtil::kPowersOfTen[scale_ - n];
+    DecimalUtil::divideWithRoundUp<R, A, int128_t>(
+        out, a, reScaleFactor, false, 0, 0);
+    out *= reScaleFactor;
+  }
+
+ private:
+  uint8_t precision_;
+  uint8_t scale_;
+};
+
+template <typename TExec>
+struct DecimalFloorFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/) {
+    scale_ = getDecimalPrecisionScale(*inputTypes[0]).second;
+  }
+
+  template <typename R, typename A>
+  void call(R& out, const A& a) {
+    const auto rescaleFactor = DecimalUtil::kPowersOfTen[scale_];
+    // Function interpretation is the same as ceil for negative numbers, and as
+    // floor for positive numbers.
+    const auto increment = (a % rescaleFactor) < 0 ? -1 : 0;
+    out = a / rescaleFactor + increment;
+  }
+
+ private:
+  uint8_t scale_;
+};
+
+template <typename TExec>
+struct DecimalTruncateFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/) {
+    const auto [precision, scale] = getDecimalPrecisionScale(*inputTypes[0]);
+    precision_ = precision;
+    scale_ = scale;
+  }
+
+  template <typename A>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      A* a,
+      const int32_t* /*n*/) {
+    initialize(inputTypes, config, a);
+  }
+
+  template <typename R, typename A>
+  void call(R& out, const A& a) {
+    if UNLIKELY (scale_ == 0 || a == 0) {
+      out = a;
+    } else {
+      out = a / DecimalUtil::kPowersOfTen[scale_];
+    }
+  }
+
+  template <typename A>
+  void call(A& out, const A& a, int32_t n) {
+    if UNLIKELY (a == 0 || (n + precision_ - scale_) <= 0) {
+      out = 0;
+    } else if UNLIKELY (scale_ <= n) {
+      out = a;
+    } else {
+      out = a - (a % DecimalUtil::kPowersOfTen[scale_ - n]);
+    }
+  }
+
+ private:
+  uint8_t precision_;
+  uint8_t scale_;
+};
+
+template <template <class> typename Func>
+void registerDecimalBinary(
+    const std::string& name,
+    const std::vector<exec::SignatureVariable>& constraints) {
+  // (long, long) -> long
+  registerFunction<
+      Func,
+      LongDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({name}, constraints);
+
+  // (short, short) -> short
+  registerFunction<
+      Func,
+      ShortDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({name}, constraints);
+
+  // (short, short) -> long
+  registerFunction<
+      Func,
+      LongDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({name}, constraints);
+
+  // (short, long) -> long
+  registerFunction<
+      Func,
+      LongDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({name}, constraints);
+
+  // (long, short) -> long
+  registerFunction<
+      Func,
+      LongDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({name}, constraints);
+}
+
+template <template <class> typename Func>
+void registerDecimalPlusMinus(const std::string& name) {
+  std::vector<exec::SignatureVariable> constraints = {
+      exec::SignatureVariable(
+          P3::name(),
+          fmt::format(
+              "min(38, max({a_precision} - {a_scale}, {b_precision} - {b_scale}) + max({a_scale}, {b_scale}) + 1)",
+              fmt::arg("a_precision", P1::name()),
+              fmt::arg("b_precision", P2::name()),
+              fmt::arg("a_scale", S1::name()),
+              fmt::arg("b_scale", S2::name())),
+          exec::ParameterType::kIntegerParameter),
+      exec::SignatureVariable(
+          S3::name(),
+          fmt::format(
+              "max({a_scale}, {b_scale})",
+              fmt::arg("a_scale", S1::name()),
+              fmt::arg("b_scale", S2::name())),
+          exec::ParameterType::kIntegerParameter),
+  };
+
+  registerDecimalBinary<Func>(name, constraints);
+}
+
+} // namespace
+
+void registerDecimalPlus(const std::string& prefix) {
+  registerDecimalPlusMinus<DecimalPlusFunction>(prefix + "plus");
+}
+
+void registerDecimalMinus(const std::string& prefix) {
+  registerDecimalPlusMinus<DecimalMinusFunction>(prefix + "minus");
+}
+
+void registerDecimalMultiply(const std::string& prefix) {
+  std::vector<exec::SignatureVariable> constraints = {
+      exec::SignatureVariable(
+          P3::name(),
+          fmt::format(
+              "min(38, {a_precision} + {b_precision})",
+              fmt::arg("a_precision", P1::name()),
+              fmt::arg("b_precision", P2::name())),
+          exec::ParameterType::kIntegerParameter),
+      exec::SignatureVariable(
+          S3::name(),
+          // Result type resolution fails if sum of input scales exceeds 38.
+          fmt::format(
+              "{a_scale} + {b_scale}",
+              fmt::arg("a_scale", S1::name()),
+              fmt::arg("b_scale", S2::name())),
+          exec::ParameterType::kIntegerParameter),
+  };
+
+  registerDecimalBinary<DecimalMultiplyFunction>(
+      prefix + "multiply", constraints);
+}
+
+void registerDecimalDivide(const std::string& prefix) {
+  std::vector<exec::SignatureVariable> constraints = {
+      exec::SignatureVariable(
+          P3::name(),
+          fmt::format(
+              "min(38, {a_precision} + {b_scale} + max(0, {b_scale} - {a_scale}))",
+              fmt::arg("a_precision", P1::name()),
+              fmt::arg("a_scale", S1::name()),
+              fmt::arg("b_scale", S2::name())),
+          exec::ParameterType::kIntegerParameter),
+      exec::SignatureVariable(
+          S3::name(),
+          fmt::format(
+              "max({a_scale}, {b_scale})",
+              fmt::arg("a_scale", S1::name()),
+              fmt::arg("b_scale", S2::name())),
+          exec::ParameterType::kIntegerParameter),
+  };
+
+  registerDecimalBinary<DecimalDivideFunction>(prefix + "divide", constraints);
+
+  // (short, long) -> short
+  registerFunction<
+      DecimalDivideFunction,
+      ShortDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({prefix + "divide"}, constraints);
+
+  // (long, short) -> short
+  registerFunction<
+      DecimalDivideFunction,
+      ShortDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({prefix + "divide"}, constraints);
+}
+
+void registerDecimalModulus(const std::string& prefix) {
+  std::vector<exec::SignatureVariable> constraints = {
+      exec::SignatureVariable(
+          P3::name(),
+          fmt::format(
+              "min({b_precision} - {b_scale}, {a_precision} - {a_scale}) + max({a_scale}, {b_scale})",
+              fmt::arg("a_precision", P1::name()),
+              fmt::arg("a_scale", S1::name()),
+              fmt::arg("b_precision", P2::name()),
+              fmt::arg("b_scale", S2::name())),
+          exec::ParameterType::kIntegerParameter),
+      exec::SignatureVariable(
+          S3::name(),
+          fmt::format(
+              "max({a_scale}, {b_scale})",
+              fmt::arg("a_scale", S1::name()),
+              fmt::arg("b_scale", S2::name())),
+          exec::ParameterType::kIntegerParameter),
+  };
+
+  // (short, short) -> short
+  registerFunction<
+      DecimalModulusFunction,
+      ShortDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({prefix + "mod"}, constraints);
+
+  // (short, long) -> short
+  registerFunction<
+      DecimalModulusFunction,
+      ShortDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({prefix + "mod"}, constraints);
+
+  // (long, short) -> short
+  registerFunction<
+      DecimalModulusFunction,
+      ShortDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({prefix + "mod"}, constraints);
+
+  // (short, long) -> long
+  registerFunction<
+      DecimalModulusFunction,
+      LongDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({prefix + "mod"}, constraints);
+
+  // (long, short) -> long
+  registerFunction<
+      DecimalModulusFunction,
+      LongDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({prefix + "mod"}, constraints);
+
+  // (long, long) -> long
+  registerFunction<
+      DecimalModulusFunction,
+      LongDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({prefix + "mod"}, constraints);
+}
+
+void registerDecimalFloor(const std::string& prefix) {
+  std::vector<exec::SignatureVariable> constraints = {
+      exec::SignatureVariable(
+          P2::name(),
+          fmt::format(
+              "min(38, {p} - {s} + min({s}, 1))",
+              fmt::arg("p", P1::name()),
+              fmt::arg("s", S1::name())),
+          exec::ParameterType::kIntegerParameter),
+      exec::SignatureVariable(
+          S2::name(), "0", exec::ParameterType::kIntegerParameter),
+  };
+
+  registerFunction<
+      DecimalFloorFunction,
+      LongDecimal<P2, S2>,
+      LongDecimal<P1, S1>>({prefix + "floor"}, constraints);
+
+  registerFunction<
+      DecimalFloorFunction,
+      ShortDecimal<P2, S2>,
+      LongDecimal<P1, S1>>({prefix + "floor"}, constraints);
+
+  registerFunction<
+      DecimalFloorFunction,
+      ShortDecimal<P2, S2>,
+      ShortDecimal<P1, S1>>({prefix + "floor"}, constraints);
+}
+
+void registerDecimalRound(const std::string& prefix) {
+  // round(decimal) -> decimal
+  {
+    std::vector<exec::SignatureVariable> constraints = {
+        exec::SignatureVariable(
+            P2::name(),
+            fmt::format(
+                "min(38, {p} - {s} + min({s}, 1))",
+                fmt::arg("p", P1::name()),
+                fmt::arg("s", S1::name())),
+            exec::ParameterType::kIntegerParameter),
+        exec::SignatureVariable(
+            S2::name(), "0", exec::ParameterType::kIntegerParameter),
+    };
+
+    registerFunction<
+        DecimalRoundFunction,
+        LongDecimal<P2, S2>,
+        LongDecimal<P1, S1>>({prefix + "round"}, constraints);
+
+    registerFunction<
+        DecimalRoundFunction,
+        ShortDecimal<P2, S2>,
+        LongDecimal<P1, S1>>({prefix + "round"}, constraints);
+
+    registerFunction<
+        DecimalRoundFunction,
+        ShortDecimal<P2, S2>,
+        ShortDecimal<P1, S1>>({prefix + "round"}, constraints);
+  }
+
+  // round(decimal, n) -> decimal
+  {
+    std::vector<exec::SignatureVariable> constraints = {
+        exec::SignatureVariable(
+            P2::name(),
+            fmt::format("min(38, {p} + 1)", fmt::arg("p", P1::name())),
+            exec::ParameterType::kIntegerParameter),
+    };
+
+    registerFunction<
+        DecimalRoundFunction,
+        LongDecimal<P2, S1>,
+        LongDecimal<P1, S1>,
+        int32_t>({prefix + "round"}, constraints);
+
+    registerFunction<
+        DecimalRoundFunction,
+        ShortDecimal<P2, S1>,
+        ShortDecimal<P1, S1>,
+        int32_t>({prefix + "round"}, constraints);
+
+    registerFunction<
+        DecimalRoundFunction,
+        LongDecimal<P2, S1>,
+        ShortDecimal<P1, S1>,
+        int32_t>({prefix + "round"}, constraints);
+  }
+}
+
+void registerDecimalTruncate(const std::string& prefix) {
+  // truncate(decimal) -> decimal
+  std::vector<exec::SignatureVariable> constraints = {
+      exec::SignatureVariable(
+          P2::name(),
+          fmt::format(
+              "max({p} - {s}, 1)",
+              fmt::arg("p", P1::name()),
+              fmt::arg("s", S1::name())),
+          exec::ParameterType::kIntegerParameter),
+      exec::SignatureVariable(
+          S2::name(), "0", exec::ParameterType::kIntegerParameter),
+  };
+
+  registerFunction<
+      DecimalTruncateFunction,
+      ShortDecimal<P2, S2>,
+      ShortDecimal<P1, S1>>({prefix + "truncate"}, constraints);
+
+  registerFunction<
+      DecimalTruncateFunction,
+      LongDecimal<P2, S2>,
+      LongDecimal<P1, S1>>({prefix + "truncate"}, constraints);
+
+  registerFunction<
+      DecimalTruncateFunction,
+      ShortDecimal<P2, S2>,
+      LongDecimal<P1, S1>>({prefix + "truncate"}, constraints);
+
+  // truncate(decimal, n) -> decimal
+  registerFunction<
+      DecimalTruncateFunction,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P1, S1>,
+      int32_t>({prefix + "truncate"});
+
+  registerFunction<
+      DecimalTruncateFunction,
+      LongDecimal<P1, S1>,
+      LongDecimal<P1, S1>,
+      int32_t>({prefix + "truncate"});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/DecimalFunctions.h b/velox/functions/prestosql/DecimalFunctions.h
new file mode 100644
index 0000000000000..651a0cd6b565f
--- /dev/null
+++ b/velox/functions/prestosql/DecimalFunctions.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions {
+
+void registerDecimalPlus(const std::string& prefix);
+
+void registerDecimalMinus(const std::string& prefix);
+
+void registerDecimalMultiply(const std::string& prefix);
+
+void registerDecimalDivide(const std::string& prefix);
+
+void registerDecimalModulus(const std::string& prefix);
+
+void registerDecimalFloor(const std::string& prefix);
+
+void registerDecimalRound(const std::string& prefix);
+
+void registerDecimalTruncate(const std::string& prefix);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/DecimalVectorFunctions.cpp b/velox/functions/prestosql/DecimalVectorFunctions.cpp
deleted file mode 100644
index d1351728741ea..0000000000000
--- a/velox/functions/prestosql/DecimalVectorFunctions.cpp
+++ /dev/null
@@ -1,770 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/expression/DecodedArgs.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/prestosql/ArithmeticImpl.h"
-#include "velox/type/DecimalUtil.h"
-
-namespace facebook::velox::functions {
-namespace {
-
-struct ExtraParams {
-  union params {
-    struct round {
-      std::optional<int32_t> decimal{};
-    } round;
-  } params;
-};
-
-template <
-    typename R /* Result Type */,
-    typename A /* Argument1 */,
-    typename B /* Argument2 */,
-    typename Operation /* Arithmetic operation */>
-class DecimalBaseFunction : public exec::VectorFunction {
- public:
-  DecimalBaseFunction(uint8_t aRescale, uint8_t bRescale)
-      : aRescale_(aRescale), bRescale_(bRescale) {}
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& resultType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    auto rawResults = prepareResults(rows, resultType, context, result);
-    if (args[0]->isConstantEncoding() && args[1]->isFlatEncoding()) {
-      // Fast path for (const, flat).
-      auto constant = args[0]->asUnchecked<SimpleVector<A>>()->valueAt(0);
-      auto flatValues = args[1]->asUnchecked<FlatVector<B>>();
-      auto rawValues = flatValues->mutableRawValues();
-      context.applyToSelectedNoThrow(rows, [&](auto row) {
-        Operation::template apply<R, A, B>(
-            rawResults[row], constant, rawValues[row], aRescale_, bRescale_);
-      });
-    } else if (args[0]->isFlatEncoding() && args[1]->isConstantEncoding()) {
-      // Fast path for (flat, const).
-      auto flatValues = args[0]->asUnchecked<FlatVector<A>>();
-      auto constant = args[1]->asUnchecked<SimpleVector<B>>()->valueAt(0);
-      auto rawValues = flatValues->mutableRawValues();
-      context.applyToSelectedNoThrow(rows, [&](auto row) {
-        Operation::template apply<R, A, B>(
-            rawResults[row], rawValues[row], constant, aRescale_, bRescale_);
-      });
-    } else if (args[0]->isFlatEncoding() && args[1]->isFlatEncoding()) {
-      // Fast path for (flat, flat).
-      auto flatA = args[0]->asUnchecked<FlatVector<A>>();
-      auto rawA = flatA->mutableRawValues();
-      auto flatB = args[1]->asUnchecked<FlatVector<B>>();
-      auto rawB = flatB->mutableRawValues();
-      context.applyToSelectedNoThrow(rows, [&](auto row) {
-        Operation::template apply<R, A, B>(
-            rawResults[row], rawA[row], rawB[row], aRescale_, bRescale_);
-      });
-    } else {
-      // Fast path if one or more arguments are encoded.
-      exec::DecodedArgs decodedArgs(rows, args, context);
-      auto a = decodedArgs.at(0);
-      auto b = decodedArgs.at(1);
-      context.applyToSelectedNoThrow(rows, [&](auto row) {
-        Operation::template apply<R, A, B>(
-            rawResults[row],
-            a->valueAt<A>(row),
-            b->valueAt<B>(row),
-            aRescale_,
-            bRescale_);
-      });
-    }
-  }
-
- private:
-  R* prepareResults(
-      const SelectivityVector& rows,
-      const TypePtr& resultType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const {
-    context.ensureWritable(rows, resultType, result);
-    result->clearNulls(rows);
-    return result->asUnchecked<FlatVector<R>>()->mutableRawValues();
-  }
-
-  const uint8_t aRescale_;
-  const uint8_t bRescale_;
-};
-
-template <
-    typename R /* Result Type */,
-    typename A /* Argument */,
-    typename Operation /* Arithmetic operation */>
-class DecimalUnaryFunction : public exec::VectorFunction {
- public:
-  explicit DecimalUnaryFunction(
-      uint8_t aPrecision,
-      uint8_t aRescale,
-      const ExtraParams& param)
-      : aPrecision_(aPrecision), aRescale_(aRescale), param_(param) {}
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& resultType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    // Single-arg deterministic functions receive their only
-    // argument as flat or constant only.
-    auto rawResults = prepareResults(rows, resultType, context, result);
-    if (args[0]->isConstantEncoding()) {
-      // Fast path for constant vectors.
-      auto constant = args[0]->asUnchecked<SimpleVector<A>>()->valueAt(0);
-      context.applyToSelectedNoThrow(rows, [&](auto row) {
-        Operation::template apply<R, A>(
-            rawResults[row], constant, aPrecision_, aRescale_, param_);
-      });
-    } else {
-      // Fast path for flat.
-      auto flatA = args[0]->asUnchecked<FlatVector<A>>();
-      auto rawA = flatA->mutableRawValues();
-      context.applyToSelectedNoThrow(rows, [&](auto row) {
-        Operation::template apply<R, A>(
-            rawResults[row], rawA[row], aPrecision_, aRescale_, param_);
-      });
-    }
-  }
-
-  bool supportsFlatNoNullsFastPath() const override {
-    return true;
-  }
-
- private:
-  R* prepareResults(
-      const SelectivityVector& rows,
-      const TypePtr& resultType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const {
-    context.ensureWritable(rows, resultType, result);
-    result->clearNulls(rows);
-    return result->asUnchecked<FlatVector<R>>()->mutableRawValues();
-  }
-
-  const uint8_t aPrecision_;
-  const uint8_t aRescale_;
-  const ExtraParams param_;
-};
-
-template <typename A /* Argument */>
-class DecimalBetweenFunction : public exec::VectorFunction {
- public:
-  DecimalBetweenFunction() {}
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& resultType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    prepareResults(rows, resultType, context, result);
-
-    // Fast path when the first argument is a flat vector.
-    if (args[0]->isFlatEncoding()) {
-      auto rawA = args[0]->asUnchecked<FlatVector<A>>()->mutableRawValues();
-
-      if (args[1]->isConstantEncoding() && args[2]->isConstantEncoding()) {
-        auto constantB = args[1]->asUnchecked<SimpleVector<A>>()->valueAt(0);
-        auto constantC = args[2]->asUnchecked<SimpleVector<A>>()->valueAt(0);
-        context.applyToSelectedNoThrow(rows, [&](auto row) {
-          result->asUnchecked<FlatVector<bool>>()->set(
-              row, rawA[row] >= constantB && rawA[row] <= constantC);
-        });
-        return;
-      }
-
-      if (args[1]->isConstantEncoding() && args[2]->isFlatEncoding()) {
-        auto constantB = args[1]->asUnchecked<SimpleVector<A>>()->valueAt(0);
-        auto rawC = args[2]->asUnchecked<FlatVector<A>>()->mutableRawValues();
-        context.applyToSelectedNoThrow(rows, [&](auto row) {
-          result->asUnchecked<FlatVector<bool>>()->set(
-              row, rawA[row] >= constantB && rawA[row] <= rawC[row]);
-        });
-        return;
-      }
-
-      if (args[1]->isFlatEncoding() && args[2]->isConstantEncoding()) {
-        auto rawB = args[1]->asUnchecked<FlatVector<A>>()->mutableRawValues();
-        auto constantC = args[2]->asUnchecked<SimpleVector<A>>()->valueAt(0);
-        context.applyToSelectedNoThrow(rows, [&](auto row) {
-          result->asUnchecked<FlatVector<bool>>()->set(
-              row, rawA[row] >= rawB[row] && rawA[row] <= constantC);
-        });
-        return;
-      }
-
-      if (args[1]->isFlatEncoding() && args[2]->isFlatEncoding()) {
-        auto rawB = args[1]->asUnchecked<FlatVector<A>>()->mutableRawValues();
-        auto rawC = args[2]->asUnchecked<FlatVector<A>>()->mutableRawValues();
-        context.applyToSelectedNoThrow(rows, [&](auto row) {
-          result->asUnchecked<FlatVector<bool>>()->set(
-              row, rawA[row] >= rawB[row] && rawA[row] <= rawC[row]);
-        });
-        return;
-      }
-    } else {
-      // Fast path when the first argument is encoded but the second and third
-      // are constants.
-      exec::DecodedArgs decodedArgs(rows, args, context);
-      auto aDecoded = decodedArgs.at(0);
-      auto aDecodedData = aDecoded->data<A>();
-
-      if (args[1]->isConstantEncoding() && args[2]->isConstantEncoding()) {
-        auto constantB = args[1]->asUnchecked<SimpleVector<A>>()->valueAt(0);
-        auto constantC = args[2]->asUnchecked<SimpleVector<A>>()->valueAt(0);
-        context.applyToSelectedNoThrow(rows, [&](auto row) {
-          auto value = aDecodedData[aDecoded->index(row)];
-          result->asUnchecked<FlatVector<bool>>()->set(
-              row, value >= constantB && value <= constantC);
-        });
-        return;
-      }
-    }
-
-    // Decode the input in all other cases.
-    exec::DecodedArgs decodedArgs(rows, args, context);
-    auto aDecoded = decodedArgs.at(0);
-    auto bDecoded = decodedArgs.at(1);
-    auto cDecoded = decodedArgs.at(2);
-
-    auto aDecodedData = aDecoded->data<A>();
-    auto bDecodedData = bDecoded->data<A>();
-    auto cDecodedData = cDecoded->data<A>();
-
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      auto aValue = aDecodedData[aDecoded->index(row)];
-      auto bValue = bDecodedData[bDecoded->index(row)];
-      auto cValue = cDecodedData[cDecoded->index(row)];
-      result->asUnchecked<FlatVector<bool>>()->set(
-          row, aValue >= bValue && aValue <= cValue);
-    });
-  }
-
- private:
-  void prepareResults(
-      const SelectivityVector& rows,
-      const TypePtr& resultType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const {
-    context.ensureWritable(rows, resultType, result);
-    result->clearNulls(rows);
-  }
-};
-
-class Addition {
- public:
-  template <typename R, typename A, typename B>
-  inline static void
-  apply(R& r, const A& a, const B& b, uint8_t aRescale, uint8_t bRescale)
-#if defined(__has_feature)
-#if __has_feature(__address_sanitizer__)
-      __attribute__((__no_sanitize__("signed-integer-overflow")))
-#endif
-#endif
-  {
-    int128_t aRescaled;
-    int128_t bRescaled;
-    if (__builtin_mul_overflow(
-            a, DecimalUtil::kPowersOfTen[aRescale], &aRescaled) ||
-        __builtin_mul_overflow(
-            b, DecimalUtil::kPowersOfTen[bRescale], &bRescaled)) {
-      VELOX_ARITHMETIC_ERROR("Decimal overflow: {} + {}", a, b);
-    }
-    r = checkedPlus<R>(R(aRescaled), R(bRescaled));
-    DecimalUtil::valueInRange(r);
-  }
-
-  inline static uint8_t
-  computeRescaleFactor(uint8_t fromScale, uint8_t toScale, uint8_t rScale = 0) {
-    return std::max(0, toScale - fromScale);
-  }
-
-  inline static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      const uint8_t aPrecision,
-      const uint8_t aScale,
-      const uint8_t bPrecision,
-      const uint8_t bScale) {
-    return {
-        std::min(
-            38,
-            std::max(aPrecision - aScale, bPrecision - bScale) +
-                std::max(aScale, bScale) + 1),
-        std::max(aScale, bScale)};
-  }
-};
-
-class Subtraction {
- public:
-  template <typename R, typename A, typename B>
-  inline static void
-  apply(R& r, const A& a, const B& b, uint8_t aRescale, uint8_t bRescale)
-#if defined(__has_feature)
-#if __has_feature(__address_sanitizer__)
-      __attribute__((__no_sanitize__("signed-integer-overflow")))
-#endif
-#endif
-  {
-    int128_t aRescaled;
-    int128_t bRescaled;
-    if (__builtin_mul_overflow(
-            a, DecimalUtil::kPowersOfTen[aRescale], &aRescaled) ||
-        __builtin_mul_overflow(
-            b, DecimalUtil::kPowersOfTen[bRescale], &bRescaled)) {
-      VELOX_ARITHMETIC_ERROR("Decimal overflow: {} - {}", a, b);
-    }
-    r = checkedMinus<R>(R(aRescaled), R(bRescaled));
-    DecimalUtil::valueInRange(r);
-  }
-
-  inline static uint8_t
-  computeRescaleFactor(uint8_t fromScale, uint8_t toScale, uint8_t rScale = 0) {
-    return std::max(0, toScale - fromScale);
-  }
-
-  inline static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      const uint8_t aPrecision,
-      const uint8_t aScale,
-      const uint8_t bPrecision,
-      const uint8_t bScale) {
-    return Addition::computeResultPrecisionScale(
-        aPrecision, aScale, bPrecision, bScale);
-  }
-};
-
-class Multiply {
- public:
-  template <typename R, typename A, typename B>
-  inline static void
-  apply(R& r, const A& a, const B& b, uint8_t aRescale, uint8_t bRescale) {
-    r = checkedMultiply<R>(
-        checkedMultiply<R>(R(a), R(b)),
-        R(DecimalUtil::kPowersOfTen[aRescale + bRescale]));
-    DecimalUtil::valueInRange(r);
-  }
-
-  inline static uint8_t
-  computeRescaleFactor(uint8_t fromScale, uint8_t toScale, uint8_t rScale = 0) {
-    return 0;
-  }
-
-  inline static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      const uint8_t aPrecision,
-      const uint8_t aScale,
-      const uint8_t bPrecision,
-      const uint8_t bScale) {
-    return {std::min(38, aPrecision + bPrecision), aScale + bScale};
-  }
-};
-
-class Divide {
- public:
-  template <typename R, typename A, typename B>
-  inline static void
-  apply(R& r, const A& a, const B& b, uint8_t aRescale, uint8_t /*bRescale*/) {
-    DecimalUtil::divideWithRoundUp<R, A, B>(r, a, b, false, aRescale, 0);
-    DecimalUtil::valueInRange(r);
-  }
-
-  inline static uint8_t
-  computeRescaleFactor(uint8_t fromScale, uint8_t toScale, uint8_t rScale) {
-    return rScale - fromScale + toScale;
-  }
-
-  inline static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      const uint8_t aPrecision,
-      const uint8_t aScale,
-      const uint8_t /*bPrecision*/,
-      const uint8_t bScale) {
-    return {
-        std::min(38, aPrecision + bScale + std::max(0, bScale - aScale)),
-        std::max(aScale, bScale)};
-  }
-};
-
-class Round {
- public:
-  template <typename R, typename A>
-  inline static void apply(
-      R& r,
-      const A& a,
-      uint8_t aPrecision,
-      uint8_t aRescale,
-      const ExtraParams& extraParams) {
-    auto decimalParam = extraParams.params.round.decimal;
-    if (!decimalParam.has_value()) {
-      // Basic round function.
-      DecimalUtil::divideWithRoundUp<R, A, int128_t>(
-          r, a, DecimalUtil::kPowersOfTen[aRescale], false, 0, 0);
-      return;
-    }
-    // RoundN function.
-    if (a == 0 || aPrecision - aRescale + decimalParam.value() <= 0) {
-      r = 0;
-      return;
-    }
-    if (decimalParam >= aRescale) {
-      r = a;
-      return;
-    }
-    auto reScaleFactor =
-        DecimalUtil::kPowersOfTen[aRescale - decimalParam.value()];
-    DecimalUtil::divideWithRoundUp<R, A, int128_t>(
-        r, a, reScaleFactor, false, 0, 0);
-    r = r * reScaleFactor;
-  }
-
-  inline static uint8_t computeRescaleFactor(
-      uint8_t fromScale,
-      uint8_t /*toScale*/,
-      uint8_t /*rScale*/) {
-    return fromScale;
-  }
-
-  inline static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      const uint8_t aPrecision,
-      const uint8_t aScale,
-      const ExtraParams& extraParams) {
-    if (!extraParams.params.round.decimal.has_value()) {
-      // Return result precision and scale for basic round function.
-      return {
-          std::min(38, aPrecision - aScale + std::min((uint8_t)1, aScale)), 0};
-    }
-    return {std::min(38, aPrecision + 1), aScale};
-  }
-};
-
-class Abs {
- public:
-  template <typename R, typename A>
-  inline static void apply(
-      R& r,
-      const A& a,
-      uint8_t aPrecision,
-      uint8_t /*aRescale*/,
-      const ExtraParams& /*param*/) {
-    if constexpr (std::is_same_v<R, A>) {
-      r = a < 0 ? R(-a) : a;
-    }
-  }
-
-  inline static uint8_t computeRescaleFactor(
-      uint8_t fromScale,
-      uint8_t /*toScale*/,
-      uint8_t /*rScale*/) {
-    return fromScale;
-  }
-
-  inline static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      const uint8_t aPrecision,
-      const uint8_t aScale,
-      const ExtraParams& param) {
-    return {aPrecision, aScale};
-  }
-};
-
-class Negate {
- public:
-  template <typename R, typename A>
-  inline static void apply(
-      R& r,
-      const A& a,
-      uint8_t aPrecision,
-      uint8_t /*aRescale*/,
-      const ExtraParams& /*param*/) {
-    if constexpr (std::is_same_v<R, A>) {
-      r = R(-a);
-    }
-  }
-
-  inline static uint8_t computeRescaleFactor(
-      uint8_t fromScale,
-      uint8_t /*toScale*/,
-      uint8_t /*rScale*/) {
-    return fromScale;
-  }
-
-  inline static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      const uint8_t aPrecision,
-      const uint8_t aScale,
-      const ExtraParams& /*additionalParm*/) {
-    return {aPrecision, aScale};
-  }
-};
-
-std::vector<std::shared_ptr<exec::FunctionSignature>>
-decimalMultiplySignature() {
-  return {
-      exec::FunctionSignatureBuilder()
-          .integerVariable("a_precision")
-          .integerVariable("a_scale")
-          .integerVariable("b_precision")
-          .integerVariable("b_scale")
-          .integerVariable("r_precision", "min(38, a_precision + b_precision)")
-          .integerVariable("r_scale", "a_scale + b_scale")
-          .returnType("DECIMAL(r_precision, r_scale)")
-          .argumentType("DECIMAL(a_precision, a_scale)")
-          .argumentType("DECIMAL(b_precision, b_scale)")
-          .build()};
-}
-
-std::vector<std::shared_ptr<exec::FunctionSignature>>
-decimalAddSubtractSignature() {
-  return {
-      exec::FunctionSignatureBuilder()
-          .integerVariable("a_precision")
-          .integerVariable("a_scale")
-          .integerVariable("b_precision")
-          .integerVariable("b_scale")
-          .integerVariable(
-              "r_precision",
-              "min(38, max(a_precision - a_scale, b_precision - b_scale) + max(a_scale, b_scale) + 1)")
-          .integerVariable("r_scale", "max(a_scale, b_scale)")
-          .returnType("DECIMAL(r_precision, r_scale)")
-          .argumentType("DECIMAL(a_precision, a_scale)")
-          .argumentType("DECIMAL(b_precision, b_scale)")
-          .build()};
-}
-
-std::vector<std::shared_ptr<exec::FunctionSignature>> decimalDivideSignature() {
-  return {exec::FunctionSignatureBuilder()
-              .integerVariable("a_precision")
-              .integerVariable("a_scale")
-              .integerVariable("b_precision")
-              .integerVariable("b_scale")
-              .integerVariable(
-                  "r_precision",
-                  "min(38, a_precision + b_scale + max(0, b_scale - a_scale))")
-              .integerVariable("r_scale", "max(a_scale, b_scale)")
-              .returnType("DECIMAL(r_precision, r_scale)")
-              .argumentType("DECIMAL(a_precision, a_scale)")
-              .argumentType("DECIMAL(b_precision, b_scale)")
-              .build()};
-}
-
-std::vector<std::shared_ptr<exec::FunctionSignature>> decimalRoundSignature() {
-  return {
-      exec::FunctionSignatureBuilder()
-          .integerVariable("a_precision")
-          .integerVariable("a_scale")
-          .integerVariable(
-              "r_precision", "min(38, a_precision - a_scale + min(1, a_scale))")
-          .returnType("DECIMAL(r_precision, 0)")
-          .argumentType("DECIMAL(a_precision, a_scale)")
-          .build(),
-      exec::FunctionSignatureBuilder()
-          .integerVariable("a_precision")
-          .integerVariable("a_scale")
-          .integerVariable("r_precision", "min(38, a_precision + 1)")
-          .returnType("DECIMAL(r_precision, a_scale)")
-          .argumentType("DECIMAL(a_precision, a_scale)")
-          .argumentType("integer")
-          .build()};
-}
-
-std::vector<std::shared_ptr<exec::FunctionSignature>>
-decimalAbsNegateSignature() {
-  return {exec::FunctionSignatureBuilder()
-              .integerVariable("a_precision")
-              .integerVariable("a_scale")
-              .returnType("DECIMAL(a_precision, a_scale)")
-              .argumentType("DECIMAL(a_precision, a_scale)")
-              .build()};
-}
-
-std::vector<std::shared_ptr<exec::FunctionSignature>>
-decimalBetweenSignature() {
-  return {exec::FunctionSignatureBuilder()
-              .integerVariable("a_precision")
-              .integerVariable("a_scale")
-              .returnType("boolean")
-              .argumentType("DECIMAL(a_precision, a_scale)")
-              .argumentType("DECIMAL(a_precision, a_scale)")
-              .argumentType("DECIMAL(a_precision, a_scale)")
-              .build()};
-}
-
-template <typename Operation>
-std::shared_ptr<exec::VectorFunction> createDecimalUnary(
-    const std::string& name,
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  auto aType = inputArgs[0].type;
-  auto [aPrecision, aScale] = getDecimalPrecisionScale(*aType);
-  ExtraParams extraParams{};
-  if (inputArgs.size() == 2) {
-    // Round can accept additional argument like number of decimal places.
-    VELOX_CHECK_EQ(inputArgs[1].type->kind(), TypeKind::INTEGER);
-    extraParams.params.round.decimal =
-        inputArgs[1]
-            .constantValue->asUnchecked<SimpleVector<int32_t>>()
-            ->valueAt(0);
-  }
-  auto [rPrecision, rScale] =
-      Operation::computeResultPrecisionScale(aPrecision, aScale, extraParams);
-  uint8_t aRescale = Operation::computeRescaleFactor(aScale, 0, rScale);
-  if (aType->isShortDecimal()) {
-    return std::make_shared<
-        DecimalUnaryFunction<int64_t /*result*/, int64_t, Operation>>(
-        aPrecision, aRescale, extraParams);
-  } else if (aType->isLongDecimal()) {
-    if (rPrecision <= ShortDecimalType::kMaxPrecision) {
-      return std::make_shared<
-          DecimalUnaryFunction<int64_t /*result*/, int128_t, Operation>>(
-          aPrecision, aRescale, extraParams);
-    }
-    return std::make_shared<
-        DecimalUnaryFunction<int128_t /*result*/, int128_t, Operation>>(
-        aPrecision, aRescale, extraParams);
-  }
-  VELOX_UNSUPPORTED();
-}
-
-template <typename Operation>
-std::shared_ptr<exec::VectorFunction> createDecimalFunction(
-    const std::string& name,
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  auto aType = inputArgs[0].type;
-  auto bType = inputArgs[1].type;
-  auto [aPrecision, aScale] = getDecimalPrecisionScale(*aType);
-  auto [bPrecision, bScale] = getDecimalPrecisionScale(*bType);
-  auto [rPrecision, rScale] = Operation::computeResultPrecisionScale(
-      aPrecision, aScale, bPrecision, bScale);
-  uint8_t aRescale = Operation::computeRescaleFactor(aScale, bScale, rScale);
-  uint8_t bRescale = Operation::computeRescaleFactor(bScale, aScale, rScale);
-  if (aType->isShortDecimal()) {
-    if (bType->isShortDecimal()) {
-      if (rPrecision > ShortDecimalType::kMaxPrecision) {
-        // Arguments are short decimals and result is a long decimal.
-        return std::make_shared<DecimalBaseFunction<
-            int128_t /*result*/,
-            int64_t,
-            int64_t,
-            Operation>>(aRescale, bRescale);
-      } else {
-        // Arguments are short decimals and result is a short decimal.
-        return std::make_shared<DecimalBaseFunction<
-            int64_t /*result*/,
-            int64_t,
-            int64_t,
-            Operation>>(aRescale, bRescale);
-      }
-    } else {
-      if (rPrecision > ShortDecimalType::kMaxPrecision) {
-        // LHS is short decimal and rhs is a long decimal, result is long
-        // decimal.
-        return std::make_shared<DecimalBaseFunction<
-            int128_t /*result*/,
-            int64_t,
-            int128_t,
-            Operation>>(aRescale, bRescale);
-      } else {
-        // In some cases such as division, the result type can still be a short
-        // decimal even though RHS is a long decimal.
-        return std::make_shared<DecimalBaseFunction<
-            int64_t /*result*/,
-            int64_t,
-            int128_t,
-            Operation>>(aRescale, bRescale);
-      }
-    }
-  } else {
-    if (bType->isShortDecimal()) {
-      // LHS is long decimal and rhs is short decimal, result is a long decimal.
-      return std::make_shared<DecimalBaseFunction<
-          int128_t /*result*/,
-          int128_t,
-          int64_t,
-          Operation>>(aRescale, bRescale);
-    } else {
-      // Arguments and result are all long decimals.
-      return std::make_shared<DecimalBaseFunction<
-          int128_t /*result*/,
-          int128_t,
-          int128_t,
-          Operation>>(aRescale, bRescale);
-    }
-  }
-  VELOX_UNSUPPORTED();
-}
-
-std::shared_ptr<exec::VectorFunction> createDecimalBetweenFunction(
-    const std::string& name,
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  auto aType = inputArgs[0].type;
-  auto bType = inputArgs[1].type;
-  auto cType = inputArgs[2].type;
-  if (aType->isShortDecimal()) {
-    VELOX_CHECK(bType->isShortDecimal());
-    VELOX_CHECK(cType->isShortDecimal());
-    // Arguments are short decimals.
-    return std::make_shared<DecimalBetweenFunction<int64_t>>();
-  } else {
-    VELOX_CHECK(bType->isLongDecimal());
-    VELOX_CHECK(cType->isLongDecimal());
-    // Arguments are long decimals.
-    return std::make_shared<DecimalBetweenFunction<int128_t>>();
-  }
-  VELOX_UNSUPPORTED();
-}
-}; // namespace
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_decimal_add,
-    decimalAddSubtractSignature(),
-    createDecimalFunction<Addition>);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_decimal_sub,
-    decimalAddSubtractSignature(),
-    createDecimalFunction<Subtraction>);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_decimal_mul,
-    decimalMultiplySignature(),
-    createDecimalFunction<Multiply>);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_decimal_div,
-    decimalDivideSignature(),
-    createDecimalFunction<Divide>);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_decimal_round,
-    decimalRoundSignature(),
-    createDecimalUnary<Round>);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_decimal_abs,
-    decimalAbsNegateSignature(),
-    createDecimalUnary<Abs>);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_decimal_negate,
-    decimalAbsNegateSignature(),
-    createDecimalUnary<Negate>);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_decimal_between,
-    decimalBetweenSignature(),
-    createDecimalBetweenFunction);
-}; // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ElementAt.cpp b/velox/functions/prestosql/ElementAt.cpp
index 5bc0d8430f4e7..373fbf5979ab3 100644
--- a/velox/functions/prestosql/ElementAt.cpp
+++ b/velox/functions/prestosql/ElementAt.cpp
@@ -29,16 +29,35 @@ namespace {
 /// - allows out of bounds accesses for arrays and maps (returns NULL if out of
 ///    bounds).
 /// - index starts at 1 for arrays.
-using ElementAtFunction = SubscriptImpl<
-    /* allowNegativeIndices */ true,
-    /* nullOnNegativeIndices */ false,
-    /* allowOutOfBound */ true,
-    /* indexStartsAtOne */ true>;
+class ElementAtFunction : public SubscriptImpl<
+                              /* allowNegativeIndices */ true,
+                              /* nullOnNegativeIndices */ false,
+                              /* allowOutOfBound */ true,
+                              /* indexStartsAtOne */ true> {
+ public:
+  explicit ElementAtFunction(bool allowcaching) : SubscriptImpl(allowcaching) {}
+};
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_element_at,
-    ElementAtFunction::signatures(),
-    std::make_unique<ElementAtFunction>());
+void registerElementAtFunction(
+    const std::string& name,
+    bool enableCaching = true) {
+  exec::registerStatefulVectorFunction(
+      name,
+      ElementAtFunction::signatures(),
+      [enableCaching](
+          const std::string&,
+          const std::vector<exec::VectorFunctionArg>& inputArgs,
+          const velox::core::QueryConfig& config) {
+        static const auto kSubscriptStateLess =
+            std::make_shared<ElementAtFunction>(false);
+        if (inputArgs[0].type->isArray()) {
+          return kSubscriptStateLess;
+        } else {
+          return std::make_shared<ElementAtFunction>(
+              enableCaching && config.isExpressionEvaluationCacheEnabled());
+        }
+      });
+}
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Fail.h b/velox/functions/prestosql/Fail.h
new file mode 100644
index 0000000000000..14d95e50d593b
--- /dev/null
+++ b/velox/functions/prestosql/Fail.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/Macros.h"
+#include "velox/functions/prestosql/json/SIMDJsonExtractor.h"
+#include "velox/functions/prestosql/json/SIMDJsonWrapper.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec>
+struct FailFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<UnknownValue>& /*result*/, const arg_type<Varchar>& message) {
+    if (threadSkipErrorDetails()) {
+      return Status::UserError();
+    }
+
+    return Status::UserError("{}", message);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<UnknownValue>& result,
+      const arg_type<int32_t>& /*errorCode*/,
+      const arg_type<Varchar>& message) {
+    return call(result, message);
+  }
+};
+
+template <typename TExec>
+struct FailFromJsonFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<UnknownValue>& /*result*/, const arg_type<Json>& json) {
+    if (threadSkipErrorDetails()) {
+      return Status::UserError();
+    }
+
+    // Extract 'message' field from 'json'.
+    std::string_view message;
+    if (extractMessage(json, message) != simdjson::SUCCESS) {
+      return Status::UserError(
+          "Cannot extract 'message' from the JSON: {}", json);
+    }
+
+    return Status::UserError("{}", message);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<UnknownValue>& result,
+      const arg_type<int32_t>& /*errorCode*/,
+      const arg_type<Json>& json) {
+    return call(result, json);
+  }
+
+ private:
+  static simdjson::error_code extractMessage(
+      const StringView& json,
+      std::string_view& message) {
+    simdjson::padded_string paddedJson(json.data(), json.size());
+
+    SIMDJSON_ASSIGN_OR_RAISE(auto jsonDoc, simdjsonParse(paddedJson));
+
+    SIMDJSON_ASSIGN_OR_RAISE(message, jsonDoc["message"].get_string());
+
+    return simdjson::SUCCESS;
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/FilterFunctions.cpp b/velox/functions/prestosql/FilterFunctions.cpp
index aed4110385d9b..f0257fa330af5 100644
--- a/velox/functions/prestosql/FilterFunctions.cpp
+++ b/velox/functions/prestosql/FilterFunctions.cpp
@@ -24,27 +24,7 @@ namespace facebook::velox::functions {
 namespace {
 
 class FilterFunctionBase : public exec::VectorFunction {
- public:
-  bool isDefaultNullBehavior() const override {
-    // array_filter and map_filter are null preserving for the array and the
-    // map. But since an expr tree with a lambda depends on all named fields,
-    // including captures, a null in a capture does not automatically make a
-    // null result.
-    return false;
-  }
-
  protected:
-  static void appendToIndicesBuffer(
-      BufferPtr* buffer,
-      memory::MemoryPool* pool,
-      vector_size_t data) {
-    if (!*buffer) {
-      *buffer = AlignedBuffer::allocate<decltype(data)>(100, pool);
-      (*buffer)->setSize(0);
-    }
-    AlignedBuffer::appendTo(buffer, &data, 1);
-  }
-
   // Applies filter functions to elements of maps or arrays and returns the
   // number of elements that passed the filters. Stores the number of elements
   // in each array or map that passed the filter in resultSizes. Stores the
@@ -60,18 +40,24 @@ class FilterFunctionBase : public exec::VectorFunction {
       BufferPtr& resultOffsets,
       BufferPtr& resultSizes,
       BufferPtr& selectedIndices) {
-    auto inputOffsets = input->rawOffsets();
-    auto inputSizes = input->rawSizes();
+    const auto* inputOffsets = input->rawOffsets();
+    const auto* inputSizes = input->rawSizes();
 
     auto* pool = context.pool();
     resultSizes = allocateSizes(rows.end(), pool);
     resultOffsets = allocateOffsets(rows.end(), pool);
-    auto rawResultSizes = resultSizes->asMutable<vector_size_t>();
-    auto rawResultOffsets = resultOffsets->asMutable<vector_size_t>();
-    auto numElements = lambdaArgs[0]->size();
+    auto* rawResultSizes = resultSizes->asMutable<vector_size_t>();
+    auto* rawResultOffsets = resultOffsets->asMutable<vector_size_t>();
 
-    auto elementToTopLevelRows = getElementToTopLevelRows(
-        numElements, rows, input.get(), context.pool());
+    const auto numElements = lambdaArgs[0]->size();
+
+    selectedIndices = allocateIndices(numElements, pool);
+    auto* rawSelectedIndices = selectedIndices->asMutable<vector_size_t>();
+
+    vector_size_t numSelected = 0;
+
+    auto elementToTopLevelRows =
+        getElementToTopLevelRows(numElements, rows, input.get(), pool);
 
     exec::LocalDecodedVector bitsDecoder(context);
     auto iter = lambdas->asUnchecked<FunctionVector>()->iterator(&rows);
@@ -97,21 +83,21 @@ class FilterFunctionBase : public exec::VectorFunction {
         }
         auto size = inputSizes[row];
         auto offset = inputOffsets[row];
-        rawResultOffsets[row] = selectedIndices
-            ? selectedIndices->size() / sizeof(vector_size_t)
-            : 0;
+        rawResultOffsets[row] = numSelected;
         for (auto i = 0; i < size; ++i) {
           if (!bitsDecoder.get()->isNullAt(offset + i) &&
               bitsDecoder.get()->valueAt<bool>(offset + i)) {
             ++rawResultSizes[row];
-            appendToIndicesBuffer(&selectedIndices, pool, offset + i);
+            rawSelectedIndices[numSelected] = offset + i;
+            ++numSelected;
           }
         }
       });
     }
 
-    return selectedIndices ? selectedIndices->size() / sizeof(vector_size_t)
-                           : 0;
+    selectedIndices->setSize(numSelected * sizeof(vector_size_t));
+
+    return numSelected;
   }
 };
 
@@ -237,7 +223,7 @@ class MapFilterFunction : public FilterFunctionBase {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // map(K,V), function(K,V,boolean) -> map(K,V)
     return {exec::FunctionSignatureBuilder()
-                .knownTypeVariable("K")
+                .typeVariable("K")
                 .typeVariable("V")
                 .returnType("map(K,V)")
                 .argumentType("map(K,V)")
@@ -247,14 +233,21 @@ class MapFilterFunction : public FilterFunctionBase {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+/// array_filter and map_filter are null preserving for the array and the
+/// map. But since an expr tree with a lambda depends on all named fields,
+/// including captures, a null in a capture does not automatically make a
+/// null result.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_array_filter,
     ArrayFilterFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<ArrayFilterFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_map_filter,
     MapFilterFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<MapFilterFunction>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/FindFirst.cpp b/velox/functions/prestosql/FindFirst.cpp
index 2439b46f22883..fd9173e28c1a4 100644
--- a/velox/functions/prestosql/FindFirst.cpp
+++ b/velox/functions/prestosql/FindFirst.cpp
@@ -20,17 +20,15 @@
 namespace facebook::velox::functions {
 namespace {
 
-class FindFirstFunctionBase : public exec::VectorFunction {
- public:
-  bool isDefaultNullBehavior() const override {
-    // find_first function is null preserving for the array argument, but
-    // predicate expression may use other fields and may not preserve nulls in
-    // these.
-    // For example: find_first(array[1, 2, 3], x -> x > coalesce(a, 0)) should
-    // not return null when 'a' is null.
-    return false;
+void recordInvalidStartIndex(vector_size_t row, exec::EvalCtx& context) {
+  try {
+    VELOX_USER_FAIL("SQL array indices start at 1. Got 0.");
+  } catch (const VeloxUserError&) {
+    context.setVeloxExceptionError(row, std::current_exception());
   }
+}
 
+class FindFirstFunctionBase : public exec::VectorFunction {
  protected:
   ArrayVectorPtr prepareInputArray(
       const VectorPtr& input,
@@ -66,6 +64,7 @@ class FindFirstFunctionBase : public exec::VectorFunction {
       exec::EvalCtx& context,
       THit onHit,
       TMiss onMiss) const {
+    const auto* rawNulls = flatArray->rawNulls();
     const auto* rawOffsets = flatArray->rawOffsets();
     const auto* rawSizes = flatArray->rawSizes();
 
@@ -79,7 +78,7 @@ class FindFirstFunctionBase : public exec::VectorFunction {
     StartIndexProcessor startIndexProcessor;
     if (startIndex != nullptr) {
       startIndexProcessor.process(
-          startIndex, rows, rawOffsets, rawSizes, context);
+          startIndex, rows, rawNulls, rawOffsets, rawSizes, context);
       rawOffsets = startIndexProcessor.adjustedOffsets->as<vector_size_t>();
       rawSizes = startIndexProcessor.adjustedSizes->as<vector_size_t>();
     }
@@ -88,12 +87,18 @@ class FindFirstFunctionBase : public exec::VectorFunction {
     // in most cases there will be only one function and the loop will run once.
     auto it = predicates.iterator(&rows);
     while (auto entry = it.next()) {
-      auto elementRows =
-          toElementRows(numElements, *entry.rows, rawOffsets, rawSizes);
+      auto elementRows = toElementRows(
+          numElements, *entry.rows, rawNulls, rawOffsets, rawSizes);
+      if (!elementRows.hasSelections()) {
+        // All arrays are NULL or empty.
+        entry.rows->applyToSelected([&](vector_size_t row) { onMiss(row); });
+        continue;
+      }
+
       auto wrapCapture = toWrapCapture<ArrayVector>(
           numElements, entry.callable, *entry.rows, flatArray);
 
-      ErrorVectorPtr elementErrors;
+      exec::EvalErrorsPtr elementErrors;
       entry.callable->applyNoThrow(
           elementRows,
           nullptr, // No need to preserve any values in 'matchBits'.
@@ -105,7 +110,10 @@ class FindFirstFunctionBase : public exec::VectorFunction {
 
       bitsDecoder.get()->decode(*matchBits, elementRows);
       entry.rows->applyToSelected([&](vector_size_t row) {
-        if (auto firstMatchingIndex = findFirstMatch(
+        if (rawNulls != nullptr && bits::isBitNull(rawNulls, row)) {
+          onMiss(row);
+        } else if (
+            auto firstMatchingIndex = findFirstMatch(
                 context,
                 row,
                 rawOffsets[row],
@@ -133,6 +141,7 @@ class FindFirstFunctionBase : public exec::VectorFunction {
     void process(
         const VectorPtr& startIndex,
         const SelectivityVector& rows,
+        const uint64_t* rawNulls,
         const vector_size_t* rawOffsets,
         const vector_size_t* rawSizes,
         exec::EvalCtx& context) {
@@ -147,7 +156,10 @@ class FindFirstFunctionBase : public exec::VectorFunction {
       auto* rawAdjustedSizes = adjustedSizes->asMutable<vector_size_t>();
 
       rows.applyToSelected([&](auto row) {
-        if (startIndexDecoder->isNullAt(row)) {
+        if (rawNulls != nullptr && bits::isBitNull(rawNulls, row)) {
+          rawAdjustedOffsets[row] = 0;
+          rawAdjustedSizes[row] = 0;
+        } else if (startIndexDecoder->isNullAt(row)) {
           rawAdjustedOffsets[row] = 0;
           rawAdjustedSizes[row] = 0;
         } else {
@@ -161,11 +173,7 @@ class FindFirstFunctionBase : public exec::VectorFunction {
             rawAdjustedOffsets[row] = 0;
             rawAdjustedSizes[row] = 0;
 
-            try {
-              VELOX_USER_FAIL("SQL array indices start at 1. Got 0.");
-            } catch (const VeloxUserError& exception) {
-              context.setVeloxExceptionError(row, std::current_exception());
-            }
+            recordInvalidStartIndex(row, context);
           } else if (start > 0) {
             rawAdjustedOffsets[row] = offset + (start - 1);
             rawAdjustedSizes[row] = size - (start - 1);
@@ -182,11 +190,16 @@ class FindFirstFunctionBase : public exec::VectorFunction {
   static SelectivityVector toElementRows(
       vector_size_t numElements,
       const SelectivityVector& arrayRows,
+      const uint64_t* rawNulls,
       const vector_size_t* rawOffsets,
       const vector_size_t* rawSizes) {
     SelectivityVector elementRows(numElements, false);
 
     arrayRows.applyToSelected([&](auto arrayRow) {
+      if (rawNulls != nullptr && bits::isBitNull(rawNulls, arrayRow)) {
+        return;
+      }
+
       const auto offset = rawOffsets[arrayRow];
       const auto size = rawSizes[arrayRow];
 
@@ -201,17 +214,6 @@ class FindFirstFunctionBase : public exec::VectorFunction {
     return elementRows;
   }
 
-  static FOLLY_ALWAYS_INLINE std::optional<std::exception_ptr> getOptionalError(
-      const ErrorVectorPtr& errors,
-      vector_size_t row) {
-    if (errors && row < errors->size() && !errors->isNullAt(row)) {
-      return *std::static_pointer_cast<std::exception_ptr>(
-          errors->valueAt(row));
-    }
-
-    return std::nullopt;
-  }
-
   // Returns an index of the first matching element or std::nullopt if no
   // element matches or there was an error evaluating the predicate.
   //
@@ -222,15 +224,16 @@ class FindFirstFunctionBase : public exec::VectorFunction {
       vector_size_t arrayRow,
       vector_size_t offset,
       vector_size_t size,
-      const ErrorVectorPtr& elementErrors,
+      const exec::EvalErrorsPtr& elementErrors,
       const exec::LocalDecodedVector& matchDecoder) const {
     const auto step = size > 0 ? 1 : -1;
-    for (auto i = offset; i != offset + size; i += step) {
-      auto index = i;
-      if (auto error = getOptionalError(elementErrors, index)) {
-        // Report first error to match Presto's implementation.
-        context.setError(arrayRow, error.value());
-        return std::nullopt;
+    for (auto index = offset; index != offset + size; index += step) {
+      if (elementErrors) {
+        if (auto error = elementErrors->errorAt(index)) {
+          // Report first error to match Presto's implementation.
+          context.setError(arrayRow, *error.value());
+          return std::nullopt;
+        }
       }
 
       if (!matchDecoder->isNullAt(index) &&
@@ -248,13 +251,39 @@ class FindFirstFunction : public FindFirstFunctionBase {
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
-      const TypePtr& /*outputType*/,
+      const TypePtr& outputType,
       exec::EvalCtx& context,
       VectorPtr& result) const override {
     auto flatArray = prepareInputArray(args[0], rows, context);
-    auto* predicateVector = args.back()->asUnchecked<FunctionVector>();
     auto startIndexVector = (args.size() == 3 ? args[1] : nullptr);
 
+    if (flatArray->elements()->size() == 0) {
+      // All arrays are NULL or empty.
+
+      if (startIndexVector != nullptr) {
+        // Check start indices for zeros.
+
+        exec::LocalDecodedVector startIndexDecoder(
+            context, *startIndexVector, rows);
+        rows.applyToSelected([&](auto row) {
+          if (flatArray->isNullAt(row) || startIndexDecoder->isNullAt(row)) {
+            return;
+          }
+          const auto start = startIndexDecoder->valueAt<int64_t>(row);
+          if (start == 0) {
+            recordInvalidStartIndex(row, context);
+          }
+        });
+      }
+
+      auto localResult = BaseVector::createNullConstant(
+          outputType, rows.end(), context.pool());
+      context.moveOrCopyResult(localResult, rows, result);
+      return;
+    }
+
+    auto* predicateVector = args.back()->asUnchecked<FunctionVector>();
+
     // Collect indices of the first matching elements or NULLs if no match or
     // error.
     BufferPtr resultIndices = allocateIndices(rows.end(), context.pool());
@@ -273,7 +302,7 @@ class FindFirstFunction : public FindFirstFunctionBase {
           if (flatArray->elements()->isNullAt(firstMatchingIndex)) {
             try {
               VELOX_USER_FAIL("find_first found NULL as the first match");
-            } catch (const VeloxUserError& exception) {
+            } catch (const VeloxUserError&) {
               context.setVeloxExceptionError(row, std::current_exception());
             }
           } else {
@@ -368,6 +397,12 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> indexSignatures() {
 
 } // namespace
 
+/// find_first function is null preserving for the array argument, but
+/// predicate expression may use other fields and may not preserve nulls in
+/// these.
+/// For example: find_first(array[1, 2, 3], x -> x > coalesce(a, 0)) should
+/// not return null when 'a' is null.
+
 VELOX_DECLARE_VECTOR_FUNCTION(
     udf_find_first,
     valueSignatures(),
diff --git a/velox/functions/prestosql/FromUnixTime.cpp b/velox/functions/prestosql/FromUnixTime.cpp
deleted file mode 100644
index f670c3ad1fd70..0000000000000
--- a/velox/functions/prestosql/FromUnixTime.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/type/tz/TimeZoneMap.h"
-
-namespace facebook::velox::functions {
-namespace {
-
-inline int64_t toMillis(double unixtime) {
-  if (UNLIKELY(std::isnan(unixtime))) {
-    return 0;
-  }
-  return std::floor(unixtime * 1'000);
-}
-
-class FromUnixtimeFunction : public exec::VectorFunction {
- public:
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    exec::DecodedArgs decodedArgs(rows, args, context);
-
-    auto unixtimes = decodedArgs.at(0);
-    auto timezoneNames = decodedArgs.at(1);
-
-    const auto size = rows.end();
-    auto* pool = context.pool();
-
-    auto timestamps = BaseVector::create(BIGINT(), size, pool);
-    auto* rawTimestamps =
-        timestamps->asFlatVector<int64_t>()->mutableRawValues();
-
-    VectorPtr timezones;
-    if (timezoneNames->isConstantMapping()) {
-      auto timezoneName = timezoneNames->valueAt<StringView>(rows.begin());
-
-      int16_t timezoneId = util::getTimeZoneID(
-          std::string_view(timezoneName.data(), timezoneName.size()));
-      timezones = std::make_shared<ConstantVector<int16_t>>(
-          pool, size, false /*isNull*/, SMALLINT(), std::move(timezoneId));
-
-      rows.applyToSelected([&](auto row) {
-        rawTimestamps[row] = toMillis(unixtimes->valueAt<double>(row));
-      });
-    } else {
-      timezones = BaseVector::create(SMALLINT(), size, pool);
-      auto* rawTimezones =
-          timezones->asFlatVector<int16_t>()->mutableRawValues();
-
-      rows.applyToSelected([&](auto row) {
-        rawTimestamps[row] = toMillis(unixtimes->valueAt<double>(row));
-
-        auto timezoneName = timezoneNames->valueAt<StringView>(row);
-        rawTimezones[row] = util::getTimeZoneID(
-            std::string_view(timezoneName.data(), timezoneName.size()));
-      });
-    }
-
-    auto localResult = std::make_shared<RowVector>(
-        pool,
-        outputType,
-        BufferPtr(nullptr),
-        rows.end(),
-        std::vector<VectorPtr>{timestamps, timezones},
-        0 /*nullCount*/);
-
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-
-  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    // double, varchar -> timestamp with time zone
-    return {exec::FunctionSignatureBuilder()
-                .returnType("timestamp with time zone")
-                .argumentType("double")
-                .argumentType("varchar")
-                .build()};
-  }
-};
-} // namespace
-
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_from_unixtime,
-    FromUnixtimeFunction::signatures(),
-    std::make_unique<FromUnixtimeFunction>());
-
-} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/FromUtf8.cpp b/velox/functions/prestosql/FromUtf8.cpp
index 0c9d2afbf7409..c538db0229618 100644
--- a/velox/functions/prestosql/FromUtf8.cpp
+++ b/velox/functions/prestosql/FromUtf8.cpp
@@ -16,8 +16,8 @@
 #include "velox/expression/DecodedArgs.h"
 #include "velox/expression/StringWriter.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/Utf8Utils.h"
 #include "velox/functions/lib/string/StringImpl.h"
-#include "velox/functions/prestosql/Utf8Utils.h"
 
 namespace facebook::velox::functions {
 namespace {
@@ -39,19 +39,47 @@ class FromUtf8Function : public exec::VectorFunction {
 
     exec::DecodedArgs decodedArgs(rows, args, context);
     auto& decodedInput = *decodedArgs.at(0);
-    if (input->loadedVector()
-            ->as<SimpleVector<StringView>>()
-            ->computeAndSetIsAscii(rows)) {
-      // Input strings are all-ASCII.
-      toVarcharNoCopy(input, decodedInput, rows, context, result);
-      return;
+
+    // Read the constant replacement if it exisits and verify that it is valid.
+    bool constantReplacement =
+        args.size() == 1 || decodedArgs.at(1)->isConstantMapping();
+    std::string constantReplacementValue = kReplacementChar;
+
+    if (constantReplacement) {
+      if (args.size() > 1) {
+        auto& decodedReplacement = *decodedArgs.at(1);
+        try {
+          constantReplacementValue = getReplacementCharacter(
+              args[1]->type(), decodedReplacement, rows.begin());
+        } catch (const std::exception&) {
+          context.setErrors(rows, std::current_exception());
+          return;
+        }
+      }
+    }
+
+    // We can only do valid UTF-8 input optimization if replacement is valid and
+    // constant otherwise we have to check replacement for each row.
+    if (constantReplacement) {
+      if (input->loadedVector()
+              ->as<SimpleVector<StringView>>()
+              ->computeAndSetIsAscii(rows)) {
+        // Input strings are all-ASCII.
+        toVarcharNoCopy(input, decodedInput, rows, context, result);
+        return;
+      }
     }
 
     auto firstInvalidRow = findFirstInvalidRow(decodedInput, rows);
-    if (!firstInvalidRow.has_value()) {
-      // All inputs are valid UTF-8 strings.
-      toVarcharNoCopy(input, decodedInput, rows, context, result);
-      return;
+
+    // We can only do this optimization if replacement is valid and
+    // constant otherwise we have to check replacement for each row.
+    if (constantReplacement) {
+      if (!firstInvalidRow.has_value()) {
+        // All inputs are valid UTF-8 strings.
+        toVarcharNoCopy(input, decodedInput, rows, context, result);
+        return;
+      }
     }
 
     BaseVector::ensureWritable(rows, VARCHAR(), context.pool(), result);
@@ -65,23 +93,7 @@ class FromUtf8Function : public exec::VectorFunction {
 
     flatResult->getBufferWithSpace(totalInputSize);
 
-    // Optimize for common case of constant 'replacement' argument.
-    bool constantReplacement =
-        args.size() == 1 || decodedArgs.at(1)->isConstantMapping();
-
     if (constantReplacement) {
-      std::string replacement = kReplacementChar;
-      if (args.size() > 1) {
-        auto& decodedReplacement = *decodedArgs.at(1);
-        try {
-          replacement = getReplacementCharacter(
-              args[1]->type(), decodedReplacement, rows.begin());
-        } catch (const std::exception&) {
-          context.setErrors(rows, std::current_exception());
-          return;
-        }
-      }
-
       rows.applyToSelected([&](auto row) {
         exec::StringWriter<false> writer(flatResult, row);
         auto value = decodedInput.valueAt<StringView>(row);
@@ -89,7 +101,7 @@ class FromUtf8Function : public exec::VectorFunction {
           writer.append(value);
           writer.finalize();
         } else {
-          fixInvalidUtf8(value, replacement, writer);
+          fixInvalidUtf8(value, constantReplacementValue, writer);
         }
       });
     } else {
@@ -160,7 +172,7 @@ class FromUtf8Function : public exec::VectorFunction {
       VELOX_USER_CHECK_EQ(
           charLength,
           replacement.size(),
-          "Replacement string must be empty or a single character")
+          "Replacement string must be empty or a single character");
     }
     return replacement;
   }
diff --git a/velox/functions/prestosql/GreatestLeast.cpp b/velox/functions/prestosql/GreatestLeast.cpp
deleted file mode 100644
index a89cdd26c6a0a..0000000000000
--- a/velox/functions/prestosql/GreatestLeast.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <cmath>
-#include <type_traits>
-#include "velox/common/base/Exceptions.h"
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::functions {
-
-namespace {
-
-template <bool>
-class ExtremeValueFunction;
-
-using LeastFunction = ExtremeValueFunction<true>;
-using GreatestFunction = ExtremeValueFunction<false>;
-
-/**
- * This class implements two functions:
- *
- * greatest(value1, value2, ..., valueN) → [same as input]
- * Returns the largest of the provided values.
- *
- * least(value1, value2, ..., valueN) → [same as input]
- * Returns the smallest of the provided values.
- **/
-template <bool isLeast>
-class ExtremeValueFunction : public exec::VectorFunction {
- private:
-  template <typename T>
-  bool shouldOverride(const T& currentValue, const T& candidateValue) const {
-    return isLeast ? candidateValue < currentValue
-                   : candidateValue > currentValue;
-  }
-
-  // For double, presto should throw error if input is Nan
-  template <typename T>
-  void checkNan(const T& value) const {
-    if constexpr (std::is_same_v<T, TypeTraits<TypeKind::DOUBLE>::NativeType>) {
-      if (std::isnan(value)) {
-        VELOX_USER_FAIL(
-            "Invalid argument to {}: NaN", isLeast ? "least()" : "greatest()");
-      }
-    }
-  }
-
-  template <typename T>
-  void applyTyped(
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const {
-    context.ensureWritable(rows, outputType, result);
-    result->clearNulls(rows);
-    BufferPtr resultValues =
-        result->as<FlatVector<T>>()->mutableValues(rows.end());
-    T* __restrict rawResult = resultValues->asMutable<T>();
-
-    exec::DecodedArgs decodedArgs(rows, args, context);
-
-    std::set<size_t> usedInputs;
-    context.applyToSelectedNoThrow(rows, [&](int row) {
-      size_t valueIndex = 0;
-
-      T currentValue = decodedArgs.at(0)->valueAt<T>(row);
-      checkNan(currentValue);
-
-      for (auto i = 1; i < args.size(); ++i) {
-        auto candidateValue = decodedArgs.at(i)->template valueAt<T>(row);
-        checkNan(candidateValue);
-
-        if (shouldOverride(currentValue, candidateValue)) {
-          currentValue = candidateValue;
-          valueIndex = i;
-        }
-      }
-      usedInputs.insert(valueIndex);
-      rawResult[row] = currentValue;
-    });
-
-    if constexpr (std::
-                      is_same_v<T, TypeTraits<TypeKind::VARCHAR>::NativeType>) {
-      auto* flatResult = result->as<FlatVector<T>>();
-      for (auto index : usedInputs) {
-        flatResult->acquireSharedStringBuffers(args[index].get());
-      }
-    }
-  }
-
- public:
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    switch (outputType.get()->kind()) {
-      case TypeKind::TINYINT:
-        applyTyped<TypeTraits<TypeKind::TINYINT>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      case TypeKind::SMALLINT:
-        applyTyped<TypeTraits<TypeKind::SMALLINT>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      case TypeKind::INTEGER:
-        applyTyped<TypeTraits<TypeKind::INTEGER>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      case TypeKind::BIGINT:
-        applyTyped<TypeTraits<TypeKind::BIGINT>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      case TypeKind::HUGEINT:
-        applyTyped<TypeTraits<TypeKind::HUGEINT>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      case TypeKind::REAL:
-        applyTyped<TypeTraits<TypeKind::REAL>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      case TypeKind::DOUBLE:
-        applyTyped<TypeTraits<TypeKind::DOUBLE>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      case TypeKind::VARCHAR:
-        applyTyped<TypeTraits<TypeKind::VARCHAR>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      case TypeKind::TIMESTAMP:
-        applyTyped<TypeTraits<TypeKind::TIMESTAMP>::NativeType>(
-            rows, args, outputType, context, result);
-        return;
-      default:
-        VELOX_FAIL(
-            "Unsupported input type for {}: {}",
-            isLeast ? "least()" : "greatest()",
-            outputType->toString());
-    }
-  }
-
-  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    std::vector<std::string> types = {
-        "tinyint",
-        "smallint",
-        "integer",
-        "bigint",
-        "double",
-        "real",
-        "varchar",
-        "timestamp",
-        "date"};
-    std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
-    for (const auto& type : types) {
-      signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                  .returnType(type)
-                                  .argumentType(type)
-                                  .variableArity()
-                                  .build());
-    }
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .integerVariable("precision")
-                                .integerVariable("scale")
-                                .returnType("DECIMAL(precision, scale)")
-                                .argumentType("DECIMAL(precision, scale)")
-                                .variableArity()
-                                .build());
-    return signatures;
-  }
-};
-} // namespace
-
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_least,
-    LeastFunction::signatures(),
-    std::make_unique<LeastFunction>());
-
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_greatest,
-    GreatestFunction::signatures(),
-    std::make_unique<GreatestFunction>());
-
-} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/GreatestLeast.h b/velox/functions/prestosql/GreatestLeast.h
new file mode 100644
index 0000000000000..d5dc0bb15f17c
--- /dev/null
+++ b/velox/functions/prestosql/GreatestLeast.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cmath>
+#include "velox/functions/Macros.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+
+namespace facebook::velox::functions {
+namespace details {
+/**
+ * This class implements two functions:
+ *
+ * greatest(value1, value2, ..., valueN) → [same as input]
+ * Returns the largest of the provided values.
+ *
+ * least(value1, value2, ..., valueN) → [same as input]
+ * Returns the smallest of the provided values.
+ *
+ * For DOUBLE and REAL type, NaN is considered as the biggest according to
+ * https://github.com/prestodb/presto/issues/22391
+ **/
+template <typename TExec, typename T, bool isLeast>
+struct ExtremeValueFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<T>& result,
+      const arg_type<T>& firstElement,
+      const arg_type<Variadic<T>>& remainingElement) {
+    auto currentValue = firstElement;
+
+    for (auto element : remainingElement) {
+      auto candidateValue = element.value();
+
+      if constexpr (isLeast) {
+        if (smallerThan(candidateValue, currentValue)) {
+          currentValue = candidateValue;
+        }
+      } else {
+        if (greaterThan(candidateValue, currentValue)) {
+          currentValue = candidateValue;
+        }
+      }
+    }
+
+    result = currentValue;
+  }
+
+ private:
+  template <typename K>
+  bool greaterThan(const K& lhs, const K& rhs) const {
+    if constexpr (std::is_same_v<K, double> || std::is_same_v<K, float>) {
+      if (std::isnan(lhs)) {
+        return true;
+      }
+
+      if (std::isnan(rhs)) {
+        return false;
+      }
+    }
+
+    return lhs > rhs;
+  }
+
+  template <typename K>
+  bool smallerThan(const K& lhs, const K& rhs) const {
+    if constexpr (std::is_same_v<K, double> || std::is_same_v<K, float>) {
+      if (std::isnan(lhs)) {
+        return false;
+      }
+
+      if (std::isnan(rhs)) {
+        return true;
+      }
+    }
+
+    return lhs < rhs;
+  }
+};
+
+template <typename TExec, bool isLeast>
+struct ExtremeValueFunctionTimestampWithTimezone {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimestampWithTimezone>& result,
+      const arg_type<TimestampWithTimezone>& firstElement,
+      const arg_type<Variadic<TimestampWithTimezone>>& remainingElement) {
+    auto currentValue = firstElement;
+
+    for (auto element : remainingElement) {
+      auto candidateValue = element.value();
+
+      if constexpr (isLeast) {
+        if (unpackMillisUtc(candidateValue) < unpackMillisUtc(currentValue)) {
+          currentValue = candidateValue;
+        }
+      } else {
+        if (unpackMillisUtc(candidateValue) > unpackMillisUtc(currentValue)) {
+          currentValue = candidateValue;
+        }
+      }
+    }
+
+    result = currentValue;
+  }
+};
+} // namespace details
+
+template <typename TExec, typename T>
+using LeastFunction = details::ExtremeValueFunction<TExec, T, true>;
+
+template <typename TExec>
+using LeastFunctionTimestampWithTimezone =
+    details::ExtremeValueFunctionTimestampWithTimezone<TExec, true>;
+
+template <typename TExec, typename T>
+using GreatestFunction = details::ExtremeValueFunction<TExec, T, false>;
+
+template <typename TExec>
+using GreatestFunctionTimestampWithTimezone =
+    details::ExtremeValueFunctionTimestampWithTimezone<TExec, false>;
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/HyperLogLogFunctions.h b/velox/functions/prestosql/HyperLogLogFunctions.h
index 89fa3f2c21964..8dc85d1ef58fe 100644
--- a/velox/functions/prestosql/HyperLogLogFunctions.h
+++ b/velox/functions/prestosql/HyperLogLogFunctions.h
@@ -48,7 +48,7 @@ struct EmptyApproxSetFunction {
 
   FOLLY_ALWAYS_INLINE bool call(out_type<HyperLogLog>& result) {
     static const std::string kEmpty =
-        common::hll::SparseHll::serializeEmpty(11);
+        common::hll::SparseHll::serializeEmpty(12);
 
     result.resize(kEmpty.size());
     memcpy(result.data(), kEmpty.data(), kEmpty.size());
@@ -62,6 +62,7 @@ struct EmptyApproxSetWithMaxErrorFunction {
   std::string serialized_;
 
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const double* maxStandardError) {
     VELOX_USER_CHECK_NOT_NULL(
diff --git a/velox/functions/prestosql/IPAddressFunctions.h b/velox/functions/prestosql/IPAddressFunctions.h
new file mode 100644
index 0000000000000..abd214a9aba47
--- /dev/null
+++ b/velox/functions/prestosql/IPAddressFunctions.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/prestosql/types/IPAddressType.h"
+
+namespace facebook::velox::functions {
+
+void registerIPAddressFunctions(const std::string& prefix) {
+  registerIPAddressType();
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/InPredicate.cpp b/velox/functions/prestosql/InPredicate.cpp
index 9c7236560230b..86d7fdeacb208 100644
--- a/velox/functions/prestosql/InPredicate.cpp
+++ b/velox/functions/prestosql/InPredicate.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/type/Filter.h"
 
@@ -20,9 +21,11 @@ namespace facebook::velox::functions {
 namespace {
 
 // Returns NULL if
-// - input value is NULL or contains NULL;
-// - input value doesn't match any of the in-list values, but some of in-list
-// values are NULL or contain NULL.
+// - input value is NULL
+// - in-list is NULL or empty
+// - input value doesn't have an exact match, but has an indeterminate match in
+// the in-list. E.g., 'array[null] in (array[1])' or 'array[1] in
+// (array[null])'.
 class ComplexTypeInPredicate : public exec::VectorFunction {
  public:
   struct ComplexValue {
@@ -61,9 +64,8 @@ class ComplexTypeInPredicate : public exec::VectorFunction {
     for (auto i = offset; i < offset + size; i++) {
       if (values->containsNullAt(i)) {
         hasNull = true;
-      } else {
-        uniqueValues.insert({values.get(), i});
       }
+      uniqueValues.insert({values.get(), i});
     }
 
     return std::make_shared<ComplexTypeInPredicate>(
@@ -83,20 +85,45 @@ class ComplexTypeInPredicate : public exec::VectorFunction {
     auto* boolResult = result->asUnchecked<FlatVector<bool>>();
 
     rows.applyToSelected([&](vector_size_t row) {
-      if (arg->containsNullAt(row)) {
+      if (arg->isNullAt(row)) {
         boolResult->setNull(row, true);
       } else {
         const bool found = uniqueValues_.contains({arg.get(), row});
-        if (!found && hasNull_) {
-          boolResult->setNull(row, true);
+        if (found) {
+          if (arg->containsNullAt(row)) {
+            boolResult->setNull(row, true);
+          } else {
+            boolResult->set(row, true);
+          }
         } else {
-          boolResult->set(row, found);
+          if ((arg->containsNullAt(row) || hasNull_) &&
+              hasIndeterminateMatch(arg, row)) {
+            boolResult->setNull(row, true);
+          } else {
+            boolResult->set(row, false);
+          }
         }
       }
     });
   }
 
  private:
+  bool hasIndeterminateMatch(const VectorPtr& vector, vector_size_t index)
+      const {
+    for (const auto& value : uniqueValues_) {
+      if (!vector
+               ->equalValueAt(
+                   value.vector,
+                   index,
+                   value.index,
+                   CompareFlags::NullHandlingMode::kNullAsIndeterminate)
+               .has_value()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   // Set of unique values to check against. This set doesn't include any value
   // that is null or contains null.
   const ComplexSet uniqueValues_;
@@ -190,16 +217,15 @@ createFloatingPointValuesFilter(
   VELOX_USER_CHECK(
       !values.empty(),
       "IN predicate expects at least one non-null value in the in-list");
-
-  if (values.size() == 1) {
-    return {
-        std::make_unique<common::FloatingPointRange<T>>(
-            values[0], false, false, values[0], false, false, nullAllowed),
-        false};
-  }
-
+  // Avoid using FloatingPointRange for optimization of a single value in-list
+  // as it does not support NaN as a bound for specifying a range.
   std::vector<int64_t> intValues(values.size());
   for (size_t i = 0; i < values.size(); ++i) {
+    if (std::isnan(values[i])) {
+      // We de-normalize NaN values to ensure different binary representations
+      // are treated the same.
+      values[i] = std::numeric_limits<T>::quiet_NaN();
+    }
     if constexpr (std::is_same_v<T, float>) {
       if (values[i] == float{}) {
         values[i] = 0;
@@ -270,6 +296,8 @@ std::pair<std::unique_ptr<common::Filter>, bool> createBytesValuesFilter(
   return {std::make_unique<common::BytesValues>(values, nullAllowed), false};
 }
 
+/// x IN (2, null) returns null when x != 2 and true when x == 2.
+/// Null for x always produces null, regardless of 'IN' list.
 class InPredicate : public exec::VectorFunction {
  public:
   explicit InPredicate(std::unique_ptr<common::Filter> filter, bool alwaysNull)
@@ -281,6 +309,7 @@ class InPredicate : public exec::VectorFunction {
       const core::QueryConfig& /*config*/) {
     VELOX_CHECK_EQ(inputArgs.size(), 2);
     auto inListType = inputArgs[1].type;
+
     VELOX_CHECK_EQ(inListType->kind(), TypeKind::ARRAY);
 
     const auto& values = inputArgs[1].constantValue;
@@ -365,12 +394,6 @@ class InPredicate : public exec::VectorFunction {
         std::move(filter.first), filter.second);
   }
 
-  // x IN (2, null) returns null when x != 2 and true when x == 2.
-  // Null for x always produces null, regardless of 'IN' list.
-  bool isDefaultNullBehavior() const override {
-    return true;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -412,26 +435,26 @@ class InPredicate : public exec::VectorFunction {
         break;
       case TypeKind::REAL:
         applyTyped<float>(rows, input, context, result, [&](float value) {
-          auto* derived =
-              dynamic_cast<common::FloatingPointRange<float>*>(filter_.get());
-          if (derived) {
-            return filter_->testFloat(value);
-          }
           if (value == float{}) {
             value = 0;
+          } else if (std::isnan(value)) {
+            // We de-normalize NaN values to ensure different binary
+            // representations
+            // are treated the same.
+            value = std::numeric_limits<float>::quiet_NaN();
           }
           return filter_->testInt64(reinterpret_cast<const int32_t&>(value));
         });
         break;
       case TypeKind::DOUBLE:
         applyTyped<double>(rows, input, context, result, [&](double value) {
-          auto* derived =
-              dynamic_cast<common::FloatingPointRange<double>*>(filter_.get());
-          if (derived) {
-            return filter_->testDouble(value);
-          }
           if (value == double{}) {
             value = 0;
+          } else if (std::isnan(value)) {
+            // We de-normalize NaN values to ensure different binary
+            // representations
+            // are treated the same.
+            value = std::numeric_limits<double>::quiet_NaN();
           }
           return filter_->testInt64(reinterpret_cast<const int64_t&>(value));
         });
@@ -463,6 +486,7 @@ class InPredicate : public exec::VectorFunction {
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     return {
+        // (T, array(T)) -> boolean for constant IN lists.
         exec::FunctionSignatureBuilder()
             .typeVariable("T")
             .returnType("boolean")
@@ -561,4 +585,5 @@ VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
     udf_in,
     InPredicate::signatures(),
     InPredicate::create);
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/InPredicate.h b/velox/functions/prestosql/InPredicate.h
new file mode 100644
index 0000000000000..9a373628872d4
--- /dev/null
+++ b/velox/functions/prestosql/InPredicate.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/common/base/CompareFlags.h"
+#include "velox/functions/Macros.h"
+
+namespace facebook::velox::functions {
+
+// Returns NULL if
+// - input value is NULL
+// - in-list is NULL or empty
+// - input value doesn't have an exact match, but has an indeterminate match in
+// the in-list. E.g., 'array[null] in (array[1])', 'array[1] in (array[null])',
+// or '1 in (null)'.
+template <typename TExec>
+struct GenericInPredicateFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE bool callNullable(
+      bool& result,
+      const arg_type<Generic<T1>>* value,
+      const arg_type<Variadic<Generic<T1>>>* inList) {
+    if (value == nullptr || inList == nullptr) {
+      return false; // NULL result.
+    }
+
+    if (inList->size() == 0) {
+      return false;
+    }
+
+    const static auto compareFlag = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+    bool hasNull = false;
+    for (const auto& v : *inList) {
+      if (v.has_value()) {
+        auto compareResult = value->compare(v.value(), compareFlag);
+        if UNLIKELY (!compareResult.has_value()) {
+          hasNull = true;
+          continue;
+        }
+        if (compareResult.value() == 0) {
+          result = true;
+          return true; // Non-NULL result.
+        }
+      } else {
+        hasNull = true;
+      }
+    }
+    if (hasNull) {
+      return false;
+    } else {
+      result = false;
+      return true;
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/JsonFunctions.cpp b/velox/functions/prestosql/JsonFunctions.cpp
index 6250608868042..8628a669d8285 100644
--- a/velox/functions/prestosql/JsonFunctions.cpp
+++ b/velox/functions/prestosql/JsonFunctions.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/expression/VectorFunction.h"
+#include "velox/functions/prestosql/json/SIMDJsonUtil.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 
 namespace facebook::velox::functions {
@@ -70,19 +71,21 @@ class JsonParseFunction : public exec::VectorFunction {
       const TypePtr& /* outputType */,
       exec::EvalCtx& context,
       VectorPtr& result) const override {
+    // Initialize errors here so that we get the proper exception context.
+    folly::call_once(
+        initializeErrors_, [this] { simdjsonErrorsToExceptions(errors_); });
+
     VectorPtr localResult;
 
     // Input can be constant or flat.
-    // TODO(arpitporwal2293) Replace folly::parseJson with a lightweight
-    // validation of JSON syntax that doesn't allocate memory or copy data.
     assert(args.size() > 0);
     const auto& arg = args[0];
     if (arg->isConstantEncoding()) {
       auto value = arg->as<ConstantVector<StringView>>()->valueAt(0);
-      try {
-        folly::parseJson(value);
-      } catch (const std::exception& e) {
-        context.setErrors(rows, std::current_exception());
+      paddedInput_.resize(value.size() + simdjson::SIMDJSON_PADDING);
+      memcpy(paddedInput_.data(), value.data(), value.size());
+      if (auto error = parse(value.size())) {
+        context.setErrors(rows, errors_[error]);
         return;
       }
       localResult = std::make_shared<ConstantVector<StringView>>(
@@ -93,8 +96,19 @@ class JsonParseFunction : public exec::VectorFunction {
       auto stringBuffers = flatInput->stringBuffers();
       VELOX_CHECK_LE(rows.end(), flatInput->size());
 
-      context.applyToSelectedNoThrow(
-          rows, [&](auto row) { folly::parseJson(flatInput->valueAt(row)); });
+      size_t maxSize = 0;
+      rows.applyToSelected([&](auto row) {
+        auto value = flatInput->valueAt(row);
+        maxSize = std::max(maxSize, value.size());
+      });
+      paddedInput_.resize(maxSize + simdjson::SIMDJSON_PADDING);
+      rows.applyToSelected([&](auto row) {
+        auto value = flatInput->valueAt(row);
+        memcpy(paddedInput_.data(), value.data(), value.size());
+        if (auto error = parse(value.size())) {
+          context.setVeloxExceptionError(row, errors_[error]);
+        }
+      });
       localResult = std::make_shared<FlatVector<StringView>>(
           context.pool(),
           JSON(),
@@ -114,6 +128,57 @@ class JsonParseFunction : public exec::VectorFunction {
                 .argumentType("varchar")
                 .build()};
   }
+
+ private:
+  simdjson::error_code parse(size_t size) const {
+    simdjson::padded_string_view paddedInput(
+        paddedInput_.data(), size, paddedInput_.size());
+    SIMDJSON_ASSIGN_OR_RAISE(auto doc, simdjsonParse(paddedInput));
+    SIMDJSON_TRY(validate<simdjson::ondemand::document&>(doc));
+    if (!doc.at_end()) {
+      return simdjson::TRAILING_CONTENT;
+    }
+    return simdjson::SUCCESS;
+  }
+
+  template <typename T>
+  static simdjson::error_code validate(T value) {
+    SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
+    switch (type) {
+      case simdjson::ondemand::json_type::array: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto array, value.get_array());
+        for (auto elementOrError : array) {
+          SIMDJSON_ASSIGN_OR_RAISE(auto element, elementOrError);
+          SIMDJSON_TRY(validate(element));
+        }
+        return simdjson::SUCCESS;
+      }
+      case simdjson::ondemand::json_type::object: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto object, value.get_object());
+        for (auto fieldOrError : object) {
+          SIMDJSON_ASSIGN_OR_RAISE(auto field, fieldOrError);
+          SIMDJSON_TRY(validate(field.value()));
+        }
+        return simdjson::SUCCESS;
+      }
+      case simdjson::ondemand::json_type::number:
+        return value.get_double().error();
+      case simdjson::ondemand::json_type::string:
+        return value.get_string().error();
+      case simdjson::ondemand::json_type::boolean:
+        return value.get_bool().error();
+      case simdjson::ondemand::json_type::null: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto isNull, value.is_null());
+        return isNull ? simdjson::SUCCESS : simdjson::N_ATOM_ERROR;
+      }
+    }
+    VELOX_UNREACHABLE();
+  }
+
+  mutable folly::once_flag initializeErrors_;
+  mutable std::exception_ptr errors_[simdjson::NUM_ERROR_CODES];
+  // Padding is needed in case string view is inlined.
+  mutable std::string paddedInput_;
 };
 
 } // namespace
@@ -123,8 +188,13 @@ VELOX_DECLARE_VECTOR_FUNCTION(
     JsonFormatFunction::signatures(),
     std::make_unique<JsonFormatFunction>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
     udf_json_parse,
     JsonParseFunction::signatures(),
-    std::make_unique<JsonParseFunction>());
+    [](const std::string& /*name*/,
+       const std::vector<exec::VectorFunctionArg>&,
+       const velox::core::QueryConfig&) {
+      return std::make_shared<JsonParseFunction>();
+    });
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/JsonFunctions.h b/velox/functions/prestosql/JsonFunctions.h
index 7c6f1421477c5..1596a95a0c94b 100644
--- a/velox/functions/prestosql/JsonFunctions.h
+++ b/velox/functions/prestosql/JsonFunctions.h
@@ -13,9 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#pragma once
+
 #include "velox/functions/Macros.h"
 #include "velox/functions/UDFOutputString.h"
-#include "velox/functions/prestosql/json/JsonExtractor.h"
+#include "velox/functions/prestosql/json/JsonPathTokenizer.h"
+#include "velox/functions/prestosql/json/SIMDJsonExtractor.h"
+#include "velox/functions/prestosql/json/SIMDJsonWrapper.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 
 namespace facebook::velox::functions {
@@ -24,116 +29,319 @@ template <typename T>
 struct IsJsonScalarFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  FOLLY_ALWAYS_INLINE void call(bool& result, const arg_type<Json>& json) {
-    auto parsedJson = folly::parseJson(json);
-    result = parsedJson.isNumber() || parsedJson.isString() ||
-        parsedJson.isBool() || parsedJson.isNull();
+  FOLLY_ALWAYS_INLINE Status call(bool& result, const arg_type<Json>& json) {
+    simdjson::ondemand::document jsonDoc;
+
+    simdjson::padded_string paddedJson(json.data(), json.size());
+    if (auto errorCode = simdjsonParse(paddedJson).get(jsonDoc)) {
+      if (threadSkipErrorDetails()) {
+        return Status::UserError();
+      }
+      return Status::UserError(
+          "Failed to parse JSON: {}", simdjson::error_message(errorCode));
+    }
+
+    result =
+        (jsonDoc.type() == simdjson::ondemand::json_type::number ||
+         jsonDoc.type() == simdjson::ondemand::json_type::string ||
+         jsonDoc.type() == simdjson::ondemand::json_type::boolean ||
+         jsonDoc.type() == simdjson::ondemand::json_type::null);
+
+    return Status::OK();
   }
 };
 
-// jsonExtractScalar(json, json_path) -> varchar
-// Current implementation support UTF-8 in json, but not in json_path.
-// Like jsonExtract(), but returns the result value as a string (as opposed
-// to being encoded as JSON). The value referenced by json_path must be a scalar
-// (boolean, number or string)
-template <typename T>
-struct JsonExtractScalarFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
+template <typename TExec>
+struct JsonArrayContainsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
-  FOLLY_ALWAYS_INLINE bool call(
-      out_type<Varchar>& result,
-      const arg_type<Json>& json,
-      const arg_type<Varchar>& jsonPath) {
-    const folly::StringPiece& jsonStringPiece = json;
-    const folly::StringPiece& jsonPathStringPiece = jsonPath;
-    auto extractResult =
-        jsonExtractScalar(jsonStringPiece, jsonPathStringPiece);
-    if (extractResult.hasValue()) {
-      UDFOutputString::assign(result, *extractResult);
-      return true;
+  template <typename T>
+  FOLLY_ALWAYS_INLINE bool
+  call(bool& result, const arg_type<Json>& json, const T& value) {
+    if constexpr (std::is_same_v<T, double>) {
+      if (!std::isfinite(value)) {
+        result = false;
+        return true;
+      }
+    }
 
-    } else {
+    simdjson::ondemand::document jsonDoc;
+
+    simdjson::padded_string paddedJson(json.data(), json.size());
+    if (simdjsonParse(paddedJson).get(jsonDoc)) {
+      return false;
+    }
+    if (jsonDoc.type().error()) {
       return false;
     }
+
+    if (jsonDoc.type() != simdjson::ondemand::json_type::array) {
+      return false;
+    }
+
+    result = false;
+    for (auto&& v : jsonDoc) {
+      if (v.error()) {
+        return false;
+      }
+      if constexpr (std::is_same_v<T, bool>) {
+        bool boolValue;
+        if (v.type() == simdjson::ondemand::json_type::boolean &&
+            !v.get_bool().get(boolValue) && boolValue == value) {
+          result = true;
+          break;
+        }
+      } else if constexpr (std::is_same_v<T, int64_t>) {
+        int64_t intValue;
+        if (v.type() == simdjson::ondemand::json_type::number &&
+            v.get_number_type() ==
+                simdjson::ondemand::number_type::signed_integer &&
+            !v.get_int64().get(intValue) && intValue == value) {
+          result = true;
+          break;
+        }
+      } else if constexpr (std::is_same_v<T, double>) {
+        double doubleValue;
+        if (v.type() == simdjson::ondemand::json_type::number &&
+            v.get_number_type() ==
+                simdjson::ondemand::number_type::floating_point_number &&
+            !v.get_double().get(doubleValue) && doubleValue == value) {
+          result = true;
+          break;
+        }
+      } else {
+        std::string_view stringValue;
+        if (v.type() == simdjson::ondemand::json_type::string &&
+            !v.get_string().get(stringValue) &&
+            ((std::string_view)value).compare(stringValue) == 0) {
+          result = true;
+          break;
+        }
+      }
+    }
+
+    return true;
   }
 };
 
 template <typename T>
-struct JsonExtractFunction {
+struct JsonArrayLengthFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  FOLLY_ALWAYS_INLINE bool call(
-      out_type<Json>& result,
-      const arg_type<Json>& json,
-      const arg_type<Varchar>& jsonPath) {
-    auto extractResult =
-        jsonExtract(folly::StringPiece(json), folly::StringPiece(jsonPath));
-    if (!extractResult.hasValue() || extractResult.value().isNull()) {
+  FOLLY_ALWAYS_INLINE bool call(int64_t& len, const arg_type<Json>& json) {
+    simdjson::ondemand::document jsonDoc;
+
+    simdjson::padded_string paddedJson(json.data(), json.size());
+    if (simdjsonParse(paddedJson).get(jsonDoc)) {
+      return false;
+    }
+    if (jsonDoc.type().error()) {
       return false;
     }
 
-    folly::json::serialization_opts opts;
-    opts.sort_keys = true;
-    folly::json::serialize(*extractResult, opts);
+    if (jsonDoc.type() != simdjson::ondemand::json_type::array) {
+      return false;
+    }
 
-    UDFOutputString::assign(
-        result, folly::json::serialize(*extractResult, opts));
+    size_t numElements;
+    if (jsonDoc.count_elements().get(numElements)) {
+      return false;
+    }
+
+    len = numElements;
     return true;
   }
 };
 
-template <typename T>
-struct JsonArrayLengthFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
+template <typename TExec>
+struct JsonArrayGetFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE bool
+  call(out_type<Json>& result, const arg_type<Json>& jsonArray, int64_t index) {
+    simdjson::ondemand::document jsonDoc;
 
-  FOLLY_ALWAYS_INLINE bool call(int64_t& result, const arg_type<Json>& json) {
-    auto parsedJson = folly::parseJson(json);
-    if (!parsedJson.isArray()) {
+    simdjson::padded_string paddedJson(jsonArray.data(), jsonArray.size());
+    if (simdjsonParse(paddedJson).get(jsonDoc)) {
+      return false;
+    }
+    if (jsonDoc.type().error()) {
       return false;
     }
 
-    result = parsedJson.size();
+    if (jsonDoc.type() != simdjson::ondemand::json_type::array) {
+      return false;
+    }
+
+    size_t numElements;
+    if (jsonDoc.count_elements().get(numElements)) {
+      return false;
+    }
+
+    if (index >= 0) {
+      if (index >= numElements) {
+        return false;
+      }
+    } else if ((int64_t)numElements + index < 0) {
+      return false;
+    } else {
+      index += numElements;
+    }
+
+    std::string_view resultStr;
+    if (simdjson::to_json_string(jsonDoc.at(index)).get(resultStr)) {
+      return false;
+    }
+
+    result.copy_from(resultStr);
     return true;
   }
 };
 
+// jsonExtractScalar(json, json_path) -> varchar
+// Like jsonExtract(), but returns the result value as a string (as opposed
+// to being encoded as JSON). The value referenced by json_path must be a scalar
+// (boolean, number or string)
 template <typename T>
-struct JsonArrayContainsFunction {
+struct JsonExtractScalarFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE bool
-  call(bool& result, const arg_type<Json>& json, const TInput& value) {
-    auto parsedJson = folly::parseJson(json);
-    if (!parsedJson.isArray()) {
-      return false;
-    }
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Json>& json,
+      const arg_type<Varchar>& jsonPath) {
+    return callImpl(result, json, jsonPath) == simdjson::SUCCESS;
+  }
 
-    result = false;
-    for (const auto& v : parsedJson) {
-      if constexpr (std::is_same_v<TInput, bool>) {
-        if (v.isBool() && v == value) {
-          result = true;
+ private:
+  FOLLY_ALWAYS_INLINE bool callImpl(
+      out_type<Varchar>& result,
+      const arg_type<Json>& json,
+      const arg_type<Varchar>& jsonPath) {
+    bool resultPopulated = false;
+    std::optional<std::string> resultStr;
+    auto consumer = [&resultStr, &resultPopulated](auto& v) {
+      if (resultPopulated) {
+        // We should just get a single value, if we see multiple, it's an error
+        // and we should return null.
+        resultStr = std::nullopt;
+        return simdjson::SUCCESS;
+      }
+
+      resultPopulated = true;
+
+      SIMDJSON_ASSIGN_OR_RAISE(auto vtype, v.type());
+      switch (vtype) {
+        case simdjson::ondemand::json_type::boolean: {
+          SIMDJSON_ASSIGN_OR_RAISE(bool vbool, v.get_bool());
+          resultStr = vbool ? "true" : "false";
           break;
         }
-      } else if constexpr (std::is_same_v<TInput, int64_t>) {
-        if (v.isInt() && v == value) {
-          result = true;
+        case simdjson::ondemand::json_type::string: {
+          SIMDJSON_ASSIGN_OR_RAISE(resultStr, v.get_string());
           break;
         }
-      } else if constexpr (std::is_same_v<TInput, double>) {
-        if (v.isDouble() && v == value) {
-          result = true;
+        case simdjson::ondemand::json_type::object:
+        case simdjson::ondemand::json_type::array:
+        case simdjson::ondemand::json_type::null:
+          // Do nothing.
           break;
+        default: {
+          SIMDJSON_ASSIGN_OR_RAISE(resultStr, simdjson::to_json_string(v));
         }
-      } else {
-        if (v.isString() && v == value) {
-          result = true;
+      }
+      return simdjson::SUCCESS;
+    };
+
+    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    SIMDJSON_TRY(simdJsonExtract(json, extractor, consumer));
+
+    if (resultStr.has_value()) {
+      result.copy_from(*resultStr);
+      return simdjson::SUCCESS;
+    } else {
+      return simdjson::NO_SUCH_FIELD;
+    }
+  }
+};
+
+template <typename T>
+struct JsonExtractFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  bool call(
+      out_type<Json>& result,
+      const arg_type<Json>& json,
+      const arg_type<Varchar>& jsonPath) {
+    return callImpl(result, json, jsonPath) == simdjson::SUCCESS;
+  }
+
+ private:
+  simdjson::error_code callImpl(
+      out_type<Json>& result,
+      const arg_type<Json>& json,
+      const arg_type<Varchar>& jsonPath) {
+    static constexpr std::string_view kNullString{"null"};
+    std::string results;
+    size_t resultSize = 0;
+    auto consumer = [&results, &resultSize](auto& v) {
+      // Add the separator for the JSON array.
+      if (resultSize++ > 0) {
+        results += ",";
+      }
+      // We could just convert v to a string using to_json_string directly, but
+      // in that case the JSON wouldn't be parsed (it would just return the
+      // contents directly) and we might miss invalid JSON.
+      SIMDJSON_ASSIGN_OR_RAISE(auto vtype, v.type());
+      switch (vtype) {
+        case simdjson::ondemand::json_type::object: {
+          SIMDJSON_ASSIGN_OR_RAISE(
+              auto jsonStr, simdjson::to_json_string(v.get_object()));
+          results += jsonStr;
+          break;
+        }
+        case simdjson::ondemand::json_type::array: {
+          SIMDJSON_ASSIGN_OR_RAISE(
+              auto jsonStr, simdjson::to_json_string(v.get_array()));
+          results += jsonStr;
           break;
         }
+        case simdjson::ondemand::json_type::string:
+        case simdjson::ondemand::json_type::number:
+        case simdjson::ondemand::json_type::boolean: {
+          SIMDJSON_ASSIGN_OR_RAISE(auto jsonStr, simdjson::to_json_string(v));
+          results += jsonStr;
+          break;
+        }
+        case simdjson::ondemand::json_type::null:
+          results += kNullString;
+          break;
       }
+      return simdjson::SUCCESS;
+    };
+
+    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    SIMDJSON_TRY(simdJsonExtract(json, extractor, consumer));
+
+    if (resultSize == 0) {
+      if (extractor.isDefinitePath()) {
+        // If the path didn't map to anything in the JSON object, return null.
+        return simdjson::NO_SUCH_FIELD;
+      }
+
+      result.copy_from("[]");
+    } else if (resultSize == 1 && extractor.isDefinitePath()) {
+      // If there was only one value mapped to by the path, don't wrap it in an
+      // array.
+      result.copy_from(results);
+    } else {
+      // Add the square brackets to make it a valid JSON array.
+      result.reserve(2 + results.size());
+      result.append("[");
+      result.append(results);
+      result.append("]");
     }
-    return true;
+    return simdjson::SUCCESS;
   }
 };
 
@@ -145,21 +353,55 @@ struct JsonSizeFunction {
       int64_t& result,
       const arg_type<Json>& json,
       const arg_type<Varchar>& jsonPath) {
-    const folly::StringPiece& jsonStringPiece = json;
-    const folly::StringPiece& jsonPathStringPiece = jsonPath;
-    auto extractResult = jsonExtract(jsonStringPiece, jsonPathStringPiece);
-    if (!extractResult.has_value()) {
-      return false;
-    }
-    // The size of the object or array is the number of members, otherwise the
-    // size is zero
-    if (extractResult->isArray() || extractResult->isObject()) {
-      result = extractResult->size();
-    } else {
-      result = 0;
+    return callImpl(result, json, jsonPath) == simdjson::SUCCESS;
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE simdjson::error_code callImpl(
+      int64_t& result,
+      const arg_type<Json>& json,
+      const arg_type<Varchar>& jsonPath) {
+    size_t resultCount = 0;
+    size_t singleResultSize = 0;
+    auto consumer = [&resultCount, &singleResultSize](auto& v) {
+      resultCount++;
+
+      if (resultCount == 1) {
+        // We only need the size of the actual object if there's only one
+        // returned, if multiple are returned we use the number of objects
+        // returned instead.
+        SIMDJSON_ASSIGN_OR_RAISE(auto vtype, v.type());
+        switch (vtype) {
+          case simdjson::ondemand::json_type::object: {
+            SIMDJSON_ASSIGN_OR_RAISE(singleResultSize, v.count_fields());
+            break;
+          }
+          case simdjson::ondemand::json_type::array: {
+            SIMDJSON_ASSIGN_OR_RAISE(singleResultSize, v.count_elements());
+            break;
+          }
+          case simdjson::ondemand::json_type::string:
+          case simdjson::ondemand::json_type::number:
+          case simdjson::ondemand::json_type::boolean:
+          case simdjson::ondemand::json_type::null:
+            singleResultSize = 0;
+            break;
+        }
+      }
+      return simdjson::SUCCESS;
+    };
+
+    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    SIMDJSON_TRY(simdJsonExtract(json, extractor, consumer));
+
+    if (resultCount == 0) {
+      // If the path didn't map to anything in the JSON object, return null.
+      return simdjson::NO_SUCH_FIELD;
     }
 
-    return true;
+    result = resultCount == 1 ? singleResultSize : resultCount;
+
+    return simdjson::SUCCESS;
   }
 };
 
diff --git a/velox/functions/prestosql/Map.cpp b/velox/functions/prestosql/Map.cpp
index 80e707f008a5f..fa24b4deb2eb8 100644
--- a/velox/functions/prestosql/Map.cpp
+++ b/velox/functions/prestosql/Map.cpp
@@ -51,10 +51,9 @@ class MapFunction : public exec::VectorFunction {
 
             VELOX_USER_CHECK(
                 !keysElements->containsNullAt(offset + i),
-                fmt::format(
-                    "{}: {}",
-                    kIndeterminateKeyErrorMessage,
-                    keysElements->toString(offset + i)));
+                "{}: {}",
+                kIndeterminateKeyErrorMessage,
+                keysElements->toString(offset + i));
           }
         };
     // When context.throwOnError is false, some rows will be marked as
@@ -88,7 +87,7 @@ class MapFunction : public exec::VectorFunction {
       auto mapVector = std::make_shared<MapVector>(
           context.pool(),
           outputType,
-          nullptr,
+          keysArray->nulls(),
           rows.end(),
           keysArray->offsets(),
           keysArray->sizes(),
@@ -279,7 +278,7 @@ class MapFunction : public exec::VectorFunction {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // array(K), array(V) -> map(K,V)
     return {exec::FunctionSignatureBuilder()
-                .knownTypeVariable("K")
+                .typeVariable("K")
                 .typeVariable("V")
                 .returnType("map(K,V)")
                 .argumentType("array(K)")
@@ -307,6 +306,14 @@ class MapFunction : public exec::VectorFunction {
       return false;
     }
     for (auto row = 0; row < keys->size(); ++row) {
+      if (keys->isNullAt(row)) {
+        continue;
+      }
+
+      if (values->isNullAt(row)) {
+        return false;
+      }
+
       if (keys->offsetAt(row) != values->offsetAt(row) ||
           keys->sizeAt(row) != values->sizeAt(row)) {
         return false;
@@ -351,4 +358,12 @@ VELOX_DECLARE_VECTOR_FUNCTION(
     udf_map_allow_duplicates,
     MapFunction</*AllowDuplicateKeys=*/true>::signatures(),
     std::make_unique<MapFunction</*AllowDuplicateKeys=*/true>>());
+
+void registerMapFunction(const std::string& name, bool allowDuplicateKeys) {
+  if (allowDuplicateKeys) {
+    VELOX_REGISTER_VECTOR_FUNCTION(udf_map_allow_duplicates, name);
+  } else {
+    VELOX_REGISTER_VECTOR_FUNCTION(udf_map, name);
+  }
+}
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Map.h b/velox/functions/prestosql/Map.h
new file mode 100644
index 0000000000000..66ded7d405c66
--- /dev/null
+++ b/velox/functions/prestosql/Map.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#include <string>
+
+namespace facebook::velox::functions {
+
+void registerMapFunction(const std::string& name, bool allowDuplicateKeys);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapEntries.cpp b/velox/functions/prestosql/MapEntries.cpp
index 1b4a9f5126a97..aa836f26eacea 100644
--- a/velox/functions/prestosql/MapEntries.cpp
+++ b/velox/functions/prestosql/MapEntries.cpp
@@ -29,7 +29,6 @@ class MapEntriesFunction : public exec::VectorFunction {
       exec::EvalCtx& context,
       VectorPtr& result) const override {
     auto& arg = args[0];
-
     VectorPtr localResult;
 
     // Input can be constant or flat.
@@ -71,7 +70,7 @@ class MapEntriesFunction : public exec::VectorFunction {
         context.pool(),
         outputType->childAt(0),
         BufferPtr(nullptr),
-        inputMap->mapKeys()->size(),
+        std::min(inputMap->mapKeys()->size(), inputMap->mapValues()->size()),
         std::vector<VectorPtr>{inputMap->mapKeys(), inputMap->mapValues()});
 
     return std::make_shared<ArrayVector>(
diff --git a/velox/functions/prestosql/MapFromEntries.cpp b/velox/functions/prestosql/MapFromEntries.cpp
index ea52b41f116ec..c6700b0dbaf92 100644
--- a/velox/functions/prestosql/MapFromEntries.cpp
+++ b/velox/functions/prestosql/MapFromEntries.cpp
@@ -122,18 +122,13 @@ class MapFromEntriesFunction : public exec::VectorFunction {
     auto rowVector = decodedRowVector->base()->as<RowVector>();
     auto keyVector = rowVector->childAt(0);
 
-    BufferPtr changedSizes = nullptr;
-    vector_size_t* mutableSizes = nullptr;
-    auto resetSize = [&](vector_size_t row) {
-      if (!mutableSizes) {
-        changedSizes = allocateSizes(rows.end(), context.pool());
-        mutableSizes = changedSizes->asMutable<vector_size_t>();
-        rows.applyToSelected([&](vector_size_t row) {
-          mutableSizes[row] = inputArray->rawSizes()[row];
-        });
-      }
-      mutableSizes[row] = 0;
-    };
+    BufferPtr sizes = allocateSizes(rows.end(), context.pool());
+    vector_size_t* mutableSizes = sizes->asMutable<vector_size_t>();
+    rows.applyToSelected([&](vector_size_t row) {
+      mutableSizes[row] = inputArray->rawSizes()[row];
+    });
+
+    auto resetSize = [&](vector_size_t row) { mutableSizes[row] = 0; };
 
     // Validate all map entries and map keys are not null.
     if (decodedRowVector->mayHaveNulls() || keyVector->mayHaveNulls() ||
@@ -232,7 +227,7 @@ class MapFromEntriesFunction : public exec::VectorFunction {
         inputArray->nulls(),
         rows.end(),
         inputArray->offsets(),
-        changedSizes ? changedSizes : inputArray->sizes(),
+        sizes,
         wrappedKeys,
         wrappedValues);
 
diff --git a/velox/functions/prestosql/MapKeysAndValues.cpp b/velox/functions/prestosql/MapKeysAndValues.cpp
index 742042270fa9a..50a03310dae86 100644
--- a/velox/functions/prestosql/MapKeysAndValues.cpp
+++ b/velox/functions/prestosql/MapKeysAndValues.cpp
@@ -89,7 +89,7 @@ class MapKeysFunction : public MapKeyValueFunction {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // map(K,V) -> array(K)
     return {exec::FunctionSignatureBuilder()
-                .knownTypeVariable("K")
+                .typeVariable("K")
                 .typeVariable("V")
                 .returnType("array(K)")
                 .argumentType("map(K,V)")
@@ -107,7 +107,7 @@ class MapValuesFunction : public MapKeyValueFunction {
       exec::EvalCtx& context) const override {
     VELOX_CHECK(
         arg->typeKind() == TypeKind::MAP,
-        "Unsupported type for map_keys function {}",
+        "Unsupported type for map_values function {}",
         mapTypeKindToName(arg->typeKind()));
 
     auto mapVector = arg->as<MapVector>();
@@ -126,7 +126,7 @@ class MapValuesFunction : public MapKeyValueFunction {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // map(K,V) -> array(V)
     return {exec::FunctionSignatureBuilder()
-                .knownTypeVariable("K")
+                .typeVariable("K")
                 .typeVariable("V")
                 .returnType("array(V)")
                 .argumentType("map(K,V)")
diff --git a/velox/functions/prestosql/MapNormalize.h b/velox/functions/prestosql/MapNormalize.h
new file mode 100644
index 0000000000000..edf7cede724f2
--- /dev/null
+++ b/velox/functions/prestosql/MapNormalize.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec>
+struct MapNormalizeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Varchar, double>>& out,
+      const arg_type<Map<Varchar, double>>& inputMap) {
+    double totalSum = 0.0;
+    for (const auto& entry : inputMap) {
+      if (entry.second.has_value()) {
+        totalSum += entry.second.value();
+      }
+    }
+
+    // totalSum can be zero, but that's OK. See
+    // https://github.com/prestodb/presto/issues/22209 for Presto Java
+    // semantics.
+
+    for (const auto& entry : inputMap) {
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter = entry.second.value() / totalSum;
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapRemoveNullValues.h b/velox/functions/prestosql/MapRemoveNullValues.h
new file mode 100644
index 0000000000000..a18b4a3c2fdc9
--- /dev/null
+++ b/velox/functions/prestosql/MapRemoveNullValues.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+namespace facebook::velox::functions {
+
+template <typename TExec>
+struct MapRemoveNullValues {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Generic<T1>, Generic<T2>>>& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& inputMap) {
+    for (const auto& entry : inputMap) {
+      if (entry.second.has_value()) {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapSubset.h b/velox/functions/prestosql/MapSubset.h
new file mode 100644
index 0000000000000..238922e8f0529
--- /dev/null
+++ b/velox/functions/prestosql/MapSubset.h
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for constant primitive type keys: map_subset(m, array[1, 2, 3]).
+template <typename TExec, typename Key>
+struct MapSubsetPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Map<Key, Generic<T1>>>* /*inputMap*/,
+      const arg_type<Array<Key>>* keys) {
+    if (keys != nullptr) {
+      constantSearchKeys_ = true;
+      initializeSearchKeys(*keys);
+    }
+  }
+
+  void call(
+      out_type<Map<Key, Generic<T1>>>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& keys) {
+    if (keys.empty()) {
+      return;
+    }
+
+    if (!constantSearchKeys_) {
+      searchKeys_.clear();
+      initializeSearchKeys(keys);
+    }
+
+    if (searchKeys_.empty()) {
+      return;
+    }
+
+    auto toFind = searchKeys_.size();
+
+    for (const auto& entry : inputMap) {
+      if (!searchKeys_.contains(entry.first)) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter = entry.first;
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter = entry.first;
+        valueWriter.copy_from(entry.second.value());
+      }
+
+      --toFind;
+      if (toFind == 0) {
+        break;
+      }
+    }
+  }
+
+ private:
+  void initializeSearchKeys(const arg_type<Array<Key>>& keys) {
+    for (const auto& key : keys.skipNulls()) {
+      searchKeys_.emplace(key);
+    }
+  }
+
+  bool constantSearchKeys_{false};
+  util::floating_point::HashSetNaNAware<arg_type<Key>> searchKeys_;
+};
+
+/// Fast path for constant string keys: map_subset(m, array['a', 'b', 'c']).
+template <typename TExec>
+struct MapSubsetVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Map<Varchar, Generic<T1>>>* /*inputMap*/,
+      const arg_type<Array<Varchar>>* keys) {
+    if (keys != nullptr) {
+      constantSearchKeys_ = true;
+
+      searchKeyStrings_.reserve(keys->size());
+      for (const auto& key : keys->skipNulls()) {
+        if (key.isInline()) {
+          searchKeys_.emplace(key);
+        } else if (!searchKeys_.contains(key)) {
+          searchKeyStrings_.push_back(key.str());
+          searchKeys_.emplace(StringView(searchKeyStrings_.back()));
+        }
+      }
+    }
+  }
+
+  void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& keys) {
+    if (keys.empty()) {
+      return;
+    }
+
+    if (!constantSearchKeys_) {
+      searchKeys_.clear();
+      for (const auto& key : keys.skipNulls()) {
+        searchKeys_.emplace(key);
+      }
+    }
+
+    if (searchKeys_.empty()) {
+      return;
+    }
+
+    auto toFind = searchKeys_.size();
+
+    for (const auto& entry : inputMap) {
+      if (!searchKeys_.contains(entry.first)) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+
+      --toFind;
+      if (toFind == 0) {
+        break;
+      }
+    }
+  }
+
+ private:
+  bool constantSearchKeys_{false};
+  folly::F14FastSet<StringView> searchKeys_;
+  std::vector<std::string> searchKeyStrings_;
+};
+
+/// Generic implementation. Doesn't provide an optimization for constant search
+/// keys.
+template <typename TExec>
+struct MapSubsetFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Generic<T1>, Generic<T2>>>& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& inputMap,
+      const arg_type<Array<Generic<T1>>>& keys) {
+    if (keys.empty()) {
+      return;
+    }
+
+    // TODO Figure out how to implement fast path for constant search keys.
+    // Just implementing 'initialize' and populating 'searchKeys_' there doesn't
+    // work because GenericView's go out of scope at the end of the method.
+
+    searchKeys_.clear();
+    for (const auto& key : keys.skipNulls()) {
+      searchKeys_.emplace(key);
+    }
+
+    if (searchKeys_.empty()) {
+      return;
+    }
+
+    auto toFind = searchKeys_.size();
+
+    for (const auto& entry : inputMap) {
+      if (!searchKeys_.contains(entry.first)) {
+        continue;
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(entry.first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(entry.first);
+        valueWriter.copy_from(entry.second.value());
+      }
+
+      --toFind;
+      if (toFind == 0) {
+        break;
+      }
+    }
+  }
+
+ private:
+  folly::F14FastSet<exec::GenericView> searchKeys_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapTopN.h b/velox/functions/prestosql/MapTopN.h
new file mode 100644
index 0000000000000..1407dc0680f71
--- /dev/null
+++ b/velox/functions/prestosql/MapTopN.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec>
+struct MapTopNFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename It>
+  struct Compare {
+    bool operator()(const It& l, const It& r) const {
+      static const CompareFlags flags{
+          false /*nullsFirst*/,
+          true /*ascending*/,
+          false /*equalsOnly*/,
+          CompareFlags::NullHandlingMode::kNullAsIndeterminate};
+
+      if (l->second.has_value() && r->second.has_value()) {
+        auto comp = l->second.value().compare(r->second.value(), flags);
+
+        if (FOLLY_UNLIKELY(comp == 0)) {
+          return l->first.compare(r->first, flags) > 0;
+        }
+
+        return comp > 0;
+      } else if (FOLLY_UNLIKELY(
+                     !l->second.has_value() && !r->second.has_value())) {
+        return l->first.compare(r->first, flags) > 0;
+      }
+
+      return l->second.has_value();
+    }
+  };
+
+  void call(
+      out_type<Map<Orderable<T1>, Orderable<T2>>>& out,
+      const arg_type<Map<Orderable<T1>, Orderable<T2>>>& inputMap,
+      int64_t n) {
+    VELOX_USER_CHECK_GE(n, 0, "n must be greater than or equal to 0");
+
+    if (n == 0) {
+      return;
+    }
+
+    if (n >= inputMap.size()) {
+      out.copy_from(inputMap);
+      return;
+    }
+
+    using It = typename arg_type<Map<Orderable<T1>, Orderable<T2>>>::Iterator;
+
+    Compare<It> comparator;
+
+    std::priority_queue<It, std::vector<It>, Compare<It>> topEntries(
+        comparator);
+
+    for (auto it = inputMap.begin(); it != inputMap.end(); ++it) {
+      if (topEntries.size() < n) {
+        topEntries.push(it);
+      } else if (comparator(it, topEntries.top())) {
+        topEntries.pop();
+        topEntries.push(it);
+      }
+    }
+
+    while (!topEntries.empty()) {
+      auto it = topEntries.top();
+
+      if (!it->second.has_value()) {
+        auto& keyWriter = out.add_null();
+        keyWriter.copy_from(it->first);
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter.copy_from(it->first);
+        valueWriter.copy_from(it->second.value());
+      }
+
+      topEntries.pop();
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapTopNImpl.h b/velox/functions/prestosql/MapTopNImpl.h
new file mode 100644
index 0000000000000..f4ab489c33c26
--- /dev/null
+++ b/velox/functions/prestosql/MapTopNImpl.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec, typename Compare>
+struct MapTopNImpl {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  using It = typename arg_type<Map<Orderable<T1>, Orderable<T2>>>::Iterator;
+
+  void call(
+      out_type<Array<Orderable<T1>>>& out,
+      const arg_type<Map<Orderable<T1>, Orderable<T2>>>& inputMap,
+      int64_t n) {
+    VELOX_USER_CHECK_GE(n, 0, "n must be greater than or equal to 0");
+
+    if (n == 0 || inputMap.size() == 0) {
+      return;
+    }
+
+    Compare comparator;
+    std::priority_queue<It, std::vector<It>, Compare> topEntries(comparator);
+
+    for (auto it = inputMap.begin(); it != inputMap.end(); ++it) {
+      if (topEntries.size() < n) {
+        topEntries.push(it);
+      } else if (comparator(it, topEntries.top())) {
+        topEntries.pop();
+        topEntries.push(it);
+      }
+    }
+    std::vector<It> result;
+    result.reserve(topEntries.size());
+    while (!topEntries.empty()) {
+      result.push_back(topEntries.top());
+      topEntries.pop();
+    }
+    // Reverse the order of the result to be in descending order.
+    for (int i = result.size() - 1; i >= 0; i--) {
+      out.push_back(result[i]->first);
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapTopNKeys.h b/velox/functions/prestosql/MapTopNKeys.h
new file mode 100644
index 0000000000000..d4a01f5b245b3
--- /dev/null
+++ b/velox/functions/prestosql/MapTopNKeys.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+#include "velox/functions/prestosql/MapTopNImpl.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec>
+struct CompareKeys {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  using It = typename arg_type<Map<Orderable<T1>, Orderable<T2>>>::Iterator;
+
+  bool operator()(const It& l, const It& r) const {
+    static const CompareFlags flags{
+        false /*nullsFirst*/,
+        true /*ascending*/,
+        false /*equalsOnly*/,
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate};
+    return l->first.compare(r->first, flags) > 0;
+  }
+};
+
+// Returns an array with the top N keys in descending order.
+template <typename TExec>
+struct MapTopNKeysFunction : MapTopNImpl<TExec, CompareKeys<TExec>> {};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapZipWith.cpp b/velox/functions/prestosql/MapZipWith.cpp
index d4195355b0b44..81718d7918c3a 100644
--- a/velox/functions/prestosql/MapZipWith.cpp
+++ b/velox/functions/prestosql/MapZipWith.cpp
@@ -78,14 +78,6 @@ struct MergeResults {
 // https://prestodb.io/docs/current/functions/map.html#map_zip_with
 class MapZipWithFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    // map_zip_with is null preserving for the map, but since an
-    // expr tree with a lambda depends on all named fields, including
-    // captures, a null in a capture does not automatically make a
-    // null result.
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -491,9 +483,15 @@ class MapZipWithFunction : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+/// map_zip_with is null preserving for the map, but since an
+/// expr tree with a lambda depends on all named fields, including
+/// captures, a null in a capture does not automatically make a
+/// null result.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_map_zip_with,
     MapZipWithFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<MapZipWithFunction>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MultimapFromEntries.h b/velox/functions/prestosql/MultimapFromEntries.h
new file mode 100644
index 0000000000000..05d86d0273d91
--- /dev/null
+++ b/velox/functions/prestosql/MultimapFromEntries.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/container/F14Map.h>
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec>
+struct MultimapFromEntriesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Map<Generic<T1>, Array<Generic<T2>>>>& out,
+      const arg_type<Array<Row<Generic<T1>, Generic<T2>>>>& inputArray) {
+    // Reuse map and vector between rows to avoid re-allocating memory. The
+    // benchmark shows 20-30% performance improvement.
+    keyValuesMap_.clear();
+
+    uniqueKeys_.clear();
+    uniqueKeys_.reserve(inputArray.size());
+
+    for (const auto& entry : inputArray.skipNulls()) {
+      const auto& key = entry.template at<0>();
+      const auto& value = entry.template at<1>();
+
+      VELOX_USER_CHECK(key.has_value(), "map key cannot be null");
+
+      auto result = keyValuesMap_.insert({key.value(), {}});
+      result.first->second.push_back(value);
+      if (result.second) {
+        uniqueKeys_.push_back(key.value());
+      }
+    }
+
+    for (const auto& key : uniqueKeys_) {
+      auto [keyWriter, valueWriter] = out.add_item();
+      keyWriter.copy_from(key);
+
+      const auto& values = keyValuesMap_[key];
+
+      for (const auto& value : values) {
+        valueWriter.push_back(value);
+      }
+    }
+  }
+
+ private:
+  folly::F14FastMap<
+      exec::GenericView,
+      std::vector<std::optional<exec::GenericView>>>
+      keyValuesMap_;
+
+  // List of unique keys in the same order as they appear in inputArray.
+  // Used to ensure deterministic order of keys in the result. Without ensuring
+  // deterministic order of keys, the results of expressions like
+  // map_keys(multimap_from_entries(...)) will be non-deterministic and trigger
+  // Fuzzer failures. F14FastMap in debug build returns keys in
+  // non-deterministic order (on purpose).
+  std::vector<exec::GenericView> uniqueKeys_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Not.cpp b/velox/functions/prestosql/Not.cpp
index 6ed340c613388..0e12e70d807d3 100644
--- a/velox/functions/prestosql/Not.cpp
+++ b/velox/functions/prestosql/Not.cpp
@@ -61,6 +61,10 @@ class NotFunction : public exec::VectorFunction {
     context.moveOrCopyResult(localResult, rows, result);
   }
 
+  exec::FunctionCanonicalName getCanonicalName() const override {
+    return exec::FunctionCanonicalName::kNot;
+  }
+
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // boolean -> boolean
     return {exec::FunctionSignatureBuilder()
diff --git a/velox/functions/prestosql/Probability.h b/velox/functions/prestosql/Probability.h
index 556041a9c88fe..f0f92cf4e09bf 100644
--- a/velox/functions/prestosql/Probability.h
+++ b/velox/functions/prestosql/Probability.h
@@ -15,7 +15,10 @@
  */
 #pragma once
 
+#include <boost/math/distributions.hpp>
+#include <boost/math/distributions/cauchy.hpp>
 #include <boost/math/distributions/laplace.hpp>
+#include <boost/math/distributions/weibull.hpp>
 #include "boost/math/distributions/beta.hpp"
 #include "boost/math/distributions/binomial.hpp"
 #include "boost/math/distributions/cauchy.hpp"
@@ -23,6 +26,7 @@
 #include "boost/math/distributions/fisher_f.hpp"
 #include "boost/math/distributions/gamma.hpp"
 #include "boost/math/distributions/poisson.hpp"
+#include "boost/math/special_functions/erf.hpp"
 #include "velox/common/base/Exceptions.h"
 #include "velox/functions/Macros.h"
 
@@ -224,5 +228,106 @@ struct PoissonCDFFunction {
   }
 };
 
+template <typename T>
+struct WeibullCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void
+  call(double& result, double a, double b, double value) {
+    static constexpr double kInf = std::numeric_limits<double>::infinity();
+
+    VELOX_USER_CHECK_GT(a, 0, "a must be greater than 0");
+    VELOX_USER_CHECK_GT(b, 0, "b must be greater than 0");
+
+    if (std::isnan(value)) {
+      result = std::numeric_limits<double>::quiet_NaN();
+    } else if (b == kInf) {
+      result = 0.0;
+    } else if (a == kInf || value == kInf) {
+      result = 1.0;
+    } else {
+      boost::math::weibull_distribution<> dist(a, b);
+      result = boost::math::cdf(dist, value);
+    }
+  }
+};
+
+template <typename T>
+struct InverseNormalCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(double& result, double m, double sd, double p) {
+    VELOX_USER_CHECK((p >= 0) && (p <= 1), "p must be 0 > p > 1");
+    VELOX_USER_CHECK_GT(sd, 0, "standardDeviation must be > 0");
+
+    static const double kSqrtOfTwo = std::sqrt(2);
+    result = m + sd * kSqrtOfTwo * boost::math::erf_inv(2 * p - 1);
+  }
+};
+
+template <typename T>
+struct InverseWeibullCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(double& result, double a, double b, double p) {
+    static constexpr double kInf = std::numeric_limits<double>::infinity();
+
+    VELOX_USER_CHECK((p >= 0) && (p <= 1), "p must be in the interval [0, 1]");
+    VELOX_USER_CHECK_GT(a, 0, "a must be greater than 0");
+    VELOX_USER_CHECK_GT(b, 0, "b must be greater than 0");
+
+    if (b == kInf) {
+      result = kInf;
+    } else {
+      // https://commons.apache.org/proper/commons-math/javadocs/api-3.6.1/org/apache/commons/math3/distribution/WeibullDistribution.html#inverseCumulativeProbability(double)
+      result = b * std::pow(-std::log1p(-p), 1.0 / a);
+    }
+  }
+};
+
+template <typename T>
+struct InverseCauchyCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  FOLLY_ALWAYS_INLINE void
+  call(double& result, double median, double scale, double p) {
+    static constexpr double kInf = std::numeric_limits<double>::infinity();
+    static constexpr double kDoubleMax = std::numeric_limits<double>::max();
+    static constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
+
+    VELOX_USER_CHECK(p >= 0 && p <= 1, "p must be in the interval [0, 1]");
+    VELOX_USER_CHECK_GT(scale, 0, "scale must be greater than 0");
+
+    if (p == 1.0) {
+      result = kInf;
+    } else if (scale == kInf) {
+      result = median;
+    } else if (std::isnan(median)) {
+      result = kNan;
+    } else if (median == kInf) {
+      result = kInf;
+    } else {
+      boost::math::cauchy_distribution<> cauchyDist(median, scale);
+      result = boost::math::quantile(cauchyDist, p);
+    }
+  }
+};
+
+template <typename T>
+struct InverseLaplaceCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  FOLLY_ALWAYS_INLINE void
+  call(double& result, double location, double scale, double p) {
+    VELOX_USER_CHECK_GT(scale, 0, "scale must be greater than 0");
+    VELOX_USER_CHECK(p >= 0 && p <= 1, "p must be in the interval [0, 1]");
+
+    if (std::isnan(location) || std::isinf(location)) {
+      result = std::numeric_limits<double>::quiet_NaN();
+    } else {
+      boost::math::laplace_distribution<> laplaceDist(location, scale);
+      result = boost::math::quantile(laplaceDist, p);
+    }
+  }
+};
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Rand.h b/velox/functions/prestosql/Rand.h
index 0d2833d2e4133..555fe1375a411 100644
--- a/velox/functions/prestosql/Rand.h
+++ b/velox/functions/prestosql/Rand.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "folly/Random.h"
+#include "velox/expression/FunctionSignature.h"
 #include "velox/functions/Macros.h"
 
 namespace facebook::velox::functions {
@@ -23,6 +24,7 @@ namespace facebook::velox::functions {
 template <typename T>
 struct RandFunction {
   static constexpr bool is_deterministic = false;
+  static constexpr auto canonical_name = exec::FunctionCanonicalName::kRand;
 
   FOLLY_ALWAYS_INLINE void call(double& result) {
     result = folly::Random::randDouble01();
@@ -56,4 +58,92 @@ struct RandFunction {
   }
 };
 
+template <typename T>
+struct SecureRandFunction {
+  static constexpr bool is_deterministic = false;
+
+  template <typename InputType>
+  FOLLY_ALWAYS_INLINE void checkInput(
+      const InputType lower,
+      const InputType upper) {
+    VELOX_USER_CHECK_GT(
+        upper, lower, "upper bound must be greater than lower bound");
+  }
+
+  FOLLY_ALWAYS_INLINE void call(double& out) {
+    out = folly::Random::secureRandDouble01();
+  }
+
+  FOLLY_ALWAYS_INLINE void
+  call(double& out, const double lower, const double upper) {
+    checkInput(lower, upper);
+    if (std::isinf(lower)) {
+      out = std::numeric_limits<double>::quiet_NaN();
+    } else if (std::isinf(upper)) {
+      out = std::numeric_limits<double>::max();
+    } else {
+      out = folly::Random::secureRandDouble(0, upper - lower) + lower;
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void
+  call(float& out, const float lower, const float upper) {
+    checkInput(lower, upper);
+    if (std::isinf(lower)) {
+      out = std::numeric_limits<float>::quiet_NaN();
+    } else if (std::isinf(upper)) {
+      out = std::numeric_limits<float>::max();
+    } else {
+      out = float(folly::Random::secureRandDouble(0, upper - lower)) + lower;
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void
+  call(int64_t& out, const int64_t lower, const int64_t upper) {
+    checkInput(lower, upper);
+    if (upper >= 0) {
+      out = int64_t(
+          folly::Random::secureRand64(0, uint64_t(upper) - lower) + lower);
+    } else {
+      out = int64_t(
+          folly::Random::secureRand64(0, uint64_t(upper - lower)) + lower);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void
+  call(int32_t& out, const int32_t lower, const int32_t upper) {
+    checkInput(lower, upper);
+    if (upper >= 0) {
+      out = int32_t(
+          folly::Random::secureRand32(0, uint32_t(upper) - lower) + lower);
+    } else {
+      out = int32_t(
+          folly::Random::secureRand32(0, uint32_t(upper - lower)) + lower);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void
+  call(int16_t& out, const int16_t lower, const int16_t upper) {
+    checkInput(lower, upper);
+    if (upper >= 0) {
+      out = int16_t(
+          folly::Random::secureRand32(0, uint16_t(upper) - lower) + lower);
+    } else {
+      out = int16_t(
+          folly::Random::secureRand32(0, uint16_t(upper - lower)) + lower);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void
+  call(int8_t& out, const int8_t lower, const int8_t upper) {
+    checkInput(lower, upper);
+    if (upper >= 0) {
+      out = int8_t(
+          folly::Random::secureRand32(0, uint8_t(upper) - lower) + lower);
+    } else {
+      out = int8_t(
+          folly::Random::secureRand32(0, uint8_t(upper - lower)) + lower);
+    }
+  }
+};
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Reduce.cpp b/velox/functions/prestosql/Reduce.cpp
index 363eeb9a9244f..2b3eea9942d61 100644
--- a/velox/functions/prestosql/Reduce.cpp
+++ b/velox/functions/prestosql/Reduce.cpp
@@ -13,12 +13,41 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/RuntimeMetrics.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
 
 namespace facebook::velox::functions {
 namespace {
 
+// Throws if any array in any of 'rows' has more than 10K elements.
+// Evaluating 'reduce' lambda function on very large arrays is too slow.
+void checkArraySizes(
+    const SelectivityVector& rows,
+    DecodedVector& decodedArray,
+    exec::EvalCtx& context) {
+  const auto* indices = decodedArray.indices();
+  const auto* rawSizes = decodedArray.base()->as<ArrayVector>()->rawSizes();
+
+  static const vector_size_t kMaxArraySize = 10'000;
+
+  rows.applyToSelected([&](auto row) {
+    if (decodedArray.isNullAt(row)) {
+      return;
+    }
+    const auto size = rawSizes[indices[row]];
+    try {
+      VELOX_USER_CHECK_LT(
+          size,
+          kMaxArraySize,
+          "reduce lambda function doesn't support arrays with more than {} elements",
+          kMaxArraySize);
+    } catch (VeloxUserError&) {
+      context.setError(row, std::current_exception());
+    }
+  });
+}
+
 /// Populates indices of the n-th elements of the arrays.
 /// Selects 'row' in 'arrayRows' if corresponding array has an n-th element.
 /// Sets elementIndices[row] to the index of the n-th element in the 'elements'
@@ -56,14 +85,6 @@ bool toNthElementRows(
 /// https://prestodb.io/docs/current/functions/array.html#reduce
 class ReduceFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    // reduce is null preserving for the array. But since an
-    // expr tree with a lambda depends on all named fields, including
-    // captures, a null in a capture does not automatically make a
-    // null result.
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -75,6 +96,36 @@ class ReduceFunction : public exec::VectorFunction {
     exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
     auto& decodedArray = *arrayDecoder.get();
 
+    checkArraySizes(rows, decodedArray, context);
+
+    exec::LocalSelectivityVector remainingRows(context, rows);
+    context.deselectErrors(*remainingRows);
+
+    doApply(*remainingRows, args, decodedArray, outputType, context, result);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    // array(T), S, function(S, T, S), function(S, R) -> R
+    return {exec::FunctionSignatureBuilder()
+                .typeVariable("T")
+                .typeVariable("S")
+                .typeVariable("R")
+                .returnType("R")
+                .argumentType("array(T)")
+                .argumentType("S")
+                .argumentType("function(S,T,S)")
+                .argumentType("function(S,R)")
+                .build()};
+  }
+
+ private:
+  void doApply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      DecodedVector& decodedArray,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
     auto flatArray = flattenArray(rows, args[0], decodedArray);
     // Identify the rows need to be computed.
     exec::LocalSelectivityVector nonNullRowsHolder(*context.execCtx());
@@ -157,6 +208,7 @@ class ReduceFunction : public exec::VectorFunction {
         n++;
       }
     }
+
     // Apply output function.
     VectorPtr localResult;
     auto outputFuncIt =
@@ -178,26 +230,210 @@ class ReduceFunction : public exec::VectorFunction {
     }
     context.moveOrCopyResult(localResult, rows, result);
   }
+};
 
-  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    // array(T), S, function(S, T, S), function(S, R) -> R
-    return {exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .typeVariable("S")
-                .typeVariable("R")
-                .returnType("R")
-                .argumentType("array(T)")
-                .argumentType("S")
-                .argumentType("function(S,T,S)")
-                .argumentType("function(S,R)")
-                .build()};
+bool isVariableReference(
+    const core::TypedExprPtr& expr,
+    const std::string& var) {
+  auto* fieldAccess =
+      dynamic_cast<const core::FieldAccessTypedExpr*>(expr.get());
+  return fieldAccess && fieldAccess->isInputColumn() &&
+      fieldAccess->name() == var;
+}
+
+core::TypedExprPtr extractFromAddition(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr,
+    const std::string& s) {
+  auto* plus = dynamic_cast<const core::CallTypedExpr*>(expr.get());
+  if (plus && plus->name() == prefix + "plus") {
+    if (!isVariableReference(plus->inputs()[0], s)) {
+      return nullptr;
+    }
+    return plus->inputs()[1];
   }
-};
+  if (!isVariableReference(expr, s)) {
+    return nullptr;
+  }
+  variant zero;
+  switch (expr->type()->kind()) {
+    case TypeKind::TINYINT:
+      zero = variant::create<int8_t>(0);
+      break;
+    case TypeKind::SMALLINT:
+      zero = variant::create<int16_t>(0);
+      break;
+    case TypeKind::INTEGER:
+      zero = variant::create<int32_t>(0);
+      break;
+    case TypeKind::BIGINT:
+      zero = variant::create<int64_t>(0);
+      break;
+    case TypeKind::REAL:
+      zero = variant::create<float>(0);
+      break;
+    case TypeKind::DOUBLE:
+      zero = variant::create<double>(0);
+      break;
+    default:
+      return nullptr;
+  }
+  return std::make_shared<core::ConstantTypedExpr>(expr->type(), zero);
+}
+
+bool containsVariableReference(
+    const core::TypedExprPtr& expr,
+    const std::string& var) {
+  if (isVariableReference(expr, var)) {
+    return true;
+  }
+  if (auto* lambda = dynamic_cast<const core::LambdaTypedExpr*>(expr.get())) {
+    return !lambda->signature()->containsChild(var) &&
+        containsVariableReference(lambda->body(), var);
+  }
+  for (auto& input : expr->inputs()) {
+    if (containsVariableReference(input, var)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+core::TypedExprPtr toArraySum(
+    const std::string& prefix,
+    const core::CallTypedExpr& reduce,
+    const RowTypePtr& inputArgs,
+    const core::TypedExprPtr& expr) {
+  if (containsVariableReference(expr, inputArgs->nameOf(0))) {
+    return nullptr;
+  }
+  auto& initial = reduce.inputs()[1];
+  TypePtr sumType;
+  switch (initial->type()->kind()) {
+    case TypeKind::TINYINT:
+    case TypeKind::SMALLINT:
+    case TypeKind::INTEGER:
+    case TypeKind::BIGINT:
+      sumType = BIGINT();
+      break;
+    case TypeKind::REAL:
+    case TypeKind::DOUBLE:
+      sumType = DOUBLE();
+      break;
+    default:
+      return nullptr;
+  }
+  auto lambda = std::make_shared<core::LambdaTypedExpr>(
+      ROW({inputArgs->nameOf(1)}, {inputArgs->childAt(1)}), expr);
+  auto transform = std::make_shared<core::CallTypedExpr>(
+      ARRAY(expr->type()),
+      std::vector<core::TypedExprPtr>({reduce.inputs()[0], lambda}),
+      prefix + "transform");
+  auto arraySum = std::make_shared<core::CallTypedExpr>(
+      sumType,
+      std::vector<core::TypedExprPtr>({transform}),
+      prefix + "array_sum_propagate_element_null");
+  auto cast =
+      std::make_shared<core::CastTypedExpr>(initial->type(), arraySum, false);
+  auto plus = std::make_shared<core::CallTypedExpr>(
+      initial->type(),
+      std::vector<core::TypedExprPtr>({initial, cast}),
+      prefix + "plus");
+  VLOG(1) << "Rewrite expression: " << reduce.toString() << " => "
+          << plus->toString();
+  addThreadLocalRuntimeStat("numReduceRewrite", RuntimeCounter(1));
+  return plus;
+}
+
+core::TypedExprPtr rewriteReduce(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr) {
+  auto* reduce = dynamic_cast<const core::CallTypedExpr*>(expr.get());
+  if (!reduce || reduce->name() != prefix + "reduce" ||
+      reduce->inputs().size() != 4) {
+    return nullptr;
+  }
+  auto* outputFunction =
+      dynamic_cast<const core::LambdaTypedExpr*>(reduce->inputs()[3].get());
+  if (!outputFunction) {
+    return nullptr;
+  }
+  auto& outputArgs = outputFunction->signature();
+  if (outputArgs->size() != 1) {
+    return nullptr;
+  }
+  if (!isVariableReference(outputFunction->body(), outputArgs->nameOf(0))) {
+    return nullptr;
+  }
+  auto* inputFunction =
+      dynamic_cast<const core::LambdaTypedExpr*>(reduce->inputs()[2].get());
+  if (!inputFunction) {
+    return nullptr;
+  }
+  auto& inputArgs = inputFunction->signature();
+  if (inputArgs->size() != 2) {
+    return nullptr;
+  }
+  auto& s = inputArgs->nameOf(0);
+  auto* inputBody =
+      dynamic_cast<const core::CallTypedExpr*>(inputFunction->body().get());
+  if (!inputBody) {
+    return nullptr;
+  }
+  if (inputBody->name() == prefix + "plus") {
+    // s + f(x) => array_sum(transform(array, x -> f(x)))
+    auto fx = extractFromAddition(prefix, inputFunction->body(), s);
+    if (!fx) {
+      return nullptr;
+    }
+    return toArraySum(prefix, *reduce, inputArgs, fx);
+  } else if (inputBody->name() == prefix + "minus") {
+    // (s + f(x)) - g(x) => array_sum(transform(array, x -> f(x) - g(x)))
+    auto fx = extractFromAddition(prefix, inputBody->inputs()[0], s);
+    if (!fx) {
+      return nullptr;
+    }
+    auto minus = std::make_shared<core::CallTypedExpr>(
+        fx->type(),
+        std::vector<core::TypedExprPtr>({fx, inputBody->inputs()[1]}),
+        prefix + "minus");
+    return toArraySum(prefix, *reduce, inputArgs, minus);
+  } else if (inputBody->name() == "if" && inputBody->inputs().size() == 3) {
+    // if(h(x), s + f(x), s + g(x)) =>
+    // array_sum(transform(array, x -> if(h(x), f(x), g(x))))
+    auto fx = extractFromAddition(prefix, inputBody->inputs()[1], s);
+    if (!fx) {
+      return nullptr;
+    }
+    auto gx = extractFromAddition(prefix, inputBody->inputs()[2], s);
+    if (!gx) {
+      return nullptr;
+    }
+    auto ifExpr = std::make_shared<core::CallTypedExpr>(
+        fx->type(),
+        std::vector<core::TypedExprPtr>({inputBody->inputs()[0], fx, gx}),
+        "if");
+    return toArraySum(prefix, *reduce, inputArgs, ifExpr);
+  }
+  return nullptr;
+}
+
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+/// reduce is null preserving for the array. But since an
+/// expr tree with a lambda depends on all named fields, including
+/// captures, a null in a capture does not automatically make a
+/// null result.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_reduce,
     ReduceFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<ReduceFunction>());
 
+void registerReduceRewrites(const std::string& prefix) {
+  exec::registerExpressionRewrite(
+      [prefix](const auto& expr) { return rewriteReduce(prefix, expr); });
+}
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Reduce.h b/velox/functions/prestosql/Reduce.h
new file mode 100644
index 0000000000000..7bb17313e1574
--- /dev/null
+++ b/velox/functions/prestosql/Reduce.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions {
+
+void registerReduceRewrites(const std::string& prefix);
+
+}
diff --git a/velox/functions/prestosql/Repeat.cpp b/velox/functions/prestosql/Repeat.cpp
deleted file mode 100644
index fd37a58152a71..0000000000000
--- a/velox/functions/prestosql/Repeat.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/expression/DecodedArgs.h"
-#include "velox/expression/VectorFunction.h"
-
-namespace facebook::velox::functions {
-namespace {
-
-// See documentation at https://prestodb.io/docs/current/functions/array.html
-class RepeatFunction : public exec::VectorFunction {
- public:
-  static constexpr int32_t kMaxResultEntries = 10'000;
-
-  bool isDefaultNullBehavior() const override {
-    // repeat(null, n) returns an array of n nulls.
-    return false;
-  }
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    VectorPtr localResult;
-    if (args[1]->isConstantEncoding()) {
-      try {
-        localResult = applyConstant(rows, args, outputType, context);
-      } catch (const VeloxRuntimeError&) {
-        throw;
-      } catch (const std::exception& e) {
-        context.setErrors(rows, std::current_exception());
-        return;
-      }
-    } else {
-      localResult = applyFlat(rows, args, outputType, context);
-    }
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-
- private:
-  static void checkCount(const int32_t count) {
-    VELOX_USER_CHECK_GE(
-        count,
-        0,
-        "Count argument of repeat function must be greater than or equal to 0");
-    VELOX_USER_CHECK_LE(
-        count,
-        kMaxResultEntries,
-        "Count argument of repeat function must be less than or equal to 10000");
-  }
-
-  VectorPtr applyConstant(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context) const {
-    const auto numRows = rows.end();
-    auto pool = context.pool();
-
-    if (args[1]->as<ConstantVector<int32_t>>()->isNullAt(0)) {
-      // If count is a null constant, the result should be all nulls.
-      return BaseVector::createNullConstant(outputType, numRows, pool);
-    }
-
-    const auto count = args[1]->as<ConstantVector<int32_t>>()->valueAt(0);
-    // Exception will be processed on the upper level.
-    checkCount(count);
-    const auto totalCount = count * numRows;
-
-    // Allocate new vectors for indices, lengths and offsets.
-    BufferPtr indices = allocateIndices(totalCount, pool);
-    BufferPtr sizes = allocateSizes(numRows, pool);
-    BufferPtr offsets = allocateOffsets(numRows, pool);
-    auto rawIndices = indices->asMutable<vector_size_t>();
-    auto rawSizes = sizes->asMutable<vector_size_t>();
-    auto rawOffsets = offsets->asMutable<vector_size_t>();
-
-    vector_size_t offset = 0;
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      rawSizes[row] = count;
-      rawOffsets[row] = offset;
-      std::fill(rawIndices + offset, rawIndices + offset + count, row);
-      offset += count;
-    });
-
-    return std::make_shared<ArrayVector>(
-        pool,
-        outputType,
-        nullptr,
-        numRows,
-        offsets,
-        sizes,
-        BaseVector::wrapInDictionary(nullptr, indices, totalCount, args[0]));
-  }
-
-  VectorPtr applyFlat(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context) const {
-    exec::DecodedArgs decodedArgs(rows, args, context);
-    auto countDecoded = decodedArgs.at(1);
-    int32_t totalCount = 0;
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      auto count =
-          countDecoded->isNullAt(row) ? 0 : countDecoded->valueAt<int32_t>(row);
-      checkCount(count);
-      totalCount += count;
-    });
-
-    const auto numRows = rows.end();
-    auto pool = context.pool();
-
-    // Allocate new vector for nulls if necessary.
-    BufferPtr nulls;
-    uint64_t* rawNulls = nullptr;
-    if (countDecoded->mayHaveNulls()) {
-      nulls = allocateNulls(numRows, pool);
-      rawNulls = nulls->asMutable<uint64_t>();
-    }
-
-    // Allocate new vectors for indices, lengths and offsets.
-    BufferPtr indices = allocateIndices(totalCount, pool);
-    BufferPtr sizes = allocateSizes(numRows, pool);
-    BufferPtr offsets = allocateOffsets(numRows, pool);
-    auto rawIndices = indices->asMutable<vector_size_t>();
-    auto rawSizes = sizes->asMutable<vector_size_t>();
-    auto rawOffsets = offsets->asMutable<vector_size_t>();
-
-    // When context.throwOnError is false, rows with invalid count argument
-    // should be deselected and not be processed further.
-    SelectivityVector remainingRows = rows;
-    context.deselectErrors(remainingRows);
-    vector_size_t offset = 0;
-    context.applyToSelectedNoThrow(remainingRows, [&](auto row) {
-      if (rawNulls && countDecoded->isNullAt(row)) {
-        // Returns null if count argument is null.
-        // e.g. repeat('a', null) -> null
-        bits::setNull(rawNulls, row);
-        return;
-      }
-      auto count = countDecoded->valueAt<int32_t>(row);
-      rawSizes[row] = count;
-      rawOffsets[row] = offset;
-      std::fill(rawIndices + offset, rawIndices + offset + count, row);
-      offset += count;
-    });
-
-    return std::make_shared<ArrayVector>(
-        pool,
-        outputType,
-        nulls,
-        numRows,
-        offsets,
-        sizes,
-        BaseVector::wrapInDictionary(nullptr, indices, totalCount, args[0]));
-  }
-};
-
-static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-  // T, integer -> array(T)
-  return {exec::FunctionSignatureBuilder()
-              .typeVariable("T")
-              .returnType("array(T)")
-              .argumentType("T")
-              .argumentType("integer")
-              .build()};
-}
-} // namespace
-
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_repeat,
-    signatures(),
-    std::make_unique<RepeatFunction>());
-
-} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Reverse.cpp b/velox/functions/prestosql/Reverse.cpp
index 9f1861d90b017..0d97ba0114cdf 100644
--- a/velox/functions/prestosql/Reverse.cpp
+++ b/velox/functions/prestosql/Reverse.cpp
@@ -26,7 +26,12 @@ namespace facebook::velox::functions {
 ///  Takes any array as an input and returns the reversed array.
 ///
 ///  reverse(Varchar) -> Varchar
-///  Takes any Varchar as an input and returns the reversed varchar.
+///  Takes any string as an input and returns a string with characters in
+///  reverse order.
+///
+///  reverse(Varbinary) -> Varbinary
+///  Takes any binary as an input and returns a binary with bytes in reverse
+///  order.
 class ReverseFunction : public exec::VectorFunction {
  private:
   /// String encoding wrappable function
@@ -35,9 +40,9 @@ class ReverseFunction : public exec::VectorFunction {
     static void apply(
         const SelectivityVector& rows,
         const FlatVector<StringView>* input,
-        FlatVector<StringView>* results) {
+        FlatVector<StringView>* result) {
       rows.applyToSelected([&](int row) {
-        auto proxy = exec::StringWriter<>(results, row);
+        auto proxy = exec::StringWriter<>(result, row);
         stringImpl::reverse<isAscii>(proxy, input->valueAt(row).getString());
         proxy.finalize();
       });
@@ -53,38 +58,50 @@ class ReverseFunction : public exec::VectorFunction {
       VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
 
+    auto& arg = args[0];
+
     switch (args[0]->typeKind()) {
       case TypeKind::ARRAY:
-        applyArray(rows, args, context, result);
+        applyArray(rows, arg, context, result);
         return;
-      case TypeKind::VARCHAR:
-        applyVarchar(rows, args, context, result);
+      case TypeKind::VARCHAR: {
+        const auto ascii = isAscii(arg.get(), rows);
+        applyVarchar(rows, arg, ascii, context, result);
+        return;
+      }
+      case TypeKind::VARBINARY:
+        // The only difference betwen VARCHAR and VARBINARY input is that
+        // VARBINARY is reversed byte-by-byte, while VARCHAR is reversed
+        // character-by-character. Hence, VARINARY behavior is the same as
+        // VARCHAR with ascii flag set to true.
+        applyVarchar(rows, arg, true /*isAscii*/, context, result);
         return;
       default:
         VELOX_FAIL(
             "Unsupported input type for 'reverse' function: {}",
-            args[0]->type()->toString());
+            arg->type()->toString());
     }
   }
 
   void applyVarchar(
       const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
+      VectorPtr& arg,
+      bool isAscii,
       exec::EvalCtx& context,
       VectorPtr& result) const {
-    auto* arg = args[0].get();
-
-    auto ascii = isAscii(arg, rows);
+    // Capture the pointer to input argument. prepareFlatResultsVector may move
+    // it into result.
+    auto* originalArg = arg.get();
 
-    prepareFlatResultsVector(result, rows, context, args[0]);
+    prepareFlatResultsVector(result, rows, context, arg, arg->type());
     auto* flatResult = result->as<FlatVector<StringView>>();
 
     // Input can be constant or flat.
-    if (arg->isConstantEncoding()) {
-      auto value = arg->as<ConstantVector<StringView>>()->valueAt(0);
+    if (originalArg->isConstantEncoding()) {
+      auto value = originalArg->as<ConstantVector<StringView>>()->valueAt(0);
 
       auto proxy = exec::StringWriter<>(flatResult, rows.begin());
-      if (ascii) {
+      if (isAscii) {
         stringImpl::reverse<true>(proxy, value.str());
       } else {
         stringImpl::reverse<false>(proxy, value.str());
@@ -96,10 +113,10 @@ class ReverseFunction : public exec::VectorFunction {
 
       rows.applyToSelected([&](auto row) { rawResults[row] = reversedValue; });
     } else {
-      auto flatInput = arg->as<FlatVector<StringView>>();
+      auto flatInput = originalArg->as<FlatVector<StringView>>();
 
       StringEncodingTemplateWrapper<ApplyVarcharInternal>::apply(
-          ascii, rows, flatInput, flatResult);
+          isAscii, rows, flatInput, flatResult);
     }
   }
 
@@ -113,11 +130,9 @@ class ReverseFunction : public exec::VectorFunction {
 
   void applyArray(
       const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
+      VectorPtr& arg,
       exec::EvalCtx& context,
       VectorPtr& result) const {
-    auto& arg = args[0];
-
     VectorPtr localResult;
 
     // Input can be constant or flat.
@@ -189,6 +204,11 @@ class ReverseFunction : public exec::VectorFunction {
             .returnType("varchar")
             .argumentType("varchar")
             .build(),
+        // varbinary -> varbinary
+        exec::FunctionSignatureBuilder()
+            .returnType("varbinary")
+            .argumentType("varbinary")
+            .build(),
     };
   }
 };
diff --git a/velox/functions/prestosql/RowFunction.cpp b/velox/functions/prestosql/RowFunction.cpp
index 77e7ca03e8936..7d3ffdd6bd156 100644
--- a/velox/functions/prestosql/RowFunction.cpp
+++ b/velox/functions/prestosql/RowFunction.cpp
@@ -37,16 +37,13 @@ class RowFunction : public exec::VectorFunction {
         0 /*nullCount*/);
     context.moveOrCopyResult(row, rows, result);
   }
-
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_concat_row,
     std::vector<std::shared_ptr<exec::FunctionSignature>>{},
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<RowFunction>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SIMDJsonFunctions.h b/velox/functions/prestosql/SIMDJsonFunctions.h
deleted file mode 100644
index a4341e507ad87..0000000000000
--- a/velox/functions/prestosql/SIMDJsonFunctions.h
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/functions/Macros.h"
-#include "velox/functions/UDFOutputString.h"
-#include "velox/functions/prestosql/json/JsonPathTokenizer.h"
-#include "velox/functions/prestosql/json/SIMDJsonExtractor.h"
-#include "velox/functions/prestosql/json/SIMDJsonWrapper.h"
-#include "velox/functions/prestosql/types/JsonType.h"
-
-namespace facebook::velox::functions {
-
-struct ParserContext {
- public:
-  explicit ParserContext() noexcept;
-  explicit ParserContext(const char* data, size_t length) noexcept
-      : padded_json(data, length) {}
-  void parseElement() {
-    jsonEle = domParser.parse(padded_json);
-  }
-  void parseDocument() {
-    jsonDoc = ondemandParser.iterate(padded_json);
-  }
-  simdjson::dom::element jsonEle;
-  simdjson::ondemand::document jsonDoc;
-
- private:
-  simdjson::padded_string padded_json;
-  simdjson::dom::parser domParser;
-  simdjson::ondemand::parser ondemandParser;
-};
-
-template <typename T>
-struct SIMDIsJsonScalarFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  FOLLY_ALWAYS_INLINE void call(bool& result, const arg_type<Json>& json) {
-    ParserContext ctx(json.data(), json.size());
-
-    ctx.parseDocument();
-
-    result =
-        (ctx.jsonDoc.type() == simdjson::ondemand::json_type::number ||
-         ctx.jsonDoc.type() == simdjson::ondemand::json_type::string ||
-         ctx.jsonDoc.type() == simdjson::ondemand::json_type::boolean ||
-         ctx.jsonDoc.type() == simdjson::ondemand::json_type::null);
-  }
-};
-
-template <typename T>
-struct SIMDJsonArrayContainsFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-  template <typename TInput>
-  FOLLY_ALWAYS_INLINE bool
-  call(bool& result, const arg_type<Json>& json, const TInput& value) {
-    ParserContext ctx(json.data(), json.size());
-    result = false;
-
-    try {
-      ctx.parseDocument();
-    } catch (const simdjson::simdjson_error&) {
-      return false;
-    }
-
-    if (ctx.jsonDoc.type() != simdjson::ondemand::json_type::array) {
-      return false;
-    }
-
-    for (auto&& v : ctx.jsonDoc) {
-      try {
-        if constexpr (std::is_same_v<TInput, bool>) {
-          if (v.type() == simdjson::ondemand::json_type::boolean &&
-              v.get_bool() == value) {
-            result = true;
-            break;
-          }
-        } else if constexpr (std::is_same_v<TInput, int64_t>) {
-          if (v.type() == simdjson::ondemand::json_type::number &&
-              v.get_number_type() ==
-                  simdjson::ondemand::number_type::signed_integer &&
-              v.get_int64() == value) {
-            result = true;
-            break;
-          }
-        } else if constexpr (std::is_same_v<TInput, double>) {
-          if (v.type() == simdjson::ondemand::json_type::number &&
-              v.get_number_type() ==
-                  simdjson::ondemand::number_type::floating_point_number &&
-              v.get_double() == value) {
-            result = true;
-            break;
-          }
-        } else {
-          if (v.type() == simdjson::ondemand::json_type::string) {
-            std::string_view rlt = v.get_string();
-            std::string str_value{value.getString()};
-            if (rlt.compare(str_value) == 0) {
-              result = true;
-              break;
-            }
-          }
-        }
-      } catch (const simdjson::simdjson_error& e) {
-        // For bool/int64_t/double type, "get_bool()/get_int64()/get_double()"
-        // may throw an exception if the conversion of json value to the
-        // specified type failed, and the corresponding error code is
-        // "INCORRECT_TYPE" or "NUMBER_ERROR".
-        // If there are multiple json values in the json array, and some of them
-        // cannot be converted to the type of input `value`, it should not
-        // return null directly. It should continue to judge whether there is a
-        // json value that matches the input value, e.g.
-        // jsonArrayContains("[truet, false]", false) => true.
-        if (e.error() != simdjson::INCORRECT_TYPE &&
-            e.error() != simdjson::NUMBER_ERROR) {
-          return false;
-        }
-      }
-    }
-
-    return true;
-  }
-};
-
-template <typename T>
-struct SIMDJsonArrayLengthFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  FOLLY_ALWAYS_INLINE bool call(int64_t& len, const arg_type<Json>& json) {
-    ParserContext ctx(json.data(), json.size());
-
-    try {
-      ctx.parseDocument();
-    } catch (const simdjson::simdjson_error&) {
-      return false;
-    }
-
-    if (ctx.jsonDoc.type() != simdjson::ondemand::json_type::array) {
-      return false;
-    }
-
-    try {
-      len = ctx.jsonDoc.count_elements();
-    } catch (const simdjson::simdjson_error&) {
-      return false;
-    }
-
-    return true;
-  }
-};
-
-// jsonExtractScalar(json, json_path) -> varchar
-// Like jsonExtract(), but returns the result value as a string (as opposed
-// to being encoded as JSON). The value referenced by json_path must be a scalar
-// (boolean, number or string)
-template <typename T>
-struct SIMDJsonExtractScalarFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  FOLLY_ALWAYS_INLINE bool call(
-      out_type<Varchar>& result,
-      const arg_type<Json>& json,
-      const arg_type<Varchar>& jsonPath) {
-    bool resultPopulated = false;
-    std::optional<std::string> resultStr;
-    auto consumer = [&resultStr, &resultPopulated](auto& v) {
-      if (resultPopulated) {
-        // We should just get a single value, if we see multiple, it's an error
-        // and we should return null.
-        resultStr = std::nullopt;
-        return true;
-      }
-
-      resultPopulated = true;
-
-      SIMDJSON_ASSIGN_OR_RAISE(auto vtype, v.type());
-      switch (vtype) {
-        case simdjson::ondemand::json_type::boolean: {
-          SIMDJSON_ASSIGN_OR_RAISE(bool vbool, v.get_bool());
-          resultStr = vbool ? "true" : "false";
-          break;
-        }
-        case simdjson::ondemand::json_type::string: {
-          SIMDJSON_ASSIGN_OR_RAISE(resultStr, v.get_string());
-          break;
-        }
-        case simdjson::ondemand::json_type::object:
-        case simdjson::ondemand::json_type::array:
-        case simdjson::ondemand::json_type::null:
-          // Do nothing.
-          break;
-        default: {
-          SIMDJSON_ASSIGN_OR_RAISE(resultStr, simdjson::to_json_string(v));
-        }
-      }
-      return true;
-    };
-
-    if (!simdJsonExtract(json, jsonPath, consumer)) {
-      // If there's an error parsing the JSON, return null.
-      return false;
-    }
-
-    if (resultStr.has_value()) {
-      result.copy_from(*resultStr);
-      return true;
-    } else {
-      return false;
-    }
-  }
-};
-
-template <typename T>
-struct SIMDJsonExtractFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  bool call(
-      out_type<Json>& result,
-      const arg_type<Json>& json,
-      const arg_type<Varchar>& jsonPath) {
-    static constexpr std::string_view kNullString{"null"};
-    std::string results;
-    size_t resultSize = 0;
-    auto consumer = [&results, &resultSize](auto& v) {
-      // Add the separator for the JSON array.
-      if (resultSize++ > 0) {
-        results += ",";
-      }
-      // We could just convert v to a string using to_json_string directly, but
-      // in that case the JSON wouldn't be parsed (it would just return the
-      // contents directly) and we might miss invalid JSON.
-      SIMDJSON_ASSIGN_OR_RAISE(auto vtype, v.type());
-      switch (vtype) {
-        case simdjson::ondemand::json_type::object: {
-          SIMDJSON_ASSIGN_OR_RAISE(
-              auto jsonStr, simdjson::to_json_string(v.get_object()));
-          results += jsonStr;
-          break;
-        }
-        case simdjson::ondemand::json_type::array: {
-          SIMDJSON_ASSIGN_OR_RAISE(
-              auto jsonStr, simdjson::to_json_string(v.get_array()));
-          results += jsonStr;
-          break;
-        }
-        case simdjson::ondemand::json_type::string:
-        case simdjson::ondemand::json_type::number:
-        case simdjson::ondemand::json_type::boolean: {
-          SIMDJSON_ASSIGN_OR_RAISE(auto jsonStr, simdjson::to_json_string(v));
-          results += jsonStr;
-          break;
-        }
-        case simdjson::ondemand::json_type::null:
-          results += kNullString;
-          break;
-      }
-      return true;
-    };
-
-    if (!simdJsonExtract(json, jsonPath, consumer)) {
-      // If there's an error parsing the JSON, return null.
-      return false;
-    }
-
-    if (resultSize == 0) {
-      // If the path didn't map to anything in the JSON object, return null.
-      return false;
-    }
-
-    if (resultSize == 1) {
-      // If there was only one value mapped to by the path, don't wrap it in an
-      // array.
-      result.copy_from(results);
-    } else {
-      // Add the square brackets to make it a valid JSON array.
-      result.copy_from("[" + results + "]");
-    }
-    return true;
-  }
-};
-
-template <typename T>
-struct SIMDJsonSizeFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  FOLLY_ALWAYS_INLINE bool call(
-      int64_t& result,
-      const arg_type<Json>& json,
-      const arg_type<Varchar>& jsonPath) {
-    size_t resultCount = 0;
-    size_t singleResultSize = 0;
-    auto consumer = [&resultCount, &singleResultSize](auto& v) {
-      resultCount++;
-
-      if (resultCount == 1) {
-        // We only need the size of the actual object if there's only one
-        // returned, if multiple are returned we use the number of objects
-        // returned instead.
-        SIMDJSON_ASSIGN_OR_RAISE(auto vtype, v.type());
-        switch (vtype) {
-          case simdjson::ondemand::json_type::object: {
-            SIMDJSON_ASSIGN_OR_RAISE(singleResultSize, v.count_fields());
-            break;
-          }
-          case simdjson::ondemand::json_type::array: {
-            SIMDJSON_ASSIGN_OR_RAISE(singleResultSize, v.count_elements());
-            break;
-          }
-          case simdjson::ondemand::json_type::string:
-          case simdjson::ondemand::json_type::number:
-          case simdjson::ondemand::json_type::boolean:
-          case simdjson::ondemand::json_type::null:
-            singleResultSize = 0;
-            break;
-        }
-      }
-      return true;
-    };
-
-    if (!simdJsonExtract(json, jsonPath, consumer)) {
-      // If there's an error parsing the JSON, return null.
-      return false;
-    }
-
-    if (resultCount == 0) {
-      // If the path didn't map to anything in the JSON object, return null.
-      return false;
-    }
-
-    result = resultCount == 1 ? singleResultSize : resultCount;
-
-    return true;
-  }
-};
-
-} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Sequence.cpp b/velox/functions/prestosql/Sequence.cpp
index a6328272d0b73..d8da1fde76684 100644
--- a/velox/functions/prestosql/Sequence.cpp
+++ b/velox/functions/prestosql/Sequence.cpp
@@ -44,31 +44,36 @@ int64_t toInt64(Timestamp value) {
 using Days = int64_t;
 using Months = int32_t;
 template <typename T, typename K>
-T add(T value, K steps);
+T add(T value, K step, int32_t sequence);
 
 template <>
-int64_t add(int64_t value, int64_t steps) {
-  return value + steps;
+int64_t add(int64_t value, int64_t step, int32_t sequence) {
+  const auto delta = (int128_t)step * (int128_t)sequence;
+  // Since step is calcuated from start and stop,
+  // the sum of 'value' and 'add' is within int64_t.
+  return value + delta;
 }
 
 template <>
-int32_t add(int32_t value, int64_t steps) {
-  return value + steps;
+int32_t add(int32_t value, int64_t step, int32_t sequence) {
+  const auto delta = (int128_t)step * (int128_t)sequence;
+  return value + delta;
 }
 
 template <>
-Timestamp add(Timestamp value, int64_t steps) {
-  return Timestamp::fromMillis(value.toMillis() + steps);
+Timestamp add(Timestamp value, int64_t step, int32_t sequence) {
+  const auto delta = (int128_t)step * (int128_t)sequence;
+  return Timestamp::fromMillis(value.toMillis() + delta);
 }
 
 template <>
-int32_t add(int32_t value, Months steps) {
-  return addToDate(value, DateTimeUnit::kMonth, steps);
+int32_t add(int32_t value, Months step, int32_t sequence) {
+  return addToDate(value, DateTimeUnit::kMonth, step * sequence);
 }
 
 template <>
-Timestamp add(Timestamp value, Months steps) {
-  return addToTimestamp(value, DateTimeUnit::kMonth, steps);
+Timestamp add(Timestamp value, Months step, int32_t sequence) {
+  return addToTimestamp(value, DateTimeUnit::kMonth, step * sequence);
 }
 
 template <typename T>
@@ -171,7 +176,7 @@ class SequenceFunction : public exec::VectorFunction {
     VELOX_USER_CHECK(
         step > 0 ? stop >= start : stop <= start,
         "sequence stop value should be greater than or equal to start value if "
-        "step is greater than zero otherwise stop should be less than or equal to start")
+        "step is greater than zero otherwise stop should be less than or equal to start");
     int128_t sequenceCount;
     if (isYearMonth) {
       sequenceCount = getStepCount(start, stop, step);
@@ -200,8 +205,8 @@ class SequenceFunction : public exec::VectorFunction {
     auto stop = stopVector->valueAt<T>(row);
     auto step = getStep(
         toInt64(start), toInt64(stop), stepVector, row, isDate, isYearMonth);
-    for (auto i = 0; i < sequenceCount; ++i) {
-      elements[i] = add(start, (K)(step * i));
+    for (auto sequence = 0; sequence < sequenceCount; ++sequence) {
+      elements[sequence] = add(start, step, sequence);
     }
   }
 
diff --git a/velox/functions/prestosql/SplitToMap.cpp b/velox/functions/prestosql/SplitToMap.cpp
new file mode 100644
index 0000000000000..29360136fee86
--- /dev/null
+++ b/velox/functions/prestosql/SplitToMap.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/SplitToMap.h"
+
+namespace facebook::velox::functions {
+
+namespace {
+
+core::CallTypedExprPtr asSplitToMapCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr) {
+  if (auto call = std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
+    if (call->name() == prefix + "split_to_map") {
+      return call;
+    }
+  }
+  return nullptr;
+}
+
+} // namespace
+
+core::TypedExprPtr rewriteSplitToMapCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr) {
+  const auto call = asSplitToMapCall(prefix, expr);
+  if (call == nullptr || call->inputs().size() != 4) {
+    return nullptr;
+  }
+
+  const auto* lambda =
+      dynamic_cast<const core::LambdaTypedExpr*>(call->inputs()[3].get());
+  VELOX_CHECK_NOT_NULL(lambda);
+
+  const auto v1 = lambda->signature()->nameOf(1);
+  const auto v2 = lambda->signature()->nameOf(2);
+
+  const auto& body = lambda->body();
+  std::optional<bool> keepFirst;
+  if (auto field =
+          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(body)) {
+    if (field->isInputColumn()) {
+      if (field->name() == v1) {
+        keepFirst = true;
+      } else if (field->name() == v2) {
+        keepFirst = false;
+      }
+    }
+  }
+
+  if (!keepFirst.has_value()) {
+    static const std::string kNotSupported =
+        "split_to_map with arbitrary lambda is not supported: {}";
+    VELOX_USER_FAIL(kNotSupported, lambda->toString());
+  }
+
+  return std::make_shared<core::CallTypedExpr>(
+      call->type(),
+      std::vector<core::TypedExprPtr>{
+          call->inputs()[0],
+          call->inputs()[1],
+          call->inputs()[2],
+          std::make_shared<core::ConstantTypedExpr>(
+              BOOLEAN(), keepFirst.value())},
+      "$internal$split_to_map");
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SplitToMap.h b/velox/functions/prestosql/SplitToMap.h
index ce8ef193aea5a..a278bfef4f05e 100644
--- a/velox/functions/prestosql/SplitToMap.h
+++ b/velox/functions/prestosql/SplitToMap.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "folly/container/F14Set.h"
+#include "velox/common/base/Status.h"
 #include "velox/functions/Udf.h"
 
 namespace facebook::velox::functions {
@@ -27,27 +28,32 @@ struct SplitToMapFunction {
   // Results refer to strings in the first argument.
   static constexpr int32_t reuse_strings_from_arg = 0;
 
-  void call(
+  Status call(
       out_type<Map<Varchar, Varchar>>& out,
       const arg_type<Varchar>& input,
       const arg_type<Varchar>& entryDelimiter,
       const arg_type<Varchar>& keyValueDelimiter) {
-    VELOX_USER_CHECK(!entryDelimiter.empty(), "entryDelimiter is empty");
-    VELOX_USER_CHECK(!keyValueDelimiter.empty(), "keyValueDelimiter is empty");
-    VELOX_USER_CHECK_NE(
-        entryDelimiter,
-        keyValueDelimiter,
-        "entryDelimiter and keyValueDelimiter must not be the same");
-
-    if (input.empty()) {
-      return;
-    }
+    return callImpl(
+        out,
+        toStringView(input),
+        toStringView(entryDelimiter),
+        toStringView(keyValueDelimiter),
+        OnDuplicateKey::kFail);
+  }
 
-    callImpl(
+  Status call(
+      out_type<Map<Varchar, Varchar>>& out,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& entryDelimiter,
+      const arg_type<Varchar>& keyValueDelimiter,
+      const arg_type<bool>& keepFirstOrLast) {
+    return callImpl(
         out,
         toStringView(input),
         toStringView(entryDelimiter),
-        toStringView(keyValueDelimiter));
+        toStringView(keyValueDelimiter),
+        keepFirstOrLast ? OnDuplicateKey::kKeepFirst
+                        : OnDuplicateKey::kKeepLast);
   }
 
  private:
@@ -55,58 +61,138 @@ struct SplitToMapFunction {
     return std::string_view(input.data(), input.size());
   }
 
-  void callImpl(
+  enum class OnDuplicateKey {
+    // Raise an error if there are duplicate keys.
+    kFail,
+
+    // Keep the first value for each key.
+    kKeepFirst,
+
+    // Keep the last value for each key.
+    kKeepLast,
+  };
+
+  Status callImpl(
       out_type<Map<Varchar, Varchar>>& out,
       std::string_view input,
       std::string_view entryDelimiter,
-      std::string_view keyValueDelimiter) const {
+      std::string_view keyValueDelimiter,
+      OnDuplicateKey onDuplicateKey) const {
+    VELOX_RETURN_IF(
+        entryDelimiter.empty(), Status::UserError("entryDelimiter is empty"));
+    VELOX_RETURN_IF(
+        keyValueDelimiter.empty(),
+        Status::UserError("keyValueDelimiter is empty"));
+    VELOX_RETURN_IF(
+        entryDelimiter == keyValueDelimiter,
+        Status::UserError(
+            "entryDelimiter and keyValueDelimiter must not be the same: {}",
+            entryDelimiter));
+
+    if (input.empty()) {
+      return Status::OK();
+    }
+
     size_t pos = 0;
 
-    folly::F14FastSet<std::string_view> keys;
+    folly::F14FastMap<std::string_view, std::string_view> keyValuePairs;
 
     auto nextEntryPos = input.find(entryDelimiter, pos);
     while (nextEntryPos != std::string::npos) {
-      processEntry(
-          out,
+      VELOX_RETURN_NOT_OK(processEntry(
           std::string_view(input.data() + pos, nextEntryPos - pos),
           keyValueDelimiter,
-          keys);
+          onDuplicateKey,
+          keyValuePairs));
 
-      pos = nextEntryPos + 1;
+      pos = nextEntryPos + entryDelimiter.size();
       nextEntryPos = input.find(entryDelimiter, pos);
     }
 
-    processEntry(
-        out,
-        std::string_view(input.data() + pos, input.size() - pos),
-        keyValueDelimiter,
-        keys);
+    // Entry delimiter can be the last character in the input. In this case
+    // there is no last entry to process.
+    if (pos < input.size()) {
+      VELOX_RETURN_NOT_OK(processEntry(
+          std::string_view(input.data() + pos, input.size() - pos),
+          keyValueDelimiter,
+          onDuplicateKey,
+          keyValuePairs));
+    }
+
+    out.reserve(keyValuePairs.size());
+    for (auto& [key, value] : keyValuePairs) {
+      auto [keyWriter, valueWriter] = out.add_item();
+      keyWriter.setNoCopy(StringView(key));
+      valueWriter.setNoCopy(StringView(value));
+    }
+
+    return Status::OK();
   }
 
-  void processEntry(
-      out_type<Map<Varchar, Varchar>>& out,
+  Status processEntry(
       std::string_view entry,
       std::string_view keyValueDelimiter,
-      folly::F14FastSet<std::string_view>& keys) const {
+      OnDuplicateKey onDuplicateKey,
+      folly::F14FastMap<std::string_view, std::string_view>& keyValuePairs)
+      const {
     const auto delimiterPos = entry.find(keyValueDelimiter, 0);
 
-    VELOX_USER_CHECK_NE(
-        delimiterPos,
-        std::string::npos,
-        "Key-value delimiter must appear exactly once in each entry. Bad input: '{}'",
-        entry)
+    VELOX_RETURN_IF(
+        delimiterPos == std::string::npos,
+        Status::UserError(
+            "No delimiter found. Key-value delimiter must appear exactly once in each entry. Bad input: '{}'",
+            entry));
+    VELOX_RETURN_IF(
+        entry.find(
+            keyValueDelimiter, delimiterPos + keyValueDelimiter.size()) !=
+            std::string::npos,
+        Status::UserError(
+            "More than one delimiter found. Key-value delimiter must appear exactly once in each entry. Bad input: '{}'",
+            entry));
 
     const auto key = std::string_view(entry.data(), delimiterPos);
-    VELOX_USER_CHECK(
-        keys.insert(key).second, "Duplicate keys ({}) are not allowed.", key);
-
-    const auto value = StringView(
-        entry.data() + delimiterPos + 1, entry.size() - delimiterPos - 1);
+    const auto value = std::string_view(
+        entry.data() + delimiterPos + keyValueDelimiter.size(),
+        entry.size() - delimiterPos - keyValueDelimiter.size());
+
+    switch (onDuplicateKey) {
+      case OnDuplicateKey::kFail: {
+        if (!keyValuePairs.emplace(key, value).second) {
+          return Status::UserError("Duplicate keys ({}) are not allowed.", key);
+        }
+        break;
+      }
+      case OnDuplicateKey::kKeepFirst:
+        keyValuePairs.try_emplace(key, value);
+        break;
+      case OnDuplicateKey::kKeepLast:
+        keyValuePairs[key] = value;
+        break;
+    }
 
-    auto [keyWriter, valueWriter] = out.add_item();
-    keyWriter.setNoCopy(StringView(key));
-    valueWriter.setNoCopy(value);
+    return Status::OK();
   }
 };
 
+/// Analyzes split_to_map(string, entryDelim, keyDelim, lambda) call
+/// to determine whether 'lambda' indicates keeping first or last value
+/// for each key. If so, rewrites the call using $internal$split_to_map.
+///
+/// For example,
+///
+/// Rewrites
+///     split_to_map(s, ed, kd, (k, v1, v2) -> v1
+/// into
+///     $internal$split_to_map(s, ed, kd, true) -- keep first
+///
+/// and
+///     split_to_map(s, ed, kd, (k, v1, v2) -> v2
+/// into
+///     $internal$split_to_map(s, ed, kd, false) -- keep last
+///
+/// Returns new expression or nullptr if rewrite is not possible.
+core::TypedExprPtr rewriteSplitToMapCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr);
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/StringFunctions.cpp b/velox/functions/prestosql/StringFunctions.cpp
index b6387c2f4631d..a90a0ee7e62d4 100644
--- a/velox/functions/prestosql/StringFunctions.cpp
+++ b/velox/functions/prestosql/StringFunctions.cpp
@@ -76,10 +76,6 @@ class UpperLowerTemplateFunction : public exec::VectorFunction {
   }
 
  public:
-  bool isDefaultNullBehavior() const override {
-    return true;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -197,10 +193,10 @@ class ConcatFunction : public exec::VectorFunction {
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
-      const TypePtr& /* outputType */,
+      const TypePtr& outputType,
       exec::EvalCtx& context,
       VectorPtr& result) const override {
-    context.ensureWritable(rows, VARCHAR(), result);
+    context.ensureWritable(rows, outputType, result);
     auto flatResult = result->asFlatVector<StringView>();
 
     auto numArgs = argMapping_.size();
@@ -256,13 +252,20 @@ class ConcatFunction : public exec::VectorFunction {
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    // varchar, varchar,.. -> varchar
-    return {exec::FunctionSignatureBuilder()
-                .returnType("varchar")
-                .argumentType("varchar")
-                .argumentType("varchar")
-                .variableArity()
-                .build()};
+    return {
+        // varchar, varchar,.. -> varchar
+        exec::FunctionSignatureBuilder()
+            .returnType("varchar")
+            .argumentType("varchar")
+            .variableArity("varchar")
+            .build(),
+        // varbinary, varbinary,.. -> varbinary
+        exec::FunctionSignatureBuilder()
+            .returnType("varbinary")
+            .argumentType("varbinary")
+            .variableArity("varbinary")
+            .build(),
+    };
   }
 
   static exec::VectorFunctionMetadata metadata() {
diff --git a/velox/functions/prestosql/StringFunctions.h b/velox/functions/prestosql/StringFunctions.h
index 391b8996a169d..22d3ea26ccb8c 100644
--- a/velox/functions/prestosql/StringFunctions.h
+++ b/velox/functions/prestosql/StringFunctions.h
@@ -121,8 +121,8 @@ struct SubstrFunction {
       length = numCharacters - start + 1;
     }
 
-    auto byteRange =
-        stringCore::getByteRange<isAscii>(input.data(), start, length);
+    auto byteRange = stringCore::getByteRange<isAscii>(
+        input.data(), input.size(), start, length);
 
     // Generating output string
     result.setNoCopy(StringView(
@@ -130,6 +130,42 @@ struct SubstrFunction {
   }
 };
 
+template <typename TExec>
+struct SubstrVarbinaryFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // Results refer to strings in the first argument.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      int64_t start,
+      int64_t length = std::numeric_limits<int64_t>::max()) {
+    if (start == 0 || length <= 0) {
+      result.setEmpty();
+      return;
+    }
+
+    int64_t size = input.size();
+
+    if (start < 0) {
+      start = size + start + 1;
+    }
+
+    if (start <= 0 || start > size) {
+      result.setEmpty();
+      return;
+    }
+
+    if (size - start + 1 < length) {
+      length = size - start + 1;
+    }
+
+    result.setNoCopy(StringView(input.data() + start - 1, length));
+  }
+};
+
 /// Trim functions
 /// ltrim(string) -> varchar
 ///    Removes leading whitespaces from the string.
@@ -341,6 +377,70 @@ struct StrLPosFunction : public StrPosFunctionBase<T, true> {};
 template <typename T>
 struct StrRPosFunction : public StrPosFunctionBase<T, false> {};
 
+/// hamming_distance(string, string) -> bigint
+/// Computes the hamming distance between two strings.
+template <typename T>
+struct HammingDistanceFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(
+      out_type<int64_t>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    int64_t leftLength = left.size();
+    int64_t rightLength = right.size();
+
+    int64_t distance = 0;
+    int64_t leftPosition = 0;
+    int64_t rightPosition = 0;
+    while (leftPosition < leftLength && rightPosition < rightLength) {
+      int leftSize = 0;
+      int rightSize = 0;
+      auto codePointLeft = utf8proc_codepoint(
+          left.data() + leftPosition, left.data() + leftLength, leftSize);
+      auto codePointRight = utf8proc_codepoint(
+          right.data() + rightPosition, right.data() + rightLength, rightSize);
+
+      // if both code points are invalid, we do not care if they are equal
+      // the following code treats them as equal if they happen to be of the
+      // same length
+      leftPosition += codePointLeft >= 0 ? leftSize : -codePointLeft;
+      rightPosition += codePointRight >= 0 ? rightSize : -codePointRight;
+
+      if (codePointLeft != codePointRight) {
+        distance++;
+      }
+    }
+    VELOX_USER_CHECK(
+        leftPosition == leftLength && rightPosition == rightLength,
+        "The input strings to hamming_distance function must have the same length");
+
+    result = distance;
+  }
+
+  void callAscii(
+      out_type<int64_t>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    int64_t leftLength = left.size();
+    int64_t rightLength = right.size();
+    VELOX_USER_CHECK_EQ(
+        leftLength,
+        rightLength,
+        "The input strings to hamming_distance function must have the same length");
+
+    auto leftCodePoints = reinterpret_cast<const uint8_t*>(left.data());
+    auto rightCodePoints = reinterpret_cast<const uint8_t*>(right.data());
+    int64_t distance = 0;
+    for (int i = 0; i < leftLength; i++) {
+      if (leftCodePoints[i] != rightCodePoints[i]) {
+        distance++;
+      }
+    }
+    result = distance;
+  }
+};
+
 template <typename T>
 struct LevenshteinDistanceFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -430,4 +530,66 @@ struct LevenshteinDistanceFunction {
   }
 };
 
+template <typename T>
+struct NormalizeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Map for holding normalization form options
+  const static inline std::unordered_map<std::string, utf8proc_int16_t>
+      normalizationOptions{
+          {"NFC", (UTF8PROC_STABLE | UTF8PROC_COMPOSE)},
+          {"NFD", (UTF8PROC_STABLE | UTF8PROC_DECOMPOSE)},
+          {"NFKC", (UTF8PROC_STABLE | UTF8PROC_COMPOSE | UTF8PROC_COMPAT)},
+          {"NFKD", (UTF8PROC_STABLE | UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT)}};
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Varchar>* /*string*/,
+      const arg_type<Varchar>* form) {
+    VELOX_USER_CHECK_NOT_NULL(form);
+    VELOX_USER_CHECK_NE(
+        normalizationOptions.count(*form),
+        0,
+        "Normalization form must be one of [NFD, NFC, NFKD, NFKC]");
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& string) {
+    doCall(result, string, "NFC");
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& string,
+      const arg_type<Varchar>& form) {
+    doCall(result, string, form);
+  }
+
+  // Note: This function newly allocates output using malloc so it should be
+  // free'd at the end.
+  FOLLY_ALWAYS_INLINE void doCall(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& string,
+      const arg_type<Varchar>& form) {
+    utf8proc_uint8_t* output = nullptr;
+    auto outputLength = utf8proc_map(
+        (utf8proc_uint8_t*)string.data(),
+        string.size(),
+        &output,
+        normalizationOptions.at(form));
+    if (outputLength < 0) {
+      result = string;
+    } else {
+      result.resize(outputLength);
+      if (result.data()) {
+        std::memcpy(
+            result.data(), reinterpret_cast<const char*>(output), outputLength);
+      }
+    }
+    free(output);
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Subscript.cpp b/velox/functions/prestosql/Subscript.cpp
index 269583463f941..72c648f5e0360 100644
--- a/velox/functions/prestosql/Subscript.cpp
+++ b/velox/functions/prestosql/Subscript.cpp
@@ -31,6 +31,8 @@ class SubscriptFunction : public SubscriptImpl<
                               /* allowOutOfBound */ false,
                               /* indexStartsAtOne */ true> {
  public:
+  explicit SubscriptFunction(bool allowcaching) : SubscriptImpl(allowcaching) {}
+
   bool canPushdown() const override {
     return true;
   }
@@ -38,9 +40,25 @@ class SubscriptFunction : public SubscriptImpl<
 
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_subscript,
-    SubscriptFunction::signatures(),
-    std::make_unique<SubscriptFunction>());
+void registerSubscriptFunction(
+    const std::string& name,
+    bool enableCaching = true) {
+  exec::registerStatefulVectorFunction(
+      name,
+      SubscriptFunction::signatures(),
+      [enableCaching](
+          const std::string&,
+          const std::vector<exec::VectorFunctionArg>& inputArgs,
+          const velox::core::QueryConfig& config) {
+        static const auto kSubscriptStateLess =
+            std::make_shared<SubscriptFunction>(false);
+        if (inputArgs[0].type->isArray()) {
+          return kSubscriptStateLess;
+        } else {
+          return std::make_shared<SubscriptFunction>(
+              enableCaching && config.isExpressionEvaluationCacheEnabled());
+        }
+      });
+}
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Transform.cpp b/velox/functions/prestosql/Transform.cpp
index 562986ce7963e..3028a2c256d18 100644
--- a/velox/functions/prestosql/Transform.cpp
+++ b/velox/functions/prestosql/Transform.cpp
@@ -25,14 +25,6 @@ namespace {
 // See documentation at https://prestodb.io/docs/current/functions/array.html
 class TransformFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    // transform is null preserving for the array. But since an
-    // expr tree with a lambda depends on all named fields, including
-    // captures, a null in a capture does not automatically make a
-    // null result.
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -85,7 +77,7 @@ class TransformFunction : public exec::VectorFunction {
         flatArray->pool(),
         outputType,
         std::move(newNulls),
-        flatArray->size(),
+        rows.end(),
         flatArray->offsets(),
         flatArray->sizes(),
         newElements);
@@ -105,9 +97,15 @@ class TransformFunction : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+/// transform is null preserving for the array. But since an
+/// expr tree with a lambda depends on all named fields, including
+/// captures, a null in a capture does not automatically make a
+/// null result.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_transform,
     TransformFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<TransformFunction>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/TransformKeys.cpp b/velox/functions/prestosql/TransformKeys.cpp
index 117021f26e642..8e0aaac36b0f7 100644
--- a/velox/functions/prestosql/TransformKeys.cpp
+++ b/velox/functions/prestosql/TransformKeys.cpp
@@ -26,14 +26,6 @@ namespace {
 // See documentation at https://prestodb.io/docs/current/functions/map.html
 class TransformKeysFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    // transform_keys is null preserving for the map. But
-    // since an expr tree with a lambda depends on all named fields, including
-    // captures, a null in a capture does not automatically make a
-    // null result.
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -59,6 +51,8 @@ class TransformKeysFunction : public exec::VectorFunction {
 
     auto elementToTopLevelRows =
         getElementToTopLevelRows(numKeys, rows, flatMap.get(), context.pool());
+    const auto* rawElementToTopLevelRows =
+        elementToTopLevelRows->as<vector_size_t>();
 
     // Loop over lambda functions and apply these to keys of the map.
     // In most cases there will be only one function and the loop will run once.
@@ -77,22 +71,48 @@ class TransformKeysFunction : public exec::VectorFunction {
           lambdaArgs,
           elementToTopLevelRows,
           &transformedKeys);
+
+      if (transformedKeys->mayHaveNulls() ||
+          transformedKeys->mayHaveNullsRecursive()) {
+        static const char* kNullKeyErrorMessage = "map key cannot be null";
+        static const char* kIndeterminateKeyErrorMessage =
+            "map key cannot be indeterminate";
+
+        keyRows.applyToSelected([&](vector_size_t keyRow) {
+          try {
+            VELOX_USER_CHECK(
+                !transformedKeys->isNullAt(keyRow), kNullKeyErrorMessage);
+
+            VELOX_USER_CHECK(
+                !transformedKeys->containsNullAt(keyRow),
+                "{}: {}",
+                kIndeterminateKeyErrorMessage,
+                transformedKeys->toString(keyRow));
+          } catch (VeloxException&) {
+            context.setVeloxExceptionError(
+                rawElementToTopLevelRows[keyRow], std::current_exception());
+          }
+        });
+      }
     }
 
-    // Set nulls for rows not present in 'rows'.
-    BufferPtr newNulls = addNullsForUnselectedRows(flatMap, rows);
+    exec::LocalSelectivityVector remainingRows(context, rows);
+    context.deselectErrors(*remainingRows);
+
+    // Set nulls for rows not present in 'remainingRows'.
+    BufferPtr newNulls = addNullsForUnselectedRows(flatMap, *remainingRows);
 
     auto localResult = std::make_shared<MapVector>(
         flatMap->pool(),
         outputType,
         std::move(newNulls),
-        flatMap->size(),
+        rows.end(),
         flatMap->offsets(),
         flatMap->sizes(),
         transformedKeys,
         flatMap->mapValues());
 
-    checkDuplicateKeys(localResult, rows, context);
+    checkDuplicateKeys(localResult, *remainingRows, context);
 
     context.moveOrCopyResult(localResult, rows, result);
   }
@@ -111,9 +131,15 @@ class TransformKeysFunction : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+/// transform_keys is null preserving for the map. But
+/// since an expr tree with a lambda depends on all named fields, including
+/// captures, a null in a capture does not automatically make a
+/// null result.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_transform_keys,
     TransformKeysFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<TransformKeysFunction>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/TransformValues.cpp b/velox/functions/prestosql/TransformValues.cpp
index 652c9945b38d1..d46e48c001888 100644
--- a/velox/functions/prestosql/TransformValues.cpp
+++ b/velox/functions/prestosql/TransformValues.cpp
@@ -25,14 +25,6 @@ namespace {
 // See documentation at https://prestodb.io/docs/current/functions/map.html
 class TransformValuesFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    // transform_values is null preserving for the map. But
-    // since an expr tree with a lambda depends on all named fields, including
-    // captures, a null in a capture does not automatically make a
-    // null result.
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -85,7 +77,7 @@ class TransformValuesFunction : public exec::VectorFunction {
         flatMap->pool(),
         outputType,
         std::move(newNulls),
-        flatMap->size(),
+        rows.end(),
         flatMap->offsets(),
         flatMap->sizes(),
         flatMap->mapKeys(),
@@ -107,9 +99,15 @@ class TransformValuesFunction : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+/// transform_values is null preserving for the map. But
+/// since an expr tree with a lambda depends on all named fields, including
+/// captures, a null in a capture does not automatically make a
+/// null result.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_transform_values,
     TransformValuesFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<TransformValuesFunction>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/TypeOf.cpp b/velox/functions/prestosql/TypeOf.cpp
new file mode 100644
index 0000000000000..622f0133903fd
--- /dev/null
+++ b/velox/functions/prestosql/TypeOf.cpp
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/prestosql/types/UuidType.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+std::string typeName(const TypePtr& type) {
+  switch (type->kind()) {
+    case TypeKind::BOOLEAN:
+      return "boolean";
+    case TypeKind::TINYINT:
+      return "tinyint";
+    case TypeKind::SMALLINT:
+      return "smallint";
+    case TypeKind::INTEGER:
+      if (type->isDate()) {
+        return "date";
+      }
+      if (type->isIntervalYearMonth()) {
+        return "interval year to month";
+      }
+      return "integer";
+    case TypeKind::BIGINT:
+      if (isTimestampWithTimeZoneType(type)) {
+        return "timestamp with time zone";
+      }
+      if (type->isIntervalDayTime()) {
+        return "interval day to second";
+      }
+      if (type->isDecimal()) {
+        const auto& shortDecimal = type->asShortDecimal();
+        return fmt::format(
+            "decimal({},{})", shortDecimal.precision(), shortDecimal.scale());
+      }
+      return "bigint";
+    case TypeKind::HUGEINT: {
+      if (isUuidType(type)) {
+        return "uuid";
+      } else if (isIPAddressType(type)) {
+        return "ipaddress";
+      }
+      VELOX_USER_CHECK(
+          type->isDecimal(),
+          "Expected decimal type. Got: {}",
+          type->toString());
+      const auto& longDecimal = type->asLongDecimal();
+      return fmt::format(
+          "decimal({},{})", longDecimal.precision(), longDecimal.scale());
+    }
+    case TypeKind::REAL:
+      return "real";
+    case TypeKind::DOUBLE:
+      return "double";
+    case TypeKind::VARCHAR:
+      if (isJsonType(type)) {
+        return "json";
+      }
+      return "varchar";
+    case TypeKind::VARBINARY:
+      if (isHyperLogLogType(type)) {
+        return "HyperLogLog";
+      }
+      return "varbinary";
+    case TypeKind::TIMESTAMP:
+      return "timestamp";
+    case TypeKind::ARRAY:
+      return fmt::format("array({})", typeName(type->childAt(0)));
+    case TypeKind::MAP:
+      return fmt::format(
+          "map({}, {})",
+          typeName(type->childAt(0)),
+          typeName(type->childAt(1)));
+    case TypeKind::ROW: {
+      const auto& rowType = type->asRow();
+      std::ostringstream out;
+      out << "row(";
+      for (auto i = 0; i < type->size(); ++i) {
+        if (i > 0) {
+          out << ", ";
+        }
+        if (!rowType.nameOf(i).empty()) {
+          out << "\"" << rowType.nameOf(i) << "\" ";
+        }
+        out << typeName(type->childAt(i));
+      }
+      out << ")";
+      return out.str();
+    }
+    case TypeKind::UNKNOWN:
+      return "unknown";
+    default:
+      VELOX_UNSUPPORTED("Unsupported type: {}", type->toString());
+  }
+}
+
+class TypeOfFunction : public exec::VectorFunction {
+ public:
+  TypeOfFunction(const TypePtr& type) : typeName_{typeName(type)} {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /* outputType */,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    auto localResult = BaseVector::createConstant(
+        VARCHAR(), typeName_, rows.size(), context.pool());
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    // T -> varchar
+    return {exec::FunctionSignatureBuilder()
+                .typeVariable("T")
+                .returnType("varchar")
+                .argumentType("T")
+                .build()};
+  }
+
+  static std::shared_ptr<exec::VectorFunction> create(
+      const std::string& /*name*/,
+      const std::vector<exec::VectorFunctionArg>& inputArgs,
+      const core::QueryConfig& /*config*/) {
+    try {
+      return std::make_shared<TypeOfFunction>(inputArgs[0].type);
+    } catch (...) {
+      return std::make_shared<exec::AlwaysFailingVectorFunction>(
+          std::current_exception());
+    }
+  }
+
+ private:
+  const std::string typeName_;
+};
+} // namespace
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION_WITH_METADATA(
+    udf_typeof,
+    TypeOfFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
+    TypeOfFunction::create);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/URLFunctions.cpp b/velox/functions/prestosql/URLFunctions.cpp
index 7320cd0731898..d943cdf183c78 100644
--- a/velox/functions/prestosql/URLFunctions.cpp
+++ b/velox/functions/prestosql/URLFunctions.cpp
@@ -15,25 +15,24 @@
  */
 
 #include "URLFunctions.h"
+#include <optional>
 #include "velox/type/Type.h"
 
-namespace facebook::velox::functions {
+namespace facebook::velox::functions::detail {
 
-bool matchAuthorityAndPath(
-    const boost::cmatch& urlMatch,
-    boost::cmatch& authAndPathMatch,
+std::optional<StringView> matchAuthorityAndPath(
+    StringView authorityAndPath,
     boost::cmatch& authorityMatch,
-    bool& hasAuthority) {
+    int subGroup) {
+  boost::cmatch authAndPathMatch;
   static const boost::regex kAuthorityAndPathRegex("//([^/]*)(/.*)?");
-  auto authorityAndPath = submatch(urlMatch, 2);
   if (!boost::regex_match(
           authorityAndPath.begin(),
           authorityAndPath.end(),
           authAndPathMatch,
           kAuthorityAndPathRegex)) {
     // Does not start with //, doesn't have authority.
-    hasAuthority = false;
-    return true;
+    return std::nullopt;
   }
 
   static const boost::regex kAuthorityRegex(
@@ -45,12 +44,14 @@ bool matchAuthorityAndPath(
   const auto authority = authAndPathMatch[1];
   if (!boost::regex_match(
           authority.first, authority.second, authorityMatch, kAuthorityRegex)) {
-    return false; // Invalid URI Authority.
+    return std::nullopt; // Invalid URI Authority.
   }
 
-  hasAuthority = true;
+  if (authorityMatch[subGroup].matched) {
+    return detail::submatch(authorityMatch, subGroup);
+  }
 
-  return true;
+  return std::nullopt;
 }
 
-} // namespace facebook::velox::functions
+} // namespace facebook::velox::functions::detail
diff --git a/velox/functions/prestosql/URLFunctions.h b/velox/functions/prestosql/URLFunctions.h
index d3d50fd894a15..97e16a5820896 100644
--- a/velox/functions/prestosql/URLFunctions.h
+++ b/velox/functions/prestosql/URLFunctions.h
@@ -17,26 +17,78 @@
 
 #include <boost/regex.hpp>
 #include <cctype>
+#include <optional>
 #include "velox/functions/Macros.h"
+#include "velox/functions/lib/string/StringImpl.h"
 
 namespace facebook::velox::functions {
 
-namespace {
+namespace detail {
+
+const auto kScheme = 2;
+const auto kAuthority = 3;
+const auto kPath = 5;
+const auto kQuery = 7;
+const auto kFragment = 9;
+const auto kHost = 3; // From the authority and path regex.
+const auto kPort = 4; // From the authority and path regex.
+
 FOLLY_ALWAYS_INLINE StringView submatch(const boost::cmatch& match, int idx) {
   const auto& sub = match[idx];
   return StringView(sub.first, sub.length());
 }
 
-template <typename TInString>
-bool parse(const TInString& rawUrl, boost::cmatch& match) {
+FOLLY_ALWAYS_INLINE bool
+parse(const char* rawUrlData, size_t rawUrlsize, boost::cmatch& match) {
+  /// This regex is taken from RFC - 3986.
+  /// See: https://www.rfc-editor.org/rfc/rfc3986#appendix-B
+  /// The basic groups are:
+  ///      scheme    = $2
+  ///      authority = $4
+  ///      path      = $5
+  ///      query     = $7
+  ///      fragment  = $9
+  /// For example a URI like below :
+  ///  http://www.ics.uci.edu/pub/ietf/uri/#Related
+  ///
+  ///   results in the following subexpression matches:
+  ///
+  ///      $1 = http:
+  ///      $2 = http
+  ///      $3 = //www.ics.uci.edu
+  ///      $4 = www.ics.uci.edu
+  ///      $5 = /pub/ietf/uri/
+  ///      $6 = <undefined>
+  ///      $7 = <undefined>
+  ///      $8 = #Related
+  ///      $9 = Related
   static const boost::regex kUriRegex(
-      "([a-zA-Z][a-zA-Z0-9+.-]*):" // scheme:
-      "([^?#]*)" // authority and path
-      "(?:\\?([^#]*))?" // ?query
-      "(?:#(.*))?"); // #fragment
+      "^(([^:\\/?#]+):)?" // scheme:
+      "(\\/\\/([^\\/?#]*))?([^?#]*)" // authority and path
+      "(\\?([^#]*))?" // ?query
+      "(#(.*))?"); // #fragment
 
   return boost::regex_match(
-      rawUrl.data(), rawUrl.data() + rawUrl.size(), match, kUriRegex);
+      rawUrlData, rawUrlData + rawUrlsize, match, kUriRegex);
+}
+
+/// Parses the url and returns the matching subgroup if the particular sub group
+/// is matched by the call to parse call above.
+FOLLY_ALWAYS_INLINE std::optional<StringView> parse(
+    StringView rawUrl,
+    int subGroup) {
+  boost::cmatch match;
+  if (!parse(rawUrl.data(), rawUrl.size(), match)) {
+    return std::nullopt;
+  }
+
+  VELOX_CHECK_LT(subGroup, match.size());
+
+  if (match[subGroup].matched) {
+    return submatch(match, subGroup);
+  }
+
+  return std::nullopt;
 }
 
 FOLLY_ALWAYS_INLINE unsigned char toHex(unsigned char c) {
@@ -84,6 +136,37 @@ FOLLY_ALWAYS_INLINE void urlEscape(TOutString& output, const TInString& input) {
   output.resize(outIndex);
 }
 
+/// Performs initial validation of the URI.
+/// Checks if the URI contains ascii whitespaces or
+/// unescaped '%' chars.
+FOLLY_ALWAYS_INLINE bool isValidURI(StringView input) {
+  const char* p = input.data();
+  const char* end = p + input.size();
+  char buf[3];
+  buf[2] = '\0';
+  char* endptr;
+  for (; p < end; ++p) {
+    if (stringImpl::isAsciiWhiteSpace(*p)) {
+      return false;
+    }
+
+    if (*p == '%') {
+      if (p + 2 < end) {
+        buf[0] = p[1];
+        buf[1] = p[2];
+        strtol(buf, &endptr, 16);
+        p += 2;
+        if (endptr != buf + 2) {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 template <typename TOutString, typename TInString>
 FOLLY_ALWAYS_INLINE void urlUnescape(
     TOutString& output,
@@ -122,13 +205,15 @@ FOLLY_ALWAYS_INLINE void urlUnescape(
   output.resize(outputBuffer - output.data());
 }
 
-} // namespace
-
-bool matchAuthorityAndPath(
-    const boost::cmatch& urlMatch,
-    boost::cmatch& authAndPathMatch,
+/// Matches the authority (i.e host[:port], ipaddress), and path from a string
+/// representing the authority and path. Returns true if the regex matches, and
+/// sets the appropriate groups matching authority in authorityMatch.
+std::optional<StringView> matchAuthorityAndPath(
+    StringView authorityAndPath,
     boost::cmatch& authorityMatch,
-    bool& hasAuthority);
+    int subGroup);
+
+} // namespace detail
 
 template <typename T>
 struct UrlExtractProtocolFunction {
@@ -143,11 +228,14 @@ struct UrlExtractProtocolFunction {
   FOLLY_ALWAYS_INLINE bool call(
       out_type<Varchar>& result,
       const arg_type<Varchar>& url) {
-    boost::cmatch match;
-    if (!parse(url, match)) {
-      result.setEmpty();
+    if (!detail::isValidURI(url)) {
+      return false;
+    }
+
+    if (auto protocol = detail::parse(url, detail::kScheme)) {
+      result.setNoCopy(protocol.value());
     } else {
-      result.setNoCopy(submatch(match, 1));
+      result.setEmpty();
     }
     return true;
   }
@@ -166,11 +254,14 @@ struct UrlExtractFragmentFunction {
   FOLLY_ALWAYS_INLINE bool call(
       out_type<Varchar>& result,
       const arg_type<Varchar>& url) {
-    boost::cmatch match;
-    if (!parse(url, match)) {
-      result.setEmpty();
+    if (!detail::isValidURI(url)) {
+      return false;
+    }
+
+    if (auto fragment = detail::parse(url, detail::kFragment)) {
+      result.setNoCopy(fragment.value());
     } else {
-      result.setNoCopy(submatch(match, 4));
+      result.setEmpty();
     }
     return true;
   }
@@ -189,19 +280,20 @@ struct UrlExtractHostFunction {
   FOLLY_ALWAYS_INLINE bool call(
       out_type<Varchar>& result,
       const arg_type<Varchar>& url) {
-    boost::cmatch match;
-    if (!parse(url, match)) {
+    if (!detail::isValidURI(url)) {
+      return false;
+    }
+
+    auto authAndPath = detail::parse(url, detail::kAuthority);
+    if (!authAndPath) {
       result.setEmpty();
       return true;
     }
-    boost::cmatch authAndPathMatch;
     boost::cmatch authorityMatch;
-    bool hasAuthority;
 
-    if (matchAuthorityAndPath(
-            match, authAndPathMatch, authorityMatch, hasAuthority) &&
-        hasAuthority) {
-      result.setNoCopy(submatch(authorityMatch, 3));
+    if (auto host = detail::matchAuthorityAndPath(
+            authAndPath.value(), authorityMatch, detail::kHost)) {
+      result.setNoCopy(host.value());
     } else {
       result.setEmpty();
     }
@@ -214,21 +306,21 @@ struct UrlExtractPortFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE bool call(int64_t& result, const arg_type<Varchar>& url) {
-    boost::cmatch match;
-    if (!parse(url, match)) {
+    if (!detail::isValidURI(url)) {
+      return false;
+    }
+
+    auto authAndPath = detail::parse(url, detail::kAuthority);
+    if (!authAndPath) {
       return false;
     }
 
-    boost::cmatch authAndPathMatch;
     boost::cmatch authorityMatch;
-    bool hasAuthority;
-    if (matchAuthorityAndPath(
-            match, authAndPathMatch, authorityMatch, hasAuthority) &&
-        hasAuthority) {
-      auto port = submatch(authorityMatch, 4);
-      if (!port.empty()) {
+    if (auto port = detail::matchAuthorityAndPath(
+            authAndPath.value(), authorityMatch, detail::kPort)) {
+      if (!port.value().empty()) {
         try {
-          result = to<int64_t>(port);
+          result = to<int64_t>(port.value());
           return true;
         } catch (folly::ConversionError const&) {
         }
@@ -244,29 +336,19 @@ struct UrlExtractPathFunction {
 
   // Input is always ASCII, but result may or may not be ASCII.
 
-  FOLLY_ALWAYS_INLINE void call(
+  FOLLY_ALWAYS_INLINE bool call(
       out_type<Varchar>& result,
       const arg_type<Varchar>& url) {
-    boost::cmatch match;
-    if (!parse(url, match)) {
-      result.setEmpty();
-      return;
+    if (!detail::isValidURI(url)) {
+      return false;
     }
 
-    boost::cmatch authAndPathMatch;
-    boost::cmatch authorityMatch;
-    bool hasAuthority;
+    auto path = detail::parse(url, detail::kPath);
+    VELOX_USER_CHECK(
+        path.has_value(), "Unable to determine path for URL: {}", url);
+    detail::urlUnescape(result, path.value());
 
-    if (matchAuthorityAndPath(
-            match, authAndPathMatch, authorityMatch, hasAuthority)) {
-      StringView escapedPath;
-      if (hasAuthority) {
-        escapedPath = submatch(authAndPathMatch, 2);
-      } else {
-        escapedPath = submatch(match, 2);
-      }
-      urlUnescape(result, escapedPath);
-    }
+    return true;
   }
 };
 
@@ -283,14 +365,16 @@ struct UrlExtractQueryFunction {
   FOLLY_ALWAYS_INLINE bool call(
       out_type<Varchar>& result,
       const arg_type<Varchar>& url) {
-    boost::cmatch match;
-    if (!parse(url, match)) {
+    if (!detail::isValidURI(url)) {
+      return false;
+    }
+
+    if (auto query = detail::parse(url, detail::kQuery)) {
+      result.setNoCopy(query.value());
+    } else {
       result.setEmpty();
-      return true;
     }
 
-    auto query = submatch(match, 3);
-    result.setNoCopy(query);
     return true;
   }
 };
@@ -309,14 +393,16 @@ struct UrlExtractParameterFunction {
       out_type<Varchar>& result,
       const arg_type<Varchar>& url,
       const arg_type<Varchar>& param) {
-    boost::cmatch match;
-    if (!parse(url, match)) {
-      result.setEmpty();
+    if (!detail::isValidURI(url)) {
+      return false;
+    }
+
+    auto query = detail::parse(url, detail::kQuery);
+    if (!query) {
       return false;
     }
 
-    auto query = submatch(match, 3);
-    if (!query.empty()) {
+    if (!query.value().empty()) {
       // Parse query string.
       static const boost::regex kQueryParamRegex(
           "(^|&)" // start of query or start of parameter "&"
@@ -327,15 +413,17 @@ struct UrlExtractParameterFunction {
       );
 
       const boost::cregex_iterator begin(
-          query.data(), query.data() + query.size(), kQueryParamRegex);
+          query.value().data(),
+          query.value().data() + query.value().size(),
+          kQueryParamRegex);
       boost::cregex_iterator end;
 
       for (auto it = begin; it != end; ++it) {
-        if (it->length(2) != 0) { // key shouldnt be empty.
-          auto key = submatch((*it), 2);
+        if (it->length(2) != 0 && (*it)[2].matched) { // key shouldnt be empty.
+          auto key = detail::submatch((*it), 2);
           if (param.compare(key) == 0) {
-            auto value = submatch((*it), 3);
-            result.setNoCopy(value);
+            auto value = detail::submatch((*it), 3);
+            detail::urlUnescape(result, value);
             return true;
           }
         }
@@ -353,7 +441,7 @@ struct UrlEncodeFunction {
   FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
       const arg_type<Varbinary>& input) {
-    urlEscape(result, input);
+    detail::urlEscape(result, input);
   }
 };
 
@@ -364,7 +452,7 @@ struct UrlDecodeFunction {
   FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
       const arg_type<Varbinary>& input) {
-    urlUnescape(result, input);
+    detail::urlUnescape(result, input);
   }
 };
 
diff --git a/velox/functions/prestosql/Utf8Utils.cpp b/velox/functions/prestosql/Utf8Utils.cpp
deleted file mode 100644
index 1509e9f0265e5..0000000000000
--- a/velox/functions/prestosql/Utf8Utils.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/functions/prestosql/Utf8Utils.h"
-#include "velox/common/base/Exceptions.h"
-#include "velox/external/utf8proc/utf8procImpl.h"
-
-namespace facebook::velox::functions {
-
-int32_t tryGetCharLength(const char* input, int64_t size) {
-  VELOX_DCHECK_NOT_NULL(input);
-  VELOX_DCHECK_GT(size, 0);
-
-  auto charLength = utf8proc_char_length(input);
-  if (charLength < 0) {
-    return -1;
-  }
-
-  if (charLength == 1) {
-    // Normal ASCII: 0xxx_xxxx.
-    return 1;
-  }
-
-  auto firstByte = input[0];
-
-  // Process second byte.
-  if (size < 2) {
-    return -1;
-  }
-
-  auto secondByte = input[1];
-  if (!utf_cont(secondByte)) {
-    return -1;
-  }
-
-  if (charLength == 2) {
-    // 110x_xxxx 10xx_xxxx
-    int codePoint = ((firstByte & 0b00011111) << 6) | (secondByte & 0b00111111);
-    // Fail if overlong encoding.
-    return codePoint < 0x80 ? -2 : 2;
-  }
-
-  // Process third byte.
-  if (size < 3) {
-    return -2;
-  }
-
-  auto thirdByte = input[2];
-  if (!utf_cont(thirdByte)) {
-    return -2;
-  }
-
-  if (charLength == 3) {
-    // 1110_xxxx 10xx_xxxx 10xx_xxxx
-    int codePoint = ((firstByte & 0b00001111) << 12) |
-        ((secondByte & 0b00111111) << 6) | (thirdByte & 0b00111111);
-
-    // Surrogates are invalid.
-    static const int kMinSurrogate = 0xd800;
-    static const int kMaxSurrogate = 0xdfff;
-    if (kMinSurrogate <= codePoint && codePoint <= kMaxSurrogate) {
-      return -3;
-    }
-
-    // Fail if overlong encoding.
-    return codePoint < 0x800 ? -3 : 3;
-  }
-
-  // Process forth byte.
-  if (size < 4) {
-    return -3;
-  }
-
-  auto forthByte = input[3];
-  if (!utf_cont(forthByte)) {
-    return -3;
-  }
-
-  if (charLength == 4) {
-    // 1111_0xxx 10xx_xxxx 10xx_xxxx 10xx_xxxx
-    int codePoint = ((firstByte & 0b00000111) << 18) |
-        ((secondByte & 0b00111111) << 12) | ((thirdByte & 0b00111111) << 6) |
-        (forthByte & 0b00111111);
-    // Fail if overlong encoding or above upper bound of Unicode.
-    if (codePoint < 0x110000 && codePoint >= 0x10000) {
-      return 4;
-    }
-    return -4;
-  }
-
-  VELOX_UNREACHABLE();
-}
-} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Utf8Utils.h b/velox/functions/prestosql/Utf8Utils.h
deleted file mode 100644
index 318a1b86a9248..0000000000000
--- a/velox/functions/prestosql/Utf8Utils.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <cstdint>
-
-namespace facebook::velox::functions {
-
-/// This function is not part of the original utf8proc.
-/// Tries to get the length of UTF-8 encoded code point.  A
-/// positive return value means the UTF-8 sequence is valid, and
-/// the result is the length of the code point.  A negative return value means
-/// the UTF-8 sequence at the position is invalid, and the length of the invalid
-/// sequence is the absolute value of the result.
-///
-/// @param input Pointer to the first byte of the code point. Must not be null.
-/// @param size Number of available bytes. Must be greater than zero.
-/// @return the length of the code point or negative the number of bytes in the
-/// invalid UTF-8 sequence.
-///
-/// Adapted from tryGetCodePointAt in
-/// https://github.com/airlift/slice/blob/master/src/main/java/io/airlift/slice/SliceUtf8.java
-int32_t tryGetCharLength(const char* input, int64_t size);
-
-} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/UuidFunctions.h b/velox/functions/prestosql/UuidFunctions.h
new file mode 100644
index 0000000000000..9e4b319a7fff0
--- /dev/null
+++ b/velox/functions/prestosql/UuidFunctions.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/types/UuidType.h"
+
+namespace facebook::velox::functions {
+
+template <typename T>
+struct UuidFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr bool is_deterministic = false;
+
+  FOLLY_ALWAYS_INLINE void call(int128_t& result) {
+    boost::uuids::uuid uuid = generator_();
+    memcpy(&result, uuid.data, 16);
+  }
+
+ private:
+  boost::uuids::random_generator generator_;
+};
+
+inline void registerUuidFunctions(const std::string& prefix) {
+  registerUuidType();
+  registerFunction<UuidFunction, Uuid>({prefix + "uuid"});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/WidthBucketArray.cpp b/velox/functions/prestosql/WidthBucketArray.cpp
index 6bfdaa718df28..a8c3a7fbb4780 100644
--- a/velox/functions/prestosql/WidthBucketArray.cpp
+++ b/velox/functions/prestosql/WidthBucketArray.cpp
@@ -169,7 +169,7 @@ std::vector<double> toBinValues(
       VELOX_USER_CHECK_GT(
           value,
           simpleVector->valueAt(offset + i - 1),
-          "Bin values are not sorted in ascending order")
+          "Bin values are not sorted in ascending order");
     }
     binValues.push_back(value);
   }
diff --git a/velox/functions/prestosql/WordStem.h b/velox/functions/prestosql/WordStem.h
new file mode 100644
index 0000000000000..41b01bb9aa350
--- /dev/null
+++ b/velox/functions/prestosql/WordStem.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <folly/container/F14Map.h>
+#include <libstemmer.h> // @manual
+
+#include "velox/functions/Udf.h"
+#include "velox/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::functions {
+
+namespace detail {
+// Wrap the sbstemmer library and use its sb_stemmer_stem
+// to get word stem.
+class Stemmer {
+ public:
+  Stemmer(sb_stemmer* stemmer) : sbStemmer_(stemmer) {
+    VELOX_CHECK_NOT_NULL(stemmer);
+  }
+
+  ~Stemmer() {
+    sb_stemmer_delete(sbStemmer_);
+  }
+
+  // Get the word stem or NULL if out of memory.
+  const char* stem(const std::string& input) {
+    return (const char*)(sb_stemmer_stem(
+        sbStemmer_,
+        reinterpret_cast<unsigned char const*>(input.c_str()),
+        input.length()));
+  }
+
+ private:
+  sb_stemmer* sbStemmer_;
+};
+} // namespace detail
+
+/// word_stem function
+/// word_stem(word) -> varchar
+///     return the stem of the word in the English language
+/// word_stem(word, lang) -> varchar
+///     return the stem of the word in the specificed language
+///
+/// Use the snowball stemmer library to calculate the stem.
+/// https://snowballstem.org
+/// The website provides Java implementation which is used in Presto as well
+/// as C implementation. Therefore, both Presto and Prestimissio
+/// would have the same word stem results.
+template <typename TExec>
+struct WordStemFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // ASCII input always produces ASCII result.
+  static constexpr bool is_default_ascii_behavior = true;
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input) {
+    return doCall<false>(result, input);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input) {
+    return doCall<true>(result, input);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& lang) {
+    return doCall<false>(result, input, lang);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& lang) {
+    return doCall<true>(result, input, lang);
+  }
+
+  template <bool isAscii>
+  FOLLY_ALWAYS_INLINE void doCall(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      const std::string& lang = "en") {
+    auto* stemmer = getStemmer(lang);
+    VELOX_USER_CHECK_NOT_NULL(
+        stemmer, "Unsupported stemmer language: {}", lang);
+
+    std::string lowerOutput;
+    stringImpl::lower<isAscii>(lowerOutput, input);
+    auto* stem = stemmer->stem(lowerOutput);
+    VELOX_CHECK_NOT_NULL(
+        stem, "Stemmer library returned a NULL (out-of-memory)");
+    result = stem;
+  }
+
+ private:
+  folly::F14FastMap<std::string, std::unique_ptr<detail::Stemmer>> stemmers_;
+
+  // Get a detail::Stemmer from the the map using the lang as the key or create
+  // a new one if it doesn't exist. Return nullptr if the specified lang is not
+  // supported.
+  detail::Stemmer* getStemmer(const std::string& lang) {
+    if (auto found = stemmers_.find(lang); found != stemmers_.end()) {
+      return found->second.get();
+    }
+    // Only support ASCII and UTF-8.
+    if (auto sbStemmer = sb_stemmer_new(lang.c_str(), "UTF_8")) {
+      auto* stemmer = new detail::Stemmer(sbStemmer);
+      stemmers_[lang] = std::unique_ptr<detail::Stemmer>(stemmer);
+      return stemmer;
+    }
+    return nullptr;
+  }
+};
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Zip.cpp b/velox/functions/prestosql/Zip.cpp
index 42073e37cab95..6e9b17a616527 100644
--- a/velox/functions/prestosql/Zip.cpp
+++ b/velox/functions/prestosql/Zip.cpp
@@ -234,24 +234,19 @@ class ZipFunction : public exec::VectorFunction {
     std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
     signatures.reserve(kAritySize);
 
-    std::vector<std::string> elementTypeNames(kAritySize);
-
-    for (int i = 0; i < kAritySize; i++) {
-      elementTypeNames[i] = fmt::format("E{:02d}", i);
-    }
-
     // Build all signatures from kMinArity to kMaxArity.
-    for (int i = 1; i < kAritySize; i++) {
+    for (int i = kMinArity; i <= kMaxArity; i++) {
       auto builder = exec::FunctionSignatureBuilder();
       std::vector<std::string> allTypeVars;
-      allTypeVars.reserve(i + 1);
+      allTypeVars.reserve(i);
 
-      for (int j = 0; j < i + 1; j++) {
-        allTypeVars.emplace_back(elementTypeNames[j]);
-        builder.typeVariable(elementTypeNames[j]);
-        builder.argumentType(fmt::format("array({})", elementTypeNames[j]));
+      for (int j = 0; j < i; j++) {
+        allTypeVars.emplace_back(fmt::format("E{:02d}", j));
+        builder.typeVariable(allTypeVars.back());
+        builder.argumentType(fmt::format("array({})", allTypeVars.back()));
       }
-      auto returnType = boost::algorithm::join(allTypeVars, ",");
+
+      const auto returnType = folly::join(",", allTypeVars);
       builder.returnType(fmt::format("array(row({}))", returnType));
       signatures.emplace_back(builder.build());
     }
diff --git a/velox/functions/prestosql/ZipWith.cpp b/velox/functions/prestosql/ZipWith.cpp
index d0a47d9361eeb..032237cbd53e7 100644
--- a/velox/functions/prestosql/ZipWith.cpp
+++ b/velox/functions/prestosql/ZipWith.cpp
@@ -46,14 +46,6 @@ struct DecodedInputs {
 // https://prestodb.io/docs/current/functions/array.html#zip_with
 class ZipWithFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    // zip_with is null preserving for the arrays, but since an
-    // expr tree with a lambda depends on all named fields, including
-    // captures, a null in a capture does not automatically make a
-    // null result.
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -322,9 +314,15 @@ class ZipWithFunction : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+/// zip_with is null preserving for the arrays, but since an
+/// expr tree with a lambda depends on all named fields, including
+/// captures, a null in a capture does not automatically make a
+/// null result.
+
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_zip_with,
     ZipWithFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<ZipWithFunction>());
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/aggregates/AggregateNames.h b/velox/functions/prestosql/aggregates/AggregateNames.h
index 8c6691588efc8..7cf2ff9810d8f 100644
--- a/velox/functions/prestosql/aggregates/AggregateNames.h
+++ b/velox/functions/prestosql/aggregates/AggregateNames.h
@@ -23,6 +23,7 @@ const char* const kApproxMostFrequent = "approx_most_frequent";
 const char* const kApproxPercentile = "approx_percentile";
 const char* const kApproxSet = "approx_set";
 const char* const kArbitrary = "arbitrary";
+const char* const kAnyValue = "any_value";
 const char* const kArrayAgg = "array_agg";
 const char* const kAvg = "avg";
 const char* const kBitwiseAnd = "bitwise_and_agg";
@@ -53,6 +54,13 @@ const char* const kMultiMapAgg = "multimap_agg";
 const char* const kReduceAgg = "reduce_agg";
 const char* const kRegrIntercept = "regr_intercept";
 const char* const kRegrSlop = "regr_slope";
+const char* const kRegrCount = "regr_count";
+const char* const kRegrAvgy = "regr_avgy";
+const char* const kRegrAvgx = "regr_avgx";
+const char* const kRegrSxy = "regr_sxy";
+const char* const kRegrSxx = "regr_sxx";
+const char* const kRegrSyy = "regr_syy";
+const char* const kRegrR2 = "regr_r2";
 const char* const kSetAgg = "set_agg";
 const char* const kSetUnion = "set_union";
 const char* const kSkewness = "skewness";
diff --git a/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
index 7c46311abb604..52ddbf628eaf5 100644
--- a/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
@@ -114,6 +114,12 @@ inline uint64_t hashOne(T value) {
   return XXH64(&value, sizeof(T), 0);
 }
 
+// Use timestamp.toMillis() to compute hash value.
+template <>
+inline uint64_t hashOne<Timestamp>(Timestamp value) {
+  return hashOne(value.toMillis());
+}
+
 template <>
 inline uint64_t hashOne<StringView>(StringView value) {
   return XXH64(value.data(), value.size(), 0);
@@ -125,10 +131,12 @@ class ApproxDistinctAggregate : public exec::Aggregate {
   explicit ApproxDistinctAggregate(
       const TypePtr& resultType,
       bool hllAsFinalResult,
-      bool hllAsRawInput)
+      bool hllAsRawInput,
+      double defaultError)
       : exec::Aggregate(resultType),
         hllAsFinalResult_{hllAsFinalResult},
-        hllAsRawInput_{hllAsRawInput} {}
+        hllAsRawInput_{hllAsRawInput},
+        indexBitLength_{common::hll::toIndexBitLength(defaultError)} {}
 
   int32_t accumulatorFixedWidthSize() const override {
     return sizeof(HllAccumulator);
@@ -142,14 +150,15 @@ class ApproxDistinctAggregate : public exec::Aggregate {
     return false;
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      auto group = groups[i];
-      new (group + offset_) HllAccumulator(allocator_);
-    }
+  bool supportsToIntermediate() const final {
+    return hllAsRawInput_;
+  }
+
+  void toIntermediate(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      VectorPtr& result) const final {
+    singleInputAsIntermediate(rows, args, result);
   }
 
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
@@ -199,10 +208,6 @@ class ApproxDistinctAggregate : public exec::Aggregate {
         });
   }
 
-  void destroy(folly::Range<char**> groups) override {
-    destroyAccumulators<HllAccumulator>(groups);
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -301,6 +306,21 @@ class ApproxDistinctAggregate : public exec::Aggregate {
     });
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      auto group = groups[i];
+      new (group + offset_) HllAccumulator(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<HllAccumulator>(groups);
+  }
+
  private:
   template <
       bool convertNullToZero,
@@ -348,17 +368,32 @@ class ApproxDistinctAggregate : public exec::Aggregate {
     decodedValue_.decode(*args[0], rows, true);
     if (args.size() > 1) {
       decodedMaxStandardError_.decode(*args[1], rows, true);
-      checkSetMaxStandardError();
+      checkSetMaxStandardError(rows);
     }
   }
 
-  void checkSetMaxStandardError() {
-    VELOX_USER_CHECK(
-        decodedMaxStandardError_.isConstantMapping(),
-        "Max standard error argument must be constant for all input rows");
+  void checkSetMaxStandardError(const SelectivityVector& rows) {
+    if (decodedMaxStandardError_.isConstantMapping()) {
+      const auto maxStandardError = decodedMaxStandardError_.valueAt<double>(0);
+      checkSetMaxStandardError(maxStandardError);
+      return;
+    }
 
-    auto maxStandardError = decodedMaxStandardError_.valueAt<double>(0);
-    checkSetMaxStandardError(maxStandardError);
+    rows.applyToSelected([&](auto row) {
+      VELOX_USER_CHECK(
+          !decodedMaxStandardError_.isNullAt(row),
+          "Max standard error cannot be null");
+      const auto maxStandardError =
+          decodedMaxStandardError_.valueAt<double>(row);
+      if (maxStandardError_ == -1) {
+        checkSetMaxStandardError(maxStandardError);
+      } else {
+        VELOX_USER_CHECK_EQ(
+            maxStandardError,
+            maxStandardError_,
+            "Max standard error argument must be constant for all input rows");
+      }
+    });
   }
 
   void checkSetMaxStandardError(double error) {
@@ -383,8 +418,7 @@ class ApproxDistinctAggregate : public exec::Aggregate {
   /// serialized HLLs.
   const bool hllAsRawInput_;
 
-  int8_t indexBitLength_{
-      common::hll::toIndexBitLength(common::hll::kDefaultStandardError)};
+  int8_t indexBitLength_;
   double maxStandardError_{-1};
   DecodedVector decodedValue_;
   DecodedVector decodedMaxStandardError_;
@@ -395,16 +429,20 @@ template <TypeKind kind>
 std::unique_ptr<exec::Aggregate> createApproxDistinct(
     const TypePtr& resultType,
     bool hllAsFinalResult,
-    bool hllAsRawInput) {
+    bool hllAsRawInput,
+    double defaultError) {
   using T = typename TypeTraits<kind>::NativeType;
   return std::make_unique<ApproxDistinctAggregate<T>>(
-      resultType, hllAsFinalResult, hllAsRawInput);
+      resultType, hllAsFinalResult, hllAsRawInput, defaultError);
 }
 
 exec::AggregateRegistrationResult registerApproxDistinct(
     const std::string& name,
     bool hllAsFinalResult,
-    bool hllAsRawInput) {
+    bool hllAsRawInput,
+    bool withCompanionFunctions,
+    bool overwrite,
+    double defaultError) {
   auto returnType = hllAsFinalResult ? "hyperloglog" : "bigint";
 
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
@@ -421,9 +459,11 @@ exec::AggregateRegistrationResult registerApproxDistinct(
           "smallint",
           "integer",
           "bigint",
+          "hugeint",
           "real",
           "double",
           "varchar",
+          "varbinary",
           "timestamp",
           "date"}) {
       signatures.push_back(exec::AggregateFunctionSignatureBuilder()
@@ -439,37 +479,74 @@ exec::AggregateRegistrationResult registerApproxDistinct(
                                .argumentType("double")
                                .build());
     }
+    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
+                             .integerVariable("a_precision")
+                             .integerVariable("a_scale")
+                             .returnType(returnType)
+                             .intermediateType("varbinary")
+                             .argumentType("DECIMAL(a_precision, a_scale)")
+                             .build());
+    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
+                             .integerVariable("a_precision")
+                             .integerVariable("a_scale")
+                             .returnType(returnType)
+                             .intermediateType("varbinary")
+                             .argumentType("DECIMAL(a_precision, a_scale)")
+                             .argumentType("double")
+                             .build());
   }
 
   return exec::registerAggregateFunction(
       name,
       std::move(signatures),
-      [name, hllAsFinalResult, hllAsRawInput](
+      [name, hllAsFinalResult, hllAsRawInput, defaultError](
           core::AggregationNode::Step /*step*/,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
-        TypePtr type = argTypes[0]->isVarbinary() ? BIGINT() : argTypes[0];
         return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
             createApproxDistinct,
-            type->kind(),
+            argTypes[0]->kind(),
             resultType,
             hllAsFinalResult,
-            hllAsRawInput);
+            hllAsRawInput,
+            defaultError);
       },
-      /*registerCompanionFunctions*/ true);
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace
 
-void registerApproxDistinctAggregates(const std::string& prefix) {
-  registerCustomType(
-      prefix + "hyperloglog",
-      std::make_unique<const HyperLogLogTypeFactories>());
-  registerApproxDistinct(prefix + kApproxDistinct, false, false);
-  registerApproxDistinct(prefix + kApproxSet, true, false);
-  registerApproxDistinct(prefix + kMerge, true, true);
+void registerApproxDistinctAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerHyperLogLogType();
+  registerApproxDistinct(
+      prefix + kApproxDistinct,
+      false,
+      false,
+      withCompanionFunctions,
+      overwrite,
+      common::hll::kDefaultApproxDistinctStandardError);
+  // approx_set and merge are already companion functions themselves. Don't
+  // register companion functions for them.
+  registerApproxDistinct(
+      prefix + kApproxSet,
+      true,
+      false,
+      false,
+      overwrite,
+      common::hll::kDefaultApproxSetStandardError);
+  registerApproxDistinct(
+      prefix + kMerge,
+      true,
+      true,
+      false,
+      overwrite,
+      common::hll::kDefaultApproxSetStandardError);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
index 8f785f27a95c5..1a6fe95540a19 100644
--- a/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/exec/Aggregate.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
 #include "velox/exec/Strings.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/lib/ApproxMostFrequentStreamSummary.h"
@@ -72,18 +73,6 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     return sizeof(Accumulator<T>);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    for (auto index : indices) {
-      new (groups[index] + offset_) Accumulator<T>(allocator_);
-    }
-  }
-
-  void destroy(folly::Range<char**> groups) override {
-    destroyAccumulators<Accumulator<T>>(groups);
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -218,6 +207,19 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     }
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto index : indices) {
+      new (groups[index] + offset_) Accumulator<T>(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<Accumulator<T>>(groups);
+  }
+
  private:
   void decodeArguments(
       const SelectivityVector& rows,
@@ -329,6 +331,110 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
   int64_t capacity_ = kMissingArgument;
 };
 
+class ApproxMostFrequentBooleanAggregate {
+ public:
+  using InputType =
+      Row</*buckets*/ int64_t, /*value*/ bool, /*capacity*/ int64_t>;
+
+  using IntermediateType =
+      Row</*buckets*/ int64_t,
+          /*capacity*/ int64_t,
+          /*values*/ Array<bool>,
+          /*counts*/ Array<int64_t>>;
+
+  using OutputType = Map<bool, int64_t>;
+
+  static bool toIntermediate(
+      exec::out_type<IntermediateType>& out,
+      int64_t buckets,
+      bool value,
+      int64_t capacity) {
+    out.get_writer_at<0>() = buckets;
+    out.get_writer_at<1>() = capacity;
+
+    auto& valuesWriter = out.get_writer_at<2>();
+    valuesWriter.add_item() = true;
+    valuesWriter.add_item() = false;
+
+    auto& countsWriter = out.get_writer_at<3>();
+    countsWriter.add_item() = value ? 1 : 0;
+    countsWriter.add_item() = value ? 0 : 1;
+
+    return true;
+  }
+
+  struct AccumulatorType {
+    int64_t numTrue{0};
+    int64_t numFalse{0};
+
+    explicit AccumulatorType(HashStringAllocator* /*allocator*/) {}
+
+    void addInput(
+        HashStringAllocator* /*allocator*/,
+        int64_t /*buckets*/,
+        bool value,
+        int64_t /*capacity*/) {
+      if (value) {
+        ++numTrue;
+      } else {
+        ++numFalse;
+      }
+    }
+
+    void combine(
+        HashStringAllocator* /*allocator*/,
+        exec::arg_type<IntermediateType> other) {
+      VELOX_CHECK(other.at<2>().has_value());
+      VELOX_CHECK(other.at<3>().has_value());
+
+      const auto& values = *other.at<2>();
+      VELOX_CHECK_EQ(2, values.size());
+
+      VELOX_CHECK_EQ(values[0].value(), true);
+      VELOX_CHECK_EQ(values[1].value(), false);
+
+      const auto& counts = *other.at<3>();
+      VELOX_CHECK_EQ(2, counts.size());
+
+      numTrue += counts[0].value();
+      numFalse += counts[1].value();
+    }
+
+    bool writeFinalResult(exec::out_type<OutputType>& out) {
+      if (numTrue > 0) {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter = true;
+        valueWriter = numTrue;
+      }
+
+      if (numFalse > 0) {
+        auto [keyWriter, valueWriter] = out.add_item();
+        keyWriter = false;
+        valueWriter = numFalse;
+      }
+
+      return true;
+    }
+
+    bool writeIntermediateResult(exec::out_type<IntermediateType>& out) {
+      // Write some hard-coded values for 'buckets' and 'capacity'. These are
+      // not used.
+      out.get_writer_at<0>() = 2;
+      out.get_writer_at<1>() = 2;
+
+      auto& valuesWriter = out.get_writer_at<2>();
+      valuesWriter.add_item() = true;
+      valuesWriter.add_item() = false;
+
+      auto& countsWriter = out.get_writer_at<3>();
+      countsWriter.add_item() = numTrue;
+      countsWriter.add_item() = numFalse;
+
+      return true;
+    }
+  };
+};
+
 template <TypeKind kKind>
 std::unique_ptr<exec::Aggregate> makeApproxMostFrequentAggregate(
     const TypePtr& resultType,
@@ -341,19 +447,29 @@ std::unique_ptr<exec::Aggregate> makeApproxMostFrequentAggregate(
     return std::make_unique<
         ApproxMostFrequentAggregate<typename TypeTraits<kKind>::NativeType>>(
         resultType);
-  } else {
-    VELOX_USER_FAIL(
-        "Unsupported value type for {} aggregation {}",
-        name,
-        valueType->toString());
   }
+
+  if (kKind == TypeKind::BOOLEAN) {
+    return std::make_unique<
+        exec::SimpleAggregateAdapter<ApproxMostFrequentBooleanAggregate>>(
+        resultType);
+  }
+
+  VELOX_USER_FAIL(
+      "Unsupported value type for {} aggregation {}",
+      name,
+      valueType->toString());
 }
 
-exec::AggregateRegistrationResult registerApproxMostFrequent(
-    const std::string& name) {
+} // namespace
+
+void registerApproxMostFrequentAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   for (const auto& valueType :
-       {"tinyint", "smallint", "integer", "bigint", "varchar"}) {
+       {"boolean", "tinyint", "smallint", "integer", "bigint", "varchar"}) {
     signatures.push_back(
         exec::AggregateFunctionSignatureBuilder()
             .returnType(fmt::format("map({},bigint)", valueType))
@@ -364,7 +480,8 @@ exec::AggregateRegistrationResult registerApproxMostFrequent(
             .argumentType("bigint")
             .build());
   }
-  return exec::registerAggregateFunction(
+  auto name = prefix + kApproxMostFrequent;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -382,13 +499,9 @@ exec::AggregateRegistrationResult registerApproxMostFrequent(
             resultType,
             name,
             valueType);
-      });
-}
-
-} // namespace
-
-void registerApproxMostFrequentAggregate(const std::string& prefix) {
-  registerApproxMostFrequent(prefix + kApproxMostFrequent);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
index 15e04e39d1189..4a5b0354b0356 100644
--- a/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
@@ -28,8 +28,47 @@ namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
+template <typename T, typename Allocator>
+struct KllSketchTypeTraits {
+  using KllSketchType = functions::kll::KllSketch<T, Allocator, std::less<T>>;
+};
+
+template <>
+struct KllSketchTypeTraits<float, StlAllocator<float>> {
+  using KllSketchType = functions::kll::KllSketch<
+      float,
+      StlAllocator<float>,
+      util::floating_point::NaNAwareLessThan<float>>;
+};
+
+template <>
+struct KllSketchTypeTraits<double, StlAllocator<double>> {
+  using KllSketchType = functions::kll::KllSketch<
+      double,
+      StlAllocator<double>,
+      util::floating_point::NaNAwareLessThan<double>>;
+};
+
+template <>
+struct KllSketchTypeTraits<float, std::allocator<float>> {
+  using KllSketchType = functions::kll::KllSketch<
+      float,
+      std::allocator<float>,
+      util::floating_point::NaNAwareLessThan<float>>;
+};
+
+template <>
+struct KllSketchTypeTraits<double, std::allocator<double>> {
+  using KllSketchType = functions::kll::KllSketch<
+      double,
+      std::allocator<double>,
+      util::floating_point::NaNAwareLessThan<double>>;
+};
+
+template <typename T, typename Allocator = StlAllocator<T>>
+using KllSketch = typename KllSketchTypeTraits<T, Allocator>::KllSketchType;
 template <typename T>
-using KllSketch = functions::kll::KllSketch<T, StlAllocator<T>>;
+using KllView = functions::kll::detail::View<T>;
 
 // Accumulator to buffer large count values in addition to the KLL
 // sketch itself.
@@ -67,42 +106,67 @@ struct KllSketchAccumulator {
     }
   }
 
-  void append(const typename KllSketch<T>::View& view) {
+  void append(const KllView<T>& view) {
     sketch_.mergeViews(folly::Range(&view, 1));
   }
 
-  void append(const std::vector<typename KllSketch<T>::View>& views) {
+  void append(const std::vector<KllView<T>>& views) {
     sketch_.mergeViews(views);
   }
 
-  void finalize() {
-    if (!largeCountValues_.empty()) {
-      flush();
-    }
-    sketch_.compact();
+  // Creates a copy of the KllSketch, merges the largeCountValues_ into it,
+  // compacts it, and returns it.
+  // Makes a copy so that uses std::allocator so that this is safe to call
+  // during spilling which may run in parallel.  HashStringAllocator is not
+  // thread safe, so merging into/compacting the original KllSketch which
+  // depends on it can lead to concurrency bugs.
+  KllSketch<T, std::allocator<T>> compact() const {
+    KllSketch<T, std::allocator<T>> newSketch =
+        KllSketch<T, std::allocator<T>>::fromView(
+            sketch_.toView(), std::allocator<T>(), random::getSeed());
+
+    mergeLargeCountValuesIntoSketch(std::allocator<T>(), newSketch);
+
+    newSketch.compact();
+
+    return newSketch;
   }
 
   const KllSketch<T>& getSketch() const {
     return sketch_;
   }
 
+  // This must be called before the KllSketch can be used for estimateQuantile()
+  // or estimateQuantiles().
+  void flush() {
+    mergeLargeCountValuesIntoSketch(StlAllocator<T>(allocator_), sketch_);
+    largeCountValues_.clear();
+
+    sketch_.finish();
+  }
+
  private:
+  template <typename Allocator, typename Compare>
+  void mergeLargeCountValuesIntoSketch(
+      const Allocator& allocator,
+      functions::kll::KllSketch<T, Allocator, Compare>& sketch) const {
+    if (!largeCountValues_.empty()) {
+      std::vector<functions::kll::KllSketch<T, Allocator, Compare>> sketches;
+      sketches.reserve(largeCountValues_.size());
+      for (auto [x, n] : largeCountValues_) {
+        sketches.push_back(
+            functions::kll::KllSketch<T, Allocator, Compare>::fromRepeatedValue(
+                x, n, k_, allocator, random::getSeed()));
+      }
+      sketch.merge(folly::Range(sketches.begin(), sketches.end()));
+    }
+  }
+
   uint16_t k_;
   HashStringAllocator* allocator_;
   KllSketch<T> sketch_;
   std::vector<std::pair<T, int64_t>, StlAllocator<std::pair<T, int64_t>>>
       largeCountValues_;
-
-  void flush() {
-    std::vector<KllSketch<T>> sketches;
-    sketches.reserve(largeCountValues_.size());
-    for (auto [x, n] : largeCountValues_) {
-      sketches.push_back(KllSketch<T>::fromRepeatedValue(
-          x, n, k_, StlAllocator<T>(allocator_), random::getSeed()));
-    }
-    sketch_.merge(folly::Range(sketches.begin(), sketches.end()));
-    largeCountValues_.clear();
-  }
 };
 
 enum IntermediateTypeChildIndex {
@@ -146,25 +210,11 @@ class ApproxPercentileAggregate : public exec::Aggregate {
     return false;
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      auto group = groups[i];
-      new (group + offset_) KllSketchAccumulator<T>(allocator_);
-    }
-  }
-
-  void destroy(folly::Range<char**> groups) override {
-    for (auto group : groups) {
-      value<KllSketchAccumulator<T>>(group)->~KllSketchAccumulator<T>();
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
-    finalize(groups, numGroups);
+    for (auto i = 0; i < numGroups; ++i) {
+      value<KllSketchAccumulator<T>>(groups[i])->flush();
+    }
 
     VELOX_CHECK(result);
     // When all inputs are nulls or masked out, percentiles_ can be
@@ -200,6 +250,7 @@ class ApproxPercentileAggregate : public exec::Aggregate {
               vector_size_t index) {
             digest.estimateQuantiles(percentiles, rawValues + elementsCount);
             result->setOffsetAndSize(index, elementsCount, percentiles.size());
+            result->setNull(index, false);
             elementsCount += percentiles.size();
           });
     } else {
@@ -219,7 +270,11 @@ class ApproxPercentileAggregate : public exec::Aggregate {
 
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
-    finalize(groups, numGroups);
+    std::vector<KllSketch<T, std::allocator<T>>> sketches;
+    sketches.reserve(numGroups);
+    for (auto i = 0; i < numGroups; ++i) {
+      sketches.push_back(value<KllSketchAccumulator<T>>(groups[i])->compact());
+    }
 
     VELOX_CHECK(result);
     auto rowResult = (*result)->as<RowVector>();
@@ -239,9 +294,10 @@ class ApproxPercentileAggregate : public exec::Aggregate {
           BaseVector::createNullConstant(BOOLEAN(), numGroups, pool);
       rowResult->childAt(kAccuracy) =
           BaseVector::createNullConstant(DOUBLE(), numGroups, pool);
-      for (auto i = 0; i < numGroups; ++i) {
-        rowResult->setNull(i, true);
-      }
+
+      // Set nulls for all rows.
+      auto rawNulls = rowResult->mutableRawNulls();
+      bits::fillBits(rawNulls, 0, rowResult->size(), bits::kNull);
       return;
     }
     auto& values = percentiles_->values;
@@ -287,9 +343,8 @@ class ApproxPercentileAggregate : public exec::Aggregate {
     auto levelsElements = levels->elements()->asFlatVector<int32_t>();
     size_t itemsCount = 0;
     vector_size_t levelsCount = 0;
-    for (int i = 0; i < numGroups; ++i) {
-      auto accumulator = value<const KllSketchAccumulator<T>>(groups[i]);
-      auto v = accumulator->getSketch().toView();
+    for (auto& sketch : sketches) {
+      auto v = sketch.toView();
       itemsCount += v.items.size();
       levelsCount += v.levels.size();
     }
@@ -303,9 +358,8 @@ class ApproxPercentileAggregate : public exec::Aggregate {
     auto rawLevels = levelsElements->mutableRawValues();
     itemsCount = 0;
     levelsCount = 0;
-    for (int i = 0; i < numGroups; ++i) {
-      auto accumulator = value<const KllSketchAccumulator<T>>(groups[i]);
-      auto v = accumulator->getSketch().toView();
+    for (int i = 0; i < sketches.size(); ++i) {
+      auto v = sketches[i].toView();
       if (v.n == 0) {
         rowResult->setNull(i, true);
       } else {
@@ -417,13 +471,26 @@ class ApproxPercentileAggregate : public exec::Aggregate {
     addIntermediate<true>(group, rows, args);
   }
 
- private:
-  void finalize(char** groups, int32_t numGroups) {
-    for (auto i = 0; i < numGroups; ++i) {
-      value<KllSketchAccumulator<T>>(groups[i])->finalize();
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      auto group = groups[i];
+      new (group + offset_) KllSketchAccumulator<T>(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        value<KllSketchAccumulator<T>>(group)->~KllSketchAccumulator<T>();
+      }
     }
   }
 
+ private:
   template <typename VectorType, typename ExtractFunc>
   void extract(
       char** groups,
@@ -464,67 +531,55 @@ class ApproxPercentileAggregate : public exec::Aggregate {
     checkSetPercentile(rows, *args[argIndex++]);
     if (hasAccuracy_) {
       decodedAccuracy_.decode(*args[argIndex++], rows, true);
-      checkSetAccuracy();
+      checkSetAccuracy(rows);
     }
     VELOX_CHECK_EQ(argIndex, args.size());
   }
 
-  /// Extract percentile info: the raw data, the length and the null-ness from
-  /// top-level ArrayVector.
-  static void extractPercentiles(
-      const ArrayVector* arrays,
-      vector_size_t indexInBaseVector,
-      const double*& data,
-      vector_size_t& len,
-      std::vector<bool>& isNull) {
-    auto elements = arrays->elements()->asFlatVector<double>();
-    auto offset = arrays->offsetAt(indexInBaseVector);
-    data = elements->rawValues() + offset;
-    len = arrays->sizeAt(indexInBaseVector);
-    isNull.resize(len);
-    for (auto index = offset; index < offset + len; index++) {
-      isNull[index - offset] = elements->isNullAt(index);
-    }
-  }
-
   void checkSetPercentile(
       const SelectivityVector& rows,
       const BaseVector& vec) {
     DecodedVector decoded(vec, rows);
-    VELOX_USER_CHECK(
-        decoded.isConstantMapping(),
-        "Percentile argument must be constant for all input rows");
+
+    auto* base = decoded.base();
+    auto baseFirstRow = decoded.index(rows.begin());
+    if (!decoded.isConstantMapping()) {
+      rows.applyToSelected([&](vector_size_t row) {
+        VELOX_USER_CHECK(!decoded.isNullAt(row), "Percentile cannot be null");
+        auto baseRow = decoded.index(row);
+        VELOX_USER_CHECK(
+            base->equalValueAt(base, baseRow, baseFirstRow),
+            "Percentile argument must be constant for all input rows: {} vs. {}",
+            base->toString(baseRow),
+            base->toString(baseFirstRow));
+      });
+    }
+
     bool isArray;
-    const double* data;
+    vector_size_t offset;
     vector_size_t len;
-    std::vector<bool> isNull;
-    auto indexInBaseVector = decoded.index(0);
-    if (decoded.base()->typeKind() == TypeKind::DOUBLE) {
+    if (base->typeKind() == TypeKind::DOUBLE) {
       isArray = false;
-      auto baseVector = decoded.base();
-      data = baseVector->asUnchecked<ConstantVector<double>>()->rawValues() +
-          indexInBaseVector;
+      offset = rows.begin();
       len = 1;
-      isNull = {baseVector->isNullAt(indexInBaseVector)};
-    } else if (decoded.base()->typeKind() == TypeKind::ARRAY) {
+    } else if (base->typeKind() == TypeKind::ARRAY) {
       isArray = true;
-      auto arrays = decoded.base()->asUnchecked<ArrayVector>();
-      VELOX_USER_CHECK(
-          arrays->elements()->isFlatEncoding(),
-          "Only flat encoding is allowed for percentile array elements");
-      extractPercentiles(arrays, indexInBaseVector, data, len, isNull);
+      auto arrays = base->asUnchecked<ArrayVector>();
+      decoded.decode(*arrays->elements());
+      offset = arrays->offsetAt(baseFirstRow);
+      len = arrays->sizeAt(baseFirstRow);
     } else {
       VELOX_USER_FAIL(
-          "Incorrect type for percentile: {}", decoded.base()->typeKind());
+          "Incorrect type for percentile: {}", base->type()->toString());
     }
-    checkSetPercentile(isArray, data, len, isNull);
+    checkSetPercentile(isArray, decoded, offset, len);
   }
 
   void checkSetPercentile(
       bool isArray,
-      const double* data,
-      vector_size_t len,
-      const std::vector<bool>& isNull) {
+      const DecodedVector& percentiles,
+      vector_size_t offset,
+      vector_size_t len) {
     if (!percentiles_) {
       VELOX_USER_CHECK_GT(len, 0, "Percentile cannot be empty");
       percentiles_ = {
@@ -532,10 +587,11 @@ class ApproxPercentileAggregate : public exec::Aggregate {
           .isArray = isArray,
       };
       for (vector_size_t i = 0; i < len; ++i) {
-        VELOX_USER_CHECK(!isNull[i], "Percentile cannot be null");
-        VELOX_USER_CHECK_GE(data[i], 0, "Percentile must be between 0 and 1");
-        VELOX_USER_CHECK_LE(data[i], 1, "Percentile must be between 0 and 1");
-        percentiles_->values[i] = data[i];
+        VELOX_USER_CHECK(!percentiles.isNullAt(i), "Percentile cannot be null");
+        auto value = percentiles.valueAt<double>(offset + i);
+        VELOX_USER_CHECK_GE(value, 0, "Percentile must be between 0 and 1");
+        VELOX_USER_CHECK_LE(value, 1, "Percentile must be between 0 and 1");
+        percentiles_->values[i] = value;
       }
     } else {
       VELOX_USER_CHECK_EQ(
@@ -548,21 +604,36 @@ class ApproxPercentileAggregate : public exec::Aggregate {
           "Percentile argument must be constant for all input rows");
       for (vector_size_t i = 0; i < len; ++i) {
         VELOX_USER_CHECK_EQ(
-            data[i],
+            percentiles.valueAt<double>(offset + i),
             percentiles_->values[i],
             "Percentile argument must be constant for all input rows");
       }
     }
   }
 
-  void checkSetAccuracy() {
+  void checkSetAccuracy(const SelectivityVector& rows) {
     if (!hasAccuracy_) {
       return;
     }
-    VELOX_USER_CHECK(
-        decodedAccuracy_.isConstantMapping(),
-        "Accuracy argument must be constant for all input rows");
-    checkSetAccuracy(decodedAccuracy_.valueAt<double>(0));
+
+    if (decodedAccuracy_.isConstantMapping()) {
+      VELOX_USER_CHECK(
+          !decodedAccuracy_.isNullAt(0), "Accuracy cannot be null");
+      checkSetAccuracy(decodedAccuracy_.valueAt<double>(0));
+    } else {
+      rows.applyToSelected([&](auto row) {
+        VELOX_USER_CHECK(
+            !decodedAccuracy_.isNullAt(row), "Accuracy cannot be null");
+        const auto accuracy = decodedAccuracy_.valueAt<double>(row);
+        if (accuracy_ == kMissingNormalizedValue) {
+          checkSetAccuracy(accuracy);
+        }
+        VELOX_USER_CHECK_EQ(
+            accuracy,
+            accuracy_,
+            "Accuracy argument must be constant for all input rows");
+      });
+    }
   }
 
   void checkSetAccuracy(double accuracy) {
@@ -646,7 +717,7 @@ class ApproxPercentileAggregate : public exec::Aggregate {
         innerRows.updateBounds();
       } else {
         velox::translateToInnerRows(
-            rows, decoded.indices(), decoded.nulls(), innerRows);
+            rows, decoded.indices(), decoded.nulls(&rows), innerRows);
       }
       baseRows = &innerRows;
     }
@@ -676,7 +747,7 @@ class ApproxPercentileAggregate : public exec::Aggregate {
     auto rawLevels = levelElements->rawValues<uint32_t>();
 
     KllSketchAccumulator<T>* accumulator = nullptr;
-    std::vector<typename KllSketch<T>::View> views;
+    std::vector<KllView<T>> views;
     if constexpr (kSingleGroup) {
       views.reserve(rows.end());
     }
@@ -699,12 +770,12 @@ class ApproxPercentileAggregate : public exec::Aggregate {
         }
 
         bool isArray = percentileIsArray->valueAt(i);
-        const double* data;
-        vector_size_t len;
-        std::vector<bool> isNull;
-        extractPercentiles(
-            percentilesBase, indexInBaseVector, data, len, isNull);
-        checkSetPercentile(isArray, data, len, isNull);
+        DecodedVector decodedElements(*percentilesBase->elements());
+        checkSetPercentile(
+            isArray,
+            decodedElements,
+            percentilesBase->offsetAt(indexInBaseVector),
+            percentilesBase->sizeAt(indexInBaseVector));
 
         if (!accuracy->isNullAt(i)) {
           checkSetAccuracy(accuracy->valueAt(i));
@@ -724,7 +795,7 @@ class ApproxPercentileAggregate : public exec::Aggregate {
               maxValue->isNullAt(i) || items->isNullAt(i) ||
               levels->isNullAt(i)));
       }
-      typename KllSketch<T>::View v{
+      KllView<T> v{
           .k = static_cast<uint32_t>(k->valueAt(i)),
           .n = static_cast<size_t>(n->valueAt(i)),
           .minValue = minValue->valueAt(i),
@@ -801,8 +872,12 @@ void addSignatures(
                            .build());
 }
 
-exec::AggregateRegistrationResult registerApproxPercentile(
-    const std::string& name) {
+} // namespace
+
+void registerApproxPercentileAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   for (const auto& inputType :
        {"tinyint", "smallint", "integer", "bigint", "real", "double"}) {
@@ -813,7 +888,8 @@ exec::AggregateRegistrationResult registerApproxPercentile(
         fmt::format("array({})", inputType),
         signatures);
   }
-  return exec::registerAggregateFunction(
+  auto name = prefix + kApproxPercentile;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -901,13 +977,8 @@ exec::AggregateRegistrationResult registerApproxPercentile(
                 type->toString());
         }
       },
-      /*registerCompanionFunctions*/ true);
-}
-
-} // namespace
-
-void registerApproxPercentileAggregate(const std::string& prefix) {
-  registerApproxPercentile(prefix + kApproxPercentile);
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp b/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
index b7cf112c998d9..d237a1ae5433d 100644
--- a/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
@@ -39,10 +39,8 @@ class ArbitraryAggregate : public SimpleNumericAggregate<T, T, T> {
     return sizeof(T);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
+  int32_t accumulatorAlignmentSize() const override {
+    return 1;
   }
 
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
@@ -60,10 +58,11 @@ class ArbitraryAggregate : public SimpleNumericAggregate<T, T, T> {
     DecodedVector decoded(*args[0], rows);
 
     if (decoded.isConstantMapping()) {
-      if (decoded.isNullAt(0)) {
+      auto begin = rows.begin();
+      if (decoded.isNullAt(begin)) {
         return;
       }
-      auto value = decoded.valueAt<T>(0);
+      auto value = decoded.valueAt<T>(begin);
       rows.applyToSelected([&](vector_size_t i) {
         if (exec::Aggregate::isNull(groups[i])) {
           updateValue(groups[i], value);
@@ -101,14 +100,15 @@ class ArbitraryAggregate : public SimpleNumericAggregate<T, T, T> {
       return;
     }
     DecodedVector decoded(*args[0], rows);
+    auto begin = rows.begin();
 
     if (decoded.isConstantMapping()) {
-      if (decoded.isNullAt(0)) {
+      if (decoded.isNullAt(begin)) {
         return;
       }
-      updateValue(group, decoded.valueAt<T>(0));
+      updateValue(group, decoded.valueAt<T>(begin));
     } else if (!decoded.mayHaveNulls()) {
-      updateValue(group, decoded.valueAt<T>(0));
+      updateValue(group, decoded.valueAt<T>(begin));
     } else {
       // Find the first non-null value.
       rows.testSelected([&](vector_size_t i) {
@@ -129,6 +129,13 @@ class ArbitraryAggregate : public SimpleNumericAggregate<T, T, T> {
     addSingleGroupRawInput(group, rows, args, mayPushdown);
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+  }
+
  private:
   inline void updateValue(char* group, T value) {
     exec::Aggregate::clearNull(group);
@@ -136,6 +143,14 @@ class ArbitraryAggregate : public SimpleNumericAggregate<T, T, T> {
   }
 };
 
+/// Override 'accumulatorAlignmentSize' for UnscaledLongDecimal values as it
+/// uses int128_t type. Some CPUs don't support misaligned access to int128_t
+/// type.
+template <>
+inline int32_t ArbitraryAggregate<int128_t>::accumulatorAlignmentSize() const {
+  return static_cast<int32_t>(sizeof(int128_t));
+}
+
 // Arbitrary for non-numeric types. We always keep the first (non-NULL) element
 // seen. Arbitrary (x) will produce partial and final aggregations of type x.
 class NonNumericArbitrary : public exec::Aggregate {
@@ -149,16 +164,6 @@ class NonNumericArbitrary : public exec::Aggregate {
     return sizeof(SingleValueAccumulator);
   }
 
-  // Initialize each group, we will not use the null flags because
-  // SingleValueAccumulator has its own flag.
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    for (auto i : indices) {
-      new (groups[i] + offset_) SingleValueAccumulator();
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     VELOX_CHECK(result);
@@ -183,19 +188,13 @@ class NonNumericArbitrary : public exec::Aggregate {
     extractValues(groups, numGroups, result);
   }
 
-  void destroy(folly::Range<char**> groups) override {
-    for (auto group : groups) {
-      value<SingleValueAccumulator>(group)->destroy(allocator_);
-    }
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       bool /*unused*/) override {
     DecodedVector decoded(*args[0], rows, true);
-    if (decoded.isConstantMapping() && decoded.isNullAt(0)) {
+    if (decoded.isConstantMapping() && decoded.isNullAt(rows.begin())) {
       // nothing to do; all values are nulls
       return;
     }
@@ -226,15 +225,19 @@ class NonNumericArbitrary : public exec::Aggregate {
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       bool /*unused*/) override {
+    auto* accumulator = value<SingleValueAccumulator>(group);
+    if (accumulator->hasValue()) {
+      return;
+    }
+
     DecodedVector decoded(*args[0], rows, true);
-    if (decoded.isConstantMapping() && decoded.isNullAt(0)) {
+    if (decoded.isConstantMapping() && decoded.isNullAt(rows.begin())) {
       // nothing to do; all values are nulls
       return;
     }
 
     const auto* indices = decoded.indices();
     const auto* baseVector = decoded.base();
-    auto* accumulator = value<SingleValueAccumulator>(group);
     // Find the first non-null value.
     rows.testSelected([&](vector_size_t i) {
       if (!decoded.isNullAt(i)) {
@@ -252,9 +255,33 @@ class NonNumericArbitrary : public exec::Aggregate {
       bool mayPushdown) override {
     addSingleGroupRawInput(group, rows, args, mayPushdown);
   }
+
+ protected:
+  // Initialize each group, we will not use the null flags because
+  // SingleValueAccumulator has its own flag.
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto i : indices) {
+      new (groups[i] + offset_) SingleValueAccumulator();
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        value<SingleValueAccumulator>(group)->destroy(allocator_);
+      }
+    }
+  }
 };
 
-exec::AggregateRegistrationResult registerArbitrary(const std::string& name) {
+} // namespace
+
+void registerArbitraryAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .typeVariable("T")
@@ -263,10 +290,11 @@ exec::AggregateRegistrationResult registerArbitrary(const std::string& name) {
           .argumentType("T")
           .build()};
 
-  return exec::registerAggregateFunction(
-      name,
+  std::vector<std::string> names = {prefix + kArbitrary, prefix + kAnyValue};
+  exec::registerAggregateFunction(
+      names,
       std::move(signatures),
-      [name](
+      [name = names.front()](
           core::AggregationNode::Step step,
           const std::vector<TypePtr>& argTypes,
           const TypePtr& /*resultType*/,
@@ -285,6 +313,11 @@ exec::AggregateRegistrationResult registerArbitrary(const std::string& name) {
             return std::make_unique<ArbitraryAggregate<int32_t>>(inputType);
           case TypeKind::BIGINT:
             return std::make_unique<ArbitraryAggregate<int64_t>>(inputType);
+          case TypeKind::HUGEINT:
+            if (inputType->isLongDecimal()) {
+              return std::make_unique<ArbitraryAggregate<int128_t>>(inputType);
+            }
+            VELOX_NYI();
           case TypeKind::REAL:
             return std::make_unique<ArbitraryAggregate<float>>(inputType);
           case TypeKind::DOUBLE:
@@ -309,13 +342,9 @@ exec::AggregateRegistrationResult registerArbitrary(const std::string& name) {
                 name,
                 inputType->kindName());
         }
-      });
-}
-
-} // namespace
-
-void registerArbitraryAggregate(const std::string& prefix) {
-  registerArbitrary(prefix + kArbitrary);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp b/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
index 52966d2958524..988a2fc84b8b6 100644
--- a/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
@@ -15,9 +15,8 @@
  */
 #include "velox/exec/ContainerRowSerde.h"
 #include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/aggregates/ValueList.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/functions/prestosql/aggregates/ValueList.h"
-#include "velox/vector/ComplexVector.h"
 
 namespace facebook::velox::aggregate::prestosql {
 namespace {
@@ -92,14 +91,6 @@ class ArrayAggAggregate : public exec::Aggregate {
         loadedElements);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    for (auto index : indices) {
-      new (groups[index] + offset_) ArrayAccumulator();
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto vector = (*result)->as<ArrayVector>();
@@ -213,9 +204,20 @@ class ArrayAggAggregate : public exec::Aggregate {
     });
   }
 
-  void destroy(folly::Range<char**> groups) override {
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto index : indices) {
+      new (groups[index] + offset_) ArrayAccumulator();
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
     for (auto group : groups) {
-      value<ArrayAccumulator>(group)->elements.free(allocator_);
+      if (isInitialized(group)) {
+        value<ArrayAccumulator>(group)->elements.free(allocator_);
+      }
     }
   }
 
@@ -235,7 +237,12 @@ class ArrayAggAggregate : public exec::Aggregate {
   DecodedVector decodedIntermediate_;
 };
 
-exec::AggregateRegistrationResult registerArray(const std::string& name) {
+} // namespace
+
+void registerArrayAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .typeVariable("E")
@@ -244,7 +251,8 @@ exec::AggregateRegistrationResult registerArray(const std::string& name) {
           .argumentType("E")
           .build()};
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kArrayAgg;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -257,13 +265,39 @@ exec::AggregateRegistrationResult registerArray(const std::string& name) {
         return std::make_unique<ArrayAggAggregate>(
             resultType, config.prestoArrayAggIgnoreNulls());
       },
-      /*registerCompanionFunctions*/ true);
+      withCompanionFunctions,
+      overwrite);
 }
 
-} // namespace
+void registerInternalArrayAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("E")
+          .returnType("array(E)")
+          .intermediateType("array(E)")
+          .argumentType("E")
+          .build()};
 
-void registerArrayAggregate(const std::string& prefix) {
-  registerArray(prefix + kArrayAgg);
+  auto name = prefix + "$internal$array_agg";
+  exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step /*step*/,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(
+            argTypes.size(), 1, "{} takes at most one argument", name);
+        return std::make_unique<ArrayAggAggregate>(
+            resultType, /*ignoreNulls*/ false);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/AverageAggregate.cpp b/velox/functions/prestosql/aggregates/AverageAggregate.cpp
index 36f3123ffaae3..d54c306cceac1 100644
--- a/velox/functions/prestosql/aggregates/AverageAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/AverageAggregate.cpp
@@ -20,7 +20,6 @@
 using namespace facebook::velox::functions::aggregate;
 
 namespace facebook::velox::aggregate::prestosql {
-namespace {
 
 /// Count is BIGINT() while sum and the final aggregates type depends on
 /// the input types:
@@ -30,7 +29,10 @@ namespace {
 ///     REAL            |     DOUBLE          |    REAL
 ///     ALL INTs        |     DOUBLE          |    DOUBLE
 ///     DECIMAL         |     DECIMAL         |    DECIMAL
-exec::AggregateRegistrationResult registerAverage(const std::string& name) {
+void registerAverageAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   for (const auto& inputType : {"smallint", "integer", "bigint", "double"}) {
@@ -55,7 +57,8 @@ exec::AggregateRegistrationResult registerAverage(const std::string& name) {
                            .returnType("DECIMAL(a_precision, a_scale)")
                            .build());
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kAvg;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -131,6 +134,7 @@ exec::AggregateRegistrationResult registerAverage(const std::string& name) {
                 return std::make_unique<DecimalAverageAggregateBase<int64_t>>(
                     resultType);
               }
+              [[fallthrough]];
             default:
               VELOX_FAIL(
                   "Unsupported result type for final aggregation: {}",
@@ -138,12 +142,9 @@ exec::AggregateRegistrationResult registerAverage(const std::string& name) {
           }
         }
       },
-      /*registerCompanionFunctions*/ true);
-}
-} // namespace
-
-void registerAverageAggregate(const std::string& prefix) {
-  registerAverage(prefix + kAvg);
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp b/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
index a5127e37bed2c..d77b31453b156 100644
--- a/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
@@ -101,9 +101,21 @@ class BitwiseAndAggregate : public BitwiseAggregateBase<T> {
 
 } // namespace
 
-void registerBitwiseAggregates(const std::string& prefix) {
-  registerBitwise<BitwiseOrAggregate>(prefix + kBitwiseOr);
-  registerBitwise<BitwiseAndAggregate>(prefix + kBitwiseAnd);
+void registerBitwiseAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
+    bool overwrite) {
+  registerBitwise<BitwiseOrAggregate>(
+      prefix + kBitwiseOr,
+      withCompanionFunctions,
+      onlyPrestoSignatures,
+      overwrite);
+  registerBitwise<BitwiseAndAggregate>(
+      prefix + kBitwiseAnd,
+      withCompanionFunctions,
+      onlyPrestoSignatures,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp b/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
index 415d2dc1bc998..aa3a52d5fa28a 100644
--- a/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
@@ -66,12 +66,19 @@ class BitwiseXorAggregate {
 
 } // namespace
 
-void registerBitwiseXorAggregate(const std::string& prefix) {
+void registerBitwiseXorAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
+    bool overwrite) {
   const std::string name = prefix + kBitwiseXor;
 
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-
-  for (const auto& inputType : {"tinyint", "smallint", "integer", "bigint"}) {
+  std::vector<std::string> typeList{"tinyint", "smallint", "integer", "bigint"};
+  if (onlyPrestoSignatures) {
+    typeList = {"bigint"};
+  }
+  for (const auto& inputType : typeList) {
     signatures.push_back(exec::AggregateFunctionSignatureBuilder()
                              .returnType(inputType)
                              .intermediateType(inputType)
@@ -114,7 +121,8 @@ void registerBitwiseXorAggregate(const std::string& prefix) {
                 inputType->toString());
         }
       },
-      false);
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/BoolAggregates.cpp b/velox/functions/prestosql/aggregates/BoolAggregates.cpp
index 93f83cce2abfc..5095cb373ccaf 100644
--- a/velox/functions/prestosql/aggregates/BoolAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/BoolAggregates.cpp
@@ -62,7 +62,8 @@ class BoolAndOrAggregate : public SimpleNumericAggregate<bool, bool, bool> {
     extractValues(groups, numGroups, result);
   }
 
-  void initializeNewGroups(
+ protected:
+  void initializeNewGroupsInternal(
       char** groups,
       folly::Range<const vector_size_t*> indices) override {
     setAllNulls(groups, indices);
@@ -71,7 +72,6 @@ class BoolAndOrAggregate : public SimpleNumericAggregate<bool, bool, bool> {
     }
   }
 
- protected:
   const bool initialValue_;
 };
 
@@ -178,7 +178,10 @@ class BoolOrAggregate final : public BoolAndOrAggregate {
 };
 
 template <class T>
-exec::AggregateRegistrationResult registerBool(const std::string& name) {
+exec::AggregateRegistrationResult registerBool(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   // TODO Fix signature to match Presto.
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
       exec::AggregateFunctionSignatureBuilder()
@@ -205,15 +208,24 @@ exec::AggregateRegistrationResult registerBool(const std::string& name) {
             name,
             inputType->kindName());
         return std::make_unique<T>();
-      });
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace
 
-void registerBoolAggregates(const std::string& prefix) {
-  registerBool<BoolAndAggregate>(prefix + kBoolAnd);
-  registerBool<BoolAndAggregate>(prefix + kEvery);
-  registerBool<BoolOrAggregate>(prefix + kBoolOr);
+void registerBoolAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerBool<BoolAndAggregate>(
+      prefix + kBoolAnd, withCompanionFunctions, overwrite);
+  registerBool<BoolAndAggregate>(
+      prefix + kEvery, withCompanionFunctions, overwrite);
+  registerBool<BoolOrAggregate>(
+      prefix + kBoolOr, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CMakeLists.txt b/velox/functions/prestosql/aggregates/CMakeLists.txt
index 6b5e31b8c24f0..4e467bab1f665 100644
--- a/velox/functions/prestosql/aggregates/CMakeLists.txt
+++ b/velox/functions/prestosql/aggregates/CMakeLists.txt
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(
   velox_aggregates
   ApproxDistinctAggregate.cpp
   ApproxMostFrequentAggregate.cpp
@@ -24,7 +24,7 @@ add_library(
   BitwiseXorAggregate.cpp
   BoolAggregates.cpp
   CentralMomentsAggregates.cpp
-  Compare.cpp
+  CountAggregate.cpp
   CountIfAggregate.cpp
   CovarianceAggregates.cpp
   ChecksumAggregate.cpp
@@ -34,21 +34,19 @@ add_library(
   MapAggAggregate.cpp
   MapUnionAggregate.cpp
   MapUnionSumAggregate.cpp
+  MaxSizeForStatsAggregate.cpp
   MinMaxAggregates.cpp
   MinMaxByAggregates.cpp
   MultiMapAggAggregate.cpp
-  CountAggregate.cpp
   PrestoHasher.cpp
   ReduceAgg.cpp
+  RegisterAggregateFunctions.cpp
   SetAggregates.cpp
   SumAggregate.cpp
-  ValueList.cpp
-  VarianceAggregates.cpp
-  MaxSizeForStatsAggregate.cpp
   SumDataSizeForStatsAggregate.cpp
-  RegisterAggregateFunctions.cpp)
+  VarianceAggregates.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_aggregates
   velox_common_hyperloglog
   velox_exec
diff --git a/velox/functions/prestosql/aggregates/CentralMomentsAggregates.cpp b/velox/functions/prestosql/aggregates/CentralMomentsAggregates.cpp
index 2c5b9c28d2a33..35b3b529b143c 100644
--- a/velox/functions/prestosql/aggregates/CentralMomentsAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/CentralMomentsAggregates.cpp
@@ -13,112 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/exec/Aggregate.h"
+#include "velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/vector/FlatVector.h"
-
-namespace facebook::velox::aggregate::prestosql {
-
-namespace {
-// Indices into RowType representing intermediate results of skewness and
-// kurtosis. Columns appear in alphabetical order.
-struct CentralMomentsIndices {
-  int32_t count;
-  int32_t m1;
-  int32_t m2;
-  int32_t m3;
-  int32_t m4;
-};
-constexpr CentralMomentsIndices kCentralMomentsIndices{0, 1, 2, 3, 4};
-
-struct CentralMomentsAccumulator {
-  double count() const {
-    return count_;
-  }
-
-  double m1() const {
-    return m1_;
-  }
-
-  double m2() const {
-    return m2_;
-  }
-
-  double m3() const {
-    return m3_;
-  }
-
-  double m4() const {
-    return m4_;
-  }
-
-  void update(double value) {
-    double oldCount = count();
-    count_ += 1;
-    double oldM1 = m1();
-    double oldM2 = m2();
-    double oldM3 = m3();
-    double delta = value - oldM1;
-    double deltaN = delta / count();
-    double deltaN2 = deltaN * deltaN;
-    double dm2 = delta * deltaN * oldCount;
-
-    m1_ += deltaN;
-    m2_ += dm2;
-    m3_ += dm2 * deltaN * (count() - 2) - 3 * deltaN * oldM2;
-    m4_ += dm2 * deltaN2 * (count() * (double)count() - 3 * count() + 3) +
-        6 * deltaN2 * oldM2 - 4 * deltaN * oldM3;
-  }
-
-  inline void merge(const CentralMomentsAccumulator& other) {
-    merge(other.count(), other.m1(), other.m2(), other.m3(), other.m4());
-  }
-
-  void merge(
-      double otherCount,
-      double otherM1,
-      double otherM2,
-      double otherM3,
-      double otherM4) {
-    if (otherCount == 0) {
-      return;
-    }
-
-    double oldCount = count();
-    count_ += otherCount;
 
-    double oldM1 = m1();
-    double oldM2 = m2();
-    double oldM3 = m3();
-    double delta = otherM1 - oldM1;
-    double delta2 = delta * delta;
-    double delta3 = delta * delta2;
-    double delta4 = delta2 * delta2;
+using namespace facebook::velox::functions::aggregate;
 
-    m1_ = (oldCount * oldM1 + otherCount * otherM1) / count();
-    m2_ += otherM2 + delta2 * oldCount * otherCount / count();
-    m3_ += otherM3 +
-        delta3 * oldCount * otherCount * (oldCount - otherCount) /
-            (count() * count()) +
-        3 * delta * (oldCount * otherM2 - otherCount * oldM2) / count();
-    m4_ += otherM4 +
-        delta4 * oldCount * otherCount *
-            (oldCount * oldCount - oldCount * otherCount +
-             otherCount * otherCount) /
-            (count() * count() * count()) +
-        6 * delta2 *
-            (oldCount * oldCount * otherM2 + otherCount * otherCount * oldM2) /
-            (count() * count()) +
-        4 * delta * (oldCount * otherM3 - otherCount * oldM3) / count();
-  }
-
- private:
-  int64_t count_{0};
-  double m1_{0};
-  double m2_{0};
-  double m3_{0};
-  double m4_{0};
-};
+namespace facebook::velox::aggregate::prestosql {
 
 struct SkewnessResultAccessor {
   static bool hasResult(const CentralMomentsAccumulator& accumulator) {
@@ -146,353 +48,11 @@ struct KurtosisResultAccessor {
   }
 };
 
-template <typename T>
-SimpleVector<T>* asSimpleVector(
-    const RowVector* rowVector,
-    int32_t childIndex) {
-  auto result = rowVector->childAt(childIndex)->as<SimpleVector<T>>();
-  VELOX_CHECK_NOT_NULL(result);
-  return result;
-}
-
-class CentralMomentsIntermediateInput {
- public:
-  explicit CentralMomentsIntermediateInput(
-      const RowVector* rowVector,
-      const CentralMomentsIndices& indices = kCentralMomentsIndices)
-      : count_{asSimpleVector<int64_t>(rowVector, indices.count)},
-        m1_{asSimpleVector<double>(rowVector, indices.m1)},
-        m2_{asSimpleVector<double>(rowVector, indices.m2)},
-        m3_{asSimpleVector<double>(rowVector, indices.m3)},
-        m4_{asSimpleVector<double>(rowVector, indices.m4)} {}
-
-  void mergeInto(CentralMomentsAccumulator& accumulator, vector_size_t row) {
-    accumulator.merge(
-        count_->valueAt(row),
-        m1_->valueAt(row),
-        m2_->valueAt(row),
-        m3_->valueAt(row),
-        m4_->valueAt(row));
-  }
-
- protected:
-  SimpleVector<int64_t>* count_;
-  SimpleVector<double>* m1_;
-  SimpleVector<double>* m2_;
-  SimpleVector<double>* m3_;
-  SimpleVector<double>* m4_;
-};
-
-template <typename T>
-T* mutableRawValues(const RowVector* rowVector, int32_t childIndex) {
-  return rowVector->childAt(childIndex)
-      ->as<FlatVector<T>>()
-      ->mutableRawValues();
-}
-
-class CentralMomentsIntermediateResult {
- public:
-  explicit CentralMomentsIntermediateResult(
-      const RowVector* rowVector,
-      const CentralMomentsIndices& indices = kCentralMomentsIndices)
-      : count_{mutableRawValues<int64_t>(rowVector, indices.count)},
-        m1_{mutableRawValues<double>(rowVector, indices.m1)},
-        m2_{mutableRawValues<double>(rowVector, indices.m2)},
-        m3_{mutableRawValues<double>(rowVector, indices.m3)},
-        m4_{mutableRawValues<double>(rowVector, indices.m4)} {}
-
-  static std::string type() {
-    return "row(bigint,double,double,double,double)";
-  }
-
-  void set(vector_size_t row, const CentralMomentsAccumulator& accumulator) {
-    count_[row] = accumulator.count();
-    m1_[row] = accumulator.m1();
-    m2_[row] = accumulator.m2();
-    m3_[row] = accumulator.m3();
-    m4_[row] = accumulator.m4();
-  }
-
- private:
-  int64_t* count_;
-  double* m1_;
-  double* m2_;
-  double* m3_;
-  double* m4_;
-};
-
-// T is the input type for partial aggregation, it can be integer, double or
-// float. Not used for final aggregation. TResultAccessor is the type of the
-// static struct that will access the result in a certain way from the
-// CentralMoments Accumulator.
-template <typename T, typename TResultAccessor>
-class CentralMomentsAggregate : public exec::Aggregate {
- public:
-  explicit CentralMomentsAggregate(TypePtr resultType)
-      : exec::Aggregate(resultType) {}
-
-  int32_t accumulatorAlignmentSize() const override {
-    return alignof(CentralMomentsAccumulator);
-  }
-
-  int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(CentralMomentsAccumulator);
-  }
-
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) CentralMomentsAccumulator();
-    }
-  }
-
-  void addRawInput(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /* mayPushdown */) override {
-    decodedRaw_.decode(*args[0], rows);
-    if (decodedRaw_.isConstantMapping()) {
-      if (!decodedRaw_.isNullAt(0)) {
-        auto value = decodedRaw_.valueAt<T>(0);
-        rows.applyToSelected(
-            [&](vector_size_t i) { updateNonNullValue(groups[i], value); });
-      }
-    } else if (decodedRaw_.mayHaveNulls()) {
-      rows.applyToSelected([&](vector_size_t i) {
-        if (decodedRaw_.isNullAt(i)) {
-          return;
-        }
-        updateNonNullValue(groups[i], decodedRaw_.valueAt<T>(i));
-      });
-    } else if (!exec::Aggregate::numNulls_ && decodedRaw_.isIdentityMapping()) {
-      auto data = decodedRaw_.data<T>();
-      rows.applyToSelected([&](vector_size_t i) {
-        updateNonNullValue<false>(groups[i], data[i]);
-      });
-    } else {
-      rows.applyToSelected([&](vector_size_t i) {
-        updateNonNullValue(groups[i], decodedRaw_.valueAt<T>(i));
-      });
-    }
-  }
-
-  void addSingleGroupRawInput(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    decodedRaw_.decode(*args[0], rows);
-
-    if (decodedRaw_.isConstantMapping()) {
-      if (!decodedRaw_.isNullAt(0)) {
-        auto value = decodedRaw_.valueAt<T>(0);
-        rows.applyToSelected(
-            [&](vector_size_t i) { updateNonNullValue(group, value); });
-      }
-    } else if (decodedRaw_.mayHaveNulls()) {
-      rows.applyToSelected([&](vector_size_t i) {
-        if (!decodedRaw_.isNullAt(i)) {
-          updateNonNullValue(group, decodedRaw_.valueAt<T>(i));
-        }
-      });
-    } else if (!exec::Aggregate::numNulls_ && decodedRaw_.isIdentityMapping()) {
-      auto data = decodedRaw_.data<T>();
-      CentralMomentsAccumulator accData;
-      rows.applyToSelected([&](vector_size_t i) { accData.update(data[i]); });
-      updateNonNullValue<false>(group, accData);
-    } else {
-      CentralMomentsAccumulator accData;
-      rows.applyToSelected(
-          [&](vector_size_t i) { accData.update(decodedRaw_.valueAt<T>(i)); });
-      updateNonNullValue(group, accData);
-    }
-  }
-
-  void addIntermediateResults(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /* mayPushdown */) override {
-    decodedPartial_.decode(*args[0], rows);
-
-    auto baseRowVector = dynamic_cast<const RowVector*>(decodedPartial_.base());
-    CentralMomentsIntermediateInput input{baseRowVector};
-
-    if (decodedPartial_.isConstantMapping()) {
-      if (!decodedPartial_.isNullAt(0)) {
-        auto decodedIndex = decodedPartial_.index(0);
-        rows.applyToSelected([&](vector_size_t i) {
-          exec::Aggregate::clearNull(groups[i]);
-          input.mergeInto(*accumulator(groups[i]), decodedIndex);
-        });
-      }
-    } else if (decodedPartial_.mayHaveNulls()) {
-      rows.applyToSelected([&](vector_size_t i) {
-        if (decodedPartial_.isNullAt(i)) {
-          return;
-        }
-        auto decodedIndex = decodedPartial_.index(i);
-        exec::Aggregate::clearNull(groups[i]);
-        input.mergeInto(*accumulator(groups[i]), decodedIndex);
-      });
-    } else {
-      rows.applyToSelected([&](vector_size_t i) {
-        auto decodedIndex = decodedPartial_.index(i);
-        exec::Aggregate::clearNull(groups[i]);
-        input.mergeInto(*accumulator(groups[i]), decodedIndex);
-      });
-    }
-  }
-
-  void addSingleGroupIntermediateResults(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /* mayPushdown */) override {
-    decodedPartial_.decode(*args[0], rows);
-    auto baseRowVector = dynamic_cast<const RowVector*>(decodedPartial_.base());
-    CentralMomentsIntermediateInput input{baseRowVector};
-
-    if (decodedPartial_.isConstantMapping()) {
-      if (!decodedPartial_.isNullAt(0)) {
-        auto decodedIndex = decodedPartial_.index(0);
-        CentralMomentsAccumulator accData;
-        rows.applyToSelected(
-            [&](vector_size_t i) { input.mergeInto(accData, decodedIndex); });
-        updateNonNullValue(group, accData);
-      }
-    } else if (decodedPartial_.mayHaveNulls()) {
-      rows.applyToSelected([&](vector_size_t i) {
-        if (decodedPartial_.isNullAt(i)) {
-          return;
-        }
-        auto decodedIndex = decodedPartial_.index(i);
-        exec::Aggregate::clearNull(group);
-        input.mergeInto(*accumulator(group), decodedIndex);
-      });
-    } else {
-      CentralMomentsAccumulator accData;
-      rows.applyToSelected([&](vector_size_t i) {
-        auto decodedIndex = decodedPartial_.index(i);
-        input.mergeInto(accData, decodedIndex);
-      });
-      updateNonNullValue(group, accData);
-    }
-  }
-
-  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    auto vector = (*result)->as<FlatVector<double>>();
-    VELOX_CHECK(vector);
-    vector->resize(numGroups);
-    uint64_t* rawNulls = getRawNulls(vector);
-
-    double* rawValues = vector->mutableRawValues();
-    for (auto i = 0; i < numGroups; ++i) {
-      char* group = groups[i];
-      if (isNull(group)) {
-        vector->setNull(i, true);
-      } else {
-        auto* accData = accumulator(group);
-        if (TResultAccessor::hasResult(*accData)) {
-          clearNull(rawNulls, i);
-          rawValues[i] = TResultAccessor::result(*accData);
-        } else {
-          vector->setNull(i, true);
-        }
-      }
-    }
-  }
-
-  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    auto rowVector = (*result)->as<RowVector>();
-    rowVector->resize(numGroups);
-    for (auto& child : rowVector->children()) {
-      child->resize(numGroups);
-    }
-
-    uint64_t* rawNulls = getRawNulls(rowVector);
-
-    CentralMomentsIntermediateResult centralMomentsResult{rowVector};
-
-    for (auto i = 0; i < numGroups; ++i) {
-      char* group = groups[i];
-      if (isNull(group)) {
-        rowVector->setNull(i, true);
-      } else {
-        clearNull(rawNulls, i);
-        centralMomentsResult.set(i, *accumulator(group));
-      }
-    }
-  }
-
- private:
-  template <bool tableHasNulls = true>
-  inline void updateNonNullValue(char* group, T value) {
-    if constexpr (tableHasNulls) {
-      exec::Aggregate::clearNull(group);
-    }
-    CentralMomentsAccumulator* accData = accumulator(group);
-    accData->update((double)value);
-  }
-
-  template <bool tableHasNulls = true>
-  inline void updateNonNullValue(
-      char* group,
-      const CentralMomentsAccumulator& accData) {
-    if constexpr (tableHasNulls) {
-      exec::Aggregate::clearNull(group);
-    }
-    CentralMomentsAccumulator* thisAccData = accumulator(group);
-    thisAccData->merge(accData);
-  }
-
-  inline CentralMomentsAccumulator* accumulator(char* group) {
-    return exec::Aggregate::value<CentralMomentsAccumulator>(group);
-  }
-
-  DecodedVector decodedRaw_;
-  DecodedVector decodedPartial_;
-};
-
-void checkAccumulatorRowType(
-    const TypePtr& type,
-    const std::string& errorMessage) {
-  VELOX_CHECK_EQ(type->kind(), TypeKind::ROW, "{}", errorMessage);
-  VELOX_CHECK_EQ(
-      type->childAt(kCentralMomentsIndices.count)->kind(),
-      TypeKind::BIGINT,
-      "{}",
-      errorMessage);
-  VELOX_CHECK_EQ(
-      type->childAt(kCentralMomentsIndices.m1)->kind(),
-      TypeKind::DOUBLE,
-      "{}",
-      errorMessage);
-  VELOX_CHECK_EQ(
-      type->childAt(kCentralMomentsIndices.m2)->kind(),
-      TypeKind::DOUBLE,
-      "{}",
-      errorMessage);
-  VELOX_CHECK_EQ(
-      type->childAt(kCentralMomentsIndices.m3)->kind(),
-      TypeKind::DOUBLE,
-      "{}",
-      errorMessage);
-  VELOX_CHECK_EQ(
-      type->childAt(kCentralMomentsIndices.m4)->kind(),
-      TypeKind::DOUBLE,
-      "{}",
-      errorMessage);
-}
-
 template <typename TResultAccessor>
 exec::AggregateRegistrationResult registerCentralMoments(
-    const std::string& name) {
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   std::vector<std::string> inputTypes = {
       "smallint", "integer", "bigint", "real", "double"};
@@ -521,45 +81,52 @@ exec::AggregateRegistrationResult registerCentralMoments(
           switch (inputType->kind()) {
             case TypeKind::SMALLINT:
               return std::make_unique<
-                  CentralMomentsAggregate<int16_t, TResultAccessor>>(
+                  CentralMomentsAggregatesBase<int16_t, TResultAccessor>>(
                   resultType);
             case TypeKind::INTEGER:
               return std::make_unique<
-                  CentralMomentsAggregate<int32_t, TResultAccessor>>(
+                  CentralMomentsAggregatesBase<int32_t, TResultAccessor>>(
                   resultType);
             case TypeKind::BIGINT:
               return std::make_unique<
-                  CentralMomentsAggregate<int64_t, TResultAccessor>>(
+                  CentralMomentsAggregatesBase<int64_t, TResultAccessor>>(
                   resultType);
             case TypeKind::DOUBLE:
               return std::make_unique<
-                  CentralMomentsAggregate<double, TResultAccessor>>(resultType);
+                  CentralMomentsAggregatesBase<double, TResultAccessor>>(
+                  resultType);
             case TypeKind::REAL:
               return std::make_unique<
-                  CentralMomentsAggregate<float, TResultAccessor>>(resultType);
+                  CentralMomentsAggregatesBase<float, TResultAccessor>>(
+                  resultType);
             default:
               VELOX_UNSUPPORTED(
                   "Unsupported input type: {}. "
                   "Expected SMALLINT, INTEGER, BIGINT, DOUBLE or REAL.",
-                  inputType->toString())
+                  inputType->toString());
           }
         } else {
           checkAccumulatorRowType(
               inputType,
               "Input type for final aggregation must be "
               "(count:bigint, m1:double, m2:double, m3:double, m4:double) struct");
-          // final agg not use template T, int64_t here has no effect.
-          return std::make_unique<
-              CentralMomentsAggregate<int64_t, TResultAccessor>>(resultType);
+          return std::make_unique<CentralMomentsAggregatesBase<
+              int64_t /*unused*/,
+              TResultAccessor>>(resultType);
         }
-      });
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
-} // namespace
-
-void registerCentralMomentsAggregates(const std::string& prefix) {
-  registerCentralMoments<KurtosisResultAccessor>(prefix + kKurtosis);
-  registerCentralMoments<SkewnessResultAccessor>(prefix + kSkewness);
+void registerCentralMomentsAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerCentralMoments<KurtosisResultAccessor>(
+      prefix + kKurtosis, withCompanionFunctions, overwrite);
+  registerCentralMoments<SkewnessResultAccessor>(
+      prefix + kSkewness, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp b/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
index 0f48fd26867e1..458be12c497c3 100644
--- a/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
@@ -40,15 +40,6 @@ class ChecksumAggregate : public exec::Aggregate {
     return sizeof(int64_t);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      *value<int64_t>(groups[i]) = 0;
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto* vector = (*result)->asUnchecked<FlatVector<StringView>>();
@@ -91,6 +82,17 @@ class ChecksumAggregate : public exec::Aggregate {
       const std::vector<VectorPtr>& args,
       bool /*mayPushDown*/) override {
     const auto& arg = args[0];
+
+    if (arg->type()->isUnKnown()) {
+      rows.applyToSelected([&](auto row) {
+        auto group = groups[row];
+        clearNull(group);
+        computeHashForNull(group);
+      });
+
+      return;
+    }
+
     auto hasher = getPrestoHasher(arg->type());
     auto hashes = getHashBuffer(rows.end(), arg->pool());
     hasher->hash(arg, rows, hashes);
@@ -137,6 +139,16 @@ class ChecksumAggregate : public exec::Aggregate {
       const std::vector<VectorPtr>& args,
       bool /*mayPushDown*/) override {
     const auto& arg = args[0];
+
+    if (arg->type()->isUnKnown()) {
+      rows.applyToSelected([&](auto row) {
+        clearNull(group);
+        computeHashForNull(group);
+      });
+
+      return;
+    }
+
     auto hasher = getPrestoHasher(arg->type());
     auto hashes = getHashBuffer(rows.end(), arg->pool());
     hasher->hash(arg, rows, hashes);
@@ -173,6 +185,16 @@ class ChecksumAggregate : public exec::Aggregate {
     safeAdd(*value<int64_t>(group), result);
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      *value<int64_t>(groups[i]) = 0;
+    }
+  }
+
  private:
   FOLLY_ALWAYS_INLINE void computeHash(char* group, const int64_t hash) {
     *value<int64_t>(group) += hash * XXH_PRIME64_1;
@@ -207,7 +229,12 @@ class ChecksumAggregate : public exec::Aggregate {
   DecodedVector decodedIntermediate_;
 };
 
-exec::AggregateRegistrationResult registerChecksum(const std::string& name) {
+} // namespace
+
+void registerChecksumAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .typeVariable("T")
@@ -217,7 +244,8 @@ exec::AggregateRegistrationResult registerChecksum(const std::string& name) {
           .build(),
   };
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kChecksum;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [&name](
@@ -233,13 +261,10 @@ exec::AggregateRegistrationResult registerChecksum(const std::string& name) {
         }
 
         return std::make_unique<ChecksumAggregate>(VARBINARY());
-      });
-}
-
-} // namespace
-
-void registerChecksumAggregate(const std::string& prefix) {
-  registerChecksum(prefix + kChecksum);
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/Compare.cpp b/velox/functions/prestosql/aggregates/Compare.cpp
deleted file mode 100644
index e751bc9e6eff0..0000000000000
--- a/velox/functions/prestosql/aggregates/Compare.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/functions/prestosql/aggregates/Compare.h"
-
-using namespace facebook::velox::functions::aggregate;
-
-namespace facebook::velox::aggregate::prestosql {
-
-int32_t compare(
-    const SingleValueAccumulator* accumulator,
-    const DecodedVector& decoded,
-    vector_size_t index) {
-  static const CompareFlags kCompareFlags{
-      true, // nullsFirst
-      true, // ascending
-      false, // equalsOnly
-      CompareFlags::NullHandlingMode::StopAtNull};
-
-  auto result = accumulator->compare(decoded, index, kCompareFlags);
-  VELOX_USER_CHECK(
-      result.has_value(),
-      fmt::format(
-          "{} comparison not supported for values that contain nulls",
-          mapTypeKindToName(decoded.base()->typeKind())));
-  return result.value();
-}
-
-bool checkNestedNulls(
-    const DecodedVector& decoded,
-    const vector_size_t* indices,
-    vector_size_t index,
-    bool throwOnNestedNulls) {
-  if (decoded.isNullAt(index)) {
-    return true;
-  }
-
-  if (throwOnNestedNulls) {
-    VELOX_USER_CHECK(
-        !decoded.base()->containsNullAt(indices[index]),
-        "{} comparison not supported for values that contain nulls",
-        mapTypeKindToName(decoded.base()->typeKind()));
-  }
-
-  return false;
-}
-
-} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/Compare.h b/velox/functions/prestosql/aggregates/Compare.h
deleted file mode 100644
index 6a5661ecbc1ef..0000000000000
--- a/velox/functions/prestosql/aggregates/Compare.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "velox/common/memory/HashStringAllocator.h"
-#include "velox/functions/lib/aggregates/SingleValueAccumulator.h"
-#include "velox/vector/DecodedVector.h"
-
-namespace facebook::velox::aggregate::prestosql {
-
-/// Compare the new value of the DecodedVector at the given index with the value
-/// stored in the SingleValueAccumulator. Returns 0 if stored and new values are
-/// equal; <0 if stored value is less then new value; >0 if stored value is
-/// greater than new value.
-///
-/// The default nullHandlingMode in Presto is StopAtNull so it will throw an
-/// exception when complex type values contain nulls.
-int32_t compare(
-    const velox::functions::aggregate::SingleValueAccumulator* accumulator,
-    const DecodedVector& decoded,
-    vector_size_t index);
-
-/// Checks nested nulls in a complex type vector. Returns true if value at
-/// specified index is null. Throws an exception if the base vector contains
-/// nulls if 'throwOnNestedNulls' is true.
-bool checkNestedNulls(
-    const DecodedVector& decoded,
-    const vector_size_t* indices,
-    vector_size_t index,
-    bool throwOnNestedNulls);
-
-} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CountAggregate.cpp b/velox/functions/prestosql/aggregates/CountAggregate.cpp
index 0cfb8ba61c932..8b484ef4c8fae 100644
--- a/velox/functions/prestosql/aggregates/CountAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/CountAggregate.cpp
@@ -15,8 +15,10 @@
  */
 #include "velox/common/base/Exceptions.h"
 #include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/aggregates/SumAggregateBase.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/functions/prestosql/aggregates/SumAggregate.h"
+
+using namespace facebook::velox::functions::aggregate;
 
 namespace facebook::velox::aggregate::prestosql {
 
@@ -32,15 +34,6 @@ class CountAggregate : public SimpleNumericAggregate<bool, int64_t, int64_t> {
     return sizeof(int64_t);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    for (auto i : indices) {
-      // result of count is never null
-      *value<int64_t>(groups[i]) = (int64_t)0;
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     BaseAggregate::doExtractValues(groups, numGroups, result, [&](char* group) {
@@ -138,6 +131,16 @@ class CountAggregate : public SimpleNumericAggregate<bool, int64_t, int64_t> {
     addToGroup(group, count);
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto i : indices) {
+      // result of count is never null
+      *value<int64_t>(groups[i]) = (int64_t)0;
+    }
+  }
+
  private:
   inline void addToGroup(char* group, int64_t count) {
     *value<int64_t>(group) += count;
@@ -146,7 +149,12 @@ class CountAggregate : public SimpleNumericAggregate<bool, int64_t, int64_t> {
   DecodedVector decodedIntermediate_;
 };
 
-exec::AggregateRegistrationResult registerCount(const std::string& name) {
+} // namespace
+
+void registerCountAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .returnType("bigint")
@@ -160,7 +168,8 @@ exec::AggregateRegistrationResult registerCount(const std::string& name) {
           .build(),
   };
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kCount;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -172,13 +181,10 @@ exec::AggregateRegistrationResult registerCount(const std::string& name) {
         VELOX_CHECK_LE(
             argTypes.size(), 1, "{} takes at most one argument", name);
         return std::make_unique<CountAggregate>();
-      });
-}
-
-} // namespace
-
-void registerCountAggregate(const std::string& prefix) {
-  registerCount(prefix + kCount);
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CountIfAggregate.cpp b/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
index 5b053c823a950..5da65ec7ce4a3 100644
--- a/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
@@ -33,14 +33,6 @@ class CountIfAggregate : public exec::Aggregate {
     return sizeof(int64_t);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    for (auto i : indices) {
-      *value<int64_t>(groups[i]) = 0;
-    }
-  }
-
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     extractValues(groups, numGroups, result);
@@ -162,13 +154,27 @@ class CountIfAggregate : public exec::Aggregate {
     addToGroup(group, numTrue);
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto i : indices) {
+      *value<int64_t>(groups[i]) = 0;
+    }
+  }
+
  private:
   inline void addToGroup(char* group, int64_t numTrue) {
     *value<int64_t>(group) += numTrue;
   }
 };
 
-exec::AggregateRegistrationResult registerCountIf(const std::string& name) {
+} // namespace
+
+void registerCountIfAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .returnType("bigint")
@@ -177,7 +183,8 @@ exec::AggregateRegistrationResult registerCountIf(const std::string& name) {
           .build(),
   };
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kCountIf;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -198,13 +205,10 @@ exec::AggregateRegistrationResult registerCountIf(const std::string& name) {
         }
 
         return std::make_unique<CountIfAggregate>();
-      });
-}
-
-} // namespace
-
-void registerCountIfAggregate(const std::string& prefix) {
-  registerCountIf(prefix + kCountIf);
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/CovarianceAggregates.cpp b/velox/functions/prestosql/aggregates/CovarianceAggregates.cpp
index a9b9007e770d3..eb7b4c0a3132c 100644
--- a/velox/functions/prestosql/aggregates/CovarianceAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/CovarianceAggregates.cpp
@@ -44,11 +44,12 @@ constexpr CorrIndices kCorrIndices{{1, 4, 5, 0}, 2, 3};
 // regr_intercept.
 struct RegrIndices : public CovarIndices {
   int32_t m2X;
+  int32_t m2Y;
 };
-constexpr RegrIndices kRegrIndices{{1, 3, 4, 0}, 2};
+constexpr RegrIndices kRegrIndices{{1, 3, 4, 0}, 2, 5};
 
 struct CovarAccumulator {
-  double count() const {
+  int64_t count() const {
     return count_;
   }
 
@@ -81,6 +82,13 @@ struct CovarAccumulator {
     if (countOther == 0) {
       return;
     }
+    if (count_ == 0) {
+      count_ = countOther;
+      meanX_ = meanXOther;
+      meanY_ = meanYOther;
+      c2_ = c2Other;
+      return;
+    }
 
     int64_t newCount = countOther + count();
     double deltaMeanX = meanXOther - meanX();
@@ -215,12 +223,14 @@ struct CorrAccumulator : public CovarAccumulator {
       return;
     }
 
-    m2X_ += m2XOther +
-        count() * countOther * std::pow(meanX() - meanXOther, 2) /
-            (double)(count() + countOther);
-    m2Y_ += m2YOther +
-        count() * countOther * std::pow(meanY() - meanYOther, 2) /
-            (double)(count() + countOther);
+    if (count() == 0) {
+      m2X_ = m2XOther;
+      m2Y_ = m2YOther;
+    } else {
+      auto k = 1.0 * count() / (count() + countOther) * countOther;
+      m2X_ += m2XOther + k * std::pow(meanX() - meanXOther, 2);
+      m2Y_ += m2YOther + k * std::pow(meanY() - meanYOther, 2);
+    }
 
     CovarAccumulator::merge(countOther, meanXOther, meanYOther, c2Other);
   }
@@ -307,15 +317,132 @@ struct RegrAccumulator : public CovarAccumulator {
     if (countOther == 0) {
       return;
     }
+    if (count() == 0) {
+      m2X_ = m2XOther;
+    } else {
+      m2X_ += m2XOther +
+          1.0 * count() / (count() + countOther) * countOther *
+              std::pow(meanX() - meanXOther, 2);
+    }
+    CovarAccumulator::merge(countOther, meanXOther, meanYOther, c2Other);
+  }
+
+ protected:
+  double m2X_{0};
+};
+
+struct ExtendedRegrAccumulator : public RegrAccumulator {
+  double m2Y() const {
+    return m2Y_;
+  }
+
+  void update(double x, double y) {
+    double oldMeanY = meanY();
+    RegrAccumulator::update(x, y);
+    m2Y_ += (y - oldMeanY) * (y - meanY());
+  }
+
+  void merge(
+      int64_t countOther,
+      double meanXOther,
+      double meanYOther,
+      double c2Other,
+      double m2XOther,
+      double m2YOther) {
+    if (countOther == 0) {
+      return;
+    }
+    if (count() == 0) {
+      m2X_ = m2XOther;
+      m2Y_ = m2YOther;
+    } else {
+      m2X_ += m2XOther +
+          1.0 * count() / (count() + countOther) * countOther *
+              std::pow(meanX() - meanXOther, 2);
 
-    m2X_ += m2XOther +
-        count() / (count() + countOther) * countOther *
-            std::pow(meanX() - meanXOther, 2);
+      m2Y_ += m2YOther +
+          1.0 * count() / (count() + countOther) * countOther *
+              std::pow(meanY() - meanYOther, 2);
+    }
     CovarAccumulator::merge(countOther, meanXOther, meanYOther, c2Other);
   }
 
  private:
-  double m2X_{0};
+  double m2Y_{0};
+};
+
+struct RegrCountResultAccessor {
+  static bool hasResult(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.count() > 0;
+  }
+
+  static double result(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.count();
+  }
+};
+
+struct RegrAvgyResultAccessor {
+  static bool hasResult(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.count() > 0;
+  }
+
+  static double result(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.meanY();
+  }
+};
+
+struct RegrAvgxResultAccessor {
+  static bool hasResult(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.count() > 0;
+  }
+
+  static double result(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.meanX();
+  }
+};
+
+struct RegrSxyResultAccessor {
+  static bool hasResult(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.count() > 0;
+  }
+
+  static double result(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.c2();
+  }
+};
+
+struct RegrR2ResultAccessor {
+  static bool hasResult(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.m2X() != 0;
+  }
+
+  static double result(const ExtendedRegrAccumulator& accumulator) {
+    if (accumulator.m2X() != 0 && accumulator.m2Y() == 0) {
+      return 1;
+    }
+    return std::pow(accumulator.c2(), 2) /
+        (accumulator.m2X() * accumulator.m2Y());
+  }
+};
+
+struct RegrSyyResultAccessor {
+  static bool hasResult(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.count() > 0;
+  }
+
+  static double result(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.m2Y();
+  }
+};
+
+struct RegrSxxResultAccessor {
+  static bool hasResult(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.count() > 0;
+  }
+
+  static double result(const ExtendedRegrAccumulator& accumulator) {
+    return accumulator.m2X();
+  }
 };
 
 struct RegrSlopeResultAccessor {
@@ -354,10 +481,30 @@ class RegrIntermediateInput : public CovarIntermediateInput {
         m2X_->valueAt(row));
   }
 
- private:
+ protected:
   SimpleVector<double>* m2X_;
 };
 
+class ExtendedRegrIntermediateInput : public RegrIntermediateInput {
+ public:
+  explicit ExtendedRegrIntermediateInput(const RowVector* rowVector)
+      : RegrIntermediateInput(rowVector),
+        m2Y_{asSimpleVector<double>(rowVector, kRegrIndices.m2Y)} {}
+
+  void mergeInto(ExtendedRegrAccumulator& accumulator, vector_size_t row) {
+    accumulator.merge(
+        count_->valueAt(row),
+        meanX_->valueAt(row),
+        meanY_->valueAt(row),
+        c2_->valueAt(row),
+        m2X_->valueAt(row),
+        m2Y_->valueAt(row));
+  }
+
+ private:
+  SimpleVector<double>* m2Y_;
+};
+
 class RegrIntermediateResult : public CovarIntermediateResult {
  public:
   explicit RegrIntermediateResult(const RowVector* rowVector)
@@ -377,6 +524,25 @@ class RegrIntermediateResult : public CovarIntermediateResult {
   double* m2X_;
 };
 
+class ExtendedRegrIntermediateResult : public RegrIntermediateResult {
+ public:
+  explicit ExtendedRegrIntermediateResult(const RowVector* rowVector)
+      : RegrIntermediateResult(rowVector),
+        m2Y_{mutableRawValues<double>(rowVector, kRegrIndices.m2Y)} {}
+
+  static std::string type() {
+    return "row(double,bigint,double,double,double,double)";
+  }
+
+  void set(vector_size_t row, const ExtendedRegrAccumulator& accumulator) {
+    RegrIntermediateResult::set(row, accumulator);
+    m2Y_[row] = accumulator.m2Y();
+  }
+
+ private:
+  double* m2Y_;
+};
+
 // @tparam T Type of the raw input and final result. Can be double or float.
 template <
     typename T,
@@ -393,21 +559,14 @@ class CovarianceAggregate : public exec::Aggregate {
     return sizeof(TAccumulator);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) TAccumulator();
-    }
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       bool /* mayPushdown */) override {
-    if constexpr (std::is_same_v<TAccumulator, RegrAccumulator>) {
+    if constexpr (
+        std::is_same_v<TAccumulator, RegrAccumulator> ||
+        std::is_same_v<TAccumulator, ExtendedRegrAccumulator>) {
       // The args order of linear regression function is (y, x), so we need to
       // swap the order
       decodedX_.decode(*args[1], rows);
@@ -454,7 +613,9 @@ class CovarianceAggregate : public exec::Aggregate {
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       bool /* mayPushdown */) override {
-    if constexpr (std::is_same_v<TAccumulator, RegrAccumulator>) {
+    if constexpr (
+        std::is_same_v<TAccumulator, RegrAccumulator> ||
+        std::is_same_v<TAccumulator, ExtendedRegrAccumulator>) {
       // The args order of linear regression function is (y, x), so we need to
       // swap the order
       decodedX_.decode(*args[1], rows);
@@ -544,6 +705,16 @@ class CovarianceAggregate : public exec::Aggregate {
     }
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) TAccumulator();
+    }
+  }
+
  private:
   inline TAccumulator* accumulator(char* group) {
     return exec::Aggregate::value<TAccumulator>(group);
@@ -559,7 +730,10 @@ template <
     typename TIntermediateInput,
     typename TIntermediateResult,
     typename TResultAccessor>
-exec::AggregateRegistrationResult registerCovariance(const std::string& name) {
+exec::AggregateRegistrationResult registerCovariance(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
       // (double, double) -> double
       exec::AggregateFunctionSignatureBuilder()
@@ -606,39 +780,90 @@ exec::AggregateRegistrationResult registerCovariance(const std::string& name) {
           default:
             VELOX_UNSUPPORTED(
                 "Unsupported raw input type: {}. Expected DOUBLE or REAL.",
-                rawInputType->toString())
+                rawInputType->toString());
         }
-      });
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace
 
-void registerCovarianceAggregates(const std::string& prefix) {
+void registerCovarianceAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerCovariance<
       CovarAccumulator,
       CovarIntermediateInput,
       CovarIntermediateResult,
-      CovarPopResultAccessor>(prefix + kCovarPop);
+      CovarPopResultAccessor>(
+      prefix + kCovarPop, withCompanionFunctions, overwrite);
   registerCovariance<
       CovarAccumulator,
       CovarIntermediateInput,
       CovarIntermediateResult,
-      CovarSampResultAccessor>(prefix + kCovarSamp);
+      CovarSampResultAccessor>(
+      prefix + kCovarSamp, withCompanionFunctions, overwrite);
   registerCovariance<
       CorrAccumulator,
       CorrIntermediateInput,
       CorrIntermediateResult,
-      CorrResultAccessor>(prefix + kCorr);
+      CorrResultAccessor>(prefix + kCorr, withCompanionFunctions, overwrite);
   registerCovariance<
       RegrAccumulator,
       RegrIntermediateInput,
       RegrIntermediateResult,
-      RegrInterceptResultAccessor>(prefix + kRegrIntercept);
+      RegrInterceptResultAccessor>(
+      prefix + kRegrIntercept, withCompanionFunctions, overwrite);
   registerCovariance<
       RegrAccumulator,
       RegrIntermediateInput,
       RegrIntermediateResult,
-      RegrSlopeResultAccessor>(prefix + kRegrSlop);
+      RegrSlopeResultAccessor>(
+      prefix + kRegrSlop, withCompanionFunctions, overwrite);
+  registerCovariance<
+      ExtendedRegrAccumulator,
+      ExtendedRegrIntermediateInput,
+      ExtendedRegrIntermediateResult,
+      RegrCountResultAccessor>(
+      prefix + kRegrCount, withCompanionFunctions, overwrite);
+  registerCovariance<
+      ExtendedRegrAccumulator,
+      ExtendedRegrIntermediateInput,
+      ExtendedRegrIntermediateResult,
+      RegrAvgyResultAccessor>(
+      prefix + kRegrAvgy, withCompanionFunctions, overwrite);
+  registerCovariance<
+      ExtendedRegrAccumulator,
+      ExtendedRegrIntermediateInput,
+      ExtendedRegrIntermediateResult,
+      RegrAvgxResultAccessor>(
+      prefix + kRegrAvgx, withCompanionFunctions, overwrite);
+  registerCovariance<
+      ExtendedRegrAccumulator,
+      ExtendedRegrIntermediateInput,
+      ExtendedRegrIntermediateResult,
+      RegrSxyResultAccessor>(
+      prefix + kRegrSxy, withCompanionFunctions, overwrite);
+  registerCovariance<
+      ExtendedRegrAccumulator,
+      ExtendedRegrIntermediateInput,
+      ExtendedRegrIntermediateResult,
+      RegrSxxResultAccessor>(
+      prefix + kRegrSxx, withCompanionFunctions, overwrite);
+  registerCovariance<
+      ExtendedRegrAccumulator,
+      ExtendedRegrIntermediateInput,
+      ExtendedRegrIntermediateResult,
+      RegrSyyResultAccessor>(
+      prefix + kRegrSyy, withCompanionFunctions, overwrite);
+  registerCovariance<
+      ExtendedRegrAccumulator,
+      ExtendedRegrIntermediateInput,
+      ExtendedRegrIntermediateResult,
+      RegrR2ResultAccessor>(
+      prefix + kRegrR2, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/EntropyAggregates.cpp b/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
index 04a17f722e024..66c0e108338c8 100644
--- a/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
@@ -85,15 +85,6 @@ class EntropyAggregate : public exec::Aggregate {
     return sizeof(EntropyAccumulator);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) EntropyAccumulator();
-    }
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -131,8 +122,11 @@ class EntropyAggregate : public exec::Aggregate {
       if (!decodedRaw_.isNullAt(0)) {
         const T value = decodedRaw_.valueAt<T>(0);
         const auto numRows = rows.countSelected();
-        EntropyAccumulator accData(
-            numRows * value, numRows * value * std::log(value));
+        // The "sum" is the constant value times the number of rows.
+        // Use double to prevent overflows (this is the same as what is done in
+        // updateNonNullValue).
+        const auto sum = (double)numRows * (double)value;
+        EntropyAccumulator accData(sum, sum * std::log(value));
         updateNonNullValue(group, accData);
       }
     } else if (decodedRaw_.mayHaveNulls()) {
@@ -273,7 +267,7 @@ class EntropyAggregate : public exec::Aggregate {
     for (int32_t i = 0; i < numGroups; ++i) {
       char* group = groups[i];
       if (isNull(group)) {
-        vector->setNull(i, true);
+        rawValues[i] = 0.0;
       } else {
         clearNull(rawNulls, i);
         EntropyAccumulator* accData = accumulator(group);
@@ -287,6 +281,15 @@ class EntropyAggregate : public exec::Aggregate {
     return exec::Aggregate::value<EntropyAccumulator>(group);
   }
 
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) EntropyAccumulator();
+    }
+  }
+
  private:
   // partial
   template <bool tableHasNulls = true>
@@ -334,7 +337,12 @@ void checkRowType(const TypePtr& type, const std::string& errorMessage) {
       errorMessage);
 }
 
-exec::AggregateRegistrationResult registerEntropy(const std::string& name) {
+} // namespace
+
+void registerEntropyAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   std::vector<std::string> inputTypes = {"smallint", "integer", "bigint"};
   for (const auto& inputType : inputTypes) {
@@ -345,7 +353,8 @@ exec::AggregateRegistrationResult registerEntropy(const std::string& name) {
                              .build());
   }
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kEntropy;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -369,7 +378,7 @@ exec::AggregateRegistrationResult registerEntropy(const std::string& name) {
               VELOX_UNSUPPORTED(
                   "Unsupported input type: {}. "
                   "Expected SMALLINT, INTEGER, BIGINT.",
-                  inputType->toString())
+                  inputType->toString());
           }
         } else {
           checkRowType(
@@ -379,13 +388,9 @@ exec::AggregateRegistrationResult registerEntropy(const std::string& name) {
           // final agg not use template T, int64_t here has no effect.
           return std::make_unique<EntropyAggregate<int64_t>>(resultType);
         }
-      });
-}
-
-} // namespace
-
-void registerEntropyAggregates(const std::string& prefix) {
-  registerEntropy(prefix + kEntropy);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp b/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
index 0e635a109e414..9bbe9ec8c73b1 100644
--- a/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
@@ -24,20 +24,20 @@ namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
-template <typename T>
+template <typename TInput, typename TResult>
 class GeometricMeanAggregate {
  public:
-  using InputType = Row<T>;
+  using InputType = Row<TInput>;
 
   using IntermediateType =
       Row</*logSum*/ double,
           /*count*/ int64_t>;
 
-  using OutputType = double;
+  using OutputType = TResult;
 
   static bool toIntermediate(
       exec::out_type<Row<double, int64_t>>& out,
-      exec::arg_type<T> in) {
+      exec::arg_type<TInput> in) {
     out.copy_from(std::make_tuple(std::log(in), 1));
     return true;
   }
@@ -52,7 +52,9 @@ class GeometricMeanAggregate {
 
     explicit AccumulatorType(HashStringAllocator* /*allocator*/) {}
 
-    void addInput(HashStringAllocator* /*allocator*/, exec::arg_type<T> data) {
+    void addInput(
+        HashStringAllocator* /*allocator*/,
+        exec::arg_type<TInput> data) {
       logSum_ += std::log(data);
       count_ = checkedPlus<int64_t>(count_, 1);
     }
@@ -80,7 +82,10 @@ class GeometricMeanAggregate {
 
 } // namespace
 
-void registerGeometricMeanAggregate(const std::string& prefix) {
+void registerGeometricMeanAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   const std::string name = prefix + kGeometricMean;
 
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
@@ -93,6 +98,13 @@ void registerGeometricMeanAggregate(const std::string& prefix) {
                              .build());
   }
 
+  // Register for real input type.
+  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
+                           .returnType("real")
+                           .intermediateType("row(double,bigint)")
+                           .argumentType("real")
+                           .build());
+
   exec::registerAggregateFunction(
       name,
       std::move(signatures),
@@ -104,37 +116,29 @@ void registerGeometricMeanAggregate(const std::string& prefix) {
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_USER_CHECK_EQ(argTypes.size(), 1, "{} takes one argument", name);
         auto inputType = argTypes[0];
-        if (exec::isRawInput(step)) {
-          switch (inputType->kind()) {
-            case TypeKind::BIGINT:
-              return std::make_unique<
-                  SimpleAggregateAdapter<GeometricMeanAggregate<int64_t>>>(
-                  resultType);
-            case TypeKind::DOUBLE:
-              return std::make_unique<
-                  SimpleAggregateAdapter<GeometricMeanAggregate<double>>>(
-                  resultType);
-            default:
-              VELOX_USER_FAIL(
-                  "Unknown input type for {} aggregation {}",
-                  name,
-                  inputType->toString());
-          }
-        } else {
-          switch (resultType->kind()) {
-            case TypeKind::DOUBLE:
-            case TypeKind::ROW:
-              return std::make_unique<
-                  SimpleAggregateAdapter<GeometricMeanAggregate<double>>>(
-                  resultType);
-            default:
-              VELOX_USER_FAIL(
-                  "Unsupported result type for final aggregation: {}",
-                  resultType->toString());
-          }
+
+        switch (inputType->kind()) {
+          case TypeKind::BIGINT:
+            return std::make_unique<SimpleAggregateAdapter<
+                GeometricMeanAggregate<int64_t, double>>>(resultType);
+          case TypeKind::DOUBLE:
+            return std::make_unique<
+                SimpleAggregateAdapter<GeometricMeanAggregate<double, double>>>(
+                resultType);
+          case TypeKind::REAL:
+            return std::make_unique<
+                SimpleAggregateAdapter<GeometricMeanAggregate<float, float>>>(
+                resultType);
+          default:
+            VELOX_USER_FAIL(
+                "Unknown input type for {} aggregation {}",
+                name,
+                inputType->toString());
         }
       },
-      false);
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/HistogramAggregate.cpp b/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
index 32661a367e896..a021fb1638cc8 100644
--- a/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
@@ -17,6 +17,7 @@
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/memory/HashStringAllocator.h"
+#include "velox/exec/AddressableNonNullValueList.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/Strings.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
@@ -26,18 +27,29 @@ namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
-template <typename T>
+template <
+    typename T,
+    typename Hash = std::hash<T>,
+    typename EqualTo = std::equal_to<T>>
 struct Accumulator {
   using ValueMap = folly::F14FastMap<
       T,
       int64_t,
-      std::hash<T>,
-      std::equal_to<T>,
+      Hash,
+      EqualTo,
       AlignedStlAllocator<std::pair<const T, int64_t>, 16>>;
+
   ValueMap values;
 
-  explicit Accumulator(HashStringAllocator* allocator)
+  Accumulator(const TypePtr& /*type*/, HashStringAllocator* allocator)
+      : values{
+            AlignedStlAllocator<std::pair<const T, int64_t>, 16>(allocator)} {}
+
+  Accumulator(Hash hash, EqualTo equalTo, HashStringAllocator* allocator)
       : values{
+            0,
+            hash,
+            equalTo,
             AlignedStlAllocator<std::pair<const T, int64_t>, 16>(allocator)} {}
 
   size_t size() const {
@@ -70,6 +82,11 @@ struct Accumulator {
       ++index;
     }
   }
+
+  void free(HashStringAllocator& allocator) {
+    using TValues = decltype(values);
+    values.~TValues();
+  }
 };
 
 struct StringViewAccumulator {
@@ -79,8 +96,8 @@ struct StringViewAccumulator {
   /// Stores unique non-null non-inline strings.
   Strings strings;
 
-  explicit StringViewAccumulator(HashStringAllocator* allocator)
-      : base{allocator} {}
+  StringViewAccumulator(const TypePtr& type, HashStringAllocator* allocator)
+      : base{type, allocator} {}
 
   size_t size() const {
     return base.size();
@@ -119,6 +136,76 @@ struct StringViewAccumulator {
       vector_size_t offset) {
     base.extractValues(keys, counts, offset);
   }
+
+  void free(HashStringAllocator& allocator) {
+    strings.free(allocator);
+    using Base = decltype(base);
+    base.~Base();
+  }
+};
+
+struct ComplexTypeAccumulator {
+  Accumulator<
+      AddressableNonNullValueList::Entry,
+      AddressableNonNullValueList::Hash,
+      AddressableNonNullValueList::EqualTo>
+      base;
+
+  AddressableNonNullValueList serializedValues;
+
+  ComplexTypeAccumulator(const TypePtr& type, HashStringAllocator* allocator)
+      : base{
+            AddressableNonNullValueList::Hash{},
+            AddressableNonNullValueList::EqualTo{type},
+            allocator} {}
+
+  size_t size() const {
+    return base.size();
+  }
+
+  void addValue(
+      DecodedVector& decoded,
+      vector_size_t index,
+      HashStringAllocator* allocator) {
+    addValueWithCount(*decoded.base(), decoded.index(index), 1, allocator);
+  }
+
+  void addValueWithCount(
+      const BaseVector& keys,
+      vector_size_t index,
+      int64_t count,
+      HashStringAllocator* allocator) {
+    auto entry = serializedValues.append(keys, index, allocator);
+
+    auto it = base.values.find(entry);
+    if (it == base.values.end()) {
+      // New entry.
+      base.values[entry] += count;
+    } else {
+      // Existing entry.
+      serializedValues.removeLast(entry);
+
+      it->second += count;
+    }
+  }
+
+  void extractValues(
+      BaseVector& keys,
+      FlatVector<int64_t>& counts,
+      vector_size_t offset) {
+    auto index = offset;
+    for (const auto& [position, count] : base.values) {
+      AddressableNonNullValueList::read(position, keys, index);
+      counts.set(index, count);
+      ++index;
+    }
+  }
+
+  void free(HashStringAllocator& allocator) {
+    serializedValues.free(allocator);
+    using Base = decltype(base);
+    base.~Base();
+  }
 };
 
 template <typename T>
@@ -126,17 +213,38 @@ struct AccumulatorTypeTraits {
   using AccumulatorType = Accumulator<T>;
 };
 
+template <>
+struct AccumulatorTypeTraits<float> {
+  using AccumulatorType = Accumulator<
+      float,
+      util::floating_point::NaNAwareHash<float>,
+      util::floating_point::NaNAwareEquals<float>>;
+};
+
+template <>
+struct AccumulatorTypeTraits<double> {
+  using AccumulatorType = Accumulator<
+      double,
+      util::floating_point::NaNAwareHash<double>,
+      util::floating_point::NaNAwareEquals<double>>;
+};
+
 template <>
 struct AccumulatorTypeTraits<StringView> {
   using AccumulatorType = StringViewAccumulator;
 };
 
+template <>
+struct AccumulatorTypeTraits<ComplexType> {
+  using AccumulatorType = ComplexTypeAccumulator;
+};
+
 // Combines a partial aggregation represented by the key-value pair at row in
 // mapKeys and mapValues into groupMap.
 template <typename T, typename Accumulator>
 FOLLY_ALWAYS_INLINE void addToFinalAggregation(
-    const FlatVector<T>* mapKeys,
-    const FlatVector<int64_t>* mapValues,
+    const BaseVector* mapKeys,
+    const FlatVector<int64_t>* flatValues,
     vector_size_t index,
     const vector_size_t* rawSizes,
     const vector_size_t* rawOffsets,
@@ -144,11 +252,20 @@ FOLLY_ALWAYS_INLINE void addToFinalAggregation(
     HashStringAllocator* allocator) {
   auto size = rawSizes[index];
   auto offset = rawOffsets[index];
-  for (int i = 0; i < size; ++i) {
-    accumulator->addValueWithCount(
-        mapKeys->valueAt(offset + i),
-        mapValues->valueAt(offset + i),
-        allocator);
+
+  if constexpr (std::is_same_v<T, ComplexType>) {
+    for (int i = 0; i < size; ++i) {
+      const auto count = flatValues->valueAt(offset + i);
+      accumulator->addValueWithCount(*mapKeys, offset + i, count, allocator);
+    }
+  } else {
+    auto* flatKeys = mapKeys->asFlatVector<T>();
+    for (int i = 0; i < size; ++i) {
+      accumulator->addValueWithCount(
+          flatKeys->valueAt(offset + i),
+          flatValues->valueAt(offset + i),
+          allocator);
+    }
   }
 }
 
@@ -168,43 +285,54 @@ class HistogramAggregate : public exec::Aggregate {
     return false;
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    for (auto index : indices) {
-      new (groups[index] + offset_) AccumulatorType{allocator_};
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
-    auto mapVector = (*result)->as<MapVector>();
+    auto* mapVector = (*result)->as<MapVector>();
     VELOX_CHECK(mapVector);
     mapVector->resize(numGroups);
 
-    auto mapKeys = mapVector->mapKeys()->asUnchecked<FlatVector<T>>();
-    auto mapValues = mapVector->mapValues()->asUnchecked<FlatVector<int64_t>>();
+    auto& mapKeys = mapVector->mapKeys();
+    auto* flatValues =
+        mapVector->mapValues()->asUnchecked<FlatVector<int64_t>>();
     VELOX_CHECK_NOT_NULL(mapKeys);
-    VELOX_CHECK_NOT_NULL(mapValues);
+    VELOX_CHECK_NOT_NULL(flatValues);
 
-    auto numElements = countElements(groups, numGroups);
+    const auto numElements = countElements(groups, numGroups);
     mapKeys->resize(numElements);
-    mapValues->resize(numElements);
+    flatValues->resize(numElements);
 
-    auto rawNulls = mapVector->mutableRawNulls();
+    auto* rawNulls = mapVector->mutableRawNulls();
     vector_size_t offset = 0;
-    for (auto i = 0; i < numGroups; ++i) {
-      char* group = groups[i];
-      auto* accumulator = value<AccumulatorType>(group);
+    if constexpr (std::is_same_v<T, ComplexType>) {
+      for (auto i = 0; i < numGroups; ++i) {
+        char* group = groups[i];
+        auto* accumulator = value<AccumulatorType>(group);
 
-      auto mapSize = accumulator->size();
-      mapVector->setOffsetAndSize(i, offset, mapSize);
-      if (mapSize == 0) {
-        bits::setNull(rawNulls, i, true);
-      } else {
-        clearNull(rawNulls, i);
-        accumulator->extractValues(*mapKeys, *mapValues, offset);
-        offset += mapSize;
+        const auto mapSize = accumulator->size();
+        mapVector->setOffsetAndSize(i, offset, mapSize);
+        if (mapSize == 0) {
+          bits::setNull(rawNulls, i, true);
+        } else {
+          clearNull(rawNulls, i);
+          accumulator->extractValues(*mapKeys, *flatValues, offset);
+          offset += mapSize;
+        }
+      }
+    } else {
+      auto* flatKeys = mapKeys->asFlatVector<T>();
+      for (auto i = 0; i < numGroups; ++i) {
+        char* group = groups[i];
+        auto* accumulator = value<AccumulatorType>(group);
+
+        const auto mapSize = accumulator->size();
+        mapVector->setOffsetAndSize(i, offset, mapSize);
+        if (mapSize == 0) {
+          bits::setNull(rawNulls, i, true);
+        } else {
+          clearNull(rawNulls, i);
+          accumulator->extractValues(*flatKeys, *flatValues, offset);
+          offset += mapSize;
+        }
       }
     }
   }
@@ -257,14 +385,14 @@ class HistogramAggregate : public exec::Aggregate {
       const std::vector<VectorPtr>& args,
       bool /*mayPushdown*/) override {
     decodedIntermediate_.decode(*args[0], rows);
-    auto indices = decodedIntermediate_.indices();
-    auto mapVector = decodedIntermediate_.base()->template as<MapVector>();
+    auto* indices = decodedIntermediate_.indices();
+    auto* mapVector = decodedIntermediate_.base()->template as<MapVector>();
 
-    auto mapKeys = mapVector->mapKeys()->template asUnchecked<FlatVector<T>>();
-    auto mapValues =
+    auto& mapKeys = mapVector->mapKeys();
+    auto* flatValues =
         mapVector->mapValues()->template asUnchecked<FlatVector<int64_t>>();
     VELOX_CHECK_NOT_NULL(mapKeys);
-    VELOX_CHECK_NOT_NULL(mapValues);
+    VELOX_CHECK_NOT_NULL(flatValues);
 
     auto rawSizes = mapVector->rawSizes();
     auto rawOffsets = mapVector->rawOffsets();
@@ -275,8 +403,8 @@ class HistogramAggregate : public exec::Aggregate {
 
         auto tracker = trackRowSize(group);
         addToFinalAggregation<T, AccumulatorType>(
-            mapKeys,
-            mapValues,
+            mapKeys.get(),
+            flatValues,
             indices[row],
             rawSizes,
             rawOffsets,
@@ -292,26 +420,26 @@ class HistogramAggregate : public exec::Aggregate {
       const std::vector<VectorPtr>& args,
       bool /* mayPushdown */) override {
     decodedIntermediate_.decode(*args[0], rows);
-    auto indices = decodedIntermediate_.indices();
-    auto mapVector = decodedIntermediate_.base()->template as<MapVector>();
+    auto* indices = decodedIntermediate_.indices();
+    auto* mapVector = decodedIntermediate_.base()->template as<MapVector>();
 
-    auto mapKeys = mapVector->mapKeys()->template asUnchecked<FlatVector<T>>();
-    auto mapValues =
+    auto& mapKeys = mapVector->mapKeys();
+    auto* flatValues =
         mapVector->mapValues()->template asUnchecked<FlatVector<int64_t>>();
     VELOX_CHECK_NOT_NULL(mapKeys);
-    VELOX_CHECK_NOT_NULL(mapValues);
+    VELOX_CHECK_NOT_NULL(flatValues);
 
     auto* accumulator = value<AccumulatorType>(group);
 
     auto tracker = trackRowSize(group);
 
-    auto rawSizes = mapVector->rawSizes();
-    auto rawOffsets = mapVector->rawOffsets();
+    auto* rawSizes = mapVector->rawSizes();
+    auto* rawOffsets = mapVector->rawOffsets();
     rows.applyToSelected([&](vector_size_t row) {
       if (!decodedIntermediate_.isNullAt(row)) {
         addToFinalAggregation<T, AccumulatorType>(
-            mapKeys,
-            mapValues,
+            mapKeys.get(),
+            flatValues,
             indices[row],
             rawSizes,
             rawOffsets,
@@ -321,8 +449,22 @@ class HistogramAggregate : public exec::Aggregate {
     });
   }
 
-  void destroy(folly::Range<char**> groups) override {
-    destroyAccumulators<AccumulatorType>(groups);
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    const auto& type = resultType()->childAt(0);
+    for (auto index : indices) {
+      new (groups[index] + offset_) AccumulatorType{type, allocator_};
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto* group : groups) {
+      if (isInitialized(group) && !isNull(group)) {
+        value<AccumulatorType>(group)->free(*allocator_);
+      }
+    }
   }
 
  private:
@@ -338,29 +480,23 @@ class HistogramAggregate : public exec::Aggregate {
   DecodedVector decodedIntermediate_;
 };
 
-exec::AggregateRegistrationResult registerHistogram(const std::string& name) {
-  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  for (const auto inputType :
-       {"boolean",
-        "tinyint",
-        "smallint",
-        "integer",
-        "bigint",
-        "real",
-        "double",
-        "timestamp",
-        "date",
-        "interval day to second",
-        "varchar"}) {
-    auto mapType = fmt::format("map({},bigint)", inputType);
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(mapType)
-                             .intermediateType(mapType)
-                             .argumentType(inputType)
-                             .build());
-  }
+} // namespace
 
-  return exec::registerAggregateFunction(
+void registerHistogramAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("map(T,bigint)")
+          .intermediateType("map(T,bigint)")
+          .argumentType("T")
+          .build(),
+  };
+
+  auto name = prefix + kHistogram;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -370,10 +506,7 @@ exec::AggregateRegistrationResult registerHistogram(const std::string& name) {
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(
-            argTypes.size(),
-            1,
-            "{} ({}): unexpected number of arguments",
-            name);
+            argTypes.size(), 1, "{}: unexpected number of arguments", name);
 
         auto inputType = argTypes[0];
         switch (exec::isRawInput(step) ? inputType->kind()
@@ -395,20 +528,25 @@ exec::AggregateRegistrationResult registerHistogram(const std::string& name) {
           case TypeKind::TIMESTAMP:
             return std::make_unique<HistogramAggregate<Timestamp>>(resultType);
           case TypeKind::VARCHAR:
+          case TypeKind::VARBINARY:
             return std::make_unique<HistogramAggregate<StringView>>(resultType);
+          case TypeKind::ARRAY:
+          case TypeKind::MAP:
+          case TypeKind::ROW:
+            return std::make_unique<HistogramAggregate<ComplexType>>(
+                resultType);
+          case TypeKind::UNKNOWN:
+            return std::make_unique<HistogramAggregate<int8_t>>(resultType);
           default:
             VELOX_NYI(
                 "Unknown input type for {} aggregation {}",
                 name,
-                inputType->kindName());
+                inputType->toString());
         }
-      });
-}
-
-} // namespace
-
-void registerHistogramAggregate(const std::string& prefix) {
-  registerHistogram(prefix + kHistogram);
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MapAccumulator.h b/velox/functions/prestosql/aggregates/MapAccumulator.h
index 13606005c8d05..bfdc335c5a5a6 100644
--- a/velox/functions/prestosql/aggregates/MapAccumulator.h
+++ b/velox/functions/prestosql/aggregates/MapAccumulator.h
@@ -19,7 +19,7 @@
 #include "velox/common/memory/HashStringAllocator.h"
 #include "velox/exec/AddressableNonNullValueList.h"
 #include "velox/exec/Strings.h"
-#include "velox/functions/prestosql/aggregates/ValueList.h"
+#include "velox/functions/lib/aggregates/ValueList.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
@@ -161,7 +161,7 @@ struct StringViewMapAccumulator {
 struct ComplexTypeMapAccumulator {
   /// A set of pointers to values stored in AddressableNonNullValueList.
   MapAccumulator<
-      HashStringAllocator::Position,
+      AddressableNonNullValueList::Entry,
       AddressableNonNullValueList::Hash,
       AddressableNonNullValueList::EqualTo>
       base;
@@ -180,11 +180,11 @@ struct ComplexTypeMapAccumulator {
       const DecodedVector& decodedValues,
       vector_size_t index,
       HashStringAllocator& allocator) {
-    auto position = serializedKeys.append(decodedKeys, index, &allocator);
+    auto entry = serializedKeys.append(decodedKeys, index, &allocator);
 
     auto cnt = base.keys.size();
-    if (!base.keys.insert({position, cnt}).second) {
-      serializedKeys.removeLast(position);
+    if (!base.keys.insert({entry, cnt}).second) {
+      serializedKeys.removeLast(entry);
       return;
     }
 
@@ -225,6 +225,22 @@ struct MapAccumulatorTypeTraits {
   using AccumulatorType = MapAccumulator<T>;
 };
 
+template <>
+struct MapAccumulatorTypeTraits<float> {
+  using AccumulatorType = MapAccumulator<
+      float,
+      util::floating_point::NaNAwareHash<float>,
+      util::floating_point::NaNAwareEquals<float>>;
+};
+
+template <>
+struct MapAccumulatorTypeTraits<double> {
+  using AccumulatorType = MapAccumulator<
+      double,
+      util::floating_point::NaNAwareHash<double>,
+      util::floating_point::NaNAwareEquals<double>>;
+};
+
 template <>
 struct MapAccumulatorTypeTraits<StringView> {
   using AccumulatorType = StringViewMapAccumulator;
diff --git a/velox/functions/prestosql/aggregates/MapAggAggregate.cpp b/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
index e072a2fe64e10..0160aaf6d4dff 100644
--- a/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/functions/prestosql/aggregates/Compare.h"
+#include "velox/functions/lib/CheckNestedNulls.h"
 #include "velox/functions/prestosql/aggregates/MapAggregateBase.h"
 
 namespace facebook::velox::aggregate::prestosql {
@@ -47,7 +47,8 @@ class MapAggAggregate : public MapAggregateBase<K> {
       DecodedVector decodedKeys(*keys, rows);
       const auto* indices = decodedKeys.indices();
       rows.applyToSelected([&](vector_size_t i) {
-        checkNestedNulls(decodedKeys, indices, i, throwOnNestedNulls_);
+        velox::functions::checkNestedNulls(
+            decodedKeys, indices, i, throwOnNestedNulls_);
       });
     }
 
@@ -103,7 +104,7 @@ class MapAggAggregate : public MapAggregateBase<K> {
     const auto* indices = Base::decodedKeys_.indices();
 
     rows.applyToSelected([&](vector_size_t row) {
-      if (checkNestedNulls(
+      if (velox::functions::checkNestedNulls(
               Base::decodedKeys_, indices, row, throwOnNestedNulls_)) {
         return;
       }
@@ -129,7 +130,7 @@ class MapAggAggregate : public MapAggregateBase<K> {
 
     auto tracker = Base::trackRowSize(group);
     rows.applyToSelected([&](vector_size_t row) {
-      if (checkNestedNulls(
+      if (velox::functions::checkNestedNulls(
               Base::decodedKeys_, indices, row, throwOnNestedNulls_)) {
         return;
       }
@@ -144,10 +145,15 @@ class MapAggAggregate : public MapAggregateBase<K> {
   const bool throwOnNestedNulls_;
 };
 
-exec::AggregateRegistrationResult registerMapAgg(const std::string& name) {
+} // namespace
+
+void registerMapAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
-          .knownTypeVariable("K")
+          .typeVariable("K")
           .typeVariable("V")
           .returnType("map(K,V)")
           .intermediateType("map(K,V)")
@@ -155,7 +161,8 @@ exec::AggregateRegistrationResult registerMapAgg(const std::string& name) {
           .argumentType("V")
           .build()};
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kMapAgg;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -168,7 +175,7 @@ exec::AggregateRegistrationResult registerMapAgg(const std::string& name) {
         VELOX_CHECK_EQ(
             argTypes.size(),
             rawInput ? 2 : 1,
-            "{} ({}): unexpected number of arguments",
+            "{}: unexpected number of arguments",
             name);
         const bool throwOnNestedNulls = rawInput;
         const auto typeKind = resultType->childAt(0)->kind();
@@ -204,13 +211,9 @@ exec::AggregateRegistrationResult registerMapAgg(const std::string& name) {
             VELOX_UNREACHABLE(
                 "Unexpected type {}", mapTypeKindToName(typeKind));
         }
-      });
-}
-
-} // namespace
-
-void registerMapAggAggregate(const std::string& prefix) {
-  registerMapAgg(prefix + kMapAgg);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MapAggregateBase.h b/velox/functions/prestosql/aggregates/MapAggregateBase.h
index 571cf690ae402..f0f9b2068430b 100644
--- a/velox/functions/prestosql/aggregates/MapAggregateBase.h
+++ b/velox/functions/prestosql/aggregates/MapAggregateBase.h
@@ -37,16 +37,6 @@ class MapAggregateBase : public exec::Aggregate {
     return false;
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    const auto& type = resultType()->childAt(0);
-    for (auto index : indices) {
-      new (groups[index] + offset_) AccumulatorType(type, allocator_);
-    }
-    setAllNulls(groups, indices);
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto mapVector = (*result)->as<MapVector>();
@@ -105,13 +95,6 @@ class MapAggregateBase : public exec::Aggregate {
     addSingleGroupMapInputToAccumulator(group, rows, args, false);
   }
 
-  void destroy(folly::Range<char**> groups) override {
-    for (auto group : groups) {
-      auto accumulator = value<AccumulatorType>(group);
-      accumulator->free(*allocator_);
-    }
-  }
-
  protected:
   vector_size_t countElements(char** groups, int32_t numGroups) const {
     vector_size_t size = 0;
@@ -121,6 +104,15 @@ class MapAggregateBase : public exec::Aggregate {
     return size;
   }
 
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        auto accumulator = value<AccumulatorType>(group);
+        accumulator->free(*allocator_);
+      }
+    }
+  }
+
   AccumulatorType* accumulator(char* group) {
     return value<AccumulatorType>(group);
   }
@@ -195,6 +187,16 @@ class MapAggregateBase : public exec::Aggregate {
     });
   }
 
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    const auto& type = resultType()->childAt(0);
+    for (auto index : indices) {
+      new (groups[index] + offset_) AccumulatorType(type, allocator_);
+    }
+    setAllNulls(groups, indices);
+  }
+
   DecodedVector decodedKeys_;
   DecodedVector decodedValues_;
   DecodedVector decodedMaps_;
diff --git a/velox/functions/prestosql/aggregates/MapUnionAggregate.cpp b/velox/functions/prestosql/aggregates/MapUnionAggregate.cpp
index fd4b24401169f..24b7ad3459e50 100644
--- a/velox/functions/prestosql/aggregates/MapUnionAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MapUnionAggregate.cpp
@@ -73,7 +73,12 @@ class MapUnionAggregate : public MapAggregateBase<K> {
   }
 };
 
-exec::AggregateRegistrationResult registerMapUnion(const std::string& name) {
+} // namespace
+
+void registerMapUnionAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .typeVariable("K")
@@ -83,7 +88,8 @@ exec::AggregateRegistrationResult registerMapUnion(const std::string& name) {
           .argumentType("map(K,V)")
           .build()};
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kMapUnion;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -93,19 +99,12 @@ exec::AggregateRegistrationResult registerMapUnion(const std::string& name) {
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(
-            argTypes.size(),
-            1,
-            "{} ({}): unexpected number of arguments",
-            name);
+            argTypes.size(), 1, "{}: unexpected number of arguments", name);
 
         return createMapAggregate<MapUnionAggregate>(resultType);
-      });
-}
-
-} // namespace
-
-void registerMapUnionAggregate(const std::string& prefix) {
-  registerMapUnion(prefix + kMapUnion);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp b/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
index d64e86092b187..b4d8ed1d67ca6 100644
--- a/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
@@ -16,7 +16,7 @@
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/Strings.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/prestosql/CheckedArithmeticImpl.h"
+#include "velox/functions/lib/CheckedArithmeticImpl.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/vector/FlatVector.h"
 
@@ -26,13 +26,11 @@ namespace {
 
 template <typename K, typename S>
 struct Accumulator {
-  folly::F14FastMap<
+  using ValuesMap = typename util::floating_point::HashMapNaNAwareTypeTraits<
       K,
       S,
-      std::hash<K>,
-      std::equal_to<K>,
-      AlignedStlAllocator<std::pair<const K, S>, 16>>
-      sums;
+      AlignedStlAllocator<std::pair<const K, S>, 16>>::Type;
+  ValuesMap sums;
 
   explicit Accumulator(HashStringAllocator* allocator)
       : sums{AlignedStlAllocator<std::pair<const K, S>, 16>(allocator)} {}
@@ -186,15 +184,6 @@ class MapUnionSumAggregate : public exec::Aggregate {
     return false;
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto index : indices) {
-      new (groups[index] + offset_) AccumulatorType{allocator_};
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto mapVector = (*result)->as<MapVector>();
@@ -290,10 +279,20 @@ class MapUnionSumAggregate : public exec::Aggregate {
     addSingleGroupRawInput(group, rows, args, false);
   }
 
-  void destroy(folly::Range<char**> groups) override {
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto index : indices) {
+      new (groups[index] + offset_) AccumulatorType{allocator_};
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
     if constexpr (std::is_same_v<K, StringView>) {
       for (auto* group : groups) {
-        if (!isNull(group)) {
+        if (isInitialized(group) && !isNull(group)) {
           value<AccumulatorType>(group)->strings.free(*allocator_);
         }
       }
@@ -345,11 +344,33 @@ std::unique_ptr<exec::Aggregate> createMapUnionSumAggregate(
   }
 }
 
-exec::AggregateRegistrationResult registerMapUnionSum(const std::string& name) {
+} // namespace
+
+void registerMapUnionSumAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  const std::vector<std::string> keyTypes = {
+      "tinyint",
+      "smallint",
+      "integer",
+      "bigint",
+      "real",
+      "double",
+      "varchar",
+  };
+  const std::vector<std::string> valueTypes = {
+      "tinyint",
+      "smallint",
+      "integer",
+      "bigint",
+      "double",
+      "real",
+  };
+
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  for (auto keyType : {"tinyint", "smallint", "integer", "bigint", "varchar"}) {
-    for (auto valueType :
-         {"tinyint", "smallint", "integer", "bigint", "double", "real"}) {
+  for (auto keyType : keyTypes) {
+    for (auto valueType : valueTypes) {
       auto mapType = fmt::format("map({},{})", keyType, valueType);
       signatures.push_back(exec::AggregateFunctionSignatureBuilder()
                                .returnType(mapType)
@@ -359,7 +380,8 @@ exec::AggregateRegistrationResult registerMapUnionSum(const std::string& name) {
     }
   }
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kMapUnionSum;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -386,19 +408,20 @@ exec::AggregateRegistrationResult registerMapUnionSum(const std::string& name) {
           case TypeKind::BIGINT:
             return createMapUnionSumAggregate<int64_t>(
                 valueTypeKind, resultType);
+          case TypeKind::REAL:
+            return createMapUnionSumAggregate<float>(valueTypeKind, resultType);
+          case TypeKind::DOUBLE:
+            return createMapUnionSumAggregate<double>(
+                valueTypeKind, resultType);
           case TypeKind::VARCHAR:
             return createMapUnionSumAggregate<StringView>(
                 valueTypeKind, resultType);
           default:
             VELOX_UNREACHABLE();
         }
-      });
-}
-
-} // namespace
-
-void registerMapUnionSumAggregate(const std::string& prefix) {
-  registerMapUnionSum(prefix + kMapUnionSum);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp b/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
index 5d9f63766d160..b4f1ed4bc1d60 100644
--- a/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
@@ -56,15 +56,6 @@ class MaxSizeForStatsAggregate
     });
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      *BaseAggregate ::value<int64_t>(groups[i]) = 0;
-    }
-  }
-
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     // Partial and final aggregations are the same.
@@ -175,7 +166,7 @@ class MaxSizeForStatsAggregate
     });
 
     getVectorSerde()->estimateSerializedSize(
-        vector,
+        vector.get(),
         folly::Range(elementIndices_.data(), elementIndices_.size()),
         elementSizePtrs_.data());
   }
@@ -200,20 +191,34 @@ class MaxSizeForStatsAggregate
       });
     }
   }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      *BaseAggregate ::value<int64_t>(groups[i]) = 0;
+    }
+  }
 };
 
-exec::AggregateRegistrationResult registerMaxSizeForStats(
-    const std::string& name) {
+} // namespace
+
+void registerMaxDataSizeForStatsAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   signatures.push_back(exec::AggregateFunctionSignatureBuilder()
                            .typeVariable("T")
-                           .returnType("BIGINT")
-                           .intermediateType("BIGINT")
+                           .returnType("bigint")
+                           .intermediateType("bigint")
                            .argumentType("T")
                            .build());
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kMaxSizeForStats;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -226,13 +231,9 @@ exec::AggregateRegistrationResult registerMaxSizeForStats(
         auto inputType = argTypes[0];
 
         return std::make_unique<MaxSizeForStatsAggregate>(resultType);
-      });
-}
-
-} // namespace
-
-void registerMaxDataSizeForStatsAggregate(const std::string& prefix) {
-  registerMaxSizeForStats(prefix + kMaxSizeForStats);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp b/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
index 224a251163280..871a62733d336 100644
--- a/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
@@ -17,10 +17,11 @@
 #include <limits>
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/AggregationHook.h"
+#include "velox/functions/lib/aggregates/MinMaxAggregateBase.h"
 #include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
 #include "velox/functions/lib/aggregates/SingleValueAccumulator.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/functions/prestosql/aggregates/Compare.h"
+#include "velox/type/FloatingPointUtil.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -28,506 +29,6 @@ namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
-template <typename T>
-struct MinMaxTrait : public std::numeric_limits<T> {};
-
-template <typename T>
-class MinMaxAggregate : public SimpleNumericAggregate<T, T, T> {
-  using BaseAggregate = SimpleNumericAggregate<T, T, T>;
-
- public:
-  explicit MinMaxAggregate(TypePtr resultType) : BaseAggregate(resultType) {}
-
-  int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(T);
-  }
-
-  int32_t accumulatorAlignmentSize() const override {
-    return 1;
-  }
-
-  bool supportsToIntermediate() const override {
-    return true;
-  }
-
-  void toIntermediate(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      VectorPtr& result) const override {
-    const auto& input = args[0];
-    if (rows.isAllSelected()) {
-      result = input;
-      return;
-    }
-
-    auto* pool = BaseAggregate::allocator_->pool();
-
-    result = BaseVector::create(input->type(), rows.size(), pool);
-
-    // Set result to NULL for rows that are masked out.
-    {
-      BufferPtr nulls = allocateNulls(rows.size(), pool, bits::kNull);
-      rows.clearNulls(nulls);
-      result->setNulls(nulls);
-    }
-
-    result->copy(input.get(), rows, nullptr);
-  }
-
-  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    BaseAggregate::template doExtractValues<T>(
-        groups, numGroups, result, [&](char* group) {
-          return *BaseAggregate::Aggregate::template value<T>(group);
-        });
-  }
-
-  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    BaseAggregate::template doExtractValues<T>(
-        groups, numGroups, result, [&](char* group) {
-          return *BaseAggregate::Aggregate::template value<T>(group);
-        });
-  }
-};
-
-/// Override 'accumulatorAlignmentSize' for UnscaledLongDecimal values as it
-/// uses int128_t type. Some CPUs don't support misaligned access to int128_t
-/// type.
-template <>
-inline int32_t MinMaxAggregate<int128_t>::accumulatorAlignmentSize() const {
-  return static_cast<int32_t>(sizeof(int128_t));
-}
-
-// Truncate timestamps to milliseconds precision.
-template <>
-void MinMaxAggregate<Timestamp>::extractValues(
-    char** groups,
-    int32_t numGroups,
-    VectorPtr* result) {
-  BaseAggregate::template doExtractValues<Timestamp>(
-      groups, numGroups, result, [&](char* group) {
-        auto ts = *BaseAggregate::Aggregate::template value<Timestamp>(group);
-        return Timestamp::fromMillis(ts.toMillis());
-      });
-}
-
-template <typename T>
-class MaxAggregate : public MinMaxAggregate<T> {
-  using BaseAggregate = SimpleNumericAggregate<T, T, T>;
-
- public:
-  explicit MaxAggregate(TypePtr resultType) : MinMaxAggregate<T>(resultType) {}
-
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      *exec::Aggregate::value<T>(groups[i]) = kInitialValue_;
-    }
-  }
-
-  void addRawInput(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    // Re-enable pushdown for TIMESTAMP after
-    // https://github.com/facebookincubator/velox/issues/6297 is fixed.
-    if (args[0]->typeKind() == TypeKind::TIMESTAMP) {
-      mayPushdown = false;
-    }
-    if (mayPushdown && args[0]->isLazy()) {
-      BaseAggregate::template pushdown<MinMaxHook<T, false>>(
-          groups, rows, args[0]);
-      return;
-    }
-    BaseAggregate::template updateGroups<true, T>(
-        groups,
-        rows,
-        args[0],
-        [](T& result, T value) {
-          if (result < value) {
-            result = value;
-          }
-        },
-        mayPushdown);
-  }
-
-  void addIntermediateResults(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    addRawInput(groups, rows, args, mayPushdown);
-  }
-
-  void addSingleGroupRawInput(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    BaseAggregate::updateOneGroup(
-        group,
-        rows,
-        args[0],
-        [](T& result, T value) {
-          if (result < value) {
-            result = value;
-          }
-        },
-        [](T& result, T value, int /* unused */) { result = value; },
-        mayPushdown,
-        kInitialValue_);
-  }
-
-  void addSingleGroupIntermediateResults(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    addSingleGroupRawInput(group, rows, args, mayPushdown);
-  }
-
- private:
-  static const T kInitialValue_;
-};
-
-template <typename T>
-const T MaxAggregate<T>::kInitialValue_ = MinMaxTrait<T>::lowest();
-
-template <typename T>
-class MinAggregate : public MinMaxAggregate<T> {
-  using BaseAggregate = SimpleNumericAggregate<T, T, T>;
-
- public:
-  explicit MinAggregate(TypePtr resultType) : MinMaxAggregate<T>(resultType) {}
-
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      *exec::Aggregate::value<T>(groups[i]) = kInitialValue_;
-    }
-  }
-
-  void addRawInput(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    // Re-enable pushdown for TIMESTAMP after
-    // https://github.com/facebookincubator/velox/issues/6297 is fixed.
-    if (args[0]->typeKind() == TypeKind::TIMESTAMP) {
-      mayPushdown = false;
-    }
-    if (mayPushdown && args[0]->isLazy()) {
-      BaseAggregate::template pushdown<MinMaxHook<T, true>>(
-          groups, rows, args[0]);
-      return;
-    }
-    BaseAggregate::template updateGroups<true, T>(
-        groups,
-        rows,
-        args[0],
-        [](T& result, T value) {
-          if (result > value) {
-            result = value;
-          }
-        },
-        mayPushdown);
-  }
-
-  void addIntermediateResults(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    addRawInput(groups, rows, args, mayPushdown);
-  }
-
-  void addSingleGroupRawInput(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    BaseAggregate::updateOneGroup(
-        group,
-        rows,
-        args[0],
-        [](T& result, T value) { result = result < value ? result : value; },
-        [](T& result, T value, int /* unused */) { result = value; },
-        mayPushdown,
-        kInitialValue_);
-  }
-
-  void addSingleGroupIntermediateResults(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    addSingleGroupRawInput(group, rows, args, mayPushdown);
-  }
-
- private:
-  static const T kInitialValue_;
-};
-
-template <typename T>
-const T MinAggregate<T>::kInitialValue_ = MinMaxTrait<T>::max();
-
-class NonNumericMinMaxAggregateBase : public exec::Aggregate {
- public:
-  explicit NonNumericMinMaxAggregateBase(
-      const TypePtr& resultType,
-      bool throwOnNestedNulls)
-      : exec::Aggregate(resultType), throwOnNestedNulls_(throwOnNestedNulls) {}
-
-  int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(SingleValueAccumulator);
-  }
-
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) SingleValueAccumulator();
-    }
-  }
-
-  bool supportsToIntermediate() const override {
-    return true;
-  }
-
-  void toIntermediate(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      VectorPtr& result) const override {
-    const auto& input = args[0];
-
-    if (throwOnNestedNulls_) {
-      DecodedVector decoded(*input, rows, true);
-      auto indices = decoded.indices();
-      rows.applyToSelected([&](vector_size_t i) {
-        checkNestedNulls(decoded, indices, i, throwOnNestedNulls_);
-      });
-    }
-
-    if (rows.isAllSelected()) {
-      result = input;
-      return;
-    }
-
-    auto* pool = allocator_->pool();
-
-    // Set result to NULL for rows that are masked out.
-    BufferPtr nulls = allocateNulls(rows.size(), pool, bits::kNull);
-    rows.clearNulls(nulls);
-
-    BufferPtr indices = allocateIndices(rows.size(), pool);
-    auto* rawIndices = indices->asMutable<vector_size_t>();
-    std::iota(rawIndices, rawIndices + rows.size(), 0);
-
-    result = BaseVector::wrapInDictionary(nulls, indices, rows.size(), input);
-  }
-
-  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    VELOX_CHECK(result);
-    (*result)->resize(numGroups);
-
-    uint64_t* rawNulls = nullptr;
-    if ((*result)->mayHaveNulls()) {
-      BufferPtr& nulls = (*result)->mutableNulls((*result)->size());
-      rawNulls = nulls->asMutable<uint64_t>();
-    }
-
-    for (auto i = 0; i < numGroups; ++i) {
-      char* group = groups[i];
-      auto accumulator = value<SingleValueAccumulator>(group);
-      if (!accumulator->hasValue()) {
-        (*result)->setNull(i, true);
-      } else {
-        if (rawNulls) {
-          bits::clearBit(rawNulls, i);
-        }
-        accumulator->read(*result, i);
-      }
-    }
-  }
-
-  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    // partial and final aggregations are the same
-    extractValues(groups, numGroups, result);
-  }
-
-  void destroy(folly::Range<char**> groups) override {
-    for (auto group : groups) {
-      value<SingleValueAccumulator>(group)->destroy(allocator_);
-    }
-  }
-
- protected:
-  template <typename TCompareTest>
-  void doUpdate(
-      char** groups,
-      const SelectivityVector& rows,
-      const VectorPtr& arg,
-      TCompareTest compareTest) {
-    DecodedVector decoded(*arg, rows, true);
-    auto indices = decoded.indices();
-    auto baseVector = decoded.base();
-
-    if (decoded.isConstantMapping() && decoded.isNullAt(0)) {
-      // nothing to do; all values are nulls
-      return;
-    }
-
-    rows.applyToSelected([&](vector_size_t i) {
-      if (checkNestedNulls(decoded, indices, i, throwOnNestedNulls_)) {
-        return;
-      }
-
-      auto accumulator = value<SingleValueAccumulator>(groups[i]);
-      if (!accumulator->hasValue() ||
-          compareTest(compare(accumulator, decoded, i))) {
-        accumulator->write(baseVector, indices[i], allocator_);
-      }
-    });
-  }
-
-  template <typename TCompareTest>
-  void doUpdateSingleGroup(
-      char* group,
-      const SelectivityVector& rows,
-      const VectorPtr& arg,
-      TCompareTest compareTest) {
-    DecodedVector decoded(*arg, rows, true);
-    auto indices = decoded.indices();
-    auto baseVector = decoded.base();
-
-    if (decoded.isConstantMapping()) {
-      if (checkNestedNulls(decoded, indices, 0, throwOnNestedNulls_)) {
-        return;
-      }
-
-      auto accumulator = value<SingleValueAccumulator>(group);
-      if (!accumulator->hasValue() ||
-          compareTest(compare(accumulator, decoded, 0))) {
-        accumulator->write(baseVector, indices[0], allocator_);
-      }
-      return;
-    }
-
-    auto accumulator = value<SingleValueAccumulator>(group);
-    rows.applyToSelected([&](vector_size_t i) {
-      if (checkNestedNulls(decoded, indices, i, throwOnNestedNulls_)) {
-        return;
-      }
-
-      if (!accumulator->hasValue() ||
-          compareTest(compare(accumulator, decoded, i))) {
-        accumulator->write(baseVector, indices[i], allocator_);
-      }
-    });
-  }
-
- private:
-  const bool throwOnNestedNulls_;
-};
-
-class NonNumericMaxAggregate : public NonNumericMinMaxAggregateBase {
- public:
-  explicit NonNumericMaxAggregate(
-      const TypePtr& resultType,
-      bool throwOnNestedNulls)
-      : NonNumericMinMaxAggregateBase(resultType, throwOnNestedNulls) {}
-
-  void addRawInput(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    doUpdate(groups, rows, args[0], [](int32_t compareResult) {
-      return compareResult < 0;
-    });
-  }
-
-  void addIntermediateResults(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    addRawInput(groups, rows, args, mayPushdown);
-  }
-
-  void addSingleGroupRawInput(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    doUpdateSingleGroup(group, rows, args[0], [](int32_t compareResult) {
-      return compareResult < 0;
-    });
-  }
-
-  void addSingleGroupIntermediateResults(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    addSingleGroupRawInput(group, rows, args, mayPushdown);
-  }
-};
-
-class NonNumericMinAggregate : public NonNumericMinMaxAggregateBase {
- public:
-  explicit NonNumericMinAggregate(
-      const TypePtr& resultType,
-      bool throwOnNestedNulls)
-      : NonNumericMinMaxAggregateBase(resultType, throwOnNestedNulls) {}
-
-  void addRawInput(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    doUpdate(groups, rows, args[0], [](int32_t compareResult) {
-      return compareResult > 0;
-    });
-  }
-
-  void addIntermediateResults(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    addRawInput(groups, rows, args, mayPushdown);
-  }
-
-  void addSingleGroupRawInput(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    doUpdateSingleGroup(group, rows, args[0], [](int32_t compareResult) {
-      return compareResult > 0;
-    });
-  }
-
-  void addSingleGroupIntermediateResults(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    addSingleGroupRawInput(group, rows, args, mayPushdown);
-  }
-};
-
 std::pair<vector_size_t*, vector_size_t*> rawOffsetAndSizes(
     ArrayVector& arrayVector) {
   return {
@@ -540,17 +41,21 @@ std::pair<vector_size_t*, vector_size_t*> rawOffsetAndSizes(
 template <typename T, typename Compare>
 struct MinMaxNAccumulator {
   int64_t n{0};
-  std::priority_queue<T, std::vector<T, StlAllocator<T>>, Compare> topValues;
+  using Allocator = std::conditional_t<
+      std::is_same_v<int128_t, T>,
+      AlignedStlAllocator<T, sizeof(int128_t)>,
+      StlAllocator<T>>;
+  std::vector<T, Allocator> heapValues;
 
   explicit MinMaxNAccumulator(HashStringAllocator* allocator)
-      : topValues{Compare{}, StlAllocator<T>(allocator)} {}
+      : heapValues{Allocator(allocator)} {}
 
   int64_t getN() const {
     return n;
   }
 
   size_t size() const {
-    return topValues.size();
+    return heapValues.size();
   }
 
   void checkAndSetN(DecodedVector& decodedN, vector_size_t row) {
@@ -579,25 +84,27 @@ struct MinMaxNAccumulator {
   }
 
   void compareAndAdd(T value, Compare& comparator) {
-    if (topValues.size() < n) {
-      topValues.push(value);
+    if (heapValues.size() < n) {
+      heapValues.push_back(value);
+      std::push_heap(heapValues.begin(), heapValues.end(), comparator);
     } else {
-      const auto& topValue = topValues.top();
+      const auto& topValue = heapValues.front();
       if (comparator(value, topValue)) {
-        topValues.pop();
-        topValues.push(value);
+        std::pop_heap(heapValues.begin(), heapValues.end(), comparator);
+        heapValues.back() = value;
+        std::push_heap(heapValues.begin(), heapValues.end(), comparator);
       }
     }
   }
 
-  /// Moves all values from 'topValues' into 'rawValues' buffer. The queue of
-  /// 'topValues' will be empty after this call.
-  void extractValues(T* rawValues, vector_size_t offset) {
-    const vector_size_t size = topValues.size();
-    for (auto i = size - 1; i >= 0; --i) {
-      rawValues[offset + i] = topValues.top();
-      topValues.pop();
+  /// Copy all values from 'topValues' into 'rawValues' buffer. The heap remains
+  /// unchanged after the call.
+  void extractValues(T* rawValues, vector_size_t offset, Compare& comparator) {
+    std::sort_heap(heapValues.begin(), heapValues.end(), comparator);
+    for (int64_t i = heapValues.size() - 1; i >= 0; --i) {
+      rawValues[offset + i] = heapValues[i];
     }
+    std::make_heap(heapValues.begin(), heapValues.end(), comparator);
   }
 };
 
@@ -617,7 +124,7 @@ class MinMaxNAggregateBase : public exec::Aggregate {
     return sizeof(AccumulatorType);
   }
 
-  void initializeNewGroups(
+  void initializeNewGroupsInternal(
       char** groups,
       folly::Range<const vector_size_t*> indices) override {
     exec::Aggregate::setAllNulls(groups, indices);
@@ -740,7 +247,7 @@ class MinMaxNAggregateBase : public exec::Aggregate {
     extractValues(groups, numGroups, rawOffsets, rawSizes, rawValues, rawNs);
   }
 
-  void destroy(folly::Range<char**> groups) override {
+  void destroyInternal(folly::Range<char**> groups) override {
     destroyAccumulators<AccumulatorType>(groups);
   }
 
@@ -770,7 +277,7 @@ class MinMaxNAggregateBase : public exec::Aggregate {
         if (rawNs != nullptr) {
           rawNs[i] = accumulator->n;
         }
-        accumulator->extractValues(rawValues, offset);
+        accumulator->extractValues(rawValues, offset, comparator_);
 
         offset += size;
       }
@@ -880,29 +387,46 @@ class MinMaxNAggregateBase : public exec::Aggregate {
 };
 
 template <typename T>
-class MinNAggregate : public MinMaxNAggregateBase<T, std::less<T>> {
+struct LessThanComparator : public std::less<T> {};
+template <>
+struct LessThanComparator<float>
+    : public util::floating_point::NaNAwareLessThan<float> {};
+template <>
+struct LessThanComparator<double>
+    : public util::floating_point::NaNAwareLessThan<double> {};
+
+template <typename T>
+struct GreaterThanComparator : public std::greater<T> {};
+template <>
+struct GreaterThanComparator<float>
+    : public util::floating_point::NaNAwareGreaterThan<float> {};
+template <>
+struct GreaterThanComparator<double>
+    : public util::floating_point::NaNAwareGreaterThan<double> {};
+
+template <typename T>
+class MinNAggregate : public MinMaxNAggregateBase<T, LessThanComparator<T>> {
  public:
   explicit MinNAggregate(const TypePtr& resultType)
-      : MinMaxNAggregateBase<T, std::less<T>>(resultType) {}
+      : MinMaxNAggregateBase<T, LessThanComparator<T>>(resultType) {}
 };
 
 template <typename T>
-class MaxNAggregate : public MinMaxNAggregateBase<T, std::greater<T>> {
+class MaxNAggregate : public MinMaxNAggregateBase<T, GreaterThanComparator<T>> {
  public:
   explicit MaxNAggregate(const TypePtr& resultType)
-      : MinMaxNAggregateBase<T, std::greater<T>>(resultType) {}
+      : MinMaxNAggregateBase<T, GreaterThanComparator<T>>(resultType) {}
 };
 
-template <
-    template <typename T>
-    class TNumeric,
-    typename TNonNumeric,
-    template <typename T>
-    class TNumericN>
-exec::AggregateRegistrationResult registerMinMax(const std::string& name) {
+template <template <typename T> class TNumericN>
+exec::AggregateRegistrationResult registerMinMax(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite,
+    bool registerMin) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .typeVariable("T")
+                           .orderableTypeVariable("T")
                            .returnType("T")
                            .intermediateType("T")
                            .argumentType("T")
@@ -919,18 +443,27 @@ exec::AggregateRegistrationResult registerMinMax(const std::string& name) {
             .build());
   }
 
+  // decimal(p,s), bigint -> row(array(decimal(p,s)), bigint) ->
+  // array(decimal(p,s))
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .argumentType("bigint")
+          .intermediateType("row(bigint, array(DECIMAL(a_precision, a_scale)))")
+          .returnType("array(DECIMAL(a_precision, a_scale))")
+          .build());
+
   return exec::registerAggregateFunction(
       name,
       std::move(signatures),
-      [name](
+      [name, registerMin](
           core::AggregationNode::Step step,
           std::vector<TypePtr> argTypes,
           const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
-          -> std::unique_ptr<exec::Aggregate> {
+          const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
         const bool nAgg = !resultType->equivalent(*argTypes[0]);
-        const bool throwOnNestedNulls = velox::exec::isRawInput(step);
-
         if (nAgg) {
           // We have either 2 arguments: T, bigint (partial aggregation)
           // or one argument: row(bigint, array(T)) (intermediate or final
@@ -955,64 +488,47 @@ exec::AggregateRegistrationResult registerMinMax(const std::string& name) {
             case TypeKind::TIMESTAMP:
               return std::make_unique<TNumericN<Timestamp>>(resultType);
             case TypeKind::HUGEINT:
-              return std::make_unique<TNumericN<int128_t>>(resultType);
+              if (inputType->isLongDecimal()) {
+                return std::make_unique<TNumericN<int128_t>>(resultType);
+              }
+              [[fallthrough]];
             default:
-              VELOX_CHECK(
-                  false,
+              VELOX_UNREACHABLE(
                   "Unknown input type for {} aggregation {}",
                   name,
                   inputType->kindName());
           }
         } else {
-          auto inputType = argTypes[0];
-          switch (inputType->kind()) {
-            case TypeKind::BOOLEAN:
-              return std::make_unique<TNumeric<bool>>(resultType);
-            case TypeKind::TINYINT:
-              return std::make_unique<TNumeric<int8_t>>(resultType);
-            case TypeKind::SMALLINT:
-              return std::make_unique<TNumeric<int16_t>>(resultType);
-            case TypeKind::INTEGER:
-              return std::make_unique<TNumeric<int32_t>>(resultType);
-            case TypeKind::BIGINT:
-              return std::make_unique<TNumeric<int64_t>>(resultType);
-            case TypeKind::REAL:
-              return std::make_unique<TNumeric<float>>(resultType);
-            case TypeKind::DOUBLE:
-              return std::make_unique<TNumeric<double>>(resultType);
-            case TypeKind::TIMESTAMP:
-              return std::make_unique<TNumeric<Timestamp>>(resultType);
-            case TypeKind::HUGEINT:
-              return std::make_unique<TNumeric<int128_t>>(resultType);
-            case TypeKind::VARBINARY:
-              [[fallthrough]];
-            case TypeKind::VARCHAR:
-              return std::make_unique<TNonNumeric>(inputType, false);
-            case TypeKind::ARRAY:
-              [[fallthrough]];
-            case TypeKind::MAP:
-              [[fallthrough]];
-            case TypeKind::ROW:
-              return std::make_unique<TNonNumeric>(
-                  inputType, throwOnNestedNulls);
-            default:
-              VELOX_CHECK(
-                  false,
-                  "Unknown input type for {} aggregation {}",
-                  name,
-                  inputType->kindName());
+          if (registerMin) {
+            auto factory = getMinFunctionFactory(
+                name,
+                CompareFlags::NullHandlingMode::kNullAsIndeterminate,
+                TimestampPrecision::kMilliseconds);
+            return factory(step, argTypes, resultType, config);
+          } else {
+            auto factory = getMaxFunctionFactory(
+                name,
+                CompareFlags::NullHandlingMode::kNullAsIndeterminate,
+                TimestampPrecision::kMilliseconds);
+            return factory(step, argTypes, resultType, config);
           }
         }
-      });
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace
 
-void registerMinMaxAggregates(const std::string& prefix) {
-  registerMinMax<MinAggregate, NonNumericMinAggregate, MinNAggregate>(
-      prefix + kMin);
-  registerMinMax<MaxAggregate, NonNumericMaxAggregate, MaxNAggregate>(
-      prefix + kMax);
+void registerMinMaxAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerMinMax<MinNAggregate>(
+      prefix + kMin, withCompanionFunctions, overwrite, true);
+  registerMinMax<MaxNAggregate>(
+      prefix + kMax, withCompanionFunctions, overwrite, false);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MinMaxByAggregates.cpp b/velox/functions/prestosql/aggregates/MinMaxByAggregates.cpp
index 58003f565bee2..71f020ca398c1 100644
--- a/velox/functions/prestosql/aggregates/MinMaxByAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/MinMaxByAggregates.cpp
@@ -14,10 +14,12 @@
  * limitations under the License.
  */
 
+#include <algorithm>
+#include "velox/functions/lib/aggregates/Compare.h"
 #include "velox/functions/lib/aggregates/MinMaxByAggregatesBase.h"
 #include "velox/functions/lib/aggregates/ValueSet.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/functions/prestosql/aggregates/Compare.h"
+#include "velox/type/FloatingPointUtil.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -39,8 +41,16 @@ struct Comparator {
         return true;
       }
       if constexpr (greaterThan) {
+        if constexpr (std::is_floating_point_v<T>) {
+          return util::floating_point::NaNAwareGreaterThan<T>{}(
+              newComparisons.valueAt<T>(index), *accumulator);
+        }
         return newComparisons.valueAt<T>(index) > *accumulator;
       } else {
+        if constexpr (std::is_floating_point_v<T>) {
+          return util::floating_point::NaNAwareLessThan<T>{}(
+              newComparisons.valueAt<T>(index), *accumulator);
+        }
         return newComparisons.valueAt<T>(index) < *accumulator;
       }
     } else {
@@ -48,10 +58,18 @@ struct Comparator {
       // is less than vector value.
       if constexpr (greaterThan) {
         return !accumulator->hasValue() ||
-            prestosql::compare(accumulator, newComparisons, index) < 0;
+            functions::aggregate::compare(
+                accumulator,
+                newComparisons,
+                index,
+                CompareFlags::NullHandlingMode::kNullAsIndeterminate) < 0;
       } else {
         return !accumulator->hasValue() ||
-            prestosql::compare(accumulator, newComparisons, index) > 0;
+            functions::aggregate::compare(
+                accumulator,
+                newComparisons,
+                index,
+                CompareFlags::NullHandlingMode::kNullAsIndeterminate) > 0;
       }
     }
   }
@@ -89,19 +107,22 @@ struct MinMaxByNAccumulator {
   int64_t n{0};
 
   using Pair = std::pair<C, std::optional<V>>;
-  using Queue =
-      std::priority_queue<Pair, std::vector<Pair, StlAllocator<Pair>>, Compare>;
-  Queue topPairs;
+  using Allocator = std::conditional_t<
+      std::is_same_v<int128_t, V> || std::is_same_v<int128_t, C>,
+      AlignedStlAllocator<Pair, sizeof(int128_t)>,
+      StlAllocator<Pair>>;
+  using Heap = std::vector<Pair, Allocator>;
+  Heap heapValues;
 
   explicit MinMaxByNAccumulator(HashStringAllocator* allocator)
-      : topPairs{Compare{}, StlAllocator<Pair>(allocator)} {}
+      : heapValues{Allocator(allocator)} {}
 
   int64_t getN() const {
     return n;
   }
 
   size_t size() const {
-    return topPairs.size();
+    return heapValues.size();
   }
 
   void checkAndSetN(DecodedVector& decodedN, vector_size_t row) {
@@ -126,61 +147,64 @@ struct MinMaxByNAccumulator {
 
   void
   compareAndAdd(C comparison, std::optional<V> value, Compare& comparator) {
-    if (topPairs.size() < n) {
-      topPairs.push({comparison, value});
+    if (heapValues.size() < n) {
+      heapValues.push_back({comparison, value});
+      std::push_heap(heapValues.begin(), heapValues.end(), comparator);
     } else {
-      const auto& topPair = topPairs.top();
+      const auto& topPair = heapValues.front();
       if (comparator.compare(comparison, topPair)) {
-        topPairs.pop();
-        topPairs.push({comparison, value});
+        std::pop_heap(heapValues.begin(), heapValues.end(), comparator);
+        heapValues.back() = std::make_pair(comparison, value);
+        std::push_heap(heapValues.begin(), heapValues.end(), comparator);
       }
     }
   }
 
-  /// Moves all values from 'topPairs' into 'rawValues' and 'rawValueNulls'
-  /// buffers. The queue of 'topPairs' will be empty after this call.
+  /// Extract all values from 'heapValues' into 'rawValues' and 'rawValueNulls'
+  /// buffers. The heap remains unchanged after the call.
   void extractValues(
       TRawValue* rawValues,
       uint64_t* rawValueNulls,
-      vector_size_t offset) {
-    const vector_size_t size = topPairs.size();
-    for (auto i = size - 1; i >= 0; --i) {
-      const auto& topPair = topPairs.top();
+      vector_size_t offset,
+      Compare& comparator) {
+    std::sort_heap(heapValues.begin(), heapValues.end(), comparator);
+    // Add heap elements to rawValues in ascending order.
+    for (int64_t i = 0; i < heapValues.size(); ++i) {
+      const auto& pair = heapValues[i];
       const auto index = offset + i;
-
-      const bool valueIsNull = !topPair.second.has_value();
+      const bool valueIsNull = !pair.second.has_value();
       bits::setNull(rawValueNulls, index, valueIsNull);
       if (!valueIsNull) {
-        RawValueExtractor<V>::extract(rawValues, index, topPair.second.value());
+        RawValueExtractor<V>::extract(rawValues, index, pair.second.value());
       }
-
-      topPairs.pop();
     }
+    std::make_heap(heapValues.begin(), heapValues.end(), comparator);
   }
 
-  /// Moves all pairs of (comparison, value) from 'topPairs' into
-  /// 'rawComparisons', 'rawValues' and 'rawValueNulls' buffers. The queue of
-  /// 'topPairs' will be empty after this call.
+  /// Moves all pairs of (comparison, value) from 'heapValues' into
+  /// 'rawComparisons', 'rawValues' and 'rawValueNulls' buffers. The heap
+  /// remains unchanged after the call.
   void extractPairs(
       TRawComparison* rawComparisons,
       TRawValue* rawValues,
       uint64_t* rawValueNulls,
-      vector_size_t offset) {
-    const vector_size_t size = topPairs.size();
-    for (auto i = size - 1; i >= 0; --i) {
-      const auto& topPair = topPairs.top();
+      vector_size_t offset,
+      Compare& comparator) {
+    std::sort_heap(heapValues.begin(), heapValues.end(), comparator);
+    // Add heap elements to rawComparisons and rawValues in ascending order.
+    for (int64_t i = 0; i < heapValues.size(); ++i) {
+      const auto& pair = heapValues[i];
       const auto index = offset + i;
 
-      RawValueExtractor<C>::extract(rawComparisons, index, topPair.first);
+      RawValueExtractor<C>::extract(rawComparisons, index, pair.first);
 
-      const bool valueIsNull = !topPair.second.has_value();
+      const bool valueIsNull = !pair.second.has_value();
       bits::setNull(rawValueNulls, index, valueIsNull);
       if (!valueIsNull) {
-        RawValueExtractor<V>::extract(rawValues, index, topPair.second.value());
+        RawValueExtractor<V>::extract(rawValues, index, pair.second.value());
       }
-
-      topPairs.pop();
     }
+    std::make_heap(heapValues.begin(), heapValues.end(), comparator);
   }
 };
 
@@ -199,15 +223,18 @@ struct Extractor {
 
   void extractValues(
       MinMaxByNAccumulator<V, C, Compare>* accumulator,
-      vector_size_t offset) {
-    accumulator->extractValues(rawValues, rawValueNulls, offset);
+      vector_size_t offset,
+      Compare& comparator) {
+    accumulator->extractValues(rawValues, rawValueNulls, offset, comparator);
   }
 
   void extractPairs(
       MinMaxByNAccumulator<V, C, Compare>* accumulator,
       TRawComparison* rawComparisons,
-      vector_size_t offset) {
-    accumulator->extractPairs(rawComparisons, rawValues, rawValueNulls, offset);
+      vector_size_t offset,
+      Compare& comparator) {
+    accumulator->extractPairs(
+        rawComparisons, rawValues, rawValueNulls, offset, comparator);
   }
 };
 
@@ -221,10 +248,8 @@ struct MinMaxByNStringViewAccumulator {
       : base{allocator}, valueSet{allocator} {}
 
   ~MinMaxByNStringViewAccumulator() {
-    while (!base.topPairs.empty()) {
-      auto& pair = base.topPairs.top();
-      freePair(pair);
-      base.topPairs.pop();
+    for (auto i = 0; i < base.heapValues.size(); ++i) {
+      freePair(base.heapValues[i]);
     }
   }
 
@@ -242,47 +267,53 @@ struct MinMaxByNStringViewAccumulator {
 
   void
   compareAndAdd(C comparison, std::optional<V> value, Compare& comparator) {
-    if (base.topPairs.size() < base.n) {
-      addToAccumulator(comparison, value);
+    if (base.heapValues.size() < base.n) {
+      addToAccumulator(comparison, value, comparator);
     } else {
-      const auto& topPair = base.topPairs.top();
+      const auto& topPair = base.heapValues.front();
       if (comparator.compare(comparison, topPair)) {
-        freePair(topPair);
-        base.topPairs.pop();
-        addToAccumulator(comparison, value);
+        std::pop_heap(
+            base.heapValues.begin(), base.heapValues.end(), comparator);
+        freePair(base.heapValues.back());
+        base.heapValues.pop_back();
+        addToAccumulator(comparison, value, comparator);
       }
     }
   }
 
-  /// Moves all values from 'topPairs' into 'values'
-  /// buffers. The queue of 'topPairs' will be empty after this call.
-  void extractValues(FlatVector<V>& values, vector_size_t offset) {
-    const vector_size_t size = base.topPairs.size();
-    for (auto i = size - 1; i >= 0; --i) {
-      const auto& pair = base.topPairs.top();
+  /// Extract all values from 'heapValues' into 'rawValues' and 'rawValueNulls'
+  /// buffers. The heap remains unchanged after the call.
+  void extractValues(
+      FlatVector<V>& values,
+      vector_size_t offset,
+      Compare& comparator) {
+    std::sort_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
+    // Add heap elements to values in ascending order.
+    for (int64_t i = 0; i < base.heapValues.size(); ++i) {
+      const auto& pair = base.heapValues[i];
       extractValue(pair, values, offset + i);
-      freePair(pair);
-      base.topPairs.pop();
     }
+    std::make_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
   }
 
-  /// Moves all pairs of (comparison, value) from 'topPairs' into
-  /// 'rawComparisons' buffer and 'values' vector. The queue of
-  /// 'topPairs' will be empty after this call.
+  /// Moves all pairs of (comparison, value) from 'heapValues' into
+  /// 'rawComparisons', 'rawValues' and 'rawValueNulls' buffers. The heap
+  /// remains unchanged after the call.
   void extractPairs(
       FlatVector<C>& compares,
       FlatVector<V>& values,
-      vector_size_t offset) {
-    const vector_size_t size = base.topPairs.size();
-    for (auto i = size - 1; i >= 0; --i) {
-      const auto& topPair = base.topPairs.top();
+      vector_size_t offset,
+      Compare& comparator) {
+    std::sort_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
+    // Add heap elements to compares and values in ascending order.
+    for (int64_t i = 0; i < base.heapValues.size(); ++i) {
+      const auto& pair = base.heapValues[i];
       const auto index = offset + i;
 
-      extractCompare(topPair, compares, index);
-      extractValue(topPair, values, index);
-      freePair(topPair);
-      base.topPairs.pop();
+      extractCompare(pair, compares, index);
+      extractValue(pair, values, index);
     }
+    std::make_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
   }
 
  private:
@@ -296,48 +327,50 @@ struct MinMaxByNStringViewAccumulator {
     return valueSet.write(*value);
   }
 
-  void addToAccumulator(C comparison, std::optional<V> value) {
+  void
+  addToAccumulator(C comparison, std::optional<V> value, Compare& comparator) {
     if constexpr (
         std::is_same_v<V, StringView> && std::is_same_v<C, StringView>) {
-      base.topPairs.push({valueSet.write(comparison), writeString(value)});
+      base.heapValues.push_back(
+          std::make_pair(valueSet.write(comparison), writeString(value)));
     } else if constexpr (std::is_same_v<V, StringView>) {
-      base.topPairs.push({comparison, writeString(value)});
+      base.heapValues.push_back(std::make_pair(comparison, writeString(value)));
     } else {
       static_assert(
           std::is_same_v<C, StringView>,
           "At least one of V and C must be StringView.");
-      base.topPairs.push({valueSet.write(comparison), value});
+      base.heapValues.push_back(
+          std::make_pair(valueSet.write(comparison), value));
     }
+    std::push_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
   }
 
-  void freePair(typename BaseType::Queue::const_reference topPair) {
+  void freePair(typename BaseType::Heap::const_reference pair) {
     if constexpr (std::is_same_v<C, StringView>) {
-      valueSet.free(topPair.first);
+      valueSet.free(pair.first);
     }
     if constexpr (std::is_same_v<V, StringView>) {
-      if (topPair.second.has_value()) {
-        valueSet.free(*topPair.second);
+      if (pair.second.has_value()) {
+        valueSet.free(*pair.second);
       }
     }
   }
 
-  void extractValue(
-      const Pair& topPair,
-      FlatVector<V>& values,
-      vector_size_t index) {
-    const bool valueIsNull = !topPair.second.has_value();
+  void
+  extractValue(const Pair& pair, FlatVector<V>& values, vector_size_t index) {
+    const bool valueIsNull = !pair.second.has_value();
     values.setNull(index, valueIsNull);
     if (!valueIsNull) {
-      values.set(index, topPair.second.value());
+      values.set(index, pair.second.value());
     }
   }
 
   void extractCompare(
-      const Pair& topPair,
+      const Pair& pair,
       FlatVector<C>& compares,
       vector_size_t index) {
     compares.setNull(index, false);
-    compares.set(index, topPair.first);
+    compares.set(index, pair.first);
   }
 };
 
@@ -353,15 +386,17 @@ struct StringViewExtractor {
 
   void extractValues(
       MinMaxByNStringViewAccumulator<V, C, Compare>* accumulator,
-      vector_size_t offset) {
-    accumulator->extractValues(values, offset);
+      vector_size_t offset,
+      Compare& comparator) {
+    accumulator->extractValues(values, offset, comparator);
   }
 
   void extractPairs(
       MinMaxByNStringViewAccumulator<V, C, Compare>* accumulator,
-      vector_size_t offset) {
+      vector_size_t offset,
+      Compare& comparator) {
     VELOX_DCHECK_NOT_NULL(compares);
-    accumulator->extractPairs(*compares, values, offset);
+    accumulator->extractPairs(*compares, values, offset, comparator);
   }
 };
 
@@ -379,10 +414,8 @@ struct MinMaxByNComplexTypeAccumulator {
       : base{allocator}, valueSet{allocator} {}
 
   ~MinMaxByNComplexTypeAccumulator() {
-    while (!base.topPairs.empty()) {
-      auto& pair = base.topPairs.top();
-      freePair(pair);
-      base.topPairs.pop();
+    for (auto i = 0; i < base.heapValues.size(); ++i) {
+      freePair(base.heapValues[i]);
     }
   }
 
@@ -403,62 +436,70 @@ struct MinMaxByNComplexTypeAccumulator {
       DecodedVector& decoded,
       vector_size_t index,
       Compare& comparator) {
-    if (base.topPairs.size() < base.n) {
+    if (base.heapValues.size() < base.n) {
       auto position = writeComplex(decoded, index);
-      addToAccumulator(comparison, position);
+      addToAccumulator(comparison, position, comparator);
     } else {
-      const auto& topPair = base.topPairs.top();
+      const auto& topPair = base.heapValues.front();
       if (comparator.compare(comparison, topPair)) {
-        freePair(topPair);
-        base.topPairs.pop();
-
+        std::pop_heap(
+            base.heapValues.begin(), base.heapValues.end(), comparator);
         auto position = writeComplex(decoded, index);
-        addToAccumulator(comparison, position);
+        freePair(base.heapValues.back());
+        base.heapValues.pop_back();
+        addToAccumulator(comparison, position, comparator);
       }
     }
   }
 
-  /// Moves all values from 'topPairs' into 'values' vector. The queue of
-  /// 'topPairs' will be empty after this call.
-  void extractValues(BaseVector& values, vector_size_t offset) {
-    const vector_size_t size = base.topPairs.size();
-    for (auto i = size - 1; i >= 0; --i) {
-      const auto& pair = base.topPairs.top();
+  /// Extract all values from 'heapValues' into 'rawValues' and 'rawValueNulls'
+  /// buffers. The heap remains unchanged after the call.
+  void
+  extractValues(BaseVector& values, vector_size_t offset, Compare& comparator) {
+    std::sort_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
+    // Add heap elements to values in ascending order.
+    for (int64_t i = 0; i < base.heapValues.size(); ++i) {
+      const auto& pair = base.heapValues[i];
       extractValue(pair, values, offset + i);
-      freePair(pair);
-      base.topPairs.pop();
     }
+    std::make_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
   }
 
-  /// Moves all pairs of (comparison, value) from 'topPairs' into
-  /// 'rawComparisons' buffer and 'values' vector. The queue of
-  /// 'topPairs' will be empty after this call.
+  /// Moves all pairs of (comparison, value) from 'heapValues' into
+  /// 'rawComparisons', 'rawValues' and 'rawValueNulls' buffers. The heap
+  /// remains unchanged after the call.
   void extractPairs(
       FlatVector<C>& compares,
       BaseVector& values,
-      vector_size_t offset) {
-    const vector_size_t size = base.topPairs.size();
-    for (auto i = size - 1; i >= 0; --i) {
-      const auto& topPair = base.topPairs.top();
+      vector_size_t offset,
+      Compare& comparator) {
+    std::sort_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
+    // Add heap elements to compares and values in ascending order.
+    for (int64_t i = 0; i < base.heapValues.size(); ++i) {
+      const auto& pair = base.heapValues[i];
       const auto index = offset + i;
 
-      extractCompare(topPair, compares, index);
-      extractValue(topPair, values, index);
-      freePair(topPair);
-      base.topPairs.pop();
+      extractCompare(pair, compares, index);
+      extractValue(pair, values, index);
     }
+    std::make_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
   }
 
  private:
   using V = HashStringAllocator::Position;
   using Pair = typename MinMaxByNAccumulator<V, C, Compare>::Pair;
 
-  void addToAccumulator(C comparison, const std::optional<V>& position) {
+  void addToAccumulator(
+      C comparison,
+      const std::optional<V>& position,
+      Compare& comparator) {
     if constexpr (std::is_same_v<C, StringView>) {
-      base.topPairs.push({valueSet.write(comparison), position});
+      base.heapValues.push_back(
+          std::make_pair(valueSet.write(comparison), position));
     } else {
-      base.topPairs.push({comparison, position});
+      base.heapValues.push_back(std::make_pair(comparison, position));
     }
+    std::push_heap(base.heapValues.begin(), base.heapValues.end(), comparator);
   }
 
   std::optional<HashStringAllocator::Position> writeComplex(
@@ -472,33 +513,32 @@ struct MinMaxByNComplexTypeAccumulator {
     return position;
   }
 
-  void freePair(typename BaseType::Queue::const_reference topPair) {
+  void freePair(typename BaseType::Heap::const_reference pair) {
     if constexpr (std::is_same_v<C, StringView>) {
-      valueSet.free(topPair.first);
+      valueSet.free(pair.first);
     }
-    if (topPair.second.has_value()) {
-      valueSet.free(topPair.second->header);
+    if (pair.second.has_value()) {
+      valueSet.free(pair.second->header);
     }
   }
 
-  void
-  extractValue(const Pair& topPair, BaseVector& values, vector_size_t index) {
-    const bool valueIsNull = !topPair.second.has_value();
+  void extractValue(const Pair& pair, BaseVector& values, vector_size_t index) {
+    const bool valueIsNull = !pair.second.has_value();
     values.setNull(index, valueIsNull);
     if (!valueIsNull) {
-      auto position = topPair.second.value();
+      auto position = pair.second.value();
       valueSet.read(&values, index, position.header);
     }
   }
 
   void extractCompare(
-      const Pair& topPair,
+      const Pair& pair,
       FlatVector<C>& compares,
       vector_size_t index) {
     compares.setNull(index, false);
-    compares.set(index, topPair.first);
+    compares.set(index, pair.first);
   }
-}; // namespace
+};
 
 template <typename C, typename Compare>
 struct ComplexTypeExtractor {
@@ -511,15 +551,17 @@ struct ComplexTypeExtractor {
 
   void extractValues(
       MinMaxByNComplexTypeAccumulator<C, Compare>* accumulator,
-      vector_size_t offset) {
-    accumulator->extractValues(values, offset);
+      vector_size_t offset,
+      Compare& comparator) {
+    accumulator->extractValues(values, offset, comparator);
   }
 
   void extractPairs(
       MinMaxByNComplexTypeAccumulator<C, Compare>* accumulator,
-      vector_size_t offset) {
+      vector_size_t offset,
+      Compare& comparator) {
     VELOX_DCHECK_NOT_NULL(compares);
-    accumulator->extractPairs(*compares, values, offset);
+    accumulator->extractPairs(*compares, values, offset, comparator);
   }
 };
 
@@ -527,10 +569,16 @@ template <typename V, typename C>
 struct Less {
   using Pair = std::pair<C, std::optional<V>>;
   bool operator()(const Pair& lhs, const Pair& rhs) {
+    if constexpr (std::is_floating_point_v<C>) {
+      return util::floating_point::NaNAwareLessThan<C>{}(lhs.first, rhs.first);
+    }
     return lhs.first < rhs.first;
   }
 
   bool compare(C lhs, const Pair& rhs) {
+    if constexpr (std::is_floating_point_v<C>) {
+      return util::floating_point::NaNAwareLessThan<C>{}(lhs, rhs.first);
+    }
     return lhs < rhs.first;
   }
 };
@@ -539,10 +587,17 @@ template <typename V, typename C>
 struct Greater {
   using Pair = std::pair<C, std::optional<V>>;
   bool operator()(const Pair& lhs, const Pair& rhs) {
+    if constexpr (std::is_floating_point_v<C>) {
+      return util::floating_point::NaNAwareGreaterThan<C>{}(
+          lhs.first, rhs.first);
+    }
     return lhs.first > rhs.first;
   }
 
   bool compare(C lhs, const Pair& rhs) {
+    if constexpr (std::is_floating_point_v<C>) {
+      return util::floating_point::NaNAwareGreaterThan<C>{}(lhs, rhs.first);
+    }
     return lhs > rhs.first;
   }
 };
@@ -615,16 +670,6 @@ class MinMaxByNAggregate : public exec::Aggregate {
     return sizeof(AccumulatorType);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (const vector_size_t i : indices) {
-      auto group = groups[i];
-      new (group + offset_) AccumulatorType(allocator_);
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto valuesArray = (*result)->as<ArrayVector>();
@@ -658,7 +703,7 @@ class MinMaxByNAggregate : public exec::Aggregate {
         rawOffsets[i] = offset;
         rawSizes[i] = size;
 
-        extractor->extractValues(accumulator, offset);
+        extractor->extractValues(accumulator, offset, comparator_);
 
         offset += size;
       }
@@ -668,12 +713,12 @@ class MinMaxByNAggregate : public exec::Aggregate {
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto rowVector = (*result)->as<RowVector>();
+    rowVector->resize(numGroups);
+
     auto nVector = rowVector->childAt(0);
     auto comparisonArray = rowVector->childAt(1)->as<ArrayVector>();
     auto valueArray = rowVector->childAt(2)->as<ArrayVector>();
 
-    resizeRowVectorAndChildren(*rowVector, numGroups);
-
     auto* rawNs = nVector->as<FlatVector<int64_t>>()->mutableRawValues();
 
     const auto numValues =
@@ -720,9 +765,10 @@ class MinMaxByNAggregate : public exec::Aggregate {
         if constexpr (
             std::is_same_v<V, StringView> || std::is_same_v<C, StringView> ||
             std::is_same_v<V, ComplexType>) {
-          extractor->extractPairs(accumulator, offset);
+          extractor->extractPairs(accumulator, offset, comparator_);
         } else {
-          extractor->extractPairs(accumulator, rawComparisons, offset);
+          extractor->extractPairs(
+              accumulator, rawComparisons, offset, comparator_);
         }
 
         offset += size;
@@ -799,7 +845,18 @@ class MinMaxByNAggregate : public exec::Aggregate {
     });
   }
 
-  void destroy(folly::Range<char**> groups) override {
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (const vector_size_t i : indices) {
+      auto group = groups[i];
+      new (group + offset_) AccumulatorType(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
     destroyAccumulators<AccumulatorType>(groups);
   }
 
@@ -1018,6 +1075,8 @@ std::unique_ptr<exec::Aggregate> createNArg(
       return std::make_unique<NAggregate<W, int32_t>>(resultType);
     case TypeKind::BIGINT:
       return std::make_unique<NAggregate<W, int64_t>>(resultType);
+    case TypeKind::HUGEINT:
+      return std::make_unique<NAggregate<W, int128_t>>(resultType);
     case TypeKind::REAL:
       return std::make_unique<NAggregate<W, float>>(resultType);
     case TypeKind::DOUBLE:
@@ -1054,6 +1113,9 @@ std::unique_ptr<exec::Aggregate> createNArg(
     case TypeKind::BIGINT:
       return createNArg<NAggregate, int64_t>(
           resultType, compareType, errorMessage);
+    case TypeKind::HUGEINT:
+      return createNArg<NAggregate, int128_t>(
+          resultType, compareType, errorMessage);
     case TypeKind::REAL:
       return createNArg<NAggregate, float>(
           resultType, compareType, errorMessage);
@@ -1102,23 +1164,28 @@ template <
     bool isMaxFunc,
     template <typename U, typename V>
     class NAggregate>
-exec::AggregateRegistrationResult registerMinMaxBy(const std::string& name) {
+exec::AggregateRegistrationResult registerMinMaxBy(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   // V, C -> row(V, C) -> V.
   signatures.push_back(exec::AggregateFunctionSignatureBuilder()
                            .typeVariable("V")
-                           .typeVariable("C")
+                           .orderableTypeVariable("C")
                            .returnType("V")
                            .intermediateType("row(V,C)")
                            .argumentType("V")
                            .argumentType("C")
                            .build());
+  // Add signatures for 3-arg version of min_by/max_by.
   const std::vector<std::string> supportedCompareTypes = {
       "boolean",
       "tinyint",
       "smallint",
       "integer",
       "bigint",
+      "hugeint",
       "real",
       "double",
       "varchar",
@@ -1138,7 +1205,18 @@ exec::AggregateRegistrationResult registerMinMaxBy(const std::string& name) {
                              .argumentType("bigint")
                              .build());
   }
-
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .typeVariable("V")
+          .returnType("array(V)")
+          .intermediateType(
+              "row(bigint,array(DECIMAL(a_precision, a_scale)),array(V))")
+          .argumentType("V")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .argumentType("bigint")
+          .build());
   return exec::registerAggregateFunction(
       name,
       std::move(signatures),
@@ -1148,7 +1226,6 @@ exec::AggregateRegistrationResult registerMinMaxBy(const std::string& name) {
           const TypePtr& resultType,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
-        const auto isRawInput = exec::isRawInput(step);
         const std::string errorMessage = fmt::format(
             "Unknown input types for {} ({}) aggregation: {}",
             name,
@@ -1159,42 +1236,27 @@ exec::AggregateRegistrationResult registerMinMaxBy(const std::string& name) {
             (argTypes.size() == 1 && argTypes[0]->size() == 3);
 
         if (nAgg) {
-          if (isRawInput) {
-            // Input is: V, C, BIGINT.
-            return createNArg<NAggregate>(
-                resultType, argTypes[0], argTypes[1], errorMessage);
-          } else {
-            // Input is: ROW(BIGINT, ARRAY(C), ARRAY(V)).
-            const auto& rowType = argTypes[0];
-            const auto& compareType = rowType->childAt(1)->childAt(0);
-            const auto& valueType = rowType->childAt(2)->childAt(0);
-            return createNArg<NAggregate>(
-                resultType, valueType, compareType, errorMessage);
-          }
+          return createNArg<NAggregate>(
+              resultType, argTypes[0], argTypes[1], errorMessage);
         } else {
-          if (isRawInput) {
-            // Input is: V, C.
-            return create<Aggregate, Comparator, isMaxFunc>(
-                resultType, argTypes[0], argTypes[1], errorMessage);
-          } else {
-            // Input is: ROW(V, C).
-            const auto& rowType = argTypes[0];
-            const auto& valueType = rowType->childAt(0);
-            const auto& compareType = rowType->childAt(1);
-            return create<Aggregate, Comparator, isMaxFunc>(
-                resultType, valueType, compareType, errorMessage);
-          }
+          return create<Aggregate, Comparator, isMaxFunc>(
+              resultType, argTypes[0], argTypes[1], errorMessage, true);
         }
-      });
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace
 
-void registerMinMaxByAggregates(const std::string& prefix) {
+void registerMinMaxByAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   registerMinMaxBy<MinMaxByAggregateBase, true, MaxByNAggregate>(
-      prefix + kMaxBy);
+      prefix + kMaxBy, withCompanionFunctions, overwrite);
   registerMinMaxBy<MinMaxByAggregateBase, false, MinByNAggregate>(
-      prefix + kMinBy);
+      prefix + kMinBy, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp b/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
index 622edc9854f98..68eac78ac8b2f 100644
--- a/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
@@ -13,10 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/exec/AddressableNonNullValueList.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/Strings.h"
+#include "velox/functions/lib/aggregates/ValueList.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/functions/prestosql/aggregates/ValueList.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::aggregate::prestosql {
@@ -42,6 +44,17 @@ struct MultiMapAccumulator {
       : keys{AlignedStlAllocator<std::pair<const K, ValueList>, 16>(
             allocator)} {}
 
+  MultiMapAccumulator(
+      Hash hash,
+      EqualTo equalTo,
+      HashStringAllocator* allocator)
+      : keys{
+            0, // initialCapacity
+            hash,
+            equalTo,
+            AlignedStlAllocator<std::pair<const K, ValueList>, 16>(
+                allocator)} {}
+
   size_t size() const {
     return keys.size();
   }
@@ -124,13 +137,132 @@ struct MultiMapAccumulator {
   }
 };
 
+struct ComplexTypeMultiMapAccumulator {
+  MultiMapAccumulator<
+      AddressableNonNullValueList::Entry,
+      AddressableNonNullValueList::Hash,
+      AddressableNonNullValueList::EqualTo>
+      base;
+
+  /// Stores unique non-null keys.
+  AddressableNonNullValueList serializedKeys;
+
+  ComplexTypeMultiMapAccumulator(
+      const TypePtr& type,
+      HashStringAllocator* allocator)
+      : base{
+            AddressableNonNullValueList::Hash{},
+            AddressableNonNullValueList::EqualTo{type},
+            allocator} {}
+
+  size_t size() const {
+    return base.size();
+  }
+
+  size_t numValues() const {
+    return base.numValues();
+  }
+
+  /// Adds key-value pair.
+  void insert(
+      const DecodedVector& decodedKeys,
+      const DecodedVector& decodedValues,
+      vector_size_t index,
+      HashStringAllocator& allocator) {
+    const auto entry = serializedKeys.append(decodedKeys, index, &allocator);
+
+    auto& values = insertKey(entry);
+    values.appendValue(decodedValues, index, &allocator);
+  }
+
+  /// Adds a key with a list of values.
+  void insertMultiple(
+      const DecodedVector& decodedKeys,
+      vector_size_t keyIndex,
+      const DecodedVector& decodedValues,
+      vector_size_t valueIndex,
+      vector_size_t numValues,
+      HashStringAllocator& allocator) {
+    const auto entry = serializedKeys.append(decodedKeys, keyIndex, &allocator);
+
+    auto& values = insertKey(entry);
+    for (auto i = 0; i < numValues; ++i) {
+      values.appendValue(decodedValues, valueIndex + i, &allocator);
+    }
+  }
+
+  ValueList& insertKey(const AddressableNonNullValueList::Entry& key) {
+    auto result = base.keys.insert({key, ValueList()});
+    if (!result.second) {
+      serializedKeys.removeLast(key);
+    }
+
+    return result.first->second;
+  }
+
+  void extract(
+      VectorPtr& mapKeys,
+      ArrayVector& mapValueArrays,
+      vector_size_t& keyOffset,
+      vector_size_t& valueOffset) {
+    auto& mapValues = mapValueArrays.elements();
+
+    for (auto& entry : base.keys) {
+      AddressableNonNullValueList::read(entry.first, *mapKeys, keyOffset);
+
+      const auto numValues = entry.second.size();
+      mapValueArrays.setOffsetAndSize(keyOffset, valueOffset, numValues);
+
+      aggregate::ValueListReader reader(entry.second);
+      for (auto i = 0; i < numValues; i++) {
+        reader.next(*mapValues, valueOffset++);
+      }
+
+      ++keyOffset;
+    }
+  }
+
+  void free(HashStringAllocator& allocator) {
+    base.free(allocator);
+    serializedKeys.free(allocator);
+  }
+};
+
+template <typename T>
+struct MultiMapAccumulatorTypeTraits {
+  using AccumulatorType = MultiMapAccumulator<T>;
+};
+
+// Ensure Accumulator treats NaNs as equal.
+template <>
+struct MultiMapAccumulatorTypeTraits<float> {
+  using AccumulatorType = MultiMapAccumulator<
+      float,
+      util::floating_point::NaNAwareHash<float>,
+      util::floating_point::NaNAwareEquals<float>>;
+};
+
+template <>
+struct MultiMapAccumulatorTypeTraits<double> {
+  using AccumulatorType = MultiMapAccumulator<
+      double,
+      util::floating_point::NaNAwareHash<double>,
+      util::floating_point::NaNAwareEquals<double>>;
+};
+
+template <>
+struct MultiMapAccumulatorTypeTraits<ComplexType> {
+  using AccumulatorType = ComplexTypeMultiMapAccumulator;
+};
+
 template <typename K>
 class MultiMapAggAggregate : public exec::Aggregate {
  public:
   explicit MultiMapAggAggregate(TypePtr resultType)
       : exec::Aggregate(std::move(resultType)) {}
 
-  using AccumulatorType = MultiMapAccumulator<K>;
+  using AccumulatorType =
+      typename MultiMapAccumulatorTypeTraits<K>::AccumulatorType;
 
   bool isFixedSize() const override {
     return false;
@@ -140,16 +272,6 @@ class MultiMapAggAggregate : public exec::Aggregate {
     return sizeof(AccumulatorType);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    const auto& type = resultType()->childAt(0);
-    for (auto index : indices) {
-      new (groups[index] + offset_) AccumulatorType(type, allocator_);
-    }
-    setAllNulls(groups, indices);
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -318,11 +440,24 @@ class MultiMapAggAggregate : public exec::Aggregate {
     extractValues(groups, numGroups, result);
   }
 
-  void destroy(folly::Range<char**> groups) override {
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    const auto& type = resultType()->childAt(0);
+    for (auto index : indices) {
+      new (groups[index] + offset_) AccumulatorType(type, allocator_);
+    }
+    setAllNulls(groups, indices);
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
     for (auto* group : groups) {
-      auto accumulator = value<AccumulatorType>(group);
-      accumulator->free(*allocator_);
-      destroyAccumulator<AccumulatorType>(group);
+      if (isInitialized(group)) {
+        auto accumulator = value<AccumulatorType>(group);
+        accumulator->free(*allocator_);
+        destroyAccumulator<AccumulatorType>(group);
+      }
     }
   }
 
@@ -361,35 +496,24 @@ class MultiMapAggAggregate : public exec::Aggregate {
   DecodedVector decodedValueArrays_;
 };
 
-exec::AggregateRegistrationResult registerMultiMapAgg(const std::string& name) {
-  static const std::vector<std::string> kSupportedKeyTypes = {
-      "boolean",
-      "tinyint",
-      "smallint",
-      "integer",
-      "bigint",
-      "real",
-      "double",
-      "timestamp",
-      "date",
-      "varbinary",
-      "varchar",
-      "unknown",
-  };
-
-  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  for (const auto& keyType : kSupportedKeyTypes) {
-    signatures.emplace_back(
-        exec::AggregateFunctionSignatureBuilder()
-            .typeVariable("V")
-            .returnType(fmt::format("map({},array(V))", keyType))
-            .intermediateType(fmt::format("map({},array(V))", keyType))
-            .argumentType(keyType)
-            .argumentType("V")
-            .build());
-  }
+} // namespace
 
-  return exec::registerAggregateFunction(
+void registerMultiMapAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("K")
+          .typeVariable("V")
+          .returnType("map(K,array(V))")
+          .intermediateType("map(K,array(V))")
+          .argumentType("K")
+          .argumentType("V")
+          .build()};
+
+  auto name = prefix + kMultiMapAgg;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -422,19 +546,22 @@ exec::AggregateRegistrationResult registerMultiMapAgg(const std::string& name) {
           case TypeKind::VARCHAR:
             return std::make_unique<MultiMapAggAggregate<StringView>>(
                 resultType);
+          case TypeKind::ARRAY:
+            [[fallthrough]];
+          case TypeKind::MAP:
+            [[fallthrough]];
+          case TypeKind::ROW:
+            return std::make_unique<MultiMapAggAggregate<ComplexType>>(
+                resultType);
           case TypeKind::UNKNOWN:
             return std::make_unique<MultiMapAggAggregate<int32_t>>(resultType);
           default:
             VELOX_UNREACHABLE(
                 "Unexpected type {}", mapTypeKindToName(typeKind));
         }
-      });
-}
-
-} // namespace
-
-void registerMultiMapAggAggregate(const std::string& prefix) {
-  registerMultiMapAgg(prefix + kMultiMapAgg);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/PrestoHasher.cpp b/velox/functions/prestosql/aggregates/PrestoHasher.cpp
index b3eac733521ac..abbcaca0ed281 100644
--- a/velox/functions/prestosql/aggregates/PrestoHasher.cpp
+++ b/velox/functions/prestosql/aggregates/PrestoHasher.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/functions/prestosql/aggregates/PrestoHasher.h"
 
+#include <type_traits>
+
 #define XXH_INLINE_ALL
 #include <xxhash.h>
 
@@ -42,7 +44,7 @@ FOLLY_ALWAYS_INLINE void applyHashFunction(
     const DecodedVector& vector,
     BufferPtr& hashes,
     Callable func) {
-  VELOX_CHECK_GE(hashes->size(), rows.end())
+  VELOX_CHECK_GE(hashes->size(), rows.end());
   auto rawHashes = hashes->asMutable<int64_t>();
 
   rows.applyToSelected([&](auto row) {
@@ -64,6 +66,34 @@ FOLLY_ALWAYS_INLINE void hashIntegral(
   });
 }
 
+template <
+    typename T,
+    typename std::enable_if_t<
+        std::is_same_v<T, float> || std::is_same_v<T, double>,
+        int> = 0>
+FOLLY_ALWAYS_INLINE void hashFloating(
+    const DecodedVector& vector,
+    const SelectivityVector& rows,
+    BufferPtr& hashes) {
+  using IntegralType =
+      std::conditional_t<std::is_same_v<T, float>, int32_t, int64_t>;
+  applyHashFunction(rows, vector, hashes, [&](auto row) {
+    auto value = vector.valueAt<T>(row);
+    if (std::isnan(value)) {
+      if constexpr (std::is_same_v<T, float>) {
+        return hashInteger<IntegralType>(0x7fc00000);
+      } else {
+        return hashInteger<IntegralType>(0x7ff8000000000000L);
+      }
+    } else if (value == (T{})) {
+      // If -0.0 treat it same as 0
+      return hashInteger<IntegralType>(0);
+    } else {
+      return hashInteger<IntegralType>(vector.valueAt<IntegralType>(row));
+    }
+  });
+}
+
 #if defined(__clang__)
 __attribute__((no_sanitize("integer")))
 #endif
@@ -99,12 +129,60 @@ FOLLY_ALWAYS_INLINE void PrestoHasher::hash<TypeKind::BOOLEAN>(
   });
 }
 
+template <>
+FOLLY_ALWAYS_INLINE void PrestoHasher::hash<TypeKind::BIGINT>(
+    const SelectivityVector& rows,
+    BufferPtr& hashes) {
+  if (vector_->base()->type()->isShortDecimal()) {
+    applyHashFunction(rows, *vector_.get(), hashes, [&](auto row) {
+      // The Presto java ShortDecimal hash implementation
+      // returns the corresponding value directly.
+      return vector_->valueAt<int64_t>(row);
+    });
+  } else if (isTimestampWithTimeZoneType(vector_->base()->type())) {
+    // Hash only timestamp value.
+    applyHashFunction(rows, *vector_.get(), hashes, [&](auto row) {
+      return hashInteger(unpackMillisUtc(vector_->valueAt<int64_t>(row)));
+    });
+  } else {
+    applyHashFunction(rows, *vector_.get(), hashes, [&](auto row) {
+      return hashInteger(vector_->valueAt<int64_t>(row));
+    });
+  }
+}
+
+FOLLY_ALWAYS_INLINE uint64_t updateTail(uint64_t hash, uint64_t value) {
+  auto mix = XXH_rotl64(value * XXH_PRIME64_2, 31) * XXH_PRIME64_1;
+  auto temp = hash ^ mix;
+  return XXH_rotl64(temp, 27) * XXH_PRIME64_1 + XXH_PRIME64_4;
+}
+
+FOLLY_ALWAYS_INLINE uint64_t hashLongDecimalPart(const uint64_t value) {
+  auto hash = XXH_PRIME64_5 + sizeof(uint64_t);
+  hash = updateTail(hash, value);
+  hash = XXH64_avalanche(hash);
+  return hash;
+}
+
+// The implementation of Presto LongDecimal hash can be found in
+// https://github.com/prestodb/presto/blob/master/presto-common/src/main/java/com/facebook/presto/common/type/LongDecimalType.java#L91-L96.
 template <>
 FOLLY_ALWAYS_INLINE void PrestoHasher::hash<TypeKind::HUGEINT>(
     const SelectivityVector& rows,
     BufferPtr& hashes) {
   applyHashFunction(rows, *vector_.get(), hashes, [&](auto row) {
-    return hashInteger(vector_->valueAt<int128_t>(row));
+    auto value = vector_->valueAt<int128_t>(row);
+    // Presto Java UnscaledDecimal128 representation uses signed magnitude
+    // representation. Only negative values differ in this representation.
+    // The processing here is mainly for the convenience of hash computation.
+    if (value < 0) {
+      value *= -1;
+      value |= DecimalUtil::kInt128Mask;
+    }
+    auto lower = HugeInt::lower(value);
+    auto high = HugeInt::upper(value);
+    return hashLongDecimalPart(lower) ^
+        hashLongDecimalPart(high & DecimalUtil::kInt64Mask);
   });
 }
 
@@ -112,7 +190,7 @@ template <>
 FOLLY_ALWAYS_INLINE void PrestoHasher::hash<TypeKind::REAL>(
     const SelectivityVector& rows,
     BufferPtr& hashes) {
-  hashIntegral<int32_t>(*vector_.get(), rows, hashes);
+  hashFloating<float>(*vector_.get(), rows, hashes);
 }
 
 template <>
@@ -137,7 +215,7 @@ template <>
 FOLLY_ALWAYS_INLINE void PrestoHasher::hash<TypeKind::DOUBLE>(
     const SelectivityVector& rows,
     BufferPtr& hashes) {
-  hashIntegral<int64_t>(*vector_.get(), rows, hashes);
+  hashFloating<double>(*vector_.get(), rows, hashes);
 }
 
 template <>
@@ -155,8 +233,14 @@ void PrestoHasher::hash<TypeKind::ARRAY>(
     BufferPtr& hashes) {
   auto baseArray = vector_->base()->as<ArrayVector>();
   auto indices = vector_->indices();
+
+  auto nonNullRows = SelectivityVector(rows);
+  if (vector_->nulls(&nonNullRows)) {
+    nonNullRows.deselectNulls(vector_->nulls(), 0, nonNullRows.end());
+  }
+
   auto elementRows = functions::toElementRows(
-      baseArray->elements()->size(), rows, baseArray, indices);
+      baseArray->elements()->size(), nonNullRows, baseArray, indices);
 
   BufferPtr elementHashes =
       AlignedBuffer::allocate<int64_t>(elementRows.end(), baseArray->pool());
@@ -165,13 +249,13 @@ void PrestoHasher::hash<TypeKind::ARRAY>(
 
   auto rawSizes = baseArray->rawSizes();
   auto rawOffsets = baseArray->rawOffsets();
-  auto rawNulls = baseArray->rawNulls();
   auto rawElementHashes = elementHashes->as<int64_t>();
   auto rawHashes = hashes->asMutable<int64_t>();
+  auto decodedNulls = vector_->nulls();
 
   rows.applyToSelected([&](auto row) {
     int64_t hash = 0;
-    if (!(rawNulls && bits::isBitNull(rawNulls, indices[row]))) {
+    if (!((decodedNulls && bits::isBitNull(decodedNulls, row)))) {
       auto size = rawSizes[indices[row]];
       auto offset = rawOffsets[indices[row]];
 
@@ -189,10 +273,15 @@ void PrestoHasher::hash<TypeKind::MAP>(
     BufferPtr& hashes) {
   auto baseMap = vector_->base()->as<MapVector>();
   auto indices = vector_->indices();
-  VELOX_CHECK_EQ(children_.size(), 2)
+  VELOX_CHECK_EQ(children_.size(), 2);
+
+  auto nonNullRows = SelectivityVector(rows);
+  if (vector_->nulls(&nonNullRows)) {
+    nonNullRows.deselectNulls(vector_->nulls(), 0, nonNullRows.end());
+  }
 
   auto elementRows = functions::toElementRows(
-      baseMap->mapKeys()->size(), rows, baseMap, indices);
+      baseMap->mapKeys()->size(), nonNullRows, baseMap, indices);
   BufferPtr keyHashes =
       AlignedBuffer::allocate<int64_t>(elementRows.end(), baseMap->pool());
 
@@ -208,11 +297,11 @@ void PrestoHasher::hash<TypeKind::MAP>(
 
   auto rawSizes = baseMap->rawSizes();
   auto rawOffsets = baseMap->rawOffsets();
-  auto rawNulls = baseMap->rawNulls();
+  auto decodedNulls = vector_->nulls();
 
   rows.applyToSelected([&](auto row) {
     int64_t hash = 0;
-    if (!(rawNulls && bits::isBitNull(rawNulls, indices[row]))) {
+    if (!((decodedNulls && bits::isBitNull(decodedNulls, row)))) {
       auto size = rawSizes[indices[row]];
       auto offset = rawOffsets[indices[row]];
 
@@ -250,24 +339,10 @@ void PrestoHasher::hash<TypeKind::ROW>(
 
   auto rawHashes = hashes->asMutable<int64_t>();
 
-  if (isTimestampWithTimeZoneType(vector_->base()->type())) {
-    // Hash only timestamp value.
-    children_[0]->hash(baseRow->childAt(0), elementRows, childHashes);
-    auto rawChildHashes = childHashes->as<int64_t>();
-    rows.applyToSelected([&](auto row) {
-      if (!baseRow->isNullAt(indices[row])) {
-        rawHashes[row] = rawChildHashes[indices[row]];
-      } else {
-        rawHashes[row] = 0;
-      }
-    });
-    return;
-  }
-
   BufferPtr combinedChildHashes =
       AlignedBuffer::allocate<int64_t>(elementRows.end(), baseRow->pool());
   auto* rawCombinedChildHashes = combinedChildHashes->asMutable<int64_t>();
-  std::fill_n(rawCombinedChildHashes, rows.end(), 1);
+  std::fill_n(rawCombinedChildHashes, elementRows.end(), 1);
 
   std::fill_n(rawHashes, rows.end(), 1);
 
@@ -298,7 +373,7 @@ void PrestoHasher::hash(
       *vector->type() == *type_,
       "Vector type: {} != initialized type: {}",
       vector->type()->toString(),
-      type_->toString())
+      type_->toString());
   vector_->decode(*vector, rows);
   auto kind = vector_->base()->typeKind();
   VELOX_DYNAMIC_TYPE_DISPATCH(hash, kind, rows, hashes);
diff --git a/velox/functions/prestosql/aggregates/ReduceAgg.cpp b/velox/functions/prestosql/aggregates/ReduceAgg.cpp
index 138c3d5e73d7f..7c7553ffd3e72 100644
--- a/velox/functions/prestosql/aggregates/ReduceAgg.cpp
+++ b/velox/functions/prestosql/aggregates/ReduceAgg.cpp
@@ -150,14 +150,6 @@ class ReduceAgg : public exec::Aggregate {
     return sizeof(ReduceAggAccumulator);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    for (auto i : indices) {
-      new (groups[i] + offset_) ReduceAggAccumulator();
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     VELOX_CHECK_NOT_NULL(result);
@@ -182,12 +174,6 @@ class ReduceAgg : public exec::Aggregate {
     extractValues(groups, numGroups, result);
   }
 
-  void destroy(folly::Range<char**> groups) override {
-    for (auto group : groups) {
-      value<ReduceAggAccumulator>(group)->destroy(allocator_);
-    }
-  }
-
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -298,7 +284,7 @@ class ReduceAgg : public exec::Aggregate {
     SelectivityVector remainingRows = rows;
     if (input->mayHaveNulls()) {
       DecodedVector decoded(*input, rows);
-      if (auto* rawNulls = decoded.nulls()) {
+      if (auto* rawNulls = decoded.nulls(&rows)) {
         remainingRows.deselectNulls(rawNulls, rows.begin(), rows.end());
       }
     }
@@ -325,6 +311,23 @@ class ReduceAgg : public exec::Aggregate {
     }
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto i : indices) {
+      new (groups[i] + offset_) ReduceAggAccumulator();
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        value<ReduceAggAccumulator>(group)->destroy(allocator_);
+      }
+    }
+  }
+
  private:
   RowVectorPtr makeLambdaInput(
       const RowTypePtr& type,
@@ -786,7 +789,10 @@ class ReduceAgg : public exec::Aggregate {
 
 } // namespace
 
-void registerReduceAgg(const std::string& prefix) {
+void registerReduceAgg(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .typeVariable("T")
@@ -810,7 +816,10 @@ void registerReduceAgg(const std::string& prefix) {
           const TypePtr& resultType,
           const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
         return std::make_unique<ReduceAgg>(resultType);
-      });
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp b/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
index ccd6aef9c3332..1aafe15371a89 100644
--- a/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
+++ b/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
@@ -14,71 +14,190 @@
  * limitations under the License.
  */
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/exec/Aggregate.h"
 
 namespace facebook::velox::aggregate::prestosql {
 
-extern void registerApproxDistinctAggregates(const std::string& prefix);
-extern void registerApproxMostFrequentAggregate(const std::string& prefix);
-extern void registerApproxPercentileAggregate(const std::string& prefix);
-extern void registerArbitraryAggregate(const std::string& prefix);
-extern void registerArrayAggregate(const std::string& prefix);
-extern void registerAverageAggregate(const std::string& prefix);
-extern void registerBitwiseAggregates(const std::string& prefix);
-extern void registerBitwiseXorAggregate(const std::string& prefix);
-extern void registerBoolAggregates(const std::string& prefix);
-extern void registerCentralMomentsAggregates(const std::string& prefix);
-extern void registerChecksumAggregate(const std::string& prefix);
-extern void registerCountAggregate(const std::string& prefix);
-extern void registerCountIfAggregate(const std::string& prefix);
-extern void registerCovarianceAggregates(const std::string& prefix);
-extern void registerEntropyAggregates(const std::string& prefix);
-extern void registerGeometricMeanAggregate(const std::string& prefix);
-extern void registerHistogramAggregate(const std::string& prefix);
-extern void registerMapAggAggregate(const std::string& prefix);
-extern void registerMapUnionAggregate(const std::string& prefix);
-extern void registerMapUnionSumAggregate(const std::string& prefix);
-extern void registerMaxDataSizeForStatsAggregate(const std::string& prefix);
-extern void registerMultiMapAggAggregate(const std::string& prefix);
-extern void registerSumDataSizeForStatsAggregate(const std::string& prefix);
-extern void registerMinMaxAggregates(const std::string& prefix);
-extern void registerMinMaxByAggregates(const std::string& prefix);
-extern void registerReduceAgg(const std::string& prefix);
-extern void registerSetAggAggregate(const std::string& prefix);
-extern void registerSetUnionAggregate(const std::string& prefix);
-extern void registerSumAggregate(const std::string& prefix);
-extern void registerVarianceAggregates(const std::string& prefix);
+extern void registerApproxMostFrequentAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerApproxPercentileAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerArbitraryAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerArrayAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerAverageAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerBitwiseXorAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
+    bool overwrite);
+extern void registerChecksumAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerCountAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerCountIfAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerEntropyAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerGeometricMeanAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerHistogramAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMapAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMapUnionAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMapUnionSumAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMaxDataSizeForStatsAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMultiMapAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerSumDataSizeForStatsAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerReduceAgg(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerSetAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerSetUnionAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
 
-void registerAllAggregateFunctions(const std::string& prefix) {
-  registerApproxDistinctAggregates(prefix);
-  registerApproxMostFrequentAggregate(prefix);
-  registerApproxPercentileAggregate(prefix);
-  registerArbitraryAggregate(prefix);
-  registerArrayAggregate(prefix);
-  registerAverageAggregate(prefix);
-  registerBitwiseAggregates(prefix);
-  registerBitwiseXorAggregate(prefix);
-  registerBoolAggregates(prefix);
-  registerCentralMomentsAggregates(prefix);
-  registerChecksumAggregate(prefix);
-  registerCountAggregate(prefix);
-  registerCountIfAggregate(prefix);
-  registerCovarianceAggregates(prefix);
-  registerEntropyAggregates(prefix);
-  registerGeometricMeanAggregate(prefix);
-  registerHistogramAggregate(prefix);
-  registerMapAggAggregate(prefix);
-  registerMapUnionAggregate(prefix);
-  registerMapUnionSumAggregate(prefix);
-  registerMaxDataSizeForStatsAggregate(prefix);
-  registerMultiMapAggAggregate(prefix);
-  registerSumDataSizeForStatsAggregate(prefix);
-  registerMinMaxAggregates(prefix);
-  registerMinMaxByAggregates(prefix);
-  registerReduceAgg(prefix);
-  registerSetAggAggregate(prefix);
-  registerSetUnionAggregate(prefix);
-  registerSumAggregate(prefix);
-  registerVarianceAggregates(prefix);
+extern void registerApproxDistinctAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerBitwiseAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
+    bool overwrite);
+extern void registerBoolAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerCentralMomentsAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerCovarianceAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMinMaxAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMinMaxByAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerSumAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerVarianceAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerAllAggregateFunctions(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool onlyPrestoSignatures,
+    bool overwrite) {
+  registerApproxDistinctAggregates(prefix, withCompanionFunctions, overwrite);
+  registerApproxMostFrequentAggregate(
+      prefix, withCompanionFunctions, overwrite);
+  registerApproxPercentileAggregate(prefix, withCompanionFunctions, overwrite);
+  registerArbitraryAggregate(prefix, withCompanionFunctions, overwrite);
+  registerArrayAggAggregate(prefix, withCompanionFunctions, overwrite);
+  registerAverageAggregate(prefix, withCompanionFunctions, overwrite);
+  registerBitwiseAggregates(
+      prefix, withCompanionFunctions, onlyPrestoSignatures, overwrite);
+  registerBitwiseXorAggregate(
+      prefix, withCompanionFunctions, onlyPrestoSignatures, overwrite);
+  registerBoolAggregates(prefix, withCompanionFunctions, overwrite);
+  registerCentralMomentsAggregates(prefix, withCompanionFunctions, overwrite);
+  registerChecksumAggregate(prefix, withCompanionFunctions, overwrite);
+  registerCountAggregate(prefix, withCompanionFunctions, overwrite);
+  registerCountIfAggregate(prefix, withCompanionFunctions, overwrite);
+  registerCovarianceAggregates(prefix, withCompanionFunctions, overwrite);
+  registerEntropyAggregate(prefix, withCompanionFunctions, overwrite);
+  registerGeometricMeanAggregate(prefix, withCompanionFunctions, overwrite);
+  registerHistogramAggregate(prefix, withCompanionFunctions, overwrite);
+  registerMapAggAggregate(prefix, withCompanionFunctions, overwrite);
+  registerMapUnionAggregate(prefix, withCompanionFunctions, overwrite);
+  registerMapUnionSumAggregate(prefix, withCompanionFunctions, overwrite);
+  registerMaxDataSizeForStatsAggregate(
+      prefix, withCompanionFunctions, overwrite);
+  registerMultiMapAggAggregate(prefix, withCompanionFunctions, overwrite);
+  registerSumDataSizeForStatsAggregate(
+      prefix, withCompanionFunctions, overwrite);
+  registerMinMaxAggregates(prefix, withCompanionFunctions, overwrite);
+  registerMinMaxByAggregates(prefix, withCompanionFunctions, overwrite);
+  registerReduceAgg(prefix, withCompanionFunctions, overwrite);
+  registerSetAggAggregate(prefix, withCompanionFunctions, overwrite);
+  registerSetUnionAggregate(prefix, withCompanionFunctions, overwrite);
+  registerSumAggregate(prefix, withCompanionFunctions, overwrite);
+  registerVarianceAggregates(prefix, withCompanionFunctions, overwrite);
+}
+
+extern void registerCountDistinctAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerInternalArrayAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+void registerInternalAggregateFunctions(const std::string& prefix) {
+  bool withCompanionFunctions = false;
+  bool overwrite = false;
+  registerCountDistinctAggregate(prefix, withCompanionFunctions, overwrite);
+  registerInternalArrayAggAggregate(prefix, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h b/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h
index e6a91e0676aa9..8fcd16f010ce8 100644
--- a/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h
+++ b/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h
@@ -19,6 +19,21 @@
 
 namespace facebook::velox::aggregate::prestosql {
 
-void registerAllAggregateFunctions(const std::string& prefix = "");
+/// Entery point to register aggregate functions.
+/// @param prefix Prefix for the aggregate functions.
+/// @param withCompanionFunctions Also register companion functions, defaults
+/// to true.
+/// @param onlyPrestoSignatures Register only function signatures
+/// that are compatible with Presto.
+void registerAllAggregateFunctions(
+    const std::string& prefix = "",
+    bool withCompanionFunctions = true,
+    bool onlyPrestoSignatures = false,
+    bool overwrite = true);
+
+/// Register internal aggregation functions only for testing. Internal
+/// aggregation functions are not registered with companion functions.
+/// @param prefix Prefix for the internal aggregate functions.
+void registerInternalAggregateFunctions(const std::string& prefix = "");
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SetAggregates.cpp b/velox/functions/prestosql/aggregates/SetAggregates.cpp
index 6032d03948858..f4998a91d88f5 100644
--- a/velox/functions/prestosql/aggregates/SetAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/SetAggregates.cpp
@@ -13,296 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/exec/Aggregate.h"
-#include "velox/exec/SetAccumulator.h"
+#include "velox/functions/lib/aggregates/SetBaseAggregate.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/functions/prestosql/aggregates/Compare.h"
-#include "velox/vector/FlatVector.h"
+
+using namespace facebook::velox::functions::aggregate;
 
 namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
-template <typename T>
-class SetBaseAggregate : public exec::Aggregate {
- public:
-  explicit SetBaseAggregate(const TypePtr& resultType)
-      : exec::Aggregate(resultType) {}
-
-  using AccumulatorType = SetAccumulator<T>;
-
-  int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(AccumulatorType);
-  }
-
-  bool isFixedSize() const override {
-    return false;
-  }
-
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    const auto& type = resultType()->childAt(0);
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) AccumulatorType(type, allocator_);
-    }
-  }
-
-  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    auto arrayVector = (*result)->as<ArrayVector>();
-    arrayVector->resize(numGroups);
-
-    auto* rawOffsets = arrayVector->offsets()->asMutable<vector_size_t>();
-    auto* rawSizes = arrayVector->sizes()->asMutable<vector_size_t>();
-
-    vector_size_t numValues = 0;
-    uint64_t* rawNulls = getRawNulls(arrayVector);
-    for (auto i = 0; i < numGroups; ++i) {
-      auto* group = groups[i];
-      if (isNull(group)) {
-        arrayVector->setNull(i, true);
-      } else {
-        clearNull(rawNulls, i);
-
-        const auto size = value(group)->size();
-
-        rawOffsets[i] = numValues;
-        rawSizes[i] = size;
-
-        numValues += size;
-      }
-    }
-
-    if constexpr (std::is_same_v<T, ComplexType>) {
-      auto values = arrayVector->elements();
-      values->resize(numValues);
-
-      vector_size_t offset = 0;
-      for (auto i = 0; i < numGroups; ++i) {
-        auto* group = groups[i];
-        if (!isNull(group)) {
-          offset += value(group)->extractValues(*values, offset);
-        }
-      }
-    } else {
-      auto values = arrayVector->elements()->as<FlatVector<T>>();
-      values->resize(numValues);
-
-      vector_size_t offset = 0;
-      for (auto i = 0; i < numGroups; ++i) {
-        auto* group = groups[i];
-        if (!isNull(group)) {
-          offset += value(group)->extractValues(*values, offset);
-        }
-      }
-    }
-  }
-
-  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    return extractValues(groups, numGroups, result);
-  }
-
-  void addIntermediateResults(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    addIntermediateResultsInt(groups, rows, args, false);
-  }
-
-  void addSingleGroupIntermediateResults(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    addSingleGroupIntermediateResultsInt(group, rows, args, false);
-  }
-
-  void destroy(folly::Range<char**> groups) override {
-    for (auto* group : groups) {
-      if (!isNull(group)) {
-        value(group)->free(*allocator_);
-      }
-    }
-  }
-
- protected:
-  inline AccumulatorType* value(char* group) {
-    return reinterpret_cast<AccumulatorType*>(group + Aggregate::offset_);
-  }
-
-  void addIntermediateResultsInt(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool clearNullForAllInputs) {
-    decoded_.decode(*args[0], rows);
-
-    auto baseArray = decoded_.base()->template as<ArrayVector>();
-    decodedElements_.decode(*baseArray->elements());
-
-    rows.applyToSelected([&](vector_size_t i) {
-      if (decoded_.isNullAt(i)) {
-        if (clearNullForAllInputs) {
-          clearNull(groups[i]);
-        }
-        return;
-      }
-
-      auto* group = groups[i];
-      clearNull(group);
-
-      auto tracker = trackRowSize(group);
-
-      auto decodedIndex = decoded_.index(i);
-      value(group)->addValues(
-          *baseArray, decodedIndex, decodedElements_, allocator_);
-    });
-  }
-
-  void addSingleGroupIntermediateResultsInt(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool clearNullForAllInputs) {
-    decoded_.decode(*args[0], rows);
-
-    auto baseArray = decoded_.base()->template as<ArrayVector>();
-
-    decodedElements_.decode(*baseArray->elements());
-
-    auto* accumulator = value(group);
-
-    auto tracker = trackRowSize(group);
-    rows.applyToSelected([&](vector_size_t i) {
-      if (decoded_.isNullAt(i)) {
-        if (clearNullForAllInputs) {
-          clearNull(group);
-        }
-        return;
-      }
-
-      clearNull(group);
-
-      auto decodedIndex = decoded_.index(i);
-      accumulator->addValues(
-          *baseArray, decodedIndex, decodedElements_, allocator_);
-    });
-  }
-
-  DecodedVector decoded_;
-  DecodedVector decodedElements_;
-};
-
-template <typename T>
-class SetAggAggregate : public SetBaseAggregate<T> {
- public:
-  explicit SetAggAggregate(
-      const TypePtr& resultType,
-      const bool throwOnNestedNulls = false)
-      : SetBaseAggregate<T>(resultType),
-        throwOnNestedNulls_(throwOnNestedNulls) {}
-
-  using Base = SetBaseAggregate<T>;
-
-  bool supportsToIntermediate() const override {
-    return true;
-  }
-
-  void toIntermediate(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      VectorPtr& result) const override {
-    const auto& elements = args[0];
-
-    if (throwOnNestedNulls_) {
-      DecodedVector decodedElements(*elements, rows);
-      auto indices = decodedElements.indices();
-      rows.applyToSelected([&](vector_size_t i) {
-        checkNestedNulls(decodedElements, indices, i, throwOnNestedNulls_);
-      });
-    }
-
-    const auto numRows = rows.size();
-
-    // Convert input to a single-entry array.
-
-    // Set nulls for rows not present in 'rows'.
-    auto* pool = Base::allocator_->pool();
-    BufferPtr nulls = allocateNulls(numRows, pool);
-    memcpy(
-        nulls->asMutable<uint64_t>(),
-        rows.asRange().bits(),
-        bits::nbytes(numRows));
-
-    // Set offsets to 0, 1, 2, 3...
-    BufferPtr offsets = allocateOffsets(numRows, pool);
-    auto* rawOffsets = offsets->asMutable<vector_size_t>();
-    std::iota(rawOffsets, rawOffsets + numRows, 0);
-
-    // Set sizes to 1.
-    BufferPtr sizes = allocateSizes(numRows, pool);
-    auto* rawSizes = sizes->asMutable<vector_size_t>();
-    std::fill(rawSizes, rawSizes + numRows, 1);
-
-    result = std::make_shared<ArrayVector>(
-        pool,
-        ARRAY(elements->type()),
-        nulls,
-        numRows,
-        offsets,
-        sizes,
-        BaseVector::loadedVectorShared(elements));
-  }
-
-  void addRawInput(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    Base::decoded_.decode(*args[0], rows);
-    auto indices = Base::decoded_.indices();
-    rows.applyToSelected([&](vector_size_t i) {
-      auto* group = groups[i];
-      Base::clearNull(group);
-
-      if (throwOnNestedNulls_) {
-        checkNestedNulls(Base::decoded_, indices, i, throwOnNestedNulls_);
-      }
-
-      auto tracker = Base::trackRowSize(group);
-      Base::value(group)->addValue(Base::decoded_, i, Base::allocator_);
-    });
-  }
-
-  void addSingleGroupRawInput(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool /*mayPushdown*/) override {
-    Base::decoded_.decode(*args[0], rows);
-
-    Base::clearNull(group);
-    auto* accumulator = Base::value(group);
-
-    auto tracker = Base::trackRowSize(group);
-    auto indices = Base::decoded_.indices();
-    rows.applyToSelected([&](vector_size_t i) {
-      if (throwOnNestedNulls_) {
-        checkNestedNulls(Base::decoded_, indices, i, throwOnNestedNulls_);
-      }
-
-      accumulator->addValue(Base::decoded_, i, Base::allocator_);
-    });
-  }
-
- private:
-  const bool throwOnNestedNulls_;
-};
-
 template <typename T>
 class SetUnionAggregate : public SetBaseAggregate<T> {
  public:
@@ -381,11 +100,67 @@ class SetUnionAggregate : public SetBaseAggregate<T> {
   }
 };
 
+/// Returns the number of distinct non-null values in a group. This is an
+/// internal function only used for testing.
+template <typename T>
+class CountDistinctAggregate : public SetAggAggregate<T, true, false> {
+ public:
+  explicit CountDistinctAggregate(
+      const TypePtr& resultType,
+      const TypePtr& inputType)
+      : SetAggAggregate<T, true, false>(resultType, false),
+        inputType_{inputType} {}
+
+  using Base = SetAggAggregate<T, true, false>;
+
+  bool supportsToIntermediate() const override {
+    return false;
+  }
+
+  void initializeNewGroups(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + Base::offset_)
+          SetAccumulator<T>(inputType_, Base::allocator_);
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    return Base::extractValues(groups, numGroups, result);
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto flatResult = (*result)->as<FlatVector<int64_t>>();
+    flatResult->resize(numGroups);
+
+    uint64_t* rawNulls = exec::Aggregate::getRawNulls(flatResult);
+    for (auto i = 0; i < numGroups; ++i) {
+      auto* group = groups[i];
+      if (Base::isNull(group)) {
+        Base::clearNull(rawNulls, i);
+        flatResult->set(i, 0);
+      } else {
+        Base::clearNull(rawNulls, i);
+
+        const auto size = Base::value(group)->size();
+        flatResult->set(i, size);
+      }
+    }
+  }
+
+ private:
+  TypePtr inputType_;
+};
+
 template <template <typename T> class Aggregate>
 std::unique_ptr<exec::Aggregate> create(
-    TypeKind typeKind,
+    const TypePtr& inputType,
     const TypePtr& resultType) {
-  switch (typeKind) {
+  switch (inputType->kind()) {
     case TypeKind::BOOLEAN:
       return std::make_unique<Aggregate<bool>>(resultType);
     case TypeKind::TINYINT:
@@ -396,6 +171,11 @@ std::unique_ptr<exec::Aggregate> create(
       return std::make_unique<Aggregate<int32_t>>(resultType);
     case TypeKind::BIGINT:
       return std::make_unique<Aggregate<int64_t>>(resultType);
+    case TypeKind::HUGEINT:
+      VELOX_CHECK(
+          inputType->isLongDecimal(),
+          "Non-decimal use of HUGEINT is not supported");
+      return std::make_unique<Aggregate<int128_t>>(resultType);
     case TypeKind::REAL:
       return std::make_unique<Aggregate<float>>(resultType);
     case TypeKind::DOUBLE:
@@ -413,11 +193,17 @@ std::unique_ptr<exec::Aggregate> create(
     case TypeKind::ROW:
       return std::make_unique<Aggregate<ComplexType>>(resultType);
     default:
-      VELOX_UNREACHABLE("Unexpected type {}", mapTypeKindToName(typeKind));
+      VELOX_UNREACHABLE(
+          "Unexpected type {}", mapTypeKindToName(inputType->kind()));
   }
 }
 
-exec::AggregateRegistrationResult registerSetAgg(const std::string& name) {
+} // namespace
+
+void registerSetAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
       exec::AggregateFunctionSignatureBuilder()
           .typeVariable("T")
@@ -426,7 +212,8 @@ exec::AggregateRegistrationResult registerSetAgg(const std::string& name) {
           .argumentType("T")
           .build()};
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kSetAgg;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -438,8 +225,9 @@ exec::AggregateRegistrationResult registerSetAgg(const std::string& name) {
         VELOX_CHECK_EQ(argTypes.size(), 1);
 
         const bool isRawInput = exec::isRawInput(step);
-        const TypeKind typeKind =
-            isRawInput ? argTypes[0]->kind() : argTypes[0]->childAt(0)->kind();
+        const TypePtr& inputType =
+            isRawInput ? argTypes[0] : argTypes[0]->childAt(0);
+        const TypeKind typeKind = inputType->kind();
         const bool throwOnNestedNulls = isRawInput;
 
         switch (typeKind) {
@@ -453,6 +241,11 @@ exec::AggregateRegistrationResult registerSetAgg(const std::string& name) {
             return std::make_unique<SetAggAggregate<int32_t>>(resultType);
           case TypeKind::BIGINT:
             return std::make_unique<SetAggAggregate<int64_t>>(resultType);
+          case TypeKind::HUGEINT:
+            VELOX_CHECK(
+                inputType->isLongDecimal(),
+                "Non-decimal use of HUGEINT is not supported");
+            return std::make_unique<SetAggAggregate<int128_t>>(resultType);
           case TypeKind::REAL:
             return std::make_unique<SetAggAggregate<float>>(resultType);
           case TypeKind::DOUBLE:
@@ -474,10 +267,15 @@ exec::AggregateRegistrationResult registerSetAgg(const std::string& name) {
             VELOX_UNREACHABLE(
                 "Unexpected type {}", mapTypeKindToName(typeKind));
         }
-      });
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
-exec::AggregateRegistrationResult registerSetUnion(const std::string& name) {
+void registerSetUnionAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
       exec::AggregateFunctionSignatureBuilder()
           .typeVariable("T")
@@ -486,7 +284,8 @@ exec::AggregateRegistrationResult registerSetUnion(const std::string& name) {
           .argumentType("array(T)")
           .build()};
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kSetUnion;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -497,20 +296,86 @@ exec::AggregateRegistrationResult registerSetUnion(const std::string& name) {
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_EQ(argTypes.size(), 1);
 
-        const TypeKind typeKind = argTypes[0]->childAt(0)->kind();
-
-        return create<SetUnionAggregate>(typeKind, resultType);
-      });
+        return create<SetUnionAggregate>(argTypes[0]->childAt(0), resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
-} // namespace
+void registerCountDistinctAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("array(T)")
+          .argumentType("T")
+          .build()};
 
-void registerSetAggAggregate(const std::string& prefix) {
-  registerSetAgg(prefix + kSetAgg);
-}
+  auto name = prefix + "$internal$count_distinct";
+  exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [](core::AggregationNode::Step step,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(argTypes.size(), 1);
 
-void registerSetUnionAggregate(const std::string& prefix) {
-  registerSetUnion(prefix + kSetUnion);
+        const bool isRawInput = exec::isRawInput(step);
+        const TypeKind typeKind =
+            isRawInput ? argTypes[0]->kind() : argTypes[0]->childAt(0)->kind();
+
+        switch (typeKind) {
+          case TypeKind::BOOLEAN:
+            return std::make_unique<CountDistinctAggregate<bool>>(
+                resultType, argTypes[0]);
+          case TypeKind::TINYINT:
+            return std::make_unique<CountDistinctAggregate<int8_t>>(
+                resultType, argTypes[0]);
+          case TypeKind::SMALLINT:
+            return std::make_unique<CountDistinctAggregate<int16_t>>(
+                resultType, argTypes[0]);
+          case TypeKind::INTEGER:
+            return std::make_unique<CountDistinctAggregate<int32_t>>(
+                resultType, argTypes[0]);
+          case TypeKind::BIGINT:
+            return std::make_unique<CountDistinctAggregate<int64_t>>(
+                resultType, argTypes[0]);
+          case TypeKind::HUGEINT:
+            return std::make_unique<CountDistinctAggregate<int128_t>>(
+                resultType, argTypes[0]);
+          case TypeKind::REAL:
+            return std::make_unique<CountDistinctAggregate<float>>(
+                resultType, argTypes[0]);
+          case TypeKind::DOUBLE:
+            return std::make_unique<CountDistinctAggregate<double>>(
+                resultType, argTypes[0]);
+          case TypeKind::TIMESTAMP:
+            return std::make_unique<CountDistinctAggregate<Timestamp>>(
+                resultType, argTypes[0]);
+          case TypeKind::VARBINARY:
+            [[fallthrough]];
+          case TypeKind::VARCHAR:
+            return std::make_unique<CountDistinctAggregate<StringView>>(
+                resultType, argTypes[0]);
+          case TypeKind::ARRAY:
+            [[fallthrough]];
+          case TypeKind::MAP:
+            [[fallthrough]];
+          case TypeKind::ROW:
+            return std::make_unique<CountDistinctAggregate<ComplexType>>(
+                resultType, argTypes[0]);
+          default:
+            VELOX_UNREACHABLE(
+                "Unexpected type {}", mapTypeKindToName(typeKind));
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SumAggregate.cpp b/velox/functions/prestosql/aggregates/SumAggregate.cpp
index 04c7b4e4d5fdc..0f6278e96a755 100644
--- a/velox/functions/prestosql/aggregates/SumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/SumAggregate.cpp
@@ -13,13 +13,114 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/functions/prestosql/aggregates/SumAggregate.h"
+#include "velox/functions/lib/aggregates/SumAggregateBase.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
+using namespace facebook::velox::functions::aggregate;
+
 namespace facebook::velox::aggregate::prestosql {
+namespace {
+template <typename TInput, typename TAccumulator, typename ResultType>
+using SumAggregate = SumAggregateBase<TInput, TAccumulator, ResultType, false>;
+
+template <template <typename U, typename V, typename W> class T>
+exec::AggregateRegistrationResult registerSum(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("real")
+          .intermediateType("double")
+          .argumentType("real")
+          .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("double")
+          .intermediateType("double")
+          .argumentType("double")
+          .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("VARBINARY")
+          .returnType("DECIMAL(38, a_scale)")
+          .build(),
+  };
+
+  for (const auto& inputType : {"tinyint", "smallint", "integer", "bigint"}) {
+    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
+                             .returnType("bigint")
+                             .intermediateType("bigint")
+                             .argumentType(inputType)
+                             .build());
+  }
+
+  return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes only one argument", name);
+        auto inputType = argTypes[0];
+        switch (inputType->kind()) {
+          case TypeKind::TINYINT:
+            return std::make_unique<T<int8_t, int64_t, int64_t>>(BIGINT());
+          case TypeKind::SMALLINT:
+            return std::make_unique<T<int16_t, int64_t, int64_t>>(BIGINT());
+          case TypeKind::INTEGER:
+            return std::make_unique<T<int32_t, int64_t, int64_t>>(BIGINT());
+          case TypeKind::BIGINT: {
+            if (inputType->isShortDecimal()) {
+              return std::make_unique<DecimalSumAggregate<int64_t>>(resultType);
+            }
+            return std::make_unique<T<int64_t, int64_t, int64_t>>(BIGINT());
+          }
+          case TypeKind::HUGEINT: {
+            if (inputType->isLongDecimal()) {
+              return std::make_unique<DecimalSumAggregate<int128_t>>(
+                  resultType);
+            }
+            VELOX_NYI();
+          }
+          case TypeKind::REAL:
+            if (resultType->kind() == TypeKind::REAL) {
+              return std::make_unique<T<float, double, float>>(resultType);
+            }
+            return std::make_unique<T<float, double, double>>(DOUBLE());
+          case TypeKind::DOUBLE:
+            if (resultType->kind() == TypeKind::REAL) {
+              return std::make_unique<T<double, double, float>>(resultType);
+            }
+            return std::make_unique<T<double, double, double>>(DOUBLE());
+          case TypeKind::VARBINARY:
+            // Always use int128_t template for Varbinary as the result
+            // type is either int128_t or
+            // UnscaledLongDecimalWithOverflowState.
+            return std::make_unique<DecimalSumAggregate<int128_t>>(resultType);
+
+          default:
+            VELOX_UNREACHABLE(
+                "Unknown input type for {} aggregation {}",
+                name,
+                inputType->kindName());
+        }
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
+}
+} // namespace
 
-void registerSumAggregate(const std::string& prefix) {
-  registerSum<SumAggregate>(prefix + kSum);
+void registerSumAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerSum<SumAggregate>(prefix + kSum, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SumAggregate.h b/velox/functions/prestosql/aggregates/SumAggregate.h
deleted file mode 100644
index 33273390a0d7a..0000000000000
--- a/velox/functions/prestosql/aggregates/SumAggregate.h
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "velox/expression/FunctionSignature.h"
-#include "velox/functions/lib/aggregates/DecimalAggregate.h"
-#include "velox/functions/lib/aggregates/SimpleNumericAggregate.h"
-#include "velox/functions/prestosql/CheckedArithmeticImpl.h"
-
-using namespace facebook::velox::functions::aggregate;
-
-namespace facebook::velox::aggregate::prestosql {
-
-template <typename TInput, typename TAccumulator, typename ResultType>
-class SumAggregate
-    : public SimpleNumericAggregate<TInput, TAccumulator, ResultType> {
-  using BaseAggregate =
-      SimpleNumericAggregate<TInput, TAccumulator, ResultType>;
-
- public:
-  explicit SumAggregate(TypePtr resultType) : BaseAggregate(resultType) {}
-
-  int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(TAccumulator);
-  }
-
-  int32_t accumulatorAlignmentSize() const override {
-    return 1;
-  }
-
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto i : indices) {
-      *exec::Aggregate::value<TAccumulator>(groups[i]) = 0;
-    }
-  }
-
-  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    BaseAggregate::template doExtractValues<ResultType>(
-        groups, numGroups, result, [&](char* group) {
-          // 'ResultType' and 'TAccumulator' might not be same such as sum(real)
-          // and we do an explicit type conversion here.
-          return (ResultType)(*BaseAggregate::Aggregate::template value<
-                              TAccumulator>(group));
-        });
-  }
-
-  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
-      override {
-    BaseAggregate::template doExtractValues<TAccumulator>(
-        groups, numGroups, result, [&](char* group) {
-          return *BaseAggregate::Aggregate::template value<TAccumulator>(group);
-        });
-  }
-
-  void addRawInput(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    updateInternal<TAccumulator>(groups, rows, args, mayPushdown);
-  }
-
-  void addIntermediateResults(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    updateInternal<TAccumulator, TAccumulator>(groups, rows, args, mayPushdown);
-  }
-
-  void addSingleGroupRawInput(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    BaseAggregate::template updateOneGroup<TAccumulator>(
-        group,
-        rows,
-        args[0],
-        &updateSingleValue<TAccumulator>,
-        &updateDuplicateValues<TAccumulator>,
-        mayPushdown,
-        TAccumulator(0));
-  }
-
-  void addSingleGroupIntermediateResults(
-      char* group,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) override {
-    BaseAggregate::template updateOneGroup<TAccumulator, TAccumulator>(
-        group,
-        rows,
-        args[0],
-        &updateSingleValue<TAccumulator>,
-        &updateDuplicateValues<TAccumulator>,
-        mayPushdown,
-        TAccumulator(0));
-  }
-
- protected:
-  // TData is used to store the updated sum state. It can be either
-  // TAccumulator or TResult, which in most cases are the same, but for
-  // sum(real) can differ. TValue is used to decode the sum input 'args'.
-  // It can be either TAccumulator or TInput, which is most cases are the same
-  // but for sum(real) can differ.
-  template <typename TData, typename TValue = TInput>
-  void updateInternal(
-      char** groups,
-      const SelectivityVector& rows,
-      const std::vector<VectorPtr>& args,
-      bool mayPushdown) {
-    const auto& arg = args[0];
-
-    if (mayPushdown && arg->isLazy()) {
-      BaseAggregate::template pushdown<SumHook<TValue, TData>>(
-          groups, rows, arg);
-      return;
-    }
-
-    if (exec::Aggregate::numNulls_) {
-      BaseAggregate::template updateGroups<true, TData, TValue>(
-          groups, rows, arg, &updateSingleValue<TData>, false);
-    } else {
-      BaseAggregate::template updateGroups<false, TData, TValue>(
-          groups, rows, arg, &updateSingleValue<TData>, false);
-    }
-  }
-
- private:
-  /// Update functions that check for overflows for integer types.
-  /// For floating points, an overflow results in +/- infinity which is a
-  /// valid output.
-  template <typename TData>
-  static void updateSingleValue(TData& result, TData value) {
-    if constexpr (
-        std::is_same_v<TData, double> || std::is_same_v<TData, float>) {
-      result += value;
-    } else {
-      result = functions::checkedPlus<TData>(result, value);
-    }
-  }
-
-  template <typename TData>
-  static void updateDuplicateValues(TData& result, TData value, int n) {
-    if constexpr (
-        std::is_same_v<TData, double> || std::is_same_v<TData, float>) {
-      result += n * value;
-    } else {
-      result = functions::checkedPlus<TData>(
-          result, functions::checkedMultiply<TData>(TData(n), value));
-    }
-  }
-};
-
-template <typename TInputType>
-class DecimalSumAggregate
-    : public functions::aggregate::DecimalAggregate<int128_t, TInputType> {
- public:
-  explicit DecimalSumAggregate(TypePtr resultType)
-      : functions::aggregate::DecimalAggregate<int128_t, TInputType>(
-            resultType) {}
-
-  virtual int128_t computeFinalValue(
-      functions::aggregate::LongDecimalWithOverflowState* accumulator) final {
-    // Value is valid if the conditions below are true.
-    int128_t sum = accumulator->sum;
-    if ((accumulator->overflow == 1 && accumulator->sum < 0) ||
-        (accumulator->overflow == -1 && accumulator->sum > 0)) {
-      sum = static_cast<int128_t>(
-          DecimalUtil::kOverflowMultiplier * accumulator->overflow +
-          accumulator->sum);
-    } else {
-      VELOX_CHECK(accumulator->overflow == 0, "Decimal overflow");
-    }
-
-    DecimalUtil::valueInRange(sum);
-    return sum;
-  }
-};
-
-template <template <typename U, typename V, typename W> class T>
-exec::AggregateRegistrationResult registerSum(const std::string& name) {
-  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
-      exec::AggregateFunctionSignatureBuilder()
-          .returnType("real")
-          .intermediateType("double")
-          .argumentType("real")
-          .build(),
-      exec::AggregateFunctionSignatureBuilder()
-          .returnType("double")
-          .intermediateType("double")
-          .argumentType("double")
-          .build(),
-      exec::AggregateFunctionSignatureBuilder()
-          .integerVariable("a_precision")
-          .integerVariable("a_scale")
-          .argumentType("DECIMAL(a_precision, a_scale)")
-          .intermediateType("VARBINARY")
-          .returnType("DECIMAL(38, a_scale)")
-          .build(),
-  };
-
-  for (const auto& inputType : {"tinyint", "smallint", "integer", "bigint"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("bigint")
-                             .intermediateType("bigint")
-                             .argumentType(inputType)
-                             .build());
-  }
-
-  return exec::registerAggregateFunction(
-      name,
-      std::move(signatures),
-      [name](
-          core::AggregationNode::Step step,
-          const std::vector<TypePtr>& argTypes,
-          const TypePtr& resultType,
-          const core::QueryConfig& /*config*/)
-          -> std::unique_ptr<exec::Aggregate> {
-        VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes only one argument", name);
-        auto inputType = argTypes[0];
-        switch (inputType->kind()) {
-          case TypeKind::TINYINT:
-            return std::make_unique<T<int8_t, int64_t, int64_t>>(BIGINT());
-          case TypeKind::SMALLINT:
-            return std::make_unique<T<int16_t, int64_t, int64_t>>(BIGINT());
-          case TypeKind::INTEGER:
-            return std::make_unique<T<int32_t, int64_t, int64_t>>(BIGINT());
-          case TypeKind::BIGINT: {
-            if (inputType->isShortDecimal()) {
-              return std::make_unique<DecimalSumAggregate<int64_t>>(resultType);
-            }
-            return std::make_unique<T<int64_t, int64_t, int64_t>>(BIGINT());
-          }
-          case TypeKind::HUGEINT: {
-            if (inputType->isLongDecimal()) {
-              return std::make_unique<DecimalSumAggregate<int128_t>>(
-                  resultType);
-            }
-            VELOX_NYI();
-          }
-          case TypeKind::REAL:
-            if (resultType->kind() == TypeKind::REAL) {
-              return std::make_unique<T<float, double, float>>(resultType);
-            }
-            return std::make_unique<T<float, double, double>>(DOUBLE());
-          case TypeKind::DOUBLE:
-            if (resultType->kind() == TypeKind::REAL) {
-              return std::make_unique<T<double, double, float>>(resultType);
-            }
-            return std::make_unique<T<double, double, double>>(DOUBLE());
-          case TypeKind::VARBINARY:
-            // Always use int128_t template for Varbinary as the result
-            // type is either int128_t or
-            // UnscaledLongDecimalWithOverflowState.
-            return std::make_unique<DecimalSumAggregate<int128_t>>(resultType);
-
-          default:
-            VELOX_CHECK(
-                false,
-                "Unknown input type for {} aggregation {}",
-                name,
-                inputType->kindName());
-        }
-      });
-}
-
-} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp b/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
index af910db608274..8f97bcfdbc5f4 100644
--- a/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
@@ -48,15 +48,6 @@ class SumDataSizeForStatsAggregate
     });
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    exec::Aggregate::setAllNulls(groups, indices);
-    for (auto index : indices) {
-      *BaseAggregate ::value<int64_t>(groups[index]) = 0;
-    }
-  }
-
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     // Partial and final aggregations are the same.
@@ -155,7 +146,7 @@ class SumDataSizeForStatsAggregate
     });
 
     getVectorSerde()->estimateSerializedSize(
-        vector,
+        vector.get(),
         folly::Range(rowIndices_.data(), rowIndices_.size()),
         rowSizePtrs_.data());
   }
@@ -172,6 +163,15 @@ class SumDataSizeForStatsAggregate
     });
   }
 
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    exec::Aggregate::setAllNulls(groups, indices);
+    for (auto index : indices) {
+      *BaseAggregate ::value<int64_t>(groups[index]) = 0;
+    }
+  }
+
  private:
   using BaseAggregate = SimpleNumericAggregate<int64_t, int64_t, int64_t>;
 
@@ -182,18 +182,23 @@ class SumDataSizeForStatsAggregate
   std::vector<IndexRange> rowIndices_;
 };
 
-exec::AggregateRegistrationResult registerSumDataSizeForStats(
-    const std::string& name) {
+} // namespace
+
+void registerSumDataSizeForStatsAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   signatures.push_back(exec::AggregateFunctionSignatureBuilder()
                            .typeVariable("T")
-                           .returnType("BIGINT")
-                           .intermediateType("BIGINT")
+                           .returnType("bigint")
+                           .intermediateType("bigint")
                            .argumentType("T")
                            .build());
 
-  return exec::registerAggregateFunction(
+  auto name = prefix + kSumDataSizeForStats;
+  exec::registerAggregateFunction(
       name,
       std::move(signatures),
       [name](
@@ -206,13 +211,9 @@ exec::AggregateRegistrationResult registerSumDataSizeForStats(
         auto inputType = argTypes[0];
 
         return std::make_unique<SumDataSizeForStatsAggregate>(resultType);
-      });
-}
-
-} // namespace
-
-void registerSumDataSizeForStatsAggregate(const std::string& prefix) {
-  registerSumDataSizeForStats(prefix + kSumDataSizeForStats);
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/VarianceAggregates.cpp b/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
index 4e0eb2c6ae68d..c91e801930cfd 100644
--- a/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
@@ -38,7 +38,7 @@ struct VarianceAccumulator {
   VarianceAccumulator(int64_t count, double value)
       : count_(count), mean_(value), m2_(0.0) {}
 
-  double count() const {
+  int64_t count() const {
     return count_;
   }
 
@@ -65,6 +65,12 @@ struct VarianceAccumulator {
     if (countOther == 0) {
       return;
     }
+    if (count_ == 0) {
+      count_ = countOther;
+      mean_ = meanOther;
+      m2_ = m2Other;
+      return;
+    }
     int64_t newCount = countOther + count();
     double delta = meanOther - mean();
     double newMean = mean() + delta / newCount * countOther;
@@ -140,15 +146,6 @@ class VarianceAggregate : public exec::Aggregate {
     return sizeof(VarianceAccumulator);
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) VarianceAccumulator();
-    }
-  }
-
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     auto rowVector = (*result)->as<RowVector>();
@@ -370,6 +367,15 @@ class VarianceAggregate : public exec::Aggregate {
     return exec::Aggregate::value<VarianceAccumulator>(group);
   }
 
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) VarianceAccumulator();
+    }
+  }
+
  private:
   // partial
   template <bool tableHasNulls = true>
@@ -459,7 +465,10 @@ void checkSumCountRowType(
 }
 
 template <template <typename TInput> class TClass>
-exec::AggregateRegistrationResult registerVariance(const std::string& name) {
+exec::AggregateRegistrationResult registerVariance(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   std::vector<std::string> inputTypes = {
       "smallint", "integer", "bigint", "real", "double"};
@@ -508,18 +517,29 @@ exec::AggregateRegistrationResult registerVariance(const std::string& name) {
               "(count:bigint, mean:double, m2:double) struct");
           return std::make_unique<TClass<int64_t>>(resultType);
         }
-      });
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace
 
-void registerVarianceAggregates(const std::string& prefix) {
-  registerVariance<StdDevSampAggregate>(prefix + kStdDev);
-  registerVariance<StdDevPopAggregate>(prefix + kStdDevPop);
-  registerVariance<StdDevSampAggregate>(prefix + kStdDevSamp);
-  registerVariance<VarSampAggregate>(prefix + kVariance);
-  registerVariance<VarPopAggregate>(prefix + kVarPop);
-  registerVariance<VarSampAggregate>(prefix + kVarSamp);
+void registerVarianceAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerVariance<StdDevSampAggregate>(
+      prefix + kStdDev, withCompanionFunctions, overwrite);
+  registerVariance<StdDevPopAggregate>(
+      prefix + kStdDevPop, withCompanionFunctions, overwrite);
+  registerVariance<StdDevSampAggregate>(
+      prefix + kStdDevSamp, withCompanionFunctions, overwrite);
+  registerVariance<VarSampAggregate>(
+      prefix + kVariance, withCompanionFunctions, overwrite);
+  registerVariance<VarPopAggregate>(
+      prefix + kVarPop, withCompanionFunctions, overwrite);
+  registerVariance<VarSampAggregate>(
+      prefix + kVarSamp, withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/benchmarks/CMakeLists.txt b/velox/functions/prestosql/aggregates/benchmarks/CMakeLists.txt
index 92b0ec8d9663d..58cb40540b43c 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/CMakeLists.txt
+++ b/velox/functions/prestosql/aggregates/benchmarks/CMakeLists.txt
@@ -27,6 +27,22 @@ target_link_libraries(
   ${FOLLY_BENCHMARK}
   gflags::gflags)
 
+add_executable(velox_aggregates_string_keys_bm TwoStringKeys.cpp)
+
+target_link_libraries(
+  velox_aggregates_string_keys_bm
+  velox_aggregates
+  velox_hive_connector
+  velox_functions_lib
+  velox_exec_test_lib
+  velox_functions_prestosql
+  velox_dwio_common_exception
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  Folly::folly
+  ${FOLLY_BENCHMARK}
+  gflags::gflags)
+
 add_executable(velox_aggregates_reduce_agg_bm SimpleAggregates.cpp)
 
 target_link_libraries(
diff --git a/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp b/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
index 0cef592fc9dea..39ef1f99c9d55 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
+++ b/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
@@ -36,8 +36,7 @@ namespace {
 // Compare performance of sum(x) with equivalent reduce_agg(x,..).
 class ReduceAggBenchmark : public HiveConnectorTestBase {
  public:
-  explicit ReduceAggBenchmark() {
-    OperatorTestBase::SetUpTestCase();
+  ReduceAggBenchmark() {
     HiveConnectorTestBase::SetUp();
 
     inputType_ = ROW({
@@ -55,7 +54,7 @@ class ReduceAggBenchmark : public HiveConnectorTestBase {
     }
 
     filePath_ = TempFilePath::create();
-    writeToFile(filePath_->path, vectors);
+    writeToFile((filePath_->getPath()), vectors);
   }
 
   ~ReduceAggBenchmark() override {
@@ -190,9 +189,11 @@ class ReduceAggBenchmark : public HiveConnectorTestBase {
         "t",
         std::move(plan),
         0,
-        std::make_shared<core::QueryCtx>(executor_.get()));
+        core::QueryCtx::create(executor_.get()),
+        exec::Task::ExecutionMode::kParallel);
 
-    task->addSplit("0", exec::Split(makeHiveConnectorSplit(filePath_->path)));
+    task->addSplit(
+        "0", exec::Split(makeHiveConnectorSplit(filePath_->getPath())));
     task->noMoreSplits("0");
     return task;
   }
@@ -224,9 +225,11 @@ BENCHMARK_RELATIVE(sum_groupby) {
 int main(int argc, char** argv) {
   folly::Init init(&argc, &argv);
 
+  OperatorTestBase::SetUpTestCase();
   benchmark = std::make_unique<ReduceAggBenchmark>();
   benchmark->verify();
   folly::runBenchmarks();
   benchmark.reset();
+  OperatorTestBase::TearDownTestCase();
   return 0;
 }
diff --git a/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp b/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
index cfe770bdcb801..58edb37da9a29 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
@@ -36,7 +36,7 @@ namespace {
 
 class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
  public:
-  explicit SimpleAggregatesBenchmark() {
+  SimpleAggregatesBenchmark() {
     OperatorTestBase::SetUpTestCase();
     HiveConnectorTestBase::SetUp();
 
@@ -107,7 +107,7 @@ class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
     }
 
     filePath_ = TempFilePath::create();
-    writeToFile(filePath_->path, vectors);
+    writeToFile(filePath_->getPath(), vectors);
   }
 
   ~SimpleAggregatesBenchmark() override {
@@ -147,7 +147,8 @@ class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
     vector_size_t numResultRows = 0;
     auto task = makeTask(plan);
 
-    task->addSplit("0", exec::Split(makeHiveConnectorSplit(filePath_->path)));
+    task->addSplit(
+        "0", exec::Split(makeHiveConnectorSplit(filePath_->getPath())));
     task->noMoreSplits("0");
 
     suspender.dismiss();
@@ -164,7 +165,8 @@ class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
         "t",
         std::move(plan),
         0,
-        std::make_shared<core::QueryCtx>(executor_.get()));
+        core::QueryCtx::create(executor_.get()),
+        exec::Task::ExecutionMode::kParallel);
   }
 
  private:
@@ -268,10 +270,11 @@ BENCHMARK_DRAW_LINE();
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
-
+  folly::Init init{&argc, &argv};
+  OperatorTestBase::SetUpTestCase();
   benchmark = std::make_unique<SimpleAggregatesBenchmark>();
   folly::runBenchmarks();
   benchmark.reset();
+  OperatorTestBase::TearDownTestCase();
   return 0;
 }
diff --git a/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp b/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp
new file mode 100644
index 0000000000000..8c43c625851e6
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <string>
+
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/tests/utils/Cursor.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int64(fuzzer_seed, 99887766, "Seed for random input dataset generator");
+
+using namespace facebook::velox;
+using namespace facebook::velox::connector::hive;
+using namespace facebook::velox::exec::test;
+
+static constexpr int32_t kNumVectors = 7'000;
+static constexpr int32_t kRowsPerVector = 4'000;
+
+namespace {
+
+// Compare performance of sum(x) with equivalent reduce_agg(x,..).
+class TwoStringKeysBenchmark : public HiveConnectorTestBase {
+ public:
+  TwoStringKeysBenchmark() {
+    HiveConnectorTestBase::SetUp();
+
+    inputType_ = ROW({
+        {"k1", VARCHAR()},
+        {"k2", VARCHAR()},
+        {"n", SMALLINT()},
+    });
+
+    VectorFuzzer::Options opts;
+    opts.vectorSize = kRowsPerVector;
+    opts.nullRatio = 0.0;
+    opts.stringLength = 32;
+    VectorFuzzer fuzzer(opts, pool(), FLAGS_fuzzer_seed);
+
+    std::vector<RowVectorPtr> vectors;
+    for (auto i = 0; i < kNumVectors; ++i) {
+      vectors.emplace_back(fuzzer.fuzzInputFlatRow(inputType_));
+    }
+
+    filePath_ = TempFilePath::create();
+    writeToFile(filePath_->getPath(), vectors);
+  }
+
+  ~TwoStringKeysBenchmark() override {
+    HiveConnectorTestBase::TearDown();
+  }
+
+  void TestBody() override {}
+
+  void verify() {
+    auto plan = PlanBuilder()
+                    .tableScan(inputType_)
+                    .singleAggregation({"k1", "k2"}, {"sum(n)"})
+                    .planFragment();
+
+    auto task = makeTask(plan);
+
+    while (auto result = task->next()) {
+      // no action
+    }
+
+    LOG(ERROR) << exec::printPlanWithStats(
+        *plan.planNode, task->taskStats(), true);
+  }
+
+  void run() {
+    folly::BenchmarkSuspender suspender;
+
+    auto plan = PlanBuilder()
+                    .tableScan(inputType_)
+                    .singleAggregation({"k1", "k2"}, {"sum(n)"})
+                    .planFragment();
+
+    auto task = makeTask(plan);
+
+    suspender.dismiss();
+
+    vector_size_t numResultRows = 0;
+    while (auto result = task->next()) {
+      numResultRows += result->size();
+    }
+
+    LOG(ERROR) << exec::printPlanWithStats(
+        *plan.planNode, task->taskStats(), true);
+
+    folly::doNotOptimizeAway(numResultRows);
+  }
+
+ private:
+  std::shared_ptr<exec::Task> makeTask(core::PlanFragment plan) {
+    auto task = exec::Task::create(
+        "t",
+        std::move(plan),
+        0,
+        core::QueryCtx::create(executor_.get()),
+        exec::Task::ExecutionMode::kParallel);
+
+    task->addSplit(
+        "0", exec::Split(makeHiveConnectorSplit((filePath_->getPath()))));
+    task->noMoreSplits("0");
+    return task;
+  }
+
+  RowTypePtr inputType_;
+  std::shared_ptr<TempFilePath> filePath_;
+};
+
+std::unique_ptr<TwoStringKeysBenchmark> benchmark;
+
+BENCHMARK(two_string_keys) {
+  benchmark->run();
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  OperatorTestBase::SetUpTestCase();
+  benchmark = std::make_unique<TwoStringKeysBenchmark>();
+  benchmark->verify();
+  benchmark.reset();
+  OperatorTestBase::TearDownTestCase();
+  return 0;
+}
diff --git a/velox/functions/prestosql/aggregates/tests/AggregationFunctionRegTest.cpp b/velox/functions/prestosql/aggregates/tests/AggregationFunctionRegTest.cpp
index bc47ca074d6f7..40777e874efb1 100644
--- a/velox/functions/prestosql/aggregates/tests/AggregationFunctionRegTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/AggregationFunctionRegTest.cpp
@@ -17,6 +17,7 @@
 #include <gtest/gtest.h>
 
 #include "velox/exec/Aggregate.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 
 namespace facebook::velox::aggregate::test {
@@ -53,4 +54,71 @@ TEST_F(AggregationFunctionRegTest, prefix) {
   });
 }
 
+TEST_F(AggregationFunctionRegTest, orderSensitive) {
+  // Remove all functions and check for no entries.
+  clearAndCheckRegistry();
+
+  std::set<std::string> nonOrderSensitiveFunctions = {
+      "sum",
+      "avg",
+      "min",
+      "max",
+      "count",
+      "bool_and",
+      "bool_or",
+      "bitwise_and_agg",
+      "bitwise_or_agg",
+      "every",
+      "checksum",
+      "count_if",
+      "geometric_mean",
+      "histogram",
+      "reduce_agg"};
+  aggregate::prestosql::registerAllAggregateFunctions();
+  exec::aggregateFunctions().withRLock([&](const auto& aggrFuncMap) {
+    for (const auto& entry : aggrFuncMap) {
+      if (!entry.second.metadata.orderSensitive) {
+        EXPECT_EQ(1, nonOrderSensitiveFunctions.erase(entry.first));
+      }
+    }
+  });
+  EXPECT_EQ(0, nonOrderSensitiveFunctions.size());
+
+  // Test some but not all order sensitive functions
+  std::set<std::string> orderSensitiveFunctions = {
+      "array_agg", "arbitrary", "any_value", "map_agg", "map_union", "set_agg"};
+  exec::aggregateFunctions().withRLock([&](const auto& aggrFuncMap) {
+    for (const auto& entry : aggrFuncMap) {
+      if (entry.second.metadata.orderSensitive) {
+        orderSensitiveFunctions.erase(entry.first);
+      }
+    }
+  });
+  EXPECT_EQ(0, orderSensitiveFunctions.size());
+}
+
+TEST_F(AggregationFunctionRegTest, prestoSupportedSignatures) {
+  // Remove all functions and check for no entries.
+  clearAndCheckRegistry();
+
+  // Register without prefix and all signatures
+  aggregate::prestosql::registerAllAggregateFunctions("", true, false);
+  auto aggrFuncMapBase = exec::aggregateFunctions().copy();
+  EXPECT_EQ(aggrFuncMapBase[kBitwiseAnd].signatures.size(), 4);
+  EXPECT_EQ(aggrFuncMapBase[kBitwiseOr].signatures.size(), 4);
+  EXPECT_EQ(aggrFuncMapBase[kBitwiseXor].signatures.size(), 4);
+
+  // Register without prefix and only those signatures that are supported by
+  // Presto.
+  clearAndCheckRegistry();
+  aggregate::prestosql::registerAllAggregateFunctions("", true, true);
+  aggrFuncMapBase = exec::aggregateFunctions().copy();
+  EXPECT_EQ(aggrFuncMapBase[kBitwiseAnd].signatures.size(), 1);
+  EXPECT_EQ(aggrFuncMapBase[kBitwiseOr].signatures.size(), 1);
+  EXPECT_EQ(aggrFuncMapBase[kBitwiseXor].signatures.size(), 1);
+
+  // Revert to previous state.
+  clearAndCheckRegistry();
+}
+
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxDistinctTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxDistinctTest.cpp
index 761bd4d05a496..47c3ac0f8cae4 100644
--- a/velox/functions/prestosql/aggregates/tests/ApproxDistinctTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ApproxDistinctTest.cpp
@@ -16,7 +16,7 @@
 #include "velox/common/hyperloglog/HllUtils.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
@@ -57,17 +57,12 @@ class ApproxDistinctTest : public AggregationTestBase {
         {fmt::format("approx_set(c0, {})", maxStandardError)},
         {"cardinality(a0)"},
         {expected});
-    testAggregationsWithCompanion(
-        {vectors},
-        [](auto& /*builder*/) {},
-        {},
-        {fmt::format("approx_set(c0, {})", maxStandardError)},
-        {{values->type(), DOUBLE()}},
-        {"cardinality(a0)"},
-        {expected});
   }
 
-  void testGlobalAgg(const VectorPtr& values, int64_t expectedResult) {
+  void testGlobalAgg(
+      const VectorPtr& values,
+      int64_t expectedResult,
+      bool testApproxSet = true) {
     auto vectors = makeRowVector({values});
     auto expected =
         makeRowVector({makeNullableFlatVector<int64_t>({expectedResult})});
@@ -82,16 +77,10 @@ class ApproxDistinctTest : public AggregationTestBase {
         {},
         {expected});
 
-    testAggregations(
-        {vectors}, {}, {"approx_set(c0)"}, {"cardinality(a0)"}, {expected});
-    testAggregationsWithCompanion(
-        {vectors},
-        [](auto& /*builder*/) {},
-        {},
-        {"approx_set(c0)"},
-        {{values->type()}},
-        {"cardinality(a0)"},
-        {expected});
+    if (testApproxSet) {
+      testAggregations(
+          {vectors}, {}, {"approx_set(c0)"}, {"cardinality(a0)"}, {expected});
+    }
   }
 
   template <typename T, typename U>
@@ -112,7 +101,8 @@ class ApproxDistinctTest : public AggregationTestBase {
   void testGroupByAgg(
       const VectorPtr& keys,
       const VectorPtr& values,
-      const std::unordered_map<int32_t, int64_t>& expectedResults) {
+      const std::unordered_map<int32_t, int64_t>& expectedResults,
+      bool testApproxSet = true) {
     auto vectors = makeRowVector({keys, values});
     auto expected = toRowVector(expectedResults);
 
@@ -126,20 +116,14 @@ class ApproxDistinctTest : public AggregationTestBase {
         {},
         {expected});
 
-    testAggregations(
-        {vectors},
-        {"c0"},
-        {"approx_set(c1)"},
-        {"c0", "cardinality(a0)"},
-        {expected});
-    testAggregationsWithCompanion(
-        {vectors},
-        [](auto& /*builder*/) {},
-        {"c0"},
-        {"approx_set(c1)"},
-        {{values->type()}},
-        {"c0", "cardinality(a0)"},
-        {expected});
+    if (testApproxSet) {
+      testAggregations(
+          {vectors},
+          {"c0"},
+          {"approx_set(c1)"},
+          {"c0", "cardinality(a0)"},
+          {expected});
+    }
   }
 };
 
@@ -190,7 +174,13 @@ TEST_F(ApproxDistinctTest, groupByHighCardinalityIntegers) {
   auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 2; });
   auto values = makeFlatVector<int32_t>(size, [](auto row) { return row; });
 
-  testGroupByAgg(keys, values, {{0, 488}, {1, 493}});
+  testGroupByAgg(keys, values, {{0, 488}, {1, 493}}, false);
+  testAggregations(
+      {makeRowVector({keys, values})},
+      {"c0"},
+      {"approx_set(c1)"},
+      {"c0", "cardinality(a0)"},
+      {toRowVector<int32_t, int64_t>({{0, 500}, {1, 500}})});
 }
 
 TEST_F(ApproxDistinctTest, groupByVeryLowCardinalityIntegers) {
@@ -240,11 +230,33 @@ TEST_F(ApproxDistinctTest, globalAggStrings) {
   testGlobalAgg(values, kFruits.size());
 }
 
+TEST_F(ApproxDistinctTest, globalAggVarbinary) {
+  auto values = makeFlatVector<std::string>(
+      1'000,
+      [&](auto row) { return kFruits[row % kFruits.size()]; },
+      nullptr,
+      VARBINARY());
+
+  testGlobalAgg(values, kFruits.size());
+}
+
+TEST_F(ApproxDistinctTest, globalAggTimeStamp) {
+  auto data = makeFlatVector<Timestamp>(
+      1'000, [](auto row) { return Timestamp::fromMillis(row); });
+  testGlobalAgg(data, 0.023, 1010);
+}
+
 TEST_F(ApproxDistinctTest, globalAggHighCardinalityIntegers) {
   vector_size_t size = 1'000;
   auto values = makeFlatVector<int32_t>(size, [](auto row) { return row; });
 
-  testGlobalAgg(values, 977);
+  testGlobalAgg(values, 977, false);
+  testAggregations(
+      {makeRowVector({values})},
+      {},
+      {"approx_set(c0)"},
+      {"cardinality(a0)"},
+      {makeRowVector({makeFlatVector<int64_t>(std::vector<int64_t>({997}))})});
 }
 
 TEST_F(ApproxDistinctTest, globalAggVeryLowCardinalityIntegers) {
@@ -258,7 +270,13 @@ TEST_F(ApproxDistinctTest, toIndexBitLength) {
   ASSERT_EQ(
       common::hll::toIndexBitLength(common::hll::kHighestMaxStandardError), 4);
   ASSERT_EQ(
-      common::hll::toIndexBitLength(common::hll::kDefaultStandardError), 11);
+      common::hll::toIndexBitLength(
+          common::hll::kDefaultApproxDistinctStandardError),
+      11);
+  ASSERT_EQ(
+      common::hll::toIndexBitLength(
+          common::hll::kDefaultApproxSetStandardError),
+      12);
   ASSERT_EQ(
       common::hll::toIndexBitLength(common::hll::kLowestMaxStandardError), 16);
 
@@ -293,8 +311,8 @@ TEST_F(ApproxDistinctTest, globalAggIntegersWithError) {
 
 TEST_F(ApproxDistinctTest, globalAggAllNulls) {
   vector_size_t size = 1'000;
-  auto values = makeFlatVector<int32_t>(
-      size, [](auto row) { return row; }, nullEvery(1));
+  auto values =
+      makeFlatVector<int32_t>(size, [](auto row) { return row; }, nullEvery(1));
 
   auto op = PlanBuilder()
                 .values({makeRowVector({values})})
@@ -328,6 +346,21 @@ TEST_F(ApproxDistinctTest, globalAggAllNulls) {
   EXPECT_TRUE(readSingleValue(op).isNull());
 }
 
+TEST_F(ApproxDistinctTest, hugeInt) {
+  auto hugeIntValues =
+      makeFlatVector<int128_t>(50000, [](auto row) { return row; });
+  testGlobalAgg(hugeIntValues, 49669, false);
+  testAggregations(
+      {makeRowVector({hugeIntValues})},
+      {},
+      {"approx_set(c0)"},
+      {"cardinality(a0)"},
+      {makeRowVector(
+          {makeFlatVector<int64_t>(std::vector<int64_t>({49958}))})});
+  testGlobalAgg(hugeIntValues, common::hll::kLowestMaxStandardError, 50110);
+  testGlobalAgg(hugeIntValues, common::hll::kHighestMaxStandardError, 41741);
+}
+
 TEST_F(ApproxDistinctTest, streaming) {
   auto rawInput1 = makeFlatVector<int64_t>({1, 2, 3});
   auto rawInput2 = makeFlatVector<int64_t>(1000, folly::identity);
@@ -367,5 +400,37 @@ TEST_F(ApproxDistinctTest, memoryLeakInMerge) {
       toPlanStats(task->taskStats()).at(finalAgg).peakMemoryBytes, 180'000);
 }
 
+TEST_F(ApproxDistinctTest, mergeWithEmpty) {
+  constexpr int kSize = 500;
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(kSize, [](auto i) { return std::min(i, 1); }),
+      makeFlatVector<int32_t>(
+          kSize, folly::identity, [](auto i) { return i == 0; }),
+  });
+  auto op = PlanBuilder()
+                .values({input})
+                .singleAggregation({"c0"}, {"approx_set(c1)"})
+                .project({"coalesce(a0, empty_approx_set())"})
+                .singleAggregation({}, {"merge(p0)"})
+                .project({"cardinality(a0)"})
+                .planNode();
+  ASSERT_EQ(readSingleValue(op).value<TypeKind::BIGINT>(), 499);
+}
+
+TEST_F(ApproxDistinctTest, toIntermediate) {
+  constexpr int kSize = 1000;
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(kSize, folly::identity),
+      makeConstant<int64_t>(1, kSize),
+  });
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .singleAggregation({"c0"}, {"approx_set(c1)"})
+                  .planNode();
+  auto digests = split(AssertQueryBuilder(plan).copyResults(pool()), 2);
+  testAggregations(
+      digests, {"c0"}, {"merge(a0)"}, {"c0", "cardinality(a0)"}, {input});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
index c6bc5aebb0bcd..148357159c255 100644
--- a/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::functions::aggregate::test;
 
@@ -27,7 +27,6 @@ struct ApproxMostFrequentTest : AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   std::shared_ptr<FlatVector<int>> makeGroupKeys() {
@@ -137,7 +136,9 @@ TYPED_TEST(ApproxMostFrequentTest, emptyGroup) {
 using ApproxMostFrequentTestInt = ApproxMostFrequentTest<int>;
 
 TEST_F(ApproxMostFrequentTestInt, invalidBuckets) {
-  static_cast<memory::MemoryPoolImpl*>(pool())->testingSetCapacity(1 << 21);
+  auto rootPool = memory::memoryManager()->addRootPool(
+      "test-root", 1 << 21, exec::MemoryReclaimer::create());
+  auto leafPool = rootPool->addLeafChild("test-leaf");
   auto run = [&](int64_t buckets) {
     auto rows = makeRowVector({
         makeConstant<int64_t>(buckets, buckets),
@@ -148,7 +149,7 @@ TEST_F(ApproxMostFrequentTestInt, invalidBuckets) {
                     .values({rows})
                     .singleAggregation({}, {"approx_most_frequent(c0, c1, c2)"})
                     .planNode();
-    return exec::test::AssertQueryBuilder(plan).copyResults(pool());
+    return exec::test::AssertQueryBuilder(plan).copyResults(leafPool.get());
   };
   ASSERT_EQ(run(10)->size(), 1);
   try {
@@ -180,5 +181,105 @@ TEST_F(ApproxMostFrequentTestStringView, stringLifeCycle) {
       {rows, rows}, {}, {"approx_most_frequent(3, c0, 31)"}, {expected});
 }
 
+class ApproxMostFrequentTestBoolean : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+};
+
+TEST_F(ApproxMostFrequentTestBoolean, basic) {
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>({0, 1, 0, 1, 0, 1, 0, 1}),
+      makeFlatVector<bool>(
+          {true, false, true, true, false, false, false, false}),
+      makeConstant(true, 8),
+      makeConstant(false, 8),
+      makeAllNullFlatVector<bool>(8),
+      makeNullableFlatVector<bool>(
+          {true, false, std::nullopt, true, false, std::nullopt, false, false}),
+  });
+
+  auto expected = makeRowVector({
+      makeMapVector<bool, int64_t>({
+          {{true, 3}, {false, 5}},
+      }),
+  });
+
+  testAggregations(
+      {input}, {}, {"approx_most_frequent(3, c1, 31)"}, {expected});
+
+  expected = makeRowVector({
+      makeFlatVector<int32_t>({0, 1}),
+      makeMapVector<bool, int64_t>({
+          {{true, 2}, {false, 2}},
+          {{true, 1}, {false, 3}},
+      }),
+  });
+
+  testAggregations(
+      {input}, {"c0"}, {"approx_most_frequent(3, c1, 31)"}, {expected});
+
+  // All 'true'.
+  expected = makeRowVector({makeMapVector<bool, int64_t>({{{true, 8}}})});
+  testAggregations(
+      {input}, {}, {"approx_most_frequent(3, c2, 31)"}, {expected});
+
+  expected = makeRowVector({
+      makeFlatVector<int32_t>({0, 1}),
+      makeMapVector<bool, int64_t>({
+          {{true, 4}},
+          {{true, 4}},
+      }),
+  });
+
+  testAggregations(
+      {input}, {"c0"}, {"approx_most_frequent(3, c2, 31)"}, {expected});
+
+  // All 'false'.
+  expected = makeRowVector({makeMapVector<bool, int64_t>({{{false, 8}}})});
+  testAggregations(
+      {input}, {}, {"approx_most_frequent(3, c3, 31)"}, {expected});
+
+  expected = makeRowVector({
+      makeFlatVector<int32_t>({0, 1}),
+      makeMapVector<bool, int64_t>({
+          {{false, 4}},
+          {{false, 4}},
+      }),
+  });
+
+  testAggregations(
+      {input}, {"c0"}, {"approx_most_frequent(3, c3, 31)"}, {expected});
+
+  // All nulls.
+  expected = makeRowVector({
+      BaseVector::createNullConstant(MAP(BOOLEAN(), BIGINT()), 1, pool()),
+  });
+  testAggregations(
+      {input}, {}, {"approx_most_frequent(3, c4, 31)"}, {expected});
+
+  // Some nulls.
+  expected = makeRowVector({
+      makeMapVector<bool, int64_t>({
+          {{true, 2}, {false, 4}},
+      }),
+  });
+
+  testAggregations(
+      {input}, {}, {"approx_most_frequent(3, c5, 31)"}, {expected});
+
+  expected = makeRowVector({
+      makeFlatVector<int32_t>({0, 1}),
+      makeMapVector<bool, int64_t>({
+          {{true, 1}, {false, 2}},
+          {{true, 1}, {false, 2}},
+      }),
+  });
+
+  testAggregations(
+      {input}, {"c0"}, {"approx_most_frequent(3, c5, 31)"}, {expected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
index 5e8e22a100b2c..89913e423877a 100644
--- a/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
@@ -14,16 +14,19 @@
  * limitations under the License.
  */
 #include <algorithm>
+#include "math.h"
 
 #include "velox/common/base/RandomUtil.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/lib/window/tests/WindowTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
+using namespace facebook::velox::window::test;
 
 namespace facebook::velox::aggregate::test {
 
@@ -87,7 +90,6 @@ class ApproxPercentileTest : public AggregationTestBase {
   void SetUp() override {
     AggregationTestBase::SetUp();
     random::setSeed(0);
-    allowInputShuffle();
   }
 
   template <typename T>
@@ -105,12 +107,36 @@ class ApproxPercentileTest : public AggregationTestBase {
     auto rows =
         weights ? makeRowVector({values, weights}) : makeRowVector({values});
 
-    auto expected = expectedResult.has_value()
-        ? fmt::format("SELECT {}", expectedResult.value())
-        : "SELECT NULL";
-    auto expectedArray = expectedResult.has_value()
-        ? fmt::format("SELECT ARRAY[{0},{0},{0}]", expectedResult.value())
-        : "SELECT NULL";
+    std::string expected;
+    std::string expectedArray;
+    if (!expectedResult.has_value()) {
+      expected = "SELECT NULL";
+      expectedArray = "SELECT NULL";
+    } else if (
+        (std::is_same<T, float>::value && isnan(expectedResult.value())) ||
+        (std::is_same<T, double>::value && isnan(expectedResult.value()))) {
+      expected = "SELECT 'NaN'";
+      expectedArray = fmt::format("SELECT ARRAY[{0},{0},{0}]", "'NaN'");
+    } else if (
+        (std::is_same<T, float>::value &&
+         expectedResult.value() == std::numeric_limits<float>::infinity()) ||
+        (std::is_same<T, double>::value &&
+         expectedResult.value() == std::numeric_limits<double>::infinity())) {
+      expected = "SELECT 'INFINITY'";
+      expectedArray = fmt::format("SELECT ARRAY[{0},{0},{0}]", "'INFINITY'");
+    } else if (
+        (std::is_same<T, float>::value &&
+         expectedResult.value() == -std::numeric_limits<float>::infinity()) ||
+        (std::is_same<T, double>::value &&
+         expectedResult.value() == -std::numeric_limits<double>::infinity())) {
+      expected = "SELECT '-INFINITY'";
+      expectedArray = fmt::format("SELECT ARRAY[{0},{0},{0}]", "'-INFINITY'");
+    } else {
+      expected = fmt::format("SELECT {}", expectedResult.value());
+      expectedArray =
+          fmt::format("SELECT ARRAY[{0},{0},{0}]", expectedResult.value());
+    }
+
     enableTestStreaming();
     testAggregations(
         {rows},
@@ -144,6 +170,30 @@ class ApproxPercentileTest : public AggregationTestBase {
         expectedArray);
   }
 
+  template <typename T>
+  void testNaN() {
+    const T nan = std::is_same_v<T, float> ? std::nanf("") : std::nan("");
+    vector_size_t size = 10;
+    auto values = makeFlatVector<T>(size, [nan](auto row) {
+      if (row > 8)
+        return -std::numeric_limits<T>::infinity();
+      else if (row > 7)
+        return std::numeric_limits<T>::infinity();
+      else if (row > 6)
+        return nan;
+      else
+        return (T)row;
+    });
+
+    testGlobalAgg<T>(
+        values, nullptr, 0.05, 0.005, -std::numeric_limits<T>::infinity());
+    testGlobalAgg<T>(values, nullptr, 0.11, 0.005, 0.0);
+    testGlobalAgg<T>(values, nullptr, 0.55, 0.005, 4.0);
+    testGlobalAgg<T>(
+        values, nullptr, 0.85, 0.005, std::numeric_limits<T>::infinity());
+    testGlobalAgg<T>(values, nullptr, 0.95, 0.005, nan);
+  }
+
   void testGroupByAgg(
       const VectorPtr& keys,
       const VectorPtr& values,
@@ -346,7 +396,7 @@ TEST_F(ApproxPercentileTest, largeWeightsGroupBy) {
 TEST_F(ApproxPercentileTest, partialFull) {
   // Make sure partial aggregation runs out of memory after first batch.
   CursorParameters params;
-  params.queryCtx = std::make_shared<core::QueryCtx>(executor_.get());
+  params.queryCtx = velox::core::QueryCtx::create(executor_.get());
   params.queryCtx->testingOverrideConfigUnsafe({
       {core::QueryConfig::kMaxPartialAggregationMemory, "300000"},
   });
@@ -379,6 +429,7 @@ TEST_F(ApproxPercentileTest, partialFull) {
       makeFlatVector<int32_t>(117, [](auto row) { return row < 7 ? 20 : 10; }),
   });
   exec::test::assertQuery(params, {expected});
+  waitForAllTasksToBeDeleted();
 }
 
 TEST_F(ApproxPercentileTest, finalAggregateAccuracy) {
@@ -400,7 +451,7 @@ TEST_F(ApproxPercentileTest, finalAggregateAccuracy) {
   assertQuery(op, "SELECT 5");
 }
 
-TEST_F(ApproxPercentileTest, invalidEncoding) {
+TEST_F(ApproxPercentileTest, nonFlatPercentileArray) {
   auto indices = AlignedBuffer::allocate<vector_size_t>(3, pool());
   auto rawIndices = indices->asMutable<vector_size_t>();
   std::iota(rawIndices, rawIndices + indices->size(), 0);
@@ -421,10 +472,8 @@ TEST_F(ApproxPercentileTest, invalidEncoding) {
                   .values({rows})
                   .singleAggregation({}, {"approx_percentile(c0, c1)"})
                   .planNode();
-  AssertQueryBuilder assertQuery(plan);
-  VELOX_ASSERT_THROW(
-      assertQuery.copyResults(pool()),
-      "Only flat encoding is allowed for percentile array elements");
+  auto expected = makeRowVector({makeArrayVector<int32_t>({{0, 5, 9}})});
+  AssertQueryBuilder(plan).assertResults(expected);
 }
 
 TEST_F(ApproxPercentileTest, invalidWeight) {
@@ -567,5 +616,37 @@ TEST_F(ApproxPercentileTest, nullPercentile) {
       "Percentile cannot be null");
 }
 
+TEST_F(ApproxPercentileTest, nanPercentile) {
+  testNaN<float>();
+  testNaN<double>();
+}
+
+class ApproxPercentileWindowTest : public WindowTestBase {
+ protected:
+  void SetUp() override {
+    WindowTestBase::SetUp();
+    random::setSeed(0);
+  }
+};
+
+TEST_F(ApproxPercentileWindowTest, window) {
+  auto data = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2, 3}),
+       makeNullableFlatVector<int32_t>({10, std::nullopt, 30}),
+       makeArrayVectorFromJson<double>({"[0.5]", "[0.5]", "[0.5]"})});
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+      makeNullableFlatVector<int32_t>({10, std::nullopt, 30}),
+      makeArrayVectorFromJson<double>({"[0.5]", "[0.5]", "[0.5]"}),
+      makeNullableArrayVector<int32_t>({{{10}}, std::nullopt, {{30}}}),
+  });
+  testWindowFunction(
+      {data},
+      "approx_percentile(c1, c2)",
+      "order by c0",
+      "rows between current row and current row",
+      expected);
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp b/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
index 4d888d70151d9..29cbc6837ddfb 100644
--- a/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
@@ -14,11 +14,15 @@
  * limitations under the License.
  */
 
+#include "velox/exec/Spill.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/lib/window/tests/WindowTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
+using namespace facebook::velox::window::test;
 
 namespace facebook::velox::aggregate::test {
 
@@ -43,10 +47,10 @@ TEST_F(ArbitraryTest, noNulls) {
   std::vector<std::string> aggregates = {
       "arbitrary(c1)",
       "arbitrary(c2)",
-      "arbitrary(c3)",
+      "any_value(c3)",
       "arbitrary(c4)",
       "arbitrary(c5)",
-      "arbitrary(c6)"};
+      "any_value(c6)"};
 
   // We do not test with TableScan because having two input splits makes the
   // result non-deterministic.
@@ -55,9 +59,7 @@ TEST_F(ArbitraryTest, noNulls) {
       vectors,
       {},
       aggregates,
-      "SELECT first(c1), first(c2), first(c3), first(c4), first(c5), first(c6) FROM tmp",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT first(c1), first(c2), first(c3), first(c4), first(c5), first(c6) FROM tmp");
 
   // Group by aggregation.
   testAggregations(
@@ -67,9 +69,7 @@ TEST_F(ArbitraryTest, noNulls) {
       },
       {"p0"},
       aggregates,
-      "SELECT c0 % 10, first(c1), first(c2), first(c3), first(c4), first(c5), first(c6) FROM tmp GROUP BY 1",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT c0 % 10, first(c1), first(c2), first(c3), first(c4), first(c5), first(c6) FROM tmp GROUP BY 1");
 
   // encodings: use filter to wrap aggregation inputs in a dictionary.
   testAggregations(
@@ -80,9 +80,7 @@ TEST_F(ArbitraryTest, noNulls) {
       },
       {"p0"},
       aggregates,
-      "SELECT c0 % 10, first(c1), first(c2), first(c3), first(c4), first(c5), first(c6) FROM tmp WHERE c0 % 2 = 0 GROUP BY 1",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT c0 % 10, first(c1), first(c2), first(c3), first(c4), first(c5), first(c6) FROM tmp WHERE c0 % 2 = 0 GROUP BY 1");
 
   testAggregations(
       [&](PlanBuilder& builder) {
@@ -90,9 +88,7 @@ TEST_F(ArbitraryTest, noNulls) {
       },
       {},
       aggregates,
-      "SELECT first(c1), first(c2), first(c3), first(c4), first(c5), first(c6) FROM tmp WHERE c0 % 2 = 0",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT first(c1), first(c2), first(c3), first(c4), first(c5), first(c6) FROM tmp WHERE c0 % 2 = 0");
 }
 
 TEST_F(ArbitraryTest, nulls) {
@@ -119,18 +115,14 @@ TEST_F(ArbitraryTest, nulls) {
       vectors,
       {},
       {"arbitrary(c1)", "arbitrary(c2)", "arbitrary(c3)"},
-      "SELECT * FROM( VALUES (4, 0.50, NULL)) AS t",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT * FROM( VALUES (4, 0.50, NULL)) AS t");
 
   // Group by aggregation.
   testAggregations(
       vectors,
       {"c0"},
       {"arbitrary(c1)", "arbitrary(c2)", "arbitrary(c3)"},
-      "SELECT * FROM(VALUES (1, NULL, 0.50, NULL), (2, 4, NULL, NULL), (3, 5, 0.25, NULL)) AS t",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT * FROM(VALUES (1, NULL, 0.50, NULL), (2, 4, NULL, NULL), (3, 5, 0.25, NULL)) AS t");
 }
 
 TEST_F(ArbitraryTest, varchar) {
@@ -146,17 +138,13 @@ TEST_F(ArbitraryTest, varchar) {
       },
       {"p0"},
       {"arbitrary(c1)"},
-      "SELECT c0 % 11, first(c1) FROM tmp WHERE c1 IS NOT NULL GROUP BY 1",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT c0 % 11, first(c1) FROM tmp WHERE c1 IS NOT NULL GROUP BY 1");
 
   testAggregations(
       vectors,
       {},
       {"arbitrary(c1)"},
-      "SELECT first(c1) FROM tmp WHERE c1 IS NOT NULL",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT first(c1) FROM tmp WHERE c1 IS NOT NULL");
 
   // encodings: use filter to wrap aggregation inputs in a dictionary.
   testAggregations(
@@ -165,9 +153,7 @@ TEST_F(ArbitraryTest, varchar) {
       },
       {"p0"},
       {"arbitrary(c1)"},
-      "SELECT c0 % 11, first(c1) FROM tmp WHERE c0 % 2 = 0 AND c1 IS NOT NULL GROUP BY 1",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT c0 % 11, first(c1) FROM tmp WHERE c0 % 2 = 0 AND c1 IS NOT NULL GROUP BY 1");
 
   testAggregations(
       [&](PlanBuilder& builder) {
@@ -175,9 +161,7 @@ TEST_F(ArbitraryTest, varchar) {
       },
       {},
       {"arbitrary(c1)"},
-      "SELECT first(c1) FROM tmp WHERE c0 % 2 = 0 AND c1 IS NOT NULL",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT first(c1) FROM tmp WHERE c0 % 2 = 0 AND c1 IS NOT NULL");
 }
 
 TEST_F(ArbitraryTest, varcharConstAndNulls) {
@@ -367,5 +351,119 @@ TEST_F(ArbitraryTest, interval) {
   testAggregations({data}, {}, {"arbitrary(c2)"}, "SELECT null");
 }
 
+TEST_F(ArbitraryTest, longDecimal) {
+  auto data = makeRowVector({// Grouping key.
+                             makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3, 4, 4}),
+                             makeNullableFlatVector<int128_t>(
+                                 {HugeInt::build(10, 100),
+                                  HugeInt::build(10, 100),
+                                  HugeInt::build(10, 200),
+                                  HugeInt::build(10, 200),
+                                  std::nullopt,
+                                  std::nullopt,
+                                  std::nullopt,
+                                  HugeInt::build(10, 400)},
+                                 DECIMAL(38, 8))});
+
+  auto expectedResult = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+      makeNullableFlatVector<int128_t>(
+          {HugeInt::build(10, 100),
+           HugeInt::build(10, 200),
+           std::nullopt,
+           HugeInt::build(10, 400)},
+          DECIMAL(38, 8)),
+  });
+
+  testAggregations({data}, {"c0"}, {"arbitrary(c1)"}, {expectedResult});
+}
+
+TEST_F(ArbitraryTest, shortDecimal) {
+  auto data = makeRowVector({// Grouping key.
+                             makeFlatVector<int64_t>({1, 1, 2, 2, 3, 3, 4, 4}),
+                             makeNullableFlatVector<int64_t>(
+                                 {10000000000000000,
+                                  10000000000000000,
+                                  20000000000000000,
+                                  20000000000000000,
+                                  std::nullopt,
+                                  std::nullopt,
+                                  std::nullopt,
+                                  40000000000000000},
+                                 DECIMAL(15, 2))});
+
+  auto expectedResult = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+      makeNullableFlatVector<int64_t>(
+          {10000000000000000,
+           20000000000000000,
+           std::nullopt,
+           40000000000000000},
+          DECIMAL(15, 2)),
+  });
+
+  testAggregations({data}, {"c0"}, {"arbitrary(c1)"}, {expectedResult});
+}
+
+class ArbitraryWindowTest : public WindowTestBase {};
+
+TEST_F(ArbitraryWindowTest, basic) {
+  auto data = makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+       makeArrayVector<double>({{1.0}, {2.0}, {3.0}, {4.0}, {5.0}}),
+       makeFlatVector<bool>({false, false, false, false, false})});
+
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+       makeArrayVector<double>({{1.0}, {2.0}, {3.0}, {4.0}, {5.0}}),
+       makeFlatVector<bool>({false, false, false, false, false}),
+       makeFlatVector<int64_t>({1, 1, 1, 1, 1})});
+  window::test::WindowTestBase::testWindowFunction(
+      {data},
+      "arbitrary(c0)",
+      "partition by c2 order by c0",
+      "range between unbounded preceding and current row",
+      expected);
+
+  expected = makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+       makeArrayVector<double>({{1.0}, {2.0}, {3.0}, {4.0}, {5.0}}),
+       makeFlatVector<bool>({false, false, false, false, false}),
+       makeArrayVector<double>({{1.0}, {1.0}, {1.0}, {1.0}, {1.0}})});
+  window::test::WindowTestBase::testWindowFunction(
+      {data},
+      "arbitrary(c1)",
+      "partition by c2 order by c0",
+      "range between unbounded preceding and current row",
+      expected);
+}
+
+TEST_F(ArbitraryTest, spilling) {
+  auto data = makeRowVector(
+      {makeFlatVector<float>({0.1, 0.2, 0.3, 0.4, 0.5, 0.6}),
+       makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5, 6})});
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5, 6}),
+       makeNullableFlatVector<float>({0.1, 0.2, 0.3, 0.4, 0.5, 0.6})});
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation({"c1"}, {"arbitrary(c0)"})
+                  .planNode();
+
+  std::shared_ptr<TempDirectoryPath> spillDirectory;
+  AssertQueryBuilder builder(plan);
+
+  exec::TestScopedSpillInjection scopedSpillInjection(100);
+  spillDirectory = exec::test::TempDirectoryPath::create();
+  builder.spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, "true")
+      .config(core::QueryConfig::kAggregationSpillEnabled, "true")
+      .config(core::QueryConfig::kSpillNumPartitionBits, "0");
+
+  auto result = builder.maxDrivers(2).copyResults(pool_.get());
+  ::facebook::velox::test::assertEqualVectors(expected, result);
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp b/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
index 3978b244dbfd5..0e9b6cc97e9aa 100644
--- a/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
@@ -13,12 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/dwio/common/tests/utils/BatchMaker.h"
+
 #include "velox/exec/tests/SimpleAggregateFunctionsRegistration.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/exec/tests/utils/Cursor.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
@@ -33,6 +34,14 @@ class ArrayAggTest : public AggregationTestBase {
   void SetUp() override {
     AggregationTestBase::SetUp();
     registerSimpleArrayAggAggregate("simple_array_agg");
+    prestosql::registerInternalAggregateFunctions();
+  }
+
+  RowVectorPtr fuzzFlat(const RowTypePtr& rowType, size_t size) {
+    VectorFuzzer::Options options;
+    options.vectorSize = size;
+    VectorFuzzer fuzzer(options, pool());
+    return fuzzer.fuzzInputFlatRow(rowType);
   }
 };
 
@@ -45,7 +54,9 @@ std::unordered_map<std::string, std::string> makeConfig(bool ignoreNulls) {
 
 TEST_F(ArrayAggTest, groupBy) {
   auto testFunction = [this](
-                          const std::string& functionName, bool ignoreNulls) {
+                          const std::string& functionName,
+                          bool ignoreNulls,
+                          bool testCompanionFunctions = true) {
     constexpr int32_t kNumGroups = 10;
     std::vector<RowVectorPtr> batches;
     // We make 10 groups. each with 10 arrays. Each array consists of n
@@ -53,17 +64,21 @@ TEST_F(ArrayAggTest, groupBy) {
     // expected result is that there is, for each key, an array of 100
     // elements with, for key k, batch[k[, batch[k + 10], ... batch[k +
     // 90], repeated 10 times.
-    batches.push_back(std::static_pointer_cast<RowVector>(
-        velox::test::BatchMaker::createBatch(
-            ROW({"c0", "a"}, {INTEGER(), ARRAY(VARCHAR())}), 100, *pool_)));
+    batches.push_back(
+        fuzzFlat(ROW({"c0", "a"}, {INTEGER(), ARRAY(VARCHAR())}), 100));
     // We divide the rows into 10 groups.
     auto keys = batches[0]->childAt(0)->as<FlatVector<int32_t>>();
+    auto values = batches[0]->childAt(1)->as<ArrayVector>();
     for (auto i = 0; i < keys->size(); ++i) {
       if (i % 10 == 0) {
         keys->setNull(i, true);
       } else {
         keys->set(i, i % kNumGroups);
       }
+
+      if (i % 7 == 0) {
+        values->setNull(i, true);
+      }
     }
     // We make 10 repeats of the first batch.
     for (auto i = 0; i < 9; ++i) {
@@ -81,17 +96,19 @@ TEST_F(ArrayAggTest, groupBy) {
             "SELECT c0, array_sort(array_agg(a) {}) FROM tmp GROUP BY c0",
             filter),
         makeConfig(ignoreNulls));
-    testAggregationsWithCompanion(
-        batches,
-        [](auto& /*builder*/) {},
-        {"c0"},
-        {fmt::format("{}(a)", functionName)},
-        {{ARRAY(VARCHAR())}},
-        {"c0", "array_sort(a0)"},
-        fmt::format(
-            "SELECT c0, array_sort(array_agg(a) {}) FROM tmp GROUP BY c0",
-            filter),
-        makeConfig(ignoreNulls));
+    if (testCompanionFunctions) {
+      testAggregationsWithCompanion(
+          batches,
+          [](auto& /*builder*/) {},
+          {"c0"},
+          {fmt::format("{}(a)", functionName)},
+          {{ARRAY(VARCHAR())}},
+          {"c0", "array_sort(a0)"},
+          fmt::format(
+              "SELECT c0, array_sort(array_agg(a) {}) FROM tmp GROUP BY c0",
+              filter),
+          makeConfig(ignoreNulls));
+    }
 
     // Having one function supporting toIntermediate and one does not, make sure
     // the row container is recreated with only the function without
@@ -109,6 +126,7 @@ TEST_F(ArrayAggTest, groupBy) {
 
   testFunction("array_agg", true);
   testFunction("array_agg", false);
+  testFunction("\"$internal$array_agg\"", false, false);
   testFunction("simple_array_agg", false);
 }
 
@@ -176,6 +194,23 @@ TEST_F(ArrayAggTest, sortedGroupBy) {
             "SELECT c0, array_agg(c1 ORDER BY c2 DESC, c3), sum(c1) "
             " FROM tmp GROUP BY 1");
 
+    // Multiple sorted aggregations with same sorting keys.
+    plan = PlanBuilder()
+               .values({data})
+               .singleAggregation(
+                   {"c0"},
+                   {
+                       fmt::format("{}(c1 ORDER BY c3)", functionName),
+                       fmt::format("{}(c2 ORDER BY c3)", functionName),
+                       "sum(c1)",
+                   })
+               .planNode();
+
+    AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .assertResults(
+            "SELECT c0, array_agg(c1 ORDER BY c3), array_agg(c2 ORDER BY c3), sum(c1) "
+            " FROM tmp GROUP BY 1");
+
     // Sorted aggregation with mask.
     plan = PlanBuilder()
                .values({data})
@@ -201,7 +236,9 @@ TEST_F(ArrayAggTest, sortedGroupBy) {
 
 TEST_F(ArrayAggTest, global) {
   auto testFunction = [this](
-                          const std::string& functionName, bool ignoreNulls) {
+                          const std::string& functionName,
+                          bool ignoreNulls,
+                          bool testCompanionFunctions = true) {
     vector_size_t size = 10;
 
     std::vector<RowVectorPtr> vectors = {makeRowVector({makeFlatVector<int32_t>(
@@ -216,25 +253,30 @@ TEST_F(ArrayAggTest, global) {
         {"array_sort(a0)"},
         fmt::format("SELECT array_sort(array_agg(c0) {}) FROM tmp", filter),
         makeConfig(ignoreNulls));
-    testAggregationsWithCompanion(
-        vectors,
-        [](auto& /*builder*/) {},
-        {},
-        {fmt::format("{}(c0)", functionName)},
-        {{INTEGER()}},
-        {"array_sort(a0)"},
-        fmt::format("SELECT array_sort(array_agg(c0) {}) FROM tmp", filter),
-        makeConfig(ignoreNulls));
+    if (testCompanionFunctions) {
+      testAggregationsWithCompanion(
+          vectors,
+          [](auto& /*builder*/) {},
+          {},
+          {fmt::format("{}(c0)", functionName)},
+          {{INTEGER()}},
+          {"array_sort(a0)"},
+          fmt::format("SELECT array_sort(array_agg(c0) {}) FROM tmp", filter),
+          makeConfig(ignoreNulls));
+    }
   };
 
   testFunction("array_agg", true);
   testFunction("array_agg", false);
+  testFunction("\"$internal$array_agg\"", false, false);
   testFunction("simple_array_agg", false);
 }
 
 TEST_F(ArrayAggTest, globalNoData) {
   auto testFunction = [this](
-                          const std::string& functionName, bool ignoreNulls) {
+                          const std::string& functionName,
+                          bool ignoreNulls,
+                          bool testCompanionFunctions = true) {
     auto data = makeRowVector(ROW({"c0"}, {INTEGER()}), 0);
     testAggregations(
         {data}, {}, {fmt::format("{}(c0)", functionName)}, "SELECT null");
@@ -251,19 +293,22 @@ TEST_F(ArrayAggTest, globalNoData) {
         {fmt::format("{}(c0)", functionName)},
         fmt::format("SELECT array_agg(c0) {} FROM tmp", filter),
         makeConfig(ignoreNulls));
-    testAggregationsWithCompanion(
-        allNulls,
-        [](auto& /*builder*/) {},
-        {},
-        {fmt::format("{}(c0)", functionName)},
-        {{INTEGER()}},
-        {"array_sort(a0)"},
-        fmt::format("SELECT array_sort(array_agg(c0) {}) FROM tmp", filter),
-        makeConfig(ignoreNulls));
+    if (testCompanionFunctions) {
+      testAggregationsWithCompanion(
+          allNulls,
+          [](auto& /*builder*/) {},
+          {},
+          {fmt::format("{}(c0)", functionName)},
+          {{INTEGER()}},
+          {"array_sort(a0)"},
+          fmt::format("SELECT array_sort(array_agg(c0) {}) FROM tmp", filter),
+          makeConfig(ignoreNulls));
+    }
   };
 
   testFunction("array_agg", true);
   testFunction("array_agg", false);
+  testFunction("\"$internal$array_agg\"", false, false);
   testFunction("simple_array_agg", false);
 }
 
diff --git a/velox/functions/prestosql/aggregates/tests/AverageAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/AverageAggregationTest.cpp
index bda896d0aa737..ffb208c19aa9a 100644
--- a/velox/functions/prestosql/aggregates/tests/AverageAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/AverageAggregationTest.cpp
@@ -18,7 +18,7 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/lib/aggregates/DecimalAggregate.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/parse/TypeResolver.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -33,7 +33,6 @@ class AverageAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
 
     registerSimpleAverageAggregate("simple_avg");
   }
@@ -441,6 +440,11 @@ TEST_F(AverageAggregationTest, decimalAccumulator) {
 }
 
 TEST_F(AverageAggregationTest, avgDecimal) {
+  // Disable incremental aggregation tests because DecimalAggregate doesn't set
+  // StringView::prefix when extracting accumulators, leaving the prefix field
+  // undefined that fails the test.
+  AggregationTestBase::disableTestIncremental();
+
   // Skip testing with TableScan because decimal is not supported in writers.
   auto shortDecimal = makeNullableFlatVector<int64_t>(
       {1'000, 2'000, 3'000, 4'000, 5'000, std::nullopt}, DECIMAL(10, 1));
@@ -451,9 +455,7 @@ TEST_F(AverageAggregationTest, avgDecimal) {
       {"avg(c0)"},
       {},
       {makeRowVector(
-          {makeNullableFlatVector<int64_t>({3'000}, DECIMAL(10, 1))})},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+          {makeNullableFlatVector<int64_t>({3'000}, DECIMAL(10, 1))})});
 
   // Long decimal aggregation
   testAggregations(
@@ -469,9 +471,7 @@ TEST_F(AverageAggregationTest, avgDecimal) {
       {"avg(c0)"},
       {},
       {makeRowVector({makeFlatVector(
-          std::vector<int128_t>{HugeInt::build(10, 300)}, DECIMAL(23, 4))})},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+          std::vector<int128_t>{HugeInt::build(10, 300)}, DECIMAL(23, 4))})});
   // Round-up average.
   testAggregations(
       {makeRowVector(
@@ -480,9 +480,7 @@ TEST_F(AverageAggregationTest, avgDecimal) {
       {"avg(c0)"},
       {},
       {makeRowVector(
-          {makeFlatVector(std::vector<int64_t>{337}, DECIMAL(3, 2))})},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+          {makeFlatVector(std::vector<int64_t>{337}, DECIMAL(3, 2))})});
 
   // The total sum overflows the max int128_t limit.
   std::vector<int128_t> rawVector;
@@ -496,9 +494,7 @@ TEST_F(AverageAggregationTest, avgDecimal) {
       {},
       {makeRowVector({makeFlatVector(
           std::vector<int128_t>{DecimalUtil::kLongDecimalMax},
-          DECIMAL(38, 0))})},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+          DECIMAL(38, 0))})});
   // The total sum underflows the min int128_t limit.
   rawVector.clear();
   auto underFlowTestResult = makeFlatVector(
@@ -511,13 +507,9 @@ TEST_F(AverageAggregationTest, avgDecimal) {
       {},
       {"avg(c0)"},
       {},
-      {makeRowVector({underFlowTestResult})},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      {makeRowVector({underFlowTestResult})});
 
-  // Add more rows to show that average result starts deviating from expected
-  // result with varying row count.
-  // Making sure the error value is consistent.
+  // Add more rows to show that average result is still accurate.
   for (int i = 0; i < 10; ++i) {
     rawVector.push_back(DecimalUtil::kLongDecimalMin);
   }
@@ -526,10 +518,7 @@ TEST_F(AverageAggregationTest, avgDecimal) {
   auto result = assertQueryBuilder.copyResults(pool());
 
   auto actualResult = result->childAt(0)->asFlatVector<int128_t>();
-  ASSERT_NE(actualResult->valueAt(0), underFlowTestResult->valueAt(0));
-  ASSERT_EQ(
-      underFlowTestResult->valueAt(0) - actualResult->valueAt(0),
-      static_cast<int128_t>(-13));
+  ASSERT_EQ(actualResult->valueAt(0), underFlowTestResult->valueAt(0));
 
   // Test constant vector.
   testAggregations(
@@ -538,9 +527,7 @@ TEST_F(AverageAggregationTest, avgDecimal) {
       {"avg(c0)"},
       {},
       {makeRowVector(
-          {makeFlatVector(std::vector<int64_t>{100}, DECIMAL(3, 2))})},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+          {makeFlatVector(std::vector<int64_t>{100}, DECIMAL(3, 2))})});
 
   auto newSize = shortDecimal->size() * 2;
   auto indices = makeIndices(newSize, [&](int row) { return row / 2; });
@@ -553,9 +540,7 @@ TEST_F(AverageAggregationTest, avgDecimal) {
       {"avg(c0)"},
       {},
       {makeRowVector(
-          {makeFlatVector(std::vector<int64_t>{3'000}, DECIMAL(10, 1))})},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+          {makeFlatVector(std::vector<int64_t>{3'000}, DECIMAL(10, 1))})});
 
   // Decimal average aggregation with multiple groups.
   auto inputRows = {
@@ -587,16 +572,14 @@ TEST_F(AverageAggregationTest, avgDecimal) {
           {makeNullableFlatVector<int32_t>({3}),
            makeFlatVector(std::vector<int64_t>{-2498}, DECIMAL(5, 2))})};
 
-  testAggregations(
-      inputRows,
-      {"c0"},
-      {"avg(c1)"},
-      expectedResult,
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations(inputRows, {"c0"}, {"avg(c1)"}, expectedResult);
+
+  AggregationTestBase::enableTestIncremental();
 }
 
 TEST_F(AverageAggregationTest, avgDecimalWithMultipleRowVectors) {
+  AggregationTestBase::disableTestIncremental();
+
   auto inputRows = {
       makeRowVector({makeFlatVector<int64_t>({100, 200}, DECIMAL(5, 2))}),
       makeRowVector({makeFlatVector<int64_t>({300, 400}, DECIMAL(5, 2))}),
@@ -606,13 +589,9 @@ TEST_F(AverageAggregationTest, avgDecimalWithMultipleRowVectors) {
   auto expectedResult = {makeRowVector(
       {makeFlatVector(std::vector<int64_t>{350}, DECIMAL(5, 2))})};
 
-  testAggregations(
-      inputRows,
-      {},
-      {"avg(c0)"},
-      expectedResult,
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations(inputRows, {}, {"avg(c0)"}, expectedResult);
+
+  AggregationTestBase::enableTestIncremental();
 }
 
 TEST_F(AverageAggregationTest, constantVectorOverflow) {
@@ -701,5 +680,28 @@ TEST_F(AverageAggregationTest, companionFunctionsWithNonFlatAndLazyInputs) {
   testFunction("simple_avg");
 }
 
+/// We can get 0 as the count of a group when
+/// try and do a single aggregation over distinct values.
+///  In this case presto returns null as avg and not 'NaN'.
+TEST_F(AverageAggregationTest, zeroCounts) {
+  auto data = makeRowVector(
+      {makeNullableFlatVector<int64_t>({std::nullopt, 1}),
+       makeNullableFlatVector<int64_t>({2, 1}),
+       makeFlatVector<bool>({true, false})});
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<int64_t>({std::nullopt, 1}),
+      makeNullableFlatVector<double>({2.0, std::nullopt}),
+  });
+
+  auto op = PlanBuilder()
+                .values({data})
+                .project({"c0", "c1", "c2"})
+                .singleAggregation({"c0"}, {"avg(distinct c1)"}, {{"c2"}})
+                .planNode();
+
+  assertQuery(op, expected);
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/BitwiseAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/BitwiseAggregationTest.cpp
index f5e8c4feab893..eb7e61837c566 100644
--- a/velox/functions/prestosql/aggregates/tests/BitwiseAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/BitwiseAggregationTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -27,7 +27,6 @@ class BitwiseAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   RowTypePtr rowType_{
diff --git a/velox/functions/prestosql/aggregates/tests/BoolAndOrTest.cpp b/velox/functions/prestosql/aggregates/tests/BoolAndOrTest.cpp
index 0bb28d5443ea1..ef2236d75b0ca 100644
--- a/velox/functions/prestosql/aggregates/tests/BoolAndOrTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/BoolAndOrTest.cpp
@@ -15,7 +15,7 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::functions::aggregate::test;
 using facebook::velox::exec::test::PlanBuilder;
@@ -38,7 +38,6 @@ class BoolAndOrTest : public virtual AggregationTestBase,
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 };
 
diff --git a/velox/functions/prestosql/aggregates/tests/CMakeLists.txt b/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
index ae3d6764c4258..85265e3613eec 100644
--- a/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
@@ -26,6 +26,7 @@ add_executable(
   CentralMomentsAggregationTest.cpp
   ChecksumAggregateTest.cpp
   CountAggregationTest.cpp
+  CountDistinctTest.cpp
   CountIfAggregationTest.cpp
   CovarianceAggregationTest.cpp
   EntropyAggregationTest.cpp
@@ -33,22 +34,20 @@ add_executable(
   HistogramTest.cpp
   Main.cpp
   MapAccumulatorTest.cpp
+  MapAggTest.cpp
+  MapUnionAggregationTest.cpp
+  MapUnionSumTest.cpp
+  MaxSizeForStatsTest.cpp
   MinMaxByAggregationTest.cpp
   MinMaxTest.cpp
   MultiMapAggTest.cpp
   PrestoHasherTest.cpp
+  ReduceAggTest.cpp
   SetAggTest.cpp
   SetUnionTest.cpp
+  SumDataSizeForStatsTest.cpp
   SumTest.cpp
-  MapAggTest.cpp
-  MapUnionAggregationTest.cpp
-  MapUnionSumTest.cpp
-  ReduceAggTest.cpp
-  ValueListTest.cpp
-  VarianceAggregationTest.cpp
-  MaxSizeForStatsTest.cpp
-  CompareTest.cpp
-  SumDataSizeForStatsTest.cpp)
+  VarianceAggregationTest.cpp)
 
 add_test(
   NAME velox_aggregates_test
@@ -65,6 +64,7 @@ target_link_libraries(
   velox_file
   velox_functions_aggregates
   velox_functions_aggregates_test_lib
+  velox_functions_window_test_lib
   velox_functions_test_lib
   velox_functions_prestosql
   velox_functions_lib
@@ -72,6 +72,7 @@ target_link_libraries(
   velox_simple_aggregate
   velox_type
   velox_vector_fuzzer
+  velox_temp_path
   gflags::gflags
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/functions/prestosql/aggregates/tests/CentralMomentsAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/CentralMomentsAggregationTest.cpp
index 5f350c6f38b24..e37539b58ab4b 100644
--- a/velox/functions/prestosql/aggregates/tests/CentralMomentsAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/CentralMomentsAggregationTest.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -29,7 +29,6 @@ class CentralMomentsAggregationTest
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   void testGroupBy(
diff --git a/velox/functions/prestosql/aggregates/tests/ChecksumAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/ChecksumAggregateTest.cpp
index 75f97eaa8b04c..65c8a20a34d8f 100644
--- a/velox/functions/prestosql/aggregates/tests/ChecksumAggregateTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ChecksumAggregateTest.cpp
@@ -16,7 +16,7 @@
 #include <boost/algorithm/string/join.hpp>
 #include "velox/common/encode/Base64.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
 using namespace facebook::velox::exec::test;
@@ -24,25 +24,29 @@ using namespace facebook::velox::functions::aggregate::test;
 
 namespace facebook::velox::aggregate::test {
 
+static constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
+static constexpr double kNaNF = std::numeric_limits<float>::quiet_NaN();
+
 class ChecksumAggregateTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   template <typename T>
   void assertSingleGroupChecksum(
       const std::vector<std::optional<T>>& data,
       const std::string& checksum,
-      const TypePtr& type = CppToType<T>::create()) {
+      const TypePtr& type = CppToType<T>::create(),
+      bool testWithTableScan = true) {
     auto inputVector = makeNullableFlatVector<T>(data, type);
-    assertChecksum(inputVector, checksum);
+    assertChecksum(inputVector, checksum, testWithTableScan);
   }
 
   void assertChecksum(
       VectorPtr inputVector,
-      const std::string& expectedChecksum) {
+      const std::string& expectedChecksum,
+      bool testWithTableScan = true) {
     auto rowVectors = std::vector{makeRowVector({inputVector})};
 
     // DuckDB doesn't have checksum aggregation, so we will just pass in
@@ -117,12 +121,17 @@ TEST_F(ChecksumAggregateTest, doubles) {
   assertSingleGroupChecksum<double>({{}}, "h8rrhbF5N54=");
   assertSingleGroupChecksum<double>({99.9}, "iVY+6I1lKyo=");
   assertSingleGroupChecksum<double>({1, 2, 3}, "AACEg9cR14o=");
+  assertSingleGroupChecksum<double>({kNaN, kNaN, kNaN}, "AACMau93L28=");
+  assertSingleGroupChecksum<double>({{-0.0}}, "AAAAAAAAAAA=");
 
   assertGroupingChecksum<int8_t, double>(
       {'a', 'b', 'a'}, {1, 2, 3}, {"AACEI6XSDyU=", "AAAAYDI/x2U="});
-
   assertGroupingChecksum<int8_t, double>(
       {'a', 'b', 'a', 'a'}, {1, 2, 3, {}}, {"AAAAYDI/x2U=", "h8pvqVZMR8M="});
+  assertGroupingChecksum<int8_t, double>(
+      {1, 1, 2}, {kNaN, kNaN, kNaN}, {"AAAIR0qlH0o=", "AACEI6XSDyU="});
+  assertGroupingChecksum<int8_t, double>(
+      {1, 2}, {0.0, -0.0}, {"AAAAAAAAAAA=", "AAAAAAAAAAA="});
 }
 
 TEST_F(ChecksumAggregateTest, reals) {
@@ -130,12 +139,17 @@ TEST_F(ChecksumAggregateTest, reals) {
   assertSingleGroupChecksum<float>({{}}, "h8rrhbF5N54=");
   assertSingleGroupChecksum<float>({99.9}, "IX/UyPhj6MY=");
   assertSingleGroupChecksum<float>({1, 2, 3}, "b/j7Q4YtV+g=");
+  assertSingleGroupChecksum<float>({kNaNF, kNaNF, kNaNF}, "AmWPYoutLK0=");
+  assertSingleGroupChecksum<float>({{-0.0}}, "AAAAAAAAAAA=");
 
   assertGroupingChecksum<int8_t, float>(
       {'a', 'b', 'a'}, {1, 2, 3}, {"Vswv9sY4wxY=", "GSzMTb/0k9E="});
-
   assertGroupingChecksum<int8_t, float>(
       {'a', 'b', 'a', 'a'}, {1, 2, 3, {}}, {"3ZYbfHiy+rQ=", "GSzMTb/0k9E="});
+  assertGroupingChecksum<int8_t, float>(
+      {1, 1, 2}, {kNaNF, kNaNF, kNaNF}, {"rJhf7Fwec3M=", "Vswvdi6PuTk="});
+  assertGroupingChecksum<int8_t, float>(
+      {1, 2}, {0.0, -0.0}, {"AAAAAAAAAAA=", "AAAAAAAAAAA="});
 }
 
 TEST_F(ChecksumAggregateTest, dates) {
@@ -162,6 +176,98 @@ TEST_F(ChecksumAggregateTest, varchars) {
       {"Thanks \u0020\u007F"_sv}, "oEh7YyEV+dM=");
 }
 
+TEST_F(ChecksumAggregateTest, shortDecimals) {
+  assertSingleGroupChecksum<int64_t>({{}}, "h8rrhbF5N54=", DECIMAL(10, 5));
+  assertSingleGroupChecksum<int64_t>({0}, "AAAAAAAAAAA=", DECIMAL(10, 5));
+  // cast(1 as decimal(10, 5))
+  assertSingleGroupChecksum<int64_t>({100000}, "YD7o6fiAEGY=", DECIMAL(10, 5));
+  // cast(-1 as decimal(10, 5))
+  assertSingleGroupChecksum<int64_t>({-100000}, "oMEXFgd/75k=", DECIMAL(10, 5));
+  // max ShortDecimal: cast(999999999999999999 as DECIMAL(18, 0))
+  assertSingleGroupChecksum<int64_t>(
+      {DecimalUtil::kShortDecimalMax}, "eTXQp+w9eBA=", DECIMAL(18, 0));
+  // min ShortDecimal: cast(-999999999999999999 as DECIMAL(18, 0))
+  assertSingleGroupChecksum<int64_t>(
+      {DecimalUtil::kShortDecimalMin}, "h8ovWBPCh+8=", DECIMAL(18, 0));
+
+  assertSingleGroupChecksum<int64_t>(
+      {DecimalUtil::kShortDecimalMin, DecimalUtil::kShortDecimalMax},
+      "AAAAAAAAAAA=",
+      DECIMAL(18, 0));
+  assertSingleGroupChecksum<int64_t>(
+      {DecimalUtil::kShortDecimalMin, DecimalUtil::kShortDecimalMin},
+      "DpVfsCaED98=",
+      DECIMAL(18, 0));
+  assertSingleGroupChecksum<int64_t>(
+      {DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMax},
+      "8mqgT9l78CA=",
+      DECIMAL(18, 0));
+  assertSingleGroupChecksum<int64_t>(
+      {DecimalUtil::kShortDecimalMax,
+       DecimalUtil::kShortDecimalMax,
+       std::nullopt},
+      "eTWM1Yr1J78=",
+      DECIMAL(18, 0));
+}
+
+TEST_F(ChecksumAggregateTest, longDecimals) {
+  assertSingleGroupChecksum<int128_t>(
+      {{}}, "h8rrhbF5N54=", DECIMAL(20, 5), false);
+  assertSingleGroupChecksum<int128_t>(
+      {0}, "AAAAAAAAAAA=", DECIMAL(20, 5), false);
+  // cast(1 as decimal(20, 5))
+  assertSingleGroupChecksum<int128_t>(
+      {100000}, "H2CwmSkDuAo=", DECIMAL(20, 5), false);
+  // cast(622389231123451.12345 as decimal(20,5))
+  assertSingleGroupChecksum<int128_t>(
+      {HugeInt::build(3, 6898690891216455152)},
+      "HGy5nQVxVXk=",
+      DECIMAL(20, 5),
+      false);
+  // cast(-622389231123451.12345 as decimal(20,5))
+  assertSingleGroupChecksum<int128_t>(
+      {HugeInt::build(18446744073709551612UL, 11548053182493096464UL)},
+      "HGy5nQVxVXk=",
+      DECIMAL(20, 5),
+      false);
+
+  // max longDecimal: cast('99999999999999999999999999999999999999'
+  // as DECIMAL(38, 0))
+  assertSingleGroupChecksum<int128_t>(
+      {DecimalUtil::kLongDecimalMax}, "91XKQU7AXNk=", DECIMAL(38, 0), false);
+
+  // min longDecimal: cast('-99999999999999999999999999999999999999'
+  // as DECIMAL(38, 0))
+  assertSingleGroupChecksum<int128_t>(
+      {DecimalUtil::kLongDecimalMin}, "91XKQU7AXNk=", DECIMAL(38, 0), false);
+
+  assertSingleGroupChecksum<int128_t>(
+      {DecimalUtil::kLongDecimalMin, DecimalUtil::kLongDecimalMax},
+      "7quUg5yAubI=",
+      DECIMAL(38, 0),
+      false);
+
+  assertSingleGroupChecksum<int128_t>(
+      {DecimalUtil::kLongDecimalMin, DecimalUtil::kLongDecimalMin},
+      "7quUg5yAubI=",
+      DECIMAL(38, 0),
+      false);
+
+  assertSingleGroupChecksum<int128_t>(
+      {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMax},
+      "7quUg5yAubI=",
+      DECIMAL(38, 0),
+      false);
+
+  assertSingleGroupChecksum<int128_t>(
+      {DecimalUtil::kLongDecimalMax,
+       DecimalUtil::kLongDecimalMax,
+       std::nullopt},
+      "dXaACU768FA=",
+      DECIMAL(38, 0),
+      false);
+}
+
 TEST_F(ChecksumAggregateTest, arrays) {
   auto arrayVector = makeArrayVector<int64_t>({
       {1, 2},
@@ -264,17 +370,56 @@ TEST_F(ChecksumAggregateTest, globalAggregationNoData) {
 }
 
 TEST_F(ChecksumAggregateTest, timestampWithTimezone) {
-  auto timestamp =
-      makeFlatVector<int64_t>(5, [](auto row) { return 1639426440000; });
-  auto timezone = makeFlatVector<int16_t>(5, [](auto row) { return 0; });
-
-  auto timestampWithTzVector = std::make_shared<RowVector>(
-      pool_.get(),
-      TIMESTAMP_WITH_TIME_ZONE(),
-      BufferPtr(nullptr),
+  auto timestampWithTimezone = makeFlatVector<int64_t>(
       5,
-      std::vector<VectorPtr>{timestamp, timezone});
+      [](auto /* row */) { return pack(1639426440000, 0); },
+      /* isNullAt */ nullptr,
+      TIMESTAMP_WITH_TIME_ZONE());
 
-  assertChecksum(timestampWithTzVector, "jwqENA0VLZY=");
+  assertChecksum(timestampWithTimezone, "jwqENA0VLZY=");
 }
+
+TEST_F(ChecksumAggregateTest, unknown) {
+  auto data = makeAllNullFlatVector<UnknownValue>(100);
+  assertChecksum(data, "vBwbUFiJq80=");
+}
+
+TEST_F(ChecksumAggregateTest, complexVectorWithNulls) {
+  // Create a dictionary on a map vector with null rows.
+  auto baseMap = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: null, 3: 30}",
+  });
+
+  auto dictionarySize = baseMap->size() * 3;
+  // Set bad index for null value.
+  auto indexBuffer = makeIndices(dictionarySize, [baseMap](auto row) {
+    return row % 7 == 0 ? -1000 : row % baseMap->size();
+  });
+  auto nulls = makeNulls(dictionarySize, [](auto row) { return row % 7 == 0; });
+  auto dictionary =
+      BaseVector::wrapInDictionary(nulls, indexBuffer, dictionarySize, baseMap);
+
+  auto row = makeRowVector({dictionary});
+
+  assertChecksum(row, "r4PlPOShD0w=");
+
+  // Create a dictionary on a array vector with null rows.
+  auto baseArray = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, null, 3, 4]",
+  });
+
+  dictionarySize = baseArray->size() * 3;
+  // Set bad index for null value.
+  indexBuffer = makeIndices(dictionarySize, [baseArray](auto row) {
+    return row % 7 == 0 ? -1000 : row % baseArray->size();
+  });
+  nulls = makeNulls(dictionarySize, [](auto row) { return row % 7 == 0; });
+  dictionary = BaseVector::wrapInDictionary(
+      nulls, indexBuffer, dictionarySize, baseArray);
+
+  row = makeRowVector({dictionary});
+
+  assertChecksum(row, "i5mk/hSs+AQ=");
+}
+
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/CompareTest.cpp b/velox/functions/prestosql/aggregates/tests/CompareTest.cpp
deleted file mode 100644
index fff5cfe070c53..0000000000000
--- a/velox/functions/prestosql/aggregates/tests/CompareTest.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-#include "velox/common/base/tests/GTestUtils.h"
-
-#include "velox/functions/prestosql/aggregates/Compare.h"
-#include "velox/vector/tests/utils/VectorTestBase.h"
-
-namespace facebook::velox::aggregate::prestosql::test {
-
-class CompareTest : public testing::Test,
-                    public facebook::velox::test::VectorTestBase {};
-
-TEST_F(CompareTest, array) {
-  auto baseVector = makeArrayVectorFromJson<int32_t>({
-      "null",
-      "[6, 7]",
-      "[2, null]",
-  });
-  DecodedVector decodedVector(*baseVector);
-  const auto* indices = decodedVector.indices();
-
-  for (bool throwOnNestedNulls : {true, false}) {
-    ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
-    ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
-  }
-
-  VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
-      "ARRAY comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
-}
-
-TEST_F(CompareTest, map) {
-  auto baseVector = makeMapVectorFromJson<int32_t, int32_t>({
-      "null",
-      "{4: 7, 1: 2}",
-      "{6: 8, 8: null}",
-  });
-  DecodedVector decodedVector(*baseVector);
-  const auto* indices = decodedVector.indices();
-
-  for (bool throwOnNestedNulls : {true, false}) {
-    ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
-    ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
-  }
-
-  VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
-      "MAP comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
-}
-
-TEST_F(CompareTest, row) {
-  auto baseVector = makeRowVector(
-      {
-          makeFlatVector<StringView>({
-              "a"_sv,
-              "b"_sv,
-              "c"_sv,
-          }),
-          makeNullableFlatVector<StringView>({
-              "aa"_sv,
-              "bb"_sv,
-              std::nullopt,
-          }),
-      },
-      [](vector_size_t row) { return row == 0; });
-  DecodedVector decodedVector(*baseVector);
-  const auto* indices = decodedVector.indices();
-
-  for (bool throwOnNestedNulls : {true, false}) {
-    ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
-    ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
-  }
-
-  VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
-      "ROW comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
-}
-} // namespace facebook::velox::aggregate::prestosql::test
diff --git a/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
index ef07d5dfad0d7..600355ecaf93e 100644
--- a/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
@@ -16,7 +16,7 @@
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -29,7 +29,6 @@ class CountAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   RowTypePtr rowType_{
@@ -154,12 +153,17 @@ TEST_F(CountAggregationTest, mask) {
 }
 
 TEST_F(CountAggregationTest, distinct) {
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
   auto data = makeRowVector({
       makeFlatVector<int16_t>({1, 2, 1, 2, 1, 1, 2, 2}),
       makeFlatVector<int32_t>({1, 1, 1, 2, 1, 1, 1, 2}),
       makeNullableFlatVector<int64_t>(
           {std::nullopt, 1, std::nullopt, 2, std::nullopt, 1, std::nullopt, 1}),
       makeNullConstant(TypeKind::DOUBLE, 8),
+      makeFlatVector<int128_t>({1, 2, 1, 2, 1, 2, 1, 1}, DECIMAL(38, 8)),
+      // Test for NaN equivalence
+      makeFlatVector<double>({kNaN, kNaN, kSNaN, kSNaN, 1, 1, 1, 2}),
   });
   createDuckDbTable({data});
 
@@ -178,6 +182,7 @@ TEST_F(CountAggregationTest, distinct) {
   testGlobal("c1");
   testGlobal("c2");
   testGlobal("c3");
+  testGlobal("c4");
 
   auto plan = PlanBuilder()
                   .values({data})
@@ -214,6 +219,7 @@ TEST_F(CountAggregationTest, distinct) {
   testGroupBy("c1");
   testGroupBy("c2");
   testGroupBy("c3");
+  testGroupBy("c4");
 
   plan = PlanBuilder()
              .values({data})
@@ -264,5 +270,53 @@ TEST_F(CountAggregationTest, distinctMask) {
           "SELECT c0, count(distinct c2) FILTER (WHERE c1) FROM tmp GROUP BY 1");
 }
 
+TEST_F(CountAggregationTest, nans) {
+  // Verify that NaNs with different binary representations are considered
+  // equal.
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+  auto data = makeRowVector(
+      {makeFlatVector<int16_t>({1, 2, 1, 2, 1, 1, 2, 2}),
+       // Column to verify with primitive type input
+       makeFlatVector<double>({kNaN, kNaN, kSNaN, kSNaN, 1, 1, 1, 2}),
+       // Column to verify with complex type input
+       makeRowVector(
+           {makeFlatVector<double>({kNaN, kNaN, kSNaN, kSNaN, 1, 1, 1, 2}),
+            makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 1, 1})})});
+
+  // Global aggregation.
+  auto testGlobal = [&](const std::string& col, const RowVectorPtr& expected) {
+    auto globalAggPlan =
+        PlanBuilder()
+            .values({data})
+            .singleAggregation({}, {fmt::format("count(distinct {})", col)})
+            .planNode();
+    AssertQueryBuilder(globalAggPlan).assertResults(expected);
+  };
+
+  RowVectorPtr expected = makeRowVector({
+      makeFlatVector<int64_t>(std::vector<int64_t>({3})),
+  });
+  testGlobal("c1", expected);
+  testGlobal("c2", expected);
+
+  // Group by.
+  auto testGroupBy = [&](const std::string& col, const RowVectorPtr& expected) {
+    auto groupByPlan =
+        PlanBuilder()
+            .values({data})
+            .singleAggregation({"c0"}, {fmt::format("count(distinct {})", col)})
+            .planNode();
+    AssertQueryBuilder(groupByPlan).assertResults(expected);
+  };
+
+  expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeFlatVector<int64_t>({2, 3}),
+  });
+  testGroupBy("c1", expected);
+  testGroupBy("c2", expected);
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/CountDistinctTest.cpp b/velox/functions/prestosql/aggregates/tests/CountDistinctTest.cpp
new file mode 100644
index 0000000000000..ee8644e792ab4
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/CountDistinctTest.cpp
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions::aggregate::test;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::aggregate::test {
+
+namespace {
+
+class CountDistinctTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    prestosql::registerInternalAggregateFunctions("");
+    AggregationTestBase::SetUp();
+  }
+};
+
+TEST_F(CountDistinctTest, global) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 3, 4, 2, 6, 7}),
+      makeFlatVector<StringView>(
+          {"1", "2", "3", "4", "5", "3", "4", "2", "6", "7"}),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(std::vector<int64_t>{7}),
+  });
+
+  testAggregations(
+      {data}, {}, {"\"$internal$count_distinct\"(c0)"}, {expected});
+  testAggregations(
+      {data}, {}, {"\"$internal$count_distinct\"(c1)"}, {expected});
+
+  // Null inputs.
+  data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {1, 2, std::nullopt, 4, 5, std::nullopt, 4, 2, 6, 7}),
+      makeNullableFlatVector<StringView>(
+          {"1", "2", std::nullopt, "4", "5", std::nullopt, "4", "2", "6", "7"}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int64_t>(std::vector<int64_t>{6}),
+  });
+
+  testAggregations(
+      {data}, {}, {"\"$internal$count_distinct\"(c0)"}, {expected});
+  testAggregations(
+      {data}, {}, {"\"$internal$count_distinct\"(c1)"}, {expected});
+
+  // All inputs are null.
+  data = makeRowVector({
+      makeAllNullFlatVector<int32_t>(1'000),
+      makeAllNullFlatVector<StringView>(1'000),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int64_t>(std::vector<int64_t>{0}),
+  });
+
+  testAggregations(
+      {data}, {}, {"\"$internal$count_distinct\"(c0)"}, {expected});
+  testAggregations(
+      {data}, {}, {"\"$internal$count_distinct\"(c1)"}, {expected});
+}
+
+TEST_F(CountDistinctTest, groupBy) {
+  auto data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2, 2, 1, 2, 1, 2, 1}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 3, 4, 2, 6, 7}),
+      makeFlatVector<StringView>(
+          {"1", "2", "3", "4", "5", "3", "4", "2", "6", "7"}),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeFlatVector<int64_t>({4, 4}),
+  });
+
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"\"$internal$count_distinct\"(c1)"},
+      {expected});
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"\"$internal$count_distinct\"(c2)"},
+      {expected});
+
+  // Null inputs.
+  data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2, 2, 1, 2, 1, 2, 1}),
+      makeNullableFlatVector<int32_t>(
+          {1,
+           std::nullopt,
+           3,
+           std::nullopt,
+           5,
+           std::nullopt,
+           3,
+           std::nullopt,
+           6,
+           1}),
+      makeNullableFlatVector<StringView>(
+          {"1",
+           std::nullopt,
+           "3",
+           std::nullopt,
+           "5",
+           std::nullopt,
+           "3",
+           std::nullopt,
+           "6",
+           "1"}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeFlatVector<int64_t>({1, 3}),
+  });
+
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"\"$internal$count_distinct\"(c1)"},
+      {expected});
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"\"$internal$count_distinct\"(c2)"},
+      {expected});
+
+  // All inputs are null for a group.
+  data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2, 2, 1, 2, 1, 2, 1}),
+      makeNullableFlatVector<int32_t>(
+          {1,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           1}),
+      makeNullableFlatVector<StringView>(
+          {"1",
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           "1"}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeFlatVector<int64_t>({1, 0}),
+  });
+
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"\"$internal$count_distinct\"(c1)"},
+      {expected});
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"\"$internal$count_distinct\"(c2)"},
+      {expected});
+}
+
+TEST_F(CountDistinctTest, globalArray) {
+  auto data = makeRowVector({
+      makeArrayVector<int32_t>({
+          {1, 2, 3},
+          {4, 5},
+          {1, 2, 3},
+          {3, 4, 2, 6, 7},
+          {1, 2, 3},
+          {4, 5},
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>(std::vector<int64_t>{3}),
+  });
+
+  testAggregations(
+      {data}, {}, {"\"$internal$count_distinct\"(c0)"}, {expected});
+}
+
+TEST_F(CountDistinctTest, groupByArray) {
+  auto data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 1, 2, 2, 1}),
+      makeArrayVector<int32_t>({
+          {1, 2, 3},
+          {4, 5},
+          {1, 2, 3},
+          {3, 4, 2, 6, 7},
+          {1, 2, 3},
+          {4, 5},
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeFlatVector<int64_t>({2, 2}),
+  });
+
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"\"$internal$count_distinct\"(c1)"},
+      {expected});
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/CountIfAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/CountIfAggregationTest.cpp
index cdb2de1d7db68..261422c7ca165 100644
--- a/velox/functions/prestosql/aggregates/tests/CountIfAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/CountIfAggregationTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
 
 using namespace facebook::velox::exec::test;
@@ -26,7 +26,6 @@ class CountIfAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   RowTypePtr rowType_{
diff --git a/velox/functions/prestosql/aggregates/tests/CovarianceAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/CovarianceAggregationTest.cpp
index fb50df123a82f..bc851ff45ecc9 100644
--- a/velox/functions/prestosql/aggregates/tests/CovarianceAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/CovarianceAggregationTest.cpp
@@ -15,7 +15,7 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -28,7 +28,6 @@ class CovarianceAggregationTest
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   void testGroupBy(const std::string& aggName, const RowVectorPtr& data) {
@@ -146,6 +145,40 @@ TEST_P(CovarianceAggregationTest, floatSomeNulls) {
   testDistinctGroupBy(aggName, data);
 }
 
+TEST_P(CovarianceAggregationTest, allSameValue) {
+  vector_size_t size = 1'000;
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(size, [](auto row) { return row % 7; }),
+      makeFlatVector<float>(size, [](auto row) { return 1; }),
+      makeFlatVector<float>(size, [](auto row) { return 2; }),
+  });
+
+  createDuckDbTable({data});
+
+  auto aggName = GetParam();
+  testGlobalAgg(aggName, data);
+  testGroupBy(aggName, data);
+  testDistinctGlobalAgg(aggName, data);
+  testDistinctGroupBy(aggName, data);
+}
+
+TEST_P(CovarianceAggregationTest, constantY) {
+  vector_size_t size = 1'000;
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(size, [](auto row) { return row % 7; }),
+      makeFlatVector<float>(size, [](auto /*row*/) { return 1; }),
+      makeFlatVector<float>(size, [](auto row) { return row * 0.2; }),
+  });
+
+  createDuckDbTable({data});
+
+  auto aggName = GetParam();
+  testGlobalAgg(aggName, data);
+  testGroupBy(aggName, data);
+  testDistinctGlobalAgg(aggName, data);
+  testDistinctGroupBy(aggName, data);
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     CovarianceAggregationTest,
     CovarianceAggregationTest,
@@ -154,5 +187,12 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
         "covar_pop",
         "corr",
         "regr_intercept",
-        "regr_slope"));
+        "regr_slope",
+        "regr_count",
+        "regr_avgy",
+        "regr_avgx",
+        "regr_sxy",
+        "regr_sxx",
+        "regr_syy",
+        "regr_r2"));
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/EntropyAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/EntropyAggregationTest.cpp
index 354176e3c6c3c..bf37188be5e0a 100644
--- a/velox/functions/prestosql/aggregates/tests/EntropyAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/EntropyAggregationTest.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -29,7 +29,6 @@ class EntropyAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   void testGroupByAgg(
@@ -172,5 +171,34 @@ TEST_F(EntropyAggregationTest, mayHaveNulls) {
   testAggregations({data}, {"c0"}, {"entropy(c1)"}, {"a0"}, {expectedResult});
 }
 
+TEST_F(EntropyAggregationTest, allNulls) {
+  auto data = makeRowVector({makeAllNullFlatVector<int64_t>(10)});
+  auto expectedResult = makeRowVector({makeConstant(0.0, 1)});
+  testAggregations({data}, {}, {"entropy(c0)"}, {expectedResult});
+
+  data = makeRowVector(
+      {makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2}),
+       makeNullableFlatVector<int32_t>(
+           {1, 1, std::nullopt, std::nullopt, std::nullopt, std::nullopt})});
+  expectedResult = makeRowVector({makeFlatVector<double>({1.0, 0.0})});
+  testAggregations({data}, {"c0"}, {"entropy(c1)"}, {"a0"}, {expectedResult});
+}
+
+TEST_F(EntropyAggregationTest, largeConstant) {
+  auto data =
+      makeRowVector({makeConstant(std::numeric_limits<int64_t>::max(), 10)});
+
+  auto expectedResult = makeRowVector(
+      {makeFlatVector<double>(std::vector<double>{3.3219280948873693})});
+  testAggregations({data}, {}, {"entropy(c0)"}, {expectedResult});
+
+  data = makeRowVector(
+      {makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2}),
+       makeConstant(std::numeric_limits<int64_t>::max(), 10)});
+  expectedResult = makeRowVector(
+      {makeFlatVector<double>({1.5849625007211632, 1.5849625007211632})});
+  testAggregations({data}, {"c0"}, {"entropy(c1)"}, {"a0"}, {expectedResult});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp b/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
index 6ac8f4198bb5d..9a6a46dcd1199 100644
--- a/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
@@ -17,7 +17,7 @@
 #include <cmath>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::functions::aggregate::test;
@@ -30,22 +30,22 @@ class GeometricMeanTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 };
 
-double geometricMean(
+template <typename T>
+T geometricMean(
     int32_t start,
     int32_t end,
     int32_t steps,
-    std::function<double(int32_t)> valueConverter) {
+    std::function<T(int32_t)> valueConverter) {
   double logSum = 0;
   int64_t count = 0;
   for (int32_t i = start; i < end; i += steps) {
     logSum += std::log(valueConverter(i));
     count++;
   }
-  return std::exp(logSum / count);
+  return static_cast<T>(std::exp(logSum / count));
 }
 
 TEST_F(GeometricMeanTest, globalEmpty) {
@@ -67,7 +67,7 @@ TEST_F(GeometricMeanTest, globalNulls) {
   testAggregations({data}, {}, {"geometric_mean(c0)"}, "SELECT NULL");
 
   auto expected = makeRowVector({
-      makeConstant(geometricMean(1, 100, 2, folly::identity), 1),
+      makeConstant(geometricMean<double>(1, 100, 2, folly::identity), 1),
   });
 
   testAggregations({data}, {}, {"geometric_mean(c1)"}, {expected});
@@ -80,7 +80,7 @@ TEST_F(GeometricMeanTest, globalIntegers) {
 
   auto expected = makeRowVector({
       makeFlatVector(std::vector<double>{
-          geometricMean(1, 100, 1, [](int32_t i) { return i / 7; }),
+          geometricMean<double>(1, 100, 1, [](int32_t i) { return i / 7; }),
       }),
   });
 
@@ -109,7 +109,7 @@ TEST_F(GeometricMeanTest, groupByNulls) {
       makeFlatVector<double>(
           10,
           [](auto row) {
-            return geometricMean(
+            return geometricMean<double>(
                 1, 10, 2, [&](int32_t i) { return row * 10 + i; });
           },
           [](auto row) { return row == 3; }),
@@ -129,7 +129,7 @@ TEST_F(GeometricMeanTest, groupByIntegers) {
       makeFlatVector<double>(
           10,
           [](auto row) {
-            return geometricMean(
+            return geometricMean<double>(
                 0, 10, 1, [&](int32_t i) { return row * 10 + i; });
           }),
   });
@@ -143,8 +143,8 @@ TEST_F(GeometricMeanTest, globalDoubles) {
   });
 
   auto expected = makeRowVector({
-      makeFlatVector(std::vector<double>{
-          geometricMean(0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
+      makeFlatVector(std::vector<double>{geometricMean<double>(
+          0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
   });
 
   testAggregations({data}, {}, {"geometric_mean(c0)"}, {expected});
@@ -161,7 +161,39 @@ TEST_F(GeometricMeanTest, groupByDoubles) {
       makeFlatVector<double>(
           10,
           [](auto row) {
-            return geometricMean(
+            return geometricMean<double>(
+                0, 10, 1, [&](int32_t i) { return row + i * 0.1; });
+          }),
+  });
+
+  testAggregations({data}, {"c0"}, {"geometric_mean(c1)"}, {expected});
+}
+
+TEST_F(GeometricMeanTest, globalReals) {
+  auto data = makeRowVector({
+      makeFlatVector<float>(100, [](auto row) { return row * 0.1 / 7; }),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector(std::vector<float>{geometricMean<float>(
+          0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
+  });
+
+  testAggregations({data}, {}, {"geometric_mean(c0)"}, {expected});
+}
+
+TEST_F(GeometricMeanTest, groupByReals) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row / 10; }),
+      makeFlatVector<float>(100, [](auto row) { return row * 0.1; }),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
+      makeFlatVector<float>(
+          10,
+          [](auto row) {
+            return geometricMean<float>(
                 0, 10, 1, [&](int32_t i) { return row + i * 0.1; });
           }),
   });
@@ -185,7 +217,7 @@ TEST_F(GeometricMeanTest, groupByMultipleBatches) {
       makeFlatVector<double>(
           10,
           [](auto row) {
-            return geometricMean(
+            return geometricMean<double>(
                 0, 10, 1, [&](int32_t i) { return row * 10 + i; });
           }),
   });
diff --git a/velox/functions/prestosql/aggregates/tests/HistogramTest.cpp b/velox/functions/prestosql/aggregates/tests/HistogramTest.cpp
index 5fe6cdd399f19..a93bbbf78d96e 100644
--- a/velox/functions/prestosql/aggregates/tests/HistogramTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/HistogramTest.cpp
@@ -13,8 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/RowContainer.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
@@ -28,7 +31,6 @@ class HistogramTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   void testHistogramWithDuck(
@@ -145,9 +147,7 @@ TEST_F(HistogramTest, groupByTimestamp) {
       num, [](vector_size_t row) { return row % 3; }, nullEvery(4));
   auto vector2 = makeFlatVector<Timestamp>(
       num,
-      [](vector_size_t row) {
-        return Timestamp{row % 2, 17'123'456};
-      },
+      [](vector_size_t row) { return Timestamp{row % 2, 17'123'456}; },
       nullEvery(5));
 
   auto expected = makeRowVector(
@@ -234,9 +234,7 @@ TEST_F(HistogramTest, globalTimestamp) {
   vector_size_t num = 10;
   auto vector = makeFlatVector<Timestamp>(
       num,
-      [](vector_size_t row) {
-        return Timestamp{row % 4, 100};
-      },
+      [](vector_size_t row) { return Timestamp{row % 4, 100}; },
       nullEvery(7));
 
   auto expected = makeRowVector({makeMapVector<Timestamp, int64_t>(
@@ -307,5 +305,124 @@ TEST_F(HistogramTest, globalString) {
   testGlobalHistogramWithDuck(data);
 }
 
+TEST_F(HistogramTest, globalNaNs) {
+  // Verify that NaNs with different binary representations are considered equal
+  // and deduplicated.
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+  auto vector = makeFlatVector<double>({1, kNaN, kSNaN, 2, 3, kNaN, kSNaN, 3});
+
+  auto expected = makeRowVector({makeMapVectorFromJson<double, int64_t>({
+      "{1: 1, 2: 1, 3: 2, NaN: 4}",
+  })});
+
+  testHistogram("histogram(c1)", {}, vector, vector, expected);
+}
+
+TEST_F(HistogramTest, arrays) {
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[1, 2]",
+          "[]",
+          "[1, 2]",
+          "[]",
+          "[1, null, 2, null]",
+          "[1, null, 2, null]",
+          "[]",
+          "[1, null, 2, null]",
+          "null",
+          "[1, null, 2, null]",
+          "null",
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeMapVector(
+          std::vector<vector_size_t>{0},
+          makeArrayVectorFromJson<int32_t>({
+              "[1, 2, 3]",
+              "[1, 2]",
+              "[]",
+              "[1, null, 2, null]",
+          }),
+          makeFlatVector<int64_t>({1, 2, 3, 4})),
+  });
+
+  testAggregations({input}, {}, {"histogram(c1)"}, {expected});
+
+  expected = makeRowVector({
+      makeMapVector(
+          std::vector<vector_size_t>{0},
+          makeArrayVectorFromJson<int32_t>({
+              "[1, 2, 3]",
+              "[1, 2]",
+              "[]",
+              "[1, null, 2, null]",
+          }),
+          makeFlatVector<int64_t>({3, 6, 9, 12})),
+  });
+  testAggregations({input, input, input}, {}, {"histogram(c1)"}, {expected});
+
+  // Group by.
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1}),
+      makeMapVector(
+          std::vector<vector_size_t>{0, 3},
+          makeArrayVectorFromJson<int32_t>({
+              // 1st map.
+              "[1, 2, 3]",
+              "[]",
+              "[1, null, 2, null]",
+              // 2nd map.
+              "[1, 2]",
+              "[]",
+              "[1, null, 2, null]",
+          }),
+          makeFlatVector<int64_t>({1, 2, 3, 2, 1, 1})),
+  });
+  testAggregations({input}, {"c0"}, {"histogram(c1)"}, {expected});
+
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1}),
+      makeMapVector(
+          std::vector<vector_size_t>{0, 3},
+          makeArrayVectorFromJson<int32_t>({
+              // 1st map.
+              "[1, 2, 3]",
+              "[]",
+              "[1, null, 2, null]",
+              // 2nd map.
+              "[1, 2]",
+              "[]",
+              "[1, null, 2, null]",
+          }),
+          makeFlatVector<int64_t>({3, 6, 9, 6, 3, 3})),
+  });
+  testAggregations(
+      {input, input, input}, {"c0"}, {"histogram(c1)"}, {expected});
+}
+
+TEST_F(HistogramTest, unknown) {
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row % 2; }),
+      makeAllNullFlatVector<UnknownValue>(100),
+  });
+
+  auto expected = makeRowVector({
+      BaseVector::createNullConstant(MAP(UNKNOWN(), BIGINT()), 1, pool()),
+  });
+
+  testAggregations({input}, {}, {"histogram(c1)"}, {expected});
+
+  expected = makeRowVector({
+      makeFlatVector<int32_t>({0, 1}),
+      BaseVector::createNullConstant(MAP(UNKNOWN(), BIGINT()), 2, pool()),
+  });
+
+  testAggregations({input}, {"c0"}, {"histogram(c1)"}, {expected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/Main.cpp b/velox/functions/prestosql/aggregates/tests/Main.cpp
index 684d28a087971..3b55575663ed0 100644
--- a/velox/functions/prestosql/aggregates/tests/Main.cpp
+++ b/velox/functions/prestosql/aggregates/tests/Main.cpp
@@ -18,6 +18,6 @@
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init(&argc, &argv, false);
   return RUN_ALL_TESTS();
 }
diff --git a/velox/functions/prestosql/aggregates/tests/MapAccumulatorTest.cpp b/velox/functions/prestosql/aggregates/tests/MapAccumulatorTest.cpp
index f26f166f55331..a4c89eb63d220 100644
--- a/velox/functions/prestosql/aggregates/tests/MapAccumulatorTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MapAccumulatorTest.cpp
@@ -23,6 +23,11 @@ namespace {
 
 class MapAccumulatorTest : public testing::Test, public test::VectorTestBase {
  protected:
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   // Takes a vector of unique keys and a matching vector of non-null values.
   template <typename K>
   void test(const VectorPtr& uniqueKeys, const VectorPtr& values) {
diff --git a/velox/functions/prestosql/aggregates/tests/MapAggTest.cpp b/velox/functions/prestosql/aggregates/tests/MapAggTest.cpp
index cdc119d137e4f..bcc68c913d24a 100644
--- a/velox/functions/prestosql/aggregates/tests/MapAggTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MapAggTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
@@ -28,7 +28,6 @@ class MapAggTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 };
 
@@ -126,8 +125,6 @@ TEST_F(MapAggTest, groupByWithNullValues) {
 }
 
 TEST_F(MapAggTest, groupByWithDuplicates) {
-  disallowInputShuffle();
-
   auto data = makeRowVector({
       makeFlatVector<int32_t>({0, 0, 1, 1, 2, 2, 3, 3, 4, 4}),
       makeFlatVector<int32_t>({0, 0, 1, 1, 2, 2, 3, 3, 4, 4}),
@@ -150,13 +147,7 @@ TEST_F(MapAggTest, groupByWithDuplicates) {
 
   // We don't test with TableScan because when there are duplicate keys in
   // different splits, the result is non-deterministic.
-  testAggregations(
-      vectors,
-      {"c0"},
-      {"map_agg(c1, c2)"},
-      {expectedResult},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations(vectors, {"c0"}, {"map_agg(c1, c2)"}, {expectedResult});
 }
 
 TEST_F(MapAggTest, groupByNoData) {
@@ -310,13 +301,7 @@ TEST_F(MapAggTest, globalDuplicateKeys) {
 
   // We don't test with TableScan because when there are duplicate keys in
   // different splits, the result is non-deterministic.
-  testAggregations(
-      vectors,
-      {},
-      {"map_agg(c0, c1)"},
-      {expectedResult},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations(vectors, {}, {"map_agg(c0, c1)"}, {expectedResult});
 }
 
 /// Reproduces the bug reported in
@@ -365,6 +350,19 @@ TEST_F(MapAggTest, selectiveMaskWithDuplicates) {
   assertQuery(plan, {expectedResult});
 }
 
+TEST_F(MapAggTest, unknownKey) {
+  auto data = makeRowVector({
+      makeFlatVector<int8_t>({1, 2, 1, 2, 1, 2, 1, 2, 1, 2}),
+      makeAllNullFlatVector<UnknownValue>(10),
+      makeConstant<int32_t>(123, 10),
+  });
+
+  testAggregations(
+      {data}, {"c0"}, {"map_agg(c1, c2)"}, "VALUES (1, NULL), (2, NULL)");
+
+  testAggregations({data}, {}, {"map_agg(c1, c2)"}, "VALUES (NULL)");
+}
+
 TEST_F(MapAggTest, stringLifeCycle) {
   vector_size_t num = 10;
   std::vector<std::string> s(num);
@@ -484,5 +482,74 @@ TEST_F(MapAggTest, rowCheckNull) {
       "ROW comparison not supported for values that contain nulls");
 }
 
+TEST_F(MapAggTest, nans) {
+  // Verify that NaNs with different binary representations are considered equal
+  // and deduplicated when used as keys in the output map.
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+
+  // Global Aggregation, Primitive type
+  auto data = makeRowVector(
+      {makeFlatVector<double>({1, kNaN, kSNaN, 2, 3, kNaN, kSNaN, 3}),
+       makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8}),
+       makeFlatVector<int32_t>({1, 1, 1, 1, 2, 2, 2, 2})});
+
+  auto expectedResult = makeRowVector({
+      makeMapVectorFromJson<double, int32_t>({
+          "{ 1: 1, 2: 4, 3: 5, NaN: 2}",
+      }),
+  });
+
+  testAggregations({data}, {}, {"map_agg(c0, c1)"}, {expectedResult});
+
+  // Group by Aggregation, Primitive type
+  expectedResult = makeRowVector(
+      {makeMapVectorFromJson<double, int32_t>(
+           {"{ 1: 1, 2: 4, NaN: 2}", "{ 3: 5, NaN: 6}"}),
+       makeFlatVector<int32_t>({1, 2})});
+
+  testAggregations(
+      {data}, {"c2"}, {"map_agg(c0, c1)"}, {"a0", "c2"}, {expectedResult});
+
+  // Global Aggregation, Complex type(Row)
+  // The complex input values that are to be used as keys are {1, 1}, {NaN, 2},
+  // {NaN, 2}, {2, 4}, {3, 5}, {NaN, 2}, {NaN, 2}, {3, 5}
+  data = makeRowVector(
+      {makeRowVector(
+           {makeFlatVector<double>({1, kNaN, kSNaN, 2, 3, kNaN, kSNaN, 3}),
+            makeFlatVector<int32_t>({1, 2, 2, 4, 5, 2, 2, 5})}),
+       makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8}),
+       makeFlatVector<int32_t>({1, 1, 1, 1, 2, 2, 2, 2})});
+
+  // The expected result is
+  // [{"key":[1,1],"value":1},{"key":[2,4],"value":4},{"key":[3,5],"value":5},
+  // {"key":["NaN",2],"value":2}]
+  expectedResult = makeRowVector({makeMapVector(
+      {0},
+      makeRowVector(
+          {makeFlatVector<double>({1, 2, 3, kNaN}),
+           makeFlatVector<int32_t>({1, 4, 5, 2})}),
+      makeFlatVector<int32_t>({1, 4, 5, 2}))});
+
+  testAggregations({data}, {}, {"map_agg(c0, c1)"}, {expectedResult});
+
+  // Group by Aggregation, Complex type(Row)
+  // The expected result is
+  // [{"key":[1,1],"value":1},{"key":[2,4],"value":4},
+  //  {"key":["NaN",2],"value":2}] | 1
+  // [{"key":[3,5],"value":5},{"key":["NaN",2],"value":6}] | 2
+  expectedResult = makeRowVector(
+      {makeMapVector(
+           {0, 3},
+           makeRowVector(
+               {makeFlatVector<double>({1, 2, kNaN, 3, kNaN}),
+                makeFlatVector<int32_t>({1, 4, 2, 5, 2})}),
+           makeFlatVector<int32_t>({1, 4, 2, 5, 6})),
+       makeFlatVector<int32_t>({1, 2})});
+
+  testAggregations(
+      {data}, {"c2"}, {"map_agg(c0, c1)"}, {"a0", "c2"}, {expectedResult});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/MapUnionAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/MapUnionAggregationTest.cpp
index 12e66c4174b89..f0b560b7e6918 100644
--- a/velox/functions/prestosql/aggregates/tests/MapUnionAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MapUnionAggregationTest.cpp
@@ -15,7 +15,7 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
@@ -278,20 +278,8 @@ TEST_F(MapUnionTest, unknownKeysAndValues) {
       makeMapVector<UnknownValue, UnknownValue>({{}, {}}),
   });
 
-  testAggregations(
-      {data},
-      {},
-      {"map_union(c1)"},
-      {expectedGlobalResult},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
-  testAggregations(
-      {data},
-      {"c0"},
-      {"map_union(c1)"},
-      {expectedGroupByResult},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations({data}, {}, {"map_union(c1)"}, {expectedGlobalResult});
+  testAggregations({data}, {"c0"}, {"map_union(c1)"}, {expectedGroupByResult});
 
   // map_union over non-empty map(T, unknown) where T is not unknown is allowed.
   data = makeRowVector({
@@ -329,20 +317,8 @@ TEST_F(MapUnionTest, unknownKeysAndValues) {
       }),
   });
 
-  testAggregations(
-      {data},
-      {},
-      {"map_union(c1)"},
-      {expectedGlobalResult},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
-  testAggregations(
-      {data},
-      {"c0"},
-      {"map_union(c1)"},
-      {expectedGroupByResult},
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations({data}, {}, {"map_union(c1)"}, {expectedGlobalResult});
+  testAggregations({data}, {"c0"}, {"map_union(c1)"}, {expectedGroupByResult});
 
   // map_union over non-emtpy map(unknown, T) is not allowed.
   data = makeRowVector({
@@ -369,5 +345,77 @@ TEST_F(MapUnionTest, unknownKeysAndValues) {
       AssertQueryBuilder(plan).copyResults(pool()), "map key cannot be null");
 }
 
+TEST_F(MapUnionTest, nans) {
+  // Verify that NaNs with different binary representations are considered equal
+  // and deduplicated when used as keys in the output map.
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+
+  // Global Aggregation, Primitive type
+  auto data = makeRowVector(
+      {makeMapVectorFromJson<double, int32_t>(
+           {"{1: 1}", "{2: 2}", "{NaN: 4}", "{3: 3}", "{NaN: 5}", "{NaN: 6}"}),
+       makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2})});
+
+  auto expectedResult = makeRowVector({
+      makeMapVectorFromJson<double, int32_t>({
+          "{ 1: 1, 2: 2, 3: 3, NaN: 4}",
+      }),
+  });
+
+  testAggregations({data}, {}, {"map_union(c0)"}, {expectedResult});
+
+  // Group by Aggregation, Primitive type
+  expectedResult = makeRowVector(
+      {makeMapVectorFromJson<double, int32_t>(
+           {"{ 1: 1, 2: 2, NaN: 4}", "{ 3: 3, NaN: 5}"}),
+       makeFlatVector<int32_t>({1, 2})});
+
+  testAggregations(
+      {data}, {"c1"}, {"map_union(c0)"}, {"a0", "c1"}, {expectedResult});
+
+  // Global Aggregation, Complex type(Row)
+  // The complex input values are:
+  // [{"key":[1,1],"value":1},{"key":["NaN",2],"value":2},{"key":[2,4],"value":3},{"key":[3,5],"value":4},
+  // {"key":["NaN",2],"value":5}, {"key":["NaN",2],"value":5}]
+  data = makeRowVector(
+      {makeMapVector(
+           {0, 1, 2, 3, 4, 5},
+           makeRowVector(
+               {makeFlatVector<double>({1, kSNaN, 2, 3, kNaN, kSNaN}),
+                makeFlatVector<int32_t>({1, 2, 4, 5, 2, 2})}),
+           makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6})),
+       makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2})});
+
+  // The expected result is
+  // [{"key":[1,1],"value":1},{"key":[2,4],"value":3},{"key":[3,5],"value":4},
+  // {"key":["NaN",2],"value":2}]
+  expectedResult = makeRowVector({makeMapVector(
+      {0},
+      makeRowVector(
+          {makeFlatVector<double>({1, 2, 3, kNaN}),
+           makeFlatVector<int32_t>({1, 4, 5, 2})}),
+      makeFlatVector<int32_t>({1, 3, 4, 2}))});
+
+  testAggregations({data}, {}, {"map_union(c0)"}, {expectedResult});
+
+  // Group by Aggregation, Complex type(Row)
+  // The expected result is
+  // [{"key":[1,1],"value":1},{"key":[2,4],"value":3},
+  //  {"key":["NaN",2],"value":2}] | 1
+  // [{"key":[3,5],"value":4},{"key":["NaN",2],"value":5}] | 2
+  expectedResult = makeRowVector(
+      {makeMapVector(
+           {0, 3},
+           makeRowVector(
+               {makeFlatVector<double>({1, 2, kNaN, 3, kNaN}),
+                makeFlatVector<int32_t>({1, 4, 2, 5, 2})}),
+           makeFlatVector<int32_t>({1, 3, 2, 4, 5})),
+       makeFlatVector<int32_t>({1, 2})});
+
+  testAggregations(
+      {data}, {"c1"}, {"map_union(c0)"}, {"a0", "c1"}, {expectedResult});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/MapUnionSumTest.cpp b/velox/functions/prestosql/aggregates/tests/MapUnionSumTest.cpp
index a5fff59b25dd4..1f6bd75371f3e 100644
--- a/velox/functions/prestosql/aggregates/tests/MapUnionSumTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MapUnionSumTest.cpp
@@ -15,7 +15,7 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
@@ -378,5 +378,65 @@ TEST_F(MapUnionSumTest, groupByVarcharKey) {
   testAggregations({data}, {"c0"}, {"map_union_sum(c1)"}, {expected});
 }
 
+TEST_F(MapUnionSumTest, floatingPointKeys) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 1, 2, 1, 1, 2, 2}),
+      makeMapVectorFromJson<float, int64_t>({
+          "{1.1: 10, 1.2: 20, 1.3: 30}",
+          "{2.1: 10, 1.2: 20, 2.3: 30}",
+          "{3.1: 10, 1.2: 20, 2.3: 30}",
+          "{}",
+          "null",
+          "{4.1: 10, 4.2: 20, 2.3: 30}",
+          "{5.1: 10, 4.2: 20, 2.3: 30}",
+          "{6.1: 10, 6.2: 20, 6.3: 30}",
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeMapVectorFromJson<float, int64_t>({
+          "{1.1: 10, 1.2: 60, 1.3: 30, 2.1: 10, 2.3: 120, 3.1: 10, 4.1: 10, "
+          "4.2: 40, 5.1: 10, 6.1: 10, 6.2: 20, 6.3: 30}",
+      }),
+  });
+
+  testAggregations({data}, {}, {"map_union_sum(c1)"}, {expected});
+}
+
+TEST_F(MapUnionSumTest, nanKeys) {
+  // Verify that NaNs with different binary representations are considered equal
+  // and deduplicated when used as keys in the output map.
+  constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
+  constexpr double kSNaN = std::numeric_limits<double>::signaling_NaN();
+
+  // Global aggregation.
+  auto data = makeRowVector(
+      {makeNullableMapVector<double, int32_t>({
+           {{{kSNaN, 10}, {2, 20}}},
+           {{{kNan, 1}, {3, 30}, {5, 50}}},
+           {{{3, 30}, {kSNaN, 4}, {1, 30}}},
+       }),
+       makeFlatVector<int32_t>({1, 1, 2})});
+
+  auto expected = makeRowVector({
+      makeMapVector<double, int32_t>({
+          {{1, 30}, {2, 20}, {3, 60}, {5, 50}, {kNan, 15}},
+      }),
+  });
+
+  testAggregations({data}, {}, {"map_union_sum(c0)"}, {expected});
+
+  // Group by aggregation.
+  expected = makeRowVector(
+      {makeMapVector<double, int32_t>({
+           {{2, 20}, {3, 30}, {5, 50}, {kNan, 11}},
+           {{1, 30}, {3, 30}, {kNan, 4}},
+       }),
+       makeFlatVector<int32_t>({1, 2})});
+
+  testAggregations(
+      {data}, {"c1"}, {"map_union_sum(c0)"}, {"a0", "c1"}, {expected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/MaxSizeForStatsTest.cpp b/velox/functions/prestosql/aggregates/tests/MaxSizeForStatsTest.cpp
index 254237027bdf7..7990d774eea11 100644
--- a/velox/functions/prestosql/aggregates/tests/MaxSizeForStatsTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MaxSizeForStatsTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -27,7 +27,6 @@ class MaxSizeForStatsTest : public AggregationTestBase {
  public:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 };
 
@@ -218,7 +217,7 @@ TEST_F(MaxSizeForStatsTest, complexRecursiveGlobalAggregate) {
           createMapOfArraysVector<int8_t, int64_t>({
               {{1, std::nullopt}},
               {{2, {{4, 5, std::nullopt}}}},
-              {{std::nullopt, {{7, 8, 9}}}},
+              {{3, {{7, 8, 9}}}},
           }),
       }),
   })};
@@ -261,7 +260,7 @@ TEST_F(MaxSizeForStatsTest, dictionaryEncodingTest) {
       createMapOfArraysVector<int8_t, int64_t>({
           {{1, std::nullopt}},
           {{2, {{4, 5, std::nullopt}}}},
-          {{std::nullopt, {{7, 8, 9}}}},
+          {{3, {{7, 8, 9}}}},
       }),
   });
   vector_size_t size = 3;
diff --git a/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
index d23c1b29f424a..8f3285b95e15b 100644
--- a/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
@@ -13,14 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#include <fmt/format.h>
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/vector/fuzzer/VectorFuzzer.h"
-
-#include <fmt/format.h>
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -36,7 +36,7 @@ struct TestParam {
   TypeKind comparisonType;
 };
 
-const std::unordered_set<TypeKind> kSupportedTypes = {
+const std::vector<TypeKind> kSupportedTypes = {
     TypeKind::BOOLEAN,
     TypeKind::TINYINT,
     TypeKind::SMALLINT,
@@ -45,12 +45,13 @@ const std::unordered_set<TypeKind> kSupportedTypes = {
     TypeKind::REAL,
     TypeKind::DOUBLE,
     TypeKind::VARCHAR,
-    TypeKind::TIMESTAMP};
+    TypeKind::TIMESTAMP,
+    TypeKind::HUGEINT};
 
 std::vector<TestParam> getTestParams() {
   std::vector<TestParam> params;
-  for (TypeKind valueType : kSupportedTypes) {
-    for (TypeKind comparisonType : kSupportedTypes) {
+  for (auto valueType : kSupportedTypes) {
+    for (auto comparisonType : kSupportedTypes) {
       params.push_back({valueType, comparisonType});
     }
   }
@@ -75,6 +76,9 @@ std::vector<TestParam> getTestParams() {
       case TypeKind::BIGINT:                                         \
         testFunc<valueType, int64_t>();                              \
         break;                                                       \
+      case TypeKind::HUGEINT:                                        \
+        testFunc<valueType, int128_t>();                             \
+        break;                                                       \
       case TypeKind::REAL:                                           \
         testFunc<valueType, float>();                                \
         break;                                                       \
@@ -111,6 +115,9 @@ std::vector<TestParam> getTestParams() {
       case TypeKind::BIGINT:                                    \
         EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int64_t);          \
         break;                                                  \
+      case TypeKind::HUGEINT:                                   \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int128_t);         \
+        break;                                                  \
       case TypeKind::REAL:                                      \
         EXECUTE_TEST_BY_VALUE_TYPE(testFunc, float);            \
         break;                                                  \
@@ -144,6 +151,12 @@ class MinMaxByAggregationTestBase : public AggregationTestBase {
 
   void SetUp() override;
 
+  void TearDown() override {
+    dataVectorsByType_.clear();
+    rowVectors_.clear();
+    AggregationTestBase::TearDown();
+  }
+
   // Build a flat vector with numeric native type of T. The value in the
   // returned flat vector is in ascending order.
   template <typename T>
@@ -189,20 +202,7 @@ class MinMaxByAggregationTestBase : public AggregationTestBase {
       vector_size_t size,
       folly::Range<const int*> values);
 
-  const RowTypePtr rowType_{
-      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9"},
-          {
-              BOOLEAN(),
-              TINYINT(),
-              SMALLINT(),
-              INTEGER(),
-              BIGINT(),
-              REAL(),
-              DOUBLE(),
-              VARCHAR(),
-              DATE(),
-              TIMESTAMP(),
-          })};
+  RowTypePtr rowType_;
   // Specify the number of values in each typed data vector in
   // 'dataVectorsByType_'.
   const int numValues_;
@@ -210,6 +210,21 @@ class MinMaxByAggregationTestBase : public AggregationTestBase {
   std::vector<RowVectorPtr> rowVectors_;
 };
 
+template <>
+FlatVectorPtr<int128_t> MinMaxByAggregationTestBase::buildDataVector(
+    vector_size_t size,
+    folly::Range<const int*> values) {
+  if (values.empty()) {
+    return makeFlatVector<int128_t>(
+        size, [](auto row) { return HugeInt::build(row - 3, row - 3); });
+  } else {
+    VELOX_CHECK_EQ(values.size(), size);
+    return makeFlatVector<int128_t>(size, [&](auto row) {
+      return HugeInt::build(values[row], values[row]);
+    });
+  }
+}
+
 // Build a flat vector with StringView. The value in the returned flat vector
 // is in ascending order.
 template <>
@@ -281,6 +296,8 @@ VectorPtr MinMaxByAggregationTestBase::buildDataVector(
       return buildDataVector<float>(size, values);
     case TypeKind::DOUBLE:
       return buildDataVector<double>(size, values);
+    case TypeKind::HUGEINT:
+      return buildDataVector<int128_t>(size, values);
     case TypeKind::VARCHAR:
       return buildDataVector<StringView>(size, values);
     case TypeKind::TIMESTAMP:
@@ -308,9 +325,15 @@ std::string asSql(bool value) {
 
 void MinMaxByAggregationTestBase::SetUp() {
   AggregationTestBase::SetUp();
-  AggregationTestBase::disallowInputShuffle();
-
-  for (const TypeKind type : kSupportedTypes) {
+  std::vector<TypePtr> supportedTypes;
+  std::vector<std::string> columnNames;
+  int columnId = 0;
+  for (auto kind : kSupportedTypes) {
+    supportedTypes.push_back(createScalarType(kind));
+    columnNames.push_back("c" + std::to_string(columnId++));
+  }
+  rowType_ = ROW(std::move(columnNames), std::move(supportedTypes));
+  for (auto type : kSupportedTypes) {
     switch (type) {
       case TypeKind::BOOLEAN:
         dataVectorsByType_.emplace(type, buildDataVector<bool>(numValues_));
@@ -327,6 +350,9 @@ void MinMaxByAggregationTestBase::SetUp() {
       case TypeKind::BIGINT:
         dataVectorsByType_.emplace(type, buildDataVector<int64_t>(numValues_));
         break;
+      case TypeKind::HUGEINT:
+        dataVectorsByType_.emplace(type, buildDataVector<int128_t>(numValues_));
+        break;
       case TypeKind::REAL:
         dataVectorsByType_.emplace(type, buildDataVector<float>(numValues_));
         break;
@@ -468,9 +494,7 @@ class MinMaxByGlobalByAggregationTest
           {},
           {"min_by(c0, c1)"},
           {},
-          testData.verifyDuckDbSql,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+          testData.verifyDuckDbSql);
     }
   }
 
@@ -566,9 +590,7 @@ class MinMaxByGlobalByAggregationTest
           {},
           {"max_by(c0, c1)"},
           {},
-          testData.verifyDuckDbSql,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+          testData.verifyDuckDbSql);
     }
   }
 };
@@ -618,20 +640,16 @@ TEST_P(
     MinMaxByGlobalByAggregationTest,
     randomMaxByGlobalByWithDistinctCompareValue) {
   if (GetParam().comparisonType == TypeKind::TIMESTAMP ||
-      GetParam().valueType == TypeKind::TIMESTAMP) {
+      GetParam().valueType == TypeKind::TIMESTAMP ||
+      GetParam().comparisonType == TypeKind::BOOLEAN) {
     return;
   }
-  if (GetParam().comparisonType == TypeKind::BOOLEAN) {
-    GTEST_SKIP() << "Boolean comparison type is not supported in this test.";
-  }
 
   // Enable disk spilling test with distinct comparison values.
-  AggregationTestBase::allowInputShuffle();
-
   auto rowType =
       ROW({"c0", "c1"},
-          {fromKindToScalerType(GetParam().valueType),
-           fromKindToScalerType(GetParam().comparisonType)});
+          {createScalarType(GetParam().valueType),
+           createScalarType(GetParam().comparisonType)});
 
   const bool isSmallInt = GetParam().comparisonType == TypeKind::TINYINT ||
       GetParam().comparisonType == TypeKind::SMALLINT;
@@ -654,7 +672,7 @@ TEST_P(
   for (int i = 0; i < kNumBatches; ++i) {
     // Generate a non-lazy vector so that it can be written out as a duckDB
     // table.
-    auto valueVector = fuzzer.fuzz(fromKindToScalerType(GetParam().valueType));
+    auto valueVector = fuzzer.fuzz(createScalarType(GetParam().valueType));
     auto comparisonVector = buildDataVector(
         GetParam().comparisonType,
         kBatchSize,
@@ -860,9 +878,7 @@ class MinMaxByGroupByAggregationTest
           {"c2"},
           {"min_by(c0, c1)"},
           {},
-          testData.verifyDuckDbSql,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+          testData.verifyDuckDbSql);
     }
   }
 
@@ -1013,9 +1029,7 @@ class MinMaxByGroupByAggregationTest
           {"c2"},
           {"max_by(c0, c1)"},
           {},
-          testData.verifyDuckDbSql,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+          testData.verifyDuckDbSql);
     }
   }
 };
@@ -1060,20 +1074,16 @@ TEST_P(
     MinMaxByGroupByAggregationTest,
     randomMinMaxByGroupByWithDistinctCompareValue) {
   if (GetParam().comparisonType == TypeKind::TIMESTAMP ||
-      GetParam().valueType == TypeKind::TIMESTAMP) {
+      GetParam().valueType == TypeKind::TIMESTAMP ||
+      GetParam().comparisonType == TypeKind::BOOLEAN) {
     return;
   }
-  if (GetParam().comparisonType == TypeKind::BOOLEAN) {
-    GTEST_SKIP() << "Boolean comparison type is not supported in this test.";
-  }
 
   // Enable disk spilling test with distinct comparison values.
-  AggregationTestBase::allowInputShuffle();
-
   auto rowType =
       ROW({"c0", "c1", "c2"},
-          {fromKindToScalerType(GetParam().valueType),
-           fromKindToScalerType(GetParam().comparisonType),
+          {createScalarType(GetParam().valueType),
+           createScalarType(GetParam().comparisonType),
            INTEGER()});
 
   const bool isSmallInt = GetParam().comparisonType == TypeKind::TINYINT ||
@@ -1097,7 +1107,7 @@ TEST_P(
   for (int i = 0; i < kNumBatches; ++i) {
     // Generate a non-lazy vector so that it can be written out as a duckDB
     // table.
-    auto valueVector = fuzzer.fuzz(fromKindToScalerType(GetParam().valueType));
+    auto valueVector = fuzzer.fuzz(createScalarType(GetParam().valueType));
     auto groupByVector = makeFlatVector<int32_t>(kBatchSize);
     auto comparisonVector = buildDataVector(
         GetParam().comparisonType,
@@ -1231,19 +1241,6 @@ TEST_F(MinMaxByComplexTypes, mapGroupBy) {
 }
 
 TEST_F(MinMaxByComplexTypes, arrayCompare) {
-  auto data = makeRowVector({
-      makeArrayVector<int64_t>({
-          {1, 2, 3},
-          {4, 5},
-          {6, 7, 8},
-      }),
-      makeNullableArrayVector<int64_t>({
-          {1, 2, 3},
-          {std::nullopt, 2},
-          {6, 7, 8},
-      }),
-  });
-
   auto expected = makeRowVector({
       makeArrayVector<int64_t>({
           {1, 2, 3},
@@ -1252,12 +1249,7 @@ TEST_F(MinMaxByComplexTypes, arrayCompare) {
           {6, 7, 8},
       }),
   });
-
-  VELOX_ASSERT_THROW(
-      testAggregations(
-          {data}, {}, {"min_by(c0, c1)", "max_by(c0, c1)"}, {expected}),
-      "ARRAY comparison not supported for values that contain nulls");
-  data = makeRowVector({
+  auto data = makeRowVector({
       makeArrayVector<int64_t>({
           {1, 2, 3},
           {4, 5},
@@ -1265,7 +1257,7 @@ TEST_F(MinMaxByComplexTypes, arrayCompare) {
       }),
       makeNullableArrayVector<int64_t>({
           {1, 2, 3},
-          {3, std::nullopt, 4},
+          {3, 4, 5},
           {6, 7, 8},
       }),
   });
@@ -1273,18 +1265,14 @@ TEST_F(MinMaxByComplexTypes, arrayCompare) {
       {data}, {}, {"min_by(c0, c1)", "max_by(c0, c1)"}, {expected});
 }
 
-TEST_F(MinMaxByComplexTypes, mapCompare) {
+TEST_F(MinMaxByComplexTypes, rowCompare) {
   auto data = makeRowVector({
       makeArrayVector<int64_t>({
           {1, 2, 3},
           {4, 5},
           {6, 7, 8},
       }),
-      makeNullableMapVector<int64_t, int64_t>({
-          {{{1, 1}, {2, 2}}},
-          {{{1, 1}, {2, std::nullopt}}},
-          {{{4, 50}}},
-      }),
+      makeRowVector({makeNullableFlatVector<int32_t>({1, 2, 3})}),
   });
 
   auto expected = makeRowVector({
@@ -1296,80 +1284,236 @@ TEST_F(MinMaxByComplexTypes, mapCompare) {
       }),
   });
 
-  VELOX_ASSERT_THROW(
-      testAggregations(
-          {data}, {}, {"min_by(c0, c1)", "max_by(c0, c1)"}, {expected}),
-      "MAP comparison not supported for values that contain nulls");
-
-  data = makeRowVector({
-      makeArrayVector<int64_t>({
-          {1, 2, 3},
-          {4, 5},
-          {6, 7, 8},
-      }),
-      makeNullableMapVector<int64_t, int64_t>({
-          {{{1, 1}, {2, 2}}},
-          {{{1, 1}, {2, 3}}},
-          {{{4, 50}}},
-      }),
-  });
   testAggregations(
       {data}, {}, {"min_by(c0, c1)", "max_by(c0, c1)"}, {expected});
 }
 
-TEST_F(MinMaxByComplexTypes, rowCompare) {
+TEST_F(MinMaxByComplexTypes, arrayCheckNulls) {
+  auto batch = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2]",
+          "[6, 7]",
+          "[2, 3]",
+      }),
+      makeFlatVector<int32_t>({1, 2, 3}),
+  });
+
+  auto batchWithNull = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2]",
+          "[6, 7]",
+          "[3, null]",
+      }),
+      makeFlatVector<int32_t>({1, 2, 3}),
+  });
+
+  for (const auto& expr : {"min_by(c0, c1)", "max_by(c0, c1)"}) {
+    testFailingAggregations(
+        {batch, batchWithNull},
+        {},
+        {expr},
+        "ARRAY comparison not supported for values that contain nulls");
+    testFailingAggregations(
+        {batch, batchWithNull},
+        {"c2"},
+        {expr},
+        "ARRAY comparison not supported for values that contain nulls");
+  }
+}
+
+TEST_F(MinMaxByComplexTypes, rowCheckNull) {
+  auto batch = makeRowVector({
+      makeFlatVector<int8_t>({1, 2, 3}),
+      makeRowVector(
+          {makeFlatVector<std::string>({"a", "b", "c"}),
+           makeFlatVector<std::string>({"aa", "bb", "cc"})}),
+      makeFlatVector<int8_t>({1, 2, 3}),
+  });
+
+  auto batchWithNull = makeRowVector({
+      makeFlatVector<int8_t>({1, 2, 3}),
+      makeRowVector({
+          makeFlatVector<std::string>({"a", "b", "c"}),
+          makeNullableFlatVector<std::string>({"aa", std::nullopt, "cc"}),
+      }),
+      makeFlatVector<int8_t>({1, 2, 3}),
+  });
+
+  for (const auto& expr : {"min_by(c0, c1)", "max_by(c0, c1)"}) {
+    testFailingAggregations(
+        {batch, batchWithNull},
+        {},
+        {expr},
+        "ROW comparison not supported for values that contain nulls");
+    testFailingAggregations(
+        {batch, batchWithNull},
+        {"c2"},
+        {expr},
+        "ROW comparison not supported for values that contain nulls");
+  }
+}
+
+TEST_F(MinMaxByComplexTypes, failOnUnorderableType) {
   auto data = makeRowVector({
-      makeArrayVector<int64_t>({
-          {1, 2, 3},
-          {4, 5},
-          {6, 7, 8},
-      }),
-      makeRowVector({makeNullableFlatVector<int32_t>({
-          1,
-          std::nullopt,
-          3,
-      })}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+      makeAllNullMapVector(5, VARCHAR(), BIGINT()),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
   });
 
+  static const std::string kErrorMessage =
+      "Aggregate function signature is not supported";
+  for (const auto& expr : {"min_by(c0, c1)", "min_by(c0, c1)"}) {
+    {
+      auto builder = PlanBuilder().values({data});
+      VELOX_ASSERT_THROW(builder.singleAggregation({}, {expr}), kErrorMessage);
+    }
+
+    {
+      auto builder = PlanBuilder().values({data});
+      VELOX_ASSERT_THROW(
+          builder.singleAggregation({"c2"}, {expr}), kErrorMessage);
+    }
+  }
+}
+
+class MinMaxByUnknownTest : public AggregationTestBase {};
+
+TEST_F(MinMaxByUnknownTest, unknown) {
+  auto data = makeRowVector(
+      {"k", "vn", "cn", "v", "c"},
+      {
+          makeFlatVector<int64_t>({1, 2, 1, 2, 1, 2}),
+          makeAllNullFlatVector<UnknownValue>(6), // value
+          makeAllNullFlatVector<UnknownValue>(6), // compare
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6}), // value
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6}), // compare
+      });
+
+  // Global agg.
   auto expected = makeRowVector({
-      makeArrayVector<int64_t>({
-          {1, 2, 3},
-      }),
-      makeArrayVector<int64_t>({
-          {6, 7, 8},
-      }),
+      makeAllNullFlatVector<UnknownValue>(1),
+      makeAllNullFlatVector<UnknownValue>(1),
   });
 
-  VELOX_ASSERT_THROW(
-      testAggregations(
-          {data}, {}, {"min_by(c0, c1)", "max_by(c0, c1)"}, {expected}),
-      "ROW comparison not supported for values that contain nulls");
+  // Both value and compare are UNKNOWN.
+  testAggregations(
+      {data}, {}, {"min_by(vn, cn)", "max_by(vn, cn)"}, {expected});
 
-  data = makeRowVector({
-      makeArrayVector<int64_t>({
-          {1, 2, 3},
-          {4, 5},
-          {6, 7, 8},
-      }),
-      makeRowVector({makeNullableFlatVector<int32_t>({
-          1,
-          2,
-          3,
-      })}),
+  // Only value is UNKNOWN.
+  testAggregations({data}, {}, {"min_by(vn, c)", "max_by(vn, c)"}, {expected});
+
+  // Only compare is UNKNOWN.
+  expected = makeRowVector({
+      makeAllNullFlatVector<int64_t>(1),
+      makeAllNullFlatVector<int64_t>(1),
   });
+
+  testAggregations({data}, {}, {"min_by(v, cn)", "max_by(v, cn)"}, {expected});
+
+  // Group by.
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeAllNullFlatVector<UnknownValue>(2),
+      makeAllNullFlatVector<UnknownValue>(2),
+  });
+
+  // Both value and compare are UNKNOWN.
   testAggregations(
-      {data}, {}, {"min_by(c0, c1)", "max_by(c0, c1)"}, {expected});
+      {data}, {"k"}, {"min_by(vn, cn)", "max_by(vn, cn)"}, {expected});
+
+  // Only value is UNKNOWN.
+  testAggregations(
+      {data}, {"k"}, {"min_by(vn, c)", "max_by(vn, c)"}, {expected});
+
+  // Only compare is UNKNOWN.
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeAllNullFlatVector<int64_t>(2),
+      makeAllNullFlatVector<int64_t>(2),
+  });
+
+  testAggregations(
+      {data}, {"k"}, {"min_by(v, cn)", "max_by(v, cn)"}, {expected});
 }
 
 class MinMaxByNTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    AggregationTestBase::allowInputShuffle();
     AggregationTestBase::enableTestStreaming();
   }
+
+  template <typename T>
+  void testNanFloatValues() {
+    // Verify that NaN values are handeled correctly as being greater than
+    // infinity.
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+    static const T kInf = std::numeric_limits<T>::infinity();
+
+    auto data = makeRowVector({
+        // output column for min_by/max_by
+        makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+        // group by column
+        makeFlatVector<int32_t>({1, 1, 2, 2, 2}),
+        // regular ordering
+        makeFlatVector<T>({2.0, kNaN, 1.1, kInf, -1.1}),
+        // with nulls
+        makeNullableFlatVector<T>({2.0, 1.1, std::nullopt, kSNaN, -1.1}),
+    });
+
+    // Global aggregation.
+    {
+      auto expected = makeRowVector({
+          makeArrayVectorFromJson<int32_t>({"[2, 4]"}),
+          makeArrayVectorFromJson<int32_t>({"[4, 1]"}),
+          makeArrayVectorFromJson<int32_t>({"[5, 3]"}),
+          makeArrayVectorFromJson<int32_t>({"[5, 2]"}),
+      });
+
+      testAggregations(
+          {data},
+          {},
+          {
+              "max_by(c0, c2, 2)",
+              "max_by(c0, c3, 2)",
+              "min_by(c0, c2, 2)",
+              "min_by(c0, c3, 2)",
+          },
+          {expected});
+    }
+
+    // group-by aggregation.
+    {
+      auto expected = makeRowVector({
+          makeFlatVector<int32_t>({1, 2}), // grouping key
+          makeArrayVectorFromJson<int32_t>({"[2, 1]", "[4, 3]"}),
+          makeArrayVectorFromJson<int32_t>({"[1, 2]", "[4, 5]"}),
+          makeArrayVectorFromJson<int32_t>({"[1, 2]", "[5, 3]"}),
+          makeArrayVectorFromJson<int32_t>({"[2, 1]", "[5, 4]"}),
+      });
+
+      testAggregations(
+          {data},
+          {"c1"},
+          {
+              "max_by(c0, c2, 2)",
+              "max_by(c0, c3, 2)",
+              "min_by(c0, c2, 2)",
+              "min_by(c0, c3, 2)",
+          },
+          {expected});
+    }
+  }
 };
 
+TEST_F(MinMaxByNTest, nans) {
+  testNanFloatValues<float>();
+  testNanFloatValues<double>();
+}
+
 TEST_F(MinMaxByNTest, global) {
   // DuckDB doesn't support 3-argument versions of min_by and max_by.
 
@@ -1760,6 +1904,10 @@ TEST_F(MinMaxByNTest, sortedGroupBy) {
 }
 
 TEST_F(MinMaxByNTest, variableN) {
+  // Tests below check the error behavior on invalid inputs, so testIncremental
+  // is not needed for these cases.
+  AggregationTestBase::disableTestIncremental();
+
   auto data = makeRowVector({
       makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7}),
       makeFlatVector<int64_t>({77, 66, 55, 44, 33, 22, 11}),
@@ -1815,6 +1963,8 @@ TEST_F(MinMaxByNTest, variableN) {
   VELOX_ASSERT_THROW(
       AssertQueryBuilder(plan).copyResults(pool()),
       "third argument of max_by/min_by must be a constant for all rows in a group");
+
+  AggregationTestBase::enableTestIncremental();
 }
 
 TEST_F(MinMaxByNTest, globalRow) {
@@ -2107,5 +2257,252 @@ TEST_F(MinMaxByNTest, stringComparison) {
   }
 }
 
+TEST_F(MinMaxByNTest, incrementalWindow) {
+  // Test that min_by(x, x, 10) and max_by(x, x, 10) produce correct results
+  // when used in window operation with incremental frames.
+  std::vector<VectorPtr> inputs = {
+      makeFlatVector<int64_t>({1, 2}),
+      makeFlatVector<StringView>({"1"_sv, "2"_sv}),
+      makeArrayVector<StringView>({{"1"_sv}, {"2"_sv}}),
+      makeFlatVector<Timestamp>({Timestamp(0, 0), Timestamp(0, 1)}),
+      makeFlatVector<int64_t>({10, 10}),
+      makeFlatVector<bool>({false, false}),
+      makeFlatVector<int64_t>({0, 1})};
+  auto data = makeRowVector(inputs);
+  auto result = inputs;
+
+  // Test primitive type.
+  {
+    auto plan =
+        PlanBuilder()
+            .values({data})
+            .window(
+                {"max_by(c0, c0, c4) over (partition by c5 order by c6 asc)"})
+            .planNode();
+
+    result.push_back(makeArrayVector<int64_t>({{1}, {2, 1}}));
+    AssertQueryBuilder(plan).assertResults(makeRowVector(result));
+
+    plan =
+        PlanBuilder()
+            .values({data})
+            .window(
+                {"min_by(c0, c0, c4) over (partition by c5 order by c6 asc)"})
+            .planNode();
+    result.back() = makeArrayVector<int64_t>({{1}, {1, 2}});
+    AssertQueryBuilder(plan).assertResults(makeRowVector(result));
+  }
+
+  // Test varchar type.
+  {
+    auto plan =
+        PlanBuilder()
+            .values({data})
+            .window(
+                {"max_by(c1, c1, c4) over (partition by c5 order by c6 asc)"})
+            .planNode();
+
+    result.back() = makeArrayVector<StringView>({{"1"_sv}, {"2"_sv, "1"_sv}});
+    AssertQueryBuilder(plan).assertResults(makeRowVector(result));
+
+    plan =
+        PlanBuilder()
+            .values({data})
+            .window(
+                {"min_by(c1, c1, c4) over (partition by c5 order by c6 asc)"})
+            .planNode();
+
+    result.back() = makeArrayVector<StringView>({{"1"_sv}, {"1"_sv, "2"_sv}});
+    AssertQueryBuilder(plan).assertResults(makeRowVector(result));
+  }
+
+  // Test complex type.
+  {
+    auto plan =
+        PlanBuilder()
+            .values({data})
+            .window(
+                {"max_by(c2, c3, c4) over (partition by c5 order by c6 asc)"})
+            .planNode();
+
+    result.back() = makeNullableNestedArrayVector<StringView>(
+        {{{{{"1"_sv}}}}, {{{{"2"_sv}}, {{"1"_sv}}}}});
+    AssertQueryBuilder(plan).assertResults(makeRowVector(result));
+
+    plan =
+        PlanBuilder()
+            .values({data})
+            .window(
+                {"min_by(c2, c3, c4) over (partition by c5 order by c6 asc)"})
+            .planNode();
+
+    result.back() = makeNullableNestedArrayVector<StringView>(
+        {{{{{"1"_sv}}}}, {{{{"1"_sv}}, {{"2"_sv}}}}});
+    AssertQueryBuilder(plan).assertResults(makeRowVector(result));
+  }
+}
+
+TEST_F(MinMaxByNTest, peakMemory) {
+  auto data = makeRowVector({
+      // Each array has 100 elements.
+      makeArrayVector<int64_t>(
+          1'000,
+          [](auto /*row*/) { return 100; },
+          [](auto row) { return row; }),
+      makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+      makeFlatVector<std::string>(
+          1'000,
+          [](auto row) {
+            return fmt::format("this is a very long string for row {}", row);
+          }),
+      makeFlatVector<std::string>(
+          1'000,
+          [](auto row) {
+            return fmt::format(
+                "this is another very long string for row {}", row);
+          }),
+  });
+
+  auto getPeakMemoryBytes = [&](const std::string& aggregate) {
+    core::PlanNodeId aggId;
+    auto plan = PlanBuilder()
+                    .values({data})
+                    .singleAggregation({}, {aggregate})
+                    .capturePlanNodeId(aggId)
+                    .planNode();
+
+    std::shared_ptr<exec::Task> task;
+    auto results = AssertQueryBuilder(plan).copyResults(pool(), task);
+
+    auto planStats = toPlanStats(task->taskStats());
+    auto& aggrStats = planStats[aggId];
+
+    return aggrStats.peakMemoryBytes;
+  };
+
+  auto minByPeak = getPeakMemoryBytes("min_by(c0, c1, 2)");
+  auto maxByPeak = getPeakMemoryBytes("max_by(c0, c1, 2)");
+
+  EXPECT_EQ(minByPeak, maxByPeak);
+  EXPECT_LT(maxByPeak, 140000);
+
+  minByPeak = getPeakMemoryBytes("min_by(c2, c1, 2)");
+  maxByPeak = getPeakMemoryBytes("max_by(c2, c1, 2)");
+
+  EXPECT_EQ(minByPeak, maxByPeak);
+  EXPECT_LT(maxByPeak, 190000);
+
+  minByPeak = getPeakMemoryBytes("min_by(c2, c3, 2)");
+  maxByPeak = getPeakMemoryBytes("max_by(c2, c3, 2)");
+
+  EXPECT_EQ(minByPeak, maxByPeak);
+  EXPECT_LT(maxByPeak, 190000);
+}
+
+class MinMaxByTest : public AggregationTestBase {
+ public:
+  template <typename T>
+  void testNanFloatValues() {
+    // Verify that NaN values are handeled correctly as being greater than
+    // infinity.
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+    static const T kInf = std::numeric_limits<T>::infinity();
+
+    auto data = makeRowVector({
+        // output column for min_by/max_by
+        makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+        // group by column
+        makeFlatVector<int32_t>({1, 1, 2, 2, 2}),
+        // regular ordering
+        makeFlatVector<T>({2.0, kNaN, 1.1, kInf, -1.1}),
+        // with nulls
+        makeNullableFlatVector<T>({2.0, 1.1, std::nullopt, kSNaN, -1.1}),
+    });
+
+    // Global aggregation.
+    {
+      auto expected = makeRowVector({
+          makeFlatVector<int32_t>(std::vector<int32_t>({2})),
+          makeFlatVector<int32_t>(std::vector<int32_t>({4})),
+          makeFlatVector<int32_t>(std::vector<int32_t>({5})),
+          makeFlatVector<int32_t>(std::vector<int32_t>({5})),
+      });
+
+      testAggregations(
+          {data},
+          {},
+          {
+              "max_by(c0, c2)",
+              "max_by(c0, c3)",
+              "min_by(c0, c2)",
+              "min_by(c0, c3)",
+          },
+          {expected});
+    }
+
+    // group-by aggregation.
+    {
+      auto expected = makeRowVector({
+          makeFlatVector<int32_t>({1, 2}), // grouping key
+          makeFlatVector<int32_t>({2, 4}),
+          makeFlatVector<int32_t>({1, 4}),
+          makeFlatVector<int32_t>({1, 5}),
+          makeFlatVector<int32_t>({2, 5}),
+      });
+
+      testAggregations(
+          {data},
+          {"c1"},
+          {
+              "max_by(c0, c2)",
+              "max_by(c0, c3)",
+              "min_by(c0, c2)",
+              "min_by(c0, c3)",
+          },
+          {expected});
+    }
+
+    // Test for float point values nested inside complex type.
+    data = makeRowVector({
+        // output column for min_by/max_by
+        makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+        // group by column
+        makeFlatVector<int32_t>({1, 1, 2, 2, 2, 2}),
+        makeRowVector({
+            makeFlatVector<T>({2, kNaN, 1, kInf, -1, kNaN}),
+            makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2}),
+        }),
+    });
+
+    // Global aggregation.
+    {
+      auto expected = makeRowVector({
+          makeFlatVector<int32_t>(std::vector<int32_t>({6})),
+          makeFlatVector<int32_t>(std::vector<int32_t>({5})),
+      });
+
+      testAggregations(
+          {data}, {}, {"max_by(c0, c2)", "min_by(c0, c2)"}, {expected});
+    }
+
+    // group-by aggregation.
+    {
+      auto expected = makeRowVector({
+          makeFlatVector<int32_t>({1, 2}), // grouping key
+          makeFlatVector<int32_t>({2, 6}),
+          makeFlatVector<int32_t>({1, 5}),
+      });
+
+      testAggregations(
+          {data}, {"c1"}, {"max_by(c0, c2)", "min_by(c0, c2)"}, {expected});
+    }
+  }
+};
+
+TEST_F(MinMaxByTest, nans) {
+  testNanFloatValues<float>();
+  testNanFloatValues<double>();
+}
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/MinMaxTest.cpp b/velox/functions/prestosql/aggregates/tests/MinMaxTest.cpp
index f3cdc59702cf1..9d0aefc6cc435 100644
--- a/velox/functions/prestosql/aggregates/tests/MinMaxTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MinMaxTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox;
@@ -34,7 +34,6 @@ class MinMaxTest : public functions::aggregate::test::AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   std::vector<RowVectorPtr> fuzzData(const RowTypePtr& rowType) {
@@ -62,12 +61,7 @@ class MinMaxTest : public functions::aggregate::test::AggregationTestBase {
 
     // Global aggregation.
     testAggregations(
-        vectors,
-        {},
-        {agg(c1)},
-        fmt::format("SELECT {} FROM tmp", agg(c1)),
-        /*config*/ {},
-        testWithTableScan);
+        vectors, {}, {agg(c1)}, fmt::format("SELECT {} FROM tmp", agg(c1)));
 
     // Group by aggregation.
     testAggregations(
@@ -76,19 +70,12 @@ class MinMaxTest : public functions::aggregate::test::AggregationTestBase {
         },
         {"p0"},
         {agg(c1)},
-        fmt::format("SELECT c0 % 10, {} FROM tmp GROUP BY 1", agg(c1)),
-        /*config*/ {},
-        testWithTableScan);
+        fmt::format("SELECT c0 % 10, {} FROM tmp GROUP BY 1", agg(c1)));
 
     // Masked aggregations.
     auto maskedAgg = agg(c1) + " filter (where mask)";
     testAggregations(
-        vectors,
-        {},
-        {maskedAgg},
-        fmt::format("SELECT {} FROM tmp", maskedAgg),
-        /*config*/ {},
-        testWithTableScan);
+        vectors, {}, {maskedAgg}, fmt::format("SELECT {} FROM tmp", maskedAgg));
 
     testAggregations(
         [&](auto& builder) {
@@ -96,9 +83,7 @@ class MinMaxTest : public functions::aggregate::test::AggregationTestBase {
         },
         {"p0"},
         {maskedAgg},
-        fmt::format("SELECT c0 % 10, {} FROM tmp GROUP BY 1", maskedAgg),
-        /*config*/ {},
-        testWithTableScan);
+        fmt::format("SELECT c0 % 10, {} FROM tmp GROUP BY 1", maskedAgg));
 
     // Encodings: use filter to wrap aggregation inputs in a dictionary.
     testAggregations(
@@ -110,17 +95,193 @@ class MinMaxTest : public functions::aggregate::test::AggregationTestBase {
         {"p0"},
         {agg(c1)},
         fmt::format(
-            "SELECT c0 % 11, {} FROM tmp WHERE c0 % 2 = 0 GROUP BY 1", agg(c1)),
-        /*config*/ {},
-        testWithTableScan);
+            "SELECT c0 % 11, {} FROM tmp WHERE c0 % 2 = 0 GROUP BY 1",
+            agg(c1)));
 
     testAggregations(
         [&](auto& builder) { builder.values(vectors).filter("c0 % 2 = 0"); },
         {},
         {agg(c1)},
-        fmt::format("SELECT {} FROM tmp WHERE c0 % 2 = 0", agg(c1)),
-        /*config*/ {},
-        testWithTableScan);
+        fmt::format("SELECT {} FROM tmp WHERE c0 % 2 = 0", agg(c1)));
+  }
+
+  template <typename T>
+  void testExtremeFloatValues() {
+    // Tests to ensure that extreme floating point values are handled correctly,
+    // including, INF, -INF, NaN. This validates that the groups have initial
+    // value set correctly, (-INF for max() and NaN for min()) and NaN is
+    // considered greater than INF. Also tests for when floating points are
+    // nested inside complex types. Finally, this also tests for when
+    // aggregation is pushed down to the scan operator which can only happen if
+    // the column is a primitive type and not used anywhere execpt a single
+    // aggregate.
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+    static const T kInf = std::numeric_limits<T>::infinity();
+
+    auto data = makeRowVector({
+        // regular ordering
+        makeFlatVector<T>({2.0, kNaN, 1.1, kInf, -1.1}),
+        // with nulls
+        makeNullableFlatVector<T>({2.0, kNaN, std::nullopt, 1.1, -1.1}),
+        // only nans (use a different binary representation for NaN to verify
+        // that they are considered equal)
+        makeFlatVector<T>({kSNaN, kSNaN, kSNaN, kSNaN, kSNaN}),
+        // only Inf
+        makeFlatVector<T>({kInf, kInf, kInf, kInf, kInf}),
+        // only -Inf
+        makeFlatVector<T>({-kInf, -kInf, -kInf, -kInf, -kInf}),
+        // group by column
+        makeFlatVector<int32_t>({1, 1, 1, 2, 2}),
+    });
+
+    // Global aggregation.
+    {
+      // Verify max pushed down to scan operator.
+      std::vector<VectorPtr> expectedMaxValues = {
+          makeFlatVector<T>(std::vector<T>({kNaN})),
+          makeFlatVector<T>(std::vector<T>({kNaN})),
+          makeFlatVector<T>(std::vector<T>({kNaN})),
+          makeFlatVector<T>(std::vector<T>({kInf})),
+          makeFlatVector<T>(std::vector<T>({-kInf}))};
+
+      testAggregations(
+          {data},
+          {},
+          {"max(c0)", "max(c1)", "max(c2)", "max(c3)", "max(c4)"},
+          {makeRowVector(expectedMaxValues)});
+
+      // Verify max pushed down to scan operator.
+      std::vector<VectorPtr> expectedMinValues = {
+          makeFlatVector<T>(std::vector<T>({-1.1})),
+          makeFlatVector<T>(std::vector<T>({-1.1})),
+          makeFlatVector<T>(std::vector<T>({kNaN})),
+          makeFlatVector<T>(std::vector<T>({kInf})),
+          makeFlatVector<T>(std::vector<T>({-kInf})),
+      };
+      testAggregations(
+          {data},
+          {},
+          {"min(c0)", "min(c1)", "min(c2)", "min(c3)", "min(c4)"},
+          {makeRowVector(expectedMinValues)});
+
+      // Verify max and min evaluated in aggregation operator.
+      std::vector<VectorPtr> allExpectedValues = expectedMaxValues;
+      allExpectedValues.insert(
+          allExpectedValues.end(),
+          expectedMinValues.begin(),
+          expectedMinValues.end());
+
+      testAggregations(
+          {data},
+          {},
+          {"max(c0)",
+           "max(c1)",
+           "max(c2)",
+           "max(c3)",
+           "max(c4)",
+           "min(c0)",
+           "min(c1)",
+           "min(c2)",
+           "min(c3)",
+           "min(c4)"},
+          {makeRowVector(allExpectedValues)});
+    }
+
+    // group-by aggregation.
+    {
+      // Verify max pushed down to scan operator.
+      std::vector<VectorPtr> expectedMaxValues = {
+          makeFlatVector<int32_t>({1, 2}), // grouping key
+          makeFlatVector<T>({kNaN, kInf}),
+          makeFlatVector<T>({kNaN, 1.1}),
+          makeFlatVector<T>({kNaN, kNaN}),
+          makeFlatVector<T>({kInf, kInf}),
+          makeFlatVector<T>({-kInf, -kInf})};
+
+      testAggregations(
+          {data},
+          {"c5"},
+          {"max(c0)", "max(c1)", "max(c2)", "max(c3)", "max(c4)"},
+          {makeRowVector(expectedMaxValues)});
+
+      // Verify min pushed down to scan operator.
+      std::vector<VectorPtr> expectedMinValues = {
+          makeFlatVector<int32_t>({1, 2}), // grouping key
+          makeFlatVector<T>({1.1, -1.1}),
+          makeFlatVector<T>({2.0, -1.1}),
+          makeFlatVector<T>({kNaN, kNaN}),
+          makeFlatVector<T>({kInf, kInf}),
+          makeFlatVector<T>({-kInf, -kInf})};
+
+      testAggregations(
+          {data},
+          {"c5"},
+          {"min(c0)", "min(c1)", "min(c2)", "min(c3)", "min(c4)"},
+          {makeRowVector(expectedMinValues)});
+
+      // Verify max and min evaluated in aggregation operator.
+      std::vector<VectorPtr> allExpectedValues = expectedMaxValues;
+      allExpectedValues.insert(
+          allExpectedValues.end(),
+          expectedMinValues.begin() + 1, // skip the grouping key column
+          expectedMinValues.end());
+
+      testAggregations(
+          {data},
+          {"c5"},
+          {"max(c0)",
+           "max(c1)",
+           "max(c2)",
+           "max(c3)",
+           "max(c4)",
+           "min(c0)",
+           "min(c1)",
+           "min(c2)",
+           "min(c3)",
+           "min(c4)"},
+          {makeRowVector(allExpectedValues)});
+    }
+
+    // Test for float point values nested inside complex type.
+    data = makeRowVector({
+        makeRowVector({
+            makeFlatVector<T>({2, kNaN, 1, kInf, -1, kNaN}),
+            makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2}),
+        }),
+        makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2}),
+    });
+
+    // Global aggregation.
+    {
+      auto expected = makeRowVector(
+          {makeRowVector({
+               makeFlatVector<T>(std::vector<T>({-1})),
+               makeFlatVector<int32_t>(std::vector<int32_t>({2})),
+           }),
+           makeRowVector({
+               makeFlatVector<T>(std::vector<T>({kNaN})),
+               makeFlatVector<int32_t>(std::vector<int32_t>({2})),
+           })});
+
+      testAggregations({data}, {}, {"min(c0)", "max(c0)"}, {expected});
+    }
+
+    // group-by aggregation.
+    {
+      auto expected = makeRowVector(
+          {makeFlatVector<int32_t>({1, 2}),
+           makeRowVector({
+               makeFlatVector<T>(std::vector<T>({1, -1})),
+               makeFlatVector<int32_t>(std::vector<int32_t>({1, 2})),
+           }),
+           makeRowVector({
+               makeFlatVector<T>(std::vector<T>({kNaN, kNaN})),
+               makeFlatVector<int32_t>(std::vector<int32_t>({1, 2})),
+           })});
+
+      testAggregations({data}, {"c1"}, {"min(c0)", "max(c0)"}, {expected});
+    }
   }
 };
 
@@ -142,10 +303,12 @@ TEST_F(MinMaxTest, maxBigint) {
 
 TEST_F(MinMaxTest, maxReal) {
   doTest(max, REAL());
+  testExtremeFloatValues<float>();
 }
 
 TEST_F(MinMaxTest, maxDouble) {
   doTest(max, DOUBLE());
+  testExtremeFloatValues<double>();
 }
 
 TEST_F(MinMaxTest, maxVarchar) {
@@ -267,6 +430,28 @@ TEST_F(MinMaxTest, minMaxDate) {
       "SELECT c0 % 17, min(c1), max(c1) FROM tmp GROUP BY 1");
 }
 
+TEST_F(MinMaxTest, minMaxUnknown) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 1, 2, 1, 2}),
+      makeAllNullFlatVector<UnknownValue>(6),
+  });
+
+  auto expected = makeRowVector({
+      makeAllNullFlatVector<UnknownValue>(1),
+      makeAllNullFlatVector<UnknownValue>(1),
+  });
+
+  testAggregations({data}, {}, {"min(c1)", "max(c1)"}, {expected});
+
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeAllNullFlatVector<UnknownValue>(2),
+      makeAllNullFlatVector<UnknownValue>(2),
+  });
+
+  testAggregations({data}, {"c0"}, {"min(c1)", "max(c1)"}, {expected});
+}
+
 TEST_F(MinMaxTest, initialValue) {
   // Ensures that no groups are default initialized (to 0) in
   // aggregate::SimpleNumericAggregate.
@@ -331,35 +516,6 @@ TEST_F(MinMaxTest, array) {
   testAggregations({data}, {}, {"min(c0)", "max(c0)"}, {expected});
 }
 
-TEST_F(MinMaxTest, map) {
-  auto data = makeRowVector({
-      makeNullableMapVector<int64_t, int64_t>({
-          {{{1, 1}, {2, 2}}},
-          {{{2, std::nullopt}, {2, 3}}},
-          {{{4, 50}}},
-      }),
-  });
-
-  auto expected = makeRowVector({
-      makeMapVector<int64_t, int64_t>({{{1, 1}, {2, 2}}}),
-      makeMapVector<int64_t, int64_t>({{{4, 50}}}),
-  });
-
-  VELOX_ASSERT_THROW(
-      testAggregations({data}, {}, {"min(c0)", "max(c0)"}, {expected}),
-      "MAP comparison not supported for values that contain nulls");
-
-  data = makeRowVector({
-      makeNullableMapVector<int64_t, int64_t>({
-          {{{1, 1}, {2, 2}}},
-          {{{1, 1}, {2, 3}}},
-          {{{4, 50}}},
-      }),
-  });
-
-  testAggregations({data}, {}, {"min(c0)", "max(c0)"}, {expected});
-}
-
 TEST_F(MinMaxTest, row) {
   auto data = makeRowVector({
       makeRowVector({
@@ -494,11 +650,32 @@ TEST_F(MinMaxTest, rowCheckNull) {
   }
 }
 
+TEST_F(MinMaxTest, failOnUnorderableType) {
+  auto data = makeRowVector({
+      makeAllNullMapVector(5, VARCHAR(), BIGINT()),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+  });
+
+  static const std::string kErrorMessage =
+      "Aggregate function signature is not supported";
+  for (const auto& expr : {"min(c0)", "max(c0)"}) {
+    {
+      auto builder = PlanBuilder().values({data});
+      VELOX_ASSERT_THROW(builder.singleAggregation({}, {expr}), kErrorMessage);
+    }
+
+    {
+      auto builder = PlanBuilder().values({data});
+      VELOX_ASSERT_THROW(
+          builder.singleAggregation({"c1"}, {expr}), kErrorMessage);
+    }
+  }
+}
+
 class MinMaxNTest : public functions::aggregate::test::AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   template <typename T>
@@ -613,6 +790,102 @@ class MinMaxNTest : public functions::aggregate::test::AggregationTestBase {
         "second argument of max/min must be less than or equal to 10000");
   }
 
+  template <typename T>
+  void testNumericGlobalDecimal() {
+    TypePtr type;
+    if (std::is_same<T, int64_t>::value) {
+      type = DECIMAL(6, 2);
+    } else {
+      type = DECIMAL(20, 2);
+    }
+    auto data = makeRowVector({
+        makeFlatVector<T>(
+            {100000,
+             131011,
+             223454,
+             111911,
+             111300,
+             800000,
+             104000,
+             712452,
+             161213,
+             135243},
+            type),
+    });
+    auto expected = makeRowVector({
+        makeArrayVector<T>(
+            {
+                {100000, 104000},
+            },
+            type),
+        makeArrayVector<T>(
+            {
+                {100000, 104000, 111300, 111911, 131011},
+            },
+            type),
+        makeArrayVector<T>(
+            {
+                {800000, 712452, 223454},
+            },
+            type),
+        makeArrayVector<T>(
+            {
+                {800000, 712452, 223454, 161213, 135243, 131011, 111911},
+            },
+            type),
+    });
+
+    testAggregations(
+        {data},
+        {},
+        {"min(c0, 2)", "min(c0, 5)", "max(c0, 3)", "max(c0, 7)"},
+        {expected});
+
+    // Add some nulls. Expect these to be ignored.
+    data = makeRowVector({
+        makeNullableFlatVector<T>(
+            {100000,
+             std::nullopt,
+             131011,
+             223454,
+             111911,
+             std::nullopt,
+             111300,
+             800000,
+             104000,
+             712452,
+             161213,
+             135243,
+             std::nullopt},
+            type),
+    });
+
+    testAggregations(
+        {data},
+        {},
+        {"min(c0, 2)", "min(c0, 5)", "max(c0, 3)", "max(c0, 7)"},
+        {expected});
+
+    // Test all null input.
+    data = makeRowVector({
+        makeNullableFlatVector<T>(
+            {std::nullopt, std::nullopt, std::nullopt, std::nullopt}, type),
+    });
+
+    expected = makeRowVector({
+        makeAllNullArrayVector(1, data->childAt(0)->type()),
+        makeAllNullArrayVector(1, data->childAt(0)->type()),
+        makeAllNullArrayVector(1, data->childAt(0)->type()),
+        makeAllNullArrayVector(1, data->childAt(0)->type()),
+    });
+
+    testAggregations(
+        {data},
+        {},
+        {"min(c0, 2)", "min(c0, 5)", "max(c0, 3)", "max(c0, 7)"},
+        {expected});
+  }
+
   template <typename T>
   void testNumericGroupBy() {
     auto data = makeRowVector({
@@ -741,6 +1014,184 @@ class MinMaxNTest : public functions::aggregate::test::AggregationTestBase {
         {"min(c1, c2)", "min(c1, c4)", "max(c1, c3)", "max(c1, c4)"},
         {expected});
   }
+
+  template <typename T>
+  void testNumericGroupByDecimal() {
+    TypePtr type;
+    if (std::is_same<T, int64_t>::value) {
+      type = DECIMAL(6, 2);
+    } else {
+      type = DECIMAL(20, 2);
+    }
+
+    auto data = makeRowVector({
+        makeFlatVector<int16_t>({1, 2, 1, 1, 2, 2, 1, 2}),
+        makeFlatVector<T>(
+            {100000, 131011, 223454, 111911, 111300, 104000, 161213, 135243},
+            type),
+    });
+
+    auto expected = makeRowVector({
+        makeFlatVector<int16_t>({1, 2}),
+        makeArrayVector<T>(
+            {
+                {100000, 111911},
+                {104000, 111300},
+            },
+            type),
+        makeArrayVector<T>(
+            {
+                {100000, 111911, 161213, 223454},
+                {104000, 111300, 131011, 135243},
+            },
+            type),
+        makeArrayVector<T>(
+            {
+                {223454, 161213, 111911},
+                {135243, 131011, 111300},
+            },
+            type),
+        makeArrayVector<T>(
+            {
+                {223454, 161213, 111911, 100000},
+                {135243, 131011, 111300, 104000},
+            },
+            type),
+    });
+
+    testAggregations(
+        {data},
+        {"c0"},
+        {"min(c1, 2)", "min(c1, 5)", "max(c1, 3)", "max(c1, 7)"},
+        {expected});
+
+    // Add some nulls. Expect these to be ignored.
+    data = makeRowVector({
+        makeFlatVector<int16_t>({1, 2, 1, 1, 1, 2, 2, 2, 1, 2}),
+        makeNullableFlatVector<T>(
+            {100000,
+             131011,
+             std::nullopt,
+             223454,
+             111911,
+             111300,
+             std::nullopt,
+             104000,
+             161213,
+             135243},
+            type),
+    });
+
+    testAggregations(
+        {data},
+        {"c0"},
+        {"min(c1, 2)", "min(c1, 5)", "max(c1, 3)", "max(c1, 7)"},
+        {expected});
+
+    // Test all null input.
+    data = makeRowVector({
+        makeFlatVector<int16_t>({1, 2, 1, 1, 1, 2, 2, 2, 1, 2}),
+        makeNullableFlatVector<T>(
+            {std::nullopt,
+             131011,
+             std::nullopt,
+             std::nullopt,
+             std::nullopt,
+             111300,
+             std::nullopt,
+             104000,
+             std::nullopt,
+             135243},
+            type),
+    });
+
+    expected = makeRowVector({
+        makeFlatVector<int16_t>({1, 2}),
+        makeNullableArrayVector<T>(
+            {
+                std::nullopt,
+                {{{104000, 111300}}},
+            },
+            ARRAY(type)),
+        makeNullableArrayVector<T>(
+            {
+                std::nullopt,
+                {{{104000, 111300, 131011, 135243}}},
+            },
+            ARRAY(type)),
+        makeNullableArrayVector<T>(
+            {
+                std::nullopt,
+                {{{135243, 131011, 111300}}},
+            },
+            ARRAY(type)),
+        makeNullableArrayVector<T>(
+            {
+                std::nullopt,
+                {{{135243, 131011, 111300, 104000}}},
+            },
+            ARRAY(type)),
+    });
+
+    testAggregations(
+        {data},
+        {"c0"},
+        {"min(c1, 2)", "min(c1, 5)", "max(c1, 3)", "max(c1, 7)"},
+        {expected});
+  }
+
+  template <typename T>
+  void testNaNFloatValues() {
+    // Tests to ensure NaN is correctly handled and considered greater than
+    // Infinity.
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kInf = std::numeric_limits<T>::infinity();
+
+    auto data = makeRowVector({
+        // regular ordering
+        makeFlatVector<T>({2.0, kNaN, kInf, kNaN, -1.1, 0.0}),
+        // with nulls (null is ignored)
+        makeNullableFlatVector<T>({2.0, kNaN, std::nullopt, 1.1, -1.1, 0.0}),
+        // group by column
+        makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2}),
+    });
+
+    // Global aggregation.
+    {
+      auto expected = makeRowVector(
+          {makeArrayVector<T>({{-1.1, 0.0, 2.0, kInf, kNaN, kNaN}}),
+           makeArrayVector<T>({{kNaN, kNaN, kInf, 2.0, 0.0, -1.1}}),
+           makeArrayVector<T>({{-1.1, 0.0, 1.1, 2.0, kNaN}}),
+           makeArrayVector<T>({{kNaN, 2.0, 1.1, 0.0, -1.1}})});
+
+      testAggregations(
+          {data},
+          {},
+          {
+              "min(c0, 6)",
+              "max(c0, 6)",
+              "min(c1, 6)",
+              "max(c1, 6)",
+          },
+          {expected});
+    }
+
+    // group-by aggregation.
+    {
+      auto expected = makeRowVector(
+          {makeFlatVector<int32_t>({1, 2}),
+           makeArrayVector<T>({{2.0, kInf, kNaN}, {-1.1, 0.0, kNaN}}),
+           makeArrayVector<T>({{kNaN, kInf, 2.0}, {kNaN, 0.0, -1.1}}),
+           makeArrayVector<T>({{2.0, kNaN}, {-1.1, 0.0, 1.1}}),
+           makeArrayVector<T>({{kNaN, 2.0}, {1.1, 0.0, -1.1}})});
+
+      testAggregations(
+          {data},
+          {"c2"},
+          {"min(c0, 3)", "max(c0, 3)", "min(c1, 3)", "max(c1, 3)"},
+          {expected});
+    }
+  }
 };
 
 TEST_F(MinMaxNTest, tinyint) {
@@ -766,11 +1217,56 @@ TEST_F(MinMaxNTest, bigint) {
 TEST_F(MinMaxNTest, real) {
   testNumericGlobal<float>();
   testNumericGroupBy<float>();
+  testNaNFloatValues<float>();
 }
 
 TEST_F(MinMaxNTest, double) {
   testNumericGlobal<double>();
   testNumericGroupBy<double>();
+  testNaNFloatValues<double>();
+}
+
+TEST_F(MinMaxNTest, shortdecimal) {
+  testNumericGlobalDecimal<int64_t>();
+  testNumericGroupByDecimal<int64_t>();
+}
+
+TEST_F(MinMaxNTest, longdecimal) {
+  testNumericGlobalDecimal<int128_t>();
+  testNumericGroupByDecimal<int128_t>();
+}
+
+TEST_F(MinMaxNTest, incrementalWindow) {
+  // SELECT
+  //  c0, c1, c2, c3,
+  //  max(c0, c1) over (partition by c2 order by c3 asc)
+  // FROM (
+  //  VALUES
+  //      (1, 10, false, 0),
+  //      (2, 10, false, 1)
+  // ) AS t(c0, c1, c2, c3)
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeFlatVector<int64_t>({10, 10}),
+      makeFlatVector<bool>({false, false}),
+      makeFlatVector<int64_t>({0, 1}),
+  });
+
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .window({"max(c0, c1) over (partition by c2 order by c3 asc)"})
+          .planNode();
+
+  // Expected result: {1, 10, false, 0, [1]}, {2, 10, false, 1, [2, 1]}.
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2}),
+      makeFlatVector<int64_t>({10, 10}),
+      makeFlatVector<bool>({false, false}),
+      makeFlatVector<int64_t>({0, 1}),
+      makeArrayVector<int64_t>({{1}, {2, 1}}),
+  });
+  AssertQueryBuilder(plan).assertResults(expected);
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/aggregates/tests/MultiMapAggTest.cpp b/velox/functions/prestosql/aggregates/tests/MultiMapAggTest.cpp
index 30d5a255c3af2..4c33989db76a6 100644
--- a/velox/functions/prestosql/aggregates/tests/MultiMapAggTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MultiMapAggTest.cpp
@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <cmath>
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 namespace facebook::velox::aggregate::prestosql {
 namespace {
@@ -23,7 +24,6 @@ class MultiMapAggTest : public functions::aggregate::test::AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 };
 
@@ -180,5 +180,171 @@ TEST_F(MultiMapAggTest, stringKeyGroupBy) {
       {expected});
 }
 
+TEST_F(MultiMapAggTest, arrayKeyGlobal) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[]",
+          "null",
+          "[1, 2, 3, 4]",
+          "[1, 2]",
+          "[1, 2, 3]",
+          "[1, 2]",
+          "[]",
+      }),
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8}),
+  });
+
+  auto expected = makeRowVector({
+      makeMapVector(
+          {0},
+          makeArrayVectorFromJson<int32_t>({
+              "[1, 2, 3]",
+              "[]",
+              "[1, 2, 3, 4]",
+              "[1, 2]",
+          }),
+          makeArrayVectorFromJson<int64_t>({
+              "[1, 6]",
+              "[2, 8]",
+              "[4]",
+              "[5, 7]",
+          })),
+  });
+
+  testAggregations(
+      {data},
+      {},
+      {"multimap_agg(c0, c1)"},
+      // Sort the result arrays to ensure deterministic results.
+      {"transform_values(a0, (k, v) -> array_sort(v))"},
+      {expected});
+}
+
+TEST_F(MultiMapAggTest, arrayKeyGroupBy) {
+  auto data = makeRowVector({
+      makeFlatVector<int16_t>({1, 2, 1, 2, 1, 2, 1, 2}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[]",
+          "null",
+          "[1, 2, 3, 4]",
+          "[1, 2]",
+          "[1, 2, 3]",
+          "[1, 2]",
+          "[]",
+      }),
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8}),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeMapVector(
+          {0, 2},
+          makeArrayVectorFromJson<int32_t>({
+              "[1, 2, 3]",
+              "[1, 2]",
+              "[]",
+              "[1, 2, 3]",
+              "[1, 2, 3, 4]",
+          }),
+          makeArrayVectorFromJson<int64_t>({
+              "[1]",
+              "[5, 7]",
+              "[2, 8]",
+              "[6]",
+              "[4]",
+          })),
+  });
+
+  testAggregations(
+      {data},
+      {"c0"},
+      {"multimap_agg(c1, c2)"},
+      // Sort the result arrays to ensure deterministic results.
+      {"c0", "transform_values(a0, (k, v) -> array_sort(v))"},
+      {expected});
+}
+
+TEST_F(MultiMapAggTest, doubleKeyGlobal) {
+  // Verify that all NaN representations used as a map key are treated as equal
+  static const double KNan1 = std::nan("1");
+  static const double KNan2 = std::nan("2");
+  auto data = makeRowVector({
+      makeFlatVector<double>(
+          {KNan1, KNan2, 1.1, 0.2, 23.0, 2.0, 23.0, 2.0, 1.1, 0.2, 23.0, 2.0}),
+      makeNullableFlatVector<int64_t>(
+          {-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}),
+  });
+
+  auto expected = makeRowVector({
+      makeMapVector(
+          {
+              0,
+          },
+          makeFlatVector<double>({KNan1, 0.2, 1.1, 2.0, 23.0}),
+          makeArrayVector<int64_t>({
+              {-2, -1},
+              {1, 7},
+              {0, 6},
+              {3, 5, 9},
+              {2, 4, 8},
+          })),
+  });
+
+  testAggregations(
+      {data},
+      {},
+      {"multimap_agg(c0, c1)"},
+      // Sort the result arrays to ensure deterministic results.
+      {"transform_values(a0, (k, v) -> array_sort(v))"},
+      {expected});
+
+  // Input keys are complex type (row).
+  data = makeRowVector({
+      makeRowVector(
+          {makeFlatVector<double>(
+               {KNan1,
+                KNan2,
+                1.1,
+                0.2,
+                23.0,
+                2.0,
+                23.0,
+                2.0,
+                1.1,
+                0.2,
+                23.0,
+                2.0}),
+           makeFlatVector<int64_t>(std::vector<int64_t>(13, 0))}),
+      makeFlatVector<int64_t>({-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}),
+  });
+
+  expected = makeRowVector({
+      makeMapVector(
+          {
+              0,
+          },
+          makeRowVector(
+              {makeFlatVector<double>({KNan1, 0.2, 1.1, 2.0, 23.0}),
+               makeFlatVector<int64_t>(std::vector<int64_t>(5, 0))}),
+          makeArrayVector<int64_t>({
+              {-2, -1},
+              {1, 7},
+              {0, 6},
+              {3, 5, 9},
+              {2, 4, 8},
+          })),
+  });
+
+  testAggregations(
+      {data},
+      {},
+      {"multimap_agg(c0, c1)"},
+      // Sort the result arrays to ensure deterministic results.
+      {"transform_values(a0, (k, v) -> array_sort(v))"},
+      {expected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp b/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
index 8761bb16f03bb..71246eed66534 100644
--- a/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
@@ -28,6 +28,10 @@ using limits = std::numeric_limits<T>;
 class PrestoHasherTest : public testing::Test,
                          public facebook::velox::test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   template <typename T>
   void assertHash(
       const std::vector<std::optional<T>>& data,
@@ -109,6 +113,25 @@ class PrestoHasherTest : public testing::Test,
 
     checkHashes(dictionaryVector, modifiedExpected);
 
+    // The dictionary vector is larger than the values.
+    // We make it much larger so that if we allocate any Buffers using the base
+    // Vector's size, it won't be large enough to hold the number of elements in
+    // the DictionaryVector even after aligning the size and expanding it to the
+    // preferred size.
+    auto longerSize = vectorSize * 100;
+
+    modifiedExpected.resize(longerSize);
+    for (size_t i = 0; i < longerSize; ++i) {
+      modifiedExpected[i] = expected[i % vectorSize];
+    }
+
+    BufferPtr longerIndices = makeIndices(
+        longerSize, [vectorSize](auto row) { return row % vectorSize; });
+
+    dictionaryVector = wrapInDictionary(longerIndices, longerSize, vector);
+
+    checkHashes(dictionaryVector, modifiedExpected);
+
     // Wrap in a constant vector of various sizes.
 
     for (int size = 1; size <= vectorSize - 1; size++) {
@@ -177,12 +200,40 @@ TEST_F(PrestoHasherTest, date) {
 
 TEST_F(PrestoHasherTest, unscaledShortDecimal) {
   assertHash<int64_t>(
-      {0, 1000, std::nullopt}, {0, 2343331593029422743, 0}, DECIMAL(10, 5));
+      {0,
+       1000,
+       -1000,
+       std::nullopt,
+       DecimalUtil::kShortDecimalMax,
+       DecimalUtil::kShortDecimalMin},
+      {0,
+       1000,
+       -1000,
+       0,
+       DecimalUtil::kShortDecimalMax,
+       DecimalUtil::kShortDecimalMin},
+      DECIMAL(18, 0));
 }
 
 TEST_F(PrestoHasherTest, unscaledLongDecimal) {
   assertHash<int128_t>(
-      {0, 1000, std::nullopt}, {0, 2343331593029422743, 0}, DECIMAL(20, 5));
+      {0,
+       1000,
+       -1000,
+       HugeInt::build(0, 6223891681234568000UL),
+       HugeInt::build(9223372036854775805UL, 6898690891216455152UL),
+       std::nullopt,
+       DecimalUtil::kLongDecimalMax,
+       DecimalUtil::kLongDecimalMin},
+      {0,
+       -3317384982385163790,
+       -3317384982385163790,
+       -2440068372815350100,
+       8392582729122626937,
+       0,
+       3027397587645285649,
+       3027397587645285649},
+      DECIMAL(38, 0));
 }
 
 TEST_F(PrestoHasherTest, doubles) {
@@ -343,39 +394,30 @@ TEST_F(PrestoHasherTest, timestampWithTimezone) {
   const auto toUnixtimeWithTimeZone =
       [&](const std::vector<std::optional<std::pair<int64_t, std::string>>>&
               timestampWithTimeZones) {
-        std::vector<std::optional<int64_t>> timestamps;
-        std::vector<std::optional<int16_t>> timeZoneIds;
+        std::vector<std::optional<int64_t>> timestampWithTimeZoneVector;
         auto size = timestampWithTimeZones.size();
         BufferPtr nulls =
             AlignedBuffer::allocate<uint64_t>(bits::nwords(size), pool());
         auto rawNulls = nulls->asMutable<uint64_t>();
-        timestamps.reserve(size);
-        timeZoneIds.reserve(size);
+        timestampWithTimeZoneVector.reserve(size);
 
         for (auto i = 0; i < size; i++) {
           auto timestampWithTimeZone = timestampWithTimeZones[i];
           if (timestampWithTimeZone.has_value()) {
             auto timestamp = timestampWithTimeZone.value().first;
             auto tz = timestampWithTimeZone.value().second;
-            const int16_t tzid = util::getTimeZoneID(tz);
-            timeZoneIds.push_back(tzid);
-            timestamps.push_back(timestamp);
+            const int16_t tzid = tz::getTimeZoneID(tz);
+            auto timestampWithTimezone = pack(timestamp, tzid);
+            timestampWithTimeZoneVector.push_back(timestampWithTimezone);
             bits::clearNull(rawNulls, i);
           } else {
-            timeZoneIds.push_back(std::nullopt);
-            timestamps.push_back(std::nullopt);
+            timestampWithTimeZoneVector.push_back(std::nullopt);
             bits::setNull(rawNulls, i);
           }
         }
 
-        return std::make_shared<RowVector>(
-            pool(),
-            TIMESTAMP_WITH_TIME_ZONE(),
-            nulls,
-            size,
-            std::vector<VectorPtr>{
-                makeNullableFlatVector(timestamps),
-                makeNullableFlatVector(timeZoneIds)});
+        return makeNullableFlatVector(
+            timestampWithTimeZoneVector, TIMESTAMP_WITH_TIME_ZONE());
       };
 
   auto timestampWithTimeZones = toUnixtimeWithTimeZone(
diff --git a/velox/functions/prestosql/aggregates/tests/ReduceAggTest.cpp b/velox/functions/prestosql/aggregates/tests/ReduceAggTest.cpp
index 2086342d63c14..f34d99980c513 100644
--- a/velox/functions/prestosql/aggregates/tests/ReduceAggTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ReduceAggTest.cpp
@@ -15,7 +15,7 @@
  */
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using facebook::velox::exec::test::AssertQueryBuilder;
@@ -28,7 +28,6 @@ class ReduceAggTest : public functions::aggregate::test::AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
     disableTestStreaming();
   }
 
diff --git a/velox/functions/prestosql/aggregates/tests/SetAggTest.cpp b/velox/functions/prestosql/aggregates/tests/SetAggTest.cpp
index b0f9d8ed04fb5..1b28c61f094f5 100644
--- a/velox/functions/prestosql/aggregates/tests/SetAggTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/SetAggTest.cpp
@@ -15,7 +15,7 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox::exec;
@@ -26,11 +26,15 @@ namespace facebook::velox::aggregate::test {
 
 namespace {
 
+constexpr int64_t kLongMax = std::numeric_limits<int64_t>::max();
+constexpr int64_t kLongMin = std::numeric_limits<int64_t>::min();
+constexpr int128_t kHugeMax = std::numeric_limits<int128_t>::max();
+constexpr int128_t kHugeMin = std::numeric_limits<int128_t>::min();
+
 class SetAggTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 };
 
@@ -155,6 +159,184 @@ TEST_F(SetAggTest, groupBy) {
       {expected});
 }
 
+TEST_F(SetAggTest, shortDecimal) {
+  // Test with short decimal
+  auto type = DECIMAL(6, 2);
+
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(
+          {kLongMin,
+           2000,
+           3000,
+           -4321,
+           kLongMax,
+           5000,
+           3000,
+           kLongMax,
+           -2000,
+           6000,
+           7000},
+          type),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>(
+          {
+              {kLongMin, -4321, -2000, 2000, 3000, 5000, 6000, 7000, kLongMax},
+          },
+          type),
+  });
+
+  testAggregations({data}, {}, {"set_agg(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Test with some NULL inputs (short decimals)
+  data = makeRowVector({
+      makeNullableFlatVector<int64_t>(
+          {1000,
+           std::nullopt,
+           kLongMin,
+           4000,
+           std::nullopt,
+           4000,
+           std::nullopt,
+           -1000,
+           5000,
+           -9999,
+           kLongMax},
+          type),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector(
+          std::vector<std::vector<std::optional<int64_t>>>{
+              {kLongMin,
+               -9999,
+               -1000,
+               1000,
+               4000,
+               5000,
+               kLongMax,
+               std::nullopt}},
+          ARRAY(type)),
+  });
+
+  testAggregations({data}, {}, {"set_agg(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Test with all NULL inputs (short decimals)
+  data = makeRowVector({
+      makeNullableFlatVector<int64_t>(
+          {std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt},
+          type),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector(
+          std::vector<std::vector<std::optional<int64_t>>>{{std::nullopt}},
+          ARRAY(type)),
+  });
+
+  testAggregations({data}, {}, {"set_agg(c0)"}, {"array_sort(a0)"}, {expected});
+}
+
+TEST_F(SetAggTest, longDecimal) {
+  // Test with long decimal
+  auto type = DECIMAL(20, 2);
+
+  auto data = makeRowVector({
+      makeFlatVector<int128_t>(
+          {kHugeMin,
+           -2000,
+           3000,
+           4000,
+           5000,
+           kHugeMax,
+           -9630,
+           2000,
+           6000,
+           7000},
+          type),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<int128_t>(
+          {
+              {kHugeMin,
+               -9630,
+               -2000,
+               2000,
+               3000,
+               4000,
+               5000,
+               6000,
+               7000,
+               kHugeMax},
+          },
+          type),
+  });
+
+  testAggregations({data}, {}, {"set_agg(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Test with some NULL inputs (long decimals)
+  data = makeRowVector({
+      makeNullableFlatVector<int128_t>(
+          {1000,
+           std::nullopt,
+           3000,
+           4000,
+           std::nullopt,
+           kHugeMax,
+           -8424,
+           4000,
+           std::nullopt,
+           -1000,
+           5000,
+           kHugeMin,
+           2000},
+          type),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector(
+          std::vector<std::vector<std::optional<int128_t>>>{
+              {kHugeMin,
+               -8424,
+               -1000,
+               1000,
+               2000,
+               3000,
+               4000,
+               5000,
+               kHugeMax,
+               std::nullopt}},
+          ARRAY(type)),
+  });
+
+  testAggregations({data}, {}, {"set_agg(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Test with all NULL inputs (long decimals)
+  data = makeRowVector({
+      makeNullableFlatVector<int128_t>(
+          {std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt},
+          type),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector(
+          std::vector<std::vector<std::optional<int128_t>>>{{std::nullopt}},
+          ARRAY(type)),
+  });
+
+  testAggregations({data}, {}, {"set_agg(c0)"}, {"array_sort(a0)"}, {expected});
+}
+
 std::vector<std::optional<std::string>> generateStrings(
     const std::vector<std::optional<std::string>>& choices,
     vector_size_t size) {
@@ -413,5 +595,189 @@ TEST_F(SetAggTest, rowCheckNull) {
       "ROW comparison not supported for values that contain nulls");
 }
 
+TEST_F(SetAggTest, inputOrder) {
+  // Presto preserves order of input.
+
+  auto testInputOrder = [&](const RowVectorPtr& data,
+                            const RowVectorPtr& expected) {
+    auto plan = PlanBuilder()
+                    .values({data})
+                    .singleAggregation({}, {"set_agg(c0)"})
+                    .planNode();
+    assertQuery(plan, expected);
+  };
+
+  // Integers.
+
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {1, 2, 3, std::nullopt, 3, 4, 4, 5, 6, 7, std::nullopt}),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[1, 2, 3, null, 4, 5, 6, 7]"}),
+  });
+
+  testInputOrder(data, expected);
+
+  // Strings.
+  data = makeRowVector({
+      makeNullableFlatVector<StringView>(
+          {"abc",
+           "bxy",
+           "cde",
+           "abc",
+           "bxy",
+           "cdef",
+           "hijk",
+           std::nullopt,
+           "abc",
+           "some very long string to test long strings"}),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector<StringView>({
+          {"abc",
+           "bxy",
+           "cde",
+           "cdef",
+           "hijk",
+           std::nullopt,
+           "some very long string to test long strings"},
+      }),
+  });
+
+  testInputOrder(data, expected);
+
+  // Complex types.
+
+  data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2]",
+          "[5, 6]",
+          "null",
+          "[3, 4]",
+          "[1, 2]",
+          "[7, 8]",
+      }),
+  });
+
+  expected = makeRowVector({
+      makeNestedArrayVectorFromJson<int32_t>(
+          {"[[1,2], [5, 6], null, [3,4], [7, 8]]"}),
+  });
+
+  testInputOrder(data, expected);
+
+  // Group by
+  data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 2, 1, 1, 1, 2, 2, 1, 2, 1}),
+      makeNullableFlatVector<int32_t>(
+          {1, 2, 3, std::nullopt, 3, 4, 4, 5, 6, 7, std::nullopt}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, null, 3, 4, 6]",
+          "[2, 3, 4, 5, 7]",
+      }),
+  });
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .singleAggregation({"c0"}, {"set_agg(c1)"})
+                  .planNode();
+
+  assertQuery(plan, expected);
+}
+
+TEST_F(SetAggTest, nans) {
+  // Verify that NaNs with different binary representations are considered equal
+  // and deduplicated.
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+
+  // Global aggregation, Primitive type.
+  auto data = makeRowVector({
+      makeFlatVector<double>({1, 2, kNaN, 3, 4, kSNaN, 2, 4, kNaN}),
+      makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2, 2, 2, 2}),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<double>({
+          {1, 2, 3, 4, kNaN},
+      }),
+  });
+
+  testAggregations({data}, {}, {"set_agg(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Group by aggregation, Primitive type.
+  expected = makeRowVector({
+      makeArrayVector<double>({
+          {1, 2, kNaN},
+          {2, 3, 4, kNaN},
+      }),
+      makeFlatVector<int32_t>({1, 2}),
+  });
+
+  testAggregations(
+      {data}, {"c1"}, {"set_agg(c0)"}, {"array_sort(a0)", "c1"}, {expected});
+
+  // Global aggregation, Complex type key (ROW(String, Double)).
+  // Input Type:  Row(Row(string, double), int)
+  data = makeRowVector({
+      makeRowVector({
+          makeFlatVector<StringView>({
+              "a"_sv,
+              "b"_sv,
+              "c"_sv,
+              "a"_sv,
+              "b"_sv,
+              "c"_sv,
+              "a"_sv,
+              "b"_sv,
+              "c"_sv,
+          }),
+          makeFlatVector<double>({1, 2, kNaN, 1, 2, kSNaN, 1, 2, kNaN}),
+      }),
+      makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2, 2, 2, 2}),
+  });
+
+  // Output Type:  Row(Array(Row(string, double)), int)
+  expected = makeRowVector({makeArrayVector(
+      {0},
+      makeRowVector(
+          {makeFlatVector<StringView>({
+               "a"_sv,
+               "b"_sv,
+               "c"_sv,
+           }),
+           makeFlatVector<double>({1, 2, kNaN})}))});
+
+  testAggregations({data}, {}, {"set_agg(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Group by aggregation, Complex type.
+  // Ouput Type:  Row(Array(Row(string, double)), int)
+  expected = makeRowVector({
+      makeArrayVector(
+          {0, 3},
+          makeRowVector(
+              {makeFlatVector<StringView>({
+                   "a"_sv,
+                   "b"_sv,
+                   "c"_sv,
+                   "a"_sv,
+                   "b"_sv,
+                   "c"_sv,
+               }),
+               makeFlatVector<double>({1, 2, kNaN, 1, 2, kNaN})})),
+      makeFlatVector<int32_t>({1, 2}),
+  });
+
+  testAggregations(
+      {data}, {"c1"}, {"set_agg(c0)"}, {"array_sort(a0)", "c1"}, {expected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/SetUnionTest.cpp b/velox/functions/prestosql/aggregates/tests/SetUnionTest.cpp
index 17e27c54c240a..e8c15dfa5fe7a 100644
--- a/velox/functions/prestosql/aggregates/tests/SetUnionTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/SetUnionTest.cpp
@@ -15,7 +15,7 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::functions::aggregate::test;
@@ -24,11 +24,15 @@ namespace facebook::velox::aggregate::test {
 
 namespace {
 
+constexpr int64_t kLongMax = std::numeric_limits<int64_t>::max();
+constexpr int64_t kLongMin = std::numeric_limits<int64_t>::min();
+constexpr int128_t kHugeMax = std::numeric_limits<int128_t>::max();
+constexpr int128_t kHugeMin = std::numeric_limits<int128_t>::min();
+
 class SetUnionTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 };
 
@@ -225,5 +229,381 @@ TEST_F(SetUnionTest, groupBy) {
       {expected});
 }
 
+TEST_F(SetUnionTest, inputOrder) {
+  // Presto preserves order of input.
+
+  auto testInputOrder = [&](const RowVectorPtr& data,
+                            const RowVectorPtr& expected) {
+    auto plan = exec::test::PlanBuilder()
+                    .values({data})
+                    .singleAggregation({}, {"set_union(c0)"})
+                    .planNode();
+    assertQuery(plan, expected);
+  };
+
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[]",
+          "[1, 2, 3]",
+          "[1, 2, null]",
+          "[2, 3, 4, 5]",
+          "[6, 7]",
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeNullableArrayVector<int32_t>({
+          {1, 2, 3, std::nullopt, 4, 5, 6, 7},
+      }),
+  });
+
+  testInputOrder(data, expected);
+
+  // Strings.
+  data = makeRowVector({
+      makeNullableArrayVector<StringView>({
+          {},
+          {"abc", "bxy", "cde"},
+          {"abc", "bxy"},
+          {"cdef", "hijk", std::nullopt},
+          {"abc", "some very long string to test long strings"},
+      }),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector<StringView>({
+          {"abc",
+           "bxy",
+           "cde",
+           "cdef",
+           "hijk",
+           std::nullopt,
+           "some very long string to test long strings"},
+      }),
+  });
+
+  testInputOrder(data, expected);
+
+  // Complex types.
+
+  data = makeRowVector({makeNestedArrayVectorFromJson<int32_t>(
+      {"[[1,2], [5, 6], null]", "[[3,4], [7, 8], null]"})});
+
+  expected = makeRowVector({makeNestedArrayVectorFromJson<int32_t>(
+      {"[[1,2], [5, 6], null, [3,4], [7, 8]]"})});
+
+  testInputOrder(data, expected);
+
+  // Group by.
+  data = makeRowVector({
+      makeFlatVector<int16_t>({
+          1,
+          2,
+          1,
+          2,
+          1,
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[]",
+          "[1, 2, 3]",
+          "[1, 2, null]",
+          "[2, 3, 4, 5]",
+          "[6, 7]",
+      }),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, null, 6, 7]",
+          "[1, 2, 3, 4, 5]",
+      }),
+  });
+
+  auto plan = exec::test::PlanBuilder()
+                  .values({data})
+                  .singleAggregation({"c0"}, {"set_union(c1)"})
+                  .planNode();
+
+  assertQuery(plan, expected);
+}
+
+TEST_F(SetUnionTest, shortDecimal) {
+  // Test with short decimal
+  auto type = DECIMAL(6, 2);
+
+  auto data = makeRowVector({
+      makeArrayVector<int64_t>(
+          {
+              {},
+              {kLongMin, 2000, 3000},
+              {kLongMin, -2000},
+              {2000, 3000, kLongMax, 5000},
+              {6000, 7000, -5432},
+          },
+          type),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>(
+          {
+              {kLongMin, -5432, -2000, 2000, 3000, 5000, 6000, 7000, kLongMax},
+          },
+          type),
+  });
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Test with some NULL inputs (short decimals)
+  data = makeRowVector({
+      makeNullableArrayVector<int64_t>(
+          {
+              {},
+              {-1000, std::nullopt, kLongMax, std::nullopt, 7000},
+              {1000, kLongMax, std::nullopt, 4000, std::nullopt, std::nullopt},
+              {kLongMin, -5923},
+          },
+          ARRAY(type)),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector(
+          std::vector<std::vector<std::optional<int64_t>>>{
+              {kLongMin,
+               -5923,
+               -1000,
+               1000,
+               4000,
+               7000,
+               kLongMax,
+               std::nullopt},
+          },
+          ARRAY(type)),
+  });
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Test with all NULL inputs (short decimals)
+  data = makeRowVector({
+      makeAllNullArrayVector(10, type),
+  });
+
+  expected = makeRowVector({
+      makeArrayVector<int64_t>({{}}, type),
+  });
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+
+  data = makeRowVector({
+      makeNullableArrayVector<int64_t>(
+          {
+              {},
+              {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+              {std::nullopt, std::nullopt, std::nullopt},
+          },
+          ARRAY(type)),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector(
+          std::vector<std::vector<std::optional<int64_t>>>{
+              {std::nullopt},
+          },
+          ARRAY(type)),
+  });
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+}
+
+TEST_F(SetUnionTest, longDecimal) {
+  // Test with long decimals
+  auto type = DECIMAL(20, 2);
+
+  auto data = makeRowVector({
+      makeArrayVector<int128_t>(
+          {
+              {},
+              {kHugeMax, -2000, 3000},
+              {1000, 2000},
+              {2000, kHugeMin, 3000, 4000, 5000},
+              {-6363, 7000},
+          },
+          type),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<int128_t>(
+          {
+              {kHugeMin,
+               -6363,
+               -2000,
+               1000,
+               2000,
+               3000,
+               4000,
+               5000,
+               7000,
+               kHugeMax},
+          },
+          type),
+  });
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Test with some NULL inputs (long decimals).
+  data = makeRowVector({
+      makeNullableArrayVector<int128_t>(
+          {
+              {},
+              {kHugeMin},
+              {1000, std::nullopt, 3000, std::nullopt, 7000},
+              {-1000, 3000, std::nullopt, 4000, std::nullopt, std::nullopt},
+              {2000, kHugeMax, -1234},
+          },
+          ARRAY(type)),
+  });
+
+  expected = makeRowVector({
+      makeNullableArrayVector(
+          std::vector<std::vector<std::optional<int128_t>>>{
+              {kHugeMin,
+               -1234,
+               -1000,
+               1000,
+               2000,
+               3000,
+               4000,
+               7000,
+               kHugeMax,
+               std::nullopt},
+          },
+          ARRAY(type)),
+  });
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Test with all NULL inputs (long decimals).
+  data = makeRowVector({
+      makeAllNullArrayVector(10, type),
+  });
+
+  expected = makeRowVector({
+      makeArrayVector<int128_t>({{}}, type),
+  });
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+}
+
+TEST_F(SetUnionTest, nans) {
+  // Verify that NaNs with different binary representations are considered equal
+  // and deduplicated.
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+
+  // Global aggregation, Primitive type.
+  auto data = makeRowVector({
+      makeArrayVector<double>({
+          {1, 2, kNaN},
+          {3, 4, kNaN},
+          {3, 2, kSNaN},
+      }),
+      makeFlatVector<int32_t>({1, 2, 2}),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<double>({
+          {1, 2, 3, 4, kNaN},
+      }),
+  });
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Check again with kSNaN as the first NaN element to be encountered.
+  data = makeRowVector({
+      makeArrayVector<double>({
+          {1, 2, kSNaN},
+          {3, 4, kSNaN},
+          {3, 2, kNaN},
+      }),
+      makeFlatVector<int32_t>({1, 2, 2}),
+  });
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Group by aggregation, Primitive type.
+  expected = makeRowVector({
+      makeArrayVector<double>({
+          {1, 2, kNaN},
+          {2, 3, 4, kNaN},
+      }),
+      makeFlatVector<int32_t>({1, 2}),
+  });
+
+  testAggregations(
+      {data}, {"c1"}, {"set_union(c0)"}, {"array_sort(a0)", "c1"}, {expected});
+
+  // Global aggregation, Complex type.
+  data = makeRowVector({
+      makeArrayVector(
+          {0, 3, 6},
+          makeRowVector({
+              makeFlatVector<StringView>({
+                  "a"_sv,
+                  "b"_sv,
+                  "c"_sv,
+                  "a"_sv,
+                  "b"_sv,
+                  "c"_sv,
+                  "a"_sv,
+                  "b"_sv,
+                  "c"_sv,
+              }),
+              makeFlatVector<double>({1, 2, kNaN, 1, 2, kSNaN, 1, 2, kNaN}),
+          })),
+      makeFlatVector<int32_t>({1, 2, 2}),
+  });
+
+  expected = makeRowVector({makeArrayVector(
+      {0},
+      makeRowVector(
+          {makeFlatVector<StringView>({
+               "a"_sv,
+               "b"_sv,
+               "c"_sv,
+           }),
+           makeFlatVector<double>({1, 2, kNaN})}))});
+
+  testAggregations(
+      {data}, {}, {"set_union(c0)"}, {"array_sort(a0)"}, {expected});
+
+  // Group by aggregation, Complex type.
+  expected = makeRowVector({
+      makeArrayVector(
+          {0, 3},
+          makeRowVector(
+              {makeFlatVector<StringView>({
+                   "a"_sv,
+                   "b"_sv,
+                   "c"_sv,
+                   "a"_sv,
+                   "b"_sv,
+                   "c"_sv,
+               }),
+               makeFlatVector<double>({1, 2, kNaN, 1, 2, kNaN})})),
+      makeFlatVector<int32_t>({1, 2}),
+  });
+
+  testAggregations(
+      {data}, {"c1"}, {"set_union(c0)"}, {"array_sort(a0)", "c1"}, {expected});
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/SumDataSizeForStatsTest.cpp b/velox/functions/prestosql/aggregates/tests/SumDataSizeForStatsTest.cpp
index 4702b034bcd4c..ddd08f4525fce 100644
--- a/velox/functions/prestosql/aggregates/tests/SumDataSizeForStatsTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/SumDataSizeForStatsTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -27,7 +27,6 @@ class SumDataSizeForStatsTest : public AggregationTestBase {
  public:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 };
 
@@ -212,12 +211,12 @@ TEST_F(SumDataSizeForStatsTest, complexRecursiveGlobalAggregate) {
           createMapOfArraysVector<int8_t, int64_t>({
               {{1, std::nullopt}},
               {{2, {{4, 5, std::nullopt}}}},
-              {{std::nullopt, {{7, 8, 9}}}},
+              {{3, {{7, 8, 9}}}},
           }),
       }),
   })};
 
-  testAggregations(vectors, {}, {"sum_data_size_for_stats(c0)"}, "SELECT 118");
+  testAggregations(vectors, {}, {"sum_data_size_for_stats(c0)"}, "SELECT 115");
 }
 
 TEST_F(SumDataSizeForStatsTest, constantEncodingTest) {
@@ -256,7 +255,7 @@ TEST_F(SumDataSizeForStatsTest, dictionaryEncodingTest) {
       createMapOfArraysVector<int8_t, int64_t>({
           {{1, std::nullopt}},
           {{2, {{4, 5, std::nullopt}}}},
-          {{std::nullopt, {{7, 8, 9}}}},
+          {{3, {{7, 8, 9}}}},
       }),
   });
   vector_size_t size = 3;
@@ -269,10 +268,10 @@ TEST_F(SumDataSizeForStatsTest, dictionaryEncodingTest) {
       BaseVector::wrapInDictionary(nullptr, indices, size, columnTwo);
   auto vectors = {makeRowVector({columnOne, columnTwoDictionaryEncoded})};
 
-  testAggregations(vectors, {}, {"sum_data_size_for_stats(c1)"}, "SELECT 118");
+  testAggregations(vectors, {}, {"sum_data_size_for_stats(c1)"}, "SELECT 115");
 
   testAggregations(
-      vectors, {"c0"}, {"sum_data_size_for_stats(c1)"}, "VALUES (1,82),(2,36)");
+      vectors, {"c0"}, {"sum_data_size_for_stats(c1)"}, "VALUES (1,79),(2,36)");
 }
 
 TEST_F(SumDataSizeForStatsTest, mask) {
diff --git a/velox/functions/prestosql/aggregates/tests/SumTest.cpp b/velox/functions/prestosql/aggregates/tests/SumTest.cpp
index db97fcfc9155d..29767c935f158 100644
--- a/velox/functions/prestosql/aggregates/tests/SumTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/SumTest.cpp
@@ -18,7 +18,7 @@
 #include "velox/exec/AggregationHook.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/SumTestBase.h"
 
 using facebook::velox::exec::test::PlanBuilder;
 using namespace facebook::velox::exec::test;
@@ -28,152 +28,19 @@ namespace facebook::velox::aggregate::test {
 
 namespace {
 
-class SumTest : public AggregationTestBase {
- protected:
-  void SetUp() override {
-    AggregationTestBase::SetUp();
-    allowInputShuffle();
-  }
-
+class SumTest : public SumTestBase {
+ public:
   template <
       typename InputType,
       typename ResultType,
       typename IntermediateType = ResultType>
   void testAggregateOverflow(
       bool expectOverflow = false,
-      const TypePtr& type = CppToType<InputType>::create());
-};
-
-template <typename ResultType>
-void verifyAggregates(
-    const std::vector<std::pair<core::PlanNodePtr, ResultType>>& aggsToTest,
-    bool expectOverflow) {
-  for (const auto& [agg, expectedResult] : aggsToTest) {
-    if (expectOverflow) {
-      VELOX_ASSERT_THROW(readSingleValue(agg), "overflow");
-    } else {
-      auto result = readSingleValue(agg);
-      if constexpr (std::is_same_v<ResultType, float>) {
-        ASSERT_FLOAT_EQ(
-            result.template value<TypeKind::REAL>(), expectedResult);
-      } else if constexpr (std::is_same_v<ResultType, double>) {
-        ASSERT_FLOAT_EQ(
-            result.template value<TypeKind::DOUBLE>(), expectedResult);
-      } else {
-        ASSERT_EQ(result, expectedResult);
-      }
-    }
+      const TypePtr& type = CppToType<InputType>::create()) {
+    SumTestBase::testAggregateOverflow<InputType, ResultType, IntermediateType>(
+        "sum", expectOverflow, type);
   }
-}
-
-template <typename InputType, typename ResultType, typename IntermediateType>
-#if defined(__has_feature)
-#if __has_feature(__address_sanitizer__)
-__attribute__((no_sanitize("integer")))
-#endif
-#endif
-void SumTest::testAggregateOverflow(
-    bool expectOverflow,
-    const TypePtr& type) {
-  const InputType maxLimit = std::numeric_limits<InputType>::max();
-  const InputType overflow = InputType(1);
-  const InputType zero = InputType(0);
-
-  // Intermediate type size is always >= result type size. Hence, use
-  // intermediate type to calculate the expected output.
-  IntermediateType limitResult = IntermediateType(maxLimit);
-  IntermediateType overflowResult = IntermediateType(overflow);
-
-  // Single max limit value. 0's to induce dummy calculations.
-  auto limitVector =
-      makeRowVector({makeFlatVector<InputType>({maxLimit, zero, zero}, type)});
-
-  // Test code path for single values with possible overflow hit in add.
-  auto overflowFlatVector =
-      makeRowVector({makeFlatVector<InputType>({maxLimit, overflow}, type)});
-  IntermediateType expectedFlatSum = limitResult + overflowResult;
-
-  // Test code path for duplicate values with possible overflow hit in
-  // multiply.
-  auto overflowConstantVector =
-      makeRowVector({makeConstant<InputType>(maxLimit / 3, 4, type)});
-  IntermediateType expectedConstantSum = (limitResult / 3) * 4;
-
-  // Test code path for duplicate values with possible overflow hit in add.
-  auto overflowHybridVector = {limitVector, overflowConstantVector};
-  IntermediateType expectedHybridSum = limitResult + expectedConstantSum;
-
-  // Vector with element pairs of a partial aggregate node, expected result.
-  std::vector<std::pair<core::PlanNodePtr, IntermediateType>> partialAggsToTest;
-  // Partial Aggregation (raw input in - partial result out).
-  partialAggsToTest.push_back(
-      {PlanBuilder()
-           .values({overflowFlatVector})
-           .partialAggregation({}, {"sum(c0)"})
-           .planNode(),
-       expectedFlatSum});
-  partialAggsToTest.push_back(
-      {PlanBuilder()
-           .values({overflowConstantVector})
-           .partialAggregation({}, {"sum(c0)"})
-           .planNode(),
-       expectedConstantSum});
-  partialAggsToTest.push_back(
-      {PlanBuilder()
-           .values(overflowHybridVector)
-           .partialAggregation({}, {"sum(c0)"})
-           .planNode(),
-       expectedHybridSum});
-
-  // Vector with element pairs of a full aggregate node, expected result.
-  std::vector<std::pair<core::PlanNodePtr, ResultType>> aggsToTest;
-  // Single Aggregation (raw input in - final result out).
-  aggsToTest.push_back(
-      {PlanBuilder()
-           .values({overflowFlatVector})
-           .singleAggregation({}, {"sum(c0)"})
-           .planNode(),
-       expectedFlatSum});
-  aggsToTest.push_back(
-      {PlanBuilder()
-           .values({overflowConstantVector})
-           .singleAggregation({}, {"sum(c0)"})
-           .planNode(),
-       expectedConstantSum});
-  aggsToTest.push_back(
-      {PlanBuilder()
-           .values(overflowHybridVector)
-           .singleAggregation({}, {"sum(c0)"})
-           .planNode(),
-       expectedHybridSum});
-  // Final Aggregation (partial result in - final result out):
-  // To make sure that the overflow occurs in the final aggregation step, we
-  // create 2 plan fragments and plugging their partially aggregated
-  // output into a final aggregate plan node. Each of those input fragments
-  // only have a single input value under the max limit which when added in
-  // the final step causes a potential overflow.
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  aggsToTest.push_back(
-      {PlanBuilder(planNodeIdGenerator)
-           .localPartition(
-               {},
-               {PlanBuilder(planNodeIdGenerator)
-                    .values({limitVector})
-                    .partialAggregation({}, {"sum(c0)"})
-                    .planNode(),
-                PlanBuilder(planNodeIdGenerator)
-                    .values({limitVector})
-                    .partialAggregation({}, {"sum(c0)"})
-                    .planNode()})
-           .finalAggregation()
-           .planNode(),
-       limitResult + limitResult});
-
-  // Verify all partial aggregates.
-  verifyAggregates<IntermediateType>(partialAggsToTest, expectOverflow);
-  // Verify all aggregates.
-  verifyAggregates<ResultType>(aggsToTest, expectOverflow);
-}
+};
 
 TEST_F(SumTest, sumTinyint) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), TINYINT()});
@@ -244,6 +111,11 @@ TEST_F(SumTest, sumDoubleAndFloat) {
 }
 
 TEST_F(SumTest, sumDecimal) {
+  // Disable incremental aggregation tests because DecimalAggregate doesn't set
+  // StringView::prefix when extracting accumulators, leaving the prefix field
+  // undefined that fails the test.
+  AggregationTestBase::disableTestIncremental();
+
   // Skip testing with TableScan because decimal is not supported in writers.
   std::vector<std::optional<int64_t>> shortDecimalRawVector;
   std::vector<std::optional<int128_t>> longDecimalRawVector;
@@ -258,12 +130,7 @@ TEST_F(SumTest, sumDecimal) {
        makeNullableFlatVector<int128_t>(longDecimalRawVector, DECIMAL(23, 4))});
   createDuckDbTable({input});
   testAggregations(
-      {input},
-      {},
-      {"sum(c0)", "sum(c1)"},
-      "SELECT sum(c0), sum(c1) FROM tmp",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      {input}, {}, {"sum(c0)", "sum(c1)"}, "SELECT sum(c0), sum(c1) FROM tmp");
 
   // Decimal sum aggregation with multiple groups.
   auto inputRows = {
@@ -298,16 +165,14 @@ TEST_F(SumTest, sumDecimal) {
            makeFlatVector<int128_t>(
                std::vector<int128_t>{-7493}, DECIMAL(38, 2))})};
 
-  testAggregations(
-      inputRows,
-      {"c0"},
-      {"sum(c1)"},
-      expectedResult,
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations(inputRows, {"c0"}, {"sum(c1)"}, expectedResult);
+
+  AggregationTestBase::enableTestIncremental();
 }
 
 TEST_F(SumTest, sumDecimalOverflow) {
+  AggregationTestBase::disableTestIncremental();
+
   // Short decimals do not overflow easily.
   std::vector<int64_t> shortDecimalInput;
   for (int i = 0; i < 10'000; ++i) {
@@ -316,13 +181,7 @@ TEST_F(SumTest, sumDecimalOverflow) {
   auto input = makeRowVector(
       {makeFlatVector<int64_t>(shortDecimalInput, DECIMAL(17, 5))});
   createDuckDbTable({input});
-  testAggregations(
-      {input},
-      {},
-      {"sum(c0)"},
-      "SELECT sum(c0) FROM tmp",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations({input}, {}, {"sum(c0)"}, "SELECT sum(c0) FROM tmp");
 
   auto decimalSumOverflow = [this](
                                 const std::vector<int128_t>& input,
@@ -388,6 +247,8 @@ TEST_F(SumTest, sumDecimalOverflow) {
   VELOX_ASSERT_THROW(
       decimalSumOverflow(longDecimalInput, longDecimalOutput),
       "Value '-100000000000000000000000000000000000000' is not in the range of Decimal Type");
+
+  AggregationTestBase::enableTestIncremental();
 }
 
 TEST_F(SumTest, sumWithMask) {
@@ -537,12 +398,6 @@ TEST_F(SumTest, nulls) {
       "SELECT c0, sum(c1) as sum_c1 FROM tmp GROUP BY 1");
 }
 
-template <typename Type>
-struct SumRow {
-  char nulls;
-  Type sum;
-};
-
 TEST_F(SumTest, hook) {
   SumRow<int64_t> sumRow;
   sumRow.nulls = 1;
@@ -550,7 +405,7 @@ TEST_F(SumTest, hook) {
 
   char* row = reinterpret_cast<char*>(&sumRow);
   uint64_t numNulls = 1;
-  aggregate::SumHook<int64_t, int64_t> hook(
+  aggregate::SumHook<int64_t> hook(
       offsetof(SumRow<int64_t>, sum),
       offsetof(SumRow<int64_t>, nulls),
       1,
@@ -558,47 +413,12 @@ TEST_F(SumTest, hook) {
       &numNulls);
 
   int64_t value = 11;
-  hook.addValue(0, &value);
+  hook.addValue(0, value);
   EXPECT_EQ(0, sumRow.nulls);
   EXPECT_EQ(0, numNulls);
   EXPECT_EQ(value, sumRow.sum);
 }
 
-template <typename InputType, typename ResultType>
-void testHookLimits(bool expectOverflow = false) {
-  // Pair of <limit, value to overflow>.
-  std::vector<std::pair<InputType, InputType>> limits = {
-      {std::numeric_limits<InputType>::min(), -1},
-      {std::numeric_limits<InputType>::max(), 1}};
-
-  for (const auto& [limit, overflow] : limits) {
-    SumRow<ResultType> sumRow;
-    sumRow.sum = 0;
-    ResultType expected = 0;
-    char* row = reinterpret_cast<char*>(&sumRow);
-    uint64_t numNulls = 0;
-    aggregate::SumHook<InputType, ResultType> hook(
-        offsetof(SumRow<ResultType>, sum),
-        offsetof(SumRow<ResultType>, nulls),
-        0,
-        &row,
-        &numNulls);
-
-    // Adding limit should not overflow.
-    ASSERT_NO_THROW(hook.addValue(0, &limit));
-    expected += limit;
-    EXPECT_EQ(expected, sumRow.sum);
-    // Adding overflow based on the ResultType should throw.
-    if (expectOverflow) {
-      VELOX_ASSERT_THROW(hook.addValue(0, &overflow), "overflow");
-    } else {
-      ASSERT_NO_THROW(hook.addValue(0, &overflow));
-      expected += overflow;
-      EXPECT_EQ(expected, sumRow.sum);
-    }
-  }
-}
-
 TEST_F(SumTest, hookLimits) {
   testHookLimits<int32_t, int64_t>();
   testHookLimits<int64_t, int64_t>(true);
diff --git a/velox/functions/prestosql/aggregates/tests/VarianceAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/VarianceAggregationTest.cpp
index a4ee8b1bff754..c298c418636d1 100644
--- a/velox/functions/prestosql/aggregates/tests/VarianceAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/VarianceAggregationTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
@@ -41,7 +41,6 @@ class VarianceAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
   }
 
   RowTypePtr rowType_{
@@ -159,8 +158,7 @@ TEST_F(VarianceAggregationTest, varianceNulls) {
 // when inputs are very large integers (> 15 digits long). Unfortunately
 // makeVectors() generates data that contains a lot of very large integers.
 // Replace makeVectors() with a dataset that doesn't contain very large
-// integers and enable more testing by calling allowInputShuffle() from
-// Setup().
+// integers and enable more testing.
 TEST_F(VarianceAggregationTest, varianceWithGlobalAggregation) {
   auto vectors = makeVectors(rowType_, 10, 20);
   createDuckDbTable(vectors);
@@ -292,5 +290,22 @@ TEST_F(VarianceAggregationTest, varianceWithoutPrecisionLoss) {
   }
 }
 
+TEST_F(VarianceAggregationTest, varianceMergeEmpty) {
+  auto accumulators = makeRowVector({
+      makeRowVector({
+          makeFlatVector<int64_t>({0, 2}),
+          makeFlatVector<double>({0, 1.45419e163}),
+          makeFlatVector<double>({0, HUGE_VAL}),
+      }),
+  });
+  auto node = PlanBuilder(pool())
+                  .values({accumulators})
+                  .finalAggregation({}, {"variance(c0)"}, {{DOUBLE()}})
+                  .planNode();
+  auto expected =
+      makeRowVector({makeFlatVector(std::vector<double>({HUGE_VAL}))});
+  AssertQueryBuilder(node).assertResults(expected);
+}
+
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/benchmarks/ArrayConcatBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayConcatBenchmark.cpp
new file mode 100644
index 0000000000000..35b99ffed951e
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/ArrayConcatBenchmark.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  facebook::velox::functions::prestosql::registerAllScalarFunctions();
+
+  auto* pool = benchmarkBuilder.pool();
+  auto& vm = benchmarkBuilder.vectorMaker();
+
+  auto createSet =
+      [&](const TypePtr& elementType,
+          const std::vector<int>& containerLengths = {5, 10, 20, 40}) {
+        VectorFuzzer::Options options;
+        options.vectorSize = 1000;
+        options.complexElementsMaxSize = 1'000'000;
+        options.containerVariableLength = false;
+
+        for (auto length : containerLengths) {
+          options.containerLength = length;
+          options.stringLength = length;
+          VectorFuzzer fuzzer(options, pool);
+
+          std::vector<VectorPtr> columns;
+          for (int i = 0; i < 4; i++) {
+            columns.push_back(fuzzer.fuzz(ARRAY(elementType)));
+          }
+
+          benchmarkBuilder
+              .addBenchmarkSet(
+                  fmt::format(
+                      "array_concat_{}_{}",
+                      elementType->toString(),
+                      options.containerLength),
+                  vm.rowVector(columns))
+              .addExpression("2arg", "concat(c0, c1)")
+              .addExpression("3arg", "concat(c0, c1, c2)")
+              .addExpression("4arg", "concat(c0, c1, c2, c3)");
+        }
+      };
+
+  createSet(INTEGER());
+  createSet(VARCHAR());
+  createSet(BOOLEAN());
+
+  benchmarkBuilder.registerBenchmarks();
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
index 8b8acdc2be801..c9d728961dbe8 100644
--- a/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
@@ -28,48 +28,70 @@ int main(int argc, char** argv) {
   folly::Init init(&argc, &argv);
 
   functions::prestosql::registerArrayFunctions();
+  memory::MemoryManager::initialize({});
+  auto anotherPool = memory::memoryManager()->addLeafPool("bm");
 
   ExpressionBenchmarkBuilder benchmarkBuilder;
 
   auto* pool = benchmarkBuilder.pool();
   auto& vm = benchmarkBuilder.vectorMaker();
 
-  auto createSet =
-      [&](const TypePtr& type, bool withNulls, const VectorPtr& constantInput) {
-        VectorFuzzer::Options options;
-        options.vectorSize = 1'000;
-        options.nullRatio = withNulls ? 0.2 : 0.0;
-
-        VectorFuzzer fuzzer(options, pool);
-        std::vector<VectorPtr> columns;
-        columns.push_back(fuzzer.fuzzFlat(type));
-        columns.push_back(fuzzer.fuzzFlat(type));
-        columns.push_back(fuzzer.fuzzFlat(type));
-        columns.push_back(
-            BaseVector::createNullConstant(type, options.vectorSize, pool));
-        columns.push_back(
-            BaseVector::wrapInConstant(options.vectorSize, 0, constantInput));
-
-        auto input = vm.rowVector({"c0", "c1", "c2", "n", "c"}, columns);
-
-        benchmarkBuilder
-            .addBenchmarkSet(
-                fmt::format(
-                    "array_constructor_{}_{}",
-                    mapTypeKindToName(type->kind()),
-                    withNulls ? "nulls" : "nullfree"),
-                input)
-            .addExpression("1", "array_constructor(c0)")
-            .addExpression("2", "array_constructor(c0, c1)")
-            .addExpression("3", "array_constructor(c0, c1, c2)")
-            .addExpression("2_null", "array_constructor(c0, c1, n)")
-            .addExpression("2_const", "array_constructor(c0, c1, c)");
-      };
+  auto createSet = [&](const TypePtr& type,
+                       bool withNulls,
+                       const VectorPtr& constantInput,
+                       const std::string& suffix = "") {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.nullRatio = withNulls ? 0.2 : 0.0;
+
+    VectorFuzzer fuzzer(options, pool);
+    std::vector<VectorPtr> columns;
+    columns.push_back(fuzzer.fuzzFlat(type));
+    columns.push_back(fuzzer.fuzzFlat(type));
+    columns.push_back(fuzzer.fuzzFlat(type));
+    columns.push_back(
+        BaseVector::createNullConstant(type, options.vectorSize, pool));
+    columns.push_back(
+        BaseVector::wrapInConstant(options.vectorSize, 0, constantInput));
+
+    auto input = vm.rowVector({"c0", "c1", "c2", "n", "c"}, columns);
+
+    benchmarkBuilder
+        .addBenchmarkSet(
+            fmt::format(
+                "array_constructor_{}_{}{}",
+                mapTypeKindToName(type->kind()),
+                withNulls ? "nulls" : "nullfree",
+                suffix),
+            input)
+        .addExpression("1", "array_constructor(c0)")
+        .addExpression("2", "array_constructor(c0, c1)")
+        .addExpression("3", "array_constructor(c0, c1, c2)")
+        .addExpression("2_null", "array_constructor(c0, c1, n)")
+        .addExpression("2_const", "array_constructor(c0, c1, c)");
+  };
 
   auto constantInteger = BaseVector::createConstant(INTEGER(), 11, 1, pool);
   createSet(INTEGER(), true, constantInteger);
   createSet(INTEGER(), false, constantInteger);
 
+  {
+    auto constantString =
+        BaseVector::createConstant(VARCHAR(), std::string(20, 'x'), 1, pool);
+    createSet(VARCHAR(), true, constantString);
+    createSet(VARCHAR(), false, constantString);
+  }
+
+  pool = anotherPool.get();
+  {
+    auto constantString =
+        BaseVector::createConstant(VARCHAR(), std::string(20, 'x'), 1, pool);
+    createSet(VARCHAR(), true, constantString, "_dp");
+    createSet(VARCHAR(), false, constantString, "_dp");
+  }
+
+  pool = benchmarkBuilder.pool();
+
   auto constantRow = vm.rowVector({
       BaseVector::createConstant(INTEGER(), 11, 1, pool),
       BaseVector::createConstant(DOUBLE(), 1.23, 1, pool),
diff --git a/velox/functions/prestosql/benchmarks/ArrayContainsBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayContainsBenchmark.cpp
index 3d452e1d9b3e0..07ce2ea8e9640 100644
--- a/velox/functions/prestosql/benchmarks/ArrayContainsBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayContainsBenchmark.cpp
@@ -18,7 +18,6 @@
 #include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/Registerer.h"
-#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 
 using namespace facebook::velox;
@@ -26,52 +25,55 @@ using namespace facebook::velox::exec;
 
 namespace {
 
-template <typename T>
-VELOX_UDF_BEGIN(contains)
-FOLLY_ALWAYS_INLINE bool call(
-    bool& out,
-    const arg_type<Array<T>>& array,
-    const arg_type<T>& key) {
-  if (array.mayHaveNulls()) {
-    auto nullFound = false;
-    for (const auto& item : array) {
-      if (item.has_value()) {
-        if (*item == key) {
-          out = true;
-          return true;
+template <typename TExec>
+struct udf_contains {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      bool& out,
+      const arg_type<Array<int32_t>>& array,
+      const arg_type<int32_t>& key) {
+    if (array.mayHaveNulls()) {
+      auto nullFound = false;
+      for (const auto& item : array) {
+        if (item.has_value()) {
+          if (*item == key) {
+            out = true;
+            return true;
+          }
+          continue;
         }
-        continue;
+        nullFound = true;
       }
-      nullFound = true;
-    }
 
-    if (!nullFound) {
-      out = false;
-      return true;
+      if (!nullFound) {
+        out = false;
+        return true;
+      }
+      return false;
     }
-    return false;
-  }
 
-  // Not nulls path
-  for (const auto& item : array) {
-    if (*item == key) {
-      out = true;
-      return true;
+    // Not nulls path
+    for (const auto& item : array) {
+      if (*item == key) {
+        out = true;
+        return true;
+      }
     }
+    out = false;
+    return true;
   }
-  out = false;
-  return true;
-}
-VELOX_UDF_END();
+};
 
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
   functions::prestosql::registerArrayFunctions();
 
   registerFunction<
-      udf_contains<int32_t>,
+      udf_contains,
       bool,
       facebook::velox::Array<int32_t>,
       int32_t>({"contains_alt"});
diff --git a/velox/functions/prestosql/benchmarks/ArrayMinMaxBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayMinMaxBenchmark.cpp
index e3249b41d0002..243e4124e5a16 100644
--- a/velox/functions/prestosql/benchmarks/ArrayMinMaxBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayMinMaxBenchmark.cpp
@@ -46,7 +46,7 @@ void registerTestSimpleFunctions() {
 using namespace facebook::velox;
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   functions::prestosql::registerArrayFunctions();
 
   functions::registerTestVectorFunctionBasic();
diff --git a/velox/functions/prestosql/benchmarks/ArrayPositionBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayPositionBenchmark.cpp
index 81cb138c65247..c59741fa6c1cb 100644
--- a/velox/functions/prestosql/benchmarks/ArrayPositionBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayPositionBenchmark.cpp
@@ -222,7 +222,7 @@ BENCHMARK_RELATIVE(vectorBasicIntegerWithInstance) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/ArraySumBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArraySumBenchmark.cpp
index 4b649cd55fa40..ec2b88e94a770 100644
--- a/velox/functions/prestosql/benchmarks/ArraySumBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArraySumBenchmark.cpp
@@ -27,7 +27,7 @@ using namespace facebook::velox::exec;
 using namespace facebook::velox::functions;
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   functions::prestosql::registerArrayFunctions();
   registerFunction<ArraySumFunction, int64_t, Array<int32_t>>(
diff --git a/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
index 191ec5c1b48fb..3afff9df542fe 100644
--- a/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
@@ -130,7 +130,7 @@ class ArrayWriterBenchmark : public functions::test::FunctionBenchmarkBase {
  public:
   ArrayWriterBenchmark() : FunctionBenchmarkBase() {
     registerFunction<SimpleFunctionResize, Array<int64_t>, int64_t>(
-        {"simpl_resize"});
+        {"simple_resize"});
     registerFunction<SimpleFunctionPushBack, Array<int64_t>, int64_t>(
         {"simple_push_back"});
     registerFunction<SimpleGeneralInterface, Array<int64_t>, int64_t>(
@@ -275,7 +275,8 @@ BENCHMARK_MULTI(std_reference) {
 } // namespace facebook::velox::exec
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  facebook::velox::memory::MemoryManager::initialize({});
 
   facebook::velox::exec::ArrayWriterBenchmark benchmark;
   benchmark.test();
diff --git a/velox/functions/prestosql/benchmarks/BitwiseBenchmark.cpp b/velox/functions/prestosql/benchmarks/BitwiseBenchmark.cpp
index 712441e7e2a96..18d1d0c0b46f7 100644
--- a/velox/functions/prestosql/benchmarks/BitwiseBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/BitwiseBenchmark.cpp
@@ -27,25 +27,32 @@ using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::functions;
 
-VELOX_UDF_BEGIN(bitwise_arithmetic_shift_right_nocheck)
-FOLLY_ALWAYS_INLINE bool call(int64_t& result, int64_t number, int64_t shift) {
-  result = number >> shift;
-  return true;
-}
-VELOX_UDF_END();
+template <typename TExec>
+struct udf_bitwise_arithmetic_shift_right_nocheck {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
 
-VELOX_UDF_BEGIN(bitwise_logical_shift_right_nocheck)
-FOLLY_ALWAYS_INLINE bool
-call(int64_t& result, int64_t number, int64_t shift, int64_t bits) {
-  if (bits == 64) {
+  FOLLY_ALWAYS_INLINE bool
+  call(int64_t& result, int64_t number, int64_t shift) {
     result = number >> shift;
     return true;
   }
+};
 
-  result = (number & ((1LL << bits) - 1)) >> shift;
-  return true;
-}
-VELOX_UDF_END();
+template <typename TExec>
+struct udf_bitwise_logical_shift_right_nocheck {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE bool
+  call(int64_t& result, int64_t number, int64_t shift, int64_t bits) {
+    if (bits == 64) {
+      result = number >> shift;
+      return true;
+    }
+
+    result = (number & ((1LL << bits) - 1)) >> shift;
+    return true;
+  }
+};
 
 class BitwiseBenchmark : public functions::test::FunctionBenchmarkBase {
  public:
@@ -154,7 +161,8 @@ BENCHMARK_RELATIVE(bitwise_shift_left) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize({});
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/CMakeLists.txt b/velox/functions/prestosql/benchmarks/CMakeLists.txt
index a671b63f7831a..0c1ac0f026e47 100644
--- a/velox/functions/prestosql/benchmarks/CMakeLists.txt
+++ b/velox/functions/prestosql/benchmarks/CMakeLists.txt
@@ -27,29 +27,35 @@ set(BENCHMARK_DEPENDENCIES
 
 add_executable(velox_functions_prestosql_benchmarks_array_contains
                ArrayContainsBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_array_contains
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_array_contains ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_array_min_max
                ArrayMinMaxBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_array_min_max
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_array_min_max ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_array_position
                ArrayPositionBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_array_position
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_array_position ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_array_sum
                ArraySumBenchmark.cpp)
 
-target_link_libraries(velox_functions_prestosql_benchmarks_array_sum
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_array_sum ${BENCHMARK_DEPENDENCIES})
+
+add_executable(velox_functions_prestosql_benchmarks_field_reference
+               FieldReferenceBenchmark.cpp)
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_field_reference
+  ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_width_bucket
                WidthBucketBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_width_bucket
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_width_bucket ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_string_ascii_utf_functions
                StringAsciiUTFFunctionBenchmarks.cpp)
@@ -58,51 +64,54 @@ target_link_libraries(
   ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_not NotBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_not
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_not ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_date_time
                DateTimeBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_date_time
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_date_time velox_type_tz
+  ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_bitwise
                BitwiseBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_bitwise
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_bitwise ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_in InBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_in
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_in ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_map_input
                MapInputBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_map_input
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_map_input ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_benchmarks_url URLBenchmark.cpp)
-target_link_libraries(velox_functions_benchmarks_url ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_benchmarks_url ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_benchmarks_compare CompareBenchmark.cpp)
-target_link_libraries(velox_functions_benchmarks_compare
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_benchmarks_compare ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_benchmark_array_writer_with_nulls ArrayWriterBenchmark.cpp)
 target_compile_definitions(velox_benchmark_array_writer_with_nulls
                            PUBLIC WITH_NULLS=true)
-target_link_libraries(velox_benchmark_array_writer_with_nulls
-                      ${BENCHMARK_DEPENDENCIES_NO_FUNC})
+target_link_libraries(
+  velox_benchmark_array_writer_with_nulls ${BENCHMARK_DEPENDENCIES_NO_FUNC})
 
 add_executable(velox_benchmark_array_writer_no_nulls ArrayWriterBenchmark.cpp)
-target_link_libraries(velox_benchmark_array_writer_no_nulls
-                      ${BENCHMARK_DEPENDENCIES_NO_FUNC})
+target_link_libraries(
+  velox_benchmark_array_writer_no_nulls ${BENCHMARK_DEPENDENCIES_NO_FUNC})
 target_compile_definitions(velox_benchmark_array_writer_no_nulls
                            PUBLIC WITH_NULLS=false)
 
 add_executable(velox_benchmark_nested_array_writer_no_nulls
                NestedArrayWriterBenchmark.cpp)
-target_link_libraries(velox_benchmark_nested_array_writer_no_nulls
-                      ${BENCHMARK_DEPENDENCIES_NO_FUNC})
+target_link_libraries(
+  velox_benchmark_nested_array_writer_no_nulls
+  ${BENCHMARK_DEPENDENCIES_NO_FUNC})
 target_compile_definitions(velox_benchmark_nested_array_writer_no_nulls
                            PUBLIC WITH_NULLS=false)
 
@@ -110,64 +119,88 @@ add_executable(velox_benchmark_nested_array_writer_with_nulls
                NestedArrayWriterBenchmark.cpp)
 target_compile_definitions(velox_benchmark_nested_array_writer_with_nulls
                            PUBLIC WITH_NULLS=true)
-target_link_libraries(velox_benchmark_nested_array_writer_with_nulls
-                      ${BENCHMARK_DEPENDENCIES_NO_FUNC})
+target_link_libraries(
+  velox_benchmark_nested_array_writer_with_nulls
+  ${BENCHMARK_DEPENDENCIES_NO_FUNC})
 
 add_executable(velox_benchmark_map_writer_with_nulls MapWriterBenchmarks.cpp)
 target_compile_definitions(velox_benchmark_map_writer_with_nulls
                            PUBLIC WITH_NULLS=true)
-target_link_libraries(velox_benchmark_map_writer_with_nulls
-                      ${BENCHMARK_DEPENDENCIES_NO_FUNC})
+target_link_libraries(
+  velox_benchmark_map_writer_with_nulls ${BENCHMARK_DEPENDENCIES_NO_FUNC})
 
 add_executable(velox_benchmark_map_writer_no_nulls MapWriterBenchmarks.cpp)
-target_link_libraries(velox_benchmark_map_writer_no_nulls
-                      ${BENCHMARK_DEPENDENCIES_NO_FUNC})
+target_link_libraries(
+  velox_benchmark_map_writer_no_nulls ${BENCHMARK_DEPENDENCIES_NO_FUNC})
 target_compile_definitions(velox_benchmark_map_writer_no_nulls
                            PUBLIC WITH_NULLS=false)
 
 add_executable(velox_functions_benchmarks_row_writer_no_nulls
                RowWriterBenchmark.cpp)
-target_link_libraries(velox_functions_benchmarks_row_writer_no_nulls
-                      ${BENCHMARK_DEPENDENCIES_NO_FUNC})
+target_link_libraries(
+  velox_functions_benchmarks_row_writer_no_nulls
+  ${BENCHMARK_DEPENDENCIES_NO_FUNC})
 
 add_executable(velox_functions_benchmarks_string_writer_no_nulls
                StringWriterBenchmark.cpp)
-target_link_libraries(velox_functions_benchmarks_string_writer_no_nulls
-                      ${BENCHMARK_DEPENDENCIES_NO_FUNC})
+target_link_libraries(
+  velox_functions_benchmarks_string_writer_no_nulls
+  ${BENCHMARK_DEPENDENCIES_NO_FUNC})
 
 add_executable(velox_functions_prestosql_benchmarks_zip ZipBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_zip
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_zip ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_row Row.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_row
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_row ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_comparisons
                ComparisonsBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_comparisons
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_comparisons ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_concat ConcatBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_concat
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_concat ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_zip_with
                ZipWithBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_zip_with
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_zip_with ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_map_zip_with
                MapZipWithBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_map_zip_with
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_map_zip_with ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_prestosql_benchmarks_cardinality
                CardinalityBenchmark.cpp)
-target_link_libraries(velox_functions_prestosql_benchmarks_cardinality
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_cardinality ${BENCHMARK_DEPENDENCIES})
 
 add_executable(velox_functions_benchmarks_simdjson_function_with_expr
                JsonExprBenchmark.cpp)
-target_link_libraries(velox_functions_benchmarks_simdjson_function_with_expr
-                      ${BENCHMARK_DEPENDENCIES})
+target_link_libraries(
+  velox_functions_benchmarks_simdjson_function_with_expr
+  ${BENCHMARK_DEPENDENCIES})
+
+add_executable(velox_functions_prestosql_benchmarks_map_subscript
+               MapSubscriptCachingBenchmark.cpp)
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_map_subscript ${BENCHMARK_DEPENDENCIES})
+
+add_executable(velox_functions_prestosql_benchmarks_regexp_replace
+               RegexpReplaceBenchmark.cpp)
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_regexp_replace ${BENCHMARK_DEPENDENCIES})
+
+add_executable(velox_functions_prestosql_benchmarks_generic
+               GenericBenchmark.cpp)
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_generic ${BENCHMARK_DEPENDENCIES})
+
+add_executable(velox_functions_prestosql_benchmarks_uuid_cast
+               UuidCastBenchmark.cpp)
+target_link_libraries(
+  velox_functions_prestosql_benchmarks_uuid_cast ${BENCHMARK_DEPENDENCIES})
diff --git a/velox/functions/prestosql/benchmarks/CardinalityBenchmark.cpp b/velox/functions/prestosql/benchmarks/CardinalityBenchmark.cpp
index 99c7f84d21d04..720b1d70b2b32 100644
--- a/velox/functions/prestosql/benchmarks/CardinalityBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/CardinalityBenchmark.cpp
@@ -238,7 +238,7 @@ BENCHMARK(vectorConditional) {
 }
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   LOG(ERROR) << "Seed: " << seed;
   {
diff --git a/velox/functions/prestosql/benchmarks/CompareBenchmark.cpp b/velox/functions/prestosql/benchmarks/CompareBenchmark.cpp
index 49c1e790c3bee..6253de929114a 100644
--- a/velox/functions/prestosql/benchmarks/CompareBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/CompareBenchmark.cpp
@@ -180,7 +180,7 @@ BENCHMARK_MULTI(Gt_Velox) {
 } // namespace facebook::velox::functions::test
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/ComparisonsBenchmark.cpp b/velox/functions/prestosql/benchmarks/ComparisonsBenchmark.cpp
index 4331b986e10b8..601c7c3f22a70 100644
--- a/velox/functions/prestosql/benchmarks/ComparisonsBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ComparisonsBenchmark.cpp
@@ -28,6 +28,10 @@ namespace facebook::velox::functions {
 void registerVectorFunctions() {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_simd_comparison_eq, "eq");
   registerBinaryScalar<EqFunction, bool>({"nonsimd_eq"});
+  registerFunction<EqFunction, bool, IntervalDayTime, IntervalDayTime>(
+      {"nonsimd_eq"});
+  registerFunction<EqFunction, bool, IntervalYearMonth, IntervalYearMonth>(
+      {"nonsimd_eq"});
 }
 
 } // namespace facebook::velox::functions
@@ -44,40 +48,22 @@ class ComparisonsBechmark
     registerVectorFunctions();
   }
 
-  template <TypeKind kind>
-  RowVectorPtr createRowData() {
-    VELOX_CHECK(TypeTraits<kind>::isPrimitiveType);
+  RowVectorPtr createRowData(const TypePtr& type) {
     VectorFuzzer::Options opts;
     opts.nullRatio = 0;
     opts.vectorSize = 10'000;
     VectorFuzzer fuzzer(opts, execCtx_.pool());
-    auto type = TypeTraits<kind>::ImplType::create();
-    auto vectorLeft = fuzzer.fuzzFlat(type);
-    auto vectorRight = fuzzer.fuzzFlat(type);
-    return vectorMaker_.rowVector({vectorLeft, vectorRight});
-  }
 
-  template <TypeKind kind>
-  void runNonSimdComparison() {
-    folly::BenchmarkSuspender suspender;
-    auto rowVector = createRowData<kind>();
-    auto exprSet = compileExpression("nonsimd_eq(c0, c1)", rowVector->type());
-    suspender.dismiss();
-
-    doRun(exprSet, rowVector);
+    return fuzzer.fuzzInputFlatRow(ROW({"c0", "c1"}, {type, type}));
   }
 
-  template <TypeKind kind>
-  void runSimdComparison() {
+  void run(const std::string& name, const TypePtr& type) {
     folly::BenchmarkSuspender suspender;
-    registerVectorFunctions();
-    auto rowVector = createRowData<kind>();
-    auto exprSet = compileExpression("eq(c0, c1)", rowVector->type());
+    auto rowVector = createRowData(type);
+    auto exprSet =
+        compileExpression(fmt::format("{}(c0, c1)", name), rowVector->type());
     suspender.dismiss();
-    doRun(exprSet, rowVector);
-  }
 
-  void doRun(ExprSet& exprSet, const RowVectorPtr& rowVector) {
     uint32_t cnt = 0;
     for (auto i = 0; i < 100; i++) {
       cnt += evaluate(exprSet, rowVector)->size();
@@ -86,31 +72,90 @@ class ComparisonsBechmark
   }
 };
 
+std::unique_ptr<ComparisonsBechmark> benchmark;
+
 BENCHMARK(non_simd_bigint_eq) {
-  ComparisonsBechmark benchmark;
-  benchmark.runNonSimdComparison<TypeKind::BIGINT>();
+  benchmark->run("nonsimd_eq", BIGINT());
 }
 
 BENCHMARK_RELATIVE(simd_bigint_eq) {
-  ComparisonsBechmark benchmark;
-  benchmark.runSimdComparison<TypeKind::BIGINT>();
+  benchmark->run("eq", BIGINT());
+}
+
+BENCHMARK(non_simd_integer_eq) {
+  benchmark->run("nonsimd_eq", INTEGER());
+}
+
+BENCHMARK_RELATIVE(simd_integer_eq) {
+  benchmark->run("eq", INTEGER());
+}
+
+BENCHMARK(non_simd_smallint_eq) {
+  benchmark->run("nonsimd_eq", SMALLINT());
+}
+
+BENCHMARK_RELATIVE(simd_smallint_eq) {
+  benchmark->run("eq", SMALLINT());
 }
 
 BENCHMARK(non_simd_tinyint_eq) {
-  ComparisonsBechmark benchmark;
-  benchmark.runNonSimdComparison<TypeKind::TINYINT>();
+  benchmark->run("nonsimd_eq", TINYINT());
 }
 
 BENCHMARK_RELATIVE(simd_tinyint_eq) {
-  ComparisonsBechmark benchmark;
-  benchmark.runSimdComparison<TypeKind::TINYINT>();
+  benchmark->run("eq", TINYINT());
+}
+
+BENCHMARK(non_simd_double_eq) {
+  benchmark->run("nonsimd_eq", DOUBLE());
+}
+
+BENCHMARK_RELATIVE(simd_double_eq) {
+  benchmark->run("eq", DOUBLE());
+}
+
+BENCHMARK(non_simd_real_eq) {
+  benchmark->run("nonsimd_eq", REAL());
+}
+
+BENCHMARK_RELATIVE(simd_real_eq) {
+  benchmark->run("eq", REAL());
+}
+
+BENCHMARK(non_simd_date_eq) {
+  benchmark->run("nonsimd_eq", DATE());
+}
+
+BENCHMARK_RELATIVE(simd_date_eq) {
+  benchmark->run("eq", DATE());
+}
+
+BENCHMARK(non_simd_interval_day_time_eq) {
+  benchmark->run("nonsimd_eq", INTERVAL_DAY_TIME());
+}
+
+BENCHMARK_RELATIVE(simd_interval_day_time_eq) {
+  benchmark->run("eq", INTERVAL_DAY_TIME());
+}
+
+BENCHMARK(non_simd_interval_year_month_eq) {
+  benchmark->run("nonsimd_eq", INTERVAL_YEAR_MONTH());
+}
+
+BENCHMARK_RELATIVE(simd_interval_year_month_eq) {
+  benchmark->run("eq", INTERVAL_YEAR_MONTH());
 }
 
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
+  facebook::velox::memory::MemoryManager::initialize({});
+
+  benchmark = std::make_unique<ComparisonsBechmark>();
   folly::runBenchmarks();
+
+  benchmark.reset();
   return 0;
 }
diff --git a/velox/functions/prestosql/benchmarks/ConcatBenchmark.cpp b/velox/functions/prestosql/benchmarks/ConcatBenchmark.cpp
index 56b0ee058ba5c..b753c95f11550 100644
--- a/velox/functions/prestosql/benchmarks/ConcatBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ConcatBenchmark.cpp
@@ -137,7 +137,7 @@ BENCHMARK_MULTI(flattenAndConstantFold, n) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   LOG(ERROR) << "Seed: " << seed;
   {
diff --git a/velox/functions/prestosql/benchmarks/DateTimeBenchmark.cpp b/velox/functions/prestosql/benchmarks/DateTimeBenchmark.cpp
index 4348e99a81459..10fb319dcd659 100644
--- a/velox/functions/prestosql/benchmarks/DateTimeBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/DateTimeBenchmark.cpp
@@ -16,9 +16,9 @@
 #include <folly/Benchmark.h>
 #include <folly/init/Init.h>
 #include "velox/expression/VectorFunction.h"
-#include "velox/external/date/tz.h"
 #include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/type/tz/TimeZoneMap.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 using namespace facebook::velox;
@@ -28,13 +28,13 @@ namespace {
 
 class HourFunction : public exec::VectorFunction {
  public:
-  const date::time_zone* FOLLY_NULLABLE
+  const tz::TimeZone* FOLLY_NULLABLE
   getTimeZoneIfNeeded(const core::QueryConfig& config) const {
-    const date::time_zone* timeZone = nullptr;
+    const tz::TimeZone* timeZone = nullptr;
     if (config.adjustTimestampToTimezone()) {
       auto sessionTzName = config.sessionTimezone();
       if (!sessionTzName.empty()) {
-        timeZone = date::locate_zone(sessionTzName);
+        timeZone = tz::locateZone(sessionTzName);
       }
     }
     return timeZone;
@@ -200,7 +200,7 @@ BENCHMARK(second) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/FieldReferenceBenchmark.cpp b/velox/functions/prestosql/benchmarks/FieldReferenceBenchmark.cpp
new file mode 100644
index 0000000000000..0abc546258ea4
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/FieldReferenceBenchmark.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions;
+
+std::vector<std::string> getColumnNames(int children) {
+  std::vector<std::string> result;
+  for (int i = 0; i < children; ++i) {
+    result.push_back(fmt::format("{}{}", 'c', i));
+  }
+  return result;
+}
+
+RowTypePtr getRowColumnType(FuzzerGenerator& rng, int children, int level) {
+  VELOX_CHECK_GE(level, 1);
+  VELOX_CHECK_GE(children, 3);
+  std::vector<TypePtr> result;
+  result.push_back(ARRAY(INTEGER()));
+  result.push_back(INTEGER());
+  if (level > 1) {
+    result.push_back(getRowColumnType(rng, children, level - 1));
+  } else {
+    result.push_back(randType(rng, 2));
+  }
+  for (int i = 0; i < children - 3; ++i) {
+    result.push_back(randType(rng, 2));
+  }
+  return ROW(getColumnNames(children), std::move(result));
+}
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  FuzzerGenerator rng;
+
+  auto createSet = [&](bool withNulls, RowTypePtr& inputType) {
+    benchmarkBuilder
+        .addBenchmarkSet(
+            fmt::format("dereference_{}", withNulls ? "nulls" : "nullfree"),
+            inputType)
+        .withFuzzerOptions(
+            {.vectorSize = 1000, .nullRatio = withNulls ? 0.2 : 0})
+        .addExpression("1LevelThenFlat", "(c0).c1")
+        .addExpression("1LevelThenComplex", "(c0).c0")
+        .addExpression("2LevelThenFlat", "(c0).c2.c1")
+        .addExpression("2LevelThenComplex", "(c0).c2.c0")
+        .addExpression("3LevelThenFlat", "(c0).c2.c2.c1")
+        .addExpression("3LevelThenComplex", "(c0).c2.c2.c0")
+        .addExpression("4LevelThenFlat", "(c0).c2.c2.c2.c1")
+        .addExpression("4LevelThenComplex", "(c0).c2.c2.c2.c0");
+  };
+
+  // Create a nested row column of depth 4. Each level has 50 columns. Each ROW
+  // at depth n will have the first three columns as ARRAY(INTEGER()), INTEGER()
+  // and ROW {of depth 4-n} respectively. The third column for the deepest ROW
+  // however can be anything.
+  auto inputType = ROW({"c0"}, {getRowColumnType(rng, 50, 4)});
+
+  createSet(true, inputType);
+  createSet(false, inputType);
+
+  benchmarkBuilder.registerBenchmarks();
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/GenericBenchmark.cpp b/velox/functions/prestosql/benchmarks/GenericBenchmark.cpp
new file mode 100644
index 0000000000000..176c7d04f467c
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/GenericBenchmark.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/common/base/VeloxException.h"
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/Udf.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+
+using namespace facebook::velox;
+
+namespace {
+// The following two functions is used to measure the cost of the cast of
+// generic view.
+
+// A function that takes array<X> and returns the summation as int64_t. For
+// simplicity is here handling double and int64_t.
+template <typename T>
+struct GenericInputArraySum {
+  template <typename TInput>
+  void call(int64_t& out, const TInput& arrayOfGeneric) {
+    out = 0;
+    if (arrayOfGeneric.elementKind() == TypeKind::DOUBLE) {
+      for (auto e : arrayOfGeneric) {
+        if (e.has_value()) {
+          out += e.value().template castTo<double>();
+        }
+      }
+    } else if (arrayOfGeneric.elementKind() == TypeKind::BIGINT) {
+      for (auto e : arrayOfGeneric) {
+        if (e.has_value()) {
+          out += e.value().template castTo<int64_t>();
+        }
+      }
+    } else {
+      out = 0;
+    }
+  }
+};
+
+template <typename T>
+struct TypedArraySum {
+  template <typename TInput>
+  void call(int64_t& out, const TInput& typedArray) {
+    out = 0;
+    for (auto e : typedArray) {
+      if (e.has_value()) {
+        out += e.value();
+      }
+    }
+  }
+};
+
+// The following two functions is used to measure the cost of the cast of
+// generic writer when casted to for primitive type.
+template <typename T>
+struct FullGenericArraySum {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(
+      out_type<Generic<T1>>& outGeneric,
+      const arg_type<Array<Generic<T1>>>& arrayOfGeneric) {
+    if (arrayOfGeneric.elementKind() == TypeKind::DOUBLE) {
+      auto& out = outGeneric.template castTo<double>();
+      out = 0;
+      for (auto e : arrayOfGeneric) {
+        if (e.has_value()) {
+          out += e.value().template castTo<double>();
+        }
+      }
+    } else if (arrayOfGeneric.elementKind() == TypeKind::BIGINT) {
+      auto& out = outGeneric.template castTo<int64_t>();
+      out = 0;
+      for (auto e : arrayOfGeneric) {
+        if (e.has_value()) {
+          out += e.value().template castTo<int64_t>();
+        }
+      }
+    } else {
+      VELOX_UNREACHABLE("not implemented");
+    }
+  }
+};
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+
+  facebook::velox::
+      registerFunction<FullGenericArraySum, Generic<T1>, Array<Generic<T1>>>(
+          {"full_generic_sum"});
+  facebook::velox::registerFunction<GenericInputArraySum, int64_t, Array<Any>>(
+      {"generic_input_sum"});
+  facebook::velox::registerFunction<TypedArraySum, int64_t, Array<double>>(
+      {"typed_sum"});
+  facebook::velox::registerFunction<TypedArraySum, int64_t, Array<int64_t>>(
+      {"typed_sum"});
+
+  auto* pool = benchmarkBuilder.pool();
+  auto& vm = benchmarkBuilder.vectorMaker();
+
+  benchmarkBuilder
+      .addBenchmarkSet(
+          fmt::format("array_sum"),
+          ROW({"c0", "c1"}, {ARRAY(BIGINT()), ARRAY(DOUBLE())}))
+      .addExpression("full_generic_int", "full_generic_sum(c0)")
+      .addExpression("generic_input_int", "generic_input_sum(c0)")
+      .addExpression("typed_int", "typed_sum(c0)")
+      .addExpression("full_generic_double", "full_generic_sum(c1)")
+      .addExpression("generic_input_double", "generic_input_sum(c1)")
+      .addExpression("typed_double", "typed_sum(c1)");
+
+  benchmarkBuilder.registerBenchmarks();
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/InBenchmark.cpp b/velox/functions/prestosql/benchmarks/InBenchmark.cpp
index 7f39553490580..8b07463450e64 100644
--- a/velox/functions/prestosql/benchmarks/InBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/InBenchmark.cpp
@@ -129,7 +129,7 @@ BENCHMARK_RELATIVE(in1K) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/JsonBenchmarkUtil.h b/velox/functions/prestosql/benchmarks/JsonBenchmarkUtil.h
deleted file mode 100644
index 2f58db720d306..0000000000000
--- a/velox/functions/prestosql/benchmarks/JsonBenchmarkUtil.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <folly/Benchmark.h>
-
-namespace facebook::velox::functions::prestosql {
-
-#define ISJSONSCALAR_BENCHMARK_NAMED_PARAM(type, name, iter, jsonSize) \
-  BENCHMARK_RELATIVE_NAMED_PARAM(                                      \
-      name, type##_i_##iter##_jSize_##jsonSize, iter, #jsonSize)
-
-#define ISJSONSCALAR_BENCHMARK_NAMED_PARAM_TWO_FUNCS(             \
-    type, func1, func2, iter, jsonSize)                           \
-  ISJSONSCALAR_BENCHMARK_NAMED_PARAM(type, func1, iter, jsonSize) \
-  ISJSONSCALAR_BENCHMARK_NAMED_PARAM(type, func2, iter, jsonSize)
-
-} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp b/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
index b798c2640f9e4..b0843f2a786cb 100644
--- a/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
@@ -22,43 +22,182 @@
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
 #include "velox/functions/prestosql/JsonFunctions.h"
-#include "velox/functions/prestosql/SIMDJsonFunctions.h"
-#include "velox/functions/prestosql/benchmarks/JsonBenchmarkUtil.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/json/JsonExtractor.h"
+#include "velox/functions/prestosql/types/JsonType.h"
 
 namespace facebook::velox::functions::prestosql {
 namespace {
 
+template <typename T>
+struct FollyIsJsonScalarFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(bool& result, const arg_type<Json>& json) {
+    auto parsedJson = folly::parseJson(json);
+    result = parsedJson.isNumber() || parsedJson.isString() ||
+        parsedJson.isBool() || parsedJson.isNull();
+  }
+};
+
+// jsonExtractScalar(json, json_path) -> varchar
+// Current implementation support UTF-8 in json, but not in json_path.
+// Like jsonExtract(), but returns the result value as a string (as opposed
+// to being encoded as JSON). The value referenced by json_path must be a scalar
+// (boolean, number or string)
+template <typename T>
+struct FollyJsonExtractScalarFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Json>& json,
+      const arg_type<Varchar>& jsonPath) {
+    const folly::StringPiece& jsonStringPiece = json;
+    const folly::StringPiece& jsonPathStringPiece = jsonPath;
+    auto extractResult =
+        jsonExtractScalar(jsonStringPiece, jsonPathStringPiece);
+    if (extractResult.hasValue()) {
+      UDFOutputString::assign(result, *extractResult);
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+
+template <typename T>
+struct FollyJsonExtractFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Json>& result,
+      const arg_type<Json>& json,
+      const arg_type<Varchar>& jsonPath) {
+    auto extractResult =
+        jsonExtract(folly::StringPiece(json), folly::StringPiece(jsonPath));
+    if (!extractResult.hasValue() || extractResult.value().isNull()) {
+      return false;
+    }
+
+    folly::json::serialization_opts opts;
+    opts.sort_keys = true;
+    folly::json::serialize(*extractResult, opts);
+
+    UDFOutputString::assign(
+        result, folly::json::serialize(*extractResult, opts));
+    return true;
+  }
+};
+
+template <typename T>
+struct FollyJsonArrayLengthFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(int64_t& result, const arg_type<Json>& json) {
+    auto parsedJson = folly::parseJson(json);
+    if (!parsedJson.isArray()) {
+      return false;
+    }
+
+    result = parsedJson.size();
+    return true;
+  }
+};
+
+template <typename T>
+struct FollyJsonArrayContainsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE bool
+  call(bool& result, const arg_type<Json>& json, const TInput& value) {
+    auto parsedJson = folly::parseJson(json);
+    if (!parsedJson.isArray()) {
+      return false;
+    }
+
+    result = false;
+    for (const auto& v : parsedJson) {
+      if constexpr (std::is_same_v<TInput, bool>) {
+        if (v.isBool() && v == value) {
+          result = true;
+          break;
+        }
+      } else if constexpr (std::is_same_v<TInput, int64_t>) {
+        if (v.isInt() && v == value) {
+          result = true;
+          break;
+        }
+      } else if constexpr (std::is_same_v<TInput, double>) {
+        if (v.isDouble() && v == value) {
+          result = true;
+          break;
+        }
+      } else {
+        if (v.isString() && v == value) {
+          result = true;
+          break;
+        }
+      }
+    }
+    return true;
+  }
+};
+
+template <typename T>
+struct FollyJsonSizeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      int64_t& result,
+      const arg_type<Json>& json,
+      const arg_type<Varchar>& jsonPath) {
+    const folly::StringPiece& jsonStringPiece = json;
+    const folly::StringPiece& jsonPathStringPiece = jsonPath;
+    auto extractResult = jsonExtract(jsonStringPiece, jsonPathStringPiece);
+    if (!extractResult.has_value()) {
+      return false;
+    }
+    // The size of the object or array is the number of members, otherwise the
+    // size is zero
+    if (extractResult->isArray() || extractResult->isObject()) {
+      result = extractResult->size();
+    } else {
+      result = 0;
+    }
+
+    return true;
+  }
+};
+
 const std::string smallJson = R"({"k1":"v1"})";
 
 class JsonBenchmark : public velox::functions::test::FunctionBenchmarkBase {
  public:
   JsonBenchmark() : FunctionBenchmarkBase() {
-    velox::functions::prestosql::registerJsonFunctions();
-    registerFunction<IsJsonScalarFunction, bool, Json>(
+    registerJsonType();
+    registerFunction<IsJsonScalarFunction, bool, Json>({"is_json_scalar"});
+    registerFunction<FollyIsJsonScalarFunction, bool, Json>(
         {"folly_is_json_scalar"});
-    registerFunction<SIMDIsJsonScalarFunction, bool, Json>(
-        {"simd_is_json_scalar"});
     registerFunction<JsonArrayContainsFunction, bool, Json, bool>(
+        {"json_array_contains"});
+    registerFunction<FollyJsonArrayContainsFunction, bool, Json, bool>(
         {"folly_json_array_contains"});
-    registerFunction<SIMDJsonArrayContainsFunction, bool, Json, bool>(
-        {"simd_json_array_contains"});
     registerFunction<JsonArrayLengthFunction, int64_t, Json>(
+        {"json_array_length"});
+    registerFunction<FollyJsonArrayLengthFunction, int64_t, Json>(
         {"folly_json_array_length"});
-    registerFunction<SIMDJsonArrayLengthFunction, int64_t, Json>(
-        {"simd_json_array_length"});
     registerFunction<JsonExtractScalarFunction, Varchar, Json, Varchar>(
+        {"json_extract_scalar"});
+    registerFunction<FollyJsonExtractScalarFunction, Varchar, Json, Varchar>(
         {"folly_json_extract_scalar"});
-    registerFunction<SIMDJsonExtractScalarFunction, Varchar, Json, Varchar>(
-        {"simd_json_extract_scalar"});
     registerFunction<JsonExtractFunction, Varchar, Json, Varchar>(
+        {"json_extract"});
+    registerFunction<FollyJsonExtractFunction, Varchar, Json, Varchar>(
         {"folly_json_extract"});
-    registerFunction<SIMDJsonExtractFunction, Varchar, Json, Varchar>(
-        {"simd_json_extract"});
-    registerFunction<JsonSizeFunction, int64_t, Json, Varchar>(
+    registerFunction<JsonSizeFunction, int64_t, Json, Varchar>({"json_size"});
+    registerFunction<FollyJsonSizeFunction, int64_t, Json, Varchar>(
         {"folly_json_size"});
-    registerFunction<SIMDJsonSizeFunction, int64_t, Json, Varchar>(
-        {"simd_json_size"});
   }
 
   std::string prepareData(int jsonSize) {
@@ -156,7 +295,7 @@ void SIMDIsJsonScalar(int iter, int vectorSize, int jsonSize) {
   JsonBenchmark benchmark;
   auto json = benchmark.prepareData(jsonSize);
   suspender.dismiss();
-  benchmark.runWithJson(iter, vectorSize, "simd_is_json_scalar", json);
+  benchmark.runWithJson(iter, vectorSize, "is_json_scalar", json);
 }
 
 void FollyJsonArrayContains(int iter, int vectorSize, int jsonSize) {
@@ -173,8 +312,7 @@ void SIMDJsonArrayContains(int iter, int vectorSize, int jsonSize) {
   JsonBenchmark benchmark;
   auto json = benchmark.prepareData(jsonSize);
   suspender.dismiss();
-  benchmark.runWithJsonContains(
-      iter, vectorSize, "simd_json_array_contains", json);
+  benchmark.runWithJsonContains(iter, vectorSize, "json_array_contains", json);
 }
 
 void FollyJsonArrayLength(int iter, int vectorSize, int jsonSize) {
@@ -190,7 +328,7 @@ void SIMDJsonArrayLength(int iter, int vectorSize, int jsonSize) {
   JsonBenchmark benchmark;
   auto json = benchmark.prepareData(jsonSize);
   suspender.dismiss();
-  benchmark.runWithJson(iter, vectorSize, "simd_json_array_length", json);
+  benchmark.runWithJson(iter, vectorSize, "json_array_length", json);
 }
 
 void FollyJsonExtractScalar(int iter, int vectorSize, int jsonSize) {
@@ -208,7 +346,7 @@ void SIMDJsonExtractScalar(int iter, int vectorSize, int jsonSize) {
   auto json = benchmark.prepareData(jsonSize);
   suspender.dismiss();
   benchmark.runWithJsonExtract(
-      iter, vectorSize, "simd_json_extract_scalar", json, "$.key[7].k1");
+      iter, vectorSize, "json_extract_scalar", json, "$.key[7].k1");
 }
 
 void FollyJsonExtract(int iter, int vectorSize, int jsonSize) {
@@ -226,7 +364,7 @@ void SIMDJsonExtract(int iter, int vectorSize, int jsonSize) {
   auto json = benchmark.prepareData(jsonSize);
   suspender.dismiss();
   benchmark.runWithJsonExtract(
-      iter, vectorSize, "simd_json_extract", json, "$.key[*].k1");
+      iter, vectorSize, "json_extract", json, "$.key[*].k1");
 }
 
 void FollyJsonSize(int iter, int vectorSize, int jsonSize) {
@@ -243,8 +381,7 @@ void SIMDJsonSize(int iter, int vectorSize, int jsonSize) {
   JsonBenchmark benchmark;
   auto json = benchmark.prepareData(jsonSize);
   suspender.dismiss();
-  benchmark.runWithJsonExtract(
-      iter, vectorSize, "simd_json_size", json, "$.key");
+  benchmark.runWithJsonExtract(iter, vectorSize, "json_size", json, "$.key");
 }
 
 BENCHMARK_DRAW_LINE();
@@ -474,7 +611,10 @@ BENCHMARK_DRAW_LINE();
 } // namespace facebook::velox::functions::prestosql
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+
+  facebook::velox::memory::MemoryManager::initialize({});
+
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/functions/prestosql/benchmarks/MapBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapBenchmark.cpp
index 01e718f8895ff..f7a1d2ac56a79 100644
--- a/velox/functions/prestosql/benchmarks/MapBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/MapBenchmark.cpp
@@ -83,7 +83,7 @@ BENCHMARK_MULTI(flatKeys, n) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
index c657949681f80..26f2a03136fac 100644
--- a/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
@@ -434,7 +434,7 @@ BENCHMARK_RELATIVE(nestedMapSumVectorFunctionMapView) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   MapInputBenchmark benchmark;
   if (benchmark.testMapSum() && benchmark.testNestedMapSum()) {
diff --git a/velox/functions/prestosql/benchmarks/MapSubscriptCachingBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapSubscriptCachingBenchmark.cpp
new file mode 100644
index 0000000000000..63568002bb60a
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/MapSubscriptCachingBenchmark.cpp
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions;
+
+namespace facebook::velox::functions {
+extern void registerSubscriptFunction(
+    const std::string& name,
+    bool enableCaching);
+}
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::testingSetInstance({});
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  facebook::velox::functions::registerSubscriptFunction(
+      "subscriptNocaching", false);
+
+  auto* pool = benchmarkBuilder.pool();
+  auto& vm = benchmarkBuilder.vectorMaker();
+
+  auto createSet = [&](const TypePtr& mapType,
+                       size_t mapLength,
+                       size_t baseVectorSize,
+                       size_t numberOfBatches = 1000) {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1000;
+    options.containerLength = mapLength;
+    // Make sure it's big enough for nested complex types.
+    options.complexElementsMaxSize = baseVectorSize * mapLength * mapLength;
+    options.containerVariableLength = false;
+
+    VectorFuzzer fuzzer(options, pool);
+    std::vector<VectorPtr> columns;
+
+    // Fuzz input map vector.
+    auto flatBase = fuzzer.fuzzFlat(mapType, baseVectorSize);
+    auto dictionary = fuzzer.fuzzDictionary(flatBase, options.vectorSize);
+
+    columns.push_back(dictionary);
+
+    // Fuzz indices vector.
+    DecodedVector decoded(*dictionary);
+    auto* map = flatBase->as<MapVector>();
+    auto indices = allocateIndices(options.vectorSize, pool);
+    auto* mutableIndices = indices->asMutable<vector_size_t>();
+
+    for (int i = 0; i < options.vectorSize; i++) {
+      auto mapIndex = decoded.index(i);
+      // Select a random exisiting key except when map is empty.
+      if (map->sizeAt(mapIndex) == 0) {
+        mutableIndices[i] = 0;
+      }
+      mutableIndices[i] = folly::Random::rand32() % map->sizeAt(mapIndex) +
+          map->offsetAt(mapIndex);
+    }
+
+    auto indicesVector = BaseVector::wrapInDictionary(
+        nullptr, indices, options.vectorSize, map->mapKeys());
+
+    columns.push_back(indicesVector);
+
+    auto name = fmt::format(
+        "{}_{}_{}", mapType->childAt(0)->toString(), mapLength, baseVectorSize);
+
+    benchmarkBuilder.addBenchmarkSet(name, vm.rowVector(columns))
+        .addExpression("subscript", "element_at(c0, c1)")
+        .addExpression("subscriptNocaching", "subscriptNocaching(c0, c1)")
+        .withIterations(numberOfBatches);
+  };
+
+  auto createSetsForType = [&](const auto& keyType) {
+    createSet(MAP(keyType, INTEGER()), 10, 1);
+    createSet(MAP(keyType, INTEGER()), 10, 1000);
+
+    createSet(MAP(keyType, INTEGER()), 100, 1);
+    createSet(MAP(keyType, INTEGER()), 100, 1000);
+
+    createSet(MAP(keyType, INTEGER()), 1000, 1);
+    createSet(MAP(keyType, INTEGER()), 1000, 1000);
+
+    createSet(MAP(keyType, INTEGER()), 10000, 1);
+    createSet(MAP(keyType, INTEGER()), 10000, 1000);
+  };
+
+  createSetsForType(INTEGER());
+  createSetsForType(VARCHAR());
+
+  // For complex types, caching only applies if the Vector has a single constant
+  // value, so we only run with a baseVectorSize of 1.  Also, due to the
+  // cost of the cardinality explosion from having nested complex types, we
+  // limit the number of iterations to 100.
+  auto createSetsForComplexType = [&](const auto& keyType) {
+    createSet(MAP(keyType, INTEGER()), 10, 1, 100);
+
+    createSet(MAP(keyType, INTEGER()), 100, 1, 100);
+
+    createSet(MAP(keyType, INTEGER()), 1000, 1, 100);
+
+    createSet(MAP(keyType, INTEGER()), 10000, 1, 100);
+  };
+
+  createSetsForComplexType(ARRAY(BIGINT()));
+  createSetsForComplexType(MAP(INTEGER(), VARCHAR()));
+
+  benchmarkBuilder.registerBenchmarks();
+  benchmarkBuilder.testBenchmarks();
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp b/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
index 5660439b9cbd0..aa705b198a2f4 100644
--- a/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
+++ b/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
@@ -255,7 +255,7 @@ BENCHMARK(simple_general, n) {
 } // namespace facebook::velox::exec
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   facebook::velox::exec::MapWriterBenchmark benchmark;
   benchmark.test();
diff --git a/velox/functions/prestosql/benchmarks/MapZipWithBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapZipWithBenchmark.cpp
index c4ec34fc83658..3ec68b047cf63 100644
--- a/velox/functions/prestosql/benchmarks/MapZipWithBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/MapZipWithBenchmark.cpp
@@ -123,7 +123,7 @@ BENCHMARK_MULTI(dictionaryKeys, n) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   LOG(ERROR) << "Seed: " << seed;
   {
diff --git a/velox/functions/prestosql/benchmarks/MultimapFromEntriesBenchmark.cpp b/velox/functions/prestosql/benchmarks/MultimapFromEntriesBenchmark.cpp
new file mode 100644
index 0000000000000..0474ffd01954f
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/MultimapFromEntriesBenchmark.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+
+  functions::prestosql::registerMapFunctions();
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+
+  auto makeInputType = [](const TypePtr& keyType, const TypePtr& valueType) {
+    return ROW({"c0"}, {ARRAY(ROW({keyType, valueType}))});
+  };
+
+  benchmarkBuilder
+      .addBenchmarkSet("integer_bigint", makeInputType(INTEGER(), BIGINT()))
+      .addExpression("", "multimap_from_entries(c0)");
+
+  benchmarkBuilder
+      .addBenchmarkSet("integer_varchar", makeInputType(INTEGER(), VARCHAR()))
+      .addExpression("", "multimap_from_entries(c0)");
+
+  benchmarkBuilder.registerBenchmarks();
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
index 798990bbef7ca..e2f4584a96e5d 100644
--- a/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
@@ -194,7 +194,7 @@ BENCHMARK_MULTI(simple) {
 } // namespace facebook::velox::exec
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   facebook::velox::exec::NestedArrayWriterBenchmark benchmark;
   benchmark.test();
diff --git a/velox/functions/prestosql/benchmarks/NotBenchmark.cpp b/velox/functions/prestosql/benchmarks/NotBenchmark.cpp
index 236b5cd34bebe..c4f097c1f009f 100644
--- a/velox/functions/prestosql/benchmarks/NotBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/NotBenchmark.cpp
@@ -79,7 +79,7 @@ BENCHMARK_RELATIVE(vectorizedNot) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/RegexpReplaceBenchmark.cpp b/velox/functions/prestosql/benchmarks/RegexpReplaceBenchmark.cpp
new file mode 100644
index 0000000000000..447db31ea1e86
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/RegexpReplaceBenchmark.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+  facebook::velox::functions::prestosql::registerAllScalarFunctions();
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+
+  VectorFuzzer::Options options;
+  options.vectorSize = 1'000;
+  options.nullRatio = 0.01;
+
+  auto* pool = benchmarkBuilder.pool();
+  auto& vm = benchmarkBuilder.vectorMaker();
+
+  // Compare regexp_replace with fixed and lambda replacement.
+  benchmarkBuilder.addBenchmarkSet("lambda_one_group", ROW({"c0"}, {VARCHAR()}))
+      .withFuzzerOptions(options)
+      .addExpression("fixed", "regexp_replace(c0, '(\\w)', '$1')")
+      .addExpression("lambda", "regexp_replace(c0, '(\\w)', x -> x[1])");
+  benchmarkBuilder
+      .addBenchmarkSet("lambda_two_groups", ROW({"c0"}, {VARCHAR()}))
+      .withFuzzerOptions(options)
+      .addExpression("fixed", "regexp_replace(c0, '(\\w)(\\w*)', '$1$2')")
+      .addExpression(
+          "lambda",
+          "regexp_replace(c0, '(\\w)(\\w*)', x -> concat(x[1], x[2]))");
+
+  // Compare regexp_replace with fixed-string pattern and replace.
+  benchmarkBuilder
+      .addBenchmarkSet("fixed_replacement", ROW({"c0"}, {VARCHAR()}))
+      .withFuzzerOptions(options)
+      .addExpression("replace", "replace(c0, 'a', '_')")
+      .addExpression("regexp_replace", "regexp_replace(c0, 'a','_')");
+
+  benchmarkBuilder.registerBenchmarks();
+  benchmarkBuilder.testBenchmarks();
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/Row.cpp b/velox/functions/prestosql/benchmarks/Row.cpp
index 5118c6eb821d0..f1cf3b278dfae 100644
--- a/velox/functions/prestosql/benchmarks/Row.cpp
+++ b/velox/functions/prestosql/benchmarks/Row.cpp
@@ -73,7 +73,7 @@ BENCHMARK(copyMostlyConst) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/RowWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/RowWriterBenchmark.cpp
index 67b897b272a9a..0d42eb1353c84 100644
--- a/velox/functions/prestosql/benchmarks/RowWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/RowWriterBenchmark.cpp
@@ -220,7 +220,7 @@ BENCHMARK_MULTI(complex_row) {
 } // namespace facebook::velox::exec
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   facebook::velox::exec::RowWriterBenchmark benchmark;
   benchmark.test();
diff --git a/velox/functions/prestosql/benchmarks/SimpleSubscriptBenchmark.cpp b/velox/functions/prestosql/benchmarks/SimpleSubscriptBenchmark.cpp
index 12b526fef848f..395dcd6ae184e 100644
--- a/velox/functions/prestosql/benchmarks/SimpleSubscriptBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/SimpleSubscriptBenchmark.cpp
@@ -352,7 +352,7 @@ BENCHMARK(ArraySubscript_ArrayRowIntInt) {
 }
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   benchmark = std::make_unique<SimpleSubscriptBenchmark>();
   benchmark->test();
   folly::runBenchmarks();
diff --git a/velox/functions/prestosql/benchmarks/StringAsciiUTFFunctionBenchmarks.cpp b/velox/functions/prestosql/benchmarks/StringAsciiUTFFunctionBenchmarks.cpp
index e23b4c46b5a07..b3dd2e41f9261 100644
--- a/velox/functions/prestosql/benchmarks/StringAsciiUTFFunctionBenchmarks.cpp
+++ b/velox/functions/prestosql/benchmarks/StringAsciiUTFFunctionBenchmarks.cpp
@@ -185,7 +185,7 @@ BENCHMARK_RELATIVE(aciiRPad) {
 // asciiUpper                                        98.22%    68.98ms    14.50
 //============================================================================
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/StringWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/StringWriterBenchmark.cpp
index 41ff095d2c875..0fc94466fc349 100644
--- a/velox/functions/prestosql/benchmarks/StringWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/StringWriterBenchmark.cpp
@@ -178,7 +178,7 @@ BENCHMARK_MULTI(array_of_string) {
 } // namespace facebook::velox::exec
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   facebook::velox::exec::StringWriterBenchmark benchmark;
   benchmark.test();
diff --git a/velox/functions/prestosql/benchmarks/URLBenchmark.cpp b/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
index 94cfe57641360..0cd63aedf0609 100644
--- a/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
@@ -127,7 +127,7 @@ struct FollyUrlExtractPortFunction {
       result = parsedUrl.port();
     } catch (const folly::ConversionError&) {
       return false;
-    } catch (const std::invalid_argument& e) {
+    } catch (const std::invalid_argument&) {
       return false;
     }
     return true;
@@ -154,7 +154,7 @@ struct FollyUrlExtractParameterFunction {
           strncpy(result.data(), pair.second.c_str(), pair.second.length());
         }
       }
-    } catch (const std::invalid_argument& e) {
+    } catch (const std::invalid_argument&) {
       return false;
     }
     return false;
@@ -300,7 +300,7 @@ BENCHMARK_RELATIVE(velox_param) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/UuidCastBenchmark.cpp b/velox/functions/prestosql/benchmarks/UuidCastBenchmark.cpp
new file mode 100644
index 0000000000000..e8256b045b406
--- /dev/null
+++ b/velox/functions/prestosql/benchmarks/UuidCastBenchmark.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+using namespace facebook;
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+
+  functions::prestosql::registerAllScalarFunctions();
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+
+  benchmarkBuilder.addBenchmarkSet("cast", ROW({}))
+      .addExpression("no_cast", "uuid()")
+      .addExpression("as_varchar", "cast(uuid() as varchar)");
+
+  benchmarkBuilder.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/prestosql/benchmarks/WidthBucketBenchmark.cpp b/velox/functions/prestosql/benchmarks/WidthBucketBenchmark.cpp
index c7be659c4b20a..8a9bbcaad40e8 100644
--- a/velox/functions/prestosql/benchmarks/WidthBucketBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/WidthBucketBenchmark.cpp
@@ -44,7 +44,8 @@ struct WidthBucketFunction {
       result = bucketCount + 1;
     } else {
       result =
-          (int64_t)((double)bucketCount * (operand - lower) / (upper - lower) + 1);
+          (int64_t)((double)bucketCount * (operand - lower) / (upper - lower) +
+                    1);
     }
 
     if (bound1 > bound2) {
@@ -111,7 +112,7 @@ BENCHMARK_RELATIVE(widthBucket) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/ZipBenchmark.cpp b/velox/functions/prestosql/benchmarks/ZipBenchmark.cpp
index 33fb428db37f0..d9a3f08d4a95f 100644
--- a/velox/functions/prestosql/benchmarks/ZipBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ZipBenchmark.cpp
@@ -111,7 +111,7 @@ BENCHMARK_MULTI(NeqSizeFlatFlat) {
 } // namespace facebook::velox::functions::test
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   folly::runBenchmarks();
   return 0;
diff --git a/velox/functions/prestosql/benchmarks/ZipWithBenchmark.cpp b/velox/functions/prestosql/benchmarks/ZipWithBenchmark.cpp
index fe54035de2de3..36cc4c72d16f5 100644
--- a/velox/functions/prestosql/benchmarks/ZipWithBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ZipWithBenchmark.cpp
@@ -136,7 +136,7 @@ BENCHMARK_MULTI(fast, n) {
 } // namespace
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   LOG(ERROR) << "Seed: " << seed;
   {
diff --git a/velox/functions/prestosql/coverage/CMakeLists.txt b/velox/functions/prestosql/coverage/CMakeLists.txt
index fe02524ccdeb3..bccae29eb7f87 100644
--- a/velox/functions/prestosql/coverage/CMakeLists.txt
+++ b/velox/functions/prestosql/coverage/CMakeLists.txt
@@ -14,5 +14,9 @@
 add_executable(velox_prestosql_coverage Coverage.cpp)
 
 target_link_libraries(
-  velox_prestosql_coverage velox_functions_prestosql velox_function_registry
-  velox_aggregates velox_window velox_coverage_util)
+  velox_prestosql_coverage
+  velox_functions_prestosql
+  velox_function_registry
+  velox_aggregates
+  velox_window
+  velox_coverage_util)
diff --git a/velox/functions/prestosql/coverage/README.md b/velox/functions/prestosql/coverage/README.md
index 0c7939035fb26..769af4e805d00 100644
--- a/velox/functions/prestosql/coverage/README.md
+++ b/velox/functions/prestosql/coverage/README.md
@@ -14,7 +14,7 @@ to be copy-pasted into velox/docs/functions.rst file.
 > velox_prestosql_coverage --all
 
 Generates coverage map using all Presto functions. The output to be copy-pasted
-into velox/docs/functions/coverage.rst file. The functions appear in alphabetical order.
+into velox/docs/functions/presto/coverage.rst file. The functions appear in alphabetical order.
 Before generating the coverage map for all Presto functions, please ensure that the data 
 files at velox/functions/prestosql/coverage/data/ contain all the Presto functions. To
 generate a list of all Presto functions, please run ```SHOW FUNCTIONS``` in Presto.
@@ -30,7 +30,7 @@ These files were created using output of SHOW FUNCTIONS Presto command.
 > velox_prestosql_coverage --most_used
 
 Generates coverage map using a subset of most used Presto functions. The output
-to be copy-pasted into velox/docs/functions/most_used_coverage.rst file. The functions
+to be copy-pasted into velox/docs/functions/presto/most_used_coverage.rst file. The functions
 appear in order from most used to least used.
 
 The list of most used Presto functions comes from data/most_used_functions.txt file.
diff --git a/velox/functions/prestosql/coverage/data/all_aggregate_functions.txt b/velox/functions/prestosql/coverage/data/all_aggregate_functions.txt
index 76a993bad024b..267a4a906a732 100644
--- a/velox/functions/prestosql/coverage/data/all_aggregate_functions.txt
+++ b/velox/functions/prestosql/coverage/data/all_aggregate_functions.txt
@@ -45,11 +45,22 @@ merge_set_digest
 min
 min_by
 multimap_agg
+noisy_avg_gaussian
+noisy_count_gaussian
+noisy_count_if_gaussian
+noisy_sum_gaussian
 numeric_histogram
 qdigest_agg
 reduce_agg
+regr_avgx
+regr_avgy
+regr_count
 regr_intercept
+regr_r2
 regr_slope
+regr_sxx
+regr_sxy
+regr_syy
 set_agg
 set_union
 skewness
diff --git a/velox/functions/prestosql/coverage/data/all_scalar_functions.txt b/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
index c2dd1ad4e2e88..69224cc3fda31 100644
--- a/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
+++ b/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
@@ -13,6 +13,7 @@ array_frequency
 array_has_duplicates
 array_intersect
 array_join
+array_least_frequent
 array_max
 array_max_by
 array_min
@@ -23,6 +24,7 @@ array_remove
 array_sort
 array_sort_desc
 array_sum
+array_top_n
 array_union
 arrays_overlap
 asin
@@ -188,6 +190,7 @@ map_entries
 map_filter
 map_from_entries
 map_keys
+map_keys_by_top_n_values
 map_normalize
 map_remove_null_values
 map_subset
@@ -240,6 +243,7 @@ remove_nulls
 render
 repeat
 replace
+replace_first
 reverse
 rgb
 round
@@ -247,6 +251,7 @@ rpad
 rtrim
 scale_qdigest
 second
+secure_rand
 secure_random
 sequence
 sha1
@@ -332,6 +337,7 @@ tdigest_agg
 timezone_hour
 timezone_minute
 to_base
+to_base32
 to_base64
 to_base64url
 to_big_endian_32
@@ -345,6 +351,7 @@ to_milliseconds
 to_spherical_geography
 to_unixtime
 to_utf8
+trail
 transform
 transform_keys
 transform_values
diff --git a/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
new file mode 100644
index 0000000000000..0c90c983afda6
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <unordered_set>
+
+#include "velox/exec/fuzzer/AggregationFuzzerOptions.h"
+#include "velox/exec/fuzzer/AggregationFuzzerRunner.h"
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/fuzzer/TransformResultVerifier.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/fuzzer/ApproxDistinctInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/MapUnionSumInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/MinMaxInputGenerator.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+DEFINE_string(
+    only,
+    "",
+    "If specified, Fuzzer will only choose functions from "
+    "this comma separated list of function names "
+    "(e.g: --only \"min\" or --only \"sum,avg\").");
+
+DEFINE_string(
+    presto_url,
+    "",
+    "Presto coordinator URI along with port. If set, we use Presto "
+    "source of truth. Otherwise, use DuckDB. Example: "
+    "--presto_url=http://127.0.0.1:8080");
+
+DEFINE_uint32(
+    req_timeout_ms,
+    1000,
+    "Timeout in milliseconds for HTTP requests made to reference DB, "
+    "such as Presto. Example: --req_timeout_ms=2000");
+
+namespace facebook::velox::exec::test {
+namespace {
+
+std::unordered_map<std::string, std::shared_ptr<InputGenerator>>
+getCustomInputGenerators() {
+  return {
+      {"min", std::make_shared<MinMaxInputGenerator>("min")},
+      {"min_by", std::make_shared<MinMaxInputGenerator>("min_by")},
+      {"max", std::make_shared<MinMaxInputGenerator>("max")},
+      {"max_by", std::make_shared<MinMaxInputGenerator>("max_by")},
+      {"approx_distinct", std::make_shared<ApproxDistinctInputGenerator>()},
+      {"approx_set", std::make_shared<ApproxDistinctInputGenerator>()},
+      {"approx_percentile", std::make_shared<ApproxPercentileInputGenerator>()},
+      {"map_union_sum", std::make_shared<MapUnionSumInputGenerator>()},
+  };
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+
+  // Register only presto supported signatures if we are verifying against
+  // Presto.
+  if (FLAGS_presto_url.empty()) {
+    facebook::velox::aggregate::prestosql::registerAllAggregateFunctions(
+        "", false);
+  } else {
+    facebook::velox::aggregate::prestosql::registerAllAggregateFunctions(
+        "", false, true);
+  }
+
+  facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  facebook::velox::window::prestosql::registerAllWindowFunctions();
+  facebook::velox::functions::prestosql::registerInternalFunctions();
+  facebook::velox::aggregate::prestosql::registerInternalAggregateFunctions();
+  facebook::velox::memory::MemoryManager::initialize({});
+
+  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+
+  // List of functions that have known bugs that cause crashes or failures.
+  static const std::unordered_set<std::string> skipFunctions = {
+      // Skip internal functions used only for result verifications.
+      "$internal$count_distinct",
+      "$internal$array_agg",
+      // https://github.com/facebookincubator/velox/issues/3493
+      "stddev_pop",
+      // Lambda functions are not supported yet.
+      "reduce_agg",
+      "max_data_size_for_stats",
+      "map_union_sum",
+      "approx_set",
+      "any_value",
+      // Presto 0.288 makes set_agg and set_union not respect order-by on
+      // inputs. Presto 0.289
+      // re-enables the order-by for them. So skip these two functions until we
+      // compare
+      // Velox result against Presto 0.289 or later versions.
+      "set_agg",
+      "set_union",
+  };
+
+  using facebook::velox::exec::test::ApproxDistinctResultVerifier;
+  using facebook::velox::exec::test::ApproxPercentileResultVerifier;
+  using facebook::velox::exec::test::ArbitraryResultVerifier;
+  using facebook::velox::exec::test::MinMaxByResultVerifier;
+  using facebook::velox::exec::test::setupReferenceQueryRunner;
+  using facebook::velox::exec::test::TransformResultVerifier;
+
+  auto makeArrayVerifier = []() {
+    return TransformResultVerifier::create("\"$internal$canonicalize\"({})");
+  };
+
+  auto makeMapVerifier = []() {
+    return TransformResultVerifier::create(
+        "\"$internal$canonicalize\"(map_keys({}))");
+  };
+
+  // Functions whose results verification should be skipped. These can be
+  // order-dependent functions whose results depend on the order of input rows,
+  // or functions that return complex-typed results containing floating-point
+  // fields. For some functions, the result can be transformed to a value that
+  // can be verified. If such transformation exists, it can be specified to be
+  // used for results verification. If no transformation is specified, results
+  // are not verified.
+  static const std::unordered_map<
+      std::string,
+      std::shared_ptr<facebook::velox::exec::test::ResultVerifier>>
+      customVerificationFunctions = {
+          // Order-dependent functions.
+          {"approx_distinct", std::make_shared<ApproxDistinctResultVerifier>()},
+          {"approx_set", nullptr},
+          {"approx_percentile",
+           std::make_shared<ApproxPercentileResultVerifier>()},
+          {"arbitrary", std::make_shared<ArbitraryResultVerifier>()},
+          {"any_value", nullptr},
+          {"array_agg", makeArrayVerifier()},
+          {"set_agg", makeArrayVerifier()},
+          {"set_union", makeArrayVerifier()},
+          {"map_agg", makeMapVerifier()},
+          {"map_union", makeMapVerifier()},
+          {"map_union_sum", makeMapVerifier()},
+          {"max_by", std::make_shared<MinMaxByResultVerifier>(false)},
+          {"min_by", std::make_shared<MinMaxByResultVerifier>(true)},
+          {"multimap_agg",
+           TransformResultVerifier::create(
+               "transform_values({}, (k, v) -> \"$internal$canonicalize\"(v))")},
+          // Semantically inconsistent functions
+          {"skewness", nullptr},
+          {"kurtosis", nullptr},
+          {"entropy", nullptr},
+          // https://github.com/facebookincubator/velox/issues/6330
+          {"max_data_size_for_stats", nullptr},
+          {"sum_data_size_for_stats", nullptr},
+      };
+
+  using Runner = facebook::velox::exec::test::AggregationFuzzerRunner;
+  using Options = facebook::velox::exec::test::AggregationFuzzerOptions;
+
+  Options options;
+  options.onlyFunctions = FLAGS_only;
+  options.skipFunctions = skipFunctions;
+  options.customVerificationFunctions = customVerificationFunctions;
+  options.customInputGenerators =
+      facebook::velox::exec::test::getCustomInputGenerators();
+  options.timestampPrecision =
+      facebook::velox::VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
+      facebook::velox::memory::memoryManager()->addRootPool()};
+  return Runner::run(
+      initialSeed,
+      setupReferenceQueryRunner(
+          rootPool.get(),
+          FLAGS_presto_url,
+          "aggregation_fuzzer",
+          FLAGS_req_timeout_ms),
+      options);
+}
diff --git a/velox/functions/prestosql/fuzzer/ApproxDistinctInputGenerator.h b/velox/functions/prestosql/fuzzer/ApproxDistinctInputGenerator.h
new file mode 100644
index 0000000000000..977321d21d4dd
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/ApproxDistinctInputGenerator.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include <string>
+
+#include "velox/exec/fuzzer/InputGenerator.h"
+
+namespace facebook::velox::exec::test {
+
+class ApproxDistinctInputGenerator : public InputGenerator {
+ public:
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    if (types.size() != 2) {
+      return {};
+    }
+
+    // Make sure to use the same value of 'e' for all batches in a given Fuzzer
+    // iteration.
+    if (!e_.has_value()) {
+      // Generate value in [0.0040625, 0.26] range.
+      static constexpr double kMin = 0.0040625;
+      static constexpr double kMax = 0.26;
+      e_ = kMin + (kMax - kMin) * boost::random::uniform_01<double>()(rng);
+    }
+
+    const auto size = fuzzer.getOptions().vectorSize;
+
+    VELOX_CHECK(
+        types.back()->isDouble(),
+        "Unexpected type: {}",
+        types.back()->toString());
+    return {
+        fuzzer.fuzz(types[0]),
+        BaseVector::createConstant(DOUBLE(), e_.value(), size, pool)};
+  }
+
+  void reset() override {
+    e_.reset();
+  }
+
+ private:
+  std::optional<double> e_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h b/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h
new file mode 100644
index 0000000000000..9704995521e7b
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+#include "velox/common/hyperloglog/HllUtils.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+// Compares results of approx_distinct(x[, e]) with count(distinct x).
+// For each group calculates the difference between 2 values and counts number
+// of groups where difference is > 2e. If total number of groups is >= 50,
+// allows 2 groups > 2e. If number of groups is small (< 50),
+// expects all groups to be under 2e.
+class ApproxDistinctResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return false;
+  }
+
+  bool supportsVerify() override {
+    return true;
+  }
+
+  // Compute count(distinct x) over 'input'.
+  void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    auto plan =
+        PlanBuilder()
+            .values(input)
+            .singleAggregation(groupingKeys, {makeCountDistinctCall(aggregate)})
+            .planNode();
+
+    expected_ = AssertQueryBuilder(plan).copyResults(input[0]->pool());
+    groupingKeys_ = groupingKeys;
+    name_ = aggregateName;
+    error_ = extractError(aggregate.call, input[0]);
+    verifyWindow_ = false;
+  }
+
+  // Compute count_distinct(x) over 'input' over 'frame'.
+  void initializeWindow(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& partitionByKeys,
+      const std::vector<SortingKeyAndOrder>& /*sortingKeysAndOrders*/,
+      const core::WindowNode::Function& function,
+      const std::string& frame,
+      const std::string& windowName) override {
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .window({makeCountDistinctWindowCall(function, frame)})
+                    .planNode();
+
+    expected_ = AssertQueryBuilder(plan).copyResults(input[0]->pool());
+    groupingKeys_ = partitionByKeys;
+    name_ = windowName;
+    error_ = extractError(function.functionCall, input[0]);
+    verifyWindow_ = true;
+  }
+
+  bool compare(
+      const RowVectorPtr& /*result*/,
+      const RowVectorPtr& /*altResult*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  bool verify(const RowVectorPtr& result) override {
+    // Union 'result' with 'expected_', group by on 'groupingKeys_' and produce
+    // pairs of actual and expected values per group. We cannot use join because
+    // grouping keys may have nulls.
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto expectedSource = PlanBuilder(planNodeIdGenerator)
+                              .values({expected_})
+                              .appendColumns({"'expected' as label"})
+                              .planNode();
+
+    auto actualSource = PlanBuilder(planNodeIdGenerator)
+                            .values({result})
+                            .appendColumns({"'actual' as label"})
+                            .planNode();
+
+    if (verifyWindow_) {
+      return verifyWindow(
+          expectedSource, actualSource, planNodeIdGenerator, result->pool());
+    }
+
+    auto mapAgg = fmt::format("map_agg(label, {}) as m", name_);
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .localPartition({}, {expectedSource, actualSource})
+                    .singleAggregation(groupingKeys_, {mapAgg})
+                    .project({"m['actual'] as a", "m['expected'] as e"})
+                    .planNode();
+    auto combined = AssertQueryBuilder(plan).copyResults(result->pool());
+
+    auto* actual = combined->childAt(0)->as<SimpleVector<int64_t>>();
+    auto* expected = combined->childAt(1)->as<SimpleVector<int64_t>>();
+
+    const auto numGroups = result->size();
+    VELOX_CHECK_EQ(numGroups, combined->size());
+
+    std::vector<double> largeGaps;
+    for (auto i = 0; i < numGroups; ++i) {
+      VELOX_CHECK(!actual->isNullAt(i));
+      VELOX_CHECK(!expected->isNullAt(i));
+
+      const auto actualCnt = actual->valueAt(i);
+      const auto expectedCnt = expected->valueAt(i);
+      if (actualCnt != expectedCnt) {
+        if (expectedCnt > 0) {
+          const auto gap =
+              std::abs(actualCnt - expectedCnt) * 1.0 / expectedCnt;
+          if (gap > 2 * error_) {
+            largeGaps.push_back(gap);
+            LOG(ERROR) << fmt::format(
+                "approx_distinct(x, {}) is more than 2 stddev away from "
+                "count(distinct x). Difference: {}, approx_distinct: {}, "
+                "count(distinct): {}. This is unusual, but doesn't necessarily "
+                "indicate a bug.",
+                error_,
+                gap,
+                actualCnt,
+                expectedCnt);
+          }
+        } else {
+          LOG(ERROR) << fmt::format(
+              "count(distinct x) returned 0, but approx_distinct(x, {}) is {}",
+              error_,
+              actualCnt);
+          return false;
+        }
+      }
+    }
+
+    // We expect large deviations (>2 stddev) in < 5% of values.
+    if (numGroups >= 50) {
+      return largeGaps.size() <= 3;
+    }
+
+    return largeGaps.empty();
+  }
+
+  // For approx_distinct in window operations, input sets for rows in the same
+  // partition are correlated. Since the error bound of approx_distinct only
+  // applies to independent input sets, we only take one max gap in each
+  // partition when checking the error bound.
+  bool verifyWindow(
+      core::PlanNodePtr& expectedSource,
+      core::PlanNodePtr& actualSource,
+      std::shared_ptr<core::PlanNodeIdGenerator>& planNodeIdGenerator,
+      memory::MemoryPool* pool) {
+    auto mapAgg = fmt::format("map_agg(label, {}) as m", name_);
+
+    auto keys = groupingKeys_;
+    keys.push_back("row_number");
+
+    // Calculate the gap between each actual and the corresponding expected
+    // counts.
+    auto projections = keys;
+    projections.push_back(
+        "cast(abs(m['actual'] - m['expected']) as double) / cast(m['expected'] as double) as gap");
+
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .localPartition({}, {expectedSource, actualSource})
+            .singleAggregation(keys, {mapAgg})
+            .project(projections)
+            // groupingKeys_ are the partition-by keys for window operations.
+            // The error bound of approx_distinct is for independent input sets,
+            // while input sets in the same partition are correlated. So we only
+            // take one max gap in each partition.
+            .singleAggregation(groupingKeys_, {"max(gap)"})
+            .planNode();
+    auto combined = AssertQueryBuilder(plan).copyResults(pool);
+    const auto numGroups = combined->size();
+
+    std::vector<double> largeGaps;
+    // Standard error would likely exceed the error bound when the number of
+    // groups is small and the error bound is large. So we only check the
+    // standard error when the numGroups >= 50 and the error bound is smaller
+    // than or equan to the default error bound.
+    bool checkError =
+        (error_ <= common::hll::kDefaultApproxDistinctStandardError ||
+         numGroups >= 50);
+    for (auto i = 0; i < numGroups; ++i) {
+      const auto gap =
+          combined->children().back()->as<SimpleVector<double>>()->valueAt(i);
+      if (gap > 2 * error_) {
+        largeGaps.push_back(gap);
+        LOG(ERROR) << fmt::format(
+            "approx_distinct(x, {}) is more than 2 stddev away from "
+            "count(distinct x) at {}. Difference: {}. This is unusual, but doesn't necessarily "
+            "indicate a bug.",
+            error_,
+            combined->toString(i),
+            gap);
+      }
+    }
+    if (!checkError) {
+      LOG(WARNING) << fmt::format(
+          "{} groups have large errors that exceed the error bound, but we don't fail the verification because current numGroups = {} and error bound is {}.",
+          largeGaps.size(),
+          numGroups,
+          error_);
+      return true;
+    }
+
+    // We expect large deviations (>2 stddev) in < 5% of values.
+    if (numGroups >= 50) {
+      return largeGaps.size() <= 0.05 * numGroups;
+    }
+
+    return largeGaps.empty();
+  }
+
+  void reset() override {
+    expected_.reset();
+  }
+
+ private:
+  static constexpr double kDefaultError = 0.023;
+
+  static double extractError(
+      const core::CallTypedExprPtr& call,
+      const RowVectorPtr& input) {
+    const auto& args = call->inputs();
+
+    if (args.size() == 1) {
+      return kDefaultError;
+    }
+
+    auto field = core::TypedExprs::asFieldAccess(args[1]);
+    VELOX_CHECK_NOT_NULL(field);
+    auto errorVector =
+        input->childAt(field->name())->as<SimpleVector<double>>();
+    return errorVector->valueAt(0);
+  }
+
+  static std::string makeCountDistinctCall(
+      const core::AggregationNode::Aggregate& aggregate) {
+    const auto& args = aggregate.call->inputs();
+    VELOX_CHECK_GE(args.size(), 1);
+
+    auto inputField = core::TypedExprs::asFieldAccess(args[0]);
+    VELOX_CHECK_NOT_NULL(inputField);
+
+    std::string countDistinctCall =
+        fmt::format("count(distinct {})", inputField->name());
+
+    if (aggregate.mask != nullptr) {
+      countDistinctCall +=
+          fmt::format(" filter (where {})", aggregate.mask->name());
+    }
+
+    return countDistinctCall;
+  }
+
+  static std::string makeCountDistinctWindowCall(
+      const core::WindowNode::Function& function,
+      const std::string& frame) {
+    const auto& args = function.functionCall->inputs();
+    VELOX_CHECK_GE(args.size(), 1);
+
+    auto inputField = core::TypedExprs::asFieldAccess(args[0]);
+    VELOX_CHECK_NOT_NULL(inputField);
+
+    std::string countDistinctCall =
+        fmt::format("\"$internal$count_distinct\"({})", inputField->name());
+
+    if (function.ignoreNulls) {
+      countDistinctCall += " ignore nulls";
+    }
+    countDistinctCall += " over(" + frame + ")";
+
+    return countDistinctCall;
+  }
+
+  RowVectorPtr expected_;
+  std::vector<std::string> groupingKeys_;
+  std::string name_;
+  double error_;
+  bool verifyWindow_{false};
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h b/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h
new file mode 100644
index 0000000000000..74fdc9048ac2c
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include <string>
+
+#include "velox/exec/fuzzer/InputGenerator.h"
+
+namespace facebook::velox::exec::test {
+
+class ApproxPercentileInputGenerator : public InputGenerator {
+ public:
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    // The arguments are: x, [w], percentile(s), [accuracy].
+    //
+    // First argument is always 'x'. If second argument's type is BIGINT, then
+    // it is 'w'. Otherwise, it is percentile(x).
+
+    const auto size = fuzzer.getOptions().vectorSize;
+
+    std::vector<VectorPtr> inputs;
+    inputs.reserve(types.size());
+    inputs.push_back(fuzzer.fuzz(types[0]));
+
+    if (types[1]->isBigint()) {
+      velox::test::VectorMaker vectorMaker{pool};
+      auto weight = vectorMaker.flatVector<int64_t>(size, [&](auto /*row*/) {
+        return boost::random::uniform_int_distribution<int64_t>(1, 1'000)(rng);
+      });
+
+      inputs.push_back(weight);
+    }
+
+    const int percentileTypeIndex = types[1]->isBigint() ? 2 : 1;
+    const TypePtr& percentileType = types[percentileTypeIndex];
+    if (percentileType->isDouble()) {
+      if (!percentile_.has_value()) {
+        percentile_ = pickPercentile(fuzzer, rng);
+      }
+
+      inputs.push_back(BaseVector::createConstant(
+          DOUBLE(), percentile_.value(), size, pool));
+    } else {
+      VELOX_CHECK(percentileType->isArray());
+      VELOX_CHECK(percentileType->childAt(0)->isDouble());
+
+      if (percentiles_.empty()) {
+        percentiles_.push_back(pickPercentile(fuzzer, rng));
+        percentiles_.push_back(pickPercentile(fuzzer, rng));
+        percentiles_.push_back(pickPercentile(fuzzer, rng));
+      }
+
+      auto arrayVector =
+          BaseVector::create<ArrayVector>(ARRAY(DOUBLE()), 1, pool);
+      auto elementsVector = arrayVector->elements()->asFlatVector<double>();
+      elementsVector->resize(percentiles_.size());
+      for (auto i = 0; i < percentiles_.size(); ++i) {
+        elementsVector->set(i, percentiles_[i]);
+      }
+      arrayVector->setOffsetAndSize(0, 0, percentiles_.size());
+
+      inputs.push_back(BaseVector::wrapInConstant(size, 0, arrayVector));
+    }
+
+    if (types.size() > percentileTypeIndex + 1) {
+      // Last argument is 'accuracy'.
+      VELOX_CHECK(types.back()->isDouble());
+      if (!accuracy_.has_value()) {
+        accuracy_ = boost::random::uniform_01<double>()(rng);
+      }
+
+      inputs.push_back(
+          BaseVector::createConstant(DOUBLE(), accuracy_.value(), size, pool));
+    }
+
+    return inputs;
+  }
+
+  void reset() override {
+    percentile_.reset();
+    percentiles_.clear();
+    accuracy_.reset();
+  }
+
+ private:
+  double pickPercentile(VectorFuzzer& fuzzer, FuzzerGenerator& rng) {
+    // 10% of the times generate random value in [0, 1] range.
+    // 90% of the times use one of the common values.
+    if (fuzzer.coinToss(0.1)) {
+      return boost::random::uniform_01<double>()(rng);
+    }
+
+    static const std::vector<double> kPercentiles = {
+        0.1, 0.25, 0.5, 0.75, 0.90, 0.95, 0.99, 0.999, 0.9999};
+
+    const auto index =
+        boost::random::uniform_int_distribution<uint32_t>()(rng) %
+        kPercentiles.size();
+
+    return kPercentiles[index];
+  }
+
+  std::optional<double> percentile_;
+  std::vector<double> percentiles_;
+  std::optional<double> accuracy_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h b/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h
new file mode 100644
index 0000000000000..bc6d13e4269ce
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h
@@ -0,0 +1,813 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+// Verifies results of approx_percentile by checking the range of percentiles
+// represented by the result value and asserting that the requested percentile
+// falls into that range within 'accuracy'.
+class ApproxPercentileResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return false;
+  }
+
+  bool supportsVerify() override {
+    return true;
+  }
+
+  // Compute the range of percentiles represented by each of the input values.
+  void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    VELOX_CHECK(!input.empty());
+    verifyWindow_ = false;
+
+    int64_t numInputs = 0;
+    for (const auto& v : input) {
+      numInputs += v->size();
+    }
+
+    groupingKeys_ = groupingKeys;
+    name_ = aggregateName;
+
+    const auto& [valueField, weightField] =
+        extractValueAndWeight(aggregate.call);
+    extractPercentileAndAccuracy(aggregate.call, input);
+
+    // Compute percentiles for all values.
+    allRanges_ =
+        computePercentiles(input, valueField, weightField, aggregate.mask);
+    VELOX_CHECK_LE(allRanges_->size(), numInputs);
+  }
+
+  void initializeWindow(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& partitionByKeys,
+      const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+      const core::WindowNode::Function& function,
+      const std::string& /*frame*/,
+      const std::string& windowName) override {
+    VELOX_CHECK(!input.empty());
+    verifyWindow_ = true;
+
+    groupingKeys_ = partitionByKeys;
+    name_ = windowName;
+
+    const auto& [valueField, weightField] =
+        extractValueAndWeight(function.functionCall);
+    bool isArrayPercentile =
+        extractPercentileAndAccuracy(function.functionCall, input);
+
+    allRanges_ = computePercentilesForWindow(
+        input,
+        valueField,
+        weightField,
+        sortingKeysAndOrders,
+        function.frame,
+        function.functionCall->type(),
+        isArrayPercentile);
+  }
+
+  bool compare(
+      const RowVectorPtr& /*result*/,
+      const RowVectorPtr& /*altResult*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  bool verify(const RowVectorPtr& result) override {
+    // Compute acceptable ranges of percentiles for each value in 'result'.
+    RowVectorPtr ranges;
+    if (verifyWindow_) {
+      ranges = getPercentileRangesForWindow(result);
+    } else {
+      ranges = getPercentileRanges(result);
+    }
+
+    auto& value = ranges->childAt(name_);
+    auto* minPct = ranges->childAt("min_pct")->as<SimpleVector<double>>();
+    auto* maxPct = ranges->childAt("max_pct")->as<SimpleVector<double>>();
+    auto* pctIndex = ranges->childAt("pct_index")->as<SimpleVector<int64_t>>();
+
+    // Number of non-null rows in the actual result.
+    auto numNonNull = 0;
+    for (auto i = 0; i < ranges->size(); ++i) {
+      if (value->isNullAt(i)) {
+        VELOX_CHECK(minPct->isNullAt(i));
+        VELOX_CHECK(maxPct->isNullAt(i));
+        continue;
+      }
+      numNonNull++;
+      VELOX_CHECK(!minPct->isNullAt(i));
+      VELOX_CHECK(!maxPct->isNullAt(i));
+      VELOX_CHECK(!pctIndex->isNullAt(i));
+
+      const auto pct = percentiles_[pctIndex->valueAt(i)];
+
+      std::pair<double, double> range{minPct->valueAt(i), maxPct->valueAt(i)};
+      if (!checkPercentileGap(pct, range, accuracy_)) {
+        return false;
+      }
+    }
+    if (verifyWindow_ && numNonNull != allRanges_->size()) {
+      LOG(ERROR) << fmt::format(
+          "Expected result contains {} non-null rows while the actual result contains {}.",
+          allRanges_->size(),
+          numNonNull);
+      return false;
+    }
+
+    return true;
+  }
+
+  void reset() override {
+    allRanges_.reset();
+  }
+
+ private:
+  static constexpr double kDefaultAccuracy = 0.0133;
+
+  // Extracts a pair of [valueField, weightField] from functionCall. weightField
+  // is an optional.
+  std::pair<std::string, std::optional<std::string>> extractValueAndWeight(
+      const core::CallTypedExprPtr& functionCall) {
+    const auto& args = functionCall->inputs();
+    const auto& valueField = fieldName(args[0]);
+    std::optional<std::string> weightField;
+    if (args.size() >= 3 && args[1]->type()->isBigint()) {
+      weightField = fieldName(args[1]);
+    }
+    return std::make_pair(valueField, weightField);
+  }
+
+  // Extracts the percentile(s) to percentiles_ and the accuracy to accuracy_.
+  // Return a boolean indicating whether the percentile is an array.
+  bool extractPercentileAndAccuracy(
+      const core::CallTypedExprPtr& functionCall,
+      const std::vector<RowVectorPtr>& input) {
+    bool isArrayPercentile;
+    percentiles_ = extractPercentiles(input, functionCall, isArrayPercentile);
+    VELOX_CHECK(!percentiles_.empty());
+
+    accuracy_ = extractAccuracy(functionCall, input[0]);
+    return isArrayPercentile;
+  }
+
+  static double extractAccuracy(
+      const core::CallTypedExprPtr& functionCall,
+      const RowVectorPtr& input) {
+    const auto& args = functionCall->inputs();
+
+    column_index_t accuracyIndex = 2;
+    if (args.size() >= 3 && args[1]->type()->isBigint()) {
+      // We have a 'w' argument.
+      accuracyIndex = 3;
+    }
+
+    if (args.size() <= accuracyIndex) {
+      return kDefaultAccuracy;
+    }
+
+    auto field = core::TypedExprs::asFieldAccess(args[accuracyIndex]);
+    VELOX_CHECK_NOT_NULL(field);
+    auto accuracyVector =
+        input->childAt(field->name())->as<SimpleVector<double>>();
+    return accuracyVector->valueAt(0);
+  }
+
+  static bool checkPercentileGap(
+      double pct,
+      const std::pair<double, double>& range,
+      double accuracy) {
+    double gap = 0.0;
+    if (pct < range.first) {
+      gap = range.first - pct;
+    } else if (pct > range.second) {
+      gap = pct - range.second;
+    }
+
+    if (gap > accuracy) {
+      LOG(ERROR) << "approx_percentile(pct: " << pct
+                 << ", accuracy: " << accuracy << ") is more than " << accuracy
+                 << " away from acceptable range of [" << range.first << ", "
+                 << range.second << "]. Difference: " << gap;
+      return false;
+    }
+
+    return true;
+  }
+
+  static std::vector<std::string> append(
+      const std::vector<std::string>& values,
+      const std::vector<std::string>& newValues) {
+    auto combined = values;
+    combined.insert(combined.end(), newValues.begin(), newValues.end());
+    return combined;
+  }
+
+  // Groups input by 'groupingKeys_'. Within each group, sorts data on
+  // 'valueField', duplicates rows according to optional weight, filters out
+  // NULLs and rows where mask is not true, then computes ranges of row numbers
+  // and turns these into ranges of percentiles.
+  //
+  // @return A vector of grouping keys, followed by value column named 'name_',
+  // followed by min_pct and max_pct columns.
+  RowVectorPtr computePercentiles(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& valueField,
+      const std::optional<std::string>& weightField,
+      const core::FieldAccessTypedExprPtr& mask) {
+    VELOX_CHECK(!input.empty());
+    const auto rowType = asRowType(input[0]->type());
+
+    std::vector<std::string> projections = groupingKeys_;
+    projections.push_back(fmt::format("{} as x", valueField));
+    projections.push_back(fmt::format(
+        "{} as w",
+        weightField.has_value() ? weightField.value() : "1::bigint"));
+
+    PlanBuilder planBuilder;
+    planBuilder.values(input);
+
+    if (mask != nullptr) {
+      planBuilder.filter(mask->name());
+    }
+
+    planBuilder.project(projections).filter("x IS NOT NULL AND w > 0");
+
+    std::string partitionByClause;
+    if (!groupingKeys_.empty()) {
+      partitionByClause =
+          fmt::format("partition by {}", folly::join(", ", groupingKeys_));
+    }
+
+    std::vector<std::string> windowCalls = {
+        // Compute the sum of all the weights.
+        fmt::format(
+            "sum(w) OVER ({} order by x range between unbounded preceding and unbounded following) as total",
+            partitionByClause),
+        // Compute the sum of the weights in the current frame.
+        fmt::format(
+            "sum(w) OVER ({} order by x range between current row and current row) "
+            "as sum",
+            partitionByClause),
+        // Compute the sum of the weights of all frames up to and including the
+        // current frame.
+        fmt::format(
+            "sum(w) OVER ({} order by x range between unbounded preceding and current row) "
+            "as prefix_sum",
+            partitionByClause),
+    };
+
+    planBuilder.window(windowCalls)
+        .appendColumns({
+            // The sum of the weights of all frames before the current frame
+            // over the total sum.
+            "(prefix_sum::double - sum::double) / total::double as lower",
+            // The sum of the weights of all frames up to and including the
+            // current frame over the total sum.
+            "(prefix_sum::double) / total::double as upper",
+        })
+        .singleAggregation(
+            append(groupingKeys_, {"x"}),
+            {"min(lower) as min_pct", "max(upper) as max_pct"})
+        .project(append(
+            groupingKeys_,
+            {fmt::format("x as {}", name_), "min_pct", "max_pct"}));
+
+    auto plan = planBuilder.planNode();
+    return AssertQueryBuilder(plan).copyResults(input[0]->pool());
+  }
+
+  std::string getFrameClause(const core::WindowNode::Frame& frame) {
+    std::stringstream ss;
+    ss << core::WindowNode::windowTypeName(frame.type) << " between ";
+    if (frame.startValue) {
+      ss << frame.startValue->toString() << " ";
+    }
+    ss << core::WindowNode::boundTypeName(frame.startType) << " and ";
+    if (frame.endValue) {
+      ss << frame.endValue->toString() << " ";
+    }
+    ss << core::WindowNode::boundTypeName(frame.endType);
+    return ss.str();
+  }
+
+  std::string getOrderByClause(
+      const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders) {
+    if (sortingKeysAndOrders.empty()) {
+      return "";
+    }
+    std::stringstream ss;
+    ss << "order by ";
+    for (auto i = 0; i < sortingKeysAndOrders.size(); ++i) {
+      if (i > 0) {
+        ss << ", ";
+      }
+      ss << sortingKeysAndOrders[i].key_ << " "
+         << sortingKeysAndOrders[i].sortOrder_.toString();
+    }
+    return ss.str();
+  }
+
+  std::string getPartitionByClause(
+      const std::vector<std::string>& partitionByKeys) {
+    if (partitionByKeys.empty()) {
+      return "";
+    }
+    return "partition by " + folly::join(", ", partitionByKeys);
+  }
+
+  // For each input row, calculates a map of {value : [order_min, order_max]} as
+  // 'expected' for every distinct value in the window frame of the current row,
+  // and the weighted total number of values in the frame as 'cnt'. 'order_min'
+  // is the rank right before the first appearance of 'value' when values in the
+  // current frame are sorted by sortingKeysAndOrders and 'order_max' is the
+  // rank of the last appearance of 'value'. For example, for a table 't(c0, c1,
+  // c2, weight, row_num)' and a window operation 'approx_percentile(c0,
+  // percentile) over (partition by c1 order by c2 desc rows between 1 preceding
+  // and 1 following)', this method essentially returns the result of the
+  // following query:
+  //  SELECT
+  //      c1,
+  //      row_num,
+  //      NULL AS actual,
+  //      MAP_AGG(bucket_element, order_pair) AS expected,
+  //      ARBITRARY(weight_total) AS cnt
+  //  FROM (
+  //      SELECT
+  //          c1,
+  //          row_num,
+  //          bucket_element,
+  //          CAST(
+  //              ROW(COALESCE(order_min, 0), order_max) AS ROW(
+  //                  order_min BIGINT,
+  //                  order_max BIGINT
+  //              )
+  //          ) AS order_pair,
+  //          weight_total
+  //      FROM (
+  //          SELECT
+  //              c1,
+  //              row_num,
+  //              bucket_element,
+  //              weight,
+  //              SUM(weight) OVER (
+  //                  PARTITION BY
+  //                      c1,
+  //                      row_num
+  //                  ORDER BY
+  //                      bucket_element ASC
+  //                  ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
+  //              ) AS weight_total,
+  //              SUM(weight) OVER (
+  //                  PARTITION BY
+  //                      c1,
+  //                      row_num
+  //                  ORDER BY
+  //                      bucket_element ASC
+  //                  ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+  //              ) AS order_min,
+  //              SUM(weight) OVER (
+  //                  PARTITION BY
+  //                      c1,
+  //                      row_num
+  //                  ORDER BY
+  //                      bucket_element ASC
+  //                  ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+  //              ) AS order_max
+  //          FROM (
+  //              SELECT
+  //                  c1,
+  //                  row_num,
+  //                  bucket_element,
+  //                  bucket_weight AS weight
+  //              FROM (
+  //                  SELECT
+  //                      c1,
+  //                      row_num,
+  //                      bucket_element,
+  //                      bucket_weight
+  //                  FROM (
+  //                      SELECT
+  //                          c1,
+  //                          row_num,
+  //                          TRANSFORM_VALUES(bucket, (k, v) -> ARRAY_SUM(v))
+  //                          AS bucket
+  //                      FROM (
+  //                          SELECT
+  //                              c1,
+  //                              row_num,
+  //                              MULTIMAP_AGG(c0, weight) OVER (
+  //                                  PARTITION BY
+  //                                      c1
+  //                                  ORDER BY
+  //                                      c2 DESC
+  //                                  ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING
+  //                              ) AS bucket
+  //                          FROM (
+  //                              VALUES
+  //                                  (1, TRUE, 1, 2, 1),
+  //                                  (2, TRUE, 3, 1, 2),
+  //                                  (1, TRUE, 4, 1, 3),
+  //                                  (4, TRUE, 5, 1, 4),
+  //                                  (1, FALSE, 1, 2, 5),
+  //                                  (2, FALSE, 3, 1, 6),
+  //                                  (3, FALSE, 4, 1, 7),
+  //                                  (4, FALSE, 5, 1, 8)
+  //                          ) t(c0, c1, c2, weight, row_num)
+  //                      )
+  //                  ) bucketed(c1, row_num, bucket)
+  //                  CROSS JOIN UNNEST(bucket) AS tmp(bucket_element,
+  //                  bucket_weight)
+  //              )
+  //          )
+  //      )
+  //  )
+  //  GROUP BY
+  //      c1,
+  //      row_num
+  RowVectorPtr computePercentilesForWindow(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& valueField,
+      const std::optional<std::string>& weightField,
+      const std::vector<SortingKeyAndOrder>& sortingKeysAndOrders,
+      const core::WindowNode::Frame& frame,
+      const TypePtr& resultType,
+      bool isArray) {
+    VELOX_CHECK(!input.empty());
+    const auto rowType = asRowType(input[0]->type());
+    const bool weighted = weightField.has_value();
+
+    std::vector<std::string> projections = groupingKeys_;
+    for (const auto& sortingKey : sortingKeysAndOrders) {
+      if (sortingKey.key_ != "row_number") {
+        projections.push_back(sortingKey.key_);
+      }
+    }
+    projections.push_back("row_number");
+    projections.push_back(fmt::format("{} as x", valueField));
+    projections.push_back(
+        fmt::format("{} as w", weighted ? weightField.value() : "1::bigint"));
+
+    PlanBuilder planBuilder;
+    planBuilder.values(input).project(projections).filter("w > 0");
+
+    auto partitionByKeysWithRowNumber =
+        getPartitionByClause(append(groupingKeys_, {"row_number"}));
+    planBuilder
+        .window({fmt::format(
+            "multimap_agg(x, w) over ({} {} {}) as bucket",
+            getPartitionByClause(groupingKeys_),
+            getOrderByClause(sortingKeysAndOrders),
+            getFrameClause(frame))})
+        .project(append(
+            groupingKeys_,
+            {"row_number",
+             "transform_values(bucket, (k, v) -> array_sum(v)) as bucket"}))
+        .unnest(append(groupingKeys_, {"row_number"}), {"bucket"})
+        .project(append(
+            groupingKeys_, {"row_number", "bucket_k", "bucket_v as weight"}))
+        .window(
+            {fmt::format(
+                 "sum(weight) over ({} order by bucket_k asc rows between unbounded preceding and unbounded following) as cnt",
+                 partitionByKeysWithRowNumber),
+             fmt::format(
+                 "sum(weight) over ({} order by bucket_k asc rows between unbounded preceding and 1 preceding) as order_min",
+                 partitionByKeysWithRowNumber),
+             fmt::format(
+                 "sum(weight) over ({} order by bucket_k asc rows between unbounded preceding and current row) as order_max",
+                 partitionByKeysWithRowNumber)})
+        .project(append(
+            groupingKeys_,
+            {"row_number",
+             "bucket_k as element",
+             "cnt",
+             "row_constructor(coalesce(order_min, 0), order_max) as order_pair"}))
+        .singleAggregation(
+            append(groupingKeys_, {"row_number"}),
+            {"map_agg(element, order_pair) as expected",
+             "arbitrary(cnt) as cnt"});
+
+    if (isArray) {
+      std::stringstream ss;
+      toTypeSql(resultType->asArray().elementType(), ss);
+
+      planBuilder
+          .appendColumns(
+              {fmt::format("sequence(1, {}) as seq", percentiles_.size())})
+          .unnest(
+              append(groupingKeys_, {"row_number", "expected", "cnt"}), {"seq"})
+          .project(append(
+              groupingKeys_,
+              {"row_number",
+               fmt::format("cast(null as {}) as actual_e", ss.str()),
+               "seq_e as pct_index",
+               "expected",
+               "cnt"}));
+    } else {
+      std::stringstream ss;
+      toTypeSql(resultType, ss);
+
+      planBuilder.project(append(
+          groupingKeys_,
+          {"row_number",
+           fmt::format("cast(null as {}) as actual", ss.str()),
+           "expected",
+           "cnt"}));
+    }
+
+    auto plan = planBuilder.planNode();
+    return AssertQueryBuilder(plan).copyResults(input[0]->pool());
+  }
+
+  static const std::string& fieldName(const core::TypedExprPtr& expression) {
+    auto field = core::TypedExprs::asFieldAccess(expression);
+    VELOX_CHECK_NOT_NULL(field);
+    return field->name();
+  }
+
+  // Extract 'percentile' argument.
+  static std::vector<double> extractPercentiles(
+      const std::vector<RowVectorPtr>& input,
+      const core::CallTypedExprPtr& functionCall,
+      bool& isArray) {
+    const auto args = functionCall->inputs();
+    column_index_t percentileIndex = 1;
+    if (args.size() >= 3 && args[1]->type()->isBigint()) {
+      percentileIndex = 2;
+    }
+
+    const auto& percentileExpr = args[percentileIndex];
+
+    if (auto constantExpr = core::TypedExprs::asConstant(percentileExpr)) {
+      if (constantExpr->type()->isDouble()) {
+        isArray = false;
+        return {constantExpr->value().value<double>()};
+      }
+      isArray = true;
+      return toList(constantExpr->valueVector());
+    }
+
+    const auto& percentileVector = input[0]->childAt(fieldName(percentileExpr));
+
+    if (percentileVector->type()->isDouble()) {
+      VELOX_CHECK(!percentileVector->isNullAt(0));
+      isArray = false;
+      return {percentileVector->as<SimpleVector<double>>()->valueAt(0)};
+    }
+    isArray = true;
+    return toList(percentileVector);
+  }
+
+  static std::vector<double> toList(const VectorPtr& vector) {
+    VELOX_CHECK(vector->type()->equivalent(*ARRAY(DOUBLE())));
+
+    DecodedVector decoded(*vector);
+    auto arrayVector = decoded.base()->as<ArrayVector>();
+
+    VELOX_CHECK(!decoded.isNullAt(0));
+    const auto offset = arrayVector->offsetAt(decoded.index(0));
+    const auto size = arrayVector->sizeAt(decoded.index(0));
+
+    auto* elementsVector = arrayVector->elements()->as<SimpleVector<double>>();
+
+    std::vector<double> percentiles;
+    percentiles.reserve(size);
+    for (auto i = 0; i < size; ++i) {
+      VELOX_CHECK(!elementsVector->isNullAt(offset + i));
+      percentiles.push_back(elementsVector->valueAt(offset + i));
+    }
+    return percentiles;
+  }
+
+  // For each row ([k1, k2,] x) in 'result', lookup min_pct and max_pct in
+  // 'allRanges_'. Return a vector of ([k1, k2,] x, min_pct, max_pct) rows.
+  RowVectorPtr getPercentileRanges(const RowVectorPtr& result) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+    core::PlanNodePtr expectedSource;
+    core::PlanNodePtr actualSource;
+    if (result->childAt(name_)->type()->isArray()) {
+      expectedSource =
+          PlanBuilder(planNodeIdGenerator)
+              .values({allRanges_})
+              .appendColumns({fmt::format(
+                  "sequence(0, {}) as s", percentiles_.size() - 1)})
+              .unnest(
+                  append(groupingKeys_, {name_, "min_pct", "max_pct"}),
+                  {"s"},
+                  "pct_index")
+              .project(append(
+                  groupingKeys_,
+                  {name_, "min_pct", "max_pct", "pct_index - 1 as pct_index"}))
+              .planNode();
+
+      actualSource = PlanBuilder(planNodeIdGenerator)
+                         .values({result})
+                         .unnest(groupingKeys_, {name_}, "pct_index")
+                         .project(append(
+                             groupingKeys_,
+                             {
+                                 fmt::format("{}_e as {}", name_, name_),
+                                 "null::double as min_pct",
+                                 "null::double as max_pct",
+                                 "pct_index - 1 as pct_index",
+                             }))
+                         .planNode();
+    } else {
+      expectedSource = PlanBuilder(planNodeIdGenerator)
+                           .values({allRanges_})
+                           .appendColumns({"0 as pct_index"})
+                           .planNode();
+
+      actualSource = PlanBuilder(planNodeIdGenerator)
+                         .values({result})
+                         .appendColumns({
+                             "null::double as min_pct",
+                             "null::double as max_pct",
+                             "0 as pct_index",
+                         })
+                         .planNode();
+    }
+
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .localPartition({}, {expectedSource, actualSource})
+                    .singleAggregation(
+                        append(groupingKeys_, {name_, "pct_index"}),
+                        {
+                            "count(1) as cnt",
+                            "arbitrary(min_pct) as min_pct",
+                            "arbitrary(max_pct) as max_pct",
+                        })
+                    .filter({"cnt = 2"})
+                    .planNode();
+    return AssertQueryBuilder(plan).copyResults(result->pool());
+  }
+
+  // For each row ([k1, k2,] x) in 'result', lookup min_pct and max_pct in
+  // 'allRanges_'. Return a vector of ([k1, k2,] x, min_pct, max_pct) rows.
+  // For example, for an actual result table 't2(c1, row_num, actual)' where c1
+  // is the partition-by key, this method essentially returns the result of the
+  // following query:
+  // SELECT
+  //     c1,
+  //     actual,
+  //     CAST(order_pair.order_min AS DOUBLE) / CAST(cnt AS DOUBLE),
+  //     CAST(order_pair.order_max AS DOUBLE) / CAST(cnt AS DOUBLE)
+  // FROM (
+  //     SELECT
+  //         c1,
+  //         actual,
+  //         expected,
+  //         value,
+  //         order_pair,
+  //         cnt
+  //     FROM (
+  //         SELECT
+  //             c1,
+  //             ARBITRARY(actual) AS actual,
+  //             ARBITRARY(expected) AS expected,
+  //             ARBITRARY(cnt) AS cnt
+  //         FROM (
+  //             SELECT
+  //                 *
+  //             FROM (
+  //                 VALUES
+  //                     (TRUE, 1, 1, NULL, NULL),
+  //                     (FALSE, 7, 3, NULL, NULL)
+  //             ) t2(c1, row_num, actual, expected, cnt)
+  //
+  //             UNION ALL
+  //
+  //             SELECT
+  //                 *
+  //             FROM allRanges_
+  //         )
+  //         GROUP BY
+  //             c1,
+  //             row_num
+  //     ) combined(c1, actual, expected, cnt)
+  //     CROSS JOIN UNNEST(expected) AS tmp(value, order_pair)
+  //     WHERE
+  //         value = actual
+  // )
+  RowVectorPtr getPercentileRangesForWindow(const RowVectorPtr& result) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+    core::PlanNodePtr expectedSource;
+    core::PlanNodePtr actualSource;
+    core::PlanNodePtr plan;
+    expectedSource =
+        PlanBuilder(planNodeIdGenerator).values({allRanges_}).planNode();
+    auto expectedType = allRanges_->type()->asRow().findChild("expected");
+    std::stringstream ss;
+    toTypeSql(expectedType, ss);
+    auto expectedTypeSql = ss.str();
+
+    if (result->childAt(name_)->type()->isArray()) {
+      actualSource =
+          PlanBuilder(planNodeIdGenerator)
+              .values({result})
+              .project(append(
+                  groupingKeys_,
+                  {"row_number",
+                   fmt::format("{} as actual", name_),
+                   fmt::format("cast(null as {}) as expected", expectedTypeSql),
+                   "cast(null as bigint) as cnt"}))
+              .unnest(
+                  append(groupingKeys_, {"row_number", "expected", "cnt"}),
+                  {"actual"},
+                  "pct_index")
+              .project(append(
+                  groupingKeys_,
+                  {"row_number", "actual_e", "pct_index", "expected", "cnt"}))
+              .planNode();
+
+      plan =
+          PlanBuilder(planNodeIdGenerator)
+              .localPartition({}, {expectedSource, actualSource})
+              .singleAggregation(
+                  append(groupingKeys_, {"pct_index", "row_number"}),
+                  {"arbitrary(actual_e) as actual",
+                   "arbitrary(expected) as expected",
+                   "arbitrary(cnt) as cnt"})
+              .unnest(
+                  append(groupingKeys_, {"actual", "pct_index", "cnt"}),
+                  {"expected"})
+              .filter("actual = expected_k")
+              .project(append(
+                  groupingKeys_,
+                  {fmt::format("actual as {}", name_),
+                   "pct_index - 1 as pct_index",
+                   "cast(expected_v.c1 as double) / cast(cnt as double) as min_pct",
+                   "cast(expected_v.c2 as double) / cast(cnt as double) as max_pct"}))
+              .planNode();
+
+    } else {
+      actualSource =
+          PlanBuilder(planNodeIdGenerator)
+              .values({result})
+              .project(append(
+                  groupingKeys_,
+                  {"row_number",
+                   fmt::format("{} as actual", name_),
+                   fmt::format("cast(null as {}) as expected", expectedTypeSql),
+                   "cast(null as bigint) as cnt"}))
+              .planNode();
+
+      plan =
+          PlanBuilder(planNodeIdGenerator)
+              .localPartition({}, {expectedSource, actualSource})
+              .singleAggregation(
+                  append(groupingKeys_, {"row_number"}),
+                  {"arbitrary(actual) as actual",
+                   "arbitrary(expected) as expected",
+                   "arbitrary(cnt) as cnt"})
+              .unnest(append(groupingKeys_, {"actual", "cnt"}), {"expected"})
+              .filter("actual = expected_k")
+              .project(append(
+                  groupingKeys_,
+                  {fmt::format("actual as {}", name_),
+                   "0 as pct_index",
+                   "cast(expected_v.c1 as double) / cast(cnt as double) as min_pct",
+                   "cast(expected_v.c2 as double) / cast(cnt as double) as max_pct"}))
+              .planNode();
+    }
+    return AssertQueryBuilder(plan).copyResults(result->pool());
+  }
+
+  std::vector<std::string> groupingKeys_;
+  std::string name_;
+  std::vector<double> percentiles_;
+  double accuracy_;
+  RowVectorPtr allRanges_;
+  TypePtr resultType_;
+  bool verifyWindow_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h b/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h
new file mode 100644
index 0000000000000..99161c336f74d
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+namespace facebook::velox::exec::test {
+
+class ArbitraryResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return false;
+  }
+
+  bool supportsVerify() override {
+    return true;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    // Create an "oracle" with an array column of all elements in each group.
+    // The result of arbitrary will be verified by checking that it is an
+    // element in the array of the corresponding group.
+    std::stringstream ss;
+    toTypeSql(aggregate.call->type(), ss);
+    aggregateTypeSql_ = ss.str();
+    std::vector<std::string> projectColumns = groupingKeys;
+    // Add a column of aggregateTypeSql_ of all nulls so that we can union the
+    // oracle result with the actual result.
+    projectColumns.push_back(fmt::format(
+        "cast(NULL as {}) as {}", aggregateTypeSql_, aggregateName));
+    projectColumns.push_back("expected");
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan =
+        PlanBuilder(planNodeIdGenerator, input[0]->pool())
+            .values(input)
+            .singleAggregation(groupingKeys, {makeArrayAggCall(aggregate)})
+            .project(projectColumns)
+            .planNode();
+
+    expected_ = AssertQueryBuilder(plan).copyResults(input[0]->pool());
+    groupingKeys_ = groupingKeys;
+    name_ = aggregateName;
+  }
+
+  bool compare(
+      const RowVectorPtr& /*result*/,
+      const RowVectorPtr& /*altResult*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  bool verify(const RowVectorPtr& result) override {
+    // Union 'result' with 'expected_', group by on 'groupingKeys_' and produce
+    // pairs of actual and expected values per group. We cannot use join because
+    // grouping keys may have nulls because rows with some grouping keys being
+    // nulls are ignored during inner joins and considered unmatchable during
+    // left, right, and outer joins.
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto expectedSource =
+        PlanBuilder(planNodeIdGenerator).values({expected_}).planNode();
+
+    // Append a column of array of arbitrary result type so that we can union
+    // 'result' with 'expected_'.
+    auto actualSource =
+        PlanBuilder(planNodeIdGenerator, result->pool())
+            .values({result})
+            .appendColumns({fmt::format(
+                "cast(NULL as {}[]) as expected", aggregateTypeSql_)})
+            .planNode();
+
+    // In the union of 'expected_' and 'result', there are two rows for each
+    // group, one row with a non-null array of all elements, and the other row
+    // with the result of arbitrary(). Combine them by array_agg to make one row
+    // of each group with two arrays and then use remove_nulls to remove the
+    // nulls in these arrays. After remove_nulls, we'll check 'a[1]' is always
+    // an element in 'e[1]'. An exception is that if the original arbitrary()
+    // result is null, 'a' after remove_nulls is an empty array. In this
+    // situation, either 'e' is empty too, or e[1] is an array that only
+    // contains null.
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .localPartition({}, {expectedSource, actualSource})
+            .singleAggregation(
+                groupingKeys_,
+                {fmt::format("array_agg({}) as a", name_),
+                 "array_agg(expected) as e"})
+            .project({"remove_nulls(a) as a", "remove_nulls(e) as e"})
+            .project(
+                {"switch(cardinality(a) > 0, cardinality(e) > 0 and \"$internal$contains\"(e[1], a[1]), switch(cardinality(e) > 0, cardinality(remove_nulls(e[1])) = 0, true))"})
+            .planNode();
+    auto contains = AssertQueryBuilder(plan).copyResults(result->pool());
+
+    const auto numGroups = result->size();
+    VELOX_CHECK_EQ(numGroups, contains->size());
+
+    VectorPtr expected =
+        BaseVector::createConstant(BOOLEAN(), true, numGroups, result->pool());
+    velox::test::VectorMaker vectorMaker(result->pool());
+    auto expectedRow = vectorMaker.rowVector({expected});
+
+    return assertEqualResults({expectedRow}, {contains});
+  }
+
+  void reset() override {
+    expected_.reset();
+  }
+
+ private:
+  std::string makeArrayAggCall(
+      const core::AggregationNode::Aggregate& aggregate) {
+    const auto& args = aggregate.call->inputs();
+    VELOX_CHECK_GE(args.size(), 1);
+
+    auto inputField = core::TypedExprs::asFieldAccess(args[0]);
+    VELOX_CHECK_NOT_NULL(inputField);
+
+    std::string arrayAggCall = fmt::format("array_agg({})", inputField->name());
+
+    if (aggregate.mask != nullptr) {
+      arrayAggCall += fmt::format(" filter (where {})", aggregate.mask->name());
+    }
+    arrayAggCall += " as expected";
+
+    return arrayAggCall;
+  }
+
+  RowVectorPtr expected_;
+  std::vector<std::string> groupingKeys_;
+  std::string name_;
+  std::string aggregateTypeSql_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/CMakeLists.txt b/velox/functions/prestosql/fuzzer/CMakeLists.txt
new file mode 100644
index 0000000000000..7e5053ac61595
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/CMakeLists.txt
@@ -0,0 +1,61 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_aggregation_result_verifier MinMaxByResultVerifier.cpp)
+
+target_link_libraries(
+  velox_aggregation_result_verifier
+  velox_core
+  velox_aggregation_fuzzer_base
+  velox_exec_test_lib
+  velox_vector
+  velox_vector_test_lib)
+
+add_executable(velox_aggregation_fuzzer_test AggregationFuzzerTest.cpp)
+
+target_link_libraries(
+  velox_aggregation_fuzzer_test
+  velox_aggregation_fuzzer
+  velox_aggregation_fuzzer_base
+  velox_aggregation_result_verifier
+  velox_aggregates
+  velox_window
+  velox_vector_test_lib
+  GTest::gtest
+  GTest::gtest_main)
+
+# Window Fuzzer
+add_executable(velox_window_fuzzer_test WindowFuzzerTest.cpp)
+
+target_link_libraries(
+  velox_window_fuzzer_test
+  velox_window_fuzzer
+  velox_fuzzer_util
+  velox_aggregates
+  velox_window
+  velox_expression_test_utility
+  velox_functions_prestosql
+  velox_vector_test_lib
+  GTest::gtest
+  GTest::gtest_main)
+
+# Writer Fuzzer
+add_executable(velox_writer_fuzzer_test WriterFuzzerTest.cpp)
+
+target_link_libraries(
+  velox_writer_fuzzer_test
+  velox_writer_fuzzer
+  velox_fuzzer_util
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/functions/prestosql/fuzzer/DivideArgGenerator.h b/velox/functions/prestosql/fuzzer/DivideArgGenerator.h
new file mode 100644
index 0000000000000..2a05d2e71627b
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/DivideArgGenerator.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+
+namespace facebook::velox::exec::test {
+
+class DivideArgGenerator : public fuzzer::DecimalArgGeneratorBase {
+ public:
+  DivideArgGenerator() {
+    initialize(2);
+  }
+
+ protected:
+  std::optional<std::pair<int, int>>
+  toReturnType(int p1, int s1, int p2, int s2) override {
+    if (s1 + s2 > 38) {
+      return std::nullopt;
+    }
+
+    auto p = std::min(38, p1 + s2 + std::max(0, s2 - s1));
+    auto s = std::max(s1, s2);
+    return {{p, s}};
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h b/velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h
new file mode 100644
index 0000000000000..72cba5ec97f6d
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include "velox/expression/fuzzer/ArgGenerator.h"
+
+namespace facebook::velox::exec::test {
+
+class FloorAndRoundArgGenerator : public fuzzer::ArgGenerator {
+ public:
+  std::vector<TypePtr> generateArgs(
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      FuzzerGenerator& rng) override {
+    if (signature.argumentTypes().size() == 1) {
+      return generateSingleArg(returnType, rng);
+    }
+    VELOX_CHECK_EQ(2, signature.argumentTypes().size());
+    return generateTwoArgs(returnType);
+  }
+
+ private:
+  // Generates a decimal type following below formulas:
+  // p = p1 - s1 + min(s1, 1)
+  // s = 0
+  std::vector<TypePtr> generateSingleArg(
+      const TypePtr& returnType,
+      FuzzerGenerator& rng) {
+    const auto [p, s] = getDecimalPrecisionScale(*returnType);
+    if (s != 0) {
+      return {};
+    }
+
+    const auto s1 = rand32(38 - p + 1, rng);
+    if (s1 == 0) {
+      return {DECIMAL(p, 0)};
+    }
+
+    return {DECIMAL(p - 1 + s1, s1)};
+  }
+
+  // Generates a decimal type and an integer type. Decimal type is generated
+  // following below formulas:
+  // p = p1 + 1
+  // s = s1
+  std::vector<TypePtr> generateTwoArgs(const TypePtr& returnType) {
+    auto [p, s] = getDecimalPrecisionScale(*returnType);
+    if (p == 1 || p == s) {
+      return {};
+    }
+
+    return {DECIMAL(p - 1, s), INTEGER()};
+  }
+
+  static uint32_t rand32(uint32_t max, FuzzerGenerator& rng) {
+    return boost::random::uniform_int_distribution<uint32_t>()(rng) % max;
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/MapUnionSumInputGenerator.h b/velox/functions/prestosql/fuzzer/MapUnionSumInputGenerator.h
new file mode 100644
index 0000000000000..8fecf1a59a49b
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/MapUnionSumInputGenerator.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include <string>
+
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/vector/FlatVector.h"
+#include "velox/vector/fuzzer/GeneratorSpec.h"
+
+namespace facebook::velox::exec::test {
+
+template <typename T>
+class ValueDistribution {
+ public:
+  explicit ValueDistribution(size_t size) : size_{size} {}
+
+  T operator()(FuzzerGenerator& rng) const {
+    // Generate inputs within [max / size_, min / size_] so that the sum of
+    // size_ values won't exceed max or below min.
+    T upperBound = std::numeric_limits<T>::max() / (int64_t)size_;
+    T lowerBound = std::numeric_limits<T>::min() / (int64_t)size_;
+    return boost::random::uniform_int_distribution<T>(
+        lowerBound, upperBound)(rng);
+  }
+
+ private:
+  size_t size_;
+};
+
+class MapUnionSumInputGenerator : public InputGenerator {
+ public:
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& /*rng*/,
+      memory::MemoryPool* /*pool*/) override {
+    VELOX_CHECK_EQ(types.size(), 1);
+    VELOX_CHECK(types[0]->isMap());
+    auto mapType = types[0]->asMap();
+    auto valueType = mapType.valueType();
+    if (valueType->isDouble() || valueType->isReal()) {
+      return {};
+    }
+
+    std::vector<VectorPtr> result;
+    auto keyType = mapType.keyType();
+    auto keysVector = fuzzer.fuzzNotNull(keyType);
+
+    VectorPtr valuesVector;
+    switch (valueType->kind()) {
+      case TypeKind::TINYINT:
+        valuesVector = generateValues<TypeKind::TINYINT>(valueType, fuzzer);
+        break;
+      case TypeKind::SMALLINT:
+        valuesVector = generateValues<TypeKind::SMALLINT>(valueType, fuzzer);
+        break;
+      case TypeKind::INTEGER:
+        valuesVector = generateValues<TypeKind::INTEGER>(valueType, fuzzer);
+        break;
+      case TypeKind::BIGINT:
+        valuesVector = generateValues<TypeKind::BIGINT>(valueType, fuzzer);
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+
+    return {fuzzer.fuzzMap(
+        keysVector, valuesVector, fuzzer.getOptions().vectorSize)};
+  }
+
+  void reset() override {}
+
+ private:
+  template <TypeKind KIND>
+  VectorPtr generateValues(const TypePtr& type, VectorFuzzer& fuzzer) {
+    using T = typename TypeTraits<KIND>::NativeType;
+    ValueDistribution<T> distribution{fuzzer.getOptions().vectorSize};
+    ScalarGeneratorSpec<KIND, ValueDistribution<T>> generatorSpec{
+        type, std::move(distribution), fuzzer.getOptions().nullRatio};
+
+    return fuzzer.fuzz(generatorSpec);
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.cpp b/velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.cpp
new file mode 100644
index 0000000000000..a6f1a1fd23f47
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.cpp
@@ -0,0 +1,398 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.h"
+
+namespace facebook::velox::exec::test {
+
+void MinMaxByResultVerifier::initialize(
+    const std::vector<RowVectorPtr>& input,
+    const std::vector<std::string>& groupingKeys,
+    const core::AggregationNode::Aggregate& aggregate,
+    const std::string& aggregateName) {
+  if (aggregate.call->inputs().size() > 2) {
+    minMaxByN_ = true;
+  }
+
+  std::stringstream ss;
+  toTypeSql(aggregate.call->type(), ss);
+  aggregateTypeSql_ = ss.str();
+
+  // Suppose the original query is below
+  // SELECT
+  //     MIN_BY(x, y, 2) FILTER(
+  //         WHERE
+  //             a
+  //     )
+  // FROM (
+  //     VALUES
+  //         (1, 'a', 'g1', TRUE),
+  //         (2, 'a', 'g1', FALSE),
+  //         (3, 'b', 'g1', TRUE),
+  //         (4, 'a', 'g1', TRUE),
+  //         (5, NULL, 'g2', TRUE),
+  //         (6, 'b', 'g2', TRUE),
+  //         (7, 'a', 'g2', TRUE)
+  // ) t(x, y, b, a)
+  // GROUP BY
+  //     b
+  // , we construct a expected query as follows:
+  // SELECT
+  //     ARRAY_AGG(
+  //         expected
+  //         ORDER BY
+  //             y ASC nulls last
+  //     )
+  // FROM (
+  //     SELECT
+  //         b,
+  //         y,
+  //         expected
+  //     FROM (
+  //         SELECT
+  //             b,
+  //             y,
+  //             IF (y IS NULL, CAST(NULL AS ARRAY(BIGINT)), expected) AS
+  //             expected
+  //         FROM (
+  //             SELECT
+  //                 b,
+  //                 y,
+  //                 ARRAY_AGG(x) AS expected
+  //             FROM (
+  //                 VALUES
+  //                     (1, 'a', 'g1', TRUE),
+  //                     (2, 'a', 'g1', FALSE),
+  //                     (3, 'b', 'g1', TRUE),
+  //                     (4, 'a', 'g1', TRUE),
+  //                     (5, NULL, 'g2', TRUE),
+  //                     (6, 'a', 'g2', TRUE),
+  //                     (7, 'a', 'g2', TRUE)
+  //             ) t(x, y, b, a)
+  //             WHERE
+  //                 a
+  //             GROUP BY
+  //                 b,
+  //                 y
+  //         )
+  //     )
+  //     WHERE
+  //         expected IS NOT NULL
+  // )
+  // GROUP BY
+  //     b
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator, input[0]->pool()).values(input);
+  // Filter out masked rows first so that groups with all rows filtered out
+  // won't take a row_number during the filtering later.
+  if (aggregate.mask != nullptr) {
+    plan = plan.filter(aggregate.mask->name());
+  }
+
+  // First, we compute array_agg grouped by the original grouping keys
+  // plus y to get the buckets of x values by the same y. Use
+  // $internal$array_agg here to make sure we don't ignore NULLs.
+  auto yColumn = extractYColumnName(aggregate);
+  auto groupingKeysAndY = combine(groupingKeys, {yColumn});
+  plan =
+      plan.singleAggregation(groupingKeysAndY, {makeArrayAggCall(aggregate)});
+
+  // When y is NULL, min_by/max_by doesn't return the x values associated with
+  // it. So remove the x bucket for NULL y.
+  std::string expectColumn;
+  if (minMaxByN_) {
+    expectColumn = fmt::format(
+        "if ({} is null, cast(NULL as {}), expected) as expected",
+        yColumn,
+        aggregateTypeSql_);
+  } else {
+    expectColumn = fmt::format(
+        "if ({} is null, cast(NULL as {}[]), expected) as expected",
+        yColumn,
+        aggregateTypeSql_);
+  }
+  auto projectColumnsForNullY = combine(groupingKeysAndY, {expectColumn});
+  plan = plan.project(projectColumnsForNullY).filter("expected is not null");
+
+  // Aggregate buckets in order of y into a list per aggregation group.
+  plan = plan.singleAggregation(
+      groupingKeys,
+      {fmt::format(
+          "array_agg(expected order by {} {} nulls last) as expected",
+          yColumn,
+          minBy_ ? "asc" : "desc")});
+
+  // Add a column of aggregateTypeSql_ of all nulls so that we can union the
+  // expected list of buckets with the actual result in the verify method.
+  auto nullColumn =
+      fmt::format("cast(NULL as {}) as {}", aggregateTypeSql_, aggregateName);
+  auto finalProjectColumns = combine(groupingKeys, {nullColumn, "expected"});
+  plan = plan.project(finalProjectColumns);
+
+  expected_ = AssertQueryBuilder(plan.planNode()).copyResults(input[0]->pool());
+  groupingKeys_ = groupingKeys;
+  name_ = aggregateName;
+}
+
+bool MinMaxByResultVerifier::verify(const RowVectorPtr& result) {
+  // Union 'result' with 'expected_', group by on 'groupingKeys_' and produce
+  // pairs of actual and expected values per group. We cannot use join because
+  // grouping keys may have nulls.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto expectedSource =
+      PlanBuilder(planNodeIdGenerator).values({expected_}).planNode();
+
+  // Append a NULL column for the expected column to 'result' so that we can
+  // union 'result' with 'expected_'.
+  std::string nullExpected;
+  if (minMaxByN_) {
+    nullExpected =
+        fmt::format("cast(NULL as {}[]) as expected", aggregateTypeSql_);
+  } else {
+    nullExpected =
+        fmt::format("cast(NULL as {}[][]) as expected", aggregateTypeSql_);
+  }
+  auto actualSource = PlanBuilder(planNodeIdGenerator, result->pool())
+                          .values({result})
+                          .appendColumns({nullExpected})
+                          .planNode();
+
+  core::PlanNodePtr plan;
+  if (minMaxByN_) {
+    // Construct a query that checks every element in 'actualSource.a0' is
+    // contained in 'expectedSource.expected' of the corresponding group:
+    // SELECT
+    //     IF (CARDINALITY(a) > 0, a[1], CAST(NULL AS {})) AS a
+    //     IF (CARDINALITY(e) > 0, e[1], ARRAY[CAST(NULL AS {})]) AS e
+    // FROM (
+    //     SELECT
+    //         remove_nulls(a) AS a,
+    //         remove_nulls(e) AS e
+    //     FROM (
+    //         SELECT
+    //             ARRAY_AGG(a0) AS a,
+    //             ARRAY_AGG(expected) AS e
+    //         FROM (
+    //             SELECT
+    //                 *
+    //             FROM expected
+    //
+    //             UNION ALL
+    //
+    //             SELECT
+    //                 *
+    //             FROM actual
+    //         )
+    //         GROUP BY
+    //             b
+    //     )
+    // )
+    plan =
+        PlanBuilder(planNodeIdGenerator, result->pool())
+            .localPartition({}, {expectedSource, actualSource})
+            // Bring the actual and corresponding expected to the same row.
+            .singleAggregation(
+                groupingKeys_,
+                {fmt::format("array_agg({}) as a", name_),
+                 "array_agg(expected) as e"})
+            .project({"remove_nulls(a) as a", "remove_nulls(e) as e"})
+            // If a or e becomes empty, it means the original actual or
+            // expected was NULL and was removed at the last step. So recover
+            // them to be NULL. Otherwise, a and e should have only one
+            // element that is the original actual and expected, so extract
+            // it.
+            .project(
+                {fmt::format(
+                     "if (cardinality(a) > 0, a[1], cast(NULL as {})) as a",
+                     aggregateTypeSql_),
+                 fmt::format(
+                     "if (cardinality(e) > 0, e[1], array[cast(NULL as {})]) as e",
+                     aggregateTypeSql_)})
+            .planNode();
+  } else {
+    // Construct a query that checks 'actualSource.a0' is contained in
+    // 'expectedSource.expected'. This is similar to the query above, but has
+    // the top-level projection replaced with the last project below.
+    plan =
+        PlanBuilder(planNodeIdGenerator, result->pool())
+            .localPartition({}, {expectedSource, actualSource})
+            .singleAggregation(
+                groupingKeys_,
+                {fmt::format("array_agg({}) as a", name_),
+                 "array_agg(expected) as e"})
+            .project({"remove_nulls(a) as a", "remove_nulls(e) as e"})
+            // Wrap the actual result in an array so that it can use the same
+            // check logic for 3-arg min_by/max_by subsequently.
+            .project(
+                {fmt::format(
+                     "array[switch(cardinality(a) > 0, a[1], cast(null as {}))] as a",
+                     aggregateTypeSql_),
+                 fmt::format(
+                     "switch(cardinality(e) > 0, e[1], array[cast(null as {}[])]) as e",
+                     aggregateTypeSql_)})
+            .planNode();
+  }
+
+  // Check that elements in the actual result fall in the buckets in expected
+  // in order.
+  auto actualAndExpected = AssertQueryBuilder(plan).copyResults(result->pool());
+  auto numGroups = result->size();
+  VELOX_CHECK_EQ(numGroups, actualAndExpected->size());
+
+  auto actualColumn =
+      actualAndExpected->as<RowVector>()->childAt(0)->as<ArrayVector>();
+  auto expectedColumn =
+      actualAndExpected->as<RowVector>()->childAt(1)->as<ArrayVector>();
+  for (auto i = 0; i < numGroups; ++i) {
+    if (actualColumn->isNullAt(i)) {
+      VELOX_CHECK(containsNull(expectedColumn, i));
+    } else {
+      VELOX_CHECK(!expectedColumn->isNullAt(i));
+
+      auto actualOffset = actualColumn->offsetAt(i);
+      auto actualSize = actualColumn->sizeAt(i);
+      auto expectedOffset = expectedColumn->offsetAt(i);
+      auto expectedSize = expectedColumn->sizeAt(i);
+      VELOX_CHECK_GE(actualSize, 0);
+      VELOX_CHECK_GE(expectedSize, 0);
+
+      auto actualElements = actualColumn->elements();
+      auto expectedInnerBuckets = expectedColumn->elements()->as<ArrayVector>();
+      auto expectedBucketElements = expectedInnerBuckets->elements();
+      auto bucketIndex = 0;
+      auto remainingSize = actualSize;
+      while (remainingSize > 0) {
+        VELOX_CHECK_LT(
+            bucketIndex,
+            expectedSize,
+            "Elements in acutal result not found in expected buckets. ActualAndExpected at row {}: {}.\n",
+            i,
+            actualAndExpected->toString(i));
+        if (expectedInnerBuckets->isNullAt(expectedOffset + bucketIndex)) {
+          if (!minMaxByN_ && actualElements->isNullAt(actualOffset)) {
+            // min_by/max_by(x, y) returns NULL because all rows in the group
+            // are masked out.
+            remainingSize -= 1;
+            actualOffset += 1;
+            bucketIndex++;
+          } else {
+            bucketIndex++;
+          }
+          continue;
+        }
+        auto currentBucketSize =
+            expectedInnerBuckets->sizeAt(expectedOffset + bucketIndex);
+        auto currentBucketOffset =
+            expectedInnerBuckets->offsetAt(expectedOffset + bucketIndex);
+        auto numElementFromCurrentBucket =
+            std::min(currentBucketSize, remainingSize);
+        SelectivityVector memo(currentBucketSize, true);
+
+        for (auto j = 0; j < numElementFromCurrentBucket; ++j) {
+          if (getElementIndexInBucketWithMemo(
+                  actualElements,
+                  actualOffset + j,
+                  expectedBucketElements,
+                  currentBucketOffset,
+                  currentBucketSize,
+                  memo) == -1) {
+            VELOX_FAIL(
+                "Element in actual result not found in expected buckets.");
+          }
+        }
+
+        remainingSize -= numElementFromCurrentBucket;
+        actualOffset += numElementFromCurrentBucket;
+        bucketIndex++;
+      }
+    }
+  }
+  return true;
+}
+
+std::vector<std::string> MinMaxByResultVerifier::combine(
+    const std::vector<std::string>& op1,
+    const std::vector<std::string>& op2) {
+  std::vector<std::string> result;
+  result.reserve(op1.size() + op2.size());
+  result.insert(result.end(), op1.begin(), op1.end());
+  result.insert(result.end(), op2.begin(), op2.end());
+  return result;
+}
+
+bool MinMaxByResultVerifier::containsNull(
+    const ArrayVector* vector,
+    vector_size_t index) {
+  auto offset = vector->offsetAt(index);
+  auto size = vector->sizeAt(index);
+  for (auto i = 0; i < size; ++i) {
+    if (vector->elements()->isNullAt(offset + i)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+int32_t MinMaxByResultVerifier::getElementIndexInBucketWithMemo(
+    const VectorPtr& actualElements,
+    vector_size_t actualIndex,
+    const VectorPtr& expectedBucketElements,
+    vector_size_t currentBucketOffset,
+    vector_size_t currentBucketSize,
+    SelectivityVector& memo) {
+  for (auto i = 0; i < currentBucketSize; ++i) {
+    if (actualElements->equalValueAt(
+            expectedBucketElements.get(),
+            actualIndex,
+            currentBucketOffset + i) &&
+        memo.isValid(i)) {
+      memo.setValid(i, false);
+      return i;
+    }
+  }
+  return -1;
+}
+
+std::string MinMaxByResultVerifier::extractYColumnName(
+    const core::AggregationNode::Aggregate& aggregate) {
+  const auto& args = aggregate.call->inputs();
+  VELOX_CHECK_GE(args.size(), 2);
+
+  auto inputField = core::TypedExprs::asFieldAccess(args[1]);
+  VELOX_CHECK_NOT_NULL(inputField);
+
+  return inputField->name();
+}
+
+std::string MinMaxByResultVerifier::makeArrayAggCall(
+    const core::AggregationNode::Aggregate& aggregate) {
+  const auto& args = aggregate.call->inputs();
+  VELOX_CHECK_GE(args.size(), 1);
+
+  auto distinct = aggregate.distinct ? "distinct" : "";
+  auto inputField = core::TypedExprs::asFieldAccess(args[0]);
+  VELOX_CHECK_NOT_NULL(inputField);
+
+  // Use $internal$array_agg to ensure we don't ignore input nulls since they
+  // may affect the result of min_by/max_by.
+  std::string arrayAggCall = fmt::format(
+      "\"$internal$array_agg\"({} {})", distinct, inputField->name());
+  arrayAggCall += " as expected";
+
+  return arrayAggCall;
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.h b/velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.h
new file mode 100644
index 0000000000000..a43aa2da5128e
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/MinMaxByResultVerifier.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <algorithm>
+#include <string>
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/ResultVerifier.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+namespace facebook::velox::exec::test {
+
+// For aggregation calls min_by/max_by(x, y) and min_by/max_by(x, y, n),
+// MinMaxByResultVerifier works by computing an expected list of x-value-list
+// bucketed by the y values and checking the actual result values fall in the
+// expected list of buckets in order.
+// For example: for SELECT min_by(x, y, 2)
+//                  FROM (VALUES (2, 'b'), (1, 'b'), (3, 'a')) t(x, y),
+// the result verifier computes an expected list [[3], [2, 1]]. Suppose the
+// actual result is [3, 1], the verifier then checks that the result value 3
+// matches the first expected bucket [3] and the result value 1 falls in the
+// second expected bucket [2, 1]. The verifier reports an error if an actual
+// result value is not found in the first unexhausted expected bucket.
+//
+// min_by/max_by(x, y) and min_by/max_by(x, y, n) can return NULL in three
+// situations:
+// (1) all x in the group are masked out,
+// (2) all y in the group are NULL,
+// (3) for min_by/max_by(x, y), one of x associated with min/max y is NULL.
+class MinMaxByResultVerifier : public ResultVerifier {
+ public:
+  explicit MinMaxByResultVerifier(bool minBy) : minBy_{minBy} {}
+
+  bool supportsCompare() override {
+    return false;
+  }
+
+  bool supportsVerify() override {
+    return true;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override;
+
+  bool compare(
+      const RowVectorPtr& /*result*/,
+      const RowVectorPtr& /*altResult*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  bool verify(const RowVectorPtr& result) override;
+
+  void reset() override {
+    expected_.reset();
+    groupingKeys_.clear();
+    name_.clear();
+    aggregateTypeSql_.clear();
+    minMaxByN_ = false;
+  }
+
+ private:
+  // Returns a vector of strings that is a combination of op1 and op2. This
+  // method doesn't remove duplicates.
+  std::vector<std::string> combine(
+      const std::vector<std::string>& op1,
+      const std::vector<std::string>& op2);
+
+  // Returns true if the array in 'vector' at 'index' contains a null.
+  bool containsNull(const ArrayVector* vector, vector_size_t index);
+
+  // Returns the index of the first element that hasn't matched before in
+  // 'expectedBucketElements' at [currentBucketOffset, currentBucketOffset +
+  // currentBucketSize) that equals to the value in actualElements at
+  // actualIndex. Each element in expectedBucketElements can match with an
+  // actual element only once, tracked by 'memo'.
+  int32_t getElementIndexInBucketWithMemo(
+      const VectorPtr& actualElements,
+      vector_size_t actualIndex,
+      const VectorPtr& expectedBucketElements,
+      vector_size_t currentBucketOffset,
+      vector_size_t currentBucketSize,
+      SelectivityVector& memo);
+
+  std::string extractYColumnName(
+      const core::AggregationNode::Aggregate& aggregate);
+
+  std::string makeArrayAggCall(
+      const core::AggregationNode::Aggregate& aggregate);
+
+  RowVectorPtr expected_;
+  std::vector<std::string> groupingKeys_;
+  std::string name_;
+  std::string aggregateTypeSql_;
+  bool minBy_;
+  bool minMaxByN_{false};
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/MinMaxInputGenerator.h b/velox/functions/prestosql/fuzzer/MinMaxInputGenerator.h
new file mode 100644
index 0000000000000..accbeb0378d55
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/MinMaxInputGenerator.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include <string>
+
+#include "velox/exec/fuzzer/InputGenerator.h"
+
+namespace facebook::velox::exec::test {
+
+class MinMaxInputGenerator : public InputGenerator {
+ public:
+  explicit MinMaxInputGenerator(const std::string& name)
+      : indexOfN_{indexOfN(name)} {}
+
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    // TODO Generate inputs free of nested nulls.
+    if (types.size() <= indexOfN_) {
+      return {};
+    }
+
+    // Make sure to use the same value of 'n' for all batches in a given Fuzzer
+    // iteration.
+    if (!n_.has_value()) {
+      n_ = boost::random::uniform_int_distribution<int64_t>(0, 9'999)(rng);
+    }
+
+    const auto size = fuzzer.getOptions().vectorSize;
+
+    std::vector<VectorPtr> inputs;
+    inputs.reserve(types.size());
+    for (auto i = 0; i < types.size() - 1; ++i) {
+      inputs.push_back(fuzzer.fuzz(types[i]));
+    }
+
+    VELOX_CHECK(
+        types.back()->isBigint(),
+        "Unexpected type: {}",
+        types.back()->toString());
+    inputs.push_back(
+        BaseVector::createConstant(BIGINT(), n_.value(), size, pool));
+    return inputs;
+  }
+
+  void reset() override {
+    n_.reset();
+  }
+
+ private:
+  // Returns zero-based index of the 'n' argument, 1 for min and max. 2 for
+  // min_by and max_by.
+  static int32_t indexOfN(const std::string& name) {
+    if (name == "min" || name == "max") {
+      return 1;
+    }
+
+    if (name == "min_by" || name == "max_by") {
+      return 2;
+    }
+
+    VELOX_FAIL("Unexpected function name: {}", name);
+  }
+
+  // Zero-based index of the 'n' argument.
+  const int32_t indexOfN_;
+  std::optional<int64_t> n_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/ModulusArgGenerator.h b/velox/functions/prestosql/fuzzer/ModulusArgGenerator.h
new file mode 100644
index 0000000000000..e29a01044449c
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/ModulusArgGenerator.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+
+namespace facebook::velox::exec::test {
+
+class ModulusArgGenerator : public fuzzer::DecimalArgGeneratorBase {
+ public:
+  ModulusArgGenerator() {
+    initialize(2);
+  }
+
+ protected:
+  std::optional<std::pair<int, int>>
+  toReturnType(int p1, int s1, int p2, int s2) override {
+    auto s = std::max(s1, s2);
+    auto p = std::min(p2 - s2, p1 - s1) + s;
+    return {{p, s}};
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h b/velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h
new file mode 100644
index 0000000000000..b8bc21be5112d
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+
+namespace facebook::velox::exec::test {
+
+class MultiplyArgGenerator : public fuzzer::DecimalArgGeneratorBase {
+ public:
+  MultiplyArgGenerator() {
+    initialize(2);
+  }
+
+ protected:
+  std::optional<std::pair<int, int>>
+  toReturnType(int p1, int s1, int p2, int s2) override {
+    if (s1 + s2 > 38) {
+      return std::nullopt;
+    }
+
+    auto p = std::min(38, p1 + p2);
+    auto s = s1 + s2;
+    return {{p, s}};
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h b/velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h
new file mode 100644
index 0000000000000..12d166b6a0557
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+
+namespace facebook::velox::exec::test {
+
+class PlusMinusArgGenerator : public fuzzer::DecimalArgGeneratorBase {
+ public:
+  PlusMinusArgGenerator() {
+    initialize(2);
+  }
+
+ protected:
+  std::optional<std::pair<int, int>>
+  toReturnType(int p1, int s1, int p2, int s2) override {
+    auto s = std::max(s1, s2);
+    auto p = std::min(38, std::max(p1 - s1, p2 - s2) + 1 + s);
+    return {{p, s}};
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/TruncateArgGenerator.h b/velox/functions/prestosql/fuzzer/TruncateArgGenerator.h
new file mode 100644
index 0000000000000..9d413461a9b22
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/TruncateArgGenerator.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_01.hpp>
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+
+namespace facebook::velox::exec::test {
+
+class TruncateArgGenerator : public fuzzer::ArgGenerator {
+ public:
+  std::vector<TypePtr> generateArgs(
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      FuzzerGenerator& rng) override {
+    // Only the single-arg truncate function is supported because
+    // ArgumentTypeFuzzer can generate argument types for the two-arg truncate
+    // function.
+    VELOX_CHECK_EQ(1, signature.argumentTypes().size());
+    // Generates a decimal type following below formulas:
+    // p = max(p1 - s1, 1)
+    // s = 0
+    const auto [p, s] = getDecimalPrecisionScale(*returnType);
+    if (s != 0) {
+      return {};
+    }
+
+    // p1 = s1
+    if (p == 1 && coinToss(rng)) {
+      const auto s1 = rand32(1, 38, rng);
+      return {DECIMAL(s1, s1)};
+    }
+
+    const auto s1 = rand32(0, 38 - p, rng);
+    return {DECIMAL(p + s1, s1)};
+  }
+
+ private:
+  // Returns true 50% of times.
+  static bool coinToss(FuzzerGenerator& rng) {
+    return boost::random::uniform_01<double>()(rng) < 0.5;
+  }
+
+  static uint32_t rand32(uint32_t min, uint32_t max, FuzzerGenerator& rng) {
+    return boost::random::uniform_int_distribution<uint32_t>(min, max)(rng);
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
new file mode 100644
index 0000000000000..dc9e17ca42501
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <unordered_set>
+
+#include "velox/exec/fuzzer/WindowFuzzerRunner.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/fuzzer/ApproxDistinctInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/MinMaxInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/WindowOffsetInputGenerator.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+DEFINE_string(
+    only,
+    "",
+    "If specified, Fuzzer will only choose functions from "
+    "this comma separated list of function names "
+    "(e.g: --only \"min\" or --only \"sum,avg\").");
+
+DEFINE_string(
+    presto_url,
+    "",
+    "Presto coordinator URI along with port. If set, we use Presto "
+    "source of truth. Otherwise, use DuckDB. Example: "
+    "--presto_url=http://127.0.0.1:8080");
+
+DEFINE_uint32(
+    req_timeout_ms,
+    1000,
+    "Timeout in milliseconds for HTTP requests made to reference DB, "
+    "such as Presto. Example: --req_timeout_ms=2000");
+
+namespace facebook::velox::exec::test {
+namespace {
+
+std::unordered_map<std::string, std::shared_ptr<InputGenerator>>
+getCustomInputGenerators() {
+  return {
+      {"min", std::make_shared<MinMaxInputGenerator>("min")},
+      {"min_by", std::make_shared<MinMaxInputGenerator>("min_by")},
+      {"max", std::make_shared<MinMaxInputGenerator>("max")},
+      {"max_by", std::make_shared<MinMaxInputGenerator>("max_by")},
+      {"approx_distinct", std::make_shared<ApproxDistinctInputGenerator>()},
+      {"approx_set", std::make_shared<ApproxDistinctInputGenerator>()},
+      {"approx_percentile", std::make_shared<ApproxPercentileInputGenerator>()},
+      {"lead", std::make_shared<WindowOffsetInputGenerator>(1)},
+      {"lag", std::make_shared<WindowOffsetInputGenerator>(1)},
+      {"nth_value", std::make_shared<WindowOffsetInputGenerator>(1)},
+      {"ntile", std::make_shared<WindowOffsetInputGenerator>(0)},
+  };
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
+
+int main(int argc, char** argv) {
+  facebook::velox::aggregate::prestosql::registerAllAggregateFunctions(
+      "", false, true);
+  facebook::velox::aggregate::prestosql::registerInternalAggregateFunctions("");
+  facebook::velox::window::prestosql::registerAllWindowFunctions();
+  facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  facebook::velox::memory::MemoryManager::initialize({});
+
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+
+  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+
+  // List of functions that have known bugs that cause crashes or failures.
+  static const std::unordered_set<std::string> skipFunctions = {
+      // Skip internal functions used only for result verifications.
+      "$internal$count_distinct",
+      "$internal$array_agg",
+      // https://github.com/facebookincubator/velox/issues/3493
+      "stddev_pop",
+      // Lambda functions are not supported yet.
+      "reduce_agg",
+      // array_agg requires a flag controlling whether to ignore nulls.
+      "array_agg",
+      // min_by and max_by are fixed recently, requiring Presto-0.286.
+      // https://github.com/prestodb/presto/pull/21793
+      "min_by",
+      "max_by",
+  };
+
+  // Functions whose results verification should be skipped. These can be
+  // functions that return complex-typed results containing floating-point
+  // fields.
+  // TODO: allow custom result verifiers.
+  using facebook::velox::exec::test::ApproxDistinctResultVerifier;
+  using facebook::velox::exec::test::ApproxPercentileResultVerifier;
+
+  static const std::unordered_map<
+      std::string,
+      std::shared_ptr<facebook::velox::exec::test::ResultVerifier>>
+      customVerificationFunctions = {
+          // Approx functions.
+          {"approx_distinct", std::make_shared<ApproxDistinctResultVerifier>()},
+          {"approx_set", nullptr},
+          {"approx_percentile",
+           std::make_shared<ApproxPercentileResultVerifier>()},
+          {"approx_most_frequent", nullptr},
+          {"merge", nullptr},
+          // Semantically inconsistent functions
+          {"skewness", nullptr},
+          {"kurtosis", nullptr},
+          {"entropy", nullptr},
+          // https://github.com/facebookincubator/velox/issues/6330
+          {"max_data_size_for_stats", nullptr},
+          {"sum_data_size_for_stats", nullptr},
+      };
+
+  static const std::unordered_set<std::string> orderDependentFunctions = {
+      // Window functions.
+      "first_value",
+      "last_value",
+      "nth_value",
+      "ntile",
+      "lag",
+      "lead",
+      "row_number",
+      "cume_dist",
+      "rank",
+      "dense_rank",
+      "percent_rank",
+      // Aggregation functions.
+      "any_value",
+      "arbitrary",
+      "array_agg",
+      "set_agg",
+      "set_union",
+      "map_agg",
+      "map_union",
+      "map_union_sum",
+      "max_by",
+      "min_by",
+      "multimap_agg",
+  };
+
+  using Runner = facebook::velox::exec::test::WindowFuzzerRunner;
+  using Options = facebook::velox::exec::test::AggregationFuzzerOptions;
+  using facebook::velox::exec::test::setupReferenceQueryRunner;
+
+  Options options;
+  options.onlyFunctions = FLAGS_only;
+  options.skipFunctions = skipFunctions;
+  options.customVerificationFunctions = customVerificationFunctions;
+  options.customInputGenerators =
+      facebook::velox::exec::test::getCustomInputGenerators();
+  options.orderDependentFunctions = orderDependentFunctions;
+  options.timestampPrecision =
+      facebook::velox::VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
+      facebook::velox::memory::memoryManager()->addRootPool()};
+  return Runner::run(
+      initialSeed,
+      setupReferenceQueryRunner(
+          rootPool.get(),
+          FLAGS_presto_url,
+          "window_fuzzer",
+          FLAGS_req_timeout_ms),
+      options);
+}
diff --git a/velox/functions/prestosql/fuzzer/WindowOffsetInputGenerator.h b/velox/functions/prestosql/fuzzer/WindowOffsetInputGenerator.h
new file mode 100644
index 0000000000000..461c38c9a7fc7
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/WindowOffsetInputGenerator.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+namespace facebook::velox::exec::test {
+
+// Generates an integer 1, 2, 3, or 9'000'000'000 as the argument at
+// argumentIndex for functions.
+class WindowOffsetInputGenerator : public InputGenerator {
+ public:
+  explicit WindowOffsetInputGenerator(int64_t argumentIndex)
+      : argumentIndex_{argumentIndex} {}
+
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& /*rng*/,
+      memory::MemoryPool* pool) override {
+    if (types.size() <= argumentIndex_) {
+      return {};
+    }
+
+    const auto size = fuzzer.getOptions().vectorSize;
+
+    std::vector<VectorPtr> inputs;
+    inputs.reserve(argumentIndex_ + 1);
+    for (auto i = 0; i < argumentIndex_; ++i) {
+      inputs.push_back(fuzzer.fuzz(types[i]));
+    }
+
+    facebook::velox::test::VectorMaker vectorMaker{pool};
+    auto baseN = vectorMaker.flatVector<int64_t>({1, 2, 3, 9'000'000'000});
+    inputs.push_back(fuzzer.fuzzDictionary(baseN, size));
+
+    return inputs;
+  }
+
+  void reset() override {}
+
+ private:
+  const int64_t argumentIndex_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/WriterFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/WriterFuzzerTest.cpp
new file mode 100644
index 0000000000000..df3a8e5713ac2
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/WriterFuzzerTest.cpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+
+#include "velox/exec/fuzzer/PrestoQueryRunner.h"
+#include "velox/exec/fuzzer/WriterFuzzerRunner.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+DEFINE_string(
+    presto_url,
+    "",
+    "Presto coordinator URI along with port. If set, we use Presto "
+    "source of truth. Otherwise, use DuckDB. Example: "
+    "--presto_url=http://127.0.0.1:8080");
+
+DEFINE_uint32(
+    req_timeout_ms,
+    1000,
+    "Timeout in milliseconds for HTTP requests made to reference DB, "
+    "such as Presto. Example: --req_timeout_ms=2000");
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+
+  facebook::velox::memory::MemoryManager::initialize({});
+
+  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+
+  using Runner = facebook::velox::exec::test::WriterFuzzerRunner;
+  using PrestoQueryRunner = facebook::velox::exec::test::PrestoQueryRunner;
+
+  VELOX_CHECK(
+      !FLAGS_presto_url.empty(),
+      "Table writer fuzzer only supports presto DB for now");
+  std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
+      facebook::velox::memory::memoryManager()->addRootPool()};
+  auto queryRunner = std::make_unique<PrestoQueryRunner>(
+      rootPool.get(),
+      FLAGS_presto_url,
+      "writer_fuzzer",
+      static_cast<std::chrono::milliseconds>(FLAGS_req_timeout_ms));
+  LOG(INFO) << "Using Presto as the reference DB.";
+  return Runner::run(initialSeed, std::move(queryRunner));
+}
diff --git a/velox/functions/prestosql/json/CMakeLists.txt b/velox/functions/prestosql/json/CMakeLists.txt
index 6488f3418c8c0..549cf3f15317f 100644
--- a/velox/functions/prestosql/json/CMakeLists.txt
+++ b/velox/functions/prestosql/json/CMakeLists.txt
@@ -11,11 +11,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_functions_json JsonExtractor.cpp JsonPathTokenizer.cpp
-                                 SIMDJsonExtractor.cpp)
+velox_add_library(
+  velox_functions_json
+  JsonExtractor.cpp
+  JsonPathTokenizer.cpp
+  JsonStringUtil.cpp
+  SIMDJsonExtractor.cpp
+  SIMDJsonUtil.cpp)
 
-target_link_libraries(velox_functions_json velox_exception Folly::folly
-                      simdjson::simdjson)
+velox_link_libraries(velox_functions_json velox_exception Folly::folly
+                     simdjson::simdjson)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/prestosql/json/JsonExtractor.cpp b/velox/functions/prestosql/json/JsonExtractor.cpp
index c782232bd490d..1c1127d062c1a 100644
--- a/velox/functions/prestosql/json/JsonExtractor.cpp
+++ b/velox/functions/prestosql/json/JsonExtractor.cpp
@@ -73,7 +73,7 @@ class JsonExtractor {
 
     while (kTokenizer.hasNext()) {
       if (auto token = kTokenizer.getNext()) {
-        tokens_.push_back(token.value());
+        tokens_.emplace_back(token.value());
       } else {
         tokens_.clear();
         return false;
diff --git a/velox/functions/prestosql/json/JsonPathTokenizer.cpp b/velox/functions/prestosql/json/JsonPathTokenizer.cpp
index 62482ff178bbb..8f11ace04398c 100644
--- a/velox/functions/prestosql/json/JsonPathTokenizer.cpp
+++ b/velox/functions/prestosql/json/JsonPathTokenizer.cpp
@@ -18,23 +18,59 @@
 
 namespace facebook::velox::functions {
 
+namespace {
 const char ROOT = '$';
 const char DOT = '.';
 const char COLON = ':';
 const char DASH = '-';
-const char QUOTE = '"';
+const char DOUBLE_QUOTE = '"';
+const char SINGLE_QUOTE = '\'';
 const char STAR = '*';
 const char BACK_SLASH = '\\';
 const char UNDER_SCORE = '_';
 const char OPEN_BRACKET = '[';
 const char CLOSE_BRACKET = ']';
 
-bool JsonPathTokenizer::reset(folly::StringPiece path) {
-  if (path.empty() || path[0] != ROOT) {
+bool isUnquotedBracketKeyFormat(char c) {
+  return c == UNDER_SCORE || c == STAR || c == DASH || std::isalnum(c);
+}
+
+bool isDotKeyFormat(char c) {
+  return c == COLON || c == DASH || isUnquotedBracketKeyFormat(c);
+}
+
+} // namespace
+
+bool JsonPathTokenizer::reset(std::string_view path) {
+  if (path.empty()) {
+    index_ = 0;
+    path_ = {};
+    return false;
+  }
+
+  if (path[0] == ROOT) {
+    index_ = 1;
+    path_ = path;
+    return true;
+  }
+
+  // Presto supplements basic JsonPath implementation with Jayway engine,
+  // which allows paths that do not start with '$'. Jayway simply prepends
+  // such paths with '$.'. This logic supports paths like 'foo' by converting
+  // them to '$.foo'. However, this logic converts paths like '.foo' into
+  // '$..foo' which uses deep scan operator (..). This changes the meaning of
+  // the path in unexpected way.
+  //
+  // Here, we allow paths like 'foo', 'foo.bar', [0] and similar. We do not
+  // allow paths like '.foo'.
+
+  index_ = 0;
+  if (path[0] == DOT) {
+    path_ = {};
     return false;
   }
-  index_ = 1;
   path_ = path;
+
   return true;
 }
 
@@ -42,87 +78,95 @@ bool JsonPathTokenizer::hasNext() const {
   return index_ < path_.size();
 }
 
-ParseResult JsonPathTokenizer::getNext() {
-  if (match(DOT)) {
+std::optional<std::string> JsonPathTokenizer::getNext() {
+  if (index_ == 0 && path_[0] != OPEN_BRACKET) {
+    // We are parsing first token in a path that doesn't start with '$' and
+    // doesn't start with '['. In this case, we assume the path starts with
+    // '$.'.
     return matchDotKey();
   }
+
+  if (index_ > 0 && match(DOT)) {
+    if (hasNext() && path_[index_] != OPEN_BRACKET) {
+      return matchDotKey();
+    }
+    // Simply ignore the '.' followed by '['. This allows non-standard paths
+    // like '$.[0].[1].[2]' supported by Jayway / Presto.
+  }
+
   if (match(OPEN_BRACKET)) {
-    auto token =
-        match(QUOTE) ? matchQuotedSubscriptKey() : matchUnquotedSubscriptKey();
+    auto token = match(DOUBLE_QUOTE)
+        ? matchQuotedSubscriptKey(DOUBLE_QUOTE)
+        : (match(SINGLE_QUOTE) ? matchQuotedSubscriptKey(SINGLE_QUOTE)
+                               : matchUnquotedSubscriptKey());
     if (!token || !match(CLOSE_BRACKET)) {
-      return folly::makeUnexpected(false);
+      return std::nullopt;
     }
     return token;
   }
-  return folly::makeUnexpected(false);
+
+  return std::nullopt;
 }
 
 bool JsonPathTokenizer::match(char expected) {
-  if (index_ < path_.size() && path_[index_] == expected) {
+  if (hasNext() && path_[index_] == expected) {
     index_++;
     return true;
   }
   return false;
 }
 
-ParseResult JsonPathTokenizer::matchDotKey() {
+std::optional<std::string> JsonPathTokenizer::matchDotKey() {
   auto start = index_;
-  while ((index_ < path_.size()) && isDotKeyFormat(path_[index_])) {
+  while (hasNext() && isDotKeyFormat(path_[index_])) {
     index_++;
   }
-  if (index_ <= start) {
-    return folly::makeUnexpected(false);
+  if (index_ == start) {
+    return std::nullopt;
   }
-  return path_.subpiece(start, index_ - start).str();
+  return std::string(path_.substr(start, index_ - start));
 }
 
-ParseResult JsonPathTokenizer::matchUnquotedSubscriptKey() {
+std::optional<std::string> JsonPathTokenizer::matchUnquotedSubscriptKey() {
   auto start = index_;
-  while (index_ < path_.size() && isUnquotedBracketKeyFormat(path_[index_])) {
+  while (hasNext() && isUnquotedBracketKeyFormat(path_[index_])) {
     index_++;
   }
-  if (index_ <= start) {
-    return folly::makeUnexpected(false);
+  if (index_ == start) {
+    return std::nullopt;
   }
-  return path_.subpiece(start, index_ - start).str();
+  return std::string(path_.substr(start, index_ - start));
 }
 
 // Reference Presto logic in
 // src/test/java/io/prestosql/operator/scalar/TestJsonExtract.java and
 // src/main/java/io/prestosql/operator/scalar/JsonExtract.java
-ParseResult JsonPathTokenizer::matchQuotedSubscriptKey() {
+std::optional<std::string> JsonPathTokenizer::matchQuotedSubscriptKey(
+    char quote) {
   bool escaped = false;
   std::string token;
-  while ((index_ < path_.size()) && (escaped || path_[index_] != QUOTE)) {
+  while (hasNext() && (escaped || path_[index_] != quote)) {
     if (escaped) {
-      if (path_[index_] != QUOTE && path_[index_] != BACK_SLASH) {
-        return folly::makeUnexpected(false);
+      if (path_[index_] != quote && path_[index_] != BACK_SLASH) {
+        return std::nullopt;
       }
       escaped = false;
       token.append(1, path_[index_]);
     } else {
       if (path_[index_] == BACK_SLASH) {
         escaped = true;
-      } else if (path_[index_] == QUOTE) {
-        return folly::makeUnexpected(false);
+      } else if (path_[index_] == quote) {
+        return std::nullopt;
       } else {
         token.append(1, path_[index_]);
       }
     }
     index_++;
   }
-  if (escaped || token.empty() || !match(QUOTE)) {
-    return folly::makeUnexpected(false);
+  if (escaped || token.empty() || !match(quote)) {
+    return std::nullopt;
   }
   return token;
 }
 
-bool JsonPathTokenizer::isDotKeyFormat(char c) {
-  return c == COLON || c == DASH || isUnquotedBracketKeyFormat(c);
-}
-
-bool JsonPathTokenizer::isUnquotedBracketKeyFormat(char c) {
-  return c == UNDER_SCORE || c == STAR || std::isalnum(c);
-}
-
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/JsonPathTokenizer.h b/velox/functions/prestosql/json/JsonPathTokenizer.h
index 6cead5859756d..48ca2a90636b2 100644
--- a/velox/functions/prestosql/json/JsonPathTokenizer.h
+++ b/velox/functions/prestosql/json/JsonPathTokenizer.h
@@ -16,36 +16,78 @@
 
 #pragma once
 
-#include <folly/Expected.h>
-#include <folly/Range.h>
+#include <optional>
+#include <string>
 
 namespace facebook::velox::functions {
 
-using ParseResult = folly::Expected<std::string, bool>;
-
+/// Splits a JSON path into individual tokens.
+///
+/// Supports a subset of JSONPath syntax:
+/// https://goessner.net/articles/JsonPath/
+///
+///   $ - the root element
+///   . or [] - child operator
+///   * - wildcard (all objects/elements regardless their names)
+///
+/// Supports single- and double-quoted keys.
+///
+/// Notably, doesn't support deep scan, e.g. $..author.
+///
+/// The leading '$.' is optional. Paths '$.foo.bar' and 'foo.bar' are
+/// equivalent. This is not part of JSONPath syntax, but this is the behavior of
+/// Jayway implementation used by Presto.
+///
+/// The leading '$' is optional in paths like '$[0]' or '$["foo"]'. Paths '[0]'
+/// and '$[0]' are equivalent.  This is not part of JSONPath syntax, but this is
+/// the behavior of Jayway implementation used by Presto.
+///
+/// It is allowed to use dot-notation redundantly, e.g. non-standard path
+/// '$.[0].foo' is allowed and is equivalent to '$[0].foo'. Similarly, paths
+/// '$.[0].[1].[2]' and '$[0].[1][2]' are allowed and equivalent to
+/// '$[0][1][2]'.
+///
+/// Examples:
+///   "$"
+///   "$.store.book[0].author"
+///   "store.book[0].author"
+///   "store.book.[0].author"
+///   "$[0].foo.bar"
+///   "$[-1]"
+///   "[0][1]"
+///   "$['store'][book][1]"
 class JsonPathTokenizer {
  public:
-  bool reset(folly::StringPiece path);
+  /// Resets the tokenizer to a new path. This method must be called and return
+  /// true before calling hasNext or getNext.
+  ///
+  /// @return true if path is not empty and first character suggests a possibly
+  /// valid path.
+  bool reset(std::string_view path);
 
+  /// Returns true if there are more tokens to be extracted.
   bool hasNext() const;
 
-  ParseResult getNext();
+  /// Returns the next token or std::nullopt if there are no more tokens left or
+  /// the remaining path is invalid.
+  std::optional<std::string> getNext();
 
  private:
   bool match(char expected);
-  ParseResult matchDotKey();
-
-  ParseResult matchUnquotedSubscriptKey();
 
-  ParseResult matchQuotedSubscriptKey();
+  std::optional<std::string> matchDotKey();
 
-  bool isDotKeyFormat(char c);
+  std::optional<std::string> matchUnquotedSubscriptKey();
 
-  bool isUnquotedBracketKeyFormat(char c);
+  std::optional<std::string> matchQuotedSubscriptKey(char quote);
 
- private:
+  // The index of the next character to process. This is at least one for
+  // standard paths that start with '$'. This can be zero if 'reset' was called
+  // with a non-standard path that doesn't have a leading '$'.
   size_t index_;
-  folly::StringPiece path_;
+
+  // The path specified in 'reset'.
+  std::string_view path_;
 };
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/JsonStringUtil.cpp b/velox/functions/prestosql/json/JsonStringUtil.cpp
new file mode 100644
index 0000000000000..43be101ec40cc
--- /dev/null
+++ b/velox/functions/prestosql/json/JsonStringUtil.cpp
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <array>
+
+#include "folly/Unicode.h"
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/functions/lib/Utf8Utils.h"
+#include "velox/functions/prestosql/json/JsonStringUtil.h"
+
+using namespace facebook::velox::functions;
+
+namespace facebook::velox {
+namespace {
+
+FOLLY_ALWAYS_INLINE char hexDigit(uint8_t c) {
+  VELOX_DCHECK_LT(c, 16);
+  return c < 10 ? c + '0' : c - 10 + 'A';
+}
+
+FOLLY_ALWAYS_INLINE void writeHex(char16_t value, char*& out) {
+  value = folly::Endian::little(value);
+  *out++ = '\\';
+  *out++ = 'u';
+  *out++ = hexDigit((value >> 12) & 0x0F);
+  *out++ = hexDigit((value >> 8) & 0x0F);
+  *out++ = hexDigit((value >> 4) & 0x0F);
+  *out++ = hexDigit(value & 0x0F);
+}
+
+std::array<int8_t, 128> getAsciiEscapes() {
+  std::array<int8_t, 128> escapes;
+  std::fill(escapes.data(), escapes.data() + 32, -1);
+  escapes['"'] = '"';
+  escapes['\\'] = '\\';
+  escapes['\b'] = 'b';
+  escapes['\t'] = 't';
+  escapes['\n'] = 'n';
+  escapes['\f'] = 'f';
+  escapes['\r'] = 'r';
+  return escapes;
+}
+static const std::array<int8_t, 128> asciiEscapes = getAsciiEscapes();
+
+FOLLY_ALWAYS_INLINE void encodeAscii(int8_t value, char*& out) {
+  int8_t escapeCode = asciiEscapes[value];
+  if (escapeCode == 0) {
+    *out++ = char(value);
+  } else if (escapeCode > 0) {
+    *out++ = '\\';
+    *out++ = char(escapeCode);
+  } else {
+    writeHex(value, out);
+  }
+}
+
+std::array<int8_t, 128> getEncodedAsciiSizes() {
+  std::array<int8_t, 128> sizes;
+  for (int c = 0; c < 128; c++) {
+    int8_t escapeCode = asciiEscapes[c];
+    if (escapeCode == 0) {
+      sizes[c] = 1;
+    } else if (escapeCode > 0) {
+      sizes[c] = 2;
+    } else {
+      sizes[c] = 6;
+    }
+  }
+  return sizes;
+}
+static const std::array<int8_t, 128> encodedAsciiSizes = getEncodedAsciiSizes();
+
+// Encode `codePoint` value into one or two UTF-16 code units. Write each code
+// unit as prefixed hexadecimals of 6 chars.
+FOLLY_ALWAYS_INLINE void encodeUtf16Hex(char32_t codePoint, char*& out) {
+  VELOX_DCHECK(codePoint <= 0x10FFFFu);
+  // Two 16-bit code units are needed.
+  if (codePoint >= 0x10000u) {
+    writeHex(
+        static_cast<char16_t>(
+            0xD800u + (((codePoint - 0x10000u) >> 10) & 0x3FFu)),
+        out);
+    writeHex(
+        static_cast<char16_t>(0xDC00u + ((codePoint - 0x10000u) & 0x3FFu)),
+        out);
+    return;
+  }
+  // One 16-bit code unit is needed.
+  writeHex(static_cast<char16_t>(codePoint), out);
+}
+
+} // namespace
+
+void testingEncodeUtf16Hex(char32_t codePoint, char*& out) {
+  encodeUtf16Hex(codePoint, out);
+}
+
+void escapeString(const char* input, size_t length, char* output) {
+  char* pos = output;
+
+  auto* start = reinterpret_cast<const unsigned char*>(input);
+  auto* end = reinterpret_cast<const unsigned char*>(input + length);
+  while (start < end) {
+    int count = validateAndGetNextUtf8Length(start, end);
+    switch (count) {
+      case 1: {
+        encodeAscii(int8_t(*start), pos);
+        start++;
+        continue;
+      }
+      case 2: {
+        memcpy(pos, reinterpret_cast<const char*>(start), 2);
+        pos += 2;
+        start += 2;
+        continue;
+      }
+      case 3: {
+        memcpy(pos, reinterpret_cast<const char*>(start), 3);
+        pos += 3;
+        start += 3;
+        continue;
+      }
+      case 4: {
+        char32_t codePoint = folly::utf8ToCodePoint(start, end, true);
+        if (codePoint == U'\ufffd') {
+          writeHex(0xFFFDu, pos);
+          continue;
+        }
+        encodeUtf16Hex(codePoint, pos);
+        continue;
+      }
+      default: {
+        writeHex(0xFFFDu, pos);
+        start++;
+      }
+    }
+  }
+}
+
+size_t escapedStringSize(const char* input, size_t length) {
+  // 6 chars that is returned by `writeHex`.
+  constexpr size_t kEncodedHexSize = 6;
+
+  size_t outSize = 0;
+
+  auto* start = reinterpret_cast<const unsigned char*>(input);
+  auto* end = reinterpret_cast<const unsigned char*>(input + length);
+  while (start < end) {
+    int count = validateAndGetNextUtf8Length(start, end);
+    switch (count) {
+      case 1:
+        outSize += encodedAsciiSizes[int8_t(*start)];
+        break;
+      case 2:
+      case 3:
+        outSize += count;
+        break;
+      case 4:
+        outSize += kEncodedHexSize * 2;
+        break;
+      default:
+        outSize += kEncodedHexSize;
+        count = 1;
+    }
+    start += count;
+  }
+
+  return outSize;
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/json/JsonStringUtil.h b/velox/functions/prestosql/json/JsonStringUtil.h
new file mode 100644
index 0000000000000..65cadd86bf683
--- /dev/null
+++ b/velox/functions/prestosql/json/JsonStringUtil.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+namespace facebook::velox {
+/// Escape the unicode characters of `input` to make it canonical for JSON
+/// and legal to print in JSON text. It is assumed that the input is UTF-8
+/// encoded.
+/// It handles the different unicode planes or code point ranges as follows,
+/// 1. Basic Multilingual Plane [0, 0xFFFF]
+///    a. [0, 0x7F] ASCII. Input is encoded by one UTF-8 byte. Refer to
+///       the `encodeAscii` function for output.
+///    b. [0x80, 0x07FF]. Input is encoded by two UTF-8 bytes. Output the UTF-8
+///       encoding of the code point, which are thus identical bytes as
+///       the input.
+///    c. [0x0800, 0xD7FF] + [0xE000, 0xFFFF]. Input is encoded by three UTF-8
+///       bytes. Output the UTF-8 encoding of the code point, which are thus
+///       identical bytes as the input.
+/// 2. 16 Supplementary Planes [0x10000, 0x10FFFF]
+///    a. [0x10000, 0x10FFFF]. Input is encoded by four UTF-8 bytes. Output
+///       the UTF-16 encoding of the code point, with two UTF-16 code units in
+///       uppercase hexadecimal and prefixed with '\' and 'u'.
+/// For illegal code point value or invalid UTF-8 input, return "\uFFFD".
+/// @param input: Input string to escape that is UTF-8 encoded.
+/// @param length: Length of the input string.
+/// @param output: Output string to write the escaped input to. The caller is
+///                responsible to allocate enough space for output.
+void escapeString(const char* input, size_t length, char* output);
+
+/// Return the size of string after the unicode characters of `input` are
+/// escaped using the method as in`escapeString`. The function will iterate
+/// over `input` once.
+/// @param input: Input string to escape that is UTF-8 encoded.
+/// @param length: Length of the input string.
+size_t escapedStringSize(const char* input, size_t length);
+
+/// For test only. Encode `codePoint` value by UTF-16 and write the one or two
+/// prefixed hexadecimals to `out`. Move `out` forward by 6 or 12 chars
+/// accordingly. The caller shall ensure there is enough space in `out`.
+void testingEncodeUtf16Hex(char32_t codePoint, char*& out);
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/json/SIMDJsonExtractor.cpp b/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
index 5d6de816f841c..0766b1dd0f2af 100644
--- a/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
+++ b/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
@@ -16,7 +16,11 @@
 
 #include "velox/functions/prestosql/json/SIMDJsonExtractor.h"
 
-namespace facebook::velox::functions::detail {
+namespace facebook::velox::functions {
+namespace {
+using JsonVector = std::vector<simdjson::ondemand::value>;
+}
+
 /* static */ SIMDJsonExtractor& SIMDJsonExtractor::getInstance(
     folly::StringPiece path) {
   // Cache tokenize operations in JsonExtractor across invocations in the same
@@ -42,12 +46,6 @@ namespace facebook::velox::functions::detail {
   return *it.first->second;
 }
 
-simdjson::simdjson_result<simdjson::ondemand::document>
-SIMDJsonExtractor::parse(const simdjson::padded_string& json) {
-  thread_local static simdjson::ondemand::parser parser;
-  return parser.iterate(json);
-}
-
 bool SIMDJsonExtractor::tokenize(const std::string& path) {
   thread_local static JsonPathTokenizer tokenizer;
 
@@ -61,7 +59,7 @@ bool SIMDJsonExtractor::tokenize(const std::string& path) {
 
   while (tokenizer.hasNext()) {
     if (auto token = tokenizer.getNext()) {
-      tokens_.push_back(token.value());
+      tokens_.emplace_back(token.value());
     } else {
       tokens_.clear();
       return false;
@@ -71,7 +69,7 @@ bool SIMDJsonExtractor::tokenize(const std::string& path) {
   return true;
 }
 
-bool extractObject(
+simdjson::error_code extractObject(
     simdjson::ondemand::value& jsonValue,
     const std::string& key,
     std::optional<simdjson::ondemand::value>& ret) {
@@ -80,24 +78,34 @@ bool extractObject(
     SIMDJSON_ASSIGN_OR_RAISE(auto currentKey, field.unescaped_key());
     if (currentKey == key) {
       ret.emplace(field.value());
-      return true;
+      return simdjson::SUCCESS;
     }
   }
-  return true;
+  return simdjson::SUCCESS;
 }
 
-bool extractArray(
+simdjson::error_code extractArray(
     simdjson::ondemand::value& jsonValue,
     const std::string& index,
     std::optional<simdjson::ondemand::value>& ret) {
   SIMDJSON_ASSIGN_OR_RAISE(auto jsonArray, jsonValue.get_array());
   auto rv = folly::tryTo<int32_t>(index);
+
   if (rv.hasValue()) {
-    auto val = jsonArray.at(rv.value());
+    auto i = rv.value();
+    if (i < 0) {
+      size_t numElements;
+      if (jsonArray.count_elements().get(numElements)) {
+        return simdjson::SUCCESS;
+      }
+
+      i += numElements;
+    }
+    auto val = jsonArray.at(i);
     if (!val.error()) {
       ret.emplace(std::move(val));
     }
   }
-  return true;
+  return simdjson::SUCCESS;
 }
-} // namespace facebook::velox::functions::detail
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/SIMDJsonExtractor.h b/velox/functions/prestosql/json/SIMDJsonExtractor.h
index 5dc4c9a48e2b1..a816ec08874d2 100644
--- a/velox/functions/prestosql/json/SIMDJsonExtractor.h
+++ b/velox/functions/prestosql/json/SIMDJsonExtractor.h
@@ -21,55 +21,43 @@
 #include "folly/Range.h"
 #include "folly/dynamic.h"
 #include "velox/common/base/Exceptions.h"
-#include "velox/common/base/Macros.h"
 #include "velox/functions/prestosql/json/JsonPathTokenizer.h"
-#include "velox/functions/prestosql/json/SIMDJsonWrapper.h"
+#include "velox/functions/prestosql/json/SIMDJsonUtil.h"
 #include "velox/type/StringView.h"
 
-#define SIMDJSON_ASSIGN_OR_RAISE_IMPL(_resultName, _lhs, _rexpr) \
-  auto&& _resultName = (_rexpr);                                 \
-  if (_resultName.error() != ::simdjson::SUCCESS) {              \
-    return false;                                                \
-  }                                                              \
-  _lhs = std::move(_resultName).value_unsafe();
-
-#define SIMDJSON_ASSIGN_OR_RAISE(_lhs, _rexpr) \
-  SIMDJSON_ASSIGN_OR_RAISE_IMPL(VELOX_VARNAME(_simdjsonResult), _lhs, _rexpr)
-
 namespace facebook::velox::functions {
 
-template <typename TConsumer>
-bool simdJsonExtract(
-    const velox::StringView& json,
-    const velox::StringView& path,
-    TConsumer&& consumer);
-
-namespace detail {
-
-using JsonVector = std::vector<simdjson::ondemand::value>;
-
 class SIMDJsonExtractor {
  public:
   template <typename TConsumer>
-  bool extract(
+  simdjson::error_code extract(
       simdjson::ondemand::value& json,
       TConsumer& consumer,
       size_t tokenStartIndex = 0);
 
-  // Returns true if this extractor was initialized with the trivial path "$".
+  /// Returns true if this extractor was initialized with the trivial path "$".
   bool isRootOnlyPath() {
     return tokens_.empty();
   }
 
-  simdjson::simdjson_result<simdjson::ondemand::document> parse(
-      const simdjson::padded_string& json);
+  /// Returns true if this extractor was initialized with a path that's
+  /// guaranteed to match at most one entry.
+  bool isDefinitePath() {
+    for (const auto& token : tokens_) {
+      if (token == "*") {
+        return false;
+      }
+    }
 
- private:
-  // Use this method to get an instance of SIMDJsonExtractor given a JSON path.
-  // Given the nature of the cache, it's important this is only used by
-  // simdJsonExtract.
+    return true;
+  }
+
+  /// Use this method to get an instance of SIMDJsonExtractor given a JSON path.
+  /// Given the nature of the cache, it's important this is only used by
+  /// the callers of simdJsonExtract.
   static SIMDJsonExtractor& getInstance(folly::StringPiece path);
 
+ private:
   // Shouldn't instantiate directly - use getInstance().
   explicit SIMDJsonExtractor(const std::string& path) {
     if (!tokenize(path)) {
@@ -83,26 +71,20 @@ class SIMDJsonExtractor {
   static const uint32_t kMaxCacheSize{32};
 
   std::vector<std::string> tokens_;
-
-  template <typename TConsumer>
-  friend bool facebook::velox::functions::simdJsonExtract(
-      const velox::StringView& json,
-      const velox::StringView& path,
-      TConsumer&& consumer);
 };
 
-bool extractObject(
+simdjson::error_code extractObject(
     simdjson::ondemand::value& jsonObj,
     const std::string& key,
     std::optional<simdjson::ondemand::value>& ret);
 
-bool extractArray(
+simdjson::error_code extractArray(
     simdjson::ondemand::value& jsonValue,
     const std::string& index,
     std::optional<simdjson::ondemand::value>& ret);
 
 template <typename TConsumer>
-bool SIMDJsonExtractor::extract(
+simdjson::error_code SIMDJsonExtractor::extract(
     simdjson::ondemand::value& json,
     TConsumer& consumer,
     size_t tokenStartIndex) {
@@ -114,36 +96,28 @@ bool SIMDJsonExtractor::extract(
        tokenIndex++) {
     auto& token = tokens_[tokenIndex];
     if (input.type() == simdjson::ondemand::json_type::object) {
-      if (!extractObject(input, token, result)) {
-        return false;
-      }
+      SIMDJSON_TRY(extractObject(input, token, result));
     } else if (input.type() == simdjson::ondemand::json_type::array) {
       if (token == "*") {
         for (auto child : input.get_array()) {
           if (tokenIndex == tokens_.size() - 1) {
             // If this is the last token in the path, consume each element in
             // the array.
-            if (!consumer(child.value())) {
-              return false;
-            }
+            SIMDJSON_TRY(consumer(child.value()));
           } else {
             // If not, then recursively call the extract function on each
             // element in the array.
-            if (!extract(child.value(), consumer, tokenIndex + 1)) {
-              return false;
-            }
+            SIMDJSON_TRY(extract(child.value(), consumer, tokenIndex + 1));
           }
         }
 
-        return true;
+        return simdjson::SUCCESS;
       } else {
-        if (!extractArray(input, token, result)) {
-          return false;
-        }
+        SIMDJSON_TRY(extractArray(input, token, result));
       }
     }
     if (!result) {
-      return true;
+      return simdjson::SUCCESS;
     }
 
     input = result.value();
@@ -151,8 +125,7 @@ bool SIMDJsonExtractor::extract(
   }
 
   return consumer(input);
-}
-} // namespace detail
+};
 
 /**
  * Extract element(s) from a JSON object using the given path.
@@ -169,20 +142,16 @@ bool SIMDJsonExtractor::extract(
  *                  Note that once consumer returns, it should be assumed that
  *                  the argument passed in is no longer valid, so do not attempt
  *                  to store it as is in the consumer.
- * @return Return true on success.
- *         If any errors are encountered parsing the JSON, returns false.
+ * @return Return simdjson::SUCCESS on success.
+ *         If any errors are encountered parsing the JSON, returns the error.
  */
-
 template <typename TConsumer>
-bool simdJsonExtract(
+simdjson::error_code simdJsonExtract(
     const velox::StringView& json,
-    const velox::StringView& path,
+    SIMDJsonExtractor& extractor,
     TConsumer&& consumer) {
-  // If extractor fails to parse the path, this will throw a VeloxUserError, and
-  // we want to let this exception bubble up to the client.
-  auto& extractor = detail::SIMDJsonExtractor::getInstance(path);
   simdjson::padded_string paddedJson(json.data(), json.size());
-  SIMDJSON_ASSIGN_OR_RAISE(auto jsonDoc, extractor.parse(paddedJson));
+  SIMDJSON_ASSIGN_OR_RAISE(auto jsonDoc, simdjsonParse(paddedJson));
 
   if (extractor.isRootOnlyPath()) {
     // If the path is just to return the original object, call consumer on the
@@ -194,14 +163,4 @@ bool simdJsonExtract(
   return extractor.extract(value, std::forward<TConsumer>(consumer));
 }
 
-template <typename TConsumer>
-bool simdJsonExtract(
-    const std::string& json,
-    const std::string& path,
-    TConsumer&& consumer) {
-  return simdJsonExtract(
-      velox::StringView(json),
-      velox::StringView(path),
-      std::forward<TConsumer>(consumer));
-}
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/SIMDJsonUtil.cpp b/velox/functions/prestosql/json/SIMDJsonUtil.cpp
new file mode 100644
index 0000000000000..c63e5263502d5
--- /dev/null
+++ b/velox/functions/prestosql/json/SIMDJsonUtil.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/json/SIMDJsonUtil.h"
+
+#include "velox/common/base/VeloxException.h"
+
+namespace facebook::velox {
+
+void simdjsonErrorsToExceptions(
+    std::exception_ptr exceptions[simdjson::NUM_ERROR_CODES]) {
+  for (int i = 1; i < simdjson::NUM_ERROR_CODES; ++i) {
+    simdjson::simdjson_error e(static_cast<simdjson::error_code>(i));
+    exceptions[i] = toVeloxException(std::make_exception_ptr(e));
+  }
+}
+
+simdjson::simdjson_result<simdjson::ondemand::document> simdjsonParse(
+    const simdjson::padded_string_view& json) {
+  thread_local simdjson::ondemand::parser parser;
+  return parser.iterate(json);
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/json/SIMDJsonUtil.h b/velox/functions/prestosql/json/SIMDJsonUtil.h
new file mode 100644
index 0000000000000..d510c319c10e4
--- /dev/null
+++ b/velox/functions/prestosql/json/SIMDJsonUtil.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/prestosql/json/SIMDJsonWrapper.h"
+
+#include <folly/Preprocessor.h>
+
+#define SIMDJSON_ASSIGN_OR_RAISE_IMPL(_resultName, _lhs, _rexpr) \
+  auto&& _resultName = (_rexpr);                                 \
+  if (_resultName.error() != ::simdjson::SUCCESS) {              \
+    return _resultName.error();                                  \
+  }                                                              \
+  _lhs = std::move(_resultName).value_unsafe();
+
+/// Helper to extract simdjson_result<T>.  Return immediately if the result is
+/// an error.  Examples:
+///
+///   std::string s;
+///   SIMDJSON_ASSIGN_OR_RAISE(s, simdjson::to_json_string(v));
+///
+///   SIMDJSON_ASSIGN_OR_RAISE(auto s, simdjson::to_json_string(v));
+#define SIMDJSON_ASSIGN_OR_RAISE(_lhs, _rexpr) \
+  SIMDJSON_ASSIGN_OR_RAISE_IMPL(               \
+      FB_ANONYMOUS_VARIABLE(_simdjsonResult), _lhs, _rexpr)
+
+namespace facebook::velox {
+
+/// Initialize the exceptions array with all possible simdjson error codes.
+void simdjsonErrorsToExceptions(
+    std::exception_ptr exceptions[simdjson::NUM_ERROR_CODES]);
+
+/// Parse the input json string using a thread local on demand parser.
+simdjson::simdjson_result<simdjson::ondemand::document> simdjsonParse(
+    const simdjson::padded_string_view& json);
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/json/tests/CMakeLists.txt b/velox/functions/prestosql/json/tests/CMakeLists.txt
index e01499b7c6e4a..d1a2ee0fa26ee 100644
--- a/velox/functions/prestosql/json/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/json/tests/CMakeLists.txt
@@ -21,7 +21,7 @@ target_link_libraries(
   velox_functions_json_test
   velox_functions_json
   Folly::folly
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
diff --git a/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp b/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
index 3ba9260efd37c..900a903a0db23 100644
--- a/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
+++ b/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
@@ -416,7 +416,7 @@ TEST(JsonExtractorTest, fullJsonValueTest) {
 
 TEST(JsonExtractorTest, invalidJsonPathTest) {
   EXPECT_THROW_INVALID_ARGUMENT(""s, ""s);
-  EXPECT_THROW_INVALID_ARGUMENT("{}"s, "$.bar[2][-1]"s);
+  EXPECT_THROW_INVALID_ARGUMENT("{}"s, "$.bar[2]-1"s);
   EXPECT_THROW_INVALID_ARGUMENT("{}"s, "$.fuu..bar"s);
   EXPECT_THROW_INVALID_ARGUMENT("{}"s, "$."s);
   EXPECT_THROW_INVALID_ARGUMENT(""s, "$$"s);
diff --git a/velox/functions/prestosql/json/tests/JsonPathTokenizerTest.cpp b/velox/functions/prestosql/json/tests/JsonPathTokenizerTest.cpp
index da497534aae6c..fcddb6591aa87 100644
--- a/velox/functions/prestosql/json/tests/JsonPathTokenizerTest.cpp
+++ b/velox/functions/prestosql/json/tests/JsonPathTokenizerTest.cpp
@@ -17,107 +17,144 @@
 #include "velox/functions/prestosql/json/JsonPathTokenizer.h"
 
 #include <vector>
-
 #include "gtest/gtest.h"
 
 using namespace std::string_literals;
-using facebook::velox::functions::JsonPathTokenizer;
 using TokenList = std::vector<std::string>;
 
-#define EXPECT_TOKEN_EQ(path, expected)  \
-  {                                      \
-    auto jsonPath = path;                \
-    auto tokens = getTokens(jsonPath);   \
-    EXPECT_TRUE(bool(tokens));           \
-    EXPECT_EQ(expected, tokens.value()); \
-  }
-
-#define EXPECT_TOKEN_INVALID(path) \
-  {                                \
-    auto tokens = getTokens(path); \
-    EXPECT_FALSE(bool(tokens));    \
-  }
+namespace facebook::velox::functions {
+namespace {
 
-#define EXPECT_QUOTED_TOKEN_EQ(path, expected) \
-  {                                            \
-    auto quotedPath = "$[\"" + path + "\"]";   \
-    EXPECT_TOKEN_EQ(quotedPath, expected);     \
-  }
-
-#define EXPECT_UNQUOTED_TOKEN_INVALID(path) \
-  {                                         \
-    auto invalidPath = "$." + path;         \
-    EXPECT_TOKEN_INVALID(invalidPath);      \
+std::optional<TokenList> getTokens(std::string_view path) {
+  JsonPathTokenizer tokenizer;
+  if (!tokenizer.reset(path)) {
+    return std::nullopt;
   }
 
-// The test is ported from Presto for compatibility
-folly::Expected<TokenList, bool> getTokens(const std::string& path) {
-  JsonPathTokenizer tokenizer;
-  tokenizer.reset(path);
   TokenList tokens;
   while (tokenizer.hasNext()) {
     if (auto token = tokenizer.getNext()) {
-      tokens.push_back(token.value());
+      tokens.emplace_back(token.value());
     } else {
       tokens.clear();
-      return folly::makeUnexpected(false);
+      return std::nullopt;
     }
   }
   return tokens;
 }
 
-TEST(JsonPathTokenizerTest, tokenizeTest) {
-  EXPECT_TOKEN_EQ("$"s, TokenList());
-  EXPECT_TOKEN_EQ("$.foo"s, TokenList{"foo"s});
-  EXPECT_TOKEN_EQ("$[\"foo\"]"s, TokenList{"foo"s});
-  EXPECT_TOKEN_EQ("$[\"foo.bar\"]"s, TokenList{"foo.bar"s});
-  EXPECT_TOKEN_EQ("$[42]"s, TokenList{"42"s});
-  EXPECT_TOKEN_EQ("$.42"s, TokenList{"42"s});
-  EXPECT_TOKEN_EQ("$.42.63"s, (TokenList{"42"s, "63"s}));
-  EXPECT_TOKEN_EQ(
-      "$.foo.42.bar.63"s, (TokenList{"foo"s, "42"s, "bar"s, "63"s}));
-  EXPECT_TOKEN_EQ("$.x.foo"s, (TokenList{"x"s, "foo"s}));
-  EXPECT_TOKEN_EQ("$.x[\"foo\"]"s, (TokenList{"x"s, "foo"s}));
-  EXPECT_TOKEN_EQ("$.x[42]"s, (TokenList{"x"s, "42"s}));
-  EXPECT_TOKEN_EQ("$.foo_42._bar63"s, (TokenList{"foo_42"s, "_bar63"s}));
-  EXPECT_TOKEN_EQ("$[foo_42][_bar63]"s, (TokenList{"foo_42"s, "_bar63"s}));
-  EXPECT_TOKEN_EQ("$.foo:42.:bar63"s, (TokenList{"foo:42"s, ":bar63"s}));
-  EXPECT_TOKEN_EQ(
-      "$[\"foo:42\"][\":bar63\"]"s, (TokenList{"foo:42"s, ":bar63"s}));
-  EXPECT_TOKEN_EQ(
+// 'path' should start with '$'.
+void assertValidPath(std::string_view path, const TokenList& expectedTokens) {
+  auto tokens = getTokens(path);
+
+  EXPECT_TRUE(tokens.has_value()) << "Invalid JSON path: " << path;
+  if (!tokens.has_value()) {
+    return;
+  }
+
+  EXPECT_EQ(expectedTokens, tokens.value());
+}
+
+void assertQuotedToken(
+    const std::string& token,
+    const TokenList& expectedTokens) {
+  auto quotedPath = "$[\"" + token + "\"]";
+  assertValidPath(quotedPath, expectedTokens);
+
+  auto invalidPath = "$." + token;
+  EXPECT_FALSE(getTokens(invalidPath));
+}
+
+// The test is ported from Presto for compatibility.
+TEST(JsonPathTokenizerTest, validPaths) {
+  assertValidPath("$"s, TokenList());
+  assertValidPath("$.foo"s, TokenList{"foo"s});
+  assertValidPath("$[\"foo\"]"s, TokenList{"foo"s});
+  assertValidPath("$[\"foo.bar\"]"s, TokenList{"foo.bar"s});
+  assertValidPath("$[42]"s, TokenList{"42"s});
+  assertValidPath("$[-1]"s, TokenList{"-1"s});
+  assertValidPath("$.42"s, TokenList{"42"s});
+  assertValidPath("$.42.63"s, TokenList{"42"s, "63"s});
+  assertValidPath("$.foo.42.bar.63"s, TokenList{"foo"s, "42"s, "bar"s, "63"s});
+  assertValidPath("$.x.foo"s, TokenList{"x"s, "foo"s});
+  assertValidPath("$.x[\"foo\"]"s, TokenList{"x"s, "foo"s});
+  assertValidPath("$.x[42]"s, TokenList{"x"s, "42"s});
+  assertValidPath("$.foo_42._bar63"s, TokenList{"foo_42"s, "_bar63"s});
+  assertValidPath("$[foo_42][_bar63]"s, TokenList{"foo_42"s, "_bar63"s});
+  assertValidPath("$.foo:42.:bar63"s, TokenList{"foo:42"s, ":bar63"s});
+  assertValidPath(
+      "$[\"foo:42\"][\":bar63\"]"s, TokenList{"foo:42"s, ":bar63"s});
+  assertValidPath("$['foo:42'][':bar63']"s, TokenList{"foo:42"s, ":bar63"s});
+  assertValidPath(
       "$.store.fruit[*].weight",
-      (TokenList{"store"s, "fruit"s, "*"s, "weight"s}));
-  EXPECT_QUOTED_TOKEN_EQ("!@#$%^&*()[]{}/?'"s, TokenList{"!@#$%^&*()[]{}/?'"s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("!@#$%^&*()[]{}/?'"s);
-  EXPECT_QUOTED_TOKEN_EQ("ab\u0001c"s, TokenList{"ab\u0001c"s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("ab\u0001c"s);
-  EXPECT_QUOTED_TOKEN_EQ("ab\0c"s, TokenList{"ab\0c"s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("ab\0c"s);
-  EXPECT_QUOTED_TOKEN_EQ("ab\t\n\rc"s, TokenList{"ab\t\n\rc"s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("ab\t\n\rc"s);
-  EXPECT_QUOTED_TOKEN_EQ("."s, TokenList{"."s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("."s);
-  EXPECT_QUOTED_TOKEN_EQ("$"s, TokenList{"$"s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("$"s);
-  EXPECT_QUOTED_TOKEN_EQ("]"s, TokenList{"]"s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("]"s);
-  EXPECT_QUOTED_TOKEN_EQ("["s, TokenList{"["s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("["s);
-  EXPECT_QUOTED_TOKEN_EQ("'"s, TokenList{"'"s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("'"s);
-  EXPECT_QUOTED_TOKEN_EQ(
+      TokenList{"store"s, "fruit"s, "*"s, "weight"s});
+  assertValidPath(
+      "$.store.book[*].author", TokenList{"store", "book", "*", "author"});
+  assertValidPath("$.store.*", TokenList({"store", "*"}));
+
+  // Paths without leading '$'.
+  assertValidPath("foo", TokenList({"foo"}));
+  assertValidPath("foo[12].bar", TokenList({"foo", "12", "bar"}));
+  assertValidPath("foo.bar.baz", TokenList({"foo", "bar", "baz"}));
+  assertValidPath(R"(["foo"])", TokenList({"foo"}));
+  assertValidPath(R"(["foo"].bar)", TokenList({"foo", "bar"}));
+  assertValidPath(R"([0][1].foo)", TokenList({"0", "1", "foo"}));
+
+  // Paths with redundant '.'s.
+  assertValidPath("$.[0].[1].[2]", TokenList({"0", "1", "2"}));
+  assertValidPath("$[0].[1].[2]", TokenList({"0", "1", "2"}));
+  assertValidPath("$[0].[1][2]", TokenList({"0", "1", "2"}));
+  assertValidPath("$.[0].[1].foo.[2]", TokenList({"0", "1", "foo", "2"}));
+  assertValidPath("$[0].[1].foo.[2]", TokenList({"0", "1", "foo", "2"}));
+  assertValidPath("$[0][1].foo.[2]", TokenList({"0", "1", "foo", "2"}));
+
+  assertQuotedToken("!@#$%^&*()[]{}/?'"s, TokenList{"!@#$%^&*()[]{}/?'"s});
+  assertQuotedToken("ab\u0001c"s, TokenList{"ab\u0001c"s});
+  assertQuotedToken("ab\0c"s, TokenList{"ab\0c"s});
+  assertQuotedToken("ab\t\n\rc"s, TokenList{"ab\t\n\rc"s});
+  assertQuotedToken("."s, TokenList{"."s});
+  assertQuotedToken("$"s, TokenList{"$"s});
+  assertQuotedToken("]"s, TokenList{"]"s});
+  assertQuotedToken("["s, TokenList{"["s});
+  assertQuotedToken("'"s, TokenList{"'"s});
+  assertQuotedToken(
       "!@#$%^&*(){}[]<>?/|.,`~\r\n\t \0"s,
       TokenList{"!@#$%^&*(){}[]<>?/|.,`~\r\n\t \0"s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("!@#$%^&*(){}[]<>?/|.,`~\r\n\t \0"s);
-  EXPECT_QUOTED_TOKEN_EQ("a\\\\b\\\""s, TokenList{"a\\b\""s});
-  EXPECT_UNQUOTED_TOKEN_INVALID("a\\\\b\\\""s);
-  EXPECT_QUOTED_TOKEN_EQ("ab\\\"cd\\\"ef"s, TokenList{"ab\"cd\"ef"s});
+  assertQuotedToken("a\\\\b\\\""s, TokenList{"a\\b\""s});
+  assertQuotedToken("ab\\\"cd\\\"ef"s, TokenList{"ab\"cd\"ef"s});
+}
+
+TEST(JsonPathTokenizerTest, invalidPaths) {
+  JsonPathTokenizer tokenizer;
+
+  // Empty path.
+  EXPECT_FALSE(getTokens(""));
+
+  // Backslash not followed by valid escape.
+  EXPECT_FALSE(getTokens("$[\"a\\ \"]"s));
+
+  // Colon in subscript must be quoted.
+  EXPECT_FALSE(getTokens("$[foo:bar]"s));
 
-  // backslash not followed by valid escape
-  EXPECT_TOKEN_INVALID("$[\"a\\ \"]"s);
+  // Open bracket without close bracket.
+  EXPECT_FALSE(getTokens("$.store.book["));
 
-  // colon in subscript must be quoted
-  EXPECT_TOKEN_INVALID("$[foo:bar]"s);
+  // Unmatched double quote.
+  EXPECT_FALSE(getTokens(R"($["foo'])"));
 
-  EXPECT_TOKEN_INVALID("$.store.book[");
+  // Unmatched single quote.
+  EXPECT_FALSE(getTokens(R"($['foo"])"));
+
+  // Unsupported deep scan operator.
+  EXPECT_FALSE(getTokens("$..store"));
+  EXPECT_FALSE(getTokens("..store"));
+  EXPECT_FALSE(getTokens("$..[3].foo"));
+  EXPECT_FALSE(getTokens("..[3].foo"));
+
+  // Paths without leading '$'.
+  EXPECT_FALSE(getTokens(".[1].foo"));
+  EXPECT_FALSE(getTokens(".foo.bar.baz"));
 }
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/tests/SIMDJsonExtractorTest.cpp b/velox/functions/prestosql/json/tests/SIMDJsonExtractorTest.cpp
index 0cb955fcb3093..503e5cc7ddc2c 100644
--- a/velox/functions/prestosql/json/tests/SIMDJsonExtractorTest.cpp
+++ b/velox/functions/prestosql/json/tests/SIMDJsonExtractorTest.cpp
@@ -22,9 +22,18 @@
 #include "gtest/gtest.h"
 #include "velox/common/base/VeloxException.h"
 
+namespace facebook::velox::functions {
 namespace {
-using facebook::velox::VeloxUserError;
-using facebook::velox::functions::simdJsonExtract;
+
+template <typename TConsumer>
+simdjson::error_code simdJsonExtract(
+    const std::string& json,
+    const std::string& path,
+    TConsumer&& consumer) {
+  auto& extractor = SIMDJsonExtractor::getInstance(path);
+  return simdJsonExtract(
+      velox::StringView(json), extractor, std::forward<TConsumer>(consumer));
+}
 
 class SIMDJsonExtractorTest : public testing::Test {
  public:
@@ -49,11 +58,13 @@ class SIMDJsonExtractorTest : public testing::Test {
     auto consumer = [&res](auto& v) {
       SIMDJSON_ASSIGN_OR_RAISE(auto jsonStr, simdjson::to_json_string(v));
       res.emplace_back(jsonStr);
-      return true;
+      return simdjson::SUCCESS;
     };
 
-    EXPECT_TRUE(simdJsonExtract(json, path, consumer))
-        << "with json " << json << " and path " << path;
+    SCOPED_TRACE(json);
+    SCOPED_TRACE(path);
+
+    EXPECT_EQ(simdJsonExtract(json, path, consumer), simdjson::SUCCESS);
 
     if (!expected) {
       EXPECT_EQ(0, res.size());
@@ -80,7 +91,7 @@ class SIMDJsonExtractorTest : public testing::Test {
         // We expect a single value, if consumer gets called multiple times,
         // e.g. the path contains [*], return null.
         actual = std::nullopt;
-        return true;
+        return simdjson::SUCCESS;
       }
 
       resultPopulated = true;
@@ -105,10 +116,10 @@ class SIMDJsonExtractorTest : public testing::Test {
           SIMDJSON_ASSIGN_OR_RAISE(actual, simdjson::to_json_string(v));
         }
       }
-      return true;
+      return simdjson::SUCCESS;
     };
 
-    EXPECT_TRUE(simdJsonExtract(json, path, consumer))
+    EXPECT_EQ(simdJsonExtract(json, path, consumer), simdjson::SUCCESS)
         << "with json " << json << " and path " << path;
 
     EXPECT_EQ(expected, actual) << "with json " << json << " and path " << path;
@@ -419,7 +430,7 @@ TEST_F(SIMDJsonExtractorTest, fullJsonValueTest) {
 
 TEST_F(SIMDJsonExtractorTest, invalidJsonPathTest) {
   expectThrowInvalidArgument("", "");
-  expectThrowInvalidArgument("{}", "$.bar[2][-1]");
+  expectThrowInvalidArgument("{}", "$.bar[2]-1");
   expectThrowInvalidArgument("{}", "$.fuu..bar");
   expectThrowInvalidArgument("{}", "$.");
   expectThrowInvalidArgument("", "$$");
@@ -464,7 +475,7 @@ TEST_F(SIMDJsonExtractorTest, reextractJsonTest) {
   std::string ret;
   auto consumer = [&ret](auto& v) {
     SIMDJSON_ASSIGN_OR_RAISE(ret, simdjson::to_json_string(v));
-    return true;
+    return simdjson::SUCCESS;
   };
 
   simdJsonExtract(json, "$", consumer);
@@ -510,7 +521,7 @@ TEST_F(SIMDJsonExtractorTest, jsonMultipleExtractsTest) {
   std::string ret;
   auto consumer = [&ret](auto& v) {
     SIMDJSON_ASSIGN_OR_RAISE(ret, simdjson::to_json_string(v));
-    return true;
+    return simdjson::SUCCESS;
   };
 
   simdJsonExtract(json, "$.store", consumer);
@@ -523,17 +534,19 @@ TEST_F(SIMDJsonExtractorTest, jsonMultipleExtractsTest) {
 
 TEST_F(SIMDJsonExtractorTest, invalidJson) {
   // No-op consumer.
-  auto consumer = [](auto& /* unused */) { return true; };
+  auto consumer = [](auto& /* unused */) { return simdjson::SUCCESS; };
 
   // Object key is invalid.
   std::string json = "{\"foo: \"bar\"}";
-  EXPECT_FALSE(simdJsonExtract(json, "$.foo", consumer));
+  EXPECT_NE(simdJsonExtract(json, "$.foo", consumer), simdjson::SUCCESS);
   // Object value is invalid.
   json = "{\"foo\": \"bar}";
-  EXPECT_FALSE(simdJsonExtract(json, "$.foo", consumer));
+  EXPECT_NE(simdJsonExtract(json, "$.foo", consumer), simdjson::SUCCESS);
   // Value in array is invalid.
   // Inner object is invalid.
   json = "{\"foo\": [\"bar\", \"baz]}";
-  EXPECT_FALSE(simdJsonExtract(json, "$.foo[0]", consumer));
+  EXPECT_NE(simdJsonExtract(json, "$.foo[0]", consumer), simdjson::SUCCESS);
 }
+
 } // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/ArithmeticFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ArithmeticFunctionsRegistration.cpp
deleted file mode 100644
index 1812065700c9c..0000000000000
--- a/velox/functions/prestosql/registration/ArithmeticFunctionsRegistration.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/functions/Registerer.h"
-#include "velox/functions/lib/RegistrationHelpers.h"
-#include "velox/functions/prestosql/Arithmetic.h"
-#include "velox/functions/prestosql/Bitwise.h"
-#include "velox/functions/prestosql/Probability.h"
-#include "velox/functions/prestosql/Rand.h"
-
-namespace facebook::velox::functions {
-
-namespace {
-void registerSimpleFunctions(const std::string& prefix) {
-  registerBinaryFloatingPoint<PlusFunction>({prefix + "plus"});
-  registerBinaryFloatingPoint<MinusFunction>({prefix + "minus"});
-  registerBinaryFloatingPoint<MultiplyFunction>({prefix + "multiply"});
-  registerBinaryFloatingPoint<DivideFunction>({prefix + "divide"});
-  registerBinaryFloatingPoint<ModulusFunction>({prefix + "mod"});
-  registerUnaryNumeric<CeilFunction>({prefix + "ceil", prefix + "ceiling"});
-  registerUnaryNumeric<FloorFunction>({prefix + "floor"});
-  registerUnaryNumeric<AbsFunction>({prefix + "abs"});
-  registerUnaryFloatingPoint<NegateFunction>({prefix + "negate"});
-  registerFunction<RadiansFunction, double, double>({prefix + "radians"});
-  registerFunction<DegreesFunction, double, double>({prefix + "degrees"});
-  registerUnaryNumeric<RoundFunction>({prefix + "round"});
-  registerFunction<RoundFunction, int8_t, int8_t, int32_t>({prefix + "round"});
-  registerFunction<RoundFunction, int16_t, int16_t, int32_t>(
-      {prefix + "round"});
-  registerFunction<RoundFunction, int32_t, int32_t, int32_t>(
-      {prefix + "round"});
-  registerFunction<RoundFunction, int64_t, int64_t, int32_t>(
-      {prefix + "round"});
-  registerFunction<RoundFunction, double, double, int32_t>({prefix + "round"});
-  registerFunction<RoundFunction, float, float, int32_t>({prefix + "round"});
-  registerFunction<PowerFunction, double, double, double>(
-      {prefix + "power", prefix + "pow"});
-  registerFunction<PowerFunction, double, int64_t, int64_t>(
-      {prefix + "power", prefix + "pow"});
-  registerFunction<ExpFunction, double, double>({prefix + "exp"});
-  registerFunction<ClampFunction, int8_t, int8_t, int8_t, int8_t>(
-      {prefix + "clamp"});
-  registerFunction<ClampFunction, int16_t, int16_t, int16_t, int16_t>(
-      {prefix + "clamp"});
-  registerFunction<ClampFunction, int32_t, int32_t, int32_t, int32_t>(
-      {prefix + "clamp"});
-  registerFunction<ClampFunction, int64_t, int64_t, int64_t, int64_t>(
-      {prefix + "clamp"});
-  registerFunction<ClampFunction, double, double, double, double>(
-      {prefix + "clamp"});
-  registerFunction<ClampFunction, float, float, float, float>(
-      {prefix + "clamp"});
-  registerFunction<LnFunction, double, double>({prefix + "ln"});
-  registerFunction<Log2Function, double, double>({prefix + "log2"});
-  registerFunction<Log10Function, double, double>({prefix + "log10"});
-  registerFunction<CosFunction, double, double>({prefix + "cos"});
-  registerFunction<CoshFunction, double, double>({prefix + "cosh"});
-  registerFunction<AcosFunction, double, double>({prefix + "acos"});
-  registerFunction<SinFunction, double, double>({prefix + "sin"});
-  registerFunction<AsinFunction, double, double>({prefix + "asin"});
-  registerFunction<TanFunction, double, double>({prefix + "tan"});
-  registerFunction<TanhFunction, double, double>({prefix + "tanh"});
-  registerFunction<AtanFunction, double, double>({prefix + "atan"});
-  registerFunction<Atan2Function, double, double, double>({prefix + "atan2"});
-  registerFunction<SqrtFunction, double, double>({prefix + "sqrt"});
-  registerFunction<CbrtFunction, double, double>({prefix + "cbrt"});
-  registerFunction<
-      WidthBucketFunction,
-      int64_t,
-      double,
-      double,
-      double,
-      int64_t>({prefix + "width_bucket"});
-
-  registerUnaryNumeric<SignFunction>({prefix + "sign"});
-  registerFunction<InfinityFunction, double>({prefix + "infinity"});
-  registerFunction<IsFiniteFunction, bool, double>({prefix + "is_finite"});
-  registerFunction<IsInfiniteFunction, bool, double>({prefix + "is_infinite"});
-  registerFunction<IsNanFunction, bool, double>({prefix + "is_nan"});
-  registerFunction<NanFunction, double>({prefix + "nan"});
-  registerFunction<RandFunction, double>({prefix + "rand", prefix + "random"});
-  registerUnaryIntegral<RandFunction>({prefix + "rand", prefix + "random"});
-  registerFunction<FromBaseFunction, int64_t, Varchar, int64_t>(
-      {prefix + "from_base"});
-  registerFunction<ToBaseFunction, Varchar, int64_t, int64_t>(
-      {prefix + "to_base"});
-  registerFunction<PiFunction, double>({prefix + "pi"});
-  registerFunction<EulerConstantFunction, double>({prefix + "e"});
-  registerFunction<TruncateFunction, double, double>({prefix + "truncate"});
-  registerFunction<TruncateFunction, double, double, int32_t>(
-      {prefix + "truncate"});
-  registerFunction<BetaCDFFunction, double, double, double, double>(
-      {prefix + "beta_cdf"});
-  registerFunction<NormalCDFFunction, double, double, double, double>(
-      {prefix + "normal_cdf"});
-  registerFunction<BinomialCDFFunction, double, int64_t, double, int64_t>(
-      {prefix + "binomial_cdf"});
-  registerFunction<BinomialCDFFunction, double, int32_t, double, int32_t>(
-      {prefix + "binomial_cdf"});
-  registerFunction<CauchyCDFFunction, double, double, double, double>(
-      {prefix + "cauchy_cdf"});
-  registerFunction<ChiSquaredCDFFunction, double, double, double>(
-      {prefix + "chi_squared_cdf"});
-  registerFunction<InverseBetaCDFFunction, double, double, double, double>(
-      {prefix + "inverse_beta_cdf"});
-  registerFunction<FCDFFunction, double, double, double, double>(
-      {prefix + "f_cdf"});
-  registerFunction<PoissonCDFFunction, double, double, int64_t>(
-      {prefix + "poisson_cdf"});
-  registerFunction<PoissonCDFFunction, double, double, int32_t>(
-      {prefix + "poisson_cdf"});
-  registerFunction<GammaCDFFunction, double, double, double, double>(
-      {prefix + "gamma_cdf"});
-  registerFunction<LaplaceCDFFunction, double, double, double, double>(
-      {prefix + "laplace_cdf"});
-  registerFunction<
-      WilsonIntervalUpperFunction,
-      double,
-      int64_t,
-      int64_t,
-      double>({prefix + "wilson_interval_upper"});
-  registerFunction<
-      WilsonIntervalLowerFunction,
-      double,
-      int64_t,
-      int64_t,
-      double>({prefix + "wilson_interval_lower"});
-}
-
-} // namespace
-
-void registerArithmeticFunctions(const std::string& prefix = "") {
-  registerSimpleFunctions(prefix);
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_not, prefix + "not");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_add, prefix + "plus");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_sub, prefix + "minus");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_mul, prefix + "multiply");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_div, prefix + "divide");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_round, prefix + "round");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_abs, prefix + "abs");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_negate, prefix + "negate");
-}
-
-} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp b/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp
new file mode 100644
index 0000000000000..b3e2faa059481
--- /dev/null
+++ b/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/ArrayFunctions.h"
+
+namespace facebook::velox::functions {
+namespace {
+template <typename T>
+inline void registerArrayConcatFunctions(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<ArrayConcatFunction, T>,
+      Array<T>,
+      Array<T>,
+      T>({prefix + "concat"});
+  registerFunction<
+      ParameterBinder<ArrayConcatFunction, T>,
+      Array<T>,
+      T,
+      Array<T>>({prefix + "concat"});
+  registerFunction<
+      ParameterBinder<ArrayConcatFunction, T>,
+      Array<T>,
+      Variadic<Array<T>>>({prefix + "concat"});
+}
+} // namespace
+
+void registerArrayConcatFunctions(const std::string& prefix) {
+  registerArrayConcatFunctions<Generic<T1>>(prefix);
+  // Fast paths for primitives types.
+  registerArrayConcatFunctions<int8_t>(prefix);
+  registerArrayConcatFunctions<int16_t>(prefix);
+  registerArrayConcatFunctions<int32_t>(prefix);
+  registerArrayConcatFunctions<int64_t>(prefix);
+  registerArrayConcatFunctions<int128_t>(prefix);
+  registerArrayConcatFunctions<float>(prefix);
+  registerArrayConcatFunctions<double>(prefix);
+  registerArrayConcatFunctions<bool>(prefix);
+  registerArrayConcatFunctions<Varchar>(prefix);
+  registerArrayConcatFunctions<Timestamp>(prefix);
+  registerArrayConcatFunctions<Date>(prefix);
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
index cf856bed2da74..789824b90c31a 100644
--- a/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
@@ -14,13 +14,21 @@
  * limitations under the License.
  */
 
+#include <string>
+
 #include "velox/functions/Registerer.h"
+#include "velox/functions/lib/ArrayShuffle.h"
+#include "velox/functions/lib/Repeat.h"
+#include "velox/functions/lib/Slice.h"
 #include "velox/functions/prestosql/ArrayConstructor.h"
 #include "velox/functions/prestosql/ArrayFunctions.h"
 #include "velox/functions/prestosql/ArraySort.h"
 #include "velox/functions/prestosql/WidthBucketArray.h"
 
 namespace facebook::velox::functions {
+extern void registerArrayConcatFunctions(const std::string& prefix);
+extern void registerArrayNGramsFunctions(const std::string& prefix);
+
 template <typename T>
 inline void registerArrayMinMaxFunctions(const std::string& prefix) {
   registerFunction<ArrayMinFunction, T, Array<T>>({prefix + "array_min"});
@@ -49,7 +57,13 @@ inline void registerArrayCombinationsFunctions(const std::string& prefix) {
       ParameterBinder<CombinationsFunction, T>,
       Array<Array<T>>,
       Array<T>,
-      int64_t>({prefix + "combinations"});
+      int32_t>({prefix + "combinations"});
+}
+
+template <typename T>
+inline void registerArrayCumSumFunction(const std::string& prefix) {
+  registerFunction<ParameterBinder<ArrayCumSumFunction, T>, Array<T>, Array<T>>(
+      {prefix + "array_cum_sum"});
 }
 
 template <typename T>
@@ -57,7 +71,7 @@ inline void registerArrayHasDuplicatesFunctions(const std::string& prefix) {
   registerFunction<
       ParameterBinder<ArrayHasDuplicatesFunction, T>,
       bool,
-      Array<T>>({prefix + "array_has_duplicates"});
+      Array<T>>({prefix + "array_has_duplicates", prefix + "array_has_dupes"});
 }
 
 template <typename T>
@@ -83,6 +97,12 @@ inline void registerArrayTrimFunctions(const std::string& prefix) {
       {prefix + "trim_array"});
 }
 
+template <typename T>
+inline void registerArrayRemoveNullFunctions(const std::string& prefix) {
+  registerFunction<ArrayRemoveNullFunction, Array<T>, Array<T>>(
+      {prefix + "remove_nulls"});
+}
+
 template <typename T>
 inline void registerArrayUnionFunctions(const std::string& prefix) {
   registerFunction<ArrayUnionFunction, Array<T>, Array<T>, Array<T>>(
@@ -95,6 +115,12 @@ inline void registerArrayRemoveFunctions(const std::string& prefix) {
       {prefix + "array_remove"});
 }
 
+void registerInternalArrayFunctions() {
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_$internal$canonicalize, "$internal$canonicalize");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_$internal$contains, "$internal$contains");
+}
+
 void registerArrayFunctions(const std::string& prefix) {
   registerArrayConstructor(prefix + "array_constructor");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_all_match, prefix + "all_match");
@@ -108,16 +134,21 @@ void registerArrayFunctions(const std::string& prefix) {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_distinct, prefix + "array_distinct");
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_array_duplicates, prefix + "array_duplicates");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_duplicates, prefix + "array_dupes");
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_array_intersect, prefix + "array_intersect");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_contains, prefix + "contains");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_except, prefix + "array_except");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_arrays_overlap, prefix + "arrays_overlap");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_slice, prefix + "slice");
+  registerBigintSliceFunction(prefix);
   VELOX_REGISTER_VECTOR_FUNCTION(udf_zip, prefix + "zip");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_zip_with, prefix + "zip_with");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_position, prefix + "array_position");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_shuffle, prefix + "shuffle");
+  exec::registerStatefulVectorFunction(
+      prefix + "shuffle",
+      arrayShuffleSignatures(),
+      makeArrayShuffle,
+      getMetadataForArrayShuffle());
 
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_sort, prefix + "array_sort");
   VELOX_REGISTER_VECTOR_FUNCTION(
@@ -128,7 +159,8 @@ void registerArrayFunctions(const std::string& prefix) {
   });
 
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_sum, prefix + "array_sum");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_repeat, prefix + "repeat");
+  exec::registerStatefulVectorFunction(
+      prefix + "repeat", repeatSignatures(), makeRepeat, repeatMetadata());
   VELOX_REGISTER_VECTOR_FUNCTION(udf_sequence, prefix + "sequence");
 
   exec::registerStatefulVectorFunction(
@@ -147,6 +179,7 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayMinMaxFunctions<Varchar>(prefix);
   registerArrayMinMaxFunctions<Timestamp>(prefix);
   registerArrayMinMaxFunctions<Date>(prefix);
+  registerArrayMinMaxFunctions<Orderable<T1>>(prefix);
 
   registerArrayJoinFunctions<int8_t>(prefix);
   registerArrayJoinFunctions<int16_t>(prefix);
@@ -163,20 +196,8 @@ void registerArrayFunctions(const std::string& prefix) {
   registerFunction<ArrayAverageFunction, double, Array<double>>(
       {prefix + "array_average"});
 
-  registerFunction<
-      ArrayConcatFunction,
-      Array<Generic<T1>>,
-      Array<Generic<T1>>,
-      Generic<T1>>({prefix + "concat"});
-  registerFunction<
-      ArrayConcatFunction,
-      Array<Generic<T1>>,
-      Generic<T1>,
-      Array<Generic<T1>>>({prefix + "concat"});
-  registerFunction<
-      ArrayConcatFunction,
-      Array<Generic<T1>>,
-      Variadic<Array<Generic<T1>>>>({prefix + "concat"});
+  registerArrayConcatFunctions(prefix);
+  registerArrayNGramsFunctions(prefix);
 
   registerFunction<
       ArrayFlattenFunction,
@@ -200,11 +221,6 @@ void registerArrayFunctions(const std::string& prefix) {
       Array<Varchar>,
       Array<Varchar>,
       Varchar>({prefix + "array_remove"});
-  registerFunction<
-      ArrayRemoveFunction,
-      Array<Generic<T1>>,
-      Array<Generic<T1>>,
-      Generic<T1>>({prefix + "array_remove"});
 
   registerArrayTrimFunctions<int8_t>(prefix);
   registerArrayTrimFunctions<int16_t>(prefix);
@@ -217,16 +233,29 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayTrimFunctions<Timestamp>(prefix);
   registerArrayTrimFunctions<Date>(prefix);
   registerArrayTrimFunctions<Varbinary>(prefix);
+  registerArrayTrimFunctions<Generic<T1>>(prefix);
   registerFunction<
       ArrayTrimFunctionString,
       Array<Varchar>,
       Array<Varchar>,
       int64_t>({prefix + "trim_array"});
+
+  registerArrayRemoveNullFunctions<int8_t>(prefix);
+  registerArrayRemoveNullFunctions<int16_t>(prefix);
+  registerArrayRemoveNullFunctions<int32_t>(prefix);
+  registerArrayRemoveNullFunctions<int64_t>(prefix);
+  registerArrayRemoveNullFunctions<int128_t>(prefix);
+  registerArrayRemoveNullFunctions<float>(prefix);
+  registerArrayRemoveNullFunctions<double>(prefix);
+  registerArrayRemoveNullFunctions<bool>(prefix);
+  registerArrayRemoveNullFunctions<Timestamp>(prefix);
+  registerArrayRemoveNullFunctions<Date>(prefix);
+  registerArrayRemoveNullFunctions<Varbinary>(prefix);
+  registerArrayRemoveNullFunctions<Generic<T1>>(prefix);
   registerFunction<
-      ArrayTrimFunction,
-      Array<Generic<T1>>,
-      Array<Generic<T1>>,
-      int64_t>({prefix + "trim_array"});
+      ArrayRemoveNullFunctionString,
+      Array<Varchar>,
+      Array<Varchar>>({prefix + "remove_nulls"});
 
   registerArrayUnionFunctions<int8_t>(prefix);
   registerArrayUnionFunctions<int16_t>(prefix);
@@ -253,6 +282,14 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayCombinationsFunctions<Timestamp>(prefix);
   registerArrayCombinationsFunctions<Date>(prefix);
 
+  registerArrayCumSumFunction<int8_t>(prefix);
+  registerArrayCumSumFunction<int16_t>(prefix);
+  registerArrayCumSumFunction<int32_t>(prefix);
+  registerArrayCumSumFunction<int64_t>(prefix);
+  registerArrayCumSumFunction<int128_t>(prefix);
+  registerArrayCumSumFunction<float>(prefix);
+  registerArrayCumSumFunction<double>(prefix);
+
   registerArrayHasDuplicatesFunctions<int8_t>(prefix);
   registerArrayHasDuplicatesFunctions<int16_t>(prefix);
   registerArrayHasDuplicatesFunctions<int32_t>(prefix);
@@ -260,11 +297,19 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayHasDuplicatesFunctions<int128_t>(prefix);
   registerArrayHasDuplicatesFunctions<Varchar>(prefix);
 
+  registerArrayFrequencyFunctions<bool>(prefix);
+  registerArrayFrequencyFunctions<int8_t>(prefix);
+  registerArrayFrequencyFunctions<int16_t>(prefix);
+  registerArrayFrequencyFunctions<int32_t>(prefix);
   registerArrayFrequencyFunctions<int64_t>(prefix);
   registerArrayFrequencyFunctions<int128_t>(prefix);
+  registerArrayFrequencyFunctions<float>(prefix);
+  registerArrayFrequencyFunctions<double>(prefix);
+  registerArrayFrequencyFunctions<Timestamp>(prefix);
+  registerArrayFrequencyFunctions<Date>(prefix);
   registerArrayFrequencyFunctions<Varchar>(prefix);
 
   registerArrayNormalizeFunctions<float>(prefix);
   registerArrayNormalizeFunctions<double>(prefix);
 }
-}; // namespace facebook::velox::functions
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/ArrayNGramsRegistration.cpp b/velox/functions/prestosql/registration/ArrayNGramsRegistration.cpp
new file mode 100644
index 0000000000000..d31926a079a2d
--- /dev/null
+++ b/velox/functions/prestosql/registration/ArrayNGramsRegistration.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/ArrayFunctions.h"
+
+namespace facebook::velox::functions {
+namespace {
+template <typename T>
+inline void registerArrayNGramsFunctions(const std::string& prefix) {
+  registerFunction<ArrayNGramsFunction, Array<Array<T>>, Array<T>, int32_t>(
+      {prefix + "ngrams"});
+}
+
+} // namespace
+void registerArrayNGramsFunctions(const std::string& prefix) {
+  registerArrayNGramsFunctions<int8_t>(prefix);
+  registerArrayNGramsFunctions<int16_t>(prefix);
+  registerArrayNGramsFunctions<int32_t>(prefix);
+  registerArrayNGramsFunctions<int64_t>(prefix);
+  registerArrayNGramsFunctions<int128_t>(prefix);
+  registerArrayNGramsFunctions<float>(prefix);
+  registerArrayNGramsFunctions<double>(prefix);
+  registerArrayNGramsFunctions<bool>(prefix);
+  registerArrayNGramsFunctions<Timestamp>(prefix);
+  registerArrayNGramsFunctions<Date>(prefix);
+  registerArrayNGramsFunctions<Varbinary>(prefix);
+  registerArrayNGramsFunctions<Generic<T1>>(prefix);
+  registerFunction<
+      ArrayNGramsFunctionString,
+      Array<Array<Varchar>>,
+      Array<Varchar>,
+      int32_t>({prefix + "ngrams"});
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp b/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
index d70e5f11cf479..6f098ebadc51a 100644
--- a/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
@@ -45,8 +45,12 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<FromHexFunction, Varbinary, Varchar>({prefix + "from_hex"});
   registerFunction<ToBase64Function, Varchar, Varbinary>(
       {prefix + "to_base64"});
+
   registerFunction<FromBase64Function, Varbinary, Varchar>(
       {prefix + "from_base64"});
+  registerFunction<FromBase64Function, Varbinary, Varbinary>(
+      {prefix + "from_base64"});
+
   registerFunction<ToBase64UrlFunction, Varchar, Varbinary>(
       {prefix + "to_base64url"});
   registerFunction<FromBase64UrlFunction, Varbinary, Varchar>(
@@ -62,6 +66,24 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "to_big_endian_64"});
   registerFunction<ToIEEE754Bits64, Varbinary, double>(
       {prefix + "to_ieee754_64"});
+  registerFunction<FromIEEE754Bits64, double, Varbinary>(
+      {prefix + "from_ieee754_64"});
+  registerFunction<ToIEEE754Bits32, Varbinary, float>(
+      {prefix + "to_ieee754_32"});
+  registerFunction<FromIEEE754Bits32, float, Varbinary>(
+      {prefix + "from_ieee754_32"});
+  registerFunction<
+      LPadVarbinaryFunction,
+      Varbinary,
+      Varbinary,
+      int64_t,
+      Varbinary>({prefix + "lpad"});
+  registerFunction<
+      RPadVarbinaryFunction,
+      Varbinary,
+      Varbinary,
+      int64_t,
+      Varbinary>({prefix + "rpad"});
 }
 } // namespace
 
diff --git a/velox/functions/prestosql/registration/BitwiseFunctionsRegistration.cpp b/velox/functions/prestosql/registration/BitwiseFunctionsRegistration.cpp
index 0503ea5a80ff0..be58b9e825154 100644
--- a/velox/functions/prestosql/registration/BitwiseFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/BitwiseFunctionsRegistration.cpp
@@ -34,6 +34,14 @@ void registerBitwiseUnaryIntegral(const std::vector<std::string>& aliases) {
   registerFunction<T, int64_t, int32_t>(aliases);
   registerFunction<T, int64_t, int64_t>(aliases);
 }
+
+template <template <class> class T>
+void registerShift(const std::vector<std::string>& aliases) {
+  registerFunction<T, int8_t, int8_t, int32_t>(aliases);
+  registerFunction<T, int16_t, int16_t, int32_t>(aliases);
+  registerFunction<T, int32_t, int32_t, int32_t>(aliases);
+  registerFunction<T, int64_t, int64_t, int32_t>(aliases);
+}
 } // namespace
 
 void registerBitwiseFunctions(const std::string& prefix) {
@@ -47,11 +55,9 @@ void registerBitwiseFunctions(const std::string& prefix) {
       int64_t,
       int64_t,
       int64_t>({prefix + "bitwise_arithmetic_shift_right"});
-  registerBitwiseBinaryIntegral<BitwiseLeftShiftFunction>(
-      {prefix + "bitwise_left_shift"});
-  registerBitwiseBinaryIntegral<BitwiseRightShiftFunction>(
-      {prefix + "bitwise_right_shift"});
-  registerBitwiseBinaryIntegral<BitwiseRightShiftArithmeticFunction>(
+  registerShift<BitwiseLeftShiftFunction>({prefix + "bitwise_left_shift"});
+  registerShift<BitwiseRightShiftFunction>({prefix + "bitwise_right_shift"});
+  registerShift<BitwiseRightShiftArithmeticFunction>(
       {prefix + "bitwise_right_shift_arithmetic"});
   registerFunction<
       BitwiseLogicalShiftRightFunction,
diff --git a/velox/functions/prestosql/registration/CMakeLists.txt b/velox/functions/prestosql/registration/CMakeLists.txt
index 0abaa95221b80..1e477d5475061 100644
--- a/velox/functions/prestosql/registration/CMakeLists.txt
+++ b/velox/functions/prestosql/registration/CMakeLists.txt
@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+velox_add_library(
   velox_functions_prestosql
-  ArithmeticFunctionsRegistration.cpp
+  ArrayConcatRegistration.cpp
   ArrayFunctionsRegistration.cpp
+  ArrayNGramsRegistration.cpp
   BinaryFunctionsRegistration.cpp
+  BitwiseFunctionsRegistration.cpp
   CheckedArithmeticRegistration.cpp
   ComparisonFunctionsRegistration.cpp
   DateTimeFunctionsRegistration.cpp
@@ -24,21 +26,25 @@ add_library(
   HyperLogFunctionsRegistration.cpp
   JsonFunctionsRegistration.cpp
   MapFunctionsRegistration.cpp
+  MathematicalFunctionsRegistration.cpp
+  MathematicalOperatorsRegistration.cpp
+  ProbabilityTrigonometricFunctionsRegistration.cpp
+  RegistrationFunctions.cpp
   StringFunctionsRegistration.cpp
-  BitwiseFunctionsRegistration.cpp
-  URLFunctionsRegistration.cpp
-  RegistrationFunctions.cpp)
+  URLFunctionsRegistration.cpp)
 
 # GCC 12 has a bug where it does not respect "pragma ignore" directives and ends
 # up failing compilation in an openssl header included by a hash-related
 # function.
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT VELOX_MONO_LIBRARY)
   target_compile_options(velox_functions_prestosql
                          PRIVATE -Wno-deprecated-declarations)
 endif()
 
-target_link_libraries(velox_functions_prestosql velox_functions_prestosql_impl
-                      velox_is_null_functions simdjson::simdjson)
+velox_link_libraries(velox_functions_prestosql velox_functions_prestosql_impl
+                     velox_is_null_functions simdjson::simdjson)
 
-set_property(TARGET velox_functions_prestosql PROPERTY JOB_POOL_COMPILE
-                                                       high_memory_pool)
+if(NOT VELOX_MONO_LIBRARY)
+  set_property(TARGET velox_functions_prestosql PROPERTY JOB_POOL_COMPILE
+                                                         high_memory_pool)
+endif()
diff --git a/velox/functions/prestosql/registration/CheckedArithmeticRegistration.cpp b/velox/functions/prestosql/registration/CheckedArithmeticRegistration.cpp
index a1e9a639ce615..b71931459d460 100644
--- a/velox/functions/prestosql/registration/CheckedArithmeticRegistration.cpp
+++ b/velox/functions/prestosql/registration/CheckedArithmeticRegistration.cpp
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
+#include "velox/functions/lib/CheckedArithmetic.h"
 #include "velox/functions/lib/RegistrationHelpers.h"
-#include "velox/functions/prestosql/CheckedArithmetic.h"
 
 namespace facebook::velox::functions {
 
diff --git a/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
index 8c42a97293dd1..d44d289e38262 100644
--- a/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
@@ -19,6 +19,16 @@
 #include "velox/type/Type.h"
 
 namespace facebook::velox::functions {
+namespace {
+
+template <template <class> class T, typename TReturn>
+void registerNonSimdizableScalar(const std::vector<std::string>& aliases) {
+  registerFunction<T, TReturn, Varchar, Varchar>(aliases);
+  registerFunction<T, TReturn, Varbinary, Varbinary>(aliases);
+  registerFunction<T, TReturn, bool, bool>(aliases);
+  registerFunction<T, TReturn, Timestamp, Timestamp>(aliases);
+}
+} // namespace
 
 void registerComparisonFunctions(const std::string& prefix) {
   // Comparison functions also need TimestampWithTimezoneType,
@@ -28,25 +38,56 @@ void registerComparisonFunctions(const std::string& prefix) {
   registerNonSimdizableScalar<EqFunction, bool>({prefix + "eq"});
   VELOX_REGISTER_VECTOR_FUNCTION(udf_simd_comparison_eq, prefix + "eq");
   registerFunction<EqFunction, bool, Generic<T1>, Generic<T1>>({prefix + "eq"});
+  registerFunction<
+      EqFunctionTimestampWithTimezone,
+      bool,
+      TimestampWithTimezone,
+      TimestampWithTimezone>({prefix + "eq"});
 
   registerNonSimdizableScalar<NeqFunction, bool>({prefix + "neq"});
   VELOX_REGISTER_VECTOR_FUNCTION(udf_simd_comparison_neq, prefix + "neq");
   registerFunction<NeqFunction, bool, Generic<T1>, Generic<T1>>(
       {prefix + "neq"});
+  registerFunction<
+      NeqFunctionTimestampWithTimezone,
+      bool,
+      TimestampWithTimezone,
+      TimestampWithTimezone>({prefix + "neq"});
 
   registerNonSimdizableScalar<LtFunction, bool>({prefix + "lt"});
+  registerFunction<
+      LtFunctionTimestampWithTimezone,
+      bool,
+      TimestampWithTimezone,
+      TimestampWithTimezone>({prefix + "lt"});
   VELOX_REGISTER_VECTOR_FUNCTION(udf_simd_comparison_lt, prefix + "lt");
 
   registerNonSimdizableScalar<GtFunction, bool>({prefix + "gt"});
+  registerFunction<
+      GtFunctionTimestampWithTimezone,
+      bool,
+      TimestampWithTimezone,
+      TimestampWithTimezone>({prefix + "gt"});
   VELOX_REGISTER_VECTOR_FUNCTION(udf_simd_comparison_gt, prefix + "gt");
 
   registerNonSimdizableScalar<LteFunction, bool>({prefix + "lte"});
+  registerFunction<
+      LteFunctionTimestampWithTimezone,
+      bool,
+      TimestampWithTimezone,
+      TimestampWithTimezone>({prefix + "lte"});
   VELOX_REGISTER_VECTOR_FUNCTION(udf_simd_comparison_lte, prefix + "lte");
 
   registerNonSimdizableScalar<GteFunction, bool>({prefix + "gte"});
+  registerFunction<
+      GteFunctionTimestampWithTimezone,
+      bool,
+      TimestampWithTimezone,
+      TimestampWithTimezone>({prefix + "gte"});
   VELOX_REGISTER_VECTOR_FUNCTION(udf_simd_comparison_gte, prefix + "gte");
 
-  registerBinaryScalar<DistinctFromFunction, bool>({prefix + "distinct_from"});
+  registerFunction<DistinctFromFunction, bool, Generic<T1>, Generic<T1>>(
+      {prefix + "distinct_from"});
 
   registerFunction<BetweenFunction, bool, int8_t, int8_t, int8_t>(
       {prefix + "between"});
@@ -66,8 +107,36 @@ void registerComparisonFunctions(const std::string& prefix) {
       {prefix + "between"});
   registerFunction<BetweenFunction, bool, Timestamp, Timestamp, Timestamp>(
       {prefix + "between"});
-
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_between, prefix + "between");
+  registerFunction<
+      BetweenFunction,
+      bool,
+      LongDecimal<P1, S1>,
+      LongDecimal<P1, S1>,
+      LongDecimal<P1, S1>>({prefix + "between"});
+  registerFunction<
+      BetweenFunction,
+      bool,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P1, S1>>({prefix + "between"});
+  registerFunction<
+      BetweenFunction,
+      bool,
+      IntervalDayTime,
+      IntervalDayTime,
+      IntervalDayTime>({prefix + "between"});
+  registerFunction<
+      BetweenFunction,
+      bool,
+      IntervalYearMonth,
+      IntervalYearMonth,
+      IntervalYearMonth>({prefix + "between"});
+  registerFunction<
+      BetweenFunctionTimestampWithTimezone,
+      bool,
+      TimestampWithTimezone,
+      TimestampWithTimezone,
+      TimestampWithTimezone>({prefix + "between"});
 }
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp b/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
index c6dcfecb71d75..4af078b6d3b3b 100644
--- a/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
@@ -20,14 +20,76 @@
 
 namespace facebook::velox::functions {
 namespace {
+
+// Register timestamp + interval and interval + timestamp
+// functions for specified TTimestamp type and 2 supported interval types
+// (IntervalDayTime and IntervalYearMonth).
+// @tparam TTimestamp Timestamp or TimestampWithTimezone.
+template <typename TTimestamp>
+void registerTimestampPlusInterval(const std::string& name) {
+  registerFunction<
+      TimestampPlusInterval,
+      TTimestamp,
+      TTimestamp,
+      IntervalDayTime>({name});
+  registerFunction<
+      TimestampPlusInterval,
+      TTimestamp,
+      TTimestamp,
+      IntervalYearMonth>({name});
+  registerFunction<
+      IntervalPlusTimestamp,
+      TTimestamp,
+      IntervalDayTime,
+      TTimestamp>({name});
+  registerFunction<
+      IntervalPlusTimestamp,
+      TTimestamp,
+      IntervalYearMonth,
+      TTimestamp>({name});
+}
+
+// Register timestamp - IntervalYearMonth and timestamp - IntervalDayTime
+// functions for specified TTimestamp type.
+// @tparam TTimestamp Timestamp or TimestampWithTimezone.
+template <typename TTimestamp>
+void registerTimestampMinusInterval(const std::string& name) {
+  registerFunction<
+      TimestampMinusInterval,
+      TTimestamp,
+      TTimestamp,
+      IntervalDayTime>({name});
+  registerFunction<
+      TimestampMinusInterval,
+      TTimestamp,
+      TTimestamp,
+      IntervalYearMonth>({name});
+}
+
+void registerFromUnixtime(const std::string& name) {
+  registerFunction<FromUnixtimeFunction, Timestamp, double>({name});
+  registerFunction<
+      FromUnixtimeFunction,
+      TimestampWithTimezone,
+      double,
+      Varchar>({name});
+  registerFunction<
+      FromUnixtimeFunction,
+      TimestampWithTimezone,
+      double,
+      int64_t,
+      int64_t>({name});
+}
+
 void registerSimpleFunctions(const std::string& prefix) {
   // Date time functions.
   registerFunction<ToUnixtimeFunction, double, Timestamp>(
       {prefix + "to_unixtime"});
   registerFunction<ToUnixtimeFunction, double, TimestampWithTimezone>(
       {prefix + "to_unixtime"});
-  registerFunction<FromUnixtimeFunction, Timestamp, double>(
-      {prefix + "from_unixtime"});
+
+  registerFromUnixtime(prefix + "from_unixtime");
+
   registerFunction<DateFunction, Date, Varchar>({prefix + "date"});
   registerFunction<DateFunction, Date, Timestamp>({prefix + "date"});
   registerFunction<DateFunction, Date, TimestampWithTimezone>(
@@ -37,10 +99,14 @@ void registerSimpleFunctions(const std::string& prefix) {
 
   registerFunction<TimeZoneMinuteFunction, int64_t, TimestampWithTimezone>(
       {prefix + "timezone_minute"});
+
   registerFunction<YearFunction, int64_t, Timestamp>({prefix + "year"});
   registerFunction<YearFunction, int64_t, Date>({prefix + "year"});
   registerFunction<YearFunction, int64_t, TimestampWithTimezone>(
       {prefix + "year"});
+  registerFunction<YearFromIntervalFunction, int64_t, IntervalYearMonth>(
+      {prefix + "year"});
+
   registerFunction<WeekFunction, int64_t, Timestamp>(
       {prefix + "week", prefix + "week_of_year"});
   registerFunction<WeekFunction, int64_t, Date>(
@@ -51,23 +117,47 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<QuarterFunction, int64_t, Date>({prefix + "quarter"});
   registerFunction<QuarterFunction, int64_t, TimestampWithTimezone>(
       {prefix + "quarter"});
+
   registerFunction<MonthFunction, int64_t, Timestamp>({prefix + "month"});
   registerFunction<MonthFunction, int64_t, Date>({prefix + "month"});
   registerFunction<MonthFunction, int64_t, TimestampWithTimezone>(
       {prefix + "month"});
+  registerFunction<MonthFromIntervalFunction, int64_t, IntervalYearMonth>(
+      {prefix + "month"});
+
   registerFunction<DayFunction, int64_t, Timestamp>(
       {prefix + "day", prefix + "day_of_month"});
   registerFunction<DayFunction, int64_t, Date>(
       {prefix + "day", prefix + "day_of_month"});
-  registerFunction<DateMinusIntervalDayTime, Date, Date, IntervalDayTime>(
+  registerFunction<DayFromIntervalFunction, int64_t, IntervalDayTime>(
+      {prefix + "day", prefix + "day_of_month"});
+
+  registerFunction<DateMinusInterval, Date, Date, IntervalDayTime>(
       {prefix + "minus"});
-  registerFunction<DatePlusIntervalDayTime, Date, Date, IntervalDayTime>(
+  registerFunction<DateMinusInterval, Date, Date, IntervalYearMonth>(
+      {prefix + "minus"});
+  registerFunction<DatePlusInterval, Date, Date, IntervalDayTime>(
+      {prefix + "plus"});
+  registerFunction<DatePlusInterval, Date, Date, IntervalYearMonth>(
       {prefix + "plus"});
+
+  registerTimestampPlusInterval<Timestamp>({prefix + "plus"});
+  registerTimestampMinusInterval<Timestamp>({prefix + "minus"});
+  registerTimestampPlusInterval<TimestampWithTimezone>({prefix + "plus"});
+  registerTimestampMinusInterval<TimestampWithTimezone>({prefix + "minus"});
+
   registerFunction<
-      TimestampMinusIntervalDayTime,
+      TimestampMinusFunction,
       IntervalDayTime,
       Timestamp,
       Timestamp>({prefix + "minus"});
+
+  registerFunction<
+      TimestampMinusFunction,
+      IntervalDayTime,
+      TimestampWithTimezone,
+      TimestampWithTimezone>({prefix + "minus"});
+
   registerFunction<DayFunction, int64_t, TimestampWithTimezone>(
       {prefix + "day", prefix + "day_of_month"});
   registerFunction<DayOfWeekFunction, int64_t, Timestamp>(
@@ -88,30 +178,44 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "yow", prefix + "year_of_week"});
   registerFunction<YearOfWeekFunction, int64_t, TimestampWithTimezone>(
       {prefix + "yow", prefix + "year_of_week"});
+
   registerFunction<HourFunction, int64_t, Timestamp>({prefix + "hour"});
   registerFunction<HourFunction, int64_t, Date>({prefix + "hour"});
   registerFunction<HourFunction, int64_t, TimestampWithTimezone>(
       {prefix + "hour"});
+  registerFunction<HourFromIntervalFunction, int64_t, IntervalDayTime>(
+      {prefix + "hour"});
+
   registerFunction<LastDayOfMonthFunction, Date, Timestamp>(
       {prefix + "last_day_of_month"});
   registerFunction<LastDayOfMonthFunction, Date, Date>(
       {prefix + "last_day_of_month"});
   registerFunction<LastDayOfMonthFunction, Date, TimestampWithTimezone>(
       {prefix + "last_day_of_month"});
+
   registerFunction<MinuteFunction, int64_t, Timestamp>({prefix + "minute"});
   registerFunction<MinuteFunction, int64_t, Date>({prefix + "minute"});
   registerFunction<MinuteFunction, int64_t, TimestampWithTimezone>(
       {prefix + "minute"});
+  registerFunction<MinuteFromIntervalFunction, int64_t, IntervalDayTime>(
+      {prefix + "minute"});
+
   registerFunction<SecondFunction, int64_t, Timestamp>({prefix + "second"});
   registerFunction<SecondFunction, int64_t, Date>({prefix + "second"});
   registerFunction<SecondFunction, int64_t, TimestampWithTimezone>(
       {prefix + "second"});
+  registerFunction<SecondFromIntervalFunction, int64_t, IntervalDayTime>(
+      {prefix + "second"});
+
   registerFunction<MillisecondFunction, int64_t, Timestamp>(
       {prefix + "millisecond"});
   registerFunction<MillisecondFunction, int64_t, Date>(
       {prefix + "millisecond"});
   registerFunction<MillisecondFunction, int64_t, TimestampWithTimezone>(
       {prefix + "millisecond"});
+  registerFunction<MillisecondFromIntervalFunction, int64_t, IntervalDayTime>(
+      {prefix + "millisecond"});
+
   registerFunction<DateTruncFunction, Timestamp, Varchar, Timestamp>(
       {prefix + "date_trunc"});
   registerFunction<DateTruncFunction, Date, Varchar, Date>(
@@ -147,6 +251,11 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "date_format"});
   registerFunction<FormatDateTimeFunction, Varchar, Timestamp, Varchar>(
       {prefix + "format_datetime"});
+  registerFunction<
+      FormatDateTimeFunction,
+      Varchar,
+      TimestampWithTimezone,
+      Varchar>({prefix + "format_datetime"});
   registerFunction<
       ParseDateTimeFunction,
       TimestampWithTimezone,
@@ -154,7 +263,26 @@ void registerSimpleFunctions(const std::string& prefix) {
       Varchar>({prefix + "parse_datetime"});
   registerFunction<DateParseFunction, Timestamp, Varchar, Varchar>(
       {prefix + "date_parse"});
+  registerFunction<FromIso8601Date, Date, Varchar>(
+      {prefix + "from_iso8601_date"});
+  registerFunction<FromIso8601Timestamp, TimestampWithTimezone, Varchar>(
+      {prefix + "from_iso8601_timestamp"});
   registerFunction<CurrentDateFunction, Date>({prefix + "current_date"});
+
+  registerFunction<ToISO8601Function, Varchar, Date>({prefix + "to_iso8601"});
+  registerFunction<ToISO8601Function, Varchar, Timestamp>(
+      {prefix + "to_iso8601"});
+  registerFunction<ToISO8601Function, Varchar, TimestampWithTimezone>(
+      {prefix + "to_iso8601"});
+
+  registerFunction<
+      AtTimezoneFunction,
+      TimestampWithTimezone,
+      TimestampWithTimezone,
+      Varchar>({prefix + "at_timezone"});
+
+  registerFunction<ToMillisecondFunction, int64_t, IntervalDayTime>(
+      {prefix + "to_milliseconds"});
 }
 } // namespace
 
@@ -162,6 +290,5 @@ void registerDateTimeFunctions(const std::string& prefix) {
   registerTimestampWithTimeZoneType();
 
   registerSimpleFunctions(prefix);
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_from_unixtime, prefix + "from_unixtime");
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp b/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
index 4dfe6a8082a52..bb154865e672a 100644
--- a/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
@@ -17,32 +17,98 @@
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/IsNull.h"
 #include "velox/functions/prestosql/Cardinality.h"
+#include "velox/functions/prestosql/Fail.h"
+#include "velox/functions/prestosql/GreatestLeast.h"
+#include "velox/functions/prestosql/InPredicate.h"
+#include "velox/functions/prestosql/Reduce.h"
 
 namespace facebook::velox::functions {
 
+namespace {
+
+void registerFailFunction(const std::vector<std::string>& names) {
+  registerFunction<FailFunction, UnknownValue, Varchar>(names);
+  registerFunction<FailFunction, UnknownValue, int32_t, Varchar>(names);
+  registerFunction<FailFromJsonFunction, UnknownValue, Json>(names);
+  registerFunction<FailFromJsonFunction, UnknownValue, int32_t, Json>(names);
+}
+
+template <typename T>
+void registerGreatestLeastFunction(const std::string& prefix) {
+  registerFunction<ParameterBinder<GreatestFunction, T>, T, T, Variadic<T>>(
+      {prefix + "greatest"});
+
+  registerFunction<ParameterBinder<LeastFunction, T>, T, T, Variadic<T>>(
+      {prefix + "least"});
+}
+
+void registerAllGreatestLeastFunctions(const std::string& prefix) {
+  registerGreatestLeastFunction<bool>(prefix);
+  registerGreatestLeastFunction<int8_t>(prefix);
+  registerGreatestLeastFunction<int16_t>(prefix);
+  registerGreatestLeastFunction<int32_t>(prefix);
+  registerGreatestLeastFunction<int64_t>(prefix);
+  registerGreatestLeastFunction<float>(prefix);
+  registerGreatestLeastFunction<double>(prefix);
+  registerGreatestLeastFunction<Varchar>(prefix);
+  registerGreatestLeastFunction<LongDecimal<P1, S1>>(prefix);
+  registerGreatestLeastFunction<ShortDecimal<P1, S1>>(prefix);
+  registerGreatestLeastFunction<Date>(prefix);
+  registerGreatestLeastFunction<Timestamp>(prefix);
+
+  registerFunction<
+      GreatestFunctionTimestampWithTimezone,
+      TimestampWithTimezone,
+      TimestampWithTimezone,
+      Variadic<TimestampWithTimezone>>({prefix + "greatest"});
+
+  registerFunction<
+      LeastFunctionTimestampWithTimezone,
+      TimestampWithTimezone,
+      TimestampWithTimezone,
+      Variadic<TimestampWithTimezone>>({prefix + "least"});
+}
+} // namespace
+
+extern void registerSubscriptFunction(
+    const std::string& name,
+    bool enableCaching);
+extern void registerElementAtFunction(
+    const std::string& name,
+    bool enableCaching);
+
 // Special form functions don't have any prefix.
 void registerAllSpecialFormGeneralFunctions() {
   exec::registerFunctionCallToSpecialForms();
   VELOX_REGISTER_VECTOR_FUNCTION(udf_in, "in");
+  registerFunction<
+      GenericInPredicateFunction,
+      bool,
+      Generic<T1>,
+      Variadic<Generic<T1>>>({"in"});
   VELOX_REGISTER_VECTOR_FUNCTION(udf_concat_row, "row_constructor");
   registerIsNullFunction("is_null");
 }
 
 void registerGeneralFunctions(const std::string& prefix) {
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_element_at, prefix + "element_at");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_subscript, prefix + "subscript");
+  registerSubscriptFunction(prefix + "subscript", true);
+  registerElementAtFunction(prefix + "element_at", true);
+
   VELOX_REGISTER_VECTOR_FUNCTION(udf_transform, prefix + "transform");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_reduce, prefix + "reduce");
+  registerReduceRewrites(prefix);
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_filter, prefix + "filter");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_typeof, prefix + "typeof");
 
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_least, prefix + "least");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_greatest, prefix + "greatest");
+  registerAllGreatestLeastFunctions(prefix);
 
-  registerFunction<CardinalityFunction, int64_t, Array<Any>>(
+  registerFunction<CardinalityFunction, int64_t, Array<Generic<T1>>>(
       {prefix + "cardinality"});
-  registerFunction<CardinalityFunction, int64_t, Map<Any, Any>>(
+  registerFunction<CardinalityFunction, int64_t, Map<Generic<T1>, Generic<T2>>>(
       {prefix + "cardinality"});
 
+  registerFailFunction({prefix + "fail"});
+
   registerAllSpecialFormGeneralFunctions();
 }
 
diff --git a/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp b/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
index 1ef95ede2f60b..ae30723fbfce2 100644
--- a/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
@@ -24,8 +24,10 @@ void registerHyperLogFunctions(const std::string& prefix) {
   registerFunction<CardinalityFunction, int64_t, HyperLogLog>(
       {prefix + "cardinality"});
 
-  registerFunction<EmptyApproxSetWithMaxErrorFunction, HyperLogLog, double>(
-      {prefix + "empty_approx_set"});
+  registerFunction<
+      EmptyApproxSetWithMaxErrorFunction,
+      HyperLogLog,
+      Constant<double>>({prefix + "empty_approx_set"});
   registerFunction<EmptyApproxSetFunction, HyperLogLog>(
       {prefix + "empty_approx_set"});
 }
diff --git a/velox/functions/prestosql/registration/JsonFunctionsRegistration.cpp b/velox/functions/prestosql/registration/JsonFunctionsRegistration.cpp
index 763588418833c..e9f2073224fec 100644
--- a/velox/functions/prestosql/registration/JsonFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/JsonFunctionsRegistration.cpp
@@ -16,52 +16,56 @@
 
 #include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/JsonFunctions.h"
-#include "velox/functions/prestosql/SIMDJsonFunctions.h"
 
 namespace facebook::velox::functions {
 void registerJsonFunctions(const std::string& prefix) {
   registerJsonType();
 
-  registerFunction<SIMDIsJsonScalarFunction, bool, Json>(
+  registerFunction<IsJsonScalarFunction, bool, Json>(
       {prefix + "is_json_scalar"});
-  registerFunction<SIMDIsJsonScalarFunction, bool, Varchar>(
+  registerFunction<IsJsonScalarFunction, bool, Varchar>(
       {prefix + "is_json_scalar"});
 
-  registerFunction<SIMDJsonExtractScalarFunction, Varchar, Json, Varchar>(
+  registerFunction<JsonExtractScalarFunction, Varchar, Json, Varchar>(
       {prefix + "json_extract_scalar"});
-  registerFunction<SIMDJsonExtractScalarFunction, Varchar, Varchar, Varchar>(
+  registerFunction<JsonExtractScalarFunction, Varchar, Varchar, Varchar>(
       {prefix + "json_extract_scalar"});
 
-  registerFunction<SIMDJsonExtractFunction, Json, Json, Varchar>(
+  registerFunction<JsonExtractFunction, Json, Json, Varchar>(
       {prefix + "json_extract"});
-  registerFunction<SIMDJsonExtractFunction, Json, Varchar, Varchar>(
+  registerFunction<JsonExtractFunction, Json, Varchar, Varchar>(
       {prefix + "json_extract"});
 
-  registerFunction<SIMDJsonArrayLengthFunction, int64_t, Json>(
+  registerFunction<JsonArrayLengthFunction, int64_t, Json>(
       {prefix + "json_array_length"});
-  registerFunction<SIMDJsonArrayLengthFunction, int64_t, Varchar>(
+  registerFunction<JsonArrayLengthFunction, int64_t, Varchar>(
       {prefix + "json_array_length"});
 
-  registerFunction<SIMDJsonArrayContainsFunction, bool, Json, bool>(
+  registerFunction<JsonArrayContainsFunction, bool, Json, bool>(
       {prefix + "json_array_contains"});
-  registerFunction<SIMDJsonArrayContainsFunction, bool, Varchar, bool>(
+  registerFunction<JsonArrayContainsFunction, bool, Varchar, bool>(
       {prefix + "json_array_contains"});
-  registerFunction<SIMDJsonArrayContainsFunction, bool, Json, int64_t>(
+  registerFunction<JsonArrayContainsFunction, bool, Json, int64_t>(
       {prefix + "json_array_contains"});
-  registerFunction<SIMDJsonArrayContainsFunction, bool, Varchar, int64_t>(
+  registerFunction<JsonArrayContainsFunction, bool, Varchar, int64_t>(
       {prefix + "json_array_contains"});
-  registerFunction<SIMDJsonArrayContainsFunction, bool, Json, double>(
+  registerFunction<JsonArrayContainsFunction, bool, Json, double>(
       {prefix + "json_array_contains"});
-  registerFunction<SIMDJsonArrayContainsFunction, bool, Varchar, double>(
+  registerFunction<JsonArrayContainsFunction, bool, Varchar, double>(
       {prefix + "json_array_contains"});
-  registerFunction<SIMDJsonArrayContainsFunction, bool, Json, Varchar>(
+  registerFunction<JsonArrayContainsFunction, bool, Json, Varchar>(
       {prefix + "json_array_contains"});
-  registerFunction<SIMDJsonArrayContainsFunction, bool, Varchar, Varchar>(
+  registerFunction<JsonArrayContainsFunction, bool, Varchar, Varchar>(
       {prefix + "json_array_contains"});
 
-  registerFunction<SIMDJsonSizeFunction, int64_t, Json, Varchar>(
+  registerFunction<JsonArrayGetFunction, Json, Json, int64_t>(
+      {prefix + "json_array_get"});
+  registerFunction<JsonArrayGetFunction, Json, Varchar, int64_t>(
+      {prefix + "json_array_get"});
+
+  registerFunction<JsonSizeFunction, int64_t, Json, Varchar>(
       {prefix + "json_size"});
-  registerFunction<SIMDJsonSizeFunction, int64_t, Varchar, Varchar>(
+  registerFunction<JsonSizeFunction, int64_t, Varchar, Varchar>(
       {prefix + "json_size"});
 
   VELOX_REGISTER_VECTOR_FUNCTION(udf_json_format, prefix + "json_format");
diff --git a/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp b/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
index e837661ea0780..62a4081b6be17 100644
--- a/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
@@ -17,14 +17,66 @@
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/MapConcat.h"
+#include "velox/functions/prestosql/Map.h"
+#include "velox/functions/prestosql/MapNormalize.h"
+#include "velox/functions/prestosql/MapRemoveNullValues.h"
+#include "velox/functions/prestosql/MapSubset.h"
+#include "velox/functions/prestosql/MapTopN.h"
+#include "velox/functions/prestosql/MapTopNKeys.h"
+#include "velox/functions/prestosql/MultimapFromEntries.h"
 
 namespace facebook::velox::functions {
+
+namespace {
+
+template <typename T>
+void registerMapSubsetPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<MapSubsetPrimitiveFunction, T>,
+      Map<T, Generic<T1>>,
+      Map<T, Generic<T1>>,
+      Array<T>>({prefix + "map_subset"});
+}
+
+void registerMapSubset(const std::string& prefix) {
+  registerMapSubsetPrimitive<bool>(prefix);
+  registerMapSubsetPrimitive<int8_t>(prefix);
+  registerMapSubsetPrimitive<int16_t>(prefix);
+  registerMapSubsetPrimitive<int32_t>(prefix);
+  registerMapSubsetPrimitive<int64_t>(prefix);
+  registerMapSubsetPrimitive<float>(prefix);
+  registerMapSubsetPrimitive<double>(prefix);
+  registerMapSubsetPrimitive<Timestamp>(prefix);
+  registerMapSubsetPrimitive<Date>(prefix);
+
+  registerFunction<
+      MapSubsetVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>>({prefix + "map_subset"});
+
+  registerFunction<
+      MapSubsetFunction,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>>({prefix + "map_subset"});
+}
+
+void registerMapRemoveNullValues(const std::string& prefix) {
+  registerFunction<
+      MapRemoveNullValues,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>>({prefix + "map_remove_null_values"});
+}
+
+} // namespace
+
 void registerMapFunctions(const std::string& prefix) {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_map_filter, prefix + "map_filter");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_transform_keys, prefix + "transform_keys");
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_transform_values, prefix + "transform_values");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_map, prefix + "map");
+  registerMapFunction(prefix + "map", false /*allowDuplicateKeys*/);
   VELOX_REGISTER_VECTOR_FUNCTION(udf_map_entries, prefix + "map_entries");
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_map_from_entries, prefix + "map_from_entries");
@@ -42,6 +94,32 @@ void registerMapFunctions(const std::string& prefix) {
       udf_no_values_match, prefix + "no_values_match");
 
   registerMapConcatFunction(prefix + "map_concat");
+
+  registerFunction<
+      MultimapFromEntriesFunction,
+      Map<Generic<T1>, Array<Generic<T2>>>,
+      Array<Row<Generic<T1>, Generic<T2>>>>({prefix + "multimap_from_entries"});
+
+  registerFunction<
+      MapTopNFunction,
+      Map<Orderable<T1>, Orderable<T2>>,
+      Map<Orderable<T1>, Orderable<T2>>,
+      int64_t>({prefix + "map_top_n"});
+
+  registerFunction<
+      MapTopNKeysFunction,
+      Array<Orderable<T1>>,
+      Map<Orderable<T1>, Orderable<T2>>,
+      int64_t>({prefix + "map_top_n_keys"});
+
+  registerMapSubset(prefix);
+
+  registerMapRemoveNullValues(prefix);
+
+  registerFunction<
+      MapNormalizeFunction,
+      Map<Varchar, double>,
+      Map<Varchar, double>>({prefix + "map_normalize"});
 }
 
 void registerMapAllowingDuplicates(
diff --git a/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp b/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp
new file mode 100644
index 0000000000000..0a13a7824f66a
--- /dev/null
+++ b/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/Registerer.h"
+#include "velox/functions/lib/RegistrationHelpers.h"
+#include "velox/functions/prestosql/Arithmetic.h"
+#include "velox/functions/prestosql/DecimalFunctions.h"
+#include "velox/functions/prestosql/Rand.h"
+
+namespace facebook::velox::functions {
+
+namespace {
+
+void registerTruncate(const std::vector<std::string>& names) {
+  registerFunction<TruncateFunction, double, double>(names);
+  registerFunction<TruncateFunction, float, float>(names);
+  registerFunction<TruncateFunction, double, double, int32_t>(names);
+  registerFunction<TruncateFunction, float, float, int32_t>(names);
+}
+
+void registerMathFunctions(const std::string& prefix) {
+  registerUnaryNumeric<CeilFunction>({prefix + "ceil", prefix + "ceiling"});
+  registerUnaryNumeric<FloorFunction>({prefix + "floor"});
+
+  registerUnaryNumeric<AbsFunction>({prefix + "abs"});
+  registerFunction<
+      DecimalAbsFunction,
+      LongDecimal<P1, S1>,
+      LongDecimal<P1, S1>>({prefix + "abs"});
+  registerFunction<
+      DecimalAbsFunction,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P1, S1>>({prefix + "abs"});
+
+  registerUnaryFloatingPoint<NegateFunction>({prefix + "negate"});
+  registerFunction<NegateFunction, LongDecimal<P1, S1>, LongDecimal<P1, S1>>(
+      {prefix + "negate"});
+  registerFunction<NegateFunction, ShortDecimal<P1, S1>, ShortDecimal<P1, S1>>(
+      {prefix + "negate"});
+
+  registerFunction<RadiansFunction, double, double>({prefix + "radians"});
+  registerFunction<DegreesFunction, double, double>({prefix + "degrees"});
+  registerUnaryNumeric<RoundFunction>({prefix + "round"});
+  registerFunction<RoundFunction, int8_t, int8_t, int32_t>({prefix + "round"});
+  registerFunction<RoundFunction, int16_t, int16_t, int32_t>(
+      {prefix + "round"});
+  registerFunction<RoundFunction, int32_t, int32_t, int32_t>(
+      {prefix + "round"});
+  registerFunction<RoundFunction, int64_t, int64_t, int32_t>(
+      {prefix + "round"});
+  registerFunction<RoundFunction, double, double, int32_t>({prefix + "round"});
+  registerFunction<RoundFunction, float, float, int32_t>({prefix + "round"});
+  registerFunction<PowerFunction, double, double, double>(
+      {prefix + "power", prefix + "pow"});
+  registerFunction<PowerFunction, double, int64_t, int64_t>(
+      {prefix + "power", prefix + "pow"});
+  registerFunction<ExpFunction, double, double>({prefix + "exp"});
+  registerFunction<ClampFunction, int8_t, int8_t, int8_t, int8_t>(
+      {prefix + "clamp"});
+  registerFunction<ClampFunction, int16_t, int16_t, int16_t, int16_t>(
+      {prefix + "clamp"});
+  registerFunction<ClampFunction, int32_t, int32_t, int32_t, int32_t>(
+      {prefix + "clamp"});
+  registerFunction<ClampFunction, int64_t, int64_t, int64_t, int64_t>(
+      {prefix + "clamp"});
+  registerFunction<ClampFunction, double, double, double, double>(
+      {prefix + "clamp"});
+  registerFunction<ClampFunction, float, float, float, float>(
+      {prefix + "clamp"});
+  registerFunction<LnFunction, double, double>({prefix + "ln"});
+  registerFunction<Log2Function, double, double>({prefix + "log2"});
+  registerFunction<Log10Function, double, double>({prefix + "log10"});
+  registerFunction<SqrtFunction, double, double>({prefix + "sqrt"});
+  registerFunction<CbrtFunction, double, double>({prefix + "cbrt"});
+  registerFunction<
+      WidthBucketFunction,
+      int64_t,
+      double,
+      double,
+      double,
+      int64_t>({prefix + "width_bucket"});
+
+  registerUnaryNumeric<SignFunction>({prefix + "sign"});
+  registerFunction<InfinityFunction, double>({prefix + "infinity"});
+  registerFunction<IsFiniteFunction, bool, double>({prefix + "is_finite"});
+  registerFunction<IsInfiniteFunction, bool, double>({prefix + "is_infinite"});
+  registerFunction<IsNanFunction, bool, double>({prefix + "is_nan"});
+  registerFunction<NanFunction, double>({prefix + "nan"});
+  registerFunction<RandFunction, double>({prefix + "rand", prefix + "random"});
+  registerUnaryIntegral<RandFunction>({prefix + "rand", prefix + "random"});
+  registerFunction<SecureRandFunction, double>(
+      {prefix + "secure_rand", prefix + "secure_random"});
+  registerBinaryNumeric<SecureRandFunction>(
+      {prefix + "secure_rand", prefix + "secure_random"});
+  registerFunction<FromBaseFunction, int64_t, Varchar, int64_t>(
+      {prefix + "from_base"});
+  registerFunction<ToBaseFunction, Varchar, int64_t, int64_t>(
+      {prefix + "to_base"});
+  registerFunction<PiFunction, double>({prefix + "pi"});
+  registerFunction<EulerConstantFunction, double>({prefix + "e"});
+
+  registerTruncate({prefix + "truncate"});
+
+  registerFunction<
+      CosineSimilarityFunction,
+      double,
+      Map<Varchar, double>,
+      Map<Varchar, double>>({prefix + "cosine_similarity"});
+}
+
+} // namespace
+
+void registerMathematicalFunctions(const std::string& prefix = "") {
+  registerMathFunctions(prefix);
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_not, prefix + "not");
+
+  registerDecimalFloor(prefix);
+  registerDecimalRound(prefix);
+  registerDecimalTruncate(prefix);
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/MathematicalOperatorsRegistration.cpp b/velox/functions/prestosql/registration/MathematicalOperatorsRegistration.cpp
new file mode 100644
index 0000000000000..f5d806589bd35
--- /dev/null
+++ b/velox/functions/prestosql/registration/MathematicalOperatorsRegistration.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/Registerer.h"
+#include "velox/functions/lib/RegistrationHelpers.h"
+#include "velox/functions/prestosql/Arithmetic.h"
+#include "velox/functions/prestosql/DecimalFunctions.h"
+
+namespace facebook::velox::functions {
+
+namespace {
+void registerMathOperators(const std::string& prefix = "") {
+  registerBinaryFloatingPoint<PlusFunction>({prefix + "plus"});
+  registerFunction<
+      PlusFunction,
+      IntervalDayTime,
+      IntervalDayTime,
+      IntervalDayTime>({prefix + "plus"});
+  registerBinaryFloatingPoint<MinusFunction>({prefix + "minus"});
+  registerFunction<
+      MinusFunction,
+      IntervalDayTime,
+      IntervalDayTime,
+      IntervalDayTime>({prefix + "minus"});
+  registerBinaryFloatingPoint<MultiplyFunction>({prefix + "multiply"});
+  registerFunction<MultiplyFunction, IntervalDayTime, IntervalDayTime, int64_t>(
+      {prefix + "multiply"});
+  registerFunction<MultiplyFunction, IntervalDayTime, int64_t, IntervalDayTime>(
+      {prefix + "multiply"});
+  registerFunction<
+      IntervalMultiplyFunction,
+      IntervalDayTime,
+      IntervalDayTime,
+      double>({prefix + "multiply"});
+  registerFunction<
+      IntervalMultiplyFunction,
+      IntervalDayTime,
+      double,
+      IntervalDayTime>({prefix + "multiply"});
+  registerBinaryFloatingPoint<DivideFunction>({prefix + "divide"});
+  registerFunction<
+      IntervalDivideFunction,
+      IntervalDayTime,
+      IntervalDayTime,
+      double>({prefix + "divide"});
+  registerBinaryFloatingPoint<ModulusFunction>({prefix + "mod"});
+}
+
+} // namespace
+
+void registerMathematicalOperators(const std::string& prefix = "") {
+  registerMathOperators(prefix);
+
+  registerDecimalPlus(prefix);
+  registerDecimalMinus(prefix);
+  registerDecimalMultiply(prefix);
+  registerDecimalDivide(prefix);
+  registerDecimalModulus(prefix);
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp
new file mode 100644
index 0000000000000..4e66db644a2cf
--- /dev/null
+++ b/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/Registerer.h"
+#include "velox/functions/lib/RegistrationHelpers.h"
+#include "velox/functions/prestosql/Arithmetic.h"
+#include "velox/functions/prestosql/Probability.h"
+
+// Register Presto Probability, Trigonometric, and Statistical functions.
+
+namespace facebook::velox::functions {
+
+namespace {
+void registerProbTrigFunctions(const std::string& prefix) {
+  registerFunction<CosFunction, double, double>({prefix + "cos"});
+  registerFunction<CoshFunction, double, double>({prefix + "cosh"});
+  registerFunction<AcosFunction, double, double>({prefix + "acos"});
+  registerFunction<SinFunction, double, double>({prefix + "sin"});
+  registerFunction<AsinFunction, double, double>({prefix + "asin"});
+  registerFunction<TanFunction, double, double>({prefix + "tan"});
+  registerFunction<TanhFunction, double, double>({prefix + "tanh"});
+  registerFunction<AtanFunction, double, double>({prefix + "atan"});
+  registerFunction<Atan2Function, double, double, double>({prefix + "atan2"});
+
+  registerFunction<BetaCDFFunction, double, double, double, double>(
+      {prefix + "beta_cdf"});
+  registerFunction<NormalCDFFunction, double, double, double, double>(
+      {prefix + "normal_cdf"});
+  registerFunction<BinomialCDFFunction, double, int64_t, double, int64_t>(
+      {prefix + "binomial_cdf"});
+  registerFunction<BinomialCDFFunction, double, int32_t, double, int32_t>(
+      {prefix + "binomial_cdf"});
+  registerFunction<CauchyCDFFunction, double, double, double, double>(
+      {prefix + "cauchy_cdf"});
+  registerFunction<ChiSquaredCDFFunction, double, double, double>(
+      {prefix + "chi_squared_cdf"});
+  registerFunction<FCDFFunction, double, double, double, double>(
+      {prefix + "f_cdf"});
+  registerFunction<InverseBetaCDFFunction, double, double, double, double>(
+      {prefix + "inverse_beta_cdf"});
+  registerFunction<InverseNormalCDFFunction, double, double, double, double>(
+      {prefix + "inverse_normal_cdf"});
+  registerFunction<PoissonCDFFunction, double, double, int32_t>(
+      {prefix + "poisson_cdf"});
+  registerFunction<GammaCDFFunction, double, double, double, double>(
+      {prefix + "gamma_cdf"});
+  registerFunction<LaplaceCDFFunction, double, double, double, double>(
+      {prefix + "laplace_cdf"});
+  registerFunction<
+      WilsonIntervalUpperFunction,
+      double,
+      int64_t,
+      int64_t,
+      double>({prefix + "wilson_interval_upper"});
+  registerFunction<
+      WilsonIntervalLowerFunction,
+      double,
+      int64_t,
+      int64_t,
+      double>({prefix + "wilson_interval_lower"});
+
+  registerFunction<WeibullCDFFunction, double, double, double, double>(
+      {prefix + "weibull_cdf"});
+  registerFunction<InverseWeibullCDFFunction, double, double, double, double>(
+      {prefix + "inverse_weibull_cdf"});
+  registerFunction<InverseCauchyCDFFunction, double, double, double, double>(
+      {prefix + "inverse_cauchy_cdf"});
+  registerFunction<InverseLaplaceCDFFunction, double, double, double, double>(
+      {prefix + "inverse_laplace_cdf"});
+}
+
+} // namespace
+
+void registerProbabilityTrigonometryFunctions(const std::string& prefix = "") {
+  registerProbTrigFunctions(prefix);
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/RegistrationFunctions.cpp b/velox/functions/prestosql/registration/RegistrationFunctions.cpp
index d4216097d52d8..6bb91a6d77aa0 100644
--- a/velox/functions/prestosql/registration/RegistrationFunctions.cpp
+++ b/velox/functions/prestosql/registration/RegistrationFunctions.cpp
@@ -14,10 +14,14 @@
  * limitations under the License.
  */
 #include <string>
+#include "velox/functions/prestosql/IPAddressFunctions.h"
+#include "velox/functions/prestosql/UuidFunctions.h"
 
 namespace facebook::velox::functions {
 
-extern void registerArithmeticFunctions(const std::string& prefix);
+extern void registerMathematicalFunctions(const std::string& prefix);
+extern void registerMathematicalOperators(const std::string& prefix);
+extern void registerProbabilityTrigonometryFunctions(const std::string& prefix);
 extern void registerArrayFunctions(const std::string& prefix);
 extern void registerBitwiseFunctions(const std::string& prefix);
 extern void registerCheckedArithmeticFunctions(const std::string& prefix);
@@ -33,10 +37,13 @@ extern void registerURLFunctions(const std::string& prefix);
 extern void registerMapAllowingDuplicates(
     const std::string& name,
     const std::string& prefix);
+extern void registerInternalArrayFunctions();
 
 namespace prestosql {
 void registerArithmeticFunctions(const std::string& prefix) {
-  functions::registerArithmeticFunctions(prefix);
+  functions::registerMathematicalOperators(prefix);
+  functions::registerMathematicalFunctions(prefix);
+  functions::registerProbabilityTrigonometryFunctions(prefix);
 }
 
 void registerCheckedArithmeticFunctions(const std::string& prefix) {
@@ -101,6 +108,8 @@ void registerAllScalarFunctions(const std::string& prefix) {
   registerStringFunctions(prefix);
   registerBinaryFunctions(prefix);
   registerBitwiseFunctions(prefix);
+  registerUuidFunctions(prefix);
+  registerIPAddressFunctions(prefix);
 }
 
 void registerMapAllowingDuplicates(
@@ -108,6 +117,10 @@ void registerMapAllowingDuplicates(
     const std::string& prefix) {
   functions::registerMapAllowingDuplicates(name, prefix);
 }
+
+void registerInternalFunctions() {
+  functions::registerInternalArrayFunctions();
+}
 } // namespace prestosql
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/RegistrationFunctions.h b/velox/functions/prestosql/registration/RegistrationFunctions.h
index 2fde672244469..405758e114321 100644
--- a/velox/functions/prestosql/registration/RegistrationFunctions.h
+++ b/velox/functions/prestosql/registration/RegistrationFunctions.h
@@ -25,6 +25,8 @@ void registerComparisonFunctions(const std::string& prefix = "");
 
 void registerArrayFunctions(const std::string& prefix = "");
 
+void registerInternalFunctions();
+
 void registerMapFunctions(const std::string& prefix = "");
 
 void registerJsonFunctions(const std::string& prefix = "");
diff --git a/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp b/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
index 8d10256786f7c..58389dc5f5bd4 100644
--- a/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
@@ -19,6 +19,7 @@
 #include "velox/functions/prestosql/SplitPart.h"
 #include "velox/functions/prestosql/SplitToMap.h"
 #include "velox/functions/prestosql/StringFunctions.h"
+#include "velox/functions/prestosql/WordStem.h"
 
 namespace facebook::velox::functions {
 
@@ -36,6 +37,8 @@ void registerSimpleFunctions(const std::string& prefix) {
   // Register string functions.
   registerFunction<ChrFunction, Varchar, int64_t>({prefix + "chr"});
   registerFunction<CodePointFunction, int32_t, Varchar>({prefix + "codepoint"});
+  registerFunction<HammingDistanceFunction, int64_t, Varchar, Varchar>(
+      {prefix + "hamming_distance"});
   registerFunction<LevenshteinDistanceFunction, int64_t, Varchar, Varchar>(
       {prefix + "levenshtein_distance"});
   registerFunction<LengthFunction, int64_t, Varchar>({prefix + "length"});
@@ -53,11 +56,23 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "substr"});
   registerFunction<SubstrFunction, Varchar, Varchar, int64_t, int64_t>(
       {prefix + "substr"});
+
+  // TODO Presto doesn't allow INTEGER types for 2nd and 3rd arguments. Remove
+  // these signatures.
   registerFunction<SubstrFunction, Varchar, Varchar, int32_t>(
       {prefix + "substr"});
   registerFunction<SubstrFunction, Varchar, Varchar, int32_t, int32_t>(
       {prefix + "substr"});
 
+  registerFunction<SubstrVarbinaryFunction, Varbinary, Varbinary, int64_t>(
+      {prefix + "substr"});
+  registerFunction<
+      SubstrVarbinaryFunction,
+      Varbinary,
+      Varbinary,
+      int64_t,
+      int64_t>({prefix + "substr"});
+
   registerFunction<SplitPart, Varchar, Varchar, Varchar, int64_t>(
       {prefix + "split_part"});
 
@@ -78,12 +93,50 @@ void registerSimpleFunctions(const std::string& prefix) {
   exec::registerStatefulVectorFunction(
       prefix + "like", likeSignatures(), makeLike);
 
-  registerFunction<SplitPart, Varchar, Varchar, Varchar, int64_t>(
-      {prefix + "split_part"});
   registerFunction<Re2RegexpReplacePresto, Varchar, Varchar, Varchar>(
       {prefix + "regexp_replace"});
   registerFunction<Re2RegexpReplacePresto, Varchar, Varchar, Varchar, Varchar>(
       {prefix + "regexp_replace"});
+  exec::registerStatefulVectorFunction(
+      prefix + "regexp_replace",
+      regexpReplaceWithLambdaSignatures(),
+      makeRegexpReplaceWithLambda,
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
+
+  registerFunction<Re2RegexpSplit, Array<Varchar>, Varchar, Varchar>(
+      {prefix + "regexp_split"});
+}
+
+void registerSplitToMap(const std::string& prefix) {
+  registerFunction<
+      SplitToMapFunction,
+      Map<Varchar, Varchar>,
+      Varchar,
+      Varchar,
+      Varchar>({prefix + "split_to_map"});
+
+  exec::registerVectorFunction(
+      prefix + "split_to_map",
+      {
+          exec::FunctionSignatureBuilder()
+              .returnType("map(varchar,varchar)")
+              .argumentType("varchar")
+              .argumentType("varchar")
+              .argumentType("varchar")
+              .argumentType("function(varchar,varchar,varchar,varchar)")
+              .build(),
+      },
+      std::make_unique<exec::ApplyNeverCalled>());
+  registerFunction<
+      SplitToMapFunction,
+      Map<Varchar, Varchar>,
+      Varchar,
+      Varchar,
+      Varchar,
+      bool>({"$internal$split_to_map"});
+  exec::registerExpressionRewrite([prefix](const auto& expr) {
+    return rewriteSplitToMapCall(prefix, expr);
+  });
 }
 } // namespace
 
@@ -93,12 +146,9 @@ void registerStringFunctions(const std::string& prefix) {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_lower, prefix + "lower");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_upper, prefix + "upper");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_split, prefix + "split");
-  registerFunction<
-      SplitToMapFunction,
-      Map<Varchar, Varchar>,
-      Varchar,
-      Varchar,
-      Varchar>({prefix + "split_to_map"});
+
+  registerSplitToMap(prefix);
+
   VELOX_REGISTER_VECTOR_FUNCTION(udf_concat, prefix + "concat");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_replace, prefix + "replace");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_reverse, prefix + "reverse");
@@ -123,5 +173,14 @@ void registerStringFunctions(const std::string& prefix) {
       {prefix + "strrpos"});
   registerFunction<StrRPosFunction, int64_t, Varchar, Varchar, int64_t>(
       {prefix + "strrpos"});
+
+  registerFunction<NormalizeFunction, Varchar, Varchar>({prefix + "normalize"});
+  registerFunction<NormalizeFunction, Varchar, Varchar, Varchar>(
+      {prefix + "normalize"});
+
+  // word_stem function
+  registerFunction<WordStemFunction, Varchar, Varchar>({prefix + "word_stem"});
+  registerFunction<WordStemFunction, Varchar, Varchar, Varchar>(
+      {prefix + "word_stem"});
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ArgGeneratorTest.cpp b/velox/functions/prestosql/tests/ArgGeneratorTest.cpp
new file mode 100644
index 0000000000000..9d4e496fbc30f
--- /dev/null
+++ b/velox/functions/prestosql/tests/ArgGeneratorTest.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h"
+#include "velox/functions/prestosql/fuzzer/DivideArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/FloorAndRoundArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/ModulusArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/MultiplyArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/PlusMinusArgGenerator.h"
+#include "velox/functions/prestosql/fuzzer/TruncateArgGenerator.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::fuzzer::test;
+namespace {
+
+class ArgGeneratorTest : public functions::test::FunctionBaseTest {
+ protected:
+  // Returns the only signature with decimal return type for a given function
+  // name.
+  const exec::FunctionSignature& getOnlySignature(
+      const std::string& functionName) {
+    const auto signatures = getSignatures(functionName, "decimal");
+    VELOX_CHECK_EQ(signatures.size(), 1);
+    return *signatures[0];
+  }
+};
+
+TEST_F(ArgGeneratorTest, plus) {
+  const auto& signature = getOnlySignature("plus");
+  const auto generator = std::make_shared<exec::test::PlusMinusArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 2));
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(38, 38));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, signature, DECIMAL(18, 18));
+}
+
+TEST_F(ArgGeneratorTest, minus) {
+  const auto& signature = getOnlySignature("minus");
+  const auto generator = std::make_shared<exec::test::PlusMinusArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 2));
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(38, 38));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, signature, DECIMAL(18, 18));
+}
+
+TEST_F(ArgGeneratorTest, multiply) {
+  const auto& signature = getOnlySignature("multiply");
+  const auto generator = std::make_shared<exec::test::MultiplyArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 2));
+  assertReturnType(generator, signature, DECIMAL(18, 18));
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(38, 38));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+}
+
+TEST_F(ArgGeneratorTest, divide) {
+  const auto& signature = getOnlySignature("divide");
+  const auto generator = std::make_shared<exec::test::DivideArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 2));
+  assertReturnType(generator, signature, DECIMAL(18, 18));
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(38, 38));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+}
+
+TEST_F(ArgGeneratorTest, floor) {
+  const auto& signature = getOnlySignature("floor");
+  const auto generator =
+      std::make_shared<exec::test::FloorAndRoundArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 0));
+  assertReturnType(generator, signature, DECIMAL(18, 0));
+  assertReturnType(generator, signature, DECIMAL(32, 0));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, signature, DECIMAL(10, 2));
+}
+
+TEST_F(ArgGeneratorTest, round) {
+  const auto signatures = getSignatures("round", "decimal");
+  VELOX_CHECK_EQ(signatures.size(), 2);
+  bool isSingleArg = signatures[0]->argumentTypes().size() == 1;
+  const auto generator =
+      std::make_shared<exec::test::FloorAndRoundArgGenerator>();
+
+  const auto& singleArgSignature =
+      isSingleArg ? *signatures[0] : *signatures[1];
+  assertReturnType(generator, singleArgSignature, DECIMAL(10, 0));
+  assertReturnType(generator, singleArgSignature, DECIMAL(18, 0));
+  assertReturnType(generator, singleArgSignature, DECIMAL(32, 0));
+  assertReturnType(generator, singleArgSignature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, singleArgSignature, DECIMAL(10, 2));
+
+  const auto& twoArgsSignature = isSingleArg ? *signatures[1] : *signatures[0];
+  assertReturnType(generator, twoArgsSignature, DECIMAL(10, 2));
+  assertReturnType(generator, twoArgsSignature, DECIMAL(32, 6));
+  assertReturnType(generator, twoArgsSignature, DECIMAL(38, 20));
+  assertReturnType(generator, twoArgsSignature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, twoArgsSignature, DECIMAL(18, 18));
+  assertEmptyArgs(generator, twoArgsSignature, DECIMAL(38, 38));
+  assertEmptyArgs(generator, twoArgsSignature, DECIMAL(1, 0));
+}
+
+TEST_F(ArgGeneratorTest, modulus) {
+  const auto& signature = getOnlySignature("mod");
+  const auto generator = std::make_shared<exec::test::ModulusArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 2));
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(38, 38));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+}
+
+TEST_F(ArgGeneratorTest, truncate) {
+  const auto signatures = getSignatures("truncate", "decimal");
+  VELOX_CHECK_EQ(signatures.size(), 2);
+  const auto& signature = signatures[0]->argumentTypes().size() == 1
+      ? *signatures[0]
+      : *signatures[1];
+  const auto generator = std::make_shared<exec::test::TruncateArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(1, 0));
+  assertReturnType(generator, signature, DECIMAL(10, 0));
+  assertReturnType(generator, signature, DECIMAL(18, 0));
+  assertReturnType(generator, signature, DECIMAL(32, 0));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, signature, DECIMAL(10, 2));
+}
+
+} // namespace
diff --git a/velox/functions/prestosql/tests/ArithmeticTest.cpp b/velox/functions/prestosql/tests/ArithmeticTest.cpp
index aa4ef98a63fdf..36bffb0c10c96 100644
--- a/velox/functions/prestosql/tests/ArithmeticTest.cpp
+++ b/velox/functions/prestosql/tests/ArithmeticTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include <cmath>
+#include <limits>
 #include <optional>
 
 #include <gmock/gmock.h>
@@ -30,6 +31,8 @@ constexpr double kInf = std::numeric_limits<double>::infinity();
 constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
 constexpr float kInfF = std::numeric_limits<float>::infinity();
 constexpr float kNanF = std::numeric_limits<float>::quiet_NaN();
+constexpr int64_t kLongMax = std::numeric_limits<int64_t>::max();
+constexpr int64_t kLongMin = std::numeric_limits<int64_t>::min();
 
 MATCHER(IsNan, "is NaN") {
   return arg && std::isnan(*arg);
@@ -61,6 +64,15 @@ class ArithmeticTest : public functions::test::FunctionBaseTest {
     }
   }
 
+  void assertExpression(
+      const std::string& expression,
+      const VectorPtr& arg0,
+      const VectorPtr& arg1,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector({arg0, arg1}));
+    test::assertEqualVectors(expected, result);
+  }
+
   template <typename T, typename U = T, typename V = T>
   void assertError(
       const std::string& expression,
@@ -80,6 +92,30 @@ class ArithmeticTest : public functions::test::FunctionBaseTest {
   }
 };
 
+TEST_F(ArithmeticTest, plus) {
+  // Test plus for intervals.
+  auto op1 = makeNullableFlatVector<int64_t>(
+      {-1, 2, -3, 4, kLongMax, -1, std::nullopt, 0}, INTERVAL_DAY_TIME());
+  auto op2 = makeNullableFlatVector<int64_t>(
+      {2, -3, -1, 1, 1, kLongMin, 0, std::nullopt}, INTERVAL_DAY_TIME());
+  auto expected = makeNullableFlatVector<int64_t>(
+      {1, -1, -4, 5, kLongMin, kLongMax, std::nullopt, std::nullopt},
+      INTERVAL_DAY_TIME());
+  assertExpression("c0 + c1", op1, op2, expected);
+}
+
+TEST_F(ArithmeticTest, minus) {
+  // Test plus for intervals.
+  auto op1 = makeNullableFlatVector<int64_t>(
+      {-1, 2, -3, 4, kLongMin, -1, std::nullopt, 0}, INTERVAL_DAY_TIME());
+  auto op2 = makeNullableFlatVector<int64_t>(
+      {2, 3, -4, 1, 1, kLongMax, 0, std::nullopt}, INTERVAL_DAY_TIME());
+  auto expected = makeNullableFlatVector<int64_t>(
+      {-3, -1, 1, 3, kLongMax, kLongMin, std::nullopt, std::nullopt},
+      INTERVAL_DAY_TIME());
+  assertExpression("c0 - c1", op1, op2, expected);
+}
+
 TEST_F(ArithmeticTest, divide)
 #if defined(__has_feature)
 #if __has_feature(__address_sanitizer__)
@@ -107,6 +143,43 @@ __attribute__((__no_sanitize__("float-divide-by-zero")))
       {5.25, kInfF, kNanF, 0.0});
   assertExpression<double>(
       "c0 / c1", {10.5, 9.2, 0.0, 0.0}, {2, 0, 0, -1}, {5.25, kInf, kNan, 0.0});
+
+  // Test interval divided by double.
+  auto intervalVector = makeNullableFlatVector<int64_t>(
+      {3, 6, 9, std::nullopt, 12, 15, 18, 21, 0, 0, 1}, INTERVAL_DAY_TIME());
+  auto doubleVector = makeNullableFlatVector<double>(
+      {0.5,
+       -2.0,
+       5.0,
+       1.0,
+       std::nullopt,
+       kNan,
+       kInf,
+       -kInf,
+       0.0,
+       -0.0,
+       0.00000001});
+  auto expected = makeNullableFlatVector<int64_t>(
+      {6, -3, 1, std::nullopt, std::nullopt, 0, 0, 0, 0, 0, 100000000},
+      INTERVAL_DAY_TIME());
+  assertExpression("c0 / c1", intervalVector, doubleVector, expected);
+
+  intervalVector = makeFlatVector<int64_t>(
+      {1, 1, 1, 1, kLongMax, kLongMin, kLongMax, kLongMin},
+      INTERVAL_DAY_TIME());
+  doubleVector = makeFlatVector<double>(
+      {0.0, -0.0, 4.9e-324, -4.9e-324, 0.1, 0.1, -0.1, -0.1});
+  expected = makeFlatVector<int64_t>(
+      {kLongMax,
+       kLongMin,
+       kLongMax,
+       kLongMin,
+       kLongMax,
+       kLongMin,
+       kLongMin,
+       kLongMax},
+      INTERVAL_DAY_TIME());
+  assertExpression("c0 / c1", intervalVector, doubleVector, expected);
 }
 
 TEST_F(ArithmeticTest, multiply) {
@@ -115,6 +188,50 @@ TEST_F(ArithmeticTest, multiply) {
       {std::numeric_limits<int32_t>::min()},
       {-1},
       "integer overflow: -2147483648 * -1");
+
+  // Test multiplication of interval type with bigint.
+  auto intervalVector = makeNullableFlatVector<int64_t>(
+      {1, 2, 3, std::nullopt, 10, 20}, INTERVAL_DAY_TIME());
+  auto bigintVector = makeNullableFlatVector<int64_t>(
+      {1, std::nullopt, 3, 4, kLongMax, kLongMin});
+  auto expected = makeNullableFlatVector<int64_t>(
+      {1, std::nullopt, 9, std::nullopt, -10, 0}, INTERVAL_DAY_TIME());
+  assertExpression("c0 * c1", intervalVector, bigintVector, expected);
+  assertExpression("c1 * c0", intervalVector, bigintVector, expected);
+
+  // Test multiplication of interval type with double.
+  intervalVector = makeNullableFlatVector<int64_t>(
+      {1, 2, 3, std::nullopt, 10, 20, 30, 40, 1000, 1000, 1000, 1000},
+      INTERVAL_DAY_TIME());
+  auto doubleVector = makeNullableFlatVector<double>(
+      {-1.8,
+       2.1,
+       kNan,
+       4.2,
+       0.0,
+       -0.0,
+       kInf,
+       -kInf,
+       9223372036854775807.01,
+       -9223372036854775808.01,
+       1.7e308,
+       -1.7e308});
+  expected = makeNullableFlatVector<int64_t>(
+      {-1,
+       4,
+       0,
+       std::nullopt,
+       0,
+       0,
+       kLongMax,
+       kLongMin,
+       kLongMax,
+       kLongMin,
+       kLongMax,
+       kLongMin},
+      INTERVAL_DAY_TIME());
+  assertExpression("c0 * c1", intervalVector, doubleVector, expected);
+  assertExpression("c1 * c0", intervalVector, doubleVector, expected);
 }
 
 TEST_F(ArithmeticTest, mod) {
@@ -482,6 +599,7 @@ TEST_F(ArithmeticTest, isFinite) {
   EXPECT_EQ(false, isFinite(-kInf));
   EXPECT_EQ(false, isFinite(1.0 / 0.0));
   EXPECT_EQ(false, isFinite(-1.0 / 0.0));
+  EXPECT_EQ(false, isFinite(kNan));
 }
 
 TEST_F(ArithmeticTest, isInfinite) {
@@ -490,6 +608,7 @@ TEST_F(ArithmeticTest, isInfinite) {
   };
 
   EXPECT_EQ(false, isInfinite(0.0));
+  EXPECT_EQ(false, isInfinite(kNan));
   EXPECT_EQ(true, isInfinite(kInf));
   EXPECT_EQ(true, isInfinite(-kInf));
   EXPECT_EQ(true, isInfinite(1.0 / 0.0));
@@ -659,10 +778,24 @@ TEST_F(ArithmeticTest, clamp) {
   EXPECT_EQ(clamp(123456, 1, -1), -1);
 }
 
-TEST_F(ArithmeticTest, truncate) {
-  const auto truncate = [&](std::optional<double> a,
-                            std::optional<int32_t> n = 0) {
-    return evaluateOnce<double>("truncate(c0,c1)", a, n);
+TEST_F(ArithmeticTest, truncateDouble) {
+  const auto truncate = [&](std::optional<double> d) {
+    const auto r = evaluateOnce<double>("truncate(c0)", d);
+
+    // truncate(d) == truncate(d, 0)
+    if (d.has_value() && std::isfinite(d.value())) {
+      const auto otherResult =
+          evaluateOnce<double>("truncate(c0, 0::integer)", d);
+
+      VELOX_CHECK_EQ(r.value(), otherResult.value());
+    }
+
+    return r;
+  };
+
+  const auto truncateN = [&](std::optional<double> d,
+                             std::optional<int32_t> n) {
+    return evaluateOnce<double>("truncate(c0, c1)", d, n);
   };
 
   EXPECT_EQ(truncate(0), 0);
@@ -672,37 +805,86 @@ TEST_F(ArithmeticTest, truncate) {
   EXPECT_THAT(truncate(kNan), IsNan());
   EXPECT_THAT(truncate(kInf), IsInf());
 
-  EXPECT_EQ(truncate(0, 0), 0);
-  EXPECT_EQ(truncate(1.5, 0), 1);
-  EXPECT_EQ(truncate(-1.5, 0), -1);
-  EXPECT_EQ(truncate(std::nullopt, 0), std::nullopt);
-  EXPECT_EQ(truncate(1.5, std::nullopt), std::nullopt);
-  EXPECT_THAT(truncate(kNan, 0), IsNan());
-  EXPECT_THAT(truncate(kNan, 1), IsNan());
-  EXPECT_THAT(truncate(kInf, 0), IsInf());
-  EXPECT_THAT(truncate(kInf, 1), IsInf());
-
-  EXPECT_DOUBLE_EQ(truncate(1.5678, 2).value(), 1.56);
-  EXPECT_DOUBLE_EQ(truncate(-1.5678, 2).value(), -1.56);
-  EXPECT_DOUBLE_EQ(truncate(1.333, -1).value(), 0);
-  EXPECT_DOUBLE_EQ(truncate(3.54555, 2).value(), 3.54);
-  EXPECT_DOUBLE_EQ(truncate(1234, 1).value(), 1234);
-  EXPECT_DOUBLE_EQ(truncate(1234, -1).value(), 1230);
-  EXPECT_DOUBLE_EQ(truncate(1234.56, 1).value(), 1234.5);
-  EXPECT_DOUBLE_EQ(truncate(1234.56, -1).value(), 1230.0);
-  EXPECT_DOUBLE_EQ(truncate(1239.999, 2).value(), 1239.99);
-  EXPECT_DOUBLE_EQ(truncate(1239.999, -2).value(), 1200.0);
+  EXPECT_EQ(truncate(0), 0);
+  EXPECT_EQ(truncate(1.5), 1);
+  EXPECT_EQ(truncate(-1.5), -1);
+  EXPECT_EQ(truncate(std::nullopt), std::nullopt);
+  EXPECT_THAT(truncate(kNan), IsNan());
+  EXPECT_THAT(truncate(kInf), IsInf());
+
+  EXPECT_EQ(truncateN(1.5, std::nullopt), std::nullopt);
+  EXPECT_THAT(truncateN(kNan, 1), IsNan());
+  EXPECT_THAT(truncateN(kInf, 1), IsInf());
+
+  EXPECT_DOUBLE_EQ(truncateN(1.5678, 2).value(), 1.56);
+  EXPECT_DOUBLE_EQ(truncateN(-1.5678, 2).value(), -1.56);
+  EXPECT_DOUBLE_EQ(truncateN(1.333, -1).value(), 0);
+  EXPECT_DOUBLE_EQ(truncateN(3.54555, 2).value(), 3.54);
+  EXPECT_DOUBLE_EQ(truncateN(1234, 1).value(), 1234);
+  EXPECT_DOUBLE_EQ(truncateN(1234, -1).value(), 1230);
+  EXPECT_DOUBLE_EQ(truncateN(1234.56, 1).value(), 1234.5);
+  EXPECT_DOUBLE_EQ(truncateN(1234.56, -1).value(), 1230.0);
+  EXPECT_DOUBLE_EQ(truncateN(1239.999, 2).value(), 1239.99);
+  EXPECT_DOUBLE_EQ(truncateN(1239.999, -2).value(), 1200.0);
   EXPECT_DOUBLE_EQ(
-      truncate(123456789012345678901.23, 3).value(), 123456789012345678901.23);
+      truncateN(123456789012345678901.23, 3).value(), 123456789012345678901.23);
   EXPECT_DOUBLE_EQ(
-      truncate(-123456789012345678901.23, 3).value(),
+      truncateN(-123456789012345678901.23, 3).value(),
       -123456789012345678901.23);
   EXPECT_DOUBLE_EQ(
-      truncate(123456789123456.999, 2).value(), 123456789123456.99);
-  EXPECT_DOUBLE_EQ(truncate(123456789012345678901.0, -21).value(), 0.0);
-  EXPECT_DOUBLE_EQ(truncate(123456789012345678901.23, -21).value(), 0.0);
-  EXPECT_DOUBLE_EQ(truncate(123456789012345678901.0, -21).value(), 0.0);
-  EXPECT_DOUBLE_EQ(truncate(123456789012345678901.23, -21).value(), 0.0);
+      truncateN(123456789123456.999, 2).value(), 123456789123456.99);
+  EXPECT_DOUBLE_EQ(truncateN(123456789012345678901.0, -21).value(), 0.0);
+  EXPECT_DOUBLE_EQ(truncateN(123456789012345678901.23, -21).value(), 0.0);
+  EXPECT_DOUBLE_EQ(truncateN(123456789012345678901.0, -21).value(), 0.0);
+  EXPECT_DOUBLE_EQ(truncateN(123456789012345678901.23, -21).value(), 0.0);
+}
+
+TEST_F(ArithmeticTest, truncateReal) {
+  const auto truncate = [&](std::optional<float> d) {
+    const auto r = evaluateOnce<float>("truncate(c0)", d);
+
+    // truncate(d) == truncate(d, 0)
+    if (d.has_value() && std::isfinite(d.value())) {
+      const auto otherResult =
+          evaluateOnce<float>("truncate(c0, 0::integer)", d);
+
+      VELOX_CHECK_EQ(r.value(), otherResult.value());
+    }
+
+    return r;
+  };
+
+  const auto truncateN = [&](std::optional<float> d, std::optional<int32_t> n) {
+    return evaluateOnce<float>("truncate(c0, c1)", d, n);
+  };
+
+  EXPECT_EQ(truncate(0), 0);
+  EXPECT_EQ(truncate(1.5), 1);
+  EXPECT_EQ(truncate(-1.5), -1);
+
+  EXPECT_EQ(truncate(std::nullopt), std::nullopt);
+  EXPECT_THAT(truncate(kNan), IsNan());
+  EXPECT_THAT(truncate(kInf), IsInf());
+
+  EXPECT_FLOAT_EQ(truncateN(123.456, 0).value(), 123);
+  EXPECT_FLOAT_EQ(truncateN(123.456, 1).value(), 123.4);
+  EXPECT_FLOAT_EQ(truncateN(123.456, 2).value(), 123.45);
+  EXPECT_FLOAT_EQ(truncateN(123.456, 3).value(), 123.456);
+  EXPECT_FLOAT_EQ(truncateN(123.456, 4).value(), 123.456);
+
+  EXPECT_FLOAT_EQ(truncateN(123.456, -1).value(), 120);
+  EXPECT_FLOAT_EQ(truncateN(123.456, -2).value(), 100);
+  EXPECT_FLOAT_EQ(truncateN(123.456, -3).value(), 0);
+
+  EXPECT_FLOAT_EQ(truncateN(-123.456, 0).value(), -123);
+  EXPECT_FLOAT_EQ(truncateN(-123.456, 1).value(), -123.4);
+  EXPECT_FLOAT_EQ(truncateN(-123.456, 2).value(), -123.45);
+  EXPECT_FLOAT_EQ(truncateN(-123.456, 3).value(), -123.456);
+  EXPECT_FLOAT_EQ(truncateN(-123.456, 4).value(), -123.456);
+
+  EXPECT_FLOAT_EQ(truncateN(-123.456, -1).value(), -120);
+  EXPECT_FLOAT_EQ(truncateN(-123.456, -2).value(), -100);
+  EXPECT_FLOAT_EQ(truncateN(-123.456, -3).value(), 0);
 }
 
 TEST_F(ArithmeticTest, wilsonIntervalLower) {
@@ -821,5 +1003,51 @@ TEST_F(ArithmeticTest, wilsonIntervalUpper) {
   EXPECT_DOUBLE_EQ(wilsonIntervalUpper(1, 3, kInf).value(), 1.0);
 }
 
+TEST_F(ArithmeticTest, cosineSimilarity) {
+  const auto cosineSimilarity =
+      [&](const std::vector<std::pair<std::string, std::optional<double>>>&
+              left,
+          const std::vector<std::pair<std::string, std::optional<double>>>&
+              right) {
+        auto leftMap = makeMapVector<std::string, double>({left});
+        auto rightMap = makeMapVector<std::string, double>({right});
+        return evaluateOnce<double>(
+                   "cosine_similarity(c0,c1)",
+                   makeRowVector({leftMap, rightMap}))
+            .value();
+      };
+
+  EXPECT_DOUBLE_EQ(
+      (2.0 * 3.0) / (std::sqrt(5.0) * std::sqrt(10.0)),
+      cosineSimilarity({{"a", 1}, {"b", 2}}, {{"c", 1}, {"b", 3}}));
+
+  EXPECT_DOUBLE_EQ(
+      (2.0 * 3.0 + (-1) * 1) / (std::sqrt(1 + 4 + 1) * std::sqrt(1 + 9)),
+      cosineSimilarity({{"a", 1}, {"b", 2}, {"c", -1}}, {{"c", 1}, {"b", 3}}));
+
+  EXPECT_DOUBLE_EQ(
+      (2.0 * 3.0 + (-1) * 1) / (std::sqrt(1 + 4 + 1) * std::sqrt(1 + 9)),
+      cosineSimilarity({{"a", 1}, {"b", 2}, {"c", -1}}, {{"c", 1}, {"b", 3}}));
+
+  EXPECT_DOUBLE_EQ(
+      0.0,
+      cosineSimilarity({{"a", 1}, {"b", 2}, {"c", -1}}, {{"d", 1}, {"e", 3}}));
+
+  EXPECT_TRUE(std::isnan(cosineSimilarity({}, {})));
+  EXPECT_TRUE(std::isnan(cosineSimilarity({{"d", 1}, {"e", 3}}, {})));
+  EXPECT_TRUE(
+      std::isnan(cosineSimilarity({{"a", 1}, {"b", 3}}, {{"a", 0}, {"b", 0}})));
+
+  auto nullableLeftMap = makeNullableMapVector<StringView, double>(
+      {{{{"a"_sv, 1}, {"b"_sv, std::nullopt}}}});
+  auto rightMap =
+      makeMapVector<StringView, double>({{{{"c"_sv, 1}, {"b"_sv, 3}}}});
+
+  EXPECT_FALSE(evaluateOnce<double>(
+                   "cosine_similarity(c0,c1)",
+                   makeRowVector({nullableLeftMap, rightMap}))
+                   .has_value());
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/ArrayAllMatchTest.cpp b/velox/functions/prestosql/tests/ArrayAllMatchTest.cpp
index 3fdc671c509c9..dda82256e4154 100644
--- a/velox/functions/prestosql/tests/ArrayAllMatchTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayAllMatchTest.cpp
@@ -92,21 +92,11 @@ TEST_F(ArrayAllMatchTest, basic) {
 }
 
 TEST_F(ArrayAllMatchTest, complexTypes) {
-  auto baseVector = makeArrayVector<int64_t>({
-      {1, 2, 3},
-      {2, 2},
-      {3, 3},
-      {4, 4},
-      {5, 5},
-      {},
+  auto arrayOfArrays = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[2, 2], [3, 3], [4, 4], [5, 5]]",
+      "[[]]",
   });
-  // Create an array of array vector using above base vector using offsets.
-  // [
-  //  [[1, 2, 3]],
-  //  [[2, 2], [3, 3], [4, 4], [5, 5]],
-  //  [[]]
-  // ]
-  auto arrayOfArrays = makeArrayVector({0, 1, 5}, baseVector);
   std::vector<std::optional<bool>> expectedResult{
       true,
       true,
@@ -114,14 +104,12 @@ TEST_F(ArrayAllMatchTest, complexTypes) {
   };
   testAllMatchExpr(expectedResult, "cardinality(x) > 0", arrayOfArrays);
 
-  // Create an array of array vector using above base vector using offsets.
-  // [
-  //  [[1, 2, 3]],  cardinalities is 3
-  //  [[2, 2], [3, 3], [4, 4], [5, 5]], all cardinalities is 2
-  //  [[]],
-  //  null
-  // ]
-  arrayOfArrays = makeArrayVector({0, 1, 5, 6}, baseVector, {3});
+  arrayOfArrays = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[2, 2], [3, 3], [4, 4], [5, 5]]",
+      "[[]]",
+      "null",
+  });
   expectedResult = {true, false, false, std::nullopt};
   testAllMatchExpr(expectedResult, "cardinality(x) > 2", arrayOfArrays);
 }
@@ -193,7 +181,7 @@ TEST_F(ArrayAllMatchTest, errors) {
 
 TEST_F(ArrayAllMatchTest, conditional) {
   // No throw and return false if there are unmatched elements except nulls
-  auto c0 = makeFlatVector<uint32_t>({1, 2, 3, 4, 5});
+  auto c0 = makeFlatVector<int32_t>({1, 2, 3, 4, 5});
   auto c1 = makeNullableArrayVector<int32_t>({
       {100, std::nullopt},
       {500, 120},
diff --git a/velox/functions/prestosql/tests/ArrayAnyMatchTest.cpp b/velox/functions/prestosql/tests/ArrayAnyMatchTest.cpp
index ac2911c7717e4..88f4615c8f06c 100644
--- a/velox/functions/prestosql/tests/ArrayAnyMatchTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayAnyMatchTest.cpp
@@ -90,21 +90,11 @@ TEST_F(ArrayAnyMatchTest, basic) {
 }
 
 TEST_F(ArrayAnyMatchTest, complexTypes) {
-  auto baseVector = makeArrayVector<int64_t>({
-      {1, 2, 3},
-      {2, 2},
-      {3, 3},
-      {4, 4},
-      {5, 5},
-      {},
+  auto arrayOfArrays = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[2, 2], [3, 3], [4, 4], [5, 5]]",
+      "[[]]",
   });
-  // Create an array of array vector using above base vector using offsets.
-  // [
-  //  [[1, 2, 3]],
-  //  [[2, 2], [3, 3], [4, 4], [5, 5]],
-  //  [[]]
-  // ]
-  auto arrayOfArrays = makeArrayVector({0, 1, 5}, baseVector);
   std::vector<std::optional<bool>> expectedResult{
       true,
       true,
@@ -112,14 +102,12 @@ TEST_F(ArrayAnyMatchTest, complexTypes) {
   };
   testAnyMatchExpr(expectedResult, "cardinality(x) > 0", arrayOfArrays);
 
-  // Create an array of array vector using above base vector using offsets.
-  // [
-  //  [[1, 2, 3]],  cardinalities is 3
-  //  [[2, 2], [3, 3], [4, 4], [5, 5]], all cardinalities is 2
-  //  [[]],
-  //  null
-  // ]
-  arrayOfArrays = makeArrayVector({0, 1, 5, 6}, baseVector, {3});
+  arrayOfArrays = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[2, 2], [3, 3], [4, 4], [5, 5]]",
+      "[[]]",
+      "null",
+  });
   expectedResult = {
       true,
       false,
@@ -198,7 +186,7 @@ TEST_F(ArrayAnyMatchTest, errors) {
 
 TEST_F(ArrayAnyMatchTest, conditional) {
   // No throw and return false if there are unmatched elements except nulls
-  auto c0 = makeFlatVector<uint32_t>({1, 2, 3, 4, 5});
+  auto c0 = makeFlatVector<int32_t>({1, 2, 3, 4, 5});
   auto c1 = makeNullableArrayVector<int32_t>({
       {4, 100, std::nullopt},
       {50, 12},
diff --git a/velox/functions/prestosql/tests/ArrayContainsTest.cpp b/velox/functions/prestosql/tests/ArrayContainsTest.cpp
index 7bf8f787cdfcb..b55a5bd5af9b0 100644
--- a/velox/functions/prestosql/tests/ArrayContainsTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayContainsTest.cpp
@@ -15,6 +15,8 @@
  */
 
 #include <optional>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 using namespace facebook::velox;
@@ -51,6 +53,59 @@ class ArrayContainsTest : public FunctionBaseTest {
 
     assertEqualVectors(makeNullableFlatVector<bool>(expected), result);
   };
+
+  void testContainsGeneric(
+      const VectorPtr& arrayVector,
+      const VectorPtr& search,
+      const std::vector<std::optional<bool>>& expected) {
+    auto result = evaluate(
+        "contains(c0, c1)",
+        makeRowVector({
+            arrayVector,
+            search,
+        }));
+
+    assertEqualVectors(makeNullableFlatVector<bool>(expected), result);
+  };
+
+  template <typename T>
+  void testFloatingPointNaNs() {
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+    {
+      auto arrayVector =
+          makeArrayVector<T>({{1, 2, 3, 4}, {3, 4, kNaN}, {5, 6, 7, 8, kSNaN}});
+      // Test fast path for flat.
+      testContains(arrayVector, kNaN, {false, true, true});
+      // Test code path for generic encoded vectors.
+      auto indices = makeIndices(arrayVector->size(), folly::identity);
+      auto dictOverArray = wrapInDictionary(indices, arrayVector);
+      testContainsGeneric(
+          dictOverArray,
+          makeConstant(kNaN, arrayVector->size()),
+          {false, true, true});
+    }
+
+    // Test code path for complex-type elements.
+    {
+      RowTypePtr rowType;
+      if constexpr (std::is_same_v<T, float>) {
+        rowType = ROW({REAL(), VARCHAR()});
+      } else {
+        static_assert(std::is_same_v<T, double>);
+        rowType = ROW({DOUBLE(), VARCHAR()});
+      }
+      using ArrayOfRow = std::vector<std::optional<std::tuple<T, std::string>>>;
+      std::vector<ArrayOfRow> data = {
+          {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+          {{{1, "red"}}, {{kNaN, "blue"}}, {{3, "green"}}},
+          {{{1, "red"}}, {{kSNaN, "blue"}}, {{3, "green"}}}};
+      auto arrayVector = makeArrayOfRowVector(data, rowType);
+      const auto searchVector =
+          makeConstantRow(rowType, variant::row({kNaN, "blue"}), 2);
+      testContainsGeneric(arrayVector, searchVector, {false, true, true});
+    }
+  }
 };
 
 TEST_F(ArrayContainsTest, integerNoNulls) {
@@ -316,4 +371,114 @@ TEST_F(ArrayContainsTest, dictionaryEncodingElements) {
   testContainsConstantKey(arrayVector, {3, 4, 5}, {true, true});
 }
 
+TEST_F(ArrayContainsTest, arrayCheckNulls) {
+  facebook::velox::functions::prestosql::registerInternalFunctions();
+
+  static const std::string kErrorMessage =
+      "contains does not support arrays with elements that contain null";
+  auto contains = [&](const std::string& search,
+                      const auto& data,
+                      bool internal = false) {
+    const auto searchBase = makeArrayVectorFromJson<int32_t>({search});
+    const auto searchConstant =
+        BaseVector::wrapInConstant(data->size(), 0, searchBase);
+    std::string call = internal ? "\"$internal$contains\"" : "contains";
+    const auto result = evaluate(
+        fmt::format("{}(c0, c1)", call), makeRowVector({data, searchConstant}));
+    return result->template asFlatVector<bool>()->valueAt(0);
+  };
+
+  {
+    // Null at the end of the array.
+    const auto baseVector = makeArrayVectorFromJson<int32_t>({
+        "[1, 1]",
+        "[2, 2]",
+        "[3, null]",
+        "[4, 4]",
+        "[5, 5]",
+        "[6, 6]",
+    });
+    const auto data = makeArrayVector({0, 3}, baseVector);
+
+    // No null equal.
+    ASSERT_FALSE(contains("[7, null]", data));
+    ASSERT_FALSE(contains("[7, null]", data, true));
+    // Null equal, [3, null] vs [3, 3].
+    VELOX_ASSERT_THROW(contains("[3, 3]", data), kErrorMessage);
+    ASSERT_FALSE(contains("[3, 3]", data, true));
+    // Null equal, [6, 6] vs [6, null].
+    VELOX_ASSERT_THROW(contains("[6, null]", data), kErrorMessage);
+    ASSERT_FALSE(contains("[6, null]", data, true));
+    // [3, null] = [3, null] is true in $internal$contains.
+    ASSERT_TRUE(contains("[3, null]", data, true));
+  }
+
+  {
+    // Null at the beginning of the array.
+    // data is [[null, 3]].
+    const auto data =
+        makeNullableNestedArrayVector<int32_t>({{{{{std::nullopt, 3}}}}});
+
+    // [null] = [null, 3] is false.
+    ASSERT_FALSE(contains("[null]", data));
+    ASSERT_FALSE(contains("[null]", data, true));
+    //  [null, 4] = [null, 3] is false.
+    ASSERT_FALSE(contains("[null, 4]", data));
+    ASSERT_FALSE(contains("[null, 4]", data, true));
+    //  [null, 4] = [1, 1] is false.
+    ASSERT_FALSE(contains("[1, 1]", data));
+    ASSERT_FALSE(contains("[1, 1]", data, true));
+
+    // [null, 3] = [null, 3] is indeterminate.
+    VELOX_ASSERT_THROW(contains("[null, 3]", data), kErrorMessage);
+    // [null, 3] = [null, null] is indeterminate.
+    VELOX_ASSERT_THROW(contains("[null, null]", data), kErrorMessage);
+    ASSERT_FALSE(contains("[null, null]", data, true));
+    // [null, 3] = [null, 3] is true in $internal$contains.
+    ASSERT_TRUE(contains("[null, 3]", data, true));
+  }
+}
+
+TEST_F(ArrayContainsTest, rowCheckNulls) {
+  facebook::velox::functions::prestosql::registerInternalFunctions();
+
+  const auto baseVector = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+      makeNullableFlatVector<int32_t>({1, 2, std::nullopt, 4, 5, 6}),
+  });
+  const auto data = makeArrayVector({0, 3}, baseVector);
+
+  auto contains = [&](const std::vector<std::optional<int32_t>>& search,
+                      bool internal = false) {
+    const auto searchBase = makeRowVector({
+        makeNullableFlatVector<int32_t>({search.at(0)}),
+        makeNullableFlatVector<int32_t>({search.at(1)}),
+    });
+    const auto searchConstant =
+        BaseVector::wrapInConstant(data->size(), 0, searchBase);
+    std::string call = internal ? "\"$internal$contains\"" : "contains";
+    const auto result = evaluate(
+        fmt::format("{}(c0, c1)", call), makeRowVector({data, searchConstant}));
+    return result->asFlatVector<bool>()->valueAt(0);
+  };
+
+  static const std::string kErrorMessage =
+      "contains does not support arrays with elements that contain null";
+  // No null equal.
+  ASSERT_FALSE(contains({7, std::nullopt}));
+  ASSERT_FALSE(contains({7, std::nullopt}, true));
+  // Null equal, (3, null) vs (3, 3).
+  VELOX_ASSERT_THROW(contains({3, 3}), kErrorMessage);
+  ASSERT_FALSE(contains({3, 3}, true));
+  // Null equal, (6, 6) vs (6, null).
+  VELOX_ASSERT_THROW(contains({6, std::nullopt}), kErrorMessage);
+  ASSERT_FALSE(contains({6, std::nullopt}, true));
+  // (3, null) = (3, null) is true in $internal$contains.
+  ASSERT_TRUE(contains({3, std::nullopt}, true));
+}
+
+TEST_F(ArrayContainsTest, floatNaNs) {
+  testFloatingPointNaNs<float>();
+  testFloatingPointNaNs<double>();
+}
 } // namespace
diff --git a/velox/functions/prestosql/tests/ArrayCumSumTest.cpp b/velox/functions/prestosql/tests/ArrayCumSumTest.cpp
new file mode 100644
index 0000000000000..11cdd3d2879aa
--- /dev/null
+++ b/velox/functions/prestosql/tests/ArrayCumSumTest.cpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <optional>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::functions::test;
+
+namespace {
+class ArrayCumSumTest : public FunctionBaseTest {
+ protected:
+  template <typename T>
+  void testArrayCumSum(const VectorPtr& expected, const VectorPtr& input) {
+    auto result = evaluate("array_cum_sum(c0)", makeRowVector({input}));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(ArrayCumSumTest, bigint) {
+  auto input = makeNullableArrayVector<int64_t>(
+      {{},
+       {10000, 1000010000, 100001000010000},
+       {-976543210987654321, std::nullopt, std::numeric_limits<int64_t>::max()},
+       {std::nullopt, 100001000010000}});
+  auto expected = makeNullableArrayVector<int64_t>(
+      {{},
+       {10000, 1000020000, 100002000030000},
+       {-976543210987654321, std::nullopt, std::nullopt},
+       {std::nullopt, std::nullopt}});
+  testArrayCumSum<int64_t>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, integer) {
+  auto input = makeNullableArrayVector<int32_t>(
+      {{},
+       {1000, 10001000, 1010001000},
+       {-976543210, std::nullopt, std::numeric_limits<int32_t>::max()},
+       {std::nullopt, 1010001000}});
+  auto expected = makeNullableArrayVector<int32_t>(
+      {{},
+       {1000, 10002000, 1020003000},
+       {-976543210, std::nullopt, std::nullopt},
+       {std::nullopt, std::nullopt}});
+  testArrayCumSum<int32_t>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, smallint) {
+  auto input = makeNullableArrayVector<int16_t>(
+      {{},
+       {10, 100, 10000},
+       {-9876, std::nullopt, std::numeric_limits<int16_t>::max()},
+       {std::nullopt, 10000}});
+  auto expected = makeNullableArrayVector<int16_t>(
+      {{},
+       {10, 110, 10110},
+       {-9876, std::nullopt, std::nullopt},
+       {std::nullopt, std::nullopt}});
+  testArrayCumSum<int16_t>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, tinyint) {
+  auto input = makeNullableArrayVector<int8_t>(
+      {{},
+       {1, 2, 4},
+       {-99, std::nullopt, std::numeric_limits<int8_t>::max()},
+       {std::nullopt, 4}});
+  auto expected = makeNullableArrayVector<int8_t>(
+      {{},
+       {1, 3, 7},
+       {-99, std::nullopt, std::nullopt},
+       {std::nullopt, std::nullopt}});
+  testArrayCumSum<int8_t>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, real) {
+  auto input = makeNullableArrayVector<float>(
+      {{},
+       {1, 2, 3},
+       {-9, std::nullopt, std::numeric_limits<float>::max()},
+       {std::nullopt, 3}});
+  auto expected = makeNullableArrayVector<float>(
+      {{},
+       {1, 3, 6},
+       {-9, std::nullopt, std::nullopt},
+       {std::nullopt, std::nullopt}});
+  testArrayCumSum<float>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, double) {
+  auto input = makeNullableArrayVector<double>(
+      {{},
+       {1, 2, 3},
+       {-9, std::nullopt, std::numeric_limits<double>::max()},
+       {std::nullopt, 3}});
+  auto expected = makeNullableArrayVector<double>(
+      {{},
+       {1, 3, 6},
+       {-9, std::nullopt, std::nullopt},
+       {std::nullopt, std::nullopt}});
+  testArrayCumSum<double>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, bigintOverflow) {
+  constexpr int64_t kMin = std::numeric_limits<int64_t>::min();
+  constexpr int64_t kMax = std::numeric_limits<int64_t>::max();
+
+  // Overflow on 1 + kMax.
+  auto input = makeNullableArrayVector<int64_t>({{1, kMax, 2, 3}});
+  VELOX_ASSERT_THROW(
+      evaluate("array_cum_sum(c0)", makeRowVector({input})),
+      "integer overflow: 1 + 9223372036854775807");
+
+  // Overflow on -1 + kMin.
+  input = makeNullableArrayVector<int64_t>({{-1, kMin, -2, -3}});
+  VELOX_ASSERT_THROW(
+      evaluate("array_cum_sum(c0)", makeRowVector({input})),
+      "integer overflow: -1 + -9223372036854775808");
+
+  // Overflow for array containing consecutive kMin values.
+  input = makeNullableArrayVector<int64_t>({{kMax, kMin, kMin}});
+  VELOX_ASSERT_THROW(
+      evaluate("array_cum_sum(c0)", makeRowVector({input})),
+      "integer overflow: -1 + -9223372036854775808");
+
+  // No overflow when function is called on alternating kMax, kMin values.
+  input = makeNullableArrayVector<int64_t>(
+      {{kMax, kMin, kMax, kMin},
+       {kMax, kMin},
+       {kMax, kMin, kMax, kMin, kMax, kMin}});
+  auto expected = makeNullableArrayVector<int64_t>(
+      {{kMax, -1, kMax - 1, -2},
+       {kMax, -1},
+       {kMax, -1, kMax - 1, -2, kMax - 2, -3}});
+  testArrayCumSum<int64_t>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, doubleLimits) {
+  constexpr double kInf = std::numeric_limits<double>::infinity();
+  constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
+  constexpr double kLowest = std::numeric_limits<double>::lowest();
+  constexpr double kMax = std::numeric_limits<double>::max();
+
+  auto input = makeNullableArrayVector<double>(
+      {{1, kInf, 123.456},
+       {1, kNan, 123.456},
+       {1, kLowest, 123.456},
+       {1, kMax, 123.456},
+       {kLowest, kMax, 123.456},
+       {kMax, kLowest, 123.456},
+       {1, kMax, kInf},
+       {1, kLowest, kInf},
+       {kLowest, kNan, 5},
+       {kMax, kNan, 5}});
+  auto expected = makeNullableArrayVector<double>(
+      {{1, kInf, kInf},
+       {1, kNan, kNan},
+       {1, kLowest, kLowest},
+       {1, kMax, kMax},
+       {kLowest, 0, 123.456},
+       {kMax, 0, 123.456},
+       {1, kMax, kInf},
+       {1, kLowest, kInf},
+       {kLowest, kNan, kNan},
+       {kMax, kNan, kNan}});
+  testArrayCumSum<double>(expected, input);
+}
+} // namespace
diff --git a/velox/functions/prestosql/tests/ArrayDistinctTest.cpp b/velox/functions/prestosql/tests/ArrayDistinctTest.cpp
index 964706109a2a0..796085daac99a 100644
--- a/velox/functions/prestosql/tests/ArrayDistinctTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayDistinctTest.cpp
@@ -105,6 +105,8 @@ class ArrayDistinctTest : public FunctionBaseTest {
         {0.0, -10.0},
         {std::numeric_limits<T>::quiet_NaN(),
          std::numeric_limits<T>::quiet_NaN()},
+        {std::numeric_limits<T>::quiet_NaN(),
+         std::numeric_limits<T>::signaling_NaN()},
         {std::numeric_limits<T>::signaling_NaN(),
          std::numeric_limits<T>::signaling_NaN()},
         {std::numeric_limits<T>::lowest(), std::numeric_limits<T>::lowest()},
@@ -134,10 +136,10 @@ class ArrayDistinctTest : public FunctionBaseTest {
         {0.0},
         {0.0, 10.0},
         {0.0, -10.0},
-        {std::numeric_limits<T>::quiet_NaN(),
-         std::numeric_limits<T>::quiet_NaN()},
-        {std::numeric_limits<T>::signaling_NaN(),
-         std::numeric_limits<T>::signaling_NaN()},
+        {std::numeric_limits<T>::quiet_NaN()},
+        // quiet NaN and signaling NaN are treated equal
+        {std::numeric_limits<T>::quiet_NaN()},
+        {std::numeric_limits<T>::signaling_NaN()},
         {std::numeric_limits<T>::lowest()},
         {std::nullopt},
         {1.0001, -2.0, 3.03, std::nullopt, 4.00004},
@@ -277,6 +279,23 @@ TEST_F(ArrayDistinctTest, stringArrays) {
   testExpr(expected, "array_distinct(C0)", {array});
 }
 
+TEST_F(ArrayDistinctTest, complexTypeArrays) {
+  auto input = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3], [1, 2], [1, 2, 3], [], [1, 2, 3], [1], [1, 2, 3], [2], []]",
+      "[[null, 2, 3], [1, 2], [1, 2, 3], [], [null, 2, 3], [1], [1, 2, 3], [2], null]",
+      "[[1, null, 3], [1, null, 3], [1, null, 3], null, [1, null, 3], [1, null, 3]]",
+  });
+
+  auto result = evaluate("array_distinct(c0)", makeRowVector({input}));
+  auto expected = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3], [1, 2], [], [1], [2]]",
+      "[[null, 2, 3], [1, 2], [1, 2, 3], [], [1], [2], null]",
+      "[[1, null, 3], null]",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
 TEST_F(ArrayDistinctTest, nonContiguousRows) {
   auto c0 = makeFlatVector<int32_t>(4, [](auto row) { return row; });
   auto c1 = makeArrayVector<int32_t>({
@@ -329,3 +348,24 @@ TEST_F(ArrayDistinctTest, constant) {
   expected = makeConstantArray<int64_t>(size, {6});
   assertEqualVectors(expected, result);
 }
+
+TEST_F(ArrayDistinctTest, unknownType) {
+  // array_distinct(ARRAY[]) -> []
+  auto emptyArrayVector = makeArrayVector<UnknownValue>({{}});
+  auto result =
+      evaluate("array_distinct(c0)", makeRowVector({emptyArrayVector}));
+  assertEqualVectors(emptyArrayVector, result);
+
+  // array_distinct(ARRAY[null, null, null]) -> [null]
+  // array_distinct(ARRAY[]) -> []
+  // array_distinct(ARRAY[null]) -> [null]
+  auto nullArrayVector = makeArrayVector(
+      {0, 3, 3},
+      makeNullableFlatVector<UnknownValue>(
+          {std::nullopt, std::nullopt, std::nullopt, std::nullopt}));
+  auto expected = makeArrayVector(
+      {0, 1, 1},
+      makeNullableFlatVector<UnknownValue>({std::nullopt, std::nullopt}));
+  result = evaluate("array_distinct(c0)", makeRowVector({nullArrayVector}));
+  assertEqualVectors(expected, result);
+}
diff --git a/velox/functions/prestosql/tests/ArrayDuplicatesTest.cpp b/velox/functions/prestosql/tests/ArrayDuplicatesTest.cpp
index 3bf1edf7cff97..0504cbad15de3 100644
--- a/velox/functions/prestosql/tests/ArrayDuplicatesTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayDuplicatesTest.cpp
@@ -36,7 +36,7 @@ class ArrayDuplicatesTest : public FunctionBaseTest {
   }
 
   // Execute test for bigint type.
-  void testBigint() {
+  void testBigint(const std::string& funcName) {
     auto array = makeNullableArrayVector<int64_t>({
         {},
         {1,
@@ -72,7 +72,123 @@ class ArrayDuplicatesTest : public FunctionBaseTest {
         {std::nullopt, 0, 1, std::numeric_limits<int64_t>::max()},
     });
 
-    testExpr(expected, "array_duplicates(C0)", {array});
+    testExpr(expected, fmt::format("{}(C0)", funcName), {array});
+  }
+
+  void testinlineStringArrays(const std::string& funcName) {
+    using S = StringView;
+
+    auto array = makeNullableArrayVector<StringView>({
+        {},
+        {S("")},
+        {std::nullopt},
+        {S("a"), S("b")},
+        {S("a"), std::nullopt, S("b")},
+        {S("a"), S("a")},
+        {S("b"), S("a"), S("b"), S("a"), S("a")},
+        {std::nullopt, std::nullopt},
+        {S("b"), std::nullopt, S("a"), S("a"), std::nullopt, S("b")},
+    });
+
+    auto expected = makeNullableArrayVector<StringView>({
+        {},
+        {},
+        {},
+        {},
+        {},
+        {S("a")},
+        {S("a"), S("b")},
+        {std::nullopt},
+        {std::nullopt, S("a"), S("b")},
+    });
+
+    testExpr(expected, fmt::format("{}(C0)", funcName), {array});
+  }
+
+  void teststringArrays(const std::string& funcName) {
+    using S = StringView;
+
+    auto array = makeNullableArrayVector<StringView>({
+        {S("red shiny car ahead"), S("blue clear sky above")},
+        {S("blue clear sky above"),
+         S("yellow rose flowers"),
+         std::nullopt,
+         S("blue clear sky above"),
+         S("orange beautiful sunset")},
+        {
+            S("red shiny car ahead"),
+            std::nullopt,
+            S("purple is an elegant color"),
+            S("red shiny car ahead"),
+            S("green plants make us happy"),
+            S("purple is an elegant color"),
+            std::nullopt,
+            S("purple is an elegant color"),
+        },
+    });
+
+    auto expected = makeNullableArrayVector<StringView>({
+        {},
+        {S("blue clear sky above")},
+        {std::nullopt,
+         S("purple is an elegant color"),
+         S("red shiny car ahead")},
+    });
+
+    testExpr(expected, fmt::format("{}(C0)", funcName), {array});
+  }
+
+  void testNonContiguousRows(const std::string& funcName) {
+    auto c0 = makeFlatVector<int64_t>(4, [](auto row) { return row; });
+    auto c1 = makeArrayVector<int64_t>({
+        {1, 1, 2, 3, 3},
+        {1, 1, 2, 3, 4, 4},
+        {1, 1, 2, 3, 4, 5, 5},
+        {1, 1, 2, 3, 3, 4, 5, 6, 6},
+    });
+
+    auto c2 = makeArrayVector<int64_t>({
+        {0, 0, 1, 1, 2, 3, 3},
+        {0, 0, 1, 1, 2, 3, 4, 4},
+        {0, 0, 1, 1, 2, 3, 4, 5, 5},
+        {0, 0, 1, 1, 2, 3, 4, 5, 6, 6},
+    });
+
+    auto expected = makeArrayVector<int64_t>({
+        {1, 3},
+        {0, 1, 4},
+        {1, 5},
+        {0, 1, 6},
+    });
+
+    auto result = evaluate<ArrayVector>(
+        fmt::format("if(c0 % 2 = 0, {}(c1), {}(c2))", funcName, funcName),
+        makeRowVector({c0, c1, c2}));
+    assertEqualVectors(expected, result);
+  }
+
+  void testConstant(const std::string& funcName) {
+    vector_size_t size = 1'000;
+    auto data =
+        makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 4, 5}, {6, 6, 6, 6}});
+
+    auto evaluateConstant = [&](vector_size_t row, const VectorPtr& vector) {
+      return evaluate(
+          fmt::format("{}(c0)", funcName),
+          makeRowVector({BaseVector::wrapInConstant(size, row, vector)}));
+    };
+
+    auto result = evaluateConstant(0, data);
+    auto expected = makeConstantArray<int64_t>(size, {});
+    assertEqualVectors(expected, result);
+
+    result = evaluateConstant(1, data);
+    expected = makeConstantArray<int64_t>(size, {4, 5});
+    assertEqualVectors(expected, result);
+
+    result = evaluateConstant(2, data);
+    expected = makeConstantArray<int64_t>(size, {6});
+    assertEqualVectors(expected, result);
   }
 };
 
@@ -80,120 +196,28 @@ class ArrayDuplicatesTest : public FunctionBaseTest {
 
 // Test integer arrays.
 TEST_F(ArrayDuplicatesTest, integerArrays) {
-  testBigint();
+  testBigint("array_duplicates");
+  testBigint("array_dupes");
 }
 
 // Test inline (short) strings.
 TEST_F(ArrayDuplicatesTest, inlineStringArrays) {
-  using S = StringView;
-
-  auto array = makeNullableArrayVector<StringView>({
-      {},
-      {S("")},
-      {std::nullopt},
-      {S("a"), S("b")},
-      {S("a"), std::nullopt, S("b")},
-      {S("a"), S("a")},
-      {S("b"), S("a"), S("b"), S("a"), S("a")},
-      {std::nullopt, std::nullopt},
-      {S("b"), std::nullopt, S("a"), S("a"), std::nullopt, S("b")},
-  });
-
-  auto expected = makeNullableArrayVector<StringView>({
-      {},
-      {},
-      {},
-      {},
-      {},
-      {S("a")},
-      {S("a"), S("b")},
-      {std::nullopt},
-      {std::nullopt, S("a"), S("b")},
-  });
-
-  testExpr(expected, "array_duplicates(C0)", {array});
+  testinlineStringArrays("array_duplicates");
+  testinlineStringArrays("array_dupes");
 }
 
 // Test non-inline (> 12 character length) strings.
 TEST_F(ArrayDuplicatesTest, stringArrays) {
-  using S = StringView;
-
-  auto array = makeNullableArrayVector<StringView>({
-      {S("red shiny car ahead"), S("blue clear sky above")},
-      {S("blue clear sky above"),
-       S("yellow rose flowers"),
-       std::nullopt,
-       S("blue clear sky above"),
-       S("orange beautiful sunset")},
-      {
-          S("red shiny car ahead"),
-          std::nullopt,
-          S("purple is an elegant color"),
-          S("red shiny car ahead"),
-          S("green plants make us happy"),
-          S("purple is an elegant color"),
-          std::nullopt,
-          S("purple is an elegant color"),
-      },
-  });
-
-  auto expected = makeNullableArrayVector<StringView>({
-      {},
-      {S("blue clear sky above")},
-      {std::nullopt, S("purple is an elegant color"), S("red shiny car ahead")},
-  });
-
-  testExpr(expected, "array_duplicates(C0)", {array});
+  teststringArrays("array_duplicates");
+  teststringArrays("array_dupes");
 }
 
 TEST_F(ArrayDuplicatesTest, nonContiguousRows) {
-  auto c0 = makeFlatVector<int64_t>(4, [](auto row) { return row; });
-  auto c1 = makeArrayVector<int64_t>({
-      {1, 1, 2, 3, 3},
-      {1, 1, 2, 3, 4, 4},
-      {1, 1, 2, 3, 4, 5, 5},
-      {1, 1, 2, 3, 3, 4, 5, 6, 6},
-  });
-
-  auto c2 = makeArrayVector<int64_t>({
-      {0, 0, 1, 1, 2, 3, 3},
-      {0, 0, 1, 1, 2, 3, 4, 4},
-      {0, 0, 1, 1, 2, 3, 4, 5, 5},
-      {0, 0, 1, 1, 2, 3, 4, 5, 6, 6},
-  });
-
-  auto expected = makeArrayVector<int64_t>({
-      {1, 3},
-      {0, 1, 4},
-      {1, 5},
-      {0, 1, 6},
-  });
-
-  auto result = evaluate<ArrayVector>(
-      "if(c0 % 2 = 0, array_duplicates(c1), array_duplicates(c2))",
-      makeRowVector({c0, c1, c2}));
-  assertEqualVectors(expected, result);
+  testNonContiguousRows("array_duplicates");
+  testNonContiguousRows("array_dupes");
 }
 
 TEST_F(ArrayDuplicatesTest, constant) {
-  vector_size_t size = 1'000;
-  auto data = makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 4, 5}, {6, 6, 6, 6}});
-
-  auto evaluateConstant = [&](vector_size_t row, const VectorPtr& vector) {
-    return evaluate(
-        "array_duplicates(c0)",
-        makeRowVector({BaseVector::wrapInConstant(size, row, vector)}));
-  };
-
-  auto result = evaluateConstant(0, data);
-  auto expected = makeConstantArray<int64_t>(size, {});
-  assertEqualVectors(expected, result);
-
-  result = evaluateConstant(1, data);
-  expected = makeConstantArray<int64_t>(size, {4, 5});
-  assertEqualVectors(expected, result);
-
-  result = evaluateConstant(2, data);
-  expected = makeConstantArray<int64_t>(size, {6});
-  assertEqualVectors(expected, result);
+  testConstant("array_duplicates");
+  testConstant("array_dupes");
 }
diff --git a/velox/functions/prestosql/tests/ArrayExceptTest.cpp b/velox/functions/prestosql/tests/ArrayExceptTest.cpp
index 9fa40a3093b43..2a23e14788f3f 100644
--- a/velox/functions/prestosql/tests/ArrayExceptTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayExceptTest.cpp
@@ -24,6 +24,9 @@ using namespace facebook::velox::functions::test;
 
 namespace {
 
+template <typename TKey, typename TValue>
+using Pair = std::pair<TKey, std::optional<TValue>>;
+
 class ArrayExceptTest : public FunctionBaseTest {
  protected:
   void testExpr(
@@ -107,6 +110,8 @@ class ArrayExceptTest : public FunctionBaseTest {
          std::numeric_limits<T>::infinity(),
          std::numeric_limits<T>::max()},
         {std::numeric_limits<T>::quiet_NaN(), 9.0009},
+        {std::numeric_limits<T>::quiet_NaN(), 9.0009},
+        {std::numeric_limits<T>::quiet_NaN(), 9.0009},
     });
     auto array2 = makeNullableArrayVector<T>({
         {1.0, -2.0, 4.0},
@@ -114,24 +119,29 @@ class ArrayExceptTest : public FunctionBaseTest {
         {1.0001, -2.02, std::numeric_limits<T>::max(), 8.00099},
         {9.0009, std::numeric_limits<T>::infinity()},
         {9.0009, std::numeric_limits<T>::quiet_NaN()},
-    });
-
-    auto expected = makeNullableArrayVector<T>({
-        {1.0001, 3.03, std::nullopt, 4.00004},
-        {2.02, 1},
-        {8.0001, std::nullopt},
-        {std::numeric_limits<T>::max()},
         {std::numeric_limits<T>::quiet_NaN()},
+        // quiet NaN and signaling NaN are treated equal
+        {std::numeric_limits<T>::signaling_NaN()},
     });
+
+    auto expected = makeNullableArrayVector<T>(
+        {{1.0001, 3.03, std::nullopt, 4.00004},
+         {2.02, 1},
+         {8.0001, std::nullopt},
+         {std::numeric_limits<T>::max()},
+         {},
+         {9.0009},
+         {9.0009}});
     testExpr(expected, "array_except(C0, C1)", {array1, array2});
 
-    expected = makeNullableArrayVector<T>({
-        {1.0, 4.0},
-        {2.0199, 1.000001},
-        {1.0001, -2.02, 8.00099},
-        {},
-        {std::numeric_limits<T>::quiet_NaN()},
-    });
+    expected = makeNullableArrayVector<T>(
+        {{1.0, 4.0},
+         {2.0199, 1.000001},
+         {1.0001, -2.02, 8.00099},
+         {},
+         {},
+         {},
+         {}});
     testExpr(expected, "array_except(C1, C0)", {array1, array2});
   }
 };
@@ -271,6 +281,67 @@ TEST_F(ArrayExceptTest, varbinary) {
   testExpr(expected, "array_except(c0, c1)", {right, left});
 }
 
+TEST_F(ArrayExceptTest, complexTypeArray) {
+  auto left = makeNestedArrayVectorFromJson<int32_t>({
+      "[null, [1, 2, 3], [null, null]]",
+      "[[1], [2], []]",
+      "[[1, null, 3]]",
+      "[[1, null, 3]]",
+  });
+
+  auto right = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[1]]",
+      "[[1, null, 3], [1, 2]]",
+      "[[1, null, 3, null]]",
+  });
+
+  auto expected = makeNestedArrayVectorFromJson<int32_t>({
+      "[null, [null, null]]",
+      "[[2], []]",
+      "[]",
+      "[[1, null, 3]]",
+  });
+  testExpr(expected, "array_except(c0, c1)", {left, right});
+}
+
+TEST_F(ArrayExceptTest, complexTypeMap) {
+  std::vector<Pair<StringView, int64_t>> a{{"blue", 1}, {"red", 2}};
+  std::vector<Pair<StringView, int64_t>> b{{"blue", 2}, {"red", 2}};
+  std::vector<Pair<StringView, int64_t>> c{{"green", std::nullopt}};
+  std::vector<Pair<StringView, int64_t>> d{{"yellow", 4}, {"purple", 5}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> leftData{
+      {b, a}, {b}, {c, a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> rightData{
+      {a, b}, {}, {a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> expectedData{
+      {}, {b}, {c}};
+
+  auto left = makeArrayOfMapVector<StringView, int64_t>(leftData);
+  auto right = makeArrayOfMapVector<StringView, int64_t>(rightData);
+  auto expected = makeArrayOfMapVector<StringView, int64_t>(expectedData);
+
+  testExpr(expected, "array_except(c0, c1)", {left, right});
+}
+
+TEST_F(ArrayExceptTest, complexTypeRow) {
+  RowTypePtr rowType = ROW({INTEGER(), VARCHAR()});
+
+  using ArrayOfRow = std::vector<std::optional<std::tuple<int, std::string>>>;
+  std::vector<ArrayOfRow> leftData = {
+      {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+      {{{1, "red"}}, {{2, "blue"}}, {}},
+      {{{1, "red"}}, std::nullopt, std::nullopt}};
+  std::vector<ArrayOfRow> rightData = {
+      {{{2, "blue"}}, {{1, "red"}}}, {{}, {{1, "green"}}}, {{{1, "red"}}}};
+  std::vector<ArrayOfRow> expectedData = {
+      {{{3, "green"}}}, {{{1, "red"}}, {{2, "blue"}}}, {std::nullopt}};
+  auto left = makeArrayOfRowVector(leftData, rowType);
+  auto right = makeArrayOfRowVector(rightData, rowType);
+  auto expected = makeArrayOfRowVector(expectedData, rowType);
+  testExpr(expected, "array_except(c0, c1)", {left, right});
+}
+
 // When one of the arrays is constant.
 TEST_F(ArrayExceptTest, constant) {
   auto array1 = makeNullableArrayVector<int32_t>({
@@ -314,10 +385,7 @@ TEST_F(ArrayExceptTest, constant) {
 }
 
 TEST_F(ArrayExceptTest, dictionaryEncodedElementsInConstant) {
-  exec::registerVectorFunction(
-      "testing_dictionary_array_elements",
-      test::TestingDictionaryArrayElementsFunction::signatures(),
-      std::make_unique<test::TestingDictionaryArrayElementsFunction>());
+  TestingDictionaryArrayElementsFunction::registerFunction();
 
   auto array = makeArrayVector<int64_t>({{1, 3}, {2, 5}, {0, 6}});
   auto expected = makeArrayVector<int64_t>({{}, {5}, {6}});
diff --git a/velox/functions/prestosql/tests/ArrayHasDuplicatesTest.cpp b/velox/functions/prestosql/tests/ArrayHasDuplicatesTest.cpp
index 4cc8199c92d3f..0f85f27c89521 100644
--- a/velox/functions/prestosql/tests/ArrayHasDuplicatesTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayHasDuplicatesTest.cpp
@@ -34,114 +34,139 @@ class ArrayHasDuplicatesTest : public FunctionBaseTest {
         evaluate<SimpleVector<bool>>(expression, makeRowVector(input));
     assertEqualVectors(expected, result);
   }
+
+  void testBigInts(const std::string& funcName) {
+    auto array = makeNullableArrayVector<int64_t>({
+        {},
+        {1,
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max()},
+        {std::nullopt},
+        {1, 2, 3},
+        {2, 1, 1, -2},
+        {1, 1, 1},
+        {-1, std::nullopt, -1, -1},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {1, -2, -2, 8, -2, 4, 8, 1},
+        {std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         1,
+         std::nullopt,
+         0,
+         1,
+         std::nullopt,
+         0},
+    });
+
+    auto expected = makeNullableFlatVector<bool>(
+        {false, false, false, false, true, true, true, true, true, true});
+
+    testExpr(expected, fmt::format("{}(C0)", funcName), {array});
+  }
+
+  void testInlineStrings(const std::string& funcName) {
+    using S = StringView;
+
+    auto array = makeNullableArrayVector<StringView>({
+        {},
+        {""_sv},
+        {std::nullopt},
+        {S("a"), S("b")},
+        {S("a"), std::nullopt, S("b")},
+        {S("a"), S("a")},
+        {S("b"), S("a"), S("b"), S("a"), S("a")},
+        {std::nullopt, std::nullopt},
+        {S("b"), std::nullopt, S("a"), S("a"), std::nullopt, S("b")},
+    });
+
+    auto expected = makeFlatVector<bool>(
+        {false, false, false, false, false, true, true, true, true});
+
+    testExpr(expected, fmt::format("{}(C0)", funcName), {array});
+  }
+
+  void testLongStrings(const std::string& funcName) {
+    using S = StringView;
+
+    auto array = makeNullableArrayVector<StringView>({
+        {S("red shiny car ahead"), S("blue clear sky above")},
+        {S("blue clear sky above"),
+         S("yellow rose flowers"),
+         std::nullopt,
+         S("blue clear sky above"),
+         S("orange beautiful sunset")},
+        {
+            S("red shiny car ahead"),
+            std::nullopt,
+            S("purple is an elegant color"),
+            S("red shiny car ahead"),
+            S("green plants make us happy"),
+            S("purple is an elegant color"),
+            std::nullopt,
+            S("purple is an elegant color"),
+        },
+    });
+    auto expected = makeFlatVector<bool>({false, true, true});
+    testExpr(expected, fmt::format("{}(C0)", funcName), {array});
+  }
+
+  void testNullFreeBigints(const std::string& funcName) {
+    auto array = makeArrayVector<int64_t>({
+        {1,
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max()},
+        {2, 1, 1, -2},
+        {1, 1, 1},
+    });
+
+    auto expected = makeNullableFlatVector<bool>({false, true, true});
+
+    testExpr(expected, fmt::format("{}(C0)", funcName), {array});
+  }
+
+  void testNullFreeStrings(const std::string& funcName) {
+    using S = StringView;
+
+    auto array = makeArrayVector<StringView>(
+        {{S("red shiny car ahead"), S("blue clear sky above")},
+         {S("red shiny car ahead"),
+          S("blue clear sky above"),
+          S("blue clear sky above")},
+         {S("a"), S("b")},
+         {S("a"), S("b"), S("b")}
+
+        });
+    auto expected = makeFlatVector<bool>({false, true, false, true});
+    testExpr(expected, fmt::format("{}(C0)", funcName), {array});
+  }
 };
 
 } // namespace
 
 // Test bigint arrays.
 TEST_F(ArrayHasDuplicatesTest, bigints) {
-  auto array = makeNullableArrayVector<int64_t>({
-      {},
-      {1,
-       std::numeric_limits<int64_t>::min(),
-       std::numeric_limits<int64_t>::max()},
-      {std::nullopt},
-      {1, 2, 3},
-      {2, 1, 1, -2},
-      {1, 1, 1},
-      {-1, std::nullopt, -1, -1},
-      {std::nullopt, std::nullopt, std::nullopt},
-      {1, -2, -2, 8, -2, 4, 8, 1},
-      {std::numeric_limits<int64_t>::max(),
-       std::numeric_limits<int64_t>::max(),
-       1,
-       std::nullopt,
-       0,
-       1,
-       std::nullopt,
-       0},
-  });
-
-  auto expected = makeNullableFlatVector<bool>(
-      {false, false, false, false, true, true, true, true, true, true});
-
-  testExpr(expected, "array_has_duplicates(C0)", {array});
+  testBigInts("array_has_duplicates");
+  testBigInts("array_has_dupes");
 }
 
 // Test inline (short) strings.
 TEST_F(ArrayHasDuplicatesTest, inlineStrings) {
-  using S = StringView;
-
-  auto array = makeNullableArrayVector<StringView>({
-      {},
-      {""_sv},
-      {std::nullopt},
-      {S("a"), S("b")},
-      {S("a"), std::nullopt, S("b")},
-      {S("a"), S("a")},
-      {S("b"), S("a"), S("b"), S("a"), S("a")},
-      {std::nullopt, std::nullopt},
-      {S("b"), std::nullopt, S("a"), S("a"), std::nullopt, S("b")},
-  });
-
-  auto expected = makeFlatVector<bool>(
-      {false, false, false, false, false, true, true, true, true});
-
-  testExpr(expected, "array_has_duplicates(C0)", {array});
+  testInlineStrings("array_has_duplicates");
+  testInlineStrings("array_has_dupes");
 }
 
 // Test non-inline (> 12 character length) strings.
 TEST_F(ArrayHasDuplicatesTest, longStrings) {
-  using S = StringView;
-
-  auto array = makeNullableArrayVector<StringView>({
-      {S("red shiny car ahead"), S("blue clear sky above")},
-      {S("blue clear sky above"),
-       S("yellow rose flowers"),
-       std::nullopt,
-       S("blue clear sky above"),
-       S("orange beautiful sunset")},
-      {
-          S("red shiny car ahead"),
-          std::nullopt,
-          S("purple is an elegant color"),
-          S("red shiny car ahead"),
-          S("green plants make us happy"),
-          S("purple is an elegant color"),
-          std::nullopt,
-          S("purple is an elegant color"),
-      },
-  });
-  auto expected = makeFlatVector<bool>({false, true, true});
-  testExpr(expected, "array_has_duplicates(C0)", {array});
+  testLongStrings("array_has_duplicates");
+  testLongStrings("array_has_dupes");
 }
 
 TEST_F(ArrayHasDuplicatesTest, nullFreeBigints) {
-  auto array = makeArrayVector<int64_t>({
-      {1,
-       std::numeric_limits<int64_t>::min(),
-       std::numeric_limits<int64_t>::max()},
-      {2, 1, 1, -2},
-      {1, 1, 1},
-  });
-
-  auto expected = makeNullableFlatVector<bool>({false, true, true});
-
-  testExpr(expected, "array_has_duplicates(C0)", {array});
+  testNullFreeBigints("array_has_duplicates");
+  testNullFreeBigints("array_has_dupes");
 }
 
 TEST_F(ArrayHasDuplicatesTest, nullFreeStrings) {
-  using S = StringView;
-
-  auto array = makeArrayVector<StringView>(
-      {{S("red shiny car ahead"), S("blue clear sky above")},
-       {S("red shiny car ahead"),
-        S("blue clear sky above"),
-        S("blue clear sky above")},
-       {S("a"), S("b")},
-       {S("a"), S("b"), S("b")}
-
-      });
-  auto expected = makeFlatVector<bool>({false, true, false, true});
-  testExpr(expected, "array_has_duplicates(C0)", {array});
+  testNullFreeStrings("array_has_duplicates");
+  testNullFreeStrings("array_has_dupes");
 }
diff --git a/velox/functions/prestosql/tests/ArrayIntersectTest.cpp b/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
index 9e466a6ccfbfd..3ae43b8acb815 100644
--- a/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
@@ -24,6 +24,9 @@ using namespace facebook::velox::functions::test;
 
 namespace {
 
+template <typename TKey, typename TValue>
+using Pair = std::pair<TKey, std::optional<TValue>>;
+
 class ArrayIntersectTest : public FunctionBaseTest {
  protected:
   void testExpr(
@@ -60,6 +63,7 @@ class ArrayIntersectTest : public FunctionBaseTest {
         {{3, 8, std::nullopt}},
         std::nullopt,
         {{1, 1, -2, -2, -2, 4, 8}},
+        {{}},
     });
     auto array2 = makeNullableArrayVector<T>({
         {1, -2, 4},
@@ -67,6 +71,7 @@ class ArrayIntersectTest : public FunctionBaseTest {
         {1, -2, 4},
         {1, 2},
         {1, -2, 4},
+        {{std::nullopt}},
     });
     auto expected = makeNullableArrayVector<T>({
         {{1, -2, 4}},
@@ -74,6 +79,7 @@ class ArrayIntersectTest : public FunctionBaseTest {
         {{}},
         std::nullopt,
         {{1, -2, 4}},
+        {{}},
     });
     testExpr(expected, "array_intersect(C0, C1)", {array1, array2});
     testExpr(expected, "array_intersect(C1, C0)", {array1, array2});
@@ -85,6 +91,7 @@ class ArrayIntersectTest : public FunctionBaseTest {
         {std::nullopt, std::nullopt, std::nullopt},
         {0, 0, 0},
         {8, 1, 8, 1},
+        {{1, std::nullopt}},
     });
     expected = makeNullableArrayVector<T>({
         {{}},
@@ -92,6 +99,7 @@ class ArrayIntersectTest : public FunctionBaseTest {
         {std::vector<std::optional<T>>{std::nullopt}},
         std::nullopt,
         {{1, 8}},
+        {{}},
     });
     testExpr(expected, "array_intersect(C0, C1)", {array1, array2});
   }
@@ -106,20 +114,24 @@ class ArrayIntersectTest : public FunctionBaseTest {
          std::numeric_limits<T>::infinity(),
          std::numeric_limits<T>::max()},
         {std::numeric_limits<T>::quiet_NaN(), 9.0009},
+        {std::numeric_limits<T>::quiet_NaN(), 9.0009},
     });
     auto array2 = makeNullableArrayVector<T>({
         {1.0, -2.0, 4.0},
         {std::numeric_limits<T>::min(), 2.0199, -2.001, 1.000001},
         {1.0001, -2.02, std::numeric_limits<T>::max(), 8.00099},
         {9.0009, std::numeric_limits<T>::infinity()},
-        {9.0009, std::numeric_limits<T>::quiet_NaN()},
+        {std::numeric_limits<T>::quiet_NaN()},
+        // quiet NaN and signaling NaN are treated equal
+        {std::numeric_limits<T>::signaling_NaN(), 9.0009},
     });
     auto expected = makeNullableArrayVector<T>({
         {-2.0},
         {std::numeric_limits<T>::min(), -2.001},
         {std::numeric_limits<T>::max()},
         {9.0009, std::numeric_limits<T>::infinity()},
-        {9.0009},
+        {std::numeric_limits<T>::quiet_NaN()},
+        {std::numeric_limits<T>::quiet_NaN(), 9.0009},
     });
 
     testExpr(expected, "array_intersect(C0, C1)", {array1, array2});
@@ -248,6 +260,62 @@ TEST_F(ArrayIntersectTest, varbinary) {
   testExpr(expected, "array_intersect(c0, c1)", {right, left});
 }
 
+TEST_F(ArrayIntersectTest, complexTypeArray) {
+  auto left = makeNestedArrayVectorFromJson<int32_t>({
+      "[null, [1, 2, 3], [null, null]]",
+      "[[1], [2], []]",
+      "[[1, null, 3]]",
+      "[[1, null, 3]]",
+  });
+
+  auto right = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[1]]",
+      "[[1, null, 3], [1, 2]]",
+      "[[1, null, 3, null]]",
+  });
+
+  auto expected = makeNestedArrayVectorFromJson<int32_t>(
+      {"[[1, 2, 3]]", "[[1]]", "[[1, null, 3]]", "[]"});
+  testExpr(expected, "array_intersect(c0, c1)", {left, right});
+}
+
+TEST_F(ArrayIntersectTest, complexTypeMap) {
+  std::vector<Pair<StringView, int64_t>> a{{"blue", 1}, {"red", 2}};
+  std::vector<Pair<StringView, int64_t>> b{{"green", std::nullopt}};
+  std::vector<Pair<StringView, int64_t>> c{{"yellow", 4}, {"purple", 5}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> leftData{
+      {b, a}, {b}, {c, a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> rightData{
+      {a, b}, {}, {a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> expectedData{
+      {b, a}, {}, {a}};
+
+  auto left = makeArrayOfMapVector<StringView, int64_t>(leftData);
+  auto right = makeArrayOfMapVector<StringView, int64_t>(rightData);
+  auto expected = makeArrayOfMapVector<StringView, int64_t>(expectedData);
+
+  testExpr(expected, "array_intersect(c0, c1)", {left, right});
+}
+
+TEST_F(ArrayIntersectTest, complexTypeRow) {
+  RowTypePtr rowType = ROW({INTEGER(), VARCHAR()});
+
+  using ArrayOfRow = std::vector<std::optional<std::tuple<int, std::string>>>;
+  std::vector<ArrayOfRow> leftData = {
+      {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+      {{{1, "red"}}, {{2, "blue"}}, {}},
+      {{{1, "red"}}, std::nullopt, std::nullopt}};
+  std::vector<ArrayOfRow> rightData = {
+      {{{2, "blue"}}, {{1, "red"}}}, {{}, {{1, "green"}}}, {{{1, "red"}}}};
+  std::vector<ArrayOfRow> expectedData = {
+      {{{1, "red"}}, {{2, "blue"}}}, {{}}, {{{1, "red"}}}};
+  auto left = makeArrayOfRowVector(leftData, rowType);
+  auto right = makeArrayOfRowVector(rightData, rowType);
+  auto expected = makeArrayOfRowVector(expectedData, rowType);
+  testExpr(expected, "array_intersect(c0, c1)", {left, right});
+}
+
 // When one of the arrays is constant.
 TEST_F(ArrayIntersectTest, constant) {
   auto array1 = makeNullableArrayVector<int32_t>({
diff --git a/velox/functions/prestosql/tests/ArrayJoinTest.cpp b/velox/functions/prestosql/tests/ArrayJoinTest.cpp
index 9beb86b50f37d..6d1fe8d1da048 100644
--- a/velox/functions/prestosql/tests/ArrayJoinTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayJoinTest.cpp
@@ -38,9 +38,14 @@ class ArrayJoinTest : public FunctionBaseTest {
   void testArrayJoinNoReplacement(
       std::vector<std::optional<T>> array,
       const StringView& delimiter,
-      const StringView& expected) {
+      const StringView& expected,
+      bool isDate = false) {
     auto arrayVector = makeNullableArrayVector(
         std::vector<std::vector<std::optional<T>>>{array});
+    if (isDate) {
+      arrayVector = makeNullableArrayVector(
+          std::vector<std::vector<std::optional<T>>>{array}, ARRAY(DATE()));
+    }
     auto delimiterVector = makeFlatVector<StringView>({delimiter});
     auto expectedVector = makeFlatVector<StringView>({expected});
     testExpr(
@@ -52,9 +57,14 @@ class ArrayJoinTest : public FunctionBaseTest {
       std::vector<std::optional<T>> array,
       const StringView& delimiter,
       const StringView& replacement,
-      const StringView& expected) {
+      const StringView& expected,
+      bool isDate = false) {
     auto arrayVector = makeNullableArrayVector(
         std::vector<std::vector<std::optional<T>>>{array});
+    if (isDate) {
+      arrayVector = makeNullableArrayVector(
+          std::vector<std::vector<std::optional<T>>>{array}, ARRAY(DATE()));
+    }
     auto delimiterVector = makeFlatVector<StringView>({delimiter});
     auto replacementVector = makeFlatVector<StringView>({replacement});
     auto expectedVector = makeFlatVector<StringView>({expected});
@@ -101,4 +111,53 @@ TEST_F(ArrayJoinTest, boolTest) {
       {true, std::nullopt, false}, ","_sv, "apple"_sv, "true,apple,false"_sv);
 }
 
+TEST_F(ArrayJoinTest, timestampTest) {
+  setLegacyCast(false);
+  testArrayJoinNoReplacement<Timestamp>(
+      {Timestamp{333183, 0}, std::nullopt, Timestamp{2925183, 0}},
+      "~"_sv,
+      "1970-01-04 20:33:03.000~1970-02-03 20:33:03.000"_sv);
+  testArrayJoinReplacement<Timestamp>(
+      {Timestamp{333183, 0}, std::nullopt, Timestamp{2925183, 0}},
+      "~"_sv,
+      "<n/a>"_sv,
+      "1970-01-04 20:33:03.000~<n/a>~1970-02-03 20:33:03.000"_sv);
+
+  setLegacyCast(true);
+  testArrayJoinNoReplacement<Timestamp>(
+      {Timestamp{333183, 0}, std::nullopt, Timestamp{2925183, 0}},
+      "~"_sv,
+      "1970-01-04T20:33:03.000~1970-02-03T20:33:03.000"_sv);
+  testArrayJoinReplacement<Timestamp>(
+      {Timestamp{333183, 0}, std::nullopt, Timestamp{2925183, 0}},
+      "~"_sv,
+      "<missing>"_sv,
+      "1970-01-04T20:33:03.000~<missing>~1970-02-03T20:33:03.000"_sv);
+
+  setLegacyCast(false);
+  setTimezone("America/Los_Angeles");
+  testArrayJoinNoReplacement<Timestamp>(
+      {Timestamp{333183, 0}, std::nullopt, Timestamp{2925183, 0}},
+      "~"_sv,
+      "1970-01-04 12:33:03.000~1970-02-03 12:33:03.000"_sv);
+  testArrayJoinReplacement<Timestamp>(
+      {Timestamp{333183, 0}, std::nullopt, Timestamp{2925183, 0}},
+      "~"_sv,
+      "<absent>"_sv,
+      "1970-01-04 12:33:03.000~<absent>~1970-02-03 12:33:03.000"_sv);
+}
+
+TEST_F(ArrayJoinTest, dateTest) {
+  std::cout << std::nextafter(0.67777777, INFINITY);
+  setLegacyCast(false);
+  testArrayJoinNoReplacement<int32_t>(
+      {-7204, std::nullopt, -7203}, ","_sv, "1950-04-12,1950-04-13"_sv, true);
+  testArrayJoinReplacement<int32_t>(
+      {-7204, std::nullopt, -7203},
+      ","_sv,
+      "."_sv,
+      "1950-04-12,.,1950-04-13"_sv,
+      true);
+}
+
 } // namespace
diff --git a/velox/functions/prestosql/tests/ArrayMaxTest.cpp b/velox/functions/prestosql/tests/ArrayMaxTest.cpp
index c0163c6ae1e77..2d7bd98a8eacd 100644
--- a/velox/functions/prestosql/tests/ArrayMaxTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayMaxTest.cpp
@@ -145,17 +145,27 @@ TEST_F(ArrayMaxTest, longVarcharNoNulls) {
 
 // Test documented example.
 TEST_F(ArrayMaxTest, docs) {
-  auto input = makeNullableArrayVector<int32_t>(
-      {{1, 2, 3}, {-1, -2, -2}, {-1, -2, std::nullopt}, {}});
-  auto expected =
-      makeNullableFlatVector<int32_t>({3, -1, std::nullopt, std::nullopt});
-  testArrayMax(input, expected);
+  {
+    auto input = makeNullableArrayVector<int32_t>(
+        {{1, 2, 3}, {-1, -2, -2}, {-1, -2, std::nullopt}, {}});
+    auto expected =
+        makeNullableFlatVector<int32_t>({3, -1, std::nullopt, std::nullopt});
+    testArrayMax(input, expected);
+  }
+  {
+    static const float kNaN = std::numeric_limits<float>::quiet_NaN();
+    static const float kInfinity = std::numeric_limits<float>::infinity();
+    auto input = makeNullableArrayVector<float>(
+        {{-1, kNaN, std::nullopt}, {-1, -2, -3, kNaN}, {kInfinity, kNaN}});
+    auto expected = makeNullableFlatVector<float>({std::nullopt, kNaN, kNaN});
+    testArrayMax(input, expected);
+  }
 }
 
 template <typename Type>
 class ArrayMaxIntegralTest : public FunctionBaseTest {
  public:
-  using T = typename Type::NativeType::NativeType;
+  using T = typename Type::NativeType;
 
   void testArrayMax(const VectorPtr& input, const VectorPtr& expected) {
     auto result =
@@ -220,7 +230,7 @@ class ArrayMaxIntegralTest : public FunctionBaseTest {
 template <typename Type>
 class ArrayMaxFloatingPointTest : public FunctionBaseTest {
  public:
-  using T = typename Type::NativeType::NativeType;
+  using T = typename Type::NativeType;
 
   void testArrayMax(VectorPtr input, VectorPtr expected) {
     auto result =
@@ -238,6 +248,7 @@ class ArrayMaxFloatingPointTest : public FunctionBaseTest {
           -0.0003,
           std::numeric_limits<T>::max()},
          {},
+         {std::nullopt},
          {std::numeric_limits<T>::min(), 1.1, 1.22222, 1.33, std::nullopt},
          {-0.00001, -0.0002, 0.0001}});
 
@@ -247,6 +258,7 @@ class ArrayMaxFloatingPointTest : public FunctionBaseTest {
          std::numeric_limits<T>::max(),
          std::nullopt,
          std::nullopt,
+         std::nullopt,
          0.0001});
     testArrayMax(input, expected);
   }
@@ -278,6 +290,22 @@ class ArrayMaxFloatingPointTest : public FunctionBaseTest {
          0.0001});
     testArrayMax(input, expected);
   }
+
+  void testExtremeValues() {
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kInfinity = std::numeric_limits<T>::infinity();
+    static const T kNegativeInfinity = -1 * std::numeric_limits<T>::infinity();
+    auto input = makeNullableArrayVector<T>(
+        {{-1, std::nullopt, kNaN},
+         {-1, std::nullopt, 2},
+         {-1, 0, 2},
+         {kNegativeInfinity, kNegativeInfinity},
+         {-1, 2, kInfinity},
+         {kInfinity, kNaN}});
+    auto expected = makeNullableFlatVector<T>(
+        {std::nullopt, std::nullopt, 2, kNegativeInfinity, kInfinity, kNaN});
+    testArrayMax(input, expected);
+  }
 };
 
 } // namespace
@@ -303,3 +331,7 @@ TYPED_TEST(ArrayMaxFloatingPointTest, arrayMaxNullable) {
 TYPED_TEST(ArrayMaxFloatingPointTest, arrayMax) {
   this->testNoNulls();
 }
+
+TYPED_TEST(ArrayMaxFloatingPointTest, arrayMaxExtreme) {
+  this->testExtremeValues();
+}
diff --git a/velox/functions/prestosql/tests/ArrayMinTest.cpp b/velox/functions/prestosql/tests/ArrayMinTest.cpp
index f2a190e6e6524..4b63f924ddbd0 100644
--- a/velox/functions/prestosql/tests/ArrayMinTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayMinTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include <optional>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 using namespace facebook::velox;
@@ -36,11 +37,20 @@ class ArrayMinTest : public FunctionBaseTest {
   }
 
   void testDocExample() {
-    auto arrayVector = makeNullableArrayVector<int64_t>(
+    auto input1 = makeNullableArrayVector<int64_t>(
         {{1, 2, 3}, {-1, -2, -2}, {-1, -2, std::nullopt}, {}});
-    auto expected =
+    auto expected1 =
         makeNullableFlatVector<int64_t>({1, -2, std::nullopt, std::nullopt});
-    testExpr<int64_t>(expected, "array_min(C0)", {arrayVector});
+    testExpr<int64_t>(expected1, "array_min(C0)", {input1});
+
+    static const float kNaN = std::numeric_limits<float>::quiet_NaN();
+    static const float kInfinity = std::numeric_limits<float>::infinity();
+    auto input2 = makeNullableArrayVector<float>(
+        {{-1, kNaN, std::nullopt}, {-1, -2, -3, kNaN}, {kInfinity, kNaN}});
+    auto expected2 =
+        makeNullableFlatVector<float>({std::nullopt, -3, kInfinity});
+
+    testExpr<float>(expected2, "array_min(C0)", {input2});
   }
 
   template <typename T>
@@ -142,10 +152,28 @@ class ArrayMinTest : public FunctionBaseTest {
         {false, true, false, std::nullopt, false, true});
     testExpr<bool>(expected, "array_min(C0)", {arrayVector});
   }
+
+  template <typename T>
+  void testFloatingPoint() {
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kInfinity = std::numeric_limits<T>::infinity();
+    static const T kNegativeInfinity = -1 * std::numeric_limits<T>::infinity();
+    auto input = makeNullableArrayVector<T>(
+        {{-1, std::nullopt, kNaN},
+         {-1, std::nullopt, 2},
+         {-1, 0, 2},
+         {-1, kNegativeInfinity, kNaN},
+         {kInfinity, kNaN},
+         {kNaN, kNaN}});
+    auto expected = makeNullableFlatVector<T>(
+        {std::nullopt, std::nullopt, -1, kNegativeInfinity, kInfinity, kNaN});
+
+    testExpr<T>(expected, "array_min(C0)", {input});
+  }
 };
 
 } // namespace
-TEST_F(ArrayMinTest, docArrays) {
+TEST_F(ArrayMinTest, docs) {
   testDocExample();
 }
 
@@ -169,3 +197,90 @@ TEST_F(ArrayMinTest, boolArrays) {
   testBoolNullable();
   testBool();
 }
+
+TEST_F(ArrayMinTest, floatArrays) {
+  testFloatingPoint<float>();
+  testFloatingPoint<double>();
+}
+
+TEST_F(ArrayMinTest, complexTypeElements) {
+  auto elements = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 3, 2, 1}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+  });
+
+  auto arrayVector = makeArrayVector({0}, elements);
+  auto result = evaluate("array_min(c0)", makeRowVector({arrayVector}));
+
+  auto expected = makeRowVector({
+      makeFlatVector(std::vector<int32_t>{1}),
+      makeFlatVector(std::vector<int32_t>{1}),
+  });
+  assertEqualVectors(expected, result);
+
+  result = evaluate("array_max(c0)", makeRowVector({arrayVector}));
+
+  expected = makeRowVector({
+      makeFlatVector(std::vector<int32_t>{3}),
+      makeFlatVector(std::vector<int32_t>{4}),
+  });
+  assertEqualVectors(expected, result);
+
+  // Array with null element.
+  elements->setNull(5, true);
+  result = evaluate("array_min(c0)", makeRowVector({arrayVector}));
+
+  ASSERT_EQ(1, result->size());
+  ASSERT_TRUE(result->isNullAt(0));
+
+  elements->clearAllNulls();
+  elements->setNull(0, true);
+  result = evaluate("array_min(c0)", makeRowVector({arrayVector}));
+
+  ASSERT_EQ(1, result->size());
+  ASSERT_TRUE(result->isNullAt(0));
+
+  // Empty array.
+  arrayVector->setOffsetAndSize(0, 0, 0);
+  result = evaluate("array_min(c0)", makeRowVector({arrayVector}));
+
+  ASSERT_EQ(1, result->size());
+  ASSERT_TRUE(result->isNullAt(0));
+
+  // Arrays with elements that contain nulls may or may not be orderable
+  // (depending on whether it would be necessary to compare nulls to decide the
+  // order).
+  elements = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 3, 3, 2, 1}),
+      makeNullableFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+  });
+  arrayVector = makeArrayVector({0}, elements);
+
+  VELOX_ASSERT_THROW(
+      evaluate("array_min(c0)", makeRowVector({arrayVector})),
+      "Ordering nulls is not supported");
+
+  VELOX_ASSERT_THROW(
+      evaluate("array_max(c0)", makeRowVector({arrayVector})),
+      "Ordering nulls is not supported");
+
+  elements = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, 3, 3, 2, 1}),
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 3, 4, 5, 6}),
+  });
+  arrayVector = makeArrayVector({0}, elements);
+
+  result = evaluate("array_min(c0)", makeRowVector({arrayVector}));
+  expected = makeRowVector({
+      makeFlatVector(std::vector<int32_t>{1}),
+      makeFlatVector(std::vector<int32_t>{1}),
+  });
+  assertEqualVectors(expected, result);
+
+  result = evaluate("array_max(c0)", makeRowVector({arrayVector}));
+  expected = makeRowVector({
+      makeFlatVector(std::vector<int32_t>{3}),
+      makeFlatVector(std::vector<int32_t>{4}),
+  });
+  assertEqualVectors(expected, result);
+}
diff --git a/velox/functions/prestosql/tests/ArrayNGramsTest.cpp b/velox/functions/prestosql/tests/ArrayNGramsTest.cpp
new file mode 100644
index 0000000000000..2b4fdaa615a4a
--- /dev/null
+++ b/velox/functions/prestosql/tests/ArrayNGramsTest.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <optional>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+class ArrayNGramsTest : public test::FunctionBaseTest {
+ protected:
+  template <typename T>
+  void testNgram(
+      const std::vector<std::optional<T>>& inputArray,
+      int32_t n,
+      const std::vector<std::optional<std::vector<std::optional<T>>>>&
+          expectedOutput) {
+    std::vector<std::optional<std::vector<std::optional<T>>>> inputVec(
+        {inputArray});
+    auto input = makeNullableArrayVector<T>(inputVec);
+    auto result = evaluate(
+        fmt::format("ngrams(c0, {}::INTEGER)", n), makeRowVector({input}));
+
+    auto expected = makeNullableNestedArrayVector<T>({expectedOutput});
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(ArrayNGramsTest, integers) {
+  testNgram<int64_t>({1, 2, 3, 4}, 1, {{{1}}, {{2}}, {{3}}, {{4}}});
+  testNgram<int64_t>({1, 2, 3, 4}, 2, {{{1, 2}}, {{2, 3}}, {{3, 4}}});
+  testNgram<int64_t>({1, 2, 3, 4}, 3, {{{1, 2, 3}}, {{2, 3, 4}}});
+  testNgram<int64_t>({1, 2, 3, 4}, 4, {{{1, 2, 3, 4}}});
+  testNgram<int64_t>({1, 2, 3, 4}, 5, {{{1, 2, 3, 4}}});
+  testNgram<int64_t>(
+      {1, 2, 3, 4}, std::numeric_limits<int32_t>::max(), {{{1, 2, 3, 4}}});
+  testNgram<int64_t>({}, 1, {{{}}});
+  testNgram<int64_t>({}, 10, {{{}}});
+}
+
+TEST_F(ArrayNGramsTest, invalidN) {
+  auto input = makeArrayVector<int64_t>({{1, 2, 3, 4}});
+  VELOX_ASSERT_THROW(
+      evaluate("ngrams(c0, 0::INTEGER)", makeRowVector({input})),
+      "(0 vs. 0) N must be greater than zero");
+  VELOX_ASSERT_THROW(
+      evaluate("ngrams(c0, -5::INTEGER)", makeRowVector({input})),
+      "Scalar function signature is not supported");
+  input = makeArrayVector<int64_t>({{}});
+  VELOX_ASSERT_THROW(
+      evaluate("ngrams(c0, 0::INTEGER)", makeRowVector({input})),
+      "(0 vs. 0) N must be greater than zero");
+}
+
+TEST_F(ArrayNGramsTest, strings) {
+  testNgram<std::string>(
+      {"foo", "bar", "baz", "this is a very long sentence"},
+      1,
+      {{{"foo"}}, {{"bar"}}, {{"baz"}}, {{"this is a very long sentence"}}});
+  testNgram<std::string>(
+      {"foo", "bar", "baz", "this is a very long sentence"},
+      2,
+      {{{"foo", "bar"}},
+       {{"bar", "baz"}},
+       {{"baz", "this is a very long sentence"}}});
+  testNgram<std::string>(
+      {"foo", "bar", "baz", "this is a very long sentence"},
+      3,
+      {{{"foo", "bar", "baz"}},
+       {{"bar", "baz", "this is a very long sentence"}}});
+  testNgram<std::string>(
+      {"foo", "bar", "baz", "this is a very long sentence"},
+      4,
+      {{{"foo", "bar", "baz", "this is a very long sentence"}}});
+  testNgram<std::string>(
+      {"foo", "bar", "baz", "this is a very long sentence"},
+      5,
+      {{{"foo", "bar", "baz", "this is a very long sentence"}}});
+}
+
+TEST_F(ArrayNGramsTest, nulls) {
+  testNgram<std::string>(
+      {"foo", std::nullopt, "bar"},
+      2,
+      {{{"foo", std::nullopt}}, {{std::nullopt, "bar"}}});
+  testNgram<std::string>(
+      {std::nullopt, std::nullopt, std::nullopt},
+      2,
+      {{{std::nullopt, std::nullopt}}, {{std::nullopt, std::nullopt}}});
+}
+} // namespace
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ArrayNoneMatchTest.cpp b/velox/functions/prestosql/tests/ArrayNoneMatchTest.cpp
index 57e1b27e58264..d19f881d42a7a 100644
--- a/velox/functions/prestosql/tests/ArrayNoneMatchTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayNoneMatchTest.cpp
@@ -91,32 +91,20 @@ TEST_F(ArrayNoneMatchTest, basic) {
 }
 
 TEST_F(ArrayNoneMatchTest, complexTypes) {
-  auto baseVector = makeArrayVector<int64_t>({
-      {1, 2, 3},
-      {2, 2},
-      {3, 3},
-      {4, 4},
-      {5, 5},
-      {},
+  auto arrayOfArrays = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[2, 2], [3, 3], [4, 4], [5, 5]]",
+      "[[]]",
   });
-  // Create an array of array vector using above base vector using offsets.
-  // [
-  //  [[1, 2, 3]],
-  //  [[2, 2], [3, 3], [4, 4], [5, 5]],
-  //  [[]]
-  // ]
-  auto arrayOfArrays = makeArrayVector({0, 1, 5}, baseVector);
   std::vector<std::optional<bool>> expectedResult{false, false, true};
   testNoneMatchExpr(expectedResult, "cardinality(x) > 0", arrayOfArrays);
 
-  // Create an array of array vector using above base vector using offsets.
-  // [
-  //  [[1, 2, 3]],  cardinalities is 3
-  //  [[2, 2], [3, 3], [4, 4], [5, 5]], all cardinalities is 2
-  //  [[]],
-  //  null
-  // ]
-  arrayOfArrays = makeArrayVector({0, 1, 5, 6}, baseVector, {3});
+  arrayOfArrays = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[2, 2], [3, 3], [4, 4], [5, 5]]",
+      "[[]]",
+      "null",
+  });
   expectedResult = {false, true, true, std::nullopt};
   testNoneMatchExpr(expectedResult, "cardinality(x) > 2", arrayOfArrays);
 }
@@ -194,7 +182,7 @@ TEST_F(ArrayNoneMatchTest, errors) {
 
 TEST_F(ArrayNoneMatchTest, conditional) {
   // No throw and return false if there are unmatched elements except nulls
-  auto c0 = makeFlatVector<uint32_t>({1, 2, 3, 4, 5});
+  auto c0 = makeFlatVector<int32_t>({1, 2, 3, 4, 5});
   auto c1 = makeNullableArrayVector<int32_t>({
       {4, 100, std::nullopt},
       {50, 12},
diff --git a/velox/functions/prestosql/tests/ArrayNormalizeTest.cpp b/velox/functions/prestosql/tests/ArrayNormalizeTest.cpp
index a7ca9b612abf7..5f40f84010f3c 100644
--- a/velox/functions/prestosql/tests/ArrayNormalizeTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayNormalizeTest.cpp
@@ -30,8 +30,7 @@ class ArrayNormalizeTest : public FunctionBaseTest {
   void testExpr(
       const VectorPtr& expected,
       const std::vector<VectorPtr>& input) {
-    auto result =
-        evaluate<ArrayVector>("array_normalize(C0, C1)", makeRowVector(input));
+    auto result = evaluate("array_normalize(C0, C1)", makeRowVector(input));
     assertEqualVectors(expected, result);
   }
 
diff --git a/velox/functions/prestosql/tests/ArrayPositionTest.cpp b/velox/functions/prestosql/tests/ArrayPositionTest.cpp
index ff8511c8bc2c1..c962f2a277f4a 100644
--- a/velox/functions/prestosql/tests/ArrayPositionTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayPositionTest.cpp
@@ -51,6 +51,17 @@ class ArrayPositionTest : public FunctionBaseTest {
         makeNullableFlatVector<int64_t>(expected));
   }
 
+  template <typename T>
+  void testPosition(
+      const ArrayVectorPtr& arrayVector,
+      const std::optional<T>& search,
+      const std::vector<std::optional<int64_t>>& expected) {
+    evalExpr(
+        {arrayVector, makeConstant(search, arrayVector->size())},
+        "array_position(c0, c1)",
+        makeNullableFlatVector<int64_t>(expected));
+  }
+
   void testPosition(
       const ArrayVectorPtr& arrayVector,
       const std::vector<int64_t>& search,
@@ -151,6 +162,20 @@ class ArrayPositionTest : public FunctionBaseTest {
         makeNullableFlatVector<int64_t>(expected));
   }
 
+  template <typename T>
+  void testPositionWithInstance(
+      const ArrayVectorPtr& array,
+      const std::optional<T>& search,
+      const int64_t instance,
+      const std::vector<std::optional<int64_t>>& expected) {
+    evalExpr(
+        {array,
+         makeConstant(search, array->size()),
+         makeConstant(instance, array->size())},
+        "array_position(c0, c1, c2)",
+        makeNullableFlatVector<int64_t>(expected));
+  }
+
   template <typename T>
   void testPositionWithInstanceNoNulls(
       const std::vector<std::vector<T>>& array,
@@ -239,6 +264,71 @@ class ArrayPositionTest : public FunctionBaseTest {
         "array_position(c0, c1, c2)",
         dictExpectedVector);
   }
+
+  // Verify that all NaNs are treated as equal and are identifiable in the input
+  // array.
+  template <typename T>
+  void testFloatingPointNaN() {
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+
+    // Test NaN in a simple array.
+    ArrayVectorPtr arrayVectorWithNulls = makeNullableArrayVector<T>({
+        {1, std::nullopt, kNaN, 4, kNaN, 5, 6, kNaN, 7},
+        {1, std::nullopt, kSNaN, 4, kNaN, 5, 6, kNaN, 7},
+    });
+    // This exercises the optimization for null free input.
+    ArrayVectorPtr arrayVectorWithoutNulls = makeArrayVector<T>({
+        {1, 3, kNaN, 4, kNaN, 5, 6, kNaN, 7},
+        {1, 3, kSNaN, 4, kNaN, 5, 6, kNaN, 7},
+    });
+
+    for (auto& arrayVectorPtr :
+         {arrayVectorWithNulls, arrayVectorWithoutNulls}) {
+      for (const T& nan : {kNaN, kSNaN}) {
+        testPosition<T>(arrayVectorPtr, nan, {3, 3});
+        testPositionWithInstance<T>(arrayVectorPtr, nan, 1, {3, 3});
+        testPositionWithInstance<T>(arrayVectorPtr, nan, 2, {5, 5});
+        testPositionWithInstance<T>(arrayVectorPtr, nan, -1, {8, 8});
+      }
+    }
+
+    // Test NaN withing a array of complex type.
+    std::vector<std::vector<std::optional<std::tuple<double, std::string>>>>
+        data = {
+            {{{1, "red"}}, {{kNaN, "blue"}}, {{3, "green"}}},
+            {{{kNaN, "blue"}}, std::nullopt, {{5, "green"}}},
+            {},
+            {std::nullopt},
+            {{{1, "yellow"}},
+             {{kNaN, "blue"}},
+             {{4, "green"}},
+             {{5, "purple"}}},
+        };
+
+    auto rowType = ROW({DOUBLE(), VARCHAR()});
+    auto arrayVector = makeArrayOfRowVector(data, rowType);
+    auto size = arrayVector->size();
+
+    auto testPositionOfRow =
+        [&](double n,
+            const char* color,
+            const std::vector<std::optional<int64_t>>& expected) {
+          auto expectedVector = makeNullableFlatVector<int64_t>(expected);
+          auto searchVector =
+              makeConstantRow(rowType, variant::row({n, color}), size);
+
+          evalExpr(
+              {arrayVector,
+               makeConstantRow(rowType, variant::row({n, color}), size)},
+              "array_position(c0, c1)",
+              makeNullableFlatVector<int64_t>(expected));
+        };
+
+    testPositionOfRow(1, "red", {1, 0, 0, 0, 0});
+    testPositionOfRow(kNaN, "blue", {2, 1, 0, 0, 2});
+    testPositionOfRow(kSNaN, "blue", {2, 1, 0, 0, 2});
+  }
 };
 
 TEST_F(ArrayPositionTest, integer) {
@@ -882,4 +972,9 @@ TEST_F(ArrayPositionTest, dictionaryEncodingElements) {
   testPosition(arrayVector, {1, 2, 3, 4}, {5, 2}, -1);
 }
 
+TEST_F(ArrayPositionTest, floatNaN) {
+  testFloatingPointNaN<float>();
+  testFloatingPointNaN<double>();
+}
+
 } // namespace
diff --git a/velox/functions/prestosql/tests/ArrayRemoveNullsTest.cpp b/velox/functions/prestosql/tests/ArrayRemoveNullsTest.cpp
new file mode 100644
index 0000000000000..0593511df5ff9
--- /dev/null
+++ b/velox/functions/prestosql/tests/ArrayRemoveNullsTest.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdint>
+#include <optional>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::functions::test;
+
+namespace {
+class ArrayRemoveNullsTest : public FunctionBaseTest {
+ protected:
+  void testArrayRemoveNull(const VectorPtr& expected, const VectorPtr& input) {
+    auto result = evaluate("remove_nulls(c0)", makeRowVector({input}));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(ArrayRemoveNullsTest, simpleString) {
+  auto input = makeNullableArrayVector<std::string>(
+      {{"foo", std::nullopt, "bar"}, {"foo", "bar"}});
+  auto expected =
+      makeNullableArrayVector<std::string>({{"foo", "bar"}, {"foo", "bar"}});
+  testArrayRemoveNull(expected, input);
+}
+
+TEST_F(ArrayRemoveNullsTest, simpleInt) {
+  auto input = makeNullableArrayVector<int>(
+      {{1, std::nullopt, std::nullopt, 3}, {1, 3}});
+  auto expected = makeNullableArrayVector<int>({{1, 3}, {1, 3}});
+  testArrayRemoveNull(expected, input);
+}
+
+TEST_F(ArrayRemoveNullsTest, simpleBool) {
+  auto input = makeNullableArrayVector<bool>(
+      {{true, false, true}, {true, false, std::nullopt}});
+  auto expected =
+      makeNullableArrayVector<bool>({{true, false, true}, {true, false}});
+  testArrayRemoveNull(expected, input);
+}
+
+TEST_F(ArrayRemoveNullsTest, complexType) {
+  using array_type = std::optional<std::vector<std::optional<int32_t>>>;
+  array_type array1 = {{1, 2}};
+  array_type array2 = std::nullopt;
+  array_type array3 = {{1, std::nullopt, 2}};
+
+  auto input =
+      makeNullableNestedArrayVector<int32_t>({{{array1, array2, array3}}});
+
+  array_type earray1 = {{1, 2}};
+  array_type earray2 = {{1, std::nullopt, 2}};
+  auto expected =
+      makeNullableNestedArrayVector<int32_t>({{{earray1, earray2}}});
+  testArrayRemoveNull(expected, input);
+}
+
+} // namespace
diff --git a/velox/functions/prestosql/tests/ArrayRemoveTest.cpp b/velox/functions/prestosql/tests/ArrayRemoveTest.cpp
index 5e0f272cdb90d..20920bdc83d7e 100644
--- a/velox/functions/prestosql/tests/ArrayRemoveTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayRemoveTest.cpp
@@ -40,6 +40,50 @@ class ArrayRemoveTest : public FunctionBaseTest {
     VELOX_ASSERT_THROW(
         evaluate(expression, makeRowVector(input)), expectedError);
   }
+
+  template <typename T>
+  void testFloats() {
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+    {
+      const auto arrayVector = makeNullableArrayVector<T>(
+          {{1, std::nullopt, 2, 3, std::nullopt, 4},
+           {3, 4, 5, kNaN, 3, 4, kNaN},
+           {kSNaN, 8, 9}});
+      const auto elementVector = makeFlatVector<T>({3, kNaN, kNaN});
+      const auto expected = makeNullableArrayVector<T>({
+          {1, std::nullopt, 2, std::nullopt, 4},
+          {3, 4, 5, 3, 4},
+          {8, 9},
+      });
+      testExpression(
+          "array_remove(c0, c1)", {arrayVector, elementVector}, expected);
+    }
+    // Test array_remove with complex-type elements.
+    {
+      RowTypePtr rowType;
+      if constexpr (std::is_same_v<T, float>) {
+        rowType = ROW({REAL(), VARCHAR()});
+      } else {
+        static_assert(std::is_same_v<T, double>);
+        rowType = ROW({DOUBLE(), VARCHAR()});
+      }
+      using ArrayOfRow = std::vector<std::optional<std::tuple<T, std::string>>>;
+      std::vector<ArrayOfRow> data = {
+          {{{1, "red"}}, {{kNaN, "blue"}}, {{3, "green"}}, {{kNaN, "blue"}}},
+          {{{1, "red"}}, {{kSNaN, "blue"}}, {{3, "green"}}, {{kNaN, "blue"}}}};
+      auto arrayVector = makeArrayOfRowVector(data, rowType);
+
+      const auto elementVector =
+          makeConstantRow(rowType, variant::row({kNaN, "blue"}), 2);
+
+      std::vector<ArrayOfRow> expectedData = {
+          {{{1, "red"}}, {{3, "green"}}}, {{{1, "red"}}, {{3, "green"}}}};
+      const auto expected = makeArrayOfRowVector(expectedData, rowType);
+      testExpression(
+          "array_remove(c0, c1)", {arrayVector, elementVector}, expected);
+    }
+  }
 };
 
 //// Remove simple-type elements from array.
@@ -60,6 +104,12 @@ TEST_F(ArrayRemoveTest, arrayWithSimpleTypes) {
       "array_remove(c0, c1)", {arrayVector, elementVector}, expected);
 }
 
+//// Remove simple-type elements from array.
+TEST_F(ArrayRemoveTest, arrayWithFloatTypes) {
+  testFloats<float>();
+  testFloats<double>();
+}
+
 //// Remove simple-type elements from array.
 TEST_F(ArrayRemoveTest, arrayWithString) {
   const auto arrayVector = makeNullableArrayVector<std::string>(
@@ -125,6 +175,21 @@ TEST_F(ArrayRemoveTest, arrayWithComplexTypes) {
       "array_remove(c0, c1)",
       {arrayOfArrays, elementVector},
       "array_remove does not support arrays with elements that are null or contain null");
+
+  // Test array_remove([[null ,1]], [null, 2]).
+  // This does not throw because [null ,1] = [null, 2] is false.
+  {
+    std::string nestedArray =
+        "array_constructor(array_constructor(null::bigint, 1))";
+    auto result = evaluate(
+        fmt::format(
+            "array_remove({}, array_constructor(null::bigint, 2))",
+            nestedArray),
+        makeRowVector({makeFlatVector<int32_t>(1)}));
+    auto expected =
+        evaluate(nestedArray, makeRowVector({makeFlatVector<int32_t>(1)}));
+    assertEqualVectors(result, expected);
+  }
 }
 
 ////  Remove null from array.
diff --git a/velox/functions/prestosql/tests/ArrayShuffleTest.cpp b/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
index a30ef8a96237e..d1fb7cd083035 100644
--- a/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
@@ -81,8 +81,7 @@ class ArrayShuffleTest : public FunctionBaseTest {
     DecodedVector decodedExpected(*input.get());
     exec::VectorReader<Array<T>> readerExpected(&decodedExpected);
 
-    auto actualVector =
-        evaluate<ArrayVector>("shuffle(C0)", makeRowVector({input}));
+    auto actualVector = evaluate("shuffle(C0)", makeRowVector({input}));
     // Validate each row from the actual decoded ArrayVector is a permutation
     // of the corresponding row from the expected decoded ArrayVector.
     DecodedVector decodedActual(*actualVector.get());
@@ -172,8 +171,7 @@ class ArrayShuffleTest : public FunctionBaseTest {
         typename exec::ArrayView<false, int32_t>::materialize_t;
     folly::F14FastSet<materialize_t> distinctValueSet;
 
-    auto actualVector =
-        evaluate<ArrayVector>("shuffle(C0)", makeRowVector({inputVector}));
+    auto actualVector = evaluate("shuffle(C0)", makeRowVector({inputVector}));
 
     DecodedVector decodedActual(*actualVector.get());
     exec::VectorReader<Array<int32_t>> readerActual(&decodedActual);
@@ -248,8 +246,8 @@ TEST_F(ArrayShuffleTest, sortAndShuffle) {
         2,
         std::nullopt}});
   auto inputVector = makeRowVector({input});
-  auto result1 = evaluate<ArrayVector>("array_sort(C0)", inputVector);
-  auto result2 = evaluate<ArrayVector>("array_sort(shuffle(C0))", inputVector);
+  auto result1 = evaluate("array_sort(C0)", inputVector);
+  auto result2 = evaluate("array_sort(shuffle(C0))", inputVector);
 
   assertEqualVectors(result1, result2);
 }
diff --git a/velox/functions/prestosql/tests/ArraySortTest.cpp b/velox/functions/prestosql/tests/ArraySortTest.cpp
index 987d35ddb911b..574b3d5913024 100644
--- a/velox/functions/prestosql/tests/ArraySortTest.cpp
+++ b/velox/functions/prestosql/tests/ArraySortTest.cpp
@@ -17,6 +17,7 @@
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 #include <fmt/format.h>
+#include <cstdint>
 
 using namespace facebook::velox;
 using namespace facebook::velox::test;
@@ -33,11 +34,9 @@ const std::unordered_set<TypeKind> kSupportedTypes = {
     TypeKind::REAL,
     TypeKind::DOUBLE,
     TypeKind::VARCHAR,
-    TypeKind::MAP,
     TypeKind::ARRAY,
     TypeKind::ROW};
 
-using TestMapType = std::vector<std::pair<int32_t, std::optional<int32_t>>>;
 using TestArrayType = std::vector<std::optional<StringView>>;
 using TestRowType = variant;
 
@@ -61,10 +60,6 @@ class ArraySortTest : public FunctionBaseTest,
         ->template asFlatVector<T>();
   }
 
-  const MapVector* getMapVector() {
-    return dynamic_cast<MapVector*>(dataVectorsByType_[TypeKind::MAP].get());
-  }
-
   template <typename T>
   T dataAt(vector_size_t index) {
     EXPECT_LT(index, numValues_);
@@ -81,14 +76,6 @@ class ArraySortTest : public FunctionBaseTest,
     return makeNullableArrayVector<T>(inputVectors);
   }
 
-  MapVectorPtr buildMapVector() {
-    return makeMapVector<int32_t, int32_t>(
-        numValues_,
-        [&](vector_size_t /*row*/) { return 1; },
-        [&](vector_size_t row) { return row; },
-        [&](vector_size_t row) { return row; });
-  }
-
   template <typename T>
   VectorPtr makeDataArray(const std::vector<std::optional<int32_t>>& indices) {
     std::vector<std::optional<T>> data;
@@ -192,12 +179,10 @@ class ArraySortTest : public FunctionBaseTest,
     };
     for (const auto& testData : testSettings) {
       SCOPED_TRACE(testData.debugString());
-      auto actualResult =
-          evaluate<ArrayVector>("array_sort(c0)", testData.inputVector);
+      auto actualResult = evaluate("array_sort(c0)", testData.inputVector);
       assertEqualVectors(testData.expectedResult, actualResult);
 
-      auto descResult =
-          evaluate<ArrayVector>("array_sort_desc(c0)", testData.inputVector);
+      auto descResult = evaluate("array_sort_desc(c0)", testData.inputVector);
       assertEqualVectors(testData.expectedDescResult, descResult);
     }
   }
@@ -228,9 +213,6 @@ class ArraySortTest : public FunctionBaseTest,
       case TypeKind::VARCHAR:
         test<StringView>();
         break;
-      case TypeKind::MAP:
-        test<TestMapType>();
-        break;
       case TypeKind::ARRAY:
         test<TestArrayType>();
         break;
@@ -243,6 +225,29 @@ class ArraySortTest : public FunctionBaseTest,
     }
   }
 
+  template <typename T>
+  void testFloatingPoint() {
+    // Verify that NaNs are treated as greater than infinity
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kInfinity = std::numeric_limits<T>::infinity();
+    static const T kNegativeInfinity = -1 * std::numeric_limits<T>::infinity();
+
+    auto input = makeRowVector({makeNullableArrayVector<T>(
+        {{kInfinity, -1, kNaN, 1, kNegativeInfinity, kNaN, 0}})});
+
+    {
+      auto expected = makeNullableArrayVector<T>(
+          {{kNegativeInfinity, -1, 0, 1, kInfinity, kNaN, kNaN}});
+      assertEqualVectors(expected, evaluate("try(array_sort(c0))", input));
+    }
+
+    {
+      auto expected = makeNullableArrayVector<T>(
+          {{kNaN, kNaN, kInfinity, 1, 0, -1, kNegativeInfinity}});
+      assertEqualVectors(expected, evaluate("try(array_sort_desc(c0))", input));
+    }
+  }
+
   // Specify the number of values per each data vector in 'dataVectorsByType_'.
   const int numValues_;
   std::unordered_map<TypeKind, VectorPtr> dataVectorsByType_;
@@ -273,16 +278,6 @@ FlatVectorPtr<bool> ArraySortTest::buildScalarVector() {
   });
 }
 
-template <>
-TestMapType ArraySortTest::dataAt<TestMapType>(vector_size_t index) {
-  EXPECT_LT(index, numValues_);
-  const int32_t key =
-      getMapVector()->mapKeys()->asFlatVector<int32_t>()->valueAt(index);
-  const std::optional<int32_t> value =
-      getMapVector()->mapValues()->asFlatVector<int32_t>()->valueAt(index);
-  return TestMapType({std::pair{key, value}});
-}
-
 template <>
 TestArrayType ArraySortTest::dataAt<TestArrayType>(vector_size_t index) {
   EXPECT_LT(index, numValues_);
@@ -300,17 +295,6 @@ TestRowType ArraySortTest::dataAt<TestRowType>(vector_size_t index) {
   return variant::row({getScalarVector<double>()->valueAt(index)});
 }
 
-template <>
-ArrayVectorPtr ArraySortTest::arrayVector<TestMapType>(
-    const std::vector<std::optional<TestMapType>>& inputValues) {
-  std::vector<std::vector<std::optional<TestMapType>>> inputVectors;
-  inputVectors.reserve(numVectors_);
-  for (int i = 0; i < numVectors_; ++i) {
-    inputVectors.push_back(inputValues);
-  }
-  return makeArrayOfMapVector<int32_t, int32_t>(inputVectors);
-}
-
 template <>
 ArrayVectorPtr ArraySortTest::arrayVector<TestArrayType>(
     const std::vector<std::optional<TestArrayType>>& inputValues) {
@@ -373,9 +357,6 @@ void ArraySortTest::SetUp() {
       case TypeKind::VARCHAR:
         dataVectorsByType_.emplace(type, buildScalarVector<StringView>());
         break;
-      case TypeKind::MAP:
-        dataVectorsByType_.emplace(type, buildMapVector());
-        break;
       case TypeKind::ARRAY:
       case TypeKind::ROW:
         // ARRAY and ROW will reuse the scalar data vectors built for DOUBLE and
@@ -393,6 +374,24 @@ TEST_P(ArraySortTest, basic) {
   runTest(GetParam());
 }
 
+TEST_F(ArraySortTest, unknown) {
+  auto input = makeNullableArrayVector<UnknownValue>({
+      {std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt},
+  });
+
+  auto result = evaluate("array_sort(c0)", makeRowVector({input}));
+  assertEqualVectors(input, result);
+
+  input = makeArrayVectorFromJson<int32_t>({
+      "[1, 2, 3]",
+      "[1, 2]",
+  });
+
+  result = evaluate("array_sort(c0, x -> null)", makeRowVector({input}));
+  assertEqualVectors(input, result);
+}
+
 TEST_F(ArraySortTest, constant) {
   vector_size_t size = 1'000;
   auto data =
@@ -553,6 +552,11 @@ TEST_F(ArraySortTest, lambda) {
     SCOPED_TRACE(lambdaExpr);
     auto result = evaluate(fmt::format("{}(c0, {})", name, lambdaExpr), data);
     assertEqualVectors(sortedAsc, result);
+
+    SelectivityVector firstRow(1);
+    result =
+        evaluate(fmt::format("{}(c0, {})", name, lambdaExpr), data, firstRow);
+    assertEqualVectors(sortedAsc->slice(0, 1), result);
   };
 
   auto testDesc = [&](const std::string& name, const std::string& lambdaExpr) {
@@ -560,6 +564,11 @@ TEST_F(ArraySortTest, lambda) {
     SCOPED_TRACE(lambdaExpr);
     auto result = evaluate(fmt::format("{}(c0, {})", name, lambdaExpr), data);
     assertEqualVectors(sortedDesc, result);
+
+    SelectivityVector firstRow(1);
+    result =
+        evaluate(fmt::format("{}(c0, {})", name, lambdaExpr), data, firstRow);
+    assertEqualVectors(sortedDesc->slice(0, 1), result);
   };
 
   // Different ways to sort by length ascending.
@@ -583,6 +592,141 @@ TEST_F(ArraySortTest, lambda) {
       "(x, y) -> if(length(x) < length(y), 1, if(length(x) = length(y), 0, -1))");
 }
 
+TEST_F(ArraySortTest, unsupporteLambda) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3, 4]",
+          "[1, 2, 3]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("array_sort(c0, (a, b) -> 0)", data),
+      "array_sort with comparator lambda that cannot be rewritten into a transform is not supported");
+}
+
+TEST_F(ArraySortTest, failOnMapTypeSort) {
+  static const std::string kErrorMessage =
+      "Scalar function signature is not supported"_sv;
+  auto data = makeRowVector({BaseVector::createNullConstant(
+      ARRAY(MAP(BIGINT(), VARCHAR())), 8, pool())});
+  auto testFail = [&](const std::string& name) {
+    VELOX_ASSERT_THROW(
+        evaluate(fmt::format("{}(c0, x -> x)", name), data), kErrorMessage);
+    VELOX_ASSERT_THROW(
+        evaluate(fmt::format("{}(c0)", name), data), kErrorMessage);
+  };
+
+  testFail("array_sort");
+  testFail("array_sort_desc");
+}
+
+TEST_F(ArraySortTest, failOnArrayNullCompare) {
+  auto baseVector = makeArrayVectorFromJson<int32_t>({
+      "[null, 1]",
+      "[1, 1]",
+      "[2, 2]",
+      "[2, null]",
+      "[4, 4]",
+      "[5, null]",
+      "null",
+  });
+  static const std::string kErrorMessage = "Ordering nulls is not supported";
+
+  // [2, null] vs [4, 4], [5, null] vs null no throw.
+  const auto noNullCompareBatch = makeRowVector({
+      makeArrayVector({3, 5}, baseVector),
+  });
+
+  // [null, 1] vs [1, 1] throws.
+  auto nullCompareBatch1 = makeRowVector({
+      makeArrayVector({0, 3, 5}, baseVector),
+  });
+
+  // [2, 2] vs [2, null] throws.
+  auto nullCompareBatch2 = makeRowVector({
+      makeArrayVector({1, 4}, baseVector),
+  });
+
+  for (const auto& name : {"array_sort", "array_sort_desc"}) {
+    evaluate(fmt::format("{}(c0)", name), noNullCompareBatch);
+    VELOX_ASSERT_THROW(
+        evaluate(fmt::format("{}(c0)", name), nullCompareBatch1),
+        kErrorMessage);
+    VELOX_ASSERT_THROW(
+        evaluate(fmt::format("{}(c0)", name), nullCompareBatch2),
+        kErrorMessage);
+  }
+
+  {
+    auto expected = makeArrayVector({2, 3, 5}, baseVector);
+    expected->setNull(0, true);
+    assertEqualVectors(
+        expected, evaluate("try(array_sort(c0))", nullCompareBatch1));
+  }
+
+  {
+    auto expected = makeArrayVector({3, 4}, baseVector);
+    expected->setNull(0, true);
+    assertEqualVectors(
+        expected, evaluate("try(array_sort(c0))", nullCompareBatch2));
+  }
+}
+
+TEST_F(ArraySortTest, failOnRowNullCompare) {
+  auto baseVector = makeRowVector({
+      makeNullableFlatVector<int32_t>({std::nullopt, 1, 2, 2, 4, 5, 0}),
+      makeNullableFlatVector<int32_t>(
+          {1, 1, 2, std::nullopt, 4, std::nullopt, 0}),
+  });
+  baseVector->setNull(6, true);
+  static const std::string kErrorMessage = "Ordering nulls is not supported";
+
+  // (2, null) vs (4, 4), (5, null) vs null no throw.
+  const auto noNullCompareBatch = makeRowVector({
+      makeArrayVector({3, 5}, baseVector),
+  });
+
+  // (null, 1) vs (1, 1) throws.
+  auto nullCompareBatch1 = makeRowVector({
+      makeArrayVector({0, 3, 5}, baseVector),
+  });
+
+  // (2, 2) vs (2, null) throws.
+  auto nullCompareBatch2 = makeRowVector({
+      makeArrayVector({1, 4}, baseVector),
+  });
+
+  for (const auto& name : {"array_sort", "array_sort_desc"}) {
+    evaluate(fmt::format("{}(c0)", name), noNullCompareBatch);
+    VELOX_ASSERT_THROW(
+        evaluate(fmt::format("{}(c0)", name), nullCompareBatch1),
+        kErrorMessage);
+    VELOX_ASSERT_THROW(
+        evaluate(fmt::format("{}(c0)", name), nullCompareBatch2),
+        kErrorMessage);
+  }
+
+  {
+    auto expected = makeArrayVector({2, 3, 5}, baseVector);
+    expected->setNull(0, true);
+    assertEqualVectors(
+        expected, evaluate("try(array_sort(c0))", nullCompareBatch1));
+  }
+
+  {
+    auto expected = makeArrayVector({3, 4}, baseVector);
+    expected->setNull(0, true);
+    assertEqualVectors(
+        expected, evaluate("try(array_sort(c0))", nullCompareBatch2));
+  }
+}
+
+TEST_F(ArraySortTest, floatingPointExtremes) {
+  testFloatingPoint<float>();
+  testFloatingPoint<double>();
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     ArraySortTest,
     ArraySortTest,
diff --git a/velox/functions/prestosql/tests/ArrayUnionTest.cpp b/velox/functions/prestosql/tests/ArrayUnionTest.cpp
index dc57d21c9c70f..9173f3725f54c 100644
--- a/velox/functions/prestosql/tests/ArrayUnionTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayUnionTest.cpp
@@ -32,6 +32,38 @@ class ArrayUnionTest : public FunctionBaseTest {
     auto result = evaluate(expression, makeRowVector(input));
     assertEqualVectors(expected, result);
   }
+
+  template <typename T>
+  void floatArrayTest() {
+    static const T kQuietNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSignalingNaN = std::numeric_limits<T>::signaling_NaN();
+    static const T kInfinity = std::numeric_limits<T>::infinity();
+    const auto array1 = makeArrayVector<T>(
+        {{1.1, 2.2, 3.3, 4.4},
+         {3.3, 4.4},
+         {3.3, 4.4, kQuietNaN},
+         {3.3, 4.4, kQuietNaN},
+         {3.3, 4.4, kQuietNaN},
+         {3.3, 4.4, kQuietNaN, kInfinity}});
+    const auto array2 = makeArrayVector<T>(
+        {{3.3, 4.4},
+         {3.3, 5.5},
+         {5.5},
+         {3.3, kQuietNaN},
+         {5.5, kSignalingNaN},
+         {5.5, kInfinity}});
+    VectorPtr expected;
+
+    expected = makeArrayVector<T>({
+        {1.1, 2.2, 3.3, 4.4},
+        {3.3, 4.4, 5.5},
+        {3.3, 4.4, kQuietNaN, 5.5},
+        {3.3, 4.4, kQuietNaN},
+        {3.3, 4.4, kQuietNaN, 5.5},
+        {3.3, 4.4, kQuietNaN, kInfinity, 5.5},
+    });
+    testExpression("array_union(c0, c1)", {array1, array2}, expected);
+  }
 };
 
 /// Union two integer arrays.
@@ -129,4 +161,11 @@ TEST_F(ArrayUnionTest, complexTypes) {
   testExpression(
       "array_union(c0, c1)", {arrayOfArrays1, arrayOfArrays2}, expected);
 }
+
+/// Union two floating point arrays including extreme values like infinity and
+/// NaN.
+TEST_F(ArrayUnionTest, floatingPointType) {
+  floatArrayTest<float>();
+  floatArrayTest<double>();
+}
 } // namespace
diff --git a/velox/functions/prestosql/tests/ArraysOverlapTest.cpp b/velox/functions/prestosql/tests/ArraysOverlapTest.cpp
index 5474802332363..002490be3ab8a 100644
--- a/velox/functions/prestosql/tests/ArraysOverlapTest.cpp
+++ b/velox/functions/prestosql/tests/ArraysOverlapTest.cpp
@@ -23,6 +23,9 @@ using namespace facebook::velox::test;
 using namespace facebook::velox::functions::test;
 
 namespace {
+template <typename TKey, typename TValue>
+using Pair = std::pair<TKey, std::optional<TValue>>;
+
 class ArraysOverlapTest : public FunctionBaseTest {
  protected:
   void testExpr(
@@ -55,7 +58,11 @@ class ArraysOverlapTest : public FunctionBaseTest {
          {1, 1, -2, -2, -2, 4, 8},
          {2, -1},
          {1, 2, 3},
-         {std::nullopt}});
+         {std::nullopt},
+         {},
+         {std::nullopt},
+         {},
+         {1, 2}});
     auto array2 = makeNullableArrayVector<T>(
         {{1, -2, 4},
          {1, -2, 4},
@@ -63,9 +70,23 @@ class ArraysOverlapTest : public FunctionBaseTest {
          {1, -2, 4},
          {1, -2, std::nullopt},
          {5, 6, 7},
-         {std::nullopt}});
+         {std::nullopt},
+         {1, std::nullopt},
+         {},
+         {std::nullopt},
+         {}});
     auto expected = makeNullableFlatVector<bool>(
-        {true, true, std::nullopt, true, std::nullopt, false, std::nullopt});
+        {true,
+         true,
+         std::nullopt,
+         true,
+         std::nullopt,
+         false,
+         std::nullopt,
+         false,
+         false,
+         false,
+         false});
     testExpr(expected, "arrays_overlap(C0, C1)", {array1, array2});
     testExpr(expected, "arrays_overlap(C1, C0)", {array1, array2});
   }
@@ -80,6 +101,9 @@ class ArraysOverlapTest : public FunctionBaseTest {
           std::numeric_limits<T>::infinity(),
           std::numeric_limits<T>::max()},
          {std::numeric_limits<T>::quiet_NaN(), 9.0009},
+         {std::numeric_limits<T>::quiet_NaN(), 3.1},
+         // quiet NaN and signaling NaN are treated equal
+         {std::numeric_limits<T>::signaling_NaN(), 3.1},
          {std::numeric_limits<T>::quiet_NaN(), 9.0009, std::nullopt}});
     auto array2 = makeNullableArrayVector<T>(
         {{1.0, -2.0, 4.0},
@@ -87,9 +111,11 @@ class ArraysOverlapTest : public FunctionBaseTest {
          {1.0001, -2.02, std::numeric_limits<T>::max(), 8.00099},
          {9.0009, std::numeric_limits<T>::infinity()},
          {9.0009, std::numeric_limits<T>::quiet_NaN()},
+         {9.0009, std::numeric_limits<T>::quiet_NaN()},
+         {9.0009, std::numeric_limits<T>::quiet_NaN()},
          {9.0}});
     auto expected = makeNullableFlatVector<bool>(
-        {true, true, true, true, true, std::nullopt});
+        {true, true, true, true, true, true, true, std::nullopt});
     testExpr(expected, "arrays_overlap(C0, C1)", {array1, array2});
     testExpr(expected, "arrays_overlap(C1, C0)", {array1, array2});
   }
@@ -187,6 +213,68 @@ TEST_F(ArraysOverlapTest, longStrings) {
   testExpr(expected, "arrays_overlap(C1, C0)", {array1, array2});
 }
 
+TEST_F(ArraysOverlapTest, complexTypeArray) {
+  auto left = makeNestedArrayVectorFromJson<int32_t>({
+      "[null, [1, 2, 3], [null, null]]",
+      "[[1], [2], []]",
+      "[[1, null, 3]]",
+      "[[1, null, 3]]",
+      "[null]",
+  });
+
+  auto right = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[1]]",
+      "[[1, 2]]",
+      "[[1, null, 3]]",
+      "[[]]",
+  });
+
+  auto expected =
+      makeNullableFlatVector<bool>({true, true, false, true, std::nullopt});
+  testExpr(expected, "arrays_overlap(c0, c1)", {left, right});
+}
+
+TEST_F(ArraysOverlapTest, complexTypeMap) {
+  std::vector<Pair<StringView, int64_t>> a{{"blue", 1}, {"red", 2}};
+  std::vector<Pair<StringView, int64_t>> b{{"green", std::nullopt}};
+  std::vector<Pair<StringView, int64_t>> c{{"yellow", 4}, {"purple", 5}};
+
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> leftData{
+      {b, a}, {b}, {c, a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> rightData{
+      {a, b}, {}, {b}};
+
+  auto left = makeArrayOfMapVector<StringView, int64_t>(leftData);
+  auto right = makeArrayOfMapVector<StringView, int64_t>(rightData);
+  auto expected = makeNullableFlatVector<bool>({true, false, false});
+
+  testExpr(expected, "arrays_overlap(c0, c1)", {left, right});
+}
+
+TEST_F(ArraysOverlapTest, complexTypeRow) {
+  RowTypePtr rowType = ROW({INTEGER(), VARCHAR()});
+
+  using ArrayOfRow = std::vector<std::optional<std::tuple<int, std::string>>>;
+  std::vector<ArrayOfRow> leftData = {
+      {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+      {{{1, "red"}}, {{2, "blue"}}, std::nullopt},
+      {{{1, "red"}}, std::nullopt, std::nullopt},
+      {{{1, "red"}}, {{}}, {{}}}};
+  std::vector<ArrayOfRow> rightData = {
+      {{{2, "blue"}}, {{1, "red"}}},
+      {{{1, "green"}}},
+      {{{1, "red"}}},
+      {{{2, "red"}}}};
+
+  auto left = makeArrayOfRowVector(leftData, rowType);
+  auto right = makeArrayOfRowVector(rightData, rowType);
+  auto expected =
+      makeNullableFlatVector<bool>({true, std::nullopt, true, false});
+
+  testExpr(expected, "arrays_overlap(c0, c1)", {left, right});
+}
+
 //// When one of the arrays is constant.
 TEST_F(ArraysOverlapTest, constant) {
   auto array1 = makeNullableArrayVector<int32_t>({
@@ -216,10 +304,7 @@ TEST_F(ArraysOverlapTest, constant) {
 }
 
 TEST_F(ArraysOverlapTest, dictionaryEncodedElementsInConstant) {
-  exec::registerVectorFunction(
-      "testing_dictionary_array_elements",
-      test::TestingDictionaryArrayElementsFunction::signatures(),
-      std::make_unique<test::TestingDictionaryArrayElementsFunction>());
+  TestingDictionaryArrayElementsFunction::registerFunction();
 
   auto array = makeArrayVector<int64_t>({{1, 3}, {2, 5}, {0, 6}});
   auto expected = makeNullableFlatVector<bool>({true, true, false});
diff --git a/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp b/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
index 3919e4fa6fc85..2ce20c3f58e28 100644
--- a/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
@@ -18,6 +18,7 @@
 #include <array>
 #include <limits>
 #include "velox/common/base/VeloxException.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/Expr.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
@@ -43,8 +44,7 @@ class BinaryFunctionsTest : public FunctionBaseTest {};
 
 TEST_F(BinaryFunctionsTest, md5) {
   const auto md5 = [&](std::optional<std::string> arg) {
-    return evaluateOnce<std::string, std::string>(
-        "md5(c0)", {arg}, {VARBINARY()});
+    return evaluateOnce<std::string>("md5(c0)", VARBINARY(), arg);
   };
 
   EXPECT_EQ(hexToDec("533f6357e0210e67d91f651bc49e1278"), md5("hashme"));
@@ -56,15 +56,13 @@ TEST_F(BinaryFunctionsTest, md5) {
 
 TEST_F(BinaryFunctionsTest, sha1) {
   const auto sha1 = [&](std::optional<std::string> arg) {
-    return evaluateOnce<std::string, std::string>(
-        "sha1(c0)", {arg}, {VARBINARY()});
+    return evaluateOnce<std::string>("sha1(c0)", VARBINARY(), arg);
   };
 
   // The result values were obtained from Presto Java sha1 function.
 
   EXPECT_EQ(hexToDec("DA39A3EE5E6B4B0D3255BFEF95601890AFD80709"), sha1(""));
   EXPECT_EQ(std::nullopt, sha1(std::nullopt));
-
   EXPECT_EQ(hexToDec("86F7E437FAA5A7FCE15D1DDCB9EAEAEA377667B8"), sha1("a"));
   EXPECT_EQ(hexToDec("382758154F5D9F9775B6A9F28B6EDD55773C87E3"), sha1("AB "));
   EXPECT_EQ(hexToDec("B858CB282617FB0956D960215C8E84D1CCF909C6"), sha1(" "));
@@ -86,8 +84,7 @@ TEST_F(BinaryFunctionsTest, sha1) {
 
 TEST_F(BinaryFunctionsTest, sha256) {
   const auto sha256 = [&](std::optional<std::string> arg) {
-    return evaluateOnce<std::string, std::string>(
-        "sha256(c0)", {arg}, {VARBINARY()});
+    return evaluateOnce<std::string>("sha256(c0)", VARBINARY(), arg);
   };
 
   EXPECT_EQ(
@@ -108,8 +105,7 @@ TEST_F(BinaryFunctionsTest, sha256) {
 
 TEST_F(BinaryFunctionsTest, sha512) {
   const auto sha512 = [&](std::optional<std::string> arg) {
-    return evaluateOnce<std::string, std::string>(
-        "sha512(c0)", {arg}, {VARBINARY()});
+    return evaluateOnce<std::string>("sha512(c0)", VARBINARY(), arg);
   };
 
   EXPECT_EQ(
@@ -133,8 +129,7 @@ TEST_F(BinaryFunctionsTest, sha512) {
 
 TEST_F(BinaryFunctionsTest, spookyHashV232) {
   const auto spookyHashV232 = [&](std::optional<std::string> arg) {
-    return evaluateOnce<std::string, std::string>(
-        "spooky_hash_v2_32(c0)", {arg}, {VARBINARY()});
+    return evaluateOnce<std::string>("spooky_hash_v2_32(c0)", VARBINARY(), arg);
   };
 
   // The result values were obtained from Presto Java spooky_hash_v2_32
@@ -153,8 +148,7 @@ TEST_F(BinaryFunctionsTest, spookyHashV232) {
 
 TEST_F(BinaryFunctionsTest, spookyHashV264) {
   const auto spookyHashV264 = [&](std::optional<std::string> arg) {
-    return evaluateOnce<std::string, std::string>(
-        "spooky_hash_v2_64(c0)", {arg}, {VARBINARY()});
+    return evaluateOnce<std::string>("spooky_hash_v2_64(c0)", VARBINARY(), arg);
   };
 
   // The result values were obtained from Presto Java spooky_hash_v2_64
@@ -176,9 +170,11 @@ TEST_F(BinaryFunctionsTest, spookyHashV264) {
 TEST_F(BinaryFunctionsTest, HmacSha1) {
   const auto hmacSha1 = [&](std::optional<std::string> arg,
                             std::optional<std::string> key) {
-    return evaluateOnce<std::string, std::string>(
-        "hmac_sha1(c0, c1)", {arg, key}, {VARBINARY(), VARBINARY()});
+    return evaluateOnce<std::string>(
+        "hmac_sha1(c0, c1)", {VARBINARY(), VARBINARY()}, arg, key);
   };
+
+  VELOX_ASSERT_THROW(hmacSha1("velox", ""), "Empty key is not allowed");
   // Use python hmac lib results as the expected value.
   // >>> import hmac
   // >>> def sha1(data, key):
@@ -206,18 +202,16 @@ TEST_F(BinaryFunctionsTest, HmacSha1) {
   EXPECT_EQ(
       hexToDec("183054bdaf8c83320fee4376e76ffd7e773a650f"),
       hmacSha1("12345abcde54321", "velox"));
-  EXPECT_EQ(
-      hexToDec("3ec5ea98df0f5ddb139231ecee2c8a9810a82e08"),
-      hmacSha1("velox", ""));
   EXPECT_EQ(std::nullopt, hmacSha1("velox", std::nullopt));
 }
 
 TEST_F(BinaryFunctionsTest, HmacSha256) {
   const auto hmacSha256 = [&](std::optional<std::string> arg,
                               std::optional<std::string> key) {
-    return evaluateOnce<std::string, std::string>(
-        "hmac_sha256(c0, c1)", {arg, key}, {VARBINARY(), VARBINARY()});
+    return evaluateOnce<std::string>(
+        "hmac_sha256(c0, c1)", {VARBINARY(), VARBINARY()}, arg, key);
   };
+  VELOX_ASSERT_THROW(hmacSha256("velox", ""), "Empty key is not allowed");
   // Use python hmac lib results as the expected value.
   // >>> import hmac
   // >>> def sha256(data, key):
@@ -246,10 +240,12 @@ TEST_F(BinaryFunctionsTest, HmacSha256) {
 TEST_F(BinaryFunctionsTest, HmacSha512) {
   const auto hmacSha512 = [&](std::optional<std::string> arg,
                               std::optional<std::string> key) {
-    return evaluateOnce<std::string, std::string>(
-        "hmac_sha512(c0, c1)", {arg, key}, {VARBINARY(), VARBINARY()});
+    return evaluateOnce<std::string>(
+        "hmac_sha512(c0, c1)", {VARBINARY(), VARBINARY()}, arg, key);
   };
+
   // Use the same expected value from TestVarbinaryFunctions of presto java
+  VELOX_ASSERT_THROW(hmacSha512("velox", ""), "Empty key is not allowed");
   EXPECT_EQ(
       hexToDec(
           "84FA5AA0279BBC473267D05A53EA03310A987CECC4C1535FF29B6D76B8F1444A728DF3AADB89D4A9A6709E1998F373566E8F824A8CA93B1821F0B69BC2A2F65E"),
@@ -264,23 +260,25 @@ TEST_F(BinaryFunctionsTest, HmacSha512) {
 TEST_F(BinaryFunctionsTest, HmacMd5) {
   const auto hmacMd5 = [&](std::optional<std::string> arg,
                            std::optional<std::string> key) {
-    return evaluateOnce<std::string, std::string>(
-        "hmac_md5(c0, c1)", {arg, key}, {VARBINARY(), VARBINARY()});
+    return evaluateOnce<std::string>(
+        "hmac_md5(c0, c1)", {VARBINARY(), VARBINARY()}, arg, key);
   };
+
   // The result values were obtained from Presto Java hmac_md5 function.
+  VELOX_ASSERT_THROW(hmacMd5("velox", ""), "Empty key is not allowed");
   EXPECT_EQ(
       hexToDec("ff66d72875f01e26fcbe71d973eaf524"), hmacMd5("hashme", "velox"));
   EXPECT_EQ(
       hexToDec("ed706a89f46773b7a478ee5d8f83db86"),
       hmacMd5("Infinity", "velox"));
   EXPECT_EQ(hexToDec("f05e7a0086c6633b496ee411646da51c"), hmacMd5("", "velox"));
+
   EXPECT_EQ(std::nullopt, hmacMd5(std::nullopt, "velox"));
 }
 
 TEST_F(BinaryFunctionsTest, crc32) {
   const auto crc32 = [&](std::optional<std::string> value) {
-    return evaluateOnce<int64_t, std::string>(
-        "crc32(c0)", {value}, {VARBINARY()});
+    return evaluateOnce<int64_t>("crc32(c0)", VARBINARY(), value);
   };
   // use python3 zlib result as the expected values,
   // >>> import zlib
@@ -299,8 +297,7 @@ TEST_F(BinaryFunctionsTest, crc32) {
 
 TEST_F(BinaryFunctionsTest, xxhash64) {
   const auto xxhash64 = [&](std::optional<std::string> value) {
-    return evaluateOnce<std::string, std::string>(
-        "xxhash64(c0)", {value}, {VARBINARY()});
+    return evaluateOnce<std::string>("xxhash64(c0)", VARBINARY(), value);
   };
 
   const auto toVarbinary = [](const int64_t input) {
@@ -418,20 +415,43 @@ TEST_F(BinaryFunctionsTest, toBase64Url) {
 
 TEST_F(BinaryFunctionsTest, fromBase64) {
   const auto fromBase64 = [&](std::optional<std::string> value) {
-    return evaluateOnce<std::string>("from_base64(c0)", value);
+    // from_base64 allows VARCHAR and VARBINARY inputs.
+    auto result =
+        evaluateOnce<std::string>("from_base64(c0)", VARCHAR(), value);
+    auto otherResult =
+        evaluateOnce<std::string>("from_base64(c0)", VARBINARY(), value);
+
+    VELOX_CHECK_EQ(result.has_value(), otherResult.has_value());
+
+    if (!result.has_value()) {
+      return result;
+    }
+
+    VELOX_CHECK_EQ(result.value(), otherResult.value());
+    return result;
   };
 
   EXPECT_EQ(std::nullopt, fromBase64(std::nullopt));
   EXPECT_EQ("", fromBase64(""));
   EXPECT_EQ("a", fromBase64("YQ=="));
+  EXPECT_EQ("ab", fromBase64("YWI="));
   EXPECT_EQ("abc", fromBase64("YWJj"));
   EXPECT_EQ("hello world", fromBase64("aGVsbG8gd29ybGQ="));
   EXPECT_EQ(
       "Hello World from Velox!",
       fromBase64("SGVsbG8gV29ybGQgZnJvbSBWZWxveCE="));
 
-  EXPECT_THROW(fromBase64("YQ="), VeloxUserError);
-  EXPECT_THROW(fromBase64("YQ==="), VeloxUserError);
+  VELOX_ASSERT_USER_THROW(
+      fromBase64("YQ="),
+      "Base64::decode() - invalid input string: string length is not a multiple of 4.");
+  VELOX_ASSERT_USER_THROW(
+      fromBase64("YQ==="),
+      "Base64::decode() - invalid input string: string length is not a multiple of 4.");
+
+  // Check encoded strings without padding
+  EXPECT_EQ("a", fromBase64("YQ"));
+  EXPECT_EQ("ab", fromBase64("YWI"));
+  EXPECT_EQ("abcd", fromBase64("YWJjZA"));
 }
 
 TEST_F(BinaryFunctionsTest, fromBase64Url) {
@@ -463,8 +483,7 @@ TEST_F(BinaryFunctionsTest, fromBase64Url) {
 
 TEST_F(BinaryFunctionsTest, fromBigEndian32) {
   const auto fromBigEndian32 = [&](const std::optional<std::string>& arg) {
-    return evaluateOnce<int32_t, std::string>(
-        "from_big_endian_32(c0)", {arg}, {VARBINARY()});
+    return evaluateOnce<int32_t>("from_big_endian_32(c0)", VARBINARY(), arg);
   };
 
   EXPECT_EQ(std::nullopt, fromBigEndian32(std::nullopt));
@@ -491,8 +510,7 @@ TEST_F(BinaryFunctionsTest, fromBigEndian32) {
 
 TEST_F(BinaryFunctionsTest, toBigEndian32) {
   const auto toBigEndian32 = [&](const std::optional<int32_t>& arg) {
-    return evaluateOnce<std::string, int32_t>(
-        "to_big_endian_32(c0)", {arg}, {INTEGER()});
+    return evaluateOnce<std::string>("to_big_endian_32(c0)", arg);
   };
 
   EXPECT_EQ(std::nullopt, toBigEndian32(std::nullopt));
@@ -512,8 +530,7 @@ TEST_F(BinaryFunctionsTest, toBigEndian32) {
 
 TEST_F(BinaryFunctionsTest, fromBigEndian64) {
   const auto fromBigEndian64 = [&](const std::optional<std::string>& arg) {
-    return evaluateOnce<int64_t, std::string>(
-        "from_big_endian_64(c0)", {arg}, {VARBINARY()});
+    return evaluateOnce<int64_t>("from_big_endian_64(c0)", VARBINARY(), arg);
   };
 
   EXPECT_EQ(std::nullopt, fromBigEndian64(std::nullopt));
@@ -553,8 +570,7 @@ TEST_F(BinaryFunctionsTest, fromBigEndian64) {
 
 TEST_F(BinaryFunctionsTest, toBigEndian64) {
   const auto toBigEndian64 = [&](const std::optional<int64_t>& arg) {
-    return evaluateOnce<std::string, int64_t>(
-        "to_big_endian_64(c0)", {arg}, {BIGINT()});
+    return evaluateOnce<std::string>("to_big_endian_64(c0)", arg);
   };
 
   EXPECT_EQ(std::nullopt, toBigEndian64(std::nullopt));
@@ -630,4 +646,189 @@ TEST_F(BinaryFunctionsTest, toIEEE754Bits64) {
       toIEEE754Bits64(std::numeric_limits<double>::infinity()));
 }
 
+TEST_F(BinaryFunctionsTest, fromIEEE754Bits64) {
+  const auto fromIEEE754Bits64 = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<double>("from_ieee754_64(c0)", VARBINARY(), arg);
+  };
+
+  const auto toIEEE754Bits64 = [&](std::optional<double> arg) {
+    return evaluateOnce<std::string>("to_ieee754_64(c0)", arg);
+  };
+
+  EXPECT_EQ(std::nullopt, fromIEEE754Bits64(std::nullopt));
+  EXPECT_EQ(1, fromIEEE754Bits64(hexToDec("3FF0000000000000")));
+  EXPECT_EQ(1.0124, fromIEEE754Bits64(hexToDec("3FF032CA57A786C2")));
+  EXPECT_EQ(
+      -1.0123999999999715, fromIEEE754Bits64(hexToDec("BFF032CA57A78642")));
+  EXPECT_EQ(3.1415926, fromIEEE754Bits64(hexToDec("400921fb4d12d84a")));
+  EXPECT_EQ(
+      std::numeric_limits<double>::infinity(),
+      fromIEEE754Bits64(hexToDec("7ff0000000000000")));
+  EXPECT_EQ(
+      1.7976931348623157E308, fromIEEE754Bits64(hexToDec("7fefffffffffffff")));
+  EXPECT_EQ(
+      -1.7976931348623157E308, fromIEEE754Bits64(hexToDec("ffefffffffffffff")));
+  EXPECT_EQ(4.9E-324, fromIEEE754Bits64(hexToDec("0000000000000001")));
+  EXPECT_EQ(-4.9E-324, fromIEEE754Bits64(hexToDec("8000000000000001")));
+  EXPECT_THROW(fromIEEE754Bits64("YQ"), VeloxUserError);
+  EXPECT_EQ(3.1415926, fromIEEE754Bits64(toIEEE754Bits64(3.1415926)));
+  EXPECT_EQ(4.9E-324, fromIEEE754Bits64(toIEEE754Bits64(4.9E-324)));
+  EXPECT_EQ(-4.9E-324, fromIEEE754Bits64(toIEEE754Bits64(-4.9E-324)));
+  EXPECT_EQ(
+      std::numeric_limits<double>::infinity(),
+      fromIEEE754Bits64(
+          toIEEE754Bits64(std::numeric_limits<double>::infinity())));
+}
+
+TEST_F(BinaryFunctionsTest, toIEEE754Bits32) {
+  const auto toIEEE754Bits32 = [&](std::optional<float> value) {
+    return evaluateOnce<std::string, float>(
+        "to_ieee754_32(cast(c0 as real))", value);
+  };
+
+  EXPECT_EQ(hexToDec("00000000"), toIEEE754Bits32(0.0));
+  EXPECT_EQ(hexToDec("3f800000"), toIEEE754Bits32(1.0));
+  EXPECT_EQ(hexToDec("40490FDA"), toIEEE754Bits32(3.1415926));
+  EXPECT_EQ(hexToDec("7F800000"), toIEEE754Bits32(1.7976931348623157E308));
+  EXPECT_EQ(hexToDec("FF800000"), toIEEE754Bits32(-1.7976931348623157E308));
+  EXPECT_EQ(hexToDec("00000000"), toIEEE754Bits32(4.9E-324));
+  EXPECT_EQ(hexToDec("80000000"), toIEEE754Bits32(-4.9E-324));
+  EXPECT_EQ(toIEEE754Bits32(100.0), toIEEE754Bits32(100));
+  EXPECT_EQ(std::nullopt, toIEEE754Bits32(std::nullopt));
+  EXPECT_EQ(
+      hexToDec("7FC00000"),
+      toIEEE754Bits32(std::numeric_limits<float>::quiet_NaN()));
+  EXPECT_EQ(
+      hexToDec("7F800000"),
+      toIEEE754Bits32(std::numeric_limits<float>::infinity()));
+  EXPECT_EQ(
+      hexToDec("FF800000"),
+      toIEEE754Bits32(-std::numeric_limits<float>::infinity()));
+  EXPECT_EQ(
+      hexToDec("00800000"), toIEEE754Bits32(std::numeric_limits<float>::min()));
+  EXPECT_EQ(
+      hexToDec("7F7FFFFF"), toIEEE754Bits32(std::numeric_limits<float>::max()));
+  EXPECT_EQ(
+      hexToDec("FF7FFFFF"),
+      toIEEE754Bits32(std::numeric_limits<float>::lowest()));
+}
+
+TEST_F(BinaryFunctionsTest, fromIEEE754Bits32) {
+  const auto fromIEEE754Bits32 = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<float>("from_ieee754_32(c0)", VARBINARY(), arg);
+  };
+
+  const auto toIEEE754Bits32 = [&](std::optional<float> arg) {
+    return evaluateOnce<std::string>("to_ieee754_32(c0)", arg);
+  };
+
+  EXPECT_EQ(std::nullopt, fromIEEE754Bits32(std::nullopt));
+  EXPECT_EQ(1.0f, fromIEEE754Bits32(hexToDec("3F800000")));
+  EXPECT_EQ(3.14f, fromIEEE754Bits32(hexToDec("4048F5C3")));
+  EXPECT_EQ(3.4028235E38f, fromIEEE754Bits32(hexToDec("7f7fffff")));
+  EXPECT_EQ(-3.4028235E38f, fromIEEE754Bits32(hexToDec("ff7fffff")));
+  EXPECT_EQ(1.4E-45f, fromIEEE754Bits32(hexToDec("00000001")));
+  EXPECT_EQ(-1.4E-45f, fromIEEE754Bits32(hexToDec("80000001")));
+  EXPECT_EQ(
+      std::numeric_limits<float>::infinity(),
+      fromIEEE754Bits32(hexToDec("7f800000")));
+  EXPECT_EQ(
+      -std::numeric_limits<float>::infinity(),
+      fromIEEE754Bits32(hexToDec("ff800000")));
+  EXPECT_THROW(fromIEEE754Bits32("YQ"), VeloxUserError);
+  EXPECT_EQ(3.4028235E38f, fromIEEE754Bits32(toIEEE754Bits32(3.4028235E38f)));
+  EXPECT_EQ(-3.4028235E38f, fromIEEE754Bits32(toIEEE754Bits32(-3.4028235E38f)));
+  EXPECT_EQ(1.4E-45f, fromIEEE754Bits32(toIEEE754Bits32(1.4E-45f)));
+  EXPECT_EQ(-1.4E-45f, fromIEEE754Bits32(toIEEE754Bits32(-1.4E-45f)));
+  EXPECT_EQ(
+      std::numeric_limits<float>::infinity(),
+      fromIEEE754Bits32(
+          toIEEE754Bits32(std::numeric_limits<float>::infinity())));
+  EXPECT_EQ(
+      -std::numeric_limits<float>::infinity(),
+      fromIEEE754Bits32(
+          toIEEE754Bits32(-std::numeric_limits<float>::infinity())));
+  EXPECT_EQ(
+      std::numeric_limits<float>::max(),
+      fromIEEE754Bits32(toIEEE754Bits32(std::numeric_limits<float>::max())));
+  EXPECT_EQ(
+      std::numeric_limits<float>::min(),
+      fromIEEE754Bits32(toIEEE754Bits32(std::numeric_limits<float>::min())));
+  EXPECT_TRUE(
+      std::isnan(fromIEEE754Bits32(
+                     toIEEE754Bits32(std::numeric_limits<float>::quiet_NaN()))
+                     .value()));
+  EXPECT_TRUE(std::isnan(
+      fromIEEE754Bits32(
+          toIEEE754Bits32(std::numeric_limits<float>::signaling_NaN()))
+          .value()));
+  EXPECT_TRUE(
+      std::isnan(fromIEEE754Bits32(toIEEE754Bits32(std::nan("nan"))).value()));
+  VELOX_ASSERT_THROW(
+      fromIEEE754Bits32(hexToDec("0000000000000001")),
+      "Input floating-point value must be exactly 4 bytes long");
+}
+
+TEST_F(BinaryFunctionsTest, rpad) {
+  const auto rpad = [&](std::optional<StringView> arg,
+                        std::optional<int32_t> size,
+                        std::optional<StringView> key) {
+    return evaluateOnce<std::string, StringView, int32_t, StringView>(
+        "rpad(c0, c1, c2)",
+        {VARBINARY(), INTEGER(), VARBINARY()},
+        {arg},
+        {size},
+        {key});
+  };
+  EXPECT_EQ(rpad("1234", 14, "45"), ("12344545454545"));
+  EXPECT_EQ(
+      rpad("123456789012", 24, "4444555566667777"),
+      ("123456789012444455556666"));
+  EXPECT_EQ(
+      rpad("1234567890", 30, "44445555666677778888"),
+      ("123456789044445555666677778888"));
+  EXPECT_EQ(rpad("1234", 15, "45"), ("123445454545454"));
+  EXPECT_EQ(rpad("1234", 14, "4524"), ("12344524452445"));
+  EXPECT_EQ(rpad("1234", 6, "4524"), ("123445"));
+  EXPECT_EQ(rpad("23", 0, "4524"), (""));
+  EXPECT_EQ(rpad("∆", 2, "˚"), ("∆˚"));
+  EXPECT_EQ(rpad("©", 4, "£"), ("©£££"));
+  EXPECT_EQ(rpad("1234", 2, "4524"), ("12"));
+  EXPECT_EQ(rpad(std::nullopt, 0, std::nullopt), std::nullopt);
+  VELOX_ASSERT_USER_THROW(
+      rpad("2312", -1, "4524"), "pad size must be in the range [0..1048576)");
+  VELOX_ASSERT_USER_THROW(rpad("2312", 1, ""), "padString must not be empty");
+}
+
+TEST_F(BinaryFunctionsTest, lpad) {
+  const auto lpad = [&](std::optional<StringView> arg,
+                        std::optional<int32_t> size,
+                        std::optional<StringView> key) {
+    return evaluateOnce<std::string, StringView, int32_t, StringView>(
+        "lpad(c0, c1, c2)",
+        {VARBINARY(), INTEGER(), VARBINARY()},
+        {arg},
+        {size},
+        {key});
+  };
+  EXPECT_EQ(lpad("1234", 14, "45"), ("45454545451234"));
+  EXPECT_EQ(lpad("1234", 15, "45"), ("454545454541234"));
+  EXPECT_EQ(
+      lpad("123456789012", 24, "4444555566667777"),
+      ("444455556666123456789012"));
+  EXPECT_EQ(
+      lpad("1234567890", 30, "44445555666677778888"),
+      ("444455556666777788881234567890"));
+  EXPECT_EQ(lpad("∆", 2, "˚"), ("˚∆"));
+  EXPECT_EQ(lpad("©", 4, "£"), ("£££©"));
+  EXPECT_EQ(lpad("1234", 14, "4524"), ("45244524451234"));
+  EXPECT_EQ(lpad("1234", 6, "4524"), ("451234"));
+  EXPECT_EQ(lpad("1234", 0, "4524"), (""));
+  EXPECT_EQ(lpad("1234", 2, "4524"), ("12"));
+  EXPECT_EQ(lpad(std::nullopt, 0, std::nullopt), std::nullopt);
+  VELOX_ASSERT_USER_THROW(
+      lpad("2312", -1, "4524"), "pad size must be in the range [0..1048576)");
+  VELOX_ASSERT_USER_THROW(lpad("2312", 1, ""), "padString must not be empty");
+}
+
 } // namespace
diff --git a/velox/functions/prestosql/tests/BitwiseTest.cpp b/velox/functions/prestosql/tests/BitwiseTest.cpp
index 588073048f4d9..f16d7703701a0 100644
--- a/velox/functions/prestosql/tests/BitwiseTest.cpp
+++ b/velox/functions/prestosql/tests/BitwiseTest.cpp
@@ -71,23 +71,22 @@ class BitwiseTest : public functions::test::FunctionBaseTest {
   template <typename T>
   std::optional<int64_t> bitwiseRightShiftArithmetic(
       std::optional<T> a,
-      std::optional<T> b) {
-    return evaluateOnce<int64_t>(
-        "bitwise_right_shift_arithmetic(c0, c1)", a, b);
+      std::optional<int32_t> b) {
+    return evaluateOnce<T>("bitwise_right_shift_arithmetic(c0, c1)", a, b);
   }
 
   template <typename T>
   std::optional<int64_t> bitwiseLeftShift(
       std::optional<T> a,
-      std::optional<T> b) {
-    return evaluateOnce<int64_t>("bitwise_left_shift(c0, c1)", a, b);
+      std::optional<int32_t> b) {
+    return evaluateOnce<T>("bitwise_left_shift(c0, c1)", a, b);
   }
 
   template <typename T>
   std::optional<int64_t> bitwiseRightShift(
       std::optional<T> a,
-      std::optional<T> b) {
-    return evaluateOnce<int64_t>("bitwise_right_shift(c0, c1)", a, b);
+      std::optional<int32_t> b) {
+    return evaluateOnce<T>("bitwise_right_shift(c0, c1)", a, b);
   }
 };
 
@@ -260,8 +259,9 @@ TEST_F(BitwiseTest, arithmeticShiftRight) {
   EXPECT_EQ(bitwiseArithmeticShiftRight(-100, 66), -1);
   EXPECT_EQ(bitwiseArithmeticShiftRight(100, 65), 0);
   EXPECT_EQ(bitwiseArithmeticShiftRight(100, 66), 0);
+  EXPECT_EQ(bitwiseArithmeticShiftRight(7, 0), 7);
   VELOX_ASSERT_THROW(
-      bitwiseArithmeticShiftRight(3, -1), "Shift must be positive");
+      bitwiseArithmeticShiftRight(3, -1), "Shift must be non-negative");
 
   EXPECT_EQ(bitwiseArithmeticShiftRight(kMin16, kMax16), -1);
   EXPECT_EQ(bitwiseArithmeticShiftRight(kMax16, kMax16), 0);
@@ -302,7 +302,7 @@ TEST_F(BitwiseTest, rightShiftArithmetic) {
   EXPECT_EQ(bitwiseRightShiftArithmetic<int64_t>(kMax64, kMax64), 0);
   EXPECT_EQ(bitwiseRightShiftArithmetic<int64_t>(kMax64, 1), kMax64 >> 1);
   EXPECT_EQ(bitwiseRightShiftArithmetic<int64_t>(kMin64, 1), kMin64 >> 1);
-  EXPECT_EQ(bitwiseRightShiftArithmetic<int64_t>(1, kMin64), 0);
+  EXPECT_EQ(bitwiseRightShiftArithmetic<int64_t>(1, kMin32), 0);
 }
 
 TEST_F(BitwiseTest, leftShift) {
@@ -318,8 +318,8 @@ TEST_F(BitwiseTest, leftShift) {
 
   EXPECT_EQ(bitwiseLeftShift<int16_t>(kMin16, kMax16), 0);
   EXPECT_EQ(bitwiseLeftShift<int16_t>(kMax16, kMax16), 0);
-  EXPECT_EQ(bitwiseLeftShift<int16_t>(kMax16, 1), kMax16 << 1);
-  EXPECT_EQ(bitwiseLeftShift<int16_t>(kMin16, 1), -65536);
+  EXPECT_EQ(bitwiseLeftShift<int16_t>(kMax16, 1), -2);
+  EXPECT_EQ(bitwiseLeftShift<int16_t>(kMin16, 1), 0);
 
   EXPECT_EQ(bitwiseLeftShift<int32_t>(kMin32, kMax32), 0);
   EXPECT_EQ(bitwiseLeftShift<int32_t>(kMax32, kMax32), 0);
@@ -328,8 +328,7 @@ TEST_F(BitwiseTest, leftShift) {
 
   EXPECT_EQ(bitwiseLeftShift<int64_t>(kMin64, kMax64), 0);
   EXPECT_EQ(bitwiseLeftShift<int64_t>(kMax64, kMax64), 0);
-  EXPECT_EQ(
-      bitwiseLeftShift<int64_t>(5787029258914367756, 6918663727935913984), 0);
+  EXPECT_EQ(bitwiseLeftShift<int64_t>(5787029258914367756, 123456), 0);
   EXPECT_EQ(bitwiseLeftShift<int64_t>(kMax64, 1), kMax64 << 1);
   EXPECT_EQ(bitwiseLeftShift<int64_t>(kMin64, 1), 0);
 }
@@ -352,54 +351,58 @@ TEST_F(BitwiseTest, rightShift) {
 
   EXPECT_EQ(bitwiseRightShift<int64_t>(kMin64, kMax64), 0);
   EXPECT_EQ(bitwiseRightShift<int64_t>(kMax64, kMax64), 0);
-  EXPECT_EQ(
-      bitwiseRightShift<int64_t>(5787029258914367756, 6918663727935913984), 0);
+  EXPECT_EQ(bitwiseRightShift<int64_t>(5787029258914367756, 123456), 0);
   EXPECT_EQ(bitwiseRightShift<int64_t>(kMax64, 1), kMax64 >> 1);
   EXPECT_EQ(bitwiseRightShift<int64_t>(kMin64, 1), (kMax64 >> 1) + 1);
 }
 
 TEST_F(BitwiseTest, logicalShiftRight) {
-  const auto bitwiseLogicalShiftRight = [&](std::optional<int64_t> number,
-                                            std::optional<int64_t> shift,
-                                            std::optional<int64_t> bits) {
+  const auto evalFunc = [&](std::optional<int64_t> number,
+                            std::optional<int64_t> shift,
+                            std::optional<int64_t> bits) {
     return evaluateOnce<int64_t>(
         "bitwise_logical_shift_right(c0, c1, c2)", number, shift, bits);
   };
 
-  EXPECT_EQ(bitwiseLogicalShiftRight(1, 1, 64), 0);
-  EXPECT_EQ(bitwiseLogicalShiftRight(-1, 1, 2), 1);
-  EXPECT_EQ(bitwiseLogicalShiftRight(-1, 32, 32), 0);
-  EXPECT_EQ(bitwiseLogicalShiftRight(-1, 30, 32), 3);
-  EXPECT_EQ(bitwiseLogicalShiftRight(kMin64, 10, 32), 0);
-  EXPECT_EQ(bitwiseLogicalShiftRight(kMin64, kMax64, 64), -1);
-  EXPECT_EQ(bitwiseLogicalShiftRight(kMax64, kMin64, 64), kMax64);
-
-  VELOX_ASSERT_THROW(
-      bitwiseLogicalShiftRight(3, -1, 3), "Shift must be positive");
-  VELOX_ASSERT_THROW(
-      bitwiseLogicalShiftRight(3, 1, 1), "Bits must be between 2 and 64");
+  EXPECT_EQ(evalFunc(1, 1, 64), 0);
+  EXPECT_EQ(evalFunc(-1, 1, 2), 1);
+  EXPECT_EQ(evalFunc(-1, 32, 32), 0);
+  EXPECT_EQ(evalFunc(-1, 30, 32), 3);
+  EXPECT_EQ(evalFunc(kMin64, 10, 32), 0);
+  EXPECT_EQ(evalFunc(kMin64, kMax64, 64), 1);
+  EXPECT_EQ(evalFunc(kMax64, kMin64, 64), kMax64);
+  EXPECT_EQ(evalFunc(7, 0, 64), 7);
+  EXPECT_EQ(evalFunc(-8, 2, 64), 4611686018427387902);
+
+  VELOX_ASSERT_THROW(evalFunc(3, -1, 3), "Shift must be non-negative");
+  VELOX_ASSERT_THROW(evalFunc(3, 1, 1), "Bits must be between 2 and 64");
 }
 
 TEST_F(BitwiseTest, shiftLeft) {
-  const auto bitwiseLogicalShiftRight = [&](std::optional<int64_t> number,
-                                            std::optional<int64_t> shift,
-                                            std::optional<int64_t> bits) {
+  const auto evalFunc = [&](std::optional<int64_t> number,
+                            std::optional<int64_t> shift,
+                            std::optional<int64_t> bits) {
     return evaluateOnce<int64_t>(
         "bitwise_shift_left(c0, c1, c2)", number, shift, bits);
   };
 
-  EXPECT_EQ(bitwiseLogicalShiftRight(1, 1, 64), 0);
-  EXPECT_EQ(bitwiseLogicalShiftRight(-1, 1, 2), 2);
-  EXPECT_EQ(bitwiseLogicalShiftRight(-1, 32, 32), 0);
-  EXPECT_EQ(bitwiseLogicalShiftRight(-1, 31, 32), 2147483648);
-  EXPECT_EQ(bitwiseLogicalShiftRight(kMin64, 10, 32), 0);
-  EXPECT_EQ(bitwiseLogicalShiftRight(kMin64, kMax64, 64), -1);
-  EXPECT_EQ(bitwiseLogicalShiftRight(kMax64, kMin64, 64), kMax64);
-
-  VELOX_ASSERT_THROW(
-      bitwiseLogicalShiftRight(3, -1, 3), "Shift must be positive");
-  VELOX_ASSERT_THROW(
-      bitwiseLogicalShiftRight(3, 1, 1), "Bits must be between 2 and 64");
+  EXPECT_EQ(evalFunc(1, 1, 64), 2);
+  EXPECT_EQ(evalFunc(1, 5, 64), 32);
+  EXPECT_EQ(evalFunc(32, 60, 64), 0);
+  EXPECT_EQ(evalFunc(48, 60, 64), 0);
+  EXPECT_EQ(evalFunc(56, 60, 64), 1L << 63);
+  EXPECT_EQ(evalFunc(-1, 1, 64), -2); // -1 << 1
+  EXPECT_EQ(evalFunc(-1, 32, 64), -4294967296); // -1 << 32
+  EXPECT_EQ(evalFunc(-1, 1, 2), 2);
+  EXPECT_EQ(evalFunc(-1, 32, 32), 0);
+  EXPECT_EQ(evalFunc(-1, 31, 32), 2147483648);
+  EXPECT_EQ(evalFunc(kMin64, 10, 32), 0);
+  EXPECT_EQ(evalFunc(kMin64, kMax64, 64), 0);
+  EXPECT_EQ(evalFunc(kMax64, kMin64, 64), kMax64);
+  EXPECT_EQ(evalFunc(7, 0, 64), 7);
+
+  VELOX_ASSERT_THROW(evalFunc(3, -1, 3), "Shift must be non-negative");
+  VELOX_ASSERT_THROW(evalFunc(3, 1, 1), "Bits must be between 2 and 64");
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/tests/CMakeLists.txt b/velox/functions/prestosql/tests/CMakeLists.txt
index 2b9bc75ae9c65..2c0d1696c275e 100644
--- a/velox/functions/prestosql/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/tests/CMakeLists.txt
@@ -24,26 +24,31 @@ add_executable(
   ArrayConcatTest.cpp
   ArrayConstructorTest.cpp
   ArrayContainsTest.cpp
+  ArrayCumSumTest.cpp
   ArrayDistinctTest.cpp
   ArrayDuplicatesTest.cpp
   ArrayExceptTest.cpp
   ArrayFilterTest.cpp
+  ArrayFrequencyTest.cpp
   ArrayFlattenTest.cpp
-  ArrayJoinTest.cpp
   ArrayHasDuplicatesTest.cpp
   ArrayIntersectTest.cpp
+  ArrayJoinTest.cpp
   ArrayMaxTest.cpp
   ArrayMinTest.cpp
+  ArrayNGramsTest.cpp
   ArrayNoneMatchTest.cpp
   ArrayNormalizeTest.cpp
   ArrayPositionTest.cpp
+  ArrayRemoveNullsTest.cpp
   ArrayRemoveTest.cpp
-  ArraySortTest.cpp
   ArrayShuffleTest.cpp
+  ArraySortTest.cpp
   ArraysOverlapTest.cpp
   ArraySumTest.cpp
   ArrayTrimTest.cpp
   ArrayUnionTest.cpp
+  ArgGeneratorTest.cpp
   BinaryFunctionsTest.cpp
   BitwiseTest.cpp
   CardinalityTest.cpp
@@ -52,45 +57,52 @@ add_executable(
   DateTimeFunctionsTest.cpp
   DecimalArithmeticTest.cpp
   ElementAtTest.cpp
+  FailTest.cpp
   FindFirstTest.cpp
   FromUtf8Test.cpp
+  GreatestLeastTest.cpp
   HyperLogLogCastTest.cpp
   HyperLogLogFunctionsTest.cpp
   InPredicateTest.cpp
+  IPAddressCastTest.cpp
   JsonCastTest.cpp
   JsonExtractScalarTest.cpp
   JsonFunctionsTest.cpp
   MapEntriesTest.cpp
   MapFilterTest.cpp
   MapFromEntriesTest.cpp
+  MapNormalizeTest.cpp
+  MapTopNTest.cpp
+  MapTopNKeysTest.cpp
   MapKeysAndValuesTest.cpp
   MapMatchTest.cpp
   MapTest.cpp
   MapZipWithTest.cpp
+  MultimapFromEntriesTest.cpp
   NotTest.cpp
   ProbabilityTest.cpp
   RandTest.cpp
   ReduceTest.cpp
   RegexpReplaceTest.cpp
-  RepeatTest.cpp
   ReverseTest.cpp
   RoundTest.cpp
   ScalarFunctionRegTest.cpp
+  SequenceTest.cpp
   SimpleComparisonMatcherTest.cpp
   SliceTest.cpp
-  SequenceTest.cpp
   SplitTest.cpp
   SplitToMapTest.cpp
   StringFunctionsTest.cpp
   TimestampWithTimeZoneCastTest.cpp
-  TransformTest.cpp
   TransformKeysTest.cpp
+  TransformTest.cpp
   TransformValuesTest.cpp
   TrimFunctionsTest.cpp
+  TypeOfTest.cpp
   URLFunctionsTest.cpp
-  Utf8Test.cpp
+  UuidFunctionsTest.cpp
   WidthBucketArrayTest.cpp
-  GreatestLeastTest.cpp
+  WordStemTest.cpp
   ZipTest.cpp
   ZipWithTest.cpp)
 
@@ -106,8 +118,10 @@ target_link_libraries(
   velox_exec_test_lib
   velox_dwio_common_test_utils
   velox_vector_fuzzer
-  gtest
-  gtest_main
+  velox_expression_fuzzer_test_utility
+  velox_expression_fuzzer
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
-  gmock
-  gmock_main)
+  GTest::gmock
+  GTest::gmock_main)
diff --git a/velox/functions/prestosql/tests/CastBaseTest.h b/velox/functions/prestosql/tests/CastBaseTest.h
index 797785a585513..7359f50ad7474 100644
--- a/velox/functions/prestosql/tests/CastBaseTest.h
+++ b/velox/functions/prestosql/tests/CastBaseTest.h
@@ -33,7 +33,10 @@ class CastBaseTest : public FunctionBaseTest {
     exec::registerVectorFunction(
         "testing_dictionary",
         test::TestingDictionaryFunction::signatures(),
-        std::make_unique<test::TestingDictionaryFunction>());
+        std::make_unique<test::TestingDictionaryFunction>(),
+        exec::VectorFunctionMetadataBuilder()
+            .defaultNullBehavior(false)
+            .build());
   }
 
   // Build an ITypedExpr for cast(fromType as toType).
@@ -44,7 +47,7 @@ class CastBaseTest : public FunctionBaseTest {
     core::TypedExprPtr inputField =
         std::make_shared<const core::FieldAccessTypedExpr>(fromType, "c0");
     return std::make_shared<const core::CastTypedExpr>(
-        toType, std::vector<core::TypedExprPtr>{inputField}, isTryCast);
+        toType, inputField, isTryCast);
   }
 
   // Evaluate cast(fromType as toType) and return the result vector.
@@ -83,12 +86,16 @@ class CastBaseTest : public FunctionBaseTest {
       bool isTryCast) {
     core::TypedExprPtr inputField =
         std::make_shared<const core::FieldAccessTypedExpr>(fromType, "c0");
+
+    // It is not sufficient to wrap input in a dictionary as it will be peeled
+    // off before calling "cast". Apply testing_dictionary function to input to
+    // ensure that "cast" receives dictionary input.
     core::TypedExprPtr callExpr = std::make_shared<const core::CallTypedExpr>(
         fromType,
         std::vector<core::TypedExprPtr>{inputField},
         "testing_dictionary");
     return std::make_shared<const core::CastTypedExpr>(
-        toType, std::vector<core::TypedExprPtr>{callExpr}, isTryCast);
+        toType, callExpr, isTryCast);
   }
 
   // Evaluate cast(testing_dictionary(fromType) as toType) and verify the result
@@ -127,40 +134,144 @@ class CastBaseTest : public FunctionBaseTest {
     assertEqualVectors(wrapInDictionary(indices, expected), result);
   }
 
+  /**
+   * @tparam From Source type for cast.
+   * @tparam To Destination type for cast.
+   * @param typeString Cast type in string.
+   * @param input Input vector of type From.
+   * @param expectedResult Expected output vector of type To.
+   */
+  template <typename TFrom, typename TTo>
+  void testCast(
+      const std::string& typeString,
+      const std::vector<std::optional<TFrom>>& input,
+      const std::vector<std::optional<TTo>>& expectedResult,
+      const TypePtr& fromType = CppToType<TFrom>::create(),
+      const TypePtr& toType = CppToType<TTo>::create()) {
+    auto result = evaluate(
+        fmt::format("cast(c0 as {})", typeString),
+        makeRowVector({makeNullableFlatVector(input, fromType)}));
+    auto expected = makeNullableFlatVector<TTo>(expectedResult, toType);
+    assertEqualVectors(expected, result);
+  }
+
+  /**
+   * @tparam From Source type for cast.
+   * @tparam To Destination type for cast.
+   * @param typeString Cast type in string.
+   * @param input Input vector of type From.
+   * @param expectedResult Expected output vector of type To.
+   */
+  template <typename TFrom, typename TTo>
+  void testTryCast(
+      const std::string& typeString,
+      const std::vector<std::optional<TFrom>>& input,
+      const std::vector<std::optional<TTo>>& expectedResult,
+      const TypePtr& fromType = CppToType<TFrom>::create(),
+      const TypePtr& toType = CppToType<TTo>::create()) {
+    auto result = evaluate(
+        fmt::format("try_cast(c0 as {})", typeString),
+        makeRowVector({makeNullableFlatVector(input, fromType)}));
+    auto expected = makeNullableFlatVector<TTo>(expectedResult, toType);
+    assertEqualVectors(expected, result);
+  }
+
+  /**
+   * @tparam From Source type for cast.
+   * @param typeString Cast type in string.
+   * @param input Input vector of type From.
+   */
+  template <typename TFrom>
+  void testInvalidCast(
+      const std::string& typeString,
+      const std::vector<std::optional<TFrom>>& input,
+      const std::string& expectedErrorMessage,
+      const TypePtr& fromType = CppToType<TFrom>::create(),
+      const bool isRunTimeThrow = false) {
+    if (!isRunTimeThrow) {
+      VELOX_ASSERT_USER_THROW(
+          evaluate(
+              fmt::format("cast(c0 as {})", typeString),
+              makeRowVector({makeNullableFlatVector(input, fromType)})),
+          expectedErrorMessage);
+    } else {
+      VELOX_ASSERT_RUNTIME_THROW(
+          evaluate(
+              fmt::format("cast(c0 as {})", typeString),
+              makeRowVector({makeNullableFlatVector(input, fromType)})),
+          expectedErrorMessage);
+    }
+  }
+
   void testCast(
-      const TypePtr& fromType,
-      const TypePtr& toType,
       const VectorPtr& input,
-      const VectorPtr& expected) {
+      const VectorPtr& expected,
+      std::optional<bool> isTryCast = std::nullopt) {
+    const auto& fromType = input->type();
+    const auto& toType = expected->type();
     SCOPED_TRACE(fmt::format(
         "Cast from {} to {}", fromType->toString(), toType->toString()));
+    const auto copy = createCopy(input);
     // Test with flat encoding.
     {
       SCOPED_TRACE("Flat encoding");
-      evaluateAndVerify(fromType, toType, makeRowVector({input}), expected);
-      evaluateAndVerify(
-          fromType, toType, makeRowVector({input}), expected, true);
+      if (isTryCast.has_value()) {
+        evaluateAndVerify(
+            fromType,
+            toType,
+            makeRowVector({input}),
+            expected,
+            isTryCast.value());
+      } else {
+        evaluateAndVerify(fromType, toType, makeRowVector({input}), expected);
+        evaluateAndVerify(
+            fromType, toType, makeRowVector({input}), expected, true);
+      }
+
+      // Make sure the input vector does not change.
+      assertEqualVectors(input, copy);
     }
 
     // Test with constant encoding that repeats the first element five times.
     {
       SCOPED_TRACE("Constant encoding");
-      auto constInput = BaseVector::wrapInConstant(5, 0, input);
-      auto constExpected = BaseVector::wrapInConstant(5, 0, expected);
+      const auto constantRow =
+          makeRowVector({BaseVector::wrapInConstant(5, 0, input)});
+      const auto localCopy = createCopy(constantRow);
+      const auto constExpected = BaseVector::wrapInConstant(5, 0, expected);
 
-      evaluateAndVerify(
-          fromType, toType, makeRowVector({constInput}), constExpected);
-      evaluateAndVerify(
-          fromType, toType, makeRowVector({constInput}), constExpected, true);
+      if (isTryCast.has_value()) {
+        evaluateAndVerify(
+            fromType, toType, constantRow, constExpected, isTryCast.value());
+      } else {
+        evaluateAndVerify(fromType, toType, constantRow, constExpected);
+        evaluateAndVerify(fromType, toType, constantRow, constExpected, true);
+      }
+
+      // Make sure the input vector does not change.
+      assertEqualVectors(constantRow, localCopy);
+      assertEqualVectors(input, copy);
     }
 
     // Test with dictionary encoding that reverses the indices.
     {
       SCOPED_TRACE("Dictionary encoding");
-      evaluateAndVerifyDictEncoding(
-          fromType, toType, makeRowVector({input}), expected);
-      evaluateAndVerifyDictEncoding(
-          fromType, toType, makeRowVector({input}), expected, true);
+      if (isTryCast.has_value()) {
+        evaluateAndVerifyDictEncoding(
+            fromType,
+            toType,
+            makeRowVector({input}),
+            expected,
+            isTryCast.value());
+      } else {
+        evaluateAndVerifyDictEncoding(
+            fromType, toType, makeRowVector({input}), expected);
+        evaluateAndVerifyDictEncoding(
+            fromType, toType, makeRowVector({input}), expected, true);
+      }
+
+      // Make sure the input vector does not change.
+      assertEqualVectors(input, copy);
     }
   }
 
@@ -173,10 +284,10 @@ class CastBaseTest : public FunctionBaseTest {
     auto inputVector = makeNullableFlatVector<TFrom>(input, fromType);
     auto expectedVector = makeNullableFlatVector<TTo>(expected, toType);
 
-    testCast(fromType, toType, inputVector, expectedVector);
+    testCast(inputVector, expectedVector);
   }
 
-  template <typename TFrom, typename TTo>
+  template <typename TFrom>
   void testThrow(
       const TypePtr& fromType,
       const TypePtr& toType,
@@ -189,6 +300,25 @@ class CastBaseTest : public FunctionBaseTest {
             makeRowVector({makeNullableFlatVector<TFrom>(input, fromType)})),
         expectedErrorMessage);
   }
+
+  VectorPtr createCopy(const VectorPtr& input) {
+    VectorPtr result;
+    SelectivityVector rows(input->size());
+    BaseVector::ensureWritable(rows, input->type(), input->pool(), result);
+    result->copy(input.get(), rows, nullptr);
+    return result;
+  }
+
+  std::shared_ptr<core::CastTypedExpr> makeCastExpr(
+      const core::TypedExprPtr& input,
+      const TypePtr& toType,
+      bool nullOnFailure) {
+    std::vector<core::TypedExprPtr> inputs = {input};
+    return std::make_shared<core::CastTypedExpr>(toType, inputs, nullOnFailure);
+  }
+
+  const float kInf = std::numeric_limits<float>::infinity();
+  const float kNan = std::numeric_limits<float>::quiet_NaN();
 };
 
 } // namespace facebook::velox::functions::test
diff --git a/velox/functions/prestosql/tests/ComparisonsTest.cpp b/velox/functions/prestosql/tests/ComparisonsTest.cpp
index 59b4f87069f9b..f05075121d052 100644
--- a/velox/functions/prestosql/tests/ComparisonsTest.cpp
+++ b/velox/functions/prestosql/tests/ComparisonsTest.cpp
@@ -13,9 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/functions/prestosql/Comparisons.h"
 #include <string>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/Udf.h"
+#include "velox/functions/lib/RegistrationHelpers.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 using namespace facebook::velox;
@@ -27,31 +29,23 @@ class ComparisonsTest : public functions::test::FunctionBaseTest {
   }
 
  protected:
-  template <typename T>
-  void testDistinctFrom(
-      const std::vector<std::optional<T>>& col1,
-      const std::vector<std::optional<T>>& col2,
-      const std::vector<bool>& expected) {
-    auto data = vectorMaker_.rowVector(
-        {vectorMaker_.flatVectorNullable<T>(col1),
-         vectorMaker_.flatVectorNullable<T>(col2)});
-
-    auto result = evaluate<SimpleVector<bool>>("c0 IS DISTINCT FROM c1", data);
-
-    ASSERT_EQ((size_t)result->size(), expected.size());
-    for (size_t i = 0; i < expected.size(); ++i) {
-      ASSERT_TRUE(!result->isNullAt(i));
-      ASSERT_EQ(expected[i], result->valueAt(i));
-    }
-  }
-
   void testBetweenExpr(
       const std::string& exprStr,
       const std::vector<VectorPtr>& input,
       const VectorPtr& expectedResult) {
-    auto actual = evaluate<SimpleVector<bool>>(exprStr, makeRowVector(input));
+    auto actual = evaluate(exprStr, makeRowVector(input));
     test::assertEqualVectors(expectedResult, actual);
   }
+
+  void registerSimpleComparisonFunctions() {
+    using namespace facebook::velox::functions;
+    registerBinaryScalar<EqFunction, bool>({"simple_eq"});
+    registerBinaryScalar<NeqFunction, bool>({"simple_neq"});
+    registerBinaryScalar<LtFunction, bool>({"simple_lt"});
+    registerBinaryScalar<LteFunction, bool>({"simple_lte"});
+    registerBinaryScalar<GtFunction, bool>({"simple_gt"});
+    registerBinaryScalar<GteFunction, bool>({"simple_gte"});
+  }
 };
 
 TEST_F(ComparisonsTest, between) {
@@ -89,10 +83,6 @@ TEST_F(ComparisonsTest, betweenVarchar) {
 }
 
 TEST_F(ComparisonsTest, betweenDate) {
-  auto parseDate = [](const std::string& dateStr) {
-    return DATE()->toDays(dateStr);
-  };
-
   std::vector<std::tuple<int32_t, bool>> testData = {
       {parseDate("2019-05-01"), false},
       {parseDate("2019-06-01"), true},
@@ -111,17 +101,14 @@ TEST_F(ComparisonsTest, betweenDate) {
 }
 
 TEST_F(ComparisonsTest, betweenTimestamp) {
-  using util::fromTimestampString;
-
   const auto between = [&](std::optional<std::string> s) {
     auto expr =
         "c0 between cast(\'2019-02-28 10:00:00.500\' as timestamp) and"
         " cast(\'2019-02-28 10:00:00.600\' as timestamp)";
-    if (s.has_value()) {
-      return evaluateOnce<bool>(
-          expr, std::optional(fromTimestampString((StringView)s.value())));
+    if (!s.has_value()) {
+      return evaluateOnce<bool>(expr, std::optional<Timestamp>());
     }
-    return evaluateOnce<bool>(expr, std::optional<Timestamp>());
+    return evaluateOnce<bool>(expr, std::optional{parseTimestamp(s.value())});
   };
 
   EXPECT_EQ(std::nullopt, between(std::nullopt));
@@ -543,20 +530,51 @@ TEST_F(ComparisonsTest, eqRow) {
 }
 
 TEST_F(ComparisonsTest, distinctFrom) {
-  testDistinctFrom(
-      std::vector<std::optional<int64_t>>{3, 1, 1, std::nullopt, std::nullopt},
-      std::vector<std::optional<int64_t>>{3, 2, std::nullopt, 2, std::nullopt},
-      {false, true, true, true, false});
+  auto input = makeRowVector({
+      makeNullableFlatVector<int64_t>({3, 1, 1, std::nullopt, std::nullopt}),
+      makeNullableFlatVector<int64_t>({3, 2, std::nullopt, 2, std::nullopt}),
+  });
+
+  auto result = evaluate("c0 is distinct from c1", input);
+  auto expected = makeFlatVector<bool>({false, true, true, true, false});
+  test::assertEqualVectors(expected, result);
 
   const Timestamp ts1(998474645, 321000000);
   const Timestamp ts2(998423705, 321000000);
   const Timestamp ts3(400000000, 123000000);
-  testDistinctFrom(
-      std::vector<std::optional<Timestamp>>{
-          ts3, ts1, ts1, std::nullopt, std::nullopt},
-      std::vector<std::optional<Timestamp>>{
-          ts3, ts2, std::nullopt, ts2, std::nullopt},
-      {false, true, true, true, false});
+  input = makeRowVector({
+      makeNullableFlatVector<Timestamp>(
+          {ts3, ts1, ts1, std::nullopt, std::nullopt}),
+      makeNullableFlatVector<Timestamp>(
+          {ts3, ts2, std::nullopt, ts2, std::nullopt}),
+  });
+
+  result = evaluate("c0 is distinct from c1", input);
+  expected = makeFlatVector<bool>({false, true, true, true, false});
+  test::assertEqualVectors(expected, result);
+
+  input = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "null",
+          "[]",
+          "[1, null]",
+          "[null, 2, 3]",
+          "null",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 4]",
+          "null",
+          "[]",
+          "[1, null]",
+          "[null, 2, 4]",
+          "[]",
+      }),
+  });
+
+  result = evaluate("c0 is distinct from c1", input);
+  expected = makeFlatVector<bool>({true, false, false, false, true, true});
+  test::assertEqualVectors(expected, result);
 }
 
 TEST_F(ComparisonsTest, eqNestedComplex) {
@@ -601,6 +619,125 @@ TEST_F(ComparisonsTest, eqNestedComplex) {
   }
 }
 
+TEST_F(ComparisonsTest, overflowTest) {
+  auto makeFlatVector = [&](size_t numRows, size_t delta) {
+    BufferPtr values =
+        AlignedBuffer::allocate<int64_t>(numRows + delta, pool());
+    auto rawValues = values->asMutable<int64_t>();
+    for (size_t i = 0; i < numRows + delta; ++i) {
+      rawValues[i] = i;
+    }
+    return std::make_shared<FlatVector<int64_t>>(
+        pool(), BIGINT(), nullptr, numRows, values, std::vector<BufferPtr>{});
+  };
+
+  size_t numRows = 1006;
+  size_t delta = 2;
+  auto rowVector = makeRowVector(
+      {makeFlatVector(numRows, delta), makeFlatVector(numRows, delta)});
+  auto result =
+      evaluate<SimpleVector<bool>>(fmt::format("{}(c0, c1)", "eq"), rowVector);
+  for (auto i = 0; i < result->size(); ++i) {
+    ASSERT_TRUE(result->valueAt(i));
+  }
+
+  auto flatResult = result->asFlatVector<bool>();
+  auto rawResult = flatResult->mutableRawValues();
+  for (auto i = 0; i < result->size(); ++i) {
+    ASSERT_TRUE(
+        bits::isBitSet(reinterpret_cast<const uint64_t*>(rawResult), i));
+  }
+  for (auto i = result->size(); i < result->size() + delta; ++i) {
+    ASSERT_FALSE(
+        bits::isBitSet(reinterpret_cast<const uint64_t*>(rawResult), i));
+  }
+}
+
+TEST_F(ComparisonsTest, nanComparison) {
+  registerSimpleComparisonFunctions();
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+  static const auto kInf = std::numeric_limits<double>::infinity();
+
+  auto testNaN =
+      [&](std::string prefix, RowVectorPtr rowVector, bool primitiveInput) {
+        auto eval = [&](const std::string& expr,
+                        const std::string& lhs,
+                        const std::string& rhs) {
+          return evaluate<SimpleVector<bool>>(
+              fmt::format("{}({}, {})", expr, lhs, rhs), rowVector);
+        };
+
+        auto allFalse = makeFlatVector<bool>({false, false});
+        auto allTrue = makeFlatVector<bool>({true, true});
+
+        // NaN compared with NaN (multiple binary representations)
+        test::assertEqualVectors(eval(prefix + "eq", "c0", "c1"), allTrue);
+        test::assertEqualVectors(eval(prefix + "neq", "c0", "c1"), allFalse);
+        if (primitiveInput) {
+          test::assertEqualVectors(eval(prefix + "lt", "c0", "c1"), allFalse);
+          test::assertEqualVectors(eval(prefix + "gt", "c0", "c1"), allFalse);
+          test::assertEqualVectors(eval(prefix + "lte", "c0", "c1"), allTrue);
+          test::assertEqualVectors(eval(prefix + "gte", "c0", "c1"), allTrue);
+          // NaN between Infinity and NaN
+          test::assertEqualVectors(
+              evaluate<SimpleVector<bool>>("c0 BETWEEN c2 and c1", rowVector),
+              allTrue);
+          // NaN distinct from NaN
+          test::assertEqualVectors(
+              evaluate<SimpleVector<bool>>("c0 IS DISTINCT FROM c1", rowVector),
+              allFalse);
+        }
+
+        // NaN compared with Inf
+        test::assertEqualVectors(eval(prefix + "eq", "c0", "c2"), allFalse);
+        test::assertEqualVectors(eval(prefix + "neq", "c0", "c2"), allTrue);
+        if (primitiveInput) {
+          test::assertEqualVectors(eval(prefix + "lt", "c0", "c2"), allFalse);
+          test::assertEqualVectors(eval(prefix + "gt", "c0", "c2"), allTrue);
+          test::assertEqualVectors(eval(prefix + "lte", "c0", "c2"), allFalse);
+          test::assertEqualVectors(eval(prefix + "gte", "c0", "c2"), allTrue);
+          // NaN between 0 and Infinity
+          test::assertEqualVectors(
+              evaluate<SimpleVector<bool>>(
+                  "c0 BETWEEN cast(0 as double) and c2", rowVector),
+              allFalse);
+          // NaN distinct from Infinity
+          test::assertEqualVectors(
+              evaluate<SimpleVector<bool>>("c0 IS DISTINCT FROM c2", rowVector),
+              allTrue);
+        }
+      };
+
+  // Primitive type input
+  auto input = makeRowVector(
+      {makeFlatVector<double>({kNaN, kSNaN}),
+       makeFlatVector<double>({kNaN, kNaN}),
+       makeFlatVector<double>({kInf, kInf})});
+  // Test the Vector function ComparisonSimdFunction.
+  testNaN("", input, true);
+  // Test the Simple functions.
+  testNaN("simple_", input, true);
+
+  // Complex type input
+  input = makeRowVector({
+      makeRowVector({
+          makeFlatVector<double>({kNaN, kSNaN}),
+          makeFlatVector<int32_t>({1, 1}),
+      }),
+      makeRowVector({
+          makeFlatVector<double>({kNaN, kNaN}),
+          makeFlatVector<int32_t>({1, 1}),
+      }),
+      makeRowVector({
+          makeFlatVector<double>({kInf, kInf}),
+          makeFlatVector<int32_t>({1, 1}),
+      }),
+  });
+  // Note: Complex comparison functions are only registered as simple functions.
+  testNaN("", input, false);
+}
+
 namespace {
 template <typename Tp, typename Op, const char* fnName>
 struct ComparisonTypeOp {
@@ -641,7 +778,7 @@ typedef ::testing::Types<
 template <typename ComparisonTypeOp>
 class SimdComparisonsTest : public functions::test::FunctionBaseTest {
  public:
-  using T = typename ComparisonTypeOp::type::NativeType::NativeType;
+  using T = typename ComparisonTypeOp::type::NativeType;
   using ComparisonOp = typename ComparisonTypeOp::fn;
   const std::string sqlFn = ComparisonTypeOp().sqlFunction;
 
@@ -726,29 +863,6 @@ class SimdComparisonsTest : public functions::test::FunctionBaseTest {
         rhsVector.begin(), rhsVector.end(), std::numeric_limits<T>::min());
 
     testVectorComparison(lhsVector, rhsVector);
-
-    // Add tests against Nan and other edge cases.
-    if constexpr (std::is_floating_point_v<T>) {
-      lhsVector = std::vector<T>(47);
-      rhsVector = std::vector<T>(47);
-
-      std::fill(
-          lhsVector.begin(),
-          lhsVector.end(),
-          std::numeric_limits<T>::signaling_NaN());
-      std::fill(
-          rhsVector.begin(),
-          rhsVector.end(),
-          std::numeric_limits<T>::signaling_NaN());
-      testVectorComparison(lhsVector, rhsVector);
-
-      std::fill(
-          lhsVector.begin(),
-          lhsVector.end(),
-          std::numeric_limits<T>::signaling_NaN());
-      std::fill(rhsVector.begin(), rhsVector.end(), 1);
-      testVectorComparison(lhsVector, rhsVector);
-    }
   }
 
   void testDictionary() {
diff --git a/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp b/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
index b03ef502a088e..03e64f68b8c31 100644
--- a/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#include <optional>
-#include <string>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/external/date/tz.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
@@ -66,7 +64,7 @@ class DateTimeFunctionsTest : public functions::test::FunctionBaseTest {
       "November",
       "December"};
 
-  std::string padNumber(int number) {
+  static std::string padNumber(int number) {
     return number < 10 ? "0" + std::to_string(number) : std::to_string(number);
   }
 
@@ -84,13 +82,36 @@ class DateTimeFunctionsTest : public functions::test::FunctionBaseTest {
   }
 
  public:
+  // Helper class to manipulate timestamp with timezone types in tests. Provided
+  // only for convenience.
   struct TimestampWithTimezone {
     TimestampWithTimezone(int64_t milliSeconds, int16_t timezoneId)
         : milliSeconds_(milliSeconds), timezoneId_(timezoneId) {}
 
+    TimestampWithTimezone(int64_t milliSeconds, std::string_view timezoneName)
+        : TimestampWithTimezone{milliSeconds, tz::getTimeZoneID(timezoneName)} {
+    }
+
     int64_t milliSeconds_{0};
     int16_t timezoneId_{0};
 
+    static std::optional<int64_t> pack(
+        std::optional<TimestampWithTimezone> zone) {
+      if (zone.has_value()) {
+        return facebook::velox::pack(zone->milliSeconds_, zone->timezoneId_);
+      }
+      return std::nullopt;
+    }
+
+    static std::optional<TimestampWithTimezone> unpack(
+        std::optional<int64_t> input) {
+      if (input.has_value()) {
+        return TimestampWithTimezone(
+            unpackMillisUtc(input.value()), unpackZoneKeyId(input.value()));
+      }
+      return std::nullopt;
+    }
+
     // Provides a nicer printer for gtest.
     friend std::ostream& operator<<(
         std::ostream& os,
@@ -100,64 +121,6 @@ class DateTimeFunctionsTest : public functions::test::FunctionBaseTest {
     }
   };
 
-  std::optional<TimestampWithTimezone> parseDatetime(
-      const std::optional<std::string>& input,
-      const std::optional<std::string>& format) {
-    auto resultVector = evaluate(
-        "parse_datetime(c0, c1)",
-        makeRowVector(
-            {makeNullableFlatVector<std::string>({input}),
-             makeNullableFlatVector<std::string>({format})}));
-    EXPECT_EQ(1, resultVector->size());
-
-    if (resultVector->isNullAt(0)) {
-      return std::nullopt;
-    }
-
-    auto rowVector = resultVector->as<RowVector>();
-    return TimestampWithTimezone{
-        rowVector->children()[0]->as<SimpleVector<int64_t>>()->valueAt(0),
-        rowVector->children()[1]->as<SimpleVector<int16_t>>()->valueAt(0)};
-  }
-
-  std::optional<Timestamp> dateParse(
-      const std::optional<std::string>& input,
-      const std::optional<std::string>& format) {
-    auto resultVector = evaluate(
-        "date_parse(c0, c1)",
-        makeRowVector(
-            {makeNullableFlatVector<std::string>({input}),
-             makeNullableFlatVector<std::string>({format})}));
-    EXPECT_EQ(1, resultVector->size());
-
-    if (resultVector->isNullAt(0)) {
-      return std::nullopt;
-    }
-    return resultVector->as<SimpleVector<Timestamp>>()->valueAt(0);
-  }
-
-  std::optional<std::string> dateFormat(
-      std::optional<Timestamp> timestamp,
-      const std::string& format) {
-    auto resultVector = evaluate(
-        "date_format(c0, c1)",
-        makeRowVector(
-            {makeNullableFlatVector<Timestamp>({timestamp}),
-             makeNullableFlatVector<std::string>({format})}));
-    return resultVector->as<SimpleVector<StringView>>()->valueAt(0);
-  }
-
-  std::optional<std::string> formatDatetime(
-      std::optional<Timestamp> timestamp,
-      const std::string& format) {
-    auto resultVector = evaluate(
-        "format_datetime(c0, c1)",
-        makeRowVector(
-            {makeNullableFlatVector<Timestamp>({timestamp}),
-             makeNullableFlatVector<std::string>({format})}));
-    return resultVector->as<SimpleVector<StringView>>()->valueAt(0);
-  }
-
   template <typename T>
   std::optional<T> evaluateWithTimestampWithTimezone(
       const std::string& expression,
@@ -193,35 +156,24 @@ class DateTimeFunctionsTest : public functions::test::FunctionBaseTest {
             timestamp.value(), timeZoneName.value().c_str())}));
   }
 
-  int32_t parseDate(const std::string& dateStr) {
-    return DATE()->toDays(dateStr);
-  }
-
-  RowVectorPtr makeTimestampWithTimeZoneVector(
-      int64_t timestamp,
-      const char* tz) {
-    const int64_t tzid = util::getTimeZoneID(tz);
+  VectorPtr makeTimestampWithTimeZoneVector(int64_t timestamp, const char* tz) {
+    auto tzid = tz::getTimeZoneID(tz);
 
-    return std::make_shared<RowVector>(
-        pool(),
-        TIMESTAMP_WITH_TIME_ZONE(),
-        nullptr,
-        1,
-        std::vector<VectorPtr>(
-            {makeNullableFlatVector<int64_t>({timestamp}),
-             makeNullableFlatVector<int16_t>({tzid})}));
+    return makeNullableFlatVector<int64_t>(
+        {pack(timestamp, tzid)}, TIMESTAMP_WITH_TIME_ZONE());
   }
 
-  RowVectorPtr makeTimestampWithTimeZoneVector(
-      const VectorPtr& timestamps,
-      const VectorPtr& timezones) {
-    VELOX_CHECK_EQ(timestamps->size(), timezones->size());
-    return std::make_shared<RowVector>(
-        pool(),
-        TIMESTAMP_WITH_TIME_ZONE(),
+  VectorPtr makeTimestampWithTimeZoneVector(
+      vector_size_t size,
+      const std::function<int64_t(int32_t row)>& timestampAt,
+      const std::function<int16_t(int32_t row)>& timezoneAt) {
+    return makeFlatVector<int64_t>(
+        size,
+        [&](int32_t index) {
+          return pack(timestampAt(index), timezoneAt(index));
+        },
         nullptr,
-        timestamps->size(),
-        std::vector<VectorPtr>({timestamps, timezones}));
+        TIMESTAMP_WITH_TIME_ZONE());
   }
 
   int32_t getCurrentDate(const std::optional<std::string>& timeZone) {
@@ -261,8 +213,18 @@ TEST_F(DateTimeFunctionsTest, parseDatetimeSignatures) {
 }
 
 TEST_F(DateTimeFunctionsTest, dayOfXxxSignatures) {
-  for (const auto& name :
-       {"day_of_year", "doy", "day_of_month", "day_of_week", "dow"}) {
+  for (const auto& name : {"day", "day_of_month"}) {
+    SCOPED_TRACE(name);
+    auto signatures = getSignatureStrings(name);
+    ASSERT_EQ(4, signatures.size());
+
+    ASSERT_EQ(1, signatures.count("(timestamp with time zone) -> bigint"));
+    ASSERT_EQ(1, signatures.count("(date) -> bigint"));
+    ASSERT_EQ(1, signatures.count("(timestamp) -> bigint"));
+    ASSERT_EQ(1, signatures.count("(interval day to second) -> bigint"));
+  }
+
+  for (const auto& name : {"day_of_year", "doy", "day_of_week", "dow"}) {
     SCOPED_TRACE(name);
     auto signatures = getSignatureStrings(name);
     ASSERT_EQ(3, signatures.size());
@@ -325,7 +287,7 @@ TEST_F(DateTimeFunctionsTest, fromUnixtimeRountTrip) {
   };
 
   testRoundTrip(Timestamp(0, 0));
-  testRoundTrip(Timestamp(-1, 9000));
+  testRoundTrip(Timestamp(-1, 9000000));
   testRoundTrip(Timestamp(4000000000, 0));
   testRoundTrip(Timestamp(4000000000, 123000000));
   testRoundTrip(Timestamp(-9999999999, 100000000));
@@ -334,65 +296,62 @@ TEST_F(DateTimeFunctionsTest, fromUnixtimeRountTrip) {
 }
 
 TEST_F(DateTimeFunctionsTest, fromUnixtimeWithTimeZone) {
-  static const double kNan = std::numeric_limits<double>::quiet_NaN();
+  const auto fromUnixtime = [&](std::optional<double> timestamp,
+                                std::optional<std::string> timezoneName) {
+    return TimestampWithTimezone::unpack(evaluateOnce<int64_t>(
+        "from_unixtime(c0, c1)", timestamp, timezoneName));
+  };
 
-  vector_size_t size = 37;
+  // Check null behavior.
+  EXPECT_EQ(fromUnixtime(std::nullopt, std::nullopt), std::nullopt);
+  EXPECT_EQ(fromUnixtime(std::nullopt, "UTC"), std::nullopt);
+  EXPECT_EQ(fromUnixtime(0, std::nullopt), std::nullopt);
 
-  auto unixtimeAt = [](vector_size_t row) -> double {
-    return 1631800000.12345 + row * 11;
-  };
+  EXPECT_EQ(
+      fromUnixtime(1631800000.12345, "-01:00"),
+      TimestampWithTimezone(1631800000123, "-01:00"));
+  EXPECT_EQ(
+      fromUnixtime(123.99, "America/Los_Angeles"),
+      TimestampWithTimezone(123990, "America/Los_Angeles"));
+  EXPECT_EQ(
+      fromUnixtime(1667721600.1, "UTC"),
+      TimestampWithTimezone(1667721600100, "UTC"));
+
+  // Nan.
+  static const double kNan = std::numeric_limits<double>::quiet_NaN();
+  EXPECT_EQ(fromUnixtime(kNan, "-04:36"), TimestampWithTimezone(0, "-04:36"));
 
-  auto unixtimes = makeFlatVector<double>(size, unixtimeAt);
+  // Test some hard coded pairs of timezone names and internal ids.
+  std::vector<TimeZoneKey> timezoneIds = {900, 960, 1020, 1080, 1140};
+  std::vector<std::string> timezoneNames = {
+      "+01:00", "+02:00", "+03:00", "+04:00", "+05:00"};
 
-  // Constant timezone parameter.
-  {
-    auto result =
-        evaluate("from_unixtime(c0, '+01:00')", makeRowVector({unixtimes}));
-
-    auto expected = makeTimestampWithTimeZoneVector(
-        makeFlatVector<int64_t>(
-            size, [&](auto row) { return unixtimeAt(row) * 1'000; }),
-        makeConstant((int16_t)900, size));
-    assertEqualVectors(expected, result);
-
-    // NaN timestamp.
-    result = evaluate(
-        "from_unixtime(c0, '+01:00')",
-        makeRowVector({makeFlatVector<double>({kNan, kNan})}));
-    expected = makeTimestampWithTimeZoneVector(
-        makeFlatVector<int64_t>({0, 0}), makeFlatVector<int16_t>({900, 900}));
-    assertEqualVectors(expected, result);
+  for (size_t i = 0; i < timezoneIds.size(); ++i) {
+    EXPECT_EQ(
+        fromUnixtime(1'000, timezoneNames[i]),
+        TimestampWithTimezone(1'000'000, timezoneIds[i]));
   }
+}
 
-  // Variable timezone parameter.
-  {
-    std::vector<int16_t> timezoneIds = {900, 960, 1020, 1080, 1140};
-    std::vector<std::string> timezoneNames = {
-        "+01:00", "+02:00", "+03:00", "+04:00", "+05:00"};
-
-    auto timezones = makeFlatVector<StringView>(
-        size, [&](auto row) { return StringView(timezoneNames[row % 5]); });
-
-    auto result = evaluate(
-        "from_unixtime(c0, c1)", makeRowVector({unixtimes, timezones}));
-    auto expected = makeTimestampWithTimeZoneVector(
-        makeFlatVector<int64_t>(
-            size, [&](auto row) { return unixtimeAt(row) * 1'000; }),
-        makeFlatVector<int16_t>(
-            size, [&](auto row) { return timezoneIds[row % 5]; }));
-    assertEqualVectors(expected, result);
-
-    // NaN timestamp.
-    result = evaluate(
-        "from_unixtime(c0, c1)",
-        makeRowVector({
-            makeFlatVector<double>({kNan, kNan}),
-            makeNullableFlatVector<StringView>({"+01:00", "+02:00"}),
-        }));
-    expected = makeTimestampWithTimeZoneVector(
-        makeFlatVector<int64_t>({0, 0}), makeFlatVector<int16_t>({900, 960}));
-    assertEqualVectors(expected, result);
-  }
+TEST_F(DateTimeFunctionsTest, fromUnixtimeTzOffset) {
+  auto fromOffset = [&](std::optional<double> epoch,
+                        std::optional<int64_t> hours,
+                        std::optional<int64_t> minutes) {
+    auto result = evaluateOnce<int64_t>(
+        "from_unixtime(c0, c1, c2)", epoch, hours, minutes);
+
+    auto otherResult = evaluateOnce<int64_t>(
+        fmt::format("from_unixtime(c0, {}, {})", *hours, *minutes), epoch);
+
+    VELOX_CHECK_EQ(result.value(), otherResult.value());
+    return TimestampWithTimezone::unpack(result.value());
+  };
+
+  EXPECT_EQ(TimestampWithTimezone(123'450, "UTC"), fromOffset(123.45, 0, 0));
+  EXPECT_EQ(
+      TimestampWithTimezone(123'450, "+05:30"), fromOffset(123.45, 5, 30));
+  EXPECT_EQ(
+      TimestampWithTimezone(123'450, "-08:00"), fromOffset(123.45, -8, 0));
 }
 
 TEST_F(DateTimeFunctionsTest, fromUnixtime) {
@@ -404,12 +363,12 @@ TEST_F(DateTimeFunctionsTest, fromUnixtime) {
   static const double kNan = std::numeric_limits<double>::quiet_NaN();
 
   EXPECT_EQ(Timestamp(0, 0), fromUnixtime(0));
-  EXPECT_EQ(Timestamp(-1, 9000), fromUnixtime(-0.999991));
+  EXPECT_EQ(Timestamp(-1, 9000000), fromUnixtime(-0.991));
+  EXPECT_EQ(Timestamp(1, 0), fromUnixtime(1 - 1e-10));
   EXPECT_EQ(Timestamp(4000000000, 0), fromUnixtime(4000000000));
   EXPECT_EQ(
       Timestamp(9'223'372'036'854'775, 807'000'000), fromUnixtime(3.87111e+37));
-  // double(123000000) to uint64_t conversion returns 123000144.
-  EXPECT_EQ(Timestamp(4000000000, 123000144), fromUnixtime(4000000000.123));
+  EXPECT_EQ(Timestamp(4000000000, 123000000), fromUnixtime(4000000000.123));
   EXPECT_EQ(Timestamp(9'223'372'036'854'775, 807'000'000), fromUnixtime(kInf));
   EXPECT_EQ(
       Timestamp(-9'223'372'036'854'776, 192'000'000), fromUnixtime(-kInf));
@@ -441,52 +400,50 @@ TEST_F(DateTimeFunctionsTest, year) {
 
 TEST_F(DateTimeFunctionsTest, yearDate) {
   const auto year = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("year(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("year(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, year(std::nullopt));
-  EXPECT_EQ(1970, year(DATE()->toDays("1970-01-01")));
-  EXPECT_EQ(1969, year(DATE()->toDays("1969-12-31")));
-  EXPECT_EQ(2020, year(DATE()->toDays("2020-01-01")));
-  EXPECT_EQ(1920, year(DATE()->toDays("1920-12-31")));
+  EXPECT_EQ(1970, year(parseDate("1970-01-01")));
+  EXPECT_EQ(1969, year(parseDate("1969-12-31")));
+  EXPECT_EQ(2020, year(parseDate("2020-01-01")));
+  EXPECT_EQ(1920, year(parseDate("1920-12-31")));
 }
 
 TEST_F(DateTimeFunctionsTest, yearTimestampWithTimezone) {
+  const auto yearTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "year(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
   EXPECT_EQ(
-      1969,
-      evaluateWithTimestampWithTimezone<int64_t>("year(c0)", 0, "-01:00"));
+      1969, yearTimestampWithTimezone(TimestampWithTimezone(0, "-01:00")));
   EXPECT_EQ(
-      1970,
-      evaluateWithTimestampWithTimezone<int64_t>("year(c0)", 0, "+00:00"));
+      1970, yearTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
       1973,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year(c0)", 123456789000, "+14:00"));
+      yearTimestampWithTimezone(TimestampWithTimezone(123456789000, "+14:00")));
   EXPECT_EQ(
       1966,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year(c0)", -123456789000, "+03:00"));
+      yearTimestampWithTimezone(
+          TimestampWithTimezone(-123456789000, "+03:00")));
   EXPECT_EQ(
       2001,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year(c0)", 987654321000, "-07:00"));
+      yearTimestampWithTimezone(TimestampWithTimezone(987654321000, "-07:00")));
   EXPECT_EQ(
       1938,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year(c0)", -987654321000, "-13:00"));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year(c0)", std::nullopt, std::nullopt));
+      yearTimestampWithTimezone(
+          TimestampWithTimezone(-987654321000, "-13:00")));
+  EXPECT_EQ(std::nullopt, yearTimestampWithTimezone(std::nullopt));
 }
 
 TEST_F(DateTimeFunctionsTest, weekDate) {
   const auto weekDate = [&](const char* dateString) {
     auto date = std::make_optional(parseDate(dateString));
-    auto week =
-        evaluateOnce<int64_t, int32_t>("week(c0)", {date}, {DATE()}).value();
+    auto week = evaluateOnce<int64_t>("week(c0)", DATE(), date).value();
     auto weekOfYear =
-        evaluateOnce<int64_t, int32_t>("week_of_year(c0)", {date}, {DATE()})
-            .value();
+        evaluateOnce<int64_t>("week_of_year(c0)", DATE(), date).value();
     VELOX_CHECK_EQ(
         week, weekOfYear, "week and week_of_year must return the same value");
     return week;
@@ -503,13 +460,34 @@ TEST_F(DateTimeFunctionsTest, weekDate) {
   EXPECT_EQ(1, weekDate("1970-01-01"));
   EXPECT_EQ(1, weekDate("0001-01-01"));
   EXPECT_EQ(52, weekDate("9999-12-31"));
+
+  // Test various cases where the last week of the previous year extends into
+  // the next year.
+
+  // Leap year that ends on Thursday.
+  EXPECT_EQ(53, weekDate("2021-01-01"));
+  // Leap year that ends on Friday.
+  EXPECT_EQ(53, weekDate("2005-01-01"));
+  // Leap year that ends on Saturday.
+  EXPECT_EQ(52, weekDate("2017-01-01"));
+  // Common year that ends on Thursday.
+  EXPECT_EQ(53, weekDate("2016-01-01"));
+  // Common year that ends on Friday.
+  EXPECT_EQ(52, weekDate("2022-01-01"));
+  // Common year that ends on Saturday.
+  EXPECT_EQ(52, weekDate("2023-01-01"));
 }
 
 TEST_F(DateTimeFunctionsTest, week) {
-  const auto weekTimestamp = [&](const char* time) {
-    auto timestampInSeconds = util::fromTimeString(time) / 1'000'000;
+  const auto weekTimestamp = [&](std::string_view time) {
+    auto ts = util::fromTimestampString(
+                  time.data(), time.size(), util::TimestampParseMode::kIso8601)
+                  .thenOrThrow(folly::identity, [&](const Status& status) {
+                    VELOX_USER_FAIL("{}", status.message());
+                  });
     auto timestamp =
-        std::make_optional(Timestamp(timestampInSeconds * 100'000'000, 0));
+        std::make_optional(Timestamp(ts.getSeconds() * 100'000'000, 0));
+
     auto week = evaluateOnce<int64_t>("week(c0)", timestamp).value();
     auto weekOfYear =
         evaluateOnce<int64_t>("week_of_year(c0)", timestamp).value();
@@ -518,19 +496,24 @@ TEST_F(DateTimeFunctionsTest, week) {
     return week;
   };
 
-  EXPECT_EQ(1, weekTimestamp("00:00:00"));
-  EXPECT_EQ(10, weekTimestamp("11:59:59"));
-  EXPECT_EQ(51, weekTimestamp("06:01:01"));
-  EXPECT_EQ(24, weekTimestamp("06:59:59"));
-  EXPECT_EQ(27, weekTimestamp("12:00:01"));
-  EXPECT_EQ(7, weekTimestamp("12:59:59"));
+  EXPECT_EQ(1, weekTimestamp("T00:00:00"));
+  EXPECT_EQ(10, weekTimestamp("T11:59:59"));
+  EXPECT_EQ(51, weekTimestamp("T06:01:01"));
+  EXPECT_EQ(24, weekTimestamp("T06:59:59"));
+  EXPECT_EQ(27, weekTimestamp("T12:00:01"));
+  EXPECT_EQ(7, weekTimestamp("T12:59:59"));
 }
 
 TEST_F(DateTimeFunctionsTest, weekTimestampWithTimezone) {
-  const auto weekTimestampTimezone = [&](const char* time,
+  const auto weekTimestampTimezone = [&](std::string_view time,
                                          const char* timezone) {
-    auto timestampInSeconds = util::fromTimeString(time) / 1'000'000;
-    auto timestamp = timestampInSeconds * 100'000'000;
+    auto ts = util::fromTimestampString(
+                  time.data(), time.size(), util::TimestampParseMode::kIso8601)
+                  .thenOrThrow(folly::identity, [&](const Status& status) {
+                    VELOX_USER_FAIL("{}", status.message());
+                  });
+
+    auto timestamp = ts.getSeconds() * 100'000'000;
     auto week = evaluateWithTimestampWithTimezone<int64_t>(
                     "week(c0)", timestamp, timezone)
                     .value();
@@ -542,14 +525,14 @@ TEST_F(DateTimeFunctionsTest, weekTimestampWithTimezone) {
     return week;
   };
 
-  EXPECT_EQ(1, weekTimestampTimezone("00:00:00", "-12:00"));
-  EXPECT_EQ(1, weekTimestampTimezone("00:00:00", "+12:00"));
-  EXPECT_EQ(47, weekTimestampTimezone("11:59:59", "-12:00"));
-  EXPECT_EQ(47, weekTimestampTimezone("11:59:59", "+12:00"));
-  EXPECT_EQ(33, weekTimestampTimezone("06:01:01", "-12:00"));
-  EXPECT_EQ(34, weekTimestampTimezone("06:01:01", "+12:00"));
-  EXPECT_EQ(47, weekTimestampTimezone("12:00:01", "-12:00"));
-  EXPECT_EQ(47, weekTimestampTimezone("12:00:01", "+12:00"));
+  EXPECT_EQ(1, weekTimestampTimezone("T00:00:00", "-12:00"));
+  EXPECT_EQ(1, weekTimestampTimezone("T00:00:00", "+12:00"));
+  EXPECT_EQ(47, weekTimestampTimezone("T11:59:59", "-12:00"));
+  EXPECT_EQ(47, weekTimestampTimezone("T11:59:59", "+12:00"));
+  EXPECT_EQ(33, weekTimestampTimezone("T06:01:01", "-12:00"));
+  EXPECT_EQ(34, weekTimestampTimezone("T06:01:01", "+12:00"));
+  EXPECT_EQ(47, weekTimestampTimezone("T12:00:01", "-12:00"));
+  EXPECT_EQ(47, weekTimestampTimezone("T12:00:01", "+12:00"));
 }
 
 TEST_F(DateTimeFunctionsTest, quarter) {
@@ -577,7 +560,7 @@ TEST_F(DateTimeFunctionsTest, quarter) {
 
 TEST_F(DateTimeFunctionsTest, quarterDate) {
   const auto quarter = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("quarter(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("quarter(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, quarter(std::nullopt));
   EXPECT_EQ(1, quarter(0));
@@ -590,32 +573,34 @@ TEST_F(DateTimeFunctionsTest, quarterDate) {
 }
 
 TEST_F(DateTimeFunctionsTest, quarterTimestampWithTimezone) {
+  const auto quarterTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "quarter(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
   EXPECT_EQ(
-      4,
-      evaluateWithTimestampWithTimezone<int64_t>("quarter(c0)", 0, "-01:00"));
+      4, quarterTimestampWithTimezone(TimestampWithTimezone(0, "-01:00")));
   EXPECT_EQ(
-      1,
-      evaluateWithTimestampWithTimezone<int64_t>("quarter(c0)", 0, "+00:00"));
+      1, quarterTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
       4,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "quarter(c0)", 123456789000, "+14:00"));
+      quarterTimestampWithTimezone(
+          TimestampWithTimezone(123456789000, "+14:00")));
   EXPECT_EQ(
       1,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "quarter(c0)", -123456789000, "+03:00"));
+      quarterTimestampWithTimezone(
+          TimestampWithTimezone(-123456789000, "+03:00")));
   EXPECT_EQ(
       2,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "quarter(c0)", 987654321000, "-07:00"));
+      quarterTimestampWithTimezone(
+          TimestampWithTimezone(987654321000, "-07:00")));
   EXPECT_EQ(
       3,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "quarter(c0)", -987654321000, "-13:00"));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "quarter(c0)", std::nullopt, std::nullopt));
+      quarterTimestampWithTimezone(
+          TimestampWithTimezone(-987654321000, "-13:00")));
+  EXPECT_EQ(std::nullopt, quarterTimestampWithTimezone(std::nullopt));
 }
 
 TEST_F(DateTimeFunctionsTest, month) {
@@ -643,7 +628,7 @@ TEST_F(DateTimeFunctionsTest, month) {
 
 TEST_F(DateTimeFunctionsTest, monthDate) {
   const auto month = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("month(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("month(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, month(std::nullopt));
   EXPECT_EQ(1, month(0));
@@ -655,30 +640,32 @@ TEST_F(DateTimeFunctionsTest, monthDate) {
 }
 
 TEST_F(DateTimeFunctionsTest, monthTimestampWithTimezone) {
-  EXPECT_EQ(
-      12, evaluateWithTimestampWithTimezone<int64_t>("month(c0)", 0, "-01:00"));
-  EXPECT_EQ(
-      1, evaluateWithTimestampWithTimezone<int64_t>("month(c0)", 0, "+00:00"));
+  const auto monthTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "month(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
+  EXPECT_EQ(12, monthTimestampWithTimezone(TimestampWithTimezone(0, "-01:00")));
+  EXPECT_EQ(1, monthTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
       11,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "month(c0)", 123456789000, "+14:00"));
+      monthTimestampWithTimezone(
+          TimestampWithTimezone(123456789000, "+14:00")));
   EXPECT_EQ(
       2,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "month(c0)", -123456789000, "+03:00"));
+      monthTimestampWithTimezone(
+          TimestampWithTimezone(-123456789000, "+03:00")));
   EXPECT_EQ(
       4,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "month(c0)", 987654321000, "-07:00"));
+      monthTimestampWithTimezone(
+          TimestampWithTimezone(987654321000, "-07:00")));
   EXPECT_EQ(
       9,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "month(c0)", -987654321000, "-13:00"));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "month(c0)", std::nullopt, std::nullopt));
+      monthTimestampWithTimezone(
+          TimestampWithTimezone(-987654321000, "-13:00")));
+  EXPECT_EQ(std::nullopt, monthTimestampWithTimezone(std::nullopt));
 }
 
 TEST_F(DateTimeFunctionsTest, hour) {
@@ -708,47 +695,36 @@ TEST_F(DateTimeFunctionsTest, hour) {
 }
 
 TEST_F(DateTimeFunctionsTest, hourTimestampWithTimezone) {
+  const auto hourTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "hour(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
   EXPECT_EQ(
       20,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", 998423705000, "+01:00"));
+      hourTimestampWithTimezone(TimestampWithTimezone(998423705000, "+01:00")));
   EXPECT_EQ(
-      12,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", 41028000, "+01:00"));
+      12, hourTimestampWithTimezone(TimestampWithTimezone(41028000, "+01:00")));
   EXPECT_EQ(
-      13,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", 41028000, "+02:00"));
+      13, hourTimestampWithTimezone(TimestampWithTimezone(41028000, "+02:00")));
   EXPECT_EQ(
-      14,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", 41028000, "+03:00"));
-  EXPECT_EQ(
-      8,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", 41028000, "-03:00"));
+      14, hourTimestampWithTimezone(TimestampWithTimezone(41028000, "+03:00")));
   EXPECT_EQ(
-      1,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", 41028000, "+14:00"));
+      8, hourTimestampWithTimezone(TimestampWithTimezone(41028000, "-03:00")));
   EXPECT_EQ(
-      9,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", -100000, "-14:00"));
+      1, hourTimestampWithTimezone(TimestampWithTimezone(41028000, "+14:00")));
   EXPECT_EQ(
-      2,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", -41028000, "+14:00"));
+      9, hourTimestampWithTimezone(TimestampWithTimezone(-100000, "-14:00")));
   EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "hour(c0)", std::nullopt, std::nullopt));
+      2, hourTimestampWithTimezone(TimestampWithTimezone(-41028000, "+14:00")));
+  EXPECT_EQ(std::nullopt, hourTimestampWithTimezone(std::nullopt));
 }
 
 TEST_F(DateTimeFunctionsTest, hourDate) {
   const auto hour = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("hour(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("hour(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, hour(std::nullopt));
   EXPECT_EQ(0, hour(0));
@@ -784,7 +760,7 @@ TEST_F(DateTimeFunctionsTest, dayOfMonth) {
 
 TEST_F(DateTimeFunctionsTest, dayOfMonthDate) {
   const auto day = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("day_of_month(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("day_of_month(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, day(std::nullopt));
   EXPECT_EQ(1, day(0));
@@ -795,6 +771,59 @@ TEST_F(DateTimeFunctionsTest, dayOfMonthDate) {
   EXPECT_EQ(2, day(-18262));
 }
 
+TEST_F(DateTimeFunctionsTest, dayOfMonthInterval) {
+  const auto day = [&](std::optional<int64_t> millis) {
+    auto result =
+        evaluateOnce<int64_t>("day_of_month(c0)", INTERVAL_DAY_TIME(), millis);
+
+    auto result2 =
+        evaluateOnce<int64_t>("day(c0)", INTERVAL_DAY_TIME(), millis);
+
+    EXPECT_EQ(result, result2);
+    return result;
+  };
+
+  EXPECT_EQ(1, day(kMillisInDay));
+  EXPECT_EQ(1, day(kMillisInDay + kMillisInHour));
+  EXPECT_EQ(10, day(10 * kMillisInDay + 7 * kMillisInHour));
+  EXPECT_EQ(-10, day(-10 * kMillisInDay - 7 * kMillisInHour));
+}
+
+TEST_F(DateTimeFunctionsTest, plusMinusDateIntervalYearMonth) {
+  const auto makeInput = [&](const std::string& date, int32_t interval) {
+    return makeRowVector({
+        makeNullableFlatVector<int32_t>({parseDate(date)}, DATE()),
+        makeNullableFlatVector<int32_t>({interval}, INTERVAL_YEAR_MONTH()),
+    });
+  };
+
+  const auto plus = [&](const std::string& date, int32_t interval) {
+    return evaluateOnce<int32_t>("c0 + c1", makeInput(date, interval));
+  };
+
+  const auto minus = [&](const std::string& date, int32_t interval) {
+    return evaluateOnce<int32_t>("c0 - c1", makeInput(date, interval));
+  };
+
+  EXPECT_EQ(parseDate("2021-10-15"), plus("2020-10-15", 12));
+  EXPECT_EQ(parseDate("2022-01-15"), plus("2020-10-15", 15));
+  EXPECT_EQ(parseDate("2020-11-15"), plus("2020-10-15", 1));
+  EXPECT_EQ(parseDate("2020-11-30"), plus("2020-10-30", 1));
+  EXPECT_EQ(parseDate("2020-11-30"), plus("2020-10-31", 1));
+  EXPECT_EQ(parseDate("2021-02-28"), plus("2020-02-28", 12));
+  EXPECT_EQ(parseDate("2021-02-28"), plus("2020-02-29", 12));
+  EXPECT_EQ(parseDate("2016-02-29"), plus("2020-02-29", -48));
+
+  EXPECT_EQ(parseDate("2019-10-15"), minus("2020-10-15", 12));
+  EXPECT_EQ(parseDate("2019-07-15"), minus("2020-10-15", 15));
+  EXPECT_EQ(parseDate("2020-09-15"), minus("2020-10-15", 1));
+  EXPECT_EQ(parseDate("2020-09-30"), minus("2020-10-30", 1));
+  EXPECT_EQ(parseDate("2020-09-30"), minus("2020-10-31", 1));
+  EXPECT_EQ(parseDate("2019-02-28"), minus("2020-02-29", 12));
+  EXPECT_EQ(parseDate("2019-02-28"), minus("2020-02-28", 12));
+  EXPECT_EQ(parseDate("2024-02-29"), minus("2020-02-29", -48));
+}
+
 TEST_F(DateTimeFunctionsTest, plusMinusDateIntervalDayTime) {
   const auto plus = [&](std::optional<int32_t> date,
                         std::optional<int64_t> interval) {
@@ -837,7 +866,217 @@ TEST_F(DateTimeFunctionsTest, plusMinusDateIntervalDayTime) {
   EXPECT_THROW(minus(baseDate, partDay), VeloxUserError);
 }
 
-TEST_F(DateTimeFunctionsTest, minusTimestampIntervalDayTime) {
+TEST_F(DateTimeFunctionsTest, timestampMinusIntervalYearMonth) {
+  const auto minus = [&](std::optional<std::string> timestamp,
+                         std::optional<int32_t> interval) {
+    return evaluateOnce<std::string>(
+        "date_format(date_parse(c0, '%Y-%m-%d %H:%i:%s') - c1, '%Y-%m-%d %H:%i:%s')",
+        makeRowVector({
+            makeNullableFlatVector<std::string>({timestamp}, VARCHAR()),
+            makeNullableFlatVector<int32_t>({interval}, INTERVAL_YEAR_MONTH()),
+        }));
+  };
+
+  EXPECT_EQ("2001-01-03 04:05:06", minus("2001-02-03 04:05:06", 1));
+  EXPECT_EQ("2000-04-03 04:05:06", minus("2001-02-03 04:05:06", 10));
+  EXPECT_EQ("1999-06-03 04:05:06", minus("2001-02-03 04:05:06", 20));
+
+  // Some special dates.
+  EXPECT_EQ("2001-04-30 04:05:06", minus("2001-05-31 04:05:06", 1));
+  EXPECT_EQ("2001-03-30 04:05:06", minus("2001-04-30 04:05:06", 1));
+  EXPECT_EQ("2001-02-28 04:05:06", minus("2001-03-30 04:05:06", 1));
+  EXPECT_EQ("2000-02-29 04:05:06", minus("2000-03-30 04:05:06", 1));
+  EXPECT_EQ("2000-01-29 04:05:06", minus("2000-02-29 04:05:06", 1));
+
+  // Check if it does the right thing if we cross daylight saving boundaries.
+  setQueryTimeZone("America/Los_Angeles");
+  EXPECT_EQ("2024-01-01 00:00:00", minus("2024-07-01 00:00:00", 6));
+  EXPECT_EQ("2023-07-01 00:00:00", minus("2024-01-01 00:00:00", 6));
+}
+
+TEST_F(DateTimeFunctionsTest, timestampPlusIntervalYearMonth) {
+  const auto plus = [&](std::optional<std::string> timestamp,
+                        std::optional<int32_t> interval) {
+    // timestamp + interval.
+    auto result1 = evaluateOnce<std::string>(
+        "date_format(date_parse(c0, '%Y-%m-%d %H:%i:%s') + c1, '%Y-%m-%d %H:%i:%s')",
+        makeRowVector(
+            {makeNullableFlatVector<std::string>({timestamp}, VARCHAR()),
+             makeNullableFlatVector<int32_t>(
+                 {interval}, INTERVAL_YEAR_MONTH())}));
+
+    // interval + timestamp.
+    auto result2 = evaluateOnce<std::string>(
+        "date_format(c1 + date_parse(c0, '%Y-%m-%d %H:%i:%s'), '%Y-%m-%d %H:%i:%s')",
+        makeRowVector(
+            {makeNullableFlatVector<std::string>({timestamp}, VARCHAR()),
+             makeNullableFlatVector<int32_t>(
+                 {interval}, INTERVAL_YEAR_MONTH())}));
+
+    // They should be the same.
+    EXPECT_EQ(result1, result2);
+    return result1;
+  };
+
+  EXPECT_EQ("2001-02-03 04:05:06", plus("2001-01-03 04:05:06", 1));
+  EXPECT_EQ("2001-02-03 04:05:06", plus("2000-04-03 04:05:06", 10));
+  EXPECT_EQ("2001-02-03 04:05:06", plus("1999-06-03 04:05:06", 20));
+
+  // Some special dates.
+  EXPECT_EQ("2001-06-30 04:05:06", plus("2001-05-31 04:05:06", 1));
+  EXPECT_EQ("2001-05-30 04:05:06", plus("2001-04-30 04:05:06", 1));
+  EXPECT_EQ("2001-02-28 04:05:06", plus("2001-01-31 04:05:06", 1));
+  EXPECT_EQ("2000-02-29 04:05:06", plus("2000-01-31 04:05:06", 1));
+  EXPECT_EQ("2000-02-29 04:05:06", plus("2000-01-29 04:05:06", 1));
+
+  // Check if it does the right thing if we cross daylight saving boundaries.
+  setQueryTimeZone("America/Los_Angeles");
+  EXPECT_EQ("2025-01-01 00:00:00", plus("2024-07-01 00:00:00", 6));
+  EXPECT_EQ("2024-07-01 00:00:00", plus("2024-01-01 00:00:00", 6));
+}
+
+TEST_F(DateTimeFunctionsTest, plusMinusTimestampIntervalDayTime) {
+  constexpr int64_t kLongMax = std::numeric_limits<int64_t>::max();
+  constexpr int64_t kLongMin = std::numeric_limits<int64_t>::min();
+
+  const auto minus = [&](std::optional<Timestamp> timestamp,
+                         std::optional<int64_t> interval) {
+    return evaluateOnce<Timestamp>(
+        "c0 - c1",
+        makeRowVector({
+            makeNullableFlatVector<Timestamp>({timestamp}),
+            makeNullableFlatVector<int64_t>({interval}, INTERVAL_DAY_TIME()),
+        }));
+  };
+
+  EXPECT_EQ(std::nullopt, minus(std::nullopt, std::nullopt));
+  EXPECT_EQ(std::nullopt, minus(std::nullopt, 1));
+  EXPECT_EQ(std::nullopt, minus(Timestamp(0, 0), std::nullopt));
+  EXPECT_EQ(Timestamp(0, 0), minus(Timestamp(0, 0), 0));
+  EXPECT_EQ(Timestamp(0, 0), minus(Timestamp(10, 0), 10'000));
+  EXPECT_EQ(Timestamp(-10, 0), minus(Timestamp(10, 0), 20'000));
+  EXPECT_EQ(
+      Timestamp(-2, 50 * Timestamp::kNanosecondsInMillisecond),
+      minus(Timestamp(0, 50 * Timestamp::kNanosecondsInMillisecond), 2'000));
+  EXPECT_EQ(
+      Timestamp(-3, 995 * Timestamp::kNanosecondsInMillisecond),
+      minus(Timestamp(0, 0), 2'005));
+  EXPECT_EQ(
+      Timestamp(9223372036854774, 809000000),
+      minus(Timestamp(-1, 0), kLongMax));
+  EXPECT_EQ(
+      Timestamp(-9223372036854775, 192000000),
+      minus(Timestamp(1, 0), kLongMin));
+
+  const auto plusAndVerify = [&](std::optional<Timestamp> timestamp,
+                                 std::optional<int64_t> interval,
+                                 std::optional<Timestamp> expected) {
+    EXPECT_EQ(
+        expected,
+        evaluateOnce<Timestamp>(
+            "c0 + c1",
+            makeRowVector({
+                makeNullableFlatVector<Timestamp>({timestamp}),
+                makeNullableFlatVector<int64_t>(
+                    {interval}, INTERVAL_DAY_TIME()),
+            })));
+    EXPECT_EQ(
+        expected,
+        evaluateOnce<Timestamp>(
+            "c1 + c0",
+            makeRowVector({
+                makeNullableFlatVector<Timestamp>({timestamp}),
+                makeNullableFlatVector<int64_t>(
+                    {interval}, INTERVAL_DAY_TIME()),
+            })));
+  };
+
+  plusAndVerify(std::nullopt, std::nullopt, std::nullopt);
+  plusAndVerify(std::nullopt, 1, std::nullopt);
+  plusAndVerify(Timestamp(0, 0), std::nullopt, std::nullopt);
+  plusAndVerify(Timestamp(0, 0), 0, Timestamp(0, 0));
+  plusAndVerify(Timestamp(0, 0), 10'000, Timestamp(10, 0));
+  plusAndVerify(
+      Timestamp(0, 0),
+      20'005,
+      Timestamp(20, 5 * Timestamp::kNanosecondsInMillisecond));
+  plusAndVerify(
+      Timestamp(0, 0),
+      -30'005,
+      Timestamp(-31, 995 * Timestamp::kNanosecondsInMillisecond));
+  plusAndVerify(
+      Timestamp(1, 0), kLongMax, Timestamp(-9223372036854775, 191000000));
+  plusAndVerify(
+      Timestamp(0, 0), kLongMin, Timestamp(-9223372036854776, 192000000));
+  plusAndVerify(
+      Timestamp(-1, 0), kLongMin, Timestamp(9223372036854774, 808000000));
+}
+
+TEST_F(DateTimeFunctionsTest, timestampWithTimeZonePlusIntervalDayTime) {
+  auto test = [&](const std::string& timestamp, int64_t interval) {
+    // ts + interval == interval + ts == ts - (-interval) ==
+    // date_add('millisecond', interval, ts).
+    auto plusResult =
+        evaluateOnce<std::string>(
+            "cast(plus(cast(c0 as timestamp with time zone), c1) as varchar)",
+            {VARCHAR(), INTERVAL_DAY_TIME()},
+            std::optional(timestamp),
+            std::optional(interval))
+            .value();
+
+    auto minusResult =
+        evaluateOnce<std::string>(
+            "cast(minus(cast(c0 as timestamp with time zone), c1) as varchar)",
+            {VARCHAR(), INTERVAL_DAY_TIME()},
+            std::optional(timestamp),
+            std::optional(-interval))
+            .value();
+
+    auto otherPlusResult =
+        evaluateOnce<std::string>(
+            "cast(plus(c1, cast(c0 as timestamp with time zone)) as varchar)",
+            {VARCHAR(), INTERVAL_DAY_TIME()},
+            std::optional(timestamp),
+            std::optional(interval))
+            .value();
+
+    auto dateAddResult =
+        evaluateOnce<std::string>(
+            "cast(date_add('millisecond', c1, cast(c0 as timestamp with time zone)) as varchar)",
+            std::optional(timestamp),
+            std::optional(interval))
+            .value();
+
+    VELOX_CHECK_EQ(plusResult, minusResult);
+    VELOX_CHECK_EQ(plusResult, otherPlusResult);
+    VELOX_CHECK_EQ(plusResult, dateAddResult);
+    return plusResult;
+  };
+
+  EXPECT_EQ(
+      "2024-10-04 01:50:00.000 America/Los_Angeles",
+      test("2024-10-03 01:50 America/Los_Angeles", 1 * kMillisInDay));
+  EXPECT_EQ(
+      "2024-10-03 02:50:00.000 America/Los_Angeles",
+      test("2024-10-03 01:50 America/Los_Angeles", 1 * kMillisInHour));
+  EXPECT_EQ(
+      "2024-10-03 01:51:00.000 America/Los_Angeles",
+      test("2024-10-03 01:50 America/Los_Angeles", 1 * kMillisInMinute));
+
+  // Testing daylight saving transitions.
+
+  // At the beginning there is a 1 hour gap.
+  EXPECT_EQ(
+      "2024-03-10 01:30:00.000 America/Los_Angeles",
+      test("2024-03-10 03:30 America/Los_Angeles", -1 * kMillisInHour));
+
+  // At the end there is a 1 hour duplication.
+  EXPECT_EQ(
+      "2024-11-03 01:30:00.000 America/Los_Angeles",
+      test("2024-11-03 01:30 America/Los_Angeles", 1 * kMillisInHour));
+}
+
+TEST_F(DateTimeFunctionsTest, minusTimestamp) {
   const auto minus = [&](std::optional<int64_t> t1, std::optional<int64_t> t2) {
     const auto timestamp1 = (t1.has_value()) ? Timestamp(t1.value(), 0)
                                              : std::optional<Timestamp>();
@@ -858,38 +1097,78 @@ TEST_F(DateTimeFunctionsTest, minusTimestampIntervalDayTime) {
   EXPECT_EQ(-1000, minus(1, 2));
   VELOX_ASSERT_THROW(
       minus(Timestamp::kMinSeconds, Timestamp::kMaxSeconds),
-      "integer overflow");
+      "Could not convert Timestamp(-9223372036854776, 0) to milliseconds");
+}
+
+TEST_F(DateTimeFunctionsTest, minusTimestampWithTimezone) {
+  auto minus = [&](const std::string& a, const std::string& b) {
+    const auto sql =
+        "cast(c0 as timestamp with time zone) - cast(c1 as timestamp with time zone)";
+
+    auto result =
+        evaluateOnce<int64_t>(sql, std::optional(a), std::optional(b));
+    auto negativeResult =
+        evaluateOnce<int64_t>(sql, std::optional(b), std::optional(a));
+
+    // a - b == -(b - a)
+    VELOX_CHECK_EQ(result.value(), -negativeResult.value());
+    return result.value();
+  };
+
+  EXPECT_EQ(
+      0,
+      minus(
+          "2024-04-15 10:20:33 America/New_York",
+          "2024-04-15 10:20:33 America/New_York"));
+
+  EXPECT_EQ(
+      0,
+      minus(
+          "2024-04-15 13:20:33 America/New_York",
+          "2024-04-15 10:20:33 America/Los_Angeles"));
+
+  EXPECT_EQ(
+      -1 * kMillisInHour - 2 * kMillisInMinute - 3 * kMillisInSecond,
+      minus(
+          "2024-04-15 10:20:33 America/New_York",
+          "2024-04-15 11:22:36 America/New_York"));
+
+  EXPECT_EQ(
+      -1 * kMillisInHour - 2 * kMillisInMinute - 3 * kMillisInSecond,
+      minus(
+          "2024-04-15 07:20:33 America/Los_Angeles",
+          "2024-04-15 11:22:36 America/New_York"));
 }
 
 TEST_F(DateTimeFunctionsTest, dayOfMonthTimestampWithTimezone) {
+  const auto dayOfMonthTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "day_of_month(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
   EXPECT_EQ(
-      31,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_month(c0)", 0, "-01:00"));
+      31, dayOfMonthTimestampWithTimezone(TimestampWithTimezone(0, "-01:00")));
   EXPECT_EQ(
-      1,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_month(c0)", 0, "+00:00"));
+      1, dayOfMonthTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
       30,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_month(c0)", 123456789000, "+14:00"));
+      dayOfMonthTimestampWithTimezone(
+          TimestampWithTimezone(123456789000, "+14:00")));
   EXPECT_EQ(
       2,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_month(c0)", -123456789000, "+03:00"));
+      dayOfMonthTimestampWithTimezone(
+          TimestampWithTimezone(-123456789000, "+03:00")));
   EXPECT_EQ(
       18,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_month(c0)", 987654321000, "-07:00"));
+      dayOfMonthTimestampWithTimezone(
+          TimestampWithTimezone(987654321000, "-07:00")));
   EXPECT_EQ(
       14,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_month(c0)", -987654321000, "-13:00"));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_month(c0)", std::nullopt, std::nullopt));
+      dayOfMonthTimestampWithTimezone(
+          TimestampWithTimezone(-987654321000, "-13:00")));
+  EXPECT_EQ(std::nullopt, dayOfMonthTimestampWithTimezone(std::nullopt));
 }
 
 TEST_F(DateTimeFunctionsTest, dayOfWeek) {
@@ -923,7 +1202,7 @@ TEST_F(DateTimeFunctionsTest, dayOfWeek) {
 
 TEST_F(DateTimeFunctionsTest, dayOfWeekDate) {
   const auto day = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("day_of_week(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("day_of_week(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, day(std::nullopt));
   EXPECT_EQ(4, day(0));
@@ -935,34 +1214,34 @@ TEST_F(DateTimeFunctionsTest, dayOfWeekDate) {
 }
 
 TEST_F(DateTimeFunctionsTest, dayOfWeekTimestampWithTimezone) {
+  const auto dayOfWeekTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "day_of_week(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
   EXPECT_EQ(
-      3,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_week(c0)", 0, "-01:00"));
+      3, dayOfWeekTimestampWithTimezone(TimestampWithTimezone(0, "-01:00")));
   EXPECT_EQ(
-      4,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_week(c0)", 0, "+00:00"));
+      4, dayOfWeekTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
       5,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_week(c0)", 123456789000, "+14:00"));
+      dayOfWeekTimestampWithTimezone(
+          TimestampWithTimezone(123456789000, "+14:00")));
   EXPECT_EQ(
       3,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_week(c0)", -123456789000, "+03:00"));
+      dayOfWeekTimestampWithTimezone(
+          TimestampWithTimezone(-123456789000, "+03:00")));
   EXPECT_EQ(
       3,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_week(c0)", 987654321000, "-07:00"));
+      dayOfWeekTimestampWithTimezone(
+          TimestampWithTimezone(987654321000, "-07:00")));
   EXPECT_EQ(
       3,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_week(c0)", -987654321000, "-13:00"));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_week(c0)", std::nullopt, std::nullopt));
+      dayOfWeekTimestampWithTimezone(
+          TimestampWithTimezone(-987654321000, "-13:00")));
+  EXPECT_EQ(std::nullopt, dayOfWeekTimestampWithTimezone(std::nullopt));
 }
 
 TEST_F(DateTimeFunctionsTest, dayOfYear) {
@@ -990,7 +1269,7 @@ TEST_F(DateTimeFunctionsTest, dayOfYear) {
 
 TEST_F(DateTimeFunctionsTest, dayOfYearDate) {
   const auto day = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("day_of_year(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("day_of_year(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, day(std::nullopt));
   EXPECT_EQ(1, day(0));
@@ -1002,34 +1281,34 @@ TEST_F(DateTimeFunctionsTest, dayOfYearDate) {
 }
 
 TEST_F(DateTimeFunctionsTest, dayOfYearTimestampWithTimezone) {
+  const auto dayOfYearTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "day_of_year(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
   EXPECT_EQ(
-      365,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_year(c0)", 0, "-01:00"));
+      365, dayOfYearTimestampWithTimezone(TimestampWithTimezone(0, "-01:00")));
   EXPECT_EQ(
-      1,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_year(c0)", 0, "+00:00"));
+      1, dayOfYearTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
       334,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_year(c0)", 123456789000, "+14:00"));
+      dayOfYearTimestampWithTimezone(
+          TimestampWithTimezone(123456789000, "+14:00")));
   EXPECT_EQ(
       33,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_year(c0)", -123456789000, "+03:00"));
+      dayOfYearTimestampWithTimezone(
+          TimestampWithTimezone(-123456789000, "+03:00")));
   EXPECT_EQ(
       108,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_year(c0)", 987654321000, "-07:00"));
+      dayOfYearTimestampWithTimezone(
+          TimestampWithTimezone(987654321000, "-07:00")));
   EXPECT_EQ(
       257,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_year(c0)", -987654321000, "-13:00"));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "day_of_year(c0)", std::nullopt, std::nullopt));
+      dayOfYearTimestampWithTimezone(
+          TimestampWithTimezone(-987654321000, "-13:00")));
+  EXPECT_EQ(std::nullopt, dayOfYearTimestampWithTimezone(std::nullopt));
 }
 
 TEST_F(DateTimeFunctionsTest, yearOfWeek) {
@@ -1061,7 +1340,7 @@ TEST_F(DateTimeFunctionsTest, yearOfWeek) {
 
 TEST_F(DateTimeFunctionsTest, yearOfWeekDate) {
   const auto yow = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("year_of_week(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("year_of_week(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, yow(std::nullopt));
   EXPECT_EQ(1970, yow(0));
@@ -1075,34 +1354,36 @@ TEST_F(DateTimeFunctionsTest, yearOfWeekDate) {
 }
 
 TEST_F(DateTimeFunctionsTest, yearOfWeekTimestampWithTimezone) {
+  const auto yearOfWeekTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "year_of_week(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
   EXPECT_EQ(
       1970,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year_of_week(c0)", 0, "-01:00"));
+      yearOfWeekTimestampWithTimezone(TimestampWithTimezone(0, "-01:00")));
   EXPECT_EQ(
       1970,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year_of_week(c0)", 0, "+00:00"));
+      yearOfWeekTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
       1973,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year_of_week(c0)", 123456789000, "+14:00"));
+      yearOfWeekTimestampWithTimezone(
+          TimestampWithTimezone(123456789000, "+14:00")));
   EXPECT_EQ(
       1966,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year_of_week(c0)", -123456789000, "+03:00"));
+      yearOfWeekTimestampWithTimezone(
+          TimestampWithTimezone(-123456789000, "+03:00")));
   EXPECT_EQ(
       2001,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year_of_week(c0)", 987654321000, "-07:00"));
+      yearOfWeekTimestampWithTimezone(
+          TimestampWithTimezone(987654321000, "-07:00")));
   EXPECT_EQ(
       1938,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year_of_week(c0)", -987654321000, "-13:00"));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "year_of_week(c0)", std::nullopt, std::nullopt));
+      yearOfWeekTimestampWithTimezone(
+          TimestampWithTimezone(-987654321000, "-13:00")));
+  EXPECT_EQ(std::nullopt, yearOfWeekTimestampWithTimezone(std::nullopt));
 }
 
 TEST_F(DateTimeFunctionsTest, minute) {
@@ -1130,7 +1411,7 @@ TEST_F(DateTimeFunctionsTest, minute) {
 
 TEST_F(DateTimeFunctionsTest, minuteDate) {
   const auto minute = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("minute(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("minute(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, minute(std::nullopt));
   EXPECT_EQ(0, minute(0));
@@ -1142,43 +1423,37 @@ TEST_F(DateTimeFunctionsTest, minuteDate) {
 }
 
 TEST_F(DateTimeFunctionsTest, minuteTimestampWithTimezone) {
+  const auto minuteTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "minute(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
+  EXPECT_EQ(std::nullopt, minuteTimestampWithTimezone(std::nullopt));
+  EXPECT_EQ(0, minuteTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "minute(c0)", std::nullopt, std::nullopt));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "minute(c0)", std::nullopt, "Asia/Kolkata"));
-  EXPECT_EQ(
-      0, evaluateWithTimestampWithTimezone<int64_t>("minute(c0)", 0, "+00:00"));
-  EXPECT_EQ(
-      30,
-      evaluateWithTimestampWithTimezone<int64_t>("minute(c0)", 0, "+05:30"));
+      30, minuteTimestampWithTimezone(TimestampWithTimezone(0, "+05:30")));
   EXPECT_EQ(
       6,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "minute(c0)", 4000000000000, "+00:00"));
+      minuteTimestampWithTimezone(
+          TimestampWithTimezone(4000000000000, "+00:00")));
   EXPECT_EQ(
       36,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "minute(c0)", 4000000000000, "+05:30"));
+      minuteTimestampWithTimezone(
+          TimestampWithTimezone(4000000000000, "+05:30")));
   EXPECT_EQ(
       4,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "minute(c0)", 998474645000, "+00:00"));
+      minuteTimestampWithTimezone(
+          TimestampWithTimezone(998474645000, "+00:00")));
   EXPECT_EQ(
       34,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "minute(c0)", 998474645000, "+05:30"));
+      minuteTimestampWithTimezone(
+          TimestampWithTimezone(998474645000, "+05:30")));
   EXPECT_EQ(
-      59,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "minute(c0)", -1000, "+00:00"));
+      59, minuteTimestampWithTimezone(TimestampWithTimezone(-1000, "+00:00")));
   EXPECT_EQ(
-      29,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "minute(c0)", -1000, "+05:30"));
+      29, minuteTimestampWithTimezone(TimestampWithTimezone(-1000, "+05:30")));
 }
 
 TEST_F(DateTimeFunctionsTest, second) {
@@ -1194,7 +1469,7 @@ TEST_F(DateTimeFunctionsTest, second) {
 
 TEST_F(DateTimeFunctionsTest, secondDate) {
   const auto second = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("second(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("second(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, second(std::nullopt));
   EXPECT_EQ(0, second(0));
@@ -1206,34 +1481,28 @@ TEST_F(DateTimeFunctionsTest, secondDate) {
 }
 
 TEST_F(DateTimeFunctionsTest, secondTimestampWithTimezone) {
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "second(c0)", std::nullopt, std::nullopt));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "second(c0)", std::nullopt, "+05:30"));
-  EXPECT_EQ(
-      0, evaluateWithTimestampWithTimezone<int64_t>("second(c0)", 0, "+00:00"));
-  EXPECT_EQ(
-      0, evaluateWithTimestampWithTimezone<int64_t>("second(c0)", 0, "+05:30"));
+  const auto secondTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "second(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
+  EXPECT_EQ(std::nullopt, secondTimestampWithTimezone(std::nullopt));
+  EXPECT_EQ(0, secondTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
+  EXPECT_EQ(0, secondTimestampWithTimezone(TimestampWithTimezone(0, "+05:30")));
   EXPECT_EQ(
       40,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "second(c0)", 4000000000000, "+00:00"));
+      secondTimestampWithTimezone(
+          TimestampWithTimezone(4000000000000, "+00:00")));
   EXPECT_EQ(
       40,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "second(c0)", 4000000000000, "+05:30"));
+      secondTimestampWithTimezone(
+          TimestampWithTimezone(4000000000000, "+05:30")));
   EXPECT_EQ(
-      59,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "second(c0)", -1000, "+00:00"));
+      59, secondTimestampWithTimezone(TimestampWithTimezone(-1000, "+00:00")));
   EXPECT_EQ(
-      59,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "second(c0)", -1000, "+05:30"));
+      59, secondTimestampWithTimezone(TimestampWithTimezone(-1000, "+05:30")));
 }
 
 TEST_F(DateTimeFunctionsTest, millisecond) {
@@ -1249,7 +1518,7 @@ TEST_F(DateTimeFunctionsTest, millisecond) {
 
 TEST_F(DateTimeFunctionsTest, millisecondDate) {
   const auto millisecond = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("millisecond(c0)", {date}, {DATE()});
+    return evaluateOnce<int64_t>("millisecond(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, millisecond(std::nullopt));
   EXPECT_EQ(0, millisecond(0));
@@ -1261,38 +1530,66 @@ TEST_F(DateTimeFunctionsTest, millisecondDate) {
 }
 
 TEST_F(DateTimeFunctionsTest, millisecondTimestampWithTimezone) {
+  const auto millisecondTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int64_t>(
+            "millisecond(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
+  EXPECT_EQ(std::nullopt, millisecondTimestampWithTimezone(std::nullopt));
   EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "millisecond(c0)", std::nullopt, std::nullopt));
-  EXPECT_EQ(
-      std::nullopt,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "millisecond(c0)", std::nullopt, "+05:30"));
-  EXPECT_EQ(
-      0,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "millisecond(c0)", 0, "+00:00"));
+      0, millisecondTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
-      0,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "millisecond(c0)", 0, "+05:30"));
+      0, millisecondTimestampWithTimezone(TimestampWithTimezone(0, "+05:30")));
   EXPECT_EQ(
       123,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "millisecond(c0)", 4000000000123, "+00:00"));
+      millisecondTimestampWithTimezone(
+          TimestampWithTimezone(4000000000123, "+00:00")));
   EXPECT_EQ(
       123,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "millisecond(c0)", 4000000000123, "+05:30"));
+      millisecondTimestampWithTimezone(
+          TimestampWithTimezone(4000000000123, "+05:30")));
   EXPECT_EQ(
       20,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "millisecond(c0)", -980, "+00:00"));
+      millisecondTimestampWithTimezone(TimestampWithTimezone(-980, "+00:00")));
   EXPECT_EQ(
       20,
-      evaluateWithTimestampWithTimezone<int64_t>(
-          "millisecond(c0)", -980, "+05:30"));
+      millisecondTimestampWithTimezone(TimestampWithTimezone(-980, "+05:30")));
+}
+
+TEST_F(DateTimeFunctionsTest, extractFromIntervalDayTime) {
+  const auto millis = 5 * kMillisInDay + 7 * kMillisInHour +
+      11 * kMillisInMinute + 13 * kMillisInSecond + 17;
+
+  auto extract = [&](const std::string& unit, int64_t millis) {
+    return evaluateOnce<int64_t>(
+               fmt::format("{}(c0)", unit),
+               INTERVAL_DAY_TIME(),
+               std::optional(millis))
+        .value();
+  };
+
+  EXPECT_EQ(17, extract("millisecond", millis));
+  EXPECT_EQ(13, extract("second", millis));
+  EXPECT_EQ(11, extract("minute", millis));
+  EXPECT_EQ(7, extract("hour", millis));
+  EXPECT_EQ(5, extract("day", millis));
+}
+
+TEST_F(DateTimeFunctionsTest, extractFromIntervalYearMonth) {
+  const auto months = 3 * 12 + 4;
+
+  auto extract = [&](const std::string& unit, int32_t months) {
+    return evaluateOnce<int64_t>(
+               fmt::format("{}(c0)", unit),
+               INTERVAL_YEAR_MONTH(),
+               std::optional(months))
+        .value();
+  };
+
+  EXPECT_EQ(3, extract("year", months));
+  EXPECT_EQ(4, extract("month", months));
 }
 
 TEST_F(DateTimeFunctionsTest, dateTrunc) {
@@ -1302,11 +1599,14 @@ TEST_F(DateTimeFunctionsTest, dateTrunc) {
         fmt::format("date_trunc('{}', c0)", unit), timestamp);
   };
 
-  setQueryTimeZone("America/Los_Angeles");
+  disableAdjustTimestampToTimezone();
 
   EXPECT_EQ(std::nullopt, dateTrunc("second", std::nullopt));
   EXPECT_EQ(Timestamp(0, 0), dateTrunc("second", Timestamp(0, 0)));
   EXPECT_EQ(Timestamp(0, 0), dateTrunc("second", Timestamp(0, 123)));
+  EXPECT_EQ(Timestamp(-1, 0), dateTrunc("second", Timestamp(-1, 0)));
+  EXPECT_EQ(Timestamp(-1, 0), dateTrunc("second", Timestamp(-1, 123)));
+  EXPECT_EQ(Timestamp(0, 0), dateTrunc("day", Timestamp(0, 123)));
   EXPECT_EQ(
       Timestamp(998474645, 0),
       dateTrunc("second", Timestamp(998'474'645, 321'001'234)));
@@ -1317,23 +1617,28 @@ TEST_F(DateTimeFunctionsTest, dateTrunc) {
       Timestamp(998474400, 0),
       dateTrunc("hour", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(998463600, 0),
+      Timestamp(998438400, 0),
       dateTrunc("day", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(996649200, 0),
+      Timestamp(998265600, 0),
+      dateTrunc("week", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(996624000, 0),
       dateTrunc("month", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(993970800, 0),
+      Timestamp(993945600, 0),
       dateTrunc("quarter", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(978336000, 0),
+      Timestamp(978307200, 0),
       dateTrunc("year", Timestamp(998'474'645, 321'001'234)));
 
-  setQueryTimeZone("Asia/Kolkata");
+  setQueryTimeZone("America/Los_Angeles");
 
   EXPECT_EQ(std::nullopt, dateTrunc("second", std::nullopt));
   EXPECT_EQ(Timestamp(0, 0), dateTrunc("second", Timestamp(0, 0)));
   EXPECT_EQ(Timestamp(0, 0), dateTrunc("second", Timestamp(0, 123)));
+
+  EXPECT_EQ(Timestamp(-57600, 0), dateTrunc("day", Timestamp(0, 0)));
   EXPECT_EQ(
       Timestamp(998474645, 0),
       dateTrunc("second", Timestamp(998'474'645, 321'001'234)));
@@ -1341,28 +1646,69 @@ TEST_F(DateTimeFunctionsTest, dateTrunc) {
       Timestamp(998474640, 0),
       dateTrunc("minute", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(998472600, 0),
+      Timestamp(998474400, 0),
       dateTrunc("hour", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(998418600, 0),
+      Timestamp(998463600, 0),
       dateTrunc("day", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(996604200, 0),
+      Timestamp(998290800, 0),
+      dateTrunc("week", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(996649200, 0),
       dateTrunc("month", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(993925800, 0),
+      Timestamp(993970800, 0),
       dateTrunc("quarter", Timestamp(998'474'645, 321'001'234)));
   EXPECT_EQ(
-      Timestamp(978287400, 0),
+      Timestamp(978336000, 0),
       dateTrunc("year", Timestamp(998'474'645, 321'001'234)));
-}
 
-TEST_F(DateTimeFunctionsTest, dateTruncDate) {
-  const auto dateTrunc = [&](const std::string& unit,
-                             std::optional<int32_t> date) {
-    return evaluateOnce<int32_t, int32_t>(
-        fmt::format("date_trunc('{}', c0)", unit), {date}, {DATE()});
-  };
+  // Check that truncation during daylight saving transition where conversions
+  // may be ambiguous return the right values.
+  EXPECT_EQ(
+      Timestamp(1667725200, 0), dateTrunc("hour", Timestamp(1667725200, 0)));
+  EXPECT_EQ(
+      Timestamp(1667725200, 0), dateTrunc("minute", Timestamp(1667725200, 0)));
+
+  setQueryTimeZone("Asia/Kolkata");
+
+  EXPECT_EQ(std::nullopt, dateTrunc("second", std::nullopt));
+  EXPECT_EQ(Timestamp(0, 0), dateTrunc("second", Timestamp(0, 0)));
+  EXPECT_EQ(Timestamp(0, 0), dateTrunc("second", Timestamp(0, 123)));
+  EXPECT_EQ(Timestamp(-19800, 0), dateTrunc("day", Timestamp(0, 0)));
+  EXPECT_EQ(
+      Timestamp(998474645, 0),
+      dateTrunc("second", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(998474640, 0),
+      dateTrunc("minute", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(998472600, 0),
+      dateTrunc("hour", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(998418600, 0),
+      dateTrunc("day", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(998245800, 0),
+      dateTrunc("week", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(996604200, 0),
+      dateTrunc("month", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(993925800, 0),
+      dateTrunc("quarter", Timestamp(998'474'645, 321'001'234)));
+  EXPECT_EQ(
+      Timestamp(978287400, 0),
+      dateTrunc("year", Timestamp(998'474'645, 321'001'234)));
+}
+
+TEST_F(DateTimeFunctionsTest, dateTruncDate) {
+  const auto dateTrunc = [&](const std::string& unit,
+                             std::optional<int32_t> date) {
+    return evaluateOnce<int32_t>(
+        fmt::format("date_trunc('{}', c0)", unit), DATE(), date);
+  };
 
   EXPECT_EQ(std::nullopt, dateTrunc("year", std::nullopt));
 
@@ -1397,8 +1743,8 @@ TEST_F(DateTimeFunctionsTest, dateTruncDate) {
 TEST_F(DateTimeFunctionsTest, dateTruncDateForWeek) {
   const auto dateTrunc = [&](const std::string& unit,
                              std::optional<int32_t> date) {
-    return evaluateOnce<int32_t, int32_t>(
-        fmt::format("date_trunc('{}', c0)", unit), {date}, {DATE()});
+    return evaluateOnce<int32_t>(
+        fmt::format("date_trunc('{}', c0)", unit), DATE(), date);
   };
 
   // Date(19576) is 2023-08-07, which is Monday, should return Monday
@@ -1509,11 +1855,11 @@ TEST_F(DateTimeFunctionsTest, dateTruncTimeStampWithTimezoneStringForWeek) {
                                                 const std::string&
                                                     expectedTimestamp) {
     assertEqualVectors(
-        evaluate<RowVector>(
+        evaluate<FlatVector<int64_t>>(
             "parse_datetime(c0, 'YYYY-MM-dd+HH:mm:ssZZ')",
             makeRowVector({makeNullableFlatVector<StringView>(
                 {StringView{expectedTimestamp}})})),
-        evaluate<RowVector>(
+        evaluate<FlatVector<int64_t>>(
             fmt::format(
                 "date_trunc('{}', parse_datetime(c0, 'YYYY-MM-dd+HH:mm:ssZZ'))",
                 truncUnit),
@@ -1601,11 +1947,11 @@ TEST_F(DateTimeFunctionsTest, dateTruncTimestampWithTimezone) {
                                                 const std::string&
                                                     expectedTimestamp) {
     assertEqualVectors(
-        evaluate<RowVector>(
+        evaluate<FlatVector<int64_t>>(
             "parse_datetime(c0, 'YYYY-MM-dd+HH:mm:ssZZ')",
             makeRowVector({makeNullableFlatVector<StringView>(
                 {StringView{expectedTimestamp}})})),
-        evaluate<RowVector>(
+        evaluate<FlatVector<int64_t>>(
             fmt::format(
                 "date_trunc('{}', parse_datetime(c0, 'YYYY-MM-dd+HH:mm:ssZZ'))",
                 truncUnit),
@@ -1643,10 +1989,11 @@ TEST_F(DateTimeFunctionsTest, dateAddDate) {
   const auto dateAdd = [&](const std::string& unit,
                            std::optional<int32_t> value,
                            std::optional<int32_t> date) {
-    return evaluateOnce<int32_t, int32_t>(
+    return evaluateOnce<int32_t>(
         fmt::format("date_add('{}', c0, c1)", unit),
-        {value, date},
-        {INTEGER(), DATE()});
+        {INTEGER(), DATE()},
+        value,
+        date);
   };
 
   // Check null behaviors
@@ -1663,6 +2010,8 @@ TEST_F(DateTimeFunctionsTest, dateAddDate) {
   // Simple tests
   EXPECT_EQ(
       parseDate("2019-03-01"), dateAdd("day", 1, parseDate("2019-02-28")));
+  EXPECT_EQ(
+      parseDate("2019-03-07"), dateAdd("week", 1, parseDate("2019-02-28")));
   EXPECT_EQ(
       parseDate("2020-03-28"), dateAdd("month", 13, parseDate("2019-02-28")));
   EXPECT_EQ(
@@ -1683,6 +2032,8 @@ TEST_F(DateTimeFunctionsTest, dateAddDate) {
   // Check for negative intervals
   EXPECT_EQ(
       parseDate("2019-02-28"), dateAdd("day", -366, parseDate("2020-02-29")));
+  EXPECT_EQ(
+      parseDate("2020-02-15"), dateAdd("week", -2, parseDate("2020-02-29")));
   EXPECT_EQ(
       parseDate("2019-02-28"), dateAdd("month", -12, parseDate("2020-02-29")));
   EXPECT_EQ(
@@ -1704,7 +2055,10 @@ TEST_F(DateTimeFunctionsTest, dateAddTimestamp) {
   EXPECT_EQ(std::nullopt, dateAdd("month", std::nullopt, Timestamp(0, 0)));
 
   // Check invalid units
-  EXPECT_THROW(dateAdd("invalid_unit", 1, Timestamp(0, 0)), VeloxUserError);
+  auto ts = Timestamp(0, 0);
+  VELOX_ASSERT_THROW(
+      dateAdd("invalid_unit", 1, ts),
+      "Unsupported datetime unit: invalid_unit");
 
   // Simple tests
   EXPECT_EQ(
@@ -1737,6 +2091,9 @@ TEST_F(DateTimeFunctionsTest, dateAddTimestamp) {
           "day",
           1,
           Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      parseTimestamp("2019-03-07 10:00:00.500"),
+      dateAdd("week", 1, parseTimestamp("2019-02-28 10:00:00.500")));
   EXPECT_EQ(
       Timestamp(1585389600, 500'999'999) /*2020-03-28 10:00:00.500*/,
       dateAdd(
@@ -1975,35 +2332,38 @@ TEST_F(DateTimeFunctionsTest, dateAddTimestamp) {
 }
 
 TEST_F(DateTimeFunctionsTest, dateAddTimestampWithTimeZone) {
-  const auto dateAdd = [&](const std::string& unit,
-                           std::optional<int32_t> value,
-                           std::optional<int64_t> timestamp,
-                           const std::optional<std::string>& timeZoneName) {
-    return evaluateWithTimestampWithTimezone(
-        fmt::format("date_add('{}', {}, c0)", unit, *value),
-        timestamp,
-        timeZoneName);
-  };
+  auto dateAdd =
+      [&](std::optional<std::string> unit,
+          std::optional<int32_t> value,
+          std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        auto result = evaluateOnce<int64_t>(
+            "date_add(c0, c1, c2)",
+            {VARCHAR(), INTEGER(), TIMESTAMP_WITH_TIME_ZONE()},
+            unit,
+            value,
+            TimestampWithTimezone::pack(timestampWithTimezone));
+        return TimestampWithTimezone::unpack(result);
+      };
 
   // 1970-01-01 00:00:00.000 UTC-8
-  auto result = dateAdd("day", 5, 0, "-08:00");
-  auto expected = makeTimestampWithTimeZoneVector(432000000, "-08:00");
-  assertEqualVectors(expected, result);
+  EXPECT_EQ(
+      TimestampWithTimezone(432000000, "-08:00"),
+      dateAdd("day", 5, TimestampWithTimezone(0, "-08:00")));
 
   // 2023-01-08 00:00:00.000 UTC-8
-  result = dateAdd("day", -7, 1673136000, "-08:00");
-  expected = makeTimestampWithTimeZoneVector(1068336000, "-08:00");
-  assertEqualVectors(expected, result);
+  EXPECT_EQ(
+      TimestampWithTimezone(1068336000, "-08:00"),
+      dateAdd("day", -7, TimestampWithTimezone(1673136000, "-08:00")));
 
   // 2023-01-08 00:00:00.000 UTC-8
-  result = dateAdd("millisecond", -7, 1673136000, "-08:00");
-  expected = makeTimestampWithTimeZoneVector(1673135993, "-08:00");
-  assertEqualVectors(expected, result);
+  EXPECT_EQ(
+      TimestampWithTimezone(1673135993, "-08:00"),
+      dateAdd("millisecond", -7, TimestampWithTimezone(1673136000, "-08:00")));
 
   // 2023-01-08 00:00:00.000 UTC-8
-  result = dateAdd("millisecond", +7, 1673136000, "-08:00");
-  expected = makeTimestampWithTimeZoneVector(1673136007, "-08:00");
-  assertEqualVectors(expected, result);
+  EXPECT_EQ(
+      TimestampWithTimezone(1673136007, "-08:00"),
+      dateAdd("millisecond", +7, TimestampWithTimezone(1673136000, "-08:00")));
 
   const auto evaluateDateAddFromStrings = [&](const std::string& unit,
                                               int32_t value,
@@ -2011,11 +2371,11 @@ TEST_F(DateTimeFunctionsTest, dateAddTimestampWithTimeZone) {
                                               const std::string&
                                                   expectedTimestamp) {
     assertEqualVectors(
-        evaluate<RowVector>(
+        evaluate<FlatVector<int64_t>>(
             "parse_datetime(c0, 'YYYY-MM-dd+HH:mm:ssZZ')",
             makeRowVector({makeNullableFlatVector<StringView>(
                 {StringView{expectedTimestamp}})})),
-        evaluate<RowVector>(
+        evaluate<FlatVector<int64_t>>(
             fmt::format(
                 "date_add('{}', {}, parse_datetime(c0, 'YYYY-MM-dd+HH:mm:ssZZ'))",
                 unit,
@@ -2050,16 +2410,42 @@ TEST_F(DateTimeFunctionsTest, dateAddTimestampWithTimeZone) {
       "year", 3, "1972-05-20+23:01:02+14:00", "1975-05-20+23:01:02+14:00");
   evaluateDateAddFromStrings(
       "year", 3, "1968-02-20+23:01:02+14:00", "1971-02-20+23:01:02+14:00");
+
+  // Tests date_add() on daylight saving transition boundaries.
+  //
+  // Presto's semantic is to apply the delta to GMT, which means that at times
+  // the observed delta may not be linear, in cases when it hits a daylight
+  // savings boundary.
+  auto dateAddAndCast = [&](std::optional<std::string> unit,
+                            std::optional<int32_t> value,
+                            std::optional<std::string> timestampString) {
+    return evaluateOnce<std::string>(
+        "cast(date_add(c0, c1, cast(c2 as timestamp with time zone)) as VARCHAR)",
+        unit,
+        value,
+        timestampString);
+  };
+
+  EXPECT_EQ(
+      "2024-03-10 03:50:00.000 America/Los_Angeles",
+      dateAddAndCast("hour", 1, "2024-03-10 01:50:00 America/Los_Angeles"));
+  EXPECT_EQ(
+      "2024-11-03 01:50:00.000 America/Los_Angeles",
+      dateAddAndCast("hour", 1, "2024-11-03 01:50:00 America/Los_Angeles"));
+  EXPECT_EQ(
+      "2024-11-03 00:50:00.000 America/Los_Angeles",
+      dateAddAndCast("hour", -1, "2024-11-03 01:50:00 America/Los_Angeles"));
 }
 
 TEST_F(DateTimeFunctionsTest, dateDiffDate) {
   const auto dateDiff = [&](const std::string& unit,
                             std::optional<int32_t> date1,
                             std::optional<int32_t> date2) {
-    return evaluateOnce<int64_t, int32_t>(
+    return evaluateOnce<int64_t>(
         fmt::format("date_diff('{}', c0, c1)", unit),
-        {date1, date2},
-        {DATE(), DATE()});
+        {DATE(), DATE()},
+        date1,
+        date2);
   };
 
   // Check null behaviors
@@ -2081,6 +2467,10 @@ TEST_F(DateTimeFunctionsTest, dateDiffDate) {
   // Simple tests
   EXPECT_EQ(
       1, dateDiff("day", parseDate("2019-02-28"), parseDate("2019-03-01")));
+  EXPECT_EQ(
+      0, dateDiff("week", parseDate("2019-02-28"), parseDate("2019-03-01")));
+  EXPECT_EQ(
+      2, dateDiff("week", parseDate("2019-02-28"), parseDate("2019-03-15")));
   EXPECT_EQ(
       13, dateDiff("month", parseDate("2019-02-28"), parseDate("2020-03-28")));
   EXPECT_EQ(
@@ -2109,6 +2499,10 @@ TEST_F(DateTimeFunctionsTest, dateDiffDate) {
   // Check for negative intervals
   EXPECT_EQ(
       -366, dateDiff("day", parseDate("2020-02-29"), parseDate("2019-02-28")));
+  EXPECT_EQ(
+      0, dateDiff("week", parseDate("2020-02-29"), parseDate("2020-02-25")));
+  EXPECT_EQ(
+      -64, dateDiff("week", parseDate("2020-02-29"), parseDate("2018-12-02")));
   EXPECT_EQ(
       -12, dateDiff("month", parseDate("2020-02-29"), parseDate("2019-02-28")));
   EXPECT_EQ(
@@ -2139,66 +2533,93 @@ TEST_F(DateTimeFunctionsTest, dateDiffTimestamp) {
         fmt::format("date_diff('{}', c0, c1)", unit), timestamp1, timestamp2);
   };
 
-  using util::fromTimestampString;
-
   // Check null behaviors
   EXPECT_EQ(std::nullopt, dateDiff("second", Timestamp(1, 0), std::nullopt));
   EXPECT_EQ(std::nullopt, dateDiff("month", std::nullopt, Timestamp(0, 0)));
 
   // Check invalid units
-  EXPECT_THROW(
+  VELOX_ASSERT_THROW(
       dateDiff("invalid_unit", Timestamp(1, 0), Timestamp(0, 0)),
-      VeloxUserError);
+      "Unsupported datetime unit: invalid_unit");
+
+  // Check for integer overflow when result unit is month or larger.
+  EXPECT_EQ(
+      -622191233,
+      dateDiff("day", Timestamp(0, 0), Timestamp(9223372036854775, 0)));
+  EXPECT_EQ(
+      -88884461,
+      dateDiff("week", Timestamp(0, 0), Timestamp(9223372036854775, 0)));
+  VELOX_ASSERT_THROW(
+      dateDiff("month", Timestamp(0, 0), Timestamp(9223372036854775, 0)),
+      "Causes arithmetic overflow:");
+  VELOX_ASSERT_THROW(
+      dateDiff("quarter", Timestamp(0, 0), Timestamp(9223372036854775, 0)),
+      "Causes arithmetic overflow:");
+  VELOX_ASSERT_THROW(
+      dateDiff("year", Timestamp(0, 0), Timestamp(9223372036854775, 0)),
+      "Causes arithmetic overflow:");
 
   // Simple tests
   EXPECT_EQ(
       60 * 1000 + 500,
       dateDiff(
           "millisecond",
-          fromTimestampString("2019-02-28 10:00:00.500"),
-          fromTimestampString("2019-02-28 10:01:01.000")));
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-02-28 10:01:01.000")));
   EXPECT_EQ(
       60 * 60 * 24,
       dateDiff(
           "second",
-          fromTimestampString("2019-02-28 10:00:00.500"),
-          fromTimestampString("2019-03-01 10:00:00.500")));
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
   EXPECT_EQ(
       60 * 24,
       dateDiff(
           "minute",
-          fromTimestampString("2019-02-28 10:00:00.500"),
-          fromTimestampString("2019-03-01 10:00:00.500")));
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
   EXPECT_EQ(
       24,
       dateDiff(
           "hour",
-          fromTimestampString("2019-02-28 10:00:00.500"),
-          fromTimestampString("2019-03-01 10:00:00.500")));
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
   EXPECT_EQ(
       1,
       dateDiff(
           "day",
-          fromTimestampString("2019-02-28 10:00:00.500"),
-          fromTimestampString("2019-03-01 10:00:00.500")));
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
+  EXPECT_EQ(
+      0,
+      dateDiff(
+          "week",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
+  EXPECT_EQ(
+      1,
+      dateDiff(
+          "week",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-10 10:00:00.500")));
   EXPECT_EQ(
       12 + 1,
       dateDiff(
           "month",
-          fromTimestampString("2019-02-28 10:00:00.500"),
-          fromTimestampString("2020-03-28 10:00:00.500")));
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2020-03-28 10:00:00.500")));
   EXPECT_EQ(
       4,
       dateDiff(
           "quarter",
-          fromTimestampString("2019-02-28 10:00:00.500"),
-          fromTimestampString("2020-02-28 10:00:00.500")));
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2020-02-28 10:00:00.500")));
   EXPECT_EQ(
       1,
       dateDiff(
           "year",
-          fromTimestampString("2019-02-28 10:00:00.500"),
-          fromTimestampString("2020-02-28 10:00:00.500")));
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2020-02-28 10:00:00.500")));
 
   // Test for daylight saving. Daylight saving in US starts at 2021-03-14
   // 02:00:00 PST.
@@ -2207,50 +2628,50 @@ TEST_F(DateTimeFunctionsTest, dateDiffTimestamp) {
       1000 * 60 * 60 * 24,
       dateDiff(
           "millisecond",
-          fromTimestampString("2021-03-14 01:00:00.000"),
-          fromTimestampString("2021-03-15 01:00:00.000")));
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
   EXPECT_EQ(
       60 * 60 * 24,
       dateDiff(
           "second",
-          fromTimestampString("2021-03-14 01:00:00.000"),
-          fromTimestampString("2021-03-15 01:00:00.000")));
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
   EXPECT_EQ(
       60 * 24,
       dateDiff(
           "minute",
-          fromTimestampString("2021-03-14 01:00:00.000"),
-          fromTimestampString("2021-03-15 01:00:00.000")));
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
   EXPECT_EQ(
       24,
       dateDiff(
           "hour",
-          fromTimestampString("2021-03-14 01:00:00.000"),
-          fromTimestampString("2021-03-15 01:00:00.000")));
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
   EXPECT_EQ(
       1,
       dateDiff(
           "day",
-          fromTimestampString("2021-03-14 01:00:00.000"),
-          fromTimestampString("2021-03-15 01:00:00.000")));
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
   EXPECT_EQ(
       1,
       dateDiff(
           "month",
-          fromTimestampString("2021-03-14 01:00:00.000"),
-          fromTimestampString("2021-04-14 01:00:00.000")));
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-04-14 01:00:00.000")));
   EXPECT_EQ(
       1,
       dateDiff(
           "quarter",
-          fromTimestampString("2021-03-14 01:00:00.000"),
-          fromTimestampString("2021-06-14 01:00:00.000")));
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-06-14 01:00:00.000")));
   EXPECT_EQ(
       1,
       dateDiff(
           "year",
-          fromTimestampString("2021-03-14 01:00:00.000"),
-          fromTimestampString("2022-03-14 01:00:00.000")));
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2022-03-14 01:00:00.000")));
 
   // When adjust_timestamp_to_timezone is on, respect Daylight saving in the
   // session time zone
@@ -2260,193 +2681,260 @@ TEST_F(DateTimeFunctionsTest, dateDiffTimestamp) {
       1000 * 60 * 60 * 24,
       dateDiff(
           "millisecond",
-          fromTimestampString("2021-03-14 09:00:00.000"),
-          fromTimestampString("2021-03-15 09:00:00.000")));
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
   EXPECT_EQ(
       60 * 60 * 24,
       dateDiff(
           "second",
-          fromTimestampString("2021-03-14 09:00:00.000"),
-          fromTimestampString("2021-03-15 09:00:00.000")));
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
   EXPECT_EQ(
       60 * 24,
       dateDiff(
           "minute",
-          fromTimestampString("2021-03-14 09:00:00.000"),
-          fromTimestampString("2021-03-15 09:00:00.000")));
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
   EXPECT_EQ(
       24,
       dateDiff(
           "hour",
-          fromTimestampString("2021-03-14 09:00:00.000"),
-          fromTimestampString("2021-03-15 09:00:00.000")));
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
   EXPECT_EQ(
       1,
       dateDiff(
           "day",
-          fromTimestampString("2021-03-14 09:00:00.000"),
-          fromTimestampString("2021-03-15 09:00:00.000")));
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
   EXPECT_EQ(
       1,
       dateDiff(
           "month",
-          fromTimestampString("2021-03-14 09:00:00.000"),
-          fromTimestampString("2021-04-14 09:00:00.000")));
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-04-14 09:00:00.000")));
   EXPECT_EQ(
       1,
       dateDiff(
           "quarter",
-          fromTimestampString("2021-03-14 09:00:00.000"),
-          fromTimestampString("2021-06-14 09:00:00.000")));
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-06-14 09:00:00.000")));
   EXPECT_EQ(
       1,
       dateDiff(
           "year",
-          fromTimestampString("2021-03-14 09:00:00.000"),
-          fromTimestampString("2022-03-14 09:00:00.000")));
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2022-03-14 09:00:00.000")));
 
   // Test for respecting the last day of a year-month
   EXPECT_EQ(
       365 + 30,
       dateDiff(
           "day",
-          fromTimestampString("2019-01-30 10:00:00.500"),
-          fromTimestampString("2020-02-29 10:00:00.500")));
+          parseTimestamp("2019-01-30 10:00:00.500"),
+          parseTimestamp("2020-02-29 10:00:00.500")));
   EXPECT_EQ(
       12 + 1,
       dateDiff(
           "month",
-          fromTimestampString("2019-01-30 10:00:00.500"),
-          fromTimestampString("2020-02-29 10:00:00.500")));
+          parseTimestamp("2019-01-30 10:00:00.500"),
+          parseTimestamp("2020-02-29 10:00:00.500")));
   EXPECT_EQ(
       1,
       dateDiff(
           "quarter",
-          fromTimestampString("2019-11-30 10:00:00.500"),
-          fromTimestampString("2020-02-29 10:00:00.500")));
+          parseTimestamp("2019-11-30 10:00:00.500"),
+          parseTimestamp("2020-02-29 10:00:00.500")));
   EXPECT_EQ(
       10,
       dateDiff(
           "year",
-          fromTimestampString("2020-02-29 10:00:00.500"),
-          fromTimestampString("2030-02-28 10:00:00.500")));
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2030-02-28 10:00:00.500")));
 
   // Test for negative difference
   EXPECT_EQ(
       -60 * 60 * 24 * 1000 - 500,
       dateDiff(
           "millisecond",
-          fromTimestampString("2020-03-01 00:00:00.500"),
-          fromTimestampString("2020-02-29 00:00:00.000")));
+          parseTimestamp("2020-03-01 00:00:00.500"),
+          parseTimestamp("2020-02-29 00:00:00.000")));
   EXPECT_EQ(
       -60 * 60 * 24,
       dateDiff(
           "second",
-          fromTimestampString("2020-03-01 00:00:00.500"),
-          fromTimestampString("2020-02-29 00:00:00.500")));
+          parseTimestamp("2020-03-01 00:00:00.500"),
+          parseTimestamp("2020-02-29 00:00:00.500")));
   EXPECT_EQ(
       -60 * 24,
       dateDiff(
           "minute",
-          fromTimestampString("2020-03-01 00:00:00.500"),
-          fromTimestampString("2020-02-29 00:00:00.500")));
+          parseTimestamp("2020-03-01 00:00:00.500"),
+          parseTimestamp("2020-02-29 00:00:00.500")));
   EXPECT_EQ(
       -24,
       dateDiff(
           "hour",
-          fromTimestampString("2020-03-01 00:00:00.500"),
-          fromTimestampString("2020-02-29 00:00:00.500")));
+          parseTimestamp("2020-03-01 00:00:00.500"),
+          parseTimestamp("2020-02-29 00:00:00.500")));
   EXPECT_EQ(
       -366,
       dateDiff(
           "day",
-          fromTimestampString("2020-02-29 10:00:00.500"),
-          fromTimestampString("2019-02-28 10:00:00.500")));
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2019-02-28 10:00:00.500")));
   EXPECT_EQ(
       -12,
       dateDiff(
           "month",
-          fromTimestampString("2020-02-29 10:00:00.500"),
-          fromTimestampString("2019-02-28 10:00:00.500")));
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2019-02-28 10:00:00.500")));
   EXPECT_EQ(
       -4,
       dateDiff(
           "quarter",
-          fromTimestampString("2020-02-29 10:00:00.500"),
-          fromTimestampString("2019-02-28 10:00:00.500")));
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2019-02-28 10:00:00.500")));
   EXPECT_EQ(
       -2,
       dateDiff(
           "year",
-          fromTimestampString("2020-02-29 10:00:00.500"),
-          fromTimestampString("2018-02-28 10:00:00.500")));
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2018-02-28 10:00:00.500")));
 }
 
 TEST_F(DateTimeFunctionsTest, dateDiffTimestampWithTimezone) {
-  const auto dateDiff = [&](const std::string& unit,
-                            std::optional<int64_t> timestamp1,
-                            const std::optional<std::string>& timeZoneName1,
-                            std::optional<int64_t> timestamp2,
-                            const std::optional<std::string>& timeZoneName2) {
-    auto ts1 = (timestamp1.has_value() && timeZoneName1.has_value())
-        ? makeTimestampWithTimeZoneVector(
-              timestamp1.value(), timeZoneName1.value().c_str())
-        : BaseVector::createNullConstant(TIMESTAMP_WITH_TIME_ZONE(), 1, pool());
-    auto ts2 = (timestamp2.has_value() && timeZoneName2.has_value())
-        ? makeTimestampWithTimeZoneVector(
-              timestamp2.value(), timeZoneName2.value().c_str())
-        : BaseVector::createNullConstant(TIMESTAMP_WITH_TIME_ZONE(), 1, pool());
-
+  const auto dateDiff = [&](std::optional<std::string> unit,
+                            std::optional<TimestampWithTimezone> input1,
+                            std::optional<TimestampWithTimezone> input2) {
     return evaluateOnce<int64_t>(
-        fmt::format("date_diff('{}', c0, c1)", unit),
-        makeRowVector({ts1, ts2}));
+        "date_diff(c0, c1, c2)",
+        {VARCHAR(), TIMESTAMP_WITH_TIME_ZONE(), TIMESTAMP_WITH_TIME_ZONE()},
+        unit,
+        TimestampWithTimezone::pack(input1),
+        TimestampWithTimezone::pack(input2));
   };
 
+  // Null behavior.
+  EXPECT_EQ(
+      std::nullopt,
+      dateDiff(
+          std::nullopt,
+          TimestampWithTimezone(0, 0),
+          TimestampWithTimezone(0, 0)));
+
+  EXPECT_EQ(
+      std::nullopt,
+      dateDiff("asdf", std::nullopt, TimestampWithTimezone(0, 0)));
+
   // timestamp1: 1970-01-01 00:00:00.000 +00:00 (0)
   // timestamp2: 2020-08-25 16:30:10.123 -08:00 (1'598'373'010'123)
   EXPECT_EQ(
-      1598347810123,
+      1598373010123,
       dateDiff(
           "millisecond",
-          0,
-          "+00:00",
-          1'598'373'010'123,
-          "America/Los_Angeles"));
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
   EXPECT_EQ(
-      1598347810,
+      1598373010,
       dateDiff(
-          "second", 0, "+00:00", 1'598'373'010'123, "America/Los_Angeles"));
+          "second",
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
   EXPECT_EQ(
-      26639130,
+      26639550,
       dateDiff(
-          "minute", 0, "+00:00", 1'598'373'010'123, "America/Los_Angeles"));
+          "minute",
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
   EXPECT_EQ(
-      443985,
-      dateDiff("hour", 0, "+00:00", 1'598'373'010'123, "America/Los_Angeles"));
+      443992,
+      dateDiff(
+          "hour",
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
   EXPECT_EQ(
       18499,
-      dateDiff("day", 0, "+00:00", 1'598'373'010'123, "America/Los_Angeles"));
+      dateDiff(
+          "day",
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
+  EXPECT_EQ(
+      2642,
+      dateDiff(
+          "week",
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
   EXPECT_EQ(
       607,
-      dateDiff("month", 0, "+00:00", 1'598'373'010'123, "America/Los_Angeles"));
+      dateDiff(
+          "month",
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
   EXPECT_EQ(
       202,
       dateDiff(
-          "quarter", 0, "+00:00", 1'598'373'010'123, "America/Los_Angeles"));
+          "quarter",
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
   EXPECT_EQ(
       50,
-      dateDiff("year", 0, "+00:00", 1'598'373'010'123, "America/Los_Angeles"));
+      dateDiff(
+          "year",
+          TimestampWithTimezone(0, "+00:00"),
+          TimestampWithTimezone(1'598'373'010'123, "America/Los_Angeles")));
+
+  // Test if calculations are being performed in correct zone. Presto behavior
+  // is to use the zone of the first parameter. Note that that this UTC interval
+  // (a, b) crosses a daylight savings boundary in PST when PST loses one hour.
+  // So whenever the calculation is performed in PST, the interval is
+  // effectively smaller than 24h and returns zero.
+  auto a = parseTimestamp("2024-11-02 17:00:00").toMillis();
+  auto b = parseTimestamp("2024-11-03 17:30:00").toMillis();
+  EXPECT_EQ(
+      1,
+      dateDiff(
+          "day",
+          TimestampWithTimezone(a, "UTC"),
+          TimestampWithTimezone(b, "America/Los_Angeles")));
+  EXPECT_EQ(
+      1,
+      dateDiff(
+          "day",
+          TimestampWithTimezone(a, "UTC"),
+          TimestampWithTimezone(b, "UTC")));
+
+  EXPECT_EQ(
+      0,
+      dateDiff(
+          "day",
+          TimestampWithTimezone(a, "America/Los_Angeles"),
+          TimestampWithTimezone(b, "UTC")));
+  EXPECT_EQ(
+      0,
+      dateDiff(
+          "day",
+          TimestampWithTimezone(a, "America/Los_Angeles"),
+          TimestampWithTimezone(b, "America/Los_Angeles")));
 }
 
 TEST_F(DateTimeFunctionsTest, parseDatetime) {
+  const auto parseDatetime = [&](const std::optional<std::string>& input,
+                                 const std::optional<std::string>& format) {
+    auto result =
+        evaluateOnce<int64_t>("parse_datetime(c0, c1)", input, format);
+    return TimestampWithTimezone::unpack(result);
+  };
+
   // Check null behavior.
   EXPECT_EQ(std::nullopt, parseDatetime("1970-01-01", std::nullopt));
   EXPECT_EQ(std::nullopt, parseDatetime(std::nullopt, "YYYY-MM-dd"));
   EXPECT_EQ(std::nullopt, parseDatetime(std::nullopt, std::nullopt));
 
   // Ensure it throws.
-  EXPECT_THROW(parseDatetime("", ""), VeloxUserError);
-  EXPECT_THROW(parseDatetime("1234", "Y Y"), VeloxUserError);
+  VELOX_ASSERT_THROW(parseDatetime("", ""), "Invalid pattern specification");
+  VELOX_ASSERT_THROW(
+      parseDatetime("1234", "Y Y"), "Invalid date format: '1234'");
 
   // Simple tests. More exhaustive tests are provided as part of Joda's
   // implementation.
@@ -2470,23 +2958,22 @@ TEST_F(DateTimeFunctionsTest, parseDatetime) {
   // 118860000 is the number of milliseconds since epoch at 1970-01-02
   // 09:01:00.000 UTC.
   EXPECT_EQ(
-      TimestampWithTimezone(118860000, util::getTimeZoneID("+00:00")),
+      TimestampWithTimezone(118860000, "+00:00"),
       parseDatetime("1970-01-02+09:01+00:00", "YYYY-MM-dd+HH:mmZZ"));
   EXPECT_EQ(
-      TimestampWithTimezone(118860000, util::getTimeZoneID("-09:00")),
+      TimestampWithTimezone(118860000, "-09:00"),
       parseDatetime("1970-01-02+00:01-09:00", "YYYY-MM-dd+HH:mmZZ"));
   EXPECT_EQ(
-      TimestampWithTimezone(118860000, util::getTimeZoneID("-02:00")),
+      TimestampWithTimezone(118860000, "-02:00"),
       parseDatetime("1970-01-02+07:01-02:00", "YYYY-MM-dd+HH:mmZZ"));
   EXPECT_EQ(
-      TimestampWithTimezone(118860000, util::getTimeZoneID("+14:00")),
+      TimestampWithTimezone(118860000, "+14:00"),
       parseDatetime("1970-01-02+23:01+14:00", "YYYY-MM-dd+HH:mmZZ"));
   EXPECT_EQ(
-      TimestampWithTimezone(
-          198060000, util::getTimeZoneID("America/Los_Angeles")),
+      TimestampWithTimezone(198060000, "America/Los_Angeles"),
       parseDatetime("1970-01-02+23:01 PST", "YYYY-MM-dd+HH:mm z"));
   EXPECT_EQ(
-      TimestampWithTimezone(169260000, util::getTimeZoneID("+00:00")),
+      TimestampWithTimezone(169260000, "+00:00"),
       parseDatetime("1970-01-02+23:01 GMT", "YYYY-MM-dd+HH:mm z"));
 
   setQueryTimeZone("Asia/Kolkata");
@@ -2494,661 +2981,920 @@ TEST_F(DateTimeFunctionsTest, parseDatetime) {
   // 66600000 is the number of millisecond since epoch at 1970-01-01
   // 18:30:00.000 UTC.
   EXPECT_EQ(
-      TimestampWithTimezone(66600000, util::getTimeZoneID("Asia/Kolkata")),
+      TimestampWithTimezone(66600000, "Asia/Kolkata"),
       parseDatetime("1970-01-02+00:00", "YYYY-MM-dd+HH:mm"));
   EXPECT_EQ(
-      TimestampWithTimezone(66600000, util::getTimeZoneID("-03:00")),
+      TimestampWithTimezone(66600000, "-03:00"),
       parseDatetime("1970-01-01+15:30-03:00", "YYYY-MM-dd+HH:mmZZ"));
 
   // -66600000 is the number of millisecond since epoch at 1969-12-31
   // 05:30:00.000 UTC.
   EXPECT_EQ(
-      TimestampWithTimezone(-66600000, util::getTimeZoneID("Asia/Kolkata")),
+      TimestampWithTimezone(-66600000, "Asia/Kolkata"),
       parseDatetime("1969-12-31+11:00", "YYYY-MM-dd+HH:mm"));
   EXPECT_EQ(
-      TimestampWithTimezone(-66600000, util::getTimeZoneID("+02:00")),
+      TimestampWithTimezone(-66600000, "+02:00"),
       parseDatetime("1969-12-31+07:30+02:00", "YYYY-MM-dd+HH:mmZZ"));
+
+  // Joda also lets 'Z' to be UTC|UCT|GMT|GMT0.
+  auto ts = TimestampWithTimezone(1708840800000, "GMT");
+  EXPECT_EQ(
+      ts, parseDatetime("2024-02-25+06:00:99 GMT", "yyyy-MM-dd+HH:mm:99 ZZZ"));
+  EXPECT_EQ(
+      ts, parseDatetime("2024-02-25+06:00:99 GMT0", "yyyy-MM-dd+HH:mm:99 ZZZ"));
+  EXPECT_EQ(
+      ts, parseDatetime("2024-02-25+06:00:99 UTC", "yyyy-MM-dd+HH:mm:99 ZZZ"));
+  EXPECT_EQ(
+      ts, parseDatetime("2024-02-25+06:00:99 UTC", "yyyy-MM-dd+HH:mm:99 ZZZ"));
+
+  VELOX_ASSERT_THROW(
+      parseDatetime("2024-02-25+06:00:99 PST", "yyyy-MM-dd+HH:mm:99 ZZZ"),
+      "Invalid date format: '2024-02-25+06:00:99 PST'");
 }
 
 TEST_F(DateTimeFunctionsTest, formatDateTime) {
-  using util::fromTimestampString;
-
-  // era test cases - 'G'
-  EXPECT_EQ("AD", formatDatetime(fromTimestampString("1970-01-01"), "G"));
-  EXPECT_EQ("BC", formatDatetime(fromTimestampString("-100-01-01"), "G"));
-  EXPECT_EQ("BC", formatDatetime(fromTimestampString("0-01-01"), "G"));
-  EXPECT_EQ("AD", formatDatetime(fromTimestampString("01-01-01"), "G"));
-  EXPECT_EQ("AD", formatDatetime(fromTimestampString("01-01-01"), "GGGGGGG"));
-
-  // century of era test cases - 'C'
-  EXPECT_EQ("19", formatDatetime(fromTimestampString("1900-01-01"), "C"));
-  EXPECT_EQ("19", formatDatetime(fromTimestampString("1955-01-01"), "C"));
-  EXPECT_EQ("20", formatDatetime(fromTimestampString("2000-01-01"), "C"));
-  EXPECT_EQ("20", formatDatetime(fromTimestampString("2020-01-01"), "C"));
-  EXPECT_EQ("0", formatDatetime(fromTimestampString("0-01-01"), "C"));
-  EXPECT_EQ("1", formatDatetime(fromTimestampString("-100-01-01"), "C"));
-  EXPECT_EQ("19", formatDatetime(fromTimestampString("-1900-01-01"), "C"));
-  EXPECT_EQ(
-      "000019", formatDatetime(fromTimestampString("1955-01-01"), "CCCCCC"));
-
-  // year of era test cases - 'Y'
-  EXPECT_EQ("1970", formatDatetime(fromTimestampString("1970-01-01"), "Y"));
-  EXPECT_EQ("2020", formatDatetime(fromTimestampString("2020-01-01"), "Y"));
-  EXPECT_EQ("1", formatDatetime(fromTimestampString("0-01-01"), "Y"));
-  EXPECT_EQ("101", formatDatetime(fromTimestampString("-100-01-01"), "Y"));
-  EXPECT_EQ("70", formatDatetime(fromTimestampString("1970-01-01"), "YY"));
-  EXPECT_EQ("70", formatDatetime(fromTimestampString("-1970-01-01"), "YY"));
-  EXPECT_EQ("1948", formatDatetime(fromTimestampString("1948-01-01"), "YYY"));
-  EXPECT_EQ("1234", formatDatetime(fromTimestampString("1234-01-01"), "YYYY"));
-  EXPECT_EQ(
-      "0000000001",
-      formatDatetime(fromTimestampString("01-01-01"), "YYYYYYYYYY"));
-
-  // day of week number - 'e'
+  const auto formatDatetime = [&](std::optional<Timestamp> timestamp,
+                                  std::optional<std::string> format) {
+    return evaluateOnce<std::string>(
+        "format_datetime(c0, c1)", timestamp, format);
+  };
+
+  // Era test cases - 'G'
+  EXPECT_EQ("AD", formatDatetime(parseTimestamp("1970-01-01"), "G"));
+  EXPECT_EQ("BC", formatDatetime(parseTimestamp("-100-01-01"), "G"));
+  EXPECT_EQ("BC", formatDatetime(parseTimestamp("0-01-01"), "G"));
+  EXPECT_EQ("AD", formatDatetime(parseTimestamp("01-01-01"), "G"));
+  EXPECT_EQ("AD", formatDatetime(parseTimestamp("01-01-01"), "GGGGGGG"));
+
+  // Century of era test cases - 'C'
+  EXPECT_EQ("19", formatDatetime(parseTimestamp("1900-01-01"), "C"));
+  EXPECT_EQ("19", formatDatetime(parseTimestamp("1955-01-01"), "C"));
+  EXPECT_EQ("20", formatDatetime(parseTimestamp("2000-01-01"), "C"));
+  EXPECT_EQ("20", formatDatetime(parseTimestamp("2020-01-01"), "C"));
+  EXPECT_EQ("0", formatDatetime(parseTimestamp("0-01-01"), "C"));
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("-100-01-01"), "C"));
+  EXPECT_EQ("19", formatDatetime(parseTimestamp("-1900-01-01"), "C"));
+  EXPECT_EQ("000019", formatDatetime(parseTimestamp("1955-01-01"), "CCCCCC"));
+
+  // Year of era test cases - 'Y'
+  EXPECT_EQ("1970", formatDatetime(parseTimestamp("1970-01-01"), "Y"));
+  EXPECT_EQ("2020", formatDatetime(parseTimestamp("2020-01-01"), "Y"));
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("0-01-01"), "Y"));
+  EXPECT_EQ("101", formatDatetime(parseTimestamp("-100-01-01"), "Y"));
+  EXPECT_EQ("70", formatDatetime(parseTimestamp("1970-01-01"), "YY"));
+  EXPECT_EQ("70", formatDatetime(parseTimestamp("-1970-01-01"), "YY"));
+  EXPECT_EQ("1948", formatDatetime(parseTimestamp("1948-01-01"), "YYY"));
+  EXPECT_EQ("1234", formatDatetime(parseTimestamp("1234-01-01"), "YYYY"));
+  EXPECT_EQ(
+      "0000000001", formatDatetime(parseTimestamp("01-01-01"), "YYYYYYYYYY"));
+
+  // Day of week number - 'e'
   for (int i = 0; i < 31; i++) {
     std::string date("2022-08-" + std::to_string(i + 1));
     EXPECT_EQ(
         std::to_string(i % 7 + 1),
-        formatDatetime(fromTimestampString(StringView{date}), "e"));
+        formatDatetime(parseTimestamp(StringView{date}), "e"));
   }
-  EXPECT_EQ(
-      "000001", formatDatetime(fromTimestampString("2022-08-01"), "eeeeee"));
+  EXPECT_EQ("000001", formatDatetime(parseTimestamp("2022-08-01"), "eeeeee"));
 
-  // day of week text - 'E'
+  // Day of week text - 'E'
   for (int i = 0; i < 31; i++) {
     std::string date("2022-08-" + std::to_string(i + 1));
     EXPECT_EQ(
         daysShort[i % 7],
-        formatDatetime(fromTimestampString(StringView{date}), "E"));
+        formatDatetime(parseTimestamp(StringView{date}), "E"));
     EXPECT_EQ(
         daysShort[i % 7],
-        formatDatetime(fromTimestampString(StringView{date}), "EE"));
+        formatDatetime(parseTimestamp(StringView{date}), "EE"));
     EXPECT_EQ(
         daysShort[i % 7],
-        formatDatetime(fromTimestampString(StringView{date}), "EEE"));
+        formatDatetime(parseTimestamp(StringView{date}), "EEE"));
     EXPECT_EQ(
         daysLong[i % 7],
-        formatDatetime(fromTimestampString(StringView{date}), "EEEE"));
+        formatDatetime(parseTimestamp(StringView{date}), "EEEE"));
     EXPECT_EQ(
         daysLong[i % 7],
-        formatDatetime(fromTimestampString(StringView{date}), "EEEEEEEE"));
+        formatDatetime(parseTimestamp(StringView{date}), "EEEEEEEE"));
   }
 
-  // year test cases - 'y'
-  EXPECT_EQ("2022", formatDatetime(fromTimestampString("2022-06-20"), "y"));
-  EXPECT_EQ("22", formatDatetime(fromTimestampString("2022-06-20"), "yy"));
-  EXPECT_EQ("2022", formatDatetime(fromTimestampString("2022-06-20"), "yyy"));
-  EXPECT_EQ("2022", formatDatetime(fromTimestampString("2022-06-20"), "yyyy"));
-
-  EXPECT_EQ("10", formatDatetime(fromTimestampString("10-06-20"), "y"));
-  EXPECT_EQ("10", formatDatetime(fromTimestampString("10-06-20"), "yy"));
-  EXPECT_EQ("010", formatDatetime(fromTimestampString("10-06-20"), "yyy"));
-  EXPECT_EQ("0010", formatDatetime(fromTimestampString("10-06-20"), "yyyy"));
-
-  EXPECT_EQ("-16", formatDatetime(fromTimestampString("-16-06-20"), "y"));
-  EXPECT_EQ("16", formatDatetime(fromTimestampString("-16-06-20"), "yy"));
-  EXPECT_EQ("-016", formatDatetime(fromTimestampString("-16-06-20"), "yyy"));
-  EXPECT_EQ("-0016", formatDatetime(fromTimestampString("-16-06-20"), "yyyy"));
-
-  EXPECT_EQ("00", formatDatetime(fromTimestampString("-1600-06-20"), "yy"));
-  EXPECT_EQ("01", formatDatetime(fromTimestampString("-1601-06-20"), "yy"));
-  EXPECT_EQ("10", formatDatetime(fromTimestampString("-1610-06-20"), "yy"));
-
-  // day of year test cases - 'D'
-  EXPECT_EQ("1", formatDatetime(fromTimestampString("2022-01-01"), "D"));
-  EXPECT_EQ("10", formatDatetime(fromTimestampString("2022-01-10"), "D"));
-  EXPECT_EQ("100", formatDatetime(fromTimestampString("2022-04-10"), "D"));
-  EXPECT_EQ("365", formatDatetime(fromTimestampString("2022-12-31"), "D"));
-  EXPECT_EQ(
-      "00100", formatDatetime(fromTimestampString("2022-04-10"), "DDDDD"));
-
-  // leap year case
-  EXPECT_EQ("60", formatDatetime(fromTimestampString("2020-02-29"), "D"));
-  EXPECT_EQ("366", formatDatetime(fromTimestampString("2020-12-31"), "D"));
-
-  // month of year test cases - 'M'
+  // Year test cases - 'y'
+  EXPECT_EQ("2022", formatDatetime(parseTimestamp("2022-06-20"), "y"));
+  EXPECT_EQ("22", formatDatetime(parseTimestamp("2022-06-20"), "yy"));
+  EXPECT_EQ("2022", formatDatetime(parseTimestamp("2022-06-20"), "yyy"));
+  EXPECT_EQ("2022", formatDatetime(parseTimestamp("2022-06-20"), "yyyy"));
+
+  EXPECT_EQ("10", formatDatetime(parseTimestamp("10-06-20"), "y"));
+  EXPECT_EQ("10", formatDatetime(parseTimestamp("10-06-20"), "yy"));
+  EXPECT_EQ("010", formatDatetime(parseTimestamp("10-06-20"), "yyy"));
+  EXPECT_EQ("0010", formatDatetime(parseTimestamp("10-06-20"), "yyyy"));
+
+  EXPECT_EQ("-16", formatDatetime(parseTimestamp("-16-06-20"), "y"));
+  EXPECT_EQ("16", formatDatetime(parseTimestamp("-16-06-20"), "yy"));
+  EXPECT_EQ("-016", formatDatetime(parseTimestamp("-16-06-20"), "yyy"));
+  EXPECT_EQ("-0016", formatDatetime(parseTimestamp("-16-06-20"), "yyyy"));
+
+  EXPECT_EQ("00", formatDatetime(parseTimestamp("-1600-06-20"), "yy"));
+  EXPECT_EQ("01", formatDatetime(parseTimestamp("-1601-06-20"), "yy"));
+  EXPECT_EQ("10", formatDatetime(parseTimestamp("-1610-06-20"), "yy"));
+
+  // Day of year test cases - 'D'
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("2022-01-01"), "D"));
+  EXPECT_EQ("10", formatDatetime(parseTimestamp("2022-01-10"), "D"));
+  EXPECT_EQ("100", formatDatetime(parseTimestamp("2022-04-10"), "D"));
+  EXPECT_EQ("365", formatDatetime(parseTimestamp("2022-12-31"), "D"));
+  EXPECT_EQ("00100", formatDatetime(parseTimestamp("2022-04-10"), "DDDDD"));
+
+  // Leap year case
+  EXPECT_EQ("60", formatDatetime(parseTimestamp("2020-02-29"), "D"));
+  EXPECT_EQ("366", formatDatetime(parseTimestamp("2020-12-31"), "D"));
+
+  // Month of year test cases - 'M'
   for (int i = 0; i < 12; i++) {
     auto month = i + 1;
     std::string date("2022-" + std::to_string(month) + "-01");
     EXPECT_EQ(
         std::to_string(month),
-        formatDatetime(fromTimestampString(StringView{date}), "M"));
+        formatDatetime(parseTimestamp(StringView{date}), "M"));
     EXPECT_EQ(
         padNumber(month),
-        formatDatetime(fromTimestampString(StringView{date}), "MM"));
+        formatDatetime(parseTimestamp(StringView{date}), "MM"));
     EXPECT_EQ(
         monthsShort[i],
-        formatDatetime(fromTimestampString(StringView{date}), "MMM"));
+        formatDatetime(parseTimestamp(StringView{date}), "MMM"));
     EXPECT_EQ(
         monthsLong[i],
-        formatDatetime(fromTimestampString(StringView{date}), "MMMM"));
+        formatDatetime(parseTimestamp(StringView{date}), "MMMM"));
     EXPECT_EQ(
         monthsLong[i],
-        formatDatetime(fromTimestampString(StringView{date}), "MMMMMMMM"));
+        formatDatetime(parseTimestamp(StringView{date}), "MMMMMMMM"));
   }
 
-  // day of month test cases - 'd'
-  EXPECT_EQ("1", formatDatetime(fromTimestampString("2022-01-01"), "d"));
-  EXPECT_EQ("10", formatDatetime(fromTimestampString("2022-01-10"), "d"));
-  EXPECT_EQ("28", formatDatetime(fromTimestampString("2022-01-28"), "d"));
-  EXPECT_EQ("31", formatDatetime(fromTimestampString("2022-01-31"), "d"));
+  // Day of month test cases - 'd'
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("2022-01-01"), "d"));
+  EXPECT_EQ("10", formatDatetime(parseTimestamp("2022-01-10"), "d"));
+  EXPECT_EQ("28", formatDatetime(parseTimestamp("2022-01-28"), "d"));
+  EXPECT_EQ("31", formatDatetime(parseTimestamp("2022-01-31"), "d"));
   EXPECT_EQ(
-      "00000031",
-      formatDatetime(fromTimestampString("2022-01-31"), "dddddddd"));
+      "00000031", formatDatetime(parseTimestamp("2022-01-31"), "dddddddd"));
 
-  // leap year case
-  EXPECT_EQ("29", formatDatetime(fromTimestampString("2020-02-29"), "d"));
+  // Leap year case
+  EXPECT_EQ("29", formatDatetime(parseTimestamp("2020-02-29"), "d"));
 
-  // halfday of day test cases - 'a'
-  EXPECT_EQ(
-      "AM", formatDatetime(fromTimestampString("2022-01-01 00:00:00"), "a"));
-  EXPECT_EQ(
-      "AM", formatDatetime(fromTimestampString("2022-01-01 11:59:59"), "a"));
+  // Halfday of day test cases - 'a'
+  EXPECT_EQ("AM", formatDatetime(parseTimestamp("2022-01-01 00:00:00"), "a"));
+  EXPECT_EQ("AM", formatDatetime(parseTimestamp("2022-01-01 11:59:59"), "a"));
+  EXPECT_EQ("PM", formatDatetime(parseTimestamp("2022-01-01 12:00:00"), "a"));
+  EXPECT_EQ("PM", formatDatetime(parseTimestamp("2022-01-01 23:59:59"), "a"));
   EXPECT_EQ(
-      "PM", formatDatetime(fromTimestampString("2022-01-01 12:00:00"), "a"));
+      "AM", formatDatetime(parseTimestamp("2022-01-01 00:00:00"), "aaaaaaaa"));
   EXPECT_EQ(
-      "PM", formatDatetime(fromTimestampString("2022-01-01 23:59:59"), "a"));
-  EXPECT_EQ(
-      "AM",
-      formatDatetime(fromTimestampString("2022-01-01 00:00:00"), "aaaaaaaa"));
-  EXPECT_EQ(
-      "PM",
-      formatDatetime(fromTimestampString("2022-01-01 12:00:00"), "aaaaaaaa"));
+      "PM", formatDatetime(parseTimestamp("2022-01-01 12:00:00"), "aaaaaaaa"));
 
-  // hour of halfday test cases - 'K'
+  // Hour of halfday test cases - 'K'
   for (int i = 0; i < 24; i++) {
     std::string buildString = "2022-01-01 " + padNumber(i) + ":00:00";
     StringView date(buildString);
     EXPECT_EQ(
-        std::to_string(i % 12), formatDatetime(fromTimestampString(date), "K"));
+        std::to_string(i % 12), formatDatetime(parseTimestamp(date), "K"));
   }
   EXPECT_EQ(
       "00000011",
-      formatDatetime(fromTimestampString("2022-01-01 11:00:00"), "KKKKKKKK"));
+      formatDatetime(parseTimestamp("2022-01-01 11:00:00"), "KKKKKKKK"));
 
-  // clockhour of halfday test cases - 'h'
+  // Clockhour of halfday test cases - 'h'
   for (int i = 0; i < 24; i++) {
     std::string buildString = "2022-01-01 " + padNumber(i) + ":00:00";
     StringView date(buildString);
     EXPECT_EQ(
         std::to_string((i + 11) % 12 + 1),
-        formatDatetime(fromTimestampString(date), "h"));
+        formatDatetime(parseTimestamp(date), "h"));
   }
   EXPECT_EQ(
       "00000011",
-      formatDatetime(fromTimestampString("2022-01-01 11:00:00"), "hhhhhhhh"));
+      formatDatetime(parseTimestamp("2022-01-01 11:00:00"), "hhhhhhhh"));
 
-  // hour of day test cases - 'H'
+  // Hour of day test cases - 'H'
   for (int i = 0; i < 24; i++) {
     std::string buildString = "2022-01-01 " + padNumber(i) + ":00:00";
     StringView date(buildString);
-    EXPECT_EQ(
-        std::to_string(i), formatDatetime(fromTimestampString(date), "H"));
+    EXPECT_EQ(std::to_string(i), formatDatetime(parseTimestamp(date), "H"));
   }
   EXPECT_EQ(
       "00000011",
-      formatDatetime(fromTimestampString("2022-01-01 11:00:00"), "HHHHHHHH"));
+      formatDatetime(parseTimestamp("2022-01-01 11:00:00"), "HHHHHHHH"));
 
-  // clockhour of day test cases - 'k'
+  // Clockhour of day test cases - 'k'
   for (int i = 0; i < 24; i++) {
     std::string buildString = "2022-01-01 " + padNumber(i) + ":00:00";
     StringView date(buildString);
     EXPECT_EQ(
         std::to_string((i + 23) % 24 + 1),
-        formatDatetime(fromTimestampString(date), "k"));
+        formatDatetime(parseTimestamp(date), "k"));
   }
   EXPECT_EQ(
       "00000011",
-      formatDatetime(fromTimestampString("2022-01-01 11:00:00"), "kkkkkkkk"));
+      formatDatetime(parseTimestamp("2022-01-01 11:00:00"), "kkkkkkkk"));
 
-  // minute of hour test cases - 'm'
-  EXPECT_EQ(
-      "0", formatDatetime(fromTimestampString("2022-01-01 00:00:00"), "m"));
-  EXPECT_EQ(
-      "1", formatDatetime(fromTimestampString("2022-01-01 01:01:00"), "m"));
-  EXPECT_EQ(
-      "10", formatDatetime(fromTimestampString("2022-01-01 02:10:00"), "m"));
-  EXPECT_EQ(
-      "30", formatDatetime(fromTimestampString("2022-01-01 03:30:00"), "m"));
-  EXPECT_EQ(
-      "59", formatDatetime(fromTimestampString("2022-01-01 04:59:00"), "m"));
+  // Minute of hour test cases - 'm'
+  EXPECT_EQ("0", formatDatetime(parseTimestamp("2022-01-01 00:00:00"), "m"));
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("2022-01-01 01:01:00"), "m"));
+  EXPECT_EQ("10", formatDatetime(parseTimestamp("2022-01-01 02:10:00"), "m"));
+  EXPECT_EQ("30", formatDatetime(parseTimestamp("2022-01-01 03:30:00"), "m"));
+  EXPECT_EQ("59", formatDatetime(parseTimestamp("2022-01-01 04:59:00"), "m"));
   EXPECT_EQ(
       "00000042",
-      formatDatetime(fromTimestampString("2022-01-01 00:42:42"), "mmmmmmmm"));
-
-  // second of minute test cases - 's'
-  EXPECT_EQ(
-      "0", formatDatetime(fromTimestampString("2022-01-01 00:00:00"), "s"));
-  EXPECT_EQ(
-      "1", formatDatetime(fromTimestampString("2022-01-01 01:01:01"), "s"));
-  EXPECT_EQ(
-      "10", formatDatetime(fromTimestampString("2022-01-01 02:10:10"), "s"));
-  EXPECT_EQ(
-      "30", formatDatetime(fromTimestampString("2022-01-01 03:30:30"), "s"));
-  EXPECT_EQ(
-      "59", formatDatetime(fromTimestampString("2022-01-01 04:59:59"), "s"));
+      formatDatetime(parseTimestamp("2022-01-01 00:42:42"), "mmmmmmmm"));
+
+  // Week of the year test cases - 'w'
+  EXPECT_EQ("52", formatDatetime(parseTimestamp("2022-01-01 04:59:00"), "w"));
+  EXPECT_EQ("52", formatDatetime(parseTimestamp("2022-01-02"), "w"));
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("2022-01-03"), "w"));
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("2024-01-01"), "w"));
+  EXPECT_EQ("22", formatDatetime(parseTimestamp("1970-05-30"), "w"));
+
+  // Second of minute test cases - 's'
+  EXPECT_EQ("0", formatDatetime(parseTimestamp("2022-01-01 00:00:00"), "s"));
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("2022-01-01 01:01:01"), "s"));
+  EXPECT_EQ("10", formatDatetime(parseTimestamp("2022-01-01 02:10:10"), "s"));
+  EXPECT_EQ("30", formatDatetime(parseTimestamp("2022-01-01 03:30:30"), "s"));
+  EXPECT_EQ("59", formatDatetime(parseTimestamp("2022-01-01 04:59:59"), "s"));
   EXPECT_EQ(
       "00000042",
-      formatDatetime(fromTimestampString("2022-01-01 00:42:42"), "ssssssss"));
+      formatDatetime(parseTimestamp("2022-01-01 00:42:42"), "ssssssss"));
 
-  // fraction of second test cases - 'S'
+  // Fraction of second test cases - 'S'
+  EXPECT_EQ("0", formatDatetime(parseTimestamp("2022-01-01 00:00:00.0"), "S"));
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("2022-01-01 00:00:00.1"), "S"));
+  EXPECT_EQ("1", formatDatetime(parseTimestamp("2022-01-01 01:01:01.11"), "S"));
   EXPECT_EQ(
-      "0", formatDatetime(fromTimestampString("2022-01-01 00:00:00.0"), "S"));
+      "11", formatDatetime(parseTimestamp("2022-01-01 02:10:10.11"), "SS"));
   EXPECT_EQ(
-      "1", formatDatetime(fromTimestampString("2022-01-01 00:00:00.1"), "S"));
+      "9", formatDatetime(parseTimestamp("2022-01-01 03:30:30.999"), "S"));
   EXPECT_EQ(
-      "1", formatDatetime(fromTimestampString("2022-01-01 01:01:01.11"), "S"));
+      "99", formatDatetime(parseTimestamp("2022-01-01 03:30:30.999"), "SS"));
   EXPECT_EQ(
-      "11",
-      formatDatetime(fromTimestampString("2022-01-01 02:10:10.11"), "SS"));
-  EXPECT_EQ(
-      "9", formatDatetime(fromTimestampString("2022-01-01 03:30:30.999"), "S"));
-  EXPECT_EQ(
-      "99",
-      formatDatetime(fromTimestampString("2022-01-01 03:30:30.999"), "SS"));
-  EXPECT_EQ(
-      "999",
-      formatDatetime(fromTimestampString("2022-01-01 03:30:30.999"), "SSS"));
+      "999", formatDatetime(parseTimestamp("2022-01-01 03:30:30.999"), "SSS"));
   EXPECT_EQ(
       "12300000",
-      formatDatetime(
-          fromTimestampString("2022-01-01 03:30:30.123"), "SSSSSSSS"));
+      formatDatetime(parseTimestamp("2022-01-01 03:30:30.123"), "SSSSSSSS"));
   EXPECT_EQ(
       "0990",
-      formatDatetime(fromTimestampString("2022-01-01 03:30:30.099"), "SSSS"));
+      formatDatetime(parseTimestamp("2022-01-01 03:30:30.099"), "SSSS"));
   EXPECT_EQ(
       "0010",
-      formatDatetime(fromTimestampString("2022-01-01 03:30:30.001"), "SSSS"));
+      formatDatetime(parseTimestamp("2022-01-01 03:30:30.001"), "SSSS"));
 
-  // time zone test cases - 'z'
+  // Time zone test cases - 'z'
   setQueryTimeZone("Asia/Kolkata");
   EXPECT_EQ(
-      "Asia/Kolkata",
-      formatDatetime(fromTimestampString("1970-01-01"), "zzzz"));
+      "Asia/Kolkata", formatDatetime(parseTimestamp("1970-01-01"), "zzzz"));
+  EXPECT_EQ("+05:30", formatDatetime(parseTimestamp("1970-01-01"), "ZZ"));
 
-  // literal test cases
-  EXPECT_EQ(
-      "hello", formatDatetime(fromTimestampString("1970-01-01"), "'hello'"));
-  EXPECT_EQ("'", formatDatetime(fromTimestampString("1970-01-01"), "''"));
+  // Literal test cases.
+  EXPECT_EQ("hello", formatDatetime(parseTimestamp("1970-01-01"), "'hello'"));
+  EXPECT_EQ("'", formatDatetime(parseTimestamp("1970-01-01"), "''"));
   EXPECT_EQ(
-      "1970 ' 1970",
-      formatDatetime(fromTimestampString("1970-01-01"), "y '' y"));
+      "1970 ' 1970", formatDatetime(parseTimestamp("1970-01-01"), "y '' y"));
   EXPECT_EQ(
-      "he'llo", formatDatetime(fromTimestampString("1970-01-01"), "'he''llo'"));
+      "he'llo", formatDatetime(parseTimestamp("1970-01-01"), "'he''llo'"));
   EXPECT_EQ(
       "'he'llo'",
-      formatDatetime(fromTimestampString("1970-01-01"), "'''he''llo'''"));
+      formatDatetime(parseTimestamp("1970-01-01"), "'''he''llo'''"));
   EXPECT_EQ(
-      "1234567890",
-      formatDatetime(fromTimestampString("1970-01-01"), "1234567890"));
+      "1234567890", formatDatetime(parseTimestamp("1970-01-01"), "1234567890"));
   EXPECT_EQ(
       "\\\"!@#$%^&*()-+[]{}||`~<>.,?/;:1234567890",
       formatDatetime(
-          fromTimestampString("1970-01-01"),
+          parseTimestamp("1970-01-01"),
           "\\\"!@#$%^&*()-+[]{}||`~<>.,?/;:1234567890"));
 
-  // Multi-specifier and literal formats
+  // Multi-specifier and literal formats.
   EXPECT_EQ(
       "AD 19 1970 4 Thu 1970 1 1 1 AM 8 8 8 8 3 11 5 Asia/Kolkata",
       formatDatetime(
-          fromTimestampString("1970-01-01 02:33:11.5"),
+          parseTimestamp("1970-01-01 02:33:11.5"),
           "G C Y e E y D M d a K h H k m s S zzzz"));
   EXPECT_EQ(
       "AD 19 1970 4 asdfghjklzxcvbnmqwertyuiop Thu ' 1970 1 1 1 AM 8 8 8 8 3 11 5 1234567890\\\"!@#$%^&*()-+`~{}[];:,./ Asia/Kolkata",
       formatDatetime(
-          fromTimestampString("1970-01-01 02:33:11.5"),
+          parseTimestamp("1970-01-01 02:33:11.5"),
           "G C Y e 'asdfghjklzxcvbnmqwertyuiop' E '' y D M d a K h H k m s S 1234567890\\\"!@#$%^&*()-+`~{}[];:,./ zzzz"));
 
-  // User format errors or unsupported errors
-  EXPECT_THROW(
-      formatDatetime(fromTimestampString("1970-01-01"), "x"), VeloxUserError);
+  disableAdjustTimestampToTimezone();
+  EXPECT_EQ(
+      "1970-01-01 00:00:00",
+      formatDatetime(
+          parseTimestamp("1970-01-01 00:00:00"), "YYYY-MM-dd HH:mm:ss"));
+
+  // User format errors or unsupported errors.
   EXPECT_THROW(
-      formatDatetime(fromTimestampString("1970-01-01"), "w"), VeloxUserError);
+      formatDatetime(parseTimestamp("1970-01-01"), "x"), VeloxUserError);
   EXPECT_THROW(
-      formatDatetime(fromTimestampString("1970-01-01"), "z"), VeloxUserError);
+      formatDatetime(parseTimestamp("1970-01-01"), "z"), VeloxUserError);
   EXPECT_THROW(
-      formatDatetime(fromTimestampString("1970-01-01"), "zz"), VeloxUserError);
+      formatDatetime(parseTimestamp("1970-01-01"), "zz"), VeloxUserError);
   EXPECT_THROW(
-      formatDatetime(fromTimestampString("1970-01-01"), "zzz"), VeloxUserError);
+      formatDatetime(parseTimestamp("1970-01-01"), "zzz"), VeloxUserError);
   EXPECT_THROW(
-      formatDatetime(fromTimestampString("1970-01-01"), "q"), VeloxUserError);
+      formatDatetime(parseTimestamp("1970-01-01"), "q"), VeloxUserError);
   EXPECT_THROW(
-      formatDatetime(fromTimestampString("1970-01-01"), "'abcd"),
-      VeloxUserError);
+      formatDatetime(parseTimestamp("1970-01-01"), "'abcd"), VeloxUserError);
+}
+
+TEST_F(DateTimeFunctionsTest, formatDateTimeTimezone) {
+  const auto formatDatetimeWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone,
+          std::optional<std::string> format) {
+        return evaluateOnce<std::string>(
+            "format_datetime(c0, c1)",
+            {TIMESTAMP_WITH_TIME_ZONE(), VARCHAR()},
+            TimestampWithTimezone::pack(timestampWithTimezone),
+            format);
+      };
+
+  // UTC explicitly set.
+  EXPECT_EQ(
+      "1970-01-01 00:00:00",
+      formatDatetimeWithTimezone(
+          TimestampWithTimezone(0, "UTC"), "YYYY-MM-dd HH:mm:ss"));
+
+  // Check that string is adjusted to the timezone set.
+  EXPECT_EQ(
+      "1970-01-01 05:30:00",
+      formatDatetimeWithTimezone(
+          TimestampWithTimezone(0, "Asia/Kolkata"), "YYYY-MM-dd HH:mm:ss"));
+
+  EXPECT_EQ(
+      "1969-12-31 16:00:00",
+      formatDatetimeWithTimezone(
+          TimestampWithTimezone(0, "America/Los_Angeles"),
+          "YYYY-MM-dd HH:mm:ss"));
+
+  // Make sure format_datetime() works with timezone offsets.
+  EXPECT_EQ(
+      "1969-12-31 16:00:00",
+      formatDatetimeWithTimezone(
+          TimestampWithTimezone(0, "-08:00"), "YYYY-MM-dd HH:mm:ss"));
+  EXPECT_EQ(
+      "1969-12-31 23:45:00",
+      formatDatetimeWithTimezone(
+          TimestampWithTimezone(0, "-00:15"), "YYYY-MM-dd HH:mm:ss"));
+  EXPECT_EQ(
+      "1970-01-01 00:07:00",
+      formatDatetimeWithTimezone(
+          TimestampWithTimezone(0, "+00:07"), "YYYY-MM-dd HH:mm:ss"));
 }
 
 TEST_F(DateTimeFunctionsTest, dateFormat) {
-  const auto dateFormatOnce = [&](std::optional<Timestamp> timestamp,
-                                  const std::string& formatString) {
-    return evaluateOnce<std::string>(
-        fmt::format("date_format(c0, '{}')", formatString), timestamp);
+  const auto dateFormat = [&](std::optional<Timestamp> timestamp,
+                              std::optional<std::string> format) {
+    return evaluateOnce<std::string>("date_format(c0, c1)", timestamp, format);
   };
-  using util::fromTimestampString;
 
-  // Check null behaviors
-  EXPECT_EQ(std::nullopt, dateFormatOnce(std::nullopt, "%Y"));
+  // Check null behaviors.
+  EXPECT_EQ(std::nullopt, dateFormat(std::nullopt, "%Y"));
+  EXPECT_EQ(std::nullopt, dateFormat(Timestamp(0, 0), std::nullopt));
 
-  // Normal cases
-  EXPECT_EQ(
-      "1970-01-01", dateFormat(fromTimestampString("1970-01-01"), "%Y-%m-%d"));
+  // Normal cases.
+  EXPECT_EQ("1970-01-01", dateFormat(parseTimestamp("1970-01-01"), "%Y-%m-%d"));
   EXPECT_EQ(
       "2000-02-29 12:00:00 AM",
-      dateFormat(
-          fromTimestampString("2000-02-29 00:00:00.987"), "%Y-%m-%d %r"));
+      dateFormat(parseTimestamp("2000-02-29 00:00:00.987"), "%Y-%m-%d %r"));
   EXPECT_EQ(
       "2000-02-29 00:00:00.987000",
       dateFormat(
-          fromTimestampString("2000-02-29 00:00:00.987"),
-          "%Y-%m-%d %H:%i:%s.%f"));
+          parseTimestamp("2000-02-29 00:00:00.987"), "%Y-%m-%d %H:%i:%s.%f"));
   EXPECT_EQ(
       "-2000-02-29 00:00:00.987000",
       dateFormat(
-          fromTimestampString("-2000-02-29 00:00:00.987"),
-          "%Y-%m-%d %H:%i:%s.%f"));
-
-  // Varying digit year cases
-  EXPECT_EQ("06", dateFormat(fromTimestampString("-6-06-20"), "%y"));
-  EXPECT_EQ("-0006", dateFormat(fromTimestampString("-6-06-20"), "%Y"));
-  EXPECT_EQ("16", dateFormat(fromTimestampString("-16-06-20"), "%y"));
-  EXPECT_EQ("-0016", dateFormat(fromTimestampString("-16-06-20"), "%Y"));
-  EXPECT_EQ("66", dateFormat(fromTimestampString("-166-06-20"), "%y"));
-  EXPECT_EQ("-0166", dateFormat(fromTimestampString("-166-06-20"), "%Y"));
-  EXPECT_EQ("66", dateFormat(fromTimestampString("-1666-06-20"), "%y"));
-  EXPECT_EQ("00", dateFormat(fromTimestampString("-1900-06-20"), "%y"));
-  EXPECT_EQ("01", dateFormat(fromTimestampString("-1901-06-20"), "%y"));
-  EXPECT_EQ("10", dateFormat(fromTimestampString("-1910-06-20"), "%y"));
-  EXPECT_EQ("12", dateFormat(fromTimestampString("-12-06-20"), "%y"));
-  EXPECT_EQ("00", dateFormat(fromTimestampString("1900-06-20"), "%y"));
-  EXPECT_EQ("01", dateFormat(fromTimestampString("1901-06-20"), "%y"));
-  EXPECT_EQ("10", dateFormat(fromTimestampString("1910-06-20"), "%y"));
-
-  // Day of week cases
+          parseTimestamp("-2000-02-29 00:00:00.987"), "%Y-%m-%d %H:%i:%s.%f"));
+
+  // Varying digit year cases.
+  EXPECT_EQ("06", dateFormat(parseTimestamp("-6-06-20"), "%y"));
+  EXPECT_EQ("-0006", dateFormat(parseTimestamp("-6-06-20"), "%Y"));
+  EXPECT_EQ("16", dateFormat(parseTimestamp("-16-06-20"), "%y"));
+  EXPECT_EQ("-0016", dateFormat(parseTimestamp("-16-06-20"), "%Y"));
+  EXPECT_EQ("66", dateFormat(parseTimestamp("-166-06-20"), "%y"));
+  EXPECT_EQ("-0166", dateFormat(parseTimestamp("-166-06-20"), "%Y"));
+  EXPECT_EQ("66", dateFormat(parseTimestamp("-1666-06-20"), "%y"));
+  EXPECT_EQ("00", dateFormat(parseTimestamp("-1900-06-20"), "%y"));
+  EXPECT_EQ("01", dateFormat(parseTimestamp("-1901-06-20"), "%y"));
+  EXPECT_EQ("10", dateFormat(parseTimestamp("-1910-06-20"), "%y"));
+  EXPECT_EQ("12", dateFormat(parseTimestamp("-12-06-20"), "%y"));
+  EXPECT_EQ("00", dateFormat(parseTimestamp("1900-06-20"), "%y"));
+  EXPECT_EQ("01", dateFormat(parseTimestamp("1901-06-20"), "%y"));
+  EXPECT_EQ("10", dateFormat(parseTimestamp("1910-06-20"), "%y"));
+
+  // Day of week cases.
   for (int i = 0; i < 8; i++) {
     std::string date("1996-01-0" + std::to_string(i + 1));
-    // Full length name
+    // Full length name.
     EXPECT_EQ(
-        daysLong[i % 7],
-        dateFormat(fromTimestampString(StringView{date}), "%W"));
-    // Abbreviated name
+        daysLong[i % 7], dateFormat(parseTimestamp(StringView{date}), "%W"));
+    // Abbreviated name.
     EXPECT_EQ(
-        daysShort[i % 7],
-        dateFormat(fromTimestampString(StringView{date}), "%a"));
+        daysShort[i % 7], dateFormat(parseTimestamp(StringView{date}), "%a"));
   }
 
-  // Month cases
+  // Month cases.
   for (int i = 0; i < 12; i++) {
     std::string date("1996-" + std::to_string(i + 1) + "-01");
     std::string monthNum = std::to_string(i + 1);
-    // Full length name
+
+    // Full length name.
     EXPECT_EQ(
-        monthsLong[i % 12],
-        dateFormat(fromTimestampString(StringView{date}), "%M"));
-    // Abbreviated name
+        monthsLong[i % 12], dateFormat(parseTimestamp(StringView{date}), "%M"));
+
+    // Abbreviated name.
     EXPECT_EQ(
         monthsShort[i % 12],
-        dateFormat(fromTimestampString(StringView{date}), "%b"));
-    // Numeric
-    EXPECT_EQ(
-        monthNum, dateFormat(fromTimestampString(StringView{date}), "%c"));
-    // Numeric 0-padded
+        dateFormat(parseTimestamp(StringView{date}), "%b"));
+
+    // Numeric.
+    EXPECT_EQ(monthNum, dateFormat(parseTimestamp(StringView{date}), "%c"));
+
+    // Numeric 0-padded.
     if (i + 1 < 10) {
       EXPECT_EQ(
-          "0" + monthNum,
-          dateFormat(fromTimestampString(StringView{date}), "%m"));
+          "0" + monthNum, dateFormat(parseTimestamp(StringView{date}), "%m"));
     } else {
-      EXPECT_EQ(
-          monthNum, dateFormat(fromTimestampString(StringView{date}), "%m"));
+      EXPECT_EQ(monthNum, dateFormat(parseTimestamp(StringView{date}), "%m"));
     }
   }
 
-  // Day of month cases
+  // Day of month cases.
   for (int i = 1; i <= 31; i++) {
     std::string dayOfMonth = std::to_string(i);
     std::string date("1970-01-" + dayOfMonth);
-    EXPECT_EQ(
-        dayOfMonth,
-        dateFormat(util::fromTimestampString(StringView{date}), "%e"));
+    EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%e"));
     if (i < 10) {
       EXPECT_EQ(
-          "0" + dayOfMonth,
-          dateFormat(util::fromTimestampString(StringView{date}), "%d"));
+          "0" + dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%d"));
     } else {
-      EXPECT_EQ(
-          dayOfMonth,
-          dateFormat(util::fromTimestampString(StringView{date}), "%d"));
+      EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%d"));
     }
   }
 
-  // Fraction of second cases
+  // Week of the year cases. Follows ISO week date format.
+  //   https://en.wikipedia.org/wiki/ISO_week_date
+  EXPECT_EQ("01", dateFormat(parseTimestamp("2024-01-01"), "%v"));
+  EXPECT_EQ("01", dateFormat(parseTimestamp("2024-01-07"), "%v"));
+  EXPECT_EQ("02", dateFormat(parseTimestamp("2024-01-08"), "%v"));
+  EXPECT_EQ("52", dateFormat(parseTimestamp("2024-12-29"), "%v"));
+  EXPECT_EQ("01", dateFormat(parseTimestamp("2024-12-30"), "%v"));
+  EXPECT_EQ("01", dateFormat(parseTimestamp("2024-12-31"), "%v"));
+  EXPECT_EQ("01", dateFormat(parseTimestamp("2025-01-01"), "%v"));
+  EXPECT_EQ("53", dateFormat(parseTimestamp("2021-01-01"), "%v"));
+  EXPECT_EQ("53", dateFormat(parseTimestamp("2021-01-03"), "%v"));
+  EXPECT_EQ("01", dateFormat(parseTimestamp("2021-01-04"), "%v"));
+
+  // Fraction of second cases.
   EXPECT_EQ(
-      "000000", dateFormat(fromTimestampString("2022-01-01 00:00:00.0"), "%f"));
+      "000000", dateFormat(parseTimestamp("2022-01-01 00:00:00.0"), "%f"));
   EXPECT_EQ(
-      "100000", dateFormat(fromTimestampString("2022-01-01 00:00:00.1"), "%f"));
+      "100000", dateFormat(parseTimestamp("2022-01-01 00:00:00.1"), "%f"));
   EXPECT_EQ(
-      "110000",
-      dateFormat(fromTimestampString("2022-01-01 01:01:01.11"), "%f"));
+      "110000", dateFormat(parseTimestamp("2022-01-01 01:01:01.11"), "%f"));
   EXPECT_EQ(
-      "110000",
-      dateFormat(fromTimestampString("2022-01-01 02:10:10.11"), "%f"));
+      "110000", dateFormat(parseTimestamp("2022-01-01 02:10:10.11"), "%f"));
   EXPECT_EQ(
-      "999000",
-      dateFormat(fromTimestampString("2022-01-01 03:30:30.999"), "%f"));
+      "999000", dateFormat(parseTimestamp("2022-01-01 03:30:30.999"), "%f"));
   EXPECT_EQ(
-      "999000",
-      dateFormat(fromTimestampString("2022-01-01 03:30:30.999"), "%f"));
+      "999000", dateFormat(parseTimestamp("2022-01-01 03:30:30.999"), "%f"));
   EXPECT_EQ(
-      "999000",
-      dateFormat(fromTimestampString("2022-01-01 03:30:30.999"), "%f"));
+      "999000", dateFormat(parseTimestamp("2022-01-01 03:30:30.999"), "%f"));
   EXPECT_EQ(
-      "123000",
-      dateFormat(fromTimestampString("2022-01-01 03:30:30.123"), "%f"));
+      "123000", dateFormat(parseTimestamp("2022-01-01 03:30:30.123"), "%f"));
   EXPECT_EQ(
-      "099000",
-      dateFormat(fromTimestampString("2022-01-01 03:30:30.099"), "%f"));
+      "099000", dateFormat(parseTimestamp("2022-01-01 03:30:30.099"), "%f"));
   EXPECT_EQ(
-      "001000",
-      dateFormat(fromTimestampString("2022-01-01 03:30:30.001234"), "%f"));
+      "001000", dateFormat(parseTimestamp("2022-01-01 03:30:30.001234"), "%f"));
 
-  // Hour cases
+  // Hour cases.
   for (int i = 0; i < 24; i++) {
     std::string hour = std::to_string(i);
     int clockHour = (i + 11) % 12 + 1;
     std::string clockHourString = std::to_string(clockHour);
     std::string toBuild = "1996-01-01 " + hour + ":00:00";
     StringView date(toBuild);
-    EXPECT_EQ(hour, dateFormat(util::fromTimestampString(date), "%k"));
+    EXPECT_EQ(hour, dateFormat(parseTimestamp(date), "%k"));
     if (i < 10) {
-      EXPECT_EQ("0" + hour, dateFormat(util::fromTimestampString(date), "%H"));
+      EXPECT_EQ("0" + hour, dateFormat(parseTimestamp(date), "%H"));
     } else {
-      EXPECT_EQ(hour, dateFormat(util::fromTimestampString(date), "%H"));
+      EXPECT_EQ(hour, dateFormat(parseTimestamp(date), "%H"));
     }
 
-    EXPECT_EQ(
-        clockHourString, dateFormat(util::fromTimestampString(date), "%l"));
+    EXPECT_EQ(clockHourString, dateFormat(parseTimestamp(date), "%l"));
     if (clockHour < 10) {
-      EXPECT_EQ(
-          "0" + clockHourString,
-          dateFormat(util::fromTimestampString(date), "%h"));
-      EXPECT_EQ(
-          "0" + clockHourString,
-          dateFormat(util::fromTimestampString(date), "%I"));
+      EXPECT_EQ("0" + clockHourString, dateFormat(parseTimestamp(date), "%h"));
+      EXPECT_EQ("0" + clockHourString, dateFormat(parseTimestamp(date), "%I"));
     } else {
-      EXPECT_EQ(
-          clockHourString, dateFormat(util::fromTimestampString(date), "%h"));
-      EXPECT_EQ(
-          clockHourString, dateFormat(util::fromTimestampString(date), "%I"));
+      EXPECT_EQ(clockHourString, dateFormat(parseTimestamp(date), "%h"));
+      EXPECT_EQ(clockHourString, dateFormat(parseTimestamp(date), "%I"));
     }
   }
 
-  // Minute cases
+  // Minute cases.
   for (int i = 0; i < 60; i++) {
     std::string minute = std::to_string(i);
     std::string toBuild = "1996-01-01 00:" + minute + ":00";
     StringView date(toBuild);
     if (i < 10) {
-      EXPECT_EQ("0" + minute, dateFormat(fromTimestampString(date), "%i"));
+      EXPECT_EQ("0" + minute, dateFormat(parseTimestamp(date), "%i"));
     } else {
-      EXPECT_EQ(minute, dateFormat(fromTimestampString(date), "%i"));
+      EXPECT_EQ(minute, dateFormat(parseTimestamp(date), "%i"));
     }
   }
 
-  // Second cases
+  // Second cases.
   for (int i = 0; i < 60; i++) {
     std::string second = std::to_string(i);
     std::string toBuild = "1996-01-01 00:00:" + second;
     StringView date(toBuild);
     if (i < 10) {
-      EXPECT_EQ("0" + second, dateFormat(fromTimestampString(date), "%S"));
-      EXPECT_EQ("0" + second, dateFormat(fromTimestampString(date), "%s"));
+      EXPECT_EQ("0" + second, dateFormat(parseTimestamp(date), "%S"));
+      EXPECT_EQ("0" + second, dateFormat(parseTimestamp(date), "%s"));
     } else {
-      EXPECT_EQ(second, dateFormat(fromTimestampString(date), "%S"));
-      EXPECT_EQ(second, dateFormat(fromTimestampString(date), "%s"));
+      EXPECT_EQ(second, dateFormat(parseTimestamp(date), "%S"));
+      EXPECT_EQ(second, dateFormat(parseTimestamp(date), "%s"));
     }
   }
 
-  // Day of year cases
-  EXPECT_EQ("001", dateFormat(fromTimestampString("2022-01-01"), "%j"));
-  EXPECT_EQ("010", dateFormat(fromTimestampString("2022-01-10"), "%j"));
-  EXPECT_EQ("100", dateFormat(fromTimestampString("2022-04-10"), "%j"));
-  EXPECT_EQ("365", dateFormat(fromTimestampString("2022-12-31"), "%j"));
+  // Day of year cases.
+  EXPECT_EQ("001", dateFormat(parseTimestamp("2022-01-01"), "%j"));
+  EXPECT_EQ("010", dateFormat(parseTimestamp("2022-01-10"), "%j"));
+  EXPECT_EQ("100", dateFormat(parseTimestamp("2022-04-10"), "%j"));
+  EXPECT_EQ("365", dateFormat(parseTimestamp("2022-12-31"), "%j"));
 
-  // Halfday of day cases
-  EXPECT_EQ("AM", dateFormat(fromTimestampString("2022-01-01 00:00:00"), "%p"));
-  EXPECT_EQ("AM", dateFormat(fromTimestampString("2022-01-01 11:59:59"), "%p"));
-  EXPECT_EQ("PM", dateFormat(fromTimestampString("2022-01-01 12:00:00"), "%p"));
-  EXPECT_EQ("PM", dateFormat(fromTimestampString("2022-01-01 23:59:59"), "%p"));
+  // Halfday of day cases.
+  EXPECT_EQ("AM", dateFormat(parseTimestamp("2022-01-01 00:00:00"), "%p"));
+  EXPECT_EQ("AM", dateFormat(parseTimestamp("2022-01-01 11:59:59"), "%p"));
+  EXPECT_EQ("PM", dateFormat(parseTimestamp("2022-01-01 12:00:00"), "%p"));
+  EXPECT_EQ("PM", dateFormat(parseTimestamp("2022-01-01 23:59:59"), "%p"));
 
-  // 12-hour time cases
+  // 12-hour time cases.
   EXPECT_EQ(
-      "12:00:00 AM",
-      dateFormat(fromTimestampString("2022-01-01 00:00:00"), "%r"));
+      "12:00:00 AM", dateFormat(parseTimestamp("2022-01-01 00:00:00"), "%r"));
   EXPECT_EQ(
-      "11:59:59 AM",
-      dateFormat(fromTimestampString("2022-01-01 11:59:59"), "%r"));
+      "11:59:59 AM", dateFormat(parseTimestamp("2022-01-01 11:59:59"), "%r"));
   EXPECT_EQ(
-      "12:00:00 PM",
-      dateFormat(fromTimestampString("2022-01-01 12:00:00"), "%r"));
+      "12:00:00 PM", dateFormat(parseTimestamp("2022-01-01 12:00:00"), "%r"));
   EXPECT_EQ(
-      "11:59:59 PM",
-      dateFormat(fromTimestampString("2022-01-01 23:59:59"), "%r"));
+      "11:59:59 PM", dateFormat(parseTimestamp("2022-01-01 23:59:59"), "%r"));
 
-  // 24-hour time cases
+  // 24-hour time cases.
   EXPECT_EQ(
-      "00:00:00", dateFormat(fromTimestampString("2022-01-01 00:00:00"), "%T"));
+      "00:00:00", dateFormat(parseTimestamp("2022-01-01 00:00:00"), "%T"));
   EXPECT_EQ(
-      "11:59:59", dateFormat(fromTimestampString("2022-01-01 11:59:59"), "%T"));
+      "11:59:59", dateFormat(parseTimestamp("2022-01-01 11:59:59"), "%T"));
   EXPECT_EQ(
-      "12:00:00", dateFormat(fromTimestampString("2022-01-01 12:00:00"), "%T"));
+      "12:00:00", dateFormat(parseTimestamp("2022-01-01 12:00:00"), "%T"));
   EXPECT_EQ(
-      "23:59:59", dateFormat(fromTimestampString("2022-01-01 23:59:59"), "%T"));
+      "23:59:59", dateFormat(parseTimestamp("2022-01-01 23:59:59"), "%T"));
 
-  // Percent followed by non-existent specifier case
-  EXPECT_EQ("q", dateFormat(fromTimestampString("1970-01-01"), "%q"));
-  EXPECT_EQ("z", dateFormat(fromTimestampString("1970-01-01"), "%z"));
-  EXPECT_EQ("g", dateFormat(fromTimestampString("1970-01-01"), "%g"));
+  // Percent followed by non-existent specifier case.
+  EXPECT_EQ("q", dateFormat(parseTimestamp("1970-01-01"), "%q"));
+  EXPECT_EQ("z", dateFormat(parseTimestamp("1970-01-01"), "%z"));
+  EXPECT_EQ("g", dateFormat(parseTimestamp("1970-01-01"), "%g"));
 
   // With timezone. Indian Standard Time (IST) UTC+5:30.
   setQueryTimeZone("Asia/Kolkata");
 
-  EXPECT_EQ(
-      "1970-01-01", dateFormat(fromTimestampString("1970-01-01"), "%Y-%m-%d"));
+  EXPECT_EQ("1970-01-01", dateFormat(parseTimestamp("1970-01-01"), "%Y-%m-%d"));
   EXPECT_EQ(
       "2000-02-29 05:30:00 AM",
-      dateFormat(
-          fromTimestampString("2000-02-29 00:00:00.987"), "%Y-%m-%d %r"));
+      dateFormat(parseTimestamp("2000-02-29 00:00:00.987"), "%Y-%m-%d %r"));
   EXPECT_EQ(
       "2000-02-29 05:30:00.987000",
       dateFormat(
-          fromTimestampString("2000-02-29 00:00:00.987"),
-          "%Y-%m-%d %H:%i:%s.%f"));
+          parseTimestamp("2000-02-29 00:00:00.987"), "%Y-%m-%d %H:%i:%s.%f"));
   EXPECT_EQ(
       "-2000-02-29 05:53:28.987000",
       dateFormat(
-          fromTimestampString("-2000-02-29 00:00:00.987"),
-          "%Y-%m-%d %H:%i:%s.%f"));
+          parseTimestamp("-2000-02-29 00:00:00.987"), "%Y-%m-%d %H:%i:%s.%f"));
 
   // Same timestamps with a different timezone. Pacific Daylight Time (North
   // America) PDT UTC-8:00.
   setQueryTimeZone("America/Los_Angeles");
 
-  EXPECT_EQ(
-      "1969-12-31", dateFormat(fromTimestampString("1970-01-01"), "%Y-%m-%d"));
+  EXPECT_EQ("1969-12-31", dateFormat(parseTimestamp("1970-01-01"), "%Y-%m-%d"));
   EXPECT_EQ(
       "2000-02-28 04:00:00 PM",
-      dateFormat(
-          fromTimestampString("2000-02-29 00:00:00.987"), "%Y-%m-%d %r"));
+      dateFormat(parseTimestamp("2000-02-29 00:00:00.987"), "%Y-%m-%d %r"));
   EXPECT_EQ(
       "2000-02-28 16:00:00.987000",
       dateFormat(
-          fromTimestampString("2000-02-29 00:00:00.987"),
-          "%Y-%m-%d %H:%i:%s.%f"));
+          parseTimestamp("2000-02-29 00:00:00.987"), "%Y-%m-%d %H:%i:%s.%f"));
   EXPECT_EQ(
       "-2000-02-28 16:07:02.987000",
       dateFormat(
-          fromTimestampString("-2000-02-29 00:00:00.987"),
-          "%Y-%m-%d %H:%i:%s.%f"));
+          parseTimestamp("-2000-02-29 00:00:00.987"), "%Y-%m-%d %H:%i:%s.%f"));
 
-  // User format errors or unsupported errors
-  EXPECT_THROW(
-      dateFormat(fromTimestampString("-2000-02-29 00:00:00.987"), "%D"),
-      VeloxUserError);
-  EXPECT_THROW(
-      dateFormat(fromTimestampString("-2000-02-29 00:00:00.987"), "%U"),
-      VeloxUserError);
-  EXPECT_THROW(
-      dateFormat(fromTimestampString("-2000-02-29 00:00:00.987"), "%u"),
-      VeloxUserError);
-  EXPECT_THROW(
-      dateFormat(fromTimestampString("-2000-02-29 00:00:00.987"), "%V"),
-      VeloxUserError);
-  EXPECT_THROW(
-      dateFormat(fromTimestampString("-2000-02-29 00:00:00.987"), "%w"),
-      VeloxUserError);
-  EXPECT_THROW(
-      dateFormat(fromTimestampString("-2000-02-29 00:00:00.987"), "%X"),
-      VeloxUserError);
-  EXPECT_THROW(
-      dateFormat(fromTimestampString("-2000-02-29 00:00:00.987"), "%v"),
-      VeloxUserError);
-  EXPECT_THROW(
-      dateFormat(fromTimestampString("-2000-02-29 00:00:00.987"), "%x"),
-      VeloxUserError);
+  // User format errors or unsupported errors.
+  const auto timestamp = parseTimestamp("-2000-02-29 00:00:00.987");
+  VELOX_ASSERT_THROW(
+      dateFormat(timestamp, "%D"),
+      "Date format specifier is not supported: %D");
+  VELOX_ASSERT_THROW(
+      dateFormat(timestamp, "%U"),
+      "Date format specifier is not supported: %U");
+  VELOX_ASSERT_THROW(
+      dateFormat(timestamp, "%u"),
+      "Date format specifier is not supported: %u");
+  VELOX_ASSERT_THROW(
+      dateFormat(timestamp, "%V"),
+      "Date format specifier is not supported: %V");
+  VELOX_ASSERT_THROW(
+      dateFormat(timestamp, "%w"),
+      "Date format specifier is not supported: %w");
+  VELOX_ASSERT_THROW(
+      dateFormat(timestamp, "%X"),
+      "Date format specifier is not supported: %X");
+  VELOX_ASSERT_THROW(
+      dateFormat(timestamp, "%x"),
+      "Date format specifier is not supported: WEEK_YEAR");
 }
 
 TEST_F(DateTimeFunctionsTest, dateFormatTimestampWithTimezone) {
-  const auto testDateFormat =
+  const auto dateFormatTimestampWithTimezone =
       [&](const std::string& formatString,
-          std::optional<int64_t> timestamp,
-          const std::optional<std::string>& timeZoneName) {
-        return evaluateWithTimestampWithTimezone<std::string>(
+          std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<std::string>(
             fmt::format("date_format(c0, '{}')", formatString),
-            timestamp,
-            timeZoneName);
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
       };
 
   EXPECT_EQ(
-      "1969-12-31 11:00:00 PM", testDateFormat("%Y-%m-%d %r", 0, "-01:00"));
+      "1969-12-31 11:00:00 PM",
+      dateFormatTimestampWithTimezone(
+          "%Y-%m-%d %r", TimestampWithTimezone(0, "-01:00")));
   EXPECT_EQ(
       "1973-11-30 12:33:09 AM",
-      testDateFormat("%Y-%m-%d %r", 123456789000, "+03:00"));
+      dateFormatTimestampWithTimezone(
+          "%Y-%m-%d %r", TimestampWithTimezone(123456789000, "+03:00")));
   EXPECT_EQ(
       "1966-02-01 12:26:51 PM",
-      testDateFormat("%Y-%m-%d %r", -123456789000, "-14:00"));
+      dateFormatTimestampWithTimezone(
+          "%Y-%m-%d %r", TimestampWithTimezone(-123456789000, "-14:00")));
   EXPECT_EQ(
       "2001-04-19 18:25:21.000000",
-      testDateFormat("%Y-%m-%d %H:%i:%s.%f", 987654321000, "+14:00"));
+      dateFormatTimestampWithTimezone(
+          "%Y-%m-%d %H:%i:%s.%f",
+          TimestampWithTimezone(987654321000, "+14:00")));
   EXPECT_EQ(
       "1938-09-14 23:34:39.000000",
-      testDateFormat("%Y-%m-%d %H:%i:%s.%f", -987654321000, "+04:00"));
+      dateFormatTimestampWithTimezone(
+          "%Y-%m-%d %H:%i:%s.%f",
+          TimestampWithTimezone(-987654321000, "+04:00")));
   EXPECT_EQ(
       "70-August-22 17:55:15 PM",
-      testDateFormat("%y-%M-%e %T %p", 20220915000, "-07:00"));
+      dateFormatTimestampWithTimezone(
+          "%y-%M-%e %T %p", TimestampWithTimezone(20220915000, "-07:00")));
   EXPECT_EQ(
       "69-May-11 20:04:45 PM",
-      testDateFormat("%y-%M-%e %T %p", -20220915000, "-03:00"));
+      dateFormatTimestampWithTimezone(
+          "%y-%M-%e %T %p", TimestampWithTimezone(-20220915000, "-03:00")));
+}
+
+TEST_F(DateTimeFunctionsTest, fromIso8601Date) {
+  const auto fromIso = [&](const std::string& input) {
+    return evaluateOnce<int32_t, std::string>("from_iso8601_date(c0)", input);
+  };
+
+  EXPECT_EQ(0, fromIso("1970-01-01"));
+  EXPECT_EQ(9, fromIso("1970-01-10"));
+  EXPECT_EQ(-1, fromIso("1969-12-31"));
+  EXPECT_EQ(0, fromIso("1970"));
+  EXPECT_EQ(0, fromIso("1970-01"));
+  EXPECT_EQ(0, fromIso("1970-1"));
+  EXPECT_EQ(8, fromIso("1970-1-9"));
+  EXPECT_EQ(-31, fromIso("1969-12"));
+  EXPECT_EQ(-31, fromIso("1969-12-1"));
+  EXPECT_EQ(-31, fromIso("1969-12-01"));
+  EXPECT_EQ(-719862, fromIso("-1-2-1"));
+
+  VELOX_ASSERT_THROW(fromIso(" 2024-01-12"), "Unable to parse date value");
+  VELOX_ASSERT_THROW(fromIso("2024-01-12  "), "Unable to parse date value");
+  VELOX_ASSERT_THROW(fromIso("2024 "), "Unable to parse date value");
+  VELOX_ASSERT_THROW(fromIso("2024-01-xx"), "Unable to parse date value");
+  VELOX_ASSERT_THROW(
+      fromIso("2024-01-02T12:31:00"), "Unable to parse date value");
+  VELOX_ASSERT_THROW(
+      fromIso("2024-01-02 12:31:00"), "Unable to parse date value");
+}
+
+TEST_F(DateTimeFunctionsTest, fromIso8601Timestamp) {
+  const auto fromIso = [&](const std::string& input) {
+    auto result =
+        evaluateOnce<int64_t, std::string>("from_iso8601_timestamp(c0)", input);
+    return TimestampWithTimezone::unpack(result);
+  };
+
+  // Full strings with different time zones.
+  const auto millis = kMillisInDay + 11 * kMillisInHour + 38 * kMillisInMinute +
+      56 * kMillisInSecond + 123;
+  const std::string ts = "1970-01-02T11:38:56.123";
+
+  EXPECT_EQ(
+      TimestampWithTimezone(millis + 5 * kMillisInHour, "-05:00"),
+      fromIso(ts + "-05:00"));
+
+  EXPECT_EQ(
+      TimestampWithTimezone(millis - 8 * kMillisInHour, "+08:00"),
+      fromIso(ts + "+08:00"));
+
+  EXPECT_EQ(TimestampWithTimezone(millis, "UTC"), fromIso(ts + "Z"));
+
+  EXPECT_EQ(TimestampWithTimezone(millis, "UTC"), fromIso(ts));
+
+  // Partial strings with different session time zones.
+  struct {
+    std::string name;
+    int32_t offset;
+  } timezones[] = {
+      {"America/New_York", -5 * kMillisInHour},
+      {"Asia/Kolkata", 5 * kMillisInHour + 30 * kMillisInMinute},
+  };
+
+  for (const auto& timezone : timezones) {
+    setQueryTimeZone(timezone.name);
+
+    const auto timezoneId = tz::getTimeZoneID(timezone.name);
+
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            kMillisInDay + 11 * kMillisInHour + 38 * kMillisInMinute +
+                56 * kMillisInSecond + 123 - timezone.offset,
+            timezoneId),
+        fromIso("1970-01-02T11:38:56.123"));
+
+    // Comma separator between seconds and microseconds.
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            kMillisInDay + 11 * kMillisInHour + 38 * kMillisInMinute +
+                56 * kMillisInSecond + 123 - timezone.offset,
+            timezoneId),
+        fromIso("1970-01-02T11:38:56,123"));
+
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            kMillisInDay + 11 * kMillisInHour + 38 * kMillisInMinute +
+                56 * kMillisInSecond - timezone.offset,
+            timezoneId),
+        fromIso("1970-01-02T11:38:56"));
+
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            kMillisInDay + 11 * kMillisInHour + 38 * kMillisInMinute -
+                timezone.offset,
+            timezoneId),
+        fromIso("1970-01-02T11:38"));
+
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            kMillisInDay + 11 * kMillisInHour - timezone.offset, timezoneId),
+        fromIso("1970-01-02T11"));
+
+    // No time.
+    EXPECT_EQ(
+        TimestampWithTimezone(kMillisInDay - timezone.offset, timezoneId),
+        fromIso("1970-01-02"));
+
+    EXPECT_EQ(
+        TimestampWithTimezone(-timezone.offset, timezoneId),
+        fromIso("1970-01-01"));
+    EXPECT_EQ(
+        TimestampWithTimezone(-timezone.offset, timezoneId),
+        fromIso("1970-01"));
+    EXPECT_EQ(
+        TimestampWithTimezone(-timezone.offset, timezoneId), fromIso("1970"));
+
+    // No date.
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            11 * kMillisInHour + 38 * kMillisInMinute + 56 * kMillisInSecond +
+                123 - timezone.offset,
+            timezoneId),
+        fromIso("T11:38:56.123"));
+
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            11 * kMillisInHour + 38 * kMillisInMinute + 56 * kMillisInSecond +
+                123 - timezone.offset,
+            timezoneId),
+        fromIso("T11:38:56,123"));
+
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            11 * kMillisInHour + 38 * kMillisInMinute + 56 * kMillisInSecond -
+                timezone.offset,
+            timezoneId),
+        fromIso("T11:38:56"));
+
+    EXPECT_EQ(
+        TimestampWithTimezone(
+            11 * kMillisInHour + 38 * kMillisInMinute - timezone.offset,
+            timezoneId),
+        fromIso("T11:38"));
+
+    EXPECT_EQ(
+        TimestampWithTimezone(11 * kMillisInHour - timezone.offset, timezoneId),
+        fromIso("T11"));
+  }
+
+  VELOX_ASSERT_THROW(
+      fromIso("1970-01-02 11:38"),
+      R"(Unable to parse timestamp value: "1970-01-02 11:38")");
+
+  VELOX_ASSERT_THROW(
+      fromIso("1970-01-02T11:38:56.123 America/New_York"),
+      R"(Unable to parse timestamp value: "1970-01-02T11:38:56.123 America/New_York")");
+
+  VELOX_ASSERT_THROW(fromIso("T"), R"(Unable to parse timestamp value: "T")");
+
+  // Leading and trailing spaces are not allowed.
+  VELOX_ASSERT_THROW(
+      fromIso(" 1970-01-02"),
+      R"(Unable to parse timestamp value: " 1970-01-02")");
+
+  VELOX_ASSERT_THROW(
+      fromIso("1970-01-02 "),
+      R"(Unable to parse timestamp value: "1970-01-02 ")");
+}
+
+TEST_F(DateTimeFunctionsTest, dateParseMonthOfYearText) {
+  auto parseAndFormat = [&](std::optional<std::string> input) {
+    return evaluateOnce<std::string>(
+        "date_format(date_parse(c0, '%M_%Y'), '%Y-%m')", input);
+  };
+
+  EXPECT_EQ(parseAndFormat(std::nullopt), std::nullopt);
+  EXPECT_EQ(parseAndFormat("jan_2024"), "2024-01");
+  EXPECT_EQ(parseAndFormat("JAN_2024"), "2024-01");
+  EXPECT_EQ(parseAndFormat("january_2024"), "2024-01");
+  EXPECT_EQ(parseAndFormat("JANUARY_2024"), "2024-01");
+
+  EXPECT_EQ(parseAndFormat("feb_2024"), "2024-02");
+  EXPECT_EQ(parseAndFormat("FEB_2024"), "2024-02");
+  EXPECT_EQ(parseAndFormat("february_2024"), "2024-02");
+  EXPECT_EQ(parseAndFormat("FEBRUARY_2024"), "2024-02");
+
+  EXPECT_EQ(parseAndFormat("mar_2024"), "2024-03");
+  EXPECT_EQ(parseAndFormat("MAR_2024"), "2024-03");
+  EXPECT_EQ(parseAndFormat("march_2024"), "2024-03");
+  EXPECT_EQ(parseAndFormat("MARCH_2024"), "2024-03");
+
+  EXPECT_EQ(parseAndFormat("apr_2024"), "2024-04");
+  EXPECT_EQ(parseAndFormat("APR_2024"), "2024-04");
+  EXPECT_EQ(parseAndFormat("april_2024"), "2024-04");
+  EXPECT_EQ(parseAndFormat("APRIL_2024"), "2024-04");
+
+  EXPECT_EQ(parseAndFormat("may_2024"), "2024-05");
+  EXPECT_EQ(parseAndFormat("MAY_2024"), "2024-05");
+
+  EXPECT_EQ(parseAndFormat("jun_2024"), "2024-06");
+  EXPECT_EQ(parseAndFormat("JUN_2024"), "2024-06");
+  EXPECT_EQ(parseAndFormat("june_2024"), "2024-06");
+  EXPECT_EQ(parseAndFormat("JUNE_2024"), "2024-06");
+
+  EXPECT_EQ(parseAndFormat("jul_2024"), "2024-07");
+  EXPECT_EQ(parseAndFormat("JUL_2024"), "2024-07");
+  EXPECT_EQ(parseAndFormat("july_2024"), "2024-07");
+  EXPECT_EQ(parseAndFormat("JULY_2024"), "2024-07");
+
+  EXPECT_EQ(parseAndFormat("aug_2024"), "2024-08");
+  EXPECT_EQ(parseAndFormat("AUG_2024"), "2024-08");
+  EXPECT_EQ(parseAndFormat("august_2024"), "2024-08");
+  EXPECT_EQ(parseAndFormat("AUGUST_2024"), "2024-08");
+
+  EXPECT_EQ(parseAndFormat("sep_2024"), "2024-09");
+  EXPECT_EQ(parseAndFormat("SEP_2024"), "2024-09");
+  EXPECT_EQ(parseAndFormat("september_2024"), "2024-09");
+  EXPECT_EQ(parseAndFormat("SEPTEMBER_2024"), "2024-09");
+
+  EXPECT_EQ(parseAndFormat("oct_2024"), "2024-10");
+  EXPECT_EQ(parseAndFormat("OCT_2024"), "2024-10");
+  EXPECT_EQ(parseAndFormat("october_2024"), "2024-10");
+  EXPECT_EQ(parseAndFormat("OCTOBER_2024"), "2024-10");
+
+  EXPECT_EQ(parseAndFormat("nov_2024"), "2024-11");
+  EXPECT_EQ(parseAndFormat("NOV_2024"), "2024-11");
+  EXPECT_EQ(parseAndFormat("november_2024"), "2024-11");
+  EXPECT_EQ(parseAndFormat("NOVEMBER_2024"), "2024-11");
+
+  EXPECT_EQ(parseAndFormat("dec_2024"), "2024-12");
+  EXPECT_EQ(parseAndFormat("DEC_2024"), "2024-12");
+  EXPECT_EQ(parseAndFormat("december_2024"), "2024-12");
+  EXPECT_EQ(parseAndFormat("DECEMBER_2024"), "2024-12");
 }
 
 TEST_F(DateTimeFunctionsTest, dateParse) {
+  const auto dateParse = [&](std::optional<std::string> input,
+                             std::optional<std::string> format) {
+    return evaluateOnce<Timestamp>("date_parse(c0, c1)", input, format);
+  };
+
   // Check null behavior.
   EXPECT_EQ(std::nullopt, dateParse("1970-01-01", std::nullopt));
   EXPECT_EQ(std::nullopt, dateParse(std::nullopt, "YYYY-MM-dd"));
@@ -3188,12 +3934,9 @@ TEST_F(DateTimeFunctionsTest, dateParse) {
   EXPECT_EQ(
       Timestamp(-66600, 0), dateParse("1969-12-31+11:00", "%Y-%m-%d+%H:%i"));
 
-  VELOX_ASSERT_THROW(
-      dateParse("", "%y+"), "Invalid format: \"\" is malformed at \"\"");
-  VELOX_ASSERT_THROW(
-      dateParse("1", "%y+"), "Invalid format: \"1\" is malformed at \"1\"");
-  VELOX_ASSERT_THROW(
-      dateParse("116", "%y+"), "Invalid format: \"116\" is malformed at \"6\"");
+  VELOX_ASSERT_THROW(dateParse("", "%y+"), "Invalid date format: ''");
+  VELOX_ASSERT_THROW(dateParse("1", "%y+"), "Invalid date format: '1'");
+  VELOX_ASSERT_THROW(dateParse("116", "%y+"), "Invalid date format: '116'");
 }
 
 TEST_F(DateTimeFunctionsTest, dateFunctionVarchar) {
@@ -3208,10 +3951,15 @@ TEST_F(DateTimeFunctionsTest, dateFunctionVarchar) {
   // Date(-18297) is 1919-11-28.
   EXPECT_EQ(-18297, dateFunction("1919-11-28"));
 
+  // Allow leading and trailing spaces.
+  EXPECT_EQ(18297, dateFunction("   2020-02-05"));
+  EXPECT_EQ(18297, dateFunction("  2020-02-05   "));
+  EXPECT_EQ(18297, dateFunction("2020-02-05 "));
+
   // Illegal date format.
   VELOX_ASSERT_THROW(
       dateFunction("2020-02-05 11:00"),
-      "Unable to parse date value: \"2020-02-05 11:00\", expected format is (YYYY-MM-DD)");
+      "Unable to parse date value: \"2020-02-05 11:00\"");
 }
 
 TEST_F(DateTimeFunctionsTest, dateFunctionTimestamp) {
@@ -3267,8 +4015,12 @@ TEST_F(DateTimeFunctionsTest, dateFunctionTimestampWithTimezone) {
   const auto dateFunction =
       [&](std::optional<int64_t> timestamp,
           const std::optional<std::string>& timeZoneName) {
-        return evaluateWithTimestampWithTimezone<int32_t>(
+        auto r1 = evaluateWithTimestampWithTimezone<int32_t>(
             "date(c0)", timestamp, timeZoneName);
+        auto r2 = evaluateWithTimestampWithTimezone<int32_t>(
+            "cast(c0 as date)", timestamp, timeZoneName);
+        EXPECT_EQ(r1, r2);
+        return r1;
       };
 
   // 1970-01-01 00:00:00.000 +00:00
@@ -3405,6 +4157,19 @@ TEST_F(DateTimeFunctionsTest, castDateForDateFunction) {
       -18297,
       castDateTest(Timestamp(
           -18297 * kSecondsInDay + kSecondsInDay - 1, kNanosInSecond - 1)));
+
+  // Trying to convert a very large timestamp should fail as velox/external/date
+  // can't convert past year 2037. Note that the correct result here should be
+  // 376358 ('3000-06-08'), and not 376357 ('3000-06-07').
+  VELOX_ASSERT_THROW(
+      castDateTest(Timestamp(32517359891, 0)), "Unable to convert timezone");
+
+  // Ensure timezone conversion failures leak through try().
+  const auto tryTest = [&](std::optional<Timestamp> timestamp) {
+    return evaluateOnce<int32_t>("try(cast(c0 as date))", timestamp);
+  };
+  VELOX_ASSERT_RUNTIME_THROW(
+      tryTest(Timestamp(32517359891, 0)), "Unable to convert timezone");
 }
 
 TEST_F(DateTimeFunctionsTest, currentDateWithTimezone) {
@@ -3446,7 +4211,7 @@ TEST_F(DateTimeFunctionsTest, currentDateWithoutTimezone) {
 
 TEST_F(DateTimeFunctionsTest, timeZoneHour) {
   const auto timezone_hour = [&](const char* time, const char* timezone) {
-    Timestamp ts = util::fromTimestampString(time);
+    Timestamp ts = parseTimestamp(time);
     auto timestamp = ts.toMillis();
     auto hour = evaluateWithTimestampWithTimezone<int64_t>(
                     "timezone_hour(c0)", timestamp, timezone)
@@ -3457,15 +4222,24 @@ TEST_F(DateTimeFunctionsTest, timeZoneHour) {
   // Asia/Kolkata - should return 5 throughout the year
   EXPECT_EQ(5, timezone_hour("2023-01-01 03:20:00", "Asia/Kolkata"));
   EXPECT_EQ(5, timezone_hour("2023-06-01 03:20:00", "Asia/Kolkata"));
+
   // America/Los_Angeles - Day light savings is from March 12 to Nov 5
   EXPECT_EQ(-8, timezone_hour("2023-03-11 12:00:00", "America/Los_Angeles"));
   EXPECT_EQ(-8, timezone_hour("2023-03-12 02:30:00", "America/Los_Angeles"));
   EXPECT_EQ(-7, timezone_hour("2023-03-13 12:00:00", "America/Los_Angeles"));
   EXPECT_EQ(-7, timezone_hour("2023-11-05 01:30:00", "America/Los_Angeles"));
   EXPECT_EQ(-8, timezone_hour("2023-12-05 01:30:00", "America/Los_Angeles"));
+
   // Different time with same date
   EXPECT_EQ(-4, timezone_hour("2023-01-01 03:20:00", "Canada/Atlantic"));
   EXPECT_EQ(-4, timezone_hour("2023-01-01 10:00:00", "Canada/Atlantic"));
+
+  // By definition (+/-) 00:00 offsets should always return the hour part of the
+  // offset itself.
+  EXPECT_EQ(0, timezone_hour("2023-12-05 01:30:00", "+00:00"));
+  EXPECT_EQ(8, timezone_hour("2023-12-05 01:30:00", "+08:00"));
+  EXPECT_EQ(-10, timezone_hour("2023-12-05 01:30:00", "-10:00"));
+
   // Invalid inputs
   VELOX_ASSERT_THROW(
       timezone_hour("invalid_date", "Canada/Atlantic"),
@@ -3477,7 +4251,7 @@ TEST_F(DateTimeFunctionsTest, timeZoneHour) {
 
 TEST_F(DateTimeFunctionsTest, timeZoneMinute) {
   const auto timezone_minute = [&](const char* time, const char* timezone) {
-    Timestamp ts = util::fromTimestampString(time);
+    Timestamp ts = parseTimestamp(time);
     auto timestamp = ts.toMillis();
     auto minute = evaluateWithTimestampWithTimezone<int64_t>(
                       "timezone_minute(c0)", timestamp, timezone)
@@ -3491,6 +4265,13 @@ TEST_F(DateTimeFunctionsTest, timeZoneMinute) {
   EXPECT_EQ(0, timezone_minute("1970-01-01 03:20:00", "Canada/Atlantic"));
   EXPECT_EQ(30, timezone_minute("1970-01-01 03:20:00", "Asia/Katmandu"));
   EXPECT_EQ(45, timezone_minute("1970-01-01 03:20:00", "Pacific/Chatham"));
+
+  // By definition (+/-) 00:00 offsets should always return the minute part of
+  // the offset itself.
+  EXPECT_EQ(0, timezone_minute("2023-12-05 01:30:00", "+00:00"));
+  EXPECT_EQ(17, timezone_minute("2023-12-05 01:30:00", "+08:17"));
+  EXPECT_EQ(-59, timezone_minute("2023-12-05 01:30:00", "-10:59"));
+
   VELOX_ASSERT_THROW(
       timezone_minute("abc", "Pacific/Chatham"),
       "Unable to parse timestamp value: \"abc\", expected format is (YYYY-MM-DD HH:MM:SS[.MS])");
@@ -3500,114 +4281,129 @@ TEST_F(DateTimeFunctionsTest, timeZoneMinute) {
 }
 
 TEST_F(DateTimeFunctionsTest, timestampWithTimezoneComparisons) {
-  auto runAndCompare = [&](std::string expr,
-                           std::shared_ptr<RowVector>& inputs,
-                           VectorPtr expectedResult) {
-    auto actual = evaluate<SimpleVector<bool>>(expr, inputs);
+  auto runAndCompare = [&](const std::string& expr,
+                           const RowVectorPtr& inputs,
+                           const VectorPtr& expectedResult) {
+    auto actual = evaluate(expr, inputs);
     test::assertEqualVectors(expectedResult, actual);
   };
 
-  RowVectorPtr timestampWithTimezoneLhs = makeTimestampWithTimeZoneVector(
-      makeFlatVector<int64_t>({0, 0, 0}),
-      makeFlatVector<int16_t>({900, 900, 800}));
-  RowVectorPtr timestampWithTimezoneRhs = makeTimestampWithTimeZoneVector(
-      makeFlatVector<int64_t>({0, 1000, 0}),
-      makeFlatVector<int16_t>({900, 900, 900}));
+  /// Timestamp with timezone is internally represented with the milliseconds
+  /// already converted to UTC and thus normalized. The timezone does not play
+  /// a role in the comparison.
+  /// For example, 1970-01-01-06:00:00+02:00 is stored as
+  /// TIMESTAMP WITH TIMEZONE value (14400000, 960). 960 being the tzid
+  /// representing +02:00. And 1970-01-01-04:00:00+00:00 is stored as (14400000,
+  /// 0). These timestamps are equivalent.
+  auto timestampsLhs = std::vector<int64_t>{0, 0, 1000};
+  auto timezonesLhs = std::vector<TimeZoneKey>{900, 900, 800};
+  VectorPtr timestampWithTimezoneLhs = makeTimestampWithTimeZoneVector(
+      timestampsLhs.size(),
+      [&](auto row) { return timestampsLhs[row]; },
+      [&](auto row) { return timezonesLhs[row]; });
+
+  auto timestampsRhs = std::vector<int64_t>{0, 1000, 0};
+  auto timezonesRhs = std::vector<TimeZoneKey>{900, 900, 800};
+  VectorPtr timestampWithTimezoneRhs = makeTimestampWithTimeZoneVector(
+      timestampsRhs.size(),
+      [&](auto row) { return timestampsRhs[row]; },
+      [&](auto row) { return timezonesRhs[row]; });
   auto inputs =
       makeRowVector({timestampWithTimezoneLhs, timestampWithTimezoneRhs});
 
-  auto expectedEq = makeNullableFlatVector<bool>({true, false, false});
+  auto expectedEq = makeFlatVector<bool>({true, false, false});
   runAndCompare("c0 = c1", inputs, expectedEq);
 
-  auto expectedNeq = makeNullableFlatVector<bool>({false, true, true});
+  auto expectedNeq = makeFlatVector<bool>({false, true, true});
   runAndCompare("c0 != c1", inputs, expectedNeq);
 
-  auto expectedLt = makeNullableFlatVector<bool>({false, true, false});
+  auto expectedLt = makeFlatVector<bool>({false, true, false});
   runAndCompare("c0 < c1", inputs, expectedLt);
 
-  auto expectedGt = makeNullableFlatVector<bool>({false, false, true});
+  auto expectedGt = makeFlatVector<bool>({false, false, true});
   runAndCompare("c0 > c1", inputs, expectedGt);
 
-  auto expectedLte = makeNullableFlatVector<bool>({true, true, false});
+  auto expectedLte = makeFlatVector<bool>({true, true, false});
   runAndCompare("c0 <= c1", inputs, expectedLte);
 
-  auto expectedGte = makeNullableFlatVector<bool>({true, false, true});
+  auto expectedGte = makeFlatVector<bool>({true, false, true});
   runAndCompare("c0 >= c1", inputs, expectedGte);
+
+  auto expectedBetween = makeNullableFlatVector<bool>({true, true, false});
+  runAndCompare("c0 between c0 and c1", inputs, expectedBetween);
 }
 
 TEST_F(DateTimeFunctionsTest, castDateToTimestamp) {
   const int64_t kSecondsInDay = kMillisInDay / 1'000;
   const auto castDateToTimestamp = [&](const std::optional<int32_t> date) {
-    return evaluateOnce<Timestamp, int32_t>(
-        "cast(c0 AS timestamp)", {date}, {DATE()});
+    return evaluateOnce<Timestamp>("cast(c0 AS timestamp)", DATE(), date);
   };
 
-  EXPECT_EQ(Timestamp(0, 0), castDateToTimestamp(DATE()->toDays("1970-01-01")));
+  EXPECT_EQ(Timestamp(0, 0), castDateToTimestamp(parseDate("1970-01-01")));
   EXPECT_EQ(
       Timestamp(kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("1970-01-02")));
+      castDateToTimestamp(parseDate("1970-01-02")));
   EXPECT_EQ(
       Timestamp(2 * kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("1970-01-03")));
+      castDateToTimestamp(parseDate("1970-01-03")));
   EXPECT_EQ(
       Timestamp(18297 * kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("2020-02-05")));
+      castDateToTimestamp(parseDate("2020-02-05")));
   EXPECT_EQ(
       Timestamp(-1 * kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("1969-12-31")));
+      castDateToTimestamp(parseDate("1969-12-31")));
   EXPECT_EQ(
       Timestamp(-18297 * kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("1919-11-28")));
+      castDateToTimestamp(parseDate("1919-11-28")));
 
   const auto tz = "America/Los_Angeles";
   const auto kTimezoneOffset = 8 * kMillisInHour / 1'000;
   setQueryTimeZone(tz);
   EXPECT_EQ(
       Timestamp(kTimezoneOffset, 0),
-      castDateToTimestamp(DATE()->toDays("1970-01-01")));
+      castDateToTimestamp(parseDate("1970-01-01")));
   EXPECT_EQ(
       Timestamp(kSecondsInDay + kTimezoneOffset, 0),
-      castDateToTimestamp(DATE()->toDays("1970-01-02")));
+      castDateToTimestamp(parseDate("1970-01-02")));
   EXPECT_EQ(
       Timestamp(2 * kSecondsInDay + kTimezoneOffset, 0),
-      castDateToTimestamp(DATE()->toDays("1970-01-03")));
+      castDateToTimestamp(parseDate("1970-01-03")));
   EXPECT_EQ(
       Timestamp(18297 * kSecondsInDay + kTimezoneOffset, 0),
-      castDateToTimestamp(DATE()->toDays("2020-02-05")));
+      castDateToTimestamp(parseDate("2020-02-05")));
   EXPECT_EQ(
       Timestamp(-1 * kSecondsInDay + kTimezoneOffset, 0),
-      castDateToTimestamp(DATE()->toDays("1969-12-31")));
+      castDateToTimestamp(parseDate("1969-12-31")));
   EXPECT_EQ(
       Timestamp(-18297 * kSecondsInDay + kTimezoneOffset, 0),
-      castDateToTimestamp(DATE()->toDays("1919-11-28")));
+      castDateToTimestamp(parseDate("1919-11-28")));
 
   disableAdjustTimestampToTimezone();
-  EXPECT_EQ(Timestamp(0, 0), castDateToTimestamp(DATE()->toDays("1970-01-01")));
+  EXPECT_EQ(Timestamp(0, 0), castDateToTimestamp(parseDate("1970-01-01")));
   EXPECT_EQ(
       Timestamp(kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("1970-01-02")));
+      castDateToTimestamp(parseDate("1970-01-02")));
   EXPECT_EQ(
       Timestamp(2 * kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("1970-01-03")));
+      castDateToTimestamp(parseDate("1970-01-03")));
   EXPECT_EQ(
       Timestamp(18297 * kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("2020-02-05")));
+      castDateToTimestamp(parseDate("2020-02-05")));
   EXPECT_EQ(
       Timestamp(-1 * kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("1969-12-31")));
+      castDateToTimestamp(parseDate("1969-12-31")));
   EXPECT_EQ(
       Timestamp(-18297 * kSecondsInDay, 0),
-      castDateToTimestamp(DATE()->toDays("1919-11-28")));
+      castDateToTimestamp(parseDate("1919-11-28")));
 }
 
 TEST_F(DateTimeFunctionsTest, lastDayOfMonthDate) {
   const auto lastDayFunc = [&](const std::optional<int32_t> date) {
-    return evaluateOnce<int32_t, int32_t>(
-        "last_day_of_month(c0)", {date}, {DATE()});
+    return evaluateOnce<int32_t>("last_day_of_month(c0)", DATE(), date);
   };
 
   const auto lastDay = [&](const StringView& dateStr) {
-    return lastDayFunc(DATE()->toDays(dateStr));
+    return lastDayFunc(parseDate(dateStr));
   };
 
   EXPECT_EQ(std::nullopt, lastDayFunc(std::nullopt));
@@ -3635,7 +4431,7 @@ TEST_F(DateTimeFunctionsTest, lastDayOfMonthTimestamp) {
   };
 
   const auto lastDay = [&](const StringView& dateStr) {
-    return lastDayFunc(util::fromTimestampString(dateStr));
+    return lastDayFunc(parseTimestamp(dateStr));
   };
 
   setQueryTimeZone("Pacific/Apia");
@@ -3650,20 +4446,187 @@ TEST_F(DateTimeFunctionsTest, lastDayOfMonthTimestamp) {
 }
 
 TEST_F(DateTimeFunctionsTest, lastDayOfMonthTimestampWithTimezone) {
+  const auto lastDayOfMonthTimestampWithTimezone =
+      [&](std::optional<TimestampWithTimezone> timestampWithTimezone) {
+        return evaluateOnce<int32_t>(
+            "last_day_of_month(c0)",
+            TIMESTAMP_WITH_TIME_ZONE(),
+            TimestampWithTimezone::pack(timestampWithTimezone));
+      };
   EXPECT_EQ(
       parseDate("1970-01-31"),
-      evaluateWithTimestampWithTimezone<int32_t>(
-          "last_day_of_month(c0)", 0, "+00:00"));
+      lastDayOfMonthTimestampWithTimezone(TimestampWithTimezone(0, "+00:00")));
   EXPECT_EQ(
       parseDate("1969-12-31"),
-      evaluateWithTimestampWithTimezone<int32_t>(
-          "last_day_of_month(c0)", 0, "-02:00"));
+      lastDayOfMonthTimestampWithTimezone(TimestampWithTimezone(0, "-02:00")));
   EXPECT_EQ(
       parseDate("2008-02-29"),
-      evaluateWithTimestampWithTimezone<int32_t>(
-          "last_day_of_month(c0)", 1201881600000, "+02:00"));
+      lastDayOfMonthTimestampWithTimezone(
+          TimestampWithTimezone(1201881600000, "+02:00")));
   EXPECT_EQ(
       parseDate("2008-01-31"),
-      evaluateWithTimestampWithTimezone<int32_t>(
-          "last_day_of_month(c0)", 1201795200000, "-02:00"));
+      lastDayOfMonthTimestampWithTimezone(
+          TimestampWithTimezone(1201795200000, "-02:00")));
+}
+
+TEST_F(DateTimeFunctionsTest, fromUnixtimeDouble) {
+  auto input = makeFlatVector<double>({
+      1623748302.,
+      1623748302.0,
+      1623748302.02,
+      1623748302.023,
+      1623748303.123,
+      1623748304.009,
+      1623748304.001,
+      1623748304.999,
+      1623748304.001290,
+      1623748304.001890,
+      1623748304.999390,
+      1623748304.999590,
+  });
+  auto actual =
+      evaluate("cast(from_unixtime(c0) as varchar)", makeRowVector({input}));
+  auto expected = makeFlatVector<StringView>({
+      "2021-06-15 09:11:42.000",
+      "2021-06-15 09:11:42.000",
+      "2021-06-15 09:11:42.020",
+      "2021-06-15 09:11:42.023",
+      "2021-06-15 09:11:43.123",
+      "2021-06-15 09:11:44.009",
+      "2021-06-15 09:11:44.001",
+      "2021-06-15 09:11:44.999",
+      "2021-06-15 09:11:44.001",
+      "2021-06-15 09:11:44.002",
+      "2021-06-15 09:11:44.999",
+      "2021-06-15 09:11:45.000",
+  });
+  assertEqualVectors(expected, actual);
+}
+
+TEST_F(DateTimeFunctionsTest, toISO8601Date) {
+  const auto toISO8601 = [&](const char* dateString) {
+    return evaluateOnce<std::string>(
+        "to_iso8601(c0)", DATE(), std::make_optional(parseDate(dateString)));
+  };
+
+  EXPECT_EQ("1970-01-01", toISO8601("1970-01-01"));
+  EXPECT_EQ("2020-02-05", toISO8601("2020-02-05"));
+  EXPECT_EQ("1919-11-28", toISO8601("1919-11-28"));
+  EXPECT_EQ("4653-07-01", toISO8601("4653-07-01"));
+  EXPECT_EQ("1844-10-14", toISO8601("1844-10-14"));
+  EXPECT_EQ("0001-01-01", toISO8601("1-01-01"));
+  EXPECT_EQ("9999-12-31", toISO8601("9999-12-31"));
+  EXPECT_EQ("872343-04-19", toISO8601("872343-04-19"));
+  EXPECT_EQ("-3492-10-05", toISO8601("-3492-10-05"));
+  EXPECT_EQ("-0653-07-12", toISO8601("-653-07-12"));
+}
+
+TEST_F(DateTimeFunctionsTest, toISO8601Timestamp) {
+  const auto toIso = [&](const char* timestamp) {
+    return evaluateOnce<std::string>(
+        "to_iso8601(c0)", std::make_optional(parseTimestamp(timestamp)));
+  };
+  disableAdjustTimestampToTimezone();
+  EXPECT_EQ("2024-11-01T10:00:00.000+00:00", toIso("2024-11-01 10:00"));
+  EXPECT_EQ("2024-11-04T10:00:00.000+00:00", toIso("2024-11-04 10:00"));
+  EXPECT_EQ("2024-11-04T15:05:34.100+00:00", toIso("2024-11-04 15:05:34.1"));
+  EXPECT_EQ("2024-11-04T15:05:34.123+00:00", toIso("2024-11-04 15:05:34.123"));
+  EXPECT_EQ("0022-11-01T10:00:00.000+00:00", toIso("22-11-01 10:00"));
+
+  setQueryTimeZone("America/Los_Angeles");
+  EXPECT_EQ("2024-11-01T03:00:00.000-07:00", toIso("2024-11-01 10:00"));
+
+  setQueryTimeZone("America/New_York");
+  EXPECT_EQ("2024-11-01T06:00:00.000-04:00", toIso("2024-11-01 10:00"));
+  EXPECT_EQ("2024-11-04T05:00:00.000-05:00", toIso("2024-11-04 10:00"));
+  EXPECT_EQ("2024-11-04T10:05:34.100-05:00", toIso("2024-11-04 15:05:34.1"));
+  EXPECT_EQ("2024-11-04T10:05:34.123-05:00", toIso("2024-11-04 15:05:34.123"));
+  EXPECT_EQ("0022-11-01T05:03:58.000-04:56:02", toIso("22-11-01 10:00"));
+
+  setQueryTimeZone("Asia/Kathmandu");
+  EXPECT_EQ("2024-11-01T15:45:00.000+05:45", toIso("2024-11-01 10:00"));
+  EXPECT_EQ("0022-11-01T15:41:16.000+05:41:16", toIso("22-11-01 10:00"));
+  EXPECT_EQ("0022-11-01T15:41:16.000+05:41:16", toIso("22-11-01 10:00"));
+}
+
+TEST_F(DateTimeFunctionsTest, toISO8601TimestampWithTimezone) {
+  const auto toIso = [&](const char* timestamp, const char* timezone) {
+    const auto* timeZone = tz::locateZone(timezone);
+    auto ts = parseTimestamp(timestamp);
+    ts.toGMT(*timeZone);
+
+    return evaluateOnce<std::string>(
+        "to_iso8601(c0)",
+        TIMESTAMP_WITH_TIME_ZONE(),
+        std::make_optional(pack(ts.toMillis(), timeZone->id())));
+  };
+
+  EXPECT_EQ(
+      "2024-11-01T10:00:00.000-04:00",
+      toIso("2024-11-01 10:00", "America/New_York"));
+  EXPECT_EQ(
+      "2024-11-04T10:00:45.120-05:00",
+      toIso("2024-11-04 10:00:45.12", "America/New_York"));
+  EXPECT_EQ(
+      "0022-11-01T10:00:00.000-04:56:02",
+      toIso("22-11-01 10:00", "America/New_York"));
+
+  EXPECT_EQ(
+      "2024-11-01T10:00:00.000+05:45",
+      toIso("2024-11-01 10:00", "Asia/Kathmandu"));
+  EXPECT_EQ(
+      "0022-11-01T10:00:00.000+05:41:16",
+      toIso("22-11-01 10:00", "Asia/Kathmandu"));
+}
+
+TEST_F(DateTimeFunctionsTest, atTimezoneTest) {
+  const auto at_timezone = [&](std::optional<int64_t> timestampWithTimezone,
+                               std::optional<std::string> targetTimezone) {
+    return evaluateOnce<int64_t>(
+        "at_timezone(c0, c1)",
+        {TIMESTAMP_WITH_TIME_ZONE(), VARCHAR()},
+        timestampWithTimezone,
+        targetTimezone);
+  };
+
+  EXPECT_EQ(
+      at_timezone(
+          pack(1500101514, tz::getTimeZoneID("Asia/Kathmandu")),
+          "America/Boise"),
+      pack(1500101514, tz::getTimeZoneID("America/Boise")));
+
+  EXPECT_EQ(
+      at_timezone(
+          pack(1500101514, tz::getTimeZoneID("America/Boise")),
+          "Europe/London"),
+      pack(1500101514, tz::getTimeZoneID("Europe/London")));
+
+  EXPECT_EQ(
+      at_timezone(
+          pack(1500321297, tz::getTimeZoneID("Canada/Yukon")),
+          "Australia/Melbourne"),
+      pack(1500321297, tz::getTimeZoneID("Australia/Melbourne")));
+
+  EXPECT_EQ(
+      at_timezone(
+          pack(1500321297, tz::getTimeZoneID("Atlantic/Bermuda")),
+          "Pacific/Fiji"),
+      pack(1500321297, tz::getTimeZoneID("Pacific/Fiji")));
+
+  EXPECT_EQ(
+      at_timezone(
+          pack(1500321297, tz::getTimeZoneID("Atlantic/Bermuda")),
+          std::nullopt),
+      std::nullopt);
+
+  EXPECT_EQ(at_timezone(std::nullopt, "Pacific/Fiji"), std::nullopt);
+}
+
+TEST_F(DateTimeFunctionsTest, toMilliseconds) {
+  EXPECT_EQ(
+      123,
+      evaluateOnce<int64_t>(
+          "to_milliseconds(c0)",
+          INTERVAL_DAY_TIME(),
+          std::optional<int64_t>(123)));
 }
diff --git a/velox/functions/prestosql/tests/DecimalArithmeticTest.cpp b/velox/functions/prestosql/tests/DecimalArithmeticTest.cpp
index c361037215b93..70377a72d6d4c 100644
--- a/velox/functions/prestosql/tests/DecimalArithmeticTest.cpp
+++ b/velox/functions/prestosql/tests/DecimalArithmeticTest.cpp
@@ -116,7 +116,7 @@ TEST_F(DecimalArithmeticTest, add) {
            {1, 2, 5, std::nullopt, std::nullopt}, DECIMAL(10, 3))});
 
   // Addition overflow.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "c0 + cast(1.00 as decimal(2,0))",
@@ -126,7 +126,7 @@ TEST_F(DecimalArithmeticTest, add) {
       "Decimal overflow. Value '100000000000000000000000000000000000000' is not in the range of Decimal Type");
 
   // Rescaling LHS overflows.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "c0 + 0.01",
@@ -135,7 +135,7 @@ TEST_F(DecimalArithmeticTest, add) {
               DECIMAL(38, 0))}),
       "Decimal overflow: 99999999999999999999999999999999999999 + 1");
   // Rescaling RHS overflows.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "0.01 + c0",
@@ -202,7 +202,7 @@ TEST_F(DecimalArithmeticTest, subtract) {
            {1, 2, 5, std::nullopt, std::nullopt}, DECIMAL(10, 3))});
 
   // Subtraction overflow.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "c0 - cast(1.00 as decimal(2,0))",
@@ -211,7 +211,7 @@ TEST_F(DecimalArithmeticTest, subtract) {
               DECIMAL(38, 0))}),
       "Decimal overflow. Value '-100000000000000000000000000000000000000' is not in the range of Decimal Type");
   // Rescaling LHS overflows.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "c0 - 0.01",
@@ -220,7 +220,7 @@ TEST_F(DecimalArithmeticTest, subtract) {
               DECIMAL(38, 0))}),
       "Decimal overflow: -99999999999999999999999999999999999999 - 1");
   // Rescaling RHS overflows.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "0.01 - c0",
@@ -271,7 +271,7 @@ TEST_F(DecimalArithmeticTest, multiply) {
       expectedConstantFlat, "c0 * 1.00", {shortFlat});
 
   // Long decimal limits
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "c0 * cast(10.00 as decimal(2,0))",
@@ -282,7 +282,7 @@ TEST_F(DecimalArithmeticTest, multiply) {
       "Decimal overflow. Value '119630519620642428561342635425231011830' is not in the range of Decimal Type");
 
   // Rescaling the final result overflows.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "c0 * cast(1.00 as decimal(2,1))",
@@ -291,6 +291,14 @@ TEST_F(DecimalArithmeticTest, multiply) {
                   HugeInt::build(0x08FFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF)},
               DECIMAL(38, 0))}),
       "Decimal overflow. Value '119630519620642428561342635425231011830' is not in the range of Decimal Type");
+
+  // The sum of input scales exceeds 38.
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "c0 * c0",
+          makeRowVector(
+              {makeFlatVector<int128_t>({1000, 2000}, DECIMAL(38, 30))})),
+      "");
 }
 
 TEST_F(DecimalArithmeticTest, decimalDivTest) {
@@ -314,6 +322,18 @@ TEST_F(DecimalArithmeticTest, decimalDivTest) {
       "divide(c0, c1)",
       {shortFlat, longFlat});
 
+  testDecimalExpr<TypeKind::HUGEINT>(
+      makeFlatVector<int128_t>(
+          {HugeInt::parse("20000000000000000"),
+           HugeInt::parse("50000000000000000")},
+          DECIMAL(38, 19)),
+      "divide(c0, c1)",
+      {makeFlatVector<int64_t>({100, 200}, DECIMAL(17, 4)),
+       makeFlatVector<int128_t>(
+           {HugeInt::parse("50000000000000000000"),
+            HugeInt::parse("40000000000000000000")},
+           DECIMAL(21, 19))});
+
   // Divide long and long, returning long.
   testDecimalExpr<TypeKind::HUGEINT>(
       makeFlatVector<int128_t>({500, 300}, DECIMAL(22, 2)),
@@ -345,12 +365,12 @@ TEST_F(DecimalArithmeticTest, decimalDivTest) {
       {makeFlatVector<int64_t>({-34, 5, 65, 90, 2, -49}, DECIMAL(2, 1))});
 
   // Divide by zero.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::BIGINT>({}, "c0 / 0.0", {shortFlat}),
       "Division by zero");
 
   // Long decimal limits.
-  VELOX_ASSERT_THROW(
+  VELOX_ASSERT_USER_THROW(
       testDecimalExpr<TypeKind::HUGEINT>(
           {},
           "c0 / 0.01",
@@ -358,6 +378,15 @@ TEST_F(DecimalArithmeticTest, decimalDivTest) {
               std::vector<int128_t>{DecimalUtil::kLongDecimalMax},
               DECIMAL(38, 0))}),
       "Decimal overflow: 99999999999999999999999999999999999999 * 10000");
+
+  // Rescale factor > max precision (38).
+  VELOX_ASSERT_USER_THROW(
+      evaluate(
+          "divide(c0, c1)",
+          makeRowVector(
+              {makeFlatVector<int128_t>({5000, 20000}, DECIMAL(20, 1)),
+               makeFlatVector<int128_t>({5000, 20000}, DECIMAL(33, 32))})),
+      "Decimal overflow");
 }
 
 TEST_F(DecimalArithmeticTest, decimalDivDifferentTypes) {
@@ -374,6 +403,72 @@ TEST_F(DecimalArithmeticTest, decimalDivDifferentTypes) {
        makeFlatVector<int64_t>({100, 200, -300, 400}, DECIMAL(12, 2))});
 }
 
+TEST_F(DecimalArithmeticTest, decimalMod) {
+  // short % short -> short.
+  testDecimalExpr<TypeKind::BIGINT>(
+      makeFlatVector<int64_t>({0, 0}, DECIMAL(2, 1)),
+      "mod(c0, c1)",
+      {makeFlatVector<int64_t>({0, 50}, DECIMAL(2, 1)),
+       makeFlatVector<int64_t>({20, 25}, DECIMAL(2, 1))});
+  testDecimalExpr<TypeKind::BIGINT>(
+      makeFlatVector<int64_t>({3, -3, 3, -3}, DECIMAL(2, 1)),
+      "mod(c0, c1)",
+      {makeFlatVector<int64_t>({13, -13, 13, -13}, DECIMAL(3, 1)),
+       makeFlatVector<int64_t>({5, 5, -5, -5}, DECIMAL(2, 1))});
+  testDecimalExpr<TypeKind::BIGINT>(
+      makeFlatVector<int64_t>({90, -245, 245, -90}, DECIMAL(3, 2)),
+      "mod(c0, c1)",
+      {makeFlatVector<int64_t>({50, -50, 50, -50}, DECIMAL(2, 1)),
+       makeFlatVector<int64_t>({205, 255, -255, -205}, DECIMAL(3, 2))});
+  testDecimalExpr<TypeKind::BIGINT>(
+      makeFlatVector<int64_t>({2500, -12000}, DECIMAL(5, 3)),
+      "mod(c0, c1)",
+      {makeFlatVector<int64_t>({2500, -12000}, DECIMAL(5, 3)),
+       makeFlatVector<int64_t>({600, 5000}, DECIMAL(5, 2))});
+
+  // short % long -> short.
+  testDecimalExpr<TypeKind::BIGINT>(
+      makeFlatVector<int64_t>({1000, -600, 1000, -600}, DECIMAL(17, 15)),
+      "mod(c0, c1)",
+      {makeFlatVector<int64_t>({1000, -600, 1000, -600}, DECIMAL(17, 15)),
+       makeFlatVector<int128_t>({13, 17, -13, -17}, DECIMAL(20, 10))});
+
+  // long % short -> short.
+  testDecimalExpr<TypeKind::BIGINT>(
+      makeFlatVector<int64_t>({8, -11, 8, -11}, DECIMAL(17, 15)),
+      "mod(c0, c1)",
+      {makeFlatVector<int128_t>({500, -4000, 500, -4000}, DECIMAL(20, 10)),
+       makeFlatVector<int64_t>({17, 19, -17, -19}, DECIMAL(17, 15))});
+
+  // short % long -> long.
+  testDecimalExpr<TypeKind::HUGEINT>(
+      makeFlatVector<int128_t>({0, -16, 0, -16}, DECIMAL(25, 10)),
+      "mod(c0, c1)",
+      {makeFlatVector<int64_t>({1000, -600, 1000, -600}, DECIMAL(17, 2)),
+       makeFlatVector<int128_t>({400, 38, -400, -38}, DECIMAL(30, 10))});
+
+  // long % short -> long.
+  testDecimalExpr<TypeKind::HUGEINT>(
+      makeFlatVector<int128_t>({500, -4000, 500, -4000}, DECIMAL(25, 10)),
+      "mod(c0, c1)",
+      {makeFlatVector<int128_t>({500, -4000, 500, -4000}, DECIMAL(30, 10)),
+       makeFlatVector<int64_t>({1000, 2000, -1000, -2000}, DECIMAL(17, 2))});
+
+  // long % long -> long.
+  testDecimalExpr<TypeKind::HUGEINT>(
+      makeFlatVector<int128_t>({2500, -12000, 2500, -12000}, DECIMAL(23, 5)),
+      "mod(c0, c1)",
+      {makeFlatVector<int128_t>({2500, -12000, 2500, -12000}, DECIMAL(25, 5)),
+       makeFlatVector<int128_t>({500, 4000, -500, -4000}, DECIMAL(20, 2))});
+
+  VELOX_ASSERT_USER_THROW(
+      testDecimalExpr<TypeKind::BIGINT>(
+          {},
+          "c0 % 0.0",
+          {makeFlatVector<int64_t>({1000, 2000}, DECIMAL(17, 3))}),
+      "Modulus by zero");
+}
+
 TEST_F(DecimalArithmeticTest, round) {
   // Round short decimals.
   testDecimalExpr<TypeKind::BIGINT>(
@@ -470,6 +565,179 @@ TEST_F(DecimalArithmeticTest, roundN) {
           DECIMAL(19, 5))});
 }
 
+TEST_F(DecimalArithmeticTest, floor) {
+  // short DECIMAL -> short DECIMAL.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({0, 0, -1, 0, -1, 0, -1, 0, -1}, DECIMAL(2, 0))},
+      "floor(c0)",
+      {makeFlatVector<int64_t>(
+          {0, 1, -1, 49, -49, 50, -50, 99, -99}, DECIMAL(3, 2))});
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>(
+          {123, -123, 123, -124, 123, -124, 123, -124, 123, -124, 123, -124},
+          DECIMAL(4, 0))},
+      "floor(c0)",
+      {makeFlatVector<int64_t>(
+          {12300,
+           -12300,
+           12301,
+           -12301,
+           12345,
+           -12345,
+           12349,
+           -12349,
+           12350,
+           -12350,
+           12399,
+           -12399},
+          DECIMAL(5, 2))});
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>(
+          {DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMin},
+          DECIMAL(18, 0))},
+      "floor(c0)",
+      {makeFlatVector<int64_t>(
+          {DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMin},
+          DECIMAL(18, 0))});
+
+  // long DECIMAL -> long DECIMAL.
+  testDecimalExpr<TypeKind::HUGEINT>(
+      {makeFlatVector<int128_t>(
+          {0, 0, -1, 0, -1, 0, -1, 0, -1}, DECIMAL(19, 0))},
+      "floor(c0)",
+      {makeFlatVector<int128_t>(
+          {0, 1, -1, 49, -49, 50, -50, 99, -99}, DECIMAL(20, 2))});
+  testDecimalExpr<TypeKind::HUGEINT>(
+      {makeFlatVector<int128_t>(
+          {DecimalUtil::kPowersOfTen[33] - 1, -DecimalUtil::kPowersOfTen[33]},
+          DECIMAL(34, 0))},
+      "floor(c0)",
+      {makeFlatVector<int128_t>(
+          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
+          DECIMAL(38, 5))});
+  testDecimalExpr<TypeKind::HUGEINT>(
+      {makeFlatVector<int128_t>(
+          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
+          DECIMAL(38, 0))},
+      "floor(c0)",
+      {makeFlatVector<int128_t>(
+          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
+          DECIMAL(38, 0))});
+
+  // long DECIMAL -> short DECIMAL.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({0, 0, -1, -1, 0}, DECIMAL(1, 0))},
+      "floor(c0)",
+      {makeFlatVector<int128_t>(
+          {1234567890123456789,
+           5000000000000000000,
+           -9000000000000000000,
+           -1000000000000000000,
+           0},
+          DECIMAL(19, 19))});
+}
+
+TEST_F(DecimalArithmeticTest, truncate) {
+  // Truncate short decimals.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({0, 0, 0, 0}, DECIMAL(1, 0))},
+      "truncate(c0)",
+      {makeFlatVector<int64_t>({123, 542, -999, 0}, DECIMAL(3, 3))});
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({1111, 1111, -9998, 9999}, DECIMAL(4, 0))},
+      "truncate(c0)",
+      {makeFlatVector<int64_t>({11112, 11115, -99989, 99999}, DECIMAL(5, 1))});
+
+  // Truncate long decimals.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({0, 0, 0, 0}, DECIMAL(1, 0))},
+      "truncate(c0)",
+      {makeFlatVector<int128_t>(
+          {1234567890123456789, 5000000000000000000, -9000000000000000000, 0},
+          DECIMAL(19, 19))});
+  testDecimalExpr<TypeKind::HUGEINT>(
+      {makeFlatVector<int128_t>(
+          {DecimalUtil::kPowersOfTen[37] - 1,
+           -DecimalUtil::kPowersOfTen[37] + 1},
+          DECIMAL(37, 0))},
+      "truncate(c0)",
+      {makeFlatVector<int128_t>(
+          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
+          DECIMAL(38, 1))});
+
+  // Min and max short decimals.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>(
+          {DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMin},
+          DECIMAL(15, 0))},
+      "truncate(c0)",
+      {makeFlatVector<int64_t>(
+          {DecimalUtil::kShortDecimalMax, DecimalUtil::kShortDecimalMin},
+          DECIMAL(15, 0))});
+
+  // Min and max long decimals.
+  testDecimalExpr<TypeKind::HUGEINT>(
+      {makeFlatVector<int128_t>(
+          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
+          DECIMAL(38, 0))},
+      "truncate(c0)",
+      {makeFlatVector<int128_t>(
+          {DecimalUtil::kLongDecimalMax, DecimalUtil::kLongDecimalMin},
+          DECIMAL(38, 0))});
+}
+
+TEST_F(DecimalArithmeticTest, truncateN) {
+  // Truncate to 'scale' decimal places.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 3))},
+      "truncate(c0, 3::integer)",
+      {makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 3))});
+
+  // Truncate to 'scale' - 1 decimal places.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({120, 550, -990, 0}, DECIMAL(3, 3))},
+      "truncate(c0, 2::integer)",
+      {makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 3))});
+
+  // Truncate to 0 decimal places.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({100, 500, -900, 0}, DECIMAL(3, 2))},
+      "truncate(c0, 0::integer)",
+      {makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 2))});
+
+  // Truncate to -1 decimal places.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({100, 500, -900, 0}, DECIMAL(3, 1))},
+      "truncate(c0, '-1'::integer)",
+      {makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 1))});
+
+  // Truncate to -2 decimal places.
+  testDecimalExpr<TypeKind::BIGINT>(
+      {makeFlatVector<int64_t>({0, 0, 0, 0}, DECIMAL(3, 1))},
+      "truncate(c0, '-2'::integer)",
+      {makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 1))});
+
+  // Truncate long decimals to 'scale' - 5 decimal places.
+  testDecimalExpr<TypeKind::HUGEINT>(
+      {makeFlatVector<int128_t>(
+          {1234567890123400000, 5000000000000000000, -999999999999900000, 0},
+          DECIMAL(19, 19))},
+      "truncate(c0, 14::integer)",
+      {makeFlatVector<int128_t>(
+          {1234567890123456789, 5000000000000000000, -999999999999999999, 0},
+          DECIMAL(19, 19))});
+
+  // Truncate long decimals to -9 decimal places.
+  testDecimalExpr<TypeKind::HUGEINT>(
+      {makeFlatVector<int128_t>(
+          {1234500000000000000, 5555500000000000000, -999900000000000000, 0},
+          DECIMAL(19, 5))},
+      "truncate(c0, '-9'::integer)",
+      {makeFlatVector<int128_t>(
+          {1234567890123456789, 5555555555555555555, -999999999999999999, 0},
+          DECIMAL(19, 5))});
+}
+
 TEST_F(DecimalArithmeticTest, abs) {
   testDecimalExpr<TypeKind::BIGINT>(
       {makeFlatVector<int64_t>({1111, 1112, 9999, 0}, DECIMAL(5, 1))},
diff --git a/velox/functions/prestosql/tests/ElementAtTest.cpp b/velox/functions/prestosql/tests/ElementAtTest.cpp
index 478d242fec641..1a7a6b8d003d2 100644
--- a/velox/functions/prestosql/tests/ElementAtTest.cpp
+++ b/velox/functions/prestosql/tests/ElementAtTest.cpp
@@ -15,10 +15,13 @@
  */
 
 #include <optional>
+
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/Expr.h"
 #include "velox/functions/lib/SubscriptUtil.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/SelectivityVector.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::functions::test;
@@ -80,17 +83,104 @@ class ElementAtTest : public FunctionBaseTest {
 
   // Create a simple vector containing a single map ([10=>10, 11=>11, 12=>12]).
   MapVectorPtr getSimpleMapVector() {
-    auto keyAt = [](auto idx) { return idx + 10; };
-    auto sizeAt = [](auto) { return 3; };
-    auto mapValueAt = [](auto idx) { return idx + 10; };
-    return makeMapVector<int64_t, int64_t>(1, sizeAt, keyAt, mapValueAt);
+    return makeMapVectorFromJson<int64_t, int64_t>({
+        "{10: 10, 11: 11, 12: 12}",
+    });
+  }
+
+  template <typename T>
+  void testFloatingPointCornerCases() {
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+
+    auto values = makeFlatVector<int32_t>({1, 2, 3, 4, 5});
+    auto expected = makeConstant<int32_t>(3, 1);
+
+    auto elementAt = [&](auto map, auto search) {
+      return evaluate("element_at(C0, C1)", makeRowVector({map, search}));
+    };
+
+    // Case 1: Verify NaNs identified even with different binary
+    // representations.
+    auto keysIdenticalNaNs = makeFlatVector<T>({1, 2, kNaN, 4, 5});
+    auto mapVector = makeMapVector({0}, keysIdenticalNaNs, values);
+    test::assertEqualVectors(
+        expected, elementAt(mapVector, makeConstant<T>(kNaN, 1)));
+    test::assertEqualVectors(
+        expected, elementAt(mapVector, makeConstant<T>(kSNaN, 1)));
+
+    // Case 2: Verify for equality of +0.0 and -0.0.
+    auto keysDifferentZeros = makeFlatVector<T>({1, 2, -0.0, 4, 5});
+    mapVector = makeMapVector({0}, keysDifferentZeros, values);
+    test::assertEqualVectors(
+        expected, elementAt(mapVector, makeConstant<T>(0.0, 1)));
+    test::assertEqualVectors(
+        expected, elementAt(mapVector, makeConstant<T>(-0.0, 1)));
+
+    // Case 3: Verify NaNs are identified when nested inside complex type keys
+    {
+      auto rowKeys = makeRowVector(
+          {makeFlatVector<T>({1, 2, kNaN, 4, 5, 6}),
+           makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6})});
+      auto mapOfRowKeys = makeMapVector(
+          {0, 3}, rowKeys, makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}));
+      auto elementValue = makeRowVector(
+          {makeFlatVector<T>({kSNaN, 1}), makeFlatVector<int32_t>({3, 1})});
+      auto element = BaseVector::wrapInConstant(2, 0, elementValue);
+      auto expected = makeNullableFlatVector<int32_t>({3, std::nullopt});
+      auto result = evaluate(
+          "element_at(C0, C1)", makeRowVector({mapOfRowKeys, element}));
+      test::assertEqualVectors(expected, result);
+    }
+    // case 4: Verify NaNs are identified when employing caching.
+    exec::ExprSet exprSet({}, &execCtx_);
+    auto inputs = makeRowVector({});
+    exec::EvalCtx evalCtx(&execCtx_, &exprSet, inputs.get());
+
+    SelectivityVector rows(1);
+    auto inputMap = makeMapVector({0}, keysIdenticalNaNs, values);
+
+    auto keys = makeFlatVector<T>(std::vector<T>({kSNaN}));
+    std::vector<VectorPtr> args = {inputMap, keys};
+
+    facebook::velox::functions::detail::MapSubscript mapSubscriptWithCaching(
+        true);
+
+    auto checkStatus = [&](bool cachingEnabled,
+                           bool materializedMapIsNull,
+                           const VectorPtr& firstSeen) {
+      EXPECT_EQ(cachingEnabled, mapSubscriptWithCaching.cachingEnabled());
+      EXPECT_EQ(firstSeen, mapSubscriptWithCaching.firstSeenMap());
+      EXPECT_EQ(
+          materializedMapIsNull,
+          nullptr == mapSubscriptWithCaching.lookupTable());
+    };
+
+    // Initial state.
+    checkStatus(true, true, nullptr);
+
+    auto result1 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    // Nothing has been materialized yet since the input is seen only once.
+    checkStatus(true, true, args[0]);
+
+    auto result2 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    checkStatus(true, false, args[0]);
+
+    auto result3 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    checkStatus(true, false, args[0]);
+
+    // all the result should be the same.
+    expected = makeConstant<int32_t>(3, 1);
+    test::assertEqualVectors(expected, result2);
+    test::assertEqualVectors(result1, result2);
+    test::assertEqualVectors(result2, result3);
   }
 };
 
 template <>
 void ElementAtTest::testVariableInputMap<StringView>() {
   auto toStr = [](size_t input) {
-    return StringView(folly::sformat("str{}", input).c_str());
+    return StringView(fmt::format("str{}", input).c_str());
   };
 
   auto indicesVector = makeFlatVector<StringView>(
@@ -519,7 +609,7 @@ TEST_F(ElementAtTest, allFlavors3) {
   exec::registerVectorFunction(
       "__f2",
       SubscriptImpl<false, true, false, false>::signatures(),
-      std::make_unique<SubscriptImpl<false, true, false, false>>());
+      std::make_unique<SubscriptImpl<false, true, false, false>>(false));
 
   // #1
   EXPECT_EQ(elementAtSimple("__f2(C0, 0)", {arrayVector}), 10);
@@ -561,7 +651,7 @@ TEST_F(ElementAtTest, allFlavors4) {
   exec::registerVectorFunction(
       "__f3",
       SubscriptImpl<true, false, true, false>::signatures(),
-      std::make_unique<SubscriptImpl<true, false, true, false>>());
+      std::make_unique<SubscriptImpl<true, false, true, false>>(false));
 
   EXPECT_EQ(elementAtSimple("__f3(C0, 0)", {arrayVector}), 10);
   EXPECT_EQ(elementAtSimple("__f3(C0, 1)", {arrayVector}), 11);
@@ -642,7 +732,7 @@ TEST_F(ElementAtTest, constantInputMap) {
 
     // String map value type.
     auto valueAt2 = [](vector_size_t idx) {
-      return StringView(folly::sformat("str{}", idx % 5).c_str());
+      return StringView(fmt::format("str{}", idx % 5).c_str());
     };
     auto expectedValueAt2 = [](vector_size_t /* row */) {
       return StringView("str3");
@@ -713,62 +803,119 @@ TEST_F(ElementAtTest, mapWithComplexTypeAsKey) {
   searchVector = makeRowVector(
       {makeFlatVector<int64_t>({1, 3, 7}),
        makeFlatVector<StringView>({"a", "c", "f"})});
-  test::assertEqualVectors(
-      expected,
-      evaluate<SimpleVector<int64_t>>(
-          "element_at(C0, C1)", makeRowVector({mapVector, searchVector})));
+
+  auto elementAt = [&](auto& map, auto& search) {
+    return evaluate("element_at(C0, C1)", makeRowVector({map, search}));
+  };
+
+  test::assertEqualVectors(expected, elementAt(mapVector, searchVector));
 
   // Constant search vector.
   searchVector = makeConstantRow(
       ROW({BIGINT(), VARCHAR()}), variant::row({(int64_t)3, "c"}), 3);
   test::assertEqualVectors(
       makeNullableFlatVector<int64_t>({std::nullopt, 3, std::nullopt}),
-      evaluate<SimpleVector<int64_t>>(
-          "element_at(C0, C1)", makeRowVector({mapVector, searchVector})));
+      elementAt(mapVector, searchVector));
 
   // Map of Arrays:
   // {ARRAY[1, 2, 3] -> 1, ARRAY[333] -> 2}
   // {ARRAY[123, 456] -> 3}
   // {ARRAY[66, 77] -> 4, ARRAY[88] -> 5, ARRAY[99] -> 6}
-  keyVector = makeArrayVector<int64_t>(
-      {{1, 2, 3}, {333}, {123, 456}, {66, 77}, {88}, {99}});
+  keyVector = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "[333]",
+      "[123, 456]",
+      "[66, 77]",
+      "[88]",
+      "[99]",
+  });
   mapVector = makeMapVector({0, 2, 3}, keyVector, valueVector);
-  searchVector = makeArrayVector<int64_t>({{1, 2, 3}, {123, 456}, {31415926}});
-  test::assertEqualVectors(
-      expected,
-      evaluate<SimpleVector<int64_t>>(
-          "element_at(C0, C1)", makeRowVector({mapVector, searchVector})));
+  searchVector = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "[123, 456]",
+      "[31415926]",
+  });
+  test::assertEqualVectors(expected, elementAt(mapVector, searchVector));
 
   // Map of Maps:
   // {MAP(1->"a", 2->"b") -> 1, MAP(3->"c") -> 2}
   // {MAP(44->"e", 55->"f") -> 3}
   // {MAP(666->"w", 777->"x") -> 4, MAP(888->"y") -> 5, MAP(999->"z") -> 6}
-  keyVector = makeMapVector<int64_t, StringView>(
-      {{{1, "a"_sv}, {2, "b"_sv}},
-       {{3, "c"_sv}},
-       {{44, "e"_sv}, {55, "f"_sv}},
-       {{666, "w"_sv}, {777, "x"_sv}},
-       {{888, "y"_sv}},
-       {{999, "z"_sv}}});
+  keyVector = makeMapVectorFromJson<int64_t, std::string>({
+      "{1: \"a\", 2: \"b\"}",
+      "{3: \"c\"}",
+      "{44: \"e\", 55: \"f\"}",
+      "{666: \"w\", 777: \"x\"}",
+      "{888: \"y\"}",
+      "{999: \"z\"}",
+  });
   mapVector = makeMapVector({0, 2, 3}, keyVector, valueVector);
-  searchVector = makeMapVector<int64_t, StringView>(
-      {{{1, "a"_sv}, {2, "b"_sv}},
-       {{44, "e"_sv}, {55, "f"_sv}},
-       {{77777, "xyz"_sv}}});
-  test::assertEqualVectors(
-      expected,
-      evaluate<SimpleVector<int64_t>>(
-          "element_at(C0, C1)", makeRowVector({mapVector, searchVector})));
+
+  searchVector = makeMapVectorFromJson<int64_t, std::string>({
+      "{1: \"a\", 2: \"b\"}",
+      "{44: \"e\", 55: \"f\"}",
+      "{77777: \"xyz\"}",
+  });
+  test::assertEqualVectors(expected, elementAt(mapVector, searchVector));
 
   // The map entry order doesn't matter.
   searchVector = makeMapVector<int64_t, StringView>(
       {{{2, "b"_sv}, {1, "a"_sv}},
        {{55, "f"_sv}, {44, "e"_sv}},
        {{77777, "xyz"_sv}}});
-  test::assertEqualVectors(
-      expected,
-      evaluate<SimpleVector<int64_t>>(
-          "element_at(C0, C1)", makeRowVector({mapVector, searchVector})));
+  test::assertEqualVectors(expected, elementAt(mapVector, searchVector));
+}
+
+// Test fast path for the case of a single map.
+TEST_F(ElementAtTest, singleMapWithComplexTypeAsKey) {
+  auto keys = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "[4, 5]",
+      "[]",
+      "[6]",
+  });
+  auto values = makeFlatVector<std::string>({"a", "b", "c", "d"});
+
+  auto singleMapVector = makeMapVector({0}, keys, values);
+  auto mapVector = BaseVector::wrapInConstant(7, 0, singleMapVector);
+
+  auto search = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "[1, 2]",
+      "[4, 5]",
+      "null",
+      "[]",
+      "[null]",
+      "[6]",
+  });
+
+  auto expected = makeNullableFlatVector<std::string>(
+      {"a", std::nullopt, "b", std::nullopt, "c", std::nullopt, "d"});
+
+  auto result =
+      evaluate("element_at(C0, C1)", makeRowVector({mapVector, search}));
+  test::assertEqualVectors(expected, result);
+
+  mapVector =
+      wrapInDictionary(makeIndices({0, 0, 0, 0, 0, 0, 0}), singleMapVector);
+  result = evaluate("element_at(C0, C1)", makeRowVector({mapVector, search}));
+  test::assertEqualVectors(expected, result);
+
+  // Use encoded keys.
+  auto encodedKeys = wrapInDictionary(makeIndicesInReverse(4), keys);
+  singleMapVector = makeMapVector({0}, encodedKeys, values);
+  mapVector = BaseVector::wrapInConstant(7, 0, singleMapVector);
+
+  expected = makeNullableFlatVector<std::string>(
+      {"d", std::nullopt, "c", std::nullopt, "b", std::nullopt, "a"});
+
+  result = evaluate("element_at(C0, C1)", makeRowVector({mapVector, search}));
+  test::assertEqualVectors(expected, result);
+
+  mapVector =
+      wrapInDictionary(makeIndices({0, 0, 0, 0, 0, 0, 0}), singleMapVector);
+  result = evaluate("element_at(C0, C1)", makeRowVector({mapVector, search}));
+  test::assertEqualVectors(expected, result);
 }
 
 TEST_F(ElementAtTest, variableInputArray) {
@@ -862,7 +1009,7 @@ TEST_F(ElementAtTest, errorStatesArray) {
         return 1 + row % 7;
       });
 
-  // Make arrays of 1-based sequences of variying lengths: [1, 2], [1, 2, 3],
+  // Make arrays of 1-based sequences of varying lengths: [1, 2], [1, 2, 3],
   // [1, 2, 3, 4], etc.
   auto sizeAt = [](vector_size_t row) { return 2 + row % 7; };
   auto expectedValueAt = [](vector_size_t row) { return 1 + row % 7; };
@@ -883,3 +1030,302 @@ TEST_F(ElementAtTest, errorStatesArray) {
       expectedValueAt,
       [](auto row) { return row == 40; });
 }
+
+TEST_F(ElementAtTest, testCachingOptimization) {
+  std::vector<std::vector<std::pair<int64_t, std::optional<int64_t>>>>
+      inputMapVectorData;
+  inputMapVectorData.push_back({});
+  for (int i = 0; i < 1000; i++) {
+    // 0 -> 1000
+    // 1 -> 1001
+    // ..etc
+    inputMapVectorData.back().push_back({i, i + 1000});
+  }
+
+  inputMapVectorData.push_back({});
+  for (int i = 0; i < 1000; i++) {
+    // 0 -> 0
+    // 2 -> 1
+    // ..etc
+    inputMapVectorData.back().push_back({i * 2, i});
+  }
+
+  // Size of this map is 10, it wont be cached.
+  inputMapVectorData.push_back({});
+  for (int i = 0; i < 10; i++) {
+    // 0 -> 0
+    // 1 -> 1
+    inputMapVectorData.back().push_back({i, i});
+  }
+
+  // Make a dummy eval context.
+  exec::ExprSet exprSet({}, &execCtx_);
+  auto inputs = makeRowVector({});
+  exec::EvalCtx evalCtx(&execCtx_, &exprSet, inputs.get());
+
+  SelectivityVector rows(3);
+  auto inputMap = makeMapVector<int64_t, int64_t>(inputMapVectorData);
+
+  auto keys = makeFlatVector<int64_t>({0, 0, 0});
+  std::vector<VectorPtr> args = {inputMap, keys};
+
+  facebook::velox::functions::detail::MapSubscript mapSubscriptWithCaching(
+      true);
+
+  auto checkStatus = [&](bool cachingEnabled,
+                         bool materializedMapIsNull,
+                         const VectorPtr& firtSeen) {
+    EXPECT_EQ(cachingEnabled, mapSubscriptWithCaching.cachingEnabled());
+    EXPECT_EQ(firtSeen, mapSubscriptWithCaching.firstSeenMap());
+    EXPECT_EQ(
+        materializedMapIsNull,
+        nullptr == mapSubscriptWithCaching.lookupTable());
+  };
+
+  // Initial state.
+  checkStatus(true, true, nullptr);
+
+  auto result1 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  // Nothing has been materialized yet since the input is seen only once.
+  checkStatus(true, true, args[0]);
+
+  auto result2 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(true, false, args[0]);
+
+  auto result3 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(true, false, args[0]);
+
+  // all the result should be the same.
+  test::assertEqualVectors(result1, result2);
+  test::assertEqualVectors(result2, result3);
+
+  // Test the cached map content.
+  auto verfyCachedContent = [&]() {
+    auto& cachedMapTyped =
+        *static_cast<facebook::velox::functions::detail::LookupTable<int64_t>*>(
+             mapSubscriptWithCaching.lookupTable().get())
+             ->map();
+
+    EXPECT_TRUE(cachedMapTyped.count(0));
+    EXPECT_TRUE(cachedMapTyped.count(1));
+    // Small map not cached.
+    EXPECT_FALSE(cachedMapTyped.count(2));
+
+    auto map0 = cachedMapTyped.find(0)->second;
+    for (int i = 0; i < 1000; i++) {
+      EXPECT_TRUE(map0.count(i));
+      // The map caches the offset of the value.
+      EXPECT_EQ(map0[i], i);
+    }
+
+    auto map1 = cachedMapTyped.find(1)->second;
+    EXPECT_EQ(map1.size(), 1000);
+    for (int i = 0; i < 1000; i++) {
+      EXPECT_TRUE(map1.count(i * 2));
+      // The map caches the offset of the value.
+      EXPECT_EQ(map1[i * 2], 1000 + i);
+    }
+  };
+
+  verfyCachedContent();
+  // Pass different map with same base.
+  {
+    auto dictInput = BaseVector::wrapInDictionary(
+        nullptr, makeIndicesInReverse(3), 3, inputMap);
+    args[0] = dictInput;
+
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    // Last seen map will keep pointing to the original map since both have the
+    // same base.
+    checkStatus(true, false, inputMap);
+
+    auto expectedResult = BaseVector::wrapInDictionary(
+        nullptr, makeIndicesInReverse(3), 3, result1);
+    test::assertEqualVectors(expectedResult, result);
+    verfyCachedContent();
+  }
+
+  {
+    auto constantInput = BaseVector::wrapInConstant(3, 0, inputMap);
+    args[0] = constantInput;
+
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    // Last seen map will keep pointing to the original map since both have the
+    // same base.
+    checkStatus(true, false, inputMap);
+
+    auto expectedResult = makeFlatVector<int64_t>({1000, 1000, 1000});
+    test::assertEqualVectors(expectedResult, result);
+    verfyCachedContent();
+  }
+
+  // Pass a different map, caching will be disabled.
+  {
+    args[0] = makeMapVector<int64_t, int64_t>(inputMapVectorData);
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    checkStatus(false, true, nullptr);
+    test::assertEqualVectors(result, result1);
+  }
+
+  {
+    args[0] = makeMapVector<int64_t, int64_t>(inputMapVectorData);
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    checkStatus(false, true, nullptr);
+    test::assertEqualVectors(result, result1);
+  }
+}
+
+TEST_F(ElementAtTest, floatingPointCornerCases) {
+  // Verify that different code paths (keys of simple types, complex types and
+  // optimized caching) correctly identify NaNs and treat all NaNs with
+  // different binary representations as equal. Also verifies that -/+ 0.0 are
+  // considered equal.
+  testFloatingPointCornerCases<float>();
+  testFloatingPointCornerCases<double>();
+}
+
+TEST_F(ElementAtTest, testCachingOptimizationComplexKey) {
+  std::vector<std::vector<int64_t>> keys;
+  std::vector<int64_t> values;
+  for (int i = 0; i < 999; i += 3) {
+    // [0, 1, 2] -> 1000
+    // [3, 4, 5] -> 1003
+    // ...
+    keys.push_back({i, i + 1, i + 2});
+    values.push_back(i + 1000);
+  }
+
+  // Make a dummy eval context.
+  exec::ExprSet exprSet({}, &execCtx_);
+  auto inputs = makeRowVector({});
+  exec::EvalCtx evalCtx(&execCtx_, &exprSet, inputs.get());
+
+  SelectivityVector rows(1);
+  auto keysVector = makeArrayVector<int64_t>(keys);
+  auto valuesVector = makeFlatVector<int64_t>(values);
+  auto inputMap = makeMapVector({0}, keysVector, valuesVector);
+
+  auto inputKeys = makeArrayVector<int64_t>({{0, 1, 2}});
+  std::vector<VectorPtr> args{inputMap, inputKeys};
+
+  facebook::velox::functions::detail::MapSubscript mapSubscriptWithCaching(
+      true);
+
+  auto checkStatus = [&](bool cachingEnabled,
+                         bool materializedMapIsNull,
+                         const VectorPtr& firtSeen) {
+    EXPECT_EQ(cachingEnabled, mapSubscriptWithCaching.cachingEnabled());
+    EXPECT_EQ(firtSeen, mapSubscriptWithCaching.firstSeenMap());
+    EXPECT_EQ(
+        materializedMapIsNull,
+        nullptr == mapSubscriptWithCaching.lookupTable());
+  };
+
+  // Initial state.
+  checkStatus(true, true, nullptr);
+
+  auto result1 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  // Nothing has been materialized yet since the input is seen only once.
+  checkStatus(true, true, args[0]);
+
+  auto result2 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(true, false, args[0]);
+
+  auto result3 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(true, false, args[0]);
+
+  // all the result should be the same.
+  test::assertEqualVectors(result1, result2);
+  test::assertEqualVectors(result2, result3);
+
+  // Test the cached map content.
+  auto verfyCachedContent = [&]() {
+    auto& cachedMap = mapSubscriptWithCaching.lookupTable()
+                          ->typedTable<void>()
+                          ->getMapAtIndex(0);
+
+    for (int i = 0; i < keysVector->size(); i += 3) {
+      EXPECT_NE(
+          cachedMap.end(),
+          cachedMap.find(facebook::velox::functions::detail::MapKey{
+              keysVector.get(), 0, 0}));
+    }
+  };
+
+  verfyCachedContent();
+  // Pass different map with same base.
+  {
+    auto dictInput = BaseVector::wrapInDictionary(
+        nullptr, makeIndices({0, 0, 0}), 1, inputMap);
+
+    SelectivityVector rows(3);
+    std::vector<VectorPtr> args{
+        dictInput, makeArrayVector<int64_t>({{0, 1, 2}, {0, 1, 2}, {0, 1, 2}})};
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    // Last seen map will keep pointing to the original map since both have
+    // the same base.
+    checkStatus(true, false, inputMap);
+
+    auto expectedResult = makeFlatVector<int64_t>({1000, 1000, 1000});
+    test::assertEqualVectors(expectedResult, result);
+    verfyCachedContent();
+  }
+
+  {
+    auto constantInput = BaseVector::wrapInConstant(3, 0, inputMap);
+
+    SelectivityVector rows(3);
+    std::vector<VectorPtr> args{
+        constantInput,
+        makeArrayVector<int64_t>({{0, 1, 2}, {0, 1, 2}, {0, 1, 2}})};
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    // Last seen map will keep pointing to the original map since both have
+    // the same base.
+    checkStatus(true, false, inputMap);
+
+    auto expectedResult = makeFlatVector<int64_t>({1000, 1000, 1000});
+    test::assertEqualVectors(expectedResult, result);
+    verfyCachedContent();
+  }
+
+  // Pass a different map, caching will be disabled.
+  {
+    args[0] = makeMapVector({0}, keysVector, valuesVector);
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    checkStatus(false, true, nullptr);
+    test::assertEqualVectors(result, result1);
+  }
+
+  {
+    args[0] = makeMapVector({0}, keysVector, valuesVector);
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    checkStatus(false, true, nullptr);
+    test::assertEqualVectors(result, result1);
+  }
+
+  for (int i = 0; i < 999; i += 3) {
+    // [0, 1, 2] -> 0
+    // [2, 3, 4] -> 1
+    // ...
+    keys.push_back({i * 2, i * 2 + 1, i * 2 + 2});
+    values.push_back(i);
+  }
+
+  for (int i = 0; i < 30; i += 3) {
+    // [0, 1, 2] -> 0
+    // [3, 4, 5] -> 3
+    // ...
+    keys.push_back({i, i + 1, i + 2});
+    values.push_back(i);
+  }
+
+  args[0] = makeMapVector({0, 333, 666}, keysVector, valuesVector);
+  auto resultWithMoreVectors =
+      mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(false, true, nullptr);
+
+  auto resultWithMoreVectors1 =
+      mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(false, true, nullptr);
+  test::assertEqualVectors(resultWithMoreVectors, resultWithMoreVectors1);
+}
diff --git a/velox/functions/prestosql/tests/FailTest.cpp b/velox/functions/prestosql/tests/FailTest.cpp
new file mode 100644
index 0000000000000..829f597c1ad46
--- /dev/null
+++ b/velox/functions/prestosql/tests/FailTest.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+
+namespace {
+
+class FailTest : public functions::test::FunctionBaseTest {};
+
+TEST_F(FailTest, basic) {
+  auto message = std::optional("test error message");
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<UnknownValue>("fail(c0)", message), message.value());
+
+  EXPECT_EQ(std::nullopt, evaluateOnce<UnknownValue>("try(fail(c0))", message));
+
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<UnknownValue>("fail(123::integer, c0)", message),
+      message.value());
+
+  EXPECT_EQ(
+      std::nullopt,
+      evaluateOnce<UnknownValue>("try(fail(123::integer, c0))", message));
+}
+
+TEST_F(FailTest, json) {
+  auto json =
+      std::optional(R"({"code": 123, "message": "test error message"})");
+
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<UnknownValue>("fail(c0)", JSON(), json),
+      "test error message");
+
+  EXPECT_EQ(
+      std::nullopt, evaluateOnce<UnknownValue>("try(fail(c0))", JSON(), json));
+
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<UnknownValue>("fail(123::integer, c0)", JSON(), json),
+      "test error message");
+
+  EXPECT_EQ(
+      std::nullopt,
+      evaluateOnce<UnknownValue>("try(fail(123::integer, c0))", JSON(), json));
+}
+
+TEST_F(FailTest, invalidJson) {
+  // Invalid JSON.
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<UnknownValue>(
+          "fail(c0)", JSON(), std::optional("not a valid JSON")),
+      "Cannot extract 'message' from the JSON");
+
+  // Valid JSON with missing 'message' field.
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<UnknownValue>("fail(c0)", JSON(), std::optional("{}")),
+      "Cannot extract 'message' from the JSON");
+
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<UnknownValue>(
+          "fail(c0)", JSON(), std::optional(R"({"code": 123})")),
+      "Cannot extract 'message' from the JSON");
+
+  // Valid JSON with 'message' field that's not string.
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<UnknownValue>(
+          "fail(c0)",
+          JSON(),
+          std::optional(R"({"code": 123, "message": [1, 2, 3]})")),
+      "Cannot extract 'message' from the JSON");
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/FindFirstTest.cpp b/velox/functions/prestosql/tests/FindFirstTest.cpp
index a5106255278be..4498a075d59f8 100644
--- a/velox/functions/prestosql/tests/FindFirstTest.cpp
+++ b/velox/functions/prestosql/tests/FindFirstTest.cpp
@@ -101,6 +101,15 @@ TEST_F(FindFirstTest, basic) {
   expected =
       makeNullableFlatVector<int64_t>({3, std::nullopt, std::nullopt, 5});
   verify("find_first_index(c0, -2, x -> (x > 0))", data, expected);
+
+  expected = makeNullConstant(TypeKind::INTEGER, 4);
+  verify("find_first(c0, cast(null as INTEGER), x -> (x > 0))", data, expected);
+
+  expected = makeNullConstant(TypeKind::BIGINT, 4);
+  verify(
+      "find_first_index(c0, cast(null as INTEGER), x -> (x > 0))",
+      data,
+      expected);
 }
 
 TEST_F(FindFirstTest, firstMatchIsNull) {
@@ -166,5 +175,111 @@ TEST_F(FindFirstTest, predicateFailures) {
   verify("find_first_index(c0, -3, x -> (10 / x > 2))", data, expected);
 }
 
+TEST_F(FindFirstTest, invalidIndex) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[-1, 2]",
+          "[-2, -3, -4]",
+          "[-5, -6]",
+      }),
+      makeFlatVector<int32_t>({2, 0, 0, 1}),
+  });
+
+  // Index 0 is not valid. Expect an error.
+  VELOX_ASSERT_THROW(
+      evaluate("find_first(c0, c1, x -> (x > 0))", data),
+      "SQL array indices start at 1. Got 0.");
+
+  // There are 2 rows with invalid index. Mark array argument in one of these
+  // rows as NULL. Still expect the other row to trigger an error.
+  data->childAt(0)->setNull(1, true);
+  VELOX_ASSERT_THROW(
+      evaluate("find_first(c0, c1, x -> (x > 0))", data),
+      "SQL array indices start at 1. Got 0.");
+
+  // Mark array argument in the other row as NULL. Expect no errors.
+  data->childAt(0)->setNull(2, true);
+  auto expected = makeNullableFlatVector<int32_t>(
+      {2, std::nullopt, std::nullopt, std::nullopt});
+  verify("find_first(c0, c1, x -> (x > 0))", data, expected);
+
+  // All null or empty arrays.
+  data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[]",
+          "null",
+          "[]",
+          "null",
+      }),
+      makeFlatVector<int32_t>({2, 0, 0, 1}),
+  });
+
+  // Index 0 is not valid. Expect an error in the 3rd row.
+  VELOX_ASSERT_THROW(
+      evaluate("find_first(c0, c1, x -> (x > 0))", data),
+      "SQL array indices start at 1. Got 0.");
+
+  // Mark 3rd row null. Expect no error.
+  data->childAt(1)->setNull(2, true);
+  expected = makeAllNullFlatVector<int32_t>(4);
+  verify("find_first(c0, c1, x -> (x > 0))", data, expected);
+}
+
+// Verify that null arrays with non-zero offsets/sizes are processed correctly.
+TEST_F(FindFirstTest, nulls) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[-1, 2]",
+          "[-2, -3, -4]",
+          "[-5, -6]",
+      }),
+  });
+
+  // find_first: x > 0.
+  VectorPtr expected =
+      makeNullableFlatVector<int32_t>({1, 2, std::nullopt, std::nullopt});
+  verify("find_first(c0, x -> (x > 0))", data, expected);
+
+  // Mark [-1, 2] array as null. Expect null result.
+  data->childAt(0)->setNull(1, true);
+  expected = makeNullableFlatVector<int32_t>(
+      {1, std::nullopt, std::nullopt, std::nullopt});
+  verify("find_first(c0, x -> (x > 0))", data, expected);
+
+  // Mark all arrays null. Expect all-null results.
+  for (auto i = 0; i < data->size(); ++i) {
+    data->childAt(0)->setNull(i, true);
+  }
+
+  expected = makeAllNullFlatVector<int32_t>(data->size());
+  verify("find_first(c0, x -> (x > 0))", data, expected);
+}
+
+// Verify evaluation on a subset of rows in ArrayVector with only null and empty
+// arrays..
+TEST_F(FindFirstTest, emptyArrays) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({
+          "[]",
+          "[]",
+          "null",
+          "[]",
+          "[]",
+          "null",
+      }),
+  });
+
+  // Evaluate on all rows, but the first one.
+  SelectivityVector rows(data->size());
+  rows.setValid(0, false);
+  rows.updateBounds();
+
+  auto result = evaluate("find_first(c0, x -> (x > 0))", data, rows);
+  auto expected = makeNullConstant(TypeKind::INTEGER, data->size());
+  velox::test::assertEqualVectors(expected, result);
+}
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/FromUtf8Test.cpp b/velox/functions/prestosql/tests/FromUtf8Test.cpp
index f8f2580a3ac43..b088e9c99ed60 100644
--- a/velox/functions/prestosql/tests/FromUtf8Test.cpp
+++ b/velox/functions/prestosql/tests/FromUtf8Test.cpp
@@ -23,8 +23,7 @@ namespace {
 class FromUtf8Test : public test::FunctionBaseTest {
  protected:
   std::optional<std::string> fromUtf8(std::optional<std::string> value) {
-    return evaluateOnce<std::string, std::string>(
-        "from_utf8(c0)", {value}, {VARBINARY()});
+    return evaluateOnce<std::string>("from_utf8(c0)", VARBINARY(), value);
   }
 
   std::optional<std::string> fromUtf8(
@@ -202,6 +201,22 @@ TEST_F(FromUtf8Test, basic) {
   EXPECT_EQ(makeExpected("#"), fromUtf8(mix.str(), '#'));
   EXPECT_EQ(makeExpected(""), fromUtf8(mix.str(), ""));
   EXPECT_EQ(makeExpected(kClef), fromUtf8(mix.str(), kClef));
+
+  // Invalid codepoint of multi-byte long.
+  {
+    // The first byte 0xFB indicates a 5-byte long codepoint.
+    auto result = evaluateOnce<std::string>(
+        "from_utf8(from_hex(c0))", std::optional<std::string>{"FBB78EB6BE"});
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ("\uFFFD", result.value());
+
+    // The first byte 0xFB indicates a 5-byte long codepoint, but only three
+    // continuation bytes follow. The fifth byte is a valid character 'X'.
+    result = evaluateOnce<std::string>(
+        "from_utf8(from_hex(c0))", std::optional<std::string>{"FBB78EB658"});
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ("\uFFFDX", result.value());
+  }
 }
 
 TEST_F(FromUtf8Test, invalidReplacement) {
@@ -267,5 +282,56 @@ TEST_F(FromUtf8Test, invalidReplacement) {
   velox::test::assertEqualVectors(expected, result);
 }
 
+TEST_F(FromUtf8Test, invalidReplacementWithAllValidRows) {
+  // Make sure that replacement is checked to be valid even if all the rows have
+  // valid UTF-8 data.
+  // c0 : all ascii
+  // c1 : all valid not ascii.
+  // c2 : invalid integer replacement.
+  // c3 : invalid string replacement.
+  auto data = makeRowVector(
+      {makeNullableFlatVector<std::string>(
+           {validAscii().front(), validAscii().front()}, VARBINARY()),
+       makeNullableFlatVector<std::string>(
+           {validMultiByte().back(), validMultiByte().back()}, VARBINARY()),
+       makeNullableFlatVector<int64_t>({22334455, 22334455}),
+       makeNullableFlatVector<std::string>({"12"
+                                            "12"})});
+
+  // Test when replacement is integer.
+  VELOX_ASSERT_THROW(
+      evaluate("from_utf8(c0, 22334455::bigint)", data),
+      "Not a valid Unicode code point: 22334455");
+
+  VELOX_ASSERT_THROW(
+      evaluate("from_utf8(c0, c2)", data),
+      "Not a valid Unicode code point: 22334455");
+
+  VELOX_ASSERT_THROW(
+      evaluate("from_utf8(c1, 22334455::bigint)", data),
+      "Not a valid Unicode code point: 22334455");
+
+  VELOX_ASSERT_THROW(
+      evaluate("from_utf8(c1, c2)", data),
+      "Not a valid Unicode code point: 22334455");
+
+  // Test when replacement is string.
+  VELOX_ASSERT_THROW(
+      evaluate("from_utf8(c0, '12')", data),
+      "Replacement string must be empty or a single character");
+
+  VELOX_ASSERT_THROW(
+      evaluate("from_utf8(c0, c3)", data),
+      "Replacement string must be empty or a single character");
+
+  VELOX_ASSERT_THROW(
+      evaluate("from_utf8(c1, '12')", data),
+      "Replacement string must be empty or a single character");
+
+  VELOX_ASSERT_THROW(
+      evaluate("from_utf8(c1, c3)", data),
+      "Replacement string must be empty or a single character");
+}
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/GreatestLeastTest.cpp b/velox/functions/prestosql/tests/GreatestLeastTest.cpp
index 50ada7c456eac..a8b9bc3ed8a52 100644
--- a/velox/functions/prestosql/tests/GreatestLeastTest.cpp
+++ b/velox/functions/prestosql/tests/GreatestLeastTest.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <cmath>
+#include <limits>
 #include <optional>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
@@ -83,29 +85,50 @@ TEST_F(GreatestLeastTest, leastReal) {
       {0, -100, -1.1});
 }
 
-TEST_F(GreatestLeastTest, nanInput) {
-  // Presto rejects NaN inputs of type DOUBLE, but allows NaN inputs of type
-  // REAL.
-  std::vector<double> input{0, 1.1, std::nan("1")};
-  VELOX_ASSERT_THROW(
-      runTest<double>("least(c0)", {{0.0 / 0.0}}, {0}),
-      "Invalid argument to least(): NaN");
-  runTest<double>("try(least(c0, 1.0))", {input}, {0, 1.0, std::nullopt});
-
-  VELOX_ASSERT_THROW(
-      runTest<double>("greatest(c0)", {1, {0.0 / 0.0}}, {1, 0}),
-      "Invalid argument to greatest(): NaN");
-  runTest<double>("try(greatest(c0, 1.0))", {input}, {1.0, 1.1, std::nullopt});
-
-  auto result = evaluateOnce<bool, float, float>(
-      "is_nan(least(c0))", std::nanf("1"), 1.2);
-  ASSERT_TRUE(result.has_value());
-  ASSERT_TRUE(result.value());
-
-  result = evaluateOnce<bool, float, float>(
-      "is_nan(greatest(c0))", std::nanf("1"), 1.2);
-  ASSERT_TRUE(result.has_value());
-  ASSERT_TRUE(result.value());
+TEST_F(GreatestLeastTest, greatestNanInput) {
+  auto constexpr kInf32 = std::numeric_limits<float>::infinity();
+  auto constexpr kInf64 = std::numeric_limits<double>::infinity();
+
+  auto greatestFloat = [&](float a, float b, float c) {
+    return evaluateOnce<float, float, float, float>(
+               "greatest(c0, c1, c2)", {a}, {b}, {c})
+        .value();
+  };
+
+  auto greatestDouble = [&](double a, double b, double c) {
+    return evaluateOnce<double, double, double, double>(
+               "greatest(c0, c1, c2)", {a}, {b}, {c})
+        .value();
+  };
+
+  EXPECT_TRUE(std::isnan(greatestFloat(1.0, std::nanf("1"), 2.0)));
+  EXPECT_TRUE(std::isnan(greatestFloat(std::nanf("1"), 1.0, kInf32)));
+
+  EXPECT_TRUE(std::isnan(greatestDouble(1.0, std::nan("1"), 2.0)));
+  EXPECT_TRUE(std::isnan(greatestDouble(std::nan("1"), 1.0, kInf64)));
+}
+
+TEST_F(GreatestLeastTest, leastNanInput) {
+  auto constexpr kInf32 = std::numeric_limits<float>::infinity();
+  auto constexpr kInf64 = std::numeric_limits<double>::infinity();
+
+  auto leastFloat = [&](float a, float b, float c) {
+    return evaluateOnce<float, float, float, float>(
+               "least(c0, c1, c2)", {a}, {b}, {c})
+        .value();
+  };
+
+  auto leastDouble = [&](double a, double b, double c) {
+    return evaluateOnce<double, double, double, double>(
+               "least(c0, c1, c2)", {a}, {b}, {c})
+        .value();
+  };
+
+  EXPECT_EQ(leastFloat(1.0, std::nanf("1"), 0.5), 0.5);
+  EXPECT_EQ(leastFloat(std::nanf("1"), 1.0, -kInf32), -kInf32);
+
+  EXPECT_EQ(leastDouble(1.0, std::nan("1"), 0.5), 0.5);
+  EXPECT_EQ(leastDouble(std::nan("1"), 1.0, -kInf64), -kInf64);
 }
 
 TEST_F(GreatestLeastTest, greatestDouble) {
@@ -202,6 +225,43 @@ TEST_F(GreatestLeastTest, leastTimeStamp) {
       {Timestamp(0, 0), Timestamp(10, 1), Timestamp(1, 10)});
 }
 
+TEST_F(GreatestLeastTest, greatestTimestampWithTimezone) {
+  auto greatest = [&](const std::string& a,
+                      const std::string& b,
+                      const std::string& c) {
+    auto result = evaluateOnce<std::string>(
+        "cast(greatest(cast(c0 as timestamp with time zone), cast(c1 as timestamp with time zone), cast(c2 as timestamp with time zone)) as varchar)",
+        std::optional(a),
+        std::optional(b),
+        std::optional(c));
+    return result.value();
+  };
+
+  auto least = [&](const std::string& a,
+                   const std::string& b,
+                   const std::string& c) {
+    auto result = evaluateOnce<std::string>(
+        "cast(least(cast(c0 as timestamp with time zone), cast(c1 as timestamp with time zone), cast(c2 as timestamp with time zone)) as varchar)",
+        std::optional(a),
+        std::optional(b),
+        std::optional(c));
+    return result.value();
+  };
+
+  EXPECT_EQ(
+      "2024-04-10 08:11:22.010 America/Los_Angeles",
+      greatest(
+          "2024-04-10 10:11:22.01 America/New_York",
+          "2024-02-10 10:11:22.01 America/New_York",
+          "2024-04-10 08:11:22.01 America/Los_Angeles"));
+  EXPECT_EQ(
+      "2024-02-10 10:11:22.010 America/New_York",
+      least(
+          "2024-04-10 10:11:22.01 America/New_York",
+          "2024-02-10 10:11:22.01 America/New_York",
+          "2024-04-10 08:11:22.01 America/Los_Angeles"));
+}
+
 TEST_F(GreatestLeastTest, greatestDate) {
   runTest<int32_t>(
       "greatest(c0, c1, c2)",
@@ -321,3 +381,21 @@ TEST_F(GreatestLeastTest, longDecimal) {
       type);
   runDecimalTest("greatest(c0, c1)", {a, b}, expected);
 }
+
+TEST_F(GreatestLeastTest, boolean) {
+  auto data = makeRowVector({
+      makeFlatVector<bool>({true, true, false, false, true, false}),
+      makeNullableFlatVector<bool>(
+          {true, false, true, false, std::nullopt, std::nullopt}),
+  });
+
+  auto result = evaluate("least(c0, c1)", data);
+  auto expected = makeNullableFlatVector<bool>(
+      {true, false, false, false, std::nullopt, std::nullopt});
+  test::assertEqualVectors(expected, result);
+
+  result = evaluate("greatest(c0, c1)", data);
+  expected = makeNullableFlatVector<bool>(
+      {true, true, true, false, std::nullopt, std::nullopt});
+  test::assertEqualVectors(expected, result);
+}
diff --git a/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp b/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
index 94fd618ae0be2..a6062e3a30a30 100644
--- a/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
@@ -48,7 +48,8 @@ class HyperLogLogFunctionsTest : public functions::test::FunctionBaseTest {
     return serialized;
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   HashStringAllocator allocator_{pool_.get()};
 };
 
@@ -56,8 +57,8 @@ TEST_F(HyperLogLogFunctionsTest, cardinalitySignatures) {
   auto signatures = getSignatureStrings("cardinality");
   ASSERT_EQ(3, signatures.size());
 
-  ASSERT_EQ(1, signatures.count("(map(any,any)) -> bigint"));
-  ASSERT_EQ(1, signatures.count("(array(any)) -> bigint"));
+  ASSERT_EQ(1, signatures.count("(map(__user_T1,__user_T2)) -> bigint"));
+  ASSERT_EQ(1, signatures.count("(array(__user_T1)) -> bigint"));
   ASSERT_EQ(1, signatures.count("(hyperloglog) -> bigint"));
 }
 
@@ -65,14 +66,13 @@ TEST_F(HyperLogLogFunctionsTest, emptyApproxSetSignatures) {
   auto signatures = getSignatureStrings("empty_approx_set");
   ASSERT_EQ(2, signatures.size());
 
-  ASSERT_EQ(1, signatures.count("(double) -> hyperloglog"));
+  ASSERT_EQ(1, signatures.count("(constant double) -> hyperloglog"));
   ASSERT_EQ(1, signatures.count("() -> hyperloglog"));
 }
 
 TEST_F(HyperLogLogFunctionsTest, cardinalitySparse) {
-  const auto cardinality = [&](const std::string& input) {
-    return evaluateOnce<int64_t, StringView>(
-        "cardinality(c0)", {StringView(input)}, {HYPERLOGLOG()});
+  const auto cardinality = [&](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>("cardinality(c0)", HYPERLOGLOG(), input);
   };
 
   SparseHll sparseHll{&allocator_};
@@ -85,9 +85,8 @@ TEST_F(HyperLogLogFunctionsTest, cardinalitySparse) {
 }
 
 TEST_F(HyperLogLogFunctionsTest, cardinalityDense) {
-  const auto cardinality = [&](const std::string& input) {
-    return evaluateOnce<int64_t, StringView>(
-        "cardinality(c0)", {StringView(input)}, {HYPERLOGLOG()});
+  const auto cardinality = [&](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>("cardinality(c0)", HYPERLOGLOG(), input);
   };
 
   DenseHll denseHll{12, &allocator_};
diff --git a/velox/functions/prestosql/tests/IPAddressCastTest.cpp b/velox/functions/prestosql/tests/IPAddressCastTest.cpp
new file mode 100644
index 0000000000000..0f62b6b724808
--- /dev/null
+++ b/velox/functions/prestosql/tests/IPAddressCastTest.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox::functions::prestosql {
+
+namespace {
+
+class IPAddressCastTest : public functions::test::FunctionBaseTest {
+ protected:
+  std::optional<std::string> castToVarchar(
+      const std::optional<std::string> input) {
+    auto result = evaluateOnce<std::string>(
+        "cast(cast(c0 as ipaddress) as varchar)", input);
+    return result;
+  }
+
+  std::optional<int128_t> castFromVarbinary(
+      const std::optional<std::string> input) {
+    auto result =
+        evaluateOnce<int128_t>("cast(from_hex(c0) as ipaddress)", input);
+    return result;
+  }
+
+  std::optional<std::string> allCasts(const std::optional<std::string> input) {
+    auto result = evaluateOnce<std::string>(
+        "cast(cast(cast(cast(c0 as ipaddress) as varbinary) as ipaddress) as varchar)",
+        input);
+    return result;
+  }
+};
+
+int128_t stringToInt128(std::string value) {
+  int128_t res = 0;
+  for (char c : value) {
+    res = res * 10 + c - '0';
+  }
+  return res;
+}
+
+TEST_F(IPAddressCastTest, castToVarchar) {
+  EXPECT_EQ(castToVarchar("::ffff:1.2.3.4"), "1.2.3.4");
+  EXPECT_EQ(castToVarchar("0:0:0:0:0:0:13.1.68.3"), "::13.1.68.3");
+  EXPECT_EQ(castToVarchar("1.2.3.4"), "1.2.3.4");
+  EXPECT_EQ(castToVarchar("192.168.0.0"), "192.168.0.0");
+  EXPECT_EQ(
+      castToVarchar("2001:0db8:0000:0000:0000:ff00:0042:8329"),
+      "2001:db8::ff00:42:8329");
+  EXPECT_EQ(castToVarchar("2001:db8::ff00:42:8329"), "2001:db8::ff00:42:8329");
+  EXPECT_EQ(castToVarchar("2001:db8:0:0:1:0:0:1"), "2001:db8::1:0:0:1");
+  EXPECT_EQ(castToVarchar("2001:db8:0:0:1::1"), "2001:db8::1:0:0:1");
+  EXPECT_EQ(castToVarchar("2001:db8::1:0:0:1"), "2001:db8::1:0:0:1");
+  EXPECT_EQ(
+      castToVarchar("2001:DB8::FF00:ABCD:12EF"), "2001:db8::ff00:abcd:12ef");
+  VELOX_ASSERT_THROW(
+      castToVarchar("facebook.com"), "Invalid IP address 'facebook.com'");
+  VELOX_ASSERT_THROW(
+      castToVarchar("localhost"), "Invalid IP address 'localhost'");
+  VELOX_ASSERT_THROW(
+      castToVarchar("2001:db8::1::1"), "Invalid IP address '2001:db8::1::1'");
+  VELOX_ASSERT_THROW(
+      castToVarchar("2001:zxy::1::1"), "Invalid IP address '2001:zxy::1::1'");
+  VELOX_ASSERT_THROW(
+      castToVarchar("789.1.1.1"), "Invalid IP address '789.1.1.1'");
+}
+
+TEST_F(IPAddressCastTest, castFromVarbinary) {
+  EXPECT_EQ(
+      castFromVarbinary("00000000000000000000ffff01020304"),
+      stringToInt128("281470698652420"));
+  EXPECT_EQ(castFromVarbinary("01020304"), stringToInt128("281470698652420"));
+  EXPECT_EQ(castFromVarbinary("c0a80000"), stringToInt128("281473913978880"));
+  EXPECT_EQ(
+      castFromVarbinary("20010db8000000000000ff0000428329"),
+      stringToInt128("42540766411282592856904265327123268393"));
+  EXPECT_THROW(castFromVarbinary("f000001100"), VeloxUserError);
+}
+
+TEST_F(IPAddressCastTest, allCasts) {
+  EXPECT_EQ(allCasts("::ffff:1.2.3.4"), "1.2.3.4");
+  EXPECT_EQ(
+      allCasts("2001:0db8:0000:0000:0000:ff00:0042:8329"),
+      "2001:db8::ff00:42:8329");
+  EXPECT_EQ(allCasts("2001:db8::ff00:42:8329"), "2001:db8::ff00:42:8329");
+}
+
+TEST_F(IPAddressCastTest, nullTest) {
+  EXPECT_EQ(castToVarchar(std::nullopt), std::nullopt);
+  EXPECT_EQ(castFromVarbinary(std::nullopt), std::nullopt);
+}
+
+TEST_F(IPAddressCastTest, castRoundTrip) {
+  auto strings = makeFlatVector<std::string>(
+      {"87a0:ce14:8989:44c9:826e:b4d8:73f9:1542",
+       "7cd6:bcec:1216:5c20:4b67:b1bd:173:ced",
+       "192.128.0.0"});
+
+  auto ipaddresses =
+      evaluate("cast(c0 as ipaddress)", makeRowVector({strings}));
+  auto stringsCopy =
+      evaluate("cast(c0 as varchar)", makeRowVector({ipaddresses}));
+  auto ipaddressesCopy =
+      evaluate("cast(c0 as ipaddress)", makeRowVector({stringsCopy}));
+
+  velox::test::assertEqualVectors(strings, stringsCopy);
+  velox::test::assertEqualVectors(ipaddresses, ipaddressesCopy);
+}
+} // namespace
+
+} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/tests/InPredicateTest.cpp b/velox/functions/prestosql/tests/InPredicateTest.cpp
index 3a5c91d627991..b085581485134 100644
--- a/velox/functions/prestosql/tests/InPredicateTest.cpp
+++ b/velox/functions/prestosql/tests/InPredicateTest.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 using namespace facebook::velox::test;
@@ -54,7 +55,7 @@ class InPredicateTest : public FunctionBaseTest {
       this->options_.parseDecimalAsDouble = false;
     }
     std::shared_ptr<memory::MemoryPool> pool{
-        memory::addDefaultLeafMemoryPool()};
+        memory::memoryManager()->addLeafPool()};
 
     const vector_size_t size = 1'000;
     auto inList = getInList<T>({1, 3, 5}, type);
@@ -219,6 +220,12 @@ class InPredicateTest : public FunctionBaseTest {
     assertEqualVectors(constNull, result);
   }
 
+  static core::TypedExprPtr field(
+      const TypePtr& type,
+      const std::string& name) {
+    return std::make_shared<core::FieldAccessTypedExpr>(type, name);
+  }
+
   core::TypedExprPtr makeInExpression(const VectorPtr& values) {
     BufferPtr offsets = allocateOffsets(1, pool());
     BufferPtr sizes = allocateSizes(1, pool());
@@ -228,7 +235,7 @@ class InPredicateTest : public FunctionBaseTest {
     return std::make_shared<core::CallTypedExpr>(
         BOOLEAN(),
         std::vector<core::TypedExprPtr>{
-            std::make_shared<core::FieldAccessTypedExpr>(values->type(), "c0"),
+            field(values->type(), "c0"),
             std::make_shared<core::ConstantTypedExpr>(
                 std::make_shared<ArrayVector>(
                     pool(),
@@ -251,6 +258,114 @@ class InPredicateTest : public FunctionBaseTest {
 
     return makeFlatVector(timestamps);
   }
+
+  template <typename T>
+  void testNaNs() {
+    const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+    TypePtr columnFloatType = CppToType<T>::create();
+
+    // Constant In-list, primitive input.
+    auto testInWithConstList = [&](std::vector<T> input,
+                                   std::vector<T> inlist,
+                                   std::vector<bool> expected) {
+      auto expr = std::make_shared<core::CallTypedExpr>(
+          BOOLEAN(),
+          std::vector<core::TypedExprPtr>{
+              field(columnFloatType, "c0"),
+              std::make_shared<core::ConstantTypedExpr>(
+                  makeArrayVector<T>({inlist})),
+          },
+          "in");
+      auto data = makeRowVector({
+          makeFlatVector<T>(input),
+      });
+      auto expectedResults = makeFlatVector<bool>(expected);
+      auto result = evaluate(expr, data);
+      assertEqualVectors(expectedResults, result);
+    };
+
+    testInWithConstList({kNaN, kSNaN}, {kNaN, 1}, {true, true});
+    testInWithConstList({kNaN, kSNaN}, {1, 2}, {false, false});
+    // Need to specifically test in-list with a single element as it previously
+    // had a seperate codepath.
+    testInWithConstList({kNaN, kSNaN}, {kNaN}, {true, true});
+    testInWithConstList({kNaN, kSNaN}, {1}, {false, false});
+
+    {
+      // Constant In-list, complex input(row).
+      // In-list is [row{kNaN, 1}].
+      auto inlist = makeArrayVector(
+          {0},
+          makeRowVector(
+              {makeFlatVector<T>(std::vector<T>({kNaN})),
+               makeFlatVector<int32_t>(std::vector<int32_t>({1}))}));
+      auto expr = std::make_shared<core::CallTypedExpr>(
+          BOOLEAN(),
+          std::vector<core::TypedExprPtr>{
+              field(ROW({columnFloatType, INTEGER()}), "c0"),
+              std::make_shared<core::ConstantTypedExpr>(inlist),
+          },
+          "in");
+      // Input is [row{kNaN, 1}, row{kSNaN, 1}, row{kNaN, 2}].
+      auto data = makeRowVector({makeRowVector(
+          {makeFlatVector<T>(std::vector<T>({kNaN, kSNaN, kNaN})),
+           makeFlatVector<int32_t>(std::vector<int32_t>({1, 1, 2}))})});
+      auto expectedResults = makeFlatVector<bool>({true, true, false});
+      auto result = evaluate(expr, data);
+      assertEqualVectors(expectedResults, result);
+    }
+
+    {
+      // Variable In-list, primitive input.
+      auto data = makeRowVector({
+          makeFlatVector<T>({kNaN, kSNaN, kNaN}),
+          makeFlatVector<T>({kNaN, kNaN, 0}),
+          makeFlatVector<T>({1, 1, 1}),
+      });
+      // Expression: c0 in (c1, c2)
+      auto inWithVariableInList = std::make_shared<core::CallTypedExpr>(
+          BOOLEAN(),
+          std::vector<core::TypedExprPtr>{
+              field(columnFloatType, "c0"),
+              field(columnFloatType, "c1"),
+              field(columnFloatType, "c2"),
+          },
+          "in");
+      auto expectedResults = makeFlatVector<bool>({
+          true, // kNaN in (kNaN, 1)
+          true, // kSNaN in (kNaN, 1)
+          false, // kNaN in (kNaN, 0)
+      });
+      auto result = evaluate(inWithVariableInList, data);
+      assertEqualVectors(expectedResults, result);
+    }
+
+    {
+      // Variable In-list, complex input(row).
+      // Input is:
+      // c0: [row{kNaN, 1}, row{kSNaN, 1}, row{kNaN, 2}]
+      // c1: [row{kNaN, 1}, row{kNaN, 1}, row{kNaN, 1}]
+      auto data = makeRowVector(
+          {makeRowVector(
+               {makeFlatVector<T>(std::vector<T>({kNaN, kSNaN, kNaN})),
+                makeFlatVector<int32_t>(std::vector<int32_t>({1, 1, 2}))}),
+           makeRowVector(
+               {makeFlatVector<T>(std::vector<T>({kNaN, kNaN, kNaN})),
+                makeFlatVector<int32_t>(std::vector<int32_t>({1, 1, 1}))})});
+      // Expression: c0 in (c1)
+      auto inWithVariableInList = std::make_shared<core::CallTypedExpr>(
+          BOOLEAN(),
+          std::vector<core::TypedExprPtr>{
+              field(ROW({columnFloatType, INTEGER()}), "c0"),
+              field(ROW({columnFloatType, INTEGER()}), "c1"),
+          },
+          "in");
+      auto expectedResults = makeFlatVector<bool>({true, true, false});
+      auto result = evaluate(inWithVariableInList, data);
+      assertEqualVectors(expectedResults, result);
+    }
+  }
 };
 
 TEST_F(InPredicateTest, bigint) {
@@ -447,7 +562,7 @@ TEST_F(InPredicateTest, varbinary) {
 }
 
 TEST_F(InPredicateTest, date) {
-  auto dateValue = DATE()->toDays("2000-01-01");
+  auto dateValue = parseDate("2000-01-01");
 
   auto input = makeRowVector({
       makeNullableFlatVector<int32_t>({dateValue}, DATE()),
@@ -835,6 +950,7 @@ TEST_F(InPredicateTest, arrays) {
           std::nullopt,
           {{2, 4, 5, 6}},
           {{1, std::nullopt, 2}},
+          {{1, std::nullopt}},
           {{1, 2, 3, 4}},
       }),
   });
@@ -845,6 +961,7 @@ TEST_F(InPredicateTest, arrays) {
       false,
       std::nullopt,
       false,
+      false,
       std::nullopt,
       false,
   });
@@ -856,6 +973,7 @@ TEST_F(InPredicateTest, arrays) {
       {1, std::nullopt, 2},
       {1, 2, 3},
       {},
+      {1, std::nullopt},
   });
 
   expected = makeNullableFlatVector<bool>(
@@ -863,9 +981,10 @@ TEST_F(InPredicateTest, arrays) {
        true,
        std::nullopt,
        std::nullopt,
+       false,
        std::nullopt,
        std::nullopt,
-       std::nullopt});
+       false});
   result = evaluate(makeInExpression(inValuesWithNulls), {data});
   assertEqualVectors(expected, result);
 }
@@ -915,5 +1034,91 @@ TEST_F(InPredicateTest, structs) {
   assertEqualVectors(expected, result);
 }
 
+TEST_F(InPredicateTest, nonConstantInList) {
+  auto data = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, 2, 3, 4, std::nullopt}),
+      makeNullableFlatVector<int32_t>({1, 1, 1, std::nullopt, 1}),
+      makeNullableFlatVector<int32_t>({2, 3, std::nullopt, 2, 2}),
+      makeNullableFlatVector<int32_t>({3, 5, 3, 3, 3}),
+  });
+
+  auto expected = makeNullableFlatVector<bool>({
+      true, // 1 in (1, 2, 3)
+      false, // 2 in (1, 3, 5)
+      true, // 3 in (1, null, 3)
+      std::nullopt, // 4 in (null, 2, 3)
+      std::nullopt, // null in (1, 2, 3)
+  });
+
+  auto in = std::make_shared<core::CallTypedExpr>(
+      BOOLEAN(),
+      std::vector<core::TypedExprPtr>{
+          field(INTEGER(), "c0"),
+          field(INTEGER(), "c1"),
+          field(INTEGER(), "c2"),
+          field(INTEGER(), "c3"),
+      },
+      "in");
+
+  auto result = evaluate(in, data);
+  assertEqualVectors(expected, result);
+
+  // Test with NULL elements in arrays.
+  data = makeRowVector({
+      makeNullableArrayVector<int64_t>(
+          {{{1, std::nullopt}},
+           {{1, 2}},
+           {{1, 2}},
+           std::nullopt,
+           {{1, 2}},
+           {{1, 2}},
+           {{1, std::nullopt}},
+           {std::vector<std::optional<int64_t>>{std::nullopt}}}),
+      makeNullableArrayVector<int64_t>(
+          {{1, std::nullopt},
+           {1, 3},
+           {1, 2},
+           {1, 2},
+           {1, std::nullopt},
+           {1, std::nullopt},
+           {2, std::nullopt},
+           {std::nullopt, std::nullopt}}),
+      makeNullableArrayVector<int64_t>(
+          {{1, 2},
+           {1, 3},
+           {1, 2},
+           {1, 2},
+           {1, std::nullopt},
+           {1, 2},
+           {2, std::nullopt},
+           {1, 2}}),
+  });
+  in = std::make_shared<core::CallTypedExpr>(
+      BOOLEAN(),
+      std::vector<core::TypedExprPtr>{
+          field(INTEGER(), "c0"),
+          field(INTEGER(), "c1"),
+          field(INTEGER(), "c2")},
+      "in");
+  expected = makeNullableFlatVector<bool>({
+      std::nullopt, // [1, null] in ([1, null], [1, 2])
+      false, // [1, 2] in ([1, 3], [1, 3])
+      true, // [1, 2] in ([1, 2], [1, 2])
+      std::nullopt, // null in ([1, 2], [1, 2])
+      std::nullopt, // [1, 2] in ([1, null], [1, null])
+      true, // [1, 2] in ([1, null], [1, 2])
+      false, // [1, null] in ([2, null], [2, null])
+      false, // [null] in ([null, null], [1, 2])
+  });
+  result = evaluate(in, data);
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(InPredicateTest, nans) {
+  // Ensure that NaNs with different bit patterns are treated as equal.
+  testNaNs<float>();
+  testNaNs<double>();
+}
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/JsonCastTest.cpp b/velox/functions/prestosql/tests/JsonCastTest.cpp
index fc2d90610a475..b89a14f5a1864 100644
--- a/velox/functions/prestosql/tests/JsonCastTest.cpp
+++ b/velox/functions/prestosql/tests/JsonCastTest.cpp
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "folly/Unicode.h"
 
+#include "velox/functions/prestosql/json/JsonStringUtil.h"
 #include "velox/functions/prestosql/tests/CastBaseTest.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 
@@ -21,9 +23,6 @@ using namespace facebook::velox;
 
 namespace {
 
-constexpr double kInf = std::numeric_limits<double>::infinity();
-constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
-
 template <typename T>
 using TwoDimVector = std::vector<std::vector<std::optional<T>>>;
 
@@ -36,6 +35,14 @@ using JsonNativeType = StringView;
 
 class JsonCastTest : public functions::test::CastBaseTest {
  protected:
+  template <typename TFrom>
+  void testCastToJson(
+      const TypePtr& fromType,
+      std::vector<std::optional<TFrom>> input,
+      std::vector<std::optional<JsonNativeType>> expected) {
+    return testCast<TFrom, JsonNativeType>(fromType, JSON(), input, expected);
+  }
+
   template <typename T>
   void testCastFromArray(
       const TypePtr& fromType,
@@ -45,7 +52,7 @@ class JsonCastTest : public functions::test::CastBaseTest {
     auto expectedVector =
         makeNullableFlatVector<JsonNativeType>(expected, JSON());
 
-    testCast(fromType, JSON(), arrayVector, expectedVector);
+    testCast(arrayVector, expectedVector);
   }
 
   template <typename TKey, typename TValue>
@@ -57,7 +64,7 @@ class JsonCastTest : public functions::test::CastBaseTest {
     auto expectedVector =
         makeNullableFlatVector<JsonNativeType>(expected, JSON());
 
-    testCast(fromType, JSON(), mapVector, expectedVector);
+    testCast(mapVector, expectedVector);
   }
 
   template <typename TChild1, typename TChild2, typename TChild3>
@@ -78,7 +85,7 @@ class JsonCastTest : public functions::test::CastBaseTest {
     auto expectedVector =
         makeNullableFlatVector<JsonNativeType>(expected, JSON());
 
-    testCast(fromType, JSON(), rowVector, expectedVector);
+    testCast(rowVector, expectedVector);
   }
 
   // Populates offsets and sizes buffers for making array and map vectors.
@@ -210,9 +217,8 @@ class JsonCastTest : public functions::test::CastBaseTest {
 };
 
 TEST_F(JsonCastTest, fromInteger) {
-  testCast<int64_t, JsonNativeType>(
+  testCastToJson<int64_t>(
       BIGINT(),
-      JSON(),
       {1, -3, 0, INT64_MAX, INT64_MIN, std::nullopt},
       {"1"_sv,
        "-3"_sv,
@@ -220,101 +226,237 @@ TEST_F(JsonCastTest, fromInteger) {
        "9223372036854775807"_sv,
        "-9223372036854775808"_sv,
        std::nullopt});
-  testCast<int8_t, JsonNativeType>(
+  testCastToJson<int8_t>(
       TINYINT(),
-      JSON(),
       {1, -3, 0, INT8_MAX, INT8_MIN, std::nullopt},
       {"1"_sv, "-3"_sv, "0"_sv, "127"_sv, "-128"_sv, std::nullopt});
-  testCast<int32_t, JsonNativeType>(
+  testCastToJson<int32_t>(
       INTEGER(),
-      JSON(),
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 }
 
+TEST_F(JsonCastTest, fromInvalidUtf8) {
+  auto fromBytes = [&](const std::vector<unsigned char>& bytes) {
+    std::string s;
+    s.resize(bytes.size());
+    memcpy(s.data(), bytes.data(), bytes.size());
+    return s;
+  };
+
+  auto invalidString = fromBytes({0xBF});
+
+  testCastToJson<StringView>(
+      VARCHAR(), {StringView(invalidString)}, {"\"\\uFFFD\""});
+
+  invalidString = fmt::format("head_{}_tail", fromBytes({0xBF}));
+  testCastToJson<StringView>(
+      VARCHAR(), {StringView(invalidString)}, {"\"head_\\uFFFD_tail\""});
+}
+
 TEST_F(JsonCastTest, fromVarchar) {
-  testCast<StringView, JsonNativeType>(
-      VARCHAR(),
-      JSON(),
-      {"aaa"_sv, "bbb"_sv, "ccc"_sv},
-      {R"("aaa")"_sv, R"("bbb")"_sv, R"("ccc")"_sv});
-  testCast<StringView, JsonNativeType>(
+  // Test casting from ASCII.
+  {
+    std::vector<char> asciiCharacters;
+    for (int c = 32; c < 0x80; c++) {
+      if (c != '\"' && c != '\\') {
+        asciiCharacters.push_back(c);
+      }
+    }
+    std::string asciiString = folly::join("", asciiCharacters);
+    std::string expected = fmt::format("\"{}\"", asciiString);
+    testCastToJson<StringView>(
+        VARCHAR(), {StringView(asciiString)}, {StringView(expected)});
+
+    testCastToJson<StringView>(
+        VARCHAR(),
+        {"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\"\\ ."_sv},
+        {R"("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000B\f\r\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\u001B\u001C\u001D\u001E\u001F\"\\ .")"_sv});
+  }
+
+  // Test casting from unicodes in BMP.
+  {
+    std::vector<std::string> charactersInUtf8;
+    for (int i = 0x80; i < 0x10000; i++) {
+      if (folly::utf16_code_unit_is_bmp(char16_t(i))) {
+        charactersInUtf8.push_back(folly::codePointToUtf8(char32_t(i)));
+      }
+    }
+    std::string utf8String = folly::join("", charactersInUtf8);
+    std::string expected = fmt::format("\"{}\"", utf8String);
+    testCastToJson<StringView>(
+        VARCHAR(), {StringView(utf8String)}, {StringView(expected)});
+  }
+
+  // Test casting from unicodes in supplementary planes.
+  {
+    std::vector<std::string> charactersInUtf8;
+    std::vector<std::string> charactersInUtf16;
+    for (int i = 0x10000; i < 0x110000; i++) {
+      charactersInUtf8.push_back(folly::codePointToUtf8(char32_t(i)));
+
+      std::string utf16Hex(12, '\0');
+      char* pos = utf16Hex.data();
+      testingEncodeUtf16Hex(char32_t(i), pos);
+      charactersInUtf16.push_back(utf16Hex);
+    }
+    std::string utf8String = folly::join("", charactersInUtf8);
+    std::string expected =
+        fmt::format("\"{}\"", folly::join("", charactersInUtf16));
+    testCastToJson<StringView>(
+        VARCHAR(), {StringView(utf8String)}, {StringView(expected)});
+  }
+
+  testCastToJson<StringView>(
       VARCHAR(),
-      JSON(),
-      {""_sv,
-       std::nullopt,
-       "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\"\\ ."_sv},
-      {"\"\""_sv,
-       std::nullopt,
-       R"("\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f\"\\ .")"_sv});
-  testCast<StringView, JsonNativeType>(
+      {""_sv, std::nullopt, "\xc0"_sv},
+      {"\"\""_sv, std::nullopt, R"("\uFFFD")"_sv});
+
+  testCastToJson<StringView>(
       VARCHAR(),
-      JSON(),
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 }
 
 TEST_F(JsonCastTest, fromBoolean) {
-  testCast<bool, JsonNativeType>(
+  testCastToJson<bool>(
       BOOLEAN(),
-      JSON(),
       {true, false, false, std::nullopt},
       {"true"_sv, "false"_sv, "false"_sv, std::nullopt});
-  testCast<bool, JsonNativeType>(
+  testCastToJson<bool>(
       BOOLEAN(),
-      JSON(),
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 }
 
-TEST_F(JsonCastTest, fromDouble) {
-  testCast<double, JsonNativeType>(
+TEST_F(JsonCastTest, fromDoubleAndReal) {
+  testCastToJson<double>(
       DOUBLE(),
-      JSON(),
-      {1.1, 2.0001, 10.0, 3.14e0, kNan, kInf, -kInf, std::nullopt},
+      {1.1,
+       2.0001,
+       10.0,
+       3.14e0,
+       -0.0,
+       0.00012,
+       -0.001,
+       12345.0,
+       10'000'000.0,
+       123456789.01234567,
+       kNan,
+       -kNan,
+       kInf,
+       -kInf,
+       std::nullopt},
       {"1.1"_sv,
        "2.0001"_sv,
-       "10"_sv,
+       "10.0"_sv,
        "3.14"_sv,
-       "NaN"_sv,
-       "Infinity"_sv,
-       "-Infinity"_sv,
+       "-0.0"_sv,
+       "1.2E-4"_sv,
+       "-0.001"_sv,
+       "12345.0"_sv,
+       "1.0E7"_sv,
+       "1.2345678901234567E8"_sv,
+       "\"NaN\""_sv,
+       "\"NaN\""_sv,
+       "\"Infinity\""_sv,
+       "\"-Infinity\""_sv,
        std::nullopt});
-  testCast<double, JsonNativeType>(
+  testCastToJson<float>(
+      REAL(),
+      {1.1,
+       2.0001,
+       10.0,
+       3.14e0,
+       -0.0,
+       0.00012,
+       -0.001,
+       12345.0,
+       10'000'000.0,
+       123456780.0,
+       kNan,
+       -kNan,
+       kInf,
+       -kInf,
+       std::nullopt},
+      {"1.1"_sv,
+       "2.0001"_sv,
+       "10.0"_sv,
+       "3.14"_sv,
+       "-0.0"_sv,
+       "1.2E-4"_sv,
+       "-0.001"_sv,
+       "12345.0"_sv,
+       "1.0E7"_sv,
+       "1.2345678E8"_sv,
+       "\"NaN\""_sv,
+       "\"NaN\""_sv,
+       "\"Infinity\""_sv,
+       "\"-Infinity\""_sv,
+       std::nullopt});
+
+  testCastToJson<double>(
       DOUBLE(),
-      JSON(),
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 }
 
 TEST_F(JsonCastTest, fromDate) {
-  testCast<int32_t, JsonNativeType>(
+  testCastToJson<int32_t>(
       DATE(),
-      JSON(),
       {0, 1000, -10000, std::nullopt},
-      {"1970-01-01"_sv, "1972-09-27"_sv, "1942-08-16"_sv, std::nullopt});
-  testCast<int32_t, JsonNativeType>(
+      {"\"1970-01-01\""_sv,
+       "\"1972-09-27\""_sv,
+       "\"1942-08-16\""_sv,
+       std::nullopt});
+  testCastToJson<int32_t>(
       DATE(),
-      JSON(),
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 }
 
+TEST_F(JsonCastTest, fromDecimal) {
+  testCastToJson<int64_t>(
+      DECIMAL(9, 2),
+      {123456789, -333333333, 0, 5, -9, std::nullopt},
+      {"1234567.89"_sv,
+       "-3333333.33"_sv,
+       "0.00"_sv,
+       "0.05"_sv,
+       "-0.09"_sv,
+       std::nullopt});
+  // Cannot cast long DECIMAL to JSON currently
+  VELOX_ASSERT_THROW(
+      testCastToJson<int128_t>(
+          DECIMAL(38, 5),
+          {DecimalUtil::kLongDecimalMin,
+           0,
+           DecimalUtil::kLongDecimalMax,
+           HugeInt::build(0xFFFFFFFFFFFFFFFFull, 0xFFFFFFFFFFFFFFFFull),
+           HugeInt::build(0xffff, 0xffffffffffffffff),
+           std::nullopt},
+          {"-999999999999999999999999999999999.99999",
+           "0.00000",
+           "999999999999999999999999999999999.99999",
+           "-0.00001",
+           "12089258196146291747.06175",
+           std::nullopt}),
+      "Cannot cast DECIMAL(38, 5) to JSON");
+}
+
 TEST_F(JsonCastTest, fromTimestamp) {
-  testCast<Timestamp, JsonNativeType>(
+  testCastToJson<Timestamp>(
       TIMESTAMP(),
-      JSON(),
       {Timestamp{0, 0},
        Timestamp{10000000, 0},
        Timestamp{-1, 9000},
        std::nullopt},
-      {"1970-01-01T00:00:00.000000000"_sv,
-       "1970-04-26T17:46:40.000000000"_sv,
-       "1969-12-31T23:59:59.000009000"_sv,
+      {"\"1970-01-01 00:00:00.000\""_sv,
+       "\"1970-04-26 17:46:40.000\""_sv,
+       "\"1969-12-31 23:59:59.000\""_sv,
        std::nullopt});
-  testCast<Timestamp, JsonNativeType>(
+  testCastToJson<Timestamp>(
       TIMESTAMP(),
-      JSON(),
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 }
@@ -326,6 +468,26 @@ TEST_F(JsonCastTest, fromUnknown) {
   evaluateAndVerify(UNKNOWN(), JSON(), makeRowVector({input}), expected);
 }
 
+TEST_F(JsonCastTest, toArrayOfJson) {
+  auto arrays = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "[4, 5]",
+      "[6, 7, 8]",
+  });
+
+  auto from = makeArrayVector({0, 2}, arrays);
+
+  auto to = makeArrayVector<JsonNativeType>(
+      {
+          {"[1,2,3]", "[4,5]"},
+          {"[6,7,8]"},
+      },
+      JSON());
+
+  testCast(from, to);
+  testCast(to, from);
+}
+
 TEST_F(JsonCastTest, fromArray) {
   TwoDimVector<StringView> array{
       {"red"_sv, "blue"_sv}, {std::nullopt, std::nullopt, "purple"_sv}, {}};
@@ -337,6 +499,13 @@ TEST_F(JsonCastTest, fromArray) {
       "[red,blue]", "[null,null,purple]", "[]"};
   testCastFromArray(ARRAY(JSON()), array, expectedJsonArray);
 
+  // Tests array of Timestamp elements.
+  TwoDimVector<Timestamp> arrayTimestamps{
+      {Timestamp{0, 0}, Timestamp{10000000, 0}}};
+  std::vector<std::optional<JsonNativeType>> expectedTimestamp{
+      "[\"1970-01-01 00:00:00.000\",\"1970-04-26 17:46:40.000\"]"};
+  testCastFromArray(ARRAY(TIMESTAMP()), arrayTimestamps, expectedTimestamp);
+
   // Tests array whose elements are of unknown type.
   auto arrayOfUnknownElements = makeArrayWithDictionaryElements<UnknownValue>(
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
@@ -344,22 +513,14 @@ TEST_F(JsonCastTest, fromArray) {
       ARRAY(UNKNOWN()));
   auto arrayOfUnknownElementsExpected = makeNullableFlatVector<JsonNativeType>(
       {"[null,null]", "[null,null]"}, JSON());
-  testCast(
-      ARRAY(UNKNOWN()),
-      JSON(),
-      arrayOfUnknownElements,
-      arrayOfUnknownElementsExpected);
+  testCast(arrayOfUnknownElements, arrayOfUnknownElementsExpected);
 
   // Tests array whose elements are wrapped in a dictionary.
   auto arrayOfDictElements =
       makeArrayWithDictionaryElements<int64_t>({1, -2, 3, -4, 5, -6, 7}, 2);
   auto arrayOfDictElementsExpected = makeNullableFlatVector<JsonNativeType>(
       {"[null,-6]", "[5,-4]", "[3,-2]", "[1]"}, JSON());
-  testCast(
-      ARRAY(BIGINT()),
-      JSON(),
-      arrayOfDictElements,
-      arrayOfDictElementsExpected);
+  testCast(arrayOfDictElements, arrayOfDictElementsExpected);
 
   // Tests array whose elements are json and wrapped in a dictionary.
   auto jsonArrayOfDictElements =
@@ -369,18 +530,37 @@ TEST_F(JsonCastTest, fromArray) {
           ARRAY(JSON()));
   auto jsonArrayOfDictElementsExpected = makeNullableFlatVector<JsonNativeType>(
       {"[null,f]", "[e,d]", "[c,b]", "[a]"}, JSON());
-  testCast(
-      ARRAY(JSON()),
-      JSON(),
-      jsonArrayOfDictElements,
-      jsonArrayOfDictElementsExpected);
+  testCast(jsonArrayOfDictElements, jsonArrayOfDictElementsExpected);
 
   // Tests array vector with nulls at all rows.
   auto allNullArray = makeAllNullArrayVector(5, BIGINT());
   auto allNullExpected = makeNullableFlatVector<JsonNativeType>(
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       JSON());
-  testCast(ARRAY(BIGINT()), JSON(), allNullArray, allNullExpected);
+  testCast(allNullArray, allNullExpected);
+}
+
+TEST_F(JsonCastTest, fromAllNullOrEmptyArrayOfRows) {
+  // ARRAY(CONSTANT(ROW)) with all null or empty elements.
+  auto elements =
+      BaseVector::createNullConstant(ROW({"c0"}, {VARCHAR()}), 0, pool());
+  auto data = makeArrayVector({0, 0, 0, 0}, elements, {0, 2});
+
+  auto expected = makeNullableFlatVector<JsonNativeType>(
+      {std::nullopt, "[]", std::nullopt, "[]"}, JSON());
+  testCast(data, expected);
+}
+
+TEST_F(JsonCastTest, fromAllNullOrEmptyMapOfRows) {
+  // MAP(..., CONSTANT(ROW)) with all null or empty elements.
+  auto keys = makeNullConstant(TypeKind::INTEGER, 0);
+  auto values =
+      BaseVector::createNullConstant(ROW({"c0"}, {VARCHAR()}), 0, pool());
+  auto data = makeMapVector({0, 0, 0, 0}, keys, values, {0, 2});
+
+  auto expected = makeNullableFlatVector<JsonNativeType>(
+      {std::nullopt, "{}", std::nullopt, "{}"}, JSON());
+  testCast(data, expected);
 }
 
 TEST_F(JsonCastTest, fromMap) {
@@ -402,9 +582,9 @@ TEST_F(JsonCastTest, fromMap) {
 
   // Tests map with floating-point keys.
   std::vector<std::vector<Pair<double, int64_t>>> mapDoubleKey{
-      {{4.4, std::nullopt}, {3.3, 2}}, {}};
+      {{4.4, std::nullopt}, {3.3, 2}, {10.0, 9}, {-100000000.5, 99}}, {}};
   std::vector<std::optional<JsonNativeType>> expectedDoubleKey{
-      R"({"3.3":2,"4.4":null})", "{}"};
+      R"({"-1.000000005E8":99,"10.0":9,"3.3":2,"4.4":null})", "{}"};
   testCastFromMap(MAP(DOUBLE(), BIGINT()), mapDoubleKey, expectedDoubleKey);
 
   // Tests map with boolean keys.
@@ -414,6 +594,14 @@ TEST_F(JsonCastTest, fromMap) {
       R"({"false":2,"true":null})", "{}"};
   testCastFromMap(MAP(BOOLEAN(), BIGINT()), mapBoolKey, expectedBoolKey);
 
+  // Tests map with Timestamp values.
+  std::vector<std::vector<Pair<int16_t, Timestamp>>> mapTimestamp{
+      {{3, Timestamp{0, 0}}, {4, Timestamp{0, 0}}}, {}};
+  std::vector<std::optional<JsonNativeType>> expectedTimestamp{
+      R"({"3":"1970-01-01 00:00:00.000","4":"1970-01-01 00:00:00.000"})", "{}"};
+  testCastFromMap(
+      MAP(SMALLINT(), TIMESTAMP()), mapTimestamp, expectedTimestamp);
+
   // Tests map whose values are of unknown type.
   std::vector<std::optional<StringView>> keys{
       "a"_sv, "b"_sv, "c"_sv, "d"_sv, "e"_sv, "f"_sv, "g"_sv};
@@ -436,47 +624,38 @@ TEST_F(JsonCastTest, fromMap) {
        R"({"a":null})"},
       JSON());
 
-  testCast(
-      MAP(VARCHAR(), UNKNOWN()),
-      JSON(),
-      mapOfUnknownValues,
-      mapOfUnknownValuesExpected);
+  testCast(mapOfUnknownValues, mapOfUnknownValuesExpected);
 
   // Tests map whose elements are wrapped in a dictionary.
   std::vector<std::optional<double>> values{
-      1.1e3, 2.2, 3.14e0, -4.4, std::nullopt, -6e-10, -7.7};
+      1.1e3, 2.2, 3.14e0, -4.4, std::nullopt, -0.0000000006, -7.7};
   auto mapOfDictElements = makeMapWithDictionaryElements(keys, values, 2);
 
   auto mapOfDictElementsExpected = makeNullableFlatVector<JsonNativeType>(
-      {R"({"f":-6E-10,"g":null})",
+      {R"({"f":-6.0E-10,"g":null})",
        R"({"d":-4.4,"e":null})",
        R"({"b":2.2,"c":3.14})",
-       R"({"a":1100})"},
+       R"({"a":1100.0})"},
       JSON());
-  testCast(
-      MAP(VARCHAR(), DOUBLE()),
-      JSON(),
-      mapOfDictElements,
-      mapOfDictElementsExpected);
+  testCast(mapOfDictElements, mapOfDictElementsExpected);
 
   // Tests map whose elements are json and wrapped in a dictionary.
   auto jsonMapOfDictElements =
       makeMapWithDictionaryElements(keys, values, 2, MAP(JSON(), DOUBLE()));
   auto jsonMapOfDictElementsExpected = makeNullableFlatVector<JsonNativeType>(
-      {"{f:-6E-10,g:null}", "{d:-4.4,e:null}", "{b:2.2,c:3.14}", "{a:1100}"},
+      {"{f:-6.0E-10,g:null}",
+       "{d:-4.4,e:null}",
+       "{b:2.2,c:3.14}",
+       "{a:1100.0}"},
       JSON());
-  testCast(
-      MAP(JSON(), DOUBLE()),
-      JSON(),
-      jsonMapOfDictElements,
-      jsonMapOfDictElementsExpected);
+  testCast(jsonMapOfDictElements, jsonMapOfDictElementsExpected);
 
   // Tests map vector with nulls at all rows.
   auto allNullMap = makeAllNullMapVector(5, VARCHAR(), BIGINT());
   auto allNullExpected = makeNullableFlatVector<JsonNativeType>(
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       JSON());
-  testCast(MAP(VARCHAR(), BIGINT()), JSON(), allNullMap, allNullExpected);
+  testCast(allNullMap, allNullExpected);
 }
 
 TEST_F(JsonCastTest, fromRow) {
@@ -509,6 +688,13 @@ TEST_F(JsonCastTest, fromRow) {
       child3,
       expectedJsonChild);
 
+  // Tests row whose children are Timestamps.
+  auto rowOfTimestampElements = makeRowWithDictionaryElements<Timestamp>(
+      {{Timestamp{0, 0}, Timestamp{10000000, 0}}}, ROW({TIMESTAMP()}));
+  auto rowOfTimestampElementsExpected = makeNullableFlatVector<JsonNativeType>(
+      {"[null]", "[\"1970-01-01 00:00:00.000\"]"}, JSON());
+  testCast(rowOfTimestampElements, rowOfTimestampElementsExpected);
+
   // Tests row whose children are of unknown type.
   auto rowOfUnknownChildren = makeRowWithDictionaryElements<UnknownValue>(
       {{std::nullopt, std::nullopt}, {std::nullopt, std::nullopt}},
@@ -516,22 +702,14 @@ TEST_F(JsonCastTest, fromRow) {
   auto rowOfUnknownChildrenExpected = makeNullableFlatVector<JsonNativeType>(
       {"[null,null]", "[null,null]"}, JSON());
 
-  testCast(
-      ROW({UNKNOWN(), UNKNOWN()}),
-      JSON(),
-      rowOfUnknownChildren,
-      rowOfUnknownChildrenExpected);
+  testCast(rowOfUnknownChildren, rowOfUnknownChildrenExpected);
 
   // Tests row whose children are wrapped in dictionaries.
   auto rowOfDictElements = makeRowWithDictionaryElements<int64_t>(
       {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, ROW({BIGINT(), BIGINT(), BIGINT()}));
   auto rowOfDictElementsExpected = makeNullableFlatVector<JsonNativeType>(
       {"[null,null,null]", "[2,5,8]", "[1,4,7]"}, JSON());
-  testCast(
-      ROW({BIGINT(), BIGINT(), BIGINT()}),
-      JSON(),
-      rowOfDictElements,
-      rowOfDictElementsExpected);
+  testCast(rowOfDictElements, rowOfDictElementsExpected);
 
   // Tests row whose children are json and wrapped in dictionaries.
   auto jsonRowOfDictElements = makeRowWithDictionaryElements<JsonNativeType>(
@@ -541,11 +719,7 @@ TEST_F(JsonCastTest, fromRow) {
       ROW({JSON(), JSON(), JSON()}));
   auto jsonRowOfDictElementsExpected = makeNullableFlatVector<JsonNativeType>(
       {"[null,null,null]", "[a2,b2,c2]", "[a1,b1,c1]"}, JSON());
-  testCast(
-      ROW({JSON(), JSON(), JSON()}),
-      JSON(),
-      jsonRowOfDictElements,
-      jsonRowOfDictElementsExpected);
+  testCast(jsonRowOfDictElements, jsonRowOfDictElementsExpected);
 
   // Tests row vector with nulls at all rows.
   auto allNullChild = makeAllNullFlatVector<int64_t>(5);
@@ -556,7 +730,7 @@ TEST_F(JsonCastTest, fromRow) {
   auto allNullExpected = makeNullableFlatVector<JsonNativeType>(
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
       JSON());
-  testCast(ROW({BIGINT()}), JSON(), allNullRow, allNullExpected);
+  testCast(allNullRow, allNullExpected);
 }
 
 TEST_F(JsonCastTest, fromNested) {
@@ -607,11 +781,7 @@ TEST_F(JsonCastTest, fromNested) {
   auto expectedVector =
       makeNullableFlatVector<JsonNativeType>(expected, JSON());
 
-  testCast(
-      ROW({MAP(VARCHAR(), ARRAY(BIGINT())), ARRAY(MAP(VARCHAR(), BIGINT()))}),
-      JSON(),
-      rowVector,
-      expectedVector);
+  testCast(rowVector, expectedVector);
 }
 
 TEST_F(JsonCastTest, unsupportedTypes) {
@@ -686,15 +856,6 @@ TEST_F(JsonCastTest, unsupportedTypes) {
       evaluateCast(
           MAP(JSON(), BIGINT()), JSON(), makeRowVector({invalidJsonKeyMap})),
       "Cannot cast map with null keys to JSON");
-
-  // Not allowing to cast from json to itself.
-  VELOX_ASSERT_THROW(
-      evaluateCast(
-          JSON(),
-          JSON(),
-          makeRowVector({makeNullableFlatVector<JsonNativeType>(
-              {"123"_sv, R"("abc")"_sv, ""_sv, std::nullopt}, JSON())})),
-      "(JSON vs. JSON) Attempting to cast from JSON to itself");
 }
 
 TEST_F(JsonCastTest, toVarchar) {
@@ -755,33 +916,37 @@ TEST_F(JsonCastTest, toInteger) {
       {"null"_sv, std::nullopt},
       {std::nullopt, std::nullopt});
 
-  testThrow<JsonNativeType, int8_t>(
+  testThrow<JsonNativeType>(
       JSON(),
       TINYINT(),
       {"128"_sv},
-      "Cannot cast from Json value 128 to TINYINT: Overflow during arithmetic conversion: (signed char) 128");
-  testThrow<JsonNativeType, int8_t>(
+      "The JSON number is too large or too small to fit within the requested type");
+  testThrow<JsonNativeType>(
       JSON(),
       TINYINT(),
       {"128.01"_sv},
-      "Cannot cast from Json value 128.01 to TINYINT: value is out of range [-128, 127]: 128.01");
-  testThrow<JsonNativeType, int8_t>(
+      "The JSON number is too large or too small to fit within the requested type");
+  testThrow<JsonNativeType>(
       JSON(),
       TINYINT(),
       {"-1223456"_sv},
-      "Cannot cast from Json value -1223456 to TINYINT: Negative overflow during arithmetic conversion: (signed char) -1223456");
-  testThrow<JsonNativeType, int8_t>(
+      "The JSON number is too large or too small to fit within the requested type");
+  testThrow<JsonNativeType>(
       JSON(),
       TINYINT(),
-      {"Infinity"_sv},
-      "Cannot cast from Json value Infinity to TINYINT: value is out of range [-128, 127]: inf");
-  testThrow<JsonNativeType, int8_t>(
+      {"\"Infinity\""_sv},
+      "The JSON element does not have the requested type");
+  testThrow<JsonNativeType>(
       JSON(),
       TINYINT(),
-      {"NaN"_sv},
-      "Cannot cast from Json value NaN to TINYINT: value is out of range [-128, 127]: nan");
-  testThrow<JsonNativeType, int8_t>(
-      JSON(), TINYINT(), {""_sv}, "Not a JSON input");
+      {"\"NaN\""_sv},
+      "The JSON element does not have the requested type");
+  testThrow<JsonNativeType>(JSON(), TINYINT(), {""_sv}, "no JSON found");
+  testThrow<JsonNativeType>(
+      JSON(),
+      BIGINT(),
+      {"233897314173811950000"_sv},
+      "BIGINT_ERROR: Big integer value that cannot be represented using 64 bits");
 }
 
 TEST_F(JsonCastTest, toDouble) {
@@ -795,25 +960,52 @@ TEST_F(JsonCastTest, toDouble) {
        "123"_sv,
        "true"_sv,
        "false"_sv,
+       R"("Infinity")"_sv,
+       R"("-Infinity")"_sv,
+       R"("NaN")"_sv,
+       R"("-NaN")"_sv,
+       "233897314173811950000"_sv,
        std::nullopt},
-      {1.1, 2.0001, 10.0, 0.0314, 123, 1, 0, std::nullopt});
+      {1.1,
+       2.0001,
+       10.0,
+       0.0314,
+       123,
+       1,
+       0,
+       HUGE_VAL,
+       -HUGE_VAL,
+       std::numeric_limits<double>::quiet_NaN(),
+       std::numeric_limits<double>::quiet_NaN(),
+       233897314173811950000.0,
+       std::nullopt});
   testCast<JsonNativeType, double>(
       JSON(),
       DOUBLE(),
       {"null"_sv, std::nullopt},
       {std::nullopt, std::nullopt});
 
-  testThrow<JsonNativeType, float>(
+  testThrow<JsonNativeType>(
       JSON(),
       REAL(),
       {"-1.7E+307"_sv},
-      "Cannot cast from Json value -1.7E+307 to REAL: Negative overflow during arithmetic conversion: (float) -1.7E307");
-  testThrow<JsonNativeType, float>(
+      "The JSON number is too large or too small to fit within the requested type");
+  testThrow<JsonNativeType>(
       JSON(),
       REAL(),
       {"1.7E+307"_sv},
-      "Cannot cast from Json value 1.7E+307 to REAL: Overflow during arithmetic conversion: (float) 1.7E307");
-  testThrow<JsonNativeType, float>(JSON(), REAL(), {""_sv}, "Not a JSON input");
+      "The JSON number is too large or too small to fit within the requested type");
+  testThrow<JsonNativeType>(JSON(), REAL(), {""_sv}, "no JSON found");
+  testThrow<JsonNativeType>(
+      JSON(),
+      DOUBLE(),
+      {"Infinity"_sv},
+      "The JSON document has an improper structure");
+  testThrow<JsonNativeType>(
+      JSON(),
+      DOUBLE(),
+      {"NaN"_sv},
+      "The JSON document has an improper structure");
 }
 
 TEST_F(JsonCastTest, toBoolean) {
@@ -848,18 +1040,17 @@ TEST_F(JsonCastTest, toBoolean) {
       {"null"_sv, std::nullopt},
       {std::nullopt, std::nullopt});
 
-  testThrow<JsonNativeType, bool>(
+  testThrow<JsonNativeType>(
       JSON(),
       BOOLEAN(),
       {R"("123")"_sv},
-      "Cannot cast from Json value \"123\" to BOOLEAN: Integer overflow when parsing bool (must be 0 or 1): \"123\"");
-  testThrow<JsonNativeType, bool>(
+      "The JSON element does not have the requested type");
+  testThrow<JsonNativeType>(
       JSON(),
       BOOLEAN(),
       {R"("abc")"_sv},
-      "Cannot cast from Json value \"abc\" to BOOLEAN: Invalid value for bool: \"abc\"");
-  testThrow<JsonNativeType, bool>(
-      JSON(), BOOLEAN(), {""_sv}, "Not a JSON input");
+      "The JSON element does not have the requested type");
+  testThrow<JsonNativeType>(JSON(), BOOLEAN(), {""_sv}, "no JSON found");
 }
 
 TEST_F(JsonCastTest, toArray) {
@@ -875,15 +1066,20 @@ TEST_F(JsonCastTest, toArray) {
        {{}},
        std::nullopt});
 
-  testCast(JSON(), ARRAY(VARCHAR()), data, expected);
+  testCast(data, expected);
 
   // Tests array that has null at every row.
   data = makeNullableFlatVector<JsonNativeType>(
-      {"null"_sv, "null"_sv, "null"_sv, "null"_sv, std::nullopt});
+      {"null"_sv, "null"_sv, "null"_sv, "null"_sv, std::nullopt}, JSON());
   expected = makeNullableArrayVector<int64_t>(
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 
-  testCast(JSON(), ARRAY(BIGINT()), data, expected);
+  testCast(data, expected);
+
+  data = makeNullableFlatVector<JsonNativeType>(
+      {"[233897314173811950000]"_sv}, JSON());
+  expected = makeArrayVector<double>({{233897314173811950000.0}});
+  testCast(data, expected);
 }
 
 TEST_F(JsonCastTest, toMap) {
@@ -899,7 +1095,7 @@ TEST_F(JsonCastTest, toMap) {
        {{}},
        std::nullopt});
 
-  testCast(JSON(), MAP(VARCHAR(), VARCHAR()), data, expected);
+  testCast(data, expected);
 
   // Tests map of non-string keys.
   data = makeNullableFlatVector<JsonNativeType>(
@@ -914,27 +1110,27 @@ TEST_F(JsonCastTest, toMap) {
        {{}},
        std::nullopt});
 
-  testCast(JSON(), MAP(BIGINT(), DOUBLE()), data, expected);
+  testCast(data, expected);
 
   // Tests map that has null at every row.
   data = makeNullableFlatVector<JsonNativeType>(
-      {"null"_sv, "null"_sv, "null"_sv, "null"_sv, std::nullopt});
+      {"null"_sv, "null"_sv, "null"_sv, "null"_sv, std::nullopt}, JSON());
   expected = makeNullableMapVector<StringView, int64_t>(
       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
 
-  testCast(JSON(), MAP(VARCHAR(), BIGINT()), data, expected);
+  testCast(data, expected);
 
   // Null keys or non-string keys in JSON maps are not allowed.
-  testThrow<JsonNativeType, ComplexType>(
+  testThrow<JsonNativeType>(
       JSON(),
       MAP(VARCHAR(), DOUBLE()),
       {R"({"red":1.1,"blue":2.2})"_sv, R"({null:3.3,"yellow":4.4})"_sv},
-      "Not a JSON input");
-  testThrow<JsonNativeType, ComplexType>(
+      "The JSON document has an improper structure");
+  testThrow<JsonNativeType>(
       JSON(),
       MAP(BIGINT(), DOUBLE()),
       {"{1:1.1,2:2.2}"_sv},
-      "Not a JSON input");
+      "The JSON document has an improper structure");
 }
 
 TEST_F(JsonCastTest, orderOfKeys) {
@@ -947,12 +1143,58 @@ TEST_F(JsonCastTest, orderOfKeys) {
 
   auto map = makeMapVector<std::string, JsonNativeType>(
       {
-          {{"k1", R"({"a":1,"b":2})"}},
-          {{"k2", R"({"a":10,"b":20})"}},
+          {{"k1", R"({"a": 1, "b": 2})"}},
+          {{"k2", R"({"a": 10, "b": 20})"}},
       },
       MAP(VARCHAR(), JSON()));
 
-  testCast(JSON(), MAP(VARCHAR(), JSON()), data, map);
+  testCast(data, map);
+}
+
+TEST_F(JsonCastTest, toRowOfArray) {
+  auto data = makeFlatVector<std::string>(
+      {
+          R"({"c0": [1, 2, 3], "c1": 1.2})",
+          R"({"c0": [], "c1": 1.3})",
+          R"({"c0": [10, null, 20, null], "c1": 1.4})",
+      },
+      JSON());
+
+  auto expected = makeRowVector({
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 2, 3]",
+          "[]",
+          "[10, null, 20, null]",
+      }),
+  });
+
+  testCast(data, expected);
+}
+
+TEST_F(JsonCastTest, toRowDuplicateKey) {
+  std::vector<std::optional<std::string>> jsonStrings = {
+      R"({"c0": 1, "c1": 1.1})",
+      R"({"c0": 2, "c1": 1.2, "C0": 45})", // Duplicate keys: c0, C0.
+      R"({"c0": 3, "c1": 1.3, "c0": 55})", // Duplicate keys: c0, c0.
+      R"({"c0": 4, "c1": 1.4, "c2": 65})",
+  };
+
+  testThrow<std::string>(
+      JSON(),
+      ROW({"c0", "c1"}, {INTEGER(), REAL()}),
+      jsonStrings,
+      "Duplicate field: c0");
+
+  auto data = makeNullableFlatVector<std::string>(jsonStrings, JSON());
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 0, 0, 4}),
+      makeFlatVector<float>({1.1, 0.0, 0.0, 1.4}),
+  });
+  expected->setNull(1, true);
+  expected->setNull(2, true);
+
+  testCast(data, expected, true /*try_cast*/);
 }
 
 TEST_F(JsonCastTest, toRow) {
@@ -969,20 +1211,16 @@ TEST_F(JsonCastTest, toRow) {
   auto child3 =
       makeNullableFlatVector<bool>({true, false, std::nullopt, std::nullopt});
 
-  testCast(
-      JSON(),
-      ROW({BIGINT(), VARCHAR(), BOOLEAN()}),
-      array,
-      makeRowVector({child1, child2, child3}));
+  testCast(array, makeRowVector({child1, child2, child3}));
 
   // Test casting to ROW from JSON objects.
   auto map = makeNullableFlatVector<JsonNativeType>(
-      {R"({"k1":123,"k2":"abc","k3":true})"_sv,
-       R"({"k2":"abc","k3":true,"k1":123})"_sv,
-       R"({"k1":123,"k3":true,"k1":456})"_sv,
-       R"({"k4":123,"k5":"abc","k3":false})"_sv,
-       R"({"k1":null,"k3":false})"_sv,
-       R"({"k1":null,"k3":null,"k2":null})"_sv},
+      {R"({"c0":123,"c1":"abc","c2":true})"_sv,
+       R"({"c1":"abc","c2":true,"c0":123})"_sv,
+       R"({"c10":123,"c2":true,"c0":456})"_sv,
+       R"({"c3":123,"c4":"abc","c2":false})"_sv,
+       R"({"c0":null,"c2":false})"_sv,
+       R"({"c0":null,"c2":null,"c1":null})"_sv},
       JSON());
   auto child4 = makeNullableFlatVector<int64_t>(
       {123, 123, 456, std::nullopt, std::nullopt, std::nullopt});
@@ -996,40 +1234,28 @@ TEST_F(JsonCastTest, toRow) {
   auto child6 = makeNullableFlatVector<bool>(
       {true, true, true, false, false, std::nullopt});
 
-  testCast(
-      JSON(),
-      ROW({"k1", "k2", "k3"}, {BIGINT(), VARCHAR(), BOOLEAN()}),
-      map,
-      makeRowVector({child4, child5, child6}));
+  testCast(map, makeRowVector({child4, child5, child6}));
 
   // Use a mix of lower case and upper case JSON keys.
   map = makeNullableFlatVector<JsonNativeType>(
-      {R"({"K1":123,"k2":"abc","k3":true})"_sv,
-       R"({"K2":"abc","k3":true,"k1":123})"_sv,
-       R"({"k1":123,"k3":true,"K1":456})"_sv,
-       R"({"k4":123,"K5":"abc","k3":false})"_sv,
-       R"({"k1":null,"K3":false})"_sv,
-       R"({"k1":null,"k3":null,"K2":null})"_sv},
+      {R"({"C0":123,"C1":"abc","C2":true})"_sv,
+       R"({"c1":"abc","C2":true,"c0":123})"_sv,
+       R"({"C10":123,"C2":true,"c0":456})"_sv,
+       R"({"c3":123,"C4":"abc","c2":false})"_sv,
+       R"({"c0":null,"c2":false})"_sv,
+       R"({"c0":null,"c2":null,"C1":null})"_sv},
       JSON());
-  testCast(
-      JSON(),
-      ROW({"k1", "k2", "k3"}, {BIGINT(), VARCHAR(), BOOLEAN()}),
-      map,
-      makeRowVector({child4, child5, child6}));
+  testCast(map, makeRowVector({child4, child5, child6}));
 
   // Use a mix of lower case and upper case field names in target ROW type.
-  testCast(
-      JSON(),
-      ROW({"K1", "k2", "K3"}, {BIGINT(), VARCHAR(), BOOLEAN()}),
-      map,
-      makeRowVector({child4, child5, child6}));
+  testCast(map, makeRowVector({"c0", "C1", "C2"}, {child4, child5, child6}));
 
   // Test casting to ROW from JSON null.
-  auto null = makeNullableFlatVector<JsonNativeType>({"null"_sv});
+  auto null = makeNullableFlatVector<JsonNativeType>({"null"_sv}, JSON());
   auto nullExpected = makeRowVector(ROW({BIGINT(), DOUBLE()}), 1);
   nullExpected->setNull(0, true);
 
-  testCast(JSON(), ROW({BIGINT(), DOUBLE()}), null, nullExpected);
+  testCast(null, nullExpected);
 }
 
 TEST_F(JsonCastTest, toNested) {
@@ -1042,10 +1268,11 @@ TEST_F(JsonCastTest, toNested) {
        {{{{}}}},
        {{}}});
 
-  testCast(JSON(), ARRAY(ARRAY(VARCHAR())), array, arrayExpected);
+  testCast(array, arrayExpected);
 
   auto map = makeNullableFlatVector<JsonNativeType>(
-      {R"({"1":[1.1,1.2],"2":[2,2.1]})"_sv, R"({"3":null,"4":[4.1,4.2]})"_sv});
+      {R"({"1":[1.1,1.2],"2":[2,2.1]})"_sv, R"({"3":null,"4":[4.1,4.2]})"_sv},
+      JSON());
   auto keys =
       makeNullableFlatVector<StringView>({"1"_sv, "2"_sv, "3"_sv, "4"_sv});
   auto innerArray = makeNullableArrayVector<double>(
@@ -1064,7 +1291,7 @@ TEST_F(JsonCastTest, toNested) {
       sizes,
       keys,
       innerArray);
-  testCast(JSON(), MAP(VARCHAR(), ARRAY(DOUBLE())), map, mapExpected);
+  testCast(map, mapExpected);
 }
 
 TEST_F(JsonCastTest, toArrayAndMapOfJson) {
@@ -1075,7 +1302,7 @@ TEST_F(JsonCastTest, toArrayAndMapOfJson) {
       {{"[1,2]"_sv, "[null]"_sv, "null"_sv, "\"3\""_sv}, {"[]"_sv}, {}},
       ARRAY(JSON()));
 
-  testCast(JSON(), ARRAY(JSON()), array, arrayExpected);
+  testCast(array, arrayExpected);
 
   // Test casting to map of JSON values.
   auto map = makeNullableFlatVector<JsonNativeType>(
@@ -1092,10 +1319,10 @@ TEST_F(JsonCastTest, toArrayAndMapOfJson) {
        {}},
       MAP(VARCHAR(), JSON()));
 
-  testCast(JSON(), MAP(VARCHAR(), JSON()), map, mapExpected);
+  testCast(map, mapExpected);
 
   // The type of map keys is not allowed to be JSON.
-  testThrow<JsonNativeType, ComplexType>(
+  testThrow<JsonNativeType>(
       JSON(),
       MAP(JSON(), BIGINT()),
       {R"({"k1":1})"_sv},
@@ -1103,36 +1330,36 @@ TEST_F(JsonCastTest, toArrayAndMapOfJson) {
 }
 
 TEST_F(JsonCastTest, toInvalid) {
-  testThrow<JsonNativeType, Timestamp>(
+  testThrow<JsonNativeType>(
       JSON(), TIMESTAMP(), {"null"_sv}, "Cannot cast JSON to TIMESTAMP");
-  testThrow<JsonNativeType, int32_t>(
+  testThrow<JsonNativeType>(
       JSON(), DATE(), {"null"_sv}, "Cannot cast JSON to DATE");
 
   // Casting JSON arrays to ROW type with different number of fields or
   // unmatched field order is not allowed.
-  testThrow<JsonNativeType, ComplexType>(
+  testThrow<JsonNativeType>(
       JSON(),
       ROW({VARCHAR(), DOUBLE(), BIGINT()}),
       {R"(["red",1.1])"_sv, R"(["blue",2.2])"_sv},
-      "Cannot cast a JSON array of size 2 to ROW with 3 fields");
-  testThrow<JsonNativeType, ComplexType>(
+      "The JSON element does not have the requested type");
+  testThrow<JsonNativeType>(
       JSON(),
       ROW({VARCHAR()}),
       {R"(["red",1.1])"_sv, R"(["blue",2.2])"_sv},
-      "Cannot cast a JSON array of size 2 to ROW with 1 fields");
-  testThrow<JsonNativeType, ComplexType>(
+      "The JSON element does not have the requested type");
+  testThrow<JsonNativeType>(
       JSON(),
       ROW({DOUBLE(), VARCHAR()}),
       {R"(["red",1.1])"_sv, R"(["blue",2.2])"_sv},
-      "Unable to convert string to floating point value: \"red\"");
+      "The JSON element does not have the requested type");
 
   // Casting to ROW type from JSON text other than arrays or objects are not
   // supported.
-  testThrow<JsonNativeType, ComplexType>(
+  testThrow<JsonNativeType>(
       JSON(),
       ROW({BIGINT()}),
       {R"(123)"_sv, R"(456)"_sv},
-      "Only casting from JSON array or object to ROW is supported");
+      "The JSON element does not have the requested type");
 }
 
 TEST_F(JsonCastTest, castInTry) {
@@ -1244,8 +1471,10 @@ TEST_F(JsonCastTest, tryCastFromJson) {
       {R"({"102":"2","101a":1.1})"_sv,
        R"({"103":null,"104":2859327816787296000})"_sv},
       JSON());
-  auto expectedMap =
-      makeNullableMapVector<int64_t, float>({std::nullopt, std::nullopt});
+  std::vector<std::pair<int64_t, std::optional<float>>> row;
+  row.emplace_back(103, std::nullopt);
+  row.emplace_back(104, 2859327816787296000.0f);
+  auto expectedMap = makeNullableMapVector<int64_t, float>({std::nullopt, row});
   evaluateAndVerify(
       JSON(), MAP(BIGINT(), REAL()), makeRowVector({data}), expectedMap, true);
 
diff --git a/velox/functions/prestosql/tests/JsonExtractScalarTest.cpp b/velox/functions/prestosql/tests/JsonExtractScalarTest.cpp
index 5cd98d5316147..ebfd284921033 100644
--- a/velox/functions/prestosql/tests/JsonExtractScalarTest.cpp
+++ b/velox/functions/prestosql/tests/JsonExtractScalarTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 
@@ -103,6 +104,19 @@ TEST_F(JsonExtractScalarTest, simple) {
       jsonExtractScalar(
           R"([{"k1":[{"k2": ["v1", "v2"]}]}])", "$[0].k1[0].k2[1]"),
       "v2");
+
+  // Paths without leading '$'.
+  EXPECT_EQ(jsonExtractScalar(R"({"k1":"v1"})", "k1"), "v1");
+  EXPECT_EQ(jsonExtractScalar(R"({"k1":{"k2": 999}})", "k1.k2"), "999");
+  EXPECT_EQ(jsonExtractScalar(R"([1,2])", "[0]"), "1");
+  EXPECT_EQ(jsonExtractScalar(R"({"k1":"v1"})", R"(["k1"])"), "v1");
+
+  // Paths with redundant '.'s.
+  auto json = "[1, 2, [10, 20, [100, 200, 300]]]";
+  EXPECT_EQ(jsonExtractScalar(json, "$[2][2][2]"), "300");
+  EXPECT_EQ(jsonExtractScalar(json, "$.[2].[2].[2]"), "300");
+  EXPECT_EQ(jsonExtractScalar(json, "$[2].[2].[2]"), "300");
+  EXPECT_EQ(jsonExtractScalar(json, "$[2][2].[2]"), "300");
 }
 
 TEST_F(JsonExtractScalarTest, jsonType) {
@@ -164,13 +178,28 @@ TEST_F(JsonExtractScalarTest, utf8) {
 }
 
 TEST_F(JsonExtractScalarTest, invalidPath) {
-  EXPECT_THROW(jsonExtractScalar(R"([0,1,2])", ""), VeloxUserError);
-  EXPECT_THROW(jsonExtractScalar(R"([0,1,2])", "$[]"), VeloxUserError);
-  EXPECT_THROW(jsonExtractScalar(R"([0,1,2])", "$[-1]"), VeloxUserError);
-  EXPECT_THROW(jsonExtractScalar(R"({"k1":"v1"})", "$k1"), VeloxUserError);
-  EXPECT_THROW(jsonExtractScalar(R"({"k1":"v1"})", "$.k1."), VeloxUserError);
-  EXPECT_THROW(jsonExtractScalar(R"({"k1":"v1"})", "$.k1]"), VeloxUserError);
-  EXPECT_THROW(jsonExtractScalar(R"({"k1":"v1)", "$.k1]"), VeloxUserError);
+  VELOX_ASSERT_THROW(jsonExtractScalar(R"([0,1,2])", ""), "Invalid JSON path");
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"([0,1,2])", "$[]"), "Invalid JSON path");
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"([0,1,2])", "$-1"), "Invalid JSON path");
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"({"k1":"v1"})", "$k1"), "Invalid JSON path");
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"({"k1":"v1"})", "$.k1."), "Invalid JSON path");
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"({"k1":"v1"})", "$.k1]"), "Invalid JSON path");
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"({"k1":"v1)", "$.k1]"), "Invalid JSON path");
+
+  // Paths without leading '$'.
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"([1,2])", ".[0]"), "Invalid JSON path");
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"({"k1":"v1"})", ".k1"), "Invalid JSON path");
+  VELOX_ASSERT_THROW(
+      jsonExtractScalar(R"({"k1":{"k2": 999}})", ".k1.k2"),
+      "Invalid JSON path");
 }
 
 // simdjson, like Presto java, returns the large number as-is as a string,
diff --git a/velox/functions/prestosql/tests/JsonFunctionsTest.cpp b/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
index ce8b4e1bda01b..067d374411f30 100644
--- a/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
@@ -197,10 +197,15 @@ TEST_F(JsonFunctionsTest, jsonParse) {
   EXPECT_EQ(jsonParse(R"({"k1":"v1"})"), R"({"k1":"v1"})");
   EXPECT_EQ(jsonParse(R"(["k1", "v1"])"), R"(["k1", "v1"])");
 
-  VELOX_ASSERT_THROW(jsonParse(R"({"k1":})"), "expected json value");
   VELOX_ASSERT_THROW(
-      jsonParse(R"({:"k1"})"), "json parse error on line 0 near `:\"k1\"}");
-  VELOX_ASSERT_THROW(jsonParse(R"(not_json)"), "expected json value");
+      jsonParse(R"({"k1":})"), "The JSON document has an improper structure");
+  VELOX_ASSERT_THROW(
+      jsonParse(R"({:"k1"})"), "The JSON document has an improper structure");
+  VELOX_ASSERT_THROW(jsonParse(R"(not_json)"), "Problem while parsing an atom");
+  VELOX_ASSERT_THROW(
+      jsonParse("[1"),
+      "JSON document ended early in the middle of an object or array");
+  VELOX_ASSERT_THROW(jsonParse(""), "no JSON found");
 
   EXPECT_EQ(jsonParseWithTry(R"(not_json)"), std::nullopt);
   EXPECT_EQ(jsonParseWithTry(R"({"k1":})"), std::nullopt);
@@ -223,7 +228,7 @@ TEST_F(JsonFunctionsTest, jsonParse) {
 
   VELOX_ASSERT_THROW(
       evaluate("json_parse(c0)", data),
-      "json parse error on line 0 near `:': parsing didn't consume all input");
+      "Unexpected trailing content in the JSON input");
 
   data = makeRowVector({makeFlatVector<StringView>(
       {R"("This is a long sentence")", R"("This is some other sentence")"})});
@@ -240,6 +245,17 @@ TEST_F(JsonFunctionsTest, jsonParse) {
 
   velox::test::assertEqualVectors(expected, result);
 
+  data = makeRowVector({makeFlatVector<StringView>({"233897314173811950000"})});
+  result = evaluate("json_parse(c0)", data);
+  expected = makeFlatVector<StringView>({{"233897314173811950000"}}, JSON());
+  velox::test::assertEqualVectors(expected, result);
+
+  data =
+      makeRowVector({makeFlatVector<StringView>({"[233897314173811950000]"})});
+  result = evaluate("json_parse(c0)", data);
+  expected = makeFlatVector<StringView>({{"[233897314173811950000]"}}, JSON());
+  velox::test::assertEqualVectors(expected, result);
+
   data = makeRowVector(
       {makeFlatVector<bool>({true, false}),
        makeFlatVector<StringView>(
@@ -251,6 +267,13 @@ TEST_F(JsonFunctionsTest, jsonParse) {
       {R"("This is a long sentence")", R"("This is some other sentence")"},
       JSON());
   velox::test::assertEqualVectors(expected, result);
+
+  try {
+    jsonParse(R"({"k1":})");
+    FAIL() << "Error expected";
+  } catch (const VeloxUserError& e) {
+    ASSERT_EQ(e.context(), "Top-level Expression: json_parse(c0)");
+  }
 }
 
 TEST_F(JsonFunctionsTest, isJsonScalarSignatures) {
@@ -333,6 +356,45 @@ TEST_F(JsonFunctionsTest, jsonArrayLength) {
   EXPECT_EQ(jsonArrayLength(R"({"k1":"v1"})"), std::nullopt);
   EXPECT_EQ(jsonArrayLength(R"({"k1":[0,1,2]})"), std::nullopt);
   EXPECT_EQ(jsonArrayLength(R"({"k1":[0,1,2], "k2":"v1"})"), std::nullopt);
+
+  // Malformed Json.
+  EXPECT_EQ(jsonArrayLength(R"((})"), std::nullopt);
+}
+
+TEST_F(JsonFunctionsTest, jsonArrayGet) {
+  auto arrayGet = [&](const std::string& json, int64_t index) {
+    auto r1 = evaluateOnce<std::string, std::string, int64_t>(
+        "json_array_get(c0, c1)", {JSON(), BIGINT()}, {json}, {index});
+    auto r2 = evaluateOnce<std::string, std::string, int64_t>(
+        "json_array_get(c0, c1)", {json}, {index});
+
+    EXPECT_EQ(r1, r2);
+    return r1;
+  };
+
+  EXPECT_FALSE(arrayGet("{}", 1).has_value());
+  EXPECT_FALSE(arrayGet("[]", 1).has_value());
+
+  // Malformed json.
+  EXPECT_FALSE(arrayGet("([1]})", 0).has_value());
+
+  EXPECT_EQ(arrayGet("[1, 2, 3]", 0), "1");
+  EXPECT_EQ(arrayGet("[1, 2, 3]", 1), "2");
+  EXPECT_EQ(arrayGet("[1, 2, 3]", 2), "3");
+  EXPECT_FALSE(arrayGet("[1, 2, 3]", 3).has_value());
+
+  EXPECT_EQ(arrayGet("[1, 2, 3]", -1), "3");
+  EXPECT_EQ(arrayGet("[1, 2, 3]", -2), "2");
+  EXPECT_EQ(arrayGet("[1, 2, 3]", -3), "1");
+  EXPECT_FALSE(arrayGet("[1, 2, 3]", -4).has_value());
+
+  EXPECT_EQ(arrayGet("[[1, 2], [3, 4], []]", 0), "[1, 2]");
+  EXPECT_EQ(arrayGet("[[1, 2], [3, 4], []]", 2), "[]");
+
+  EXPECT_EQ(arrayGet("[{\"foo\": 123}, {\"foo\": 456}]", 1), "{\"foo\": 456}");
+
+  EXPECT_FALSE(arrayGet("[1, 2, ...", 1).has_value());
+  EXPECT_FALSE(arrayGet("not json", 1).has_value());
 }
 
 TEST_F(JsonFunctionsTest, jsonArrayContainsBool) {
@@ -387,12 +449,16 @@ TEST_F(JsonFunctionsTest, jsonArrayContainsBigint) {
   EXPECT_EQ(
       jsonArrayContains<int64_t>(R"("thefoxjumpedoverthefence")", 1),
       std::nullopt);
+
   EXPECT_EQ(jsonArrayContains<int64_t>(R"("")", 1), std::nullopt);
   EXPECT_EQ(jsonArrayContains<int64_t>(R"(true)", 1), std::nullopt);
   EXPECT_EQ(
       jsonArrayContains<int64_t>(R"({"k1":[0,1,2], "k2":"v1"})", 1),
       std::nullopt);
 
+  EXPECT_EQ(jsonArrayContains<int64_t>(R"([1, 2, 3,...)", 2), std::nullopt);
+  EXPECT_EQ(jsonArrayContains<int64_t>(R"([1, 2, 3,...)", 5), std::nullopt);
+
   EXPECT_EQ(jsonArrayContains<int64_t>(R"([1, 2, 3])", 1), true);
   EXPECT_EQ(jsonArrayContains<int64_t>(R"([1, 2, 3])", 4), false);
   EXPECT_EQ(
@@ -438,6 +504,13 @@ TEST_F(JsonFunctionsTest, jsonArrayContainsDouble) {
       jsonArrayContains<double>(R"({"k1":[0,1,2], "k2":"v1"})", 2.3),
       std::nullopt);
 
+  static const double kNan = std::numeric_limits<double>::quiet_NaN();
+  static const double kInf = std::numeric_limits<double>::infinity();
+  EXPECT_EQ(jsonArrayContains<double>(R"([1.1, 2.2, 3.3])", kNan), false);
+  EXPECT_EQ(jsonArrayContains<double>(R"([1.1, 2.2, 3.3])", kInf), false);
+  EXPECT_EQ(jsonArrayContains<double>(R"([1.1, 2.2, 3.3...)", kNan), false);
+  EXPECT_EQ(jsonArrayContains<double>(R"([1.1, 2.2, 3.3...)", kInf), false);
+
   EXPECT_EQ(jsonArrayContains<double>(R"([1.2, 2.3, 3.4])", 2.3), true);
   EXPECT_EQ(jsonArrayContains<double>(R"([1.2, 2.3, 3.4])", 2.4), false);
   EXPECT_EQ(
@@ -522,6 +595,14 @@ TEST_F(JsonFunctionsTest, jsonArrayContainsString) {
       true);
 }
 
+TEST_F(JsonFunctionsTest, jsonArrayContainsMalformed) {
+  auto [jsonVector, _] = makeVectors(R"([]})");
+  EXPECT_EQ(
+      evaluateOnce<bool>(
+          "json_array_contains(c0, 'a')", makeRowVector({jsonVector})),
+      std::nullopt);
+}
+
 TEST_F(JsonFunctionsTest, jsonSize) {
   EXPECT_EQ(jsonSize(R"({"k1":{"k2": 999}, "k3": 1})", "$.k1.k2"), 0);
   EXPECT_EQ(jsonSize(R"({"k1":{"k2": 999}, "k3": 1})", "$.k1"), 1);
@@ -541,7 +622,7 @@ TEST_F(JsonFunctionsTest, jsonSize) {
 TEST_F(JsonFunctionsTest, invalidPath) {
   VELOX_ASSERT_THROW(jsonSize(R"([0,1,2])", ""), "Invalid JSON path");
   VELOX_ASSERT_THROW(jsonSize(R"([0,1,2])", "$[]"), "Invalid JSON path");
-  VELOX_ASSERT_THROW(jsonSize(R"([0,1,2])", "$[-1]"), "Invalid JSON path");
+  VELOX_ASSERT_THROW(jsonSize(R"([0,1,2])", "$-1"), "Invalid JSON path");
   VELOX_ASSERT_THROW(jsonSize(R"({"k1":"v1"})", "$k1"), "Invalid JSON path");
   VELOX_ASSERT_THROW(jsonSize(R"({"k1":"v1"})", "$.k1."), "Invalid JSON path");
   VELOX_ASSERT_THROW(jsonSize(R"({"k1":"v1"})", "$.k1]"), "Invalid JSON path");
@@ -558,18 +639,26 @@ TEST_F(JsonFunctionsTest, jsonExtract) {
   };
 
   EXPECT_EQ(
-      "{\"x\": {\"a\" : 1, \"b\" : 2} }",
-      jsonExtract("{\"x\": {\"a\" : 1, \"b\" : 2} }", "$"));
+      R"({"x": {"a" : 1, "b" : 2} })",
+      jsonExtract(R"({"x": {"a" : 1, "b" : 2} })", "$"));
   EXPECT_EQ(
-      "{\"a\" : 1, \"b\" : 2}",
-      jsonExtract("{\"x\": {\"a\" : 1, \"b\" : 2} }", "$.x"));
-  EXPECT_EQ("1", jsonExtract("{\"x\": {\"a\" : 1, \"b\" : 2} }", "$.x.a"));
+      R"({"a" : 1, "b" : 2})",
+      jsonExtract(R"({"x": {"a" : 1, "b" : 2} })", "$.x"));
+  EXPECT_EQ("1", jsonExtract(R"({"x": {"a" : 1, "b" : 2} })", "$.x.a"));
   EXPECT_EQ(
-      std::nullopt, jsonExtract("{\"x\": {\"a\" : 1, \"b\" : 2} }", "$.x.c"));
+      std::nullopt, jsonExtract(R"({"x": {"a" : 1, "b" : 2} })", "$.x.c"));
+  EXPECT_EQ("3", jsonExtract(R"({"x": {"a" : 1, "b" : [2, 3]} })", "$.x.b[1]"));
   EXPECT_EQ(
-      "3", jsonExtract("{\"x\": {\"a\" : 1, \"b\" : [2, 3]} }", "$.x.b[1]"));
-  EXPECT_EQ("2", jsonExtract("[1,2,3]", "$[1]"));
-  EXPECT_EQ("null", jsonExtract("[1,null,3]", "$[1]"));
+      "1", jsonExtract(R"({"x": {"a" : 1, "b" : 2} })", R"($['x']["a"])"));
+
+  EXPECT_EQ("2", jsonExtract("[1, 2, 3]", "$[1]"));
+  EXPECT_EQ("null", jsonExtract("[1, null, 3]", "$[1]"));
+  EXPECT_EQ(std::nullopt, jsonExtract("[1, 2, 3]", "$[10]"));
+
+  EXPECT_EQ("3", jsonExtract("[1, 2, 3]", "$[-1]"));
+  EXPECT_EQ("null", jsonExtract("[1, null, 3]", "$[-2]"));
+  EXPECT_EQ(std::nullopt, jsonExtract("[1, 2, 3]", "$[-10]"));
+
   EXPECT_EQ(std::nullopt, jsonExtract("INVALID_JSON", "$"));
   VELOX_ASSERT_THROW(jsonExtract("{\"\":\"\"}", ""), "Invalid JSON path");
 
@@ -578,6 +667,30 @@ TEST_F(JsonFunctionsTest, jsonExtract) {
       jsonExtract(kJson, "$.store.book[*].isbn"));
   EXPECT_EQ("\"Evelyn Waugh\"", jsonExtract(kJson, "$.store.book[1].author"));
 
+  // Paths without leading '$'.
+  auto json = R"({"x": {"a": 1, "b": [10, 11, 12]} })";
+  EXPECT_EQ(R"({"a": 1, "b": [10, 11, 12]})", jsonExtract(json, "x"));
+  EXPECT_EQ("1", jsonExtract(json, "x.a"));
+  EXPECT_EQ("[10, 11, 12]", jsonExtract(json, "x.b"));
+  EXPECT_EQ("12", jsonExtract(json, "x.b[2]"));
+  EXPECT_EQ(std::nullopt, jsonExtract(json, "x.c"));
+  EXPECT_EQ(std::nullopt, jsonExtract(json, "x.b[20]"));
+
+  // Paths with redundant '.'s.
+  json = R"([[[{"a": 1, "b": [1, 2, 3]}]]])";
+  EXPECT_EQ("1", jsonExtract(json, "$.[0][0][0].a"));
+  EXPECT_EQ("[1, 2, 3]", jsonExtract(json, "$.[0].[0].[0].b"));
+  EXPECT_EQ("[1, 2, 3]", jsonExtract(json, "$[0][0].[0].b"));
+  EXPECT_EQ("3", jsonExtract(json, "$[0][0][0].b.[2]"));
+  EXPECT_EQ("3", jsonExtract(json, "$.[0].[0][0].b.[2]"));
+
+  // Definite vs. non-definite paths.
+  EXPECT_EQ("[123]", jsonExtract(R"({"a": [{"b": 123}]})", "$.a[*].b"));
+  EXPECT_EQ("123", jsonExtract(R"({"a": [{"b": 123}]})", "$.a[0].b"));
+
+  EXPECT_EQ("[]", jsonExtract(R"({"a": [{"b": 123}]})", "$.a[*].c"));
+  EXPECT_EQ(std::nullopt, jsonExtract(R"({"a": [{"b": 123}]})", "$.a[0].c"));
+
   // TODO The following paths are supported by Presto via Jayway, but do not
   // work in Velox yet. Figure out how to add support for these.
   VELOX_ASSERT_THROW(jsonExtract(kJson, "$..price"), "Invalid JSON path");
diff --git a/velox/functions/prestosql/tests/MapEntriesTest.cpp b/velox/functions/prestosql/tests/MapEntriesTest.cpp
index c97ba1969e1af..a152a0a7e7007 100644
--- a/velox/functions/prestosql/tests/MapEntriesTest.cpp
+++ b/velox/functions/prestosql/tests/MapEntriesTest.cpp
@@ -43,22 +43,27 @@ TEST_F(MapEntriesTest, basic) {
       [](vector_size_t row) { return row % 11; },
       nullEvery(13));
 
-  auto result = evaluate<ArrayVector>("map_entries(C0)", makeRowVector({map}));
+  auto result = evaluate("map_entries(C0)", makeRowVector({map}));
   ASSERT_EQ(size, result->size());
-
-  auto resultKeys = result->elements()->as<RowVector>()->childAt(0);
-  auto resultValues = result->elements()->as<RowVector>()->childAt(1);
+  DecodedVector decodedArray(*result);
+  auto base = decodedArray.base()->as<ArrayVector>();
+  auto resultKeys = base->elements()->as<RowVector>()->childAt(0);
+  auto resultValues = base->elements()->as<RowVector>()->childAt(1);
   for (auto i = 0; i < size; i++) {
     auto isNull = map->isNullAt(i);
     ASSERT_EQ(isNull, result->isNullAt(i)) << "at " << i;
     if (!isNull) {
       auto mapSize = map->sizeAt(i);
-      ASSERT_EQ(mapSize, result->sizeAt(i)) << "at " << i;
+      ASSERT_EQ(mapSize, base->sizeAt(decodedArray.index(i))) << "at " << i;
       for (auto j = 0; j < mapSize; j++) {
         ASSERT_TRUE(map->mapKeys()->equalValueAt(
-            resultKeys.get(), map->offsetAt(i) + j, result->offsetAt(i) + j));
+            resultKeys.get(),
+            map->offsetAt(i) + j,
+            base->offsetAt(decodedArray.index(i)) + j));
         ASSERT_TRUE(map->mapValues()->equalValueAt(
-            resultValues.get(), map->offsetAt(i) + j, result->offsetAt(i) + j));
+            resultValues.get(),
+            map->offsetAt(i) + j,
+            base->offsetAt(decodedArray.index(i)) + j));
       }
     }
   }
@@ -157,3 +162,35 @@ TEST_F(MapEntriesTest, outputSizeIsBoundBySelectedRows) {
 
   ASSERT_EQ(results[0]->size(), 5);
 }
+
+TEST_F(MapEntriesTest, differentSizedValueKeyVectors) {
+  auto keyVector =
+      makeNullableFlatVector<int64_t>({1, 2, 3, 4, std::nullopt, std::nullopt});
+  auto valueVector = makeFlatVector<int64_t>({1, 2, 3, 4});
+
+  auto offsetBuffer = makeIndices({3, 2, 1, 0});
+  auto sizeBuffer = makeIndices({1, 1, 1, 1});
+
+  auto mapVector = std::make_shared<MapVector>(
+      pool(),
+      MAP(BIGINT(), BIGINT()),
+      nullptr,
+      4,
+      offsetBuffer,
+      sizeBuffer,
+      keyVector,
+      valueVector);
+
+  mapVector->validate({});
+  auto rowVector = makeRowVector({mapVector});
+
+  auto result = evaluate("map_entries(c0)", rowVector);
+
+  EXPECT_NE(result, nullptr);
+  auto elementVector = makeRowVector(
+      {makeFlatVector<int64_t>({4, 3, 2, 1}),
+       makeFlatVector<int64_t>({4, 3, 2, 1})});
+  auto arrayVector = makeArrayVector({0, 1, 2, 3}, elementVector);
+
+  test::assertEqualVectors(arrayVector, result);
+}
diff --git a/velox/functions/prestosql/tests/MapFilterTest.cpp b/velox/functions/prestosql/tests/MapFilterTest.cpp
index 42be9f2e81f78..ec8e89ebcec76 100644
--- a/velox/functions/prestosql/tests/MapFilterTest.cpp
+++ b/velox/functions/prestosql/tests/MapFilterTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
@@ -73,8 +74,7 @@ TEST_F(MapFilterTest, filter) {
   auto data = std::static_pointer_cast<RowVector>(
       BatchMaker::createBatch(rowType, 1'000, *execCtx_.pool()));
 
-  auto result = evaluate<BaseVector>(
-      "map_filter(map_val, (k, v) -> (k > long_val))", data);
+  auto result = evaluate("map_filter(map_val, (k, v) -> (k > long_val))", data);
   auto* cutoff = data->childAt(0)->as<SimpleVector<int64_t>>();
   checkMapFilter<SimpleVector<int64_t>, SimpleVector<int32_t>>(
       data->childAt(1).get(),
@@ -119,7 +119,7 @@ TEST_F(MapFilterTest, dictionaryWithUniqueValues) {
   // Wrap the input in a dictionary.
   BufferPtr indices = makeIndicesInReverse(data->size());
   data->childAt(1) = wrapInDictionary(indices, data->size(), data->childAt(1));
-  auto result = evaluate<BaseVector>(
+  auto result = evaluate(
       "map_filter(map_filter(map_val, (k, v) -> (k > long_val)), (k, v) -> (v > 0))",
       data);
   auto* cutoff = data->childAt(0)->as<SimpleVector<int64_t>>();
@@ -140,7 +140,7 @@ TEST_F(MapFilterTest, dictionaryWithUniqueValues) {
 
   // Wrap both inputs in the same dictionary.
   data->childAt(0) = wrapInDictionary(indices, data->size(), data->childAt(0));
-  result = evaluate<BaseVector>(
+  result = evaluate(
       "map_filter(map_filter(map_val, (k, v) -> (k > long_val)), (k, v) -> (v > 0))",
       data);
   cutoff = data->childAt(0)->as<SimpleVector<int64_t>>();
@@ -154,7 +154,7 @@ TEST_F(MapFilterTest, conditional) {
   auto data = std::static_pointer_cast<RowVector>(
       BatchMaker::createBatch(rowType, 1'000, *execCtx_.pool()));
 
-  auto result = evaluate<BaseVector>(
+  auto result = evaluate(
       "map_filter(map_val, "
       "  if (long_val < 0, (k, v) -> (v < long_val), (k, v) -> (k > long_val)))",
       data);
@@ -205,13 +205,13 @@ TEST_F(MapFilterTest, dictionaryWithDuplicates) {
 
   auto input = makeRowVector({capture, map});
 
-  auto result = evaluate<BaseVector>(
-      "map_filter(c1, (k, v) -> ((k + v + c0) % 7 < 3))", input);
+  auto result =
+      evaluate("map_filter(c1, (k, v) -> ((k + v + c0) % 7 < 3))", input);
 
   auto flatMap = flatten(map);
   input = makeRowVector({capture, flatMap});
-  auto expectedResult = evaluate<BaseVector>(
-      "map_filter(c1, (k, v) -> ((k + v + c0) % 7 < 3))", input);
+  auto expectedResult =
+      evaluate("map_filter(c1, (k, v) -> ((k + v + c0) % 7 < 3))", input);
 
   assertEqualVectors(expectedResult, result);
 }
@@ -260,13 +260,18 @@ TEST_F(MapFilterTest, try) {
       }),
   });
 
-  ASSERT_THROW(
-      evaluate<BaseVector>("map_filter(c0, (k, v) -> (v / k > 0))", data),
-      std::exception);
+  VELOX_ASSERT_THROW(
+      evaluate("map_filter(c0, (k, v) -> (v / k > 0))", data),
+      "division by zero");
 
-  auto result =
-      evaluate<BaseVector>("try(map_filter(c0, (k, v) -> (v / k > 0)))", data);
+  auto result = evaluate("try(map_filter(c0, (k, v) -> (v / k > 0)))", data);
   auto expected = makeNullableMapVector<int64_t, int64_t>(
       {{{{1, 2}, {2, 3}}}, std::nullopt, {{{7, 8}}}, {{}}});
   assertEqualVectors(expected, result);
 }
+
+TEST_F(MapFilterTest, unknown) {
+  auto data = makeRowVector({makeAllNullMapVector(10, UNKNOWN(), BIGINT())});
+  auto result = evaluate("map_filter(c0, (k, v) -> (v > 5))", data);
+  assertEqualVectors(data->childAt(0), result);
+}
diff --git a/velox/functions/prestosql/tests/MapFromEntriesTest.cpp b/velox/functions/prestosql/tests/MapFromEntriesTest.cpp
index 262dec10f1af6..adf14fd87b58d 100644
--- a/velox/functions/prestosql/tests/MapFromEntriesTest.cpp
+++ b/velox/functions/prestosql/tests/MapFromEntriesTest.cpp
@@ -295,6 +295,8 @@ TEST_F(MapFromEntriesTest, arrayOfDictionaryRowOfNulls) {
   RowVectorPtr rowVector =
       makeRowVector({makeFlatVector<int32_t>(0), makeFlatVector<int32_t>(0)});
   rowVector->resize(4);
+  rowVector->childAt(0)->resize(0);
+  rowVector->childAt(1)->resize(0);
   for (int i = 0; i < rowVector->size(); i++) {
     rowVector->setNull(i, true);
   }
@@ -330,7 +332,8 @@ TEST_F(MapFromEntriesTest, arrayOfConstantRowOfNulls) {
       makeRowVector({makeFlatVector<int32_t>(0), makeFlatVector<int32_t>(0)});
   rowVector->resize(1);
   rowVector->setNull(0, true);
-
+  rowVector->childAt(0)->resize(0);
+  rowVector->childAt(1)->resize(0);
   EXPECT_EQ(rowVector->childAt(0)->size(), 0);
   EXPECT_EQ(rowVector->childAt(1)->size(), 0);
 
@@ -440,3 +443,34 @@ TEST_F(MapFromEntriesTest, nullRowEntriesWithSmallerChildren) {
       BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool()),
       result);
 }
+
+TEST_F(MapFromEntriesTest, allTopLevelNullsCornerCase) {
+  // Test a corner case where the input of mapFromEntries is an array with
+  // array at row 0 : [(null), (null)]
+  // array at row 1 : []
+  // And the function is evaluated only at row 1.
+
+  auto keys = makeNullableFlatVector<int32_t>({});
+  auto values = makeNullableFlatVector<int32_t>({});
+  auto rowVector = makeRowVector({keys, values});
+
+  EXPECT_EQ(rowVector->size(), 0);
+  rowVector->appendNulls(2);
+
+  EXPECT_EQ(rowVector->size(), 2);
+  EXPECT_EQ(rowVector->childAt(0)->size(), 0);
+  EXPECT_EQ(rowVector->childAt(1)->size(), 0);
+
+  // Array at row 0 is [(null), (null)]
+  // Array at row 1 is []
+  auto arrayVector = makeArrayVector({0, 2}, rowVector);
+
+  SelectivityVector rows(2);
+  rows.setValid(0, false);
+
+  auto result =
+      evaluate("map_from_entries(c0)", makeRowVector({arrayVector}), rows);
+  result->validate();
+  auto expected = makeMapVectorFromJson<int32_t, int32_t>({"{}", "{}"});
+  assertEqualVectors(expected, result);
+}
diff --git a/velox/functions/prestosql/tests/MapKeysAndValuesTest.cpp b/velox/functions/prestosql/tests/MapKeysAndValuesTest.cpp
index ab022db2ac342..45d44070c92f0 100644
--- a/velox/functions/prestosql/tests/MapKeysAndValuesTest.cpp
+++ b/velox/functions/prestosql/tests/MapKeysAndValuesTest.cpp
@@ -29,15 +29,16 @@ class MapKeysAndValuesTest : public FunctionBaseTest {
       MapVectorPtr mapVector,
       VectorPtr mapKeys,
       vector_size_t row,
-      ArrayVectorPtr result,
+      DecodedVector& decodedArray,
+      const ArrayVector* result,
       VectorPtr resultElements) {
     auto size = mapVector->sizeAt(row);
-    EXPECT_EQ(size, result->sizeAt(row)) << "at " << row;
+    EXPECT_EQ(size, result->sizeAt(decodedArray.index(row))) << "at " << row;
     for (vector_size_t j = 0; j < size; j++) {
       EXPECT_TRUE(mapKeys->equalValueAt(
           resultElements->wrappedVector(),
           mapVector->offsetAt(row) + j,
-          result->offsetAt(row) + j));
+          result->offsetAt(decodedArray.index(row)) + j));
     }
   }
 
@@ -49,50 +50,22 @@ class MapKeysAndValuesTest : public FunctionBaseTest {
     auto mapVector = makeMapVector<int32_t, int64_t>(
         numRows_, sizeAt, keyAt, valueAt, isNullAt);
 
-    auto result = evaluate<ArrayVector>(expression, makeRowVector({mapVector}));
+    auto result = evaluate(expression, makeRowVector({mapVector}));
+    DecodedVector decodedArray(*result);
+    auto baseArray = decodedArray.base()->as<ArrayVector>();
     ASSERT_EQ(result->typeKind(), TypeKind::ARRAY);
 
     auto expected = expectedFunc(mapVector);
 
-    auto resultElements = result->elements();
-    ASSERT_TRUE(resultElements->type()->kindEquals(expected->type()));
+    auto baseArrayElements = baseArray->elements();
+    ASSERT_TRUE(baseArrayElements->type()->kindEquals(expected->type()));
 
-    EXPECT_EQ(numRows_, result->size());
+    EXPECT_EQ(numRows_, decodedArray.size());
     for (vector_size_t i = 0; i < numRows_; ++i) {
-      EXPECT_EQ(result->isNullAt(i), mapVector->isNullAt(i)) << "at " << i;
+      EXPECT_EQ(decodedArray.isNullAt(i), mapVector->isNullAt(i)) << "at " << i;
       if (!mapVector->isNullAt(i)) {
-        checkResult(mapVector, expected, i, result, resultElements);
-      }
-    }
-  }
-
-  void testConstantMap(
-      const std::string& expression,
-      std::function<vector_size_t(vector_size_t /* row */)> sizeAt,
-      std::function<bool(vector_size_t /*row */)> isNullAt,
-      std::function<VectorPtr(MapVectorPtr /*mapVector*/)> expectedFunc) {
-    auto mapVector = makeMapVector<int32_t, int64_t>(
-        numRows_, sizeAt, keyAt, valueAt, isNullAt);
-
-    auto result = evaluate<ConstantVector<ComplexType>>(
-        expression, makeRowVector({mapVector}));
-    ASSERT_EQ(result->typeKind(), TypeKind::ARRAY);
-
-    auto expected = expectedFunc(mapVector);
-    if (result->isNullAt(0)) {
-      EXPECT_EQ(0, expected->size());
-      return;
-    }
-    auto array = std::dynamic_pointer_cast<ArrayVector>(
-        result->as<ConstantVector<ComplexType>>()->valueVector());
-    auto elements = array->elements();
-    ASSERT_TRUE(elements->type()->kindEquals(expected->type()));
-
-    EXPECT_EQ(numRows_, result->size());
-    for (vector_size_t i = 0; i < elements->size(); ++i) {
-      EXPECT_EQ(result->isNullAt(i), mapVector->isNullAt(i)) << "at " << i;
-      if (!mapVector->isNullAt(i)) {
-        checkResult(mapVector, expected, i, array, elements);
+        checkResult(
+            mapVector, expected, i, decodedArray, baseArray, baseArrayElements);
       }
     }
   }
@@ -109,26 +82,30 @@ class MapKeysAndValuesTest : public FunctionBaseTest {
     auto c =
         makeFlatVector<int32_t>(numRows_, [](vector_size_t i) { return i; });
 
-    auto result = evaluate<ArrayVector>(expression, makeRowVector({c, a, b}));
+    auto result = evaluate(expression, makeRowVector({c, a, b}));
+    DecodedVector decodedArray(*result);
+    auto baseArray = decodedArray.base()->as<ArrayVector>();
     ASSERT_EQ(result->typeKind(), TypeKind::ARRAY);
 
     auto aExpected = expectedFunc(a);
     auto bExpected = expectedFunc(b);
 
-    auto resultElements = result->elements();
-    ASSERT_TRUE(result->type()->childAt(0)->kindEquals(aExpected->type()));
+    auto baseArrayElements = baseArray->elements();
+    ASSERT_TRUE(baseArray->type()->childAt(0)->kindEquals(aExpected->type()));
 
-    EXPECT_EQ(numRows_, result->size());
+    EXPECT_EQ(numRows_, decodedArray.size());
     for (vector_size_t i = 0; i < numRows_; ++i) {
       if (i % 2 == 0) {
-        EXPECT_EQ(result->isNullAt(i), a->isNullAt(i)) << "at " << i;
-        if (!result->isNullAt(i)) {
-          checkResult(a, aExpected, i, result, resultElements);
+        EXPECT_EQ(decodedArray.isNullAt(i), a->isNullAt(i)) << "at " << i;
+        if (!decodedArray.isNullAt(i)) {
+          checkResult(
+              a, aExpected, i, decodedArray, baseArray, baseArrayElements);
         }
       } else {
-        EXPECT_EQ(result->isNullAt(i), b->isNullAt(i)) << "at " << i;
-        if (!result->isNullAt(i)) {
-          checkResult(b, bExpected, i, result, resultElements);
+        EXPECT_EQ(decodedArray.isNullAt(i), b->isNullAt(i)) << "at " << i;
+        if (!decodedArray.isNullAt(i)) {
+          checkResult(
+              b, bExpected, i, decodedArray, baseArray, baseArrayElements);
         }
       }
     }
@@ -157,7 +134,7 @@ class MapKeysTest : public MapKeysAndValuesTest {
   void testConstantMapKeys(
       std::function<vector_size_t(vector_size_t /* row */)> sizeAt,
       std::function<bool(vector_size_t /*row */)> isNullAt) {
-    testConstantMap("map_keys(C0)", sizeAt, isNullAt, mapKeys);
+    testMap("map_keys(C0)", sizeAt, isNullAt, mapKeys);
   }
 
   void testMapKeysPartiallyPopulated(
@@ -187,7 +164,7 @@ class MapValuesTest : public MapKeysAndValuesTest {
   void testConstantMapValues(
       std::function<vector_size_t(vector_size_t /* row */)> sizeAt,
       std::function<bool(vector_size_t /*row */)> isNullAt) {
-    testConstantMap("map_values(C0)", sizeAt, isNullAt, mapValues);
+    testMap("map_values(C0)", sizeAt, isNullAt, mapValues);
   }
 
   void testMapValuesPartiallyPopulated(
@@ -270,6 +247,17 @@ TEST_F(MapKeysTest, constant) {
   test::assertEqualVectors(expected, result);
 }
 
+TEST_F(MapKeysTest, unknown) {
+  auto keys = makeFlatVector<UnknownValue>({}, UNKNOWN());
+  auto values = makeFlatVector<UnknownValue>({}, UNKNOWN());
+  auto map = makeMapVector({0, 0, 0}, keys, values);
+
+  auto result = evaluate("map_keys(c0)", makeRowVector({map}));
+  auto expected = makeArrayVector({0, 0, 0}, keys);
+
+  test::assertEqualVectors(expected, result);
+}
+
 TEST_F(MapValuesTest, noNulls) {
   auto sizeAt = [](vector_size_t row) { return row % 7; };
   testMapValues(sizeAt, nullptr);
@@ -355,3 +343,14 @@ TEST_F(MapValuesTest, noDictionaryReceived) {
   auto expected = makeArrayVector<int64_t>({{100, 200}, {100, 200}});
   test::assertEqualVectors(expected, result);
 }
+
+TEST_F(MapValuesTest, unknown) {
+  auto keys = makeFlatVector<UnknownValue>({}, UNKNOWN());
+  auto values = makeFlatVector<UnknownValue>({}, UNKNOWN());
+  auto map = makeMapVector({0, 0, 0}, keys, values);
+
+  auto result = evaluate("map_values(c0)", makeRowVector({map}));
+  auto expected = makeArrayVector({0, 0, 0}, values);
+
+  test::assertEqualVectors(expected, result);
+}
diff --git a/velox/functions/prestosql/tests/MapNormalizeTest.cpp b/velox/functions/prestosql/tests/MapNormalizeTest.cpp
new file mode 100644
index 0000000000000..db3eb39029354
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapNormalizeTest.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapNormalizeTest : public test::FunctionBaseTest {};
+
+TEST_F(MapNormalizeTest, basic) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<std::string, double>({
+          "{\"a\": 1.0, \"b\": 2.0, \"c\": 2.0}",
+          "{\"a\": 2.0, \"b\": 2.0, \"c\": null, \"d\": 1.0}",
+          "{\"a\": 1.0, \"b\": -1.0, \"c\": null, \"d\": 0.0}",
+          "{\"a\": null, \"b\": null}",
+          "{}",
+      }),
+  });
+
+  auto result = evaluate("map_normalize(c0)", data);
+
+  auto expected = makeMapVectorFromJson<std::string, double>({
+      "{\"a\": 0.2, \"b\": 0.4, \"c\": 0.4}",
+      "{\"a\": 0.4, \"b\": 0.4, \"c\": null, \"d\": 0.2}",
+      "{\"a\": Infinity, \"b\": -Infinity, \"c\": null, \"d\": NaN}",
+      "{\"a\": null, \"b\": null}",
+      "{}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapRemoveNullValuesTest.cpp b/velox/functions/prestosql/tests/MapRemoveNullValuesTest.cpp
new file mode 100644
index 0000000000000..5ec46a4ca6b3e
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapRemoveNullValuesTest.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapRemoveNullValuesTest : public test::FunctionBaseTest {};
+
+TEST_F(MapRemoveNullValuesTest, general) {
+  // bigint key
+  auto data = makeRowVector({makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:4, 2:5, 3:6}",
+      "{-1:null, -2:5, -3:null}",
+      "{}",
+      "null",
+  })});
+
+  auto result = evaluate("map_remove_null_values(c0)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>(
+      {"{1:4, 2:5, 3:6}", "{-2:5}", "{}", "null"});
+
+  assertEqualVectors(expected, result);
+
+  // string key
+  data = makeRowVector({makeMapVectorFromJson<std::string, std::string>({
+      "{\"ad\":null, \"bc\":null, \"cd\":null}",
+  })});
+
+  result = evaluate("map_remove_null_values(c0)", data);
+
+  expected = makeMapVectorFromJson<std::string, std::string>({"{}"});
+
+  assertEqualVectors(expected, result);
+
+  // empty input map
+  data =
+      makeRowVector({makeMapVectorFromJson<std::string, std::string>({"{}"})});
+  expected = makeMapVectorFromJson<std::string, std::string>({"{}"});
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapSubsetTest.cpp b/velox/functions/prestosql/tests/MapSubsetTest.cpp
new file mode 100644
index 0000000000000..8d120003d6397
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapSubsetTest.cpp
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapSubsetTest : public test::FunctionBaseTest {
+ public:
+  template <typename T>
+  void testFloatNaNs() {
+    static const auto kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const auto kSNaN = std::numeric_limits<T>::signaling_NaN();
+
+    // Case 1: Non-constant search keys.
+    auto data = makeRowVector(
+        {makeMapVectorFromJson<T, int32_t>({
+             "{1:10, NaN:20, 3:null, 4:40, 5:50, 6:60}",
+             "{NaN:20}",
+         }),
+         makeArrayVector<T>({{1, kNaN, 5}, {kSNaN, 3}})});
+
+    auto expected = makeMapVectorFromJson<T, int32_t>({
+        "{1:10, NaN:20, 5:50}",
+        "{NaN:20}",
+    });
+    auto result = evaluate("map_subset(c0, c1)", data);
+    assertEqualVectors(expected, result);
+
+    // Case 2: Constant search keys.
+    data = makeRowVector(
+        {makeMapVectorFromJson<T, int32_t>({
+             "{1:10, NaN:20, 3:null, 4:40, 5:50, 6:60}",
+             "{NaN:20}",
+         }),
+         BaseVector::wrapInConstant(2, 0, makeArrayVector<T>({{1, kNaN, 5}}))});
+    expected = makeMapVectorFromJson<T, int32_t>({
+        "{1:10, NaN:20, 5:50}",
+        "{NaN:20}",
+    });
+    result = evaluate("map_subset(c0, c1)", data);
+    assertEqualVectors(expected, result);
+
+    // Case 3: Map with Complex type as key.
+    // Map: { [{1, NaN,3}: 1, {4, 5}: 2], [{NaN, 3}: 3, {1, 2}: 4] }
+    data = makeRowVector({
+        makeMapVector(
+            {0, 2},
+            makeArrayVector<T>({{1, kNaN, 3}, {4, 5}, {kSNaN, 3}, {1, 2}}),
+            makeFlatVector<int32_t>({1, 2, 3, 4})),
+        makeNestedArrayVectorFromJson<T>({
+            "[[1, NaN, 3], [4, 5]]",
+            "[[1, 2, 3], [NaN, 3]]",
+        }),
+    });
+    expected = makeMapVector(
+        {0, 2},
+        makeArrayVectorFromJson<T>({
+            "[1, NaN, 3]",
+            "[4, 5]",
+            "[NaN, 3]",
+        }),
+        makeFlatVector<int32_t>({1, 2, 3}));
+
+    result = evaluate("map_subset(c0, c1)", data);
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(MapSubsetTest, bigintKey) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:null, 4:40, 5:50, 6:60}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{}",
+          "{2:20, 4:40, 6:60}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 3, 5]",
+          "[1, 3, 5, 7]",
+          "[3, 5]",
+          "[1, 3]",
+      }),
+  });
+
+  // Constant keys.
+  auto result = evaluate("map_subset(c0, array_constructor(1, 3, 5))", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 3:null, 5:50}",
+      "{1:10, 5:50}",
+      "{}",
+      "{}",
+  });
+
+  assertEqualVectors(expected, result);
+
+  // Non-constant keys.
+  result = evaluate("map_subset(c0, c1)", data);
+  assertEqualVectors(expected, result);
+
+  // Empty list of keys. Expect empty maps.
+  result = evaluate("map_subset(c0, array_constructor()::bigint[])", data);
+
+  expected = makeMapVectorFromJson<int64_t, int32_t>({"{}", "{}", "{}", "{}"});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetTest, varcharKey) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<std::string, int32_t>({
+          "{\"apple\": 1, \"banana\": 2, \"Cucurbitaceae\": null, \"date\": 4, \"eggplant\": 5, \"fig\": 6}",
+          "{\"banana\": 2, \"orange\": 4}",
+          "{\"banana\": 2, \"fig\": 4, \"date\": 5}",
+      }),
+      makeArrayVectorFromJson<std::string>({
+          "[\"apple\", \"Cucurbitaceae\", \"fig\"]",
+          "[\"apple\", \"Cucurbitaceae\", \"date\", \"eggplant\"]",
+          "[\"fig\"]",
+      }),
+  });
+
+  // Constant keys.
+  auto result = evaluate(
+      "map_subset(c0, array_constructor('apple', 'some very looooong name', 'fig', 'Cucurbitaceae'))",
+      data);
+
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      "{\"apple\": 1, \"Cucurbitaceae\": null, \"fig\": 6}",
+      "{}",
+      "{\"fig\": 4}",
+  });
+
+  assertEqualVectors(expected, result);
+
+  // Non-constant keys.
+  result = evaluate("map_subset(c0, c1)", data);
+  assertEqualVectors(expected, result);
+
+  // Empty list of keys. Expect empty maps.
+  result = evaluate("map_subset(c0, array_constructor()::varchar[])", data);
+
+  expected = makeMapVectorFromJson<std::string, int32_t>({"{}", "{}", "{}"});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetTest, arrayKey) {
+  auto data = makeRowVector({
+      makeMapVector(
+          {0, 2},
+          makeArrayVectorFromJson<int32_t>({
+              "[1, 2, 3]",
+              "[4, 5]",
+              "[]",
+              "[1, 2]",
+          }),
+          makeFlatVector<std::string>(
+              {"apple", "orange", "Cucurbitaceae", "date"})),
+      makeNestedArrayVectorFromJson<int32_t>({
+          "[[1, 2, 3], [4, 5, 6]]",
+          "[[1, 2, 3], []]",
+      }),
+  });
+
+  auto result = evaluate("map_subset(c0, c1)", data);
+
+  auto expected = makeMapVector(
+      {0, 1},
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[]",
+      }),
+      makeFlatVector<std::string>({"apple", "Cucurbitaceae"}));
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapSubsetTest, floatNaNs) {
+  testFloatNaNs<float>();
+  testFloatNaNs<double>();
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapTest.cpp b/velox/functions/prestosql/tests/MapTest.cpp
index 0b72a62b00f6f..4113b4c5d1666 100644
--- a/velox/functions/prestosql/tests/MapTest.cpp
+++ b/velox/functions/prestosql/tests/MapTest.cpp
@@ -25,7 +25,62 @@ using namespace facebook::velox::functions::test;
 
 namespace {
 
-class MapTest : public FunctionBaseTest {};
+class MapTest : public FunctionBaseTest {
+ public:
+  template <typename T>
+  void testFloatingPointCornerCases() {
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kSNaN = std::numeric_limits<T>::signaling_NaN();
+    auto values = makeNullableArrayVector<int32_t>({{1, 2, 3, 4, 5, 6}});
+    auto checkDuplicate = [&](VectorPtr& keys, std::string expectedError) {
+      VELOX_ASSERT_THROW(
+          evaluate("map(c0, c1)", makeRowVector({keys, values})),
+          expectedError);
+
+      ASSERT_NO_THROW(
+          evaluate("try(map(c0, c1))", makeRowVector({keys, values})));
+
+      // Trying the map version with allowing duplicates.
+      functions::prestosql::registerMapAllowingDuplicates("map2");
+      ASSERT_NO_THROW(evaluate("map2(c0, c1)", makeRowVector({keys, values})));
+    };
+    // Case 1: Check for duplicate NaNs with the same binary representation.
+    VectorPtr keysIdenticalNaNs =
+        makeNullableArrayVector<T>({{1, 2, kNaN, 4, 5, kNaN}});
+    checkDuplicate(
+        keysIdenticalNaNs, "Duplicate map keys (NaN) are not allowed");
+    // Case 2: Check for duplicate NaNs with different binary representation.
+    VectorPtr keysDifferentNaNs =
+        makeNullableArrayVector<T>({{1, 2, kNaN, 4, 5, kSNaN}});
+    checkDuplicate(
+        keysDifferentNaNs, "Duplicate map keys (NaN) are not allowed");
+    // Case 3: Check for duplicate NaNs when the keys vector is a constant. This
+    // is to ensure the code path for constant keys is exercised.
+    VectorPtr keysConstant =
+        BaseVector::wrapInConstant(1, 0, keysDifferentNaNs);
+    checkDuplicate(keysConstant, "Duplicate map keys (NaN) are not allowed");
+    // Case 4: Check for duplicate NaNs when the keys vector wrapped in a
+    // dictionary.
+    VectorPtr keysInDictionary =
+        wrapInDictionary(makeIndices(1, folly::identity), keysDifferentNaNs);
+    checkDuplicate(
+        keysInDictionary, "Duplicate map keys (NaN) are not allowed");
+    // Case 5: Check for equality of +0.0 and -0.0.
+    VectorPtr keysDifferentZeros =
+        makeNullableArrayVector<T>({{1, 2, -0.0, 4, 5, 0.0}});
+    checkDuplicate(
+        keysDifferentZeros, "Duplicate map keys (0) are not allowed");
+
+    // Case 6: Check for duplicate NaNs nested inside a complex key.
+    VectorPtr arrayOfRows = makeArrayVector(
+        {0},
+        makeRowVector(
+            {makeFlatVector<T>({1, 2, kNaN, 4, 5, kSNaN}),
+             makeFlatVector<int32_t>({1, 2, 3, 4, 5, 3})}));
+    checkDuplicate(
+        arrayOfRows, "Duplicate map keys ({NaN, 3}) are not allowed");
+  }
+};
 
 TEST_F(MapTest, noNulls) {
   auto size = 1'000;
@@ -59,6 +114,36 @@ TEST_F(MapTest, someNulls) {
   assertEqualVectors(expectedMap, result);
 }
 
+TEST_F(MapTest, nullWithNonZeroSizes) {
+  auto keys = makeArrayVectorFromJson<int32_t>({
+      "[1, 2, 3]",
+      "[1, 2]",
+      "[1, 2, 3]",
+  });
+
+  auto values = makeArrayVectorFromJson<int64_t>({
+      "[10, 20, 30]",
+      "[11, 21]",
+      "[12, 22, 32]",
+  });
+
+  // Set null for one of the rows. Also, set offset and size for the row to
+  // values that exceed the size of the 'elements' vector.
+  keys->setNull(1, true);
+  keys->setOffsetAndSize(1, 100, 10);
+  values->setNull(1, true);
+  values->setOffsetAndSize(1, 100, 10);
+
+  auto result = evaluate("map(c0, c1)", makeRowVector({keys, values}));
+
+  auto expected = makeMapVectorFromJson<int32_t, int64_t>({
+      "{1: 10, 2: 20, 3: 30}",
+      "null",
+      "{1: 12, 2: 22, 3: 32}",
+  });
+  assertEqualVectors(expected, result);
+}
+
 TEST_F(MapTest, partiallyPopulated) {
   auto size = 1'000;
 
@@ -140,6 +225,11 @@ TEST_F(MapTest, duplicateKeys) {
   ASSERT_NO_THROW(evaluate("map2(c0, c1)", makeRowVector({keys, values})));
 }
 
+TEST_F(MapTest, floatingPointCornerCases) {
+  testFloatingPointCornerCases<float>();
+  testFloatingPointCornerCases<double>();
+}
+
 TEST_F(MapTest, fewerValuesThanKeys) {
   auto size = 1'000;
 
@@ -390,4 +480,21 @@ TEST_F(MapTest, nestedNullInKeys) {
       "map key cannot be indeterminate");
 }
 
+TEST_F(MapTest, unknownType) {
+  // MAP(ARRAY[], ARRAY[])
+  auto emptyArrayVector = makeArrayVector<UnknownValue>({{}});
+  auto expectedMap = makeMapVector<UnknownValue, UnknownValue>({{}});
+  auto result = evaluate(
+      "map(c0, c1)", makeRowVector({emptyArrayVector, emptyArrayVector}));
+  assertEqualVectors(expectedMap, result);
+
+  // MAP(ARRAY[null], ARRAY[null])
+  auto elementVector = makeNullableFlatVector<UnknownValue>({std::nullopt});
+  auto nullArrayVector = makeArrayVector({0}, elementVector);
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "map(c0, c1)", makeRowVector({nullArrayVector, nullArrayVector})),
+      "map key cannot be null");
+}
+
 } // namespace
diff --git a/velox/functions/prestosql/tests/MapTopNKeysTest.cpp b/velox/functions/prestosql/tests/MapTopNKeysTest.cpp
new file mode 100644
index 0000000000000..8699fb9e5cdea
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapTopNKeysTest.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapTopNKeysTest : public test::FunctionBaseTest {};
+
+TEST_F(MapTopNKeysTest, emptyMap) {
+  RowVectorPtr input = makeRowVector({
+      makeMapVectorFromJson<int32_t, int64_t>({
+          "{}",
+      }),
+  });
+
+  assertEqualVectors(
+      evaluate("map_top_n_keys(c0, 3)", input),
+      makeArrayVectorFromJson<int32_t>({
+          "[]",
+      }));
+}
+
+TEST_F(MapTopNKeysTest, multipleMaps) {
+  RowVectorPtr input = makeRowVector({
+      makeMapVectorFromJson<int32_t, int64_t>({
+          "{3:1, 2:1, 5:1, 4:1, 1:1}",
+          "{3:1, 2:1, 1:1}",
+          "{2:1, 1:1}",
+      }),
+  });
+
+  assertEqualVectors(
+      evaluate("map_top_n_keys(c0, 3)", input),
+      makeArrayVectorFromJson<int32_t>({
+          "[5, 4, 3]",
+          "[3, 2, 1]",
+          "[2, 1]",
+      }));
+}
+
+TEST_F(MapTopNKeysTest, nIsZero) {
+  RowVectorPtr input = makeRowVector({
+      makeMapVectorFromJson<int32_t, int64_t>({
+          "{2:1, 1:1}",
+      }),
+  });
+
+  assertEqualVectors(
+      evaluate("map_top_n_keys(c0, 0)", input),
+      makeArrayVectorFromJson<int32_t>({"[]"}));
+}
+
+TEST_F(MapTopNKeysTest, nIsNegative) {
+  RowVectorPtr input = makeRowVector({
+      makeMapVectorFromJson<int32_t, int64_t>({
+          "{2:1, 1:1}",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_top_n_keys(c0, -1)", input),
+      "n must be greater than or equal to 0");
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapTopNTest.cpp b/velox/functions/prestosql/tests/MapTopNTest.cpp
new file mode 100644
index 0000000000000..ca3e758e7884c
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapTopNTest.cpp
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapTopNTest : public test::FunctionBaseTest {};
+
+TEST_F(MapTopNTest, basic) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int32_t, int64_t>({
+          "{1:3, 2:5, 3:1, 4:4, 5:2}",
+          "{1:3, 2:5, 3:null, 4:4, 5:2}",
+          "{1:null, 2:null, 3:1, 4:4, 5:null}",
+          "{1:10, 2:7, 3:11, 5:4}",
+          "{1:10, 2:7, 3:0}",
+          "{1:null, 2:10}",
+          "{}",
+          "{1:null, 2:null, 3:null}",
+      }),
+  });
+
+  auto result = evaluate("map_top_n(c0, 3)", data);
+
+  auto expected = makeMapVectorFromJson<int32_t, int64_t>({
+      "{2:5, 4:4, 1:3}",
+      "{2:5, 4:4, 1:3}",
+      "{4:4, 3:1, 5:null}",
+      "{3:11, 1:10, 2:7}",
+      "{1:10, 2:7, 3:0}",
+      "{2:10, 1:null}",
+      "{}",
+      "{1:null, 2:null, 3:null}",
+  });
+
+  assertEqualVectors(expected, result);
+
+  // n = 0. Expect empty maps.
+  result = evaluate("map_top_n(c0, 0)", data);
+
+  expected = makeMapVectorFromJson<int32_t, int64_t>(
+      {"{}", "{}", "{}", "{}", "{}", "{}", "{}", "{}"});
+
+  assertEqualVectors(expected, result);
+
+  // n is negative. Expect an error.
+  VELOX_ASSERT_THROW(
+      evaluate("map_top_n(c0, -1)", data),
+      "n must be greater than or equal to 0");
+}
+
+// Test to ensure we use keys to break ties if values are
+// equal.
+TEST_F(MapTopNTest, equalValues) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int32_t, int64_t>(
+          {"{6:3, 2:5, 3:1, 4:4, 5:2, 1:3}",
+           "{1:3, 2:5, 3:null, 4:4, 5:2, 6:5 }",
+           "{5:null, 2:null, 3:1, 4:4, 1:null}",
+           "{1:null, 5:null, 3:null, 4:null, 2:null}"}),
+  });
+
+  auto result = evaluate("map_top_n(c0, 3)", data);
+
+  auto expected = makeMapVectorFromJson<int32_t, int64_t>(
+      {"{2:5, 4:4, 6:3}",
+       "{6:5, 2:5, 4:4}",
+       "{4:4, 3:1, 5:null}",
+       "{4:null, 3:null, 5:null}"});
+
+  assertEqualVectors(expected, result);
+
+  // Map vector with equal array's as values.
+  auto valuesVector = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "[4, 5, 6]",
+      "[-1, -2, -3]",
+      "[1, 2, 3]",
+  });
+
+  auto keysVector = makeFlatVector<int32_t>({1, 2, 3, 4});
+
+  auto mapvector = makeMapVector({0, 4}, keysVector, valuesVector);
+
+  result = evaluate("map_top_n(c0, 3)", makeRowVector({mapvector}));
+
+  auto expectedValues = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "[4, 5, 6]",
+      "[1, 2, 3]",
+  });
+
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2, 4});
+
+  auto expectedResults = makeMapVector({0, 3}, expectedKeys, expectedValues);
+
+  assertEqualVectors(expectedResults, result);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MultimapFromEntriesTest.cpp b/velox/functions/prestosql/tests/MultimapFromEntriesTest.cpp
new file mode 100644
index 0000000000000..1404c3fe55687
--- /dev/null
+++ b/velox/functions/prestosql/tests/MultimapFromEntriesTest.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MultimapFromEntriesTest : public test::FunctionBaseTest {};
+
+TEST_F(MultimapFromEntriesTest, basic) {
+  auto row = [](std::vector<variant>&& inputs) {
+    return variant::row(std::move(inputs));
+  };
+
+  auto input = makeArrayOfRowVector(
+      ROW({INTEGER(), VARCHAR()}),
+      {
+          // No duplicate keys.
+          {row({1, "red"}), row({2, "blue"}), row({3, "green"})},
+          // Some duplicate keys.
+          {row({1, "pink"}),
+           row({1, "red"}),
+           row({2, "blue"}),
+           row({2, variant::null(TypeKind::VARCHAR)}),
+           row({2, "lightblue"}),
+           row({3, "green"})},
+          // Empty array.
+          {},
+      });
+
+  auto result = evaluate("multimap_from_entries(c0)", makeRowVector({input}));
+
+  auto expectedKeys = makeFlatVector<int32_t>({1, 2, 3, 1, 2, 3});
+  auto expectedValues = makeNullableArrayVector<std::string>({
+      {"red"},
+      {"blue"},
+      {"green"},
+      {"pink", "red"},
+      {"blue", std::nullopt, "lightblue"},
+      {"green"},
+  });
+
+  auto expectedMap = makeMapVector({0, 3, 6}, expectedKeys, expectedValues);
+  assertEqualVectors(expectedMap, result);
+}
+
+TEST_F(MultimapFromEntriesTest, nullKey) {
+  auto row = [](std::vector<variant>&& inputs) {
+    return variant::row(std::move(inputs));
+  };
+
+  auto input = makeArrayOfRowVector(
+      ROW({INTEGER(), VARCHAR()}),
+      {
+          {
+              row({1, "red"}),
+              row({variant::null(TypeKind::INTEGER), "blue"}),
+              row({3, "green"}),
+          },
+      });
+
+  VELOX_ASSERT_THROW(
+      evaluate("multimap_from_entries(c0)", makeRowVector({input})),
+      "map key cannot be null");
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ProbabilityTest.cpp b/velox/functions/prestosql/tests/ProbabilityTest.cpp
index 124f0edd2347b..5cb4329ad3757 100644
--- a/velox/functions/prestosql/tests/ProbabilityTest.cpp
+++ b/velox/functions/prestosql/tests/ProbabilityTest.cpp
@@ -28,8 +28,6 @@ constexpr double kDoubleMax = std::numeric_limits<double>::max();
 constexpr double kDoubleMin = std::numeric_limits<double>::min();
 constexpr int64_t kBigIntMax = std::numeric_limits<int64_t>::max();
 constexpr int64_t kBigIntMin = std::numeric_limits<int64_t>::min();
-constexpr int32_t kIntMax = std::numeric_limits<int32_t>::max();
-constexpr int32_t kIntMin = std::numeric_limits<int32_t>::min();
 
 MATCHER(IsNan, "is NaN") {
   return arg && std::isnan(*arg);
@@ -400,7 +398,6 @@ TEST_F(ProbabilityTest, gammaCDF) {
 
 TEST_F(ProbabilityTest, poissonCDF) {
   poissonCDFTests<int32_t>();
-  poissonCDFTests<int64_t>();
 }
 
 TEST_F(ProbabilityTest, binomialCDF) {
@@ -408,5 +405,205 @@ TEST_F(ProbabilityTest, binomialCDF) {
   binomialCDFTests<int64_t>();
 }
 
+TEST_F(ProbabilityTest, weibullCDF) {
+  const auto weibullCDF = [&](std::optional<double> a,
+                              std::optional<double> b,
+                              std::optional<double> value) {
+    return evaluateOnce<double>("weibull_cdf(c0, c1, c2)", a, b, value);
+  };
+
+  EXPECT_EQ(weibullCDF(1.0, 1.0, 0.0), 0.0);
+  EXPECT_EQ(weibullCDF(1.0, 1.0, 40.0), 1.0);
+  EXPECT_EQ(weibullCDF(1.0, 0.6, 3.0), 0.99326205300091452);
+  EXPECT_EQ(weibullCDF(1.0, 0.9, 2.0), 0.89163197677810413);
+
+  EXPECT_EQ(weibullCDF(std::nullopt, 1.0, 0.3), std::nullopt);
+  EXPECT_EQ(weibullCDF(1.0, std::nullopt, 0.2), std::nullopt);
+  EXPECT_EQ(weibullCDF(1.0, 0.4, std::nullopt), std::nullopt);
+
+  EXPECT_EQ(weibullCDF(kDoubleMin, 1.0, 2.0), 0.63212055882855767);
+  EXPECT_EQ(weibullCDF(kDoubleMax, 1.0, 3.0), 1.0);
+  EXPECT_EQ(weibullCDF(1.0, kDoubleMin, 2.0), 1.0);
+  EXPECT_EQ(weibullCDF(1.0, kDoubleMax, 3.0), 1.668805393880401e-308);
+  EXPECT_EQ(weibullCDF(kInf, 1.0, 3.0), 1.0);
+  EXPECT_EQ(weibullCDF(1.0, kInf, 20.0), 0.0);
+  EXPECT_EQ(weibullCDF(kDoubleMin, kDoubleMin, 1.0), 0.63212055882855767);
+  EXPECT_EQ(weibullCDF(kDoubleMax, kDoubleMax, 4.0), 0.0);
+  EXPECT_EQ(weibullCDF(kDoubleMax, kDoubleMin, kInf), 1.0);
+  EXPECT_EQ(weibullCDF(kInf, kInf, 10.0), 0.0);
+  EXPECT_EQ(weibullCDF(1.0, 1.0, kInf), 1.0);
+  EXPECT_EQ(weibullCDF(99999999999999, 999999999999999, kInf), 1.0);
+  EXPECT_EQ(weibullCDF(kInf, 1.0, 40.0), 1.0);
+  EXPECT_EQ(weibullCDF(1.0, kInf, 10.0), 0.0);
+  EXPECT_THAT(weibullCDF(1.0, 0.5, kNan), IsNan());
+  EXPECT_THAT(weibullCDF(99999999999999.0, 999999999999999.0, kNan), IsNan());
+
+  VELOX_ASSERT_THROW(
+      weibullCDF(kNan, kNan, kDoubleMin), "a must be greater than 0");
+  VELOX_ASSERT_THROW(weibullCDF(0, 3, 0.5), "a must be greater than 0");
+  VELOX_ASSERT_THROW(weibullCDF(3, 0, 0.5), "b must be greater than 0");
+  VELOX_ASSERT_THROW(weibullCDF(kNan, 3.0, 0.5), "a must be greater than 0");
+  VELOX_ASSERT_THROW(weibullCDF(3.0, kNan, 0.5), "b must be greater than 0");
+  VELOX_ASSERT_THROW(weibullCDF(-1.0, 1.0, 30.0), "a must be greater than 0");
+  VELOX_ASSERT_THROW(weibullCDF(1.0, -1.0, 40.0), "b must be greater than 0");
+  VELOX_ASSERT_THROW(
+      weibullCDF(kNan, kDoubleMin, kDoubleMax), "a must be greater than 0");
+  VELOX_ASSERT_THROW(
+      weibullCDF(kDoubleMin, kNan, kDoubleMax), "b must be greater than 0");
+}
+
+TEST_F(ProbabilityTest, inverseNormalCDF) {
+  const auto inverseNormalCDF = [&](std::optional<double> mean,
+                                    std::optional<double> sd,
+                                    std::optional<double> p) {
+    return evaluateOnce<double>("inverse_normal_cdf(c0, c1, c2)", mean, sd, p);
+  };
+
+  EXPECT_EQ(inverseNormalCDF(0, 1, 0.3), -0.52440051270804089);
+  EXPECT_EQ(inverseNormalCDF(10, 9, 0.9), 21.533964089901406);
+  EXPECT_EQ(inverseNormalCDF(0.5, 0.25, 0.65), 0.59633011660189195);
+  EXPECT_EQ(inverseNormalCDF(0, 1, 0.00001), -4.2648907939226017);
+
+  EXPECT_EQ(inverseNormalCDF(kDoubleMin, 0.25, 0.65), 0.096330116601891919);
+  EXPECT_EQ(inverseNormalCDF(kDoubleMax, 0.25, 0.65), 1.7976931348623157e+308);
+  EXPECT_EQ(inverseNormalCDF(0.5, kDoubleMin, 0.65), 0.5);
+  EXPECT_THAT(inverseNormalCDF(0.5, kDoubleMax, 0.65), IsInf());
+  EXPECT_THAT(inverseNormalCDF(kNan, 2, 0.1985), IsNan());
+
+  EXPECT_EQ(inverseNormalCDF(std::nullopt, 1, 1), std::nullopt);
+  EXPECT_EQ(inverseNormalCDF(1, 1, std::nullopt), std::nullopt);
+  EXPECT_EQ(inverseNormalCDF(std::nullopt, 1, std::nullopt), std::nullopt);
+  EXPECT_EQ(
+      inverseNormalCDF(std::nullopt, std::nullopt, std::nullopt), std::nullopt);
+
+  EXPECT_THAT(inverseNormalCDF(kInf, 1, 0.1985), IsInf());
+  EXPECT_THAT(inverseNormalCDF(0, kInf, 0.1985), IsInf());
+  EXPECT_THAT(inverseNormalCDF(-kInf, 1, 0.1985), IsInf());
+
+  // Test invalid inputs.
+  VELOX_ASSERT_THROW(
+      inverseNormalCDF(0, -kInf, 0.1985), "standardDeviation must be > 0");
+  VELOX_ASSERT_THROW(inverseNormalCDF(0, 1, kInf), "p must be 0 > p > 1");
+  VELOX_ASSERT_THROW(inverseNormalCDF(0, 1, -kInf), "p must be 0 > p > 1");
+
+  VELOX_ASSERT_THROW(
+      inverseNormalCDF(0, kNan, 0.1985), "standardDeviation must be > 0");
+  VELOX_ASSERT_THROW(inverseNormalCDF(0, 1, kNan), "p must be 0 > p > 1");
+  VELOX_ASSERT_THROW(inverseNormalCDF(kNan, kNan, kNan), "p must be 0 > p > 1");
+
+  VELOX_ASSERT_THROW(inverseNormalCDF(0, 1, kDoubleMax), "p must be 0 > p > 1");
+  VELOX_ASSERT_THROW(
+      inverseNormalCDF(0, 1, kDoubleMin),
+      "Error in function boost::math::erf_inv<double>(double, double): Overflow Error");
+
+  VELOX_ASSERT_THROW(
+      inverseNormalCDF(0, 0, 0.1985), "standardDeviation must be > 0");
+  VELOX_ASSERT_THROW(inverseNormalCDF(0, 1, 1.00001), "p must be 0 > p > 1");
+}
+
+TEST_F(ProbabilityTest, inverseWeibullCDF) {
+  const auto inverseWeibullCDF = [&](std::optional<double> a,
+                                     std::optional<double> b,
+                                     std::optional<double> p) {
+    return evaluateOnce<double>("inverse_weibull_cdf(c0, c1, c2)", a, b, p);
+  };
+
+  const auto roundToTwoDecimals = [](double value) {
+    return round(value * 100) / 100.0;
+  };
+
+  EXPECT_EQ(inverseWeibullCDF(1.0, 1.0, 0.), 0.0);
+  EXPECT_EQ(
+      roundToTwoDecimals(inverseWeibullCDF(1.0, 1.0, 0.632).value()), 1.00);
+  EXPECT_EQ(
+      roundToTwoDecimals(inverseWeibullCDF(1.0, 0.6, 0.91).value()), 1.44);
+
+  VELOX_ASSERT_THROW(
+      inverseWeibullCDF(1.0, 1.0, kNan), "p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      inverseWeibullCDF(999999999.9, 999999999.0, kInf),
+      "p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      inverseWeibullCDF(3, 5, -0.1), "p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      inverseWeibullCDF(3, 5, 1.1), "p must be in the interval [0, 1]");
+
+  EXPECT_EQ(inverseWeibullCDF(kDoubleMin, 1.0, 0.3), 0.0);
+  EXPECT_EQ(inverseWeibullCDF(kDoubleMax, 1.0, 0.4), 1.0);
+  EXPECT_EQ(inverseWeibullCDF(kInf, 999999999.9, 0.4), 9.999999999E8);
+  EXPECT_EQ(inverseWeibullCDF(kInf, 1.0, 0.1), 1.0);
+  EXPECT_EQ(inverseWeibullCDF(kDoubleMin, kDoubleMin, 0.9), kInf);
+  EXPECT_EQ(inverseWeibullCDF(kDoubleMax, kDoubleMax, 0.8), kDoubleMax);
+  VELOX_ASSERT_THROW(
+      inverseWeibullCDF(kNan, 1.0, 0.1), "a must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseWeibullCDF(-1.0, 1.0, 0.1), "a must be greater than 0");
+  VELOX_ASSERT_THROW(inverseWeibullCDF(0, 3, 0.5), "a must be greater than 0");
+
+  EXPECT_EQ(inverseWeibullCDF(1.0, kDoubleMin, 0.5), 1.5423036715619055e-308);
+  EXPECT_EQ(inverseWeibullCDF(1.0, kDoubleMax, 0.7), kInf);
+  EXPECT_THAT(inverseWeibullCDF(1.0, kInf, 0.2), IsInf());
+  VELOX_ASSERT_THROW(
+      inverseWeibullCDF(1.0, kNan, 0.4), "b must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseWeibullCDF(1.0, -1.0, 0.4), "b must be greater than 0");
+  VELOX_ASSERT_THROW(inverseWeibullCDF(3, 0, 0.5), "b must be greater than 0");
+}
+
+TEST_F(ProbabilityTest, inverseCauchyCDF) {
+  const auto invCauchyCDF = [&](std::optional<double> median,
+                                std::optional<double> scale,
+                                std::optional<double> p) {
+    return evaluateOnce<double>(
+        "inverse_cauchy_cdf(c0, c1, c2)", median, scale, p);
+  };
+
+  EXPECT_EQ(invCauchyCDF(0.0, 1.0, 0.5), 0.0);
+  EXPECT_EQ(invCauchyCDF(2.5, 1.0, 0.64758361765043326), 3.0);
+
+  EXPECT_EQ(invCauchyCDF(5.0, 2.0, 1.0), kInf);
+  VELOX_ASSERT_THROW(
+      invCauchyCDF(1.0, 1.0, kNan), "p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      invCauchyCDF(1.0, 1.0, 9), "p must be in the interval [0, 1]");
+
+  EXPECT_EQ(invCauchyCDF(5.0, kInf, 0.5), 5.0);
+  VELOX_ASSERT_THROW(invCauchyCDF(0, -1, 0.5), "scale must be greater than 0");
+
+  EXPECT_THAT(invCauchyCDF(kNan, 1.0, 0.5), IsNan());
+  EXPECT_EQ(invCauchyCDF(kInf, 2.0, 0.5), kInf);
+  EXPECT_EQ(invCauchyCDF(kDoubleMax, 2.0, 0.5), kDoubleMax);
+  EXPECT_EQ(invCauchyCDF(kDoubleMin, 2.0, 0.5), kDoubleMin);
+}
+
+TEST_F(ProbabilityTest, inverseLaplaceCDF) {
+  const auto inverseLaplaceCDF = [&](std::optional<double> location,
+                                     std::optional<double> scale,
+                                     std::optional<double> p) {
+    return evaluateOnce<double>(
+        "inverse_laplace_cdf(c0, c1, c2)", location, scale, p);
+  };
+
+  EXPECT_EQ(inverseLaplaceCDF(0.0, 1.0, 0.5), 0.0);
+  EXPECT_EQ(inverseLaplaceCDF(5.0, 2.0, 0.5), 5.0);
+
+  VELOX_ASSERT_THROW(
+      inverseLaplaceCDF(1.0, 1.0, kNan), "p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      inverseLaplaceCDF(1.0, 1.0, 2.0), "p must be in the interval [0, 1]");
+
+  EXPECT_EQ(inverseLaplaceCDF(10.0, kDoubleMax, 0.999999999999), kInf);
+  EXPECT_EQ(inverseLaplaceCDF(10.0, kDoubleMin, 0.000000000001), 10.0);
+  VELOX_ASSERT_THROW(
+      inverseLaplaceCDF(1.0, kNan, 0.5), "scale must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseLaplaceCDF(1.0, -1.0, 0.5), "scale must be greater than 0");
+
+  EXPECT_THAT(inverseLaplaceCDF(kInf, 1.0, 0.5), IsNan());
+  EXPECT_THAT(inverseLaplaceCDF(kNan, 1.0, 0.5), IsNan());
+  EXPECT_THAT(inverseLaplaceCDF(kDoubleMax, 1.0, 0.5), kDoubleMax);
+  EXPECT_THAT(inverseLaplaceCDF(kDoubleMin, 1.0, 0.5), kDoubleMin);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/RandTest.cpp b/velox/functions/prestosql/tests/RandTest.cpp
index 07eee6adc563e..e1d6344a462f3 100644
--- a/velox/functions/prestosql/tests/RandTest.cpp
+++ b/velox/functions/prestosql/tests/RandTest.cpp
@@ -23,6 +23,13 @@ namespace facebook::velox::functions {
 
 namespace {
 
+constexpr double kInf = std::numeric_limits<double>::infinity();
+constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
+constexpr float kInfF = std::numeric_limits<float>::infinity();
+constexpr float kNanF = std::numeric_limits<float>::quiet_NaN();
+constexpr int64_t kLongMax = std::numeric_limits<int64_t>::max();
+constexpr int64_t kLongMin = std::numeric_limits<int64_t>::min();
+
 class RandTest : public functions::test::FunctionBaseTest {
  protected:
   template <typename T>
@@ -44,6 +51,18 @@ class RandTest : public functions::test::FunctionBaseTest {
   std::optional<T> randWithTry(T n) {
     return evaluateOnce<T>("try(rand(c0))", std::make_optional(n));
   }
+
+  template <typename T>
+  std::optional<T> secureRandom(
+      std::optional<T> lower,
+      std::optional<T> upper) {
+    return evaluateOnce<T>("secure_random(c0, c1)", lower, upper);
+  }
+
+  template <typename T>
+  std::optional<T> secureRand(std::optional<T> lower, std::optional<T> upper) {
+    return evaluateOnce<T>("secure_rand(c0, c1)", lower, upper);
+  }
 };
 
 TEST_F(RandTest, zeroArg) {
@@ -74,5 +93,140 @@ TEST_F(RandTest, nonNullInt8) {
   EXPECT_LT(rand(4), 4);
 }
 
+TEST_F(RandTest, secureRandZeroArg) {
+  auto result =
+      evaluateOnce<double>("secure_random()", makeRowVector(ROW({}), 1));
+  EXPECT_LT(result, 1.0);
+  EXPECT_GE(result, 0.0);
+
+  result = evaluateOnce<double>("secure_rand()", makeRowVector(ROW({}), 1));
+  EXPECT_LT(result, 1.0);
+  EXPECT_GE(result, 0.0);
+}
+
+TEST_F(RandTest, secureRandInt64) {
+  auto result =
+      secureRand<int64_t>((int64_t)-2147532562, (int64_t)4611791058295013614);
+  EXPECT_LT(result, 4611791058295013614);
+  EXPECT_GE(result, -2147532562);
+
+  result = secureRand<int64_t>((int64_t)0, (int64_t)46117910582950136);
+  EXPECT_LT(result, 46117910582950136);
+  EXPECT_GE(result, 0);
+
+  result = secureRand<int64_t>(
+      std::numeric_limits<int64_t>::min(), std::numeric_limits<int64_t>::max());
+  EXPECT_LT(result, std::numeric_limits<int64_t>::max());
+  EXPECT_GE(result, std::numeric_limits<int64_t>::min());
+}
+
+TEST_F(RandTest, secureRandInt32) {
+  auto result = secureRand<int32_t>((int32_t)8765432, (int32_t)2145613151);
+  EXPECT_LT(result, 2145613151);
+  EXPECT_GE(result, 8765432);
+
+  result = secureRand<int32_t>((int32_t)0, (int32_t)21456131);
+  EXPECT_LT(result, 21456131);
+  EXPECT_GE(result, 0);
+}
+
+TEST_F(RandTest, secureRandInt16) {
+  auto result = secureRand<int16_t>((int16_t)-100, (int16_t)23286);
+  EXPECT_LT(result, 23286);
+  EXPECT_GE(result, -100);
+
+  result = secureRand<int16_t>((int16_t)0, (int16_t)23286);
+  EXPECT_LT(result, 23286);
+  EXPECT_GE(result, 0);
+}
+
+TEST_F(RandTest, secureRandInt8) {
+  auto result = secureRand<int8_t>((int8_t)10, (int8_t)120);
+  EXPECT_LT(result, 120);
+  EXPECT_GE(result, 10);
+
+  result = secureRand<int8_t>((int8_t)0, (int8_t)120);
+  EXPECT_LT(result, 120);
+  EXPECT_GE(result, 0);
+}
+
+TEST_F(RandTest, secureRandDouble) {
+  auto result = secureRand<double>((double)10.5, (double)120.7895);
+  EXPECT_LT(result, 120.7895);
+  EXPECT_GE(result, 10.5);
+
+  result = secureRand<double>((double)0.0, (double)120.7895);
+  EXPECT_LT(result, 120.7895);
+  EXPECT_GE(result, 0.0);
+}
+
+TEST_F(RandTest, secureRandFloat) {
+  auto result = secureRand<float>((float)-10.5, (float)120.7);
+  EXPECT_LT(result, 120.7);
+  EXPECT_GE(result, -10.5);
+
+  result = secureRand<float>((float)0.0, (float)120.7);
+  EXPECT_LT(result, 120.7);
+  EXPECT_GE(result, 0.0);
+}
+
+TEST_F(RandTest, secureRandInvalid) {
+  VELOX_ASSERT_THROW(
+      secureRand<int64_t>((int64_t)-5, (int64_t)-10),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<int64_t>((int64_t)15, (int64_t)10),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<int32_t>((int32_t)5, (int32_t)-10),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<int32_t>((int32_t)15, (int32_t)10),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<int16_t>((int16_t)-5, (int16_t)-10),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<int16_t>((int16_t)15, (int16_t)10),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<int8_t>((int8_t)5, (int8_t)-10),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<int8_t>((int8_t)15, (int8_t)10),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<double>(-5.7, -10.7),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<double>(15.6, 10.1),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<float>((float)-5.7, (float)-10.7),
+      "upper bound must be greater than lower bound");
+  VELOX_ASSERT_THROW(
+      secureRand<float>((float)15.6, (float)10.1),
+      "upper bound must be greater than lower bound");
+}
+
+TEST_F(RandTest, secureRandSpecialValues) {
+  EXPECT_LT(secureRand<int64_t>(0, kLongMax), kLongMax);
+  EXPECT_GE(secureRand<int64_t>(kLongMin, 0), kLongMin);
+
+  EXPECT_TRUE(std::isnan(secureRand<float>(-kInfF, 0).value()));
+  EXPECT_LE(secureRand<float>(0.0, kInfF), std::numeric_limits<float>::max());
+
+  EXPECT_TRUE(std::isnan(secureRand<double>(-kInf, 0).value()));
+  EXPECT_EQ(secureRand<double>(0.0, kInf), std::numeric_limits<double>::max());
+
+  VELOX_ASSERT_THROW(
+      secureRand<double>(0.0, kNan),
+      "upper bound must be greater than lower bound");
+
+  VELOX_ASSERT_THROW(
+      secureRand<float>(0.0, kNanF),
+      "upper bound must be greater than lower bound");
+}
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ReduceTest.cpp b/velox/functions/prestosql/tests/ReduceTest.cpp
index 39ec8a770632b..26c74bcaf79ff 100644
--- a/velox/functions/prestosql/tests/ReduceTest.cpp
+++ b/velox/functions/prestosql/tests/ReduceTest.cpp
@@ -13,12 +13,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
+
 using namespace facebook::velox::test;
 
-class ReduceTest : public functions::test::FunctionBaseTest {};
+class ReduceTest : public functions::test::FunctionBaseTest {
+ protected:
+  void testReduceRewrite(
+      const RowVectorPtr& input,
+      const std::string& lambdaBody) {
+    TestRuntimeStatWriter writer;
+    RuntimeStatWriterScopeGuard guard(&writer);
+    auto actual = evaluate(
+        fmt::format("reduce(c0, 10, (s, x) -> {}, s -> s)", lambdaBody), input);
+    ASSERT_EQ(writer.stats().size(), 1);
+    ASSERT_EQ(writer.stats()[0].first, "numReduceRewrite");
+    ASSERT_EQ(writer.stats()[0].second.value, 1);
+    auto expected = evaluate(
+        fmt::format("reduce(c0, 10, (s, x) -> {}, s -> 1 * s)", lambdaBody),
+        input);
+    ASSERT_EQ(writer.stats().size(), 1);
+    ASSERT_EQ(writer.stats()[0].first, "numReduceRewrite");
+    ASSERT_EQ(writer.stats()[0].second.value, 1);
+    assertEqualVectors(expected, actual);
+  }
+};
 
 TEST_F(ReduceTest, basic) {
   vector_size_t size = 1'000;
@@ -242,3 +265,64 @@ TEST_F(ReduceTest, nullArray) {
   assertEqualVectors(
       makeNullableFlatVector<int64_t>({std::nullopt, std::nullopt}), result);
 }
+
+// Verify limit on the number of array elements.
+TEST_F(ReduceTest, limit) {
+  // Make array vector with huge arrays in rows 2 and 4.
+  auto data = makeRowVector({makeArrayVector(
+      {0, 1'000, 10'000, 100'000, 100'010}, makeConstant(123, 1'000'000))});
+
+  VELOX_ASSERT_THROW(
+      evaluate("reduce(c0, 0, (s, x) -> s + x, s -> 1 * s)", data),
+      "reduce lambda function doesn't support arrays with more than 10000 elements");
+
+  // Exclude huge arrays.
+  SelectivityVector rows(4);
+  rows.setValid(2, false);
+  rows.updateBounds();
+  auto result =
+      evaluate("reduce(c0, 0, (s, x) -> s + x, s -> 1 * s)", data, rows);
+  auto expected =
+      makeFlatVector<int64_t>({123 * 1'000, 123 * 9'000, -1, 123 * 10});
+  assertEqualVectors(expected, result, rows);
+
+  // Mask errors with TRY.
+  result = evaluate("TRY(reduce(c0, 0, (s, x) -> s + x, s -> 1 * s))", data);
+  expected = makeNullableFlatVector<int64_t>(
+      {123 * 1'000, 123 * 9'000, std::nullopt, 123 * 10, std::nullopt});
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(ReduceTest, rewrites) {
+  std::vector<std::optional<std::vector<std::optional<int64_t>>>> data;
+  for (int i = 0; i < 20; ++i) {
+    if (i == 7) {
+      data.push_back(std::nullopt);
+      continue;
+    }
+    auto& array = data.emplace_back(std::vector<std::optional<int64_t>>());
+    for (int j = 0; j < i % 5; ++j) {
+      if (i == 13 && j == 0) {
+        array->push_back(std::nullopt);
+      } else {
+        array->emplace_back(i + j);
+      }
+    }
+  }
+  auto input = makeRowVector({makeNullableArrayVector(data)});
+  {
+    SCOPED_TRACE("plus");
+    testReduceRewrite(input, "s + x * 2");
+  }
+  {
+    SCOPED_TRACE("plus minus");
+    testReduceRewrite(input, "(s + 1) - x");
+  }
+  {
+    SCOPED_TRACE("if");
+    testReduceRewrite(input, "if(x % 2 = 0, s + 1, s)");
+  }
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/RegexpReplaceTest.cpp b/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
index c0e992e7b100a..15953231acbd0 100644
--- a/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
+++ b/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
@@ -16,21 +16,22 @@
 #include <exception>
 #include <optional>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 namespace facebook::velox {
 namespace {
 
-class RegexFunctionsTest : public functions::test::FunctionBaseTest {
+class RegexpReplaceTest : public functions::test::FunctionBaseTest {
  protected:
-  std::optional<std::string> regexp_replace(
+  std::optional<std::string> regexpReplace(
       const std::optional<std::string>& string,
       const std::string& pattern) {
     return evaluateOnce<std::string>(
         fmt::format("regexp_replace(c0, '{}')", pattern), string);
   }
 
-  std::optional<std::string> regexp_replace(
+  std::optional<std::string> regexpReplace(
       const std::optional<std::string>& string,
       const std::string& pattern,
       const std::string& replacement) {
@@ -40,47 +41,231 @@ class RegexFunctionsTest : public functions::test::FunctionBaseTest {
   }
 };
 
-TEST_F(RegexFunctionsTest, RegexpReplaceNoReplacement) {
-  EXPECT_EQ(regexp_replace("abcd", "cd"), "ab");
-  EXPECT_EQ(regexp_replace("a12b34c5", "\\d"), "abc");
-  EXPECT_EQ(regexp_replace("abc", "\\w"), "");
-  EXPECT_EQ(regexp_replace("", "\\d"), "");
-  EXPECT_EQ(regexp_replace("abc", ""), "abc");
-  EXPECT_EQ(regexp_replace("$$$.", "\\$"), ".");
-  EXPECT_EQ(regexp_replace("???.", "\\?"), ".");
-  EXPECT_EQ(regexp_replace(std::nullopt, "abc"), std::nullopt);
+TEST_F(RegexpReplaceTest, noReplacement) {
+  EXPECT_EQ(regexpReplace("abcd", "cd"), "ab");
+  EXPECT_EQ(regexpReplace("a12b34c5", "\\d"), "abc");
+  EXPECT_EQ(regexpReplace("abc", "\\w"), "");
+  EXPECT_EQ(regexpReplace("", "\\d"), "");
+  EXPECT_EQ(regexpReplace("abc", ""), "abc");
+  EXPECT_EQ(regexpReplace("$$$.", "\\$"), ".");
+  EXPECT_EQ(regexpReplace("???.", "\\?"), ".");
+  EXPECT_EQ(regexpReplace(std::nullopt, "abc"), std::nullopt);
+
+  auto input = makeRowVector({
+      makeFlatVector<std::string>(
+          {"apple123", "1 banana", "orange 23 ...", "12 34 56"}),
+      makeFlatVector<std::string>({"[0-9]+", "\\d+", "ge\\s", "[4-9 ]"}),
+  });
+
+  auto result = evaluate("regexp_replace(c0, c1)", input);
+
+  auto expected =
+      makeFlatVector<std::string>({"apple", " banana", "oran23 ...", "123"});
+  test::assertEqualVectors(expected, result);
 }
 
-TEST_F(RegexFunctionsTest, RegexpReplaceWithReplacement) {
-  EXPECT_EQ(regexp_replace("abcd", "cd", "ef"), "abef");
-  EXPECT_EQ(regexp_replace("abc", "\\w", ""), "");
-  EXPECT_EQ(regexp_replace("a12b34c5", "\\d", "."), "a..b..c.");
-  EXPECT_EQ(regexp_replace("", "\\d", "."), "");
-  EXPECT_EQ(regexp_replace("abc", "", "."), ".a.b.c.");
+TEST_F(RegexpReplaceTest, withReplacement) {
+  EXPECT_EQ(regexpReplace("abcd", "cd", "ef"), "abef");
+  EXPECT_EQ(regexpReplace("abc", "\\w", ""), "");
+  EXPECT_EQ(regexpReplace("a12b34c5", "\\d", "."), "a..b..c.");
+  EXPECT_EQ(regexpReplace("", "\\d", "."), "");
+  EXPECT_EQ(regexpReplace("abc", "", "."), ".a.b.c.");
+  EXPECT_EQ(regexpReplace("", "", "."), ".");
   EXPECT_EQ(
-      regexp_replace("1a 2b 14m", "(\\d+)([ab]) ", "3c$2 "), "3ca 3cb 14m");
-  EXPECT_EQ(regexp_replace("1a 2b 14m", "(\\d+)([ab])", "3c$2"), "3ca 3cb 14m");
-  EXPECT_EQ(regexp_replace("abc", "(?P<alpha>\\w)", "1${alpha}"), "1a1b1c");
+      regexpReplace("1a 2b 14m", "(\\d+)([ab]) ", "3c$2 "), "3ca 3cb 14m");
+  EXPECT_EQ(regexpReplace("1a 2b 14m", "(\\d+)([ab])", "3c$2"), "3ca 3cb 14m");
+  EXPECT_EQ(regexpReplace("abc", "(?P<alpha>\\w)", "1${alpha}"), "1a1b1c");
   EXPECT_EQ(
-      regexp_replace("1a1b1c", "(?<digit>\\d)(?<alpha>\\w)", "${alpha}\\$"),
+      regexpReplace("1a1b1c", "(?<digit>\\d)(?<alpha>\\w)", "${alpha}\\$"),
       "a$b$c$");
   EXPECT_EQ(
-      regexp_replace(
-          "1a2b3c", "(?<digit>\\d)(?<alpha>\\w)", "${alpha}${digit}"),
+      regexpReplace("1a2b3c", "(?<digit>\\d)(?<alpha>\\w)", "${alpha}${digit}"),
       "a1b2c3");
-  EXPECT_EQ(regexp_replace("123", "(\\d)", "\\$"), "$$$");
+  EXPECT_EQ(regexpReplace("123", "(\\d)", "\\$"), "$$$");
   EXPECT_EQ(
-      regexp_replace("123", "(?<digit>(?<nest>\\d))", ".${digit}"), ".1.2.3");
+      regexpReplace("123", "(?<digit>(?<nest>\\d))", ".${digit}"), ".1.2.3");
   EXPECT_EQ(
-      regexp_replace("123", "(?<digit>(?<nest>\\d))", ".${nest}"), ".1.2.3");
-  EXPECT_EQ(regexp_replace(std::nullopt, "abc", "def"), std::nullopt);
-
-  EXPECT_THROW(regexp_replace("123", "(?<d", "."), VeloxUserError);
-  EXPECT_THROW(regexp_replace("123", R"((?''digit''\d))", "."), VeloxUserError);
-  EXPECT_THROW(regexp_replace("123", "(?P<>\\d)", "."), VeloxUserError);
-  EXPECT_THROW(
-      regexp_replace("123", "(?P<digit>\\d)", "${dd}"), VeloxUserError);
-  EXPECT_THROW(regexp_replace("123", "(?P<digit>\\d)", "${}"), VeloxUserError);
+      regexpReplace("123", "(?<digit>(?<nest>\\d))", ".${nest}"), ".1.2.3");
+  EXPECT_EQ(regexpReplace(std::nullopt, "abc", "def"), std::nullopt);
+
+  EXPECT_THROW(regexpReplace("123", "(?<d", "."), VeloxUserError);
+  EXPECT_THROW(regexpReplace("123", R"((?''digit''\d))", "."), VeloxUserError);
+  EXPECT_THROW(regexpReplace("123", "(?P<>\\d)", "."), VeloxUserError);
+  EXPECT_THROW(regexpReplace("123", "(?P<digit>\\d)", "${dd}"), VeloxUserError);
+  EXPECT_THROW(regexpReplace("123", "(?P<digit>\\d)", "${}"), VeloxUserError);
+
+  auto input = makeRowVector({
+      makeFlatVector<std::string>(
+          {"apple123", "1 banana", "orange 23 ...", "12 34 56"}),
+      makeFlatVector<std::string>({"[0-9]+", "\\d+", "ge\\s", "[4-9]"}),
+      makeFlatVector<std::string>({"_", ".", "", "[===]"}),
+  });
+
+  auto result = evaluate("regexp_replace(c0, c1, c2)", input);
+
+  auto expected = makeFlatVector<std::string>(
+      {"apple_", ". banana", "oran23 ...", "12 3[===] [===][===]"});
+  test::assertEqualVectors(expected, result);
+
+  // Constant 'replacement' with non-constant 'pattern'.
+  result = evaluate("regexp_replace(c0, c1, '||')", input);
+
+  expected = makeFlatVector<std::string>(
+      {"apple||", "|| banana", "oran||23 ...", "12 3|| ||||"});
+  test::assertEqualVectors(expected, result);
+}
+
+TEST_F(RegexpReplaceTest, lambda) {
+  auto input = makeRowVector({
+      makeFlatVector<std::string>(
+          {"new york", "", "los angeles", "san francisco", "seattle"}),
+      makeFlatVector<std::string>({"[a]", "[b]", "[c]", "[d]", "[e]"}),
+      makeFlatVector<int64_t>({0, 1, 2, 3, 4}),
+  });
+
+  auto result = evaluate(
+      "regexp_replace(c0, '(\\w)(\\w*)', x -> (concat(upper(x[1]), lower(x[2]))))",
+      input);
+
+  VectorPtr expected = makeFlatVector<std::string>(
+      {"New York", "", "Los Angeles", "San Francisco", "Seattle"});
+  test::assertEqualVectors(expected, result);
+
+  // No matches for any input string. The result should be the same as input.
+  result = evaluate(
+      "regexp_replace(c0, '\\d+', x -> (concat(upper(x[1]), lower(x[2]))))",
+      input);
+  test::assertEqualVectors(input->childAt(0), result);
+
+  // No matches for the second group.
+  result = evaluate(
+      "regexp_replace(c0, '(\\w)(\\d*)', x -> (concat(upper(x[1]), lower(x[2]))))",
+      input);
+  expected = makeFlatVector<std::string>(
+      {"NEW YORK", "", "LOS ANGELES", "SAN FRANCISCO", "SEATTLE"});
+  test::assertEqualVectors(expected, result);
+
+  // Regex with no matching groups.
+  result = evaluate("regexp_replace(c0, '\\w\\w*', x -> '_')", input);
+  expected = makeFlatVector<std::string>({"_ _", "", "_ _", "_ _", "_"});
+  test::assertEqualVectors(expected, result);
+
+  // Lambda references non-existent matching groups.
+  VELOX_ASSERT_THROW(
+      (evaluate(
+          "regexp_replace(c0, '\\w(\\w*)', x -> (concat(upper(x[1]), lower(x[2]))))",
+          input)),
+      "Array subscript out of bounds");
+
+  result = evaluate(
+      "regexp_replace(c0, '\\w(\\w*)', x -> try(concat(upper(x[1]), lower(x[2]))))",
+      input);
+  expected = makeNullableFlatVector<std::string>(
+      {std::nullopt, "", std::nullopt, std::nullopt, std::nullopt});
+  test::assertEqualVectors(expected, result);
+
+  result = evaluate(
+      "try(regexp_replace(c0, '\\w(\\w*)', x -> (concat(upper(x[1]), lower(x[2])))))",
+      input);
+  test::assertEqualVectors(expected, result);
+
+  // Empty pattern.
+  result = evaluate("regexp_replace(c0, '', x -> '_')", input);
+  expected = makeFlatVector<std::string>(
+      {"_n_e_w_ _y_o_r_k_",
+       "_",
+       "_l_o_s_ _a_n_g_e_l_e_s_",
+       "_s_a_n_ _f_r_a_n_c_i_s_c_o_",
+       "_s_e_a_t_t_l_e_"});
+  test::assertEqualVectors(expected, result);
+
+  // Regex that "matches" empty string.
+  result = evaluate("regexp_replace(c0, '\\d*', x -> '_')", input);
+  test::assertEqualVectors(expected, result);
+
+  // Lambda with captures.
+  result = evaluate(
+      "regexp_replace(c0, '(\\w)(\\w*)', x -> concat(c1, lower(x[2])))", input);
+  expected = makeFlatVector<std::string>(
+      {"[a]ew [a]ork",
+       "",
+       "[c]os [c]ngeles",
+       "[d]an [d]rancisco",
+       "[e]eattle"});
+  test::assertEqualVectors(expected, result);
+
+  // Different lambdas for different rows.
+  // Even rows: replace each word with the first letter uppercase.
+  // Odd rows: remove first letter from each word.
+  result = evaluate(
+      "regexp_replace(c0, '(\\w)(\\w*)', if (c2 % 2 = 0, x -> upper(x[1]), x -> x[2]))",
+      input);
+  expected =
+      makeFlatVector<std::string>({"N Y", "", "L A", "an rancisco", "S"});
+  test::assertEqualVectors(expected, result);
+
+  // Lambda fails for some rows.
+  VELOX_ASSERT_THROW(
+      (evaluate(
+          "regexp_replace(c0, '(\\w)(\\w*)', x -> if (x[1] = 's', x[10], concat(upper(x[1]), lower(x[2]))))",
+          input)),
+      "Array subscript out of bounds");
+
+  result = evaluate(
+      "regexp_replace(c0, '(\\w)(\\w*)', x -> try(if (x[1] = 's', x[10], concat(upper(x[1]), lower(x[2])))))",
+      input);
+  expected = makeNullableFlatVector<std::string>(
+      {"New York", "", "Los Angeles", std::nullopt, std::nullopt});
+  test::assertEqualVectors(expected, result);
+
+  // Nulls in 'string', 'pattern' or 'capture'.
+  auto inputWithNulls = makeRowVector({
+      makeNullableFlatVector<std::string>(
+          {"new york",
+           std::nullopt,
+           "los angeles",
+           "san francisco",
+           "seattle",
+           std::nullopt}),
+      makeNullableFlatVector<std::string>({
+          "(\\w+)",
+          "(\\d+)",
+          std::nullopt,
+          "(\\w)",
+          "(\\w)",
+          "(\\d+)",
+      }),
+      makeNullableFlatVector<std::string>({
+          "!",
+          "[b]",
+          "[c]",
+          std::nullopt,
+          "_",
+          "_",
+      }),
+
+  });
+
+  result = evaluate("regexp_replace(c0, c1, x -> upper(x[1]))", inputWithNulls);
+  expected = makeNullableFlatVector<std::string>(
+      {"NEW YORK",
+       std::nullopt,
+       std::nullopt,
+       "SAN FRANCISCO",
+       "SEATTLE",
+       std::nullopt});
+  test::assertEqualVectors(expected, result);
+
+  result =
+      evaluate("regexp_replace(c0, c1, x -> concat(c2, x[1]))", inputWithNulls);
+  expected = makeNullableFlatVector<std::string>(
+      {"!new !york",
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       "_s_e_a_t_t_l_e",
+       std::nullopt});
+  test::assertEqualVectors(expected, result);
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/tests/RepeatTest.cpp b/velox/functions/prestosql/tests/RepeatTest.cpp
deleted file mode 100644
index 95275c8c7e4f0..0000000000000
--- a/velox/functions/prestosql/tests/RepeatTest.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::test;
-using namespace facebook::velox::functions::test;
-
-namespace {
-
-class RepeatTest : public FunctionBaseTest {
- protected:
-  void testExpression(
-      const std::string& expression,
-      const std::vector<VectorPtr>& input,
-      const VectorPtr& expected) {
-    auto result = evaluate(expression, makeRowVector(input));
-    assertEqualVectors(expected, result);
-  }
-
-  void testExpressionWithError(
-      const std::string& expression,
-      const std::vector<VectorPtr>& input,
-      const std::string& expectedError) {
-    VELOX_ASSERT_THROW(
-        evaluate(expression, makeRowVector(input)), expectedError);
-  }
-};
-} // namespace
-
-TEST_F(RepeatTest, repeat) {
-  const auto elementVector = makeNullableFlatVector<float>(
-      {0.0, -2.0, 3.333333, 4.0004, std::nullopt, 5.12345});
-  const auto countVector =
-      makeNullableFlatVector<int32_t>({1, 2, 3, 0, 4, std::nullopt});
-  VectorPtr expected;
-
-  expected = makeNullableArrayVector<float>({
-      {{0.0}},
-      {{-2.0, -2.0}},
-      {{3.333333, 3.333333, 3.333333}},
-      {{}},
-      {{std::nullopt, std::nullopt, std::nullopt, std::nullopt}},
-      std::nullopt,
-  });
-  testExpression("repeat(C0, C1)", {elementVector, countVector}, expected);
-  testExpression("try(repeat(C0, C1))", {elementVector, countVector}, expected);
-
-  // Test using a null constant as the count argument.
-  expected = BaseVector::createNullConstant(ARRAY(REAL()), 6, pool());
-  testExpression("repeat(C0, null::INTEGER)", {elementVector}, expected);
-  testExpression("try(repeat(C0, null::INTEGER))", {elementVector}, expected);
-
-  // Test using a non-null constant as the count argument.
-  expected = makeNullableArrayVector<float>({
-      {0.0, 0.0, 0.0},
-      {-2.0, -2.0, -2.0},
-      {3.333333, 3.333333, 3.333333},
-      {4.0004, 4.0004, 4.0004},
-      {std::nullopt, std::nullopt, std::nullopt},
-      {5.12345, 5.12345, 5.12345},
-  });
-  testExpression("repeat(C0, '3'::INTEGER)", {elementVector}, expected);
-  testExpression("try(repeat(C0, '3'::INTEGER))", {elementVector}, expected);
-
-  expected = makeArrayVector<float>({{}, {}, {}, {}, {}, {}});
-  testExpression("repeat(C0, '0'::INTEGER)", {elementVector}, expected);
-  testExpression("try(repeat(C0, '0'::INTEGER))", {elementVector}, expected);
-}
-
-TEST_F(RepeatTest, repeatWithInvalidCount) {
-  const auto elementVector =
-      makeNullableFlatVector<float>({0.0, 2.0, 3.333333});
-
-  VectorPtr countVector;
-  VectorPtr expected;
-
-  expected = makeNullableArrayVector<float>({
-      {{0.0}},
-      std::nullopt,
-      {{3.333333, 3.333333, 3.333333}},
-  });
-  countVector = makeNullableFlatVector<int32_t>({1, -2, 3});
-  testExpression("try(repeat(C0, C1))", {elementVector, countVector}, expected);
-  testExpressionWithError(
-      "repeat(C0, C1)",
-      {elementVector, countVector},
-      "(-2 vs. 0) Count argument of repeat function must be greater than or equal to 0");
-
-  countVector = makeNullableFlatVector<int32_t>({1, 123456, 3});
-  testExpression("try(repeat(C0, C1))", {elementVector, countVector}, expected);
-  testExpressionWithError(
-      "repeat(C0, C1)",
-      {elementVector, countVector},
-      "(123456 vs. 10000) Count argument of repeat function must be less than or equal to 10000");
-
-  // Test using a constant as the count argument.
-  expected = BaseVector::createNullConstant(ARRAY(REAL()), 3, pool());
-  testExpression("try(repeat(C0, '-5'::INTEGER))", {elementVector}, expected);
-  testExpressionWithError(
-      "repeat(C0, '-5'::INTEGER)",
-      {elementVector},
-      "(-5 vs. 0) Count argument of repeat function must be greater than or equal to 0");
-
-  testExpression(
-      "try(repeat(C0, '10001'::INTEGER))", {elementVector}, expected);
-  testExpressionWithError(
-      "repeat(C0, '10001'::INTEGER)",
-      {elementVector},
-      "(10001 vs. 10000) Count argument of repeat function must be less than or equal to 10000");
-}
diff --git a/velox/functions/prestosql/tests/ReverseTest.cpp b/velox/functions/prestosql/tests/ReverseTest.cpp
index ec06e11303ee7..2646e53638789 100644
--- a/velox/functions/prestosql/tests/ReverseTest.cpp
+++ b/velox/functions/prestosql/tests/ReverseTest.cpp
@@ -23,9 +23,8 @@ using namespace facebook::velox::functions::test;
 namespace {
 class ReverseTest : public FunctionBaseTest {
  protected:
-  template <typename T>
   void testExpr(const VectorPtr& expected, const VectorPtr& input) {
-    auto result = evaluate<T>("reverse(C0)", makeRowVector({input}));
+    auto result = evaluate("reverse(C0)", makeRowVector({input}));
     assertEqualVectors(expected, result);
   }
 };
@@ -44,7 +43,7 @@ TEST_F(ReverseTest, intsArrays) {
        {std::nullopt, 8, 3},
        {8, 1},
        {}});
-  testExpr<ArrayVector>(expected, array1);
+  testExpr(expected, array1);
 }
 
 TEST_F(ReverseTest, doublesArrays) {
@@ -59,7 +58,7 @@ TEST_F(ReverseTest, doublesArrays) {
       {std::nullopt, 8, 3},
       {8, 1},
   });
-  testExpr<ArrayVector>(expected, input);
+  testExpr(expected, input);
 }
 
 TEST_F(ReverseTest, stringsArrays) {
@@ -74,7 +73,7 @@ TEST_F(ReverseTest, stringsArrays) {
        {std::nullopt, S("xyz"), S("mnoasda asasd aqqerewqe")},
        {}});
 
-  testExpr<ArrayVector>(expected, input);
+  testExpr(expected, input);
 }
 
 TEST_F(ReverseTest, constant) {
@@ -86,7 +85,7 @@ TEST_F(ReverseTest, constant) {
 
   auto expected = makeNullableArrayVector<int32_t>({{3, 2, 1}, {3, 2, 1}});
 
-  testExpr<SimpleVector<ComplexType>>(expected, constant);
+  testExpr(expected, constant);
 }
 
 TEST_F(ReverseTest, nestedArray) {
@@ -140,18 +139,18 @@ TEST_F(ReverseTest, nestedArray) {
        O({4, 3}),
        O({1, 2})});
 
-  testExpr<ArrayVector>(expected, arrayOfArrays);
+  testExpr(expected, arrayOfArrays);
 
   arrayOfArrays =
       createArrayOfArrays({O({1, 2, 3, 4}), O({4, 5, std::nullopt})});
   expected = createArrayOfArrays({O({4, 5, std::nullopt}), O({1, 2, 3, 4})});
 
-  testExpr<ArrayVector>(expected, arrayOfArrays);
+  testExpr(expected, arrayOfArrays);
 
   arrayOfArrays = createArrayOfArrays({std::nullopt, O({4, 5, std::nullopt})});
   expected = createArrayOfArrays({O({4, 5, std::nullopt}), std::nullopt});
 
-  testExpr<ArrayVector>(expected, arrayOfArrays);
+  testExpr(expected, arrayOfArrays);
 }
 
 TEST_F(ReverseTest, nullArray) {
@@ -164,6 +163,6 @@ TEST_F(ReverseTest, nullArray) {
   auto reverseNullArray =
       makeNullableArrayVector<int32_t>({reverseNullVec, std::nullopt});
 
-  testExpr<ArrayVector>(reverseNullArray, nullArray);
+  testExpr(reverseNullArray, nullArray);
 }
 } // namespace
diff --git a/velox/functions/prestosql/tests/RoundTest.cpp b/velox/functions/prestosql/tests/RoundTest.cpp
index 1abbeff8a2299..bfcc1c55b46ec 100644
--- a/velox/functions/prestosql/tests/RoundTest.cpp
+++ b/velox/functions/prestosql/tests/RoundTest.cpp
@@ -61,28 +61,27 @@ class RoundTest : public functions::test::FunctionBaseTest {
   template <typename T>
   std::vector<std::tuple<T, int32_t, T>> testRoundWithDecFloatData() {
     return {
-        {1.122112, 0, 1},
-        {1.129, 1, 1.1},
-        {1.129, 2, 1.13},
-        {1.0 / 3, 0, 0.0},
-        {1.0 / 3, 1, 0.3},
-        {1.0 / 3, 2, 0.33},
-        {1.0 / 3, 10, 0.3333333333},
-        {-1.122112, 0, -1},
-        {-1.129, 1, -1.1},
-        {-1.129, 2, -1.13},
-        {-1.129, 2, -1.13},
-        {-1.0 / 3, 0, 0.0},
-        {-1.0 / 3, 1, -0.3},
-        {-1.0 / 3, 2, -0.33},
-        {-1.0 / 3, 10, -0.3333333333},
-        {1.0, -1, 0.0},
-        {0.0, -2, 0.0},
-        {-1.0, -3, 0.0},
-        {11111.0, -1, 11110.0},
-        {11111.0, -2, 11100.0},
-        {11111.0, -3, 11000.0},
-        {11111.0, -4, 10000.0}};
+        {3.8636365, 2, 3.86},     {-2.3622048, 2, -2.36},
+        {1.6806724, 2, 1.68},     {2.3648648, 2, 2.36},
+        {-5.970149, 2, -5.97},    {1.5931978, 2, 1.59},
+        {-5.965909, 2, -5.97},    {-1.831502, 2, -1.83},
+        {-4.971341, 2, -4.97},    {-1.4285715, 2, -1.43},
+        {-6.965645, 2, -6.97},    {1.122112, 0, 1},
+        {1.45, 1, 1.5},           {-1.45, 1, -1.5},
+        {-0.60265756, 1, -0.6},   {-0.60265756, 2, -0.6},
+        {-0.60265756, 3, -0.603}, {-0.60265756, 4, -0.6027},
+        {1.129, 1, 1.1},          {1.129, 2, 1.13},
+        {1.0 / 3, 0, 0.0},        {1.0 / 3, 1, 0.3},
+        {1.0 / 3, 2, 0.33},       {1.0 / 3, 10, 0.3333333333},
+        {-1.122112, 0, -1},       {-1.129, 1, -1.1},
+        {-1.129, 2, -1.13},       {-1.129, 2, -1.13},
+        {-1.0 / 3, 0, 0.0},       {-1.0 / 3, 1, -0.3},
+        {-1.0 / 3, 2, -0.33},     {-1.0 / 3, 10, -0.3333333333},
+        {1.0, -1, 0.0},           {0.0, -2, 0.0},
+        {-1.0, -3, 0.0},          {11111.0, -1, 11110.0},
+        {11111.0, -2, 11100.0},   {11111.0, -3, 11000.0},
+        {11111.0, -4, 10000.0},
+    };
   }
 
   template <typename T>
@@ -122,3 +121,70 @@ TEST_F(RoundTest, roundWithDecimal) {
   runRoundWithDecimalTest<int16_t>(testRoundWithDecIntegralData<int16_t>());
   runRoundWithDecimalTest<int8_t>(testRoundWithDecIntegralData<int8_t>());
 }
+
+TEST_F(RoundTest, roundWithDecimalLargeNumbers) {
+  for (int32_t i = 0; i < 64; ++i) {
+    runRoundWithDecimalTest<double>({
+        {9223372036854775807, i, 9223372036854775807},
+        {1941561021063124736, i, 1941561021063124736},
+        {194156102106312473, i, 194156102106312473},
+        {19415610210631247, i, 19415610210631247},
+        {281474976710655, i, 281474976710655},
+        {17592186044415, i, 17592186044415},
+        {1099511627775, i, 1099511627775},
+        {68719476735, i, 68719476735},
+        {4294967295, i, 4294967295},
+    });
+    runRoundWithDecimalTest<float>({
+        {9223372036854775807, i, 9223372036854775807},
+        {1941561021063124736, i, 1941561021063124736},
+        {194156102106312473, i, 194156102106312473},
+        {19415610210631247, i, 19415610210631247},
+        {281474976710655, i, 281474976710655},
+        {17592186044415, i, 17592186044415},
+        {1099511627775, i, 1099511627775},
+        {68719476735, i, 68719476735},
+        {4294967295, i, 4294967295},
+        {268435455, i, 268435455},
+    });
+    runRoundWithDecimalTest<int64_t>({
+        {9223372036854775807, i, 9223372036854775807},
+        {1941561021063124736, i, 1941561021063124736},
+        {194156102106312473, i, 194156102106312473},
+        {19415610210631247, i, 19415610210631247},
+        {281474976710655, i, 281474976710655},
+        {17592186044415, i, 17592186044415},
+        {1099511627775, i, 1099511627775},
+        {68719476735, i, 68719476735},
+        {4294967295, i, 4294967295},
+        {268435455, i, 268435455},
+    });
+  }
+
+  for (int32_t i = 0; i < 64; ++i) {
+    runRoundWithDecimalTest<double>(
+        {{std::numeric_limits<double>::max(),
+          i,
+          std::numeric_limits<double>::max()}});
+  };
+
+  runRoundWithDecimalTest<double>({
+      {1941561021063124736.458, 1, 1941561021063124736.5},
+      {194156102106312473.314, 2, 194156102106312473.31},
+      {19415610210631247.874, 3, 19415610210631247.874},
+      {281474976710655.87434, 4, 281474976710655.8743},
+      {17592186044415.87434, 4, 17592186044415.8743},
+      {1099511627775.86443, 4, 1099511627775.8644},
+      {68719476735.86443, 4, 68719476735.8644},
+      {4294967295.86443, 4, 4294967295.8644},
+      {1941561021063124736.8636365, 2, 1941561021063124736.86},
+      {194156102106312473.8636365, 2, 194156102106312473.86},
+      {-19415610210631247.8636365, 2, -19415610210631247.86},
+      {281474976710655.8636365, 2, 281474976710655.86},
+      {17592186044415.8636365, 2, 17592186044415.86},
+      {-1099511627775.8636365, 2, -1099511627775.86},
+      {68719476735.8636365, 2, 68719476735.86},
+      {4294967295.868636365443, 2, 4294967295.87},
+      {-268435455.868636365443, 2, -268435455.87},
+  });
+}
diff --git a/velox/functions/prestosql/tests/ScalarFunctionRegTest.cpp b/velox/functions/prestosql/tests/ScalarFunctionRegTest.cpp
index 507fde7e8f0af..ecf639f081420 100644
--- a/velox/functions/prestosql/tests/ScalarFunctionRegTest.cpp
+++ b/velox/functions/prestosql/tests/ScalarFunctionRegTest.cpp
@@ -48,6 +48,7 @@ TEST_F(ScalarFunctionRegTest, prefix) {
 
   // Register with prefix and check all functions have the prefix.
   const std::string prefix{"test.abc_schema."};
+  const auto prefixSize = prefix.size();
   prestosql::registerAllScalarFunctions(prefix);
   std::unordered_map<std::string, exec::VectorFunctionEntry>
       scalarVectorFuncMap = *(exec::vectorFunctionFactories().rlock());
@@ -58,14 +59,23 @@ TEST_F(ScalarFunctionRegTest, prefix) {
   scalarVectorFuncMap.erase("is_null");
 
   for (const auto& entry : scalarVectorFuncMap) {
-    EXPECT_EQ(prefix, entry.first.substr(0, prefix.size()));
-    EXPECT_EQ(
-        1, scalarVectorFuncMapBase.count(entry.first.substr(prefix.size())));
+    const auto& name = entry.first;
+    EXPECT_EQ(prefix, name.substr(0, prefixSize));
+    EXPECT_EQ(1, scalarVectorFuncMapBase.count(name.substr(prefixSize)));
   }
+
   for (const auto& funcName : exec::simpleFunctions().getFunctionNames()) {
-    EXPECT_EQ(prefix, funcName.substr(0, prefix.size()));
-    EXPECT_EQ(
-        1, scalarSimpleFuncBaseNames.count(funcName.substr(prefix.size())));
+    // Skip special forms. They don't have any prefix.
+    if (funcName == "in") {
+      continue;
+    }
+
+    // Skip internal functions. They don't have any prefix.
+    if (funcName.find("$internal$") == 0) {
+      continue;
+    }
+    EXPECT_EQ(prefix, funcName.substr(0, prefixSize));
+    EXPECT_EQ(1, scalarSimpleFuncBaseNames.count(funcName.substr(prefixSize)));
   }
 }
 
diff --git a/velox/functions/prestosql/tests/SequenceTest.cpp b/velox/functions/prestosql/tests/SequenceTest.cpp
index bdc282c330e51..bfce7a25a78a9 100644
--- a/velox/functions/prestosql/tests/SequenceTest.cpp
+++ b/velox/functions/prestosql/tests/SequenceTest.cpp
@@ -44,10 +44,6 @@ class SequenceTest : public FunctionBaseTest {
 };
 } // namespace
 
-int32_t parseDate(const std::string& dateStr) {
-  return DATE()->toDays(dateStr);
-}
-
 TEST_F(SequenceTest, sequence) {
   const auto startVector = makeFlatVector<int64_t>({1, 2, 10});
   const auto stopVector = makeFlatVector<int64_t>({2, 5, 9});
@@ -58,13 +54,27 @@ TEST_F(SequenceTest, sequence) {
 
 TEST_F(SequenceTest, integerOverflow) {
   // stop - start = 9223372036854775807 - (-2147483648) would overflow
-  const auto startVector = makeFlatVector<int64_t>({int64_t(-2147483648), 1});
-  const auto stopVector =
-      makeFlatVector<int64_t>({int64_t(9223372036854775807), 2});
+  auto startVector = makeFlatVector<int64_t>({int64_t(-2147483648), 1});
+  auto stopVector = makeFlatVector<int64_t>({int64_t(9223372036854775807), 2});
   testExpressionWithError(
       "sequence(C0, C1)",
       {startVector, stopVector},
       "result of sequence function must not have more than 10000 entries");
+
+  startVector = makeFlatVector<int64_t>({int64_t(-9000000000000000000), 1});
+  stopVector = makeFlatVector<int64_t>({int64_t(9000000000000000000), 2});
+  const auto stepVector = makeFlatVector<int64_t>({5000000000000000000, 1});
+  // For the 3rd element's calculation
+  // start + step * 3 = -9000000000000000000 + 5000000000000000000 * 3
+  // 5000000000000000000 * 3 would overflow
+  VectorPtr expected = makeArrayVector<int64_t>(
+      {{-9000000000000000000,
+        -4000000000000000000,
+        1000000000000000000,
+        6000000000000000000},
+       {1, 2}});
+  testExpression(
+      "sequence(C0, C1, C2)", {startVector, stopVector, stepVector}, expected);
 }
 
 TEST_F(SequenceTest, negative) {
@@ -383,48 +393,47 @@ TEST_F(SequenceTest, timestampInvalidIntervalStep) {
 
 TEST_F(SequenceTest, timestampYearMonthStep) {
   const auto startVector = makeFlatVector<Timestamp>(
-      {facebook::velox::util::fromTimestampString("1975-01-31 10:00:00.500"),
-       facebook::velox::util::fromTimestampString("1975-03-15 10:10:10.200"),
-       facebook::velox::util::fromTimestampString("2023-12-31 23:00:00.500")});
+      {parseTimestamp("1975-01-31 10:00:00.500"),
+       parseTimestamp("1975-03-15 10:10:10.200"),
+       parseTimestamp("2023-12-31 23:00:00.500")});
   const auto stopVector = makeFlatVector<Timestamp>(
-      {facebook::velox::util::fromTimestampString("1975-06-01 01:00:00.500"),
-       facebook::velox::util::fromTimestampString("1974-12-15 10:20:00.500"),
-       facebook::velox::util::fromTimestampString("2024-05-31 10:00:00.500")});
+      {parseTimestamp("1975-06-01 01:00:00.500"),
+       parseTimestamp("1974-12-15 10:20:00.500"),
+       parseTimestamp("2024-05-31 10:00:00.500")});
 
   const auto stepVector =
       makeFlatVector<int32_t>({1, -1, 2}, INTERVAL_YEAR_MONTH());
   const auto expected = makeArrayVector<Timestamp>(
       {// last day of Feb
-       {facebook::velox::util::fromTimestampString("1975-01-31 10:00:00.500"),
-        facebook::velox::util::fromTimestampString("1975-02-28 10:00:00.500"),
-        facebook::velox::util::fromTimestampString("1975-03-31 10:00:00.500"),
-        facebook::velox::util::fromTimestampString("1975-04-30 10:00:00.500"),
-        facebook::velox::util::fromTimestampString("1975-05-31 10:00:00.500")},
+       {parseTimestamp("1975-01-31 10:00:00.500"),
+        parseTimestamp("1975-02-28 10:00:00.500"),
+        parseTimestamp("1975-03-31 10:00:00.500"),
+        parseTimestamp("1975-04-30 10:00:00.500"),
+        parseTimestamp("1975-05-31 10:00:00.500")},
        // date is the same but timestamp is different so couldn't include
        // 1974-12-15 10:10:10.200
        // negative step
-       {facebook::velox::util::fromTimestampString("1975-03-15 10:10:10.200"),
-        facebook::velox::util::fromTimestampString("1975-02-15 10:10:10.200"),
-        facebook::velox::util::fromTimestampString("1975-01-15 10:10:10.200")},
+       {parseTimestamp("1975-03-15 10:10:10.200"),
+        parseTimestamp("1975-02-15 10:10:10.200"),
+        parseTimestamp("1975-01-15 10:10:10.200")},
        // leap year
        // result won't include 2024-05-31 10:00:00.500
-       {facebook::velox::util::fromTimestampString("2023-12-31 23:00:00.500"),
-        facebook::velox::util::fromTimestampString("2024-02-29 23:00:00.500"),
-        facebook::velox::util::fromTimestampString(
-            "2024-04-30 23:00:00.500")}});
+       {parseTimestamp("2023-12-31 23:00:00.500"),
+        parseTimestamp("2024-02-29 23:00:00.500"),
+        parseTimestamp("2024-04-30 23:00:00.500")}});
   testExpression(
       "sequence(C0, C1, C2)", {startVector, stopVector, stepVector}, expected);
 }
 
 TEST_F(SequenceTest, timestampInvalidYearMonthStep) {
   const auto startVector = makeFlatVector<Timestamp>(
-      {facebook::velox::util::fromTimestampString("1975-01-31 10:00:00.500"),
-       facebook::velox::util::fromTimestampString("1975-03-15 10:10:10.200"),
-       facebook::velox::util::fromTimestampString("2023-12-31 23:00:00.500")});
+      {parseTimestamp("1975-01-31 10:00:00.500"),
+       parseTimestamp("1975-03-15 10:10:10.200"),
+       parseTimestamp("2023-12-31 23:00:00.500")});
   const auto stopVector = makeFlatVector<Timestamp>(
-      {facebook::velox::util::fromTimestampString("1975-06-01 01:00:00.500"),
-       facebook::velox::util::fromTimestampString("1974-12-15 10:20:00.500"),
-       facebook::velox::util::fromTimestampString("2024-05-31 10:00:00.500")});
+      {parseTimestamp("1975-06-01 01:00:00.500"),
+       parseTimestamp("1974-12-15 10:20:00.500"),
+       parseTimestamp("2024-05-31 10:00:00.500")});
 
   auto stepVector = makeFlatVector<int32_t>({0, 0, 0}, INTERVAL_DAY_TIME());
   testExpressionWithError(
@@ -442,19 +451,17 @@ TEST_F(SequenceTest, timestampInvalidYearMonthStep) {
 
   auto expected = makeNullableArrayVector<Timestamp>(
       {// last day of Feb
-       {{facebook::velox::util::fromTimestampString("1975-01-31 10:00:00.500"),
-         facebook::velox::util::fromTimestampString("1975-02-28 10:00:00.500"),
-         facebook::velox::util::fromTimestampString("1975-03-31 10:00:00.500"),
-         facebook::velox::util::fromTimestampString("1975-04-30 10:00:00.500"),
-         facebook::velox::util::fromTimestampString(
-             "1975-05-31 10:00:00.500")}},
+       {{parseTimestamp("1975-01-31 10:00:00.500"),
+         parseTimestamp("1975-02-28 10:00:00.500"),
+         parseTimestamp("1975-03-31 10:00:00.500"),
+         parseTimestamp("1975-04-30 10:00:00.500"),
+         parseTimestamp("1975-05-31 10:00:00.500")}},
        std::nullopt,
        // leap year
        // result won't include 2024-05-31 10:00:00.500
-       {{facebook::velox::util::fromTimestampString("2023-12-31 23:00:00.500"),
-         facebook::velox::util::fromTimestampString("2024-02-29 23:00:00.500"),
-         facebook::velox::util::fromTimestampString(
-             "2024-04-30 23:00:00.500")}}});
+       {{parseTimestamp("2023-12-31 23:00:00.500"),
+         parseTimestamp("2024-02-29 23:00:00.500"),
+         parseTimestamp("2024-04-30 23:00:00.500")}}});
   testExpression(
       "try(sequence(C0, C1, C2))",
       {startVector, stopVector, stepVector},
@@ -463,13 +470,13 @@ TEST_F(SequenceTest, timestampInvalidYearMonthStep) {
 
 TEST_F(SequenceTest, timestampIntervalExceedMaxEntries) {
   const auto startVector = makeFlatVector<Timestamp>(
-      {facebook::velox::util::fromTimestampString("1975-01-31 10:00:00.500"),
-       facebook::velox::util::fromTimestampString("1975-03-15 10:10:10.200"),
-       facebook::velox::util::fromTimestampString("2023-12-31 23:00:00.500")});
+      {parseTimestamp("1975-01-31 10:00:00.500"),
+       parseTimestamp("1975-03-15 10:10:10.200"),
+       parseTimestamp("2023-12-31 23:00:00.500")});
   const auto stopVector = makeFlatVector<Timestamp>(
-      {facebook::velox::util::fromTimestampString("3975-06-01 01:00:00.500"),
-       facebook::velox::util::fromTimestampString("3974-12-15 10:20:00.500"),
-       facebook::velox::util::fromTimestampString("4024-05-31 10:00:00.500")});
+      {parseTimestamp("3975-06-01 01:00:00.500"),
+       parseTimestamp("3974-12-15 10:20:00.500"),
+       parseTimestamp("4024-05-31 10:00:00.500")});
   auto stepVector = makeFlatVector<int32_t>({1, 1, 1}, INTERVAL_YEAR_MONTH());
   testExpressionWithError(
       "sequence(C0, C1, C2)",
diff --git a/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp b/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
index 9c644d37f6fad..c4a6e4edf2023 100644
--- a/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
+++ b/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
@@ -29,6 +29,10 @@ namespace {
 class SimpleComparisonMatcherTest : public testing::Test,
                                     public test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
     functions::prestosql::registerAllScalarFunctions(prefix_);
     parse::registerTypeResolver();
@@ -43,7 +47,7 @@ class SimpleComparisonMatcherTest : public testing::Test,
     return core::Expressions::inferTypes(untyped, rowType, execCtx_->pool());
   }
 
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
+  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
   std::unique_ptr<core::ExecCtx> execCtx_{
       std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
   const std::string prefix_ = "tp.";
diff --git a/velox/functions/prestosql/tests/SliceTest.cpp b/velox/functions/prestosql/tests/SliceTest.cpp
index e598ff9c3dbd0..782a97f1dc812 100644
--- a/velox/functions/prestosql/tests/SliceTest.cpp
+++ b/velox/functions/prestosql/tests/SliceTest.cpp
@@ -13,117 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::test;
-using namespace facebook::velox::functions::test;
+#include "velox/functions/lib/tests/SliceTestBase.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 
+namespace facebook::velox::functions::prestosql {
 namespace {
 
-class SliceTest : public FunctionBaseTest {
+class SliceTest : public test::SliceTestBase {
  protected:
   static const vector_size_t kVectorSize{1000};
-
-  void testSlice(
-      const std::string& expression,
-      const std::vector<VectorPtr>& parameters,
-      const ArrayVectorPtr& expectedArrayVector) {
-    auto result = evaluate<ArrayVector>(expression, makeRowVector(parameters));
-    assertEqualVectors(expectedArrayVector, result);
-    EXPECT_NO_THROW(expectedArrayVector->checkRanges());
+  static void SetUpTestCase() {
+    SliceTestBase::SetUpTestCase();
+    registerAllScalarFunctions();
   }
 };
 
-TEST_F(SliceTest, prestoTestCases) {
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4, 5}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    testSlice("slice(C0, 1, 4)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{1, 2}});
-    testSlice("slice(C0, 1, 4)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4, 5}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{3, 4}});
-    testSlice("slice(C0, 3, 2)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{3, 4}});
-    testSlice("slice(C0, 3, 3)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{2, 3, 4}});
-    testSlice("slice(C0, -3, 3)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{2, 3, 4}});
-    testSlice("slice(C0, -3, 5)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{}});
-    testSlice("slice(C0, 1, 0)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{}});
-    testSlice("slice(C0, -2, 0)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{}});
-    testSlice("slice(C0, -2, 0)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{}});
-    testSlice("slice(C0, -5, 5)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{}});
-    testSlice("slice(C0, -6, 5)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{}});
-    testSlice("slice(C0, -6, 5)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    // The implementation is zero-copy, so floating point number comparison
-    // won't have issue here since numerical representation remains the same.
-    auto arrayVector = makeArrayVector<double>({{2.3, 2.3, 2.2}});
-    auto expectedArrayVector = makeArrayVector<double>({{2.3, 2.2}});
-    testSlice("slice(C0, 2, 3)", {arrayVector}, expectedArrayVector);
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{}});
-    VELOX_ASSERT_THROW(
-        testSlice(
-            "slice(C0, 1, -1)",
-            {arrayVector, arrayVector, expectedArrayVector},
-            expectedArrayVector),
-        "The value of length argument of slice() function should not be negative");
-  }
-  {
-    auto arrayVector = makeArrayVector<int64_t>({{1, 2, 3, 4}});
-    auto expectedArrayVector = makeArrayVector<int64_t>({{}});
-    VELOX_ASSERT_THROW(
-        testSlice(
-            "slice(C0, 0, 1)",
-            {arrayVector, arrayVector, expectedArrayVector},
-            expectedArrayVector),
-        "SQL array indices start at 1");
-  }
+TEST_F(SliceTest, basic) {
+  basicTestCases();
 }
 
 TEST_F(SliceTest, constantInputArray) {
@@ -398,3 +304,4 @@ TEST_F(SliceTest, constantArrayNonConstantLength) {
 }
 
 } // namespace
+} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/tests/SplitToMapTest.cpp b/velox/functions/prestosql/tests/SplitToMapTest.cpp
index 42fee07cd2c99..a8b54fb283147 100644
--- a/velox/functions/prestosql/tests/SplitToMapTest.cpp
+++ b/velox/functions/prestosql/tests/SplitToMapTest.cpp
@@ -22,25 +22,153 @@ namespace {
 class SplitToMapTest : public test::FunctionBaseTest {};
 
 TEST_F(SplitToMapTest, basic) {
+  auto callFunc = [&](const RowVectorPtr& input) {
+    return evaluate("split_to_map(c0, ',', ':')", input);
+  };
+
+  auto tryCallFunc = [&](const RowVectorPtr& input) {
+    auto result = evaluate("try(split_to_map(c0, ',', ':'))", input);
+    auto expected = makeAllNullMapVector(input->size(), VARCHAR(), VARCHAR());
+    velox::test::assertEqualVectors(expected, result);
+  };
+
+  // Valid string cases.
   auto data = makeRowVector({
       makeFlatVector<std::string>({
           "1:10,2:20,3:30,4:",
           "4:40",
           "",
           ":00,1:11,3:33,5:55,7:77",
+          ":",
+          "11:17,",
+          ":,",
+      }),
+  });
+
+  auto result = callFunc(data);
+
+  auto expected = makeMapVector<std::string, std::string>({
+      {{"1", "10"}, {"2", "20"}, {"3", "30"}, {"4", ""}},
+      {{"4", "40"}},
+      {},
+      {{"", "00"}, {"1", "11"}, {"3", "33"}, {"5", "55"}, {"7", "77"}},
+      {{"", ""}},
+      {{"11", "17"}},
+      {{"", ""}},
+  });
+
+  velox::test::assertEqualVectors(expected, result);
+
+  // Invalid string cases.
+  const std::string errorMessage =
+      "Key-value delimiter must appear exactly once in each entry. Bad input:";
+
+  data = makeRowVector({makeFlatVector<std::string>({","})});
+  VELOX_ASSERT_THROW(callFunc(data), errorMessage);
+  tryCallFunc(data);
+
+  data = makeRowVector({makeFlatVector<std::string>({",11:17"})});
+  VELOX_ASSERT_THROW(callFunc(data), errorMessage);
+  tryCallFunc(data);
+
+  data = makeRowVector({makeFlatVector<std::string>({"11:17,,"})});
+  VELOX_ASSERT_THROW(callFunc(data), errorMessage);
+  tryCallFunc(data);
+
+  data = makeRowVector({makeFlatVector<std::string>({"11"})});
+  VELOX_ASSERT_THROW(callFunc(data), errorMessage);
+  tryCallFunc(data);
+}
+
+TEST_F(SplitToMapTest, MultiCharKeyValueDelimiter) {
+  const auto callFunc = [&](const RowVectorPtr& input) {
+    return evaluate("split_to_map(c0, ',', ';=')", input);
+  };
+
+  auto tryCallFunc = [&](const RowVectorPtr& input) {
+    auto result = evaluate("try(split_to_map(c0, ',', ':='))", input);
+    auto expected = makeAllNullMapVector(input->size(), VARCHAR(), VARCHAR());
+    velox::test::assertEqualVectors(expected, result);
+  };
+
+  // Valid string cases.
+  auto data = makeRowVector({
+      makeFlatVector<std::string>(
+          {"1;=10,2;=20,3;=30,4;=",
+           "4;=40,",
+           "",
+           ";=00,1;=11,3;=33,5;=55,7;=77",
+           ";=",
+           "4;=40\",2;=20\""}),
+  });
+
+  auto result = callFunc(data);
+
+  auto expected = makeMapVector<std::string, std::string>(
+      {{{"1", "10"}, {"2", "20"}, {"3", "30"}, {"4", ""}},
+       {{"4", "40"}},
+       {},
+       {{"", "00"}, {"1", "11"}, {"3", "33"}, {"5", "55"}, {"7", "77"}},
+       {{"", ""}},
+       {{"4", "40\""}, {"2", "20\""}}});
+
+  velox::test::assertEqualVectors(expected, result);
+
+  // Invalid string cases.
+  const std::string errorMessage =
+      "Key-value delimiter must appear exactly once in each entry. Bad input:";
+
+  // repeated key value delimiter
+  data = makeRowVector({makeFlatVector<std::string>({"1;=;=10,2;=;=20"})});
+  VELOX_ASSERT_THROW(callFunc(data), errorMessage);
+  tryCallFunc(data);
+
+  // No Delimiter found
+  data = makeRowVector({makeFlatVector<std::string>({"1;=10,,"})});
+  VELOX_ASSERT_THROW(callFunc(data), errorMessage);
+  tryCallFunc(data);
+}
+
+TEST_F(SplitToMapTest, MultiCharEntryDelimiter) {
+  const auto callFunc = [&](const RowVectorPtr& input) {
+    return evaluate("split_to_map(c0, ';;', ';')", input);
+  };
+
+  auto tryCallFunc = [&](const RowVectorPtr& input) {
+    auto result = evaluate("try(split_to_map(c0, ';;', ';'))", input);
+    auto expected = makeAllNullMapVector(input->size(), VARCHAR(), VARCHAR());
+    velox::test::assertEqualVectors(expected, result);
+  };
+
+  // Valid string cases.
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({
+          "1;10;;2;20;;3;30;;4;",
+          "4;40;;",
+          "",
+          ";00;;1;11;;3;33;;5;55;;7;77",
+          ";",
       }),
   });
 
-  auto result = evaluate("split_to_map(c0, ',', ':')", data);
+  auto result = callFunc(data);
 
   auto expected = makeMapVector<std::string, std::string>({
       {{"1", "10"}, {"2", "20"}, {"3", "30"}, {"4", ""}},
       {{"4", "40"}},
       {},
       {{"", "00"}, {"1", "11"}, {"3", "33"}, {"5", "55"}, {"7", "77"}},
+      {{"", ""}},
   });
 
   velox::test::assertEqualVectors(expected, result);
+
+  const std::string errorMessage =
+      "Key-value delimiter must appear exactly once in each entry. Bad input:";
+  // No Delimiter found
+  data = makeRowVector({makeFlatVector<std::string>({"a;b;;;;c;d"})});
+  VELOX_ASSERT_THROW(callFunc(data), errorMessage);
+  tryCallFunc(data);
 }
 
 TEST_F(SplitToMapTest, invalidInput) {
@@ -51,23 +179,93 @@ TEST_F(SplitToMapTest, invalidInput) {
   });
 
   auto splitToMap = [&](const std::string& entryDelimiter,
-                        const std::string& keyValueDelimiter) {
+                        const std::string& keyValueDelimiter,
+                        RowVectorPtr data) {
     evaluate(
         fmt::format(
             "split_to_map(c0, '{}', '{}')", entryDelimiter, keyValueDelimiter),
         data);
   };
 
+  auto trySplitToMap = [&](const std::string& entryDelimiter,
+                           const std::string& keyValueDelimiter,
+                           const RowVectorPtr& data) {
+    SCOPED_TRACE(fmt::format("{} {}", entryDelimiter, keyValueDelimiter));
+    auto result = evaluate(
+        fmt::format(
+            "try(split_to_map(c0, '{}', '{}'))",
+            entryDelimiter,
+            keyValueDelimiter),
+        data);
+    auto expected = makeAllNullMapVector(data->size(), VARCHAR(), VARCHAR());
+    velox::test::assertEqualVectors(expected, result);
+  };
+
   VELOX_ASSERT_THROW(
-      splitToMap(".", "."),
+      splitToMap(".", ".", data),
       "entryDelimiter and keyValueDelimiter must not be the same");
-  VELOX_ASSERT_THROW(splitToMap(".", ""), "keyValueDelimiter is empty");
-  VELOX_ASSERT_THROW(splitToMap("", "."), "entryDelimiter is empty");
+  trySplitToMap(".", ".", data);
+
+  VELOX_ASSERT_THROW(splitToMap(".", "", data), "keyValueDelimiter is empty");
+  trySplitToMap(".", "", data);
+
+  VELOX_ASSERT_THROW(splitToMap("", ".", data), "entryDelimiter is empty");
+  trySplitToMap("", ".", data);
+
   VELOX_ASSERT_THROW(
-      splitToMap(":", ","),
-      "Key-value delimiter must appear exactly once in each entry. Bad input: '1'");
+      splitToMap(":", ",", data),
+      "No delimiter found. Key-value delimiter must appear exactly once in each entry. Bad input: '1'");
+  trySplitToMap(":", ",", data);
+
   VELOX_ASSERT_THROW(
-      splitToMap(",", ":"), "Duplicate keys (1) are not allowed.");
+      splitToMap(",", ":", data), "Duplicate keys (1) are not allowed.");
+  trySplitToMap(",", ":", data);
+
+  data = makeRowVector({
+      makeFlatVector<std::string>({
+          "1::10,2:20,1:30",
+      }),
+  });
+  VELOX_ASSERT_THROW(
+      splitToMap(",", ":", data),
+      "More than one delimiter found. Key-value delimiter must appear exactly once in each entry");
+  trySplitToMap(",", ":", data);
+}
+
+TEST_F(SplitToMapTest, lambda) {
+  auto splitToMap = [&](const std::string& input, const std::string& lambda) {
+    auto rowVector = makeRowVector({
+        makeFlatVector<std::string>({input}),
+    });
+
+    return evaluate(
+        fmt::format("split_to_map(c0, ',', ':', {})", lambda), rowVector);
+  };
+
+  // No duplicate keys.
+  auto result = splitToMap("1:a,2:b,3:c", "(k, v1, v2) -> v1");
+  auto expected = makeMapVector<std::string, std::string>({
+      {{"1", "a"}, {"2", "b"}, {"3", "c"}},
+  });
+  velox::test::assertEqualVectors(expected, result);
+
+  // Duplicate keys. Keep first.
+  result = splitToMap("1:a,2:b,1:c,2:d,3:e", "(k, v1, v2) -> v1");
+  expected = makeMapVector<std::string, std::string>({
+      {{"1", "a"}, {"2", "b"}, {"3", "e"}},
+  });
+  velox::test::assertEqualVectors(expected, result);
+
+  // Duplicate keys. Keep last.
+  result = splitToMap("1:a,2:b,1:c,2:d,3:e", "(k, v1, v2) -> v2");
+  expected = makeMapVector<std::string, std::string>({
+      {{"1", "c"}, {"2", "d"}, {"3", "e"}},
+  });
+  velox::test::assertEqualVectors(expected, result);
+
+  VELOX_ASSERT_USER_THROW(
+      splitToMap("1:a,2:b,1:c,2:d,3:e", "(k, v1, v2) -> concat(v1, v2)"),
+      "split_to_map with arbitrary lambda is not supported");
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/tests/StringFunctionsTest.cpp b/velox/functions/prestosql/tests/StringFunctionsTest.cpp
index 8ee452314ede7..d884a25c2f566 100644
--- a/velox/functions/prestosql/tests/StringFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/StringFunctionsTest.cpp
@@ -406,6 +406,81 @@ TEST_F(StringFunctionsTest, substrVariable) {
   }
 }
 
+TEST_F(StringFunctionsTest, substrInvalidUtf8) {
+  const auto substr = [&](std::optional<std::string> str,
+                          std::optional<int32_t> start,
+                          std::optional<int32_t> length) {
+    return evaluateOnce<std::string>("substr(c0, c1, c2)", str, start, length);
+  };
+
+  // The byte \xE7 indicates it should have 2 more bytes to be valid UTF-8, but
+  // it doesn't.
+  EXPECT_EQ(substr("abc\xE7xyz", 2, 4), "bc\xE7x");
+  // The byte \xBF is a UTF-8 continuation character, these aren't preceded by
+  // a valid prefix byte, but they should be ignored and not count towards the
+  // length of the substring or where the substring starts.
+  EXPECT_EQ(
+      substr(
+          "\xBF"
+          "\xBF"
+          "a"
+          "\xBF"
+          "\xBF"
+          "b"
+          "\xBF"
+          "\xBF"
+          "c"
+          "\xBF"
+          "\xBF"
+          "x"
+          "\xBF"
+          "\xBF"
+          "y"
+          "\xBF"
+          "\xBF"
+          "z"
+          "\xBF"
+          "\xBF",
+          2,
+          4),
+      "b"
+      "\xBF"
+      "\xBF"
+      "c"
+      "\xBF"
+      "\xBF"
+      "x"
+      "\xBF"
+      "\xBF"
+      "y"
+      "\xBF"
+      "\xBF");
+  // Check that when the substring goes to the end of the string, and the string
+  // ends with UTF-8 continuation characters, we don't go off the end of the
+  // string.
+  EXPECT_EQ(
+      substr(
+          "\xBF"
+          "\xBF"
+          "a"
+          "\xBF"
+          "\xBF"
+          "b"
+          "\xBF"
+          "\xBF"
+          "c"
+          "\xBF"
+          "\xBF",
+          2,
+          2),
+      "b"
+      "\xBF"
+      "\xBF"
+      "c"
+      "\xBF"
+      "\xBF");
+}
+
 /**
  * The test for one of non-optimized cases (all constant values)
  */
@@ -591,6 +666,54 @@ TEST_F(StringFunctionsTest, substrWithConditionalSingleBuffer) {
   }
 }
 
+TEST_F(StringFunctionsTest, substrVarbinary) {
+  auto substr = [&](const std::string& input,
+                    int64_t start,
+                    std::optional<int64_t> length = {}) {
+    if (length.has_value()) {
+      return evaluateOnce<std::string>(
+          "substr(c0, c1, c2)",
+          {VARBINARY(), BIGINT(), BIGINT()},
+          std::optional(input),
+          std::optional(start),
+          length);
+    } else {
+      return evaluateOnce<std::string>(
+          "substr(c0, c1)",
+          {VARBINARY(), BIGINT()},
+          std::optional(input),
+          std::optional(start));
+    }
+  };
+
+  EXPECT_EQ(substr("Apple", 0), "");
+  EXPECT_EQ(substr("Apple", 1), "Apple");
+  EXPECT_EQ(substr("Apple", 3), "ple");
+  EXPECT_EQ(substr("Apple", 5), "e");
+  EXPECT_EQ(substr("Apple", 100), "");
+
+  EXPECT_EQ(substr("Apple", -1), "e");
+  EXPECT_EQ(substr("Apple", -4), "pple");
+  EXPECT_EQ(substr("Apple", -5), "Apple");
+  EXPECT_EQ(substr("Apple", -100), "");
+
+  EXPECT_EQ(substr("", 0), "");
+  EXPECT_EQ(substr("", 1), "");
+  EXPECT_EQ(substr("", -1), "");
+
+  EXPECT_EQ(substr("Apple", 1, 1), "A");
+  EXPECT_EQ(substr("Apple", 2, 3), "ppl");
+  EXPECT_EQ(substr("Apple", 2, 4), "pple");
+  EXPECT_EQ(substr("Apple", 2, 10), "pple");
+
+  EXPECT_EQ(substr("Apple", -1, 1), "e");
+  EXPECT_EQ(substr("Apple", -3, 2), "pl");
+  EXPECT_EQ(substr("Apple", -3, 5), "ple");
+  EXPECT_EQ(substr("Apple", -5, 4), "Appl");
+  EXPECT_EQ(substr("Apple", -5, 10), "Apple");
+  EXPECT_EQ(substr("Apple", -6, 1), "");
+}
+
 namespace {
 std::vector<std::tuple<std::string, std::string>> getUpperAsciiTestData() {
   return {
@@ -809,6 +932,36 @@ TEST_F(StringFunctionsTest, concat) {
   }
 }
 
+TEST_F(StringFunctionsTest, concatVarbinary) {
+  auto input = makeRowVector({
+      makeFlatVector<std::string>(
+          {
+              "apple",
+              "orange",
+              "pineapple",
+              "mixed berries",
+              "",
+              "plum",
+          },
+          VARBINARY()),
+  });
+
+  auto result =
+      evaluate("concat(c0, '_'::varbinary, c0, '_'::varbinary, c0)", input);
+  auto expected = makeFlatVector<std::string>(
+      {
+          "apple_apple_apple",
+          "orange_orange_orange",
+          "pineapple_pineapple_pineapple",
+          "mixed berries_mixed berries_mixed berries",
+          "__",
+          "plum_plum_plum",
+      },
+      VARBINARY());
+
+  test::assertEqualVectors(expected, result);
+}
+
 // Test length vector function
 TEST_F(StringFunctionsTest, length) {
   auto lengthUtf8Ref = [](std::string string) {
@@ -1415,6 +1568,27 @@ TEST_F(StringFunctionsTest, reverse) {
   EXPECT_EQ(reverse(invalidIncompleteString), "\xa0\xed");
 }
 
+TEST_F(StringFunctionsTest, varbinaryReverse) {
+  // Reversing binary string with multi-byte unicode characters doesn't preserve
+  // the characters.
+  auto input =
+      makeFlatVector<std::string>({"hi", "", "\u4FE1 \u7231"}, VARBINARY());
+
+  // \u4FE1 character is 3 bytes: \xE4\xBF\xA1
+  // \u7231 character is 3 bytes: \xE7\x88\xB1
+  auto expected = makeFlatVector<std::string>(
+      {"ih", "", "\xB1\x88\xE7 \xA1\xBF\xE4"}, VARBINARY());
+  auto result = evaluate("reverse(c0)", makeRowVector({input}));
+  test::assertEqualVectors(expected, result);
+
+  // Reversing same string as varchar preserves the characters.
+  input = makeFlatVector<std::string>({"hi", "", "\u4FE1 \u7231"}, VARCHAR());
+  expected = makeFlatVector<std::string>(
+      {"ih", "", "\xE7\x88\xB1 \xE4\xBF\xA1"}, VARCHAR());
+  result = evaluate("reverse(c0)", makeRowVector({input}));
+  test::assertEqualVectors(expected, result);
+}
+
 TEST_F(StringFunctionsTest, toUtf8) {
   const auto toUtf8 = [&](std::optional<std::string> value) {
     return evaluateOnce<std::string>("to_utf8(c0)", value);
@@ -1841,3 +2015,142 @@ TEST_F(StringFunctionsTest, varbinaryLength) {
   auto result = evaluate("length(c0)", makeRowVector({vector}));
   test::assertEqualVectors(expected, result);
 }
+
+TEST_F(StringFunctionsTest, hammingDistance) {
+  const auto hammingDistance = [&](std::optional<std::string> left,
+                                   std::optional<std::string> right) {
+    return evaluateOnce<int64_t>("hamming_distance(c0, c1)", left, right);
+  };
+
+  EXPECT_EQ(hammingDistance("", ""), 0);
+  EXPECT_EQ(hammingDistance(" ", " "), 0);
+  EXPECT_EQ(hammingDistance("6", "6"), 0);
+  EXPECT_EQ(hammingDistance("z", "z"), 0);
+  EXPECT_EQ(hammingDistance("a", "b"), 1);
+  EXPECT_EQ(hammingDistance("b", "B"), 1);
+  EXPECT_EQ(hammingDistance("hello", "hello"), 0);
+  EXPECT_EQ(hammingDistance("hello", "jello"), 1);
+  EXPECT_EQ(hammingDistance("like", "hate"), 3);
+  EXPECT_EQ(hammingDistance("hello", "world"), 4);
+  EXPECT_EQ(hammingDistance("Customs", "Luptoki"), 4);
+  EXPECT_EQ(hammingDistance("This is lame", "Why to slam "), 8);
+  EXPECT_EQ(
+      hammingDistance(
+          "The quick brown fox jumps over the lazy dog",
+          "The quick green dog jumps over the grey pot"),
+      10);
+
+  EXPECT_EQ(hammingDistance("hello na\u00EFve world", "hello naive world"), 1);
+  EXPECT_EQ(
+      hammingDistance(
+          "The quick b\u0155\u00F6wn fox jumps over the laz\uFF59 dog",
+          "The quick br\u006Fwn fox jumps over the la\u1E91y dog"),
+      4);
+  EXPECT_EQ(
+      hammingDistance(
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B",
+          "\u4FE1\u4EF0,\u7231,\u5E0C\u671B"),
+      1);
+  EXPECT_EQ(
+      hammingDistance(
+          "\u4F11\u5FF5,\u7231,\u5E0C\u671B",
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B"),
+      1);
+  EXPECT_EQ(hammingDistance("\u0001", "\u0001"), 0);
+  EXPECT_EQ(hammingDistance("\u0001", "\u0002"), 1);
+  // Test equal null characters on ASCII path.
+  EXPECT_EQ(
+      hammingDistance(std::string("\u0000", 1), std::string("\u0000", 1)), 0);
+  // Test null and non-null character on ASCII path.
+  EXPECT_EQ(hammingDistance(std::string("\u0000", 1), "\u0001"), 1);
+  // Test null and non-null character on non-ASCII path.
+  EXPECT_EQ(hammingDistance(std::string("\u0000", 1), "\u7231"), 1);
+  // Test equal null characters on non-ASCII path.
+  EXPECT_EQ(
+      hammingDistance(
+          std::string("\u7231\u0000", 2), std::string("\u7231\u0000", 2)),
+      0);
+  // Test invalid UTF-8 characters.
+  EXPECT_EQ(hammingDistance("\xFF\xFF", "\xF0\x82"), 0);
+
+  VELOX_ASSERT_THROW(
+      hammingDistance("\u0000", "\u0001"),
+      "The input strings to hamming_distance function must have the same length");
+  VELOX_ASSERT_THROW(
+      hammingDistance("hello", ""),
+      "The input strings to hamming_distance function must have the same length");
+  VELOX_ASSERT_THROW(
+      hammingDistance("", "hello"),
+      "The input strings to hamming_distance function must have the same length");
+  VELOX_ASSERT_THROW(
+      hammingDistance("hello", "o"),
+      "The input strings to hamming_distance function must have the same length");
+  VELOX_ASSERT_THROW(
+      hammingDistance("h", "hello"),
+      "The input strings to hamming_distance function must have the same length");
+  VELOX_ASSERT_THROW(
+      hammingDistance("hello na\u00EFve world", "hello na:ive world"),
+      "The input strings to hamming_distance function must have the same length");
+  VELOX_ASSERT_THROW(
+      hammingDistance(
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B", "\u4FE1\u5FF5\u5E0C\u671B"),
+      "The input strings to hamming_distance function must have the same length");
+  // Test invalid UTF-8 characters.
+  VELOX_ASSERT_THROW(
+      hammingDistance("\xFF\x82\xFF", "\xF0\x82"),
+      "The input strings to hamming_distance function must have the same length");
+}
+
+TEST_F(StringFunctionsTest, normalize) {
+  const auto normalizeWithoutForm = [&](std::optional<std::string> string) {
+    return evaluateOnce<std::string>("normalize(c0)", string);
+  };
+
+  const auto normalizeWithForm = [&](std::optional<std::string> string,
+                                     const std::string& form) {
+    return evaluateOnce<std::string>(
+        fmt::format("normalize(c0, '{}')", form), string);
+  };
+
+  EXPECT_EQ(normalizeWithoutForm(std::nullopt), std::nullopt);
+  EXPECT_EQ(normalizeWithoutForm(""), "");
+  EXPECT_EQ(normalizeWithoutForm("sch\u00f6n"), "sch\u00f6n");
+  EXPECT_EQ(normalizeWithForm(std::nullopt, "NFD"), std::nullopt);
+  EXPECT_EQ(normalizeWithForm("", "NFKC"), "");
+  EXPECT_EQ(
+      normalizeWithForm(
+          (normalizeWithForm("sch\u00f6n", "NFD"), "scho\u0308n"), "NFC"),
+      "sch\u00f6n");
+  EXPECT_EQ(
+      normalizeWithForm(
+          (normalizeWithForm("sch\u00f6n", "NFKD"), "scho\u0308n"), "NFKC"),
+      "sch\u00f6n");
+  EXPECT_EQ(
+      normalizeWithForm("Hello world from Velox!!", "NFKC"),
+      "Hello world from Velox!!");
+
+  std::string testStringOne =
+      "\u3231\u3327\u3326\u2162\u3231\u3327\u3326\u2162\u3231\u3327\u3326\u2162";
+  std::string testStringTwo =
+      "(\u682a)\u30c8\u30f3\u30c9\u30ebIII(\u682a)\u30c8\u30f3\u30c9\u30ebIII(\u682a)\u30c8\u30f3\u30c9\u30ebIII";
+  EXPECT_EQ(normalizeWithForm(testStringOne, "NFKC"), testStringTwo);
+  EXPECT_EQ(
+      normalizeWithForm((normalizeWithForm(testStringTwo, "NFC")), "NFKC"),
+      testStringTwo);
+
+  std::string testStringThree =
+      "\uff8a\uff9d\uff76\uff78\uff76\uff85\uff8a\uff9d\uff76\uff78\uff76\uff85\uff8a\uff9d\uff76\uff78\uff76\uff85\uff8a\uff9d\uff76\uff78\uff76\uff85";
+  std::string testStringFour =
+      "\u30cf\u30f3\u30ab\u30af\u30ab\u30ca\u30cf\u30f3\u30ab\u30af\u30ab\u30ca\u30cf\u30f3\u30ab\u30af\u30ab\u30ca\u30cf\u30f3\u30ab\u30af\u30ab\u30ca";
+  EXPECT_EQ(normalizeWithForm(testStringThree, "NFKC"), testStringFour);
+  EXPECT_EQ(
+      normalizeWithForm((normalizeWithForm(testStringFour, "NFD")), "NFKC"),
+      testStringFour);
+
+  // Invalid UTF-8 string
+  std::string inValidTestString = "\xEF\xBE\x8";
+  EXPECT_EQ(normalizeWithForm(inValidTestString, "NFKC"), inValidTestString);
+  VELOX_ASSERT_THROW(
+      normalizeWithForm("sch\u00f6n", "NFKE"),
+      "Normalization form must be one of [NFD, NFC, NFKD, NFKC]");
+}
diff --git a/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp b/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
index 803f5b265a5d5..6b9990ada9245 100644
--- a/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
+++ b/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
@@ -16,44 +16,281 @@
 
 #include "velox/functions/prestosql/tests/CastBaseTest.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/tz/TimeZoneMap.h"
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
 
 class TimestampWithTimeZoneCastTest : public functions::test::CastBaseTest {
  public:
-  RowVectorPtr makeTimestampWithTimeZoneVector(
-      const VectorPtr& timestamps,
-      const VectorPtr& timezones) {
-    VELOX_CHECK_EQ(timestamps->size(), timezones->size());
-    return std::make_shared<RowVector>(
-        pool(),
-        TIMESTAMP_WITH_TIME_ZONE(),
+  VectorPtr makeTimestampWithTimeZoneVector(
+      vector_size_t size,
+      const std::function<int64_t(int32_t row)>& timestampAt,
+      const std::function<int16_t(int32_t row)>& timezoneAt) {
+    return makeFlatVector<int64_t>(
+        size,
+        [&](int32_t index) {
+          return pack(timestampAt(index), timezoneAt(index));
+        },
         nullptr,
-        timestamps->size(),
-        std::vector<VectorPtr>({timestamps, timezones}));
+        TIMESTAMP_WITH_TIME_ZONE());
+  }
+
+ protected:
+  void setQueryTimeZone(const std::string& timeZone) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+
+  void disableAdjustTimestampToTimezone() {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kAdjustTimestampToTimezone, "false"},
+    });
   }
 };
 
 TEST_F(TimestampWithTimeZoneCastTest, fromTimestamp) {
   const auto tsVector = makeNullableFlatVector<Timestamp>(
       {Timestamp(1996, 0), std::nullopt, Timestamp(19920, 0)});
+  auto timestamps =
+      std::vector<int64_t>{1996 * kMillisInSecond, 0, 19920 * kMillisInSecond};
+  auto timezones = std::vector<TimeZoneKey>{0, 0, 0};
   const auto expected = makeTimestampWithTimeZoneVector(
-      makeFlatVector<int64_t>(
-          {1996 * kMillisInSecond, 0, 19920 * kMillisInSecond}),
-      makeFlatVector<int16_t>({0, 0, 0}));
+      timestamps.size(),
+      [&](int32_t index) { return timestamps[index]; },
+      [&](int32_t index) { return timezones[index]; });
   expected->setNull(1, true);
 
-  testCast(TIMESTAMP(), TIMESTAMP_WITH_TIME_ZONE(), tsVector, expected);
+  testCast(tsVector, expected);
+}
+
+TEST_F(TimestampWithTimeZoneCastTest, fromVarchar) {
+  const auto stringVector = makeNullableFlatVector<StringView>(
+      {std::nullopt,
+       "2012-10-31 01:00:47 America/Denver",
+       "2012-10-31 01:00:47 -06:00",
+       "1994-05-06 15:49 Europe/Vienna",
+       "1979-02-24 08:33:31 Pacific/Chatham",
+       "1979-02-24 08:33:31 +13:45"});
+
+  // Varchar representations above hold local time (relative to specified time
+  // zone). For instance, the first string represents a wall-clock displaying
+  // '2012-10-31 01:00:47' in Denver. Below, we use UTC representations of the
+  // above local wall-clocks, to match the UTC timepoints held in the
+  // TimestampWithTimezone type.
+  auto denverUTC = parseTimestamp("2012-10-31 07:00:47").toMillis();
+  auto viennaUTC = parseTimestamp("1994-05-06 13:49:00").toMillis();
+  auto chathamUTC = parseTimestamp("1979-02-23 18:48:31").toMillis();
+
+  auto timestamps = std::vector<int64_t>{
+      0, denverUTC, denverUTC, viennaUTC, chathamUTC, chathamUTC};
+
+  auto timezones = std::vector<TimeZoneKey>{
+      {0,
+       (int16_t)tz::getTimeZoneID("America/Denver"),
+       (int16_t)tz::getTimeZoneID("-06:00"),
+       (int16_t)tz::getTimeZoneID("Europe/Vienna"),
+       (int16_t)tz::getTimeZoneID("Pacific/Chatham"),
+       (int16_t)tz::getTimeZoneID("+13:45")}};
+
+  const auto expected = makeTimestampWithTimeZoneVector(
+      timestamps.size(),
+      [&](int32_t index) { return timestamps[index]; },
+      [&](int32_t index) { return timezones[index]; });
+  expected->setNull(0, true);
+
+  testCast(stringVector, expected);
+}
+
+TEST_F(TimestampWithTimeZoneCastTest, toVarchar) {
+  // 1970-01-01 06:11:37.123 UTC in 4 different time zones.
+  const int64_t utcMillis =
+      6 * kMillisInHour + 11 * kMillisInMinute + 37 * kMillisInSecond + 123;
+  auto input = makeFlatVector<int64_t>(
+      {
+          // -5 hours.
+          pack(utcMillis, tz::getTimeZoneID("America/New_York")),
+          // -8 hours.
+          pack(utcMillis, tz::getTimeZoneID("America/Los_Angeles")),
+          // +8 hours.
+          pack(utcMillis, tz::getTimeZoneID("Asia/Shanghai")),
+          // +5:30 hours.
+          pack(utcMillis, tz::getTimeZoneID("Asia/Calcutta")),
+      },
+      TIMESTAMP_WITH_TIME_ZONE());
+
+  auto expected = makeFlatVector<std::string>({
+      "1970-01-01 01:11:37.123 America/New_York",
+      "1969-12-31 22:11:37.123 America/Los_Angeles",
+      "1970-01-01 14:11:37.123 Asia/Shanghai",
+      "1970-01-01 11:41:37.123 Asia/Calcutta",
+  });
+
+  auto result = evaluate("cast(c0 as varchar)", makeRowVector({input}));
+  test::assertEqualVectors(expected, result);
+}
+
+TEST_F(TimestampWithTimeZoneCastTest, fromVarcharWithoutTimezone) {
+  setQueryTimeZone("America/Denver");
+
+  const auto stringVector =
+      makeNullableFlatVector<StringView>({"2012-10-31 01:00:47"});
+  auto denverUTC = parseTimestamp("2012-10-31 07:00:47").toMillis();
+
+  auto timestamps = std::vector<int64_t>{denverUTC};
+
+  auto timezones =
+      std::vector<TimeZoneKey>{(int16_t)tz::getTimeZoneID("America/Denver")};
+
+  const auto expected = makeTimestampWithTimeZoneVector(
+      timestamps.size(),
+      [&](int32_t index) { return timestamps[index]; },
+      [&](int32_t index) { return timezones[index]; });
+
+  testCast(stringVector, expected);
+}
+
+TEST_F(TimestampWithTimeZoneCastTest, fromVarcharInvalidInput) {
+  const auto invalidStringVector1 = makeNullableFlatVector<StringView>(
+      {"2012-10-31 01:00:47fooAmerica/Los_Angeles"});
+
+  const auto invalidStringVector2 = makeNullableFlatVector<StringView>(
+      {"2012-10-31 01:00:47 America/California"});
+
+  const auto invalidStringVector3 = makeNullableFlatVector<StringView>(
+      {"2012-10-31foo01:00:47 America/Los_Angeles"});
+
+  const auto invalidStringVector4 = makeNullableFlatVector<StringView>(
+      {"2012-10-31 35:00:47 America/Los_Angeles"});
+
+  auto millis = parseTimestamp("2012-10-31 07:00:47").toMillis();
+  auto timestamps = std::vector<int64_t>{millis};
+
+  auto timezones =
+      std::vector<TimeZoneKey>{(int16_t)tz::getTimeZoneID("America/Denver")};
+
+  const auto expected = makeTimestampWithTimeZoneVector(
+      timestamps.size(),
+      [&](int32_t index) { return timestamps[index]; },
+      [&](int32_t index) { return timezones[index]; });
+
+  VELOX_ASSERT_THROW(
+      testCast(invalidStringVector1, expected),
+      "Unknown timezone value: \"fooAmerica/Los_Angeles\"");
+  VELOX_ASSERT_THROW(
+      testCast(invalidStringVector2, expected),
+      "Unknown timezone value: \"America/California\"");
+  VELOX_ASSERT_THROW(
+      testCast(invalidStringVector3, expected),
+      "Unable to parse timestamp value: \"2012-10-31foo01:00:47 America/Los_Angeles\"");
+  VELOX_ASSERT_THROW(
+      testCast(invalidStringVector4, expected),
+      "Unable to parse timestamp value: \"2012-10-31 35:00:47 America/Los_Angeles\"");
 }
 
 TEST_F(TimestampWithTimeZoneCastTest, toTimestamp) {
+  auto timestamps =
+      std::vector<int64_t>{1996 * kMillisInSecond, 0, 19920 * kMillisInSecond};
+  auto timezones = std::vector<TimeZoneKey>{0, 0, 1825 /*America/Los_Angeles*/};
+
   const auto tsWithTZVector = makeTimestampWithTimeZoneVector(
-      makeFlatVector<int64_t>(
-          {1996 * kMillisInSecond, 0, 19920 * kMillisInSecond}),
-      makeFlatVector<int16_t>({0, 0, 1825 /*America/Los_Angeles*/}));
+      timestamps.size(),
+      [&](int32_t index) { return timestamps[index]; },
+      [&](int32_t index) { return timezones[index]; });
   tsWithTZVector->setNull(1, true);
-  const auto expected = makeNullableFlatVector<Timestamp>(
+
+  for (const char* timezone : {"America/Los_Angeles", "America/New_York"}) {
+    setQueryTimeZone(timezone);
+    auto expected = makeNullableFlatVector<Timestamp>(
+        {Timestamp(1996, 0), std::nullopt, Timestamp(19920, 0)});
+    testCast(tsWithTZVector, expected);
+
+    // Cast('1969-12-31 16:00:00 -08:00' as timestamp).
+    auto result = evaluateOnce<Timestamp>(
+        "cast(from_unixtime(c0, 'America/Los_Angeles') as timestamp)",
+        makeRowVector({makeFlatVector<double>(std::vector<double>(1, 0))}));
+    // 1970-01-01 00:00:00.
+    EXPECT_EQ(Timestamp(0, 0), result.value());
+  }
+
+  disableAdjustTimestampToTimezone();
+  auto expected = makeNullableFlatVector<Timestamp>(
       {Timestamp(1996, 0), std::nullopt, Timestamp(19920 - 8 * 3600, 0)});
+  testCast(tsWithTZVector, expected);
+
+  // Cast('1969-12-31 16:00:00 -08:00' as timestamp).
+  auto result = evaluateOnce<Timestamp>(
+      "cast(from_unixtime(c0, 'America/Los_Angeles') as timestamp)",
+      makeRowVector({makeFlatVector<double>(std::vector<double>(1, 0))}));
+  // 1969-12-31 16:00:00.
+  EXPECT_EQ(Timestamp(-28800, 0), result.value());
+}
+
+TEST_F(TimestampWithTimeZoneCastTest, toDate) {
+  auto input = makeFlatVector<int64_t>(
+      {
+          // 6AM UTC is 1AM EST (same day), 10PM PST (previous day), 2PM CST
+          // (same day).
+          pack(6 * kMillisInHour, tz::getTimeZoneID("America/New_York")),
+          pack(6 * kMillisInHour, tz::getTimeZoneID("America/Los_Angeles")),
+          pack(6 * kMillisInHour, tz::getTimeZoneID("Asia/Shanghai")),
+          // 6PM UTC is 1PM EST (same day), 10AM PST (same day), 2AM CST (next
+          // day).
+          pack(18 * kMillisInHour, tz::getTimeZoneID("America/New_York")),
+          pack(18 * kMillisInHour, tz::getTimeZoneID("America/Los_Angeles")),
+          pack(18 * kMillisInHour, tz::getTimeZoneID("Asia/Shanghai")),
+      },
+      TIMESTAMP_WITH_TIME_ZONE());
+  auto expected = makeFlatVector<int32_t>({0, -1, 0, 0, 0, 1}, DATE());
+
+  auto result = evaluate("cast(c0 as date)", makeRowVector({input}));
+  test::assertEqualVectors(expected, result);
+
+  // Verify that session time zone doesn't affect the result.
 
-  testCast(TIMESTAMP_WITH_TIME_ZONE(), TIMESTAMP(), tsWithTZVector, expected);
+  for (auto tz : {"America/New_York", "America/Los_Angeles", "Asia/Shanghai"}) {
+    setQueryTimeZone(tz);
+    result = evaluate("cast(c0 as date)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
 }
+
+TEST_F(TimestampWithTimeZoneCastTest, fromDate) {
+  auto input = makeFlatVector<int32_t>({-1, 0, 1}, DATE());
+
+  setQueryTimeZone("America/New_York");
+
+  auto tzId = tz::getTimeZoneID("America/New_York");
+  auto tzOffset = -5 * kMillisInHour;
+  auto expected = makeFlatVector<int64_t>(
+      {
+          pack(-kMillisInDay - tzOffset, tzId),
+          pack(-tzOffset, tzId),
+          pack(kMillisInDay - tzOffset, tzId),
+      },
+      TIMESTAMP_WITH_TIME_ZONE());
+  auto result =
+      evaluate("cast(c0 as timestamp with time zone)", makeRowVector({input}));
+  test::assertEqualVectors(expected, result);
+
+  setQueryTimeZone("Asia/Shanghai");
+
+  tzId = tz::getTimeZoneID("Asia/Shanghai");
+  tzOffset = 8 * kMillisInHour;
+  expected = makeFlatVector<int64_t>(
+      {
+          pack(-kMillisInDay - tzOffset, tzId),
+          pack(-tzOffset, tzId),
+          pack(kMillisInDay - tzOffset, tzId),
+      },
+      TIMESTAMP_WITH_TIME_ZONE());
+
+  result =
+      evaluate("cast(c0 as timestamp with time zone)", makeRowVector({input}));
+  test::assertEqualVectors(expected, result);
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/TransformKeysTest.cpp b/velox/functions/prestosql/tests/TransformKeysTest.cpp
index 5eb2d2fb604f1..1fda68b55bf21 100644
--- a/velox/functions/prestosql/tests/TransformKeysTest.cpp
+++ b/velox/functions/prestosql/tests/TransformKeysTest.cpp
@@ -69,19 +69,33 @@ TEST_F(TransformKeysTest, evaluateSubsetOfRows) {
           nullEvery(13)),
   });
 
-  SelectivityVector inputRows(size, false);
-  inputRows.setValidRange(0, size / 3, true);
-  inputRows.updateBounds();
+  // Test using 2 selectivity vectors. One of size 100 with 33 first rows
+  // selected. Another of size 33 with all rows selected. Both should produce
+  // the same result.
 
-  auto result = evaluate<MapVector>(
-      "transform_keys(c0, (k, v) -> k + 5)", input, inputRows);
   auto expectedResult = makeMapVector<int64_t, int32_t>(
       size / 3,
       [](auto row) { return row % 5; },
       [](auto row) { return row % 7 + 5; },
       [](auto row) { return row % 11; },
       nullEvery(13));
-  assertEqualVectors(expectedResult, result, inputRows);
+
+  {
+    SelectivityVector inputRows(size, false);
+    inputRows.setValidRange(0, size / 3, true);
+    inputRows.updateBounds();
+
+    auto result = evaluate<MapVector>(
+        "transform_keys(c0, (k, v) -> k + 5)", input, inputRows);
+    assertEqualVectors(expectedResult, result, inputRows);
+  }
+
+  {
+    SelectivityVector inputRows(size / 3);
+    auto result = evaluate<MapVector>(
+        "transform_keys(c0, (k, v) -> k + 5)", input, inputRows);
+    assertEqualVectors(expectedResult, result, inputRows);
+  }
 }
 
 TEST_F(TransformKeysTest, duplicateKeys) {
@@ -103,6 +117,80 @@ TEST_F(TransformKeysTest, duplicateKeys) {
       evaluate("try(transform_keys(c0, (k, v) -> 10 + k % 2))", input));
 }
 
+TEST_F(TransformKeysTest, nullKeys) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int32_t, int64_t>({
+          "{1: 10, 2: 20, 3: 30}",
+          "{1: 10, 2: 20}",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("transform_keys(c0, (k, v) -> null::double)", data),
+      "map key cannot be null");
+
+  auto result =
+      evaluate("try(transform_keys(c0, (k, v) -> null::double))", data);
+  VectorPtr expected =
+      BaseVector::createNullConstant(MAP(DOUBLE(), BIGINT()), 2, pool());
+  assertEqualVectors(expected, result);
+
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "transform_keys(c0, (k, v) -> if (k < 3, k::double + 0.5, null::double))",
+          data),
+      "map key cannot be null");
+
+  result = evaluate(
+      "try(transform_keys(c0, (k, v) -> if (k < 3, k::double + 0.5, null::double)))",
+      data);
+  expected = makeMapVectorFromJson<double, int64_t>({
+      "null",
+      "{1.5: 10, 2.5: 20}",
+  });
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(TransformKeysTest, indeterminateKeys) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int32_t, int64_t>({
+          "{1: 10, 2: 20, 3: 30}",
+          "{1: 10, 2: 20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, null, 2]",
+          "[1, null, 2]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("transform_keys(c0, (k, v) -> c1)", data),
+      "map key cannot be indeterminate");
+
+  auto result = evaluate("try(transform_keys(c0, (k, v) -> c1))", data);
+  VectorPtr expected =
+      BaseVector::createNullConstant(MAP(ARRAY(BIGINT()), BIGINT()), 2, pool());
+  assertEqualVectors(expected, result);
+
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "transform_keys(c0, (k, v) -> if (k < 3, sequence(0, k), c1))", data),
+      "map key cannot be indeterminate");
+
+  result = evaluate(
+      "try(transform_keys(c0, (k, v) -> if (k < 3, sequence(0, k), c1)))",
+      data);
+  expected = makeMapVector(
+      {0, 0},
+      makeArrayVectorFromJson<int64_t>({
+          "[0, 1]",
+          "[0, 1, 2]",
+      }),
+      makeFlatVector<int64_t>({10, 20}));
+  expected->setNull(0, true);
+  assertEqualVectors(expected, result);
+}
+
 TEST_F(TransformKeysTest, differentResultType) {
   vector_size_t size = 1'000;
   auto input = makeRowVector({
diff --git a/velox/functions/prestosql/tests/TransformTest.cpp b/velox/functions/prestosql/tests/TransformTest.cpp
index d48e997465210..01b470d4fc462 100644
--- a/velox/functions/prestosql/tests/TransformTest.cpp
+++ b/velox/functions/prestosql/tests/TransformTest.cpp
@@ -45,19 +45,32 @@ TEST_F(TransformTest, evaluateSubsetOfRows) {
   auto input = makeRowVector(
       {makeArrayVector<int64_t>(size, modN(5), modN(7), nullEvery(11))});
 
-  SelectivityVector inputRows(size, false);
-  inputRows.setValidRange(0, size / 3, true);
-  inputRows.updateBounds();
-
-  auto result =
-      evaluate<ArrayVector>("transform(c0, x -> x + 5)", input, inputRows);
+  // Test using 2 selectivity vectors. One of size 100 with 33 first rows
+  // selected. Another of size 33 with all rows selected. Both should produce
+  // the same result.
 
   auto expectedResult = makeArrayVector<int64_t>(
       size / 3,
       modN(5),
       [](vector_size_t row) { return row % 7 + 5; },
       nullEvery(11));
-  assertEqualVectors(expectedResult, result, inputRows);
+  {
+    SelectivityVector inputRows(size, false);
+    inputRows.setValidRange(0, size / 3, true);
+    inputRows.updateBounds();
+
+    auto result =
+        evaluate<ArrayVector>("transform(c0, x -> x + 5)", input, inputRows);
+    assertEqualVectors(expectedResult, result, inputRows);
+  }
+
+  {
+    SelectivityVector inputRows(size / 3);
+
+    auto result =
+        evaluate<ArrayVector>("transform(c0, x -> x + 5)", input, inputRows);
+    assertEqualVectors(expectedResult, result, inputRows);
+  }
 }
 
 TEST_F(TransformTest, differentResultType) {
diff --git a/velox/functions/prestosql/tests/TransformValuesTest.cpp b/velox/functions/prestosql/tests/TransformValuesTest.cpp
index 9347725b2bc67..b851a5935df72 100644
--- a/velox/functions/prestosql/tests/TransformValuesTest.cpp
+++ b/velox/functions/prestosql/tests/TransformValuesTest.cpp
@@ -69,19 +69,33 @@ TEST_F(TransformValuesTest, evaluateSubsetOfRows) {
           nullEvery(13)),
   });
 
-  SelectivityVector inputRows(size, false);
-  inputRows.setValidRange(0, size / 3, true);
-  inputRows.updateBounds();
-
-  auto result = evaluate<MapVector>(
-      "transform_values(c0, (k, v) -> v + 5)", input, inputRows);
+  // Test using 2 selectivity vectors. One of size 100 with 33 first rows
+  // selected. Another of size 33 with all rows selected. Both should produce
+  // the same result.
   auto expectedResult = makeMapVector<int32_t, int64_t>(
       size / 3,
       [](auto row) { return row % 5; },
       [](auto row) { return row % 7; },
       [](auto row) { return row % 11 + 5; },
       nullEvery(13));
-  assertEqualVectors(expectedResult, result, inputRows);
+
+  {
+    SelectivityVector inputRows(size, false);
+    inputRows.setValidRange(0, size / 3, true);
+    inputRows.updateBounds();
+
+    auto result = evaluate<MapVector>(
+        "transform_values(c0, (k, v) -> v + 5)", input, inputRows);
+    assertEqualVectors(expectedResult, result, inputRows);
+  }
+
+  {
+    SelectivityVector inputRows(size / 3);
+
+    auto result = evaluate<MapVector>(
+        "transform_values(c0, (k, v) -> v + 5)", input, inputRows);
+    assertEqualVectors(expectedResult, result, inputRows);
+  }
 }
 
 TEST_F(TransformValuesTest, differentResultType) {
diff --git a/velox/functions/prestosql/tests/TypeOfTest.cpp b/velox/functions/prestosql/tests/TypeOfTest.cpp
new file mode 100644
index 0000000000000..6921fc171bb22
--- /dev/null
+++ b/velox/functions/prestosql/tests/TypeOfTest.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+class TypeOfTest : public functions::test::FunctionBaseTest {};
+
+TEST_F(TypeOfTest, basic) {
+  const auto typeOf = [&](const TypePtr& type) {
+    auto data = makeRowVector({
+        BaseVector::createNullConstant(type, 1, pool()),
+    });
+    return evaluateOnce<std::string>("typeof(c0)", data).value();
+  };
+
+  EXPECT_EQ("boolean", typeOf(BOOLEAN()));
+
+  EXPECT_EQ("tinyint", typeOf(TINYINT()));
+  EXPECT_EQ("smallint", typeOf(SMALLINT()));
+  EXPECT_EQ("integer", typeOf(INTEGER()));
+  EXPECT_EQ("bigint", typeOf(BIGINT()));
+
+  EXPECT_EQ("real", typeOf(REAL()));
+  EXPECT_EQ("double", typeOf(DOUBLE()));
+
+  EXPECT_EQ("decimal(5,2)", typeOf(DECIMAL(5, 2)));
+  EXPECT_EQ("decimal(25,7)", typeOf(DECIMAL(25, 7)));
+
+  EXPECT_EQ("varchar", typeOf(VARCHAR()));
+  EXPECT_EQ("varbinary", typeOf(VARBINARY()));
+
+  EXPECT_EQ("timestamp", typeOf(TIMESTAMP()));
+  EXPECT_EQ("timestamp with time zone", typeOf(TIMESTAMP_WITH_TIME_ZONE()));
+  EXPECT_EQ("date", typeOf(DATE()));
+
+  EXPECT_EQ("json", typeOf(JSON()));
+
+  EXPECT_EQ("HyperLogLog", typeOf(HYPERLOGLOG()));
+
+  EXPECT_EQ("unknown", typeOf(UNKNOWN()));
+
+  EXPECT_EQ("array(integer)", typeOf(ARRAY(INTEGER())));
+  EXPECT_EQ("map(varchar, array(date))", typeOf(MAP(VARCHAR(), ARRAY(DATE()))));
+  EXPECT_EQ(
+      "row(integer, varchar, array(date))",
+      typeOf(ROW({INTEGER(), VARCHAR(), ARRAY(DATE())})));
+  EXPECT_EQ(
+      "row(\"a\" integer, \"b\" varchar, \"c\" array(date))",
+      typeOf(ROW({"a", "b", "c"}, {INTEGER(), VARCHAR(), ARRAY(DATE())})));
+
+  VELOX_ASSERT_THROW(typeOf(OPAQUE<int>()), "Unsupported type: OPAQUE<int>");
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/URLFunctionsTest.cpp b/velox/functions/prestosql/tests/URLFunctionsTest.cpp
index 2269f02af4dfe..58252664ff5eb 100644
--- a/velox/functions/prestosql/tests/URLFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/URLFunctionsTest.cpp
@@ -23,11 +23,11 @@ class URLFunctionsTest : public functions::test::FunctionBaseTest {
  protected:
   void validate(
       const std::string& url,
-      const std::string& expectedProtocol,
-      const std::string& expectedHost,
-      const std::string& expectedPath,
-      const std::string& expectedFragment,
-      const std::string& expectedQuery,
+      const std::optional<std::string>& expectedProtocol,
+      const std::optional<std::string>& expectedHost,
+      const std::optional<std::string>& expectedPath,
+      const std::optional<std::string>& expectedFragment,
+      const std::optional<std::string>& expectedQuery,
       const std::optional<int32_t> expectedPort) {
     const auto extractFn = [&](const std::string& fn,
                                const std::optional<std::string>& a) {
@@ -40,7 +40,7 @@ class URLFunctionsTest : public functions::test::FunctionBaseTest {
     };
 
     EXPECT_EQ(extractFn("protocol", url), expectedProtocol);
-    EXPECT_EQ(extractFn("host", url).value(), expectedHost);
+    EXPECT_EQ(extractFn("host", url), expectedHost);
     EXPECT_EQ(extractFn("path", url), expectedPath);
     EXPECT_EQ(extractFn("fragment", url), expectedFragment);
     EXPECT_EQ(extractFn("query", url), expectedQuery);
@@ -97,7 +97,31 @@ TEST_F(URLFunctionsTest, validateURL) {
       "",
       "",
       std::nullopt);
-  validate("foo", "", "", "", "", "", std::nullopt);
+  validate(
+      "https://www.ucu.edu.uy/agenda/evento/%%UCUrlCompartir%%",
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt);
+  validate("foo", "", "", "foo", "", "", std::nullopt);
+  validate(
+      "foo ",
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt);
+  validate(
+      "IC6S!8hGVRpo+!,yTaJEy/$RUZpqcr",
+      "",
+      "",
+      "IC6S!8hGVRpo !,yTaJEy/$RUZpqcr",
+      "",
+      "",
+      std::nullopt);
 }
 
 TEST_F(URLFunctionsTest, extractPath) {
@@ -105,10 +129,19 @@ TEST_F(URLFunctionsTest, extractPath) {
     return evaluateOnce<std::string>("url_extract_path(c0)", url);
   };
 
-  ASSERT_EQ(
+  EXPECT_EQ(
       "/media/set/Books and Magazines.php",
       extractPath(
           "https://www.cnn.com/media/set/Books%20and%20Magazines.php?foo=bar"));
+
+  EXPECT_EQ(
+      "java-net@java.sun.com", extractPath("mailto:java-net@java.sun.com"));
+  EXPECT_EQ(
+      std::nullopt,
+      extractPath("https://www.ucu.edu.uy/agenda/evento/%%UCUrlCompartir%%"));
+  EXPECT_EQ("foo", extractPath("foo"));
+  EXPECT_EQ(std::nullopt, extractPath("BAD URL!"));
+  EXPECT_EQ("", extractPath("http://www.yahoo.com"));
 }
 
 TEST_F(URLFunctionsTest, extractParameter) {
@@ -124,6 +157,10 @@ TEST_F(URLFunctionsTest, extractParameter) {
       extractParam(
           "http://example.com/path1/p.php?k1=v1&k2=v2&k3&k4#Ref1", "k1"),
       "v1");
+  // Tests unescaping functionality.
+  EXPECT_EQ(
+      extractParam("http://example.com/path1/p.php?k1=v1%2Bv2#Ref1", "k1"),
+      "v1+v2");
   EXPECT_EQ(
       extractParam(
           "http://example.com/path1/p.php?k1=v1&k2=v2&k3&k4#Ref1", "k3"),
diff --git a/velox/functions/prestosql/tests/UuidFunctionsTest.cpp b/velox/functions/prestosql/tests/UuidFunctionsTest.cpp
new file mode 100644
index 0000000000000..a66a9ff5adbb2
--- /dev/null
+++ b/velox/functions/prestosql/tests/UuidFunctionsTest.cpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <boost/lexical_cast.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox::functions::prestosql {
+
+namespace {
+
+class UuidFunctionsTest : public functions::test::FunctionBaseTest {};
+
+TEST_F(UuidFunctionsTest, uuid) {
+  auto result =
+      evaluate<FlatVector<int128_t>>("uuid()", makeRowVector(ROW({}), 10));
+
+  // Sanity check results. All values are unique.
+  std::unordered_set<int128_t> uuids;
+  for (auto i = 0; i < 10; ++i) {
+    const auto uuid = result->valueAt(i);
+    ASSERT_TRUE(uuids.insert(uuid).second);
+  }
+  ASSERT_EQ(10, uuids.size());
+}
+
+TEST_F(UuidFunctionsTest, typeof) {
+  auto result = evaluate("typeof(uuid())", makeRowVector(ROW({}), 10));
+
+  auto expected = makeConstant("uuid", 10);
+  velox::test::assertEqualVectors(expected, result);
+
+  result = evaluate(
+      "typeof(array_constructor(uuid(), uuid()))", makeRowVector(ROW({}), 10));
+
+  expected = makeConstant("array(uuid)", 10);
+  velox::test::assertEqualVectors(expected, result);
+}
+
+TEST_F(UuidFunctionsTest, castAsVarchar) {
+  const vector_size_t size = 1'000;
+  auto uuids =
+      evaluate<FlatVector<int128_t>>("uuid()", makeRowVector(ROW({}), size));
+
+  auto result = evaluate<FlatVector<StringView>>(
+      "cast(c0 as varchar)", makeRowVector({uuids}));
+
+  // Verify that CAST results as the same as boost::lexical_cast. We do not use
+  // boost::lexical_cast to implement CAST because it is too slow.
+  auto expected = makeFlatVector<std::string>(size, [&](auto row) {
+    const auto uuid = uuids->valueAt(row);
+
+    boost::uuids::uuid u;
+    memcpy(&u, &uuid, 16);
+
+    return boost::lexical_cast<std::string>(u);
+  });
+
+  velox::test::assertEqualVectors(expected, result);
+
+  // Sanity check results. All strings are unique. Each string is 36 bytes
+  // long.
+  std::unordered_set<std::string> uniqueUuids;
+  for (auto i = 0; i < size; ++i) {
+    const auto uuid = result->valueAt(i).str();
+    ASSERT_EQ(36, uuid.size());
+    ASSERT_TRUE(uniqueUuids.insert(uuid).second);
+  }
+  ASSERT_EQ(size, uniqueUuids.size());
+}
+
+TEST_F(UuidFunctionsTest, castRoundTrip) {
+  auto strings = makeFlatVector<std::string>({
+      "33355449-2c7d-43d7-967a-f53cd23215ad",
+      "eed9f812-4b0c-472f-8a10-4ae7bff79a47",
+      "f768f36d-4f09-4da7-a298-3564d8f3c986",
+  });
+
+  auto uuids = evaluate("cast(c0 as uuid)", makeRowVector({strings}));
+  auto stringsCopy = evaluate("cast(c0 as varchar)", makeRowVector({uuids}));
+  auto uuidsCopy = evaluate("cast(c0 as uuid)", makeRowVector({stringsCopy}));
+
+  velox::test::assertEqualVectors(strings, stringsCopy);
+  velox::test::assertEqualVectors(uuids, uuidsCopy);
+}
+
+TEST_F(UuidFunctionsTest, unsupportedCast) {
+  auto input = makeRowVector(ROW({}), 10);
+  VELOX_ASSERT_THROW(
+      evaluate("cast(uuid() as integer)", input),
+      "Cannot cast UUID to INTEGER");
+  VELOX_ASSERT_THROW(
+      evaluate("cast(123 as uuid())", input), "Cannot cast BIGINT to UUID.");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/tests/WordStemTest.cpp b/velox/functions/prestosql/tests/WordStemTest.cpp
new file mode 100644
index 0000000000000..e94783e1dd1ab
--- /dev/null
+++ b/velox/functions/prestosql/tests/WordStemTest.cpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <optional>
+#include <string>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox::functions::test;
+
+namespace facebook::velox::functions {
+namespace {
+class WordStemTest : public FunctionBaseTest {
+ protected:
+  std::string wordStem(const std::string& word, const std::string& lang) {
+    return evaluateOnce<std::string>(
+               "word_stem(c0, c1)", std::optional(word), std::optional(lang))
+        .value();
+  }
+
+  std::string wordStem(const std::string& word) {
+    return evaluateOnce<std::string>("word_stem(c0)", std::optional(word))
+        .value();
+  }
+};
+
+/// Borrow test cases from Presto Java:
+/// https://github.com/prestodb/presto/blob/master/presto-main/src/test/java/com/facebook/presto/operator/scalar/TestWordStemFunction.java
+TEST_F(WordStemTest, asciiWord) {
+  EXPECT_EQ(wordStem(""), "");
+  EXPECT_EQ(wordStem("x"), "x");
+  EXPECT_EQ(wordStem("abc"), "abc");
+  EXPECT_EQ(wordStem("generally"), "general");
+  EXPECT_EQ(wordStem("useful"), "use");
+  EXPECT_EQ(wordStem("runs"), "run");
+  EXPECT_EQ(wordStem("run"), "run");
+  EXPECT_EQ(wordStem("authorized", "en"), "author");
+  EXPECT_EQ(wordStem("accessories", "en"), "accessori");
+  EXPECT_EQ(wordStem("intensifying", "en"), "intensifi");
+  EXPECT_EQ(wordStem("resentment", "en"), "resent");
+  EXPECT_EQ(wordStem("faithfulness", "en"), "faith");
+  EXPECT_EQ(wordStem("continuerait", "fr"), "continu");
+  EXPECT_EQ(wordStem("torpedearon", "es"), "torped");
+  EXPECT_EQ(wordStem("quilomtricos", "pt"), "quilomtr");
+  EXPECT_EQ(wordStem("pronunziare", "it"), "pronunz");
+  EXPECT_EQ(wordStem("auferstnde", "de"), "auferstnd");
+}
+
+TEST_F(WordStemTest, invalidLang) {
+  VELOX_ASSERT_THROW(
+      wordStem("hello", "xx"), "Unsupported stemmer language: xx");
+}
+
+TEST_F(WordStemTest, unicodeWord) {
+  EXPECT_EQ(
+      wordStem(
+          "\u004b\u0069\u0074\u0061\u0062\u0131\u006d\u0131\u007a\u0064\u0131",
+          "tr"),
+      "kitap");
+  EXPECT_EQ(
+      wordStem("\u0432\u0435\u0441\u0435\u043d\u043d\u0438\u0439", "ru"),
+      "\u0432\u0435\u0441\u0435\u043d");
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ZipTest.cpp b/velox/functions/prestosql/tests/ZipTest.cpp
index 21090b30f2fb9..a74f951205386 100644
--- a/velox/functions/prestosql/tests/ZipTest.cpp
+++ b/velox/functions/prestosql/tests/ZipTest.cpp
@@ -101,7 +101,7 @@ TEST_F(ZipTest, nullEmptyArray) {
       {5, 5},
   });
 
-  auto result = evaluate<ArrayVector>(
+  auto result = evaluate(
       "zip(c0, c1)",
       makeRowVector({
           firstVector,
@@ -121,39 +121,60 @@ TEST_F(ZipTest, nullEmptyArray) {
   assertEqualVectors(expected, result);
 }
 
-/// Test if we can pass multiple different array types in one function.
+// Verify that zip takes between 2 and 7 arguments.
 TEST_F(ZipTest, arity) {
-  using S = StringView;
-  auto firstVector =
-      makeArrayVector<int16_t>({{1, 1, 1, 1}, {2, 2, 2}, {3, 3}});
+  std::vector<VectorPtr> inputs;
+  for (auto i = 0; i < 7; i++) {
+    if (i % 2 == 0) {
+      inputs.push_back(makeArrayVectorFromJson<int32_t>({
+          "[1, 1, 1, 1]",
+          "[2, 2, 2]",
+          "[3, 3]",
+      }));
+    } else {
+      inputs.push_back(makeArrayVectorFromJson<double>({
+          "[1.1, 1.1, 1.1, 1.1]",
+          "[2.2, 2.2, 2.2]",
+          "[3.3, 3.3]",
+      }));
+    }
+  }
 
-  auto secondVector =
-      makeArrayVector<int32_t>({{0, 0, 0, 0}, {4, 4, 4}, {5, 5}});
+  std::vector<VectorPtr> inputElements;
+  for (auto i = 0; i < 7; i++) {
+    inputElements.push_back(inputs[i]->as<ArrayVector>()->elements());
+  }
 
-  auto thirdVector =
-      makeArrayVector<int64_t>({{1, 1, 1, 1}, {2, 2, 2}, {3, 3}});
+  for (auto i = 2; i <= 7; ++i) {
+    std::ostringstream expression;
+    expression << "zip(c0";
+    for (auto j = 1; j < i; ++j) {
+      expression << ", c" + std::to_string(j);
+    }
+    expression << ")";
 
-  auto fourthVector = makeArrayVector<StringView>(
-      {{S("a"), S("a"), S("a"), S("a")},
-       {S("b"), S("b"), S("b")},
-       {S("c"), S("c")}});
+    SCOPED_TRACE(expression.str());
+    auto result = evaluate(expression.str(), makeRowVector(inputs));
 
-  auto result = evaluate<ArrayVector>(
-      "zip(c0, c1, c2, c3)",
-      makeRowVector({firstVector, secondVector, thirdVector, fourthVector}));
+    std::vector<VectorPtr> children;
+    for (auto j = 0; j < i; ++j) {
+      children.push_back(inputElements[j]);
+    }
 
-  auto firstResult =
-      makeNullableFlatVector<int16_t>({1, 1, 1, 1, 2, 2, 2, 3, 3});
-  auto secondResult =
-      makeNullableFlatVector<int32_t>({0, 0, 0, 0, 4, 4, 4, 5, 5});
-  auto thirdResult =
-      makeNullableFlatVector<int64_t>({1, 1, 1, 1, 2, 2, 2, 3, 3});
-  auto fourthResult = makeNullableFlatVector<std::string>(
-      {S("a"), S("a"), S("a"), S("a"), S("b"), S("b"), S("b"), S("c"), S("c")});
-  auto rowVector =
-      makeRowVector({firstResult, secondResult, thirdResult, fourthResult});
-  auto expected = makeArrayVector({0, 4, 7}, rowVector);
-  assertEqualVectors(expected, result);
+    auto expected = makeArrayVector({0, 4, 7}, makeRowVector(children));
+    assertEqualVectors(expected, result);
+  }
+
+  // Verify that 0, 1, or 8 args are not supported.
+  VELOX_ASSERT_THROW(
+      evaluate("zip()", makeRowVector(inputs)),
+      "Scalar function signature is not supported: zip");
+  VELOX_ASSERT_THROW(
+      evaluate("zip(c0)", makeRowVector(inputs)),
+      "Scalar function signature is not supported: zip");
+  VELOX_ASSERT_THROW(
+      evaluate("zip(c0, c1, c2, c3, c0, c1, c2, c3)", makeRowVector(inputs)),
+      "Scalar function signature is not supported: zip");
 }
 
 /// Test if we can zip on complex types
@@ -305,7 +326,7 @@ TEST_F(ZipTest, flatArraysWithDifferentOffsets) {
 
 /// Test if we can zip two flat vectors of arrays with overlapping ranges of
 /// elements.
-TEST_F(ZipTest, flatArraysWithOverlappingRanges) {
+TEST_F(ZipTest, DISABLED_flatArraysWithOverlappingRanges) {
   const auto size = 3;
   BufferPtr offsetsBuffer = allocateOffsets(size, pool_.get());
   BufferPtr sizesBuffer = allocateSizes(size, pool_.get());
@@ -417,18 +438,4 @@ TEST_F(ZipTest, flatArraysWithGapInElements) {
   assertEqualVectors(expected, result);
 }
 
-// Single arg not supported.
-TEST_F(ZipTest, singleArgument) {
-  auto vector = makeNullableArrayVector<int64_t>(
-      {{1, 2, 3, 4}, {3, 4, 5}, {std::nullopt}});
-  VELOX_ASSERT_THROW(
-      evaluate<ArrayVector>("zip(c0)", makeRowVector({vector})),
-      "Scalar function signature is not supported: zip(ARRAY<BIGINT>). Supported signatures: "
-      "(array(E00),array(E01)) -> array(row(E00,E01)), (array(E00),array(E01),array(E02)) -> "
-      "array(row(E00,E01,E02)), (array(E00),array(E01),array(E02),array(E03)) -> array(row(E0"
-      "0,E01,E02,E03)), (array(E00),array(E01),array(E02),array(E03),array(E04)) -> array(row"
-      "(E00,E01,E02,E03,E04)), (array(E00),array(E01),array(E02),array(E03),array(E04),array("
-      "E05)) -> array(row(E00,E01,E02,E03,E04,E05))");
-}
-
 } // namespace
diff --git a/velox/functions/prestosql/tests/utils/CMakeLists.txt b/velox/functions/prestosql/tests/utils/CMakeLists.txt
index 075eecd802014..9fad6d743a6d2 100644
--- a/velox/functions/prestosql/tests/utils/CMakeLists.txt
+++ b/velox/functions/prestosql/tests/utils/CMakeLists.txt
@@ -14,5 +14,9 @@
 
 add_library(velox_functions_test_lib FunctionBaseTest.cpp)
 
-target_link_libraries(velox_functions_test_lib velox_exec velox_exec_test_lib
-                      velox_vector_test_lib velox_parse_parser)
+target_link_libraries(
+  velox_functions_test_lib
+  velox_exec
+  velox_exec_test_lib
+  velox_vector_test_lib
+  velox_parse_parser)
diff --git a/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp b/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
index a477dc8f8eef8..d6c8a6e4d34ae 100644
--- a/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
+++ b/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
@@ -23,6 +23,28 @@ namespace facebook::velox::functions::test {
 void FunctionBaseTest::SetUpTestCase() {
   parse::registerTypeResolver();
   functions::prestosql::registerAllScalarFunctions();
+  memory::MemoryManager::testingSetInstance({});
+}
+
+// static
+std::vector<const exec::FunctionSignature*> FunctionBaseTest::getSignatures(
+    const std::string& functionName,
+    const std::string& returnType) {
+  const auto allSignatures = getFunctionSignatures();
+
+  std::vector<const exec::FunctionSignature*> signatures;
+  for (const auto& signature : allSignatures.at(functionName)) {
+    const auto& typeName = signature->returnType().baseName();
+    if (exec::sanitizeName(typeName) == exec::sanitizeName(returnType)) {
+      signatures.push_back(signature);
+    }
+  }
+  VELOX_CHECK(
+      !signatures.empty(),
+      "No signature found for function {} with return type {}.",
+      functionName,
+      returnType);
+  return signatures;
 }
 
 // static
@@ -59,4 +81,83 @@ FunctionBaseTest::evaluateWithStats(
   return {results[0], exprSet.stats()};
 }
 
+void FunctionBaseTest::testEncodings(
+    const core::TypedExprPtr& expr,
+    const std::vector<VectorPtr>& inputs,
+    const VectorPtr& expected) {
+  VELOX_CHECK(!inputs.empty());
+
+  const auto size = inputs[0]->size();
+  VELOX_CHECK_GE(size, 3);
+
+  auto testDictionary = [&](vector_size_t dictionarySize,
+                            std::function<vector_size_t(vector_size_t)> indexAt,
+                            std::function<bool(vector_size_t)> nullAt =
+                                nullptr) {
+    // Wrap each input in its own dictionary.
+    std::vector<VectorPtr> encodedInputs;
+    encodedInputs.reserve(inputs.size());
+    for (const auto& input : inputs) {
+      auto indices = makeIndices(dictionarySize, indexAt);
+      auto nulls =
+          nullAt ? makeNulls(dictionarySize, nullAt) : BufferPtr(nullptr);
+      encodedInputs.emplace_back(
+          BaseVector::wrapInDictionary(nulls, indices, dictionarySize, input));
+    }
+    auto encodedRow = makeRowVector(encodedInputs);
+
+    SCOPED_TRACE(fmt::format("Dictionary: {}", encodedRow->toString()));
+
+    auto indices = makeIndices(dictionarySize, indexAt);
+    auto nulls =
+        nullAt ? makeNulls(dictionarySize, nullAt) : BufferPtr(nullptr);
+    auto expectedResult =
+        BaseVector::wrapInDictionary(nulls, indices, dictionarySize, expected);
+    velox::test::assertEqualVectors(expectedResult, evaluate(expr, encodedRow));
+  };
+
+  auto testConstant = [&](vector_size_t row) {
+    std::vector<VectorPtr> constantInputs;
+    for (const auto& input : inputs) {
+      constantInputs.push_back(BaseVector::wrapInConstant(100, row, input));
+    }
+    auto constantRow = makeRowVector(constantInputs);
+
+    SCOPED_TRACE(fmt::format("Constant: {}", constantRow->toString()));
+
+    auto expectedResult = BaseVector::wrapInConstant(100, row, expected);
+    velox::test::assertEqualVectors(
+        expectedResult, evaluate(expr, constantRow));
+  };
+
+  SCOPED_TRACE(expr->toString());
+
+  // No extra encoding.
+  velox::test::assertEqualVectors(
+      expected, evaluate(expr, makeRowVector(inputs)));
+
+  // Repeat each row twice: 0, 0, 1, 1,... No extra nulls.
+  testDictionary(size * 2, [](auto row) { return row / 2; });
+
+  // Select even rows: 0, 2, 4,... No extra nulls.
+  testDictionary(size / 2, [](auto row) { return row * 2; });
+
+  // Go over all rows in reverse: N, N-1, N-2,...0. No extra nulls.
+  testDictionary(size, [&](auto row) { return size - 1 - row; });
+
+  // Repeat each row twice: 0, 0, 1, 1,... Add some nulls.
+  testDictionary(size * 2, [](auto row) { return row / 2; }, nullEvery(3));
+
+  // Select even rows: 0, 2, 4,... Add some nulls.
+  testDictionary(size / 2, [](auto row) { return row * 2; }, nullEvery(3));
+
+  // Go over all rows in reverse: N, N-1, N-2,...0. Add some nulls.
+  testDictionary(size, [&](auto row) { return size - 1 - row; }, nullEvery(3));
+
+  // Generate constant vectors and verify the results.
+  for (auto i = 0; i < size; ++i) {
+    testConstant(i);
+  }
+}
+
 } // namespace facebook::velox::functions::test
diff --git a/velox/functions/prestosql/tests/utils/FunctionBaseTest.h b/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
index 65654f72d2882..4ff9dd37d9652 100644
--- a/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
+++ b/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <gtest/gtest.h>
+#include <utility>
 
 #include "velox/expression/Expr.h"
 #include "velox/parse/Expressions.h"
@@ -41,6 +42,25 @@ class FunctionBaseTest : public testing::Test,
       DoubleType,
       RealType>;
 
+  void setLegacyCast(bool value) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kLegacyCast, std::to_string(value)},
+    });
+  }
+
+  void setCastMatchStructByName(bool value) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kCastMatchStructByName, std::to_string(value)},
+    });
+  }
+
+  void setTimezone(const std::string& value) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, value},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+
  protected:
   static void SetUpTestCase();
 
@@ -155,52 +175,124 @@ class FunctionBaseTest : public testing::Test,
     return std::dynamic_pointer_cast<T>(results[0]);
   }
 
-  // Evaluate the given expression once, returning the result as a std::optional
-  // C++ value. Arguments should be referenced using c0, c1, .. cn.  Supports
-  // integers, floats, booleans, and strings.
-  //
-  // Example:
-  //   std::optional<double> exp(std::optional<double> a) {
-  //     return evaluateOnce<double>("exp(c0)", a);
-  //   }
-  //   EXPECT_EQ(1, exp(0));
-  //   EXPECT_EQ(std::nullopt, exp(std::nullopt));
-  template <typename ReturnType, typename... Args>
-  std::optional<ReturnType> evaluateOnce(
+  /// Evaluate a given expression over a single row of input returning the
+  /// result as a std::optional C++ value. Prefer to use the `evaluateOnce()`
+  /// helper methods below when testing simple functions instead of manually
+  /// handling input and output vectors.
+  ///
+  /// Arguments should be referenced using c0, c1, .. cn.  Supports integers,
+  /// floats, booleans, strings, timestamps, and other primitive types.
+  ///
+  /// The template parameter type `TReturn` is mandatory and used to cast the
+  /// returned value. Always use the C++ type for the returned value (e.g.
+  /// `double` not `DOUBLE()`). Either StringView or std::string can be used for
+  /// VARCHAR() and VARBINARY().
+  ///
+  /// If the function returns a custom type, use the physical type that
+  /// represent the custom type (e.g. `CustomType<T>::type`). For example, use
+  /// `int64_t` to return TIMESTAMP_WITH_TIME_ZONE()
+  ///
+  /// Input and output parameters should always be wrapped in an std::optional
+  /// to allow the representation of null values.
+  ///
+  /// Example:
+  ///
+  ///   std::optional<double> exp(std::optional<double> a) {
+  ///     return evaluateOnce<double>("exp(c0)", a);
+  ///   }
+  ///   EXPECT_EQ(1, exp(0));
+  ///   EXPECT_EQ(std::nullopt, exp(std::nullopt));
+  ///
+  ///
+  /// Multiple parameters are supported:
+  ///
+  ///   std::optional<int64_t> xxhash64(
+  ///       std::optional<std::string> val,
+  ///       std::optional<int64_t> seed) {
+  ///     return evaluateOnce<int64_t>("fb_xxhash64(c0, c1)", val, seed);
+  ///   }
+  ///
+  ///
+  /// If not specified, input logical types are derived from the C++ type
+  /// provided as input using CppToType. In the example above, the `std::string`
+  /// C++ type will be translated to `VARCHAR` logical type, and `int64_t` to
+  /// `BIGINT`.
+  ///
+  /// To override the input logical type, use:
+  ///
+  ///   std::optional<int64_t> hour(std::optional<int32_t> date) {
+  ///     return evaluateOnce<int64_t>("hour(c0)", DATE(), date);
+  ///   }
+  ///
+  /// Custom types like TIMESTAMP_WITH_TIMEZONE() and HYPERLOGLOG() are also
+  /// supported. For multiple parameters, use a list of logical types:
+  ///
+  ///   return evaluateOnce<std::string>(
+  ///       "hmac_sha1(c0, c1)", {VARBINARY(), VARBINARY()}, arg, key);
+  ///
+  ///
+  /// One can also manually specify additional template parameters, in case
+  /// there are problems with template type deduction:
+  ///
+  ///   return evaluateOnce<int64_t, std::string, int64_t>(
+  ///       "fb_xxhash64(c0, c1)", val, seed);
+  ///
+  template <typename TReturn, typename... TArgs>
+  std::optional<TReturn> evaluateOnce(
       const std::string& expr,
-      const std::optional<Args>&... args) {
-    return evaluateOnce<ReturnType>(
+      const std::initializer_list<TypePtr>& types,
+      std::optional<TArgs>... args) {
+    return evaluateOnce<TReturn>(
         expr,
-        makeRowVector(std::vector<VectorPtr>{
-            makeNullableFlatVector(std::vector{args})...}));
+        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
+            std::vector<TypePtr>{types},
+            std::forward<std::optional<TArgs>>(std::move(args))...)));
   }
 
-  template <typename ReturnType, typename Args>
-  std::optional<ReturnType> evaluateOnce(
+  template <typename TReturn, typename... TArgs>
+  std::optional<TReturn> evaluateOnce(
       const std::string& expr,
-      const std::vector<std::optional<Args>>& args,
-      const std::vector<TypePtr>& types,
-      const std::optional<SelectivityVector>& rows = std::nullopt,
-      const TypePtr& resultType = nullptr) {
-    std::vector<VectorPtr> flatVectors;
-    for (vector_size_t i = 0; i < args.size(); ++i) {
-      flatVectors.emplace_back(makeNullableFlatVector(
-          std::vector<std::optional<Args>>{args[i]}, types[i]));
-    }
-    auto rowVectorPtr = makeRowVector(flatVectors);
-    return evaluateOnce<ReturnType>(expr, rowVectorPtr, rows, resultType);
+      std::optional<TArgs>... args) {
+    return evaluateOnce<TReturn>(
+        expr,
+        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
+            {}, std::forward<std::optional<TArgs>>(std::move(args))...)));
+  }
+
+  // Convenience version to allow API users to specify a single type for
+  // functions that take a single parameter, instead of having to wrap them in a
+  // initializer_list. For example, it allows users to do:
+  //
+  //  auto a = evaluateOnce<int64_t>("hour(c0)", DATE(), date);
+  //
+  // instead of:
+  //
+  //  auto a = evaluateOnce<int64_t>("hour(c0)", {DATE()}, date);
+  //
+  // Note that if types are specified, evaluateOnce() will throws if the number
+  // of types and parameter do not match.
+  template <typename TReturn, typename... TArgs>
+  std::optional<TReturn> evaluateOnce(
+      const std::string& expr,
+      const TypePtr& type,
+      std::optional<TArgs>... args) {
+    return evaluateOnce<TReturn>(
+        expr,
+        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
+            {type}, std::forward<std::optional<TArgs>>(std::move(args))...)));
   }
 
-  template <typename ReturnType>
-  std::optional<ReturnType> evaluateOnce(
+  template <typename TReturn>
+  std::optional<TReturn> evaluateOnce(
       const std::string& expr,
       const RowVectorPtr rowVectorPtr,
       const std::optional<SelectivityVector>& rows = std::nullopt,
       const TypePtr& resultType = nullptr) {
-    auto result = evaluate<SimpleVector<EvalType<ReturnType>>>(
-        expr, rowVectorPtr, rows, resultType);
-    return result->isNullAt(0) ? std::optional<ReturnType>{}
-                               : ReturnType(result->valueAt(0));
+    auto result =
+        evaluate<SimpleVector<facebook::velox::test::EvalType<TReturn>>>(
+            expr, rowVectorPtr, rows, resultType);
+    return result->isNullAt(0) ? std::optional<TReturn>{}
+                               : TReturn(result->valueAt(0));
   }
 
   core::TypedExprPtr parseExpression(
@@ -245,12 +337,44 @@ class FunctionBaseTest : public testing::Test,
     return result[0];
   }
 
+  /// Parses a timestamp string into Timestamp.
+  /// Accepts strings formatted as 'YYYY-MM-DD HH:mm:ss[.nnn]'.
+  static Timestamp parseTimestamp(const std::string& text) {
+    return util::fromTimestampString(
+               text.data(), text.size(), util::TimestampParseMode::kPrestoCast)
+        .thenOrThrow(folly::identity, [&](const Status& status) {
+          VELOX_USER_FAIL("{}", status.message());
+        });
+  }
+
+  /// Parses a date string into days since epoch.
+  /// Accepts strings formatted as 'YYYY-MM-DD'.
+  static int32_t parseDate(const std::string& text) {
+    return DATE()->toDays(text);
+  }
+
+  /// Returns a vector of signatures for the given function name and return
+  /// type.
+  /// @param returnType The name of expected return type defined in function
+  /// signature.
+  static std::vector<const exec::FunctionSignature*> getSignatures(
+      const std::string& functionName,
+      const std::string& returnType);
+
   /// Returns a set of signatures for a given function serialized to strings.
   static std::unordered_set<std::string> getSignatureStrings(
       const std::string& functionName);
 
+  /// Given an expression, a list of inputs and expected results, generate
+  /// dictionary-encoded and constant-encoded vectors, evaluate the expression
+  /// and verify the results.
+  void testEncodings(
+      const core::TypedExprPtr& expr,
+      const std::vector<VectorPtr>& inputs,
+      const VectorPtr& expected);
+
   std::shared_ptr<core::QueryCtx> queryCtx_{
-      std::make_shared<core::QueryCtx>(executor_.get())};
+      core::QueryCtx::create(executor_.get())};
   core::ExecCtx execCtx_{pool_.get(), queryCtx_.get()};
   parse::ParseOptions options_;
 
@@ -293,6 +417,36 @@ class FunctionBaseTest : public testing::Test,
     ExprSet exprSet({typedExpr}, &execCtx_);
     return evaluate(exprSet, data, rows);
   }
+
+  // Unpack parameters for evaluateOnce(). Base recursion case.
+  template <typename...>
+  std::vector<VectorPtr> unpackEvaluateParams(
+      const std::vector<TypePtr>& types) {
+    VELOX_CHECK(types.empty(), "Wrong number of types passed to evaluateOnce.");
+    return {};
+  }
+
+  // Recursively unpack input values and types into vectors.
+  template <typename T, typename... TArgs>
+  std::vector<VectorPtr> unpackEvaluateParams(
+      const std::vector<TypePtr>& types,
+      T&& value,
+      TArgs&&... args) {
+    // If there are no input types, let makeNullable figure it out.
+    auto output = std::vector<VectorPtr>{
+        types.empty()
+            ? makeNullableFlatVector(std::vector{value})
+            : makeNullableFlatVector(std::vector{value}, types.front()),
+    };
+
+    // Recurse starting from the second parameter.
+    auto result = unpackEvaluateParams<TArgs...>(
+        types.size() > 1 ? std::vector<TypePtr>{types.begin() + 1, types.end()}
+                         : std::vector<TypePtr>{},
+        std::forward<TArgs>(std::move(args))...);
+    output.insert(output.end(), result.begin(), result.end());
+    return output;
+  }
 };
 
 } // namespace facebook::velox::functions::test
diff --git a/velox/functions/prestosql/types/CMakeLists.txt b/velox/functions/prestosql/types/CMakeLists.txt
index d65f5714559cf..0089307a4f071 100644
--- a/velox/functions/prestosql/types/CMakeLists.txt
+++ b/velox/functions/prestosql/types/CMakeLists.txt
@@ -11,11 +11,21 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_presto_types HyperLogLogType.cpp JsonType.cpp
-                               TimestampWithTimeZoneType.cpp)
+velox_add_library(
+  velox_presto_types
+  HyperLogLogType.cpp
+  JsonType.cpp
+  TimestampWithTimeZoneType.cpp
+  UuidType.cpp
+  IPAddressType.cpp)
 
-target_link_libraries(velox_presto_types velox_memory velox_expression
-                      velox_functions_util)
+velox_link_libraries(
+  velox_presto_types
+  velox_memory
+  velox_expression
+  velox_functions_util
+  velox_functions_json
+  velox_functions_lib_date_time_formatter)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/prestosql/types/HyperLogLogType.h b/velox/functions/prestosql/types/HyperLogLogType.h
index c481e5735efe7..6680a3fd2f120 100644
--- a/velox/functions/prestosql/types/HyperLogLogType.h
+++ b/velox/functions/prestosql/types/HyperLogLogType.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 #include "velox/vector/VectorTypeUtils.h"
 
diff --git a/velox/functions/prestosql/types/IPAddressType.cpp b/velox/functions/prestosql/types/IPAddressType.cpp
new file mode 100644
index 0000000000000..691ca0a28ce2b
--- /dev/null
+++ b/velox/functions/prestosql/types/IPAddressType.cpp
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/IPAddressType.h"
+#include <folly/IPAddress.h>
+#include "velox/expression/CastExpr.h"
+
+static constexpr int kIPV4AddressBytes = 4;
+static constexpr int kIPV4ToV6FFIndex = 10;
+static constexpr int kIPV4ToV6Index = 12;
+static constexpr int kIPAddressBytes = 16;
+
+namespace facebook::velox {
+
+namespace {
+
+class IPAddressCastOperator : public exec::CastOperator {
+ public:
+  bool isSupportedFromType(const TypePtr& other) const override {
+    switch (other->kind()) {
+      case TypeKind::VARBINARY:
+      case TypeKind::VARCHAR:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  bool isSupportedToType(const TypePtr& other) const override {
+    switch (other->kind()) {
+      case TypeKind::VARBINARY:
+      case TypeKind::VARCHAR:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+
+    if (input.typeKind() == TypeKind::VARCHAR) {
+      castFromString(input, context, rows, *result);
+    } else if (input.typeKind() == TypeKind::VARBINARY) {
+      castFromVarbinary(input, context, rows, *result);
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from {} to IPAddress not supported", resultType->toString());
+    }
+  }
+
+  void castFrom(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+
+    if (resultType->kind() == TypeKind::VARCHAR) {
+      castToString(input, context, rows, *result);
+    } else if (resultType->kind() == TypeKind::VARBINARY) {
+      castToVarbinary(input, context, rows, *result);
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from IPAddress to {} not supported", resultType->toString());
+    }
+  }
+
+ private:
+  static void castToString(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) {
+    auto* flatResult = result.as<FlatVector<StringView>>();
+    const auto* ipaddresses = input.as<SimpleVector<int128_t>>();
+    folly::ByteArray16 addrBytes;
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto intAddr = ipaddresses->valueAt(row);
+      memcpy(&addrBytes, &intAddr, kIPAddressBytes);
+
+      std::reverse(addrBytes.begin(), addrBytes.end());
+      folly::IPAddressV6 v6Addr(addrBytes);
+
+      exec::StringWriter<false> result(flatResult, row);
+      if (v6Addr.isIPv4Mapped()) {
+        result.append(v6Addr.createIPv4().str());
+      } else {
+        result.append(v6Addr.str());
+      }
+      result.finalize();
+    });
+  }
+
+  static void castFromString(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) {
+    auto* flatResult = result.as<FlatVector<int128_t>>();
+    const auto* ipAddressStrings = input.as<SimpleVector<StringView>>();
+    int128_t intAddr;
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto ipAddressString = ipAddressStrings->valueAt(row);
+
+      auto maybeIp = folly::IPAddress::tryFromString(ipAddressString);
+      if (maybeIp.hasError()) {
+        if (threadSkipErrorDetails()) {
+          context.setStatus(row, Status::UserError());
+        } else {
+          context.setStatus(
+              row,
+              Status::UserError("Invalid IP address '{}'", ipAddressString));
+        }
+        return;
+      }
+      folly::IPAddress addr = maybeIp.value();
+      auto addrBytes = folly::IPAddress::createIPv6(addr).toByteArray();
+
+      std::reverse(addrBytes.begin(), addrBytes.end());
+      memcpy(&intAddr, &addrBytes, kIPAddressBytes);
+
+      flatResult->set(row, intAddr);
+    });
+  }
+
+  static void castToVarbinary(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) {
+    auto* flatResult = result.as<FlatVector<StringView>>();
+    const auto* ipaddresses = input.as<SimpleVector<int128_t>>();
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto intAddr = ipaddresses->valueAt(row);
+      folly::ByteArray16 addrBytes;
+      memcpy(&addrBytes, &intAddr, kIPAddressBytes);
+      std::reverse(addrBytes.begin(), addrBytes.end());
+
+      exec::StringWriter<false> result(flatResult, row);
+      result.resize(kIPAddressBytes);
+      memcpy(result.data(), &addrBytes, kIPAddressBytes);
+      result.finalize();
+    });
+  }
+
+  static void castFromVarbinary(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) {
+    auto* flatResult = result.as<FlatVector<int128_t>>();
+    const auto* ipAddressBinaries = input.as<SimpleVector<StringView>>();
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      int128_t intAddr;
+      folly::ByteArray16 addrBytes = {};
+      const auto ipAddressBinary = ipAddressBinaries->valueAt(row);
+
+      if (ipAddressBinary.size() == kIPV4AddressBytes) {
+        addrBytes[kIPV4ToV6FFIndex] = 0xFF;
+        addrBytes[kIPV4ToV6FFIndex + 1] = 0xFF;
+        memcpy(
+            &addrBytes[kIPV4ToV6Index],
+            ipAddressBinary.data(),
+            kIPV4AddressBytes);
+      } else if (ipAddressBinary.size() == kIPAddressBytes) {
+        memcpy(&addrBytes, ipAddressBinary.data(), kIPAddressBytes);
+      } else {
+        if (threadSkipErrorDetails()) {
+          context.setStatus(row, Status::UserError());
+        } else {
+          context.setStatus(
+              row,
+              Status::UserError(
+                  "Invalid IP address binary length: {}",
+                  ipAddressBinary.size()));
+        }
+        return;
+      }
+
+      std::reverse(addrBytes.begin(), addrBytes.end());
+      memcpy(&intAddr, &addrBytes, kIPAddressBytes);
+      flatResult->set(row, intAddr);
+    });
+  }
+};
+
+class IPAddressTypeFactories : public CustomTypeFactories {
+ public:
+  IPAddressTypeFactories() = default;
+
+  TypePtr getType() const override {
+    return IPADDRESS();
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return std::make_shared<IPAddressCastOperator>();
+  }
+};
+
+} // namespace
+
+void registerIPAddressType() {
+  registerCustomType(
+      "ipaddress", std::make_unique<const IPAddressTypeFactories>());
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/IPAddressType.h b/velox/functions/prestosql/types/IPAddressType.h
new file mode 100644
index 0000000000000..e1e2d9fc1bf28
--- /dev/null
+++ b/velox/functions/prestosql/types/IPAddressType.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+class IPAddressType : public HugeintType {
+  IPAddressType() = default;
+
+ public:
+  static const std::shared_ptr<const IPAddressType>& get() {
+    static const std::shared_ptr<const IPAddressType> instance{
+        new IPAddressType()};
+
+    return instance;
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  const char* name() const override {
+    return "IPADDRESS";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "Type";
+    obj["type"] = name();
+    return obj;
+  }
+};
+
+FOLLY_ALWAYS_INLINE bool isIPAddressType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return IPAddressType::get() == type;
+}
+
+FOLLY_ALWAYS_INLINE std::shared_ptr<const IPAddressType> IPADDRESS() {
+  return IPAddressType::get();
+}
+
+// Type used for function registration.
+struct IPAddressT {
+  using type = int128_t;
+  static constexpr const char* typeName = "ipaddress";
+};
+
+using IPAddress = CustomType<IPAddressT>;
+
+void registerIPAddressType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/JsonType.cpp b/velox/functions/prestosql/types/JsonType.cpp
index d3412d85484b3..35558028336fe 100644
--- a/velox/functions/prestosql/types/JsonType.cpp
+++ b/velox/functions/prestosql/types/JsonType.cpp
@@ -15,12 +15,12 @@
  */
 
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/type/DecimalUtil.h"
 
 #include <algorithm>
 #include <stdexcept>
 #include <string>
 
-#include "folly/CPortability.h"
 #include "folly/Conv.h"
 #include "folly/json.h"
 
@@ -30,43 +30,133 @@
 #include "velox/expression/StringWriter.h"
 #include "velox/expression/VectorWriters.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/functions/lib/string/StringCore.h"
+#include "velox/functions/prestosql/json/JsonStringUtil.h"
+#include "velox/functions/prestosql/json/SIMDJsonUtil.h"
+#include "velox/type/Conversions.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
+
 namespace {
 
-template <typename T, bool isMapKey = false>
+template <typename T, bool legacyCast>
 void generateJsonTyped(
     const SimpleVector<T>& input,
     int row,
     std::string& result,
-    const TypePtr& type) {
+    const TypePtr& type,
+    const std::shared_ptr<exec::CastHooks>& hooks) {
   auto value = input.valueAt(row);
 
   if constexpr (std::is_same_v<T, StringView>) {
-    folly::json::escapeString(value, result, folly::json::serialization_opts{});
+    size_t resultSize = escapedStringSize(value.data(), value.size());
+    result.resize(resultSize + 2);
+    result.data()[0] = '"';
+    escapeString(value.data(), value.size(), result.data() + 1);
+    result.data()[resultSize + 1] = '"';
   } else if constexpr (std::is_same_v<T, UnknownValue>) {
     VELOX_FAIL(
         "Casting UNKNOWN to JSON: Vectors of UNKNOWN type should not contain non-null rows");
   } else {
-    if constexpr (isMapKey) {
-      result.append("\"");
-    }
-
     if constexpr (std::is_same_v<T, bool>) {
       result.append(value ? "true" : "false");
+    } else if constexpr (
+        std::is_same_v<T, double> || std::is_same_v<T, float>) {
+      if constexpr (!legacyCast) {
+        if (FOLLY_UNLIKELY(std::isinf(value) || std::isnan(value))) {
+          result.append(fmt::format(
+              "\"{}\"",
+              util::Converter<TypeKind::VARCHAR>::tryCast(value).value()));
+        } else {
+          result.append(
+              util::Converter<TypeKind::VARCHAR>::tryCast(value).value());
+        }
+      } else {
+        folly::toAppend<std::string, T>(value, &result);
+      }
     } else if constexpr (std::is_same_v<T, Timestamp>) {
-      result.append(std::to_string(value));
+      std::string buffer;
+      if (hooks) {
+        Timestamp inputValue = value;
+        const auto& options = hooks->timestampToStringOptions();
+        if (options.timeZone) {
+          inputValue.toTimezone(*(options.timeZone));
+        }
+        buffer.resize(getMaxStringLength(options));
+        const auto stringView =
+            Timestamp::tsToStringView(inputValue, options, buffer.data());
+        buffer.resize(stringView.size());
+      } else {
+        buffer = std::to_string(value);
+      }
+      result.reserve(buffer.size() + 2);
+      result.append("\"");
+      result.append(buffer);
+      result.append("\"");
     } else if (type->isDate()) {
-      result.append(DATE()->toString(value));
+      std::string stringValue = DATE()->toString(value);
+      result.reserve(stringValue.size() + 2);
+      result.append("\"");
+      result.append(stringValue);
+      result.append("\"");
+    } else if (type->isDecimal()) {
+      result.append(DecimalUtil::toString(value, type));
     } else {
       folly::toAppend<std::string, T>(value, &result);
     }
+  }
+}
 
-    if constexpr (isMapKey) {
-      result.append("\"");
+template <typename T, bool legacyCast>
+void generateJsonNonKeyTyped(
+    const SimpleVector<T>& inputVector,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks) {
+  std::string result;
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    if (inputVector.isNullAt(row)) {
+      flatResult.set(row, "null");
+    } else {
+      result.clear();
+      generateJsonTyped<T, legacyCast>(
+          inputVector, row, result, inputVector.type(), hooks);
+
+      flatResult.set(row, StringView{result});
     }
-  }
+  });
+}
+
+template <typename T, bool legacyCast>
+void generateJsonKeyTyped(
+    const SimpleVector<T>& inputVector,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks) {
+  std::string result;
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    if (inputVector.isNullAt(row)) {
+      VELOX_USER_FAIL("Map keys cannot be null.");
+    } else {
+      result.clear();
+
+      if constexpr (!std::is_same_v<T, StringView>) {
+        result.append("\"");
+      }
+
+      generateJsonTyped<T, legacyCast>(
+          inputVector, row, result, inputVector.type(), hooks);
+
+      if constexpr (!std::is_same_v<T, StringView>) {
+        result.append("\"");
+      }
+
+      flatResult.set(row, StringView{result});
+    }
+  });
 }
 
 // Casts primitive-type input vectors to Json type.
@@ -78,35 +168,31 @@ void castToJson(
     exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks,
     bool isMapKey = false) {
   using T = typename TypeTraits<kind>::NativeType;
 
   // input is guaranteed to be in flat or constant encodings when passed in.
   auto inputVector = input.as<SimpleVector<T>>();
 
-  std::string result;
-  if (!isMapKey) {
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      if (inputVector->isNullAt(row)) {
-        flatResult.set(row, "null");
-      } else {
-        result.clear();
-        generateJsonTyped(*inputVector, row, result, input.type());
+  bool legacyCast = context.execCtx()->queryCtx()->queryConfig().isLegacyCast();
 
-        flatResult.set(row, StringView{result});
-      }
-    });
+  if (FOLLY_LIKELY(!legacyCast)) {
+    if (!isMapKey) {
+      generateJsonNonKeyTyped<T, false>(
+          *inputVector, context, rows, flatResult, hooks);
+    } else {
+      generateJsonKeyTyped<T, false>(
+          *inputVector, context, rows, flatResult, hooks);
+    }
   } else {
-    context.applyToSelectedNoThrow(rows, [&](auto row) {
-      if (inputVector->isNullAt(row)) {
-        VELOX_USER_FAIL("Map keys cannot be null.");
-      } else {
-        result.clear();
-        generateJsonTyped<T, true>(*inputVector, row, result, input.type());
-
-        flatResult.set(row, StringView{result});
-      }
-    });
+    if (!isMapKey) {
+      generateJsonNonKeyTyped<T, true>(
+          *inputVector, context, rows, flatResult, hooks);
+    } else {
+      generateJsonKeyTyped<T, true>(
+          *inputVector, context, rows, flatResult, hooks);
+    }
   }
 }
 
@@ -115,19 +201,22 @@ void castToJsonFromArray(
     const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    FlatVector<StringView>& flatResult);
+    FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks);
 
 void castToJsonFromMap(
     const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    FlatVector<StringView>& flatResult);
+    FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks);
 
 void castToJsonFromRow(
     const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    FlatVector<StringView>& flatResult);
+    FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks);
 
 // Casts complex-type input vectors to Json type.
 template <
@@ -138,16 +227,17 @@ void castToJson(
     exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks,
     bool isMapKey = false) {
   VELOX_CHECK(
       !isMapKey, "Casting map with complex key type to JSON is not supported");
 
   if constexpr (kind == TypeKind::ARRAY) {
-    castToJsonFromArray(input, context, rows, flatResult);
+    castToJsonFromArray(input, context, rows, flatResult, hooks);
   } else if constexpr (kind == TypeKind::MAP) {
-    castToJsonFromMap(input, context, rows, flatResult);
+    castToJsonFromMap(input, context, rows, flatResult, hooks);
   } else if constexpr (kind == TypeKind::ROW) {
-    castToJsonFromRow(input, context, rows, flatResult);
+    castToJsonFromRow(input, context, rows, flatResult, hooks);
   } else {
     VELOX_FAIL(
         "Casting {} to JSON is not supported.", input.type()->toString());
@@ -161,34 +251,37 @@ struct AsJson {
       const VectorPtr& input,
       const SelectivityVector& rows,
       const BufferPtr& elementToTopLevelRows,
+      const std::shared_ptr<exec::CastHooks>& hooks,
       bool isMapKey = false)
       : decoded_(context) {
-    ErrorVectorPtr oldErrors;
+    VELOX_CHECK(rows.hasSelections());
+
+    exec::EvalErrorsPtr oldErrors;
     context.swapErrors(oldErrors);
     if (isJsonType(input->type())) {
       json_ = input;
     } else {
-      if (!exec::PeeledEncoding::isPeelable(input->encoding()) ||
-          !rows.hasSelections()) {
-        doCast(context, input, rows, isMapKey, json_);
+      if (!exec::PeeledEncoding::isPeelable(input->encoding())) {
+        doCast(context, input, rows, isMapKey, json_, hooks);
       } else {
-        exec::ScopedContextSaver saver;
-        exec::LocalSelectivityVector newRowsHolder(*context.execCtx());
-
-        exec::LocalDecodedVector localDecoded(context);
-        std::vector<VectorPtr> peeledVectors;
-        auto peeledEncoding = exec::PeeledEncoding::peel(
-            {input}, rows, localDecoded, true, peeledVectors);
-        VELOX_CHECK_EQ(peeledVectors.size(), 1);
-        auto newRows =
-            peeledEncoding->translateToInnerRows(rows, newRowsHolder);
-        // Save context and set the peel.
-        context.saveAndReset(saver, rows);
-        context.setPeeledEncoding(peeledEncoding);
-
-        doCast(context, peeledVectors[0], *newRows, isMapKey, json_);
-        json_ = context.getPeeledEncoding()->wrap(
-            json_->type(), context.pool(), json_, rows);
+        exec::withContextSaver([&](exec::ContextSaver& saver) {
+          exec::LocalSelectivityVector newRowsHolder(*context.execCtx());
+
+          exec::LocalDecodedVector localDecoded(context);
+          std::vector<VectorPtr> peeledVectors;
+          auto peeledEncoding = exec::PeeledEncoding::peel(
+              {input}, rows, localDecoded, true, peeledVectors);
+          VELOX_CHECK_EQ(peeledVectors.size(), 1);
+          auto newRows =
+              peeledEncoding->translateToInnerRows(rows, newRowsHolder);
+          // Save context and set the peel.
+          context.saveAndReset(saver, rows);
+          context.setPeeledEncoding(peeledEncoding);
+
+          doCast(context, peeledVectors[0], *newRows, isMapKey, json_, hooks);
+          json_ = context.getPeeledEncoding()->wrap(
+              json_->type(), context.pool(), json_, rows);
+        });
       }
     }
     decoded_.get()->decode(*json_, rows);
@@ -235,7 +328,8 @@ struct AsJson {
       const VectorPtr& input,
       const SelectivityVector& baseRows,
       bool isMapKey,
-      VectorPtr& result) {
+      VectorPtr& result,
+      const std::shared_ptr<exec::CastHooks>& hooks) {
     context.ensureWritable(baseRows, JSON(), result);
     auto flatJsonStrings = result->as<FlatVector<StringView>>();
 
@@ -246,6 +340,7 @@ struct AsJson {
         context,
         baseRows,
         *flatJsonStrings,
+        hooks,
         isMapKey);
   }
 
@@ -258,7 +353,7 @@ struct AsJson {
       exec::EvalCtx& context,
       const SelectivityVector& rows,
       const BufferPtr& elementToTopLevelRows,
-      ErrorVectorPtr& oldErrors) {
+      exec::EvalErrorsPtr& oldErrors) {
     if (context.errors()) {
       if (elementToTopLevelRows) {
         context.addElementErrorsToTopLevel(
@@ -279,16 +374,34 @@ void castToJsonFromArray(
     const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    FlatVector<StringView>& flatResult) {
+    FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks) {
   // input is guaranteed to be in flat encoding when passed in.
   auto inputArray = input.as<ArrayVector>();
 
   auto elements = inputArray->elements();
   auto elementsRows =
       functions::toElementRows(elements->size(), rows, inputArray);
+  if (!elementsRows.hasSelections()) {
+    // All arrays are null or empty.
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      if (inputArray->isNullAt(row)) {
+        flatResult.set(row, "null");
+      } else {
+        VELOX_CHECK_EQ(
+            inputArray->sizeAt(row),
+            0,
+            "All arrays are expected to be null or empty");
+        flatResult.set(row, "[]");
+      }
+    });
+    return;
+  }
+
   auto elementToTopLevelRows = functions::getElementToTopLevelRows(
       elements->size(), rows, inputArray, context.pool());
-  AsJson elementsAsJson{context, elements, elementsRows, elementToTopLevelRows};
+  AsJson elementsAsJson{
+      context, elements, elementsRows, elementToTopLevelRows, hooks};
 
   // Estimates an upperbound of the total length of all Json strings for the
   // input according to the length of all elements Json strings and the
@@ -341,20 +454,38 @@ void castToJsonFromMap(
     const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    FlatVector<StringView>& flatResult) {
+    FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks) {
   // input is guaranteed to be in flat encoding when passed in.
   auto inputMap = input.as<MapVector>();
 
   auto mapKeys = inputMap->mapKeys();
   auto mapValues = inputMap->mapValues();
   auto elementsRows = functions::toElementRows(mapKeys->size(), rows, inputMap);
+  if (!elementsRows.hasSelections()) {
+    // All maps are null or empty.
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      if (inputMap->isNullAt(row)) {
+        flatResult.set(row, "null");
+      } else {
+        VELOX_CHECK_EQ(
+            inputMap->sizeAt(row),
+            0,
+            "All maps are expected to be null or empty");
+        flatResult.set(row, "{}");
+      }
+    });
+    return;
+  }
+
   auto elementToTopLevelRows = functions::getElementToTopLevelRows(
       mapKeys->size(), rows, inputMap, context.pool());
   // Maps with unsupported key types should have already been rejected by
   // JsonCastOperator::isSupportedType() beforehand.
   AsJson keysAsJson{
-      context, mapKeys, elementsRows, elementToTopLevelRows, true};
-  AsJson valuesAsJson{context, mapValues, elementsRows, elementToTopLevelRows};
+      context, mapKeys, elementsRows, elementToTopLevelRows, hooks, true};
+  AsJson valuesAsJson{
+      context, mapValues, elementsRows, elementToTopLevelRows, hooks};
 
   // Estimates an upperbound of the total length of all Json strings for the
   // input according to the length of all elements Json strings and the
@@ -419,8 +550,10 @@ void castToJsonFromRow(
     const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    FlatVector<StringView>& flatResult) {
+    FlatVector<StringView>& flatResult,
+    const std::shared_ptr<exec::CastHooks>& hooks) {
   // input is guaranteed to be in flat encoding when passed in.
+  VELOX_CHECK_EQ(input.encoding(), VectorEncoding::Simple::ROW);
   auto inputRow = input.as<RowVector>();
   auto childrenSize = inputRow->childrenSize();
 
@@ -430,7 +563,8 @@ void castToJsonFromRow(
   size_t childrenStringSize = 0;
   std::vector<AsJson> childrenAsJson;
   for (int i = 0; i < childrenSize; ++i) {
-    childrenAsJson.emplace_back(context, inputRow->childAt(i), rows, nullptr);
+    childrenAsJson.emplace_back(
+        context, inputRow->childAt(i), rows, nullptr, hooks);
 
     context.applyToSelectedNoThrow(rows, [&](auto row) {
       if (inputRow->isNullAt(row)) {
@@ -468,293 +602,481 @@ void castToJsonFromRow(
   });
 }
 
-// Write object to writer at the current offset.
-template <TypeKind kind>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped(
-    const folly::dynamic& /*object*/,
-    exec::GenericWriter&
-    /*writer*/) {
-  VELOX_NYI(
-      "Casting from JSON to {} is not supported.", TypeTraits<kind>::name);
+template <typename T>
+simdjson::simdjson_result<T> fromString(const std::string_view& s) {
+  auto result = folly::tryTo<T>(s);
+  if (result.hasError()) {
+    return simdjson::INCORRECT_TYPE;
+  }
+  return std::move(*result);
 }
 
-// Forward declarations.
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::ARRAY>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer);
-
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::MAP>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer);
-
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::ROW>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer);
-
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::VARCHAR>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  if (isJsonType(writer.type())) {
-    // Sort keys to match Presto's behavior.
-    folly::json::serialization_opts opts;
-    opts.sort_keys = true;
-    writer.castTo<Varchar>().append(folly::json::serialize(object, opts));
-  } else if (object.isBool()) {
-    writer.castTo<Varchar>().append(object.asBool() ? "true" : "false");
+// Write x to writer if x is in the range of writer type `To'.  Only the
+// following cases are supported:
+//
+// Signed Integer -> Signed Integer
+// Float | Double -> Float | Double | Signed Integer
+template <typename To, typename From>
+simdjson::error_code convertIfInRange(From x, exec::GenericWriter& writer) {
+  static_assert(std::is_signed_v<From> && std::is_signed_v<To>);
+  if constexpr (std::is_integral_v<To> == std::is_integral_v<From>) {
+    if constexpr (sizeof(To) < sizeof(From)) {
+      constexpr From kMin = std::numeric_limits<To>::lowest();
+      constexpr From kMax = std::numeric_limits<To>::max();
+      if (!(kMin <= x && x <= kMax)) {
+        return simdjson::NUMBER_OUT_OF_RANGE;
+      }
+    }
+    writer.castTo<To>() = x;
+    return simdjson::SUCCESS;
   } else {
-    writer.castTo<Varchar>().append(object.asString());
+    static_assert(std::is_integral_v<To> && !std::is_integral_v<From>);
+    // Upper/lower bound values that could be accurately represented in both
+    // int64_t and double types.  Same values are used by
+    // folly::constexpr_clamp_cast.
+    constexpr double kMin = -9223372036854774784.0;
+    constexpr double kMax = 9223372036854774784.0;
+    if (!(kMin <= x && x <= kMax)) {
+      return simdjson::NUMBER_OUT_OF_RANGE;
+    }
+    return convertIfInRange<To, int64_t>(x, writer);
   }
 }
 
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::BOOLEAN>(
-    const folly::dynamic& object,
+template <TypeKind kind>
+simdjson::error_code appendMapKey(
+    const std::string_view& value,
     exec::GenericWriter& writer) {
-  writer.castTo<bool>() = object.asBool();
-}
-
-template <typename T>
-FOLLY_ALWAYS_INLINE T castJsonToInt(const folly::dynamic& object) {
-  if (object.isDouble()) {
-    constexpr double kIntMaxAsDouble =
-        static_cast<double>(std::numeric_limits<T>::max());
-    constexpr double kIntMinAsDouble =
-        static_cast<double>(std::numeric_limits<T>::min());
-
-    double value = object.asDouble();
-    if (value <= kIntMaxAsDouble && value >= kIntMinAsDouble) {
-      return static_cast<T>(value);
-    }
-
-    VELOX_USER_FAIL(
-        "value is out of range [{}, {}]: {}",
-        kIntMinAsDouble,
-        kIntMaxAsDouble,
-        value);
+  using T = typename TypeTraits<kind>::NativeType;
+  if constexpr (std::is_same_v<T, void>) {
+    return simdjson::INCORRECT_TYPE;
   } else {
-    return folly::to<T>(object.asInt());
+    SIMDJSON_ASSIGN_OR_RAISE(writer.castTo<T>(), fromString<T>(value));
+    return simdjson::SUCCESS;
   }
 }
 
 template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::TINYINT>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  writer.castTo<int8_t>() = castJsonToInt<int8_t>(object);
-}
-
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::SMALLINT>(
-    const folly::dynamic& object,
+simdjson::error_code appendMapKey<TypeKind::VARCHAR>(
+    const std::string_view& value,
     exec::GenericWriter& writer) {
-  writer.castTo<int16_t>() = castJsonToInt<int16_t>(object);
+  writer.castTo<Varchar>().append(value);
+  return simdjson::SUCCESS;
 }
 
 template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::INTEGER>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  writer.castTo<int32_t>() = castJsonToInt<int32_t>(object);
-}
-
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::BIGINT>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  writer.castTo<int64_t>() = castJsonToInt<int64_t>(object);
+simdjson::error_code appendMapKey<TypeKind::VARBINARY>(
+    const std::string_view& /*value*/,
+    exec::GenericWriter& /*writer*/) {
+  return simdjson::INCORRECT_TYPE;
 }
 
 template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::REAL>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  writer.castTo<float>() = folly::to<float>(object.asDouble());
+simdjson::error_code appendMapKey<TypeKind::TIMESTAMP>(
+    const std::string_view& /*value*/,
+    exec::GenericWriter& /*writer*/) {
+  return simdjson::INCORRECT_TYPE;
 }
 
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::DOUBLE>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  writer.castTo<double>() = folly::to<double>(object.asDouble());
-}
-
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::ARRAY>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  auto& writerTyped = writer.castTo<Array<Any>>();
-
-  for (auto it = object.begin(); it != object.end(); ++it) {
-    // If casting to array of JSON, nulls in array elements should become the
-    // JSON text "null".
-    if (!isJsonType(writer.type()->childAt(0)) && it->isNull()) {
-      writerTyped.add_null();
-    } else {
-      VELOX_DYNAMIC_TYPE_DISPATCH(
-          castFromJsonTyped,
-          writer.type()->childAt(0)->kind(),
-          *it,
-          writerTyped.add_item());
-    }
+template <typename Input>
+struct CastFromJsonTypedImpl {
+  template <TypeKind kind>
+  static simdjson::error_code apply(Input input, exec::GenericWriter& writer) {
+    return KindDispatcher<kind>::apply(input, writer);
   }
-}
 
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::MAP>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  auto& writerTyped = writer.castTo<Map<Any, Any>>();
-
-  for (const auto& pair : object.items()) {
-    // If casting to map of JSON values, nulls in map values should become the
-    // JSON text "null".
-    if (!isJsonType(writer.type()->childAt(1)) && pair.second.isNull()) {
-      auto& keyWriter = writerTyped.add_null();
-      VELOX_DYNAMIC_TYPE_DISPATCH(
-          castFromJsonTyped,
-          writer.type()->childAt(0)->kind(),
-          pair.first,
-          keyWriter);
-    } else {
-      auto writerPair = writerTyped.add_item();
-      VELOX_DYNAMIC_TYPE_DISPATCH(
-          castFromJsonTyped,
-          writer.type()->childAt(0)->kind(),
-          pair.first,
-          std::get<0>(writerPair));
-      VELOX_DYNAMIC_TYPE_DISPATCH(
-          castFromJsonTyped,
-          writer.type()->childAt(1)->kind(),
-          pair.second,
-          std::get<1>(writerPair));
+ private:
+  // Dummy is needed because full/explicit specialization is not allowed inside
+  // class.
+  template <TypeKind kind, typename Dummy = void>
+  struct KindDispatcher {
+    static simdjson::error_code apply(Input, exec::GenericWriter&) {
+      VELOX_NYI(
+          "Casting from JSON to {} is not supported.", TypeTraits<kind>::name);
+      return simdjson::error_code::UNEXPECTED_ERROR; // Make compiler happy.
     }
-  }
-}
-
-template <>
-FOLLY_ALWAYS_INLINE void castFromJsonTyped<TypeKind::ROW>(
-    const folly::dynamic& object,
-    exec::GenericWriter& writer) {
-  VELOX_USER_CHECK(
-      object.isArray() || object.isObject(),
-      "Only casting from JSON array or object to ROW is supported.");
-
-  auto& writerTyped = writer.castTo<DynamicRow>();
-
-  if (object.isArray()) {
-    VELOX_USER_CHECK_EQ(
-        writer.type()->size(),
-        object.size(),
-        "Cannot cast a JSON array of size {} to ROW with {} fields.",
-        object.size(),
-        writer.type()->size());
-
-    column_index_t i = 0;
-    for (auto it = object.begin(); it != object.end(); ++it, ++i) {
-      if (it->isNull()) {
-        writerTyped.set_null_at(i);
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::VARCHAR, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
+      std::string_view s;
+      if (isJsonType(writer.type())) {
+        SIMDJSON_ASSIGN_OR_RAISE(s, rawJson(value, type));
       } else {
-        VELOX_DYNAMIC_TYPE_DISPATCH(
-            castFromJsonTyped,
-            writer.type()->childAt(i)->kind(),
-            *it,
-            writerTyped.get_writer_at(i));
+        switch (type) {
+          case simdjson::ondemand::json_type::string: {
+            SIMDJSON_ASSIGN_OR_RAISE(s, value.get_string());
+            break;
+          }
+          case simdjson::ondemand::json_type::number:
+          case simdjson::ondemand::json_type::boolean:
+            s = value.raw_json_token();
+            break;
+          default:
+            return simdjson::INCORRECT_TYPE;
+        }
       }
+      writer.castTo<Varchar>().append(s);
+      return simdjson::SUCCESS;
     }
-  } else {
-    auto rowType = writer.type()->asRow();
-    column_index_t fieldCount = rowType.size();
-    auto notFound = object.items().end();
-
-    folly::F14FastMap<std::string, const folly::dynamic*> lowerCaseKeys;
-    lowerCaseKeys.reserve(object.size());
-
-    for (const auto& [key, value] : object.items()) {
-      // Skip null values.
-      if (!value.isNull()) {
-        const auto lowerCaseKey =
-            boost::algorithm::to_lower_copy(key.asString());
-        lowerCaseKeys.insert({lowerCaseKey, &value});
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::BOOLEAN, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
+      auto& w = writer.castTo<bool>();
+      switch (type) {
+        case simdjson::ondemand::json_type::boolean: {
+          SIMDJSON_ASSIGN_OR_RAISE(w, value.get_bool());
+          break;
+        }
+        case simdjson::ondemand::json_type::number: {
+          SIMDJSON_ASSIGN_OR_RAISE(auto num, value.get_number());
+          switch (num.get_number_type()) {
+            case simdjson::ondemand::number_type::floating_point_number:
+              w = num.get_double() != 0;
+              break;
+            case simdjson::ondemand::number_type::signed_integer:
+              w = num.get_int64() != 0;
+              break;
+            case simdjson::ondemand::number_type::unsigned_integer:
+              w = num.get_uint64() != 0;
+              break;
+            case simdjson::ondemand::number_type::big_integer:
+              VELOX_UNREACHABLE(); // value.get_number() would have failed
+                                   // already.
+          }
+          break;
+        }
+        case simdjson::ondemand::json_type::string: {
+          SIMDJSON_ASSIGN_OR_RAISE(auto s, value.get_string());
+          SIMDJSON_ASSIGN_OR_RAISE(w, fromString<bool>(s));
+          break;
+        }
+        default:
+          return simdjson::INCORRECT_TYPE;
       }
+      return simdjson::SUCCESS;
     }
-
-    for (column_index_t i = 0; i < fieldCount; ++i) {
-      const auto lowerCaseName =
-          boost::algorithm::to_lower_copy(rowType.nameOf(i));
-      auto it = lowerCaseKeys.find(lowerCaseName);
-      if (it == lowerCaseKeys.end()) {
-        writerTyped.set_null_at(i);
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::TINYINT, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      return castJsonToInt<int8_t>(value, writer);
+    }
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::SMALLINT, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      return castJsonToInt<int16_t>(value, writer);
+    }
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::INTEGER, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      return castJsonToInt<int32_t>(value, writer);
+    }
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::BIGINT, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      return castJsonToInt<int64_t>(value, writer);
+    }
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::REAL, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      return castJsonToFloatingPoint<float>(value, writer);
+    }
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::DOUBLE, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      return castJsonToFloatingPoint<double>(value, writer);
+    }
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::ARRAY, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      auto& writerTyped = writer.castTo<Array<Any>>();
+      auto& elementType = writer.type()->childAt(0);
+      SIMDJSON_ASSIGN_OR_RAISE(auto array, value.get_array());
+      for (auto elementResult : array) {
+        SIMDJSON_ASSIGN_OR_RAISE(auto element, elementResult);
+        // If casting to array of JSON, nulls in array elements should become
+        // the JSON text "null".
+        if (!isJsonType(elementType) && element.is_null()) {
+          writerTyped.add_null();
+        } else {
+          SIMDJSON_TRY(VELOX_DYNAMIC_TYPE_DISPATCH(
+              CastFromJsonTypedImpl<simdjson::ondemand::value>::apply,
+              elementType->kind(),
+              element,
+              writerTyped.add_item()));
+        }
+      }
+      return simdjson::SUCCESS;
+    }
+  };
+
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::MAP, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      auto& writerTyped = writer.castTo<Map<Any, Any>>();
+      auto& keyType = writer.type()->childAt(0);
+      auto& valueType = writer.type()->childAt(1);
+      SIMDJSON_ASSIGN_OR_RAISE(auto object, value.get_object());
+      for (auto fieldResult : object) {
+        SIMDJSON_ASSIGN_OR_RAISE(auto field, fieldResult);
+        SIMDJSON_ASSIGN_OR_RAISE(auto key, field.unescaped_key(true));
+        // If casting to map of JSON values, nulls in map values should become
+        // the JSON text "null".
+        if (!isJsonType(valueType) && field.value().is_null()) {
+          SIMDJSON_TRY(VELOX_DYNAMIC_TYPE_DISPATCH(
+              appendMapKey, keyType->kind(), key, writerTyped.add_null()));
+        } else {
+          auto writers = writerTyped.add_item();
+          SIMDJSON_TRY(VELOX_DYNAMIC_TYPE_DISPATCH(
+              appendMapKey, keyType->kind(), key, std::get<0>(writers)));
+          SIMDJSON_TRY(VELOX_DYNAMIC_TYPE_DISPATCH(
+              CastFromJsonTypedImpl<simdjson::ondemand::value>::apply,
+              valueType->kind(),
+              field.value(),
+              std::get<1>(writers)));
+        }
+      }
+      return simdjson::SUCCESS;
+    }
+  };
+
+  static folly::F14FastMap<std::string, int32_t> makeFieldIndicesMap(
+      const RowType& rowType,
+      bool allFieldsAreAscii) {
+    folly::F14FastMap<std::string, int32_t> fieldIndices;
+    const auto size = rowType.size();
+    for (auto i = 0; i < size; ++i) {
+      std::string key = rowType.nameOf(i);
+      if (allFieldsAreAscii) {
+        folly::toLowerAscii(key);
       } else {
-        VELOX_DYNAMIC_TYPE_DISPATCH(
-            castFromJsonTyped,
-            rowType.childAt(i)->kind(),
-            *(it->second),
-            writerTyped.get_writer_at(i));
+        boost::algorithm::to_lower(key);
       }
+
+      fieldIndices[key] = i;
     }
-  }
-}
 
-template <TypeKind kind>
-void castFromJson(
-    const BaseVector& input,
-    exec::EvalCtx& context,
-    const SelectivityVector& rows,
-    BaseVector& result) {
-  // result is guaranteed to be a flat writable vector.
-  auto* flatResult = result.as<typename KindToFlatVector<kind>::type>();
-  exec::VectorWriter<Any> writer;
-  writer.init(*flatResult);
+    return fieldIndices;
+  }
 
-  // input is guaranteed to be in flat or constant encodings when passed in.
-  auto* inputVector = input.as<SimpleVector<StringView>>();
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::ROW, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer) {
+      auto& rowType = writer.type()->asRow();
+      auto& writerTyped = writer.castTo<DynamicRow>();
+      SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
+      if (type == simdjson::ondemand::json_type::array) {
+        SIMDJSON_ASSIGN_OR_RAISE(auto array, value.get_array());
+        SIMDJSON_ASSIGN_OR_RAISE(auto arraySize, array.count_elements());
+        if (arraySize != writer.type()->size()) {
+          return simdjson::INCORRECT_TYPE;
+        }
+        column_index_t i = 0;
+        for (auto elementResult : array) {
+          SIMDJSON_ASSIGN_OR_RAISE(auto element, elementResult);
+          if (element.is_null()) {
+            writerTyped.set_null_at(i);
+          } else {
+            SIMDJSON_TRY(VELOX_DYNAMIC_TYPE_DISPATCH(
+                CastFromJsonTypedImpl<simdjson::ondemand::value>::apply,
+                rowType.childAt(i)->kind(),
+                element,
+                writerTyped.get_writer_at(i)));
+          }
+          ++i;
+        }
+      } else {
+        SIMDJSON_ASSIGN_OR_RAISE(auto object, value.get_object());
+
+        // TODO Populate this mapping once, not per-row.
+        // Mapping from lower-case field names of the target RowType to their
+        // indices.
+        bool allFieldsAreAscii = true;
+        const auto size = rowType.size();
+        for (auto i = 0; i < size; ++i) {
+          const auto& name = rowType.nameOf(i);
+          allFieldsAreAscii &=
+              functions::stringCore::isAscii(name.data(), name.size());
+        }
 
-  folly::dynamic object;
-  context.applyToSelectedNoThrow(rows, [&](auto row) {
-    writer.setOffset(row);
+        auto fieldIndices = makeFieldIndicesMap(rowType, allFieldsAreAscii);
+
+        std::string key;
+        for (auto fieldResult : object) {
+          SIMDJSON_ASSIGN_OR_RAISE(auto field, fieldResult);
+          if (!field.value().is_null()) {
+            SIMDJSON_ASSIGN_OR_RAISE(key, field.unescaped_key(true));
+
+            // boost::algorithm::to_lower is very slow. Use much faster
+            // folly::toLowerAscii if possible.
+            if (allFieldsAreAscii) {
+              folly::toLowerAscii(key);
+            } else {
+              boost::algorithm::to_lower(key);
+            }
+
+            auto it = fieldIndices.find(key);
+            if (it != fieldIndices.end()) {
+              const auto index = it->second;
+
+              VELOX_USER_CHECK_GE(index, 0, "Duplicate field: {}", key);
+              it->second = -1;
+
+              SIMDJSON_TRY(VELOX_DYNAMIC_TYPE_DISPATCH(
+                  CastFromJsonTypedImpl<simdjson::ondemand::value>::apply,
+                  rowType.childAt(index)->kind(),
+                  field.value(),
+                  writerTyped.get_writer_at(index)));
+            }
+          }
+        }
 
-    if (inputVector->isNullAt(row)) {
-      writer.commitNull();
-    } else {
-      try {
-        object = folly::parseJson(inputVector->valueAt(row));
-      } catch (const std::exception& e) {
-        writer.commitNull();
-        VELOX_USER_FAIL("Not a JSON input: {}", inputVector->valueAt(row));
+        for (const auto& [key, index] : fieldIndices) {
+          if (index >= 0) {
+            writerTyped.set_null_at(index);
+          }
+        }
       }
+      return simdjson::SUCCESS;
+    }
+  };
+
+  static simdjson::simdjson_result<std::string_view> rawJson(
+      Input value,
+      simdjson::ondemand::json_type type) {
+    switch (type) {
+      case simdjson::ondemand::json_type::array: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto array, value.get_array());
+        return array.raw_json();
+      }
+      case simdjson::ondemand::json_type::object: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto object, value.get_object());
+        return object.raw_json();
+      }
+      default:
+        return value.raw_json_token();
+    }
+  }
 
-      if (object.isNull()) {
-        writer.commitNull();
-      } else {
-        try {
-          castFromJsonTyped<kind>(object, writer.current());
-        } catch (const VeloxException& ve) {
-          if (!ve.isUserError()) {
-            throw;
-          }
-          writer.commitNull();
-          VELOX_USER_FAIL(
-              "Cannot cast from Json value {} to {}: {}",
-              inputVector->valueAt(row),
-              result.type()->toString(),
-              ve.message());
-        } catch (const std::exception& e) {
-          writer.commitNull();
-          VELOX_USER_FAIL(
-              "Cannot cast from Json value {} to {}: {}",
-              inputVector->valueAt(row),
-              result.type()->toString(),
-              e.what());
+  template <typename T>
+  static simdjson::error_code castJsonToInt(
+      Input value,
+      exec::GenericWriter& writer) {
+    SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
+    switch (type) {
+      case simdjson::ondemand::json_type::number: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto num, value.get_number());
+        switch (num.get_number_type()) {
+          case simdjson::ondemand::number_type::floating_point_number:
+            return convertIfInRange<T>(num.get_double(), writer);
+          case simdjson::ondemand::number_type::signed_integer:
+            return convertIfInRange<T>(num.get_int64(), writer);
+          case simdjson::ondemand::number_type::unsigned_integer:
+            return simdjson::NUMBER_OUT_OF_RANGE;
+          case simdjson::ondemand::number_type::big_integer:
+            VELOX_UNREACHABLE(); // value.get_number() would have failed
+                                 // already.
         }
-        writer.commit(true);
+        break;
       }
+      case simdjson::ondemand::json_type::boolean: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto b, value.get_bool());
+        writer.castTo<T>() = b;
+        break;
+      }
+      case simdjson::ondemand::json_type::string: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto s, value.get_string());
+        SIMDJSON_ASSIGN_OR_RAISE(writer.castTo<T>(), fromString<T>(s));
+        break;
+      }
+      default:
+        return simdjson::INCORRECT_TYPE;
     }
-  });
-  writer.finish();
+    return simdjson::SUCCESS;
+  }
+
+  template <typename T>
+  static simdjson::error_code castJsonToFloatingPoint(
+      Input value,
+      exec::GenericWriter& writer) {
+    SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
+    switch (type) {
+      case simdjson::ondemand::json_type::number: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto num, value.get_double());
+        return convertIfInRange<T>(num, writer);
+      }
+      case simdjson::ondemand::json_type::boolean: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto b, value.get_bool());
+        writer.castTo<T>() = b;
+        break;
+      }
+      case simdjson::ondemand::json_type::string: {
+        SIMDJSON_ASSIGN_OR_RAISE(auto s, value.get_string());
+        SIMDJSON_ASSIGN_OR_RAISE(writer.castTo<T>(), fromString<T>(s));
+        break;
+      }
+      default:
+        return simdjson::INCORRECT_TYPE;
+    }
+    return simdjson::SUCCESS;
+  }
+};
+
+template <TypeKind kind>
+simdjson::error_code castFromJsonOneRow(
+    simdjson::padded_string_view input,
+    exec::VectorWriter<Any>& writer) {
+  SIMDJSON_ASSIGN_OR_RAISE(auto doc, simdjsonParse(input));
+  if (doc.is_null()) {
+    writer.commitNull();
+  } else {
+    SIMDJSON_TRY(
+        CastFromJsonTypedImpl<simdjson::ondemand::document&>::apply<kind>(
+            doc, writer.current()));
+    writer.commit(true);
+  }
+  return simdjson::SUCCESS;
 }
 
 bool isSupportedBasicType(const TypePtr& type) {
@@ -773,7 +1095,79 @@ bool isSupportedBasicType(const TypePtr& type) {
   }
 }
 
-} // namespace
+/// Custom operator for casts from and to Json type.
+class JsonCastOperator : public exec::CastOperator {
+ public:
+  bool isSupportedFromType(const TypePtr& other) const override;
+
+  bool isSupportedToType(const TypePtr& other) const override;
+
+  void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override;
+
+  void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result,
+      const std::shared_ptr<exec::CastHooks>& hooks) const override;
+
+  void castFrom(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override;
+
+ private:
+  template <TypeKind kind>
+  void castFromJson(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) const {
+    // Result is guaranteed to be a flat writable vector.
+    auto* flatResult = result.as<typename KindToFlatVector<kind>::type>();
+    exec::VectorWriter<Any> writer;
+    writer.init(*flatResult);
+    // Input is guaranteed to be in flat or constant encodings when passed in.
+    auto* inputVector = input.as<SimpleVector<StringView>>();
+    size_t maxSize = 0;
+    rows.applyToSelected([&](auto row) {
+      if (inputVector->isNullAt(row)) {
+        return;
+      }
+      auto& input = inputVector->valueAt(row);
+      maxSize = std::max(maxSize, input.size());
+    });
+    paddedInput_.resize(maxSize + simdjson::SIMDJSON_PADDING);
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      writer.setOffset(row);
+      if (inputVector->isNullAt(row)) {
+        writer.commitNull();
+        return;
+      }
+      auto& input = inputVector->valueAt(row);
+      memcpy(paddedInput_.data(), input.data(), input.size());
+      simdjson::padded_string_view paddedInput(
+          paddedInput_.data(), input.size(), paddedInput_.size());
+      if (auto error = castFromJsonOneRow<kind>(paddedInput, writer)) {
+        context.setVeloxExceptionError(row, errors_[error]);
+        writer.commitNull();
+      }
+    });
+    writer.finish();
+  }
+
+  mutable folly::once_flag initializeErrors_;
+  mutable std::exception_ptr errors_[simdjson::NUM_ERROR_CODES];
+  mutable std::string paddedInput_;
+};
 
 bool JsonCastOperator::isSupportedFromType(const TypePtr& other) const {
   if (isSupportedBasicType(other)) {
@@ -847,13 +1241,23 @@ void JsonCastOperator::castTo(
     const SelectivityVector& rows,
     const TypePtr& resultType,
     VectorPtr& result) const {
+  castTo(input, context, rows, resultType, result, nullptr);
+}
+
+void JsonCastOperator::castTo(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    const TypePtr& resultType,
+    VectorPtr& result,
+    const std::shared_ptr<exec::CastHooks>& hooks) const {
   context.ensureWritable(rows, resultType, result);
   auto* flatResult = result->as<FlatVector<StringView>>();
 
   // Casting from VARBINARY and OPAQUE are not supported and should have been
   // rejected by isSupportedType() in the caller.
   VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-      castToJson, input.typeKind(), input, context, rows, *flatResult);
+      castToJson, input.typeKind(), input, context, rows, *flatResult, hooks);
 }
 
 /// Converts an input vector from Json type to the type of result vector.
@@ -863,6 +1267,9 @@ void JsonCastOperator::castFrom(
     const SelectivityVector& rows,
     const TypePtr& resultType,
     VectorPtr& result) const {
+  // Initialize errors here so that we get the proper exception context.
+  folly::call_once(
+      initializeErrors_, [this] { simdjsonErrorsToExceptions(errors_); });
   context.ensureWritable(rows, resultType, result);
   // Casting to unsupported types should have been rejected by isSupportedType()
   // in the caller.
@@ -870,6 +1277,21 @@ void JsonCastOperator::castFrom(
       castFromJson, result->typeKind(), input, context, rows, *result);
 }
 
+class JsonTypeFactories : public CustomTypeFactories {
+ public:
+  JsonTypeFactories() = default;
+
+  TypePtr getType() const override {
+    return JSON();
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return std::make_shared<JsonCastOperator>();
+  }
+};
+
+} // namespace
+
 void registerJsonType() {
   registerCustomType("json", std::make_unique<const JsonTypeFactories>());
 }
diff --git a/velox/functions/prestosql/types/JsonType.h b/velox/functions/prestosql/types/JsonType.h
index f879c0ff4e81b..224679d64208f 100644
--- a/velox/functions/prestosql/types/JsonType.h
+++ b/velox/functions/prestosql/types/JsonType.h
@@ -16,42 +16,11 @@
 #pragma once
 
 #include "velox/expression/CastExpr.h"
+#include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
 
-/// Custom operator for casts from and to Json type.
-class JsonCastOperator : public exec::CastOperator {
- public:
-  static const std::shared_ptr<const CastOperator>& get() {
-    static const std::shared_ptr<const CastOperator> instance{
-        new JsonCastOperator()};
-
-    return instance;
-  }
-
-  bool isSupportedFromType(const TypePtr& other) const override;
-
-  bool isSupportedToType(const TypePtr& other) const override;
-
-  void castTo(
-      const BaseVector& input,
-      exec::EvalCtx& context,
-      const SelectivityVector& rows,
-      const TypePtr& resultType,
-      VectorPtr& result) const override;
-
-  void castFrom(
-      const BaseVector& input,
-      exec::EvalCtx& context,
-      const SelectivityVector& rows,
-      const TypePtr& resultType,
-      VectorPtr& result) const override;
-
- private:
-  JsonCastOperator() = default;
-};
-
 /// Represents JSON as a string.
 class JsonType : public VarcharType {
   JsonType() = default;
@@ -63,10 +32,6 @@ class JsonType : public VarcharType {
     return instance;
   }
 
-  static const std::shared_ptr<const exec::CastOperator>& getCastOperator() {
-    return JsonCastOperator::get();
-  }
-
   bool equivalent(const Type& other) const override {
     // Pointer comparison works since this type is a singleton.
     return this == &other;
@@ -105,19 +70,6 @@ struct JsonT {
 
 using Json = CustomType<JsonT>;
 
-class JsonTypeFactories : public CustomTypeFactories {
- public:
-  JsonTypeFactories() = default;
-
-  TypePtr getType() const override {
-    return JSON();
-  }
-
-  exec::CastOperatorPtr getCastOperator() const override {
-    return JsonCastOperator::get();
-  }
-};
-
 void registerJsonType();
 
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimestampWithTimeZoneType.cpp b/velox/functions/prestosql/types/TimestampWithTimeZoneType.cpp
index aa92a5bc39478..bf8bd4a0cbd4a 100644
--- a/velox/functions/prestosql/types/TimestampWithTimeZoneType.cpp
+++ b/velox/functions/prestosql/types/TimestampWithTimeZoneType.cpp
@@ -14,96 +14,163 @@
  * limitations under the License.
  */
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/expression/StringWriter.h"
+#include "velox/functions/lib/DateTimeFormatter.h"
+#include "velox/type/Timestamp.h"
+#include "velox/type/TimestampConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox {
 namespace {
+
+const tz::TimeZone* getTimeZoneFromConfig(const core::QueryConfig& config) {
+  const auto sessionTzName = config.sessionTimezone();
+
+  if (!sessionTzName.empty()) {
+    return tz::locateZone(sessionTzName);
+  }
+
+  return tz::locateZone(0); // GMT
+}
+
 void castFromTimestamp(
     const SimpleVector<Timestamp>& inputVector,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    RowVector& rowResult) {
+    int64_t* rawResults) {
   const auto& config = context.execCtx()->queryCtx()->queryConfig();
-  const auto& sessionTzName = config.sessionTimezone();
-  int64_t sessionTzID = 0;
-  if (!sessionTzName.empty()) {
-    sessionTzID = util::getTimeZoneID(sessionTzName);
-  }
+  const auto* sessionTimeZone = getTimeZoneFromConfig(config);
+
   const auto adjustTimestampToTimezone = config.adjustTimestampToTimezone();
 
-  auto timestampVector = rowResult.childAt(0)->asFlatVector<int64_t>();
-  auto timezoneVector = rowResult.childAt(1)->asFlatVector<int16_t>();
-  auto rawTsValues = timestampVector->values()->asMutable<int64_t>();
-  auto rawTzValues = timezoneVector->values()->asMutable<int16_t>();
-  timestampVector->clearNulls(rows);
-  timezoneVector->clearNulls(rows);
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    auto ts = inputVector.valueAt(row);
+    if (!adjustTimestampToTimezone) {
+      // Treat TIMESTAMP as wall time in session time zone. This means that in
+      // order to get its UTC representation we need to shift the value by the
+      // offset of the time zone.
+      ts.toGMT(*sessionTimeZone);
+    }
+    rawResults[row] = pack(ts.toMillis(), sessionTimeZone->id());
+  });
+}
+
+void castFromDate(
+    const SimpleVector<int32_t>& inputVector,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    int64_t* rawResults) {
+  const auto& config = context.execCtx()->queryCtx()->queryConfig();
+  const auto* sessionTimeZone = getTimeZoneFromConfig(config);
+
+  static const int64_t kSecondsInDay = 86400;
 
   context.applyToSelectedNoThrow(rows, [&](auto row) {
-    if (inputVector.isNullAt(row)) {
-      rowResult.setNull(row, true);
+    const auto days = inputVector.valueAt(row);
+    Timestamp ts{days * kSecondsInDay, 0};
+    if (sessionTimeZone != nullptr) {
+      ts.toGMT(*sessionTimeZone);
+    }
+    rawResults[row] = pack(ts.toMillis(), sessionTimeZone->id());
+  });
+}
+
+void castFromString(
+    const SimpleVector<StringView>& inputVector,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    int64_t* rawResults) {
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    const auto castResult = util::fromTimestampWithTimezoneString(
+        inputVector.valueAt(row).data(),
+        inputVector.valueAt(row).size(),
+        util::TimestampParseMode::kPrestoCast);
+    if (castResult.hasError()) {
+      context.setStatus(row, castResult.error());
     } else {
-      auto ts = inputVector.valueAt(row);
-      if (!adjustTimestampToTimezone) {
-        // Treat TIMESTAMP as wall time in session time zone. This means that in
-        // order to get its UTC representation we need to shift the value by the
-        // offset of the time zone.
-        ts.toGMT(sessionTzID);
+      auto [ts, timeZone] = castResult.value();
+      // Input string may not contain a timezone - if so, it is interpreted in
+      // session timezone.
+      if (timeZone == nullptr) {
+        const auto& config = context.execCtx()->queryCtx()->queryConfig();
+        timeZone = getTimeZoneFromConfig(config);
       }
-      rawTsValues[row] = ts.toMillis();
-      rawTzValues[row] = sessionTzID;
+      ts.toGMT(*timeZone);
+      rawResults[row] = pack(ts.toMillis(), timeZone->id());
     }
   });
 }
 
-template <TypeKind kind>
-void castToTimestampWithTimeZone(
+void castToString(
     const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    RowVector& rowResult) {
-  VELOX_CHECK_EQ(kind, TypeKind::TIMESTAMP)
-  const auto inputVector = input.as<SimpleVector<Timestamp>>();
-  castFromTimestamp(*inputVector, context, rows, rowResult);
+    BaseVector& result) {
+  auto* flatResult = result.as<FlatVector<StringView>>();
+  const auto* timestamps = input.as<SimpleVector<int64_t>>();
+
+  auto formatter =
+      functions::buildJodaDateTimeFormatter("yyyy-MM-dd HH:mm:ss.SSS zzzz");
+
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    const auto timestampWithTimezone = timestamps->valueAt(row);
+
+    const auto timestamp = unpackTimestampUtc(timestampWithTimezone);
+    const auto timeZoneId = unpackZoneKeyId(timestampWithTimezone);
+    const auto* timezonePtr = tz::locateZone(tz::getTimeZoneName(timeZoneId));
+
+    exec::StringWriter<false> result(flatResult, row);
+
+    const auto maxResultSize = formatter->maxResultSize(timezonePtr);
+    result.reserve(maxResultSize);
+    const auto resultSize =
+        formatter->format(timestamp, timezonePtr, maxResultSize, result.data());
+    result.resize(resultSize);
+
+    result.finalize();
+  });
 }
 
 void castToTimestamp(
-    const RowVector& inputVector,
+    const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
-    FlatVector<Timestamp>& flatResult) {
+    BaseVector& result) {
   const auto& config = context.execCtx()->queryCtx()->queryConfig();
   const auto adjustTimestampToTimezone = config.adjustTimestampToTimezone();
-  const auto timestampVector =
-      inputVector.childAt(0)->as<SimpleVector<int64_t>>();
-  const auto timezoneVector =
-      inputVector.childAt(1)->as<SimpleVector<int16_t>>();
+  auto* flatResult = result.as<FlatVector<Timestamp>>();
+  const auto* timestamps = input.as<SimpleVector<int64_t>>();
 
   context.applyToSelectedNoThrow(rows, [&](auto row) {
-    if (inputVector.isNullAt(row)) {
-      flatResult.setNull(row, true);
-    } else {
-      Timestamp ts = Timestamp::fromMillis(timestampVector->valueAt(row));
-      if (!adjustTimestampToTimezone) {
-        // Convert UTC to the given time zone.
-        ts.toTimezone(timezoneVector->valueAt(row));
-      }
-      flatResult.set(row, ts);
+    auto timestampWithTimezone = timestamps->valueAt(row);
+    auto ts = unpackTimestampUtc(timestampWithTimezone);
+    if (!adjustTimestampToTimezone) {
+      // Convert UTC to the given time zone.
+      ts.toTimezone(*tz::locateZone(unpackZoneKeyId(timestampWithTimezone)));
     }
+    flatResult->set(row, ts);
   });
 }
 
-template <TypeKind kind>
-void castFromTimestampWithTimeZone(
+void castToDate(
     const BaseVector& input,
     exec::EvalCtx& context,
     const SelectivityVector& rows,
     BaseVector& result) {
-  VELOX_CHECK_EQ(kind, TypeKind::TIMESTAMP)
+  auto* flatResult = result.as<FlatVector<int32_t>>();
+  const auto* timestampVector = input.as<SimpleVector<int64_t>>();
+
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    auto timestampWithTimezone = timestampVector->valueAt(row);
+    auto timestamp = unpackTimestampUtc(timestampWithTimezone);
+    timestamp.toTimezone(
+        *tz::locateZone(unpackZoneKeyId(timestampWithTimezone)));
 
-  const auto inputVector = input.as<RowVector>();
-  auto flatResult = result.as<FlatVector<Timestamp>>();
-  castToTimestamp(*inputVector, context, rows, *flatResult);
+    const auto days = util::toDate(timestamp, nullptr);
+    flatResult->set(row, days);
+  });
 }
+
 } // namespace
 
 bool TimestampWithTimeZoneCastOperator::isSupportedFromType(
@@ -112,9 +179,9 @@ bool TimestampWithTimeZoneCastOperator::isSupportedFromType(
     case TypeKind::TIMESTAMP:
       return true;
     case TypeKind::VARCHAR:
-      // TODO: support cast from VARCHAR
+      return true;
     case TypeKind::INTEGER:
-      // TODO: support cast from DATE
+      return other->isDate();
     default:
       return false;
   }
@@ -126,9 +193,9 @@ bool TimestampWithTimeZoneCastOperator::isSupportedToType(
     case TypeKind::TIMESTAMP:
       return true;
     case TypeKind::VARCHAR:
-      // TODO: support cast to VARCHAR
+      return true;
     case TypeKind::INTEGER:
-      // TODO: support cast to DATE
+      return other->isDate();
     default:
       return false;
   }
@@ -141,18 +208,27 @@ void TimestampWithTimeZoneCastOperator::castTo(
     const TypePtr& resultType,
     VectorPtr& result) const {
   context.ensureWritable(rows, resultType, result);
-  auto rowResult = result->as<RowVector>();
-  for (const auto& child : rowResult->children()) {
-    child->resize(rowResult->size());
-  }
 
-  VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-      castToTimestampWithTimeZone,
-      input.typeKind(),
-      input,
-      context,
-      rows,
-      *rowResult);
+  auto* timestampWithTzResult = result->asFlatVector<int64_t>();
+  timestampWithTzResult->clearNulls(rows);
+
+  auto* rawResults = timestampWithTzResult->mutableRawValues();
+
+  if (input.typeKind() == TypeKind::TIMESTAMP) {
+    const auto inputVector = input.as<SimpleVector<Timestamp>>();
+    castFromTimestamp(*inputVector, context, rows, rawResults);
+  } else if (input.typeKind() == TypeKind::VARCHAR) {
+    const auto inputVector = input.as<SimpleVector<StringView>>();
+    castFromString(*inputVector, context, rows, rawResults);
+  } else if (input.typeKind() == TypeKind::INTEGER) {
+    VELOX_CHECK(input.type()->isDate());
+    const auto inputVector = input.as<SimpleVector<int32_t>>();
+    castFromDate(*inputVector, context, rows, rawResults);
+  } else {
+    VELOX_UNSUPPORTED(
+        "Cast from {} to TIMESTAMP WITH TIME ZONE not yet supported",
+        input.type()->toString());
+  }
 }
 
 void TimestampWithTimeZoneCastOperator::castFrom(
@@ -163,13 +239,18 @@ void TimestampWithTimeZoneCastOperator::castFrom(
     VectorPtr& result) const {
   context.ensureWritable(rows, resultType, result);
 
-  VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-      castFromTimestampWithTimeZone,
-      result->typeKind(),
-      input,
-      context,
-      rows,
-      *result);
+  if (resultType->kind() == TypeKind::TIMESTAMP) {
+    castToTimestamp(input, context, rows, *result);
+  } else if (resultType->kind() == TypeKind::VARCHAR) {
+    castToString(input, context, rows, *result);
+  } else if (resultType->kind() == TypeKind::INTEGER) {
+    VELOX_CHECK(resultType->isDate());
+    castToDate(input, context, rows, *result);
+  } else {
+    VELOX_UNSUPPORTED(
+        "Cast from TIMESTAMP WITH TIME ZONE to {} not yet supported",
+        resultType->toString());
+  }
 }
 
 void registerTimestampWithTimeZoneType() {
diff --git a/velox/functions/prestosql/types/TimestampWithTimeZoneType.h b/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
index 1134c905dd706..78b56483e8624 100644
--- a/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
+++ b/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "velox/expression/CastExpr.h"
+#include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 #include "velox/vector/VectorTypeUtils.h"
 
@@ -54,9 +55,8 @@ class TimestampWithTimeZoneCastOperator : public exec::CastOperator {
 
 /// Represents timestamp with time zone as a number of milliseconds since epoch
 /// and time zone ID.
-class TimestampWithTimeZoneType : public RowType {
-  TimestampWithTimeZoneType()
-      : RowType({"timestamp", "timezone"}, {BIGINT(), SMALLINT()}) {}
+class TimestampWithTimeZoneType : public BigintType {
+  TimestampWithTimeZoneType() = default;
 
  public:
   static const std::shared_ptr<const TimestampWithTimeZoneType>& get() {
@@ -105,7 +105,7 @@ TIMESTAMP_WITH_TIME_ZONE() {
 
 // Type used for function registration.
 struct TimestampWithTimezoneT {
-  using type = Row<int64_t, int16_t>;
+  using type = int64_t;
   static constexpr const char* typeName = "timestamp with time zone";
 };
 
@@ -125,4 +125,29 @@ class TimestampWithTimeZoneTypeFactories : public CustomTypeFactories {
 
 void registerTimestampWithTimeZoneType();
 
+using TimeZoneKey = int16_t;
+
+constexpr int32_t kTimezoneMask = 0xFFF;
+constexpr int32_t kMillisShift = 12;
+
+inline int64_t unpackMillisUtc(int64_t dateTimeWithTimeZone) {
+  return dateTimeWithTimeZone >> kMillisShift;
+}
+
+inline TimeZoneKey unpackZoneKeyId(int64_t dateTimeWithTimeZone) {
+  return dateTimeWithTimeZone & kTimezoneMask;
+}
+
+inline int64_t pack(int64_t millisUtc, int16_t timeZoneKey) {
+  return (millisUtc << kMillisShift) | (timeZoneKey & kTimezoneMask);
+}
+
+inline int64_t pack(const Timestamp& timestamp, int16_t timeZoneKey) {
+  return pack(timestamp.toMillis(), timeZoneKey);
+}
+
+inline Timestamp unpackTimestampUtc(int64_t dateTimeWithTimeZone) {
+  return Timestamp::fromMillis(unpackMillisUtc(dateTimeWithTimeZone));
+}
+
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/UuidType.cpp b/velox/functions/prestosql/types/UuidType.cpp
new file mode 100644
index 0000000000000..8d0b5b5b22fa0
--- /dev/null
+++ b/velox/functions/prestosql/types/UuidType.cpp
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/types/UuidType.h"
+#include <boost/lexical_cast.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+namespace facebook::velox {
+
+namespace {
+
+class UuidCastOperator : public exec::CastOperator {
+ public:
+  bool isSupportedFromType(const TypePtr& other) const override {
+    return VARCHAR()->equivalent(*other);
+  }
+
+  bool isSupportedToType(const TypePtr& other) const override {
+    return VARCHAR()->equivalent(*other);
+  }
+
+  void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+
+    if (input.typeKind() == TypeKind::VARCHAR) {
+      castFromString(input, context, rows, *result);
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from {} to UUID not yet supported", resultType->toString());
+    }
+  }
+
+  void castFrom(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+
+    if (resultType->kind() == TypeKind::VARCHAR) {
+      castToString(input, context, rows, *result);
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from UUID to {} not yet supported", resultType->toString());
+    }
+  }
+
+ private:
+  static void castToString(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) {
+    auto* flatResult = result.as<FlatVector<StringView>>();
+    const auto* uuids = input.as<SimpleVector<int128_t>>();
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto uuid = uuids->valueAt(row);
+
+      const uint8_t* uuidBytes = reinterpret_cast<const uint8_t*>(&uuid);
+
+      // Do not use boost::lexical_cast. It is very slow.
+
+      // 2 hex digits per each value in [0, 127] range (1 byte).
+      static const char* const kHexTable =
+          "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
+          "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
+          "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
+          "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f"
+          "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
+          "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
+          "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
+          "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
+
+      exec::StringWriter<false> result(flatResult, row);
+      result.resize(36);
+
+      size_t offset = 0;
+      for (auto i = 0; i < 16; ++i) {
+        result.data()[offset] = kHexTable[uuidBytes[i] * 2];
+        result.data()[offset + 1] = kHexTable[uuidBytes[i] * 2 + 1];
+
+        offset += 2;
+        if (i == 3 || i == 5 || i == 7 || i == 9) {
+          result.data()[offset] = '-';
+          offset++;
+        }
+      }
+
+      result.finalize();
+    });
+  }
+
+  static void castFromString(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) {
+    auto* flatResult = result.as<FlatVector<int128_t>>();
+    const auto* uuidStrings = input.as<SimpleVector<StringView>>();
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto uuidString = uuidStrings->valueAt(row);
+
+      auto uuid = boost::lexical_cast<boost::uuids::uuid>(uuidString);
+
+      int128_t u;
+      memcpy(&u, &uuid, 16);
+
+      flatResult->set(row, u);
+    });
+  }
+};
+
+class UuidTypeFactories : public CustomTypeFactories {
+ public:
+  UuidTypeFactories() = default;
+
+  TypePtr getType() const override {
+    return UUID();
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return std::make_shared<UuidCastOperator>();
+  }
+};
+
+} // namespace
+
+void registerUuidType() {
+  registerCustomType("uuid", std::make_unique<const UuidTypeFactories>());
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/UuidType.h b/velox/functions/prestosql/types/UuidType.h
new file mode 100644
index 0000000000000..7f37dd80b4c90
--- /dev/null
+++ b/velox/functions/prestosql/types/UuidType.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/CastExpr.h"
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+/// Represents a UUID (Universally Unique IDentifier), also known as a
+/// GUID (Globally Unique IDentifier), using the format defined in :rfc:`4122`.
+///
+/// Example: UUID '12151fd2-7586-11e9-8f9e-2a86e4085a59'
+class UuidType : public HugeintType {
+  UuidType() = default;
+
+ public:
+  static const std::shared_ptr<const UuidType>& get() {
+    static const std::shared_ptr<const UuidType> instance{new UuidType()};
+
+    return instance;
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  const char* name() const override {
+    return "UUID";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "Type";
+    obj["type"] = name();
+    return obj;
+  }
+};
+
+FOLLY_ALWAYS_INLINE bool isUuidType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return UuidType::get() == type;
+}
+
+FOLLY_ALWAYS_INLINE std::shared_ptr<const UuidType> UUID() {
+  return UuidType::get();
+}
+
+// Type used for function registration.
+struct UuidT {
+  using type = int128_t;
+  static constexpr const char* typeName = "uuid";
+};
+
+using Uuid = CustomType<UuidT>;
+
+void registerUuidType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/tests/CMakeLists.txt b/velox/functions/prestosql/types/tests/CMakeLists.txt
index 6eda6a99e73e7..e2b8105d268ef 100644
--- a/velox/functions/prestosql/types/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/types/tests/CMakeLists.txt
@@ -11,9 +11,15 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 add_executable(
-  velox_presto_types_test HyperLogLogTypeTest.cpp JsonTypeTest.cpp
-                          TimestampWithTimeZoneTypeTest.cpp TypeTestBase.cpp)
+  velox_presto_types_test
+  HyperLogLogTypeTest.cpp
+  JsonTypeTest.cpp
+  TimestampWithTimeZoneTypeTest.cpp
+  TypeTestBase.cpp
+  UuidTypeTest.cpp
+  IPAddressTypeTest.cpp)
 
 add_test(velox_presto_types_test velox_presto_types_test)
 
@@ -21,8 +27,8 @@ target_link_libraries(
   velox_presto_types_test
   velox_presto_types
   Folly::folly
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   gflags::gflags
   glog::glog)
diff --git a/velox/functions/prestosql/types/tests/HyperLogLogTypeTest.cpp b/velox/functions/prestosql/types/tests/HyperLogLogTypeTest.cpp
index bff7427fb4417..7f4a6ba75446e 100644
--- a/velox/functions/prestosql/types/tests/HyperLogLogTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/HyperLogLogTypeTest.cpp
@@ -26,8 +26,8 @@ class HyperLogLogTypeTest : public testing::Test, public TypeTestBase {
 };
 
 TEST_F(HyperLogLogTypeTest, basic) {
-  ASSERT_EQ(HYPERLOGLOG()->name(), "HYPERLOGLOG");
-  ASSERT_EQ(HYPERLOGLOG()->kindName(), "VARBINARY");
+  ASSERT_STREQ(HYPERLOGLOG()->name(), "HYPERLOGLOG");
+  ASSERT_STREQ(HYPERLOGLOG()->kindName(), "VARBINARY");
   ASSERT_TRUE(HYPERLOGLOG()->parameters().empty());
   ASSERT_EQ(HYPERLOGLOG()->toString(), "HYPERLOGLOG");
 
diff --git a/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp b/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp
new file mode 100644
index 0000000000000..f024c785d94b3
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/types/IPAddressType.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class IPAddressTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  IPAddressTypeTest() {
+    registerIPAddressType();
+  }
+};
+
+TEST_F(IPAddressTypeTest, basic) {
+  ASSERT_STREQ(IPADDRESS()->name(), "IPADDRESS");
+  ASSERT_STREQ(IPADDRESS()->kindName(), "HUGEINT");
+  ASSERT_TRUE(IPADDRESS()->parameters().empty());
+  ASSERT_EQ(IPADDRESS()->toString(), "IPADDRESS");
+
+  ASSERT_TRUE(hasType("IPADDRESS"));
+  ASSERT_EQ(*getType("IPADDRESS", {}), *IPADDRESS());
+}
+
+TEST_F(IPAddressTypeTest, serde) {
+  testTypeSerde(IPADDRESS());
+}
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/JsonTypeTest.cpp b/velox/functions/prestosql/types/tests/JsonTypeTest.cpp
index 6ddafef8e96bb..9685f2b1d42fb 100644
--- a/velox/functions/prestosql/types/tests/JsonTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/JsonTypeTest.cpp
@@ -26,8 +26,8 @@ class JsonTypeTest : public testing::Test, public TypeTestBase {
 };
 
 TEST_F(JsonTypeTest, basic) {
-  ASSERT_EQ(JSON()->name(), "JSON");
-  ASSERT_EQ(JSON()->kindName(), "VARCHAR");
+  ASSERT_STREQ(JSON()->name(), "JSON");
+  ASSERT_STREQ(JSON()->kindName(), "VARCHAR");
   ASSERT_TRUE(JSON()->parameters().empty());
   ASSERT_EQ(JSON()->toString(), "JSON");
 
diff --git a/velox/functions/prestosql/types/tests/TimestampWithTimeZoneTypeTest.cpp b/velox/functions/prestosql/types/tests/TimestampWithTimeZoneTypeTest.cpp
index 71c25dd4c5ccc..8cfa5f578b6e7 100644
--- a/velox/functions/prestosql/types/tests/TimestampWithTimeZoneTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/TimestampWithTimeZoneTypeTest.cpp
@@ -27,8 +27,8 @@ class TimestampWithTimeZoneTypeTest : public testing::Test,
 };
 
 TEST_F(TimestampWithTimeZoneTypeTest, basic) {
-  ASSERT_EQ(TIMESTAMP_WITH_TIME_ZONE()->name(), "TIMESTAMP WITH TIME ZONE");
-  ASSERT_EQ(TIMESTAMP_WITH_TIME_ZONE()->kindName(), "ROW");
+  ASSERT_STREQ(TIMESTAMP_WITH_TIME_ZONE()->name(), "TIMESTAMP WITH TIME ZONE");
+  ASSERT_STREQ(TIMESTAMP_WITH_TIME_ZONE()->kindName(), "BIGINT");
   ASSERT_TRUE(TIMESTAMP_WITH_TIME_ZONE()->parameters().empty());
   ASSERT_EQ(TIMESTAMP_WITH_TIME_ZONE()->toString(), "TIMESTAMP WITH TIME ZONE");
 
@@ -40,4 +40,29 @@ TEST_F(TimestampWithTimeZoneTypeTest, basic) {
 TEST_F(TimestampWithTimeZoneTypeTest, serde) {
   testTypeSerde(TIMESTAMP_WITH_TIME_ZONE());
 }
+
+TEST_F(TimestampWithTimeZoneTypeTest, pack) {
+  std::mt19937 randGen(std::random_device{}());
+  // 0xFFF8000000000000 and 0x7FFFFFFFFFFFF are hexadecimal numbers
+  // that represent the minimum and maximum values that the
+  // TimestampWithTimeZoneType type can represent, respectively.
+  std::uniform_int_distribution<int64_t> millisUtcDis(
+      0xFFF8000000000000L, 0x7FFFFFFFFFFFF);
+
+  // 2233 represents the maximum value of timeZoneKey,
+  // see tzDB in TimeZoneDatabase.cpp
+  std::uniform_int_distribution<int16_t> timeZoneKeyDis(0, 2233);
+
+  for (int64_t i = 0; i < 10'000; ++i) {
+    auto millisUtc = millisUtcDis(randGen);
+    auto timeZoneKey = timeZoneKeyDis(randGen);
+    SCOPED_TRACE(
+        fmt::format("millisUtc={}, timeZoneKey={}", millisUtc, timeZoneKey));
+
+    auto packedTimeMillis = pack(millisUtc, timeZoneKey);
+    ASSERT_EQ(unpackMillisUtc(packedTimeMillis), millisUtc);
+    ASSERT_EQ(unpackZoneKeyId(packedTimeMillis), timeZoneKey);
+  }
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/UuidTypeTest.cpp b/velox/functions/prestosql/types/tests/UuidTypeTest.cpp
new file mode 100644
index 0000000000000..97ba1ea6a91e5
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/UuidTypeTest.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class UuidTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  UuidTypeTest() {
+    registerUuidType();
+  }
+};
+
+TEST_F(UuidTypeTest, basic) {
+  ASSERT_STREQ(UUID()->name(), "UUID");
+  ASSERT_STREQ(UUID()->kindName(), "HUGEINT");
+  ASSERT_TRUE(UUID()->parameters().empty());
+  ASSERT_EQ(UUID()->toString(), "UUID");
+
+  ASSERT_TRUE(hasType("UUID"));
+  ASSERT_EQ(*getType("UUID", {}), *UUID());
+}
+
+TEST_F(UuidTypeTest, serde) {
+  testTypeSerde(UUID());
+}
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/window/CMakeLists.txt b/velox/functions/prestosql/window/CMakeLists.txt
index 9770146d87198..2fa0b2f04f3cd 100644
--- a/velox/functions/prestosql/window/CMakeLists.txt
+++ b/velox/functions/prestosql/window/CMakeLists.txt
@@ -15,8 +15,16 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-add_library(velox_window CumeDist.cpp FirstLastValue.cpp LeadLag.cpp Ntile.cpp
-                         WindowFunctionsRegistration.cpp)
+velox_add_library(
+  velox_window
+  CumeDist.cpp
+  FirstLastValue.cpp
+  LeadLag.cpp
+  WindowFunctionsRegistration.cpp)
 
-target_link_libraries(velox_window velox_buffer velox_exec
-                      velox_functions_window Folly::folly)
+velox_link_libraries(
+  velox_window
+  velox_buffer
+  velox_exec
+  velox_functions_window
+  Folly::folly)
diff --git a/velox/functions/prestosql/window/CumeDist.cpp b/velox/functions/prestosql/window/CumeDist.cpp
index 98b264ec9ca92..439693e7ccc71 100644
--- a/velox/functions/prestosql/window/CumeDist.cpp
+++ b/velox/functions/prestosql/window/CumeDist.cpp
@@ -74,6 +74,7 @@ void registerCumeDist(const std::string& name) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& /*args*/,
           const TypePtr& /*resultType*/,
diff --git a/velox/functions/prestosql/window/FirstLastValue.cpp b/velox/functions/prestosql/window/FirstLastValue.cpp
index bab12e5d01cde..8aff5e26d2a2a 100644
--- a/velox/functions/prestosql/window/FirstLastValue.cpp
+++ b/velox/functions/prestosql/window/FirstLastValue.cpp
@@ -127,11 +127,13 @@ class FirstLastValueFunction : public exec::WindowFunction {
       // The function returns null for this case. -1 correctly maps to
       // kNullRow as expected for rowNumbers_ extraction.
       if constexpr (TValue == ValueType::kFirst) {
-        rowNumbers_[i] = bits::findFirstBit(
+        auto position = bits::findFirstBit(
             rawNonNulls, frameStart - leastFrame, frameEnd - leastFrame + 1);
+        rowNumbers_[i] = (position == -1) ? -1 : position + leastFrame;
       } else {
-        rowNumbers_[i] = bits::findLastBit(
+        auto position = bits::findLastBit(
             rawNonNulls, frameStart - leastFrame, frameEnd - leastFrame + 1);
+        rowNumbers_[i] = (position == -1) ? -1 : position + leastFrame;
       }
     });
   }
@@ -173,6 +175,7 @@ void registerFirstLastInternal(const std::string& name) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [](const std::vector<exec::WindowFunctionArg>& args,
          const TypePtr& resultType,
          bool ignoreNulls,
diff --git a/velox/functions/prestosql/window/LeadLag.cpp b/velox/functions/prestosql/window/LeadLag.cpp
index a394dd0c7573e..9d65351c76d56 100644
--- a/velox/functions/prestosql/window/LeadLag.cpp
+++ b/velox/functions/prestosql/window/LeadLag.cpp
@@ -87,6 +87,15 @@ class LeadLagFunction : public exec::WindowFunction {
   }
 
  private:
+  // Lead/Lag return default value (using kDefaultValueRow) if offsets for
+  // target rowNumbers are outside the partition. If offset is null, then the
+  // functions return null (using kNullRow) .
+  //
+  // kDefaultValueRow needs to be a negative number so that
+  // WindowPartition::extractColumn calls skip this row. It is set to -2 to
+  // distinguish it from kNullRow which is -1.
+  static constexpr vector_size_t kDefaultValueRow = -2;
+
   void initializeOffset(const std::vector<exec::WindowFunctionArg>& args) {
     if (args.size() == 1) {
       constantOffset_ = 1;
@@ -102,6 +111,9 @@ class LeadLagFunction : public exec::WindowFunction {
             constantOffset->as<ConstantVector<int64_t>>()->valueAt(0);
         VELOX_USER_CHECK_GE(
             constantOffset_.value(), 0, "Offset must be at least 0");
+        if (constantOffset_.value() == 0) {
+          isConstantOffsetZero_ = true;
+        }
       }
     } else {
       offsetIndex_ = offsetArg.index.value();
@@ -130,15 +142,21 @@ class LeadLagFunction : public exec::WindowFunction {
   void setRowNumbersForConstantOffset(vector_size_t offset);
 
   void setRowNumbersForConstantOffset() {
+    // Set row number to kNullRow for NULL offset.
     if (isConstantOffsetNull_) {
       std::fill(rowNumbers_.begin(), rowNumbers_.end(), kNullRow);
       return;
     }
+    // If the offset is 0 then it means always return the current row.
+    if (isConstantOffsetZero_) {
+      std::iota(rowNumbers_.begin(), rowNumbers_.end(), partitionOffset_);
+      return;
+    }
 
     auto constantOffsetValue = constantOffset_.value();
-    // Set row number to kNullRow for out of range offset.
+    // Set row number to kDefaultValueRow for out of range offset.
     if (constantOffsetValue > partition_->numRows()) {
-      std::fill(rowNumbers_.begin(), rowNumbers_.end(), kNullRow);
+      std::fill(rowNumbers_.begin(), rowNumbers_.end(), kDefaultValueRow);
       return;
     }
 
@@ -154,14 +172,20 @@ class LeadLagFunction : public exec::WindowFunction {
     const auto maxRowNumber = partition_->numRows() - 1;
     auto* rawNulls = nulls_->as<uint64_t>();
     for (auto i = 0; i < numRows; ++i) {
+      // Set row number to kNullRow for NULL offset.
       if (offsets_->isNullAt(i)) {
         rowNumbers_[i] = kNullRow;
       } else {
         auto offset = offsets_->valueAt(i);
         VELOX_USER_CHECK_GE(offset, 0, "Offset must be at least 0");
-        // Set rowNumber to kNullRow for out of range offset.
+        // Set rowNumber to kDefaultValueRow for out of range offset.
         if (offset > partition_->numRows()) {
-          rowNumbers_[i] = kNullRow;
+          rowNumbers_[i] = kDefaultValueRow;
+          continue;
+        }
+        // If the offset is 0 then it means always return the current row.
+        if (offset == 0) {
+          rowNumbers_[i] = partitionOffset_ + i;
           continue;
         }
 
@@ -170,8 +194,9 @@ class LeadLagFunction : public exec::WindowFunction {
             rowNumbers_[i] = rowNumberIgnoreNull(
                 rawNulls, offset, partitionOffset_ + i - 1, -1, -1);
           } else {
+            // Set rowNumber to kDefaultValueRow for out of range offset.
             auto rowNumber = partitionOffset_ + i - offset;
-            rowNumbers_[i] = rowNumber >= 0 ? rowNumber : kNullRow;
+            rowNumbers_[i] = rowNumber >= 0 ? rowNumber : kDefaultValueRow;
           }
         } else {
           if constexpr (ignoreNulls) {
@@ -182,14 +207,17 @@ class LeadLagFunction : public exec::WindowFunction {
                 partition_->numRows(),
                 1);
           } else {
+            // Set rowNumber to kDefaultValueRow for out of range offset.
             auto rowNumber = partitionOffset_ + i + offset;
-            rowNumbers_[i] = rowNumber <= maxRowNumber ? rowNumber : kNullRow;
+            rowNumbers_[i] =
+                rowNumber <= maxRowNumber ? rowNumber : kDefaultValueRow;
           }
         }
       }
     }
   }
 
+  // This method assumes the input offset > 0
   vector_size_t rowNumberIgnoreNull(
       const uint64_t* rawNulls,
       vector_size_t offset,
@@ -206,20 +234,20 @@ class LeadLagFunction : public exec::WindowFunction {
       }
     }
 
-    return kNullRow;
+    return kDefaultValueRow;
   }
 
   void setDefaultValue(const VectorPtr& result, int32_t resultOffset) {
+    // Default value is not specified, just return.
     if (!constantDefaultValue_ && !defaultValueIndex_) {
       return;
     }
 
     // Copy default values into 'result' for rows with invalid offsets or empty
     // frames.
-
     if (constantDefaultValue_) {
       for (auto i = 0; i < rowNumbers_.size(); ++i) {
-        if (rowNumbers_[i] == kNullRow) {
+        if (rowNumbers_[i] == kDefaultValueRow) {
           result->copy(constantDefaultValue_.get(), resultOffset + i, 0, 1);
         }
       }
@@ -227,7 +255,7 @@ class LeadLagFunction : public exec::WindowFunction {
       std::vector<vector_size_t> defaultValueRowNumbers;
       defaultValueRowNumbers.reserve(rowNumbers_.size());
       for (auto i = 0; i < rowNumbers_.size(); ++i) {
-        if (rowNumbers_[i] == kNullRow) {
+        if (rowNumbers_[i] == kDefaultValueRow) {
           defaultValueRowNumbers.push_back(partitionOffset_ + i);
         }
       }
@@ -268,6 +296,7 @@ class LeadLagFunction : public exec::WindowFunction {
   // Value of the 'offset' if constant.
   std::optional<int64_t> constantOffset_;
   bool isConstantOffsetNull_ = false;
+  bool isConstantOffsetZero_ = false;
 
   // Index of the 'default_value' argument if default value is specified and not
   // constant.
@@ -281,7 +310,7 @@ class LeadLagFunction : public exec::WindowFunction {
   // Reusable vector of offsets if these are not constant.
   FlatVectorPtr<int64_t> offsets_;
 
-  // Reusable vector of default values if these are not cosntant.
+  // Reusable vector of default values if these are not constant.
   VectorPtr defaultValues_;
 
   // Null positions buffer to use for ignoreNulls.
@@ -302,13 +331,14 @@ class LeadLagFunction : public exec::WindowFunction {
 template <>
 void LeadLagFunction<true>::setRowNumbersForConstantOffset(
     vector_size_t offset) {
-  // Figure out how many rows at the start should be NULL.
+  // Figure out how many rows at the start is out of range.
   vector_size_t nullCnt = 0;
   if (offset > partitionOffset_) {
     nullCnt =
         std::min<vector_size_t>(offset - partitionOffset_, rowNumbers_.size());
     if (nullCnt) {
-      std::fill(rowNumbers_.begin(), rowNumbers_.begin() + nullCnt, kNullRow);
+      std::fill(
+          rowNumbers_.begin(), rowNumbers_.begin() + nullCnt, kDefaultValueRow);
     }
   }
 
@@ -330,14 +360,15 @@ void LeadLagFunction<true>::setRowNumbersForConstantOffset(
 template <>
 void LeadLagFunction<false>::setRowNumbersForConstantOffset(
     vector_size_t offset) {
-  // Figure out how many rows at the end should be NULL.
+  // Figure out how many rows at the end is out of range.
   vector_size_t nonNullCnt = std::max<vector_size_t>(
       0,
       std::min<vector_size_t>(
           rowNumbers_.size(),
           partition_->numRows() - partitionOffset_ - offset));
   if (nonNullCnt < rowNumbers_.size()) {
-    std::fill(rowNumbers_.begin() + nonNullCnt, rowNumbers_.end(), kNullRow);
+    std::fill(
+        rowNumbers_.begin() + nonNullCnt, rowNumbers_.end(), kDefaultValueRow);
   }
 
   // Populate sequential values for non-NULL rows.
@@ -393,6 +424,7 @@ void registerLag(const std::string& name) {
   exec::registerWindowFunction(
       name,
       signatures(),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& args,
           const TypePtr& resultType,
@@ -410,6 +442,7 @@ void registerLead(const std::string& name) {
   exec::registerWindowFunction(
       name,
       signatures(),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& args,
           const TypePtr& resultType,
diff --git a/velox/functions/prestosql/window/WindowFunctionsRegistration.cpp b/velox/functions/prestosql/window/WindowFunctionsRegistration.cpp
index 4c7a97beb9130..351f3c6bc92b0 100644
--- a/velox/functions/prestosql/window/WindowFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/window/WindowFunctionsRegistration.cpp
@@ -21,7 +21,7 @@ namespace facebook::velox::window {
 namespace prestosql {
 
 extern void registerCumeDist(const std::string& name);
-extern void registerNtile(const std::string& name);
+extern void registerNtileBigint(const std::string& name);
 extern void registerFirstValue(const std::string& name);
 extern void registerLastValue(const std::string& name);
 extern void registerLag(const std::string& name);
@@ -33,7 +33,7 @@ void registerAllWindowFunctions(const std::string& prefix) {
   functions::window::registerDenseRankBigint(prefix + "dense_rank");
   functions::window::registerPercentRank(prefix + "percent_rank");
   registerCumeDist(prefix + "cume_dist");
-  registerNtile(prefix + "ntile");
+  functions::window::registerNtileBigint(prefix + "ntile");
   functions::window::registerNthValueBigint(prefix + "nth_value");
   registerFirstValue(prefix + "first_value");
   registerLastValue(prefix + "last_value");
diff --git a/velox/functions/prestosql/window/tests/AggregateWindowTest.cpp b/velox/functions/prestosql/window/tests/AggregateWindowTest.cpp
new file mode 100644
index 0000000000000..4e216de1a19c8
--- /dev/null
+++ b/velox/functions/prestosql/window/tests/AggregateWindowTest.cpp
@@ -0,0 +1,426 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/lib/window/tests/WindowTestBase.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::window::test {
+
+namespace {
+
+static const std::vector<std::string> kAggregateFunctions = {
+    std::string("sum(c2)"),
+    std::string("min(c2)"),
+    std::string("max(c2)"),
+    std::string("count(c2)"),
+    std::string("avg(c2)"),
+    std::string("sum(1)")};
+
+// This AggregateWindowTestBase class is used to instantiate parameterized
+// aggregate window function tests. The parameters are (function, over clause).
+// The window function is tested for the over clause and all combinations of
+// frame clauses. Doing so helps to construct input vectors and DuckDB table
+// only once for the (function, over clause) combination over all frame clauses.
+struct AggregateWindowTestParam {
+  const std::string function;
+  const std::string overClause;
+};
+
+class AggregateWindowTest : public WindowTestBase {
+ protected:
+  explicit AggregateWindowTest(const AggregateWindowTestParam& testParam)
+      : function_(testParam.function), overClause_(testParam.overClause) {}
+
+  explicit AggregateWindowTest() : function_(""), overClause_("") {}
+
+  void SetUp() override {
+    WindowTestBase::SetUp();
+    window::prestosql::registerAllWindowFunctions();
+  }
+
+  void testWindowFunction(const std::vector<RowVectorPtr>& vectors) {
+    testWindowFunction(vectors, kFrameClauses);
+  }
+
+  void testWindowFunction(
+      const std::vector<RowVectorPtr>& vectors,
+      const std::vector<std::string>& frameClauses) {
+    WindowTestBase::testWindowFunction(
+        vectors, function_, {overClause_}, frameClauses);
+  }
+
+  const std::string function_;
+  const std::string overClause_;
+};
+
+std::vector<AggregateWindowTestParam> getAggregateTestParams() {
+  std::vector<AggregateWindowTestParam> params;
+  for (auto function : kAggregateFunctions) {
+    for (auto overClause : kOverClauses) {
+      params.push_back({function, overClause});
+    }
+  }
+  return params;
+}
+
+class MultiAggregateWindowTest
+    : public AggregateWindowTest,
+      public testing::WithParamInterface<AggregateWindowTestParam> {
+ public:
+  MultiAggregateWindowTest() : AggregateWindowTest(GetParam()) {}
+};
+
+// Tests function with a dataset with uniform partitions.
+TEST_P(MultiAggregateWindowTest, basic) {
+  testWindowFunction({makeSimpleVector(10)});
+}
+
+// Tests function with a dataset with a single partition but 2 input row
+// vectors.
+TEST_P(MultiAggregateWindowTest, singlePartition) {
+  auto input = {makeSinglePartitionVector(50), makeSinglePartitionVector(40)};
+  testWindowFunction(input);
+}
+
+// Tests function with a dataset where all partitions have a single row.
+TEST_P(MultiAggregateWindowTest, singleRowPartitions) {
+  testWindowFunction({makeSingleRowPartitionsVector(40)});
+}
+
+// Tests function with a randomly generated input dataset.
+TEST_P(MultiAggregateWindowTest, randomInput) {
+  testWindowFunction({makeRandomInputVector(25)});
+}
+
+// Instantiate all the above tests for each combination of aggregate function
+// and over clause.
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    AggregatesTestInstantiation,
+    MultiAggregateWindowTest,
+    testing::ValuesIn(getAggregateTestParams()));
+
+// Test for an aggregate function with strings that needs out of line storage.
+TEST_F(AggregateWindowTest, variableWidthAggregate) {
+  auto size = 10;
+  auto input = {makeRowVector({
+      makeRandomInputVector(BIGINT(), size, 0.2),
+      makeRandomInputVector(SMALLINT(), size, 0.2),
+      makeRandomInputVector(VARCHAR(), size, 0.3),
+      makeRandomInputVector(VARCHAR(), size, 0.3),
+  })};
+
+  WindowTestBase::testWindowFunction(input, "min(c2)", kOverClauses);
+  WindowTestBase::testWindowFunction(
+      input, "max(c2)", kOverClauses, {""}, false);
+}
+
+// Tests function with k RANGE PRECEDING (FOLLOWING) frames.
+TEST_F(AggregateWindowTest, rangeFrames) {
+  auto aggregateFunctions = kAggregateFunctions;
+  aggregateFunctions.push_back("array_agg(c2)");
+  for (const auto& function : aggregateFunctions) {
+    // count function is skipped as DuckDB returns inconsistent results
+    // with Velox for rows with empty frames. Velox expects empty frames to
+    // return 0, but DuckDB returns null.
+    if (function != "count(c2)") {
+      testKRangeFrames(function);
+    }
+  }
+}
+
+TEST_F(AggregateWindowTest, rangeNullsOrder) {
+  auto c0 = makeNullableFlatVector<int64_t>({1, 2, 1, std::nullopt});
+  auto input = makeRowVector({c0});
+
+  std::string overClause = "order by c0 asc nulls last";
+  // This frame corresponds to range between 0 preceding and 0 following
+  // (since c0 is used for both the ORDER BY and range frame column).
+  // So for each row the frame corresponds to all rows with the same value.
+
+  // This test validates that the null value doesn't mix in the range of
+  // adjacent rows.
+  std::string frameClause = "range between c0 preceding and c0 following";
+  auto arr =
+      makeNullableArrayVector<int64_t>({{1, 1}, {2}, {1, 1}, {std::nullopt}});
+  auto expected = makeRowVector({c0, arr});
+
+  WindowTestBase::testWindowFunction(
+      {input}, "array_agg(c0)", overClause, frameClause, expected);
+
+  overClause = "order by c0 asc nulls first";
+  WindowTestBase::testWindowFunction(
+      {input}, "array_agg(c0)", overClause, frameClause, expected);
+
+  overClause = "order by c0 desc nulls last";
+  WindowTestBase::testWindowFunction(
+      {input}, "array_agg(c0)", overClause, frameClause, expected);
+
+  overClause = "order by c0 desc nulls first";
+  WindowTestBase::testWindowFunction(
+      {input}, "array_agg(c0)", overClause, frameClause, expected);
+}
+
+// Test for aggregates that return NULL as the default value for empty frames
+// against DuckDb.
+TEST_F(AggregateWindowTest, nullEmptyResult) {
+  auto input = {makeSinglePartitionVector(50), makeSinglePartitionVector(40)};
+  auto aggregateFunctions = kAggregateFunctions;
+  aggregateFunctions.erase(
+      std::remove(
+          aggregateFunctions.begin(), aggregateFunctions.end(), "count(c2)"),
+      aggregateFunctions.end());
+  for (const auto& function : aggregateFunctions) {
+    WindowTestBase::testWindowFunction(
+        input, function, kOverClauses, kEmptyFrameClauses);
+  }
+}
+
+// Test for count aggregate with empty frames against expectedResult and not
+// DuckDb, since DuckDb returns NULL instead of 0 for such queries.
+TEST_F(AggregateWindowTest, nonNullEmptyResult) {
+  auto c0 = makeFlatVector<int64_t>({-1, -1, -1, -1, -1, -1, 2, 2, 2, 2});
+  auto c1 = makeFlatVector<double>({-1, -2, -3, -4, -5, -6, -7, -8, -9, -10});
+  auto input = makeRowVector({c0, c1});
+
+  auto expected = makeRowVector(
+      {c0, c1, makeFlatVector<int64_t>({0, 0, 0, 1, 2, 3, 0, 0, 0, 1})});
+  std::string overClause = "partition by c0 order by c1 desc";
+  std::string frameClause = "rows between 6 preceding and 3 preceding";
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  expected = makeRowVector({c0, c1, makeConstant<int64_t>(0, c0->size())});
+  frameClause = "rows between 6 following and unbounded following";
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+}
+
+TEST_F(AggregateWindowTest, testDecimal) {
+  auto size = 30;
+  auto testAggregate = [&](const TypePtr& type) {
+    auto input = {makeRowVector({
+        makeRandomInputVector(BIGINT(), size, 0.2),
+        makeRandomInputVector(type, size, 0.2),
+        makeFlatVector<int64_t>(size, [](auto row) { return row % 11 + 1; }),
+        makeFlatVector<int64_t>(size, [](auto row) { return row % 13 + 1; }),
+    })};
+
+    WindowTestBase::testWindowFunction(input, "min(c1)", kOverClauses);
+    WindowTestBase::testWindowFunction(
+        input, "max(c1)", kOverClauses, {""}, false);
+    WindowTestBase::testWindowFunction(
+        input, "sum(c1)", kOverClauses, {""}, false);
+    WindowTestBase::testWindowFunction(
+        input, "count(c1)", kOverClauses, {""}, false);
+  };
+
+  testAggregate(DECIMAL(5, 2));
+  testAggregate(DECIMAL(20, 5));
+}
+
+TEST_F(AggregateWindowTest, integerOverflowRowsFrame) {
+  auto c0 = makeFlatVector<int64_t>({-1, -1, -1, -1, -1, -1, 2, 2, 2, 2});
+  auto c1 = makeFlatVector<double>({-1, -2, -3, -4, -5, -6, -7, -8, -9, -10});
+  // INT32_MAX: 2147483647
+  auto c2 = makeFlatVector<int32_t>(
+      {1,
+       2147483647,
+       2147483646,
+       2147483645,
+       1,
+       10,
+       1,
+       2147483647,
+       2147483646,
+       2147483645});
+  auto c3 = makeFlatVector<int64_t>(
+      {2147483651,
+       1,
+       2147483650,
+       10,
+       2147483648,
+       2147483647,
+       2,
+       2147483646,
+       2147483650,
+       2147483648});
+  auto input = makeRowVector({c0, c1, c2, c3});
+  std::string overClause = "partition by c0 order by c1 desc";
+
+  // Constant following larger than INT32_MAX (2147483647).
+  std::string frameClause = "rows between 0 preceding and 2147483650 following";
+  auto expected = makeRowVector(
+      {c0,
+       c1,
+       c2,
+       c3,
+       makeFlatVector<int64_t>({6, 5, 4, 3, 2, 1, 4, 3, 2, 1})});
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  // Overflow starts happening from middle of the partition.
+  frameClause = "rows between 0 preceding and 2147483645 following";
+  expected = makeRowVector(
+      {c0,
+       c1,
+       c2,
+       c3,
+       makeFlatVector<int64_t>({6, 5, 4, 3, 2, 1, 4, 3, 2, 1})});
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  // Column-specified following (int32).
+  frameClause = "rows between 0 preceding and c2 following";
+  expected = makeRowVector(
+      {c0,
+       c1,
+       c2,
+       c3,
+       makeFlatVector<int64_t>({2, 5, 4, 3, 2, 1, 2, 3, 2, 1})});
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  // Column-specified following (int64).
+  frameClause = "rows between 0 preceding and c3 following";
+  expected = makeRowVector(
+      {c0,
+       c1,
+       c2,
+       c3,
+       makeFlatVector<int64_t>({6, 2, 4, 3, 2, 1, 3, 3, 2, 1})});
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  // Constant preceding larger than INT32_MAX.
+  frameClause = "rows between 2147483650 preceding and 0 following";
+  expected = makeRowVector(
+      {c0,
+       c1,
+       c2,
+       c3,
+       makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 1, 2, 3, 4})});
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  // Column-specified preceding (int32).
+  frameClause = "rows between c2 preceding and 0 following";
+  expected = makeRowVector(
+      {c0,
+       c1,
+       c2,
+       c3,
+       makeFlatVector<int64_t>({1, 2, 3, 4, 2, 6, 1, 2, 3, 4})});
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  // Column-specified preceding (int64).
+  frameClause = "rows between c3 preceding and 0 following";
+  expected = makeRowVector(
+      {c0,
+       c1,
+       c2,
+       c3,
+       makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 1, 2, 3, 4})});
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  // Constant preceding & following both larger than INT32_MAX.
+  frameClause = "rows between 2147483650 preceding and 2147483651 following";
+  expected = makeRowVector(
+      {c0,
+       c1,
+       c2,
+       c3,
+       makeFlatVector<int64_t>({6, 6, 6, 6, 6, 6, 4, 4, 4, 4})});
+  WindowTestBase::testWindowFunction(
+      {input}, "count(c1)", overClause, frameClause, expected);
+
+  // Empty frame with overflowed frame end.
+  input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+      makeConstant<int64_t>(30000000000, 4),
+  });
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+      makeConstant<int64_t>(30000000000, 4),
+      makeNullConstant(TypeKind::BIGINT, 4),
+  });
+  WindowTestBase::testWindowFunction(
+      {input},
+      "sum(c0)",
+      "",
+      "rows between unbounded preceding and 30000000000 preceding",
+      expected);
+  WindowTestBase::testWindowFunction(
+      {input},
+      "sum(c0)",
+      "",
+      "rows between unbounded preceding and c1 preceding",
+      expected);
+
+  // Empty frame with overflowed frame start.
+  WindowTestBase::testWindowFunction(
+      {input},
+      "sum(c0)",
+      "",
+      "rows between 30000000000 following and unbounded following",
+      expected);
+  WindowTestBase::testWindowFunction(
+      {input},
+      "sum(c0)",
+      "",
+      "rows between c1 following and unbounded following",
+      expected);
+}
+
+TEST_F(AggregateWindowTest, zeroRangeFrame) {
+  auto p0 = makeFlatVector<int32_t>({1, 1, 1, 2, 2});
+  auto s0 = makeFlatVector<int32_t>({1, 2, 3, 4, 5});
+
+  auto test = [&](const std::string& frame,
+                  const FlatVectorPtr<int64_t>& expected) {
+    WindowTestBase::testWindowFunction(
+        // Use s0 for both s0 and k range column since offset = 0.
+        {makeRowVector({"p0", "s0", "k"}, {p0, s0, s0})},
+        "sum(p0)",
+        "partition by p0 order by s0",
+        frame,
+        {makeRowVector({p0, s0, s0, expected})});
+  };
+
+  auto expected = makeFlatVector<int64_t>({1, 2, 3, 2, 4});
+  test("range between unbounded preceding and k preceding", expected);
+
+  // Introduce peer rows in partition=1 data as well.
+  s0 = makeFlatVector<int32_t>({1, 1, 3, 4, 5});
+  expected = makeFlatVector<int64_t>({2, 2, 3, 2, 4});
+  test("range between unbounded preceding and k preceding", expected);
+  test("range between unbounded preceding and k following", expected);
+
+  expected = makeFlatVector<int64_t>({2, 2, 1, 2, 2});
+  test("range between k preceding and k preceding", expected);
+  test("range between k preceding and k following", expected);
+  test("range between k following and k following", expected);
+
+  expected = makeFlatVector<int64_t>({3, 3, 1, 4, 2});
+  test("range between k preceding and unbounded following", expected);
+  test("range between k following and unbounded following", expected);
+}
+
+}; // namespace
+}; // namespace facebook::velox::window::test
diff --git a/velox/functions/prestosql/window/tests/CMakeLists.txt b/velox/functions/prestosql/window/tests/CMakeLists.txt
index 7ed42c4f5d537..cf9afa3650406 100644
--- a/velox/functions/prestosql/window/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/window/tests/CMakeLists.txt
@@ -21,8 +21,8 @@ set(CMAKE_WINDOW_TEST_LINK_LIBRARIES
     velox_vector_test_lib
     velox_window
     gflags::gflags
-    gtest
-    gtest_main)
+    GTest::gtest
+    GTest::gtest_main)
 
 set(CMAKE_WINDOW_TEST_MAIN_FILES Main.cpp)
 
@@ -34,8 +34,8 @@ add_test(
   COMMAND velox_windows_rank_test
   WORKING_DIRECTORY .)
 
-target_link_libraries(velox_windows_rank_test
-                      ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
+target_link_libraries(
+  velox_windows_rank_test ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
 
 add_executable(velox_windows_value_test NthValueTest.cpp LeadLagTest.cpp
                                         ${CMAKE_WINDOW_TEST_MAIN_FILES})
@@ -45,10 +45,10 @@ add_test(
   COMMAND velox_windows_value_test
   WORKING_DIRECTORY .)
 
-target_link_libraries(velox_windows_value_test
-                      ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
+target_link_libraries(
+  velox_windows_value_test ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
 
-add_executable(velox_windows_agg_test SimpleAggregatesTest.cpp
+add_executable(velox_windows_agg_test AggregateWindowTest.cpp
                                       ${CMAKE_WINDOW_TEST_MAIN_FILES})
 
 add_test(
@@ -56,16 +56,5 @@ add_test(
   COMMAND velox_windows_agg_test
   WORKING_DIRECTORY .)
 
-target_link_libraries(velox_windows_agg_test
-                      ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
-
-add_executable(velox_windows_util_test WindowFunctionRegTest.cpp
-                                       ${CMAKE_WINDOW_TEST_MAIN_FILES})
-
-add_test(
-  NAME velox_windows_util_test
-  COMMAND velox_windows_util_test
-  WORKING_DIRECTORY .)
-
-target_link_libraries(velox_windows_util_test
-                      ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
+target_link_libraries(
+  velox_windows_agg_test ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
diff --git a/velox/functions/prestosql/window/tests/LeadLagTest.cpp b/velox/functions/prestosql/window/tests/LeadLagTest.cpp
index b48000b52cb39..d733f20d3c5b6 100644
--- a/velox/functions/prestosql/window/tests/LeadLagTest.cpp
+++ b/velox/functions/prestosql/window/tests/LeadLagTest.cpp
@@ -64,6 +64,8 @@ TEST_P(LeadLagTest, offset) {
       // Large offsets.
       makeFlatVector<int64_t>(
           {largeOffset, largeOffset, largeOffset, largeOffset, largeOffset}),
+      // Default values.
+      makeNullableFlatVector<int64_t>({std::nullopt, 99, 99, 99, std::nullopt}),
   });
 
   createDuckDbTable({data});
@@ -114,6 +116,44 @@ TEST_P(LeadLagTest, offset) {
       appendColumn(data, makeNullableFlatVector<int64_t>(expectedWindow));
 
   assertQuery(queryInfo.planNode, expected);
+
+  // Out of range offsets return default value(99 here, constant case), whereas
+  // null offsets return null.
+  queryInfo = buildWindowQuery({data}, fn("c0, c2, 99"), "order by c0", "");
+  if (isLag()) {
+    expectedWindow = {99, 99, 99, std::nullopt, 3};
+  } else {
+    expectedWindow = {2, 4, 99, std::nullopt, 99};
+  }
+  expected =
+      appendColumn(data, makeNullableFlatVector<int64_t>(expectedWindow));
+  assertQuery(queryInfo.planNode, expected);
+
+  // Out of range offsets return default value(null here, constant null case),
+  // whereas null offsets return null.
+  queryInfo =
+      buildWindowQuery({data}, fn("c0, c2, null::bigint"), "order by c0", "");
+  if (isLag()) {
+    expectedWindow = {
+        std::nullopt, std::nullopt, std::nullopt, std::nullopt, 3};
+  } else {
+    expectedWindow = {2, 4, std::nullopt, std::nullopt, std::nullopt};
+  }
+  expected =
+      appendColumn(data, makeNullableFlatVector<int64_t>(expectedWindow));
+  assertQuery(queryInfo.planNode, expected);
+
+  // Out of range offsets return default value(c4 here, nullable offset
+  // variable case), whereas null offsets return null.
+  queryInfo = buildWindowQuery({data}, fn("c0, c2, c4"), "order by c0", "");
+  if (isLag()) {
+    expectedWindow = {std::nullopt, 99, 99, std::nullopt, 3};
+  } else {
+    expectedWindow = {2, 4, 99, std::nullopt, std::nullopt};
+  }
+  expected =
+      appendColumn(data, makeNullableFlatVector<int64_t>(expectedWindow));
+  assertQuery(queryInfo.planNode, expected);
 }
 
 TEST_P(LeadLagTest, ignoreNullsInt64Offset) {
@@ -144,6 +184,35 @@ TEST_P(LeadLagTest, ignoreNullsInt64Offset) {
   assertResults(fn(fmt::format("c0, {} IGNORE NULLS", largeOffset)));
 }
 
+TEST_P(LeadLagTest, zeroOffset) {
+  auto data = makeRowVector({
+      // Values with null.
+      makeNullableFlatVector<int32_t>(
+          {1, std::nullopt, 2, std::nullopt, std::nullopt}),
+      // Values without null.
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+      // Offsets.
+      makeFlatVector<int64_t>({0, 0, 0, 0, 0}),
+  });
+  createDuckDbTable({data});
+
+  auto assertResults = [&](const std::string& functionSql) {
+    auto queryInfo = buildWindowQuery({data}, functionSql, "order by c0", "");
+    SCOPED_TRACE(queryInfo.functionSql);
+    assertQuery(queryInfo.planNode, queryInfo.querySql);
+  };
+
+  assertResults(fn("c0, 0"));
+  assertResults(fn("c0, c2"));
+  assertResults(fn("c0, 0 IGNORE NULLS"));
+  assertResults(fn("c0, c2 IGNORE NULLS"));
+
+  assertResults(fn("c1, 0"));
+  assertResults(fn("c1, c2"));
+  assertResults(fn("c1, 0 IGNORE NULLS"));
+  assertResults(fn("c1, c2 IGNORE NULLS"));
+}
+
 TEST_P(LeadLagTest, defaultValue) {
   auto data = makeRowVector({
       // Values.
@@ -272,15 +341,23 @@ TEST_P(LeadLagTest, largePartitions) {
   queryInfo = buildWindowQuery({data}, fn("c0, c1, c2"), "order by c0", "");
 
   if (isLag()) {
-    expectedWindow = makeFlatVector<int64_t>(data->size(), [](auto row) {
-      auto defaultValue = row < 5 || row % 7 == 0;
-      return defaultValue ? row * 10 : row - (1 + row % 5);
-    });
+    expectedWindow = makeFlatVector<int64_t>(
+        data->size(),
+        // Default values.
+        [](auto row) {
+          auto defaultValue = row < 5;
+          return defaultValue ? row * 10 : row - (1 + row % 5);
+        },
+        nullEvery(7));
   } else {
-    expectedWindow = makeFlatVector<int64_t>(data->size(), [](auto row) {
-      auto defaultValue = row >= 9'997 || row % 7 == 0;
-      return defaultValue ? row * 10 : row + (1 + row % 5);
-    });
+    expectedWindow = makeFlatVector<int64_t>(
+        data->size(),
+        // Default values.
+        [](auto row) {
+          auto defaultValue = row >= 9'997;
+          return defaultValue ? row * 10 : row + (1 + row % 5);
+        },
+        nullEvery(7));
   }
 
   {
@@ -390,12 +467,13 @@ inline const std::vector<std::string> kIgnoreNullsPartitionClauses = {
 
 TEST_F(LeadLagTest, ignoreNulls) {
   auto size = 40;
-  auto input = makeRowVector({
-      makeFlatVector<int32_t>(size, [](auto row) { return row % 5; }),
-      makeFlatVector<int64_t>(
-          size, [](auto row) { return row % 7; }, nullEvery(8)),
-      makeFlatVector<int64_t>(size, [](auto row) { return row % 6 + 1; }),
-  });
+  auto input = makeRowVector(
+      {makeFlatVector<int32_t>(size, [](auto row) { return row % 5; }),
+       makeFlatVector<int64_t>(
+           size, [](auto row) { return row % 7; }, nullEvery(8)),
+       makeFlatVector<int64_t>(size, [](auto row) { return row % 6 + 1; }),
+       // All null values.
+       makeAllNullFlatVector<int64_t>(size)});
   // c1 has null values, so used for the values argument.
   const std::vector<std::string> kFunctionsList = {
       "lead(c1, 2 IGNORE NULLS)",
@@ -406,6 +484,10 @@ TEST_F(LeadLagTest, ignoreNulls) {
       "lag(c1, 2, 5 IGNORE NULLS)",
       "lead(c1, 2, c2 IGNORE NULLS)",
       "lag(c1, 2, c2 IGNORE NULLS)",
+      // All null values with IGNORE NULLS specified return default
+      // value.
+      "lead(c3, 2, 99 IGNORE NULLS)",
+      "lag(c3, 2, 99 IGNORE NULLS)",
   };
 
   bool createTable = true;
diff --git a/velox/functions/prestosql/window/tests/Main.cpp b/velox/functions/prestosql/window/tests/Main.cpp
index 684d28a087971..3b55575663ed0 100644
--- a/velox/functions/prestosql/window/tests/Main.cpp
+++ b/velox/functions/prestosql/window/tests/Main.cpp
@@ -18,6 +18,6 @@
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init(&argc, &argv, false);
   return RUN_ALL_TESTS();
 }
diff --git a/velox/functions/prestosql/window/tests/NthValueTest.cpp b/velox/functions/prestosql/window/tests/NthValueTest.cpp
index 18715361c8fa7..1922f43d57bce 100644
--- a/velox/functions/prestosql/window/tests/NthValueTest.cpp
+++ b/velox/functions/prestosql/window/tests/NthValueTest.cpp
@@ -88,6 +88,8 @@ class NthValueTest : public WindowTestBase {
         makeRandomInputVector(VARBINARY(), size, 0.7),
         makeRandomInputVector(TIMESTAMP(), size, 0.8),
         makeRandomInputVector(DATE(), size, 0.9),
+        makeRandomInputVector(DECIMAL(10, 2), size, 0.1),
+        makeRandomInputVector(DECIMAL(20, 5), size, 0.2),
     });
 
     const std::string overClause =
@@ -335,6 +337,32 @@ TEST_F(NthValueTest, ignoreNulls) {
   }
 }
 
+TEST_F(NthValueTest, frameStartsFromFollowing) {
+  auto input = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt, 2}),
+      makeFlatVector<bool>({false, false, false}),
+      makeFlatVector<int64_t>({1, 2, 3}),
+  });
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int64_t>({1, std::nullopt, 2}),
+       makeFlatVector<bool>({false, false, false}),
+       makeFlatVector<int64_t>({1, 2, 3}),
+       makeNullableFlatVector<int64_t>({2, 2, std::nullopt})});
+
+  WindowTestBase::testWindowFunction(
+      {input},
+      "first_value(c0 IGNORE NULLS)",
+      "partition by c1 order by c2",
+      "rows between 1 following and unbounded following",
+      expected);
+  WindowTestBase::testWindowFunction(
+      {input},
+      "last_value(c0 IGNORE NULLS)",
+      "partition by c1 order by c2",
+      "rows between 1 following and unbounded following",
+      expected);
+}
+
 // These tests are added since DuckDB has issues with
 // CURRENT ROW frames. These tests will be replaced by DuckDB based
 // tests after it is upgraded to v0.8.
@@ -466,5 +494,5 @@ TEST_F(NthValueTest, ignoreNullsCurrentRow) {
       "range between current row and unbounded following");
 }
 
-}; // namespace
-}; // namespace facebook::velox::window::test
+} // namespace
+} // namespace facebook::velox::window::test
diff --git a/velox/functions/prestosql/window/tests/NtileTest.cpp b/velox/functions/prestosql/window/tests/NtileTest.cpp
index c905193213795..61bb014b4edc1 100644
--- a/velox/functions/prestosql/window/tests/NtileTest.cpp
+++ b/velox/functions/prestosql/window/tests/NtileTest.cpp
@@ -100,5 +100,5 @@ TEST_F(NtileTest, errorCases) {
       {columnVector}, "ntile(c0)", overClause, bucketError);
 }
 
-}; // namespace
-}; // namespace facebook::velox::window::test
+} // namespace
+} // namespace facebook::velox::window::test
diff --git a/velox/functions/prestosql/window/tests/RankTest.cpp b/velox/functions/prestosql/window/tests/RankTest.cpp
index c5d957d6eb301..5abbfe6dae4d1 100644
--- a/velox/functions/prestosql/window/tests/RankTest.cpp
+++ b/velox/functions/prestosql/window/tests/RankTest.cpp
@@ -103,5 +103,5 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     RankTest,
     testing::ValuesIn(getRankTestParams()));
 
-}; // namespace
-}; // namespace facebook::velox::window::test
+} // namespace
+} // namespace facebook::velox::window::test
diff --git a/velox/functions/prestosql/window/tests/SimpleAggregatesTest.cpp b/velox/functions/prestosql/window/tests/SimpleAggregatesTest.cpp
deleted file mode 100644
index dac02f60453b1..0000000000000
--- a/velox/functions/prestosql/window/tests/SimpleAggregatesTest.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/functions/lib/window/tests/WindowTestBase.h"
-#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
-
-using namespace facebook::velox::exec::test;
-
-namespace facebook::velox::window::test {
-
-namespace {
-
-static const std::vector<std::string> kAggregateFunctions = {
-    std::string("sum(c2)"),
-    std::string("min(c2)"),
-    std::string("max(c2)"),
-    std::string("count(c2)"),
-    std::string("avg(c2)"),
-    std::string("sum(1)")};
-
-// This AggregateWindowTestBase class is used to instantiate parameterized
-// aggregate window function tests. The parameters are (function, over clause).
-// The window function is tested for the over clause and all combinations of
-// frame clauses. Doing so helps to construct input vectors and DuckDB table
-// only once for the (function, over clause) combination over all frame clauses.
-struct AggregateWindowTestParam {
-  const std::string function;
-  const std::string overClause;
-};
-
-class AggregateWindowTestBase : public WindowTestBase {
- protected:
-  explicit AggregateWindowTestBase(const AggregateWindowTestParam& testParam)
-      : function_(testParam.function), overClause_(testParam.overClause) {}
-
-  void SetUp() override {
-    WindowTestBase::SetUp();
-    window::prestosql::registerAllWindowFunctions();
-  }
-
-  void testWindowFunction(const std::vector<RowVectorPtr>& vectors) {
-    testWindowFunction(vectors, kFrameClauses);
-  }
-
-  void testWindowFunction(
-      const std::vector<RowVectorPtr>& vectors,
-      const std::vector<std::string>& frameClauses) {
-    WindowTestBase::testWindowFunction(
-        vectors, function_, {overClause_}, frameClauses);
-  }
-
-  const std::string function_;
-  const std::string overClause_;
-};
-
-std::vector<AggregateWindowTestParam> getAggregateTestParams() {
-  std::vector<AggregateWindowTestParam> params;
-  for (auto function : kAggregateFunctions) {
-    for (auto overClause : kOverClauses) {
-      params.push_back({function, overClause});
-    }
-  }
-  return params;
-}
-
-class SimpleAggregatesTest
-    : public AggregateWindowTestBase,
-      public testing::WithParamInterface<AggregateWindowTestParam> {
- public:
-  SimpleAggregatesTest() : AggregateWindowTestBase(GetParam()) {}
-};
-
-// Tests function with a dataset with uniform partitions.
-TEST_P(SimpleAggregatesTest, basic) {
-  testWindowFunction({makeSimpleVector(10)});
-}
-
-// Tests function with a dataset with a single partition but 2 input row
-// vectors.
-TEST_P(SimpleAggregatesTest, singlePartition) {
-  auto input = {makeSinglePartitionVector(50), makeSinglePartitionVector(40)};
-  testWindowFunction(input);
-  testWindowFunction(input, kEmptyFrameClauses);
-}
-
-// Tests function with a dataset where all partitions have a single row.
-TEST_P(SimpleAggregatesTest, singleRowPartitions) {
-  testWindowFunction({makeSingleRowPartitionsVector(40)});
-}
-
-// Tests function with a randomly generated input dataset.
-TEST_P(SimpleAggregatesTest, randomInput) {
-  testWindowFunction({makeRandomInputVector(25)});
-}
-
-// Instantiate all the above tests for each combination of aggregate function
-// and over clause.
-VELOX_INSTANTIATE_TEST_SUITE_P(
-    AggregatesTestInstantiation,
-    SimpleAggregatesTest,
-    testing::ValuesIn(getAggregateTestParams()));
-
-class StringAggregatesTest : public WindowTestBase {};
-
-// Test for an aggregate function with strings that needs out of line storage.
-TEST_F(StringAggregatesTest, nonFixedWidthAggregate) {
-  auto size = 10;
-  auto input = {makeRowVector({
-      makeRandomInputVector(BIGINT(), size, 0.2),
-      makeRandomInputVector(SMALLINT(), size, 0.2),
-      makeRandomInputVector(VARCHAR(), size, 0.3),
-      makeRandomInputVector(VARCHAR(), size, 0.3),
-  })};
-
-  testWindowFunction(input, "min(c2)", kOverClauses);
-  testWindowFunction(input, "max(c2)", kOverClauses);
-}
-
-}; // namespace
-}; // namespace facebook::velox::window::test
diff --git a/velox/functions/prestosql/window/tests/WindowFunctionRegTest.cpp b/velox/functions/prestosql/window/tests/WindowFunctionRegTest.cpp
deleted file mode 100644
index bcdd5a5be877a..0000000000000
--- a/velox/functions/prestosql/window/tests/WindowFunctionRegTest.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-
-#include "velox/exec/WindowFunction.h"
-#include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
-
-namespace facebook::velox::window::test {
-
-class WindowFunctionRegTest : public testing::Test {};
-
-TEST_F(WindowFunctionRegTest, prefix) {
-  // Remove all functions and check for no entries.
-  exec::windowFunctions().clear();
-  EXPECT_EQ(0, exec::windowFunctions().size());
-
-  // Register without prefix and memorize function maps.
-  window::prestosql::registerAllWindowFunctions();
-  const auto windowFuncMapBase = exec::windowFunctions();
-
-  // Remove all functions and check for no entries.
-  exec::windowFunctions().clear();
-  EXPECT_EQ(0, exec::windowFunctions().size());
-
-  // Register with prefix and check all functions have the prefix.
-  const std::string prefix{"test.abc_schema."};
-  window::prestosql::registerAllWindowFunctions(prefix);
-  auto& windowFuncMap = exec::windowFunctions();
-  for (const auto& entry : windowFuncMap) {
-    EXPECT_EQ(prefix, entry.first.substr(0, prefix.size()));
-    EXPECT_EQ(1, windowFuncMapBase.count(entry.first.substr(prefix.size())));
-  }
-}
-
-} // namespace facebook::velox::window::test
diff --git a/velox/functions/remote/client/CMakeLists.txt b/velox/functions/remote/client/CMakeLists.txt
index c8e442410b27e..56663a29d04b8 100644
--- a/velox/functions/remote/client/CMakeLists.txt
+++ b/velox/functions/remote/client/CMakeLists.txt
@@ -12,15 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_functions_remote_thrift_client ThriftClient.cpp)
-target_link_libraries(velox_functions_remote_thrift_client
-                      PUBLIC velox_remote_function_thrift FBThrift::thriftcpp2)
+velox_add_library(velox_functions_remote_thrift_client ThriftClient.cpp)
+velox_link_libraries(velox_functions_remote_thrift_client
+                     PUBLIC remote_function_thrift FBThrift::thriftcpp2)
 
-add_library(velox_functions_remote Remote.cpp)
-target_link_libraries(
+velox_add_library(velox_functions_remote Remote.cpp)
+velox_link_libraries(
   velox_functions_remote
-  PUBLIC velox_expression velox_functions_remote_thrift_client
-         velox_functions_remote_get_serde velox_type_fbhive Folly::folly)
+  PUBLIC velox_expression
+         velox_functions_remote_thrift_client
+         velox_functions_remote_get_serde
+         velox_type_fbhive
+         Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/remote/client/Remote.cpp b/velox/functions/remote/client/Remote.cpp
index 135770db56c94..1f88745aa73ea 100644
--- a/velox/functions/remote/client/Remote.cpp
+++ b/velox/functions/remote/client/Remote.cpp
@@ -70,16 +70,6 @@ class RemoteFunction : public exec::VectorFunction {
     }
   }
 
-  // TODO: The values for these flags shold be obtained from the
-  // VectorFunctionMetadata object passed by clients.
-  bool isDeterministic() const override {
-    return true;
-  }
-
-  bool isDefaultNullBehavior() const override {
-    return true;
-  }
-
  private:
   void applyRemote(
       const SelectivityVector& rows,
diff --git a/velox/functions/remote/client/tests/CMakeLists.txt b/velox/functions/remote/client/tests/CMakeLists.txt
index 0ea7d01fc0d6e..1659ad9d7e5a3 100644
--- a/velox/functions/remote/client/tests/CMakeLists.txt
+++ b/velox/functions/remote/client/tests/CMakeLists.txt
@@ -18,12 +18,12 @@ add_test(velox_functions_remote_client_test velox_functions_remote_client_test)
 
 target_link_libraries(
   velox_functions_remote_client_test
-  velox_remote_function_thrift
+  remote_function_thrift
   velox_functions_remote_server
   velox_functions_remote
   velox_function_registry
   velox_functions_test_lib
   velox_exec_test_lib
-  gmock
-  gtest
-  gtest_main)
+  GTest::gmock
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/functions/remote/client/tests/RemoteFunctionTest.cpp b/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
index 38e1b576cb4db..d49e8f8f695a2 100644
--- a/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
+++ b/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
@@ -18,13 +18,13 @@
 #include <folly/init/Init.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-#include <cstdio>
+#include <stdlib.h>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/Registerer.h"
+#include "velox/functions/lib/CheckedArithmetic.h"
 #include "velox/functions/prestosql/Arithmetic.h"
-#include "velox/functions/prestosql/CheckedArithmetic.h"
 #include "velox/functions/prestosql/StringFunctions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/remote/client/Remote.h"
@@ -125,8 +125,18 @@ class RemoteFunctionTest
 
   // Creates a random temporary file name to use to communicate as a unix domain
   // socket.
-  folly::SocketAddress location_{
-      folly::SocketAddress::makeFromPath(std::tmpnam(nullptr))};
+  folly::SocketAddress location_ = []() {
+    char name[] = "/tmp/socketXXXXXX";
+    int fd = mkstemp(name);
+    if (fd < 0) {
+      throw std::runtime_error("Failed to create temporary file for socket");
+    }
+    close(fd);
+    std::string socketPath(name);
+    // Cleanup existing socket file if it exists.
+    unlink(socketPath.c_str());
+    return folly::SocketAddress::makeFromPath(socketPath);
+  }();
 
   const std::string remotePrefix_{"remote"};
 };
@@ -180,6 +190,6 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/functions/remote/if/CMakeLists.txt b/velox/functions/remote/if/CMakeLists.txt
index 087ecbbd04abb..9818b3cc350da 100644
--- a/velox/functions/remote/if/CMakeLists.txt
+++ b/velox/functions/remote/if/CMakeLists.txt
@@ -14,13 +14,12 @@
 
 include(FBThriftCppLibrary)
 
-add_fbthrift_cpp_library(velox_remote_function_thrift RemoteFunction.thrift
-                         SERVICES RemoteFunctionService)
+add_fbthrift_cpp_library(remote_function_thrift RemoteFunction.thrift SERVICES
+                         RemoteFunctionService)
 
-target_compile_options(velox_remote_function_thrift
+target_compile_options(remote_function_thrift
                        PRIVATE -Wno-deprecated-declarations)
 
-add_library(velox_functions_remote_get_serde GetSerde.cpp)
-target_link_libraries(
-  velox_functions_remote_get_serde PUBLIC velox_remote_function_thrift
-                                          velox_presto_serializer)
+velox_add_library(velox_functions_remote_get_serde GetSerde.cpp)
+velox_link_libraries(velox_functions_remote_get_serde
+                     PUBLIC remote_function_thrift velox_presto_serializer)
diff --git a/velox/functions/remote/if/GetSerde.cpp b/velox/functions/remote/if/GetSerde.cpp
index 84e5108ad8cf2..78f52d614796d 100644
--- a/velox/functions/remote/if/GetSerde.cpp
+++ b/velox/functions/remote/if/GetSerde.cpp
@@ -28,6 +28,6 @@ std::unique_ptr<VectorSerde> getSerde(const remote::PageFormat& format) {
     case remote::PageFormat::SPARK_UNSAFE_ROW:
       return std::make_unique<serializer::spark::UnsafeRowVectorSerde>();
   }
+  VELOX_UNREACHABLE();
 }
-
 } // namespace facebook::velox::functions
diff --git a/velox/functions/remote/if/RemoteFunction.thrift b/velox/functions/remote/if/RemoteFunction.thrift
index c3134ff340018..edac31ef22e86 100644
--- a/velox/functions/remote/if/RemoteFunction.thrift
+++ b/velox/functions/remote/if/RemoteFunction.thrift
@@ -19,7 +19,10 @@ namespace java.swift com.facebook.spark.remotefunctionserver.api
 
 cpp_include "folly/io/IOBuf.h"
 
-typedef binary (cpp2.type = "folly::IOBuf") IOBuf
+include "thrift/annotation/cpp.thrift"
+
+@cpp.Type{name = "folly::IOBuf"}
+typedef binary IOBuf
 
 /// The format used to serialize buffers/payloads.
 enum PageFormat {
diff --git a/velox/functions/remote/server/CMakeLists.txt b/velox/functions/remote/server/CMakeLists.txt
index 297151dddaf3d..ff2afa0fed6a8 100644
--- a/velox/functions/remote/server/CMakeLists.txt
+++ b/velox/functions/remote/server/CMakeLists.txt
@@ -16,10 +16,11 @@ add_library(velox_functions_remote_server RemoteFunctionService.cpp)
 
 target_link_libraries(
   velox_functions_remote_server
-  PUBLIC velox_remote_function_thrift velox_functions_remote_get_serde
+  PUBLIC remote_function_thrift velox_functions_remote_get_serde
          velox_type_fbhive velox_memory)
 
 add_executable(velox_functions_remote_server_main RemoteFunctionServiceMain.cpp)
 
-target_link_libraries(velox_functions_remote_server_main
-                      velox_functions_remote_server velox_functions_prestosql)
+target_link_libraries(
+  velox_functions_remote_server_main velox_functions_remote_server
+  velox_functions_prestosql)
diff --git a/velox/functions/remote/server/RemoteFunctionService.cpp b/velox/functions/remote/server/RemoteFunctionService.cpp
index 5fc9fb713821f..c3310ccb2cd04 100644
--- a/velox/functions/remote/server/RemoteFunctionService.cpp
+++ b/velox/functions/remote/server/RemoteFunctionService.cpp
@@ -94,8 +94,8 @@ void RemoteFunctionServiceHandler::invokeFunction(
   SelectivityVector rows{numRows};
 
   // Expression boilerplate.
-  core::QueryCtx queryCtx;
-  core::ExecCtx execCtx{pool_.get(), &queryCtx};
+  auto queryCtx = core::QueryCtx::create();
+  core::ExecCtx execCtx{pool_.get(), queryCtx.get()};
   exec::ExprSet exprSet{
       getExpressions(
           inputType,
diff --git a/velox/functions/remote/server/RemoteFunctionService.h b/velox/functions/remote/server/RemoteFunctionService.h
index f06a4cc8e3e83..b033eb333b277 100644
--- a/velox/functions/remote/server/RemoteFunctionService.h
+++ b/velox/functions/remote/server/RemoteFunctionService.h
@@ -35,7 +35,8 @@ class RemoteFunctionServiceHandler
       std::unique_ptr<remote::RemoteFunctionRequest> request) override;
 
  private:
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   const std::string functionPrefix_;
 };
 
diff --git a/velox/functions/remote/server/RemoteFunctionServiceMain.cpp b/velox/functions/remote/server/RemoteFunctionServiceMain.cpp
index 85999b7b13c49..c92ab9231d114 100644
--- a/velox/functions/remote/server/RemoteFunctionServiceMain.cpp
+++ b/velox/functions/remote/server/RemoteFunctionServiceMain.cpp
@@ -43,7 +43,7 @@ using namespace ::facebook::velox;
 using ::apache::thrift::ThriftServer;
 
 int main(int argc, char* argv[]) {
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   FLAGS_logtostderr = true;
 
   // Always registers all Presto functions and make them available under a
diff --git a/velox/functions/sparksql/Arithmetic.h b/velox/functions/sparksql/Arithmetic.h
index fa9e101913d45..0b25444e5806b 100644
--- a/velox/functions/sparksql/Arithmetic.h
+++ b/velox/functions/sparksql/Arithmetic.h
@@ -21,13 +21,18 @@
 #include <system_error>
 #include <type_traits>
 
+#include "velox/common/base/Doubles.h"
+#include "velox/common/base/Status.h"
 #include "velox/functions/Macros.h"
+#include "velox/functions/lib/ToHex.h"
 
 namespace facebook::velox::functions::sparksql {
 
 template <typename T>
 struct RemainderFunction {
-  template <typename TInput>
+  template <
+      typename TInput,
+      typename std::enable_if_t<!std::is_floating_point_v<TInput>, int> = 0>
   FOLLY_ALWAYS_INLINE bool
   call(TInput& result, const TInput a, const TInput n) {
     if (UNLIKELY(n == 0)) {
@@ -43,6 +48,29 @@ struct RemainderFunction {
     }
     return true;
   }
+
+  // Specialization for floating point types.
+  template <
+      typename TInput,
+      typename std::enable_if_t<std::is_floating_point_v<TInput>, int> = 0>
+  FOLLY_ALWAYS_INLINE bool
+  call(TInput& result, const TInput a, const TInput n) {
+    if (UNLIKELY(n == 0)) {
+      return false;
+    }
+    // If either the dividend or the divisor is NaN, or if the dividend is
+    // infinity, the result is set to NaN.
+    if (UNLIKELY(std::isnan(a) || std::isnan(n) || std::isinf(a))) {
+      result = std::numeric_limits<TInput>::quiet_NaN();
+    }
+    // If the divisor is infinity, the result is equal to the dividend.
+    else if (UNLIKELY(std::isinf(n))) {
+      result = a;
+    } else {
+      result = std::fmod(a, n);
+    }
+    return true;
+  }
 };
 
 template <typename T>
@@ -122,11 +150,8 @@ inline int64_t safeDoubleToInt64(const double& arg) {
   }
   static const int64_t kMax = std::numeric_limits<int64_t>::max();
   static const int64_t kMin = std::numeric_limits<int64_t>::min();
-  // On some compilers if we cast 'kMax' to a double, we can get a number larger
-  // than 'kMax'. This will allow 'arg' values > 'kMax'. The workaround
-  // here is to use uint64_t to represent ('kMax' + 1), which can be represented
-  // exactly as double. We then check if the difference with 'arg' <= 1.
-  if ((static_cast<uint64_t>(kMax) + 1) - arg <= 1) {
+
+  if (arg >= kMinDoubleAboveInt64Max) {
     return kMax;
   }
   if (arg < kMin) {
@@ -263,6 +288,28 @@ struct Log1pFunction {
   }
 };
 
+template <typename T>
+struct LogarithmFunction {
+  FOLLY_ALWAYS_INLINE bool call(double& result, double a, double b) {
+    if (a <= 0 || b <= 0) {
+      return false;
+    }
+    result = std::log(b) / std::log(a);
+    return true;
+  }
+};
+
+template <typename T>
+struct Expm1Function {
+  FOLLY_ALWAYS_INLINE void call(double& result, double a) {
+    // The std::expm1 is more accurate than the expression std::exp(num) - 1.0
+    // if num is close to zero. This matches Spark's implementation that uses
+    // java.lang.StrictMath.expm1 as below. Ref:
+    // https://docs.oracle.com/javase/8/docs/api/java/lang/StrictMath.html#expm1-double-.
+    result = std::expm1(a);
+  }
+};
+
 template <typename T>
 struct CotFunction {
   FOLLY_ALWAYS_INLINE void call(double& result, double a) {
@@ -270,6 +317,27 @@ struct CotFunction {
   }
 };
 
+template <typename T>
+struct Atan2Function {
+  FOLLY_ALWAYS_INLINE void call(double& result, double y, double x) {
+    // Spark (as of Spark 3.5)'s atan2 SQL function is internally calculated by
+    // Math.atan2(y + 0.0, x + 0.0). We do the same here for compatibility.
+    //
+    // The sign (+/-) for 0.0 matters because it could make atan2 output
+    // different results. For example:
+
+    // * std::atan2(0.0, 0.0) = 0
+    // * std::atan2(0.0, -0.0) = 3.1415926535897931
+    // * std::atan2(-0.0, -0.0) = -3.1415926535897931
+    // * std::atan2(-0.0, 0.0) = 0
+
+    // By doing x + 0.0 or y + 0.0, we make sure all the -0s have been
+    // replaced by 0s before sending to atan2 function. So the function
+    // will always return atan2(0.0, 0.0) = 0 for atan2(+0.0/-0.0, +0.0/-0.0).
+    result = std::atan2(y + 0.0, x + 0.0);
+  }
+};
+
 template <typename T>
 struct Log10Function {
   FOLLY_ALWAYS_INLINE bool call(double& result, double a) {
@@ -280,4 +348,262 @@ struct Log10Function {
     return true;
   }
 };
+
+template <typename T>
+struct IsNanFunction {
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void call(bool& result, TInput a) {
+    result = std::isnan(a);
+  }
+
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void callNullable(bool& result, const TInput* a) {
+    if (a) {
+      call(result, *a);
+    } else {
+      result = false;
+    }
+  }
+};
+
+template <typename T>
+struct ToHexVarbinaryFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varbinary>& input) {
+    ToHexUtil::toHex(input, result);
+  }
+};
+
+template <typename T>
+struct ToHexVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input) {
+    ToHexUtil::toHex(input, result);
+  }
+};
+
+template <typename T>
+struct ToHexBigintFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<int64_t>& input) {
+    ToHexUtil::toHex(input, result);
+  }
+};
+
+namespace detail {
+FOLLY_ALWAYS_INLINE static int8_t fromHex(char c) {
+  if (c >= '0' && c <= '9') {
+    return c - '0';
+  }
+
+  if (c >= 'A' && c <= 'F') {
+    return 10 + c - 'A';
+  }
+
+  if (c >= 'a' && c <= 'f') {
+    return 10 + c - 'a';
+  }
+  return -1;
+}
+} // namespace detail
+
+template <typename T>
+struct WidthBucketFunction {
+  FOLLY_ALWAYS_INLINE bool call(
+      int64_t& result,
+      double value,
+      double bound1,
+      double bound2,
+      int64_t numBuckets) {
+    // NULL would be returned if the input arguments don't follow conditions
+    // list belows:
+    // - `numBuckets` must be greater than zero and be less than Long.MaxValue.
+    // - `value`, `bound1`, and `bound2` cannot be NaN.
+    // - `bound1` bound cannot equal `bound2`.
+    // - `bound1` and `bound2` must be finite.
+    if (shouldReturnNull(value, bound1, bound2, numBuckets)) {
+      return false;
+    }
+
+    result = computeBucketNumber(value, bound1, bound2, numBuckets);
+    return true;
+  }
+
+ private:
+  static FOLLY_ALWAYS_INLINE bool shouldReturnNull(
+      double value,
+      double bound1,
+      double bound2,
+      int64_t numBuckets) {
+    return numBuckets <= 0 ||
+        numBuckets == std::numeric_limits<int64_t>::max() ||
+        std::isnan(value) || bound1 == bound2 || !std::isfinite(bound1) ||
+        !std::isfinite(bound2);
+  }
+
+  static FOLLY_ALWAYS_INLINE int64_t computeBucketNumber(
+      double value,
+      double bound1,
+      double bound2,
+      int64_t numBuckets) {
+    if (bound1 < bound2) {
+      if (value < bound1) {
+        return 0;
+      }
+
+      if (value >= bound2) {
+        return numBuckets + 1;
+      }
+    } else { // bound1 > bound2 case
+      if (value > bound1) {
+        return 0;
+      }
+      if (value <= bound2) {
+        return numBuckets + 1;
+      }
+    }
+    return static_cast<int64_t>(
+               (numBuckets * (value - bound1) / (bound2 - bound1))) +
+        1;
+  }
+};
+
+template <typename T>
+struct UnHexFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varbinary>& result,
+      const arg_type<Varchar>& input) {
+    const auto resultSize = (input.size() + 1) >> 1;
+    result.resize(resultSize);
+    const char* inputBuffer = input.data();
+    char* resultBuffer = result.data();
+
+    int32_t i = 0;
+    if ((input.size() & 0x01) != 0) {
+      const auto v = detail::fromHex(inputBuffer[0]);
+      if (v == -1) {
+        return false;
+      }
+      resultBuffer[0] = v;
+      i += 1;
+    }
+
+    while (i < input.size()) {
+      const auto first = detail::fromHex(inputBuffer[i]);
+      const auto second = detail::fromHex(inputBuffer[i + 1]);
+      if (first == -1 || second == -1) {
+        return false;
+      }
+      resultBuffer[(i + 1) / 2] = (first << 4) | second;
+      i += 2;
+    }
+    return true;
+  }
+};
+
+template <typename T>
+struct RIntFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(double& result, double input) {
+    result = std::rint(input);
+  }
+};
+
+template <typename TExec>
+struct CheckedAddFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(T& result, const T& a, const T& b) {
+    if constexpr (std::is_integral_v<T>) {
+      T res;
+      bool overflow = __builtin_add_overflow(a, b, &res);
+      if (UNLIKELY(overflow)) {
+        if (threadSkipErrorDetails()) {
+          return Status::UserError();
+        }
+        return Status::UserError("Arithmetic overflow: {} + {}", a, b);
+      }
+      result = res;
+    } else {
+      result = a + b;
+    }
+    return Status::OK();
+  }
+};
+
+template <typename TExec>
+struct CheckedSubtractFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(T& result, const T& a, const T& b) {
+    if constexpr (std::is_integral_v<T>) {
+      bool overflow = __builtin_sub_overflow(a, b, &result);
+      if (UNLIKELY(overflow)) {
+        if (threadSkipErrorDetails()) {
+          return Status::UserError();
+        }
+        return Status::UserError("Arithmetic overflow: {} - {}", a, b);
+      }
+    } else {
+      result = a - b;
+    }
+    return Status::OK();
+  }
+};
+
+template <typename TExec>
+struct CheckedMultiplyFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(T& result, const T& a, const T& b) {
+    if constexpr (std::is_integral_v<T>) {
+      bool overflow = __builtin_mul_overflow(a, b, &result);
+      if (UNLIKELY(overflow)) {
+        if (threadSkipErrorDetails()) {
+          return Status::UserError();
+        }
+        return Status::UserError("Arithmetic overflow: {} * {}", a, b);
+      }
+    } else {
+      result = a * b;
+    }
+    return Status::OK();
+  }
+};
+
+template <typename TExec>
+struct CheckedDivideFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(T& result, const T& a, const T& b) {
+    if (b == 0) {
+      if (threadSkipErrorDetails()) {
+        return Status::UserError();
+      }
+      return Status::UserError("division by zero");
+    }
+    if constexpr (std::is_integral_v<T>) {
+      if (UNLIKELY(a == std::numeric_limits<T>::min() && b == -1)) {
+        if (threadSkipErrorDetails()) {
+          return Status::UserError();
+        }
+        return Status::UserError("Arithmetic overflow: {} / {}", a, b);
+      }
+    }
+    result = a / b;
+    return Status::OK();
+  }
+};
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/ArrayFlattenFunction.h b/velox/functions/sparksql/ArrayFlattenFunction.h
new file mode 100644
index 0000000000000..ac369714de259
--- /dev/null
+++ b/velox/functions/sparksql/ArrayFlattenFunction.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// flatten(array(array(E))) → array(E)
+/// Flattens nested array by concatenating the contained arrays.
+template <typename T>
+struct ArrayFlattenFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T)
+
+  // INT_MAX - 15, keep the same limit with spark.
+  static constexpr int32_t kMaxNumberOfElements = 2147483632;
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Array<Generic<T1>>>& out,
+      const arg_type<Array<Array<Generic<T1>>>>& arrays) {
+    int64_t elementCount = 0;
+    for (const auto& array : arrays) {
+      if (array.has_value()) {
+        elementCount += array.value().size();
+      } else {
+        // Return NULL if any of the nested arrays is NULL.
+        return false;
+      }
+    }
+
+    VELOX_USER_CHECK_LE(
+        elementCount,
+        kMaxNumberOfElements,
+        "array flatten result exceeds the max array size limit {}",
+        kMaxNumberOfElements);
+
+    out.reserve(elementCount);
+    for (const auto& array : arrays) {
+      out.add_items(array.value());
+    };
+    return true;
+  }
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/ArrayGetFunction.cpp b/velox/functions/sparksql/ArrayGetFunction.cpp
new file mode 100644
index 0000000000000..c764f4691bd4d
--- /dev/null
+++ b/velox/functions/sparksql/ArrayGetFunction.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/SubscriptUtil.h"
+
+namespace facebook::velox::functions::sparksql {
+
+namespace {
+
+// get(array, index) -> array[index]
+//
+// - allows negative indices for arrays (returns NULL if index < 0).
+// - allows out of bounds accesses for arrays (returns NULL if out of
+//    bounds).
+// - index starts at 0 for arrays.
+class ArrayGetFunction : public SubscriptImpl<
+                             /* allowNegativeIndices */ true,
+                             /* nullOnNegativeIndices */ true,
+                             /* allowOutOfBound */ true,
+                             /* indexStartsAtOne */ false> {
+ public:
+  explicit ArrayGetFunction() : SubscriptImpl(false) {}
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    return {// array(T), integer -> T
+            exec::FunctionSignatureBuilder()
+                .typeVariable("T")
+                .returnType("T")
+                .argumentType("array(T)")
+                .argumentType("integer")
+                .build()};
+  }
+};
+} // namespace
+
+VELOX_DECLARE_VECTOR_FUNCTION(
+    udf_array_get,
+    ArrayGetFunction::signatures(),
+    std::make_unique<ArrayGetFunction>());
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/ArrayInsert.h b/velox/functions/sparksql/ArrayInsert.h
new file mode 100644
index 0000000000000..98c6391b4002f
--- /dev/null
+++ b/velox/functions/sparksql/ArrayInsert.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// array_insert(array(E), pos, E, bool) → array(E)
+/// Places new element into index pos of the input array.
+template <typename T>
+struct ArrayInsert {
+  VELOX_DEFINE_FUNCTION_TYPES(T)
+
+  static constexpr int32_t kMaxNumberOfElements = 10'000;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Array<Generic<T1>>>* /*srcArray*/,
+      const arg_type<int32_t>* /*pos*/,
+      const arg_type<Generic<T1>>* /*item*/,
+      const arg_type<bool>* legacyNegativeIndex) {
+    if (legacyNegativeIndex == nullptr) {
+      VELOX_USER_FAIL("Constant legacyNegativeIndex is expected.");
+    }
+    legacyNegativeIndex_ = *legacyNegativeIndex;
+  }
+
+  FOLLY_ALWAYS_INLINE bool callNullable(
+      out_type<Array<Generic<T1>>>& out,
+      const arg_type<Array<Generic<T1>>>* srcArray,
+      const arg_type<int32_t>* pos,
+      const arg_type<Generic<T1>>* item,
+      const arg_type<bool>* /*legacyNegativeIndex*/) {
+    if (srcArray == nullptr || pos == nullptr) {
+      return false;
+    }
+    VELOX_USER_CHECK_NE(*pos, 0, "Array insert position should not be 0.");
+
+    if (*pos > 0) {
+      // Insert element into input array on the given position. Append nulls
+      // after the original elements if the given position is above the input
+      // array size.
+      const int64_t newArrayLength =
+          std::max((int64_t)srcArray->size() + 1, (int64_t)*pos);
+      VELOX_USER_CHECK_LE(
+          newArrayLength,
+          kMaxNumberOfElements,
+          "The size of result array must be less than or equal to {}.",
+          kMaxNumberOfElements);
+
+      out.reserve(newArrayLength);
+      int32_t posIdx = *pos - 1;
+      int32_t nextIdx = 0;
+      for (int32_t i = 0; i < newArrayLength; i++) {
+        if (i == posIdx) {
+          item ? out.push_back(*item) : out.add_null();
+        } else {
+          // If inserted, i is large than the source index by 1.
+          int32_t srcIdx = i > posIdx ? i - 1 : i;
+          if (srcIdx < srcArray->size()) {
+            out.push_back((*srcArray)[srcIdx]);
+          } else {
+            out.add_null();
+          }
+        }
+      }
+    } else {
+      bool newPosExtendsArrayLeft = -(int64_t)(*pos) > srcArray->size();
+      if (newPosExtendsArrayLeft) {
+        // Insert element at the beginning of the input array followed by nulls
+        // and the original array. If legacyNegativeIndex_ is true, the new
+        // array size is larger by 1.
+        int64_t newArrayLength = -(int64_t)(*pos) + legacyNegativeIndex_;
+        VELOX_USER_CHECK_LE(
+            newArrayLength,
+            kMaxNumberOfElements,
+            "The size of result array must be less than or equal to {}.",
+            kMaxNumberOfElements);
+
+        out.reserve(newArrayLength);
+        item ? out.push_back(*item) : out.add_null();
+        int64_t nullsToFill = newArrayLength - 1 - srcArray->size();
+        while (nullsToFill > 0) {
+          out.add_null();
+          nullsToFill--;
+        }
+        for (const auto& element : *srcArray) {
+          out.push_back(element);
+        }
+      } else {
+        // Insert element into input array on the calculated positive position.
+        // When legacyNegativeIndex_ is true, the inserting position is more to
+        // the left by 1.
+        int64_t posIdx = *pos + srcArray->size() + !legacyNegativeIndex_;
+        int64_t newArrayLength = (int64_t)srcArray->size() + 1;
+        VELOX_USER_CHECK_LE(
+            newArrayLength,
+            kMaxNumberOfElements,
+            "The size of result array must be less than or equal to {}.",
+            kMaxNumberOfElements);
+
+        out.reserve(newArrayLength);
+        int32_t nextIdx = 0;
+        for (const auto& element : *srcArray) {
+          if (nextIdx == posIdx) {
+            item ? out.push_back(*item) : out.add_null();
+            nextIdx++;
+          }
+          out.push_back(element);
+          nextIdx++;
+        }
+        if (nextIdx < newArrayLength) {
+          item ? out.push_back(*item) : out.add_null();
+        }
+      }
+    }
+
+    return true;
+  }
+
+ private:
+  // If true, -1 points to the last but one position. Otherwise, -1 points to
+  // the last position.
+  bool legacyNegativeIndex_;
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Bitwise.cpp b/velox/functions/sparksql/Bitwise.cpp
index 50d3d6f2a4c35..056f3b83c7040 100644
--- a/velox/functions/sparksql/Bitwise.cpp
+++ b/velox/functions/sparksql/Bitwise.cpp
@@ -33,6 +33,22 @@ struct BitwiseOrFunction {
   }
 };
 
+template <typename T>
+struct BitwiseXorFunction {
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void call(TInput& result, TInput a, TInput b) {
+    result = a ^ b;
+  }
+};
+
+template <typename T>
+struct BitwiseNotFunction {
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void call(TInput& result, TInput a) {
+    result = ~a;
+  }
+};
+
 template <typename T>
 struct ShiftLeftFunction {
   template <typename TInput1, typename TInput2>
@@ -99,11 +115,11 @@ struct BitGetFunction {
     VELOX_USER_CHECK_GE(
         pos,
         0,
-        "The value of 'pos' argument must be greater than or equal to zero.")
+        "The value of 'pos' argument must be greater than or equal to zero.");
     VELOX_USER_CHECK_LT(
         pos,
         kMaxBits,
-        "The value of 'pos' argument must not exceed the number of bits in 'x' - 1.")
+        "The value of 'pos' argument must not exceed the number of bits in 'x' - 1.");
     result = (num >> pos) & 1;
   }
 };
@@ -111,6 +127,9 @@ struct BitGetFunction {
 void registerBitwiseFunctions(const std::string& prefix) {
   registerBinaryIntegral<BitwiseAndFunction>({prefix + "bitwise_and"});
   registerBinaryIntegral<BitwiseOrFunction>({prefix + "bitwise_or"});
+  registerBinaryIntegral<BitwiseXorFunction>({prefix + "bitwise_xor"});
+
+  registerUnaryIntegral<BitwiseNotFunction>({prefix + "bitwise_not"});
 
   registerFunction<BitCountFunction, int32_t, bool>({prefix + "bit_count"});
   registerFunction<BitCountFunction, int32_t, int8_t>({prefix + "bit_count"});
diff --git a/velox/functions/sparksql/CMakeLists.txt b/velox/functions/sparksql/CMakeLists.txt
index 265fe8e87082f..1b940591e2a46 100644
--- a/velox/functions/sparksql/CMakeLists.txt
+++ b/velox/functions/sparksql/CMakeLists.txt
@@ -12,37 +12,50 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(
+add_subdirectory(specialforms)
+velox_add_library(
   velox_functions_spark
+  ArrayGetFunction.cpp
   ArraySort.cpp
   Bitwise.cpp
   Comparisons.cpp
+  DecimalArithmetic.cpp
+  DecimalCompare.cpp
   Hash.cpp
   In.cpp
   LeastGreatest.cpp
+  MakeTimestamp.cpp
   Map.cpp
   RegexFunctions.cpp
   Register.cpp
   RegisterArithmetic.cpp
   RegisterCompare.cpp
   Size.cpp
-  SplitFunctions.cpp
-  String.cpp)
+  String.cpp
+  UnscaledValueFunction.cpp)
 
 # GCC 12 has a bug where it does not respect "pragma ignore" directives and ends
 # up failing compilation in an openssl header included by a hash-related
 # function.
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT VELOX_MONO_LIBRARY)
   target_compile_options(velox_functions_spark
                          PRIVATE -Wno-deprecated-declarations)
 endif()
 
-target_link_libraries(
-  velox_functions_spark velox_functions_lib velox_functions_prestosql_impl
-  velox_is_null_functions velox_functions_util Folly::folly)
+velox_link_libraries(
+  velox_functions_spark
+  velox_functions_lib
+  velox_functions_prestosql_impl
+  velox_functions_spark_specialforms
+  velox_is_null_functions
+  velox_functions_util
+  Folly::folly
+  simdjson::simdjson)
 
-set_property(TARGET velox_functions_spark PROPERTY JOB_POOL_COMPILE
-                                                   high_memory_pool)
+if(NOT VELOX_MONO_LIBRARY)
+  set_property(TARGET velox_functions_spark PROPERTY JOB_POOL_COMPILE
+                                                     high_memory_pool)
+endif()
 
 add_subdirectory(window)
 
@@ -53,6 +66,7 @@ endif()
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
   add_subdirectory(coverage)
+  add_subdirectory(fuzzer)
 endif()
 
 if(${VELOX_ENABLE_BENCHMARKS})
diff --git a/velox/functions/sparksql/Comparisons.cpp b/velox/functions/sparksql/Comparisons.cpp
index 154c98a60737f..4fdd368faeb90 100644
--- a/velox/functions/sparksql/Comparisons.cpp
+++ b/velox/functions/sparksql/Comparisons.cpp
@@ -17,6 +17,7 @@
 
 #include "velox/expression/EvalCtx.h"
 #include "velox/expression/Expr.h"
+#include "velox/functions/lib/SIMDComparisonUtil.h"
 #include "velox/functions/sparksql/Comparisons.h"
 #include "velox/type/Type.h"
 
@@ -37,28 +38,44 @@ class ComparisonFunction final : public exec::VectorFunction {
       const TypePtr& outputType,
       exec::EvalCtx& context,
       VectorPtr& result) const override {
+    const Cmp cmp;
     context.ensureWritable(rows, BOOLEAN(), result);
+    result->clearNulls(rows);
+    if constexpr (
+        kind == TypeKind::TINYINT || kind == TypeKind::SMALLINT ||
+        kind == TypeKind::INTEGER || kind == TypeKind::BIGINT) {
+      if ((args[0]->isFlatEncoding() || args[0]->isConstantEncoding()) &&
+          (args[1]->isFlatEncoding() || args[1]->isConstantEncoding()) &&
+          rows.isAllSelected()) {
+        applySimdComparison<T, Cmp>(rows, args, result);
+        return;
+      }
+    }
+    if (shouldApplyAutoSimdComparison<T, T>(rows, args)) {
+      applyAutoSimdComparison<T, T, Cmp>(rows, args, context, result);
+      return;
+    }
+
     auto* flatResult = result->asUnchecked<FlatVector<bool>>();
-    const Cmp cmp;
 
     if (args[0]->isFlatEncoding() && args[1]->isFlatEncoding()) {
       // Fast path for (flat, flat).
-      auto rawA = args[0]->asUnchecked<FlatVector<T>>()->mutableRawValues();
-      auto rawB = args[1]->asUnchecked<FlatVector<T>>()->mutableRawValues();
+      const auto* rawA = args[0]->asUnchecked<FlatVector<T>>()->rawValues();
+      const auto* rawB = args[1]->asUnchecked<FlatVector<T>>()->rawValues();
       rows.applyToSelected(
           [&](vector_size_t i) { flatResult->set(i, cmp(rawA[i], rawB[i])); });
     } else if (args[0]->isConstantEncoding() && args[1]->isFlatEncoding()) {
       // Fast path for (const, flat).
       auto constant = args[0]->asUnchecked<ConstantVector<T>>()->valueAt(0);
-      auto rawValues =
-          args[1]->asUnchecked<FlatVector<T>>()->mutableRawValues();
+      const auto* rawValues =
+          args[1]->asUnchecked<FlatVector<T>>()->rawValues();
       rows.applyToSelected([&](vector_size_t i) {
         flatResult->set(i, cmp(constant, rawValues[i]));
       });
     } else if (args[0]->isFlatEncoding() && args[1]->isConstantEncoding()) {
       // Fast path for (flat, const).
-      auto rawValues =
-          args[0]->asUnchecked<FlatVector<T>>()->mutableRawValues();
+      const auto* rawValues =
+          args[0]->asUnchecked<FlatVector<T>>()->rawValues();
       auto constant = args[1]->asUnchecked<ConstantVector<T>>()->valueAt(0);
       rows.applyToSelected([&](vector_size_t i) {
         flatResult->set(i, cmp(rawValues[i], constant));
@@ -103,7 +120,7 @@ class BoolComparisonFunction final : public exec::VectorFunction {
                       ->template mutableRawValues<uint64_t>();
       rows.applyToSelected([&](vector_size_t i) {
         flatResult->set(
-            i, cmp(bits::isBitSet(rawA, i), bits::isBitSet(rawA, i)));
+            i, cmp(bits::isBitSet(rawA, i), bits::isBitSet(rawB, i)));
       });
     } else if (args[0]->isConstantEncoding() && args[1]->isFlatEncoding()) {
       // Fast path for (const, flat).
@@ -136,7 +153,7 @@ class BoolComparisonFunction final : public exec::VectorFunction {
   }
 };
 
-template <template <typename> class Cmp>
+template <template <typename> class Cmp, typename StdCmp>
 std::shared_ptr<exec::VectorFunction> makeImpl(
     const std::string& functionName,
     const std::vector<exec::VectorFunctionArg>& args) {
@@ -150,17 +167,21 @@ std::shared_ptr<exec::VectorFunction> makeImpl(
     return std::make_shared<ComparisonFunction<      \
         Cmp<TypeTraits<TypeKind::kind>::NativeType>, \
         TypeKind::kind>>();
-    SCALAR_CASE(TINYINT)
-    SCALAR_CASE(SMALLINT)
-    SCALAR_CASE(INTEGER)
-    SCALAR_CASE(BIGINT)
-    SCALAR_CASE(HUGEINT)
     SCALAR_CASE(REAL)
     SCALAR_CASE(DOUBLE)
+    SCALAR_CASE(HUGEINT)
     SCALAR_CASE(VARCHAR)
     SCALAR_CASE(VARBINARY)
     SCALAR_CASE(TIMESTAMP)
 #undef SCALAR_CASE
+#define STD_SCALAR_CASE(kind) \
+  case TypeKind::kind:        \
+    return std::make_shared<ComparisonFunction<StdCmp, TypeKind::kind>>();
+    STD_SCALAR_CASE(TINYINT)
+    STD_SCALAR_CASE(SMALLINT)
+    STD_SCALAR_CASE(INTEGER)
+    STD_SCALAR_CASE(BIGINT)
+#undef STDSCALAR_CASE
     case TypeKind::BOOLEAN:
       return std::make_shared<BoolComparisonFunction<
           Cmp<TypeTraits<TypeKind::BOOLEAN>::NativeType>>>();
@@ -192,8 +213,8 @@ void applyTyped(
   } else {
     // (isnull(a) AND isnull(b)) || (a == b)
     // When DecodedVector::nulls() is null it means there are no nulls.
-    auto* rawNulls0 = decodedLhs->nulls();
-    auto* rawNulls1 = decodedRhs->nulls();
+    auto* rawNulls0 = decodedLhs->nulls(&rows);
+    auto* rawNulls1 = decodedRhs->nulls(&rows);
     rows.applyToSelected([&](vector_size_t i) {
       auto isNull0 = rawNulls0 && bits::isBitNull(rawNulls0, i);
       auto isNull1 = rawNulls1 && bits::isBitNull(rawNulls1, i);
@@ -206,45 +227,8 @@ void applyTyped(
   }
 }
 
-template <>
-void applyTyped<TypeKind::ARRAY>(
-    const SelectivityVector& /* rows */,
-    std::vector<VectorPtr>& /* args */,
-    DecodedVector* /* decodedLhs */,
-    DecodedVector* /* decodedRhs */,
-    exec::EvalCtx& /* context */,
-    FlatVector<bool>* /* flatResult */) {
-  VELOX_NYI("euqaltonullsafe does not support arrays.");
-}
-
-template <>
-void applyTyped<TypeKind::MAP>(
-    const SelectivityVector& /* rows */,
-    std::vector<VectorPtr>& /* args */,
-    DecodedVector* /* decodedLhs */,
-    DecodedVector* /* decodedRhs */,
-    exec::EvalCtx& /* context */,
-    FlatVector<bool>* /* flatResult */) {
-  VELOX_NYI("euqaltonullsafe does not support maps.");
-}
-
-template <>
-void applyTyped<TypeKind::ROW>(
-    const SelectivityVector& /* rows */,
-    std::vector<VectorPtr>& /* args */,
-    DecodedVector* /* decodedLhs */,
-    DecodedVector* /* decodedRhs */,
-    exec::EvalCtx& /* context */,
-    FlatVector<bool>* /* flatResult */) {
-  VELOX_NYI("euqaltonullsafe does not support structs.");
-}
-
 class EqualtoNullSafe final : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -259,7 +243,7 @@ class EqualtoNullSafe final : public exec::VectorFunction {
     auto* flatResult = result->asUnchecked<FlatVector<bool>>();
     flatResult->mutableRawValues<int64_t>();
 
-    VELOX_DYNAMIC_TYPE_DISPATCH(
+    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
         applyTyped,
         args[0]->typeKind(),
         rows,
@@ -277,35 +261,35 @@ std::shared_ptr<exec::VectorFunction> makeEqualTo(
     const std::string& functionName,
     const std::vector<exec::VectorFunctionArg>& args,
     const core::QueryConfig& /*config*/) {
-  return makeImpl<Equal>(functionName, args);
+  return makeImpl<Equal, std::equal_to<>>(functionName, args);
 }
 
 std::shared_ptr<exec::VectorFunction> makeLessThan(
     const std::string& functionName,
     const std::vector<exec::VectorFunctionArg>& args,
     const core::QueryConfig& /*config*/) {
-  return makeImpl<Less>(functionName, args);
+  return makeImpl<Less, std::less<>>(functionName, args);
 }
 
 std::shared_ptr<exec::VectorFunction> makeGreaterThan(
     const std::string& functionName,
     const std::vector<exec::VectorFunctionArg>& args,
     const core::QueryConfig& /*config*/) {
-  return makeImpl<Greater>(functionName, args);
+  return makeImpl<Greater, std::greater<>>(functionName, args);
 }
 
 std::shared_ptr<exec::VectorFunction> makeLessThanOrEqual(
     const std::string& functionName,
     const std::vector<exec::VectorFunctionArg>& args,
     const core::QueryConfig& /*config*/) {
-  return makeImpl<LessOrEqual>(functionName, args);
+  return makeImpl<LessOrEqual, std::less_equal<>>(functionName, args);
 }
 
 std::shared_ptr<exec::VectorFunction> makeGreaterThanOrEqual(
     const std::string& functionName,
     const std::vector<exec::VectorFunctionArg>& args,
     const core::QueryConfig& /*config*/) {
-  return makeImpl<GreaterOrEqual>(functionName, args);
+  return makeImpl<GreaterOrEqual, std::greater_equal<>>(functionName, args);
 }
 
 std::shared_ptr<exec::VectorFunction> makeEqualToNullSafe(
diff --git a/velox/functions/sparksql/Comparisons.h b/velox/functions/sparksql/Comparisons.h
index e714a2ad12ce1..7038b5550e142 100644
--- a/velox/functions/sparksql/Comparisons.h
+++ b/velox/functions/sparksql/Comparisons.h
@@ -15,7 +15,9 @@
  */
 #pragma once
 
+#include "velox/common/base/CompareFlags.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/functions/Macros.h"
 
 namespace facebook::velox::functions::sparksql {
 
@@ -123,12 +125,35 @@ std::shared_ptr<exec::VectorFunction> makeGreaterThanOrEqual(
 
 inline std::vector<std::shared_ptr<exec::FunctionSignature>>
 comparisonSignatures() {
-  return {exec::FunctionSignatureBuilder()
-              .typeVariable("T")
-              .returnType("boolean")
-              .argumentType("T")
-              .argumentType("T")
-              .build()};
+  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
+  signatures.emplace_back(exec::FunctionSignatureBuilder()
+                              .integerVariable("a_precision")
+                              .integerVariable("a_scale")
+                              .returnType("boolean")
+                              .argumentType("DECIMAL(a_precision, a_scale)")
+                              .argumentType("DECIMAL(a_precision, a_scale)")
+                              .build());
+  for (const auto& inputType :
+       {"tinyint",
+        "smallint",
+        "integer",
+        "bigint",
+        "real",
+        "double",
+        "boolean",
+        "varchar",
+        "varbinary",
+        "timestamp",
+        "date",
+        "interval day to second",
+        "interval year to month"}) {
+    signatures.emplace_back(exec::FunctionSignatureBuilder()
+                                .returnType("boolean")
+                                .argumentType(inputType)
+                                .argumentType(inputType)
+                                .build());
+  }
+  return signatures;
 }
 
 template <typename T>
@@ -143,19 +168,46 @@ struct BetweenFunction {
   }
 };
 
-inline std::vector<std::shared_ptr<exec::FunctionSignature>>
-equalNullSafeSignatures() {
-  return {exec::FunctionSignatureBuilder()
-              .typeVariable("T")
-              .returnType("boolean")
-              .argumentType("T")
-              .argumentType("T")
-              .build()};
-}
-
 std::shared_ptr<exec::VectorFunction> makeEqualToNullSafe(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config);
 
+template <typename T>
+struct EqualToFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  // For arbitrary nested complex types.
+  FOLLY_ALWAYS_INLINE void call(
+      bool& out,
+      const arg_type<Generic<T1>>& lhs,
+      const arg_type<Generic<T1>>& rhs) {
+    static constexpr CompareFlags kFlags =
+        CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
+
+    auto result = lhs.compare(rhs, kFlags);
+    out = (result.value() == 0);
+  }
+};
+
+template <typename T>
+struct EqualNullSafeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  // For arbitrary nested complex types.
+  FOLLY_ALWAYS_INLINE void callNullable(
+      bool& out,
+      const arg_type<Generic<T1>>* lhs,
+      const arg_type<Generic<T1>>* rhs) {
+    static constexpr CompareFlags kFlags =
+        CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
+    if (!lhs && !rhs) {
+      out = true;
+    } else if (!lhs || !rhs) {
+      out = false;
+    } else {
+      auto result = lhs->compare(*rhs, kFlags);
+      out = (result.value() == 0);
+    }
+  }
+};
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DateTimeFunctions.h b/velox/functions/sparksql/DateTimeFunctions.h
index 3bd40279c0c9c..07b39ff098962 100644
--- a/velox/functions/sparksql/DateTimeFunctions.h
+++ b/velox/functions/sparksql/DateTimeFunctions.h
@@ -14,9 +14,13 @@
  * limitations under the License.
  */
 
+#pragma once
+
+#include <boost/algorithm/string.hpp>
+
 #include "velox/functions/lib/DateTimeFormatter.h"
 #include "velox/functions/lib/TimeUtils.h"
-#include "velox/functions/prestosql/DateTimeImpl.h"
+#include "velox/type/TimestampConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::functions::sparksql {
@@ -94,6 +98,44 @@ struct WeekFunction : public InitSessionTimezone<T> {
   }
 };
 
+template <typename T>
+struct YearOfWeekFunction : public InitSessionTimezone<T> {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    const auto dateTime = getDateTime(date);
+
+    int isoWeekDay = dateTime.tm_wday == 0 ? 7 : dateTime.tm_wday;
+    // The last few days in December may belong to the next year if they are
+    // in the same week as the next January 1 and this January 1 is a Thursday
+    // or before.
+    if (UNLIKELY(
+            dateTime.tm_mon == 11 && dateTime.tm_mday >= 29 &&
+            dateTime.tm_mday - isoWeekDay >= 31 - 3)) {
+      result = 1900 + dateTime.tm_year + 1;
+      return;
+    }
+    // The first few days in January may belong to the last year if they are
+    // in the same week as January 1 and January 1 is a Friday or after.
+    if (UNLIKELY(
+            dateTime.tm_mon == 0 && dateTime.tm_mday <= 3 &&
+            isoWeekDay - (dateTime.tm_mday - 1) >= 5)) {
+      result = 1900 + dateTime.tm_year - 1;
+      return;
+    }
+    result = 1900 + dateTime.tm_year;
+  }
+};
+
+template <typename T>
+struct UnixDateFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = date;
+  }
+};
+
 template <typename T>
 struct UnixTimestampFunction {
   // unix_timestamp();
@@ -111,6 +153,7 @@ struct UnixTimestampParseFunction {
   // unix_timestamp(input);
   // If format is not specified, assume kDefaultFormat.
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* /*input*/) {
     format_ = buildJodaDateTimeFormatter(kDefaultFormat_);
@@ -120,16 +163,13 @@ struct UnixTimestampParseFunction {
   FOLLY_ALWAYS_INLINE bool call(
       int64_t& result,
       const arg_type<Varchar>& input) {
-    DateTimeResult dateTimeResult;
-    try {
-      dateTimeResult =
-          format_->parse(std::string_view(input.data(), input.size()));
-    } catch (const VeloxUserError&) {
-      // Return null if could not parse.
+    auto dateTimeResult = format_->parse(std::string_view(input));
+    // Return null if could not parse.
+    if (dateTimeResult.hasError()) {
       return false;
     }
-    dateTimeResult.timestamp.toGMT(getTimezoneId(dateTimeResult));
-    result = dateTimeResult.timestamp.getSeconds();
+    (*dateTimeResult).timestamp.toGMT(*getTimeZone(*dateTimeResult));
+    result = (*dateTimeResult).timestamp.getSeconds();
     return true;
   }
 
@@ -137,21 +177,20 @@ struct UnixTimestampParseFunction {
   void setTimezone(const core::QueryConfig& config) {
     auto sessionTzName = config.sessionTimezone();
     if (!sessionTzName.empty()) {
-      sessionTzID_ = util::getTimeZoneID(sessionTzName);
+      sessionTimeZone_ = tz::locateZone(sessionTzName);
     }
   }
 
-  int16_t getTimezoneId(const DateTimeResult& result) {
-    // If timezone was not parsed, fallback to the session timezone. If there's
-    // no session timezone, fallback to 0 (GMT).
-    return result.timezoneId != -1 ? result.timezoneId
-                                   : sessionTzID_.value_or(0);
+  const tz::TimeZone* getTimeZone(const DateTimeResult& result) {
+    // If timezone was not parsed, fallback to the session timezone.
+    return result.timezoneId != -1 ? tz::locateZone(result.timezoneId)
+                                   : sessionTimeZone_;
   }
 
   // Default if format is not specified, as per Spark documentation.
   constexpr static std::string_view kDefaultFormat_{"yyyy-MM-dd HH:mm:ss"};
   std::shared_ptr<DateTimeFormatter> format_;
-  std::optional<int64_t> sessionTzID_;
+  const tz::TimeZone* sessionTimeZone_{tz::locateZone(0)}; // fallback to GMT.
 };
 
 template <typename T>
@@ -162,6 +201,7 @@ struct UnixTimestampParseWithFormatFunction
   // unix_timestamp(input, format):
   // If format is constant, compile it just once per batch.
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* /*input*/,
       const arg_type<Varchar>* format) {
@@ -185,20 +225,23 @@ struct UnixTimestampParseWithFormatFunction
       return false;
     }
 
-    // Format or parsing error returns null.
+    // Format error returns null.
     try {
       if (!isConstFormat_) {
         this->format_ = buildJodaDateTimeFormatter(
             std::string_view(format.data(), format.size()));
       }
-
-      auto dateTimeResult =
-          this->format_->parse(std::string_view(input.data(), input.size()));
-      dateTimeResult.timestamp.toGMT(this->getTimezoneId(dateTimeResult));
-      result = dateTimeResult.timestamp.getSeconds();
     } catch (const VeloxUserError&) {
       return false;
     }
+    auto dateTimeResult =
+        this->format_->parse(std::string_view(input.data(), input.size()));
+    // parsing error returns null
+    if (dateTimeResult.hasError()) {
+      return false;
+    }
+    (*dateTimeResult).timestamp.toGMT(*this->getTimeZone(*dateTimeResult));
+    result = (*dateTimeResult).timestamp.getSeconds();
     return true;
   }
 
@@ -207,6 +250,162 @@ struct UnixTimestampParseWithFormatFunction
   bool invalidFormat_{false};
 };
 
+// Parses unix time in seconds to a formatted string.
+template <typename T>
+struct FromUnixtimeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<int64_t>* /*unixtime*/,
+      const arg_type<Varchar>* format) {
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+    if (format != nullptr) {
+      setFormatter(*format);
+      isConstantTimeFormat_ = true;
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<int64_t>& second,
+      const arg_type<Varchar>& format) {
+    if (!isConstantTimeFormat_) {
+      setFormatter(format);
+    }
+    const Timestamp timestamp{second, 0};
+    result.reserve(maxResultSize_);
+    int32_t resultSize;
+    resultSize = formatter_->format(
+        timestamp, sessionTimeZone_, maxResultSize_, result.data(), true);
+    result.resize(resultSize);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE void setFormatter(const arg_type<Varchar>& format) {
+    formatter_ = buildJodaDateTimeFormatter(
+        std::string_view(format.data(), format.size()));
+    maxResultSize_ = formatter_->maxResultSize(sessionTimeZone_);
+  }
+
+  const tz::TimeZone* sessionTimeZone_{nullptr};
+  std::shared_ptr<DateTimeFormatter> formatter_;
+  uint32_t maxResultSize_;
+  bool isConstantTimeFormat_{false};
+};
+
+template <typename T>
+struct ToUtcTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Varchar>* /*input*/,
+      const arg_type<Varchar>* timezone) {
+    if (timezone) {
+      timeZone_ = tz::locateZone(std::string_view(*timezone), false);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<Timestamp>& timestamp,
+      const arg_type<Varchar>& timezone) {
+    result = timestamp;
+    const auto* fromTimezone = timeZone_ != nullptr
+        ? timeZone_
+        : tz::locateZone(std::string_view(timezone), false);
+    VELOX_USER_CHECK_NOT_NULL(
+        fromTimezone, "Unknown time zone: '{}'", timezone);
+    result.toGMT(*fromTimezone);
+  }
+
+ private:
+  const tz::TimeZone* timeZone_{nullptr};
+};
+
+template <typename T>
+struct FromUtcTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Varchar>* /*input*/,
+      const arg_type<Varchar>* timezone) {
+    if (timezone) {
+      timeZone_ = tz::locateZone(std::string_view(*timezone), false);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<Timestamp>& timestamp,
+      const arg_type<Varchar>& timezone) {
+    result = timestamp;
+    const auto* toTimeZone = timeZone_ != nullptr
+        ? timeZone_
+        : tz::locateZone(std::string_view(timezone), false);
+    VELOX_USER_CHECK_NOT_NULL(toTimeZone, "Unknown time zone: '{}'", timezone);
+    result.toTimezone(*toTimeZone);
+  }
+
+ private:
+  const tz::TimeZone* timeZone_{nullptr};
+};
+
+/// Converts date string to Timestmap type.
+template <typename T>
+struct GetTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Varchar>* /*input*/,
+      const arg_type<Varchar>* format) {
+    auto sessionTimezoneName = config.sessionTimezone();
+    if (!sessionTimezoneName.empty()) {
+      sessionTimeZone_ = tz::locateZone(sessionTimezoneName);
+    }
+    if (format != nullptr) {
+      formatter_ = buildJodaDateTimeFormatter(std::string_view(*format));
+      isConstantTimeFormat_ = true;
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Timestamp>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& format) {
+    if (!isConstantTimeFormat_) {
+      formatter_ = buildJodaDateTimeFormatter(std::string_view(format));
+    }
+    auto dateTimeResult = formatter_->parse(std::string_view(input));
+    // Null as result for parsing error.
+    if (dateTimeResult.hasError()) {
+      return false;
+    }
+    (*dateTimeResult).timestamp.toGMT(*getTimeZone(*dateTimeResult));
+    result = (*dateTimeResult).timestamp;
+    return true;
+  }
+
+ private:
+  const tz::TimeZone* getTimeZone(const DateTimeResult& result) const {
+    // If timezone was not parsed, fallback to the session timezone. If there's
+    // no session timezone, fallback to 0 (GMT).
+    return result.timezoneId != -1 ? tz::locateZone(result.timezoneId)
+                                   : sessionTimeZone_;
+  }
+
+  std::shared_ptr<DateTimeFormatter> formatter_{nullptr};
+  bool isConstantTimeFormat_{false};
+  const tz::TimeZone* sessionTimeZone_{tz::locateZone(0)}; // default to GMT.
+};
+
 template <typename T>
 struct MakeDateFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -216,7 +415,12 @@ struct MakeDateFunction {
       const int32_t year,
       const int32_t month,
       const int32_t day) {
-    auto daysSinceEpoch = util::daysSinceEpochFromDate(year, month, day);
+    Expected<int64_t> expected = util::daysSinceEpochFromDate(year, month, day);
+    if (expected.hasError()) {
+      VELOX_DCHECK(expected.error().isUserError());
+      VELOX_USER_FAIL(expected.error().message());
+    }
+    int64_t daysSinceEpoch = expected.value();
     VELOX_USER_CHECK_EQ(
         daysSinceEpoch,
         (int32_t)daysSinceEpoch,
@@ -252,7 +456,13 @@ struct LastDayFunction {
     int32_t month = getMonth(dateTime);
     int32_t day = getMonth(dateTime);
     auto lastDay = util::getMaxDayOfMonth(year, month);
-    auto daysSinceEpoch = util::daysSinceEpochFromDate(year, month, lastDay);
+    Expected<int64_t> expected =
+        util::daysSinceEpochFromDate(year, month, lastDay);
+    if (expected.hasError()) {
+      VELOX_DCHECK(expected.error().isUserError());
+      VELOX_USER_FAIL(expected.error().message());
+    }
+    int64_t daysSinceEpoch = expected.value();
     VELOX_USER_CHECK_EQ(
         daysSinceEpoch,
         (int32_t)daysSinceEpoch,
@@ -264,15 +474,25 @@ struct LastDayFunction {
   }
 };
 
+template <typename T>
+struct DateFromUnixDateFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(out_type<Date>& result, const int32_t& value) {
+    result = value;
+  }
+};
+
 template <typename T>
 struct DateAddFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  template <typename TInput>
   FOLLY_ALWAYS_INLINE void call(
       out_type<Date>& result,
       const arg_type<Date>& date,
-      const int32_t value) {
-    result = addToDate(date, DateTimeUnit::kDay, value);
+      const TInput& value) {
+    __builtin_add_overflow(date, value, &result);
   }
 };
 
@@ -280,27 +500,17 @@ template <typename T>
 struct DateSubFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  template <typename TInput>
   FOLLY_ALWAYS_INLINE void call(
       out_type<Date>& result,
       const arg_type<Date>& date,
-      const int32_t value) {
-    constexpr int32_t kMin = std::numeric_limits<int32_t>::min();
-    if (value > kMin) {
-      int32_t subValue = 0 - value;
-      result = addToDate(date, DateTimeUnit::kDay, subValue);
-    } else {
-      // If input values is kMin,  0 - value overflows.
-      // Subtract kMin in 2 steps to avoid overflow: -(-(kMin+1)), then -1.
-      int32_t subValue = 0 - (kMin + 1);
-      result = addToDate(date, DateTimeUnit::kDay, subValue);
-      result = addToDate(result, DateTimeUnit::kDay, 1);
-    }
+      const TInput& value) {
+    __builtin_sub_overflow(date, value, &result);
   }
 };
 
 template <typename T>
-struct DayOfWeekFunction : public InitSessionTimezone<T>,
-                           public TimestampWithTimezoneSupport<T> {
+struct DayOfWeekFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   // 1 = Sunday, 2 = Monday, ..., 7 = Saturday
@@ -308,12 +518,6 @@ struct DayOfWeekFunction : public InitSessionTimezone<T>,
     return time.tm_wday + 1;
   }
 
-  FOLLY_ALWAYS_INLINE void call(
-      int32_t& result,
-      const arg_type<Timestamp>& timestamp) {
-    result = getDayOfWeek(getDateTime(timestamp, this->timeZone_));
-  }
-
   FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
     result = getDayOfWeek(getDateTime(date));
   }
@@ -336,4 +540,273 @@ struct DateDiffFunction {
     result = endDate - startDate;
   }
 };
+
+template <typename T>
+struct AddMonthsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void
+  call(out_type<Date>& result, const arg_type<Date>& date, int32_t numMonths) {
+    const auto dateTime = getDateTime(date);
+    const auto year = getYear(dateTime);
+    const auto month = getMonth(dateTime);
+    const auto day = getDay(dateTime);
+
+    // Similar to handling number in base 12. Here, month - 1 makes it in
+    // [0, 11] range.
+    int64_t monthAdded = (int64_t)month - 1 + numMonths;
+    // Used to adjust month/year when monthAdded is not in [0, 11] range.
+    int64_t yearOffset = (monthAdded >= 0 ? monthAdded : monthAdded - 11) / 12;
+    // Adjusts monthAdded to natural month number in [1, 12] range.
+    auto monthResult = static_cast<int32_t>(monthAdded - yearOffset * 12 + 1);
+    // Adjusts year.
+    auto yearResult = year + yearOffset;
+
+    auto lastDayOfMonth = util::getMaxDayOfMonth(yearResult, monthResult);
+    // Adjusts day to valid one.
+    auto dayResult = lastDayOfMonth < day ? lastDayOfMonth : day;
+
+    Expected<int64_t> expected =
+        util::daysSinceEpochFromDate(yearResult, monthResult, dayResult);
+    if (expected.hasError()) {
+      VELOX_DCHECK(expected.error().isUserError());
+      VELOX_USER_FAIL(expected.error().message());
+    }
+    int64_t daysSinceEpoch = expected.value();
+    VELOX_USER_CHECK_EQ(
+        daysSinceEpoch,
+        (int32_t)daysSinceEpoch,
+        "Integer overflow in add_months({}, {})",
+        DATE()->toString(date),
+        numMonths);
+    result = daysSinceEpoch;
+  }
+};
+
+template <typename T>
+struct MonthFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = getMonth(getDateTime(date));
+  }
+};
+
+template <typename T>
+struct QuarterFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = getQuarter(getDateTime(date));
+  }
+};
+
+template <typename T>
+struct DayFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = getDateTime(date).tm_mday;
+  }
+};
+
+template <typename T>
+struct DayOfYearFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = getDayOfYear(getDateTime(date));
+  }
+};
+
+template <typename T>
+struct WeekdayFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // 0 = Monday, 1 = Tuesday, ..., 6 = Sunday
+  FOLLY_ALWAYS_INLINE int32_t getWeekday(const std::tm& time) {
+    return (time.tm_wday + 6) % 7;
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = getWeekday(getDateTime(date));
+  }
+};
+
+template <typename T>
+struct NextDayFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Date>* /*startDate*/,
+      const arg_type<Varchar>* dayOfWeek) {
+    if (dayOfWeek != nullptr) {
+      weekDay_ = getDayOfWeekFromString(*dayOfWeek);
+      if (!weekDay_.has_value()) {
+        invalidFormat_ = true;
+      }
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Date>& result,
+      const arg_type<Date>& startDate,
+      const arg_type<Varchar>& dayOfWeek) {
+    if (invalidFormat_) {
+      return false;
+    }
+    auto weekDay = weekDay_.has_value() ? weekDay_.value()
+                                        : getDayOfWeekFromString(dayOfWeek);
+    if (!weekDay.has_value()) {
+      return false;
+    }
+    auto nextDay = getNextDate(startDate, weekDay.value());
+    if (nextDay != (int32_t)nextDay) {
+      return false;
+    }
+    result = nextDay;
+    return true;
+  }
+
+ private:
+  static FOLLY_ALWAYS_INLINE std::optional<int8_t> getDayOfWeekFromString(
+      const StringView& dayOfWeek) {
+    std::string lowerDayOfWeek =
+        boost::algorithm::to_lower_copy(dayOfWeek.str());
+    auto it = kDayOfWeekNames.find(lowerDayOfWeek);
+    if (it != kDayOfWeekNames.end()) {
+      return it->second;
+    }
+    return std::nullopt;
+  }
+
+  static FOLLY_ALWAYS_INLINE int64_t
+  getNextDate(int64_t startDay, int8_t dayOfWeek) {
+    return startDay + 1 + ((dayOfWeek - 1 - startDay) % 7 + 7) % 7;
+  }
+
+  std::optional<int8_t> weekDay_;
+  bool invalidFormat_{false};
+};
+
+template <typename T>
+struct HourFunction : public InitSessionTimezone<T> {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = getDateTime(timestamp, this->timeZone_).tm_hour;
+  }
+};
+
+template <typename T>
+struct MinuteFunction : public InitSessionTimezone<T> {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = getDateTime(timestamp, this->timeZone_).tm_min;
+  }
+};
+
+template <typename T>
+struct SecondFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = getDateTime(timestamp, nullptr).tm_sec;
+  }
+};
+
+template <typename T>
+struct MakeYMIntervalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(out_type<IntervalYearMonth>& result) {
+    result = 0;
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<IntervalYearMonth>& result,
+      const int32_t year) {
+    VELOX_USER_CHECK(
+        !__builtin_mul_overflow(year, kMonthInYear, &result),
+        "Integer overflow in make_ym_interval({})",
+        year);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<IntervalYearMonth>& result,
+      const int32_t year,
+      const int32_t month) {
+    auto totalMonths = (int64_t)year * kMonthInYear + month;
+    VELOX_USER_CHECK_EQ(
+        totalMonths,
+        (int32_t)totalMonths,
+        "Integer overflow in make_ym_interval({}, {})",
+        year,
+        month);
+    result = totalMonths;
+  }
+};
+
+template <typename T>
+struct UnixSecondsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = timestamp.getSeconds();
+  }
+};
+
+template <typename T>
+struct TimestampToMicrosFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = timestamp.toMicros();
+  }
+};
+
+template <typename TExec>
+struct MicrosToTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void call(out_type<Timestamp>& result, const T& micros) {
+    result = Timestamp::fromMicrosNoError(micros);
+  }
+};
+
+template <typename T>
+struct TimestampToMillisFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = timestamp.toMillis();
+  }
+};
+
+template <typename TExec>
+struct MillisToTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void call(out_type<Timestamp>& result, const T& millis) {
+    result = Timestamp::fromMillisNoError(millis);
+  }
+};
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalArithmetic.cpp b/velox/functions/sparksql/DecimalArithmetic.cpp
new file mode 100644
index 0000000000000..61599bce10ea1
--- /dev/null
+++ b/velox/functions/sparksql/DecimalArithmetic.cpp
@@ -0,0 +1,600 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+struct DecimalAddSubtractBase {
+ protected:
+  void initializeBase(const std::vector<TypePtr>& inputTypes) {
+    auto [aPrecision, aScale] = getDecimalPrecisionScale(*inputTypes[0]);
+    auto [bPrecision, bScale] = getDecimalPrecisionScale(*inputTypes[1]);
+    aScale_ = aScale;
+    bScale_ = bScale;
+    auto [rPrecision, rScale] =
+        computeResultPrecisionScale(aPrecision, aScale_, bPrecision, bScale_);
+    rPrecision_ = rPrecision;
+    rScale_ = rScale;
+    aRescale_ = computeRescaleFactor(aScale_, bScale_);
+    bRescale_ = computeRescaleFactor(bScale_, aScale_);
+  }
+
+  // Adds the values 'a' and 'b' and stores the result in 'r'. To align the
+  // scales of inputs, the value with the smaller scale is rescaled to the
+  // larger scale. 'aRescale' and 'bRescale' are the rescale factors needed to
+  // rescale 'a' and 'b'. 'rPrecision' and 'rScale' are the precision and scale
+  // of the result.
+  template <typename TResult, typename A, typename B>
+  bool applyAdd(TResult& r, A a, B b) {
+    // The overflow flag is set to true if an overflow occurs
+    // during the addition.
+    bool overflow = false;
+    if (rPrecision_ < LongDecimalType::kMaxPrecision) {
+      const int128_t aRescaled =
+          a * velox::DecimalUtil::kPowersOfTen[aRescale_];
+      const int128_t bRescaled =
+          b * velox::DecimalUtil::kPowersOfTen[bRescale_];
+      r = TResult(aRescaled + bRescaled);
+    } else {
+      const uint32_t minLeadingZeros =
+          sparksql::DecimalUtil::minLeadingZeros<A, B>(
+              a, b, aRescale_, bRescale_);
+      if (minLeadingZeros >= 3) {
+        // Fast path for no overflow. If both numbers contain at least 3 leading
+        // zeros, they can be added directly without the risk of overflow.
+        // The reason is if a number contains at least 2 leading zeros, it is
+        // ensured that the number fits in the maximum of decimal, because
+        // '2^126 - 1 < 10^38 - 1'. If both numbers contain at least 3 leading
+        // zeros, we are guaranteed that the result will have at least 2 leading
+        // zeros.
+        int128_t aRescaled = a * velox::DecimalUtil::kPowersOfTen[aRescale_];
+        int128_t bRescaled = b * velox::DecimalUtil::kPowersOfTen[bRescale_];
+        r = reduceScale(
+            TResult(aRescaled + bRescaled),
+            std::max(aScale_, bScale_) - rScale_);
+      } else {
+        // The risk of overflow should be considered. Add whole and fraction
+        // parts separately, and then combine.
+        r = addLarge<TResult, A, B>(a, b, aScale_, bScale_, rScale_, overflow);
+      }
+    }
+    return !overflow &&
+        velox::DecimalUtil::valueInPrecisionRange(r, rPrecision_);
+  }
+
+ private:
+  // Returns the whole and fraction parts of a decimal value.
+  template <typename T>
+  static std::pair<T, T> getWholeAndFraction(T value, uint8_t scale) {
+    const auto scaleFactor = velox::DecimalUtil::kPowersOfTen[scale];
+    const T whole = value / scaleFactor;
+    return {whole, value - whole * scaleFactor};
+  }
+
+  // Increases the scale of input value by 'delta'. Returns the input value if
+  // delta is not positive.
+  static int128_t increaseScale(int128_t in, int16_t delta) {
+    // No need to consider overflow as 'delta == higher scale - input scale', so
+    // the scaled value will not exceed the maximum of long decimal.
+    return delta <= 0 ? in : in * velox::DecimalUtil::kPowersOfTen[delta];
+  }
+
+  // Scales up the whole part to result scale, and combine it with fraction part
+  // to produce a full result for decimal add. Checks whether the result
+  // overflows.
+  template <typename T>
+  static T
+  decimalAddResult(T whole, T fraction, uint8_t resultScale, bool& overflow) {
+    T scaledWhole = sparksql::DecimalUtil::multiply<T>(
+        whole, velox::DecimalUtil::kPowersOfTen[resultScale], overflow);
+    if (FOLLY_UNLIKELY(overflow)) {
+      return 0;
+    }
+    const auto result = scaledWhole + fraction;
+    if constexpr (std::is_same_v<T, int64_t>) {
+      overflow = (result > velox::DecimalUtil::kShortDecimalMax) ||
+          (result < velox::DecimalUtil::kShortDecimalMin);
+    } else {
+      overflow = (result > velox::DecimalUtil::kLongDecimalMax) ||
+          (result < velox::DecimalUtil::kLongDecimalMin);
+    }
+    return result;
+  }
+
+  // Reduces the scale of input value by 'delta'. Returns the input value if
+  // delta is not positive.
+  template <typename T>
+  static T reduceScale(T in, int32_t delta) {
+    if (delta <= 0) {
+      return in;
+    }
+    T result;
+    bool overflow;
+    const auto scaleFactor = velox::DecimalUtil::kPowersOfTen[delta];
+    if constexpr (std::is_same_v<T, int64_t>) {
+      VELOX_DCHECK_LE(
+          scaleFactor,
+          std::numeric_limits<int64_t>::max(),
+          "Scale factor should not exceed the maximum of int64_t.");
+    }
+    DecimalUtil::divideWithRoundUp<T, T, T>(
+        result, in, T(scaleFactor), 0, overflow);
+    VELOX_DCHECK(!overflow);
+    return result;
+  }
+
+  // Adds two non-negative values by adding the whole and fraction parts
+  // separately.
+  template <typename TResult, typename A, typename B>
+  static TResult addLargeNonNegative(
+      A a,
+      B b,
+      uint8_t aScale,
+      uint8_t bScale,
+      uint8_t rScale,
+      bool& overflow) {
+    VELOX_DCHECK_GE(
+        a, 0, "Non-negative value is expected in addLargeNonNegative.");
+    VELOX_DCHECK_GE(
+        b, 0, "Non-negative value is expected in addLargeNonNegative.");
+
+    // Separate whole and fraction parts.
+    const auto [aWhole, aFraction] = getWholeAndFraction<A>(a, aScale);
+    const auto [bWhole, bFraction] = getWholeAndFraction<B>(b, bScale);
+
+    // Adjust fractional parts to higher scale.
+    const auto higherScale = std::max(aScale, bScale);
+    const auto aFractionScaled =
+        increaseScale((int128_t)aFraction, higherScale - aScale);
+    const auto bFractionScaled =
+        increaseScale((int128_t)bFraction, higherScale - bScale);
+
+    int128_t fraction;
+    bool carryToLeft = false;
+    const auto carrier = velox::DecimalUtil::kPowersOfTen[higherScale];
+    if (aFractionScaled >= carrier - bFractionScaled) {
+      fraction = aFractionScaled + bFractionScaled - carrier;
+      carryToLeft = true;
+    } else {
+      fraction = aFractionScaled + bFractionScaled;
+    }
+
+    // Scale up the whole part and scale down the fraction part to combine them.
+    fraction = reduceScale(TResult(fraction), higherScale - rScale);
+    const auto whole = TResult(aWhole) + TResult(bWhole) + TResult(carryToLeft);
+    return decimalAddResult(whole, TResult(fraction), rScale, overflow);
+  }
+
+  // Adds two opposite values by adding the whole and fraction parts separately.
+  template <typename TResult, typename A, typename B>
+  static TResult addLargeOpposite(
+      A a,
+      B b,
+      uint8_t aScale,
+      uint8_t bScale,
+      int32_t rScale,
+      bool& overflow) {
+    VELOX_DCHECK(
+        (a < 0 && b > 0) || (a > 0 && b < 0),
+        "One positve and one negative value are expected in addLargeOpposite.");
+
+    // Separate whole and fraction parts.
+    const auto [aWhole, aFraction] = getWholeAndFraction<A>(a, aScale);
+    const auto [bWhole, bFraction] = getWholeAndFraction<B>(b, bScale);
+
+    // Adjust fractional parts to higher scale.
+    const auto higherScale = std::max(aScale, bScale);
+    const auto aFractionScaled =
+        increaseScale((int128_t)aFraction, higherScale - aScale);
+    const auto bFractionScaled =
+        increaseScale((int128_t)bFraction, higherScale - bScale);
+
+    // No need to consider overflow because two inputs are opposite.
+    int128_t whole = (int128_t)aWhole + (int128_t)bWhole;
+    int128_t fraction = aFractionScaled + bFractionScaled;
+
+    // If the whole and fractional parts have different signs, adjust them to
+    // the same sign.
+    const auto scaleFactor = velox::DecimalUtil::kPowersOfTen[higherScale];
+    if (whole < 0 && fraction > 0) {
+      whole += 1;
+      fraction -= scaleFactor;
+    } else if (whole > 0 && fraction < 0) {
+      whole -= 1;
+      fraction += scaleFactor;
+    }
+
+    // Scale up the whole part and scale down the fraction part to combine them.
+    fraction = reduceScale(TResult(fraction), higherScale - rScale);
+    return decimalAddResult(
+        TResult(whole), TResult(fraction), rScale, overflow);
+  }
+
+  // Add whole and fraction parts separately, and then combine. The overflow
+  // flag will be set to true if an overflow occurs during the addition.
+  template <typename TResult, typename A, typename B>
+  static TResult addLarge(
+      A a,
+      B b,
+      uint8_t aScale,
+      uint8_t bScale,
+      int32_t rScale,
+      bool& overflow) {
+    if (a >= 0 && b >= 0) {
+      // Both non-negative.
+      return addLargeNonNegative<TResult, A, B>(
+          a, b, aScale, bScale, rScale, overflow);
+    } else if (a <= 0 && b <= 0) {
+      // Both non-positive.
+      return TResult(-addLargeNonNegative<TResult, A, B>(
+          A(-a), B(-b), aScale, bScale, rScale, overflow));
+    } else {
+      // One positive and the other negative.
+      return addLargeOpposite<TResult, A, B>(
+          a, b, aScale, bScale, rScale, overflow);
+    }
+  }
+
+  // Computes the result precision and scale for decimal add and subtract
+  // operations following Hive's formulas.
+  // If result is representable with long decimal, the result
+  // scale is the maximum of 'aScale' and 'bScale'. If not, reduces result scale
+  // and caps the result precision at 38.
+  static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
+      uint8_t aPrecision,
+      uint8_t aScale,
+      uint8_t bPrecision,
+      uint8_t bScale) {
+    auto precision = std::max(aPrecision - aScale, bPrecision - bScale) +
+        std::max(aScale, bScale) + 1;
+    auto scale = std::max(aScale, bScale);
+    return sparksql::DecimalUtil::adjustPrecisionScale(precision, scale);
+  }
+
+  static uint8_t computeRescaleFactor(uint8_t fromScale, uint8_t toScale) {
+    return std::max(0, toScale - fromScale);
+  }
+
+  uint8_t aScale_;
+  uint8_t bScale_;
+  uint8_t aRescale_;
+  uint8_t bRescale_;
+  uint8_t rPrecision_;
+  uint8_t rScale_;
+};
+
+template <typename TExec>
+struct DecimalAddFunction : DecimalAddSubtractBase {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    initializeBase(inputTypes);
+  }
+
+  template <typename R, typename A, typename B>
+  bool call(R& out, const A& a, const B& b) {
+    return applyAdd<R, A, B>(out, a, b);
+  }
+};
+
+template <typename TExec>
+struct DecimalSubtractFunction : DecimalAddSubtractBase {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    initializeBase(inputTypes);
+  }
+
+  template <typename R, typename A, typename B>
+  bool call(R& out, const A& a, const B& b) {
+    return applyAdd<R, A, B>(out, a, B(-b));
+  }
+};
+
+template <typename TExec>
+struct DecimalMultiplyFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    auto [aPrecision, aScale] = getDecimalPrecisionScale(*inputTypes[0]);
+    auto [bPrecision, bScale] = getDecimalPrecisionScale(*inputTypes[1]);
+    auto [rPrecision, rScale] = DecimalUtil::adjustPrecisionScale(
+        aPrecision + bPrecision + 1, aScale + bScale);
+    rPrecision_ = rPrecision;
+    deltaScale_ = aScale + bScale - rScale;
+  }
+
+  template <typename R, typename A, typename B>
+  bool call(R& out, const A& a, const B& b) {
+    bool overflow = false;
+    if (rPrecision_ < 38) {
+      out = DecimalUtil::multiply<R>(R(a), R(b), overflow);
+      VELOX_DCHECK(!overflow);
+    } else if (a == 0 && b == 0) {
+      // Handle this separately to avoid divide-by-zero errors.
+      out = R(0);
+    } else {
+      if (deltaScale_ == 0) {
+        // No scale down.
+        // Multiply when the out_precision is 38, and there is no trimming of
+        // the scale i.e the intermediate value is the same as the final value.
+        out = DecimalUtil::multiply<R>(R(a), R(b), overflow);
+      } else {
+        // Scale down.
+        // It's possible that the intermediate value does not fit in 128-bits,
+        // but the final value will (after scaling down).
+        int32_t totalLeadingZeros =
+            bits::countLeadingZeros(DecimalUtil::absValue<A>(a)) +
+            bits::countLeadingZeros(DecimalUtil::absValue<B>(b));
+        // This check is quick, but conservative. In some cases it will
+        // indicate that converting to 256 bits is necessary, when it's not
+        // actually the case.
+        if (UNLIKELY(totalLeadingZeros <= 128)) {
+          // Needs int256.
+          int256_t reslarge =
+              static_cast<int256_t>(a) * static_cast<int256_t>(b);
+          reslarge = reduceScaleBy(reslarge, deltaScale_);
+          out = DecimalUtil::convert<R>(reslarge, overflow);
+        } else {
+          if (LIKELY(deltaScale_ <= 38)) {
+            // The largest value that result can have here is (2^64 - 1) * (2^63
+            // - 1) = 1.70141E+38,which is greater than
+            // DecimalUtil::kLongDecimalMax.
+            R result = DecimalUtil::multiply<R>(R(a), R(b), overflow);
+            VELOX_DCHECK(!overflow);
+            // Since deltaScale is greater than zero, result can now be at most
+            // ((2^64 - 1) * (2^63 - 1)) / 10, which is less than
+            // DecimalUtil::kLongDecimalMax, so there cannot be any overflow.
+            DecimalUtil::divideWithRoundUp<R, R, R>(
+                out,
+                result,
+                R(velox::DecimalUtil::kPowersOfTen[deltaScale_]),
+                0,
+                overflow);
+            VELOX_DCHECK(!overflow);
+          } else {
+            // We are multiplying decimal(38, 38) by decimal(38, 38). The result
+            // should be a
+            // decimal(38, 37), so delta scale = 38 + 38 - 37 = 39. Since we are
+            // not in the 256 bit intermediate value case and we are scaling
+            // down by 39, then we are guaranteed that the result is 0 (even if
+            // we try to round). The largest possible intermediate result is 38
+            // "9"s. If we scale down by 39, the leftmost 9 is now two digits to
+            // the right of the rightmost "visible" one. The reason why we have
+            // to handle this case separately is because a scale multiplier with
+            // a deltaScale 39 does not fit into 128 bit.
+            out = R(0);
+          }
+        }
+      }
+    }
+
+    return !overflow &&
+        velox::DecimalUtil::valueInPrecisionRange(out, rPrecision_);
+  }
+
+ private:
+  static int256_t reduceScaleBy(int256_t in, int32_t reduceBy) {
+    if (reduceBy == 0) {
+      return in;
+    }
+
+    int256_t divisor = velox::DecimalUtil::kPowersOfTen[reduceBy];
+    auto result = in / divisor;
+    auto remainder = in % divisor;
+    // Round up.
+    if (abs(remainder) >= (divisor >> 1)) {
+      result += (in > 0 ? 1 : -1);
+    }
+    return result;
+  }
+
+  uint8_t rPrecision_;
+  // The difference between result scale and the sum of aScale and bScale.
+  int32_t deltaScale_;
+};
+
+template <typename TExec>
+struct DecimalDivideFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    auto [aPrecision, aScale] = getDecimalPrecisionScale(*inputTypes[0]);
+    auto [bPrecision, bScale] = getDecimalPrecisionScale(*inputTypes[1]);
+    auto [rPrecision, rScale] =
+        computeResultPrecisionScale(aPrecision, aScale, bPrecision, bScale);
+    rPrecision_ = rPrecision;
+    aRescale_ = rScale - aScale + bScale;
+  }
+
+  template <typename R, typename A, typename B>
+  bool call(R& out, const A& a, const B& b) {
+    bool overflow = false;
+    DecimalUtil::divideWithRoundUp<R, A, B>(out, a, b, aRescale_, overflow);
+    return !overflow &&
+        velox::DecimalUtil::valueInPrecisionRange(out, rPrecision_);
+  }
+
+ private:
+  static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
+      uint8_t aPrecision,
+      uint8_t aScale,
+      uint8_t bPrecision,
+      uint8_t bScale) {
+    auto scale = std::max(6, aScale + bPrecision + 1);
+    auto precision = aPrecision - aScale + bScale + scale;
+    return DecimalUtil::adjustPrecisionScale(precision, scale);
+  }
+
+  uint8_t aRescale_;
+  uint8_t rPrecision_;
+};
+
+template <template <class> typename Func>
+void registerDecimalBinary(
+    const std::string& name,
+    std::vector<exec::SignatureVariable> constraints) {
+  // (long, long) -> long
+  registerFunction<
+      Func,
+      LongDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({name}, constraints);
+
+  // (short, short) -> short
+  registerFunction<
+      Func,
+      ShortDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({name}, constraints);
+
+  // (short, short) -> long
+  registerFunction<
+      Func,
+      LongDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({name}, constraints);
+
+  // (short, long) -> long
+  registerFunction<
+      Func,
+      LongDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({name}, constraints);
+
+  // (long, short) -> long
+  registerFunction<
+      Func,
+      LongDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({name}, constraints);
+}
+
+std::vector<exec::SignatureVariable> makeConstraints(
+    const std::string& rPrecision,
+    const std::string& rScale) {
+  std::string finalScale = fmt::format(
+      "({}) <= 38 ? ({}) : max(({}) - ({}) + 38, min(({}), 6))",
+      rPrecision,
+      rScale,
+      rScale,
+      rPrecision,
+      rScale);
+  return {
+      exec::SignatureVariable(
+          P3::name(),
+          fmt::format(
+              "min(38, {r_precision})", fmt::arg("r_precision", rPrecision)),
+          exec::ParameterType::kIntegerParameter),
+      exec::SignatureVariable(
+          S3::name(), finalScale, exec::ParameterType::kIntegerParameter)};
+}
+
+template <template <class> typename Func>
+void registerDecimalAddSubtract(const std::string& name) {
+  std::string rPrecision = fmt::format(
+      "max({a_precision} - {a_scale}, {b_precision} - {b_scale}) + max({a_scale}, {b_scale}) + 1",
+      fmt::arg("a_precision", P1::name()),
+      fmt::arg("b_precision", P2::name()),
+      fmt::arg("a_scale", S1::name()),
+      fmt::arg("b_scale", S2::name()));
+  std::string rScale = fmt::format(
+      "max({a_scale}, {b_scale})",
+      fmt::arg("a_scale", S1::name()),
+      fmt::arg("b_scale", S2::name()));
+  registerDecimalBinary<Func>(name, makeConstraints(rPrecision, rScale));
+}
+
+} // namespace
+
+void registerDecimalAdd(const std::string& prefix) {
+  registerDecimalAddSubtract<DecimalAddFunction>(prefix + "add");
+}
+
+void registerDecimalSubtract(const std::string& prefix) {
+  registerDecimalAddSubtract<DecimalSubtractFunction>(prefix + "subtract");
+}
+
+void registerDecimalMultiply(const std::string& prefix) {
+  std::string rPrecision = fmt::format(
+      "{a_precision} + {b_precision} + 1",
+      fmt::arg("a_precision", P1::name()),
+      fmt::arg("b_precision", P2::name()));
+  std::string rScale = fmt::format(
+      "{a_scale} + {b_scale}",
+      fmt::arg("a_scale", S1::name()),
+      fmt::arg("b_scale", S2::name()));
+  registerDecimalBinary<DecimalMultiplyFunction>(
+      prefix + "multiply", makeConstraints(rPrecision, rScale));
+}
+
+std::vector<exec::SignatureVariable> getDivideConstraints() {
+  std::string rPrecision = fmt::format(
+      "{a_precision} - {a_scale} + {b_scale} + max(6, {a_scale} + {b_precision} + 1)",
+      fmt::arg("a_precision", P1::name()),
+      fmt::arg("b_precision", P2::name()),
+      fmt::arg("a_scale", S1::name()),
+      fmt::arg("b_scale", S2::name()));
+  std::string rScale = fmt::format(
+      "max(6, {a_scale} + {b_precision} + 1)",
+      fmt::arg("a_scale", S1::name()),
+      fmt::arg("b_precision", P2::name()));
+  return makeConstraints(rPrecision, rScale);
+}
+
+void registerDecimalDivide(const std::string& prefix) {
+  std::vector<exec::SignatureVariable> constraints = getDivideConstraints();
+  registerDecimalBinary<DecimalDivideFunction>(prefix + "divide", constraints);
+
+  // (short, long) -> short
+  registerFunction<
+      DecimalDivideFunction,
+      ShortDecimal<P3, S3>,
+      ShortDecimal<P1, S1>,
+      LongDecimal<P2, S2>>({prefix + "divide"}, constraints);
+
+  // (long, short) -> short
+  registerFunction<
+      DecimalDivideFunction,
+      ShortDecimal<P3, S3>,
+      LongDecimal<P1, S1>,
+      ShortDecimal<P2, S2>>({prefix + "divide"}, constraints);
+}
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalArithmetic.h b/velox/functions/sparksql/DecimalArithmetic.h
new file mode 100644
index 0000000000000..f1a94ce01a923
--- /dev/null
+++ b/velox/functions/sparksql/DecimalArithmetic.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions::sparksql {
+
+void registerDecimalAdd(const std::string& prefix);
+
+void registerDecimalSubtract(const std::string& prefix);
+
+void registerDecimalMultiply(const std::string& prefix);
+
+void registerDecimalDivide(const std::string& prefix);
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalCompare.cpp b/velox/functions/sparksql/DecimalCompare.cpp
new file mode 100644
index 0000000000000..dc086caefaa9a
--- /dev/null
+++ b/velox/functions/sparksql/DecimalCompare.cpp
@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/DecodedArgs.h"
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/SIMDComparisonUtil.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+// Rescale two inputs as the same scale and compare. Returns 0 when a is equal
+// with b. Returns -1 when a is less than b. Returns 1 when a is greater than b.
+template <typename T>
+int32_t rescaleAndCompare(T a, T b, int32_t deltaScale) {
+  T aScaled = a;
+  T bScaled = b;
+  if (deltaScale < 0) {
+    aScaled = a * velox::DecimalUtil::kPowersOfTen[-deltaScale];
+  } else if (deltaScale > 0) {
+    bScaled = b * velox::DecimalUtil::kPowersOfTen[deltaScale];
+  }
+  if (aScaled == bScaled) {
+    return 0;
+  } else if (aScaled < bScaled) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+
+// Compare two decimals. Rescale one of them if they are of different scales.
+int32_t
+decimalCompare(int128_t a, int128_t b, int8_t deltaScale, bool need256) {
+  if (need256) {
+    return rescaleAndCompare<int256_t>(
+        static_cast<int256_t>(a), static_cast<int256_t>(b), deltaScale);
+  }
+  return rescaleAndCompare<int128_t>(a, b, deltaScale);
+}
+
+struct GreaterThan {
+  inline static bool
+  apply(int128_t a, int128_t b, int8_t deltaScale, bool need256) {
+    return decimalCompare(a, b, deltaScale, need256) > 0;
+  }
+};
+
+struct GreaterThanOrEqual {
+  inline static bool
+  apply(int128_t a, int128_t b, int8_t deltaScale, bool need256) {
+    return decimalCompare(a, b, deltaScale, need256) >= 0;
+  }
+};
+
+struct LessThan {
+  inline static bool
+  apply(int128_t a, int128_t b, int8_t deltaScale, bool need256) {
+    return decimalCompare(a, b, deltaScale, need256) < 0;
+  }
+};
+
+struct LessThanOrEqual {
+  inline static bool
+  apply(int128_t a, int128_t b, int8_t deltaScale, bool need256) {
+    return decimalCompare(a, b, deltaScale, need256) <= 0;
+  }
+};
+
+struct Equal {
+  inline static bool
+  apply(int128_t a, int128_t b, int8_t deltaScale, bool need256) {
+    return decimalCompare(a, b, deltaScale, need256) == 0;
+  }
+};
+
+struct NotEqual {
+  inline static bool
+  apply(int128_t a, int128_t b, int8_t deltaScale, bool need256) {
+    return decimalCompare(a, b, deltaScale, need256) != 0;
+  }
+};
+
+template <typename A, typename B, typename Operation /* Arithmetic operation */>
+class DecimalCompareFunction : public exec::VectorFunction {
+ public:
+  DecimalCompareFunction(
+      uint8_t aPrecision,
+      uint8_t aScale,
+      uint8_t bPrecision,
+      uint8_t bScale)
+      : aPrecision_(aPrecision),
+        bPrecision_(bPrecision),
+        deltaScale_(aScale - bScale),
+        need256_(
+            (deltaScale_ < 0 &&
+             aPrecision_ - deltaScale_ > LongDecimalType::kMaxPrecision) ||
+            (bPrecision_ + deltaScale_ > LongDecimalType::kMaxPrecision)) {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& resultType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    prepareResults(rows, resultType, context, result);
+
+    if (shouldApplyAutoSimdComparison<A, B>(rows, args)) {
+      applyAutoSimdComparison<A, B, Operation, int8_t, bool>(
+          rows, args, context, result, deltaScale_, need256_);
+      return;
+    }
+
+    // Fast path when the first argument is a flat vector.
+    if (args[0]->isFlatEncoding()) {
+      auto rawA = args[0]->asUnchecked<FlatVector<A>>()->mutableRawValues();
+
+      if (args[1]->isConstantEncoding()) {
+        auto constantB = args[1]->asUnchecked<SimpleVector<B>>()->valueAt(0);
+        context.applyToSelectedNoThrow(rows, [&](auto row) {
+          result->asUnchecked<FlatVector<bool>>()->set(
+              row,
+              Operation::apply(
+                  (int128_t)rawA[row],
+                  (int128_t)constantB,
+                  deltaScale_,
+                  need256_));
+        });
+        return;
+      }
+
+      if (args[1]->isFlatEncoding()) {
+        auto rawB = args[1]->asUnchecked<FlatVector<B>>()->mutableRawValues();
+        context.applyToSelectedNoThrow(rows, [&](auto row) {
+          result->asUnchecked<FlatVector<bool>>()->set(
+              row,
+              Operation::apply(
+                  (int128_t)rawA[row],
+                  (int128_t)rawB[row],
+                  deltaScale_,
+                  need256_));
+        });
+        return;
+      }
+    } else {
+      // Fast path when the first argument is encoded but the second is
+      // constant.
+      exec::DecodedArgs decodedArgs(rows, args, context);
+      auto aDecoded = decodedArgs.at(0);
+      auto aDecodedData = aDecoded->data<A>();
+
+      if (args[1]->isConstantEncoding()) {
+        auto constantB = args[1]->asUnchecked<SimpleVector<B>>()->valueAt(0);
+        context.applyToSelectedNoThrow(rows, [&](auto row) {
+          auto value = aDecodedData[aDecoded->index(row)];
+          result->asUnchecked<FlatVector<bool>>()->set(
+              row,
+              Operation::apply(
+                  (int128_t)value, (int128_t)constantB, deltaScale_, need256_));
+        });
+        return;
+      }
+    }
+
+    // Decode the input in all other cases.
+    exec::DecodedArgs decodedArgs(rows, args, context);
+    auto aDecoded = decodedArgs.at(0);
+    auto bDecoded = decodedArgs.at(1);
+
+    auto aDecodedData = aDecoded->data<A>();
+    auto bDecodedData = bDecoded->data<B>();
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      auto aValue = aDecodedData[aDecoded->index(row)];
+      auto bValue = bDecodedData[bDecoded->index(row)];
+      result->asUnchecked<FlatVector<bool>>()->set(
+          row,
+          Operation::apply(
+              (int128_t)aValue, (int128_t)bValue, deltaScale_, need256_));
+    });
+  }
+
+ private:
+  void prepareResults(
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
+    context.ensureWritable(rows, resultType, result);
+    result->clearNulls(rows);
+  }
+
+  const uint8_t aPrecision_;
+  const uint8_t bPrecision_;
+  const int8_t deltaScale_;
+  // If 256 bits are needed after adjusting the scale.
+  const bool need256_;
+};
+
+template <typename Operation>
+std::shared_ptr<exec::VectorFunction> createDecimalCompareFunction(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& /*config*/) {
+  const auto& aType = inputArgs[0].type;
+  const auto& bType = inputArgs[1].type;
+  auto [aPrecision, aScale] = getDecimalPrecisionScale(*aType);
+  auto [bPrecision, bScale] = getDecimalPrecisionScale(*bType);
+  if (aType->isShortDecimal()) {
+    if (bType->isShortDecimal()) {
+      return std::make_shared<
+          DecimalCompareFunction<int64_t, int64_t, Operation>>(
+          aPrecision, aScale, bPrecision, bScale);
+    } else {
+      return std::make_shared<
+          DecimalCompareFunction<int64_t, int128_t, Operation>>(
+          aPrecision, aScale, bPrecision, bScale);
+    }
+  }
+  if (aType->isLongDecimal()) {
+    if (bType->isShortDecimal()) {
+      return std::make_shared<
+          DecimalCompareFunction<int128_t, int64_t, Operation>>(
+          aPrecision, aScale, bPrecision, bScale);
+    } else {
+      return std::make_shared<
+          DecimalCompareFunction<int128_t, int128_t, Operation>>(
+          aPrecision, aScale, bPrecision, bScale);
+    }
+  }
+  VELOX_UNREACHABLE();
+}
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+decimalCompareSignature() {
+  return {exec::FunctionSignatureBuilder()
+              .integerVariable("a_precision")
+              .integerVariable("a_scale")
+              .integerVariable("b_precision")
+              .integerVariable("b_scale")
+              .returnType("boolean")
+              .argumentType("DECIMAL(a_precision, a_scale)")
+              .argumentType("DECIMAL(b_precision, b_scale)")
+              .build()};
+}
+
+} // namespace
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_decimal_gt,
+    decimalCompareSignature(),
+    createDecimalCompareFunction<GreaterThan>);
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_decimal_gte,
+    decimalCompareSignature(),
+    createDecimalCompareFunction<GreaterThanOrEqual>);
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_decimal_lt,
+    decimalCompareSignature(),
+    createDecimalCompareFunction<LessThan>);
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_decimal_lte,
+    decimalCompareSignature(),
+    createDecimalCompareFunction<LessThanOrEqual>);
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_decimal_eq,
+    decimalCompareSignature(),
+    createDecimalCompareFunction<Equal>);
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_decimal_neq,
+    decimalCompareSignature(),
+    createDecimalCompareFunction<NotEqual>);
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalUtil.h b/velox/functions/sparksql/DecimalUtil.h
new file mode 100644
index 0000000000000..fbe5da77809ec
--- /dev/null
+++ b/velox/functions/sparksql/DecimalUtil.h
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <boost/multiprecision/cpp_int.hpp>
+
+#include "velox/type/DecimalUtil.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::functions::sparksql {
+using int256_t = boost::multiprecision::int256_t;
+
+// DecimalUtil holds the utility function for Spark sql.
+class DecimalUtil {
+ public:
+  /// Scale adjustment implementation is based on Hive's one, which is itself
+  /// inspired to SQLServer's one. In particular, when a result precision is
+  /// greater than {LongDecimalType::kMaxPrecision}, the corresponding scale is
+  /// reduced to prevent the integral part of a result from being truncated.
+  ///
+  /// This method is used only when
+  /// `spark.sql.decimalOperations.allowPrecisionLoss` is set to true.
+  inline static std::pair<uint8_t, uint8_t> adjustPrecisionScale(
+      uint8_t rPrecision,
+      uint8_t rScale) {
+    if (rPrecision <= LongDecimalType::kMaxPrecision) {
+      return {rPrecision, rScale};
+    } else {
+      int32_t minScale = std::min(static_cast<int32_t>(rScale), 6);
+      int32_t delta = rPrecision - 38;
+      return {38, std::max(rScale - delta, minScale)};
+    }
+  }
+
+  /// @brief Convert int256 value to int64 or int128, set overflow to true if
+  /// value cannot convert to specific type.
+  /// @return The converted value.
+  template <
+      class T,
+      typename = std::enable_if_t<
+          std::is_same_v<T, int64_t> || std::is_same_v<T, int128_t>>>
+  inline static T convert(int256_t in, bool& overflow) {
+    typedef typename std::
+        conditional<std::is_same_v<T, int64_t>, uint64_t, __uint128_t>::type UT;
+    T result = 0;
+    constexpr auto uintMask =
+        static_cast<int256_t>(std::numeric_limits<UT>::max());
+
+    int256_t inAbs = abs(in);
+    bool isNegative = in < 0;
+
+    UT unsignResult = (inAbs & uintMask).convert_to<UT>();
+    inAbs >>= sizeof(T) * 8;
+
+    if (inAbs > 0) {
+      // We've shifted in by bit of T, so nothing should be left.
+      overflow = true;
+    } else if (unsignResult > std::numeric_limits<T>::max()) {
+      overflow = true;
+    } else {
+      result = static_cast<T>(unsignResult);
+    }
+    return isNegative ? -result : result;
+  }
+
+  // Returns the abs value of input value.
+  template <class T, typename = std::enable_if_t<std::is_same_v<T, int64_t>>>
+  FOLLY_ALWAYS_INLINE static uint64_t absValue(int64_t a) {
+    return a < 0 ? static_cast<uint64_t>(-a) : static_cast<uint64_t>(a);
+  }
+
+  // Returns the abs value of input value.
+  template <class T, typename = std::enable_if_t<std::is_same_v<T, int128_t>>>
+  FOLLY_ALWAYS_INLINE static uint128_t absValue(int128_t a) {
+    return a < 0 ? static_cast<uint128_t>(-a) : static_cast<uint128_t>(a);
+  }
+
+  /// Multiply a and b, set overflow to true if overflow. The caller should
+  /// treat overflow flag first.
+  template <class T, typename = std::enable_if_t<std::is_same_v<T, int64_t>>>
+  FOLLY_ALWAYS_INLINE static int64_t
+  multiply(int64_t a, int64_t b, bool& overflow) {
+    int64_t value;
+    overflow = __builtin_mul_overflow(a, b, &value);
+    return value;
+  }
+
+  /// Multiply a and b, set overflow to true if overflow. The caller should
+  /// treat overflow flag first.
+  template <class T, typename = std::enable_if_t<std::is_same_v<T, int128_t>>>
+  FOLLY_ALWAYS_INLINE static int128_t
+  multiply(int128_t a, int128_t b, bool& overflow) {
+    int128_t value;
+    overflow = __builtin_mul_overflow(a, b, &value);
+    return value;
+  }
+
+  /// Returns the minumum number of leading zeros after scaling up two inputs
+  /// for certain scales. Inputs are decimal values of bigint or hugeint type.
+  template <typename A, typename B>
+  inline static uint32_t
+  minLeadingZeros(A a, B b, uint8_t aRescale, uint8_t bRescale) {
+    auto minLeadingZerosAfterRescale = [](int32_t numLeadingZeros,
+                                          uint8_t scale) {
+      if (scale == 0) {
+        return numLeadingZeros;
+      }
+      /// If a value containing 'numLeadingZeros' leading zeros is scaled up by
+      /// 'scale', the new leading zeros depend on the max bits need to be
+      /// increased.
+      return std::max(
+          numLeadingZeros - kMaxBitsRequiredIncreaseAfterScaling[scale], 0);
+    };
+
+    const int32_t aLeadingZeros = minLeadingZerosAfterRescale(
+        bits::countLeadingZeros(absValue<A>(a)), aRescale);
+    const int32_t bLeadingZeros = minLeadingZerosAfterRescale(
+        bits::countLeadingZeros(absValue<B>(b)), bRescale);
+    return std::min(aLeadingZeros, bLeadingZeros);
+  }
+
+  /// Derives from Arrow BasicDecimal128 Divide.
+  /// https://github.com/apache/arrow/blob/release-12.0.1-rc1/cpp/src/gandiva/precompiled/decimal_ops.cc#L350
+  ///
+  /// Divide a and b, set overflow to true if the result overflows. The caller
+  /// should treat the overflow flag first. Using HALF_UP rounding, the digit 5
+  /// is rounded up.
+  /// Compute the maximum bits required to increase, if it is less than
+  /// result type bits, result type is enough, if not, we should introduce
+  /// int256_t as intermediate type, and then convert to real result type with
+  /// overflow flag.
+  template <typename R, typename A, typename B>
+  inline static R
+  divideWithRoundUp(R& r, A a, B b, uint8_t aRescale, bool& overflow) {
+    if (b == 0) {
+      overflow = true;
+      return R(-1);
+    }
+    int resultSign = 1;
+    R unsignedDividendRescaled(a);
+    int aSign = 1;
+    int bSign = 1;
+    if (a < 0) {
+      resultSign = -1;
+      unsignedDividendRescaled *= -1;
+      aSign = -1;
+    }
+    R unsignedDivisor(b);
+    if (b < 0) {
+      resultSign *= -1;
+      unsignedDivisor *= -1;
+      bSign = -1;
+    }
+    auto bitsRequiredAfterScaling = maxBitsRequiredAfterScaling<A>(a, aRescale);
+    if (bitsRequiredAfterScaling < sizeof(R) * 8) {
+      // Fast-path. The dividend fits in 128-bit after scaling too.
+      overflow = __builtin_mul_overflow(
+          unsignedDividendRescaled,
+          R(velox::DecimalUtil::kPowersOfTen[aRescale]),
+          &unsignedDividendRescaled);
+      VELOX_DCHECK(!overflow);
+      R quotient = unsignedDividendRescaled / unsignedDivisor;
+      R remainder = unsignedDividendRescaled % unsignedDivisor;
+      if (remainder * 2 >= unsignedDivisor) {
+        ++quotient;
+      }
+      r = quotient * resultSign;
+      return remainder;
+    } else {
+      if (aRescale > 38 && bitsRequiredAfterScaling > 255) {
+        overflow = true;
+        return R(-1);
+      }
+      int256_t aLarge = a;
+      int256_t aLargeScaledUp =
+          aLarge * velox::DecimalUtil::kPowersOfTen[aRescale];
+      int256_t bLarge = b;
+      int256_t resultLarge = aLargeScaledUp / bLarge;
+      int256_t remainderLarge = aLargeScaledUp % bLarge;
+      /// Since we are scaling up and then, scaling down, round-up the result
+      /// (+1 for +ve, -1 for -ve), if the remainder is >= 2 * divisor.
+      if (abs(2 * remainderLarge) >= abs(bLarge)) {
+        /// x +ve and y +ve, result is +ve =>   (1 ^ 1)  + 1 =  0 + 1 = +1
+        /// x +ve and y -ve, result is -ve =>  (-1 ^ 1)  + 1 = -2 + 1 = -1
+        /// x +ve and y -ve, result is -ve =>   (1 ^ -1) + 1 = -2 + 1 = -1
+        /// x -ve and y -ve, result is +ve =>  (-1 ^ -1) + 1 =  0 + 1 = +1
+        resultLarge += (aSign ^ bSign) + 1;
+      }
+
+      auto result = convert<R>(resultLarge, overflow);
+      if (overflow) {
+        return R(-1);
+      }
+      r = result;
+      auto remainder = convert<R>(remainderLarge, overflow);
+      return remainder;
+    }
+  }
+
+ private:
+  /// Maintains the max bits that need to be increased for rescaling a value by
+  /// certain scale. The calculation relies on the following formula:
+  /// bitsRequired(x * 10^y) <= bitsRequired(x) + floor(log2(10^y)) + 1.
+  /// This array stores the precomputed 'floor(log2(10^y)) + 1' for y = 0,
+  /// 1, 2, ..., 75, 76.
+  static constexpr int32_t kMaxBitsRequiredIncreaseAfterScaling[] = {
+      0,   4,   7,   10,  14,  17,  20,  24,  27,  30,  34,  37,  40,
+      44,  47,  50,  54,  57,  60,  64,  67,  70,  74,  77,  80,  84,
+      87,  90,  94,  97,  100, 103, 107, 110, 113, 117, 120, 123, 127,
+      130, 133, 137, 140, 143, 147, 150, 153, 157, 160, 163, 167, 170,
+      173, 177, 180, 183, 187, 190, 193, 196, 200, 203, 206, 210, 213,
+      216, 220, 223, 226, 230, 233, 236, 240, 243, 246, 250, 253};
+
+  template <typename A>
+  inline static int32_t maxBitsRequiredAfterScaling(A num, uint8_t aRescale) {
+    auto valueAbs = absValue<A>(num);
+    int32_t numOccupied = sizeof(A) * 8 - bits::countLeadingZeros(valueAbs);
+    return numOccupied + kMaxBitsRequiredIncreaseAfterScaling[aRescale];
+  }
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Hash.cpp b/velox/functions/sparksql/Hash.cpp
index 7167cb638ccf2..480da25596af5 100644
--- a/velox/functions/sparksql/Hash.cpp
+++ b/velox/functions/sparksql/Hash.cpp
@@ -26,21 +26,333 @@ namespace {
 
 const int32_t kDefaultSeed = 42;
 
+// Computes the hash value of input using the hash function in HashClass.
+template <typename HashClass>
+typename HashClass::ReturnType hashOne(
+    int32_t input,
+    typename HashClass::SeedType seed) {
+  return HashClass::hashInt32(input, seed);
+}
+
+template <typename HashClass>
+typename HashClass::ReturnType hashOne(
+    int64_t input,
+    typename HashClass::SeedType seed) {
+  return HashClass::hashInt64(input, seed);
+}
+
+template <typename HashClass>
+typename HashClass::ReturnType hashOne(
+    float input,
+    typename HashClass::SeedType seed) {
+  return HashClass::hashFloat(input, seed);
+}
+
+template <typename HashClass>
+typename HashClass::ReturnType hashOne(
+    double input,
+    typename HashClass::SeedType seed) {
+  return HashClass::hashDouble(input, seed);
+}
+
+template <typename HashClass>
+typename HashClass::ReturnType hashOne(
+    int128_t input,
+    typename HashClass::SeedType seed) {
+  return HashClass::hashLongDecimal(input, seed);
+}
+
+template <typename HashClass>
+typename HashClass::ReturnType hashOne(
+    Timestamp input,
+    typename HashClass::SeedType seed) {
+  return HashClass::hashTimestamp(input, seed);
+}
+
+template <typename HashClass>
+typename HashClass::ReturnType hashOne(
+    StringView input,
+    typename HashClass::SeedType seed) {
+  return HashClass::hashBytes(input, seed);
+}
+
+template <typename HashClass>
+typename HashClass::ReturnType hashOne(
+    UnknownValue /*input*/,
+    typename HashClass::SeedType seed) {
+  return seed;
+}
+
+template <typename HashClass, TypeKind kind>
+class PrimitiveVectorHasher;
+
+template <typename HashClass>
+class ArrayVectorHasher;
+
+template <typename HashClass>
+class MapVectorHasher;
+
+template <typename HashClass>
+class RowVectorHasher;
+
+template <typename HashClass>
+class UnknowTypeVectorHasher;
+
+// Class to compute hashes identical to one produced by Spark.
+// Hashes are computed using the algorithm implemented in HashClass.
+template <typename HashClass>
+class SparkVectorHasher {
+ public:
+  using SeedType = typename HashClass::SeedType;
+  using ReturnType = typename HashClass::ReturnType;
+
+  SparkVectorHasher(DecodedVector& decoded) : decoded_(decoded) {}
+
+  virtual ~SparkVectorHasher() = default;
+
+  // Compute the hash value of input vector at index.
+  ReturnType hashAt(vector_size_t index, SeedType seed) {
+    if (decoded_.isNullAt(index)) {
+      return seed;
+    }
+    return hashNotNullAt(index, seed);
+  }
+
+  // Compute the hash value of input vector at index for non-null values.
+  virtual ReturnType hashNotNullAt(vector_size_t index, SeedType seed) = 0;
+
+ protected:
+  const DecodedVector& decoded_;
+};
+
+template <typename HashClass, TypeKind kind>
+std::shared_ptr<SparkVectorHasher<HashClass>> createPrimitiveVectorHasher(
+    DecodedVector& decoded) {
+  return std::make_shared<PrimitiveVectorHasher<HashClass, kind>>(decoded);
+}
+
+template <typename HashClass>
+std::shared_ptr<SparkVectorHasher<HashClass>> createVectorHasher(
+    DecodedVector& decoded) {
+  switch (decoded.base()->typeKind()) {
+    case TypeKind::ARRAY:
+      return std::make_shared<ArrayVectorHasher<HashClass>>(decoded);
+    case TypeKind::MAP:
+      return std::make_shared<MapVectorHasher<HashClass>>(decoded);
+    case TypeKind::ROW:
+      return std::make_shared<RowVectorHasher<HashClass>>(decoded);
+    case TypeKind::UNKNOWN:
+      return std::make_shared<UnknowTypeVectorHasher<HashClass>>(decoded);
+    default:
+      return VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
+          createPrimitiveVectorHasher,
+          HashClass,
+          decoded.base()->typeKind(),
+          decoded);
+  }
+}
+
+template <typename HashClass, TypeKind kind>
+class PrimitiveVectorHasher : public SparkVectorHasher<HashClass> {
+ public:
+  using SeedType = typename HashClass::SeedType;
+  using ReturnType = typename HashClass::ReturnType;
+
+  PrimitiveVectorHasher(DecodedVector& decoded)
+      : SparkVectorHasher<HashClass>(decoded) {}
+
+  ReturnType hashNotNullAt(vector_size_t index, SeedType seed) override {
+    return hashOne<HashClass>(
+        this->decoded_.template valueAt<typename TypeTraits<kind>::NativeType>(
+            index),
+        seed);
+  }
+};
+
+template <typename HashClass>
+class UnknowTypeVectorHasher : public SparkVectorHasher<HashClass> {
+ public:
+  using SeedType = typename HashClass::SeedType;
+  using ReturnType = typename HashClass::ReturnType;
+
+  explicit UnknowTypeVectorHasher(DecodedVector& decoded)
+      : SparkVectorHasher<HashClass>(decoded) {}
+
+  ReturnType hashNotNullAt(vector_size_t /*index*/, SeedType /*seed*/)
+      override {
+    VELOX_FAIL("hashNotNullAt should not be called for unknown type.");
+  }
+};
+
+template <typename HashClass>
+class ArrayVectorHasher : public SparkVectorHasher<HashClass> {
+ public:
+  using SeedType = typename HashClass::SeedType;
+  using ReturnType = typename HashClass::ReturnType;
+
+  ArrayVectorHasher(DecodedVector& decoded)
+      : SparkVectorHasher<HashClass>(decoded) {
+    base_ = decoded.base()->as<ArrayVector>();
+    indices_ = decoded.indices();
+
+    SelectivityVector rows(base_->elements()->size());
+    decodedElements_.decode(*base_->elements(), rows);
+    elementHasher_ = createVectorHasher<HashClass>(decodedElements_);
+  }
+
+  ReturnType hashNotNullAt(vector_size_t index, SeedType seed) override {
+    auto size = base_->sizeAt(indices_[index]);
+    auto offset = base_->offsetAt(indices_[index]);
+
+    ReturnType result = seed;
+    for (auto i = 0; i < size; ++i) {
+      result = elementHasher_->hashAt(i + offset, result);
+    }
+    return result;
+  }
+
+ private:
+  const ArrayVector* base_;
+  const int32_t* indices_;
+  DecodedVector decodedElements_;
+  std::shared_ptr<SparkVectorHasher<HashClass>> elementHasher_;
+};
+
+template <typename HashClass>
+class MapVectorHasher : public SparkVectorHasher<HashClass> {
+ public:
+  using SeedType = typename HashClass::SeedType;
+  using ReturnType = typename HashClass::ReturnType;
+
+  MapVectorHasher(DecodedVector& decoded)
+      : SparkVectorHasher<HashClass>(decoded) {
+    base_ = decoded.base()->as<MapVector>();
+    indices_ = decoded.indices();
+
+    SelectivityVector rows(base_->mapKeys()->size());
+    decodedKeys_.decode(*base_->mapKeys(), rows);
+    decodedValues_.decode(*base_->mapValues(), rows);
+    keyHasher_ = createVectorHasher<HashClass>(decodedKeys_);
+    valueHasher_ = createVectorHasher<HashClass>(decodedValues_);
+  }
+
+  ReturnType hashNotNullAt(vector_size_t index, SeedType seed) override {
+    auto size = base_->sizeAt(indices_[index]);
+    auto offset = base_->offsetAt(indices_[index]);
+
+    ReturnType result = seed;
+    for (auto i = 0; i < size; ++i) {
+      result = keyHasher_->hashAt(i + offset, result);
+      result = valueHasher_->hashAt(i + offset, result);
+    }
+    return result;
+  }
+
+ private:
+  const MapVector* base_;
+  const int32_t* indices_;
+  DecodedVector decodedKeys_;
+  DecodedVector decodedValues_;
+  std::shared_ptr<SparkVectorHasher<HashClass>> keyHasher_;
+  std::shared_ptr<SparkVectorHasher<HashClass>> valueHasher_;
+};
+
+template <typename HashClass>
+class RowVectorHasher : public SparkVectorHasher<HashClass> {
+ public:
+  using SeedType = typename HashClass::SeedType;
+  using ReturnType = typename HashClass::ReturnType;
+
+  RowVectorHasher(DecodedVector& decoded)
+      : SparkVectorHasher<HashClass>(decoded) {
+    base_ = decoded.base()->as<RowVector>();
+    indices_ = decoded.indices();
+
+    SelectivityVector rows(base_->size());
+    decodedChildren_.resize(base_->childrenSize());
+    hashers_.resize(base_->childrenSize());
+    for (auto i = 0; i < base_->childrenSize(); ++i) {
+      decodedChildren_[i].decode(*base_->childAt(i), rows);
+      hashers_[i] = createVectorHasher<HashClass>(decodedChildren_[i]);
+    }
+  }
+
+  ReturnType hashNotNullAt(vector_size_t index, SeedType seed) override {
+    ReturnType result = seed;
+    for (auto i = 0; i < base_->childrenSize(); ++i) {
+      result = hashers_[i]->hashAt(indices_[index], result);
+    }
+    return result;
+  }
+
+ private:
+  const RowVector* base_;
+  const int32_t* indices_;
+  std::vector<DecodedVector> decodedChildren_;
+  std::vector<std::shared_ptr<SparkVectorHasher<HashClass>>> hashers_;
+};
+
+template <typename HashClass, typename ReturnType, typename ArgType>
+void hashSimdTyped(
+    const SelectivityVector* rows,
+    std::vector<VectorPtr>& args,
+    FlatVector<ReturnType>& result,
+    const int32_t hashIdx) {
+  const ArgType* __restrict rawA =
+      args[hashIdx]->asUnchecked<FlatVector<ArgType>>()->rawValues();
+  auto* __restrict rawResult = result.template mutableRawValues<ReturnType>();
+  rows->applyToSelected([&](auto row) {
+    rawResult[row] = hashOne<HashClass>(rawA[row], rawResult[row]);
+  });
+}
+
+template <typename HashClass, typename ReturnType>
+void hashSimd(
+    const SelectivityVector* rows,
+    std::vector<VectorPtr>& args,
+    FlatVector<ReturnType>& result,
+    const int32_t hashIdx) {
+  switch (args[hashIdx]->typeKind()) {
+#define SCALAR_CASE(kind) \
+  case TypeKind::kind:    \
+    return hashSimdTyped< \
+        HashClass,        \
+        ReturnType,       \
+        TypeTraits<TypeKind::kind>::NativeType>(rows, args, result, hashIdx);
+    SCALAR_CASE(TINYINT)
+    SCALAR_CASE(SMALLINT)
+    SCALAR_CASE(INTEGER)
+    SCALAR_CASE(BIGINT)
+    SCALAR_CASE(HUGEINT)
+    SCALAR_CASE(REAL)
+    SCALAR_CASE(DOUBLE)
+    SCALAR_CASE(VARCHAR)
+    SCALAR_CASE(VARBINARY)
+    SCALAR_CASE(TIMESTAMP)
+    SCALAR_CASE(UNKNOWN)
+#undef SCALAR_CASE
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
 // ReturnType can be either int32_t or int64_t
 // HashClass contains the function like hashInt32
-template <typename ReturnType, typename HashClass, typename SeedType>
+template <
+    typename HashClass,
+    typename SeedType = typename HashClass::SeedType,
+    typename ReturnType = typename HashClass::ReturnType>
 void applyWithType(
     const SelectivityVector& rows,
     std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
     std::optional<SeedType> seed,
     exec::EvalCtx& context,
     VectorPtr& resultRef) {
-  HashClass hash;
   size_t hashIdx = seed ? 1 : 0;
   SeedType hashSeed = seed ? *seed : kDefaultSeed;
 
   auto& result = *resultRef->as<FlatVector<ReturnType>>();
-  rows.applyToSelected([&](int row) { result.set(row, hashSeed); });
+  rows.applyToSelected([&](auto row) { result.set(row, hashSeed); });
 
   exec::LocalSelectivityVector selectedMinusNulls(context);
 
@@ -51,39 +363,31 @@ void applyWithType(
     if (args[i]->mayHaveNulls()) {
       *selectedMinusNulls.get(rows.end()) = rows;
       selectedMinusNulls->deselectNulls(
-          decoded->nulls(), rows.begin(), rows.end());
+          decoded->nulls(&rows), rows.begin(), rows.end());
       selected = selectedMinusNulls.get();
     }
-    switch (args[i]->type()->kind()) {
-// Derived from InterpretedHashFunction.hash:
-// https://github.com/apache/spark/blob/382b66e/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/hash.scala#L532
-#define CASE(typeEnum, hashFn, inputType)                                      \
-  case TypeKind::typeEnum:                                                     \
-    selected->applyToSelected([&](int row) {                                   \
-      result.set(                                                              \
-          row, hashFn(decoded->valueAt<inputType>(row), result.valueAt(row))); \
-    });                                                                        \
-    break;
-      CASE(BOOLEAN, hash.hashInt32, bool);
-      CASE(TINYINT, hash.hashInt32, int8_t);
-      CASE(SMALLINT, hash.hashInt32, int16_t);
-      CASE(INTEGER, hash.hashInt32, int32_t);
-      CASE(BIGINT, hash.hashInt64, int64_t);
-      CASE(VARCHAR, hash.hashBytes, StringView);
-      CASE(VARBINARY, hash.hashBytes, StringView);
-      CASE(REAL, hash.hashFloat, float);
-      CASE(DOUBLE, hash.hashDouble, double);
-      CASE(HUGEINT, hash.hashLongDecimal, int128_t);
-      CASE(TIMESTAMP, hash.hashTimestamp, Timestamp);
-#undef CASE
-      default:
-        VELOX_NYI(
-            "Unsupported type for HASH(): {}", args[i]->type()->toString());
+
+    auto kind = args[i]->typeKind();
+    if ((kind == TypeKind::TINYINT || kind == TypeKind::SMALLINT ||
+         kind == TypeKind::INTEGER || kind == TypeKind::BIGINT ||
+         kind == TypeKind::REAL || kind == TypeKind::DOUBLE ||
+         kind == TypeKind::TIMESTAMP || kind == TypeKind::VARCHAR ||
+         kind == TypeKind::VARBINARY || kind == TypeKind::HUGEINT ||
+         kind == TypeKind::UNKNOWN) &&
+        args[i]->isFlatEncoding()) {
+      hashSimd<HashClass, ReturnType>(selected, args, result, i);
+      continue;
     }
+
+    auto hasher = createVectorHasher<HashClass>(*decoded);
+    selected->applyToSelected([&](auto row) {
+      result.set(row, hasher->hashNotNullAt(row, result.valueAt(row)));
+    });
   }
 }
 
-// Derived from src/main/java/org/apache/spark/unsafe/hash/Murmur3_x86_32.java.
+// Derived from
+// src/main/java/org/apache/spark/unsafe/hash/Murmur3_x86_32.java.
 //
 // Spark's Murmur3 seems slightly different from the original from Austin
 // Appleby: in particular the fmix function's first line is different. The
@@ -95,13 +399,16 @@ void applyWithType(
 
 class Murmur3Hash final {
  public:
-  uint32_t hashInt32(int32_t input, uint32_t seed) {
+  using SeedType = int32_t;
+  using ReturnType = int32_t;
+
+  static uint32_t hashInt32(int32_t input, uint32_t seed) {
     uint32_t k1 = mixK1(input);
     uint32_t h1 = mixH1(seed, k1);
     return fmix(h1, 4);
   }
 
-  uint32_t hashInt64(uint64_t input, uint32_t seed) {
+  static uint32_t hashInt64(uint64_t input, uint32_t seed) {
     uint32_t low = input;
     uint32_t high = input >> 32;
 
@@ -116,19 +423,19 @@ class Murmur3Hash final {
 
   // Floating point numbers are hashed as if they are integers, with
   // -0f defined to have the same output as +0f.
-  uint32_t hashFloat(float input, uint32_t seed) {
+  static uint32_t hashFloat(float input, uint32_t seed) {
     return hashInt32(
         input == -0.f ? 0 : *reinterpret_cast<uint32_t*>(&input), seed);
   }
 
-  uint32_t hashDouble(double input, uint32_t seed) {
+  static uint32_t hashDouble(double input, uint32_t seed) {
     return hashInt64(
         input == -0. ? 0 : *reinterpret_cast<uint64_t*>(&input), seed);
   }
 
   // Spark also has an hashUnsafeBytes2 function, but it was not used at the
   // time of implementation.
-  uint32_t hashBytes(const StringView& input, uint32_t seed) {
+  static uint32_t hashBytes(const StringView& input, uint32_t seed) {
     const char* i = input.data();
     const char* const end = input.data() + input.size();
     uint32_t h1 = seed;
@@ -141,25 +448,25 @@ class Murmur3Hash final {
     return fmix(h1, input.size());
   }
 
-  uint32_t hashLongDecimal(int128_t input, uint32_t seed) {
+  static uint32_t hashLongDecimal(int128_t input, uint32_t seed) {
     char out[sizeof(int128_t)];
     int32_t length = DecimalUtil::toByteArray(input, out);
     return hashBytes(StringView(out, length), seed);
   }
 
-  uint32_t hashTimestamp(Timestamp input, uint32_t seed) {
+  static uint32_t hashTimestamp(Timestamp input, uint32_t seed) {
     return hashInt64(input.toMicros(), seed);
   }
 
  private:
-  uint32_t mixK1(uint32_t k1) {
+  static uint32_t mixK1(uint32_t k1) {
     k1 *= 0xcc9e2d51;
     k1 = bits::rotateLeft(k1, 15);
     k1 *= 0x1b873593;
     return k1;
   }
 
-  uint32_t mixH1(uint32_t h1, uint32_t k1) {
+  static uint32_t mixH1(uint32_t h1, uint32_t k1) {
     h1 ^= k1;
     h1 = bits::rotateLeft(h1, 13);
     h1 = h1 * 5 + 0xe6546b64;
@@ -167,7 +474,7 @@ class Murmur3Hash final {
   }
 
   // Finalization mix - force all bits of a hash block to avalanche
-  uint32_t fmix(uint32_t h1, uint32_t length) {
+  static uint32_t fmix(uint32_t h1, uint32_t length) {
     h1 ^= length;
     h1 ^= h1 >> 16;
     h1 *= 0x85ebca6b;
@@ -183,10 +490,6 @@ class Murmur3HashFunction final : public exec::VectorFunction {
   Murmur3HashFunction() = default;
   explicit Murmur3HashFunction(int32_t seed) : seed_(seed) {}
 
-  bool isDefaultNullBehavior() const final {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
@@ -194,7 +497,7 @@ class Murmur3HashFunction final : public exec::VectorFunction {
       exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     context.ensureWritable(rows, INTEGER(), resultRef);
-    applyWithType<int32_t, Murmur3Hash>(rows, args, seed_, context, resultRef);
+    applyWithType<Murmur3Hash>(rows, args, seed_, context, resultRef);
   }
 
  private:
@@ -202,21 +505,18 @@ class Murmur3HashFunction final : public exec::VectorFunction {
 };
 
 class XxHash64 final {
-  const uint64_t PRIME64_1 = 0x9E3779B185EBCA87L;
-  const uint64_t PRIME64_2 = 0xC2B2AE3D27D4EB4FL;
-  const uint64_t PRIME64_3 = 0x165667B19E3779F9L;
-  const uint64_t PRIME64_4 = 0x85EBCA77C2B2AE63L;
-  const uint64_t PRIME64_5 = 0x27D4EB2F165667C5L;
-
  public:
-  int64_t hashInt32(const int32_t input, uint64_t seed) {
+  using SeedType = int64_t;
+  using ReturnType = int64_t;
+
+  static uint64_t hashInt32(const int32_t input, uint64_t seed) {
     int64_t hash = seed + PRIME64_5 + 4L;
     hash ^= static_cast<int64_t>((input & 0xFFFFFFFFL) * PRIME64_1);
     hash = bits::rotateLeft64(hash, 23) * PRIME64_2 + PRIME64_3;
     return fmix(hash);
   }
 
-  int64_t hashInt64(int64_t input, uint64_t seed) {
+  static uint64_t hashInt64(int64_t input, uint64_t seed) {
     int64_t hash = seed + PRIME64_5 + 8L;
     hash ^= bits::rotateLeft64(input * PRIME64_2, 31) * PRIME64_1;
     hash = bits::rotateLeft64(hash, 27) * PRIME64_1 + PRIME64_4;
@@ -225,17 +525,17 @@ class XxHash64 final {
 
   // Floating point numbers are hashed as if they are integers, with
   // -0f defined to have the same output as +0f.
-  int64_t hashFloat(float input, uint64_t seed) {
+  static uint64_t hashFloat(float input, uint64_t seed) {
     return hashInt32(
         input == -0.f ? 0 : *reinterpret_cast<uint32_t*>(&input), seed);
   }
 
-  int64_t hashDouble(double input, uint64_t seed) {
+  static uint64_t hashDouble(double input, uint64_t seed) {
     return hashInt64(
         input == -0. ? 0 : *reinterpret_cast<uint64_t*>(&input), seed);
   }
 
-  uint64_t hashBytes(const StringView& input, uint64_t seed) {
+  static uint64_t hashBytes(const StringView& input, uint64_t seed) {
     const char* i = input.data();
     const char* const end = input.data() + input.size();
 
@@ -257,18 +557,24 @@ class XxHash64 final {
     return fmix(hash);
   }
 
-  int64_t hashLongDecimal(int128_t input, uint32_t seed) {
+  static uint64_t hashLongDecimal(int128_t input, uint64_t seed) {
     char out[sizeof(int128_t)];
     int32_t length = DecimalUtil::toByteArray(input, out);
     return hashBytes(StringView(out, length), seed);
   }
 
-  int64_t hashTimestamp(Timestamp input, uint32_t seed) {
+  static uint64_t hashTimestamp(Timestamp input, uint64_t seed) {
     return hashInt64(input.toMicros(), seed);
   }
 
  private:
-  uint64_t fmix(uint64_t hash) {
+  static const uint64_t PRIME64_1 = 0x9E3779B185EBCA87L;
+  static const uint64_t PRIME64_2 = 0xC2B2AE3D27D4EB4FL;
+  static const uint64_t PRIME64_3 = 0x165667B19E3779F9L;
+  static const uint64_t PRIME64_4 = 0x85EBCA77C2B2AE63L;
+  static const uint64_t PRIME64_5 = 0x27D4EB2F165667C5L;
+
+  static uint64_t fmix(uint64_t hash) {
     hash ^= hash >> 33;
     hash *= PRIME64_2;
     hash ^= hash >> 29;
@@ -277,7 +583,7 @@ class XxHash64 final {
     return hash;
   }
 
-  uint64_t hashBytesByWords(const StringView& input, uint64_t seed) {
+  static uint64_t hashBytesByWords(const StringView& input, uint64_t seed) {
     const char* i = input.data();
     const char* const end = input.data() + input.size();
     uint32_t length = input.size();
@@ -350,10 +656,6 @@ class XxHash64Function final : public exec::VectorFunction {
   XxHash64Function() = default;
   explicit XxHash64Function(int64_t seed) : seed_(seed) {}
 
-  bool isDefaultNullBehavior() const final {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
@@ -361,20 +663,61 @@ class XxHash64Function final : public exec::VectorFunction {
       exec::EvalCtx& context,
       VectorPtr& resultRef) const final {
     context.ensureWritable(rows, BIGINT(), resultRef);
-    applyWithType<int64_t, XxHash64>(rows, args, seed_, context, resultRef);
+    applyWithType<XxHash64>(rows, args, seed_, context, resultRef);
   }
 
  private:
   const std::optional<int64_t> seed_;
 };
 
+bool checkHashElementType(const TypePtr& type) {
+  switch (type->kind()) {
+    case TypeKind::BOOLEAN:
+    case TypeKind::TINYINT:
+    case TypeKind::SMALLINT:
+    case TypeKind::INTEGER:
+    case TypeKind::BIGINT:
+    case TypeKind::VARCHAR:
+    case TypeKind::VARBINARY:
+    case TypeKind::REAL:
+    case TypeKind::DOUBLE:
+    case TypeKind::HUGEINT:
+    case TypeKind::TIMESTAMP:
+    case TypeKind::UNKNOWN:
+      return true;
+    case TypeKind::ARRAY:
+      return checkHashElementType(type->asArray().elementType());
+    case TypeKind::MAP:
+      return checkHashElementType(type->asMap().keyType()) &&
+          checkHashElementType(type->asMap().valueType());
+    case TypeKind::ROW: {
+      const auto& children = type->asRow().children();
+      return std::all_of(
+          children.begin(), children.end(), [](const auto& child) {
+            return checkHashElementType(child);
+          });
+    }
+    default:
+      return false;
+  }
+}
+
+void checkArgTypes(const std::vector<exec::VectorFunctionArg>& args) {
+  for (const auto& arg : args) {
+    if (!checkHashElementType(arg.type)) {
+      VELOX_USER_FAIL("Unsupported type for hash: {}", arg.type->toString());
+    }
+  }
+}
+
 } // namespace
 
+// Not all types are supported by now. Check types when making hash function.
+// See checkArgTypes.
 std::vector<std::shared_ptr<exec::FunctionSignature>> hashSignatures() {
   return {exec::FunctionSignatureBuilder()
               .returnType("integer")
-              .argumentType("any")
-              .variableArity()
+              .variableArity("any")
               .build()};
 }
 
@@ -382,6 +725,7 @@ std::shared_ptr<exec::VectorFunction> makeHash(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/) {
+  checkArgTypes(inputArgs);
   static const auto kHashFunction = std::make_shared<Murmur3HashFunction>();
   return kHashFunction;
 }
@@ -390,6 +734,7 @@ std::shared_ptr<exec::VectorFunction> makeHashWithSeed(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/) {
+  checkArgTypes(inputArgs);
   const auto& constantSeed = inputArgs[0].constantValue;
   if (!constantSeed || constantSeed->isNullAt(0)) {
     VELOX_USER_FAIL("{} requires a constant non-null seed argument.", name);
@@ -402,16 +747,14 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> hashWithSeedSignatures() {
   return {exec::FunctionSignatureBuilder()
               .returnType("integer")
               .constantArgumentType("integer")
-              .argumentType("any")
-              .variableArity()
+              .variableArity("any")
               .build()};
 }
 
 std::vector<std::shared_ptr<exec::FunctionSignature>> xxhash64Signatures() {
   return {exec::FunctionSignatureBuilder()
               .returnType("bigint")
-              .argumentType("any")
-              .variableArity()
+              .variableArity("any")
               .build()};
 }
 
@@ -420,8 +763,7 @@ xxhash64WithSeedSignatures() {
   return {exec::FunctionSignatureBuilder()
               .returnType("bigint")
               .constantArgumentType("bigint")
-              .argumentType("any")
-              .variableArity()
+              .variableArity("any")
               .build()};
 }
 
@@ -429,6 +771,7 @@ std::shared_ptr<exec::VectorFunction> makeXxHash64(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/) {
+  checkArgTypes(inputArgs);
   static const auto kXxHash64Function = std::make_shared<XxHash64Function>();
   return kXxHash64Function;
 }
@@ -445,4 +788,10 @@ std::shared_ptr<exec::VectorFunction> makeXxHash64WithSeed(
   return std::make_shared<XxHash64Function>(seed);
 }
 
+exec::VectorFunctionMetadata hashMetadata() {
+  return exec::VectorFunctionMetadataBuilder()
+      .defaultNullBehavior(false)
+      .build();
+}
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Hash.h b/velox/functions/sparksql/Hash.h
index 6f931af4c9a8f..73f0389d5abc8 100644
--- a/velox/functions/sparksql/Hash.h
+++ b/velox/functions/sparksql/Hash.h
@@ -54,12 +54,10 @@ std::shared_ptr<exec::VectorFunction> makeHashWithSeed(
 //   - Decimal
 //   - Date
 //   - Timestamp
-//
-// Unsupported:
-//   - Structs, Arrays: hash the elements in order
-//   - Maps: iterate over map, hashing key then value. Since map ordering is
-//        unspecified, hashing logically equivalent maps may result in
-//        different hash values.
+//   - UnknownType
+//   - Struct
+//   - Array
+//   - Map
 
 std::vector<std::shared_ptr<exec::FunctionSignature>> xxhash64Signatures();
 
@@ -76,4 +74,6 @@ std::shared_ptr<exec::VectorFunction> makeXxHash64WithSeed(
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config);
 
+exec::VectorFunctionMetadata hashMetadata();
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/In.cpp b/velox/functions/sparksql/In.cpp
index 8eefa17c1698a..cddfbaab9ed7a 100644
--- a/velox/functions/sparksql/In.cpp
+++ b/velox/functions/sparksql/In.cpp
@@ -29,6 +29,18 @@ namespace {
 template <typename T>
 class Set : public folly::F14FastSet<T, folly::hasher<T>, Equal<T>> {};
 
+template <>
+class Set<float> : public folly::F14FastSet<
+                       float,
+                       util::floating_point::NaNAwareHash<float>,
+                       util::floating_point::NaNAwareEquals<float>> {};
+
+template <>
+class Set<double> : public folly::F14FastSet<
+                        double,
+                        util::floating_point::NaNAwareHash<double>,
+                        util::floating_point::NaNAwareEquals<double>> {};
+
 template <>
 class Set<StringView> {
  public:
@@ -69,6 +81,7 @@ struct InFunctionOuter {
     VELOX_DEFINE_FUNCTION_TYPES(TExecCtx);
 
     FOLLY_ALWAYS_INLINE void initialize(
+        const std::vector<TypePtr>& /*inputTypes*/,
         const core::QueryConfig& /*config*/,
         const arg_type<TInput>* /*searchTerm*/,
         const arg_type<velox::Array<TInput>>* searchElements) {
diff --git a/velox/functions/sparksql/JsonObjectKeys.h b/velox/functions/sparksql/JsonObjectKeys.h
new file mode 100644
index 0000000000000..a320cbb084136
--- /dev/null
+++ b/velox/functions/sparksql/JsonObjectKeys.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/prestosql/json/SIMDJsonUtil.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// json_object_keys(jsonString) -> array(string)
+///
+/// Returns all the keys of the outermost JSON object as an array if a valid
+/// JSON object is given.
+template <typename T>
+struct JsonObjectKeysFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Array<Varchar>>& out,
+      const arg_type<Varchar>& json) {
+    simdjson::ondemand::document jsonDoc;
+
+    simdjson::padded_string paddedJson(json.data(), json.size());
+    // The result is NULL if the given string is not a valid JSON string.
+    if (simdjsonParse(paddedJson).get(jsonDoc)) {
+      return false;
+    }
+
+    // The result is NULL if the given string is not a JSON object string.
+    if (jsonDoc.type() != simdjson::ondemand::json_type::object) {
+      return false;
+    }
+
+    simdjson::ondemand::object jsonObject;
+    // The result is NULL if the given string is not a valid JSON object string.
+    if (jsonDoc.get_object().get(jsonObject)) {
+      return false;
+    }
+
+    for (auto field : jsonObject) {
+      out.add_item().copy_from(std::string_view(field.unescaped_key()));
+    }
+    return true;
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/LeastGreatest.cpp b/velox/functions/sparksql/LeastGreatest.cpp
index 52d4339d428a9..24a77b0c8753e 100644
--- a/velox/functions/sparksql/LeastGreatest.cpp
+++ b/velox/functions/sparksql/LeastGreatest.cpp
@@ -27,10 +27,6 @@ template <typename Cmp, TypeKind kind>
 class LeastGreatestFunction final : public exec::VectorFunction {
   using T = typename TypeTraits<kind>::NativeType;
 
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -56,7 +52,7 @@ class LeastGreatestFunction final : public exec::VectorFunction {
 
       // Only compare with non-null elements of each argument
       *cmpRows = rows;
-      if (auto* rawNulls = decodedVectorHolder->nulls()) {
+      if (auto* rawNulls = decodedVectorHolder->nulls(&rows)) {
         cmpRows->deselectNulls(rawNulls, 0, nrows);
       }
 
@@ -113,6 +109,7 @@ std::shared_ptr<exec::VectorFunction> makeImpl(
     SCALAR_CASE(SMALLINT)
     SCALAR_CASE(INTEGER)
     SCALAR_CASE(BIGINT)
+    SCALAR_CASE(HUGEINT)
     SCALAR_CASE(REAL)
     SCALAR_CASE(DOUBLE)
     SCALAR_CASE(VARCHAR)
@@ -155,10 +152,16 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> leastSignatures() {
     signatures.emplace_back(exec::FunctionSignatureBuilder()
                                 .returnType(type)
                                 .argumentType(type)
-                                .argumentType(type)
-                                .variableArity()
+                                .variableArity(type)
                                 .build());
   }
+  signatures.emplace_back(exec::FunctionSignatureBuilder()
+                              .integerVariable("p")
+                              .integerVariable("s")
+                              .returnType("decimal(p,s)")
+                              .argumentType("decimal(p,s)")
+                              .variableArity("decimal(p,s)")
+                              .build());
   return signatures;
 }
 
diff --git a/velox/functions/sparksql/LeastGreatest.h b/velox/functions/sparksql/LeastGreatest.h
index 09cb4e0f40071..e672548d68353 100644
--- a/velox/functions/sparksql/LeastGreatest.h
+++ b/velox/functions/sparksql/LeastGreatest.h
@@ -27,6 +27,7 @@ namespace facebook::velox::functions::sparksql {
 /// SMALLINT
 /// INTEGER
 /// BIGINT
+/// HUGEINT
 /// REAL
 /// DOUBLE
 /// BOOLEAN
diff --git a/velox/functions/sparksql/MakeTimestamp.cpp b/velox/functions/sparksql/MakeTimestamp.cpp
new file mode 100644
index 0000000000000..1d1895a275f62
--- /dev/null
+++ b/velox/functions/sparksql/MakeTimestamp.cpp
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/DecodedArgs.h"
+#include "velox/expression/VectorFunction.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+std::optional<Timestamp> makeTimeStampFromDecodedArgs(
+    vector_size_t row,
+    DecodedVector* yearVector,
+    DecodedVector* monthVector,
+    DecodedVector* dayVector,
+    DecodedVector* hourVector,
+    DecodedVector* minuteVector,
+    DecodedVector* microsVector) {
+  // Check hour.
+  auto hour = hourVector->valueAt<int32_t>(row);
+  if (hour < 0 || hour > 24) {
+    return std::nullopt;
+  }
+  // Check minute.
+  auto minute = minuteVector->valueAt<int32_t>(row);
+  if (minute < 0 || minute > 60) {
+    return std::nullopt;
+  }
+  // Check microseconds.
+  auto micros = microsVector->valueAt<int64_t>(row);
+  if (micros < 0) {
+    return std::nullopt;
+  }
+  auto seconds = micros / util::kMicrosPerSec;
+  if (seconds > 60 || (seconds == 60 && micros % util::kMicrosPerSec != 0)) {
+    return std::nullopt;
+  }
+
+  // Year, month, day will be checked in utils::daysSinceEpochFromDate.
+  Expected<int64_t> daysSinceEpoch = util::daysSinceEpochFromDate(
+      yearVector->valueAt<int32_t>(row),
+      monthVector->valueAt<int32_t>(row),
+      dayVector->valueAt<int32_t>(row));
+  if (daysSinceEpoch.hasError()) {
+    VELOX_DCHECK(daysSinceEpoch.error().isUserError());
+    return std::nullopt;
+  }
+
+  // Micros has at most 8 digits (2 for seconds + 6 for microseconds),
+  // thus it's safe to cast micros from int64_t to int32_t.
+  auto localMicros = util::fromTime(hour, minute, 0, (int32_t)micros);
+  return util::fromDatetime(daysSinceEpoch.value(), localMicros);
+}
+
+void setTimestampOrNull(
+    int32_t row,
+    std::optional<Timestamp> timestamp,
+    DecodedVector* timeZoneVector,
+    FlatVector<Timestamp>* result) {
+  const auto timeZoneName = timeZoneVector->valueAt<StringView>(row);
+  const auto* timeZone = tz::locateZone(std::string_view(timeZoneName));
+  if (timestamp.has_value()) {
+    timestamp->toGMT(*timeZone);
+    result->set(row, *timestamp);
+  } else {
+    result->setNull(row, true);
+  }
+}
+
+void setTimestampOrNull(
+    int32_t row,
+    std::optional<Timestamp> timestamp,
+    const tz::TimeZone* timeZone,
+    FlatVector<Timestamp>* result) {
+  if (timestamp.has_value()) {
+    timestamp->toGMT(*timeZone);
+    result->set(row, *timestamp);
+  } else {
+    result->setNull(row, true);
+  }
+}
+
+class MakeTimestampFunction : public exec::VectorFunction {
+ public:
+  MakeTimestampFunction(const tz::TimeZone* sessionTimeZone)
+      : sessionTimeZone_(sessionTimeZone) {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, TIMESTAMP(), result);
+    auto* resultFlatVector = result->as<FlatVector<Timestamp>>();
+
+    exec::DecodedArgs decodedArgs(rows, args, context);
+    auto* year = decodedArgs.at(0);
+    auto* month = decodedArgs.at(1);
+    auto* day = decodedArgs.at(2);
+    auto* hour = decodedArgs.at(3);
+    auto* minute = decodedArgs.at(4);
+    auto* micros = decodedArgs.at(5);
+
+    if (args.size() == 7) {
+      // If the timezone argument is specified, treat the input timestamp as the
+      // time in that timezone.
+      if (args[6]->isConstantEncoding()) {
+        auto tz =
+            args[6]->asUnchecked<ConstantVector<StringView>>()->valueAt(0);
+        const tz::TimeZone* constantTimeZone = nullptr;
+        try {
+          constantTimeZone = tz::locateZone(std::string_view(tz));
+        } catch (const VeloxException&) {
+          context.setErrors(rows, std::current_exception());
+          return;
+        }
+        rows.applyToSelected([&](vector_size_t row) {
+          auto timestamp = makeTimeStampFromDecodedArgs(
+              row, year, month, day, hour, minute, micros);
+          setTimestampOrNull(
+              row, timestamp, constantTimeZone, resultFlatVector);
+        });
+      } else {
+        auto* timeZone = decodedArgs.at(6);
+        context.applyToSelectedNoThrow(rows, [&](auto row) {
+          auto timestamp = makeTimeStampFromDecodedArgs(
+              row, year, month, day, hour, minute, micros);
+          setTimestampOrNull(row, timestamp, timeZone, resultFlatVector);
+        });
+      }
+    } else {
+      // Otherwise use session timezone.
+      rows.applyToSelected([&](vector_size_t row) {
+        auto timestamp = makeTimeStampFromDecodedArgs(
+            row, year, month, day, hour, minute, micros);
+        setTimestampOrNull(row, timestamp, sessionTimeZone_, resultFlatVector);
+      });
+    }
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    return {
+        exec::FunctionSignatureBuilder()
+            // precision <= 18.
+            .integerVariable("precision", "min(precision, 18)")
+            .returnType("timestamp")
+            .argumentType("integer")
+            .argumentType("integer")
+            .argumentType("integer")
+            .argumentType("integer")
+            .argumentType("integer")
+            .argumentType("decimal(precision, 6)")
+            .build(),
+        exec::FunctionSignatureBuilder()
+            // precision <= 18.
+            .integerVariable("precision", "min(precision, 18)")
+            .returnType("timestamp")
+            .argumentType("integer")
+            .argumentType("integer")
+            .argumentType("integer")
+            .argumentType("integer")
+            .argumentType("integer")
+            .argumentType("decimal(precision, 6)")
+            .argumentType("varchar")
+            .build(),
+    };
+  }
+
+ private:
+  const tz::TimeZone* sessionTimeZone_;
+};
+
+std::shared_ptr<exec::VectorFunction> createMakeTimestampFunction(
+    const std::string& /* name */,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  const auto sessionTzName = config.sessionTimezone();
+  VELOX_USER_CHECK(
+      !sessionTzName.empty(),
+      "make_timestamp requires session time zone to be set.");
+  const auto* sessionTimeZone = tz::locateZone(sessionTzName);
+
+  const auto& secondsType = inputArgs[5].type;
+  VELOX_USER_CHECK(
+      secondsType->isShortDecimal(),
+      "Seconds must be short decimal type but got {}",
+      secondsType->toString());
+  auto secondsScale = secondsType->asShortDecimal().scale();
+  VELOX_USER_CHECK_EQ(
+      secondsScale,
+      6,
+      "Seconds fraction must have 6 digits for microseconds but got {}",
+      secondsScale);
+
+  return std::make_shared<MakeTimestampFunction>(sessionTimeZone);
+}
+} // namespace
+
+VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
+    udf_make_timestamp,
+    MakeTimestampFunction::signatures(),
+    createMakeTimestampFunction);
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Map.cpp b/velox/functions/sparksql/Map.cpp
index 16656473453a1..7b56f9ab98cbb 100644
--- a/velox/functions/sparksql/Map.cpp
+++ b/velox/functions/sparksql/Map.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 #include <velox/common/base/Exceptions.h>
-#include <velox/type/Timestamp.h>
 #include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/vector/VectorTypeUtils.h"
@@ -32,66 +31,42 @@
 namespace facebook::velox::functions::sparksql {
 namespace {
 
-template <TypeKind kind>
-void setKeysResultTyped(
+void setKeysAndValuesResult(
     vector_size_t mapSize,
+    vector_size_t baseOffset,
     std::vector<VectorPtr>& args,
     const VectorPtr& keysResult,
-    exec::EvalCtx& context,
-    const SelectivityVector& rows) {
-  using T = typename KindToFlatVector<kind>::WrapperType;
-  auto flatVector = keysResult->asFlatVector<T>();
-  flatVector->resize(rows.end() * mapSize);
-
-  exec::LocalDecodedVector decoded(context);
-  for (vector_size_t i = 0; i < mapSize; i++) {
-    decoded.get()->decode(*args[i * 2], rows);
-    // For efficiency traverse one arg at the time
-    rows.applyToSelected([&](vector_size_t row) {
-      VELOX_CHECK(!decoded->isNullAt(row), "Cannot use null as map key!");
-      flatVector->set(row * mapSize + i, decoded->valueAt<T>(row));
-    });
-  }
-}
-
-template <TypeKind kind>
-void setValuesResultTyped(
-    vector_size_t mapSize,
-    std::vector<VectorPtr>& args,
     const VectorPtr& valuesResult,
     exec::EvalCtx& context,
     const SelectivityVector& rows) {
-  using T = typename KindToFlatVector<kind>::WrapperType;
-  auto flatVector = valuesResult->asFlatVector<T>();
-  flatVector->resize(rows.end() * mapSize);
-
   exec::LocalDecodedVector decoded(context);
+  SelectivityVector targetRows(keysResult->size(), false);
+  std::vector<vector_size_t> toSourceRow(keysResult->size());
   for (vector_size_t i = 0; i < mapSize; i++) {
-    decoded.get()->decode(*args[i * 2 + 1], rows);
-
-    rows.applyToSelected([&](vector_size_t row) {
-      if (decoded->isNullAt(row)) {
-        flatVector->setNull(row * mapSize + i, true);
-      } else {
-        flatVector->set(row * mapSize + i, decoded->valueAt<T>(row));
-      }
+    decoded.get()->decode(*args[i * 2], rows);
+    auto offset = baseOffset;
+    context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      VELOX_USER_CHECK(!decoded->isNullAt(row), "Cannot use null as map key!");
+      targetRows.setValid(offset + i, true);
+      toSourceRow[offset + i] = row;
+      offset += mapSize;
     });
+    targetRows.updateBounds();
+    keysResult->copy(args[i * 2].get(), targetRows, toSourceRow.data());
+    valuesResult->copy(args[i * 2 + 1].get(), targetRows, toSourceRow.data());
+    targetRows.clearAll();
   }
 }
 
 class MapFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /*outputType*/,
       exec::EvalCtx& context,
       VectorPtr& result) const override {
-    VELOX_CHECK(
+    VELOX_USER_CHECK(
         args.size() >= 2 && args.size() % 2 == 0,
         "Map function must take an even number of arguments");
     auto mapSize = args.size() / 2;
@@ -101,14 +76,12 @@ class MapFunction : public exec::VectorFunction {
 
     // Check key and value types
     for (auto i = 0; i < mapSize; i++) {
-      VELOX_CHECK_EQ(
-          args[i * 2]->type(),
-          keyType,
-          "All the key arguments in Map function must be the same!");
-      VELOX_CHECK_EQ(
-          args[i * 2 + 1]->type(),
-          valueType,
+      VELOX_USER_CHECK(
+          args[i * 2]->type()->equivalent(*keyType),
           "All the key arguments in Map function must be the same!");
+      VELOX_USER_CHECK(
+          args[i * 2 + 1]->type()->equivalent(*valueType),
+          "All the value arguments in Map function must be the same!");
     }
 
     // Initializing input
@@ -121,35 +94,24 @@ class MapFunction : public exec::VectorFunction {
     auto offsets = mapResult->mutableOffsets(rows.end());
     auto rawOffsets = offsets->asMutable<int32_t>();
 
+    // Setting keys and value elements
+    auto& keysResult = mapResult->mapKeys();
+    auto& valuesResult = mapResult->mapValues();
+    const auto baseOffset =
+        std::max<vector_size_t>(keysResult->size(), valuesResult->size());
+
     // Setting size and offsets
+    vector_size_t offset = baseOffset;
     rows.applyToSelected([&](vector_size_t row) {
       rawSizes[row] = mapSize;
-      rawOffsets[row] = row * mapSize;
+      rawOffsets[row] = offset;
+      offset += mapSize;
     });
 
-    // Setting keys and value elements
-    auto keysResult = mapResult->mapKeys();
-    auto valuesResult = mapResult->mapValues();
-    keysResult->resize(rows.end() * mapSize);
-    valuesResult->resize(rows.end() * mapSize);
-
-    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-        setKeysResultTyped,
-        keyType->kind(),
-        mapSize,
-        args,
-        keysResult,
-        context,
-        rows);
-
-    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-        setValuesResultTyped,
-        valueType->kind(),
-        mapSize,
-        args,
-        valuesResult,
-        context,
-        rows);
+    keysResult->resize(offset);
+    valuesResult->resize(offset);
+    setKeysAndValuesResult(
+        mapSize, baseOffset, args, keysResult, valuesResult, context, rows);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -173,8 +135,9 @@ class MapFunction : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_map,
     MapFunction::signatures(),
+    exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build(),
     std::make_unique<MapFunction>());
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/MaskFunction.h b/velox/functions/sparksql/MaskFunction.h
new file mode 100644
index 0000000000000..67faef19b666f
--- /dev/null
+++ b/velox/functions/sparksql/MaskFunction.h
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/lib/Utf8Utils.h"
+
+namespace facebook::velox::functions::sparksql {
+
+// mask(string) -> string
+// mask(string, upperChar) -> string
+// mask(string, upperChar, lowerChar) -> string
+// mask(string, upperChar, lowerChar, digitChar) -> string
+// mask(string, upperChar, lowerChar, digitChar, otherChar) -> string
+//
+// Masks the characters of the given string value with the provided specific
+// characters respectively. Upper-case characters are replaced with the second
+// argument. Default value is 'X'. Lower-case characters are replaced with the
+// third argument. Default value is 'x'. Digit characters are replaced with the
+// fourth argument. Default value is 'n'. Other characters are replaced with the
+// last argument. Default value is NULL and the original character is retained.
+// If the provided nth argument is NULL, the related original character is
+// retained.
+template <typename T>
+struct MaskFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input) {
+    doCall(
+        result,
+        std::string_view(input),
+        kMaskedUpperCase_,
+        kMaskedLowerCase_,
+        kMaskedDigit_,
+        std::nullopt);
+  }
+
+  FOLLY_ALWAYS_INLINE bool callNullable(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>* inputPtr,
+      const arg_type<Varchar>* upperCharPtr) {
+    if (inputPtr == nullptr) {
+      return false;
+    }
+
+    doCall(
+        result,
+        std::string_view(*inputPtr),
+        getMaskedChar(upperCharPtr),
+        kMaskedLowerCase_,
+        kMaskedDigit_,
+        std::nullopt);
+    return true;
+  }
+
+  FOLLY_ALWAYS_INLINE bool callNullable(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>* inputPtr,
+      const arg_type<Varchar>* upperCharPtr,
+      const arg_type<Varchar>* lowerCharPtr) {
+    if (inputPtr == nullptr) {
+      return false;
+    }
+
+    doCall(
+        result,
+        std::string_view(*inputPtr),
+        getMaskedChar(upperCharPtr),
+        getMaskedChar(lowerCharPtr),
+        kMaskedDigit_,
+        std::nullopt);
+    return true;
+  }
+
+  FOLLY_ALWAYS_INLINE bool callNullable(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>* inputPtr,
+      const arg_type<Varchar>* upperCharPtr,
+      const arg_type<Varchar>* lowerCharPtr,
+      const arg_type<Varchar>* digitCharPtr) {
+    if (inputPtr == nullptr) {
+      return false;
+    }
+
+    doCall(
+        result,
+        std::string_view(*inputPtr),
+        getMaskedChar(upperCharPtr),
+        getMaskedChar(lowerCharPtr),
+        getMaskedChar(digitCharPtr),
+        std::nullopt);
+    return true;
+  }
+
+  FOLLY_ALWAYS_INLINE bool callNullable(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>* inputPtr,
+      const arg_type<Varchar>* upperCharPtr,
+      const arg_type<Varchar>* lowerCharPtr,
+      const arg_type<Varchar>* digitCharPtr,
+      const arg_type<Varchar>* otherCharPtr) {
+    if (inputPtr == nullptr) {
+      return false;
+    }
+
+    doCall(
+        result,
+        std::string_view(*inputPtr),
+        getMaskedChar(upperCharPtr),
+        getMaskedChar(lowerCharPtr),
+        getMaskedChar(digitCharPtr),
+        getMaskedChar(otherCharPtr));
+    return true;
+  }
+
+ private:
+  void doCall(
+      out_type<Varchar>& result,
+      std::string_view input,
+      const std::optional<std::string_view> upperChar,
+      const std::optional<std::string_view> lowerChar,
+      const std::optional<std::string_view> digitChar,
+      const std::optional<std::string_view> otherChar) const {
+    auto inputBuffer = input.data();
+    const size_t inputSize = input.size();
+    result.reserve(inputSize * 4);
+    auto outputBuffer = result.data();
+    size_t inputIdx = 0;
+    size_t outputIdx = 0;
+    while (inputIdx < inputSize) {
+      int charByteSize;
+      auto curCodePoint = utf8proc_codepoint(
+          &inputBuffer[inputIdx], inputBuffer + inputSize, charByteSize);
+      if (curCodePoint == -1) {
+        // That means it is a invalid UTF-8 character for example '\xED',
+        // treat it as char with size 1.
+        charByteSize = 1;
+      }
+      auto maskedChar = &inputBuffer[inputIdx];
+      auto maskedCharByteSize = charByteSize;
+      // Treat invalid UTF-8 character as other char.
+      utf8proc_propval_t category = utf8proc_category(curCodePoint);
+      if (isUpperChar(category) && upperChar.has_value()) {
+        maskedChar = upperChar.value().data();
+        maskedCharByteSize = upperChar.value().size();
+      } else if (isLowerChar(category) && lowerChar.has_value()) {
+        maskedChar = lowerChar.value().data();
+        maskedCharByteSize = lowerChar.value().size();
+      } else if (isDigitChar(category) && digitChar.has_value()) {
+        maskedChar = digitChar.value().data();
+        maskedCharByteSize = digitChar.value().size();
+      } else if (
+          !isUpperChar(category) && !isLowerChar(category) &&
+          !isDigitChar(category) && otherChar.has_value()) {
+        maskedChar = otherChar.value().data();
+        maskedCharByteSize = otherChar.value().size();
+      }
+
+      for (auto i = 0; i < maskedCharByteSize; i++) {
+        outputBuffer[outputIdx++] = maskedChar[i];
+      }
+
+      inputIdx += charByteSize;
+    }
+    result.resize(outputIdx);
+  }
+
+  bool isUpperChar(utf8proc_propval_t& category) const {
+    return category == UTF8PROC_CATEGORY_LU;
+  }
+
+  bool isLowerChar(utf8proc_propval_t& category) const {
+    return category == UTF8PROC_CATEGORY_LL;
+  }
+
+  bool isDigitChar(utf8proc_propval_t& category) const {
+    return category == UTF8PROC_CATEGORY_ND;
+  }
+
+  std::optional<std::string_view> getMaskedChar(
+      const arg_type<Varchar>* maskChar) {
+    if (maskChar) {
+      auto maskCharData = maskChar->data();
+      auto maskCharSize = maskChar->size();
+      if (maskCharSize == 1) {
+        return std::string_view(maskCharData);
+      }
+
+      VELOX_USER_CHECK_NE(
+          maskCharSize,
+          0,
+          "Replacement string must contain a single character and cannot be empty.");
+
+      // Calculates the byte length of the first unicode character, and compares
+      // it with the length of replacing character. Inequality indicates the
+      // replacing character includes more than one unicode characters.
+      int size;
+      auto codePoint = utf8proc_codepoint(
+          &maskCharData[0], maskCharData + maskCharSize, size);
+      VELOX_USER_CHECK_EQ(
+          maskCharSize,
+          size,
+          "Replacement string must contain a single character and cannot be empty.");
+
+      return std::string_view(maskCharData, maskCharSize);
+    }
+    return std::nullopt;
+  }
+
+  static constexpr std::string_view kMaskedUpperCase_{"X"};
+  static constexpr std::string_view kMaskedLowerCase_{"x"};
+  static constexpr std::string_view kMaskedDigit_{"n"};
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/MightContain.h b/velox/functions/sparksql/MightContain.h
index 7885bb98c12f3..21b16007b8bdb 100644
--- a/velox/functions/sparksql/MightContain.h
+++ b/velox/functions/sparksql/MightContain.h
@@ -26,6 +26,7 @@ struct BloomFilterMightContainFunction {
   using Allocator = std::allocator<uint64_t>;
 
   void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig&,
       const arg_type<Varbinary>* serialized,
       const arg_type<int64_t>*) {
diff --git a/velox/functions/sparksql/MonotonicallyIncreasingId.h b/velox/functions/sparksql/MonotonicallyIncreasingId.h
new file mode 100644
index 0000000000000..af1caef73a249
--- /dev/null
+++ b/velox/functions/sparksql/MonotonicallyIncreasingId.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/Macros.h"
+
+namespace facebook::velox::functions::sparksql {
+
+template <typename T>
+struct MonotonicallyIncreasingIdFunction {
+  static constexpr bool is_deterministic = false;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config) {
+    count_ = (int64_t)config.sparkPartitionId() << 33;
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result) {
+    result = count_++;
+  }
+
+ private:
+  int64_t count_;
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/RaiseError.h b/velox/functions/sparksql/RaiseError.h
new file mode 100644
index 0000000000000..9b7e65b22584a
--- /dev/null
+++ b/velox/functions/sparksql/RaiseError.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/Macros.h"
+namespace facebook::velox::functions::sparksql {
+
+template <typename T>
+struct RaiseErrorFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  callNullable(out_type<UnknownValue>& result, const arg_type<Varchar>* input) {
+    if (input) {
+      return Status::UserError("{}", *input);
+    }
+    return Status::UserError();
+  }
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Rand.h b/velox/functions/sparksql/Rand.h
index 50cd2abddd1d3..01cf174861a83 100644
--- a/velox/functions/sparksql/Rand.h
+++ b/velox/functions/sparksql/Rand.h
@@ -23,54 +23,27 @@ template <typename T>
 struct RandFunction {
   static constexpr bool is_deterministic = false;
 
-  FOLLY_ALWAYS_INLINE void call(double& result) {
-    result = folly::Random::randDouble01();
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const TInput* seedInput) {
+    const auto partitionId = config.sparkPartitionId();
+    int64_t seed = seedInput ? (int64_t)*seedInput : 0;
+    generator_.seed(seed + partitionId);
   }
 
-  FOLLY_ALWAYS_INLINE void callNullable(
-      double& result,
-      const int32_t* seed,
-      const int32_t* partitionIndex) {
-    initializeGenerator(seed, partitionIndex);
-    result = folly::Random::randDouble01(*generator_);
-  }
-
-  // To differentiate generator for each thread, seed plus partitionIndex is
-  // the actual seed used for generator.
-  FOLLY_ALWAYS_INLINE void callNullable(
-      double& result,
-      const int64_t* seed,
-      const int32_t* partitionIndex) {
-    initializeGenerator(seed, partitionIndex);
-    result = folly::Random::randDouble01(*generator_);
+  FOLLY_ALWAYS_INLINE void call(double& result) {
+    result = folly::Random::randDouble01();
   }
 
-  // For NULL constant input of unknown type.
-  FOLLY_ALWAYS_INLINE void callNullable(
-      double& result,
-      const UnknownValue* /*seed*/,
-      const int32_t* partitionIndex) {
-    initializeGenerator<int64_t>(nullptr, partitionIndex);
-    result = folly::Random::randDouble01(*generator_);
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void callNullable(double& result, TInput /*seedInput*/) {
+    result = folly::Random::randDouble01(generator_);
   }
 
  private:
-  template <typename TSeed>
-  FOLLY_ALWAYS_INLINE void initializeGenerator(
-      const TSeed* seed,
-      const int32_t* partitionIndex) {
-    VELOX_USER_CHECK_NOT_NULL(partitionIndex, "partitionIndex cannot be null.");
-    if (!generator_.has_value()) {
-      generator_ = std::mt19937{};
-      if (seed != nullptr) {
-        generator_->seed((int64_t)*seed + *partitionIndex);
-      } else {
-        // For null seed, partitionIndex is the seed, consistent with Spark.
-        generator_->seed(*partitionIndex);
-      }
-    }
-  }
-
-  std::optional<std::mt19937> generator_;
+  std::mt19937 generator_;
 };
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/RegexFunctions.cpp b/velox/functions/sparksql/RegexFunctions.cpp
index 7385f4cd754a5..7cdabbda674e7 100644
--- a/velox/functions/sparksql/RegexFunctions.cpp
+++ b/velox/functions/sparksql/RegexFunctions.cpp
@@ -13,49 +13,153 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <folly/container/F14Map.h>
 #include "velox/functions/lib/Re2Functions.h"
-
-#include "velox/common/base/Exceptions.h"
+#include "velox/functions/lib/string/StringImpl.h"
 
 namespace facebook::velox::functions::sparksql {
 namespace {
 
-// Blocks patterns that contain character class union, intersection, or
-// difference because these are not understood by RE2 and will be parsed as a
-// different pattern than in java.util.regex.
-void ensureRegexIsCompatible(
+using ::re2::RE2;
+
+template <typename T>
+re2::StringPiece toStringPiece(const T& string) {
+  return re2::StringPiece(string.data(), string.size());
+}
+
+void checkForBadPattern(const RE2& re) {
+  if (UNLIKELY(!re.ok())) {
+    VELOX_USER_FAIL("invalid regular expression:{}", re.error());
+  }
+}
+
+void ensureRegexIsConstant(
     const char* functionName,
     const VectorPtr& patternVector) {
-  if (!patternVector ||
-      patternVector->encoding() != VectorEncoding::Simple::CONSTANT) {
+  if (!patternVector || !patternVector->isConstantEncoding()) {
     VELOX_USER_FAIL("{} requires a constant pattern.", functionName);
   }
-  if (patternVector->isNullAt(0)) {
-    return;
+}
+
+// REGEXP_REPLACE(string, pattern, overwrite) → string
+// REGEXP_REPLACE(string, pattern, overwrite, position) → string
+//
+// If a string has a substring that matches the given pattern, replace
+// the match in the string wither overwrite and return the string. If
+// optional paramter position is provided, only make replacements
+// after that positon in the string (1 indexed).
+//
+// If position <= 0, throw error.
+// If position > length string, return string.
+template <typename T>
+struct RegexpReplaceFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr bool is_default_ascii_behavior = true;
+
+  void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& stringInput,
+      const arg_type<Varchar>& pattern,
+      const arg_type<Varchar>& replace) {
+    call(result, stringInput, pattern, replace, 1);
   }
-  const StringView pattern =
-      patternVector->as<ConstantVector<StringView>>()->valueAt(0);
-  // If in a character class, points to the [ at the beginning of that class.
-  const char* charClassStart = nullptr;
-  // This minimal regex parser looks just for the class begin/end markers.
-  for (const char* c = pattern.begin(); c < pattern.end(); ++c) {
-    if (*c == '\\') {
-      ++c;
-    } else if (*c == '[') {
-      if (charClassStart) {
-        VELOX_USER_FAIL(
-            "{} does not support character class union, intersection, "
-            "or difference ([a[b]], [a&&[b]], [a&&[^b]])",
-            functionName);
-      }
-      charClassStart = c;
-      // A ] immediately after a [ does not end the character class, and is
-      // instead adds the character ].
-    } else if (*c == ']' && charClassStart + 1 != c) {
-      charClassStart = nullptr;
+
+  void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& stringInput,
+      const arg_type<Varchar>& pattern,
+      const arg_type<Varchar>& replace,
+      const arg_type<int64_t>& position) {
+    if (performChecks(result, stringInput, pattern, replace, position - 1)) {
+      return;
+    }
+    size_t start = functions::stringImpl::cappedByteLength<false>(
+        stringInput, position - 1);
+    if (start > stringInput.size() + 1) {
+      result = stringInput;
+      return;
     }
+    performReplace(result, stringInput, pattern, replace, start);
   }
-}
+
+  void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& stringInput,
+      const arg_type<Varchar>& pattern,
+      const arg_type<Varchar>& replace) {
+    callAscii(result, stringInput, pattern, replace, 1);
+  }
+
+  void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& stringInput,
+      const arg_type<Varchar>& pattern,
+      const arg_type<Varchar>& replace,
+      const arg_type<int64_t>& position) {
+    if (performChecks(result, stringInput, pattern, replace, position - 1)) {
+      return;
+    }
+    performReplace(result, stringInput, pattern, replace, position - 1);
+  }
+
+ private:
+  bool performChecks(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& stringInput,
+      const arg_type<Varchar>& pattern,
+      const arg_type<Varchar>& replace,
+      const arg_type<int64_t>& position) {
+    VELOX_USER_CHECK_GE(
+        position + 1, 1, "regexp_replace requires a position >= 1");
+    if (position > stringInput.size()) {
+      result = stringInput;
+      return true;
+    }
+
+    if (stringInput.size() == 0 && pattern.size() == 0 && position == 1) {
+      result = replace;
+      return true;
+    }
+    return false;
+  }
+
+  void performReplace(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& stringInput,
+      const arg_type<Varchar>& pattern,
+      const arg_type<Varchar>& replace,
+      const arg_type<int64_t>& position) {
+    re2::RE2* patternRegex = getRegex(pattern.str());
+    re2::StringPiece replaceStringPiece = toStringPiece(replace);
+
+    std::string prefix(stringInput.data(), position);
+    std::string targetString(
+        stringInput.data() + position, stringInput.size() - position);
+
+    RE2::GlobalReplace(&targetString, *patternRegex, replaceStringPiece);
+    result = prefix + targetString;
+  }
+
+  re2::RE2* getRegex(const std::string& pattern) {
+    auto it = cache_.find(pattern);
+    if (it != cache_.end()) {
+      return it->second.get();
+    }
+    VELOX_USER_CHECK_LT(
+        cache_.size(),
+        kMaxCompiledRegexes,
+        "regexp_replace hit the maximum number of unique regexes: {}",
+        kMaxCompiledRegexes);
+    auto patternRegex = std::make_unique<re2::RE2>(pattern, re2::RE2::Quiet);
+    auto* rawPatternRegex = patternRegex.get();
+    checkForBadPattern(*rawPatternRegex);
+    cache_.emplace(pattern, std::move(patternRegex));
+    return rawPatternRegex;
+  }
+
+  folly::F14FastMap<std::string, std::unique_ptr<re2::RE2>> cache_;
+};
 
 } // namespace
 
@@ -69,7 +173,7 @@ std::shared_ptr<exec::VectorFunction> makeRLike(
     const core::QueryConfig& config) {
   // Return any errors from re2Search() first.
   auto result = makeRe2Search(name, inputArgs, config);
-  ensureRegexIsCompatible("RLIKE", inputArgs[1].constantValue);
+  ensureRegexIsConstant("RLIKE", inputArgs[1].constantValue);
   return result;
 }
 
@@ -78,8 +182,20 @@ std::shared_ptr<exec::VectorFunction> makeRegexExtract(
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config) {
   auto result = makeRe2Extract(name, inputArgs, config, /*emptyNoMatch=*/true);
-  ensureRegexIsCompatible("REGEXP_EXTRACT", inputArgs[1].constantValue);
+  ensureRegexIsConstant("REGEXP_EXTRACT", inputArgs[1].constantValue);
   return result;
 }
 
+void registerRegexpReplace(const std::string& prefix) {
+  registerFunction<RegexpReplaceFunction, Varchar, Varchar, Varchar, Varchar>(
+      {prefix + "regexp_replace"});
+  registerFunction<
+      RegexpReplaceFunction,
+      Varchar,
+      Varchar,
+      Varchar,
+      Varchar,
+      int32_t>({prefix + "regexp_replace"});
+}
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/RegexFunctions.h b/velox/functions/sparksql/RegexFunctions.h
index 895ee8e499d6f..3aae640132d7e 100644
--- a/velox/functions/sparksql/RegexFunctions.h
+++ b/velox/functions/sparksql/RegexFunctions.h
@@ -60,4 +60,18 @@ std::shared_ptr<exec::VectorFunction> makeRegexExtract(
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config);
 
+/// Full implementation of RegexReplace found in SparkSQL only,
+/// due to semantic mismatches betweeen Spark and Presto
+/// regexp_replace(string, pattern, overwrite) → string
+/// regexp_replace(string, pattern, overwrite, position) → string
+///
+/// If a string has a substring that matches the given pattern, replace
+/// the match in the string with overwrite and return the string. If
+/// optional parameter position is provided, only make replacements
+/// after that positon in the string (1 indexed).
+///
+/// If position <= 0, throw error.
+/// If position > length string, return string.
+void registerRegexpReplace(const std::string& prefix);
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Register.cpp b/velox/functions/sparksql/Register.cpp
index 6011eda92cd09..4e66c748998fa 100644
--- a/velox/functions/sparksql/Register.cpp
+++ b/velox/functions/sparksql/Register.cpp
@@ -16,27 +16,77 @@
 #include "velox/functions/sparksql/Register.h"
 
 #include "velox/expression/RegisterSpecialForm.h"
+#include "velox/expression/RowConstructor.h"
+#include "velox/expression/SpecialFormRegistry.h"
+#include "velox/functions/lib/ArrayShuffle.h"
 #include "velox/functions/lib/IsNull.h"
 #include "velox/functions/lib/Re2Functions.h"
 #include "velox/functions/lib/RegistrationHelpers.h"
+#include "velox/functions/lib/Repeat.h"
+#include "velox/functions/lib/Slice.h"
+#include "velox/functions/prestosql/ArrayFunctions.h"
+#include "velox/functions/prestosql/BinaryFunctions.h"
 #include "velox/functions/prestosql/DateTimeFunctions.h"
-#include "velox/functions/prestosql/JsonFunctions.h"
 #include "velox/functions/prestosql/StringFunctions.h"
+#include "velox/functions/prestosql/URLFunctions.h"
+#include "velox/functions/sparksql/ArrayFlattenFunction.h"
+#include "velox/functions/sparksql/ArrayInsert.h"
 #include "velox/functions/sparksql/ArrayMinMaxFunction.h"
 #include "velox/functions/sparksql/ArraySort.h"
 #include "velox/functions/sparksql/Bitwise.h"
 #include "velox/functions/sparksql/DateTimeFunctions.h"
 #include "velox/functions/sparksql/Hash.h"
 #include "velox/functions/sparksql/In.h"
+#include "velox/functions/sparksql/JsonObjectKeys.h"
 #include "velox/functions/sparksql/LeastGreatest.h"
+#include "velox/functions/sparksql/MaskFunction.h"
 #include "velox/functions/sparksql/MightContain.h"
+#include "velox/functions/sparksql/MonotonicallyIncreasingId.h"
+#include "velox/functions/sparksql/RaiseError.h"
 #include "velox/functions/sparksql/RegexFunctions.h"
 #include "velox/functions/sparksql/RegisterArithmetic.h"
 #include "velox/functions/sparksql/RegisterCompare.h"
 #include "velox/functions/sparksql/Size.h"
+#include "velox/functions/sparksql/SparkPartitionId.h"
+#include "velox/functions/sparksql/Split.h"
 #include "velox/functions/sparksql/String.h"
+#include "velox/functions/sparksql/StringToMap.h"
+#include "velox/functions/sparksql/UnscaledValueFunction.h"
+#include "velox/functions/sparksql/Uuid.h"
+#include "velox/functions/sparksql/specialforms/DecimalRound.h"
+#include "velox/functions/sparksql/specialforms/MakeDecimal.h"
+#include "velox/functions/sparksql/specialforms/SparkCastExpr.h"
 
 namespace facebook::velox::functions {
+extern void registerElementAtFunction(
+    const std::string& name,
+    bool enableCaching);
+
+template <typename T>
+inline void registerArrayRemoveFunctions(const std::string& prefix) {
+  registerFunction<ArrayRemoveFunction, Array<T>, Array<T>, T>(
+      {prefix + "array_remove"});
+}
+
+inline void registerArrayRemoveFunctions(const std::string& prefix) {
+  registerArrayRemoveFunctions<int8_t>(prefix);
+  registerArrayRemoveFunctions<int16_t>(prefix);
+  registerArrayRemoveFunctions<int32_t>(prefix);
+  registerArrayRemoveFunctions<int64_t>(prefix);
+  registerArrayRemoveFunctions<int128_t>(prefix);
+  registerArrayRemoveFunctions<float>(prefix);
+  registerArrayRemoveFunctions<double>(prefix);
+  registerArrayRemoveFunctions<bool>(prefix);
+  registerArrayRemoveFunctions<Timestamp>(prefix);
+  registerArrayRemoveFunctions<Date>(prefix);
+  registerArrayRemoveFunctions<Varbinary>(prefix);
+  registerArrayRemoveFunctions<Generic<T1>>(prefix);
+  registerFunction<
+      ArrayRemoveFunctionString,
+      Array<Varchar>,
+      Array<Varchar>,
+      Varchar>({prefix + "array_remove"});
+}
 
 static void workAroundRegistrationMacro(const std::string& prefix) {
   // VELOX_REGISTER_VECTOR_FUNCTION must be invoked in the same namespace as the
@@ -53,25 +103,51 @@ static void workAroundRegistrationMacro(const std::string& prefix) {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_contains, prefix + "array_contains");
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_array_intersect, prefix + "array_intersect");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_distinct, prefix + "array_distinct");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_except, prefix + "array_except");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_position, prefix + "array_position");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_zip_with, prefix + "zip_with");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_all_match, prefix + "forall");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_any_match, prefix + "exists");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_zip, prefix + "arrays_zip");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_map_entries, prefix + "map_entries");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_map_keys, prefix + "map_keys");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_map_values, prefix + "map_values");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_map_zip_with, prefix + "map_zip_with");
+
   // This is the semantics of spark.sql.ansi.enabled = false.
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_element_at, prefix + "element_at");
+  registerElementAtFunction(prefix + "element_at", true);
+
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_map_allow_duplicates, prefix + "map_from_arrays");
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_concat_row, exec::RowConstructorCallToSpecialForm::kRowConstructor);
   // String functions.
   VELOX_REGISTER_VECTOR_FUNCTION(udf_concat, prefix + "concat");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_lower, prefix + "lower");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_replace, prefix + "replace");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_upper, prefix + "upper");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_reverse, prefix + "reverse");
   // Logical.
   VELOX_REGISTER_VECTOR_FUNCTION(udf_not, prefix + "not");
   registerIsNullFunction(prefix + "isnull");
   registerIsNotNullFunction(prefix + "isnotnull");
+  registerArrayRemoveFunctions(prefix);
 }
 
 namespace sparksql {
 
 void registerAllSpecialFormGeneralFunctions() {
   exec::registerFunctionCallToSpecialForms();
+  exec::registerFunctionCallToSpecialForm(
+      MakeDecimalCallToSpecialForm::kMakeDecimal,
+      std::make_unique<MakeDecimalCallToSpecialForm>());
+  exec::registerFunctionCallToSpecialForm(
+      DecimalRoundCallToSpecialForm::kRoundDecimal,
+      std::make_unique<DecimalRoundCallToSpecialForm>());
+  registerFunctionCallToSpecialForm(
+      "cast", std::make_unique<SparkCastCallToSpecialForm>());
+  registerFunctionCallToSpecialForm(
+      "try_cast", std::make_unique<SparkTryCastCallToSpecialForm>());
 }
 
 namespace {
@@ -102,8 +178,10 @@ void registerFunctions(const std::string& prefix) {
   // Register size functions
   registerSize(prefix + "size");
 
-  registerFunction<JsonExtractScalarFunction, Varchar, Varchar, Varchar>(
-      {prefix + "get_json_object"});
+  registerRegexpReplace(prefix);
+
+  registerFunction<JsonObjectKeysFunction, Array<Varchar>, Varchar>(
+      {prefix + "json_object_keys"});
 
   // Register string functions.
   registerFunction<sparksql::ChrFunction, Varchar, int64_t>({prefix + "chr"});
@@ -139,40 +217,72 @@ void registerFunctions(const std::string& prefix) {
       int32_t,
       int32_t>({prefix + "overlay"});
 
+  registerFunction<
+      sparksql::StringToMapFunction,
+      Map<Varchar, Varchar>,
+      Varchar,
+      Varchar,
+      Varchar>({prefix + "str_to_map"});
+
   registerFunction<sparksql::LeftFunction, Varchar, Varchar, int32_t>(
       {prefix + "left"});
 
+  registerFunction<sparksql::BitLengthFunction, int32_t, Varchar>(
+      {prefix + "bit_length"});
+  registerFunction<sparksql::BitLengthFunction, int32_t, Varbinary>(
+      {prefix + "bit_length"});
+
   exec::registerStatefulVectorFunction(
       prefix + "instr", instrSignatures(), makeInstr);
   exec::registerStatefulVectorFunction(
       prefix + "length", lengthSignatures(), makeLength);
+  registerFunction<SubstringIndexFunction, Varchar, Varchar, Varchar, int32_t>(
+      {prefix + "substring_index"});
 
   registerFunction<Md5Function, Varchar, Varbinary>({prefix + "md5"});
   registerFunction<Sha1HexStringFunction, Varchar, Varbinary>(
       {prefix + "sha1"});
   registerFunction<Sha2HexStringFunction, Varchar, Varbinary, int32_t>(
       {prefix + "sha2"});
+  registerFunction<CRC32Function, int64_t, Varbinary>({prefix + "crc32"});
+  registerFunction<Empty2NullFunction, Varchar, Varchar>(
+      {prefix + "empty2null"});
 
   exec::registerStatefulVectorFunction(
       prefix + "regexp_extract", re2ExtractSignatures(), makeRegexExtract);
+  exec::registerStatefulVectorFunction(
+      prefix + "regexp_extract_all",
+      re2ExtractAllSignatures(),
+      makeRe2ExtractAll);
   exec::registerStatefulVectorFunction(
       prefix + "rlike", re2SearchSignatures(), makeRLike);
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_regexp_split, prefix + "split");
+  exec::registerStatefulVectorFunction(
+      prefix + "like", likeSignatures(), makeLike);
 
   exec::registerStatefulVectorFunction(
-      prefix + "least", leastSignatures(), makeLeast);
+      prefix + "least",
+      leastSignatures(),
+      makeLeast,
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
   exec::registerStatefulVectorFunction(
-      prefix + "greatest", greatestSignatures(), makeGreatest);
+      prefix + "greatest",
+      greatestSignatures(),
+      makeGreatest,
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
   exec::registerStatefulVectorFunction(
-      prefix + "hash", hashSignatures(), makeHash);
+      prefix + "hash", hashSignatures(), makeHash, hashMetadata());
   exec::registerStatefulVectorFunction(
-      prefix + "hash_with_seed", hashWithSeedSignatures(), makeHashWithSeed);
+      prefix + "hash_with_seed",
+      hashWithSeedSignatures(),
+      makeHashWithSeed,
+      hashMetadata());
   exec::registerStatefulVectorFunction(
-      prefix + "xxhash64", xxhash64Signatures(), makeXxHash64);
+      prefix + "xxhash64", xxhash64Signatures(), makeXxHash64, hashMetadata());
   exec::registerStatefulVectorFunction(
       prefix + "xxhash64_with_seed",
       xxhash64WithSeedSignatures(),
-      makeXxHash64WithSeed);
+      makeXxHash64WithSeed,
+      hashMetadata());
   VELOX_REGISTER_VECTOR_FUNCTION(udf_map, prefix + "map");
 
   // Register 'in' functions.
@@ -209,17 +319,61 @@ void registerFunctions(const std::string& prefix) {
   registerFunction<TranslateFunction, Varchar, Varchar, Varchar, Varchar>(
       {prefix + "translate"});
 
+  registerFunction<ConvFunction, Varchar, Varchar, int32_t, int32_t>(
+      {prefix + "conv"});
+
+  registerFunction<ReplaceFunction, Varchar, Varchar, Varchar>(
+      {prefix + "replace"});
+  registerFunction<ReplaceFunction, Varchar, Varchar, Varchar, Varchar>(
+      {prefix + "replace"});
+
+  registerFunction<FindInSetFunction, int32_t, Varchar, Varchar>(
+      {prefix + "find_in_set"});
+
+  registerFunction<UrlEncodeFunction, Varchar, Varchar>(
+      {prefix + "url_encode"});
+  registerFunction<UrlDecodeFunction, Varchar, Varchar>(
+      {prefix + "url_decode"});
+
   // Register array sort functions.
   exec::registerStatefulVectorFunction(
       prefix + "array_sort", arraySortSignatures(), makeArraySort);
   exec::registerStatefulVectorFunction(
       prefix + "sort_array", sortArraySignatures(), makeSortArray);
 
+  exec::registerStatefulVectorFunction(
+      prefix + "array_repeat",
+      repeatSignatures(),
+      makeRepeatAllowNegativeCount,
+      repeatMetadata());
+
+  registerIntegerSliceFunction(prefix);
+
+  exec::registerStatefulVectorFunction(
+      prefix + "shuffle",
+      arrayShuffleWithCustomSeedSignatures(),
+      makeArrayShuffleWithCustomSeed,
+      getMetadataForArrayShuffle());
+
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_get, prefix + "get");
+
   // Register date functions.
   registerFunction<YearFunction, int32_t, Timestamp>({prefix + "year"});
   registerFunction<YearFunction, int32_t, Date>({prefix + "year"});
   registerFunction<WeekFunction, int32_t, Timestamp>({prefix + "week_of_year"});
   registerFunction<WeekFunction, int32_t, Date>({prefix + "week_of_year"});
+  registerFunction<YearOfWeekFunction, int32_t, Date>(
+      {prefix + "year_of_week"});
+
+  registerFunction<ToUtcTimestampFunction, Timestamp, Timestamp, Varchar>(
+      {prefix + "to_utc_timestamp"});
+  registerFunction<FromUtcTimestampFunction, Timestamp, Timestamp, Varchar>(
+      {prefix + "from_utc_timestamp"});
+
+  registerFunction<UnixDateFunction, int32_t, Date>({prefix + "unix_date"});
+
+  registerFunction<UnixSecondsFunction, int64_t, Timestamp>(
+      {prefix + "unix_seconds"});
 
   registerFunction<UnixTimestampFunction, int64_t>({prefix + "unix_timestamp"});
 
@@ -230,34 +384,137 @@ void registerFunctions(const std::string& prefix) {
       int64_t,
       Varchar,
       Varchar>({prefix + "unix_timestamp", prefix + "to_unix_timestamp"});
+  registerFunction<FromUnixtimeFunction, Varchar, int64_t, Varchar>(
+      {prefix + "from_unixtime"});
   registerFunction<MakeDateFunction, Date, int32_t, int32_t, int32_t>(
       {prefix + "make_date"});
   registerFunction<DateDiffFunction, int32_t, Date, Date>(
       {prefix + "datediff"});
   registerFunction<LastDayFunction, Date, Date>({prefix + "last_day"});
+  registerFunction<AddMonthsFunction, Date, Date, int32_t>(
+      {prefix + "add_months"});
 
+  registerFunction<DateAddFunction, Date, Date, int8_t>({prefix + "date_add"});
+  registerFunction<DateAddFunction, Date, Date, int16_t>({prefix + "date_add"});
   registerFunction<DateAddFunction, Date, Date, int32_t>({prefix + "date_add"});
+
+  registerFunction<DateFromUnixDateFunction, Date, int32_t>(
+      {prefix + "date_from_unix_date"});
+
+  registerFunction<DateSubFunction, Date, Date, int8_t>({prefix + "date_sub"});
+  registerFunction<DateSubFunction, Date, Date, int16_t>({prefix + "date_sub"});
   registerFunction<DateSubFunction, Date, Date, int32_t>({prefix + "date_sub"});
 
-  registerFunction<DayFunction, int64_t, Timestamp>(
+  registerFunction<DayFunction, int32_t, Date>(
       {prefix + "day", prefix + "dayofmonth"});
-  registerFunction<DayFunction, int64_t, Date>(
-      {prefix + "day", prefix + "dayofmonth"});
-  registerFunction<DayOfYearFunction, int64_t, Timestamp>(
-      {prefix + "doy", prefix + "dayofyear"});
-  registerFunction<DayOfYearFunction, int64_t, Date>(
+  registerFunction<DayOfYearFunction, int32_t, Date>(
       {prefix + "doy", prefix + "dayofyear"});
 
-  registerFunction<DayOfWeekFunction, int32_t, Timestamp>(
-      {prefix + "dow", prefix + "dayofweek"});
-  registerFunction<DayOfWeekFunction, int32_t, Date>(
-      {prefix + "dow", prefix + "dayofweek"});
+  registerFunction<DayOfWeekFunction, int32_t, Date>({prefix + "dayofweek"});
+
+  registerFunction<WeekdayFunction, int32_t, Date>({prefix + "weekday"});
+
+  registerFunction<QuarterFunction, int32_t, Date>({prefix + "quarter"});
+
+  registerFunction<MonthFunction, int32_t, Date>({prefix + "month"});
+
+  registerFunction<NextDayFunction, Date, Date, Varchar>({prefix + "next_day"});
+
+  registerFunction<GetTimestampFunction, Timestamp, Varchar, Varchar>(
+      {prefix + "get_timestamp"});
+
+  registerFunction<HourFunction, int32_t, Timestamp>({prefix + "hour"});
+
+  registerFunction<MinuteFunction, int32_t, Timestamp>({prefix + "minute"});
+
+  registerFunction<SecondFunction, int32_t, Timestamp>({prefix + "second"});
+
+  registerFunction<MakeYMIntervalFunction, IntervalYearMonth>(
+      {prefix + "make_ym_interval"});
+  registerFunction<MakeYMIntervalFunction, IntervalYearMonth, int32_t>(
+      {prefix + "make_ym_interval"});
+  registerFunction<MakeYMIntervalFunction, IntervalYearMonth, int32_t, int32_t>(
+      {prefix + "make_ym_interval"});
+
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_make_timestamp, prefix + "make_timestamp");
+
+  registerFunction<TimestampToMicrosFunction, int64_t, Timestamp>(
+      {prefix + "unix_micros"});
+  registerUnaryIntegralWithTReturn<MicrosToTimestampFunction, Timestamp>(
+      {prefix + "timestamp_micros"});
+  registerFunction<TimestampToMillisFunction, int64_t, Timestamp>(
+      {prefix + "unix_millis"});
+  registerUnaryIntegralWithTReturn<MillisToTimestampFunction, Timestamp>(
+      {prefix + "timestamp_millis"});
 
   // Register bloom filter function
   registerFunction<BloomFilterMightContainFunction, bool, Varbinary, int64_t>(
       {prefix + "might_contain"});
 
   registerArrayMinMaxFunctions(prefix);
+
+  // Register decimal vector functions.
+  exec::registerVectorFunction(
+      prefix + "unscaled_value",
+      unscaledValueSignatures(),
+      makeUnscaledValue());
+
+  registerFunction<SparkPartitionIdFunction, int32_t>(
+      {prefix + "spark_partition_id"});
+
+  registerFunction<MonotonicallyIncreasingIdFunction, int64_t>(
+      {prefix + "monotonically_increasing_id"});
+
+  registerFunction<UuidFunction, Varchar, Constant<int64_t>>({prefix + "uuid"});
+
+  registerFunction<
+      ArrayFlattenFunction,
+      Array<Generic<T1>>,
+      Array<Array<Generic<T1>>>>({prefix + "flatten"});
+
+  registerFunction<RepeatFunction, Varchar, Varchar, int32_t>(
+      {prefix + "repeat"});
+
+  registerFunction<SoundexFunction, Varchar, Varchar>({prefix + "soundex"});
+
+  registerFunction<RaiseErrorFunction, UnknownValue, Varchar>(
+      {prefix + "raise_error"});
+
+  registerFunction<
+      LevenshteinDistanceFunction,
+      int32_t,
+      Varchar,
+      Varchar,
+      int32_t>({prefix + "levenshtein"});
+  registerFunction<LevenshteinDistanceFunction, int32_t, Varchar, Varchar>(
+      {prefix + "levenshtein"});
+
+  registerFunction<
+      ArrayInsert,
+      Array<Generic<T1>>,
+      Array<Generic<T1>>,
+      int32_t,
+      Generic<T1>,
+      bool>({prefix + "array_insert"});
+
+  registerFunction<Split, Array<Varchar>, Varchar, Varchar>({prefix + "split"});
+  registerFunction<Split, Array<Varchar>, Varchar, Varchar, int32_t>(
+      {prefix + "split"});
+
+  registerFunction<MaskFunction, Varchar, Varchar>({prefix + "mask"});
+  registerFunction<MaskFunction, Varchar, Varchar, Varchar>({prefix + "mask"});
+  registerFunction<MaskFunction, Varchar, Varchar, Varchar, Varchar>(
+      {prefix + "mask"});
+  registerFunction<MaskFunction, Varchar, Varchar, Varchar, Varchar, Varchar>(
+      {prefix + "mask"});
+  registerFunction<
+      MaskFunction,
+      Varchar,
+      Varchar,
+      Varchar,
+      Varchar,
+      Varchar,
+      Varchar>({prefix + "mask"});
 }
 
 } // namespace sparksql
diff --git a/velox/functions/sparksql/RegisterArithmetic.cpp b/velox/functions/sparksql/RegisterArithmetic.cpp
index 78d024b377f2e..c2a820d36ee6d 100644
--- a/velox/functions/sparksql/RegisterArithmetic.cpp
+++ b/velox/functions/sparksql/RegisterArithmetic.cpp
@@ -16,32 +16,18 @@
 #include "velox/functions/sparksql/RegisterArithmetic.h"
 #include "velox/functions/lib/RegistrationHelpers.h"
 #include "velox/functions/prestosql/Arithmetic.h"
-#include "velox/functions/prestosql/CheckedArithmetic.h"
 #include "velox/functions/sparksql/Arithmetic.h"
+#include "velox/functions/sparksql/DecimalArithmetic.h"
 #include "velox/functions/sparksql/Rand.h"
 
 namespace facebook::velox::functions::sparksql {
 
 void registerRandFunctions(const std::string& prefix) {
   registerFunction<RandFunction, double>({prefix + "rand", prefix + "random"});
-  // Has seed & partition index as input.
-  registerFunction<
-      RandFunction,
-      double,
-      int32_t /*seed*/,
-      int32_t /*partition index*/>({prefix + "rand", prefix + "random"});
-  // Has seed & partition index as input.
-  registerFunction<
-      RandFunction,
-      double,
-      int64_t /*seed*/,
-      int32_t /*partition index*/>({prefix + "rand", prefix + "random"});
-  // NULL constant as seed of unknown type.
-  registerFunction<
-      RandFunction,
-      double,
-      UnknownValue /*seed*/,
-      int32_t /*partition index*/>({prefix + "rand", prefix + "random"});
+  registerFunction<RandFunction, double, Constant<int32_t>>(
+      {prefix + "rand", prefix + "random"});
+  registerFunction<RandFunction, double, Constant<int64_t>>(
+      {prefix + "rand", prefix + "random"});
 }
 
 void registerArithmeticFunctions(const std::string& prefix) {
@@ -50,25 +36,44 @@ void registerArithmeticFunctions(const std::string& prefix) {
   registerBinaryNumeric<MinusFunction>({prefix + "subtract"});
   registerBinaryNumeric<MultiplyFunction>({prefix + "multiply"});
   registerFunction<DivideFunction, double, double, double>({prefix + "divide"});
-  registerBinaryIntegral<RemainderFunction>({prefix + "remainder"});
+  registerBinaryNumeric<RemainderFunction>({prefix + "remainder"});
   registerUnaryNumeric<UnaryMinusFunction>({prefix + "unaryminus"});
   // Math functions.
   registerUnaryNumeric<AbsFunction>({prefix + "abs"});
+  registerFunction<
+      DecimalAbsFunction,
+      LongDecimal<P1, S1>,
+      LongDecimal<P1, S1>>({prefix + "abs"});
+  registerFunction<
+      DecimalAbsFunction,
+      ShortDecimal<P1, S1>,
+      ShortDecimal<P1, S1>>({prefix + "abs"});
   registerFunction<AcosFunction, double, double>({prefix + "acos"});
+  registerFunction<AsinFunction, double, double>({prefix + "asin"});
   registerFunction<AcoshFunction, double, double>({prefix + "acosh"});
   registerFunction<AsinhFunction, double, double>({prefix + "asinh"});
+  registerFunction<AtanFunction, double, double>({prefix + "atan"});
   registerFunction<AtanhFunction, double, double>({prefix + "atanh"});
   registerFunction<SecFunction, double, double>({prefix + "sec"});
   registerFunction<CscFunction, double, double>({prefix + "csc"});
   registerFunction<SinhFunction, double, double>({prefix + "sinh"});
+  registerFunction<CosFunction, double, double>({prefix + "cos"});
   registerFunction<CoshFunction, double, double>({prefix + "cosh"});
   registerFunction<CotFunction, double, double>({prefix + "cot"});
+  registerFunction<DegreesFunction, double, double>({prefix + "degrees"});
+  registerFunction<Atan2Function, double, double, double>({prefix + "atan2"});
   registerFunction<Log1pFunction, double, double>({prefix + "log1p"});
   registerFunction<ToBinaryStringFunction, Varchar, int64_t>({prefix + "bin"});
+  registerFunction<ToHexBigintFunction, Varchar, int64_t>({prefix + "hex"});
+  registerFunction<ToHexVarcharFunction, Varchar, Varchar>({prefix + "hex"});
+  registerFunction<ToHexVarbinaryFunction, Varchar, Varbinary>(
+      {prefix + "hex"});
   registerFunction<ExpFunction, double, double>({prefix + "exp"});
+  registerFunction<Expm1Function, double, double>({prefix + "expm1"});
   registerBinaryIntegral<PModIntFunction>({prefix + "pmod"});
   registerBinaryFloatingPoint<PModFloatFunction>({prefix + "pmod"});
   registerFunction<PowerFunction, double, double, double>({prefix + "power"});
+  registerFunction<RIntFunction, double, double>({prefix + "rint"});
   registerUnaryNumeric<RoundFunction>({prefix + "round"});
   registerFunction<RoundFunction, int8_t, int8_t, int32_t>({prefix + "round"});
   registerFunction<RoundFunction, int16_t, int16_t, int32_t>(
@@ -79,6 +84,7 @@ void registerArithmeticFunctions(const std::string& prefix) {
       {prefix + "round"});
   registerFunction<RoundFunction, double, double, int32_t>({prefix + "round"});
   registerFunction<RoundFunction, float, float, int32_t>({prefix + "round"});
+  registerFunction<UnHexFunction, Varbinary, Varchar>({prefix + "unhex"});
   // In Spark only long, double, and decimal have ceil/floor
   registerFunction<sparksql::CeilFunction, int64_t, int64_t>({prefix + "ceil"});
   registerFunction<sparksql::CeilFunction, int64_t, double>({prefix + "ceil"});
@@ -89,7 +95,28 @@ void registerArithmeticFunctions(const std::string& prefix) {
   registerFunction<HypotFunction, double, double, double>({prefix + "hypot"});
   registerFunction<sparksql::Log2Function, double, double>({prefix + "log2"});
   registerFunction<sparksql::Log10Function, double, double>({prefix + "log10"});
+  registerFunction<sparksql::LogarithmFunction, double, double, double>(
+      {prefix + "log"});
+  registerFunction<
+      WidthBucketFunction,
+      int64_t,
+      double,
+      double,
+      double,
+      int64_t>({prefix + "width_bucket"});
   registerRandFunctions(prefix);
+
+  registerDecimalAdd(prefix);
+  registerDecimalSubtract(prefix);
+  registerDecimalMultiply(prefix);
+  registerDecimalDivide(prefix);
+  registerFunction<sparksql::IsNanFunction, bool, float>({prefix + "isnan"});
+  registerFunction<sparksql::IsNanFunction, bool, double>({prefix + "isnan"});
+
+  registerBinaryNumeric<CheckedAddFunction>({prefix + "checked_add"});
+  registerBinaryNumeric<CheckedSubtractFunction>({prefix + "checked_subtract"});
+  registerBinaryNumeric<CheckedMultiplyFunction>({prefix + "checked_multiply"});
+  registerBinaryNumeric<CheckedDivideFunction>({prefix + "checked_divide"});
 }
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/RegisterCompare.cpp b/velox/functions/sparksql/RegisterCompare.cpp
index 5f14010afee23..f9d3f7e2af135 100644
--- a/velox/functions/sparksql/RegisterCompare.cpp
+++ b/velox/functions/sparksql/RegisterCompare.cpp
@@ -23,6 +23,8 @@ namespace facebook::velox::functions::sparksql {
 void registerCompareFunctions(const std::string& prefix) {
   exec::registerStatefulVectorFunction(
       prefix + "equalto", comparisonSignatures(), makeEqualTo);
+  registerFunction<EqualToFunction, bool, Generic<T1>, Generic<T1>>(
+      {prefix + "equalto"});
   exec::registerStatefulVectorFunction(
       prefix + "lessthan", comparisonSignatures(), makeLessThan);
   exec::registerStatefulVectorFunction(
@@ -35,7 +37,12 @@ void registerCompareFunctions(const std::string& prefix) {
       makeGreaterThanOrEqual);
   // Compare nullsafe functions.
   exec::registerStatefulVectorFunction(
-      prefix + "equalnullsafe", equalNullSafeSignatures(), makeEqualToNullSafe);
+      prefix + "equalnullsafe",
+      comparisonSignatures(),
+      makeEqualToNullSafe,
+      exec::VectorFunctionMetadataBuilder().defaultNullBehavior(false).build());
+  registerFunction<EqualNullSafeFunction, bool, Generic<T1>, Generic<T1>>(
+      {prefix + "equalnullsafe"});
   registerFunction<BetweenFunction, bool, int8_t, int8_t, int8_t>(
       {prefix + "between"});
   registerFunction<BetweenFunction, bool, int16_t, int16_t, int16_t>(
@@ -50,6 +57,17 @@ void registerCompareFunctions(const std::string& prefix) {
       {prefix + "between"});
   registerFunction<BetweenFunction, bool, double, double, double>(
       {prefix + "between"});
+  // Decimal comapre functions.
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_decimal_gt, prefix + "decimal_greaterthan");
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_decimal_gte, prefix + "decimal_greaterthanorequal");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_lt, prefix + "decimal_lessthan");
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_decimal_lte, prefix + "decimal_lessthanorequal");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_decimal_eq, prefix + "decimal_equalto");
+  VELOX_REGISTER_VECTOR_FUNCTION(
+      udf_decimal_neq, prefix + "decimal_notequalto");
 }
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Size.cpp b/velox/functions/sparksql/Size.cpp
index c4653f963cf33..70d7d3d509d2d 100644
--- a/velox/functions/sparksql/Size.cpp
+++ b/velox/functions/sparksql/Size.cpp
@@ -29,33 +29,41 @@ struct Size {
 
   template <typename TInput>
   FOLLY_ALWAYS_INLINE void initialize(
-      const core::QueryConfig& config,
-      const TInput* input /*input*/) {
-    legacySizeOfNull_ = config.sparkLegacySizeOfNull();
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const TInput* /*input*/,
+      const bool* legacySizeOfNull) {
+    if (legacySizeOfNull == nullptr) {
+      VELOX_USER_FAIL("Constant legacySizeOfNull is expected.");
+    }
+    legacySizeOfNull_ = *legacySizeOfNull;
   }
 
   template <typename TInput>
-  FOLLY_ALWAYS_INLINE bool callNullable(int32_t& out, const TInput* input) {
+  FOLLY_ALWAYS_INLINE bool callNullable(
+      int32_t& out,
+      const TInput* input,
+      const bool* /*legacySizeOfNull*/) {
     if (input == nullptr) {
       if (legacySizeOfNull_) {
         out = -1;
         return true;
-      } else {
-        return false;
       }
+      return false;
     }
     out = input->size();
     return true;
   }
 
  private:
+  // If true, returns -1 for null input. Otherwise, returns null.
   bool legacySizeOfNull_;
 };
 } // namespace
 
 void registerSize(const std::string& prefix) {
-  registerFunction<Size, int32_t, Array<Any>>({prefix});
-  registerFunction<Size, int32_t, Map<Any, Any>>({prefix});
+  registerFunction<Size, int32_t, Array<Any>, bool>({prefix});
+  registerFunction<Size, int32_t, Map<Any, Any>, bool>({prefix});
 }
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/SparkPartitionId.h b/velox/functions/sparksql/SparkPartitionId.h
new file mode 100644
index 0000000000000..32594070be50d
--- /dev/null
+++ b/velox/functions/sparksql/SparkPartitionId.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+
+namespace facebook::velox::functions::sparksql {
+
+template <typename T>
+struct SparkPartitionIdFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config) {
+    partitionId_ = config.sparkPartitionId();
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result) {
+    result = partitionId_;
+  }
+
+ private:
+  int32_t partitionId_;
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Split.h b/velox/functions/sparksql/Split.h
new file mode 100644
index 0000000000000..86fdde503ceda
--- /dev/null
+++ b/velox/functions/sparksql/Split.h
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/lib/Utf8Utils.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// split(string, delimiter[, limit]) -> array(varchar)
+///
+/// Splits string on delimiter and returns an array of size at most limit.
+/// delimiter is a string representing regular expression.
+/// limit is an integer which controls the number of times the regex is applied.
+/// By default, limit is -1, which means 'no limit', the delimiter will be
+/// applied as many times as possible.
+template <typename T>
+struct Split {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Results refer to strings in the first argument.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Array<Varchar>>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& delimiter) {
+    doCall(result, input, delimiter, INT32_MAX);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Array<Varchar>>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& delimiter,
+      const arg_type<int32_t>& limit) {
+    doCall(result, input, delimiter, limit > 0 ? limit : INT32_MAX);
+  }
+
+ private:
+  void doCall(
+      out_type<Array<Varchar>>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& delimiter,
+      int32_t limit) const {
+    if (delimiter.empty()) {
+      splitEmptyDelimiter(result, input, limit);
+    } else {
+      split(result, input, delimiter, limit);
+    }
+  }
+
+  // When pattern is empty, split each character out. Since Spark 3.4, when
+  // delimiter is empty, the result does not include an empty tail string, e.g.
+  // split('abc', '') outputs ["a", "b", "c"] instead of ["a", "b", "c", ""].
+  // The result does not include remaining string when limit is smaller than the
+  // string size, e.g. split('abc', '', 2) outputs ["a", "b"] instead of ["a",
+  // "bc"].
+  void splitEmptyDelimiter(
+      out_type<Array<Varchar>>& result,
+      const arg_type<Varchar>& input,
+      int32_t limit) const {
+    if (input.size() == 0) {
+      result.add_item().setNoCopy(StringView());
+      return;
+    }
+
+    const size_t end = input.size();
+    const char* start = input.data();
+    size_t pos = 0;
+    int32_t count = 0;
+    while (pos < end && count < limit) {
+      auto charLength = tryGetCharLength(start + pos, end - pos);
+      if (charLength <= 0) {
+        // Invalid UTF-8 character, the length of the invalid
+        // character is the absolute value of result of `tryGetCharLength`.
+        charLength = -charLength;
+      }
+      result.add_item().setNoCopy(StringView(start + pos, charLength));
+      pos += charLength;
+      count += 1;
+    }
+  }
+
+  // Split with a non-empty delimiter. If limit > 0, The resulting array's
+  // length will not be more than limit and the resulting array's last entry
+  // will contain all input beyond the last matched regex. If limit <= 0,
+  // delimiter will be applied as many times as possible, and the resulting
+  // array can be of any size.
+  void split(
+      out_type<Array<Varchar>>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& delimiter,
+      int32_t limit) const {
+    VELOX_DCHECK(!delimiter.empty(), "Non-empty delimiter is expected");
+
+    // Trivial case of converting string to array with 1 element.
+    if (limit == 1) {
+      result.add_item().setNoCopy(input);
+      return;
+    }
+
+    // Splits input string using the delimiter and adds the cutting-off pieces
+    // to elements vector until the string's end or the limit is reached.
+    int32_t addedElements{0};
+    auto* re = cache_.findOrCompile(delimiter);
+    const size_t end = input.size();
+    const char* start = input.data();
+    const auto re2String = re2::StringPiece(start, end);
+    size_t pos = 0;
+
+    re2::StringPiece subMatches[1];
+    // Matches a regular expression against a portion of the input string,
+    // starting from 'pos' to the end of the input string. The match is not
+    // anchored, which means it can start at any position in the string. If a
+    // match is found, the matched portion of the string is stored in
+    // 'subMatches'. The '1' indicates that we are only interested in the first
+    // match found from the current position 'pos' in each iteration of the
+    // loop.
+    while (re->Match(
+        re2String, pos, end, RE2::Anchor::UNANCHORED, subMatches, 1)) {
+      const auto fullMatch = subMatches[0];
+      auto offset = fullMatch.data() - start;
+      const auto size = fullMatch.size();
+      if (offset >= end) {
+        break;
+      }
+
+      // When hitting an empty match, split the character at the current 'pos'
+      // of the input string and put it into the result array, followed by an
+      // empty tail string at last, e.g., the result array for split('abc','d|')
+      // is ["a","b","c",""].
+      if (size == 0) {
+        auto charLength = tryGetCharLength(start + pos, end - pos);
+        if (charLength <= 0) {
+          // Invalid UTF-8 character, the length of the invalid
+          // character is the absolute value of result of `tryGetCharLength`.
+          charLength = -charLength;
+        }
+        offset += charLength;
+      }
+      result.add_item().setNoCopy(StringView(start + pos, offset - pos));
+      pos = offset + size;
+
+      ++addedElements;
+      // If the next element should be the last, leave the loop.
+      if (addedElements + 1 == limit) {
+        break;
+      }
+    }
+
+    // Add the rest of the string and we are done.
+    // Note that the rest of the string can be empty - we still add it.
+    result.add_item().setNoCopy(StringView(start + pos, end - pos));
+  }
+
+  mutable detail::ReCache cache_;
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/SplitFunctions.cpp b/velox/functions/sparksql/SplitFunctions.cpp
deleted file mode 100644
index 4d092e6928373..0000000000000
--- a/velox/functions/sparksql/SplitFunctions.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <utility>
-
-#include "velox/expression/VectorFunction.h"
-#include "velox/expression/VectorWriters.h"
-
-namespace facebook::velox::functions::sparksql {
-namespace {
-
-/// This class only implements the basic split version in which the pattern is a
-/// single character
-class SplitCharacter final : public exec::VectorFunction {
- public:
-  explicit SplitCharacter(const char pattern) : pattern_{pattern} {
-    static constexpr std::string_view kRegexChars = ".$|()[{^?*+\\";
-    VELOX_CHECK(
-        kRegexChars.find(pattern) == std::string::npos,
-        "This version of split supports single-length non-regex patterns");
-  }
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /* outputType */,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    exec::LocalDecodedVector input(context, *args[0], rows);
-
-    BaseVector::ensureWritable(rows, ARRAY(VARCHAR()), context.pool(), result);
-    exec::VectorWriter<Array<Varchar>> resultWriter;
-    resultWriter.init(*result->as<ArrayVector>());
-
-    rows.applyToSelected([&](vector_size_t row) {
-      resultWriter.setOffset(row);
-      auto& arrayWriter = resultWriter.current();
-
-      const StringView& current = input->valueAt<StringView>(row);
-      const char* pos = current.begin();
-      const char* end = pos + current.size();
-      const char* delim;
-      do {
-        delim = std::find(pos, end, pattern_);
-        arrayWriter.add_item().setNoCopy(StringView(pos, delim - pos));
-        pos = delim + 1; // Skip past delim.
-      } while (delim != end);
-
-      resultWriter.commit();
-    });
-
-    resultWriter.finish();
-
-    // Reference the input StringBuffers since we did not deep copy above.
-    result->as<ArrayVector>()
-        ->elements()
-        ->as<FlatVector<StringView>>()
-        ->acquireSharedStringBuffers(args[0].get());
-  }
-
- private:
-  const char pattern_;
-};
-
-/// This class will be updated in the future as we support more variants of
-/// split
-class Split final : public exec::VectorFunction {
- public:
-  Split() {}
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /* outputType */,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    auto delimiterVector = args[1]->as<ConstantVector<StringView>>();
-    VELOX_CHECK(
-        delimiterVector, "Split function supports only constant delimiter");
-    auto patternString = args[1]->as<ConstantVector<StringView>>()->valueAt(0);
-    VELOX_CHECK_EQ(
-        patternString.size(),
-        1,
-        "split only supports only single-character pattern");
-    char pattern = patternString.data()[0];
-    SplitCharacter splitCharacter(pattern);
-    splitCharacter.apply(rows, args, nullptr, context, result);
-  }
-};
-
-/// The function returns specialized version of split based on the constant
-/// inputs.
-/// \param inputArgs the inputs types (VARCHAR, VARCHAR, int64) and constant
-///     values (if provided).
-std::shared_ptr<exec::VectorFunction> createSplit(
-    const std::string& /*name*/,
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  BaseVector* constantPattern = inputArgs[1].constantValue.get();
-
-  if (inputArgs.size() > 3 || inputArgs[0].type->isVarchar() ||
-      inputArgs[1].type->isVarchar() || (constantPattern == nullptr)) {
-    return std::make_shared<Split>();
-  }
-  auto pattern = constantPattern->as<ConstantVector<StringView>>()->valueAt(0);
-  if (pattern.size() != 1) {
-    return std::make_shared<Split>();
-  }
-  char charPattern = pattern.data()[0];
-  // TODO: Add support for zero-length pattern, 2-character pattern
-  // TODO: add support for general regex pattern using R2
-  return std::make_shared<SplitCharacter>(charPattern);
-}
-
-std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-  // varchar, varchar -> array(varchar)
-  return {exec::FunctionSignatureBuilder()
-              .returnType("array(varchar)")
-              .argumentType("varchar")
-              .constantArgumentType("varchar")
-              .build()};
-}
-
-} // namespace
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_regexp_split,
-    signatures(),
-    createSplit);
-} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/String.h b/velox/functions/sparksql/String.h
index 39c3157b71252..72f106250c8b4 100644
--- a/velox/functions/sparksql/String.h
+++ b/velox/functions/sparksql/String.h
@@ -15,14 +15,14 @@
  */
 #pragma once
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #include "folly/ssl/OpenSSLHash.h"
-#pragma GCC diagnostic pop
 
+#include <codecvt>
+#include <string>
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/UDFOutputString.h"
+#include "velox/functions/lib/string/StringCore.h"
 #include "velox/functions/lib/string/StringImpl.h"
 
 namespace facebook::velox::functions::sparksql {
@@ -91,6 +91,16 @@ struct AsciiFunction {
   }
 };
 
+template <typename T>
+struct BitLengthFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, TInput& input) {
+    result = input.size() * 8;
+  }
+};
+
 /// chr function
 /// chr(n) -> string
 /// Returns the Unicode code point ``n`` as a single character string.
@@ -283,6 +293,60 @@ struct EndsWithFunction {
   }
 };
 
+/// Returns the substring from str before count occurrences of the delimiter
+/// delim. If count is positive, everything to the left of the final delimiter
+/// (counting from the left) is returned. If count is negative, everything to
+/// the right of the final delimiter (counting from the right) is returned. The
+/// function substring_index performs a case-sensitive match when searching for
+/// delim.
+template <typename T>
+struct SubstringIndexFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Results refer to strings in the first argument.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  // ASCII input always produces ASCII result.
+  static constexpr bool is_default_ascii_behavior = true;
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& str,
+      const arg_type<Varchar>& delim,
+      const int32_t& count) {
+    if (count == 0) {
+      result.setEmpty();
+      return;
+    }
+
+    int64_t index;
+    if (count > 0) {
+      index = stringImpl::stringPosition<true, true>(str, delim, count);
+    } else {
+      index = stringImpl::stringPosition<true, false>(str, delim, -count);
+    }
+
+    // If 'delim' is not found or found fewer than 'count' times,
+    // return the input string directly.
+    if (index == 0) {
+      result.setNoCopy(str);
+      return;
+    }
+
+    auto start = 0;
+    auto length = str.size();
+    const auto delimLength = delim.size();
+    if (count > 0) {
+      length = index - 1;
+    } else {
+      start = index + delimLength - 1;
+      length -= start;
+    }
+
+    result.setNoCopy(StringView(str.data() + start, length));
+  }
+};
+
 /// ltrim(trimStr, srcStr) -> varchar
 ///     Remove leading specified characters from srcStr. The specified character
 ///     is any character contained in trimStr.
@@ -512,8 +576,8 @@ struct SubstrFunction {
       return;
     }
 
-    auto byteRange =
-        stringCore::getByteRange<isAscii>(input.data(), start, length);
+    auto byteRange = stringCore::getByteRange<isAscii>(
+        input.data(), input.size(), start, length);
 
     // Generating output string
     result.setNoCopy(StringView(
@@ -559,7 +623,7 @@ struct OverlayFunctionBase {
       std::pair<int32_t, int32_t> pair) {
     if constexpr (isVarchar && !isAscii) {
       auto byteRange = stringCore::getByteRange<false>(
-          input.data(), pair.first + 1, pair.second);
+          input.data(), input.size(), pair.first + 1, pair.second);
       result.append(StringView(
           input.data() + byteRange.first, byteRange.second - byteRange.first));
     } else {
@@ -695,8 +759,8 @@ struct LeftFunction {
 
     int32_t start = 1;
 
-    auto byteRange =
-        stringCore::getByteRange<isAscii>(input.data(), start, length);
+    auto byteRange = stringCore::getByteRange<isAscii>(
+        input.data(), input.size(), start, length);
 
     // Generating output string
     result.setNoCopy(StringView(
@@ -718,54 +782,8 @@ struct TranslateFunction {
   // ASCII input always produces ASCII result.
   static constexpr bool is_default_ascii_behavior = true;
 
-  std::optional<folly::F14FastMap<std::string, std::string>> unicodeDictionary_;
-  std::optional<folly::F14FastMap<char, char>> asciiDictionary_;
-
-  bool isConstantDictionary_ = false;
-
-  folly::F14FastMap<std::string, std::string> buildUnicodeDictionary(
-      const arg_type<Varchar>& match,
-      const arg_type<Varchar>& replace) {
-    folly::F14FastMap<std::string, std::string> dictionary;
-    int i = 0;
-    int j = 0;
-    while (i < match.size()) {
-      std::string replaceChar;
-      // If match's character size is larger than replace's, the extra
-      // characters in match will be removed from input string.
-      if (j < replace.size()) {
-        int replaceCharLength = utf8proc_char_length(replace.data() + j);
-        replaceChar = std::string(replace.data() + j, replaceCharLength);
-        j += replaceCharLength;
-      }
-      int matchCharLength = utf8proc_char_length(match.data() + i);
-      std::string matchChar = std::string(match.data() + i, matchCharLength);
-      // Only considers the first occurrence of a character in match.
-      dictionary.emplace(matchChar, replaceChar);
-      i += matchCharLength;
-    }
-    return dictionary;
-  }
-
-  folly::F14FastMap<char, char> buildAsciiDictionary(
-      const arg_type<Varchar>& match,
-      const arg_type<Varchar>& replace) {
-    folly::F14FastMap<char, char> dictionary;
-    int i = 0;
-    for (; i < std::min(match.size(), replace.size()); i++) {
-      char matchChar = *(match.data() + i);
-      char replaceChar = *(replace.data() + i);
-      // Only consider the first occurrence of a character in match.
-      dictionary.emplace(matchChar, replaceChar);
-    }
-    for (; i < match.size(); i++) {
-      char matchChar = *(match.data() + i);
-      dictionary.emplace(matchChar, '\0');
-    }
-    return dictionary;
-  }
-
   FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& /*config*/,
       const arg_type<Varchar>* /*string*/,
       const arg_type<Varchar>* match,
@@ -793,7 +811,7 @@ struct TranslateFunction {
     int i = 0;
     int k = 0;
     while (k < input.size()) {
-      int inputCharLength = utf8proc_char_length(input.data() + k);
+      int inputCharLength = getUtf8CharLength(input, k);
       auto inputChar = std::string(input.data() + k, inputCharLength);
       auto it = unicodeDictionary_->find(inputChar);
       if (it == unicodeDictionary_->end()) {
@@ -843,6 +861,606 @@ struct TranslateFunction {
     }
     result.resize(i);
   }
+
+ private:
+  // Returns the length of a UTF-8 character starting at 'offset'. Returns 1
+  // for invalid UTF-8 character.
+  FOLLY_ALWAYS_INLINE int32_t
+  getUtf8CharLength(const arg_type<Varchar>& input, int32_t offset) {
+    return std::min<int32_t>(
+        std::abs(utf8proc_char_length(input.data() + offset)),
+        input.size() - offset);
+  }
+
+  folly::F14FastMap<std::string, std::string> buildUnicodeDictionary(
+      const arg_type<Varchar>& match,
+      const arg_type<Varchar>& replace) {
+    folly::F14FastMap<std::string, std::string> dictionary;
+    int i = 0;
+    int j = 0;
+    while (i < match.size()) {
+      std::string replaceChar;
+      // If match's character size is larger than replace's, the extra
+      // characters in match will be removed from input string.
+      if (j < replace.size()) {
+        int replaceCharLength = getUtf8CharLength(replace, j);
+        replaceChar = std::string(replace.data() + j, replaceCharLength);
+        j += replaceCharLength;
+      }
+      int matchCharLength = getUtf8CharLength(match, i);
+      std::string matchChar = std::string(match.data() + i, matchCharLength);
+      // Only considers the first occurrence of a character in match.
+      dictionary.emplace(matchChar, replaceChar);
+      i += matchCharLength;
+    }
+    return dictionary;
+  }
+
+  folly::F14FastMap<char, char> buildAsciiDictionary(
+      const arg_type<Varchar>& match,
+      const arg_type<Varchar>& replace) {
+    folly::F14FastMap<char, char> dictionary;
+    int i = 0;
+    for (; i < std::min(match.size(), replace.size()); i++) {
+      char matchChar = *(match.data() + i);
+      char replaceChar = *(replace.data() + i);
+      // Only consider the first occurrence of a character in match.
+      dictionary.emplace(matchChar, replaceChar);
+    }
+    for (; i < match.size(); i++) {
+      char matchChar = *(match.data() + i);
+      dictionary.emplace(matchChar, '\0');
+    }
+    return dictionary;
+  }
+
+  std::optional<folly::F14FastMap<std::string, std::string>> unicodeDictionary_;
+  std::optional<folly::F14FastMap<char, char>> asciiDictionary_;
+
+  bool isConstantDictionary_ = false;
+};
+
+template <typename T>
+struct ConvFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr bool is_default_ascii_behavior = true;
+
+  static const uint64_t kMaxUnsignedInt64_ = 0xFFFFFFFFFFFFFFFF;
+  static const int kMinBase = 2;
+  static const int kMaxBase = 36;
+
+  static bool checkInput(StringView input, int32_t fromBase, int32_t toBase) {
+    if (input.empty()) {
+      return false;
+    }
+    // Consistent with spark, only supports fromBase belonging to [2, 36]
+    // and toBase belonging to [2, 36] or [-36, -2].
+    if (fromBase < kMinBase || fromBase > kMaxBase ||
+        std::abs(toBase) < kMinBase || std::abs(toBase) > kMaxBase) {
+      return false;
+    }
+    return true;
+  }
+
+  static int32_t skipLeadingSpaces(StringView input) {
+    // Ignore leading spaces.
+    int i = 0;
+    for (; i < input.size(); i++) {
+      if (input.data()[i] != ' ') {
+        break;
+      }
+    }
+    return i;
+  }
+
+  static uint64_t
+  toUnsigned(StringView input, int32_t start, int32_t fromBase) {
+    uint64_t unsignedValue;
+    auto fromStatus = std::from_chars(
+        input.data() + start,
+        input.data() + input.size(),
+        unsignedValue,
+        fromBase);
+    if (fromStatus.ec == std::errc::invalid_argument) {
+      return 0;
+    }
+    if (fromStatus.ec == std::errc::result_out_of_range) {
+      return kMaxUnsignedInt64_;
+    }
+    return unsignedValue;
+  }
+
+  static void toUpper(char* buffer, const int32_t size) {
+    for (int i = 0; i < size; i++) {
+      buffer[i] = std::toupper(buffer[i]);
+    }
+  }
+
+  static std::pair<int64_t, int32_t> getSignedValueAndResultSize(
+      uint64_t unsignedValue,
+      bool isNegativeInput,
+      int32_t toBase) {
+    // This flag is used to make sure when we calculate the resultSize in
+    // `toChars` we always get a positive number. It is due to the
+    // `std::abs(min_int64)` would return a negative number.
+    auto isMinInt64Num =
+        unsignedValue == (uint64_t)std::numeric_limits<int64_t>::min();
+    int64_t signedValue;
+    int64_t absValue;
+    if (isMinInt64Num) {
+      signedValue = (int64_t)unsignedValue;
+      // `std::abs(min_int64)` return a negative number, so here we set
+      // absValue to max_int64 manually.
+      absValue = std::numeric_limits<int64_t>::max();
+    } else if (!isNegativeInput) {
+      signedValue = (int64_t)unsignedValue;
+      absValue = std::abs(signedValue);
+    } else {
+      signedValue = -std::abs((int64_t)unsignedValue);
+      absValue = std::abs(signedValue);
+    }
+    int32_t resultSize =
+        (int32_t)std::floor(std::log(absValue) / std::log(-toBase)) + 1;
+    // Negative symbol is considered.
+    if (signedValue < 0) {
+      ++resultSize;
+    }
+    return std::make_pair(signedValue, resultSize);
+  }
+
+  static std::pair<uint64_t, int32_t> getUnsignedValueAndResultSize(
+      uint64_t unsignedInput,
+      bool isNegativeInput,
+      int32_t toBase) {
+    uint64_t unsignedValue = unsignedInput;
+    if (isNegativeInput) {
+      int64_t negativeInput = -std::abs((int64_t)unsignedValue);
+      unsignedValue = (uint64_t)negativeInput;
+    } // Here directly use unsignedValue if isNegativeInput = false.
+    int32_t resultSize =
+        (int32_t)std::floor(std::log(unsignedValue) / std::log(toBase)) + 1;
+    return std::make_pair(unsignedValue, resultSize);
+  }
+
+  // For signed value, toBase is negative.
+  static void toChars(
+      out_type<Varchar>& result,
+      int64_t signedValue,
+      int32_t toBase,
+      int32_t resultSize) {
+    result.resize(resultSize);
+    auto toStatus = std::to_chars(
+        result.data(), result.data() + result.size(), signedValue, -toBase);
+    result.resize(toStatus.ptr - result.data());
+  }
+
+  // For unsigned value, toBase is positive.
+  static void toChars(
+      out_type<Varchar>& result,
+      uint64_t unsignedValue,
+      int32_t toBase,
+      int32_t resultSize) {
+    result.resize(resultSize);
+    auto toStatus = std::to_chars(
+        result.data(),
+        result.data() + result.size(),
+        unsignedValue,
+        std::abs(toBase));
+    result.resize(toStatus.ptr - result.data());
+  }
+
+  bool call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      int32_t fromBase,
+      int32_t toBase) {
+    if (!checkInput(input, fromBase, toBase)) {
+      return false;
+    }
+
+    auto i = skipLeadingSpaces(input);
+    // All are spaces.
+    if (i == input.size()) {
+      return false;
+    }
+    const bool isNegativeInput = (input.data()[i] == '-');
+    // Skips negative symbol.
+    if (isNegativeInput) {
+      ++i;
+    }
+
+    uint64_t unsignedInput = toUnsigned(input, i, fromBase);
+    if (unsignedInput == 0) {
+      result.append("0");
+      return true;
+    }
+
+    // When toBase is negative, converts to signed value. Otherwise, converts to
+    // unsigned value. Overflow is allowed, consistent with Spark.
+    if (toBase < 0) {
+      auto [signedValue, resultSize] =
+          getSignedValueAndResultSize(unsignedInput, isNegativeInput, toBase);
+      toChars(result, signedValue, toBase, resultSize);
+    } else {
+      auto [unsignedValue, resultSize] =
+          getUnsignedValueAndResultSize(unsignedInput, isNegativeInput, toBase);
+      toChars(result, unsignedValue, toBase, resultSize);
+    }
+
+    // Converts to uppper case, consistent with Spark.
+    if (std::abs(toBase) > 10) {
+      toUpper(result.data(), result.size());
+    }
+    return true;
+  }
+};
+
+/// replace(input, replaced) -> varchar
+///
+///     Removes all instances of ``replaced`` from ``input``.
+///     If ``replaced`` is an empty string, returns the original ``input``
+///     string.
+
+///
+/// replace(input, replaced, replacement) -> varchar
+///
+///     Replaces all instances of ``replaced`` with ``replacement`` in
+///     ``input``. If ``replaced`` is an empty string, returns the original
+///     ``input`` string.
+template <typename T>
+struct ReplaceFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& replaced) {
+    result.reserve(input.size());
+    auto resultSize = stringCore::replace<true /*ignoreEmptyReplaced*/>(
+        result.data(),
+        std::string_view(input.data(), input.size()),
+        std::string_view(replaced.data(), replaced.size()),
+        std::string_view(),
+        false);
+    result.resize(resultSize);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& replaced,
+      const arg_type<Varchar>& replacement) {
+    size_t reserveSize = input.size();
+    if (replaced.size() != 0 && replacement.size() > replaced.size()) {
+      reserveSize = (input.size() / replaced.size()) * replacement.size() +
+          input.size() % replaced.size();
+    }
+    result.reserve(reserveSize);
+    auto resultSize = stringCore::replace<true /*ignoreEmptyReplaced*/>(
+        result.data(),
+        std::string_view(input.data(), input.size()),
+        std::string_view(replaced.data(), replaced.size()),
+        std::string_view(replacement.data(), replacement.size()),
+        false);
+    result.resize(resultSize);
+  }
+};
+
+template <typename T>
+struct FindInSetFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int32_t>& result,
+      const arg_type<Varchar>& str,
+      const arg_type<Varchar>& strArray) {
+    if (std::string_view(str).find(',') != std::string::npos) {
+      result = 0;
+      return;
+    }
+
+    int32_t index = 1;
+    int32_t lastComma = -1;
+    auto arrayData = strArray.data();
+    auto matchData = str.data();
+    size_t arraySize = strArray.size();
+    size_t matchSize = str.size();
+
+    for (int i = 0; i < arraySize; i++) {
+      if (arrayData[i] == ',') {
+        if (i - (lastComma + 1) == matchSize &&
+            std::memcmp(arrayData + (lastComma + 1), matchData, matchSize) ==
+                0) {
+          result = index;
+          return;
+        }
+        lastComma = i;
+        index++;
+      }
+    }
+
+    if (arraySize - (lastComma + 1) == matchSize &&
+        std::memcmp(arrayData + (lastComma + 1), matchData, matchSize) == 0) {
+      result = index;
+      return;
+    }
+
+    result = 0;
+    return;
+  }
+};
+
+/// repeat(input, n) -> varchar
+///
+///    Returns the string which repeats input n times.
+///    Result size must be less than or equal to 1MB.
+///    If n is less than or equal to 0, empty string is returned.
+template <typename T>
+struct RepeatFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr bool is_default_ascii_behavior = true;
+
+  FOLLY_ALWAYS_INLINE void
+  call(out_type<Varchar>& result, const arg_type<Varchar>& input, int32_t n) {
+    static constexpr size_t resultMaxSize = 1024 * 1024; // 1MB
+    auto inputSize = input.size();
+    if (inputSize == 0 || n <= 0) {
+      result.resize(0);
+      return;
+    }
+    int32_t newSize = velox::checkedMultiply<int32_t>(inputSize, n);
+    VELOX_USER_CHECK_LE(
+        newSize,
+        resultMaxSize,
+        "Result size must be less than or equal to {}",
+        resultMaxSize);
+    result.resize(newSize);
+    for (auto i = 0; i < n; ++i) {
+      std::memcpy(result.data() + i * inputSize, input.data(), inputSize);
+    }
+  }
+};
+
+template <typename T>
+struct SoundexFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr bool is_default_ascii_behavior = true;
+
+  /// Soundex is a phonetic algorithm for indexing names by sound, for details,
+  /// please see https://en.wikipedia.org/wiki/Soundex.
+  void call(out_type<Varchar>& result, const arg_type<Varchar>& input) {
+    size_t inputSize = input.size();
+    if (inputSize == 0) {
+      result.resize(0);
+      return;
+    }
+    if (!std::isalpha(input.data()[0])) {
+      // First character must be a letter, otherwise input is returned.
+      result = input;
+      return;
+    }
+    result.resize(4);
+    result.data()[0] = std::toupper(input.data()[0]);
+    int32_t soundexIndex = 1;
+    int32_t dataIndex = result.data()[0] - 'A';
+    char lastCode = kUSEnglishMapping[dataIndex];
+    for (auto i = 1; i < inputSize; ++i) {
+      if (!std::isalpha(input.data()[i])) {
+        lastCode = '0';
+        continue;
+      }
+      dataIndex = std::toupper(input.data()[i]) - 'A';
+      char code = kUSEnglishMapping[dataIndex];
+      if (code != '7') {
+        if (code != '0' && code != lastCode) {
+          result.data()[soundexIndex++] = code;
+          if (soundexIndex > 3) {
+            break;
+          }
+        }
+        lastCode = code;
+      }
+    }
+    for (; soundexIndex < 4; soundexIndex++) {
+      result.data()[soundexIndex] = '0';
+    }
+  }
+
+ private:
+  // Soundex mapping table.
+  static constexpr char kUSEnglishMapping[] = {
+      '0', '1', '2', '3', '0', '1', '2', '7', '0', '2', '2', '4', '5',
+      '5', '0', '1', '2', '6', '2', '3', '0', '1', '7', '2', '0', '2'};
+};
+
+/// Implementation adopted from
+/// org.apache.commons.text.similarity.LevenshteinDistance.limitedCompare and
+/// Velox Presto LevenshteinDistanceFunction.
+template <typename T>
+struct LevenshteinDistanceFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int32_t>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right,
+      int32_t threshold) {
+    auto leftCodePoints = stringImpl::stringToCodePoints(left);
+    auto rightCodePoints = stringImpl::stringToCodePoints(right);
+    doCall<int32_t>(
+        result,
+        leftCodePoints.data(),
+        rightCodePoints.data(),
+        leftCodePoints.size(),
+        rightCodePoints.size(),
+        threshold);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<int32_t>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right,
+      int32_t threshold) {
+    auto leftCodePoints = reinterpret_cast<const uint8_t*>(left.data());
+    auto rightCodePoints = reinterpret_cast<const uint8_t*>(right.data());
+    doCall<uint8_t>(
+        result,
+        leftCodePoints,
+        rightCodePoints,
+        left.size(),
+        right.size(),
+        threshold);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int32_t>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    call(result, left, right, INT32_MAX);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<int32_t>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    callAscii(result, left, right, INT32_MAX);
+  }
+
+ private:
+  // This implementation only computes the distance if it's less than or equal
+  // to the threshold value, setting result as -1 if it's greater. Threshold k
+  // allows us to reduce the time complexity from
+  // O(leftCodePointsSize * rightCodePointsSize) to
+  // O(k * rightCodePointsSize) by only computing a diagonal stripe of at most
+  // width 2k + 1 of the cost table.
+  // One example: suppose the two gives strings are of length 5 and 7, and
+  // threshold is 1. In this case we're going to walk through a stripe of
+  // length 3. The matrix would look like so:
+  //
+  // <pre>
+  //    0 1 2 3 4
+  // 0 |#|#| | | | --> lower boundary:0, upper:2;
+  // 1 |#|#|#| | | --> lower boundary:0, upper:3;
+  // 2 | |#|#|#| | --> lower boundary:1, upper:4;
+  // 3 | | |#|#|#| --> lower boundary:2, upper:5;
+  // 4 | | | |#|#| --> lower boundary:3, upper:5;
+  // 5 | | | | |#| --> lower boundary:4, upper:5;
+  // 6 | | | | | |
+  // </pre>
+  template <typename TCodePoint>
+  void doCall(
+      out_type<int32_t>& result,
+      const TCodePoint* leftCodePoints,
+      const TCodePoint* rightCodePoints,
+      size_t leftCodePointsSize,
+      size_t rightCodePointsSize,
+      int32_t threshold) {
+    if (leftCodePointsSize < rightCodePointsSize) {
+      doCall(
+          result,
+          rightCodePoints,
+          leftCodePoints,
+          rightCodePointsSize,
+          leftCodePointsSize,
+          threshold);
+      return;
+    }
+    VELOX_USER_CHECK_LE(
+        leftCodePointsSize,
+        INT32_MAX,
+        "The inputs size exceeded max Levenshtein distance input size,"
+        " the code points size of left is {}, code points size of right is {}",
+        leftCodePointsSize,
+        rightCodePointsSize);
+    if (leftCodePointsSize - rightCodePointsSize > threshold) {
+      result = -1;
+      return;
+    }
+    if (rightCodePointsSize == 0) {
+      result = leftCodePointsSize;
+      return;
+    }
+    std::vector<int32_t> distances;
+    distances.reserve(rightCodePointsSize);
+    // These fills ensure that the value above the rightmost entry of our
+    // stripe will be ignored in following loop iterations.
+    int32_t boundary = std::min<int32_t>(rightCodePointsSize, threshold);
+    auto i = 0;
+    for (; i < boundary; i++) {
+      distances.push_back(i + 1);
+    }
+    for (; i < rightCodePointsSize; i++) {
+      distances.push_back(INT32_MAX);
+    }
+
+    for (auto i = 0; i < leftCodePointsSize; i++) {
+      auto lower = std::max<int32_t>(0, i - threshold);
+      int32_t maxValueWithThreshold;
+      int32_t upper = rightCodePointsSize;
+      if (!__builtin_add_overflow(i + 1, threshold, &maxValueWithThreshold)) {
+        upper = std::min<int32_t>(rightCodePointsSize, maxValueWithThreshold);
+      }
+      if (lower > upper) {
+        result = -1;
+        return;
+      }
+      int32_t leftUpDistance;
+      if (lower == 0) {
+        leftUpDistance = distances[lower];
+        if (leftCodePoints[i] == rightCodePoints[0]) {
+          distances[0] = i;
+        } else {
+          distances[0] = std::min(i, distances[0]) + 1;
+        }
+        lower = 1;
+      } else {
+        leftUpDistance = distances[lower - 1];
+        // Set this as Max value to ignore entry left of leftmost.
+        distances[lower - 1] = INT32_MAX;
+      }
+      for (int j = lower; j < upper; j++) {
+        auto leftUpDistanceNext = distances[j];
+        if (leftCodePoints[i] == rightCodePoints[j]) {
+          distances[j] = leftUpDistance;
+        } else {
+          distances[j] =
+              std::min(
+                  distances[j - 1], std::min(leftUpDistance, distances[j])) +
+              1;
+        }
+        leftUpDistance = leftUpDistanceNext;
+      }
+    }
+    result = distances[rightCodePointsSize - 1];
+    if (result > threshold) {
+      result = -1;
+    }
+  }
+};
+
+/// empty2null(input) -> varchar
+///
+///    Returns NULL when the input is empty,
+///    otherwise, it returns the input itself.
+template <typename T>
+struct Empty2NullFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Results refer to strings in the first argument.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input) {
+    if (input.empty()) {
+      return false;
+    }
+    result.setNoCopy(input);
+    return true;
+  }
 };
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/StringToMap.h b/velox/functions/sparksql/StringToMap.h
new file mode 100644
index 0000000000000..3e635a86b1720
--- /dev/null
+++ b/velox/functions/sparksql/StringToMap.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "folly/container/F14Set.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions::sparksql {
+
+template <typename T>
+struct StringToMapFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Results refer to strings in the first argument.
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  void call(
+      out_type<Map<Varchar, Varchar>>& out,
+      const arg_type<Varchar>& input,
+      const arg_type<Varchar>& entryDelimiter,
+      const arg_type<Varchar>& keyValueDelimiter) {
+    VELOX_USER_CHECK_EQ(
+        entryDelimiter.size(), 1, "entryDelimiter's size should be 1.");
+    VELOX_USER_CHECK_EQ(
+        keyValueDelimiter.size(), 1, "keyValueDelimiter's size should be 1.");
+
+    callImpl(
+        out,
+        toStringView(input),
+        toStringView(entryDelimiter),
+        toStringView(keyValueDelimiter));
+  }
+
+ private:
+  static std::string_view toStringView(const arg_type<Varchar>& input) {
+    return std::string_view(input.data(), input.size());
+  }
+
+  void callImpl(
+      out_type<Map<Varchar, Varchar>>& out,
+      std::string_view input,
+      std::string_view entryDelimiter,
+      std::string_view keyValueDelimiter) const {
+    size_t pos = 0;
+    folly::F14FastSet<std::string_view> keys;
+
+    auto nextEntryPos = input.find(entryDelimiter, pos);
+    while (nextEntryPos != std::string::npos) {
+      processEntry(
+          out,
+          std::string_view(input.data() + pos, nextEntryPos - pos),
+          keyValueDelimiter,
+          keys);
+
+      pos = nextEntryPos + 1;
+      nextEntryPos = input.find(entryDelimiter, pos);
+    }
+
+    processEntry(
+        out,
+        std::string_view(input.data() + pos, input.size() - pos),
+        keyValueDelimiter,
+        keys);
+  }
+
+  void processEntry(
+      out_type<Map<Varchar, Varchar>>& out,
+      std::string_view entry,
+      std::string_view keyValueDelimiter,
+      folly::F14FastSet<std::string_view>& keys) const {
+    const auto delimiterPos = entry.find(keyValueDelimiter, 0);
+    // Allows keyValue delimiter not found.
+    if (delimiterPos == std::string::npos) {
+      out.add_null().setNoCopy(StringView(entry));
+      return;
+    }
+    const auto key = std::string_view(entry.data(), delimiterPos);
+    VELOX_USER_CHECK(
+        keys.insert(key).second, "Duplicate keys are not allowed: '{}'.", key);
+    const auto value = StringView(
+        entry.data() + delimiterPos + 1, entry.size() - delimiterPos - 1);
+
+    auto [keyWriter, valueWriter] = out.add_item();
+    keyWriter.setNoCopy(StringView(key));
+    valueWriter.setNoCopy(value);
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/UnscaledValueFunction.cpp b/velox/functions/sparksql/UnscaledValueFunction.cpp
new file mode 100644
index 0000000000000..3f7858a2d62e8
--- /dev/null
+++ b/velox/functions/sparksql/UnscaledValueFunction.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/sparksql/UnscaledValueFunction.h"
+
+#include "velox/expression/DecodedArgs.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+// Return the unscaled bigint value of a decimal, assuming it
+// fits in a bigint. Only short decimal input is accepted.
+class UnscaledValueFunction final : public exec::VectorFunction {
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const final {
+    VELOX_USER_CHECK(
+        args[0]->type()->isShortDecimal(),
+        "Expect short decimal type, but got: {}",
+        args[0]->type());
+    exec::DecodedArgs decodedArgs(rows, args, context);
+    auto decimalVector = decodedArgs.at(0);
+    context.ensureWritable(rows, BIGINT(), result);
+    result->clearNulls(rows);
+    auto flatResult =
+        result->asUnchecked<FlatVector<int64_t>>()->mutableRawValues();
+    rows.applyToSelected([&](auto row) {
+      flatResult[row] = decimalVector->valueAt<int64_t>(row);
+    });
+  }
+};
+} // namespace
+
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+unscaledValueSignatures() {
+  return {exec::FunctionSignatureBuilder()
+              // precision <= 18.
+              .integerVariable("precision", "min(precision, 18)")
+              .integerVariable("scale")
+              .returnType("bigint")
+              .argumentType("DECIMAL(precision, scale)")
+              .build()};
+}
+
+std::unique_ptr<exec::VectorFunction> makeUnscaledValue() {
+  return std::make_unique<UnscaledValueFunction>();
+}
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/UnscaledValueFunction.h b/velox/functions/sparksql/UnscaledValueFunction.h
new file mode 100644
index 0000000000000..563b51b20a6cd
--- /dev/null
+++ b/velox/functions/sparksql/UnscaledValueFunction.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/VectorFunction.h"
+
+namespace facebook::velox::functions::sparksql {
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> unscaledValueSignatures();
+std::unique_ptr<exec::VectorFunction> makeUnscaledValue();
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Uuid.h b/velox/functions/sparksql/Uuid.h
new file mode 100644
index 0000000000000..1e403decb1d3d
--- /dev/null
+++ b/velox/functions/sparksql/Uuid.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+
+namespace facebook::velox::functions::sparksql {
+
+template <typename T>
+struct UuidFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  static constexpr bool is_deterministic = false;
+
+  // Spark would set the seed with 'random.nextLong()' by 'ResolveRandomSeed'
+  // rule.
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const int64_t* seed) {
+    VELOX_CHECK_NOT_NULL(seed, "seed argument must be constant");
+    const int32_t partitionId = config.sparkPartitionId();
+    generator_.seed((*seed) + partitionId);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(out_type<Varchar>& result, int64_t /*seed*/) {
+    int64_t mostSigBits =
+        (nextLong() & 0xFFFFFFFFFFFF0FFFL) | 0x0000000000004000L;
+    int64_t leastSigBits =
+        (nextLong() | 0x8000000000000000L) & 0xBFFFFFFFFFFFFFFFL;
+    for (int32_t i = 0; i < 8; ++i) {
+      uuid_.data[i] = (mostSigBits >> ((7 - i) * 8)) & 0xFF;
+      uuid_.data[i + 8] = (leastSigBits >> ((7 - i) * 8)) & 0xFF;
+    }
+    constexpr int32_t kUuidStringSize = 36;
+    result.resize(kUuidStringSize);
+    boost::uuids::to_chars(
+        uuid_, result.data(), result.data() + kUuidStringSize);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE int64_t nextLong() {
+    // Follow the org.apache.commons.math3.random.BitsStreamGenerator
+    // implementation.
+    int64_t high = (int64_t)generator_() << 32;
+    int64_t low = (int64_t)generator_() & 4294967295L;
+    return high | low;
+  }
+
+  std::mt19937 generator_;
+  boost::uuids::uuid uuid_;
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/aggregates/AverageAggregate.cpp b/velox/functions/sparksql/aggregates/AverageAggregate.cpp
index 8c52551304be0..2149651cbbb31 100644
--- a/velox/functions/sparksql/aggregates/AverageAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/AverageAggregate.cpp
@@ -84,7 +84,10 @@ class AverageAggregate
 ///     REAL            |     DOUBLE          |    DOUBLE
 ///     ALL INTs        |     DOUBLE          |    DOUBLE
 ///     DECIMAL         |     DECIMAL         |    DECIMAL
-exec::AggregateRegistrationResult registerAverage(const std::string& name) {
+exec::AggregateRegistrationResult registerAverage(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   for (const auto& inputType :
@@ -180,6 +183,7 @@ exec::AggregateRegistrationResult registerAverage(const std::string& name) {
                 return std::make_unique<DecimalAverageAggregateBase<int64_t>>(
                     resultType);
               }
+              [[fallthrough]];
             default:
               VELOX_FAIL(
                   "Unsupported result type for final aggregation: {}",
@@ -187,7 +191,8 @@ exec::AggregateRegistrationResult registerAverage(const std::string& name) {
           }
         }
       },
-      /*registerCompanionFunctions*/ true);
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/AverageAggregate.h b/velox/functions/sparksql/aggregates/AverageAggregate.h
index 33bda31409be5..6c2a4468d2fa2 100644
--- a/velox/functions/sparksql/aggregates/AverageAggregate.h
+++ b/velox/functions/sparksql/aggregates/AverageAggregate.h
@@ -22,6 +22,9 @@
 
 namespace facebook::velox::functions::aggregate::sparksql {
 
-exec::AggregateRegistrationResult registerAverage(const std::string& name);
+exec::AggregateRegistrationResult registerAverage(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite);
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
index 2029e364f33e0..13c3deeba7d36 100644
--- a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
@@ -66,9 +66,11 @@ class BitwiseXorAggregate : public BitwiseAggregateBase<T> {
 } // namespace
 
 exec::AggregateRegistrationResult registerBitwiseXorAggregate(
-    const std::string& prefix) {
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
   return functions::aggregate::registerBitwise<BitwiseXorAggregate>(
-      prefix + "bit_xor");
+      prefix + "bit_xor", withCompanionFunctions, false, overwrite);
 }
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.h b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.h
index f141c5e0b8064..083b31dacabfb 100644
--- a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.h
+++ b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.h
@@ -23,6 +23,8 @@
 namespace facebook::velox::functions::aggregate::sparksql {
 
 exec::AggregateRegistrationResult registerBitwiseXorAggregate(
-    const std::string& name);
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite);
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.cpp b/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.cpp
index 14a36e1c2d514..89a0a0c4a2009 100644
--- a/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.cpp
@@ -56,7 +56,7 @@ struct BloomFilterAccumulator {
   }
 
   BloomFilter<StlAllocator<uint64_t>> bloomFilter;
-}; // namespace
+};
 
 class BloomFilterAggAggregate : public exec::Aggregate {
  public:
@@ -76,13 +76,12 @@ class BloomFilterAggAggregate : public exec::Aggregate {
     return false;
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    setAllNulls(groups, indices);
-    for (auto i : indices) {
-      new (groups[i] + offset_) BloomFilterAccumulator(allocator_);
-    }
+  static FOLLY_ALWAYS_INLINE void checkBloomFilterNotNull(
+      DecodedVector& decoded,
+      vector_size_t idx) {
+    VELOX_USER_CHECK(
+        !decoded.isNullAt(idx),
+        "First argument of bloom_filter_agg cannot be null");
   }
 
   void addRawInput(
@@ -92,10 +91,11 @@ class BloomFilterAggAggregate : public exec::Aggregate {
       bool /*mayPushdown*/) override {
     decodeArguments(rows, args);
     computeCapacity();
-    VELOX_USER_CHECK(
-        !decodedRaw_.mayHaveNulls(),
-        "First argument of bloom_filter_agg cannot be null");
+    auto mayHaveNulls = decodedRaw_.mayHaveNulls();
     rows.applyToSelected([&](vector_size_t row) {
+      if (mayHaveNulls) {
+        checkBloomFilterNotNull(decodedRaw_, row);
+      }
       auto group = groups[row];
       auto tracker = trackRowSize(group);
       auto accumulator = value<BloomFilterAccumulator>(group);
@@ -133,15 +133,17 @@ class BloomFilterAggAggregate : public exec::Aggregate {
     auto tracker = trackRowSize(group);
     auto accumulator = value<BloomFilterAccumulator>(group);
     accumulator->init(capacity_);
-    VELOX_USER_CHECK(
-        !decodedRaw_.mayHaveNulls(),
-        "First argument of bloom_filter_agg cannot be null");
     if (decodedRaw_.isConstantMapping()) {
       // All values are same, just do for the first.
+      checkBloomFilterNotNull(decodedRaw_, 0);
       accumulator->insert(decodedRaw_.valueAt<int64_t>(0));
       return;
     }
+    auto mayHaveNulls = decodedRaw_.mayHaveNulls();
     rows.applyToSelected([&](vector_size_t row) {
+      if (mayHaveNulls) {
+        checkBloomFilterNotNull(decodedRaw_, row);
+      }
       accumulator->insert(decodedRaw_.valueAt<int64_t>(row));
     });
   }
@@ -194,6 +196,16 @@ class BloomFilterAggAggregate : public exec::Aggregate {
     extractValues(groups, numGroups, result);
   }
 
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) BloomFilterAccumulator(allocator_);
+    }
+  }
+
  private:
   void decodeArguments(
       const SelectivityVector& rows,
@@ -277,7 +289,9 @@ class BloomFilterAggAggregate : public exec::Aggregate {
 } // namespace
 
 exec::AggregateRegistrationResult registerBloomFilterAggAggregate(
-    const std::string& name) {
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
       exec::AggregateFunctionSignatureBuilder()
           .argumentType("bigint")
@@ -307,6 +321,8 @@ exec::AggregateRegistrationResult registerBloomFilterAggAggregate(
           const TypePtr& resultType,
           const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
         return std::make_unique<BloomFilterAggAggregate>(resultType, config);
-      });
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.h b/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.h
index 48c69f305dbc6..7cd54e1140e75 100644
--- a/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.h
+++ b/velox/functions/sparksql/aggregates/BloomFilterAggAggregate.h
@@ -23,6 +23,8 @@
 namespace facebook::velox::functions::aggregate::sparksql {
 
 exec::AggregateRegistrationResult registerBloomFilterAggAggregate(
-    const std::string& name);
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite);
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/CMakeLists.txt b/velox/functions/sparksql/aggregates/CMakeLists.txt
index 0018dadcce2e8..e8ff61d3629da 100644
--- a/velox/functions/sparksql/aggregates/CMakeLists.txt
+++ b/velox/functions/sparksql/aggregates/CMakeLists.txt
@@ -11,13 +11,29 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(
+velox_add_library(
   velox_functions_spark_aggregates
-  BitwiseXorAggregate.cpp BloomFilterAggAggregate.cpp FirstLastAggregate.cpp
-  AverageAggregate.cpp MinMaxByAggregate.cpp Register.cpp)
+  AverageAggregate.cpp
+  BitwiseXorAggregate.cpp
+  BloomFilterAggAggregate.cpp
+  CentralMomentsAggregate.cpp
+  CollectListAggregate.cpp
+  CollectSetAggregate.cpp
+  FirstLastAggregate.cpp
+  MinMaxAggregate.cpp
+  MinMaxByAggregate.cpp
+  ModeAggregate.cpp
+  Register.cpp
+  RegrReplacementAggregate.cpp
+  SumAggregate.cpp)
 
-target_link_libraries(velox_functions_spark_aggregates fmt::fmt velox_exec
-                      velox_expression_functions velox_aggregates velox_vector)
+velox_link_libraries(
+  velox_functions_spark_aggregates
+  fmt::fmt
+  velox_exec
+  velox_expression_functions
+  velox_aggregates
+  velox_vector)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/sparksql/aggregates/CentralMomentsAggregate.cpp b/velox/functions/sparksql/aggregates/CentralMomentsAggregate.cpp
new file mode 100644
index 0000000000000..90a0ade6f0e7a
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/CentralMomentsAggregate.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/aggregates/CentralMomentsAggregate.h"
+#include "velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+namespace {
+struct SkewnessResultAccessor {
+  static bool hasResult(const CentralMomentsAccumulator& accumulator) {
+    return accumulator.count() >= 1 && accumulator.m2() != 0;
+  }
+
+  static double result(const CentralMomentsAccumulator& accumulator) {
+    return std::sqrt(accumulator.count()) * accumulator.m3() /
+        std::pow(accumulator.m2(), 1.5);
+  }
+};
+
+struct KurtosisResultAccessor {
+  static bool hasResult(const CentralMomentsAccumulator& accumulator) {
+    return accumulator.count() >= 1 && accumulator.m2() != 0;
+  }
+
+  static double result(const CentralMomentsAccumulator& accumulator) {
+    double count = accumulator.count();
+    double m2 = accumulator.m2();
+    double m4 = accumulator.m4();
+    return count * m4 / (m2 * m2) - 3.0;
+  }
+};
+
+template <typename TResultAccessor>
+exec::AggregateRegistrationResult registerCentralMoments(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+  std::vector<std::string> inputTypes = {
+      "smallint", "integer", "bigint", "real", "double"};
+  for (const auto& inputType : inputTypes) {
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType(CentralMomentsIntermediateResult::type())
+            .argumentType(inputType)
+            .build());
+  }
+
+  return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_LE(
+            argTypes.size(), 1, "{} takes at most one argument", name);
+        const auto& inputType = argTypes[0];
+        if (exec::isRawInput(step)) {
+          switch (inputType->kind()) {
+            case TypeKind::SMALLINT:
+              return std::make_unique<
+                  CentralMomentsAggregatesBase<int16_t, TResultAccessor>>(
+                  resultType);
+            case TypeKind::INTEGER:
+              return std::make_unique<
+                  CentralMomentsAggregatesBase<int32_t, TResultAccessor>>(
+                  resultType);
+            case TypeKind::BIGINT:
+              return std::make_unique<
+                  CentralMomentsAggregatesBase<int64_t, TResultAccessor>>(
+                  resultType);
+            case TypeKind::DOUBLE:
+              return std::make_unique<
+                  CentralMomentsAggregatesBase<double, TResultAccessor>>(
+                  resultType);
+            case TypeKind::REAL:
+              return std::make_unique<
+                  CentralMomentsAggregatesBase<float, TResultAccessor>>(
+                  resultType);
+            default:
+              VELOX_UNSUPPORTED(
+                  "Unsupported input type: {}. "
+                  "Expected SMALLINT, INTEGER, BIGINT, DOUBLE or REAL.",
+                  inputType->toString());
+          }
+        } else {
+          checkAccumulatorRowType(
+              inputType,
+              "Input type for final aggregation must be "
+              "(count:bigint, m1:double, m2:double, m3:double, m4:double) struct");
+          return std::make_unique<CentralMomentsAggregatesBase<
+              int64_t /*unused*/,
+              TResultAccessor>>(resultType);
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+} // namespace
+
+void registerCentralMomentsAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerCentralMoments<SkewnessResultAccessor>(
+      prefix + "skewness", withCompanionFunctions, overwrite);
+  registerCentralMoments<KurtosisResultAccessor>(
+      prefix + "kurtosis", withCompanionFunctions, overwrite);
+}
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/CentralMomentsAggregate.h b/velox/functions/sparksql/aggregates/CentralMomentsAggregate.h
new file mode 100644
index 0000000000000..a0b9a69297e3f
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/CentralMomentsAggregate.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "velox/exec/Aggregate.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+void registerCentralMomentsAggregate(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/CollectListAggregate.cpp b/velox/functions/sparksql/aggregates/CollectListAggregate.cpp
new file mode 100644
index 0000000000000..e2c14cfa79699
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/CollectListAggregate.cpp
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/aggregates/CollectListAggregate.h"
+
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/functions/lib/aggregates/ValueList.h"
+
+using namespace facebook::velox::aggregate;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::functions::aggregate::sparksql {
+namespace {
+class CollectListAggregate {
+ public:
+  using InputType = Row<Generic<T1>>;
+
+  using IntermediateType = Array<Generic<T1>>;
+
+  using OutputType = Array<Generic<T1>>;
+
+  /// In Spark, when all inputs are null, the output is an empty array instead
+  /// of null. Therefore, in the writeIntermediateResult and writeFinalResult,
+  /// we still need to output the empty element_ when the group is null. This
+  /// behavior can only be achieved when the default-null behavior is disabled.
+  static constexpr bool default_null_behavior_ = false;
+
+  static bool toIntermediate(
+      exec::out_type<Array<Generic<T1>>>& out,
+      exec::optional_arg_type<Generic<T1>> in) {
+    if (in.has_value()) {
+      out.add_item().copy_from(in.value());
+      return true;
+    }
+    return false;
+  }
+
+  struct AccumulatorType {
+    ValueList elements_;
+
+    explicit AccumulatorType(HashStringAllocator* /*allocator*/)
+        : elements_{} {}
+
+    static constexpr bool is_fixed_size_ = false;
+
+    bool addInput(
+        HashStringAllocator* allocator,
+        exec::optional_arg_type<Generic<T1>> data) {
+      if (data.has_value()) {
+        elements_.appendValue(data, allocator);
+        return true;
+      }
+      return false;
+    }
+
+    bool combine(
+        HashStringAllocator* allocator,
+        exec::optional_arg_type<IntermediateType> other) {
+      if (!other.has_value()) {
+        return false;
+      }
+      for (auto element : other.value()) {
+        elements_.appendValue(element, allocator);
+      }
+      return true;
+    }
+
+    bool writeIntermediateResult(
+        bool /*nonNullGroup*/,
+        exec::out_type<IntermediateType>& out) {
+      // If the group's accumulator is null, the corresponding intermediate
+      // result is an empty array.
+      copyValueListToArrayWriter(out, elements_);
+      return true;
+    }
+
+    bool writeFinalResult(
+        bool /*nonNullGroup*/,
+        exec::out_type<OutputType>& out) {
+      // If the group's accumulator is null, the corresponding result is an
+      // empty array.
+      copyValueListToArrayWriter(out, elements_);
+      return true;
+    }
+
+    void destroy(HashStringAllocator* allocator) {
+      elements_.free(allocator);
+    }
+  };
+};
+
+AggregateRegistrationResult registerCollectList(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("E")
+          .returnType("array(E)")
+          .intermediateType("array(E)")
+          .argumentType("E")
+          .build()};
+  return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step /*step*/,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(
+            argTypes.size(), 1, "{} takes at most one argument", name);
+        return std::make_unique<SimpleAggregateAdapter<CollectListAggregate>>(
+            resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+} // namespace
+
+void registerCollectListAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerCollectList(
+      prefix + "collect_list", withCompanionFunctions, overwrite);
+}
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/CollectListAggregate.h b/velox/functions/sparksql/aggregates/CollectListAggregate.h
new file mode 100644
index 0000000000000..3c32023db95ed
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/CollectListAggregate.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+void registerCollectListAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp b/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp
new file mode 100644
index 0000000000000..85ca79844449f
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/lib/aggregates/SetBaseAggregate.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+namespace {
+
+// Null inputs are excluded by setting 'ignoreNulls' as true.
+// Empty arrays are returned for empty groups by setting 'nullForEmpty'
+// as false.
+template <typename T>
+using SparkSetAggAggregate = SetAggAggregate<T, true, false>;
+
+} // namespace
+
+void registerCollectSetAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures = {
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("array(T)")
+          .intermediateType("array(T)")
+          .argumentType("T")
+          .build()};
+
+  auto name = prefix + "collect_set";
+  exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(argTypes.size(), 1);
+
+        const bool isRawInput = exec::isRawInput(step);
+        const TypePtr& inputType =
+            isRawInput ? argTypes[0] : argTypes[0]->childAt(0);
+        const TypeKind typeKind = inputType->kind();
+
+        switch (typeKind) {
+          case TypeKind::BOOLEAN:
+            return std::make_unique<SparkSetAggAggregate<bool>>(resultType);
+          case TypeKind::TINYINT:
+            return std::make_unique<SparkSetAggAggregate<int8_t>>(resultType);
+          case TypeKind::SMALLINT:
+            return std::make_unique<SparkSetAggAggregate<int16_t>>(resultType);
+          case TypeKind::INTEGER:
+            return std::make_unique<SparkSetAggAggregate<int32_t>>(resultType);
+          case TypeKind::BIGINT:
+            return std::make_unique<SparkSetAggAggregate<int64_t>>(resultType);
+          case TypeKind::HUGEINT:
+            VELOX_CHECK(
+                inputType->isLongDecimal(),
+                "Non-decimal use of HUGEINT is not supported");
+            return std::make_unique<SparkSetAggAggregate<int128_t>>(resultType);
+          case TypeKind::REAL:
+            return std::make_unique<SparkSetAggAggregate<float>>(resultType);
+          case TypeKind::DOUBLE:
+            return std::make_unique<SparkSetAggAggregate<double>>(resultType);
+          case TypeKind::TIMESTAMP:
+            return std::make_unique<SparkSetAggAggregate<Timestamp>>(
+                resultType);
+          case TypeKind::VARBINARY:
+            [[fallthrough]];
+          case TypeKind::VARCHAR:
+            return std::make_unique<SparkSetAggAggregate<StringView>>(
+                resultType);
+          case TypeKind::ARRAY:
+            [[fallthrough]];
+          case TypeKind::ROW:
+            // Nested nulls are allowed by setting 'throwOnNestedNulls' as
+            // false.
+            return std::make_unique<SparkSetAggAggregate<ComplexType>>(
+                resultType, false);
+          default:
+            VELOX_UNSUPPORTED(
+                "Unsupported type {}", mapTypeKindToName(typeKind));
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/DecimalSumAggregate.h b/velox/functions/sparksql/aggregates/DecimalSumAggregate.h
new file mode 100644
index 0000000000000..f23c034405df5
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/DecimalSumAggregate.h
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/type/DecimalUtil.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+/// @tparam TInputType The raw input data type.
+/// @tparam TSumType The type of sum in the output of partial aggregation or the
+/// final output type of final aggregation.
+template <typename TInputType, typename TSumType>
+class DecimalSumAggregate {
+ public:
+  using InputType = Row<TInputType>;
+
+  using IntermediateType =
+      Row</*sum*/ TSumType,
+          /*isEmpty*/ bool>;
+
+  using OutputType = TSumType;
+
+  /// Spark's decimal sum doesn't have the concept of a null group, each group
+  /// is initialized with an initial value, where sum = 0 and isEmpty = true.
+  /// The final agg may fallback to being executed in Spark, so the meaning of
+  /// the intermediate data should be consistent with Spark. Therefore, we need
+  /// to use the parameter nonNullGroup in writeIntermediateResult to output a
+  /// null group as sum = 0, isEmpty = true. nonNullGroup is only available when
+  /// default-null behavior is disabled.
+  static constexpr bool default_null_behavior_ = false;
+
+  static bool toIntermediate(
+      exec::out_type<Row<TSumType, bool>>& out,
+      exec::optional_arg_type<TInputType> in) {
+    if (in.has_value()) {
+      out.copy_from(std::make_tuple(static_cast<TSumType>(in.value()), false));
+    } else {
+      out.copy_from(std::make_tuple(static_cast<TSumType>(0), true));
+    }
+    return true;
+  }
+
+  /// This struct stores the sum of input values, overflow during accumulation,
+  /// and a bool value isEmpty used to indicate whether all inputs are null. The
+  /// initial value of sum is 0. We need to keep sum unchanged if the input is
+  /// null, as sum function ignores null input. If the isEmpty is true, then it
+  /// means there were no values to begin with or all the values were null, so
+  /// the result will be null. If the isEmpty is false, then if sum is nullopt
+  /// that means an overflow has happened, it returns null.
+  struct AccumulatorType {
+    std::optional<int128_t> sum{0};
+    int64_t overflow{0};
+    bool isEmpty{true};
+
+    static constexpr bool is_aligned_ = true;
+
+    AccumulatorType() = delete;
+
+    explicit AccumulatorType(HashStringAllocator* /*allocator*/) {}
+
+    std::optional<int128_t> computeFinalResult() const {
+      if (!sum.has_value()) {
+        return std::nullopt;
+      }
+      auto const adjustedSum =
+          DecimalUtil::adjustSumForOverflow(sum.value(), overflow);
+      constexpr uint8_t maxPrecision = std::is_same_v<TSumType, int128_t>
+          ? LongDecimalType::kMaxPrecision
+          : ShortDecimalType::kMaxPrecision;
+      if (adjustedSum.has_value() &&
+          DecimalUtil::valueInPrecisionRange(adjustedSum, maxPrecision)) {
+        return adjustedSum;
+      } else {
+        // Found overflow during computing adjusted sum.
+        return std::nullopt;
+      }
+    }
+
+    bool addInput(
+        HashStringAllocator* /*allocator*/,
+        exec::optional_arg_type<TInputType> data) {
+      if (!data.has_value()) {
+        return false;
+      }
+      if (!sum.has_value()) {
+        // sum is initialized to 0. When it is nullopt, it implies that the
+        // input data must not be empty.
+        VELOX_CHECK(!isEmpty);
+        return true;
+      }
+      int128_t result;
+      overflow +=
+          DecimalUtil::addWithOverflow(result, data.value(), sum.value());
+      sum = result;
+      isEmpty = false;
+      return true;
+    }
+
+    bool combine(
+        HashStringAllocator* /*allocator*/,
+        exec::optional_arg_type<Row<TSumType, bool>> other) {
+      if (!other.has_value()) {
+        return false;
+      }
+      auto const otherSum = other.value().template at<0>();
+      auto const otherIsEmpty = other.value().template at<1>();
+
+      // isEmpty is never null.
+      VELOX_CHECK(otherIsEmpty.has_value());
+      if (isEmpty && otherIsEmpty.value()) {
+        // Both accumulators are empty, no need to do the combination.
+        return false;
+      }
+
+      bool currentOverflow = !isEmpty && !sum.has_value();
+      bool otherOverflow = !otherIsEmpty.value() && !otherSum.has_value();
+      if (currentOverflow || otherOverflow) {
+        sum = std::nullopt;
+        isEmpty = false;
+      } else {
+        int128_t result;
+        overflow +=
+            DecimalUtil::addWithOverflow(result, otherSum.value(), sum.value());
+        sum = result;
+        isEmpty &= otherIsEmpty.value();
+      }
+      return true;
+    }
+
+    bool writeIntermediateResult(
+        bool nonNullGroup,
+        exec::out_type<IntermediateType>& out) {
+      if (!nonNullGroup) {
+        // If a group is null, all values in this group are null. In Spark, this
+        // group will be the initial value, where sum is 0 and isEmpty is true.
+        out = std::make_tuple(static_cast<TSumType>(0), true);
+      } else {
+        auto finalResult = computeFinalResult();
+        if (finalResult.has_value()) {
+          out = std::make_tuple(
+              static_cast<TSumType>(finalResult.value()), isEmpty);
+        } else {
+          // Sum should be set to null on overflow,
+          // and isEmpty should be set to false.
+          out.template set_null_at<0>();
+          out.template get_writer_at<1>() = false;
+        }
+      }
+      return true;
+    }
+
+    bool writeFinalResult(bool nonNullGroup, exec::out_type<OutputType>& out) {
+      if (!nonNullGroup || isEmpty) {
+        // If isEmpty is true, we should set null.
+        return false;
+      }
+      auto finalResult = computeFinalResult();
+      if (finalResult.has_value()) {
+        out = static_cast<TSumType>(finalResult.value());
+        return true;
+      } else {
+        // Sum should be set to null on overflow.
+        return false;
+      }
+    }
+  };
+};
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp b/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
index 1d5a579aed85d..232ecf859be38 100644
--- a/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
@@ -55,16 +55,6 @@ class FirstLastAggregateBase
     return 1;
   }
 
-  void initializeNewGroups(
-      char** groups,
-      folly::Range<const vector_size_t*> indices) override {
-    Aggregate::setAllNulls(groups, indices);
-
-    for (auto i : indices) {
-      new (groups[i] + Aggregate::offset_) TAccumulator();
-    }
-  }
-
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     if constexpr (numeric) {
@@ -112,19 +102,6 @@ class FirstLastAggregateBase
     }
   }
 
-  void destroy(folly::Range<char**> groups) override {
-    if constexpr (!numeric) {
-      for (auto group : groups) {
-        auto accumulator = Aggregate::value<TAccumulator>(group);
-        // If ignoreNull is true and groups are all null, accumulator will not
-        // set.
-        if (accumulator->has_value()) {
-          accumulator->value().destroy(Aggregate::allocator_);
-        }
-      }
-    }
-  }
-
  protected:
   void decodeIntermediateRows(
       const SelectivityVector& rows,
@@ -140,6 +117,31 @@ class FirstLastAggregateBase
     this->decodedValue_.decode(*rowVector->childAt(0), rows);
   }
 
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    Aggregate::setAllNulls(groups, indices);
+
+    for (auto i : indices) {
+      new (groups[i] + Aggregate::offset_) TAccumulator();
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    if constexpr (!numeric) {
+      for (auto group : groups) {
+        if (BaseAggregate::isInitialized(group)) {
+          auto accumulator = Aggregate::value<TAccumulator>(group);
+          // If ignoreNull is true and groups are all null, accumulator will not
+          // set.
+          if (accumulator->has_value()) {
+            accumulator->value().destroy(Aggregate::allocator_);
+          }
+        }
+      }
+    }
+  }
+
   DecodedVector decodedValue_;
   DecodedVector decodedIntermediates_;
 };
@@ -429,7 +431,10 @@ class LastAggregate : public FirstLastAggregateBase<numeric, TData> {
 } // namespace
 
 template <template <bool B1, typename T, bool B2> class TClass, bool ignoreNull>
-AggregateRegistrationResult registerFirstLast(const std::string& name) {
+AggregateRegistrationResult registerFirstLast(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures = {
       AggregateFunctionSignatureBuilder()
           .typeVariable("T")
@@ -499,14 +504,23 @@ AggregateRegistrationResult registerFirstLast(const std::string& name) {
                 name,
                 inputType->toString());
         }
-      });
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
-void registerFirstLastAggregates(const std::string& prefix) {
-  registerFirstLast<FirstAggregate, false>(prefix + "first");
-  registerFirstLast<FirstAggregate, true>(prefix + "first_ignore_null");
-  registerFirstLast<LastAggregate, false>(prefix + "last");
-  registerFirstLast<LastAggregate, true>(prefix + "last_ignore_null");
+void registerFirstLastAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerFirstLast<FirstAggregate, false>(
+      prefix + "first", withCompanionFunctions, overwrite);
+  registerFirstLast<FirstAggregate, true>(
+      prefix + "first_ignore_null", withCompanionFunctions, overwrite);
+  registerFirstLast<LastAggregate, false>(
+      prefix + "last", withCompanionFunctions, overwrite);
+  registerFirstLast<LastAggregate, true>(
+      prefix + "last_ignore_null", withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp b/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp
new file mode 100644
index 0000000000000..591db8f95d1ab
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/aggregates/MinMaxAggregateBase.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+namespace {
+
+exec::AggregateRegistrationResult registerMin(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
+                           .orderableTypeVariable("T")
+                           .returnType("T")
+                           .intermediateType("T")
+                           .argumentType("T")
+                           .build());
+  return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step step,
+          std::vector<TypePtr> argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
+        auto factory = getMinFunctionFactory(
+            name,
+            CompareFlags::NullHandlingMode::kNullAsValue,
+            TimestampPrecision::kMicroseconds);
+        return factory(step, argTypes, resultType, config);
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
+}
+
+exec::AggregateRegistrationResult registerMax(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
+                           .orderableTypeVariable("T")
+                           .returnType("T")
+                           .intermediateType("T")
+                           .argumentType("T")
+                           .build());
+  return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step step,
+          std::vector<TypePtr> argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
+        auto factory = getMaxFunctionFactory(
+            name,
+            CompareFlags::NullHandlingMode::kNullAsValue,
+            TimestampPrecision::kMicroseconds);
+        return factory(step, argTypes, resultType, config);
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace
+
+void registerMinMaxAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerMin(prefix + "min", withCompanionFunctions, overwrite);
+  registerMax(prefix + "max", withCompanionFunctions, overwrite);
+}
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp b/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
index 015dd86b23472..20c957322e654 100644
--- a/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
@@ -60,7 +60,7 @@ struct SparkComparator {
         true, // nullsFirst
         true, // ascending
         false, // equalsOnly
-        CompareFlags::NullHandlingMode::NoStop};
+        CompareFlags::NullHandlingMode::kNullAsValue};
     auto result = accumulator->compare(decoded, index, kCompareFlags);
     return result.value();
   }
@@ -86,12 +86,15 @@ template <
         class C>
     class Aggregate,
     bool isMaxFunc>
-exec::AggregateRegistrationResult registerMinMaxBy(const std::string& name) {
+exec::AggregateRegistrationResult registerMinMaxBy(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   // V, C -> row(V, C) -> V.
   signatures.push_back(exec::AggregateFunctionSignatureBuilder()
                            .typeVariable("V")
-                           .typeVariable("C")
+                           .orderableTypeVariable("C")
                            .returnType("V")
                            .intermediateType("row(V,C)")
                            .argumentType("V")
@@ -137,14 +140,21 @@ exec::AggregateRegistrationResult registerMinMaxBy(const std::string& name) {
           return create<Aggregate, SparkComparator, isMaxFunc>(
               resultType, valueType, compareType, errorMessage);
         }
-      });
+      },
+      withCompanionFunctions,
+      overwrite);
 }
 
 } // namespace
 
-void registerMinMaxByAggregates(const std::string& prefix) {
-  registerMinMaxBy<MinMaxByAggregateBase, true>(prefix + "max_by");
-  registerMinMaxBy<MinMaxByAggregateBase, false>(prefix + "min_by");
+void registerMinMaxByAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerMinMaxBy<MinMaxByAggregateBase, true>(
+      prefix + "max_by", withCompanionFunctions, overwrite);
+  registerMinMaxBy<MinMaxByAggregateBase, false>(
+      prefix + "min_by", withCompanionFunctions, overwrite);
 }
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/ModeAggregate.cpp b/velox/functions/sparksql/aggregates/ModeAggregate.cpp
new file mode 100644
index 0000000000000..1d027fec4f1c9
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/ModeAggregate.cpp
@@ -0,0 +1,580 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "folly/container/F14Map.h"
+
+#include "velox/exec/AddressableNonNullValueList.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/exec/Strings.h"
+
+using namespace facebook::velox::aggregate::prestosql;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+namespace {
+
+// Mode aggregate function for scalar types.
+template <
+    typename T,
+    typename Hash = std::hash<T>,
+    typename EqualTo = std::equal_to<T>>
+class ModeAggregate {
+ public:
+  using InputType = Row<T>;
+
+  using IntermediateType = Map<T, int64_t>;
+
+  using OutputType = T;
+
+  struct AccumulatorType {
+    using ValueMap = folly::F14FastMap<
+        T,
+        int64_t,
+        Hash,
+        EqualTo,
+        AlignedStlAllocator<std::pair<const T, int64_t>, 16>>;
+
+    // A map of T -> count.
+    ValueMap values;
+
+    explicit AccumulatorType(HashStringAllocator* allocator)
+        : values{AlignedStlAllocator<std::pair<const T, int64_t>, 16>(
+              allocator)} {}
+
+    static constexpr bool is_fixed_size_ = false;
+
+    void addInput(HashStringAllocator* /*allocator*/, arg_type<T> data) {
+      values[data]++;
+    }
+
+    void combine(
+        HashStringAllocator* /*allocator*/,
+        arg_type<IntermediateType> other) {
+      for (const auto& [key, count] : other) {
+        if (count.has_value()) {
+          values[key] += count.value();
+        }
+      }
+    }
+
+    bool writeIntermediateResult(out_type<IntermediateType>& out) {
+      out.reserve(values.size());
+      for (const auto& [value, count] : values) {
+        out.emplace(value, count);
+      }
+      return true;
+    }
+
+    bool writeFinalResult(out_type<OutputType>& out) {
+      auto iterator = std::max_element(
+          std::begin(values),
+          std::end(values),
+          [](const std::pair<T, int64_t>& p1, const std::pair<T, int64_t>& p2) {
+            return p1.second < p2.second;
+          });
+      out = iterator->first;
+      return true;
+    }
+
+    void destroy(HashStringAllocator* /*allocator*/) {
+      using TValues = decltype(values);
+      values.~TValues();
+    }
+  };
+};
+
+// Mode aggregate function for VARCHAR type.
+class StringModeAggregate {
+ public:
+  using InputType = Row<Varchar>;
+
+  using IntermediateType = Map<Varchar, int64_t>;
+
+  using OutputType = Varchar;
+
+  struct AccumulatorType {
+    using ValueMap = folly::F14FastMap<
+        StringView,
+        int64_t,
+        std::hash<StringView>,
+        std::equal_to<StringView>,
+        AlignedStlAllocator<std::pair<const StringView, int64_t>, 16>>;
+
+    // A map of unique StringViews pointing to storage managed by 'strings'.
+    ValueMap values;
+
+    // Stores unique non-null non-inline strings.
+    Strings strings;
+
+    explicit AccumulatorType(HashStringAllocator* allocator)
+        : values{AlignedStlAllocator<std::pair<const StringView, int64_t>, 16>(
+              allocator)} {}
+
+    static constexpr bool is_fixed_size_ = false;
+
+    void addInput(HashStringAllocator* allocator, arg_type<Varchar> data) {
+      values[store(data, allocator)]++;
+    }
+
+    void combine(
+        HashStringAllocator* allocator,
+        arg_type<IntermediateType> other) {
+      for (const auto& [key, count] : other) {
+        if (count.has_value()) {
+          values[store(key, allocator)] += count.value();
+        }
+      }
+    }
+
+    bool writeIntermediateResult(out_type<IntermediateType>& out) {
+      out.reserve(values.size());
+      for (const auto& [value, count] : values) {
+        out.add_item() = std::make_tuple(value, count);
+      }
+      return true;
+    }
+
+    bool writeFinalResult(out_type<OutputType>& out) {
+      auto iterator = std::max_element(
+          std::begin(values),
+          std::end(values),
+          [](const std::pair<StringView, int64_t>& p1,
+             const std::pair<StringView, int64_t>& p2) {
+            return p1.second < p2.second;
+          });
+      out = iterator->first;
+      return true;
+    }
+
+    void destroy(HashStringAllocator* allocator) {
+      strings.free(*allocator);
+      using TValues = decltype(values);
+      values.~TValues();
+    }
+
+   private:
+    // Stores the non-inlined string in memory blocks managed by
+    // HashStringAllocator, if it's not exist in the values map.
+    StringView store(StringView value, HashStringAllocator* allocator) {
+      if (!value.isInline()) {
+        auto it = values.find(value);
+        if (it == values.end()) {
+          value = strings.append(value, *allocator);
+        }
+      }
+      return value;
+    }
+  };
+};
+
+struct ComplexTypeAccumulator {
+  using ValueMap = folly::F14FastMap<
+      AddressableNonNullValueList::Entry,
+      int64_t,
+      AddressableNonNullValueList::Hash,
+      AddressableNonNullValueList::EqualTo,
+      AlignedStlAllocator<
+          std::pair<const AddressableNonNullValueList::Entry, int64_t>,
+          16>>;
+
+  ValueMap values;
+
+  AddressableNonNullValueList serializedValues;
+
+  ComplexTypeAccumulator(const TypePtr& type, HashStringAllocator* allocator)
+      : values{
+            0,
+            AddressableNonNullValueList::Hash{},
+            AddressableNonNullValueList::EqualTo{type},
+            AlignedStlAllocator<
+                std::pair<const AddressableNonNullValueList::Entry, int64_t>,
+                16>(allocator)} {}
+
+  size_t size() const {
+    return values.size();
+  }
+
+  void addValue(
+      DecodedVector& decoded,
+      vector_size_t index,
+      HashStringAllocator* allocator) {
+    addValueWithCount(*decoded.base(), decoded.index(index), 1, allocator);
+  }
+
+  void addValueWithCount(
+      const BaseVector& keys,
+      vector_size_t index,
+      int64_t count,
+      HashStringAllocator* allocator) {
+    auto entry = serializedValues.append(keys, index, allocator);
+
+    auto it = values.find(entry);
+    if (it == values.end()) {
+      // New entry.
+      values[entry] += count;
+    } else {
+      // Existing entry.
+      serializedValues.removeLast(entry);
+
+      it->second += count;
+    }
+  }
+
+  void extractValues(
+      BaseVector& keys,
+      FlatVector<int64_t>& counts,
+      vector_size_t offset) {
+    auto index = offset;
+    for (const auto& [position, count] : values) {
+      AddressableNonNullValueList::read(position, keys, index);
+      counts.set(index, count);
+      ++index;
+    }
+  }
+
+  void extractValues(const VectorPtr& results, vector_size_t offset) {
+    auto iterator = std::max_element(
+        std::begin(values),
+        std::end(values),
+        [](const std::pair<AddressableNonNullValueList::Entry, int64_t>& p1,
+           const std::pair<AddressableNonNullValueList::Entry, int64_t>& p2) {
+          return p1.second < p2.second;
+        });
+    AddressableNonNullValueList::read(iterator->first, *results, offset);
+  }
+
+  void free(HashStringAllocator& allocator) {
+    serializedValues.free(allocator);
+    using TValues = decltype(values);
+    values.~TValues();
+  }
+};
+
+// Mode aggregate function for complex types.
+template <typename T>
+class ComplexTypeModeAggregate : public Aggregate {
+ public:
+  explicit ComplexTypeModeAggregate(TypePtr resultType, TypePtr inputType)
+      : Aggregate(std::move(resultType)), inputType_(std::move(inputType)) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(ComplexTypeAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    VELOX_CHECK(*result);
+    (*result)->resize(numGroups);
+    uint64_t* rawNulls = nullptr;
+    if ((*result)->mayHaveNulls()) {
+      BufferPtr& nulls = (*result)->mutableNulls((*result)->size());
+      rawNulls = nulls->asMutable<uint64_t>();
+    }
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      auto* accumulator = value<ComplexTypeAccumulator>(group);
+      if (accumulator->size() == 0) {
+        (*result)->setNull(i, true);
+      } else {
+        if (rawNulls) {
+          bits::clearBit(rawNulls, i);
+        }
+        accumulator->extractValues(*result, i);
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto* mapVector = (*result)->as<MapVector>();
+    VELOX_CHECK(mapVector);
+    mapVector->resize(numGroups);
+
+    auto& mapKeys = mapVector->mapKeys();
+    auto* flatValues =
+        mapVector->mapValues()->asUnchecked<FlatVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(mapKeys);
+    VELOX_CHECK_NOT_NULL(flatValues);
+
+    vector_size_t numElements = 0;
+    for (int32_t i = 0; i < numGroups; ++i) {
+      numElements += value<ComplexTypeAccumulator>(groups[i])->size();
+    }
+    mapKeys->resize(numElements);
+    flatValues->resize(numElements);
+
+    auto* rawNulls = mapVector->mutableRawNulls();
+    vector_size_t offset = 0;
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      auto* accumulator = value<ComplexTypeAccumulator>(group);
+
+      const auto mapSize = accumulator->size();
+      mapVector->setOffsetAndSize(i, offset, mapSize);
+      if (mapSize == 0) {
+        bits::setNull(rawNulls, i, true);
+      } else {
+        clearNull(rawNulls, i);
+        accumulator->extractValues(*mapKeys, *flatValues, offset);
+        offset += mapSize;
+      }
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedKeys_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](auto row) {
+      if (decodedKeys_.isNullAt(row)) {
+        // Nulls among the values being aggregated are ignored.
+        return;
+      }
+      auto group = groups[row];
+      auto* accumulator = value<ComplexTypeAccumulator>(group);
+
+      auto tracker = trackRowSize(group);
+      accumulator->addValue(decodedKeys_, row, allocator_);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /* mayPushdown */) override {
+    decodedKeys_.decode(*args[0], rows);
+    auto* accumulator = value<ComplexTypeAccumulator>(group);
+
+    auto tracker = trackRowSize(group);
+    rows.applyToSelected([&](auto row) {
+      // Nulls among the values being aggregated are ignored.
+      if (!decodedKeys_.isNullAt(row)) {
+        accumulator->addValue(decodedKeys_, row, allocator_);
+      }
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+    auto* indices = decodedIntermediate_.indices();
+    auto* mapVector = decodedIntermediate_.base()->template as<MapVector>();
+
+    auto& mapKeys = mapVector->mapKeys();
+    auto* flatValues =
+        mapVector->mapValues()->template asUnchecked<FlatVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(mapKeys);
+    VELOX_CHECK_NOT_NULL(flatValues);
+
+    auto rawSizes = mapVector->rawSizes();
+    auto rawOffsets = mapVector->rawOffsets();
+    rows.applyToSelected([&](vector_size_t row) {
+      if (!decodedIntermediate_.isNullAt(row)) {
+        auto group = groups[row];
+        auto* accumulator = value<ComplexTypeAccumulator>(group);
+
+        auto tracker = trackRowSize(group);
+        addToFinalAggregation(
+            mapKeys.get(),
+            flatValues,
+            indices[row],
+            rawSizes,
+            rawOffsets,
+            accumulator,
+            allocator_);
+      }
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /* mayPushdown */) override {
+    decodedIntermediate_.decode(*args[0], rows);
+    auto* indices = decodedIntermediate_.indices();
+    auto* mapVector = decodedIntermediate_.base()->template as<MapVector>();
+
+    auto& mapKeys = mapVector->mapKeys();
+    auto* flatValues =
+        mapVector->mapValues()->template asUnchecked<FlatVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(mapKeys);
+    VELOX_CHECK_NOT_NULL(flatValues);
+
+    auto* accumulator = value<ComplexTypeAccumulator>(group);
+
+    auto tracker = trackRowSize(group);
+
+    auto* rawSizes = mapVector->rawSizes();
+    auto* rawOffsets = mapVector->rawOffsets();
+    rows.applyToSelected([&](vector_size_t row) {
+      if (!decodedIntermediate_.isNullAt(row)) {
+        addToFinalAggregation(
+            mapKeys.get(),
+            flatValues,
+            indices[row],
+            rawSizes,
+            rawOffsets,
+            accumulator,
+            allocator_);
+      }
+    });
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    for (auto index : indices) {
+      new (groups[index] + offset_)
+          ComplexTypeAccumulator{inputType_, allocator_};
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto* group : groups) {
+      if (isInitialized(group) && !isNull(group)) {
+        value<ComplexTypeAccumulator>(group)->free(*allocator_);
+      }
+    }
+  }
+
+ private:
+  // Combines a partial aggregation represented by the key-value pair at row in
+  // mapKeys and mapValues into groupMap.
+  FOLLY_ALWAYS_INLINE void addToFinalAggregation(
+      const BaseVector* mapKeys,
+      const FlatVector<int64_t>* flatValues,
+      vector_size_t index,
+      const vector_size_t* rawSizes,
+      const vector_size_t* rawOffsets,
+      ComplexTypeAccumulator* accumulator,
+      HashStringAllocator* allocator) {
+    auto size = rawSizes[index];
+    auto offset = rawOffsets[index];
+
+    for (int i = 0; i < size; ++i) {
+      const auto count = flatValues->valueAt(offset + i);
+      accumulator->addValueWithCount(*mapKeys, offset + i, count, allocator);
+    }
+  }
+
+  DecodedVector decodedKeys_;
+  DecodedVector decodedIntermediate_;
+  TypePtr inputType_;
+};
+} // namespace
+
+void registerModeAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures = {
+      AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("T")
+          .intermediateType("map(T,bigint)")
+          .argumentType("T")
+          .build(),
+  };
+
+  auto name = prefix + "mode";
+  registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/) -> std::unique_ptr<Aggregate> {
+        VELOX_CHECK_EQ(
+            argTypes.size(), 1, "{}: unexpected number of arguments", name);
+
+        auto inputType =
+            isRawInput(step) ? argTypes[0] : argTypes[0]->childAt(0);
+        switch (inputType->kind()) {
+          case TypeKind::BOOLEAN:
+            return std::make_unique<
+                SimpleAggregateAdapter<ModeAggregate<bool>>>(resultType);
+          case TypeKind::TINYINT:
+            return std::make_unique<
+                SimpleAggregateAdapter<ModeAggregate<int8_t>>>(resultType);
+          case TypeKind::SMALLINT:
+            return std::make_unique<
+                SimpleAggregateAdapter<ModeAggregate<int16_t>>>(resultType);
+          case TypeKind::INTEGER:
+            return std::make_unique<
+                SimpleAggregateAdapter<ModeAggregate<int32_t>>>(resultType);
+          case TypeKind::BIGINT:
+            return std::make_unique<
+                SimpleAggregateAdapter<ModeAggregate<int64_t>>>(resultType);
+          case TypeKind::HUGEINT:
+            return std::make_unique<
+                SimpleAggregateAdapter<ModeAggregate<int128_t>>>(resultType);
+          case TypeKind::REAL:
+            return std::make_unique<SimpleAggregateAdapter<ModeAggregate<
+                float,
+                util::floating_point::NaNAwareHash<float>,
+                util::floating_point::NaNAwareEquals<float>>>>(resultType);
+          case TypeKind::DOUBLE:
+            return std::make_unique<SimpleAggregateAdapter<ModeAggregate<
+                double,
+                util::floating_point::NaNAwareHash<double>,
+                util::floating_point::NaNAwareEquals<double>>>>(resultType);
+          case TypeKind::TIMESTAMP:
+            return std::make_unique<
+                SimpleAggregateAdapter<ModeAggregate<Timestamp>>>(resultType);
+          case TypeKind::UNKNOWN:
+            // Regitsers Mode function with unknown type, this needs hasher for
+            // UnknownValue, we use folly::hasher for it.
+            return std::make_unique<SimpleAggregateAdapter<ModeAggregate<
+                UnknownValue,
+                folly::hasher<UnknownValue>,
+                std::equal_to<UnknownValue>>>>(resultType);
+          case TypeKind::VARCHAR:
+          case TypeKind::VARBINARY:
+            return std::make_unique<
+                SimpleAggregateAdapter<StringModeAggregate>>(resultType);
+          case TypeKind::ARRAY:
+          case TypeKind::MAP:
+          case TypeKind::ROW:
+            return std::make_unique<ComplexTypeModeAggregate<ComplexType>>(
+                resultType, inputType);
+          default:
+            VELOX_NYI(
+                "Unknown input type for {} aggregation {}",
+                name,
+                inputType->toString());
+        }
+      },
+      {false /*orderSensitive*/},
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/Register.cpp b/velox/functions/sparksql/aggregates/Register.cpp
index 0a2e06feb3bae..97c4753baee03 100644
--- a/velox/functions/sparksql/aggregates/Register.cpp
+++ b/velox/functions/sparksql/aggregates/Register.cpp
@@ -19,17 +19,50 @@
 #include "velox/functions/sparksql/aggregates/AverageAggregate.h"
 #include "velox/functions/sparksql/aggregates/BitwiseXorAggregate.h"
 #include "velox/functions/sparksql/aggregates/BloomFilterAggAggregate.h"
+#include "velox/functions/sparksql/aggregates/CentralMomentsAggregate.h"
+#include "velox/functions/sparksql/aggregates/CollectListAggregate.h"
+#include "velox/functions/sparksql/aggregates/RegrReplacementAggregate.h"
+#include "velox/functions/sparksql/aggregates/SumAggregate.h"
 
 namespace facebook::velox::functions::aggregate::sparksql {
 
-extern void registerFirstLastAggregates(const std::string& prefix);
-extern void registerMinMaxByAggregates(const std::string& prefix);
+extern void registerCollectSetAggAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerFirstLastAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMinMaxAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMinMaxByAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerModeAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
 
-void registerAggregateFunctions(const std::string& prefix) {
-  registerFirstLastAggregates(prefix);
-  registerMinMaxByAggregates(prefix);
-  registerBitwiseXorAggregate(prefix);
-  registerBloomFilterAggAggregate(prefix + "bloom_filter_agg");
-  registerAverage(prefix + "avg");
+void registerAggregateFunctions(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerFirstLastAggregates(prefix, withCompanionFunctions, overwrite);
+  registerMinMaxAggregates(prefix, withCompanionFunctions, overwrite);
+  registerMinMaxByAggregates(prefix, withCompanionFunctions, overwrite);
+  registerBitwiseXorAggregate(prefix, withCompanionFunctions, overwrite);
+  registerBloomFilterAggAggregate(
+      prefix + "bloom_filter_agg", withCompanionFunctions, overwrite);
+  registerAverage(prefix + "avg", withCompanionFunctions, overwrite);
+  registerSum(prefix + "sum", withCompanionFunctions, overwrite);
+  registerCentralMomentsAggregate(prefix, withCompanionFunctions, overwrite);
+  registerCollectSetAggAggregate(prefix, withCompanionFunctions, overwrite);
+  registerCollectListAggregate(prefix, withCompanionFunctions, overwrite);
+  registerRegrReplacementAggregate(prefix, withCompanionFunctions, overwrite);
+  registerModeAggregate(prefix, withCompanionFunctions, overwrite);
 }
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/Register.h b/velox/functions/sparksql/aggregates/Register.h
index 5bfea69916b35..fdd5953857cd3 100644
--- a/velox/functions/sparksql/aggregates/Register.h
+++ b/velox/functions/sparksql/aggregates/Register.h
@@ -18,5 +18,8 @@
 #include <string>
 
 namespace facebook::velox::functions::aggregate::sparksql {
-void registerAggregateFunctions(const std::string& prefix);
+void registerAggregateFunctions(
+    const std::string& prefix,
+    bool withCompanionFunctions = true,
+    bool overwrite = true);
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp b/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp
new file mode 100644
index 0000000000000..85f69d1f7c3fb
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/aggregates/RegrReplacementAggregate.h"
+
+#include "velox/exec/SimpleAggregateAdapter.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+namespace {
+class RegrReplacementAggregate {
+ public:
+  using InputType = Row<double>;
+  using IntermediateType =
+      Row</*n*/ double,
+          /*avg*/ double,
+          /*m2*/ double>;
+  using OutputType = double;
+
+  static bool toIntermediate(
+      exec::out_type<Row<double, double, double>>& out,
+      exec::arg_type<double> in) {
+    out.copy_from(std::make_tuple(1.0, in, 0.0));
+    return true;
+  }
+
+  struct AccumulatorType {
+    double n{0.0};
+    double avg{0.0};
+    double m2{0.0};
+
+    explicit AccumulatorType(HashStringAllocator* /*allocator*/) {}
+
+    void addInput(
+        HashStringAllocator* /*allocator*/,
+        exec::arg_type<double> data) {
+      n += 1.0;
+      double delta = data - avg;
+      double deltaN = delta / n;
+      avg += deltaN;
+      m2 += delta * (delta - deltaN);
+    }
+
+    void combine(
+        HashStringAllocator* /*allocator*/,
+        exec::arg_type<Row<double, double, double>> other) {
+      VELOX_CHECK(other.at<0>().has_value());
+      VELOX_CHECK(other.at<1>().has_value());
+      VELOX_CHECK(other.at<2>().has_value());
+
+      double otherN = other.at<0>().value();
+      double otherAvg = other.at<1>().value();
+      double otherM2 = other.at<2>().value();
+
+      double originN = n;
+      n += otherN;
+      double delta = otherAvg - avg;
+      double deltaN = n == 0.0 ? 0.0 : delta / n;
+      avg += deltaN * otherN;
+      m2 += otherM2 + delta * deltaN * originN * otherN;
+    }
+
+    bool writeIntermediateResult(exec::out_type<IntermediateType>& out) {
+      out = std::make_tuple(n, avg, m2);
+      return true;
+    }
+
+    bool writeFinalResult(exec::out_type<OutputType>& out) {
+      if (n == 0.0) {
+        return false;
+      }
+      out = m2;
+      return true;
+    }
+  };
+};
+
+exec::AggregateRegistrationResult registerRegrReplacement(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("double")
+          .intermediateType("row(double, double, double)")
+          .argumentType("double")
+          .build()};
+  return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step /*step*/,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(
+            argTypes.size(), 1, "{} takes at most one argument", name);
+        return std::make_unique<
+            exec::SimpleAggregateAdapter<RegrReplacementAggregate>>(resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+} // namespace
+
+void registerRegrReplacementAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerRegrReplacement(
+      prefix + "regr_replacement", withCompanionFunctions, overwrite);
+}
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/RegrReplacementAggregate.h b/velox/functions/sparksql/aggregates/RegrReplacementAggregate.h
new file mode 100644
index 0000000000000..d8fa8f78d28a9
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/RegrReplacementAggregate.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+void registerRegrReplacementAggregate(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/SumAggregate.cpp b/velox/functions/sparksql/aggregates/SumAggregate.cpp
new file mode 100644
index 0000000000000..a0c8fe2c0acb8
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/SumAggregate.cpp
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/sparksql/aggregates/SumAggregate.h"
+
+#include "velox/functions/lib/aggregates/SumAggregateBase.h"
+#include "velox/functions/sparksql/aggregates/DecimalSumAggregate.h"
+
+using namespace facebook::velox::functions::aggregate;
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+namespace {
+template <typename TInput, typename TAccumulator, typename ResultType>
+using SumAggregate = SumAggregateBase<TInput, TAccumulator, ResultType, true>;
+
+TypePtr getDecimalSumType(const TypePtr& resultType) {
+  if (resultType->isRow()) {
+    // If the resultType is ROW, then the type if sum is the type of the first
+    // child of the ROW.
+    return resultType->childAt(0);
+  }
+  return resultType;
+}
+
+void checkAccumulatorRowType(const TypePtr& type) {
+  VELOX_CHECK_EQ(type->kind(), TypeKind::ROW);
+  VELOX_CHECK(
+      type->childAt(0)->isShortDecimal() || type->childAt(0)->isLongDecimal());
+  VELOX_CHECK_EQ(type->childAt(1)->kind(), TypeKind::BOOLEAN);
+}
+} // namespace
+
+exec::AggregateRegistrationResult registerSum(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("double")
+          .intermediateType("double")
+          .argumentType("real")
+          .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("double")
+          .intermediateType("double")
+          .argumentType("double")
+          .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .integerVariable("r_precision", "min(38, a_precision + 10)")
+          .integerVariable("r_scale", "min(38, a_scale)")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("ROW(DECIMAL(r_precision, r_scale), boolean)")
+          .returnType("DECIMAL(r_precision, r_scale)")
+          .build(),
+  };
+
+  for (const auto& inputType : {"tinyint", "smallint", "integer", "bigint"}) {
+    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
+                             .returnType("bigint")
+                             .intermediateType("bigint")
+                             .argumentType(inputType)
+                             .build());
+  }
+
+  return exec::registerAggregateFunction(
+      name,
+      std::move(signatures),
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_EQ(argTypes.size(), 1, "{} takes only one argument", name);
+        auto inputType = argTypes[0];
+        switch (inputType->kind()) {
+          case TypeKind::TINYINT:
+            return std::make_unique<SumAggregate<int8_t, int64_t, int64_t>>(
+                BIGINT());
+          case TypeKind::SMALLINT:
+            return std::make_unique<SumAggregate<int16_t, int64_t, int64_t>>(
+                BIGINT());
+          case TypeKind::INTEGER:
+            return std::make_unique<SumAggregate<int32_t, int64_t, int64_t>>(
+                BIGINT());
+          case TypeKind::BIGINT: {
+            if (inputType->isShortDecimal()) {
+              auto const sumType = getDecimalSumType(resultType);
+              if (sumType->isShortDecimal()) {
+                return std::make_unique<exec::SimpleAggregateAdapter<
+                    DecimalSumAggregate<int64_t, int64_t>>>(resultType);
+              } else if (sumType->isLongDecimal()) {
+                return std::make_unique<exec::SimpleAggregateAdapter<
+                    DecimalSumAggregate<int64_t, int128_t>>>(resultType);
+              }
+            }
+            return std::make_unique<SumAggregate<int64_t, int64_t, int64_t>>(
+                BIGINT());
+          }
+          case TypeKind::HUGEINT: {
+            VELOX_CHECK(inputType->isLongDecimal());
+            // If inputType is long decimal,
+            // its output type is always long decimal.
+            return std::make_unique<exec::SimpleAggregateAdapter<
+                DecimalSumAggregate<int128_t, int128_t>>>(resultType);
+          }
+          case TypeKind::REAL:
+            if (resultType->kind() == TypeKind::REAL) {
+              return std::make_unique<SumAggregate<float, double, float>>(
+                  resultType);
+            }
+            return std::make_unique<SumAggregate<float, double, double>>(
+                DOUBLE());
+          case TypeKind::DOUBLE:
+            if (resultType->kind() == TypeKind::REAL) {
+              return std::make_unique<SumAggregate<double, double, float>>(
+                  resultType);
+            }
+            return std::make_unique<SumAggregate<double, double, double>>(
+                DOUBLE());
+          case TypeKind::ROW: {
+            VELOX_DCHECK(!exec::isRawInput(step));
+            checkAccumulatorRowType(inputType);
+            // For the intermediate aggregation step, input intermediate sum
+            // type is equal to final result sum type.
+            if (inputType->childAt(0)->isShortDecimal()) {
+              return std::make_unique<exec::SimpleAggregateAdapter<
+                  DecimalSumAggregate<int64_t, int64_t>>>(resultType);
+            } else if (inputType->childAt(0)->isLongDecimal()) {
+              return std::make_unique<exec::SimpleAggregateAdapter<
+                  DecimalSumAggregate<int128_t, int128_t>>>(resultType);
+            }
+          }
+            [[fallthrough]];
+          default:
+            VELOX_UNREACHABLE(
+                "Unknown input type for {} aggregation {}",
+                name,
+                inputType->kindName());
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/SumAggregate.h b/velox/functions/sparksql/aggregates/SumAggregate.h
new file mode 100644
index 0000000000000..51341a1bff641
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/SumAggregate.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "velox/exec/Aggregate.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+
+exec::AggregateRegistrationResult registerSum(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
index fdef8a189bf59..93057ef155a56 100644
--- a/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
@@ -16,7 +16,7 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
 using namespace facebook::velox::exec::test;
@@ -30,7 +30,6 @@ class AverageAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    allowInputShuffle();
     registerAggregateFunctions("spark_");
   }
 };
diff --git a/velox/functions/sparksql/aggregates/tests/BitwiseXorAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/BitwiseXorAggregationTest.cpp
index 21e9baca69c7f..ea422392a4c07 100644
--- a/velox/functions/sparksql/aggregates/tests/BitwiseXorAggregationTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/BitwiseXorAggregationTest.cpp
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
 namespace facebook::velox::functions::aggregate::sparksql::test {
@@ -25,7 +25,6 @@ class BitwiseXorAggregationTest : public aggregate::test::AggregationTestBase {
   void SetUp() override {
     AggregationTestBase::SetUp();
     registerAggregateFunctions("");
-    allowInputShuffle();
   }
 
   RowTypePtr rowType_{
diff --git a/velox/functions/sparksql/aggregates/tests/BloomFilterAggAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/BloomFilterAggAggregateTest.cpp
index 597ba026d6ea8..d36fe420a9137 100644
--- a/velox/functions/sparksql/aggregates/tests/BloomFilterAggAggregateTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/BloomFilterAggAggregateTest.cpp
@@ -18,7 +18,7 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
 namespace facebook::velox::functions::aggregate::sparksql::test {
@@ -29,10 +29,9 @@ class BloomFilterAggAggregateTest
   void SetUp() override {
     AggregationTestBase::SetUp();
     registerAggregateFunctions("");
-    allowInputShuffle();
   }
 
-  std::string getSerializedBloomFilter(int32_t capacity) {
+  VectorPtr getSerializedBloomFilter(int32_t capacity) {
     BloomFilter bloomFilter;
     bloomFilter.reset(capacity);
     for (auto i = 0; i < 9; ++i) {
@@ -41,7 +40,7 @@ class BloomFilterAggAggregateTest
     std::string data;
     data.resize(bloomFilter.serializedSize());
     bloomFilter.serialize(data.data());
-    return data;
+    return makeConstant(StringView(data), 1, VARBINARY());
   }
 };
 } // namespace
@@ -49,10 +48,7 @@ class BloomFilterAggAggregateTest
 TEST_F(BloomFilterAggAggregateTest, basic) {
   auto vectors = {makeRowVector({makeFlatVector<int64_t>(
       100, [](vector_size_t row) { return row % 9; })})};
-  auto bloomFilter = getSerializedBloomFilter(4);
-  auto expected = {
-      makeRowVector({makeConstant<StringView>(StringView(bloomFilter), 1)})};
-
+  auto expected = {makeRowVector({getSerializedBloomFilter(4)})};
   testAggregations(vectors, {}, {"bloom_filter_agg(c0, 5, 64)"}, expected);
 }
 
@@ -60,21 +56,17 @@ TEST_F(BloomFilterAggAggregateTest, bloomFilterAggArgument) {
   auto vectors = {makeRowVector({makeFlatVector<int64_t>(
       100, [](vector_size_t row) { return row % 9; })})};
 
-  auto bloomFilter1 = getSerializedBloomFilter(3);
-  auto expected1 = {
-      makeRowVector({makeConstant<StringView>(StringView(bloomFilter1), 1)})};
+  auto expected1 = {makeRowVector({getSerializedBloomFilter(3)})};
   testAggregations(vectors, {}, {"bloom_filter_agg(c0, 6)"}, expected1);
+
   // This capacity is kMaxNumBits / 16.
-  auto bloomFilter2 = getSerializedBloomFilter(262144);
-  auto expected2 = {
-      makeRowVector({makeConstant<StringView>(StringView(bloomFilter2), 1)})};
+  auto expected2 = {makeRowVector({getSerializedBloomFilter(262144)})};
   testAggregations(vectors, {}, {"bloom_filter_agg(c0)"}, expected2);
 }
 
 TEST_F(BloomFilterAggAggregateTest, emptyInput) {
   auto vectors = {makeRowVector({makeFlatVector<int64_t>({})})};
-  auto expected = {makeRowVector(
-      {makeNullableFlatVector<StringView>({std::nullopt}, VARBINARY())})};
+  auto expected = {makeRowVector({makeNullConstant(TypeKind::VARBINARY, 1)})};
   testAggregations(vectors, {}, {"bloom_filter_agg(c0, 5, 64)"}, expected);
 }
 
@@ -91,9 +83,8 @@ TEST_F(BloomFilterAggAggregateTest, nullBloomFilter) {
 TEST_F(BloomFilterAggAggregateTest, config) {
   auto vector = {makeRowVector({makeFlatVector<int64_t>(
       100, [](vector_size_t row) { return row % 9; })})};
-  auto bloomFilter = getSerializedBloomFilter(100);
   std::vector<RowVectorPtr> expected = {
-      makeRowVector({makeConstant<StringView>(StringView(bloomFilter), 1)})};
+      makeRowVector({getSerializedBloomFilter(100)})};
 
   // This config will decide the bloom filter capacity, the expected value is
   // the serialized bloom filter, it should be consistent.
diff --git a/velox/functions/sparksql/aggregates/tests/CMakeLists.txt b/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
index 806d539c5610f..15663519b08ca 100644
--- a/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
@@ -14,13 +14,20 @@
 
 add_executable(
   velox_functions_spark_aggregates_test
+  AverageAggregationTest.cpp
   BitwiseXorAggregationTest.cpp
   BloomFilterAggAggregateTest.cpp
+  CentralMomentsAggregationTest.cpp
+  CollectListAggregateTest.cpp
+  CollectSetAggregateTest.cpp
   FirstAggregateTest.cpp
   LastAggregateTest.cpp
-  AverageAggregationTest.cpp
   Main.cpp
-  MinMaxByAggregationTest.cpp)
+  MinMaxAggregationTest.cpp
+  MinMaxByAggregationTest.cpp
+  ModeAggregateTest.cpp
+  RegrReplacementAggregationTest.cpp
+  SumAggregationTest.cpp)
 
 add_test(velox_functions_spark_aggregates_test
          velox_functions_spark_aggregates_test)
@@ -30,8 +37,10 @@ target_link_libraries(
   velox_exec_test_lib
   velox_vector_test_lib
   velox_functions_aggregates_test_lib
+  velox_functions_spark
   velox_functions_spark_aggregates
   velox_hive_connector
+  velox_vector_fuzzer
   gflags::gflags
-  gtest
-  gtest_main)
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/functions/sparksql/aggregates/tests/CentralMomentsAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/CentralMomentsAggregationTest.cpp
new file mode 100644
index 0000000000000..9f5dd9b3efd8b
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/CentralMomentsAggregationTest.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+
+namespace {
+class CentralMomentsAggregationTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerAggregateFunctions("spark_");
+  }
+
+  void testCenteralMomentsAggResult(
+      const std::string& agg,
+      const RowVectorPtr& input,
+      const RowVectorPtr& expected) {
+    PlanBuilder builder(pool());
+    builder.values({input});
+    builder.singleAggregation({}, {fmt::format("spark_{}(c0)", agg)});
+    AssertQueryBuilder(builder.planNode()).assertResults({expected});
+  }
+};
+
+TEST_F(CentralMomentsAggregationTest, skewnessHasResult) {
+  auto agg = "skewness";
+  auto input = makeRowVector({makeFlatVector<int32_t>({1, 2})});
+  // Even when the count is 2, Spark still produces output.
+  auto expected =
+      makeRowVector({makeFlatVector<double>(std::vector<double>{0.0})});
+  testCenteralMomentsAggResult(agg, input, expected);
+
+  input = makeRowVector({makeFlatVector<int32_t>({1, 1})});
+  expected = makeRowVector({makeNullableFlatVector<double>(
+      std::vector<std::optional<double>>{std::nullopt})});
+  testCenteralMomentsAggResult(agg, input, expected);
+}
+
+TEST_F(CentralMomentsAggregationTest, pearsonKurtosis) {
+  auto agg = "kurtosis";
+  auto input = makeRowVector({makeFlatVector<int32_t>({1, 10, 100, 10, 1})});
+  auto expected = makeRowVector(
+      {makeFlatVector<double>(std::vector<double>{0.19432323191699075})});
+  testCenteralMomentsAggResult(agg, input, expected);
+
+  input = makeRowVector({makeFlatVector<int32_t>({-10, -20, 100, 1000})});
+  expected = makeRowVector(
+      {makeFlatVector<double>(std::vector<double>{-0.7014368047529627})});
+  testCenteralMomentsAggResult(agg, input, expected);
+
+  // Even when the count is 2, Spark still produces non-null result.
+  input = makeRowVector({makeFlatVector<int32_t>({1, 2})});
+  expected = makeRowVector({makeFlatVector<double>(std::vector<double>{-2.0})});
+  testCenteralMomentsAggResult(agg, input, expected);
+
+  // Output NULL when m2 equals 0.
+  input = makeRowVector({makeFlatVector<int32_t>({1, 1})});
+  expected = makeRowVector({makeNullableFlatVector<double>(
+      std::vector<std::optional<double>>{std::nullopt})});
+  testCenteralMomentsAggResult(agg, input, expected);
+}
+
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/CollectListAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/CollectListAggregateTest.cpp
new file mode 100644
index 0000000000000..73088a47b6202
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/CollectListAggregateTest.cpp
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+
+namespace {
+
+class CollectListAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerAggregateFunctions("spark_");
+  }
+};
+
+TEST_F(CollectListAggregateTest, groupBy) {
+  std::vector<RowVectorPtr> batches;
+  // Creating 3 batches of input data.
+  // 0: {0, null} {0, 1}    {0, 2}
+  // 1: {1, 1}    {1, null} {1, 3}
+  // 2: {2, 2}    {2, 3}    {2, null}
+  // 3: {3, 3}    {3, 4}    {3, 5}
+  // 4: {4, 4}    {4, 5}    {4, 6}
+  for (auto i = 0; i < 3; i++) {
+    RowVectorPtr data = makeRowVector(
+        {makeFlatVector<int32_t>({0, 1, 2, 3, 4}),
+         makeFlatVector<int64_t>(
+             5,
+             [&i](const vector_size_t& row) { return i + row; },
+             [&i](const auto& row) { return i == row; })});
+    batches.push_back(data);
+  }
+
+  auto expected = makeRowVector(
+      {makeFlatVector<int32_t>({0, 1, 2, 3, 4}),
+       makeArrayVectorFromJson<int64_t>(
+           {"[1, 2]", "[1, 3]", "[2, 3]", "[3, 4, 5]", "[4, 5, 6]"})});
+
+  testAggregations(
+      batches,
+      {"c0"},
+      {"spark_collect_list(c1)"},
+      {"c0", "array_sort(a0)"},
+      {expected});
+  testAggregationsWithCompanion(
+      batches,
+      [](auto& /*builder*/) {},
+      {"c0"},
+      {"spark_collect_list(c1)"},
+      {{BIGINT()}},
+      {"c0", "array_sort(a0)"},
+      {expected},
+      {});
+}
+
+TEST_F(CollectListAggregateTest, global) {
+  auto data = makeRowVector({makeNullableFlatVector<int32_t>(
+      {std::nullopt, 1, 2, std::nullopt, 4, 5})});
+  auto expected =
+      makeRowVector({makeArrayVectorFromJson<int32_t>({"[1, 2, 4, 5]"})});
+
+  testAggregations(
+      {data}, {}, {"spark_collect_list(c0)"}, {"array_sort(a0)"}, {expected});
+  testAggregationsWithCompanion(
+      {data},
+      [](auto& /*builder*/) {},
+      {},
+      {"spark_collect_list(c0)"},
+      {{INTEGER()}},
+      {"array_sort(a0)"},
+      {expected});
+}
+
+TEST_F(CollectListAggregateTest, ignoreNulls) {
+  auto input = makeRowVector({makeNullableFlatVector<int32_t>(
+      {1, 2, std::nullopt, 4, std::nullopt, 6})});
+  // Spark will ignore all null values in the input.
+  auto expected =
+      makeRowVector({makeArrayVectorFromJson<int32_t>({"[1, 2, 4, 6]"})});
+  testAggregations(
+      {input}, {}, {"spark_collect_list(c0)"}, {"array_sort(a0)"}, {expected});
+  testAggregationsWithCompanion(
+      {input},
+      [](auto& /*builder*/) {},
+      {},
+      {"spark_collect_list(c0)"},
+      {{INTEGER()}},
+      {"array_sort(a0)"},
+      {expected},
+      {});
+}
+
+TEST_F(CollectListAggregateTest, allNullsInput) {
+  auto input = makeRowVector({makeAllNullFlatVector<int64_t>(100)});
+  // If all input data is null, Spark will output an empty array.
+  auto expected = makeRowVector({makeArrayVectorFromJson<int32_t>({"[]"})});
+  testAggregations({input}, {}, {"spark_collect_list(c0)"}, {expected});
+  testAggregationsWithCompanion(
+      {input},
+      [](auto& /*builder*/) {},
+      {},
+      {"spark_collect_list(c0)"},
+      {{BIGINT()}},
+      {},
+      {expected},
+      {});
+}
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/CollectSetAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/CollectSetAggregateTest.cpp
new file mode 100644
index 0000000000000..4a06bb10ac8ec
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/CollectSetAggregateTest.cpp
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/sparksql/Register.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+
+namespace {
+
+class CollectSetAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerAggregateFunctions("");
+    functions::sparksql::registerFunctions("spark_");
+  }
+};
+
+TEST_F(CollectSetAggregateTest, global) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 3, 4, 2, 6, 7}),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[1, 2, 3, 4, 5, 6, 7]"}),
+  });
+
+  testAggregations(
+      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+
+  // Null inputs.
+  data = makeRowVector({
+      makeNullableFlatVector<int32_t>(
+          {1, 2, std::nullopt, 4, 5, std::nullopt, 4, 2, 6, 7}),
+  });
+
+  expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[1, 2, 4, 5, 6, 7]"}),
+  });
+
+  testAggregations(
+      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+
+  // All inputs are null.
+  data = makeRowVector({
+      makeAllNullFlatVector<int32_t>(1'000),
+  });
+
+  expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[]"}),
+  });
+
+  testAggregations(
+      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+
+  data = makeRowVector({
+      makeFlatVector<double>(
+          {1,
+           std::numeric_limits<double>::quiet_NaN(),
+           std::nan("1"),
+           std::nan("2")}),
+  });
+
+  expected = makeRowVector({
+      makeArrayVector<double>({
+          {1, std::numeric_limits<double>::quiet_NaN()},
+      }),
+  });
+
+  testAggregations(
+      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+}
+
+TEST_F(CollectSetAggregateTest, noInputRow) {
+  // Empty input.
+  auto data = makeRowVector({makeFlatVector<int32_t>({})});
+  auto expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[]"}),
+  });
+  testAggregations({data}, {}, {"collect_set(c0)"}, {}, {expected});
+
+  // No input row passes aggregate filter.
+  const auto size = 1'000;
+  const auto integers =
+      makeFlatVector<int32_t>(size, [](auto row) { return row % 10; });
+  data = makeRowVector({
+      integers,
+      makeFlatVector<bool>(size, [](auto /*row*/) { return false; }),
+  });
+
+  auto op = exec::test::PlanBuilder()
+                .values({data})
+                .singleAggregation({}, {"collect_set(c0)"}, {"c1"})
+                .planNode();
+  assertQuery(op, expected);
+
+  // Some groups have no input row passes aggregate filter.
+  data = makeRowVector({
+      integers,
+      integers,
+      makeFlatVector<bool>(size, [](auto row) { return row % 2 == 0; }),
+  });
+  expected = makeRowVector({
+      makeFlatVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
+      makeArrayVectorFromJson<int32_t>(
+          {"[0]", "[]", "[2]", "[]", "[4]", "[]", "[6]", "[]", "[8]", "[]"}),
+  });
+  op = exec::test::PlanBuilder()
+           .values({data})
+           .singleAggregation({"c0"}, {"collect_set(c1)"}, {"c2"})
+           .planNode();
+  assertQuery(op, expected);
+}
+
+TEST_F(CollectSetAggregateTest, groupBy) {
+  auto data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2, 2, 1, 2, 1, 2, 1}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 3, 4, 2, 6, 7}),
+  });
+
+  auto expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeArrayVectorFromJson<int32_t>({"[1, 2, 3, 7]", "[3, 4, 5, 6]"}),
+  });
+
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"collect_set(c1)"},
+      {"c0", "spark_array_sort(a0)"},
+      {expected});
+
+  // Null inputs.
+  data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2, 2, 1, 2, 1, 2, 1}),
+      makeNullableFlatVector<int32_t>(
+          {1,
+           std::nullopt,
+           3,
+           std::nullopt,
+           5,
+           std::nullopt,
+           3,
+           std::nullopt,
+           6,
+           1}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1]",
+          "[3, 5, 6]",
+      }),
+  });
+
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"collect_set(c1)"},
+      {"c0", "spark_array_sort(a0)"},
+      {expected});
+
+  // All inputs are null for a group.
+  data = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 2, 2, 2, 1, 2, 1, 2, 1}),
+      makeNullableFlatVector<int32_t>(
+          {1,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           std::nullopt,
+           1}),
+  });
+
+  expected = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1]",
+          "[]",
+      }),
+  });
+
+  testAggregations(
+      {data, data, data},
+      {"c0"},
+      {"collect_set(c1)"},
+      {"c0", "spark_array_sort(a0)"},
+      {expected});
+
+  data = makeRowVector({
+      makeFlatVector<int16_t>({1, 2}),
+      makeMapVectorFromJson<int64_t, int64_t>({
+          "{10: 10, 11: 11}",
+          "{12: 12}",
+      }),
+  });
+
+  testFailingAggregations(
+      {data}, {"c0"}, {"collect_set(c1)"}, "Unsupported type MAP");
+}
+
+TEST_F(CollectSetAggregateTest, arrayWithNestedNulls) {
+  auto data = makeRowVector({
+      makeArrayVectorFromJson<int32_t>(
+          {"[1, 2, 3]",
+           "[4 ,5]",
+           "[1, 2, 3]",
+           "[3, 4, 2, 6, 7]",
+           "[1, 2, 3]",
+           "[4 ,5, null]"}),
+  });
+
+  auto expected = makeRowVector({makeNestedArrayVectorFromJson<int32_t>(
+      {"[[1, 2, 3], [3, 4, 2, 6, 7], [4 ,5], [4 ,5, null]]"})});
+
+  testAggregations(
+      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+}
+
+TEST_F(CollectSetAggregateTest, rowWithNestedNull) {
+  auto data = makeRowVector({makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 2, 1}),
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 2, 1}),
+  })});
+  auto expected = makeRowVector({
+      makeArrayOfRowVector(
+          ROW({INTEGER(), INTEGER()}),
+          {
+              {
+                  variant::row({1, 1}),
+                  variant::row({2, 2}),
+                  variant::row({2, variant::null(TypeKind::INTEGER)}),
+              },
+          }),
+  });
+
+  testAggregations(
+      {data}, {}, {"collect_set(c0)"}, {"spark_array_sort(a0)"}, {expected});
+}
+
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/FirstAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/FirstAggregateTest.cpp
index b6a0c00c9a748..45fde44561000 100644
--- a/velox/functions/sparksql/aggregates/tests/FirstAggregateTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/FirstAggregateTest.cpp
@@ -14,11 +14,15 @@
  * limitations under the License.
  */
 
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
 using namespace facebook::velox::functions::aggregate::test;
+using facebook::velox::exec::test::AssertQueryBuilder;
+using facebook::velox::exec::test::PlanBuilder;
 
 namespace facebook::velox::functions::aggregate::sparksql::test {
 
@@ -29,6 +33,9 @@ class FirstAggregateTest : public AggregationTestBase {
   void SetUp() override {
     AggregationTestBase::SetUp();
     registerAggregateFunctions("spark_");
+    // Disable incremental aggregation tests because the boolean field in
+    // intermediate result of spark_first is unset and has undefined value.
+    AggregationTestBase::disableTestIncremental();
   }
 
   template <typename T>
@@ -52,9 +59,7 @@ class FirstAggregateTest : public AggregationTestBase {
             vectors,
             {"c0"},
             {"spark_first_ignore_null(c1)"},
-            "SELECT c0, first(c1 ORDER BY c1 NULLS LAST) FROM tmp GROUP BY c0",
-            /*config*/ {},
-            /*testWithTableScan*/ false);
+            "SELECT c0, first(c1 ORDER BY c1 NULLS LAST) FROM tmp GROUP BY c0");
       }
       {
         // Expected result should have first 7 rows including nulls.
@@ -66,13 +71,7 @@ class FirstAggregateTest : public AggregationTestBase {
                 [](auto row) { return row; }, // valueAt
                 [](auto row) { return row % 3 == 0; }), // nullAt
         })};
-        testAggregations(
-            vectors,
-            {"c0"},
-            {"spark_first(c1)"},
-            expected,
-            /*config*/ {},
-            /*testWithTableScan*/ false);
+        testAggregations(vectors, {"c0"}, {"spark_first(c1)"}, expected);
       }
     }
 
@@ -85,24 +84,13 @@ class FirstAggregateTest : public AggregationTestBase {
         SCOPED_TRACE("ignore null + global");
         auto expectedTrue = {makeRowVector({makeNullableFlatVector<T>({1})})};
         testAggregations(
-            vectors,
-            {},
-            {"spark_first_ignore_null(c0)"},
-            expectedTrue,
-            /*config*/ {},
-            /*testWithTableScan*/ false);
+            vectors, {}, {"spark_first_ignore_null(c0)"}, expectedTrue);
       }
       {
         SCOPED_TRACE("not ignore null + global");
         auto expectedFalse = {
             makeRowVector({makeNullableFlatVector<T>({std::nullopt})})};
-        testAggregations(
-            vectors,
-            {},
-            {"spark_first(c0)"},
-            expectedFalse,
-            /*config*/ {},
-            /*testWithTableScan*/ false);
+        testAggregations(vectors, {}, {"spark_first(c0)"}, expectedFalse);
       }
     }
   }
@@ -114,23 +102,12 @@ class FirstAggregateTest : public AggregationTestBase {
     {
       SCOPED_TRACE("ignore null + group by");
       testAggregations(
-          data,
-          {"c0"},
-          {"spark_first_ignore_null(c1)"},
-          ignoreNullData,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+          data, {"c0"}, {"spark_first_ignore_null(c1)"}, ignoreNullData);
     }
 
     {
       SCOPED_TRACE("not ignore null + group by");
-      testAggregations(
-          data,
-          {"c0"},
-          {"spark_first(c1)"},
-          hasNullData,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+      testAggregations(data, {"c0"}, {"spark_first(c1)"}, hasNullData);
     }
   }
 
@@ -141,23 +118,12 @@ class FirstAggregateTest : public AggregationTestBase {
     {
       SCOPED_TRACE("ignore null + global");
       testAggregations(
-          data,
-          {},
-          {"spark_first_ignore_null(c0)"},
-          ignoreNullData,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+          data, {}, {"spark_first_ignore_null(c0)"}, ignoreNullData);
     }
 
     {
       SCOPED_TRACE("not ignore null + global");
-      testAggregations(
-          data,
-          {},
-          {"spark_first(c0)"},
-          hasNullData,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+      testAggregations(data, {}, {"spark_first(c0)"}, hasNullData);
     }
   }
 };
@@ -422,9 +388,7 @@ TEST_F(FirstAggregateTest, varcharGroupBy) {
         vectors,
         {"c0"},
         {"spark_first_ignore_null(c1)"},
-        "SELECT c0, first(c1) FROM tmp WHERE c1 IS NOT NULL GROUP BY c0",
-        /*config*/ {},
-        /*testWithTableScan*/ false);
+        "SELECT c0, first(c1) FROM tmp WHERE c1 IS NOT NULL GROUP BY c0");
   }
 
   {
@@ -436,13 +400,7 @@ TEST_F(FirstAggregateTest, varcharGroupBy) {
             [&data](auto row) { return StringView(data[row]); }, // valueAt
             nullEvery(3)),
     })};
-    testAggregations(
-        vectors,
-        {"c0"},
-        {"spark_first(c1)"},
-        expected,
-        /*config*/ {},
-        /*testWithTableScan*/ false);
+    testAggregations(vectors, {"c0"}, {"spark_first(c1)"}, expected);
   }
 }
 
@@ -533,13 +491,7 @@ TEST_F(FirstAggregateTest, mapGroupBy) {
           [](auto idx) { return idx * 0.1; }), // valueAt
   })};
 
-  testAggregations(
-      vectors,
-      {"c0"},
-      {"spark_first(c1)"},
-      expected,
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations(vectors, {"c0"}, {"spark_first(c1)"}, expected);
 }
 
 TEST_F(FirstAggregateTest, mapGlobal) {
@@ -562,5 +514,35 @@ TEST_F(FirstAggregateTest, mapGlobal) {
   testGlobalAggregate(vectors, ignoreNullData, hasNullData);
 }
 
+TEST_F(FirstAggregateTest, spillingAndSorting) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 1, 2, 2, 2}),
+      makeFlatVector<int32_t>({3, 2, 1, 0, 6, 5, 4, 5, 1, 3}),
+  });
+
+  auto plan = PlanBuilder()
+                  .values(split(data))
+                  .singleAggregation({"c0"}, {"spark_first(c1 ORDER BY c1)"})
+                  .planNode();
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<int32_t>({0, 1}),
+  });
+
+  auto results = AssertQueryBuilder(plan).copyResults(pool());
+  exec::test::assertEqualResults({expected}, {results});
+
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+
+  exec::TestScopedSpillInjection scopedSpillInjection(100);
+  results = AssertQueryBuilder(plan)
+                .config(core::QueryConfig::kSpillEnabled, "true")
+                .config(core::QueryConfig::kAggregationSpillEnabled, "true")
+                .spillDirectory(spillDirectory->getPath())
+                .copyResults(pool());
+  exec::test::assertEqualResults({expected}, {results});
+}
+
 } // namespace
 } // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/LastAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/LastAggregateTest.cpp
index 94a76d6cc1e7b..411cd117aafb0 100644
--- a/velox/functions/sparksql/aggregates/tests/LastAggregateTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/LastAggregateTest.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
 namespace facebook::velox::functions::aggregate::sparksql::test {
@@ -27,6 +27,9 @@ class LastAggregateTest : public aggregate::test::AggregationTestBase {
   void SetUp() override {
     aggregate::test::AggregationTestBase::SetUp();
     registerAggregateFunctions("spark_");
+    // Disable incremental aggregation tests because the boolean field in
+    // intermediate result of spark_last is unset and has undefined value.
+    AggregationTestBase::disableTestIncremental();
   }
 
   template <typename T>
@@ -50,9 +53,7 @@ class LastAggregateTest : public aggregate::test::AggregationTestBase {
             vectors,
             {"c0"},
             {"spark_last_ignore_null(c1)"},
-            "SELECT c0, last(c1 ORDER BY c1 NULLS FIRST) FROM tmp GROUP BY c0",
-            /*config*/ {},
-            /*testWithTableScan*/ false);
+            "SELECT c0, last(c1 ORDER BY c1 NULLS FIRST) FROM tmp GROUP BY c0");
       }
       {
         // Expected result should have first 7 rows including nulls.
@@ -64,13 +65,7 @@ class LastAggregateTest : public aggregate::test::AggregationTestBase {
                 [](auto row) { return 91 + row; }, // valueAt
                 [](auto row) { return (91 + row) % 3 == 0; }), // nullAt
         })};
-        testAggregations(
-            vectors,
-            {"c0"},
-            {"spark_last(c1)"},
-            expected,
-            /*config*/ {},
-            /*testWithTableScan*/ false);
+        testAggregations(vectors, {"c0"}, {"spark_last(c1)"}, expected);
       }
     }
 
@@ -83,24 +78,13 @@ class LastAggregateTest : public aggregate::test::AggregationTestBase {
         SCOPED_TRACE("ignore null + global");
         auto expectedTrue = {makeRowVector({makeNullableFlatVector<T>({2})})};
         testAggregations(
-            vectors,
-            {},
-            {"spark_last_ignore_null(c0)"},
-            expectedTrue,
-            /*config*/ {},
-            /*testWithTableScan*/ false);
+            vectors, {}, {"spark_last_ignore_null(c0)"}, expectedTrue);
       }
       {
         SCOPED_TRACE("not ignore null + global");
         auto expectedFalse = {
             makeRowVector({makeNullableFlatVector<T>({std::nullopt})})};
-        testAggregations(
-            vectors,
-            {},
-            {"spark_last(c0)"},
-            expectedFalse,
-            /*config*/ {},
-            /*testWithTableScan*/ false);
+        testAggregations(vectors, {}, {"spark_last(c0)"}, expectedFalse);
       }
     }
   }
@@ -112,23 +96,12 @@ class LastAggregateTest : public aggregate::test::AggregationTestBase {
     {
       SCOPED_TRACE("ignore null + group by");
       testAggregations(
-          data,
-          {"c0"},
-          {"spark_last_ignore_null(c1)"},
-          ignoreNullData,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+          data, {"c0"}, {"spark_last_ignore_null(c1)"}, ignoreNullData);
     }
 
     {
       SCOPED_TRACE("not ignore null + group by");
-      testAggregations(
-          data,
-          {"c0"},
-          {"spark_last(c1)"},
-          hasNullData,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+      testAggregations(data, {"c0"}, {"spark_last(c1)"}, hasNullData);
     }
   }
 
@@ -139,23 +112,12 @@ class LastAggregateTest : public aggregate::test::AggregationTestBase {
     {
       SCOPED_TRACE("ignore null + global");
       testAggregations(
-          data,
-          {},
-          {"spark_last_ignore_null(c0)"},
-          ignoreNullData,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+          data, {}, {"spark_last_ignore_null(c0)"}, ignoreNullData);
     }
 
     {
       SCOPED_TRACE("not ignore null + global");
-      testAggregations(
-          data,
-          {},
-          {"spark_last(c0)"},
-          hasNullData,
-          /*config*/ {},
-          /*testWithTableScan*/ false);
+      testAggregations(data, {}, {"spark_last(c0)"}, hasNullData);
     }
   }
 };
@@ -421,9 +383,7 @@ TEST_F(LastAggregateTest, varcharGroupBy) {
       vectors,
       {"c0"},
       {"spark_last_ignore_null(c1)"},
-      "SELECT c0, last(c1) FROM tmp WHERE c1 IS NOT NULL GROUP BY c0",
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+      "SELECT c0, last(c1) FROM tmp WHERE c1 IS NOT NULL GROUP BY c0");
 
   // Verify when ignoreNull is false.
   // Expected result should have last 7 rows [91..98) including nulls.
@@ -434,13 +394,7 @@ TEST_F(LastAggregateTest, varcharGroupBy) {
           [&data](auto row) { return StringView(data[91 + row]); }, // valueAt
           [](auto row) { return (91 + row) % 3 == 0; }), // nullAt
   })};
-  testAggregations(
-      vectors,
-      {"c0"},
-      {"spark_last(c1)"},
-      expected,
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations(vectors, {"c0"}, {"spark_last(c1)"}, expected);
 }
 
 TEST_F(LastAggregateTest, varcharGlobal) {
@@ -533,13 +487,7 @@ TEST_F(LastAggregateTest, mapGroupBy) {
           [](auto idx) { return (92 + idx) * 0.1; }), // valueAt
   })};
 
-  testAggregations(
-      vectors,
-      {"c0"},
-      {"spark_last(c1)"},
-      expected,
-      /*config*/ {},
-      /*testWithTableScan*/ false);
+  testAggregations(vectors, {"c0"}, {"spark_last(c1)"}, expected);
 }
 
 TEST_F(LastAggregateTest, mapGlobal) {
diff --git a/velox/functions/sparksql/aggregates/tests/Main.cpp b/velox/functions/sparksql/aggregates/tests/Main.cpp
index 684d28a087971..3b55575663ed0 100644
--- a/velox/functions/sparksql/aggregates/tests/Main.cpp
+++ b/velox/functions/sparksql/aggregates/tests/Main.cpp
@@ -18,6 +18,6 @@
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init(&argc, &argv, false);
   return RUN_ALL_TESTS();
 }
diff --git a/velox/functions/sparksql/aggregates/tests/MinMaxAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/MinMaxAggregationTest.cpp
new file mode 100644
index 0000000000000..36877f070812a
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/MinMaxAggregationTest.cpp
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+
+namespace {
+
+std::string min(const std::string& column) {
+  return fmt::format("spark_min({})", column);
+}
+
+std::string max(const std::string& column) {
+  return fmt::format("spark_max({})", column);
+}
+
+class MinMaxAggregationTest
+    : public functions::aggregate::test::AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerAggregateFunctions("spark_");
+  }
+
+  std::vector<RowVectorPtr> fuzzData(const RowTypePtr& rowType) {
+    VectorFuzzer::Options options;
+    options.vectorSize = 1'000;
+    options.nullRatio = 0.1;
+    VectorFuzzer fuzzer(options, pool());
+    std::vector<RowVectorPtr> vectors(10);
+    for (auto i = 0; i < 10; ++i) {
+      vectors[i] = fuzzer.fuzzInputRow(rowType);
+    }
+    return vectors;
+  }
+
+  void doTest(const TypePtr& inputType, bool testWithTableScan = true) {
+    auto rowType = ROW({"c0", "c1", "mask"}, {BIGINT(), inputType, BOOLEAN()});
+    auto vectors = fuzzData(rowType);
+    createDuckDbTable(vectors);
+
+    static const std::string c0 = "c0";
+    static const std::string c1 = "c1";
+    static const std::string a0 = "a0";
+
+    // Global aggregation.
+    testAggregations(
+        vectors, {}, {min(c1), max(c1)}, "SELECT min(c1), max(c1) FROM tmp");
+
+    // Group by aggregation.
+    testAggregations(
+        [&](auto& builder) {
+          builder.values(vectors).project({"c0 % 10", "c1"});
+        },
+        {"p0"},
+        {min(c1), max(c1)},
+        "SELECT c0 % 10, min(c1), max(c1) FROM tmp GROUP BY 1");
+
+    // Masked aggregations.
+    auto minMaskedAgg = min(c1) + " filter (where mask)";
+    testAggregations(
+        vectors,
+        {},
+        {minMaskedAgg},
+        "SELECT min(c1) filter (where mask) FROM tmp");
+
+    testAggregations(
+        [&](auto& builder) {
+          builder.values(vectors).project({"c0 % 10", "c1", "mask"});
+        },
+        {"p0"},
+        {minMaskedAgg},
+        "SELECT c0 % 10, min(c1) filter (where mask) FROM tmp GROUP BY 1");
+
+    auto maxMaskedAgg = max(c1) + " filter (where mask)";
+    testAggregations(
+        vectors,
+        {},
+        {maxMaskedAgg},
+        "SELECT max(c1) filter (where mask) FROM tmp");
+
+    testAggregations(
+        [&](auto& builder) {
+          builder.values(vectors).project({"c0 % 10", "c1", "mask"});
+        },
+        {"p0"},
+        {maxMaskedAgg},
+        "SELECT c0 % 10, max(c1) filter (where mask) FROM tmp GROUP BY 1");
+
+    // Encodings: use filter to wrap aggregation inputs in a dictionary.
+    testAggregations(
+        [&](auto& builder) {
+          builder.values(vectors)
+              .filter("c0 % 2 = 0")
+              .project({"c0 % 11", "c1"});
+        },
+        {"p0"},
+        {min(c1), max(c1)},
+        "SELECT c0 % 11, min(c1), max(c1) FROM tmp WHERE c0 % 2 = 0 GROUP BY 1");
+
+    testAggregations(
+        [&](auto& builder) { builder.values(vectors).filter("c0 % 2 = 0"); },
+        {},
+        {min(c1), max(c1)},
+        "SELECT min(c1), max(c1) FROM tmp WHERE c0 % 2 = 0");
+  }
+};
+
+TEST_F(MinMaxAggregationTest, tinyint) {
+  doTest(TINYINT());
+}
+
+TEST_F(MinMaxAggregationTest, smallint) {
+  doTest(SMALLINT());
+}
+
+TEST_F(MinMaxAggregationTest, integer) {
+  doTest(INTEGER());
+}
+
+TEST_F(MinMaxAggregationTest, bigint) {
+  doTest(BIGINT());
+}
+
+TEST_F(MinMaxAggregationTest, real) {
+  doTest(REAL());
+}
+
+TEST_F(MinMaxAggregationTest, double) {
+  doTest(DOUBLE());
+}
+
+TEST_F(MinMaxAggregationTest, varchar) {
+  doTest(VARCHAR());
+}
+
+TEST_F(MinMaxAggregationTest, boolean) {
+  doTest(BOOLEAN());
+}
+
+TEST_F(MinMaxAggregationTest, interval) {
+  doTest(INTERVAL_DAY_TIME());
+}
+
+TEST_F(MinMaxAggregationTest, shortDecimal) {
+  doTest(DECIMAL(18, 3), false);
+}
+
+TEST_F(MinMaxAggregationTest, longDecimal) {
+  doTest(DECIMAL(20, 3), false);
+}
+
+TEST_F(MinMaxAggregationTest, timestamp) {
+  auto rowType = ROW({"c0", "c1"}, {SMALLINT(), TIMESTAMP()});
+  auto vectors = makeVectors(rowType, 1'000, 10);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {min("c1"), max("c1")},
+      "SELECT date_trunc('microsecond', min(c1)), "
+      "date_trunc('microsecond', max(c1)) FROM tmp");
+
+  testAggregations(
+      [&](auto& builder) {
+        builder.values(vectors).project({"c0 % 17 as k", "c1"});
+      },
+      {"k"},
+      {min("c1"), max("c1")},
+      "SELECT c0 % 17, date_trunc('microsecond', min(c1)), "
+      "date_trunc('microsecond', max(c1)) FROM tmp GROUP BY 1");
+}
+
+TEST_F(MinMaxAggregationTest, array) {
+  auto data = makeRowVector({
+      makeNullableArrayVector<int64_t>({
+          {1, 2, 3},
+          {2, std::nullopt},
+          {6, 7, 8},
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVector<int64_t>({
+          {1, 2, 3},
+      }),
+      makeArrayVector<int64_t>({
+          {6, 7, 8},
+      }),
+  });
+
+  testAggregations({data}, {}, {min("c0"), max("c0")}, {expected});
+
+  data = makeRowVector({
+      makeNullableArrayVector<int64_t>({
+          {1, 2, 3},
+          {3, 2},
+          {6, 7, 8},
+      }),
+  });
+  testAggregations({data}, {}, {min("c0"), max("c0")}, {expected});
+}
+
+TEST_F(MinMaxAggregationTest, row) {
+  auto data = makeRowVector({
+      makeRowVector({
+          makeFlatVector<StringView>({
+              "a"_sv,
+              "b"_sv,
+              "c"_sv,
+          }),
+          makeNullableFlatVector<StringView>({
+              std::nullopt,
+              "efg"_sv,
+              "hij"_sv,
+          }),
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeRowVector(
+          {makeFlatVector<StringView>({"a"_sv}),
+           makeNullableFlatVector<StringView>({std::nullopt})}),
+      makeRowVector(
+          {makeFlatVector<StringView>({"c"_sv}),
+           makeFlatVector<StringView>({"hij"_sv})}),
+  });
+
+  testAggregations({data}, {}, {min("c0"), max("c0")}, {expected});
+
+  data = makeRowVector({
+      makeRowVector({
+          makeFlatVector<StringView>({
+              "a"_sv,
+              "b"_sv,
+              "c"_sv,
+          }),
+          makeNullableFlatVector<StringView>({
+              "abc"_sv,
+              "efg"_sv,
+              "hij"_sv,
+          }),
+      }),
+  });
+  expected = makeRowVector({
+      makeRowVector(
+          {makeFlatVector<StringView>({"a"_sv}),
+           makeFlatVector<StringView>({"abc"_sv})}),
+      makeRowVector(
+          {makeFlatVector<StringView>({"c"_sv}),
+           makeFlatVector<StringView>({"hij"_sv})}),
+  });
+  testAggregations({data}, {}, {min("c0"), max("c0")}, {expected});
+}
+
+TEST_F(MinMaxAggregationTest, failOnUnorderableType) {
+  auto data = makeRowVector({makeMapVectorFromJson<int32_t, double>({
+      "{0: 0.05, 2: 2.05}",
+      "{4: 4.05}",
+      "{6: 6.05, 8: 8.05}",
+  })});
+
+  static const std::string kErrorMessage =
+      "Aggregate function signature is not supported";
+  for (const auto& expr : {min("c0"), max("c0")}) {
+    {
+      auto builder = PlanBuilder().values({data});
+      VELOX_ASSERT_THROW(builder.singleAggregation({}, {expr}), kErrorMessage);
+    }
+
+    {
+      auto builder = PlanBuilder().values({data});
+      VELOX_ASSERT_THROW(
+          builder.singleAggregation({"c1"}, {expr}), kErrorMessage);
+    }
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/MinMaxByAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/MinMaxByAggregationTest.cpp
index 2fb273148bf37..f164c1151e978 100644
--- a/velox/functions/sparksql/aggregates/tests/MinMaxByAggregationTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/MinMaxByAggregationTest.cpp
@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/lib/aggregates/tests/AggregationTestBase.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
 using namespace facebook::velox::functions::aggregate::test;
@@ -28,7 +29,6 @@ class MinMaxByAggregateTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    AggregationTestBase::disallowInputShuffle();
     registerAggregateFunctions("spark_");
   }
 };
@@ -113,54 +113,18 @@ TEST_F(MinMaxByAggregateTest, arrayCompare) {
 
 TEST_F(MinMaxByAggregateTest, mapCompare) {
   auto data = makeRowVector({
-      makeArrayVector<int64_t>({
-          {1, 2, 3},
-          {4, 5},
-          {6, 7, 8},
-      }),
-      makeNullableMapVector<int64_t, int64_t>({
-          {{{1, 1}, {2, 2}}},
-          {{{1, 1}, {2, std::nullopt}}},
-          {{{4, 50}}},
-      }),
+      makeArrayVector<int64_t>({}),
+      makeNullableMapVector<int64_t, int64_t>({}),
   });
+  std::vector<RowVectorPtr> expected = {};
 
-  auto expected = makeRowVector({
-      makeArrayVector<int64_t>({
-          {4, 5},
-      }),
-      makeArrayVector<int64_t>({
-          {6, 7, 8},
-      }),
-  });
+  VELOX_ASSERT_USER_THROW(
+      testAggregations({data}, {}, {"spark_min_by(c0, c1)"}, expected),
+      "Aggregate function signature is not supported");
 
-  testAggregations(
-      {data}, {}, {"spark_min_by(c0, c1)", "spark_max_by(c0, c1)"}, {expected});
-
-  data = makeRowVector({
-      makeArrayVector<int64_t>({
-          {1, 2, 3},
-          {4, 5},
-          {6, 7, 8},
-      }),
-      makeNullableMapVector<int64_t, int64_t>({
-          {{{1, 1}, {2, 2}}},
-          {{{1, 1}, {2, 3}}},
-          {{{4, 50}}},
-      }),
-  });
-
-  expected = makeRowVector({
-      makeArrayVector<int64_t>({
-          {1, 2, 3},
-      }),
-      makeArrayVector<int64_t>({
-          {6, 7, 8},
-      }),
-  });
-
-  testAggregations(
-      {data}, {}, {"spark_min_by(c0, c1)", "spark_max_by(c0, c1)"}, {expected});
+  VELOX_ASSERT_USER_THROW(
+      testAggregations({data}, {}, {"spark_max_by(c0, c1)"}, expected),
+      "Aggregate function signature is not supported");
 }
 
 TEST_F(MinMaxByAggregateTest, rowCompare) {
diff --git a/velox/functions/sparksql/aggregates/tests/ModeAggregateTest.cpp b/velox/functions/sparksql/aggregates/tests/ModeAggregateTest.cpp
new file mode 100644
index 0000000000000..135e9dee1618d
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/ModeAggregateTest.cpp
@@ -0,0 +1,502 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+
+namespace {
+
+class ModeAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerAggregateFunctions("");
+  }
+
+  void testModeWithDuck(const VectorPtr& vector1, const VectorPtr& vector2) {
+    ASSERT_EQ(vector1->size(), vector2->size());
+
+    auto num = vector1->size();
+    auto reverseIndices = makeIndicesInReverse(num);
+
+    auto vectors = makeRowVector(
+        {vector1,
+         vector2,
+         wrapInDictionary(reverseIndices, num, vector1),
+         wrapInDictionary(reverseIndices, num, vector2)});
+
+    createDuckDbTable({vectors});
+    testAggregations(
+        {vectors},
+        {"c0"},
+        {"mode(c1)"},
+        "SELECT c0, mode(c1) FROM tmp GROUP BY c0");
+
+    testAggregations(
+        {vectors},
+        {"c0"},
+        {"mode(c3)"},
+        "SELECT c0, mode(c3) FROM tmp GROUP BY c0");
+
+    testAggregations(
+        {vectors},
+        {"c2"},
+        {"mode(c1)"},
+        "SELECT c2, mode(c1) FROM tmp GROUP BY c2");
+
+    testAggregations(
+        {vectors},
+        {"c2"},
+        {"mode(c3)"},
+        "SELECT c2, mode(c3) FROM tmp GROUP BY c2");
+  }
+
+  void testGlobalModeWithDuck(const VectorPtr& vector) {
+    auto num = vector->size();
+    auto reverseIndices = makeIndicesInReverse(num);
+
+    auto vectors =
+        makeRowVector({vector, wrapInDictionary(reverseIndices, num, vector)});
+
+    createDuckDbTable({vectors});
+    testAggregations({vectors}, {}, {"mode(c0)"}, "SELECT mode(c0) FROM tmp");
+
+    testAggregations({vectors}, {}, {"mode(c1)"}, "SELECT mode(c1) FROM tmp");
+  }
+
+  void testMode(
+      const std::string& expression,
+      const std::vector<std::string>& groupKeys,
+      const VectorPtr& vector1,
+      const VectorPtr& vector2,
+      const RowVectorPtr& expected) {
+    auto vectors = makeRowVector({vector1, vector2});
+    testAggregations({vectors}, groupKeys, {expression}, {expected});
+  }
+};
+
+TEST_F(ModeAggregateTest, groupByInteger) {
+  vector_size_t num = 37;
+
+  auto vector1 = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 3; }, nullEvery(4));
+  auto vector2 = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 2; }, nullEvery(5));
+
+  testModeWithDuck(vector1, vector2);
+
+  // Test when some group-by keys have only null values.
+  auto vector3 =
+      makeNullableFlatVector<int64_t>({1, 1, 1, 2, 2, 2, 3, 3, std::nullopt});
+  auto vector4 = makeNullableFlatVector<int64_t>(
+      {10, 10, 10, 20, std::nullopt, 20, std::nullopt, std::nullopt, 20});
+
+  testModeWithDuck(vector3, vector4);
+}
+
+TEST_F(ModeAggregateTest, groupByDouble) {
+  vector_size_t num = 37;
+
+  auto vector1 = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 3; }, nullEvery(4));
+  auto vector2 = makeFlatVector<double>(
+      num, [](vector_size_t row) { return row % 2 + 0.05; }, nullEvery(5));
+
+  testModeWithDuck(vector1, vector2);
+}
+
+TEST_F(ModeAggregateTest, groupByBoolean) {
+  vector_size_t num = 37;
+
+  auto vector1 = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 3; }, nullEvery(4));
+  auto vector2 = makeFlatVector<bool>(
+      num, [](vector_size_t row) { return row % 2 == 0; }, nullEvery(5));
+
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int32_t>({std::nullopt, 0, 1, 2}),
+       makeFlatVector<bool>({true, false, false, false})});
+
+  testMode("mode(c1)", {"c0"}, vector1, vector2, expected);
+}
+
+TEST_F(ModeAggregateTest, groupByTimestamp) {
+  vector_size_t num = 10;
+
+  auto vector1 = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 3; }, nullEvery(4));
+  auto vector2 = makeFlatVector<Timestamp>(
+      num,
+      [](vector_size_t row) { return Timestamp{row % 2, 17'123'456}; },
+      nullEvery(5));
+
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int32_t>({std::nullopt, 0, 1, 2}),
+       makeFlatVector<Timestamp>(
+           {Timestamp{0, 17'123'456},
+            Timestamp{1, 17'123'456},
+            Timestamp{1, 17'123'456},
+            Timestamp{0, 17'123'456}})});
+
+  testMode("mode(c1)", {"c0"}, vector1, vector2, expected);
+}
+
+TEST_F(ModeAggregateTest, groupByDate) {
+  vector_size_t num = 10;
+
+  auto vector1 = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 3; }, nullEvery(4));
+  auto vector2 = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 2; }, nullEvery(5), DATE());
+
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int32_t>({std::nullopt, 0, 1, 2}),
+       makeFlatVector<int32_t>({0, 1, 1, 0}, DATE())});
+
+  testMode("mode(c1)", {"c0"}, vector1, vector2, expected);
+}
+
+TEST_F(ModeAggregateTest, groupByInterval) {
+  vector_size_t num = 30;
+
+  auto vector1 = makeFlatVector<int32_t>(num, [](auto row) { return row; });
+  auto vector2 = makeFlatVector<int64_t>(
+      num,
+      [](auto row) { return row % 5 == 0 ? 2 : row + 1; },
+      nullEvery(5),
+      INTERVAL_DAY_TIME());
+
+  testModeWithDuck(vector1, vector2);
+}
+
+TEST_F(ModeAggregateTest, groupByString) {
+  std::vector<std::string> strings = {
+      "grapes",
+      "oranges",
+      "sweet fruits: apple",
+      "sweet fruits: banana",
+      "sweet fruits: papaya",
+  };
+
+  auto keys = makeFlatVector<int16_t>(
+      1'002, [](auto row) { return row % 5; }, nullEvery(5));
+  auto data = makeFlatVector<StringView>(
+      1'002,
+      [&](auto row) { return StringView(strings[row % strings.size()]); },
+      nullEvery(5));
+  testModeWithDuck(keys, data);
+}
+
+TEST_F(ModeAggregateTest, globalInteger) {
+  vector_size_t num = 30;
+  auto vector = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 7; }, nullEvery(7));
+
+  testGlobalModeWithDuck(vector);
+}
+
+TEST_F(ModeAggregateTest, globalDecimal) {
+  vector_size_t num = 10;
+  auto longDecimalType = DECIMAL(20, 2);
+  auto vector1 = makeFlatVector<int128_t>(
+      num,
+      [](vector_size_t row) { return row % 4; },
+      nullEvery(7),
+      longDecimalType);
+
+  testGlobalModeWithDuck(vector1);
+
+  auto shortDecimalType = DECIMAL(6, 2);
+  auto vector2 = makeFlatVector<int64_t>(
+      num,
+      [](vector_size_t row) { return row % 4; },
+      nullEvery(7),
+      shortDecimalType);
+
+  testGlobalModeWithDuck(vector2);
+}
+
+TEST_F(ModeAggregateTest, globalUnknown) {
+  auto vector = makeAllNullFlatVector<UnknownValue>(6);
+
+  auto expected = makeRowVector({
+      BaseVector::createNullConstant(UNKNOWN(), 1, pool()),
+  });
+
+  testMode("mode(c1)", {}, vector, vector, expected);
+}
+
+TEST_F(ModeAggregateTest, globalDouble) {
+  vector_size_t num = 32;
+  auto vector = makeFlatVector<double>(
+      num, [](vector_size_t row) { return row % 5 + 0.05; }, nullEvery(5));
+
+  testGlobalModeWithDuck(vector);
+}
+
+TEST_F(ModeAggregateTest, globalBoolean) {
+  auto vector =
+      makeNullableFlatVector<bool>({false, false, true, std::nullopt});
+
+  auto expected =
+      makeRowVector({makeFlatVector<bool>(std::vector<bool>{false})});
+
+  testMode("mode(c1)", {}, vector, vector, expected);
+}
+
+TEST_F(ModeAggregateTest, globalTimestamp) {
+  vector_size_t num = 10;
+  auto vector = makeFlatVector<Timestamp>(
+      num,
+      [](vector_size_t row) { return Timestamp{row % 4, 100}; },
+      nullEvery(7));
+
+  auto expected = makeRowVector(
+      {makeFlatVector<Timestamp>(std::vector<Timestamp>{Timestamp{1, 100}})});
+
+  testMode("mode(c1)", {}, vector, vector, expected);
+}
+
+TEST_F(ModeAggregateTest, globalDate) {
+  vector_size_t num = 10;
+  auto vector = makeFlatVector<int32_t>(
+      num, [](vector_size_t row) { return row % 4; }, nullEvery(7), DATE());
+
+  auto expected =
+      makeRowVector({makeFlatVector<int32_t>(std::vector<int32_t>{1}, DATE())});
+
+  testMode("mode(c1)", {}, vector, vector, expected);
+}
+
+TEST_F(ModeAggregateTest, globalInterval) {
+  auto vector = makeFlatVector<int64_t>(
+      51, [](auto row) { return row % 7; }, nullEvery(7), INTERVAL_DAY_TIME());
+
+  testGlobalModeWithDuck(vector);
+}
+
+TEST_F(ModeAggregateTest, globalEmpty) {
+  auto vector = makeFlatVector<int32_t>({});
+
+  auto expected = makeRowVector({
+      BaseVector::createNullConstant(INTEGER(), 1, pool()),
+  });
+
+  testMode("mode(c1)", {}, vector, vector, expected);
+}
+
+TEST_F(ModeAggregateTest, globalString) {
+  std::vector<std::string> strings = {
+      "grapes",
+      "oranges",
+      "sweet fruits: apple",
+      "sweet fruits: banana",
+      "sweet fruits: papaya",
+  };
+
+  auto data = makeFlatVector<StringView>(1'001, [&](auto row) {
+    return StringView(strings[row % strings.size()]);
+  });
+  testGlobalModeWithDuck(data);
+
+  // Some nulls.
+  data = makeFlatVector<StringView>(
+      1'002,
+      [&](auto row) { return StringView(strings[row % strings.size()]); },
+      nullEvery(strings.size()));
+  testGlobalModeWithDuck(data);
+
+  // All nulls.
+  testGlobalModeWithDuck(makeAllNullFlatVector<StringView>(1'000));
+
+  // Lots of unique strings.
+  std::string scratch;
+  data = makeFlatVector<StringView>(
+      1'002,
+      [&](auto row) {
+        scratch = std::string(50 + row % 1'000, 'A' + (row % 10));
+        return StringView(scratch);
+      },
+      nullEvery(10));
+  testGlobalModeWithDuck(data);
+}
+
+TEST_F(ModeAggregateTest, globalNaNs) {
+  // Verify that NaNs with different binary representations are considered equal
+  // and deduplicated.
+  static const auto kNaN = std::numeric_limits<double>::quiet_NaN();
+  static const auto kSNaN = std::numeric_limits<double>::signaling_NaN();
+  auto vector = makeFlatVector<double>({1, kNaN, kSNaN, 2, 3, kNaN, kSNaN, 3});
+
+  auto expected =
+      makeRowVector({makeFlatVector<double>(std::vector<double>{kNaN})});
+
+  testMode("mode(c1)", {}, vector, vector, expected);
+}
+
+TEST_F(ModeAggregateTest, allNulls) {
+  auto vector = makeAllNullFlatVector<int32_t>(3);
+
+  auto expected = makeRowVector({makeAllNullFlatVector<int32_t>(1)});
+
+  testMode("mode(c1)", {}, vector, vector, expected);
+
+  vector = makeAllNullFlatVector<int32_t>(0);
+
+  testMode("mode(c1)", {}, vector, vector, expected);
+}
+
+TEST_F(ModeAggregateTest, arrays) {
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2, 3]",
+          "[1, 2]",
+          "[]",
+          "[1, 2]",
+          "[]",
+          "[1, null, 2, null]",
+          "[1, null, 2, null]",
+          "[]",
+          "[1, null, 2, null]",
+          "null",
+          "[1, null, 2, null]",
+          "null",
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeArrayVectorFromJson<int32_t>({"[1, null, 2, null]"}),
+  });
+
+  testAggregations({input}, {}, {"mode(c1)"}, {expected});
+
+  // Group by.
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1}),
+      makeArrayVectorFromJson<int32_t>({
+          "[1, null, 2, null]",
+          "[1, 2]",
+      }),
+  });
+  testAggregations({input}, {"c0"}, {"mode(c1)"}, {expected});
+}
+
+TEST_F(ModeAggregateTest, maps) {
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1}),
+      makeMapVectorFromJson<int32_t, int32_t>({
+          "{1: 10, 2: 20, 3: 30}",
+          "{1: 10, 2: 20}",
+          "{}",
+          "{1: 10, 2: 20}",
+          "{}",
+          "{1: 10, 2: 20, 3: null}",
+          "{1: 10, 2: 20, 3: null}",
+          "{}",
+          "{1: 10, 2: 20, 3: null}",
+          "null",
+          "{1: 10, 2: 20, 3: null}",
+          "null",
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeMapVectorFromJson<int32_t, int32_t>({"{1: 10, 2: 20, 3: null}"}),
+  });
+
+  testAggregations({input}, {}, {"mode(c1)"}, {expected});
+
+  // Group by.
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1}),
+      makeMapVectorFromJson<int32_t, int32_t>({
+          "{1: 10, 2: 20, 3: null}",
+          "{1: 10, 2: 20}",
+      }),
+  });
+  testAggregations({input}, {"c0"}, {"mode(c1)"}, {expected});
+}
+
+TEST_F(ModeAggregateTest, rows) {
+  auto input = makeRowVector({
+      makeRowVector({
+          makeFlatVector<int32_t>({
+              1,
+              1,
+              2,
+              1,
+          }),
+          makeNullableFlatVector<int32_t>({
+              std::nullopt,
+              1,
+              2,
+              1,
+          }),
+      }),
+  });
+
+  auto expected = makeRowVector({
+      makeRowVector({
+          makeConstant(1, 1),
+          makeConstant(1, 1),
+      }),
+  });
+
+  testAggregations({input}, {}, {"mode(c0)"}, {expected});
+
+  // Group by.
+  auto input1 = makeRowVector({
+      makeFlatVector<int64_t>({1, 0, 1, 0, 1, 1}),
+      makeRowVector({
+          makeFlatVector<int32_t>({
+              1,
+              1,
+              2,
+              1,
+              2,
+              2,
+          }),
+          makeNullableFlatVector<int32_t>({
+              std::nullopt,
+              1,
+              2,
+              1,
+              1,
+              2,
+          }),
+      }),
+  });
+  auto expected1 = makeRowVector({
+      makeFlatVector<int64_t>({0, 1}),
+      makeRowVector({
+          makeFlatVector<int32_t>({1, 2}),
+          makeFlatVector<int32_t>({1, 2}),
+      }),
+  });
+  testAggregations({input1}, {"c0"}, {"mode(c1)"}, {expected1});
+}
+
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/RegrReplacementAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/RegrReplacementAggregationTest.cpp
new file mode 100644
index 0000000000000..03219738b0dff
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/RegrReplacementAggregationTest.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+
+namespace {
+class RegrReplacementAggregationTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerAggregateFunctions("spark_");
+  }
+};
+
+TEST_F(RegrReplacementAggregationTest, groupBy) {
+  vector_size_t size = 1'000;
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(size, [](auto row) { return row % 10; }),
+      makeFlatVector<double>(size, [](auto row) { return row * 0.1; }),
+  });
+
+  createDuckDbTable({data});
+  // m2 is equal to the population variance divided by the size of the group.
+  testAggregations(
+      {data},
+      {"c0"},
+      {"spark_regr_replacement(c1)"},
+      {"c0", "a0 / 100.0"},
+      "select c0, var_pop(c1) from tmp group by c0");
+  testAggregationsWithCompanion(
+      {data},
+      [](auto& /*builder*/) {},
+      {"c0"},
+      {"spark_regr_replacement(c1)"},
+      {{DOUBLE()}},
+      {"c0", "a0 / 100.0"},
+      "select c0, var_pop(c1) from tmp group by c0");
+}
+
+TEST_F(RegrReplacementAggregationTest, global) {
+  vector_size_t size = 1'000;
+  auto data = makeRowVector({
+      makeFlatVector<double>(size, [](auto row) { return row * 0.3; }),
+  });
+
+  createDuckDbTable({data});
+  // m2 is equal to the population variance divided by the size of the group.
+  testAggregations(
+      {data},
+      {},
+      {"spark_regr_replacement(c0)"},
+      {"a0 / 1000.0"},
+      "select var_pop(c0) from tmp");
+  testAggregationsWithCompanion(
+      {data},
+      [](auto& /*builder*/) {},
+      {},
+      {"spark_regr_replacement(c0)"},
+      {{DOUBLE()}},
+      {"a0 / 1000.0"},
+      "select var_pop(c0) from tmp");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp
new file mode 100644
index 0000000000000..b273c5313a6eb
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp
@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/SumTestBase.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+using facebook::velox::exec::test::PlanBuilder;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::functions::aggregate::sparksql::test {
+
+namespace {
+class SumAggregationTest : public SumTestBase {
+ protected:
+  void SetUp() override {
+    SumTestBase::SetUp();
+    registerAggregateFunctions("spark_", true);
+  }
+
+ protected:
+  // Check global partial agg overflow, and final agg output null.
+  void decimalGlobalSumOverflow(
+      const std::vector<std::optional<int128_t>>& input,
+      const std::vector<std::optional<int128_t>>& output) {
+    const TypePtr type = DECIMAL(38, 0);
+    auto in = makeRowVector({makeNullableFlatVector<int128_t>({input}, type)});
+    auto expected =
+        makeRowVector({makeNullableFlatVector<int128_t>({output}, type)});
+    testAggregations({in}, {}, {"spark_sum(c0)"}, {expected});
+    testAggregationsWithCompanion(
+        {in},
+        [](auto& /*builder*/) {},
+        {},
+        {"spark_sum(c0)"},
+        {{type}},
+        {},
+        {expected},
+        {});
+  }
+
+  // Check group by partial agg overflow, and final agg output null.
+  void decimalGroupBySumOverflow(
+      const std::vector<std::optional<int128_t>>& input) {
+    const TypePtr type = DECIMAL(38, 0);
+    auto in = makeRowVector(
+        {makeFlatVector<int32_t>(20, [](auto row) { return row % 10; }),
+         makeNullableFlatVector<int128_t>(input, type)});
+    auto expected = makeRowVector(
+        {makeFlatVector<int32_t>(10, [](auto row) { return row; }),
+         makeNullableFlatVector<int128_t>(
+             std::vector<std::optional<int128_t>>(10, std::nullopt), type)});
+    testAggregations({in}, {"c0"}, {"spark_sum(c1)"}, {expected});
+    testAggregationsWithCompanion(
+        {in},
+        [](auto& /*builder*/) {},
+        {"c0"},
+        {"spark_sum(c1)"},
+        {{type}},
+        {"c0", "a0"},
+        {expected},
+        {});
+  }
+
+  template <typename TIn, typename TOut>
+  void decimalSumAllNulls(
+      const std::vector<std::optional<TIn>>& input,
+      const TypePtr& inputType,
+      const std::vector<std::optional<TOut>>& output,
+      const TypePtr& outputType) {
+    std::vector<RowVectorPtr> vectors;
+    VectorPtr inputDecimalVector =
+        makeNullableFlatVector<TIn>(input, inputType);
+    for (int i = 0; i < 5; ++i) {
+      vectors.emplace_back(makeRowVector(
+          {makeFlatVector<int32_t>(20, [](auto row) { return row % 4; }),
+           inputDecimalVector}));
+    }
+
+    VectorPtr outputDecimalVector =
+        makeNullableFlatVector<TOut>(output, outputType);
+    auto expected = makeRowVector(
+        {makeFlatVector<int32_t>(std::vector<int32_t>{0, 1, 2, 3}),
+         outputDecimalVector});
+    testAggregations({vectors}, {"c0"}, {"spark_sum(c1)"}, {expected});
+    testAggregationsWithCompanion(
+        {vectors},
+        [](auto& /*builder*/) {},
+        {"c0"},
+        {"spark_sum(c1)"},
+        {{inputType}},
+        {"c0", "a0"},
+        {expected},
+        {});
+  }
+};
+
+TEST_F(SumAggregationTest, overflow) {
+  SumTestBase::testAggregateOverflow<int64_t, int64_t, int64_t>("spark_sum");
+}
+
+TEST_F(SumAggregationTest, hookLimits) {
+  testHookLimits<int64_t, int64_t, true>();
+}
+
+TEST_F(SumAggregationTest, decimalSumCompanionPartial) {
+  std::vector<int64_t> shortDecimalRawVector;
+  int128_t sum = 0;
+  for (int i = 0; i < 100; ++i) {
+    shortDecimalRawVector.emplace_back(i * 1000);
+    sum += i * 1000;
+  }
+
+  auto input = makeRowVector(
+      {makeFlatVector<int64_t>(shortDecimalRawVector, DECIMAL(10, 1))});
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .singleAggregation({}, {"spark_sum_partial(c0)"})
+                  .planNode();
+  std::vector<int128_t> sumVector = {sum};
+  std::vector<bool> isEmptyVector = {false};
+  auto expected = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(sumVector, DECIMAL(20, 1)),
+       makeFlatVector<bool>(isEmptyVector)})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(SumAggregationTest, decimalSumCompanionMerge) {
+  auto intermediateInput = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(
+           std::vector<int128_t>{1000, 2000, 3000}, DECIMAL(20, 1)),
+       makeFlatVector<bool>(std::vector<bool>{false, false, false})})});
+
+  auto plan = PlanBuilder()
+                  .values({intermediateInput})
+                  .singleAggregation({}, {"spark_sum_merge(c0)"})
+                  .planNode();
+  auto expected = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(std::vector<int128_t>{6000}, DECIMAL(20, 1)),
+       makeFlatVector<bool>(std::vector<bool>{false})})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(SumAggregationTest, decimalSum) {
+  std::vector<std::optional<int64_t>> shortDecimalRawVector;
+  std::vector<std::optional<int128_t>> longDecimalRawVector;
+  for (int i = 0; i < 1000; ++i) {
+    shortDecimalRawVector.emplace_back(i * 1000);
+    longDecimalRawVector.emplace_back(HugeInt::build(i * 10, i * 100));
+  }
+  shortDecimalRawVector.emplace_back(std::nullopt);
+  longDecimalRawVector.emplace_back(std::nullopt);
+  auto input = makeRowVector(
+      {makeNullableFlatVector<int64_t>(shortDecimalRawVector, DECIMAL(10, 1)),
+       makeNullableFlatVector<int128_t>(longDecimalRawVector, DECIMAL(23, 4))});
+  createDuckDbTable({input});
+  testAggregations(
+      {input},
+      {},
+      {"spark_sum(c0)", "spark_sum(c1)"},
+      "SELECT sum(c0), sum(c1) FROM tmp");
+  testAggregationsWithCompanion(
+      {input},
+      [](auto& /*builder*/) {},
+      {},
+      {"spark_sum(c0)", "spark_sum(c1)"},
+      {{DECIMAL(10, 1)}, {DECIMAL(23, 4)}},
+      {},
+      "SELECT sum(c0), sum(c1) FROM tmp",
+      {});
+
+  // Short decimal sum aggregation with multiple groups.
+  auto inputShortDecimalRows = {
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1, 1}),
+           makeFlatVector<int64_t>(
+               std::vector<int64_t>{37220, 53450}, DECIMAL(5, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2, 2}),
+           makeFlatVector<int64_t>(
+               std::vector<int64_t>{10410, 9250}, DECIMAL(5, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({3, 3}),
+           makeFlatVector<int64_t>(
+               std::vector<int64_t>{-12783, 0}, DECIMAL(5, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1, 2}),
+           makeFlatVector<int64_t>(
+               std::vector<int64_t>{23178, 41093}, DECIMAL(5, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2, 3}),
+           makeFlatVector<int64_t>(
+               std::vector<int64_t>{-10023, 5290}, DECIMAL(5, 2))}),
+  };
+
+  auto expectedShortDecimalResult = {
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1}),
+           makeFlatVector<int64_t>(
+               std::vector<int64_t>{113848}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2}),
+           makeFlatVector<int64_t>(
+               std::vector<int64_t>{50730}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({3}),
+           makeFlatVector<int64_t>(
+               std::vector<int64_t>{-7493}, DECIMAL(15, 2))})};
+
+  testAggregations(
+      inputShortDecimalRows,
+      {"c0"},
+      {"spark_sum(c1)"},
+      expectedShortDecimalResult);
+  testAggregationsWithCompanion(
+      {inputShortDecimalRows},
+      [](auto& /*builder*/) {},
+      {"c0"},
+      {"spark_sum(c1)"},
+      {{DECIMAL(5, 2)}},
+      {"c0", "a0"},
+      expectedShortDecimalResult,
+      {});
+
+  // Long decimal sum aggregation with multiple groups.
+  auto inputLongDecimalRows = {
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1, 1}),
+           makeFlatVector<int128_t>(
+               {HugeInt::build(13, 113848), HugeInt::build(12, 53450)},
+               DECIMAL(20, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2, 2}),
+           makeFlatVector<int128_t>(
+               {HugeInt::build(21, 10410), HugeInt::build(17, 9250)},
+               DECIMAL(20, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({3, 3}),
+           makeFlatVector<int128_t>(
+               {HugeInt::build(25, 12783), HugeInt::build(19, 0)},
+               DECIMAL(20, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1, 2}),
+           makeFlatVector<int128_t>(
+               {HugeInt::build(31, 23178), HugeInt::build(82, 41093)},
+               DECIMAL(20, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2, 3}),
+           makeFlatVector<int128_t>(
+               {HugeInt::build(25, 10023), HugeInt::build(43, 5290)},
+               DECIMAL(20, 2))}),
+  };
+
+  auto expectedLongDecimalResult = {
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1}),
+           makeFlatVector<int128_t>(
+               std::vector<int128_t>{HugeInt::build(56, 190476)},
+               DECIMAL(38, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2}),
+           makeFlatVector<int128_t>(
+               std::vector<int128_t>{HugeInt::build(145, 70776)},
+               DECIMAL(38, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({3}),
+           makeFlatVector<int128_t>(
+               std::vector<int128_t>{HugeInt::build(87, 18073)},
+               DECIMAL(38, 2))})};
+
+  testAggregations(
+      inputLongDecimalRows,
+      {"c0"},
+      {"spark_sum(c1)"},
+      expectedLongDecimalResult);
+  testAggregationsWithCompanion(
+      {inputShortDecimalRows},
+      [](auto& /*builder*/) {},
+      {"c0"},
+      {"spark_sum(c1)"},
+      {{DECIMAL(20, 2)}},
+      {"c0", "a0"},
+      expectedShortDecimalResult,
+      {});
+}
+
+TEST_F(SumAggregationTest, decimalGlobalSumOverflow) {
+  // Test Positive Overflow.
+  std::vector<std::optional<int128_t>> longDecimalInput;
+  std::vector<std::optional<int128_t>> longDecimalOutput;
+  // Create input with 2 kLongDecimalMax.
+  longDecimalInput.emplace_back(DecimalUtil::kLongDecimalMax);
+  longDecimalInput.emplace_back(DecimalUtil::kLongDecimalMax);
+  // The sum must overflow, and will return null
+  decimalGlobalSumOverflow(longDecimalInput, {std::nullopt});
+
+  // Now add kLongDecimalMin.
+  // The sum now must not overflow.
+  longDecimalInput.emplace_back(DecimalUtil::kLongDecimalMin);
+  longDecimalOutput.emplace_back(DecimalUtil::kLongDecimalMax);
+  decimalGlobalSumOverflow(longDecimalInput, longDecimalOutput);
+
+  // Test Negative Overflow.
+  longDecimalInput.clear();
+  longDecimalOutput.clear();
+
+  // Create input with 2 kLongDecimalMin.
+  longDecimalInput.emplace_back(DecimalUtil::kLongDecimalMin);
+  longDecimalInput.emplace_back(DecimalUtil::kLongDecimalMin);
+
+  // The sum must overflow, and will return null
+  decimalGlobalSumOverflow(longDecimalInput, {std::nullopt});
+
+  // Now add kLongDecimalMax.
+  // The sum now must not overflow.
+  longDecimalInput.emplace_back(DecimalUtil::kLongDecimalMax);
+  longDecimalOutput.emplace_back(DecimalUtil::kLongDecimalMin);
+  decimalGlobalSumOverflow(longDecimalInput, longDecimalOutput);
+
+  // Check value in range.
+  longDecimalInput.clear();
+  longDecimalInput.emplace_back(DecimalUtil::kLongDecimalMax);
+  longDecimalInput.emplace_back(1);
+  decimalGlobalSumOverflow(longDecimalInput, {std::nullopt});
+
+  longDecimalInput.clear();
+  longDecimalInput.emplace_back(DecimalUtil::kLongDecimalMin);
+  longDecimalInput.emplace_back(-1);
+  decimalGlobalSumOverflow(longDecimalInput, {std::nullopt});
+}
+
+TEST_F(SumAggregationTest, decimalGroupBySumOverflow) {
+  // Test Positive Overflow.
+  decimalGroupBySumOverflow(
+      std::vector<std::optional<int128_t>>(20, DecimalUtil::kLongDecimalMax));
+
+  // Test Negative Overflow.
+  decimalGroupBySumOverflow(
+      std::vector<std::optional<int128_t>>(20, DecimalUtil::kLongDecimalMin));
+
+  // Check value in range.
+  auto decimalVector =
+      std::vector<std::optional<int128_t>>(10, DecimalUtil::kLongDecimalMax);
+  auto oneValueVector = std::vector<std::optional<int128_t>>(10, 1);
+  decimalVector.insert(
+      decimalVector.end(), oneValueVector.begin(), oneValueVector.end());
+  decimalGroupBySumOverflow(decimalVector);
+
+  decimalVector =
+      std::vector<std::optional<int128_t>>(10, DecimalUtil::kLongDecimalMin);
+  oneValueVector = std::vector<std::optional<int128_t>>(10, -1);
+  decimalVector.insert(
+      decimalVector.end(), oneValueVector.begin(), oneValueVector.end());
+  decimalGroupBySumOverflow(decimalVector);
+}
+
+TEST_F(SumAggregationTest, decimalAllNullValues) {
+  std::vector<std::optional<int128_t>> allNull(5, std::nullopt);
+  auto input = makeRowVector(
+      {makeNullableFlatVector<int128_t>(allNull, DECIMAL(20, 2))});
+  std::vector<std::optional<int128_t>> result = {std::nullopt};
+  auto expected =
+      makeRowVector({makeNullableFlatVector<int128_t>(result, DECIMAL(30, 2))});
+  testAggregations({input}, {}, {"spark_sum(c0)"}, {expected});
+  testAggregationsWithCompanion(
+      {input},
+      [](auto& /*builder*/) {},
+      {},
+      {"spark_sum(c0)"},
+      {{DECIMAL(20, 2)}},
+      {},
+      {expected},
+      {});
+}
+
+// Test if all values in some groups are null, the final sum of this group
+// should be null.
+TEST_F(SumAggregationTest, decimalSomeGroupsAllnullValues) {
+  std::vector<std::optional<int64_t>> shortDecimalNulls(20);
+  std::vector<std::optional<int128_t>> longDecimalNulls(20);
+  for (int i = 0; i < 20; i++) {
+    if (i % 4 == 1 || i % 4 == 3) {
+      // not all groups are null
+      shortDecimalNulls[i] = 1;
+      longDecimalNulls[i] = 1;
+    }
+  }
+
+  // Test short decimal inputs and the output sum is short decimal.
+  decimalSumAllNulls<int64_t, int64_t>(
+      shortDecimalNulls,
+      DECIMAL(7, 2),
+      std::vector<std::optional<int64_t>>{std::nullopt, 25, std::nullopt, 25},
+      DECIMAL(17, 2));
+
+  // Test short decimal inputs and the output sum is long decimal.
+  decimalSumAllNulls<int64_t, int128_t>(
+      shortDecimalNulls,
+      DECIMAL(17, 2),
+      std::vector<std::optional<int128_t>>{std::nullopt, 25, std::nullopt, 25},
+      DECIMAL(27, 2));
+
+  // Test long decimal inputs and the output sum is long decimal.
+  decimalSumAllNulls<int128_t, int128_t>(
+      longDecimalNulls,
+      DECIMAL(25, 2),
+      std::vector<std::optional<int128_t>>{std::nullopt, 25, std::nullopt, 25},
+      DECIMAL(35, 2));
+}
+
+TEST_F(SumAggregationTest, decimalRangeOverflow) {
+  // HugeInt::build(542101086242752217, 68739955140067328) =
+  // 10'000'000'000'000'000'000'000'000'000'000'000'000,
+  // one followed by 37 zeros.
+  int128_t largeNumber = HugeInt::build(542101086242752217, 68739955140067328);
+  std::vector<int128_t> firstLargeDecimals(11, largeNumber);
+  std::vector<int128_t> secondLargeDecimals(1, largeNumber);
+  auto firstInput = makeRowVector(
+      {makeFlatVector<int128_t>(firstLargeDecimals, DECIMAL(38, 18))});
+  auto secondInput = makeRowVector(
+      {makeFlatVector<int128_t>(secondLargeDecimals, DECIMAL(38, 18))});
+  std::vector<std::optional<int128_t>> result = {std::nullopt};
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int128_t>(result, DECIMAL(38, 18))});
+  testAggregations(
+      {firstInput, secondInput}, {}, {"spark_sum(c0)"}, {expected});
+  testAggregationsWithCompanion(
+      {firstInput, secondInput},
+      [](auto& /*builder*/) {},
+      {},
+      {"spark_sum(c0)"},
+      {{DECIMAL(38, 18)}},
+      {},
+      {expected},
+      {});
+}
+
+TEST_F(SumAggregationTest, sumFloat) {
+  auto data =
+      makeRowVector({makeFlatVector<float>({3.4028235E38, 3.4028235E38})});
+  createDuckDbTable({data});
+
+  testAggregations(
+      [&](auto& builder) { builder.values({data}); },
+      {},
+      {"spark_sum(c0)"},
+      "SELECT sum(c0) FROM tmp");
+}
+} // namespace
+} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/benchmarks/CMakeLists.txt b/velox/functions/sparksql/benchmarks/CMakeLists.txt
index 1cb3ad1492771..8a9ef858460fa 100644
--- a/velox/functions/sparksql/benchmarks/CMakeLists.txt
+++ b/velox/functions/sparksql/benchmarks/CMakeLists.txt
@@ -23,3 +23,18 @@ target_link_libraries(
   velox_vector_fuzzer
   Folly::folly
   ${FOLLY_BENCHMARK})
+
+add_executable(velox_sparksql_benchmarks_compare CompareBenchmark.cpp)
+target_link_libraries(
+  velox_sparksql_benchmarks_compare velox_functions_spark
+  velox_benchmark_builder velox_vector_test_lib)
+
+add_executable(velox_sparksql_benchmarks_simd_compare SIMDCompareBenchmark.cpp)
+target_link_libraries(
+  velox_sparksql_benchmarks_simd_compare velox_functions_spark
+  velox_benchmark_builder velox_vector_test_lib)
+
+add_executable(velox_sparksql_benchmarks_hash HashBenchmark.cpp)
+target_link_libraries(
+  velox_sparksql_benchmarks_hash velox_functions_spark velox_benchmark_builder
+  velox_vector_test_lib)
diff --git a/velox/functions/sparksql/benchmarks/CompareBenchmark.cpp b/velox/functions/sparksql/benchmarks/CompareBenchmark.cpp
new file mode 100644
index 0000000000000..b0b7efdfc3cbe
--- /dev/null
+++ b/velox/functions/sparksql/benchmarks/CompareBenchmark.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/sparksql/Register.h"
+
+using namespace facebook;
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+  functions::sparksql::registerFunctions("");
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  for (auto nullRatio : {0.0, 0.1, 0.9}) {
+    benchmarkBuilder
+        .addBenchmarkSet(
+            fmt::format("compare#{}\%null", nullRatio * 100),
+            ROW({"c0", "c1"}, {DECIMAL(18, 6), DECIMAL(38, 16)}))
+        .withFuzzerOptions({.vectorSize = 1000, .nullRatio = nullRatio})
+        .addExpression("gt", "decimal_greaterthan(c0, c1)")
+        .addExpression(
+            "gt_with_cast", "greaterthan(cast (c0 as decimal(38, 16)), c1)")
+        .addExpression("gte", "decimal_greaterthanorequal(c0, c1)")
+        .addExpression(
+            "gte_with_cast",
+            "greaterthanorequal(cast (c0 as decimal(38, 16)), c1)")
+        .addExpression("lt", "decimal_lessthan(c0, c1)")
+        .addExpression(
+            "lt_with_cast", "lessthan(cast (c0 as decimal(38, 16)), c1)")
+        .addExpression("lte", "decimal_lessthanorequal(c0, c1)")
+        .addExpression(
+            "lte_with_cast",
+            "lessthanorequal(cast (c0 as decimal(38, 16)), c1)")
+        .addExpression("eq", "decimal_equalto(c0, c1)")
+        .addExpression(
+            "eq_with_cast", "equalto(cast (c0 as decimal(38, 16)), c1)")
+        .addExpression("neq", "decimal_notequalto(c0, c1)")
+        .addExpression(
+            "neq_with_cast", "not(equalto(cast (c0 as decimal(38, 16)), c1))")
+        .withIterations(100);
+  }
+
+  benchmarkBuilder.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/sparksql/benchmarks/HashBenchmark.cpp b/velox/functions/sparksql/benchmarks/HashBenchmark.cpp
new file mode 100644
index 0000000000000..b197cadf5965d
--- /dev/null
+++ b/velox/functions/sparksql/benchmarks/HashBenchmark.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/sparksql/Register.h"
+
+using namespace facebook;
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+  functions::sparksql::registerFunctions("");
+
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+
+  std::vector<TypePtr> inputTypes = {
+      TINYINT(),
+      SMALLINT(),
+      BIGINT(),
+      REAL(),
+      DOUBLE(),
+      TIMESTAMP(),
+      VARCHAR(),
+      DECIMAL(18, 6),
+      DECIMAL(38, 6),
+      UNKNOWN(),
+      ARRAY(MAP(INTEGER(), VARCHAR())),
+      ROW({"f_map", "f_array"}, {MAP(INTEGER(), VARCHAR()), ARRAY(INTEGER())}),
+  };
+  for (auto nullRatio : {0.0, 0.25}) {
+    for (auto& inputType : inputTypes) {
+      benchmarkBuilder
+          .addBenchmarkSet(
+              fmt::format(
+                  "hash#{}#{}\%nulls", inputType->toString(), nullRatio * 100),
+              ROW({"c0"}, {inputType}))
+          .withFuzzerOptions({.vectorSize = 4096, .nullRatio = nullRatio})
+          .addExpression("hash", "hash(c0)")
+          .addExpression("xxhash64", "xxhash64(c0)")
+          .withIterations(100);
+    }
+  }
+
+  benchmarkBuilder.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/sparksql/benchmarks/In.cpp b/velox/functions/sparksql/benchmarks/In.cpp
index bfe7ad39faabd..45600ece0ef78 100644
--- a/velox/functions/sparksql/benchmarks/In.cpp
+++ b/velox/functions/sparksql/benchmarks/In.cpp
@@ -124,7 +124,7 @@ void registerInFunctions() {
 } // namespace facebook::velox::functions::sparksql
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   facebook::velox::functions::registerPrestoIn();
   facebook::velox::functions::sparksql::registerInFunctions();
   facebook::velox::functions::registerArrayConstructor();
diff --git a/velox/functions/sparksql/benchmarks/SIMDCompareBenchmark.cpp b/velox/functions/sparksql/benchmarks/SIMDCompareBenchmark.cpp
new file mode 100644
index 0000000000000..8dda0d515596d
--- /dev/null
+++ b/velox/functions/sparksql/benchmarks/SIMDCompareBenchmark.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/sparksql/Register.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook;
+
+using namespace facebook::velox;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize({});
+  functions::sparksql::registerFunctions("");
+  std::vector<TypePtr> inputTypes = {
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      REAL(),
+      DOUBLE(),
+      TIMESTAMP(),
+      VARCHAR(),
+  };
+  ExpressionBenchmarkBuilder benchmarkBuilder;
+  for (auto nullRatio : {0.0, 0.1, 0.9}) {
+    for (auto& inputType : inputTypes) {
+      VectorFuzzer::Options opts;
+      opts.vectorSize = 10000;
+      opts.nullRatio = nullRatio;
+      VectorFuzzer fuzzer(opts, benchmarkBuilder.pool());
+      std::vector<VectorPtr> childrenVectors = {
+          fuzzer.fuzzDictionary(fuzzer.fuzzFlat(inputType)),
+          fuzzer.fuzzFlat(inputType)};
+      benchmarkBuilder
+          .addBenchmarkSet(
+              fmt::format(
+                  "Dict#{}#{}\%null", inputType->toString(), nullRatio * 100),
+              fuzzer.fuzzRow(
+                  std::move(childrenVectors), {"c0", "c1"}, opts.vectorSize))
+          .addExpression("equalto", "equalto(c0, c1)")
+          .addExpression("greaterthan", "greaterthan(c0, c1)")
+          .addExpression("greaterthanorequal", "greaterthanorequal(c0, c1)")
+          .withIterations(100);
+      benchmarkBuilder
+          .addBenchmarkSet(
+              fmt::format(
+                  "Flat#{}#{}\%null", inputType->toString(), nullRatio * 100),
+              ROW({"c0", "c1"}, {inputType, inputType}))
+          .withFuzzerOptions(opts)
+          .addExpression("equalto", "equalto(c0, c1)")
+          .addExpression("greaterthan", "greaterthan(c0, c1)")
+          .addExpression("greaterthanorequal", "greaterthanorequal(c0, c1)")
+          .withIterations(100);
+    }
+  }
+
+  benchmarkBuilder.registerBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/sparksql/coverage/CMakeLists.txt b/velox/functions/sparksql/coverage/CMakeLists.txt
index 9b8f71dad6913..b9588e5dbcdd2 100644
--- a/velox/functions/sparksql/coverage/CMakeLists.txt
+++ b/velox/functions/sparksql/coverage/CMakeLists.txt
@@ -14,6 +14,9 @@
 add_executable(velox_sparksql_coverage Coverage.cpp)
 
 target_link_libraries(
-  velox_sparksql_coverage velox_functions_spark velox_function_registry
-  velox_functions_spark_aggregates velox_functions_spark_window
+  velox_sparksql_coverage
+  velox_functions_spark
+  velox_function_registry
+  velox_functions_spark_aggregates
+  velox_functions_spark_window
   velox_coverage_util)
diff --git a/velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h b/velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h
new file mode 100644
index 0000000000000..c8978e5a6a386
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::sparksql::fuzzer {
+
+class AddSubtractArgGenerator : public velox::fuzzer::DecimalArgGeneratorBase {
+ public:
+  AddSubtractArgGenerator() {
+    initialize(2);
+  }
+
+ protected:
+  std::optional<std::pair<int, int>>
+  toReturnType(int p1, int s1, int p2, int s2) override {
+    const auto precision = std::max(p1 - s1, p2 - s2) + std::max(s1, s2) + 1;
+    const auto scale = std::max(s1, s2);
+    return DecimalUtil::adjustPrecisionScale(precision, scale);
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/fuzzer/CMakeLists.txt b/velox/functions/sparksql/fuzzer/CMakeLists.txt
new file mode 100644
index 0000000000000..2f475283262b7
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/CMakeLists.txt
@@ -0,0 +1,116 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Download Spark source code and copy the Spark connect proto files to Velox
+# directory.
+set(SPARK_VERSION 3.5.1)
+set(SPARK_SHA256_CHECKSUM
+    SHA256=8eb939a637cc9d4406467620cfef8e8985bf370d766907967fc85db3e9a120cb)
+set(SPARK_SOURCE_URL
+    "https://github.com/apache/spark/archive/refs/tags/v${SPARK_VERSION}.tar.gz"
+)
+
+FetchContent_Declare(
+  Spark
+  URL ${SPARK_SOURCE_URL}
+  URL_HASH ${SPARK_SHA256_CHECKSUM})
+FetchContent_MakeAvailable(Spark)
+
+set(SPARK_CONNECT_PROTO_BASE_DIR
+    "${spark_SOURCE_DIR}/connector/connect/common/src/main/protobuf")
+set(SPARK_CONNECT_PROTO_DIR "${SPARK_CONNECT_PROTO_BASE_DIR}/spark/connect")
+
+# Set up Spark connect.
+file(
+  GLOB PROTO_FILES
+  RELATIVE ${PROJECT_SOURCE_DIR}
+  CONFIGURE_DEPENDS ${SPARK_CONNECT_PROTO_DIR}/*.proto)
+foreach(PROTO ${PROTO_FILES})
+  get_filename_component(PROTO_NAME ${PROTO} NAME_WE)
+  list(APPEND PROTO_SRCS
+       "${PROJECT_BINARY_DIR}/spark/connect/${PROTO_NAME}.pb.cc")
+  list(APPEND PROTO_HDRS
+       "${PROJECT_BINARY_DIR}/spark/connect/${PROTO_NAME}.pb.h")
+  list(APPEND GRPC_SRCS
+       "${PROJECT_BINARY_DIR}/spark/connect/${PROTO_NAME}.grpc.pb.cc")
+  list(APPEND GRPC_HDRS
+       "${PROJECT_BINARY_DIR}/spark/connect/${PROTO_NAME}.grpc.pb.h")
+  list(APPEND PROTO_FILES_FULL "${SPARK_CONNECT_PROTO_DIR}/${PROTO_NAME}.proto")
+endforeach()
+
+set(PROTO_OUTPUT_FILES ${PROTO_HDRS} ${PROTO_SRCS})
+set_source_files_properties(${PROTO_OUTPUT_FILES} PROPERTIES GENERATED TRUE)
+
+set(GRPC_OUTPUT_FILES ${GRPC_HDRS} ${GRPC_SRCS})
+set_source_files_properties(${GRPC_OUTPUT_FILES} PROPERTIES GENERATED TRUE)
+
+# Ensure that the option --proto_path is not given an empty argument.
+foreach(PROTO_PATH ${SPARK_CONNECT_PROTO_BASE_DIR} ${Protobuf_INCLUDE_DIRS})
+  list(APPEND PROTO_PATH_ARGS --proto_path=${PROTO_PATH})
+endforeach()
+
+# Generate Spark connect hearders and sources.
+add_custom_command(
+  OUTPUT ${PROTO_OUTPUT_FILES}
+  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${PROJECT_BINARY_DIR}
+          ${PROTO_FILES_FULL}
+  DEPENDS protobuf::protoc
+  COMMENT "Running PROTO compiler"
+  VERBATIM)
+
+# Generate grpc headers and sources.
+add_custom_command(
+  OUTPUT ${GRPC_OUTPUT_FILES}
+  COMMAND
+    protobuf::protoc ${PROTO_PATH_ARGS} --grpc_out=${PROJECT_BINARY_DIR}
+    --plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
+    ${PROTO_FILES_FULL}
+  DEPENDS protobuf::protoc
+  COMMENT "Running gRPC C++ protocol buffer compiler"
+  VERBATIM)
+
+add_library(velox_spark_query_runner ${PROTO_SRCS} ${GRPC_SRCS}
+                                     SparkQueryRunner.cpp)
+
+target_include_directories(velox_spark_query_runner
+                           PUBLIC ${PROJECT_BINARY_DIR}/spark/connect/)
+
+target_link_libraries(
+  velox_spark_query_runner
+  velox_dwio_arrow_parquet_writer
+  velox_fuzzer_util
+  velox_exec_test_lib
+  velox_arrow_bridge
+  gRPC::grpc++
+  gRPC::grpc
+  protobuf::libprotobuf
+  arrow)
+
+add_executable(spark_aggregation_fuzzer_test SparkAggregationFuzzerTest.cpp)
+
+target_link_libraries(
+  spark_aggregation_fuzzer_test
+  velox_aggregation_fuzzer
+  velox_aggregation_fuzzer_base
+  velox_functions_spark_aggregates
+  velox_spark_query_runner
+  velox_fuzzer_util
+  velox_window
+  velox_vector_test_lib
+  GTest::gtest
+  GTest::gtest_main)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/functions/sparksql/fuzzer/DivideArgGenerator.h b/velox/functions/sparksql/fuzzer/DivideArgGenerator.h
new file mode 100644
index 0000000000000..a69706db04269
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/DivideArgGenerator.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::sparksql::fuzzer {
+
+class DivideArgGenerator : public velox::fuzzer::DecimalArgGeneratorBase {
+ public:
+  DivideArgGenerator() {
+    initialize(2);
+  }
+
+ protected:
+  std::optional<std::pair<int, int>>
+  toReturnType(int p1, int s1, int p2, int s2) override {
+    const auto scale = std::max(6, s1 + p2 + 1);
+    const auto precision = p1 - s1 + s2 + scale;
+    return DecimalUtil::adjustPrecisionScale(precision, scale);
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h b/velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h
new file mode 100644
index 0000000000000..5ff9c36888a51
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::sparksql::fuzzer {
+
+class MakeTimestampArgGenerator : public velox::fuzzer::ArgGenerator {
+ public:
+  std::vector<TypePtr> generateArgs(
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      FuzzerGenerator& rng) override {
+    const auto s = 6;
+    const auto p = rand32(s, ShortDecimalType::kMaxPrecision, rng);
+    std::vector<TypePtr> types = {
+        INTEGER(), INTEGER(), INTEGER(), INTEGER(), INTEGER(), DECIMAL(p, s)};
+
+    if (signature.argumentTypes().size() == 6) {
+      return types;
+    }
+    types.push_back(VARCHAR());
+    return types;
+  }
+
+ private:
+  static uint32_t rand32(uint32_t min, uint32_t max, FuzzerGenerator& rng) {
+    return boost::random::uniform_int_distribution<uint32_t>(min, max)(rng);
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h b/velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h
new file mode 100644
index 0000000000000..f2e49af0e0331
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/fuzzer/DecimalArgGeneratorBase.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::sparksql::fuzzer {
+
+class MultiplyArgGenerator : public velox::fuzzer::DecimalArgGeneratorBase {
+ public:
+  MultiplyArgGenerator() {
+    initialize(2);
+  }
+
+ protected:
+  std::optional<std::pair<int, int>>
+  toReturnType(int p1, int s1, int p2, int s2) override {
+    return DecimalUtil::adjustPrecisionScale(p1 + p2 + 1, s1 + s2);
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp b/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp
new file mode 100644
index 0000000000000..e5c1c3e17981a
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <unordered_set>
+
+#include "velox/exec/fuzzer/AggregationFuzzerOptions.h"
+#include "velox/exec/fuzzer/AggregationFuzzerRunner.h"
+#include "velox/exec/fuzzer/DuckQueryRunner.h"
+#include "velox/exec/fuzzer/TransformResultVerifier.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+DEFINE_string(
+    only,
+    "",
+    "If specified, Fuzzer will only choose functions from "
+    "this comma separated list of function names "
+    "(e.g: --only \"min\" or --only \"sum,avg\").");
+
+int main(int argc, char** argv) {
+  facebook::velox::functions::aggregate::sparksql::registerAggregateFunctions(
+      "", false);
+
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Calls common init functions in the necessary order, initializing
+  // singletons, installing proper signal handlers for better debugging
+  // experience, and initialize glog and gflags.
+  folly::Init init(&argc, &argv);
+
+  facebook::velox::functions::prestosql::registerInternalFunctions();
+  facebook::velox::memory::MemoryManager::initialize({});
+
+  // TODO: List of the functions that at some point crash or fail and need to
+  // be fixed before we can enable. Constant argument of bloom_filter_agg cause
+  // fuzzer test fail.
+  std::unordered_set<std::string> skipFunctions = {"bloom_filter_agg"};
+
+  using facebook::velox::exec::test::TransformResultVerifier;
+
+  auto makeArrayVerifier = []() {
+    return TransformResultVerifier::create("\"$internal$canonicalize\"({})");
+  };
+
+  // The results of the following functions depend on the order of input
+  // rows. For some functions, the result can be transformed to a value that
+  // doesn't depend on the order of inputs. If such transformation exists, it
+  // can be specified to be used for results verification. If no transformation
+  // is specified, results are not verified.
+  std::unordered_map<
+      std::string,
+      std::shared_ptr<facebook::velox::exec::test::ResultVerifier>>
+      customVerificationFunctions = {
+          {"last", nullptr},
+          {"last_ignore_null", nullptr},
+          {"first", nullptr},
+          {"first_ignore_null", nullptr},
+          {"max_by", nullptr},
+          {"min_by", nullptr},
+          // If multiple values have the same greatest frequency, the return
+          // value is indeterminate.
+          {"mode", nullptr},
+          {"skewness", nullptr},
+          {"kurtosis", nullptr},
+          {"collect_list", makeArrayVerifier()},
+          {"collect_set", makeArrayVerifier()},
+          // Nested nulls are handled as values in Spark. But nested nulls
+          // comparison always generates null in DuckDB.
+          {"min", nullptr},
+          {"max", nullptr},
+      };
+
+  size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+  std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
+      facebook::velox::memory::memoryManager()->addRootPool()};
+  auto duckQueryRunner =
+      std::make_unique<facebook::velox::exec::test::DuckQueryRunner>(
+          rootPool.get());
+  duckQueryRunner->disableAggregateFunctions(
+      {// https://github.com/facebookincubator/velox/issues/7677
+       "max_by",
+       "min_by",
+       // The skewness functions of Velox and DuckDB use different
+       // algorithms.
+       // https://github.com/facebookincubator/velox/issues/4845
+       "skewness",
+       // Spark's kurtosis uses Pearson's formula for calculating the kurtosis
+       // coefficient. Meanwhile, DuckDB employs the sample kurtosis calculation
+       // formula. The results from the two methods are completely different.
+       "kurtosis"});
+
+  using Runner = facebook::velox::exec::test::AggregationFuzzerRunner;
+  using Options = facebook::velox::exec::test::AggregationFuzzerOptions;
+
+  Options options;
+  options.onlyFunctions = FLAGS_only;
+  options.skipFunctions = skipFunctions;
+  options.customVerificationFunctions = customVerificationFunctions;
+  options.orderableGroupKeys = true;
+  return Runner::run(initialSeed, std::move(duckQueryRunner), options);
+}
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp b/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp
new file mode 100644
index 0000000000000..89d05aeb604d7
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <memory>
+#include <string>
+
+#include "arrow/buffer.h"
+#include "arrow/c/bridge.h"
+#include "arrow/io/api.h"
+#include "arrow/ipc/api.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "grpc/grpc.h"
+#include "spark/connect/base.pb.h"
+#include "spark/connect/relations.pb.h"
+#include "velox/common/base/Fs.h"
+#include "velox/dwio/common/WriterFactory.h"
+#include "velox/dwio/parquet/writer/Writer.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/fuzzer/ToSQLUtil.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/functions/sparksql/fuzzer/SparkQueryRunner.h"
+#include "velox/vector/arrow/Bridge.h"
+
+using namespace spark::connect;
+
+namespace facebook::velox::functions::sparksql::fuzzer {
+namespace {
+
+void writeToFile(
+    const std::string& path,
+    const std::vector<RowVectorPtr>& data,
+    memory::MemoryPool* pool) {
+  VELOX_CHECK_GT(data.size(), 0);
+
+  auto options = std::make_shared<parquet::WriterOptions>();
+  options->schema = data[0]->type();
+  options->memoryPool = pool;
+  // Spark does not recognize int64-timestamp written as nano precision in
+  // Parquet.
+  options->parquetWriteTimestampUnit = TimestampUnit::kMicro;
+
+  auto writeFile = std::make_unique<LocalWriteFile>(path, true, false);
+  auto sink =
+      std::make_unique<dwio::common::WriteFileSink>(std::move(writeFile), path);
+  auto writer =
+      dwio::common::getWriterFactory(dwio::common::FileFormat::PARQUET)
+          ->createWriter(std::move(sink), options);
+
+  for (const auto& vector : data) {
+    // When vector is dictionary-encoded, complex types are not supported in
+    // exportFlattenedVector. Flatten the vector before writing to Parquet.
+    // https://github.com/facebookincubator/velox/issues/10397
+    VectorPtr flattened = vector;
+    BaseVector::flattenVector(flattened);
+    writer->write(flattened);
+  }
+  writer->close();
+}
+
+} // namespace
+
+const std::vector<TypePtr>& SparkQueryRunner::supportedScalarTypes() const {
+  static const std::vector<TypePtr> kScalarTypes{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      REAL(),
+      DOUBLE(),
+      VARCHAR(),
+      VARBINARY(),
+      TIMESTAMP(),
+      DATE(),
+  };
+  return kScalarTypes;
+}
+
+std::optional<std::string> SparkQueryRunner::toSql(
+    const velox::core::PlanNodePtr& plan) {
+  if (const auto aggregationNode =
+          std::dynamic_pointer_cast<const core::AggregationNode>(plan)) {
+    return toSql(aggregationNode);
+  }
+  if (const auto projectNode =
+          std::dynamic_pointer_cast<const core::ProjectNode>(plan)) {
+    return toSql(projectNode);
+  }
+  VELOX_NYI("Unsupported plan node: {}.", plan->toString());
+}
+
+std::multiset<std::vector<variant>> SparkQueryRunner::execute(
+    const std::string& sql,
+    const std::vector<RowVectorPtr>& input,
+    const RowTypePtr& resultType) {
+  return exec::test::materialize(executeVector(sql, input, resultType));
+}
+
+std::vector<RowVectorPtr> SparkQueryRunner::executeVector(
+    const std::string& sql,
+    const std::vector<RowVectorPtr>& input,
+    const RowTypePtr& resultType) {
+  auto inputType = asRowType(input[0]->type());
+  if (inputType->size() == 0) {
+    auto rowVector = exec::test::makeNullRows(input, "x", pool());
+    return executeVector(sql, {rowVector}, resultType);
+  }
+
+  // Write the input to a Parquet file.
+  auto tempFile = exec::test::TempFilePath::create();
+  const auto& filePath = tempFile->getPath();
+  auto writerPool = aggregatePool()->addAggregateChild("writer");
+  writeToFile(filePath, input, writerPool.get());
+
+  // Create temporary view 'tmp' in Spark by reading the generated Parquet file.
+  execute(fmt::format(
+      "CREATE OR REPLACE TEMPORARY VIEW tmp AS (SELECT * from parquet.`file://{}`);",
+      filePath));
+  return execute(sql);
+}
+
+std::vector<RowVectorPtr> SparkQueryRunner::execute(
+    const std::string& content) {
+  auto sql = google::protobuf::Arena::CreateMessage<SQL>(&arena_);
+  sql->set_query(content);
+
+  auto relation = google::protobuf::Arena::CreateMessage<Relation>(&arena_);
+  relation->set_allocated_sql(sql);
+
+  auto plan = google::protobuf::Arena::CreateMessage<Plan>(&arena_);
+  plan->set_allocated_root(relation);
+
+  auto context = google::protobuf::Arena::CreateMessage<UserContext>(&arena_);
+  context->set_user_id(userId_);
+  context->set_user_name(userName_);
+
+  auto request =
+      google::protobuf::Arena::CreateMessage<ExecutePlanRequest>(&arena_);
+  request->set_session_id(sessionId_);
+  request->set_allocated_user_context(context);
+  request->set_allocated_plan(plan);
+
+  grpc::ClientContext clientContext;
+  auto reader = stub_->ExecutePlan(&clientContext, *request);
+  ExecutePlanResponse response;
+  std::vector<RowVectorPtr> results;
+  while (reader->Read(&response)) {
+    VELOX_CHECK_EQ(
+        response.session_id(),
+        sessionId_,
+        "The session id of the response does not match that of the request.");
+    if (response.has_arrow_batch()) {
+      const std::string& data = response.arrow_batch().data();
+      const auto batchResults = readArrowData(data);
+      results.insert(results.end(), batchResults.begin(), batchResults.end());
+    }
+  }
+  return results;
+}
+
+std::string SparkQueryRunner::generateUUID() {
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<> dis(0, 15);
+  std::stringstream ss;
+  ss << std::hex;
+  for (int i = 0; i < 32; i++) {
+    ss << "0123456789abcdef"[dis(gen)];
+    if (i == 7 || i == 11 || i == 15 || i == 19)
+      ss << "-";
+  }
+  return ss.str();
+}
+
+std::vector<RowVectorPtr> SparkQueryRunner::readArrowData(
+    const std::string& data) {
+  auto buffer = std::make_shared<arrow::Buffer>(data);
+  auto bufferReader = std::make_shared<arrow::io::BufferReader>(buffer);
+  arrow::Result<std::shared_ptr<arrow::ipc::RecordBatchReader>> result =
+      arrow::ipc::RecordBatchStreamReader::Open(bufferReader);
+  VELOX_CHECK(
+      result.ok(),
+      "Failed to open RecordBatchReader: {}.",
+      result.status().ToString());
+
+  std::shared_ptr<arrow::ipc::RecordBatchReader> reader = result.ValueUnsafe();
+  std::shared_ptr<arrow::Schema> schema = reader->schema();
+
+  ArrowSchema arrowSchema;
+  auto status = arrow::ExportSchema(*schema, &arrowSchema);
+  VELOX_CHECK(status.ok(), "Failed to export schema: {}.", status.ToString());
+
+  arrow::Result<std::shared_ptr<arrow::RecordBatch>> batchResult;
+  std::vector<RowVectorPtr> results;
+  while ((batchResult = reader->Next()).ok() && batchResult.ValueUnsafe()) {
+    std::shared_ptr<arrow::RecordBatch> batch = batchResult.ValueUnsafe();
+    ArrowArray arrowArray;
+    status = ExportRecordBatch(*batch, &arrowArray);
+    VELOX_CHECK(status.ok(), "Failed to export array: {}.", status.ToString());
+    auto rv = std::dynamic_pointer_cast<RowVector>(
+        importFromArrowAsOwner(arrowSchema, arrowArray, pool()));
+    auto copy =
+        BaseVector::create<RowVector>(rv->type(), rv->size(), copyPool_.get());
+    copy->copy(rv.get(), 0, 0, rv->size());
+    results.push_back(copy);
+  }
+  VELOX_CHECK(
+      batchResult.ok(),
+      "Failed to read batch: {}.",
+      batchResult.status().ToString());
+  return results;
+}
+
+std::optional<std::string> SparkQueryRunner::toSql(
+    const std::shared_ptr<const core::AggregationNode>& aggregationNode) {
+  // Assume plan is Aggregation over Values.
+  VELOX_CHECK(aggregationNode->step() == core::AggregationNode::Step::kSingle);
+
+  std::vector<std::string> groupingKeys;
+  for (const auto& key : aggregationNode->groupingKeys()) {
+    groupingKeys.push_back(key->name());
+  }
+
+  std::stringstream sql;
+  sql << "SELECT " << folly::join(", ", groupingKeys);
+
+  const auto& aggregates = aggregationNode->aggregates();
+  if (!aggregates.empty()) {
+    if (!groupingKeys.empty()) {
+      sql << ", ";
+    }
+
+    for (auto i = 0; i < aggregates.size(); ++i) {
+      exec::test::appendComma(i, sql);
+      const auto& aggregate = aggregates[i];
+      VELOX_CHECK(
+          aggregate.sortingKeys.empty(),
+          "Sort key is not supported in Spark's aggregation. You may need to disable 'enable_sorted_aggregations' when running the fuzzer test.");
+      sql << exec::test::toAggregateCallSql(
+          aggregate.call, {}, {}, aggregate.distinct);
+
+      if (aggregate.mask != nullptr) {
+        sql << " filter (where " << aggregate.mask->name() << ")";
+      }
+      sql << " as " << aggregationNode->aggregateNames()[i];
+    }
+  }
+
+  sql << " FROM tmp";
+
+  if (!groupingKeys.empty()) {
+    sql << " GROUP BY " << folly::join(", ", groupingKeys);
+  }
+
+  return sql.str();
+}
+
+std::optional<std::string> SparkQueryRunner::toSql(
+    const std::shared_ptr<const core::ProjectNode>& projectNode) {
+  auto sourceSql = toSql(projectNode->sources()[0]);
+  if (!sourceSql.has_value()) {
+    return std::nullopt;
+  }
+
+  std::stringstream sql;
+  sql << "SELECT ";
+
+  for (auto i = 0; i < projectNode->names().size(); ++i) {
+    exec::test::appendComma(i, sql);
+    auto projection = projectNode->projections()[i];
+    if (auto field =
+            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+                projection)) {
+      sql << field->name();
+    } else if (
+        auto call =
+            std::dynamic_pointer_cast<const core::CallTypedExpr>(projection)) {
+      sql << exec::test::toCallSql(call);
+    } else {
+      VELOX_NYI(
+          "Unsupported projection {} in project node: {}.",
+          projection->toString(),
+          projectNode->toString());
+    }
+
+    sql << " as " << projectNode->names()[i];
+  }
+
+  sql << " FROM (" << sourceSql.value() << ")";
+  return sql.str();
+}
+} // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunner.h b/velox/functions/sparksql/fuzzer/SparkQueryRunner.h
new file mode 100644
index 0000000000000..038f3a82b04fc
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunner.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "grpc++/channel.h"
+#include "grpc++/client_context.h"
+#include "grpc++/create_channel.h"
+#include "grpc++/security/credentials.h"
+#include "spark/connect/base.grpc.pb.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::functions::sparksql::fuzzer {
+
+/// Query runner that uses Spark as a reference database. It converts Velox
+/// query plan to Spark SQL and executes it in Spark. The results are returned
+/// as Velox compatible format.
+class SparkQueryRunner : public velox::exec::test::ReferenceQueryRunner {
+ public:
+  /// @param coordinatorUri Spark connect server endpoint, e.g. localhost:15002.
+  SparkQueryRunner(
+      memory::MemoryPool* pool,
+      const std::string& coordinatorUri,
+      const std::string& userId,
+      const std::string& userName)
+      : ReferenceQueryRunner(pool),
+        userId_(userId),
+        userName_(userName),
+        sessionId_(generateUUID()),
+        stub_(spark::connect::SparkConnectService::NewStub(grpc::CreateChannel(
+            coordinatorUri,
+            grpc::InsecureChannelCredentials()))) {
+    pool_ = aggregatePool()->addLeafChild("leaf");
+    copyPool_ = aggregatePool()->addLeafChild("copy");
+  };
+
+  /// Converts Velox query plan to Spark SQL. Supports Values -> Aggregation.
+  /// Values node is converted into reading from 'tmp' table.
+  /// @return std::nullopt for unsupported cases.
+  std::optional<std::string> toSql(
+      const velox::core::PlanNodePtr& plan) override;
+
+  std::multiset<std::vector<velox::variant>> execute(
+      const std::string& sql,
+      const std::vector<velox::RowVectorPtr>& input,
+      const velox::RowTypePtr& resultType) override;
+
+  std::multiset<std::vector<velox::variant>> execute(
+      const std::string& sql,
+      const std::vector<RowVectorPtr>& probeInput,
+      const std::vector<RowVectorPtr>& buildInput,
+      const RowTypePtr& resultType) override {
+    VELOX_NYI("SparkQueryRunner does not support join node.");
+  }
+
+  RunnerType runnerType() const override {
+    return RunnerType::kSparkQueryRunner;
+  }
+
+  const std::vector<TypePtr>& supportedScalarTypes() const override;
+
+  bool supportsVeloxVectorResults() const override {
+    return true;
+  }
+
+  std::vector<velox::RowVectorPtr> executeVector(
+      const std::string& sql,
+      const std::vector<velox::RowVectorPtr>& input,
+      const velox::RowTypePtr& resultType) override;
+
+  std::vector<velox::RowVectorPtr> execute(const std::string& sql) override;
+
+ private:
+  // Generates a random UUID string for Spark. It must be of the format
+  // '00112233-4455-6677-8899-aabbccddeeff'.
+  std::string generateUUID();
+
+  velox::memory::MemoryPool* pool() {
+    return pool_.get();
+  }
+
+  // Reads the arrow IPC-format string data with arrow IPC reader and convert
+  // them into Velox RowVectors.
+  std::vector<velox::RowVectorPtr> readArrowData(const std::string& data);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const velox::core::AggregationNode>&
+          aggregationNode);
+
+  std::optional<std::string> toSql(
+      const std::shared_ptr<const core::ProjectNode>& projectNode);
+
+  google::protobuf::Arena arena_;
+  const std::string userId_;
+  const std::string userName_;
+  const std::string sessionId_;
+  // Used to make gRPC calls to the SparkConnectService.
+  std::unique_ptr<spark::connect::SparkConnectService::Stub> stub_;
+  std::shared_ptr<velox::memory::MemoryPool> pool_;
+  std::shared_ptr<velox::memory::MemoryPool> copyPool_;
+};
+} // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h b/velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h
new file mode 100644
index 0000000000000..e60b8fe985972
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <boost/random/uniform_int_distribution.hpp>
+#include "velox/expression/fuzzer/ArgGenerator.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::sparksql::fuzzer {
+
+class UnscaledValueArgGenerator : public velox::fuzzer::ArgGenerator {
+ public:
+  std::vector<TypePtr> generateArgs(
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      FuzzerGenerator& rng) override {
+    const auto p = rand32(
+        ShortDecimalType::kMinPrecision, ShortDecimalType::kMaxPrecision, rng);
+    const auto s = rand32(0, p, rng);
+
+    return {DECIMAL(p, s)};
+  }
+
+ private:
+  static uint32_t rand32(uint32_t min, uint32_t max, FuzzerGenerator& rng) {
+    return boost::random::uniform_int_distribution<uint32_t>(min, max)(rng);
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/fuzzer/tests/CMakeLists.txt b/velox/functions/sparksql/fuzzer/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..4f885f0230b78
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/tests/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_spark_query_runner_test SparkQueryRunnerTest.cpp)
+
+add_test(
+  NAME velox_spark_query_runner_test
+  COMMAND velox_spark_query_runner_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(
+  velox_spark_query_runner_test
+  PRIVATE
+    velox_functions_spark_aggregates
+    velox_spark_query_runner
+    velox_functions_spark
+    velox_exec_test_lib
+    velox_parse_utils
+    velox_vector_test_lib
+    GTest::gtest
+    GTest::gtest_main
+    Folly::folly)
diff --git a/velox/functions/sparksql/fuzzer/tests/SparkQueryRunnerTest.cpp b/velox/functions/sparksql/fuzzer/tests/SparkQueryRunnerTest.cpp
new file mode 100644
index 0000000000000..50a1ff60b370e
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/tests/SparkQueryRunnerTest.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/sparksql/Register.h"
+#include "velox/functions/sparksql/aggregates/Register.h"
+#include "velox/functions/sparksql/fuzzer/SparkQueryRunner.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class SparkQueryRunnerTest : public ::testing::Test,
+                             public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    velox::functions::sparksql::registerFunctions("");
+    velox::functions::aggregate::sparksql::registerAggregateFunctions("");
+    velox::parse::registerTypeResolver();
+  }
+};
+
+// This test requires a Spark coordinator running at localhost, so disable it
+// by default.
+TEST_F(SparkQueryRunnerTest, DISABLED_basic) {
+  auto aggregatePool = rootPool_->addAggregateChild("basic");
+  auto queryRunner = std::make_unique<fuzzer::SparkQueryRunner>(
+      aggregatePool.get(), "localhost:15002", "test", "basic");
+
+  auto input = makeRowVector({
+      makeConstant<int64_t>(1, 25),
+  });
+  auto outputType = ROW({"a"}, {BIGINT()});
+  auto sparkResults =
+      queryRunner->execute("SELECT count(*) FROM tmp", {input}, outputType);
+  auto expected = makeRowVector({
+      makeConstant<int64_t>(25, 1),
+  });
+  exec::test::assertEqualResults(sparkResults, outputType, {expected});
+
+  input = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2,
+                               3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4}),
+      makeFlatVector<int64_t>({1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                               1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}),
+  });
+  outputType = ROW({"a", "b"}, {BIGINT(), BIGINT()});
+  sparkResults = queryRunner->execute(
+      "SELECT c0, count(*) FROM tmp GROUP BY 1", {input}, outputType);
+  expected = makeRowVector({
+      makeFlatVector<int64_t>({0, 1, 2, 3, 4}),
+      makeFlatVector<int64_t>({5, 5, 5, 5, 5}),
+  });
+  exec::test::assertEqualResults(sparkResults, outputType, {expected});
+}
+
+// This test requires a Spark coordinator running at localhost, so disable it
+// by default.
+TEST_F(SparkQueryRunnerTest, DISABLED_fuzzer) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+      makeNullableFlatVector<int64_t>({std::nullopt, 1, 2, std::nullopt, 4, 5}),
+  });
+
+  auto plan = exec::test::PlanBuilder()
+                  .values({data})
+                  .singleAggregation({}, {"sum(c0)", "collect_list(c1)"})
+                  .project({"a0", "array_sort(a1)"})
+                  .planNode();
+
+  auto aggregatePool = rootPool_->addAggregateChild("fuzzer");
+  auto queryRunner = std::make_unique<fuzzer::SparkQueryRunner>(
+      aggregatePool.get(), "localhost:15002", "test", "fuzzer");
+  auto sql = queryRunner->toSql(plan);
+  ASSERT_TRUE(sql.has_value());
+
+  auto sparkResults = queryRunner->execute(
+      sql.value(), {data}, ROW({"a", "b"}, {BIGINT(), ARRAY(BIGINT())}));
+
+  auto veloxResults = exec::test::AssertQueryBuilder(plan).copyResults(pool());
+  exec::test::assertEqualResults(
+      sparkResults, plan->outputType(), {veloxResults});
+}
+
+TEST_F(SparkQueryRunnerTest, toSql) {
+  auto aggregatePool = rootPool_->addAggregateChild("toSql");
+  auto queryRunner = std::make_unique<fuzzer::SparkQueryRunner>(
+      aggregatePool.get(), "unused", "unused", "unused");
+
+  auto dataType = ROW({"c0", "c1", "c2"}, {DOUBLE(), DOUBLE(), BOOLEAN()});
+  auto plan = exec::test::PlanBuilder()
+                  .tableScan("tmp", dataType)
+                  .singleAggregation({"c1"}, {"avg(c0)"})
+                  .planNode();
+  EXPECT_EQ(
+      queryRunner->toSql(plan),
+      "SELECT c1, avg(c0) as a0 FROM tmp GROUP BY c1");
+
+  plan = exec::test::PlanBuilder()
+             .tableScan("tmp", dataType)
+             .singleAggregation({"c1"}, {"sum(c0)"})
+             .project({"a0 / c1"})
+             .planNode();
+  EXPECT_EQ(
+      queryRunner->toSql(plan),
+      "SELECT divide(a0, c1) as p0 FROM (SELECT c1, sum(c0) as a0 FROM tmp GROUP BY c1)");
+
+  plan = exec::test::PlanBuilder()
+             .tableScan("tmp", dataType)
+             .singleAggregation({}, {"avg(c0)", "avg(c1)"}, {"c2"})
+             .planNode();
+  EXPECT_EQ(
+      queryRunner->toSql(plan),
+      "SELECT avg(c0) filter (where c2) as a0, avg(c1) as a1 FROM tmp");
+
+  auto data =
+      makeRowVector({makeFlatVector<int64_t>({}), makeFlatVector<int64_t>({})});
+  plan = exec::test::PlanBuilder()
+             .values({data})
+             .singleAggregation({}, {"sum(distinct c0)"})
+             .planNode();
+  EXPECT_EQ(queryRunner->toSql(plan), "SELECT sum(distinct c0) as a0 FROM tmp");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::Init init{&argc, &argv, false};
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/functions/sparksql/specialforms/CMakeLists.txt b/velox/functions/sparksql/specialforms/CMakeLists.txt
new file mode 100644
index 0000000000000..e134309b7b5e7
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/CMakeLists.txt
@@ -0,0 +1,23 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+velox_add_library(
+  velox_functions_spark_specialforms
+  DecimalRound.cpp
+  MakeDecimal.cpp
+  SparkCastExpr.cpp
+  SparkCastHooks.cpp)
+
+velox_link_libraries(velox_functions_spark_specialforms fmt::fmt
+                     velox_expression)
diff --git a/velox/functions/sparksql/specialforms/DecimalRound.cpp b/velox/functions/sparksql/specialforms/DecimalRound.cpp
new file mode 100644
index 0000000000000..80ab19fea894e
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/DecimalRound.cpp
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/specialforms/DecimalRound.h"
+#include "velox/expression/ConstantExpr.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+template <typename TResult, typename TInput>
+class DecimalRoundFunction : public exec::VectorFunction {
+ public:
+  DecimalRoundFunction(
+      int32_t scale,
+      uint8_t inputPrecision,
+      uint8_t inputScale,
+      uint8_t resultPrecision,
+      uint8_t resultScale)
+      : scale_(
+            scale >= 0
+                ? std::min(scale, (int32_t)LongDecimalType::kMaxPrecision)
+                : std::max(scale, -(int32_t)LongDecimalType::kMaxPrecision)),
+        inputPrecision_(inputPrecision),
+        inputScale_(inputScale),
+        resultPrecision_(resultPrecision),
+        resultScale_(resultScale) {
+    const auto [p, s] = DecimalRoundCallToSpecialForm::getResultPrecisionScale(
+        inputPrecision, inputScale, scale);
+    VELOX_USER_CHECK_EQ(
+        p,
+        resultPrecision,
+        "The result precision of decimal_round is inconsistent with Spark expected.");
+    VELOX_USER_CHECK_EQ(
+        s,
+        resultScale,
+        "The result scale of decimal_round is inconsistent with Spark expected.");
+
+    // Decide the rescale factor of divide and multiply when rounding to a
+    // negative scale.
+    auto rescaleFactor = [&](int32_t rescale) {
+      VELOX_USER_CHECK_GT(
+          rescale, 0, "A non-negative rescale value is expected.");
+      return DecimalUtil::kPowersOfTen[std::min(
+          rescale, (int32_t)LongDecimalType::kMaxPrecision)];
+    };
+    if (scale_ < 0) {
+      divideFactor_ = rescaleFactor(inputScale_ - scale_);
+      multiplyFactor_ = rescaleFactor(-scale_);
+    }
+  }
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& resultType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VELOX_USER_CHECK(
+        args[0]->isConstantEncoding() || args[0]->isFlatEncoding(),
+        "Single-arg deterministic functions receive their only argument as flat or constant vector.");
+    context.ensureWritable(rows, resultType, result);
+    result->clearNulls(rows);
+    auto rawResults =
+        result->asUnchecked<FlatVector<TResult>>()->mutableRawValues();
+    if (args[0]->isConstantEncoding()) {
+      // Fast path for constant vector.
+      applyConstant(rows, args[0], rawResults);
+    } else {
+      // Fast path for flat vector.
+      applyFlat(rows, args[0], rawResults);
+    }
+  }
+
+  bool supportsFlatNoNullsFastPath() const override {
+    return true;
+  }
+
+ private:
+  inline TResult applyRound(const TInput& input) const {
+    if (scale_ >= 0) {
+      TResult rescaledValue;
+      const auto status = DecimalUtil::rescaleWithRoundUp<TInput, TResult>(
+          input,
+          inputPrecision_,
+          inputScale_,
+          resultPrecision_,
+          resultScale_,
+          rescaledValue);
+      VELOX_DCHECK(status.ok());
+      return rescaledValue;
+    } else {
+      TResult rescaledValue;
+      DecimalUtil::divideWithRoundUp<TResult, TInput, int128_t>(
+          rescaledValue, input, divideFactor_.value(), false, 0, 0);
+      rescaledValue *= multiplyFactor_.value();
+      return rescaledValue;
+    }
+  }
+
+  void applyConstant(
+      const SelectivityVector& rows,
+      const VectorPtr& arg,
+      TResult* rawResults) const {
+    const TResult rounded =
+        applyRound(arg->asUnchecked<ConstantVector<TInput>>()->valueAt(0));
+    rows.applyToSelected([&](auto row) { rawResults[row] = rounded; });
+  }
+
+  void applyFlat(
+      const SelectivityVector& rows,
+      const VectorPtr& arg,
+      TResult* rawResults) const {
+    auto rawValues = arg->asUnchecked<FlatVector<TInput>>()->mutableRawValues();
+    rows.applyToSelected(
+        [&](auto row) { rawResults[row] = applyRound(rawValues[row]); });
+  }
+
+  const int32_t scale_;
+  const uint8_t inputPrecision_;
+  const uint8_t inputScale_;
+  const uint8_t resultPrecision_;
+  const uint8_t resultScale_;
+  std::optional<int128_t> divideFactor_ = std::nullopt;
+  std::optional<int128_t> multiplyFactor_ = std::nullopt;
+};
+
+std::shared_ptr<exec::VectorFunction> createDecimalRound(
+    const TypePtr& inputType,
+    int32_t scale,
+    const TypePtr& resultType) {
+  const auto [inputPrecision, inputScale] =
+      getDecimalPrecisionScale(*inputType);
+  const auto [resultPrecision, resultScale] =
+      getDecimalPrecisionScale(*resultType);
+  if (inputType->isShortDecimal()) {
+    if (resultType->isShortDecimal()) {
+      return std::make_shared<DecimalRoundFunction<int64_t, int64_t>>(
+          scale, inputPrecision, inputScale, resultPrecision, resultScale);
+    } else {
+      return std::make_shared<DecimalRoundFunction<int128_t, int64_t>>(
+          scale, inputPrecision, inputScale, resultPrecision, resultScale);
+    }
+  } else {
+    if (resultType->isShortDecimal()) {
+      return std::make_shared<DecimalRoundFunction<int64_t, int128_t>>(
+          scale, inputPrecision, inputScale, resultPrecision, resultScale);
+    } else {
+      return std::make_shared<DecimalRoundFunction<int128_t, int128_t>>(
+          scale, inputPrecision, inputScale, resultPrecision, resultScale);
+    }
+  }
+}
+} // namespace
+
+std::pair<uint8_t, uint8_t>
+DecimalRoundCallToSpecialForm::getResultPrecisionScale(
+    uint8_t precision,
+    uint8_t scale,
+    int32_t roundScale) {
+  // After rounding we may need one more digit in the integral part,
+  // e.g. 'decimal_round(9.9, 0)' -> '10', 'decimal_round(99, -1)' -> '100'.
+  const int32_t integralLeastNumDigits = precision - scale + 1;
+  if (roundScale < 0) {
+    // Negative scale means we need to adjust `-scale` number of digits before
+    // the decimal point, which means we need at least `-scale + 1` digits after
+    // rounding, and the result scale is 0.
+    const auto newPrecision = std::max(
+        integralLeastNumDigits,
+        -std::max(roundScale, -(int32_t)LongDecimalType::kMaxPrecision) + 1);
+    // We have to accept the risk of overflow as we can't exceed the max
+    // precision.
+    return {std::min(newPrecision, (int32_t)LongDecimalType::kMaxPrecision), 0};
+  }
+  const uint8_t newScale = std::min((int32_t)scale, roundScale);
+  // We have to accept the risk of overflow as we cannot exceed the max
+  // precision.
+  return {
+      std::min(
+          integralLeastNumDigits + newScale,
+          (int32_t)LongDecimalType::kMaxPrecision),
+      newScale};
+}
+
+TypePtr DecimalRoundCallToSpecialForm::resolveType(
+    const std::vector<TypePtr>& /*argTypes*/) {
+  VELOX_FAIL("Decimal round function does not support type resolution.");
+}
+
+exec::ExprPtr DecimalRoundCallToSpecialForm::constructSpecialForm(
+    const TypePtr& type,
+    std::vector<exec::ExprPtr>&& args,
+    bool trackCpuUsage,
+    const core::QueryConfig& /*config*/) {
+  VELOX_USER_CHECK(
+      type->isDecimal(),
+      "The result type of decimal_round should be decimal type.");
+  VELOX_USER_CHECK_GE(
+      args.size(), 1, "Decimal_round expects one or two arguments.");
+  VELOX_USER_CHECK_LE(
+      args.size(), 2, "Decimal_round expects one or two arguments.");
+  VELOX_USER_CHECK(
+      args[0]->type()->isDecimal(),
+      "The first argument of decimal_round should be of decimal type.");
+
+  int32_t scale = 0;
+  if (args.size() > 1) {
+    VELOX_USER_CHECK_EQ(
+        args[1]->type()->kind(),
+        TypeKind::INTEGER,
+        "The second argument of decimal_round should be of integer type.");
+    auto constantExpr = std::dynamic_pointer_cast<exec::ConstantExpr>(args[1]);
+    VELOX_USER_CHECK_NOT_NULL(
+        constantExpr,
+        "The second argument of decimal_round should be constant expression.");
+    VELOX_USER_CHECK(
+        constantExpr->value()->isConstantEncoding(),
+        "The second argument of decimal_round should be wrapped in constant vector.");
+    auto constantVector =
+        constantExpr->value()->asUnchecked<ConstantVector<int32_t>>();
+    VELOX_USER_CHECK(
+        !constantVector->isNullAt(0),
+        "The second argument of decimal_round is non-nullable.");
+    scale = constantVector->valueAt(0);
+  }
+
+  auto decimalRound = createDecimalRound(args[0]->type(), scale, type);
+
+  return std::make_shared<exec::Expr>(
+      type,
+      std::move(args),
+      std::move(decimalRound),
+      exec::VectorFunctionMetadata{},
+      kRoundDecimal,
+      trackCpuUsage);
+}
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/DecimalRound.h b/velox/functions/sparksql/specialforms/DecimalRound.h
new file mode 100644
index 0000000000000..9955c52247a2a
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/DecimalRound.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/FunctionCallToSpecialForm.h"
+
+namespace facebook::velox::functions::sparksql {
+
+class DecimalRoundCallToSpecialForm : public exec::FunctionCallToSpecialForm {
+ public:
+  // Throws not supported exception.
+  TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
+
+  /// @brief Returns an expression for decimal_round special form. The
+  /// expression is a regular expression based on a custom VectorFunction
+  /// implementation.
+  /// @param type Result type. Must be short or long decimal.
+  /// @param args One or two inputs. First input must be decimal. Second
+  /// optional input is the new scale to be rounded to, and must be constant
+  /// INTEGER.
+  exec::ExprPtr constructSpecialForm(
+      const TypePtr& type,
+      std::vector<exec::ExprPtr>&& args,
+      bool trackCpuUsage,
+      const core::QueryConfig& config) override;
+
+  /// Returns the result precision and scale after rounding from the input
+  /// precision and scale to a new scale. The calculation logic is consistent
+  /// with Spark version after 3.3.
+  static std::pair<uint8_t, uint8_t>
+  getResultPrecisionScale(uint8_t precision, uint8_t scale, int32_t roundScale);
+
+  static constexpr const char* kRoundDecimal = "decimal_round";
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/MakeDecimal.cpp b/velox/functions/sparksql/specialforms/MakeDecimal.cpp
new file mode 100644
index 0000000000000..0d0958ab4837b
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/MakeDecimal.cpp
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/specialforms/MakeDecimal.h"
+#include "velox/expression/ConstantExpr.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+template <typename T>
+class MakeDecimalFunction final : public exec::VectorFunction {
+ public:
+  MakeDecimalFunction(uint8_t resultPrecision, bool nullOnOverflow)
+      : resultPrecision_(resultPrecision), nullOnOverflow_(nullOnOverflow) {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const final {
+    VELOX_USER_CHECK_GE(
+        args.size(), 1, "Make_decimal expects at least one argument.");
+    VELOX_USER_CHECK(
+        args[0]->isConstantEncoding() || args[0]->isFlatEncoding(),
+        "Single-arg deterministic functions receive their only argument as flat or constant vector.");
+    context.ensureWritable(rows, outputType, result);
+    result->clearNulls(rows);
+    auto rawResults = result->asUnchecked<FlatVector<T>>()->mutableRawValues();
+    const int128_t bound = DecimalUtil::kPowersOfTen[resultPrecision_];
+    if (args[0]->isConstantEncoding()) {
+      // Fast path for constant vectors.
+      applyConstant(rows, args[0], bound, context, result, rawResults);
+    } else {
+      // Fast path for flat vectors.
+      applyFlat(rows, args[0], bound, context, result, rawResults);
+    }
+  }
+
+ private:
+  void applyConstant(
+      const SelectivityVector& rows,
+      VectorPtr& arg,
+      int128_t bound,
+      exec::EvalCtx& context,
+      VectorPtr& result,
+      T* rawResults) const {
+    const auto constant =
+        arg->asUnchecked<ConstantVector<int64_t>>()->valueAt(0);
+    if constexpr (std::is_same_v<T, int64_t>) {
+      const bool overflow = constant <= -bound || constant >= bound;
+      if (overflow) {
+        // The unscaled value cannot fit in the requested precision.
+        if (nullOnOverflow_) {
+          result->addNulls(rows);
+        } else {
+          context.setErrors(
+              rows, overflowException(constant, resultPrecision_));
+        }
+      } else {
+        rows.applyToSelected(
+            [&](vector_size_t row) { rawResults[row] = constant; });
+      }
+    } else {
+      rows.applyToSelected(
+          [&](vector_size_t row) { rawResults[row] = (int128_t)constant; });
+    }
+  }
+
+  void applyFlat(
+      const SelectivityVector& rows,
+      VectorPtr& arg,
+      int128_t bound,
+      exec::EvalCtx& context,
+      VectorPtr& result,
+      T* rawResults) const {
+    auto rawValues =
+        arg->asUnchecked<FlatVector<int64_t>>()->mutableRawValues();
+    if constexpr (std::is_same_v<T, int64_t>) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
+        const auto unscaled = rawValues[row];
+        if (unscaled <= -bound || unscaled >= bound) {
+          // The unscaled value cannot fit in the requested precision.
+          if (nullOnOverflow_) {
+            result->setNull(row, true);
+          } else {
+            context.setError(
+                row, overflowException(unscaled, resultPrecision_));
+          }
+        } else {
+          rawResults[row] = unscaled;
+        }
+      });
+    } else {
+      rows.applyToSelected([&](vector_size_t row) {
+        rawResults[row] = (int128_t)rawValues[row];
+      });
+    }
+  }
+
+  std::exception_ptr overflowException(
+      int64_t unscaled,
+      uint8_t resultPrecision) const {
+    return std::make_exception_ptr(std::overflow_error(fmt::format(
+        "Unscaled value {} too large for precision {}.",
+        unscaled,
+        resultPrecision)));
+  }
+
+  const uint8_t resultPrecision_;
+  const bool nullOnOverflow_;
+};
+
+std::shared_ptr<exec::VectorFunction> createMakeDecimal(
+    const TypePtr& type,
+    bool nullOnOverflow) {
+  const uint8_t precision = getDecimalPrecisionScale(*type).first;
+  if (type->isShortDecimal()) {
+    return std::make_shared<MakeDecimalFunction<int64_t>>(
+        precision, nullOnOverflow);
+  }
+  return std::make_shared<MakeDecimalFunction<int128_t>>(
+      precision, nullOnOverflow);
+}
+} // namespace
+
+TypePtr MakeDecimalCallToSpecialForm::resolveType(
+    const std::vector<TypePtr>& /*argTypes*/) {
+  VELOX_FAIL("Make decimal function does not support type resolution.");
+}
+
+exec::ExprPtr MakeDecimalCallToSpecialForm::constructSpecialForm(
+    const TypePtr& type,
+    std::vector<exec::ExprPtr>&& args,
+    bool trackCpuUsage,
+    const core::QueryConfig& /*config*/) {
+  VELOX_USER_CHECK(
+      type->isDecimal(),
+      "The result type of make_decimal should be decimal type.");
+  VELOX_USER_CHECK_GE(
+      args.size(), 1, "Make_decimal expects one or two arguments.");
+  VELOX_USER_CHECK_LE(
+      args.size(), 2, "Make_decimal expects one or two arguments.");
+  VELOX_USER_CHECK_EQ(
+      args[0]->type()->kind(),
+      TypeKind::BIGINT,
+      "The first argument of make_decimal should be of bigint type.");
+  bool nullOnOverflow = true;
+  if (args.size() > 1) {
+    VELOX_USER_CHECK_EQ(
+        args[1]->type()->kind(),
+        TypeKind::BOOLEAN,
+        "The second argument of make_decimal should be of boolean type.");
+    auto constantExpr = std::dynamic_pointer_cast<exec::ConstantExpr>(args[1]);
+    VELOX_USER_CHECK_NOT_NULL(
+        constantExpr,
+        "The second argument of make_decimal should be constant expression.");
+    VELOX_USER_CHECK(
+        constantExpr->value()->isConstantEncoding(),
+        "The second argument of make_decimal should be wrapped in constant vector.");
+    auto constantVector =
+        constantExpr->value()->asUnchecked<ConstantVector<bool>>();
+    VELOX_USER_CHECK(
+        !constantVector->isNullAt(0),
+        "The second argument of make_decimal is non-nullable.");
+    nullOnOverflow = constantVector->valueAt(0);
+  }
+  return std::make_shared<exec::Expr>(
+      type,
+      std::move(args),
+      createMakeDecimal(type, nullOnOverflow),
+      exec::VectorFunctionMetadata{},
+      kMakeDecimal,
+      trackCpuUsage);
+}
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/MakeDecimal.h b/velox/functions/sparksql/specialforms/MakeDecimal.h
new file mode 100644
index 0000000000000..1f1224f465915
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/MakeDecimal.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/expression/FunctionCallToSpecialForm.h"
+
+namespace facebook::velox::functions::sparksql {
+class MakeDecimalCallToSpecialForm : public exec::FunctionCallToSpecialForm {
+ public:
+  // Throws not supported exception.
+  TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
+
+  /// @brief Returns an expression for make_decimal special form. The expression
+  /// is a regular expression based on a custom VectorFunction implementation.
+  /// @param type Result type. Must be short or long decimal.
+  /// @param args One or two inputs. First input must be BIGINT (unscaled
+  /// value). Second optional input must be constant BOOLEAN (indicates whether
+  /// to return null or throw if unscaled value is too large for the result
+  /// precision).
+  exec::ExprPtr constructSpecialForm(
+      const TypePtr& type,
+      std::vector<exec::ExprPtr>&& args,
+      bool trackCpuUsage,
+      const core::QueryConfig& config) override;
+
+  static constexpr const char* kMakeDecimal = "make_decimal";
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/SparkCastExpr.cpp b/velox/functions/sparksql/specialforms/SparkCastExpr.cpp
new file mode 100644
index 0000000000000..2fbff4a669bf9
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/SparkCastExpr.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/specialforms/SparkCastExpr.h"
+
+namespace facebook::velox::functions::sparksql {
+
+exec::ExprPtr SparkCastCallToSpecialForm::constructSpecialForm(
+    const TypePtr& type,
+    std::vector<exec::ExprPtr>&& compiledChildren,
+    bool trackCpuUsage,
+    const core::QueryConfig& /*config*/) {
+  VELOX_CHECK_EQ(
+      compiledChildren.size(),
+      1,
+      "CAST statements expect exactly 1 argument, received {}.",
+      compiledChildren.size());
+  return std::make_shared<SparkCastExpr>(
+      type,
+      std::move(compiledChildren[0]),
+      trackCpuUsage,
+      false,
+      std::make_shared<SparkCastHooks>());
+}
+
+exec::ExprPtr SparkTryCastCallToSpecialForm::constructSpecialForm(
+    const TypePtr& type,
+    std::vector<exec::ExprPtr>&& compiledChildren,
+    bool trackCpuUsage,
+    const core::QueryConfig& /*config*/) {
+  VELOX_CHECK_EQ(
+      compiledChildren.size(),
+      1,
+      "TRY CAST statements expect exactly 1 argument, received {}.",
+      compiledChildren.size());
+  return std::make_shared<SparkCastExpr>(
+      type,
+      std::move(compiledChildren[0]),
+      trackCpuUsage,
+      true,
+      std::make_shared<SparkCastHooks>());
+}
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/SparkCastExpr.h b/velox/functions/sparksql/specialforms/SparkCastExpr.h
new file mode 100644
index 0000000000000..9349876ba707d
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/SparkCastExpr.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/CastExpr.h"
+#include "velox/functions/sparksql/specialforms/SparkCastHooks.h"
+
+namespace facebook::velox::functions::sparksql {
+
+class SparkCastExpr : public exec::CastExpr {
+ public:
+  /// @param type The target type of the cast expression
+  /// @param expr The expression to cast
+  /// @param trackCpuUsage Whether to track CPU usage
+  SparkCastExpr(
+      TypePtr type,
+      exec::ExprPtr&& expr,
+      bool trackCpuUsage,
+      bool nullOnFailure,
+      std::shared_ptr<SparkCastHooks> hooks)
+      : exec::CastExpr(
+            type,
+            std::move(expr),
+            trackCpuUsage,
+            nullOnFailure,
+            hooks) {}
+};
+
+class SparkCastCallToSpecialForm : public exec::CastCallToSpecialForm {
+ public:
+  exec::ExprPtr constructSpecialForm(
+      const TypePtr& type,
+      std::vector<exec::ExprPtr>&& compiledChildren,
+      bool trackCpuUsage,
+      const core::QueryConfig& config) override;
+};
+
+class SparkTryCastCallToSpecialForm : public exec::TryCastCallToSpecialForm {
+ public:
+  exec::ExprPtr constructSpecialForm(
+      const TypePtr& type,
+      std::vector<exec::ExprPtr>&& compiledChildren,
+      bool trackCpuUsage,
+      const core::QueryConfig& config) override;
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/SparkCastHooks.cpp b/velox/functions/sparksql/specialforms/SparkCastHooks.cpp
new file mode 100644
index 0000000000000..061ccc46198df
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/SparkCastHooks.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/specialforms/SparkCastHooks.h"
+#include "velox/functions/lib/string/StringImpl.h"
+#include "velox/type/TimestampConversion.h"
+
+namespace facebook::velox::functions::sparksql {
+
+Expected<Timestamp> SparkCastHooks::castStringToTimestamp(
+    const StringView& view) const {
+  return util::fromTimestampString(
+      view.data(), view.size(), util::TimestampParseMode::kSparkCast);
+}
+
+Expected<int32_t> SparkCastHooks::castStringToDate(
+    const StringView& dateString) const {
+  // Allows all patterns supported by Spark:
+  // `[+-]yyyy*`
+  // `[+-]yyyy*-[m]m`
+  // `[+-]yyyy*-[m]m-[d]d`
+  // `[+-]yyyy*-[m]m-[d]d *`
+  // `[+-]yyyy*-[m]m-[d]dT*`
+  // The asterisk `*` in `yyyy*` stands for any numbers.
+  // For the last two patterns, the trailing `*` can represent none or any
+  // sequence of characters, e.g:
+  //   "1970-01-01 123"
+  //   "1970-01-01 (BC)"
+  return util::fromDateString(
+      removeWhiteSpaces(dateString), util::ParseMode::kSparkCast);
+}
+
+Expected<float> SparkCastHooks::castStringToReal(const StringView& data) const {
+  return util::Converter<TypeKind::REAL>::tryCast(data);
+}
+
+Expected<double> SparkCastHooks::castStringToDouble(
+    const StringView& data) const {
+  return util::Converter<TypeKind::DOUBLE>::tryCast(data);
+}
+
+StringView SparkCastHooks::removeWhiteSpaces(const StringView& view) const {
+  StringView output;
+  stringImpl::trimUnicodeWhiteSpace<true, true, StringView, StringView>(
+      output, view);
+  return output;
+}
+
+const TimestampToStringOptions& SparkCastHooks::timestampToStringOptions()
+    const {
+  static constexpr TimestampToStringOptions options = {
+      .precision = TimestampToStringOptions::Precision::kMicroseconds,
+      .leadingPositiveSign = true,
+      .skipTrailingZeros = true,
+      .zeroPaddingYear = true,
+      .dateTimeSeparator = ' ',
+  };
+  return options;
+}
+
+exec::PolicyType SparkCastHooks::getPolicy() const {
+  return exec::PolicyType::SparkCastPolicy;
+}
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/SparkCastHooks.h b/velox/functions/sparksql/specialforms/SparkCastHooks.h
new file mode 100644
index 0000000000000..61e52916e5f08
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/SparkCastHooks.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/expression/CastHooks.h"
+
+namespace facebook::velox::functions::sparksql {
+
+// This class provides cast hooks following Spark semantics.
+class SparkCastHooks : public exec::CastHooks {
+ public:
+  // TODO: Spark hook allows more string patterns than Presto.
+  Expected<Timestamp> castStringToTimestamp(
+      const StringView& view) const override;
+
+  /// 1) Removes all leading and trailing UTF8 white-spaces before cast. 2) Uses
+  /// non-standard cast mode to cast from string to date.
+  Expected<int32_t> castStringToDate(
+      const StringView& dateString) const override;
+
+  // Allows casting 'NaN', 'Infinity', '-Infinity', 'Inf', '-Inf', and these
+  // strings with different letter cases to real.
+  Expected<float> castStringToReal(const StringView& data) const override;
+
+  // Allows casting 'NaN', 'Infinity', '-Infinity', 'Inf', '-Inf', and these
+  // strings with different letter cases to double.
+  Expected<double> castStringToDouble(const StringView& data) const override;
+
+  /// When casting from string to integral, floating-point, decimal, date, and
+  /// timestamp types, Spark hook trims all leading and trailing UTF8
+  /// whitespaces before cast.
+  StringView removeWhiteSpaces(const StringView& view) const override;
+
+  /// 1) Does not follow 'isLegacyCast' and session timezone. 2) The conversion
+  /// precision is microsecond. 3) Does not append trailing zeros. 4) Adds a
+  /// positive sign at first if the year exceeds 9999.
+  const TimestampToStringOptions& timestampToStringOptions() const override;
+
+  bool truncate() const override {
+    return true;
+  }
+
+  exec::PolicyType getPolicy() const override;
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/tests/ArgGeneratorTest.cpp b/velox/functions/sparksql/tests/ArgGeneratorTest.cpp
new file mode 100644
index 0000000000000..46a6f42e18f03
--- /dev/null
+++ b/velox/functions/sparksql/tests/ArgGeneratorTest.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/expression/fuzzer/tests/ArgGeneratorTestUtils.h"
+#include "velox/functions/FunctionRegistry.h"
+#include "velox/functions/sparksql/fuzzer/AddSubtractArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/DivideArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/MakeTimestampArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/MultiplyArgGenerator.h"
+#include "velox/functions/sparksql/fuzzer/UnscaledValueArgGenerator.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox::fuzzer::test;
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class ArgGeneratorTest : public SparkFunctionBaseTest {
+ protected:
+  // Assert that the generated argument types meet user-specified check.
+  void assertArgumentTypes(
+      std::shared_ptr<velox::fuzzer::ArgGenerator> generator,
+      const exec::FunctionSignature& signature,
+      const TypePtr& returnType,
+      std::function<void(const std::vector<TypePtr>&)> check) {
+    std::mt19937 seed{0};
+    const auto argTypes = generator->generateArgs(signature, returnType, seed);
+    check(argTypes);
+  }
+
+  // Returns the only signature with specified return type for a given function
+  // name.
+  // @param returnType The name of expected return type defined in function
+  // signature. Default is 'decimal'.
+  const exec::FunctionSignature& getOnlySignature(
+      const std::string& functionName,
+      const std::string& returnType = "decimal") {
+    const auto signatures = getSignatures(functionName, returnType);
+    VELOX_CHECK_EQ(signatures.size(), 1);
+    return *signatures[0];
+  }
+};
+
+TEST_F(ArgGeneratorTest, add) {
+  const auto& signature = getOnlySignature("add");
+  const auto generator = std::make_shared<fuzzer::AddSubtractArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 2));
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, signature, DECIMAL(18, 18));
+  assertEmptyArgs(generator, signature, DECIMAL(38, 38));
+}
+
+TEST_F(ArgGeneratorTest, subtract) {
+  const auto& signature = getOnlySignature("subtract");
+  const auto generator = std::make_shared<fuzzer::AddSubtractArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 2));
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, signature, DECIMAL(18, 18));
+  assertEmptyArgs(generator, signature, DECIMAL(38, 38));
+}
+
+TEST_F(ArgGeneratorTest, multiply) {
+  const auto& signature = getOnlySignature("multiply");
+  const auto generator = std::make_shared<fuzzer::MultiplyArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(10, 2));
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, signature, DECIMAL(18, 18));
+  assertEmptyArgs(generator, signature, DECIMAL(38, 38));
+}
+
+TEST_F(ArgGeneratorTest, divide) {
+  const auto& signature = getOnlySignature("divide");
+  const auto generator = std::make_shared<fuzzer::DivideArgGenerator>();
+
+  assertReturnType(generator, signature, DECIMAL(32, 6));
+  assertReturnType(generator, signature, DECIMAL(38, 20));
+  assertReturnType(generator, signature, DECIMAL(18, 18));
+  assertReturnType(generator, signature, DECIMAL(38, 38));
+  assertEmptyArgs(generator, signature, DECIMAL(38, 0));
+  assertEmptyArgs(generator, signature, DECIMAL(10, 2));
+}
+
+TEST_F(ArgGeneratorTest, makeTimestamp) {
+  const auto signatures = getSignatures("make_timestamp", "timestamp");
+  VELOX_CHECK_EQ(signatures.size(), 2);
+  bool isSixArgs = signatures[0]->argumentTypes().size() == 6;
+  const auto generator = std::make_shared<fuzzer::MakeTimestampArgGenerator>();
+
+  std::function<void(const TypePtr&)> assertDecimalType =
+      [](const TypePtr& type) {
+        ASSERT_TRUE(type->isShortDecimal());
+        auto [precision, scale] = getDecimalPrecisionScale(*type);
+        ASSERT_EQ(scale, 6);
+      };
+
+  const auto& sixArgsSignature = isSixArgs ? *signatures[0] : *signatures[1];
+  assertReturnType(generator, sixArgsSignature, TIMESTAMP());
+  assertArgumentTypes(
+      generator,
+      sixArgsSignature,
+      TIMESTAMP(),
+      [&](const std::vector<TypePtr>& argumentTypes) {
+        EXPECT_EQ(argumentTypes.size(), 6);
+        assertDecimalType(argumentTypes[5]);
+      });
+
+  const auto& sevenArgsSignature = isSixArgs ? *signatures[1] : *signatures[0];
+  assertReturnType(generator, sevenArgsSignature, TIMESTAMP());
+  assertArgumentTypes(
+      generator,
+      sevenArgsSignature,
+      TIMESTAMP(),
+      [&](const std::vector<TypePtr>& argumentTypes) {
+        EXPECT_EQ(argumentTypes.size(), 7);
+        assertDecimalType(argumentTypes[5]);
+      });
+}
+
+TEST_F(ArgGeneratorTest, unscaledValue) {
+  const auto& signature = getOnlySignature("unscaled_value", "bigint");
+  const auto generator = std::make_shared<fuzzer::UnscaledValueArgGenerator>();
+
+  assertReturnType(generator, signature, BIGINT());
+  assertArgumentTypes(
+      generator,
+      signature,
+      BIGINT(),
+      [](const std::vector<TypePtr>& argumentTypes) {
+        EXPECT_EQ(argumentTypes.size(), 1);
+        ASSERT_TRUE(argumentTypes[0]->isShortDecimal());
+      });
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArithmeticTest.cpp b/velox/functions/sparksql/tests/ArithmeticTest.cpp
index af43bc329999f..72ac45caf0d0b 100644
--- a/velox/functions/sparksql/tests/ArithmeticTest.cpp
+++ b/velox/functions/sparksql/tests/ArithmeticTest.cpp
@@ -91,6 +91,11 @@ class RemainderTest : public SparkFunctionBaseTest {
   std::optional<T> remainder(std::optional<T> a, std::optional<T> n) {
     return evaluateOnce<T>("remainder(c0, c1)", a, n);
   };
+
+  template <typename T>
+  T remainderValue(std::optional<T> a, std::optional<T> n) {
+    return remainder<T>(a, n).value();
+  }
 };
 
 TEST_F(RemainderTest, int8) {
@@ -133,6 +138,44 @@ TEST_F(RemainderTest, int64) {
   EXPECT_EQ(-1, remainder<int64_t>(INT64_MIN, INT64_MAX));
 }
 
+TEST_F(RemainderTest, double) {
+  constexpr double kInf = std::numeric_limits<double>::infinity();
+  constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
+
+  EXPECT_DOUBLE_EQ(0.0, remainderValue<double>(2.0, 1.0));
+  EXPECT_DOUBLE_EQ(1.0, remainderValue<double>(5.0, 2.0));
+  EXPECT_DOUBLE_EQ(-1.0, remainderValue<double>(-5.0, 2.0));
+  EXPECT_DOUBLE_EQ(0.5, remainderValue<double>(1.5, 1.0));
+  EXPECT_DOUBLE_EQ(0.0, remainderValue<double>(0.0, 1.0));
+  EXPECT_DOUBLE_EQ(2.0, remainderValue<double>(2.0, kInf));
+
+  EXPECT_EQ(std::nullopt, remainder<double>(2.0, 0.0));
+  EXPECT_TRUE(std::isnan(remainderValue<double>(kNan, 1.0)));
+  EXPECT_TRUE(std::isnan(remainderValue<double>(1.0, kNan)));
+  EXPECT_TRUE(std::isnan(remainderValue<double>(kInf, 1.0)));
+  EXPECT_TRUE(std::isnan(remainderValue<double>(-kInf, 1.0)));
+  EXPECT_TRUE(std::isnan(remainderValue<double>(kInf, kInf)));
+}
+
+TEST_F(RemainderTest, float) {
+  constexpr float kInf = std::numeric_limits<float>::infinity();
+  constexpr float kNan = std::numeric_limits<float>::quiet_NaN();
+
+  EXPECT_FLOAT_EQ(0.0f, remainderValue<float>(2.0f, 1.0f));
+  EXPECT_FLOAT_EQ(1.0f, remainderValue<float>(5.0f, 2.0f));
+  EXPECT_FLOAT_EQ(-1.0f, remainderValue<float>(-5.0f, 2.0f));
+  EXPECT_FLOAT_EQ(0.5f, remainderValue<float>(1.5f, 1.0f));
+  EXPECT_FLOAT_EQ(0.0f, remainderValue<float>(0.0f, 1.0f));
+  EXPECT_FLOAT_EQ(2.0f, remainderValue<float>(2.0f, kInf));
+
+  EXPECT_EQ(std::nullopt, remainder<float>(2.0f, 0.0f));
+  EXPECT_TRUE(std::isnan(remainderValue<float>(kNan, 1.0f)));
+  EXPECT_TRUE(std::isnan(remainderValue<float>(1.0f, kNan)));
+  EXPECT_TRUE(std::isnan(remainderValue<float>(kInf, 1.0f)));
+  EXPECT_TRUE(std::isnan(remainderValue<float>(-kInf, 1.0f)));
+  EXPECT_TRUE(std::isnan(remainderValue<float>(kInf, kInf)));
+}
+
 class ArithmeticTest : public SparkFunctionBaseTest {
  protected:
   template <typename T>
@@ -146,8 +189,87 @@ class ArithmeticTest : public SparkFunctionBaseTest {
     return evaluateOnce<double>("divide(c0, c1)", numerator, denominator);
   }
 
+  template <typename T>
+  std::optional<T> checkedAdd(
+      const std::optional<T> a,
+      const std::optional<T> b) {
+    return evaluateOnce<T>("checked_add(c0, c1)", a, b);
+  }
+
+  template <typename T>
+  std::optional<T> checkedDivide(
+      const std::optional<T> a,
+      const std::optional<T> b) {
+    return evaluateOnce<T>("checked_divide(c0, c1)", a, b);
+  }
+
+  template <typename T>
+  std::optional<T> checkedMultiply(
+      const std::optional<T> a,
+      const std::optional<T> b) {
+    return evaluateOnce<T>("checked_multiply(c0, c1)", a, b);
+  }
+
+  template <typename T>
+  std::optional<T> checkedSubtract(
+      const std::optional<T> a,
+      const std::optional<T> b) {
+    return evaluateOnce<T>("checked_subtract(c0, c1)", a, b);
+  }
+
+  template <typename T>
+  void assertErrorForCheckedArithmetic(
+      const std::string& func,
+      const std::optional<T> a,
+      const std::optional<T> b,
+      const std::string& errorMessage) {
+    auto res = evaluateOnce<T>(fmt::format("try({}(c0, c1))", func), a, b);
+    ASSERT_TRUE(!res.has_value());
+    try {
+      evaluateOnce<T>(fmt::format("{}(c0, c1)", func), a, b);
+      FAIL() << "Expected an error";
+    } catch (const std::exception& e) {
+      ASSERT_TRUE(
+          std::string(e.what()).find(errorMessage) != std::string::npos);
+    }
+  }
+
+  template <typename T>
+  void assertErrorForCheckedAdd(
+      const std::optional<T> a,
+      const std::optional<T> b,
+      const std::string& errorMessage) {
+    assertErrorForCheckedArithmetic("checked_add", a, b, errorMessage);
+  }
+
+  template <typename T>
+  void assertErrorForCheckedDivide(
+      const std::optional<T> a,
+      const std::optional<T> b,
+      const std::string& errorMessage) {
+    assertErrorForCheckedArithmetic("checked_divide", a, b, errorMessage);
+  }
+
+  template <typename T>
+  void assertErrorForCheckedMultiply(
+      const std::optional<T> a,
+      const std::optional<T> b,
+      const std::string& errorMessage) {
+    assertErrorForCheckedArithmetic("checked_multiply", a, b, errorMessage);
+  }
+
+  template <typename T>
+  void assertErrorForcheckedSubtract(
+      const std::optional<T> a,
+      const std::optional<T> b,
+      const std::string& errorMessage) {
+    assertErrorForCheckedArithmetic("checked_subtract", a, b, errorMessage);
+  }
+
   static constexpr float kNan = std::numeric_limits<float>::quiet_NaN();
+  static constexpr double kNanDouble = std::numeric_limits<double>::quiet_NaN();
   static constexpr float kInf = std::numeric_limits<float>::infinity();
+  static constexpr double kInfDouble = std::numeric_limits<double>::infinity();
 };
 
 TEST_F(ArithmeticTest, UnaryMinus) {
@@ -267,15 +389,57 @@ TEST_F(ArithmeticTest, cosh) {
   EXPECT_TRUE(std::isnan(cosh(kNan).value_or(0)));
 }
 
+TEST_F(ArithmeticTest, rint) {
+  const auto rint = [&](double a) {
+    return evaluateOnce<double>("rint(c0)", std::optional(a)).value();
+  };
+
+  EXPECT_EQ(rint(2.3), 2.0);
+  EXPECT_EQ(rint(3.8), 4.0);
+  EXPECT_EQ(rint(-2.3), -2.0);
+  EXPECT_EQ(rint(-3.8), -4.0);
+
+  EXPECT_EQ(rint(2.5), 2.0);
+
+  EXPECT_TRUE(std::isnan(rint(kNanDouble)));
+  EXPECT_EQ(rint(kInfDouble), kInfDouble);
+  EXPECT_EQ(rint(-kInfDouble), -kInfDouble);
+  EXPECT_EQ(rint(0.0), 0.0);
+  EXPECT_EQ(rint(-0.0), -0.0);
+
+  EXPECT_EQ(rint(std::nextafter(1.0, 0.0)), 1.0);
+  EXPECT_EQ(rint(std::nextafter(1.0, 2.0)), 1.0);
+  EXPECT_EQ(rint(std::nextafter(1e+16, kInfDouble)), 1e+16 + 2);
+}
+
+TEST_F(ArithmeticTest, unhex) {
+  const auto unhex = [&](std::optional<std::string> a) {
+    return evaluateOnce<std::string>("unhex(c0)", a);
+  };
+
+  EXPECT_EQ(unhex("737472696E67"), "string");
+  EXPECT_EQ(unhex(""), "");
+  EXPECT_EQ(unhex("23"), "#");
+  EXPECT_EQ(unhex("123"), "\x01#");
+  EXPECT_EQ(unhex("b23"), "\x0B#");
+  EXPECT_EQ(unhex("b2323"), "\x0B##");
+  EXPECT_EQ(unhex("F"), "\x0F");
+  EXPECT_EQ(unhex("ff"), "\xFF");
+  EXPECT_EQ(unhex("G"), std::nullopt);
+  EXPECT_EQ(unhex("GG"), std::nullopt);
+  EXPECT_EQ(unhex("G23"), std::nullopt);
+  EXPECT_EQ(unhex("E4B889E9878DE79A84"), "\u4E09\u91CD\u7684");
+}
+
 class CeilFloorTest : public SparkFunctionBaseTest {
  protected:
   template <typename T>
   std::optional<int64_t> ceil(std::optional<T> a) {
-    return evaluateOnce<int64_t, T>("ceil(c0)", a);
+    return evaluateOnce<int64_t>("ceil(c0)", a);
   }
   template <typename T>
   std::optional<int64_t> floor(std::optional<T> a) {
-    return evaluateOnce<int64_t, T>("floor(c0)", a);
+    return evaluateOnce<int64_t>("floor(c0)", a);
   }
 };
 
@@ -333,10 +497,34 @@ TEST_F(ArithmeticTest, log1p) {
   EXPECT_TRUE(std::isnan(log1p(kNan).value_or(0)));
 }
 
+TEST_F(ArithmeticTest, expm1) {
+  static const auto expm1 = [&](std::optional<double> a) {
+    return evaluateOnce<double>("expm1(c0)", a);
+  };
+
+  const double kE = std::exp(1);
+
+  // If the argument is NaN, the result is NaN.
+  // If the argument is positive infinity, then the result is positive infinity.
+  // If the argument is negative infinity, then the result is -1.0.
+  // If the argument is zero, then the result is a zero with the same sign as
+  // the argument.
+  EXPECT_TRUE(std::isnan(expm1(kNan).value_or(0)));
+  EXPECT_EQ(expm1(kInf), kInf);
+  EXPECT_EQ(expm1(-kInf), -1);
+  EXPECT_EQ(expm1(0), 0);
+  EXPECT_EQ(expm1(1), kE - 1);
+  // As this is only for high accuracy of little number, we use a little number
+  // 1e-12 which can give the difference. If you use std::exp(x) - 1, the value
+  // may be 1.000009e-12, while the true value should be
+  // below 1.000000000000005e-12.
+  EXPECT_LT(expm1(1e-12), 1.00009e-12);
+}
+
 class BinTest : public SparkFunctionBaseTest {
  protected:
   std::optional<std::string> bin(std::optional<std::int64_t> arg) {
-    return evaluateOnce<std::string, int64_t>("bin(c0)", {arg}, {BIGINT()});
+    return evaluateOnce<std::string>("bin(c0)", arg);
   }
 };
 
@@ -350,6 +538,9 @@ TEST_F(BinTest, bin) {
       bin(std::numeric_limits<int64_t>::max()),
       "111111111111111111111111111111111111111111111111111111111111111");
   EXPECT_EQ(bin(0), "0");
+  auto result = evaluateOnce<std::string, int64_t>(
+      "bin(row_constructor(c0).c1)", std::make_optional(13L));
+  EXPECT_EQ(result, "1101");
 }
 
 TEST_F(ArithmeticTest, hypot) {
@@ -376,9 +567,172 @@ TEST_F(ArithmeticTest, cot) {
   EXPECT_EQ(cot(0), 1 / std::tan(0));
 }
 
+TEST_F(ArithmeticTest, atan2) {
+  const auto atan2 = [&](std::optional<double> y, std::optional<double> x) {
+    return evaluateOnce<double>("atan2(c0, c1)", y, x);
+  };
+
+  EXPECT_EQ(atan2(0.0, 0.0), 0.0);
+  EXPECT_EQ(atan2(-0.0, -0.0), 0.0);
+  EXPECT_EQ(atan2(0.0, -0.0), 0.0);
+  EXPECT_EQ(atan2(-0.0, 0.0), 0.0);
+  EXPECT_EQ(atan2(-1.0, 1.0), std::atan2(-1.0, 1.0));
+  EXPECT_EQ(atan2(1.0, 1.0), std::atan2(1.0, 1.0));
+  EXPECT_EQ(atan2(1.0, -1.0), std::atan2(1.0, -1.0));
+  EXPECT_EQ(atan2(-1.0, -1.0), std::atan2(-1.0, -1.0));
+}
+
+TEST_F(ArithmeticTest, isNanFloat) {
+  const auto isNan = [&](std::optional<float> a) {
+    return evaluateOnce<bool>("isnan(c0)", a);
+  };
+
+  EXPECT_EQ(false, isNan(0.0f));
+  EXPECT_EQ(true, isNan(kNan));
+  EXPECT_EQ(true, isNan(0.0f / 0.0f));
+  EXPECT_EQ(false, isNan(std::nullopt));
+}
+
+TEST_F(ArithmeticTest, isNanDouble) {
+  const auto isNan = [&](std::optional<double> a) {
+    return evaluateOnce<bool>("isnan(c0)", a);
+  };
+
+  EXPECT_EQ(false, isNan(0.0));
+  EXPECT_EQ(true, isNan(kNanDouble));
+  EXPECT_EQ(true, isNan(0.0 / 0.0));
+  EXPECT_EQ(false, isNan(std::nullopt));
+}
+
+TEST_F(ArithmeticTest, hexWithBigint) {
+  const auto toHex = [&](std::optional<int64_t> value) {
+    return evaluateOnce<std::string>("hex(c0)", value);
+  };
+  EXPECT_EQ("11", toHex(17));
+  EXPECT_EQ("FFFFFFFFFFFFFFEF", toHex(-17));
+  EXPECT_EQ("0", toHex(0));
+  EXPECT_EQ("FFFFFFFFFFFFFFFF", toHex(-1));
+  EXPECT_EQ("7FFFFFFFFFFFFFFF", toHex(INT64_MAX));
+  EXPECT_EQ("8000000000000000", toHex(INT64_MIN));
+}
+
+TEST_F(ArithmeticTest, hexWithVarbinaryAndVarchar) {
+  const auto toHex = [&](std::optional<std::string> value) {
+    auto varbinaryResult =
+        evaluateOnce<std::string>("hex(cast(c0 as varbinary))", value);
+    auto varcharResult = evaluateOnce<std::string>("hex(c0)", value);
+
+    EXPECT_TRUE(varbinaryResult.has_value());
+    EXPECT_TRUE(varcharResult.has_value());
+    EXPECT_EQ(varbinaryResult.value(), varcharResult.value());
+
+    return varcharResult.value();
+  };
+  ASSERT_EQ(toHex(""), "");
+  ASSERT_EQ(toHex("Spark SQL"), "537061726B2053514C");
+  ASSERT_EQ(toHex("Spark\x65\x21SQL"), "537061726B652153514C");
+  ASSERT_EQ(toHex("Spark\u6570\u636ESQL"), "537061726BE695B0E68DAE53514C");
+}
+
+TEST_F(ArithmeticTest, widthBucket) {
+  constexpr int64_t kMaxInt64 = std::numeric_limits<int64_t>::max();
+
+  const auto widthBucket = [&](std::optional<double> value,
+                               std::optional<double> min,
+                               std::optional<double> max,
+                               std::optional<int64_t> numBucket) {
+    return evaluateOnce<int64_t>(
+        "width_bucket(c0, c1, c2, c3)", value, min, max, numBucket);
+  };
+
+  // min < max
+  EXPECT_EQ(3, widthBucket(3.14, 0, 4, 3));
+  EXPECT_EQ(2, widthBucket(2, 0, 4, 3));
+  EXPECT_EQ(4, widthBucket(kInf, 0, 4, 3));
+  EXPECT_EQ(0, widthBucket(-1, 0, 3.2, 4));
+
+  // min > max
+  EXPECT_EQ(1, widthBucket(3.14, 4, 0, 3));
+  EXPECT_EQ(2, widthBucket(2, 4, 0, 3));
+  EXPECT_EQ(0, widthBucket(kInf, 4, 0, 3));
+  EXPECT_EQ(5, widthBucket(-1, 3.2, 0, 4));
+
+  // max - min + 1 > Long.MaxValue
+  EXPECT_EQ(widthBucket(5.3, 0, 9223372036854775807, 10), 1);
+
+  // Cases to get null result.
+  EXPECT_EQ(widthBucket(3.14, 0, 4, 0), std::nullopt);
+  EXPECT_EQ(widthBucket(kNan, 0, 4, 10), std::nullopt);
+  EXPECT_EQ(widthBucket(3.14, kNan, 0, 10), std::nullopt);
+  EXPECT_EQ(widthBucket(3.14, kInf, 0, 10), std::nullopt);
+  EXPECT_EQ(widthBucket(3.14, 0, kNan, 10), std::nullopt);
+  EXPECT_EQ(widthBucket(3.14, 0, kInf, 10), std::nullopt);
+  EXPECT_EQ(widthBucket(3.14, 0, 0, 10), std::nullopt);
+  EXPECT_EQ(widthBucket(kInf, 0, 4, kMaxInt64), std::nullopt);
+  EXPECT_EQ(widthBucket(kInf, 4, 0, kMaxInt64), std::nullopt);
+  EXPECT_EQ(widthBucket(5.3, 0.2, 10.6, 9223372036854775807), std::nullopt);
+
+  // value is infinite.
+  EXPECT_EQ(widthBucket(kInf, 0, 4, 3), 4);
+  EXPECT_EQ(widthBucket(-kInf, 0, 4, 3), 0);
+}
+
+TEST_F(ArithmeticTest, checkedAdd) {
+  assertErrorForCheckedAdd<int8_t>(INT8_MAX, 1, "Arithmetic overflow: 127 + 1");
+  assertErrorForCheckedAdd<int16_t>(
+      INT16_MAX, 1, "Arithmetic overflow: 32767 + 1");
+  assertErrorForCheckedAdd<int32_t>(
+      INT32_MAX, 1, "Arithmetic overflow: 2147483647 + 1");
+  assertErrorForCheckedAdd<int64_t>(
+      INT64_MAX, 1, "Arithmetic overflow: 9223372036854775807 + 1");
+  EXPECT_EQ(checkedAdd<float>(kInf, 1), kInf);
+  EXPECT_EQ(checkedAdd<double>(kInfDouble, 1), kInfDouble);
+}
+
+TEST_F(ArithmeticTest, checkedSubtract) {
+  assertErrorForcheckedSubtract<int8_t>(
+      INT8_MIN, 1, "Arithmetic overflow: -128 - 1");
+  assertErrorForcheckedSubtract<int16_t>(
+      INT16_MIN, 1, "Arithmetic overflow: -32768 - 1");
+  assertErrorForcheckedSubtract<int32_t>(
+      INT32_MIN, 1, "Arithmetic overflow: -2147483648 - 1");
+  assertErrorForcheckedSubtract<int64_t>(
+      INT64_MIN, 1, "Arithmetic overflow: -9223372036854775808 - 1");
+  EXPECT_EQ(checkedSubtract<float>(kInf, 1), kInf);
+  EXPECT_EQ(checkedSubtract<double>(kInfDouble, 1), kInfDouble);
+}
+
+TEST_F(ArithmeticTest, checkedMultiply) {
+  assertErrorForCheckedMultiply<int8_t>(
+      INT8_MAX, 2, "Arithmetic overflow: 127 * 2");
+  assertErrorForCheckedMultiply<int16_t>(
+      INT16_MAX, 2, "Arithmetic overflow: 32767 * 2");
+  assertErrorForCheckedMultiply<int32_t>(
+      INT32_MAX, 2, "Arithmetic overflow: 2147483647 * 2");
+  assertErrorForCheckedMultiply<int64_t>(
+      INT64_MAX, 2, "Arithmetic overflow: 9223372036854775807 * 2");
+  EXPECT_EQ(checkedMultiply<float>(kInf, 1), kInf);
+  EXPECT_EQ(checkedMultiply<double>(kInfDouble, 1), kInfDouble);
+}
+
+TEST_F(ArithmeticTest, checkedDivide) {
+  assertErrorForCheckedDivide<int32_t>(1, 0, "division by zero");
+  assertErrorForCheckedDivide<int8_t>(
+      INT8_MIN, -1, "Arithmetic overflow: -128 / -1");
+  assertErrorForCheckedDivide<int16_t>(
+      INT16_MIN, -1, "Arithmetic overflow: -32768 / -1");
+  assertErrorForCheckedDivide<int32_t>(
+      INT32_MIN, -1, "Arithmetic overflow: -2147483648 / -1");
+  assertErrorForCheckedDivide<int64_t>(
+      INT64_MIN, -1, "Arithmetic overflow: -9223372036854775808 / -1");
+  EXPECT_EQ(checkedDivide<float>(kInf, 1), kInf);
+  EXPECT_EQ(checkedDivide<double>(kInfDouble, 1), kInfDouble);
+}
+
 class LogNTest : public SparkFunctionBaseTest {
  protected:
-  static constexpr float kInf = std::numeric_limits<double>::infinity();
+  static constexpr double kInf = std::numeric_limits<double>::infinity();
+  static constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
 };
 
 TEST_F(LogNTest, log2) {
@@ -401,5 +755,30 @@ TEST_F(LogNTest, log10) {
   EXPECT_EQ(log10(kInf), kInf);
 }
 
+TEST_F(LogNTest, log) {
+  const auto log = [&](std::optional<double> a, std::optional<double> b) {
+    return evaluateOnce<double>("log(c0, c1)", a, b);
+  };
+  const auto isNan = [&](std::optional<double> res) {
+    return std::isnan(res.value());
+  };
+  EXPECT_EQ(log(10, 100), 2.0);
+
+  EXPECT_EQ(log(0.0, 1.0), std::nullopt);
+  EXPECT_EQ(log(1.0, 0.0), std::nullopt);
+  EXPECT_EQ(log(-1.0, 1.0), std::nullopt);
+  EXPECT_EQ(log(1.0, -1.0), std::nullopt);
+
+  EXPECT_EQ(log(1.0, 3.0), kInf);
+
+  EXPECT_TRUE(isNan(log(kNan, kNan)));
+  EXPECT_TRUE(isNan(log(kInf, kNan)));
+  EXPECT_TRUE(isNan(log(kNan, kInf)));
+  EXPECT_TRUE(isNan(log(kInf, kInf)));
+
+  EXPECT_EQ(log(kInf, -kInf), std::nullopt);
+  EXPECT_EQ(log(-kInf, kInf), std::nullopt);
+}
+
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArrayFlattenTest.cpp b/velox/functions/sparksql/tests/ArrayFlattenTest.cpp
new file mode 100644
index 0000000000000..b531c0b903c7d
--- /dev/null
+++ b/velox/functions/sparksql/tests/ArrayFlattenTest.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class ArrayFlattenTest : public SparkFunctionBaseTest {
+ protected:
+  void testExpression(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    const auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+};
+
+// Flatten integer arrays.
+TEST_F(ArrayFlattenTest, intArrays) {
+  const auto arrayOfArrays = makeNestedArrayVectorFromJson<int64_t>({
+      "[[1, 1], [2, 2], [3, 3]]",
+      "[[4, 4]]",
+      "[[5, 5], [6, 6]]",
+  });
+
+  const auto expected = makeArrayVectorFromJson<int64_t>(
+      {"[1, 1, 2, 2, 3, 3]", "[4, 4]", "[5, 5, 6, 6]"});
+
+  testExpression("flatten(c0)", {arrayOfArrays}, expected);
+}
+
+// Flatten arrays with null.
+TEST_F(ArrayFlattenTest, nullArray) {
+  const auto arrayOfArrays = makeNestedArrayVectorFromJson<int64_t>({
+      "[[1, 1], null, [3, 3]]",
+      "null",
+      "[[5, null], [null, 6], [null, null], []]",
+  });
+
+  const auto expected = makeArrayVectorFromJson<int64_t>(
+      {"null", "null", "[5, null, null, 6, null, null]"});
+
+  testExpression("flatten(c0)", {arrayOfArrays}, expected);
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArrayGetTest.cpp b/velox/functions/sparksql/tests/ArrayGetTest.cpp
new file mode 100644
index 0000000000000..13d8c70100c02
--- /dev/null
+++ b/velox/functions/sparksql/tests/ArrayGetTest.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <optional>
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::functions::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class ArrayGetTest : public SparkFunctionBaseTest {
+ protected:
+  template <typename T>
+  std::optional<T> arrayGet(
+      const ArrayVectorPtr& arrayVector,
+      const std::optional<int32_t>& index) {
+    auto input =
+        makeRowVector({arrayVector, makeConstant(index, arrayVector->size())});
+    return evaluateOnce<T>("get(c0, c1)", input);
+  }
+};
+
+TEST_F(ArrayGetTest, basic) {
+  auto arrayVector = makeNullableArrayVector<int32_t>({{1, 2, std::nullopt}});
+  EXPECT_EQ(arrayGet<int32_t>(arrayVector, -1), std::nullopt);
+  EXPECT_EQ(arrayGet<int32_t>(arrayVector, 0), 1);
+  EXPECT_EQ(arrayGet<int32_t>(arrayVector, 1), 2);
+  EXPECT_EQ(arrayGet<int32_t>(arrayVector, 2), std::nullopt);
+  EXPECT_EQ(arrayGet<int32_t>(arrayVector, 3), std::nullopt);
+  EXPECT_EQ(arrayGet<int32_t>(arrayVector, std::nullopt), std::nullopt);
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArrayInsertTest.cpp b/velox/functions/sparksql/tests/ArrayInsertTest.cpp
new file mode 100644
index 0000000000000..39b236b991f66
--- /dev/null
+++ b/velox/functions/sparksql/tests/ArrayInsertTest.cpp
@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class ArrayInsertTest : public SparkFunctionBaseTest {
+ protected:
+  void SetUp() override {
+    SparkFunctionBaseTest::SetUp();
+    options_.parseIntegerAsBigint = false;
+  }
+
+  void testExpression(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    const auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+
+  void evaluateExpression(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input) {
+    evaluate(expression, makeRowVector(input));
+  }
+
+  template <typename T>
+  void testInt() {
+    const std::vector<VectorPtr> input{
+        makeArrayVectorFromJson<T>({"[1]", "[2, 2]"}),
+        makeNullableFlatVector<T>({0, std::nullopt}),
+    };
+
+    auto expected = makeArrayVectorFromJson<T>({"[0, 1]", "[null, 2, 2]"});
+    testExpression("array_insert(c0, 1, c1, false)", input, expected);
+
+    expected = makeArrayVectorFromJson<T>({"[0, 1]", "[2, null, 2]"});
+    testExpression("array_insert(c0, -2, c1, false)", input, expected);
+  }
+
+  template <typename T>
+  void testFloat() {
+    static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+    static const T kInf = std::numeric_limits<T>::infinity();
+
+    const std::vector<VectorPtr> input{
+        makeNullableArrayVector<T>(
+            {{1.0001, -2.0}, {2.0001, kInf}, {kNaN, 9.0009}, {3.0001}}),
+        makeNullableFlatVector<T>({0, std::nullopt, kInf, kNaN}),
+    };
+
+    auto expected = makeNullableArrayVector<T>(
+        {{0, 1.0001, -2.0},
+         {std::nullopt, 2.0001, kInf},
+         {kInf, kNaN, 9.0009},
+         {kNaN, 3.0001}});
+    testExpression("array_insert(c0, 1, c1, false)", input, expected);
+
+    expected = makeNullableArrayVector<T>(
+        {{1.0001, 0, -2.0},
+         {2.0001, std::nullopt, kInf},
+         {kNaN, kInf, 9.0009},
+         {kNaN, 3.0001}});
+    testExpression("array_insert(c0, -2, c1, false)", input, expected);
+  }
+};
+
+TEST_F(ArrayInsertTest, intArrays) {
+  testInt<int8_t>();
+  testInt<int16_t>();
+  testInt<int32_t>();
+  testInt<int64_t>();
+}
+
+TEST_F(ArrayInsertTest, floatArrays) {
+  testInt<float_t>();
+  testInt<double_t>();
+}
+
+TEST_F(ArrayInsertTest, boolArrays) {
+  const auto arrays = makeArrayVectorFromJson<bool>(
+      {"[true]", "[true, false]", "[true, false, true]"});
+
+  auto expected = makeArrayVectorFromJson<bool>(
+      {"[true, true]", "[true, true, false]", "[true, true, false, true]"});
+  testExpression("array_insert(c0, 1, true, false)", {arrays}, expected);
+
+  expected = makeArrayVectorFromJson<bool>(
+      {"[null, true]", "[null, true, false]", "[null, true, false, true]"});
+  testExpression(
+      "array_insert(c0, 1, null::BOOLEAN, false)", {arrays}, expected);
+
+  expected = expected = makeArrayVectorFromJson<bool>(
+      {"[true, true]", "[true, true, false]", "[true, false, true, true]"});
+  testExpression("array_insert(c0, -2, true, false)", {arrays}, expected);
+}
+
+TEST_F(ArrayInsertTest, strArrays) {
+  using S = StringView;
+
+  auto arrays = makeNullableArrayVector<StringView>({
+      {S("a"), std::nullopt, S("b")},
+      {S("a"), S("b"), S("a"), S("a")},
+      {std::nullopt, S("b"), std::nullopt},
+      {S("purple is an elegant color")},
+  });
+
+  auto expected = makeNullableArrayVector<StringView>({
+      {S("X"), S("a"), std::nullopt, S("b")},
+      {S("X"), S("a"), S("b"), S("a"), S("a")},
+      {S("X"), std::nullopt, S("b"), std::nullopt},
+      {S("X"), S("purple is an elegant color")},
+  });
+  testExpression("array_insert(c0, 1, 'X', false)", {arrays}, expected);
+
+  expected = makeNullableArrayVector<StringView>({
+      {std::nullopt, S("a"), std::nullopt, S("b")},
+      {std::nullopt, S("a"), S("b"), S("a"), S("a")},
+      {std::nullopt, std::nullopt, S("b"), std::nullopt},
+      {std::nullopt, S("purple is an elegant color")},
+  });
+  testExpression(
+      "array_insert(c0, 1, null::STRING, false)", {arrays}, expected);
+
+  expected = makeNullableArrayVector<StringView>({
+      {S("a"), std::nullopt, S("X"), S("b")},
+      {S("a"), S("b"), S("a"), S("X"), S("a")},
+      {std::nullopt, S("b"), S("X"), std::nullopt},
+      {S("X"), S("purple is an elegant color")},
+  });
+  testExpression("array_insert(c0, -2, 'X', false)", {arrays}, expected);
+}
+
+TEST_F(ArrayInsertTest, varbinary) {
+  auto arrays = makeNullableArrayVector<StringView>(
+      {{"a"_sv, "b"_sv, "c"_sv}}, ARRAY(VARBINARY()));
+
+  auto expected = makeNullableArrayVector<StringView>(
+      {{"X"_sv, "a"_sv, "b"_sv, "c"_sv}}, ARRAY(VARBINARY()));
+  testExpression(
+      "array_insert(c0, 1, 'X'::VARBINARY, false)", {arrays}, expected);
+
+  expected = makeNullableArrayVector<StringView>(
+      {{std::nullopt, "a"_sv, "b"_sv, "c"_sv}}, ARRAY(VARBINARY()));
+  testExpression(
+      "array_insert(c0, 1, null::VARBINARY, false)", {arrays}, expected);
+
+  expected = makeNullableArrayVector<StringView>(
+      {{"a"_sv, "b"_sv, "X"_sv, "c"_sv}}, ARRAY(VARBINARY()));
+  testExpression(
+      "array_insert(c0, -2, 'X'::VARBINARY, false)", {arrays}, expected);
+}
+
+TEST_F(ArrayInsertTest, nestedArrays) {
+  auto arrays = makeNestedArrayVectorFromJson<int64_t>(
+      {"[[1, 1], null, [3, 3]]", "[[5, null], [null, 6], [null, null], []]"});
+  auto expected = makeNestedArrayVectorFromJson<int64_t>(
+      {"[[0, 0], [1, 1], null, [3, 3]]",
+       "[[0, 0], [5, null], [null, 6], [null, null], []]"});
+  testExpression("array_insert(c0, 1, ARRAY[0, 0], false)", {arrays}, expected);
+
+  const std::vector<VectorPtr> input{
+      arrays, makeArrayVectorFromJson<int64_t>({"null", "null"})};
+  expected = makeNestedArrayVectorFromJson<int64_t>(
+      {"[null, [1, 1], null, [3, 3]]",
+       "[null, [5, null], [null, 6], [null, null], []]"});
+  testExpression("array_insert(c0, 1, c1, false)", input, expected);
+
+  expected = makeNestedArrayVectorFromJson<int64_t>(
+      {"[[1, 1], null, [0, 0], [3, 3]]",
+       "[[5, null], [null, 6], [null, null], [0, 0], []]"});
+  testExpression(
+      "array_insert(c0, -2, ARRAY[0, 0], false)", {arrays}, expected);
+}
+
+TEST_F(ArrayInsertTest, mapArrays) {
+  using M = std::vector<std::pair<int32_t, std::optional<int32_t>>>;
+  auto arrays = makeArrayOfMapVector<int32_t, int32_t>(
+      {{M{{1, 10}}}, {M{{2, 20}, {3, 30}}, std::nullopt}});
+  auto expected = makeArrayOfMapVector<int32_t, int32_t>(
+      {{M{{0, 0}}, M{{1, 10}}},
+       {M{{0, 0}}, M{{2, 20}, {3, 30}}, std::nullopt}});
+  testExpression("array_insert(c0, 1, map(0, 0), false)", {arrays}, expected);
+
+  expected = makeArrayOfMapVector<int32_t, int32_t>(
+      {{std::nullopt, M{{1, 10}}},
+       {std::nullopt, M{{2, 20}, {3, 30}}, std::nullopt}});
+  testExpression(
+      "array_insert(c0, 1, null::MAP(INTEGER, INTEGER), false)",
+      {arrays},
+      expected);
+
+  expected = makeArrayOfMapVector<int32_t, int32_t>(
+      {{M{{0, 0}}, M{{1, 10}}},
+       {M{{2, 20}, {3, 30}}, M{{0, 0}}, std::nullopt}});
+  testExpression("array_insert(c0, -2, map(0, 0), false)", {arrays}, expected);
+}
+
+TEST_F(ArrayInsertTest, structArrays) {
+  using ArraysOfRow =
+      std::vector<std::vector<std::optional<std::tuple<int32_t, int32_t>>>>;
+  auto rowType = ROW({{"a", INTEGER()}, {"b", INTEGER()}});
+  auto arrays = makeArrayOfRowVector(
+      ArraysOfRow{{{{1, 1}}}, {{{2, 2}}, {{3, 3}}}}, rowType);
+  auto expected = makeArrayOfRowVector(
+      ArraysOfRow{{{{0, 0}}, {{1, 1}}}, {{{0, 0}}, {{2, 2}}, {{3, 3}}}},
+      rowType);
+  testExpression(
+      "array_insert(c0, 1, row_constructor(0, 0), false)", {arrays}, expected);
+
+  expected = makeArrayOfRowVector(
+      ArraysOfRow{{std::nullopt, {{1, 1}}}, {std::nullopt, {{2, 2}}, {{3, 3}}}},
+      rowType);
+  testExpression(
+      "array_insert(c0, 1, null::STRUCT(a INTEGER, b INTEGER), false)",
+      {arrays},
+      expected);
+
+  expected = makeArrayOfRowVector(
+      ArraysOfRow{{{{0, 0}}, {{1, 1}}}, {{{2, 2}}, {{0, 0}}, {{3, 3}}}},
+      rowType);
+  testExpression(
+      "array_insert(c0, -2, row_constructor(0, 0), false)", {arrays}, expected);
+}
+
+TEST_F(ArrayInsertTest, nullInputs) {
+  // Null input array.
+  auto arrays = makeArrayVectorFromJson<int64_t>({"null"});
+  auto expected = makeArrayVectorFromJson<int64_t>({"null"});
+  testExpression("array_insert(c0, 1, 1, false)", {arrays}, expected);
+
+  // Null postition.
+  arrays = makeArrayVectorFromJson<int64_t>({"[1, 1]"});
+  expected = makeArrayVectorFromJson<int64_t>({"null"});
+  testExpression(
+      "array_insert(c0, null::INTEGER, 1, false)", {arrays}, expected);
+
+  // Null element.
+  expected = makeArrayVectorFromJson<int64_t>({"[1, null, 1]"});
+  testExpression(
+      "array_insert(c0, 2, null::INTEGER, false)", {arrays}, expected);
+}
+
+TEST_F(ArrayInsertTest, posGTArraySize) {
+  const auto arrays = makeArrayVectorFromJson<int64_t>({"[1]", "[2, 2]"});
+
+  auto expected =
+      makeArrayVectorFromJson<int64_t>({"[1, null, 0]", "[2, 2, 0]"});
+  testExpression("array_insert(c0, 3, 0, false)", {arrays}, expected);
+
+  expected =
+      makeArrayVectorFromJson<int64_t>({"[1, null, null]", "[2, 2, null]"});
+  testExpression(
+      "array_insert(c0, 3, null::INTEGER, false)", {arrays}, expected);
+
+  // Insert into position INT_MAX.
+  EXPECT_THROW(
+      evaluateExpression("array_insert(c0, 2147483647, 0, false)", {arrays}),
+      VeloxUserError);
+  // Insert into position INT_MIN.
+  EXPECT_THROW(
+      evaluateExpression(
+          "array_insert(c0, cast(-2147483648 as integer), 0, false)", {arrays}),
+      VeloxUserError);
+}
+
+TEST_F(ArrayInsertTest, negativePos) {
+  const auto arrays =
+      makeArrayVectorFromJson<int64_t>({"[1]", "[2, 2]", "[3, 3, 3]"});
+
+  auto expected = makeArrayVectorFromJson<int64_t>(
+      {"[0, null, 1]", "[0, 2, 2]", "[3, 0, 3, 3]"});
+  testExpression("array_insert(c0, -3, 0, false)", {arrays}, expected);
+
+  expected =
+      makeArrayVectorFromJson<int64_t>({"[1, 0]", "[2, 2, 0]", "[3, 3, 3, 0]"});
+  testExpression("array_insert(c0, -1, 0, false)", {arrays}, expected);
+
+  expected = makeArrayVectorFromJson<int64_t>(
+      {"[null, null, 1]", "[null, 2, 2]", "[3, null, 3, 3]"});
+  testExpression(
+      "array_insert(c0, -3, null::INTEGER, false)", {arrays}, expected);
+}
+
+TEST_F(ArrayInsertTest, negativePosLegacy) {
+  const auto arrays =
+      makeArrayVectorFromJson<int64_t>({"[1]", "[2, 2]", "[3, 3, 3]"});
+
+  auto expected = makeArrayVectorFromJson<int64_t>(
+      {"[0, null, null, 1]", "[0, null, 2, 2]", "[0, 3, 3, 3]"});
+  testExpression("array_insert(c0, -3, 0, true)", {arrays}, expected);
+
+  expected =
+      makeArrayVectorFromJson<int64_t>({"[0, 1]", "[2, 0, 2]", "[3, 3, 0, 3]"});
+  testExpression("array_insert(c0, -1, 0, true)", {arrays}, expected);
+
+  expected = makeArrayVectorFromJson<int64_t>(
+      {"[null, null, null, 1]", "[null, null, 2, 2]", "[null, 3, 3, 3]"});
+  testExpression(
+      "array_insert(c0, -3, null::INTEGER, true)", {arrays}, expected);
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArrayMaxTest.cpp b/velox/functions/sparksql/tests/ArrayMaxTest.cpp
index aead97e1ca1b0..9d390c5d6dfbc 100644
--- a/velox/functions/sparksql/tests/ArrayMaxTest.cpp
+++ b/velox/functions/sparksql/tests/ArrayMaxTest.cpp
@@ -77,16 +77,6 @@ TEST_F(ArrayMaxTest, longVarchar) {
       "red shiny car ahead");
 }
 
-TEST_F(ArrayMaxTest, date) {
-  auto dt = [](const std::string& dateStr) { return DATE()->toDays(dateStr); };
-  EXPECT_EQ(
-      arrayMax<int32_t>({dt("1970-01-01"), dt("2023-08-23")}),
-      dt("2023-08-23"));
-  EXPECT_EQ(arrayMax<int32_t>({}), std::nullopt);
-  EXPECT_EQ(
-      arrayMax<int32_t>({dt("1970-01-01"), std::nullopt}), dt("1970-01-01"));
-}
-
 TEST_F(ArrayMaxTest, timestamp) {
   auto ts = [](int64_t micros) { return Timestamp::fromMicros(micros); };
   EXPECT_EQ(arrayMax<Timestamp>({ts(0), ts(1)}), ts(1));
@@ -100,7 +90,7 @@ TEST_F(ArrayMaxTest, timestamp) {
 template <typename Type>
 class ArrayMaxIntegralTest : public ArrayMaxTest {
  public:
-  using NATIVE_TYPE = typename Type::NativeType::NativeType;
+  using NATIVE_TYPE = typename Type::NativeType;
 };
 
 TYPED_TEST_SUITE(ArrayMaxIntegralTest, FunctionBaseTest::IntegralTypes);
@@ -141,7 +131,7 @@ TYPED_TEST(ArrayMaxIntegralTest, basic) {
 template <typename Type>
 class ArrayMaxFloatingPointTest : public ArrayMaxTest {
  public:
-  using NATIVE_TYPE = typename Type::NativeType::NativeType;
+  using NATIVE_TYPE = typename Type::NativeType;
 };
 
 TYPED_TEST_SUITE(
diff --git a/velox/functions/sparksql/tests/ArrayMinTest.cpp b/velox/functions/sparksql/tests/ArrayMinTest.cpp
index a658dba0344de..2b4c6e2cd3a83 100644
--- a/velox/functions/sparksql/tests/ArrayMinTest.cpp
+++ b/velox/functions/sparksql/tests/ArrayMinTest.cpp
@@ -78,16 +78,6 @@ TEST_F(ArrayMinTest, longVarchar) {
       "green plants make us happy");
 }
 
-TEST_F(ArrayMinTest, date) {
-  auto dt = [](const std::string& dateStr) { return DATE()->toDays(dateStr); };
-  EXPECT_EQ(
-      arrayMin<int32_t>({dt("1970-01-01"), dt("2023-08-23")}),
-      dt("1970-01-01"));
-  EXPECT_EQ(arrayMin<int32_t>({}), std::nullopt);
-  EXPECT_EQ(
-      arrayMin<int32_t>({dt("1970-01-01"), std::nullopt}), dt("1970-01-01"));
-}
-
 TEST_F(ArrayMinTest, timestamp) {
   auto ts = [](int64_t micros) { return Timestamp::fromMicros(micros); };
   EXPECT_EQ(arrayMin<Timestamp>({ts(0), ts(1)}), ts(0));
@@ -101,7 +91,7 @@ TEST_F(ArrayMinTest, timestamp) {
 template <typename Type>
 class ArrayMinIntegralTest : public ArrayMinTest {
  public:
-  using NATIVE_TYPE = typename Type::NativeType::NativeType;
+  using NATIVE_TYPE = typename Type::NativeType;
 };
 
 TYPED_TEST_SUITE(ArrayMinIntegralTest, FunctionBaseTest::IntegralTypes);
@@ -142,7 +132,7 @@ TYPED_TEST(ArrayMinIntegralTest, basic) {
 template <typename Type>
 class ArrayMinFloatingPointTest : public ArrayMinTest {
  public:
-  using NATIVE_TYPE = typename Type::NativeType::NativeType;
+  using NATIVE_TYPE = typename Type::NativeType;
 };
 
 TYPED_TEST_SUITE(
diff --git a/velox/functions/sparksql/tests/ArrayShuffleTest.cpp b/velox/functions/sparksql/tests/ArrayShuffleTest.cpp
new file mode 100644
index 0000000000000..fa92683aa9f93
--- /dev/null
+++ b/velox/functions/sparksql/tests/ArrayShuffleTest.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/expression/VectorReaders.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+using namespace facebook::velox::test;
+
+class ArrayShuffleTest : public SparkFunctionBaseTest {
+ protected:
+  void testShuffle(
+      const VectorPtr& input,
+      const VectorPtr& expected,
+      int64_t seed,
+      int32_t partitionId = 0) {
+    setSparkPartitionId(partitionId);
+    assertEqualVectors(
+        evaluate(fmt::format("shuffle(c0, {})", seed), makeRowVector({input})),
+        expected);
+  }
+
+  template <typename T>
+  void testShuffle(
+      const VectorPtr& input,
+      const std::vector<std::string>& expected,
+      int64_t seed,
+      int32_t partitionId = 0) {
+    testShuffle(input, makeArrayVectorFromJson<T>(expected), seed, partitionId);
+  }
+
+  template <typename T>
+  void testShuffle(
+      const std::string& input,
+      const std::string& expected,
+      int64_t seed,
+      int32_t partitionId = 0) {
+    testShuffle<T>(
+        makeArrayVectorFromJson<T>({input}), {expected}, seed, partitionId);
+  }
+};
+
+TEST_F(ArrayShuffleTest, basic) {
+  testShuffle<int64_t>("[1, 2, 3, 4, 5]", "[3, 5, 4, 1, 2]", 0);
+  testShuffle<std::string>(
+      R"(["a", "b", "c", "d"])", R"(["a", "c", "b", "d"])", 0);
+
+  // Assert results are different with different seeds / partition ids.
+  testShuffle<int64_t>("[1, 2, 3, 4, 5]", "[2, 1, 3, 4, 5]", 0, 1);
+  testShuffle<int64_t>("[1, 2, 3, 4, 5]", "[4, 1, 3, 5, 2]", 2, 0);
+}
+
+TEST_F(ArrayShuffleTest, nestedArrays) {
+  auto input = makeNestedArrayVectorFromJson<int64_t>(
+      {"[[1, 2, 3, 4], [5, 6]]",
+       "[null, null, [1, 2, 3, 4], [5, 6], [6, 7, 8]]",
+       "[[]]",
+       "[[null]]"});
+  auto result = makeNestedArrayVectorFromJson<int64_t>(
+      {"[[1, 2, 3, 4], [5, 6]]",
+       "[[1, 2, 3, 4], null, [5, 6], null, [6, 7, 8]]",
+       "[[]]",
+       "[[null]]"});
+  testShuffle(input, result, 0);
+}
+
+TEST_F(ArrayShuffleTest, constantEncoding) {
+  vector_size_t size = 3;
+  // Test empty array, array with null element,
+  // array with duplicate elements, and array with distinct values.
+  auto valueVector = makeArrayVectorFromJson<int64_t>(
+      {"[]", "[null, 0]", "[5, 5]", "[1, 2, 3]"});
+  std::vector<std::vector<std::string>> result = {
+      {"[]", "[]", "[]"},
+      {"[null, 0]", "[null, 0]", "[null, 0]"},
+      {"[5, 5]", "[5, 5]", "[5, 5]"},
+      {"[3, 2, 1]", "[3, 2, 1]", "[1, 3, 2]"}};
+  for (auto i = 0; i < valueVector->size(); i++) {
+    auto input = BaseVector::wrapInConstant(size, i, valueVector);
+    testShuffle<int64_t>(input, result[i], 0);
+  }
+}
+
+TEST_F(ArrayShuffleTest, dictEncoding) {
+  // Test dict with repeated elements: {1,2,3} x 3, {4,5} x 2.
+  auto base = makeArrayVectorFromJson<int64_t>(
+      {"[0]",
+       "[1, 2 ,3]",
+       "[4, 5, null]",
+       "[1, 2, 3]",
+       "[1, 2, 3]",
+       "[4, 5, null]"});
+  std::vector<std::string> result = {
+      "[3, 2, 1]",
+      "[3, 2 ,1]",
+      "[1, 3, 2]",
+      "[4, 5, null]",
+      "[null, 5, 4]",
+      "[1, 2, 3]",
+      "[3, 2, 1]",
+      "[1, 2, 3]"};
+  // Test repeated index elements and indices filtering (filter out element at
+  // index 0).
+  auto indices = makeIndices({3, 3, 4, 2, 2, 1, 1, 1});
+  auto input = wrapInDictionary(indices, base);
+  testShuffle<int64_t>(input, result, 0);
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArraySortTest.cpp b/velox/functions/sparksql/tests/ArraySortTest.cpp
index 4f9d51955633d..1247e020239a7 100644
--- a/velox/functions/sparksql/tests/ArraySortTest.cpp
+++ b/velox/functions/sparksql/tests/ArraySortTest.cpp
@@ -31,8 +31,7 @@ using facebook::velox::functions::test::FunctionBaseTest;
 class ArraySortTest : public SparkFunctionBaseTest {
  protected:
   void testArraySort(const VectorPtr& input, const VectorPtr& expected) {
-    auto result =
-        evaluate<ArrayVector>("array_sort(c0)", makeRowVector({input}));
+    auto result = evaluate("array_sort(c0)", makeRowVector({input}));
     assertEqualVectors(expected, result);
   }
 
diff --git a/velox/functions/sparksql/tests/BitwiseTest.cpp b/velox/functions/sparksql/tests/BitwiseTest.cpp
index bc635fc1e025b..d53b967d3e008 100644
--- a/velox/functions/sparksql/tests/BitwiseTest.cpp
+++ b/velox/functions/sparksql/tests/BitwiseTest.cpp
@@ -32,7 +32,6 @@ static constexpr auto kMin32 = std::numeric_limits<int32_t>::min();
 static constexpr auto kMax32 = std::numeric_limits<int32_t>::max();
 static constexpr auto kMin64 = std::numeric_limits<int64_t>::min();
 static constexpr auto kMax64 = std::numeric_limits<int64_t>::max();
-static constexpr int kMaxBits = std::numeric_limits<uint64_t>::digits;
 
 class BitwiseTest : public SparkFunctionBaseTest {
  protected:
@@ -41,11 +40,21 @@ class BitwiseTest : public SparkFunctionBaseTest {
     return evaluateOnce<T>("bitwise_and(c0, c1)", a, b);
   }
 
+  template <typename T>
+  std::optional<T> bitwiseNot(std::optional<T> a) {
+    return evaluateOnce<T>("bitwise_not(c0)", a);
+  }
+
   template <typename T>
   std::optional<T> bitwiseOr(std::optional<T> a, std::optional<T> b) {
     return evaluateOnce<T>("bitwise_or(c0, c1)", a, b);
   }
 
+  template <typename T>
+  std::optional<T> bitwiseXor(std::optional<T> a, std::optional<T> b) {
+    return evaluateOnce<T>("bitwise_xor(c0, c1)", a, b);
+  }
+
   template <typename T>
   std::optional<int32_t> bitCount(std::optional<T> a) {
     return evaluateOnce<int32_t>("bit_count(c0)", a);
@@ -115,6 +124,25 @@ TEST_F(BitwiseTest, bitwiseAnd) {
   EXPECT_EQ(bitwiseAnd<int64_t>(kMin64, -1), kMin64);
 }
 
+TEST_F(BitwiseTest, bitwiseNot) {
+  EXPECT_EQ(bitwiseNot<int32_t>(0), -1);
+  EXPECT_EQ(bitwiseNot<int32_t>(3), -4);
+  EXPECT_EQ(bitwiseNot<int32_t>(-4), 3);
+  EXPECT_EQ(bitwiseNot<int32_t>(60), -61);
+
+  EXPECT_EQ(bitwiseNot<int8_t>(kMin8), kMax8);
+  EXPECT_EQ(bitwiseNot<int8_t>(kMax8), kMin8);
+
+  EXPECT_EQ(bitwiseNot<int16_t>(kMin16), kMax16);
+  EXPECT_EQ(bitwiseNot<int16_t>(kMax16), kMin16);
+
+  EXPECT_EQ(bitwiseNot<int32_t>(kMin32), kMax32);
+  EXPECT_EQ(bitwiseNot<int32_t>(kMax32), kMin32);
+
+  EXPECT_EQ(bitwiseNot<int64_t>(kMin64), kMax64);
+  EXPECT_EQ(bitwiseNot<int64_t>(kMax64), kMin64);
+}
+
 TEST_F(BitwiseTest, bitwiseOr) {
   EXPECT_EQ(bitwiseOr<int32_t>(0, -1), -1);
   EXPECT_EQ(bitwiseOr<int32_t>(3, 8), 11);
@@ -149,6 +177,49 @@ TEST_F(BitwiseTest, bitwiseOr) {
   EXPECT_EQ(bitwiseOr<int64_t>(kMin64, -1), -1);
 }
 
+TEST_F(BitwiseTest, bitwiseXor) {
+  EXPECT_EQ(bitwiseXor<int32_t>(0, -1), -1);
+  EXPECT_EQ(bitwiseXor<int32_t>(3, 8), 11);
+  EXPECT_EQ(bitwiseXor<int32_t>(-4, 12), -16);
+  EXPECT_EQ(bitwiseXor<int32_t>(60, 21), 41);
+
+  EXPECT_EQ(bitwiseXor<int8_t>(kMin8, kMax8), -1);
+  EXPECT_EQ(bitwiseXor<int8_t>(kMax8, kMax8), 0);
+  EXPECT_EQ(bitwiseXor<int8_t>(kMax8, kMin8), -1);
+  EXPECT_EQ(bitwiseXor<int8_t>(kMin8, kMin8), 0);
+  EXPECT_EQ(bitwiseXor<int8_t>(kMax8, 1), kMax8 - 1);
+  EXPECT_EQ(bitwiseXor<int8_t>(kMax8, -1), kMin8);
+  EXPECT_EQ(bitwiseXor<int8_t>(kMin8, 1), kMin8 + 1);
+  EXPECT_EQ(bitwiseXor<int8_t>(kMin8, -1), kMax8);
+
+  EXPECT_EQ(bitwiseXor<int16_t>(kMin16, kMax16), -1);
+  EXPECT_EQ(bitwiseXor<int16_t>(kMax16, kMax16), 0);
+  EXPECT_EQ(bitwiseXor<int16_t>(kMax16, kMin16), -1);
+  EXPECT_EQ(bitwiseXor<int16_t>(kMin16, kMin16), 0);
+  EXPECT_EQ(bitwiseXor<int16_t>(kMax16, 1), kMax16 - 1);
+  EXPECT_EQ(bitwiseXor<int16_t>(kMax16, -1), kMin16);
+  EXPECT_EQ(bitwiseXor<int16_t>(kMin16, 1), kMin16 + 1);
+  EXPECT_EQ(bitwiseXor<int16_t>(kMin16, -1), kMax16);
+
+  EXPECT_EQ(bitwiseXor<int32_t>(kMin32, kMax32), -1);
+  EXPECT_EQ(bitwiseXor<int32_t>(kMax32, kMax32), 0);
+  EXPECT_EQ(bitwiseXor<int32_t>(kMax32, kMin32), -1);
+  EXPECT_EQ(bitwiseXor<int32_t>(kMin32, kMin32), 0);
+  EXPECT_EQ(bitwiseXor<int32_t>(kMax32, 1), kMax32 - 1);
+  EXPECT_EQ(bitwiseXor<int32_t>(kMax32, -1), kMin32);
+  EXPECT_EQ(bitwiseXor<int32_t>(kMin32, 1), kMin32 + 1);
+  EXPECT_EQ(bitwiseXor<int32_t>(kMin32, -1), kMax32);
+
+  EXPECT_EQ(bitwiseXor<int64_t>(kMin64, kMax64), -1);
+  EXPECT_EQ(bitwiseXor<int64_t>(kMax64, kMax64), 0);
+  EXPECT_EQ(bitwiseXor<int64_t>(kMax64, kMin64), -1);
+  EXPECT_EQ(bitwiseXor<int64_t>(kMin64, kMin64), 0);
+  EXPECT_EQ(bitwiseXor<int64_t>(kMax64, 1), kMax64 - 1);
+  EXPECT_EQ(bitwiseXor<int64_t>(kMax64, -1), kMin64);
+  EXPECT_EQ(bitwiseXor<int64_t>(kMin64, 1), kMin64 + 1);
+  EXPECT_EQ(bitwiseXor<int64_t>(kMin64, -1), kMax64);
+}
+
 TEST_F(BitwiseTest, bitCount) {
   EXPECT_EQ(bitCount<int8_t>(std::nullopt), std::nullopt);
   EXPECT_EQ(bitCount<bool>(1), 1);
diff --git a/velox/functions/sparksql/tests/CMakeLists.txt b/velox/functions/sparksql/tests/CMakeLists.txt
index e574afcf7bd43..8543e0c733a21 100644
--- a/velox/functions/sparksql/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/tests/CMakeLists.txt
@@ -15,24 +15,45 @@
 add_executable(
   velox_functions_spark_test
   ArithmeticTest.cpp
+  ArrayFlattenTest.cpp
+  ArrayGetTest.cpp
+  ArrayInsertTest.cpp
   ArrayMaxTest.cpp
   ArrayMinTest.cpp
   ArraySortTest.cpp
+  ArrayShuffleTest.cpp
+  ArgGeneratorTest.cpp
   BitwiseTest.cpp
   ComparisonsTest.cpp
   DateTimeFunctionsTest.cpp
+  DecimalArithmeticTest.cpp
+  DecimalCompareTest.cpp
+  DecimalRoundTest.cpp
+  DecimalUtilTest.cpp
   ElementAtTest.cpp
   HashTest.cpp
   InTest.cpp
+  JsonObjectKeysTest.cpp
   LeastGreatestTest.cpp
+  MakeDecimalTest.cpp
+  MakeTimestampTest.cpp
   MapTest.cpp
+  MaskTest.cpp
   MightContainTest.cpp
+  MonotonicallyIncreasingIdTest.cpp
+  RaiseErrorTest.cpp
   RandTest.cpp
   RegexFunctionsTest.cpp
+  SliceTest.cpp
   SizeTest.cpp
   SortArrayTest.cpp
-  SplitFunctionsTest.cpp
+  SparkCastExprTest.cpp
+  SparkPartitionIdTest.cpp
+  SplitTest.cpp
   StringTest.cpp
+  StringToMapTest.cpp
+  UnscaledValueFunctionTest.cpp
+  UuidTest.cpp
   XxHash64Test.cpp)
 
 add_test(velox_functions_spark_test velox_functions_spark_test)
@@ -42,8 +63,10 @@ target_link_libraries(
   velox_functions_spark
   velox_functions_test_lib
   velox_exec_test_lib
+  velox_expression_fuzzer_test_utility
+  velox_expression_fuzzer
   fmt::fmt
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   gflags::gflags)
diff --git a/velox/functions/sparksql/tests/ComparisonsTest.cpp b/velox/functions/sparksql/tests/ComparisonsTest.cpp
index 553b38d80a546..e3990581e8563 100644
--- a/velox/functions/sparksql/tests/ComparisonsTest.cpp
+++ b/velox/functions/sparksql/tests/ComparisonsTest.cpp
@@ -65,9 +65,153 @@ class ComparisonsTest : public SparkFunctionBaseTest {
       std::optional<T> b) {
     return evaluateOnce<bool>("greaterthanorequal(c0, c1)", a, b);
   }
+
+  template <TypeKind kind>
+  void runSIMDCompareAndAssert(int size, int unSelectedRows = 0) {
+    using T = typename TypeTraits<kind>::NativeType;
+    auto type = TypeTraits<kind>::ImplType::create();
+    auto expectedResult = std::vector<bool>();
+    expectedResult.resize(size);
+    VectorFuzzer::Options opts;
+    opts.vectorSize = size;
+    VectorFuzzer fuzzer(opts, execCtx_.pool());
+    auto lVector = fuzzer.fuzzFlat(type, size);
+    auto left = lVector->template as<FlatVector<T>>()->rawValues();
+    auto rVector = fuzzer.fuzzFlat(type, size);
+    auto right = rVector->template as<FlatVector<T>>()->rawValues();
+    auto constVector = fuzzer.fuzzConstant(type);
+    auto constant = constVector->template as<ConstantVector<T>>()->value();
+    auto lDictVector = fuzzer.fuzzDictionary(lVector);
+    auto rDictVector = fuzzer.fuzzDictionary(rVector);
+    auto lDictDictVector = fuzzer.fuzzDictionary(lDictVector);
+    SelectivityVector rows(size);
+    rows.setValidRange(0, unSelectedRows, false);
+
+    // Flat, Flat
+    std::vector<VectorPtr> childrenVectors = {lVector, rVector};
+    auto rowVector =
+        fuzzer.fuzzRow(std::move(childrenVectors), {"c0", "c1"}, size);
+    auto result =
+        evaluate<SimpleVector<bool>>("greaterthanorequal(c0, c1)", rowVector);
+    for (auto i = unSelectedRows; i < size; i++) {
+      expectedResult[i] = left[i] >= right[i];
+    }
+    velox::test::assertEqualVectors(
+        makeFlatVector<bool>(expectedResult), result, rows);
+
+    // Flat, Const
+    std::vector<VectorPtr> rConstVectors = {lVector, constVector};
+    rowVector = fuzzer.fuzzRow(std::move(rConstVectors), {"c0", "c1"}, size);
+    result = evaluate<SimpleVector<bool>>("equalto(c0, c1)", rowVector);
+    for (auto i = unSelectedRows; i < size; i++) {
+      expectedResult[i] = left[i] == constant;
+    }
+    velox::test::assertEqualVectors(
+        makeFlatVector<bool>(expectedResult), result, rows);
+
+    // Const, Flat
+    std::vector<VectorPtr> lConstVectors = {constVector, rVector};
+    rowVector = fuzzer.fuzzRow(std::move(lConstVectors), {"c0", "c1"}, size);
+    result = evaluate<SimpleVector<bool>>("lessthan(c0, c1)", rowVector);
+    for (auto i = unSelectedRows; i < size; i++) {
+      expectedResult[i] = constant < right[i];
+    }
+    velox::test::assertEqualVectors(
+        makeFlatVector<bool>(expectedResult), result, rows);
+
+    // Dict(Flat), Flat
+    childrenVectors = {lDictVector, rVector};
+    rowVector = fuzzer.fuzzRow(std::move(childrenVectors), {"c0", "c1"}, size);
+    result = evaluate<SimpleVector<bool>>("lessthanorequal(c0, c1)", rowVector);
+    DecodedVector lDecodedVector(*lDictVector);
+    for (auto i = unSelectedRows; i < size; i++) {
+      expectedResult[i] = lDecodedVector.valueAt<T>(i) <= right[i];
+    }
+    velox::test::assertEqualVectors(
+        makeFlatVector<bool>(expectedResult), result, rows);
+
+    // Flat, Dict(Flat)
+    childrenVectors = {lVector, rDictVector};
+    rowVector = fuzzer.fuzzRow(std::move(childrenVectors), {"c0", "c1"}, size);
+    result = evaluate<SimpleVector<bool>>("greaterthan(c0, c1)", rowVector);
+    DecodedVector rDecodedVector(*rDictVector);
+    for (auto i = unSelectedRows; i < size; i++) {
+      expectedResult[i] = left[i] > rDecodedVector.valueAt<T>(i);
+    }
+    velox::test::assertEqualVectors(
+        makeFlatVector<bool>(expectedResult), result, rows);
+
+    // Dict(Dict(Flat)), Flat
+    childrenVectors = {lDictDictVector, rVector};
+    rowVector = fuzzer.fuzzRow(std::move(childrenVectors), {"c0", "c1"}, size);
+    result = evaluate<SimpleVector<bool>>("lessthanorequal(c0, c1)", rowVector);
+    DecodedVector decodedVector(*lDictDictVector);
+    for (auto i = unSelectedRows; i < size; i++) {
+      expectedResult[i] = decodedVector.valueAt<T>(i) <= right[i];
+    }
+    velox::test::assertEqualVectors(
+        makeFlatVector<bool>(expectedResult), result, rows);
+  }
+
+  void runAndCompare(
+      const std::string& functionName,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expectedResult) {
+    auto actual = evaluate<SimpleVector<bool>>(
+        fmt::format("{}(c0, c1)", functionName), makeRowVector(input));
+    facebook::velox::test::assertEqualVectors(expectedResult, actual);
+  }
+
+  RowVectorPtr constructRowVector(
+      const std::optional<int64_t>& value,
+      const bool rowIsNull = false) {
+    auto child = makeNullableFlatVector<int64_t>({value});
+    if (rowIsNull) {
+      return makeRowVector({child}, nullEvery(1));
+    }
+    return makeRowVector({child});
+  }
+
+  void runAndCompareForArrayInput(
+      const std::string& functionName,
+      const std::string& array1,
+      const std::string& array2,
+      std::optional<bool> expectedResult) {
+    auto vector1 = makeArrayVectorFromJson<double>({array1});
+    auto vector2 = makeArrayVectorFromJson<double>({array2});
+    runAndCompare(
+        functionName,
+        {vector1, vector2},
+        makeNullableFlatVector<bool>({expectedResult}));
+  }
+
+  void runAndCompareForRowInput(
+      const std::string& functionName,
+      const RowVectorPtr& vector1,
+      const RowVectorPtr& vector2,
+      const VectorPtr& expectedResult) {
+    runAndCompare(functionName, {vector1, vector2}, expectedResult);
+  }
 };
 
 TEST_F(ComparisonsTest, equaltonullsafe) {
+  const auto funcName = "equalnullsafe";
+  auto testArrayInput = [&](const std::string& array1,
+                            const std::string& array2,
+                            std::optional<bool> expectedResult) {
+    runAndCompareForArrayInput(funcName, array1, array2, expectedResult);
+  };
+
+  auto testRowInput = [&](const std::optional<int64_t>& value1,
+                          const std::optional<int64_t>& value2,
+                          std::optional<bool> expectedResult) {
+    runAndCompareForRowInput(
+        funcName,
+        constructRowVector(value1),
+        constructRowVector(value2),
+        makeNullableFlatVector<bool>({expectedResult}));
+  };
+
   EXPECT_EQ(equaltonullsafe<int64_t>(1, 1), true);
   EXPECT_EQ(equaltonullsafe<int32_t>(1, 2), false);
   EXPECT_EQ(equaltonullsafe<float>(std::nullopt, std::nullopt), true);
@@ -77,13 +221,68 @@ TEST_F(ComparisonsTest, equaltonullsafe) {
   EXPECT_EQ(equaltonullsafe<double>(kNaN, std::nullopt), false);
   EXPECT_EQ(equaltonullsafe<double>(kNaN, 1), false);
   EXPECT_EQ(equaltonullsafe<double>(kNaN, kNaN), true);
+
+  testArrayInput("null", "null", true);
+  testArrayInput("null", "[1.0]", false);
+  testArrayInput("[1.0]", "null", false);
+
+  testArrayInput("[]", "[]", true);
+
+  testArrayInput("[1.0, 2.0, 3.0]", "[1.0, 2.0, 3.0]", true);
+  testArrayInput("[1.0, 2.0, 3.0]", "[1.0, 2.0, 4.0]", false);
+
+  testArrayInput("[1.0, null]", "[6.0, 2.0]", false);
+  testArrayInput("[1.0, null]", "[1.0, 2.0]", false);
+  testArrayInput("[1.0, NaN]", "[1.0, NaN]", true);
+
+  testArrayInput("[]", "[null, null]", false);
+  testArrayInput("[1.0, 2.0]", "[1.0, 2.0, null]", false);
+  testArrayInput("[null, null]", "[null, null, null]", false);
+
+  testArrayInput("[null, null]", "[null, null]", true);
+
+  testRowInput(std::nullopt, std::nullopt, true);
+  testRowInput(std::nullopt, 1, false);
+  testRowInput(1, std::nullopt, false);
+
+  testRowInput(1, 2, false);
+  testRowInput(1, 1, true);
+
+  runAndCompareForRowInput(
+      funcName,
+      constructRowVector(std::nullopt, true),
+      constructRowVector(std::nullopt, true),
+      makeNullableFlatVector<bool>({true}));
+  runAndCompareForRowInput(
+      funcName,
+      constructRowVector(std::nullopt, true),
+      constructRowVector(1, false),
+      makeNullableFlatVector<bool>({false}));
+  runAndCompareForRowInput(
+      funcName,
+      constructRowVector(1, false),
+      constructRowVector(std::nullopt, true),
+      makeNullableFlatVector<bool>({false}));
 }
 
 TEST_F(ComparisonsTest, equalto) {
+  const auto funcName = "equalto";
+  auto testArrayInput = [&](const std::string& array1,
+                            const std::string& array2,
+                            std::optional<bool> expectedResult) {
+    runAndCompareForArrayInput(funcName, array1, array2, expectedResult);
+  };
+
+  auto testRowInput = [&](const std::optional<int64_t>& value1,
+                          const std::optional<int64_t>& value2,
+                          std::optional<bool> expectedResult) {
+    runAndCompareForRowInput(
+        funcName,
+        constructRowVector(value1),
+        constructRowVector(value2),
+        makeNullableFlatVector<bool>({expectedResult}));
+  };
   EXPECT_EQ(equalto<Timestamp>(Timestamp(2, 2), Timestamp(2, 2)), true);
-  EXPECT_EQ(
-      equalto<int128_t>(HugeInt::build(10, 300), HugeInt::build(-10, 300)),
-      false);
   EXPECT_EQ(equalto<StringView>("test"_sv, "test"_sv), true);
   EXPECT_EQ(equalto<StringView>("test"_sv, std::nullopt), std::nullopt);
   EXPECT_EQ(equalto<int64_t>(1, 1), true);
@@ -104,6 +303,48 @@ TEST_F(ComparisonsTest, equalto) {
   EXPECT_EQ(equalto<float>(-kInfF, 1.0), false);
   EXPECT_EQ(equalto<float>(kInfF, -kInfF), false);
   EXPECT_EQ(equalto<double>(kInf, kNaN), false);
+
+  testArrayInput("null", "null", std::nullopt);
+  testArrayInput("null", "[1.0]", std::nullopt);
+  testArrayInput("[1.0]", "null", std::nullopt);
+
+  testArrayInput("[]", "[]", true);
+
+  testArrayInput("[1.0, 2.0, 3.0]", "[1.0, 2.0, 3.0]", true);
+  testArrayInput("[1.0, 2.0, 3.0]", "[1.0, 2.0, 4.0]", false);
+
+  testArrayInput("[1.0, null]", "[6.0, 2.0]", false);
+  testArrayInput("[1.0, null]", "[1.0, 2.0]", false);
+  testArrayInput("[1.0, NaN]", "[1.0, NaN]", true);
+
+  testArrayInput("[]", "[null, null]", false);
+  testArrayInput("[1.0, 2.0]", "[1.0, 2.0, null]", false);
+  testArrayInput("[null, null]", "[null, null, null]", false);
+
+  testArrayInput("[null, null]", "[null, null]", true);
+
+  testRowInput(std::nullopt, std::nullopt, true);
+  testRowInput(std::nullopt, 1, false);
+  testRowInput(1, std::nullopt, false);
+
+  testRowInput(1, 2, false);
+  testRowInput(1, 1, true);
+
+  runAndCompareForRowInput(
+      funcName,
+      constructRowVector(std::nullopt, true),
+      constructRowVector(std::nullopt, true),
+      makeNullableFlatVector<bool>({std::nullopt}));
+  runAndCompareForRowInput(
+      funcName,
+      constructRowVector(std::nullopt, true),
+      constructRowVector(1, false),
+      makeNullableFlatVector<bool>({std::nullopt}));
+  runAndCompareForRowInput(
+      funcName,
+      constructRowVector(1, false),
+      constructRowVector(std::nullopt, true),
+      makeNullableFlatVector<bool>({std::nullopt}));
 }
 
 TEST_F(ComparisonsTest, between) {
@@ -126,13 +367,7 @@ TEST_F(ComparisonsTest, between) {
   EXPECT_EQ(between<double>(kInf, -kInf, kNaN), false);
 }
 
-TEST_F(ComparisonsTest, testdecimal) {
-  auto runAndCompare = [&](const std::string& exprStr,
-                           std::vector<VectorPtr>& input,
-                           VectorPtr expectedResult) {
-    auto actual = evaluate<SimpleVector<bool>>(exprStr, makeRowVector(input));
-    facebook::velox::test::assertEqualVectors(actual, expectedResult);
-  };
+TEST_F(ComparisonsTest, decimal) {
   std::vector<VectorPtr> inputs = {
       makeNullableFlatVector<int64_t>(
           {1, std::nullopt, 3, -2, std::nullopt, 4}, DECIMAL(10, 5)),
@@ -140,7 +375,7 @@ TEST_F(ComparisonsTest, testdecimal) {
           {0, 2, 3, -3, std::nullopt, 5}, DECIMAL(10, 5))};
   auto expected = makeNullableFlatVector<bool>(
       {true, std::nullopt, false, true, std::nullopt, false});
-  runAndCompare(fmt::format("{}(c0, c1)", "greaterthan"), inputs, expected);
+  runAndCompare("greaterthan", inputs, expected);
   std::vector<VectorPtr> longDecimalsInputs = {
       makeNullableFlatVector<int128_t>(
           {DecimalUtil::kLongDecimalMax,
@@ -158,12 +393,12 @@ TEST_F(ComparisonsTest, testdecimal) {
            std::nullopt,
            5},
           DECIMAL(38, 5))};
-  auto expectedGteLte = makeNullableFlatVector<bool>(
-      {true, std::nullopt, true, true, std::nullopt, false});
-  runAndCompare(
-      fmt::format("{}(c1, c0)", "lessthanorequal"),
-      longDecimalsInputs,
-      expectedGteLte);
+  auto expectedLte = makeNullableFlatVector<bool>(
+      {false, std::nullopt, true, false, std::nullopt, true});
+  runAndCompare("lessthanorequal", longDecimalsInputs, expectedLte);
+  auto expectedEqNullSafe =
+      makeFlatVector<bool>({false, false, true, false, true, false});
+  runAndCompare("equalnullsafe", longDecimalsInputs, expectedEqNullSafe);
 
   // Test with different data types.
   std::vector<VectorPtr> invalidInputs = {
@@ -171,10 +406,9 @@ TEST_F(ComparisonsTest, testdecimal) {
       makeFlatVector(std::vector<int64_t>{1}, DECIMAL(10, 4))};
   auto invalidResult = makeConstant<bool>(true, 1);
   VELOX_ASSERT_THROW(
-      runAndCompare(
-          fmt::format("{}(c1, c0)", "equalto"), invalidInputs, invalidResult),
+      runAndCompare("equalto", invalidInputs, invalidResult),
       "Scalar function signature is not supported: "
-      "equalto(DECIMAL(10, 4), DECIMAL(10, 5))");
+      "equalto(DECIMAL(10, 5), DECIMAL(10, 4))");
 }
 
 TEST_F(ComparisonsTest, testdictionary) {
@@ -188,8 +422,8 @@ TEST_F(ComparisonsTest, testdictionary) {
     return BaseVector::wrapInConstant(base->size(), 0, base);
   };
   // Lhs: 0, null, 2, null, 4.
-  auto lhs = makeFlatVector<int16_t>(
-      5, [](auto row) { return row; }, nullEvery(2, 1));
+  auto lhs =
+      makeFlatVector<int16_t>(5, [](auto row) { return row; }, nullEvery(2, 1));
   auto rhs = makeFlatVector<int16_t>({1, 0, 3, 0, 5});
   auto lhsVector = makeDictionary(lhs);
   auto rhsVector = makeDictionary(rhs);
@@ -200,8 +434,7 @@ TEST_F(ComparisonsTest, testdictionary) {
   // Result : false, null, false, null, false.
   facebook::velox::test::assertEqualVectors(
       result,
-      makeFlatVector<bool>(
-          5, [](auto row) { return false; }, nullEvery(2, 1)));
+      makeFlatVector<bool>(5, [](auto row) { return false; }, nullEvery(2, 1)));
   auto constVector = makeConstant(100, 5);
   auto testConstVector =
       makeRowVector({makeDictionary(lhs), makeConstantDic(constVector)});
@@ -212,8 +445,7 @@ TEST_F(ComparisonsTest, testdictionary) {
       fmt::format("{}(c0, c1)", "lessthanorequal"), testConstVector);
   facebook::velox::test::assertEqualVectors(
       constResult,
-      makeFlatVector<bool>(
-          5, [](auto row) { return true; }, nullEvery(2, 1)));
+      makeFlatVector<bool>(5, [](auto row) { return true; }, nullEvery(2, 1)));
   // Lhs: const 100.
   // Rhs: 0, null, 2, null, 4.
   // Greaterthanorequal result : true, null, true, null, true.
@@ -223,8 +455,7 @@ TEST_F(ComparisonsTest, testdictionary) {
       fmt::format("{}(c0, c1)", "greaterthanorequal"), testConstVector1);
   facebook::velox::test::assertEqualVectors(
       constResult1,
-      makeFlatVector<bool>(
-          5, [](auto row) { return true; }, nullEvery(2, 1)));
+      makeFlatVector<bool>(5, [](auto row) { return true; }, nullEvery(2, 1)));
 }
 
 TEST_F(ComparisonsTest, testflat) {
@@ -232,8 +463,8 @@ TEST_F(ComparisonsTest, testflat) {
   auto vector1 = makeFlatVector<int32_t>(
       4, [](auto row) { return row + 1; }, nullEvery(2));
 
-  auto expectedResult = makeFlatVector<bool>(
-      4, [](auto row) { return true; }, nullEvery(2));
+  auto expectedResult =
+      makeFlatVector<bool>(4, [](auto row) { return true; }, nullEvery(2));
   auto actualResult = evaluate<SimpleVector<bool>>(
       "lessthan(c0, c1)", makeRowVector({vector0, vector1}));
   facebook::velox::test::assertEqualVectors(expectedResult, actualResult);
@@ -244,6 +475,32 @@ TEST_F(ComparisonsTest, testflat) {
   facebook::velox::test::assertEqualVectors(vectorBool0, actualBoolResult);
 }
 
+TEST_F(ComparisonsTest, testSIMDComparsion) {
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(64);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(65);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(1001);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(1001, 27);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(1001, 47);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(1001, 56);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(1001, 100);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(4096);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(4096, 30);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(4096, 31);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(4096, 32);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(4096, 33);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(4096, 78);
+
+  runSIMDCompareAndAssert<TypeKind::TINYINT>(675);
+  runSIMDCompareAndAssert<TypeKind::SMALLINT>(10240);
+  runSIMDCompareAndAssert<TypeKind::INTEGER>(7799);
+  runSIMDCompareAndAssert<TypeKind::BIGINT>(8876);
+  runSIMDCompareAndAssert<TypeKind::REAL>(1000);
+  runSIMDCompareAndAssert<TypeKind::DOUBLE>(10000);
+  runSIMDCompareAndAssert<TypeKind::TIMESTAMP>(1024);
+  runSIMDCompareAndAssert<TypeKind::VARCHAR>(686);
+  runSIMDCompareAndAssert<TypeKind::VARBINARY>(777);
+}
+
 TEST_F(ComparisonsTest, lessthan) {
   EXPECT_EQ(lessthan<int64_t>(1, 1), false);
   EXPECT_EQ(lessthan<int32_t>(1, 2), true);
@@ -332,5 +589,108 @@ TEST_F(ComparisonsTest, greaterthanorequal) {
   EXPECT_EQ(greaterthanorequal<float>(kInfF, -kInfF), true);
   EXPECT_EQ(greaterthanorequal<float>(kInf, kNaN), false);
 }
+
+TEST_F(ComparisonsTest, boolean) {
+  std::vector<VectorPtr> inputs = {
+      makeNullableFlatVector<bool>({true, false, false, true, std::nullopt}),
+      makeNullableFlatVector<bool>({false, true, false, true, std::nullopt})};
+
+  runAndCompare(
+      "equalnullsafe",
+      inputs,
+      makeFlatVector<bool>({false, false, true, true, true}));
+  runAndCompare(
+      "equalto",
+      inputs,
+      makeNullableFlatVector<bool>({false, false, true, true, std::nullopt}));
+  runAndCompare(
+      "lessthan",
+      inputs,
+      makeNullableFlatVector<bool>({false, true, false, false, std::nullopt}));
+  runAndCompare(
+      "lessthanorequal",
+      inputs,
+      makeNullableFlatVector<bool>({false, true, true, true, std::nullopt}));
+  runAndCompare(
+      "greaterthan",
+      inputs,
+      makeNullableFlatVector<bool>({true, false, false, false, std::nullopt}));
+  runAndCompare(
+      "greaterthanorequal",
+      inputs,
+      makeNullableFlatVector<bool>({true, false, true, true, std::nullopt}));
+}
+
+TEST_F(ComparisonsTest, dateTypes) {
+  std::vector<VectorPtr> dateInputs = {
+      makeNullableFlatVector<int32_t>({126, 128, std::nullopt}, DATE()),
+      makeNullableFlatVector<int32_t>({126, 127, std::nullopt}, DATE())};
+  std::vector<VectorPtr> intervalDayInputs = {
+      makeNullableFlatVector<int64_t>(
+          {126, 128, std::nullopt}, INTERVAL_DAY_TIME()),
+      makeNullableFlatVector<int64_t>(
+          {126, 127, std::nullopt}, INTERVAL_DAY_TIME())};
+  std::vector<VectorPtr> intervalYearInputs = {
+      makeNullableFlatVector<int32_t>(
+          {1, 2, std::nullopt}, INTERVAL_YEAR_MONTH()),
+      makeNullableFlatVector<int32_t>(
+          {1, 1, std::nullopt}, INTERVAL_YEAR_MONTH())};
+
+  auto test = [&](std::vector<VectorPtr>& inputs) {
+    runAndCompare(
+        "equalnullsafe", inputs, makeFlatVector<bool>({true, false, true}));
+    runAndCompare(
+        "equalto",
+        inputs,
+        makeNullableFlatVector<bool>({true, false, std::nullopt}));
+    runAndCompare(
+        "lessthan",
+        inputs,
+        makeNullableFlatVector<bool>({false, false, std::nullopt}));
+    runAndCompare(
+        "lessthanorequal",
+        inputs,
+        makeNullableFlatVector<bool>({true, false, std::nullopt}));
+    runAndCompare(
+        "greaterthan",
+        inputs,
+        makeNullableFlatVector<bool>({false, true, std::nullopt}));
+    runAndCompare(
+        "greaterthanorequal",
+        inputs,
+        makeNullableFlatVector<bool>({true, true, std::nullopt}));
+  };
+
+  test(dateInputs);
+
+  test(intervalDayInputs);
+
+  test(intervalYearInputs);
+}
+
+TEST_F(ComparisonsTest, notSupportedTypes) {
+  const auto candidataFuncs = {
+      "lessthan", "lessthanorequal", "greaterthan", "greaterthanorequal"};
+  auto arrayData = makeArrayVectorFromJson<int64_t>({"[1, 2, 3]"});
+  auto mapData = makeMapVectorFromJson<int64_t, int64_t>({"{1: 1}"});
+  auto rowData = makeRowVector({arrayData});
+  std::vector<VectorPtr> unsupportedTypeData = {arrayData, mapData, rowData};
+  auto testFails = [&](const std::string& func, const VectorPtr& vector) {
+    VELOX_ASSERT_USER_THROW(
+        evaluate<SimpleVector<bool>>(
+            fmt::format("{}(c1, c0)", func), makeRowVector({vector, vector})),
+        fmt::format(
+            "Scalar function signature is not supported: {}({}, {})",
+            func,
+            vector->type()->toString(),
+            vector->type()->toString()));
+  };
+
+  for (const auto& func : candidataFuncs) {
+    for (const auto& data : unsupportedTypeData) {
+      testFails(func, data);
+    }
+  }
+}
 } // namespace
-}; // namespace facebook::velox::functions::sparksql::test
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp b/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
index 67e49252c4cc9..482686ac84c34 100644
--- a/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
+++ b/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
@@ -16,12 +16,33 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+#include "velox/type/Timestamp.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::functions::sparksql::test {
 namespace {
 
+std::string timestampToString(Timestamp ts) {
+  TimestampToStringOptions options;
+  options.mode = TimestampToStringOptions::Mode::kFull;
+  std::string result;
+  result.resize(getMaxStringLength(options));
+  const auto view = Timestamp::tsToStringView(ts, options, result.data());
+  result.resize(view.size());
+  return result;
+}
+
 class DateTimeFunctionsTest : public SparkFunctionBaseTest {
+ public:
+  static constexpr int32_t kMin = std::numeric_limits<int32_t>::min();
+  static constexpr int32_t kMax = std::numeric_limits<int32_t>::max();
+  static constexpr int16_t kMinSmallint = std::numeric_limits<int16_t>::min();
+  static constexpr int16_t kMaxSmallint = std::numeric_limits<int16_t>::max();
+  static constexpr int8_t kMinTinyint = std::numeric_limits<int8_t>::min();
+  static constexpr int8_t kMaxTinyint = std::numeric_limits<int8_t>::max();
+  static constexpr int64_t kMinBigint = std::numeric_limits<int64_t>::min();
+  static constexpr int64_t kMaxBigint = std::numeric_limits<int64_t>::max();
+
  protected:
   void setQueryTimeZone(const std::string& timeZone) {
     queryCtx_->testingOverrideConfigUnsafe({
@@ -30,11 +51,107 @@ class DateTimeFunctionsTest : public SparkFunctionBaseTest {
     });
   }
 
-  int32_t parseDate(const std::string& dateStr) {
-    return DATE()->toDays(dateStr);
+  template <typename TOutput, typename TValue>
+  std::optional<TOutput> evaluateDateFuncOnce(
+      const std::string& expr,
+      const std::optional<int32_t>& date,
+      const std::optional<TValue>& value) {
+    return evaluateOnce<TOutput>(
+        expr,
+        makeRowVector(
+            {makeNullableFlatVector(
+                 std::vector<std::optional<int32_t>>{date}, DATE()),
+             makeNullableFlatVector(
+                 std::vector<std::optional<TValue>>{value})}));
   }
 };
 
+TEST_F(DateTimeFunctionsTest, toUtcTimestamp) {
+  const auto toUtcTimestamp = [&](const StringView& ts, const std::string& tz) {
+    auto timestamp = std::make_optional<Timestamp>(parseTimestamp(ts));
+    auto result = evaluateOnce<Timestamp>(
+        "to_utc_timestamp(c0, c1)",
+        timestamp,
+        std::make_optional<std::string>(tz));
+    return timestampToString(result.value());
+  };
+  EXPECT_EQ(
+      "2015-07-24T07:00:00.000000000",
+      toUtcTimestamp("2015-07-24 00:00:00", "America/Los_Angeles"));
+  EXPECT_EQ(
+      "2015-01-24T08:00:00.000000000",
+      toUtcTimestamp("2015-01-24 00:00:00", "America/Los_Angeles"));
+  EXPECT_EQ(
+      "2015-01-24T00:00:00.000000000",
+      toUtcTimestamp("2015-01-24 00:00:00", "UTC"));
+  EXPECT_EQ(
+      "2015-01-24T00:00:00.000000000",
+      toUtcTimestamp("2015-01-24 05:30:00", "Asia/Kolkata"));
+  EXPECT_EQ(
+      "2015-01-23T16:00:00.000000000",
+      toUtcTimestamp("2015-01-24 00:00:00", "+08:00"));
+  VELOX_ASSERT_THROW(
+      toUtcTimestamp("2015-01-24 00:00:00", "Asia/Ooty"),
+      "Unknown time zone: 'Asia/Ooty'");
+}
+
+TEST_F(DateTimeFunctionsTest, fromUtcTimestamp) {
+  const auto fromUtcTimestamp = [&](const StringView& ts,
+                                    const std::string& tz) {
+    auto timestamp = std::make_optional<Timestamp>(parseTimestamp(ts));
+    auto result = evaluateOnce<Timestamp>(
+        "from_utc_timestamp(c0, c1)",
+        timestamp,
+        std::make_optional<std::string>(tz));
+    return timestampToString(result.value());
+  };
+  EXPECT_EQ(
+      "2015-07-24T00:00:00.000000000",
+      fromUtcTimestamp("2015-07-24 07:00:00", "America/Los_Angeles"));
+  EXPECT_EQ(
+      "2015-01-24T00:00:00.000000000",
+      fromUtcTimestamp("2015-01-24 08:00:00", "America/Los_Angeles"));
+  EXPECT_EQ(
+      "2015-01-24T00:00:00.000000000",
+      fromUtcTimestamp("2015-01-24 00:00:00", "UTC"));
+  EXPECT_EQ(
+      "2015-01-24T05:30:00.000000000",
+      fromUtcTimestamp("2015-01-24 00:00:00", "Asia/Kolkata"));
+  EXPECT_EQ(
+      "2015-01-24T08:00:00.000000000",
+      fromUtcTimestamp("2015-01-24 00:00:00", "+08:00"));
+  VELOX_ASSERT_THROW(
+      fromUtcTimestamp("2015-01-24 00:00:00", "Asia/Ooty"),
+      "Unknown time zone: 'Asia/Ooty'");
+}
+
+TEST_F(DateTimeFunctionsTest, toFromUtcTimestamp) {
+  const auto toFromUtcTimestamp = [&](const StringView& ts,
+                                      const std::string& tz) {
+    auto timestamp = std::make_optional<Timestamp>(parseTimestamp(ts));
+    auto result = evaluateOnce<Timestamp>(
+        "to_utc_timestamp(from_utc_timestamp(c0, c1), c1)",
+        timestamp,
+        std::make_optional<std::string>(tz));
+    return timestampToString(result.value());
+  };
+  EXPECT_EQ(
+      "2015-07-24T07:00:00.000000000",
+      toFromUtcTimestamp("2015-07-24 07:00:00", "America/Los_Angeles"));
+  EXPECT_EQ(
+      "2015-01-24T08:00:00.000000000",
+      toFromUtcTimestamp("2015-01-24 08:00:00", "America/Los_Angeles"));
+  EXPECT_EQ(
+      "2015-01-24T00:00:00.000000000",
+      toFromUtcTimestamp("2015-01-24 00:00:00", "UTC"));
+  EXPECT_EQ(
+      "2015-01-24T00:00:00.000000000",
+      toFromUtcTimestamp("2015-01-24 00:00:00", "Asia/Kolkata"));
+  VELOX_ASSERT_THROW(
+      toFromUtcTimestamp("2015-01-24 00:00:00", "Asia/Ooty"),
+      "Unknown time zone: 'Asia/Ooty'");
+}
+
 TEST_F(DateTimeFunctionsTest, year) {
   const auto year = [&](std::optional<Timestamp> date) {
     return evaluateOnce<int32_t>("year(c0)", date);
@@ -60,20 +177,19 @@ TEST_F(DateTimeFunctionsTest, year) {
 
 TEST_F(DateTimeFunctionsTest, yearDate) {
   const auto year = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int32_t, int32_t>("year(c0)", {date}, {DATE()});
+    return evaluateOnce<int32_t>("year(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, year(std::nullopt));
-  EXPECT_EQ(1970, year(DATE()->toDays("1970-05-05")));
-  EXPECT_EQ(1969, year(DATE()->toDays("1969-12-31")));
-  EXPECT_EQ(2020, year(DATE()->toDays("2020-01-01")));
-  EXPECT_EQ(1920, year(DATE()->toDays("1920-01-01")));
+  EXPECT_EQ(1970, year(parseDate("1970-05-05")));
+  EXPECT_EQ(1969, year(parseDate("1969-12-31")));
+  EXPECT_EQ(2020, year(parseDate("2020-01-01")));
+  EXPECT_EQ(1920, year(parseDate("1920-01-01")));
 }
 
 TEST_F(DateTimeFunctionsTest, weekOfYear) {
   const auto weekOfYear = [&](const char* dateString) {
     auto date = std::make_optional(parseDate(dateString));
-    return evaluateOnce<int32_t, int32_t>("week_of_year(c0)", {date}, {DATE()})
-        .value();
+    return evaluateOnce<int32_t>("week_of_year(c0)", DATE(), date).value();
   };
 
   EXPECT_EQ(1, weekOfYear("1919-12-31"));
@@ -92,6 +208,24 @@ TEST_F(DateTimeFunctionsTest, weekOfYear) {
   EXPECT_EQ(15, weekOfYear("2013-04-08"));
 }
 
+TEST_F(DateTimeFunctionsTest, unixDate) {
+  const auto unixDate = [&](const std::string& date) {
+    return evaluateOnce<int32_t>(
+        "unix_date(c0)", DATE(), std::make_optional<int32_t>(parseDate(date)));
+  };
+
+  EXPECT_EQ(unixDate("1970-01-01"), 0);
+  EXPECT_EQ(unixDate("1970-01-02"), 1);
+  EXPECT_EQ(unixDate("1969-12-31"), -1);
+  EXPECT_EQ(unixDate("1970-02-01"), 31);
+  EXPECT_EQ(unixDate("1971-01-31"), 395);
+  EXPECT_EQ(unixDate("1971-01-01"), 365);
+  EXPECT_EQ(unixDate("1972-02-29"), 365 + 365 + 30 + 29);
+  EXPECT_EQ(unixDate("1971-03-01"), 365 + 30 + 28 + 1);
+  EXPECT_EQ(unixDate("5881580-07-11"), kMax);
+  EXPECT_EQ(unixDate("-5877641-06-23"), kMin);
+}
+
 TEST_F(DateTimeFunctionsTest, unixTimestamp) {
   const auto unixTimestamp = [&](std::optional<StringView> dateStr) {
     return evaluateOnce<int64_t>("unix_timestamp(c0)", dateStr);
@@ -175,10 +309,9 @@ TEST_F(DateTimeFunctionsTest, makeDate) {
                             std::optional<int32_t> day) {
     return evaluateOnce<int32_t>("make_date(c0, c1, c2)", year, month, day);
   };
-  EXPECT_EQ(makeDate(1920, 1, 25), DATE()->toDays("1920-01-25"));
-  EXPECT_EQ(makeDate(-10, 1, 30), DATE()->toDays("-0010-01-30"));
+  EXPECT_EQ(makeDate(1920, 1, 25), parseDate("1920-01-25"));
+  EXPECT_EQ(makeDate(-10, 1, 30), parseDate("-0010-01-30"));
 
-  constexpr int32_t kMax = std::numeric_limits<int32_t>::max();
   auto errorMessage = fmt::format("Date out of range: {}-12-15", kMax);
   VELOX_ASSERT_THROW(makeDate(kMax, 12, 15), errorMessage);
 
@@ -189,23 +322,23 @@ TEST_F(DateTimeFunctionsTest, makeDate) {
   VELOX_ASSERT_THROW(makeDate(2022, 3, 35), "Date out of range: 2022-3-35");
 
   VELOX_ASSERT_THROW(makeDate(2023, 4, 31), "Date out of range: 2023-4-31");
-  EXPECT_EQ(makeDate(2023, 3, 31), DATE()->toDays("2023-03-31"));
+  EXPECT_EQ(makeDate(2023, 3, 31), parseDate("2023-03-31"));
 
   VELOX_ASSERT_THROW(makeDate(2023, 2, 29), "Date out of range: 2023-2-29");
-  EXPECT_EQ(makeDate(2023, 3, 29), DATE()->toDays("2023-03-29"));
+  EXPECT_EQ(makeDate(2023, 3, 29), parseDate("2023-03-29"));
 }
 
 TEST_F(DateTimeFunctionsTest, lastDay) {
   const auto lastDayFunc = [&](const std::optional<int32_t> date) {
-    return evaluateOnce<int32_t, int32_t>("last_day(c0)", {date}, {DATE()});
+    return evaluateOnce<int32_t>("last_day(c0)", DATE(), date);
   };
 
   const auto lastDay = [&](const std::string& dateStr) {
-    return lastDayFunc(DATE()->toDays(dateStr));
+    return lastDayFunc(parseDate(dateStr));
   };
 
   const auto parseDateStr = [&](const std::string& dateStr) {
-    return DATE()->toDays(dateStr);
+    return parseDate(dateStr);
   };
 
   EXPECT_EQ(lastDay("2015-02-28"), parseDateStr("2015-02-28"));
@@ -224,51 +357,106 @@ TEST_F(DateTimeFunctionsTest, lastDay) {
   EXPECT_EQ(lastDayFunc(std::nullopt), std::nullopt);
 }
 
+TEST_F(DateTimeFunctionsTest, dateFromUnixDate) {
+  const auto dateFromUnixDate = [&](std::optional<int32_t> value) {
+    return evaluateOnce<int32_t>("date_from_unix_date(c0)", value);
+  };
+
+  // Basic tests
+  EXPECT_EQ(parseDate("1970-01-01"), dateFromUnixDate(0));
+  EXPECT_EQ(parseDate("1970-01-02"), dateFromUnixDate(1));
+  EXPECT_EQ(parseDate("1969-12-31"), dateFromUnixDate(-1));
+  EXPECT_EQ(parseDate("1970-02-01"), dateFromUnixDate(31));
+  EXPECT_EQ(parseDate("1971-01-31"), dateFromUnixDate(395));
+  EXPECT_EQ(parseDate("1971-01-01"), dateFromUnixDate(365));
+
+  // Leap year tests
+  EXPECT_EQ(parseDate("1972-02-29"), dateFromUnixDate(365 + 365 + 30 + 29));
+  EXPECT_EQ(parseDate("1971-03-01"), dateFromUnixDate(365 + 30 + 28 + 1));
+
+  // Min and max value tests
+  EXPECT_EQ(parseDate("5881580-07-11"), dateFromUnixDate(kMax));
+  EXPECT_EQ(parseDate("-5877641-06-23"), dateFromUnixDate(kMin));
+}
+
 TEST_F(DateTimeFunctionsTest, dateAdd) {
-  const auto dateAdd = [&](std::optional<int32_t> date,
+  const auto dateAdd = [&](const std::string& dateStr,
                            std::optional<int32_t> value) {
-    return evaluateOnce<int32_t, int32_t>(
-        "date_add(c0, c1)", {date, value}, {DATE(), INTEGER()});
+    return evaluateDateFuncOnce<int32_t, int32_t>(
+        "date_add(c0, c1)", parseDate(dateStr), value);
   };
 
-  // Check null behaviors
-  EXPECT_EQ(std::nullopt, dateAdd(std::nullopt, 1));
-  EXPECT_EQ(std::nullopt, dateAdd(parseDate("2019-02-28"), std::nullopt));
-  EXPECT_EQ(std::nullopt, dateAdd(std::nullopt, std::nullopt));
+  // Check simple tests.
+  EXPECT_EQ(parseDate("2019-03-01"), dateAdd("2019-03-01", 0));
+  EXPECT_EQ(parseDate("2019-03-01"), dateAdd("2019-02-28", 1));
+
+  // Account for the last day of a year-month
+  EXPECT_EQ(parseDate("2020-02-29"), dateAdd("2019-01-30", 395));
+  EXPECT_EQ(parseDate("2020-02-29"), dateAdd("2019-01-30", 395));
+
+  // Check for negative intervals
+  EXPECT_EQ(parseDate("2019-02-28"), dateAdd("2020-02-29", -366));
+  EXPECT_EQ(parseDate("2019-02-28"), dateAdd("2020-02-29", -366));
+
+  // Check for minimum and maximum tests.
+  EXPECT_EQ(parseDate("5881580-07-11"), dateAdd("1970-01-01", kMax));
+  EXPECT_EQ(parseDate("1969-12-31"), dateAdd("-5877641-06-23", kMax));
+  EXPECT_EQ(parseDate("-5877641-06-23"), dateAdd("1970-01-01", kMin));
+  EXPECT_EQ(parseDate("1969-12-31"), dateAdd("5881580-07-11", kMin));
+  EXPECT_EQ(parseDate("5881580-07-10"), dateAdd("1969-12-31", kMax));
+
+  EXPECT_EQ(parseDate("-5877587-07-11"), dateAdd("2024-01-22", kMax - 1));
+  EXPECT_EQ(parseDate("-5877587-07-12"), dateAdd("2024-01-22", kMax));
+}
+
+TEST_F(DateTimeFunctionsTest, dateAddSmallint) {
+  const auto dateAdd = [&](const std::string& dateStr,
+                           std::optional<int16_t> value) {
+    return evaluateDateFuncOnce<int32_t, int16_t>(
+        "date_add(c0, c1)", parseDate(dateStr), value);
+  };
 
   // Check simple tests.
-  EXPECT_EQ(parseDate("2019-03-01"), dateAdd(parseDate("2019-03-01"), 0));
-  EXPECT_EQ(parseDate("2019-03-01"), dateAdd(parseDate("2019-02-28"), 1));
+  EXPECT_EQ(parseDate("2019-03-01"), dateAdd("2019-03-01", 0));
+  EXPECT_EQ(parseDate("2019-03-01"), dateAdd("2019-02-28", 1));
 
   // Account for the last day of a year-month
-  EXPECT_EQ(parseDate("2020-02-29"), dateAdd(parseDate("2019-01-30"), 395));
-  EXPECT_EQ(parseDate("2020-02-29"), dateAdd(parseDate("2019-01-30"), 395));
+  EXPECT_EQ(parseDate("2020-02-29"), dateAdd("2019-01-30", 395));
+  EXPECT_EQ(parseDate("2020-02-29"), dateAdd("2019-01-30", 395));
 
   // Check for negative intervals
-  EXPECT_EQ(parseDate("2019-02-28"), dateAdd(parseDate("2020-02-29"), -366));
-  EXPECT_EQ(parseDate("2019-02-28"), dateAdd(parseDate("2020-02-29"), -366));
+  EXPECT_EQ(parseDate("2019-02-28"), dateAdd("2020-02-29", -366));
+  EXPECT_EQ(parseDate("2019-02-28"), dateAdd("2020-02-29", -366));
 
   // Check for minimum and maximum tests.
-  constexpr int32_t kMin = std::numeric_limits<int32_t>::min();
-  constexpr int32_t kMax = std::numeric_limits<int32_t>::max();
-  EXPECT_EQ(parseDate("5881580-07-11"), dateAdd(parseDate("1970-01-01"), kMax));
-  EXPECT_EQ(
-      parseDate("1969-12-31"), dateAdd(parseDate("-5877641-06-23"), kMax));
-  EXPECT_EQ(
-      parseDate("-5877641-06-23"), dateAdd(parseDate("1970-01-01"), kMin));
-  EXPECT_EQ(parseDate("1969-12-31"), dateAdd(parseDate("5881580-07-11"), kMin));
+  EXPECT_EQ(parseDate("2059-09-17"), dateAdd("1969-12-31", kMaxSmallint));
+  EXPECT_EQ(parseDate("1880-04-13"), dateAdd("1969-12-31", kMinSmallint));
+
+  EXPECT_EQ(parseDate("2113-10-09"), dateAdd("2024-01-22", kMaxSmallint));
 }
 
-TEST_F(DateTimeFunctionsTest, dateSub) {
-  const auto dateSubFunc = [&](std::optional<int32_t> date,
-                               std::optional<int32_t> value) {
-    return evaluateOnce<int32_t, int32_t>(
-        "date_sub(c0, c1)", {date, value}, {DATE(), INTEGER()});
+TEST_F(DateTimeFunctionsTest, dateAddTinyint) {
+  const auto dateAdd = [&](const std::string& dateStr,
+                           std::optional<int8_t> value) {
+    return evaluateDateFuncOnce<int32_t, int8_t>(
+        "date_add(c0, c1)", parseDate(dateStr), value);
   };
+  // Check simple tests.
+  EXPECT_EQ(parseDate("2019-03-01"), dateAdd("2019-03-01", 0));
+  EXPECT_EQ(parseDate("2019-03-01"), dateAdd("2019-02-28", 1));
 
+  EXPECT_EQ(parseDate("1970-05-07"), dateAdd("1969-12-31", kMaxTinyint));
+
+  EXPECT_EQ(parseDate("1969-08-25"), dateAdd("1969-12-31", kMinTinyint));
+
+  EXPECT_EQ(parseDate("2024-05-28"), dateAdd("2024-01-22", kMaxTinyint));
+}
+
+TEST_F(DateTimeFunctionsTest, dateSub) {
   const auto dateSub = [&](const std::string& dateStr,
                            std::optional<int32_t> value) {
-    return dateSubFunc(parseDate(dateStr), value);
+    return evaluateDateFuncOnce<int32_t, int32_t>(
+        "date_sub(c0, c1)", parseDate(dateStr), value);
   };
 
   // Check simple tests.
@@ -282,17 +470,58 @@ TEST_F(DateTimeFunctionsTest, dateSub) {
   EXPECT_EQ(parseDate("2020-02-29"), dateSub("2019-02-28", -366));
 
   // Check for minimum and maximum tests.
-  constexpr int32_t kMin = std::numeric_limits<int32_t>::min();
-  constexpr int32_t kMax = std::numeric_limits<int32_t>::max();
   EXPECT_EQ(parseDate("-5877641-06-23"), dateSub("1969-12-31", kMax));
   EXPECT_EQ(parseDate("1970-01-01"), dateSub("5881580-07-11", kMax));
   EXPECT_EQ(parseDate("1970-01-01"), dateSub("-5877641-06-23", kMin));
   EXPECT_EQ(parseDate("5881580-07-11"), dateSub("1969-12-31", kMin));
+
+  EXPECT_EQ(parseDate("-5877588-12-28"), dateSub("2023-07-10", kMin + 1));
+  EXPECT_EQ(parseDate("-5877588-12-29"), dateSub("2023-07-10", kMin));
+}
+
+TEST_F(DateTimeFunctionsTest, dateSubSmallint) {
+  const auto dateSub = [&](const std::string& dateStr,
+                           std::optional<int16_t> value) {
+    return evaluateDateFuncOnce<int32_t, int16_t>(
+        "date_sub(c0, c1)", parseDate(dateStr), value);
+  };
+
+  // Check simple tests.
+  EXPECT_EQ(parseDate("2019-03-01"), dateSub("2019-03-01", 0));
+  EXPECT_EQ(parseDate("2019-02-28"), dateSub("2019-03-01", 1));
+
+  // Account for the last day of a year-month.
+  EXPECT_EQ(parseDate("2019-01-30"), dateSub("2020-02-29", 395));
+
+  // Check for negative intervals.
+  EXPECT_EQ(parseDate("2020-02-29"), dateSub("2019-02-28", -366));
+
+  EXPECT_EQ(parseDate("1880-04-15"), dateSub("1970-01-01", kMaxSmallint));
+  EXPECT_EQ(parseDate("2059-09-19"), dateSub("1970-01-01", kMinSmallint));
+
+  EXPECT_EQ(parseDate("2113-03-28"), dateSub("2023-07-10", kMinSmallint));
+}
+
+TEST_F(DateTimeFunctionsTest, dateSubTinyint) {
+  const auto dateSub = [&](const std::string& dateStr,
+                           std::optional<int8_t> value) {
+    return evaluateDateFuncOnce<int32_t, int8_t>(
+        "date_sub(c0, c1)", parseDate(dateStr), value);
+  };
+
+  // Check simple tests.
+  EXPECT_EQ(parseDate("2019-03-01"), dateSub("2019-03-01", 0));
+  EXPECT_EQ(parseDate("2019-02-28"), dateSub("2019-03-01", 1));
+
+  EXPECT_EQ(parseDate("1969-08-27"), dateSub("1970-01-01", kMaxTinyint));
+  EXPECT_EQ(parseDate("1970-05-09"), dateSub("1970-01-01", kMinTinyint));
+
+  EXPECT_EQ(parseDate("2023-11-15"), dateSub("2023-07-10", kMinTinyint));
 }
 
 TEST_F(DateTimeFunctionsTest, dayOfYear) {
   const auto day = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("dayofyear(c0)", {date}, {DATE()});
+    return evaluateOnce<int32_t>("dayofyear(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, day(std::nullopt));
   EXPECT_EQ(100, day(parseDate("2016-04-09")));
@@ -302,7 +531,7 @@ TEST_F(DateTimeFunctionsTest, dayOfYear) {
 
 TEST_F(DateTimeFunctionsTest, dayOfMonth) {
   const auto day = [&](std::optional<int32_t> date) {
-    return evaluateOnce<int64_t, int32_t>("dayofmonth(c0)", {date}, {DATE()});
+    return evaluateOnce<int32_t>("dayofmonth(c0)", DATE(), date);
   };
   EXPECT_EQ(std::nullopt, day(std::nullopt));
   EXPECT_EQ(30, day(parseDate("2009-07-30")));
@@ -310,80 +539,58 @@ TEST_F(DateTimeFunctionsTest, dayOfMonth) {
 }
 
 TEST_F(DateTimeFunctionsTest, dayOfWeekDate) {
-  const auto dayOfWeek = [&](std::optional<int32_t> date,
-                             const std::string& func) {
-    return evaluateOnce<int32_t, int32_t>(
-        fmt::format("{}(c0)", func), {date}, {DATE()});
-  };
-
-  for (const auto& func : {"dayofweek", "dow"}) {
-    EXPECT_EQ(std::nullopt, dayOfWeek(std::nullopt, func));
-    EXPECT_EQ(5, dayOfWeek(0, func));
-    EXPECT_EQ(4, dayOfWeek(-1, func));
-    EXPECT_EQ(7, dayOfWeek(-40, func));
-    EXPECT_EQ(5, dayOfWeek(parseDate("2009-07-30"), func));
-    EXPECT_EQ(1, dayOfWeek(parseDate("2023-08-20"), func));
-    EXPECT_EQ(2, dayOfWeek(parseDate("2023-08-21"), func));
-    EXPECT_EQ(3, dayOfWeek(parseDate("2023-08-22"), func));
-    EXPECT_EQ(4, dayOfWeek(parseDate("2023-08-23"), func));
-    EXPECT_EQ(5, dayOfWeek(parseDate("2023-08-24"), func));
-    EXPECT_EQ(6, dayOfWeek(parseDate("2023-08-25"), func));
-    EXPECT_EQ(7, dayOfWeek(parseDate("2023-08-26"), func));
-    EXPECT_EQ(1, dayOfWeek(parseDate("2023-08-27"), func));
-
-    // test cases from spark's DateExpressionSuite.
-    EXPECT_EQ(6, dayOfWeek(util::fromDateString("2011-05-06"), func));
-  }
+  const auto dayOfWeek = [&](std::optional<int32_t> date) {
+    return evaluateOnce<int32_t>("dayofweek(c0)", DATE(), date);
+  };
+
+  EXPECT_EQ(std::nullopt, dayOfWeek(std::nullopt));
+  EXPECT_EQ(5, dayOfWeek(0));
+  EXPECT_EQ(4, dayOfWeek(-1));
+  EXPECT_EQ(7, dayOfWeek(-40));
+  EXPECT_EQ(5, dayOfWeek(parseDate("2009-07-30")));
+  EXPECT_EQ(1, dayOfWeek(parseDate("2023-08-20")));
+  EXPECT_EQ(2, dayOfWeek(parseDate("2023-08-21")));
+  EXPECT_EQ(3, dayOfWeek(parseDate("2023-08-22")));
+  EXPECT_EQ(4, dayOfWeek(parseDate("2023-08-23")));
+  EXPECT_EQ(5, dayOfWeek(parseDate("2023-08-24")));
+  EXPECT_EQ(6, dayOfWeek(parseDate("2023-08-25")));
+  EXPECT_EQ(7, dayOfWeek(parseDate("2023-08-26")));
+  EXPECT_EQ(1, dayOfWeek(parseDate("2023-08-27")));
+  EXPECT_EQ(6, dayOfWeek(parseDate("2011-05-06")));
+  EXPECT_EQ(4, dayOfWeek(parseDate("2015-04-08")));
+  EXPECT_EQ(7, dayOfWeek(parseDate("2017-05-27")));
+  EXPECT_EQ(6, dayOfWeek(parseDate("1582-10-15")));
 }
 
-TEST_F(DateTimeFunctionsTest, dayofWeekTs) {
-  const auto dayOfWeek = [&](std::optional<Timestamp> date,
-                             const std::string& func) {
-    return evaluateOnce<int32_t>(fmt::format("{}(c0)", func), date);
-  };
-
-  for (const auto& func : {"dayofweek", "dow"}) {
-    EXPECT_EQ(5, dayOfWeek(Timestamp(0, 0), func));
-    EXPECT_EQ(4, dayOfWeek(Timestamp(-1, 0), func));
-    EXPECT_EQ(
-        1,
-        dayOfWeek(util::fromTimestampString("2023-08-20 20:23:00.001"), func));
-    EXPECT_EQ(
-        2,
-        dayOfWeek(util::fromTimestampString("2023-08-21 21:23:00.030"), func));
-    EXPECT_EQ(
-        3,
-        dayOfWeek(util::fromTimestampString("2023-08-22 11:23:00.100"), func));
-    EXPECT_EQ(
-        4,
-        dayOfWeek(util::fromTimestampString("2023-08-23 22:23:00.030"), func));
-    EXPECT_EQ(
-        5,
-        dayOfWeek(util::fromTimestampString("2023-08-24 15:23:00.000"), func));
-    EXPECT_EQ(
-        6,
-        dayOfWeek(util::fromTimestampString("2023-08-25 03:23:04.000"), func));
-    EXPECT_EQ(
-        7,
-        dayOfWeek(util::fromTimestampString("2023-08-26 01:03:00.300"), func));
-    EXPECT_EQ(
-        1,
-        dayOfWeek(util::fromTimestampString("2023-08-27 01:13:00.000"), func));
-    // test cases from spark's DateExpressionSuite.
-    EXPECT_EQ(
-        4, dayOfWeek(util::fromTimestampString("2015-04-08 13:10:15"), func));
-    EXPECT_EQ(
-        7, dayOfWeek(util::fromTimestampString("2017-05-27 13:10:15"), func));
-    EXPECT_EQ(
-        6, dayOfWeek(util::fromTimestampString("1582-10-15 13:10:15"), func));
-  }
+TEST_F(DateTimeFunctionsTest, weekdayDate) {
+  const auto weekday = [&](std::optional<int32_t> value) {
+    return evaluateOnce<int32_t>("weekday(c0)", DATE(), value);
+  };
+
+  EXPECT_EQ(3, weekday(0));
+  EXPECT_EQ(2, weekday(-1));
+  EXPECT_EQ(5, weekday(-40));
+  EXPECT_EQ(3, weekday(parseDate("2009-07-30")));
+  EXPECT_EQ(6, weekday(parseDate("2023-08-20")));
+  EXPECT_EQ(0, weekday(parseDate("2023-08-21")));
+  EXPECT_EQ(1, weekday(parseDate("2023-08-22")));
+  EXPECT_EQ(2, weekday(parseDate("2023-08-23")));
+  EXPECT_EQ(3, weekday(parseDate("2023-08-24")));
+  EXPECT_EQ(4, weekday(parseDate("2023-08-25")));
+  EXPECT_EQ(5, weekday(parseDate("2023-08-26")));
+  EXPECT_EQ(6, weekday(parseDate("2023-08-27")));
+  EXPECT_EQ(5, weekday(parseDate("2017-05-27")));
+  EXPECT_EQ(2, weekday(parseDate("2015-04-08")));
+  EXPECT_EQ(4, weekday(parseDate("2013-11-08")));
+  EXPECT_EQ(4, weekday(parseDate("2011-05-06")));
+  EXPECT_EQ(4, weekday(parseDate("1582-10-15")));
 }
 
 TEST_F(DateTimeFunctionsTest, dateDiffDate) {
   const auto dateDiff = [&](std::optional<int32_t> endDate,
                             std::optional<int32_t> startDate) {
-    return evaluateOnce<int32_t, int32_t>(
-        "datediff(c0, c1)", {endDate, startDate}, {DATE(), DATE()});
+    return evaluateOnce<int32_t>(
+        "datediff(c0, c1)", {DATE(), DATE()}, endDate, startDate);
   };
 
   // Simple tests.
@@ -404,5 +611,478 @@ TEST_F(DateTimeFunctionsTest, dateDiffDate) {
       dateDiff(parseDate("-5877641-06-23"), parseDate("1994-09-12")));
 }
 
+TEST_F(DateTimeFunctionsTest, addMonths) {
+  const auto addMonths = [&](const std::string& dateString,
+                             std::optional<int32_t> value) {
+    return evaluateOnce<int32_t>(
+        "add_months(c0, c1)",
+        {DATE(), INTEGER()},
+        std::make_optional(parseDate(dateString)),
+        value);
+  };
+
+  EXPECT_EQ(addMonths("2015-01-30", 1), parseDate("2015-02-28"));
+  EXPECT_EQ(addMonths("2015-01-30", 11), parseDate("2015-12-30"));
+  EXPECT_EQ(addMonths("2015-01-01", 10), parseDate("2015-11-01"));
+  EXPECT_EQ(addMonths("2015-01-31", 24), parseDate("2017-01-31"));
+  EXPECT_EQ(addMonths("2015-01-31", 8), parseDate("2015-09-30"));
+  EXPECT_EQ(addMonths("2015-01-30", 0), parseDate("2015-01-30"));
+  // The last day of Feb. 2016 is 29th.
+  EXPECT_EQ(addMonths("2016-03-30", -1), parseDate("2016-02-29"));
+  // The last day of Feb. 2015 is 28th.
+  EXPECT_EQ(addMonths("2015-03-31", -1), parseDate("2015-02-28"));
+  EXPECT_EQ(addMonths("2015-01-30", -2), parseDate("2014-11-30"));
+  EXPECT_EQ(addMonths("2015-04-20", -24), parseDate("2013-04-20"));
+
+  VELOX_ASSERT_THROW(
+      addMonths("2023-07-10", kMin),
+      fmt::format("Integer overflow in add_months(2023-07-10, {})", kMin));
+  VELOX_ASSERT_THROW(
+      addMonths("2023-07-10", kMax),
+      fmt::format("Integer overflow in add_months(2023-07-10, {})", kMax));
+}
+
+TEST_F(DateTimeFunctionsTest, monthDate) {
+  const auto month = [&](const std::string& dateString) {
+    return evaluateOnce<int32_t>(
+        "month(c0)", DATE(), std::make_optional(parseDate(dateString)));
+  };
+
+  EXPECT_EQ(4, month("2015-04-08"));
+  EXPECT_EQ(11, month("2013-11-08"));
+  EXPECT_EQ(1, month("1987-01-08"));
+  EXPECT_EQ(8, month("1954-08-08"));
+}
+
+TEST_F(DateTimeFunctionsTest, quarterDate) {
+  const auto quarter = [&](const std::string& dateString) {
+    return evaluateOnce<int32_t>(
+        "quarter(c0)", DATE(), std::make_optional(parseDate(dateString)));
+  };
+
+  EXPECT_EQ(2, quarter("2015-04-08"));
+  EXPECT_EQ(4, quarter("2013-11-08"));
+  EXPECT_EQ(1, quarter("1987-01-08"));
+  EXPECT_EQ(3, quarter("1954-08-08"));
+}
+
+TEST_F(DateTimeFunctionsTest, nextDay) {
+  const auto nextDay = [&](const std::string& date,
+                           const std::string& dayOfWeek) {
+    auto startDates =
+        makeNullableFlatVector<int32_t>({parseDate(date)}, DATE());
+    auto dayOfWeeks = makeNullableFlatVector<std::string>({dayOfWeek});
+
+    auto result = evaluateOnce<int32_t>(
+        fmt::format("next_day(c0, '{}')", dayOfWeek),
+        makeRowVector({startDates}));
+
+    auto anotherResult = evaluateOnce<int32_t>(
+        "next_day(c0, c1)", makeRowVector({startDates, dayOfWeeks}));
+
+    EXPECT_EQ(result, anotherResult);
+    std::optional<std::string> res;
+    if (result.has_value()) {
+      res = DATE()->toString(result.value());
+    }
+    return res;
+  };
+
+  EXPECT_EQ(nextDay("2015-07-23", "Mon"), "2015-07-27");
+  EXPECT_EQ(nextDay("2015-07-23", "mo"), "2015-07-27");
+  EXPECT_EQ(nextDay("2015-07-23", "monday"), "2015-07-27");
+  EXPECT_EQ(nextDay("2015-07-23", "Tue"), "2015-07-28");
+  EXPECT_EQ(nextDay("2015-07-23", "tu"), "2015-07-28");
+  EXPECT_EQ(nextDay("2015-07-23", "tuesday"), "2015-07-28");
+  EXPECT_EQ(nextDay("2015-07-23", "we"), "2015-07-29");
+  EXPECT_EQ(nextDay("2015-07-23", "wed"), "2015-07-29");
+  EXPECT_EQ(nextDay("2015-07-23", "wednesday"), "2015-07-29");
+  EXPECT_EQ(nextDay("2015-07-23", "Thu"), "2015-07-30");
+  EXPECT_EQ(nextDay("2015-07-23", "TH"), "2015-07-30");
+  EXPECT_EQ(nextDay("2015-07-23", "thursday"), "2015-07-30");
+  EXPECT_EQ(nextDay("2015-07-23", "Fri"), "2015-07-24");
+  EXPECT_EQ(nextDay("2015-07-23", "fr"), "2015-07-24");
+  EXPECT_EQ(nextDay("2015-07-23", "friday"), "2015-07-24");
+  EXPECT_EQ(nextDay("2015-07-31", "wed"), "2015-08-05");
+  EXPECT_EQ(nextDay("2015-07-23", "saturday"), "2015-07-25");
+  EXPECT_EQ(nextDay("2015-07-23", "sunday"), "2015-07-26");
+  EXPECT_EQ(nextDay("2015-12-31", "Fri"), "2016-01-01");
+
+  EXPECT_EQ(nextDay("2015-07-23", "xx"), std::nullopt);
+  EXPECT_EQ(nextDay("2015-07-23", "\"quote"), std::nullopt);
+  EXPECT_EQ(nextDay("2015-07-23", ""), std::nullopt);
+}
+
+TEST_F(DateTimeFunctionsTest, getTimestamp) {
+  const auto getTimestamp = [&](const std::optional<StringView>& dateString,
+                                const std::string& format) {
+    return evaluateOnce<Timestamp>(
+        fmt::format("get_timestamp(c0, '{}')", format), dateString);
+  };
+
+  const auto getTimestampString =
+      [&](const std::optional<StringView>& dateString,
+          const std::string& format) {
+        return getTimestamp(dateString, format).value().toString();
+      };
+
+  EXPECT_EQ(getTimestamp("1970-01-01", "yyyy-MM-dd"), Timestamp(0, 0));
+  EXPECT_EQ(
+      getTimestamp("1970-01-01 00:00:00.010", "yyyy-MM-dd HH:mm:ss.SSS"),
+      Timestamp::fromMillis(10));
+  auto milliSeconds = (6 * 60 * 60 + 10 * 60 + 59) * 1000 + 19;
+  EXPECT_EQ(
+      getTimestamp("1970-01-01 06:10:59.019", "yyyy-MM-dd HH:mm:ss.SSS"),
+      Timestamp::fromMillis(milliSeconds));
+
+  EXPECT_EQ(
+      getTimestampString("1970-01-01", "yyyy-MM-dd"),
+      "1970-01-01T00:00:00.000000000");
+  EXPECT_EQ(
+      getTimestampString("1970/01/01", "yyyy/MM/dd"),
+      "1970-01-01T00:00:00.000000000");
+  EXPECT_EQ(
+      getTimestampString("08/27/2017", "MM/dd/yyy"),
+      "2017-08-27T00:00:00.000000000");
+  EXPECT_EQ(
+      getTimestampString("1970/01/01 12:08:59", "yyyy/MM/dd HH:mm:ss"),
+      "1970-01-01T12:08:59.000000000");
+  EXPECT_EQ(
+      getTimestampString("2023/12/08 08:20:19", "yyyy/MM/dd HH:mm:ss"),
+      "2023-12-08T08:20:19.000000000");
+
+  // 8 hours ahead UTC.
+  setQueryTimeZone("Asia/Shanghai");
+  EXPECT_EQ(
+      getTimestampString("1970-01-01", "yyyy-MM-dd"),
+      "1969-12-31T16:00:00.000000000");
+  EXPECT_EQ(
+      getTimestampString("1970/01/01", "yyyy/MM/dd"),
+      "1969-12-31T16:00:00.000000000");
+  EXPECT_EQ(
+      getTimestampString("2023/12/08 08:20:19", "yyyy/MM/dd HH:mm:ss"),
+      "2023-12-08T00:20:19.000000000");
+
+  // 8 hours behind UTC.
+  setQueryTimeZone("America/Los_Angeles");
+  EXPECT_EQ(
+      getTimestampString("1970/01/01", "yyyy/MM/dd"),
+      "1970-01-01T08:00:00.000000000");
+  EXPECT_EQ(
+      getTimestampString("2023/12/08 08:20:19", "yyyy/MM/dd HH:mm:ss"),
+      "2023-12-08T16:20:19.000000000");
+
+  // Parsing error.
+  EXPECT_EQ(
+      getTimestamp("1970-01-01 06:10:59.019", "HH:mm:ss.SSS"), std::nullopt);
+  EXPECT_EQ(
+      getTimestamp("1970-01-01 06:10:59.019", "yyyy/MM/dd HH:mm:ss.SSS"),
+      std::nullopt);
+
+  // Invalid date format.
+  VELOX_ASSERT_THROW(
+      getTimestamp("2020/01/24", "AA/MM/dd"), "Specifier A is not supported");
+  VELOX_ASSERT_THROW(
+      getTimestamp("2023-07-13 21:34", "yyyy-MM-dd HH:II"),
+      "Specifier I is not supported");
+}
+
+TEST_F(DateTimeFunctionsTest, hour) {
+  const auto hour = [&](const StringView timestampStr) {
+    const auto timeStamp = std::make_optional(parseTimestamp(timestampStr));
+    return evaluateOnce<int32_t>("hour(c0)", timeStamp);
+  };
+
+  EXPECT_EQ(0, hour("2024-01-08 00:23:00.001"));
+  EXPECT_EQ(0, hour("2024-01-08 00:59:59.999"));
+  EXPECT_EQ(1, hour("2024-01-08 01:23:00.001"));
+  EXPECT_EQ(13, hour("2024-01-20 13:23:00.001"));
+  EXPECT_EQ(13, hour("1969-01-01 13:23:00.001"));
+
+  // Set time zone to Pacific/Apia (13 hours ahead of UTC).
+  setQueryTimeZone("Pacific/Apia");
+
+  EXPECT_EQ(13, hour("2024-01-08 00:23:00.001"));
+  EXPECT_EQ(13, hour("2024-01-08 00:59:59.999"));
+  EXPECT_EQ(14, hour("2024-01-08 01:23:00.001"));
+  EXPECT_EQ(2, hour("2024-01-20 13:23:00.001"));
+  EXPECT_EQ(2, hour("1969-01-01 13:23:00.001"));
+}
+
+TEST_F(DateTimeFunctionsTest, minute) {
+  const auto minute = [&](const StringView& timestampStr) {
+    const auto timeStamp = std::make_optional(parseTimestamp(timestampStr));
+    return evaluateOnce<int32_t>("minute(c0)", timeStamp);
+  };
+
+  EXPECT_EQ(23, minute("2024-01-08 00:23:00.001"));
+  EXPECT_EQ(59, minute("2024-01-08 00:59:59.999"));
+  EXPECT_EQ(10, minute("2015-04-08 13:10:15"));
+  EXPECT_EQ(43, minute("1969-01-01 13:43:00.001"));
+
+  // Set time zone to Pacific/Apia (13 hours ahead of UTC).
+  setQueryTimeZone("Pacific/Apia");
+
+  EXPECT_EQ(23, minute("2024-01-08 00:23:00.001"));
+  EXPECT_EQ(59, minute("2024-01-08 00:59:59.999"));
+  EXPECT_EQ(10, minute("2015-04-08 13:10:15"));
+  EXPECT_EQ(43, minute("1969-01-01 13:43:00.001"));
+
+  // Set time zone to Asia/Kolkata (5.5 hours ahead of UTC).
+  setQueryTimeZone("Asia/Kolkata");
+
+  EXPECT_EQ(53, minute("2024-01-08 00:23:00.001"));
+  EXPECT_EQ(29, minute("2024-01-08 00:59:59.999"));
+  EXPECT_EQ(40, minute("2015-04-08 13:10:15"));
+  EXPECT_EQ(13, minute("1969-01-01 13:43:00.001"));
+}
+
+TEST_F(DateTimeFunctionsTest, second) {
+  const auto second = [&](const StringView& timestampStr) {
+    const auto timeStamp = std::make_optional(parseTimestamp(timestampStr));
+    return evaluateOnce<int32_t>("second(c0)", timeStamp);
+  };
+
+  EXPECT_EQ(0, second("2024-01-08 00:23:00.001"));
+  EXPECT_EQ(59, second("2024-01-08 00:59:59.999"));
+  EXPECT_EQ(15, second("2015-04-08 13:10:15"));
+  EXPECT_EQ(0, second("1969-01-01 13:43:00.001"));
+}
+
+TEST_F(DateTimeFunctionsTest, fromUnixtime) {
+  const auto getUnixTime = [&](const StringView& str) {
+    Timestamp t = parseTimestamp(str);
+    return t.getSeconds();
+  };
+
+  const auto fromUnixTime = [&](const std::optional<int64_t>& unixTime,
+                                const std::optional<std::string>& timeFormat) {
+    return evaluateOnce<std::string>(
+        "from_unixtime(c0, c1)", unixTime, timeFormat);
+  };
+
+  EXPECT_EQ(fromUnixTime(0, "yyyy-MM-dd HH:mm:ss"), "1970-01-01 00:00:00");
+  EXPECT_EQ(fromUnixTime(100, "yyyy-MM-dd"), "1970-01-01");
+  EXPECT_EQ(fromUnixTime(120, "yyyy-MM-dd HH:mm"), "1970-01-01 00:02");
+  EXPECT_EQ(fromUnixTime(100, "yyyy-MM-dd HH:mm:ss"), "1970-01-01 00:01:40");
+  EXPECT_EQ(fromUnixTime(-59, "yyyy-MM-dd HH:mm:ss"), "1969-12-31 23:59:01");
+  EXPECT_EQ(fromUnixTime(3600, "yyyy"), "1970");
+  EXPECT_EQ(
+      fromUnixTime(getUnixTime("2020-06-30 11:29:59"), "yyyy-MM-dd HH:mm:ss"),
+      "2020-06-30 11:29:59");
+  EXPECT_EQ(
+      fromUnixTime(getUnixTime("2020-06-30 11:29:59"), "yyyy-MM-dd"),
+      "2020-06-30");
+  EXPECT_EQ(fromUnixTime(getUnixTime("2020-06-30 11:29:59"), "MM-dd"), "06-30");
+  EXPECT_EQ(
+      fromUnixTime(getUnixTime("2020-06-30 11:29:59"), "HH:mm:ss"), "11:29:59");
+  EXPECT_EQ(
+      fromUnixTime(getUnixTime("2020-06-30 23:59:59"), "yyyy-MM-dd HH:mm:ss"),
+      "2020-06-30 23:59:59");
+
+// In debug mode, Timestamp constructor will throw exception if range check
+// fails.
+#ifndef NDEBUG
+  VELOX_ASSERT_THROW(
+      fromUnixTime(std::numeric_limits<int64_t>::max(), "yyyy-MM-dd HH:mm:ss"),
+      "Timestamp seconds out of range");
+#endif
+
+  // 8 hours ahead UTC.
+  setQueryTimeZone("Asia/Shanghai");
+
+  EXPECT_EQ(fromUnixTime(0, "yyyy-MM-dd HH:mm:ss"), "1970-01-01 08:00:00");
+  EXPECT_EQ(fromUnixTime(120, "yyyy-MM-dd HH:mm"), "1970-01-01 08:02");
+  EXPECT_EQ(fromUnixTime(-59, "yyyy-MM-dd HH:mm:ss"), "1970-01-01 07:59:01");
+  EXPECT_EQ(
+      fromUnixTime(getUnixTime("2014-07-21 16:00:00"), "yyyy-MM-dd"),
+      "2014-07-22");
+  EXPECT_EQ(
+      fromUnixTime(getUnixTime("2020-06-30 23:59:59"), "yyyy-MM-dd HH:mm:ss"),
+      "2020-07-01 07:59:59");
+
+  // Invalid format.
+  VELOX_ASSERT_THROW(
+      fromUnixTime(0, "yyyy-AA"), "Specifier A is not supported.");
+  VELOX_ASSERT_THROW(
+      fromUnixTime(0, "FF/MM/dd"), "Specifier F is not supported");
+  VELOX_ASSERT_THROW(
+      fromUnixTime(0, "yyyy-MM-dd HH:II"), "Specifier I is not supported");
+}
+
+TEST_F(DateTimeFunctionsTest, makeYMInterval) {
+  const auto fromYearAndMonth = [&](const std::optional<int32_t>& year,
+                                    const std::optional<int32_t>& month) {
+    auto result =
+        evaluateOnce<int32_t>("make_ym_interval(c0, c1)", year, month);
+    VELOX_CHECK(result.has_value());
+    return INTERVAL_YEAR_MONTH()->valueToString(result.value());
+  };
+  const auto fromYear = [&](const std::optional<int32_t>& year) {
+    auto result = evaluateOnce<int32_t>("make_ym_interval(c0)", year);
+    VELOX_CHECK(result.has_value());
+    return INTERVAL_YEAR_MONTH()->valueToString(result.value());
+  };
+
+  EXPECT_EQ(fromYearAndMonth(1, 2), "1-2");
+  EXPECT_EQ(fromYearAndMonth(0, 1), "0-1");
+  EXPECT_EQ(fromYearAndMonth(1, 100), "9-4");
+  EXPECT_EQ(fromYear(0), "0-0");
+  EXPECT_EQ(fromYear(178956970), "178956970-0");
+  EXPECT_EQ(fromYear(-178956970), "-178956970-0");
+  {
+    // Test signature for no year and month.
+    auto result = evaluateOnce<int32_t>(
+        "make_ym_interval()",
+        makeRowVector(ROW({}), 1),
+        std::nullopt,
+        {INTERVAL_YEAR_MONTH()});
+    VELOX_CHECK(result.has_value());
+    EXPECT_EQ(INTERVAL_YEAR_MONTH()->valueToString(result.value()), "0-0");
+  }
+
+  VELOX_ASSERT_THROW(
+      fromYearAndMonth(178956970, 8),
+      "Integer overflow in make_ym_interval(178956970, 8)");
+  VELOX_ASSERT_THROW(
+      fromYearAndMonth(-178956970, -9),
+      "Integer overflow in make_ym_interval(-178956970, -9)");
+  VELOX_ASSERT_THROW(
+      fromYearAndMonth(178956971, 0),
+      "Integer overflow in make_ym_interval(178956971, 0)");
+  VELOX_ASSERT_THROW(
+      fromYear(178956971), "Integer overflow in make_ym_interval(178956971)");
+  VELOX_ASSERT_THROW(
+      fromYear(-178956971), "Integer overflow in make_ym_interval(-178956971)");
+}
+
+TEST_F(DateTimeFunctionsTest, yearOfWeek) {
+  const auto yearOfWeek = [&](std::optional<int32_t> date) {
+    return evaluateOnce<int32_t>("year_of_week(c0)", DATE(), date);
+  };
+  EXPECT_EQ(1970, yearOfWeek(0));
+  EXPECT_EQ(1970, yearOfWeek(-1));
+  EXPECT_EQ(1969, yearOfWeek(-4));
+  EXPECT_EQ(1970, yearOfWeek(-3));
+  EXPECT_EQ(1970, yearOfWeek(365));
+  EXPECT_EQ(1970, yearOfWeek(367));
+  EXPECT_EQ(1971, yearOfWeek(368));
+  EXPECT_EQ(2005, yearOfWeek(parseDate("2006-01-01")));
+  EXPECT_EQ(2006, yearOfWeek(parseDate("2006-01-02")));
+}
+
+TEST_F(DateTimeFunctionsTest, unixSeconds) {
+  const auto unixSeconds = [&](const StringView time) {
+    return evaluateOnce<int64_t>(
+        "unix_seconds(c0)", std::make_optional(parseTimestamp(time)));
+  };
+  EXPECT_EQ(unixSeconds("1970-01-01 00:00:01"), 1);
+  EXPECT_EQ(unixSeconds("1970-01-01 00:00:00.000127"), 0);
+  EXPECT_EQ(unixSeconds("1969-12-31 23:59:59.999872"), -1);
+  EXPECT_EQ(unixSeconds("1970-01-01 00:35:47.483647"), 2147);
+  EXPECT_EQ(unixSeconds("1971-01-01 00:00:01.483647"), 31536001);
+}
+
+TEST_F(DateTimeFunctionsTest, microsToTimestamp) {
+  const auto microsToTimestamp = [&](std::optional<int64_t> micros) {
+    return evaluateOnce<Timestamp>("timestamp_micros(c0)", micros);
+  };
+  EXPECT_EQ(microsToTimestamp(1000000), parseTimestamp("1970-01-01 00:00:01"));
+  EXPECT_EQ(
+      microsToTimestamp(1230219000123123),
+      parseTimestamp("2008-12-25 15:30:00.123123"));
+
+  EXPECT_EQ(
+      microsToTimestamp(kMaxTinyint),
+      parseTimestamp("1970-01-01 00:00:00.000127"));
+  EXPECT_EQ(
+      microsToTimestamp(kMinTinyint),
+      parseTimestamp("1969-12-31 23:59:59.999872"));
+  EXPECT_EQ(
+      microsToTimestamp(kMaxSmallint),
+      parseTimestamp("1970-01-01 00:00:00.032767"));
+  EXPECT_EQ(
+      microsToTimestamp(kMinSmallint),
+      parseTimestamp("1969-12-31 23:59:59.967232"));
+  EXPECT_EQ(
+      microsToTimestamp(kMax), parseTimestamp("1970-01-01 00:35:47.483647"));
+  EXPECT_EQ(
+      microsToTimestamp(kMin), parseTimestamp("1969-12-31 23:24:12.516352"));
+  EXPECT_EQ(
+      microsToTimestamp(kMaxBigint),
+      parseTimestamp("294247-01-10 04:00:54.775807"));
+  EXPECT_EQ(
+      microsToTimestamp(kMinBigint),
+      parseTimestamp("-290308-12-21 19:59:05.224192"));
+}
+
+TEST_F(DateTimeFunctionsTest, millisToTimestamp) {
+  const auto millisToTimestamp = [&](int64_t millis) {
+    return evaluateOnce<Timestamp, int64_t>("timestamp_millis(c0)", millis);
+  };
+  EXPECT_EQ(millisToTimestamp(1000), parseTimestamp("1970-01-01 00:00:01"));
+  EXPECT_EQ(
+      millisToTimestamp(1230219000123),
+      parseTimestamp("2008-12-25 15:30:00.123"));
+
+  EXPECT_EQ(
+      millisToTimestamp(kMaxTinyint),
+      parseTimestamp("1970-01-01 00:00:00.127"));
+  EXPECT_EQ(
+      millisToTimestamp(kMinTinyint),
+      parseTimestamp("1969-12-31 23:59:59.872"));
+  EXPECT_EQ(
+      millisToTimestamp(kMaxSmallint),
+      parseTimestamp("1970-01-01 00:00:32.767"));
+  EXPECT_EQ(
+      millisToTimestamp(kMinSmallint),
+      parseTimestamp("1969-12-31 23:59:27.232"));
+  EXPECT_EQ(millisToTimestamp(kMax), parseTimestamp("1970-01-25 20:31:23.647"));
+  EXPECT_EQ(millisToTimestamp(kMin), parseTimestamp("1969-12-07 03:28:36.352"));
+  EXPECT_EQ(
+      millisToTimestamp(kMaxBigint),
+      parseTimestamp("292278994-08-17 07:12:55.807"));
+  EXPECT_EQ(
+      millisToTimestamp(kMinBigint),
+      parseTimestamp("-292275055-05-16 16:47:04.192"));
+}
+
+TEST_F(DateTimeFunctionsTest, timestampToMicros) {
+  const auto timestampToMicros = [&](const StringView time) {
+    return evaluateOnce<int64_t, Timestamp>(
+        "unix_micros(c0)", parseTimestamp(time));
+  };
+  EXPECT_EQ(timestampToMicros("1970-01-01 00:00:01"), 1000000);
+  EXPECT_EQ(timestampToMicros("2008-12-25 15:30:00.123123"), 1230219000123123);
+
+  EXPECT_EQ(timestampToMicros("1970-01-01 00:00:00.000127"), kMaxTinyint);
+  EXPECT_EQ(timestampToMicros("1969-12-31 23:59:59.999872"), kMinTinyint);
+  EXPECT_EQ(timestampToMicros("1970-01-01 00:00:00.032767"), kMaxSmallint);
+  EXPECT_EQ(timestampToMicros("1969-12-31 23:59:59.967232"), kMinSmallint);
+  EXPECT_EQ(timestampToMicros("1970-01-01 00:35:47.483647"), kMax);
+  EXPECT_EQ(timestampToMicros("1969-12-31 23:24:12.516352"), kMin);
+  EXPECT_EQ(timestampToMicros("294247-01-10 04:00:54.775807"), kMaxBigint);
+  EXPECT_EQ(
+      timestampToMicros("-290308-12-21 19:59:06.224192"), kMinBigint + 1000000);
+}
+
+TEST_F(DateTimeFunctionsTest, timestampToMillis) {
+  const auto timestampToMillis = [&](const std::string& time) {
+    return evaluateOnce<int64_t, Timestamp>(
+        "unix_millis(c0)", parseTimestamp(time));
+  };
+  EXPECT_EQ(timestampToMillis("1970-01-01 00:00:01"), 1000);
+  EXPECT_EQ(timestampToMillis("2008-12-25 15:30:00.123"), 1230219000123);
+
+  EXPECT_EQ(timestampToMillis("1970-01-01 00:00:00.127"), kMaxTinyint);
+  EXPECT_EQ(timestampToMillis("1969-12-31 23:59:59.872"), kMinTinyint);
+  EXPECT_EQ(timestampToMillis("1970-01-01 00:00:32.767"), kMaxSmallint);
+  EXPECT_EQ(timestampToMillis("1969-12-31 23:59:27.232"), kMinSmallint);
+  EXPECT_EQ(timestampToMillis("1970-01-25 20:31:23.647"), kMax);
+  EXPECT_EQ(timestampToMillis("1969-12-07 03:28:36.352"), kMin);
+  EXPECT_EQ(timestampToMillis("292278994-08-17 07:12:55.807"), kMaxBigint);
+  EXPECT_EQ(timestampToMillis("-292275055-05-16 16:47:04.192"), kMinBigint);
+}
+
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp b/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp
new file mode 100644
index 0000000000000..a80baacf78dcc
--- /dev/null
+++ b/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp
@@ -0,0 +1,521 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/DecimalArithmetic.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::functions::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class DecimalArithmeticTest : public SparkFunctionBaseTest {
+ public:
+  DecimalArithmeticTest() {
+    options_.parseDecimalAsDouble = false;
+  }
+
+ protected:
+  void testArithmeticFunction(
+      const std::string& functionName,
+      const VectorPtr& expected,
+      const std::vector<VectorPtr>& inputs) {
+    VELOX_USER_CHECK_EQ(
+        inputs.size(),
+        2,
+        "Two input vectors are needed for arithmetic function test.");
+    std::vector<core::TypedExprPtr> inputExprs = {
+        std::make_shared<core::FieldAccessTypedExpr>(inputs[0]->type(), "c0"),
+        std::make_shared<core::FieldAccessTypedExpr>(inputs[1]->type(), "c1")};
+    auto expr = std::make_shared<const core::CallTypedExpr>(
+        expected->type(), std::move(inputExprs), functionName);
+    assertEqualVectors(expected, evaluate(expr, makeRowVector(inputs)));
+  }
+
+  VectorPtr makeNullableLongDecimalVector(
+      const std::vector<std::string>& values,
+      const TypePtr& type) {
+    VELOX_USER_CHECK(
+        type->isDecimal(),
+        "Decimal type is needed to create long decimal vector.");
+    std::vector<std::optional<int128_t>> numbers;
+    numbers.reserve(values.size());
+    for (const auto& value : values) {
+      if (value == "null") {
+        numbers.emplace_back(std::nullopt);
+      } else {
+        numbers.emplace_back(HugeInt::parse(value));
+      }
+    }
+    return makeNullableFlatVector<int128_t>(numbers, type);
+  }
+};
+
+TEST_F(DecimalArithmeticTest, add) {
+  // Precision < 38.
+  testArithmeticFunction(
+      "add",
+      makeNullableLongDecimalVector(
+          {"502", "1502", "11232", "1999999999999999999999999999998"},
+          DECIMAL(31, 3)),
+      {makeNullableLongDecimalVector(
+           {"201", "601", "1366", "999999999999999999999999999999"},
+           DECIMAL(30, 3)),
+       makeNullableLongDecimalVector(
+           {"301", "901", "9866", "999999999999999999999999999999"},
+           DECIMAL(30, 3))});
+
+  // Min leading zero >= 3.
+  testArithmeticFunction(
+      "add",
+      makeFlatVector(
+          std::vector<int128_t>{2123210, 2999889, 4234568, 4213563},
+          DECIMAL(38, 6)),
+      {makeFlatVector(
+           std::vector<int128_t>{11232100, 9998888, 12345678, 2135632},
+           DECIMAL(38, 7)),
+       makeFlatVector(std::vector<int64_t>{1, 2, 3, 4}, DECIMAL(10, 0))});
+
+  // No carry to left.
+  testArithmeticFunction(
+      "add",
+      makeNullableLongDecimalVector(
+          {"99999999999999999999999999999990000010",
+           "99999999999999999999999999999999010000",
+           "99999999999999999999999999999999900123",
+           "99999999999999999999999999999999990100"},
+          DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector(
+           {"9999999999999999999999999999999000000",
+            "9999999999999999999999999999999900000",
+            "9999999999999999999999999999999990000",
+            "9999999999999999999999999999999999000"},
+           DECIMAL(38, 5)),
+       makeFlatVector(
+           std::vector<int128_t>{100, 99999, 1234, 999}, DECIMAL(38, 7))});
+
+  // Carry to left.
+  testArithmeticFunction(
+      "add",
+      makeNullableLongDecimalVector(
+          {"99999999999999999999999999999991500000",
+           "99999999999999999999999999999991000000",
+           "99999999999999999999999999999999500000",
+           "99999999999999999999999999999999100000"},
+          DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector(
+           {"9999999999999999999999999999999070000",
+            "9999999999999999999999999999999050000",
+            "9999999999999999999999999999999870000",
+            "9999999999999999999999999999999890000"},
+           DECIMAL(38, 5)),
+       makeFlatVector(
+           std::vector<int128_t>{8000000, 5000000, 8000000, 1999999},
+           DECIMAL(38, 7))});
+
+  // Both -ve.
+  testArithmeticFunction(
+      "add",
+      makeNullableLongDecimalVector(
+          {"-502", "-1502", "-11232", "-1999999999999999999999999999998"},
+          DECIMAL(31, 3)),
+      {makeNullableLongDecimalVector(
+           {"-201", "-601", "-1366", "-999999999999999999999999999999"},
+           DECIMAL(30, 3)),
+       makeNullableLongDecimalVector(
+           {"-301", "-901", "-9866", "-999999999999999999999999999999"},
+           DECIMAL(30, 3))});
+
+  // Overflow when scaling up the whole part.
+  testArithmeticFunction(
+      "add",
+      makeNullableLongDecimalVector(
+          {"null", "null", "null", "null"}, DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector(
+           {"-99999999999999999999999999999999990000",
+            "99999999999999999999999999999999999000",
+            "-99999999999999999999999999999999999900",
+            "99999999999999999999999999999999999990"},
+           DECIMAL(38, 3)),
+       makeFlatVector(
+           std::vector<int128_t>{-100, 9999999, -999900, 99999},
+           DECIMAL(38, 7))});
+
+  // Ve and -ve.
+  testArithmeticFunction(
+      "add",
+      makeNullableLongDecimalVector(
+          {"999990", "-999990", "-10", "10"}, DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector(
+           {"99999999999999999999999999999989999990",
+            "-99999999999999999999999999999989999990",
+            "99999999999999999999999999999999999980",
+            "-99999999999999999999999999999999999980"},
+           DECIMAL(38, 6)),
+       makeNullableLongDecimalVector(
+           {"-9999999999999999999999999999998900000",
+            "9999999999999999999999999999998900000",
+            "-9999999999999999999999999999999999999",
+            "9999999999999999999999999999999999999"},
+           DECIMAL(38, 5))});
+}
+
+TEST_F(DecimalArithmeticTest, subtract) {
+  testArithmeticFunction(
+      "subtract",
+      makeNullableLongDecimalVector(
+          {"-100", "-300", "-8500", "1999999999999999999999999999998"},
+          DECIMAL(31, 3)),
+      {makeNullableLongDecimalVector(
+           {"201", "601", "1366", "999999999999999999999999999999"},
+           DECIMAL(30, 3)),
+       makeNullableLongDecimalVector(
+           {"301", "901", "9866", "-999999999999999999999999999999"},
+           DECIMAL(30, 3))});
+
+  // Min leading zero >= 3.
+  testArithmeticFunction(
+      "subtract",
+      makeFlatVector(
+          std::vector<int128_t>{123210, -1000111, -1765432, -3786437},
+          DECIMAL(38, 6)),
+      {makeFlatVector(
+           std::vector<int128_t>{11232100, 9998888, 12345678, 2135632},
+           DECIMAL(38, 7)),
+       makeFlatVector(std::vector<int64_t>{1, 2, 3, 4}, DECIMAL(10, 0))});
+
+  // No carry to left.
+  testArithmeticFunction(
+      "subtract",
+      makeNullableLongDecimalVector(
+          {"99999999999999999999999999999990000010",
+           "99999999999999999999999999999999010000",
+           "99999999999999999999999999999999900123",
+           "99999999999999999999999999999999990100"},
+          DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector(
+           {"9999999999999999999999999999999000000",
+            "9999999999999999999999999999999900000",
+            "9999999999999999999999999999999990000",
+            "9999999999999999999999999999999999000"},
+           DECIMAL(38, 5)),
+       makeFlatVector(
+           std::vector<int128_t>{-100, -99999, -1234, -999}, DECIMAL(38, 7))});
+
+  // Carry to left.
+  testArithmeticFunction(
+      "subtract",
+      makeNullableLongDecimalVector(
+          {"99999999999999999999999999999991500000",
+           "99999999999999999999999999999991000000",
+           "99999999999999999999999999999999500000",
+           "99999999999999999999999999999999100000"},
+          DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector(
+           {"9999999999999999999999999999999070000",
+            "9999999999999999999999999999999050000",
+            "9999999999999999999999999999999870000",
+            "9999999999999999999999999999999890000"},
+           DECIMAL(38, 5)),
+       makeFlatVector(
+           std::vector<int128_t>{-8000000, -5000000, -8000000, -1999999},
+           DECIMAL(38, 7))});
+
+  // Both -ve.
+  testArithmeticFunction(
+      "subtract",
+      makeNullableLongDecimalVector(
+          {"100", "300", "8500", "0"}, DECIMAL(31, 3)),
+      {makeNullableLongDecimalVector(
+           {"-201", "-601", "-1366", "-999999999999999999999999999999"},
+           DECIMAL(30, 3)),
+       makeNullableLongDecimalVector(
+           {"-301", "-901", "-9866", "-999999999999999999999999999999"},
+           DECIMAL(30, 3))});
+
+  // Overflow when scaling up the whole part.
+  testArithmeticFunction(
+      "subtract",
+      makeNullableLongDecimalVector(
+          {"null", "null", "null", "null"}, DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector(
+           {"-99999999999999999999999999999999990000",
+            "99999999999999999999999999999999999000",
+            "-99999999999999999999999999999999999900",
+            "99999999999999999999999999999999999990"},
+           DECIMAL(38, 3)),
+       makeFlatVector(
+           std::vector<int128_t>{100, -9999999, 999900, -99999},
+           DECIMAL(38, 7))});
+
+  // Ve and -ve.
+  testArithmeticFunction(
+      "subtract",
+      makeNullableLongDecimalVector(
+          {"99999999999999999999999999999999999990",
+           "-99999999999999999999999999999999999990",
+           "99999999999999999999999999999999999990",
+           "-99999999999999999999999999999999999990"},
+          DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector(
+           {"99999999999999999999999999999989999990",
+            "-99999999999999999999999999999989999990",
+            "99999999999999999999999999999999999980",
+            "-99999999999999999999999999999999999980"},
+           DECIMAL(38, 6)),
+       makeFlatVector(
+           std::vector<int128_t>{-1000000, 1000000, -1, 1}, DECIMAL(38, 5))});
+}
+
+TEST_F(DecimalArithmeticTest, multiply) {
+  // The result can be obtained by Spark unit test
+  //       test("multiply") {
+  //     val l1 = Literal.create(
+  //       Decimal(BigDecimal(1), 17, 3),
+  //       DecimalType(17, 3))
+  //     val l2 = Literal.create(
+  //       Decimal(BigDecimal(1), 17, 3),
+  //       DecimalType(17, 3))
+  //     checkEvaluation(Divide(l1, l2), null)
+  //   }
+  auto shortFlat = makeFlatVector<int64_t>({1000, 2000}, DECIMAL(17, 3));
+  // Multiply short and short, returning long.
+  testArithmeticFunction(
+      "multiply",
+      makeFlatVector<int128_t>({1000000, 4000000}, DECIMAL(35, 6)),
+      {shortFlat, shortFlat});
+  // Multiply short and long, returning long.
+  auto longFlat = makeFlatVector<int128_t>({1000, 2000}, DECIMAL(20, 3));
+  auto expectedLongFlat =
+      makeFlatVector<int128_t>({1000000, 4000000}, DECIMAL(38, 6));
+  testArithmeticFunction("multiply", expectedLongFlat, {shortFlat, longFlat});
+  // Multiply long and short, returning long.
+  testArithmeticFunction("multiply", expectedLongFlat, {longFlat, shortFlat});
+
+  // Multiply long and long, returning long.
+  testArithmeticFunction(
+      "multiply",
+      makeFlatVector<int128_t>({1000000, 4000000}, DECIMAL(38, 6)),
+      {longFlat, longFlat});
+
+  auto leftFlat0 = makeFlatVector<int128_t>({0, 1, 0}, DECIMAL(20, 3));
+  auto rightFlat0 = makeFlatVector<int128_t>({1, 0, 0}, DECIMAL(20, 2));
+  testArithmeticFunction(
+      "multiply",
+      makeFlatVector<int128_t>({0, 0, 0}, DECIMAL(38, 5)),
+      {leftFlat0, rightFlat0});
+
+  // Multiply short and short, returning short.
+  shortFlat = makeFlatVector<int64_t>({1000, 2000}, DECIMAL(6, 3));
+  testArithmeticFunction(
+      "multiply",
+      makeFlatVector<int64_t>({1000000, 4000000}, DECIMAL(13, 6)),
+      {shortFlat, shortFlat});
+
+  auto expectedConstantFlat =
+      makeFlatVector<int64_t>({100000, 200000}, DECIMAL(10, 5));
+  // Constant and Flat arguments.
+  testArithmeticFunction(
+      "multiply",
+      expectedConstantFlat,
+      {makeConstant<int64_t>(100, 2, DECIMAL(3, 2)), shortFlat});
+
+  // Flat and Constant arguments.
+  testArithmeticFunction(
+      "multiply",
+      expectedConstantFlat,
+      {shortFlat, makeConstant<int64_t>(100, 2, DECIMAL(3, 2))});
+
+  // out_precision == 38, small input values, trimming of scale.
+  testArithmeticFunction(
+      "multiply",
+      makeConstant<int128_t>(61, 1, DECIMAL(38, 7)),
+      {makeConstant<int128_t>(201, 1, DECIMAL(20, 5)),
+       makeConstant<int128_t>(301, 1, DECIMAL(20, 5))});
+
+  // out_precision == 38, large values, trimming of scale.
+  testArithmeticFunction(
+      "multiply",
+      makeConstant<int128_t>(
+          HugeInt::parse("201" + std::string(31, '0')), 1, DECIMAL(38, 6)),
+      {makeConstant<int128_t>(201, 1, DECIMAL(20, 5)),
+       makeConstant<int128_t>(
+           HugeInt::parse(std::string(35, '9')), 1, DECIMAL(35, 5))});
+
+  // out_precision == 38, very large values, trimming of scale (requires convert
+  // to 256).
+  testArithmeticFunction(
+      "multiply",
+      makeConstant<int128_t>(
+          HugeInt::parse("9999999999999999999999999999999999890"),
+          1,
+          DECIMAL(38, 6)),
+      {makeConstant<int128_t>(
+           HugeInt::parse(std::string(35, '9')), 1, DECIMAL(38, 20)),
+       makeConstant<int128_t>(
+           HugeInt::parse(std::string(36, '9')), 1, DECIMAL(38, 20))});
+
+  // out_precision == 38, very large values, trimming of scale (requires convert
+  // to 256). should cause overflow.
+  testArithmeticFunction(
+      "multiply",
+      makeConstant<int128_t>(std::nullopt, 1, DECIMAL(38, 6)),
+      {makeConstant<int128_t>(
+           HugeInt::parse(std::string(35, '9')), 1, DECIMAL(38, 4)),
+       makeConstant<int128_t>(
+           HugeInt::parse(std::string(36, '9')), 1, DECIMAL(38, 4))});
+
+  // Big scale * big scale.
+  testArithmeticFunction(
+      "multiply",
+      makeConstant<int128_t>(0, 1, DECIMAL(38, 37)),
+      {makeConstant<int128_t>(201, 1, DECIMAL(38, 38)),
+       makeConstant<int128_t>(301, 1, DECIMAL(38, 38))});
+
+  // Long decimal limits.
+  testArithmeticFunction(
+      "multiply",
+      makeConstant<int128_t>(std::nullopt, 1, DECIMAL(38, 0)),
+      {makeConstant<int128_t>(
+           HugeInt::build(0x08FFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF),
+           1,
+           DECIMAL(38, 0)),
+       makeConstant<int64_t>(10, 1, DECIMAL(2, 0))});
+
+  // Rescaling the final result overflows.
+  testArithmeticFunction(
+      "multiply",
+      makeConstant<int128_t>(std::nullopt, 1, DECIMAL(38, 1)),
+      {makeConstant<int128_t>(
+           HugeInt::build(0x08FFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF),
+           1,
+           DECIMAL(38, 0)),
+       makeConstant<int64_t>(100, 1, DECIMAL(2, 1))});
+}
+
+TEST_F(DecimalArithmeticTest, divide) {
+  auto shortFlat = makeFlatVector<int64_t>({1000, 2000}, DECIMAL(17, 3));
+  // Divide short and short, returning long.
+  testArithmeticFunction(
+      "divide",
+      makeNullableLongDecimalVector(
+          {"500000000000000000000", "2000000000000000000000"}, DECIMAL(38, 21)),
+      {makeFlatVector<int64_t>({500, 4000}, DECIMAL(17, 3)), shortFlat});
+
+  // Divide short and long, returning long.
+  auto longFlat = makeFlatVector<int128_t>({500, 4000}, DECIMAL(20, 2));
+  testArithmeticFunction(
+      "divide",
+      makeFlatVector<int128_t>(
+          {500000000000000000, 2000000000000000000}, DECIMAL(38, 17)),
+      {longFlat, shortFlat});
+
+  // Divide long and short, returning long.
+  testArithmeticFunction(
+      "divide",
+      makeNullableLongDecimalVector(
+          {"20" + std::string(20, '0'), "5" + std::string(20, '0')},
+          DECIMAL(38, 22)),
+      {shortFlat, longFlat});
+
+  // Divide long and long, returning long.
+  testArithmeticFunction(
+      "divide",
+      makeNullableLongDecimalVector(
+          {"5" + std::string(18, '0'), "3" + std::string(18, '0')},
+          DECIMAL(38, 18)),
+      {makeFlatVector<int128_t>({2500, 12000}, DECIMAL(20, 2)), longFlat});
+
+  // Divide short and short, returning short.
+  testArithmeticFunction(
+      "divide",
+      makeFlatVector<int64_t>({500000000, 300000000}, DECIMAL(13, 11)),
+      {makeFlatVector<int64_t>({2500, 12000}, DECIMAL(5, 5)),
+       makeFlatVector<int64_t>({500, 4000}, DECIMAL(5, 2))});
+  // This result can be obtained by Spark unit test
+  //   test("divide decimal big") {
+  //     val s = Seq(35, 6, 20, 3)
+  //     var builder = new StringBuffer()
+  //     (0 until 29).foreach(_ => builder = builder.append("9"))
+  //     builder.append(".")
+  //     (0 until 6).foreach(_ => builder = builder.append("9"))
+  //     val str1 = builder.toString
+
+  //     val l1 = Literal.create(
+  //       Decimal(BigDecimal(str1), s.head, s(1)),
+  //       DecimalType(s.head, s(1)))
+  //     val l2 = Literal.create(
+  //       Decimal(BigDecimal(0.201), s(2), s(3)),
+  //       DecimalType(s(2), s(3)))
+  //     checkEvaluation(Divide(l1, l2), null)
+  //   }
+  testArithmeticFunction(
+      "divide",
+      makeNullableLongDecimalVector(
+          {"497512437810945273631840796019900493"}, DECIMAL(38, 6)),
+      {makeNullableLongDecimalVector({std::string(35, '9')}, DECIMAL(35, 6)),
+       makeConstant<int128_t>(201, 1, DECIMAL(20, 3))});
+
+  testArithmeticFunction(
+      "divide",
+      makeNullableLongDecimalVector(
+          {"1000" + std::string(17, '0'), "500" + std::string(17, '0')},
+          DECIMAL(24, 20)),
+      {makeConstant<int64_t>(100, 2, DECIMAL(3, 2)), shortFlat});
+
+  // Flat and Constant arguments.
+  testArithmeticFunction(
+      "divide",
+      makeNullableLongDecimalVector(
+          {"500" + std::string(4, '0'), "1000" + std::string(4, '0')},
+          DECIMAL(23, 7)),
+      {shortFlat, makeConstant<int64_t>(200, 2, DECIMAL(3, 2))});
+
+  // Divide and round-up.
+  // The result can be obtained by Spark unit test
+  //     test("divide test") {
+  //     spark.sql("create table decimals_test(a decimal(2,1)) using parquet;")
+  //     spark.sql("insert into decimals_test values(6)")
+  //     val df = spark.sql("select a / -6.0 from decimals_test")
+  //     df.printSchema()
+  //     df.show(truncate = false)
+  //     spark.sql("drop table decimals_test;")
+  //   }
+  testArithmeticFunction(
+      "divide",
+      makeFlatVector<int64_t>(
+          {566667, -83333, -1083333, -1500000, -33333, 816667}, DECIMAL(8, 6)),
+      {makeFlatVector<int64_t>({-34, 5, 65, 90, 2, -49}, DECIMAL(2, 1)),
+       makeConstant<int64_t>(-60, 6, DECIMAL(2, 1))});
+  // Divide by zero.
+  testArithmeticFunction(
+      "divide",
+      makeConstant<int128_t>(std::nullopt, 2, DECIMAL(21, 6)),
+      {shortFlat, makeConstant<int64_t>(0, 2, DECIMAL(2, 1))});
+
+  // Long decimal limits.
+  testArithmeticFunction(
+      "divide",
+      makeConstant<int128_t>(std::nullopt, 1, DECIMAL(38, 6)),
+      {makeConstant<int128_t>(DecimalUtil::kLongDecimalMax, 1, DECIMAL(38, 0)),
+       makeConstant<int64_t>(1, 1, DECIMAL(3, 2))});
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DecimalCompareTest.cpp b/velox/functions/sparksql/tests/DecimalCompareTest.cpp
new file mode 100644
index 0000000000000..6ebb8a679800b
--- /dev/null
+++ b/velox/functions/sparksql/tests/DecimalCompareTest.cpp
@@ -0,0 +1,969 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class DecimalCompareTest : public SparkFunctionBaseTest {
+ protected:
+  void testCompareExpr(
+      const std::string& exprStr,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expectedResult,
+      const std::optional<SelectivityVector>& rows = std::nullopt) {
+    auto actual = evaluate(exprStr, makeRowVector(input), rows);
+    if (rows.has_value()) {
+      velox::test::assertEqualVectors(expectedResult, actual, rows.value());
+    } else {
+      velox::test::assertEqualVectors(expectedResult, actual);
+    }
+  }
+};
+
+TEST_F(DecimalCompareTest, gt) {
+  // Fast path when c1 vector is constant.
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeConstant((int64_t)100, 4, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({false, true, true, false}));
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeConstant((int64_t)100000, 4, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // Fast path when vectors are flat.
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({false, true, true, false}));
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeFlatVector<int64_t>(
+              {100000, 120000, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // General case when vectors are dictionary-encoded.
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1))),
+      },
+      makeFlatVector<bool>({false, true, true, false}));
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int128_t>(
+                  {10'000'000'000'000'000,
+                   12'000'000'000'000'000,
+                   13'000'000'000'000'000,
+                   35'000'000'000'000'000},
+                  DECIMAL(38, 34))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>(
+                  {100000, 120000, 130000, 350000}, DECIMAL(6, 1))),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // Decimal with nulls.
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeNullableFlatVector<bool>({false, std::nullopt, true, false}));
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeNullableFlatVector<int64_t>(
+              {100000, std::nullopt, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeNullableFlatVector<bool>({false, std::nullopt, false, false}));
+
+  // All rows selected.
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          70, [](auto row) { return row % 2 == 0 ? false : true; }));
+
+  // 90% rows selected.
+  SelectivityVector row(130);
+  row.setValidRange(0, 13, false);
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          130, [](auto row) { return row % 2 == 0 ? false : true; }),
+      row);
+
+  testCompareExpr(
+      "decimal_greaterthan(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices(140, [](auto row) { return row % 2; }),
+              makeFlatVector<int64_t>(
+                  2,
+                  [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+                  nullptr,
+                  DECIMAL(6, 2))),
+          makeFlatVector<int64_t>(
+              140,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          140, [](auto row) { return row % 2 == 0 ? false : true; }));
+}
+
+TEST_F(DecimalCompareTest, gte) {
+  // Fast path when c1 vector is constant.
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeConstant((int64_t)100, 4, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({true, true, true, false}));
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeConstant((int64_t)100000, 4, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // Fast path when vectors are flat.
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({true, true, true, false}));
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeFlatVector<int64_t>(
+              {100000, 120000, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // General case when vectors are dictionary-encoded.
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1))),
+      },
+      makeFlatVector<bool>({true, true, true, false}));
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int128_t>(
+                  {10'000'000'000'000'000,
+                   12'000'000'000'000'000,
+                   13'000'000'000'000'000,
+                   35'000'000'000'000'000},
+                  DECIMAL(38, 34))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>(
+                  {100000, 120000, 130000, 350000}, DECIMAL(6, 1))),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // Decimal with nulls.
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeNullableFlatVector<bool>({true, std::nullopt, true, false}));
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeNullableFlatVector<int64_t>(
+              {100000, std::nullopt, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeNullableFlatVector<bool>({false, std::nullopt, false, false}));
+
+  // All rows selected.
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(70, [](auto /*row*/) { return true; }));
+
+  // 90% rows selected.
+  SelectivityVector row(130);
+  row.setValidRange(0, 13, false);
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(130, [](auto /*row*/) { return true; }),
+      row);
+
+  testCompareExpr(
+      "decimal_greaterthanorequal(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices(140, [](auto row) { return row % 2; }),
+              makeFlatVector<int64_t>(
+                  2,
+                  [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+                  nullptr,
+                  DECIMAL(6, 2))),
+          makeFlatVector<int64_t>(
+              140,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(140, [](auto /*row*/) { return true; }));
+}
+
+TEST_F(DecimalCompareTest, eq) {
+  // Fast path when c1 vector is constant.
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeConstant((int64_t)100, 4, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({true, false, false, false}));
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeConstant((int64_t)100000, 4, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // Fast path when vectors are flat.
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({true, false, false, false}));
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeFlatVector<int64_t>(
+              {100000, 120000, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // General case when vectors are dictionary-encoded.
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1))),
+      },
+      makeFlatVector<bool>({true, false, false, false}));
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int128_t>(
+                  {10'000'000'000'000'000,
+                   12'000'000'000'000'000,
+                   13'000'000'000'000'000,
+                   35'000'000'000'000'000},
+                  DECIMAL(38, 34))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>(
+                  {100000, 120000, 130000, 350000}, DECIMAL(6, 1))),
+      },
+      makeFlatVector<bool>({false, false, false, false}));
+
+  // Decimal with nulls.
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeNullableFlatVector<bool>({true, std::nullopt, false, false}));
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeNullableFlatVector<int64_t>(
+              {100000, std::nullopt, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeNullableFlatVector<bool>({false, std::nullopt, false, false}));
+
+  // All rows selected.
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          70, [](auto row) { return row % 2 == 0 ? true : false; }));
+
+  // 90% rows selected.
+  SelectivityVector row(130);
+  row.setValidRange(0, 13, false);
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          130, [](auto row) { return row % 2 == 0 ? true : false; }),
+      row);
+
+  testCompareExpr(
+      "decimal_equalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              140,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+          wrapInDictionary(
+              makeIndices(140, [](auto row) { return row % 2; }),
+              makeFlatVector<int64_t>(
+                  2,
+                  [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+                  nullptr,
+                  DECIMAL(6, 2))),
+      },
+      makeFlatVector<bool>(
+          140, [](auto row) { return row % 2 == 0 ? true : false; }));
+}
+
+TEST_F(DecimalCompareTest, neq) {
+  // Fast path when c1 vector is constant.
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeConstant((int64_t)100, 4, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({false, true, true, true}));
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeConstant((int64_t)100000, 4, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // Fast path when vectors are flat.
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({false, true, true, true}));
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeFlatVector<int64_t>(
+              {100000, 120000, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // General case when vectors are dictionary-encoded.
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1))),
+      },
+      makeFlatVector<bool>({false, true, true, true}));
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int128_t>(
+                  {10'000'000'000'000'000,
+                   12'000'000'000'000'000,
+                   13'000'000'000'000'000,
+                   35'000'000'000'000'000},
+                  DECIMAL(38, 34))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>(
+                  {100000, 120000, 130000, 350000}, DECIMAL(6, 1))),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // Decimal with nulls.
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeNullableFlatVector<bool>({false, std::nullopt, true, true}));
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeNullableFlatVector<int64_t>(
+              {100000, std::nullopt, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeNullableFlatVector<bool>({true, std::nullopt, true, true}));
+
+  // All rows selected.
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          70, [](auto row) { return row % 2 == 0 ? false : true; }));
+
+  // 90% rows selected.
+  SelectivityVector row(130);
+  row.setValidRange(0, 13, false);
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          130, [](auto row) { return row % 2 == 0 ? false : true; }),
+      row);
+
+  testCompareExpr(
+      "decimal_notequalto(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices(140, [](auto row) { return row % 2; }),
+              makeFlatVector<int64_t>(
+                  2,
+                  [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+                  nullptr,
+                  DECIMAL(6, 2))),
+          makeFlatVector<int64_t>(
+              140,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          140, [](auto row) { return row % 2 == 0 ? false : true; }));
+}
+
+TEST_F(DecimalCompareTest, lt) {
+  // Fast path when c1 vector is constant.
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeConstant((int64_t)100, 4, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({false, false, false, true}));
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeConstant((int64_t)100000, 4, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // Fast path when vectors are flat.
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({false, false, false, true}));
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeFlatVector<int64_t>(
+              {100000, 120000, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // General case when vectors are dictionary-encoded.
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1))),
+      },
+      makeFlatVector<bool>({false, false, false, true}));
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int128_t>(
+                  {10'000'000'000'000'000,
+                   12'000'000'000'000'000,
+                   13'000'000'000'000'000,
+                   35'000'000'000'000'000},
+                  DECIMAL(38, 34))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>(
+                  {100000, 120000, 130000, 350000}, DECIMAL(6, 1))),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // Decimal with nulls.
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeNullableFlatVector<bool>({false, std::nullopt, false, true}));
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeNullableFlatVector<int64_t>(
+              {100000, std::nullopt, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeNullableFlatVector<bool>({true, std::nullopt, true, true}));
+
+  // All rows selected.
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(70, [](auto /*row*/) { return false; }));
+
+  // 90% rows selected.
+  SelectivityVector row(130);
+  row.setValidRange(0, 13, false);
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(130, [](auto /*row*/) { return false; }),
+      row);
+
+  testCompareExpr(
+      "decimal_lessthan(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices(140, [](auto row) { return row % 2; }),
+              makeFlatVector<int64_t>(
+                  2,
+                  [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+                  nullptr,
+                  DECIMAL(6, 2))),
+          makeFlatVector<int64_t>(
+              140,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(140, [](auto /*row*/) { return false; }));
+}
+
+TEST_F(DecimalCompareTest, lte) {
+  // Fast path when c1 vector is constant.
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeConstant((int64_t)100, 4, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({true, false, false, true}));
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeConstant((int64_t)100000, 4, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // Fast path when vectors are flat.
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>({true, false, false, true}));
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeFlatVector<int64_t>(
+              {100000, 120000, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // General case when vectors are dictionary-encoded.
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>({100, 120, 130, 350}, DECIMAL(5, 1))),
+      },
+      makeFlatVector<bool>({true, false, false, true}));
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int128_t>(
+                  {10'000'000'000'000'000,
+                   12'000'000'000'000'000,
+                   13'000'000'000'000'000,
+                   35'000'000'000'000'000},
+                  DECIMAL(38, 34))),
+          wrapInDictionary(
+              makeIndices({0, 1, 2, 3}),
+              makeFlatVector<int64_t>(
+                  {100000, 120000, 130000, 350000}, DECIMAL(6, 1))),
+      },
+      makeFlatVector<bool>({true, true, true, true}));
+
+  // Decimal with nulls.
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>({1000, 2000, 3000, 400}, DECIMAL(6, 2)),
+          makeNullableFlatVector<int64_t>(
+              {100, std::nullopt, 130, 350}, DECIMAL(5, 1)),
+      },
+      makeNullableFlatVector<bool>({true, std::nullopt, false, true}));
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          makeFlatVector<int128_t>(
+              {10'000'000'000'000'000,
+               12'000'000'000'000'000,
+               13'000'000'000'000'000,
+               35'000'000'000'000'000},
+              DECIMAL(38, 34)),
+          makeNullableFlatVector<int64_t>(
+              {100000, std::nullopt, 130000, 350000}, DECIMAL(6, 1)),
+      },
+      makeNullableFlatVector<bool>({true, std::nullopt, true, true}));
+
+  // All rows selected.
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              70,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          70, [](auto row) { return row % 2 == 0 ? true : false; }));
+
+  // 90% rows selected.
+  SelectivityVector row(130);
+  row.setValidRange(0, 13, false);
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+              nullptr,
+              DECIMAL(6, 2)),
+          makeFlatVector<int64_t>(
+              130,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          130, [](auto row) { return row % 2 == 0 ? true : false; }),
+      row);
+
+  testCompareExpr(
+      "decimal_lessthanorequal(c0, c1)",
+      {
+          wrapInDictionary(
+              makeIndices(140, [](auto row) { return row % 2; }),
+              makeFlatVector<int64_t>(
+                  2,
+                  [](auto row) { return row % 2 == 0 ? 1000 : 3000; },
+                  nullptr,
+                  DECIMAL(6, 2))),
+          makeFlatVector<int64_t>(
+              140,
+              [](auto row) { return row % 2 == 0 ? 100 : 130; },
+              nullptr,
+              DECIMAL(5, 1)),
+      },
+      makeFlatVector<bool>(
+          140, [](auto row) { return row % 2 == 0 ? true : false; }));
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DecimalRoundTest.cpp b/velox/functions/sparksql/tests/DecimalRoundTest.cpp
new file mode 100644
index 0000000000000..4ac674a467dbe
--- /dev/null
+++ b/velox/functions/sparksql/tests/DecimalRoundTest.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/specialforms/DecimalRound.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class DecimalRoundTest : public SparkFunctionBaseTest {
+ protected:
+  core::CallTypedExprPtr createDecimalRound(
+      const TypePtr& inputType,
+      const std::optional<int32_t>& scaleOpt,
+      bool castScale) {
+    std::vector<core::TypedExprPtr> inputs = {
+        std::make_shared<core::FieldAccessTypedExpr>(inputType, "c0")};
+    int32_t scale = 0;
+    if (scaleOpt.has_value()) {
+      scale = scaleOpt.value();
+      if (castScale) {
+        // It is a common case in Spark for the second argument to be cast from
+        // bigint to integer.
+        inputs.emplace_back(std::make_shared<core::CastTypedExpr>(
+            INTEGER(),
+            std::make_shared<core::ConstantTypedExpr>(
+                BIGINT(), variant((int64_t)scale)),
+            true /*nullOnFailure*/));
+      } else {
+        inputs.emplace_back(std::make_shared<core::ConstantTypedExpr>(
+            INTEGER(), variant(scale)));
+      }
+    }
+
+    const auto [inputPrecision, inputScale] =
+        getDecimalPrecisionScale(*inputType);
+    const auto [resultPrecision, resultScale] =
+        DecimalRoundCallToSpecialForm::getResultPrecisionScale(
+            inputPrecision, inputScale, scale);
+    return std::make_shared<const core::CallTypedExpr>(
+        DECIMAL(resultPrecision, resultScale),
+        std::move(inputs),
+        DecimalRoundCallToSpecialForm::kRoundDecimal);
+  }
+
+  void testDecimalRound(
+      const VectorPtr& input,
+      const std::optional<int32_t>& scaleOpt,
+      const VectorPtr& expected) {
+    for (auto castScale : {true, false}) {
+      auto expr = createDecimalRound(input->type(), scaleOpt, castScale);
+      testEncodings(expr, {input}, expected);
+    }
+  }
+};
+
+TEST_F(DecimalRoundTest, round) {
+  // Round to 'scale'.
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 3)),
+      3,
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(4, 3)));
+
+  // Round to 'scale - 1'.
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 3)),
+      2,
+      makeFlatVector<int64_t>({12, 55, -100, 0}, DECIMAL(3, 2)));
+
+  // Round to 0 decimal scale.
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 3)),
+      0,
+      makeFlatVector<int64_t>({0, 1, -1, 0}, DECIMAL(1, 0)));
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 3)),
+      std::nullopt,
+      makeFlatVector<int64_t>({0, 1, -1, 0}, DECIMAL(1, 0)));
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 2)),
+      0,
+      makeFlatVector<int64_t>({1, 6, -10, 0}, DECIMAL(2, 0)));
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 2)),
+      std::nullopt,
+      makeFlatVector<int64_t>({1, 6, -10, 0}, DECIMAL(2, 0)));
+
+  // Round to negative decimal scale.
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 3)),
+      -1,
+      makeFlatVector<int64_t>({0, 0, 0, 0}, DECIMAL(2, 0)));
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 1)),
+      -1,
+      makeFlatVector<int64_t>({10, 60, -100, 0}, DECIMAL(3, 0)));
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 1)),
+      -3,
+      makeFlatVector<int64_t>({0, 0, 0, 0}, DECIMAL(4, 0)));
+
+  // Round long decimals to short decimals.
+  testDecimalRound(
+      makeFlatVector<int128_t>(
+          {1234567890123456789, 5000000000000000000, -999999999999999999, 0},
+          DECIMAL(19, 19)),
+      14,
+      makeNullableFlatVector<int64_t>(
+          {12345678901235, 50000000000000, -10'000'000'000'000, 0},
+          DECIMAL(15, 14)));
+  testDecimalRound(
+      makeFlatVector<int128_t>(
+          {1234567890123456789, 5555555555555555555, -999999999999999999, 0},
+          DECIMAL(19, 5)),
+      -9,
+      makeFlatVector<int64_t>(
+          {12346000000000, 55556000000000, -10000000000000, 0},
+          DECIMAL(15, 0)));
+
+  // Round long decimals to long decimals.
+  testDecimalRound(
+      makeFlatVector<int128_t>(
+          {1234567890123456789, 5555555555555555555, -999999999999999999, 0},
+          DECIMAL(19, 5)),
+      14,
+      makeFlatVector<int128_t>(
+          {1234567890123456789, 5555555555555555555, -999999999999999999, 0},
+          DECIMAL(20, 5)));
+  testDecimalRound(
+      makeFlatVector<int128_t>(
+          {1234567890123456789, 5555555555555555555, -999999999999999999, 0},
+          DECIMAL(32, 5)),
+      -9,
+      makeFlatVector<int128_t>(
+          {12346000000000, 55556000000000, -10000000000000, 0},
+          DECIMAL(28, 0)));
+
+  // Result precision is 38.
+  testDecimalRound(
+      makeFlatVector<int128_t>(
+          {1234567890123456789, 5555555555555555555, -999999999999999999, 0},
+          DECIMAL(32, 0)),
+      -38,
+      makeFlatVector<int128_t>({0, 0, 0, 0}, DECIMAL(38, 0)));
+
+  // Round to a scale exceeding the max precision of long decimal.
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 1)),
+      std::numeric_limits<int32_t>::max(),
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(4, 1)));
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 1)),
+      std::numeric_limits<int32_t>::min(),
+      makeFlatVector<int128_t>({0, 0, 0, 0}, DECIMAL(38, 0)));
+
+  // Round to INT_MAX and INT_MIN.
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 1)),
+      std::numeric_limits<int32_t>::max(),
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(4, 1)));
+  testDecimalRound(
+      makeFlatVector<int64_t>({123, 552, -999, 0}, DECIMAL(3, 1)),
+      std::numeric_limits<int32_t>::min(),
+      makeFlatVector<int128_t>({0, 0, 0, 0}, DECIMAL(38, 0)));
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DecimalUtilTest.cpp b/velox/functions/sparksql/tests/DecimalUtilTest.cpp
new file mode 100644
index 0000000000000..833b88605a206
--- /dev/null
+++ b/velox/functions/sparksql/tests/DecimalUtilTest.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/sparksql/DecimalUtil.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class DecimalUtilTest : public testing::Test {
+ protected:
+  template <typename R, typename A, typename B>
+  void testDivideWithRoundUp(
+      A a,
+      B b,
+      int32_t aRescale,
+      R expectedResult,
+      bool expectedOverflow) {
+    R r;
+    bool overflow = false;
+    DecimalUtil::divideWithRoundUp<R, A, B>(r, a, b, aRescale, overflow);
+    ASSERT_EQ(overflow, expectedOverflow);
+    ASSERT_EQ(r, expectedResult);
+  }
+};
+} // namespace
+
+TEST_F(DecimalUtilTest, divideWithRoundUp) {
+  testDivideWithRoundUp<int64_t, int64_t, int64_t>(60, 30, 3, 2000, false);
+  testDivideWithRoundUp<int64_t, int64_t, int64_t>(
+      6, velox::DecimalUtil::kPowersOfTen[17], 20, 6000, false);
+}
+
+TEST_F(DecimalUtilTest, minLeadingZeros) {
+  auto result =
+      DecimalUtil::minLeadingZeros<int64_t, int64_t>(10000, 6000000, 10, 12);
+  ASSERT_EQ(result, 1);
+
+  result = DecimalUtil::minLeadingZeros<int64_t, int128_t>(
+      10000, 6'000'000'000'000'000'000, 10, 12);
+  ASSERT_EQ(result, 16);
+
+  result = DecimalUtil::minLeadingZeros<int128_t, int128_t>(
+      velox::DecimalUtil::kLongDecimalMax,
+      velox::DecimalUtil::kLongDecimalMin,
+      10,
+      12);
+  ASSERT_EQ(result, 0);
+}
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/HashTest.cpp b/velox/functions/sparksql/tests/HashTest.cpp
index 422d63643e56b..e9e9558275cc3 100644
--- a/velox/functions/sparksql/tests/HashTest.cpp
+++ b/velox/functions/sparksql/tests/HashTest.cpp
@@ -18,6 +18,8 @@
 
 #include <stdint.h>
 
+using facebook::velox::test::assertEqualVectors;
+
 namespace facebook::velox::functions::sparksql::test {
 namespace {
 
@@ -27,6 +29,42 @@ class HashTest : public SparkFunctionBaseTest {
   std::optional<int32_t> hash(std::optional<T> arg) {
     return evaluateOnce<int32_t>("hash(c0)", arg);
   }
+
+  VectorPtr hash(VectorPtr vector) {
+    return evaluate("hash(c0)", makeRowVector({vector}));
+  }
+
+  template <typename T>
+  void runSIMDHashAndAssert(
+      const T value,
+      const int32_t expectedResult,
+      const int32_t size,
+      int unSelectedRows = 0) {
+    // Generate 'size' flat vector to test SIMD code path.
+    // We use same value in the vector to make comparing the results easier.
+    std::vector<int32_t> resultData;
+    resultData.reserve(size);
+    for (auto i = 0; i < size; ++i) {
+      resultData.emplace_back(expectedResult);
+    }
+    VectorPtr input;
+    if constexpr (std::is_same_v<T, UnknownValue>) {
+      input = makeAllNullFlatVector<T>(size);
+    } else {
+      std::vector<T> inputData;
+      inputData.reserve(size);
+      for (auto i = 0; i < size; ++i) {
+        inputData.emplace_back(value);
+      }
+      input = makeFlatVector<T>(inputData);
+    }
+    SelectivityVector rows(size);
+    rows.setValidRange(0, unSelectedRows, false);
+    auto result =
+        evaluate<SimpleVector<int32_t>>("hash(c0)", makeRowVector({input}));
+    velox::test::assertEqualVectors(
+        makeFlatVector<int32_t>(resultData), result, rows);
+  }
 };
 
 TEST_F(HashTest, String) {
@@ -128,5 +166,142 @@ TEST_F(HashTest, Float) {
   EXPECT_EQ(hash<float>(-limits::infinity()), 427440766);
 }
 
+TEST_F(HashTest, array) {
+  assertEqualVectors(
+      makeFlatVector<int32_t>({2101165938, 42, 1045631400}),
+      hash(makeArrayVector<int64_t>({{1, 2, 3, 4, 5}, {}, {1, 2, 3}})));
+
+  assertEqualVectors(
+      makeFlatVector<int32_t>({-559580957, 1765031574, 42}),
+      hash(makeNullableArrayVector<int32_t>(
+          {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
+
+  // Nested array.
+  {
+    auto arrayVector = makeNestedArrayVectorFromJson<int64_t>(
+        {"[[1, null, 2, 3], [4, 5]]",
+         "[[1, null, 2, 3], [6, 7, 8]]",
+         "[[]]",
+         "[[null]]",
+         "[null]"});
+    assertEqualVectors(
+        makeFlatVector<int32_t>({2101165938, -992561130, 42, 42, 42}),
+        hash(arrayVector));
+  }
+
+  // Array of map.
+  {
+    using S = StringView;
+    using P = std::pair<int64_t, std::optional<S>>;
+    std::vector<P> a{P{1, S{"a"}}, P{2, std::nullopt}};
+    std::vector<P> b{P{3, S{"c"}}};
+    std::vector<std::vector<std::vector<P>>> data = {{a, b}};
+    auto arrayVector = makeArrayOfMapVector<int64_t, S>(data);
+    assertEqualVectors(
+        makeFlatVector<int32_t>(std::vector<int32_t>{-718462205}),
+        hash(arrayVector));
+  }
+
+  // Array of row.
+  {
+    std::vector<std::vector<std::optional<std::tuple<int32_t, std::string>>>>
+        data = {
+            {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+            {{{1, "red"}}, std::nullopt, {{3, "green"}}},
+            {std::nullopt},
+        };
+    auto arrayVector = makeArrayOfRowVector(data, ROW({INTEGER(), VARCHAR()}));
+    assertEqualVectors(
+        makeFlatVector<int32_t>({-1458343314, 551500425, 42}),
+        hash(arrayVector));
+  }
+}
+
+TEST_F(HashTest, map) {
+  auto mapVector = makeMapVector<int64_t, double>(
+      {{{1, 17.0}, {2, 36.0}, {3, 8.0}, {4, 28.0}, {5, 24.0}, {6, 32.0}}});
+  assertEqualVectors(
+      makeFlatVector<int32_t>(std::vector<int32_t>{1263683448}),
+      hash(mapVector));
+
+  auto mapOfArrays = createMapOfArraysVector<int32_t, int32_t>(
+      {{{1, {{1, 2, 3}}}}, {{2, {{4, 5, 6}}}}, {{3, {{7, 8, 9}}}}});
+  assertEqualVectors(
+      makeFlatVector<int32_t>({-1818148947, 529298908, 825098912}),
+      hash(mapOfArrays));
+
+  auto mapWithNullArrays = createMapOfArraysVector<int64_t, int64_t>(
+      {{{1, std::nullopt}}, {{2, {{4, 5, std::nullopt}}}}, {{3, {{}}}}});
+  assertEqualVectors(
+      makeFlatVector<int32_t>({-1712319331, 2060637564, 519220707}),
+      hash(mapWithNullArrays));
+}
+
+TEST_F(HashTest, row) {
+  auto row = makeRowVector({
+      makeFlatVector<int64_t>({1, 3}),
+      makeFlatVector<int64_t>({2, 4}),
+  });
+  assertEqualVectors(
+      makeFlatVector<int32_t>({-1181176833, 1717636039}), hash(row));
+
+  row = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt}),
+      makeNullableFlatVector<int64_t>({std::nullopt, 4}),
+  });
+  assertEqualVectors(
+      makeFlatVector<int32_t>({-1712319331, 1344313940}), hash(row));
+
+  row->setNull(0, true);
+  assertEqualVectors(makeFlatVector<int32_t>({42, 1344313940}), hash(row));
+
+  row->setNull(1, true);
+  assertEqualVectors(makeFlatVector<int32_t>({42, 42}), hash(row));
+}
+
+TEST_F(HashTest, unknown) {
+  assertEqualVectors(
+      makeFlatVector<int32_t>({42, 42, 42}),
+      hash(makeAllNullFlatVector<UnknownValue>(3)));
+
+  assertEqualVectors(
+      makeFlatVector<int32_t>({42, 42}),
+      hash(makeNullableArrayVector<UnknownValue>({
+          {std::nullopt, std::nullopt},
+          {std::nullopt, std::nullopt, std::nullopt},
+      })));
+
+  auto mapVector = makeNullableMapVector<UnknownValue, UnknownValue>({
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+  });
+  assertEqualVectors(makeFlatVector<int32_t>({42, 42, 42}), hash(mapVector));
+
+  auto row = makeRowVector({
+      makeFlatVector<int64_t>({1, 3, 4}),
+      makeAllNullFlatVector<UnknownValue>(3),
+  });
+  assertEqualVectors(
+      makeFlatVector<int32_t>({-1712319331, 519220707, 1344313940}), hash(row));
+}
+
+TEST_F(HashTest, simd) {
+  runSIMDHashAndAssert<int8_t>(1, -559580957, 1024, 10);
+  runSIMDHashAndAssert<int16_t>(-1, -1604776387, 4096);
+  runSIMDHashAndAssert<int32_t>(0xcafecafe, 638354558, 33);
+  runSIMDHashAndAssert<int64_t>(-1, -939490007, 34);
+  runSIMDHashAndAssert<std::string>("Spark", 228093765, 33);
+  runSIMDHashAndAssert<float>(1, -466301895, 77);
+  runSIMDHashAndAssert<double>(1, -460888942, 1000, 32);
+  runSIMDHashAndAssert<Timestamp>(
+      Timestamp::fromMicros(12345678), 1402875301, 1000);
+
+  runSIMDHashAndAssert<int64_t>(-1, -939490007, 1024, 1023);
+  runSIMDHashAndAssert<int64_t>(-1, -939490007, 1024, 512);
+  runSIMDHashAndAssert<int64_t>(-1, -939490007, 1024, 3);
+  runSIMDHashAndAssert<UnknownValue>(UnknownValue(), 42, 10);
+}
+
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/InTest.cpp b/velox/functions/sparksql/tests/InTest.cpp
index 7738226707e2f..5daaecd1cc946 100644
--- a/velox/functions/sparksql/tests/InTest.cpp
+++ b/velox/functions/sparksql/tests/InTest.cpp
@@ -31,10 +31,6 @@ constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
 /// Wraps input in a dictionary that repeats first row.
 class TestingDictionaryFunction : public exec::VectorFunction {
  public:
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
@@ -63,7 +59,10 @@ class InTest : public SparkFunctionBaseTest {
     exec::registerVectorFunction(
         "testing_dictionary",
         TestingDictionaryFunction::signatures(),
-        std::make_unique<TestingDictionaryFunction>());
+        std::make_unique<TestingDictionaryFunction>(),
+        exec::VectorFunctionMetadataBuilder()
+            .defaultNullBehavior(false)
+            .build());
   }
 
   template <typename T>
@@ -144,6 +143,7 @@ TEST_F(InTest, Float) {
   EXPECT_EQ(in<float>(-0.0, {-1.0, 0.0, 1.0}), true);
   EXPECT_EQ(in<float>(kNan, {-1.0, 0.0, 1.0}), false);
   EXPECT_EQ(in<float>(kNan, {kNan, -1.0, 0.0, 1.0}), true);
+  EXPECT_EQ(in<float>(std::nanf("1"), {kNan, -1.0, 0.0, 1.0}), true);
 }
 
 TEST_F(InTest, Double) {
@@ -152,6 +152,7 @@ TEST_F(InTest, Double) {
   EXPECT_EQ(in<double>(-0.0, {-1.0, 0.0, 1.0}), true);
   EXPECT_EQ(in<double>(kNan, {-1.0, 0.0, 1.0}), false);
   EXPECT_EQ(in<double>(kNan, {kNan, -1.0, 0.0, 1.0}), true);
+  EXPECT_EQ(in<double>(std::nan("1"), {kNan, -1.0, 0.0, 1.0}), true);
   EXPECT_EQ(in<double>(kInf, {kNan, -1.0, 0.0, 1.0}), false);
   EXPECT_EQ(in<double>(kInf, {kNan, -1.0, 0.0, 1.0, kInf}), true);
   EXPECT_EQ(in<double>(-kInf, {kNan, -1.0, 0.0, 1.0}), false);
diff --git a/velox/functions/sparksql/tests/JsonObjectKeysTest.cpp b/velox/functions/sparksql/tests/JsonObjectKeysTest.cpp
new file mode 100644
index 0000000000000..79a608503c086
--- /dev/null
+++ b/velox/functions/sparksql/tests/JsonObjectKeysTest.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class JsonObjectKeysTest : public SparkFunctionBaseTest {
+ protected:
+  VectorPtr jsonObjectKeys(const std::string& json) {
+    auto varcharVector = makeFlatVector<std::string>({json});
+    return evaluate("json_object_keys(c0)", makeRowVector({varcharVector}));
+  }
+};
+
+TEST_F(JsonObjectKeysTest, basic) {
+  auto expected =
+      makeArrayVectorFromJson<std::string>({"[\"name\",\"age\",\"id\"]"});
+  assertEqualVectors(
+      jsonObjectKeys(R"({"name": "Alice", "age": 5, "id": "001"})"), expected);
+
+  expected = makeArrayVectorFromJson<std::string>({"[]"});
+  assertEqualVectors(jsonObjectKeys(R"({})"), expected);
+
+  expected = makeNullableArrayVector<std::string>({std::nullopt});
+  assertEqualVectors(jsonObjectKeys(R"(1)"), expected);
+  assertEqualVectors(jsonObjectKeys(R"("hello")"), expected);
+  assertEqualVectors(jsonObjectKeys(R"("")"), expected);
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/LeastGreatestTest.cpp b/velox/functions/sparksql/tests/LeastGreatestTest.cpp
index 729b8f767bea2..79cbe1756699e 100644
--- a/velox/functions/sparksql/tests/LeastGreatestTest.cpp
+++ b/velox/functions/sparksql/tests/LeastGreatestTest.cpp
@@ -27,8 +27,8 @@ class LeastTest : public SparkFunctionBaseTest {
       std::optional<T> arg1,
       std::optional<T> arg2,
       const TypePtr& type = CppToType<T>::create()) {
-    return evaluateOnce<T, T>(
-        "least(c0, c1, c2)", {arg0, arg1, arg2}, {type, type, type});
+    return evaluateOnce<T>(
+        "least(c0, c1, c2)", {type, type, type}, arg0, arg1, arg2);
   }
 
   template <typename T>
@@ -38,10 +38,13 @@ class LeastTest : public SparkFunctionBaseTest {
       std::optional<T> arg2,
       std::optional<T> arg3,
       const TypePtr& type = CppToType<T>::create()) {
-    return evaluateOnce<T, T>(
+    return evaluateOnce<T>(
         "least(c0, c1, c2, c3)",
-        {arg0, arg1, arg2, arg3},
-        {type, type, type, type});
+        {type, type, type, type},
+        arg0,
+        arg1,
+        arg2,
+        arg3);
   }
 
   template <typename T>
@@ -176,6 +179,14 @@ TEST_F(LeastTest, date) {
   EXPECT_EQ(least<int32_t>(100, 1000, 10000, DATE()), 100);
 }
 
+TEST_F(LeastTest, decimal) {
+  flat<int64_t>(DECIMAL(6, 2));
+  constant<int64_t>(DECIMAL(6, 2));
+
+  flat<int128_t>(DECIMAL(28, 12));
+  constant<int128_t>(DECIMAL(28, 12));
+}
+
 class GreatestTest : public SparkFunctionBaseTest {
  protected:
   template <typename T>
@@ -184,8 +195,8 @@ class GreatestTest : public SparkFunctionBaseTest {
       std::optional<T> arg1,
       std::optional<T> arg2,
       const TypePtr& type = CppToType<T>::create()) {
-    return evaluateOnce<T, T>(
-        "greatest(c0, c1, c2)", {arg0, arg1, arg2}, {type, type, type});
+    return evaluateOnce<T>(
+        "greatest(c0, c1, c2)", {type, type, type}, arg0, arg1, arg2);
   }
 
   template <typename T>
@@ -195,10 +206,13 @@ class GreatestTest : public SparkFunctionBaseTest {
       std::optional<T> arg2,
       std::optional<T> arg3,
       const TypePtr& type = CppToType<T>::create()) {
-    return evaluateOnce<T, T>(
+    return evaluateOnce<T>(
         "greatest(c0, c1, c2, c3)",
-        {arg0, arg1, arg2, arg3},
-        {type, type, type, type});
+        {type, type, type, type},
+        arg0,
+        arg1,
+        arg2,
+        arg3);
   }
 
   template <typename T>
@@ -334,5 +348,13 @@ TEST_F(GreatestTest, date) {
   EXPECT_EQ(greatest<int32_t>(100, 1000, 10000, DATE()), 10000);
 }
 
+TEST_F(GreatestTest, decimal) {
+  flat<int64_t>(DECIMAL(6, 2));
+  constant<int64_t>(DECIMAL(6, 2));
+
+  flat<int128_t>(DECIMAL(28, 12));
+  constant<int128_t>(DECIMAL(28, 12));
+}
+
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/MakeDecimalTest.cpp b/velox/functions/sparksql/tests/MakeDecimalTest.cpp
new file mode 100644
index 0000000000000..5d11bd9c0dfa4
--- /dev/null
+++ b/velox/functions/sparksql/tests/MakeDecimalTest.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+class MakeDecimalTest : public SparkFunctionBaseTest {
+ protected:
+  core::CallTypedExprPtr createMakeDecimal(
+      std::optional<bool> nullOnOverflow,
+      const TypePtr& outputType,
+      bool tryMakeDecimal) {
+    std::vector<core::TypedExprPtr> inputs = {
+        std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0")};
+    if (nullOnOverflow.has_value()) {
+      inputs.emplace_back(std::make_shared<core::ConstantTypedExpr>(
+          BOOLEAN(), variant(nullOnOverflow.value())));
+    }
+    auto makeDecimal = std::make_shared<const core::CallTypedExpr>(
+        outputType, std::move(inputs), "make_decimal");
+    if (tryMakeDecimal) {
+      return std::make_shared<core::CallTypedExpr>(
+          outputType, std::vector<core::TypedExprPtr>{makeDecimal}, "try");
+    } else {
+      return makeDecimal;
+    }
+  }
+
+  void testMakeDecimal(
+      const VectorPtr& input,
+      std::optional<bool> nullOnOverflow,
+      const VectorPtr& expected,
+      bool tryMakeDecimal = false) {
+    auto expr =
+        createMakeDecimal(nullOnOverflow, expected->type(), tryMakeDecimal);
+    testEncodings(expr, {input}, expected);
+  }
+};
+
+TEST_F(MakeDecimalTest, makeDecimal) {
+  testMakeDecimal(
+      makeFlatVector<int64_t>({1111, -1112, 9999, 0}),
+      std::nullopt,
+      makeFlatVector<int64_t>({1111, -1112, 9999, 0}, DECIMAL(5, 1)));
+  testMakeDecimal(
+      makeFlatVector<int64_t>({1111, -1112, 9999, 0}),
+      true,
+      makeFlatVector<int64_t>({1111, -1112, 9999, 0}, DECIMAL(5, 1)));
+  testMakeDecimal(
+      makeFlatVector<int64_t>(
+          {11111111, -11112112, 99999999, DecimalUtil::kShortDecimalMax + 1}),
+      true,
+      makeFlatVector<int128_t>(
+          {11111111, -11112112, 99999999, DecimalUtil::kShortDecimalMax + 1},
+          DECIMAL(38, 19)));
+  testMakeDecimal(
+      makeFlatVector<int64_t>(
+          {11111111, -11112112, 99999999, DecimalUtil::kShortDecimalMax + 1}),
+      true,
+      makeNullableFlatVector<int64_t>(
+          {11111111, -11112112, 99999999, std::nullopt}, DECIMAL(18, 0)));
+  VELOX_ASSERT_THROW(
+      testMakeDecimal(
+          makeFlatVector<int64_t>(
+              {11111111,
+               -11112112,
+               99999999,
+               DecimalUtil::kShortDecimalMax + 1}),
+          false,
+          makeNullableFlatVector<int64_t>(
+              {11111111, -11112112, 99999999, std::nullopt}, DECIMAL(18, 0))),
+      "Unscaled value 1000000000000000000 too large for precision 18.");
+  testMakeDecimal(
+      makeFlatVector<int64_t>(
+          {11111111, -11112112, 99999999, DecimalUtil::kShortDecimalMax + 1}),
+      false,
+      makeNullableFlatVector<int64_t>(
+          {11111111, -11112112, 99999999, std::nullopt}, DECIMAL(18, 0)),
+      true /*tryMakeDecimal*/);
+  testMakeDecimal(
+      makeNullableFlatVector<int64_t>({101, std::nullopt, 1000}),
+      true,
+      makeNullableFlatVector<int64_t>(
+          {101, std::nullopt, std::nullopt}, DECIMAL(3, 1)));
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/MakeTimestampTest.cpp b/velox/functions/sparksql/tests/MakeTimestampTest.cpp
new file mode 100644
index 0000000000000..624058c9bdecc
--- /dev/null
+++ b/velox/functions/sparksql/tests/MakeTimestampTest.cpp
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class MakeTimestampTest : public SparkFunctionBaseTest {
+ protected:
+  void setQueryTimeZone(const std::string& timeZone) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+};
+
+TEST_F(MakeTimestampTest, basic) {
+  const auto microsType = DECIMAL(16, 6);
+  const auto testMakeTimestamp = [&](const RowVectorPtr& data,
+                                     const VectorPtr& expected,
+                                     bool hasTimeZone) {
+    auto result = hasTimeZone
+        ? evaluate("make_timestamp(c0, c1, c2, c3, c4, c5, c6)", data)
+        : evaluate("make_timestamp(c0, c1, c2, c3, c4, c5)", data);
+    facebook::velox::test::assertEqualVectors(expected, result);
+  };
+  const auto testConstantTimezone = [&](const RowVectorPtr& data,
+                                        const std::string& timezone,
+                                        const VectorPtr& expected) {
+    auto result = evaluate(
+        fmt::format("make_timestamp(c0, c1, c2, c3, c4, c5, '{}')", timezone),
+        data);
+    facebook::velox::test::assertEqualVectors(expected, result);
+  };
+
+  // Valid cases w/o time zone argument.
+  {
+    const auto year = makeFlatVector<int32_t>({2021, 2021, 2021, 2021, 2021});
+    const auto month = makeFlatVector<int32_t>({7, 7, 7, 7, 7});
+    const auto day = makeFlatVector<int32_t>({11, 11, 11, 11, 11});
+    const auto hour = makeFlatVector<int32_t>({6, 6, 6, 6, 6});
+    const auto minute = makeFlatVector<int32_t>({30, 30, 30, 30, 30});
+    const auto micros = makeNullableFlatVector<int64_t>(
+        {45678000, 1e6, 6e7, 59999999, std::nullopt}, microsType);
+    auto data = makeRowVector({year, month, day, hour, minute, micros});
+
+    setQueryTimeZone("GMT");
+    auto expectedGMT = makeNullableFlatVector<Timestamp>(
+        {parseTimestamp("2021-07-11 06:30:45.678"),
+         parseTimestamp("2021-07-11 06:30:01"),
+         parseTimestamp("2021-07-11 06:31:00"),
+         parseTimestamp("2021-07-11 06:30:59.999999"),
+         std::nullopt});
+    testMakeTimestamp(data, expectedGMT, false);
+    testConstantTimezone(data, "GMT", expectedGMT);
+
+    setQueryTimeZone("Asia/Shanghai");
+    auto expectedSessionTimezone = makeNullableFlatVector<Timestamp>(
+        {parseTimestamp("2021-07-10 22:30:45.678"),
+         parseTimestamp("2021-07-10 22:30:01"),
+         parseTimestamp("2021-07-10 22:31:00"),
+         parseTimestamp("2021-07-10 22:30:59.999999"),
+         std::nullopt});
+    testMakeTimestamp(data, expectedSessionTimezone, false);
+    // Session time zone will be ignored if time zone is specified in argument.
+    testConstantTimezone(data, "GMT", expectedGMT);
+  }
+
+  // Valid cases w/ time zone argument.
+  {
+    setQueryTimeZone("Asia/Shanghai");
+    const auto year = makeFlatVector<int32_t>({2021, 2021, 1});
+    const auto month = makeFlatVector<int32_t>({07, 07, 1});
+    const auto day = makeFlatVector<int32_t>({11, 11, 1});
+    const auto hour = makeFlatVector<int32_t>({6, 6, 1});
+    const auto minute = makeFlatVector<int32_t>({30, 30, 1});
+    const auto micros =
+        makeNullableFlatVector<int64_t>({45678000, 45678000, 1e6}, microsType);
+    const auto timeZone =
+        makeNullableFlatVector<StringView>({"GMT", "CET", std::nullopt});
+    auto data =
+        makeRowVector({year, month, day, hour, minute, micros, timeZone});
+    // Session time zone will be ignored if time zone is specified in argument.
+    auto expected = makeNullableFlatVector<Timestamp>(
+        {parseTimestamp("2021-07-11 06:30:45.678"),
+         parseTimestamp("2021-07-11 04:30:45.678"),
+         std::nullopt});
+    testMakeTimestamp(data, expected, true);
+  }
+}
+
+TEST_F(MakeTimestampTest, errors) {
+  const auto microsType = DECIMAL(16, 6);
+  const auto testInvalidInputs = [&](const RowVectorPtr& data) {
+    std::vector<std::optional<Timestamp>> nullResults(
+        data->size(), std::nullopt);
+    auto expected = makeNullableFlatVector<Timestamp>(nullResults);
+    auto result = evaluate("make_timestamp(c0, c1, c2, c3, c4, c5)", data);
+    facebook::velox::test::assertEqualVectors(expected, result);
+  };
+  std::optional<int32_t> one = 1;
+  const auto testInvalidSeconds = [&](std::optional<int64_t> microsec) {
+    auto result = evaluateOnce<Timestamp>(
+        "make_timestamp(c0, c1, c2, c3, c4, c5)",
+        {INTEGER(), INTEGER(), INTEGER(), INTEGER(), INTEGER(), microsType},
+        one,
+        one,
+        one,
+        one,
+        one,
+        microsec);
+    EXPECT_EQ(result, std::nullopt);
+  };
+  const auto testInvalidArguments = [&](std::optional<int64_t> microsec,
+                                        const TypePtr& microsType) {
+    return evaluateOnce<Timestamp>(
+        "make_timestamp(c0, c1, c2, c3, c4, c5)",
+        {INTEGER(), INTEGER(), INTEGER(), INTEGER(), INTEGER(), microsType},
+        one,
+        one,
+        one,
+        one,
+        one,
+        microsec);
+  };
+
+  // Throw if no session time zone.
+  VELOX_ASSERT_USER_THROW(
+      testInvalidArguments(60007000, DECIMAL(16, 6)),
+      "make_timestamp requires session time zone to be set.");
+
+  setQueryTimeZone("Asia/Shanghai");
+  // Invalid input returns null.
+  const auto year = makeFlatVector<int32_t>(
+      {facebook::velox::util::kMinYear - 1,
+       facebook::velox::util::kMaxYear + 1,
+       1,
+       1,
+       1,
+       1,
+       1,
+       1});
+  const auto month = makeFlatVector<int32_t>({1, 1, 0, 13, 1, 1, 1, 1});
+  const auto day = makeFlatVector<int32_t>({1, 1, 1, 1, 0, 32, 1, 1});
+  const auto hour = makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 25, 1});
+  const auto minute = makeFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 1, 61});
+  const auto micros =
+      makeFlatVector<int64_t>({1, 1, 1, 1, 1, 1, 1, 1}, microsType);
+  auto data = makeRowVector({year, month, day, hour, minute, micros});
+  testInvalidInputs(data);
+
+  // Seconds should be either in the range of [0,59], or 60 with zero
+  // microseconds.
+  testInvalidSeconds(61e6);
+  testInvalidSeconds(99999999);
+  testInvalidSeconds(999999999);
+  testInvalidSeconds(60007000);
+
+  // Throw if data type for microseconds is invalid.
+  VELOX_ASSERT_THROW(
+      testInvalidArguments(1e6, DECIMAL(20, 6)),
+      "Seconds must be short decimal type but got DECIMAL(20, 6)");
+  VELOX_ASSERT_THROW(
+      testInvalidArguments(1e6, DECIMAL(16, 8)),
+      "Scalar function signature is not supported: "
+      "make_timestamp(INTEGER, INTEGER, INTEGER, INTEGER, INTEGER, "
+      "DECIMAL(16, 8)).");
+}
+
+TEST_F(MakeTimestampTest, invalidTimezone) {
+  const auto microsType = DECIMAL(16, 6);
+  const auto year = makeFlatVector<int32_t>({2021, 2021, 2021, 2021, 2021});
+  const auto month = makeFlatVector<int32_t>({7, 7, 7, 7, 7});
+  const auto day = makeFlatVector<int32_t>({11, 11, 11, 11, 11});
+  const auto hour = makeFlatVector<int32_t>({6, 6, 6, -6, 6});
+  const auto minute = makeFlatVector<int32_t>({30, 30, 30, 30, 30});
+  const auto micros = makeNullableFlatVector<int64_t>(
+      {45678000, 1e6, 6e7, 59999999, std::nullopt}, microsType);
+  auto data = makeRowVector({year, month, day, hour, minute, micros});
+
+  // Time zone is not set.
+  VELOX_ASSERT_USER_THROW(
+      evaluate("make_timestamp(c0, c1, c2, c3, c4, c5)", data),
+      "make_timestamp requires session time zone to be set.");
+
+  // Invalid constant time zone.
+  setQueryTimeZone("GMT");
+  for (auto timeZone : {"Invalid", ""}) {
+    SCOPED_TRACE(fmt::format("timezone: {}", timeZone));
+    VELOX_ASSERT_USER_THROW(
+        evaluate(
+            fmt::format(
+                "make_timestamp(c0, c1, c2, c3, c4, c5, '{}')", timeZone),
+            data),
+        fmt::format("Unknown time zone: '{}'", timeZone));
+  }
+
+  // Invalid timezone from vector.
+  auto timeZones = makeFlatVector<StringView>(
+      {"GMT", "CET", "Asia/Shanghai", "Invalid", "GMT"});
+  data = makeRowVector({year, month, day, hour, minute, micros, timeZones});
+  VELOX_ASSERT_USER_THROW(
+      evaluate("make_timestamp(c0, c1, c2, c3, c4, c5, c6)", data),
+      "Unknown time zone: 'Invalid'");
+
+  timeZones =
+      makeFlatVector<StringView>({"GMT", "CET", "Asia/Shanghai", "", "GMT"});
+  data = makeRowVector({year, month, day, hour, minute, micros, timeZones});
+  VELOX_ASSERT_USER_THROW(
+      evaluate("make_timestamp(c0, c1, c2, c3, c4, c5, c6)", data),
+      "Unknown time zone: ''");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/MapTest.cpp b/velox/functions/sparksql/tests/MapTest.cpp
index b8446fff17394..655bdb652b96b 100644
--- a/velox/functions/sparksql/tests/MapTest.cpp
+++ b/velox/functions/sparksql/tests/MapTest.cpp
@@ -14,8 +14,11 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/VeloxException.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+#include "velox/type/Variant.h"
 
 #include <stdint.h>
 
@@ -25,19 +28,20 @@ namespace {
 class MapTest : public SparkFunctionBaseTest {
  protected:
   template <typename K = int64_t, typename V = std::string>
-  void mapSimple(
+  void testMap(
       const std::string& expression,
       const std::vector<VectorPtr>& parameters,
-      bool expectException = false,
-      const VectorPtr& expected = nullptr) {
-    if (expectException) {
-      ASSERT_THROW(
-          evaluate<MapVector>(expression, makeRowVector(parameters)),
-          std::exception);
-    } else {
-      auto result = evaluate<MapVector>(expression, makeRowVector(parameters));
-      ::facebook::velox::test::assertEqualVectors(result, expected);
-    }
+      const VectorPtr& expected) {
+    auto result = evaluate<MapVector>(expression, makeRowVector(parameters));
+    ::facebook::velox::test::assertEqualVectors(expected, result);
+  }
+
+  void testMapFails(
+      const std::string& expression,
+      const std::vector<VectorPtr>& parameters,
+      const std::string errorMsg) {
+    VELOX_ASSERT_USER_THROW(
+        evaluate<MapVector>(expression, makeRowVector(parameters)), errorMsg);
   }
 };
 
@@ -46,7 +50,7 @@ TEST_F(MapTest, Basics) {
   auto inputVector2 = makeNullableFlatVector<int64_t>({4, 5, 6});
   auto mapVector =
       makeMapVector<int64_t, int64_t>({{{1, 4}}, {{2, 5}}, {{3, 6}}});
-  mapSimple("map(c0, c1)", {inputVector1, inputVector2}, false, mapVector);
+  testMap("map(c0, c1)", {inputVector1, inputVector2}, mapVector);
 }
 
 TEST_F(MapTest, Nulls) {
@@ -55,55 +59,169 @@ TEST_F(MapTest, Nulls) {
       makeNullableFlatVector<int64_t>({std::nullopt, 5, std::nullopt});
   auto mapVector = makeMapVector<int64_t, int64_t>(
       {{{1, std::nullopt}}, {{2, 5}}, {{3, std::nullopt}}});
-  mapSimple("map(c0, c1)", {inputVector1, inputVector2}, false, mapVector);
+  testMap("map(c0, c1)", {inputVector1, inputVector2}, mapVector);
 }
 
-TEST_F(MapTest, DifferentTypes) {
+TEST_F(MapTest, differentTypes) {
   auto inputVector1 = makeNullableFlatVector<int64_t>({1, 2, 3});
   auto inputVector2 = makeNullableFlatVector<double>({4.0, 5.0, 6.0});
   auto mapVector =
       makeMapVector<int64_t, double>({{{1, 4.0}}, {{2, 5.0}}, {{3, 6.0}}});
-  mapSimple("map(c0, c1)", {inputVector1, inputVector2}, false, mapVector);
+  testMap("map(c0, c1)", {inputVector1, inputVector2}, mapVector);
 }
 
 TEST_F(MapTest, boolType) {
   auto inputVector1 = makeNullableFlatVector<bool>({1, 1, 0});
   auto inputVector2 = makeNullableFlatVector<bool>({0, 0, 1});
   auto mapVector = makeMapVector<bool, bool>({{{1, 0}}, {{1, 0}}, {{0, 1}}});
-  mapSimple("map(c0, c1)", {inputVector1, inputVector2}, false, mapVector);
+  testMap("map(c0, c1)", {inputVector1, inputVector2}, mapVector);
 }
 
-TEST_F(MapTest, Wide) {
+TEST_F(MapTest, wide) {
   auto inputVector1 = makeNullableFlatVector<int64_t>({1, 2, 3});
   auto inputVector2 = makeNullableFlatVector<double>({4.0, 5.0, 6.0});
   auto inputVector11 = makeNullableFlatVector<int64_t>({10, 20, 30});
   auto inputVector22 = makeNullableFlatVector<double>({4.1, 5.1, 6.1});
   auto mapVector = makeMapVector<int64_t, double>(
       {{{1, 4.0}, {10, 4.1}}, {{2, 5.0}, {20, 5.1}}, {{3, 6.0}, {30, 6.1}}});
-  mapSimple(
+  testMap(
       "map(c0, c1, c2, c3)",
       {inputVector1, inputVector2, inputVector11, inputVector22},
-      false,
       mapVector);
 }
 
-TEST_F(MapTest, ErrorCases) {
+TEST_F(MapTest, errorCases) {
+  auto inputVectorInt64 = makeNullableFlatVector<int64_t>({1, 2, 3});
+  auto inputVectorDouble = makeNullableFlatVector<double>({4.0, 5.0, 6.0});
+  auto nullInputVector = makeNullableFlatVector<int64_t>({1, std::nullopt, 3});
+
   // Number of args
-  auto inputVector1 = makeNullableFlatVector<int64_t>({1, 2, 3});
-  auto inputVector2 = makeNullableFlatVector<double>({4.0, 5.0, 6.0});
-  auto mapVector =
-      makeMapVector<int64_t, double>({{{1, 4.0}}, {{2, 5.0}}, {{3, 6.0}}});
-  mapSimple("map(c0)", {inputVector1}, true);
-  mapSimple(
-      "map(c0, c1, c2)", {inputVector1, inputVector2, inputVector1}, true);
+  testMapFails(
+      "map(c0)",
+      {inputVectorInt64},
+      "Scalar function signature is not supported: map(BIGINT)");
+  testMapFails(
+      "map(c0, c1, c2)",
+      {inputVectorInt64, inputVectorDouble, inputVectorInt64},
+      "Scalar function signature is not supported: map(BIGINT, DOUBLE, BIGINT)");
+
+  testMapFails(
+      "map(c0, c1, c2, c3, c4, c5, c6, c7)",
+      {inputVectorDouble,
+       inputVectorDouble,
+       inputVectorDouble,
+       inputVectorDouble,
+       inputVectorDouble,
+       inputVectorDouble,
+       inputVectorDouble,
+       inputVectorDouble},
+      "Scalar function signature is not supported: map(DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE)");
 
   // Types of args
-  auto inputVector11 = makeNullableFlatVector<double>({10.0, 20.0, 30.0});
-  auto inputVector22 = makeNullableFlatVector<double>({4.1, 5.1, 6.1});
-  mapSimple(
+  testMapFails(
       "map(c0, c1, c2, c3)",
-      {inputVector1, inputVector2, inputVector11, inputVector22},
-      true);
+      {inputVectorInt64,
+       inputVectorDouble,
+       inputVectorDouble,
+       inputVectorDouble},
+      "Scalar function signature is not supported: map(BIGINT, DOUBLE, DOUBLE, DOUBLE)");
+  testMapFails(
+      "map(c0, c1, c2, c3)",
+      {inputVectorDouble,
+       inputVectorInt64,
+       inputVectorDouble,
+       inputVectorDouble},
+      "Scalar function signature is not supported: map(DOUBLE, BIGINT, DOUBLE, DOUBLE)");
+
+  testMapFails(
+      "map(c0, c1)",
+      {nullInputVector, inputVectorDouble},
+      "Cannot use null as map key");
+}
+
+TEST_F(MapTest, complexTypes) {
+  auto makeSingleMapVector = [&](const VectorPtr& keyVector,
+                                 const VectorPtr& valueVector) {
+    return makeMapVector(
+        {
+            0,
+        },
+        keyVector,
+        valueVector);
+  };
+
+  auto makeSingleRowVector = [&](vector_size_t size = 1,
+                                 vector_size_t base = 0) {
+    return makeRowVector({
+        makeFlatVector<int64_t>(size, [&](auto row) { return row + base; }),
+    });
+  };
+
+  auto testSingleMap = [&](const VectorPtr& keyVector,
+                           const VectorPtr& valueVector) {
+    testMap(
+        "map(c0, c1)",
+        {keyVector, valueVector},
+        makeSingleMapVector(keyVector, valueVector));
+  };
+
+  auto arrayKey = makeArrayVectorFromJson<int64_t>({"[1, 2, 3]"});
+  auto arrayValue = makeArrayVectorFromJson<int64_t>({"[1, 3, 5]"});
+  auto nullArrayValue = makeArrayVectorFromJson<int64_t>({"null"});
+
+  testSingleMap(makeSingleRowVector(), makeSingleRowVector(1, 2));
+
+  testSingleMap(arrayKey, arrayValue);
+
+  testSingleMap(
+      makeSingleMapVector(makeSingleRowVector(), makeSingleRowVector(1, 3)),
+      makeSingleMapVector(makeSingleRowVector(), makeSingleRowVector(1, 2)));
+
+  testSingleMap(
+      makeSingleMapVector(
+          makeSingleMapVector(makeSingleRowVector(), makeSingleRowVector()),
+          makeSingleRowVector()),
+      makeSingleMapVector(
+          arrayKey,
+          makeSingleMapVector(makeSingleRowVector(), makeSingleRowVector())));
+
+  testSingleMap(arrayKey, nullArrayValue);
+
+  auto mixedArrayKey1 = makeArrayVector<int64_t>({{1, 2, 3}});
+  auto mixedRowValue1 = makeSingleRowVector();
+  auto mixedArrayKey2 = makeArrayVector<int64_t>({{4, 5}});
+  auto mixedRowValue2 = makeSingleRowVector(1, 1);
+  auto mixedMapResult = makeSingleMapVector(
+      makeArrayVector<int64_t>({{1, 2, 3}, {4, 5}}), makeSingleRowVector(2, 0));
+  testMap(
+      "map(c0, c1, c2, c3)",
+      {mixedArrayKey1, mixedRowValue1, mixedArrayKey2, mixedRowValue2},
+      mixedMapResult);
+
+  auto arrayMapResult1 = makeMapVector(
+      {
+          0,
+          1,
+      },
+      makeArrayVector<int64_t>({{1, 2, 3}, {7, 9}}),
+      makeArrayVector<int64_t>({{1, 2}, {4, 6}}));
+  testMap(
+      "map(c0, c1)",
+      {makeArrayVector<int64_t>({{1, 2, 3}, {7, 9}}),
+       makeArrayVector<int64_t>({{1, 2}, {4, 6}})},
+      arrayMapResult1);
+}
+
+TEST_F(MapTest, resultSize) {
+  auto condition = makeFlatVector<int64_t>({1, 2, 3});
+  auto keys = makeFlatVector<int64_t>({3, 2, 1});
+  auto values = makeFlatVector<int64_t>({4, 5, 6});
+  auto mapVector =
+      makeMapVector<int64_t, int64_t>({{{4, 3}}, {{5, 2}}, {{1, 6}}});
+  testMap(
+      "if(greaterthan(c2, 2), map(c0, c1), map(c1, c0))",
+      {keys, values, condition},
+      mapVector);
 }
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/MaskTest.cpp b/velox/functions/sparksql/tests/MaskTest.cpp
new file mode 100644
index 0000000000000..cd5b6179a42fd
--- /dev/null
+++ b/velox/functions/sparksql/tests/MaskTest.cpp
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class MaskTest : public SparkFunctionBaseTest {
+ protected:
+  std::optional<std::string> maskWithOneArg(
+      const std::optional<std::string>& srcStr) {
+    return evaluateOnce<std::string>("mask(c0)", srcStr);
+  };
+
+  std::optional<std::string> maskWithTwoArg(
+      const std::optional<std::string>& srcStr,
+      const std::optional<std::string>& upperChar) {
+    return evaluateOnce<std::string>("mask(c0, c1)", srcStr, upperChar);
+  };
+
+  std::optional<std::string> maskWithThreeArg(
+      const std::optional<std::string>& srcStr,
+      const std::optional<std::string>& upperChar,
+      const std::optional<std::string>& lowerChar) {
+    return evaluateOnce<std::string>(
+        "mask(c0, c1, c2)", srcStr, upperChar, lowerChar);
+  };
+
+  std::optional<std::string> maskWithFourArg(
+      const std::optional<std::string>& srcStr,
+      const std::optional<std::string>& upperChar,
+      const std::optional<std::string>& lowerChar,
+      const std::optional<std::string>& digitChar) {
+    return evaluateOnce<std::string>(
+        "mask(c0, c1, c2, c3)", srcStr, upperChar, lowerChar, digitChar);
+  };
+
+  std::optional<std::string> maskWithFiveArg(
+      const std::optional<std::string>& srcStr,
+      const std::optional<std::string>& upperChar,
+      const std::optional<std::string>& lowerChar,
+      const std::optional<std::string>& digitChar,
+      const std::optional<std::string>& otherChar) {
+    return evaluateOnce<std::string>(
+        "mask(c0, c1, c2, c3, c4)",
+        srcStr,
+        upperChar,
+        lowerChar,
+        digitChar,
+        otherChar);
+  };
+};
+
+TEST_F(MaskTest, mask) {
+  std::string upperChar = "Y";
+  std::string lowerChar = "y";
+  std::string digitChar = "d";
+  std::string otherChar = "*";
+
+  EXPECT_EQ(maskWithOneArg("AbCD123-@$#"), "XxXXnnn-@$#");
+  EXPECT_EQ(maskWithOneArg("abcd-EFGH-8765-4321"), "xxxx-XXXX-nnnn-nnnn");
+  EXPECT_EQ(maskWithOneArg(std::nullopt), std::nullopt);
+  EXPECT_EQ(maskWithOneArg(""), "");
+  // Case to cover unicode characters.
+  EXPECT_EQ(maskWithOneArg("синяяい绿AbCD123世界🙂"), "xxxxxい绿XxXXnnn世界🙂");
+  // Case to cover invalid UTF-8 characters.
+  EXPECT_EQ(maskWithOneArg("\xED\xA0\x80"), "\xED\xA0\x80");
+  EXPECT_EQ(maskWithOneArg("Abc-\xED\xA0\x80@123"), "Xxx-\xED\xA0\x80@nnn");
+
+  EXPECT_EQ(maskWithTwoArg("AbCD123-@$#", upperChar), "YxYYnnn-@$#");
+  EXPECT_EQ(
+      maskWithTwoArg("abcd-EFGH-8765-4321", upperChar), "xxxx-YYYY-nnnn-nnnn");
+  EXPECT_EQ(maskWithTwoArg(std::nullopt, upperChar), std::nullopt);
+  EXPECT_EQ(maskWithTwoArg("", upperChar), "");
+  // Case to cover unicode characters.
+  EXPECT_EQ(
+      maskWithTwoArg("синяяい绿AbCD123世界🙂", upperChar),
+      "xxxxxい绿YxYYnnn世界🙂");
+  // Case to cover invalid UTF-8 characters.
+  EXPECT_EQ(
+      maskWithTwoArg("Abc-\xED\xA0\x80@123", upperChar),
+      "Yxx-\xED\xA0\x80@nnn");
+  EXPECT_EQ(maskWithTwoArg("AbCD123-@$#", std::nullopt), "AxCDnnn-@$#");
+  EXPECT_EQ(
+      maskWithTwoArg("abcd-EFGH-8765-4321", std::nullopt),
+      "xxxx-EFGH-nnnn-nnnn");
+
+  EXPECT_EQ(
+      maskWithThreeArg("AbCD123-@$#", upperChar, lowerChar), "YyYYnnn-@$#");
+  EXPECT_EQ(
+      maskWithThreeArg("abcd-EFGH-8765-4321", upperChar, lowerChar),
+      "yyyy-YYYY-nnnn-nnnn");
+  EXPECT_EQ(maskWithThreeArg(std::nullopt, upperChar, lowerChar), std::nullopt);
+  EXPECT_EQ(maskWithThreeArg("", upperChar, lowerChar), "");
+  // Case to cover unicode characters.
+  EXPECT_EQ(
+      maskWithThreeArg("синяяい绿AbCD123世界🙂", upperChar, lowerChar),
+      "yyyyyい绿YyYYnnn世界🙂");
+  // Case to cover invalid UTF-8 characters.
+  EXPECT_EQ(
+      maskWithThreeArg("Abc-\xED\xA0\x80@123", upperChar, lowerChar),
+      "Yyy-\xED\xA0\x80@nnn");
+  EXPECT_EQ(
+      maskWithThreeArg("AbCD123-@$#", upperChar, std::nullopt), "YbYYnnn-@$#");
+  EXPECT_EQ(
+      maskWithThreeArg("abcd-EFGH-8765-4321", std::nullopt, lowerChar),
+      "yyyy-EFGH-nnnn-nnnn");
+  EXPECT_EQ(
+      maskWithThreeArg("AbCD123-@$#", std::nullopt, std::nullopt),
+      "AbCDnnn-@$#");
+
+  EXPECT_EQ(
+      maskWithFourArg("AbCD123-@$#", upperChar, lowerChar, digitChar),
+      "YyYYddd-@$#");
+  EXPECT_EQ(
+      maskWithFourArg("abcd-EFGH-8765-4321", upperChar, lowerChar, digitChar),
+      "yyyy-YYYY-dddd-dddd");
+  EXPECT_EQ(
+      maskWithFourArg(std::nullopt, upperChar, lowerChar, digitChar),
+      std::nullopt);
+  EXPECT_EQ(maskWithFourArg("", upperChar, lowerChar, digitChar), "");
+  // Case to cover unicode characters.
+  EXPECT_EQ(
+      maskWithFourArg(
+          "синяяい绿AbCD123世界🙂", upperChar, lowerChar, digitChar),
+      "yyyyyい绿YyYYddd世界🙂");
+  // Case to cover invalid UTF-8 characters.
+  EXPECT_EQ(
+      maskWithFourArg("Abc-\xED\xA0\x80@123", upperChar, lowerChar, digitChar),
+      "Yyy-\xED\xA0\x80@ddd");
+  EXPECT_EQ(
+      maskWithFourArg("AbCD123-@$#", std::nullopt, lowerChar, digitChar),
+      "AyCDddd-@$#");
+  EXPECT_EQ(
+      maskWithFourArg("AbCD123-@$#", upperChar, std::nullopt, digitChar),
+      "YbYYddd-@$#");
+  EXPECT_EQ(
+      maskWithFourArg("AbCD123-@$#", upperChar, lowerChar, std::nullopt),
+      "YyYY123-@$#");
+  EXPECT_EQ(
+      maskWithFourArg("AbCD123-@$#", upperChar, std::nullopt, std::nullopt),
+      "YbYY123-@$#");
+  EXPECT_EQ(
+      maskWithFourArg("AbCD123-@$#", std::nullopt, lowerChar, std::nullopt),
+      "AyCD123-@$#");
+  EXPECT_EQ(
+      maskWithFourArg("AbCD123-@$#", std::nullopt, std::nullopt, digitChar),
+      "AbCDddd-@$#");
+  EXPECT_EQ(
+      maskWithFourArg("AbCD123-@$#", std::nullopt, std::nullopt, std::nullopt),
+      "AbCD123-@$#");
+
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", upperChar, lowerChar, digitChar, otherChar),
+      "YyYYddd****");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "abcd-EFGH-8765-4321", upperChar, lowerChar, digitChar, otherChar),
+      "yyyy*YYYY*dddd*dddd");
+  EXPECT_EQ(
+      maskWithFiveArg(std::nullopt, upperChar, lowerChar, digitChar, otherChar),
+      std::nullopt);
+  EXPECT_EQ(
+      maskWithFiveArg("", upperChar, lowerChar, digitChar, otherChar), "");
+  // Case to cover unicode characters.
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "синяяい绿AbCD123世界🙂", upperChar, lowerChar, digitChar, otherChar),
+      "yyyyy**YyYYddd***");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "синяяい绿AbCD123世界🙂", upperChar, lowerChar, digitChar, "い"),
+      "yyyyyいいYyYYdddいいい");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "синяяい绿AbCD123世界🙂", upperChar, lowerChar, digitChar, "🚀"),
+      "yyyyy🚀🚀YyYYddd🚀🚀🚀");
+  // Case to cover invalid UTF-8 characters.
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "\xED\xA0\x80", upperChar, lowerChar, digitChar, otherChar),
+      "***");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "Abc-\xED\xA0\x80@123", upperChar, lowerChar, digitChar, otherChar),
+      "Yyy*****ddd");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", std::nullopt, lowerChar, digitChar, otherChar),
+      "AyCDddd****");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", upperChar, std::nullopt, digitChar, otherChar),
+      "YbYYddd****");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", upperChar, lowerChar, std::nullopt, otherChar),
+      "YyYY123****");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", upperChar, lowerChar, digitChar, std::nullopt),
+      "YyYYddd-@$#");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", std::nullopt, lowerChar, digitChar, std::nullopt),
+      "AyCDddd-@$#");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", upperChar, std::nullopt, digitChar, std::nullopt),
+      "YbYYddd-@$#");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", upperChar, lowerChar, std::nullopt, std::nullopt),
+      "YyYY123-@$#");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", std::nullopt, std::nullopt, digitChar, otherChar),
+      "AbCDddd****");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", std::nullopt, lowerChar, std::nullopt, otherChar),
+      "AyCD123****");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", upperChar, std::nullopt, std::nullopt, otherChar),
+      "YbYY123****");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", std::nullopt, std::nullopt, std::nullopt, otherChar),
+      "AbCD123****");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", upperChar, std::nullopt, std::nullopt, std::nullopt),
+      "YbYY123-@$#");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", std::nullopt, lowerChar, std::nullopt, std::nullopt),
+      "AyCD123-@$#");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#", std::nullopt, std::nullopt, digitChar, std::nullopt),
+      "AbCDddd-@$#");
+  EXPECT_EQ(
+      maskWithFiveArg(
+          "AbCD123-@$#",
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt),
+      "AbCD123-@$#");
+
+  // Case to cover input is ASCII but replacement character is wide-character.
+  EXPECT_EQ(maskWithThreeArg("ABCabc", "🚀", "🚀"), "🚀🚀🚀🚀🚀🚀");
+}
+
+TEST_F(MaskTest, maskWithError) {
+  std::string upperChar = "Y";
+  std::string lowerChar = "y";
+  std::string digitChar = "d";
+  std::string otherChar = "*";
+  VELOX_ASSERT_USER_THROW(
+      maskWithFiveArg("AbCD123-@$#", "", lowerChar, digitChar, otherChar),
+      "Replacement string must contain a single character and cannot be empty.");
+
+  VELOX_ASSERT_USER_THROW(
+      maskWithFiveArg("AbCD123-@$#", "🚀🚀", lowerChar, digitChar, otherChar),
+      "Replacement string must contain a single character and cannot be empty.");
+
+  VELOX_ASSERT_USER_THROW(
+      maskWithFiveArg("AbCD123-@$#", upperChar, "", digitChar, otherChar),
+      "Replacement string must contain a single character and cannot be empty.");
+
+  VELOX_ASSERT_USER_THROW(
+      maskWithFiveArg("AbCD123-@$#", upperChar, lowerChar, "", otherChar),
+      "Replacement string must contain a single character and cannot be empty.");
+
+  VELOX_ASSERT_USER_THROW(
+      maskWithFiveArg("AbCD123-@$#", upperChar, lowerChar, digitChar, ""),
+      "Replacement string must contain a single character and cannot be empty.");
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/MonotonicallyIncreasingIdTest.cpp b/velox/functions/sparksql/tests/MonotonicallyIncreasingIdTest.cpp
new file mode 100644
index 0000000000000..ede2b55ff8a07
--- /dev/null
+++ b/velox/functions/sparksql/tests/MonotonicallyIncreasingIdTest.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class MonotonicallyIncreasingIdTest : public SparkFunctionBaseTest {
+ protected:
+  void testMonotonicallyIncreasingId(
+      int32_t partitionId,
+      int32_t vectorSize,
+      const std::vector<int64_t>& expected) {
+    setSparkPartitionId(partitionId);
+    auto result = evaluate(
+        "monotonically_increasing_id()", makeRowVector(ROW({}), vectorSize));
+    ASSERT_FALSE(result->isConstantEncoding());
+    velox::test::assertEqualVectors(
+        {makeFlatVector<int64_t>(expected)}, result);
+  }
+};
+
+TEST_F(MonotonicallyIncreasingIdTest, basic) {
+  testMonotonicallyIncreasingId(0, 1, {0});
+  testMonotonicallyIncreasingId(2, 2, {17179869184, 17179869185});
+  testMonotonicallyIncreasingId(5, 3, {42949672960, 42949672961, 42949672962});
+  testMonotonicallyIncreasingId(
+      100, 4, {858993459200, 858993459201, 858993459202, 858993459203});
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/RaiseErrorTest.cpp b/velox/functions/sparksql/tests/RaiseErrorTest.cpp
new file mode 100644
index 0000000000000..716428a8d962f
--- /dev/null
+++ b/velox/functions/sparksql/tests/RaiseErrorTest.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class RaiseErrorTest : public SparkFunctionBaseTest {
+ protected:
+  void raiseError(const std::optional<std::string>& message) {
+    evaluateOnce<UnknownValue>("raise_error(c0)", message);
+  }
+};
+
+TEST_F(RaiseErrorTest, basic) {
+  VELOX_ASSERT_USER_THROW(raiseError(""), "");
+  VELOX_ASSERT_USER_THROW(raiseError("0 > 1 is not true"), "0 > 1 is not true");
+  VELOX_ASSERT_USER_THROW(raiseError(std::nullopt), "");
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/RandTest.cpp b/velox/functions/sparksql/tests/RandTest.cpp
index cbb49476c8ff9..52010edfd8756 100644
--- a/velox/functions/sparksql/tests/RandTest.cpp
+++ b/velox/functions/sparksql/tests/RandTest.cpp
@@ -27,24 +27,25 @@ class RandTest : public SparkFunctionBaseTest {
 
  protected:
   std::optional<double> rand(int32_t seed, int32_t partitionIndex = 0) {
+    setSparkPartitionId(partitionIndex);
     return evaluateOnce<double>(
-        fmt::format("rand({}, {})", seed, partitionIndex),
-        makeRowVector(ROW({}), 1));
+        fmt::format("rand({})", seed), makeRowVector(ROW({}), 1));
   }
 
   std::optional<double> randWithNullSeed(int32_t partitionIndex = 0) {
-    return evaluateOnce<double>(
-        fmt::format("rand(NULL, {})", partitionIndex),
-        makeRowVector(ROW({}), 1));
+    setSparkPartitionId(partitionIndex);
+    std::optional<int32_t> seed = std::nullopt;
+    return evaluateOnce<double>("rand(c0)", seed);
   }
 
   std::optional<double> randWithNoSeed() {
+    setSparkPartitionId(0);
     return evaluateOnce<double>("rand()", makeRowVector(ROW({}), 1));
   }
 
   VectorPtr randWithBatchInput(int32_t seed, int32_t partitionIndex = 0) {
-    auto exprSet = compileExpression(
-        fmt::format("rand({}, {})", seed, partitionIndex), ROW({}));
+    setSparkPartitionId(partitionIndex);
+    auto exprSet = compileExpression(fmt::format("rand({})", seed), ROW({}));
     return evaluate(*exprSet, makeRowVector(ROW({}), 20));
   }
 
@@ -92,6 +93,7 @@ TEST_F(RandTest, withSeed) {
 
   // Test with batch input.
   auto batchResult1 = randWithBatchInput(100);
+  ASSERT_FALSE(batchResult1->isConstantEncoding());
   auto batchResult2 = randWithBatchInput(100);
   // Same seed & partition index produce same results.
   velox::test::assertEqualVectors(batchResult1, batchResult2);
diff --git a/velox/functions/sparksql/tests/RegexFunctionsTest.cpp b/velox/functions/sparksql/tests/RegexFunctionsTest.cpp
index dfffc8d0f0116..35bd63bfbe57b 100644
--- a/velox/functions/sparksql/tests/RegexFunctionsTest.cpp
+++ b/velox/functions/sparksql/tests/RegexFunctionsTest.cpp
@@ -20,15 +20,26 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/lib/Re2Functions.h"
 #include "velox/functions/sparksql/RegexFunctions.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 
 namespace facebook::velox::functions::sparksql {
+
+using namespace facebook::velox::test;
 namespace {
 
 class RegexFunctionsTest : public test::SparkFunctionBaseTest {
  public:
+  void SetUp() override {
+    SparkFunctionBaseTest::SetUp();
+    // For parsing literal integers as INTEGER, not BIGINT,
+    // required by regexp_replace because its position argument
+    // is INTEGER.
+    options_.parseIntegerAsBigint = false;
+  }
+
   std::optional<bool> rlike(
       std::optional<std::string> str,
       std::string pattern) {
@@ -41,18 +52,129 @@ class RegexFunctionsTest : public test::SparkFunctionBaseTest {
     return evaluateOnce<std::string>(
         fmt::format("regexp_extract(c0, '{}')", pattern), str);
   }
+
+  std::string testRegexpReplace(
+      const std::optional<std::string>& input,
+      const std::string& pattern,
+      const std::string& replace,
+      std::optional<int32_t> position = std::nullopt) {
+    auto result = [&] {
+      if (!position) {
+        return evaluateOnce<std::string>(
+            fmt::format("regexp_replace(c0, '{}', '{}')", pattern, replace),
+            input);
+      } else {
+        return evaluateOnce<std::string>(
+            fmt::format(
+                "regexp_replace(c0, '{}', '{}', {})",
+                pattern,
+                replace,
+                position.value()),
+            input);
+      }
+    }();
+    return result.has_value() ? result.value() : "";
+  }
+
+  std::shared_ptr<facebook::velox::SimpleVector<facebook::velox::StringView>>
+  testingRegexpReplaceRows(
+      const std::vector<std::string>& input,
+      const std::vector<std::string>& pattern,
+      const std::vector<std::string>& replace,
+      const std::optional<std::vector<int32_t>>& position = std::nullopt,
+      int repeatCount = 1) {
+    EXPECT_GT(repeatCount, 0);
+
+    // Repeat the inputs to allow for testing very large dataframes.
+    std::vector<std::string> repeatedInput = repeatVector(input, repeatCount);
+    std::vector<std::string> repeatedPattern =
+        repeatVector(pattern, repeatCount);
+    std::vector<std::string> repeatedReplace =
+        repeatVector(replace, repeatCount);
+    std::vector<int32_t> repeatedPosition = position.has_value()
+        ? repeatVector(*position, repeatCount)
+        : std::vector<int32_t>();
+
+    auto inputStringVector = makeFlatVector<std::string>(repeatedInput);
+    auto patternStringVector = makeFlatVector<std::string>(repeatedPattern);
+    auto replaceStringVector = makeFlatVector<std::string>(repeatedReplace);
+    auto positionIntVector = makeFlatVector<int32_t>(repeatedPosition);
+
+    std::shared_ptr<SimpleVector<StringView>> result;
+    if (position) {
+      result = evaluate<SimpleVector<StringView>>(
+          "regexp_replace(c0, c1, c2, c3)",
+          makeRowVector(
+              {inputStringVector,
+               patternStringVector,
+               replaceStringVector,
+               positionIntVector}));
+    } else {
+      result = evaluate<SimpleVector<StringView>>(
+          "regexp_replace(c0, c1, c2)",
+          makeRowVector(
+              {inputStringVector, patternStringVector, replaceStringVector}));
+    }
+    return result;
+  }
+
+  std::shared_ptr<facebook::velox::SimpleVector<facebook::velox::StringView>>
+  testingRegexpReplaceConstantPattern(
+      const std::vector<std::string>& input,
+      const std::string& pattern,
+      const std::vector<std::string>& replace,
+      const std::optional<std::vector<int32_t>>& position = std::nullopt) {
+    auto inputStringVector = makeFlatVector<std::string>(input);
+    auto replaceStringVector = makeFlatVector<std::string>(replace);
+
+    std::shared_ptr<SimpleVector<StringView>> result;
+    if (position) {
+      auto positionIntVector = makeFlatVector<int32_t>(*position);
+
+      result = evaluate<SimpleVector<StringView>>(
+          fmt::format("regexp_replace(c0, '{}', c1, c2)", pattern),
+          makeRowVector(
+              {inputStringVector, replaceStringVector, positionIntVector}));
+    } else {
+      result = evaluate<SimpleVector<StringView>>(
+          fmt::format("regexp_replace(c0, '{}', c1)", pattern),
+          makeRowVector({inputStringVector, replaceStringVector}));
+    }
+    return result;
+  }
+
+  template <typename T>
+  std::vector<T> repeatVector(const std::vector<T>& vec, int repeatCount) {
+    std::vector<T> result(vec.size() * repeatCount);
+    for (int i = 0; i < repeatCount; ++i) {
+      std::copy(vec.begin(), vec.end(), result.begin() + i * vec.size());
+    }
+    return result;
+  }
+
+  std::shared_ptr<facebook::velox::FlatVector<facebook::velox::StringView>>
+  convertOutput(const std::vector<std::string>& output, size_t repeatCount) {
+    std::vector<std::optional<facebook::velox::StringView>> repeatedOutput(
+        output.size() * repeatCount);
+
+    using StringView = facebook::velox::StringView;
+
+    for (size_t i = 0; i < repeatCount; ++i) {
+      for (size_t j = 0; j < output.size(); ++j) {
+        repeatedOutput[i * output.size() + j] = !output[j].empty()
+            ? std::optional<StringView>(output[j])
+            : std::nullopt;
+      }
+    }
+
+    return makeNullableFlatVector(repeatedOutput);
+  }
 };
 
 // A list of known incompatibilities with java.util.regex. Most result in an
 // error being thrown; some unsupported character class features result in
 // different results.
-TEST_F(RegexFunctionsTest, JavaRegexIncompatibilities) {
-  // Character class union is not supported; parsed as [a\[b]\].
-  EXPECT_THROW(rlike("[]", R"([a[b]])"), VeloxUserError);
-  // Character class intersection not supported; parsed as [a&\[b]\].
-  EXPECT_THROW(rlike("&]", R"([a&&[b]])"), VeloxUserError);
-  // Character class difference not supported; parsed as [\w&\[\^b]\].
-  EXPECT_THROW(rlike("^]", R"([\w&&[^b]])"), VeloxUserError);
+TEST_F(RegexFunctionsTest, javaRegexIncompatibilities) {
   // Unsupported character classes.
   EXPECT_THROW(rlike(" ", "\\h"), VeloxUserError);
   EXPECT_THROW(rlike(" ", "\\H"), VeloxUserError);
@@ -83,7 +205,7 @@ TEST_F(RegexFunctionsTest, JavaRegexIncompatibilities) {
   EXPECT_THROW(rlike(" ", "(?<! )"), VeloxUserError);
 }
 
-TEST_F(RegexFunctionsTest, AllowSimpleConstantRegex) {
+TEST_F(RegexFunctionsTest, allowSimpleConstantRegex) {
   // rlike returns std::optional<bool>; EXPECT_TRUE would check for non-null,
   // not check the result.
   EXPECT_EQ(rlike("a", "a*"), true);
@@ -93,23 +215,376 @@ TEST_F(RegexFunctionsTest, AllowSimpleConstantRegex) {
   EXPECT_EQ(rlike(std::nullopt, "a*"), std::nullopt);
 }
 
-TEST_F(RegexFunctionsTest, BlockUnsupportedEdgeCases) {
+TEST_F(RegexFunctionsTest, blockUnsupportedEdgeCases) {
   // Non-constant pattern.
   EXPECT_THROW(
       evaluateOnce<bool>("rlike('a', c0)", std::optional<std::string>("a*")),
       VeloxUserError);
-  // Unsupported set union syntax.
-  EXPECT_THROW(rlike("", "[a[b]]"), VeloxUserError);
 }
 
-TEST_F(RegexFunctionsTest, RegexMatchRegistration) {
+TEST_F(RegexFunctionsTest, regexMatchRegistration) {
   EXPECT_THROW(
       evaluateOnce<std::string>(
           "regexp_extract('a', c0)", std::optional<std::string>("a*")),
       VeloxUserError);
   EXPECT_EQ(regexp_extract("abc", "a."), "ab");
-  EXPECT_THROW(regexp_extract("[]", "[a[b]]"), VeloxUserError);
 }
 
+TEST_F(RegexFunctionsTest, regexpReplaceRegistration) {
+  std::string output = "teeheebc";
+  auto result = testRegexpReplace("abc", "a", "teehee");
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceEmptyString) {
+  std::string output = "";
+  auto result = testRegexpReplace("", "empty string", "nothing");
+  EXPECT_EQ(result, output);
+  output = "abc";
+  result = testRegexpReplace("", "", "abc");
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceSimple) {
+  std::string output = "HeLLo WorLd";
+  auto result = testRegexpReplace("Hello World", "l", "L");
+  EXPECT_EQ(result, output);
+}
+TEST_F(RegexFunctionsTest, badUTF8) {
+  std::string badUTF = "\xF0\x82\x82\xAC";
+  std::string badHalf = "\xF0\x82";
+  std::string overlongA = "\xC1\x81"; // 'A' should not be encoded like this.
+  std::string invalidCodePoint =
+      "\xED\xA0\x80"; // Start of the surrogate pair range in UTF-8
+  std::string incompleteSequence = "\xC3"; // Missing the continuation byte.
+  std::string illegalContinuation =
+      "\x80"; // This is a continuation byte without a start.
+  std::string unexpectedContinuation =
+      "\xE0\x80\x80\x80"; // Too many continuation bytes.
+
+  VELOX_ASSERT_THROW(
+      testingRegexpReplaceRows({badUTF}, {badHalf}, {"Bad"}), "invalid UTF-8");
+  VELOX_ASSERT_THROW(
+      testingRegexpReplaceRows({overlongA}, {badHalf}, {"Bad"}),
+      "invalid UTF-8");
+  VELOX_ASSERT_THROW(
+      testingRegexpReplaceRows({invalidCodePoint}, {badHalf}, {"Bad"}),
+      "invalid UTF-8");
+  VELOX_ASSERT_THROW(
+      testingRegexpReplaceRows({incompleteSequence}, {badHalf}, {"Bad"}),
+      "invalid UTF-8");
+  VELOX_ASSERT_THROW(
+      testingRegexpReplaceRows({illegalContinuation}, {badHalf}, {"Bad"}),
+      "invalid UTF-8");
+  VELOX_ASSERT_THROW(
+      testingRegexpReplaceRows({unexpectedContinuation}, {badHalf}, {"Bad"}),
+      "invalid UTF-8");
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceSimplePosition) {
+  std::string output = "Hello WorLd";
+  auto result = testRegexpReplace("Hello World", "l", "L", {6});
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceNonAscii) {
+  std::string output = "♫ Resume is updated!♫ ";
+  auto result = testRegexpReplace("♫ Resume is updated¡♫ ", "¡", "!");
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceNonAsciiPositionNoChange) {
+  std::string output = "♫ Resume is updated¡♫ Some padding";
+  auto result =
+      testRegexpReplace("♫ Resume is updated¡♫ Some padding", "¡", "!", {21});
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceNonAsciiPositionWithChange) {
+  std::string output = "♫ Resume is updated!♫ Some padding";
+  auto result =
+      testRegexpReplace("♫ Resume is updated¡♫ Some padding", "¡", "!", {20});
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceMatchSparkSqlTestSimple) {
+  std::vector<int32_t> positions = {1, 1, 1};
+  const std::vector<std::string> outputVector = {"300", "400", "400-400"};
+  auto result = testingRegexpReplaceRows(
+      {"100-200", "100-200", "100-200"},
+      {"(\\d+)-(\\d+)", "(\\d+)-(\\d+)", "(\\d+)"},
+      {"300", "400", "400"},
+      positions);
+  auto output = convertOutput({"300", "400", "400-400"}, 1);
+  assertEqualVectors(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceWithEmptyString) {
+  std::string output = "bc";
+  auto result = testRegexpReplace("abc", "a", "");
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplacePosition) {
+  std::string output1 = "abc";
+  std::string output2 = "bc";
+  std::string output3 = "aaaaa";
+  auto result1 = testRegexpReplace("abca", "a", "", {2});
+  auto result2 = testRegexpReplace("abca", "a", "", {1});
+  auto result3 = testRegexpReplace("abca", "bc", "aaa", {1});
+  EXPECT_EQ(result1, output1);
+  EXPECT_EQ(result2, output2);
+  EXPECT_EQ(result3, output3);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceNegativePosition) {
+  VELOX_ASSERT_THROW(
+      testRegexpReplace("abc", "a", "", {-1}),
+      "regexp_replace requires a position >= 1");
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceZeroPosition) {
+  VELOX_ASSERT_THROW(
+      testRegexpReplace("abc", "a", "", {0}),
+      "regexp_replace requires a position >= 1");
+}
+
+TEST_F(RegexFunctionsTest, regexpReplacePositionTooLarge) {
+  std::string output = "abc";
+  auto result1 = testRegexpReplace("abc", "a", "", {1000});
+  auto result2 = testRegexpReplace("abc", "a", "", {4});
+  EXPECT_EQ(result1, output);
+  EXPECT_EQ(result2, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceSpecialCharacters) {
+  std::string output = "abca";
+  auto result = testRegexpReplace("a.b.c.a", "\\.", "");
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceNoReplacement) {
+  std::string output = "abcde";
+  auto result = testRegexpReplace("abcde", "f", "z");
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceMultipleMatches) {
+  std::string output = "bb";
+  auto result = testRegexpReplace("aa", "a", "b");
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceWord) {
+  std::string output = "I like cake";
+  auto result = testRegexpReplace("I like pie", "pie", "cake");
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceEscapedCharacters) {
+  std::string output = "abcde";
+  auto result = testRegexpReplace("abc\\de", "\\\\", "");
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplacePatternBeforePosition) {
+  std::string output = "abcdef";
+  auto result = testRegexpReplace("abcdef", "d", "z", {5});
+  EXPECT_EQ(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceConstantPattern) {
+  std::vector<int32_t> positions = {1, 2};
+  const std::vector<std::string> outputVector = {
+      "the sky was blue", "coding isn't fun"};
+  auto result = testingRegexpReplaceConstantPattern(
+      {"the sky is blue", "coding is fun"}, "is", {"was", "isn't"}, positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceDataframe) {
+  // Basic Replacement
+  std::vector<int32_t> positions = {1, 2};
+  const std::vector<std::string> outputVector = {"hi world", "coding was fun"};
+  auto result = testingRegexpReplaceRows(
+      {"hello world", "coding is fun"},
+      {"hello", " is"},
+      {"hi", " was"},
+      positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceDataframeMultiple) {
+  // Multiple matches
+  std::vector<int32_t> positions = {1, 1};
+  const std::vector<std::string> outputVector = {
+      "fruit fruit fruit", "fruit fruit fruit"};
+  auto result = testingRegexpReplaceRows(
+      {"apple apple apple", "banana banana banana"},
+      {"apple", "banana"},
+      {"fruit", "fruit"},
+      positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceDataframeSpecial) {
+  // Special characters
+  std::vector<int32_t> positions = {1, 1};
+  const std::vector<std::string> outputVector = {"a-b-c", "coding"};
+  auto result = testingRegexpReplaceRows(
+      {"a.b.c", "[coding]"}, {R"(\.)", R"(\[|\])"}, {"-", ""}, positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceDataframeSizes) {
+  // Replacement with different sizes
+  std::vector<int32_t> positions = {1, 1};
+  const std::vector<std::string> outputVector = {"fantastic day", "short"};
+  auto result = testingRegexpReplaceRows(
+      {"good day", "shorter"},
+      {"good", "shorter"},
+      {"fantastic", "short"},
+      positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceDataframeNoMatches) {
+  // No matches
+  std::vector<int32_t> positions = {1, 1};
+  const std::vector<std::string> outputVector = {"apple", "banana"};
+  auto result = testingRegexpReplaceRows(
+      {"apple", "banana"}, {"orange", "grape"}, {"fruit", "fruit"}, positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceDataframeOffsetPosition) {
+  // Offset position
+  std::vector<int32_t> positions = {9, 6};
+  const std::vector<std::string> outputVector = {
+      "apple pie fruit", "grape fruit grape"};
+  auto result = testingRegexpReplaceRows(
+      {"apple pie apple", "grape banana grape"},
+      {"apple", "banana"},
+      {"fruit", "fruit"},
+      positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceEmptyStringsAndPatterns) {
+  // Empty strings and patterns
+  std::vector<int32_t> positions = {1, 1};
+  const std::vector<std::string> outputVector = {"prefix ", "he world"};
+  auto result = testingRegexpReplaceRows(
+      {"", "hello"}, {"", "llo"}, {"prefix ", " world"}, positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceDataframeCharacterTypes) {
+  // Multiple character types
+  std::vector<int32_t> positions = {1, 1};
+  const std::vector<std::string> outputVector = {"XXXABC", "YYY"};
+  auto result = testingRegexpReplaceRows(
+      {"123ABC", "!@#"}, {R"(\d)", R"(\W)"}, {"X", "Y"}, positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceDataframeBadPosition) {
+  // Larger offsets than string size
+  std::vector<int32_t> positions = {10, 15};
+  const std::vector<std::string> outputVector = {"apple", "banana"};
+  auto result = testingRegexpReplaceRows(
+      {"apple", "banana"}, {"apple", "banana"}, {"fruit", "fruit"}, positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceDataframeLastCharacter) {
+  std::vector<int32_t> positions = {5, 6};
+  const std::vector<std::string> outputVector = {"apple", "banana"};
+  auto result = testingRegexpReplaceRows(
+      {"applez", "bananaz"}, {"z", "z"}, {"", ""}, positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+
+// Test to match
+// https://github.com/apache/spark/blob/master/sql/core/src/test/scala/org/apache/spark/sql/StringFunctionsSuite.scala#L180-L184
+// This test is the crux of why regexp_replace needed to support non-constant
+// parameters. Used position {0,0} out of convenience, ideally we create another
+// function that does not pass a position parameter.
+TEST_F(RegexFunctionsTest, regexpReplaceMatchSparkSqlTest) {
+  std::vector<int32_t> positions = {1, 1, 1};
+  const std::vector<std::string> outputVector = {"300", "400", "400-400"};
+  auto result = testingRegexpReplaceRows(
+      {"100-200", "100-200", "100-200"},
+      {"(\\d+)-(\\d+)", "(\\d+)-(\\d+)", "(\\d+)"},
+      {"300", "400", "400"},
+      positions);
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+TEST_F(RegexFunctionsTest, regexpReplaceRowsNoPosition) {
+  const std::vector<std::string> outputVector = {"300", "400", "400-400"};
+  auto result = testingRegexpReplaceRows(
+      {"100-200", "100-200", "100-200"},
+      {"(\\d+)-(\\d+)", "(\\d+)-(\\d+)", "(\\d+)"},
+      {"300", "400", "400"});
+  auto output = convertOutput(outputVector, 1);
+  assertEqualVectors(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceMassiveVectors) {
+  std::vector<int32_t> positions = {1, 1, 1};
+  const std::vector<std::string> outputVector = {"300", "400", "400-400"};
+  auto result = testingRegexpReplaceRows(
+      {"100-200", "100-200", "100-200"},
+      {"(\\d+)-(\\d+)", "(\\d+)-(\\d+)", "(\\d+)"},
+      {"300", "400", "400"},
+      positions,
+      100000);
+  auto output = convertOutput(outputVector, 100000);
+  assertEqualVectors(result, output);
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceCacheLimitTest) {
+  std::vector<std::string> patterns;
+  std::vector<std::string> strings;
+  std::vector<std::string> replaces;
+  std::vector<std::string> expectedOutputs;
+
+  for (int i = 0; i <= kMaxCompiledRegexes; ++i) {
+    patterns.push_back("\\d" + std::to_string(i) + "-\\d" + std::to_string(i));
+    strings.push_back("1" + std::to_string(i) + "-2" + std::to_string(i));
+    replaces.push_back("X" + std::to_string(i) + "-Y" + std::to_string(i));
+    expectedOutputs.push_back(
+        "X" + std::to_string(i) + "-Y" + std::to_string(i));
+  }
+
+  VELOX_ASSERT_THROW(
+      testingRegexpReplaceRows(strings, patterns, replaces),
+      "regexp_replace hit the maximum number of unique regexes: 20");
+}
+
+TEST_F(RegexFunctionsTest, regexpReplaceCacheMissLimit) {
+  std::vector<std::string> patterns;
+  std::vector<std::string> strings;
+  std::vector<std::string> replaces;
+  std::vector<std::string> expectedOutputs;
+  std::vector<int32_t> positions;
+
+  for (int i = 0; i <= kMaxCompiledRegexes - 1; ++i) {
+    patterns.push_back("\\d" + std::to_string(i) + "-\\d" + std::to_string(i));
+    strings.push_back("1" + std::to_string(i) + "-2" + std::to_string(i));
+    replaces.push_back("X" + std::to_string(i) + "-Y" + std::to_string(i));
+    expectedOutputs.push_back(
+        "X" + std::to_string(i) + "-Y" + std::to_string(i));
+    positions.push_back(1);
+  }
+
+  auto result =
+      testingRegexpReplaceRows(strings, patterns, replaces, positions, 3);
+  auto output = convertOutput(expectedOutputs, 3);
+  assertEqualVectors(result, output);
+}
 } // namespace
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/tests/SizeTest.cpp b/velox/functions/sparksql/tests/SizeTest.cpp
index d885e41705af5..ff69ca04a5ac6 100644
--- a/velox/functions/sparksql/tests/SizeTest.cpp
+++ b/velox/functions/sparksql/tests/SizeTest.cpp
@@ -15,8 +15,11 @@
  */
 #include <string>
 
+#include <gtest/gtest.h>
 #include <velox/core/QueryConfig.h>
+#include <optional>
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+#include "velox/type/Timestamp.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -28,9 +31,9 @@ class SizeTest : public SparkFunctionBaseTest {
   std::function<vector_size_t(vector_size_t /* row */)> sizeAt =
       [](vector_size_t row) { return 1 + row % 7; };
 
-  void testSize(VectorPtr vector, vector_size_t numRows) {
-    auto result =
-        evaluate<SimpleVector<int32_t>>("size(c0)", makeRowVector({vector}));
+  void testLegacySizeOfNull(VectorPtr vector, vector_size_t numRows) {
+    auto result = evaluate<SimpleVector<int32_t>>(
+        "size(c0, true)", makeRowVector({vector}));
     for (vector_size_t i = 0; i < numRows; ++i) {
       if (vector->isNullAt(i)) {
         EXPECT_EQ(result->valueAt(i), -1) << "at " << i;
@@ -40,18 +43,19 @@ class SizeTest : public SparkFunctionBaseTest {
     }
   }
 
-  void testSizeLegacyNull(VectorPtr vector, vector_size_t numRows) {
-    auto result =
-        evaluate<SimpleVector<int32_t>>("size(c0)", makeRowVector({vector}));
+  void testSize(VectorPtr vector, vector_size_t numRows) {
+    auto result = evaluate<SimpleVector<int32_t>>(
+        "size(c0, false)", makeRowVector({vector}));
     for (vector_size_t i = 0; i < numRows; ++i) {
       EXPECT_EQ(result->isNullAt(i), vector->isNullAt(i)) << "at " << i;
     }
   }
 
-  void setConfig(std::string configStr, bool value) {
-    execCtx_.queryCtx()->testingOverrideConfigUnsafe({
-        {configStr, std::to_string(value)},
-    });
+  template <typename T>
+  int32_t testArraySize(const std::vector<std::optional<T>>& input) {
+    auto row = makeRowVector({makeNullableArrayVector(
+        std::vector<std::vector<std::optional<T>>>{input})});
+    return evaluateOnce<int32_t>("size(c0, false)", row).value();
   }
 
   static inline vector_size_t valueAt(vector_size_t idx) {
@@ -59,32 +63,73 @@ class SizeTest : public SparkFunctionBaseTest {
   }
 };
 
-TEST_F(SizeTest, sizetest) {
+// Ensure that out is set to -1 for null input if legacySizeOfNull = true.
+TEST_F(SizeTest, legacySizeOfNull) {
   vector_size_t numRows = 100;
   auto arrayVector =
       makeArrayVector<int64_t>(numRows, sizeAt, valueAt, nullptr);
-  testSize(arrayVector, numRows);
+  testLegacySizeOfNull(arrayVector, numRows);
   arrayVector =
       makeArrayVector<int64_t>(numRows, sizeAt, valueAt, nullEvery(5));
-  testSize(arrayVector, numRows);
+  testLegacySizeOfNull(arrayVector, numRows);
   auto mapVector = makeMapVector<int64_t, int64_t>(
       numRows, sizeAt, valueAt, valueAt, nullptr);
-  testSize(mapVector, numRows);
+  testLegacySizeOfNull(mapVector, numRows);
   mapVector = makeMapVector<int64_t, int64_t>(
       numRows, sizeAt, valueAt, valueAt, nullEvery(5));
-  testSize(mapVector, numRows);
+  testLegacySizeOfNull(mapVector, numRows);
 }
 
-// Ensure that out if set to -1 if SparkLegacySizeOfNull is specified.
-TEST_F(SizeTest, legacySizeOfNull) {
+// Ensure that out is set to null for null input if legacySizeOfNull = false.
+TEST_F(SizeTest, size) {
   vector_size_t numRows = 100;
-  setConfig(core::QueryConfig::kSparkLegacySizeOfNull, false);
   auto arrayVector =
       makeArrayVector<int64_t>(numRows, sizeAt, valueAt, nullEvery(1));
-  testSizeLegacyNull(arrayVector, numRows);
+  testSize(arrayVector, numRows);
   auto mapVector = makeMapVector<int64_t, int64_t>(
       numRows, sizeAt, valueAt, valueAt, nullEvery(1));
-  testSizeLegacyNull(mapVector, numRows);
+  testSize(mapVector, numRows);
+}
+
+TEST_F(SizeTest, boolean) {
+  EXPECT_EQ(testArraySize<bool>({true, false}), 2);
+  EXPECT_EQ(testArraySize<bool>({true}), 1);
+  EXPECT_EQ(testArraySize<bool>({}), 0);
+  EXPECT_EQ(testArraySize<bool>({true, false, true, std::nullopt}), 4);
+}
+
+TEST_F(SizeTest, smallint) {
+  EXPECT_EQ(testArraySize<int8_t>({}), 0);
+  EXPECT_EQ(testArraySize<int8_t>({1}), 1);
+  EXPECT_EQ(testArraySize<int8_t>({std::nullopt}), 1);
+  EXPECT_EQ(testArraySize<int8_t>({std::nullopt, 1}), 2);
+}
+
+TEST_F(SizeTest, real) {
+  EXPECT_EQ(testArraySize<float>({}), 0);
+  EXPECT_EQ(testArraySize<float>({1.1}), 1);
+  EXPECT_EQ(testArraySize<float>({std::nullopt}), 1);
+  EXPECT_EQ(testArraySize<float>({std::nullopt, 1.1}), 2);
+}
+
+TEST_F(SizeTest, varchar) {
+  EXPECT_EQ(testArraySize<std::string>({"red", "blue"}), 2);
+  EXPECT_EQ(
+      testArraySize<std::string>({std::nullopt, "blue", "yellow", "orange"}),
+      4);
+  EXPECT_EQ(testArraySize<std::string>({}), 0);
+  EXPECT_EQ(testArraySize<std::string>({std::nullopt}), 1);
+}
+
+TEST_F(SizeTest, integer) {
+  EXPECT_EQ(testArraySize<int32_t>({1, 2}), 2);
+}
+
+TEST_F(SizeTest, timestamp) {
+  auto ts = [](int64_t micros) { return Timestamp::fromMicros(micros); };
+  EXPECT_EQ(testArraySize<Timestamp>({}), 0);
+  EXPECT_EQ(testArraySize<Timestamp>({std::nullopt}), 1);
+  EXPECT_EQ(testArraySize<Timestamp>({ts(0), ts(1)}), 2);
 }
 
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/SliceTest.cpp b/velox/functions/sparksql/tests/SliceTest.cpp
new file mode 100644
index 0000000000000..1d4feff3c6369
--- /dev/null
+++ b/velox/functions/sparksql/tests/SliceTest.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/lib/tests/SliceTestBase.h"
+#include "velox/functions/sparksql/Register.h"
+
+namespace facebook::velox::functions::sparksql::test {
+
+namespace {
+class SliceTest : public ::facebook::velox::functions::test::SliceTestBase {
+ protected:
+  static void SetUpTestCase() {
+    SliceTestBase::SetUpTestCase();
+    sparksql::registerFunctions("");
+  }
+
+  void SetUp() override {
+    // Parses integer literals as INTEGER, not BIGINT.
+    options_.parseIntegerAsBigint = false;
+  }
+};
+
+TEST_F(SliceTest, basic) {
+  basicTestCases();
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/SortArrayTest.cpp b/velox/functions/sparksql/tests/SortArrayTest.cpp
index f5313b32b86a7..83a70dc72e7ab 100644
--- a/velox/functions/sparksql/tests/SortArrayTest.cpp
+++ b/velox/functions/sparksql/tests/SortArrayTest.cpp
@@ -50,7 +50,7 @@ class SortArrayTest : public SparkFunctionBaseTest {
       const VectorPtr& input,
       const VectorPtr& expected) {
     SCOPED_TRACE(expr);
-    auto result = evaluate<ArrayVector>(expr, makeRowVector({input}));
+    auto result = evaluate(expr, makeRowVector({input}));
     assertEqualVectors(expected, result);
   }
 
diff --git a/velox/functions/sparksql/tests/SparkCastExprTest.cpp b/velox/functions/sparksql/tests/SparkCastExprTest.cpp
new file mode 100644
index 0000000000000..36ed1c4b0e387
--- /dev/null
+++ b/velox/functions/sparksql/tests/SparkCastExprTest.cpp
@@ -0,0 +1,637 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/functions/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/sparksql/Register.h"
+#include "velox/parse/TypeResolver.h"
+
+using namespace facebook::velox;
+namespace facebook::velox::test {
+namespace {
+
+class SparkCastExprTest : public functions::test::CastBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    parse::registerTypeResolver();
+    functions::sparksql::registerFunctions("");
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  template <typename T>
+  void testDecimalToIntegralCasts() {
+    auto shortFlat = makeNullableFlatVector<int64_t>(
+        {-300,
+         -260,
+         -230,
+         -200,
+         -100,
+         0,
+         5500,
+         5749,
+         5755,
+         6900,
+         7200,
+         std::nullopt},
+        DECIMAL(6, 2));
+    testCast(
+        shortFlat,
+        makeNullableFlatVector<T>(
+            {-3,
+             -2 /*-2.6 truncated to -2*/,
+             -2 /*-2.3 truncated to -2*/,
+             -2,
+             -1,
+             0,
+             55,
+             57 /*57.49 truncated to 57*/,
+             57 /*57.55 truncated to 57*/,
+             69,
+             72,
+             std::nullopt}));
+    auto longFlat = makeNullableFlatVector<int128_t>(
+        {-30'000'000'000,
+         -25'500'000'000,
+         -24'500'000'000,
+         -20'000'000'000,
+         -10'000'000'000,
+         0,
+         550'000'000'000,
+         554'900'000'000,
+         559'900'000'000,
+         690'000'000'000,
+         720'000'000'000,
+         std::nullopt},
+        DECIMAL(20, 10));
+    testCast(
+        longFlat,
+        makeNullableFlatVector<T>(
+            {-3,
+             -2 /*-2.55 truncated to -2*/,
+             -2 /*-2.45 truncated to -2*/,
+             -2,
+             -1,
+             0,
+             55,
+             55 /* 55.49 truncated to 55*/,
+             55 /* 55.99 truncated to 55*/,
+             69,
+             72,
+             std::nullopt}));
+  }
+};
+
+TEST_F(SparkCastExprTest, date) {
+  testCast<std::string, int32_t>(
+      "date",
+      {"1970-01-01",
+       "2020-01-01",
+       "2135-11-09",
+       "1969-12-27",
+       "1812-04-15",
+       "1920-01-02",
+       "12345-12-18",
+       "1970-1-2",
+       "1970-01-2",
+       "1970-1-02",
+       "+1970-01-02",
+       "-1-1-1",
+       " 1970-01-01",
+       std::nullopt},
+      {0,
+       18262,
+       60577,
+       -5,
+       -57604,
+       -18262,
+       3789742,
+       1,
+       1,
+       1,
+       1,
+       -719893,
+       0,
+       std::nullopt},
+      VARCHAR(),
+      DATE());
+  testCast<std::string, int32_t>(
+      "date",
+      {"12345",
+       "2015",
+       "2015-03",
+       "2015-03-18T",
+       "2015-03-18T123123",
+       "2015-03-18 123142",
+       "2015-03-18 (BC)"},
+      {3789391, 16436, 16495, 16512, 16512, 16512, 16512},
+      VARCHAR(),
+      DATE());
+}
+
+TEST_F(SparkCastExprTest, decimalToIntegral) {
+  testDecimalToIntegralCasts<int64_t>();
+  testDecimalToIntegralCasts<int32_t>();
+  testDecimalToIntegralCasts<int16_t>();
+  testDecimalToIntegralCasts<int8_t>();
+}
+
+TEST_F(SparkCastExprTest, invalidDate) {
+  testInvalidCast<int8_t>(
+      "date", {12}, "Cast from TINYINT to DATE is not supported", TINYINT());
+  testInvalidCast<int16_t>(
+      "date",
+      {1234},
+      "Cast from SMALLINT to DATE is not supported",
+      SMALLINT());
+  testInvalidCast<int32_t>(
+      "date", {1234}, "Cast from INTEGER to DATE is not supported", INTEGER());
+  testInvalidCast<int64_t>(
+      "date", {1234}, "Cast from BIGINT to DATE is not supported", BIGINT());
+
+  testInvalidCast<float>(
+      "date", {12.99}, "Cast from REAL to DATE is not supported", REAL());
+  testInvalidCast<double>(
+      "date", {12.99}, "Cast from DOUBLE to DATE is not supported", DOUBLE());
+
+  // Parsing ill-formated dates.
+  testInvalidCast<std::string>(
+      "date",
+      {"2012-Oct-23"},
+      "Unable to parse date value: \"2012-Oct-23\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-03-18X"},
+      "Unable to parse date value: \"2015-03-18X\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015/03/18"},
+      "Unable to parse date value: \"2015/03/18\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015.03.18"},
+      "Unable to parse date value: \"2015.03.18\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"20150318"},
+      "Unable to parse date value: \"20150318\"",
+      VARCHAR());
+  testInvalidCast<std::string>(
+      "date",
+      {"2015-031-8"},
+      "Unable to parse date value: \"2015-031-8\"",
+      VARCHAR());
+}
+
+TEST_F(SparkCastExprTest, stringToTimestamp) {
+  std::vector<std::optional<std::string>> input{
+      "1970-01-01",
+      "2000-01-01",
+      "1970-01-01 00:00:00",
+      "2000-01-01 12:21:56",
+      std::nullopt,
+      "2015-03-18T12:03:17",
+      "2015-03-18 12:03:17",
+      "2015-03-18T12:03:17",
+      "2015-03-18 12:03:17.123",
+      "2015-03-18T12:03:17.123",
+      "2015-03-18T12:03:17.456",
+      "2015-03-18 12:03:17.456",
+  };
+  std::vector<std::optional<Timestamp>> expected{
+      Timestamp(0, 0),
+      Timestamp(946684800, 0),
+      Timestamp(0, 0),
+      Timestamp(946729316, 0),
+      std::nullopt,
+      Timestamp(1426680197, 0),
+      Timestamp(1426680197, 0),
+      Timestamp(1426680197, 0),
+      Timestamp(1426680197, 123000000),
+      Timestamp(1426680197, 123000000),
+      Timestamp(1426680197, 456000000),
+      Timestamp(1426680197, 456000000),
+  };
+  testCast<std::string, Timestamp>("timestamp", input, expected);
+}
+
+TEST_F(SparkCastExprTest, primitiveInvalidCornerCases) {
+  // To integer.
+  {
+    // Invalid strings.
+    testInvalidCast<std::string>(
+        "tinyint",
+        {"1234567"},
+        "Cannot cast VARCHAR '1234567' to TINYINT. TINYINT overflow: 123 * 10");
+    testInvalidCast<std::string>(
+        "tinyint", {"1a"}, "Encountered a non-digit character");
+    testInvalidCast<std::string>("tinyint", {""}, "Empty string");
+    testInvalidCast<std::string>(
+        "integer", {"1'234'567"}, "Encountered a non-digit character");
+    testInvalidCast<std::string>(
+        "integer", {"1,234,567"}, "Encountered a non-digit character");
+    testInvalidCast<std::string>(
+        "bigint", {"infinity"}, "Encountered a non-digit character");
+    testInvalidCast<std::string>(
+        "bigint", {"nan"}, "Encountered a non-digit character");
+  }
+
+  // To floating-point.
+  {
+    // Invalid strings.
+    testInvalidCast<std::string>(
+        "real",
+        {"1.2a"},
+        "Non-whitespace character found after end of conversion");
+    testInvalidCast<std::string>(
+        "real",
+        {"1.2.3"},
+        "Non-whitespace character found after end of conversion");
+  }
+
+  // To boolean.
+  {
+    testInvalidCast<std::string>(
+        "boolean", {"1.7E308"}, "Cannot cast 1.7E308 to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"nan"}, "Cannot cast nan to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"infinity"}, "Cannot cast infinity to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"12"}, "Cannot cast 12 to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"-1"}, "Cannot cast -1 to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"tr"}, "Cannot cast tr to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"tru"}, "Cannot cast tru to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"on"}, "Cannot cast on to BOOLEAN");
+    testInvalidCast<std::string>(
+        "boolean", {"off"}, "Cannot cast off to BOOLEAN");
+  }
+}
+
+TEST_F(SparkCastExprTest, primitiveValidCornerCases) {
+  // To integer.
+  {
+    // Valid strings.
+    testCast<std::string, int8_t>("tinyint", {"1.2"}, {1});
+    testCast<std::string, int8_t>("tinyint", {"1.23444"}, {1});
+    testCast<std::string, int8_t>("tinyint", {".2355"}, {0});
+    testCast<std::string, int8_t>("tinyint", {"-1.8"}, {-1});
+    testCast<std::string, int8_t>("tinyint", {"+1"}, {1});
+    testCast<std::string, int8_t>("tinyint", {"1."}, {1});
+    testCast<std::string, int8_t>("tinyint", {"-1"}, {-1});
+    testCast<std::string, int8_t>("tinyint", {"-1."}, {-1});
+    testCast<std::string, int8_t>("tinyint", {"0."}, {0});
+    testCast<std::string, int8_t>("tinyint", {"."}, {0});
+    testCast<std::string, int8_t>("tinyint", {"-."}, {0});
+
+    testCast<int32_t, int8_t>("tinyint", {1234567}, {-121});
+    testCast<int32_t, int8_t>("tinyint", {-1234567}, {121});
+    testCast<double, int8_t>("tinyint", {12345.67}, {57});
+    testCast<double, int8_t>("tinyint", {-12345.67}, {-57});
+    testCast<double, int8_t>("tinyint", {127.1}, {127});
+    testCast<float, int64_t>("bigint", {kInf}, {9223372036854775807});
+    testCast<float, int64_t>("bigint", {kNan}, {0});
+    testCast<float, int32_t>("integer", {kNan}, {0});
+    testCast<float, int16_t>("smallint", {kNan}, {0});
+    testCast<float, int8_t>("tinyint", {kNan}, {0});
+
+    testCast<double, int64_t>("bigint", {12345.12}, {12345});
+    testCast<double, int64_t>("bigint", {12345.67}, {12345});
+  }
+
+  // To floating-point.
+  {
+    testCast<double, float>("real", {1.7E308}, {kInf});
+
+    testCast<std::string, float>("real", {"1.7E308"}, {kInf});
+    testCast<std::string, float>("real", {"1."}, {1.0});
+    testCast<std::string, float>("real", {"1"}, {1});
+    testCast<std::string, float>("real", {"infinity"}, {kInf});
+    testCast<std::string, float>("real", {"-infinity"}, {-kInf});
+    testCast<std::string, float>("real", {"nan"}, {kNan});
+    testCast<std::string, float>("real", {"InfiNiTy"}, {kInf});
+    testCast<std::string, float>("real", {"-InfiNiTy"}, {-kInf});
+    testCast<std::string, float>("real", {"nAn"}, {kNan});
+  }
+
+  // To boolean.
+  {
+    testCast<int8_t, bool>("boolean", {1}, {true});
+    testCast<int8_t, bool>("boolean", {0}, {false});
+    testCast<int8_t, bool>("boolean", {12}, {true});
+    testCast<int8_t, bool>("boolean", {-1}, {true});
+    testCast<double, bool>("boolean", {1.0}, {true});
+    testCast<double, bool>("boolean", {1.1}, {true});
+    testCast<double, bool>("boolean", {0.1}, {true});
+    testCast<double, bool>("boolean", {-0.1}, {true});
+    testCast<double, bool>("boolean", {-1.0}, {true});
+    testCast<float, bool>("boolean", {kNan}, {false});
+    testCast<float, bool>("boolean", {kInf}, {true});
+    testCast<double, bool>("boolean", {0.0000000000001}, {true});
+
+    testCast<std::string, bool>("boolean", {"1"}, {true});
+    testCast<std::string, bool>("boolean", {"t"}, {true});
+    testCast<std::string, bool>("boolean", {"y"}, {true});
+    testCast<std::string, bool>("boolean", {"yes"}, {true});
+    testCast<std::string, bool>("boolean", {"true"}, {true});
+
+    testCast<std::string, bool>("boolean", {"0"}, {false});
+    testCast<std::string, bool>("boolean", {"f"}, {false});
+    testCast<std::string, bool>("boolean", {"n"}, {false});
+    testCast<std::string, bool>("boolean", {"no"}, {false});
+    testCast<std::string, bool>("boolean", {"false"}, {false});
+  }
+
+  // To string.
+  {
+    testCast<float, std::string>("varchar", {kInf}, {"Infinity"});
+    testCast<float, std::string>("varchar", {kNan}, {"NaN"});
+  }
+}
+
+TEST_F(SparkCastExprTest, truncate) {
+  // Testing truncate cast from double to int.
+  testCast<int32_t, int8_t>(
+      "tinyint", {1111111, 2, 3, 1000, -100101}, {71, 2, 3, -24, -5});
+}
+
+TEST_F(SparkCastExprTest, errorHandling) {
+  testTryCast<std::string, int8_t>(
+      "tinyint",
+      {"-",
+       "-0",
+       " @w 123",
+       "123 ",
+       "  122",
+       "",
+       "-12-3",
+       "1234",
+       "-129",
+       "1.1.1",
+       "1..",
+       "1.abc",
+       "..",
+       "-..",
+       "125.5",
+       "127",
+       "-128"},
+      {std::nullopt,
+       0,
+       std::nullopt,
+       123,
+       122,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       125,
+       127,
+       -128});
+
+  testTryCast<double, int>(
+      "integer",
+      {1e12, 2.5, 3.6, 100.44, -100.101},
+      {std::numeric_limits<int32_t>::max(), 2, 3, 100, -100});
+}
+
+TEST_F(SparkCastExprTest, overflow) {
+  testCast<int16_t, int8_t>("tinyint", {456}, {-56});
+  testCast<int32_t, int8_t>("tinyint", {266}, {10});
+  testCast<int64_t, int8_t>("tinyint", {1234}, {-46});
+  testCast<int64_t, int16_t>("smallint", {1234567}, {-10617});
+  testCast<double, int8_t>("tinyint", {127.8}, {127});
+  testCast<double, int8_t>("tinyint", {129.9}, {-127});
+  testCast<double, int16_t>("smallint", {1234567.89}, {-10617});
+  testCast<double, int64_t>(
+      "bigint", {std::numeric_limits<double>::max()}, {9223372036854775807});
+  testCast<double, int64_t>(
+      "bigint", {std::numeric_limits<double>::quiet_NaN()}, {0});
+  auto shortFlat = makeNullableFlatVector<int64_t>(
+      {-3000,
+       -2600,
+       -2300,
+       -2000,
+       -1000,
+       0,
+       55000,
+       57490,
+       5755,
+       6900,
+       7200,
+       std::nullopt},
+      DECIMAL(5, 1));
+  testCast(
+      shortFlat,
+      makeNullableFlatVector<int8_t>(
+          {-44, -4, 26, 56, -100, 0, 124, 117, 63, -78, -48, std::nullopt}));
+  testCast(
+      makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
+      makeNullableFlatVector<int8_t>({0}));
+  testCast(
+      makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
+      makeNullableFlatVector<int32_t>({-2147483648}));
+  testCast(
+      makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
+      makeNullableFlatVector<int64_t>({2147483648}));
+
+  testInvalidCast<std::string>(
+      "tinyint",
+      {"166"},
+      "Cannot cast VARCHAR '166' to TINYINT. TINYINT overflow: 16 * 10");
+  testInvalidCast<std::string>(
+      "smallint",
+      {"52769"},
+      "Cannot cast VARCHAR '52769' to SMALLINT. SMALLINT overflow: 5276 * 10");
+  testInvalidCast<std::string>(
+      "integer",
+      {"17515055537"},
+      "Cannot cast VARCHAR '17515055537' to INTEGER. INTEGER overflow: 1751505553 * 10");
+  testInvalidCast<std::string>(
+      "integer",
+      {"-17515055537"},
+      "Cannot cast VARCHAR '-17515055537' to INTEGER. INTEGER overflow: -1751505553 * 10");
+  testInvalidCast<std::string>(
+      "bigint",
+      {"9663372036854775809"},
+      "Cannot cast VARCHAR '9663372036854775809' to BIGINT. BIGINT overflow: 966337203685477580 * 10");
+}
+
+TEST_F(SparkCastExprTest, timestampToString) {
+  testCast<Timestamp, std::string>(
+      "string",
+      {
+          Timestamp(-946684800, 0),
+          Timestamp(-7266, 0),
+          Timestamp(0, 0),
+          Timestamp(946684800, 0),
+          Timestamp(9466848000, 0),
+          Timestamp(94668480000, 0),
+          Timestamp(946729316, 0),
+          Timestamp(946729316, 123),
+          Timestamp(946729316, 100000000),
+          Timestamp(946729316, 129900000),
+          Timestamp(946729316, 123456789),
+          Timestamp(7266, 0),
+          Timestamp(-50049331200, 0),
+          Timestamp(253405036800, 0),
+          Timestamp(-62480037600, 0),
+          std::nullopt,
+      },
+      {
+          "1940-01-02 00:00:00",
+          "1969-12-31 21:58:54",
+          "1970-01-01 00:00:00",
+          "2000-01-01 00:00:00",
+          "2269-12-29 00:00:00",
+          "4969-12-04 00:00:00",
+          "2000-01-01 12:21:56",
+          "2000-01-01 12:21:56",
+          "2000-01-01 12:21:56.1",
+          "2000-01-01 12:21:56.1299",
+          "2000-01-01 12:21:56.123456",
+          "1970-01-01 02:01:06",
+          "0384-01-01 08:00:00",
+          "+10000-02-01 16:00:00",
+          "-0010-02-01 10:00:00",
+          std::nullopt,
+      });
+}
+
+TEST_F(SparkCastExprTest, fromString) {
+  // String with leading and trailing whitespaces.
+  testCast<std::string, int8_t>(
+      "tinyint", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
+  testCast<std::string, int32_t>(
+      "integer", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
+  testCast<std::string, int64_t>(
+      "bigint", {"\n\f\r\t\n\u001F 123\u000B\u001C\u001D\u001E"}, {123});
+  testCast<std::string, int32_t>(
+      "date",
+      {"\n\f\r\t\n\u001F 2015-03-18T\u000B\u001C\u001D\u001E"},
+      {16512},
+      VARCHAR(),
+      DATE());
+  testCast<std::string, float>(
+      "real", {"\n\f\r\t\n\u001F 123.0\u000B\u001C\u001D\u001E"}, {123.0});
+  testCast<std::string, double>(
+      "double", {"\n\f\r\t\n\u001F 123.0\u000B\u001C\u001D\u001E"}, {123.0});
+  testCast<std::string, Timestamp>(
+      "timestamp",
+      {"\n\f\r\t\n\u001F 2000-01-01 12:21:56\u000B\u001C\u001D\u001E"},
+      {Timestamp(946729316, 0)});
+  testCast(
+      makeFlatVector<StringView>(
+          {" 9999999999.99",
+           "9999999999.99 ",
+           "\n\f\r\t\n\u001F 9999999999.99\u000B\u001C\u001D\u001E",
+           " -3E+2",
+           "-3E+2 ",
+           "\u000B\u001C\u001D-3E+2\u001E\n\f\r\t\n\u001F "}),
+      makeFlatVector<int64_t>(
+          {999'999'999'999,
+           999'999'999'999,
+           999'999'999'999,
+           -30000,
+           -30000,
+           -30000},
+          DECIMAL(12, 2)));
+}
+
+TEST_F(SparkCastExprTest, tinyintToBinary) {
+  testCast<int8_t, std::string>(
+      TINYINT(),
+      VARBINARY(),
+      {18,
+       -26,
+       0,
+       110,
+       std::numeric_limits<int8_t>::max(),
+       std::numeric_limits<int8_t>::min()},
+      {std::string("\x12", 1),
+       std::string("\xE6", 1),
+       std::string("\0", 1),
+       std::string("\x6E", 1),
+       std::string("\x7F", 1),
+       std::string("\x80", 1)});
+}
+
+TEST_F(SparkCastExprTest, smallintToBinary) {
+  testCast<int16_t, std::string>(
+      SMALLINT(),
+      VARBINARY(),
+      {180,
+       -199,
+       0,
+       12300,
+       std::numeric_limits<int16_t>::max(),
+       std::numeric_limits<int16_t>::min()},
+      {std::string("\0\xB4", 2),
+       std::string("\xFF\x39", 2),
+       std::string("\0\0", 2),
+       std::string("\x30\x0C", 2),
+       std::string("\x7F\xFF", 2),
+       std::string("\x80\00", 2)});
+}
+
+TEST_F(SparkCastExprTest, integerToBinary) {
+  testCast<int32_t, std::string>(
+      INTEGER(),
+      VARBINARY(),
+      {18,
+       -26,
+       0,
+       180000,
+       std::numeric_limits<int32_t>::max(),
+       std::numeric_limits<int32_t>::min()},
+      {std::string("\0\0\0\x12", 4),
+       std::string("\xFF\xFF\xFF\xE6", 4),
+       std::string("\0\0\0\0", 4),
+       std::string("\0\x02\xBF\x20", 4),
+       std::string("\x7F\xFF\xFF\xFF", 4),
+       std::string("\x80\0\0\0", 4)});
+}
+
+TEST_F(SparkCastExprTest, bigintToBinary) {
+  testCast<int64_t, std::string>(
+      BIGINT(),
+      VARBINARY(),
+      {123456,
+       -256789,
+       0,
+       180000,
+       std::numeric_limits<int64_t>::max(),
+       std::numeric_limits<int64_t>::min()},
+      {std::string("\0\0\0\0\0\x01\xE2\x40", 8),
+       std::string("\xFF\xFF\xFF\xFF\xFF\xFC\x14\xEB", 8),
+       std::string("\0\0\0\0\0\0\0\0", 8),
+       std::string("\0\0\0\0\0\x02\xBF\x20", 8),
+       std::string("\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 8),
+       std::string("\x80\x00\x00\x00\x00\x00\x00\x00", 8)});
+}
+
+} // namespace
+} // namespace facebook::velox::test
diff --git a/velox/functions/sparksql/tests/SparkFunctionBaseTest.h b/velox/functions/sparksql/tests/SparkFunctionBaseTest.h
index f56659fdab83c..1b527708807b3 100644
--- a/velox/functions/sparksql/tests/SparkFunctionBaseTest.h
+++ b/velox/functions/sparksql/tests/SparkFunctionBaseTest.h
@@ -30,6 +30,12 @@ class SparkFunctionBaseTest : public FunctionBaseTest {
   static void SetUpTestCase() {
     parse::registerTypeResolver();
     sparksql::registerFunctions("");
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void setSparkPartitionId(int32_t partitionId) {
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kSparkPartitionId, std::to_string(partitionId)}});
   }
 };
 
diff --git a/velox/functions/sparksql/tests/SparkPartitionIdTest.cpp b/velox/functions/sparksql/tests/SparkPartitionIdTest.cpp
new file mode 100644
index 0000000000000..67eaaf4ddb233
--- /dev/null
+++ b/velox/functions/sparksql/tests/SparkPartitionIdTest.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class SparkPartitionIdTest : public SparkFunctionBaseTest {
+ protected:
+  void testSparkPartitionId(int32_t partitionId, int32_t vectorSize) {
+    setSparkPartitionId(partitionId);
+    auto result =
+        evaluate("spark_partition_id()", makeRowVector(ROW({}), vectorSize));
+    ASSERT_TRUE(result->isConstantEncoding());
+    velox::test::assertEqualVectors(
+        makeConstant(partitionId, vectorSize), result);
+  }
+};
+
+TEST_F(SparkPartitionIdTest, basic) {
+  testSparkPartitionId(0, 1);
+  testSparkPartitionId(100, 1);
+  testSparkPartitionId(0, 100);
+  testSparkPartitionId(100, 100);
+}
+
+TEST_F(SparkPartitionIdTest, error) {
+  auto rowVector = makeRowVector(ROW({}), 1);
+
+  queryCtx_->testingOverrideConfigUnsafe({{}});
+  VELOX_ASSERT_THROW(
+      evaluate("spark_partition_id()", rowVector),
+      "Spark partition id is not set");
+
+  setSparkPartitionId(-1);
+  VELOX_ASSERT_THROW(
+      evaluate("spark_partition_id()", rowVector),
+      "Invalid Spark partition id");
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/SplitFunctionsTest.cpp b/velox/functions/sparksql/tests/SplitFunctionsTest.cpp
deleted file mode 100644
index 8928849a44ce2..0000000000000
--- a/velox/functions/sparksql/tests/SplitFunctionsTest.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <optional>
-#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
-
-namespace facebook::velox::functions::sparksql::test {
-
-using namespace facebook::velox::test;
-namespace {
-
-class SplitTest : public SparkFunctionBaseTest {
- protected:
-  void testSplitCharacter(
-      const std::vector<std::optional<std::string>>& input,
-      std::optional<char> pattern,
-      const std::vector<std::optional<std::vector<std::string>>>& output);
-};
-
-void SplitTest::testSplitCharacter(
-    const std::vector<std::optional<std::string>>& input,
-    std::optional<char> pattern,
-    const std::vector<std::optional<std::vector<std::string>>>& output) {
-  auto valueAt = [&input](vector_size_t row) {
-    return input[row] ? StringView(*input[row]) : StringView();
-  };
-
-  // Creating vectors for input strings
-  auto nullAt = [&input](vector_size_t row) { return !input[row].has_value(); };
-
-  auto result = [&] {
-    auto inputString =
-        makeFlatVector<StringView>(input.size(), valueAt, nullAt);
-    auto rowVector = makeRowVector({inputString});
-
-    // Evaluating the function for each input and seed
-    std::string patternString =
-        pattern.has_value() ? std::string(", '") + pattern.value() + "'" : "";
-    std::string expressionString =
-        std::string("split(c0") + patternString + ")";
-    return evaluate<ArrayVector>(expressionString, rowVector);
-  }();
-
-  // Creating vectors for output string vectors
-  auto sizeAtOutput = [&output](vector_size_t row) {
-    return output[row] ? output[row]->size() : 0;
-  };
-  auto valueAtOutput = [&output](vector_size_t row, vector_size_t idx) {
-    return output[row] ? StringView(output[row]->at(idx)) : StringView("");
-  };
-  auto nullAtOutput = [&output](vector_size_t row) {
-    return !output[row].has_value();
-  };
-  auto expectedResult = makeArrayVector<StringView>(
-      output.size(), sizeAtOutput, valueAtOutput, nullAtOutput);
-
-  // Checking the results
-  assertEqualVectors(expectedResult, result);
-}
-
-TEST_F(SplitTest, reallocationAndCornerCases) {
-  testSplitCharacter(
-      {"boo:and:foo", "abcfd", "abcfd:", "", ":ab::cfd::::"},
-      ':',
-      {{{"boo", "and", "foo"}},
-       {{"abcfd"}},
-       {{"abcfd", ""}},
-       {{""}},
-       {{"", "ab", "", "cfd", "", "", "", ""}}});
-}
-
-TEST_F(SplitTest, nulls) {
-  testSplitCharacter(
-      {std::nullopt, "abcfd", "abcfd:", std::nullopt, ":ab::cfd::::"},
-      ':',
-      {{std::nullopt},
-       {{"abcfd"}},
-       {{"abcfd", ""}},
-       {{std::nullopt}},
-       {{"", "ab", "", "cfd", "", "", "", ""}}});
-}
-
-TEST_F(SplitTest, defaultArguments) {
-  testSplitCharacter(
-      {"boo:and:foo", "abcfd"}, ':', {{{"boo", "and", "foo"}}, {{"abcfd"}}});
-}
-
-TEST_F(SplitTest, longStrings) {
-  testSplitCharacter(
-      {"abcdefghijklkmnopqrstuvwxyz"},
-      ',',
-      {{{"abcdefghijklkmnopqrstuvwxyz"}}});
-}
-
-} // namespace
-} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/SplitTest.cpp b/velox/functions/sparksql/tests/SplitTest.cpp
new file mode 100644
index 0000000000000..33a8e133f9b2e
--- /dev/null
+++ b/velox/functions/sparksql/tests/SplitTest.cpp
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+#include "velox/type/Type.h"
+
+using namespace facebook::velox::test;
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class SplitTest : public SparkFunctionBaseTest {
+ protected:
+  void testSplit(
+      const std::vector<std::string>& input,
+      const std::string& delim,
+      std::optional<int32_t> limit,
+      size_t numRows,
+      const std::vector<std::vector<std::string>>& expected) {
+    auto strings = makeFlatVector(input);
+    auto delims = makeConstant(StringView{delim}, numRows);
+    auto expectedResult = makeArrayVector(expected);
+    VectorPtr result;
+    if (limit.has_value()) {
+      auto limits = makeConstant<int32_t>(limit.value(), numRows);
+      auto input = makeRowVector({strings, delims, limits});
+      result = evaluate("split(c0, c1, c2)", input);
+    } else {
+      auto input = makeRowVector({strings, delims});
+      result = evaluate("split(c0, c1)", input);
+    }
+    assertEqualVectors(expectedResult, result);
+  };
+};
+
+TEST_F(SplitTest, basic) {
+  auto numRows = 4;
+  auto input = std::vector<std::string>{
+      {"I,he,she,they"}, // Simple
+      {"one,,,four,"}, // Empty strings
+      {"a,\xED,\xA0,123"}, // Not a well-formed UTF-8 string
+      {""}, // The whole string is empty
+  };
+  auto expected = std::vector<std::vector<std::string>>({
+      {"I", "he", "she", "they"},
+      {"one", "", "", "four", ""},
+      {"a", "\xED", "\xA0", "123"},
+      {""},
+  });
+
+  // No limit provided.
+  testSplit(input, ",", std::nullopt, numRows, expected);
+
+  // Limit <= 0.
+  testSplit(input, ",", -1, numRows, expected);
+
+  // High limit, the limit greater than the input string size.
+  testSplit(input, ",", 10, numRows, expected);
+
+  // Small limit, the limit is smaller than or equals to input string size.
+  expected = {
+      {"I", "he", "she,they"},
+      {"one", "", ",four,"},
+      {"a", "\xED", "\xA0,123"},
+      {""},
+  };
+  testSplit(input, ",", 3, numRows, expected);
+
+  // limit = 1, the resulting array only has one entry to contain all input.
+  expected = {
+      {"I,he,she,they"},
+      {"one,,,four,"},
+      {"a,\xED,\xA0,123"},
+      {""},
+  };
+  testSplit(input, ",", 1, numRows, expected);
+
+  // Non-ascii delimiter.
+  input = {
+      {"синяя сливаలేదా赤いトマトలేదా黃苹果లేదాbrown pear"},
+      {"зелёное небоలేదాలేదాలేదా緑の空లేదా"},
+      {"aలేదా\xEDలేదా\xA0లేదా123"},
+      {""},
+  };
+  expected = {
+      {"синяя слива", "赤いトマト", "黃苹果", "brown pear"},
+      {"зелёное небо", "", "", "緑の空", ""},
+      {"a", "\xED", "\xA0", "123"},
+      {""},
+  };
+  testSplit(input, "లేదా", std::nullopt, numRows, expected);
+  testSplit(input, "లేదా", -1, numRows, expected);
+  testSplit(input, "లేదా", 10, numRows, expected);
+  expected = {
+      {"синяя слива", "赤いトマト", "黃苹果లేదాbrown pear"},
+      {"зелёное небо", "", "లేదా緑の空లేదా"},
+      {"a", "\xED", "\xA0లేదా123"},
+      {""},
+  };
+  testSplit(input, "లేదా", 3, numRows, expected);
+  expected = {
+      {"синяя сливаలేదా赤いトマトలేదా黃苹果లేదాbrown pear"},
+      {"зелёное небоలేదాలేదాలేదా緑の空లేదా"},
+      {"aలేదా\xEDలేదా\xA0లేదా123"},
+      {""},
+  };
+  testSplit(input, "లేదా", 1, numRows, expected);
+
+  // Cover case that delimiter not exists in input string.
+  testSplit(input, "A", std::nullopt, numRows, expected);
+}
+
+TEST_F(SplitTest, emptyDelimiter) {
+  auto numRows = 4;
+  auto input = std::vector<std::string>{
+      {"I,he,she,they"}, // Simple
+      {"one,,,four,"}, // Empty strings
+      {"a\xED\xA0@123"}, // Not a well-formed UTF-8 string
+      {""}, // The whole string is empty
+  };
+  auto expected = std::vector<std::vector<std::string>>({
+      {"I", ",", "h", "e", ",", "s", "h", "e", ",", "t", "h", "e", "y"},
+      {"o", "n", "e", ",", ",", ",", "f", "o", "u", "r", ","},
+      {"a", "\xED\xA0", "@", "1", "2", "3"},
+      {""},
+  });
+
+  // No limit provided.
+  testSplit(input, "", std::nullopt, numRows, expected);
+
+  // Limit <= 0.
+  testSplit(input, "", -1, numRows, expected);
+
+  // High limit, the limit greater than the input string size.
+  testSplit(input, "", 20, numRows, expected);
+
+  // Small limit, the limit is smaller than or equals to input string size.
+  expected = {
+      {"I", ",", "h"},
+      {"o", "n", "e"},
+      {"a", "\xED\xA0", "@"},
+      {""},
+  };
+  testSplit(input, "", 3, numRows, expected);
+
+  // limit = 1.
+  expected = {
+      {"I"},
+      {"o"},
+      {"a"},
+      {""},
+  };
+  testSplit(input, "", 1, numRows, expected);
+
+  // Non-ascii, empty delimiter.
+  input = std::vector<std::string>{
+      {"синяя赤いトマト緑の"},
+      {"Hello世界🙂"},
+      {"a\xED\xA0@123"}, // Not a well-formed UTF-8 string
+      {""},
+  };
+  expected = {
+      {"с", "и", "н", "я", "я", "赤", "い", "ト", "マ", "ト", "緑", "の"},
+      {"H", "e", "l", "l", "o", "世", "界", "🙂"},
+      {"a", "\xED\xA0", "@", "1", "2", "3"},
+      {""},
+  };
+  testSplit(input, "", std::nullopt, numRows, expected);
+
+  expected = {
+      {"с", "и"},
+      {"H", "e"},
+      {"a", "\xED\xA0"},
+      {""},
+  };
+  testSplit(input, "", 2, numRows, expected);
+}
+
+TEST_F(SplitTest, regexDelimiter) {
+  auto input = std::vector<std::string>{
+      "1a 2b \xA0 14m",
+      "1a 2b \xA0 14",
+      "",
+      "a123b",
+  };
+  auto numRows = 4;
+  auto expected = std::vector<std::vector<std::string>>({
+      {"1", "2", "\xA0 14", ""},
+      {"1", "2", "\xA0 14"},
+      {""},
+      {"", "123", ""},
+  });
+
+  // No limit.
+  testSplit(input, "\\s*[a-z]+\\s*", std::nullopt, numRows, expected);
+  // Limit < 0.
+  testSplit(input, "\\s*[a-z]+\\s*", -1, numRows, expected);
+  // High limit.
+  testSplit(input, "\\s*[a-z]+\\s*", 10, numRows, expected);
+  // Small limit.
+  expected = {
+      {"1", "2", "\xA0 14m"},
+      {"1", "2", "\xA0 14"},
+      {""},
+      {"", "123", ""},
+  };
+  testSplit(input, "\\s*[a-z]+\\s*", 3, numRows, expected);
+  expected = {
+      {"1a 2b \xA0 14m"},
+      {"1a 2b \xA0 14"},
+      {""},
+      {"a123b"},
+  };
+  testSplit(input, "\\s*[a-z]+\\s*", 1, numRows, expected);
+
+  numRows = 3;
+  input = std::vector<std::string>{
+      {"синя🙂赤トマト🙂緑の"},
+      {"Hello🙂世界\xED🙂"},
+      {""},
+  };
+  expected = std::vector<std::vector<std::string>>({
+      {"с", "и", "н", "я", "🙂", "赤", "ト", "マ", "ト", "🙂", "緑", "の", ""},
+      {"H", "e", "l", "l", "o", "🙂", "世", "界", "\xED", "🙂", ""},
+      {""},
+  });
+
+  testSplit(input, "A|", std::nullopt, numRows, expected);
+
+  expected = {
+      {"с", "иня🙂赤トマト🙂緑の"},
+      {"H", "ello🙂世界\xED🙂"},
+      {""},
+  };
+  testSplit(input, "A|", 2, numRows, expected);
+
+  expected = {
+      {"синя", "赤トマト", "緑の"},
+      {"Hello", "世界\xED", ""},
+      {""},
+  };
+  testSplit(input, "🙂", -1, numRows, expected);
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/StringTest.cpp b/velox/functions/sparksql/tests/StringTest.cpp
index faa025c62ac9d..f06c698a69c69 100644
--- a/velox/functions/sparksql/tests/StringTest.cpp
+++ b/velox/functions/sparksql/tests/StringTest.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 #include "velox/type/Type.h"
 
@@ -21,178 +22,17 @@
 namespace facebook::velox::functions::sparksql::test {
 namespace {
 
-// This is a five codepoint sequence that renders as a single emoji.
-static constexpr char kWomanFacepalmingLightSkinTone[] =
-    "\xF0\x9F\xA4\xA6\xF0\x9F\x8F\xBB\xE2\x80\x8D\xE2\x99\x80\xEF\xB8\x8F";
-
 class StringTest : public SparkFunctionBaseTest {
  protected:
-  std::optional<int32_t> ascii(std::optional<std::string> arg) {
-    return evaluateOnce<int32_t>("ascii(c0)", arg);
-  }
-
-  std::optional<std::string> chr(std::optional<int64_t> arg) {
-    return evaluateOnce<std::string>("chr(c0)", arg);
-  }
-
-  std::optional<int32_t> instr(
-      std::optional<std::string> haystack,
-      std::optional<std::string> needle) {
-    return evaluateOnce<int32_t>("instr(c0, c1)", haystack, needle);
-  }
-
-  std::optional<int32_t> length(std::optional<std::string> arg) {
-    return evaluateOnce<int32_t>("length(c0)", arg);
-  }
-
-  std::optional<int32_t> length_bytes(std::optional<std::string> arg) {
-    return evaluateOnce<int32_t, std::string>(
-        "length(c0)", {arg}, {VARBINARY()});
-  }
-
-  std::optional<std::string> trim(std::optional<std::string> srcStr) {
-    return evaluateOnce<std::string>("trim(c0)", srcStr);
-  }
-
-  std::optional<std::string> trim(
-      std::optional<std::string> trimStr,
-      std::optional<std::string> srcStr) {
-    return evaluateOnce<std::string>("trim(c0, c1)", trimStr, srcStr);
-  }
-
-  std::optional<std::string> ltrim(std::optional<std::string> srcStr) {
-    return evaluateOnce<std::string>("ltrim(c0)", srcStr);
-  }
-
-  std::optional<std::string> ltrim(
-      std::optional<std::string> trimStr,
-      std::optional<std::string> srcStr) {
-    return evaluateOnce<std::string>("ltrim(c0, c1)", trimStr, srcStr);
-  }
-
-  std::optional<std::string> rtrim(std::optional<std::string> srcStr) {
-    return evaluateOnce<std::string>("rtrim(c0)", srcStr);
-  }
-
-  std::optional<std::string> rtrim(
-      std::optional<std::string> trimStr,
-      std::optional<std::string> srcStr) {
-    return evaluateOnce<std::string>("rtrim(c0, c1)", trimStr, srcStr);
-  }
-
-  std::optional<std::string> md5(std::optional<std::string> arg) {
-    return evaluateOnce<std::string, std::string>(
-        "md5(c0)", {arg}, {VARBINARY()});
-  }
-
-  std::optional<std::string> sha1(std::optional<std::string> arg) {
-    return evaluateOnce<std::string, std::string>(
-        "sha1(c0)", {arg}, {VARBINARY()});
-  }
-
-  std::optional<std::string> sha2(
-      std::optional<std::string> str,
-      std::optional<int32_t> bitLength) {
-    return evaluateOnce<std::string, std::string, int32_t>(
-        "sha2(cast(c0 as varbinary), c1)", str, bitLength);
-  }
-
-  bool compareFunction(
-      const std::string& function,
-      const std::optional<std::string>& str,
-      const std::optional<std::string>& pattern) {
-    return evaluateOnce<bool>(function + "(c0, c1)", str, pattern).value();
-  }
-
-  std::optional<bool> startsWith(
-      const std::optional<std::string>& str,
-      const std::optional<std::string>& pattern) {
-    return evaluateOnce<bool>("startsWith(c0, c1)", str, pattern);
-  }
-  std::optional<bool> endsWith(
-      const std::optional<std::string>& str,
-      const std::optional<std::string>& pattern) {
-    return evaluateOnce<bool>("endsWith(c0, c1)", str, pattern);
-  }
-  std::optional<bool> contains(
-      const std::optional<std::string>& str,
-      const std::optional<std::string>& pattern) {
-    return evaluateOnce<bool>("contains(c0, c1)", str, pattern);
-  }
-
-  std::optional<std::string> substring(
-      std::optional<std::string> str,
-      std::optional<int32_t> start) {
-    return evaluateOnce<std::string>("substring(c0, c1)", str, start);
-  }
-
-  std::optional<std::string> substring(
-      std::optional<std::string> str,
-      std::optional<int32_t> start,
-      std::optional<int32_t> length) {
-    return evaluateOnce<std::string>(
-        "substring(c0, c1, c2)", str, start, length);
-  }
-
-  std::optional<std::string> left(
-      std::optional<std::string> str,
-      std::optional<int32_t> length) {
-    return evaluateOnce<std::string>("left(c0, c1)", str, length);
-  }
-
-  std::optional<std::string> overlay(
-      std::optional<std::string> input,
-      std::optional<std::string> replace,
-      std::optional<int32_t> pos,
-      std::optional<int32_t> len) {
-    // overlay is a keyword of DuckDB, use double quote avoid parse error.
-    return evaluateOnce<std::string>(
-        "\"overlay\"(c0, c1, c2, c3)", input, replace, pos, len);
-  }
-
-  std::optional<std::string> overlayVarbinary(
-      std::optional<std::string> input,
-      std::optional<std::string> replace,
-      std::optional<int32_t> pos,
-      std::optional<int32_t> len) {
-    // overlay is a keyword of DuckDB, use double quote avoid parse error.
-    return evaluateOnce<std::string>(
-        "\"overlay\"(cast(c0 as varbinary), cast(c1 as varbinary), c2, c3)",
-        input,
-        replace,
-        pos,
-        len);
-  }
-  std::optional<std::string> rpad(
-      std::optional<std::string> string,
-      std::optional<int32_t> size,
-      std::optional<std::string> padString) {
-    return evaluateOnce<std::string>(
-        "rpad(c0, c1, c2)", string, size, padString);
-  }
-
-  std::optional<std::string> lpad(
-      std::optional<std::string> string,
-      std::optional<int32_t> size,
-      std::optional<std::string> padString) {
-    return evaluateOnce<std::string>(
-        "lpad(c0, c1, c2)", string, size, padString);
-  }
-
-  std::optional<std::string> rpad(
-      std::optional<std::string> string,
-      std::optional<int32_t> size) {
-    return evaluateOnce<std::string>("rpad(c0, c1)", string, size);
-  }
-
-  std::optional<std::string> lpad(
-      std::optional<std::string> string,
-      std::optional<int32_t> size) {
-    return evaluateOnce<std::string>("lpad(c0, c1)", string, size);
-  }
+  // This is a five codepoint sequence that renders as a single emoji.
+  static constexpr char kWomanFacepalmingLightSkinTone[] =
+      "\xF0\x9F\xA4\xA6\xF0\x9F\x8F\xBB\xE2\x80\x8D\xE2\x99\x80\xEF\xB8\x8F";
 };
 
-TEST_F(StringTest, Ascii) {
+TEST_F(StringTest, ascii) {
+  const auto ascii = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<int32_t>("ascii(c0)", arg);
+  };
   EXPECT_EQ(ascii(std::string("\0", 1)), 0);
   EXPECT_EQ(ascii(" "), 32);
   EXPECT_EQ(ascii("😋"), 128523);
@@ -210,7 +50,40 @@ TEST_F(StringTest, Ascii) {
   EXPECT_EQ(ascii(std::nullopt), std::nullopt);
 }
 
-TEST_F(StringTest, Chr) {
+TEST_F(StringTest, bitLength) {
+  const auto bitLength = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<int32_t>("bit_length(c0)", arg);
+  };
+
+  EXPECT_EQ(bitLength(""), 0);
+  EXPECT_EQ(bitLength(std::string("\0", 1)), 8);
+  EXPECT_EQ(bitLength("1"), 8);
+  EXPECT_EQ(bitLength("123"), 24);
+  EXPECT_EQ(bitLength("😋"), 32);
+  // Consists of five codepoints.
+  EXPECT_EQ(bitLength(kWomanFacepalmingLightSkinTone), 136);
+  EXPECT_EQ(bitLength("\U0001F408"), 32);
+}
+
+TEST_F(StringTest, bitLengthVarbinary) {
+  const auto bitLength = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<int32_t>("bit_length(c0)", VARBINARY(), arg);
+  };
+
+  EXPECT_EQ(bitLength(""), 0);
+  EXPECT_EQ(bitLength(std::string("\0", 1)), 8);
+  EXPECT_EQ(bitLength("1"), 8);
+  EXPECT_EQ(bitLength("123"), 24);
+  EXPECT_EQ(bitLength("😋"), 32);
+  // Consists of five codepoints.
+  EXPECT_EQ(bitLength(kWomanFacepalmingLightSkinTone), 136);
+  EXPECT_EQ(bitLength("\U0001F408"), 32);
+}
+
+TEST_F(StringTest, chr) {
+  const auto chr = [&](std::optional<int64_t> arg) {
+    return evaluateOnce<std::string>("chr(c0)", arg);
+  };
   EXPECT_EQ(chr(-16), "");
   EXPECT_EQ(chr(0), std::string("\0", 1));
   EXPECT_EQ(chr(0x100), std::string("\0", 1));
@@ -224,7 +97,218 @@ TEST_F(StringTest, Chr) {
   EXPECT_EQ(chr(std::nullopt), std::nullopt);
 }
 
-TEST_F(StringTest, Instr) {
+TEST_F(StringTest, contains) {
+  const auto contains = [&](const std::optional<std::string>& str,
+                            const std::optional<std::string>& pattern) {
+    return evaluateOnce<bool>("contains(c0, c1)", str, pattern);
+  };
+  EXPECT_EQ(contains("hello", "ello"), true);
+  EXPECT_EQ(contains("hello", "hell"), true);
+  EXPECT_EQ(contains("hello", "hello there!"), false);
+  EXPECT_EQ(contains("hello there!", "hello"), true);
+  EXPECT_EQ(contains("hello there!", ""), true);
+  EXPECT_EQ(contains("-- hello there!", std::nullopt), std::nullopt);
+  EXPECT_EQ(contains(std::nullopt, "abc"), std::nullopt);
+}
+
+TEST_F(StringTest, conv) {
+  const auto conv = [&](const std::optional<std::string>& str,
+                        const std::optional<int32_t>& fromBase,
+                        const std::optional<int32_t>& toBase) {
+    return evaluateOnce<std::string>("conv(c0, c1, c2)", str, fromBase, toBase);
+  };
+  EXPECT_EQ(conv("4", 10, 2), "100");
+  EXPECT_EQ(conv("110", 2, 10), "6");
+  EXPECT_EQ(conv("15", 10, 16), "F");
+  EXPECT_EQ(conv("15", 10, -16), "F");
+  EXPECT_EQ(conv("big", 36, 16), "3A48");
+  EXPECT_EQ(conv("-15", 10, -16), "-F");
+  EXPECT_EQ(conv("-10", 16, -10), "-16");
+
+  // Overflow case.
+  EXPECT_EQ(
+      conv("-9223372036854775809", 10, -2),
+      "-111111111111111111111111111111111111111111111111111111111111111");
+  EXPECT_EQ(
+      conv("-9223372036854775808", 10, -2),
+      "-1000000000000000000000000000000000000000000000000000000000000000");
+  EXPECT_EQ(
+      conv("9223372036854775808", 10, -2),
+      "-1000000000000000000000000000000000000000000000000000000000000000");
+  EXPECT_EQ(
+      conv("8000000000000000", 16, -2),
+      "-1000000000000000000000000000000000000000000000000000000000000000");
+  EXPECT_EQ(conv("-1", 10, 16), "FFFFFFFFFFFFFFFF");
+  EXPECT_EQ(conv("FFFFFFFFFFFFFFFF", 16, -10), "-1");
+  EXPECT_EQ(conv("-FFFFFFFFFFFFFFFF", 16, -10), "-1");
+  EXPECT_EQ(conv("-FFFFFFFFFFFFFFFF", 16, 10), "18446744073709551615");
+  EXPECT_EQ(conv("-15", 10, 16), "FFFFFFFFFFFFFFF1");
+  EXPECT_EQ(conv("9223372036854775807", 36, 16), "FFFFFFFFFFFFFFFF");
+
+  // Leading and trailing spaces.
+  EXPECT_EQ(conv("15 ", 10, 16), "F");
+  EXPECT_EQ(conv(" 15 ", 10, 16), "F");
+
+  // Invalid characters.
+  // Only converts "11".
+  EXPECT_EQ(conv("11abc", 10, 16), "B");
+  // Only converts "F".
+  EXPECT_EQ(conv("FH", 16, 10), "15");
+  // Discards followed invalid character even though converting to same base.
+  EXPECT_EQ(conv("11abc", 10, 10), "11");
+  EXPECT_EQ(conv("FH", 16, 16), "F");
+  // Begins with invalid character.
+  EXPECT_EQ(conv("HF", 16, 10), "0");
+  // All are invalid for binary base.
+  EXPECT_EQ(conv("2345", 2, 10), "0");
+
+  // Negative symbol only.
+  EXPECT_EQ(conv("-", 10, 16), "0");
+
+  // Null result.
+  EXPECT_EQ(conv("", 10, 16), std::nullopt);
+  EXPECT_EQ(conv(" ", 10, 16), std::nullopt);
+  EXPECT_EQ(conv("", std::nullopt, 16), std::nullopt);
+  EXPECT_EQ(conv("", 10, std::nullopt), std::nullopt);
+}
+
+TEST_F(StringTest, levenshtein) {
+  const auto levenshtein = [&](const std::optional<std::string>& left,
+                               const std::optional<std::string>& right,
+                               const std::optional<int32_t>& threshold =
+                                   std::nullopt) {
+    if (threshold.has_value()) {
+      return evaluateOnce<int32_t>(
+          "levenshtein(c0, c1, c2)", left, right, threshold);
+    }
+    return evaluateOnce<int32_t>("levenshtein(c0, c1)", left, right);
+  };
+
+  EXPECT_EQ(levenshtein("abc", "abc"), 0);
+  EXPECT_EQ(levenshtein("kitten", "sitting"), 3);
+  EXPECT_EQ(levenshtein("frog", "fog"), 1);
+  EXPECT_EQ(levenshtein("", "hello"), 5);
+  EXPECT_EQ(levenshtein("hello", ""), 5);
+  EXPECT_EQ(levenshtein("hello", "hello"), 0);
+  EXPECT_EQ(levenshtein("hello", "olleh"), 4);
+  EXPECT_EQ(levenshtein("hello world", "hello"), 6);
+  EXPECT_EQ(levenshtein("hello", "hello world"), 6);
+  EXPECT_EQ(levenshtein("hello world", "hel wold"), 3);
+  EXPECT_EQ(levenshtein("hello world", "hellq wodld"), 2);
+  EXPECT_EQ(levenshtein("hello word", "dello world"), 2);
+  EXPECT_EQ(levenshtein("  facebook  ", "  facebook  "), 0);
+  EXPECT_EQ(levenshtein("hello", std::string(100000, 'h')), 99999);
+  EXPECT_EQ(levenshtein(std::string(100000, 'l'), "hello"), 99998);
+  EXPECT_EQ(levenshtein(std::string(1000001, 'h'), ""), 1000001);
+  EXPECT_EQ(levenshtein("", std::string(1000001, 'h')), 1000001);
+  EXPECT_EQ(levenshtein("千世", "fog"), 3);
+  EXPECT_EQ(levenshtein("世界千世", "大a界b"), 4);
+
+  EXPECT_EQ(levenshtein("kitten", "sitting", 2), -1);
+
+  EXPECT_EQ(levenshtein("", "", 0), 0);
+
+  EXPECT_EQ(levenshtein("aaapppp", "", 8), 7);
+  EXPECT_EQ(levenshtein("aaapppp", "", 7), 7);
+  EXPECT_EQ(levenshtein("aaapppp", "", 6), -1);
+
+  EXPECT_EQ(levenshtein("elephant", "hippo", 7), 7);
+  EXPECT_EQ(levenshtein("elephant", "hippo", 6), -1);
+  EXPECT_EQ(levenshtein("hippo", "elephant", 7), 7);
+  EXPECT_EQ(levenshtein("hippo", "elephant", 6), -1);
+
+  EXPECT_EQ(levenshtein("b", "a", 0), -1);
+  EXPECT_EQ(levenshtein("a", "b", 0), -1);
+
+  EXPECT_EQ(levenshtein("aa", "aa", 0), 0);
+  EXPECT_EQ(levenshtein("aa", "aa", 2), 0);
+
+  EXPECT_EQ(levenshtein("aaa", "bbb", 2), -1);
+  EXPECT_EQ(levenshtein("aaa", "bbb", 3), 3);
+
+  EXPECT_EQ(levenshtein("aaaaaa", "b", 10), 6);
+
+  EXPECT_EQ(levenshtein("aaapppp", "b", 8), 7);
+  EXPECT_EQ(levenshtein("a", "bbb", 4), 3);
+
+  EXPECT_EQ(levenshtein("aaapppp", "b", 7), 7);
+  EXPECT_EQ(levenshtein("a", "bbb", 3), 3);
+
+  EXPECT_EQ(levenshtein("a", "bbb", 2), -1);
+  EXPECT_EQ(levenshtein("bbb", "a", 2), -1);
+  EXPECT_EQ(levenshtein("aaapppp", "b", 6), -1);
+
+  EXPECT_EQ(levenshtein("a", "bbb", 1), -1);
+  EXPECT_EQ(levenshtein("bbb", "a", 1), -1);
+
+  EXPECT_EQ(levenshtein("12345", "1234567", 1), -1);
+  EXPECT_EQ(levenshtein("1234567", "12345", 1), -1);
+
+  EXPECT_EQ(levenshtein("千世", "fog", 3), 3);
+  EXPECT_EQ(levenshtein("千世", "fog", 2), -1);
+  EXPECT_EQ(levenshtein("世界千世", "大a界b", 4), 4);
+  EXPECT_EQ(levenshtein("世界千世", "大a界b", 3), -1);
+}
+
+TEST_F(StringTest, endsWith) {
+  const auto endsWith = [&](const std::optional<std::string>& str,
+                            const std::optional<std::string>& pattern) {
+    return evaluateOnce<bool>("endsWith(c0, c1)", str, pattern);
+  };
+  EXPECT_EQ(endsWith("hello", "ello"), true);
+  EXPECT_EQ(endsWith("hello", "hell"), false);
+  EXPECT_EQ(endsWith("hello", "hello there!"), false);
+  EXPECT_EQ(endsWith("hello there!", "hello"), false);
+  EXPECT_EQ(endsWith("hello there!", "!"), true);
+  EXPECT_EQ(endsWith("hello there!", "there!"), true);
+  EXPECT_EQ(endsWith("hello there!", "hello there!"), true);
+  EXPECT_EQ(endsWith("hello there!", ""), true);
+  EXPECT_EQ(endsWith("hello there!", "hello there"), false);
+  EXPECT_EQ(endsWith("-- hello there!", "hello there"), false);
+  EXPECT_EQ(endsWith("-- hello there!", std::nullopt), std::nullopt);
+  EXPECT_EQ(endsWith(std::nullopt, "abc"), std::nullopt);
+}
+
+TEST_F(StringTest, findInSet) {
+  const auto findInSet = [&](const std::optional<std::string>& str,
+                             const std::optional<std::string>& strArray) {
+    return evaluateOnce<int32_t>("find_in_set(c0, c1)", str, strArray);
+  };
+  EXPECT_EQ(findInSet("ab", "abc,b,ab,c,def"), 3);
+  EXPECT_EQ(findInSet("abc", "abc,b,ab,c,def"), 1);
+  EXPECT_EQ(findInSet("ab,", "abc,b,ab,c,def"), 0);
+  EXPECT_EQ(findInSet("ab", "abc,b,ab,ab,ab"), 3);
+  EXPECT_EQ(findInSet("abc", "abc,abc,abc,abc,abc"), 1);
+  EXPECT_EQ(findInSet("c", "abc,b,ab,c,def"), 4);
+  EXPECT_EQ(findInSet("dfg", "abc,b,ab,c,def"), 0);
+  EXPECT_EQ(findInSet("dfg", "dfgdsiaq"), 0);
+  EXPECT_EQ(findInSet("dfg", "dfgdsiaq, dshadad"), 0);
+  EXPECT_EQ(findInSet("", ""), 1);
+  EXPECT_EQ(findInSet("", "123"), 0);
+  EXPECT_EQ(findInSet("123", ""), 0);
+  EXPECT_EQ(findInSet("", "123,"), 2);
+  EXPECT_EQ(findInSet("", ",123"), 1);
+  EXPECT_EQ(findInSet("dfg", std::nullopt), std::nullopt);
+  EXPECT_EQ(findInSet(std::nullopt, "abc"), std::nullopt);
+  EXPECT_EQ(findInSet(std::nullopt, std::nullopt), std::nullopt);
+  EXPECT_EQ(findInSet("\u0061\u0062", "abc,b,ab,c,def"), 3);
+  EXPECT_EQ(findInSet("\u0063", "abc,b,ab,c,def"), 4);
+  EXPECT_EQ(findInSet("", "\u002c\u0031\u0032\u0033"), 1);
+  EXPECT_EQ(findInSet("123", "\u002c\u0031\u0032\u0033"), 2);
+  EXPECT_EQ(findInSet("😊", "🌍,😊"), 2);
+  EXPECT_EQ(findInSet("😊", "😊,123"), 1);
+  EXPECT_EQ(findInSet("abåæçè", ",abåæçè"), 2);
+  EXPECT_EQ(findInSet("abåæçè", "abåæçè,"), 1);
+  EXPECT_EQ(findInSet("\u0061\u0062\u00e5\u00e6\u00e7\u00e8", ",abåæçè"), 2);
+  EXPECT_EQ(
+      findInSet("abåæçè", "\u002c\u0061\u0062\u00e5\u00e6\u00e7\u00e8"), 2);
+}
+
+TEST_F(StringTest, instr) {
+  const auto instr = [&](const std::optional<std::string>& haystack,
+                         const std::optional<std::string>& needle) {
+    return evaluateOnce<int32_t>("instr(c0, c1)", haystack, needle);
+  };
   EXPECT_EQ(instr("SparkSQL", "SQL"), 6);
   EXPECT_EQ(instr(std::nullopt, "SQL"), std::nullopt);
   EXPECT_EQ(instr("SparkSQL", std::nullopt), std::nullopt);
@@ -244,32 +328,347 @@ TEST_F(StringTest, Instr) {
       10);
 }
 
-TEST_F(StringTest, LengthString) {
+TEST_F(StringTest, left) {
+  const auto left = [&](const std::optional<std::string>& str,
+                        const std::optional<int32_t>& length) {
+    return evaluateOnce<std::string>("left(c0, c1)", str, length);
+  };
+  EXPECT_EQ(left("example", -2), "");
+  EXPECT_EQ(left("example", 0), "");
+  EXPECT_EQ(left("example", 2), "ex");
+  EXPECT_EQ(left("example", 7), "example");
+  EXPECT_EQ(left("example", 20), "example");
+
+  EXPECT_EQ(left("da\u6570\u636Eta", 2), "da");
+  EXPECT_EQ(left("da\u6570\u636Eta", 3), "da\u6570");
+  EXPECT_EQ(left("da\u6570\u636Eta", 30), "da\u6570\u636Eta");
+}
+
+TEST_F(StringTest, lengthString) {
+  const auto length = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<int32_t>("length(c0)", arg);
+  };
   EXPECT_EQ(length(""), 0);
   EXPECT_EQ(length(std::string("\0", 1)), 1);
   EXPECT_EQ(length("1"), 1);
   EXPECT_EQ(length("😋"), 1);
+  EXPECT_EQ(length("😋😋"), 2);
   // Consists of five codepoints.
   EXPECT_EQ(length(kWomanFacepalmingLightSkinTone), 5);
   EXPECT_EQ(length("1234567890abdef"), 15);
 }
 
-TEST_F(StringTest, LengthBytes) {
-  EXPECT_EQ(length_bytes(""), 0);
-  EXPECT_EQ(length_bytes(std::string("\0", 1)), 1);
-  EXPECT_EQ(length_bytes("1"), 1);
-  EXPECT_EQ(length_bytes("😋"), 4);
-  EXPECT_EQ(length_bytes(kWomanFacepalmingLightSkinTone), 17);
-  EXPECT_EQ(length_bytes("1234567890abdef"), 15);
+TEST_F(StringTest, lengthVarbinary) {
+  const auto length = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<int32_t>("length(c0)", VARBINARY(), arg);
+  };
+  EXPECT_EQ(length(""), 0);
+  EXPECT_EQ(length(std::string("\0", 1)), 1);
+  EXPECT_EQ(length("1"), 1);
+  EXPECT_EQ(length("😋"), 4);
+  EXPECT_EQ(length(kWomanFacepalmingLightSkinTone), 17);
+  EXPECT_EQ(length("1234567890abdef"), 15);
 }
 
-TEST_F(StringTest, MD5) {
+TEST_F(StringTest, lpad) {
+  const std::string invalidString = "Ψ\xFF\xFFΣΓΔA";
+  const std::string invalidPadString = "\xFFΨ\xFF";
+
+  const auto lpad = [&](const std::optional<std::string>& string,
+                        const std::optional<int32_t>& size) {
+    return evaluateOnce<std::string>("lpad(c0, c1)", string, size);
+  };
+
+  const auto lpadWithPadString =
+      [&](const std::optional<std::string>& string,
+          const std::optional<int32_t>& size,
+          const std::optional<std::string>& padString) {
+        return evaluateOnce<std::string>(
+            "lpad(c0, c1, c2)", string, size, padString);
+      };
+
+  EXPECT_EQ("  text", lpad("text", 6));
+
+  // ASCII strings with various values for size and padString
+  EXPECT_EQ("xtext", lpadWithPadString("text", 5, "x"));
+  EXPECT_EQ("text", lpadWithPadString("text", 4, "x"));
+  EXPECT_EQ("xyxtext", lpadWithPadString("text", 7, "xy"));
+
+  // Non-ASCII strings with various values for size and padString
+  EXPECT_EQ(
+      "\u671B\u671B\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ",
+      lpadWithPadString("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 11, "\u671B"));
+  EXPECT_EQ(
+      "\u5E0C\u671B\u5E0C\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ",
+      lpadWithPadString(
+          "\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 12, "\u5E0C\u671B"));
+
+  // Empty string
+  EXPECT_EQ("aaa", lpadWithPadString("", 3, "a"));
+
+  // Truncating string
+  EXPECT_EQ("", lpadWithPadString("abc", 0, "e"));
+  EXPECT_EQ("tex", lpadWithPadString("text", 3, "xy"));
+  EXPECT_EQ(
+      "\u4FE1\u5FF5 \u7231 ",
+      lpadWithPadString("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 5, "\u671B"));
+
+  // Invalid UTF-8 chars
+  EXPECT_EQ("x" + invalidString, lpadWithPadString(invalidString, 8, "x"));
+  EXPECT_EQ(
+      invalidPadString + "abc", lpadWithPadString("abc", 6, invalidPadString));
+}
+
+TEST_F(StringTest, ltrim) {
+  const auto ltrim = [&](const std::optional<std::string>& srcStr) {
+    return evaluateOnce<std::string>("ltrim(c0)", srcStr);
+  };
+
+  const auto ltrimWithTrimStr = [&](const std::optional<std::string>& trimStr,
+                                    const std::optional<std::string>& srcStr) {
+    return evaluateOnce<std::string>("ltrim(c0, c1)", trimStr, srcStr);
+  };
+
+  EXPECT_EQ(ltrim(""), "");
+  EXPECT_EQ(ltrim("  data\t "), "data\t ");
+  EXPECT_EQ(ltrim("  data\t"), "data\t");
+  EXPECT_EQ(ltrim("data\t "), "data\t ");
+  EXPECT_EQ(ltrim("data\t"), "data\t");
+  EXPECT_EQ(ltrim("  \u6570\u636E\t "), "\u6570\u636E\t ");
+  EXPECT_EQ(ltrim("  \u6570\u636E\t"), "\u6570\u636E\t");
+  EXPECT_EQ(ltrim("\u6570\u636E\t "), "\u6570\u636E\t ");
+  EXPECT_EQ(ltrim("\u6570\u636E\t"), "\u6570\u636E\t");
+
+  EXPECT_EQ(ltrimWithTrimStr("", ""), "");
+  EXPECT_EQ(ltrimWithTrimStr("", "srcStr"), "srcStr");
+  EXPECT_EQ(ltrimWithTrimStr("trimStr", ""), "");
+  EXPECT_EQ(ltrimWithTrimStr("data!egr< >int", "integer data!"), "");
+  EXPECT_EQ(ltrimWithTrimStr("int", "integer data!"), "eger data!");
+  EXPECT_EQ(ltrimWithTrimStr("!!at", "integer data!"), "integer data!");
+  EXPECT_EQ(ltrimWithTrimStr("a", "integer data!"), "integer data!");
+  EXPECT_EQ(
+      ltrimWithTrimStr(
+          "\u6570\u6574!\u6570 \u636E!", "\u6574\u6570 \u6570\u636E!"),
+      "");
+  EXPECT_EQ(
+      ltrimWithTrimStr(" \u6574\u6570 ", "\u6574\u6570 \u6570\u636E!"),
+      "\u636E!");
+  EXPECT_EQ(
+      ltrimWithTrimStr("! \u6570\u636E!", "\u6574\u6570 \u6570\u636E!"),
+      "\u6574\u6570 \u6570\u636E!");
+  EXPECT_EQ(
+      ltrimWithTrimStr("\u6570", "\u6574\u6570 \u6570\u636E!"),
+      "\u6574\u6570 \u6570\u636E!");
+}
+
+TEST_F(StringTest, md5) {
+  const auto md5 = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<std::string>("md5(c0)", VARBINARY(), arg);
+  };
   EXPECT_EQ(md5(std::nullopt), std::nullopt);
   EXPECT_EQ(md5(""), "d41d8cd98f00b204e9800998ecf8427e");
   EXPECT_EQ(md5("Infinity"), "eb2ac5b04180d8d6011a016aeb8f75b3");
 }
 
+TEST_F(StringTest, overlayVarchar) {
+  const auto overlay = [&](const std::optional<std::string>& input,
+                           const std::optional<std::string>& replace,
+                           const std::optional<int32_t>& pos,
+                           const std::optional<int32_t>& len) {
+    // overlay is a keyword of DuckDB, use double quote avoid parse error.
+    return evaluateOnce<std::string>(
+        "\"overlay\"(c0, c1, c2, c3)", input, replace, pos, len);
+  };
+  EXPECT_EQ(overlay("Spark\u6570\u636ESQL", "_", 6, -1), "Spark_\u636ESQL");
+  EXPECT_EQ(
+      overlay("Spark\u6570\u636ESQL", "_", 6, 0), "Spark_\u6570\u636ESQL");
+  EXPECT_EQ(overlay("Spark\u6570\u636ESQL", "_", -6, 2), "_\u636ESQL");
+
+  EXPECT_EQ(overlay("Spark SQL", "_", 6, -1), "Spark_SQL");
+  EXPECT_EQ(overlay("Spark SQL", "CORE", 7, -1), "Spark CORE");
+  EXPECT_EQ(overlay("Spark SQL", "ANSI ", 7, 0), "Spark ANSI SQL");
+  EXPECT_EQ(overlay("Spark SQL", "tructured", 2, 4), "Structured SQL");
+
+  EXPECT_EQ(overlay("Spark SQL", "##", 10, -1), "Spark SQL##");
+  EXPECT_EQ(overlay("Spark SQL", "##", 10, 4), "Spark SQL##");
+  EXPECT_EQ(overlay("Spark SQL", "##", 0, -1), "##park SQL");
+  EXPECT_EQ(overlay("Spark SQL", "##", 0, 4), "##rk SQL");
+  EXPECT_EQ(overlay("Spark SQL", "##", -10, -1), "##park SQL");
+  EXPECT_EQ(overlay("Spark SQL", "##", -10, 4), "##rk SQL");
+}
+
+TEST_F(StringTest, overlayVarbinary) {
+  const auto overlay = [&](const std::optional<std::string>& input,
+                           const std::optional<std::string>& replace,
+                           const std::optional<int32_t>& pos,
+                           const std::optional<int32_t>& len) {
+    // overlay is a keyword of DuckDB, use double quote avoid parse error.
+    return evaluateOnce<std::string>(
+        "\"overlay\"(cast(c0 as varbinary), cast(c1 as varbinary), c2, c3)",
+        input,
+        replace,
+        pos,
+        len);
+  };
+  EXPECT_EQ(overlay("Spark\x65\x20SQL", "_", 6, -1), "Spark_\x20SQL");
+  EXPECT_EQ(overlay("Spark\x65\x20SQL", "_", 6, 0), "Spark_\x65\x20SQL");
+  EXPECT_EQ(overlay("Spark\x65\x20SQL", "_", -6, 2), "_\x20SQL");
+
+  EXPECT_EQ(overlay("Spark SQL", "_", 6, -1), "Spark_SQL");
+  EXPECT_EQ(overlay("Spark SQL", "CORE", 7, -1), "Spark CORE");
+  EXPECT_EQ(overlay("Spark SQL", "ANSI ", 7, 0), "Spark ANSI SQL");
+  EXPECT_EQ(overlay("Spark SQL", "tructured", 2, 4), "Structured SQL");
+
+  EXPECT_EQ(overlay("Spark SQL", "##", 10, -1), "Spark SQL##");
+  EXPECT_EQ(overlay("Spark SQL", "##", 10, 4), "Spark SQL##");
+  EXPECT_EQ(overlay("Spark SQL", "##", 0, -1), "##park SQL");
+  EXPECT_EQ(overlay("Spark SQL", "##", 0, 4), "##rk SQL");
+  EXPECT_EQ(overlay("Spark SQL", "##", -10, -1), "##park SQL");
+  EXPECT_EQ(overlay("Spark SQL", "##", -10, 4), "##rk SQL");
+}
+
+TEST_F(StringTest, repeat) {
+  const auto stringRepeat = [&](const std::optional<std::string>& str,
+                                const std::optional<int32_t>& times) {
+    return evaluateOnce<std::string>(
+        fmt::format("{}(c0, c1)", "repeat"), str, times);
+  };
+
+  EXPECT_EQ(stringRepeat("hh", 2), "hhhh");
+  EXPECT_EQ(stringRepeat("abab", 0), "");
+  EXPECT_EQ(stringRepeat("abab", -1), "");
+  EXPECT_EQ(stringRepeat("", 2), "");
+  EXPECT_EQ(stringRepeat("123\u6570", 2), "123\u6570123\u6570");
+  VELOX_ASSERT_USER_THROW(
+      stringRepeat("hh", 524289),
+      "Result size must be less than or equal to 1048576");
+  VELOX_ASSERT_USER_THROW(
+      stringRepeat(std::string(214749, 'l'), 10000),
+      "integer overflow: 214749 * 10000");
+}
+
+TEST_F(StringTest, replace) {
+  const auto replace = [&](const std::optional<std::string>& str,
+                           const std::optional<std::string>& replaced) {
+    return evaluateOnce<std::string>("replace(c0, c1)", str, replaced);
+  };
+
+  const auto replaceWithReplacement =
+      [&](const std::optional<std::string>& str,
+          const std::optional<std::string>& replaced,
+          const std::optional<std::string>& replacement) {
+        return evaluateOnce<std::string>(
+            "replace(c0, c1, c2)", str, replaced, replacement);
+      };
+  EXPECT_EQ(replace("aaabaac", "a"), "bc");
+  EXPECT_EQ(replace("aaabaac", ""), "aaabaac");
+  EXPECT_EQ(replaceWithReplacement("aaabaac", "a", "z"), "zzzbzzc");
+  EXPECT_EQ(replaceWithReplacement("aaabaac", "", "z"), "aaabaac");
+  EXPECT_EQ(replaceWithReplacement("aaabaac", "a", ""), "bc");
+  EXPECT_EQ(replaceWithReplacement("aaabaac", "x", "z"), "aaabaac");
+  EXPECT_EQ(replaceWithReplacement("aaabaac", "aaa", "z"), "zbaac");
+  EXPECT_EQ(replaceWithReplacement("aaabaac", "a", "xyz"), "xyzxyzxyzbxyzxyzc");
+  EXPECT_EQ(replaceWithReplacement("aaabaac", "aaabaac", "z"), "z");
+  EXPECT_EQ(
+      replaceWithReplacement("123\u6570\u6570\u636E", "\u6570\u636E", "data"),
+      "123\u6570data");
+}
+
+TEST_F(StringTest, rpad) {
+  const std::string invalidString = "Ψ\xFF\xFFΣΓΔA";
+  const std::string invalidPadString = "\xFFΨ\xFF";
+
+  const auto rpad = [&](const std::optional<std::string>& string,
+                        const std::optional<int32_t>& size) {
+    return evaluateOnce<std::string>("rpad(c0, c1)", string, size);
+  };
+
+  const auto rpadWithPadString =
+      [&](const std::optional<std::string>& string,
+          const std::optional<int32_t>& size,
+          const std::optional<std::string>& padString) {
+        return evaluateOnce<std::string>(
+            "rpad(c0, c1, c2)", string, size, padString);
+      };
+
+  EXPECT_EQ("text  ", rpad("text", 6));
+
+  // ASCII strings with various values for size and padString
+  EXPECT_EQ("textx", rpadWithPadString("text", 5, "x"));
+  EXPECT_EQ("text", rpadWithPadString("text", 4, "x"));
+  EXPECT_EQ("textxyx", rpadWithPadString("text", 7, "xy"));
+
+  // Non-ASCII strings with various values for size and padString
+  EXPECT_EQ(
+      "\u4FE1\u5FF5 \u7231 \u5E0C\u671B  \u671B\u671B",
+      rpadWithPadString("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 11, "\u671B"));
+  EXPECT_EQ(
+      "\u4FE1\u5FF5 \u7231 \u5E0C\u671B  \u5E0C\u671B\u5E0C",
+      rpadWithPadString(
+          "\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 12, "\u5E0C\u671B"));
+
+  // Empty string
+  EXPECT_EQ("aaa", rpadWithPadString("", 3, "a"));
+
+  // Truncating string
+  EXPECT_EQ("", rpadWithPadString("abc", 0, "e"));
+  EXPECT_EQ("tex", rpadWithPadString("text", 3, "xy"));
+  EXPECT_EQ(
+      "\u4FE1\u5FF5 \u7231 ",
+      rpadWithPadString("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 5, "\u671B"));
+
+  // Invalid UTF-8 chars
+  EXPECT_EQ(invalidString + "x", rpadWithPadString(invalidString, 8, "x"));
+  EXPECT_EQ(
+      "abc" + invalidPadString, rpadWithPadString("abc", 6, invalidPadString));
+}
+
+TEST_F(StringTest, rtrim) {
+  const auto rtrim = [&](const std::optional<std::string>& srcStr) {
+    return evaluateOnce<std::string>("rtrim(c0)", srcStr);
+  };
+
+  const auto rtrimWithTrimStr = [&](const std::optional<std::string>& trimStr,
+                                    const std::optional<std::string>& srcStr) {
+    return evaluateOnce<std::string>("rtrim(c0, c1)", trimStr, srcStr);
+  };
+  EXPECT_EQ(rtrim(""), "");
+  EXPECT_EQ(rtrim("  data\t "), "  data\t");
+  EXPECT_EQ(rtrim("  data\t"), "  data\t");
+  EXPECT_EQ(rtrim("data\t "), "data\t");
+  EXPECT_EQ(rtrim("data\t"), "data\t");
+  EXPECT_EQ(rtrim("  \u6570\u636E\t "), "  \u6570\u636E\t");
+  EXPECT_EQ(rtrim("  \u6570\u636E\t"), "  \u6570\u636E\t");
+  EXPECT_EQ(rtrim("\u6570\u636E\t "), "\u6570\u636E\t");
+  EXPECT_EQ(rtrim("\u6570\u636E\t"), "\u6570\u636E\t");
+
+  EXPECT_EQ(rtrimWithTrimStr("", ""), "");
+  EXPECT_EQ(rtrimWithTrimStr("", "srcStr"), "srcStr");
+  EXPECT_EQ(rtrimWithTrimStr("trimStr", ""), "");
+  EXPECT_EQ(rtrimWithTrimStr("data!egr< >int", "integer data!"), "");
+  EXPECT_EQ(rtrimWithTrimStr("int", "integer data!"), "integer data!");
+  EXPECT_EQ(rtrimWithTrimStr("!!at", "integer data!"), "integer d");
+  EXPECT_EQ(rtrimWithTrimStr("a", "integer data!"), "integer data!");
+  EXPECT_EQ(
+      rtrimWithTrimStr(
+          "\u6570\u6574!\u6570 \u636E!", "\u6574\u6570 \u6570\u636E!"),
+      "");
+  EXPECT_EQ(
+      rtrimWithTrimStr(" \u6574\u6570 ", "\u6574\u6570 \u6570\u636E!"),
+      "\u6574\u6570 \u6570\u636E!");
+  EXPECT_EQ(
+      rtrimWithTrimStr("! \u6570\u636E!", "\u6574\u6570 \u6570\u636E!"),
+      "\u6574");
+  EXPECT_EQ(
+      rtrimWithTrimStr("\u6570", "\u6574\u6570 \u6570\u636E!"),
+      "\u6574\u6570 \u6570\u636E!");
+}
+
 TEST_F(StringTest, sha1) {
+  const auto sha1 = [&](const std::optional<std::string>& arg) {
+    return evaluateOnce<std::string>("sha1(c0)", VARBINARY(), arg);
+  };
+
   EXPECT_EQ(sha1(std::nullopt), std::nullopt);
   EXPECT_EQ(sha1(""), "da39a3ee5e6b4b0d3255bfef95601890afd80709");
   EXPECT_EQ(sha1("Spark"), "85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c");
@@ -279,6 +678,12 @@ TEST_F(StringTest, sha1) {
 }
 
 TEST_F(StringTest, sha2) {
+  const auto sha2 = [&](const std::optional<std::string>& str,
+                        const std::optional<int32_t>& bitLength) {
+    return evaluateOnce<std::string, std::string, int32_t>(
+        "sha2(cast(c0 as varbinary), c1)", str, bitLength);
+  };
+
   EXPECT_EQ(sha2("Spark", -1), std::nullopt);
   EXPECT_EQ(sha2("Spark", 1), std::nullopt);
   EXPECT_EQ(
@@ -334,7 +739,50 @@ TEST_F(StringTest, sha2) {
       "3ce4857a6262b03834c01c610d74cd1215f9a466dc6ad3dd15078e3309a03a6d");
 }
 
+TEST_F(StringTest, soundex) {
+  const auto soundex = [&](const std::optional<std::string>& input) {
+    return evaluateOnce<std::string>("soundex(c0)", input);
+  };
+  EXPECT_EQ(soundex("ZIN"), "Z500");
+  EXPECT_EQ(soundex("SU"), "S000");
+  EXPECT_EQ(soundex("zZ"), "Z000");
+  EXPECT_EQ(soundex("RAGSSEEESSSVEEWE"), "R221");
+  EXPECT_EQ(soundex("Miller"), "M460");
+  EXPECT_EQ(soundex("Peterson"), "P362");
+  EXPECT_EQ(soundex("Peters"), "P362");
+  EXPECT_EQ(soundex("Auerbach"), "A612");
+  EXPECT_EQ(soundex("Uhrbach"), "U612");
+  EXPECT_EQ(soundex("Moskowitz"), "M232");
+  EXPECT_EQ(soundex("Moskovitz"), "M213");
+  EXPECT_EQ(soundex("relyheewsgeessg"), "R422");
+
+  EXPECT_EQ(soundex("Robert"), "R163");
+  EXPECT_EQ(soundex("Rupert"), "R163");
+  EXPECT_EQ(soundex("Rubin"), "R150");
+
+  EXPECT_EQ(soundex("Ashcraft"), "A261");
+  EXPECT_EQ(soundex("Ashcroft"), "A261");
+  EXPECT_EQ(soundex("Aswcraft"), "A261");
+
+  EXPECT_EQ(soundex("Tymczak"), "T522");
+
+  EXPECT_EQ(soundex("Pfister"), "P236");
+
+  EXPECT_EQ(soundex("Honeyman"), "H555");
+
+  EXPECT_EQ(soundex("Tschüss"), "T220");
+
+  EXPECT_EQ(soundex(""), "");
+  EXPECT_EQ(soundex("!!"), "!!");
+  EXPECT_EQ(soundex("测试"), "测试");
+}
+
 TEST_F(StringTest, startsWith) {
+  const auto startsWith = [&](const std::optional<std::string>& str,
+                              const std::optional<std::string>& pattern) {
+    return evaluateOnce<bool>("startsWith(c0, c1)", str, pattern);
+  };
+
   EXPECT_EQ(startsWith("hello", "ello"), false);
   EXPECT_EQ(startsWith("hello", "hell"), true);
   EXPECT_EQ(startsWith("hello", "hello there!"), false);
@@ -345,136 +793,18 @@ TEST_F(StringTest, startsWith) {
   EXPECT_EQ(startsWith(std::nullopt, "abc"), std::nullopt);
 }
 
-TEST_F(StringTest, contains) {
-  EXPECT_EQ(contains("hello", "ello"), true);
-  EXPECT_EQ(contains("hello", "hell"), true);
-  EXPECT_EQ(contains("hello", "hello there!"), false);
-  EXPECT_EQ(contains("hello there!", "hello"), true);
-  EXPECT_EQ(contains("hello there!", ""), true);
-  EXPECT_EQ(contains("-- hello there!", std::nullopt), std::nullopt);
-  EXPECT_EQ(contains(std::nullopt, "abc"), std::nullopt);
-}
-
-TEST_F(StringTest, endsWith) {
-  EXPECT_EQ(endsWith("hello", "ello"), true);
-  EXPECT_EQ(endsWith("hello", "hell"), false);
-  EXPECT_EQ(endsWith("hello", "hello there!"), false);
-  EXPECT_EQ(endsWith("hello there!", "hello"), false);
-  EXPECT_EQ(endsWith("hello there!", "!"), true);
-  EXPECT_EQ(endsWith("hello there!", "there!"), true);
-  EXPECT_EQ(endsWith("hello there!", "hello there!"), true);
-  EXPECT_EQ(endsWith("hello there!", ""), true);
-  EXPECT_EQ(endsWith("hello there!", "hello there"), false);
-  EXPECT_EQ(endsWith("-- hello there!", "hello there"), false);
-  EXPECT_EQ(endsWith("-- hello there!", std::nullopt), std::nullopt);
-  EXPECT_EQ(endsWith(std::nullopt, "abc"), std::nullopt);
-}
-
-TEST_F(StringTest, trim) {
-  EXPECT_EQ(trim(""), "");
-  EXPECT_EQ(trim("  data\t "), "data\t");
-  EXPECT_EQ(trim("  data\t"), "data\t");
-  EXPECT_EQ(trim("data\t "), "data\t");
-  EXPECT_EQ(trim("data\t"), "data\t");
-  EXPECT_EQ(trim("  \u6570\u636E\t "), "\u6570\u636E\t");
-  EXPECT_EQ(trim("  \u6570\u636E\t"), "\u6570\u636E\t");
-  EXPECT_EQ(trim("\u6570\u636E\t "), "\u6570\u636E\t");
-  EXPECT_EQ(trim("\u6570\u636E\t"), "\u6570\u636E\t");
-
-  EXPECT_EQ(trim("", ""), "");
-  EXPECT_EQ(trim("", "srcStr"), "srcStr");
-  EXPECT_EQ(trim("trimStr", ""), "");
-  EXPECT_EQ(trim("data!egr< >int", "integer data!"), "");
-  EXPECT_EQ(trim("int", "integer data!"), "eger data!");
-  EXPECT_EQ(trim("!!at", "integer data!"), "integer d");
-  EXPECT_EQ(trim("a", "integer data!"), "integer data!");
-  EXPECT_EQ(
-      trim("\u6570\u6574!\u6570 \u636E!", "\u6574\u6570 \u6570\u636E!"), "");
-  EXPECT_EQ(trim(" \u6574\u6570 ", "\u6574\u6570 \u6570\u636E!"), "\u636E!");
-  EXPECT_EQ(trim("! \u6570\u636E!", "\u6574\u6570 \u6570\u636E!"), "\u6574");
-  EXPECT_EQ(
-      trim("\u6570", "\u6574\u6570 \u6570\u636E!"),
-      "\u6574\u6570 \u6570\u636E!");
-}
-
-TEST_F(StringTest, ltrim) {
-  EXPECT_EQ(ltrim(""), "");
-  EXPECT_EQ(ltrim("  data\t "), "data\t ");
-  EXPECT_EQ(ltrim("  data\t"), "data\t");
-  EXPECT_EQ(ltrim("data\t "), "data\t ");
-  EXPECT_EQ(ltrim("data\t"), "data\t");
-  EXPECT_EQ(ltrim("  \u6570\u636E\t "), "\u6570\u636E\t ");
-  EXPECT_EQ(ltrim("  \u6570\u636E\t"), "\u6570\u636E\t");
-  EXPECT_EQ(ltrim("\u6570\u636E\t "), "\u6570\u636E\t ");
-  EXPECT_EQ(ltrim("\u6570\u636E\t"), "\u6570\u636E\t");
-
-  EXPECT_EQ(ltrim("", ""), "");
-  EXPECT_EQ(ltrim("", "srcStr"), "srcStr");
-  EXPECT_EQ(ltrim("trimStr", ""), "");
-  EXPECT_EQ(ltrim("data!egr< >int", "integer data!"), "");
-  EXPECT_EQ(ltrim("int", "integer data!"), "eger data!");
-  EXPECT_EQ(ltrim("!!at", "integer data!"), "integer data!");
-  EXPECT_EQ(ltrim("a", "integer data!"), "integer data!");
-  EXPECT_EQ(
-      ltrim("\u6570\u6574!\u6570 \u636E!", "\u6574\u6570 \u6570\u636E!"), "");
-  EXPECT_EQ(ltrim(" \u6574\u6570 ", "\u6574\u6570 \u6570\u636E!"), "\u636E!");
-  EXPECT_EQ(
-      ltrim("! \u6570\u636E!", "\u6574\u6570 \u6570\u636E!"),
-      "\u6574\u6570 \u6570\u636E!");
-  EXPECT_EQ(
-      ltrim("\u6570", "\u6574\u6570 \u6570\u636E!"),
-      "\u6574\u6570 \u6570\u636E!");
-}
-
-TEST_F(StringTest, rtrim) {
-  EXPECT_EQ(rtrim(""), "");
-  EXPECT_EQ(rtrim("  data\t "), "  data\t");
-  EXPECT_EQ(rtrim("  data\t"), "  data\t");
-  EXPECT_EQ(rtrim("data\t "), "data\t");
-  EXPECT_EQ(rtrim("data\t"), "data\t");
-  EXPECT_EQ(rtrim("  \u6570\u636E\t "), "  \u6570\u636E\t");
-  EXPECT_EQ(rtrim("  \u6570\u636E\t"), "  \u6570\u636E\t");
-  EXPECT_EQ(rtrim("\u6570\u636E\t "), "\u6570\u636E\t");
-  EXPECT_EQ(rtrim("\u6570\u636E\t"), "\u6570\u636E\t");
-
-  EXPECT_EQ(rtrim("", ""), "");
-  EXPECT_EQ(rtrim("", "srcStr"), "srcStr");
-  EXPECT_EQ(rtrim("trimStr", ""), "");
-  EXPECT_EQ(rtrim("data!egr< >int", "integer data!"), "");
-  EXPECT_EQ(rtrim("int", "integer data!"), "integer data!");
-  EXPECT_EQ(rtrim("!!at", "integer data!"), "integer d");
-  EXPECT_EQ(rtrim("a", "integer data!"), "integer data!");
-  EXPECT_EQ(
-      rtrim("\u6570\u6574!\u6570 \u636E!", "\u6574\u6570 \u6570\u636E!"), "");
-  EXPECT_EQ(
-      rtrim(" \u6574\u6570 ", "\u6574\u6570 \u6570\u636E!"),
-      "\u6574\u6570 \u6570\u636E!");
-  EXPECT_EQ(rtrim("! \u6570\u636E!", "\u6574\u6570 \u6570\u636E!"), "\u6574");
-  EXPECT_EQ(
-      rtrim("\u6570", "\u6574\u6570 \u6570\u636E!"),
-      "\u6574\u6570 \u6570\u636E!");
-}
-
 TEST_F(StringTest, substring) {
-  EXPECT_EQ(substring("example", 0, 2), "ex");
-  EXPECT_EQ(substring("example", 1, -1), "");
-  EXPECT_EQ(substring("example", 1, 0), "");
-  EXPECT_EQ(substring("example", 1, 2), "ex");
-  EXPECT_EQ(substring("example", 1, 7), "example");
-  EXPECT_EQ(substring("example", 1, 100), "example");
-  EXPECT_EQ(substring("example", 2, 2), "xa");
-  EXPECT_EQ(substring("example", 8, 2), "");
-  EXPECT_EQ(substring("example", -2, 2), "le");
-  EXPECT_EQ(substring("example", -7, 2), "ex");
-  EXPECT_EQ(substring("example", -8, 2), "e");
-  EXPECT_EQ(substring("example", -9, 2), "");
-  EXPECT_EQ(substring("example", -7, 7), "example");
-  EXPECT_EQ(substring("example", -9, 9), "example");
-  EXPECT_EQ(substring("example", 4, 2147483645), "mple");
-  EXPECT_EQ(substring("example", 2147483645, 4), "");
-  EXPECT_EQ(substring("example", -2147483648, 1), "");
-  EXPECT_EQ(substring("da\u6570\u636Eta", 2, 4), "a\u6570\u636Et");
-  EXPECT_EQ(substring("da\u6570\u636Eta", -3, 2), "\u636Et");
+  const auto substring = [&](const std::optional<std::string>& str,
+                             const std::optional<int32_t>& start) {
+    return evaluateOnce<std::string>("substring(c0, c1)", str, start);
+  };
+
+  const auto substringWithLength = [&](const std::optional<std::string>& str,
+                                       const std::optional<int32_t>& start,
+                                       const std::optional<int32_t>& length) {
+    return evaluateOnce<std::string>(
+        "substring(c0, c1, c2)", str, start, length);
+  };
 
   EXPECT_EQ(substring("example", 0), "example");
   EXPECT_EQ(substring("example", 1), "example");
@@ -488,125 +818,66 @@ TEST_F(StringTest, substring) {
   EXPECT_EQ(substring("example", -2147483647), "example");
   EXPECT_EQ(substring("da\u6570\u636Eta", 3), "\u6570\u636Eta");
   EXPECT_EQ(substring("da\u6570\u636Eta", -3), "\u636Eta");
-}
-
-TEST_F(StringTest, overlayVarchar) {
-  EXPECT_EQ(overlay("Spark\u6570\u636ESQL", "_", 6, -1), "Spark_\u636ESQL");
-  EXPECT_EQ(
-      overlay("Spark\u6570\u636ESQL", "_", 6, 0), "Spark_\u6570\u636ESQL");
-  EXPECT_EQ(overlay("Spark\u6570\u636ESQL", "_", -6, 2), "_\u636ESQL");
-
-  EXPECT_EQ(overlay("Spark SQL", "_", 6, -1), "Spark_SQL");
-  EXPECT_EQ(overlay("Spark SQL", "CORE", 7, -1), "Spark CORE");
-  EXPECT_EQ(overlay("Spark SQL", "ANSI ", 7, 0), "Spark ANSI SQL");
-  EXPECT_EQ(overlay("Spark SQL", "tructured", 2, 4), "Structured SQL");
 
-  EXPECT_EQ(overlay("Spark SQL", "##", 10, -1), "Spark SQL##");
-  EXPECT_EQ(overlay("Spark SQL", "##", 10, 4), "Spark SQL##");
-  EXPECT_EQ(overlay("Spark SQL", "##", 0, -1), "##park SQL");
-  EXPECT_EQ(overlay("Spark SQL", "##", 0, 4), "##rk SQL");
-  EXPECT_EQ(overlay("Spark SQL", "##", -10, -1), "##park SQL");
-  EXPECT_EQ(overlay("Spark SQL", "##", -10, 4), "##rk SQL");
-}
-
-TEST_F(StringTest, overlayVarbinary) {
-  EXPECT_EQ(overlay("Spark\x65\x20SQL", "_", 6, -1), "Spark_\x20SQL");
-  EXPECT_EQ(overlay("Spark\x65\x20SQL", "_", 6, 0), "Spark_\x65\x20SQL");
-  EXPECT_EQ(overlay("Spark\x65\x20SQL", "_", -6, 2), "_\x20SQL");
-
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "_", 6, -1), "Spark_SQL");
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "CORE", 7, -1), "Spark CORE");
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "ANSI ", 7, 0), "Spark ANSI SQL");
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "tructured", 2, 4), "Structured SQL");
-
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "##", 10, -1), "Spark SQL##");
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "##", 10, 4), "Spark SQL##");
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "##", 0, -1), "##park SQL");
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "##", 0, 4), "##rk SQL");
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "##", -10, -1), "##park SQL");
-  EXPECT_EQ(overlayVarbinary("Spark SQL", "##", -10, 4), "##rk SQL");
+  EXPECT_EQ(substringWithLength("example", 0, 2), "ex");
+  EXPECT_EQ(substringWithLength("example", 1, -1), "");
+  EXPECT_EQ(substringWithLength("example", 1, 0), "");
+  EXPECT_EQ(substringWithLength("example", 1, 2), "ex");
+  EXPECT_EQ(substringWithLength("example", 1, 7), "example");
+  EXPECT_EQ(substringWithLength("example", 1, 100), "example");
+  EXPECT_EQ(substringWithLength("example", 2, 2), "xa");
+  EXPECT_EQ(substringWithLength("example", 8, 2), "");
+  EXPECT_EQ(substringWithLength("example", -2, 2), "le");
+  EXPECT_EQ(substringWithLength("example", -7, 2), "ex");
+  EXPECT_EQ(substringWithLength("example", -8, 2), "e");
+  EXPECT_EQ(substringWithLength("example", -9, 2), "");
+  EXPECT_EQ(substringWithLength("example", -7, 7), "example");
+  EXPECT_EQ(substringWithLength("example", -9, 9), "example");
+  EXPECT_EQ(substringWithLength("example", 4, 2147483645), "mple");
+  EXPECT_EQ(substringWithLength("example", 2147483645, 4), "");
+  EXPECT_EQ(substringWithLength("example", -2147483648, 1), "");
+  EXPECT_EQ(substringWithLength("da\u6570\u636Eta", 2, 4), "a\u6570\u636Et");
+  EXPECT_EQ(substringWithLength("da\u6570\u636Eta", -3, 2), "\u636Et");
 }
 
-TEST_F(StringTest, rpad) {
-  const std::string invalidString = "Ψ\xFF\xFFΣΓΔA";
-  const std::string invalidPadString = "\xFFΨ\xFF";
-
-  // ASCII strings with various values for size and padString
-  EXPECT_EQ("textx", rpad("text", 5, "x"));
-  EXPECT_EQ("text", rpad("text", 4, "x"));
-  EXPECT_EQ("textxyx", rpad("text", 7, "xy"));
-  EXPECT_EQ("text  ", rpad("text", 6));
-
-  // Non-ASCII strings with various values for size and padString
-  EXPECT_EQ(
-      "\u4FE1\u5FF5 \u7231 \u5E0C\u671B  \u671B\u671B",
-      rpad("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 11, "\u671B"));
-  EXPECT_EQ(
-      "\u4FE1\u5FF5 \u7231 \u5E0C\u671B  \u5E0C\u671B\u5E0C",
-      rpad("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 12, "\u5E0C\u671B"));
-
-  // Empty string
-  EXPECT_EQ("aaa", rpad("", 3, "a"));
-
-  // Truncating string
-  EXPECT_EQ("", rpad("abc", 0, "e"));
-  EXPECT_EQ("tex", rpad("text", 3, "xy"));
-  EXPECT_EQ(
-      "\u4FE1\u5FF5 \u7231 ",
-      rpad("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 5, "\u671B"));
-
-  // Invalid UTF-8 chars
-  EXPECT_EQ(invalidString + "x", rpad(invalidString, 8, "x"));
-  EXPECT_EQ("abc" + invalidPadString, rpad("abc", 6, invalidPadString));
-}
-
-TEST_F(StringTest, lpad) {
-  std::string invalidString = "Ψ\xFF\xFFΣΓΔA";
-  std::string invalidPadString = "\xFFΨ\xFF";
-
-  // ASCII strings with various values for size and padString
-  EXPECT_EQ("xtext", lpad("text", 5, "x"));
-  EXPECT_EQ("text", lpad("text", 4, "x"));
-  EXPECT_EQ("xyxtext", lpad("text", 7, "xy"));
-  EXPECT_EQ("  text", lpad("text", 6));
-
-  // Non-ASCII strings with various values for size and padString
-  EXPECT_EQ(
-      "\u671B\u671B\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ",
-      lpad("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 11, "\u671B"));
-  EXPECT_EQ(
-      "\u5E0C\u671B\u5E0C\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ",
-      lpad("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 12, "\u5E0C\u671B"));
-
-  // Empty string
-  EXPECT_EQ("aaa", lpad("", 3, "a"));
-
-  // Truncating string
-  EXPECT_EQ("", lpad("abc", 0, "e"));
-  EXPECT_EQ("tex", lpad("text", 3, "xy"));
-  EXPECT_EQ(
-      "\u4FE1\u5FF5 \u7231 ",
-      lpad("\u4FE1\u5FF5 \u7231 \u5E0C\u671B  ", 5, "\u671B"));
-
-  // Invalid UTF-8 chars
-  EXPECT_EQ("x" + invalidString, lpad(invalidString, 8, "x"));
-  EXPECT_EQ(invalidPadString + "abc", lpad("abc", 6, invalidPadString));
-}
-
-TEST_F(StringTest, left) {
-  EXPECT_EQ(left("example", -2), "");
-  EXPECT_EQ(left("example", 0), "");
-  EXPECT_EQ(left("example", 2), "ex");
-  EXPECT_EQ(left("example", 7), "example");
-  EXPECT_EQ(left("example", 20), "example");
-
-  EXPECT_EQ(left("da\u6570\u636Eta", 2), "da");
-  EXPECT_EQ(left("da\u6570\u636Eta", 3), "da\u6570");
-  EXPECT_EQ(left("da\u6570\u636Eta", 30), "da\u6570\u636Eta");
+TEST_F(StringTest, substringIndex) {
+  const auto substringIndex =
+      [&](const std::string& str, const std::string& delim, int32_t count) {
+        return evaluateOnce<std::string, std::string, std::string, int32_t>(
+            "substring_index(c0, c1, c2)", str, delim, count);
+      };
+  EXPECT_EQ(substringIndex("www.apache.org", ".", 3), "www.apache.org");
+  EXPECT_EQ(substringIndex("www.apache.org", ".", 2), "www.apache");
+  EXPECT_EQ(substringIndex("www.apache.org", ".", 1), "www");
+  EXPECT_EQ(substringIndex("www.apache.org", ".", 0), "");
+  EXPECT_EQ(substringIndex("www.apache.org", ".", -1), "org");
+  EXPECT_EQ(substringIndex("www.apache.org", ".", -2), "apache.org");
+  EXPECT_EQ(substringIndex("www.apache.org", ".", -3), "www.apache.org");
+  // Str is empty string.
+  EXPECT_EQ(substringIndex("", ".", 1), "");
+  // Empty string delim.
+  EXPECT_EQ(substringIndex("www.apache.org", "", 1), "");
+  // Delim does not exist in str.
+  EXPECT_EQ(substringIndex("www.apache.org", "#", 2), "www.apache.org");
+  EXPECT_EQ(substringIndex("www.apache.org", "WW", 1), "www.apache.org");
+  // Delim is 2 chars.
+  EXPECT_EQ(substringIndex("www||apache||org", "||", 2), "www||apache");
+  EXPECT_EQ(substringIndex("www||apache||org", "||", -2), "apache||org");
+  // Non ascii chars.
+  EXPECT_EQ(substringIndex("大千世界大千世界", "千", 2), "大千世界大");
+
+  // Overlapped delim.
+  EXPECT_EQ(substringIndex("||||||", "|||", 3), "||");
+  EXPECT_EQ(substringIndex("||||||", "|||", -4), "|||");
+  EXPECT_EQ(substringIndex("aaaaa", "aa", 2), "a");
+  EXPECT_EQ(substringIndex("aaaaa", "aa", -4), "aaa");
+  EXPECT_EQ(substringIndex("aaaaa", "aa", 0), "");
+  EXPECT_EQ(substringIndex("aaaaa", "aa", 5), "aaaaa");
+  EXPECT_EQ(substringIndex("aaaaa", "aa", -5), "aaaaa");
 }
 
 TEST_F(StringTest, translate) {
-  auto testTranslate =
+  const auto testTranslate =
       [&](const std::vector<std::optional<std::string>>& inputs,
           auto& expected) {
         EXPECT_EQ(
@@ -629,13 +900,25 @@ TEST_F(StringTest, translate) {
   testTranslate({"abc", std::nullopt, "\u2029"}, std::nullopt);
   testTranslate({"abc", "\u2028", std::nullopt}, std::nullopt);
   testTranslate({std::nullopt, "\u2028", "\u2029"}, std::nullopt);
+  // Test corner case: the input may contain invalid UTF-8 characters, which
+  // could be generated by functions like url_decode. We need to ensure that
+  // these characters do not cause incorrect results or failures.
+  std::string invalidUtf8Char(1, (char)203);
+  testTranslate({invalidUtf8Char, "1", "a"}, invalidUtf8Char);
+  invalidUtf8Char[0] = (char)128;
+  testTranslate({invalidUtf8Char, "1", "a"}, invalidUtf8Char);
+  testTranslate({invalidUtf8Char, invalidUtf8Char, "a"}, "a");
+  std::string data = "1ae4b";
+  data[2] = (char)128;
+  testTranslate({"1ae4b", "e", invalidUtf8Char}, data);
+  testTranslate({data, "3", "a"}, data);
 }
 
 TEST_F(StringTest, translateConstantMatch) {
   auto rowType = ROW({{"c0", VARCHAR()}});
   auto exprSet = compileExpression("translate(c0, 'ab', '12')", rowType);
 
-  auto testTranslate = [&](const auto& input, const auto& expected) {
+  const auto testTranslate = [&](const auto& input, const auto& expected) {
     auto result = evaluate(*exprSet, makeRowVector({input}));
     velox::test::assertEqualVectors(expected, result);
   };
@@ -655,8 +938,8 @@ TEST_F(StringTest, translateNonconstantMatch) {
   auto rowType = ROW({{"c0", VARCHAR()}, {"c1", VARCHAR()}, {"c2", VARCHAR()}});
   auto exprSet = compileExpression("translate(c0, c1, c2)", rowType);
 
-  auto testTranslate = [&](const std::vector<VectorPtr>& inputs,
-                           const auto& expected) {
+  const auto testTranslate = [&](const std::vector<VectorPtr>& inputs,
+                                 const auto& expected) {
     auto result = evaluate(*exprSet, makeRowVector(inputs));
     velox::test::assertEqualVectors(expected, result);
   };
@@ -682,5 +965,56 @@ TEST_F(StringTest, translateNonconstantMatch) {
   expected = makeFlatVector<std::string>({"åbaæçè", "åæcèaç"});
   testTranslate({input, match, replace}, expected);
 }
+
+TEST_F(StringTest, trim) {
+  const auto trim = [&](const std::optional<std::string>& srcStr) {
+    return evaluateOnce<std::string>("trim(c0)", srcStr);
+  };
+
+  const auto trimWithTrimStr = [&](const std::optional<std::string>& trimStr,
+                                   const std::optional<std::string>& srcStr) {
+    return evaluateOnce<std::string>("trim(c0, c1)", trimStr, srcStr);
+  };
+
+  EXPECT_EQ(trim(""), "");
+  EXPECT_EQ(trim("  data\t "), "data\t");
+  EXPECT_EQ(trim("  data\t"), "data\t");
+  EXPECT_EQ(trim("data\t "), "data\t");
+  EXPECT_EQ(trim("data\t"), "data\t");
+  EXPECT_EQ(trim("  \u6570\u636E\t "), "\u6570\u636E\t");
+  EXPECT_EQ(trim("  \u6570\u636E\t"), "\u6570\u636E\t");
+  EXPECT_EQ(trim("\u6570\u636E\t "), "\u6570\u636E\t");
+  EXPECT_EQ(trim("\u6570\u636E\t"), "\u6570\u636E\t");
+
+  EXPECT_EQ(trimWithTrimStr("", ""), "");
+  EXPECT_EQ(trimWithTrimStr("", "srcStr"), "srcStr");
+  EXPECT_EQ(trimWithTrimStr("trimWithTrimStrStr", ""), "");
+  EXPECT_EQ(trimWithTrimStr("data!egr< >int", "integer data!"), "");
+  EXPECT_EQ(trimWithTrimStr("int", "integer data!"), "eger data!");
+  EXPECT_EQ(trimWithTrimStr("!!at", "integer data!"), "integer d");
+  EXPECT_EQ(trimWithTrimStr("a", "integer data!"), "integer data!");
+  EXPECT_EQ(
+      trimWithTrimStr(
+          "\u6570\u6574!\u6570 \u636E!", "\u6574\u6570 \u6570\u636E!"),
+      "");
+  EXPECT_EQ(
+      trimWithTrimStr(" \u6574\u6570 ", "\u6574\u6570 \u6570\u636E!"),
+      "\u636E!");
+  EXPECT_EQ(
+      trimWithTrimStr("! \u6570\u636E!", "\u6574\u6570 \u6570\u636E!"),
+      "\u6574");
+  EXPECT_EQ(
+      trimWithTrimStr("\u6570", "\u6574\u6570 \u6570\u636E!"),
+      "\u6574\u6570 \u6570\u636E!");
+}
+
+TEST_F(StringTest, empty2Null) {
+  const auto empty2Null = [&](const std::optional<std::string>& a) {
+    return evaluateOnce<std::string>("empty2null(c0)", a);
+  };
+
+  EXPECT_EQ(empty2Null(""), std::nullopt);
+  EXPECT_EQ(empty2Null("abc"), "abc");
+}
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/StringToMapTest.cpp b/velox/functions/sparksql/tests/StringToMapTest.cpp
new file mode 100644
index 0000000000000..3cfbb24ef8dab
--- /dev/null
+++ b/velox/functions/sparksql/tests/StringToMapTest.cpp
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+class StringToMapTest : public SparkFunctionBaseTest {
+ protected:
+  VectorPtr evaluateStringToMap(const std::vector<StringView>& inputs) {
+    const std::string expr =
+        fmt::format("str_to_map(c0, '{}', '{}')", inputs[1], inputs[2]);
+    return evaluate<MapVector>(
+        expr, makeRowVector({makeFlatVector<StringView>({inputs[0]})}));
+  }
+
+  void testStringToMap(
+      const std::vector<StringView>& inputs,
+      const std::vector<std::pair<StringView, std::optional<StringView>>>&
+          expect) {
+    auto result = evaluateStringToMap(inputs);
+    auto expectVector = makeMapVector<StringView, StringView>({expect});
+    assertEqualVectors(result, expectVector);
+  }
+};
+
+TEST_F(StringToMapTest, basic) {
+  testStringToMap(
+      {"a:1,b:2,c:3", ",", ":"}, {{"a", "1"}, {"b", "2"}, {"c", "3"}});
+  testStringToMap({"a: ,b:2", ",", ":"}, {{"a", " "}, {"b", "2"}});
+  testStringToMap({"a:,b:2", ",", ":"}, {{"a", ""}, {"b", "2"}});
+  testStringToMap({"", ",", ":"}, {{"", std::nullopt}});
+  testStringToMap({"a", ",", ":"}, {{"a", std::nullopt}});
+  testStringToMap(
+      {"a=1,b=2,c=3", ",", "="}, {{"a", "1"}, {"b", "2"}, {"c", "3"}});
+  testStringToMap({"", ",", "="}, {{"", std::nullopt}});
+  testStringToMap(
+      {"a::1,b::2,c::3", ",", "c"},
+      {{"a::1", std::nullopt}, {"b::2", std::nullopt}, {"", "::3"}});
+  testStringToMap(
+      {"a:1_b:2_c:3", "_", ":"}, {{"a", "1"}, {"b", "2"}, {"c", "3"}});
+
+  // Same delimiters.
+  testStringToMap(
+      {"a:1,b:2,c:3", ",", ","},
+      {{"a:1", std::nullopt}, {"b:2", std::nullopt}, {"c:3", std::nullopt}});
+  testStringToMap(
+      {"a:1_b:2_c:3", "_", "_"},
+      {{"a:1", std::nullopt}, {"b:2", std::nullopt}, {"c:3", std::nullopt}});
+
+  // Exception for illegal delimiters.
+  // Empty string is used.
+  VELOX_ASSERT_THROW(
+      evaluateStringToMap({"a:1,b:2", "", ":"}),
+      "entryDelimiter's size should be 1.");
+  VELOX_ASSERT_THROW(
+      evaluateStringToMap({"a:1,b:2", ",", ""}),
+      "keyValueDelimiter's size should be 1.");
+  // Delimiter's length > 1.
+  VELOX_ASSERT_THROW(
+      evaluateStringToMap({"a:1,b:2", ";;", ":"}),
+      "entryDelimiter's size should be 1.");
+  VELOX_ASSERT_THROW(
+      evaluateStringToMap({"a:1,b:2", ",", "::"}),
+      "keyValueDelimiter's size should be 1.");
+  // Unicode character is used.
+  VELOX_ASSERT_THROW(
+      evaluateStringToMap({"a:1,b:2", "å", ":"}),
+      "entryDelimiter's size should be 1.");
+  VELOX_ASSERT_THROW(
+      evaluateStringToMap({"a:1,b:2", ",", "æ"}),
+      "keyValueDelimiter's size should be 1.");
+
+  // Exception for duplicated keys.
+  VELOX_ASSERT_THROW(
+      evaluateStringToMap({"a:1,b:2,a:3", ",", ":"}),
+      "Duplicate keys are not allowed: 'a'.");
+  VELOX_ASSERT_THROW(
+      evaluateStringToMap({":1,:2", ",", ":"}),
+      "Duplicate keys are not allowed: ''.");
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/UnscaledValueFunctionTest.cpp b/velox/functions/sparksql/tests/UnscaledValueFunctionTest.cpp
new file mode 100644
index 0000000000000..018833b48299e
--- /dev/null
+++ b/velox/functions/sparksql/tests/UnscaledValueFunctionTest.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class UnscaledValueFunctionTest : public SparkFunctionBaseTest {};
+
+TEST_F(UnscaledValueFunctionTest, unscaledValue) {
+  auto testUnscaledValue = [&](const std::vector<int64_t>& unscaledValue,
+                               const TypePtr& decimalType) {
+    auto input = makeFlatVector<int64_t>(unscaledValue, decimalType);
+    auto expected = makeFlatVector<int64_t>(unscaledValue);
+    auto result = evaluate("unscaled_value(c0)", makeRowVector({input}));
+    assertEqualVectors(expected, result);
+  };
+
+  testUnscaledValue({1000, 2000, -3000, -4000}, DECIMAL(18, 3));
+
+  VELOX_ASSERT_THROW(
+      testUnscaledValue({1000, 2000, -3000, -4000}, DECIMAL(20, 3)),
+      "Expect short decimal type, but got: DECIMAL(20, 3)");
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/UuidTest.cpp b/velox/functions/sparksql/tests/UuidTest.cpp
new file mode 100644
index 0000000000000..4d14a261e67de
--- /dev/null
+++ b/velox/functions/sparksql/tests/UuidTest.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class UuidTest : public SparkFunctionBaseTest {
+ protected:
+  std::optional<std::string> uuidOne(int64_t seed, int32_t partitionIndex) {
+    setSparkPartitionId(partitionIndex);
+    return evaluateOnce<std::string>(
+        fmt::format("uuid({})", seed), makeRowVector(ROW({}), 1));
+  }
+
+  VectorPtr uuidMany(int64_t seed, int32_t partitionIndex, int32_t batchSize) {
+    setSparkPartitionId(partitionIndex);
+    auto exprSet = compileExpression(fmt::format("uuid({})", seed), ROW({}));
+    return evaluate(*exprSet, makeRowVector(ROW({}), batchSize));
+  }
+};
+
+TEST_F(UuidTest, basic) {
+  // With same partitionIndex, same seed always produces same result.
+  EXPECT_EQ(uuidOne(100, 1), uuidOne(100, 1));
+  EXPECT_EQ(uuidOne(2, 1234), uuidOne(2, 1234));
+
+  EXPECT_NE(uuidOne(9, 1), uuidOne(100, 1));
+  EXPECT_NE(uuidOne(9, 1), uuidOne(9, 2));
+  EXPECT_NE(uuidOne(100, 1), uuidOne(99, 20));
+
+  // Expected result comes from Spark.
+  EXPECT_EQ(uuidOne(0, 0), std::string("8c7f0aac-97c4-4a2f-b716-a675d821ccc0"));
+
+  velox::test::assertEqualVectors(
+      uuidMany(123, 1233, 100), uuidMany(123, 1233, 100));
+  velox::test::assertEqualVectors(
+      uuidMany(321, 1233, 33), uuidMany(321, 1233, 33));
+}
+
+TEST_F(UuidTest, nonConstantSeed) {
+  setSparkPartitionId(0);
+
+  VELOX_ASSERT_THROW(
+      evaluateOnce<std::string>("uuid(c0)", std::optional<int64_t>(123)),
+      "seed argument must be constant");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/XxHash64Test.cpp b/velox/functions/sparksql/tests/XxHash64Test.cpp
index 09162f4a0279e..8926194e898f1 100644
--- a/velox/functions/sparksql/tests/XxHash64Test.cpp
+++ b/velox/functions/sparksql/tests/XxHash64Test.cpp
@@ -18,6 +18,8 @@
 
 #include <stdint.h>
 
+using facebook::velox::test::assertEqualVectors;
+
 namespace facebook::velox::functions::sparksql::test {
 namespace {
 class XxHash64Test : public SparkFunctionBaseTest {
@@ -26,6 +28,42 @@ class XxHash64Test : public SparkFunctionBaseTest {
   std::optional<int64_t> xxhash64(std::optional<T> arg) {
     return evaluateOnce<int64_t>("xxhash64(c0)", arg);
   }
+
+  VectorPtr xxhash64(VectorPtr vector) {
+    return evaluate("xxhash64(c0)", makeRowVector({vector}));
+  }
+
+  template <typename T>
+  void runSIMDHashAndAssert(
+      const T value,
+      const int64_t expectedResult,
+      const int32_t size,
+      int unSelectedRows = 0) {
+    // Generate 'size' flat vector to test SIMD code path.
+    // We use same value in the vector to make comparing the results easier.
+    std::vector<int64_t> resultData;
+    resultData.reserve(size);
+    for (auto i = 0; i < size; ++i) {
+      resultData.emplace_back(expectedResult);
+    }
+    VectorPtr input;
+    if constexpr (std::is_same_v<T, UnknownValue>) {
+      input = makeAllNullFlatVector<T>(size);
+    } else {
+      std::vector<T> inputData;
+      inputData.reserve(size);
+      for (auto i = 0; i < size; ++i) {
+        inputData.emplace_back(value);
+      }
+      input = makeFlatVector<T>(inputData);
+    }
+    SelectivityVector rows(size);
+    rows.setValidRange(0, unSelectedRows, false);
+    auto result =
+        evaluate<SimpleVector<int64_t>>("xxhash64(c0)", makeRowVector({input}));
+    velox::test::assertEqualVectors(
+        makeFlatVector<int64_t>(resultData), result, rows);
+  }
 };
 
 // The expected result was obtained by running SELECT xxhash64("Spark") query
@@ -138,6 +176,136 @@ TEST_F(XxHash64Test, float) {
   EXPECT_EQ(xxhash64<float>(-limits::infinity()), -7580553461823983095);
 }
 
+TEST_F(XxHash64Test, array) {
+  assertEqualVectors(
+      makeFlatVector<int64_t>({-6041664978295882827, 42, 4904562767517797033}),
+      xxhash64(makeArrayVector<int64_t>({{1, 2, 3, 4, 5}, {}, {1, 2, 3}})));
+
+  assertEqualVectors(
+      makeFlatVector<int64_t>({-6698625589789238999, 8420071140774656230, 42}),
+      xxhash64(makeNullableArrayVector<int32_t>(
+          {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
+
+  // Nested array.
+  {
+    auto arrayVector = makeNestedArrayVectorFromJson<int64_t>(
+        {"[[1, null, 2, 3], [4, 5]]",
+         "[[1, null, 2, 3], [6, 7, 8]]",
+         "[[]]",
+         "[[null]]",
+         "[null]"});
+    assertEqualVectors(
+        makeFlatVector<int64_t>(
+            {-6041664978295882827, -1052942565807509112, 42, 42, 42}),
+        xxhash64(arrayVector));
+  }
+
+  // Array of map.
+  {
+    using S = StringView;
+    using P = std::pair<int64_t, std::optional<S>>;
+    std::vector<P> a{P{1, S{"a"}}, P{2, std::nullopt}};
+    std::vector<P> b{P{3, S{"c"}}};
+    std::vector<std::vector<std::vector<P>>> data = {{a, b}};
+    auto arrayVector = makeArrayOfMapVector<int64_t, S>(data);
+    assertEqualVectors(
+        makeFlatVector<int64_t>(std::vector<int64_t>{2880747995994395223}),
+        xxhash64(arrayVector));
+  }
+
+  // Array of row.
+  {
+    std::vector<std::vector<std::optional<std::tuple<int32_t, std::string>>>>
+        data = {
+            {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+            {{{1, "red"}}, std::nullopt, {{3, "green"}}},
+            {std::nullopt},
+        };
+    auto arrayVector = makeArrayOfRowVector(data, ROW({INTEGER(), VARCHAR()}));
+    assertEqualVectors(
+        makeFlatVector<int64_t>(
+            {-4096178443626566478, -8973283971856715104, 42}),
+        xxhash64(arrayVector));
+  }
+}
+
+TEST_F(XxHash64Test, map) {
+  auto mapVector = makeMapVector<int64_t, double>(
+      {{{1, 17.0}, {2, 36.0}, {3, 8.0}, {4, 28.0}, {5, 24.0}, {6, 32.0}}});
+  assertEqualVectors(
+      makeFlatVector<int64_t>(std::vector<int64_t>{-6303587702533348160}),
+      xxhash64(mapVector));
+
+  auto mapOfArrays = createMapOfArraysVector<int32_t, int32_t>(
+      {{{1, {{1, 2, 3}}}}, {{2, {{4, 5, 6}}}}, {{3, {{7, 8, 9}}}}});
+  assertEqualVectors(
+      makeFlatVector<int64_t>(
+          {-2103781794412908874, 1112887818746642853, 5787852566364222439}),
+      xxhash64(mapOfArrays));
+
+  auto mapWithNullArrays = createMapOfArraysVector<int64_t, int64_t>(
+      {{{1, std::nullopt}}, {{2, {{4, 5, std::nullopt}}}}, {{3, {{}}}}});
+  assertEqualVectors(
+      makeFlatVector<int64_t>(
+          {-7001672635703045582, 7217681953522744649, 3188756510806108107}),
+      xxhash64(mapWithNullArrays));
+}
+
+TEST_F(XxHash64Test, row) {
+  auto row = makeRowVector({
+      makeFlatVector<int64_t>({1, 3}),
+      makeFlatVector<int64_t>({2, 4}),
+  });
+  assertEqualVectors(
+      makeFlatVector<int64_t>({-8198029865082835910, 351067884137457704}),
+      xxhash64(row));
+
+  row = makeRowVector({
+      makeNullableFlatVector<int64_t>({1, std::nullopt}),
+      makeNullableFlatVector<int64_t>({std::nullopt, 4}),
+  });
+  assertEqualVectors(
+      makeFlatVector<int64_t>({-7001672635703045582, 404280023041566627}),
+      xxhash64(row));
+
+  row->setNull(0, true);
+  assertEqualVectors(
+      makeFlatVector<int64_t>({42, 404280023041566627}), xxhash64(row));
+
+  row->setNull(1, true);
+  assertEqualVectors(makeFlatVector<int64_t>({42, 42}), xxhash64(row));
+}
+
+TEST_F(XxHash64Test, unknown) {
+  assertEqualVectors(
+      makeFlatVector<int64_t>({42, 42, 42}),
+      xxhash64(makeAllNullFlatVector<UnknownValue>(3)));
+
+  assertEqualVectors(
+      makeFlatVector<int64_t>({42, 42}),
+      xxhash64(makeNullableArrayVector<UnknownValue>({
+          {std::nullopt, std::nullopt},
+          {std::nullopt, std::nullopt, std::nullopt},
+      })));
+
+  auto mapVector = makeNullableMapVector<UnknownValue, UnknownValue>({
+      std::nullopt,
+      std::nullopt,
+      std::nullopt,
+  });
+  assertEqualVectors(
+      makeFlatVector<int64_t>({42, 42, 42}), xxhash64(mapVector));
+
+  auto row = makeRowVector({
+      makeFlatVector<int64_t>({1, 3, 4}),
+      makeAllNullFlatVector<UnknownValue>(3),
+  });
+  assertEqualVectors(
+      makeFlatVector<int64_t>(
+          {-7001672635703045582, 3188756510806108107, 404280023041566627}),
+      xxhash64(row));
+}
+
 TEST_F(XxHash64Test, hashSeed) {
   auto xxhash64WithSeed = [&](int64_t seed, const std::optional<int64_t>& arg) {
     return evaluateOnce<int64_t>(
@@ -177,5 +345,22 @@ TEST_F(XxHash64Test, hashSeedVarcharArgs) {
   EXPECT_EQ(xxhash64WithSeed(0L, "", "hello"), 1992633642622160295);
 }
 
+TEST_F(XxHash64Test, simd) {
+  runSIMDHashAndAssert<int8_t>(1, -6698625589789238999, 1024);
+  runSIMDHashAndAssert<int16_t>(-1, 2017008487422258757, 4096);
+  runSIMDHashAndAssert<int32_t>(0xcafecafe, 3599843564351570672, 33);
+  runSIMDHashAndAssert<int64_t>(-1, 3858142552250413010, 34);
+  runSIMDHashAndAssert<std::string>("Spark", -4294468057691064905, 33);
+  runSIMDHashAndAssert<float>(1, 700633588856507837, 77);
+  runSIMDHashAndAssert<double>(1, -2162451265447482029, 1000);
+  runSIMDHashAndAssert<Timestamp>(
+      Timestamp::fromMicros(12345678), 782671362992292307, 1000);
+
+  runSIMDHashAndAssert<int64_t>(-1, 3858142552250413010, 1024, 1023);
+  runSIMDHashAndAssert<int64_t>(-1, 3858142552250413010, 1024, 512);
+  runSIMDHashAndAssert<int64_t>(-1, 3858142552250413010, 1024, 3);
+  runSIMDHashAndAssert<UnknownValue>(UnknownValue(), 42, 10);
+}
+
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/window/CMakeLists.txt b/velox/functions/sparksql/window/CMakeLists.txt
index f79546442d793..0aac945967174 100644
--- a/velox/functions/sparksql/window/CMakeLists.txt
+++ b/velox/functions/sparksql/window/CMakeLists.txt
@@ -11,10 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_functions_spark_window WindowFunctionsRegistration.cpp)
+velox_add_library(velox_functions_spark_window WindowFunctionsRegistration.cpp)
 
-target_link_libraries(velox_functions_spark_window velox_buffer velox_exec
-                      velox_functions_window Folly::folly)
+velox_link_libraries(
+  velox_functions_spark_window
+  velox_buffer
+  velox_exec
+  velox_functions_window
+  Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/sparksql/window/WindowFunctionsRegistration.cpp b/velox/functions/sparksql/window/WindowFunctionsRegistration.cpp
index 7100b779bcec1..5a603b75f602b 100644
--- a/velox/functions/sparksql/window/WindowFunctionsRegistration.cpp
+++ b/velox/functions/sparksql/window/WindowFunctionsRegistration.cpp
@@ -23,6 +23,7 @@ void registerWindowFunctions(const std::string& prefix) {
   functions::window::registerRowNumberInteger(prefix + "row_number");
   functions::window::registerRankInteger(prefix + "rank");
   functions::window::registerDenseRankInteger(prefix + "dense_rank");
+  functions::window::registerNtileInteger(prefix + "ntile");
 }
 
 } // namespace facebook::velox::functions::window::sparksql
diff --git a/velox/functions/sparksql/window/tests/CMakeLists.txt b/velox/functions/sparksql/window/tests/CMakeLists.txt
index 9e2b17d48a934..f0498d83e44cb 100644
--- a/velox/functions/sparksql/window/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/window/tests/CMakeLists.txt
@@ -21,8 +21,8 @@ set(CMAKE_WINDOW_TEST_LINK_LIBRARIES
     velox_vector_fuzzer
     velox_vector_test_lib
     gflags::gflags
-    gtest
-    gtest_main)
+    GTest::gtest
+    GTest::gtest_main)
 
 set(CMAKE_WINDOW_TEST_MAIN_FILES Main.cpp)
 
@@ -34,5 +34,5 @@ add_test(
   COMMAND velox_spark_windows_test
   WORKING_DIRECTORY .)
 
-target_link_libraries(velox_spark_windows_test
-                      ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
+target_link_libraries(
+  velox_spark_windows_test ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
diff --git a/velox/functions/sparksql/window/tests/Main.cpp b/velox/functions/sparksql/window/tests/Main.cpp
index 684d28a087971..fe6fb2fb6aeee 100644
--- a/velox/functions/sparksql/window/tests/Main.cpp
+++ b/velox/functions/sparksql/window/tests/Main.cpp
@@ -18,6 +18,6 @@
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/functions/sparksql/window/tests/SparkWindowTest.cpp b/velox/functions/sparksql/window/tests/SparkWindowTest.cpp
index 5102c9a1a3c45..92478c7bcf159 100644
--- a/velox/functions/sparksql/window/tests/SparkWindowTest.cpp
+++ b/velox/functions/sparksql/window/tests/SparkWindowTest.cpp
@@ -25,9 +25,15 @@ namespace {
 
 static const std::vector<std::string> kSparkWindowFunctions = {
     std::string("nth_value(c0, 1)"),
+    std::string("nth_value(c0, c3)"),
     std::string("row_number()"),
     std::string("rank()"),
-    std::string("dense_rank()")};
+    std::string("dense_rank()"),
+    std::string("ntile(c3)"),
+    std::string("ntile(1)"),
+    std::string("ntile(7)"),
+    std::string("ntile(10)"),
+    std::string("ntile(16)")};
 
 struct SparkWindowTestParam {
   const std::string function;
@@ -100,5 +106,5 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     SparkWindowTest,
     testing::ValuesIn(getSparkWindowTestParams()));
 
-}; // namespace
-}; // namespace facebook::velox::window::test
+} // namespace
+} // namespace facebook::velox::window::test
diff --git a/velox/functions/tests/CMakeLists.txt b/velox/functions/tests/CMakeLists.txt
index 9a0836d610577..6b5401bacff89 100644
--- a/velox/functions/tests/CMakeLists.txt
+++ b/velox/functions/tests/CMakeLists.txt
@@ -15,5 +15,10 @@ add_executable(velox_function_registry_test FunctionRegistryTest.cpp)
 
 add_test(NAME velox_function_registry_test COMMAND velox_function_registry_test)
 
-target_link_libraries(velox_function_registry_test velox_function_registry
-                      gmock gtest gtest_main)
+target_link_libraries(
+  velox_function_registry_test
+  velox_function_registry
+  velox_functions_test_lib
+  GTest::gmock
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/functions/tests/FunctionRegistryTest.cpp b/velox/functions/tests/FunctionRegistryTest.cpp
index 4b051031aeef8..6c10e18dc92d9 100644
--- a/velox/functions/tests/FunctionRegistryTest.cpp
+++ b/velox/functions/tests/FunctionRegistryTest.cpp
@@ -24,6 +24,8 @@
 #include "velox/functions/FunctionRegistry.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
@@ -47,8 +49,10 @@ struct FuncOne {
 template <typename T>
 struct FuncTwo {
   template <typename T1, typename T2>
-  FOLLY_ALWAYS_INLINE bool
-  call(int64_t& /* result */, const T1& /* arg1 */, const T2& /* arg2 */) {
+  FOLLY_ALWAYS_INLINE bool callNullable(
+      int64_t& /* result */,
+      const T1* /* arg1 */,
+      const T2* /* arg2 */) {
     return true;
   }
 };
@@ -77,9 +81,18 @@ struct FuncFour {
 
 template <typename T>
 struct FuncFive {
-  FOLLY_ALWAYS_INLINE bool call(
-      int64_t& /* result */,
-      const int64_t& /* arg1 */) {
+  FOLLY_ALWAYS_INLINE bool call(int64_t& result, const int64_t& /* arg1 */) {
+    result = 5;
+    return true;
+  }
+};
+
+// FuncSix has the same signature as FuncFive. It's used to test overwrite
+// during registration.
+template <typename T>
+struct FuncSix {
+  FOLLY_ALWAYS_INLINE bool call(int64_t& result, const int64_t& /* arg1 */) {
+    result = 6;
     return true;
   }
 };
@@ -171,11 +184,6 @@ class VectorFuncFour : public velox::exec::VectorFunction {
                 .argumentType("map(K,V)")
                 .build()};
   }
-
-  // Make it non-deterministic.
-  bool isDeterministic() const override {
-    return false;
-  }
 };
 
 VELOX_DECLARE_VECTOR_FUNCTION(
@@ -193,9 +201,10 @@ VELOX_DECLARE_VECTOR_FUNCTION(
     VectorFuncThree::signatures(),
     std::make_unique<VectorFuncThree>());
 
-VELOX_DECLARE_VECTOR_FUNCTION(
+VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     udf_vector_func_four,
     VectorFuncFour::signatures(),
+    exec::VectorFunctionMetadataBuilder().deterministic(false).build(),
     std::make_unique<VectorFuncFour>());
 
 inline void registerTestFunctions() {
@@ -225,7 +234,7 @@ inline void registerTestFunctions() {
 }
 } // namespace
 
-class FunctionRegistryTest : public ::testing::Test {
+class FunctionRegistryTest : public testing::Test {
  public:
   FunctionRegistryTest() {
     registerTestFunctions();
@@ -342,8 +351,7 @@ TEST_F(FunctionRegistryTest, getFunctionSignatures) {
       functionSignatures["variadic_func"].at(0)->toString(),
       exec::FunctionSignatureBuilder()
           .returnType("varchar")
-          .argumentType("varchar")
-          .variableArity()
+          .variableArity("varchar")
           .build()
           ->toString());
 
@@ -382,6 +390,27 @@ TEST_F(FunctionRegistryTest, getFunctionSignatures) {
           ->toString());
 }
 
+TEST_F(FunctionRegistryTest, getVectorFunctionSignatures) {
+  auto functionSignatures = getVectorFunctionSignatures();
+  ASSERT_EQ(functionSignatures.size(), 5);
+
+  std::set<std::string> functionNames;
+  std::transform(
+      functionSignatures.begin(),
+      functionSignatures.end(),
+      std::inserter(functionNames, functionNames.end()),
+      [](auto& signature) { return signature.first; });
+
+  ASSERT_THAT(
+      functionNames,
+      ::testing::UnorderedElementsAre(
+          "vector_func_one",
+          "vector_func_one_alias",
+          "vector_func_two",
+          "vector_func_three",
+          "vector_func_four"));
+}
+
 TEST_F(FunctionRegistryTest, hasSimpleFunctionSignature) {
   auto result = resolveFunction("func_one", {VARCHAR()});
   ASSERT_EQ(*result, *VARCHAR());
@@ -466,6 +495,20 @@ TEST_F(FunctionRegistryTest, functionNameInMixedCase) {
   ASSERT_EQ(*result, *VARCHAR());
 }
 
+TEST_F(FunctionRegistryTest, isDeterministic) {
+  functions::prestosql::registerAllScalarFunctions();
+  ASSERT_TRUE(isDeterministic("plus").value());
+  ASSERT_TRUE(isDeterministic("in").value());
+
+  ASSERT_FALSE(isDeterministic("rand").value());
+  ASSERT_FALSE(isDeterministic("uuid").value());
+  ASSERT_FALSE(isDeterministic("shuffle").value());
+
+  // Not found functions.
+  ASSERT_FALSE(isDeterministic("cast").has_value());
+  ASSERT_FALSE(isDeterministic("not_found_function").has_value());
+}
+
 template <typename T>
 struct TestFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -564,4 +607,51 @@ TEST_F(FunctionRegistryTest, resolveCast) {
       velox::VeloxRuntimeError);
 }
 
+TEST_F(FunctionRegistryTest, resolveWithMetadata) {
+  auto result = resolveFunctionWithMetadata("func_one", {VARCHAR()});
+  EXPECT_TRUE(result.has_value());
+  EXPECT_EQ(*result->first, *VARCHAR());
+  EXPECT_TRUE(result->second.defaultNullBehavior);
+  EXPECT_FALSE(result->second.deterministic);
+  EXPECT_FALSE(result->second.supportsFlattening);
+
+  result = resolveFunctionWithMetadata("func_two", {BIGINT(), INTEGER()});
+  EXPECT_TRUE(result.has_value());
+  EXPECT_EQ(*result->first, *BIGINT());
+  EXPECT_FALSE(result->second.defaultNullBehavior);
+  EXPECT_TRUE(result->second.deterministic);
+  EXPECT_FALSE(result->second.supportsFlattening);
+
+  result = resolveFunctionWithMetadata(
+      "vector_func_four", {MAP(INTEGER(), VARCHAR())});
+  EXPECT_TRUE(result.has_value());
+  EXPECT_EQ(*result->first, *ARRAY(INTEGER()));
+  EXPECT_TRUE(result->second.defaultNullBehavior);
+  EXPECT_FALSE(result->second.deterministic);
+  EXPECT_FALSE(result->second.supportsFlattening);
+
+  result = resolveFunctionWithMetadata("non-existent-function", {VARCHAR()});
+  EXPECT_FALSE(result.has_value());
+}
+
+class FunctionRegistryOverwriteTest : public functions::test::FunctionBaseTest {
+ public:
+  FunctionRegistryOverwriteTest() {
+    registerTestFunctions();
+  }
+};
+
+TEST_F(FunctionRegistryOverwriteTest, overwrite) {
+  ASSERT_TRUE((registerFunction<FuncFive, int64_t, int64_t>({"foo"})));
+  ASSERT_FALSE(
+      (registerFunction<FuncSix, int64_t, int64_t>({"foo"}, {}, false)));
+  ASSERT_TRUE((evaluateOnce<int64_t, int64_t>("foo(c0)", 0) == 5));
+  ASSERT_TRUE((registerFunction<FuncSix, int64_t, int64_t>({"foo"})));
+  ASSERT_TRUE((evaluateOnce<int64_t, int64_t>("foo(c0)", 0) == 6));
+
+  auto& simpleFunctions = exec::simpleFunctions();
+  auto signatures = simpleFunctions.getFunctionSignatures("foo");
+  ASSERT_EQ(signatures.size(), 1);
+}
+
 } // namespace facebook::velox
diff --git a/velox/parse/CMakeLists.txt b/velox/parse/CMakeLists.txt
index 45b00d490fd42..75a5e835933c5 100644
--- a/velox/parse/CMakeLists.txt
+++ b/velox/parse/CMakeLists.txt
@@ -11,17 +11,25 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_parse_expression Expressions.cpp)
-target_link_libraries(velox_parse_expression velox_type velox_parse_utils
-                      velox_expression velox_exec)
+velox_add_library(velox_parse_expression Expressions.cpp)
+velox_link_libraries(
+  velox_parse_expression
+  velox_type
+  velox_parse_utils
+  velox_expression
+  velox_exec)
 
-add_library(velox_parse_parser ExpressionsParser.cpp QueryPlanner.cpp)
-target_link_libraries(velox_parse_parser velox_parse_expression velox_type
-                      velox_duckdb_parser)
+velox_add_library(velox_parse_parser ExpressionsParser.cpp QueryPlanner.cpp)
+velox_link_libraries(velox_parse_parser velox_parse_expression velox_type
+                     velox_duckdb_parser)
 
-add_library(velox_parse_utils TypeResolver.cpp)
-target_link_libraries(velox_parse_utils velox_buffer velox_type velox_vector
-                      velox_function_registry)
+velox_add_library(velox_parse_utils TypeResolver.cpp)
+velox_link_libraries(
+  velox_parse_utils
+  velox_buffer
+  velox_type
+  velox_vector
+  velox_function_registry)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/parse/DuckLogicalOperator.h b/velox/parse/DuckLogicalOperator.h
index e0559b01b96a3..fc5b063e06356 100644
--- a/velox/parse/DuckLogicalOperator.h
+++ b/velox/parse/DuckLogicalOperator.h
@@ -41,7 +41,7 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
-#include "velox/external/duckdb/duckdb.hpp"
+#include <duckdb.hpp> // @manual
 
 namespace duckdb {
 
diff --git a/velox/parse/Expressions.cpp b/velox/parse/Expressions.cpp
index 2b51bd1aa09b5..feb87a3801f66 100644
--- a/velox/parse/Expressions.cpp
+++ b/velox/parse/Expressions.cpp
@@ -29,13 +29,6 @@ namespace facebook::velox::core {
 Expressions::TypeResolverHook Expressions::resolverHook_;
 
 namespace {
-std::vector<TypePtr> getTypes(const std::vector<TypedExprPtr>& inputs) {
-  std::vector<TypePtr> types{};
-  for (auto& i : inputs) {
-    types.push_back(i->type());
-  }
-  return types;
-}
 
 // Determine output type based on input types.
 TypePtr resolveTypeImpl(
@@ -49,8 +42,8 @@ TypePtr resolveTypeImpl(
 namespace {
 std::shared_ptr<const core::CastTypedExpr> makeTypedCast(
     const TypePtr& type,
-    const std::vector<TypedExprPtr>& inputs) {
-  return std::make_shared<const core::CastTypedExpr>(type, inputs, false);
+    const TypedExprPtr& input) {
+  return std::make_shared<const core::CastTypedExpr>(type, input, false);
 }
 
 std::vector<TypePtr> implicitCastTargets(const TypePtr& type) {
@@ -85,7 +78,7 @@ std::vector<TypePtr> implicitCastTargets(const TypePtr& type) {
       break;
     }
     default: // make compilers happy
-        ;
+      (void)0; // Statement to avoid empty semicolon warning
   }
   return targetTypes;
 }
@@ -100,7 +93,7 @@ std::vector<TypedExprPtr> genImplicitCasts(const TypedExprPtr& typedExpr) {
   std::vector<TypedExprPtr> implicitCasts;
   implicitCasts.reserve(targetTypes.size());
   for (auto targetType : targetTypes) {
-    implicitCasts.emplace_back(makeTypedCast(targetType, {typedExpr}));
+    implicitCasts.emplace_back(makeTypedCast(targetType, typedExpr));
   }
   return implicitCasts;
 }
@@ -141,21 +134,6 @@ TypedExprPtr adjustLastNArguments(
   return nullptr;
 }
 
-std::string toString(
-    const std::shared_ptr<const core::CallExpr>& expr,
-    const std::vector<TypedExprPtr>& inputs) {
-  std::ostringstream signature;
-  signature << expr->getFunctionName() << "(";
-  for (auto i = 0; i < inputs.size(); i++) {
-    if (i > 0) {
-      signature << ", ";
-    }
-    signature << inputs[i]->type()->toString();
-  }
-  signature << ")";
-  return signature.str();
-}
-
 TypedExprPtr createWithImplicitCast(
     const std::shared_ptr<const core::CallExpr>& expr,
     const std::vector<TypedExprPtr>& inputs) {
@@ -207,12 +185,14 @@ TypedExprPtr Expressions::inferTypes(
   VELOX_CHECK_NOT_NULL(expr);
 
   if (auto lambdaExpr = std::dynamic_pointer_cast<const LambdaExpr>(expr)) {
-    return resolveLambdaExpr(lambdaExpr, inputRow, lambdaInputTypes, pool);
+    return resolveLambdaExpr(
+        lambdaExpr, inputRow, lambdaInputTypes, pool, complexConstants);
   }
 
   if (auto call = std::dynamic_pointer_cast<const CallExpr>(expr)) {
     if (!expr->getInputs().empty()) {
-      if (auto returnType = tryResolveCallWithLambdas(call, inputRow, pool)) {
+      if (auto returnType = tryResolveCallWithLambdas(
+              call, inputRow, pool, complexConstants)) {
         return returnType;
       }
     }
@@ -221,8 +201,15 @@ TypedExprPtr Expressions::inferTypes(
   // try rebuilding complex constant type from vector
   if (auto fun = std::dynamic_pointer_cast<const CallExpr>(expr)) {
     if (fun->getFunctionName() == "__complex_constant") {
-      VELOX_CHECK(complexConstants);
+      VELOX_CHECK_NOT_NULL(
+          complexConstants,
+          "Expression contains __complex_constant function call, but complexConstants is missing");
+
       auto ccInputRow = complexConstants->as<RowVector>();
+      VELOX_CHECK_NOT_NULL(
+          ccInputRow,
+          "Expected RowVector for complexConstants: {}",
+          complexConstants->toString());
       auto name =
           std::dynamic_pointer_cast<const FieldAccessExpr>(fun->getInputs()[0])
               ->getFieldName();
@@ -268,11 +255,16 @@ TypedExprPtr Expressions::inferTypes(
       // ConstantVector<ComplexType>.
       VELOX_CHECK_NOT_NULL(
           pool, "parsing array literals requires a memory pool");
-      auto arrayVector = variantArrayToVector(
-          constant->type(), constant->value().array(), pool);
-      auto constantVector =
-          std::make_shared<ConstantVector<velox::ComplexType>>(
-              pool, 1, 0, arrayVector);
+      VectorPtr constantVector;
+      if (constant->value().isNull()) {
+        constantVector =
+            BaseVector::createNullConstant(constant->type(), 1, pool);
+      } else {
+        auto arrayVector = variantArrayToVector(
+            constant->type(), constant->value().array(), pool);
+        constantVector = std::make_shared<ConstantVector<velox::ComplexType>>(
+            pool, 1, 0, arrayVector);
+      }
       return std::make_shared<const ConstantTypedExpr>(constantVector);
     }
     return std::make_shared<const ConstantTypedExpr>(
@@ -294,7 +286,8 @@ TypedExprPtr Expressions::resolveLambdaExpr(
     const std::shared_ptr<const core::LambdaExpr>& lambdaExpr,
     const TypePtr& inputRow,
     const std::vector<TypePtr>& lambdaInputTypes,
-    memory::MemoryPool* pool) {
+    memory::MemoryPool* pool,
+    const VectorPtr& complexConstants) {
   auto names = lambdaExpr->inputNames();
   auto body = lambdaExpr->body();
 
@@ -318,7 +311,7 @@ TypedExprPtr Expressions::resolveLambdaExpr(
   auto lambdaRow = ROW(std::move(names), std::move(types));
 
   return std::make_shared<LambdaTypedExpr>(
-      signature, inferTypes(body, lambdaRow, pool));
+      signature, inferTypes(body, lambdaRow, pool, complexConstants));
 }
 
 namespace {
@@ -413,7 +406,8 @@ const exec::FunctionSignature* findLambdaSignature(
 TypedExprPtr Expressions::tryResolveCallWithLambdas(
     const std::shared_ptr<const CallExpr>& callExpr,
     const TypePtr& inputRow,
-    memory::MemoryPool* pool) {
+    memory::MemoryPool* pool,
+    const VectorPtr& complexConstants) {
   auto signature = findLambdaSignature(callExpr);
 
   if (signature == nullptr) {
@@ -426,7 +420,8 @@ TypedExprPtr Expressions::tryResolveCallWithLambdas(
   std::vector<TypePtr> childTypes(numArgs);
   for (auto i = 0; i < numArgs; ++i) {
     if (!isLambdaArgument(signature->argumentTypes()[i])) {
-      children[i] = inferTypes(callExpr->getInputs()[i], inputRow, pool);
+      children[i] = inferTypes(
+          callExpr->getInputs()[i], inputRow, pool, complexConstants);
       childTypes[i] = children[i]->type();
     }
   }
@@ -446,8 +441,12 @@ TypedExprPtr Expressions::tryResolveCallWithLambdas(
         lambdaTypes.push_back(type);
       }
 
-      children[i] =
-          inferTypes(callExpr->getInputs()[i], inputRow, lambdaTypes, pool);
+      children[i] = inferTypes(
+          callExpr->getInputs()[i],
+          inputRow,
+          lambdaTypes,
+          pool,
+          complexConstants);
     }
   }
 
diff --git a/velox/parse/Expressions.h b/velox/parse/Expressions.h
index 260cdcbe5c66d..7f7de046abcf7 100644
--- a/velox/parse/Expressions.h
+++ b/velox/parse/Expressions.h
@@ -60,12 +60,14 @@ class Expressions {
       const std::shared_ptr<const core::LambdaExpr>& lambdaExpr,
       const TypePtr& inputRow,
       const std::vector<TypePtr>& lambdaInputTypes,
-      memory::MemoryPool* pool);
+      memory::MemoryPool* pool,
+      const VectorPtr& complexConstants = nullptr);
 
   static TypedExprPtr tryResolveCallWithLambdas(
       const std::shared_ptr<const CallExpr>& expr,
       const TypePtr& input,
-      memory::MemoryPool* pool);
+      memory::MemoryPool* pool,
+      const VectorPtr& complexConstants = nullptr);
 
   static TypeResolverHook resolverHook_;
 };
diff --git a/velox/parse/QueryPlanner.cpp b/velox/parse/QueryPlanner.cpp
index bdd3f5a3a646c..deea47f34159a 100644
--- a/velox/parse/QueryPlanner.cpp
+++ b/velox/parse/QueryPlanner.cpp
@@ -15,9 +15,17 @@
  */
 #include "velox/parse/QueryPlanner.h"
 #include "velox/duckdb/conversion/DuckConversion.h"
-#include "velox/external/duckdb/duckdb.hpp"
 #include "velox/parse/DuckLogicalOperator.h"
 
+#include <duckdb.hpp> // @manual
+#include <duckdb/main/connection.hpp> // @manual
+#include <duckdb/planner/expression/bound_aggregate_expression.hpp> // @manual
+#include <duckdb/planner/expression/bound_cast_expression.hpp> // @manual
+#include <duckdb/planner/expression/bound_comparison_expression.hpp> // @manual
+#include <duckdb/planner/expression/bound_constant_expression.hpp> // @manual
+#include <duckdb/planner/expression/bound_function_expression.hpp> // @manual
+#include <duckdb/planner/expression/bound_reference_expression.hpp> // @manual
+
 namespace facebook::velox::core {
 
 namespace {
@@ -254,7 +262,7 @@ PlanNodePtr toVeloxPlan(
     memory::MemoryPool* pool,
     std::vector<PlanNodePtr> sources,
     QueryContext& queryContext) {
-  VELOX_CHECK_EQ(1, logicalFilter.expressions.size())
+  VELOX_CHECK_EQ(1, logicalFilter.expressions.size());
   auto filter = toVeloxExpression(
       *logicalFilter.expressions.front(), sources[0]->outputType());
   return std::make_shared<FilterNode>(
@@ -516,7 +524,8 @@ void DuckDbQueryPlanner::registerTable(
   auto createTableSql =
       duckdb::makeCreateTableSql(name, *asRowType(data[0]->type()));
   auto res = conn_.Query(createTableSql);
-  VELOX_CHECK(res->success, "Failed to create DuckDB table: {}", res->error);
+  VELOX_CHECK(
+      !res->HasError(), "Failed to create DuckDB table: {}", res->GetError());
 
   tables_.insert({name, data});
 }
@@ -525,7 +534,7 @@ void DuckDbQueryPlanner::registerScalarFunction(
     const std::string& name,
     const std::vector<TypePtr>& argTypes,
     const TypePtr& returnType) {
-  std::vector<::duckdb::LogicalType> argDuckTypes;
+  ::duckdb::vector<::duckdb::LogicalType> argDuckTypes;
   for (auto& type : argTypes) {
     argDuckTypes.push_back(duckdb::fromVeloxType(type));
   }
@@ -541,7 +550,7 @@ void DuckDbQueryPlanner::registerAggregateFunction(
     const std::string& name,
     const std::vector<TypePtr>& argTypes,
     const TypePtr& returnType) {
-  std::vector<::duckdb::LogicalType> argDuckTypes;
+  ::duckdb::vector<::duckdb::LogicalType> argDuckTypes;
   for (auto& type : argTypes) {
     argDuckTypes.push_back(duckdb::fromVeloxType(type));
   }
diff --git a/velox/parse/QueryPlanner.h b/velox/parse/QueryPlanner.h
index abef3e0f01854..ba98e74401a93 100644
--- a/velox/parse/QueryPlanner.h
+++ b/velox/parse/QueryPlanner.h
@@ -16,9 +16,10 @@
 #pragma once
 
 #include "velox/core/PlanNode.h"
-#include "velox/external/duckdb/duckdb.hpp"
 #include "velox/parse/PlanNodeIdGenerator.h"
 
+#include <duckdb.hpp> // @manual
+
 namespace facebook::velox::core {
 
 class DuckDbQueryPlanner {
diff --git a/velox/parse/tests/CMakeLists.txt b/velox/parse/tests/CMakeLists.txt
index 209219ab492b7..e6309be1f251a 100644
--- a/velox/parse/tests/CMakeLists.txt
+++ b/velox/parse/tests/CMakeLists.txt
@@ -16,5 +16,9 @@ add_executable(velox_parse_test QueryPlannerTest.cpp)
 
 add_test(velox_parse_test velox_parse_test)
 
-target_link_libraries(velox_parse_test velox_parse_parser gtest gtest_main
-                      gflags::gflags)
+target_link_libraries(
+  velox_parse_test
+  velox_parse_parser
+  GTest::gtest
+  GTest::gtest_main
+  gflags::gflags)
diff --git a/velox/parse/tests/QueryPlannerTest.cpp b/velox/parse/tests/QueryPlannerTest.cpp
index d906efb6d8689..8a227ab695d90 100644
--- a/velox/parse/tests/QueryPlannerTest.cpp
+++ b/velox/parse/tests/QueryPlannerTest.cpp
@@ -20,6 +20,10 @@ namespace facebook::velox::core::test {
 
 class QueryPlannerTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void assertPlan(
       const std::string& sql,
       const std::unordered_map<std::string, std::vector<RowVectorPtr>>&
@@ -54,42 +58,43 @@ class QueryPlannerTest : public testing::Test {
         std::vector<VectorPtr>{});
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 TEST_F(QueryPlannerTest, values) {
   assertPlan(
       "SELECT x, x + 5 FROM UNNEST([1, 2, 3]) as t(x)",
-      "-- Project\n"
-      "  -- Unnest\n"
-      "    -- Project\n"
-      "      -- Values\n");
+      "-- Project[3]\n"
+      "  -- Unnest[2]\n"
+      "    -- Project[1]\n"
+      "      -- Values[0]\n");
 
   assertPlan(
       "SELECT sum(x) FROM UNNEST([1, 2, 3]) as t(x)",
-      "-- Project\n"
-      "  -- Aggregation\n"
-      "    -- Unnest\n"
-      "      -- Project\n"
-      "        -- Values\n");
+      "-- Project[4]\n"
+      "  -- Aggregation[3]\n"
+      "    -- Unnest[2]\n"
+      "      -- Project[1]\n"
+      "        -- Values[0]\n");
 
   assertPlan(
       "SELECT x % 5, sum(x) FROM UNNEST([1, 2, 3]) as t(x) GROUP BY 1",
-      "-- Project\n"
-      "  -- Aggregation\n"
-      "    -- Project\n"
-      "      -- Unnest\n"
-      "        -- Project\n"
-      "          -- Values\n");
+      "-- Project[5]\n"
+      "  -- Aggregation[4]\n"
+      "    -- Project[3]\n"
+      "      -- Unnest[2]\n"
+      "        -- Project[1]\n"
+      "          -- Values[0]\n");
 
   assertPlan(
       "SELECT sum(x * 4) FROM UNNEST([1, 2, 3]) as t(x)",
-      "-- Project\n"
-      "  -- Aggregation\n"
-      "    -- Project\n"
-      "      -- Unnest\n"
-      "        -- Project\n"
-      "          -- Values\n");
+      "-- Project[5]\n"
+      "  -- Aggregation[4]\n"
+      "    -- Project[3]\n"
+      "      -- Unnest[2]\n"
+      "        -- Project[1]\n"
+      "          -- Values[0]\n");
 }
 
 TEST_F(QueryPlannerTest, tableScan) {
@@ -103,19 +108,19 @@ TEST_F(QueryPlannerTest, tableScan) {
   assertPlan(
       "SELECT a, sum(b) FROM t WHERE c > 5 GROUP BY 1",
       inMemoryTables,
-      "-- Project\n"
-      "  -- Aggregation\n"
-      "    -- Filter\n"
-      "      -- Values\n");
+      "-- Project[3]\n"
+      "  -- Aggregation[2]\n"
+      "    -- Filter[1]\n"
+      "      -- Values[0]\n");
 
   assertPlan(
       "SELECT t.a, t.b, t.c, u.b FROM t, u WHERE t.a = u.a",
       inMemoryTables,
-      "-- Project\n"
-      "  -- Filter\n"
-      "    -- NestedLoopJoin\n"
-      "      -- Values\n"
-      "      -- Values\n");
+      "-- Project[4]\n"
+      "  -- Filter[3]\n"
+      "    -- NestedLoopJoin[2]\n"
+      "      -- Values[0]\n"
+      "      -- Values[1]\n");
 }
 
 TEST_F(QueryPlannerTest, customScalarFunctions) {
@@ -127,10 +132,10 @@ TEST_F(QueryPlannerTest, customScalarFunctions) {
       planner.plan("SELECT foo(x), bar([x]) FROM UNNEST([1, 2, 3]) as t(x)");
   ASSERT_EQ(
       plan->toString(false, true),
-      "-- Project\n"
-      "  -- Unnest\n"
-      "    -- Project\n"
-      "      -- Values\n");
+      "-- Project[3]\n"
+      "  -- Unnest[2]\n"
+      "    -- Project[1]\n"
+      "      -- Values[0]\n");
 }
 
 TEST_F(QueryPlannerTest, customAggregateFunctions) {
@@ -144,12 +149,12 @@ TEST_F(QueryPlannerTest, customAggregateFunctions) {
       "SELECT foo_agg(x, x + 5), bar_agg([x], 1) FROM UNNEST([1, 2, 3]) as t(x)");
   ASSERT_EQ(
       plan->toString(false, true),
-      "-- Project\n"
-      "  -- Aggregation\n"
-      "    -- Project\n"
-      "      -- Unnest\n"
-      "        -- Project\n"
-      "          -- Values\n");
+      "-- Project[5]\n"
+      "  -- Aggregation[4]\n"
+      "    -- Project[3]\n"
+      "      -- Unnest[2]\n"
+      "        -- Project[1]\n"
+      "          -- Values[0]\n");
 }
 
 TEST_F(QueryPlannerTest, error) {
diff --git a/velox/row/CMakeLists.txt b/velox/row/CMakeLists.txt
index 175de09f24908..9eb9cb524682e 100644
--- a/velox/row/CMakeLists.txt
+++ b/velox/row/CMakeLists.txt
@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_row_fast UnsafeRowFast.cpp CompactRow.cpp)
+velox_add_library(velox_row_fast CompactRow.cpp UnsafeRowFast.cpp)
 
-target_link_libraries(velox_row_fast PUBLIC velox_vector)
+velox_link_libraries(velox_row_fast PUBLIC velox_vector)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/row/UnsafeRowDeserializers.h b/velox/row/UnsafeRowDeserializers.h
index 49cd3c63b93ad..bcda23dc60a88 100644
--- a/velox/row/UnsafeRowDeserializers.h
+++ b/velox/row/UnsafeRowDeserializers.h
@@ -287,8 +287,6 @@ struct ArrayBatchIterator : UnsafeRowDataBatchIterator {
   /**
    * Constructor for UnsafeRowArray.
    * @param data A batch of unsafe row array representation data.
-   * @param isFixedLength whether the elements in the array is fixed length
-   * @param fixedDataWidth the data width if the element is fixed length
    */
   ArrayBatchIterator(
       const std::vector<std::optional<std::string_view>>& data,
@@ -556,7 +554,7 @@ struct UnsafeRowPrimitiveBatchDeserializer {
 struct UnsafeRowDeserializer {
   /**
    * Allocate and populate the metadata Vectors in ArrayVector or MapVector.
-   * @param dataIterators iterator that points to whole column batch of data.
+   * @param dataIterator iterator that points to whole column batch of data.
    * process.
    * @param pool
    * @param size
@@ -613,7 +611,7 @@ struct UnsafeRowDeserializer {
 
   /**
    * Converts a list of MapBatchIterators to Vectors.
-   * @param dataIterators iterator that points to whole column batch of data.
+   * @param dataIterator iterator that points to whole column batch of data.
    * @param pool
    * @return a MapVectorPtr
    */
@@ -789,10 +787,9 @@ struct UnsafeRowDeserializer {
 
   /**
    * Calls createFlatVector with the correct template argument.
-   * @param dataIterators iterator that points to the first dataIterator to
+   * @param dataIterator iterator that points to the first dataIterator to
    * process.
    * @param pool
-   * @param numIteratorsToProcess
    * @return A FlatVector
    */
   static VectorPtr convertPrimitiveIteratorsToVectors(
diff --git a/velox/row/benchmark/DynamicRowVectorDeserializeBenchmark.cpp b/velox/row/benchmark/DynamicRowVectorDeserializeBenchmark.cpp
index 679feac385af3..e32623244a7a5 100644
--- a/velox/row/benchmark/DynamicRowVectorDeserializeBenchmark.cpp
+++ b/velox/row/benchmark/DynamicRowVectorDeserializeBenchmark.cpp
@@ -49,8 +49,8 @@ class UnsaferowBatchDeserializer : public Deserializer {
   }
 
  private:
-  std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::addDefaultLeafMemoryPool();
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 class BenchmarkHelper {
@@ -115,8 +115,8 @@ class BenchmarkHelper {
       MAP(VARCHAR(), ARRAY(INTEGER())),
       ROW({INTEGER()})};
 
-  std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::addDefaultLeafMemoryPool();
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 int deserialize(
@@ -173,7 +173,8 @@ BENCHMARK_NAMED_PARAM_MULTI(
 } // namespace facebook::spark::benchmarks
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  facebook::velox::memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/row/benchmark/UnsafeRowSerializeBenchmark.cpp b/velox/row/benchmark/UnsafeRowSerializeBenchmark.cpp
index 4f472452a4eb2..388908ecd7187 100644
--- a/velox/row/benchmark/UnsafeRowSerializeBenchmark.cpp
+++ b/velox/row/benchmark/UnsafeRowSerializeBenchmark.cpp
@@ -99,10 +99,9 @@ class SerializeBenchmark {
 
     auto copy = BaseVector::create(rowType, data->size(), pool());
 
-    ByteStream in;
-    HashStringAllocator::prepareRead(position.header, in);
+    auto in = HashStringAllocator::prepareRead(position.header);
     for (auto i = 0; i < data->size(); ++i) {
-      exec::ContainerRowSerde::deserialize(in, i, copy.get());
+      exec::ContainerRowSerde::deserialize(*in, i, copy.get());
     }
 
     VELOX_CHECK_EQ(copy->size(), data->size());
@@ -188,10 +187,11 @@ class SerializeBenchmark {
   HashStringAllocator::Position serialize(
       const RowVectorPtr& data,
       HashStringAllocator& allocator) {
-    ByteStream out(&allocator);
+    ByteOutputStream out(&allocator);
     auto position = allocator.newWrite(out);
+    const exec::ContainerRowSerdeOptions options{};
     for (auto i = 0; i < data->size(); ++i) {
-      exec::ContainerRowSerde::serialize(*data, i, out);
+      exec::ContainerRowSerde::serialize(*data, i, out, options);
     }
     allocator.finishWrite(out, 0);
     return position;
@@ -201,7 +201,8 @@ class SerializeBenchmark {
     return pool_.get();
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 #define SERDE_BENCHMARKS(name, rowType)      \
@@ -299,7 +300,8 @@ SERDE_BENCHMARKS(
 } // namespace facebook::velox::row
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  facebook::velox::memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/row/tests/CMakeLists.txt b/velox/row/tests/CMakeLists.txt
index 93ee13c9005df..4d1abfb28c58e 100644
--- a/velox/row/tests/CMakeLists.txt
+++ b/velox/row/tests/CMakeLists.txt
@@ -12,17 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_row_test UnsafeRowFuzzTest.cpp CompactRowTest.cpp)
+add_executable(velox_row_test CompactRowTest.cpp UnsafeRowFuzzTest.cpp)
 
 add_test(velox_row_test velox_row_test)
 
 target_link_libraries(
   velox_row_test
-  PRIVATE velox_exception
-          velox_row_fast
-          velox_vector
-          velox_vector_fuzzer
-          velox_vector_test_lib
-          Folly::folly
-          gtest
-          gtest_main)
+  PRIVATE
+    velox_exception
+    velox_row_fast
+    velox_vector
+    velox_vector_fuzzer
+    velox_vector_test_lib
+    Folly::folly
+    GTest::gtest
+    GTest::gtest_main)
diff --git a/velox/row/tests/CompactRowTest.cpp b/velox/row/tests/CompactRowTest.cpp
index f13157743a088..00ef636a0e309 100644
--- a/velox/row/tests/CompactRowTest.cpp
+++ b/velox/row/tests/CompactRowTest.cpp
@@ -27,6 +27,10 @@ namespace {
 
 class CompactRowTest : public ::testing::Test, public VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   /// TODO Replace with VectorFuzzer::fuzzInputRow once
   /// https://github.com/facebookincubator/velox/issues/6195 is fixed.
   RowVectorPtr fuzzInputRow(VectorFuzzer& fuzzer, const RowTypePtr& rowType) {
@@ -496,7 +500,6 @@ TEST_F(CompactRowTest, fuzz) {
   opts.vectorSize = 100;
   opts.containerLength = 5;
   opts.nullRatio = 0.1;
-  opts.containerHasNulls = true;
   opts.dictionaryHasNulls = false;
   opts.stringVariableLength = true;
   opts.stringLength = 20;
diff --git a/velox/row/tests/UnsafeRowFuzzTest.cpp b/velox/row/tests/UnsafeRowFuzzTest.cpp
index f85dc9cfeb7a1..8ce4ce74eb755 100644
--- a/velox/row/tests/UnsafeRowFuzzTest.cpp
+++ b/velox/row/tests/UnsafeRowFuzzTest.cpp
@@ -31,6 +31,10 @@ using namespace facebook::velox::test;
 
 class UnsafeRowFuzzTests : public ::testing::Test {
  public:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   UnsafeRowFuzzTests() {
     clearBuffers();
   }
@@ -48,7 +52,6 @@ class UnsafeRowFuzzTests : public ::testing::Test {
     VectorFuzzer::Options opts;
     opts.vectorSize = kNumBuffers;
     opts.nullRatio = 0.1;
-    opts.containerHasNulls = false;
     opts.dictionaryHasNulls = false;
     opts.stringVariableLength = true;
     opts.stringLength = 20;
@@ -91,7 +94,7 @@ class UnsafeRowFuzzTests : public ::testing::Test {
   std::array<char[kBufferSize], kNumBuffers> buffers_{};
 
   std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::addDefaultLeafMemoryPool();
+      memory::memoryManager()->addLeafPool();
 };
 
 TEST_F(UnsafeRowFuzzTests, fast) {
diff --git a/velox/serializers/CMakeLists.txt b/velox/serializers/CMakeLists.txt
index 1a6e499496846..72a069d8ca553 100644
--- a/velox/serializers/CMakeLists.txt
+++ b/velox/serializers/CMakeLists.txt
@@ -11,12 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(
-  velox_presto_serializer PrestoSerializer.cpp UnsafeRowSerializer.cpp
-                          CompactRowSerializer.cpp)
+velox_add_library(velox_presto_serializer CompactRowSerializer.cpp
+                  PrestoSerializer.cpp UnsafeRowSerializer.cpp)
 
-target_link_libraries(velox_presto_serializer velox_dwio_common velox_vector
-                      velox_row_fast)
+velox_link_libraries(velox_presto_serializer velox_vector velox_row_fast)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/serializers/CompactRowSerializer.cpp b/velox/serializers/CompactRowSerializer.cpp
index f3a7b4bee77f8..70407c0d4f474 100644
--- a/velox/serializers/CompactRowSerializer.cpp
+++ b/velox/serializers/CompactRowSerializer.cpp
@@ -20,14 +20,15 @@
 namespace facebook::velox::serializer {
 
 void CompactRowVectorSerde::estimateSerializedSize(
-    VectorPtr /* vector */,
+    const BaseVector* /* vector */,
     const folly::Range<const IndexRange*>& /* ranges */,
-    vector_size_t** /* sizes */) {
+    vector_size_t** /* sizes */,
+    Scratch& /*scratch*/) {
   VELOX_UNSUPPORTED();
 }
 
 namespace {
-class CompactRowVectorSerializer : public VectorSerializer {
+class CompactRowVectorSerializer : public IterativeVectorSerializer {
  public:
   using TRowSize = uint32_t;
 
@@ -36,7 +37,8 @@ class CompactRowVectorSerializer : public VectorSerializer {
 
   void append(
       const RowVectorPtr& vector,
-      const folly::Range<const IndexRange*>& ranges) override {
+      const folly::Range<const IndexRange*>& ranges,
+      Scratch& scratch) override {
     size_t totalSize = 0;
     row::CompactRow row(vector);
     if (auto fixedRowSize =
@@ -90,12 +92,36 @@ class CompactRowVectorSerializer : public VectorSerializer {
   }
 
  private:
-  memory::MemoryPool* const FOLLY_NONNULL pool_;
+  memory::MemoryPool* const pool_;
   std::vector<BufferPtr> buffers_;
 };
+
+// Read from the stream until the full row is concatenated.
+std::string concatenatePartialRow(
+    ByteInputStream* source,
+    std::string_view rowFragment,
+    CompactRowVectorSerializer::TRowSize rowSize) {
+  std::string rowBuffer;
+  rowBuffer.reserve(rowSize);
+  rowBuffer.append(rowFragment);
+
+  while (rowBuffer.size() < rowSize) {
+    rowFragment = source->nextView(rowSize - rowBuffer.size());
+    VELOX_CHECK_GT(
+        rowFragment.size(),
+        0,
+        "Unable to read full serialized CompactRow. Needed {} but read {} bytes.",
+        rowSize - rowBuffer.size(),
+        rowFragment.size());
+    rowBuffer += rowFragment;
+  }
+  return rowBuffer;
+}
+
 } // namespace
 
-std::unique_ptr<VectorSerializer> CompactRowVectorSerde::createSerializer(
+std::unique_ptr<IterativeVectorSerializer>
+CompactRowVectorSerde::createIterativeSerializer(
     RowTypePtr /* type */,
     int32_t /* numRows */,
     StreamArena* streamArena,
@@ -104,17 +130,27 @@ std::unique_ptr<VectorSerializer> CompactRowVectorSerde::createSerializer(
 }
 
 void CompactRowVectorSerde::deserialize(
-    ByteStream* source,
+    ByteInputStream* source,
     velox::memory::MemoryPool* pool,
     RowTypePtr type,
     RowVectorPtr* result,
     const Options* /* options */) {
   std::vector<std::string_view> serializedRows;
+  std::vector<std::string> concatenatedRows;
+
   while (!source->atEnd()) {
     // First read row size in big endian order.
     auto rowSize = folly::Endian::big(
         source->read<CompactRowVectorSerializer::TRowSize>());
     auto row = source->nextView(rowSize);
+
+    // If we couldn't read the entire row at once, we need to concatenate it
+    // in a different buffer.
+    if (row.size() < rowSize) {
+      concatenatedRows.push_back(concatenatePartialRow(source, row, rowSize));
+      row = concatenatedRows.back();
+    }
+
     VELOX_CHECK_EQ(row.size(), rowSize);
     serializedRows.push_back(row);
   }
diff --git a/velox/serializers/CompactRowSerializer.h b/velox/serializers/CompactRowSerializer.h
index 3ad0c99cbfa35..42a700282ecb1 100644
--- a/velox/serializers/CompactRowSerializer.h
+++ b/velox/serializers/CompactRowSerializer.h
@@ -23,15 +23,17 @@ namespace facebook::velox::serializer {
 class CompactRowVectorSerde : public VectorSerde {
  public:
   CompactRowVectorSerde() = default;
+
   // We do not implement this method since it is not used in production code.
   void estimateSerializedSize(
-      VectorPtr vector,
+      const BaseVector* vector,
       const folly::Range<const IndexRange*>& ranges,
-      vector_size_t** sizes) override;
+      vector_size_t** sizes,
+      Scratch& scratch) override;
 
   // This method is not used in production code. It is only used to
   // support round-trip tests for deserialization.
-  std::unique_ptr<VectorSerializer> createSerializer(
+  std::unique_ptr<IterativeVectorSerializer> createIterativeSerializer(
       RowTypePtr type,
       int32_t numRows,
       StreamArena* streamArena,
@@ -39,7 +41,7 @@ class CompactRowVectorSerde : public VectorSerde {
 
   // This method is used when reading data from the exchange.
   void deserialize(
-      ByteStream* source,
+      ByteInputStream* source,
       velox::memory::MemoryPool* pool,
       RowTypePtr type,
       RowVectorPtr* result,
diff --git a/velox/serializers/PrestoSerializer.cpp b/velox/serializers/PrestoSerializer.cpp
index dfb0a76d1c926..4036e47912667 100644
--- a/velox/serializers/PrestoSerializer.cpp
+++ b/velox/serializers/PrestoSerializer.cpp
@@ -14,10 +14,14 @@
  * limitations under the License.
  */
 #include "velox/serializers/PrestoSerializer.h"
+
+#include <optional>
+
+#include <folly/lang/Bits.h>
+
 #include "velox/common/base/Crc.h"
 #include "velox/common/base/RawVector.h"
 #include "velox/common/memory/ByteStream.h"
-#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/vector/BiasVector.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DictionaryVector.h"
@@ -25,10 +29,35 @@
 #include "velox/vector/VectorTypeUtils.h"
 
 namespace facebook::velox::serializer::presto {
+
+using SerdeOpts = PrestoVectorSerde::PrestoOptions;
+
 namespace {
 constexpr int8_t kCompressedBitMask = 1;
 constexpr int8_t kEncryptedBitMask = 2;
 constexpr int8_t kCheckSumBitMask = 4;
+// uncompressed size comes after the number of rows and the codec
+constexpr int32_t kSizeInBytesOffset{4 + 1};
+// There header for a page is:
+// + number of rows (4 bytes)
+// + codec (1 byte)
+// + uncompressed size (4 bytes)
+// + size (4 bytes) (this is the compressed size if the data is compressed,
+//                   otherwise it's uncompressed size again)
+// + checksum (8 bytes)
+//
+// See https://prestodb.io/docs/current/develop/serialized-page.html for a
+// detailed specification of the format.
+constexpr int32_t kHeaderSize{kSizeInBytesOffset + 4 + 4 + 8};
+static inline const std::string_view kByteArray{"BYTE_ARRAY"};
+static inline const std::string_view kShortArray{"SHORT_ARRAY"};
+static inline const std::string_view kIntArray{"INT_ARRAY"};
+static inline const std::string_view kLongArray{"LONG_ARRAY"};
+static inline const std::string_view kInt128Array{"INT128_ARRAY"};
+static inline const std::string_view kVariableWidth{"VARIABLE_WIDTH"};
+static inline const std::string_view kArray{"ARRAY"};
+static inline const std::string_view kMap{"MAP"};
+static inline const std::string_view kRow{"ROW"};
 static inline const std::string_view kRLE{"RLE"};
 static inline const std::string_view kDictionary{"DICTIONARY"};
 
@@ -45,21 +74,27 @@ int64_t computeChecksum(
 }
 
 int64_t computeChecksum(
-    ByteStream* source,
+    ByteInputStream* source,
     int codecMarker,
     int numRows,
-    int uncompressedSize) {
-  auto offset = source->tellp();
+    int32_t uncompressedSize,
+    int32_t compressedSize) {
+  const auto offset = source->tellp();
+  const bool compressed = codecMarker & kCompressedBitMask;
+  if (compressed) {
+    VELOX_CHECK_LT(compressedSize, uncompressedSize);
+  }
+  const int32_t dataSize = compressed ? compressedSize : uncompressedSize;
   bits::Crc32 crc32;
-  if (FOLLY_UNLIKELY(source->remainingSize() < uncompressedSize)) {
+  if (FOLLY_UNLIKELY(source->remainingSize() < dataSize)) {
     VELOX_FAIL(
         "Tried to read {} bytes, larger than what's remained in source {} "
         "bytes. Source details: {}",
-        uncompressedSize,
+        dataSize,
         source->remainingSize(),
         source->toString());
   }
-  auto remainingBytes = uncompressedSize;
+  auto remainingBytes = dataSize;
   while (remainingBytes > 0) {
     auto data = source->nextView(remainingBytes);
     if (FOLLY_UNLIKELY(data.size() == 0)) {
@@ -91,7 +126,7 @@ bool isCompressedBitSet(int8_t codec) {
   return (codec & kCompressedBitMask) == kCompressedBitMask;
 }
 
-bool isEncryptedBit(int8_t codec) {
+bool isEncryptedBitSet(int8_t codec) {
   return (codec & kEncryptedBitMask) == kEncryptedBitMask;
 }
 
@@ -99,40 +134,40 @@ bool isChecksumBitSet(int8_t codec) {
   return (codec & kCheckSumBitMask) == kCheckSumBitMask;
 }
 
-std::string typeToEncodingName(const TypePtr& type) {
+std::string_view typeToEncodingName(const TypePtr& type) {
   switch (type->kind()) {
     case TypeKind::BOOLEAN:
-      return "BYTE_ARRAY";
+      return kByteArray;
     case TypeKind::TINYINT:
-      return "BYTE_ARRAY";
+      return kByteArray;
     case TypeKind::SMALLINT:
-      return "SHORT_ARRAY";
+      return kShortArray;
     case TypeKind::INTEGER:
-      return "INT_ARRAY";
+      return kIntArray;
     case TypeKind::BIGINT:
-      return "LONG_ARRAY";
+      return kLongArray;
     case TypeKind::HUGEINT:
-      return "INT128_ARRAY";
+      return kInt128Array;
     case TypeKind::REAL:
-      return "INT_ARRAY";
+      return kIntArray;
     case TypeKind::DOUBLE:
-      return "LONG_ARRAY";
+      return kLongArray;
     case TypeKind::VARCHAR:
-      return "VARIABLE_WIDTH";
+      return kVariableWidth;
     case TypeKind::VARBINARY:
-      return "VARIABLE_WIDTH";
+      return kVariableWidth;
     case TypeKind::TIMESTAMP:
-      return "LONG_ARRAY";
+      return kLongArray;
     case TypeKind::ARRAY:
-      return "ARRAY";
+      return kArray;
     case TypeKind::MAP:
-      return "MAP";
+      return kMap;
     case TypeKind::ROW:
-      return isTimestampWithTimeZoneType(type) ? "LONG_ARRAY" : "ROW";
+      return kRow;
     case TypeKind::UNKNOWN:
-      return "BYTE_ARRAY";
+      return kByteArray;
     default:
-      throw std::runtime_error("Unknown type kind");
+      VELOX_FAIL("Unknown type kind: {}", static_cast<int>(type->kind()));
   }
 }
 
@@ -141,351 +176,651 @@ PrestoVectorSerde::PrestoOptions toPrestoOptions(
   if (options == nullptr) {
     return PrestoVectorSerde::PrestoOptions();
   }
-  return *(static_cast<const PrestoVectorSerde::PrestoOptions*>(options));
+  auto prestoOptions =
+      dynamic_cast<const PrestoVectorSerde::PrestoOptions*>(options);
+  VELOX_CHECK_NOT_NULL(
+      prestoOptions, "Serde options are not Presto-compatible");
+  return *prestoOptions;
 }
 
 FOLLY_ALWAYS_INLINE bool needCompression(const folly::io::Codec& codec) {
   return codec.type() != folly::io::CodecType::NO_COMPRESSION;
 }
 
+using StructNullsMap =
+    folly::F14FastMap<int64_t, std::pair<raw_vector<uint64_t>, int32_t>>;
+
+auto& structNullsMap() {
+  thread_local std::unique_ptr<StructNullsMap> map;
+  return map;
+}
+
+std::pair<const uint64_t*, int32_t> getStructNulls(int64_t position) {
+  auto& map = structNullsMap();
+  auto it = map->find(position);
+  if (it == map->end()) {
+    return {nullptr, 0};
+  }
+  return {it->second.first.data(), it->second.second};
+}
+
+template <typename T>
+T readInt(std::string_view* source) {
+  assert(source->size() >= sizeof(T));
+  auto value = folly::loadUnaligned<T>(source->data());
+  source->remove_prefix(sizeof(T));
+  return value;
+}
+
+struct PrestoHeader {
+  int32_t numRows;
+  int8_t pageCodecMarker;
+  int32_t uncompressedSize;
+  int32_t compressedSize;
+  int64_t checksum;
+
+  static PrestoHeader read(ByteInputStream* source) {
+    PrestoHeader header;
+    header.numRows = source->read<int32_t>();
+    header.pageCodecMarker = source->read<int8_t>();
+    header.uncompressedSize = source->read<int32_t>();
+    header.compressedSize = source->read<int32_t>();
+    header.checksum = source->read<int64_t>();
+
+    VELOX_CHECK_GE(header.numRows, 0);
+    VELOX_CHECK_GE(header.uncompressedSize, 0);
+    VELOX_CHECK_GE(header.compressedSize, 0);
+
+    return header;
+  }
+
+  static std::optional<PrestoHeader> read(std::string_view* source) {
+    if (source->size() < kHeaderSize) {
+      return std::nullopt;
+    }
+
+    PrestoHeader header;
+    header.numRows = readInt<int32_t>(source);
+    header.pageCodecMarker = readInt<int8_t>(source);
+    header.uncompressedSize = readInt<int32_t>(source);
+    header.compressedSize = readInt<int32_t>(source);
+    header.checksum = readInt<int64_t>(source);
+
+    if (header.numRows < 0) {
+      return std::nullopt;
+    }
+    if (header.uncompressedSize < 0) {
+      return std::nullopt;
+    }
+    if (header.compressedSize < 0) {
+      return std::nullopt;
+    }
+
+    return header;
+  }
+};
+
+template <typename T>
+int32_t checkValuesSize(
+    const BufferPtr& values,
+    const BufferPtr& nulls,
+    int32_t size,
+    int32_t offset) {
+  auto bufferSize = (std::is_same_v<T, bool>) ? values->size() * 8
+                                              : values->size() / sizeof(T);
+  // If all nulls, values does not have to be sized for vector size.
+  if (nulls && bits::isAllSet(nulls->as<uint64_t>(), 0, size + offset, false)) {
+    return 0;
+  }
+  VELOX_CHECK_LE(offset + size, bufferSize);
+  return bufferSize;
+}
+
 template <typename T>
 void readValues(
-    ByteStream* source,
+    ByteInputStream* source,
     vector_size_t size,
-    BufferPtr nulls,
+    vector_size_t offset,
+    const BufferPtr& nulls,
     vector_size_t nullCount,
-    BufferPtr values) {
+    const BufferPtr& values) {
   if (nullCount) {
+    auto bufferSize = checkValuesSize<T>(values, nulls, size, offset);
     auto rawValues = values->asMutable<T>();
-    int32_t toClear = 0;
-    bits::forEachSetBit(nulls->as<uint64_t>(), 0, size, [&](int32_t row) {
-      // Set the values between the last non-null and this to type default.
-      for (; toClear < row; ++toClear) {
-        rawValues[toClear] = T();
-      }
-      rawValues[row] = source->read<T>();
-      toClear = row + 1;
-    });
+    int32_t toClear = offset;
+    bits::forEachSetBit(
+        nulls->as<uint64_t>(), offset, offset + size, [&](int32_t row) {
+          // Set the values between the last non-null and this to type default.
+          for (; toClear < row; ++toClear) {
+            VELOX_CHECK_LT(toClear, bufferSize);
+            rawValues[toClear] = T();
+          }
+          VELOX_CHECK_LT(row, bufferSize);
+          rawValues[row] = source->read<T>();
+          toClear = row + 1;
+        });
   } else {
-    source->readBytes(values->asMutable<uint8_t>(), size * sizeof(T));
+    source->readBytes(
+        values->asMutable<uint8_t>() + offset * sizeof(T), size * sizeof(T));
   }
 }
 
 template <>
 void readValues<bool>(
-    ByteStream* source,
+    ByteInputStream* source,
     vector_size_t size,
-    BufferPtr nulls,
+    vector_size_t offset,
+    const BufferPtr& nulls,
     vector_size_t nullCount,
-    BufferPtr values) {
+    const BufferPtr& values) {
   auto rawValues = values->asMutable<uint64_t>();
+  auto bufferSize = checkValuesSize<bool>(values, nulls, size, offset);
   if (nullCount) {
-    int32_t toClear = 0;
-    bits::forEachSetBit(nulls->as<uint64_t>(), 0, size, [&](int32_t row) {
-      // Set the values between the last non-null and this to type default.
-      for (; toClear < row; ++toClear) {
-        bits::clearBit(rawValues, toClear);
-      }
-      bits::setBit(rawValues, row, (source->read<int8_t>() != 0));
-      toClear = row + 1;
-    });
+    int32_t toClear = offset;
+    bits::forEachSetBit(
+        nulls->as<uint64_t>(), offset, offset + size, [&](int32_t row) {
+          // Set the values between the last non-null and this to type default.
+          for (; toClear < row; ++toClear) {
+            VELOX_CHECK_LT(toClear, bufferSize);
+            bits::clearBit(rawValues, toClear);
+          }
+          VELOX_CHECK_LT(row, bufferSize);
+          bits::setBit(rawValues, row, (source->read<int8_t>() != 0));
+          toClear = row + 1;
+        });
   } else {
-    for (int32_t row = 0; row < size; ++row) {
+    for (int32_t row = offset; row < offset + size; ++row) {
       bits::setBit(rawValues, row, (source->read<int8_t>() != 0));
     }
   }
 }
 
-Timestamp readTimestamp(ByteStream* source) {
+Timestamp readTimestamp(ByteInputStream* source) {
   int64_t millis = source->read<int64_t>();
   return Timestamp::fromMillis(millis);
 }
 
 template <>
 void readValues<Timestamp>(
-    ByteStream* source,
+    ByteInputStream* source,
     vector_size_t size,
-    BufferPtr nulls,
+    vector_size_t offset,
+    const BufferPtr& nulls,
     vector_size_t nullCount,
-    BufferPtr values) {
+    const BufferPtr& values) {
   auto rawValues = values->asMutable<Timestamp>();
+  checkValuesSize<Timestamp>(values, nulls, size, offset);
   if (nullCount) {
-    int32_t toClear = 0;
-    bits::forEachSetBit(nulls->as<uint64_t>(), 0, size, [&](int32_t row) {
-      // Set the values between the last non-null and this to type default.
-      for (; toClear < row; ++toClear) {
-        rawValues[toClear] = Timestamp();
-      }
-      rawValues[row] = readTimestamp(source);
-      toClear = row + 1;
-    });
+    int32_t toClear = offset;
+    bits::forEachSetBit(
+        nulls->as<uint64_t>(), offset, offset + size, [&](int32_t row) {
+          // Set the values between the last non-null and this to type default.
+          for (; toClear < row; ++toClear) {
+            rawValues[toClear] = Timestamp();
+          }
+          rawValues[row] = readTimestamp(source);
+          toClear = row + 1;
+        });
   } else {
-    for (int32_t row = 0; row < size; ++row) {
+    for (int32_t row = offset; row < offset + size; ++row) {
       rawValues[row] = readTimestamp(source);
     }
   }
 }
 
-Timestamp readLosslessTimestamp(ByteStream* source) {
+Timestamp readLosslessTimestamp(ByteInputStream* source) {
   int64_t seconds = source->read<int64_t>();
   uint64_t nanos = source->read<uint64_t>();
   return Timestamp(seconds, nanos);
 }
 
 void readLosslessTimestampValues(
-    ByteStream* source,
+    ByteInputStream* source,
     vector_size_t size,
-    BufferPtr nulls,
+    vector_size_t offset,
+    const BufferPtr& nulls,
     vector_size_t nullCount,
-    BufferPtr values) {
+    const BufferPtr& values) {
   auto rawValues = values->asMutable<Timestamp>();
+  checkValuesSize<Timestamp>(values, nulls, size, offset);
   if (nullCount > 0) {
-    int32_t toClear = 0;
-    bits::forEachSetBit(nulls->as<uint64_t>(), 0, size, [&](int32_t row) {
-      // Set the values between the last non-null and this to type default.
-      for (; toClear < row; ++toClear) {
-        rawValues[toClear] = Timestamp();
-      }
-      rawValues[row] = readLosslessTimestamp(source);
-      toClear = row + 1;
-    });
+    int32_t toClear = offset;
+    bits::forEachSetBit(
+        nulls->as<uint64_t>(), offset, offset + size, [&](int32_t row) {
+          // Set the values between the last non-null and this to type default.
+          for (; toClear < row; ++toClear) {
+            rawValues[toClear] = Timestamp();
+          }
+          rawValues[row] = readLosslessTimestamp(source);
+          toClear = row + 1;
+        });
   } else {
-    for (int32_t row = 0; row < size; ++row) {
+    for (int32_t row = offset; row < offset + size; ++row) {
       rawValues[row] = readLosslessTimestamp(source);
     }
   }
 }
 
-int128_t readJavaDecimal(ByteStream* source) {
-  constexpr int64_t kInt64DeserializeMask = ~(static_cast<int64_t>(1) << 63);
-  // ByteStream does not support reading int128_t values.
+int128_t readJavaDecimal(ByteInputStream* source) {
+  // ByteInputStream does not support reading int128_t values.
   auto low = source->read<int64_t>();
   auto high = source->read<int64_t>();
   // 'high' is in signed magnitude representation.
   if (high < 0) {
     // Remove the sign bit before building the int128 value.
     // Negate the value.
-    return -1 * HugeInt::build(high & kInt64DeserializeMask, low);
+    return -1 * HugeInt::build(high & DecimalUtil::kInt64Mask, low);
   }
   return HugeInt::build(high, low);
 }
 
 void readDecimalValues(
-    ByteStream* source,
+    ByteInputStream* source,
     vector_size_t size,
-    BufferPtr nulls,
+    vector_size_t offset,
+    const BufferPtr& nulls,
     vector_size_t nullCount,
-    BufferPtr values) {
+    const BufferPtr& values) {
   auto rawValues = values->asMutable<int128_t>();
   if (nullCount) {
-    int32_t toClear = 0;
-    bits::forEachSetBit(nulls->as<uint64_t>(), 0, size, [&](int32_t row) {
-      // Set the values between the last non-null and this to type default.
-      for (; toClear < row; ++toClear) {
-        rawValues[toClear] = 0;
-      }
-      rawValues[row] = readJavaDecimal(source);
-      toClear = row + 1;
-    });
+    checkValuesSize<int128_t>(values, nulls, size, offset);
+
+    int32_t toClear = offset;
+    bits::forEachSetBit(
+        nulls->as<uint64_t>(), offset, offset + size, [&](int32_t row) {
+          // Set the values between the last non-null and this to type default.
+          for (; toClear < row; ++toClear) {
+            rawValues[toClear] = 0;
+          }
+          rawValues[row] = readJavaDecimal(source);
+          toClear = row + 1;
+        });
   } else {
     for (int32_t row = 0; row < size; ++row) {
-      rawValues[row] = readJavaDecimal(source);
+      rawValues[offset + row] = readJavaDecimal(source);
     }
   }
 }
 
-vector_size_t
-readNulls(ByteStream* source, vector_size_t size, BaseVector& result) {
+/// When deserializing vectors under row vectors that introduce
+/// nulls, the child vector must have a gap at the place where a
+/// parent RowVector has a null. So, if there is a parent RowVector
+/// that adds a null, 'incomingNulls' is the bitmap where a null
+/// denotes a null in the parent RowVector(s). 'numIncomingNulls' is
+/// the number of bits in this bitmap, i.e. the number of rows in
+/// the parentRowVector. 'size' is the size of the child vector
+/// being deserialized. This size does not include rows where a
+/// parent RowVector has nulls.
+vector_size_t sizeWithIncomingNulls(
+    vector_size_t size,
+    int32_t numIncomingNulls) {
+  return numIncomingNulls == 0 ? size : numIncomingNulls;
+}
+
+// Fills the nulls of 'result' from the serialized nulls in
+// 'source'. Adds nulls from 'incomingNulls' so that the null flags
+// gets padded with extra nulls where a parent RowVector has a
+// null. Returns the number of nulls in the result.
+vector_size_t readNulls(
+    ByteInputStream* source,
+    vector_size_t size,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
+    BaseVector& result) {
+  VELOX_DCHECK_LE(
+      result.size(), resultOffset + (incomingNulls ? numIncomingNulls : size));
   if (source->readByte() == 0) {
-    result.clearNulls(0, size);
-    result.setNullCount(0);
-    return 0;
+    if (incomingNulls) {
+      auto* rawNulls = result.mutableRawNulls();
+      bits::copyBits(
+          incomingNulls, 0, rawNulls, resultOffset, numIncomingNulls);
+    } else {
+      result.clearNulls(resultOffset, resultOffset + size);
+    }
+    return incomingNulls
+        ? numIncomingNulls - bits::countBits(incomingNulls, 0, numIncomingNulls)
+        : 0;
+  }
+
+  const auto numNewValues = sizeWithIncomingNulls(size, numIncomingNulls);
+
+  const bool noPriorNulls = (result.rawNulls() == nullptr);
+  // Allocate one extra byte in case we cannot use bits from the current last
+  // partial byte.
+  BufferPtr& nulls = result.mutableNulls(resultOffset + numNewValues + 8);
+  if (noPriorNulls) {
+    bits::fillBits(
+        nulls->asMutable<uint64_t>(), 0, resultOffset, bits::kNotNull);
   }
 
-  BufferPtr& nulls = result.mutableNulls(size);
-  auto rawNulls = nulls->asMutable<uint8_t>();
-  auto numBytes = BaseVector::byteSize<bool>(size);
+  auto* rawNulls = nulls->asMutable<uint8_t>() + bits::nbytes(resultOffset);
+  const auto numBytes = BaseVector::byteSize<bool>(size);
 
   source->readBytes(rawNulls, numBytes);
   bits::reverseBits(rawNulls, numBytes);
   bits::negate(reinterpret_cast<char*>(rawNulls), numBytes * 8);
-  vector_size_t nullCount = nulls ? BaseVector::countNulls(nulls, 0, size) : 0;
-  result.setNullCount(nullCount);
-  return nullCount;
+  // Add incoming nulls if any.
+  if (incomingNulls) {
+    bits::scatterBits(
+        size,
+        numIncomingNulls,
+        reinterpret_cast<const char*>(rawNulls),
+        incomingNulls,
+        reinterpret_cast<char*>(rawNulls));
+  }
+
+  // Shift bits if needed.
+  if (bits::nbytes(resultOffset) * 8 > resultOffset) {
+    bits::copyBits(
+        nulls->asMutable<uint64_t>(),
+        bits::nbytes(resultOffset) * 8,
+        nulls->asMutable<uint64_t>(),
+        resultOffset,
+        numNewValues);
+  }
+
+  return BaseVector::countNulls(
+      nulls, resultOffset, resultOffset + numNewValues);
 }
 
 template <typename T>
 void read(
-    ByteStream* source,
-    std::shared_ptr<const Type> type,
+    ByteInputStream* source,
+    const TypePtr& type,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
     velox::memory::MemoryPool* pool,
-    VectorPtr& result,
-    bool useLosslessTimestamp) {
-  int32_t size = source->read<int32_t>();
-  result->resize(size);
+    const SerdeOpts& opts,
+    VectorPtr& result) {
+  const int32_t size = source->read<int32_t>();
+  const auto numNewValues = sizeWithIncomingNulls(size, numIncomingNulls);
+  result->resize(resultOffset + numNewValues);
 
   auto flatResult = result->asFlatVector<T>();
-  auto nullCount = readNulls(source, size, *flatResult);
+  auto nullCount = readNulls(
+      source, size, resultOffset, incomingNulls, numIncomingNulls, *flatResult);
 
-  BufferPtr values = flatResult->mutableValues(size);
+  BufferPtr values = flatResult->mutableValues(resultOffset + numNewValues);
   if constexpr (std::is_same_v<T, Timestamp>) {
-    if (useLosslessTimestamp) {
+    if (opts.useLosslessTimestamp) {
       readLosslessTimestampValues(
-          source, size, flatResult->nulls(), nullCount, values);
+          source,
+          numNewValues,
+          resultOffset,
+          flatResult->nulls(),
+          nullCount,
+          values);
       return;
     }
   }
   if (type->isLongDecimal()) {
-    readDecimalValues(source, size, flatResult->nulls(), nullCount, values);
+    readDecimalValues(
+        source,
+        numNewValues,
+        resultOffset,
+        flatResult->nulls(),
+        nullCount,
+        values);
     return;
   }
-  readValues<T>(source, size, flatResult->nulls(), nullCount, values);
-}
-
-BufferPtr findOrAllocateStringBuffer(
-    int64_t size,
-    const std::vector<BufferPtr>& buffers,
-    velox::memory::MemoryPool* pool) {
-  BufferPtr smallestBuffer;
-  for (auto& buffer : buffers) {
-    if (buffer->unique() && buffer->capacity() >= size && !buffer->isView()) {
-      if (!smallestBuffer || buffer->capacity() < smallestBuffer->capacity()) {
-        smallestBuffer = buffer;
-      }
-    }
-  }
-  if (smallestBuffer) {
-    if (smallestBuffer->size() < size) {
-      smallestBuffer->setSize(size);
-    }
-    return smallestBuffer;
-  }
-
-  return AlignedBuffer::allocate<char>(size, pool);
+  readValues<T>(
+      source,
+      numNewValues,
+      resultOffset,
+      flatResult->nulls(),
+      nullCount,
+      values);
 }
 
 template <>
 void read<StringView>(
-    ByteStream* source,
-    std::shared_ptr<const Type> type,
+    ByteInputStream* source,
+    const TypePtr& type,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
     velox::memory::MemoryPool* pool,
-    VectorPtr& result,
-    bool useLosslessTimestamp) {
-  int32_t size = source->read<int32_t>();
+    const SerdeOpts& opts,
+    VectorPtr& result) {
+  const int32_t size = source->read<int32_t>();
+  const int32_t numNewValues = sizeWithIncomingNulls(size, numIncomingNulls);
 
-  result->resize(size);
+  result->resize(resultOffset + numNewValues);
 
   auto flatResult = result->as<FlatVector<StringView>>();
-  BufferPtr values = flatResult->mutableValues(size);
+  BufferPtr values = flatResult->mutableValues(resultOffset + size);
   auto rawValues = values->asMutable<StringView>();
-  for (int32_t i = 0; i < size; ++i) {
+  int32_t lastOffset = 0;
+  for (int32_t i = 0; i < numNewValues; ++i) {
     // Set the first int32_t of each StringView to be the offset.
-    *reinterpret_cast<int32_t*>(&rawValues[i]) = source->read<int32_t>();
+    if (incomingNulls && bits::isBitNull(incomingNulls, i)) {
+      *reinterpret_cast<int32_t*>(&rawValues[resultOffset + i]) = lastOffset;
+      continue;
+    }
+    lastOffset = source->read<int32_t>();
+    *reinterpret_cast<int32_t*>(&rawValues[resultOffset + i]) = lastOffset;
+  }
+  readNulls(
+      source, size, resultOffset, incomingNulls, numIncomingNulls, *flatResult);
+
+  const int32_t dataSize = source->read<int32_t>();
+  if (dataSize == 0) {
+    return;
   }
-  readNulls(source, size, *flatResult);
 
-  int32_t dataSize = source->read<int32_t>();
-  const auto& stringBuffers = flatResult->stringBuffers();
-  BufferPtr strings = findOrAllocateStringBuffer(dataSize, stringBuffers, pool);
-  flatResult->setStringBuffers({strings});
-  auto rawStrings = strings->asMutable<uint8_t>();
+  auto* rawStrings =
+      flatResult->getRawStringBufferWithSpace(dataSize, true /*exactSize*/);
 
   source->readBytes(rawStrings, dataSize);
   int32_t previousOffset = 0;
   auto rawChars = reinterpret_cast<char*>(rawStrings);
-  for (int32_t i = 0; i < size; ++i) {
-    int32_t offset = rawValues[i].size();
-    rawValues[i] =
+  for (int32_t i = 0; i < numNewValues; ++i) {
+    int32_t offset = rawValues[resultOffset + i].size();
+    rawValues[resultOffset + i] =
         StringView(rawChars + previousOffset, offset - previousOffset);
     previousOffset = offset;
   }
 }
 
 void readColumns(
-    ByteStream* source,
-    velox::memory::MemoryPool* pool,
+    ByteInputStream* source,
     const std::vector<TypePtr>& types,
-    std::vector<VectorPtr>& result,
-    bool useLosslessTimestamp);
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
+    velox::memory::MemoryPool* pool,
+    const SerdeOpts& opts,
+    std::vector<VectorPtr>& result);
 
 void readConstantVector(
-    ByteStream* source,
+    ByteInputStream* source,
     const TypePtr& type,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
     velox::memory::MemoryPool* pool,
-    VectorPtr& result,
-    bool useLosslessTimestamp) {
-  auto size = source->read<int32_t>();
+    const SerdeOpts& opts,
+    VectorPtr& result) {
+  const auto size = source->read<int32_t>();
+  const int32_t numNewValues = sizeWithIncomingNulls(size, numIncomingNulls);
   std::vector<TypePtr> childTypes = {type};
   std::vector<VectorPtr> children{BaseVector::create(type, 0, pool)};
-  readColumns(source, pool, childTypes, children, useLosslessTimestamp);
+  readColumns(source, childTypes, 0, nullptr, 0, pool, opts, children);
   VELOX_CHECK_EQ(1, children[0]->size());
-  result = BaseVector::wrapInConstant(size, 0, children[0]);
+
+  auto constantVector =
+      BaseVector::wrapInConstant(numNewValues, 0, children[0]);
+
+  // If there are no previous results, we output this as a constant. RowVectors
+  // with top-level nulls can have child ConstantVector (even though they can't
+  // have nulls explicitly set on them), so we don't need to try to apply
+  // incomingNulls here.
+  if (resultOffset == 0) {
+    result = std::move(constantVector);
+  } else {
+    if (!incomingNulls &&
+        opts.nullsFirst && // TODO remove when removing scatter nulls pass.
+        result->encoding() == VectorEncoding::Simple::CONSTANT &&
+        constantVector->equalValueAt(result.get(), 0, 0)) {
+      result->resize(resultOffset + numNewValues);
+      return;
+    }
+    result->resize(resultOffset + numNewValues);
+
+    SelectivityVector rows(resultOffset + numNewValues, false);
+    rows.setValidRange(resultOffset, resultOffset + numNewValues, true);
+    rows.updateBounds();
+
+    BaseVector::ensureWritable(rows, type, pool, result);
+    result->copy(constantVector.get(), resultOffset, 0, numNewValues);
+    if (incomingNulls) {
+      bits::forEachUnsetBit(incomingNulls, 0, numNewValues, [&](auto row) {
+        result->setNull(resultOffset + row, true);
+      });
+    }
+  }
 }
 
 void readDictionaryVector(
-    ByteStream* source,
+    ByteInputStream* source,
     const TypePtr& type,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
     velox::memory::MemoryPool* pool,
-    VectorPtr& result,
-    bool useLosslessTimestamp) {
-  auto size = source->read<int32_t>();
+    const SerdeOpts& opts,
+    VectorPtr& result) {
+  const auto size = source->read<int32_t>();
+  const int32_t numNewValues = sizeWithIncomingNulls(size, numIncomingNulls);
 
   std::vector<TypePtr> childTypes = {type};
   std::vector<VectorPtr> children{BaseVector::create(type, 0, pool)};
-  readColumns(source, pool, childTypes, children, useLosslessTimestamp);
+  readColumns(source, childTypes, 0, nullptr, 0, pool, opts, children);
 
   // Read indices.
-  BufferPtr indices = allocateIndices(size, pool);
-  source->readBytes(indices->asMutable<char>(), size * sizeof(int32_t));
+  BufferPtr indices = allocateIndices(numNewValues, pool);
+  if (incomingNulls) {
+    auto rawIndices = indices->asMutable<int32_t>();
+    for (auto i = 0; i < numNewValues; ++i) {
+      if (bits::isBitNull(incomingNulls, i)) {
+        rawIndices[i] = 0;
+      } else {
+        rawIndices[i] = source->read<int32_t>();
+      }
+    }
+  } else {
+    source->readBytes(
+        indices->asMutable<char>(), numNewValues * sizeof(int32_t));
+  }
 
   // Skip 3 * 8 bytes of 'instance id'. Velox doesn't use 'instance id' for
   // dictionary vectors.
   source->skip(24);
 
-  result = BaseVector::wrapInDictionary(nullptr, indices, size, children[0]);
+  BufferPtr incomingNullsBuffer = nullptr;
+  if (incomingNulls) {
+    incomingNullsBuffer = AlignedBuffer::allocate<bool>(numIncomingNulls, pool);
+    memcpy(
+        incomingNullsBuffer->asMutable<char>(),
+        incomingNulls,
+        bits::nbytes(numIncomingNulls));
+  }
+  auto dictionaryVector = BaseVector::wrapInDictionary(
+      incomingNullsBuffer, indices, numNewValues, children[0]);
+  if (resultOffset == 0) {
+    result = std::move(dictionaryVector);
+  } else {
+    result->resize(resultOffset + numNewValues);
+
+    SelectivityVector rows(resultOffset + numNewValues, false);
+    rows.setValidRange(resultOffset, resultOffset + numNewValues, true);
+    rows.updateBounds();
+
+    BaseVector::ensureWritable(rows, type, pool, result);
+    result->copy(dictionaryVector.get(), resultOffset, 0, numNewValues);
+  }
 }
 
 void readArrayVector(
-    ByteStream* source,
-    std::shared_ptr<const Type> type,
+    ByteInputStream* source,
+    const TypePtr& type,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
     velox::memory::MemoryPool* pool,
-    VectorPtr& result,
-    bool useLosslessTimestamp) {
+    const SerdeOpts& opts,
+    VectorPtr& result) {
   ArrayVector* arrayVector = result->as<ArrayVector>();
 
+  const auto resultElementsOffset = arrayVector->elements()->size();
+
   std::vector<TypePtr> childTypes = {type->childAt(0)};
   std::vector<VectorPtr> children{arrayVector->elements()};
-  readColumns(source, pool, childTypes, children, useLosslessTimestamp);
+  readColumns(
+      source,
+      childTypes,
+      resultElementsOffset,
+      nullptr,
+      0,
+      pool,
+      opts,
+      children);
 
-  vector_size_t size = source->read<int32_t>();
-  arrayVector->resize(size);
+  const vector_size_t size = source->read<int32_t>();
+  const auto numNewValues = sizeWithIncomingNulls(size, numIncomingNulls);
+  arrayVector->resize(resultOffset + numNewValues);
   arrayVector->setElements(children[0]);
 
-  BufferPtr offsets = arrayVector->mutableOffsets(size);
+  BufferPtr offsets = arrayVector->mutableOffsets(resultOffset + numNewValues);
   auto rawOffsets = offsets->asMutable<vector_size_t>();
-  BufferPtr sizes = arrayVector->mutableSizes(size);
+  BufferPtr sizes = arrayVector->mutableSizes(resultOffset + numNewValues);
   auto rawSizes = sizes->asMutable<vector_size_t>();
   int32_t base = source->read<int32_t>();
-  for (int32_t i = 0; i < size; ++i) {
+  for (int32_t i = 0; i < numNewValues; ++i) {
+    if (incomingNulls && bits::isBitNull(incomingNulls, i)) {
+      rawOffsets[resultOffset + i] = 0;
+      rawSizes[resultOffset + i] = 0;
+      continue;
+    }
     int32_t offset = source->read<int32_t>();
-    rawOffsets[i] = base;
-    rawSizes[i] = offset - base;
+    rawOffsets[resultOffset + i] = resultElementsOffset + base;
+    rawSizes[resultOffset + i] = offset - base;
     base = offset;
   }
 
-  readNulls(source, size, *arrayVector);
+  readNulls(
+      source,
+      size,
+      resultOffset,
+      incomingNulls,
+      numIncomingNulls,
+      *arrayVector);
 }
 
 void readMapVector(
-    ByteStream* source,
-    std::shared_ptr<const Type> type,
+    ByteInputStream* source,
+    const TypePtr& type,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
     velox::memory::MemoryPool* pool,
-    VectorPtr& result,
-    bool useLosslessTimestamp) {
+    const SerdeOpts& opts,
+    VectorPtr& result) {
   MapVector* mapVector = result->as<MapVector>();
+  const auto resultElementsOffset = mapVector->mapKeys()->size();
   std::vector<TypePtr> childTypes = {type->childAt(0), type->childAt(1)};
   std::vector<VectorPtr> children{mapVector->mapKeys(), mapVector->mapValues()};
-  readColumns(source, pool, childTypes, children, useLosslessTimestamp);
+  readColumns(
+      source,
+      childTypes,
+      resultElementsOffset,
+      nullptr,
+      0,
+      pool,
+      opts,
+      children);
 
   int32_t hashTableSize = source->read<int32_t>();
   if (hashTableSize != -1) {
@@ -493,333 +828,111 @@ void readMapVector(
     source->skip(hashTableSize * sizeof(int32_t));
   }
 
-  vector_size_t size = source->read<int32_t>();
-  mapVector->resize(size);
+  const vector_size_t size = source->read<int32_t>();
+  const vector_size_t numNewValues =
+      sizeWithIncomingNulls(size, numIncomingNulls);
+  mapVector->resize(resultOffset + numNewValues);
   mapVector->setKeysAndValues(children[0], children[1]);
 
-  BufferPtr offsets = mapVector->mutableOffsets(size);
+  BufferPtr offsets = mapVector->mutableOffsets(resultOffset + numNewValues);
   auto rawOffsets = offsets->asMutable<vector_size_t>();
-  BufferPtr sizes = mapVector->mutableSizes(size);
+  BufferPtr sizes = mapVector->mutableSizes(resultOffset + numNewValues);
   auto rawSizes = sizes->asMutable<vector_size_t>();
   int32_t base = source->read<int32_t>();
-  for (int32_t i = 0; i < size; ++i) {
+  for (int32_t i = 0; i < numNewValues; ++i) {
+    if (incomingNulls && bits::isBitNull(incomingNulls, i)) {
+      rawOffsets[resultOffset + i] = 0;
+      rawSizes[resultOffset + i] = 0;
+      continue;
+    }
     int32_t offset = source->read<int32_t>();
-    rawOffsets[i] = base;
-    rawSizes[i] = offset - base;
+    rawOffsets[resultOffset + i] = resultElementsOffset + base;
+    rawSizes[resultOffset + i] = offset - base;
     base = offset;
   }
 
-  readNulls(source, size, *mapVector);
+  readNulls(
+      source, size, resultOffset, incomingNulls, numIncomingNulls, *mapVector);
 }
 
-int64_t packTimestampWithTimeZone(int64_t timestamp, int16_t timezone) {
-  return timezone | (timestamp << 12);
-}
-
-void unpackTimestampWithTimeZone(
-    int64_t packed,
-    int64_t& timestamp,
-    int16_t& timezone) {
-  timestamp = packed >> 12;
-  timezone = packed & 0xfff;
-}
-
-void readTimestampWithTimeZone(
-    ByteStream* source,
+void readRowVector(
+    ByteInputStream* source,
+    const TypePtr& type,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
     velox::memory::MemoryPool* pool,
+    const SerdeOpts& opts,
     VectorPtr& result) {
-  VectorPtr timestamps = BaseVector::create(BIGINT(), 0, pool);
-  read<int64_t>(source, BIGINT(), pool, timestamps, false);
-
-  auto rawTimestamps = timestamps->asFlatVector<int64_t>()->mutableRawValues();
-
-  auto size = timestamps->size();
-
-  auto timezones = BaseVector::create(SMALLINT(), size, pool);
-  auto rawTimezones = timezones->asFlatVector<int16_t>()->mutableRawValues();
-
-  auto rawNulls = timestamps->rawNulls();
-  for (auto i = 0; i < size; ++i) {
-    if (!rawNulls || !bits::isBitNull(rawNulls, i)) {
-      unpackTimestampWithTimeZone(
-          rawTimestamps[i], rawTimestamps[i], rawTimezones[i]);
-    }
-  }
-
-  result = std::make_shared<RowVector>(
-      pool,
-      TIMESTAMP_WITH_TIME_ZONE(),
-      timestamps->nulls(),
-      size,
-      std::vector<VectorPtr>{timestamps, timezones});
-}
-
-template <typename T>
-void scatterValues(int32_t numValues, const vector_size_t* indices, T* data) {
-  for (auto index = numValues - 1; index >= 0; --index) {
-    auto destination = indices[index];
-    if (destination == index) {
-      break;
-    }
-    data[destination] = data[index];
-  }
-}
-
-void scatterBits(
-    int32_t numValues,
-    const vector_size_t* indices,
-    uint64_t* data) {
-  for (auto index = numValues - 1; index >= 0; --index) {
-    auto destination = indices[index];
-    if (destination == index) {
-      break;
+  auto* row = result->asUnchecked<RowVector>();
+  BufferPtr combinedNulls;
+  const uint64_t* childNulls = incomingNulls;
+  int32_t numChildNulls = numIncomingNulls;
+  if (opts.nullsFirst) {
+    const auto size = source->read<int32_t>();
+    const auto numNewValues = sizeWithIncomingNulls(size, numIncomingNulls);
+    row->resize(resultOffset + numNewValues);
+    readNulls(
+        source, size, resultOffset, incomingNulls, numIncomingNulls, *result);
+    if (row->rawNulls()) {
+      combinedNulls = AlignedBuffer::allocate<bool>(numNewValues, pool);
+      bits::copyBits(
+          row->rawNulls(),
+          resultOffset,
+          combinedNulls->asMutable<uint64_t>(),
+          0,
+          numNewValues);
+      childNulls = combinedNulls->as<uint64_t>();
+      numChildNulls = numNewValues;
     }
-    bits::setBit(data, destination, bits::isBitSet(data, index));
-  }
-}
-
-template <TypeKind kind>
-void scatterFlatValues(
-    vector_size_t scatterSize,
-    const vector_size_t* scatter,
-    BaseVector& vector) {
-  using T = typename TypeTraits<kind>::NativeType;
-  auto* values = const_cast<T*>(vector.values()->as<T>());
-  scatterValues(scatterSize, scatter, values);
-}
-
-template <>
-void scatterFlatValues<TypeKind::BOOLEAN>(
-    vector_size_t scatterSize,
-    const vector_size_t* scatter,
-    BaseVector& vector) {
-  auto* values = const_cast<uint64_t*>(vector.values()->as<uint64_t>());
-  scatterBits(scatterSize, scatter, values);
-}
-
-void scatterStructNulls(
-    vector_size_t size,
-    vector_size_t scatterSize,
-    const vector_size_t* scatter,
-    const uint64_t* incomingNulls,
-    RowVector& row);
-
-// Scatters existing nulls and adds 'incomingNulls' to the gaps. 'oldSize' is
-// the number of valid bits in the nulls of 'vector'. 'vector' must have been
-// resized to the new size before calling this.
-void scatterNulls(
-    vector_size_t oldSize,
-    const uint64_t* incomingNulls,
-    BaseVector& vector) {
-  bool hasNulls = vector.mayHaveNulls();
-  auto size = vector.size();
-  vector.mutableRawNulls();
-  if (hasNulls) {
-    auto bits = reinterpret_cast<char*>(vector.mutableRawNulls());
-    bits::scatterBits(oldSize, vector.size(), bits, incomingNulls, bits);
   } else {
-    memcpy(
-        vector.mutableRawNulls(), incomingNulls, bits::nbytes(vector.size()));
-  }
-}
-
-void scatterVector(
-    int32_t size,
-    vector_size_t scatterSize,
-    const vector_size_t* scatter,
-    const uint64_t* incomingNulls,
-    VectorPtr& vector) {
-  auto oldSize = vector->size();
-  vector->resize(size);
-  switch (vector->encoding()) {
-    case VectorEncoding::Simple::DICTIONARY: {
-      if (incomingNulls) {
-        auto dictIndices =
-            const_cast<vector_size_t*>(vector->wrapInfo()->as<vector_size_t>());
-        scatterValues(scatterSize, scatter, dictIndices);
-        scatterNulls(oldSize, incomingNulls, *vector);
-      }
-      auto values = vector->valueVector();
-      scatterVector(values->size(), 0, nullptr, nullptr, values);
-      break;
-    }
-    case VectorEncoding::Simple::CONSTANT: {
-      auto values = vector->valueVector();
-      if (values) {
-        scatterVector(values->size(), 0, nullptr, nullptr, values);
-      }
-
-      if (incomingNulls) {
-        BaseVector::ensureWritable(
-            SelectivityVector::empty(), vector->type(), vector->pool(), vector);
-        scatterNulls(oldSize, incomingNulls, *vector);
-      }
-      break;
-    }
-    case VectorEncoding::Simple::ARRAY: {
-      auto* array = reinterpret_cast<ArrayVector*>(vector.get());
-      if (incomingNulls) {
-        auto offsets = const_cast<vector_size_t*>(array->rawOffsets());
-        auto sizes = const_cast<vector_size_t*>(array->rawSizes());
-        scatterValues(scatterSize, scatter, offsets);
-        scatterValues(scatterSize, scatter, sizes);
-        scatterNulls(oldSize, incomingNulls, *vector);
-      }
-      auto elements = array->elements();
-      scatterVector(array->elements()->size(), 0, nullptr, nullptr, elements);
-      break;
-    }
-    case VectorEncoding::Simple::MAP: {
-      auto* map = reinterpret_cast<MapVector*>(vector.get());
-      if (incomingNulls) {
-        auto offsets = const_cast<vector_size_t*>(map->rawOffsets());
-        auto sizes = const_cast<vector_size_t*>(map->rawSizes());
-        scatterValues(scatterSize, scatter, offsets);
-        scatterValues(scatterSize, scatter, sizes);
-        scatterNulls(oldSize, incomingNulls, *vector);
-      }
-      auto keys = map->mapKeys();
-      scatterVector(keys->size(), 0, nullptr, nullptr, keys);
-      auto values = map->mapValues();
-      scatterVector(values->size(), 0, nullptr, nullptr, values);
-      break;
-    }
-    case VectorEncoding::Simple::ROW: {
-      auto* row = reinterpret_cast<RowVector*>(vector.get());
-      scatterStructNulls(row->size(), 0, nullptr, nullptr, *row);
-      break;
-    }
-    case VectorEncoding::Simple::FLAT: {
+    auto [structNulls, numStructNulls] = getStructNulls(source->tellp());
+    // childNulls is the nulls added to the children, i.e. the nulls of this
+    // struct combined with nulls of enclosing structs.
+    if (structNulls) {
       if (incomingNulls) {
-        VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-            scatterFlatValues,
-            vector->typeKind(),
-            scatterSize,
-            scatter,
-            *vector);
-        scatterNulls(oldSize, incomingNulls, *vector);
+        combinedNulls = AlignedBuffer::allocate<bool>(numIncomingNulls, pool);
+        bits::scatterBits(
+            numStructNulls,
+            numIncomingNulls,
+            reinterpret_cast<const char*>(structNulls),
+            incomingNulls,
+            combinedNulls->asMutable<char>());
+        childNulls = combinedNulls->as<uint64_t>();
+        numChildNulls = numIncomingNulls;
+      } else {
+        childNulls = structNulls;
+        numChildNulls = numStructNulls;
       }
-      break;
-    }
-    default:
-      VELOX_FAIL("Unsupported encoding in scatter: {}", vector->encoding());
-  }
-}
-
-// A RowVector with nulls is serialized with children having a value
-// only for rows where the struct is non-null. After deserializing,
-// we do an extra traversal to add gaps into struct members where
-// the containing struct is null. As we go down the struct tree, we
-// merge child struct nulls into the nulls from enclosing structs so
-// that the leaves only get scattered once, considering all nulls
-// from all  enclosing structs.
-void scatterStructNulls(
-    vector_size_t size,
-    vector_size_t scatterSize,
-    const vector_size_t* scatter,
-    const uint64_t* incomingNulls,
-    RowVector& row) {
-  auto oldSize = row.size();
-  if (isTimestampWithTimeZoneType(row.type())) {
-    // The timestamp with tz case is special. The child vectors are aligned with
-    // the struct even if the struct as nulls.
-    if (incomingNulls) {
-      scatterVector(
-          row.size(), scatterSize, scatter, incomingNulls, row.childAt(0));
-      scatterVector(
-          row.size(), scatterSize, scatter, incomingNulls, row.childAt(1));
-      row.resize(size);
-      scatterNulls(oldSize, incomingNulls, row);
-    }
-    return;
-  }
-  const uint64_t* childIncomingNulls = incomingNulls;
-  const vector_size_t* childScatter = scatter;
-  auto childScatterSize = scatterSize;
-  raw_vector<vector_size_t> innerScatter;
-  raw_vector<uint64_t> childIncomingNullsVector;
-  if (auto* rawNulls = row.rawNulls()) {
-    if (!incomingNulls) {
-      childIncomingNulls = rawNulls;
-      innerScatter.resize(size);
-      childScatterSize =
-          simd::indicesOfSetBits(rawNulls, 0, size, innerScatter.data());
-      childScatter = innerScatter.data();
-    } else {
-      childIncomingNullsVector.resize(bits::nwords(size));
-      auto newNulls = childIncomingNullsVector.data();
-      bits::scatterBits(
-          row.size(),
-          size,
-          reinterpret_cast<const char*>(rawNulls),
-          incomingNulls,
-          reinterpret_cast<char*>(newNulls));
-      childIncomingNulls = newNulls;
-      innerScatter.resize(size);
-      childScatterSize = simd::indicesOfSetBits(
-          childIncomingNulls, 0, size, innerScatter.data());
-      childScatter = innerScatter.data();
-    }
-  }
-  for (auto i = 0; i < row.childrenSize(); ++i) {
-    auto& child = row.childAt(i);
-    if (child->encoding() == VectorEncoding::Simple::ROW) {
-      scatterStructNulls(
-          size,
-          childScatterSize,
-          childScatter,
-          childIncomingNulls,
-          *reinterpret_cast<RowVector*>(child.get()));
-    } else {
-      scatterVector(
-          size,
-          childScatterSize,
-          childScatter,
-          childIncomingNulls,
-          row.childAt(i));
     }
   }
-  if (incomingNulls) {
-    row.resize(size);
-    scatterNulls(oldSize, incomingNulls, row);
-  }
-  // On return of scatter we check that child sizes match the struct size. This
-  // is safe also if no scatter.
-  for (auto i = 0; i < row.childrenSize(); ++i) {
-    VELOX_CHECK_EQ(row.childAt(i)->size(), row.size());
-  }
-}
-
-void readRowVector(
-    ByteStream* source,
-    std::shared_ptr<const Type> type,
-    velox::memory::MemoryPool* pool,
-    VectorPtr& result,
-    bool useLosslessTimestamp) {
-  if (isTimestampWithTimeZoneType(type)) {
-    readTimestampWithTimeZone(source, pool, result);
-    return;
-  }
 
-  int32_t numChildren = source->read<int32_t>();
-  auto* row = result->as<RowVector>();
+  source->read<int32_t>(); // numChildren
   auto& children = row->children();
 
   const auto& childTypes = type->asRow().children();
-  readColumns(source, pool, childTypes, children, useLosslessTimestamp);
-
-  auto size = source->read<int32_t>();
-  // Set the size of the row but do not alter the size of the
-  // children. The children get adjusted in a separate pass over the
-  // data. The parent and child size MUST be separate until the second pass.
-  row->BaseVector::resize(size);
-  for (int32_t i = 0; i <= size; ++i) {
-    source->read<int32_t>();
+  readColumns(
+      source,
+      childTypes,
+      resultOffset,
+      childNulls,
+      numChildNulls,
+      pool,
+      opts,
+      children);
+  if (!opts.nullsFirst) {
+    const auto size = source->read<int32_t>();
+    const auto numNewValues = sizeWithIncomingNulls(size, numIncomingNulls);
+    row->resize(resultOffset + numNewValues);
+    // Read and discard the offsets. The number of offsets is not affected by
+    // incomingNulls.
+    source->skip((size + 1) * sizeof(int32_t));
+    readNulls(
+        source, size, resultOffset, incomingNulls, numIncomingNulls, *result);
   }
-  readNulls(source, size, *result);
 }
 
-std::string readLengthPrefixedString(ByteStream* source) {
+std::string readLengthPrefixedString(ByteInputStream* source) {
   int32_t size = source->read<int32_t>();
   std::string value;
   value.resize(size);
@@ -827,30 +940,84 @@ std::string readLengthPrefixedString(ByteStream* source) {
   return value;
 }
 
-void checkTypeEncoding(std::string encoding, TypePtr type) {
-  auto kindEncoding = typeToEncodingName(type);
-  VELOX_CHECK(
+void checkTypeEncoding(std::string_view encoding, const TypePtr& type) {
+  const auto kindEncoding = typeToEncodingName(type);
+  VELOX_USER_CHECK(
       encoding == kindEncoding,
-      "Encoding to Type mismatch {} expected {} got {}",
+      "Serialized encoding is not compatible with requested type: {}. Expected {}. Got {}.",
       type->kindName(),
       kindEncoding,
       encoding);
 }
 
-void readColumns(
-    ByteStream* source,
+// This is used when there's a mismatch between the encoding in the serialized
+// page and the expected output encoding. If the serialized encoding is
+// BYTE_ARRAY, it may represent an all-null vector of the expected output type.
+// We attempt to read the serialized page as an UNKNOWN type, check if all
+// values are null, and set the columnResult accordingly. If all values are
+// null, we return true; otherwise, we return false.
+bool tryReadNullColumn(
+    ByteInputStream* source,
+    const TypePtr& columnType,
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
     velox::memory::MemoryPool* pool,
+    const SerdeOpts& opts,
+    VectorPtr& columnResult) {
+  auto unknownType = UNKNOWN();
+  VectorPtr tempResult = BaseVector::create(unknownType, 0, pool);
+  read<UnknownValue>(
+      source,
+      unknownType,
+      0 /*resultOffset*/,
+      incomingNulls,
+      numIncomingNulls,
+      pool,
+      opts,
+      tempResult);
+  auto deserializedSize = tempResult->size();
+  // Ensure it contains all null values.
+  auto numNulls = BaseVector::countNulls(tempResult->nulls(), deserializedSize);
+  if (deserializedSize != numNulls) {
+    return false;
+  }
+  if (resultOffset == 0) {
+    columnResult =
+        BaseVector::createNullConstant(columnType, deserializedSize, pool);
+  } else {
+    columnResult->resize(resultOffset + deserializedSize);
+
+    SelectivityVector nullRows(resultOffset + deserializedSize, false);
+    nullRows.setValidRange(resultOffset, resultOffset + deserializedSize, true);
+    nullRows.updateBounds();
+
+    BaseVector::ensureWritable(nullRows, columnType, pool, columnResult);
+    columnResult->addNulls(nullRows);
+  }
+  return true;
+}
+
+void readColumns(
+    ByteInputStream* source,
     const std::vector<TypePtr>& types,
-    std::vector<VectorPtr>& result,
-    bool useLosslessTimestamp) {
-  static std::unordered_map<
+    vector_size_t resultOffset,
+    const uint64_t* incomingNulls,
+    int32_t numIncomingNulls,
+    velox::memory::MemoryPool* pool,
+    const SerdeOpts& opts,
+    std::vector<VectorPtr>& results) {
+  static const std::unordered_map<
       TypeKind,
       std::function<void(
-          ByteStream * source,
-          std::shared_ptr<const Type> type,
-          velox::memory::MemoryPool * pool,
-          VectorPtr & result,
-          bool useLosslessTimestamp)>>
+          ByteInputStream * source,
+          const TypePtr& type,
+          vector_size_t resultOffset,
+          const uint64_t* incomingNulls,
+          int32_t numIncomingNulls,
+          velox::memory::MemoryPool* pool,
+          const SerdeOpts& opts,
+          VectorPtr& result)>>
       readers = {
           {TypeKind::BOOLEAN, &read<bool>},
           {TypeKind::TINYINT, &read<int8_t>},
@@ -868,23 +1035,266 @@ void readColumns(
           {TypeKind::ROW, &readRowVector},
           {TypeKind::UNKNOWN, &read<UnknownValue>}};
 
+  VELOX_CHECK_EQ(types.size(), results.size());
+
   for (int32_t i = 0; i < types.size(); ++i) {
-    auto encoding = readLengthPrefixedString(source);
+    const auto& columnType = types[i];
+    auto& columnResult = results[i];
+
+    const auto encoding = readLengthPrefixedString(source);
     if (encoding == kRLE) {
       readConstantVector(
-          source, types[i], pool, result[i], useLosslessTimestamp);
+          source,
+          columnType,
+          resultOffset,
+          incomingNulls,
+          numIncomingNulls,
+          pool,
+          opts,
+          columnResult);
     } else if (encoding == kDictionary) {
       readDictionaryVector(
-          source, types[i], pool, result[i], useLosslessTimestamp);
+          source,
+          columnType,
+          resultOffset,
+          incomingNulls,
+          numIncomingNulls,
+          pool,
+          opts,
+          columnResult);
     } else {
-      checkTypeEncoding(encoding, types[i]);
-      auto it = readers.find(types[i]->kind());
-      VELOX_CHECK(
-          it != readers.end(),
-          "Column reader for type {} is missing",
-          types[i]->kindName());
+      auto typeToEncoding = typeToEncodingName(columnType);
+      if (encoding != typeToEncoding) {
+        if (encoding == kByteArray &&
+            tryReadNullColumn(
+                source,
+                columnType,
+                resultOffset,
+                incomingNulls,
+                numIncomingNulls,
+                pool,
+                opts,
+                columnResult)) {
+          return;
+        }
+      }
+      checkTypeEncoding(encoding, columnType);
+      if (columnResult != nullptr &&
+          (columnResult->encoding() == VectorEncoding::Simple::CONSTANT ||
+           columnResult->encoding() == VectorEncoding::Simple::DICTIONARY)) {
+        BaseVector::ensureWritable(
+            SelectivityVector::empty(), types[i], pool, columnResult);
+      }
+      const auto it = readers.find(columnType->kind());
+      VELOX_CHECK(
+          it != readers.end(),
+          "Column reader for type {} is missing",
+          columnType->kindName());
+
+      it->second(
+          source,
+          columnType,
+          resultOffset,
+          incomingNulls,
+          numIncomingNulls,
+          pool,
+          opts,
+          columnResult);
+    }
+  }
+}
+
+// Reads nulls into 'scratch' and returns count of non-nulls. If 'copy' is
+// given, returns the null bits in 'copy'.
+vector_size_t valueCount(
+    ByteInputStream* source,
+    vector_size_t size,
+    Scratch& scratch,
+    raw_vector<uint64_t>* copy = nullptr) {
+  if (source->readByte() == 0) {
+    return size;
+  }
+  ScratchPtr<uint64_t, 16> nullsHolder(scratch);
+  auto rawNulls = nullsHolder.get(bits::nwords(size));
+  auto numBytes = bits::nbytes(size);
+  source->readBytes(rawNulls, numBytes);
+  bits::reverseBits(reinterpret_cast<uint8_t*>(rawNulls), numBytes);
+  bits::negate(reinterpret_cast<char*>(rawNulls), numBytes * 8);
+  if (copy) {
+    copy->resize(bits::nwords(size));
+    memcpy(copy->data(), rawNulls, numBytes);
+  }
+  return bits::countBits(rawNulls, 0, size);
+}
+
+template <typename T>
+void readStructNulls(
+    ByteInputStream* source,
+    const TypePtr& type,
+    bool useLosslessTimestamp,
+    Scratch& scratch) {
+  const int32_t size = source->read<int32_t>();
+  auto numValues = valueCount(source, size, scratch);
+
+  if constexpr (std::is_same_v<T, Timestamp>) {
+    source->skip(
+        numValues *
+        (useLosslessTimestamp ? sizeof(Timestamp) : sizeof(uint64_t)));
+    return;
+  }
+  source->skip(numValues * sizeof(T));
+}
+
+template <>
+void readStructNulls<StringView>(
+    ByteInputStream* source,
+    const TypePtr& type,
+    bool /*useLosslessTimestamp*/,
+    Scratch& scratch) {
+  const int32_t size = source->read<int32_t>();
+  source->skip(size * sizeof(int32_t));
+  valueCount(source, size, scratch);
+  const int32_t dataSize = source->read<int32_t>();
+  source->skip(dataSize);
+}
+
+void readStructNullsColumns(
+    ByteInputStream* source,
+    const std::vector<TypePtr>& types,
+    bool useLoasslessTimestamp,
+    Scratch& scratch);
+
+void readConstantVectorStructNulls(
+    ByteInputStream* source,
+    const TypePtr& type,
+    bool useLosslessTimestamp,
+    Scratch& scratch) {
+  source->read<int32_t>(); // size
+  std::vector<TypePtr> childTypes = {type};
+  readStructNullsColumns(source, childTypes, useLosslessTimestamp, scratch);
+}
+
+void readDictionaryVectorStructNulls(
+    ByteInputStream* source,
+    const TypePtr& type,
+    bool useLosslessTimestamp,
+    Scratch& scratch) {
+  const auto size = source->read<int32_t>();
+  std::vector<TypePtr> childTypes = {type};
+  readStructNullsColumns(source, childTypes, useLosslessTimestamp, scratch);
+
+  // Skip indices.
+  source->skip(sizeof(int32_t) * size);
+
+  // Skip 3 * 8 bytes of 'instance id'. Velox doesn't use 'instance id' for
+  // dictionary vectors.
+  source->skip(24);
+}
+
+void readArrayVectorStructNulls(
+    ByteInputStream* source,
+    const TypePtr& type,
+    bool useLosslessTimestamp,
+    Scratch& scratch) {
+  std::vector<TypePtr> childTypes = {type->childAt(0)};
+  readStructNullsColumns(source, childTypes, useLosslessTimestamp, scratch);
+
+  const vector_size_t size = source->read<int32_t>();
+
+  source->skip((size + 1) * sizeof(int32_t));
+  valueCount(source, size, scratch);
+}
+
+void readMapVectorStructNulls(
+    ByteInputStream* source,
+    const TypePtr& type,
+    bool useLosslessTimestamp,
+    Scratch& scratch) {
+  std::vector<TypePtr> childTypes = {type->childAt(0), type->childAt(1)};
+  readStructNullsColumns(source, childTypes, useLosslessTimestamp, scratch);
+
+  int32_t hashTableSize = source->read<int32_t>();
+  if (hashTableSize != -1) {
+    // Skip over serialized hash table from Presto wire format.
+    source->skip(hashTableSize * sizeof(int32_t));
+  }
+
+  const vector_size_t size = source->read<int32_t>();
 
-      it->second(source, types[i], pool, result[i], useLosslessTimestamp);
+  source->skip((1 + size) * sizeof(int32_t));
+  valueCount(source, size, scratch);
+}
+
+void readRowVectorStructNulls(
+    ByteInputStream* source,
+    const TypePtr& type,
+    bool useLosslessTimestamp,
+    Scratch& scratch) {
+  auto streamPos = source->tellp();
+  source->read<int32_t>(); // numChildren
+  const auto& childTypes = type->asRow().children();
+  readStructNullsColumns(source, childTypes, useLosslessTimestamp, scratch);
+
+  const auto size = source->read<int32_t>();
+  // Read and discard the offsets. The number of offsets is not affected by
+  // nulls.
+  source->skip((size + 1) * sizeof(int32_t));
+  raw_vector<uint64_t> nullsCopy;
+  auto numNonNull = valueCount(source, size, scratch, &nullsCopy);
+  if (size != numNonNull) {
+    (*structNullsMap())[streamPos] =
+        std::pair<raw_vector<uint64_t>, int32_t>(std::move(nullsCopy), size);
+  }
+}
+
+void readStructNullsColumns(
+    ByteInputStream* source,
+    const std::vector<TypePtr>& types,
+    bool useLosslessTimestamp,
+    Scratch& scratch) {
+  static const std::unordered_map<
+      TypeKind,
+      std::function<void(
+          ByteInputStream * source,
+          const TypePtr& type,
+          bool useLosslessTimestamp,
+          Scratch& scratch)>>
+      readers = {
+          {TypeKind::BOOLEAN, &readStructNulls<bool>},
+          {TypeKind::TINYINT, &readStructNulls<int8_t>},
+          {TypeKind::SMALLINT, &readStructNulls<int16_t>},
+          {TypeKind::INTEGER, &readStructNulls<int32_t>},
+          {TypeKind::BIGINT, &readStructNulls<int64_t>},
+          {TypeKind::HUGEINT, &readStructNulls<int128_t>},
+          {TypeKind::REAL, &readStructNulls<float>},
+          {TypeKind::DOUBLE, &readStructNulls<double>},
+          {TypeKind::TIMESTAMP, &readStructNulls<Timestamp>},
+          {TypeKind::VARCHAR, &readStructNulls<StringView>},
+          {TypeKind::VARBINARY, &readStructNulls<StringView>},
+          {TypeKind::ARRAY, &readArrayVectorStructNulls},
+          {TypeKind::MAP, &readMapVectorStructNulls},
+          {TypeKind::ROW, &readRowVectorStructNulls},
+          {TypeKind::UNKNOWN, &readStructNulls<UnknownValue>}};
+
+  for (int32_t i = 0; i < types.size(); ++i) {
+    const auto& columnType = types[i];
+
+    const auto encoding = readLengthPrefixedString(source);
+    if (encoding == kRLE) {
+      readConstantVectorStructNulls(
+          source, columnType, useLosslessTimestamp, scratch);
+    } else if (encoding == kDictionary) {
+      readDictionaryVectorStructNulls(
+          source, columnType, useLosslessTimestamp, scratch);
+    } else {
+      checkTypeEncoding(encoding, columnType);
+      const auto it = readers.find(columnType->kind());
+      VELOX_CHECK(
+          it != readers.end(),
+          "Column reader for type {} is missing",
+          columnType->kindName());
+
+      it->second(source, columnType, useLosslessTimestamp, scratch);
     }
   }
 }
@@ -925,98 +1335,154 @@ class CountingOutputStream : public OutputStream {
   std::streampos pos_{0};
 };
 
+raw_vector<uint64_t>& threadTempNulls() {
+  thread_local raw_vector<uint64_t> temp;
+  return temp;
+}
+
 // Appendable container for serialized values. To append a value at a
-// time, call appendNull or appendNonNull first. Then call
-// appendLength if the type has a length. A null value has a length of
-// 0. Then call appendValue if the value was not null.
+// time, call appendNull or appendNonNull first. Then call appendLength if the
+// type has a length. A null value has a length of 0. Then call appendValue if
+// the value was not null.
 class VectorStream {
  public:
+  // This constructor takes an optional encoding and vector. In cases where the
+  // vector (data) is not available when the stream is created, callers can also
+  // manually specify the encoding, which only applies to the top level stream.
+  // If both are specified, `encoding` takes precedence over the actual
+  // encoding of `vector`. Only 'flat' encoding can take precedence over the
+  // input data encoding.
   VectorStream(
       const TypePtr& type,
       std::optional<VectorEncoding::Simple> encoding,
+      std::optional<VectorPtr> vector,
       StreamArena* streamArena,
       int32_t initialNumRows,
-      bool useLosslessTimestamp)
+      const SerdeOpts& opts)
       : type_(type),
-        encoding_{encoding},
-        useLosslessTimestamp_(useLosslessTimestamp),
+        streamArena_(streamArena),
+        useLosslessTimestamp_(opts.useLosslessTimestamp),
+        nullsFirst_(opts.nullsFirst),
+        isLongDecimal_(type_->isLongDecimal()),
+        opts_(opts),
+        encoding_(getEncoding(encoding, vector)),
         nulls_(streamArena, true, true),
         lengths_(streamArena),
         values_(streamArena) {
     if (initialNumRows == 0) {
       initializeHeader(typeToEncodingName(type), *streamArena);
+      if (type_->size() > 0) {
+        hasLengths_ = true;
+        children_.resize(type_->size());
+        for (int32_t i = 0; i < type_->size(); ++i) {
+          children_[i] = std::make_unique<VectorStream>(
+              type_->childAt(i),
+              std::nullopt,
+              getChildAt(vector, i),
+              streamArena_,
+              initialNumRows,
+              opts_);
+        }
+
+        // The first element in the offsets in the wire format is always 0 for
+        // nested types.
+        lengths_.startWrite(sizeof(vector_size_t));
+        lengths_.appendOne<int32_t>(0);
+      }
       return;
     }
 
-    if (encoding.has_value()) {
-      switch (encoding.value()) {
+    if (encoding_.has_value()) {
+      switch (encoding_.value()) {
         case VectorEncoding::Simple::CONSTANT: {
           initializeHeader(kRLE, *streamArena);
+          isConstantStream_ = true;
           children_.emplace_back(std::make_unique<VectorStream>(
               type_,
               std::nullopt,
+              std::nullopt,
               streamArena,
               initialNumRows,
-              useLosslessTimestamp));
+              opts));
           return;
         }
         case VectorEncoding::Simple::DICTIONARY: {
+          // For fix width types that are smaller than int32_t (the type for
+          // indexes into the dictionary) dictionary encoding increases the
+          // size, so we should flatten it.
+          if (type->isFixedWidth() &&
+              type->cppSizeInBytes() <= sizeof(int32_t)) {
+            encoding_ = std::nullopt;
+            break;
+          }
+
           initializeHeader(kDictionary, *streamArena);
           values_.startWrite(initialNumRows * 4);
+          isDictionaryStream_ = true;
           children_.emplace_back(std::make_unique<VectorStream>(
               type_,
               std::nullopt,
+              std::nullopt,
               streamArena,
               initialNumRows,
-              useLosslessTimestamp));
+              opts));
           return;
         }
-        default:;
+        default:
+          break;
       }
     }
 
-    initializeHeader(typeToEncodingName(type), *streamArena);
-    nulls_.startWrite(1 + (initialNumRows / 8));
+    initializeFlatStream(vector, initialNumRows);
+  }
 
-    switch (type_->kind()) {
-      case TypeKind::ROW:
-        if (isTimestampWithTimeZoneType(type_)) {
-          values_.startWrite(initialNumRows * 4);
-          break;
-        }
-        [[fallthrough]];
-      case TypeKind::ARRAY:
-      case TypeKind::MAP:
-        hasLengths_ = true;
-        lengths_.startWrite(initialNumRows * sizeof(vector_size_t));
-        children_.resize(type_->size());
-        for (int32_t i = 0; i < type_->size(); ++i) {
-          children_[i] = std::make_unique<VectorStream>(
-              type_->childAt(i),
-              std::nullopt,
-              streamArena,
-              initialNumRows,
-              useLosslessTimestamp);
-        }
-        break;
-      case TypeKind::VARCHAR:
-      case TypeKind::VARBINARY:
-        hasLengths_ = true;
-        lengths_.startWrite(initialNumRows * sizeof(vector_size_t));
-        values_.startWrite(initialNumRows * 10);
-        break;
+  void flattenStream(const VectorPtr& vector, int32_t initialNumRows) {
+    VELOX_CHECK_EQ(nullCount_, 0);
+    VELOX_CHECK_EQ(nonNullCount_, 0);
+    VELOX_CHECK_EQ(totalLength_, 0);
 
-      default:;
-        values_.startWrite(initialNumRows * 4);
-        break;
+    if (!isConstantStream_ && !isDictionaryStream_) {
+      return;
+    }
+
+    encoding_ = std::nullopt;
+    isConstantStream_ = false;
+    isDictionaryStream_ = false;
+    children_.clear();
+
+    initializeFlatStream(vector, initialNumRows);
+  }
+
+  std::optional<VectorEncoding::Simple> getEncoding(
+      std::optional<VectorEncoding::Simple> encoding,
+      std::optional<VectorPtr> vector) {
+    if (encoding.has_value()) {
+      return encoding;
+    } else if (vector.has_value()) {
+      return vector.value()->encoding();
+    } else {
+      return std::nullopt;
+    }
+  }
+
+  std::optional<VectorPtr> getChildAt(
+      std::optional<VectorPtr> vector,
+      size_t idx) {
+    if (!vector.has_value()) {
+      return std::nullopt;
+    }
+
+    if ((*vector)->encoding() == VectorEncoding::Simple::ROW) {
+      return (*vector)->as<RowVector>()->childAt(idx);
     }
+    return std::nullopt;
   }
 
   void initializeHeader(std::string_view name, StreamArena& streamArena) {
-    streamArena.newTinyRange(50, &header_);
+    streamArena.newTinyRange(50, nullptr, &header_);
     header_.size = name.size() + sizeof(int32_t);
     *reinterpret_cast<int32_t*>(header_.buffer) = name.size();
-    memcpy(header_.buffer + sizeof(int32_t), &name[0], name.size());
+    ::memcpy(header_.buffer + sizeof(int32_t), &name[0], name.size());
   }
 
   void appendNull() {
@@ -1031,26 +1497,85 @@ class VectorStream {
   }
 
   void appendNonNull(int32_t count = 1) {
-    if (nullCount_) {
+    if (nullCount_ > 0) {
       nulls_.appendBool(false, count);
     }
     nonNullCount_ += count;
   }
 
   void appendLength(int32_t length) {
-    if (nullCount_ + nonNullCount_ == 1) {
-      // The first element in the offsets in the wire format is always 0 for
-      // nested types but not for string.
-      auto kind = type_->kind();
-      if (kind == TypeKind::ROW || kind == TypeKind::ARRAY ||
-          kind == TypeKind::MAP) {
-        lengths_.appendOne<int32_t>(0);
-      }
-    }
     totalLength_ += length;
     lengths_.appendOne<int32_t>(totalLength_);
   }
 
+  void appendNulls(
+      const uint64_t* nulls,
+      int32_t begin,
+      int32_t end,
+      int32_t numNonNull) {
+    VELOX_DCHECK_EQ(numNonNull, bits::countBits(nulls, begin, end));
+    const auto numRows = end - begin;
+    const auto numNulls = numRows - numNonNull;
+    if (numNulls == 0 && nullCount_ == 0) {
+      nonNullCount_ += numNonNull;
+      return;
+    }
+    if (FOLLY_UNLIKELY(numNulls > 0 && nonNullCount_ > 0 && nullCount_ == 0)) {
+      // There were only non-nulls up until now. Add the bits for them.
+      nulls_.appendBool(false, nonNullCount_);
+    }
+    nullCount_ += numNulls;
+    nonNullCount_ += numNonNull;
+
+    if (FOLLY_LIKELY(end <= 64)) {
+      const uint64_t inverted = ~nulls[0];
+      nulls_.appendBitsFresh(&inverted, begin, end);
+      return;
+    }
+
+    const int32_t firstWord = begin >> 6;
+    const int32_t firstBit = begin & 63;
+    const auto numWords = bits::nwords(numRows + firstBit);
+    // The polarity of nulls is reverse in wire format. Make an inverted copy.
+    uint64_t smallNulls[16];
+    uint64_t* invertedNulls = smallNulls;
+    if (numWords > sizeof(smallNulls) / sizeof(smallNulls[0])) {
+      auto& tempNulls = threadTempNulls();
+      tempNulls.resize(numWords + 1);
+      invertedNulls = tempNulls.data();
+    }
+    for (auto i = 0; i < numWords; ++i) {
+      invertedNulls[i] = ~nulls[i + firstWord];
+    }
+    nulls_.appendBitsFresh(invertedNulls, firstBit, firstBit + numRows);
+  }
+
+  // Appends a zero length for each null bit and a length from lengthFunc(row)
+  // for non-nulls in rows.
+  template <typename LengthFunc>
+  void appendLengths(
+      const uint64_t* nulls,
+      folly::Range<const vector_size_t*> rows,
+      int32_t numNonNull,
+      LengthFunc lengthFunc) {
+    const auto numRows = rows.size();
+    if (nulls == nullptr) {
+      appendNonNull(numRows);
+      for (auto i = 0; i < numRows; ++i) {
+        appendLength(lengthFunc(rows[i]));
+      }
+    } else {
+      appendNulls(nulls, 0, numRows, numNonNull);
+      for (auto i = 0; i < numRows; ++i) {
+        if (bits::isBitSet(nulls, i)) {
+          appendLength(lengthFunc(rows[i]));
+        } else {
+          appendLength(0);
+        }
+      }
+    }
+  }
+
   template <typename T>
   void append(folly::Range<const T*> values) {
     values_.append(values);
@@ -1061,10 +1586,26 @@ class VectorStream {
     append(folly::Range(&value, 1));
   }
 
+  bool isDictionaryStream() const {
+    return isDictionaryStream_;
+  }
+
+  bool isConstantStream() const {
+    return isConstantStream_;
+  }
+
   VectorStream* childAt(int32_t index) {
     return children_[index].get();
   }
 
+  ByteOutputStream& values() {
+    return values_;
+  }
+
+  auto& nulls() {
+    return nulls_;
+  }
+
   // Returns the size to flush to OutputStream before calling `flush`.
   size_t serializedSize() {
     CountingOutputStream out;
@@ -1095,41 +1636,32 @@ class VectorStream {
           writeInt64(out, unused);
           return;
         }
-        default:;
+        default:
+          break;
       }
     }
 
     switch (type_->kind()) {
       case TypeKind::ROW:
-        if (isTimestampWithTimeZoneType(type_)) {
+        if (opts_.nullsFirst) {
           writeInt32(out, nullCount_ + nonNullCount_);
           flushNulls(out);
-          values_.flush(out);
-          return;
         }
 
         writeInt32(out, children_.size());
         for (auto& child : children_) {
           child->flush(out);
         }
-        writeInt32(out, nullCount_ + nonNullCount_);
-        if (nullCount_ + nonNullCount_ == 0) {
-          // If nothing was added, there is still one offset in the wire
-          // format.
-          lengths_.appendOne<int32_t>(0);
+        if (!opts_.nullsFirst) {
+          writeInt32(out, nullCount_ + nonNullCount_);
+          lengths_.flush(out);
+          flushNulls(out);
         }
-        lengths_.flush(out);
-        flushNulls(out);
         return;
 
       case TypeKind::ARRAY:
         children_[0]->flush(out);
         writeInt32(out, nullCount_ + nonNullCount_);
-        if (nullCount_ + nonNullCount_ == 0) {
-          // If nothing was added, there is still one offset in the wire
-          // format.
-          lengths_.appendOne<int32_t>(0);
-        }
         lengths_.flush(out);
         flushNulls(out);
         return;
@@ -1140,11 +1672,6 @@ class VectorStream {
         // hash table size. -1 means not included in serialization.
         writeInt32(out, -1);
         writeInt32(out, nullCount_ + nonNullCount_);
-        if (nullCount_ + nonNullCount_ == 0) {
-          // If nothing was added, there is still one offset in the wire
-          // format.
-          lengths_.appendOne<int32_t>(0);
-        }
 
         lengths_.flush(out);
         flushNulls(out);
@@ -1178,22 +1705,98 @@ class VectorStream {
     }
   }
 
+  bool isLongDecimal() const {
+    return isLongDecimal_;
+  }
+
+  void clear() {
+    encoding_ = std::nullopt;
+    initializeHeader(typeToEncodingName(type_), *streamArena_);
+    nonNullCount_ = 0;
+    nullCount_ = 0;
+    totalLength_ = 0;
+    if (hasLengths_) {
+      lengths_.startWrite(lengths_.size());
+      if (type_->kind() == TypeKind::ROW || type_->kind() == TypeKind::ARRAY ||
+          type_->kind() == TypeKind::MAP) {
+        // A complex type has a 0 as first length.
+        lengths_.appendOne<int32_t>(0);
+      }
+    }
+    nulls_.startWrite(nulls_.size());
+    values_.startWrite(values_.size());
+    for (auto& child : children_) {
+      child->clear();
+    }
+  }
+
  private:
+  void initializeFlatStream(
+      std::optional<VectorPtr> vector,
+      vector_size_t initialNumRows) {
+    initializeHeader(typeToEncodingName(type_), *streamArena_);
+    nulls_.startWrite(1 + (initialNumRows / 8));
+
+    switch (type_->kind()) {
+      case TypeKind::ROW:
+        [[fallthrough]];
+      case TypeKind::ARRAY:
+        [[fallthrough]];
+      case TypeKind::MAP:
+        hasLengths_ = true;
+        lengths_.startWrite(initialNumRows * sizeof(vector_size_t));
+        children_.resize(type_->size());
+        for (int32_t i = 0; i < type_->size(); ++i) {
+          children_[i] = std::make_unique<VectorStream>(
+              type_->childAt(i),
+              std::nullopt,
+              getChildAt(vector, i),
+              streamArena_,
+              initialNumRows,
+              opts_);
+        }
+        // The first element in the offsets in the wire format is always 0 for
+        // nested types.
+        lengths_.appendOne<int32_t>(0);
+        break;
+      case TypeKind::VARCHAR:
+        [[fallthrough]];
+      case TypeKind::VARBINARY:
+        hasLengths_ = true;
+        lengths_.startWrite(initialNumRows * sizeof(vector_size_t));
+        if (values_.ranges().empty()) {
+          values_.startWrite(initialNumRows * 10);
+        }
+        break;
+      default:
+        if (values_.ranges().empty()) {
+          values_.startWrite(initialNumRows * 4);
+        }
+        break;
+    }
+  }
+
   const TypePtr type_;
-  const std::optional<VectorEncoding::Simple> encoding_;
+  StreamArena* const streamArena_;
   /// Indicates whether to serialize timestamps with nanosecond precision.
   /// If false, they are serialized with millisecond precision which is
   /// compatible with presto.
   const bool useLosslessTimestamp_;
+  const bool nullsFirst_;
+  const bool isLongDecimal_;
+  const SerdeOpts opts_;
+  std::optional<VectorEncoding::Simple> encoding_;
   int32_t nonNullCount_{0};
   int32_t nullCount_{0};
   int32_t totalLength_{0};
   bool hasLengths_{false};
   ByteRange header_;
-  ByteStream nulls_;
-  ByteStream lengths_;
-  ByteStream values_;
+  ByteOutputStream nulls_;
+  ByteOutputStream lengths_;
+  ByteOutputStream values_;
   std::vector<std::unique_ptr<VectorStream>> children_;
+  bool isDictionaryStream_{false};
+  bool isConstantStream_{false};
 };
 
 template <>
@@ -1201,13 +1804,13 @@ inline void VectorStream::append(folly::Range<const StringView*> values) {
   for (auto& value : values) {
     auto size = value.size();
     appendLength(size);
-    values_.appendStringPiece(folly::StringPiece(value.data(), size));
+    values_.appendStringView(value);
   }
 }
 
 template <>
 void VectorStream::append(folly::Range<const Timestamp*> values) {
-  if (useLosslessTimestamp_) {
+  if (opts_.useLosslessTimestamp) {
     for (auto& value : values) {
       appendOne(value.getSeconds());
       appendOne(value.getNanos());
@@ -1229,12 +1832,11 @@ void VectorStream::append(folly::Range<const bool*> values) {
 }
 
 FOLLY_ALWAYS_INLINE int128_t toJavaDecimalValue(int128_t value) {
-  constexpr int128_t kInt128SerializeMask = (static_cast<int128_t>(1) << 127);
   // Presto Java UnscaledDecimal128 representation uses signed magnitude
   // representation. Only negative values differ in this representation.
   if (value < 0) {
     value *= -1;
-    value |= kInt128SerializeMask;
+    value |= DecimalUtil::kInt128Mask;
   }
   return value;
 }
@@ -1243,7 +1845,7 @@ template <>
 void VectorStream::append(folly::Range<const int128_t*> values) {
   for (auto& value : values) {
     int128_t val = value;
-    if (type_->isLongDecimal()) {
+    if (isLongDecimal_) {
       val = toJavaDecimalValue(value);
     }
     values_.append<int128_t>(folly::Range(&val, 1));
@@ -1252,12 +1854,12 @@ void VectorStream::append(folly::Range<const int128_t*> values) {
 
 template <TypeKind kind>
 void serializeFlatVector(
-    const BaseVector* vector,
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
     VectorStream* stream) {
   using T = typename TypeTraits<kind>::NativeType;
-  auto flatVector = dynamic_cast<const FlatVector<T>*>(vector);
-  auto rawValues = flatVector->rawValues();
+  auto* flatVector = vector->as<FlatVector<T>>();
+  auto* rawValues = flatVector->rawValues();
   if (!flatVector->mayHaveNulls()) {
     for (auto& range : ranges) {
       stream->appendNonNull(range.size);
@@ -1267,7 +1869,7 @@ void serializeFlatVector(
     int32_t firstNonNull = -1;
     int32_t lastNonNull = -1;
     for (int32_t i = 0; i < ranges.size(); ++i) {
-      int32_t end = ranges[i].begin + ranges[i].size;
+      const int32_t end = ranges[i].begin + ranges[i].size;
       for (int32_t offset = ranges[i].begin; offset < end; ++offset) {
         if (flatVector->isNullAt(offset)) {
           stream->appendNull();
@@ -1301,10 +1903,10 @@ void serializeFlatVector(
 
 template <>
 void serializeFlatVector<TypeKind::BOOLEAN>(
-    const BaseVector* vector,
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
     VectorStream* stream) {
-  auto flatVector = dynamic_cast<const FlatVector<bool>*>(vector);
+  auto flatVector = vector->as<FlatVector<bool>>();
   if (!vector->mayHaveNulls()) {
     for (int32_t i = 0; i < ranges.size(); ++i) {
       stream->appendNonNull(ranges[i].size);
@@ -1329,93 +1931,79 @@ void serializeFlatVector<TypeKind::BOOLEAN>(
 }
 
 void serializeColumn(
-    const BaseVector* vector,
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream);
+    VectorStream* stream,
+    Scratch& scratch);
+
+void serializeColumn(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch);
 
 void serializeWrapped(
-    const BaseVector* vector,
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
+    VectorStream* stream,
+    Scratch& scratch) {
   std::vector<IndexRange> newRanges;
-  bool mayHaveNulls = vector->mayHaveNulls();
-  const BaseVector* wrapped = vector->wrappedVector();
+  const bool mayHaveNulls = vector->mayHaveNulls();
+  const VectorPtr& wrapped = BaseVector::wrappedVectorShared(vector);
   for (int32_t i = 0; i < ranges.size(); ++i) {
-    auto end = ranges[i].begin + ranges[i].size;
+    const auto end = ranges[i].begin + ranges[i].size;
     for (int32_t offset = ranges[i].begin; offset < end; ++offset) {
       if (mayHaveNulls && vector->isNullAt(offset)) {
         // The wrapper added a null.
         if (!newRanges.empty()) {
-          serializeColumn(wrapped, newRanges, stream);
+          serializeColumn(wrapped, newRanges, stream, scratch);
           newRanges.clear();
         }
         stream->appendNull();
         continue;
       }
-      auto innerIndex = vector->wrappedIndex(offset);
+      const auto innerIndex = vector->wrappedIndex(offset);
       newRanges.push_back(IndexRange{innerIndex, 1});
     }
   }
   if (!newRanges.empty()) {
-    serializeColumn(wrapped, newRanges, stream);
+    serializeColumn(wrapped, newRanges, stream, scratch);
   }
 }
 
-void serializeTimestampWithTimeZone(
-    const RowVector* rowVector,
+void serializeRowVector(
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
-  auto timestamps = rowVector->childAt(0)->as<SimpleVector<int64_t>>();
-  auto timezones = rowVector->childAt(1)->as<SimpleVector<int16_t>>();
-  for (const auto& range : ranges) {
-    for (auto i = range.begin; i < range.begin + range.size; ++i) {
-      if (rowVector->isNullAt(i)) {
+    VectorStream* stream,
+    Scratch& scratch) {
+  auto rowVector = vector->as<RowVector>();
+
+  std::vector<IndexRange> childRanges;
+  for (int32_t i = 0; i < ranges.size(); ++i) {
+    auto begin = ranges[i].begin;
+    auto end = begin + ranges[i].size;
+    for (auto offset = begin; offset < end; ++offset) {
+      if (rowVector->isNullAt(offset)) {
         stream->appendNull();
       } else {
         stream->appendNonNull();
-        stream->appendOne(packTimestampWithTimeZone(
-            timestamps->valueAt(i), timezones->valueAt(i)));
-      }
-    }
-  }
-}
-
-void serializeRowVector(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
-  auto rowVector = dynamic_cast<const RowVector*>(vector);
-
-  if (isTimestampWithTimeZoneType(vector->type())) {
-    serializeTimestampWithTimeZone(rowVector, ranges, stream);
-    return;
-  }
-
-  std::vector<IndexRange> childRanges;
-  for (int32_t i = 0; i < ranges.size(); ++i) {
-    auto begin = ranges[i].begin;
-    auto end = begin + ranges[i].size;
-    for (auto offset = begin; offset < end; ++offset) {
-      if (rowVector->isNullAt(offset)) {
-        stream->appendNull();
-      } else {
-        stream->appendNonNull();
-        stream->appendLength(1);
-        childRanges.push_back(IndexRange{offset, 1});
+        stream->appendLength(1);
+        childRanges.push_back(IndexRange{offset, 1});
       }
     }
   }
   for (int32_t i = 0; i < rowVector->childrenSize(); ++i) {
     serializeColumn(
-        rowVector->childAt(i).get(), childRanges, stream->childAt(i));
+        rowVector->childAt(i), childRanges, stream->childAt(i), scratch);
   }
 }
 
 void serializeArrayVector(
-    const BaseVector* vector,
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
-  auto arrayVector = dynamic_cast<const ArrayVector*>(vector);
+    VectorStream* stream,
+    Scratch& scratch) {
+  auto arrayVector = vector->as<ArrayVector>();
   auto rawSizes = arrayVector->rawSizes();
   auto rawOffsets = arrayVector->rawOffsets();
   std::vector<IndexRange> childRanges;
@@ -1437,14 +2025,15 @@ void serializeArrayVector(
     }
   }
   serializeColumn(
-      arrayVector->elements().get(), childRanges, stream->childAt(0));
+      arrayVector->elements(), childRanges, stream->childAt(0), scratch);
 }
 
 void serializeMapVector(
-    const BaseVector* vector,
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
-  auto mapVector = dynamic_cast<const MapVector*>(vector);
+    VectorStream* stream,
+    Scratch& scratch) {
+  auto mapVector = vector->as<MapVector>();
   auto rawSizes = mapVector->rawSizes();
   auto rawOffsets = mapVector->rawOffsets();
   std::vector<IndexRange> childRanges;
@@ -1465,9 +2054,10 @@ void serializeMapVector(
       }
     }
   }
-  serializeColumn(mapVector->mapKeys().get(), childRanges, stream->childAt(0));
   serializeColumn(
-      mapVector->mapValues().get(), childRanges, stream->childAt(1));
+      mapVector->mapKeys(), childRanges, stream->childAt(0), scratch);
+  serializeColumn(
+      mapVector->mapValues(), childRanges, stream->childAt(1), scratch);
 }
 
 static inline int32_t rangesTotalSize(
@@ -1479,18 +2069,127 @@ static inline int32_t rangesTotalSize(
   return total;
 }
 
+template <typename T>
+vector_size_t computeSelectedIndices(
+    const DictionaryVector<T>* dictionaryVector,
+    const folly::Range<const IndexRange*>& ranges,
+    Scratch& scratch,
+    vector_size_t* selectedIndices) {
+  // Create a bit set to track which values in the Dictionary are used.
+  ScratchPtr<uint64_t, 64> usedIndicesHolder(scratch);
+  auto* usedIndices = usedIndicesHolder.get(
+      bits::nwords(dictionaryVector->valueVector()->size()));
+  simd::memset(usedIndices, 0, usedIndicesHolder.size() * sizeof(uint64_t));
+
+  auto* indices = dictionaryVector->indices()->template as<vector_size_t>();
+  for (const auto& range : ranges) {
+    for (auto i = 0; i < range.size; ++i) {
+      bits::setBit(usedIndices, indices[range.begin + i]);
+    }
+  }
+
+  // Convert the bitset to a list of the used indices.
+  return simd::indicesOfSetBits(
+      usedIndices, 0, dictionaryVector->valueVector()->size(), selectedIndices);
+}
+
+template <TypeKind Kind>
+void serializeDictionaryVector(
+    const VectorPtr& vector,
+    const folly::Range<const IndexRange*>& ranges,
+    VectorStream* stream,
+    Scratch& scratch) {
+  // Check if the stream was set up for dictionary (we had to know the
+  // encoding type when creating VectorStream for that).
+  if (!stream->isDictionaryStream()) {
+    serializeWrapped(vector, ranges, stream, scratch);
+    return;
+  }
+
+  auto numRows = rangesTotalSize(ranges);
+
+  // Cannot serialize dictionary as PrestoPage dictionary if it has nulls.
+  if (vector->nulls()) {
+    stream->flattenStream(vector, numRows);
+    serializeWrapped(vector, ranges, stream, scratch);
+    return;
+  }
+
+  using T = typename KindToFlatVector<Kind>::WrapperType;
+  auto dictionaryVector = vector->as<DictionaryVector<T>>();
+
+  ScratchPtr<vector_size_t, 64> selectedIndicesHolder(scratch);
+  auto* mutableSelectedIndices =
+      selectedIndicesHolder.get(dictionaryVector->valueVector()->size());
+  auto numUsed = computeSelectedIndices(
+      dictionaryVector, ranges, scratch, mutableSelectedIndices);
+
+  // If the values are fixed width and we aren't getting enough reuse to justify
+  // the dictionary, flatten it.
+  // For variable width types, rather than iterate over them computing their
+  // size, we simply assume we'll get a benefit.
+  if constexpr (TypeTraits<Kind>::isFixedWidth) {
+    // This calculation admittdely ignores some constants, but if they really
+    // make a difference, they're small so there's not much difference either
+    // way.
+    if (numUsed * vector->type()->cppSizeInBytes() +
+            numRows * sizeof(int32_t) >=
+        numRows * vector->type()->cppSizeInBytes()) {
+      stream->flattenStream(vector, numRows);
+      serializeWrapped(vector, ranges, stream, scratch);
+      return;
+    }
+  }
+
+  // If every element is unique the dictionary isn't giving us any benefit,
+  // flatten it.
+  if (numUsed == numRows) {
+    stream->flattenStream(vector, numRows);
+    serializeWrapped(vector, ranges, stream, scratch);
+    return;
+  }
+
+  // Serialize the used elements from the Dictionary.
+  serializeColumn(
+      dictionaryVector->valueVector(),
+      folly::Range<const vector_size_t*>(mutableSelectedIndices, numUsed),
+      stream->childAt(0),
+      scratch);
+
+  // Create a mapping from the original indices to the indices in the shrunk
+  // Dictionary of just used values.
+  ScratchPtr<vector_size_t, 64> updatedIndicesHolder(scratch);
+  auto* updatedIndices =
+      updatedIndicesHolder.get(dictionaryVector->valueVector()->size());
+  vector_size_t curIndex = 0;
+  for (vector_size_t i = 0; i < numUsed; ++i) {
+    updatedIndices[mutableSelectedIndices[i]] = curIndex++;
+  }
+
+  // Write out the indices, translating them using the above mapping.
+  stream->appendNonNull(numRows);
+  auto* indices = dictionaryVector->indices()->template as<vector_size_t>();
+  for (const auto& range : ranges) {
+    for (auto i = 0; i < range.size; ++i) {
+      stream->appendOne(updatedIndices[indices[range.begin + i]]);
+    }
+  }
+}
+
 template <TypeKind kind>
-void serializeConstantVector(
-    const BaseVector* vector,
+void serializeConstantVectorImpl(
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
+    VectorStream* stream,
+    Scratch& scratch) {
   using T = typename KindToFlatVector<kind>::WrapperType;
-  auto constVector = dynamic_cast<const ConstantVector<T>*>(vector);
-  if (constVector->valueVector()) {
-    serializeWrapped(constVector, ranges, stream);
+  auto constVector = vector->as<ConstantVector<T>>();
+  if (constVector->valueVector() != nullptr) {
+    serializeWrapped(vector, ranges, stream, scratch);
     return;
   }
-  int32_t count = rangesTotalSize(ranges);
+
+  const int32_t count = rangesTotalSize(ranges);
   if (vector->isNullAt(0)) {
     for (int32_t i = 0; i < count; ++i) {
       stream->appendNull();
@@ -1498,19 +2197,39 @@ void serializeConstantVector(
     return;
   }
 
-  T value = constVector->valueAtFast(0);
+  const T value = constVector->valueAtFast(0);
   for (int32_t i = 0; i < count; ++i) {
     stream->appendNonNull();
     stream->appendOne(value);
   }
 }
 
+template <TypeKind Kind>
+void serializeConstantVector(
+    const VectorPtr& vector,
+    const folly::Range<const IndexRange*>& ranges,
+    VectorStream* stream,
+    Scratch& scratch) {
+  if (stream->isConstantStream()) {
+    for (const auto& range : ranges) {
+      stream->appendNonNull(range.size);
+    }
+
+    std::vector<IndexRange> newRanges;
+    newRanges.push_back({0, 1});
+    serializeConstantVectorImpl<Kind>(
+        vector, newRanges, stream->childAt(0), scratch);
+  } else {
+    serializeConstantVectorImpl<Kind>(vector, ranges, stream, scratch);
+  }
+}
+
 template <typename T>
 void serializeBiasVector(
-    const BaseVector* vector,
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
     VectorStream* stream) {
-  auto biasVector = dynamic_cast<const BiasVector<T>*>(vector);
+  auto biasVector = vector->as<BiasVector<T>>();
   if (!vector->mayHaveNulls()) {
     for (int32_t i = 0; i < ranges.size(); ++i) {
       stream->appendNonNull(ranges[i].size);
@@ -1535,9 +2254,10 @@ void serializeBiasVector(
 }
 
 void serializeColumn(
-    const BaseVector* vector,
+    const VectorPtr& vector,
     const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
+    VectorStream* stream,
+    Scratch& scratch) {
   switch (vector->encoding()) {
     case VectorEncoding::Simple::FLAT:
       VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
@@ -1545,7 +2265,21 @@ void serializeColumn(
       break;
     case VectorEncoding::Simple::CONSTANT:
       VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-          serializeConstantVector, vector->typeKind(), vector, ranges, stream);
+          serializeConstantVector,
+          vector->typeKind(),
+          vector,
+          ranges,
+          stream,
+          scratch);
+      break;
+    case VectorEncoding::Simple::DICTIONARY:
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+          serializeDictionaryVector,
+          vector->typeKind(),
+          vector,
+          ranges,
+          stream,
+          scratch);
       break;
     case VectorEncoding::Simple::BIASED:
       switch (vector->typeKind()) {
@@ -1559,194 +2293,728 @@ void serializeColumn(
           serializeBiasVector<int64_t>(vector, ranges, stream);
           break;
         default:
-          throw std::invalid_argument("Invalid biased vector type");
+          VELOX_FAIL(
+              "Invalid biased vector type {}",
+              static_cast<int>(vector->encoding()));
       }
       break;
     case VectorEncoding::Simple::ROW:
-      serializeRowVector(vector, ranges, stream);
+      serializeRowVector(vector, ranges, stream, scratch);
       break;
     case VectorEncoding::Simple::ARRAY:
-      serializeArrayVector(vector, ranges, stream);
+      serializeArrayVector(vector, ranges, stream, scratch);
       break;
     case VectorEncoding::Simple::MAP:
-      serializeMapVector(vector, ranges, stream);
+      serializeMapVector(vector, ranges, stream, scratch);
       break;
     case VectorEncoding::Simple::LAZY:
-      serializeColumn(vector->loadedVector(), ranges, stream);
+      serializeColumn(
+          BaseVector::loadedVectorShared(vector), ranges, stream, scratch);
       break;
     default:
-      serializeWrapped(vector, ranges, stream);
+      serializeWrapped(vector, ranges, stream, scratch);
   }
 }
 
-template <TypeKind Kind>
-void serializeConstantColumn(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
-  for (const auto& range : ranges) {
-    stream->appendNonNull(range.size);
+// Returns ranges for the non-null rows of an array  or map. 'rows' gives the
+// rows. nulls is the nulls of the array/map or nullptr if no nulls. 'offsets'
+// and 'sizes' are the offsets and sizes of the array/map.Returns the number of
+// index ranges. Obtains the ranges from 'rangesHolder'. If 'sizesPtr' is
+// non-null, gets returns  the sizes for the inner ranges in 'sizesHolder'. If
+// 'stream' is non-null, writes the lengths and nulls for the array/map into
+// 'stream'.
+int32_t rowsToRanges(
+    folly::Range<const vector_size_t*> rows,
+    const uint64_t* rawNulls,
+    const vector_size_t* offsets,
+    const vector_size_t* sizes,
+    vector_size_t** sizesPtr,
+    ScratchPtr<IndexRange>& rangesHolder,
+    ScratchPtr<vector_size_t*>* sizesHolder,
+    VectorStream* stream,
+    Scratch& scratch) {
+  auto numRows = rows.size();
+  auto* innerRows = rows.data();
+  auto* nonNullRows = innerRows;
+  int32_t numInner = rows.size();
+  ScratchPtr<vector_size_t, 64> nonNullHolder(scratch);
+  ScratchPtr<vector_size_t, 64> innerRowsHolder(scratch);
+  if (rawNulls) {
+    ScratchPtr<uint64_t, 4> nullsHolder(scratch);
+    auto* nulls = nullsHolder.get(bits::nwords(rows.size()));
+    simd::gatherBits(rawNulls, rows, nulls);
+    auto* mutableNonNullRows = nonNullHolder.get(numRows);
+    auto* mutableInnerRows = innerRowsHolder.get(numRows);
+    numInner = simd::indicesOfSetBits(nulls, 0, numRows, mutableNonNullRows);
+    if (stream) {
+      stream->appendLengths(
+          nulls, rows, numInner, [&](auto row) { return sizes[row]; });
+    }
+    simd::transpose(
+        rows.data(),
+        folly::Range<const vector_size_t*>(mutableNonNullRows, numInner),
+        mutableInnerRows);
+    nonNullRows = mutableNonNullRows;
+    innerRows = mutableInnerRows;
+  } else if (stream) {
+    stream->appendNonNull(rows.size());
+    for (auto i = 0; i < rows.size(); ++i) {
+      stream->appendLength(sizes[rows[i]]);
+    }
   }
+  vector_size_t** sizesOut = nullptr;
+  if (sizesPtr) {
+    sizesOut = sizesHolder->get(numInner);
+  }
+  auto ranges = rangesHolder.get(numInner);
+  int32_t fill = 0;
+  for (auto i = 0; i < numInner; ++i) {
+    // Add the size of the length.
+    if (sizesPtr) {
+      *sizesPtr[rawNulls ? nonNullRows[i] : i] += sizeof(int32_t);
+    }
+    if (sizes[innerRows[i]] == 0) {
+      continue;
+    }
+    if (sizesOut) {
+      sizesOut[fill] = sizesPtr[rawNulls ? nonNullRows[i] : i];
+    }
+    ranges[fill].begin = offsets[innerRows[i]];
+    ranges[fill].size = sizes[innerRows[i]];
+    ++fill;
+  }
+  return fill;
+}
 
-  std::vector<IndexRange> newRanges;
-  newRanges.push_back({0, 1});
-  serializeConstantVector<Kind>(vector, newRanges, stream->childAt(0));
+template <typename T>
+void copyWords(
+    T* destination,
+    const int32_t* indices,
+    int32_t numIndices,
+    const T* values,
+    bool isLongDecimal = false) {
+  if (std::is_same_v<T, int128_t> && isLongDecimal) {
+    for (auto i = 0; i < numIndices; ++i) {
+      reinterpret_cast<int128_t*>(destination)[i] = toJavaDecimalValue(
+          reinterpret_cast<const int128_t*>(values)[indices[i]]);
+    }
+    return;
+  }
+  for (auto i = 0; i < numIndices; ++i) {
+    destination[i] = values[indices[i]];
+  }
 }
 
-template <TypeKind Kind>
-void serializeDictionaryColumn(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
-  using T = typename KindToFlatVector<Kind>::WrapperType;
+template <typename T>
+void copyWordsWithRows(
+    T* destination,
+    const int32_t* rows,
+    const int32_t* indices,
+    int32_t numIndices,
+    const T* values,
+    bool isLongDecimal = false) {
+  if (!indices) {
+    copyWords(destination, rows, numIndices, values, isLongDecimal);
+    return;
+  }
+  if (std::is_same_v<T, int128_t> && isLongDecimal) {
+    for (auto i = 0; i < numIndices; ++i) {
+      reinterpret_cast<int128_t*>(destination)[i] = toJavaDecimalValue(
+          reinterpret_cast<const int128_t*>(values)[rows[indices[i]]]);
+    }
+    return;
+  }
+  for (auto i = 0; i < numIndices; ++i) {
+    destination[i] = values[rows[indices[i]]];
+  }
+}
 
-  auto dictionaryVector = dynamic_cast<const DictionaryVector<T>*>(vector);
-  VELOX_CHECK_NULL(
-      dictionaryVector->nulls(),
-      "Cannot serialize dictionary vector with nulls");
+template <typename T>
+void appendNonNull(
+    VectorStream* stream,
+    const uint64_t* nulls,
+    folly::Range<const vector_size_t*> rows,
+    const T* values,
+    Scratch& scratch) {
+  auto numRows = rows.size();
+  ScratchPtr<int32_t, 64> nonNullHolder(scratch);
+  const int32_t* nonNullIndices;
+  int32_t numNonNull;
+  if (LIKELY(numRows <= 8)) {
+    // Short batches need extra optimization. The set bits are prematerialized.
+    uint8_t nullsByte = *reinterpret_cast<const uint8_t*>(nulls);
+    numNonNull = __builtin_popcount(nullsByte);
+    nonNullIndices =
+        numNonNull == numRows ? nullptr : simd::byteSetBits(nullsByte);
+  } else {
+    auto mutableIndices = nonNullHolder.get(numRows);
+    // Convert null flags to indices. This is much faster than checking bits one
+    // by one, several bits per clock specially if mostly null or non-null. Even
+    // worst case of half nulls is more than one row per clock.
+    numNonNull = simd::indicesOfSetBits(nulls, 0, numRows, mutableIndices);
+    nonNullIndices = numNonNull == numRows ? nullptr : mutableIndices;
+  }
+  stream->appendNulls(nulls, 0, rows.size(), numNonNull);
+  ByteOutputStream& out = stream->values();
+
+  if constexpr (sizeof(T) == 8) {
+    AppendWindow<int64_t> window(out, scratch);
+    int64_t* output = window.get(numNonNull);
+    copyWordsWithRows(
+        output,
+        rows.data(),
+        nonNullIndices,
+        numNonNull,
+        reinterpret_cast<const int64_t*>(values));
+  } else if constexpr (sizeof(T) == 4) {
+    AppendWindow<int32_t> window(out, scratch);
+    int32_t* output = window.get(numNonNull);
+    copyWordsWithRows(
+        output,
+        rows.data(),
+        nonNullIndices,
+        numNonNull,
+        reinterpret_cast<const int32_t*>(values));
+  } else {
+    AppendWindow<T> window(out, scratch);
+    T* output = window.get(numNonNull);
+    copyWordsWithRows(
+        output,
+        rows.data(),
+        nonNullIndices,
+        numNonNull,
+        values,
+        stream->isLongDecimal());
+  }
+}
 
-  std::vector<IndexRange> childRanges;
-  childRanges.push_back({0, dictionaryVector->valueVector()->size()});
-  serializeColumn(
-      dictionaryVector->valueVector().get(), childRanges, stream->childAt(0));
+void appendStrings(
+    const uint64_t* nulls,
+    folly::Range<const vector_size_t*> rows,
+    const StringView* views,
+    VectorStream* stream,
+    Scratch& scratch) {
+  if (nulls == nullptr) {
+    stream->appendLengths(nullptr, rows, rows.size(), [&](auto row) {
+      return views[row].size();
+    });
+    for (auto i = 0; i < rows.size(); ++i) {
+      const auto& view = views[rows[i]];
+      stream->values().appendStringView(
+          std::string_view(view.data(), view.size()));
+    }
+    return;
+  }
 
-  const BufferPtr& indices = dictionaryVector->indices();
-  auto* rawIndices = indices->as<vector_size_t>();
-  for (const auto& range : ranges) {
-    stream->appendNonNull(range.size);
-    stream->append<int32_t>(folly::Range(&rawIndices[range.begin], range.size));
+  ScratchPtr<vector_size_t, 64> nonNullHolder(scratch);
+  auto* nonNull = nonNullHolder.get(rows.size());
+  const auto numNonNull =
+      simd::indicesOfSetBits(nulls, 0, rows.size(), nonNull);
+  stream->appendLengths(
+      nulls, rows, numNonNull, [&](auto row) { return views[row].size(); });
+  for (auto i = 0; i < numNonNull; ++i) {
+    auto& view = views[rows[nonNull[i]]];
+    stream->values().appendStringView(
+        std::string_view(view.data(), view.size()));
   }
 }
 
-void serializeEncodedColumn(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    VectorStream* stream) {
-  switch (vector->encoding()) {
-    case VectorEncoding::Simple::CONSTANT:
-      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-          serializeConstantColumn, vector->typeKind(), vector, ranges, stream);
-      break;
-    case VectorEncoding::Simple::DICTIONARY:
-      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-          serializeDictionaryColumn,
-          vector->typeKind(),
-          vector,
-          ranges,
-          stream);
-      break;
-    default:
-      serializeColumn(vector, ranges, stream);
+void appendTimestamps(
+    const uint64_t* nulls,
+    folly::Range<const vector_size_t*> rows,
+    const Timestamp* timestamps,
+    VectorStream* stream,
+    Scratch& scratch) {
+  if (nulls == nullptr) {
+    stream->appendNonNull(rows.size());
+    for (auto i = 0; i < rows.size(); ++i) {
+      stream->appendOne(timestamps[rows[i]]);
+    }
+    return;
+  }
+
+  ScratchPtr<vector_size_t, 64> nonNullHolder(scratch);
+  auto* nonNullRows = nonNullHolder.get(rows.size());
+  const auto numNonNull =
+      simd::indicesOfSetBits(nulls, 0, rows.size(), nonNullRows);
+  stream->appendNulls(nulls, 0, rows.size(), numNonNull);
+  for (auto i = 0; i < numNonNull; ++i) {
+    stream->appendOne(timestamps[rows[nonNullRows[i]]]);
   }
 }
 
-void expandRepeatedRanges(
-    const BaseVector* vector,
-    const vector_size_t* rawOffsets,
-    const vector_size_t* rawSizes,
-    const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes,
-    std::vector<IndexRange>* childRanges,
-    std::vector<vector_size_t*>* childSizes) {
-  for (int32_t i = 0; i < ranges.size(); ++i) {
-    int32_t begin = ranges[i].begin;
-    int32_t end = begin + ranges[i].size;
-    *sizes[i] += sizeof(int32_t);
-    for (int32_t offset = begin; offset < end; ++offset) {
-      if (!vector->isNullAt(offset)) {
-        childRanges->push_back(
-            IndexRange{rawOffsets[offset], rawSizes[offset]});
-        childSizes->push_back(sizes[i]);
-      }
+template <TypeKind kind>
+void serializeFlatVector(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  using T = typename TypeTraits<kind>::NativeType;
+  auto* flatVector = vector->asUnchecked<FlatVector<T>>();
+  auto* rawValues = flatVector->rawValues();
+  if (!flatVector->mayHaveNulls()) {
+    if (std::is_same_v<T, Timestamp>) {
+      appendTimestamps(
+          nullptr,
+          rows,
+          reinterpret_cast<const Timestamp*>(rawValues),
+          stream,
+          scratch);
+      return;
+    }
+
+    if (std::is_same_v<T, StringView>) {
+      appendStrings(
+          nullptr,
+          rows,
+          reinterpret_cast<const StringView*>(rawValues),
+          stream,
+          scratch);
+      return;
     }
+
+    stream->appendNonNull(rows.size());
+    AppendWindow<T> window(stream->values(), scratch);
+    T* output = window.get(rows.size());
+    copyWords(
+        output, rows.data(), rows.size(), rawValues, stream->isLongDecimal());
+    return;
+  }
+
+  ScratchPtr<uint64_t, 4> nullsHolder(scratch);
+  uint64_t* nulls = nullsHolder.get(bits::nwords(rows.size()));
+  simd::gatherBits(vector->rawNulls(), rows, nulls);
+  if (std::is_same_v<T, Timestamp>) {
+    appendTimestamps(
+        nulls,
+        rows,
+        reinterpret_cast<const Timestamp*>(rawValues),
+        stream,
+        scratch);
+    return;
+  }
+  if (std::is_same_v<T, StringView>) {
+    appendStrings(
+        nulls,
+        rows,
+        reinterpret_cast<const StringView*>(rawValues),
+        stream,
+        scratch);
+    return;
   }
+  appendNonNull(stream, nulls, rows, rawValues, scratch);
 }
 
-template <TypeKind Kind>
-void estimateFlatSerializedSize(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
-  auto valueSize = vector->type()->cppSizeInBytes();
-  if (vector->mayHaveNulls()) {
-    for (int32_t i = 0; i < ranges.size(); ++i) {
-      auto end = ranges[i].begin + ranges[i].size;
-      int32_t numNulls = 0;
-      int32_t bytes = 0;
-      auto rawNulls = vector->rawNulls();
-      for (int32_t offset = ranges[i].begin; offset < end; ++offset) {
-        if (bits::isBitNull(rawNulls, offset)) {
-          ++numNulls;
-        } else {
-          bytes += valueSize;
-        }
-      }
-      *(sizes[i]) += bytes + bits::nbytes(numNulls);
-    }
+uint64_t bitsToBytesMap[256];
+
+uint64_t bitsToBytes(uint8_t byte) {
+  return bitsToBytesMap[byte];
+}
+
+template <>
+void serializeFlatVector<TypeKind::BOOLEAN>(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  auto* flatVector = vector->as<FlatVector<bool>>();
+  auto* rawValues = flatVector->rawValues<uint64_t*>();
+  ScratchPtr<uint64_t, 4> bitsHolder(scratch);
+  uint64_t* valueBits;
+  int32_t numValueBits;
+  if (!flatVector->mayHaveNulls()) {
+    stream->appendNonNull(rows.size());
+    valueBits = bitsHolder.get(bits::nwords(rows.size()));
+    simd::gatherBits(
+        reinterpret_cast<const uint64_t*>(rawValues), rows, valueBits);
+    numValueBits = rows.size();
   } else {
-    for (int32_t i = 0; i < ranges.size(); ++i) {
-      *(sizes[i]) += ranges[i].size * valueSize;
+    uint64_t* nulls = bitsHolder.get(bits::nwords(rows.size()));
+    simd::gatherBits(vector->rawNulls(), rows, nulls);
+    ScratchPtr<vector_size_t, 64> nonNullsHolder(scratch);
+    auto* nonNulls = nonNullsHolder.get(rows.size());
+    numValueBits = simd::indicesOfSetBits(nulls, 0, rows.size(), nonNulls);
+    stream->appendNulls(nulls, 0, rows.size(), numValueBits);
+    valueBits = nulls;
+    simd::transpose(
+        rows.data(),
+        folly::Range<const vector_size_t*>(nonNulls, numValueBits),
+        nonNulls);
+    simd::gatherBits(
+        reinterpret_cast<const uint64_t*>(rawValues),
+        folly::Range<const vector_size_t*>(nonNulls, numValueBits),
+        valueBits);
+  }
+
+  // 'valueBits' contains the non-null bools to be appended to the
+  // stream. The wire format has a byte for each bit. Every full byte
+  // is appended as a word. The partial byte is translated to a word
+  // and its low bytes are appended.
+  AppendWindow<uint8_t> window(stream->values(), scratch);
+  uint8_t* output = window.get(numValueBits);
+  const auto numBytes = bits::nbytes(numValueBits);
+  for (auto i = 0; i < numBytes; ++i) {
+    uint64_t word = bitsToBytes(reinterpret_cast<uint8_t*>(valueBits)[i]);
+    if (i < numBytes - 1) {
+      reinterpret_cast<uint64_t*>(output)[i] = word;
+    } else {
+      memcpy(output + i * 8, &word, numValueBits - i * 8);
     }
   }
 }
 
-void estimateFlatSerializedSizeVarcharOrVarbinary(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
-  auto strings = static_cast<const FlatVector<StringView>*>(vector);
-  auto rawNulls = strings->rawNulls();
-  auto rawValues = strings->rawValues();
-  for (int32_t i = 0; i < ranges.size(); ++i) {
-    auto end = ranges[i].begin + ranges[i].size;
-    int32_t numNulls = 0;
-    int32_t bytes = 0;
-    for (int32_t offset = ranges[i].begin; offset < end; ++offset) {
-      if (rawNulls && bits::isBitNull(rawNulls, offset)) {
-        ++numNulls;
-      } else {
-        bytes += sizeof(int32_t) + rawValues[offset].size();
+void serializeWrapped(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  ScratchPtr<vector_size_t, 1> innerRowsHolder(scratch);
+  const int32_t numRows = rows.size();
+  int32_t numInner = 0;
+  auto* innerRows = innerRowsHolder.get(numRows);
+  bool mayHaveNulls = vector->mayHaveNulls();
+  VectorPtr wrapped;
+  if (vector->encoding() == VectorEncoding::Simple::DICTIONARY &&
+      !mayHaveNulls) {
+    // Dictionary with no nulls.
+    auto* indices = vector->wrapInfo()->as<vector_size_t>();
+    wrapped = vector->valueVector();
+    simd::transpose(indices, rows, innerRows);
+    numInner = numRows;
+  } else {
+    wrapped = BaseVector::wrappedVectorShared(vector);
+    for (int32_t i = 0; i < rows.size(); ++i) {
+      if (mayHaveNulls && vector->isNullAt(rows[i])) {
+        // The wrapper added a null.
+        if (numInner > 0) {
+          serializeColumn(
+              wrapped,
+              folly::Range<const vector_size_t*>(innerRows, numInner),
+              stream,
+              scratch);
+          numInner = 0;
+        }
+        stream->appendNull();
+        continue;
       }
+      innerRows[numInner++] = vector->wrappedIndex(rows[i]);
     }
-    *(sizes[i]) += bytes + bits::nbytes(numNulls) + 4 * numNulls;
+  }
+
+  if (numInner > 0) {
+    serializeColumn(
+        wrapped,
+        folly::Range<const vector_size_t*>(innerRows, numInner),
+        stream,
+        scratch);
   }
 }
 
 template <>
-void estimateFlatSerializedSize<TypeKind::VARCHAR>(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
-  estimateFlatSerializedSizeVarcharOrVarbinary(vector, ranges, sizes);
+void serializeFlatVector<TypeKind::UNKNOWN>(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  VELOX_CHECK_NOT_NULL(vector->rawNulls());
+  for (auto i = 0; i < rows.size(); ++i) {
+    VELOX_DCHECK(vector->isNullAt(rows[i]));
+    stream->appendNull();
+  }
 }
 
 template <>
-void estimateFlatSerializedSize<TypeKind::VARBINARY>(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
-  estimateFlatSerializedSizeVarcharOrVarbinary(vector, ranges, sizes);
+void serializeFlatVector<TypeKind::OPAQUE>(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& ranges,
+    VectorStream* stream,
+    Scratch& scratch) {
+  VELOX_UNSUPPORTED();
 }
 
-void estimateBiasedSerializedSize(
-    const BaseVector* vector,
-    const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
-  auto valueSize = vector->type()->cppSizeInBytes();
-  if (vector->mayHaveNulls()) {
-    auto rawNulls = vector->rawNulls();
-    for (int32_t i = 0; i < ranges.size(); ++i) {
-      auto end = ranges[i].begin + ranges[i].size;
-      int32_t numNulls = 0;
-      int32_t bytes = 0;
-      for (int32_t offset = ranges[i].begin; offset < end; ++offset) {
-        if (bits::isBitNull(rawNulls, offset)) {
-          ++numNulls;
-        } else {
-          bytes += valueSize;
-        }
+void serializeRowVector(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  auto rowVector = vector->as<RowVector>();
+  ScratchPtr<uint64_t, 4> nullsHolder(scratch);
+  ScratchPtr<vector_size_t, 64> innerRowsHolder(scratch);
+  auto innerRows = rows.data();
+  auto numInnerRows = rows.size();
+  if (auto rawNulls = vector->rawNulls()) {
+    auto nulls = nullsHolder.get(bits::nwords(rows.size()));
+    simd::gatherBits(rawNulls, rows, nulls);
+    auto* mutableInnerRows = innerRowsHolder.get(rows.size());
+    numInnerRows =
+        simd::indicesOfSetBits(nulls, 0, rows.size(), mutableInnerRows);
+    stream->appendLengths(nulls, rows, numInnerRows, [](int32_t) { return 1; });
+    simd::transpose(
+        rows.data(),
+        folly::Range<const vector_size_t*>(mutableInnerRows, numInnerRows),
+        mutableInnerRows);
+    innerRows = mutableInnerRows;
+  } else {
+    stream->appendLengths(
+        nullptr, rows, rows.size(), [](int32_t) { return 1; });
+  }
+  for (int32_t i = 0; i < rowVector->childrenSize(); ++i) {
+    serializeColumn(
+        rowVector->childAt(i),
+        folly::Range<const vector_size_t*>(innerRows, numInnerRows),
+        stream->childAt(i),
+        scratch);
+  }
+}
+
+void serializeArrayVector(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  auto arrayVector = vector->as<ArrayVector>();
+
+  ScratchPtr<IndexRange> rangesHolder(scratch);
+  int32_t numRanges = rowsToRanges(
+      rows,
+      arrayVector->rawNulls(),
+      arrayVector->rawOffsets(),
+      arrayVector->rawSizes(),
+      nullptr,
+      rangesHolder,
+      nullptr,
+      stream,
+      scratch);
+  if (numRanges == 0) {
+    return;
+  }
+  serializeColumn(
+      arrayVector->elements(),
+      folly::Range<const IndexRange*>(rangesHolder.get(), numRanges),
+      stream->childAt(0),
+      scratch);
+}
+
+void serializeMapVector(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  auto mapVector = vector->as<MapVector>();
+
+  ScratchPtr<IndexRange> rangesHolder(scratch);
+  int32_t numRanges = rowsToRanges(
+      rows,
+      mapVector->rawNulls(),
+      mapVector->rawOffsets(),
+      mapVector->rawSizes(),
+      nullptr,
+      rangesHolder,
+      nullptr,
+      stream,
+      scratch);
+  if (numRanges == 0) {
+    return;
+  }
+  serializeColumn(
+      mapVector->mapKeys(),
+      folly::Range<const IndexRange*>(rangesHolder.get(), numRanges),
+      stream->childAt(0),
+      scratch);
+  serializeColumn(
+      mapVector->mapValues(),
+      folly::Range<const IndexRange*>(rangesHolder.get(), numRanges),
+      stream->childAt(1),
+      scratch);
+}
+
+template <TypeKind kind>
+void serializeConstantVector(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  using T = typename KindToFlatVector<kind>::WrapperType;
+  auto constVector = vector->as<ConstantVector<T>>();
+  if (constVector->valueVector()) {
+    serializeWrapped(vector, rows, stream, scratch);
+    return;
+  }
+  const auto numRows = rows.size();
+  if (vector->isNullAt(0)) {
+    for (int32_t i = 0; i < numRows; ++i) {
+      stream->appendNull();
+    }
+    return;
+  }
+
+  T value = constVector->valueAtFast(0);
+  for (int32_t i = 0; i < numRows; ++i) {
+    stream->appendNonNull();
+    stream->appendOne(value);
+  }
+}
+
+template <typename T>
+void serializeBiasVector(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  VELOX_UNSUPPORTED();
+}
+
+void serializeColumn(
+    const VectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    VectorStream* stream,
+    Scratch& scratch) {
+  switch (vector->encoding()) {
+    case VectorEncoding::Simple::FLAT:
+      VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+          serializeFlatVector,
+          vector->typeKind(),
+          vector,
+          rows,
+          stream,
+          scratch);
+      break;
+    case VectorEncoding::Simple::CONSTANT:
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+          serializeConstantVector,
+          vector->typeKind(),
+          vector,
+          rows,
+          stream,
+          scratch);
+      break;
+    case VectorEncoding::Simple::BIASED:
+      VELOX_UNSUPPORTED();
+    case VectorEncoding::Simple::ROW:
+      serializeRowVector(vector, rows, stream, scratch);
+      break;
+    case VectorEncoding::Simple::ARRAY:
+      serializeArrayVector(vector, rows, stream, scratch);
+      break;
+    case VectorEncoding::Simple::MAP:
+      serializeMapVector(vector, rows, stream, scratch);
+      break;
+    case VectorEncoding::Simple::LAZY:
+      serializeColumn(
+          BaseVector::loadedVectorShared(vector), rows, stream, scratch);
+      break;
+    default:
+      serializeWrapped(vector, rows, stream, scratch);
+  }
+}
+
+void expandRepeatedRanges(
+    const BaseVector* vector,
+    const vector_size_t* rawOffsets,
+    const vector_size_t* rawSizes,
+    const folly::Range<const IndexRange*>& ranges,
+    vector_size_t** sizes,
+    std::vector<IndexRange>* childRanges,
+    std::vector<vector_size_t*>* childSizes) {
+  for (int32_t i = 0; i < ranges.size(); ++i) {
+    int32_t begin = ranges[i].begin;
+    int32_t end = begin + ranges[i].size;
+    bool hasNull = false;
+    for (int32_t offset = begin; offset < end; ++offset) {
+      if (vector->isNullAt(offset)) {
+        hasNull = true;
+      } else {
+        // Add the size of the length.
+        *sizes[i] += sizeof(int32_t);
+        childRanges->push_back(
+            IndexRange{rawOffsets[offset], rawSizes[offset]});
+        childSizes->push_back(sizes[i]);
+      }
+    }
+
+    if (hasNull) {
+      // Add the size of the null bit mask.
+      *sizes[i] += bits::nbytes(ranges[i].size);
+    }
+  }
+}
+
+template <TypeKind Kind>
+void estimateFlatSerializedSize(
+    const BaseVector* vector,
+    const folly::Range<const IndexRange*>& ranges,
+    vector_size_t** sizes) {
+  auto valueSize = vector->type()->cppSizeInBytes();
+  if (vector->mayHaveNulls()) {
+    auto rawNulls = vector->rawNulls();
+    for (int32_t i = 0; i < ranges.size(); ++i) {
+      auto end = ranges[i].begin + ranges[i].size;
+      auto numValues = bits::countBits(rawNulls, ranges[i].begin, end);
+      // Add the size of the values.
+      *(sizes[i]) += numValues * valueSize;
+      // Add the size of the null bit mask if there are nulls in the range.
+      if (numValues != ranges[i].size) {
+        *(sizes[i]) += bits::nbytes(ranges[i].size);
+      }
+    }
+  } else {
+    for (int32_t i = 0; i < ranges.size(); ++i) {
+      // Add the size of the values (there's not bit mask since there are no
+      // nulls).
+      *(sizes[i]) += ranges[i].size * valueSize;
+    }
+  }
+}
+
+void estimateFlatSerializedSizeVarcharOrVarbinary(
+    const BaseVector* vector,
+    const folly::Range<const IndexRange*>& ranges,
+    vector_size_t** sizes) {
+  auto strings = static_cast<const FlatVector<StringView>*>(vector);
+  auto rawNulls = strings->rawNulls();
+  auto rawValues = strings->rawValues();
+  for (int32_t i = 0; i < ranges.size(); ++i) {
+    auto end = ranges[i].begin + ranges[i].size;
+    int32_t numNulls = 0;
+    int32_t bytes = 0;
+    for (int32_t offset = ranges[i].begin; offset < end; ++offset) {
+      if (rawNulls && bits::isBitNull(rawNulls, offset)) {
+        ++numNulls;
+      } else {
+        bytes += sizeof(int32_t) + rawValues[offset].size();
       }
-      *(sizes[i]) += bytes + bits::nbytes(numNulls);
+    }
+    *(sizes[i]) += bytes + bits::nbytes(numNulls) + 4 * numNulls;
+  }
+}
+
+template <>
+void estimateFlatSerializedSize<TypeKind::VARCHAR>(
+    const BaseVector* vector,
+    const folly::Range<const IndexRange*>& ranges,
+    vector_size_t** sizes) {
+  estimateFlatSerializedSizeVarcharOrVarbinary(vector, ranges, sizes);
+}
+
+template <>
+void estimateFlatSerializedSize<TypeKind::VARBINARY>(
+    const BaseVector* vector,
+    const folly::Range<const IndexRange*>& ranges,
+    vector_size_t** sizes) {
+  estimateFlatSerializedSizeVarcharOrVarbinary(vector, ranges, sizes);
+}
+
+void estimateBiasedSerializedSize(
+    const BaseVector* vector,
+    const folly::Range<const IndexRange*>& ranges,
+    vector_size_t** sizes) {
+  auto valueSize = vector->type()->cppSizeInBytes();
+  if (vector->mayHaveNulls()) {
+    auto rawNulls = vector->rawNulls();
+    for (int32_t i = 0; i < ranges.size(); ++i) {
+      auto end = ranges[i].begin + ranges[i].size;
+      int32_t numValues = bits::countBits(rawNulls, ranges[i].begin, end);
+      *(sizes[i]) += numValues * valueSize + bits::nbytes(ranges[i].size);
     }
   } else {
     for (int32_t i = 0; i < ranges.size(); ++i) {
@@ -1758,12 +3026,14 @@ void estimateBiasedSerializedSize(
 void estimateSerializedSizeInt(
     const BaseVector* vector,
     const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes);
+    vector_size_t** sizes,
+    Scratch& scratch);
 
 void estimateWrapperSerializedSize(
     const folly::Range<const IndexRange*>& ranges,
     vector_size_t** sizes,
-    const BaseVector* wrapper) {
+    const BaseVector* wrapper,
+    Scratch& scratch) {
   std::vector<IndexRange> newRanges;
   std::vector<vector_size_t*> newSizes;
   const BaseVector* wrapped = wrapper->wrappedVector();
@@ -1780,19 +3050,20 @@ void estimateWrapperSerializedSize(
     }
     *sizes[i] += bits::nbytes(numNulls);
   }
-  estimateSerializedSizeInt(wrapped, newRanges, newSizes.data());
+  estimateSerializedSizeInt(wrapped, newRanges, newSizes.data(), scratch);
 }
 
 template <TypeKind Kind>
-void estimateConstantSerializedSize(
+void estimateFlattenedConstantSerializedSize(
     const BaseVector* vector,
     const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
+    vector_size_t** sizes,
+    Scratch& scratch) {
   VELOX_CHECK(vector->encoding() == VectorEncoding::Simple::CONSTANT);
   using T = typename KindToFlatVector<Kind>::WrapperType;
   auto constantVector = vector->as<ConstantVector<T>>();
   if (constantVector->valueVector()) {
-    estimateWrapperSerializedSize(ranges, sizes, vector);
+    estimateWrapperSerializedSize(ranges, sizes, vector, scratch);
     return;
   }
   int32_t elementSize = sizeof(T);
@@ -1811,7 +3082,8 @@ void estimateConstantSerializedSize(
 void estimateSerializedSizeInt(
     const BaseVector* vector,
     const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
+    vector_size_t** sizes,
+    Scratch& scratch) {
   switch (vector->encoding()) {
     case VectorEncoding::Simple::FLAT:
       VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
@@ -1823,15 +3095,16 @@ void estimateSerializedSizeInt(
       break;
     case VectorEncoding::Simple::CONSTANT:
       VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-          estimateConstantSerializedSize,
+          estimateFlattenedConstantSerializedSize,
           vector->typeKind(),
           vector,
           ranges,
-          sizes);
+          sizes,
+          scratch);
       break;
     case VectorEncoding::Simple::DICTIONARY:
     case VectorEncoding::Simple::SEQUENCE:
-      estimateWrapperSerializedSize(ranges, sizes, vector);
+      estimateWrapperSerializedSize(ranges, sizes, vector, scratch);
       break;
     case VectorEncoding::Simple::BIASED:
       estimateBiasedSerializedSize(vector, ranges, sizes);
@@ -1851,13 +3124,14 @@ void estimateSerializedSizeInt(
         }
       }
       auto rowVector = vector->as<RowVector>();
-      auto children = rowVector->children();
+      auto& children = rowVector->children();
       for (auto& child : children) {
         if (child) {
           estimateSerializedSizeInt(
               child.get(),
               folly::Range(childRanges.data(), childRanges.size()),
-              childSizes.data());
+              childSizes.data(),
+              scratch);
         }
       }
       break;
@@ -1875,9 +3149,12 @@ void estimateSerializedSizeInt(
           &childRanges,
           &childSizes);
       estimateSerializedSizeInt(
-          mapVector->mapKeys().get(), childRanges, childSizes.data());
+          mapVector->mapKeys().get(), childRanges, childSizes.data(), scratch);
       estimateSerializedSizeInt(
-          mapVector->mapValues().get(), childRanges, childSizes.data());
+          mapVector->mapValues().get(),
+          childRanges,
+          childSizes.data(),
+          scratch);
       break;
     }
     case VectorEncoding::Simple::ARRAY: {
@@ -1893,346 +3170,1425 @@ void estimateSerializedSizeInt(
           &childRanges,
           &childSizes);
       estimateSerializedSizeInt(
-          arrayVector->elements().get(), childRanges, childSizes.data());
+          arrayVector->elements().get(),
+          childRanges,
+          childSizes.data(),
+          scratch);
       break;
     }
     case VectorEncoding::Simple::LAZY:
-      estimateSerializedSizeInt(vector->loadedVector(), ranges, sizes);
+      estimateSerializedSizeInt(vector->loadedVector(), ranges, sizes, scratch);
       break;
     default:
       VELOX_CHECK(false, "Unsupported vector encoding {}", vector->encoding());
   }
 }
 
-class PrestoVectorSerializer : public VectorSerializer {
- public:
-  PrestoVectorSerializer(
-      const RowTypePtr& rowType,
-      std::vector<VectorEncoding::Simple> encodings,
-      int32_t numRows,
-      StreamArena* streamArena,
-      bool useLosslessTimestamp,
-      common::CompressionKind compressionKind)
-      : streamArena_(streamArena),
-        codec_(common::compressionKindToCodec(compressionKind)) {
-    auto types = rowType->children();
-    auto numTypes = types.size();
-    streams_.resize(numTypes);
-    for (int i = 0; i < numTypes; i++) {
-      std::optional<VectorEncoding::Simple> encoding = std::nullopt;
-      if (!encodings.empty()) {
-        encoding = encodings[i];
-      }
-      streams_[i] = std::make_unique<VectorStream>(
-          types[i], encoding, streamArena, numRows, useLosslessTimestamp);
-    }
-  }
+void estimateSerializedSizeInt(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    Scratch& scratch);
 
-  void append(
-      const RowVectorPtr& vector,
-      const folly::Range<const IndexRange*>& ranges) override {
-    auto newRows = rangesTotalSize(ranges);
-    if (newRows > 0) {
-      numRows_ += newRows;
-      for (int32_t i = 0; i < vector->childrenSize(); ++i) {
-        serializeColumn(vector->childAt(i).get(), ranges, streams_[i].get());
-      }
+template <TypeKind Kind>
+void estimateFlatSerializedSize(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  const auto valueSize = vector->type()->cppSizeInBytes();
+  const auto numRows = rows.size();
+  if (vector->mayHaveNulls()) {
+    auto rawNulls = vector->rawNulls();
+    ScratchPtr<uint64_t, 4> nullsHolder(scratch);
+    ScratchPtr<int32_t, 64> nonNullsHolder(scratch);
+    auto nulls = nullsHolder.get(bits::nwords(numRows));
+    simd::gatherBits(rawNulls, rows, nulls);
+    auto nonNulls = nonNullsHolder.get(numRows);
+    const auto numNonNull = simd::indicesOfSetBits(nulls, 0, numRows, nonNulls);
+    for (int32_t i = 0; i < numNonNull; ++i) {
+      *sizes[nonNulls[i]] += valueSize;
     }
+  } else {
+    VELOX_UNREACHABLE("Non null fixed width case handled before this");
   }
+}
 
-  void appendEncoded(
-      const RowVectorPtr& vector,
-      const folly::Range<const IndexRange*>& ranges) {
-    auto newRows = rangesTotalSize(ranges);
-    if (newRows > 0) {
-      numRows_ += newRows;
-      for (int32_t i = 0; i < vector->childrenSize(); ++i) {
-        serializeEncodedColumn(
-            vector->childAt(i).get(), ranges, streams_[i].get());
-      }
+void estimateFlatSerializedSizeVarcharOrVarbinary(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  const auto numRows = rows.size();
+  auto strings = static_cast<const FlatVector<StringView>*>(vector);
+  auto rawNulls = strings->rawNulls();
+  auto rawValues = strings->rawValues();
+  if (!rawNulls) {
+    for (auto i = 0; i < rows.size(); ++i) {
+      *sizes[i] += rawValues[rows[i]].size();
     }
-  }
-
-  size_t maxSerializedSize() const override {
-    size_t dataSize = 4; // streams_.size()
-    for (auto& stream : streams_) {
-      dataSize += stream->serializedSize();
+  } else {
+    ScratchPtr<uint64_t, 4> nullsHolder(scratch);
+    ScratchPtr<int32_t, 64> nonNullsHolder(scratch);
+    auto nulls = nullsHolder.get(bits::nwords(numRows));
+    simd::gatherBits(rawNulls, rows, nulls);
+    auto* nonNulls = nonNullsHolder.get(numRows);
+    auto numNonNull = simd::indicesOfSetBits(nulls, 0, numRows, nonNulls);
+
+    for (int32_t i = 0; i < numNonNull; ++i) {
+      *sizes[nonNulls[i]] += rawValues[rows[nonNulls[i]]].size();
     }
-
-    auto compressedSize = needCompression(*codec_)
-        ? codec_->maxCompressedLength(dataSize)
-        : dataSize;
-    return kHeaderSize + compressedSize;
-  }
-
-  // The SerializedPage layout is:
-  // numRows(4) | codec(1) | uncompressedSize(4) | compressedSize(4) |
-  // checksum(8) | data
-  void flush(OutputStream* out) override {
-    flushInternal(numRows_, out);
   }
+}
 
-  void flushEncoded(const RowVectorPtr& vector, OutputStream* out) {
-    VELOX_CHECK_EQ(0, numRows_);
-
-    std::vector<IndexRange> ranges{{0, vector->size()}};
-    appendEncoded(vector, folly::Range(ranges.data(), ranges.size()));
-
-    flushInternal(vector->size(), out);
-  }
-
- private:
-  void flushUncompressed(
-      int32_t numRows,
-      OutputStream* out,
-      PrestoOutputStreamListener* listener) {
-    int32_t offset = out->tellp();
-
-    char codec = 0;
-    if (listener) {
-      codec = getCodecMarker();
-    }
-    // Pause CRC computation
-    if (listener) {
-      listener->pause();
-    }
-
-    writeInt32(out, numRows);
-    out->write(&codec, 1);
-
-    // Make space for uncompressedSizeInBytes & sizeInBytes
-    writeInt32(out, 0);
-    writeInt32(out, 0);
-    // Write zero checksum.
-    writeInt64(out, 0);
-
-    // Number of columns and stream content. Unpause CRC.
-    if (listener) {
-      listener->resume();
-    }
-    writeInt32(out, streams_.size());
+template <>
+void estimateFlatSerializedSize<TypeKind::VARCHAR>(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  estimateFlatSerializedSizeVarcharOrVarbinary(vector, rows, sizes, scratch);
+}
 
-    for (auto& stream : streams_) {
-      stream->flush(out);
-    }
+template <>
+void estimateFlatSerializedSize<TypeKind::VARBINARY>(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  estimateFlatSerializedSizeVarcharOrVarbinary(vector, rows, sizes, scratch);
+}
 
-    // Pause CRC computation
-    if (listener) {
-      listener->pause();
-    }
+void estimateBiasedSerializedSize(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  VELOX_UNSUPPORTED();
+}
 
-    // Fill in uncompressedSizeInBytes & sizeInBytes
-    int32_t size = (int32_t)out->tellp() - offset;
-    int32_t uncompressedSize = size - kHeaderSize;
-    int64_t crc = 0;
-    if (listener) {
-      crc = computeChecksum(listener, codec, numRows, uncompressedSize);
+void estimateWrapperSerializedSize(
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    const BaseVector* wrapper,
+    Scratch& scratch) {
+  ScratchPtr<vector_size_t, 1> innerRowsHolder(scratch);
+  ScratchPtr<vector_size_t*, 1> innerSizesHolder(scratch);
+  const int32_t numRows = rows.size();
+  int32_t numInner = 0;
+  auto innerRows = innerRowsHolder.get(numRows);
+  auto innerSizes = sizes;
+  const BaseVector* wrapped;
+  if (wrapper->encoding() == VectorEncoding::Simple::DICTIONARY &&
+      !wrapper->rawNulls()) {
+    // Dictionary with no nulls.
+    auto* indices = wrapper->wrapInfo()->as<vector_size_t>();
+    wrapped = wrapper->valueVector().get();
+    simd::transpose(indices, rows, innerRows);
+    numInner = numRows;
+  } else {
+    wrapped = wrapper->wrappedVector();
+    innerSizes = innerSizesHolder.get(numRows);
+    for (int32_t i = 0; i < rows.size(); ++i) {
+      if (!wrapper->isNullAt(rows[i])) {
+        innerRows[numInner] = wrapper->wrappedIndex(rows[i]);
+        innerSizes[numInner] = sizes[i];
+        ++numInner;
+      }
     }
-
-    out->seekp(offset + kSizeInBytesOffset);
-    writeInt32(out, uncompressedSize);
-    writeInt32(out, uncompressedSize);
-    writeInt64(out, crc);
-    out->seekp(offset + size);
   }
+  if (numInner == 0) {
+    return;
+  }
+  estimateSerializedSizeInt(
+      wrapped,
+      folly::Range<const vector_size_t*>(innerRows, numInner),
+      innerSizes,
+      scratch);
+}
 
-  void flushCompressed(
-      int32_t numRows,
-      OutputStream* output,
-      PrestoOutputStreamListener* listener) {
-    const int32_t offset = output->tellp();
-    char codec = kCompressedBitMask;
-    if (listener) {
-      codec |= kCheckSumBitMask;
+template <TypeKind Kind>
+void estimateFlattenedConstantSerializedSize(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  VELOX_CHECK(vector->encoding() == VectorEncoding::Simple::CONSTANT);
+  using T = typename KindToFlatVector<Kind>::WrapperType;
+  auto constantVector = vector->as<ConstantVector<T>>();
+  int32_t elementSize = sizeof(T);
+  if (constantVector->isNullAt(0)) {
+    elementSize = 1;
+  } else if (vector->valueVector()) {
+    auto values = constantVector->wrappedVector();
+    vector_size_t* sizePtr = &elementSize;
+    vector_size_t singleRow = constantVector->wrappedIndex(0);
+    estimateSerializedSizeInt(
+        values,
+        folly::Range<const vector_size_t*>(&singleRow, 1),
+        &sizePtr,
+        scratch);
+  } else if (std::is_same_v<T, StringView>) {
+    auto value = constantVector->valueAt(0);
+    auto string = reinterpret_cast<const StringView*>(&value);
+    elementSize = string->size();
+  }
+  for (int32_t i = 0; i < rows.size(); ++i) {
+    *sizes[i] += elementSize;
+  }
+}
+void estimateSerializedSizeInt(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*>& rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  const auto numRows = rows.size();
+  if (vector->type()->isFixedWidth() && !vector->mayHaveNullsRecursive()) {
+    const auto elementSize = vector->type()->cppSizeInBytes();
+    for (auto i = 0; i < numRows; ++i) {
+      *sizes[i] += elementSize;
+    }
+    return;
+  }
+  switch (vector->encoding()) {
+    case VectorEncoding::Simple::FLAT: {
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+          estimateFlatSerializedSize,
+          vector->typeKind(),
+          vector,
+          rows,
+          sizes,
+          scratch);
+      break;
     }
+    case VectorEncoding::Simple::CONSTANT:
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+          estimateFlattenedConstantSerializedSize,
+          vector->typeKind(),
+          vector,
+          rows,
+          sizes,
+          scratch);
+      break;
+    case VectorEncoding::Simple::DICTIONARY:
+    case VectorEncoding::Simple::SEQUENCE:
+      estimateWrapperSerializedSize(rows, sizes, vector, scratch);
+      break;
+    case VectorEncoding::Simple::BIASED:
+      estimateBiasedSerializedSize(vector, rows, sizes, scratch);
+      break;
+    case VectorEncoding::Simple::ROW: {
+      ScratchPtr<vector_size_t, 1> innerRowsHolder(scratch);
+      ScratchPtr<vector_size_t*, 1> innerSizesHolder(scratch);
+      ScratchPtr<uint64_t, 1> nullsHolder(scratch);
+      auto* innerRows = rows.data();
+      auto* innerSizes = sizes;
+      const auto numRows = rows.size();
+      int32_t numInner = numRows;
+      if (vector->mayHaveNulls()) {
+        auto nulls = nullsHolder.get(bits::nwords(numRows));
+        simd::gatherBits(vector->rawNulls(), rows, nulls);
+        auto mutableInnerRows = innerRowsHolder.get(numRows);
+        numInner = simd::indicesOfSetBits(nulls, 0, numRows, mutableInnerRows);
+        innerSizes = innerSizesHolder.get(numInner);
+        for (auto i = 0; i < numInner; ++i) {
+          innerSizes[i] = sizes[mutableInnerRows[i]];
+        }
+        simd::transpose(
+            rows.data(),
+            folly::Range<const vector_size_t*>(mutableInnerRows, numInner),
+            mutableInnerRows);
+        innerRows = mutableInnerRows;
+      }
+      auto rowVector = vector->as<RowVector>();
+      auto& children = rowVector->children();
+      for (auto& child : children) {
+        if (child) {
+          estimateSerializedSizeInt(
+              child.get(),
+              folly::Range(innerRows, numInner),
+              innerSizes,
+              scratch);
+        }
+      }
+      break;
+    }
+    case VectorEncoding::Simple::MAP: {
+      auto mapVector = vector->asUnchecked<MapVector>();
+      ScratchPtr<IndexRange> rangeHolder(scratch);
+      ScratchPtr<vector_size_t*> sizesHolder(scratch);
+      const auto numRanges = rowsToRanges(
+          rows,
+          mapVector->rawNulls(),
+          mapVector->rawOffsets(),
+          mapVector->rawSizes(),
+          sizes,
+          rangeHolder,
+          &sizesHolder,
+          nullptr,
+          scratch);
+      if (numRanges == 0) {
+        return;
+      }
+      estimateSerializedSizeInt(
+          mapVector->mapKeys().get(),
+          folly::Range<const IndexRange*>(rangeHolder.get(), numRanges),
+          sizesHolder.get(),
+          scratch);
+      estimateSerializedSizeInt(
+          mapVector->mapValues().get(),
+          folly::Range<const IndexRange*>(rangeHolder.get(), numRanges),
+          sizesHolder.get(),
+          scratch);
+      break;
+    }
+    case VectorEncoding::Simple::ARRAY: {
+      auto arrayVector = vector->as<ArrayVector>();
+      ScratchPtr<IndexRange> rangeHolder(scratch);
+      ScratchPtr<vector_size_t*> sizesHolder(scratch);
+      const auto numRanges = rowsToRanges(
+          rows,
+          arrayVector->rawNulls(),
+          arrayVector->rawOffsets(),
+          arrayVector->rawSizes(),
+          sizes,
+          rangeHolder,
+          &sizesHolder,
+          nullptr,
+          scratch);
+      if (numRanges == 0) {
+        return;
+      }
+      estimateSerializedSizeInt(
+          arrayVector->elements().get(),
+          folly::Range<const IndexRange*>(rangeHolder.get(), numRanges),
+          sizesHolder.get(),
+          scratch);
+      break;
+    }
+    case VectorEncoding::Simple::LAZY:
+      estimateSerializedSizeInt(vector->loadedVector(), rows, sizes, scratch);
+      break;
+    default:
+      VELOX_CHECK(false, "Unsupported vector encoding {}", vector->encoding());
+  }
+}
+
+int64_t flushUncompressed(
+    const std::vector<std::unique_ptr<VectorStream>>& streams,
+    int32_t numRows,
+    OutputStream* out,
+    PrestoOutputStreamListener* listener) {
+  int32_t offset = out->tellp();
+
+  char codecMask = 0;
+  if (listener) {
+    codecMask = getCodecMarker();
+  }
+  // Pause CRC computation
+  if (listener) {
+    listener->pause();
+  }
+
+  writeInt32(out, numRows);
+  out->write(&codecMask, 1);
+
+  // Make space for uncompressedSizeInBytes & sizeInBytes
+  writeInt32(out, 0);
+  writeInt32(out, 0);
+  // Write zero checksum.
+  writeInt64(out, 0);
+
+  // Number of columns and stream content. Unpause CRC.
+  if (listener) {
+    listener->resume();
+  }
+  writeInt32(out, streams.size());
+
+  for (auto& stream : streams) {
+    stream->flush(out);
+  }
+
+  // Pause CRC computation
+  if (listener) {
+    listener->pause();
+  }
+
+  // Fill in uncompressedSizeInBytes & sizeInBytes
+  int32_t size = (int32_t)out->tellp() - offset;
+  const int32_t uncompressedSize = size - kHeaderSize;
+  int64_t crc = 0;
+  if (listener) {
+    crc = computeChecksum(listener, codecMask, numRows, uncompressedSize);
+  }
+
+  out->seekp(offset + kSizeInBytesOffset);
+  writeInt32(out, uncompressedSize);
+  writeInt32(out, uncompressedSize);
+  writeInt64(out, crc);
+  out->seekp(offset + size);
+  return uncompressedSize;
+}
+namespace {
+// Represents sizes  of a flush. If the sizes are equal, no compression is
+// applied. Otherwise 'compressedSize' must be less than 'uncompressedSize'.
+struct FlushSizes {
+  int64_t uncompressedSize;
+  int64_t compressedSize;
+};
+} // namespace
 
-    // Pause CRC computation
-    if (listener) {
-      listener->pause();
+void flushSerialization(
+    int32_t numRows,
+    int32_t uncompressedSize,
+    int32_t serializationSize,
+    char codecMask,
+    const std::unique_ptr<folly::IOBuf>& iobuf,
+    OutputStream* output,
+    PrestoOutputStreamListener* listener) {
+  output->write(&codecMask, 1);
+  writeInt32(output, uncompressedSize);
+  writeInt32(output, serializationSize);
+  auto crcOffset = output->tellp();
+  // Write zero checksum
+  writeInt64(output, 0);
+  // Number of columns and stream content. Unpause CRC.
+  if (listener) {
+    listener->resume();
+  }
+  for (auto range : *iobuf) {
+    output->write(reinterpret_cast<const char*>(range.data()), range.size());
+  }
+  // Pause CRC computation
+  if (listener) {
+    listener->pause();
+  }
+  const int32_t endSize = output->tellp();
+  // Fill in crc
+  int64_t crc = 0;
+  if (listener) {
+    crc = computeChecksum(listener, codecMask, numRows, uncompressedSize);
+  }
+  output->seekp(crcOffset);
+  writeInt64(output, crc);
+  output->seekp(endSize);
+}
+
+FlushSizes flushCompressed(
+    const std::vector<std::unique_ptr<VectorStream>>& streams,
+    const StreamArena& arena,
+    folly::io::Codec& codec,
+    int32_t numRows,
+    float minCompressionRatio,
+    OutputStream* output,
+    PrestoOutputStreamListener* listener) {
+  char codecMask = kCompressedBitMask;
+  if (listener) {
+    codecMask |= kCheckSumBitMask;
+  }
+
+  // Pause CRC computation
+  if (listener) {
+    listener->pause();
+  }
+
+  writeInt32(output, numRows);
+
+  IOBufOutputStream out(*(arena.pool()), nullptr, arena.size());
+  writeInt32(&out, streams.size());
+
+  for (auto& stream : streams) {
+    stream->flush(&out);
+  }
+
+  const int32_t uncompressedSize = out.tellp();
+  VELOX_CHECK_LE(
+      uncompressedSize,
+      codec.maxUncompressedLength(),
+      "UncompressedSize exceeds limit");
+  auto iobuf = out.getIOBuf();
+  const auto compressedBuffer = codec.compress(iobuf.get());
+  const int32_t compressedSize = compressedBuffer->length();
+  if (compressedSize > uncompressedSize * minCompressionRatio) {
+    flushSerialization(
+        numRows,
+        uncompressedSize,
+        uncompressedSize,
+        codecMask & ~kCompressedBitMask,
+        iobuf,
+        output,
+        listener);
+    return {uncompressedSize, uncompressedSize};
+  }
+  flushSerialization(
+      numRows,
+      uncompressedSize,
+      compressedSize,
+      codecMask,
+      compressedBuffer,
+      output,
+      listener);
+  return {uncompressedSize, compressedSize};
+}
+
+FlushSizes flushStreams(
+    const std::vector<std::unique_ptr<VectorStream>>& streams,
+    int32_t numRows,
+    const StreamArena& arena,
+    folly::io::Codec& codec,
+    float minCompressionRatio,
+    OutputStream* out) {
+  auto listener = dynamic_cast<PrestoOutputStreamListener*>(out->listener());
+  // Reset CRC computation
+  if (listener) {
+    listener->reset();
+  }
+
+  if (!needCompression(codec)) {
+    const auto size = flushUncompressed(streams, numRows, out, listener);
+    return {size, size};
+  } else {
+    return flushCompressed(
+        streams, arena, codec, numRows, minCompressionRatio, out, listener);
+  }
+}
+
+template <TypeKind Kind>
+void estimateConstantSerializedSize(
+    const VectorPtr& vector,
+    const folly::Range<const IndexRange*>& ranges,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  VELOX_CHECK(vector->encoding() == VectorEncoding::Simple::CONSTANT);
+  using T = typename KindToFlatVector<Kind>::WrapperType;
+  auto constantVector = vector->as<ConstantVector<T>>();
+  vector_size_t elementSize = 0;
+  if (constantVector->isNullAt(0)) {
+    // There's just a bit mask for the one null.
+    elementSize = 1;
+  } else if (constantVector->valueVector()) {
+    std::vector<IndexRange> newRanges;
+    newRanges.push_back({constantVector->index(), 1});
+    auto* elementSizePtr = &elementSize;
+    // In PrestoBatchVectorSerializer we don't preserve the encodings for the
+    // valueVector for a ConstantVector.
+    estimateSerializedSizeInt(
+        constantVector->valueVector().get(),
+        newRanges,
+        &elementSizePtr,
+        scratch);
+  } else if (std::is_same_v<T, StringView>) {
+    auto value = constantVector->valueAt(0);
+    auto string = reinterpret_cast<const StringView*>(&value);
+    elementSize = string->size();
+  } else {
+    elementSize = sizeof(T);
+  }
+
+  for (int32_t i = 0; i < ranges.size(); ++i) {
+    *sizes[i] += elementSize;
+  }
+}
+
+template <TypeKind Kind>
+void estimateDictionarySerializedSize(
+    const VectorPtr& vector,
+    const folly::Range<const IndexRange*>& ranges,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  VELOX_CHECK(vector->encoding() == VectorEncoding::Simple::DICTIONARY);
+  using T = typename KindToFlatVector<Kind>::WrapperType;
+  auto dictionaryVector = vector->as<DictionaryVector<T>>();
+
+  // We don't currently support serializing DictionaryVectors with nulls, so use
+  // the flattened size.
+  if (dictionaryVector->nulls()) {
+    estimateWrapperSerializedSize(ranges, sizes, vector.get(), scratch);
+    return;
+  }
+
+  // This will ultimately get passed to simd::transpose, so it needs to be a
+  // raw_vector.
+  raw_vector<vector_size_t> childIndices;
+  std::vector<vector_size_t*> childSizes;
+  for (int rangeIndex = 0; rangeIndex < ranges.size(); rangeIndex++) {
+    ScratchPtr<vector_size_t, 64> selectedIndicesHolder(scratch);
+    auto* mutableSelectedIndices =
+        selectedIndicesHolder.get(dictionaryVector->valueVector()->size());
+    auto numUsed = computeSelectedIndices(
+        dictionaryVector,
+        ranges.subpiece(rangeIndex, 1),
+        scratch,
+        mutableSelectedIndices);
+    for (int i = 0; i < numUsed; i++) {
+      childIndices.push_back(mutableSelectedIndices[i]);
+      childSizes.push_back(sizes[rangeIndex]);
     }
 
-    writeInt32(output, numRows);
-    output->write(&codec, 1);
+    // Add the size of the indices.
+    *sizes[rangeIndex] += sizeof(int32_t) * ranges[rangeIndex].size;
+  }
 
-    IOBufOutputStream out(
-        *(streamArena_->pool()), nullptr, streamArena_->size());
-    writeInt32(&out, streams_.size());
+  // In PrestoBatchVectorSerializer we don't preserve the encodings for the
+  // valueVector for a DictionaryVector.
+  estimateSerializedSizeInt(
+      dictionaryVector->valueVector().get(),
+      childIndices,
+      childSizes.data(),
+      scratch);
+}
 
-    for (auto& stream : streams_) {
-      stream->flush(&out);
+class PrestoBatchVectorSerializer : public BatchVectorSerializer {
+ public:
+  PrestoBatchVectorSerializer(memory::MemoryPool* pool, const SerdeOpts& opts)
+      : pool_(pool),
+        codec_(common::compressionKindToCodec(opts.compressionKind)),
+        opts_(opts) {}
+
+  void serialize(
+      const RowVectorPtr& vector,
+      const folly::Range<const IndexRange*>& ranges,
+      Scratch& scratch,
+      OutputStream* stream) override {
+    const auto numRows = rangesTotalSize(ranges);
+    const auto rowType = vector->type();
+    const auto numChildren = vector->childrenSize();
+
+    StreamArena arena(pool_);
+    std::vector<std::unique_ptr<VectorStream>> streams(numChildren);
+    for (int i = 0; i < numChildren; i++) {
+      streams[i] = std::make_unique<VectorStream>(
+          rowType->childAt(i),
+          std::nullopt,
+          vector->childAt(i),
+          &arena,
+          numRows,
+          opts_);
+
+      if (numRows > 0) {
+        serializeColumn(vector->childAt(i), ranges, streams[i].get(), scratch);
+      }
     }
 
-    const int32_t uncompressedSize = out.tellp();
-    VELOX_CHECK_LE(
-        uncompressedSize,
-        codec_->maxUncompressedLength(),
-        "UncompressedSize exceeds limit");
-    auto compressed = codec_->compress(out.getIOBuf().get());
-    const int32_t compressedSize = compressed->length();
-    writeInt32(output, uncompressedSize);
-    writeInt32(output, compressedSize);
-    const int32_t crcOffset = output->tellp();
-    writeInt64(output, 0); // Write zero checksum
-    // Number of columns and stream content. Unpause CRC.
-    if (listener) {
-      listener->resume();
-    }
-    output->write(
-        reinterpret_cast<const char*>(compressed->writableData()),
-        compressed->length());
-    // Pause CRC computation
-    if (listener) {
-      listener->pause();
-    }
-    const int32_t endSize = output->tellp();
-    // Fill in crc
-    int64_t crc = 0;
-    if (listener) {
-      crc = computeChecksum(listener, codec, numRows, compressedSize);
-    }
-    output->seekp(crcOffset);
-    writeInt64(output, crc);
-    output->seekp(endSize);
-  }
-
-  // Writes the contents to 'stream' in wire format
-  void flushInternal(int32_t numRows, OutputStream* out) {
-    auto listener = dynamic_cast<PrestoOutputStreamListener*>(out->listener());
-    // Reset CRC computation
-    if (listener) {
-      listener->reset();
+    flushStreams(
+        streams, numRows, arena, *codec_, opts_.minCompressionRatio, stream);
+  }
+
+  void estimateSerializedSize(
+      VectorPtr vector,
+      const folly::Range<const IndexRange*>& ranges,
+      vector_size_t** sizes,
+      Scratch& scratch) override {
+    estimateSerializedSizeImpl(vector, ranges, sizes, scratch);
+  }
+
+ private:
+  void estimateSerializedSizeImpl(
+      const VectorPtr& vector,
+      const folly::Range<const IndexRange*>& ranges,
+      vector_size_t** sizes,
+      Scratch& scratch) {
+    switch (vector->encoding()) {
+      case VectorEncoding::Simple::FLAT:
+        VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+            estimateFlatSerializedSize,
+            vector->typeKind(),
+            vector.get(),
+            ranges,
+            sizes);
+        break;
+      case VectorEncoding::Simple::CONSTANT:
+        VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+            estimateConstantSerializedSize,
+            vector->typeKind(),
+            vector,
+            ranges,
+            sizes,
+            scratch);
+        break;
+      case VectorEncoding::Simple::DICTIONARY:
+        VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+            estimateDictionarySerializedSize,
+            vector->typeKind(),
+            vector,
+            ranges,
+            sizes,
+            scratch);
+        break;
+      case VectorEncoding::Simple::ROW: {
+        if (!vector->mayHaveNulls()) {
+          // Add the size of the offsets in the Row encoding.
+          for (int32_t i = 0; i < ranges.size(); ++i) {
+            *sizes[i] += ranges[i].size * sizeof(int32_t);
+          }
+
+          auto rowVector = vector->as<RowVector>();
+          auto& children = rowVector->children();
+          for (auto& child : children) {
+            if (child) {
+              estimateSerializedSizeImpl(child, ranges, sizes, scratch);
+            }
+          }
+
+          break;
+        }
+
+        std::vector<IndexRange> childRanges;
+        std::vector<vector_size_t*> childSizes;
+        for (int32_t i = 0; i < ranges.size(); ++i) {
+          // Add the size of the nulls bit mask.
+          *sizes[i] += bits::nbytes(ranges[i].size);
+
+          auto begin = ranges[i].begin;
+          auto end = begin + ranges[i].size;
+          for (auto offset = begin; offset < end; ++offset) {
+            // Add the size of the offset.
+            *sizes[i] += sizeof(int32_t);
+            if (!vector->isNullAt(offset)) {
+              childRanges.push_back(IndexRange{offset, 1});
+              childSizes.push_back(sizes[i]);
+            }
+          }
+        }
+
+        auto rowVector = vector->as<RowVector>();
+        auto& children = rowVector->children();
+        for (auto& child : children) {
+          if (child) {
+            estimateSerializedSizeImpl(
+                child,
+                folly::Range(childRanges.data(), childRanges.size()),
+                childSizes.data(),
+                scratch);
+          }
+        }
+
+        break;
+      }
+      case VectorEncoding::Simple::MAP: {
+        auto mapVector = vector->as<MapVector>();
+        std::vector<IndexRange> childRanges;
+        std::vector<vector_size_t*> childSizes;
+        expandRepeatedRanges(
+            mapVector,
+            mapVector->rawOffsets(),
+            mapVector->rawSizes(),
+            ranges,
+            sizes,
+            &childRanges,
+            &childSizes);
+        estimateSerializedSizeImpl(
+            mapVector->mapKeys(), childRanges, childSizes.data(), scratch);
+        estimateSerializedSizeImpl(
+            mapVector->mapValues(), childRanges, childSizes.data(), scratch);
+        break;
+      }
+      case VectorEncoding::Simple::ARRAY: {
+        auto arrayVector = vector->as<ArrayVector>();
+        std::vector<IndexRange> childRanges;
+        std::vector<vector_size_t*> childSizes;
+        expandRepeatedRanges(
+            arrayVector,
+            arrayVector->rawOffsets(),
+            arrayVector->rawSizes(),
+            ranges,
+            sizes,
+            &childRanges,
+            &childSizes);
+        estimateSerializedSizeImpl(
+            arrayVector->elements(), childRanges, childSizes.data(), scratch);
+        break;
+      }
+      case VectorEncoding::Simple::LAZY:
+        estimateSerializedSizeImpl(
+            vector->as<LazyVector>()->loadedVectorShared(),
+            ranges,
+            sizes,
+            scratch);
+        break;
+      default:
+        VELOX_CHECK(
+            false, "Unsupported vector encoding {}", vector->encoding());
     }
+  }
 
+  memory::MemoryPool* pool_;
+  const std::unique_ptr<folly::io::Codec> codec_;
+  SerdeOpts opts_;
+};
+
+class PrestoIterativeVectorSerializer : public IterativeVectorSerializer {
+ public:
+  PrestoIterativeVectorSerializer(
+      const RowTypePtr& rowType,
+      int32_t numRows,
+      StreamArena* streamArena,
+      const SerdeOpts& opts)
+      : opts_(opts),
+        streamArena_(streamArena),
+        codec_(common::compressionKindToCodec(opts.compressionKind)) {
+    const auto types = rowType->children();
+    const auto numTypes = types.size();
+    streams_.resize(numTypes);
+
+    for (int i = 0; i < numTypes; ++i) {
+      streams_[i] = std::make_unique<VectorStream>(
+          types[i], std::nullopt, std::nullopt, streamArena, numRows, opts);
+    }
+  }
+
+  void append(
+      const RowVectorPtr& vector,
+      const folly::Range<const IndexRange*>& ranges,
+      Scratch& scratch) override {
+    const auto numNewRows = rangesTotalSize(ranges);
+    if (numNewRows == 0) {
+      return;
+    }
+    numRows_ += numNewRows;
+    for (int32_t i = 0; i < vector->childrenSize(); ++i) {
+      serializeColumn(vector->childAt(i), ranges, streams_[i].get(), scratch);
+    }
+  }
+
+  void append(
+      const RowVectorPtr& vector,
+      const folly::Range<const vector_size_t*>& rows,
+      Scratch& scratch) override {
+    const auto numNewRows = rows.size();
+    if (numNewRows == 0) {
+      return;
+    }
+    numRows_ += numNewRows;
+    for (int32_t i = 0; i < vector->childrenSize(); ++i) {
+      serializeColumn(vector->childAt(i), rows, streams_[i].get(), scratch);
+    }
+  }
+
+  size_t maxSerializedSize() const override {
+    size_t dataSize = 4; // streams_.size()
+    for (auto& stream : streams_) {
+      dataSize += stream->serializedSize();
+    }
+
+    auto compressedSize = needCompression(*codec_)
+        ? codec_->maxCompressedLength(dataSize)
+        : dataSize;
+    return kHeaderSize + compressedSize;
+  }
+
+  // The SerializedPage layout is:
+  // numRows(4) | codec(1) | uncompressedSize(4) | compressedSize(4) |
+  // checksum(8) | data
+  void flush(OutputStream* out) override {
+    constexpr int32_t kMaxCompressionAttemptsToSkip = 30;
     if (!needCompression(*codec_)) {
-      flushUncompressed(numRows, out, listener);
+      flushStreams(
+          streams_,
+          numRows_,
+          *streamArena_,
+          *codec_,
+          opts_.minCompressionRatio,
+          out);
     } else {
-      flushCompressed(numRows, out, listener);
+      if (numCompressionToSkip_ > 0) {
+        const auto noCompressionCodec = common::compressionKindToCodec(
+            common::CompressionKind::CompressionKind_NONE);
+        auto [size, ignore] = flushStreams(
+            streams_, numRows_, *streamArena_, *noCompressionCodec, 1, out);
+        stats_.compressionSkippedBytes += size;
+        --numCompressionToSkip_;
+        ++stats_.numCompressionSkipped;
+      } else {
+        auto [size, compressedSize] = flushStreams(
+            streams_,
+            numRows_,
+            *streamArena_,
+            *codec_,
+            opts_.minCompressionRatio,
+            out);
+        stats_.compressionInputBytes += size;
+        stats_.compressedBytes += compressedSize;
+        if (compressedSize > size * opts_.minCompressionRatio) {
+          numCompressionToSkip_ = std::min<int64_t>(
+              kMaxCompressionAttemptsToSkip, 1 + stats_.numCompressionSkipped);
+        }
+      }
+    }
+  }
+
+  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+    std::unordered_map<std::string, RuntimeCounter> map;
+    map.insert(
+        {{"compressedBytes",
+          RuntimeCounter(stats_.compressedBytes, RuntimeCounter::Unit::kBytes)},
+         {"compressionInputBytes",
+          RuntimeCounter(
+              stats_.compressionInputBytes, RuntimeCounter::Unit::kBytes)},
+         {"compressionSkippedBytes",
+          RuntimeCounter(
+              stats_.compressionSkippedBytes, RuntimeCounter::Unit::kBytes)}});
+    return map;
+  }
+
+  void clear() override {
+    numRows_ = 0;
+    for (auto& stream : streams_) {
+      stream->clear();
     }
   }
 
-  static const int32_t kSizeInBytesOffset{4 + 1};
-  static const int32_t kHeaderSize{kSizeInBytesOffset + 4 + 4 + 8};
+ private:
+  struct CompressionStats {
+    // Number of times compression was not attempted.
+    int32_t numCompressionSkipped{0};
+
+    // uncompressed size for which compression was attempted.
+    int64_t compressionInputBytes{0};
 
+    // Compressed bytes.
+    int64_t compressedBytes{0};
+
+    // Bytes for which compression was not attempted because of past
+    // non-performance.
+    int64_t compressionSkippedBytes{0};
+  };
+
+  const SerdeOpts opts_;
   StreamArena* const streamArena_;
   const std::unique_ptr<folly::io::Codec> codec_;
+
   int32_t numRows_{0};
   std::vector<std::unique_ptr<VectorStream>> streams_;
+
+  // Count of forthcoming compressions to skip.
+  int32_t numCompressionToSkip_{0};
+  CompressionStats stats_;
 };
 } // namespace
 
 void PrestoVectorSerde::estimateSerializedSize(
-    VectorPtr vector,
+    const BaseVector* vector,
     const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
-  estimateSerializedSizeInt(vector->loadedVector(), ranges, sizes);
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  estimateSerializedSizeInt(vector->loadedVector(), ranges, sizes, scratch);
+}
+
+void PrestoVectorSerde::estimateSerializedSize(
+    const BaseVector* vector,
+    const folly::Range<const vector_size_t*> rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  estimateSerializedSizeInt(vector->loadedVector(), rows, sizes, scratch);
 }
 
-std::unique_ptr<VectorSerializer> PrestoVectorSerde::createSerializer(
+std::unique_ptr<IterativeVectorSerializer>
+PrestoVectorSerde::createIterativeSerializer(
     RowTypePtr type,
     int32_t numRows,
     StreamArena* streamArena,
     const Options* options) {
-  auto prestoOptions = toPrestoOptions(options);
-  return std::make_unique<PrestoVectorSerializer>(
-      type,
-      prestoOptions.encodings,
-      numRows,
-      streamArena,
-      prestoOptions.useLosslessTimestamp,
-      prestoOptions.compressionKind);
+  const auto prestoOptions = toPrestoOptions(options);
+  return std::make_unique<PrestoIterativeVectorSerializer>(
+      type, numRows, streamArena, prestoOptions);
 }
 
-void PrestoVectorSerde::serializeEncoded(
-    const RowVectorPtr& vector,
-    StreamArena* streamArena,
-    const Options* options,
-    OutputStream* out) {
-  auto serializer = createSerializer(
-      asRowType(vector->type()), vector->size(), streamArena, options);
+std::unique_ptr<BatchVectorSerializer> PrestoVectorSerde::createBatchSerializer(
+    memory::MemoryPool* pool,
+    const Options* options) {
+  const auto prestoOptions = toPrestoOptions(options);
+  return std::make_unique<PrestoBatchVectorSerializer>(pool, prestoOptions);
+}
 
-  static_cast<PrestoVectorSerializer*>(serializer.get())
-      ->flushEncoded(vector, out);
+namespace {
+bool hasNestedStructs(const TypePtr& type) {
+  if (type->isRow()) {
+    return true;
+  }
+  if (type->isArray()) {
+    return hasNestedStructs(type->childAt(0));
+  }
+  if (type->isMap()) {
+    return hasNestedStructs(type->childAt(0)) ||
+        hasNestedStructs(type->childAt(1));
+  }
+  return false;
+}
+
+bool hasNestedStructs(const std::vector<TypePtr>& types) {
+  for (auto& child : types) {
+    if (hasNestedStructs(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void readTopColumns(
+    ByteInputStream& source,
+    const RowTypePtr& type,
+    velox::memory::MemoryPool* pool,
+    const RowVectorPtr& result,
+    int32_t resultOffset,
+    const SerdeOpts& opts,
+    bool singleColumn = false) {
+  int32_t numColumns = 1;
+  if (!singleColumn) {
+    numColumns = source.read<int32_t>();
+  }
+  auto& children = result->children();
+  const auto& childTypes = type->asRow().children();
+  // Bug for bug compatibility: Extra columns at the end are allowed for
+  // non-compressed data.
+  if (opts.compressionKind == common::CompressionKind_NONE) {
+    VELOX_USER_CHECK_GE(
+        numColumns,
+        type->size(),
+        "Number of columns in serialized data doesn't match "
+        "number of columns requested for deserialization");
+  } else {
+    VELOX_USER_CHECK_EQ(
+        numColumns,
+        type->size(),
+        "Number of columns in serialized data doesn't match "
+        "number of columns requested for deserialization");
+  }
+
+  auto guard = folly::makeGuard([&]() { structNullsMap().reset(); });
+
+  if (!opts.nullsFirst && hasNestedStructs(childTypes)) {
+    structNullsMap() = std::make_unique<StructNullsMap>();
+    Scratch scratch;
+    auto position = source.tellp();
+    readStructNullsColumns(
+        &source, childTypes, opts.useLosslessTimestamp, scratch);
+    source.seekp(position);
+  }
+  readColumns(
+      &source, childTypes, resultOffset, nullptr, 0, pool, opts, children);
 }
+} // namespace
 
 void PrestoVectorSerde::deserialize(
-    ByteStream* source,
+    ByteInputStream* source,
     velox::memory::MemoryPool* pool,
     RowTypePtr type,
-    std::shared_ptr<RowVector>* result,
+    RowVectorPtr* result,
+    vector_size_t resultOffset,
     const Options* options) {
-  auto prestoOptions = toPrestoOptions(options);
-  const bool useLosslessTimestamp = prestoOptions.useLosslessTimestamp;
-  auto codec = common::compressionKindToCodec(prestoOptions.compressionKind);
-  auto numRows = source->read<int32_t>();
+  const auto prestoOptions = toPrestoOptions(options);
+  const auto codec =
+      common::compressionKindToCodec(prestoOptions.compressionKind);
+  auto const header = PrestoHeader::read(source);
 
-  if (*result && result->unique()) {
+  int64_t actualCheckSum = 0;
+  if (isChecksumBitSet(header.pageCodecMarker)) {
+    actualCheckSum = computeChecksum(
+        source,
+        header.pageCodecMarker,
+        header.numRows,
+        header.uncompressedSize,
+        header.compressedSize);
+  }
+
+  VELOX_CHECK_EQ(
+      header.checksum, actualCheckSum, "Received corrupted serialized page.");
+
+  if (resultOffset > 0) {
+    VELOX_CHECK_NOT_NULL(*result);
+    VELOX_CHECK(result->unique());
+    (*result)->resize(resultOffset + header.numRows);
+  } else if (*result && result->unique()) {
     VELOX_CHECK(
         *(*result)->type() == *type,
         "Unexpected type: {} vs. {}",
         (*result)->type()->toString(),
         type->toString());
     (*result)->prepareForReuse();
-    (*result)->resize(numRows);
+    (*result)->resize(header.numRows);
   } else {
-    *result = std::dynamic_pointer_cast<RowVector>(
-        BaseVector::create(type, numRows, pool));
-  }
-
-  auto pageCodecMarker = source->read<int8_t>();
-  auto uncompressedSize = source->read<int32_t>();
-  auto compressedSize = source->read<int32_t>();
-  auto checksum = source->read<int64_t>();
-
-  int64_t actualCheckSum = 0;
-  if (isChecksumBitSet(pageCodecMarker)) {
-    actualCheckSum =
-        computeChecksum(source, pageCodecMarker, numRows, compressedSize);
+    *result = BaseVector::create<RowVector>(type, header.numRows, pool);
   }
 
   VELOX_CHECK_EQ(
-      checksum, actualCheckSum, "Received corrupted serialized page.");
+      header.checksum, actualCheckSum, "Received corrupted serialized page.");
 
-  VELOX_CHECK_EQ(
-      needCompression(*codec),
-      isCompressedBitSet(pageCodecMarker),
-      "Compression kind {} should align with codec marker.",
-      common::compressionKindToString(
-          common::codecTypeToCompressionKind(codec->type())));
-
-  auto& children = (*result)->children();
-  const auto& childTypes = type->asRow().children();
-  if (!needCompression(*codec)) {
-    auto numColumns = source->read<int32_t>();
-    readColumns(source, pool, childTypes, children, useLosslessTimestamp);
+  if (!isCompressedBitSet(header.pageCodecMarker)) {
+    readTopColumns(*source, type, pool, *result, resultOffset, prestoOptions);
   } else {
-    auto compressBuf = folly::IOBuf::create(compressedSize);
-    source->readBytes(compressBuf->writableData(), compressedSize);
-    compressBuf->append(compressedSize);
-    auto uncompress = codec->uncompress(compressBuf.get(), uncompressedSize);
+    auto compressBuf = folly::IOBuf::create(header.compressedSize);
+    source->readBytes(compressBuf->writableData(), header.compressedSize);
+    compressBuf->append(header.compressedSize);
+    auto uncompress =
+        codec->uncompress(compressBuf.get(), header.uncompressedSize);
     ByteRange byteRange{
         uncompress->writableData(), (int32_t)uncompress->length(), 0};
-    ByteStream uncompressedSource;
-    uncompressedSource.resetInput({byteRange});
-    auto numColumns = uncompressedSource.read<int32_t>();
-    VELOX_CHECK_EQ(numColumns, type->as<TypeKind::ROW>().size());
-    readColumns(
-        &uncompressedSource, pool, childTypes, children, useLosslessTimestamp);
+    auto uncompressedSource =
+        std::make_unique<BufferInputStream>(std::vector<ByteRange>{byteRange});
+    readTopColumns(
+        *uncompressedSource, type, pool, *result, resultOffset, prestoOptions);
   }
-  scatterStructNulls((*result)->size(), 0, nullptr, nullptr, **result);
 }
 
-void testingScatterStructNulls(
-    vector_size_t size,
-    vector_size_t scatterSize,
-    const vector_size_t* scatter,
-    const uint64_t* incomingNulls,
-    RowVector& row) {
-  scatterStructNulls(size, scatterSize, scatter, incomingNulls, row);
+void PrestoVectorSerde::deserializeSingleColumn(
+    ByteInputStream* source,
+    velox::memory::MemoryPool* pool,
+    TypePtr type,
+    VectorPtr* result,
+    const Options* options) {
+  const auto prestoOptions = toPrestoOptions(options);
+  VELOX_CHECK_EQ(
+      prestoOptions.compressionKind,
+      common::CompressionKind::CompressionKind_NONE);
+  const bool useLosslessTimestamp = prestoOptions.useLosslessTimestamp;
+
+  if (*result && result->unique()) {
+    VELOX_CHECK(
+        *(*result)->type() == *type,
+        "Unexpected type: {} vs. {}",
+        (*result)->type()->toString(),
+        type->toString());
+    (*result)->prepareForReuse();
+  } else {
+    *result = BaseVector::create(type, 0, pool);
+  }
+
+  auto rowType = ROW({"c0"}, {type});
+  auto row = std::make_shared<RowVector>(
+      pool, rowType, BufferPtr(nullptr), 0, std::vector<VectorPtr>{*result});
+  readTopColumns(*source, rowType, pool, row, 0, prestoOptions, true);
+  *result = row->childAt(0);
 }
 
 // static
 void PrestoVectorSerde::registerVectorSerde() {
+  auto toByte = [](int32_t number, int32_t bit) {
+    return static_cast<uint64_t>(bits::isBitSet(&number, bit)) << (bit * 8);
+  };
+  for (auto i = 0; i < 256; ++i) {
+    bitsToBytesMap[i] = toByte(i, 0) | toByte(i, 1) | toByte(i, 2) |
+        toByte(i, 3) | toByte(i, 4) | toByte(i, 5) | toByte(i, 6) |
+        toByte(i, 7);
+  }
   velox::registerVectorSerde(std::make_unique<PrestoVectorSerde>());
 }
 
+namespace {
+class PrestoVectorLexer {
+ public:
+  using Token = PrestoVectorSerde::Token;
+  using TokenType = PrestoVectorSerde::TokenType;
+
+  explicit PrestoVectorLexer(std::string_view source)
+      : source_(source), committedPtr_(source.begin()) {}
+
+  Status lex(std::vector<Token>& out) && {
+    VELOX_RETURN_NOT_OK(lexHeader());
+
+    int32_t numColumns;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NUM_COLUMNS, &numColumns));
+
+    for (int32_t col = 0; col < numColumns; ++col) {
+      VELOX_RETURN_NOT_OK(lexColumn());
+    }
+
+    VELOX_RETURN_IF(
+        !source_.empty(), Status::Invalid("Source not fully consumed"));
+
+    out = std::move(tokens_);
+    return Status::OK();
+  }
+
+ private:
+  Status lexHeader() {
+    assertCommitted();
+
+    const auto header = PrestoHeader::read(&source_);
+    VELOX_RETURN_IF(
+        !header.has_value(), Status::Invalid("PrestoPage header invalid"));
+    VELOX_RETURN_IF(
+        isCompressedBitSet(header->pageCodecMarker),
+        Status::Invalid("Compression is not supported"));
+    VELOX_RETURN_IF(
+        isEncryptedBitSet(header->pageCodecMarker),
+        Status::Invalid("Encryption is not supported"));
+    VELOX_RETURN_IF(
+        header->uncompressedSize != header->compressedSize,
+        Status::Invalid(
+            "Compressed size must match uncompressed size: {} != {}",
+            header->uncompressedSize,
+            header->compressedSize));
+    VELOX_RETURN_IF(
+        header->uncompressedSize != source_.size(),
+        Status::Invalid(
+            "Uncompressed size does not match content size: {} != {}",
+            header->uncompressedSize,
+            source_.size()));
+
+    commit(TokenType::HEADER);
+
+    return Status::OK();
+  }
+
+  Status lexColumEncoding(std::string& out) {
+    assertCommitted();
+    // Don't use readLengthPrefixedString because it doesn't validate the length
+    int32_t encodingLength;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::COLUMN_ENCODING, &encodingLength));
+    // Control encoding length to avoid large allocations
+    VELOX_RETURN_IF(
+        encodingLength < 0 || encodingLength > 100,
+        Status::Invalid("Invalid column encoding length: {}", encodingLength));
+
+    std::string encoding;
+    encoding.resize(encodingLength);
+    VELOX_RETURN_NOT_OK(
+        lexBytes(encodingLength, TokenType::COLUMN_ENCODING, encoding.data()));
+
+    out = std::move(encoding);
+
+    return Status::OK();
+  }
+
+  Status lexColumn() {
+    std::string encoding;
+    VELOX_RETURN_NOT_OK(lexColumEncoding(encoding));
+
+    if (encoding == kByteArray) {
+      VELOX_RETURN_NOT_OK(lexFixedArray<int8_t>(TokenType::BYTE_ARRAY));
+    } else if (encoding == kShortArray) {
+      VELOX_RETURN_NOT_OK(lexFixedArray<int16_t>(TokenType::SHORT_ARRAY));
+    } else if (encoding == kIntArray) {
+      VELOX_RETURN_NOT_OK(lexFixedArray<int32_t>(TokenType::INT_ARRAY));
+    } else if (encoding == kLongArray) {
+      VELOX_RETURN_NOT_OK(lexFixedArray<int64_t>(TokenType::LONG_ARRAY));
+    } else if (encoding == kInt128Array) {
+      VELOX_RETURN_NOT_OK(lexFixedArray<int128_t>(TokenType::INT128_ARRAY));
+    } else if (encoding == kVariableWidth) {
+      VELOX_RETURN_NOT_OK(lexVariableWidth());
+    } else if (encoding == kArray) {
+      VELOX_RETURN_NOT_OK(lexArray());
+    } else if (encoding == kMap) {
+      VELOX_RETURN_NOT_OK(lexMap());
+    } else if (encoding == kRow) {
+      VELOX_RETURN_NOT_OK(lexRow());
+    } else if (encoding == kDictionary) {
+      VELOX_RETURN_NOT_OK(lexDictionary());
+    } else if (encoding == kRLE) {
+      VELOX_RETURN_NOT_OK(lexRLE());
+    } else {
+      return Status::Invalid("Unknown encoding: {}", encoding);
+    }
+
+    return Status::OK();
+  }
+
+  template <typename T>
+  Status lexFixedArray(TokenType tokenType) {
+    int32_t numRows;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NUM_ROWS, &numRows));
+    VELOX_RETURN_NOT_OK(lexNulls(numRows));
+    const auto numBytes = numRows * sizeof(T);
+    VELOX_RETURN_NOT_OK(lexBytes(numBytes, tokenType));
+    return Status::OK();
+  }
+
+  Status lexVariableWidth() {
+    int32_t numRows;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NUM_ROWS, &numRows));
+    const auto numOffsetBytes = numRows * sizeof(int32_t);
+    VELOX_RETURN_NOT_OK(lexBytes(numOffsetBytes, TokenType::OFFSETS));
+    VELOX_RETURN_NOT_OK(lexNulls(numRows));
+    int32_t dataBytes;
+    VELOX_RETURN_NOT_OK(
+        lexInt(TokenType::VARIABLE_WIDTH_DATA_SIZE, &dataBytes));
+    VELOX_RETURN_NOT_OK(lexBytes(dataBytes, TokenType::VARIABLE_WIDTH_DATA));
+    return Status::OK();
+  }
+
+  Status lexArray() {
+    VELOX_RETURN_NOT_OK(lexColumn());
+    int32_t numRows;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NUM_ROWS, &numRows));
+    const auto offsetBytes = (numRows + 1) * sizeof(int32_t);
+    VELOX_RETURN_NOT_OK(lexBytes(offsetBytes, TokenType::OFFSETS));
+    VELOX_RETURN_NOT_OK(lexNulls(numRows));
+    return Status::OK();
+  }
+
+  Status lexMap() {
+    // Key column
+    VELOX_RETURN_NOT_OK(lexColumn());
+    // Value column
+    VELOX_RETURN_NOT_OK(lexColumn());
+    int32_t hashTableBytes;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::HASH_TABLE_SIZE, &hashTableBytes));
+    if (hashTableBytes != -1) {
+      VELOX_RETURN_NOT_OK(lexBytes(hashTableBytes, TokenType::HASH_TABLE));
+    }
+    int32_t numRows;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NUM_ROWS, &numRows));
+    const auto offsetBytes = (numRows + 1) * sizeof(int32_t);
+    VELOX_RETURN_NOT_OK(lexBytes(offsetBytes, TokenType::OFFSETS));
+    VELOX_RETURN_NOT_OK(lexNulls(numRows));
+    return Status::OK();
+  }
+
+  Status lexRow() {
+    int32_t numFields;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NUM_FIELDS, &numFields));
+    for (int32_t field = 0; field < numFields; ++field) {
+      VELOX_RETURN_NOT_OK(lexColumn());
+    }
+    int32_t numRows;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NUM_ROWS, &numRows));
+    const auto offsetBytes = (numRows + 1) * sizeof(int32_t);
+    VELOX_RETURN_NOT_OK(lexBytes(offsetBytes, TokenType::OFFSETS));
+    VELOX_RETURN_NOT_OK(lexNulls(numRows));
+
+    return Status::OK();
+  }
+
+  Status lexDictionary() {
+    int32_t numRows;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NUM_ROWS, &numRows));
+    // Dictionary column
+    VELOX_RETURN_NOT_OK(lexColumn());
+    const auto indicesBytes = numRows * sizeof(int32_t);
+    VELOX_RETURN_NOT_OK(lexBytes(indicesBytes, TokenType::DICTIONARY_INDICES));
+    // Dictionary ID
+    VELOX_RETURN_NOT_OK(lexBytes(24, TokenType::DICTIONARY_ID));
+    return Status::OK();
+  }
+
+  Status lexRLE() {
+    // Num rows
+    VELOX_RETURN_NOT_OK(lexInt<int32_t>(TokenType::NUM_ROWS));
+    // RLE length one column
+    VELOX_RETURN_NOT_OK(lexColumn());
+    return Status::OK();
+  }
+
+  Status lexNulls(int32_t& numRows) {
+    assertCommitted();
+    VELOX_RETURN_IF(
+        numRows < 0, Status::Invalid("Negative num rows: {}", numRows));
+
+    int8_t hasNulls;
+    VELOX_RETURN_NOT_OK(lexInt(TokenType::NULLS, &hasNulls));
+    if (hasNulls != 0) {
+      const auto numBytes = bits::nbytes(numRows);
+      VELOX_RETURN_IF(
+          numBytes > source_.size(),
+          Status::Invalid(
+              "More rows than bytes in source: {} > {}",
+              numRows,
+              source_.size()));
+      if (nullsBuffer_.size() < numBytes) {
+        constexpr auto eltBytes = sizeof(nullsBuffer_[0]);
+        nullsBuffer_.resize(bits::roundUp(numBytes, eltBytes) / eltBytes);
+      }
+      auto* nulls = nullsBuffer_.data();
+      VELOX_RETURN_NOT_OK(
+          lexBytes(numBytes, TokenType::NULLS, reinterpret_cast<char*>(nulls)));
+
+      bits::reverseBits(reinterpret_cast<uint8_t*>(nulls), numBytes);
+      const auto numNulls = bits::countBits(nulls, 0, numRows);
+
+      numRows -= numNulls;
+    }
+    commit(TokenType::NULLS);
+    return Status::OK();
+  }
+
+  Status lexBytes(int32_t numBytes, TokenType tokenType, char* dst = nullptr) {
+    assertCommitted();
+    VELOX_RETURN_IF(
+        numBytes < 0,
+        Status::Invalid("Attempting to read negative numBytes: {}", numBytes));
+    VELOX_RETURN_IF(
+        numBytes > source_.size(),
+        Status::Invalid(
+            "Attempting to read more bytes than in source: {} > {}",
+            numBytes,
+            source_.size()));
+    if (dst != nullptr) {
+      std::copy(source_.begin(), source_.begin() + numBytes, dst);
+    }
+    source_.remove_prefix(numBytes);
+    commit(tokenType);
+    return Status::OK();
+  }
+
+  template <typename T>
+  Status lexInt(TokenType tokenType, T* out = nullptr) {
+    assertCommitted();
+    VELOX_RETURN_IF(
+        source_.size() < sizeof(T),
+        Status::Invalid(
+            "Source size less than int size: {} < {}",
+            source_.size(),
+            sizeof(T)));
+    const auto value = readInt<T>(&source_);
+    if (out != nullptr) {
+      *out = value;
+    }
+    commit(tokenType);
+    return Status::OK();
+  }
+
+  void assertCommitted() const {
+    assert(committedPtr_ == source_.begin());
+  }
+
+  void commit(TokenType tokenType) {
+    const auto newPtr = source_.begin();
+    assert(committedPtr_ <= newPtr);
+    assert(
+        int64_t(newPtr - committedPtr_) <=
+        int64_t(std::numeric_limits<uint32_t>::max()));
+    if (newPtr != committedPtr_) {
+      const uint32_t length = uint32_t(newPtr - committedPtr_);
+      if (!tokens_.empty() && tokens_.back().tokenType == tokenType) {
+        tokens_.back().length += length;
+      } else {
+        PrestoVectorSerde::Token token;
+        token.tokenType = tokenType;
+        token.length = length;
+        tokens_.push_back(token);
+      }
+    }
+    committedPtr_ = newPtr;
+  }
+
+  std::string_view source_;
+  const char* committedPtr_;
+  std::vector<uint64_t> nullsBuffer_;
+  std::vector<Token> tokens_;
+};
+} // namespace
+
+/* static */ Status PrestoVectorSerde::lex(
+    std::string_view source,
+    std::vector<Token>& out,
+    const Options* options) {
+  const auto prestoOptions = toPrestoOptions(options);
+
+  VELOX_RETURN_IF(
+      prestoOptions.useLosslessTimestamp,
+      Status::Invalid(
+          "Lossless timestamps are not supported, because they cannot be decoded without the Schema"));
+  VELOX_RETURN_IF(
+      prestoOptions.compressionKind !=
+          common::CompressionKind::CompressionKind_NONE,
+      Status::Invalid("Compression is not supported"));
+  VELOX_RETURN_IF(
+      prestoOptions.nullsFirst,
+      Status::Invalid(
+          "Nulls first encoding is not currently supported, but support can be added if needed"));
+
+  return PrestoVectorLexer(source).lex(out);
+}
+
 } // namespace facebook::velox::serializer::presto
diff --git a/velox/serializers/PrestoSerializer.h b/velox/serializers/PrestoSerializer.h
index 24d6d9df5cd70..6bd323568d116 100644
--- a/velox/serializers/PrestoSerializer.h
+++ b/velox/serializers/PrestoSerializer.h
@@ -14,11 +14,33 @@
  * limitations under the License.
  */
 #pragma once
+
+#include <string_view>
+
 #include "velox/common/base/Crc.h"
 #include "velox/common/compression/Compression.h"
 #include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::serializer::presto {
+
+/// There are two ways to serialize data using PrestoVectorSerde:
+///
+/// 1. In order to append multiple RowVectors into the same serialized payload,
+/// one can first create an IterativeVectorSerializer using
+/// createIterativeSerializer(), then append successive RowVectors using
+/// IterativeVectorSerializer::append(). In this case, since different RowVector
+/// might encode columns differently, data is always flattened in the serialized
+/// payload.
+///
+/// Note that there are two flavors of append(), one that takes a range of rows,
+/// and one that takes a list of row ids. The former is useful when serializing
+/// large sections of the input vector (or the full vector); the latter is
+/// efficient for a selective subset, e.g. when splitting a vector to a large
+/// number of output shuffle destinations.
+///
+/// 2. To serialize a single RowVector, one can use the BatchVectorSerializer
+/// returned by createBatchSerializer(). Since it serializes a single RowVector,
+/// it tries to preserve the encodings of the input data.
 class PrestoVectorSerde : public VectorSerde {
  public:
   // Input options that the serializer recognizes.
@@ -27,59 +49,147 @@ class PrestoVectorSerde : public VectorSerde {
 
     PrestoOptions(
         bool _useLosslessTimestamp,
-        common::CompressionKind _compressionKind)
-        : useLosslessTimestamp(_useLosslessTimestamp),
-          compressionKind(_compressionKind) {}
-
-    // Currently presto only supports millisecond precision and the serializer
-    // converts velox native timestamp to that resulting in loss of precision.
-    // This option allows it to serialize with nanosecond precision and is
-    // currently used for spilling. Is false by default.
+        common::CompressionKind _compressionKind,
+        bool _nullsFirst = false)
+        : VectorSerde::Options(_compressionKind),
+          useLosslessTimestamp(_useLosslessTimestamp),
+          nullsFirst(_nullsFirst) {}
+
+    /// Currently presto only supports millisecond precision and the serializer
+    /// converts velox native timestamp to that resulting in loss of precision.
+    /// This option allows it to serialize with nanosecond precision and is
+    /// currently used for spilling. Is false by default.
     bool useLosslessTimestamp{false};
-    common::CompressionKind compressionKind{
-        common::CompressionKind::CompressionKind_NONE};
-    std::vector<VectorEncoding::Simple> encodings;
+
+    /// Serializes nulls of structs before the columns. Used to allow
+    /// single pass reading of in spilling.
+    ///
+    /// TODO: Make Presto also serialize nulls before columns of
+    /// structs.
+    bool nullsFirst{false};
+
+    /// Minimum achieved compression if compression is enabled. Compressing less
+    /// than this causes subsequent compression attempts to be skipped. The more
+    /// times compression misses the target the less frequently it is tried.
+    float minCompressionRatio{0.8};
   };
 
+  /// Adds the serialized sizes of the rows of 'vector' in 'ranges[i]' to
+  /// '*sizes[i]'.
   void estimateSerializedSize(
-      VectorPtr vector,
+      const BaseVector* vector,
       const folly::Range<const IndexRange*>& ranges,
-      vector_size_t** sizes) override;
+      vector_size_t** sizes,
+      Scratch& scratch) override;
 
-  std::unique_ptr<VectorSerializer> createSerializer(
+  void estimateSerializedSize(
+      const BaseVector* vector,
+      const folly::Range<const vector_size_t*> rows,
+      vector_size_t** sizes,
+      Scratch& scratch) override;
+
+  std::unique_ptr<IterativeVectorSerializer> createIterativeSerializer(
       RowTypePtr type,
       int32_t numRows,
       StreamArena* streamArena,
       const Options* options) override;
 
-  /// Serializes a flat RowVector with possibly encoded children. Preserves
-  /// first level of encodings. Dictionary vectors must not have nulls added by
-  /// the dictionary.
-  ///
-  /// Used for testing.
-  void serializeEncoded(
-      const RowVectorPtr& vector,
-      StreamArena* streamArena,
-      const Options* options,
-      OutputStream* out);
+  /// Note that in addition to the differences highlighted in the VectorSerde
+  /// interface, BatchVectorSerializer returned by this function can maintain
+  /// the encodings of the input vectors recursively.
+  std::unique_ptr<BatchVectorSerializer> createBatchSerializer(
+      memory::MemoryPool* pool,
+      const Options* options) override;
+
+  bool supportsAppendInDeserialize() const override {
+    return true;
+  }
+
+  void deserialize(
+      ByteInputStream* source,
+      velox::memory::MemoryPool* pool,
+      RowTypePtr type,
+      RowVectorPtr* result,
+      const Options* options) override {
+    return deserialize(source, pool, type, result, 0, options);
+  }
 
   void deserialize(
-      ByteStream* source,
+      ByteInputStream* source,
       velox::memory::MemoryPool* pool,
       RowTypePtr type,
-      std::shared_ptr<RowVector>* result,
+      RowVectorPtr* result,
+      vector_size_t resultOffset,
       const Options* options) override;
+
+  /// This function is used to deserialize a single column that is serialized in
+  /// PrestoPage format. It is important to note that the PrestoPage format used
+  /// here does not include the Presto page header. Therefore, the 'source'
+  /// should contain uncompressed, serialized binary data, beginning at the
+  /// column header.
+  void deserializeSingleColumn(
+      ByteInputStream* source,
+      velox::memory::MemoryPool* pool,
+      TypePtr type,
+      VectorPtr* result,
+      const Options* options);
+
+  enum class TokenType {
+    HEADER,
+    NUM_COLUMNS,
+    COLUMN_ENCODING,
+    NUM_ROWS,
+    NULLS,
+    BYTE_ARRAY,
+    SHORT_ARRAY,
+    INT_ARRAY,
+    LONG_ARRAY,
+    INT128_ARRAY,
+    VARIABLE_WIDTH_DATA_SIZE,
+    VARIABLE_WIDTH_DATA,
+    DICTIONARY_INDICES,
+    DICTIONARY_ID,
+    HASH_TABLE_SIZE,
+    HASH_TABLE,
+    NUM_FIELDS,
+    OFFSETS,
+  };
+
+  struct Token {
+    TokenType tokenType;
+    uint32_t length;
+  };
+
+  /**
+   * This function lexes the PrestoPage encoded source into tokens so that
+   * Zstrong can parse the PrestoPage without knowledge of the PrestoPage
+   * format. The compressor, which needs to parse presto page, uses this
+   * function to attach meaning to each token in the source. Then the decoder
+   * can simply regnerate the tokens and concatenate, so it is independent of
+   * the PrestoPage format and agnostic to any changes in the format.
+   *
+   * @returns Status::OK() if the @p source successfully parses as a PrestoPage,
+   * and fills @p out with the tokens. Otherwise, returns an error status and
+   * does not modify @p out.
+   *
+   * WARNING: This function does not support compression, encryption, nulls
+   * first, or lossless timestamps and will throw an exception if these features
+   * are enabled.
+   *
+   * NOTE: If this function returns success, the lex is guaranteed to be valid.
+   * However, if the source was not PrestoPage, this function may still return
+   * success, if the source is also interpretable as a PrestoPage. It attempts
+   * to validate as much as possible, to reduce false positives, but provides no
+   * guarantees.
+   */
+  static Status lex(
+      std::string_view source,
+      std::vector<Token>& out,
+      const Options* options = nullptr);
+
   static void registerVectorSerde();
 };
 
-// Testing function for nested encodings. See comments in scatterStructNulls().
-void testingScatterStructNulls(
-    vector_size_t size,
-    vector_size_t scatterSize,
-    const vector_size_t* scatter,
-    const uint64_t* incomingNulls,
-    RowVector& row);
-
 class PrestoOutputStreamListener : public OutputStreamListener {
  public:
   void onWrite(const char* s, std::streamsize count) override {
diff --git a/velox/serializers/UnsafeRowSerializer.cpp b/velox/serializers/UnsafeRowSerializer.cpp
index 184ac73c2d36f..2e5d6e3c8b228 100644
--- a/velox/serializers/UnsafeRowSerializer.cpp
+++ b/velox/serializers/UnsafeRowSerializer.cpp
@@ -21,14 +21,15 @@
 namespace facebook::velox::serializer::spark {
 
 void UnsafeRowVectorSerde::estimateSerializedSize(
-    VectorPtr /* vector */,
+    const BaseVector* /* vector */,
     const folly::Range<const IndexRange*>& /* ranges */,
-    vector_size_t** /* sizes */) {
+    vector_size_t** /* sizes */,
+    Scratch& /*scratch*/) {
   VELOX_UNSUPPORTED();
 }
 
 namespace {
-class UnsafeRowVectorSerializer : public VectorSerializer {
+class UnsafeRowVectorSerializer : public IterativeVectorSerializer {
  public:
   using TRowSize = uint32_t;
 
@@ -37,7 +38,8 @@ class UnsafeRowVectorSerializer : public VectorSerializer {
 
   void append(
       const RowVectorPtr& vector,
-      const folly::Range<const IndexRange*>& ranges) override {
+      const folly::Range<const IndexRange*>& ranges,
+      Scratch& /*scratch*/) override {
     size_t totalSize = 0;
     row::UnsafeRowFast unsafeRow(vector);
     if (auto fixedRowSize =
@@ -92,12 +94,36 @@ class UnsafeRowVectorSerializer : public VectorSerializer {
   }
 
  private:
-  memory::MemoryPool* const FOLLY_NONNULL pool_;
+  memory::MemoryPool* const pool_;
   std::vector<BufferPtr> buffers_;
 };
+
+// Read from the stream until the full row is concatenated.
+std::string concatenatePartialRow(
+    ByteInputStream* source,
+    std::string_view rowFragment,
+    UnsafeRowVectorSerializer::TRowSize rowSize) {
+  std::string rowBuffer;
+  rowBuffer.reserve(rowSize);
+  rowBuffer.append(rowFragment);
+
+  while (rowBuffer.size() < rowSize) {
+    rowFragment = source->nextView(rowSize - rowBuffer.size());
+    VELOX_CHECK_GT(
+        rowFragment.size(),
+        0,
+        "Unable to read full serialized UnsafeRow. Needed {} but read {} bytes.",
+        rowSize - rowBuffer.size(),
+        rowFragment.size());
+    rowBuffer += rowFragment;
+  }
+  return rowBuffer;
+}
+
 } // namespace
 
-std::unique_ptr<VectorSerializer> UnsafeRowVectorSerde::createSerializer(
+std::unique_ptr<IterativeVectorSerializer>
+UnsafeRowVectorSerde::createIterativeSerializer(
     RowTypePtr /* type */,
     int32_t /* numRows */,
     StreamArena* streamArena,
@@ -106,17 +132,27 @@ std::unique_ptr<VectorSerializer> UnsafeRowVectorSerde::createSerializer(
 }
 
 void UnsafeRowVectorSerde::deserialize(
-    ByteStream* source,
+    ByteInputStream* source,
     velox::memory::MemoryPool* pool,
     RowTypePtr type,
     RowVectorPtr* result,
     const Options* /* options */) {
   std::vector<std::optional<std::string_view>> serializedRows;
+  std::vector<std::string> concatenatedRows;
+
   while (!source->atEnd()) {
     // First read row size in big endian order.
     auto rowSize =
         folly::Endian::big(source->read<UnsafeRowVectorSerializer::TRowSize>());
     auto row = source->nextView(rowSize);
+
+    // If we couldn't read the entire row at once, we need to concatenate it
+    // in a different buffer.
+    if (row.size() < rowSize) {
+      concatenatedRows.push_back(concatenatePartialRow(source, row, rowSize));
+      row = concatenatedRows.back();
+    }
+
     VELOX_CHECK_EQ(row.size(), rowSize);
     serializedRows.push_back(row);
   }
diff --git a/velox/serializers/UnsafeRowSerializer.h b/velox/serializers/UnsafeRowSerializer.h
index 810607a88eb5c..1940281537087 100644
--- a/velox/serializers/UnsafeRowSerializer.h
+++ b/velox/serializers/UnsafeRowSerializer.h
@@ -24,13 +24,14 @@ class UnsafeRowVectorSerde : public VectorSerde {
   UnsafeRowVectorSerde() = default;
   // We do not implement this method since it is not used in production code.
   void estimateSerializedSize(
-      VectorPtr vector,
+      const BaseVector* vector,
       const folly::Range<const IndexRange*>& ranges,
-      vector_size_t** sizes) override;
+      vector_size_t** sizes,
+      Scratch& scratch) override;
 
   // This method is not used in production code. It is only used to
   // support round-trip tests for deserialization.
-  std::unique_ptr<VectorSerializer> createSerializer(
+  std::unique_ptr<IterativeVectorSerializer> createIterativeSerializer(
       RowTypePtr type,
       int32_t numRows,
       StreamArena* streamArena,
@@ -38,7 +39,7 @@ class UnsafeRowVectorSerde : public VectorSerde {
 
   // This method is used when reading data from the exchange.
   void deserialize(
-      ByteStream* source,
+      ByteInputStream* source,
       velox::memory::MemoryPool* pool,
       RowTypePtr type,
       RowVectorPtr* result,
diff --git a/velox/serializers/tests/CMakeLists.txt b/velox/serializers/tests/CMakeLists.txt
index 08cddb61f9610..52a0bf715b3e4 100644
--- a/velox/serializers/tests/CMakeLists.txt
+++ b/velox/serializers/tests/CMakeLists.txt
@@ -12,19 +12,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 add_executable(
-  velox_presto_serializer_test
-  PrestoOutputStreamListenerTest.cpp PrestoSerializerTest.cpp
-  UnsafeRowSerializerTest.cpp CompactRowSerializerTest.cpp)
+  velox_serializer_test
+  CompactRowSerializerTest.cpp PrestoOutputStreamListenerTest.cpp
+  PrestoSerializerTest.cpp UnsafeRowSerializerTest.cpp)
 
-add_test(velox_presto_serializer_test velox_presto_serializer_test)
+add_test(velox_serializer_test velox_serializer_test)
 
 target_link_libraries(
-  velox_presto_serializer_test
+  velox_serializer_test
   velox_presto_serializer
   velox_vector_test_lib
   velox_vector_fuzzer
   velox_row_fast
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
+  gflags::gflags
+  glog::glog)
+
+add_executable(velox_serializer_benchmark SerializerBenchmark.cpp)
+
+target_link_libraries(
+  velox_serializer_benchmark
+  velox_presto_serializer
+  velox_vector_test_lib
+  velox_vector_fuzzer
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
diff --git a/velox/serializers/tests/CompactRowSerializerTest.cpp b/velox/serializers/tests/CompactRowSerializerTest.cpp
index da1bc27e1d329..7dc49e83a49cb 100644
--- a/velox/serializers/tests/CompactRowSerializerTest.cpp
+++ b/velox/serializers/tests/CompactRowSerializerTest.cpp
@@ -24,8 +24,12 @@ namespace {
 class CompactRowSerializerTest : public ::testing::Test,
                                  public test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = memory::addDefaultLeafMemoryPool();
+    pool_ = memory::memoryManager()->addLeafPool();
     serde_ = std::make_unique<serializer::CompactRowVectorSerde>();
   }
 
@@ -39,23 +43,35 @@ class CompactRowSerializerTest : public ::testing::Test,
 
     auto arena = std::make_unique<StreamArena>(pool_.get());
     auto rowType = asRowType(rowVector->type());
-    auto serializer = serde_->createSerializer(rowType, numRows, arena.get());
+    auto serializer =
+        serde_->createIterativeSerializer(rowType, numRows, arena.get());
 
-    serializer->append(rowVector, folly::Range(rows.data(), numRows));
+    Scratch scratch;
+    serializer->append(rowVector, folly::Range(rows.data(), numRows), scratch);
     auto size = serializer->maxSerializedSize();
     OStreamOutputStream out(output);
     serializer->flush(&out);
     ASSERT_EQ(size, output->tellp());
   }
 
-  std::unique_ptr<ByteStream> toByteStream(const std::string_view& input) {
-    auto byteStream = std::make_unique<ByteStream>();
-    ByteRange byteRange{
-        reinterpret_cast<uint8_t*>(const_cast<char*>(input.data())),
-        (int32_t)input.length(),
-        0};
-    byteStream->resetInput({byteRange});
-    return byteStream;
+  std::unique_ptr<ByteInputStream> toByteStream(
+      const std::string_view& input,
+      size_t pageSize = 32) {
+    auto rawBytes = reinterpret_cast<uint8_t*>(const_cast<char*>(input.data()));
+    size_t offset = 0;
+    std::vector<ByteRange> ranges;
+
+    // Split the input buffer into many different pages.
+    while (offset < input.length()) {
+      ranges.push_back({
+          rawBytes + offset,
+          std::min<int32_t>(pageSize, input.length() - offset),
+          0,
+      });
+      offset += pageSize;
+    }
+
+    return std::make_unique<BufferInputStream>(std::move(ranges));
   }
 
   RowVectorPtr deserialize(
@@ -102,7 +118,6 @@ TEST_F(CompactRowSerializerTest, fuzz) {
   VectorFuzzer::Options opts;
   opts.vectorSize = 5;
   opts.nullRatio = 0.1;
-  opts.containerHasNulls = false;
   opts.dictionaryHasNulls = false;
   opts.stringVariableLength = true;
   opts.stringLength = 20;
@@ -119,7 +134,7 @@ TEST_F(CompactRowSerializerTest, fuzz) {
   SCOPED_TRACE(fmt::format("seed: {}", seed));
   VectorFuzzer fuzzer(opts, pool_.get(), seed);
 
-  auto data = fuzzer.fuzzRow(rowType);
+  auto data = fuzzer.fuzzInputRow(rowType);
   testRoundTrip(data);
 }
 
diff --git a/velox/serializers/tests/PrestoSerializerTest.cpp b/velox/serializers/tests/PrestoSerializerTest.cpp
index 58d480d8780c9..9f4817a00c76b 100644
--- a/velox/serializers/tests/PrestoSerializerTest.cpp
+++ b/velox/serializers/tests/PrestoSerializerTest.cpp
@@ -19,29 +19,36 @@
 #include <vector>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/ByteStream.h"
+#include "velox/common/time/Timer.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
-#include "velox/vector/BaseVector.h"
-#include "velox/vector/ComplexVector.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::test;
 
+struct SerializeStats {
+  int64_t actualSize{0};
+  int64_t estimatedSize{0};
+};
+
 class PrestoSerializerTest
-    : public ::testing::TestWithParam<common::CompressionKind> {
+    : public ::testing::TestWithParam<common::CompressionKind>,
+      public VectorTestBase {
  protected:
-  static void SetUpTestCase() {
-    serializer::presto::PrestoVectorSerde::registerVectorSerde();
+  static void SetUpTestSuite() {
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    memory::MemoryManager::testingSetInstance({});
   }
 
   void SetUp() override {
-    pool_ = memory::addDefaultLeafMemoryPool();
     serde_ = std::make_unique<serializer::presto::PrestoVectorSerde>();
-    vectorMaker_ = std::make_unique<test::VectorMaker>(pool_.get());
   }
 
   void sanityCheckEstimateSerializedSize(const RowVectorPtr& rowVector) {
+    Scratch scratch;
     const auto numRows = rowVector->size();
 
     std::vector<IndexRange> rows(numRows);
@@ -55,7 +62,10 @@ class PrestoSerializerTest
       rawRowSizes[i] = &rowSizes[i];
     }
     serde_->estimateSerializedSize(
-        rowVector, folly::Range(rows.data(), numRows), rawRowSizes.data());
+        rowVector.get(),
+        folly::Range(rows.data(), numRows),
+        rawRowSizes.data(),
+        scratch);
   }
 
   serializer::presto::PrestoVectorSerde::PrestoOptions getParamSerdeOptions(
@@ -64,46 +74,120 @@ class PrestoSerializerTest
     const bool useLosslessTimestamp =
         serdeOptions == nullptr ? false : serdeOptions->useLosslessTimestamp;
     common::CompressionKind kind = GetParam();
+    const bool nullsFirst =
+        serdeOptions == nullptr ? false : serdeOptions->nullsFirst;
     serializer::presto::PrestoVectorSerde::PrestoOptions paramOptions{
-        useLosslessTimestamp, kind};
+        useLosslessTimestamp, kind, nullsFirst};
+
     return paramOptions;
   }
 
-  void serialize(
+  SerializeStats serialize(
       const RowVectorPtr& rowVector,
       std::ostream* output,
-      const serializer::presto::PrestoVectorSerde::PrestoOptions*
-          serdeOptions) {
+      const serializer::presto::PrestoVectorSerde::PrestoOptions* serdeOptions,
+      std::optional<folly::Range<const IndexRange*>> indexRanges = std::nullopt,
+      std::optional<folly::Range<const vector_size_t*>> rows = std::nullopt,
+      std::unique_ptr<IterativeVectorSerializer>* reuseSerializer = nullptr,
+      std::unique_ptr<StreamArena>* reuseArena = nullptr) {
     auto streamInitialSize = output->tellp();
     sanityCheckEstimateSerializedSize(rowVector);
 
-    auto arena = std::make_unique<StreamArena>(pool_.get());
+    std::unique_ptr<StreamArena> arena;
     auto rowType = asRowType(rowVector->type());
     auto numRows = rowVector->size();
     auto paramOptions = getParamSerdeOptions(serdeOptions);
-    auto serializer =
-        serde_->createSerializer(rowType, numRows, arena.get(), &paramOptions);
-
-    serializer->append(rowVector);
+    std::unique_ptr<IterativeVectorSerializer> serializer;
+    if (reuseSerializer && *reuseSerializer) {
+      arena = std::move(*reuseArena);
+      serializer = std::move(*reuseSerializer);
+      serializer->clear();
+    } else {
+      arena = std::make_unique<StreamArena>(pool_.get());
+      serializer = serde_->createIterativeSerializer(
+          rowType, numRows, arena.get(), &paramOptions);
+    }
+    vector_size_t sizeEstimate = 0;
+
+    Scratch scratch;
+    if (indexRanges.has_value()) {
+      raw_vector<vector_size_t*> sizes(indexRanges.value().size());
+      std::fill(sizes.begin(), sizes.end(), &sizeEstimate);
+      serde_->estimateSerializedSize(
+          rowVector.get(), indexRanges.value(), sizes.data(), scratch);
+      serializer->append(rowVector, indexRanges.value(), scratch);
+    } else if (rows.has_value()) {
+      raw_vector<vector_size_t*> sizes(rows.value().size());
+      std::fill(sizes.begin(), sizes.end(), &sizeEstimate);
+      serde_->estimateSerializedSize(
+          rowVector.get(), rows.value(), sizes.data(), scratch);
+      serializer->append(rowVector, rows.value(), scratch);
+    } else {
+      vector_size_t* sizes = &sizeEstimate;
+      IndexRange range{0, rowVector->size()};
+      serde_->estimateSerializedSize(
+          rowVector.get(),
+          folly::Range<const IndexRange*>(&range, 1),
+          &sizes,
+          scratch);
+      serializer->append(rowVector);
+    }
     auto size = serializer->maxSerializedSize();
+    auto estimatePct = (100.0 * sizeEstimate) / static_cast<float>(size + 1);
+    LOG(INFO) << "Size=" << size << " estimate=" << sizeEstimate << " "
+              << estimatePct << "%";
     facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
     OStreamOutputStream out(output, &listener);
     serializer->flush(&out);
     if (paramOptions.compressionKind == common::CompressionKind_NONE) {
-      ASSERT_EQ(size, out.tellp() - streamInitialSize);
+      EXPECT_EQ(size, out.tellp() - streamInitialSize);
     } else {
-      ASSERT_GE(size, out.tellp() - streamInitialSize);
+      EXPECT_GE(size, out.tellp() - streamInitialSize);
+    }
+    if (reuseSerializer) {
+      *reuseArena = std::move(arena);
+      *reuseSerializer = std::move(serializer);
     }
+    return {static_cast<int64_t>(size), sizeEstimate};
   }
 
-  std::unique_ptr<ByteStream> toByteStream(const std::string& input) {
-    auto byteStream = std::make_unique<ByteStream>();
+  std::unique_ptr<ByteInputStream> toByteStream(const std::string& input) {
     ByteRange byteRange{
         reinterpret_cast<uint8_t*>(const_cast<char*>(input.data())),
         (int32_t)input.length(),
         0};
-    byteStream->resetInput({byteRange});
-    return byteStream;
+    return std::make_unique<BufferInputStream>(
+        std::vector<ByteRange>{{byteRange}});
+  }
+
+  void validateLexer(
+      const std::string& input,
+      const serializer::presto::PrestoVectorSerde::PrestoOptions&
+          paramOptions) {
+    if (paramOptions.useLosslessTimestamp ||
+        paramOptions.compressionKind !=
+            common::CompressionKind::CompressionKind_NONE ||
+        paramOptions.nullsFirst) {
+      // Unsupported options
+      return;
+    }
+    std::vector<serializer::presto::PrestoVectorSerde::Token> tokens;
+    const auto status = serializer::presto::PrestoVectorSerde::lex(
+        input, tokens, &paramOptions);
+    EXPECT_TRUE(status.ok()) << status.message();
+    size_t tokenLengthSum = 0;
+    for (auto const& token : tokens) {
+      tokenLengthSum += token.length;
+    }
+    for (auto const& token : tokens) {
+      // The lexer should not produce empty tokens
+      EXPECT_NE(token.length, 0);
+    }
+    for (size_t i = 1; i < tokens.size(); ++i) {
+      // The lexer should merge consecutive tokens of the same type
+      EXPECT_NE(tokens[i].tokenType, tokens[i - 1].tokenType);
+    }
+    EXPECT_EQ(tokenLengthSum, input.size());
   }
 
   RowVectorPtr deserialize(
@@ -113,77 +197,576 @@ class PrestoSerializerTest
           serdeOptions) {
     auto byteStream = toByteStream(input);
     auto paramOptions = getParamSerdeOptions(serdeOptions);
+    validateLexer(input, paramOptions);
     RowVectorPtr result;
     serde_->deserialize(
-        byteStream.get(), pool_.get(), rowType, &result, &paramOptions);
+        byteStream.get(), pool_.get(), rowType, &result, 0, &paramOptions);
     return result;
   }
 
   RowVectorPtr makeTestVector(vector_size_t size) {
-    auto a = vectorMaker_->flatVector<int64_t>(
-        size, [](vector_size_t row) { return row; });
-    auto b = vectorMaker_->flatVector<double>(
+    auto a =
+        makeFlatVector<int64_t>(size, [](vector_size_t row) { return row; });
+    auto b = makeFlatVector<double>(
         size, [](vector_size_t row) { return row * 0.1; });
-    auto c = vectorMaker_->flatVector<std::string>(size, [](vector_size_t row) {
+    auto c = makeFlatVector<std::string>(size, [](vector_size_t row) {
       return row % 2 == 0 ? "LaaaaaaaaargeString" : "inlineStr";
     });
 
     std::vector<VectorPtr> childVectors = {a, b, c};
 
-    return vectorMaker_->rowVector(childVectors);
+    return makeRowVector(childVectors);
+  }
+
+  RowVectorPtr wrapChildren(const RowVectorPtr& row) {
+    auto children = row->children();
+    std::vector<VectorPtr> newChildren = children;
+    auto indices = makeIndices(row->size(), [](auto row) { return row; });
+    for (auto& child : newChildren) {
+      child = BaseVector::wrapInDictionary(
+          BufferPtr(nullptr), indices, row->size(), child);
+    }
+    return makeRowVector(newChildren);
   }
 
   void testRoundTrip(
       VectorPtr vector,
       const serializer::presto::PrestoVectorSerde::PrestoOptions* serdeOptions =
           nullptr) {
-    auto rowVector = vectorMaker_->rowVector({vector});
+    std::unique_ptr<IterativeVectorSerializer> reuseSerializer;
+    std::unique_ptr<StreamArena> reuseArena;
+    auto rowVector = makeRowVector({vector});
     std::ostringstream out;
-    serialize(rowVector, &out, serdeOptions);
+    serialize(
+        rowVector,
+        &out,
+        serdeOptions,
+        std::nullopt,
+        std::nullopt,
+        &reuseSerializer,
+        &reuseArena);
 
     auto rowType = asRowType(rowVector->type());
     auto deserialized = deserialize(rowType, out.str(), serdeOptions);
     assertEqualVectors(deserialized, rowVector);
+
+    if (rowVector->size() < 3) {
+      return;
+    }
+
+    // Split input into 3 batches. Serialize each separately. Then, deserialize
+    // all into one vector.
+    auto splits = split(rowVector, 3);
+    std::vector<std::string> serialized;
+    for (const auto& split : splits) {
+      std::ostringstream out;
+      serialize(
+          split,
+          &out,
+          serdeOptions,
+          std::nullopt,
+          std::nullopt,
+          &reuseSerializer,
+          &reuseArena);
+      serialized.push_back(out.str());
+    }
+
+    auto paramOptions = getParamSerdeOptions(serdeOptions);
+    RowVectorPtr result;
+    vector_size_t offset = 0;
+    for (auto i = 0; i < serialized.size(); ++i) {
+      auto byteStream = toByteStream(serialized[i]);
+      serde_->deserialize(
+          byteStream.get(),
+          pool_.get(),
+          rowType,
+          &result,
+          offset,
+          &paramOptions);
+      offset = result->size();
+    }
+
+    assertEqualVectors(result, rowVector);
+
+    // Serialize the vector with even and odd rows in different partitions.
+    auto even =
+        makeIndices(rowVector->size() / 2, [&](auto row) { return row * 2; });
+    auto odd = makeIndices(
+        (rowVector->size() - 1) / 2, [&](auto row) { return (row * 2) + 1; });
+    testSerializeRows(
+        rowVector, even, serdeOptions, &reuseSerializer, &reuseArena);
+    auto oddStats = testSerializeRows(
+        rowVector, odd, serdeOptions, &reuseSerializer, &reuseArena);
+    auto wrappedRowVector = wrapChildren(rowVector);
+    auto wrappedStats = testSerializeRows(
+        wrappedRowVector, odd, serdeOptions, &reuseSerializer, &reuseArena);
+    EXPECT_EQ(oddStats.estimatedSize, wrappedStats.estimatedSize);
+    // The second serialization may come out smaller if encoding is better.
+    EXPECT_GE(oddStats.actualSize, wrappedStats.actualSize);
+  }
+
+  void testLexer(
+      VectorPtr vector,
+      const serializer::presto::PrestoVectorSerde::PrestoOptions* serdeOptions =
+          nullptr) {
+    auto rowVector = makeRowVector({vector});
+    std::ostringstream out;
+    serialize(rowVector, &out, serdeOptions);
+    validateLexer(out.str(), getParamSerdeOptions(serdeOptions));
   }
 
-  void serializeEncoded(
+  SerializeStats testSerializeRows(
+      const RowVectorPtr& rowVector,
+      BufferPtr indices,
+      const serializer::presto::PrestoVectorSerde::PrestoOptions* serdeOptions,
+      std::unique_ptr<IterativeVectorSerializer>* reuseSerializer,
+      std::unique_ptr<StreamArena>* reuseArena) {
+    std::ostringstream out;
+    auto rows = folly::Range<const vector_size_t*>(
+        indices->as<vector_size_t>(), indices->size() / sizeof(vector_size_t));
+    auto stats = serialize(
+        rowVector,
+        &out,
+        serdeOptions,
+        std::nullopt,
+        rows,
+        reuseSerializer,
+        reuseArena);
+
+    auto rowType = asRowType(rowVector->type());
+    auto deserialized = deserialize(rowType, out.str(), serdeOptions);
+    assertEqualVectors(
+        deserialized,
+        BaseVector::wrapInDictionary(
+            BufferPtr(nullptr),
+            indices,
+            indices->size() / sizeof(vector_size_t),
+            rowVector));
+    return stats;
+  }
+
+  void assertEqualEncoding(
+      const RowVectorPtr& expected,
+      const RowVectorPtr& actual,
+      // If true, we allow the encodings of actual and expected to differ if a
+      // dictionary was flattened.
+      bool allowFlatteningDictionaries = false) {
+    for (auto i = 0; i < expected->childrenSize(); ++i) {
+      auto expectedEncoding = expected->childAt(i)->encoding();
+      auto actualEncoding = actual->childAt(i)->encoding();
+
+      if (allowFlatteningDictionaries &&
+          actualEncoding == VectorEncoding::Simple::FLAT &&
+          expectedEncoding == VectorEncoding::Simple::DICTIONARY) {
+        continue;
+      }
+
+      VELOX_CHECK_EQ(actualEncoding, expectedEncoding);
+
+      if (expectedEncoding == VectorEncoding::Simple::ROW) {
+        assertEqualEncoding(
+            std::dynamic_pointer_cast<RowVector>(expected->childAt(i)),
+            std::dynamic_pointer_cast<RowVector>(actual->childAt(i)),
+            allowFlatteningDictionaries);
+      }
+    }
+  }
+
+  void verifySerializedEncodedData(
+      const RowVectorPtr& original,
+      const std::string& serialized,
+      bool allowFlatteningDictionaries,
+      const serializer::presto::PrestoVectorSerde::PrestoOptions*
+          serdeOptions) {
+    auto rowType = asRowType(original->type());
+    auto deserialized = deserialize(rowType, serialized, serdeOptions);
+
+    assertEqualVectors(original, deserialized);
+    // Dictionaries may get flattened depending on the nature of the data.
+    assertEqualEncoding(original, deserialized, allowFlatteningDictionaries);
+
+    // Deserialize 3 times while appending to a single vector.
+    auto paramOptions = getParamSerdeOptions(serdeOptions);
+    RowVectorPtr result;
+    vector_size_t offset = 0;
+    for (auto i = 0; i < 3; ++i) {
+      auto byteStream = toByteStream(serialized);
+      serde_->deserialize(
+          byteStream.get(),
+          pool_.get(),
+          rowType,
+          &result,
+          offset,
+          &paramOptions);
+      offset = result->size();
+    }
+
+    auto expected =
+        BaseVector::create(original->type(), original->size() * 3, pool());
+    for (auto i = 0; i < 3; ++i) {
+      expected->copy(original.get(), original->size() * i, 0, original->size());
+    }
+
+    assertEqualVectors(expected, result);
+  }
+
+  void makePermutations(
+      const std::vector<VectorPtr>& vectors,
+      int32_t size,
+      std::vector<VectorPtr>& items,
+      std::vector<std::vector<VectorPtr>>& result) {
+    if (size == items.size()) {
+      result.push_back(items);
+      return;
+    }
+    for (const auto& vector : vectors) {
+      items.push_back(vector);
+      makePermutations(vectors, size, items, result);
+      items.pop_back();
+    }
+  }
+
+  // tests combining encodings in serialization and deserialization. Serializes
+  // each of 'vectors' with encoding, then reads them back into a single vector.
+  void testEncodedConcatenation(
+      std::vector<VectorPtr>& vectors,
+      const serializer::presto::PrestoVectorSerde::PrestoOptions* serdeOptions =
+          nullptr) {
+    std::vector<std::string> pieces;
+    std::vector<std::string> reusedPieces;
+    auto rowType = ROW({{"f", vectors[0]->type()}});
+    auto concatenation = BaseVector::create(rowType, 0, pool_.get());
+    auto arena = std::make_unique<StreamArena>(pool_.get());
+    auto paramOptions = getParamSerdeOptions(serdeOptions);
+    auto serializer = serde_->createIterativeSerializer(
+        rowType, 10, arena.get(), &paramOptions);
+    auto reusedSerializer = serde_->createIterativeSerializer(
+        rowType, 10, arena.get(), &paramOptions);
+
+    facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
+    std::ostringstream allOut;
+    OStreamOutputStream allOutStream(&allOut, &listener);
+    serializer->flush(&allOutStream);
+
+    auto allDeserialized = deserialize(rowType, allOut.str(), &paramOptions);
+    assertEqualVectors(allDeserialized, concatenation);
+    RowVectorPtr deserialized =
+        BaseVector::create<RowVector>(rowType, 0, pool_.get());
+    for (auto pieceIdx = 0; pieceIdx < pieces.size(); ++pieceIdx) {
+      auto piece = pieces[pieceIdx];
+      auto byteStream = toByteStream(piece);
+      serde_->deserialize(
+          byteStream.get(),
+          pool_.get(),
+          rowType,
+          &deserialized,
+          deserialized->size(),
+          &paramOptions);
+
+      RowVectorPtr single =
+          BaseVector::create<RowVector>(rowType, 0, pool_.get());
+      byteStream = toByteStream(piece);
+      serde_->deserialize(
+          byteStream.get(), pool_.get(), rowType, &single, 0, &paramOptions);
+      assertEqualVectors(single->childAt(0), vectors[pieceIdx]);
+
+      RowVectorPtr single2 =
+          BaseVector::create<RowVector>(rowType, 0, pool_.get());
+      byteStream = toByteStream(reusedPieces[pieceIdx]);
+      serde_->deserialize(
+          byteStream.get(), pool_.get(), rowType, &single2, 0, &paramOptions);
+      assertEqualVectors(single2->childAt(0), vectors[pieceIdx]);
+    }
+    assertEqualVectors(concatenation, deserialized);
+  }
+  int64_t randInt(int64_t min, int64_t max) {
+    return min + folly::Random::rand64(rng_) % (max - min);
+  }
+
+  void randomOptions(VectorFuzzer::Options& options, bool isFirst) {
+    options.nullRatio = randInt(1, 10) < 3 ? 0.0 : randInt(1, 10) / 10.0;
+    options.stringLength = randInt(1, 100);
+    options.stringVariableLength = true;
+    options.containerLength = randInt(1, 50);
+    options.containerVariableLength = true;
+    options.complexElementsMaxSize = 20000;
+    options.maxConstantContainerSize = 2;
+    options.normalizeMapKeys = randInt(0, 20) < 16;
+    if (isFirst) {
+      options.timestampPrecision =
+          static_cast<VectorFuzzer::Options::TimestampPrecision>(randInt(0, 3));
+    }
+    options.allowLazyVector = false;
+  }
+
+  void serializeBatch(
       const RowVectorPtr& rowVector,
       std::ostream* output,
       const serializer::presto::PrestoVectorSerde::PrestoOptions*
           serdeOptions) {
     facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
     OStreamOutputStream out(output, &listener);
-    StreamArena arena{pool_.get()};
     auto paramOptions = getParamSerdeOptions(serdeOptions);
 
-    for (const auto& child : rowVector->children()) {
-      paramOptions.encodings.push_back(child->encoding());
-    }
-
-    serde_->serializeEncoded(rowVector, &arena, &paramOptions, &out);
+    auto serializer = serde_->createBatchSerializer(pool_.get(), &paramOptions);
+    serializer->serialize(rowVector, &out);
   }
 
-  void testEncodedRoundTrip(
+  void testBatchVectorSerializerRoundTrip(
       const RowVectorPtr& data,
+      bool allowFlatteningDictionaries = false,
       const serializer::presto::PrestoVectorSerde::PrestoOptions* serdeOptions =
           nullptr) {
     std::ostringstream out;
-    serializeEncoded(data, &out, serdeOptions);
+    serializeBatch(data, &out, serdeOptions);
+    const auto serialized = out.str();
 
-    auto rowType = asRowType(data->type());
-    auto deserialized = deserialize(rowType, out.str(), serdeOptions);
+    verifySerializedEncodedData(
+        data, serialized, allowFlatteningDictionaries, serdeOptions);
+  }
 
-    assertEqualVectors(data, deserialized);
+  RowVectorPtr encodingsTestVector() {
+    // String is variable length, so this ensures the data isn't flattened.
+    auto baseNoNulls = makeFlatVector<std::string>({"a", "b", "c", "d"});
+    auto baseWithNulls =
+        makeNullableFlatVector<std::string>({"a", std::nullopt, "b", "c"});
+    auto baseArray =
+        makeArrayVector<int32_t>({{1, 2, 3}, {}, {4, 5}, {6, 7, 8, 9, 10}});
+    auto indices = makeIndices(8, [](auto row) { return row / 2; });
+
+    return makeRowVector({
+        BaseVector::wrapInDictionary(nullptr, indices, 8, baseNoNulls),
+        BaseVector::wrapInDictionary(nullptr, indices, 8, baseWithNulls),
+        BaseVector::wrapInDictionary(nullptr, indices, 8, baseArray),
+        BaseVector::createConstant(INTEGER(), 123, 8, pool_.get()),
+        BaseVector::createNullConstant(VARCHAR(), 8, pool_.get()),
+        BaseVector::wrapInConstant(8, 1, baseArray),
+        BaseVector::wrapInConstant(8, 2, baseArray),
+        makeRowVector({
+            BaseVector::wrapInDictionary(nullptr, indices, 8, baseNoNulls),
+            BaseVector::wrapInDictionary(nullptr, indices, 8, baseWithNulls),
+            BaseVector::wrapInDictionary(nullptr, indices, 8, baseArray),
+            BaseVector::createConstant(INTEGER(), 123, 8, pool_.get()),
+            BaseVector::createNullConstant(VARCHAR(), 8, pool_.get()),
+            BaseVector::wrapInConstant(8, 1, baseArray),
+            BaseVector::wrapInConstant(8, 2, baseArray),
+            makeRowVector({
+                BaseVector::wrapInDictionary(
+                    nullptr, indices, 8, baseWithNulls),
+                BaseVector::createConstant(INTEGER(), 123, 8, pool_.get()),
+                BaseVector::wrapInConstant(8, 2, baseArray),
+            }),
+        }),
+    });
+  }
 
-    for (auto i = 0; i < data->childrenSize(); ++i) {
-      VELOX_CHECK_EQ(
-          data->childAt(i)->encoding(), deserialized->childAt(i)->encoding());
-    }
+  RowVectorPtr encodingsArrayElementsTestVector() {
+    auto baseNoNulls = makeFlatVector<int64_t>({1, 2, 3, 4});
+    auto baseWithNulls =
+        makeNullableFlatVector<int32_t>({1, std::nullopt, 2, 3});
+    auto baseArray =
+        makeArrayVector<int32_t>({{1, 2, 3}, {}, {4, 5}, {6, 7, 8, 9, 10}});
+    auto elementIndices = makeIndices(16, [](auto row) { return row / 4; });
+    std::vector<vector_size_t> offsets{0, 2, 4, 6, 8, 10, 12, 14, 16};
+
+    return makeRowVector({
+        makeArrayVector(
+            offsets,
+            BaseVector::wrapInDictionary(
+                nullptr, elementIndices, 16, baseNoNulls)),
+        makeArrayVector(
+            offsets,
+            BaseVector::wrapInDictionary(
+                nullptr, elementIndices, 16, baseWithNulls)),
+        makeArrayVector(
+            offsets,
+            BaseVector::wrapInDictionary(
+                nullptr, elementIndices, 16, baseArray)),
+        makeArrayVector(
+            offsets,
+            BaseVector::createConstant(INTEGER(), 123, 16, pool_.get())),
+        makeArrayVector(
+            offsets,
+            BaseVector::createNullConstant(VARCHAR(), 16, pool_.get())),
+        makeArrayVector(offsets, BaseVector::wrapInConstant(16, 1, baseArray)),
+        makeRowVector({
+            makeArrayVector(
+                offsets,
+                BaseVector::wrapInDictionary(
+                    nullptr, elementIndices, 16, baseNoNulls)),
+            makeArrayVector(
+                offsets,
+                BaseVector::wrapInDictionary(
+                    nullptr, elementIndices, 16, baseWithNulls)),
+            makeArrayVector(
+                offsets,
+                BaseVector::wrapInDictionary(
+                    nullptr, elementIndices, 16, baseArray)),
+            makeArrayVector(
+                offsets,
+                BaseVector::createConstant(INTEGER(), 123, 16, pool_.get())),
+            makeArrayVector(
+                offsets,
+                BaseVector::createNullConstant(VARCHAR(), 16, pool_.get())),
+            makeArrayVector(
+                offsets, BaseVector::wrapInConstant(16, 1, baseArray)),
+        }),
+    });
+  }
+
+  RowVectorPtr encodingsMapValuesTestVector() {
+    auto baseNoNulls = makeFlatVector<int64_t>({1, 2, 3, 4});
+    auto baseWithNulls =
+        makeNullableFlatVector<int32_t>({1, std::nullopt, 2, 3});
+    auto baseArray =
+        makeArrayVector<int32_t>({{1, 2, 3}, {}, {4, 5}, {6, 7, 8, 9, 10}});
+    auto valueIndices = makeIndices(16, [](auto row) { return row / 4; });
+    std::vector<vector_size_t> offsets{0, 2, 4, 6, 8, 10, 12, 14, 16};
+    auto mapKeys = makeFlatVector<int32_t>(16, [](auto row) { return row; });
+
+    return makeRowVector({
+        makeMapVector(
+            offsets,
+            mapKeys,
+            BaseVector::wrapInDictionary(
+                nullptr, valueIndices, 16, baseNoNulls)),
+        makeMapVector(
+            offsets,
+            mapKeys,
+            BaseVector::wrapInDictionary(
+                nullptr, valueIndices, 16, baseWithNulls)),
+        makeMapVector(
+            offsets,
+            mapKeys,
+            BaseVector::wrapInDictionary(nullptr, valueIndices, 16, baseArray)),
+        makeMapVector(
+            offsets,
+            mapKeys,
+            BaseVector::createConstant(INTEGER(), 123, 16, pool_.get())),
+        makeMapVector(
+            offsets,
+            mapKeys,
+            BaseVector::createNullConstant(VARCHAR(), 16, pool_.get())),
+        makeMapVector(
+            offsets, mapKeys, BaseVector::wrapInConstant(16, 1, baseArray)),
+        makeRowVector({
+            makeMapVector(
+                offsets,
+                mapKeys,
+                BaseVector::wrapInDictionary(
+                    nullptr, valueIndices, 16, baseNoNulls)),
+            makeMapVector(
+                offsets,
+                mapKeys,
+                BaseVector::wrapInDictionary(
+                    nullptr, valueIndices, 16, baseWithNulls)),
+            makeMapVector(
+                offsets,
+                mapKeys,
+                BaseVector::wrapInDictionary(
+                    nullptr, valueIndices, 16, baseArray)),
+            makeMapVector(
+                offsets,
+                mapKeys,
+                BaseVector::createConstant(INTEGER(), 123, 16, pool_.get())),
+            makeMapVector(
+                offsets,
+                mapKeys,
+                BaseVector::createNullConstant(VARCHAR(), 16, pool_.get())),
+            makeMapVector(
+                offsets, mapKeys, BaseVector::wrapInConstant(16, 1, baseArray)),
+        }),
+    });
+  }
+
+  void testMinimalDictionaryEncoding(
+      vector_size_t numRows,
+      vector_size_t alphabetSize) {
+    // This factor is used to ensure we have some repetition in the dictionary
+    // in each of the cases to ensure the serializer doesn't flatten the data.
+    auto factor = alphabetSize <= numRows ? 2 : alphabetSize / numRows * 2;
+    // String is variable length, so this ensures the data isn't flattened.
+    auto base = makeFlatVector<std::string>(
+        alphabetSize, [](vector_size_t row) { return fmt::format("{}", row); });
+    auto evenIndices = makeIndices(numRows, [alphabetSize, factor](auto row) {
+      return (row * factor) % alphabetSize;
+    });
+    auto oddIndices = makeIndices(numRows, [alphabetSize, factor](auto row) {
+      return (row * factor + 1) % alphabetSize;
+    });
+    auto prefixIndices = makeIndices(numRows, [alphabetSize, factor](auto row) {
+      return row % (alphabetSize / factor);
+    });
+    auto suffixIndices = makeIndices(numRows, [alphabetSize, factor](auto row) {
+      return row % (alphabetSize / factor) +
+          (factor - 1) * (alphabetSize / factor);
+    });
+
+    auto rows = makeRowVector({
+        BaseVector::wrapInDictionary(nullptr, evenIndices, numRows, base),
+        BaseVector::wrapInDictionary(nullptr, oddIndices, numRows, base),
+        BaseVector::wrapInDictionary(nullptr, prefixIndices, numRows, base),
+        BaseVector::wrapInDictionary(nullptr, suffixIndices, numRows, base),
+    });
+
+    std::ostringstream out;
+    serializeBatch(rows, &out, /*serdeOptions=*/nullptr);
+    const auto serialized = out.str();
+
+    auto rowType = asRowType(rows->type());
+    auto deserialized =
+        deserialize(rowType, serialized, /*serdeOptions=*/nullptr);
+
+    assertEqualVectors(rows, deserialized);
+    assertEqualEncoding(rows, deserialized);
+
+    ASSERT_EQ(
+        deserialized->childAt(0)
+            ->as<DictionaryVector<StringView>>()
+            ->valueVector()
+            ->size(),
+        alphabetSize / factor);
+    ASSERT_EQ(
+        deserialized->childAt(1)
+            ->as<DictionaryVector<StringView>>()
+            ->valueVector()
+            ->size(),
+        alphabetSize / factor);
+    ASSERT_EQ(
+        deserialized->childAt(2)
+            ->as<DictionaryVector<StringView>>()
+            ->valueVector()
+            ->size(),
+        alphabetSize / factor);
+    ASSERT_EQ(
+        deserialized->childAt(3)
+            ->as<DictionaryVector<StringView>>()
+            ->valueVector()
+            ->size(),
+        alphabetSize / factor);
+  }
+
+  RowVectorPtr makeEmptyTestVector() {
+    return makeRowVector(
+        {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"},
+        {makeFlatVector<bool>({}),
+         makeFlatVector<int8_t>({}),
+         makeFlatVector<int16_t>({}),
+         makeFlatVector<int32_t>({}),
+         makeFlatVector<int64_t>({}),
+         makeFlatVector<float>({}),
+         makeFlatVector<double>({}),
+         makeFlatVector<StringView>({}),
+         makeFlatVector<Timestamp>({}),
+         makeRowVector(
+             {"1", "2"},
+             {makeFlatVector<StringView>({}), makeFlatVector<int32_t>({})}),
+         makeArrayVector<int32_t>({}),
+         makeMapVector<StringView, int32_t>({})});
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_;
   std::unique_ptr<serializer::presto::PrestoVectorSerde> serde_;
-  std::unique_ptr<test::VectorMaker> vectorMaker_;
+  folly::Random::DefaultGenerator rng_;
 };
 
 TEST_P(PrestoSerializerTest, basic) {
@@ -197,8 +780,7 @@ TEST_P(PrestoSerializerTest, basic) {
 TEST_P(PrestoSerializerTest, dictionaryWithExtraNulls) {
   vector_size_t size = 1'000;
 
-  auto base =
-      vectorMaker_->flatVector<int64_t>(10, [](auto row) { return row; });
+  auto base = makeFlatVector<int64_t>(10, [](auto row) { return row; });
 
   BufferPtr nulls = AlignedBuffer::allocate<bool>(size, pool_.get());
   auto rawNulls = nulls->asMutable<uint64_t>();
@@ -219,7 +801,7 @@ TEST_P(PrestoSerializerTest, dictionaryWithExtraNulls) {
 }
 
 TEST_P(PrestoSerializerTest, emptyPage) {
-  auto rowVector = vectorMaker_->rowVector(ROW({"a"}, {BIGINT()}), 0);
+  auto rowVector = makeEmptyTestVector();
 
   std::ostringstream out;
   serialize(rowVector, &out, nullptr);
@@ -229,8 +811,52 @@ TEST_P(PrestoSerializerTest, emptyPage) {
   assertEqualVectors(deserialized, rowVector);
 }
 
+TEST_P(PrestoSerializerTest, serializeNoRowsSelected) {
+  std::ostringstream out;
+  facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
+  OStreamOutputStream output(&out, &listener);
+  auto paramOptions = getParamSerdeOptions(nullptr);
+  auto arena = std::make_unique<StreamArena>(pool_.get());
+  auto rowVector = makeRowVector(
+      {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"},
+      {makeFlatVector<bool>({true, false, true, false}),
+       makeFlatVector<int8_t>({1, 2, 3, 4}),
+       makeFlatVector<int16_t>({5, 6, 7, 8}),
+       makeFlatVector<int32_t>({9, 10, 11, 12}),
+       makeFlatVector<int64_t>({13, 14, 15, 16}),
+       makeFlatVector<float>({17.0, 18.0, 19.0, 20.0}),
+       makeFlatVector<double>({21.0, 22.0, 23.0, 24.0}),
+       makeFlatVector<StringView>({"25", "26", "27", "28"}),
+       makeFlatVector<Timestamp>({{29, 30}, {32, 32}, {33, 34}, {35, 36}}),
+       makeRowVector(
+           {"1", "2"},
+           {makeFlatVector<StringView>({"37", "38", "39", "40"}),
+            makeFlatVector<int32_t>({41, 42, 43, 44})}),
+       makeArrayVector<int32_t>({{45, 46}, {47, 48}, {49, 50}, {51, 52}}),
+       makeMapVector<StringView, int32_t>(
+           {{{"53", 54}, {"55", 56}},
+            {{"57", 58}, {"59", 60}},
+            {{"61", 62}, {"63", 64}},
+            {{"65", 66}, {"67", 68}}})});
+  const IndexRange noRows{0, 0};
+
+  auto serializer = serde_->createIterativeSerializer(
+      asRowType(rowVector->type()),
+      rowVector->size(),
+      arena.get(),
+      &paramOptions);
+
+  serializer->append(rowVector, folly::Range(&noRows, 1));
+  serializer->flush(&output);
+
+  auto expected = makeEmptyTestVector();
+  auto rowType = asRowType(expected->type());
+  auto deserialized = deserialize(rowType, out.str(), nullptr);
+  assertEqualVectors(deserialized, expected);
+}
+
 TEST_P(PrestoSerializerTest, emptyArray) {
-  auto arrayVector = vectorMaker_->arrayVector<int32_t>(
+  auto arrayVector = makeArrayVector<int32_t>(
       1'000,
       [](vector_size_t row) { return row % 5; },
       [](vector_size_t row) { return row; });
@@ -239,7 +865,7 @@ TEST_P(PrestoSerializerTest, emptyArray) {
 }
 
 TEST_P(PrestoSerializerTest, emptyMap) {
-  auto mapVector = vectorMaker_->mapVector<int32_t, int32_t>(
+  auto mapVector = makeMapVector<int32_t, int32_t>(
       1'000,
       [](vector_size_t row) { return row % 5; },
       [](vector_size_t row) { return row; },
@@ -249,29 +875,23 @@ TEST_P(PrestoSerializerTest, emptyMap) {
 }
 
 TEST_P(PrestoSerializerTest, timestampWithTimeZone) {
-  auto timestamp = vectorMaker_->flatVector<int64_t>(
-      100, [](auto row) { return 10'000 + row; });
-  auto timezone =
-      vectorMaker_->flatVector<int16_t>(100, [](auto row) { return row % 37; });
-
-  auto vector = std::make_shared<RowVector>(
-      pool_.get(),
-      TIMESTAMP_WITH_TIME_ZONE(),
-      BufferPtr(nullptr),
+  auto timestamp = makeFlatVector<int64_t>(
       100,
-      std::vector<VectorPtr>{timestamp, timezone});
+      [](auto row) { return pack(10'000 + row, row % 37); },
+      /* isNullAt */ nullptr,
+      TIMESTAMP_WITH_TIME_ZONE());
 
-  testRoundTrip(vector);
+  testRoundTrip(timestamp);
 
   // Add some nulls.
   for (auto i = 0; i < 100; i += 7) {
-    vector->setNull(i, true);
+    timestamp->setNull(i, true);
   }
-  testRoundTrip(vector);
+  testRoundTrip(timestamp);
 }
 
 TEST_P(PrestoSerializerTest, intervalDayTime) {
-  auto vector = vectorMaker_->flatVector<int64_t>(
+  auto vector = makeFlatVector<int64_t>(
       100,
       [](auto row) { return row + folly::Random::rand32(); },
       nullptr, // nullAt
@@ -287,16 +907,65 @@ TEST_P(PrestoSerializerTest, intervalDayTime) {
 }
 
 TEST_P(PrestoSerializerTest, unknown) {
+  // Verify vectors of UNKNOWN type. Also verifies a special case where a
+  // vector, not of UNKNOWN type and with all nulls is serialized as an UNKNOWN
+  // type having BYTE_ARRAY encoding.
+  auto testAllNullSerializedAsUnknown = [&](VectorPtr vector,
+                                            TypePtr outputType) {
+    auto rowVector = makeRowVector({vector});
+    auto expected = makeRowVector(
+        {BaseVector::createNullConstant(outputType, vector->size(), pool())});
+    std::ostringstream out;
+    serialize(rowVector, &out, nullptr);
+
+    auto rowType = asRowType(expected->type());
+    auto deserialized = deserialize(rowType, out.str(), nullptr);
+    assertEqualVectors(expected, deserialized);
+
+    if (rowVector->size() < 3) {
+      return;
+    }
+
+    // Split input into 3 batches. Serialize each separately. Then, deserialize
+    // all into one vector.
+    auto splits = split(rowVector, 3);
+    std::vector<std::string> serialized;
+    for (const auto& split : splits) {
+      std::ostringstream oss;
+      serialize(split, &oss, nullptr);
+      serialized.push_back(oss.str());
+    }
+
+    auto paramOptions = getParamSerdeOptions(nullptr);
+    RowVectorPtr result;
+    vector_size_t offset = 0;
+    for (auto i = 0; i < serialized.size(); ++i) {
+      auto byteStream = toByteStream(serialized[i]);
+      serde_->deserialize(
+          byteStream.get(),
+          pool_.get(),
+          rowType,
+          &result,
+          offset,
+          &paramOptions);
+      offset = result->size();
+    }
+
+    assertEqualVectors(expected, result);
+  };
+
   const vector_size_t size = 123;
   auto constantVector =
-      BaseVector::createNullConstant(UNKNOWN(), 123, pool_.get());
+      BaseVector::createNullConstant(UNKNOWN(), size, pool_.get());
   testRoundTrip(constantVector);
+  testAllNullSerializedAsUnknown(constantVector, BIGINT());
 
   auto flatVector = BaseVector::create(UNKNOWN(), size, pool_.get());
   for (auto i = 0; i < size; i++) {
     flatVector->setNull(i, true);
   }
   testRoundTrip(flatVector);
+  testAllNullSerializedAsUnknown(flatVector, BIGINT());
 }
 
 TEST_P(PrestoSerializerTest, multiPage) {
@@ -321,7 +990,12 @@ TEST_P(PrestoSerializerTest, multiPage) {
   for (int i = 0; i < testVectors.size(); i++) {
     RowVectorPtr& vec = testVectors[i];
     serde_->deserialize(
-        byteStream.get(), pool_.get(), rowType, &deserialized, &paramOptions);
+        byteStream.get(),
+        pool_.get(),
+        rowType,
+        &deserialized,
+        0,
+        &paramOptions);
     if (i < testVectors.size() - 1) {
       ASSERT_FALSE(byteStream->atEnd());
     } else {
@@ -338,7 +1012,7 @@ TEST_P(PrestoSerializerTest, timestampWithNanosecondPrecision) {
   const serializer::presto::PrestoVectorSerde::PrestoOptions
       kUseLosslessTimestampOptions(
           true, common::CompressionKind::CompressionKind_NONE);
-  auto timestamp = vectorMaker_->flatVector<Timestamp>(
+  auto timestamp = makeFlatVector<Timestamp>(
       {Timestamp{0, 0},
        Timestamp{12, 0},
        Timestamp{0, 17'123'456},
@@ -347,15 +1021,14 @@ TEST_P(PrestoSerializerTest, timestampWithNanosecondPrecision) {
   testRoundTrip(timestamp, &kUseLosslessTimestampOptions);
 
   // Verify that precision is lost when no option is passed to the serde.
-  auto timestampMillis = vectorMaker_->flatVector<Timestamp>(
+  auto timestampMillis = makeFlatVector<Timestamp>(
       {Timestamp{0, 0},
        Timestamp{12, 0},
        Timestamp{0, 17'000'000},
        Timestamp{1, 17'000'000},
        Timestamp{-1, 17'000'000}});
-  auto inputRowVector = vectorMaker_->rowVector({timestamp});
-  auto expectedOutputWithLostPrecision =
-      vectorMaker_->rowVector({timestampMillis});
+  auto inputRowVector = makeRowVector({timestamp});
+  auto expectedOutputWithLostPrecision = makeRowVector({timestampMillis});
   std::ostringstream out;
   serialize(inputRowVector, &out, {});
   auto rowType = asRowType(inputRowVector->type());
@@ -370,8 +1043,7 @@ TEST_P(PrestoSerializerTest, longDecimal) {
     decimalValues[row] = row - 50;
   }
   decimalValues[101] = DecimalUtil::kLongDecimalMax;
-  auto vector =
-      vectorMaker_->flatVector<int128_t>(decimalValues, DECIMAL(20, 5));
+  auto vector = makeFlatVector<int128_t>(decimalValues, DECIMAL(20, 5));
 
   testRoundTrip(vector);
 
@@ -382,77 +1054,157 @@ TEST_P(PrestoSerializerTest, longDecimal) {
   testRoundTrip(vector);
 }
 
-TEST_P(PrestoSerializerTest, encodings) {
-  auto baseNoNulls = vectorMaker_->flatVector<int64_t>({1, 2, 3, 4});
-  auto baseWithNulls =
-      vectorMaker_->flatVectorNullable<int32_t>({1, std::nullopt, 2, 3});
-  auto baseArray = vectorMaker_->arrayVector<int32_t>(
-      {{1, 2, 3}, {}, {4, 5}, {6, 7, 8, 9, 10}});
-  auto indices = makeIndices(
-      8, [](auto row) { return row / 2; }, pool_.get());
-
-  auto data = vectorMaker_->rowVector({
-      BaseVector::wrapInDictionary(nullptr, indices, 8, baseNoNulls),
-      BaseVector::wrapInDictionary(nullptr, indices, 8, baseWithNulls),
-      BaseVector::wrapInDictionary(nullptr, indices, 8, baseArray),
-      BaseVector::createConstant(INTEGER(), 123, 8, pool_.get()),
-      BaseVector::createNullConstant(VARCHAR(), 8, pool_.get()),
-      BaseVector::wrapInConstant(8, 1, baseArray),
-      BaseVector::wrapInConstant(8, 2, baseArray),
+// Test that hierarchically encoded columns (rows) have their encodings
+// preserved by the PrestoBatchVectorSerializer.
+TEST_P(PrestoSerializerTest, encodingsBatchVectorSerializer) {
+  testBatchVectorSerializerRoundTrip(encodingsTestVector());
+}
+
+// Test that array elements have their encodings preserved by the
+// PrestoBatchVectorSerializer.
+TEST_P(PrestoSerializerTest, encodingsArrayElementsBatchVectorSerializer) {
+  testBatchVectorSerializerRoundTrip(encodingsArrayElementsTestVector());
+}
+
+// Test that map values have their encodings preserved by the
+// PrestoBatchVectorSerializer.
+TEST_P(PrestoSerializerTest, encodingsMapValuesBatchVectorSerializer) {
+  testBatchVectorSerializerRoundTrip(encodingsMapValuesTestVector());
+}
+
+// Test that dictionary encoding is preserved and that only the minimum number
+// of entries from the alphabet are serialized.
+TEST_P(PrestoSerializerTest, minimalDictionaryEncodings) {
+  // Dictionary same size as rows.
+  testMinimalDictionaryEncoding(32, 32);
+  // Dictionary smaller than rows.
+  testMinimalDictionaryEncoding(32, 16);
+  // Dictionary larger than rows.
+  testMinimalDictionaryEncoding(32, 64);
+}
+
+// Test that dictionary encoded inputs are flattened in cases where it doesn't
+// help.
+TEST_P(PrestoSerializerTest, dictionaryEncodingTurnedOff) {
+  auto smallIntBase =
+      makeFlatVector<int16_t>(32, [](vector_size_t row) { return row; });
+  auto intBase =
+      makeFlatVector<int32_t>(32, [](vector_size_t row) { return row; });
+  auto bigintBase =
+      makeFlatVector<int64_t>(32, [](vector_size_t row) { return row; });
+  auto stringBase = makeFlatVector<std::string>(
+      32, [](vector_size_t row) { return fmt::format("{}", row); });
+  auto oneIndex = makeIndices(32, [](auto) { return 0; });
+  auto quarterIndices = makeIndices(32, [](auto row) { return row % 8; });
+  auto allButOneIndices = makeIndices(32, [](auto row) { return row % 31; });
+  auto allIndices = makeIndices(32, [](auto row) { return row; });
+
+  auto rows = makeRowVector({
+      // Even though these have very effective dictionary encoding, they should
+      // be flattened because their types are too small.
+      BaseVector::wrapInDictionary(nullptr, oneIndex, 32, smallIntBase),
+      BaseVector::wrapInDictionary(nullptr, oneIndex, 32, intBase),
+      // These should keep dictionary encoding.
+      BaseVector::wrapInDictionary(nullptr, oneIndex, 32, bigintBase),
+      BaseVector::wrapInDictionary(nullptr, quarterIndices, 32, bigintBase),
+      // These should be flattened because dictionary encoding isn't giving
+      // enough benefit to outweigh the cost.
+      BaseVector::wrapInDictionary(nullptr, allButOneIndices, 32, bigintBase),
+      BaseVector::wrapInDictionary(nullptr, allIndices, 32, bigintBase),
+      // These should keep dictionary encoding because strings are variable
+      // length.
+      BaseVector::wrapInDictionary(nullptr, oneIndex, 32, stringBase),
+      BaseVector::wrapInDictionary(nullptr, quarterIndices, 32, stringBase),
+      BaseVector::wrapInDictionary(nullptr, allButOneIndices, 32, stringBase),
+      // This should be flattened because the alphabet is the same as the
+      // flattened vector.
+      BaseVector::wrapInDictionary(nullptr, allIndices, 32, stringBase),
   });
 
-  testEncodedRoundTrip(data);
+  std::ostringstream out;
+  serializeBatch(rows, &out, /*serdeOptions=*/nullptr);
+  const auto serialized = out.str();
+
+  auto rowType = asRowType(rows->type());
+  auto deserialized =
+      deserialize(rowType, serialized, /*serdeOptions=*/nullptr);
+
+  assertEqualVectors(rows, deserialized);
+
+  // smallInt + one index
+  ASSERT_EQ(deserialized->childAt(0)->encoding(), VectorEncoding::Simple::FLAT);
+  // int + one index
+  ASSERT_EQ(deserialized->childAt(1)->encoding(), VectorEncoding::Simple::FLAT);
+  // bigint + one index
+  ASSERT_EQ(
+      deserialized->childAt(2)->encoding(), VectorEncoding::Simple::DICTIONARY);
+  // bigint + quarter indices
+  ASSERT_EQ(
+      deserialized->childAt(3)->encoding(), VectorEncoding::Simple::DICTIONARY);
+  // bigint + all but one indices
+  ASSERT_EQ(deserialized->childAt(4)->encoding(), VectorEncoding::Simple::FLAT);
+  // bigint + all indices
+  ASSERT_EQ(deserialized->childAt(5)->encoding(), VectorEncoding::Simple::FLAT);
+  // string + one index
+  ASSERT_EQ(
+      deserialized->childAt(6)->encoding(), VectorEncoding::Simple::DICTIONARY);
+  // string + quarter indices
+  ASSERT_EQ(
+      deserialized->childAt(7)->encoding(), VectorEncoding::Simple::DICTIONARY);
+  // string + all but one indices
+  ASSERT_EQ(
+      deserialized->childAt(8)->encoding(), VectorEncoding::Simple::DICTIONARY);
+  // string + all indices
+  ASSERT_EQ(deserialized->childAt(9)->encoding(), VectorEncoding::Simple::FLAT);
 }
 
-TEST_P(PrestoSerializerTest, scatterEncoded) {
-  // Makes a struct with nulls and constant/dictionary encoded children. The
-  // children need to get gaps where the parent struct has a null.
-  VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
-  opts.nullRatio = 0.1;
-  VectorFuzzer fuzzer(opts, pool_.get());
+TEST_P(PrestoSerializerTest, emptyVectorBatchVectorSerializer) {
+  // Serialize an empty RowVector.
+  auto rowVector = makeEmptyTestVector();
 
-  auto rowType = ROW(
-      {{"inner",
-        ROW(
-            {{"i1", BIGINT()},
-             {"i2", VARCHAR()},
-             {"i3", ARRAY(INTEGER())},
-             {"i4", ROW({{"ii1", BIGINT()}})}})}});
-  auto row = fuzzer.fuzzInputRow(rowType);
-  auto inner =
-      const_cast<RowVector*>(row->childAt(0)->wrappedVector()->as<RowVector>());
-  if (!inner->mayHaveNulls()) {
-    return;
-  }
-  auto numNulls = BaseVector::countNulls(inner->nulls(), 0, inner->size());
-  auto numNonNull = inner->size() - numNulls;
-  auto indices = makeIndices(
-      numNonNull, [](auto row) { return row; }, pool_.get());
+  std::ostringstream out;
+  serializeBatch(rowVector, &out, nullptr);
 
-  inner->children()[0] = BaseVector::createConstant(
-      BIGINT(),
-      variant::create<TypeKind::BIGINT>(11L),
-      numNonNull,
-      pool_.get());
-  inner->children()[1] = BaseVector::wrapInDictionary(
-      BufferPtr(nullptr), indices, numNonNull, inner->childAt(1));
-  inner->children()[2] =
-      BaseVector::wrapInConstant(numNonNull, 3, inner->childAt(2));
-
-  // i4 is a struct that we wrap in constant. We make ths struct like it was
-  // read from seriailization, needing scatter for struct nulls.
-  auto i4 = const_cast<RowVector*>(
-      inner->childAt(3)->wrappedVector()->as<RowVector>());
-  auto i4NonNull = i4->mayHaveNulls()
-      ? i4->size() - BaseVector::countNulls(i4->nulls(), 0, i4->size())
-      : i4->size();
-  i4->childAt(0)->resize(i4NonNull);
-  inner->children()[3] =
-      BaseVector::wrapInConstant(numNonNull, 3, inner->childAt(3));
-  serializer::presto::testingScatterStructNulls(
-      row->size(), row->size(), nullptr, nullptr, *row);
+  auto rowType = asRowType(rowVector->type());
+  auto deserialized = deserialize(rowType, out.str(), nullptr);
+  assertEqualVectors(deserialized, rowVector);
+}
+
+TEST_P(PrestoSerializerTest, serializeNoRowsSelectedBatchVectorSerializer) {
+  std::ostringstream out;
+  facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
+  OStreamOutputStream output(&out, &listener);
+  auto paramOptions = getParamSerdeOptions(nullptr);
+  auto serializer = serde_->createBatchSerializer(pool_.get(), &paramOptions);
+  auto rowVector = makeRowVector(
+      {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"},
+      {makeFlatVector<bool>({true, false, true, false}),
+       makeFlatVector<int8_t>({1, 2, 3, 4}),
+       makeFlatVector<int16_t>({5, 6, 7, 8}),
+       makeFlatVector<int32_t>({9, 10, 11, 12}),
+       makeFlatVector<int64_t>({13, 14, 15, 16}),
+       makeFlatVector<float>({17.0, 18.0, 19.0, 20.0}),
+       makeFlatVector<double>({21.0, 22.0, 23.0, 24.0}),
+       makeFlatVector<StringView>({"25", "26", "27", "28"}),
+       makeFlatVector<Timestamp>({{29, 30}, {32, 32}, {33, 34}, {35, 36}}),
+       makeRowVector(
+           {"1", "2"},
+           {makeFlatVector<StringView>({"37", "38", "39", "40"}),
+            makeFlatVector<int32_t>({41, 42, 43, 44})}),
+       makeArrayVector<int32_t>({{45, 46}, {47, 48}, {49, 50}, {51, 52}}),
+       makeMapVector<StringView, int32_t>(
+           {{{"53", 54}, {"55", 56}},
+            {{"57", 58}, {"59", 60}},
+            {{"61", 62}, {"63", 64}},
+            {{"65", 66}, {"67", 68}}})});
+  const IndexRange noRows{0, 0};
+
+  serializer->serialize(rowVector, folly::Range(&noRows, 1), &output);
+
+  auto expected = makeEmptyTestVector();
+  auto rowType = asRowType(expected->type());
+  auto deserialized = deserialize(rowType, out.str(), nullptr);
+  assertEqualVectors(deserialized, expected);
 }
 
 TEST_P(PrestoSerializerTest, lazy) {
@@ -473,7 +1225,7 @@ TEST_P(PrestoSerializerTest, ioBufRoundTrip) {
   opts.nullRatio = 0.1;
   VectorFuzzer fuzzer(opts, pool_.get());
 
-  const size_t numRounds = 20;
+  const size_t numRounds = 200;
 
   for (size_t i = 0; i < numRounds; ++i) {
     auto rowType = fuzzer.randRowType();
@@ -485,6 +1237,233 @@ TEST_P(PrestoSerializerTest, ioBufRoundTrip) {
   }
 }
 
+TEST_P(PrestoSerializerTest, roundTrip) {
+  VectorFuzzer::Options opts;
+  opts.timestampPrecision =
+      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.nullRatio = 0.1;
+  VectorFuzzer fuzzer(opts, pool_.get());
+  VectorFuzzer::Options nonNullOpts;
+  nonNullOpts.timestampPrecision =
+      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  nonNullOpts.nullRatio = 0;
+  VectorFuzzer nonNullFuzzer(nonNullOpts, pool_.get());
+
+  const size_t numRounds = 100;
+
+  for (size_t i = 0; i < numRounds; ++i) {
+    auto rowType = fuzzer.randRowType();
+    auto inputRowVector = (i % 2 == 0) ? fuzzer.fuzzInputRow(rowType)
+                                       : nonNullFuzzer.fuzzInputRow(rowType);
+    serializer::presto::PrestoVectorSerde::PrestoOptions prestoOpts;
+    // Test every 2/4 with struct nulls first.
+    prestoOpts.nullsFirst = i % 4 < 2;
+    testRoundTrip(inputRowVector, &prestoOpts);
+  }
+}
+
+TEST_P(PrestoSerializerTest, encodedRoundtrip) {
+  VectorFuzzer::Options opts;
+  opts.timestampPrecision =
+      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.nullRatio = 0.1;
+  opts.dictionaryHasNulls = false;
+  VectorFuzzer fuzzer(opts, pool_.get());
+
+  const size_t numRounds = 200;
+
+  for (size_t i = 0; i < numRounds; ++i) {
+    auto rowType = fuzzer.randRowType();
+    auto inputRowVector = fuzzer.fuzzInputRow(rowType);
+    serializer::presto::PrestoVectorSerde::PrestoOptions serdeOpts;
+    serdeOpts.nullsFirst = i % 2 == 0;
+    testBatchVectorSerializerRoundTrip(inputRowVector, true, &serdeOpts);
+  }
+}
+
+TEST_P(PrestoSerializerTest, encodedConcatenation) {
+  // Slow test, run only for no compression.
+  if (GetParam() != common::CompressionKind::CompressionKind_NONE) {
+    return;
+  }
+
+  std::vector<TypePtr> types = {ROW({{"s0", VARCHAR()}}), VARCHAR()};
+  VectorFuzzer::Options nonNullOpts{
+      .nullRatio = 0, .dictionaryHasNulls = false};
+  VectorFuzzer nonNullFuzzer(nonNullOpts, pool_.get());
+  VectorFuzzer::Options nullOpts{.nullRatio = 1, .dictionaryHasNulls = false};
+  VectorFuzzer nullFuzzer(nullOpts, pool_.get());
+  VectorFuzzer::Options mixedOpts{
+      .nullRatio = 0.5, .dictionaryHasNulls = false};
+  VectorFuzzer mixedFuzzer(mixedOpts, pool_.get());
+
+  for (const auto& type : types) {
+    auto flatNull = nullFuzzer.fuzzFlat(type, 12);
+    auto flatNonNull = nonNullFuzzer.fuzzFlat(type, 13);
+
+    std::vector<VectorPtr> vectors = {
+        nullFuzzer.fuzzConstant(type, 10),
+        nonNullFuzzer.fuzzConstant(type, 11),
+        flatNonNull,
+        flatNull,
+        nonNullFuzzer.fuzzDictionary(flatNonNull),
+        nonNullFuzzer.fuzzDictionary(flatNull),
+        nullFuzzer.fuzzDictionary(flatNull),
+    };
+
+    if (type->isRow()) {
+      auto& rowType = type->as<TypeKind::ROW>();
+      auto row = makeRowVector(
+          {rowType.nameOf(0)},
+          {nonNullFuzzer.fuzzConstant(rowType.childAt(0), 14)});
+      row->setNull(2, true);
+      row->setNull(10, true);
+      vectors.push_back(row);
+    }
+    std::vector<std::vector<VectorPtr>> permutations;
+    std::vector<VectorPtr> temp;
+    makePermutations(vectors, 4, temp, permutations);
+    for (auto i = 0; i < permutations.size(); ++i) {
+      serializer::presto::PrestoVectorSerde::PrestoOptions opts;
+      opts.nullsFirst = i % 2 == 0;
+
+      testEncodedConcatenation(permutations[i], &opts);
+    }
+  }
+}
+
+TEST_P(PrestoSerializerTest, encodedConcatenation2) {
+  // Slow test, run only for no compression.
+  if (GetParam() != common::CompressionKind::CompressionKind_NONE) {
+    return;
+  }
+  VectorFuzzer::Options options;
+  VectorFuzzer fuzzer(options, pool_.get());
+  for (auto nthType = 0; nthType < 20; ++nthType) {
+    auto type = (fuzzer.randRowType());
+
+    std::vector<VectorPtr> vectors;
+    for (auto nth = 0; nth < 3; ++nth) {
+      randomOptions(options, 0 == nth);
+      fuzzer.setOptions(options);
+      vectors.push_back(fuzzer.fuzzInputRow(type));
+    }
+    std::vector<std::vector<VectorPtr>> permutations;
+    std::vector<VectorPtr> temp;
+    makePermutations(vectors, 3, temp, permutations);
+    for (auto i = 0; i < permutations.size(); ++i) {
+      serializer::presto::PrestoVectorSerde::PrestoOptions opts;
+      opts.useLosslessTimestamp = true;
+      opts.nullsFirst = i % 2 == 0;
+
+      testEncodedConcatenation(permutations[i], &opts);
+    }
+  }
+}
+
+TEST_P(PrestoSerializerTest, emptyArrayOfRowVector) {
+  // The value of nullCount_ + nonNullCount_ of the inner RowVector is 0.
+  auto arrayOfRow = makeArrayOfRowVector(ROW({UNKNOWN()}), {{}});
+  testRoundTrip(arrayOfRow);
+}
+
+TEST_P(PrestoSerializerTest, typeMismatch) {
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<std::string>({"a", "b", "c"}),
+  });
+
+  std::ostringstream out;
+  serialize(data, &out, nullptr);
+  auto serialized = out.str();
+
+  // Too many columns to deserialize.
+  VELOX_ASSERT_THROW(
+      deserialize(ROW({BIGINT(), VARCHAR(), BOOLEAN()}), serialized, nullptr),
+      "Number of columns in serialized data doesn't match "
+      "number of columns requested for deserialization");
+
+  // TMore columns in serialization than in type.
+  if (GetParam() == common::CompressionKind_NONE) {
+    // No throw.
+    deserialize(ROW({BIGINT()}), serialized, nullptr);
+  } else {
+    VELOX_ASSERT_THROW(
+        deserialize(ROW({BIGINT()}), serialized, nullptr),
+        "Number of columns in serialized data doesn't match "
+        "number of columns requested for deserialization");
+  }
+
+  // Wrong types of columns.
+  VELOX_ASSERT_THROW(
+      deserialize(ROW({BIGINT(), DOUBLE()}), serialized, nullptr),
+      "Serialized encoding is not compatible with requested type: DOUBLE. "
+      "Expected LONG_ARRAY. Got VARIABLE_WIDTH.");
+}
+
+TEST_P(PrestoSerializerTest, lexer) {
+  VectorFuzzer::Options opts;
+  opts.timestampPrecision =
+      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.nullRatio = 0.1;
+  VectorFuzzer fuzzer(opts, pool_.get());
+  VectorFuzzer::Options nonNullOpts;
+  nonNullOpts.timestampPrecision =
+      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  nonNullOpts.nullRatio = 0;
+  VectorFuzzer nonNullFuzzer(nonNullOpts, pool_.get());
+
+  const size_t numRounds = 20;
+
+  for (size_t i = 0; i < numRounds; ++i) {
+    auto rowType = fuzzer.randRowType();
+
+    auto inputRowVector = (i % 2 == 0) ? fuzzer.fuzzInputRow(rowType)
+                                       : nonNullFuzzer.fuzzInputRow(rowType);
+    testLexer(inputRowVector);
+  }
+}
+
+TEST_P(PrestoSerializerTest, checksum) {
+  std::ostringstream output;
+  // The payload (doesn't matter what as long as it's not 0).
+  vector_size_t data = 4;
+
+  // Write out the number of rows.
+  vector_size_t numRows = std::numeric_limits<int32_t>::max();
+  output.write(reinterpret_cast<char*>(&numRows), sizeof(numRows));
+  // Set the bit indicating there's a checksum.
+  char marker = 4;
+  output.write(&marker, sizeof(marker));
+  vector_size_t size = sizeof(data);
+  // Write out the uncompressed size and size (we're not compressing the data so
+  // they're the same).
+  output.write(reinterpret_cast<char*>(&size), sizeof(size));
+  output.write(reinterpret_cast<char*>(&size), sizeof(size));
+  // Write out the checksum, it shouldn't match the checksum of data.
+  int64_t checksum = 0;
+  output.write(reinterpret_cast<char*>(&checksum), sizeof(checksum));
+  output.write(reinterpret_cast<char*>(&data), sizeof(data));
+
+  auto paramOptions = getParamSerdeOptions(nullptr);
+  RowVectorPtr result;
+  auto serialized = output.str();
+  auto byteStream = toByteStream(serialized);
+  // Make a small memory pool, if we try to allocate a Vector with numRows we'll
+  // OOM.
+  auto pool = memory::memoryManager()->addRootPool("checksum", 1UL << 10);
+  // This should fail because the checksums don't match.
+  VELOX_ASSERT_THROW(
+      serde_->deserialize(
+          byteStream.get(),
+          pool->addLeafChild("child").get(),
+          ROW({BIGINT()}),
+          &result,
+          0,
+          &paramOptions),
+      "Received corrupted serialized page.");
+}
+
 INSTANTIATE_TEST_SUITE_P(
     PrestoSerializerTest,
     PrestoSerializerTest,
@@ -495,3 +1474,420 @@ INSTANTIATE_TEST_SUITE_P(
         common::CompressionKind::CompressionKind_ZSTD,
         common::CompressionKind::CompressionKind_LZ4,
         common::CompressionKind::CompressionKind_GZIP));
+
+TEST_F(PrestoSerializerTest, deserializeSingleColumn) {
+  // Verify that deserializeSingleColumn API can handle all supported types.
+  static const size_t kPrestoPageHeaderBytes = 21;
+  static const size_t kNumOfColumnsSerializedBytes = sizeof(int32_t);
+  static const size_t kBytesToTrim =
+      kPrestoPageHeaderBytes + kNumOfColumnsSerializedBytes;
+
+  auto testRoundTripSingleColumn = [&](const VectorPtr& vector) {
+    auto rowVector = makeRowVector({vector});
+    // Serialize to PrestoPage format.
+    std::ostringstream output;
+    auto arena = std::make_unique<StreamArena>(pool_.get());
+    auto rowType = asRowType(rowVector->type());
+    auto numRows = rowVector->size();
+    auto serializer = serde_->createIterativeSerializer(
+        rowType, numRows, arena.get(), nullptr);
+    serializer->append(rowVector);
+    facebook::velox::serializer::presto::PrestoOutputStreamListener listener;
+    OStreamOutputStream out(&output, &listener);
+    serializer->flush(&out);
+
+    validateLexer(output.str(), {});
+
+    // Remove the PrestoPage header and Number of columns section from the
+    // serialized data.
+    std::string input = output.str().substr(kBytesToTrim);
+
+    auto byteStream = toByteStream(input);
+    VectorPtr deserialized;
+    serde_->deserializeSingleColumn(
+        byteStream.get(), pool(), vector->type(), &deserialized, nullptr);
+    assertEqualVectors(vector, deserialized);
+  };
+
+  std::vector<TypePtr> typesToTest = {
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      REAL(),
+      DOUBLE(),
+      VARCHAR(),
+      TIMESTAMP(),
+      ROW({VARCHAR(), INTEGER()}),
+      ARRAY(INTEGER()),
+      ARRAY(INTEGER()),
+      MAP(VARCHAR(), INTEGER()),
+      MAP(VARCHAR(), ARRAY(INTEGER())),
+  };
+
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 5;
+  opts.nullRatio = 0.1;
+  opts.dictionaryHasNulls = false;
+  opts.stringVariableLength = true;
+  opts.stringLength = 20;
+  opts.containerVariableLength = false;
+  opts.timestampPrecision =
+      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.containerLength = 10;
+
+  auto seed = 0;
+
+  LOG(ERROR) << "Seed: " << seed;
+  SCOPED_TRACE(fmt::format("seed: {}", seed));
+  VectorFuzzer fuzzer(opts, pool_.get(), seed);
+
+  for (const auto& type : typesToTest) {
+    SCOPED_TRACE(fmt::format("Type: {}", type->toString()));
+    auto data = fuzzer.fuzz(type);
+    testRoundTripSingleColumn(data);
+  }
+}
+
+class PrestoSerializerBatchEstimateSizeTest : public testing::Test,
+                                              public VectorTestBase {
+ protected:
+  static void SetUpTestSuite() {
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    serde_ = std::make_unique<serializer::presto::PrestoVectorSerde>();
+    serializer_ = serde_->createBatchSerializer(pool_.get(), &paramOptions_);
+  }
+
+  void testEstimateSerializedSize(
+      VectorPtr input,
+      const std::vector<IndexRange>& ranges,
+      const std::vector<vector_size_t>& expectedSizes) {
+    ASSERT_EQ(ranges.size(), expectedSizes.size());
+
+    // Wrap the input a RowVector to better emulate production.
+    auto row = makeRowVector({input});
+
+    std::vector<vector_size_t> sizes(ranges.size(), 0);
+    std::vector<vector_size_t*> sizesPtrs(ranges.size());
+    for (int i = 0; i < ranges.size(); i++) {
+      sizesPtrs[i] = &sizes[i];
+    }
+
+    Scratch scratch;
+    serializer_->estimateSerializedSize(row, ranges, sizesPtrs.data(), scratch);
+
+    for (int i = 0; i < expectedSizes.size(); i++) {
+      // Add 4 bytes for each row in the wrapper. This is needed because we wrap
+      // the input in a RowVector.
+      ASSERT_EQ(sizes[i], expectedSizes[i] + 4 * ranges[i].size)
+          << "Mismatched estimated size for range" << i << " "
+          << ranges[i].begin << ":" << ranges[i].size;
+    }
+  }
+
+  void testEstimateSerializedSize(
+      const VectorPtr& vector,
+      vector_size_t totalExpectedSize) {
+    // The whole Vector is a single range.
+    testEstimateSerializedSize(
+        vector, {{0, vector->size()}}, {totalExpectedSize});
+    // Split the Vector into two equal ranges.
+    testEstimateSerializedSize(
+        vector,
+        {{0, vector->size() / 2}, {vector->size() / 2, vector->size() / 2}},
+        {totalExpectedSize / 2, totalExpectedSize / 2});
+    // Split the Vector into three ranges of 1/4, 1/2, 1/4.
+    testEstimateSerializedSize(
+        vector,
+        {{0, vector->size() / 4},
+         {vector->size() / 4, vector->size() / 2},
+         {vector->size() * 3 / 4, vector->size() / 4}},
+        {totalExpectedSize / 4, totalExpectedSize / 2, totalExpectedSize / 4});
+  }
+
+  std::unique_ptr<serializer::presto::PrestoVectorSerde> serde_;
+  std::unique_ptr<BatchVectorSerializer> serializer_;
+  serializer::presto::PrestoVectorSerde::PrestoOptions paramOptions_;
+};
+
+TEST_F(PrestoSerializerBatchEstimateSizeTest, flat) {
+  auto flatBoolVector =
+      makeFlatVector<bool>(32, [](vector_size_t row) { return row % 2 == 0; });
+
+  // Bools are 1 byte each.
+  // 32 * 1 = 32
+  testEstimateSerializedSize(flatBoolVector, 32);
+
+  auto flatIntVector =
+      makeFlatVector<int32_t>(32, [](vector_size_t row) { return row; });
+
+  // Ints are 4 bytes each.
+  // 4 * 32 = 128
+  testEstimateSerializedSize(flatIntVector, 128);
+
+  auto flatDoubleVector =
+      makeFlatVector<double>(32, [](vector_size_t row) { return row; });
+
+  // Doubles are 8 bytes each.
+  // 8 * 32 = 256
+  testEstimateSerializedSize(flatDoubleVector, 256);
+
+  auto flatStringVector = makeFlatVector<std::string>(
+      32, [](vector_size_t row) { return fmt::format("{}", row); });
+
+  // Strings are variable length, the first 10 are 1 byte each, the rest are 2
+  // bytes.  Plus 4 bytes for the length of each string.
+  // 10 * 1 + 22 * 2 + 4 * 32 = 182
+  testEstimateSerializedSize(flatStringVector, {{0, 32}}, {182});
+  testEstimateSerializedSize(flatStringVector, {{0, 16}, {16, 16}}, {86, 96});
+  testEstimateSerializedSize(
+      flatStringVector, {{0, 8}, {8, 16}, {24, 8}}, {40, 94, 48});
+
+  auto flatVectorWithNulls = makeFlatVector<double>(
+      32,
+      [](vector_size_t row) { return row; },
+      [](vector_size_t row) { return row % 4 == 0; });
+
+  // Doubles are 8 bytes each, and only non-null doubles are counted. In
+  // addition there's a null bit per row.
+  // 8 * 24 + (32 / 8) = 196
+  testEstimateSerializedSize(flatVectorWithNulls, {{0, 32}}, {196});
+  testEstimateSerializedSize(
+      flatVectorWithNulls, {{0, 16}, {16, 16}}, {98, 98});
+  testEstimateSerializedSize(
+      flatVectorWithNulls, {{0, 8}, {8, 16}, {24, 8}}, {49, 98, 49});
+}
+
+TEST_F(PrestoSerializerBatchEstimateSizeTest, array) {
+  std::vector<vector_size_t> offsets{
+      0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30};
+  auto elements =
+      makeFlatVector<int32_t>(32, [](vector_size_t row) { return row; });
+  auto arrayVector = makeArrayVector(offsets, elements);
+
+  // The ints in the array are 4 bytes each, and the array length is another 4
+  // bytes per row.
+  // 4 * 32 + 4 * 16 = 192
+  testEstimateSerializedSize(arrayVector, 192);
+
+  std::vector<vector_size_t> offsetsWithEmptyOrNulls{
+      0, 4, 4, 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32};
+  auto arrayVectorWithEmptyArrays =
+      makeArrayVector(offsetsWithEmptyOrNulls, elements);
+
+  // The ints in the array are 4 bytes each, and the array length is another 4
+  // bytes per row.
+  // 4 * 32 + 4 * 16 = 192
+  testEstimateSerializedSize(arrayVectorWithEmptyArrays, 192);
+
+  std::vector<vector_size_t> nullOffsets{1, 3, 5, 7, 9, 11, 13, 15};
+  auto arrayVectorWithNulls =
+      makeArrayVector(offsetsWithEmptyOrNulls, elements, nullOffsets);
+
+  // The ints in the array are 4 bytes each, and the array length is another 4
+  // bytes per non-null row, and 1 null bit per row.
+  // 4 * 32 + 4 * 8 + 16 / 8 = 162
+  testEstimateSerializedSize(arrayVectorWithNulls, {{0, 16}}, {162});
+  testEstimateSerializedSize(arrayVectorWithNulls, {{0, 8}, {8, 8}}, {81, 81});
+  testEstimateSerializedSize(
+      arrayVectorWithNulls, {{0, 4}, {4, 8}, {8, 4}}, {41, 81, 41});
+}
+
+TEST_F(PrestoSerializerBatchEstimateSizeTest, map) {
+  std::vector<vector_size_t> offsets{
+      0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30};
+  auto keys =
+      makeFlatVector<int32_t>(32, [](vector_size_t row) { return row; });
+  auto values =
+      makeFlatVector<double>(32, [](vector_size_t row) { return row; });
+  auto mapVector = makeMapVector(offsets, keys, values);
+
+  // The ints in the map are 4 bytes each, the doubles are 8 bytes, and the map
+  // length is another 4 bytes per row.
+  // 4 * 32 + 8 * 32 + 4 * 16 = 448
+  testEstimateSerializedSize(mapVector, 448);
+
+  std::vector<vector_size_t> offsetsWithEmptyOrNulls{
+      0, 4, 4, 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32};
+  auto mapVectorWithEmptyMaps =
+      makeMapVector(offsetsWithEmptyOrNulls, keys, values);
+
+  // The ints in the map are 4 bytes each, the doubles are 8 bytes, and the map
+  // length is another 4 bytes per row.
+  // 4 * 32 + 8 * 32 + 4 * 16 = 448
+  testEstimateSerializedSize(mapVectorWithEmptyMaps, 448);
+
+  std::vector<vector_size_t> nullOffsets{1, 3, 5, 7, 9, 11, 13, 15};
+  auto mapVectorWithNulls =
+      makeMapVector(offsetsWithEmptyOrNulls, keys, values, nullOffsets);
+
+  // The ints in the map are 4 bytes each, the doubles are 8 bytes, and the map
+  // length is another 4 bytes per non-null row, and 1 null bit per row.
+  // 4 * 32 + 8 * 32 + 4 * 8 + 16 / 8 = 216
+  testEstimateSerializedSize(mapVectorWithNulls, {{0, 16}}, {418});
+  testEstimateSerializedSize(mapVectorWithNulls, {{0, 8}, {8, 8}}, {209, 209});
+  testEstimateSerializedSize(
+      mapVectorWithNulls, {{0, 4}, {4, 8}, {12, 4}}, {105, 209, 105});
+}
+
+TEST_F(PrestoSerializerBatchEstimateSizeTest, row) {
+  auto field1 =
+      makeFlatVector<int32_t>(32, [](vector_size_t row) { return row; });
+  auto field2 =
+      makeFlatVector<double>(32, [](vector_size_t row) { return row; });
+  auto rowVector = makeRowVector({field1, field2});
+
+  // The ints in the row are 4 bytes each, the doubles are 8 bytes, and the
+  // offsets are 4 bytes per row.
+  // 4 * 32 + 8 * 32 + 4 * 32 = 512
+  testEstimateSerializedSize(rowVector, 512);
+
+  auto rowVectorWithNulls =
+      makeRowVector({field1, field2}, [](auto row) { return row % 4 == 0; });
+
+  // The ints in the row are 4 bytes each, the doubles are 8 bytes, and the
+  // offsets are 4 bytes per row, and 1 null bit per row.
+  // 4 * 24 + 8 * 24 + 4 * 32 + 32 / 8 = 420
+  testEstimateSerializedSize(rowVectorWithNulls, 420);
+}
+
+TEST_F(PrestoSerializerBatchEstimateSizeTest, constant) {
+  auto flatVector =
+      makeFlatVector<int32_t>(32, [](vector_size_t row) { return row; });
+  auto constantInt = BaseVector::wrapInConstant(32, 0, flatVector);
+
+  // The single constant int is 4 bytes.
+  testEstimateSerializedSize(constantInt, {{0, 32}}, {4});
+  testEstimateSerializedSize(constantInt, {{0, 16}, {16, 16}}, {4, 4});
+  testEstimateSerializedSize(
+      constantInt, {{0, 8}, {8, 16}, {24, 8}}, {4, 4, 4});
+
+  auto nullConstant = BaseVector::createNullConstant(BIGINT(), 32, pool_.get());
+
+  // The single constant null is 1 byte (for the bit mask).
+  testEstimateSerializedSize(nullConstant, {{0, 32}}, {1});
+  testEstimateSerializedSize(nullConstant, {{0, 16}, {16, 16}}, {1, 1});
+  testEstimateSerializedSize(
+      nullConstant, {{0, 8}, {8, 16}, {24, 8}}, {1, 1, 1});
+
+  std::vector<vector_size_t> offsets{
+      0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30};
+  auto arrayVector = makeArrayVector(offsets, flatVector);
+  auto constantArray = BaseVector::wrapInConstant(32, 0, arrayVector);
+
+  // The single constant array is 4 bytes for the length, and 4 bytes for each
+  // of the 2 integer elements.
+  // 4 + 2 * 4 = 12
+  testEstimateSerializedSize(constantArray, {{0, 32}}, {12});
+  testEstimateSerializedSize(constantArray, {{0, 16}, {16, 16}}, {12, 12});
+  testEstimateSerializedSize(
+      constantArray, {{0, 8}, {8, 16}, {24, 8}}, {12, 12, 12});
+
+  auto arrayVectorWithConstantElements = makeArrayVector(offsets, constantInt);
+  auto constantArrayWithConstantElements =
+      BaseVector::wrapInConstant(32, 0, arrayVectorWithConstantElements);
+
+  // The single constant array is 4 bytes for the length, and 4 bytes for each
+  // of the 2 integer elements (encodings for children of encoded complex types
+  // are not currently preserved).
+  // 4 + 2 * 4 = 12
+  testEstimateSerializedSize(
+      constantArrayWithConstantElements, {{0, 32}}, {12});
+  testEstimateSerializedSize(
+      constantArrayWithConstantElements, {{0, 16}, {16, 16}}, {12, 12});
+  testEstimateSerializedSize(
+      constantArrayWithConstantElements,
+      {{0, 8}, {8, 16}, {24, 8}},
+      {12, 12, 12});
+}
+
+TEST_F(PrestoSerializerBatchEstimateSizeTest, dictionary) {
+  auto indices = makeIndices(32, [](auto row) { return (row * 2) % 32; });
+  auto flatVector =
+      makeFlatVector<int32_t>(32, [](vector_size_t row) { return row; });
+  auto dictionaryInts =
+      BaseVector::wrapInDictionary(nullptr, indices, 32, flatVector);
+
+  // The indices are 4 bytes, and the dictionary entries are 4 bytes each.
+  // 4 * 32 + 4 * 16 = 192
+  testEstimateSerializedSize(dictionaryInts, {{0, 32}}, {192});
+  testEstimateSerializedSize(dictionaryInts, {{0, 16}, {16, 16}}, {128, 128});
+  testEstimateSerializedSize(
+      dictionaryInts, {{0, 8}, {8, 16}, {24, 8}}, {64, 128, 64});
+
+  auto flatVectorWithNulls = makeFlatVector<double>(
+      32,
+      [](vector_size_t row) { return row; },
+      [](vector_size_t row) { return row % 4 == 0; });
+  auto dictionaryNullElements =
+      BaseVector::wrapInDictionary(nullptr, indices, 32, flatVectorWithNulls);
+
+  // The indices are 4 bytes, half the dictionary entries are 8 byte doubles.
+  // Note that the bytes for the null bits in the entries are not accounted for,
+  // this is a limitation of having non-contiguous ranges selected from the
+  // dictionary values.
+  // 4 * 32 + 8 * 8 = 192
+  testEstimateSerializedSize(dictionaryNullElements, {{0, 32}}, {192});
+  testEstimateSerializedSize(
+      dictionaryNullElements, {{0, 16}, {16, 16}}, {128, 128});
+  testEstimateSerializedSize(
+      dictionaryNullElements, {{0, 8}, {8, 16}, {24, 8}}, {64, 128, 64});
+
+  auto arrayIndices = makeIndices(16, [](auto row) { return (row * 2) % 16; });
+  std::vector<vector_size_t> offsets{
+      0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30};
+  auto arrayVector = makeArrayVector(offsets, flatVector);
+  auto dictionaryArray =
+      BaseVector::wrapInDictionary(nullptr, arrayIndices, 16, arrayVector);
+
+  // The indices are 4 bytes, and the dictionary entries are 4 bytes length + 4
+  // bytes for each of the 2 array elements.
+  // 4 * 16 + 4 * 8 + 2 * 8 * 4 = 160
+  testEstimateSerializedSize(dictionaryArray, {{0, 16}}, {160});
+  testEstimateSerializedSize(dictionaryArray, {{0, 8}, {8, 8}}, {128, 128});
+  testEstimateSerializedSize(
+      dictionaryArray, {{0, 4}, {4, 8}, {12, 4}}, {64, 128, 64});
+
+  auto constantInt = BaseVector::wrapInConstant(32, 0, flatVector);
+  auto arrayVectorWithConstantElements = makeArrayVector(offsets, constantInt);
+  auto dictionaryArrayWithConstantElements = BaseVector::wrapInDictionary(
+      nullptr, arrayIndices, 16, arrayVectorWithConstantElements);
+
+  // The indices are 4 bytes, and the dictionary entries are 4 bytes length + 4
+  // bytes for each of the 2 array elements (encodings for children of encoded
+  // complex types are not currently preserved).
+  // 4 * 16 + 4 * 8 + 2 * 8 * 4 = 160
+  testEstimateSerializedSize(
+      dictionaryArrayWithConstantElements, {{0, 16}}, {160});
+  testEstimateSerializedSize(
+      dictionaryArrayWithConstantElements, {{0, 8}, {8, 8}}, {128, 128});
+  testEstimateSerializedSize(
+      dictionaryArrayWithConstantElements,
+      {{0, 4}, {4, 8}, {12, 4}},
+      {64, 128, 64});
+
+  auto dictionaryWithNulls = BaseVector::wrapInDictionary(
+      makeNulls(32, [](auto row) { return row % 2 == 0; }),
+      indices,
+      32,
+      flatVector);
+
+  // When nulls are present in the dictionary, currently we flatten the data. So
+  // there are 4 bytes per row.  Null bits are only accounted for the null
+  // elements because the non-null elements in the wrapped vector or
+  // non-contiguous.
+  // 4 * 16 + 16 / 8 = 66
+  testEstimateSerializedSize(dictionaryWithNulls, {{0, 32}}, {66});
+  testEstimateSerializedSize(
+      dictionaryWithNulls, {{0, 16}, {16, 16}}, {33, 33});
+  testEstimateSerializedSize(
+      dictionaryWithNulls, {{0, 8}, {8, 16}, {24, 8}}, {17, 33, 17});
+}
diff --git a/velox/serializers/tests/SerializerBenchmark.cpp b/velox/serializers/tests/SerializerBenchmark.cpp
new file mode 100644
index 0000000000000..d6aeb1f3add7b
--- /dev/null
+++ b/velox/serializers/tests/SerializerBenchmark.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <folly/init/Init.h>
+
+#include <vector>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/ByteStream.h"
+#include "velox/common/time/Timer.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+class SerializerBenchmark : public VectorTestBase {
+ public:
+  struct SerializeCase {
+    int32_t nullPct;
+    int32_t numSelected;
+    int32_t bits;
+    int32_t vectorSize;
+    uint64_t irTime{0};
+    uint64_t rrTime{0};
+
+    std::string toString() {
+      return fmt::format(
+          "{} of {} {} bit {}%null: {} ir / {} rr",
+          numSelected,
+          vectorSize,
+          bits,
+          nullPct,
+          irTime,
+          rrTime);
+    }
+  };
+
+  void setup() {
+    serde_ = std::make_unique<serializer::presto::PrestoVectorSerde>();
+  }
+  void timeFlat() {
+    // Serialize different fractions of a 10K vector of int32_t and int64_t with
+    // IndexRange and row range variants with and without nulls.
+    constexpr int32_t kPad = 8;
+    std::vector<int32_t> numSelectedValues = {3, 30, 300, 10000};
+    std::vector<std::vector<IndexRange>> indexRanges;
+    std::vector<std::vector<vector_size_t>> rowSets;
+    std::vector<int32_t> nullPctValues = {0, 1, 10, 90};
+    std::vector<int32_t> bitsValues = {32, 64};
+    const int32_t vectorSize = 10000;
+    for (auto numSelected : numSelectedValues) {
+      std::vector<IndexRange> ir;
+      std::vector<vector_size_t> rr;
+      int32_t step = vectorSize / numSelected;
+      for (auto r = 0; r < vectorSize; r += step) {
+        ir.push_back(IndexRange{r, 1});
+        rr.push_back(r);
+      }
+      std::cout << rr.size();
+      indexRanges.push_back(std::move(ir));
+      rr.resize(rr.size() + kPad, 999999999);
+      rowSets.push_back(std::move(rr));
+    }
+    VectorMaker vm(pool_.get());
+    std::vector<VectorPtr> v32s;
+    std::vector<VectorPtr> v64s;
+    for (auto nullPct : nullPctValues) {
+      auto v32 = vm.flatVector<int32_t>(
+          vectorSize,
+          [&](auto row) { return row; },
+          [&](auto row) { return nullPct == 0 ? false : row % 100 < nullPct; });
+      auto v64 = vm.flatVector<int64_t>(
+          vectorSize,
+          [&](auto row) { return row; },
+          [&](auto row) { return nullPct == 0 ? false : row % 100 < nullPct; });
+      v32s.push_back(std::move(v32));
+      v64s.push_back(std::move(v64));
+    }
+    std::vector<SerializeCase> cases;
+    Scratch scratch;
+
+    auto runCase = [&](int32_t nullIdx, int32_t selIdx, int32_t bits) {
+      SerializeCase item;
+      item.vectorSize = vectorSize;
+      item.nullPct = nullPctValues[nullIdx];
+      item.numSelected = numSelectedValues[selIdx];
+      item.bits = bits;
+      int32_t numRepeat = 100 * vectorSize / indexRanges[selIdx].size();
+
+      VectorPtr vector = bits == 32 ? v32s[nullIdx] : v64s[nullIdx];
+      auto rowType = ROW({vector->type()});
+      auto rowVector = vm.rowVector({vector});
+      {
+        MicrosecondTimer t(&item.irTime);
+        auto group = std::make_unique<VectorStreamGroup>(pool_.get());
+        group->createStreamTree(rowType, rowSets[selIdx].size() - kPad);
+        for (auto repeat = 0; repeat < numRepeat; ++repeat) {
+          group->append(
+              rowVector,
+              folly::Range(
+                  indexRanges[selIdx].data(), indexRanges[selIdx].size()),
+              scratch);
+        }
+      }
+
+      {
+        MicrosecondTimer t(&item.rrTime);
+        auto group = std::make_unique<VectorStreamGroup>(pool_.get());
+        group->createStreamTree(rowType, rowSets[selIdx].size());
+
+        for (auto repeat = 0; repeat < numRepeat; ++repeat) {
+          group->append(
+              rowVector,
+              folly::Range(
+                  rowSets[selIdx].data(), rowSets[selIdx].size() - kPad),
+              scratch);
+        }
+      }
+      return item;
+    };
+
+    for (auto bits : bitsValues) {
+      for (auto nullIdx = 0; nullIdx < nullPctValues.size(); ++nullIdx) {
+        for (auto selIdx = 0; selIdx < numSelectedValues.size(); ++selIdx) {
+          int32_t numRepeat = 10 / numSelectedValues[selIdx];
+          cases.push_back(runCase(nullIdx, selIdx, bits));
+        }
+      }
+    }
+    for (auto& item : cases) {
+      std::cout << item.toString() << std::endl;
+    }
+  }
+
+  std::unique_ptr<serializer::presto::PrestoVectorSerde> serde_;
+};
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  serializer::presto::PrestoVectorSerde::registerVectorSerde();
+  SerializerBenchmark bm;
+  bm.setup();
+  bm.timeFlat();
+}
diff --git a/velox/serializers/tests/UnsafeRowSerializerTest.cpp b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
index c2372b091a747..cfcb2a61f8bdf 100644
--- a/velox/serializers/tests/UnsafeRowSerializerTest.cpp
+++ b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/serializers/UnsafeRowSerializer.h"
 #include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -23,8 +24,12 @@ using namespace facebook::velox;
 class UnsafeRowSerializerTest : public ::testing::Test,
                                 public test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = memory::addDefaultLeafMemoryPool();
+    pool_ = memory::memoryManager()->addLeafPool();
     serde_ = std::make_unique<serializer::spark::UnsafeRowVectorSerde>();
   }
 
@@ -38,28 +43,34 @@ class UnsafeRowSerializerTest : public ::testing::Test,
 
     auto arena = std::make_unique<StreamArena>(pool_.get());
     auto rowType = std::dynamic_pointer_cast<const RowType>(rowVector->type());
-    auto serializer = serde_->createSerializer(rowType, numRows, arena.get());
+    auto serializer =
+        serde_->createIterativeSerializer(rowType, numRows, arena.get());
 
-    serializer->append(rowVector, folly::Range(rows.data(), numRows));
+    Scratch scratch;
+    serializer->append(rowVector, folly::Range(rows.data(), numRows), scratch);
     auto size = serializer->maxSerializedSize();
     OStreamOutputStream out(output);
     serializer->flush(&out);
     ASSERT_EQ(size, output->tellp());
   }
 
-  std::unique_ptr<ByteStream> toByteStream(const std::string_view& input) {
-    auto byteStream = std::make_unique<ByteStream>();
-    ByteRange byteRange{
-        reinterpret_cast<uint8_t*>(const_cast<char*>(input.data())),
-        (int32_t)input.length(),
-        0};
-    byteStream->resetInput({byteRange});
-    return byteStream;
+  std::unique_ptr<ByteInputStream> toByteStream(
+      const std::vector<std::string_view>& inputs) {
+    std::vector<ByteRange> ranges;
+    ranges.reserve(inputs.size());
+
+    for (const auto& input : inputs) {
+      ranges.push_back(
+          {reinterpret_cast<uint8_t*>(const_cast<char*>(input.data())),
+           (int32_t)input.length(),
+           0});
+    }
+    return std::make_unique<BufferInputStream>(std::move(ranges));
   }
 
   RowVectorPtr deserialize(
       std::shared_ptr<const RowType> rowType,
-      const std::string_view& input) {
+      const std::vector<std::string_view>& input) {
     auto byteStream = toByteStream(input);
 
     RowVectorPtr result;
@@ -72,7 +83,7 @@ class UnsafeRowSerializerTest : public ::testing::Test,
     serialize(rowVector, &out);
 
     auto rowType = std::dynamic_pointer_cast<const RowType>(rowVector->type());
-    auto deserialized = deserialize(rowType, out.str());
+    auto deserialized = deserialize(rowType, {out.str()});
     test::assertEqualVectors(deserialized, rowVector);
   }
 
@@ -83,12 +94,18 @@ class UnsafeRowSerializerTest : public ::testing::Test,
     EXPECT_EQ(std::memcmp(expectedData, out.str().data(), dataSize), 0);
   }
 
+  void testDeserialize(
+      const std::vector<std::string_view>& input,
+      RowVectorPtr expectedVector) {
+    auto results = deserialize(asRowType(expectedVector->type()), input);
+    test::assertEqualVectors(expectedVector, results);
+  }
+
   void
   testDeserialize(int8_t* data, size_t dataSize, RowVectorPtr expectedVector) {
-    auto results = deserialize(
-        asRowType(expectedVector->type()),
-        std::string_view(reinterpret_cast<const char*>(data), dataSize));
-    test::assertEqualVectors(expectedVector, results);
+    testDeserialize(
+        {std::string_view(reinterpret_cast<const char*>(data), dataSize)},
+        expectedVector);
   }
 
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -207,6 +224,70 @@ TEST_F(UnsafeRowSerializerTest, manyRows) {
   testDeserialize(data, 140, expected);
 }
 
+TEST_F(UnsafeRowSerializerTest, splitRow) {
+  int8_t data[20] = {0, 0, 0,  16, 0,   0,   0, 0, 0, 0,
+                     0, 0, 62, 28, -36, -33, 2, 0, 0, 0};
+  auto expected =
+      makeRowVector({makeFlatVector(std::vector<int64_t>{12345678910})});
+
+  std::vector<std::string_view> buffers;
+  const char* rawData = reinterpret_cast<const char*>(data);
+
+  // Split input row into two buffers.
+  buffers = {{rawData, 10}, {rawData + 10, 10}};
+  testDeserialize(buffers, expected);
+
+  // Split input row into many buffers.
+  buffers = {
+      {rawData, 4},
+      {rawData + 4, 4},
+      {rawData + 8, 4},
+      {rawData + 12, 8},
+  };
+  testDeserialize(buffers, expected);
+
+  // One byte at a time.
+  buffers.clear();
+  for (size_t i = 0; i < 20; i++) {
+    buffers.push_back({rawData + i, 1});
+  }
+  testDeserialize(buffers, expected);
+}
+
+TEST_F(UnsafeRowSerializerTest, incompleteRow) {
+  int8_t data[20] = {0, 0, 0,  16, 0,   0,   0, 0, 0, 0,
+                     0, 0, 62, 28, -36, -33, 2, 0, 0, 0};
+  auto expected =
+      makeRowVector({makeFlatVector(std::vector<int64_t>{12345678910})});
+  const char* rawData = reinterpret_cast<const char*>(data);
+
+  std::vector<std::string_view> buffers;
+
+  // Cut in the middle of the row.
+  buffers = {{rawData, 10}};
+  VELOX_ASSERT_RUNTIME_THROW(
+      testDeserialize(buffers, expected),
+      "Unable to read full serialized UnsafeRow");
+
+  // Still incomplete row.
+  buffers = {{rawData, 10}, {rawData, 5}};
+  VELOX_ASSERT_RUNTIME_THROW(
+      testDeserialize(buffers, expected),
+      "Unable to read full serialized UnsafeRow");
+
+  // Cut right after the row size.
+  buffers = {{rawData, 4}};
+  VELOX_ASSERT_RUNTIME_THROW(
+      testDeserialize(buffers, expected),
+      "Unable to read full serialized UnsafeRow");
+
+  // Cut in the middle of the `size` integer.
+  buffers = {{rawData, 2}};
+  VELOX_ASSERT_RUNTIME_THROW(
+      testDeserialize(buffers, expected),
+      "(1 vs. 1) Reading past end of BufferInputStream");
+}
+
 TEST_F(UnsafeRowSerializerTest, types) {
   auto rowType = ROW(
       {BOOLEAN(),
@@ -229,7 +310,6 @@ TEST_F(UnsafeRowSerializerTest, types) {
   VectorFuzzer::Options opts;
   opts.vectorSize = 5;
   opts.nullRatio = 0.1;
-  opts.containerHasNulls = false;
   opts.dictionaryHasNulls = false;
   opts.stringVariableLength = true;
   opts.stringLength = 20;
@@ -246,7 +326,7 @@ TEST_F(UnsafeRowSerializerTest, types) {
   SCOPED_TRACE(fmt::format("seed: {}", seed));
   VectorFuzzer fuzzer(opts, pool_.get(), seed);
 
-  auto data = fuzzer.fuzzRow(rowType);
+  auto data = fuzzer.fuzzInputRow(rowType);
   testRoundTrip(data);
 }
 
diff --git a/velox/substrait/CMakeLists.txt b/velox/substrait/CMakeLists.txt
index a3a9ade8f21f9..13ce0e01a981e 100644
--- a/velox/substrait/CMakeLists.txt
+++ b/velox/substrait/CMakeLists.txt
@@ -30,14 +30,17 @@ set_source_files_properties(${PROTO_OUTPUT_FILES} PROPERTIES GENERATED TRUE)
 
 get_filename_component(PROTO_DIR ${substrait_proto_directory}/, DIRECTORY)
 
+# Ensure that the option --proto_path is not given an empty argument
+foreach(PROTO_PATH ${PROJECT_SOURCE_DIR} ${Protobuf_INCLUDE_DIRS})
+  list(APPEND PROTO_PATH_ARGS --proto_path=${PROTO_PATH})
+endforeach()
+
 # Generate Substrait hearders
 add_custom_command(
   OUTPUT ${PROTO_OUTPUT_FILES}
-  COMMAND
-    ${Protobuf_PROTOC_EXECUTABLE} --proto_path ${PROJECT_SOURCE_DIR}/
-    --proto_path ${Protobuf_INCLUDE_DIRS} --cpp_out ${PROJECT_SOURCE_DIR}
-    ${PROTO_FILES}
-  DEPENDS ${PROTO_DIR}
+  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${PROJECT_SOURCE_DIR}
+          ${PROTO_FILES}
+  DEPENDS ${PROTO_DIR} protobuf::protoc
   COMMENT "Running PROTO compiler"
   VERBATIM)
 add_custom_target(substrait_proto ALL DEPENDS ${PROTO_OUTPUT_FILES})
@@ -45,22 +48,22 @@ add_dependencies(substrait_proto protobuf::libprotobuf)
 
 set(SRCS
     ${PROTO_SRCS}
+    SubstraitExtensionCollector.cpp
     SubstraitParser.cpp
     SubstraitToVeloxExpr.cpp
     SubstraitToVeloxPlan.cpp
     TypeUtils.cpp
-    SubstraitExtensionCollector.cpp
+    VeloxSubstraitSignature.cpp
     VeloxToSubstraitExpr.cpp
     VeloxToSubstraitPlan.cpp
     VeloxToSubstraitType.cpp
-    VeloxSubstraitSignature.cpp
     VariantToVectorConverter.cpp)
 
-add_library(velox_substrait_plan_converter ${SRCS})
+velox_add_library(velox_substrait_plan_converter ${SRCS})
 target_include_directories(velox_substrait_plan_converter
                            PUBLIC ${PROTO_OUTPUT_DIR})
-target_link_libraries(velox_substrait_plan_converter velox_connector
-                      velox_dwio_dwrf_common)
+velox_link_libraries(velox_substrait_plan_converter velox_connector
+                     velox_dwio_dwrf_common)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/substrait/SubstraitExtensionCollector.h b/velox/substrait/SubstraitExtensionCollector.h
index fa64671b77216..56a4d00795aad 100644
--- a/velox/substrait/SubstraitExtensionCollector.h
+++ b/velox/substrait/SubstraitExtensionCollector.h
@@ -114,4 +114,4 @@ struct hash<facebook::velox::substrait::ExtensionFunctionId> {
   }
 };
 
-}; // namespace std
+} // namespace std
diff --git a/velox/substrait/SubstraitParser.cpp b/velox/substrait/SubstraitParser.cpp
index 0e51cd50a1e1e..c2a22c68180f4 100644
--- a/velox/substrait/SubstraitParser.cpp
+++ b/velox/substrait/SubstraitParser.cpp
@@ -15,149 +15,82 @@
  */
 
 #include "velox/substrait/SubstraitParser.h"
+#include <string>
 #include "velox/common/base/Exceptions.h"
 #include "velox/substrait/TypeUtils.h"
+#include "velox/substrait/VeloxSubstraitSignature.h"
 
 namespace facebook::velox::substrait {
 
-std::shared_ptr<SubstraitParser::SubstraitType> SubstraitParser::parseType(
-    const ::substrait::Type& substraitType) {
-  // The used type names should be aligned with those in Velox.
-  std::string typeName;
-  ::substrait::Type_Nullability nullability;
+TypePtr SubstraitParser::parseType(const ::substrait::Type& substraitType) {
   switch (substraitType.kind_case()) {
-    case ::substrait::Type::KindCase::kBool: {
-      typeName = "BOOLEAN";
-      nullability = substraitType.bool_().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kI8: {
-      typeName = "TINYINT";
-      nullability = substraitType.i8().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kI16: {
-      typeName = "SMALLINT";
-      nullability = substraitType.i16().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kI32: {
-      typeName = "INTEGER";
-      nullability = substraitType.i32().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kI64: {
-      typeName = "BIGINT";
-      nullability = substraitType.i64().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kFp32: {
-      typeName = "REAL";
-      nullability = substraitType.fp32().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kFp64: {
-      typeName = "DOUBLE";
-      nullability = substraitType.fp64().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kString: {
-      typeName = "VARCHAR";
-      nullability = substraitType.string().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kBinary: {
-      typeName = "VARBINARY";
-      nullability = substraitType.string().nullability();
-      break;
-    }
+    case ::substrait::Type::KindCase::kBool:
+      return BOOLEAN();
+    case ::substrait::Type::KindCase::kI8:
+      return TINYINT();
+    case ::substrait::Type::KindCase::kI16:
+      return SMALLINT();
+    case ::substrait::Type::KindCase::kI32:
+      return INTEGER();
+    case ::substrait::Type::KindCase::kI64:
+      return BIGINT();
+    case ::substrait::Type::KindCase::kFp32:
+      return REAL();
+    case ::substrait::Type::KindCase::kFp64:
+      return DOUBLE();
+    case ::substrait::Type::KindCase::kString:
+      return VARCHAR();
+    case ::substrait::Type::KindCase::kBinary:
+      return VARBINARY();
     case ::substrait::Type::KindCase::kStruct: {
-      // The type name of struct is in the format of:
-      // ROW<type0,type1,ROW<type2>>...typen.
-      typeName = "ROW<";
-      const auto& sStruct = substraitType.struct_();
-      const auto& substraitTypes = sStruct.types();
-      for (int i = 0; i < substraitTypes.size(); i++) {
-        if (i > 0) {
-          typeName += ",";
-        }
-        typeName += parseType(substraitTypes[i])->type;
+      const auto& substraitStruct = substraitType.struct_();
+      const auto& structTypes = substraitStruct.types();
+      std::vector<TypePtr> types;
+      std::vector<std::string> names;
+      for (int i = 0; i < structTypes.size(); i++) {
+        types.emplace_back(parseType(structTypes[i]));
+        names.emplace_back(fmt::format("col_{}", i));
       }
-      typeName += ">";
-      nullability = substraitType.struct_().nullability();
-      break;
+      return ROW(std::move(names), std::move(types));
     }
     case ::substrait::Type::KindCase::kList: {
       // The type name of list is in the format of: ARRAY<T>.
-      const auto& sList = substraitType.list();
-      const auto& sType = sList.type();
-      typeName = "ARRAY<" + parseType(sType)->type + ">";
-      nullability = substraitType.list().nullability();
-      break;
+      const auto& fieldType = substraitType.list().type();
+      return ARRAY(parseType(fieldType));
     }
     case ::substrait::Type::KindCase::kMap: {
       // The type name of map is in the format of: MAP<K,V>.
       const auto& sMap = substraitType.map();
       const auto& keyType = sMap.key();
       const auto& valueType = sMap.value();
-      typeName = "MAP<" + parseType(keyType)->type + "," +
-          parseType(valueType)->type + ">";
-      nullability = substraitType.map().nullability();
-      break;
+      return MAP(parseType(keyType), parseType(valueType));
     }
-    case ::substrait::Type::KindCase::kUserDefined: {
+    case ::substrait::Type::KindCase::kUserDefined:
       // We only support UNKNOWN type to handle the null literal whose type is
       // not known.
-      VELOX_CHECK_EQ(substraitType.user_defined().type_reference(), 0);
-      typeName = "UNKNOWN";
-      nullability = substraitType.string().nullability();
-      break;
-    }
-    case ::substrait::Type::KindCase::kDate: {
-      typeName = "DATE";
-      nullability = substraitType.date().nullability();
-      break;
-    }
+      return UNKNOWN();
+    case ::substrait::Type::KindCase::kDate:
+      return DATE();
     default:
       VELOX_NYI(
           "Parsing for Substrait type not supported: {}",
           substraitType.DebugString());
   }
-
-  bool nullable;
-  switch (nullability) {
-    case ::substrait::Type_Nullability::
-        Type_Nullability_NULLABILITY_UNSPECIFIED:
-      nullable = true;
-      break;
-    case ::substrait::Type_Nullability::Type_Nullability_NULLABILITY_NULLABLE:
-      nullable = true;
-      break;
-    case ::substrait::Type_Nullability::Type_Nullability_NULLABILITY_REQUIRED:
-      nullable = false;
-      break;
-    default:
-      VELOX_NYI(
-          "Substrait parsing for nullability {} not supported.", nullability);
-  }
-  SubstraitType type = {typeName, nullable};
-  return std::make_shared<SubstraitType>(type);
 }
 
-std::vector<std::shared_ptr<SubstraitParser::SubstraitType>>
-SubstraitParser::parseNamedStruct(const ::substrait::NamedStruct& namedStruct) {
+std::vector<TypePtr> SubstraitParser::parseNamedStruct(
+    const ::substrait::NamedStruct& namedStruct) {
   // Nte that "names" are not used.
 
   // Parse Struct.
   const auto& substraitStruct = namedStruct.struct_();
   const auto& substraitTypes = substraitStruct.types();
-  std::vector<std::shared_ptr<SubstraitParser::SubstraitType>>
-      substraitTypeList;
-  substraitTypeList.reserve(substraitTypes.size());
+  std::vector<TypePtr> typeList;
+  typeList.reserve(substraitTypes.size());
   for (const auto& type : substraitTypes) {
-    substraitTypeList.emplace_back(parseType(type));
+    typeList.emplace_back(parseType(type));
   }
-  return substraitTypeList;
+  return typeList;
 }
 
 int32_t SubstraitParser::parseReferenceSegment(
@@ -171,7 +104,7 @@ int32_t SubstraitParser::parseReferenceSegment(
     default:
       VELOX_NYI(
           "Substrait conversion not supported for ReferenceSegment '{}'",
-          typeCase);
+          std::to_string(typeCase));
   }
 }
 
@@ -239,4 +172,46 @@ std::string SubstraitParser::mapToVeloxFunction(
   return substraitFunction;
 }
 
+std::vector<std::string> SubstraitParser::getSubFunctionTypes(
+    const std::string& substraitFunction) {
+  // Get the position of ":" in the function name.
+  size_t pos = substraitFunction.find(":");
+  // Get the input types.
+  std::vector<std::string> types;
+  if (pos == std::string::npos || pos == substraitFunction.size() - 1) {
+    return types;
+  }
+  // Extract input types with delimiter.
+  for (;;) {
+    const size_t endPos = substraitFunction.find("_", pos + 1);
+    if (endPos == std::string::npos) {
+      std::string typeName = substraitFunction.substr(pos + 1);
+      if (typeName != "opt" && typeName != "req") {
+        types.emplace_back(typeName);
+      }
+      break;
+    }
+
+    const std::string typeName =
+        substraitFunction.substr(pos + 1, endPos - pos - 1);
+    if (typeName != "opt" && typeName != "req") {
+      types.emplace_back(typeName);
+    }
+    pos = endPos;
+  }
+  return types;
+}
+
+std::vector<TypePtr> SubstraitParser::getInputTypes(
+    const std::string& signature) {
+  std::vector<std::string> typeStrs = getSubFunctionTypes(signature);
+  std::vector<TypePtr> types;
+  types.reserve(typeStrs.size());
+  for (const auto& typeStr : typeStrs) {
+    types.emplace_back(
+        VeloxSubstraitSignature::fromSubstraitSignature(typeStr));
+  }
+  return types;
+}
+
 } // namespace facebook::velox::substrait
diff --git a/velox/substrait/SubstraitParser.h b/velox/substrait/SubstraitParser.h
index a76db95efc1db..8066199529962 100644
--- a/velox/substrait/SubstraitParser.h
+++ b/velox/substrait/SubstraitParser.h
@@ -25,25 +25,20 @@
 #include "velox/substrait/proto/substrait/type.pb.h"
 #include "velox/substrait/proto/substrait/type_expressions.pb.h"
 
+#include "velox/type/Type.h"
+
 namespace facebook::velox::substrait {
 
 /// This class contains some common functions used to parse Substrait
 /// components, and convert them into recognizable representations.
 class SubstraitParser {
  public:
-  /// Stores the type name and nullability.
-  struct SubstraitType {
-    std::string type;
-    bool nullable;
-  };
-
   /// Parse Substrait NamedStruct.
-  std::vector<std::shared_ptr<SubstraitParser::SubstraitType>> parseNamedStruct(
+  std::vector<TypePtr> parseNamedStruct(
       const ::substrait::NamedStruct& namedStruct);
 
   /// Parse Substrait Type.
-  std::shared_ptr<SubstraitType> parseType(
-      const ::substrait::Type& substraitType);
+  TypePtr parseType(const ::substrait::Type& substraitType);
 
   /// Parse Substrait ReferenceSegment.
   int32_t parseReferenceSegment(
@@ -70,6 +65,10 @@ class SubstraitParser {
       const std::unordered_map<uint64_t, std::string>& functionMap,
       uint64_t id) const;
 
+  /// This function is used get the types from the compound name.
+  static std::vector<std::string> getSubFunctionTypes(
+      const std::string& substraitFunction);
+
   /// Find the Velox function name according to the function id
   /// from a pre-constructed function map.
   std::string findVeloxFunction(
@@ -79,6 +78,9 @@ class SubstraitParser {
   /// Map the Substrait function keyword into Velox function keyword.
   std::string mapToVeloxFunction(const std::string& substraitFunction) const;
 
+  /// Get input types from Substrait function signature.
+  static std::vector<TypePtr> getInputTypes(const std::string& signature);
+
  private:
   /// A map used for mapping Substrait function keywords into Velox functions'
   /// keywords. Key: the Substrait function keyword, Value: the Velox function
diff --git a/velox/substrait/SubstraitToVeloxExpr.cpp b/velox/substrait/SubstraitToVeloxExpr.cpp
index e110e6deb5ebc..29a54310170eb 100644
--- a/velox/substrait/SubstraitToVeloxExpr.cpp
+++ b/velox/substrait/SubstraitToVeloxExpr.cpp
@@ -195,10 +195,10 @@ core::TypedExprPtr SubstraitVeloxExprConverter::toVeloxExpr(
   }
   const auto& veloxFunction = substraitParser_.findVeloxFunction(
       functionMap_, substraitFunc.function_reference());
-  std::string typeName =
-      substraitParser_.parseType(substraitFunc.output_type())->type;
   return std::make_shared<const core::CallTypedExpr>(
-      toVeloxType(typeName), std::move(params), veloxFunction);
+      substraitParser_.parseType(substraitFunc.output_type()),
+      std::move(params),
+      veloxFunction);
 }
 
 std::shared_ptr<const core::ConstantTypedExpr>
@@ -233,8 +233,7 @@ SubstraitVeloxExprConverter::toVeloxExpr(
       return std::make_shared<core::ConstantTypedExpr>(
           VARCHAR(), variant(substraitLit.string()));
     case ::substrait::Expression_Literal::LiteralTypeCase::kNull: {
-      auto veloxType =
-          toVeloxType(substraitParser_.parseType(substraitLit.null())->type);
+      auto veloxType = substraitParser_.parseType(substraitLit.null());
       return std::make_shared<core::ConstantTypedExpr>(
           veloxType, variant::null(veloxType->kind()));
     }
@@ -289,8 +288,7 @@ ArrayVectorPtr SubstraitVeloxExprConverter::literalsToArrayVector(
       return makeArrayVector(constructFlatVector<TypeKind::VARCHAR>(
           listLiteral, childSize, VARCHAR(), pool_));
     case ::substrait::Expression_Literal::LiteralTypeCase::kNull: {
-      auto veloxType =
-          toVeloxType(substraitParser_.parseType(listLiteral.null())->type);
+      auto veloxType = substraitParser_.parseType(listLiteral.null());
       auto kind = veloxType->kind();
       return makeArrayVector(VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
           constructFlatVector, kind, listLiteral, childSize, veloxType, pool_));
@@ -325,8 +323,7 @@ ArrayVectorPtr SubstraitVeloxExprConverter::literalsToArrayVector(
 core::TypedExprPtr SubstraitVeloxExprConverter::toVeloxExpr(
     const ::substrait::Expression::Cast& castExpr,
     const RowTypePtr& inputType) {
-  auto substraitType = substraitParser_.parseType(castExpr.type());
-  auto type = toVeloxType(substraitType->type);
+  auto type = substraitParser_.parseType(castExpr.type());
   bool nullOnFailure = isNullOnFailure(castExpr.failure_behavior());
 
   std::vector<core::TypedExprPtr> inputs{
diff --git a/velox/substrait/SubstraitToVeloxExpr.h b/velox/substrait/SubstraitToVeloxExpr.h
index dd5957e8e7857..0c53d82d45535 100644
--- a/velox/substrait/SubstraitToVeloxExpr.h
+++ b/velox/substrait/SubstraitToVeloxExpr.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <fmt/format.h>
 #include "velox/core/Expressions.h"
 #include "velox/substrait/SubstraitParser.h"
 #include "velox/vector/ComplexVector.h"
@@ -81,3 +82,40 @@ class SubstraitVeloxExprConverter {
 };
 
 } // namespace facebook::velox::substrait
+
+template <>
+struct fmt::formatter<substrait::Expression::RexTypeCase> : formatter<int> {
+  auto format(const substrait::Expression::RexTypeCase& s, format_context& ctx)
+      const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<substrait::Expression::Cast::FailureBehavior>
+    : formatter<int> {
+  auto format(
+      const substrait::Expression::Cast::FailureBehavior& s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
+template <>
+struct fmt::formatter<substrait::Expression_FieldReference::ReferenceTypeCase>
+    : formatter<int> {
+  auto format(
+      const substrait::Expression_FieldReference::ReferenceTypeCase& s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<substrait::Expression_Literal::LiteralTypeCase>
+    : formatter<int> {
+  auto format(
+      const substrait::Expression_Literal::LiteralTypeCase& s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/substrait/SubstraitToVeloxPlan.cpp b/velox/substrait/SubstraitToVeloxPlan.cpp
index eca70f98dd15d..5179a00667e81 100644
--- a/velox/substrait/SubstraitToVeloxPlan.cpp
+++ b/velox/substrait/SubstraitToVeloxPlan.cpp
@@ -144,18 +144,20 @@ core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
     const auto& aggFunction = measure.measure();
     auto funcName = substraitParser_->findVeloxFunction(
         functionMap_, aggFunction.function_reference());
+
     std::vector<core::TypedExprPtr> aggParams;
     aggParams.reserve(aggFunction.arguments().size());
     for (const auto& arg : aggFunction.arguments()) {
       aggParams.emplace_back(
           exprConverter_->toVeloxExpr(arg.value(), inputType));
     }
-    auto aggVeloxType = toVeloxType(
-        substraitParser_->parseType(aggFunction.output_type())->type);
+    auto aggVeloxType = substraitParser_->parseType(aggFunction.output_type());
     auto aggExpr = std::make_shared<const core::CallTypedExpr>(
         aggVeloxType, std::move(aggParams), funcName);
+    std::vector<TypePtr> rawInputTypes = SubstraitParser::getInputTypes(
+        findFunction(aggFunction.function_reference()));
     aggregates.emplace_back(
-        core::AggregationNode::Aggregate{aggExpr, {}, mask, {}, {}});
+        core::AggregationNode::Aggregate{aggExpr, rawInputTypes, mask, {}, {}});
   }
 
   bool ignoreNullKeys = false;
@@ -369,11 +371,7 @@ core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
     for (const auto& name : baseSchema.names()) {
       colNameList.emplace_back(name);
     }
-    auto substraitTypeList = substraitParser_->parseNamedStruct(baseSchema);
-    veloxTypeList.reserve(substraitTypeList.size());
-    for (const auto& substraitType : substraitTypeList) {
-      veloxTypeList.emplace_back(toVeloxType(substraitType->type));
-    }
+    veloxTypeList = substraitParser_->parseNamedStruct(baseSchema);
   }
 
   // Parse local files
@@ -559,7 +557,7 @@ core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
     const ::substrait::Plan& substraitPlan) {
   VELOX_CHECK(
       checkTypeExtension(substraitPlan),
-      "The type extension only have unknown type.")
+      "The type extension only have unknown type.");
   // Construct the function map based on the Substrait representation.
   constructFunctionMap(substraitPlan);
 
diff --git a/velox/substrait/SubstraitToVeloxPlan.h b/velox/substrait/SubstraitToVeloxPlan.h
index c76eca3fdb7f1..c4a951c3d3e41 100644
--- a/velox/substrait/SubstraitToVeloxPlan.h
+++ b/velox/substrait/SubstraitToVeloxPlan.h
@@ -17,13 +17,10 @@
 #pragma once
 
 #include "velox/connectors/hive/HiveConnector.h"
-#include "velox/core/PlanNode.h"
-#include "velox/substrait/SubstraitToVeloxExpr.h"
-
-#ifndef VELOX_ENABLE_BACKWARD_COMPATIBILITY
 #include "velox/connectors/hive/TableHandle.h"
+#include "velox/core/PlanNode.h"
 #include "velox/dwio/common/Options.h"
-#endif
+#include "velox/substrait/SubstraitToVeloxExpr.h"
 
 namespace facebook::velox::substrait {
 
diff --git a/velox/substrait/TypeUtils.cpp b/velox/substrait/TypeUtils.cpp
index add6d7692205a..a179eebc49e1a 100644
--- a/velox/substrait/TypeUtils.cpp
+++ b/velox/substrait/TypeUtils.cpp
@@ -64,67 +64,4 @@ std::string_view getNameBeforeDelimiter(
   }
   return std::string_view(compoundName.data(), pos);
 }
-
-TypePtr toVeloxType(const std::string& typeName) {
-  VELOX_CHECK(!typeName.empty(), "Cannot convert empty string to Velox type.");
-
-  auto type = std::string(getNameBeforeDelimiter(typeName, "<"));
-  if (DATE()->toString() == type) {
-    return DATE();
-  }
-  auto typeKind = mapNameToTypeKind(type);
-  switch (typeKind) {
-    case TypeKind::BOOLEAN:
-      return BOOLEAN();
-    case TypeKind::TINYINT:
-      return TINYINT();
-    case TypeKind::SMALLINT:
-      return SMALLINT();
-    case TypeKind::INTEGER:
-      return INTEGER();
-    case TypeKind::BIGINT:
-      return BIGINT();
-    case TypeKind::REAL:
-      return REAL();
-    case TypeKind::DOUBLE:
-      return DOUBLE();
-    case TypeKind::VARCHAR:
-      return VARCHAR();
-    case TypeKind::VARBINARY:
-      return VARBINARY();
-    case TypeKind::ARRAY: {
-      auto fieldTypes = getTypesFromCompoundName(typeName);
-      VELOX_CHECK_EQ(
-          fieldTypes.size(), 1, "The size of ARRAY type should be only one.");
-      return ARRAY(toVeloxType(std::string(fieldTypes[0])));
-    }
-    case TypeKind::MAP: {
-      auto fieldTypes = getTypesFromCompoundName(typeName);
-      VELOX_CHECK_EQ(
-          fieldTypes.size(), 2, "The size of MAP type should be two.");
-      auto keyType = toVeloxType(std::string(fieldTypes[0]));
-      auto valueType = toVeloxType(std::string(fieldTypes[1]));
-      return MAP(keyType, valueType);
-    }
-    case TypeKind::ROW: {
-      auto fieldTypes = getTypesFromCompoundName(typeName);
-      VELOX_CHECK(
-          !fieldTypes.empty(),
-          "Converting empty ROW type from Substrait to Velox is not supported.");
-
-      std::vector<TypePtr> types;
-      std::vector<std::string> names;
-      for (int idx = 0; idx < fieldTypes.size(); idx++) {
-        names.emplace_back("col_" + std::to_string(idx));
-        types.emplace_back(toVeloxType(std::string(fieldTypes[idx])));
-      }
-      return ROW(std::move(names), std::move(types));
-    }
-    case TypeKind::UNKNOWN:
-      return UNKNOWN();
-    default:
-      VELOX_NYI("Velox type conversion not supported for type {}.", typeName);
-  }
-}
-
 } // namespace facebook::velox::substrait
diff --git a/velox/substrait/TypeUtils.h b/velox/substrait/TypeUtils.h
index 3a649eef674c0..599af3dd53b50 100644
--- a/velox/substrait/TypeUtils.h
+++ b/velox/substrait/TypeUtils.h
@@ -18,9 +18,6 @@
 
 namespace facebook::velox::substrait {
 
-/// Return the Velox type according to the typename.
-TypePtr toVeloxType(const std::string& typeName);
-
 std::string_view getNameBeforeDelimiter(
     const std::string& compoundName,
     const std::string& delimiter);
diff --git a/velox/substrait/VariantToVectorConverter.cpp b/velox/substrait/VariantToVectorConverter.cpp
index c058d807a9094..33194f6ac1663 100644
--- a/velox/substrait/VariantToVectorConverter.cpp
+++ b/velox/substrait/VariantToVectorConverter.cpp
@@ -60,7 +60,7 @@ VectorPtr setVectorFromVariantsByKind<TypeKind::VARCHAR>(
     if (values[i].isNull()) {
       flatVector->setNull(i, true);
     } else {
-      flatVector->set(i, StringView(values[i].value<Varchar>()));
+      flatVector->set(i, StringView(values[i].value<TypeKind::VARCHAR>()));
     }
   }
   return flatVector;
diff --git a/velox/substrait/VeloxSubstraitSignature.cpp b/velox/substrait/VeloxSubstraitSignature.cpp
index ea20742b664a2..0a709c87ac07f 100644
--- a/velox/substrait/VeloxSubstraitSignature.cpp
+++ b/velox/substrait/VeloxSubstraitSignature.cpp
@@ -59,6 +59,58 @@ std::string VeloxSubstraitSignature::toSubstraitSignature(const TypePtr& type) {
   }
 }
 
+// static
+TypePtr VeloxSubstraitSignature::fromSubstraitSignature(
+    const std::string& signature) {
+  if (signature == "bool") {
+    return BOOLEAN();
+  }
+
+  if (signature == "i8") {
+    return TINYINT();
+  }
+
+  if (signature == "i16") {
+    return SMALLINT();
+  }
+
+  if (signature == "i32") {
+    return INTEGER();
+  }
+
+  if (signature == "i64") {
+    return BIGINT();
+  }
+
+  if (signature == "fp32") {
+    return REAL();
+  }
+
+  if (signature == "fp64") {
+    return DOUBLE();
+  }
+
+  if (signature == "str") {
+    return VARCHAR();
+  }
+
+  if (signature == "vbin") {
+    return VARBINARY();
+  }
+
+  if (signature == "ts") {
+    return TIMESTAMP();
+  }
+
+  if (signature == "date") {
+    return DATE();
+  }
+
+  VELOX_UNSUPPORTED(
+      "Substrait type signature conversion to Velox type not supported for {}.",
+      signature);
+}
+
 std::string VeloxSubstraitSignature::toSubstraitSignature(
     const std::string& functionName,
     const std::vector<TypePtr>& arguments) {
diff --git a/velox/substrait/VeloxSubstraitSignature.h b/velox/substrait/VeloxSubstraitSignature.h
index aa8304a4db576..0a4baed478ebe 100644
--- a/velox/substrait/VeloxSubstraitSignature.h
+++ b/velox/substrait/VeloxSubstraitSignature.h
@@ -31,6 +31,9 @@ class VeloxSubstraitSignature {
   /// https://substrait.io/extensions/#function-signature-compound-names.
   static std::string toSubstraitSignature(const TypePtr& type);
 
+  /// Given a substrait type signature, return the Velox type.
+  static TypePtr fromSubstraitSignature(const std::string& signature);
+
   /// Given a velox scalar function name and argument types, return the
   /// substrait function signature.
   static std::string toSubstraitSignature(
diff --git a/velox/substrait/VeloxToSubstraitPlan.cpp b/velox/substrait/VeloxToSubstraitPlan.cpp
index b8bcbfcb08aeb..4022f77d0eb9f 100644
--- a/velox/substrait/VeloxToSubstraitPlan.cpp
+++ b/velox/substrait/VeloxToSubstraitPlan.cpp
@@ -290,7 +290,7 @@ void VeloxToSubstraitPlanConvertor::toSubstrait(
     }
 
     auto referenceNumber = extensionCollector_->getReferenceNumber(
-        funName, arguments, aggregateNode->step());
+        funName, aggregate.rawInputTypes, aggregateNode->step());
 
     aggFunction->set_function_reference(referenceNumber);
 
@@ -320,7 +320,7 @@ void VeloxToSubstraitPlanConvertor::toSubstrait(
 
   VELOX_CHECK(
       !orderByNode->isPartial(),
-      "Substrait doesn't support partial order by yet")
+      "Substrait doesn't support partial order by yet");
   sortRel->mutable_common()->mutable_direct();
 }
 
@@ -343,7 +343,7 @@ void VeloxToSubstraitPlanConvertor::toSubstrait(
   sortRel->mutable_common()->mutable_direct();
 
   VELOX_CHECK(
-      !topNNode->isPartial(), "Substrait doesn't support partial topN yet")
+      !topNNode->isPartial(), "Substrait doesn't support partial topN yet");
 
   fetchRel->set_offset(0);
   fetchRel->set_count(topNNode->count());
@@ -384,7 +384,7 @@ void VeloxToSubstraitPlanConvertor::toSubstrait(
   fetchRel->set_count(limitNode->count());
 
   VELOX_CHECK(
-      !limitNode->isPartial(), "Substrait doesn't support partial limit yet")
+      !limitNode->isPartial(), "Substrait doesn't support partial limit yet");
 
   fetchRel->mutable_common()->mutable_direct();
 }
diff --git a/velox/substrait/tests/CMakeLists.txt b/velox/substrait/tests/CMakeLists.txt
index f453fb61b7c43..7f5498a0d6bfe 100644
--- a/velox/substrait/tests/CMakeLists.txt
+++ b/velox/substrait/tests/CMakeLists.txt
@@ -14,14 +14,14 @@
 
 add_executable(
   velox_plan_conversion_test
-  Substrait2VeloxPlanConversionTest.cpp
-  Substrait2VeloxValuesNodeConversionTest.cpp
   FunctionTest.cpp
   JsonToProtoConverter.cpp
+  Substrait2VeloxPlanConversionTest.cpp
+  Substrait2VeloxValuesNodeConversionTest.cpp
+  SubstraitExtensionCollectorTest.cpp
   VeloxSubstraitRoundTripTest.cpp
   VeloxToSubstraitTypeTest.cpp
-  VeloxSubstraitSignatureTest.cpp
-  SubstraitExtensionCollectorTest.cpp)
+  VeloxSubstraitSignatureTest.cpp)
 
 add_dependencies(velox_plan_conversion_test velox_substrait_plan_converter)
 
@@ -56,8 +56,8 @@ target_link_libraries(
   Boost::regex
   Boost::thread
   Boost::system
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   Folly::folly
   gflags::gflags
   glog::glog
diff --git a/velox/substrait/tests/FunctionTest.cpp b/velox/substrait/tests/FunctionTest.cpp
index 2a200453bb33f..c3928d92d9b07 100644
--- a/velox/substrait/tests/FunctionTest.cpp
+++ b/velox/substrait/tests/FunctionTest.cpp
@@ -19,17 +19,11 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h"
 
+#include "velox/core/QueryCtx.h"
 #include "velox/substrait/SubstraitToVeloxPlan.h"
 #include "velox/substrait/TypeUtils.h"
 #include "velox/substrait/VariantToVectorConverter.h"
 
-#ifndef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-#include "velox/core/QueryCtx.h"
-#else
-#include "velox/common/base/Fs.h"
-#include "velox/substrait/VeloxToSubstraitType.h"
-#endif
-
 using namespace facebook::velox;
 using namespace facebook::velox::test;
 using namespace facebook::velox::substrait;
@@ -37,11 +31,14 @@ namespace vestrait = facebook::velox::substrait;
 
 class FunctionTest : public ::testing::Test {
  protected:
-  std::shared_ptr<core::QueryCtx> queryCtx_ =
-      std::make_shared<core::QueryCtx>();
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<core::QueryCtx> queryCtx_ = core::QueryCtx::create();
 
   std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::addDefaultLeafMemoryPool();
+      memory::memoryManager()->addLeafPool();
 
   std::shared_ptr<vestrait::SubstraitParser> substraitParser_ =
       std::make_shared<vestrait::SubstraitParser>();
@@ -212,3 +209,34 @@ TEST_F(FunctionTest, setVectorFromVariants) {
   ASSERT_EQ(20, resultVec->asFlatVector<int32_t>()->valueAt(0));
   ASSERT_EQ(30, resultVec->asFlatVector<int32_t>()->valueAt(1));
 }
+
+TEST_F(FunctionTest, getFunctionType) {
+  std::vector<std::string> types =
+      SubstraitParser::getSubFunctionTypes("sum:opt_i32");
+  ASSERT_EQ("i32", types[0]);
+
+  types = SubstraitParser::getSubFunctionTypes("sum:i32");
+  ASSERT_EQ("i32", types[0]);
+
+  types = SubstraitParser::getSubFunctionTypes("split:req_str_str");
+  ASSERT_EQ(2, types.size());
+  ASSERT_EQ("str", types[0]);
+  ASSERT_EQ("str", types[1]);
+}
+
+TEST_F(FunctionTest, getInputTypes) {
+  std::vector<TypePtr> types = SubstraitParser::getInputTypes("sum:opt_i32");
+  ASSERT_EQ(types[0]->kind(), TypeKind::INTEGER);
+
+  types = SubstraitParser::getInputTypes("and:opt_bool_bool");
+  ASSERT_EQ(2, types.size());
+  ASSERT_EQ(types[0]->kind(), TypeKind::BOOLEAN);
+  ASSERT_EQ(types[1]->kind(), TypeKind::BOOLEAN);
+
+  types = SubstraitParser::getInputTypes("function:i32_str_ts_date_fp64");
+  ASSERT_EQ(types[0]->kind(), TypeKind::INTEGER);
+  ASSERT_EQ(types[1]->kind(), TypeKind::VARCHAR);
+  ASSERT_EQ(types[2]->kind(), TypeKind::TIMESTAMP);
+  ASSERT_EQ(types[3]->kind(), TypeKind::INTEGER);
+  ASSERT_EQ(types[4]->kind(), TypeKind::DOUBLE);
+}
diff --git a/velox/substrait/tests/JsonToProtoConverter.cpp b/velox/substrait/tests/JsonToProtoConverter.cpp
index 356e296b0c027..26db710abce9f 100644
--- a/velox/substrait/tests/JsonToProtoConverter.cpp
+++ b/velox/substrait/tests/JsonToProtoConverter.cpp
@@ -32,7 +32,6 @@ void JsonToProtoConverter::readFromFile(
   auto status = google::protobuf::util::JsonStringToMessage(msgData, &msg);
   VELOX_CHECK(
       status.ok(),
-      "Failed to parse Substrait JSON: {} {}",
-      status.code(),
-      status.message());
+      "Failed to parse Substrait JSON: {}",
+      std::string_view(status.message().data(), status.message().size()));
 }
diff --git a/velox/substrait/tests/Substrait2VeloxPlanConversionTest.cpp b/velox/substrait/tests/Substrait2VeloxPlanConversionTest.cpp
index a1a7354783569..debca68a75d6e 100644
--- a/velox/substrait/tests/Substrait2VeloxPlanConversionTest.cpp
+++ b/velox/substrait/tests/Substrait2VeloxPlanConversionTest.cpp
@@ -33,6 +33,10 @@ using namespace facebook::velox::exec;
 class Substrait2VeloxPlanConversionTest
     : public exec::test::HiveConnectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
   makeSplits(
       const facebook::velox::substrait::SubstraitVeloxPlanConverter& converter,
@@ -53,7 +57,7 @@ class Substrait2VeloxPlanConversionTest
     splits.reserve(paths.size());
 
     for (int i = 0; i < paths.size(); i++) {
-      auto path = fmt::format("{}{}", tmpDir_->path, paths[i]);
+      auto path = fmt::format("{}{}", tmpDir_->getPath(), paths[i]);
       auto start = starts[i];
       auto length = lengths[i];
       auto split = facebook::velox::exec::test::HiveConnectorSplitBuilder(path)
@@ -117,7 +121,8 @@ TEST_F(Substrait2VeloxPlanConversionTest, DISABLED_q6) {
            VARCHAR(),
            VARCHAR(),
            VARCHAR()});
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   std::vector<VectorPtr> vectors;
   // TPC-H lineitem table has 16 columns.
   int colNum = 16;
@@ -262,7 +267,7 @@ TEST_F(Substrait2VeloxPlanConversionTest, DISABLED_q6) {
 
   // Write data into an ORC file.
   writeToFile(
-      tmpDir_->path + "/mock_lineitem.orc",
+      tmpDir_->getPath() + "/mock_lineitem.orc",
       {makeRowVector(type->names(), vectors)});
 
   // Find and deserialize Substrait plan json file.
diff --git a/velox/substrait/tests/VeloxSubstraitRoundTripTest.cpp b/velox/substrait/tests/VeloxSubstraitRoundTripTest.cpp
index 27c4d2872bd12..d9af98c2e7bb8 100644
--- a/velox/substrait/tests/VeloxSubstraitRoundTripTest.cpp
+++ b/velox/substrait/tests/VeloxSubstraitRoundTripTest.cpp
@@ -105,7 +105,7 @@ TEST_F(VeloxSubstraitRoundTripTest, project) {
   createDuckDbTable(vectors);
   auto plan =
       PlanBuilder().values(vectors).project({"c0 + c1", "c1 / c2"}).planNode();
-  assertPlanConversion(plan, "SELECT c0 + c1, c1 / c2 FROM tmp");
+  assertPlanConversion(plan, "SELECT c0 + c1, c1 // c2 FROM tmp");
 }
 
 TEST_F(VeloxSubstraitRoundTripTest, cast) {
@@ -509,6 +509,6 @@ TEST_F(VeloxSubstraitRoundTripTest, dateType) {
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/substrait/tests/VeloxSubstraitSignatureTest.cpp b/velox/substrait/tests/VeloxSubstraitSignatureTest.cpp
index 9bcd037ef7595..e8db267e2565d 100644
--- a/velox/substrait/tests/VeloxSubstraitSignatureTest.cpp
+++ b/velox/substrait/tests/VeloxSubstraitSignatureTest.cpp
@@ -30,6 +30,10 @@ class VeloxSubstraitSignatureTest : public ::testing::Test {
     functions::prestosql::registerAllScalarFunctions();
   }
 
+  static TypePtr fromSubstraitSignature(const std::string& signature) {
+    return VeloxSubstraitSignature::fromSubstraitSignature(signature);
+  }
+
   static std::string toSubstraitSignature(const TypePtr& type) {
     return VeloxSubstraitSignature::toSubstraitSignature(type);
   }
@@ -106,4 +110,19 @@ TEST_F(
   ASSERT_ANY_THROW(toSubstraitSignature("transform_keys", std::move(types)));
 }
 
+TEST_F(VeloxSubstraitSignatureTest, fromSubstraitSignature) {
+  ASSERT_EQ(fromSubstraitSignature("bool")->kind(), TypeKind::BOOLEAN);
+  ASSERT_EQ(fromSubstraitSignature("i8")->kind(), TypeKind::TINYINT);
+  ASSERT_EQ(fromSubstraitSignature("i16")->kind(), TypeKind::SMALLINT);
+  ASSERT_EQ(fromSubstraitSignature("i32")->kind(), TypeKind::INTEGER);
+  ASSERT_EQ(fromSubstraitSignature("i64")->kind(), TypeKind::BIGINT);
+  ASSERT_EQ(fromSubstraitSignature("fp32")->kind(), TypeKind::REAL);
+  ASSERT_EQ(fromSubstraitSignature("fp64")->kind(), TypeKind::DOUBLE);
+  ASSERT_EQ(fromSubstraitSignature("str")->kind(), TypeKind::VARCHAR);
+  ASSERT_EQ(fromSubstraitSignature("vbin")->kind(), TypeKind::VARBINARY);
+  ASSERT_EQ(fromSubstraitSignature("ts")->kind(), TypeKind::TIMESTAMP);
+  ASSERT_EQ(fromSubstraitSignature("date")->kind(), TypeKind::INTEGER);
+  ASSERT_ANY_THROW(fromSubstraitSignature("other")->kind());
+}
+
 } // namespace facebook::velox::substrait::test
diff --git a/velox/substrait/tests/VeloxToSubstraitTypeTest.cpp b/velox/substrait/tests/VeloxToSubstraitTypeTest.cpp
index 9970bff0d5145..2e0e36fe4b10d 100644
--- a/velox/substrait/tests/VeloxToSubstraitTypeTest.cpp
+++ b/velox/substrait/tests/VeloxToSubstraitTypeTest.cpp
@@ -32,8 +32,7 @@ class VeloxToSubstraitTypeTest : public ::testing::Test {
 
     google::protobuf::Arena arena;
     auto substraitType = typeConvertor_->toSubstraitType(arena, type);
-    auto sameType =
-        toVeloxType(substraitParser_->parseType(substraitType)->type);
+    auto sameType = substraitParser_->parseType(substraitType);
     ASSERT_TRUE(sameType->kindEquals(type))
         << "Expected: " << type->toString()
         << ", but got: " << sameType->toString();
@@ -66,6 +65,6 @@ TEST_F(VeloxToSubstraitTypeTest, basic) {
   testTypeConversion(
       ROW({"a", "b", "c"},
           {BIGINT(), ROW({"x", "y"}, {BOOLEAN(), VARCHAR()}), REAL()}));
-  ASSERT_ANY_THROW(testTypeConversion(ROW({}, {})));
+  testTypeConversion(ROW({}, {}));
 }
 } // namespace facebook::velox::substrait::test
diff --git a/velox/tpch/gen/CMakeLists.txt b/velox/tpch/gen/CMakeLists.txt
index 0ea05a1f5780f..eada0a24676d6 100644
--- a/velox/tpch/gen/CMakeLists.txt
+++ b/velox/tpch/gen/CMakeLists.txt
@@ -11,9 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_tpch_gen TpchGen.cpp DBGenIterator.cpp)
 
-target_link_libraries(velox_tpch_gen velox_memory velox_vector dbgen duckdb)
+add_subdirectory(dbgen)
+
+velox_add_library(velox_tpch_gen DBGenIterator.cpp TpchGen.cpp)
+
+velox_include_directories(velox_tpch_gen PRIVATE dbgen/include)
+
+velox_link_libraries(velox_tpch_gen velox_memory velox_vector dbgen)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/tpch/gen/DBGenIterator.cpp b/velox/tpch/gen/DBGenIterator.cpp
index 9a0cd92bb8078..7e39d40f35848 100644
--- a/velox/tpch/gen/DBGenIterator.cpp
+++ b/velox/tpch/gen/DBGenIterator.cpp
@@ -17,8 +17,8 @@
 #include "velox/tpch/gen/DBGenIterator.h"
 
 #include <folly/Singleton.h>
+#include <velox/tpch/gen/dbgen/include/dbgen/dbgen_gunk.hpp>
 #include "velox/common/base/Exceptions.h"
-#include "velox/external/duckdb/tpch/dbgen/include/dbgen/dbgen_gunk.hpp"
 
 namespace facebook::velox::tpch {
 
diff --git a/velox/tpch/gen/DBGenIterator.h b/velox/tpch/gen/DBGenIterator.h
index 2ce61c4906438..6771510ec2b89 100644
--- a/velox/tpch/gen/DBGenIterator.h
+++ b/velox/tpch/gen/DBGenIterator.h
@@ -19,8 +19,8 @@
 #include <memory>
 #include <mutex>
 
-#include "velox/external/duckdb/tpch/dbgen/include/dbgen/dss.h"
-#include "velox/external/duckdb/tpch/dbgen/include/dbgen/dsstypes.h"
+#include <velox/tpch/gen/dbgen/include/dbgen/dss.h>
+#include <velox/tpch/gen/dbgen/include/dbgen/dsstypes.h>
 
 namespace facebook::velox::tpch {
 
diff --git a/velox/tpch/gen/TpchGen.cpp b/velox/tpch/gen/TpchGen.cpp
index cefb4bd68f98c..4c9420b419af7 100644
--- a/velox/tpch/gen/TpchGen.cpp
+++ b/velox/tpch/gen/TpchGen.cpp
@@ -15,9 +15,7 @@
  */
 
 #include "velox/tpch/gen/TpchGen.h"
-#include "velox/external/duckdb/tpch/dbgen/include/dbgen/dbgen.hpp"
-#include "velox/external/duckdb/tpch/dbgen/include/dbgen/dss.h"
-#include "velox/external/duckdb/tpch/dbgen/include/dbgen/dsstypes.h"
+#include <velox/tpch/gen/dbgen/include/tpch_constants.hpp>
 #include "velox/tpch/gen/DBGenIterator.h"
 #include "velox/vector/FlatVector.h"
 
@@ -752,7 +750,11 @@ RowVectorPtr genTpchRegion(
 }
 
 std::string getQuery(int query) {
-  auto queryString = ::tpch::DBGenWrapper::GetQuery(query);
+  if (query <= 0 || query > TPCH_QUERIES_COUNT) {
+    VELOX_FAIL("Out of range TPC-H query number {}", query);
+  }
+
+  auto queryString = std::string(TPCH_QUERIES[query - 1]);
   // Output of GetQuery() has a new line and a semi-colon. These need to be
   // removed in order to use the query string in a subquery
   queryString.pop_back(); // remove new line
diff --git a/velox/tpch/gen/dbgen/CMakeLists.txt b/velox/tpch/gen/dbgen/CMakeLists.txt
new file mode 100644
index 0000000000000..0f39ad339e04d
--- /dev/null
+++ b/velox/tpch/gen/dbgen/CMakeLists.txt
@@ -0,0 +1,35 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+cmake_minimum_required(VERSION 3.0.0)
+cmake_policy(SET CMP0063 NEW)
+
+project(dbgen CXX C)
+
+add_library(
+  dbgen STATIC
+  dbgen.cpp
+  dbgen_gunk.cpp
+  bm_utils.cpp
+  build.cpp
+  permute.cpp
+  rnd.cpp
+  rng64.cpp
+  speed_seed.cpp
+  text.cpp)
+
+target_compile_definitions(dbgen PRIVATE DBNAME=dss MAC ORACLE TPCH)
+target_include_directories(dbgen PRIVATE include)
+
+# Suppress warnings when compiling dbgen.
+target_compile_options(dbgen PRIVATE -w)
diff --git a/velox/tpch/gen/dbgen/bm_utils.cpp b/velox/tpch/gen/dbgen/bm_utils.cpp
new file mode 100644
index 0000000000000..b36d91179c3a1
--- /dev/null
+++ b/velox/tpch/gen/dbgen/bm_utils.cpp
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+/*
+ *
+ * Various routines that handle distributions, value selections and
+ * seed value management for the DSS benchmark. Current functions:
+ * tpch_env_config -- set config vars with optional environment override
+ * tpch_a_rnd(min, max) -- random alphanumeric within length range
+ * pick_str(size, set) -- select a string from the set of size
+ * read_dist(file, name, distribution *) -- read named dist from file
+ * tbl_open(path, mode) -- std fopen with lifenoise
+ * julian(date) -- julian date correction
+ * rowcnt(tbl) -- proper scaling of given table
+ * e_str(set, min, max) -- build an embedded str
+ * agg_str() -- build a string from the named set
+ * dsscasecmp() -- version of strcasecmp()
+ * dssncasecmp() -- version of strncasecmp()
+ * getopt()
+ * set_state() -- initialize the RNG
+ */
+
+#include "dbgen/config.h" // @manual
+#include "dbgen/dss.h" // @manual
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#ifdef HP
+#include <strings.h>
+#endif /* HP */
+#include <ctype.h>
+#include <math.h>
+#ifndef _POSIX_SOURCE
+// #include <malloc.h>
+#endif /* POSIX_SOURCE */
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+/* Lines added by Chuck McDevitt for WIN32 support */
+#ifdef WIN32
+#ifndef _POSIX_
+#include <io.h> // @manual
+#ifndef S_ISREG
+#define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
+#define S_ISFIFO(m) (((m) & _S_IFMT) == _S_IFIFO)
+#endif
+#endif
+#ifndef stat
+#define stat _stat
+#endif
+#ifndef fdopen
+#define fdopen _fdopen
+#endif
+#ifndef open
+#define open _open
+#endif
+#ifndef O_RDONLY
+#define O_RDONLY _O_RDONLY
+#endif
+#ifndef O_WRONLY
+#define O_WRONLY _O_WRONLY
+#endif
+#ifndef O_CREAT
+#define O_CREAT _O_CREAT
+#endif
+#endif
+/* End of lines added by Chuck McDevitt for WIN32 support */
+#include "dbgen/dsstypes.h" // @manual
+
+static char alpha_num[65] =
+    "0123456789abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ,";
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define PROTO(s) s
+#else
+#define PROTO(s) ()
+#endif
+
+#ifndef WIN32
+char* getenv PROTO((const char* name));
+#endif
+void usage();
+void permute_dist(distribution* d, seed_t* seed);
+
+/*
+ * tpch_env_config: look for a environmental variable setting and return its
+ * value; otherwise return the default supplied
+ */
+const char* tpch_env_config(const char* var, const char* dflt) {
+  static char* evar;
+
+  if ((evar = getenv(var)) != NULL)
+    return (evar);
+  else
+    return (dflt);
+}
+
+/*
+ * generate a random string with length randomly selected in [min, max]
+ * and using the characters in alphanum (currently includes a space
+ * and comma)
+ */
+void tpch_a_rnd(int min, int max, seed_t* seed, char* dest) {
+  DSS_HUGE i, len, char_int;
+
+  RANDOM(len, min, max, seed);
+  for (i = 0; i < len; i++) {
+    if (i % 5 == 0)
+      RANDOM(char_int, 0, MAX_LONG, seed);
+    *(dest + i) = alpha_num[char_int & 077];
+    char_int >>= 6;
+  }
+  *(dest + len) = '\0';
+  return;
+}
+
+/*
+ * embed a randomly selected member of distribution d in alpha-numeric
+ * noise of a length rendomly selected between min and max at a random
+ * position
+ */
+void e_str(distribution* d, int min, int max, seed_t* seed, char* dest) {
+  char strtmp[MAXAGG_LEN + 1];
+  DSS_HUGE loc;
+  int len;
+
+  tpch_a_rnd(min, max, seed, dest);
+  pick_str(d, seed, strtmp);
+  len = (int)strlen(strtmp);
+  RANDOM(loc, 0, ((int)strlen(dest) - 1 - len), seed);
+  memcpy(dest + loc, strtmp, sizeof(char) * len);
+
+  return;
+}
+
+/*
+ * return the string associate with the LSB of a uniformly selected
+ * long in [1, max] where max is determined by the distribution
+ * being queried
+ */
+int pick_str(distribution* s, seed_t* seed, char* target) {
+  long i = 0;
+  DSS_HUGE j;
+
+  RANDOM(j, 1, s->list[s->count - 1].weight, seed);
+  while (s->list[i].weight < j)
+    i++;
+  strcpy(target, s->list[i].text);
+  return (i);
+}
+
+/*
+ * unjulian (long date) -- return(date - STARTDATE)
+ */
+long unjulian(long date) {
+  int i;
+  long res = 0;
+
+  for (i = STARTDATE / 1000; i < date / 1000; i++)
+    res += 365 + LEAP(i);
+  res += date % 1000 - 1;
+
+  return (res);
+}
+
+long julian(long date) {
+  long offset;
+  long result;
+  long yr;
+  long yend;
+
+  offset = date - STARTDATE;
+  result = STARTDATE;
+
+#ifdef WIN32
+/* Disable warning about conditional expression is constant */
+#pragma warning(disable : 4127)
+#endif
+
+  while (1) {
+#ifdef WIN32
+#pragma warning(default : 4127)
+#endif
+    yr = result / 1000;
+    yend = yr * 1000 + 365 + LEAP(yr);
+    if (result + offset > yend) /* overflow into next year */
+    {
+      offset -= yend - result + 1;
+      result += 1000;
+      continue;
+    } else
+      break;
+  }
+  return (result + offset);
+}
+
+#include "dbgen/dists_dss.h" // @manual
+
+static char
+read_line_into_buffer(char* buffer, size_t bufsiz, const char** src) {
+  size_t count = 0;
+  while (**src && count < bufsiz - 1) {
+    buffer[count++] = **src;
+    if (**src == '\n') {
+      (*src)++;
+      break;
+    }
+    (*src)++;
+  }
+  buffer[count] = '\0';
+  return **src;
+}
+
+/*
+ * load a distribution from a flat file into the target structure;
+ * should be rewritten to allow multiple dists in a file
+ */
+void read_dist(const char* path, const char* name, distribution* target) {
+  const char* src = dists_dss;
+  char line[256], token[256], *c;
+  long weight, count = 0, name_set = 0;
+
+  while (read_line_into_buffer(line, sizeof(line), &src)) {
+    if ((c = strchr(line, '\n')) != NULL)
+      *c = '\0';
+    if ((c = strchr(line, '#')) != NULL)
+      *c = '\0';
+    if (*line == '\0')
+      continue;
+
+    if (!name_set) {
+      if (dsscasecmp(strtok(line, "\n\t "), "BEGIN"))
+        continue;
+      if (dsscasecmp(strtok(NULL, "\n\t "), name))
+        continue;
+      name_set = 1;
+      continue;
+    } else {
+      if (!dssncasecmp(line, "END", 3)) {
+        return;
+      }
+    }
+
+    if (sscanf(line, "%[^|]|%ld", token, &weight) != 2)
+      continue;
+
+    if (!dsscasecmp(token, "count")) {
+      target->count = weight;
+      target->list = (set_member*)malloc((size_t)(weight * sizeof(set_member)));
+      MALLOC_CHECK(target->list);
+      target->max = 0;
+      continue;
+    }
+    target->list[count].text = (char*)malloc((size_t)((int)strlen(token) + 1));
+    MALLOC_CHECK(target->list[count].text);
+    strcpy(target->list[count].text, token);
+    target->max += weight;
+    target->list[count].weight = target->max;
+
+    count += 1;
+  } /* while fgets() */
+
+  if (count != target->count) {
+    fprintf(stderr, "Read error on dist '%s'\n", name);
+    exit(1);
+  }
+  target->permute = (long*)NULL;
+  return;
+}
+
+/*
+ * agg_str(set, count) build an aggregated string from count unique
+ * selections taken from set
+ */
+void agg_str(distribution* set, long count, seed_t* seed, char* dest) {
+  distribution* d;
+  int i;
+
+  d = set;
+  *dest = '\0';
+
+  permute_dist(d, seed);
+  for (i = 0; i < count; i++) {
+    strcat(dest, DIST_MEMBER(set, DIST_PERMUTE(d, i)));
+    strcat(dest, " ");
+  }
+  *(dest + (int)strlen(dest) - 1) = '\0';
+
+  return;
+}
+
+long dssncasecmp(const char* s1, const char* s2, int n) {
+  for (; n > 0; ++s1, ++s2, --n)
+    if (tolower(*s1) != tolower(*s2))
+      return ((tolower(*s1) < tolower(*s2)) ? -1 : 1);
+    else if (*s1 == '\0')
+      return (0);
+  return (0);
+}
+
+long dsscasecmp(const char* s1, const char* s2) {
+  for (; tolower(*s1) == tolower(*s2); ++s1, ++s2)
+    if (*s1 == '\0')
+      return (0);
+  return ((tolower(*s1) < tolower(*s2)) ? -1 : 1);
+}
+
+#ifndef STDLIB_HAS_GETOPT
+int optind = 0;
+int opterr = 0;
+char* optarg = NULL;
+
+int getopt(int ac, char** av, char* opt) {
+  static char* nextchar = NULL;
+  char* cp;
+  char hold;
+
+  if (optarg == NULL) {
+    optarg = (char*)malloc(BUFSIZ);
+    MALLOC_CHECK(optarg);
+  }
+
+  if (!nextchar || *nextchar == '\0') {
+    optind++;
+    if (optind == ac)
+      return (-1);
+    nextchar = av[optind];
+    if (*nextchar != '-')
+      return (-1);
+    nextchar += 1;
+  }
+
+  if (nextchar && *nextchar == '-') /* -- termination */
+  {
+    optind++;
+    return (-1);
+  } else /* found an option */
+  {
+    cp = strchr(opt, *nextchar);
+    nextchar += 1;
+    if (cp == NULL) /* not defined for this run */
+      return ('?');
+    if (*(cp + 1) == ':') /* option takes an argument */
+    {
+      if (*nextchar) {
+        hold = *cp;
+        cp = optarg;
+        while (*nextchar)
+          *cp++ = *nextchar++;
+        *cp = '\0';
+        *cp = hold;
+      } else /* white space separated, use next arg */
+      {
+        if (++optind == ac)
+          return ('?');
+        strcpy(optarg, av[optind]);
+      }
+      nextchar = NULL;
+    }
+    return (*cp);
+  }
+}
+#endif /* STDLIB_HAS_GETOPT */
+
+char** mk_ascdate(void) {
+  char** m;
+  dss_time_t t;
+  DSS_HUGE i;
+
+  m = (char**)malloc((size_t)(TOTDATE * sizeof(char*)));
+  MALLOC_CHECK(m);
+  for (i = 0; i < TOTDATE; i++) {
+    mk_time(i + 1, &t);
+    m[i] = strdup(t.alpha);
+  }
+
+  return (m);
+}
+
+/*
+ * set_state() -- initialize the RNG so that
+ * appropriate data sets can be generated.
+ * For each table that is to be generated, calculate the number of rows/child,
+ * and send that to the seed generation routine in speed_seed.c. Note: assumes
+ * that tables are completely independent. Returns the number of rows to be
+ * generated by the named step.
+ */
+DSS_HUGE
+set_state(
+    int table_2,
+    long sf,
+    long procs,
+    long step_2,
+    DSS_HUGE* extra_rows,
+    DBGenContext* ctx) {
+  int i;
+  DSS_HUGE rowcount, result;
+
+  if (sf == 0 || step_2 == 0)
+    return (0);
+
+  rowcount = ctx->tdefs[table_2].base;
+  rowcount *= sf;
+  *extra_rows = rowcount % procs;
+  rowcount /= procs;
+  result = rowcount;
+  for (i = 0; i < step_2 - 1; i++) {
+    if (table_2 == LINE) /* special case for shared seeds */
+      ctx->tdefs[table_2].gen_seed(1, rowcount);
+    else
+      ctx->tdefs[table_2].gen_seed(0, rowcount);
+    /* need to set seeds of child in case there's a dependency */
+    /* NOTE: this assumes that the parent and child have the same base row
+     * count */
+    if (ctx->tdefs[table_2].child != NONE)
+      ctx->tdefs[ctx->tdefs[table_2].child].gen_seed(0, rowcount);
+  }
+  if (step_2 > procs) /* moving to the end to generate updates */
+    ctx->tdefs[table_2].gen_seed(0, *extra_rows);
+
+  return (result);
+}
diff --git a/velox/tpch/gen/dbgen/build.cpp b/velox/tpch/gen/dbgen/build.cpp
new file mode 100644
index 0000000000000..8882b4e3adf4d
--- /dev/null
+++ b/velox/tpch/gen/dbgen/build.cpp
@@ -0,0 +1,365 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+#include <stdio.h>
+#include <string.h>
+#ifndef VMS
+#include <sys/types.h>
+#endif
+#if defined(SUN)
+#include <unistd.h>
+#endif
+#include "dbgen/dss.h" // @manual
+#include "dbgen/dsstypes.h" // @manual
+
+#include <math.h>
+#include "dbgen/rng64.h" // @manual
+
+#define LEAP_ADJ(yr, mnth) ((LEAP(yr) && (mnth) >= 2) ? 1 : 0)
+#define JDAY_BASE 8035 /* start from 1/1/70 a la unix */
+#define JMNTH_BASE (-70 * 12) /* start from 1/1/70 a la unix */
+#define JDAY(date) ((date) - STARTDATE + JDAY_BASE + 1)
+#define PART_SUPP_BRIDGE(tgt, p, s)                                           \
+  {                                                                           \
+    DSS_HUGE tot_scnt = ctx->tdefs[SUPP].base * ctx->scale_factor;            \
+    tgt = (p + s * (tot_scnt / SUPP_PER_PART + (long)((p - 1) / tot_scnt))) % \
+            tot_scnt +                                                        \
+        1;                                                                    \
+  }
+#define V_STR(avg, seed, tgt) \
+  tpch_a_rnd((int)(avg * V_STR_LOW), (int)(avg * V_STR_HGH), seed, tgt)
+#define TEXT(avg, seed, tgt) \
+  dbg_text(tgt, (int)(avg * V_STR_LOW), (int)(avg * V_STR_HGH), seed)
+static void gen_phone PROTO((DSS_HUGE ind, char* target, seed_t* seed));
+
+DSS_HUGE
+rpb_routine(DSS_HUGE p) {
+  DSS_HUGE price;
+
+  price = 90000;
+  price += (p / 10) % 20001; /* limit contribution to $200 */
+  price += (p % 1000) * 100;
+
+  return (price);
+}
+
+static void gen_phone(DSS_HUGE ind, char* target, seed_t* seed) {
+  DSS_HUGE acode, exchg, number;
+
+  RANDOM(acode, 100, 999, seed);
+  RANDOM(exchg, 100, 999, seed);
+  RANDOM(number, 1000, 9999, seed);
+
+  sprintf(target, "%02d", (int)(10 + (ind % NATIONS_MAX)));
+  sprintf(target + 3, "%03d", (int)acode);
+  sprintf(target + 7, "%03d", (int)exchg);
+  sprintf(target + 11, "%04d", (int)number);
+  target[2] = target[6] = target[10] = '-';
+
+  return;
+}
+
+long mk_cust(DSS_HUGE n_cust, customer_t* c, DBGenContext* ctx) {
+  DSS_HUGE i;
+  static int bInit = 0;
+  static char szFormat[100];
+
+  if (!bInit) {
+    sprintf(szFormat, C_NAME_FMT, 9, &HUGE_FORMAT[1]);
+    bInit = 1;
+  }
+  c->custkey = n_cust;
+  sprintf(c->name, szFormat, C_NAME_TAG, n_cust);
+  V_STR(C_ADDR_LEN, &ctx->Seed[C_ADDR_SD], c->address);
+  c->alen = (int)strlen(c->address);
+  RANDOM(i, 0, (nations.count - 1), &ctx->Seed[C_NTRG_SD]);
+  c->nation_code = i;
+  gen_phone(i, c->phone, &ctx->Seed[C_PHNE_SD]);
+  RANDOM(c->acctbal, C_ABAL_MIN, C_ABAL_MAX, &ctx->Seed[C_ABAL_SD]);
+  pick_str(&c_mseg_set, &ctx->Seed[C_MSEG_SD], c->mktsegment);
+  TEXT(C_CMNT_LEN, &ctx->Seed[C_CMNT_SD], c->comment);
+  c->clen = (int)strlen(c->comment);
+
+  return (0);
+}
+
+/*
+ * generate the numbered order and its associated lineitems
+ */
+void mk_sparse(DSS_HUGE i, DSS_HUGE* ok, long seq) {
+  long low_bits;
+
+  *ok = i;
+  low_bits = (long)(i & ((1 << SPARSE_KEEP) - 1));
+  *ok = *ok >> SPARSE_KEEP;
+  *ok = *ok << SPARSE_BITS;
+  *ok += seq;
+  *ok = *ok << SPARSE_KEEP;
+  *ok += low_bits;
+
+  return;
+}
+
+long mk_order(DSS_HUGE index, order_t* o, DBGenContext* ctx, long upd_num) {
+  DSS_HUGE lcnt;
+  DSS_HUGE rprice;
+  long ocnt;
+  DSS_HUGE tmp_date;
+  DSS_HUGE s_date;
+  DSS_HUGE r_date;
+  DSS_HUGE c_date;
+  DSS_HUGE clk_num;
+  DSS_HUGE supp_num;
+  static char** asc_date = NULL;
+  char tmp_str[2];
+  char** mk_ascdate PROTO((void));
+  int delta = 1;
+  static int bInit = 0;
+  static char szFormat[100];
+
+  if (!bInit) {
+    sprintf(szFormat, O_CLRK_FMT, 9, &HUGE_FORMAT[1]);
+    bInit = 1;
+  }
+  if (asc_date == NULL)
+    asc_date = mk_ascdate();
+  mk_sparse(
+      index, &o->okey, (upd_num == 0) ? 0 : 1 + upd_num / (10000 / UPD_PCT));
+  if (ctx->scale_factor >= 30000)
+    RANDOM64(o->custkey, O_CKEY_MIN, O_CKEY_MAX, &ctx->Seed[O_CKEY_SD]);
+  else
+    RANDOM(o->custkey, O_CKEY_MIN, O_CKEY_MAX, &ctx->Seed[O_CKEY_SD]);
+  while (o->custkey % CUST_MORTALITY == 0) {
+    o->custkey += delta;
+    o->custkey = MIN(o->custkey, O_CKEY_MAX);
+    delta *= -1;
+  }
+
+  RANDOM(tmp_date, O_ODATE_MIN, O_ODATE_MAX, &ctx->Seed[O_ODATE_SD]);
+  strcpy(o->odate, asc_date[tmp_date - STARTDATE]);
+
+  pick_str(&o_priority_set, &ctx->Seed[O_PRIO_SD], o->opriority);
+  RANDOM(
+      clk_num,
+      1,
+      MAX((ctx->scale_factor * O_CLRK_SCL), O_CLRK_SCL),
+      &ctx->Seed[O_CLRK_SD]);
+  sprintf(o->clerk, szFormat, O_CLRK_TAG, clk_num);
+  TEXT(O_CMNT_LEN, &ctx->Seed[O_CMNT_SD], o->comment);
+  o->clen = (int)strlen(o->comment);
+#ifdef DEBUG
+  if (o->clen > O_CMNT_MAX)
+    fprintf(stderr, "comment error: O%d\n", index);
+#endif /* DEBUG */
+  o->spriority = 0;
+
+  o->totalprice = 0;
+  o->orderstatus = 'O';
+  ocnt = 0;
+
+  RANDOM(o->lines, O_LCNT_MIN, O_LCNT_MAX, &ctx->Seed[O_LCNT_SD]);
+  for (lcnt = 0; lcnt < o->lines; lcnt++) {
+    o->l[lcnt].okey = o->okey;
+    ;
+    o->l[lcnt].lcnt = lcnt + 1;
+    RANDOM(o->l[lcnt].quantity, L_QTY_MIN, L_QTY_MAX, &ctx->Seed[L_QTY_SD]);
+    RANDOM(o->l[lcnt].discount, L_DCNT_MIN, L_DCNT_MAX, &ctx->Seed[L_DCNT_SD]);
+    RANDOM(o->l[lcnt].tax, L_TAX_MIN, L_TAX_MAX, &ctx->Seed[L_TAX_SD]);
+    pick_str(&l_instruct_set, &ctx->Seed[L_SHIP_SD], o->l[lcnt].shipinstruct);
+    pick_str(&l_smode_set, &ctx->Seed[L_SMODE_SD], o->l[lcnt].shipmode);
+    TEXT(L_CMNT_LEN, &ctx->Seed[L_CMNT_SD], o->l[lcnt].comment);
+    o->l[lcnt].clen = (int)strlen(o->l[lcnt].comment);
+    if (ctx->scale_factor >= 30000)
+      RANDOM64(
+          o->l[lcnt].partkey, L_PKEY_MIN, L_PKEY_MAX, &ctx->Seed[L_PKEY_SD]);
+    else
+      RANDOM(o->l[lcnt].partkey, L_PKEY_MIN, L_PKEY_MAX, &ctx->Seed[L_PKEY_SD]);
+    rprice = rpb_routine(o->l[lcnt].partkey);
+    RANDOM(supp_num, 0, 3, &ctx->Seed[L_SKEY_SD]);
+    PART_SUPP_BRIDGE(o->l[lcnt].suppkey, o->l[lcnt].partkey, supp_num);
+    o->l[lcnt].eprice = rprice * o->l[lcnt].quantity;
+
+    o->totalprice += ((o->l[lcnt].eprice * ((long)100 - o->l[lcnt].discount)) /
+                      (long)PENNIES) *
+        ((long)100 + o->l[lcnt].tax) / (long)PENNIES;
+
+    RANDOM(s_date, L_SDTE_MIN, L_SDTE_MAX, &ctx->Seed[L_SDTE_SD]);
+    s_date += tmp_date;
+    RANDOM(c_date, L_CDTE_MIN, L_CDTE_MAX, &ctx->Seed[L_CDTE_SD]);
+    c_date += tmp_date;
+    RANDOM(r_date, L_RDTE_MIN, L_RDTE_MAX, &ctx->Seed[L_RDTE_SD]);
+    r_date += s_date;
+
+    strcpy(o->l[lcnt].sdate, asc_date[s_date - STARTDATE]);
+    strcpy(o->l[lcnt].cdate, asc_date[c_date - STARTDATE]);
+    strcpy(o->l[lcnt].rdate, asc_date[r_date - STARTDATE]);
+
+    if (julian(r_date) <= CURRENTDATE) {
+      pick_str(&l_rflag_set, &ctx->Seed[L_RFLG_SD], tmp_str);
+      o->l[lcnt].rflag[0] = *tmp_str;
+    } else
+      o->l[lcnt].rflag[0] = 'N';
+
+    if (julian(s_date) <= CURRENTDATE) {
+      ocnt++;
+      o->l[lcnt].lstatus[0] = 'F';
+    } else
+      o->l[lcnt].lstatus[0] = 'O';
+  }
+
+  if (ocnt > 0)
+    o->orderstatus = 'P';
+  if (ocnt == o->lines)
+    o->orderstatus = 'F';
+
+  return (0);
+}
+
+long mk_part(DSS_HUGE index, part_t* p, DBGenContext* ctx) {
+  DSS_HUGE temp;
+  long snum;
+  DSS_HUGE brnd;
+  static int bInit = 0;
+  static char szFormat[100];
+  static char szBrandFormat[100];
+
+  if (!bInit) {
+    sprintf(szFormat, P_MFG_FMT, 1, &HUGE_FORMAT[1]);
+    sprintf(szBrandFormat, P_BRND_FMT, 2, &HUGE_FORMAT[1]);
+    bInit = 1;
+  }
+  p->partkey = index;
+  agg_str(&colors, (long)P_NAME_SCL, &ctx->Seed[P_NAME_SD], p->name);
+  RANDOM(temp, P_MFG_MIN, P_MFG_MAX, &ctx->Seed[P_MFG_SD]);
+  sprintf(p->mfgr, szFormat, P_MFG_TAG, temp);
+  RANDOM(brnd, P_BRND_MIN, P_BRND_MAX, &ctx->Seed[P_BRND_SD]);
+  sprintf(p->brand, szBrandFormat, P_BRND_TAG, (temp * 10 + brnd));
+  p->tlen = pick_str(&p_types_set, &ctx->Seed[P_TYPE_SD], p->type);
+  p->tlen = (int)strlen(p_types_set.list[p->tlen].text);
+  RANDOM(p->size, P_SIZE_MIN, P_SIZE_MAX, &ctx->Seed[P_SIZE_SD]);
+  pick_str(&p_cntr_set, &ctx->Seed[P_CNTR_SD], p->container);
+  p->retailprice = rpb_routine(index);
+  TEXT(P_CMNT_LEN, &ctx->Seed[P_CMNT_SD], p->comment);
+  p->clen = (int)strlen(p->comment);
+
+  for (snum = 0; snum < SUPP_PER_PART; snum++) {
+    p->s[snum].partkey = p->partkey;
+    PART_SUPP_BRIDGE(p->s[snum].suppkey, index, snum);
+    RANDOM(p->s[snum].qty, PS_QTY_MIN, PS_QTY_MAX, &ctx->Seed[PS_QTY_SD]);
+    RANDOM(p->s[snum].scost, PS_SCST_MIN, PS_SCST_MAX, &ctx->Seed[PS_SCST_SD]);
+    TEXT(PS_CMNT_LEN, &ctx->Seed[PS_CMNT_SD], p->s[snum].comment);
+    p->s[snum].clen = (int)strlen(p->s[snum].comment);
+  }
+  return (0);
+}
+
+long mk_supp(DSS_HUGE index, supplier_t* s, DBGenContext* ctx) {
+  DSS_HUGE i, bad_press, noise, offset, type;
+  static int bInit = 0;
+  static char szFormat[100];
+
+  if (!bInit) {
+    sprintf(szFormat, S_NAME_FMT, 9, &HUGE_FORMAT[1]);
+    bInit = 1;
+  }
+  s->suppkey = index;
+  sprintf(s->name, szFormat, S_NAME_TAG, index);
+  V_STR(S_ADDR_LEN, &ctx->Seed[S_ADDR_SD], s->address);
+  s->alen = (int)strlen(s->address);
+  RANDOM(i, 0, nations.count - 1, &ctx->Seed[S_NTRG_SD]);
+  s->nation_code = i;
+  gen_phone(i, s->phone, &ctx->Seed[S_PHNE_SD]);
+  RANDOM(s->acctbal, S_ABAL_MIN, S_ABAL_MAX, &ctx->Seed[S_ABAL_SD]);
+
+  TEXT(S_CMNT_LEN, &ctx->Seed[S_CMNT_SD], s->comment);
+  s->clen = (int)strlen(s->comment);
+  /*
+   * these calls should really move inside the if stmt below, but this
+   * will simplify seedless parallel load
+   */
+  RANDOM(bad_press, 1, 10000, &ctx->Seed[BBB_CMNT_SD]);
+  RANDOM(type, 0, 100, &ctx->Seed[BBB_TYPE_SD]);
+  RANDOM(noise, 0, (s->clen - BBB_CMNT_LEN), &ctx->Seed[BBB_JNK_SD]);
+  RANDOM(
+      offset, 0, (s->clen - (BBB_CMNT_LEN + noise)), &ctx->Seed[BBB_OFFSET_SD]);
+  if (bad_press <= S_CMNT_BBB) {
+    type = (type < BBB_DEADBEATS) ? 0 : 1;
+    memcpy(s->comment + offset, BBB_BASE, BBB_BASE_LEN);
+    if (type == 0)
+      memcpy(
+          s->comment + BBB_BASE_LEN + offset + noise,
+          BBB_COMPLAIN,
+          BBB_TYPE_LEN);
+    else
+      memcpy(
+          s->comment + BBB_BASE_LEN + offset + noise,
+          BBB_COMMEND,
+          BBB_TYPE_LEN);
+  }
+  return (0);
+}
+
+struct {
+  char* mdes;
+  long days;
+  long dcnt;
+} months[] =
+
+    {{NULL, 0, 0},
+     {"JAN", 31, 31},
+     {"FEB", 28, 59},
+     {"MAR", 31, 90},
+     {"APR", 30, 120},
+     {"MAY", 31, 151},
+     {"JUN", 30, 181},
+     {"JUL", 31, 212},
+     {"AUG", 31, 243},
+     {"SEP", 30, 273},
+     {"OCT", 31, 304},
+     {"NOV", 30, 334},
+     {"DEC", 31, 365}};
+
+long mk_time(DSS_HUGE index, dss_time_t* t) {
+  long m = 0;
+  long y;
+  long d;
+
+  t->timekey = index + JDAY_BASE;
+  y = julian(index + STARTDATE - 1) / 1000;
+  d = julian(index + STARTDATE - 1) % 1000;
+  while (d > months[m].dcnt + LEAP_ADJ(y, m))
+    m++;
+  PR_DATE(
+      t->alpha, y, m, d - months[m - 1].dcnt - ((LEAP(y) && m > 2) ? 1 : 0));
+  t->year = 1900 + y;
+  t->month = m + 12 * y + JMNTH_BASE;
+  t->week = (d + T_START_DAY - 1) / 7 + 1;
+  t->day = d - months[m - 1].dcnt - LEAP_ADJ(y, m - 1);
+
+  return (0);
+}
+
+int mk_nation(DSS_HUGE index, code_t* c, DBGenContext* ctx) {
+  c->code = index - 1;
+  c->text = nations.list[index - 1].text;
+  c->join = nations.list[index - 1].weight;
+  TEXT(N_CMNT_LEN, &ctx->Seed[N_CMNT_SD], c->comment);
+  c->clen = (int)strlen(c->comment);
+  return (0);
+}
+
+int mk_region(DSS_HUGE index, code_t* c, DBGenContext* ctx) {
+  c->code = index - 1;
+  c->text = regions.list[index - 1].text;
+  c->join = 0; /* for completeness */
+  TEXT(R_CMNT_LEN, &ctx->Seed[R_CMNT_SD], c->comment);
+  c->clen = (int)strlen(c->comment);
+  return (0);
+}
diff --git a/velox/tpch/gen/dbgen/dbgen.cpp b/velox/tpch/gen/dbgen/dbgen.cpp
new file mode 100644
index 0000000000000..8b8127edb75f2
--- /dev/null
+++ b/velox/tpch/gen/dbgen/dbgen.cpp
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// dbgen EXTERN references get defined here.
+#define DECLARER
+
+#include <velox/tpch/gen/dbgen/include/dbgen/dss.h>
diff --git a/velox/tpch/gen/dbgen/dbgen_gunk.cpp b/velox/tpch/gen/dbgen/dbgen_gunk.cpp
new file mode 100644
index 0000000000000..cb28530ecc116
--- /dev/null
+++ b/velox/tpch/gen/dbgen/dbgen_gunk.cpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+#include "dbgen/dbgen_gunk.hpp" // @manual
+
+#include "dbgen/dss.h" // @manual
+
+void load_dists(long textBufferSize, DBGenContext* ctx) {
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "p_cntr", &p_cntr_set);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "colors", &colors);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "p_types", &p_types_set);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "nations", &nations);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "regions", &regions);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "o_oprio", &o_priority_set);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "instruct", &l_instruct_set);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "smode", &l_smode_set);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "category", &l_category_set);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "rflag", &l_rflag_set);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "msegmnt", &c_mseg_set);
+
+  /* load the distributions that contain text generation */
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "nouns", &nouns);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "verbs", &verbs);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "adjectives", &adjectives);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "adverbs", &adverbs);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "auxillaries", &auxillaries);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "terminators", &terminators);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "articles", &articles);
+  read_dist(
+      tpch_env_config(DIST_TAG, DIST_DFLT), "prepositions", &prepositions);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "grammar", &grammar);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "np", &np);
+  read_dist(tpch_env_config(DIST_TAG, DIST_DFLT), "vp", &vp);
+
+  /* populate the text buffer used to generate random text */
+  init_text_pool(textBufferSize, ctx);
+}
+
+static void cleanup_dist(distribution* target) {
+  if (!target) {
+    return;
+  }
+  if (target->list) {
+    for (int i = 0; i < target->count; i++) {
+      if (target->list[i].text) {
+        free(target->list[i].text);
+      }
+    }
+    free(target->list);
+  }
+}
+
+void cleanup_dists(void) {
+  cleanup_dist(&p_cntr_set);
+  cleanup_dist(&colors);
+  cleanup_dist(&p_types_set);
+  cleanup_dist(&nations);
+  cleanup_dist(&regions);
+  cleanup_dist(&o_priority_set);
+  cleanup_dist(&l_instruct_set);
+  cleanup_dist(&l_smode_set);
+  cleanup_dist(&l_category_set);
+  cleanup_dist(&l_rflag_set);
+  cleanup_dist(&c_mseg_set);
+  cleanup_dist(&nouns);
+  cleanup_dist(&verbs);
+  cleanup_dist(&adjectives);
+  cleanup_dist(&adverbs);
+  cleanup_dist(&auxillaries);
+  cleanup_dist(&terminators);
+  cleanup_dist(&articles);
+  cleanup_dist(&prepositions);
+  cleanup_dist(&grammar);
+  cleanup_dist(&np);
+  cleanup_dist(&vp);
+
+  free_text_pool();
+}
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/config.h b/velox/tpch/gen/dbgen/include/dbgen/config.h
similarity index 97%
rename from velox/external/duckdb/tpch/dbgen/include/dbgen/config.h
rename to velox/tpch/gen/dbgen/include/dbgen/config.h
index d705b38438ca2..78b2c90317336 100644
--- a/velox/external/duckdb/tpch/dbgen/include/dbgen/config.h
+++ b/velox/tpch/gen/dbgen/include/dbgen/config.h
@@ -107,8 +107,8 @@
 #endif /* LINUX */
 
 #ifdef MAC
-//#define _POSIX_C_SOURCE 200112L
-//#define _POSIX_SOURCE
+// #define _POSIX_C_SOURCE 200112L
+// #define _POSIX_SOURCE
 #define STDLIB_HAS_GETOPT
 #define SUPPORT_64BITS
 #define DSS_HUGE long long
@@ -139,7 +139,7 @@
 #define RNG_C 1uI64
 #define HUGE_FORMAT "%I64d"
 #define HUGE_DATE_FORMAT "%02I64d"
-/* requried by move to Visual Studio 2005 */
+/* required by move to Visual Studio 2005 */
 #define strdup(x) _strdup(x)
 #endif /* WIN32 */
 
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/dbgen_gunk.hpp b/velox/tpch/gen/dbgen/include/dbgen/dbgen_gunk.hpp
similarity index 86%
rename from velox/external/duckdb/tpch/dbgen/include/dbgen/dbgen_gunk.hpp
rename to velox/tpch/gen/dbgen/include/dbgen/dbgen_gunk.hpp
index 45054d745c133..12675c77e6085 100644
--- a/velox/external/duckdb/tpch/dbgen/include/dbgen/dbgen_gunk.hpp
+++ b/velox/tpch/gen/dbgen/include/dbgen/dbgen_gunk.hpp
@@ -12,5 +12,5 @@
 
 struct DBGenContext;
 
-void load_dists(long textBufferSize, DBGenContext *ctx);
+void load_dists(long textBufferSize, DBGenContext* ctx);
 void cleanup_dists(void);
diff --git a/velox/tpch/gen/dbgen/include/dbgen/dists_dss.h b/velox/tpch/gen/dbgen/include/dbgen/dists_dss.h
new file mode 100644
index 0000000000000..e6eeac7f1e8cf
--- /dev/null
+++ b/velox/tpch/gen/dbgen/include/dbgen/dists_dss.h
@@ -0,0 +1,851 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+const char* dists_dss =
+    "#\n"
+    "# $Id: dists.dss,v 1.2 2005/01/03 20:08:58 jms Exp $\n"
+    "#\n"
+    "# Revision History\n"
+    "# ===================\n"
+    "# $Log: dists.dss,v $\n"
+    "# Revision 1.2  2005/01/03 20:08:58  jms\n"
+    "# change line terminations\n"
+    "#\n"
+    "# Revision 1.1.1.1  2004/11/24 23:31:46  jms\n"
+    "# re-establish external server\n"
+    "#\n"
+    "# Revision 1.1.1.1  2003/04/03 18:54:21  jms\n"
+    "# recreation after CVS crash\n"
+    "#\n"
+    "# Revision 1.1.1.1  2003/04/03 18:54:21  jms\n"
+    "# initial checkin\n"
+    "#\n"
+    "#\n"
+    "#\n"
+    "#\n"
+    "# distributions have the following format:\n"
+    "#\n"
+    "# <token> | <weight> # comment\n"
+    "#\n"
+    "# Distributions are used to bias the selection of a token \n"
+    "# based on its associated weight. The list of tokens and values \n"
+    "# between the keywords BEGIN and END define the distribution named after\n"
+    "# the BEGIN. A uniformly random value from [0, sum(weights)]\n"
+    "# will be chosen and the first token whose cumulative weight is greater "
+    "than\n"
+    "# or equal to the result will be returned. In essence, the weights for "
+    "each\n"
+    "# token represent its relative weight within a distribution.\n"
+    "#\n"
+    "# one special token is defined: count (number of data points in the \n"
+    "#  distribution). It MUST be defined for each named distribution.\n"
+    "#-----------------------------------------------------------------------\n"
+    "# currently defined distributions and their use:\n"
+    "#  NAME       FIELD/NOTES\n"
+    "#  ========   ==============\n"
+    "#  category   parts.category\n"
+    "#  container  parts.container\n"
+    "#  instruct   shipping instructions\n"
+    "#  msegmnt    market segment\n"
+    "#  names      parts.name\n"
+    "#  nations    must be ordered along with regions\n"
+    "#  nations2   stand alone nations set for use with qgen\n"
+    "#  o_prio     order priority\n"
+    "#  regions    must be ordered along with nations\n"
+    "#  rflag      lineitems.returnflag\n"
+    "#  types      parts.type\n"
+    "#  colors     embedded string creation; CANNOT BE USED FOR pick_str(), "
+    "agg_str() perturbs order\n"
+    "#  articles   comment generation \n"
+    "#  nouns      \n"
+    "#  verbs      \n"
+    "#  adverbs    \n"
+    "#  auxillaries \n"
+    "#  prepositions\n"
+    "#  terminators\n"
+    "#  grammar    sentence formation\n"
+    "#  np\n"
+    "#  vp\n"
+    "###\n"
+    "# category\n"
+    "###\n"
+    "BEGIN category\n"
+    "COUNT|5\n"
+    "FURNITURE|1\n"
+    "STORAGE EQUIP|1\n"
+    "TOOLS|1\n"
+    "MACHINE TOOLS|1\n"
+    "OTHER|1\n"
+    "END category\n"
+    "###\n"
+    "# container\n"
+    "###\n"
+    "begin p_cntr\n"
+    "count|40\n"
+    "SM CASE|1\n"
+    "SM BOX|1\n"
+    "SM BAG|1\n"
+    "SM JAR|1\n"
+    "SM PACK|1\n"
+    "SM PKG|1\n"
+    "SM CAN|1\n"
+    "SM DRUM|1\n"
+    "LG CASE|1\n"
+    "LG BOX|1\n"
+    "LG BAG|1\n"
+    "LG JAR|1\n"
+    "LG PACK|1\n"
+    "LG PKG|1\n"
+    "LG CAN|1\n"
+    "LG DRUM|1\n"
+    "MED CASE|1\n"
+    "MED BOX|1\n"
+    "MED BAG|1\n"
+    "MED JAR|1\n"
+    "MED PACK|1\n"
+    "MED PKG|1\n"
+    "MED CAN|1\n"
+    "MED DRUM|1\n"
+    "JUMBO CASE|1\n"
+    "JUMBO BOX|1\n"
+    "JUMBO BAG|1\n"
+    "JUMBO JAR|1\n"
+    "JUMBO PACK|1\n"
+    "JUMBO PKG|1\n"
+    "JUMBO CAN|1\n"
+    "JUMBO DRUM|1\n"
+    "WRAP CASE|1\n"
+    "WRAP BOX|1\n"
+    "WRAP BAG|1\n"
+    "WRAP JAR|1\n"
+    "WRAP PACK|1\n"
+    "WRAP PKG|1\n"
+    "WRAP CAN|1\n"
+    "WRAP DRUM|1\n"
+    "end p_cntr\n"
+    "###\n"
+    "# instruct\n"
+    "###\n"
+    "begin instruct\n"
+    "count|4\n"
+    "DELIVER IN PERSON|1\n"
+    "COLLECT COD|1\n"
+    "TAKE BACK RETURN|1\n"
+    "NONE|1\n"
+    "end instruct\n"
+    "###\n"
+    "# msegmnt\n"
+    "###\n"
+    "begin msegmnt\n"
+    "count|5\n"
+    "AUTOMOBILE|1\n"
+    "BUILDING|1\n"
+    "FURNITURE|1\n"
+    "HOUSEHOLD|1\n"
+    "MACHINERY|1\n"
+    "end msegmnt\n"
+    "###\n"
+    "# names\n"
+    "###\n"
+    "begin p_names\n"
+    "COUNT|4\n"
+    "CLEANER|1\n"
+    "SOAP|1\n"
+    "DETERGENT|1\n"
+    "EXTRA|1\n"
+    "end p_names\n"
+    "###\n"
+    "# nations\n"
+    "# NOTE: this is a special case; the weights here are adjustments to\n"
+    "#       map correctly into the regions table, and are *NOT* cummulative\n"
+    "#       values to mimic a distribution\n"
+    "###\n"
+    "begin nations\n"
+    "count|25\n"
+    "ALGERIA|0\n"
+    "ARGENTINA|1\n"
+    "BRAZIL|0\n"
+    "CANADA|0\n"
+    "EGYPT|3\n"
+    "ETHIOPIA|-4\n"
+    "FRANCE|3\n"
+    "GERMANY|0\n"
+    "INDIA|-1\n"
+    "INDONESIA|0\n"
+    "IRAN|2\n"
+    "IRAQ|0\n"
+    "JAPAN|-2\n"
+    "JORDAN|2\n"
+    "KENYA|-4\n"
+    "MOROCCO|0\n"
+    "MOZAMBIQUE|0\n"
+    "PERU|1\n"
+    "CHINA|1\n"
+    "ROMANIA|1\n"
+    "SAUDI ARABIA|1\n"
+    "VIETNAM|-2\n"
+    "RUSSIA|1\n"
+    "UNITED KINGDOM|0\n"
+    "UNITED STATES|-2\n"
+    "end nations\n"
+    "###\n"
+    "# nations2\n"
+    "###\n"
+    "begin nations2\n"
+    "count|25\n"
+    "ALGERIA|1\n"
+    "ARGENTINA|1\n"
+    "BRAZIL|1\n"
+    "CANADA|1\n"
+    "EGYPT|1\n"
+    "ETHIOPIA|1\n"
+    "FRANCE|1\n"
+    "GERMANY|1\n"
+    "INDIA|1\n"
+    "INDONESIA|1\n"
+    "IRAN|1\n"
+    "IRAQ|1\n"
+    "JAPAN|1\n"
+    "JORDAN|1\n"
+    "KENYA|1\n"
+    "MOROCCO|1\n"
+    "MOZAMBIQUE|1\n"
+    "PERU|1\n"
+    "CHINA|1\n"
+    "ROMANIA|1\n"
+    "SAUDI ARABIA|1\n"
+    "VIETNAM|1\n"
+    "RUSSIA|1\n"
+    "UNITED KINGDOM|1\n"
+    "UNITED STATES|1\n"
+    "end nations2\n"
+    "###\n"
+    "# regions\n"
+    "###\n"
+    "begin regions\n"
+    "count|5\n"
+    "AFRICA|1\n"
+    "AMERICA|1\n"
+    "ASIA|1\n"
+    "EUROPE|1\n"
+    "MIDDLE EAST|1\n"
+    "end regions\n"
+    "###\n"
+    "# o_prio\n"
+    "###\n"
+    "begin o_oprio\n"
+    "count|5\n"
+    "1-URGENT|1\n"
+    "2-HIGH|1\n"
+    "3-MEDIUM|1\n"
+    "4-NOT SPECIFIED|1\n"
+    "5-LOW|1\n"
+    "end o_oprio\n"
+    "###\n"
+    "# rflag\n"
+    "###\n"
+    "begin rflag\n"
+    "count|2\n"
+    "R|1\n"
+    "A|1\n"
+    "end rflag\n"
+    "###\n"
+    "# smode\n"
+    "###\n"
+    "begin smode\n"
+    "count|7\n"
+    "REG AIR|1\n"
+    "AIR|1\n"
+    "RAIL|1\n"
+    "TRUCK|1\n"
+    "MAIL|1\n"
+    "FOB|1\n"
+    "SHIP|1\n"
+    "end smode\n"
+    "###\n"
+    "# types\n"
+    "###\n"
+    "begin p_types\n"
+    "COUNT|150\n"
+    "STANDARD ANODIZED TIN|1\n"
+    "STANDARD ANODIZED NICKEL|1\n"
+    "STANDARD ANODIZED BRASS|1\n"
+    "STANDARD ANODIZED STEEL|1\n"
+    "STANDARD ANODIZED COPPER|1\n"
+    "STANDARD BURNISHED TIN|1\n"
+    "STANDARD BURNISHED NICKEL|1\n"
+    "STANDARD BURNISHED BRASS|1\n"
+    "STANDARD BURNISHED STEEL|1\n"
+    "STANDARD BURNISHED COPPER|1\n"
+    "STANDARD PLATED TIN|1\n"
+    "STANDARD PLATED NICKEL|1\n"
+    "STANDARD PLATED BRASS|1\n"
+    "STANDARD PLATED STEEL|1\n"
+    "STANDARD PLATED COPPER|1\n"
+    "STANDARD POLISHED TIN|1\n"
+    "STANDARD POLISHED NICKEL|1\n"
+    "STANDARD POLISHED BRASS|1\n"
+    "STANDARD POLISHED STEEL|1\n"
+    "STANDARD POLISHED COPPER|1\n"
+    "STANDARD BRUSHED TIN|1\n"
+    "STANDARD BRUSHED NICKEL|1\n"
+    "STANDARD BRUSHED BRASS|1\n"
+    "STANDARD BRUSHED STEEL|1\n"
+    "STANDARD BRUSHED COPPER|1\n"
+    "SMALL ANODIZED TIN|1\n"
+    "SMALL ANODIZED NICKEL|1\n"
+    "SMALL ANODIZED BRASS|1\n"
+    "SMALL ANODIZED STEEL|1\n"
+    "SMALL ANODIZED COPPER|1\n"
+    "SMALL BURNISHED TIN|1\n"
+    "SMALL BURNISHED NICKEL|1\n"
+    "SMALL BURNISHED BRASS|1\n"
+    "SMALL BURNISHED STEEL|1\n"
+    "SMALL BURNISHED COPPER|1\n"
+    "SMALL PLATED TIN|1\n"
+    "SMALL PLATED NICKEL|1\n"
+    "SMALL PLATED BRASS|1\n"
+    "SMALL PLATED STEEL|1\n"
+    "SMALL PLATED COPPER|1\n"
+    "SMALL POLISHED TIN|1\n"
+    "SMALL POLISHED NICKEL|1\n"
+    "SMALL POLISHED BRASS|1\n"
+    "SMALL POLISHED STEEL|1\n"
+    "SMALL POLISHED COPPER|1\n"
+    "SMALL BRUSHED TIN|1\n"
+    "SMALL BRUSHED NICKEL|1\n"
+    "SMALL BRUSHED BRASS|1\n"
+    "SMALL BRUSHED STEEL|1\n"
+    "SMALL BRUSHED COPPER|1\n"
+    "MEDIUM ANODIZED TIN|1\n"
+    "MEDIUM ANODIZED NICKEL|1\n"
+    "MEDIUM ANODIZED BRASS|1\n"
+    "MEDIUM ANODIZED STEEL|1\n"
+    "MEDIUM ANODIZED COPPER|1\n"
+    "MEDIUM BURNISHED TIN|1\n"
+    "MEDIUM BURNISHED NICKEL|1\n"
+    "MEDIUM BURNISHED BRASS|1\n"
+    "MEDIUM BURNISHED STEEL|1\n"
+    "MEDIUM BURNISHED COPPER|1\n"
+    "MEDIUM PLATED TIN|1\n"
+    "MEDIUM PLATED NICKEL|1\n"
+    "MEDIUM PLATED BRASS|1\n"
+    "MEDIUM PLATED STEEL|1\n"
+    "MEDIUM PLATED COPPER|1\n"
+    "MEDIUM POLISHED TIN|1\n"
+    "MEDIUM POLISHED NICKEL|1\n"
+    "MEDIUM POLISHED BRASS|1\n"
+    "MEDIUM POLISHED STEEL|1\n"
+    "MEDIUM POLISHED COPPER|1\n"
+    "MEDIUM BRUSHED TIN|1\n"
+    "MEDIUM BRUSHED NICKEL|1\n"
+    "MEDIUM BRUSHED BRASS|1\n"
+    "MEDIUM BRUSHED STEEL|1\n"
+    "MEDIUM BRUSHED COPPER|1\n"
+    "LARGE ANODIZED TIN|1\n"
+    "LARGE ANODIZED NICKEL|1\n"
+    "LARGE ANODIZED BRASS|1\n"
+    "LARGE ANODIZED STEEL|1\n"
+    "LARGE ANODIZED COPPER|1\n"
+    "LARGE BURNISHED TIN|1\n"
+    "LARGE BURNISHED NICKEL|1\n"
+    "LARGE BURNISHED BRASS|1\n"
+    "LARGE BURNISHED STEEL|1\n"
+    "LARGE BURNISHED COPPER|1\n"
+    "LARGE PLATED TIN|1\n"
+    "LARGE PLATED NICKEL|1\n"
+    "LARGE PLATED BRASS|1\n"
+    "LARGE PLATED STEEL|1\n"
+    "LARGE PLATED COPPER|1\n"
+    "LARGE POLISHED TIN|1\n"
+    "LARGE POLISHED NICKEL|1\n"
+    "LARGE POLISHED BRASS|1\n"
+    "LARGE POLISHED STEEL|1\n"
+    "LARGE POLISHED COPPER|1\n"
+    "LARGE BRUSHED TIN|1\n"
+    "LARGE BRUSHED NICKEL|1\n"
+    "LARGE BRUSHED BRASS|1\n"
+    "LARGE BRUSHED STEEL|1\n"
+    "LARGE BRUSHED COPPER|1\n"
+    "ECONOMY ANODIZED TIN|1\n"
+    "ECONOMY ANODIZED NICKEL|1\n"
+    "ECONOMY ANODIZED BRASS|1\n"
+    "ECONOMY ANODIZED STEEL|1\n"
+    "ECONOMY ANODIZED COPPER|1\n"
+    "ECONOMY BURNISHED TIN|1\n"
+    "ECONOMY BURNISHED NICKEL|1\n"
+    "ECONOMY BURNISHED BRASS|1\n"
+    "ECONOMY BURNISHED STEEL|1\n"
+    "ECONOMY BURNISHED COPPER|1\n"
+    "ECONOMY PLATED TIN|1\n"
+    "ECONOMY PLATED NICKEL|1\n"
+    "ECONOMY PLATED BRASS|1\n"
+    "ECONOMY PLATED STEEL|1\n"
+    "ECONOMY PLATED COPPER|1\n"
+    "ECONOMY POLISHED TIN|1\n"
+    "ECONOMY POLISHED NICKEL|1\n"
+    "ECONOMY POLISHED BRASS|1\n"
+    "ECONOMY POLISHED STEEL|1\n"
+    "ECONOMY POLISHED COPPER|1\n"
+    "ECONOMY BRUSHED TIN|1\n"
+    "ECONOMY BRUSHED NICKEL|1\n"
+    "ECONOMY BRUSHED BRASS|1\n"
+    "ECONOMY BRUSHED STEEL|1\n"
+    "ECONOMY BRUSHED COPPER|1\n"
+    "PROMO ANODIZED TIN|1\n"
+    "PROMO ANODIZED NICKEL|1\n"
+    "PROMO ANODIZED BRASS|1\n"
+    "PROMO ANODIZED STEEL|1\n"
+    "PROMO ANODIZED COPPER|1\n"
+    "PROMO BURNISHED TIN|1\n"
+    "PROMO BURNISHED NICKEL|1\n"
+    "PROMO BURNISHED BRASS|1\n"
+    "PROMO BURNISHED STEEL|1\n"
+    "PROMO BURNISHED COPPER|1\n"
+    "PROMO PLATED TIN|1\n"
+    "PROMO PLATED NICKEL|1\n"
+    "PROMO PLATED BRASS|1\n"
+    "PROMO PLATED STEEL|1\n"
+    "PROMO PLATED COPPER|1\n"
+    "PROMO POLISHED TIN|1\n"
+    "PROMO POLISHED NICKEL|1\n"
+    "PROMO POLISHED BRASS|1\n"
+    "PROMO POLISHED STEEL|1\n"
+    "PROMO POLISHED COPPER|1\n"
+    "PROMO BRUSHED TIN|1\n"
+    "PROMO BRUSHED NICKEL|1\n"
+    "PROMO BRUSHED BRASS|1\n"
+    "PROMO BRUSHED STEEL|1\n"
+    "PROMO BRUSHED COPPER|1\n"
+    "end p_types\n"
+    "###\n"
+    "# colors\n"
+    "# NOTE: This distribution CANNOT be used by pick_str(), since agg_str() "
+    "perturbs its order\n"
+    "###\n"
+    "begin colors\n"
+    "COUNT|92\n"
+    "almond|1\n"
+    "antique|1\n"
+    "aquamarine|1\n"
+    "azure|1\n"
+    "beige|1\n"
+    "bisque|1\n"
+    "black|1\n"
+    "blanched|1\n"
+    "blue|1\n"
+    "blush|1\n"
+    "brown|1\n"
+    "burlywood|1\n"
+    "burnished|1\n"
+    "chartreuse|1\n"
+    "chiffon|1\n"
+    "chocolate|1\n"
+    "coral|1\n"
+    "cornflower|1\n"
+    "cornsilk|1\n"
+    "cream|1\n"
+    "cyan|1\n"
+    "dark|1\n"
+    "deep|1\n"
+    "dim|1\n"
+    "dodger|1\n"
+    "drab|1\n"
+    "firebrick|1\n"
+    "floral|1\n"
+    "forest|1\n"
+    "frosted|1\n"
+    "gainsboro|1\n"
+    "ghost|1\n"
+    "goldenrod|1\n"
+    "green|1\n"
+    "grey|1\n"
+    "honeydew|1\n"
+    "hot|1\n"
+    "indian|1\n"
+    "ivory|1\n"
+    "khaki|1\n"
+    "lace|1\n"
+    "lavender|1\n"
+    "lawn|1\n"
+    "lemon|1\n"
+    "light|1\n"
+    "lime|1\n"
+    "linen|1\n"
+    "magenta|1\n"
+    "maroon|1\n"
+    "medium|1\n"
+    "metallic|1\n"
+    "midnight|1\n"
+    "mint|1\n"
+    "misty|1\n"
+    "moccasin|1\n"
+    "navajo|1\n"
+    "navy|1\n"
+    "olive|1\n"
+    "orange|1\n"
+    "orchid|1\n"
+    "pale|1\n"
+    "papaya|1\n"
+    "peach|1\n"
+    "peru|1\n"
+    "pink|1\n"
+    "plum|1\n"
+    "powder|1\n"
+    "puff|1\n"
+    "purple|1\n"
+    "red|1\n"
+    "rose|1\n"
+    "rosy|1\n"
+    "royal|1\n"
+    "saddle|1\n"
+    "salmon|1\n"
+    "sandy|1\n"
+    "seashell|1\n"
+    "sienna|1\n"
+    "sky|1\n"
+    "slate|1\n"
+    "smoke|1\n"
+    "snow|1\n"
+    "spring|1\n"
+    "steel|1\n"
+    "tan|1\n"
+    "thistle|1\n"
+    "tomato|1\n"
+    "turquoise|1\n"
+    "violet|1\n"
+    "wheat|1\n"
+    "white|1\n"
+    "yellow|1\n"
+    "end colors\n"
+    "################\n"
+    "################\n"
+    "## psuedo text distributions\n"
+    "################\n"
+    "################\n"
+    "###\n"
+    "# nouns\n"
+    "###\n"
+    "BEGIN nouns\n"
+    "COUNT|45\n"
+    "packages|40\n"
+    "requests|40\n"
+    "accounts|40\n"
+    "deposits|40\n"
+    "foxes|20\n"
+    "ideas|20\n"
+    "theodolites|20\n"
+    "pinto beans|20\n"
+    "instructions|20\n"
+    "dependencies|10\n"
+    "excuses|10\n"
+    "platelets|10\n"
+    "asymptotes|10\n"
+    "courts|5\n"
+    "dolphins|5\n"
+    "multipliers|1\n"
+    "sauternes|1\n"
+    "warthogs|1\n"
+    "frets|1\n"
+    "dinos|1\n"
+    "attainments|1\n"
+    "somas|1\n"
+    "Tiresias|1\n"
+    "patterns|1\n"
+    "forges|1\n"
+    "braids|1\n"
+    "frays|1\n"
+    "warhorses|1\n"
+    "dugouts|1\n"
+    "notornis|1\n"
+    "epitaphs|1\n"
+    "pearls|1\n"
+    "tithes|1\n"
+    "waters|1\n"
+    "orbits|1\n"
+    "gifts|1\n"
+    "sheaves|1\n"
+    "depths|1\n"
+    "sentiments|1\n"
+    "decoys|1\n"
+    "realms|1\n"
+    "pains|1\n"
+    "grouches|1\n"
+    "escapades|1\n"
+    "hockey players|1\n"
+    "END nouns\n"
+    "###\n"
+    "# verbs\n"
+    "###\n"
+    "BEGIN verbs\n"
+    "COUNT|40\n"
+    "sleep|20\n"
+    "wake|20\n"
+    "are|20\n"
+    "cajole|20\n"
+    "haggle|20\n"
+    "nag|10\n"
+    "use|10\n"
+    "boost|10\n"
+    "affix|5\n"
+    "detect|5\n"
+    "integrate|5\n"
+    "maintain|1\n"
+    "nod|1\n"
+    "was|1\n"
+    "lose|1\n"
+    "sublate|1\n"
+    "solve|1\n"
+    "thrash|1\n"
+    "promise|1\n"
+    "engage|1\n"
+    "hinder|1\n"
+    "print|1\n"
+    "x-ray|1\n"
+    "breach|1\n"
+    "eat|1\n"
+    "grow|1\n"
+    "impress|1\n"
+    "mold|1\n"
+    "poach|1\n"
+    "serve|1\n"
+    "run|1\n"
+    "dazzle|1\n"
+    "snooze|1\n"
+    "doze|1\n"
+    "unwind|1\n"
+    "kindle|1\n"
+    "play|1\n"
+    "hang|1\n"
+    "believe|1\n"
+    "doubt|1\n"
+    "END verbs\n"
+    "###\n"
+    "# adverbs\n"
+    "##\n"
+    "BEGIN adverbs\n"
+    "COUNT|28\n"
+    "sometimes|1\n"
+    "always|1\n"
+    "never|1\n"
+    "furiously|50\n"
+    "slyly|50\n"
+    "carefully|50\n"
+    "blithely|40\n"
+    "quickly|30\n"
+    "fluffily|20\n"
+    "slowly|1\n"
+    "quietly|1\n"
+    "ruthlessly|1\n"
+    "thinly|1\n"
+    "closely|1\n"
+    "doggedly|1\n"
+    "daringly|1\n"
+    "bravely|1\n"
+    "stealthily|1\n"
+    "permanently|1\n"
+    "enticingly|1\n"
+    "idly|1\n"
+    "busily|1\n"
+    "regularly|1\n"
+    "finally|1\n"
+    "ironically|1\n"
+    "evenly|1\n"
+    "boldly|1\n"
+    "silently|1\n"
+    "END adverbs\n"
+    "###\n"
+    "# articles\n"
+    "##\n"
+    "BEGIN articles\n"
+    "COUNT|3\n"
+    "the|50\n"
+    "a|20\n"
+    "an|5\n"
+    "END articles\n"
+    "###\n"
+    "# prepositions\n"
+    "##\n"
+    "BEGIN prepositions\n"
+    "COUNT|47\n"
+    "about|50\n"
+    "above|50\n"
+    "according to|50\n"
+    "across|50\n"
+    "after|50\n"
+    "against|40\n"
+    "along|40\n"
+    "alongside of|30\n"
+    "among|30\n"
+    "around|20\n"
+    "at|10\n"
+    "atop|1\n"
+    "before|1\n"
+    "behind|1\n"
+    "beneath|1\n"
+    "beside|1\n"
+    "besides|1\n"
+    "between|1\n"
+    "beyond|1\n"
+    "by|1\n"
+    "despite|1\n"
+    "during|1\n"
+    "except|1\n"
+    "for|1\n"
+    "from|1\n"
+    "in place of|1\n"
+    "inside|1\n"
+    "instead of|1\n"
+    "into|1\n"
+    "near|1\n"
+    "of|1\n"
+    "on|1\n"
+    "outside|1\n"
+    "over|1 \n"
+    "past|1\n"
+    "since|1\n"
+    "through|1\n"
+    "throughout|1\n"
+    "to|1\n"
+    "toward|1\n"
+    "under|1\n"
+    "until|1\n"
+    "up|1 \n"
+    "upon|1\n"
+    "whithout|1\n"
+    "with|1\n"
+    "within|1\n"
+    "END prepositions\n"
+    "###\n"
+    "# auxillaries\n"
+    "##\n"
+    "BEGIN auxillaries\n"
+    "COUNT|18\n"
+    "do|1\n"
+    "may|1\n"
+    "might|1\n"
+    "shall|1\n"
+    "will|1\n"
+    "would|1\n"
+    "can|1\n"
+    "could|1\n"
+    "should|1\n"
+    "ought to|1\n"
+    "must|1\n"
+    "will have to|1\n"
+    "shall have to|1\n"
+    "could have to|1\n"
+    "should have to|1\n"
+    "must have to|1\n"
+    "need to|1\n"
+    "try to|1\n"
+    "END auxiallaries\n"
+    "###\n"
+    "# terminators\n"
+    "##\n"
+    "BEGIN terminators\n"
+    "COUNT|6\n"
+    ".|50\n"
+    ";|1\n"
+    ":|1\n"
+    "?|1\n"
+    "!|1\n"
+    "--|1\n"
+    "END terminators\n"
+    "###\n"
+    "# adjectives\n"
+    "##\n"
+    "BEGIN adjectives\n"
+    "COUNT|29\n"
+    "special|20\n"
+    "pending|20\n"
+    "unusual|20\n"
+    "express|20\n"
+    "furious|1\n"
+    "sly|1\n"
+    "careful|1\n"
+    "blithe|1\n"
+    "quick|1\n"
+    "fluffy|1\n"
+    "slow|1\n"
+    "quiet|1\n"
+    "ruthless|1\n"
+    "thin|1\n"
+    "close|1\n"
+    "dogged|1\n"
+    "daring|1\n"
+    "brave|1\n"
+    "stealthy|1\n"
+    "permanent|1\n"
+    "enticing|1\n"
+    "idle|1\n"
+    "busy|1\n"
+    "regular|50\n"
+    "final|40\n"
+    "ironic|40\n"
+    "even|30\n"
+    "bold|20\n"
+    "silent|10\n"
+    "END adjectives\n"
+    "###\n"
+    "# grammar\n"
+    "# first level grammar. N=noun phrase, V=verb phrase,\n"
+    "# P=prepositional phrase, T=setence termination\n"
+    "##\n"
+    "BEGIN grammar\n"
+    "COUNT|5\n"
+    "N V T|3\n"
+    "N V P T|3\n"
+    "N V N T|3\n"
+    "N P V N T|1\n"
+    "N P V P T|1\n"
+    "END grammar\n"
+    "###\n"
+    "# NP\n"
+    "# second level grammar. Noun phrases. N=noun, A=article, \n"
+    "# J=adjective, D=adverb\n"
+    "##\n"
+    "BEGIN np\n"
+    "COUNT|4\n"
+    "N|10\n"
+    "J N|20\n"
+    "J, J N|10\n"
+    "D J N|50\n"
+    "END np\n"
+    "###\n"
+    "# VP\n"
+    "# second level grammar. Verb phrases. V=verb, X=auxiallary, \n"
+    "# D=adverb\n"
+    "##\n"
+    "BEGIN vp\n"
+    "COUNT|4\n"
+    "V|30\n"
+    "X V|1\n"
+    "V D|40\n"
+    "X V D|1\n"
+    "END vp\n"
+    "###\n"
+    "# Q13\n"
+    "# Substitution parameters for Q13 \n"
+    "##\n"
+    "BEGIN Q13a\n"
+    "COUNT|4\n"
+    "special|20\n"
+    "pending|20\n"
+    "unusual|20\n"
+    "express|20\n"
+    "END Q13a\n"
+    "BEGIN Q13b\n"
+    "COUNT|4\n"
+    "packages|40\n"
+    "requests|40\n"
+    "accounts|40\n"
+    "deposits|40\n"
+    "END Q13b";
diff --git a/velox/tpch/gen/dbgen/include/dbgen/dss.h b/velox/tpch/gen/dbgen/include/dbgen/dss.h
new file mode 100644
index 0000000000000..f4356e9f0c4d1
--- /dev/null
+++ b/velox/tpch/gen/dbgen/include/dbgen/dss.h
@@ -0,0 +1,581 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+/*
+ * general definitions and control information for the DSS code
+ * generator; if it controls the data set, it's here
+ */
+#ifndef DSS_H
+#define DSS_H
+
+#include "dbgen/config.h" // @manual
+
+#ifdef TPCH
+#define NAME "TPC-H"
+#endif
+#ifdef TPCR
+#define NAME "TPC-R"
+#endif
+#ifndef NAME
+#error Benchmark version must be defined in config.h
+#endif
+#define TPC "Transaction Processing Performance Council"
+#define C_DATES "1994 - 2010"
+
+#include "dbgen/config.h" // @manual
+#include "dbgen/shared.h" // @manual
+
+#include <stdio.h>
+#include <stdlib.h>
+
+// some defines to avoid r warnings
+#define exit(status)
+#define printf(...)
+#define fprintf(...)
+
+#define NONE -1
+#define PART 0
+#define PSUPP 1
+#define SUPP 2
+#define CUST 3
+#define ORDER 4
+#define LINE 5
+#define ORDER_LINE 6
+#define PART_PSUPP 7
+#define NATION 8
+#define REGION 9
+#define UPDATE 10
+#define MAX_TABLE 11
+#define ONE_STREAM 1
+#define ADD_AT_END 2
+
+#ifdef MAX
+#undef MAX
+#endif
+#ifdef MIN
+#undef MIN
+#endif
+#define MAX(a, b) ((a > b) ? a : b)
+#define MIN(A, B) ((A) < (B) ? (A) : (B))
+
+#define INTERNAL_ERROR(p) // {fprintf(stderr,"%s", p);abort();}
+#define LN_CNT 4
+// static char lnoise[4] = {'|', '/', '-', '\\' };
+#define LIFENOISE( \
+    n, var) // if (verbose > 0) fprintf(stderr, "%c\b", lnoise[(var%LN_CNT)])
+
+#define MALLOC_CHECK(var)                                            \
+  if ((var) == NULL) {                                               \
+    fprintf(stderr, "Malloc failed at %s:%d\n", __FILE__, __LINE__); \
+    exit(1);                                                         \
+  }
+#define OPEN_CHECK(var, path)                                               \
+  if ((var) == NULL) {                                                      \
+    fprintf(                                                                \
+        stderr, "Open failed for %s at %s:%d\n", path, __FILE__, __LINE__); \
+    exit(1);                                                                \
+  }
+#ifndef MAX_CHILDREN
+#define MAX_CHILDREN 1000
+#endif
+
+/*
+ * macros that control sparse keys
+ *
+ * refer to Porting.Notes for a complete explanation
+ */
+#ifndef BITS_PER_LONG
+#define BITS_PER_LONG 32
+#define MAX_LONG 0x7FFFFFFF
+#endif /* BITS_PER_LONG */
+#define SPARSE_BITS 2
+#define SPARSE_KEEP 3
+#define MK_SPARSE(key, seq) \
+  (((((key >> 3) << 2) | (seq & 0x0003)) << 3) | (key & 0x0007))
+
+#define RANDOM(tgt, lower, upper, seed) dss_random(&tgt, lower, upper, seed)
+#define RANDOM64(tgt, lower, upper, seed) dss_random64(&tgt, lower, upper, seed)
+
+typedef struct {
+  long weight;
+  char* text;
+} set_member;
+
+typedef struct {
+  int count;
+  int max;
+  set_member* list;
+  long* permute;
+} distribution;
+/*
+ * some handy access functions
+ */
+#define DIST_SIZE(d) d->count
+#define DIST_MEMBER(d, i) ((set_member*)((d)->list + i))->text
+#define DIST_PERMUTE(d, i) (d->permute[i])
+
+typedef struct {
+  const char* name;
+  const char* comment;
+  DSS_HUGE base;
+  int (*loader)();
+  long (*gen_seed)(int, int);
+  int child;
+  DSS_HUGE vtotal;
+} tdef;
+
+typedef struct SEED_T {
+  long table;
+  DSS_HUGE value;
+  DSS_HUGE usage;
+  DSS_HUGE boundary;
+#ifdef RNG_TEST
+  DSS_HUGE nCalls;
+#endif
+} seed_t;
+
+#define PROTO(s) s
+
+struct DBGenContext;
+
+/* bm_utils.c */
+const char* tpch_env_config PROTO((const char* var, const char* dflt));
+void tpch_a_rnd PROTO((int min, int max, seed_t* seed, char* dest));
+int tx_rnd PROTO((long min, long max, long column, char* tgt));
+long julian PROTO((long date));
+long unjulian PROTO((long date));
+long dssncasecmp PROTO((const char* s1, const char* s2, int n));
+long dsscasecmp PROTO((const char* s1, const char* s2));
+int pick_str PROTO((distribution * s, seed_t* seed, char* target));
+void agg_str PROTO((distribution * set, long count, seed_t* seed, char* dest));
+void read_dist
+    PROTO((const char* path, const char* name, distribution* target));
+void embed_str
+    PROTO((distribution * d, int min, int max, int stream, char* dest));
+#ifndef STDLIB_HAS_GETOPT
+int getopt PROTO((int arg_cnt, char** arg_vect, char* oprions));
+#endif /* STDLIB_HAS_GETOPT */
+DSS_HUGE set_state PROTO(
+    (int t, long scale, long procs, long step, DSS_HUGE* e, DBGenContext* ctx));
+
+/* rnd.c */
+DSS_HUGE NextRand PROTO((DSS_HUGE nSeed));
+DSS_HUGE UnifInt PROTO((DSS_HUGE nLow, DSS_HUGE nHigh, seed_t* seed));
+void dss_random(DSS_HUGE* tgt, DSS_HUGE min, DSS_HUGE max, seed_t* seed);
+void row_start(int t, DBGenContext* ctx);
+void row_stop_h(int t, DBGenContext* ctx);
+void dump_seeds_ds(int t, seed_t* seeds);
+
+/* text.c */
+#define MAX_GRAMMAR_LEN 12 /* max length of grammar component */
+#define MAX_SENT_LEN 256 /* max length of populated sentence */
+#define RNG_PER_SENT 27 /* max number of RNG calls per sentence */
+
+void init_text_pool PROTO((long bSize, DBGenContext* ctx));
+void free_text_pool PROTO(());
+
+void dbg_text PROTO((char* t, int min, int max, seed_t* seed));
+
+#ifdef DECLARER
+#define EXTERN
+#else
+#define EXTERN extern
+#endif /* DECLARER */
+
+EXTERN distribution nations;
+EXTERN distribution nations2;
+EXTERN distribution regions;
+EXTERN distribution o_priority_set;
+EXTERN distribution l_instruct_set;
+EXTERN distribution l_smode_set;
+EXTERN distribution l_category_set;
+EXTERN distribution l_rflag_set;
+EXTERN distribution c_mseg_set;
+EXTERN distribution colors;
+EXTERN distribution p_types_set;
+EXTERN distribution p_cntr_set;
+
+/* distributions that control text generation */
+EXTERN distribution articles;
+EXTERN distribution nouns;
+EXTERN distribution adjectives;
+EXTERN distribution adverbs;
+EXTERN distribution prepositions;
+EXTERN distribution verbs;
+EXTERN distribution terminators;
+EXTERN distribution auxillaries;
+EXTERN distribution np;
+EXTERN distribution vp;
+EXTERN distribution grammar;
+
+EXTERN int refresh;
+EXTERN int resume;
+EXTERN long verbose;
+EXTERN long force;
+EXTERN long updates;
+EXTERN long table;
+EXTERN long children;
+EXTERN int step;
+EXTERN int set_seeds;
+EXTERN char* d_path;
+
+/* added for segmented updates */
+EXTERN int insert_segments;
+EXTERN int delete_segments;
+EXTERN int insert_orders_segment;
+EXTERN int insert_lineitem_segment;
+EXTERN int delete_segment;
+
+/*****************************************************************
+ ** table level defines use the following naming convention: t_ccc_xxx
+ ** with: t, a table identifier
+ **       ccc, a column identifier
+ **       xxx, a limit type
+ ****************************************************************
+ */
+
+/*
+ * defines which control the parts table
+ */
+#define P_SIZE 126
+#define P_NAME_SCL 5
+#define P_MFG_TAG "Manufacturer#"
+#define P_MFG_FMT "%%s%%0%d%s"
+#define P_MFG_MIN 1
+#define P_MFG_MAX 5
+#define P_BRND_TAG "Brand#"
+#define P_BRND_FMT "%%s%%0%d%s"
+#define P_BRND_MIN 1
+#define P_BRND_MAX 5
+#define P_SIZE_MIN 1
+#define P_SIZE_MAX 50
+#define P_MCST_MIN 100
+#define P_MCST_MAX 99900
+#define P_MCST_SCL 100.0
+#define P_RCST_MIN 90000
+#define P_RCST_MAX 200000
+#define P_RCST_SCL 100.0
+/*
+ * defines which control the suppliers table
+ */
+#define S_SIZE 145
+#define S_NAME_TAG "Supplier#"
+#define S_NAME_FMT "%%s%%0%d%s"
+#define S_ABAL_MIN -99999
+#define S_ABAL_MAX 999999
+#define S_CMNT_MAX 101
+#define S_CMNT_BBB 10 /* number of BBB comments/SF */
+#define BBB_DEADBEATS 50 /* % that are complaints */
+#define BBB_BASE "Customer "
+#define BBB_COMPLAIN "Complaints"
+#define BBB_COMMEND "Recommends"
+#define BBB_CMNT_LEN 19
+#define BBB_BASE_LEN 9
+#define BBB_TYPE_LEN 10
+
+/*
+ * defines which control the partsupp table
+ */
+#define PS_SIZE 145
+#define PS_SKEY_MIN 0
+#define PS_SKEY_MAX ((ctx->tdefs[SUPP].base - 1) * ctx->scale_factor)
+#define PS_SCST_MIN 100
+#define PS_SCST_MAX 100000
+#define PS_QTY_MIN 1
+#define PS_QTY_MAX 9999
+/*
+ * defines which control the customers table
+ */
+#define C_SIZE 165
+#define C_NAME_TAG "Customer#"
+#define C_NAME_FMT "%%s%%0%d%s"
+#define C_MSEG_MAX 5
+#define C_ABAL_MIN -99999
+#define C_ABAL_MAX 999999
+/*
+ * defines which control the order table
+ */
+#define O_SIZE 109
+#define O_CKEY_MIN 1
+#define O_CKEY_MAX (ctx->tdefs[CUST].base * ctx->scale_factor)
+#define O_ODATE_MIN STARTDATE
+#define O_ODATE_MAX (STARTDATE + TOTDATE - (L_SDTE_MAX + L_RDTE_MAX) - 1)
+#define O_CLRK_TAG "Clerk#"
+#define O_CLRK_FMT "%%s%%0%d%s"
+#define O_CLRK_SCL 1000
+#define O_LCNT_MIN 1
+#define O_LCNT_MAX 7
+
+/*
+ * defines which control the lineitem table
+ */
+#define L_SIZE 144L
+#define L_QTY_MIN 1
+#define L_QTY_MAX 50
+#define L_TAX_MIN 0
+#define L_TAX_MAX 8
+#define L_DCNT_MIN 0
+#define L_DCNT_MAX 10
+#define L_PKEY_MIN 1
+#define L_PKEY_MAX (ctx->tdefs[PART].base * ctx->scale_factor)
+#define L_SDTE_MIN 1
+#define L_SDTE_MAX 121
+#define L_CDTE_MIN 30
+#define L_CDTE_MAX 90
+#define L_RDTE_MIN 1
+#define L_RDTE_MAX 30
+/*
+ * defines which control the time table
+ */
+#define T_SIZE 30
+#define T_START_DAY 3 /* wednesday ? */
+#define LEAP(y) ((!(y % 4) && (y % 100)) ? 1 : 0)
+
+/*******************************************************************
+ *******************************************************************
+ ***
+ *** general or inter table defines
+ ***
+ *******************************************************************
+ *******************************************************************/
+#define SUPP_PER_PART 4
+#define ORDERS_PER_CUST 10 /* sync this with CUST_MORTALITY */
+#define CUST_MORTALITY 3 /* portion with have no orders */
+#define NATIONS_MAX 90 /* limited by country codes in phone numbers */
+#define PHONE_FMT "%02d-%03d-%03d-%04d"
+#define STARTDATE 92001
+#define CURRENTDATE 95168
+#define ENDDATE 98365
+#define TOTDATE 2557
+#define UPD_PCT 10
+#define MAX_STREAM 47
+#define V_STR_LOW 0.4
+#define PENNIES 100 /* for scaled int money arithmetic */
+#define Q11_FRACTION (double)0.0001
+/*
+ * max and min SF in GB; Larger SF will require changes to the build routines
+ */
+#define MIN_SCALE 1.0
+#define MAX_SCALE 100000.0
+/*
+ * beyond this point we need to allow for BCD calculations
+ */
+#define MAX_32B_SCALE 1000.0
+#define LONG2HUGE(src, dst) *dst = (DSS_HUGE)src
+#define HUGE2LONG(src, dst) *dst = (long)src
+#define HUGE_SET(src, dst) *dst = *src
+#define HUGE_MUL(op1, op2) *op1 *= op2
+#define HUGE_DIV(op1, op2) *op1 /= op2
+#define HUGE_ADD(op1, op2, dst) *dst = *op1 + op2
+#define HUGE_SUB(op1, op2, dst) *dst = *op1 - op2
+#define HUGE_MOD(op1, op2) *op1 % op2
+#define HUGE_CMP(op1, op2) (*op1 == *op2) ? 0 : (*op1 < *op2) - 1 : 1
+
+/******** environmental variables and defaults ***************/
+#define DIST_TAG "DSS_DIST" /* environment var to override ... */
+#define DIST_DFLT "dists.dss" /* default file to hold distributions */
+#define PATH_TAG "DSS_PATH" /* environment var to override ... */
+#define PATH_DFLT "." /* default directory to hold tables */
+#define CONFIG_TAG "DSS_CONFIG" /* environment var to override ... */
+#define CONFIG_DFLT "." /* default directory to config files */
+#define ADHOC_TAG "DSS_ADHOC" /* environment var to override ... */
+#define ADHOC_DFLT "adhoc.dss" /* default file name for adhoc vars */
+
+/******* output macros ********/
+#ifndef SEPARATOR
+#define SEPARATOR '|' /* field spearator for generated flat files */
+#endif
+/* Data type flags for a single print routine */
+#define DT_STR 0
+#ifndef MVS
+#define DT_VSTR DT_STR
+#else
+#define DT_VSTR 1
+#endif /* MVS */
+#define DT_INT 2
+#define DT_HUGE 3
+#define DT_KEY 4
+#define DT_MONEY 5
+#define DT_CHR 6
+
+int dbg_print(int dt, FILE* tgt, void* data, int len, int eol);
+#define PR_STR(f, str, len) dbg_print(DT_STR, f, (void*)str, len, 1)
+#define PR_VSTR(f, str, len) dbg_print(DT_VSTR, f, (void*)str, len, 1)
+#define PR_VSTR_LAST(f, str, len) dbg_print(DT_VSTR, f, (void*)str, len, 0)
+#define PR_INT(f, str) dbg_print(DT_INT, f, (void*)str, 0, 1)
+#define PR_HUGE(f, str) dbg_print(DT_HUGE, f, (void*)str, 0, 1)
+#define PR_HUGE_LAST(f, str) dbg_print(DT_HUGE, f, (void*)str, 0, 0)
+#define PR_KEY(f, str) dbg_print(DT_KEY, f, (void*)str, 0, -1)
+#define PR_MONEY(f, str) dbg_print(DT_MONEY, f, (void*)str, 0, 1)
+#define PR_CHR(f, str) dbg_print(DT_CHR, f, (void*)str, 0, 1)
+#define PR_STRT(fp) /* any line prep for a record goes here */
+#define PR_END(fp) fprintf(fp, "\n") /* finish the record here */
+#ifdef MDY_DATE
+#define PR_DATE(tgt, yr, mn, dy) sprintf(tgt, "%02d-%02d-19%02d", mn, dy, yr)
+#else
+#define PR_DATE(tgt, yr, mn, dy) sprintf(tgt, "19%02ld-%02ld-%02ld", yr, mn, dy)
+#endif /* DATE_FORMAT */
+
+/*
+ * verification macros
+ */
+#define VRF_STR(t, d)                \
+  {                                  \
+    char* xx = d;                    \
+    while (*xx)                      \
+      ctx->tdefs[t].vtotal += *xx++; \
+  }
+#define VRF_INT(t, d) ctx->tdefs[t].vtotal += d
+#define VRF_HUGE(t, d) ctx->tdefs[t].vtotal = *((long*)&d) + *((long*)(&d + 1))
+/* assume float is a 64 bit quantity */
+#define VRF_MONEY(t, d) ctx->tdefs[t].vtotal = *((long*)&d) + *((long*)(&d + 1))
+#define VRF_CHR(t, d) ctx->tdefs[t].vtotal += d
+#define VRF_STRT(t)
+#define VRF_END(t)
+
+/*********** distribuitons currently defined *************/
+#define UNIFORM 0
+
+/*
+ * seed indexes; used to separate the generation of individual columns
+ */
+#define P_MFG_SD 0
+#define P_BRND_SD 1
+#define P_TYPE_SD 2
+#define P_SIZE_SD 3
+#define P_CNTR_SD 4
+#define P_RCST_SD 5
+#define PS_QTY_SD 7
+#define PS_SCST_SD 8
+#define O_SUPP_SD 10
+#define O_CLRK_SD 11
+#define O_ODATE_SD 13
+#define L_QTY_SD 14
+#define L_DCNT_SD 15
+#define L_TAX_SD 16
+#define L_SHIP_SD 17
+#define L_SMODE_SD 18
+#define L_PKEY_SD 19
+#define L_SKEY_SD 20
+#define L_SDTE_SD 21
+#define L_CDTE_SD 22
+#define L_RDTE_SD 23
+#define L_RFLG_SD 24
+#define C_NTRG_SD 27
+#define C_PHNE_SD 28
+#define C_ABAL_SD 29
+#define C_MSEG_SD 30
+#define S_NTRG_SD 33
+#define S_PHNE_SD 34
+#define S_ABAL_SD 35
+#define P_NAME_SD 37
+#define O_PRIO_SD 38
+#define HVAR_SD 39
+#define O_CKEY_SD 40
+#define N_CMNT_SD 41
+#define R_CMNT_SD 42
+#define O_LCNT_SD 43
+#define BBB_JNK_SD 44
+#define BBB_TYPE_SD 45
+#define BBB_CMNT_SD 46
+#define BBB_OFFSET_SD 47
+
+struct DBGenContext {
+  seed_t Seed[MAX_STREAM + 1] = {
+      {PART, 1, 0, 1}, /* P_MFG_SD     0 */
+      {PART, 46831694, 0, 1}, /* P_BRND_SD    1 */
+      {PART, 1841581359, 0, 1}, /* P_TYPE_SD    2 */
+      {PART, 1193163244, 0, 1}, /* P_SIZE_SD    3 */
+      {PART, 727633698, 0, 1}, /* P_CNTR_SD    4 */
+      {NONE, 933588178, 0, 1}, /* text pregeneration  5 */
+      {PART, 804159733, 0, 2}, /* P_CMNT_SD    6 */
+      {PSUPP, 1671059989, 0, SUPP_PER_PART}, /* PS_QTY_SD    7 */
+      {PSUPP, 1051288424, 0, SUPP_PER_PART}, /* PS_SCST_SD   8 */
+      {PSUPP, 1961692154, 0, SUPP_PER_PART * 2}, /* PS_CMNT_SD   9 */
+      {ORDER, 1227283347, 0, 1}, /* O_SUPP_SD    10 */
+      {ORDER, 1171034773, 0, 1}, /* O_CLRK_SD    11 */
+      {ORDER, 276090261, 0, 2}, /* O_CMNT_SD    12 */
+      {ORDER, 1066728069, 0, 1}, /* O_ODATE_SD   13 */
+      {LINE, 209208115, 0, O_LCNT_MAX}, /* L_QTY_SD     14 */
+      {LINE, 554590007, 0, O_LCNT_MAX}, /* L_DCNT_SD    15 */
+      {LINE, 721958466, 0, O_LCNT_MAX}, /* L_TAX_SD     16 */
+      {LINE, 1371272478, 0, O_LCNT_MAX}, /* L_SHIP_SD    17 */
+      {LINE, 675466456, 0, O_LCNT_MAX}, /* L_SMODE_SD   18 */
+      {LINE, 1808217256, 0, O_LCNT_MAX}, /* L_PKEY_SD    19 */
+      {LINE, 2095021727, 0, O_LCNT_MAX}, /* L_SKEY_SD    20 */
+      {LINE, 1769349045, 0, O_LCNT_MAX}, /* L_SDTE_SD    21 */
+      {LINE, 904914315, 0, O_LCNT_MAX}, /* L_CDTE_SD    22 */
+      {LINE, 373135028, 0, O_LCNT_MAX}, /* L_RDTE_SD    23 */
+      {LINE, 717419739, 0, O_LCNT_MAX}, /* L_RFLG_SD    24 */
+      {LINE, 1095462486, 0, O_LCNT_MAX * 2}, /* L_CMNT_SD    25 */
+      {CUST, 881155353, 0, 9}, /* C_ADDR_SD    26 */
+      {CUST, 1489529863, 0, 1}, /* C_NTRG_SD    27 */
+      {CUST, 1521138112, 0, 3}, /* C_PHNE_SD    28 */
+      {CUST, 298370230, 0, 1}, /* C_ABAL_SD    29 */
+      {CUST, 1140279430, 0, 1}, /* C_MSEG_SD    30 */
+      {CUST, 1335826707, 0, 2}, /* C_CMNT_SD    31 */
+      {SUPP, 706178559, 0, 9}, /* S_ADDR_SD    32 */
+      {SUPP, 110356601, 0, 1}, /* S_NTRG_SD    33 */
+      {SUPP, 884434366, 0, 3}, /* S_PHNE_SD    34 */
+      {SUPP, 962338209, 0, 1}, /* S_ABAL_SD    35 */
+      {SUPP, 1341315363, 0, 2}, /* S_CMNT_SD    36 */
+      {PART, 709314158, 0, 92}, /* P_NAME_SD    37 */
+      {ORDER, 591449447, 0, 1}, /* O_PRIO_SD    38 */
+      {LINE, 431918286, 0, 1}, /* HVAR_SD      39 */
+      {ORDER, 851767375, 0, 1}, /* O_CKEY_SD    40 */
+      {NATION, 606179079, 0, 2}, /* N_CMNT_SD    41 */
+      {REGION, 1500869201, 0, 2}, /* R_CMNT_SD    42 */
+      {ORDER, 1434868289, 0, 1}, /* O_LCNT_SD    43 */
+      {SUPP, 263032577, 0, 1}, /* BBB offset   44 */
+      {SUPP, 753643799, 0, 1}, /* BBB type     45 */
+      {SUPP, 202794285, 0, 1}, /* BBB comment  46 */
+      {SUPP, 715851524, 0, 1} /* BBB junk     47 */
+  };
+
+  static constexpr double dM = 2147483647.0;
+
+  tdef tdefs[10] = {
+      {"part.tbl", "part table", 200000, nullptr, nullptr, PSUPP, 0},
+      {"partsupp.tbl", "partsupplier table", 200000, nullptr, nullptr, NONE, 0},
+      {"supplier.tbl", "suppliers table", 10000, nullptr, nullptr, NONE, 0},
+      {"customer.tbl", "customers table", 150000, nullptr, nullptr, NONE, 0},
+      {"orders.tbl", "order table", 150000, nullptr, nullptr, LINE, 0},
+      {"lineitem.tbl", "lineitem table", 150000, nullptr, nullptr, NONE, 0},
+      {"orders.tbl",
+       "orders/lineitem tables",
+       150000,
+       nullptr,
+       nullptr,
+       LINE,
+       0},
+      {"part.tbl", "part/partsupplier tables", 200000, NULL, NULL, PSUPP, 0},
+      {"nation.tbl", "nation table", NATIONS_MAX, NULL, NULL, NONE, 0},
+      {"region.tbl", "region table", NATIONS_MAX, NULL, NULL, NONE, 0},
+  };
+
+  long scale_factor = 1;
+};
+
+#endif /* DSS_H */
diff --git a/velox/tpch/gen/dbgen/include/dbgen/dsstypes.h b/velox/tpch/gen/dbgen/include/dbgen/dsstypes.h
new file mode 100644
index 0000000000000..056c814349e40
--- /dev/null
+++ b/velox/tpch/gen/dbgen/include/dbgen/dsstypes.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+/*
+ * general definitions and control information for the DSS data types
+ * and function prototypes
+ */
+
+#pragma once
+
+/*
+ * typedefs
+ */
+typedef struct {
+  DSS_HUGE custkey;
+  char name[C_NAME_LEN + 3];
+  char address[C_ADDR_MAX + 1];
+  int alen;
+  DSS_HUGE nation_code;
+  char phone[PHONE_LEN + 1];
+  DSS_HUGE acctbal;
+  char mktsegment[MAXAGG_LEN + 1];
+  char comment[C_CMNT_MAX + 1];
+  int clen;
+} customer_t;
+/* customers.c */
+long mk_cust PROTO((DSS_HUGE n_cust, customer_t* c, DBGenContext* ctx));
+int pr_cust PROTO((customer_t * c, int mode));
+int ld_cust PROTO((customer_t * c, int mode));
+
+typedef struct {
+  DSS_HUGE okey;
+  DSS_HUGE partkey;
+  DSS_HUGE suppkey;
+  DSS_HUGE lcnt;
+  DSS_HUGE quantity;
+  DSS_HUGE eprice;
+  DSS_HUGE discount;
+  DSS_HUGE tax;
+  char rflag[1];
+  char lstatus[1];
+  char cdate[DATE_LEN];
+  char sdate[DATE_LEN];
+  char rdate[DATE_LEN];
+  char shipinstruct[MAXAGG_LEN + 1];
+  char shipmode[MAXAGG_LEN + 1];
+  char comment[L_CMNT_MAX + 1];
+  int clen;
+} line_t;
+
+typedef struct {
+  DSS_HUGE okey;
+  DSS_HUGE custkey;
+  char orderstatus;
+  DSS_HUGE totalprice;
+  char odate[DATE_LEN];
+  char opriority[MAXAGG_LEN + 1];
+  char clerk[O_CLRK_LEN + 1];
+  long spriority;
+  DSS_HUGE lines;
+  char comment[O_CMNT_MAX + 1];
+  int clen;
+  line_t l[O_LCNT_MAX];
+} order_t;
+
+/* order.c */
+long mk_order
+    PROTO((DSS_HUGE index, order_t* o, DBGenContext* ctx, long upd_num));
+int pr_order PROTO((order_t * o, int mode));
+int ld_order PROTO((order_t * o, int mode));
+void mk_sparse PROTO((DSS_HUGE index, DSS_HUGE* ok, long seq));
+
+typedef struct {
+  DSS_HUGE partkey;
+  DSS_HUGE suppkey;
+  DSS_HUGE qty;
+  DSS_HUGE scost;
+  char comment[PS_CMNT_MAX + 1];
+  int clen;
+} partsupp_t;
+
+typedef struct {
+  DSS_HUGE partkey;
+  char name[P_NAME_LEN + 1];
+  int nlen;
+  char mfgr[P_MFG_LEN + 1];
+  char brand[P_BRND_LEN + 1];
+  char type[P_TYPE_LEN + 1];
+  int tlen;
+  DSS_HUGE size;
+  char container[P_CNTR_LEN + 1];
+  DSS_HUGE retailprice;
+  char comment[P_CMNT_MAX + 1];
+  int clen;
+  partsupp_t s[SUPP_PER_PART];
+} part_t;
+
+/* parts.c */
+long mk_part PROTO((DSS_HUGE index, part_t* p, DBGenContext* ctx));
+int pr_part PROTO((part_t * part, int mode));
+int ld_part PROTO((part_t * part, int mode));
+
+typedef struct {
+  DSS_HUGE suppkey;
+  char name[S_NAME_LEN + 1];
+  char address[S_ADDR_MAX + 1];
+  int alen;
+  DSS_HUGE nation_code;
+  char phone[PHONE_LEN + 1];
+  DSS_HUGE acctbal;
+  char comment[S_CMNT_MAX + 1];
+  int clen;
+} supplier_t;
+/* supplier.c */
+long mk_supp PROTO((DSS_HUGE index, supplier_t* s, DBGenContext* ctx));
+int pr_supp PROTO((supplier_t * supp, int mode));
+int ld_supp PROTO((supplier_t * supp, int mode));
+
+typedef struct {
+  DSS_HUGE timekey;
+  char alpha[DATE_LEN];
+  long year;
+  long month;
+  long week;
+  long day;
+} dss_time_t;
+
+/* time.c */
+long mk_time PROTO((DSS_HUGE h, dss_time_t* t));
+
+/*
+ * this assumes that N_CMNT_LEN >= R_CMNT_LEN
+ */
+typedef struct {
+  DSS_HUGE code;
+  char* text;
+  long join;
+  char comment[N_CMNT_MAX + 1];
+  int clen;
+} code_t;
+
+/* code table */
+int mk_nation PROTO((DSS_HUGE i, code_t* c, DBGenContext* ctx));
+int pr_nation PROTO((code_t * c, int mode));
+int ld_nation PROTO((code_t * c, int mode));
+int mk_region PROTO((DSS_HUGE i, code_t* c, DBGenContext* ctx));
+int pr_region PROTO((code_t * c, int mode));
+int ld_region PROTO((code_t * c, int mode));
+
+/* speed seed - advances seeds `skip_count` times */
+long sd_nation(int child, DSS_HUGE skip_count, DBGenContext* ctx);
+long sd_region(int child, DSS_HUGE skip_coun, DBGenContext* ctx);
+long sd_order(int child, DSS_HUGE skip_count, DBGenContext* ctx);
+long sd_line(int child, DSS_HUGE skip_count, DBGenContext* ctx);
+long sd_supp(int child, DSS_HUGE skip_count, DBGenContext* ctx);
+long sd_part(int child, DSS_HUGE skip_count, DBGenContext* ctx);
+long sd_psupp(int child, DSS_HUGE skip_count, DBGenContext* ctx);
+long sd_cust(int child, DSS_HUGE skip_count, DBGenContext* ctx);
diff --git a/velox/tpch/gen/dbgen/include/dbgen/permute.h b/velox/tpch/gen/dbgen/include/dbgen/permute.h
new file mode 100644
index 0000000000000..e2939f8a83666
--- /dev/null
+++ b/velox/tpch/gen/dbgen/include/dbgen/permute.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+long permutation[41][22] = {
+    {14, 2,  9, 20, 6,  17, 18, 8,  21, 13, 3,
+     22, 16, 4, 11, 15, 1,  10, 19, 5,  7,  12},
+    {21, 3,  18, 5, 11, 7,  6,  20, 17, 12, 16,
+     15, 13, 10, 2, 8,  14, 19, 9,  22, 1,  4},
+    {6,  17, 14, 16, 19, 10, 9, 2,  15, 8,  5,
+     22, 12, 7,  13, 18, 1,  4, 20, 3,  11, 21},
+    {8,  5,  4,  6,  17, 7,  1,  18, 22, 14, 9,
+     10, 15, 11, 20, 2,  21, 19, 13, 16, 12, 3},
+    {5,  21, 14, 19, 15, 17, 12, 6, 4,  9, 8,
+     16, 11, 2,  10, 18, 1,  13, 7, 22, 3, 20},
+    {21, 15, 4, 6, 7, 16, 19, 18, 14, 22, 11,
+     13, 3,  1, 2, 5, 8,  20, 12, 17, 10, 9},
+    {10, 3,  15, 13, 6,  8, 9,  7,  4,  11, 22,
+     18, 12, 1,  5,  16, 2, 14, 19, 20, 17, 21},
+    {18, 8, 20, 21, 2, 4,  22, 17, 1,  11, 9,
+     19, 3, 13, 5,  7, 10, 16, 6,  14, 15, 12},
+    {19, 1,  15, 17, 5,  8,  9,  12, 14, 7,  4,
+     3,  20, 16, 6,  22, 10, 13, 2,  21, 18, 11},
+    {8,  13, 2, 20, 17, 3, 6,  21, 18, 11, 19,
+     10, 15, 4, 22, 1,  7, 12, 9,  14, 5,  16},
+    {6,  15, 18, 17, 12, 1,  7,  2,  22, 13, 21,
+     10, 14, 9,  3,  16, 20, 19, 11, 4,  8,  5},
+    {15, 14, 18, 17, 10, 20, 16, 11, 1, 8,  4,
+     22, 5,  12, 3,  9,  21, 2,  13, 6, 19, 7},
+    {1, 7, 16, 17, 18, 22, 12, 6,  8, 9,  11,
+     4, 2, 5,  20, 21, 13, 10, 19, 3, 14, 15},
+    {21, 17, 7, 3, 1,  10, 12, 22, 9,  16, 6,
+     11, 2,  4, 5, 14, 8,  20, 13, 18, 15, 19},
+    {2,  9,  5,  4,  18, 1,  20, 15, 16, 17, 7,
+     21, 13, 14, 19, 8,  22, 11, 10, 3,  12, 6},
+    {16, 9,  17, 8,  14, 11, 10, 12, 6, 21, 7,
+     3,  15, 5,  22, 20, 1,  13, 19, 2, 4,  18},
+    {1, 3,  6,  5,  2, 16, 14, 22, 17, 20, 4,
+     9, 10, 11, 15, 8, 12, 19, 18, 13, 7,  21},
+    {3, 16, 5,  11, 21, 9, 2, 15, 10, 18, 17,
+     7, 8,  19, 14, 13, 1, 4, 22, 20, 6,  12},
+    {14, 4, 13, 5,  21, 11, 8,  6,  3, 17, 2,
+     20, 1, 19, 10, 9,  12, 18, 15, 7, 22, 16},
+    {4, 12, 22, 14, 5, 15, 16, 2,  8,  10, 17,
+     9, 21, 7,  3,  6, 13, 18, 11, 20, 19, 1},
+    {16, 15, 14, 13, 4, 22, 18, 19, 7, 1, 12,
+     17, 5,  10, 20, 3, 9,  21, 11, 2, 6, 8},
+    {20, 14, 21, 12, 15, 17, 4,  19, 13, 10, 11,
+     1,  16, 5,  18, 7,  8,  22, 9,  6,  3,  2},
+    {16, 14, 13, 2, 21, 10, 11, 4,  1,  22, 18,
+     12, 19, 5,  7, 8,  6,  3,  15, 20, 9,  17},
+    {18, 15, 9,  14, 12, 2,  8, 11, 22, 21, 16,
+     1,  6,  17, 5,  10, 19, 4, 20, 13, 3,  7},
+    {7, 3,  10, 14, 13, 21, 18, 6,  20, 4,  9,
+     8, 22, 15, 2,  1,  5,  12, 19, 17, 11, 16},
+    {18, 1,  13, 7, 16, 10, 14, 2, 19, 5, 21,
+     11, 22, 15, 8, 17, 20, 3,  4, 12, 6, 9},
+    {13, 2,  22, 5, 11, 21, 20, 14, 7,  10, 4,
+     9,  19, 18, 6, 3,  1,  8,  15, 12, 17, 16},
+    {14, 17, 21, 8, 2,  9,  6,  4,  5,  13, 22,
+     7,  15, 3,  1, 18, 16, 11, 10, 12, 20, 19},
+    {10, 22, 1, 12, 13, 18, 21, 20, 2, 14, 16,
+     7,  15, 3, 4,  17, 5,  19, 6,  8, 9,  11},
+    {10, 8,  9, 18, 12, 6,  1,  5,  20, 11, 17,
+     22, 16, 3, 13, 2,  15, 21, 14, 19, 7,  4},
+    {7,  17, 22, 5,  3,  10, 13, 18, 9,  1, 14,
+     15, 21, 19, 16, 12, 8,  6,  11, 20, 4, 2},
+    {2,  9,  21, 3,  4,  7,  1,  11, 16, 5,  20,
+     19, 18, 8,  17, 13, 10, 12, 15, 6,  14, 22},
+    {15, 12, 8, 4, 22, 13, 16, 17, 18, 3,  7,
+     5,  6,  1, 9, 11, 21, 10, 14, 20, 19, 2},
+    {15, 16, 2, 11, 17, 7,  5, 14, 20, 4,  21,
+     3,  10, 9, 12, 8,  13, 6, 18, 19, 22, 1},
+    {1, 13, 11, 3,  4,  21, 6,  14, 15, 22, 18,
+     9, 7,  5,  10, 20, 12, 16, 17, 8,  19, 2},
+    {14, 17, 22, 20, 8,  16, 5, 10, 1,  13, 2,
+     21, 12, 9,  4,  18, 3,  7, 6,  19, 15, 11},
+    {9, 17, 7,  4,  5,  13, 21, 18, 11, 3,  22,
+     1, 6,  16, 20, 14, 15, 10, 8,  2,  12, 19},
+    {13, 14, 5, 22, 19, 11, 9, 6,  18, 15, 8,
+     10, 7,  4, 17, 16, 3,  1, 12, 2,  21, 20},
+    {20, 5, 4,  14, 11, 1,  6,  16, 8,  22, 7,
+     3,  2, 12, 21, 19, 17, 13, 10, 15, 18, 9},
+    {3,  7,  14, 15, 6, 5, 21, 20, 18, 10, 4,
+     16, 19, 1,  13, 9, 8, 17, 11, 12, 22, 2},
+    {13, 15, 17, 1, 22, 11, 3, 4,  7,  20, 14,
+     21, 9,  8,  2, 18, 16, 6, 10, 12, 5,  19}};
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/release.h b/velox/tpch/gen/dbgen/include/dbgen/release.h
similarity index 100%
rename from velox/external/duckdb/tpch/dbgen/include/dbgen/release.h
rename to velox/tpch/gen/dbgen/include/dbgen/release.h
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/rnd.h b/velox/tpch/gen/dbgen/include/dbgen/rnd.h
similarity index 100%
rename from velox/external/duckdb/tpch/dbgen/include/dbgen/rnd.h
rename to velox/tpch/gen/dbgen/include/dbgen/rnd.h
diff --git a/velox/tpch/gen/dbgen/include/dbgen/rng64.h b/velox/tpch/gen/dbgen/include/dbgen/rng64.h
new file mode 100644
index 0000000000000..974cc9f69b707
--- /dev/null
+++ b/velox/tpch/gen/dbgen/include/dbgen/rng64.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+#pragma once
+
+#include "dbgen/config.h" // @manual
+#include "dbgen/dss.h" // @manual
+
+DSS_HUGE AdvanceRand64(DSS_HUGE nSeed, DSS_HUGE nCount);
+void dss_random64(DSS_HUGE* tgt, DSS_HUGE nLow, DSS_HUGE nHigh, seed_t* seed);
+DSS_HUGE NextRand64(DSS_HUGE nSeed);
diff --git a/velox/external/duckdb/tpch/dbgen/include/dbgen/shared.h b/velox/tpch/gen/dbgen/include/dbgen/shared.h
similarity index 100%
rename from velox/external/duckdb/tpch/dbgen/include/dbgen/shared.h
rename to velox/tpch/gen/dbgen/include/dbgen/shared.h
diff --git a/velox/tpch/gen/dbgen/include/tpch_constants.hpp b/velox/tpch/gen/dbgen/include/tpch_constants.hpp
new file mode 100644
index 0000000000000..8fcc6c3c88423
--- /dev/null
+++ b/velox/tpch/gen/dbgen/include/tpch_constants.hpp
@@ -0,0 +1,60703 @@
+/* THIS FILE WAS AUTOMATICALLY GENERATED BY generate_csv_header.py */
+
+#pragma once
+
+const int TPCH_QUERIES_COUNT = 22;
+const uint8_t TPCH_QUERIES_q01[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  108, 95,  114, 101,
+    116, 117, 114, 110, 102, 108, 97,  103, 44,  10,  32,  32,  32,  32,  108,
+    95,  108, 105, 110, 101, 115, 116, 97,  116, 117, 115, 44,  10,  32,  32,
+    32,  32,  115, 117, 109, 40,  108, 95,  113, 117, 97,  110, 116, 105, 116,
+    121, 41,  32,  65,  83,  32,  115, 117, 109, 95,  113, 116, 121, 44,  10,
+    32,  32,  32,  32,  115, 117, 109, 40,  108, 95,  101, 120, 116, 101, 110,
+    100, 101, 100, 112, 114, 105, 99,  101, 41,  32,  65,  83,  32,  115, 117,
+    109, 95,  98,  97,  115, 101, 95,  112, 114, 105, 99,  101, 44,  10,  32,
+    32,  32,  32,  115, 117, 109, 40,  108, 95,  101, 120, 116, 101, 110, 100,
+    101, 100, 112, 114, 105, 99,  101, 32,  42,  32,  40,  49,  32,  45,  32,
+    108, 95,  100, 105, 115, 99,  111, 117, 110, 116, 41,  41,  32,  65,  83,
+    32,  115, 117, 109, 95,  100, 105, 115, 99,  95,  112, 114, 105, 99,  101,
+    44,  10,  32,  32,  32,  32,  115, 117, 109, 40,  108, 95,  101, 120, 116,
+    101, 110, 100, 101, 100, 112, 114, 105, 99,  101, 32,  42,  32,  40,  49,
+    32,  45,  32,  108, 95,  100, 105, 115, 99,  111, 117, 110, 116, 41,  32,
+    42,  32,  40,  49,  32,  43,  32,  108, 95,  116, 97,  120, 41,  41,  32,
+    65,  83,  32,  115, 117, 109, 95,  99,  104, 97,  114, 103, 101, 44,  10,
+    32,  32,  32,  32,  97,  118, 103, 40,  108, 95,  113, 117, 97,  110, 116,
+    105, 116, 121, 41,  32,  65,  83,  32,  97,  118, 103, 95,  113, 116, 121,
+    44,  10,  32,  32,  32,  32,  97,  118, 103, 40,  108, 95,  101, 120, 116,
+    101, 110, 100, 101, 100, 112, 114, 105, 99,  101, 41,  32,  65,  83,  32,
+    97,  118, 103, 95,  112, 114, 105, 99,  101, 44,  10,  32,  32,  32,  32,
+    97,  118, 103, 40,  108, 95,  100, 105, 115, 99,  111, 117, 110, 116, 41,
+    32,  65,  83,  32,  97,  118, 103, 95,  100, 105, 115, 99,  44,  10,  32,
+    32,  32,  32,  99,  111, 117, 110, 116, 40,  42,  41,  32,  65,  83,  32,
+    99,  111, 117, 110, 116, 95,  111, 114, 100, 101, 114, 10,  70,  82,  79,
+    77,  10,  32,  32,  32,  32,  108, 105, 110, 101, 105, 116, 101, 109, 10,
+    87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  108, 95,  115, 104, 105,
+    112, 100, 97,  116, 101, 32,  60,  61,  32,  67,  65,  83,  84,  40,  39,
+    49,  57,  57,  56,  45,  48,  57,  45,  48,  50,  39,  32,  65,  83,  32,
+    100, 97,  116, 101, 41,  10,  71,  82,  79,  85,  80,  32,  66,  89,  10,
+    32,  32,  32,  32,  108, 95,  114, 101, 116, 117, 114, 110, 102, 108, 97,
+    103, 44,  10,  32,  32,  32,  32,  108, 95,  108, 105, 110, 101, 115, 116,
+    97,  116, 117, 115, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,
+    32,  32,  32,  108, 95,  114, 101, 116, 117, 114, 110, 102, 108, 97,  103,
+    44,  10,  32,  32,  32,  32,  108, 95,  108, 105, 110, 101, 115, 116, 97,
+    116, 117, 115, 59,  10,  0};
+const uint8_t TPCH_QUERIES_q02[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  115, 95,  97,  99,
+    99,  116, 98,  97,  108, 44,  10,  32,  32,  32,  32,  115, 95,  110, 97,
+    109, 101, 44,  10,  32,  32,  32,  32,  110, 95,  110, 97,  109, 101, 44,
+    10,  32,  32,  32,  32,  112, 95,  112, 97,  114, 116, 107, 101, 121, 44,
+    10,  32,  32,  32,  32,  112, 95,  109, 102, 103, 114, 44,  10,  32,  32,
+    32,  32,  115, 95,  97,  100, 100, 114, 101, 115, 115, 44,  10,  32,  32,
+    32,  32,  115, 95,  112, 104, 111, 110, 101, 44,  10,  32,  32,  32,  32,
+    115, 95,  99,  111, 109, 109, 101, 110, 116, 10,  70,  82,  79,  77,  10,
+    32,  32,  32,  32,  112, 97,  114, 116, 44,  10,  32,  32,  32,  32,  115,
+    117, 112, 112, 108, 105, 101, 114, 44,  10,  32,  32,  32,  32,  112, 97,
+    114, 116, 115, 117, 112, 112, 44,  10,  32,  32,  32,  32,  110, 97,  116,
+    105, 111, 110, 44,  10,  32,  32,  32,  32,  114, 101, 103, 105, 111, 110,
+    10,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  112, 95,  112, 97,
+    114, 116, 107, 101, 121, 32,  61,  32,  112, 115, 95,  112, 97,  114, 116,
+    107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  115, 95,  115,
+    117, 112, 112, 107, 101, 121, 32,  61,  32,  112, 115, 95,  115, 117, 112,
+    112, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  112, 95,
+    115, 105, 122, 101, 32,  61,  32,  49,  53,  10,  32,  32,  32,  32,  65,
+    78,  68,  32,  112, 95,  116, 121, 112, 101, 32,  76,  73,  75,  69,  32,
+    39,  37,  66,  82,  65,  83,  83,  39,  10,  32,  32,  32,  32,  65,  78,
+    68,  32,  115, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 32,  61,
+    32,  110, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 10,  32,  32,
+    32,  32,  65,  78,  68,  32,  110, 95,  114, 101, 103, 105, 111, 110, 107,
+    101, 121, 32,  61,  32,  114, 95,  114, 101, 103, 105, 111, 110, 107, 101,
+    121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  114, 95,  110, 97,  109,
+    101, 32,  61,  32,  39,  69,  85,  82,  79,  80,  69,  39,  10,  32,  32,
+    32,  32,  65,  78,  68,  32,  112, 115, 95,  115, 117, 112, 112, 108, 121,
+    99,  111, 115, 116, 32,  61,  32,  40,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  109, 105, 110, 40,  112, 115, 95,  115, 117,
+    112, 112, 108, 121, 99,  111, 115, 116, 41,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  112, 97,  114, 116, 115, 117, 112, 112, 44,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  115, 117, 112,
+    112, 108, 105, 101, 114, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  110, 97,  116, 105, 111, 110, 44,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  114, 101, 103, 105, 111, 110,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  87,  72,  69,  82,  69,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  112, 95,  112,
+    97,  114, 116, 107, 101, 121, 32,  61,  32,  112, 115, 95,  112, 97,  114,
+    116, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  65,  78,  68,  32,  115, 95,  115, 117, 112, 112, 107, 101, 121,
+    32,  61,  32,  112, 115, 95,  115, 117, 112, 112, 107, 101, 121, 10,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,
+    115, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 32,  61,  32,  110,
+    95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 10,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  110, 95,  114,
+    101, 103, 105, 111, 110, 107, 101, 121, 32,  61,  32,  114, 95,  114, 101,
+    103, 105, 111, 110, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  65,  78,  68,  32,  114, 95,  110, 97,  109, 101,
+    32,  61,  32,  39,  69,  85,  82,  79,  80,  69,  39,  41,  10,  79,  82,
+    68,  69,  82,  32,  66,  89,  10,  32,  32,  32,  32,  115, 95,  97,  99,
+    99,  116, 98,  97,  108, 32,  68,  69,  83,  67,  44,  10,  32,  32,  32,
+    32,  110, 95,  110, 97,  109, 101, 44,  10,  32,  32,  32,  32,  115, 95,
+    110, 97,  109, 101, 44,  10,  32,  32,  32,  32,  112, 95,  112, 97,  114,
+    116, 107, 101, 121, 10,  76,  73,  77,  73,  84,  32,  49,  48,  48,  59,
+    10,  0};
+const uint8_t TPCH_QUERIES_q03[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  108, 95,  111, 114,
+    100, 101, 114, 107, 101, 121, 44,  10,  32,  32,  32,  32,  115, 117, 109,
+    40,  108, 95,  101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,
+    101, 32,  42,  32,  40,  49,  32,  45,  32,  108, 95,  100, 105, 115, 99,
+    111, 117, 110, 116, 41,  41,  32,  65,  83,  32,  114, 101, 118, 101, 110,
+    117, 101, 44,  10,  32,  32,  32,  32,  111, 95,  111, 114, 100, 101, 114,
+    100, 97,  116, 101, 44,  10,  32,  32,  32,  32,  111, 95,  115, 104, 105,
+    112, 112, 114, 105, 111, 114, 105, 116, 121, 10,  70,  82,  79,  77,  10,
+    32,  32,  32,  32,  99,  117, 115, 116, 111, 109, 101, 114, 44,  10,  32,
+    32,  32,  32,  111, 114, 100, 101, 114, 115, 44,  10,  32,  32,  32,  32,
+    108, 105, 110, 101, 105, 116, 101, 109, 10,  87,  72,  69,  82,  69,  10,
+    32,  32,  32,  32,  99,  95,  109, 107, 116, 115, 101, 103, 109, 101, 110,
+    116, 32,  61,  32,  39,  66,  85,  73,  76,  68,  73,  78,  71,  39,  10,
+    32,  32,  32,  32,  65,  78,  68,  32,  99,  95,  99,  117, 115, 116, 107,
+    101, 121, 32,  61,  32,  111, 95,  99,  117, 115, 116, 107, 101, 121, 10,
+    32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  111, 114, 100, 101, 114,
+    107, 101, 121, 32,  61,  32,  111, 95,  111, 114, 100, 101, 114, 107, 101,
+    121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  111, 95,  111, 114, 100,
+    101, 114, 100, 97,  116, 101, 32,  60,  32,  67,  65,  83,  84,  40,  39,
+    49,  57,  57,  53,  45,  48,  51,  45,  49,  53,  39,  32,  65,  83,  32,
+    100, 97,  116, 101, 41,  10,  32,  32,  32,  32,  65,  78,  68,  32,  108,
+    95,  115, 104, 105, 112, 100, 97,  116, 101, 32,  62,  32,  67,  65,  83,
+    84,  40,  39,  49,  57,  57,  53,  45,  48,  51,  45,  49,  53,  39,  32,
+    65,  83,  32,  100, 97,  116, 101, 41,  10,  71,  82,  79,  85,  80,  32,
+    66,  89,  10,  32,  32,  32,  32,  108, 95,  111, 114, 100, 101, 114, 107,
+    101, 121, 44,  10,  32,  32,  32,  32,  111, 95,  111, 114, 100, 101, 114,
+    100, 97,  116, 101, 44,  10,  32,  32,  32,  32,  111, 95,  115, 104, 105,
+    112, 112, 114, 105, 111, 114, 105, 116, 121, 10,  79,  82,  68,  69,  82,
+    32,  66,  89,  10,  32,  32,  32,  32,  114, 101, 118, 101, 110, 117, 101,
+    32,  68,  69,  83,  67,  44,  10,  32,  32,  32,  32,  111, 95,  111, 114,
+    100, 101, 114, 100, 97,  116, 101, 10,  76,  73,  77,  73,  84,  32,  49,
+    48,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q04[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  111, 95,  111, 114,
+    100, 101, 114, 112, 114, 105, 111, 114, 105, 116, 121, 44,  10,  32,  32,
+    32,  32,  99,  111, 117, 110, 116, 40,  42,  41,  32,  65,  83,  32,  111,
+    114, 100, 101, 114, 95,  99,  111, 117, 110, 116, 10,  70,  82,  79,  77,
+    10,  32,  32,  32,  32,  111, 114, 100, 101, 114, 115, 10,  87,  72,  69,
+    82,  69,  10,  32,  32,  32,  32,  111, 95,  111, 114, 100, 101, 114, 100,
+    97,  116, 101, 32,  62,  61,  32,  67,  65,  83,  84,  40,  39,  49,  57,
+    57,  51,  45,  48,  55,  45,  48,  49,  39,  32,  65,  83,  32,  100, 97,
+    116, 101, 41,  10,  32,  32,  32,  32,  65,  78,  68,  32,  111, 95,  111,
+    114, 100, 101, 114, 100, 97,  116, 101, 32,  60,  32,  67,  65,  83,  84,
+    40,  39,  49,  57,  57,  51,  45,  49,  48,  45,  48,  49,  39,  32,  65,
+    83,  32,  100, 97,  116, 101, 41,  10,  32,  32,  32,  32,  65,  78,  68,
+    32,  69,  88,  73,  83,  84,  83,  32,  40,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  42,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  108, 105, 110, 101, 105, 116, 101, 109, 10,  32,  32,
+    32,  32,  32,  32,  32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  108, 95,  111, 114, 100, 101,
+    114, 107, 101, 121, 32,  61,  32,  111, 95,  111, 114, 100, 101, 114, 107,
+    101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    65,  78,  68,  32,  108, 95,  99,  111, 109, 109, 105, 116, 100, 97,  116,
+    101, 32,  60,  32,  108, 95,  114, 101, 99,  101, 105, 112, 116, 100, 97,
+    116, 101, 41,  10,  71,  82,  79,  85,  80,  32,  66,  89,  10,  32,  32,
+    32,  32,  111, 95,  111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105,
+    116, 121, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,  32,  32,
+    32,  111, 95,  111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116,
+    121, 59,  10,  0};
+const uint8_t TPCH_QUERIES_q05[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  110, 95,  110, 97,
+    109, 101, 44,  10,  32,  32,  32,  32,  115, 117, 109, 40,  108, 95,  101,
+    120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,  101, 32,  42,  32,
+    40,  49,  32,  45,  32,  108, 95,  100, 105, 115, 99,  111, 117, 110, 116,
+    41,  41,  32,  65,  83,  32,  114, 101, 118, 101, 110, 117, 101, 10,  70,
+    82,  79,  77,  10,  32,  32,  32,  32,  99,  117, 115, 116, 111, 109, 101,
+    114, 44,  10,  32,  32,  32,  32,  111, 114, 100, 101, 114, 115, 44,  10,
+    32,  32,  32,  32,  108, 105, 110, 101, 105, 116, 101, 109, 44,  10,  32,
+    32,  32,  32,  115, 117, 112, 112, 108, 105, 101, 114, 44,  10,  32,  32,
+    32,  32,  110, 97,  116, 105, 111, 110, 44,  10,  32,  32,  32,  32,  114,
+    101, 103, 105, 111, 110, 10,  87,  72,  69,  82,  69,  10,  32,  32,  32,
+    32,  99,  95,  99,  117, 115, 116, 107, 101, 121, 32,  61,  32,  111, 95,
+    99,  117, 115, 116, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,
+    32,  108, 95,  111, 114, 100, 101, 114, 107, 101, 121, 32,  61,  32,  111,
+    95,  111, 114, 100, 101, 114, 107, 101, 121, 10,  32,  32,  32,  32,  65,
+    78,  68,  32,  108, 95,  115, 117, 112, 112, 107, 101, 121, 32,  61,  32,
+    115, 95,  115, 117, 112, 112, 107, 101, 121, 10,  32,  32,  32,  32,  65,
+    78,  68,  32,  99,  95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 32,
+    61,  32,  115, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 10,  32,
+    32,  32,  32,  65,  78,  68,  32,  115, 95,  110, 97,  116, 105, 111, 110,
+    107, 101, 121, 32,  61,  32,  110, 95,  110, 97,  116, 105, 111, 110, 107,
+    101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  110, 95,  114, 101,
+    103, 105, 111, 110, 107, 101, 121, 32,  61,  32,  114, 95,  114, 101, 103,
+    105, 111, 110, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,
+    114, 95,  110, 97,  109, 101, 32,  61,  32,  39,  65,  83,  73,  65,  39,
+    10,  32,  32,  32,  32,  65,  78,  68,  32,  111, 95,  111, 114, 100, 101,
+    114, 100, 97,  116, 101, 32,  62,  61,  32,  67,  65,  83,  84,  40,  39,
+    49,  57,  57,  52,  45,  48,  49,  45,  48,  49,  39,  32,  65,  83,  32,
+    100, 97,  116, 101, 41,  10,  32,  32,  32,  32,  65,  78,  68,  32,  111,
+    95,  111, 114, 100, 101, 114, 100, 97,  116, 101, 32,  60,  32,  67,  65,
+    83,  84,  40,  39,  49,  57,  57,  53,  45,  48,  49,  45,  48,  49,  39,
+    32,  65,  83,  32,  100, 97,  116, 101, 41,  10,  71,  82,  79,  85,  80,
+    32,  66,  89,  10,  32,  32,  32,  32,  110, 95,  110, 97,  109, 101, 10,
+    79,  82,  68,  69,  82,  32,  66,  89,  10,  32,  32,  32,  32,  114, 101,
+    118, 101, 110, 117, 101, 32,  68,  69,  83,  67,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q06[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  115, 117, 109, 40,
+    108, 95,  101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,  101,
+    32,  42,  32,  108, 95,  100, 105, 115, 99,  111, 117, 110, 116, 41,  32,
+    65,  83,  32,  114, 101, 118, 101, 110, 117, 101, 10,  70,  82,  79,  77,
+    10,  32,  32,  32,  32,  108, 105, 110, 101, 105, 116, 101, 109, 10,  87,
+    72,  69,  82,  69,  10,  32,  32,  32,  32,  108, 95,  115, 104, 105, 112,
+    100, 97,  116, 101, 32,  62,  61,  32,  67,  65,  83,  84,  40,  39,  49,
+    57,  57,  52,  45,  48,  49,  45,  48,  49,  39,  32,  65,  83,  32,  100,
+    97,  116, 101, 41,  10,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,
+    115, 104, 105, 112, 100, 97,  116, 101, 32,  60,  32,  67,  65,  83,  84,
+    40,  39,  49,  57,  57,  53,  45,  48,  49,  45,  48,  49,  39,  32,  65,
+    83,  32,  100, 97,  116, 101, 41,  10,  32,  32,  32,  32,  65,  78,  68,
+    32,  108, 95,  100, 105, 115, 99,  111, 117, 110, 116, 32,  66,  69,  84,
+    87,  69,  69,  78,  32,  48,  46,  48,  53,  10,  32,  32,  32,  32,  65,
+    78,  68,  32,  48,  46,  48,  55,  10,  32,  32,  32,  32,  65,  78,  68,
+    32,  108, 95,  113, 117, 97,  110, 116, 105, 116, 121, 32,  60,  32,  50,
+    52,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q07[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  115, 117, 112, 112,
+    95,  110, 97,  116, 105, 111, 110, 44,  10,  32,  32,  32,  32,  99,  117,
+    115, 116, 95,  110, 97,  116, 105, 111, 110, 44,  10,  32,  32,  32,  32,
+    108, 95,  121, 101, 97,  114, 44,  10,  32,  32,  32,  32,  115, 117, 109,
+    40,  118, 111, 108, 117, 109, 101, 41,  32,  65,  83,  32,  114, 101, 118,
+    101, 110, 117, 101, 10,  70,  82,  79,  77,  32,  40,  10,  32,  32,  32,
+    32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  110, 49,  46,  110, 95,  110, 97,  109, 101, 32,  65,  83,  32,  115,
+    117, 112, 112, 95,  110, 97,  116, 105, 111, 110, 44,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  110, 50,  46,  110, 95,  110, 97,  109, 101, 32,
+    65,  83,  32,  99,  117, 115, 116, 95,  110, 97,  116, 105, 111, 110, 44,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  101, 120, 116, 114, 97,  99,
+    116, 40,  121, 101, 97,  114, 32,  70,  82,  79,  77,  32,  108, 95,  115,
+    104, 105, 112, 100, 97,  116, 101, 41,  32,  65,  83,  32,  108, 95,  121,
+    101, 97,  114, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  108, 95,
+    101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,  101, 32,  42,
+    32,  40,  49,  32,  45,  32,  108, 95,  100, 105, 115, 99,  111, 117, 110,
+    116, 41,  32,  65,  83,  32,  118, 111, 108, 117, 109, 101, 10,  32,  32,
+    32,  32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    115, 117, 112, 112, 108, 105, 101, 114, 44,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  108, 105, 110, 101, 105, 116, 101, 109, 44,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  111, 114, 100, 101, 114, 115, 44,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  99,  117, 115, 116, 111, 109, 101, 114,
+    44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  110, 97,  116, 105, 111,
+    110, 32,  110, 49,  44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  110,
+    97,  116, 105, 111, 110, 32,  110, 50,  10,  32,  32,  32,  32,  87,  72,
+    69,  82,  69,  10,  32,  32,  32,  32,  32,  32,  32,  32,  115, 95,  115,
+    117, 112, 112, 107, 101, 121, 32,  61,  32,  108, 95,  115, 117, 112, 112,
+    107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,
+    32,  111, 95,  111, 114, 100, 101, 114, 107, 101, 121, 32,  61,  32,  108,
+    95,  111, 114, 100, 101, 114, 107, 101, 121, 10,  32,  32,  32,  32,  32,
+    32,  32,  32,  65,  78,  68,  32,  99,  95,  99,  117, 115, 116, 107, 101,
+    121, 32,  61,  32,  111, 95,  99,  117, 115, 116, 107, 101, 121, 10,  32,
+    32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  115, 95,  110, 97,
+    116, 105, 111, 110, 107, 101, 121, 32,  61,  32,  110, 49,  46,  110, 95,
+    110, 97,  116, 105, 111, 110, 107, 101, 121, 10,  32,  32,  32,  32,  32,
+    32,  32,  32,  65,  78,  68,  32,  99,  95,  110, 97,  116, 105, 111, 110,
+    107, 101, 121, 32,  61,  32,  110, 50,  46,  110, 95,  110, 97,  116, 105,
+    111, 110, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  65,
+    78,  68,  32,  40,  40,  110, 49,  46,  110, 95,  110, 97,  109, 101, 32,
+    61,  32,  39,  70,  82,  65,  78,  67,  69,  39,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,
+    32,  110, 50,  46,  110, 95,  110, 97,  109, 101, 32,  61,  32,  39,  71,
+    69,  82,  77,  65,  78,  89,  39,  41,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  79,  82,  32,  40,  110, 49,  46,  110, 95,
+    110, 97,  109, 101, 32,  61,  32,  39,  71,  69,  82,  77,  65,  78,  89,
+    39,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  65,  78,  68,  32,  110, 50,  46,  110, 95,  110, 97,  109,
+    101, 32,  61,  32,  39,  70,  82,  65,  78,  67,  69,  39,  41,  41,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  115,
+    104, 105, 112, 100, 97,  116, 101, 32,  66,  69,  84,  87,  69,  69,  78,
+    32,  67,  65,  83,  84,  40,  39,  49,  57,  57,  53,  45,  48,  49,  45,
+    48,  49,  39,  32,  65,  83,  32,  100, 97,  116, 101, 41,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  67,  65,  83,  84,  40,
+    39,  49,  57,  57,  54,  45,  49,  50,  45,  51,  49,  39,  32,  65,  83,
+    32,  100, 97,  116, 101, 41,  41,  32,  65,  83,  32,  115, 104, 105, 112,
+    112, 105, 110, 103, 10,  71,  82,  79,  85,  80,  32,  66,  89,  10,  32,
+    32,  32,  32,  115, 117, 112, 112, 95,  110, 97,  116, 105, 111, 110, 44,
+    10,  32,  32,  32,  32,  99,  117, 115, 116, 95,  110, 97,  116, 105, 111,
+    110, 44,  10,  32,  32,  32,  32,  108, 95,  121, 101, 97,  114, 10,  79,
+    82,  68,  69,  82,  32,  66,  89,  10,  32,  32,  32,  32,  115, 117, 112,
+    112, 95,  110, 97,  116, 105, 111, 110, 44,  10,  32,  32,  32,  32,  99,
+    117, 115, 116, 95,  110, 97,  116, 105, 111, 110, 44,  10,  32,  32,  32,
+    32,  108, 95,  121, 101, 97,  114, 59,  10,  0};
+const uint8_t TPCH_QUERIES_q08[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  111, 95,  121, 101,
+    97,  114, 44,  10,  32,  32,  32,  32,  115, 117, 109, 40,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  67,  65,  83,  69,  32,  87,  72,  69,  78,
+    32,  110, 97,  116, 105, 111, 110, 32,  61,  32,  39,  66,  82,  65,  90,
+    73,  76,  39,  32,  84,  72,  69,  78,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  118, 111, 108, 117, 109, 101, 10,  32,  32,
+    32,  32,  32,  32,  32,  32,  69,  76,  83,  69,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  48,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  69,  78,  68,  41,  32,  47,  32,  115, 117, 109, 40,  118,
+    111, 108, 117, 109, 101, 41,  32,  65,  83,  32,  109, 107, 116, 95,  115,
+    104, 97,  114, 101, 10,  70,  82,  79,  77,  32,  40,  10,  32,  32,  32,
+    32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  101, 120, 116, 114, 97,  99,  116, 40,  121, 101, 97,  114, 32,  70,
+    82,  79,  77,  32,  111, 95,  111, 114, 100, 101, 114, 100, 97,  116, 101,
+    41,  32,  65,  83,  32,  111, 95,  121, 101, 97,  114, 44,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  108, 95,  101, 120, 116, 101, 110, 100, 101,
+    100, 112, 114, 105, 99,  101, 32,  42,  32,  40,  49,  32,  45,  32,  108,
+    95,  100, 105, 115, 99,  111, 117, 110, 116, 41,  32,  65,  83,  32,  118,
+    111, 108, 117, 109, 101, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    110, 50,  46,  110, 95,  110, 97,  109, 101, 32,  65,  83,  32,  110, 97,
+    116, 105, 111, 110, 10,  32,  32,  32,  32,  70,  82,  79,  77,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  112, 97,  114, 116, 44,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  115, 117, 112, 112, 108, 105, 101, 114, 44,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  108, 105, 110, 101, 105, 116,
+    101, 109, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  111, 114, 100,
+    101, 114, 115, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  99,  117,
+    115, 116, 111, 109, 101, 114, 44,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  110, 97,  116, 105, 111, 110, 32,  110, 49,  44,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  110, 97,  116, 105, 111, 110, 32,  110, 50,  44,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  114, 101, 103, 105, 111, 110,
+    10,  32,  32,  32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  112, 95,  112, 97,  114, 116, 107, 101, 121, 32,  61,
+    32,  108, 95,  112, 97,  114, 116, 107, 101, 121, 10,  32,  32,  32,  32,
+    32,  32,  32,  32,  65,  78,  68,  32,  115, 95,  115, 117, 112, 112, 107,
+    101, 121, 32,  61,  32,  108, 95,  115, 117, 112, 112, 107, 101, 121, 10,
+    32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  111,
+    114, 100, 101, 114, 107, 101, 121, 32,  61,  32,  111, 95,  111, 114, 100,
+    101, 114, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  65,
+    78,  68,  32,  111, 95,  99,  117, 115, 116, 107, 101, 121, 32,  61,  32,
+    99,  95,  99,  117, 115, 116, 107, 101, 121, 10,  32,  32,  32,  32,  32,
+    32,  32,  32,  65,  78,  68,  32,  99,  95,  110, 97,  116, 105, 111, 110,
+    107, 101, 121, 32,  61,  32,  110, 49,  46,  110, 95,  110, 97,  116, 105,
+    111, 110, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  65,
+    78,  68,  32,  110, 49,  46,  110, 95,  114, 101, 103, 105, 111, 110, 107,
+    101, 121, 32,  61,  32,  114, 95,  114, 101, 103, 105, 111, 110, 107, 101,
+    121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  114,
+    95,  110, 97,  109, 101, 32,  61,  32,  39,  65,  77,  69,  82,  73,  67,
+    65,  39,  10,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,
+    115, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 32,  61,  32,  110,
+    50,  46,  110, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 10,  32,
+    32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  111, 95,  111, 114,
+    100, 101, 114, 100, 97,  116, 101, 32,  66,  69,  84,  87,  69,  69,  78,
+    32,  67,  65,  83,  84,  40,  39,  49,  57,  57,  53,  45,  48,  49,  45,
+    48,  49,  39,  32,  65,  83,  32,  100, 97,  116, 101, 41,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  67,  65,  83,  84,  40,
+    39,  49,  57,  57,  54,  45,  49,  50,  45,  51,  49,  39,  32,  65,  83,
+    32,  100, 97,  116, 101, 41,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    65,  78,  68,  32,  112, 95,  116, 121, 112, 101, 32,  61,  32,  39,  69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  39,  41,  32,  65,  83,  32,  97,  108, 108,
+    95,  110, 97,  116, 105, 111, 110, 115, 10,  71,  82,  79,  85,  80,  32,
+    66,  89,  10,  32,  32,  32,  32,  111, 95,  121, 101, 97,  114, 10,  79,
+    82,  68,  69,  82,  32,  66,  89,  10,  32,  32,  32,  32,  111, 95,  121,
+    101, 97,  114, 59,  10,  0};
+const uint8_t TPCH_QUERIES_q09[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  110, 97,  116, 105,
+    111, 110, 44,  10,  32,  32,  32,  32,  111, 95,  121, 101, 97,  114, 44,
+    10,  32,  32,  32,  32,  115, 117, 109, 40,  97,  109, 111, 117, 110, 116,
+    41,  32,  65,  83,  32,  115, 117, 109, 95,  112, 114, 111, 102, 105, 116,
+    10,  70,  82,  79,  77,  32,  40,  10,  32,  32,  32,  32,  83,  69,  76,
+    69,  67,  84,  10,  32,  32,  32,  32,  32,  32,  32,  32,  110, 95,  110,
+    97,  109, 101, 32,  65,  83,  32,  110, 97,  116, 105, 111, 110, 44,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  101, 120, 116, 114, 97,  99,  116,
+    40,  121, 101, 97,  114, 32,  70,  82,  79,  77,  32,  111, 95,  111, 114,
+    100, 101, 114, 100, 97,  116, 101, 41,  32,  65,  83,  32,  111, 95,  121,
+    101, 97,  114, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  108, 95,
+    101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,  101, 32,  42,
+    32,  40,  49,  32,  45,  32,  108, 95,  100, 105, 115, 99,  111, 117, 110,
+    116, 41,  32,  45,  32,  112, 115, 95,  115, 117, 112, 112, 108, 121, 99,
+    111, 115, 116, 32,  42,  32,  108, 95,  113, 117, 97,  110, 116, 105, 116,
+    121, 32,  65,  83,  32,  97,  109, 111, 117, 110, 116, 10,  32,  32,  32,
+    32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,  112,
+    97,  114, 116, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  115, 117,
+    112, 112, 108, 105, 101, 114, 44,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  108, 105, 110, 101, 105, 116, 101, 109, 44,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  112, 97,  114, 116, 115, 117, 112, 112, 44,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  111, 114, 100, 101, 114, 115, 44,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  110, 97,  116, 105, 111, 110, 10,
+    32,  32,  32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  115, 95,  115, 117, 112, 112, 107, 101, 121, 32,  61,  32,
+    108, 95,  115, 117, 112, 112, 107, 101, 121, 10,  32,  32,  32,  32,  32,
+    32,  32,  32,  65,  78,  68,  32,  112, 115, 95,  115, 117, 112, 112, 107,
+    101, 121, 32,  61,  32,  108, 95,  115, 117, 112, 112, 107, 101, 121, 10,
+    32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  112, 115, 95,
+    112, 97,  114, 116, 107, 101, 121, 32,  61,  32,  108, 95,  112, 97,  114,
+    116, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,
+    68,  32,  112, 95,  112, 97,  114, 116, 107, 101, 121, 32,  61,  32,  108,
+    95,  112, 97,  114, 116, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,
+    32,  32,  65,  78,  68,  32,  111, 95,  111, 114, 100, 101, 114, 107, 101,
+    121, 32,  61,  32,  108, 95,  111, 114, 100, 101, 114, 107, 101, 121, 10,
+    32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  115, 95,  110,
+    97,  116, 105, 111, 110, 107, 101, 121, 32,  61,  32,  110, 95,  110, 97,
+    116, 105, 111, 110, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,
+    32,  65,  78,  68,  32,  112, 95,  110, 97,  109, 101, 32,  76,  73,  75,
+    69,  32,  39,  37,  103, 114, 101, 101, 110, 37,  39,  41,  32,  65,  83,
+    32,  112, 114, 111, 102, 105, 116, 10,  71,  82,  79,  85,  80,  32,  66,
+    89,  10,  32,  32,  32,  32,  110, 97,  116, 105, 111, 110, 44,  10,  32,
+    32,  32,  32,  111, 95,  121, 101, 97,  114, 10,  79,  82,  68,  69,  82,
+    32,  66,  89,  10,  32,  32,  32,  32,  110, 97,  116, 105, 111, 110, 44,
+    10,  32,  32,  32,  32,  111, 95,  121, 101, 97,  114, 32,  68,  69,  83,
+    67,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q10[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  99,  95,  99,  117,
+    115, 116, 107, 101, 121, 44,  10,  32,  32,  32,  32,  99,  95,  110, 97,
+    109, 101, 44,  10,  32,  32,  32,  32,  115, 117, 109, 40,  108, 95,  101,
+    120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,  101, 32,  42,  32,
+    40,  49,  32,  45,  32,  108, 95,  100, 105, 115, 99,  111, 117, 110, 116,
+    41,  41,  32,  65,  83,  32,  114, 101, 118, 101, 110, 117, 101, 44,  10,
+    32,  32,  32,  32,  99,  95,  97,  99,  99,  116, 98,  97,  108, 44,  10,
+    32,  32,  32,  32,  110, 95,  110, 97,  109, 101, 44,  10,  32,  32,  32,
+    32,  99,  95,  97,  100, 100, 114, 101, 115, 115, 44,  10,  32,  32,  32,
+    32,  99,  95,  112, 104, 111, 110, 101, 44,  10,  32,  32,  32,  32,  99,
+    95,  99,  111, 109, 109, 101, 110, 116, 10,  70,  82,  79,  77,  10,  32,
+    32,  32,  32,  99,  117, 115, 116, 111, 109, 101, 114, 44,  10,  32,  32,
+    32,  32,  111, 114, 100, 101, 114, 115, 44,  10,  32,  32,  32,  32,  108,
+    105, 110, 101, 105, 116, 101, 109, 44,  10,  32,  32,  32,  32,  110, 97,
+    116, 105, 111, 110, 10,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,
+    99,  95,  99,  117, 115, 116, 107, 101, 121, 32,  61,  32,  111, 95,  99,
+    117, 115, 116, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,
+    108, 95,  111, 114, 100, 101, 114, 107, 101, 121, 32,  61,  32,  111, 95,
+    111, 114, 100, 101, 114, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,
+    68,  32,  111, 95,  111, 114, 100, 101, 114, 100, 97,  116, 101, 32,  62,
+    61,  32,  67,  65,  83,  84,  40,  39,  49,  57,  57,  51,  45,  49,  48,
+    45,  48,  49,  39,  32,  65,  83,  32,  100, 97,  116, 101, 41,  10,  32,
+    32,  32,  32,  65,  78,  68,  32,  111, 95,  111, 114, 100, 101, 114, 100,
+    97,  116, 101, 32,  60,  32,  67,  65,  83,  84,  40,  39,  49,  57,  57,
+    52,  45,  48,  49,  45,  48,  49,  39,  32,  65,  83,  32,  100, 97,  116,
+    101, 41,  10,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  114, 101,
+    116, 117, 114, 110, 102, 108, 97,  103, 32,  61,  32,  39,  82,  39,  10,
+    32,  32,  32,  32,  65,  78,  68,  32,  99,  95,  110, 97,  116, 105, 111,
+    110, 107, 101, 121, 32,  61,  32,  110, 95,  110, 97,  116, 105, 111, 110,
+    107, 101, 121, 10,  71,  82,  79,  85,  80,  32,  66,  89,  10,  32,  32,
+    32,  32,  99,  95,  99,  117, 115, 116, 107, 101, 121, 44,  10,  32,  32,
+    32,  32,  99,  95,  110, 97,  109, 101, 44,  10,  32,  32,  32,  32,  99,
+    95,  97,  99,  99,  116, 98,  97,  108, 44,  10,  32,  32,  32,  32,  99,
+    95,  112, 104, 111, 110, 101, 44,  10,  32,  32,  32,  32,  110, 95,  110,
+    97,  109, 101, 44,  10,  32,  32,  32,  32,  99,  95,  97,  100, 100, 114,
+    101, 115, 115, 44,  10,  32,  32,  32,  32,  99,  95,  99,  111, 109, 109,
+    101, 110, 116, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,  32,
+    32,  32,  114, 101, 118, 101, 110, 117, 101, 32,  68,  69,  83,  67,  10,
+    76,  73,  77,  73,  84,  32,  50,  48,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q11[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  112, 115, 95,  112,
+    97,  114, 116, 107, 101, 121, 44,  10,  32,  32,  32,  32,  115, 117, 109,
+    40,  112, 115, 95,  115, 117, 112, 112, 108, 121, 99,  111, 115, 116, 32,
+    42,  32,  112, 115, 95,  97,  118, 97,  105, 108, 113, 116, 121, 41,  32,
+    65,  83,  32,  118, 97,  108, 117, 101, 10,  70,  82,  79,  77,  10,  32,
+    32,  32,  32,  112, 97,  114, 116, 115, 117, 112, 112, 44,  10,  32,  32,
+    32,  32,  115, 117, 112, 112, 108, 105, 101, 114, 44,  10,  32,  32,  32,
+    32,  110, 97,  116, 105, 111, 110, 10,  87,  72,  69,  82,  69,  10,  32,
+    32,  32,  32,  112, 115, 95,  115, 117, 112, 112, 107, 101, 121, 32,  61,
+    32,  115, 95,  115, 117, 112, 112, 107, 101, 121, 10,  32,  32,  32,  32,
+    65,  78,  68,  32,  115, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121,
+    32,  61,  32,  110, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 10,
+    32,  32,  32,  32,  65,  78,  68,  32,  110, 95,  110, 97,  109, 101, 32,
+    61,  32,  39,  71,  69,  82,  77,  65,  78,  89,  39,  10,  71,  82,  79,
+    85,  80,  32,  66,  89,  10,  32,  32,  32,  32,  112, 115, 95,  112, 97,
+    114, 116, 107, 101, 121, 10,  72,  65,  86,  73,  78,  71,  10,  32,  32,
+    32,  32,  115, 117, 109, 40,  112, 115, 95,  115, 117, 112, 112, 108, 121,
+    99,  111, 115, 116, 32,  42,  32,  112, 115, 95,  97,  118, 97,  105, 108,
+    113, 116, 121, 41,  32,  62,  32,  40,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  115, 117, 109, 40,  112, 115, 95,  115, 117,
+    112, 112, 108, 121, 99,  111, 115, 116, 32,  42,  32,  112, 115, 95,  97,
+    118, 97,  105, 108, 113, 116, 121, 41,  32,  42,  32,  48,  46,  48,  48,
+    48,  49,  48,  48,  48,  48,  48,  48,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  112, 97,  114, 116, 115, 117, 112, 112, 44,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  115, 117, 112, 112,
+    108, 105, 101, 114, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  110, 97,  116, 105, 111, 110, 10,  32,  32,  32,  32,  32,
+    32,  32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  112, 115, 95,  115, 117, 112, 112, 107, 101,
+    121, 32,  61,  32,  115, 95,  115, 117, 112, 112, 107, 101, 121, 10,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,
+    115, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 32,  61,  32,  110,
+    95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 10,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  110, 95,  110,
+    97,  109, 101, 32,  61,  32,  39,  71,  69,  82,  77,  65,  78,  89,  39,
+    41,  10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,  32,  32,  32,
+    118, 97,  108, 117, 101, 32,  68,  69,  83,  67,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q12[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  108, 95,  115, 104,
+    105, 112, 109, 111, 100, 101, 44,  10,  32,  32,  32,  32,  115, 117, 109,
+    40,  10,  32,  32,  32,  32,  32,  32,  32,  32,  67,  65,  83,  69,  32,
+    87,  72,  69,  78,  32,  111, 95,  111, 114, 100, 101, 114, 112, 114, 105,
+    111, 114, 105, 116, 121, 32,  61,  32,  39,  49,  45,  85,  82,  71,  69,
+    78,  84,  39,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  79,  82,  32,  111, 95,  111, 114, 100, 101, 114, 112, 114, 105, 111,
+    114, 105, 116, 121, 32,  61,  32,  39,  50,  45,  72,  73,  71,  72,  39,
+    32,  84,  72,  69,  78,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  49,  10,  32,  32,  32,  32,  32,  32,  32,  32,  69,  76,
+    83,  69,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    48,  10,  32,  32,  32,  32,  32,  32,  32,  32,  69,  78,  68,  41,  32,
+    65,  83,  32,  104, 105, 103, 104, 95,  108, 105, 110, 101, 95,  99,  111,
+    117, 110, 116, 44,  10,  32,  32,  32,  32,  115, 117, 109, 40,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  67,  65,  83,  69,  32,  87,  72,  69,
+    78,  32,  111, 95,  111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105,
+    116, 121, 32,  60,  62,  32,  39,  49,  45,  85,  82,  71,  69,  78,  84,
+    39,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,
+    78,  68,  32,  111, 95,  111, 114, 100, 101, 114, 112, 114, 105, 111, 114,
+    105, 116, 121, 32,  60,  62,  32,  39,  50,  45,  72,  73,  71,  72,  39,
+    32,  84,  72,  69,  78,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  49,  10,  32,  32,  32,  32,  32,  32,  32,  32,  69,  76,
+    83,  69,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    48,  10,  32,  32,  32,  32,  32,  32,  32,  32,  69,  78,  68,  41,  32,
+    65,  83,  32,  108, 111, 119, 95,  108, 105, 110, 101, 95,  99,  111, 117,
+    110, 116, 10,  70,  82,  79,  77,  10,  32,  32,  32,  32,  111, 114, 100,
+    101, 114, 115, 44,  10,  32,  32,  32,  32,  108, 105, 110, 101, 105, 116,
+    101, 109, 10,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  111, 95,
+    111, 114, 100, 101, 114, 107, 101, 121, 32,  61,  32,  108, 95,  111, 114,
+    100, 101, 114, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,
+    108, 95,  115, 104, 105, 112, 109, 111, 100, 101, 32,  73,  78,  32,  40,
+    39,  77,  65,  73,  76,  39,  44,  32,  39,  83,  72,  73,  80,  39,  41,
+    10,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  99,  111, 109, 109,
+    105, 116, 100, 97,  116, 101, 32,  60,  32,  108, 95,  114, 101, 99,  101,
+    105, 112, 116, 100, 97,  116, 101, 10,  32,  32,  32,  32,  65,  78,  68,
+    32,  108, 95,  115, 104, 105, 112, 100, 97,  116, 101, 32,  60,  32,  108,
+    95,  99,  111, 109, 109, 105, 116, 100, 97,  116, 101, 10,  32,  32,  32,
+    32,  65,  78,  68,  32,  108, 95,  114, 101, 99,  101, 105, 112, 116, 100,
+    97,  116, 101, 32,  62,  61,  32,  67,  65,  83,  84,  40,  39,  49,  57,
+    57,  52,  45,  48,  49,  45,  48,  49,  39,  32,  65,  83,  32,  100, 97,
+    116, 101, 41,  10,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  114,
+    101, 99,  101, 105, 112, 116, 100, 97,  116, 101, 32,  60,  32,  67,  65,
+    83,  84,  40,  39,  49,  57,  57,  53,  45,  48,  49,  45,  48,  49,  39,
+    32,  65,  83,  32,  100, 97,  116, 101, 41,  10,  71,  82,  79,  85,  80,
+    32,  66,  89,  10,  32,  32,  32,  32,  108, 95,  115, 104, 105, 112, 109,
+    111, 100, 101, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,  32,
+    32,  32,  108, 95,  115, 104, 105, 112, 109, 111, 100, 101, 59,  10,  0};
+const uint8_t TPCH_QUERIES_q13[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  99,  95,  99,  111,
+    117, 110, 116, 44,  10,  32,  32,  32,  32,  99,  111, 117, 110, 116, 40,
+    42,  41,  32,  65,  83,  32,  99,  117, 115, 116, 100, 105, 115, 116, 10,
+    70,  82,  79,  77,  32,  40,  10,  32,  32,  32,  32,  83,  69,  76,  69,
+    67,  84,  10,  32,  32,  32,  32,  32,  32,  32,  32,  99,  95,  99,  117,
+    115, 116, 107, 101, 121, 44,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    99,  111, 117, 110, 116, 40,  111, 95,  111, 114, 100, 101, 114, 107, 101,
+    121, 41,  10,  32,  32,  32,  32,  70,  82,  79,  77,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  99,  117, 115, 116, 111, 109, 101, 114, 10,  32,
+    32,  32,  32,  76,  69,  70,  84,  32,  79,  85,  84,  69,  82,  32,  74,
+    79,  73,  78,  32,  111, 114, 100, 101, 114, 115, 32,  79,  78,  32,  99,
+    95,  99,  117, 115, 116, 107, 101, 121, 32,  61,  32,  111, 95,  99,  117,
+    115, 116, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  111,
+    95,  99,  111, 109, 109, 101, 110, 116, 32,  78,  79,  84,  32,  76,  73,
+    75,  69,  32,  39,  37,  115, 112, 101, 99,  105, 97,  108, 37,  114, 101,
+    113, 117, 101, 115, 116, 115, 37,  39,  10,  71,  82,  79,  85,  80,  32,
+    66,  89,  10,  32,  32,  32,  32,  99,  95,  99,  117, 115, 116, 107, 101,
+    121, 41,  32,  65,  83,  32,  99,  95,  111, 114, 100, 101, 114, 115, 32,
+    40,  99,  95,  99,  117, 115, 116, 107, 101, 121, 44,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  99,  95,  99,  111, 117, 110, 116, 41,  10,  71,
+    82,  79,  85,  80,  32,  66,  89,  10,  32,  32,  32,  32,  99,  95,  99,
+    111, 117, 110, 116, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,
+    32,  32,  32,  99,  117, 115, 116, 100, 105, 115, 116, 32,  68,  69,  83,
+    67,  44,  10,  32,  32,  32,  32,  99,  95,  99,  111, 117, 110, 116, 32,
+    68,  69,  83,  67,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q14[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  49,  48,  48,  46,
+    48,  48,  32,  42,  32,  115, 117, 109, 40,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  67,  65,  83,  69,  32,  87,  72,  69,  78,  32,  112, 95,
+    116, 121, 112, 101, 32,  76,  73,  75,  69,  32,  39,  80,  82,  79,  77,
+    79,  37,  39,  32,  84,  72,  69,  78,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  108, 95,  101, 120, 116, 101, 110, 100, 101,
+    100, 112, 114, 105, 99,  101, 32,  42,  32,  40,  49,  32,  45,  32,  108,
+    95,  100, 105, 115, 99,  111, 117, 110, 116, 41,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  69,  76,  83,  69,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  48,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  69,  78,  68,  41,  32,  47,  32,  115, 117, 109, 40,  108, 95,  101,
+    120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,  101, 32,  42,  32,
+    40,  49,  32,  45,  32,  108, 95,  100, 105, 115, 99,  111, 117, 110, 116,
+    41,  41,  32,  65,  83,  32,  112, 114, 111, 109, 111, 95,  114, 101, 118,
+    101, 110, 117, 101, 10,  70,  82,  79,  77,  10,  32,  32,  32,  32,  108,
+    105, 110, 101, 105, 116, 101, 109, 44,  10,  32,  32,  32,  32,  112, 97,
+    114, 116, 10,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  108, 95,
+    112, 97,  114, 116, 107, 101, 121, 32,  61,  32,  112, 95,  112, 97,  114,
+    116, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,
+    115, 104, 105, 112, 100, 97,  116, 101, 32,  62,  61,  32,  100, 97,  116,
+    101, 32,  39,  49,  57,  57,  53,  45,  48,  57,  45,  48,  49,  39,  10,
+    32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  115, 104, 105, 112, 100,
+    97,  116, 101, 32,  60,  32,  67,  65,  83,  84,  40,  39,  49,  57,  57,
+    53,  45,  49,  48,  45,  48,  49,  39,  32,  65,  83,  32,  100, 97,  116,
+    101, 41,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q15[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  115, 95,  115, 117,
+    112, 112, 107, 101, 121, 44,  10,  32,  32,  32,  32,  115, 95,  110, 97,
+    109, 101, 44,  10,  32,  32,  32,  32,  115, 95,  97,  100, 100, 114, 101,
+    115, 115, 44,  10,  32,  32,  32,  32,  115, 95,  112, 104, 111, 110, 101,
+    44,  10,  32,  32,  32,  32,  116, 111, 116, 97,  108, 95,  114, 101, 118,
+    101, 110, 117, 101, 10,  70,  82,  79,  77,  10,  32,  32,  32,  32,  115,
+    117, 112, 112, 108, 105, 101, 114, 44,  10,  32,  32,  32,  32,  40,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  83,  69,  76,  69,  67,  84,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  108, 95,  115,
+    117, 112, 112, 107, 101, 121, 32,  65,  83,  32,  115, 117, 112, 112, 108,
+    105, 101, 114, 95,  110, 111, 44,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  115, 117, 109, 40,  108, 95,  101, 120, 116, 101,
+    110, 100, 101, 100, 112, 114, 105, 99,  101, 32,  42,  32,  40,  49,  32,
+    45,  32,  108, 95,  100, 105, 115, 99,  111, 117, 110, 116, 41,  41,  32,
+    65,  83,  32,  116, 111, 116, 97,  108, 95,  114, 101, 118, 101, 110, 117,
+    101, 10,  32,  32,  32,  32,  32,  32,  32,  32,  70,  82,  79,  77,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  108, 105, 110,
+    101, 105, 116, 101, 109, 10,  32,  32,  32,  32,  32,  32,  32,  32,  87,
+    72,  69,  82,  69,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  108, 95,  115, 104, 105, 112, 100, 97,  116, 101, 32,  62,  61,
+    32,  67,  65,  83,  84,  40,  39,  49,  57,  57,  54,  45,  48,  49,  45,
+    48,  49,  39,  32,  65,  83,  32,  100, 97,  116, 101, 41,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  108,
+    95,  115, 104, 105, 112, 100, 97,  116, 101, 32,  60,  32,  67,  65,  83,
+    84,  40,  39,  49,  57,  57,  54,  45,  48,  52,  45,  48,  49,  39,  32,
+    65,  83,  32,  100, 97,  116, 101, 41,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  71,  82,  79,  85,  80,  32,  66,  89,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  115, 117, 112, 112, 108, 105, 101,
+    114, 95,  110, 111, 41,  32,  114, 101, 118, 101, 110, 117, 101, 48,  10,
+    87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  115, 95,  115, 117, 112,
+    112, 107, 101, 121, 32,  61,  32,  115, 117, 112, 112, 108, 105, 101, 114,
+    95,  110, 111, 10,  32,  32,  32,  32,  65,  78,  68,  32,  116, 111, 116,
+    97,  108, 95,  114, 101, 118, 101, 110, 117, 101, 32,  61,  32,  40,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  83,  69,  76,  69,  67,  84,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  109, 97,  120,
+    40,  116, 111, 116, 97,  108, 95,  114, 101, 118, 101, 110, 117, 101, 41,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  70,  82,  79,  77,  32,  40,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  83,  69,
+    76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  108, 95,  115, 117, 112, 112, 107, 101, 121,
+    32,  65,  83,  32,  115, 117, 112, 112, 108, 105, 101, 114, 95,  110, 111,
+    44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  115, 117, 109, 40,  108, 95,  101, 120, 116, 101, 110, 100,
+    101, 100, 112, 114, 105, 99,  101, 32,  42,  32,  40,  49,  32,  45,  32,
+    108, 95,  100, 105, 115, 99,  111, 117, 110, 116, 41,  41,  32,  65,  83,
+    32,  116, 111, 116, 97,  108, 95,  114, 101, 118, 101, 110, 117, 101, 10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  70,  82,  79,
+    77,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  108, 105, 110, 101, 105, 116, 101, 109, 10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  87,  72,  69,  82,  69,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  108, 95,  115, 104, 105, 112, 100, 97,  116, 101, 32,  62,  61,  32,
+    67,  65,  83,  84,  40,  39,  49,  57,  57,  54,  45,  48,  49,  45,  48,
+    49,  39,  32,  65,  83,  32,  100, 97,  116, 101, 41,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,
+    68,  32,  108, 95,  115, 104, 105, 112, 100, 97,  116, 101, 32,  60,  32,
+    67,  65,  83,  84,  40,  39,  49,  57,  57,  54,  45,  48,  52,  45,  48,
+    49,  39,  32,  65,  83,  32,  100, 97,  116, 101, 41,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  71,  82,  79,  85,  80,  32,
+    66,  89,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  115, 117, 112, 112, 108, 105, 101, 114, 95,  110, 111,
+    41,  32,  114, 101, 118, 101, 110, 117, 101, 49,  41,  10,  79,  82,  68,
+    69,  82,  32,  66,  89,  10,  32,  32,  32,  32,  115, 95,  115, 117, 112,
+    112, 107, 101, 121, 59,  10,  0};
+const uint8_t TPCH_QUERIES_q16[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  112, 95,  98,  114,
+    97,  110, 100, 44,  10,  32,  32,  32,  32,  112, 95,  116, 121, 112, 101,
+    44,  10,  32,  32,  32,  32,  112, 95,  115, 105, 122, 101, 44,  10,  32,
+    32,  32,  32,  99,  111, 117, 110, 116, 40,  68,  73,  83,  84,  73,  78,
+    67,  84,  32,  112, 115, 95,  115, 117, 112, 112, 107, 101, 121, 41,  32,
+    65,  83,  32,  115, 117, 112, 112, 108, 105, 101, 114, 95,  99,  110, 116,
+    10,  70,  82,  79,  77,  10,  32,  32,  32,  32,  112, 97,  114, 116, 115,
+    117, 112, 112, 44,  10,  32,  32,  32,  32,  112, 97,  114, 116, 10,  87,
+    72,  69,  82,  69,  10,  32,  32,  32,  32,  112, 95,  112, 97,  114, 116,
+    107, 101, 121, 32,  61,  32,  112, 115, 95,  112, 97,  114, 116, 107, 101,
+    121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  112, 95,  98,  114, 97,
+    110, 100, 32,  60,  62,  32,  39,  66,  114, 97,  110, 100, 35,  52,  53,
+    39,  10,  32,  32,  32,  32,  65,  78,  68,  32,  112, 95,  116, 121, 112,
+    101, 32,  78,  79,  84,  32,  76,  73,  75,  69,  32,  39,  77,  69,  68,
+    73,  85,  77,  32,  80,  79,  76,  73,  83,  72,  69,  68,  37,  39,  10,
+    32,  32,  32,  32,  65,  78,  68,  32,  112, 95,  115, 105, 122, 101, 32,
+    73,  78,  32,  40,  52,  57,  44,  32,  49,  52,  44,  32,  50,  51,  44,
+    32,  52,  53,  44,  32,  49,  57,  44,  32,  51,  44,  32,  51,  54,  44,
+    32,  57,  41,  10,  32,  32,  32,  32,  65,  78,  68,  32,  112, 115, 95,
+    115, 117, 112, 112, 107, 101, 121, 32,  78,  79,  84,  32,  73,  78,  32,
+    40,  10,  32,  32,  32,  32,  32,  32,  32,  32,  83,  69,  76,  69,  67,
+    84,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  115,
+    95,  115, 117, 112, 112, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,
+    32,  32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  115, 117, 112, 112, 108, 105, 101, 114, 10,  32,  32,
+    32,  32,  32,  32,  32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  115, 95,  99,  111, 109, 109,
+    101, 110, 116, 32,  76,  73,  75,  69,  32,  39,  37,  67,  117, 115, 116,
+    111, 109, 101, 114, 37,  67,  111, 109, 112, 108, 97,  105, 110, 116, 115,
+    37,  39,  41,  10,  71,  82,  79,  85,  80,  32,  66,  89,  10,  32,  32,
+    32,  32,  112, 95,  98,  114, 97,  110, 100, 44,  10,  32,  32,  32,  32,
+    112, 95,  116, 121, 112, 101, 44,  10,  32,  32,  32,  32,  112, 95,  115,
+    105, 122, 101, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,  32,
+    32,  32,  115, 117, 112, 112, 108, 105, 101, 114, 95,  99,  110, 116, 32,
+    68,  69,  83,  67,  44,  10,  32,  32,  32,  32,  112, 95,  98,  114, 97,
+    110, 100, 44,  10,  32,  32,  32,  32,  112, 95,  116, 121, 112, 101, 44,
+    10,  32,  32,  32,  32,  112, 95,  115, 105, 122, 101, 59,  10,  0};
+const uint8_t TPCH_QUERIES_q17[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  115, 117, 109, 40,
+    108, 95,  101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,  101,
+    41,  32,  47,  32,  55,  46,  48,  32,  65,  83,  32,  97,  118, 103, 95,
+    121, 101, 97,  114, 108, 121, 10,  70,  82,  79,  77,  10,  32,  32,  32,
+    32,  108, 105, 110, 101, 105, 116, 101, 109, 44,  10,  32,  32,  32,  32,
+    112, 97,  114, 116, 10,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,
+    112, 95,  112, 97,  114, 116, 107, 101, 121, 32,  61,  32,  108, 95,  112,
+    97,  114, 116, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,
+    112, 95,  98,  114, 97,  110, 100, 32,  61,  32,  39,  66,  114, 97,  110,
+    100, 35,  50,  51,  39,  10,  32,  32,  32,  32,  65,  78,  68,  32,  112,
+    95,  99,  111, 110, 116, 97,  105, 110, 101, 114, 32,  61,  32,  39,  77,
+    69,  68,  32,  66,  79,  88,  39,  10,  32,  32,  32,  32,  65,  78,  68,
+    32,  108, 95,  113, 117, 97,  110, 116, 105, 116, 121, 32,  60,  32,  40,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  83,  69,  76,  69,  67,  84,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  48,  46,
+    50,  32,  42,  32,  97,  118, 103, 40,  108, 95,  113, 117, 97,  110, 116,
+    105, 116, 121, 41,  10,  32,  32,  32,  32,  32,  32,  32,  32,  70,  82,
+    79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    108, 105, 110, 101, 105, 116, 101, 109, 10,  32,  32,  32,  32,  32,  32,
+    32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  108, 95,  112, 97,  114, 116, 107, 101, 121, 32,
+    61,  32,  112, 95,  112, 97,  114, 116, 107, 101, 121, 41,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q18[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  99,  95,  110, 97,
+    109, 101, 44,  10,  32,  32,  32,  32,  99,  95,  99,  117, 115, 116, 107,
+    101, 121, 44,  10,  32,  32,  32,  32,  111, 95,  111, 114, 100, 101, 114,
+    107, 101, 121, 44,  10,  32,  32,  32,  32,  111, 95,  111, 114, 100, 101,
+    114, 100, 97,  116, 101, 44,  10,  32,  32,  32,  32,  111, 95,  116, 111,
+    116, 97,  108, 112, 114, 105, 99,  101, 44,  10,  32,  32,  32,  32,  115,
+    117, 109, 40,  108, 95,  113, 117, 97,  110, 116, 105, 116, 121, 41,  10,
+    70,  82,  79,  77,  10,  32,  32,  32,  32,  99,  117, 115, 116, 111, 109,
+    101, 114, 44,  10,  32,  32,  32,  32,  111, 114, 100, 101, 114, 115, 44,
+    10,  32,  32,  32,  32,  108, 105, 110, 101, 105, 116, 101, 109, 10,  87,
+    72,  69,  82,  69,  10,  32,  32,  32,  32,  111, 95,  111, 114, 100, 101,
+    114, 107, 101, 121, 32,  73,  78,  32,  40,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  108, 95,  111, 114, 100, 101, 114, 107,
+    101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  70,  82,  79,  77,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  108, 105,
+    110, 101, 105, 116, 101, 109, 10,  32,  32,  32,  32,  32,  32,  32,  32,
+    71,  82,  79,  85,  80,  32,  66,  89,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  108, 95,  111, 114, 100, 101, 114, 107, 101,
+    121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  72,  65,  86,  73,  78,
+    71,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  115,
+    117, 109, 40,  108, 95,  113, 117, 97,  110, 116, 105, 116, 121, 41,  32,
+    62,  32,  51,  48,  48,  41,  10,  32,  32,  32,  32,  65,  78,  68,  32,
+    99,  95,  99,  117, 115, 116, 107, 101, 121, 32,  61,  32,  111, 95,  99,
+    117, 115, 116, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,
+    111, 95,  111, 114, 100, 101, 114, 107, 101, 121, 32,  61,  32,  108, 95,
+    111, 114, 100, 101, 114, 107, 101, 121, 10,  71,  82,  79,  85,  80,  32,
+    66,  89,  10,  32,  32,  32,  32,  99,  95,  110, 97,  109, 101, 44,  10,
+    32,  32,  32,  32,  99,  95,  99,  117, 115, 116, 107, 101, 121, 44,  10,
+    32,  32,  32,  32,  111, 95,  111, 114, 100, 101, 114, 107, 101, 121, 44,
+    10,  32,  32,  32,  32,  111, 95,  111, 114, 100, 101, 114, 100, 97,  116,
+    101, 44,  10,  32,  32,  32,  32,  111, 95,  116, 111, 116, 97,  108, 112,
+    114, 105, 99,  101, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,
+    32,  32,  32,  111, 95,  116, 111, 116, 97,  108, 112, 114, 105, 99,  101,
+    32,  68,  69,  83,  67,  44,  10,  32,  32,  32,  32,  111, 95,  111, 114,
+    100, 101, 114, 100, 97,  116, 101, 10,  76,  73,  77,  73,  84,  32,  49,
+    48,  48,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q19[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  115, 117, 109, 40,
+    108, 95,  101, 120, 116, 101, 110, 100, 101, 100, 112, 114, 105, 99,  101,
+    32,  42,  32,  40,  49,  32,  45,  32,  108, 95,  100, 105, 115, 99,  111,
+    117, 110, 116, 41,  41,  32,  65,  83,  32,  114, 101, 118, 101, 110, 117,
+    101, 10,  70,  82,  79,  77,  10,  32,  32,  32,  32,  108, 105, 110, 101,
+    105, 116, 101, 109, 44,  10,  32,  32,  32,  32,  112, 97,  114, 116, 10,
+    87,  72,  69,  82,  69,  32,  40,  112, 95,  112, 97,  114, 116, 107, 101,
+    121, 32,  61,  32,  108, 95,  112, 97,  114, 116, 107, 101, 121, 10,  32,
+    32,  32,  32,  65,  78,  68,  32,  112, 95,  98,  114, 97,  110, 100, 32,
+    61,  32,  39,  66,  114, 97,  110, 100, 35,  49,  50,  39,  10,  32,  32,
+    32,  32,  65,  78,  68,  32,  112, 95,  99,  111, 110, 116, 97,  105, 110,
+    101, 114, 32,  73,  78,  32,  40,  39,  83,  77,  32,  67,  65,  83,  69,
+    39,  44,  32,  39,  83,  77,  32,  66,  79,  88,  39,  44,  32,  39,  83,
+    77,  32,  80,  65,  67,  75,  39,  44,  32,  39,  83,  77,  32,  80,  75,
+    71,  39,  41,  10,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  113,
+    117, 97,  110, 116, 105, 116, 121, 32,  62,  61,  32,  49,  10,  32,  32,
+    32,  32,  65,  78,  68,  32,  108, 95,  113, 117, 97,  110, 116, 105, 116,
+    121, 32,  60,  61,  32,  49,  32,  43,  32,  49,  48,  10,  32,  32,  32,
+    32,  65,  78,  68,  32,  112, 95,  115, 105, 122, 101, 32,  66,  69,  84,
+    87,  69,  69,  78,  32,  49,  32,  65,  78,  68,  32,  53,  10,  32,  32,
+    32,  32,  65,  78,  68,  32,  108, 95,  115, 104, 105, 112, 109, 111, 100,
+    101, 32,  73,  78,  32,  40,  39,  65,  73,  82,  39,  44,  32,  39,  65,
+    73,  82,  32,  82,  69,  71,  39,  41,  10,  32,  32,  32,  32,  65,  78,
+    68,  32,  108, 95,  115, 104, 105, 112, 105, 110, 115, 116, 114, 117, 99,
+    116, 32,  61,  32,  39,  68,  69,  76,  73,  86,  69,  82,  32,  73,  78,
+    32,  80,  69,  82,  83,  79,  78,  39,  41,  10,  32,  32,  32,  32,  79,
+    82,  32,  40,  112, 95,  112, 97,  114, 116, 107, 101, 121, 32,  61,  32,
+    108, 95,  112, 97,  114, 116, 107, 101, 121, 10,  32,  32,  32,  32,  32,
+    32,  32,  32,  65,  78,  68,  32,  112, 95,  98,  114, 97,  110, 100, 32,
+    61,  32,  39,  66,  114, 97,  110, 100, 35,  50,  51,  39,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  112, 95,  99,  111, 110,
+    116, 97,  105, 110, 101, 114, 32,  73,  78,  32,  40,  39,  77,  69,  68,
+    32,  66,  65,  71,  39,  44,  32,  39,  77,  69,  68,  32,  66,  79,  88,
+    39,  44,  32,  39,  77,  69,  68,  32,  80,  75,  71,  39,  44,  32,  39,
+    77,  69,  68,  32,  80,  65,  67,  75,  39,  41,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  113, 117, 97,  110, 116,
+    105, 116, 121, 32,  62,  61,  32,  49,  48,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  65,  78,  68,  32,  108, 95,  113, 117, 97,  110, 116, 105,
+    116, 121, 32,  60,  61,  32,  49,  48,  32,  43,  32,  49,  48,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  112, 95,  115, 105,
+    122, 101, 32,  66,  69,  84,  87,  69,  69,  78,  32,  49,  32,  65,  78,
+    68,  32,  49,  48,  10,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,
+    68,  32,  108, 95,  115, 104, 105, 112, 109, 111, 100, 101, 32,  73,  78,
+    32,  40,  39,  65,  73,  82,  39,  44,  32,  39,  65,  73,  82,  32,  82,
+    69,  71,  39,  41,  10,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,
+    68,  32,  108, 95,  115, 104, 105, 112, 105, 110, 115, 116, 114, 117, 99,
+    116, 32,  61,  32,  39,  68,  69,  76,  73,  86,  69,  82,  32,  73,  78,
+    32,  80,  69,  82,  83,  79,  78,  39,  41,  10,  32,  32,  32,  32,  79,
+    82,  32,  40,  112, 95,  112, 97,  114, 116, 107, 101, 121, 32,  61,  32,
+    108, 95,  112, 97,  114, 116, 107, 101, 121, 10,  32,  32,  32,  32,  32,
+    32,  32,  32,  65,  78,  68,  32,  112, 95,  98,  114, 97,  110, 100, 32,
+    61,  32,  39,  66,  114, 97,  110, 100, 35,  51,  52,  39,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  112, 95,  99,  111, 110,
+    116, 97,  105, 110, 101, 114, 32,  73,  78,  32,  40,  39,  76,  71,  32,
+    67,  65,  83,  69,  39,  44,  32,  39,  76,  71,  32,  66,  79,  88,  39,
+    44,  32,  39,  76,  71,  32,  80,  65,  67,  75,  39,  44,  32,  39,  76,
+    71,  32,  80,  75,  71,  39,  41,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  65,  78,  68,  32,  108, 95,  113, 117, 97,  110, 116, 105, 116, 121,
+    32,  62,  61,  32,  50,  48,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    65,  78,  68,  32,  108, 95,  113, 117, 97,  110, 116, 105, 116, 121, 32,
+    60,  61,  32,  50,  48,  32,  43,  32,  49,  48,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  65,  78,  68,  32,  112, 95,  115, 105, 122, 101, 32,
+    66,  69,  84,  87,  69,  69,  78,  32,  49,  32,  65,  78,  68,  32,  49,
+    53,  10,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  108,
+    95,  115, 104, 105, 112, 109, 111, 100, 101, 32,  73,  78,  32,  40,  39,
+    65,  73,  82,  39,  44,  32,  39,  65,  73,  82,  32,  82,  69,  71,  39,
+    41,  10,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  108,
+    95,  115, 104, 105, 112, 105, 110, 115, 116, 114, 117, 99,  116, 32,  61,
+    32,  39,  68,  69,  76,  73,  86,  69,  82,  32,  73,  78,  32,  80,  69,
+    82,  83,  79,  78,  39,  41,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q20[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  115, 95,  110, 97,
+    109, 101, 44,  10,  32,  32,  32,  32,  115, 95,  97,  100, 100, 114, 101,
+    115, 115, 10,  70,  82,  79,  77,  10,  32,  32,  32,  32,  115, 117, 112,
+    112, 108, 105, 101, 114, 44,  10,  32,  32,  32,  32,  110, 97,  116, 105,
+    111, 110, 10,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  115, 95,
+    115, 117, 112, 112, 107, 101, 121, 32,  73,  78,  32,  40,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  83,  69,  76,  69,  67,  84,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  112, 115, 95,  115, 117,
+    112, 112, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  70,
+    82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  112, 97,  114, 116, 115, 117, 112, 112, 10,  32,  32,  32,  32,  32,
+    32,  32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  112, 115, 95,  112, 97,  114, 116, 107, 101,
+    121, 32,  73,  78,  32,  40,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  83,  69,  76,  69,  67,  84,  10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  112, 95,  112, 97,  114, 116, 107, 101, 121, 10,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  112, 97,  114, 116,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  112, 95,
+    110, 97,  109, 101, 32,  76,  73,  75,  69,  32,  39,  102, 111, 114, 101,
+    115, 116, 37,  39,  41,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  112, 115, 95,  97,
+    118, 97,  105, 108, 113, 116, 121, 32,  62,  32,  40,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  48,  46,  53,  32,  42,  32,  115, 117, 109, 40,  108, 95,
+    113, 117, 97,  110, 116, 105, 116, 121, 41,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    70,  82,  79,  77,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  108,
+    105, 110, 101, 105, 116, 101, 109, 10,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  87,  72,
+    69,  82,  69,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  108, 95,
+    112, 97,  114, 116, 107, 101, 121, 32,  61,  32,  112, 115, 95,  112, 97,
+    114, 116, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    65,  78,  68,  32,  108, 95,  115, 117, 112, 112, 107, 101, 121, 32,  61,
+    32,  112, 115, 95,  115, 117, 112, 112, 107, 101, 121, 10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  108, 95,  115, 104, 105,
+    112, 100, 97,  116, 101, 32,  62,  61,  32,  67,  65,  83,  84,  40,  39,
+    49,  57,  57,  52,  45,  48,  49,  45,  48,  49,  39,  32,  65,  83,  32,
+    100, 97,  116, 101, 41,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    65,  78,  68,  32,  108, 95,  115, 104, 105, 112, 100, 97,  116, 101, 32,
+    60,  32,  67,  65,  83,  84,  40,  39,  49,  57,  57,  53,  45,  48,  49,
+    45,  48,  49,  39,  32,  65,  83,  32,  100, 97,  116, 101, 41,  41,  41,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,
+    68,  32,  115, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 32,  61,
+    32,  110, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 10,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,  32,  110,
+    95,  110, 97,  109, 101, 32,  61,  32,  39,  67,  65,  78,  65,  68,  65,
+    39,  10,  32,  32,  32,  32,  32,  32,  32,  32,  79,  82,  68,  69,  82,
+    32,  66,  89,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  115, 95,  110, 97,  109, 101, 59,  10,  0};
+const uint8_t TPCH_QUERIES_q21[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  115, 95,  110, 97,
+    109, 101, 44,  10,  32,  32,  32,  32,  99,  111, 117, 110, 116, 40,  42,
+    41,  32,  65,  83,  32,  110, 117, 109, 119, 97,  105, 116, 10,  70,  82,
+    79,  77,  10,  32,  32,  32,  32,  115, 117, 112, 112, 108, 105, 101, 114,
+    44,  10,  32,  32,  32,  32,  108, 105, 110, 101, 105, 116, 101, 109, 32,
+    108, 49,  44,  10,  32,  32,  32,  32,  111, 114, 100, 101, 114, 115, 44,
+    10,  32,  32,  32,  32,  110, 97,  116, 105, 111, 110, 10,  87,  72,  69,
+    82,  69,  10,  32,  32,  32,  32,  115, 95,  115, 117, 112, 112, 107, 101,
+    121, 32,  61,  32,  108, 49,  46,  108, 95,  115, 117, 112, 112, 107, 101,
+    121, 10,  32,  32,  32,  32,  65,  78,  68,  32,  111, 95,  111, 114, 100,
+    101, 114, 107, 101, 121, 32,  61,  32,  108, 49,  46,  108, 95,  111, 114,
+    100, 101, 114, 107, 101, 121, 10,  32,  32,  32,  32,  65,  78,  68,  32,
+    111, 95,  111, 114, 100, 101, 114, 115, 116, 97,  116, 117, 115, 32,  61,
+    32,  39,  70,  39,  10,  32,  32,  32,  32,  65,  78,  68,  32,  108, 49,
+    46,  108, 95,  114, 101, 99,  101, 105, 112, 116, 100, 97,  116, 101, 32,
+    62,  32,  108, 49,  46,  108, 95,  99,  111, 109, 109, 105, 116, 100, 97,
+    116, 101, 10,  32,  32,  32,  32,  65,  78,  68,  32,  69,  88,  73,  83,
+    84,  83,  32,  40,  10,  32,  32,  32,  32,  32,  32,  32,  32,  83,  69,
+    76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  42,  10,  32,  32,  32,  32,  32,  32,  32,  32,  70,  82,  79,
+    77,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  108,
+    105, 110, 101, 105, 116, 101, 109, 32,  108, 50,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  108, 50,  46,  108, 95,  111, 114, 100,
+    101, 114, 107, 101, 121, 32,  61,  32,  108, 49,  46,  108, 95,  111, 114,
+    100, 101, 114, 107, 101, 121, 10,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  65,  78,  68,  32,  108, 50,  46,  108, 95,  115, 117,
+    112, 112, 107, 101, 121, 32,  60,  62,  32,  108, 49,  46,  108, 95,  115,
+    117, 112, 112, 107, 101, 121, 41,  10,  32,  32,  32,  32,  65,  78,  68,
+    32,  78,  79,  84,  32,  69,  88,  73,  83,  84,  83,  32,  40,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  83,  69,  76,  69,  67,  84,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  42,  10,  32,  32,
+    32,  32,  32,  32,  32,  32,  70,  82,  79,  77,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  108, 105, 110, 101, 105, 116, 101,
+    109, 32,  108, 51,  10,  32,  32,  32,  32,  32,  32,  32,  32,  87,  72,
+    69,  82,  69,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  108, 51,  46,  108, 95,  111, 114, 100, 101, 114, 107, 101, 121, 32,
+    61,  32,  108, 49,  46,  108, 95,  111, 114, 100, 101, 114, 107, 101, 121,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,
+    68,  32,  108, 51,  46,  108, 95,  115, 117, 112, 112, 107, 101, 121, 32,
+    60,  62,  32,  108, 49,  46,  108, 95,  115, 117, 112, 112, 107, 101, 121,
+    10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,
+    68,  32,  108, 51,  46,  108, 95,  114, 101, 99,  101, 105, 112, 116, 100,
+    97,  116, 101, 32,  62,  32,  108, 51,  46,  108, 95,  99,  111, 109, 109,
+    105, 116, 100, 97,  116, 101, 41,  10,  32,  32,  32,  32,  65,  78,  68,
+    32,  115, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 32,  61,  32,
+    110, 95,  110, 97,  116, 105, 111, 110, 107, 101, 121, 10,  32,  32,  32,
+    32,  65,  78,  68,  32,  110, 95,  110, 97,  109, 101, 32,  61,  32,  39,
+    83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  39,  10,  71,
+    82,  79,  85,  80,  32,  66,  89,  10,  32,  32,  32,  32,  115, 95,  110,
+    97,  109, 101, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,  32,
+    32,  32,  110, 117, 109, 119, 97,  105, 116, 32,  68,  69,  83,  67,  44,
+    10,  32,  32,  32,  32,  115, 95,  110, 97,  109, 101, 10,  76,  73,  77,
+    73,  84,  32,  49,  48,  48,  59,  10,  0};
+const uint8_t TPCH_QUERIES_q22[] = {
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  99,  110, 116, 114,
+    121, 99,  111, 100, 101, 44,  10,  32,  32,  32,  32,  99,  111, 117, 110,
+    116, 40,  42,  41,  32,  65,  83,  32,  110, 117, 109, 99,  117, 115, 116,
+    44,  10,  32,  32,  32,  32,  115, 117, 109, 40,  99,  95,  97,  99,  99,
+    116, 98,  97,  108, 41,  32,  65,  83,  32,  116, 111, 116, 97,  99,  99,
+    116, 98,  97,  108, 10,  70,  82,  79,  77,  32,  40,  10,  32,  32,  32,
+    32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  115, 117, 98,  115, 116, 114, 105, 110, 103, 40,  99,  95,  112, 104,
+    111, 110, 101, 32,  70,  82,  79,  77,  32,  49,  32,  70,  79,  82,  32,
+    50,  41,  32,  65,  83,  32,  99,  110, 116, 114, 121, 99,  111, 100, 101,
+    44,  10,  32,  32,  32,  32,  32,  32,  32,  32,  99,  95,  97,  99,  99,
+    116, 98,  97,  108, 10,  32,  32,  32,  32,  70,  82,  79,  77,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  99,  117, 115, 116, 111, 109, 101, 114,
+    10,  32,  32,  32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  115, 117, 98,  115, 116, 114, 105, 110, 103, 40,  99,
+    95,  112, 104, 111, 110, 101, 32,  70,  82,  79,  77,  32,  49,  32,  70,
+    79,  82,  32,  50,  41,  32,  73,  78,  32,  40,  39,  49,  51,  39,  44,
+    32,  39,  51,  49,  39,  44,  32,  39,  50,  51,  39,  44,  32,  39,  50,
+    57,  39,  44,  32,  39,  51,  48,  39,  44,  32,  39,  49,  56,  39,  44,
+    32,  39,  49,  55,  39,  41,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    65,  78,  68,  32,  99,  95,  97,  99,  99,  116, 98,  97,  108, 32,  62,
+    32,  40,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    83,  69,  76,  69,  67,  84,  10,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  97,  118, 103, 40,  99,  95,  97,
+    99,  99,  116, 98,  97,  108, 41,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  99,  117, 115, 116,
+    111, 109, 101, 114, 10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  87,  72,  69,  82,  69,  10,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  99,  95,  97,  99,  99,  116,
+    98,  97,  108, 32,  62,  32,  48,  46,  48,  48,  10,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  65,  78,  68,
+    32,  115, 117, 98,  115, 116, 114, 105, 110, 103, 40,  99,  95,  112, 104,
+    111, 110, 101, 32,  70,  82,  79,  77,  32,  49,  32,  70,  79,  82,  32,
+    50,  41,  32,  73,  78,  32,  40,  39,  49,  51,  39,  44,  32,  39,  51,
+    49,  39,  44,  32,  39,  50,  51,  39,  44,  32,  39,  50,  57,  39,  44,
+    32,  39,  51,  48,  39,  44,  32,  39,  49,  56,  39,  44,  32,  39,  49,
+    55,  39,  41,  41,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  65,  78,  68,  32,  78,  79,  84,  32,  69,  88,  73,  83,  84,
+    83,  32,  40,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  83,  69,  76,  69,  67,  84,  10,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  42,  10,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  70,  82,  79,  77,  10,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    111, 114, 100, 101, 114, 115, 10,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  87,  72,  69,  82,  69,  10,  32,
+    32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+    32,  32,  32,  32,  111, 95,  99,  117, 115, 116, 107, 101, 121, 32,  61,
+    32,  99,  95,  99,  117, 115, 116, 107, 101, 121, 41,  41,  32,  65,  83,
+    32,  99,  117, 115, 116, 115, 97,  108, 101, 10,  71,  82,  79,  85,  80,
+    32,  66,  89,  10,  32,  32,  32,  32,  99,  110, 116, 114, 121, 99,  111,
+    100, 101, 10,  79,  82,  68,  69,  82,  32,  66,  89,  10,  32,  32,  32,
+    32,  99,  110, 116, 114, 121, 99,  111, 100, 101, 59,  10,  0};
+const char* TPCH_QUERIES[] = {
+    (const char*)TPCH_QUERIES_q01, (const char*)TPCH_QUERIES_q02,
+    (const char*)TPCH_QUERIES_q03, (const char*)TPCH_QUERIES_q04,
+    (const char*)TPCH_QUERIES_q05, (const char*)TPCH_QUERIES_q06,
+    (const char*)TPCH_QUERIES_q07, (const char*)TPCH_QUERIES_q08,
+    (const char*)TPCH_QUERIES_q09, (const char*)TPCH_QUERIES_q10,
+    (const char*)TPCH_QUERIES_q11, (const char*)TPCH_QUERIES_q12,
+    (const char*)TPCH_QUERIES_q13, (const char*)TPCH_QUERIES_q14,
+    (const char*)TPCH_QUERIES_q15, (const char*)TPCH_QUERIES_q16,
+    (const char*)TPCH_QUERIES_q17, (const char*)TPCH_QUERIES_q18,
+    (const char*)TPCH_QUERIES_q19, (const char*)TPCH_QUERIES_q20,
+    (const char*)TPCH_QUERIES_q21, (const char*)TPCH_QUERIES_q22};
+const uint8_t TPCH_ANSWERS_SF0_01_q01[] = {
+    108, 95,  114, 101, 116, 117, 114, 110, 102, 108, 97,  103, 124, 108, 95,
+    108, 105, 110, 101, 115, 116, 97,  116, 117, 115, 124, 115, 117, 109, 95,
+    113, 116, 121, 124, 115, 117, 109, 95,  98,  97,  115, 101, 95,  112, 114,
+    105, 99,  101, 124, 115, 117, 109, 95,  100, 105, 115, 99,  95,  112, 114,
+    105, 99,  101, 124, 115, 117, 109, 95,  99,  104, 97,  114, 103, 101, 124,
+    97,  118, 103, 95,  113, 116, 121, 124, 97,  118, 103, 95,  112, 114, 105,
+    99,  101, 124, 97,  118, 103, 95,  100, 105, 115, 99,  124, 99,  111, 117,
+    110, 116, 95,  111, 114, 100, 101, 114, 10,  65,  124, 70,  124, 51,  56,
+    48,  52,  53,  54,  124, 53,  51,  50,  51,  52,  56,  50,  49,  49,  46,
+    54,  53,  124, 53,  48,  53,  56,  50,  50,  52,  52,  49,  46,  52,  56,
+    54,  49,  124, 53,  50,  54,  49,  54,  53,  57,  51,  52,  46,  48,  48,
+    48,  56,  51,  57,  124, 50,  53,  46,  53,  55,  53,  49,  53,  52,  54,
+    49,  49,  52,  53,  52,  54,  57,  50,  49,  124, 51,  53,  55,  56,  53,
+    46,  55,  48,  57,  51,  48,  54,  57,  51,  55,  51,  52,  57,  124, 48,
+    46,  48,  53,  48,  48,  56,  49,  51,  51,  57,  48,  54,  57,  54,  52,
+    50,  51,  55,  54,  57,  56,  124, 49,  52,  56,  55,  54,  10,  78,  124,
+    70,  124, 56,  57,  55,  49,  124, 49,  50,  51,  56,  52,  56,  48,  49,
+    46,  51,  55,  124, 49,  49,  55,  57,  56,  50,  53,  55,  46,  50,  48,
+    56,  48,  124, 49,  50,  50,  56,  50,  52,  56,  53,  46,  48,  53,  54,
+    57,  51,  51,  124, 50,  53,  46,  55,  55,  56,  55,  51,  53,  54,  51,
+    50,  49,  56,  51,  57,  48,  56,  48,  124, 51,  53,  53,  56,  56,  46,
+    53,  48,  57,  54,  56,  51,  57,  48,  56,  48,  52,  54,  124, 48,  46,
+    48,  52,  55,  55,  53,  56,  54,  50,  48,  54,  56,  57,  54,  53,  53,
+    49,  55,  50,  52,  49,  124, 51,  52,  56,  10,  78,  124, 79,  124, 55,
+    52,  50,  56,  48,  50,  124, 49,  48,  52,  49,  53,  48,  50,  56,  52,
+    49,  46,  52,  53,  124, 57,  56,  57,  55,  51,  55,  53,  49,  56,  46,
+    54,  51,  52,  54,  124, 49,  48,  50,  57,  52,  49,  56,  53,  51,  49,
+    46,  53,  50,  51,  51,  53,  48,  124, 50,  53,  46,  52,  53,  52,  57,
+    56,  55,  56,  51,  52,  53,  52,  57,  56,  55,  56,  51,  124, 51,  53,
+    54,  57,  49,  46,  49,  50,  57,  50,  48,  57,  48,  55,  52,  51,  57,
+    56,  124, 48,  46,  48,  52,  57,  57,  51,  49,  49,  49,  57,  53,  54,
+    52,  48,  57,  57,  57,  50,  56,  48,  52,  124, 50,  57,  49,  56,  49,
+    10,  82,  124, 70,  124, 51,  56,  49,  52,  52,  57,  124, 53,  51,  52,
+    53,  57,  52,  52,  52,  53,  46,  51,  53,  124, 53,  48,  55,  57,  57,
+    54,  52,  53,  52,  46,  52,  48,  54,  55,  124, 53,  50,  56,  53,  50,
+    52,  50,  49,  57,  46,  51,  53,  56,  57,  48,  51,  124, 50,  53,  46,
+    53,  57,  55,  49,  54,  56,  49,  54,  53,  51,  52,  54,  57,  51,  51,
+    51,  124, 51,  53,  56,  55,  52,  46,  48,  48,  54,  53,  51,  50,  54,
+    56,  48,  49,  55,  55,  124, 48,  46,  48,  52,  57,  56,  50,  55,  53,
+    51,  57,  57,  50,  55,  53,  50,  54,  53,  48,  54,  53,  49,  124, 49,
+    52,  57,  48,  50,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q02[] = {
+    115, 95,  97,  99,  99,  116, 98,  97,  108, 124, 115, 95,  110, 97,  109,
+    101, 124, 110, 95,  110, 97,  109, 101, 124, 112, 95,  112, 97,  114, 116,
+    107, 101, 121, 124, 112, 95,  109, 102, 103, 114, 124, 115, 95,  97,  100,
+    100, 114, 101, 115, 115, 124, 115, 95,  112, 104, 111, 110, 101, 124, 115,
+    95,  99,  111, 109, 109, 101, 110, 116, 10,  52,  49,  56,  54,  46,  57,
+    53,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  48,  55,  55,  124, 71,  69,  82,  77,  65,  78,  89,  124, 50,
+    52,  57,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  52,  124, 119, 53,  121, 79,  32,  48,  121, 106, 88,  111, 117, 32,
+    56,  73,  52,  102, 102, 122, 65,  68,  113, 44,  82,  56,  116, 68,  48,
+    54,  120, 49,  118, 98,  101, 77,  112, 76,  74,  70,  50,  124, 49,  55,
+    45,  50,  56,  49,  45,  51,  52,  53,  45,  52,  56,  54,  51,  124, 116,
+    104, 101, 32,  115, 108, 121, 108, 121, 32,  102, 105, 110, 97,  108, 32,
+    97,  115, 121, 109, 112, 116, 111, 116, 101, 115, 46,  32,  98,  108, 105,
+    116, 104, 101, 108, 121, 32,  112, 101, 110, 100, 105, 110, 103, 32,  116,
+    104, 101, 111, 100, 111, 108, 105, 10,  49,  56,  56,  51,  46,  51,  55,
+    124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    48,  48,  56,  54,  124, 82,  79,  77,  65,  78,  73,  65,  124, 49,  48,
+    49,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  52,  124, 105, 90,  76,  75,  75,  87,  97,  81,  65,  68,  101, 124,
+    50,  57,  45,  57,  48,  51,  45,  54,  54,  53,  45,  55,  48,  54,  53,
+    124, 99,  97,  106, 111, 108, 101, 32,  102, 117, 114, 105, 111, 117, 115,
+    108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 44,  32,  102, 105, 110,
+    97,  108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 58,  32,  102, 117,
+    114, 105, 111, 117, 115, 108, 121, 32,  115, 112, 101, 99,  10,  49,  54,
+    56,  55,  46,  56,  49,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  48,  49,  55,  124, 82,  79,  77,  65,  78,
+    73,  65,  124, 49,  54,  51,  52,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  50,  124, 80,  89,  78,  48,  109, 57,  106,
+    57,  56,  71,  104, 88,  52,  50,  68,  118, 66,  75,  118, 85,  82,  99,
+    65,  100, 44,  66,  124, 50,  57,  45,  54,  48,  49,  45,  56,  56,  52,
+    45,  57,  50,  49,  57,  124, 101, 101, 112, 32,  97,  103, 97,  105, 110,
+    115, 116, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108,
+    121, 32,  98,  111, 108, 100, 32,  105, 100, 101, 97,  115, 46,  32,  102,
+    108, 117, 102, 102, 105, 108, 121, 32,  98,  111, 108, 100, 32,  112, 97,
+    99,  107, 97,  10,  50,  56,  55,  46,  49,  54,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  48,  53,  50,  124,
+    82,  79,  77,  65,  78,  73,  65,  124, 51,  50,  51,  124, 77,  97,  110,
+    117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 53,  111, 71,
+    114, 51,  112, 106, 50,  115, 112, 114, 90,  78,  119, 104, 111, 56,  67,
+    70,  87,  50,  104, 97,  97,  79,  98,  100, 48,  124, 50,  57,  45,  57,
+    55,  52,  45,  57,  51,  52,  45,  52,  55,  49,  51,  124, 100, 111, 108,
+    105, 116, 101, 115, 32,  97,  114, 101, 32,  115, 108, 121, 108, 121, 32,
+    97,  103, 97,  105, 110, 115, 116, 32,  116, 104, 101, 32,  102, 117, 114,
+    105, 111, 117, 115, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,
+    112, 97,  99,  107, 97,  103, 101, 115, 46,  32,  105, 114, 111, 110, 105,
+    99,  44,  32,  102, 105, 110, 97,  108, 32,  100, 101, 112, 111, 115, 105,
+    116, 115, 32,  99,  97,  106, 111, 108, 101, 32,  113, 117, 105, 99,  107,
+    108, 121, 10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q03[] = {
+    108, 95,  111, 114, 100, 101, 114, 107, 101, 121, 124, 114, 101, 118, 101,
+    110, 117, 101, 124, 111, 95,  111, 114, 100, 101, 114, 100, 97,  116, 101,
+    124, 111, 95,  115, 104, 105, 112, 112, 114, 105, 111, 114, 105, 116, 121,
+    10,  52,  55,  55,  49,  52,  124, 50,  54,  55,  48,  49,  48,  46,  53,
+    56,  57,  52,  124, 49,  57,  57,  53,  45,  48,  51,  45,  49,  49,  124,
+    48,  10,  50,  50,  50,  55,  54,  124, 50,  54,  54,  51,  53,  49,  46,
+    53,  53,  54,  50,  124, 49,  57,  57,  53,  45,  48,  49,  45,  50,  57,
+    124, 48,  10,  51,  50,  57,  54,  53,  124, 50,  54,  51,  55,  54,  56,
+    46,  51,  52,  49,  52,  124, 49,  57,  57,  53,  45,  48,  50,  45,  50,
+    53,  124, 48,  10,  50,  49,  57,  53,  54,  124, 50,  53,  52,  53,  52,
+    49,  46,  49,  50,  56,  53,  124, 49,  57,  57,  53,  45,  48,  50,  45,
+    48,  50,  124, 48,  10,  49,  54,  51,  55,  124, 50,  52,  51,  53,  49,
+    50,  46,  55,  57,  56,  49,  124, 49,  57,  57,  53,  45,  48,  50,  45,
+    48,  56,  124, 48,  10,  49,  48,  57,  49,  54,  124, 50,  52,  49,  51,
+    50,  48,  46,  48,  56,  49,  52,  124, 49,  57,  57,  53,  45,  48,  51,
+    45,  49,  49,  124, 48,  10,  51,  48,  52,  57,  55,  124, 50,  48,  56,
+    53,  54,  54,  46,  54,  57,  54,  57,  124, 49,  57,  57,  53,  45,  48,
+    50,  45,  48,  55,  124, 48,  10,  52,  53,  48,  124, 50,  48,  53,  52,
+    52,  55,  46,  52,  50,  51,  50,  124, 49,  57,  57,  53,  45,  48,  51,
+    45,  48,  53,  124, 48,  10,  52,  55,  50,  48,  52,  124, 50,  48,  52,
+    52,  55,  56,  46,  53,  50,  49,  51,  124, 49,  57,  57,  53,  45,  48,
+    51,  45,  49,  51,  124, 48,  10,  57,  54,  57,  54,  124, 50,  48,  49,
+    53,  48,  50,  46,  50,  49,  56,  56,  124, 49,  57,  57,  53,  45,  48,
+    50,  45,  50,  48,  124, 48,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q04[] = {
+    111, 95,  111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116,
+    121, 124, 111, 114, 100, 101, 114, 95,  99,  111, 117, 110, 116, 10,
+    49,  45,  85,  82,  71,  69,  78,  84,  124, 57,  51,  10,  50,  45,
+    72,  73,  71,  72,  124, 49,  48,  51,  10,  51,  45,  77,  69,  68,
+    73,  85,  77,  124, 49,  48,  57,  10,  52,  45,  78,  79,  84,  32,
+    83,  80,  69,  67,  73,  70,  73,  69,  68,  124, 49,  48,  50,  10,
+    53,  45,  76,  79,  87,  124, 49,  50,  56,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q05[] = {
+    110, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 10,
+    86,  73, 69,  84, 78,  65,  77,  124, 49,  48,  48,  48,  57,  50,  54,
+    46,  54, 57,  57, 57,  10,  67,  72,  73,  78,  65,  124, 55,  52,  48,
+    50,  49, 48,  46, 55,  53,  55,  48,  10,  74,  65,  80,  65,  78,  124,
+    54,  54, 48,  54, 53,  49,  46,  50,  52,  50,  53,  10,  73,  78,  68,
+    79,  78, 69,  83, 73,  65,  124, 53,  54,  54,  51,  55,  57,  46,  53,
+    50,  55, 54,  10, 73,  78,  68,  73,  65,  124, 52,  50,  50,  56,  55,
+    52,  46, 54,  56, 52,  52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q06[] = {
+    114, 101, 118, 101, 110, 117, 101, 10, 49, 49, 57,
+    51,  48,  53,  51,  46,  50,  50,  53, 51, 10, 0};
+const uint8_t TPCH_ANSWERS_SF0_01_q07[] = {
+    115, 117, 112, 112, 95,  110, 97,  116, 105, 111, 110, 124, 99,  117,
+    115, 116, 95,  110, 97,  116, 105, 111, 110, 124, 108, 95,  121, 101,
+    97,  114, 124, 114, 101, 118, 101, 110, 117, 101, 10,  70,  82,  65,
+    78,  67,  69,  124, 71,  69,  82,  77,  65,  78,  89,  124, 49,  57,
+    57,  53,  124, 50,  54,  56,  48,  54,  56,  46,  53,  55,  55,  52,
+    10,  70,  82,  65,  78,  67,  69,  124, 71,  69,  82,  77,  65,  78,
+    89,  124, 49,  57,  57,  54,  124, 51,  48,  51,  56,  54,  50,  46,
+    50,  57,  56,  48,  10,  71,  69,  82,  77,  65,  78,  89,  124, 70,
+    82,  65,  78,  67,  69,  124, 49,  57,  57,  53,  124, 54,  50,  49,
+    49,  53,  57,  46,  52,  56,  56,  50,  10,  71,  69,  82,  77,  65,
+    78,  89,  124, 70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  54,
+    124, 51,  55,  57,  48,  57,  53,  46,  56,  56,  53,  52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q08[] = {
+    111, 95,  121, 101, 97, 114, 124, 109, 107, 116, 95, 115, 104, 97,
+    114, 101, 10,  49,  57, 57,  53,  124, 48,  46,  48, 48,  48,  48,
+    48,  48,  48,  48,  48, 48,  48,  48,  48,  48,  48, 48,  48,  48,
+    48,  48,  48,  48,  48, 48,  10,  49,  57,  57,  54, 124, 48,  46,
+    48,  48,  48,  48,  48, 48,  48,  48,  48,  48,  48, 48,  48,  48,
+    48,  48,  48,  48,  48, 48,  48,  48,  48,  48,  10, 0};
+const uint8_t TPCH_ANSWERS_SF0_01_q09[] = {
+    110, 97,  116, 105, 111, 110, 124, 111, 95,  121, 101, 97,  114, 124, 115,
+    117, 109, 95,  112, 114, 111, 102, 105, 116, 10,  65,  76,  71,  69,  82,
+    73,  65,  124, 49,  57,  57,  56,  124, 57,  55,  56,  54,  52,  46,  53,
+    54,  56,  50,  10,  65,  76,  71,  69,  82,  73,  65,  124, 49,  57,  57,
+    55,  124, 51,  54,  56,  50,  51,  49,  46,  54,  54,  57,  53,  10,  65,
+    76,  71,  69,  82,  73,  65,  124, 49,  57,  57,  54,  124, 49,  57,  54,
+    53,  50,  53,  46,  56,  48,  52,  54,  10,  65,  76,  71,  69,  82,  73,
+    65,  124, 49,  57,  57,  53,  124, 51,  52,  49,  52,  51,  56,  46,  54,
+    56,  56,  53,  10,  65,  76,  71,  69,  82,  73,  65,  124, 49,  57,  57,
+    52,  124, 54,  55,  55,  52,  52,  52,  46,  48,  49,  54,  48,  10,  65,
+    76,  71,  69,  82,  73,  65,  124, 49,  57,  57,  51,  124, 52,  53,  56,
+    55,  53,  54,  46,  57,  49,  53,  55,  10,  65,  76,  71,  69,  82,  73,
+    65,  124, 49,  57,  57,  50,  124, 53,  52,  57,  50,  52,  51,  46,  57,
+    53,  49,  49,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,
+    57,  57,  56,  124, 56,  48,  52,  52,  56,  46,  55,  54,  56,  48,  10,
+    65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  55,  124,
+    49,  56,  54,  50,  55,  57,  46,  49,  54,  49,  56,  10,  65,  82,  71,
+    69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  54,  124, 49,  53,  52,
+    48,  52,  49,  46,  56,  56,  50,  50,  10,  65,  82,  71,  69,  78,  84,
+    73,  78,  65,  124, 49,  57,  57,  53,  124, 49,  49,  51,  49,  52,  51,
+    46,  51,  49,  49,  57,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,
+    124, 49,  57,  57,  52,  124, 49,  54,  57,  54,  56,  48,  46,  52,  50,
+    51,  57,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,
+    57,  51,  124, 49,  49,  54,  53,  49,  51,  46,  56,  49,  52,  49,  10,
+    65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  50,  124,
+    50,  48,  50,  52,  48,  52,  46,  55,  54,  48,  56,  10,  66,  82,  65,
+    90,  73,  76,  124, 49,  57,  57,  56,  124, 55,  53,  57,  53,  50,  46,
+    53,  57,  52,  54,  10,  66,  82,  65,  90,  73,  76,  124, 49,  57,  57,
+    55,  124, 49,  57,  48,  53,  52,  56,  46,  49,  49,  48,  52,  10,  66,
+    82,  65,  90,  73,  76,  124, 49,  57,  57,  54,  124, 50,  49,  57,  48,
+    53,  57,  46,  48,  54,  57,  50,  10,  66,  82,  65,  90,  73,  76,  124,
+    49,  57,  57,  53,  124, 49,  56,  54,  52,  51,  53,  46,  50,  48,  50,
+    51,  10,  66,  82,  65,  90,  73,  76,  124, 49,  57,  57,  52,  124, 57,
+    54,  56,  51,  53,  46,  49,  56,  55,  48,  10,  66,  82,  65,  90,  73,
+    76,  124, 49,  57,  57,  51,  124, 49,  56,  54,  51,  54,  53,  46,  52,
+    49,  48,  57,  10,  66,  82,  65,  90,  73,  76,  124, 49,  57,  57,  50,
+    124, 49,  53,  50,  53,  52,  54,  46,  52,  52,  51,  57,  10,  67,  65,
+    78,  65,  68,  65,  124, 49,  57,  57,  56,  124, 49,  48,  49,  48,  51,
+    48,  46,  51,  51,  51,  54,  10,  67,  65,  78,  65,  68,  65,  124, 49,
+    57,  57,  55,  124, 49,  48,  49,  49,  57,  55,  46,  51,  52,  52,  49,
+    10,  67,  65,  78,  65,  68,  65,  124, 49,  57,  57,  54,  124, 50,  53,
+    55,  54,  57,  55,  46,  49,  51,  53,  53,  10,  67,  65,  78,  65,  68,
+    65,  124, 49,  57,  57,  53,  124, 57,  49,  52,  55,  52,  46,  56,  56,
+    50,  48,  10,  67,  65,  78,  65,  68,  65,  124, 49,  57,  57,  52,  124,
+    50,  52,  57,  49,  56,  50,  46,  55,  53,  52,  56,  10,  67,  65,  78,
+    65,  68,  65,  124, 49,  57,  57,  51,  124, 49,  56,  53,  55,  51,  55,
+    46,  56,  51,  55,  57,  10,  67,  65,  78,  65,  68,  65,  124, 49,  57,
+    57,  50,  124, 49,  52,  51,  51,  55,  49,  46,  55,  52,  54,  53,  10,
+    67,  72,  73,  78,  65,  124, 49,  57,  57,  56,  124, 53,  48,  56,  51,
+    54,  52,  46,  53,  52,  52,  52,  10,  67,  72,  73,  78,  65,  124, 49,
+    57,  57,  55,  124, 54,  53,  48,  50,  51,  53,  46,  49,  54,  52,  54,
+    10,  67,  72,  73,  78,  65,  124, 49,  57,  57,  54,  124, 57,  49,  49,
+    51,  54,  54,  46,  48,  54,  57,  56,  10,  67,  72,  73,  78,  65,  124,
+    49,  57,  57,  53,  124, 55,  57,  55,  50,  54,  56,  46,  52,  48,  55,
+    54,  10,  67,  72,  73,  78,  65,  124, 49,  57,  57,  52,  124, 53,  50,
+    57,  57,  56,  57,  46,  51,  48,  57,  53,  10,  67,  72,  73,  78,  65,
+    124, 49,  57,  57,  51,  124, 53,  55,  51,  56,  54,  52,  46,  51,  57,
+    55,  50,  10,  67,  72,  73,  78,  65,  124, 49,  57,  57,  50,  124, 55,
+    53,  49,  54,  56,  56,  46,  55,  54,  49,  51,  10,  69,  71,  89,  80,
+    84,  124, 49,  57,  57,  56,  124, 51,  48,  54,  51,  50,  53,  46,  50,
+    56,  52,  50,  10,  69,  71,  89,  80,  84,  124, 49,  57,  57,  55,  124,
+    53,  54,  56,  52,  54,  49,  46,  54,  54,  57,  57,  10,  69,  71,  89,
+    80,  84,  124, 49,  57,  57,  54,  124, 52,  54,  53,  48,  56,  49,  46,
+    57,  50,  51,  50,  10,  69,  71,  89,  80,  84,  124, 49,  57,  57,  53,
+    124, 53,  52,  50,  56,  56,  54,  46,  53,  48,  56,  55,  10,  69,  71,
+    89,  80,  84,  124, 49,  57,  57,  52,  124, 55,  52,  53,  56,  48,  55,
+    46,  56,  49,  50,  51,  10,  69,  71,  89,  80,  84,  124, 49,  57,  57,
+    51,  124, 51,  56,  49,  53,  48,  51,  46,  50,  48,  48,  56,  10,  69,
+    71,  89,  80,  84,  124, 49,  57,  57,  50,  124, 54,  52,  49,  56,  54,
+    54,  46,  52,  51,  54,  55,  10,  69,  84,  72,  73,  79,  80,  73,  65,
+    124, 49,  57,  57,  56,  124, 50,  50,  54,  48,  53,  52,  46,  53,  55,
+    49,  54,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124, 49,  57,  57,
+    55,  124, 53,  56,  53,  49,  57,  51,  46,  50,  56,  48,  50,  10,  69,
+    84,  72,  73,  79,  80,  73,  65,  124, 49,  57,  57,  54,  124, 52,  48,
+    53,  52,  49,  50,  46,  55,  55,  52,  49,  10,  69,  84,  72,  73,  79,
+    80,  73,  65,  124, 49,  57,  57,  53,  124, 50,  55,  48,  52,  53,  53,
+    46,  55,  54,  51,  55,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124,
+    49,  57,  57,  52,  124, 53,  54,  55,  56,  55,  53,  46,  52,  50,  55,
+    57,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124, 49,  57,  57,  51,
+    124, 52,  49,  50,  51,  48,  50,  46,  50,  56,  55,  49,  10,  69,  84,
+    72,  73,  79,  80,  73,  65,  124, 49,  57,  57,  50,  124, 53,  53,  49,
+    50,  56,  52,  46,  53,  56,  50,  49,  10,  70,  82,  65,  78,  67,  69,
+    124, 49,  57,  57,  56,  124, 49,  51,  53,  55,  50,  51,  46,  52,  48,
+    53,  48,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  55,  124,
+    50,  52,  57,  54,  54,  52,  46,  55,  53,  55,  56,  10,  70,  82,  65,
+    78,  67,  69,  124, 49,  57,  57,  54,  124, 49,  55,  53,  56,  56,  50,
+    46,  56,  57,  51,  52,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,
+    57,  53,  124, 49,  49,  54,  51,  57,  52,  46,  55,  56,  54,  54,  10,
+    70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  52,  124, 49,  57,  55,
+    54,  57,  53,  46,  50,  52,  51,  56,  10,  70,  82,  65,  78,  67,  69,
+    124, 49,  57,  57,  51,  124, 50,  51,  49,  56,  55,  56,  46,  54,  50,
+    48,  49,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  50,  124,
+    49,  57,  57,  49,  51,  49,  46,  50,  48,  51,  55,  10,  71,  69,  82,
+    77,  65,  78,  89,  124, 49,  57,  57,  56,  124, 49,  55,  50,  55,  52,
+    49,  46,  49,  48,  50,  52,  10,  71,  69,  82,  77,  65,  78,  89,  124,
+    49,  57,  57,  55,  124, 51,  57,  51,  56,  51,  51,  46,  52,  54,  54,
+    48,  10,  71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,  54,  124,
+    51,  51,  53,  54,  51,  52,  46,  53,  57,  51,  54,  10,  71,  69,  82,
+    77,  65,  78,  89,  124, 49,  57,  57,  53,  124, 51,  55,  56,  49,  48,
+    54,  46,  48,  55,  54,  51,  10,  71,  69,  82,  77,  65,  78,  89,  124,
+    49,  57,  57,  52,  124, 50,  53,  48,  49,  48,  55,  46,  54,  54,  53,
+    51,  10,  71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,  51,  124,
+    51,  50,  55,  49,  53,  52,  46,  57,  51,  54,  53,  10,  71,  69,  82,
+    77,  65,  78,  89,  124, 49,  57,  57,  50,  124, 51,  56,  55,  50,  52,
+    48,  46,  48,  56,  56,  53,  10,  73,  78,  68,  73,  65,  124, 49,  57,
+    57,  56,  124, 51,  52,  55,  53,  52,  56,  46,  55,  54,  48,  52,  10,
+    73,  78,  68,  73,  65,  124, 49,  57,  57,  55,  124, 54,  53,  54,  55,
+    57,  55,  46,  57,  54,  55,  48,  10,  73,  78,  68,  73,  65,  124, 49,
+    57,  57,  54,  124, 53,  50,  50,  55,  53,  57,  46,  51,  53,  50,  57,
+    10,  73,  78,  68,  73,  65,  124, 49,  57,  57,  53,  124, 53,  55,  52,
+    52,  50,  56,  46,  54,  54,  57,  51,  10,  73,  78,  68,  73,  65,  124,
+    49,  57,  57,  52,  124, 55,  52,  49,  57,  56,  51,  46,  55,  56,  52,
+    54,  10,  73,  78,  68,  73,  65,  124, 49,  57,  57,  51,  124, 55,  50,
+    57,  57,  52,  56,  46,  53,  51,  52,  49,  10,  73,  78,  68,  73,  65,
+    124, 49,  57,  57,  50,  124, 54,  54,  49,  48,  54,  49,  46,  49,  52,
+    49,  53,  10,  73,  78,  68,  79,  78,  69,  83,  73,  65,  124, 49,  57,
+    57,  56,  124, 57,  49,  55,  57,  49,  46,  53,  48,  57,  54,  10,  73,
+    78,  68,  79,  78,  69,  83,  73,  65,  124, 49,  57,  57,  55,  124, 49,
+    56,  51,  57,  53,  54,  46,  52,  54,  49,  51,  10,  73,  78,  68,  79,
+    78,  69,  83,  73,  65,  124, 49,  57,  57,  54,  124, 52,  49,  53,  50,
+    51,  52,  46,  55,  56,  52,  56,  10,  73,  78,  68,  79,  78,  69,  83,
+    73,  65,  124, 49,  57,  57,  53,  124, 52,  50,  55,  49,  53,  53,  46,
+    51,  56,  48,  52,  10,  73,  78,  68,  79,  78,  69,  83,  73,  65,  124,
+    49,  57,  57,  52,  124, 50,  56,  54,  50,  55,  49,  46,  50,  56,  55,
+    53,  10,  73,  78,  68,  79,  78,  69,  83,  73,  65,  124, 49,  57,  57,
+    51,  124, 53,  53,  49,  49,  55,  56,  46,  56,  56,  50,  51,  10,  73,
+    78,  68,  79,  78,  69,  83,  73,  65,  124, 49,  57,  57,  50,  124, 50,
+    55,  52,  53,  49,  51,  46,  50,  54,  56,  53,  10,  73,  82,  65,  78,
+    124, 49,  57,  57,  56,  124, 52,  55,  57,  53,  57,  46,  56,  50,  49,
+    57,  10,  73,  82,  65,  78,  124, 49,  57,  57,  55,  124, 49,  56,  52,
+    51,  51,  53,  46,  48,  54,  49,  53,  10,  73,  82,  65,  78,  124, 49,
+    57,  57,  54,  124, 50,  50,  51,  49,  49,  53,  46,  50,  52,  54,  52,
+    10,  73,  82,  65,  78,  124, 49,  57,  57,  53,  124, 49,  50,  53,  51,
+    51,  57,  46,  48,  57,  50,  55,  10,  73,  82,  65,  78,  124, 49,  57,
+    57,  52,  124, 49,  49,  55,  50,  50,  56,  46,  51,  49,  50,  50,  10,
+    73,  82,  65,  78,  124, 49,  57,  57,  51,  124, 50,  48,  56,  48,  51,
+    48,  46,  51,  50,  50,  57,  10,  73,  82,  65,  78,  124, 49,  57,  57,
+    50,  124, 49,  54,  49,  56,  51,  53,  46,  53,  52,  55,  53,  10,  73,
+    82,  65,  81,  124, 49,  57,  57,  56,  124, 49,  54,  49,  55,  57,  55,
+    46,  52,  57,  50,  52,  10,  73,  82,  65,  81,  124, 49,  57,  57,  55,
+    124, 50,  50,  52,  56,  55,  54,  46,  53,  52,  51,  54,  10,  73,  82,
+    65,  81,  124, 49,  57,  57,  54,  124, 49,  52,  53,  50,  55,  55,  46,
+    56,  57,  56,  48,  10,  73,  82,  65,  81,  124, 49,  57,  57,  53,  124,
+    52,  54,  55,  57,  53,  53,  46,  50,  53,  48,  53,  10,  73,  82,  65,
+    81,  124, 49,  57,  57,  52,  124, 57,  55,  52,  53,  53,  46,  50,  57,
+    57,  48,  10,  73,  82,  65,  81,  124, 49,  57,  57,  51,  124, 49,  49,
+    52,  56,  50,  49,  46,  54,  52,  52,  48,  10,  73,  82,  65,  81,  124,
+    49,  57,  57,  50,  124, 50,  49,  51,  51,  48,  55,  46,  49,  53,  55,
+    52,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  56,  124, 51,  48,
+    55,  53,  57,  52,  46,  53,  57,  56,  48,  10,  74,  65,  80,  65,  78,
+    124, 49,  57,  57,  55,  124, 51,  51,  57,  48,  49,  56,  46,  49,  52,
+    56,  56,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  54,  124, 54,
+    52,  57,  53,  55,  56,  46,  51,  51,  54,  56,  10,  74,  65,  80,  65,
+    78,  124, 49,  57,  57,  53,  124, 54,  55,  49,  54,  52,  52,  46,  48,
+    57,  49,  49,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  52,  124,
+    53,  55,  54,  50,  54,  54,  46,  50,  51,  56,  54,  10,  74,  65,  80,
+    65,  78,  124, 49,  57,  57,  51,  124, 53,  49,  52,  49,  57,  48,  46,
+    56,  52,  51,  55,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  50,
+    124, 53,  51,  52,  57,  49,  52,  46,  57,  51,  51,  57,  10,  74,  79,
+    82,  68,  65,  78,  124, 49,  57,  57,  54,  124, 51,  51,  52,  54,  48,
+    46,  50,  52,  52,  55,  10,  74,  79,  82,  68,  65,  78,  124, 49,  57,
+    57,  53,  124, 50,  48,  51,  54,  52,  46,  49,  54,  50,  51,  10,  74,
+    79,  82,  68,  65,  78,  124, 49,  57,  57,  52,  124, 49,  53,  53,  50,
+    56,  46,  54,  48,  56,  56,  10,  74,  79,  82,  68,  65,  78,  124, 49,
+    57,  57,  51,  124, 49,  52,  54,  52,  48,  46,  57,  56,  56,  57,  10,
+    74,  79,  82,  68,  65,  78,  124, 49,  57,  57,  50,  124, 49,  48,  57,
+    48,  52,  46,  50,  57,  51,  49,  10,  75,  69,  78,  89,  65,  124, 49,
+    57,  57,  56,  124, 53,  50,  49,  57,  50,  54,  46,  53,  49,  57,  56,
+    10,  75,  69,  78,  89,  65,  124, 49,  57,  57,  55,  124, 53,  53,  57,
+    54,  51,  50,  46,  51,  52,  48,  56,  10,  75,  69,  78,  89,  65,  124,
+    49,  57,  57,  54,  124, 55,  55,  50,  56,  53,  53,  46,  55,  57,  51,
+    57,  10,  75,  69,  78,  89,  65,  124, 49,  57,  57,  53,  124, 53,  49,
+    54,  52,  53,  50,  46,  53,  48,  54,  55,  10,  75,  69,  78,  89,  65,
+    124, 49,  57,  57,  52,  124, 53,  52,  51,  54,  54,  53,  46,  56,  49,
+    53,  52,  10,  75,  69,  78,  89,  65,  124, 49,  57,  57,  51,  124, 56,
+    54,  54,  57,  50,  52,  46,  56,  55,  53,  52,  10,  75,  69,  78,  89,
+    65,  124, 49,  57,  57,  50,  124, 53,  54,  55,  52,  49,  48,  46,  53,
+    53,  48,  50,  10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,
+    56,  124, 50,  49,  55,  55,  57,  52,  46,  52,  57,  55,  51,  10,  77,
+    79,  82,  79,  67,  67,  79,  124, 49,  57,  57,  55,  124, 52,  51,  57,
+    50,  52,  48,  46,  57,  50,  56,  55,  10,  77,  79,  82,  79,  67,  67,
+    79,  124, 49,  57,  57,  54,  124, 51,  57,  57,  57,  54,  57,  46,  52,
+    54,  56,  48,  10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,
+    53,  124, 50,  53,  56,  49,  51,  49,  46,  57,  51,  57,  56,  10,  77,
+    79,  82,  79,  67,  67,  79,  124, 49,  57,  57,  52,  124, 51,  56,  54,
+    57,  55,  50,  46,  49,  52,  50,  52,  10,  77,  79,  82,  79,  67,  67,
+    79,  124, 49,  57,  57,  51,  124, 49,  52,  53,  52,  54,  56,  46,  48,
+    51,  56,  49,  10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,
+    50,  124, 50,  56,  52,  51,  49,  52,  46,  50,  56,  49,  51,  10,  77,
+    79,  90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  56,  124,
+    53,  49,  56,  54,  57,  51,  46,  50,  50,  51,  56,  10,  77,  79,  90,
+    65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  55,  124, 54,  49,
+    51,  56,  55,  51,  46,  50,  57,  54,  49,  10,  77,  79,  90,  65,  77,
+    66,  73,  81,  85,  69,  124, 49,  57,  57,  54,  124, 57,  51,  54,  55,
+    57,  51,  46,  53,  54,  49,  50,  10,  77,  79,  90,  65,  77,  66,  73,
+    81,  85,  69,  124, 49,  57,  57,  53,  124, 55,  50,  55,  50,  48,  52,
+    46,  55,  55,  49,  56,  10,  77,  79,  90,  65,  77,  66,  73,  81,  85,
+    69,  124, 49,  57,  57,  52,  124, 49,  49,  48,  52,  54,  49,  56,  46,
+    49,  56,  48,  55,  10,  77,  79,  90,  65,  77,  66,  73,  81,  85,  69,
+    124, 49,  57,  57,  51,  124, 56,  57,  51,  50,  54,  54,  46,  48,  53,
+    51,  48,  10,  77,  79,  90,  65,  77,  66,  73,  81,  85,  69,  124, 49,
+    57,  57,  50,  124, 49,  48,  54,  50,  52,  51,  50,  46,  48,  56,  56,
+    52,  10,  80,  69,  82,  85,  124, 49,  57,  57,  56,  124, 50,  56,  55,
+    50,  52,  50,  46,  57,  55,  57,  55,  10,  80,  69,  82,  85,  124, 49,
+    57,  57,  55,  124, 53,  51,  50,  51,  53,  56,  46,  51,  54,  54,  48,
+    10,  80,  69,  82,  85,  124, 49,  57,  57,  54,  124, 51,  57,  56,  52,
+    51,  53,  46,  55,  53,  48,  55,  10,  80,  69,  82,  85,  124, 49,  57,
+    57,  53,  124, 52,  54,  50,  48,  51,  49,  46,  54,  50,  53,  49,  10,
+    80,  69,  82,  85,  124, 49,  57,  57,  52,  124, 51,  48,  52,  50,  51,
+    53,  46,  52,  49,  49,  56,  10,  80,  69,  82,  85,  124, 49,  57,  57,
+    51,  124, 53,  48,  53,  56,  56,  53,  46,  52,  56,  57,  48,  10,  80,
+    69,  82,  85,  124, 49,  57,  57,  50,  124, 51,  56,  50,  50,  57,  48,
+    46,  48,  57,  52,  55,  10,  82,  79,  77,  65,  78,  73,  65,  124, 49,
+    57,  57,  56,  124, 51,  53,  55,  56,  50,  52,  46,  53,  53,  50,  56,
+    10,  82,  79,  77,  65,  78,  73,  65,  124, 49,  57,  57,  55,  124, 53,
+    54,  57,  56,  48,  54,  46,  53,  53,  54,  52,  10,  82,  79,  77,  65,
+    78,  73,  65,  124, 49,  57,  57,  54,  124, 55,  51,  50,  48,  48,  49,
+    46,  53,  53,  54,  56,  10,  82,  79,  77,  65,  78,  73,  65,  124, 49,
+    57,  57,  53,  124, 52,  48,  56,  54,  53,  55,  46,  49,  49,  53,  52,
+    10,  82,  79,  77,  65,  78,  73,  65,  124, 49,  57,  57,  52,  124, 53,
+    52,  48,  55,  48,  50,  46,  53,  52,  54,  51,  10,  82,  79,  77,  65,
+    78,  73,  65,  124, 49,  57,  57,  51,  124, 56,  56,  51,  49,  53,  56,
+    46,  53,  48,  53,  54,  10,  82,  79,  77,  65,  78,  73,  65,  124, 49,
+    57,  57,  50,  124, 53,  48,  53,  52,  56,  56,  46,  57,  53,  48,  49,
+    10,  82,  85,  83,  83,  73,  65,  124, 49,  57,  57,  56,  124, 51,  52,
+    52,  52,  56,  46,  54,  51,  53,  55,  10,  82,  85,  83,  83,  73,  65,
+    124, 49,  57,  57,  55,  124, 51,  49,  52,  57,  55,  50,  46,  48,  52,
+    52,  54,  10,  82,  85,  83,  83,  73,  65,  124, 49,  57,  57,  54,  124,
+    52,  51,  48,  48,  52,  57,  46,  53,  56,  50,  49,  10,  82,  85,  83,
+    83,  73,  65,  124, 49,  57,  57,  53,  124, 51,  54,  48,  53,  51,  56,
+    46,  48,  53,  56,  54,  10,  82,  85,  83,  83,  73,  65,  124, 49,  57,
+    57,  52,  124, 51,  48,  49,  55,  57,  49,  46,  48,  49,  49,  52,  10,
+    82,  85,  83,  83,  73,  65,  124, 49,  57,  57,  51,  124, 51,  48,  56,
+    57,  57,  51,  46,  57,  54,  50,  50,  10,  82,  85,  83,  83,  73,  65,
+    124, 49,  57,  57,  50,  124, 50,  56,  57,  56,  54,  56,  46,  54,  53,
+    54,  52,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,
+    124, 49,  57,  57,  56,  124, 49,  54,  53,  48,  50,  46,  52,  49,  48,
+    48,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124,
+    49,  57,  57,  55,  124, 54,  49,  56,  51,  48,  46,  57,  53,  53,  54,
+    10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,
+    57,  57,  54,  124, 50,  49,  51,  54,  53,  48,  46,  50,  56,  48,  57,
+    10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,
+    57,  57,  53,  124, 54,  50,  54,  54,  56,  46,  55,  50,  53,  48,  10,
+    83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,  57,
+    57,  52,  124, 57,  52,  54,  50,  57,  46,  49,  53,  51,  56,  10,  83,
+    65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,  57,  57,
+    51,  124, 53,  55,  55,  54,  56,  46,  51,  48,  55,  49,  10,  83,  65,
+    85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,  57,  57,  50,
+    124, 54,  54,  53,  50,  48,  46,  49,  48,  57,  51,  10,  85,  78,  73,
+    84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  57,
+    56,  124, 56,  48,  52,  51,  55,  46,  54,  53,  50,  51,  10,  85,  78,
+    73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,
+    57,  55,  124, 50,  53,  50,  53,  48,  57,  46,  55,  51,  53,  49,  10,
+    85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124,
+    49,  57,  57,  54,  124, 50,  51,  49,  49,  53,  50,  46,  56,  53,  56,
+    50,  10,  85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,
+    77,  124, 49,  57,  57,  53,  124, 49,  56,  49,  51,  49,  48,  46,  56,
+    56,  48,  56,  10,  85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,
+    68,  79,  77,  124, 49,  57,  57,  52,  124, 50,  51,  57,  49,  54,  49,
+    46,  50,  48,  54,  49,  10,  85,  78,  73,  84,  69,  68,  32,  75,  73,
+    78,  71,  68,  79,  77,  124, 49,  57,  57,  51,  124, 49,  50,  50,  49,
+    48,  51,  46,  49,  49,  52,  50,  10,  85,  78,  73,  84,  69,  68,  32,
+    75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  57,  50,  124, 54,  48,
+    56,  56,  50,  46,  51,  48,  56,  48,  10,  85,  78,  73,  84,  69,  68,
+    32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  56,  124, 52,  52,
+    48,  51,  52,  55,  46,  54,  54,  53,  56,  10,  85,  78,  73,  84,  69,
+    68,  32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  55,  124, 54,
+    53,  50,  57,  53,  56,  46,  57,  51,  55,  49,  10,  85,  78,  73,  84,
+    69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  54,  124,
+    49,  48,  48,  52,  53,  57,  51,  46,  56,  50,  56,  50,  10,  85,  78,
+    73,  84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,
+    53,  124, 56,  54,  48,  49,  52,  52,  46,  49,  48,  50,  57,  10,  85,
+    78,  73,  84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,  57,
+    57,  52,  124, 56,  48,  55,  55,  57,  55,  46,  52,  56,  55,  55,  10,
+    85,  78,  73,  84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,
+    57,  57,  51,  124, 55,  51,  54,  54,  54,  57,  46,  52,  55,  49,  49,
+    10,  85,  78,  73,  84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124,
+    49,  57,  57,  50,  124, 56,  55,  55,  56,  53,  49,  46,  52,  49,  48,
+    51,  10,  86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,  56,  124,
+    51,  53,  56,  50,  52,  56,  46,  48,  49,  53,  57,  10,  86,  73,  69,
+    84,  78,  65,  77,  124, 49,  57,  57,  55,  124, 51,  57,  52,  56,  49,
+    55,  46,  50,  56,  52,  50,  10,  86,  73,  69,  84,  78,  65,  77,  124,
+    49,  57,  57,  54,  124, 52,  51,  57,  51,  57,  48,  46,  48,  56,  51,
+    54,  10,  86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,  53,  124,
+    52,  49,  56,  54,  50,  54,  46,  54,  51,  50,  53,  10,  86,  73,  69,
+    84,  78,  65,  77,  124, 49,  57,  57,  52,  124, 52,  50,  50,  54,  52,
+    52,  46,  56,  49,  54,  56,  10,  86,  73,  69,  84,  78,  65,  77,  124,
+    49,  57,  57,  51,  124, 51,  48,  57,  48,  54,  51,  46,  52,  48,  50,
+    48,  10,  86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,  50,  124,
+    55,  49,  54,  49,  50,  54,  46,  53,  51,  55,  56,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q10[] = {
+    99,  95,  99,  117, 115, 116, 107, 101, 121, 124, 99,  95,  110, 97,  109,
+    101, 124, 114, 101, 118, 101, 110, 117, 101, 124, 99,  95,  97,  99,  99,
+    116, 98,  97,  108, 124, 110, 95,  110, 97,  109, 101, 124, 99,  95,  97,
+    100, 100, 114, 101, 115, 115, 124, 99,  95,  112, 104, 111, 110, 101, 124,
+    99,  95,  99,  111, 109, 109, 101, 110, 116, 10,  54,  55,  57,  124, 67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  48,  54,
+    55,  57,  124, 51,  55,  56,  50,  49,  49,  46,  51,  50,  53,  50,  124,
+    49,  51,  57,  52,  46,  52,  52,  124, 73,  82,  65,  78,  124, 106, 104,
+    76,  90,  108, 71,  49,  102, 82,  105, 83,  69,  48,  32,  119, 68,  76,
+    79,  67,  103, 117, 86,  66,  57,  54,  100, 72,  54,  97,  53,  124, 50,
+    48,  45,  49,  52,  54,  45,  54,  57,  54,  45,  57,  53,  48,  56,  124,
+    101, 108, 121, 32,  112, 101, 110, 100, 105, 110, 103, 32,  102, 114, 97,
+    121, 115, 32,  98,  111, 111, 115, 116, 32,  99,  97,  114, 101, 102, 117,
+    108, 108, 121, 10,  49,  50,  48,  49,  124, 67,  117, 115, 116, 111, 109,
+    101, 114, 35,  48,  48,  48,  48,  48,  49,  50,  48,  49,  124, 51,  55,
+    52,  51,  51,  49,  46,  53,  51,  52,  48,  124, 53,  49,  54,  53,  46,
+    51,  57,  124, 73,  82,  65,  78,  124, 103, 76,  111, 56,  53,  104, 52,
+    67,  115, 116, 53,  99,  107, 110, 52,  48,  90,  75,  82,  54,  52,  48,
+    51,  75,  106, 87,  50,  54,  89,  67,  87,  65,  70,  90,  115, 113, 32,
+    100, 124, 50,  48,  45,  56,  50,  53,  45,  52,  48,  48,  45,  49,  49,
+    56,  55,  124, 108, 121, 108, 121, 32,  112, 101, 110, 100, 105, 110, 103,
+    32,  112, 97,  99,  107, 97,  103, 101, 115, 46,  32,  115, 112, 101, 99,
+    105, 97,  108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  115, 108,
+    101, 101, 112, 45,  45,  32,  112, 108, 97,  116, 101, 108, 101, 116, 115,
+    32,  117, 115, 101, 32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  97,
+    102, 116, 101, 114, 32,  116, 104, 101, 32,  105, 110, 115, 116, 114, 117,
+    99,  116, 105, 111, 110, 115, 46,  32,  115, 111, 109, 101, 116, 105, 109,
+    101, 115, 32,  101, 118, 101, 110, 32,  105, 100, 10,  52,  50,  50,  124,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    52,  50,  50,  124, 51,  54,  54,  52,  53,  49,  46,  48,  49,  50,  54,
+    124, 45,  50,  55,  50,  46,  49,  52,  124, 73,  78,  68,  79,  78,  69,
+    83,  73,  65,  124, 114, 116, 100, 115, 49,  113, 119, 69,  105, 110, 68,
+    87,  89,  104, 121, 73,  98,  82,  117, 115, 82,  103, 88,  66,  68,  120,
+    71,  74,  114, 97,  80,  44,  67,  44,  83,  32,  122, 68,  119, 65,  124,
+    49,  57,  45,  50,  57,  57,  45,  50,  52,  55,  45,  50,  52,  52,  52,
+    124, 101, 112, 111, 115, 105, 116, 115, 59,  32,  102, 117, 114, 105, 111,
+    117, 115, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  112, 97,  99,
+    107, 97,  103, 101, 115, 32,  97,  99,  99,  111, 114, 100, 105, 10,  51,
+    51,  52,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  51,  51,  52,  124, 51,  54,  48,  51,  55,  48,  46,  55,
+    53,  53,  48,  124, 45,  52,  48,  53,  46,  57,  49,  124, 69,  71,  89,
+    80,  84,  124, 100, 98,  100, 90,  100, 85,  121, 87,  81,  97,  90,  88,
+    55,  68,  111, 67,  79,  124, 49,  52,  45,  57,  52,  55,  45,  50,  57,
+    49,  45,  53,  48,  48,  50,  124, 102, 117, 108, 108, 121, 32,  98,  117,
+    115, 105, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 32,  105, 100,
+    101, 97,  115, 46,  32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,
+    102, 105, 110, 97,  108, 32,  101, 120, 99,  117, 115, 101, 115, 32,  108,
+    111, 115, 101, 32,  115, 108, 121, 108, 121, 32,  99,  97,  114, 101, 102,
+    117, 108, 108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  97,  99,
+    99,  111, 117, 110, 116, 115, 46,  32,  101, 118, 101, 110, 44,  32,  105,
+    114, 111, 110, 105, 99,  32,  112, 108, 97,  116, 101, 108, 101, 116, 115,
+    32,  97,  114, 10,  56,  48,  53,  124, 67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  56,  48,  53,  124, 51,  53,  57,
+    52,  52,  56,  46,  57,  48,  51,  54,  124, 53,  49,  49,  46,  54,  57,
+    124, 73,  82,  65,  78,  124, 119, 111, 103, 117, 86,  116, 79,  106, 119,
+    118, 67,  56,  76,  76,  116, 80,  82,  65,  76,  73,  83,  78,  119, 65,
+    79,  70,  82,  102, 55,  48,  80,  102, 113, 107, 124, 50,  48,  45,  55,
+    51,  50,  45,  57,  56,  57,  45,  53,  54,  53,  51,  124, 98,  117, 115,
+    121, 32,  115, 101, 110, 116, 105, 109, 101, 110, 116, 115, 46,  32,  112,
+    101, 110, 100, 105, 110, 103, 32,  112, 97,  99,  107, 97,  103, 101, 115,
+    32,  104, 97,  103, 103, 108, 101, 32,  97,  109, 111, 110, 103, 32,  116,
+    104, 101, 32,  101, 120, 112, 114, 101, 115, 115, 32,  114, 101, 113, 117,
+    101, 115, 116, 115, 45,  45,  32,  115, 108, 121, 108, 121, 32,  114, 101,
+    103, 117, 108, 97,  114, 32,  101, 120, 99,  117, 115, 101, 115, 32,  97,
+    98,  111, 118, 101, 32,  116, 104, 101, 32,  115, 108, 121, 108, 10,  57,
+    51,  50,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  57,  51,  50,  124, 51,  52,  49,  54,  48,  56,  46,  50,
+    55,  53,  51,  124, 54,  53,  53,  51,  46,  51,  55,  124, 74,  79,  82,
+    68,  65,  78,  124, 107, 100, 82,  113, 66,  48,  101, 122, 104, 107, 85,
+    101, 80,  83,  99,  124, 50,  51,  45,  51,  48,  48,  45,  55,  48,  56,
+    45,  55,  57,  50,  55,  124, 112, 97,  99,  107, 97,  103, 101, 115, 32,
+    98,  111, 111, 115, 116, 32,  115, 108, 121, 108, 121, 32,  97,  108, 111,
+    110, 103, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108,
+    121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  102, 111, 120, 101, 115,
+    46,  32,  101, 118, 10,  56,  53,  51,  124, 67,  117, 115, 116, 111, 109,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  56,  53,  51,  124, 51,  52,
+    49,  50,  51,  54,  46,  54,  50,  52,  54,  124, 45,  52,  52,  52,  46,
+    55,  51,  124, 66,  82,  65,  90,  73,  76,  124, 55,  44,  114, 82,  98,
+    65,  118, 113, 75,  52,  104, 83,  113, 109, 44,  108, 106, 69,  68,  111,
+    108, 121, 106, 82,  112, 56,  77,  117, 52,  52,  120, 83,  84,  71,  124,
+    49,  50,  45,  56,  54,  57,  45,  49,  54,  49,  45,  51,  52,  54,  56,
+    124, 121, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 32,  100, 101,
+    112, 111, 115, 105, 116, 115, 32,  119, 97,  107, 101, 32,  97,  108, 111,
+    110, 103, 115, 105, 100, 101, 32,  111, 102, 10,  56,  55,  50,  124, 67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  48,  56,
+    55,  50,  124, 51,  51,  56,  51,  50,  56,  46,  55,  56,  48,  56,  124,
+    45,  56,  53,  56,  46,  54,  49,  124, 80,  69,  82,  85,  124, 120, 102,
+    98,  84,  73,  101, 49,  112, 103, 87,  113, 48,  106, 113, 100, 109, 55,
+    103, 81,  80,  54,  105, 88,  113, 99,  115, 50,  82,  99,  83,  107, 124,
+    50,  55,  45,  51,  53,  55,  45,  49,  51,  57,  45,  55,  49,  54,  52,
+    124, 32,  100, 101, 116, 101, 99,  116, 46,  32,  112, 97,  99,  107, 97,
+    103, 101, 115, 32,  119, 97,  107, 101, 32,  115, 108, 121, 108, 121, 32,
+    101, 120, 112, 114, 101, 115, 115, 32,  102, 111, 120, 101, 115, 46,  32,
+    101, 118, 101, 110, 32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  114,
+    117, 10,  55,  51,  55,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  55,  51,  55,  124, 51,  51,  56,  49,  56,
+    53,  46,  51,  51,  54,  53,  124, 50,  53,  48,  49,  46,  55,  52,  124,
+    67,  72,  73,  78,  65,  124, 101, 78,  72,  107, 90,  72,  89,  87,  88,
+    73,  112, 102, 56,  67,  116, 44,  70,  50,  65,  101, 106, 32,  66,  119,
+    120, 107, 90,  54,  76,  84,  87,  124, 50,  56,  45,  54,  53,  56,  45,
+    57,  51,  56,  45,  49,  49,  48,  50,  124, 100, 105, 110, 103, 32,  116,
+    111, 32,  116, 104, 101, 32,  102, 105, 110, 97,  108, 32,  112, 108, 97,
+    116, 101, 108, 101, 116, 115, 46,  32,  114, 101, 103, 117, 108, 97,  114,
+    32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,  103, 97,  105, 110,
+    115, 116, 32,  116, 104, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108,
+    121, 32,  102, 105, 110, 97,  108, 32,  105, 100, 101, 97,  115, 32,  104,
+    97,  103, 10,  49,  49,  49,  56,  124, 67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  48,  49,  49,  49,  56,  124, 51,  49,  57,
+    56,  55,  53,  46,  55,  50,  56,  48,  124, 52,  49,  51,  48,  46,  49,
+    56,  124, 73,  82,  65,  81,  124, 98,  106, 75,  48,  110, 101, 119, 109,
+    53,  51,  82,  50,  67,  111, 78,  65,  116, 118, 81,  115, 73,  113, 104,
+    124, 50,  49,  45,  53,  56,  51,  45,  55,  49,  53,  45,  56,  54,  50,
+    55,  124, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  114, 101, 113,
+    117, 101, 115, 116, 115, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101,
+    32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  105, 114, 111, 110, 105,
+    99,  32,  97,  99,  99,  111, 117, 110, 116, 115, 32,  117, 115, 101, 32,
+    115, 108, 121, 108, 121, 32,  98,  111, 108, 100, 32,  112, 97,  99,  107,
+    97,  103, 101, 115, 58,  32,  114, 101, 103, 117, 108, 97,  114, 32,  112,
+    105, 110, 116, 111, 32,  98,  101, 97,  110, 115, 32,  101, 97,  116, 32,
+    99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  115, 112, 101, 10,  50,
+    50,  51,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  50,  50,  51,  124, 51,  49,  57,  53,  54,  52,  46,  50,
+    55,  53,  48,  124, 55,  52,  55,  54,  46,  50,  48,  124, 83,  65,  85,
+    68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 77,  121, 81,  120, 85,
+    99,  71,  48,  80,  32,  81,  67,  101, 116, 109, 71,  48,  48,  71,  108,
+    70,  124, 51,  48,  45,  49,  57,  51,  45,  54,  52,  51,  45,  49,  53,
+    49,  55,  124, 97,  108, 44,  32,  114, 101, 103, 117, 108, 97,  114, 32,
+    114, 101, 113, 117, 101, 115, 116, 115, 32,  114, 117, 110, 32,  102, 117,
+    114, 105, 111, 117, 115, 108, 121, 32,  98,  108, 105, 116, 104, 101, 108,
+    121, 32,  115, 105, 108, 101, 110, 116, 32,  112, 97,  99,  107, 97,  103,
+    101, 115, 46,  32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  105, 114,
+    111, 110, 105, 99,  32,  97,  99,  99,  111, 117, 110, 116, 115, 32,  97,
+    99,  114, 111, 115, 115, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111,
+    117, 115, 10,  56,  48,  56,  124, 67,  117, 115, 116, 111, 109, 101, 114,
+    35,  48,  48,  48,  48,  48,  48,  56,  48,  56,  124, 51,  49,  52,  55,
+    55,  52,  46,  54,  49,  54,  55,  124, 53,  53,  54,  49,  46,  57,  51,
+    124, 82,  79,  77,  65,  78,  73,  65,  124, 57,  89,  52,  71,  56,  104,
+    111, 107, 121, 68,  81,  74,  79,  108, 99,  67,  85,  101, 52,  79,  121,
+    112, 88,  32,  115, 109, 70,  108, 77,  69,  54,  100, 32,  75,  114, 124,
+    50,  57,  45,  53,  51,  49,  45,  51,  49,  57,  45,  55,  55,  50,  54,
+    124, 32,  117, 110, 117, 115, 117, 97,  108, 32,  100, 101, 112, 111, 115,
+    105, 116, 115, 46,  32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,
+    101, 118, 101, 110, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,
+    103, 97,  105, 110, 115, 116, 32,  116, 104, 101, 32,  102, 117, 114, 105,
+    111, 117, 115, 108, 121, 32,  101, 118, 101, 110, 32,  97,  99,  10,  52,
+    55,  56,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  52,  55,  56,  124, 50,  57,  57,  54,  53,  49,  46,  56,
+    48,  50,  54,  124, 45,  50,  49,  48,  46,  52,  48,  124, 65,  82,  71,
+    69,  78,  84,  73,  78,  65,  124, 80,  70,  116, 65,  87,  87,  83,  110,
+    105, 71,  52,  51,  121, 87,  65,  103, 116, 106, 70,  80,  78,  48,  68,
+    114, 104, 121, 77,  67,  68,  73,  109, 124, 49,  49,  45,  54,  53,  53,
+    45,  50,  57,  49,  45,  50,  54,  57,  52,  124, 111, 32,  116, 104, 101,
+    32,  102, 111, 120, 101, 115, 46,  32,  105, 114, 111, 110, 105, 99,  32,
+    114, 101, 113, 117, 101, 115, 116, 115, 32,  115, 108, 101, 101, 112, 46,
+    32,  99,  10,  49,  52,  52,  49,  124, 67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  48,  49,  52,  52,  49,  124, 50,  57,  52,
+    55,  48,  53,  46,  51,  57,  51,  53,  124, 57,  52,  54,  53,  46,  49,
+    53,  124, 85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,
+    77,  124, 121, 44,  50,  50,  49,  81,  87,  85,  118, 48,  67,  118, 103,
+    67,  86,  107, 82,  119, 115, 114, 79,  85,  112, 82,  115, 104, 87,  112,
+    99,  106, 75,  107, 114, 72,  117, 124, 51,  51,  45,  54,  56,  49,  45,
+    51,  51,  52,  45,  52,  52,  57,  57,  124, 110, 116, 115, 32,  104, 97,
+    103, 103, 108, 101, 32,  113, 117, 105, 101, 116, 108, 121, 32,  113, 117,
+    105, 99,  107, 108, 121, 32,  102, 105, 110, 97,  108, 32,  97,  99,  99,
+    111, 117, 110, 116, 115, 46,  32,  115, 108, 121, 108, 121, 32,  114, 101,
+    103, 117, 108, 97,  114, 32,  97,  99,  99,  111, 117, 110, 116, 115, 32,
+    97,  109, 111, 110, 103, 32,  116, 104, 101, 32,  115, 108, 10,  49,  52,
+    55,  56,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  48,  49,  52,  55,  56,  124, 50,  57,  52,  52,  51,  49,  46,  57,
+    49,  55,  56,  124, 57,  55,  48,  49,  46,  53,  52,  124, 71,  69,  82,
+    77,  65,  78,  89,  124, 118, 84,  106, 110, 119, 105, 110, 110, 66,  57,
+    89,  101, 65,  49,  86,  120, 75,  89,  111, 81,  69,  76,  97,  90,  74,
+    109, 44,  72,  87,  124, 49,  55,  45,  52,  50,  48,  45,  52,  56,  52,
+    45,  53,  57,  53,  57,  124, 110, 103, 32,  116, 104, 101, 32,  102, 117,
+    114, 105, 111, 117, 115, 108, 121, 32,  98,  111, 108, 100, 32,  102, 111,
+    120, 101, 115, 46,  32,  101, 118, 101, 110, 32,  110, 111, 116, 111, 114,
+    110, 105, 115, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101, 32,  117,
+    110, 117, 115, 117, 97,  108, 32,  10,  50,  49,  49,  124, 67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  48,  50,  49,  49,
+    124, 50,  56,  55,  57,  48,  53,  46,  54,  51,  54,  56,  124, 52,  49,
+    57,  56,  46,  55,  50,  124, 74,  79,  82,  68,  65,  78,  124, 55,  57,
+    74,  70,  53,  99,  115, 115, 87,  108, 66,  51,  77,  69,  124, 50,  51,
+    45,  57,  54,  53,  45,  51,  51,  53,  45,  57,  52,  55,  49,  124, 102,
+    117, 114, 105, 111, 117, 115, 108, 121, 32,  114, 101, 103, 117, 108, 97,
+    114, 32,  102, 111, 120, 101, 115, 32,  98,  111, 111, 115, 116, 32,  102,
+    108, 117, 102, 102, 105, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108,
+    32,  105, 100, 101, 97,  115, 46,  32,  99,  97,  114, 101, 102, 117, 108,
+    108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  100, 101, 112, 101,
+    110, 100, 101, 110, 99,  105, 101, 115, 32,  97,  114, 101, 46,  32,  115,
+    108, 121, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  10,  49,  57,
+    55,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  49,  57,  55,  124, 50,  56,  51,  49,  57,  48,  46,  52,  56,
+    48,  55,  124, 57,  56,  54,  48,  46,  50,  50,  124, 65,  82,  71,  69,
+    78,  84,  73,  78,  65,  124, 55,  77,  53,  65,  122, 32,  77,  66,  100,
+    120, 52,  69,  121, 49,  88,  84,  110, 124, 49,  49,  45,  49,  48,  55,
+    45,  51,  49,  50,  45,  54,  53,  56,  53,  124, 105, 99,  107, 108, 121,
+    32,  102, 105, 110, 97,  108, 32,  97,  99,  99,  111, 117, 110, 116, 115,
+    32,  99,  97,  106, 111, 108, 101, 46,  32,  102, 117, 114, 105, 111, 117,
+    115, 108, 121, 32,  114, 101, 10,  49,  48,  51,  48,  124, 67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  49,  48,  51,  48,
+    124, 50,  56,  50,  53,  53,  55,  46,  51,  53,  54,  54,  124, 54,  51,
+    53,  57,  46,  50,  55,  124, 73,  78,  68,  73,  65,  124, 52,  66,  121,
+    90,  112, 74,  112, 86,  74,  82,  68,  124, 49,  56,  45,  55,  53,  57,
+    45,  56,  55,  55,  45,  49,  56,  55,  48,  124, 100, 105, 110, 103, 32,
+    116, 111, 32,  116, 104, 101, 32,  115, 108, 121, 108, 121, 32,  117, 110,
+    117, 115, 117, 97,  108, 32,  97,  99,  99,  111, 117, 110, 116, 115, 46,
+    32,  101, 118, 101, 110, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,
+    97,  109, 111, 110, 103, 32,  116, 104, 101, 32,  101, 118, 101, 110, 108,
+    121, 10,  49,  48,  52,  57,  124, 67,  117, 115, 116, 111, 109, 101, 114,
+    35,  48,  48,  48,  48,  48,  49,  48,  52,  57,  124, 50,  56,  49,  49,
+    51,  52,  46,  49,  49,  49,  55,  124, 56,  55,  52,  55,  46,  57,  57,
+    124, 73,  78,  68,  79,  78,  69,  83,  73,  65,  124, 81,  49,  90,  99,
+    79,  109, 74,  106, 81,  105, 50,  86,  75,  101, 73,  107, 124, 49,  57,
+    45,  52,  57,  57,  45,  50,  53,  56,  45,  50,  56,  53,  49,  124, 117,
+    114, 105, 111, 117, 115, 108, 121, 32,  97,  99,  99,  111, 114, 100, 105,
+    110, 103, 32,  116, 111, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111,
+    117, 115, 108, 121, 32,  115, 105, 108, 101, 110, 116, 32,  112, 97,  99,
+    107, 97,  103, 101, 115, 10,  49,  48,  57,  52,  124, 67,  117, 115, 116,
+    111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  49,  48,  57,  52,  124,
+    50,  55,  52,  56,  55,  55,  46,  52,  52,  52,  48,  124, 50,  53,  52,
+    52,  46,  52,  57,  124, 66,  82,  65,  90,  73,  76,  124, 100, 108, 115,
+    44,  77,  78,  78,  55,  69,  98,  70,  51,  71,  89,  114, 89,  51,  101,
+    82,  119, 83,  101, 79,  66,  90,  89,  100, 53,  111, 44,  99,  103, 124,
+    49,  50,  45,  50,  51,  52,  45,  55,  50,  49,  45,  57,  56,  55,  49,
+    124, 116, 101, 115, 32,  115, 101, 114, 118, 101, 32,  98,  108, 105, 116,
+    104, 101, 108, 121, 32,  113, 117, 105, 99,  107, 108, 121, 32,  112, 101,
+    110, 100, 105, 110, 103, 32,  102, 111, 120, 101, 115, 46,  32,  101, 120,
+    112, 114, 101, 115, 115, 44,  32,  113, 117, 105, 99,  107, 32,  97,  99,
+    99,  111, 117, 110, 116, 115, 10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q11[] = {
+    112, 115, 95,  112, 97,  114, 116, 107, 101, 121, 124, 118, 97,  108, 117,
+    101, 10,  49,  51,  55,  54,  124, 49,  51,  50,  55,  49,  50,  52,  57,
+    46,  56,  57,  10,  55,  56,  56,  124, 57,  52,  57,  56,  54,  52,  56,
+    46,  48,  54,  10,  49,  48,  55,  49,  124, 57,  51,  56,  56,  50,  54,
+    52,  46,  52,  48,  10,  49,  55,  54,  56,  124, 57,  50,  48,  55,  49,
+    57,  57,  46,  55,  53,  10,  49,  49,  54,  56,  124, 56,  56,  56,  49,
+    57,  48,  56,  46,  57,  54,  10,  49,  48,  56,  52,  124, 56,  55,  48,
+    57,  52,  57,  52,  46,  49,  54,  10,  49,  52,  49,  53,  124, 56,  52,
+    55,  49,  52,  56,  57,  46,  53,  54,  10,  49,  51,  51,  56,  124, 56,
+    50,  57,  51,  56,  52,  49,  46,  49,  50,  10,  49,  50,  52,  124, 56,
+    50,  48,  51,  50,  48,  57,  46,  51,  48,  10,  49,  50,  51,  50,  124,
+    56,  49,  49,  49,  54,  54,  51,  46,  51,  52,  10,  49,  54,  52,  51,
+    124, 55,  57,  55,  53,  56,  54,  50,  46,  55,  53,  10,  49,  57,  53,
+    50,  124, 55,  57,  51,  54,  57,  52,  55,  46,  54,  49,  10,  49,  57,
+    52,  52,  124, 55,  56,  56,  48,  48,  49,  56,  46,  54,  48,  10,  49,
+    56,  56,  52,  124, 55,  53,  49,  51,  52,  50,  50,  46,  56,  52,  10,
+    57,  52,  50,  124, 55,  53,  49,  49,  48,  49,  56,  46,  55,  54,  10,
+    54,  55,  48,  124, 55,  50,  57,  57,  57,  53,  54,  46,  56,  48,  10,
+    49,  53,  51,  50,  124, 55,  50,  50,  50,  51,  52,  55,  46,  50,  48,
+    10,  49,  48,  53,  50,  124, 55,  49,  53,  56,  53,  56,  54,  46,  48,
+    48,  10,  52,  53,  53,  124, 55,  48,  54,  52,  50,  56,  53,  46,  56,
+    52,  10,  49,  49,  55,  54,  124, 55,  48,  54,  48,  54,  55,  48,  46,
+    56,  57,  10,  49,  52,  51,  124, 55,  48,  51,  55,  54,  52,  56,  46,
+    54,  52,  10,  49,  54,  53,  51,  124, 54,  57,  52,  57,  53,  51,  51,
+    46,  55,  48,  10,  49,  49,  52,  48,  124, 54,  57,  50,  57,  52,  54,
+    52,  46,  48,  56,  10,  49,  48,  55,  54,  124, 54,  56,  55,  55,  52,
+    55,  50,  46,  57,  54,  10,  50,  48,  48,  48,  124, 54,  55,  50,  48,
+    48,  48,  57,  46,  51,  56,  10,  51,  52,  56,  124, 54,  54,  56,  49,
+    51,  48,  55,  46,  51,  52,  10,  56,  49,  48,  124, 54,  53,  55,  54,
+    54,  52,  48,  46,  57,  53,  10,  57,  52,  51,  124, 54,  52,  53,  56,
+    54,  52,  49,  46,  55,  48,  10,  55,  50,  48,  124, 54,  51,  57,  49,
+    51,  51,  48,  46,  50,  55,  10,  49,  55,  52,  56,  124, 54,  51,  52,
+    49,  53,  51,  48,  46,  52,  48,  10,  49,  50,  52,  49,  124, 54,  51,
+    48,  52,  57,  52,  52,  46,  54,  54,  10,  49,  51,  56,  52,  124, 54,
+    50,  55,  57,  50,  54,  49,  46,  49,  50,  10,  49,  55,  56,  52,  124,
+    54,  50,  52,  55,  56,  54,  51,  46,  50,  53,  10,  57,  56,  52,  124,
+    54,  49,  51,  54,  57,  50,  55,  46,  48,  48,  10,  52,  52,  53,  124,
+    54,  49,  50,  55,  55,  56,  52,  46,  50,  56,  10,  49,  57,  55,  54,
+    124, 54,  48,  55,  57,  50,  51,  55,  46,  48,  56,  10,  49,  54,  48,
+    57,  124, 54,  48,  50,  50,  55,  50,  48,  46,  56,  48,  10,  49,  53,
+    54,  51,  124, 53,  57,  55,  56,  49,  57,  53,  46,  48,  56,  10,  52,
+    53,  50,  124, 53,  56,  51,  56,  48,  53,  50,  46,  48,  48,  10,  50,
+    50,  50,  124, 53,  55,  51,  55,  49,  54,  50,  46,  50,  52,  10,  49,
+    54,  50,  57,  124, 53,  55,  48,  51,  49,  49,  55,  46,  49,  50,  10,
+    49,  52,  53,  52,  124, 53,  54,  57,  52,  56,  48,  52,  46,  49,  56,
+    10,  49,  48,  56,  50,  124, 53,  54,  56,  49,  57,  56,  49,  46,  50,
+    53,  10,  54,  57,  49,  124, 53,  54,  51,  51,  53,  56,  57,  46,  55,
+    50,  10,  49,  52,  55,  52,  124, 53,  54,  49,  52,  54,  55,  51,  46,
+    54,  52,  10,  49,  57,  48,  48,  124, 53,  53,  57,  49,  57,  48,  53,
+    46,  51,  54,  10,  50,  54,  50,  124, 53,  53,  53,  51,  50,  56,  53,
+    46,  51,  50,  10,  49,  56,  55,  54,  124, 53,  53,  49,  55,  57,  57,
+    55,  46,  53,  57,  10,  49,  48,  50,  55,  124, 53,  52,  57,  48,  57,
+    49,  54,  46,  48,  48,  10,  49,  56,  51,  51,  124, 53,  52,  53,  49,
+    52,  57,  53,  46,  48,  48,  10,  53,  49,  51,  124, 53,  51,  55,  52,
+    52,  50,  54,  46,  50,  50,  10,  55,  53,  50,  124, 53,  51,  53,  56,
+    57,  49,  57,  46,  55,  48,  10,  49,  51,  54,  55,  124, 53,  51,  53,
+    50,  55,  55,  51,  46,  50,  53,  10,  53,  52,  51,  124, 53,  49,  56,
+    57,  49,  48,  49,  46,  54,  56,  10,  49,  49,  52,  52,  124, 53,  49,
+    55,  52,  51,  56,  56,  46,  53,  54,  10,  52,  48,  51,  124, 53,  49,
+    50,  54,  49,  49,  56,  46,  49,  53,  10,  49,  52,  48,  54,  124, 53,
+    49,  50,  49,  56,  56,  54,  46,  52,  52,  10,  51,  50,  48,  124, 53,
+    48,  55,  50,  48,  57,  57,  46,  55,  54,  10,  49,  57,  52,  48,  124,
+    53,  48,  54,  57,  49,  55,  56,  46,  52,  48,  10,  49,  53,  48,  51,
+    124, 53,  48,  53,  48,  56,  57,  53,  46,  53,  48,  10,  49,  52,  51,
+    55,  124, 53,  48,  51,  57,  53,  57,  48,  46,  54,  48,  10,  55,  52,
+    51,  124, 53,  48,  51,  57,  50,  55,  49,  46,  52,  50,  10,  56,  50,
+    124, 52,  57,  57,  53,  57,  51,  57,  46,  48,  48,  10,  57,  49,  54,
+    124, 52,  57,  57,  52,  55,  51,  48,  46,  49,  48,  10,  55,  51,  50,
+    124, 52,  57,  51,  50,  56,  48,  57,  46,  56,  50,  10,  51,  53,  54,
+    124, 52,  56,  55,  57,  56,  54,  48,  46,  48,  57,  10,  49,  53,  57,
+    50,  124, 52,  56,  51,  49,  50,  52,  50,  46,  54,  48,  10,  49,  48,
+    52,  51,  124, 52,  56,  50,  53,  57,  50,  49,  46,  51,  49,  10,  49,
+    51,  50,  124, 52,  55,  56,  49,  57,  56,  52,  46,  49,  52,  10,  49,
+    48,  48,  54,  124, 52,  55,  51,  51,  57,  53,  52,  46,  54,  52,  10,
+    52,  57,  55,  124, 52,  55,  49,  49,  49,  55,  51,  46,  54,  48,  10,
+    49,  48,  48,  56,  124, 52,  53,  54,  53,  53,  56,  56,  46,  56,  53,
+    10,  49,  51,  55,  48,  124, 52,  53,  54,  51,  56,  51,  48,  46,  49,
+    48,  10,  50,  49,  54,  124, 52,  53,  54,  49,  49,  52,  51,  46,  56,
+    48,  10,  51,  52,  124, 52,  53,  48,  49,  57,  56,  50,  46,  55,  49,
+    10,  49,  57,  48,  56,  124, 52,  52,  49,  55,  57,  51,  49,  46,  56,
+    48,  10,  57,  56,  50,  124, 52,  51,  57,  49,  52,  57,  53,  46,  52,
+    54,  10,  49,  54,  53,  50,  124, 52,  51,  53,  56,  55,  57,  51,  46,
+    49,  52,  10,  54,  49,  52,  124, 52,  51,  53,  54,  54,  53,  55,  46,
+    52,  53,  10,  49,  53,  53,  50,  124, 52,  51,  53,  53,  53,  52,  49,
+    46,  55,  48,  10,  51,  53,  57,  124, 52,  51,  53,  51,  53,  54,  54,
+    46,  56,  55,  10,  49,  49,  48,  52,  124, 52,  51,  52,  55,  53,  49,
+    53,  46,  57,  48,  10,  49,  57,  56,  124, 52,  51,  49,  53,  48,  52,
+    57,  46,  48,  48,  10,  57,  57,  56,  124, 52,  49,  54,  55,  55,  56,
+    52,  46,  56,  56,  10,  49,  53,  52,  51,  124, 52,  49,  53,  57,  53,
+    54,  56,  46,  49,  54,  10,  49,  51,  48,  56,  124, 52,  49,  53,  51,
+    49,  50,  52,  46,  57,  53,  10,  52,  55,  52,  124, 52,  49,  50,  51,
+    56,  49,  57,  46,  50,  48,  10,  49,  51,  57,  52,  124, 52,  49,  50,
+    50,  55,  50,  57,  46,  51,  51,  10,  50,  55,  49,  124, 52,  48,  57,
+    53,  49,  56,  48,  46,  57,  54,  10,  57,  48,  56,  124, 52,  48,  56,
+    56,  56,  53,  54,  46,  50,  48,  10,  49,  49,  51,  53,  124, 52,  48,
+    52,  53,  48,  49,  52,  46,  49,  51,  10,  49,  54,  51,  50,  124, 52,
+    48,  49,  48,  55,  57,  52,  46,  57,  48,  10,  49,  51,  54,  50,  124,
+    51,  57,  56,  50,  48,  54,  48,  46,  49,  54,  10,  49,  53,  56,  124,
+    51,  57,  52,  49,  56,  56,  49,  46,  54,  53,  10,  49,  56,  53,  50,
+    124, 51,  57,  50,  51,  48,  51,  53,  46,  48,  50,  10,  49,  53,  53,
+    54,  124, 51,  56,  57,  54,  55,  48,  57,  46,  53,  52,  10,  53,  56,
+    52,  124, 51,  56,  52,  51,  56,  52,  56,  46,  51,  48,  10,  56,  56,
+    53,  124, 51,  56,  50,  54,  48,  50,  49,  46,  49,  54,  10,  51,  55,
+    54,  124, 51,  55,  56,  49,  50,  48,  49,  46,  57,  54,  10,  55,  49,
+    50,  124, 51,  55,  52,  57,  54,  57,  54,  46,  56,  48,  10,  50,  124,
+    51,  55,  52,  51,  50,  52,  49,  46,  52,  51,  10,  54,  55,  54,  124,
+    51,  55,  51,  53,  55,  49,  53,  46,  50,  48,  10,  49,  56,  51,  50,
+    124, 51,  55,  48,  57,  48,  48,  56,  46,  54,  48,  10,  49,  57,  53,
+    53,  124, 51,  55,  48,  50,  55,  57,  52,  46,  55,  48,  10,  54,  56,
+    124, 51,  54,  57,  48,  55,  48,  50,  46,  52,  49,  10,  49,  52,  51,
+    53,  124, 51,  54,  53,  57,  49,  49,  52,  46,  49,  48,  10,  49,  52,
+    52,  51,  124, 51,  54,  53,  54,  55,  54,  50,  46,  56,  52,  10,  49,
+    50,  55,  56,  124, 51,  54,  53,  51,  49,  48,  48,  46,  54,  54,  10,
+    49,  57,  50,  48,  124, 51,  54,  52,  55,  56,  57,  50,  46,  53,  52,
+    10,  52,  50,  51,  124, 51,  54,  48,  50,  48,  51,  49,  46,  56,  48,
+    10,  56,  49,  56,  124, 51,  53,  56,  57,  48,  52,  55,  46,  54,  48,
+    10,  55,  55,  57,  124, 51,  53,  53,  57,  53,  57,  55,  46,  53,  51,
+    10,  52,  56,  53,  124, 51,  53,  53,  56,  53,  49,  49,  46,  52,  52,
+    10,  53,  53,  50,  124, 51,  53,  53,  53,  52,  55,  48,  46,  49,  48,
+    10,  49,  50,  54,  57,  124, 51,  53,  49,  48,  52,  50,  55,  46,  54,
+    53,  10,  49,  54,  48,  50,  124, 51,  52,  57,  50,  49,  49,  55,  46,
+    55,  48,  10,  52,  50,  54,  124, 51,  52,  56,  54,  56,  56,  56,  46,
+    48,  50,  10,  49,  52,  53,  50,  124, 51,  52,  56,  48,  56,  50,  53,
+    46,  54,  48,  10,  55,  53,  54,  124, 51,  52,  54,  57,  51,  55,  51,
+    46,  55,  48,  10,  56,  51,  50,  124, 51,  52,  52,  55,  55,  52,  54,
+    46,  52,  54,  10,  49,  52,  57,  51,  124, 51,  52,  52,  54,  56,  54,
+    55,  46,  52,  48,  10,  49,  54,  53,  48,  124, 51,  52,  49,  55,  55,
+    53,  50,  46,  53,  56,  10,  50,  48,  53,  124, 51,  52,  48,  51,  48,
+    52,  54,  46,  50,  53,  10,  57,  51,  124, 51,  51,  54,  49,  52,  50,
+    53,  46,  56,  57,  10,  55,  54,  124, 51,  51,  52,  50,  48,  56,  49,
+    46,  56,  50,  10,  49,  55,  53,  57,  124, 51,  51,  48,  51,  48,  53,
+    48,  46,  52,  48,  10,  56,  56,  54,  124, 51,  51,  48,  50,  49,  56,
+    48,  46,  55,  48,  10,  49,  53,  52,  52,  124, 51,  50,  56,  56,  53,
+    55,  51,  46,  49,  54,  10,  49,  57,  51,  50,  124, 51,  50,  55,  48,
+    57,  48,  48,  46,  52,  48,  10,  52,  56,  57,  124, 51,  50,  53,  51,
+    51,  54,  56,  46,  51,  48,  10,  53,  57,  52,  124, 51,  49,  55,  55,
+    52,  48,  56,  46,  53,  55,  10,  49,  56,  52,  124, 51,  49,  55,  55,
+    49,  54,  50,  46,  48,  53,  10,  57,  53,  48,  124, 51,  49,  54,  53,
+    50,  49,  51,  46,  48,  49,  10,  49,  49,  50,  52,  124, 51,  49,  52,
+    51,  50,  55,  57,  46,  51,  54,  10,  49,  48,  54,  124, 51,  48,  57,
+    57,  48,  50,  49,  46,  57,  56,  10,  49,  57,  54,  52,  124, 51,  48,
+    49,  54,  53,  53,  51,  46,  49,  48,  10,  51,  56,  52,  124, 50,  57,
+    54,  52,  50,  54,  50,  46,  55,  55,  10,  57,  55,  52,  124, 50,  57,
+    53,  57,  52,  57,  55,  46,  49,  48,  10,  57,  54,  52,  124, 50,  57,
+    53,  49,  51,  50,  57,  46,  52,  53,  10,  49,  57,  56,  52,  124, 50,
+    57,  48,  55,  51,  52,  53,  46,  51,  54,  10,  50,  48,  48,  124, 50,
+    56,  57,  53,  54,  56,  56,  46,  51,  50,  10,  54,  56,  51,  124, 50,
+    56,  50,  57,  52,  55,  54,  46,  57,  53,  10,  49,  53,  54,  52,  124,
+    50,  56,  49,  54,  53,  48,  54,  46,  53,  54,  10,  53,  52,  54,  124,
+    50,  55,  56,  56,  48,  53,  57,  46,  54,  52,  10,  53,  48,  50,  124,
+    50,  55,  56,  48,  56,  50,  56,  46,  54,  52,  10,  51,  57,  54,  124,
+    50,  55,  55,  56,  52,  50,  49,  46,  51,  57,  10,  50,  48,  51,  124,
+    50,  55,  54,  49,  52,  51,  57,  46,  56,  56,  10,  56,  54,  54,  124,
+    50,  55,  53,  51,  48,  51,  49,  46,  50,  48,  10,  49,  55,  52,  51,
+    124, 50,  55,  52,  51,  56,  56,  57,  46,  52,  57,  10,  49,  48,  52,
+    49,  124, 50,  55,  51,  56,  48,  56,  51,  46,  57,  50,  10,  49,  52,
+    51,  50,  124, 50,  55,  49,  51,  52,  49,  50,  46,  49,  54,  10,  52,
+    51,  124, 50,  53,  56,  55,  51,  53,  57,  46,  53,  56,  10,  57,  52,
+    49,  124, 50,  53,  56,  55,  48,  57,  49,  46,  53,  50,  10,  49,  56,
+    57,  48,  124, 50,  53,  53,  56,  55,  51,  57,  46,  54,  57,  10,  49,
+    56,  54,  54,  124, 50,  53,  52,  53,  56,  51,  56,  46,  52,  48,  10,
+    55,  52,  55,  124, 50,  53,  49,  49,  55,  52,  53,  46,  51,  50,  10,
+    55,  55,  54,  124, 50,  53,  48,  54,  52,  56,  57,  46,  56,  57,  10,
+    53,  53,  52,  124, 50,  53,  48,  53,  52,  49,  55,  46,  50,  53,  10,
+    49,  50,  49,  48,  124, 50,  52,  57,  48,  56,  50,  48,  46,  57,  50,
+    10,  49,  50,  51,  57,  124, 50,  52,  48,  53,  50,  48,  54,  46,  51,
+    48,  10,  52,  52,  51,  124, 50,  51,  56,  50,  49,  53,  48,  46,  48,
+    53,  10,  49,  54,  54,  49,  124, 50,  51,  55,  48,  53,  55,  52,  46,
+    49,  54,  10,  49,  48,  55,  57,  124, 50,  51,  54,  51,  53,  48,  53,
+    46,  49,  49,  10,  49,  51,  50,  57,  124, 50,  51,  48,  53,  56,  55,
+    48,  46,  52,  50,  10,  49,  54,  57,  49,  124, 50,  50,  54,  49,  49,
+    53,  57,  46,  57,  50,  10,  49,  50,  52,  55,  124, 50,  50,  51,  57,
+    53,  53,  51,  46,  50,  56,  10,  49,  55,  53,  50,  124, 50,  50,  51,
+    48,  48,  53,  53,  46,  55,  54,  10,  49,  53,  48,  124, 50,  50,  49,
+    55,  48,  52,  51,  46,  53,  57,  10,  49,  56,  49,  52,  124, 50,  50,
+    49,  51,  54,  51,  53,  46,  50,  48,  10,  50,  56,  57,  124, 50,  49,
+    56,  55,  49,  54,  48,  46,  52,  53,  10,  49,  52,  48,  48,  124, 50,
+    49,  51,  57,  56,  52,  53,  46,  49,  48,  10,  49,  56,  57,  56,  124,
+    50,  49,  51,  48,  49,  49,  52,  46,  57,  54,  10,  49,  56,  48,  57,
+    124, 50,  49,  50,  50,  55,  53,  56,  46,  55,  50,  10,  56,  56,  52,
+    124, 50,  49,  48,  55,  52,  55,  57,  46,  53,  54,  10,  49,  48,  51,
+    56,  124, 50,  48,  57,  54,  56,  54,  56,  46,  57,  55,  10,  49,  51,
+    49,  56,  124, 50,  48,  53,  49,  51,  48,  50,  46,  52,  52,  10,  53,
+    50,  52,  124, 50,  48,  51,  53,  50,  54,  50,  46,  50,  50,  10,  52,
+    49,  52,  124, 50,  48,  50,  57,  54,  57,  50,  46,  52,  53,  10,  50,
+    57,  56,  124, 50,  48,  50,  54,  57,  56,  49,  46,  55,  52,  10,  49,
+    57,  57,  54,  124, 50,  48,  50,  48,  57,  53,  51,  46,  53,  52,  10,
+    49,  55,  52,  50,  124, 50,  48,  49,  57,  49,  57,  48,  46,  56,  48,
+    10,  49,  54,  50,  48,  124, 50,  48,  49,  48,  49,  49,  50,  46,  48,
+    48,  10,  56,  55,  55,  124, 49,  57,  53,  54,  52,  50,  57,  46,  49,
+    56,  10,  49,  51,  51,  50,  124, 49,  57,  49,  57,  48,  50,  57,  46,
+    53,  54,  10,  49,  53,  51,  54,  124, 49,  56,  53,  57,  51,  49,  56,
+    46,  49,  53,  10,  49,  49,  49,  54,  124, 49,  56,  53,  50,  53,  56,
+    56,  46,  50,  56,  10,  52,  52,  55,  124, 49,  56,  49,  55,  57,  53,
+    49,  46,  51,  50,  10,  49,  54,  55,  54,  124, 49,  56,  48,  50,  51,
+    48,  54,  46,  48,  56,  10,  49,  57,  49,  49,  124, 49,  55,  55,  57,
+    54,  52,  54,  46,  52,  52,  10,  49,  52,  53,  57,  124, 49,  55,  54,
+    55,  54,  48,  50,  46,  51,  48,  10,  53,  55,  54,  124, 49,  55,  54,
+    49,  56,  51,  56,  46,  55,  53,  10,  49,  50,  55,  51,  124, 49,  55,
+    53,  52,  50,  51,  53,  46,  48,  49,  10,  53,  56,  51,  124, 49,  55,
+    50,  53,  54,  52,  57,  46,  57,  50,  10,  53,  51,  50,  124, 49,  54,
+    56,  50,  51,  49,  49,  46,  52,  56,  10,  49,  55,  51,  50,  124, 49,
+    54,  53,  50,  56,  51,  49,  46,  50,  48,  10,  49,  53,  55,  50,  124,
+    49,  54,  53,  48,  57,  53,  51,  46,  53,  50,  10,  49,  56,  56,  57,
+    124, 49,  54,  51,  56,  52,  52,  51,  46,  55,  50,  10,  52,  55,  54,
+    124, 49,  54,  51,  49,  49,  53,  52,  46,  48,  54,  10,  49,  50,  50,
+    49,  124, 49,  54,  50,  57,  56,  56,  51,  46,  52,  54,  10,  49,  55,
+    57,  50,  124, 49,  54,  48,  54,  51,  52,  54,  46,  49,  48,  10,  50,
+    52,  51,  124, 49,  54,  48,  51,  50,  51,  53,  46,  49,  54,  10,  51,
+    50,  56,  124, 49,  53,  54,  57,  56,  50,  54,  46,  55,  50,  10,  49,
+    57,  57,  57,  124, 49,  53,  53,  51,  55,  48,  54,  46,  48,  48,  10,
+    49,  54,  49,  49,  124, 49,  53,  50,  57,  56,  53,  55,  46,  48,  49,
+    10,  54,  52,  51,  124, 49,  53,  49,  50,  56,  51,  56,  46,  56,  48,
+    10,  49,  50,  55,  54,  124, 49,  52,  54,  55,  53,  54,  55,  46,  50,
+    56,  10,  49,  56,  50,  51,  124, 49,  52,  54,  50,  50,  57,  51,  46,
+    48,  48,  10,  49,  124, 49,  52,  53,  54,  48,  53,  48,  46,  57,  54,
+    10,  50,  55,  124, 49,  52,  50,  53,  56,  51,  50,  46,  52,  48,  10,
+    54,  51,  50,  124, 49,  52,  48,  56,  48,  56,  55,  46,  50,  54,  10,
+    49,  49,  56,  52,  124, 49,  52,  48,  54,  49,  48,  49,  46,  55,  56,
+    10,  50,  53,  50,  124, 49,  51,  55,  57,  49,  56,  54,  46,  51,  53,
+    10,  51,  57,  50,  124, 49,  51,  53,  52,  56,  49,  51,  46,  49,  56,
+    10,  49,  50,  49,  53,  124, 49,  51,  52,  52,  51,  56,  51,  46,  50,
+    48,  10,  50,  54,  124, 49,  51,  51,  55,  48,  48,  50,  46,  56,  57,
+    10,  56,  52,  124, 49,  51,  51,  52,  49,  52,  54,  46,  55,  49,  10,
+    55,  56,  52,  124, 49,  51,  50,  55,  50,  57,  55,  46,  48,  49,  10,
+    49,  56,  48,  51,  124, 49,  51,  50,  55,  48,  52,  53,  46,  48,  54,
+    10,  51,  53,  50,  124, 49,  51,  50,  54,  49,  48,  50,  46,  51,  52,
+    10,  49,  54,  53,  124, 49,  50,  56,  57,  48,  55,  53,  46,  55,  54,
+    10,  49,  55,  54,  124, 49,  50,  56,  53,  56,  54,  54,  46,  50,  48,
+    10,  49,  51,  49,  52,  124, 49,  50,  52,  52,  49,  55,  51,  46,  50,
+    54,  10,  49,  55,  48,  49,  124, 49,  50,  51,  57,  48,  57,  53,  46,
+    52,  52,  10,  56,  52,  52,  124, 49,  50,  50,  53,  54,  57,  54,  46,
+    48,  53,  10,  49,  57,  56,  56,  124, 49,  50,  49,  54,  55,  57,  56,
+    46,  51,  51,  10,  49,  56,  52,  55,  124, 49,  50,  48,  50,  48,  49,
+    50,  46,  49,  51,  10,  49,  55,  48,  54,  124, 49,  49,  56,  52,  49,
+    50,  53,  46,  49,  48,  10,  55,  52,  52,  124, 49,  49,  56,  50,  56,
+    50,  48,  46,  56,  48,  10,  50,  51,  48,  124, 49,  49,  54,  53,  57,
+    51,  50,  46,  51,  48,  10,  52,  49,  56,  124, 49,  48,  55,  56,  51,
+    50,  49,  46,  52,  52,  10,  49,  55,  52,  124, 49,  48,  54,  48,  53,
+    56,  52,  46,  56,  48,  10,  49,  48,  55,  51,  124, 49,  48,  50,  56,
+    52,  52,  57,  46,  56,  57,  10,  49,  55,  50,  54,  124, 49,  48,  49,
+    56,  54,  55,  51,  46,  48,  52,  10,  49,  50,  48,  54,  124, 49,  48,
+    48,  50,  51,  49,  57,  46,  52,  57,  10,  49,  51,  52,  51,  124, 57,
+    57,  56,  49,  48,  53,  46,  55,  54,  10,  57,  53,  50,  124, 57,  57,
+    55,  54,  56,  52,  46,  50,  52,  10,  52,  56,  52,  124, 57,  57,  49,
+    53,  51,  48,  46,  57,  51,  10,  57,  51,  50,  124, 57,  56,  48,  54,
+    50,  48,  46,  54,  56,  10,  56,  52,  51,  124, 57,  55,  56,  56,  54,
+    50,  46,  57,  50,  10,  49,  56,  52,  49,  124, 57,  54,  50,  49,  51,
+    49,  46,  56,  54,  10,  52,  57,  52,  124, 57,  53,  55,  53,  55,  53,
+    46,  51,  52,  10,  54,  53,  57,  124, 57,  53,  52,  50,  57,  49,  46,
+    48,  53,  10,  50,  53,  49,  124, 57,  51,  57,  55,  54,  52,  46,  55,
+    48,  10,  49,  52,  49,  51,  124, 57,  51,  54,  57,  53,  49,  46,  57,
+    52,  10,  53,  55,  50,  124, 57,  48,  54,  49,  49,  49,  46,  57,  57,
+    10,  51,  50,  124, 56,  57,  52,  52,  56,  52,  46,  48,  57,  10,  57,
+    124, 56,  57,  51,  57,  48,  53,  46,  57,  50,  10,  49,  52,  57,  56,
+    124, 56,  57,  48,  56,  56,  55,  46,  56,  53,  10,  49,  55,  57,  48,
+    124, 56,  55,  56,  57,  50,  51,  46,  54,  52,  10,  49,  54,  55,  48,
+    124, 56,  53,  52,  48,  52,  54,  46,  52,  51,  10,  56,  55,  54,  124,
+    56,  52,  50,  50,  52,  53,  46,  54,  55,  10,  49,  55,  53,  56,  124,
+    56,  52,  49,  50,  55,  53,  46,  52,  50,  10,  57,  51,  48,  124, 56,
+    51,  50,  57,  54,  51,  46,  54,  56,  10,  50,  56,  52,  124, 56,  50,
+    54,  54,  52,  50,  46,  54,  48,  10,  49,  55,  49,  48,  124, 56,  49,
+    49,  53,  48,  52,  46,  51,  56,  10,  49,  48,  52,  55,  124, 55,  57,
+    49,  50,  49,  52,  46,  52,  53,  10,  54,  53,  51,  124, 55,  56,  56,
+    57,  55,  52,  46,  50,  49,  10,  51,  49,  53,  124, 55,  55,  48,  53,
+    50,  54,  46,  48,  53,  10,  49,  55,  51,  52,  124, 55,  54,  51,  53,
+    54,  57,  46,  52,  48,  10,  49,  48,  49,  55,  124, 55,  49,  53,  51,
+    48,  50,  46,  55,  50,  10,  49,  51,  48,  53,  124, 55,  49,  51,  51,
+    53,  49,  46,  52,  51,  10,  55,  55,  124, 54,  56,  56,  56,  54,  53,
+    46,  56,  50,  10,  49,  53,  49,  50,  124, 54,  56,  50,  52,  51,  52,
+    46,  49,  53,  10,  50,  55,  54,  124, 54,  56,  48,  50,  51,  57,  46,
+    48,  52,  10,  49,  50,  56,  52,  124, 54,  55,  49,  50,  50,  53,  46,
+    57,  52,  10,  49,  51,  53,  54,  124, 54,  54,  53,  55,  49,  54,  46,
+    56,  51,  10,  56,  48,  48,  124, 54,  54,  51,  52,  49,  52,  46,  54,
+    53,  10,  49,  49,  55,  124, 54,  51,  57,  54,  53,  48,  46,  56,  56,
+    10,  54,  53,  50,  124, 54,  51,  53,  54,  50,  57,  46,  50,  56,  10,
+    53,  55,  124, 54,  51,  48,  57,  56,  55,  46,  52,  52,  10,  49,  52,
+    50,  54,  124, 54,  50,  56,  50,  52,  49,  46,  50,  53,  10,  49,  49,
+    57,  54,  124, 54,  50,  50,  52,  50,  55,  46,  49,  54,  10,  53,  49,
+    124, 54,  50,  50,  50,  52,  57,  46,  53,  52,  10,  49,  56,  52,  54,
+    124, 54,  50,  49,  48,  54,  56,  46,  56,  48,  10,  54,  48,  49,  124,
+    54,  49,  53,  57,  52,  50,  46,  54,  48,  10,  54,  52,  53,  124, 54,
+    48,  55,  57,  56,  53,  46,  56,  52,  10,  54,  56,  52,  124, 53,  55,
+    49,  52,  57,  48,  46,  55,  48,  10,  52,  54,  53,  124, 53,  55,  48,
+    51,  51,  55,  46,  52,  48,  10,  53,  54,  50,  124, 53,  54,  55,  54,
+    53,  49,  46,  50,  52,  10,  51,  56,  55,  124, 53,  53,  54,  54,  51,
+    52,  46,  55,  54,  10,  49,  49,  53,  50,  124, 53,  53,  53,  57,  56,
+    57,  46,  50,  56,  10,  49,  50,  48,  50,  124, 53,  53,  51,  56,  49,
+    56,  46,  49,  56,  10,  49,  49,  49,  50,  124, 53,  53,  50,  54,  53,
+    56,  46,  54,  56,  10,  51,  48,  52,  124, 53,  51,  53,  56,  54,  56,
+    46,  49,  54,  10,  51,  54,  56,  124, 53,  50,  54,  57,  57,  53,  46,
+    56,  52,  10,  49,  56,  48,  48,  124, 53,  50,  54,  55,  49,  49,  46,
+    49,  49,  10,  49,  49,  52,  56,  124, 53,  49,  53,  55,  48,  50,  46,
+    49,  54,  10,  50,  50,  53,  124, 53,  49,  51,  53,  56,  55,  46,  53,
+    55,  10,  51,  50,  52,  124, 53,  48,  48,  57,  53,  52,  46,  53,  56,
+    10,  53,  56,  54,  124, 52,  57,  57,  52,  55,  53,  46,  53,  56,  10,
+    49,  53,  55,  54,  124, 52,  57,  52,  52,  48,  49,  46,  48,  53,  10,
+    49,  52,  56,  52,  124, 52,  54,  50,  51,  57,  54,  46,  50,  55,  10,
+    49,  50,  54,  124, 52,  54,  49,  50,  54,  51,  46,  55,  52,  10,  49,
+    49,  51,  50,  124, 52,  53,  53,  52,  57,  50,  46,  50,  52,  10,  54,
+    50,  50,  124, 52,  52,  57,  54,  56,  53,  46,  54,  48,  10,  49,  49,
+    54,  48,  124, 52,  52,  56,  49,  56,  51,  46,  48,  54,  10,  49,  51,
+    53,  50,  124, 52,  51,  57,  57,  54,  55,  46,  48,  52,  10,  49,  56,
+    124, 52,  50,  54,  52,  52,  50,  46,  48,  56,  10,  55,  124, 52,  49,
+    52,  53,  53,  56,  46,  50,  48,  10,  56,  51,  51,  124, 51,  57,  56,
+    53,  52,  48,  46,  56,  55,  10,  49,  54,  57,  52,  124, 51,  55,  54,
+    52,  52,  51,  46,  57,  56,  10,  54,  53,  48,  124, 51,  55,  48,  57,
+    48,  48,  46,  57,  57,  10,  49,  53,  48,  52,  124, 51,  55,  48,  56,
+    49,  53,  46,  57,  48,  10,  52,  51,  50,  124, 51,  55,  48,  53,  50,
+    56,  46,  53,  50,  10,  54,  49,  50,  124, 51,  54,  55,  56,  57,  52,
+    46,  53,  48,  10,  53,  52,  50,  124, 51,  54,  55,  54,  53,  51,  46,
+    54,  54,  10,  52,  53,  54,  124, 51,  54,  48,  57,  49,  49,  46,  51,
+    50,  10,  53,  50,  124, 51,  53,  56,  55,  57,  50,  46,  51,  54,  10,
+    49,  51,  52,  54,  124, 51,  53,  48,  54,  51,  55,  46,  52,  51,  10,
+    53,  57,  124, 51,  52,  50,  50,  50,  49,  46,  52,  56,  10,  49,  49,
+    48,  55,  124, 51,  52,  49,  56,  48,  53,  46,  50,  48,  10,  49,  49,
+    55,  49,  124, 51,  51,  52,  57,  51,  56,  46,  48,  52,  10,  49,  48,
+    54,  50,  124, 51,  50,  54,  52,  52,  53,  46,  57,  48,  10,  53,  57,
+    50,  124, 51,  49,  51,  48,  56,  49,  46,  55,  53,  10,  49,  55,  53,
+    48,  124, 51,  49,  50,  50,  50,  57,  46,  51,  51,  10,  49,  56,  52,
+    51,  124, 51,  48,  57,  52,  53,  54,  46,  57,  53,  10,  49,  56,  48,
+    124, 51,  48,  56,  53,  51,  57,  46,  56,  52,  10,  56,  57,  57,  124,
+    51,  48,  49,  57,  56,  57,  46,  53,  48,  10,  49,  49,  56,  48,  124,
+    50,  57,  51,  52,  53,  50,  46,  53,  48,  10,  53,  50,  50,  124, 50,
+    57,  49,  54,  48,  49,  46,  55,  53,  10,  50,  52,  57,  124, 50,  56,
+    50,  53,  50,  48,  46,  51,  50,  10,  49,  53,  56,  52,  124, 50,  55,
+    56,  53,  53,  57,  46,  51,  56,  10,  49,  52,  48,  52,  124, 50,  55,
+    54,  48,  53,  55,  46,  57,  48,  10,  49,  50,  54,  53,  124, 50,  55,
+    49,  48,  55,  57,  46,  55,  54,  10,  49,  53,  52,  124, 50,  54,  57,
+    54,  52,  49,  46,  52,  50,  10,  49,  50,  57,  53,  124, 50,  54,  53,
+    53,  54,  54,  46,  53,  54,  10,  49,  53,  50,  51,  124, 50,  54,  51,
+    49,  53,  56,  46,  57,  48,  10,  49,  54,  51,  53,  124, 50,  53,  52,
+    56,  51,  52,  46,  53,  54,  10,  49,  55,  55,  54,  124, 50,  51,  52,
+    49,  56,  49,  46,  50,  48,  10,  49,  48,  57,  55,  124, 50,  51,  52,
+    49,  49,  51,  46,  53,  53,  10,  49,  50,  53,  56,  124, 50,  51,  51,
+    53,  48,  48,  46,  54,  49,  10,  54,  50,  49,  124, 50,  51,  51,  52,
+    51,  49,  46,  51,  48,  10,  49,  53,  50,  124, 50,  50,  57,  55,  56,
+    49,  46,  54,  48,  10,  50,  55,  56,  124, 50,  49,  54,  51,  55,  50,
+    46,  56,  52,  10,  50,  51,  50,  124, 50,  49,  49,  56,  55,  57,  46,
+    57,  50,  10,  49,  54,  56,  52,  124, 50,  48,  49,  51,  56,  54,  46,
+    50,  50,  10,  49,  50,  52,  51,  124, 49,  57,  57,  53,  56,  55,  46,
+    53,  52,  10,  57,  55,  54,  124, 49,  57,  55,  52,  51,  50,  46,  49,
+    48,  10,  56,  49,  57,  124, 49,  57,  49,  52,  55,  53,  46,  57,  48,
+    10,  49,  57,  52,  51,  124, 49,  57,  49,  50,  52,  55,  46,  55,  54,
+    10,  56,  53,  51,  124, 49,  56,  57,  50,  51,  50,  46,  54,  52,  10,
+    52,  48,  48,  124, 49,  56,  56,  57,  52,  49,  46,  50,  48,  10,  54,
+    51,  57,  124, 49,  56,  54,  53,  51,  51,  46,  50,  56,  10,  56,  53,
+    49,  124, 49,  56,  52,  49,  48,  51,  46,  49,  54,  10,  57,  48,  57,
+    124, 49,  55,  53,  48,  57,  57,  46,  48,  48,  10,  50,  53,  55,  124,
+    49,  54,  57,  48,  51,  51,  46,  52,  52,  10,  49,  52,  52,  53,  124,
+    49,  54,  52,  56,  56,  56,  46,  54,  56,  10,  49,  56,  53,  53,  124,
+    49,  54,  52,  54,  49,  52,  46,  56,  49,  10,  49,  50,  53,  50,  124,
+    49,  53,  56,  54,  56,  48,  46,  57,  48,  10,  49,  48,  49,  52,  124,
+    49,  53,  54,  52,  54,  53,  46,  56,  50,  10,  49,  55,  49,  55,  124,
+    49,  52,  56,  51,  50,  53,  46,  55,  53,  10,  49,  48,  51,  50,  124,
+    49,  52,  54,  52,  48,  56,  46,  52,  48,  10,  55,  56,  48,  124, 49,
+    51,  54,  50,  57,  54,  46,  50,  54,  10,  57,  49,  56,  124, 49,  51,
+    53,  50,  54,  56,  46,  51,  50,  10,  54,  57,  48,  124, 49,  51,  51,
+    56,  50,  54,  46,  56,  56,  10,  55,  49,  49,  124, 49,  49,  51,  50,
+    54,  56,  46,  56,  52,  10,  51,  51,  50,  124, 49,  49,  50,  49,  56,
+    49,  46,  51,  48,  10,  49,  53,  57,  54,  124, 49,  49,  48,  53,  54,
+    53,  46,  48,  48,  10,  50,  57,  53,  124, 57,  55,  54,  48,  52,  46,
+    50,  53,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q12[] = {
+    108, 95,  115, 104, 105, 112, 109, 111, 100, 101, 124, 104, 105,
+    103, 104, 95,  108, 105, 110, 101, 95,  99,  111, 117, 110, 116,
+    124, 108, 111, 119, 95,  108, 105, 110, 101, 95,  99,  111, 117,
+    110, 116, 10,  77,  65,  73,  76,  124, 54,  52,  124, 56,  54,
+    10,  83,  72,  73,  80,  124, 54,  49,  124, 57,  54,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q13[] = {
+    99,  95,  99,  111, 117, 110, 116, 124, 99,  117, 115, 116, 100, 105, 115,
+    116, 10,  48,  124, 53,  48,  48,  10,  49,  49,  124, 54,  56,  10,  49,
+    48,  124, 54,  52,  10,  49,  50,  124, 54,  50,  10,  57,  124, 54,  50,
+    10,  56,  124, 54,  49,  10,  49,  52,  124, 53,  52,  10,  49,  51,  124,
+    53,  50,  10,  55,  124, 52,  57,  10,  50,  48,  124, 52,  56,  10,  50,
+    49,  124, 52,  55,  10,  49,  54,  124, 52,  54,  10,  49,  53,  124, 52,
+    53,  10,  49,  57,  124, 52,  52,  10,  49,  55,  124, 52,  49,  10,  49,
+    56,  124, 51,  56,  10,  50,  50,  124, 51,  51,  10,  54,  124, 51,  51,
+    10,  50,  52,  124, 51,  48,  10,  50,  51,  124, 50,  55,  10,  50,  53,
+    124, 50,  49,  10,  50,  55,  124, 49,  55,  10,  50,  54,  124, 49,  53,
+    10,  53,  124, 49,  52,  10,  50,  56,  124, 54,  10,  52,  124, 54,  10,
+    51,  50,  124, 53,  10,  50,  57,  124, 53,  10,  51,  48,  124, 50,  10,
+    51,  124, 50,  10,  51,  49,  124, 49,  10,  50,  124, 49,  10,  49,  124,
+    49,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q14[] = {
+    112, 114, 111, 109, 111, 95, 114, 101, 118, 101, 110, 117,
+    101, 10,  49,  53,  46,  52, 56,  54,  53,  52,  53,  56,
+    49,  50,  50,  56,  52,  48, 55,  49,  53,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q15[] = {
+    115, 95,  115, 117, 112, 112, 107, 101, 121, 124, 115, 95,  110, 97,
+    109, 101, 124, 115, 95,  97,  100, 100, 114, 101, 115, 115, 124, 115,
+    95,  112, 104, 111, 110, 101, 124, 116, 111, 116, 97,  108, 95,  114,
+    101, 118, 101, 110, 117, 101, 10,  50,  49,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  48,  50,  49,
+    124, 84,  90,  111, 81,  119, 78,  70,  70,  79,  32,  105, 44,  98,
+    97,  88,  112, 98,  112, 105, 110, 48,  50,  44,  104, 118, 117, 104,
+    69,  44,  71,  82,  86,  73,  75,  109, 32,  124, 49,  50,  45,  50,
+    53,  51,  45,  53,  57,  48,  45,  53,  56,  49,  54,  124, 49,  49,
+    54,  49,  48,  57,  57,  46,  52,  54,  51,  54,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q16[] = {
+    112, 95,  98,  114, 97,  110, 100, 124, 112, 95,  116, 121, 112, 101, 124,
+    112, 95,  115, 105, 122, 101, 124, 115, 117, 112, 112, 108, 105, 101, 114,
+    95,  99,  110, 116, 10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q17[] =
+    {97, 118, 103, 95, 121, 101, 97, 114, 108, 121, 10, 10, 0};
+const uint8_t TPCH_ANSWERS_SF0_01_q18[] = {
+    99,  95,  110, 97,  109, 101, 124, 99,  95,  99,  117, 115, 116, 107, 101,
+    121, 124, 111, 95,  111, 114, 100, 101, 114, 107, 101, 121, 124, 111, 95,
+    111, 114, 100, 101, 114, 100, 97,  116, 101, 124, 111, 95,  116, 111, 116,
+    97,  108, 112, 114, 105, 99,  101, 124, 115, 117, 109, 10,  67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  48,  54,  54,  55,
+    124, 54,  54,  55,  124, 50,  57,  49,  53,  56,  124, 49,  57,  57,  53,
+    45,  49,  48,  45,  50,  49,  124, 52,  51,  57,  54,  56,  55,  46,  50,
+    51,  124, 51,  48,  53,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  49,  55,  56,  124, 49,  55,  56,  124, 54,
+    56,  56,  50,  124, 49,  57,  57,  55,  45,  48,  52,  45,  48,  57,  124,
+    52,  50,  50,  51,  53,  57,  46,  54,  53,  124, 51,  48,  51,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q19[] = {114, 101, 118, 101, 110, 117, 101,
+                                           10,  50,  50,  57,  50,  51,  46,
+                                           48,  50,  56,  48,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q20[] = {
+    115, 95,  110, 97, 109, 101, 124, 115, 95,  97,  100, 100, 114, 101,
+    115, 115, 10,  83, 117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48, 48,  49,  51,  124, 107, 103, 84,  90,  106, 98,
+    116, 52,  67,  65, 97,  52,  99,  51,  83,  108, 105, 114, 108, 66,
+    76,  113, 73,  76, 52,  49,  89,  98,  67,  106, 10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q21[] = {
+    115, 95, 110, 97,  109, 101, 124, 110, 117, 109, 119, 97, 105,
+    116, 10, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48, 48,
+    48,  48, 48,  48,  48,  55,  52,  124, 57,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_01_q22[] = {
+    99,  110, 116, 114, 121, 99,  111, 100, 101, 124, 110, 117, 109, 99, 117,
+    115, 116, 124, 116, 111, 116, 97,  99,  99,  116, 98,  97,  108, 10, 49,
+    51,  124, 49,  48,  124, 55,  53,  51,  53,  57,  46,  50,  57,  10, 49,
+    55,  124, 56,  124, 54,  50,  50,  56,  56,  46,  57,  56,  10,  49, 56,
+    124, 49,  52,  124, 49,  49,  49,  48,  55,  50,  46,  52,  53,  10, 50,
+    51,  124, 53,  124, 52,  48,  52,  53,  56,  46,  56,  54,  10,  50, 57,
+    124, 49,  49,  124, 56,  56,  55,  50,  50,  46,  56,  53,  10,  51, 48,
+    124, 49,  55,  124, 49,  50,  50,  49,  56,  57,  46,  51,  51,  10, 51,
+    49,  124, 56,  124, 54,  54,  51,  49,  51,  46,  49,  54,  10,  0};
+const char* TPCH_ANSWERS_SF0_01[] = {
+    (const char*)TPCH_ANSWERS_SF0_01_q01, (const char*)TPCH_ANSWERS_SF0_01_q02,
+    (const char*)TPCH_ANSWERS_SF0_01_q03, (const char*)TPCH_ANSWERS_SF0_01_q04,
+    (const char*)TPCH_ANSWERS_SF0_01_q05, (const char*)TPCH_ANSWERS_SF0_01_q06,
+    (const char*)TPCH_ANSWERS_SF0_01_q07, (const char*)TPCH_ANSWERS_SF0_01_q08,
+    (const char*)TPCH_ANSWERS_SF0_01_q09, (const char*)TPCH_ANSWERS_SF0_01_q10,
+    (const char*)TPCH_ANSWERS_SF0_01_q11, (const char*)TPCH_ANSWERS_SF0_01_q12,
+    (const char*)TPCH_ANSWERS_SF0_01_q13, (const char*)TPCH_ANSWERS_SF0_01_q14,
+    (const char*)TPCH_ANSWERS_SF0_01_q15, (const char*)TPCH_ANSWERS_SF0_01_q16,
+    (const char*)TPCH_ANSWERS_SF0_01_q17, (const char*)TPCH_ANSWERS_SF0_01_q18,
+    (const char*)TPCH_ANSWERS_SF0_01_q19, (const char*)TPCH_ANSWERS_SF0_01_q20,
+    (const char*)TPCH_ANSWERS_SF0_01_q21, (const char*)TPCH_ANSWERS_SF0_01_q22};
+const uint8_t TPCH_ANSWERS_SF0_1_q01[] = {
+    108, 95,  114, 101, 116, 117, 114, 110, 102, 108, 97,  103, 124, 108, 95,
+    108, 105, 110, 101, 115, 116, 97,  116, 117, 115, 124, 115, 117, 109, 95,
+    113, 116, 121, 124, 115, 117, 109, 95,  98,  97,  115, 101, 95,  112, 114,
+    105, 99,  101, 124, 115, 117, 109, 95,  100, 105, 115, 99,  95,  112, 114,
+    105, 99,  101, 124, 115, 117, 109, 95,  99,  104, 97,  114, 103, 101, 124,
+    97,  118, 103, 95,  113, 116, 121, 124, 97,  118, 103, 95,  112, 114, 105,
+    99,  101, 124, 97,  118, 103, 95,  100, 105, 115, 99,  124, 99,  111, 117,
+    110, 116, 95,  111, 114, 100, 101, 114, 10,  65,  124, 70,  124, 51,  55,
+    55,  52,  50,  48,  48,  124, 53,  51,  50,  48,  55,  53,  51,  56,  56,
+    48,  46,  54,  57,  124, 53,  48,  53,  52,  48,  57,  54,  50,  54,  54,
+    46,  54,  56,  50,  56,  124, 53,  50,  53,  54,  55,  53,  49,  51,  51,
+    49,  46,  52,  52,  57,  50,  51,  52,  124, 50,  53,  46,  53,  51,  55,
+    53,  56,  55,  49,  49,  54,  56,  53,  52,  57,  57,  55,  48,  124, 51,
+    54,  48,  48,  50,  46,  49,  50,  51,  56,  50,  57,  48,  49,  52,  49,
+    52,  50,  124, 48,  46,  48,  53,  48,  49,  52,  52,  53,  57,  55,  48,
+    54,  51,  52,  48,  48,  55,  55,  49,  51,  54,  124, 49,  52,  55,  55,
+    57,  48,  10,  78,  124, 70,  124, 57,  53,  50,  53,  55,  124, 49,  51,
+    51,  55,  51,  55,  55,  57,  53,  46,  56,  52,  124, 49,  50,  55,  49,
+    51,  50,  51,  55,  50,  46,  54,  53,  49,  50,  124, 49,  51,  50,  50,
+    56,  54,  50,  57,  49,  46,  50,  50,  57,  52,  52,  53,  124, 50,  53,
+    46,  51,  48,  48,  54,  54,  52,  48,  49,  48,  54,  50,  52,  49,  55,
+    48,  48,  124, 51,  53,  53,  50,  49,  46,  51,  50,  54,  57,  49,  54,
+    51,  51,  52,  54,  54,  49,  124, 48,  46,  48,  52,  57,  51,  57,  52,
+    52,  50,  50,  51,  49,  48,  55,  53,  54,  57,  55,  50,  49,  49,  124,
+    51,  55,  54,  53,  10,  78,  124, 79,  124, 55,  52,  53,  57,  50,  57,
+    55,  124, 49,  48,  53,  49,  50,  50,  55,  48,  48,  48,  56,  46,  57,
+    48,  124, 57,  57,  56,  54,  50,  51,  56,  51,  51,  56,  46,  51,  56,
+    52,  55,  124, 49,  48,  51,  56,  53,  53,  55,  56,  51,  55,  54,  46,
+    53,  56,  53,  52,  54,  55,  124, 50,  53,  46,  53,  52,  53,  53,  51,
+    55,  54,  55,  49,  50,  51,  50,  56,  55,  54,  55,  124, 51,  54,  48,
+    48,  48,  46,  57,  50,  52,  54,  56,  56,  48,  49,  51,  54,  57,  57,
+    124, 48,  46,  48,  53,  48,  48,  57,  53,  57,  53,  56,  57,  48,  52,
+    49,  48,  57,  53,  56,  57,  48,  52,  124, 50,  57,  50,  48,  48,  48,
+    10,  82,  124, 70,  124, 51,  55,  56,  53,  53,  50,  51,  124, 53,  51,
+    51,  55,  57,  53,  48,  53,  50,  54,  46,  52,  55,  124, 53,  48,  55,
+    49,  56,  49,  56,  53,  51,  50,  46,  57,  52,  50,  48,  124, 53,  50,
+    55,  52,  52,  48,  53,  53,  48,  51,  46,  48,  52,  57,  51,  54,  55,
+    124, 50,  53,  46,  53,  50,  53,  57,  52,  51,  56,  53,  55,  52,  50,
+    53,  49,  48,  49,  55,  124, 51,  53,  57,  57,  52,  46,  48,  50,  57,
+    50,  49,  52,  48,  51,  48,  57,  50,  52,  124, 48,  46,  48,  52,  57,
+    57,  56,  57,  50,  55,  56,  53,  54,  49,  56,  52,  51,  56,  49,  55,
+    54,  52,  124, 49,  52,  56,  51,  48,  49,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q02[] = {
+    115, 95,  97,  99,  99,  116, 98,  97,  108, 124, 115, 95,  110, 97,  109,
+    101, 124, 110, 95,  110, 97,  109, 101, 124, 112, 95,  112, 97,  114, 116,
+    107, 101, 121, 124, 112, 95,  109, 102, 103, 114, 124, 115, 95,  97,  100,
+    100, 114, 101, 115, 115, 124, 115, 95,  112, 104, 111, 110, 101, 124, 115,
+    95,  99,  111, 109, 109, 101, 110, 116, 10,  57,  56,  50,  56,  46,  50,
+    49,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  54,  52,  55,  124, 85,  78,  73,  84,  69,  68,  32,  75,  73,
+    78,  71,  68,  79,  77,  124, 49,  51,  49,  50,  48,  124, 77,  97,  110,
+    117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 118, 86,  54,
+    84,  101, 113, 49,  69,  118, 76,  108, 82,  124, 51,  51,  45,  50,  53,
+    56,  45,  50,  48,  50,  45,  52,  55,  56,  50,  124, 115, 32,  116, 104,
+    101, 32,  115, 108, 121, 108, 121, 32,  101, 118, 101, 110, 32,  105, 100,
+    101, 97,  115, 32,  112, 111, 97,  99,  104, 32,  102, 108, 117, 102, 102,
+    105, 108, 121, 32,  10,  57,  53,  48,  56,  46,  51,  55,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  48,  55,
+    48,  124, 70,  82,  65,  78,  67,  69,  124, 51,  53,  54,  51,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 106,
+    100, 52,  100, 106, 90,  118, 48,  99,  99,  53,  75,  100, 110, 65,  48,
+    113, 57,  111, 79,  113, 118, 99,  101, 97,  80,  85,  98,  78,  108, 111,
+    79,  87,  124, 49,  54,  45,  56,  50,  49,  45,  54,  48,  56,  45,  49,
+    49,  54,  54,  124, 101, 115, 116, 115, 32,  115, 108, 101, 101, 112, 32,
+    113, 117, 105, 99,  107, 108, 121, 32,  101, 120, 112, 114, 101, 115, 115,
+    32,  105, 100, 101, 97,  115, 46,  32,  105, 114, 111, 110, 105, 99,  32,
+    105, 100, 101, 97,  115, 32,  104, 97,  103, 103, 108, 101, 32,  97,  98,
+    111, 117, 116, 32,  116, 104, 101, 32,  102, 105, 110, 97,  108, 32,  84,
+    10,  57,  53,  48,  56,  46,  51,  55,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  48,  55,  48,  124, 70,  82,
+    65,  78,  67,  69,  124, 49,  55,  50,  54,  56,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 106, 100, 52,  100,
+    106, 90,  118, 48,  99,  99,  53,  75,  100, 110, 65,  48,  113, 57,  111,
+    79,  113, 118, 99,  101, 97,  80,  85,  98,  78,  108, 111, 79,  87,  124,
+    49,  54,  45,  56,  50,  49,  45,  54,  48,  56,  45,  49,  49,  54,  54,
+    124, 101, 115, 116, 115, 32,  115, 108, 101, 101, 112, 32,  113, 117, 105,
+    99,  107, 108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  105, 100,
+    101, 97,  115, 46,  32,  105, 114, 111, 110, 105, 99,  32,  105, 100, 101,
+    97,  115, 32,  104, 97,  103, 103, 108, 101, 32,  97,  98,  111, 117, 116,
+    32,  116, 104, 101, 32,  102, 105, 110, 97,  108, 32,  84,  10,  57,  52,
+    53,  51,  46,  48,  49,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  56,  48,  50,  124, 82,  79,  77,  65,  78,
+    73,  65,  124, 49,  48,  48,  50,  49,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  53,  124, 49,  85,  106, 50,  51,  81,
+    87,  120, 81,  106, 106, 55,  69,  121, 101, 113, 72,  87,  113, 71,  87,
+    84,  98,  78,  124, 50,  57,  45,  51,  52,  50,  45,  56,  56,  50,  45,
+    54,  52,  54,  51,  124, 103, 117, 108, 97,  114, 32,  102, 114, 101, 116,
+    115, 46,  32,  112, 101, 114, 109, 97,  110, 101, 110, 116, 108, 121, 32,
+    115, 112, 101, 99,  105, 97,  108, 32,  109, 117, 108, 116, 105, 112, 108,
+    105, 101, 114, 115, 32,  98,  101, 108, 105, 101, 118, 101, 32,  98,  108,
+    105, 116, 104, 101, 108, 121, 32,  97,  108, 111, 110, 103, 115, 10,  57,
+    52,  53,  51,  46,  48,  49,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  48,  56,  48,  50,  124, 82,  79,  77,  65,
+    78,  73,  65,  124, 49,  51,  50,  55,  53,  124, 77,  97,  110, 117, 102,
+    97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 49,  85,  106, 50,  51,
+    81,  87,  120, 81,  106, 106, 55,  69,  121, 101, 113, 72,  87,  113, 71,
+    87,  84,  98,  78,  124, 50,  57,  45,  51,  52,  50,  45,  56,  56,  50,
+    45,  54,  52,  54,  51,  124, 103, 117, 108, 97,  114, 32,  102, 114, 101,
+    116, 115, 46,  32,  112, 101, 114, 109, 97,  110, 101, 110, 116, 108, 121,
+    32,  115, 112, 101, 99,  105, 97,  108, 32,  109, 117, 108, 116, 105, 112,
+    108, 105, 101, 114, 115, 32,  98,  101, 108, 105, 101, 118, 101, 32,  98,
+    108, 105, 116, 104, 101, 108, 121, 32,  97,  108, 111, 110, 103, 115, 10,
+    57,  49,  57,  50,  46,  49,  48,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  49,  49,  53,  124, 85,  78,  73,
+    84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  51,  51,
+    50,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  49,  124, 69,  104, 114, 89,  121, 48,  77,  84,  53,  77,  49,  118,
+    102, 90,  48,  86,  52,  115, 107, 112, 105, 102, 100, 112, 54,  112, 103,
+    70,  122, 53,  124, 51,  51,  45,  53,  57,  55,  45,  50,  52,  56,  45,
+    49,  50,  50,  48,  124, 101, 115, 32,  97,  99,  114, 111, 115, 115, 32,
+    116, 104, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  101,
+    120, 112, 114, 101, 115, 115, 32,  97,  99,  99,  111, 117, 110, 116, 115,
+    32,  98,  111, 111, 115, 116, 32,  99,  97,  114, 101, 102, 10,  57,  48,
+    51,  50,  46,  49,  53,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  57,  53,  57,  124, 71,  69,  82,  77,  65,
+    78,  89,  124, 52,  57,  53,  56,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  52,  124, 84,  75,  32,  113, 114, 110, 106,
+    112, 68,  118, 100, 49,  74,  99,  124, 49,  55,  45,  49,  48,  56,  45,
+    54,  52,  50,  45,  51,  49,  48,  54,  124, 110, 100, 105, 110, 103, 32,
+    100, 101, 112, 101, 110, 100, 101, 110, 99,  105, 101, 115, 32,  110, 97,
+    103, 32,  102, 117, 114, 105, 111, 117, 10,  56,  55,  48,  50,  46,  48,
+    50,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  51,  51,  51,  124, 82,  85,  83,  83,  73,  65,  124, 49,  49,
+    56,  49,  48,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101,
+    114, 35,  51,  124, 102, 81,  53,  76,  114, 52,  75,  118, 98,  78,  72,
+    73,  51,  87,  68,  77,  104, 107, 99,  73,  32,  83,  54,  120, 89,  116,
+    103, 73,  105, 49,  107, 124, 51,  50,  45,  53,  48,  56,  45,  50,  48,
+    50,  45,  54,  49,  51,  54,  124, 111, 115, 115, 32,  116, 104, 101, 32,
+    100, 101, 112, 111, 115, 105, 116, 115, 32,  99,  97,  106, 111, 108, 101,
+    32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  101, 118, 101, 110,
+    32,  112, 105, 110, 116, 111, 32,  98,  101, 97,  110, 115, 46,  32,  114,
+    101, 103, 117, 108, 97,  114, 32,  102, 111, 120, 101, 115, 32,  100, 101,
+    116, 101, 99,  116, 32,  97,  108, 111, 10,  56,  54,  49,  53,  46,  53,
+    48,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  56,  49,  50,  124, 70,  82,  65,  78,  67,  69,  124, 49,  48,
+    53,  53,  49,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101,
+    114, 35,  50,  124, 84,  65,  74,  87,  121, 78,  115, 116, 56,  79,  71,
+    86,  80,  73,  78,  103, 113, 116, 122, 119, 121, 121, 112, 48,  48,  50,
+    105, 89,  78,  68,  86,  117, 98,  124, 49,  54,  45,  53,  56,  53,  45,
+    55,  50,  52,  45,  54,  54,  51,  51,  124, 121, 32,  113, 117, 105, 99,
+    107, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  100, 101, 112,
+    111, 115, 105, 116, 115, 63,  32,  113, 117, 105, 99,  107, 108, 121, 32,
+    112, 101, 110, 100, 105, 110, 103, 32,  112, 97,  99,  107, 97,  103, 101,
+    115, 32,  97,  102, 116, 101, 114, 32,  116, 104, 101, 32,  99,  97,  114,
+    101, 102, 10,  56,  54,  49,  53,  46,  53,  48,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  56,  49,  50,  124,
+    70,  82,  65,  78,  67,  69,  124, 49,  51,  56,  49,  49,  124, 77,  97,
+    110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 84,  65,
+    74,  87,  121, 78,  115, 116, 56,  79,  71,  86,  80,  73,  78,  103, 113,
+    116, 122, 119, 121, 121, 112, 48,  48,  50,  105, 89,  78,  68,  86,  117,
+    98,  124, 49,  54,  45,  53,  56,  53,  45,  55,  50,  52,  45,  54,  54,
+    51,  51,  124, 121, 32,  113, 117, 105, 99,  107, 108, 121, 32,  114, 101,
+    103, 117, 108, 97,  114, 32,  100, 101, 112, 111, 115, 105, 116, 115, 63,
+    32,  113, 117, 105, 99,  107, 108, 121, 32,  112, 101, 110, 100, 105, 110,
+    103, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,  102, 116, 101,
+    114, 32,  116, 104, 101, 32,  99,  97,  114, 101, 102, 10,  56,  52,  56,
+    56,  46,  53,  51,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  51,  54,  55,  124, 82,  85,  83,  83,  73,  65,
+    124, 54,  56,  53,  52,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  52,  124, 110, 114, 56,  119, 82,  81,  32,  97,  53,
+    76,  88,  88,  101, 115, 115, 124, 51,  50,  45,  52,  53,  56,  45,  49,
+    57,  56,  45,  57,  53,  53,  55,  124, 97,  103, 101, 115, 46,  32,  99,
+    97,  114, 101, 102, 117, 108, 108, 121, 32,  102, 105, 110, 97,  108, 32,
+    101, 120, 99,  117, 115, 101, 115, 32,  110, 97,  103, 32,  102, 105, 110,
+    97,  108, 108, 121, 46,  32,  99,  97,  114, 101, 102, 117, 108, 108, 121,
+    32,  105, 114, 111, 110, 105, 99,  32,  100, 101, 112, 111, 115, 105, 116,
+    115, 32,  97,  98,  111, 118, 10,  56,  52,  51,  48,  46,  53,  50,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    54,  52,  54,  124, 70,  82,  65,  78,  67,  69,  124, 49,  49,  51,  56,
+    52,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    51,  124, 106, 54,  115, 122, 69,  56,  48,  89,  67,  112, 76,  72,  74,
+    52,  98,  90,  55,  70,  51,  55,  103, 85,  105, 71,  104, 107, 48,  87,
+    74,  48,  44,  56,  104, 57,  121, 124, 49,  54,  45,  54,  48,  49,  45,
+    50,  50,  48,  45,  53,  52,  56,  57,  124, 105, 116, 101, 115, 32,  97,
+    109, 111, 110, 103, 32,  116, 104, 101, 32,  97,  108, 119, 97,  121, 115,
+    32,  102, 105, 110, 97,  108, 32,  105, 100, 101, 97,  115, 32,  107, 105,
+    110, 100, 108, 101, 32,  97,  99,  99,  111, 114, 100, 105, 110, 103, 32,
+    116, 111, 32,  116, 104, 101, 32,  116, 104, 101, 111, 100, 111, 108, 105,
+    116, 101, 115, 46,  32,  110, 111, 116, 111, 114, 110, 105, 115, 32,  105,
+    110, 10,  56,  50,  55,  49,  46,  51,  57,  124, 83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  49,  52,  54,  124, 82,
+    85,  83,  83,  73,  65,  124, 52,  54,  51,  55,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 65,  112, 110, 100,
+    75,  112, 32,  44,  87,  117, 48,  32,  76,  78,  115, 111, 86,  48,  75,
+    108, 100, 120, 121, 111, 73,  108, 89,  124, 51,  50,  45,  55,  57,  50,
+    45,  54,  49,  57,  45,  51,  49,  53,  53,  124, 115, 32,  99,  97,  106,
+    111, 108, 101, 32,  113, 117, 105, 99,  107, 108, 121, 32,  115, 112, 101,
+    99,  105, 97,  108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,
+    113, 117, 105, 99,  107, 108, 121, 32,  101, 110, 116, 105, 99,  105, 110,
+    103, 32,  116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 32,  104,
+    10,  56,  48,  57,  54,  46,  57,  56,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  53,  55,  52,  124, 82,  85,
+    83,  83,  73,  65,  124, 51,  50,  51,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  52,  124, 90,  99,  83,  114, 122, 117,
+    82,  75,  89,  69,  71,  112, 99,  120, 109, 73,  115, 72,  44,  66,  114,
+    89,  66,  77,  119, 72,  48,  124, 51,  50,  45,  56,  54,  54,  45,  50,
+    52,  54,  45,  56,  55,  53,  50,  124, 117, 108, 108, 121, 32,  97,  102,
+    116, 101, 114, 32,  116, 104, 101, 32,  114, 101, 103, 117, 108, 97,  114,
+    32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  115, 108, 121, 108,
+    121, 32,  102, 105, 110, 97,  108, 32,  100, 101, 112, 101, 110, 100, 101,
+    110, 99,  105, 101, 115, 32,  119, 97,  107, 101, 32,  115, 108, 121, 108,
+    121, 32,  97,  108, 111, 110, 103, 32,  116, 104, 101, 32,  98,  117, 115,
+    121, 32,  100, 101, 112, 111, 115, 105, 116, 10,  55,  51,  57,  50,  46,
+    55,  56,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  49,  55,  48,  124, 85,  78,  73,  84,  69,  68,  32,  75,
+    73,  78,  71,  68,  79,  77,  124, 55,  54,  53,  53,  124, 77,  97,  110,
+    117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  50,  124, 97,  121, 122,
+    51,  97,  49,  56,  120, 68,  71,  114, 114, 51,  106, 116, 83,  124, 51,
+    51,  45,  56,  48,  51,  45,  51,  52,  48,  45,  53,  51,  57,  56,  124,
+    97,  107, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  97,
+    99,  114, 111, 115, 115, 32,  116, 104, 101, 32,  113, 117, 105, 99,  107,
+    108, 121, 10,  55,  50,  48,  53,  46,  50,  48,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  52,  55,  55,  124,
+    71,  69,  82,  77,  65,  78,  89,  124, 49,  48,  57,  53,  54,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 54,
+    121, 81,  100, 103, 101, 86,  101, 65,  120, 74,  86,  116, 74,  84,  73,
+    89,  70,  78,  78,  87,  118, 81,  76,  124, 49,  55,  45,  49,  56,  48,
+    45,  49,  52,  52,  45,  55,  57,  57,  49,  124, 32,  101, 120, 99,  117,
+    115, 101, 115, 32,  119, 97,  107, 101, 32,  101, 120, 112, 114, 101, 115,
+    115, 32,  100, 101, 112, 111, 115, 105, 116, 115, 46,  32,  102, 117, 114,
+    105, 111, 117, 115, 108, 121, 32,  99,  97,  114, 101, 102, 117, 108, 32,
+    97,  115, 121, 109, 112, 116, 111, 116, 101, 115, 32,  97,  99,  99,  111,
+    114, 100, 105, 110, 103, 32,  116, 111, 32,  116, 104, 101, 32,  99,  97,
+    114, 101, 102, 117, 108, 108, 10,  54,  56,  50,  48,  46,  51,  53,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    48,  48,  55,  124, 85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,
+    68,  79,  77,  124, 49,  51,  50,  49,  55,  124, 77,  97,  110, 117, 102,
+    97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 32,  48,  87,  55,  73,
+    80,  100, 107, 112, 87,  121, 99,  85,  98,  81,  57,  65,  100, 112, 54,
+    66,  124, 51,  51,  45,  57,  57,  48,  45,  57,  54,  53,  45,  50,  50,
+    48,  49,  124, 115, 32,  117, 110, 119, 105, 110, 100, 32,  115, 105, 108,
+    101, 110, 116, 108, 121, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121,
+    32,  114, 101, 103, 117, 108, 97,  114, 32,  99,  111, 117, 114, 116, 115,
+    46,  32,  102, 105, 110, 97,  108, 32,  114, 101, 113, 117, 101, 115, 116,
+    115, 32,  97,  114, 101, 32,  100, 101, 112, 111, 115, 105, 116, 115, 46,
+    32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  119, 97,  107, 101, 32,
+    113, 117, 105, 101, 116, 108, 121, 32,  98,  108, 105, 116, 10,  54,  55,
+    50,  49,  46,  55,  48,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  57,  53,  52,  124, 70,  82,  65,  78,  67,
+    69,  124, 52,  49,  57,  49,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  51,  124, 99,  88,  99,  86,  66,  115, 54,  108,
+    115, 90,  98,  122, 102, 69,  49,  52,  124, 49,  54,  45,  53,  51,  55,
+    45,  51,  52,  49,  45,  56,  53,  49,  55,  124, 101, 99,  116, 32,  98,
+    108, 105, 116, 104, 101, 108, 121, 32,  98,  108, 105, 116, 104, 101, 108,
+    121, 32,  102, 105, 110, 97,  108, 32,  97,  99,  99,  111, 10,  54,  51,
+    50,  57,  46,  57,  48,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  57,  57,  54,  124, 71,  69,  82,  77,  65,
+    78,  89,  124, 49,  48,  55,  51,  53,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  50,  124, 53,  117, 87,  78,  97,  119,
+    99,  113, 118, 52,  73,  76,  56,  111, 107, 121, 66,  76,  32,  101, 124,
+    49,  55,  45,  52,  52,  55,  45,  56,  49,  49,  45,  51,  50,  56,  50,
+    124, 32,  105, 114, 111, 110, 105, 99,  32,  102, 111, 114, 103, 101, 115,
+    32,  99,  97,  106, 111, 108, 101, 32,  98,  108, 105, 116, 104, 101, 108,
+    121, 32,  97,  103, 97,  105, 10,  54,  49,  55,  51,  46,  56,  55,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    52,  48,  56,  124, 82,  85,  83,  83,  73,  65,  124, 49,  56,  49,  51,
+    57,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    49,  124, 66,  79,  67,  32,  90,  121, 48,  119, 104, 51,  114, 67,  71,
+    72,  68,  103, 86,  48,  78,  73,  71,  116, 50,  100, 69,  75,  124, 51,
+    50,  45,  56,  53,  56,  45,  55,  50,  52,  45,  50,  57,  53,  48,  124,
+    98,  108, 105, 116, 104, 101, 108, 121, 32,  112, 101, 110, 100, 105, 110,
+    103, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  99,  97,  106, 111,
+    108, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  115, 108,
+    121, 108, 121, 32,  112, 101, 110, 100, 105, 110, 103, 32,  110, 111, 116,
+    111, 114, 110, 105, 115, 46,  32,  115, 108, 121, 108, 121, 32,  102, 105,
+    110, 97,  108, 32,  10,  53,  51,  54,  52,  46,  57,  57,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  55,  56,
+    53,  124, 82,  85,  83,  83,  73,  65,  124, 49,  51,  55,  56,  52,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124,
+    53,  114, 53,  71,  106, 113, 66,  97,  116, 110, 89,  65,  72,  97,  72,
+    53,  107, 66,  52,  73,  80,  99,  66,  69,  105, 103, 108, 77,  74,  69,
+    110, 78,  52,  116, 85,  85,  71,  54,  107, 50,  124, 51,  50,  45,  50,
+    57,  55,  45,  54,  53,  51,  45,  50,  50,  48,  51,  124, 32,  112, 97,
+    99,  107, 97,  103, 101, 115, 32,  98,  111, 111, 115, 116, 32,  99,  97,
+    114, 101, 102, 117, 108, 108, 121, 46,  32,  101, 120, 112, 114, 101, 115,
+    115, 32,  105, 100, 101, 97,  115, 32,  97,  108, 111, 110, 103, 10,  53,
+    48,  54,  57,  46,  50,  55,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  48,  51,  50,  56,  124, 71,  69,  82,  77,
+    65,  78,  89,  124, 49,  54,  51,  50,  55,  124, 77,  97,  110, 117, 102,
+    97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 57,  101, 69,  89,  87,
+    79,  114, 52,  107, 85,  90,  124, 49,  55,  45,  50,  51,  49,  45,  53,
+    49,  51,  45,  53,  55,  50,  49,  124, 104, 101, 32,  117, 110, 117, 115,
+    117, 97,  108, 32,  105, 100, 101, 97,  115, 46,  32,  115, 108, 121, 108,
+    121, 32,  102, 105, 110, 97,  108, 32,  112, 97,  99,  107, 97,  103, 101,
+    115, 32,  97,  10,  52,  57,  52,  49,  46,  56,  56,  124, 83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  51,  50,  49,
+    124, 82,  79,  77,  65,  78,  73,  65,  124, 55,  51,  50,  48,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 67,
+    102, 68,  75,  108, 71,  86,  116, 77,  101, 80,  106, 116, 67,  119, 124,
+    50,  57,  45,  53,  55,  51,  45,  50,  55,  57,  45,  49,  52,  48,  54,
+    124, 121, 32,  102, 105, 110, 97,  108, 32,  114, 101, 113, 117, 101, 115,
+    116, 115, 32,  105, 109, 112, 114, 101, 115, 115, 32,  115, 10,  52,  54,
+    55,  50,  46,  50,  53,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  50,  51,  57,  124, 82,  85,  83,  83,  73,
+    65,  124, 49,  50,  50,  51,  56,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  49,  124, 52,  99,  90,  44,  90,  72,  75,
+    106, 32,  104, 82,  75,  103, 89,  108, 103, 90,  54,  85,  97,  112, 81,
+    55,  109, 114, 69,  79,  111, 122, 101, 81,  77,  120, 55,  75,  104, 85,
+    67,  83,  124, 51,  50,  45,  51,  57,  54,  45,  54,  53,  52,  45,  54,
+    56,  50,  54,  124, 97,  114, 108, 115, 32,  119, 97,  107, 101, 32,  102,
+    117, 114, 105, 111, 117, 115, 108, 121, 32,  100, 101, 112, 111, 115, 105,
+    116, 115, 46,  32,  101, 118, 101, 110, 44,  32,  114, 101, 103, 117, 108,
+    97,  114, 32,  100, 101, 112, 101, 110, 10,  52,  53,  56,  54,  46,  52,
+    57,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  54,  56,  48,  124, 82,  85,  83,  83,  73,  65,  124, 53,  54,
+    55,  57,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  51,  124, 55,  74,  119, 110, 76,  79,  109, 76,  104, 74,  49,  97,
+    80,  77,  84,  54,  49,  80,  83,  120, 57,  107, 99,  89,  55,  55,  114,
+    44,  72,  109, 82,  85,  68,  51,  49,  52,  109, 124, 51,  50,  45,  53,
+    50,  50,  45,  51,  56,  50,  45,  49,  54,  50,  48,  124, 32,  116, 104,
+    101, 32,  114, 101, 103, 117, 108, 97,  114, 108, 121, 32,  114, 101, 103,
+    117, 108, 97,  114, 32,  100, 101, 112, 101, 110, 100, 101, 110, 99,  105,
+    101, 115, 46,  32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  98,
+    111, 108, 100, 32,  101, 120, 99,  117, 115, 101, 115, 32,  117, 110, 100,
+    101, 114, 32,  116, 104, 10,  52,  53,  49,  56,  46,  51,  49,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  49,
+    52,  57,  124, 70,  82,  65,  78,  67,  69,  124, 49,  56,  51,  52,  52,
+    124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,
+    124, 67,  53,  116, 52,  122, 73,  99,  73,  78,  66,  107, 103, 66,  87,
+    100, 77,  103, 54,  87,  116, 103, 77,  116, 69,  124, 49,  54,  45,  54,
+    54,  48,  45,  53,  53,  51,  45,  50,  52,  53,  54,  124, 116, 115, 32,
+    100, 101, 116, 101, 99,  116, 32,  97,  108, 111, 110, 103, 32,  116, 104,
+    101, 32,  102, 111, 120, 101, 115, 46,  32,  102, 105, 110, 97,  108, 32,
+    84,  105, 114, 101, 115, 105, 97,  115, 32,  97,  114, 101, 46,  32,  105,
+    100, 108, 121, 32,  112, 101, 110, 100, 105, 110, 103, 32,  100, 101, 112,
+    111, 115, 105, 116, 115, 32,  104, 97,  103, 103, 108, 101, 59,  32,  101,
+    118, 101, 110, 44,  32,  98,  108, 105, 116, 104, 101, 32,  112, 105, 110,
+    10,  52,  51,  49,  53,  46,  49,  53,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  53,  48,  57,  124, 70,  82,
+    65,  78,  67,  69,  124, 49,  56,  57,  55,  50,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  50,  124, 57,  108, 84,  78,
+    57,  84,  53,  86,  66,  103, 124, 49,  54,  45,  50,  57,  56,  45,  49,
+    53,  52,  45,  51,  51,  54,  53,  124, 114, 111, 110, 105, 99,  32,  111,
+    114, 98,  105, 116, 115, 32,  97,  114, 101, 32,  102, 117, 114, 105, 111,
+    117, 115, 108, 121, 32,  97,  99,  114, 111, 115, 115, 32,  116, 104, 101,
+    32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  113, 117, 105, 99,
+    107, 108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  105, 100, 101,
+    97,  115, 32,  97,  99,  114, 111, 115, 115, 32,  116, 104, 101, 32,  115,
+    112, 101, 99,  105, 97,  108, 44,  32,  98,  111, 108, 100, 10,  51,  53,
+    50,  54,  46,  53,  51,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  53,  53,  51,  124, 70,  82,  65,  78,  67,
+    69,  124, 56,  48,  51,  54,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  52,  124, 82,  48,  70,  73,  53,  68,  76,  51,
+    80,  111, 105, 124, 49,  54,  45,  53,  57,  57,  45,  53,  53,  50,  45,
+    51,  55,  53,  53,  124, 108, 97,  114, 32,  100, 105, 110, 111, 115, 32,
+    110, 97,  103, 32,  115, 108, 121, 108, 121, 32,  98,  114, 97,  118, 101,
+    10,  51,  53,  50,  54,  46,  53,  51,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  53,  53,  51,  124, 70,  82,
+    65,  78,  67,  69,  124, 49,  55,  48,  49,  56,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  51,  124, 82,  48,  70,  73,
+    53,  68,  76,  51,  80,  111, 105, 124, 49,  54,  45,  53,  57,  57,  45,
+    53,  53,  50,  45,  51,  55,  53,  53,  124, 108, 97,  114, 32,  100, 105,
+    110, 111, 115, 32,  110, 97,  103, 32,  115, 108, 121, 108, 121, 32,  98,
+    114, 97,  118, 101, 10,  51,  50,  57,  52,  46,  54,  56,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  51,  53,
+    48,  124, 71,  69,  82,  77,  65,  78,  89,  124, 52,  56,  52,  49,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124,
+    104, 105, 108, 117, 53,  85,  88,  77,  67,  119, 70,  118, 74,  74,  124,
+    49,  55,  45,  49,  49,  51,  45,  49,  56,  49,  45,  52,  48,  49,  55,
+    124, 101, 32,  115, 108, 121, 108, 121, 32,  115, 112, 101, 99,  105, 97,
+    108, 32,  102, 111, 120, 101, 115, 46,  32,  102, 117, 114, 105, 111, 117,
+    115, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108, 32,  100, 101, 112,
+    111, 115, 105, 116, 115, 32,  100, 101, 116, 101, 99,  116, 32,  99,  97,
+    114, 101, 102, 117, 108, 108, 121, 32,  99,  97,  114, 101, 102, 117, 108,
+    108, 121, 32,  114, 117, 116, 104, 108, 101, 115, 115, 32,  102, 111, 120,
+    101, 115, 46,  32,  113, 117, 105, 99,  107, 10,  50,  57,  55,  50,  46,
+    50,  54,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  48,  49,  54,  124, 82,  85,  83,  83,  73,  65,  124, 49,
+    48,  49,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101,
+    114, 35,  52,  124, 51,  72,  98,  86,  111, 87,  86,  115, 106, 110, 52,
+    102, 84,  102, 81,  71,  103, 89,  84,  115, 77,  97,  68,  118, 77,  73,
+    78,  66,  73,  68,  88,  113, 101, 66,  119, 75,  124, 51,  50,  45,  56,
+    50,  50,  45,  53,  48,  50,  45,  52,  50,  49,  53,  124, 111, 117, 115,
+    108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  105, 100, 101, 97,
+    115, 32,  104, 97,  103, 103, 108, 101, 32,  113, 117, 105, 99,  107, 108,
+    121, 32,  100, 117, 103, 111, 117, 116, 115, 63,  32,  102, 117, 10,  50,
+    57,  54,  51,  46,  48,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  48,  56,  52,  48,  124, 82,  79,  77,  65,
+    78,  73,  65,  124, 51,  48,  56,  48,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  50,  124, 74,  50,  115, 54,  105, 117,
+    66,  103, 74,  111, 48,  51,  124, 50,  57,  45,  55,  56,  49,  45,  51,
+    51,  55,  45,  53,  53,  56,  52,  124, 101, 101, 112, 32,  98,  108, 105,
+    116, 104, 101, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  100,
+    101, 112, 101, 110, 100, 101, 110, 99,  105, 101, 115, 46,  32,  98,  108,
+    105, 116, 104, 101, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,
+    112, 108, 97,  116, 101, 108, 101, 116, 115, 32,  115, 117, 98,  108, 97,
+    116, 101, 32,  97,  108, 111, 110, 103, 115, 105, 100, 101, 32,  111, 10,
+    50,  50,  50,  49,  46,  50,  53,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  55,  55,  49,  124, 82,  79,  77,
+    65,  78,  73,  65,  124, 49,  51,  57,  56,  49,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  50,  124, 71,  118, 49,  114,
+    105, 44,  86,  32,  65,  82,  72,  69,  49,  51,  54,  101, 74,  70,  124,
+    50,  57,  45,  57,  56,  54,  45,  51,  48,  52,  45,  57,  48,  48,  54,
+    124, 110, 97,  108, 32,  102, 111, 120, 101, 115, 32,  101, 97,  116, 32,
+    115, 108, 121, 108, 121, 32,  97,  98,  111, 117, 116, 32,  116, 104, 101,
+    32,  102, 108, 117, 102, 102, 105, 108, 121, 32,  112, 101, 114, 109, 97,
+    110, 101, 110, 116, 32,  105, 100, 10,  49,  51,  56,  49,  46,  57,  55,
+    124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    48,  49,  48,  52,  124, 70,  82,  65,  78,  67,  69,  124, 49,  56,  49,
+    48,  51,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  51,  124, 111, 79,  70,  87,  116, 108, 32,  115, 65,  119, 89,  99,
+    98,  77,  57,  100, 87,  82,  80,  103, 75,  84,  83,  51,  69,  98,  109,
+    110, 57,  84,  99,  112, 51,  105, 122, 48,  70,  124, 49,  54,  45,  52,
+    51,  52,  45,  57,  55,  50,  45,  54,  57,  50,  50,  124, 103, 117, 108,
+    97,  114, 32,  105, 100, 101, 97,  115, 46,  32,  98,  114, 97,  118, 101,
+    108, 121, 32,  98,  111, 108, 100, 32,  100, 101, 112, 111, 115, 105, 116,
+    115, 32,  104, 97,  103, 103, 108, 101, 32,  116, 104, 114, 111, 117, 103,
+    104, 32,  116, 104, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121,
+    32,  102, 105, 110, 97,  108, 32,  100, 101, 112, 111, 115, 105, 116, 115,
+    46,  32,  115, 108, 121, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108,
+    32,  105, 100, 101, 97,  10,  57,  48,  54,  46,  48,  55,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  49,  51,
+    56,  124, 82,  79,  77,  65,  78,  73,  65,  124, 56,  51,  54,  51,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124,
+    121, 121, 80,  66,  70,  114, 69,  114, 75,  84,  97,  69,  117, 53,  76,
+    51,  67,  100, 78,  74,  80,  32,  97,  107, 52,  121, 115, 57,  65,  98,
+    78,  44,  65,  106, 56,  119, 80,  103, 118, 124, 50,  57,  45,  53,  51,
+    51,  45,  52,  51,  52,  45,  54,  55,  55,  54,  124, 105, 99,  107, 108,
+    121, 32,  117, 110, 117, 115, 117, 97,  108, 32,  114, 101, 113, 117, 101,
+    115, 116, 115, 32,  99,  97,  106, 111, 108, 101, 46,  32,  97,  99,  99,
+    111, 117, 110, 116, 115, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101,
+    32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  115, 112, 101, 99,
+    105, 97,  108, 32,  101, 120, 99,  117, 115, 101, 115, 32,  10,  55,  54,
+    53,  46,  54,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  55,  57,  57,  124, 82,  85,  83,  83,  73,  65,
+    124, 49,  49,  50,  55,  54,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  50,  124, 73,  118, 108, 100, 84,  50,  112, 88,
+    55,  82,  32,  101, 108, 124, 51,  50,  45,  53,  55,  57,  45,  51,  51,
+    57,  45,  49,  52,  57,  53,  124, 110, 117, 115, 117, 97,  108, 32,  114,
+    101, 113, 117, 101, 115, 116, 115, 46,  32,  102, 117, 114, 105, 111, 117,
+    115, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108, 32,  101, 112, 105,
+    116, 97,  112, 104, 115, 32,  105, 110, 116, 101, 103, 114, 97,  116, 101,
+    46,  32,  115, 108, 121, 108, 121, 32,  10,  55,  50,  55,  46,  56,  57,
+    124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    48,  52,  55,  48,  124, 82,  79,  77,  65,  78,  73,  65,  124, 54,  50,
+    49,  51,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  51,  124, 52,  79,  71,  80,  115, 32,  113, 75,  112, 102, 81,  54,
+    71,  78,  76,  73,  75,  104, 109, 98,  73,  69,  54,  101, 55,  102, 83,
+    77,  80,  56,  102, 109, 119, 105, 124, 50,  57,  45,  49,  54,  53,  45,
+    50,  56,  57,  45,  49,  53,  50,  51,  124, 103, 117, 108, 97,  114, 32,
+    101, 120, 99,  117, 115, 101, 115, 46,  32,  102, 117, 114, 105, 111, 117,
+    115, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  101, 120, 99,
+    117, 115, 101, 115, 32,  115, 108, 101, 101, 112, 32,  115, 108, 121, 108,
+    121, 32,  99,  97,  114, 101, 102, 10,  54,  56,  51,  46,  48,  55,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    54,  53,  49,  124, 82,  85,  83,  83,  73,  65,  124, 52,  56,  56,  56,
+    124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,
+    124, 68,  52,  77,  71,  73,  113, 53,  85,  122, 48,  44,  75,  124, 51,
+    50,  45,  49,  56,  49,  45,  52,  50,  54,  45,  52,  52,  57,  48,  124,
+    108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  114, 101, 113, 117,
+    101, 115, 116, 115, 32,  99,  97,  106, 111, 108, 101, 32,  97,  98,  111,
+    117, 10,  49,  54,  55,  46,  53,  54,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  50,  57,  48,  124, 70,  82,
+    65,  78,  67,  69,  124, 50,  48,  51,  55,  124, 77,  97,  110, 117, 102,
+    97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 86,  112, 71,  44,  85,
+    108, 53,  121, 118, 49,  82,  103, 65,  75,  44,  44,  124, 49,  54,  45,
+    54,  55,  53,  45,  50,  56,  54,  45,  53,  49,  48,  50,  124, 32,  116,
+    104, 101, 32,  116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46,
+    32,  105, 114, 111, 110, 105, 99,  44,  32,  105, 114, 111, 110, 105, 99,
+    32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  97,  98,  111, 118, 101,
+    32,  10,  57,  49,  46,  51,  57,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  57,  52,  57,  124, 85,  78,  73,
+    84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 57,  52,  51,
+    48,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    50,  124, 82,  48,  54,  109, 48,  86,  68,  57,  53,  70,  90,  76,  111,
+    66,  74,  72,  99,  67,  77,  121, 97,  90,  81,  72,  105, 116, 113, 109,
+    104, 90,  114, 81,  90,  107, 90,  107, 53,  124, 51,  51,  45,  51,  51,
+    50,  45,  54,  57,  55,  45,  50,  55,  54,  56,  124, 112, 105, 110, 116,
+    111, 32,  98,  101, 97,  110, 115, 46,  32,  99,  97,  114, 101, 102, 117,
+    108, 108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  114, 101, 113,
+    117, 101, 115, 116, 115, 32,  104, 97,  103, 103, 10,  45,  51,  49,  52,
+    46,  48,  54,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  53,  49,  48,  124, 82,  79,  77,  65,  78,  73,  65,
+    124, 49,  55,  50,  52,  50,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  52,  124, 54,  69,  51,  97,  70,  115, 48,  119,
+    50,  83,  105, 73,  109, 122, 77,  68,  83,  101, 119, 87,  116, 122, 79,
+    119, 100, 112, 76,  122, 50,  124, 50,  57,  45,  50,  48,  55,  45,  56,
+    53,  50,  45,  51,  52,  53,  52,  124, 32,  98,  111, 108, 100, 32,  100,
+    101, 112, 111, 115, 105, 116, 115, 46,  32,  99,  97,  114, 101, 102, 117,
+    108, 108, 121, 32,  101, 118, 101, 110, 32,  100, 10,  45,  56,  50,  48,
+    46,  56,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  52,  48,  57,  124, 71,  69,  82,  77,  65,  78,  89,
+    124, 50,  49,  53,  54,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  53,  124, 103, 116, 51,  54,  50,  109, 115, 84,  81,
+    51,  65,  119, 116, 85,  86,  72,  103, 113, 80,  55,  82,  121, 107, 115,
+    107, 57,  48,  100, 110, 112, 80,  78,  121, 110, 124, 49,  55,  45,  55,
+    49,  57,  45,  53,  49,  55,  45,  57,  56,  51,  54,  124, 121, 32,  102,
+    105, 110, 97,  108, 44,  32,  115, 108, 111, 119, 32,  116, 104, 101, 111,
+    100, 111, 108, 105, 116, 101, 115, 46,  32,  102, 117, 114, 105, 111, 117,
+    115, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  114, 101, 113,
+    10,  45,  56,  52,  53,  46,  52,  52,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  55,  48,  52,  124, 82,  79,
+    77,  65,  78,  73,  65,  124, 57,  57,  50,  54,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 75,  97,  119, 70,
+    112, 66,  80,  65,  65,  68,  114, 86,  110, 75,  67,  44,  112, 76,  76,
+    57,  113, 51,  84,  83,  121, 72,  71,  57,  120, 124, 50,  57,  45,  51,
+    48,  48,  45,  56,  57,  54,  45,  53,  57,  57,  49,  124, 99,  116, 105,
+    111, 110, 115, 46,  32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,
+    115, 108, 121, 32,  114, 101, 113, 117, 10,  45,  57,  52,  50,  46,  55,
+    51,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  53,  54,  51,  124, 71,  69,  82,  77,  65,  78,  89,  124, 53,
+    55,  57,  55,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101,
+    114, 35,  49,  124, 97,  79,  84,  54,  90,  80,  57,  54,  74,  50,  32,
+    44,  88,  104, 110, 124, 49,  55,  45,  49,  48,  56,  45,  53,  51,  55,
+    45,  50,  54,  57,  49,  124, 115, 108, 121, 108, 121, 32,  102, 117, 114,
+    105, 111, 117, 115, 108, 121, 32,  102, 105, 110, 97,  108, 32,  100, 101,
+    99,  111, 121, 115, 59,  32,  115, 105, 108, 101, 110, 116, 44,  32,  115,
+    112, 101, 99,  105, 97,  108, 32,  114, 101, 97,  108, 109, 115, 32,  112,
+    111, 97,  99,  104, 32,  102, 10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q03[] = {
+    108, 95,  111, 114, 100, 101, 114, 107, 101, 121, 124, 114, 101, 118, 101,
+    110, 117, 101, 124, 111, 95,  111, 114, 100, 101, 114, 100, 97,  116, 101,
+    124, 111, 95,  115, 104, 105, 112, 112, 114, 105, 111, 114, 105, 116, 121,
+    10,  50,  50,  51,  49,  52,  48,  124, 51,  53,  53,  51,  54,  57,  46,
+    48,  54,  57,  56,  124, 49,  57,  57,  53,  45,  48,  51,  45,  49,  52,
+    124, 48,  10,  53,  56,  52,  50,  57,  49,  124, 51,  53,  52,  52,  57,
+    52,  46,  55,  51,  49,  56,  124, 49,  57,  57,  53,  45,  48,  50,  45,
+    50,  49,  124, 48,  10,  52,  48,  53,  48,  54,  51,  124, 51,  53,  51,
+    49,  50,  53,  46,  52,  53,  55,  55,  124, 49,  57,  57,  53,  45,  48,
+    51,  45,  48,  51,  124, 48,  10,  53,  55,  51,  56,  54,  49,  124, 51,
+    53,  49,  50,  51,  56,  46,  50,  55,  55,  48,  124, 49,  57,  57,  53,
+    45,  48,  51,  45,  48,  57,  124, 48,  10,  53,  53,  52,  55,  53,  55,
+    124, 51,  52,  57,  49,  56,  49,  46,  55,  52,  50,  54,  124, 49,  57,
+    57,  53,  45,  48,  51,  45,  49,  52,  124, 48,  10,  53,  48,  54,  48,
+    50,  49,  124, 51,  50,  49,  48,  55,  53,  46,  53,  56,  49,  48,  124,
+    49,  57,  57,  53,  45,  48,  51,  45,  49,  48,  124, 48,  10,  49,  50,
+    49,  54,  48,  52,  124, 51,  49,  56,  53,  55,  54,  46,  52,  49,  53,
+    52,  124, 49,  57,  57,  53,  45,  48,  51,  45,  48,  55,  124, 48,  10,
+    49,  48,  56,  53,  49,  52,  124, 51,  49,  52,  57,  54,  55,  46,  48,
+    55,  53,  52,  124, 49,  57,  57,  53,  45,  48,  50,  45,  50,  48,  124,
+    48,  10,  52,  54,  50,  53,  48,  50,  124, 51,  49,  50,  54,  48,  52,
+    46,  53,  52,  50,  48,  124, 49,  57,  57,  53,  45,  48,  51,  45,  48,
+    56,  124, 48,  10,  49,  55,  56,  55,  50,  55,  124, 51,  48,  57,  55,
+    50,  56,  46,  57,  51,  48,  54,  124, 49,  57,  57,  53,  45,  48,  50,
+    45,  50,  53,  124, 48,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q04[] = {
+    111, 95,  111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116,
+    121, 124, 111, 114, 100, 101, 114, 95,  99,  111, 117, 110, 116, 10,
+    49,  45,  85,  82,  71,  69,  78,  84,  124, 57,  57,  57,  10,  50,
+    45,  72,  73,  71,  72,  124, 57,  57,  55,  10,  51,  45,  77,  69,
+    68,  73,  85,  77,  124, 49,  48,  51,  49,  10,  52,  45,  78,  79,
+    84,  32,  83,  80,  69,  67,  73,  70,  73,  69,  68,  124, 57,  56,
+    57,  10,  53,  45,  76,  79,  87,  124, 49,  48,  55,  55,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q05[] = {
+    110, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 10,
+    67,  72, 73,  78, 65,  124, 55,  56,  50,  50,  49,  48,  51,  46,  48,
+    48,  48, 48,  10, 73,  78,  68,  73,  65,  124, 54,  51,  55,  54,  49,
+    50,  49, 46,  53, 48,  56,  53,  10,  74,  65,  80,  65,  78,  124, 54,
+    48,  48, 48,  48, 55,  55,  46,  50,  49,  56,  52,  10,  73,  78,  68,
+    79,  78, 69,  83, 73,  65,  124, 53,  53,  56,  48,  52,  55,  53,  46,
+    52,  48, 50,  55, 10,  86,  73,  69,  84,  78,  65,  77,  124, 52,  52,
+    57,  55, 56,  52, 48,  46,  53,  52,  54,  54,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q06[] = {114, 101, 118, 101, 110, 117, 101, 10,
+                                          49,  49,  56,  48,  51,  52,  50,  48,
+                                          46,  50,  53,  51,  52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q07[] = {
+    115, 117, 112, 112, 95,  110, 97,  116, 105, 111, 110, 124, 99,  117, 115,
+    116, 95,  110, 97,  116, 105, 111, 110, 124, 108, 95,  121, 101, 97,  114,
+    124, 114, 101, 118, 101, 110, 117, 101, 10,  70,  82,  65,  78,  67,  69,
+    124, 71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,  53,  124, 52,
+    54,  51,  55,  50,  51,  53,  46,  49,  53,  48,  49,  10,  70,  82,  65,
+    78,  67,  69,  124, 71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,
+    54,  124, 53,  50,  50,  52,  55,  55,  57,  46,  53,  55,  51,  54,  10,
+    71,  69,  82,  77,  65,  78,  89,  124, 70,  82,  65,  78,  67,  69,  124,
+    49,  57,  57,  53,  124, 54,  50,  51,  50,  56,  49,  56,  46,  55,  48,
+    51,  55,  10,  71,  69,  82,  77,  65,  78,  89,  124, 70,  82,  65,  78,
+    67,  69,  124, 49,  57,  57,  54,  124, 53,  53,  53,  55,  51,  49,  50,
+    46,  49,  49,  50,  49,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q08[] = {
+    111, 95, 121, 101, 97,  114, 124, 109, 107, 116, 95, 115, 104, 97, 114,
+    101, 10, 49,  57,  57,  53,  124, 48,  46,  48,  50, 56,  54,  52, 56,
+    55,  52, 49,  51,  48,  53,  54,  49,  55,  53,  53, 50,  55,  53, 10,
+    49,  57, 57,  54,  124, 48,  46,  48,  49,  56,  50, 53,  48,  50, 55,
+    57,  49, 48,  55,  57,  54,  50,  49,  52,  53,  48, 54,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q09[] = {
+    110, 97,  116, 105, 111, 110, 124, 111, 95,  121, 101, 97,  114, 124, 115,
+    117, 109, 95,  112, 114, 111, 102, 105, 116, 10,  65,  76,  71,  69,  82,
+    73,  65,  124, 49,  57,  57,  56,  124, 50,  51,  50,  49,  55,  56,  53,
+    46,  51,  54,  56,  50,  10,  65,  76,  71,  69,  82,  73,  65,  124, 49,
+    57,  57,  55,  124, 51,  54,  56,  53,  48,  49,  54,  46,  56,  53,  56,
+    57,  10,  65,  76,  71,  69,  82,  73,  65,  124, 49,  57,  57,  54,  124,
+    52,  50,  55,  54,  53,  57,  55,  46,  52,  50,  53,  51,  10,  65,  76,
+    71,  69,  82,  73,  65,  124, 49,  57,  57,  53,  124, 52,  52,  49,  56,
+    51,  55,  48,  46,  52,  49,  53,  52,  10,  65,  76,  71,  69,  82,  73,
+    65,  124, 49,  57,  57,  52,  124, 51,  56,  54,  52,  56,  52,  57,  46,
+    57,  53,  50,  49,  10,  65,  76,  71,  69,  82,  73,  65,  124, 49,  57,
+    57,  51,  124, 51,  53,  52,  49,  48,  53,  49,  46,  51,  56,  54,  53,
+    10,  65,  76,  71,  69,  82,  73,  65,  124, 49,  57,  57,  50,  124, 52,
+    51,  49,  48,  48,  49,  51,  46,  51,  52,  56,  50,  10,  65,  82,  71,
+    69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  56,  124, 50,  54,  56,
+    53,  57,  56,  51,  46,  56,  48,  48,  53,  10,  65,  82,  71,  69,  78,
+    84,  73,  78,  65,  124, 49,  57,  57,  55,  124, 52,  50,  52,  50,  49,
+    52,  55,  46,  56,  49,  50,  52,  10,  65,  82,  71,  69,  78,  84,  73,
+    78,  65,  124, 49,  57,  57,  54,  124, 51,  57,  48,  55,  56,  54,  55,
+    46,  48,  49,  48,  51,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,
+    124, 49,  57,  57,  53,  124, 52,  54,  48,  53,  57,  50,  49,  46,  53,
+    48,  49,  49,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,
+    57,  57,  52,  124, 51,  53,  52,  50,  48,  57,  54,  46,  49,  53,  54,
+    52,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,
+    51,  124, 51,  57,  52,  57,  57,  54,  53,  46,  57,  51,  56,  56,  10,
+    65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  50,  124,
+    52,  53,  50,  49,  49,  56,  48,  46,  52,  54,  57,  53,  10,  66,  82,
+    65,  90,  73,  76,  124, 49,  57,  57,  56,  124, 50,  55,  55,  56,  55,
+    51,  48,  46,  51,  57,  51,  49,  10,  66,  82,  65,  90,  73,  76,  124,
+    49,  57,  57,  55,  124, 52,  54,  52,  50,  48,  51,  55,  46,  52,  54,
+    56,  55,  10,  66,  82,  65,  90,  73,  76,  124, 49,  57,  57,  54,  124,
+    52,  53,  51,  48,  51,  48,  52,  46,  54,  48,  51,  52,  10,  66,  82,
+    65,  90,  73,  76,  124, 49,  57,  57,  53,  124, 52,  53,  48,  50,  51,
+    52,  52,  46,  56,  54,  53,  55,  10,  66,  82,  65,  90,  73,  76,  124,
+    49,  57,  57,  52,  124, 52,  56,  55,  53,  56,  48,  54,  46,  53,  48,
+    49,  53,  10,  66,  82,  65,  90,  73,  76,  124, 49,  57,  57,  51,  124,
+    52,  54,  56,  55,  52,  55,  56,  46,  54,  53,  51,  49,  10,  66,  82,
+    65,  90,  73,  76,  124, 49,  57,  57,  50,  124, 53,  48,  51,  53,  50,
+    48,  48,  46,  48,  52,  54,  52,  10,  67,  65,  78,  65,  68,  65,  124,
+    49,  57,  57,  56,  124, 50,  49,  57,  52,  53,  48,  57,  46,  48,  52,
+    54,  53,  10,  67,  65,  78,  65,  68,  65,  124, 49,  57,  57,  55,  124,
+    51,  52,  56,  50,  49,  57,  55,  46,  57,  53,  50,  49,  10,  67,  65,
+    78,  65,  68,  65,  124, 49,  57,  57,  54,  124, 51,  55,  49,  50,  50,
+    51,  49,  46,  50,  56,  49,  52,  10,  67,  65,  78,  65,  68,  65,  124,
+    49,  57,  57,  53,  124, 52,  48,  49,  52,  56,  49,  52,  46,  56,  52,
+    55,  54,  10,  67,  65,  78,  65,  68,  65,  124, 49,  57,  57,  52,  124,
+    52,  49,  52,  53,  51,  48,  52,  46,  52,  56,  53,  53,  10,  67,  65,
+    78,  65,  68,  65,  124, 49,  57,  57,  51,  124, 51,  55,  56,  55,  48,
+    54,  57,  46,  54,  48,  52,  53,  10,  67,  65,  78,  65,  68,  65,  124,
+    49,  57,  57,  50,  124, 52,  49,  54,  56,  48,  48,  57,  46,  52,  50,
+    48,  49,  10,  67,  72,  73,  78,  65,  124, 49,  57,  57,  56,  124, 51,
+    51,  57,  56,  53,  55,  56,  46,  48,  48,  48,  49,  10,  67,  72,  73,
+    78,  65,  124, 49,  57,  57,  55,  124, 54,  51,  53,  56,  57,  53,  57,
+    46,  51,  51,  51,  56,  10,  67,  72,  73,  78,  65,  124, 49,  57,  57,
+    54,  124, 54,  52,  51,  53,  49,  53,  56,  46,  51,  50,  50,  57,  10,
+    67,  72,  73,  78,  65,  124, 49,  57,  57,  53,  124, 54,  49,  55,  52,
+    55,  55,  54,  46,  50,  49,  49,  51,  10,  67,  72,  73,  78,  65,  124,
+    49,  57,  57,  52,  124, 54,  51,  56,  53,  55,  53,  49,  46,  48,  56,
+    49,  50,  10,  67,  72,  73,  78,  65,  124, 49,  57,  57,  51,  124, 53,
+    55,  54,  53,  48,  51,  52,  46,  49,  49,  57,  52,  10,  67,  72,  73,
+    78,  65,  124, 49,  57,  57,  50,  124, 54,  51,  50,  52,  48,  51,  52,
+    46,  50,  51,  55,  57,  10,  69,  71,  89,  80,  84,  124, 49,  57,  57,
+    56,  124, 50,  51,  51,  51,  49,  52,  56,  46,  51,  51,  51,  52,  10,
+    69,  71,  89,  80,  84,  124, 49,  57,  57,  55,  124, 51,  54,  54,  49,
+    50,  52,  52,  46,  50,  55,  51,  49,  10,  69,  71,  89,  80,  84,  124,
+    49,  57,  57,  54,  124, 51,  55,  54,  53,  51,  55,  49,  46,  50,  51,
+    54,  56,  10,  69,  71,  89,  80,  84,  124, 49,  57,  57,  53,  124, 52,
+    48,  57,  52,  55,  52,  52,  46,  50,  57,  50,  53,  10,  69,  71,  89,
+    80,  84,  124, 49,  57,  57,  52,  124, 51,  53,  54,  54,  53,  48,  56,
+    46,  48,  56,  49,  56,  10,  69,  71,  89,  80,  84,  124, 49,  57,  57,
+    51,  124, 51,  55,  50,  53,  50,  56,  51,  46,  55,  55,  52,  55,  10,
+    69,  71,  89,  80,  84,  124, 49,  57,  57,  50,  124, 51,  51,  55,  51,
+    55,  54,  50,  46,  51,  51,  51,  53,  10,  69,  84,  72,  73,  79,  80,
+    73,  65,  124, 49,  57,  57,  56,  124, 49,  57,  53,  51,  57,  50,  55,
+    46,  50,  54,  56,  50,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124,
+    49,  57,  57,  55,  124, 51,  50,  56,  53,  55,  56,  54,  46,  51,  50,
+    54,  54,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124, 49,  57,  57,
+    54,  124, 51,  53,  50,  53,  48,  50,  56,  46,  55,  57,  53,  50,  10,
+    69,  84,  72,  73,  79,  80,  73,  65,  124, 49,  57,  57,  53,  124, 51,
+    55,  56,  49,  54,  55,  52,  46,  56,  57,  49,  49,  10,  69,  84,  72,
+    73,  79,  80,  73,  65,  124, 49,  57,  57,  52,  124, 51,  48,  51,  55,
+    52,  48,  57,  46,  52,  51,  54,  48,  10,  69,  84,  72,  73,  79,  80,
+    73,  65,  124, 49,  57,  57,  51,  124, 51,  48,  48,  56,  57,  55,  56,
+    46,  50,  54,  55,  55,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124,
+    49,  57,  57,  50,  124, 50,  55,  50,  49,  50,  48,  51,  46,  50,  51,
+    53,  53,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  56,  124,
+    50,  54,  48,  52,  51,  55,  51,  46,  56,  56,  48,  53,  10,  70,  82,
+    65,  78,  67,  69,  124, 49,  57,  57,  55,  124, 51,  57,  56,  50,  56,
+    55,  50,  46,  48,  52,  56,  56,  10,  70,  82,  65,  78,  67,  69,  124,
+    49,  57,  57,  54,  124, 51,  54,  50,  50,  52,  55,  57,  46,  50,  52,
+    49,  51,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  53,  124,
+    52,  52,  55,  57,  57,  51,  57,  46,  55,  48,  50,  48,  10,  70,  82,
+    65,  78,  67,  69,  124, 49,  57,  57,  52,  124, 51,  53,  51,  49,  48,
+    49,  51,  46,  49,  57,  56,  49,  10,  70,  82,  65,  78,  67,  69,  124,
+    49,  57,  57,  51,  124, 52,  48,  56,  54,  52,  51,  55,  46,  51,  49,
+    48,  50,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  50,  124,
+    51,  54,  51,  55,  55,  57,  50,  46,  49,  51,  51,  51,  10,  71,  69,
+    82,  77,  65,  78,  89,  124, 49,  57,  57,  56,  124, 51,  50,  57,  49,
+    48,  50,  51,  46,  50,  57,  54,  53,  10,  71,  69,  82,  77,  65,  78,
+    89,  124, 49,  57,  57,  55,  124, 53,  49,  51,  57,  51,  51,  55,  46,
+    51,  52,  52,  51,  10,  71,  69,  82,  77,  65,  78,  89,  124, 49,  57,
+    57,  54,  124, 52,  55,  57,  57,  56,  49,  48,  46,  52,  53,  55,  55,
+    10,  71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,  53,  124, 53,
+    52,  48,  53,  55,  56,  53,  46,  55,  57,  55,  56,  10,  71,  69,  82,
+    77,  65,  78,  89,  124, 49,  57,  57,  52,  124, 52,  53,  53,  53,  53,
+    53,  54,  46,  52,  53,  57,  50,  10,  71,  69,  82,  77,  65,  78,  89,
+    124, 49,  57,  57,  51,  124, 52,  52,  50,  56,  49,  57,  53,  46,  49,
+    48,  49,  57,  10,  71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,
+    50,  124, 52,  54,  53,  54,  49,  52,  56,  46,  52,  50,  48,  52,  10,
+    73,  78,  68,  73,  65,  124, 49,  57,  57,  56,  124, 50,  53,  57,  49,
+    50,  56,  56,  46,  49,  56,  55,  52,  10,  73,  78,  68,  73,  65,  124,
+    49,  57,  57,  55,  124, 53,  49,  53,  57,  53,  54,  50,  46,  55,  48,
+    51,  51,  10,  73,  78,  68,  73,  65,  124, 49,  57,  57,  54,  124, 53,
+    51,  48,  55,  50,  53,  56,  46,  51,  48,  52,  57,  10,  73,  78,  68,
+    73,  65,  124, 49,  57,  57,  53,  124, 53,  49,  52,  56,  50,  48,  56,
+    46,  55,  57,  48,  50,  10,  73,  78,  68,  73,  65,  124, 49,  57,  57,
+    52,  124, 53,  49,  54,  52,  48,  48,  49,  46,  57,  53,  56,  50,  10,
+    73,  78,  68,  73,  65,  124, 49,  57,  57,  51,  124, 52,  51,  50,  49,
+    51,  57,  56,  46,  52,  51,  56,  56,  10,  73,  78,  68,  73,  65,  124,
+    49,  57,  57,  50,  124, 53,  50,  57,  55,  55,  48,  51,  46,  54,  57,
+    51,  53,  10,  73,  78,  68,  79,  78,  69,  83,  73,  65,  124, 49,  57,
+    57,  56,  124, 51,  48,  57,  52,  57,  48,  48,  46,  49,  53,  57,  55,
+    10,  73,  78,  68,  79,  78,  69,  83,  73,  65,  124, 49,  57,  57,  55,
+    124, 53,  55,  49,  57,  55,  55,  51,  46,  48,  51,  53,  56,  10,  73,
+    78,  68,  79,  78,  69,  83,  73,  65,  124, 49,  57,  57,  54,  124, 54,
+    48,  51,  55,  50,  51,  56,  46,  53,  57,  57,  51,  10,  73,  78,  68,
+    79,  78,  69,  83,  73,  65,  124, 49,  57,  57,  53,  124, 53,  50,  54,
+    54,  55,  56,  51,  46,  52,  56,  57,  57,  10,  73,  78,  68,  79,  78,
+    69,  83,  73,  65,  124, 49,  57,  57,  52,  124, 53,  52,  55,  48,  55,
+    54,  50,  46,  56,  55,  50,  57,  10,  73,  78,  68,  79,  78,  69,  83,
+    73,  65,  124, 49,  57,  57,  51,  124, 54,  49,  56,  57,  56,  50,  54,
+    46,  54,  54,  49,  51,  10,  73,  78,  68,  79,  78,  69,  83,  73,  65,
+    124, 49,  57,  57,  50,  124, 52,  52,  49,  52,  54,  50,  51,  46,  49,
+    53,  52,  57,  10,  73,  82,  65,  78,  124, 49,  57,  57,  56,  124, 51,
+    50,  49,  52,  56,  54,  52,  46,  49,  50,  48,  57,  10,  73,  82,  65,
+    78,  124, 49,  57,  57,  55,  124, 51,  54,  56,  56,  48,  52,  57,  46,
+    48,  54,  57,  49,  10,  73,  82,  65,  78,  124, 49,  57,  57,  54,  124,
+    51,  54,  50,  49,  54,  52,  57,  46,  50,  50,  52,  55,  10,  73,  82,
+    65,  78,  124, 49,  57,  57,  53,  124, 52,  52,  50,  48,  55,  56,  51,
+    46,  52,  50,  48,  53,  10,  73,  82,  65,  78,  124, 49,  57,  57,  52,
+    124, 52,  51,  55,  51,  57,  56,  52,  46,  54,  53,  50,  51,  10,  73,
+    82,  65,  78,  124, 49,  57,  57,  51,  124, 51,  55,  51,  49,  51,  48,
+    49,  46,  55,  56,  49,  52,  10,  73,  82,  65,  78,  124, 49,  57,  57,
+    50,  124, 52,  52,  49,  55,  49,  51,  51,  46,  51,  54,  54,  50,  10,
+    73,  82,  65,  81,  124, 49,  57,  57,  56,  124, 50,  51,  51,  56,  56,
+    53,  57,  46,  52,  48,  57,  57,  10,  73,  82,  65,  81,  124, 49,  57,
+    57,  55,  124, 51,  54,  50,  50,  54,  56,  49,  46,  53,  54,  52,  51,
+    10,  73,  82,  65,  81,  124, 49,  57,  57,  54,  124, 52,  55,  54,  50,
+    50,  57,  49,  46,  56,  55,  50,  50,  10,  73,  82,  65,  81,  124, 49,
+    57,  57,  53,  124, 52,  53,  53,  56,  48,  57,  50,  46,  55,  51,  53,
+    57,  10,  73,  82,  65,  81,  124, 49,  57,  57,  52,  124, 52,  57,  53,
+    49,  54,  48,  52,  46,  49,  54,  57,  57,  10,  73,  82,  65,  81,  124,
+    49,  57,  57,  51,  124, 51,  56,  51,  48,  48,  55,  55,  46,  57,  57,
+    49,  49,  10,  73,  82,  65,  81,  124, 49,  57,  57,  50,  124, 51,  57,
+    51,  56,  54,  51,  54,  46,  52,  56,  55,  52,  10,  74,  65,  80,  65,
+    78,  124, 49,  57,  57,  56,  124, 49,  56,  52,  57,  53,  51,  53,  46,
+    48,  56,  48,  50,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  55,
+    124, 52,  48,  54,  56,  54,  56,  56,  46,  56,  53,  51,  55,  10,  74,
+    65,  80,  65,  78,  124, 49,  57,  57,  54,  124, 52,  48,  52,  52,  55,
+    55,  52,  46,  55,  53,  57,  55,  10,  74,  65,  80,  65,  78,  124, 49,
+    57,  57,  53,  124, 52,  55,  57,  51,  48,  48,  53,  46,  56,  48,  50,
+    55,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  52,  124, 52,  49,
+    49,  52,  55,  49,  55,  46,  48,  53,  54,  56,  10,  74,  65,  80,  65,
+    78,  124, 49,  57,  57,  51,  124, 51,  54,  49,  52,  52,  54,  56,  46,
+    55,  52,  56,  53,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  50,
+    124, 52,  50,  54,  54,  54,  57,  52,  46,  52,  55,  48,  48,  10,  74,
+    79,  82,  68,  65,  78,  124, 49,  57,  57,  56,  124, 49,  56,  49,  49,
+    52,  56,  56,  46,  48,  55,  49,  57,  10,  74,  79,  82,  68,  65,  78,
+    124, 49,  57,  57,  55,  124, 50,  57,  53,  49,  50,  57,  55,  46,  56,
+    54,  55,  56,  10,  74,  79,  82,  68,  65,  78,  124, 49,  57,  57,  54,
+    124, 51,  51,  48,  50,  53,  50,  56,  46,  51,  48,  54,  55,  10,  74,
+    79,  82,  68,  65,  78,  124, 49,  57,  57,  53,  124, 51,  50,  50,  49,
+    56,  49,  51,  46,  57,  57,  57,  48,  10,  74,  79,  82,  68,  65,  78,
+    124, 49,  57,  57,  52,  124, 50,  52,  49,  55,  56,  57,  50,  46,  48,
+    57,  50,  49,  10,  74,  79,  82,  68,  65,  78,  124, 49,  57,  57,  51,
+    124, 51,  49,  48,  55,  54,  52,  49,  46,  55,  54,  54,  49,  10,  74,
+    79,  82,  68,  65,  78,  124, 49,  57,  57,  50,  124, 51,  51,  49,  54,
+    51,  55,  57,  46,  48,  53,  56,  53,  10,  75,  69,  78,  89,  65,  124,
+    49,  57,  57,  56,  124, 50,  53,  55,  57,  48,  55,  53,  46,  52,  49,
+    57,  48,  10,  75,  69,  78,  89,  65,  124, 49,  57,  57,  55,  124, 50,
+    57,  50,  57,  49,  57,  52,  46,  50,  51,  49,  55,  10,  75,  69,  78,
+    89,  65,  124, 49,  57,  57,  54,  124, 51,  53,  54,  57,  49,  50,  57,
+    46,  53,  54,  49,  57,  10,  75,  69,  78,  89,  65,  124, 49,  57,  57,
+    53,  124, 51,  53,  52,  50,  56,  56,  57,  46,  49,  48,  56,  55,  10,
+    75,  69,  78,  89,  65,  124, 49,  57,  57,  52,  124, 51,  57,  56,  51,
+    48,  57,  53,  46,  51,  57,  57,  52,  10,  75,  69,  78,  89,  65,  124,
+    49,  57,  57,  51,  124, 51,  55,  49,  51,  57,  56,  56,  46,  57,  55,
+    48,  56,  10,  75,  69,  78,  89,  65,  124, 49,  57,  57,  50,  124, 51,
+    51,  48,  52,  54,  52,  49,  46,  56,  51,  52,  48,  10,  77,  79,  82,
+    79,  67,  67,  79,  124, 49,  57,  57,  56,  124, 49,  56,  49,  53,  51,
+    51,  52,  46,  56,  49,  56,  48,  10,  77,  79,  82,  79,  67,  67,  79,
+    124, 49,  57,  57,  55,  124, 51,  54,  57,  51,  50,  49,  52,  46,  56,
+    52,  52,  55,  10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,
+    54,  124, 52,  49,  49,  54,  49,  55,  53,  46,  57,  50,  51,  48,  10,
+    77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,  53,  124, 51,  53,
+    49,  53,  49,  50,  55,  46,  49,  52,  48,  50,  10,  77,  79,  82,  79,
+    67,  67,  79,  124, 49,  57,  57,  52,  124, 52,  48,  48,  51,  48,  55,
+    50,  46,  49,  49,  50,  48,  10,  77,  79,  82,  79,  67,  67,  79,  124,
+    49,  57,  57,  51,  124, 51,  53,  57,  57,  49,  57,  57,  46,  54,  54,
+    55,  57,  10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,  50,
+    124, 51,  57,  53,  56,  51,  51,  53,  46,  52,  50,  50,  52,  10,  77,
+    79,  90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  56,  124,
+    49,  54,  50,  48,  52,  50,  56,  46,  55,  51,  52,  54,  10,  77,  79,
+    90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  55,  124, 50,
+    56,  48,  50,  49,  54,  54,  46,  54,  52,  55,  51,  10,  77,  79,  90,
+    65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  54,  124, 50,  52,
+    48,  57,  57,  53,  53,  46,  49,  55,  53,  53,  10,  77,  79,  90,  65,
+    77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  53,  124, 50,  55,  55,
+    49,  54,  48,  50,  46,  54,  50,  55,  52,  10,  77,  79,  90,  65,  77,
+    66,  73,  81,  85,  69,  124, 49,  57,  57,  52,  124, 50,  53,  52,  56,
+    50,  50,  54,  46,  50,  49,  53,  56,  10,  77,  79,  90,  65,  77,  66,
+    73,  81,  85,  69,  124, 49,  57,  57,  51,  124, 50,  56,  52,  51,  55,
+    52,  56,  46,  57,  48,  53,  51,  10,  77,  79,  90,  65,  77,  66,  73,
+    81,  85,  69,  124, 49,  57,  57,  50,  124, 50,  53,  53,  54,  53,  48,
+    49,  46,  48,  57,  52,  51,  10,  80,  69,  82,  85,  124, 49,  57,  57,
+    56,  124, 50,  48,  51,  54,  52,  51,  48,  46,  51,  54,  48,  50,  10,
+    80,  69,  82,  85,  124, 49,  57,  57,  55,  124, 52,  48,  54,  52,  49,
+    52,  50,  46,  52,  48,  57,  49,  10,  80,  69,  82,  85,  124, 49,  57,
+    57,  54,  124, 52,  48,  54,  56,  54,  55,  56,  46,  53,  54,  55,  49,
+    10,  80,  69,  82,  85,  124, 49,  57,  57,  53,  124, 52,  54,  53,  55,
+    54,  57,  52,  46,  56,  52,  49,  50,  10,  80,  69,  82,  85,  124, 49,
+    57,  57,  52,  124, 52,  55,  51,  49,  57,  53,  57,  46,  52,  54,  53,
+    53,  10,  80,  69,  82,  85,  124, 49,  57,  57,  51,  124, 52,  49,  52,
+    52,  48,  48,  54,  46,  54,  54,  49,  48,  10,  80,  69,  82,  85,  124,
+    49,  57,  57,  50,  124, 51,  55,  53,  52,  54,  51,  53,  46,  48,  48,
+    55,  56,  10,  82,  79,  77,  65,  78,  73,  65,  124, 49,  57,  57,  56,
+    124, 49,  57,  57,  50,  55,  55,  51,  46,  54,  56,  49,  49,  10,  82,
+    79,  77,  65,  78,  73,  65,  124, 49,  57,  57,  55,  124, 50,  56,  53,
+    52,  54,  51,  57,  46,  56,  54,  56,  48,  10,  82,  79,  77,  65,  78,
+    73,  65,  124, 49,  57,  57,  54,  124, 51,  49,  51,  57,  51,  51,  55,
+    46,  51,  48,  50,  57,  10,  82,  79,  77,  65,  78,  73,  65,  124, 49,
+    57,  57,  53,  124, 51,  50,  50,  50,  49,  53,  51,  46,  51,  55,  55,
+    54,  10,  82,  79,  77,  65,  78,  73,  65,  124, 49,  57,  57,  52,  124,
+    51,  50,  50,  50,  56,  52,  52,  46,  51,  49,  57,  48,  10,  82,  79,
+    77,  65,  78,  73,  65,  124, 49,  57,  57,  51,  124, 51,  52,  56,  56,
+    57,  57,  52,  46,  48,  50,  56,  56,  10,  82,  79,  77,  65,  78,  73,
+    65,  124, 49,  57,  57,  50,  124, 51,  48,  50,  57,  50,  55,  52,  46,
+    52,  52,  50,  48,  10,  82,  85,  83,  83,  73,  65,  124, 49,  57,  57,
+    56,  124, 50,  51,  51,  57,  56,  54,  53,  46,  54,  54,  51,  53,  10,
+    82,  85,  83,  83,  73,  65,  124, 49,  57,  57,  55,  124, 52,  49,  53,
+    51,  54,  49,  57,  46,  53,  52,  50,  52,  10,  82,  85,  83,  83,  73,
+    65,  124, 49,  57,  57,  54,  124, 51,  55,  55,  50,  48,  54,  55,  46,
+    52,  48,  52,  49,  10,  82,  85,  83,  83,  73,  65,  124, 49,  57,  57,
+    53,  124, 52,  55,  48,  52,  57,  56,  56,  46,  56,  54,  48,  55,  10,
+    82,  85,  83,  83,  73,  65,  124, 49,  57,  57,  52,  124, 52,  52,  55,
+    57,  48,  56,  50,  46,  56,  54,  57,  52,  10,  82,  85,  83,  83,  73,
+    65,  124, 49,  57,  57,  51,  124, 52,  55,  54,  55,  55,  49,  57,  46,
+    57,  55,  57,  49,  10,  82,  85,  83,  83,  73,  65,  124, 49,  57,  57,
+    50,  124, 52,  53,  51,  51,  52,  54,  53,  46,  53,  53,  57,  48,  10,
+    83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,  57,
+    57,  56,  124, 51,  51,  56,  54,  57,  52,  56,  46,  57,  53,  54,  52,
+    10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,
+    57,  57,  55,  124, 53,  52,  50,  53,  57,  56,  48,  46,  51,  51,  55,
+    51,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124,
+    49,  57,  57,  54,  124, 53,  50,  50,  55,  54,  48,  55,  46,  49,  54,
+    55,  55,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,
+    124, 49,  57,  57,  53,  124, 52,  53,  48,  54,  55,  51,  49,  46,  54,
+    52,  49,  49,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,
+    65,  124, 49,  57,  57,  52,  124, 52,  54,  57,  56,  54,  53,  56,  46,
+    55,  52,  50,  53,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,
+    73,  65,  124, 49,  57,  57,  51,  124, 53,  52,  57,  51,  54,  50,  54,
+    46,  53,  50,  56,  53,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,
+    66,  73,  65,  124, 49,  57,  57,  50,  124, 52,  53,  55,  51,  53,  54,
+    48,  46,  48,  49,  53,  48,  10,  85,  78,  73,  84,  69,  68,  32,  75,
+    73,  78,  71,  68,  79,  77,  124, 49,  57,  57,  56,  124, 50,  50,  53,
+    50,  48,  50,  49,  46,  53,  49,  51,  55,  10,  85,  78,  73,  84,  69,
+    68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  57,  55,  124,
+    52,  51,  52,  51,  57,  50,  54,  46,  56,  48,  50,  54,  10,  85,  78,
+    73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,
+    57,  54,  124, 52,  49,  56,  57,  52,  55,  54,  46,  51,  48,  54,  53,
+    10,  85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,
+    124, 49,  57,  57,  53,  124, 52,  52,  54,  57,  53,  54,  57,  46,  56,
+    56,  50,  57,  10,  85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,
+    68,  79,  77,  124, 49,  57,  57,  52,  124, 52,  52,  49,  48,  48,  57,
+    52,  46,  54,  50,  54,  52,  10,  85,  78,  73,  84,  69,  68,  32,  75,
+    73,  78,  71,  68,  79,  77,  124, 49,  57,  57,  51,  124, 52,  48,  53,
+    52,  54,  55,  55,  46,  49,  48,  53,  48,  10,  85,  78,  73,  84,  69,
+    68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  57,  50,  124,
+    51,  57,  55,  56,  54,  56,  56,  46,  56,  56,  51,  49,  10,  85,  78,
+    73,  84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,
+    56,  124, 50,  50,  51,  56,  55,  55,  49,  46,  53,  53,  56,  49,  10,
+    85,  78,  73,  84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,
+    57,  57,  55,  124, 52,  49,  51,  53,  53,  56,  49,  46,  53,  55,  51,
+    52,  10,  85,  78,  73,  84,  69,  68,  32,  83,  84,  65,  84,  69,  83,
+    124, 49,  57,  57,  54,  124, 51,  54,  50,  52,  48,  49,  51,  46,  50,
+    54,  54,  48,  10,  85,  78,  73,  84,  69,  68,  32,  83,  84,  65,  84,
+    69,  83,  124, 49,  57,  57,  53,  124, 51,  56,  57,  50,  50,  52,  52,
+    46,  53,  49,  55,  50,  10,  85,  78,  73,  84,  69,  68,  32,  83,  84,
+    65,  84,  69,  83,  124, 49,  57,  57,  52,  124, 51,  50,  56,  57,  50,
+    50,  52,  46,  49,  49,  51,  56,  10,  85,  78,  73,  84,  69,  68,  32,
+    83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  51,  124, 51,  54,  50,
+    54,  49,  55,  48,  46,  50,  48,  50,  56,  10,  85,  78,  73,  84,  69,
+    68,  32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  50,  124, 51,
+    57,  57,  51,  57,  55,  51,  46,  52,  57,  57,  55,  10,  86,  73,  69,
+    84,  78,  65,  77,  124, 49,  57,  57,  56,  124, 49,  57,  50,  52,  51,
+    49,  51,  46,  52,  56,  54,  50,  10,  86,  73,  69,  84,  78,  65,  77,
+    124, 49,  57,  57,  55,  124, 51,  52,  51,  54,  49,  57,  53,  46,  51,
+    55,  48,  57,  10,  86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,
+    54,  124, 52,  48,  49,  55,  50,  56,  56,  46,  56,  57,  50,  55,  10,
+    86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,  53,  124, 51,  54,
+    52,  52,  48,  53,  52,  46,  49,  51,  55,  50,  10,  86,  73,  69,  84,
+    78,  65,  77,  124, 49,  57,  57,  52,  124, 52,  49,  52,  49,  50,  55,
+    55,  46,  54,  54,  54,  53,  10,  86,  73,  69,  84,  78,  65,  77,  124,
+    49,  57,  57,  51,  124, 50,  53,  53,  54,  49,  49,  52,  46,  49,  54,
+    57,  51,  10,  86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,  50,
+    124, 52,  48,  57,  48,  53,  50,  52,  46,  52,  57,  48,  53,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q10[] = {
+    99,  95,  99,  117, 115, 116, 107, 101, 121, 124, 99,  95,  110, 97,  109,
+    101, 124, 114, 101, 118, 101, 110, 117, 101, 124, 99,  95,  97,  99,  99,
+    116, 98,  97,  108, 124, 110, 95,  110, 97,  109, 101, 124, 99,  95,  97,
+    100, 100, 114, 101, 115, 115, 124, 99,  95,  112, 104, 111, 110, 101, 124,
+    99,  95,  99,  111, 109, 109, 101, 110, 116, 10,  56,  50,  52,  50,  124,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  56,
+    50,  52,  50,  124, 54,  50,  50,  55,  56,  54,  46,  55,  50,  57,  55,
+    124, 54,  51,  50,  50,  46,  48,  57,  124, 69,  84,  72,  73,  79,  80,
+    73,  65,  124, 99,  89,  68,  87,  68,  105, 74,  116, 48,  54,  66,  56,
+    67,  89,  122, 88,  88,  50,  76,  56,  120, 50,  104, 110, 49,  86,  70,
+    71,  124, 49,  53,  45,  55,  57,  50,  45,  54,  55,  54,  45,  49,  49,
+    56,  52,  124, 115, 108, 121, 108, 121, 32,  114, 101, 103, 117, 108, 97,
+    114, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  104, 97,  103, 103,
+    108, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  105, 114,
+    111, 110, 105, 99,  32,  105, 100, 101, 97,  115, 46,  32,  99,  111, 117,
+    114, 116, 115, 32,  97,  114, 101, 32,  102, 117, 114, 105, 111, 117, 115,
+    108, 121, 46,  32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  117,
+    110, 117, 115, 117, 97,  108, 32,  116, 104, 101, 111, 100, 111, 108, 105,
+    116, 101, 115, 32,  99,  97,  106, 111, 108, 101, 46,  32,  105, 10,  55,
+    55,  49,  52,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  48,  48,  55,  55,  49,  52,  124, 53,  53,  55,  52,  48,  48,  46,
+    51,  48,  53,  51,  124, 57,  55,  57,  57,  46,  57,  56,  124, 73,  82,
+    65,  78,  124, 57,  68,  68,  105, 107, 113, 48,  56,  71,  69,  69,  52,
+    66,  51,  88,  124, 50,  48,  45,  57,  50,  50,  45,  52,  49,  56,  45,
+    54,  48,  50,  52,  124, 97,  114, 104, 111, 114, 115, 101, 115, 32,  97,
+    99,  99,  111, 114, 100, 105, 110, 103, 32,  116, 111, 32,  116, 104, 101,
+    32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  101, 120, 112, 114, 101,
+    115, 115, 32,  114, 101, 10,  49,  49,  48,  51,  50,  124, 67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  49,  49,  48,  51,  50,
+    124, 53,  49,  50,  53,  48,  48,  46,  57,  54,  52,  49,  124, 56,  52,
+    57,  54,  46,  57,  51,  124, 85,  78,  73,  84,  69,  68,  32,  75,  73,
+    78,  71,  68,  79,  77,  124, 53,  105, 103, 106, 111, 85,  103, 88,  111,
+    68,  85,  90,  86,  85,  73,  101, 99,  116, 76,  53,  108, 88,  79,  49,
+    84,  51,  65,  71,  75,  122, 97,  48,  102, 116, 124, 51,  51,  45,  49,
+    48,  50,  45,  55,  55,  50,  45,  51,  53,  51,  51,  124, 112, 111, 115,
+    105, 116, 115, 45,  45,  32,  102, 117, 114, 105, 111, 117, 115, 108, 121,
+    32,  105, 114, 111, 110, 105, 99,  32,  97,  99,  99,  111, 117, 110, 116,
+    115, 32,  97,  114, 101, 32,  97,  103, 97,  105, 110, 10,  50,  52,  53,
+    53,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,
+    48,  50,  52,  53,  53,  124, 52,  56,  49,  53,  57,  50,  46,  52,  48,
+    53,  51,  124, 50,  48,  55,  48,  46,  57,  57,  124, 71,  69,  82,  77,
+    65,  78,  89,  124, 97,  53,  68,  90,  49,  57,  57,  121, 102, 65,  99,
+    70,  104, 102, 105, 50,  117, 119, 66,  69,  32,  80,  75,  111, 44,  90,
+    124, 49,  55,  45,  57,  52,  54,  45,  50,  50,  53,  45,  57,  57,  55,
+    55,  124, 97,  108, 32,  97,  115, 121, 109, 112, 116, 111, 116, 101, 115,
+    46,  32,  102, 105, 110, 97,  108, 108, 121, 32,  105, 114, 111, 110, 105,
+    99,  32,  97,  99,  99,  111, 117, 110, 116, 115, 32,  99,  97,  106, 111,
+    108, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 46,  32,  112,
+    101, 114, 109, 97,  110, 101, 110, 116, 108, 121, 32,  117, 110, 117, 115,
+    117, 97,  108, 32,  116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115,
+    32,  97,  114, 111, 10,  49,  50,  49,  48,  54,  124, 67,  117, 115, 116,
+    111, 109, 101, 114, 35,  48,  48,  48,  48,  49,  50,  49,  48,  54,  124,
+    52,  55,  57,  52,  49,  52,  46,  50,  49,  51,  51,  124, 53,  51,  52,
+    50,  46,  49,  49,  124, 85,  78,  73,  84,  69,  68,  32,  83,  84,  65,
+    84,  69,  83,  124, 119, 121, 74,  88,  121, 119, 99,  69,  120, 85,  120,
+    116, 124, 51,  52,  45,  57,  48,  53,  45,  51,  52,  54,  45,  52,  52,
+    55,  50,  124, 108, 121, 32,  97,  102, 116, 101, 114, 32,  116, 104, 101,
+    32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  114, 101, 103, 117, 108,
+    97,  114, 32,  102, 111, 120, 101, 115, 46,  32,  97,  99,  99,  111, 117,
+    110, 116, 115, 32,  104, 97,  103, 103, 108, 101, 32,  99,  97,  114, 101,
+    102, 117, 108, 108, 121, 32,  97,  108, 111, 110, 103, 115, 105, 100, 101,
+    32,  111, 102, 32,  116, 104, 101, 32,  98,  108, 105, 116, 104, 101, 108,
+    121, 32,  101, 118, 101, 110, 32,  105, 100, 101, 97,  115, 46,  10,  56,
+    53,  51,  48,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  48,  48,  56,  53,  51,  48,  124, 52,  53,  55,  56,  53,  53,  46,
+    57,  52,  54,  55,  124, 57,  55,  51,  52,  46,  57,  53,  124, 77,  79,
+    82,  79,  67,  67,  79,  124, 108, 101, 97,  116, 121, 78,  82,  87,  67,
+    110, 102, 84,  77,  110, 84,  78,  117, 68,  71,  72,  115, 87,  74,  106,
+    82,  117, 65,  88,  124, 50,  53,  45,  55,  51,  54,  45,  57,  51,  50,
+    45,  53,  56,  53,  48,  124, 115, 108, 121, 108, 121, 32,  97,  115, 121,
+    109, 112, 116, 111, 116, 101, 115, 46,  32,  113, 117, 105, 99,  107, 108,
+    121, 32,  102, 105, 110, 97,  108, 32,  100, 101, 112, 111, 115, 105, 116,
+    115, 32,  105, 110, 10,  49,  51,  57,  56,  52,  124, 67,  117, 115, 116,
+    111, 109, 101, 114, 35,  48,  48,  48,  48,  49,  51,  57,  56,  52,  124,
+    52,  52,  54,  51,  49,  54,  46,  53,  49,  48,  52,  124, 51,  52,  56,
+    50,  46,  50,  56,  124, 73,  82,  65,  78,  124, 66,  49,  51,  118, 120,
+    82,  66,  111, 106, 119, 118, 80,  51,  124, 50,  48,  45,  57,  56,  49,
+    45,  50,  54,  52,  45,  50,  57,  53,  50,  124, 121, 32,  117, 110, 117,
+    115, 117, 97,  108, 32,  99,  111, 117, 114, 116, 115, 32,  99,  111, 117,
+    108, 100, 32,  119, 97,  107, 101, 32,  102, 117, 114, 105, 111, 117, 115,
+    108, 121, 10,  49,  57,  54,  54,  124, 67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  48,  49,  57,  54,  54,  124, 52,  52,  52,
+    48,  53,  57,  46,  48,  51,  56,  50,  124, 49,  57,  51,  55,  46,  55,
+    50,  124, 65,  76,  71,  69,  82,  73,  65,  124, 73,  98,  119, 90,  114,
+    55,  106, 32,  81,  86,  105, 102, 113, 102, 57,  87,  105, 122, 79,  73,
+    87,  120, 44,  85,  88,  86,  57,  67,  113, 120, 85,  121, 114, 119, 106,
+    124, 49,  48,  45,  57,  55,  51,  45,  50,  54,  57,  45,  56,  56,  56,
+    54,  124, 116, 104, 101, 32,  98,  108, 105, 116, 104, 101, 108, 121, 32,
+    101, 118, 101, 110, 32,  97,  99,  99,  111, 117, 110, 116, 115, 46,  32,
+    102, 105, 110, 97,  108, 32,  100, 101, 112, 111, 115, 105, 116, 115, 32,
+    99,  97,  106, 111, 108, 101, 32,  97,  114, 111, 117, 110, 100, 32,  116,
+    104, 101, 32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  102, 105, 110,
+    97,  108, 32,  112, 97,  99,  107, 97,  103, 101, 115, 46,  32,  10,  49,
+    49,  48,  50,  54,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,
+    48,  48,  48,  49,  49,  48,  50,  54,  124, 52,  49,  55,  57,  49,  51,
+    46,  52,  49,  52,  50,  124, 55,  55,  51,  56,  46,  55,  54,  124, 65,
+    76,  71,  69,  82,  73,  65,  124, 52,  67,  32,  105, 71,  122, 67,  104,
+    99,  113, 110, 104, 71,  66,  100, 101, 101, 117, 124, 49,  48,  45,  49,
+    56,  52,  45,  49,  54,  51,  45,  52,  54,  51,  50,  124, 108, 121, 32,
+    101, 118, 101, 110, 32,  100, 111, 108, 112, 104, 105, 110, 115, 32,  101,
+    97,  116, 32,  97,  108, 111, 110, 103, 32,  116, 104, 101, 32,  98,  108,
+    105, 116, 104, 101, 108, 121, 32,  101, 118, 101, 110, 32,  105, 110, 115,
+    116, 114, 117, 99,  116, 105, 111, 110, 115, 46,  32,  101, 120, 112, 114,
+    101, 115, 115, 32,  97,  116, 116, 97,  105, 110, 109, 101, 110, 116, 115,
+    32,  99,  97,  106, 111, 108, 101, 32,  115, 108, 121, 108, 121, 46,  32,
+    98,  117, 115, 121, 32,  100, 111, 108, 112, 104, 105, 110, 115, 32,  105,
+    110, 10,  56,  53,  48,  49,  124, 67,  117, 115, 116, 111, 109, 101, 114,
+    35,  48,  48,  48,  48,  48,  56,  53,  48,  49,  124, 52,  49,  50,  55,
+    57,  55,  46,  53,  49,  48,  48,  124, 54,  57,  48,  54,  46,  55,  48,
+    124, 65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 85,  84,  85,  81,
+    76,  88,  32,  99,  81,  114, 70,  49,  85,  85,  74,  80,  115, 122, 124,
+    49,  49,  45,  51,  49,  55,  45,  53,  53,  50,  45,  53,  56,  52,  48,
+    124, 121, 32,  102, 105, 110, 97,  108, 32,  100, 101, 112, 111, 115, 105,
+    116, 115, 32,  97,  102, 116, 101, 114, 32,  116, 104, 101, 32,  102, 108,
+    117, 102, 102, 105, 108, 121, 32,  101, 118, 101, 110, 32,  97,  99,  99,
+    111, 117, 110, 116, 115, 32,  97,  114, 101, 32,  115, 108, 121, 108, 121,
+    32,  102, 105, 110, 97,  108, 44,  32,  114, 101, 103, 117, 108, 97,  114,
+    10,  49,  53,  54,  53,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  48,  49,  53,  54,  53,  124, 52,  49,  50,  53,  48,
+    54,  46,  48,  48,  54,  50,  124, 49,  56,  50,  48,  46,  48,  51,  124,
+    66,  82,  65,  90,  73,  76,  124, 110, 52,  97,  99,  86,  112, 71,  48,
+    68,  101, 121, 106, 53,  97,  73,  70,  65,  102, 83,  78,  103, 32,  73,
+    117, 57,  99,  85,  97,  103, 119, 78,  51,  79,  115, 82,  98,  75,  67,
+    32,  52,  124, 49,  50,  45,  52,  48,  50,  45,  49,  55,  56,  45,  50,
+    48,  48,  55,  124, 111, 117, 115, 108, 121, 32,  114, 101, 103, 117, 108,
+    97,  114, 32,  97,  99,  99,  111, 117, 110, 116, 115, 32,  119, 97,  107,
+    101, 32,  115, 108, 121, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,
+    105, 100, 101, 97,  10,  49,  52,  51,  57,  56,  124, 67,  117, 115, 116,
+    111, 109, 101, 114, 35,  48,  48,  48,  48,  49,  52,  51,  57,  56,  124,
+    52,  48,  56,  53,  55,  53,  46,  51,  54,  48,  48,  124, 45,  54,  48,
+    50,  46,  50,  52,  124, 85,  78,  73,  84,  69,  68,  32,  83,  84,  65,
+    84,  69,  83,  124, 108, 52,  57,  111, 75,  106, 98,  106, 81,  72,  122,
+    54,  89,  90,  119, 106, 111, 53,  119, 80,  105, 104, 77,  32,  108, 121,
+    89,  79,  54,  71,  124, 51,  52,  45,  56,  49,  52,  45,  49,  49,  49,
+    45,  53,  52,  50,  52,  124, 115, 46,  32,  98,  108, 105, 116, 104, 101,
+    108, 121, 32,  101, 118, 101, 110, 32,  97,  99,  99,  111, 117, 110, 116,
+    115, 32,  99,  97,  106, 111, 108, 101, 32,  98,  108, 105, 116, 104, 101,
+    108, 121, 46,  32,  101, 118, 101, 110, 32,  102, 111, 120, 101, 115, 32,
+    100, 111, 117, 98,  116, 45,  45,  32,  10,  49,  52,  54,  53,  124, 67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  49,  52,
+    54,  53,  124, 52,  48,  53,  48,  53,  53,  46,  51,  52,  53,  55,  124,
+    57,  51,  54,  53,  46,  57,  51,  124, 73,  78,  68,  73,  65,  124, 122,
+    110, 57,  81,  55,  112, 84,  54,  75,  108, 81,  112, 51,  84,  53,  109,
+    85,  79,  53,  51,  51,  97,  113, 44,  124, 49,  56,  45,  56,  48,  55,
+    45,  52,  56,  55,  45,  49,  48,  55,  52,  124, 115, 32,  108, 111, 115,
+    101, 32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  105, 114, 111, 110,
+    105, 99,  44,  32,  114, 101, 103, 117, 108, 97,  114, 32,  112, 97,  99,
+    107, 97,  103, 101, 115, 46,  32,  114, 101, 103, 117, 108, 97,  114, 44,
+    32,  102, 105, 110, 97,  108, 32,  102, 111, 120, 101, 115, 32,  104, 97,
+    103, 103, 108, 101, 32,  99,  10,  49,  50,  53,  57,  53,  124, 67,  117,
+    115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  49,  50,  53,  57,
+    53,  124, 52,  48,  49,  52,  48,  50,  46,  50,  51,  57,  49,  124, 45,
+    54,  46,  57,  50,  124, 73,  78,  68,  73,  65,  124, 103, 69,  77,  81,
+    51,  87,  79,  57,  48,  118, 83,  100, 65,  103, 120, 76,  70,  114, 116,
+    57,  70,  82,  83,  124, 49,  56,  45,  49,  56,  54,  45,  49,  51,  50,
+    45,  51,  51,  53,  50,  124, 111, 32,  116, 104, 101, 32,  98,  117, 115,
+    121, 32,  97,  99,  99,  111, 117, 110, 116, 115, 46,  32,  98,  108, 105,
+    116, 104, 101, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 32,  103,
+    105, 102, 116, 115, 32,  109, 97,  105, 110, 116, 97,  105, 110, 32,  97,
+    10,  57,  54,  49,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  57,  54,  49,  124, 52,  48,  49,  49,  57,  56,
+    46,  49,  55,  51,  55,  124, 54,  57,  54,  51,  46,  54,  56,  124, 74,
+    65,  80,  65,  78,  124, 87,  48,  83,  90,  50,  111, 102, 108, 120, 57,
+    97,  87,  84,  103, 103, 116, 119, 83,  107, 51,  79,  69,  73,  88,  115,
+    117, 98,  88,  84,  98,  71,  98,  68,  124, 50,  50,  45,  57,  56,  57,
+    45,  52,  54,  51,  45,  54,  48,  56,  57,  124, 101, 32,  102, 105, 110,
+    97,  108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 58,  32,  98,  117,
+    115, 105, 108, 121, 32,  102, 105, 110, 97,  108, 32,  97,  99,  99,  111,
+    117, 110, 116, 115, 32,  98,  101, 108, 105, 101, 118, 101, 32,  97,  10,
+    49,  52,  50,  57,  57,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  49,  52,  50,  57,  57,  124, 52,  48,  48,  57,  54,
+    56,  46,  51,  55,  53,  49,  124, 54,  53,  57,  53,  46,  57,  55,  124,
+    82,  85,  83,  83,  73,  65,  124, 85,  70,  108, 79,  115, 56,  116, 81,
+    44,  73,  102, 90,  80,  74,  109, 53,  55,  124, 51,  50,  45,  49,  53,
+    54,  45,  54,  49,  56,  45,  49,  50,  50,  52,  124, 32,  99,  97,  114,
+    101, 102, 117, 108, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,
+    114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  113, 117, 105, 99,  107,
+    108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  97,  99,  99,  111, 117,
+    110, 116, 115, 32,  97,  103, 97,  105, 110, 115, 116, 32,  116, 104, 101,
+    32,  114, 117, 10,  54,  50,  51,  124, 67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  54,  50,  51,  124, 51,  57,  57,
+    56,  56,  51,  46,  52,  50,  53,  55,  124, 55,  56,  56,  55,  46,  54,
+    48,  124, 73,  78,  68,  79,  78,  69,  83,  73,  65,  124, 107, 51,  73,
+    108, 80,  83,  67,  52,  70,  75,  66,  49,  51,  32,  104, 99,  54,  111,
+    109, 104, 86,  115, 49,  105, 98,  118, 113, 101, 87,  69,  86,  124, 49,
+    57,  45,  49,  49,  51,  45,  50,  48,  50,  45,  55,  48,  56,  53,  124,
+    32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  100, 111, 108, 112,
+    104, 105, 110, 115, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101, 32,
+    98,  117, 115, 105, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,
+    100, 101, 112, 101, 110, 100, 101, 110, 99,  105, 101, 115, 32,  99,  97,
+    106, 111, 108, 101, 32,  97,  102, 116, 101, 114, 10,  57,  49,  53,  49,
+    124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,
+    57,  49,  53,  49,  124, 51,  57,  54,  53,  54,  50,  46,  48,  50,  57,
+    53,  124, 53,  54,  57,  49,  46,  57,  53,  124, 73,  82,  65,  81,  124,
+    85,  75,  105, 78,  57,  79,  81,  117, 112, 82,  44,  109, 53,  78,  116,
+    118, 83,  110, 116, 98,  73,  56,  74,  66,  101, 111, 124, 50,  49,  45,
+    56,  51,  52,  45,  49,  52,  55,  45,  52,  57,  48,  54,  124, 97,  106,
+    111, 108, 101, 32,  102, 108, 117, 102, 102, 105, 108, 121, 46,  32,  102,
+    117, 114, 105, 111, 117, 115, 108, 121, 32,  114, 101, 103, 117, 108, 97,
+    114, 32,  97,  99,  99,  111, 117, 110, 116, 115, 32,  97,  114, 101, 32,
+    115, 112, 101, 99,  105, 97,  108, 44,  32,  115, 105, 108, 101, 110, 116,
+    32,  97,  99,  99,  111, 117, 110, 116, 10,  49,  52,  56,  49,  57,  124,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  49,  52,
+    56,  49,  57,  124, 51,  57,  54,  50,  55,  49,  46,  49,  48,  51,  54,
+    124, 55,  51,  48,  56,  46,  51,  57,  124, 70,  82,  65,  78,  67,  69,
+    124, 119, 83,  56,  121, 105, 81,  116, 69,  54,  51,  70,  102, 111, 79,
+    54,  82,  75,  85,  122, 117, 86,  102, 54,  105, 66,  84,  109, 88,  66,
+    113, 49,  54,  117, 124, 49,  54,  45,  55,  54,  57,  45,  51,  57,  56,
+    45,  55,  57,  50,  54,  124, 115, 115, 44,  32,  102, 105, 110, 97,  108,
+    32,  97,  115, 121, 109, 112, 116, 111, 116, 101, 115, 32,  117, 115, 101,
+    32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  115, 108, 121, 108,
+    121, 32,  105, 114, 111, 110, 105, 99,  32,  100, 101, 112, 101, 110, 100,
+    101, 110, 99,  105, 101, 115, 46,  32,  115, 112, 101, 99,  105, 97,  108,
+    44,  32,  101, 120, 112, 114, 101, 115, 115, 32,  100, 117, 103, 111, 117,
+    116, 115, 32,  97,  99,  99,  111, 114, 100, 105, 110, 103, 32,  116, 111,
+    32,  116, 104, 101, 32,  100, 101, 112, 10,  49,  51,  52,  55,  56,  124,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  49,  51,
+    52,  55,  56,  124, 51,  57,  53,  53,  49,  51,  46,  49,  51,  53,  56,
+    124, 45,  55,  55,  56,  46,  49,  49,  124, 75,  69,  78,  89,  65,  124,
+    83,  53,  105, 122, 119, 106, 77,  49,  32,  104, 67,  111, 85,  99,  99,
+    79,  50,  74,  77,  101, 112, 89,  119, 78,  121, 66,  83,  113, 73,  44,
+    97,  121, 124, 50,  52,  45,  57,  56,  51,  45,  50,  48,  50,  45,  56,
+    50,  52,  48,  124, 114, 32,  116, 104, 101, 111, 100, 111, 108, 105, 116,
+    101, 115, 46,  32,  115, 108, 121, 108, 121, 32,  117, 110, 117, 115, 117,
+    97,  108, 32,  112, 105, 110, 116, 111, 32,  98,  101, 97,  110, 115, 32,
+    115, 108, 101, 101, 112, 32,  102, 108, 117, 102, 102, 105, 108, 121, 32,
+    97,  103, 97,  105, 110, 115, 116, 32,  116, 104, 101, 32,  97,  115, 121,
+    109, 112, 116, 111, 116, 101, 115, 46,  32,  113, 117, 105, 99,  107, 108,
+    121, 32,  114, 10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q11[] = {
+    112, 115, 95,  112, 97,  114, 116, 107, 101, 121, 124, 118, 97,  108, 117,
+    101, 10,  49,  50,  48,  57,  56,  124, 49,  54,  50,  50,  55,  54,  56,
+    49,  46,  50,  49,  10,  53,  49,  51,  52,  124, 49,  53,  55,  48,  57,
+    51,  51,  56,  46,  53,  50,  10,  49,  51,  51,  51,  52,  124, 49,  53,
+    48,  50,  51,  54,  54,  50,  46,  52,  49,  10,  49,  55,  48,  53,  50,
+    124, 49,  52,  51,  53,  49,  54,  52,  52,  46,  50,  48,  10,  51,  52,
+    53,  50,  124, 49,  52,  48,  55,  48,  56,  55,  48,  46,  49,  52,  10,
+    49,  50,  53,  53,  50,  124, 49,  51,  51,  51,  50,  52,  54,  57,  46,
+    49,  56,  10,  49,  48,  56,  52,  124, 49,  51,  49,  55,  48,  52,  50,
+    56,  46,  50,  57,  10,  53,  55,  57,  55,  124, 49,  51,  48,  51,  56,
+    54,  50,  50,  46,  55,  50,  10,  49,  50,  54,  51,  51,  124, 49,  50,
+    56,  57,  50,  53,  54,  49,  46,  54,  49,  10,  52,  48,  51,  124, 49,
+    50,  56,  53,  54,  50,  49,  55,  46,  51,  52,  10,  49,  56,  51,  51,
+    124, 49,  50,  48,  50,  52,  53,  56,  49,  46,  55,  50,  10,  50,  48,
+    56,  52,  124, 49,  49,  53,  48,  50,  56,  55,  53,  46,  51,  54,  10,
+    49,  55,  51,  52,  57,  124, 49,  49,  51,  53,  52,  50,  49,  51,  46,
+    48,  53,  10,  49,  56,  52,  50,  55,  124, 49,  49,  50,  56,  50,  51,
+    56,  53,  46,  50,  52,  10,  50,  56,  54,  48,  124, 49,  49,  50,  54,
+    50,  53,  50,  57,  46,  57,  53,  10,  49,  55,  56,  53,  50,  124, 49,
+    48,  57,  51,  52,  55,  49,  49,  46,  57,  51,  10,  57,  56,  55,  49,
+    124, 49,  48,  56,  56,  57,  50,  53,  51,  46,  54,  56,  10,  49,  50,
+    50,  51,  49,  124, 49,  48,  56,  52,  49,  49,  51,  49,  46,  51,  57,
+    10,  54,  51,  54,  54,  124, 49,  48,  55,  53,  57,  55,  56,  54,  46,
+    56,  49,  10,  49,  50,  49,  52,  54,  124, 49,  48,  50,  53,  55,  51,
+    54,  50,  46,  54,  54,  10,  53,  48,  52,  51,  124, 49,  48,  50,  50,
+    54,  51,  57,  53,  46,  56,  56,  10,  49,  50,  57,  54,  57,  124, 49,
+    48,  49,  50,  53,  55,  55,  55,  46,  57,  51,  10,  49,  53,  48,  52,
+    124, 49,  48,  48,  48,  52,  51,  57,  55,  46,  48,  56,  10,  49,  52,
+    51,  50,  55,  124, 57,  57,  56,  49,  54,  57,  55,  46,  48,  56,  10,
+    49,  51,  52,  124, 57,  57,  54,  53,  49,  53,  48,  46,  54,  54,  10,
+    54,  56,  54,  48,  124, 57,  56,  48,  53,  56,  55,  49,  46,  50,  54,
+    10,  49,  48,  54,  50,  52,  124, 57,  55,  55,  54,  49,  51,  56,  46,
+    52,  48,  10,  49,  53,  56,  49,  57,  124, 57,  55,  55,  53,  55,  48,
+    53,  46,  51,  49,  10,  51,  50,  57,  51,  124, 57,  54,  55,  52,  57,
+    50,  56,  46,  49,  50,  10,  49,  57,  56,  54,  53,  124, 57,  54,  53,
+    51,  55,  54,  54,  46,  56,  51,  10,  56,  56,  55,  48,  124, 57,  54,
+    52,  56,  57,  56,  49,  46,  56,  55,  10,  49,  53,  55,  55,  56,  124,
+    57,  54,  51,  54,  51,  51,  50,  46,  56,  50,  10,  49,  50,  51,  54,
+    48,  124, 57,  54,  51,  53,  48,  50,  51,  46,  57,  50,  10,  49,  52,
+    51,  56,  57,  124, 57,  52,  55,  53,  53,  56,  56,  46,  51,  52,  10,
+    51,  50,  53,  55,  124, 57,  52,  53,  49,  48,  50,  57,  46,  50,  52,
+    10,  57,  52,  55,  54,  124, 57,  52,  51,  53,  50,  48,  55,  46,  50,
+    56,  10,  49,  57,  54,  50,  57,  124, 57,  51,  57,  49,  50,  51,  54,
+    46,  52,  48,  10,  55,  49,  55,  57,  124, 57,  51,  56,  54,  50,  50,
+    50,  46,  50,  53,  10,  49,  53,  55,  50,  51,  124, 57,  51,  56,  51,
+    57,  48,  48,  46,  56,  48,  10,  52,  48,  53,  52,  124, 57,  51,  49,
+    51,  56,  49,  48,  46,  48,  50,  10,  50,  51,  56,  48,  124, 57,  51,
+    48,  55,  55,  53,  49,  46,  50,  50,  10,  49,  57,  48,  56,  52,  124,
+    57,  51,  48,  50,  57,  49,  54,  46,  56,  48,  10,  52,  55,  48,  51,
+    124, 57,  50,  56,  48,  56,  48,  52,  46,  56,  48,  10,  49,  56,  55,
+    57,  49,  124, 57,  50,  54,  55,  48,  49,  55,  46,  57,  55,  10,  49,
+    57,  57,  57,  52,  124, 57,  50,  51,  53,  57,  55,  50,  46,  57,  50,
+    10,  57,  49,  52,  57,  124, 57,  49,  50,  49,  56,  48,  51,  46,  57,
+    48,  10,  49,  53,  49,  49,  56,  124, 57,  49,  50,  48,  56,  49,  57,
+    46,  53,  48,  10,  54,  49,  49,  54,  124, 57,  48,  55,  57,  51,  54,
+    57,  46,  50,  48,  10,  55,  48,  53,  50,  124, 57,  48,  55,  55,  52,
+    54,  56,  46,  57,  50,  10,  49,  52,  49,  52,  55,  124, 57,  48,  54,
+    57,  49,  57,  51,  46,  55,  56,  10,  55,  51,  48,  53,  124, 57,  48,
+    51,  53,  50,  50,  56,  46,  53,  51,  10,  57,  49,  51,  48,  124, 57,
+    48,  50,  52,  51,  55,  57,  46,  50,  53,  10,  49,  54,  54,  57,  56,
+    124, 56,  57,  57,  49,  51,  51,  55,  46,  57,  53,  10,  49,  53,  53,
+    51,  124, 56,  57,  55,  55,  50,  50,  54,  46,  49,  48,  10,  49,  54,
+    55,  55,  55,  124, 56,  57,  54,  49,  51,  53,  53,  46,  54,  50,  10,
+    49,  52,  48,  50,  124, 56,  57,  53,  51,  55,  55,  57,  46,  49,  50,
+    10,  49,  56,  57,  54,  51,  124, 56,  57,  51,  52,  48,  54,  51,  46,
+    52,  48,  10,  56,  51,  53,  56,  124, 56,  57,  51,  48,  54,  49,  49,
+    46,  52,  56,  10,  49,  55,  53,  52,  55,  124, 56,  56,  54,  48,  49,
+    49,  55,  46,  48,  48,  10,  53,  49,  50,  56,  124, 56,  56,  52,  52,
+    50,  50,  50,  46,  55,  53,  10,  49,  55,  48,  54,  51,  124, 56,  56,
+    52,  48,  54,  52,  57,  46,  54,  48,  10,  49,  53,  52,  57,  48,  124,
+    56,  56,  51,  51,  53,  56,  49,  46,  52,  48,  10,  49,  52,  55,  54,
+    49,  124, 56,  56,  49,  55,  50,  52,  48,  46,  53,  54,  10,  49,  57,
+    54,  48,  49,  124, 56,  55,  57,  49,  51,  52,  49,  46,  48,  50,  10,
+    49,  54,  49,  54,  48,  124, 56,  55,  52,  48,  50,  54,  50,  46,  55,
+    54,  10,  49,  51,  53,  57,  55,  124, 56,  55,  48,  50,  54,  54,  57,
+    46,  56,  50,  10,  49,  51,  54,  53,  51,  124, 56,  54,  57,  51,  49,
+    55,  48,  46,  49,  54,  10,  49,  54,  51,  56,  51,  124, 56,  54,  57,
+    49,  53,  48,  53,  46,  57,  50,  10,  51,  50,  53,  124, 56,  54,  54,
+    55,  55,  52,  49,  46,  50,  56,  10,  56,  56,  55,  57,  124, 56,  54,
+    54,  55,  53,  56,  52,  46,  51,  56,  10,  49,  48,  53,  54,  52,  124,
+    56,  54,  54,  55,  48,  57,  56,  46,  50,  50,  10,  49,  55,  52,  50,
+    57,  124, 56,  54,  54,  49,  56,  50,  55,  46,  57,  48,  10,  49,  55,
+    52,  48,  51,  124, 56,  54,  52,  51,  51,  53,  48,  46,  51,  48,  10,
+    49,  56,  50,  57,  52,  124, 56,  54,  49,  54,  53,  56,  51,  46,  52,
+    51,  10,  52,  49,  56,  49,  124, 56,  53,  57,  50,  54,  56,  52,  46,
+    54,  54,  10,  49,  51,  48,  48,  56,  124, 56,  53,  54,  55,  52,  56,
+    48,  46,  54,  52,  10,  49,  51,  50,  49,  49,  124, 56,  53,  51,  55,
+    48,  48,  48,  46,  48,  49,  10,  49,  56,  56,  52,  124, 56,  53,  51,
+    50,  54,  52,  52,  46,  51,  52,  10,  49,  49,  49,  48,  49,  124, 56,
+    53,  51,  48,  57,  52,  53,  46,  51,  50,  10,  49,  49,  53,  54,  50,
+    124, 56,  53,  50,  56,  48,  50,  56,  46,  53,  55,  10,  49,  53,  56,
+    55,  56,  124, 56,  53,  50,  51,  53,  57,  49,  46,  56,  52,  10,  56,
+    51,  52,  124, 56,  53,  50,  50,  49,  51,  53,  46,  50,  55,  10,  50,
+    52,  50,  51,  124, 56,  53,  49,  55,  57,  48,  50,  46,  56,  53,  10,
+    49,  53,  51,  56,  51,  124, 56,  53,  49,  51,  52,  51,  51,  46,  49,
+    49,  10,  49,  56,  49,  49,  57,  124, 56,  53,  48,  55,  54,  49,  49,
+    46,  56,  48,  10,  55,  51,  56,  57,  124, 56,  53,  48,  54,  48,  57,
+    57,  46,  50,  48,  10,  53,  48,  49,  54,  124, 56,  52,  56,  57,  55,
+    56,  52,  46,  49,  53,  10,  49,  55,  52,  55,  51,  124, 56,  52,  52,
+    52,  55,  54,  54,  46,  50,  52,  10,  54,  54,  54,  57,  124, 56,  52,
+    50,  56,  54,  49,  56,  46,  52,  54,  10,  51,  56,  52,  124, 56,  52,
+    49,  56,  52,  55,  50,  46,  50,  55,  10,  49,  50,  48,  53,  50,  124,
+    56,  52,  49,  49,  53,  49,  57,  46,  50,  56,  10,  49,  55,  53,  54,
+    50,  124, 56,  52,  48,  57,  48,  50,  50,  46,  56,  51,  10,  56,  49,
+    50,  56,  124, 56,  51,  55,  57,  49,  52,  57,  46,  52,  55,  10,  49,
+    51,  56,  49,  51,  124, 56,  51,  55,  52,  56,  51,  48,  46,  56,  52,
+    10,  49,  50,  56,  48,  48,  124, 56,  51,  49,  56,  54,  50,  54,  46,
+    55,  56,  10,  49,  48,  56,  56,  55,  124, 56,  51,  49,  53,  48,  49,
+    57,  46,  51,  54,  10,  49,  54,  52,  52,  124, 56,  50,  56,  53,  52,
+    53,  51,  46,  48,  56,  10,  49,  54,  54,  51,  56,  124, 56,  50,  55,
+    52,  53,  54,  56,  46,  48,  48,  10,  49,  51,  57,  52,  124, 56,  50,
+    53,  53,  49,  52,  48,  46,  54,  48,  10,  55,  50,  49,  57,  124, 56,
+    50,  53,  52,  57,  56,  53,  46,  51,  48,  10,  49,  51,  51,  53,  56,
+    124, 56,  50,  53,  51,  56,  50,  57,  46,  56,  48,  10,  53,  53,  54,
+    50,  124, 56,  50,  53,  50,  51,  54,  53,  46,  49,  54,  10,  49,  52,
+    56,  54,  49,  124, 56,  50,  52,  50,  50,  57,  54,  46,  49,  53,  10,
+    49,  53,  52,  49,  54,  124, 56,  49,  57,  54,  54,  50,  49,  46,  53,
+    51,  10,  49,  57,  54,  51,  124, 56,  49,  57,  50,  50,  48,  54,  46,
+    54,  49,  10,  50,  56,  52,  49,  124, 56,  49,  52,  56,  54,  55,  56,
+    46,  52,  53,  10,  54,  54,  51,  53,  124, 56,  49,  50,  50,  57,  49,
+    56,  46,  50,  56,  10,  51,  54,  48,  57,  124, 56,  48,  57,  57,  56,
+    49,  50,  46,  48,  53,  10,  54,  51,  55,  50,  124, 56,  48,  57,  51,
+    54,  57,  53,  46,  48,  54,  10,  53,  50,  51,  49,  124, 56,  48,  57,
+    49,  55,  48,  52,  46,  49,  56,  10,  56,  55,  53,  53,  124, 56,  48,
+    56,  53,  48,  49,  55,  46,  48,  51,  10,  52,  48,  55,  49,  124, 56,
+    48,  56,  51,  55,  53,  53,  46,  49,  56,  10,  52,  57,  55,  55,  124,
+    56,  48,  53,  56,  53,  48,  49,  46,  55,  50,  10,  49,  49,  56,  55,
+    51,  124, 56,  48,  53,  55,  53,  52,  48,  46,  51,  48,  10,  49,  50,
+    49,  50,  55,  124, 56,  48,  53,  49,  49,  52,  50,  46,  57,  52,  10,
+    50,  52,  48,  49,  124, 56,  48,  52,  57,  53,  50,  53,  46,  57,  52,
+    10,  49,  53,  57,  54,  52,  124, 56,  48,  51,  55,  53,  52,  55,  46,
+    55,  53,  10,  49,  48,  49,  50,  57,  124, 56,  48,  51,  48,  56,  53,
+    53,  46,  48,  52,  10,  55,  54,  48,  53,  124, 56,  48,  50,  56,  54,
+    50,  50,  46,  52,  50,  10,  57,  51,  50,  55,  124, 56,  48,  50,  50,
+    50,  57,  49,  46,  51,  48,  10,  49,  49,  56,  49,  52,  124, 55,  57,
+    56,  51,  53,  56,  57,  46,  53,  57,  10,  52,  54,  52,  54,  124, 55,
+    57,  56,  49,  54,  54,  48,  46,  54,  48,  10,  54,  48,  51,  50,  124,
+    55,  57,  56,  49,  53,  49,  49,  46,  50,  56,  10,  49,  48,  55,  54,
+    124, 55,  57,  55,  55,  48,  55,  52,  46,  55,  53,  10,  52,  48,  52,
+    51,  124, 55,  57,  55,  49,  57,  50,  57,  46,  57,  48,  10,  56,  57,
+    51,  50,  124, 55,  57,  54,  55,  50,  50,  50,  46,  49,  57,  10,  49,
+    51,  55,  48,  53,  124, 55,  57,  53,  51,  51,  52,  52,  46,  53,  50,
+    10,  49,  54,  56,  53,  53,  124, 55,  57,  50,  51,  56,  49,  57,  46,
+    48,  48,  10,  51,  50,  51,  52,  124, 55,  57,  50,  48,  48,  50,  50,
+    46,  48,  48,  10,  49,  55,  55,  53,  50,  124, 55,  57,  48,  49,  51,
+    54,  50,  46,  55,  55,  10,  50,  48,  57,  55,  124, 55,  56,  57,  50,
+    57,  57,  51,  46,  49,  55,  10,  49,  56,  53,  57,  57,  124, 55,  56,
+    57,  48,  55,  55,  52,  46,  52,  48,  10,  49,  57,  53,  57,  54,  124,
+    55,  56,  55,  52,  53,  54,  52,  46,  53,  57,  10,  49,  49,  51,  57,
+    50,  124, 55,  56,  54,  49,  49,  55,  50,  46,  52,  56,  10,  49,  56,
+    49,  50,  49,  124, 55,  56,  53,  55,  53,  56,  49,  46,  54,  48,  10,
+    49,  55,  52,  53,  50,  124, 55,  56,  51,  56,  52,  54,  53,  46,  51,
+    54,  10,  54,  48,  55,  54,  124, 55,  56,  50,  49,  51,  49,  54,  46,
+    56,  48,  10,  49,  53,  49,  51,  52,  124, 55,  56,  48,  52,  55,  54,
+    48,  46,  50,  53,  10,  56,  54,  52,  49,  124, 55,  56,  48,  50,  57,
+    49,  55,  46,  49,  53,  10,  50,  49,  51,  52,  124, 55,  56,  48,  48,
+    49,  56,  53,  46,  52,  51,  10,  49,  54,  51,  53,  50,  124, 55,  55,
+    57,  55,  49,  49,  50,  46,  48,  48,  10,  49,  57,  51,  49,  50,  124,
+    55,  55,  55,  53,  57,  53,  50,  46,  50,  52,  10,  50,  56,  57,  53,
+    124, 55,  55,  53,  57,  51,  50,  55,  46,  50,  51,  10,  49,  50,  56,
+    54,  48,  124, 55,  55,  53,  56,  49,  51,  53,  46,  50,  49,  10,  49,
+    53,  51,  124, 55,  55,  53,  53,  54,  56,  49,  46,  50,  56,  10,  49,
+    53,  48,  56,  57,  124, 55,  55,  51,  53,  52,  51,  56,  46,  50,  54,
+    10,  49,  52,  55,  57,  55,  124, 55,  55,  50,  53,  51,  53,  51,  46,
+    49,  54,  10,  49,  53,  57,  52,  54,  124, 55,  55,  50,  50,  55,  55,
+    51,  46,  56,  56,  10,  49,  48,  57,  49,  57,  124, 55,  55,  50,  50,
+    52,  50,  53,  46,  51,  54,  10,  57,  56,  54,  55,  124, 55,  55,  50,
+    49,  53,  57,  55,  46,  55,  56,  10,  49,  49,  56,  56,  49,  124, 55,
+    55,  49,  51,  49,  51,  54,  46,  52,  50,  10,  49,  54,  53,  53,  50,
+    124, 55,  55,  48,  56,  53,  49,  56,  46,  49,  53,  10,  54,  57,  50,
+    53,  124, 55,  55,  48,  51,  57,  57,  57,  46,  54,  56,  10,  49,  50,
+    49,  52,  55,  124, 55,  55,  48,  51,  56,  50,  54,  46,  57,  56,  10,
+    56,  57,  50,  51,  124, 55,  55,  48,  50,  54,  57,  48,  46,  50,  56,
+    10,  49,  54,  49,  49,  54,  124, 55,  54,  57,  55,  57,  55,  48,  46,
+    56,  52,  10,  49,  48,  54,  54,  49,  124, 55,  54,  55,  51,  56,  51,
+    48,  46,  50,  48,  10,  49,  55,  48,  57,  52,  124, 55,  54,  54,  53,
+    51,  54,  56,  46,  49,  54,  10,  49,  56,  54,  52,  56,  124, 55,  54,
+    53,  48,  56,  54,  50,  46,  48,  50,  10,  49,  50,  49,  55,  50,  124,
+    55,  54,  52,  49,  51,  50,  54,  46,  52,  48,  10,  49,  53,  49,  50,
+    51,  124, 55,  54,  51,  51,  48,  51,  50,  46,  53,  48,  10,  52,  57,
+    57,  51,  124, 55,  54,  48,  48,  53,  55,  48,  46,  56,  48,  10,  49,
+    55,  49,  54,  50,  124, 55,  53,  57,  50,  48,  54,  50,  46,  53,  54,
+    10,  49,  51,  53,  48,  54,  124, 55,  53,  56,  48,  56,  48,  57,  46,
+    56,  51,  10,  51,  52,  51,  54,  124, 55,  53,  55,  53,  54,  49,  54,
+    46,  51,  51,  10,  54,  50,  55,  49,  124, 55,  53,  53,  57,  55,  57,
+    51,  46,  57,  51,  10,  49,  51,  51,  49,  52,  124, 55,  53,  53,  53,
+    49,  53,  54,  46,  54,  51,  10,  49,  55,  50,  52,  50,  124, 55,  53,
+    53,  48,  57,  52,  57,  46,  53,  48,  10,  50,  55,  53,  51,  124, 55,
+    53,  52,  57,  53,  55,  52,  46,  48,  54,  10,  55,  51,  57,  49,  124,
+    55,  53,  52,  51,  49,  53,  57,  46,  54,  56,  10,  55,  52,  49,  56,
+    124, 55,  53,  52,  49,  52,  52,  57,  46,  54,  53,  10,  49,  49,  54,
+    124, 55,  53,  50,  48,  56,  55,  52,  46,  50,  52,  10,  49,  50,  52,
+    51,  54,  124, 55,  53,  50,  48,  50,  51,  52,  46,  53,  52,  10,  49,
+    49,  56,  49,  124, 55,  52,  57,  52,  55,  57,  56,  46,  50,  56,  10,
+    49,  50,  57,  54,  51,  124, 55,  52,  57,  49,  50,  52,  56,  46,  49,
+    48,  10,  50,  49,  51,  124, 55,  52,  55,  57,  52,  55,  48,  46,  50,
+    56,  10,  55,  49,  49,  52,  124, 55,  52,  55,  55,  54,  56,  49,  46,
+    50,  48,  10,  49,  56,  53,  50,  49,  124, 55,  52,  55,  54,  52,  55,
+    56,  46,  51,  48,  10,  56,  57,  55,  51,  124, 55,  52,  53,  56,  54,
+    48,  51,  46,  54,  55,  10,  52,  50,  48,  50,  124, 55,  52,  53,  52,
+    48,  57,  53,  46,  55,  52,  10,  49,  50,  48,  48,  57,  124, 55,  52,
+    52,  50,  49,  48,  53,  46,  52,  48,  10,  49,  48,  54,  48,  57,  124,
+    55,  52,  50,  57,  51,  52,  54,  46,  52,  48,  10,  53,  54,  50,  50,
+    124, 55,  52,  50,  52,  49,  52,  50,  46,  54,  54,  10,  53,  49,  52,
+    51,  124, 55,  52,  50,  50,  55,  54,  48,  46,  50,  56,  10,  56,  57,
+    56,  124, 55,  52,  49,  52,  49,  51,  51,  46,  56,  48,  10,  49,  50,
+    50,  53,  55,  124, 55,  52,  48,  56,  49,  57,  48,  46,  54,  51,  10,
+    54,  55,  52,  48,  124, 55,  52,  48,  48,  51,  53,  48,  46,  51,  53,
+    10,  49,  49,  52,  54,  124, 55,  51,  57,  52,  51,  57,  52,  46,  52,
+    56,  10,  53,  52,  56,  53,  124, 55,  51,  55,  56,  49,  56,  49,  46,
+    57,  52,  10,  56,  52,  51,  55,  124, 55,  51,  55,  54,  51,  53,  51,
+    46,  53,  57,  10,  54,  53,  51,  49,  124, 55,  51,  54,  50,  51,  54,
+    54,  46,  55,  56,  10,  49,  54,  52,  54,  51,  124, 55,  51,  54,  50,
+    49,  48,  54,  46,  56,  48,  10,  49,  48,  52,  49,  50,  124, 55,  51,
+    53,  57,  53,  53,  50,  46,  52,  50,  10,  49,  50,  56,  53,  55,  124,
+    55,  51,  52,  48,  56,  48,  49,  46,  53,  56,  10,  49,  50,  51,  53,
+    52,  124, 55,  51,  51,  50,  51,  52,  51,  46,  50,  48,  10,  55,  54,
+    49,  54,  124, 55,  51,  50,  48,  48,  51,  50,  46,  51,  55,  10,  51,
+    52,  50,  54,  124, 55,  51,  49,  50,  51,  52,  48,  46,  52,  49,  10,
+    56,  54,  50,  50,  124, 55,  51,  48,  55,  50,  54,  54,  46,  51,  51,
+    10,  54,  56,  49,  56,  124, 55,  51,  48,  52,  55,  56,  50,  46,  49,
+    48,  10,  51,  55,  48,  53,  124, 55,  50,  57,  57,  51,  56,  48,  46,
+    49,  48,  10,  49,  50,  55,  51,  51,  124, 55,  50,  57,  56,  51,  57,
+    56,  46,  49,  55,  10,  49,  53,  55,  52,  124, 55,  50,  57,  51,  52,
+    52,  54,  46,  48,  52,  10,  49,  48,  53,  53,  52,  124, 55,  50,  56,
+    57,  57,  51,  51,  46,  55,  50,  10,  57,  51,  54,  51,  124, 55,  50,
+    56,  52,  54,  52,  55,  46,  55,  48,  10,  52,  54,  49,  49,  124, 55,
+    50,  56,  50,  49,  49,  53,  46,  48,  48,  10,  55,  56,  53,  55,  124,
+    55,  50,  54,  54,  57,  52,  56,  46,  57,  50,  10,  57,  54,  49,  54,
+    124, 55,  50,  54,  53,  48,  48,  53,  46,  51,  48,  10,  49,  53,  56,
+    54,  48,  124, 55,  50,  53,  52,  52,  54,  54,  46,  54,  54,  10,  49,
+    53,  53,  53,  52,  124, 55,  50,  52,  55,  53,  57,  50,  46,  53,  49,
+    10,  51,  52,  50,  50,  124, 55,  50,  52,  55,  53,  56,  54,  46,  52,
+    53,  10,  57,  49,  51,  52,  124, 55,  50,  51,  54,  52,  48,  52,  46,
+    54,  55,  10,  49,  55,  52,  48,  56,  124, 55,  50,  50,  48,  48,  56,
+    51,  46,  54,  48,  10,  49,  53,  56,  53,  51,  124, 55,  50,  49,  57,
+    57,  56,  52,  46,  57,  48,  10,  57,  50,  54,  54,  124, 55,  50,  49,
+    56,  53,  49,  55,  46,  49,  49,  10,  49,  56,  56,  49,  124, 55,  50,
+    48,  56,  51,  52,  54,  46,  52,  53,  10,  49,  48,  49,  52,  56,  124,
+    55,  50,  48,  53,  51,  51,  53,  46,  56,  51,  10,  56,  56,  54,  48,
+    124, 55,  50,  48,  50,  52,  48,  49,  46,  52,  52,  10,  56,  51,  55,
+    51,  124, 55,  49,  56,  57,  48,  51,  57,  46,  53,  48,  10,  49,  48,
+    56,  53,  57,  124, 55,  49,  56,  56,  57,  57,  48,  46,  54,  57,  10,
+    49,  50,  54,  55,  48,  124, 55,  49,  56,  56,  49,  55,  55,  46,  50,
+    50,  10,  50,  53,  53,  51,  124, 55,  49,  56,  48,  48,  48,  54,  46,
+    48,  50,  10,  49,  57,  51,  52,  54,  124, 55,  49,  55,  54,  55,  57,
+    55,  46,  50,  53,  10,  49,  54,  56,  49,  124, 55,  49,  54,  48,  49,
+    54,  57,  46,  56,  52,  10,  49,  53,  50,  50,  53,  124, 55,  49,  53,
+    56,  56,  54,  49,  46,  51,  50,  10,  49,  48,  53,  50,  124, 55,  49,
+    53,  56,  53,  56,  54,  46,  48,  48,  10,  55,  55,  124, 55,  49,  53,
+    53,  53,  51,  49,  46,  49,  48,  10,  55,  50,  51,  49,  124, 55,  49,
+    53,  53,  50,  53,  48,  46,  51,  56,  10,  49,  50,  54,  50,  50,  124,
+    55,  49,  51,  55,  52,  48,  56,  46,  52,  50,  10,  57,  56,  49,  52,
+    124, 55,  49,  48,  53,  51,  54,  51,  46,  49,  52,  10,  56,  54,  57,
+    53,  124, 55,  49,  48,  51,  49,  56,  55,  46,  48,  48,  10,  49,  51,
+    49,  55,  52,  124, 55,  48,  57,  57,  49,  56,  50,  46,  53,  51,  10,
+    54,  49,  55,  57,  124, 55,  48,  57,  53,  49,  51,  52,  46,  48,  53,
+    10,  54,  52,  53,  49,  124, 55,  48,  56,  50,  52,  57,  53,  46,  51,
+    54,  10,  49,  57,  56,  54,  48,  124, 55,  48,  55,  51,  50,  48,  54,
+    46,  56,  51,  10,  57,  51,  48,  55,  124, 55,  48,  53,  57,  57,  55,
+    51,  46,  54,  56,  10,  55,  56,  49,  57,  124, 55,  48,  53,  53,  57,
+    54,  51,  46,  48,  52,  10,  49,  48,  53,  53,  54,  124, 55,  48,  53,
+    51,  52,  57,  49,  46,  48,  55,  10,  57,  51,  54,  54,  124, 55,  48,
+    52,  56,  54,  57,  48,  46,  55,  52,  10,  49,  50,  49,  50,  52,  124,
+    55,  48,  52,  48,  48,  50,  49,  46,  51,  49,  10,  49,  49,  52,  55,
+    54,  124, 55,  48,  51,  55,  57,  48,  54,  46,  55,  54,  10,  49,  57,
+    50,  52,  53,  124, 55,  48,  51,  52,  48,  52,  53,  46,  50,  52,  10,
+    55,  53,  54,  50,  124, 55,  48,  51,  48,  50,  55,  53,  46,  55,  57,
+    10,  49,  50,  50,  57,  48,  124, 55,  48,  50,  48,  51,  55,  50,  46,
+    48,  54,  10,  49,  56,  49,  49,  56,  124, 55,  48,  48,  51,  51,  57,
+    54,  46,  56,  48,  10,  49,  50,  53,  51,  124, 55,  48,  48,  49,  53,
+    54,  57,  46,  54,  50,  10,  56,  54,  54,  50,  124, 54,  57,  57,  57,
+    56,  51,  52,  46,  50,  55,  10,  49,  55,  55,  57,  124, 54,  57,  57,
+    55,  51,  56,  53,  46,  55,  51,  10,  49,  53,  51,  56,  54,  124, 54,
+    57,  57,  54,  56,  55,  49,  46,  55,  57,  10,  49,  52,  55,  124, 54,
+    57,  56,  57,  48,  55,  57,  46,  56,  56,  10,  57,  53,  54,  50,  124,
+    54,  57,  56,  51,  48,  55,  54,  46,  57,  48,  10,  51,  57,  53,  56,
+    124, 54,  57,  54,  57,  56,  51,  51,  46,  50,  50,  10,  55,  50,  49,
+    49,  124, 54,  57,  54,  54,  54,  48,  54,  46,  54,  55,  10,  49,  50,
+    56,  52,  50,  124, 54,  57,  50,  51,  50,  55,  55,  46,  54,  54,  10,
+    52,  51,  54,  56,  124, 54,  57,  49,  56,  55,  56,  51,  46,  57,  53,
+    10,  49,  49,  49,  51,  49,  124, 54,  57,  49,  56,  54,  53,  54,  46,
+    55,  56,  10,  52,  54,  50,  56,  124, 54,  56,  57,  52,  56,  57,  51,
+    46,  56,  50,  10,  53,  56,  55,  57,  124, 54,  56,  56,  49,  51,  54,
+    55,  46,  49,  52,  10,  49,  54,  53,  56,  54,  124, 54,  56,  54,  53,
+    57,  51,  49,  46,  56,  48,  10,  51,  50,  124, 54,  56,  53,  50,  57,
+    50,  53,  46,  53,  57,  10,  49,  50,  49,  49,  57,  124, 54,  56,  52,
+    50,  55,  55,  51,  46,  55,  48,  10,  49,  51,  55,  49,  124, 54,  56,
+    51,  49,  49,  51,  55,  46,  53,  50,  10,  54,  49,  51,  54,  124, 54,
+    56,  50,  55,  57,  49,  55,  46,  48,  49,  10,  49,  51,  56,  53,  55,
+    124, 54,  56,  50,  52,  50,  52,  48,  46,  54,  48,  10,  49,  48,  55,
+    52,  124, 54,  56,  50,  49,  55,  52,  55,  46,  56,  56,  10,  49,  56,
+    54,  51,  124, 54,  56,  50,  49,  53,  50,  50,  46,  49,  57,  10,  49,
+    52,  53,  57,  55,  124, 54,  56,  49,  55,  51,  56,  53,  46,  54,  54,
+    10,  57,  50,  55,  49,  124, 54,  55,  56,  51,  48,  54,  56,  46,  56,
+    56,  10,  54,  51,  56,  57,  124, 54,  55,  56,  49,  48,  55,  53,  46,
+    54,  56,  10,  49,  49,  55,  48,  51,  124, 54,  55,  55,  54,  53,  51,
+    56,  46,  51,  54,  10,  49,  51,  55,  48,  49,  124, 54,  55,  54,  56,
+    56,  56,  48,  46,  53,  54,  10,  49,  52,  56,  56,  48,  124, 54,  55,
+    54,  51,  55,  56,  56,  46,  50,  52,  10,  49,  56,  52,  50,  56,  124,
+    54,  55,  54,  51,  54,  55,  48,  46,  53,  52,  10,  49,  48,  48,  54,
+    124, 54,  55,  54,  50,  48,  54,  53,  46,  57,  52,  10,  52,  57,  50,
+    55,  124, 54,  55,  53,  54,  55,  54,  53,  46,  50,  49,  10,  49,  49,
+    54,  53,  57,  124, 54,  55,  53,  53,  50,  52,  54,  46,  54,  56,  10,
+    54,  56,  49,  53,  124, 54,  55,  51,  56,  57,  50,  56,  46,  51,  53,
+    10,  49,  52,  51,  54,  55,  124, 54,  55,  51,  51,  56,  53,  55,  46,
+    50,  48,  10,  49,  48,  55,  48,  51,  124, 54,  55,  51,  48,  57,  51,
+    54,  46,  52,  54,  10,  51,  49,  53,  48,  124, 54,  55,  50,  55,  57,
+    50,  48,  46,  52,  48,  10,  57,  57,  54,  51,  124, 54,  55,  50,  53,
+    57,  49,  57,  46,  51,  53,  10,  49,  48,  52,  51,  56,  124, 54,  55,
+    49,  48,  49,  53,  51,  46,  54,  50,  10,  52,  55,  52,  53,  124, 54,
+    54,  56,  50,  49,  53,  51,  46,  54,  55,  10,  49,  53,  50,  57,  55,
+    124, 54,  54,  56,  49,  55,  49,  49,  46,  50,  56,  10,  49,  48,  56,
+    52,  56,  124, 54,  54,  55,  56,  54,  54,  54,  46,  50,  53,  10,  49,
+    49,  55,  52,  57,  124, 54,  54,  55,  55,  56,  57,  53,  46,  55,  51,
+    10,  49,  54,  55,  51,  57,  124, 54,  54,  55,  53,  53,  52,  57,  46,
+    49,  50,  10,  49,  52,  57,  49,  53,  124, 54,  54,  55,  50,  50,  52,
+    56,  46,  54,  54,  10,  49,  57,  56,  52,  49,  124, 54,  54,  54,  57,
+    49,  57,  49,  46,  50,  48,  10,  54,  50,  56,  124, 54,  54,  54,  54,
+    56,  57,  50,  46,  57,  48,  10,  49,  54,  53,  48,  124, 54,  54,  53,
+    55,  49,  55,  56,  46,  51,  50,  10,  55,  48,  54,  57,  124, 54,  54,
+    52,  56,  54,  55,  50,  46,  50,  52,  10,  55,  49,  48,  56,  124, 54,
+    54,  52,  54,  52,  52,  53,  46,  57,  54,  10,  56,  56,  56,  55,  124,
+    54,  54,  52,  49,  54,  53,  53,  46,  57,  48,  10,  49,  56,  55,  51,
+    53,  124, 54,  54,  51,  54,  52,  53,  55,  46,  53,  54,  10,  51,  55,
+    49,  49,  124, 54,  54,  51,  50,  54,  54,  53,  46,  51,  56,  10,  50,
+    51,  50,  53,  124, 54,  54,  51,  48,  52,  55,  53,  46,  57,  50,  10,
+    54,  52,  56,  52,  124, 54,  54,  50,  50,  57,  54,  53,  46,  50,  48,
+    10,  50,  54,  52,  51,  124, 54,  54,  49,  55,  51,  48,  52,  46,  57,
+    56,  10,  55,  56,  57,  53,  124, 54,  54,  49,  53,  48,  54,  49,  46,
+    50,  54,  10,  49,  50,  56,  52,  48,  124, 54,  54,  48,  52,  56,  52,
+    56,  46,  53,  52,  10,  52,  51,  49,  52,  124, 54,  54,  48,  48,  57,
+    48,  53,  46,  55,  49,  10,  49,  57,  48,  55,  55,  124, 54,  53,  57,
+    49,  48,  57,  49,  46,  57,  55,  10,  49,  55,  52,  55,  54,  124, 54,
+    53,  55,  54,  48,  50,  57,  46,  48,  48,  10,  55,  48,  51,  57,  124,
+    54,  53,  53,  57,  56,  51,  56,  46,  57,  48,  10,  56,  49,  48,  54,
+    124, 54,  53,  53,  56,  50,  50,  51,  46,  48,  50,  10,  50,  51,  57,
+    49,  124, 54,  53,  53,  55,  49,  50,  48,  46,  48,  56,  10,  55,  55,
+    49,  55,  124, 54,  53,  52,  55,  55,  48,  54,  46,  56,  56,  10,  49,
+    50,  52,  55,  54,  124, 54,  53,  52,  54,  57,  56,  56,  46,  49,  53,
+    10,  57,  49,  53,  53,  124, 54,  53,  52,  48,  55,  57,  51,  46,  54,
+    48,  10,  51,  54,  48,  124, 54,  53,  51,  48,  50,  57,  55,  46,  52,
+    49,  10,  54,  51,  56,  51,  124, 54,  53,  50,  57,  51,  51,  54,  46,
+    48,  50,  10,  52,  56,  51,  48,  124, 54,  53,  49,  56,  57,  57,  56,
+    46,  57,  50,  10,  49,  50,  54,  48,  48,  124, 54,  53,  49,  49,  53,
+    52,  57,  46,  52,  54,  10,  49,  51,  55,  52,  48,  124, 54,  53,  48,
+    56,  48,  53,  55,  46,  57,  50,  10,  52,  54,  55,  56,  124, 54,  53,
+    48,  55,  56,  52,  55,  46,  57,  56,  10,  49,  55,  56,  49,  53,  124,
+    54,  53,  48,  50,  50,  56,  52,  46,  55,  54,  10,  55,  51,  50,  57,
+    124, 54,  52,  57,  48,  56,  49,  49,  46,  57,  53,  10,  49,  51,  56,
+    56,  52,  124, 54,  52,  57,  48,  48,  54,  51,  46,  49,  48,  10,  53,
+    49,  52,  55,  124, 54,  52,  56,  55,  48,  54,  57,  46,  48,  48,  10,
+    49,  54,  53,  52,  56,  124, 54,  52,  56,  50,  48,  50,  52,  46,  53,
+    48,  10,  49,  52,  49,  52,  52,  124, 54,  52,  55,  54,  52,  49,  51,
+    46,  52,  48,  10,  49,  48,  49,  56,  49,  124, 54,  52,  55,  52,  57,
+    56,  52,  46,  56,  56,  10,  49,  49,  48,  51,  49,  124, 54,  52,  54,
+    51,  51,  48,  56,  46,  48,  50,  10,  49,  57,  57,  53,  56,  124, 54,
+    52,  54,  49,  53,  48,  54,  46,  51,  56,  10,  54,  48,  52,  51,  124,
+    54,  52,  53,  56,  49,  55,  55,  46,  54,  52,  10,  49,  48,  48,  54,
+    48,  124, 54,  52,  53,  53,  52,  55,  54,  46,  56,  57,  10,  57,  49,
+    52,  52,  124, 54,  52,  53,  52,  48,  52,  50,  46,  48,  53,  10,  55,
+    48,  52,  51,  124, 54,  52,  52,  56,  48,  49,  57,  46,  57,  56,  10,
+    49,  55,  51,  52,  54,  124, 54,  52,  52,  52,  51,  48,  55,  46,  53,
+    50,  10,  49,  51,  57,  54,  51,  124, 54,  52,  52,  50,  48,  49,  52,
+    46,  52,  56,  10,  55,  49,  49,  49,  124, 54,  52,  52,  49,  57,  52,
+    55,  46,  48,  55,  10,  49,  52,  49,  52,  48,  124, 54,  52,  51,  57,
+    57,  53,  53,  46,  53,  52,  10,  50,  51,  50,  55,  124, 54,  52,  51,
+    56,  57,  55,  55,  46,  50,  56,  10,  49,  52,  56,  49,  50,  124, 54,
+    52,  51,  55,  49,  53,  50,  46,  53,  52,  10,  49,  54,  55,  53,  53,
+    124, 54,  52,  51,  48,  56,  57,  53,  46,  51,  54,  10,  49,  52,  56,
+    52,  48,  124, 54,  52,  51,  48,  53,  52,  57,  46,  49,  52,  10,  49,
+    52,  49,  51,  52,  124, 54,  52,  50,  50,  48,  55,  57,  46,  50,  54,
+    10,  49,  50,  54,  53,  53,  124, 54,  52,  48,  53,  52,  57,  54,  46,
+    55,  57,  10,  49,  53,  49,  56,  124, 54,  51,  57,  48,  49,  52,  56,
+    46,  50,  50,  10,  57,  56,  56,  56,  124, 54,  51,  56,  53,  48,  51,
+    51,  46,  48,  50,  10,  55,  51,  56,  55,  124, 54,  51,  56,  52,  48,
+    48,  53,  46,  49,  56,  10,  53,  51,  57,  51,  124, 54,  51,  56,  49,
+    48,  56,  51,  46,  48,  52,  10,  49,  49,  48,  53,  55,  124, 54,  51,
+    55,  53,  57,  55,  52,  46,  50,  50,  10,  49,  54,  56,  49,  56,  124,
+    54,  51,  54,  56,  56,  50,  56,  46,  56,  48,  10,  52,  53,  55,  54,
+    124, 54,  51,  54,  52,  57,  50,  53,  46,  55,  49,  10,  49,  57,  54,
+    52,  52,  124, 54,  51,  53,  48,  48,  48,  48,  46,  51,  51,  10,  49,
+    51,  57,  124, 54,  51,  51,  54,  48,  54,  53,  46,  53,  53,  10,  49,
+    49,  55,  51,  53,  124, 54,  51,  51,  52,  51,  48,  53,  46,  57,  48,
+    10,  49,  48,  49,  48,  56,  124, 54,  51,  51,  50,  48,  53,  53,  46,
+    57,  57,  10,  49,  53,  54,  50,  56,  124, 54,  51,  50,  57,  56,  48,
+    49,  46,  51,  52,  10,  52,  51,  52,  57,  124, 54,  51,  49,  52,  57,
+    52,  57,  46,  54,  56,  10,  55,  48,  52,  56,  124, 54,  51,  49,  51,
+    56,  54,  56,  46,  53,  53,  10,  49,  55,  49,  49,  57,  124, 54,  50,
+    57,  56,  57,  51,  53,  46,  51,  56,  10,  49,  56,  53,  57,  55,  124,
+    54,  50,  57,  49,  52,  49,  54,  46,  51,  49,  10,  50,  52,  56,  56,
+    124, 54,  50,  56,  54,  51,  55,  50,  46,  48,  53,  10,  50,  50,  57,
+    54,  124, 54,  50,  55,  53,  53,  49,  57,  46,  50,  53,  10,  52,  51,
+    52,  51,  124, 54,  50,  55,  50,  56,  51,  52,  46,  50,  48,  10,  57,
+    57,  53,  56,  124, 54,  50,  54,  55,  55,  49,  52,  46,  54,  49,  10,
+    50,  49,  52,  55,  124, 54,  50,  54,  55,  52,  55,  53,  46,  51,  50,
+    10,  57,  51,  54,  56,  124, 54,  50,  53,  52,  53,  55,  56,  46,  57,
+    50,  10,  49,  51,  49,  51,  52,  124, 54,  50,  53,  50,  52,  51,  50,
+    46,  55,  54,  10,  49,  48,  49,  49,  57,  124, 54,  50,  53,  49,  52,
+    53,  54,  46,  50,  53,  10,  50,  48,  57,  51,  124, 54,  50,  52,  57,
+    51,  52,  50,  46,  51,  54,  10,  50,  51,  57,  50,  124, 54,  50,  51,
+    55,  52,  55,  54,  46,  53,  54,  10,  49,  55,  50,  51,  49,  124, 54,
+    50,  51,  51,  53,  48,  57,  46,  49,  56,  10,  51,  55,  55,  51,  124,
+    54,  50,  50,  54,  54,  53,  52,  46,  54,  56,  10,  57,  56,  51,  57,
+    124, 54,  50,  49,  52,  48,  52,  52,  46,  49,  48,  10,  49,  57,  51,
+    52,  57,  124, 54,  50,  49,  51,  57,  54,  57,  46,  51,  48,  10,  55,
+    56,  54,  57,  124, 54,  50,  49,  50,  55,  53,  49,  46,  48,  48,  10,
+    56,  49,  53,  56,  124, 54,  50,  49,  48,  50,  55,  57,  46,  50,  52,
+    10,  49,  51,  49,  55,  57,  124, 54,  50,  48,  53,  55,  55,  51,  46,
+    54,  53,  10,  50,  51,  52,  57,  124, 54,  50,  48,  53,  53,  56,  57,
+    46,  50,  54,  10,  57,  48,  53,  50,  124, 54,  50,  48,  48,  55,  50,
+    57,  46,  55,  48,  10,  49,  55,  52,  52,  124, 54,  49,  56,  57,  57,
+    54,  55,  46,  51,  54,  10,  53,  57,  55,  124, 54,  49,  56,  51,  49,
+    48,  51,  46,  52,  55,  10,  49,  54,  55,  50,  49,  124, 54,  49,  55,
+    54,  54,  48,  54,  46,  54,  48,  10,  55,  52,  57,  56,  124, 54,  49,
+    55,  54,  50,  55,  55,  46,  50,  53,  10,  49,  53,  49,  53,  55,  124,
+    54,  49,  55,  54,  50,  50,  50,  46,  53,  48,  10,  49,  55,  53,  50,
+    52,  124, 54,  49,  55,  49,  49,  48,  55,  46,  51,  54,  10,  55,  57,
+    50,  50,  124, 54,  49,  55,  48,  57,  48,  54,  46,  48,  55,  10,  54,
+    54,  49,  53,  124, 54,  49,  55,  48,  55,  51,  56,  46,  52,  50,  10,
+    50,  55,  48,  54,  124, 54,  49,  54,  53,  57,  57,  49,  46,  54,  53,
+    10,  49,  54,  52,  51,  50,  124, 54,  49,  54,  50,  55,  52,  48,  46,
+    54,  56,  10,  49,  54,  52,  55,  51,  124, 54,  49,  54,  50,  52,  50,
+    55,  46,  57,  54,  10,  49,  50,  56,  50,  53,  124, 54,  49,  54,  49,
+    53,  57,  53,  46,  54,  48,  10,  49,  56,  56,  49,  51,  124, 54,  49,
+    53,  52,  54,  55,  56,  46,  53,  53,  10,  49,  48,  51,  48,  124, 54,
+    49,  52,  54,  53,  48,  48,  46,  50,  56,  10,  50,  53,  55,  49,  124,
+    54,  49,  52,  53,  55,  55,  50,  46,  52,  51,  10,  55,  55,  48,  55,
+    124, 54,  49,  52,  52,  55,  53,  52,  46,  55,  49,  10,  49,  48,  51,
+    50,  55,  124, 54,  49,  51,  55,  54,  49,  50,  46,  48,  48,  10,  52,
+    55,  49,  48,  124, 54,  49,  51,  50,  51,  52,  54,  46,  53,  54,  10,
+    51,  54,  52,  57,  124, 54,  49,  51,  48,  54,  48,  50,  46,  54,  51,
+    10,  52,  56,  57,  51,  124, 54,  49,  50,  56,  52,  54,  49,  46,  50,
+    52,  10,  49,  50,  56,  52,  52,  124, 54,  49,  50,  56,  49,  57,  49,
+    46,  50,  52,  10,  56,  55,  57,  52,  124, 54,  49,  50,  50,  54,  57,
+    48,  46,  50,  56,  10,  49,  49,  53,  55,  124, 54,  49,  49,  55,  55,
+    52,  57,  46,  50,  50,  10,  49,  48,  56,  57,  53,  124, 54,  49,  49,
+    50,  48,  49,  55,  46,  54,  56,  10,  49,  54,  49,  54,  54,  124, 54,
+    49,  48,  56,  50,  53,  48,  46,  57,  56,  10,  49,  49,  57,  50,  48,
+    124, 54,  49,  48,  55,  49,  50,  50,  46,  53,  54,  10,  53,  54,  50,
+    49,  124, 54,  49,  48,  50,  49,  50,  51,  46,  53,  54,  10,  54,  49,
+    52,  49,  124, 54,  48,  57,  51,  56,  50,  54,  46,  53,  54,  10,  49,
+    52,  48,  55,  54,  124, 54,  48,  56,  54,  54,  55,  49,  46,  48,  56,
+    10,  49,  53,  56,  56,  52,  124, 54,  48,  56,  48,  52,  56,  53,  46,
+    53,  57,  10,  52,  56,  49,  52,  124, 54,  48,  56,  48,  51,  51,  55,
+    46,  57,  54,  10,  53,  56,  49,  52,  124, 54,  48,  55,  57,  56,  52,
+    50,  46,  57,  54,  10,  49,  49,  51,  52,  124, 54,  48,  55,  56,  54,
+    56,  53,  46,  50,  48,  10,  49,  57,  48,  52,  56,  124, 54,  48,  55,
+    49,  56,  49,  51,  46,  50,  56,  10,  51,  48,  51,  124, 54,  48,  55,
+    48,  54,  48,  49,  46,  51,  53,  10,  49,  53,  50,  49,  49,  124, 54,
+    48,  54,  53,  54,  55,  56,  46,  48,  54,  10,  49,  48,  50,  48,  124,
+    54,  48,  53,  52,  49,  54,  56,  46,  48,  48,  10,  49,  49,  50,  57,
+    50,  124, 54,  48,  53,  50,  53,  50,  50,  46,  56,  51,  10,  55,  49,
+    51,  52,  124, 54,  48,  52,  57,  56,  54,  53,  46,  50,  53,  10,  49,
+    52,  49,  49,  57,  124, 54,  48,  52,  57,  54,  49,  57,  46,  53,  53,
+    10,  50,  51,  56,  57,  124, 54,  48,  52,  50,  52,  50,  57,  46,  49,
+    50,  10,  53,  57,  50,  54,  124, 54,  48,  51,  52,  50,  54,  57,  46,
+    53,  50,  10,  56,  53,  53,  51,  124, 54,  48,  51,  48,  57,  50,  50,
+    46,  57,  53,  10,  49,  56,  56,  49,  52,  124, 54,  48,  50,  51,  50,
+    53,  53,  46,  49,  55,  10,  49,  50,  55,  48,  50,  124, 54,  48,  50,
+    51,  49,  57,  48,  46,  57,  57,  10,  50,  54,  52,  52,  124, 54,  48,
+    50,  48,  57,  51,  49,  46,  51,  51,  10,  49,  57,  54,  50,  56,  124,
+    54,  48,  49,  48,  55,  48,  52,  46,  48,  48,  10,  49,  56,  49,  49,
+    50,  124, 54,  48,  48,  56,  55,  48,  55,  46,  53,  50,  10,  49,  51,
+    56,  54,  48,  124, 54,  48,  48,  56,  49,  55,  48,  46,  50,  57,  10,
+    49,  52,  53,  54,  124, 54,  48,  48,  53,  48,  57,  50,  46,  49,  52,
+    10,  49,  54,  51,  51,  124, 54,  48,  48,  50,  48,  54,  56,  46,  56,
+    53,  10,  50,  51,  48,  49,  124, 54,  48,  48,  48,  51,  48,  50,  46,
+    50,  57,  10,  49,  48,  55,  52,  48,  124, 53,  57,  57,  57,  56,  48,
+    57,  46,  48,  53,  10,  50,  54,  51,  48,  124, 53,  57,  57,  55,  48,
+    48,  56,  46,  52,  51,  10,  56,  56,  49,  56,  124, 53,  57,  57,  50,
+    50,  57,  54,  46,  57,  48,  10,  49,  48,  48,  52,  51,  124, 53,  57,
+    57,  48,  53,  57,  52,  46,  48,  50,  10,  54,  53,  51,  124, 53,  57,
+    56,  55,  57,  52,  50,  46,  56,  51,  10,  54,  56,  50,  57,  124, 53,
+    57,  56,  53,  57,  57,  48,  46,  54,  54,  10,  49,  53,  49,  55,  57,
+    124, 53,  57,  55,  55,  55,  50,  55,  46,  53,  50,  10,  57,  54,  54,
+    51,  124, 53,  57,  55,  51,  53,  50,  51,  46,  57,  50,  10,  53,  56,
+    54,  51,  124, 53,  57,  55,  51,  51,  50,  56,  46,  57,  50,  10,  51,
+    54,  50,  56,  124, 53,  57,  54,  54,  51,  52,  48,  46,  48,  57,  10,
+    55,  54,  49,  56,  124, 53,  57,  54,  48,  49,  53,  53,  46,  56,  54,
+    10,  50,  53,  56,  56,  124, 53,  57,  53,  50,  54,  52,  56,  46,  53,
+    54,  10,  52,  56,  54,  53,  124, 53,  57,  52,  57,  51,  56,  51,  46,
+    52,  48,  10,  52,  50,  51,  51,  124, 53,  57,  52,  52,  54,  57,  57,
+    46,  54,  48,  10,  49,  51,  51,  57,  48,  124, 53,  57,  52,  52,  49,
+    48,  52,  46,  54,  57,  10,  49,  54,  51,  50,  49,  124, 53,  57,  52,
+    50,  55,  49,  52,  46,  55,  48,  10,  57,  54,  53,  51,  124, 53,  57,
+    52,  49,  51,  48,  56,  46,  53,  48,  10,  49,  56,  56,  56,  52,  124,
+    53,  57,  50,  53,  53,  52,  56,  46,  50,  52,  10,  52,  51,  57,  52,
+    124, 53,  57,  50,  48,  57,  50,  55,  46,  49,  52,  10,  49,  57,  55,
+    55,  52,  124, 53,  57,  49,  54,  55,  50,  51,  46,  49,  50,  10,  49,
+    50,  53,  55,  124, 53,  57,  49,  52,  48,  53,  50,  46,  51,  54,  10,
+    50,  57,  54,  51,  124, 53,  57,  49,  49,  57,  49,  55,  46,  55,  55,
+    10,  49,  55,  49,  53,  55,  124, 53,  56,  57,  57,  53,  55,  51,  46,
+    48,  50,  10,  51,  56,  51,  124, 53,  56,  56,  52,  54,  57,  51,  46,
+    51,  54,  10,  49,  49,  55,  48,  57,  124, 53,  56,  56,  52,  49,  51,
+    52,  46,  52,  56,  10,  49,  56,  49,  51,  53,  124, 53,  56,  55,  49,
+    52,  51,  49,  46,  54,  49,  10,  49,  51,  49,  54,  57,  124, 53,  56,
+    54,  57,  55,  51,  54,  46,  56,  56,  10,  50,  57,  51,  50,  124, 53,
+    56,  54,  56,  57,  57,  53,  46,  56,  48,  10,  50,  56,  56,  56,  124,
+    53,  56,  54,  51,  50,  50,  57,  46,  51,  48,  10,  54,  56,  50,  48,
+    124, 53,  56,  53,  51,  49,  48,  54,  46,  56,  48,  10,  49,  56,  54,
+    50,  50,  124, 53,  56,  53,  48,  57,  53,  49,  46,  54,  48,  10,  57,
+    48,  54,  54,  124, 53,  56,  52,  54,  48,  53,  50,  46,  55,  50,  10,
+    49,  57,  56,  52,  48,  124, 53,  56,  51,  50,  50,  53,  49,  46,  52,
+    48,  10,  54,  51,  50,  53,  124, 53,  56,  50,  55,  50,  57,  56,  46,
+    52,  51,  10,  49,  52,  48,  57,  50,  124, 53,  56,  50,  51,  55,  49,
+    49,  46,  55,  50,  10,  49,  49,  53,  51,  50,  124, 53,  56,  50,  51,
+    50,  55,  55,  46,  49,  50,  10,  49,  56,  48,  52,  51,  124, 53,  56,
+    49,  53,  50,  52,  56,  46,  55,  48,  10,  51,  57,  51,  50,  124, 53,
+    56,  48,  57,  49,  51,  52,  46,  54,  48,  10,  49,  48,  51,  54,  52,
+    124, 53,  56,  48,  56,  51,  55,  49,  46,  52,  48,  10,  49,  49,  55,
+    57,  124, 53,  56,  48,  56,  51,  48,  51,  46,  50,  52,  10,  49,  49,
+    52,  52,  49,  124, 53,  55,  57,  57,  51,  55,  56,  46,  51,  51,  10,
+    49,  53,  55,  54,  55,  124, 53,  55,  57,  56,  50,  54,  51,  46,  50,
+    54,  10,  49,  52,  48,  54,  51,  124, 53,  55,  57,  55,  50,  48,  52,
+    46,  48,  48,  10,  49,  49,  51,  56,  51,  124, 53,  55,  57,  51,  56,
+    57,  51,  46,  49,  50,  10,  49,  48,  48,  54,  53,  124, 53,  55,  56,
+    49,  55,  54,  52,  46,  52,  53,  10,  49,  55,  55,  56,  53,  124, 53,
+    55,  54,  54,  56,  51,  56,  46,  55,  54,  10,  49,  56,  51,  52,  57,
+    124, 53,  55,  54,  49,  55,  54,  53,  46,  55,  55,  10,  49,  52,  56,
+    50,  52,  124, 53,  55,  54,  48,  51,  51,  57,  46,  55,  56,  10,  49,
+    52,  54,  57,  57,  124, 53,  55,  53,  57,  52,  57,  48,  46,  49,  56,
+    10,  49,  49,  54,  50,  56,  124, 53,  55,  53,  53,  49,  51,  55,  46,
+    50,  48,  10,  52,  52,  48,  51,  124, 53,  55,  53,  50,  51,  55,  54,
+    46,  54,  52,  10,  49,  51,  48,  57,  48,  124, 53,  55,  53,  49,  57,
+    52,  57,  46,  50,  53,  10,  49,  53,  51,  51,  50,  124, 53,  55,  52,
+    52,  54,  48,  54,  46,  50,  56,  10,  49,  55,  53,  55,  51,  124, 53,
+    55,  52,  52,  51,  56,  52,  46,  49,  53,  10,  49,  50,  56,  57,  53,
+    124, 53,  55,  52,  49,  48,  48,  55,  46,  48,  50,  10,  49,  51,  53,
+    55,  55,  124, 53,  55,  51,  57,  50,  48,  57,  46,  57,  52,  10,  49,
+    54,  53,  57,  52,  124, 53,  55,  51,  50,  53,  50,  51,  46,  54,  52,
+    10,  56,  52,  57,  55,  124, 53,  55,  50,  55,  53,  48,  57,  46,  56,
+    52,  10,  50,  56,  55,  50,  124, 53,  55,  50,  52,  48,  54,  56,  46,
+    55,  50,  10,  49,  54,  49,  56,  49,  124, 53,  55,  50,  49,  55,  56,
+    56,  46,  49,  54,  10,  54,  54,  51,  57,  124, 53,  55,  49,  50,  48,
+    52,  49,  46,  50,  50,  10,  49,  51,  48,  57,  53,  124, 53,  55,  48,
+    56,  55,  57,  56,  46,  50,  53,  10,  52,  53,  51,  53,  124, 53,  54,
+    57,  51,  51,  52,  49,  46,  50,  48,  10,  49,  48,  57,  53,  54,  124,
+    53,  54,  57,  50,  53,  56,  53,  46,  53,  48,  10,  49,  57,  55,  53,
+    53,  124, 53,  54,  56,  54,  57,  49,  51,  46,  51,  55,  10,  49,  50,
+    57,  57,  53,  124, 53,  54,  56,  50,  50,  48,  48,  46,  52,  49,  10,
+    49,  51,  49,  53,  55,  124, 53,  54,  56,  49,  52,  53,  52,  46,  57,
+    52,  10,  49,  56,  56,  55,  124, 53,  54,  56,  49,  51,  52,  49,  46,
+    50,  52,  10,  49,  56,  52,  55,  50,  124, 53,  54,  56,  48,  51,  53,
+    54,  46,  48,  48,  10,  49,  57,  56,  49,  52,  124, 53,  54,  55,  57,
+    51,  54,  48,  46,  48,  48,  10,  49,  56,  53,  56,  51,  124, 53,  54,
+    54,  57,  51,  54,  48,  46,  53,  50,  10,  51,  56,  57,  52,  124, 53,
+    54,  54,  52,  51,  56,  53,  46,  52,  57,  10,  49,  55,  52,  48,  124,
+    53,  54,  53,  57,  53,  53,  50,  46,  48,  52,  10,  54,  50,  124, 53,
+    54,  53,  57,  52,  55,  48,  46,  49,  54,  10,  49,  54,  53,  51,  50,
+    124, 53,  54,  53,  51,  55,  55,  57,  46,  52,  54,  10,  57,  57,  53,
+    124, 53,  54,  52,  56,  57,  55,  51,  46,  52,  53,  10,  55,  52,  56,
+    54,  124, 53,  54,  52,  54,  56,  53,  49,  46,  56,  55,  10,  49,  57,
+    48,  48,  55,  124, 53,  54,  52,  50,  55,  49,  48,  46,  57,  51,  10,
+    49,  51,  48,  54,  48,  124, 53,  54,  52,  50,  48,  50,  52,  46,  54,
+    52,  10,  49,  50,  51,  55,  49,  124, 53,  54,  51,  53,  55,  49,  48,
+    46,  52,  53,  10,  50,  50,  56,  48,  124, 53,  54,  51,  52,  48,  55,
+    55,  46,  52,  48,  10,  51,  49,  49,  53,  124, 53,  54,  51,  49,  51,
+    53,  50,  46,  51,  50,  10,  49,  49,  49,  48,  55,  124, 53,  54,  51,
+    49,  50,  53,  50,  46,  52,  54,  10,  53,  56,  55,  51,  124, 53,  54,
+    50,  57,  49,  50,  53,  46,  55,  53,  10,  49,  52,  55,  52,  51,  124,
+    53,  54,  50,  56,  55,  51,  50,  46,  56,  48,  10,  50,  50,  50,  52,
+    124, 53,  54,  50,  52,  55,  52,  54,  46,  54,  50,  10,  50,  54,  53,
+    51,  124, 53,  54,  50,  51,  56,  53,  57,  46,  57,  57,  10,  49,  55,
+    54,  50,  50,  124, 53,  54,  50,  51,  48,  53,  55,  46,  52,  52,  10,
+    49,  52,  55,  48,  48,  124, 53,  54,  49,  53,  51,  52,  52,  46,  48,
+    48,  10,  49,  52,  55,  52,  48,  124, 53,  54,  49,  51,  57,  50,  57,
+    46,  51,  57,  10,  54,  52,  48,  51,  124, 53,  54,  49,  49,  57,  50,
+    52,  46,  53,  49,  10,  54,  56,  57,  54,  124, 53,  54,  48,  57,  49,
+    54,  57,  46,  56,  56,  10,  49,  48,  51,  56,  52,  124, 53,  54,  48,
+    55,  51,  51,  55,  46,  53,  50,  10,  49,  54,  52,  51,  51,  124, 53,
+    54,  48,  53,  55,  48,  55,  46,  48,  51,  10,  53,  56,  57,  56,  124,
+    53,  54,  48,  52,  57,  51,  55,  46,  55,  54,  10,  52,  55,  56,  57,
+    124, 53,  54,  48,  48,  52,  56,  56,  46,  51,  54,  10,  56,  49,  51,
+    50,  124, 53,  53,  57,  51,  49,  48,  55,  46,  53,  48,  10,  51,  56,
+    51,  56,  124, 53,  53,  57,  50,  51,  49,  51,  46,  50,  48,  10,  49,
+    51,  54,  51,  49,  124, 53,  53,  56,  54,  52,  50,  52,  46,  56,  48,
+    10,  49,  49,  50,  51,  51,  124, 53,  53,  56,  53,  50,  52,  55,  46,
+    48,  49,  10,  56,  52,  57,  124, 53,  53,  56,  51,  53,  49,  54,  46,
+    52,  53,  10,  49,  52,  54,  53,  51,  124, 53,  53,  56,  49,  53,  53,
+    48,  46,  52,  53,  10,  49,  52,  55,  56,  56,  124, 53,  53,  56,  48,
+    52,  51,  51,  46,  48,  48,  10,  49,  56,  49,  56,  49,  124, 53,  53,
+    55,  56,  53,  54,  50,  46,  56,  56,  10,  49,  57,  56,  49,  53,  124,
+    53,  53,  55,  55,  49,  48,  50,  46,  54,  50,  10,  53,  53,  56,  52,
+    124, 53,  53,  55,  54,  54,  57,  50,  46,  50,  48,  10,  53,  51,  56,
+    53,  124, 53,  53,  55,  54,  52,  50,  48,  46,  49,  57,  10,  49,  51,
+    55,  56,  48,  124, 53,  53,  54,  57,  48,  50,  56,  46,  54,  49,  10,
+    57,  51,  52,  50,  124, 53,  53,  54,  54,  55,  56,  51,  46,  55,  49,
+    10,  49,  57,  48,  53,  54,  124, 53,  53,  54,  54,  53,  50,  52,  46,
+    49,  50,  10,  56,  49,  56,  57,  124, 53,  53,  54,  53,  54,  57,  52,
+    46,  55,  52,  10,  49,  51,  56,  48,  56,  124, 53,  53,  54,  48,  55,
+    50,  49,  46,  57,  54,  10,  49,  48,  54,  51,  53,  124, 53,  53,  54,
+    48,  48,  53,  56,  46,  53,  53,  10,  56,  51,  48,  52,  124, 53,  53,
+    53,  48,  55,  56,  52,  46,  52,  49,  10,  49,  52,  50,  53,  55,  124,
+    53,  53,  52,  57,  49,  54,  52,  46,  48,  54,  10,  56,  57,  57,  57,
+    124, 53,  53,  52,  50,  49,  48,  48,  46,  49,  48,  10,  49,  57,  49,
+    51,  52,  124, 53,  53,  51,  57,  51,  49,  50,  46,  53,  54,  10,  56,
+    51,  54,  48,  124, 53,  53,  51,  56,  48,  51,  49,  46,  49,  48,  10,
+    54,  51,  57,  55,  124, 53,  53,  51,  54,  54,  53,  49,  46,  57,  50,
+    10,  50,  53,  57,  55,  124, 53,  53,  50,  53,  51,  49,  55,  46,  55,
+    54,  10,  56,  54,  51,  49,  124, 53,  53,  49,  53,  57,  48,  57,  46,
+    51,  56,  10,  49,  54,  55,  50,  57,  124, 53,  53,  49,  50,  54,  54,
+    51,  46,  54,  53,  10,  49,  49,  56,  54,  49,  124, 53,  53,  49,  49,
+    55,  56,  53,  46,  57,  51,  10,  49,  54,  56,  53,  51,  124, 53,  53,
+    49,  49,  54,  56,  57,  46,  57,  49,  10,  54,  51,  52,  49,  124, 53,
+    53,  48,  50,  55,  57,  48,  46,  48,  56,  10,  49,  51,  49,  50,  124,
+    53,  52,  57,  54,  54,  52,  57,  46,  52,  48,  10,  53,  53,  54,  54,
+    124, 53,  52,  57,  53,  56,  56,  53,  46,  56,  55,  10,  49,  50,  53,
+    49,  57,  124, 53,  52,  57,  48,  54,  52,  57,  46,  57,  55,  10,  49,
+    57,  48,  51,  50,  124, 53,  52,  56,  56,  49,  48,  53,  46,  48,  50,
+    10,  56,  50,  51,  49,  124, 53,  52,  55,  57,  51,  49,  50,  46,  53,
+    48,  10,  51,  48,  50,  54,  124, 53,  52,  54,  54,  55,  51,  50,  46,
+    51,  50,  10,  54,  51,  56,  56,  124, 53,  52,  54,  54,  49,  54,  56,
+    46,  56,  48,  10,  49,  53,  51,  52,  57,  124, 53,  52,  54,  52,  53,
+    55,  49,  46,  53,  50,  10,  49,  56,  57,  56,  53,  124, 53,  52,  54,
+    51,  56,  57,  55,  46,  49,  51,  10,  49,  57,  56,  52,  56,  124, 53,
+    52,  53,  52,  50,  54,  54,  46,  52,  48,  10,  49,  55,  51,  55,  56,
+    124, 53,  52,  53,  51,  50,  56,  52,  46,  55,  52,  10,  52,  48,  48,
+    48,  124, 53,  52,  52,  56,  54,  57,  48,  46,  51,  57,  10,  51,  55,
+    49,  48,  124, 53,  52,  52,  53,  56,  50,  50,  46,  53,  51,  10,  49,
+    51,  49,  56,  49,  124, 53,  52,  51,  57,  55,  55,  52,  46,  48,  54,
+    10,  54,  52,  50,  48,  124, 53,  52,  51,  56,  51,  50,  53,  46,  51,
+    50,  10,  51,  54,  52,  52,  124, 53,  52,  51,  55,  55,  55,  50,  46,
+    49,  52,  10,  49,  49,  49,  55,  124, 53,  52,  51,  55,  48,  50,  52,
+    46,  57,  55,  10,  49,  51,  48,  50,  55,  124, 53,  52,  51,  54,  57,
+    54,  56,  46,  52,  54,  10,  49,  50,  56,  56,  52,  124, 53,  52,  51,
+    50,  54,  51,  50,  46,  51,  52,  10,  49,  50,  55,  56,  49,  124, 53,
+    52,  50,  57,  49,  54,  49,  46,  48,  56,  10,  49,  48,  48,  56,  52,
+    124, 53,  52,  50,  56,  50,  51,  49,  46,  54,  50,  10,  53,  54,  52,
+    48,  124, 53,  52,  50,  51,  51,  49,  56,  46,  53,  56,  10,  49,  54,
+    50,  48,  56,  124, 53,  52,  50,  50,  57,  48,  49,  46,  52,  48,  10,
+    55,  53,  51,  124, 53,  52,  49,  54,  56,  57,  57,  46,  55,  52,  10,
+    52,  49,  50,  48,  124, 53,  52,  49,  51,  56,  50,  50,  46,  52,  54,
+    10,  49,  50,  51,  52,  56,  124, 53,  52,  49,  50,  48,  54,  49,  46,
+    55,  49,  10,  49,  53,  56,  54,  124, 53,  52,  49,  49,  49,  57,  56,
+    46,  53,  53,  10,  50,  53,  48,  51,  124, 53,  52,  49,  49,  49,  50,
+    53,  46,  56,  48,  10,  49,  51,  56,  49,  124, 53,  51,  57,  55,  55,
+    57,  48,  46,  49,  48,  10,  49,  57,  54,  55,  51,  124, 53,  51,  57,
+    55,  55,  52,  54,  46,  55,  55,  10,  49,  57,  51,  56,  57,  124, 53,
+    51,  57,  52,  52,  50,  54,  46,  52,  48,  10,  49,  53,  53,  51,  50,
+    124, 53,  51,  56,  54,  51,  54,  49,  46,  51,  56,  10,  51,  53,  54,
+    50,  124, 53,  51,  56,  48,  51,  51,  53,  46,  48,  56,  10,  49,  57,
+    49,  49,  52,  124, 53,  51,  55,  53,  49,  51,  51,  46,  48,  48,  10,
+    51,  50,  48,  52,  124, 53,  51,  55,  50,  50,  49,  53,  46,  52,  54,
+    10,  54,  54,  53,  51,  124, 53,  51,  54,  53,  49,  55,  56,  46,  48,
+    48,  10,  51,  53,  53,  51,  124, 53,  51,  54,  51,  54,  57,  48,  46,
+    50,  57,  10,  49,  50,  54,  56,  55,  124, 53,  51,  54,  49,  54,  56,
+    50,  46,  49,  50,  10,  51,  50,  55,  57,  124, 53,  51,  53,  55,  53,
+    48,  53,  46,  54,  53,  10,  57,  56,  52,  48,  124, 53,  51,  53,  48,
+    49,  49,  50,  46,  49,  56,  10,  56,  50,  53,  56,  124, 53,  51,  52,
+    55,  48,  54,  52,  46,  54,  55,  10,  49,  49,  51,  56,  55,  124, 53,
+    51,  52,  53,  50,  56,  52,  46,  48,  48,  10,  49,  53,  50,  49,  48,
+    124, 53,  51,  52,  49,  49,  49,  55,  46,  57,  50,  10,  49,  53,  48,
+    57,  50,  124, 53,  51,  52,  48,  56,  57,  54,  46,  56,  48,  10,  54,
+    48,  53,  50,  124, 53,  51,  51,  57,  55,  54,  50,  46,  49,  56,  10,
+    49,  52,  48,  52,  51,  124, 53,  51,  51,  57,  53,  56,  55,  46,  54,
+    56,  10,  54,  50,  56,  52,  124, 53,  51,  51,  54,  49,  53,  51,  46,
+    48,  48,  10,  54,  50,  57,  55,  124, 53,  51,  51,  50,  51,  53,  55,
+    46,  55,  52,  10,  49,  54,  50,  53,  52,  124, 53,  51,  50,  54,  54,
+    48,  55,  46,  56,  51,  10,  49,  56,  52,  51,  54,  124, 53,  51,  50,
+    54,  49,  57,  56,  46,  53,  48,  10,  49,  52,  52,  51,  54,  124, 53,
+    51,  50,  53,  53,  49,  55,  46,  49,  52,  10,  49,  48,  51,  54,  56,
+    124, 53,  51,  49,  57,  57,  56,  51,  46,  48,  56,  10,  54,  51,  52,
+    57,  124, 53,  51,  49,  55,  57,  52,  51,  46,  52,  48,  10,  49,  57,
+    57,  56,  52,  124, 53,  51,  49,  55,  54,  50,  48,  46,  48,  48,  10,
+    49,  57,  48,  56,  48,  124, 53,  51,  49,  48,  54,  55,  56,  46,  54,
+    48,  10,  49,  52,  48,  51,  124, 53,  51,  48,  54,  55,  55,  49,  46,
+    51,  50,  10,  53,  57,  57,  53,  124, 53,  51,  48,  53,  48,  53,  54,
+    46,  49,  50,  10,  49,  51,  50,  49,  52,  124, 53,  50,  57,  57,  52,
+    50,  48,  46,  52,  53,  10,  49,  57,  50,  57,  51,  124, 53,  50,  57,
+    55,  48,  53,  52,  46,  52,  48,  10,  55,  49,  51,  48,  124, 53,  50,
+    56,  57,  55,  54,  49,  46,  52,  56,  10,  57,  56,  48,  57,  124, 53,
+    50,  56,  54,  55,  56,  52,  46,  56,  48,  10,  57,  50,  55,  51,  124,
+    53,  50,  55,  55,  57,  50,  52,  46,  55,  55,  10,  49,  54,  55,  56,
+    54,  124, 53,  50,  54,  48,  48,  51,  53,  46,  48,  48,  10,  49,  49,
+    48,  51,  50,  124, 53,  50,  53,  54,  51,  53,  52,  46,  51,  53,  10,
+    49,  55,  55,  49,  57,  124, 53,  50,  52,  54,  51,  50,  50,  46,  50,
+    48,  10,  51,  52,  48,  48,  124, 53,  50,  52,  52,  50,  48,  51,  46,
+    54,  56,  10,  56,  50,  55,  56,  124, 53,  50,  52,  51,  55,  49,  56,
+    46,  52,  56,  10,  55,  56,  55,  51,  124, 53,  50,  52,  49,  49,  54,
+    56,  46,  56,  48,  10,  57,  51,  53,  55,  124, 53,  50,  51,  57,  54,
+    57,  53,  46,  55,  55,  10,  50,  50,  51,  57,  124, 53,  50,  51,  53,
+    55,  54,  55,  46,  56,  51,  10,  49,  56,  54,  57,  53,  124, 53,  50,
+    50,  51,  57,  54,  48,  46,  51,  53,  10,  49,  57,  50,  55,  49,  124,
+    53,  50,  49,  54,  52,  57,  56,  46,  50,  57,  10,  52,  53,  54,  51,
+    124, 53,  50,  49,  52,  54,  55,  51,  46,  55,  48,  10,  49,  56,  57,
+    54,  124, 53,  50,  49,  48,  54,  57,  57,  46,  55,  57,  10,  49,  53,
+    55,  53,  53,  124, 53,  50,  49,  48,  52,  56,  49,  46,  50,  52,  10,
+    49,  55,  54,  50,  56,  124, 53,  50,  48,  57,  56,  56,  50,  46,  51,
+    55,  10,  53,  55,  52,  55,  124, 53,  50,  48,  54,  56,  57,  50,  46,
+    50,  52,  10,  49,  56,  48,  53,  55,  124, 53,  50,  48,  52,  57,  48,
+    55,  46,  52,  48,  10,  53,  48,  55,  53,  124, 53,  50,  48,  52,  52,
+    49,  50,  46,  56,  49,  10,  53,  51,  50,  53,  124, 53,  49,  57,  48,
+    49,  54,  50,  46,  55,  53,  10,  49,  55,  54,  55,  53,  124, 53,  49,
+    56,  51,  49,  51,  53,  46,  51,  54,  10,  49,  56,  56,  49,  56,  124,
+    53,  49,  56,  49,  50,  57,  53,  46,  51,  48,  10,  49,  49,  48,  54,
+    52,  124, 53,  49,  56,  48,  54,  54,  55,  46,  53,  55,  10,  49,  50,
+    53,  55,  56,  124, 53,  49,  55,  55,  50,  50,  50,  46,  51,  51,  10,
+    51,  55,  50,  53,  124, 53,  49,  54,  57,  49,  56,  51,  46,  55,  53,
+    10,  49,  49,  49,  49,  50,  124, 53,  49,  54,  49,  53,  52,  54,  46,
+    48,  48,  10,  52,  55,  52,  57,  124, 53,  49,  54,  49,  52,  57,  57,
+    46,  52,  52,  10,  55,  54,  51,  50,  124, 53,  49,  53,  57,  49,  56,
+    48,  46,  53,  48,  10,  49,  51,  49,  49,  57,  124, 53,  49,  53,  49,
+    54,  54,  53,  46,  53,  49,  10,  53,  54,  53,  51,  124, 53,  49,  52,
+    48,  51,  50,  52,  46,  54,  52,  10,  49,  54,  49,  51,  52,  124, 53,
+    49,  51,  55,  52,  56,  50,  46,  53,  49,  10,  53,  54,  55,  49,  124,
+    53,  49,  51,  54,  56,  49,  53,  46,  53,  53,  10,  49,  56,  51,  52,
+    56,  124, 53,  49,  51,  50,  57,  56,  49,  46,  48,  55,  10,  53,  54,
+    50,  124, 53,  49,  51,  50,  52,  56,  55,  46,  50,  53,  10,  50,  53,
+    54,  50,  124, 53,  49,  50,  54,  55,  54,  51,  46,  56,  51,  10,  49,
+    48,  51,  48,  52,  124, 53,  49,  50,  53,  49,  56,  48,  46,  48,  48,
+    10,  55,  54,  50,  50,  124, 53,  49,  50,  48,  55,  49,  57,  46,  57,
+    56,  10,  49,  50,  55,  53,  53,  124, 53,  49,  49,  56,  50,  49,  51,
+    46,  57,  50,  10,  49,  56,  49,  52,  124, 53,  49,  48,  48,  55,  48,
+    53,  46,  53,  56,  10,  49,  49,  50,  54,  57,  124, 53,  48,  57,  54,
+    54,  55,  49,  46,  51,  51,  10,  50,  57,  54,  52,  124, 53,  48,  57,
+    53,  50,  53,  51,  46,  55,  50,  10,  49,  54,  49,  54,  124, 53,  48,
+    57,  49,  56,  51,  52,  46,  48,  48,  10,  57,  50,  57,  52,  124, 53,
+    48,  57,  48,  55,  53,  51,  46,  53,  51,  10,  49,  54,  55,  57,  51,
+    124, 53,  48,  56,  53,  51,  51,  48,  46,  53,  52,  10,  52,  57,  57,
+    57,  124, 53,  48,  56,  49,  54,  53,  49,  46,  55,  53,  10,  49,  55,
+    50,  48,  57,  124, 53,  48,  55,  57,  48,  50,  57,  46,  50,  56,  10,
+    55,  49,  53,  49,  124, 53,  48,  55,  56,  57,  51,  55,  46,  54,  48,
+    10,  49,  53,  53,  50,  50,  124, 53,  48,  55,  50,  52,  54,  57,  46,
+    54,  48,  10,  51,  48,  53,  54,  124, 53,  48,  55,  50,  51,  50,  57,
+    46,  53,  53,  10,  55,  54,  49,  50,  124, 53,  48,  54,  56,  51,  50,
+    50,  46,  56,  55,  10,  49,  56,  52,  53,  51,  124, 53,  48,  54,  51,
+    56,  57,  50,  46,  57,  50,  10,  49,  56,  51,  50,  52,  124, 53,  48,
+    53,  56,  57,  48,  49,  46,  50,  50,  10,  49,  50,  50,  54,  54,  124,
+    53,  48,  53,  56,  49,  56,  54,  46,  55,  53,  10,  49,  57,  51,  57,
+    52,  124, 53,  48,  53,  54,  50,  51,  53,  46,  55,  51,  10,  49,  55,
+    49,  51,  124, 53,  48,  53,  52,  57,  54,  56,  46,  48,  53,  10,  49,
+    53,  54,  56,  49,  124, 53,  48,  53,  49,  53,  54,  57,  46,  54,  51,
+    10,  56,  50,  55,  52,  124, 53,  48,  52,  51,  51,  50,  56,  46,  48,
+    48,  10,  49,  56,  49,  54,  48,  124, 53,  48,  52,  51,  48,  55,  52,
+    46,  56,  51,  10,  49,  56,  50,  53,  51,  124, 53,  48,  52,  49,  53,
+    55,  50,  46,  48,  48,  10,  49,  49,  56,  52,  48,  124, 53,  48,  52,
+    48,  53,  57,  48,  46,  48,  52,  10,  49,  53,  51,  50,  124, 53,  48,
+    51,  51,  49,  55,  49,  46,  48,  48,  10,  53,  56,  52,  124, 53,  48,
+    51,  49,  54,  48,  50,  46,  54,  52,  10,  49,  50,  51,  56,  50,  124,
+    53,  48,  50,  56,  57,  48,  49,  46,  48,  48,  10,  49,  52,  56,  49,
+    52,  124, 53,  48,  50,  50,  50,  48,  48,  46,  48,  55,  10,  49,  57,
+    48,  53,  56,  124, 53,  48,  49,  57,  48,  48,  49,  46,  57,  50,  10,
+    52,  52,  56,  55,  124, 53,  48,  49,  54,  54,  52,  48,  46,  56,  54,
+    10,  56,  52,  56,  50,  124, 53,  48,  49,  53,  52,  52,  52,  46,  50,
+    53,  10,  49,  56,  52,  55,  54,  124, 53,  48,  49,  49,  49,  51,  54,
+    46,  51,  54,  10,  49,  50,  51,  51,  53,  124, 53,  48,  48,  51,  53,
+    56,  49,  46,  52,  48,  10,  52,  52,  53,  53,  124, 52,  57,  57,  55,
+    57,  51,  51,  46,  51,  49,  10,  49,  52,  51,  53,  53,  124, 52,  57,
+    57,  50,  56,  50,  50,  46,  57,  50,  10,  49,  53,  50,  53,  51,  124,
+    52,  57,  57,  50,  54,  52,  50,  46,  50,  48,  10,  49,  52,  48,  54,
+    57,  124, 52,  57,  56,  51,  50,  52,  52,  46,  50,  48,  10,  49,  55,
+    56,  52,  51,  124, 52,  57,  55,  55,  50,  57,  52,  46,  51,  55,  10,
+    57,  51,  56,  57,  124, 52,  57,  55,  53,  56,  56,  53,  46,  56,  51,
+    10,  49,  52,  52,  51,  53,  124, 52,  57,  55,  49,  52,  52,  50,  46,
+    49,  57,  10,  49,  51,  50,  53,  52,  124, 52,  57,  53,  57,  52,  56,
+    49,  46,  52,  53,  10,  57,  55,  55,  51,  124, 52,  57,  53,  53,  56,
+    56,  55,  46,  56,  48,  10,  55,  54,  49,  53,  124, 52,  57,  53,  50,
+    52,  50,  49,  46,  53,  52,  10,  54,  52,  55,  54,  124, 52,  57,  52,
+    55,  50,  53,  48,  46,  48,  53,  10,  57,  50,  53,  51,  124, 52,  57,
+    52,  53,  49,  53,  57,  46,  55,  48,  10,  49,  52,  57,  51,  50,  124,
+    52,  57,  51,  52,  51,  57,  53,  46,  52,  56,  10,  49,  51,  50,  53,
+    51,  124, 52,  57,  51,  50,  56,  54,  55,  46,  52,  53,  10,  49,  57,
+    51,  50,  50,  124, 52,  57,  51,  49,  53,  50,  53,  46,  55,  56,  10,
+    49,  54,  57,  52,  53,  124, 52,  57,  51,  49,  52,  52,  48,  46,  54,
+    49,  10,  55,  51,  49,  124, 52,  57,  51,  48,  49,  57,  49,  46,  57,
+    51,  10,  54,  53,  52,  48,  124, 52,  57,  50,  53,  49,  49,  52,  46,
+    53,  49,  10,  53,  49,  52,  56,  124, 52,  57,  50,  51,  48,  52,  56,
+    46,  48,  48,  10,  49,  57,  51,  52,  124, 52,  57,  50,  49,  49,  57,
+    54,  46,  57,  48,  10,  49,  53,  52,  48,  50,  124, 52,  57,  50,  48,
+    56,  52,  48,  46,  55,  50,  10,  49,  55,  57,  49,  52,  124, 52,  57,
+    49,  57,  54,  48,  55,  46,  48,  52,  10,  53,  52,  49,  54,  124, 52,
+    57,  49,  54,  48,  52,  49,  46,  57,  50,  10,  49,  54,  55,  51,  52,
+    124, 52,  57,  49,  52,  50,  48,  53,  46,  50,  55,  10,  49,  52,  57,
+    54,  55,  124, 52,  57,  48,  48,  50,  54,  50,  46,  48,  56,  10,  56,
+    55,  48,  54,  124, 52,  56,  57,  52,  53,  57,  53,  46,  53,  56,  10,
+    49,  51,  54,  124, 52,  56,  57,  49,  57,  54,  48,  46,  57,  50,  10,
+    49,  57,  52,  57,  52,  124, 52,  56,  56,  54,  48,  50,  56,  46,  51,
+    48,  10,  56,  55,  51,  55,  124, 52,  56,  56,  48,  54,  52,  48,  46,
+    52,  52,  10,  55,  54,  53,  51,  124, 52,  56,  55,  57,  52,  50,  51,
+    46,  54,  52,  10,  52,  49,  52,  57,  124, 52,  56,  55,  53,  55,  56,
+    50,  46,  52,  48,  10,  55,  56,  57,  48,  124, 52,  56,  55,  50,  52,
+    50,  52,  46,  52,  48,  10,  49,  49,  49,  52,  50,  124, 52,  56,  55,
+    49,  52,  49,  53,  46,  52,  50,  10,  49,  48,  51,  56,  54,  124, 52,
+    56,  54,  51,  54,  50,  51,  46,  53,  48,  10,  56,  54,  48,  51,  124,
+    52,  56,  54,  49,  56,  49,  52,  46,  54,  49,  10,  50,  54,  56,  48,
+    124, 52,  56,  54,  49,  50,  50,  51,  46,  55,  52,  10,  52,  56,  57,
+    49,  124, 52,  56,  53,  56,  49,  48,  51,  46,  56,  56,  10,  49,  57,
+    50,  51,  54,  124, 52,  56,  53,  53,  48,  57,  55,  46,  54,  57,  10,
+    49,  52,  50,  53,  49,  124, 52,  56,  53,  52,  55,  51,  57,  46,  56,
+    54,  10,  49,  56,  56,  57,  53,  124, 52,  56,  53,  51,  51,  54,  53,
+    46,  49,  48,  10,  49,  55,  49,  51,  52,  124, 52,  56,  53,  50,  48,
+    52,  49,  46,  48,  52,  10,  52,  57,  51,  50,  124, 52,  56,  52,  51,
+    55,  48,  49,  46,  52,  53,  10,  49,  48,  48,  51,  51,  124, 52,  56,
+    52,  49,  54,  52,  55,  46,  55,  50,  10,  49,  51,  56,  51,  124, 52,
+    56,  51,  57,  49,  52,  52,  46,  51,  49,  10,  49,  56,  55,  50,  49,
+    124, 52,  56,  51,  55,  57,  56,  51,  46,  51,  54,  10,  56,  54,  49,
+    56,  124, 52,  56,  51,  51,  49,  50,  53,  46,  52,  50,  10,  49,  55,
+    51,  56,  54,  124, 52,  56,  51,  49,  53,  52,  53,  46,  56,  52,  10,
+    51,  55,  57,  48,  124, 52,  56,  51,  48,  50,  56,  50,  46,  51,  54,
+    10,  49,  48,  52,  51,  124, 52,  56,  50,  53,  57,  50,  49,  46,  51,
+    49,  10,  49,  50,  52,  51,  52,  124, 52,  56,  50,  50,  53,  57,  55,
+    46,  55,  56,  10,  49,  56,  51,  56,  53,  124, 52,  56,  49,  57,  54,
+    52,  51,  46,  52,  48,  10,  54,  48,  52,  54,  124, 52,  56,  49,  55,
+    52,  54,  48,  46,  48,  54,  10,  53,  56,  50,  49,  124, 52,  56,  49,
+    52,  52,  50,  51,  46,  52,  53,  10,  49,  48,  56,  51,  54,  124, 52,
+    56,  49,  52,  51,  48,  51,  46,  50,  52,  10,  54,  56,  52,  56,  124,
+    52,  56,  49,  51,  57,  53,  52,  46,  48,  56,  10,  54,  56,  56,  48,
+    124, 52,  56,  48,  52,  54,  48,  48,  46,  51,  53,  10,  49,  49,  50,
+    52,  57,  124, 52,  56,  48,  48,  49,  49,  54,  46,  56,  50,  10,  49,
+    49,  57,  55,  48,  124, 52,  55,  57,  57,  55,  51,  57,  46,  54,  54,
+    10,  49,  52,  50,  53,  51,  124, 52,  55,  57,  54,  53,  50,  49,  46,
+    50,  57,  10,  55,  55,  56,  50,  124, 52,  55,  57,  51,  50,  50,  55,
+    46,  49,  51,  10,  55,  53,  124, 52,  55,  57,  48,  48,  52,  50,  46,
+    56,  56,  10,  55,  48,  55,  54,  124, 52,  55,  56,  57,  51,  52,  55,
+    46,  51,  52,  10,  57,  53,  54,  54,  124, 52,  55,  56,  50,  53,  51,
+    49,  46,  56,  48,  10,  50,  49,  51,  55,  124, 52,  55,  54,  55,  57,
+    51,  49,  46,  55,  52,  10,  50,  51,  51,  54,  124, 52,  55,  54,  51,
+    56,  55,  48,  46,  55,  57,  10,  49,  53,  51,  54,  50,  124, 52,  55,
+    53,  57,  48,  52,  51,  46,  51,  56,  10,  51,  50,  56,  52,  124, 52,
+    55,  53,  53,  48,  52,  56,  46,  55,  54,  10,  49,  50,  57,  54,  52,
+    124, 52,  55,  53,  51,  54,  50,  55,  46,  52,  56,  10,  49,  55,  56,
+    49,  124, 52,  55,  53,  50,  56,  51,  53,  46,  50,  48,  10,  53,  52,
+    53,  52,  124, 52,  55,  52,  56,  51,  52,  50,  46,  57,  56,  10,  49,
+    50,  53,  57,  55,  124, 52,  55,  52,  50,  48,  55,  55,  46,  56,  52,
+    10,  49,  57,  49,  50,  48,  124, 52,  55,  51,  51,  52,  53,  57,  46,
+    57,  54,  10,  49,  52,  56,  56,  52,  124, 52,  55,  51,  49,  52,  57,
+    57,  46,  52,  52,  10,  56,  50,  53,  124, 52,  55,  51,  48,  55,  50,
+    48,  46,  50,  56,  10,  49,  52,  54,  56,  51,  124, 52,  55,  51,  48,
+    52,  56,  50,  46,  51,  50,  10,  53,  51,  54,  49,  124, 52,  55,  50,
+    54,  49,  49,  51,  46,  48,  48,  10,  49,  50,  49,  55,  57,  124, 52,
+    55,  50,  53,  48,  49,  56,  46,  49,  48,  10,  49,  52,  54,  49,  124,
+    52,  55,  49,  48,  57,  53,  52,  46,  54,  57,  10,  57,  56,  57,  48,
+    124, 52,  55,  48,  57,  54,  53,  56,  46,  52,  48,  10,  49,  51,  51,
+    54,  57,  124, 52,  55,  48,  53,  48,  56,  53,  46,  51,  57,  10,  49,
+    49,  54,  49,  50,  124, 52,  55,  48,  49,  54,  50,  55,  46,  57,  57,
+    10,  51,  48,  57,  54,  124, 52,  54,  57,  57,  52,  49,  52,  46,  52,
+    48,  10,  49,  48,  51,  56,  51,  124, 52,  54,  57,  55,  56,  54,  54,
+    46,  52,  55,  10,  49,  49,  50,  57,  51,  124, 52,  54,  57,  55,  51,
+    51,  54,  46,  48,  54,  10,  51,  51,  56,  51,  124, 52,  54,  57,  53,
+    56,  50,  53,  46,  50,  48,  10,  54,  50,  51,  49,  124, 52,  54,  57,
+    52,  51,  56,  49,  46,  55,  50,  10,  55,  51,  57,  54,  124, 52,  54,
+    57,  49,  51,  49,  57,  46,  48,  54,  10,  49,  55,  56,  50,  55,  124,
+    52,  54,  56,  56,  55,  57,  55,  46,  52,  52,  10,  49,  53,  56,  53,
+    54,  124, 52,  54,  56,  51,  51,  54,  56,  46,  50,  49,  10,  56,  50,
+    53,  51,  124, 52,  54,  55,  56,  53,  54,  48,  46,  56,  54,  10,  49,
+    50,  51,  50,  55,  124, 52,  54,  55,  55,  57,  56,  52,  46,  55,  52,
+    10,  52,  51,  57,  53,  124, 52,  54,  55,  54,  56,  50,  57,  46,  56,
+    50,  10,  52,  50,  51,  50,  124, 52,  54,  55,  54,  54,  52,  54,  46,
+    52,  48,  10,  49,  52,  50,  54,  48,  124, 52,  54,  55,  48,  53,  50,
+    50,  46,  56,  48,  10,  49,  53,  50,  56,  56,  124, 52,  54,  54,  57,
+    50,  55,  51,  46,  57,  57,  10,  49,  55,  53,  50,  54,  124, 52,  54,
+    54,  56,  53,  52,  53,  46,  54,  52,  10,  57,  56,  56,  52,  124, 52,
+    54,  54,  50,  54,  57,  51,  46,  56,  52,  10,  50,  49,  49,  56,  124,
+    52,  54,  54,  48,  51,  53,  50,  46,  55,  56,  10,  52,  53,  50,  52,
+    124, 52,  54,  53,  51,  57,  53,  54,  46,  54,  48,  10,  49,  57,  48,
+    57,  48,  124, 52,  54,  53,  48,  56,  55,  50,  46,  57,  52,  10,  51,
+    57,  50,  56,  124, 52,  54,  52,  57,  51,  53,  57,  46,  52,  52,  10,
+    49,  52,  51,  50,  53,  124, 52,  54,  52,  55,  55,  54,  50,  46,  49,
+    55,  10,  49,  53,  52,  55,  54,  124, 52,  54,  52,  51,  52,  54,  57,
+    46,  48,  52,  10,  52,  49,  55,  57,  124, 52,  54,  51,  57,  57,  51,
+    49,  46,  55,  54,  10,  49,  52,  52,  48,  56,  124, 52,  54,  51,  57,
+    54,  51,  49,  46,  50,  56,  10,  49,  57,  52,  50,  52,  124, 52,  54,
+    51,  52,  56,  49,  55,  46,  52,  52,  10,  51,  51,  51,  52,  124, 52,
+    54,  51,  51,  49,  48,  50,  46,  53,  48,  10,  57,  52,  55,  55,  124,
+    52,  54,  50,  56,  48,  55,  51,  46,  53,  49,  10,  49,  49,  56,  48,
+    51,  124, 52,  54,  50,  53,  51,  57,  54,  46,  56,  48,  10,  49,  52,
+    56,  48,  53,  124, 52,  54,  49,  56,  52,  53,  50,  46,  49,  56,  10,
+    52,  54,  51,  124, 52,  54,  49,  54,  51,  48,  55,  46,  50,  56,  10,
+    49,  54,  54,  50,  56,  124, 52,  54,  48,  55,  52,  57,  48,  46,  57,
+    54,  10,  51,  49,  49,  54,  124, 52,  54,  48,  52,  52,  54,  51,  46,
+    49,  48,  10,  49,  57,  57,  54,  50,  124, 52,  54,  48,  50,  57,  52,
+    57,  46,  52,  55,  10,  49,  50,  56,  53,  57,  124, 52,  54,  48,  50,
+    56,  55,  48,  46,  53,  53,  10,  49,  50,  48,  54,  51,  124, 52,  54,
+    48,  48,  55,  48,  56,  46,  52,  53,  10,  53,  54,  52,  56,  124, 52,
+    53,  57,  50,  50,  55,  51,  46,  50,  53,  10,  56,  53,  53,  54,  124,
+    52,  53,  57,  48,  55,  50,  54,  46,  56,  54,  10,  49,  53,  50,  56,
+    49,  124, 52,  53,  56,  57,  52,  50,  53,  46,  52,  49,  10,  57,  52,
+    49,  52,  124, 52,  53,  56,  55,  52,  50,  54,  46,  57,  48,  10,  49,
+    51,  57,  53,  49,  124, 52,  53,  56,  54,  50,  56,  49,  46,  50,  53,
+    10,  49,  57,  51,  50,  56,  124, 52,  53,  56,  50,  54,  50,  52,  46,
+    56,  50,  10,  49,  53,  57,  54,  51,  124, 52,  53,  55,  57,  55,  48,
+    53,  46,  53,  48,  10,  49,  48,  55,  55,  51,  124, 52,  53,  55,  51,
+    50,  55,  54,  46,  50,  48,  10,  49,  52,  49,  55,  57,  124, 52,  53,
+    54,  56,  56,  49,  54,  46,  48,  48,  10,  49,  56,  57,  53,  124, 52,
+    53,  54,  51,  57,  56,  56,  46,  49,  54,  10,  54,  52,  48,  56,  124,
+    52,  53,  54,  49,  52,  57,  54,  46,  51,  57,  10,  53,  57,  53,  56,
+    124, 52,  53,  53,  52,  48,  48,  48,  46,  48,  48,  10,  51,  54,  53,
+    51,  124, 52,  53,  52,  56,  49,  51,  52,  46,  52,  48,  10,  49,  49,
+    50,  49,  56,  124, 52,  53,  52,  54,  50,  51,  55,  46,  57,  50,  10,
+    49,  57,  51,  50,  55,  124, 52,  53,  52,  51,  57,  56,  55,  46,  55,
+    55,  10,  57,  53,  55,  50,  124, 52,  53,  51,  53,  57,  52,  49,  46,
+    49,  54,  10,  49,  52,  53,  53,  54,  124, 52,  53,  51,  49,  52,  54,
+    52,  46,  55,  53,  10,  50,  52,  55,  53,  124, 52,  53,  50,  57,  55,
+    54,  49,  46,  53,  48,  10,  57,  54,  51,  49,  124, 52,  53,  50,  57,
+    50,  54,  49,  46,  53,  54,  10,  49,  57,  48,  49,  124, 52,  53,  50,
+    56,  53,  57,  50,  46,  53,  53,  10,  56,  54,  124, 52,  53,  50,  56,
+    52,  55,  53,  46,  51,  56,  10,  57,  53,  56,  54,  124, 52,  53,  50,
+    55,  49,  52,  54,  46,  50,  50,  10,  49,  55,  51,  54,  49,  124, 52,
+    53,  49,  57,  48,  57,  56,  46,  56,  55,  10,  56,  49,  49,  50,  124,
+    52,  53,  49,  52,  57,  52,  57,  46,  52,  53,  10,  49,  51,  52,  54,
+    56,  124, 52,  52,  57,  57,  55,  50,  56,  46,  50,  48,  10,  49,  56,
+    50,  51,  57,  124, 52,  52,  57,  55,  54,  51,  51,  46,  54,  52,  10,
+    49,  48,  50,  49,  53,  124, 52,  52,  57,  52,  53,  53,  51,  46,  54,
+    48,  10,  54,  50,  49,  49,  124, 52,  52,  57,  50,  50,  54,  52,  46,
+    57,  54,  10,  56,  51,  54,  124, 52,  52,  57,  48,  57,  52,  53,  46,
+    49,  48,  10,  56,  57,  53,  124, 52,  52,  56,  57,  49,  52,  49,  46,
+    53,  48,  10,  49,  57,  53,  52,  50,  124, 52,  52,  56,  56,  51,  57,
+    51,  46,  55,  53,  10,  52,  51,  50,  50,  124, 52,  52,  56,  55,  56,
+    56,  52,  46,  50,  51,  10,  50,  49,  49,  54,  124, 52,  52,  56,  54,
+    57,  52,  52,  46,  54,  53,  10,  53,  53,  51,  124, 52,  52,  56,  54,
+    48,  55,  53,  46,  52,  56,  10,  50,  53,  49,  53,  124, 52,  52,  56,
+    53,  49,  56,  56,  46,  50,  54,  10,  49,  54,  50,  56,  54,  124, 52,
+    52,  56,  49,  52,  55,  48,  46,  52,  55,  10,  49,  50,  50,  55,  49,
+    124, 52,  52,  55,  56,  50,  50,  52,  46,  57,  53,  10,  49,  54,  53,
+    55,  48,  124, 52,  52,  54,  53,  56,  49,  56,  46,  48,  48,  10,  55,
+    57,  57,  53,  124, 52,  52,  53,  55,  53,  55,  52,  46,  54,  54,  10,
+    49,  56,  51,  57,  54,  124, 52,  52,  53,  55,  50,  50,  57,  46,  54,
+    48,  10,  49,  54,  51,  51,  49,  124, 52,  52,  53,  53,  55,  51,  53,
+    46,  52,  56,  10,  49,  56,  49,  53,  55,  124, 52,  52,  53,  50,  49,
+    57,  54,  46,  54,  51,  10,  53,  50,  55,  49,  124, 52,  52,  53,  50,
+    48,  52,  48,  46,  48,  49,  10,  49,  49,  54,  50,  50,  124, 52,  52,
+    53,  49,  50,  52,  52,  46,  56,  52,  10,  52,  48,  53,  50,  124, 52,
+    52,  52,  54,  51,  57,  55,  46,  51,  52,  10,  50,  56,  54,  52,  124,
+    52,  52,  52,  54,  48,  48,  56,  46,  51,  56,  10,  52,  57,  48,  124,
+    52,  52,  52,  50,  56,  57,  50,  46,  51,  48,  10,  49,  57,  56,  51,
+    55,  124, 52,  52,  51,  52,  49,  55,  50,  46,  51,  57,  10,  52,  49,
+    49,  52,  124, 52,  52,  51,  51,  54,  53,  55,  46,  56,  53,  10,  49,
+    49,  52,  51,  54,  124, 52,  52,  51,  51,  48,  55,  48,  46,  49,  53,
+    10,  54,  48,  56,  53,  124, 52,  52,  51,  49,  51,  48,  54,  46,  53,
+    55,  10,  57,  55,  51,  53,  124, 52,  52,  51,  48,  52,  52,  53,  46,
+    54,  48,  10,  49,  55,  56,  51,  52,  124, 52,  52,  49,  54,  50,  56,
+    54,  46,  51,  51,  10,  56,  49,  53,  55,  124, 52,  52,  49,  54,  49,
+    49,  54,  46,  54,  53,  10,  49,  56,  56,  52,  48,  124, 52,  52,  49,
+    52,  57,  50,  53,  46,  51,  50,  10,  49,  51,  53,  53,  51,  124, 52,
+    52,  49,  50,  50,  54,  49,  46,  55,  48,  10,  49,  50,  53,  54,  50,
+    124, 52,  52,  49,  49,  49,  56,  51,  46,  48,  52,  10,  49,  52,  48,
+    50,  53,  124, 52,  52,  48,  51,  52,  52,  50,  46,  49,  54,  10,  49,
+    55,  57,  54,  52,  124, 52,  52,  48,  48,  51,  54,  48,  46,  48,  57,
+    10,  54,  51,  54,  124, 52,  51,  57,  57,  56,  54,  51,  46,  56,  52,
+    10,  56,  51,  57,  48,  124, 52,  51,  56,  57,  48,  50,  52,  46,  51,
+    51,  10,  50,  51,  49,  124, 52,  51,  56,  55,  51,  57,  55,  46,  51,
+    48,  10,  57,  54,  57,  57,  124, 52,  51,  56,  53,  56,  57,  49,  46,
+    48,  50,  10,  49,  48,  54,  50,  50,  124, 52,  51,  56,  52,  48,  48,
+    53,  46,  51,  50,  10,  49,  52,  51,  54,  52,  124, 52,  51,  56,  51,
+    50,  51,  54,  46,  57,  48,  10,  49,  48,  53,  56,  48,  124, 52,  51,
+    56,  49,  53,  51,  51,  46,  50,  51,  10,  49,  48,  49,  50,  52,  124,
+    52,  51,  54,  57,  56,  48,  48,  46,  57,  54,  10,  49,  48,  52,  53,
+    49,  124, 52,  51,  54,  56,  56,  54,  55,  46,  53,  48,  10,  52,  54,
+    55,  51,  124, 52,  51,  54,  55,  49,  49,  51,  46,  52,  52,  10,  49,
+    49,  51,  53,  49,  124, 52,  51,  54,  50,  54,  49,  54,  46,  53,  48,
+    10,  52,  55,  55,  48,  124, 52,  51,  54,  50,  51,  57,  55,  46,  51,
+    50,  10,  49,  50,  57,  51,  50,  124, 52,  51,  54,  50,  48,  52,  50,
+    46,  54,  48,  10,  49,  48,  54,  48,  51,  124, 52,  51,  53,  55,  50,
+    49,  54,  46,  53,  48,  10,  49,  57,  55,  51,  51,  124, 52,  51,  52,
+    56,  57,  51,  49,  46,  55,  53,  10,  52,  50,  50,  50,  124, 52,  51,
+    52,  56,  56,  55,  49,  46,  57,  49,  10,  49,  55,  51,  49,  57,  124,
+    52,  51,  52,  55,  54,  56,  55,  46,  54,  57,  10,  51,  51,  55,  53,
+    124, 52,  51,  52,  54,  53,  50,  57,  46,  52,  56,  10,  49,  52,  57,
+    57,  53,  124, 52,  51,  51,  56,  50,  57,  53,  46,  54,  53,  10,  55,
+    54,  55,  53,  124, 52,  51,  51,  55,  52,  57,  57,  46,  54,  48,  10,
+    49,  53,  48,  52,  51,  124, 52,  51,  51,  51,  57,  50,  49,  46,  50,
+    48,  10,  52,  56,  51,  53,  124, 52,  51,  51,  50,  54,  52,  56,  46,
+    48,  48,  10,  52,  52,  48,  56,  124, 52,  51,  51,  50,  53,  56,  56,
+    46,  57,  48,  10,  53,  53,  53,  57,  124, 52,  51,  51,  48,  53,  55,
+    55,  46,  48,  57,  10,  55,  51,  55,  54,  124, 52,  51,  50,  56,  57,
+    51,  54,  46,  53,  52,  10,  49,  56,  48,  54,  49,  124, 52,  51,  50,
+    56,  55,  57,  51,  46,  57,  56,  10,  50,  55,  52,  57,  124, 52,  51,
+    50,  56,  54,  55,  49,  46,  53,  51,  10,  54,  54,  50,  56,  124, 52,
+    51,  50,  56,  53,  48,  49,  46,  56,  56,  10,  53,  56,  56,  56,  124,
+    52,  51,  50,  51,  48,  52,  57,  46,  55,  50,  10,  49,  56,  56,  55,
+    50,  124, 52,  51,  50,  50,  53,  57,  53,  46,  54,  50,  10,  53,  52,
+    55,  54,  124, 52,  51,  49,  57,  54,  52,  50,  46,  53,  56,  10,  49,
+    55,  53,  53,  124, 52,  51,  49,  56,  57,  51,  53,  46,  54,  51,  10,
+    49,  48,  54,  50,  51,  124, 52,  51,  49,  53,  56,  50,  50,  46,  53,
+    54,  10,  49,  56,  55,  55,  53,  124, 52,  51,  49,  52,  54,  55,  55,
+    46,  54,  52,  10,  51,  53,  55,  48,  124, 52,  51,  49,  50,  54,  57,
+    55,  46,  56,  55,  10,  49,  49,  49,  52,  55,  124, 52,  51,  49,  48,
+    55,  52,  48,  46,  53,  55,  10,  54,  48,  55,  49,  124, 52,  51,  48,
+    55,  54,  49,  50,  46,  52,  48,  10,  49,  48,  56,  48,  55,  124, 52,
+    51,  48,  54,  48,  48,  54,  46,  48,  48,  10,  57,  53,  53,  48,  124,
+    52,  50,  57,  57,  52,  55,  56,  46,  53,  54,  10,  54,  53,  55,  124,
+    52,  50,  57,  54,  55,  57,  52,  46,  49,  57,  10,  49,  57,  54,  54,
+    57,  124, 52,  50,  57,  52,  54,  52,  48,  46,  57,  48,  10,  56,  53,
+    51,  50,  124, 52,  50,  57,  48,  54,  53,  49,  46,  54,  48,  10,  49,
+    51,  52,  54,  57,  124, 52,  50,  56,  49,  55,  49,  53,  46,  54,  50,
+    10,  56,  56,  48,  57,  124, 52,  50,  56,  48,  55,  55,  56,  46,  56,
+    48,  10,  49,  49,  51,  48,  49,  124, 52,  50,  55,  54,  56,  52,  55,
+    46,  57,  53,  10,  54,  49,  52,  55,  124, 52,  50,  54,  54,  56,  55,
+    57,  46,  57,  50,  10,  50,  54,  49,  50,  124, 52,  50,  54,  53,  57,
+    54,  50,  46,  51,  53,  10,  49,  53,  54,  57,  57,  124, 52,  50,  53,
+    54,  49,  49,  56,  46,  55,  50,  10,  49,  50,  51,  48,  48,  124, 52,
+    50,  53,  52,  52,  48,  57,  46,  49,  49,  10,  51,  52,  57,  52,  124,
+    52,  50,  53,  48,  56,  49,  48,  46,  54,  48,  10,  49,  49,  48,  52,
+    48,  124, 52,  50,  53,  48,  48,  51,  48,  46,  50,  48,  10,  54,  49,
+    57,  48,  124, 52,  50,  52,  52,  48,  52,  54,  46,  56,  48,  10,  49,
+    55,  54,  49,  54,  124, 52,  50,  51,  57,  57,  51,  55,  46,  53,  48,
+    10,  55,  50,  55,  49,  124, 52,  50,  51,  52,  52,  48,  55,  46,  48,
+    48,  10,  49,  52,  48,  52,  56,  124, 52,  50,  50,  54,  57,  55,  55,
+    46,  52,  52,  10,  52,  52,  53,  54,  124, 52,  50,  50,  52,  54,  56,
+    52,  46,  57,  56,  10,  49,  48,  48,  49,  50,  124, 52,  50,  50,  51,
+    56,  52,  49,  46,  50,  49,  10,  49,  49,  49,  55,  53,  124, 52,  50,
+    50,  51,  55,  48,  52,  46,  49,  52,  10,  49,  56,  54,  55,  53,  124,
+    52,  50,  49,  53,  52,  48,  54,  46,  56,  54,  10,  49,  48,  55,  57,
+    50,  124, 52,  50,  49,  52,  56,  57,  56,  46,  53,  55,  10,  49,  48,
+    56,  48,  54,  124, 52,  50,  48,  57,  54,  55,  56,  46,  51,  50,  10,
+    49,  56,  55,  52,  57,  124, 52,  50,  48,  52,  55,  56,  55,  46,  48,
+    48,  10,  49,  55,  52,  49,  48,  124, 52,  49,  57,  56,  48,  50,  53,
+    46,  50,  56,  10,  56,  48,  51,  50,  124, 52,  49,  57,  53,  52,  51,
+    48,  46,  48,  48,  10,  49,  49,  48,  57,  52,  124, 52,  49,  57,  50,
+    51,  48,  52,  46,  57,  52,  10,  49,  55,  53,  56,  50,  124, 52,  49,
+    56,  55,  51,  52,  49,  46,  52,  52,  10,  49,  50,  50,  52,  54,  124,
+    52,  49,  56,  51,  50,  51,  48,  46,  57,  53,  10,  54,  54,  52,  48,
+    124, 52,  49,  56,  50,  57,  54,  56,  46,  56,  48,  10,  55,  51,  52,
+    54,  124, 52,  49,  55,  52,  55,  48,  55,  46,  54,  48,  10,  49,  50,
+    55,  52,  55,  124, 52,  49,  54,  57,  56,  54,  53,  46,  56,  49,  10,
+    51,  56,  54,  57,  124, 52,  49,  54,  52,  57,  53,  55,  46,  52,  52,
+    10,  49,  51,  49,  48,  54,  124, 52,  49,  54,  49,  57,  48,  50,  46,
+    48,  56,  10,  49,  48,  53,  52,  55,  124, 52,  49,  53,  57,  53,  52,
+    49,  46,  51,  54,  10,  49,  53,  50,  56,  57,  124, 52,  49,  53,  54,
+    50,  48,  53,  46,  55,  54,  10,  49,  54,  55,  57,  124, 52,  49,  53,
+    54,  49,  53,  54,  46,  54,  52,  10,  49,  49,  50,  54,  124, 52,  49,
+    53,  53,  53,  57,  51,  46,  48,  56,  10,  49,  57,  49,  48,  54,  124,
+    52,  49,  52,  55,  52,  51,  57,  46,  53,  50,  10,  57,  55,  48,  53,
+    124, 52,  49,  52,  52,  48,  50,  52,  46,  50,  48,  10,  49,  53,  51,
+    50,  52,  124, 52,  49,  52,  50,  53,  49,  56,  46,  53,  54,  10,  49,
+    54,  53,  52,  52,  124, 52,  49,  52,  48,  51,  55,  53,  46,  55,  50,
+    10,  56,  56,  49,  50,  124, 52,  49,  51,  57,  51,  50,  50,  46,  56,
+    49,  10,  49,  48,  55,  55,  50,  124, 52,  49,  51,  52,  49,  48,  49,
+    46,  54,  52,  10,  50,  56,  48,  48,  124, 52,  49,  50,  55,  49,  53,
+    48,  46,  48,  56,  10,  49,  53,  53,  52,  57,  124, 52,  49,  50,  52,
+    55,  48,  52,  46,  54,  52,  10,  51,  54,  48,  55,  124, 52,  49,  49,
+    56,  54,  57,  55,  46,  53,  55,  10,  49,  57,  56,  48,  124, 52,  49,
+    49,  55,  54,  51,  51,  46,  55,  50,  10,  50,  49,  52,  124, 52,  49,
+    49,  51,  49,  49,  55,  46,  51,  54,  10,  49,  57,  50,  49,  55,  124,
+    52,  49,  48,  52,  50,  49,  55,  46,  54,  48,  10,  50,  52,  54,  48,
+    124, 52,  48,  57,  56,  53,  55,  55,  46,  52,  54,  10,  49,  57,  49,
+    53,  54,  124, 52,  48,  57,  51,  56,  54,  52,  46,  52,  54,  10,  49,
+    56,  51,  53,  57,  124, 52,  48,  57,  50,  55,  50,  55,  46,  50,  57,
+    10,  49,  50,  56,  54,  53,  124, 52,  48,  57,  50,  53,  50,  54,  46,
+    56,  52,  10,  49,  52,  54,  49,  54,  124, 52,  48,  57,  50,  52,  51,
+    52,  46,  53,  52,  10,  57,  48,  56,  124, 52,  48,  56,  56,  56,  53,
+    54,  46,  50,  48,  10,  49,  49,  55,  57,  49,  124, 52,  48,  56,  51,
+    56,  48,  52,  46,  57,  55,  10,  52,  49,  53,  55,  124, 52,  48,  55,
+    56,  51,  52,  53,  46,  54,  48,  10,  51,  56,  53,  55,  124, 52,  48,
+    55,  48,  56,  55,  50,  46,  56,  55,  10,  49,  53,  49,  49,  52,  124,
+    52,  48,  53,  54,  49,  49,  50,  46,  53,  48,  10,  51,  57,  53,  124,
+    52,  48,  53,  50,  57,  57,  55,  46,  55,  54,  10,  49,  55,  52,  53,
+    54,  124, 52,  48,  53,  49,  52,  53,  55,  46,  50,  56,  10,  49,  48,
+    53,  54,  50,  124, 52,  48,  53,  48,  56,  57,  52,  46,  49,  57,  10,
+    49,  48,  56,  56,  52,  124, 52,  48,  53,  48,  51,  51,  48,  46,  55,
+    54,  10,  49,  50,  49,  55,  55,  124, 52,  48,  52,  57,  56,  52,  50,
+    46,  54,  56,  10,  49,  53,  53,  57,  53,  124, 52,  48,  52,  48,  53,
+    55,  55,  46,  53,  54,  10,  49,  53,  57,  49,  54,  124, 52,  48,  51,
+    54,  48,  52,  52,  46,  53,  48,  10,  55,  48,  56,  52,  124, 52,  48,
+    51,  53,  49,  48,  50,  46,  55,  50,  10,  52,  52,  50,  52,  124, 52,
+    48,  51,  52,  55,  54,  49,  46,  53,  54,  10,  49,  48,  56,  55,  52,
+    124, 52,  48,  51,  49,  48,  49,  53,  46,  56,  53,  10,  52,  55,  52,
+    48,  124, 52,  48,  51,  48,  52,  48,  51,  46,  55,  54,  10,  49,  54,
+    53,  56,  53,  124, 52,  48,  51,  48,  48,  49,  48,  46,  50,  54,  10,
+    49,  56,  56,  50,  52,  124, 52,  48,  50,  56,  57,  56,  52,  46,  49,
+    48,  10,  49,  52,  56,  55,  53,  124, 52,  48,  50,  56,  52,  53,  50,
+    46,  48,  56,  10,  49,  51,  56,  53,  53,  124, 52,  48,  50,  52,  56,
+    50,  56,  46,  51,  52,  10,  49,  48,  57,  51,  50,  124, 52,  48,  50,
+    52,  48,  48,  50,  46,  52,  48,  10,  57,  48,  56,  52,  124, 52,  48,
+    50,  49,  51,  54,  50,  46,  52,  53,  10,  49,  52,  51,  53,  50,  124,
+    52,  48,  49,  56,  48,  56,  57,  46,  55,  52,  10,  49,  56,  48,  56,
+    54,  124, 52,  48,  49,  53,  49,  56,  48,  46,  54,  56,  10,  57,  53,
+    49,  52,  124, 52,  48,  49,  51,  54,  54,  54,  46,  54,  55,  10,  49,
+    53,  55,  56,  55,  124, 52,  48,  49,  51,  49,  53,  52,  46,  53,  54,
+    10,  55,  49,  52,  124, 52,  48,  49,  48,  50,  52,  57,  46,  52,  52,
+    10,  56,  56,  49,  49,  124, 52,  48,  48,  57,  53,  56,  56,  46,  57,
+    48,  10,  49,  52,  51,  56,  54,  124, 52,  48,  48,  55,  50,  49,  48,
+    46,  56,  56,  10,  54,  49,  54,  124, 52,  48,  48,  52,  48,  53,  55,
+    46,  50,  54,  10,  55,  52,  54,  48,  124, 52,  48,  48,  51,  52,  49,
+    50,  46,  52,  56,  10,  56,  54,  54,  124, 52,  48,  48,  51,  49,  56,
+    50,  46,  53,  52,  10,  55,  56,  50,  124, 52,  48,  48,  49,  50,  57,
+    57,  46,  57,  52,  10,  56,  53,  54,  50,  124, 51,  57,  57,  57,  52,
+    52,  49,  46,  54,  50,  10,  49,  51,  54,  54,  124, 51,  57,  57,  52,
+    48,  54,  48,  46,  56,  54,  10,  50,  56,  55,  57,  124, 51,  57,  57,
+    51,  48,  53,  54,  46,  53,  53,  10,  49,  54,  54,  55,  57,  124, 51,
+    57,  57,  50,  52,  51,  52,  46,  57,  57,  10,  49,  55,  51,  48,  54,
+    124, 51,  57,  57,  48,  55,  50,  51,  46,  51,  48,  10,  49,  51,  49,
+    52,  48,  124, 51,  57,  56,  50,  56,  49,  55,  46,  51,  57,  10,  49,
+    55,  57,  52,  50,  124, 51,  57,  56,  48,  56,  53,  55,  46,  48,  52,
+    10,  54,  53,  55,  50,  124, 51,  57,  55,  55,  54,  55,  54,  46,  50,
+    56,  10,  51,  53,  55,  56,  124, 51,  57,  55,  55,  53,  50,  51,  46,
+    57,  52,  10,  49,  53,  56,  48,  50,  124, 51,  57,  54,  57,  57,  52,
+    54,  46,  57,  48,  10,  51,  51,  54,  124, 51,  57,  54,  55,  57,  51,
+    56,  46,  51,  56,  10,  57,  56,  48,  55,  124, 51,  57,  54,  52,  52,
+    54,  57,  46,  54,  48,  10,  49,  50,  49,  48,  52,  124, 51,  57,  54,
+    52,  50,  55,  51,  46,  52,  48,  10,  52,  50,  55,  49,  124, 51,  57,
+    54,  50,  51,  53,  57,  46,  50,  56,  10,  54,  55,  48,  50,  124, 51,
+    57,  54,  49,  54,  53,  55,  46,  52,  52,  10,  49,  57,  55,  54,  51,
+    124, 51,  57,  53,  53,  53,  56,  50,  46,  55,  53,  10,  51,  54,  57,
+    124, 51,  57,  53,  51,  55,  48,  50,  46,  56,  56,  10,  52,  48,  56,
+    57,  124, 51,  57,  53,  51,  52,  53,  53,  46,  54,  56,  10,  50,  53,
+    57,  51,  124, 51,  57,  52,  54,  49,  53,  51,  46,  56,  48,  10,  53,
+    57,  48,  124, 51,  57,  52,  51,  56,  52,  49,  46,  49,  54,  10,  56,
+    51,  50,  53,  124, 51,  57,  52,  50,  49,  49,  56,  46,  55,  53,  10,
+    49,  53,  56,  124, 51,  57,  52,  49,  56,  56,  49,  46,  54,  53,  10,
+    49,  50,  48,  53,  52,  124, 51,  57,  51,  56,  51,  54,  50,  46,  54,
+    57,  10,  49,  56,  51,  51,  48,  124, 51,  57,  51,  56,  51,  48,  51,
+    46,  56,  56,  10,  53,  51,  53,  52,  124, 51,  57,  51,  54,  50,  51,
+    57,  46,  53,  56,  10,  56,  49,  53,  48,  124, 51,  57,  50,  53,  55,
+    57,  51,  46,  52,  54,  10,  56,  51,  52,  52,  124, 51,  57,  50,  49,
+    50,  57,  51,  46,  54,  48,  10,  54,  48,  54,  57,  124, 51,  57,  50,
+    49,  49,  51,  48,  46,  53,  53,  10,  52,  48,  51,  50,  124, 51,  57,
+    50,  48,  48,  48,  56,  46,  53,  57,  10,  49,  55,  57,  51,  57,  124,
+    51,  57,  49,  55,  55,  53,  48,  46,  50,  55,  10,  55,  48,  49,  52,
+    124, 51,  57,  49,  52,  52,  55,  49,  46,  50,  48,  10,  50,  56,  52,
+    48,  124, 51,  57,  49,  51,  49,  51,  49,  46,  53,  56,  10,  49,  56,
+    54,  56,  124, 51,  57,  49,  50,  57,  56,  55,  46,  53,  52,  10,  49,
+    48,  57,  55,  53,  124, 51,  57,  49,  49,  57,  50,  48,  46,  52,  56,
+    10,  53,  51,  55,  52,  124, 51,  57,  49,  48,  56,  48,  50,  46,  55,
+    52,  10,  49,  49,  49,  50,  56,  124, 51,  57,  48,  56,  49,  53,  54,
+    46,  52,  54,  10,  49,  56,  52,  52,  57,  124, 51,  57,  48,  55,  53,
+    56,  57,  46,  52,  48,  10,  49,  49,  55,  52,  48,  124, 51,  57,  48,
+    55,  52,  53,  57,  46,  56,  52,  10,  50,  51,  53,  54,  124, 51,  57,
+    48,  55,  49,  56,  57,  46,  48,  48,  10,  53,  55,  50,  49,  124, 51,
+    57,  48,  49,  53,  56,  53,  46,  57,  55,  10,  52,  50,  51,  49,  124,
+    51,  57,  48,  48,  55,  55,  57,  46,  48,  53,  10,  52,  51,  53,  50,
+    124, 51,  56,  57,  57,  57,  51,  51,  46,  52,  52,  10,  52,  51,  50,
+    124, 51,  56,  57,  57,  56,  51,  54,  46,  52,  52,  10,  49,  53,  51,
+    50,  49,  124, 51,  56,  57,  57,  53,  49,  54,  46,  53,  56,  10,  49,
+    48,  50,  57,  54,  124, 51,  56,  57,  55,  48,  49,  53,  46,  49,  52,
+    10,  53,  54,  52,  55,  124, 51,  56,  57,  53,  48,  56,  56,  46,  49,
+    54,  10,  55,  51,  56,  54,  124, 51,  56,  57,  49,  57,  49,  54,  46,
+    53,  49,  10,  53,  48,  55,  124, 51,  56,  57,  49,  52,  56,  55,  46,
+    54,  56,  10,  51,  57,  57,  53,  124, 51,  56,  56,  55,  51,  56,  55,
+    46,  48,  55,  10,  52,  50,  55,  56,  124, 51,  56,  56,  50,  50,  57,
+    52,  46,  48,  50,  10,  49,  56,  52,  48,  55,  124, 51,  56,  56,  48,
+    50,  54,  55,  46,  56,  54,  10,  54,  49,  50,  55,  124, 51,  56,  55,
+    57,  49,  54,  54,  46,  55,  49,  10,  49,  52,  53,  124, 51,  56,  55,
+    53,  50,  55,  55,  46,  50,  52,  10,  49,  57,  50,  54,  57,  124, 51,
+    56,  55,  52,  54,  56,  53,  46,  55,  54,  10,  49,  56,  50,  53,  55,
+    124, 51,  56,  55,  52,  52,  53,  52,  46,  56,  57,  10,  57,  48,  54,
+    56,  124, 51,  56,  54,  57,  55,  54,  55,  46,  55,  52,  10,  53,  55,
+    54,  124, 51,  56,  54,  48,  48,  48,  55,  46,  55,  57,  10,  52,  56,
+    54,  48,  124, 51,  56,  53,  50,  56,  54,  50,  46,  48,  50,  10,  49,
+    56,  55,  57,  51,  124, 51,  56,  52,  57,  56,  51,  56,  46,  49,  54,
+    10,  49,  53,  57,  56,  56,  124, 51,  56,  52,  55,  50,  53,  55,  46,
+    48,  53,  10,  54,  56,  57,  49,  124, 51,  56,  52,  54,  51,  56,  54,
+    46,  55,  53,  10,  51,  50,  51,  49,  124, 51,  56,  52,  54,  51,  52,
+    52,  46,  51,  48,  10,  49,  53,  50,  51,  55,  124, 51,  56,  52,  53,
+    52,  50,  49,  46,  48,  48,  10,  57,  48,  51,  53,  124, 51,  56,  52,
+    52,  49,  54,  54,  46,  56,  53,  10,  55,  53,  57,  55,  124, 51,  56,
+    51,  56,  54,  52,  51,  46,  51,  53,  10,  49,  54,  51,  52,  57,  124,
+    51,  56,  51,  55,  49,  50,  49,  46,  54,  53,  10,  50,  52,  57,  55,
+    124, 51,  56,  50,  55,  56,  53,  48,  46,  50,  48,  10,  51,  54,  49,
+    54,  124, 51,  56,  50,  55,  51,  57,  48,  46,  57,  53,  10,  49,  49,
+    53,  54,  54,  124, 51,  56,  50,  54,  49,  50,  50,  46,  52,  55,  10,
+    49,  56,  52,  48,  51,  124, 51,  56,  50,  50,  48,  51,  51,  46,  48,
+    50,  10,  50,  57,  55,  50,  124, 51,  56,  50,  49,  57,  48,  51,  46,
+    53,  53,  10,  56,  49,  50,  124, 51,  56,  50,  49,  53,  50,  51,  46,
+    55,  50,  10,  50,  48,  52,  51,  124, 51,  56,  50,  48,  53,  54,  49,
+    46,  51,  54,  10,  53,  48,  53,  124, 51,  56,  49,  56,  57,  50,  50,
+    46,  48,  51,  10,  56,  50,  53,  55,  124, 51,  56,  49,  53,  48,  55,
+    49,  46,  57,  50,  10,  54,  48,  56,  52,  124, 51,  56,  49,  52,  49,
+    57,  52,  46,  57,  53,  10,  49,  49,  50,  53,  51,  124, 51,  56,  49,
+    51,  57,  49,  55,  46,  50,  52,  10,  51,  54,  54,  124, 51,  56,  49,
+    50,  50,  53,  55,  46,  56,  56,  10,  49,  51,  54,  51,  50,  124, 51,
+    56,  49,  49,  54,  48,  49,  46,  51,  50,  10,  49,  52,  50,  57,  56,
+    124, 51,  56,  48,  49,  52,  49,  50,  46,  52,  50,  10,  55,  48,  57,
+    50,  124, 51,  55,  57,  56,  55,  50,  57,  46,  52,  56,  10,  50,  48,
+    53,  56,  124, 51,  55,  57,  54,  49,  48,  57,  46,  48,  52,  10,  49,
+    52,  56,  50,  48,  124, 51,  55,  57,  49,  49,  57,  53,  46,  56,  54,
+    10,  55,  49,  53,  55,  124, 51,  55,  56,  56,  54,  57,  48,  46,  56,
+    50,  10,  49,  55,  50,  49,  49,  124, 51,  55,  56,  54,  48,  51,  48,
+    46,  49,  55,  10,  49,  54,  54,  52,  52,  124, 51,  55,  56,  54,  48,
+    49,  57,  46,  50,  53,  10,  49,  53,  54,  57,  51,  124, 51,  55,  56,
+    51,  54,  54,  50,  46,  49,  57,  10,  50,  54,  50,  55,  124, 51,  55,
+    56,  50,  51,  57,  52,  46,  54,  48,  10,  49,  49,  50,  51,  49,  124,
+    51,  55,  56,  50,  48,  55,  55,  46,  54,  48,  10,  49,  50,  54,  57,
+    54,  124, 51,  55,  56,  49,  55,  54,  49,  46,  54,  54,  10,  56,  55,
+    48,  53,  124, 51,  55,  55,  56,  48,  55,  55,  46,  48,  48,  10,  49,
+    54,  48,  53,  50,  124, 51,  55,  55,  49,  53,  55,  55,  46,  48,  52,
+    10,  57,  57,  124, 51,  55,  54,  48,  50,  54,  57,  46,  51,  49,  10,
+    50,  48,  56,  50,  124, 51,  55,  53,  55,  53,  49,  55,  46,  53,  48,
+    10,  56,  55,  50,  124, 51,  55,  53,  48,  48,  48,  53,  46,  51,  52,
+    10,  55,  49,  50,  54,  124, 51,  55,  52,  57,  49,  51,  56,  46,  57,
+    50,  10,  49,  48,  51,  48,  50,  124, 51,  55,  52,  52,  52,  55,  53,
+    46,  50,  53,  10,  49,  55,  49,  50,  50,  124, 51,  55,  52,  49,  48,
+    49,  50,  46,  57,  56,  10,  49,  48,  48,  56,  48,  124, 51,  55,  52,
+    48,  49,  48,  55,  46,  49,  48,  10,  49,  54,  48,  50,  49,  124, 51,
+    55,  51,  57,  54,  49,  49,  46,  50,  48,  10,  51,  48,  55,  52,  124,
+    51,  55,  51,  57,  50,  50,  52,  46,  57,  54,  10,  51,  49,  52,  50,
+    124, 51,  55,  51,  56,  56,  49,  49,  46,  48,  50,  10,  49,  51,  50,
+    49,  51,  124, 51,  55,  51,  53,  49,  49,  54,  46,  50,  53,  10,  49,
+    51,  52,  52,  50,  124, 51,  55,  51,  51,  49,  51,  50,  46,  49,  52,
+    10,  49,  49,  53,  52,  50,  124, 51,  55,  51,  49,  48,  48,  48,  46,
+    49,  50,  10,  49,  51,  55,  51,  50,  124, 51,  55,  51,  48,  52,  52,
+    52,  46,  57,  48,  10,  50,  54,  48,  56,  124, 51,  55,  50,  57,  51,
+    55,  50,  46,  52,  48,  10,  53,  124, 51,  55,  50,  53,  53,  49,  49,
+    46,  53,  48,  10,  49,  57,  49,  53,  55,  124, 51,  55,  50,  51,  56,
+    52,  52,  46,  55,  50,  10,  49,  56,  50,  51,  49,  124, 51,  55,  50,
+    49,  55,  48,  55,  46,  57,  57,  10,  56,  49,  55,  57,  124, 51,  55,
+    49,  52,  49,  53,  53,  46,  48,  52,  10,  49,  50,  55,  52,  48,  124,
+    51,  55,  48,  56,  54,  52,  54,  46,  57,  49,  10,  49,  49,  53,  57,
+    55,  124, 51,  55,  48,  54,  53,  50,  56,  46,  53,  57,  10,  49,  51,
+    57,  54,  56,  124, 51,  55,  48,  50,  51,  55,  54,  46,  48,  56,  10,
+    54,  52,  51,  54,  124, 51,  54,  56,  55,  51,  52,  54,  46,  52,  52,
+    10,  57,  49,  56,  49,  124, 51,  54,  56,  55,  49,  51,  52,  46,  48,
+    56,  10,  53,  54,  52,  124, 51,  54,  56,  48,  50,  48,  48,  46,  56,
+    48,  10,  49,  51,  52,  54,  52,  124, 51,  54,  55,  56,  52,  48,  54,
+    46,  50,  48,  10,  49,  52,  48,  56,  52,  124, 51,  54,  55,  51,  55,
+    57,  48,  46,  51,  56,  10,  50,  55,  53,  53,  124, 51,  54,  55,  48,
+    53,  57,  51,  46,  54,  57,  10,  49,  52,  50,  56,  52,  124, 51,  54,
+    54,  56,  54,  52,  48,  46,  56,  48,  10,  49,  50,  49,  55,  56,  124,
+    51,  54,  53,  51,  51,  57,  50,  46,  52,  56,  10,  49,  53,  55,  51,
+    48,  124, 51,  54,  53,  48,  50,  53,  56,  46,  51,  48,  10,  53,  53,
+    54,  48,  124, 51,  54,  52,  57,  53,  54,  57,  46,  53,  57,  10,  56,
+    53,  57,  52,  124, 51,  54,  52,  55,  49,  52,  48,  46,  53,  54,  10,
+    55,  48,  51,  50,  124, 51,  54,  52,  54,  52,  51,  57,  46,  53,  52,
+    10,  49,  54,  56,  52,  54,  124, 51,  54,  52,  52,  56,  52,  51,  46,
+    49,  48,  10,  49,  53,  51,  48,  124, 51,  54,  52,  50,  56,  51,  56,
+    46,  48,  56,  10,  51,  57,  55,  56,  124, 51,  54,  51,  57,  55,  49,
+    50,  46,  48,  53,  10,  50,  56,  57,  55,  124, 51,  54,  51,  57,  52,
+    52,  50,  46,  51,  50,  10,  49,  54,  54,  50,  53,  124, 51,  54,  51,
+    54,  53,  50,  55,  46,  53,  52,  10,  49,  50,  48,  50,  57,  124, 51,
+    54,  51,  54,  51,  51,  57,  46,  55,  50,  10,  49,  54,  56,  51,  48,
+    124, 51,  54,  51,  51,  52,  52,  56,  46,  53,  55,  10,  57,  53,  57,
+    55,  124, 51,  54,  51,  50,  54,  54,  50,  46,  49,  49,  10,  53,  53,
+    51,  51,  124, 51,  54,  51,  48,  51,  51,  56,  46,  54,  55,  10,  53,
+    49,  56,  49,  124, 51,  54,  50,  53,  57,  54,  53,  46,  57,  51,  10,
+    56,  49,  51,  49,  124, 51,  54,  50,  53,  55,  51,  56,  46,  54,  50,
+    10,  56,  53,  54,  48,  124, 51,  54,  50,  48,  55,  54,  49,  46,  50,
+    54,  10,  49,  49,  56,  54,  48,  124, 51,  54,  49,  56,  55,  52,  54,
+    46,  50,  53,  10,  49,  50,  48,  48,  56,  124, 51,  54,  49,  52,  54,
+    48,  52,  46,  52,  48,  10,  49,  48,  55,  51,  55,  124, 51,  54,  49,
+    49,  57,  57,  48,  46,  54,  52,  10,  49,  56,  50,  48,  56,  124, 51,
+    54,  49,  49,  53,  57,  54,  46,  49,  48,  10,  53,  49,  49,  57,  124,
+    51,  54,  49,  49,  48,  51,  56,  46,  50,  48,  10,  49,  49,  57,  53,
+    56,  124, 51,  54,  48,  49,  54,  53,  52,  46,  54,  53,  10,  49,  53,
+    49,  50,  52,  124, 51,  53,  57,  56,  50,  55,  56,  46,  50,  48,  10,
+    49,  52,  48,  53,  56,  124, 51,  53,  57,  55,  52,  57,  48,  46,  48,
+    50,  10,  49,  50,  50,  55,  48,  124, 51,  53,  57,  51,  57,  49,  50,
+    46,  49,  48,  10,  49,  55,  55,  57,  51,  124, 51,  53,  57,  51,  51,
+    49,  56,  46,  57,  53,  10,  57,  51,  56,  53,  124, 51,  53,  56,  55,
+    51,  50,  55,  46,  56,  52,  10,  49,  50,  56,  49,  52,  124, 51,  53,
+    56,  55,  48,  56,  51,  46,  56,  52,  10,  53,  51,  48,  52,  124, 51,
+    53,  56,  54,  50,  51,  48,  46,  54,  49,  10,  51,  54,  51,  49,  124,
+    51,  53,  56,  50,  56,  52,  49,  46,  54,  53,  10,  54,  49,  48,  124,
+    51,  53,  56,  49,  57,  49,  55,  46,  51,  48,  10,  49,  57,  51,  49,
+    55,  124, 51,  53,  56,  48,  52,  49,  50,  46,  52,  51,  10,  49,  50,
+    56,  124, 51,  53,  54,  55,  48,  48,  52,  46,  53,  54,  10,  49,  49,
+    54,  49,  54,  124, 51,  53,  54,  54,  49,  53,  52,  46,  56,  48,  10,
+    49,  48,  49,  55,  54,  124, 51,  53,  54,  53,  51,  57,  50,  46,  49,
+    53,  10,  55,  51,  52,  57,  124, 51,  53,  54,  52,  49,  49,  48,  46,
+    54,  52,  10,  49,  55,  49,  50,  124, 51,  53,  54,  48,  52,  48,  56,
+    46,  52,  51,  10,  49,  56,  56,  54,  48,  124, 51,  53,  53,  57,  51,
+    52,  48,  46,  54,  48,  10,  49,  55,  54,  49,  55,  124, 51,  53,  53,
+    55,  53,  49,  54,  46,  48,  48,  10,  54,  52,  52,  51,  124, 51,  53,
+    53,  54,  50,  57,  54,  46,  57,  54,  10,  49,  53,  52,  48,  56,  124,
+    51,  53,  53,  52,  56,  49,  52,  46,  53,  54,  10,  49,  54,  51,  53,
+    48,  124, 51,  53,  53,  52,  51,  56,  56,  46,  54,  51,  10,  49,  55,
+    52,  51,  54,  124, 51,  53,  53,  52,  49,  48,  53,  46,  49,  51,  10,
+    53,  55,  52,  48,  124, 51,  53,  53,  49,  51,  50,  52,  46,  54,  56,
+    10,  49,  50,  49,  56,  49,  124, 51,  53,  53,  48,  50,  49,  56,  46,
+    53,  52,  10,  49,  54,  56,  57,  53,  124, 51,  53,  53,  48,  49,  49,
+    57,  46,  51,  48,  10,  49,  57,  57,  57,  53,  124, 51,  53,  52,  56,
+    56,  51,  57,  46,  55,  48,  10,  52,  57,  54,  56,  124, 51,  53,  52,
+    56,  51,  48,  54,  46,  56,  55,  10,  50,  50,  53,  55,  124, 51,  53,
+    52,  54,  54,  57,  50,  46,  50,  57,  10,  49,  56,  50,  53,  124, 51,
+    53,  52,  51,  49,  57,  56,  46,  55,  56,  10,  49,  56,  57,  56,  57,
+    124, 51,  53,  51,  57,  48,  51,  56,  46,  48,  56,  10,  49,  56,  55,
+    50,  55,  124, 51,  53,  51,  54,  48,  56,  49,  46,  52,  48,  10,  49,
+    54,  49,  54,  53,  124, 51,  53,  51,  51,  55,  56,  57,  46,  56,  52,
+    10,  51,  50,  52,  57,  124, 51,  53,  51,  51,  55,  48,  57,  46,  56,
+    55,  10,  49,  49,  55,  51,  49,  124, 51,  53,  51,  50,  56,  55,  53,
+    46,  48,  48,  10,  49,  51,  48,  51,  50,  124, 51,  53,  51,  50,  52,
+    49,  53,  46,  55,  57,  10,  57,  51,  55,  55,  124, 51,  53,  51,  49,
+    53,  56,  50,  46,  48,  56,  10,  53,  56,  56,  51,  124, 51,  53,  51,
+    49,  52,  55,  57,  46,  48,  48,  10,  49,  50,  49,  49,  124, 51,  53,
+    50,  56,  56,  51,  51,  46,  52,  48,  10,  49,  50,  48,  54,  53,  124,
+    51,  53,  50,  54,  57,  52,  56,  46,  49,  48,  10,  49,  48,  56,  54,
+    54,  124, 51,  53,  50,  54,  49,  52,  54,  46,  54,  54,  10,  50,  48,
+    55,  51,  124, 51,  53,  50,  48,  49,  51,  49,  46,  51,  48,  10,  50,
+    51,  55,  56,  124, 51,  53,  49,  50,  49,  56,  54,  46,  50,  48,  10,
+    49,  54,  56,  54,  48,  124, 51,  53,  48,  57,  54,  57,  51,  46,  48,
+    55,  10,  51,  56,  57,  124, 51,  53,  48,  55,  56,  49,  52,  46,  54,
+    52,  10,  49,  53,  54,  48,  52,  124, 51,  53,  48,  53,  54,  53,  51,
+    46,  50,  55,  10,  49,  49,  50,  53,  55,  124, 51,  53,  48,  50,  56,
+    51,  49,  46,  56,  48,  10,  49,  51,  50,  55,  124, 51,  53,  48,  50,
+    48,  50,  50,  46,  54,  48,  10,  49,  54,  54,  48,  50,  124, 51,  53,
+    48,  49,  48,  55,  52,  46,  56,  56,  10,  49,  52,  57,  51,  124, 51,
+    52,  57,  56,  56,  48,  56,  46,  57,  53,  10,  56,  50,  50,  52,  124,
+    51,  52,  57,  56,  49,  55,  57,  46,  53,  50,  10,  54,  50,  50,  124,
+    51,  52,  57,  55,  49,  53,  56,  46,  51,  54,  10,  51,  48,  55,  50,
+    124, 51,  52,  57,  53,  57,  53,  56,  46,  55,  50,  10,  49,  52,  55,
+    56,  124, 51,  52,  57,  52,  56,  56,  48,  46,  52,  56,  10,  51,  49,
+    50,  53,  124, 51,  52,  57,  52,  49,  54,  57,  46,  57,  48,  10,  50,
+    48,  53,  50,  124, 51,  52,  56,  56,  52,  51,  56,  46,  48,  56,  10,
+    56,  52,  55,  54,  124, 51,  52,  56,  55,  49,  57,  49,  46,  50,  56,
+    10,  49,  48,  55,  51,  53,  124, 51,  52,  55,  55,  55,  52,  48,  46,
+    55,  54,  10,  49,  52,  56,  54,  48,  124, 51,  52,  55,  54,  50,  51,
+    53,  46,  56,  52,  10,  54,  53,  56,  54,  124, 51,  52,  55,  53,  55,
+    52,  53,  46,  49,  48,  10,  53,  49,  51,  48,  124, 51,  52,  55,  50,
+    48,  50,  52,  46,  53,  48,  10,  55,  49,  56,  49,  124, 51,  52,  55,
+    49,  51,  48,  54,  46,  51,  48,  10,  54,  49,  56,  124, 51,  52,  54,
+    55,  57,  48,  54,  46,  53,  50,  10,  49,  53,  54,  57,  56,  124, 51,
+    52,  54,  52,  56,  53,  57,  46,  52,  55,  10,  49,  55,  53,  56,  53,
+    124, 51,  52,  54,  50,  52,  53,  48,  46,  52,  54,  10,  50,  53,  52,
+    56,  124, 51,  52,  53,  54,  56,  53,  54,  46,  57,  54,  10,  50,  54,
+    51,  50,  124, 51,  52,  53,  54,  50,  51,  48,  46,  55,  52,  10,  50,
+    56,  56,  50,  124, 51,  52,  53,  51,  57,  56,  54,  46,  56,  54,  10,
+    49,  50,  50,  49,  54,  124, 51,  52,  53,  50,  57,  48,  55,  46,  49,
+    53,  10,  52,  57,  50,  53,  124, 51,  52,  53,  50,  57,  48,  52,  46,
+    54,  51,  10,  57,  48,  49,  50,  124, 51,  52,  52,  50,  53,  56,  49,
+    46,  51,  54,  10,  54,  54,  54,  55,  124, 51,  52,  51,  48,  48,  55,
+    54,  46,  52,  48,  10,  49,  55,  57,  53,  56,  124, 51,  52,  50,  52,
+    57,  54,  50,  46,  53,  54,  10,  54,  48,  57,  51,  124, 51,  52,  50,
+    52,  50,  52,  49,  46,  57,  50,  10,  49,  48,  54,  52,  56,  124, 51,
+    52,  49,  55,  52,  49,  52,  46,  48,  48,  10,  49,  52,  54,  50,  124,
+    51,  52,  49,  51,  50,  52,  56,  46,  54,  49,  10,  50,  53,  54,  57,
+    124, 51,  52,  49,  50,  51,  56,  56,  46,  56,  50,  10,  49,  56,  54,
+    49,  54,  124, 51,  52,  48,  57,  56,  56,  48,  46,  57,  49,  10,  55,
+    51,  54,  56,  124, 51,  52,  48,  56,  48,  51,  54,  46,  52,  53,  10,
+    51,  49,  49,  48,  124, 51,  52,  48,  55,  51,  55,  52,  46,  54,  48,
+    10,  49,  48,  56,  50,  52,  124, 51,  52,  48,  54,  56,  49,  57,  46,
+    50,  57,  10,  49,  49,  53,  49,  48,  124, 51,  52,  48,  52,  55,  48,
+    49,  46,  57,  54,  10,  52,  56,  52,  48,  124, 51,  51,  57,  55,  50,
+    51,  54,  46,  52,  48,  10,  52,  52,  52,  57,  124, 51,  51,  57,  54,
+    57,  57,  51,  46,  54,  48,  10,  49,  51,  53,  56,  124, 51,  51,  57,
+    54,  54,  49,  54,  46,  51,  50,  10,  51,  56,  56,  53,  124, 51,  51,
+    57,  53,  56,  49,  55,  46,  54,  48,  10,  49,  51,  51,  56,  49,  124,
+    51,  51,  57,  49,  57,  53,  51,  46,  53,  50,  10,  49,  54,  53,  53,
+    124, 51,  51,  56,  51,  48,  53,  49,  46,  53,  49,  10,  50,  56,  50,
+    124, 51,  51,  56,  49,  55,  56,  53,  46,  52,  50,  10,  52,  57,  50,
+    56,  124, 51,  51,  55,  52,  50,  55,  48,  46,  52,  56,  10,  51,  49,
+    57,  57,  124, 51,  51,  55,  50,  52,  56,  56,  46,  56,  48,  10,  49,
+    54,  48,  56,  54,  124, 51,  51,  55,  48,  55,  49,  48,  46,  54,  53,
+    10,  56,  54,  49,  50,  124, 51,  51,  54,  50,  57,  50,  50,  46,  53,
+    48,  10,  49,  57,  53,  57,  55,  124, 51,  51,  54,  48,  55,  54,  52,
+    46,  48,  48,  10,  56,  56,  54,  55,  124, 51,  51,  53,  52,  52,  48,
+    48,  46,  49,  49,  10,  52,  48,  57,  56,  124, 51,  51,  53,  51,  53,
+    55,  52,  46,  50,  56,  10,  49,  50,  54,  49,  55,  124, 51,  51,  53,
+    49,  52,  57,  57,  46,  48,  53,  10,  49,  52,  51,  54,  53,  124, 51,
+    51,  52,  55,  50,  57,  54,  46,  48,  48,  10,  49,  48,  52,  52,  51,
+    124, 51,  51,  52,  53,  52,  57,  51,  46,  49,  48,  10,  55,  54,  124,
+    51,  51,  52,  50,  48,  56,  49,  46,  56,  50,  10,  49,  49,  53,  56,
+    53,  124, 51,  51,  52,  49,  57,  52,  49,  46,  50,  50,  10,  52,  51,
+    56,  51,  124, 51,  51,  51,  56,  57,  54,  48,  46,  50,  55,  10,  49,
+    51,  57,  49,  48,  124, 51,  51,  51,  53,  57,  54,  52,  46,  49,  54,
+    10,  56,  48,  55,  54,  124, 51,  51,  51,  50,  52,  52,  57,  46,  56,
+    57,  10,  49,  54,  48,  48,  53,  124, 51,  51,  51,  50,  49,  57,  48,
+    46,  52,  48,  10,  50,  54,  50,  50,  124, 51,  51,  50,  57,  51,  54,
+    52,  46,  52,  53,  10,  49,  50,  56,  50,  50,  124, 51,  51,  50,  49,
+    49,  56,  51,  46,  53,  50,  10,  49,  55,  48,  55,  54,  124, 51,  51,
+    50,  48,  51,  57,  56,  46,  48,  54,  10,  53,  51,  57,  50,  124, 51,
+    51,  50,  48,  51,  53,  55,  46,  49,  53,  10,  49,  56,  54,  50,  56,
+    124, 51,  51,  49,  57,  54,  49,  53,  46,  56,  52,  10,  49,  51,  54,
+    57,  53,  124, 51,  51,  49,  56,  53,  50,  53,  46,  57,  57,  10,  49,
+    48,  51,  50,  54,  124, 51,  51,  49,  56,  50,  55,  52,  46,  49,  54,
+    10,  57,  49,  48,  57,  124, 51,  51,  49,  55,  56,  51,  51,  46,  57,
+    48,  10,  49,  52,  56,  57,  124, 51,  51,  49,  55,  54,  50,  48,  46,
+    56,  48,  10,  51,  51,  55,  56,  124, 51,  51,  49,  53,  57,  52,  56,
+    46,  48,  48,  10,  55,  55,  51,  56,  124, 51,  51,  49,  50,  57,  55,
+    57,  46,  50,  48,  10,  49,  56,  52,  52,  124, 51,  51,  49,  50,  50,
+    55,  55,  46,  51,  54,  10,  49,  57,  57,  54,  51,  124, 51,  51,  48,
+    55,  53,  48,  48,  46,  48,  48,  10,  50,  52,  51,  54,  124, 51,  51,
+    48,  54,  52,  49,  57,  46,  48,  53,  10,  56,  56,  54,  124, 51,  51,
+    48,  50,  49,  56,  48,  46,  55,  48,  10,  49,  53,  52,  55,  53,  124,
+    51,  51,  48,  49,  54,  57,  51,  46,  53,  48,  10,  54,  51,  50,  55,
+    124, 51,  51,  48,  48,  54,  56,  48,  46,  55,  56,  10,  54,  48,  53,
+    48,  124, 51,  50,  57,  57,  52,  54,  48,  46,  50,  48,  10,  57,  56,
+    55,  54,  124, 51,  50,  57,  56,  52,  49,  48,  46,  48,  53,  10,  49,
+    57,  53,  56,  54,  124, 51,  50,  57,  49,  49,  51,  49,  46,  50,  53,
+    10,  49,  52,  51,  52,  57,  124, 51,  50,  56,  57,  56,  54,  50,  46,
+    53,  50,  10,  49,  48,  57,  57,  51,  124, 51,  50,  56,  55,  57,  56,
+    48,  46,  53,  55,  10,  49,  56,  55,  56,  52,  124, 51,  50,  56,  54,
+    55,  53,  50,  46,  49,  50,  10,  49,  56,  48,  48,  124, 51,  50,  56,
+    53,  52,  54,  54,  46,  50,  52,  10,  57,  57,  48,  124, 51,  50,  56,
+    52,  53,  57,  53,  46,  53,  48,  10,  51,  56,  50,  51,  124, 51,  50,
+    56,  49,  57,  57,  50,  46,  57,  52,  10,  49,  53,  55,  51,  55,  124,
+    51,  50,  55,  57,  51,  48,  53,  46,  57,  54,  10,  49,  57,  53,  49,
+    56,  124, 51,  50,  55,  54,  55,  53,  57,  46,  54,  51,  10,  57,  48,
+    51,  50,  124, 51,  50,  55,  50,  52,  52,  48,  46,  51,  50,  10,  55,
+    55,  56,  54,  124, 51,  50,  55,  49,  50,  49,  55,  46,  50,  56,  10,
+    56,  54,  52,  56,  124, 51,  50,  55,  49,  49,  54,  50,  46,  52,  52,
+    10,  53,  53,  51,  50,  124, 51,  50,  55,  48,  49,  56,  55,  46,  57,
+    55,  10,  49,  53,  57,  49,  52,  124, 51,  50,  54,  56,  53,  50,  48,
+    46,  57,  56,  10,  49,  54,  48,  54,  53,  124, 51,  50,  54,  53,  48,
+    54,  56,  46,  56,  52,  10,  49,  49,  50,  49,  50,  124, 51,  50,  54,
+    52,  54,  53,  55,  46,  48,  51,  10,  49,  51,  50,  50,  57,  124, 51,
+    50,  54,  50,  48,  50,  50,  46,  50,  56,  10,  49,  53,  56,  50,  55,
+    124, 51,  50,  54,  48,  56,  54,  50,  46,  55,  50,  10,  49,  53,  56,
+    50,  124, 51,  50,  54,  48,  51,  52,  48,  46,  48,  48,  10,  51,  56,
+    50,  55,  124, 51,  50,  54,  48,  48,  57,  51,  46,  55,  54,  10,  51,
+    53,  52,  54,  124, 51,  50,  53,  57,  50,  52,  52,  46,  48,  55,  10,
+    49,  53,  56,  52,  57,  124, 51,  50,  53,  56,  57,  49,  56,  46,  48,
+    48,  10,  49,  52,  56,  53,  54,  124, 51,  50,  53,  56,  51,  55,  57,
+    46,  52,  48,  10,  50,  48,  50,  56,  124, 51,  50,  53,  53,  48,  49,
+    51,  46,  57,  54,  10,  54,  54,  49,  56,  124, 51,  50,  53,  52,  53,
+    56,  49,  46,  57,  53,  10,  49,  55,  52,  54,  49,  124, 51,  50,  53,
+    50,  57,  50,  54,  46,  56,  56,  10,  49,  51,  53,  53,  49,  124, 51,
+    50,  52,  49,  54,  48,  50,  46,  50,  48,  10,  49,  57,  53,  54,  49,
+    124, 51,  50,  51,  57,  55,  57,  53,  46,  51,  50,  10,  50,  50,  55,
+    54,  124, 51,  50,  51,  54,  49,  55,  50,  46,  51,  48,  10,  49,  52,
+    50,  48,  51,  124, 51,  50,  51,  52,  54,  52,  57,  46,  51,  57,  10,
+    55,  55,  53,  55,  124, 51,  50,  51,  49,  51,  53,  49,  46,  56,  52,
+    10,  49,  50,  50,  124, 51,  50,  50,  54,  50,  49,  51,  46,  56,  56,
+    10,  49,  50,  57,  53,  52,  124, 51,  50,  50,  53,  57,  52,  51,  46,
+    48,  48,  10,  54,  52,  55,  124, 51,  50,  50,  52,  55,  56,  51,  46,
+    55,  54,  10,  49,  50,  51,  56,  51,  124, 51,  50,  50,  51,  57,  56,
+    57,  46,  52,  52,  10,  51,  56,  51,  49,  124, 51,  50,  50,  51,  49,
+    50,  54,  46,  54,  48,  10,  49,  54,  56,  51,  54,  124, 51,  50,  50,
+    50,  50,  54,  48,  46,  55,  51,  10,  52,  53,  54,  53,  124, 51,  50,
+    50,  49,  53,  57,  55,  46,  52,  52,  10,  49,  57,  52,  50,  54,  124,
+    51,  50,  49,  56,  49,  48,  54,  46,  53,  52,  10,  49,  55,  56,  53,
+    53,  124, 51,  50,  49,  55,  56,  49,  51,  46,  48,  50,  10,  53,  54,
+    50,  52,  124, 51,  50,  48,  55,  55,  55,  55,  46,  51,  54,  10,  56,
+    51,  54,  56,  124, 51,  50,  48,  51,  51,  55,  54,  46,  52,  53,  10,
+    57,  52,  56,  48,  124, 51,  50,  48,  48,  57,  48,  52,  46,  48,  48,
+    10,  49,  49,  49,  56,  49,  124, 51,  49,  57,  57,  53,  48,  48,  46,
+    53,  51,  10,  56,  57,  56,  49,  124, 51,  49,  57,  55,  56,  54,  52,
+    46,  48,  48,  10,  49,  54,  52,  50,  54,  124, 51,  49,  57,  53,  57,
+    57,  53,  46,  57,  55,  10,  49,  54,  52,  56,  124, 51,  49,  57,  53,
+    53,  53,  56,  46,  57,  48,  10,  49,  52,  52,  48,  52,  124, 51,  49,
+    57,  50,  55,  50,  57,  46,  54,  48,  10,  49,  55,  56,  54,  55,  124,
+    51,  49,  56,  56,  53,  55,  49,  46,  48,  48,  10,  49,  56,  49,  49,
+    55,  124, 51,  49,  56,  51,  50,  50,  57,  46,  48,  52,  10,  49,  52,
+    50,  56,  57,  124, 51,  49,  56,  50,  50,  54,  49,  46,  54,  48,  10,
+    53,  51,  124, 51,  49,  56,  50,  50,  53,  54,  46,  48,  48,  10,  49,
+    53,  53,  52,  54,  124, 51,  49,  56,  48,  49,  56,  48,  46,  48,  52,
+    10,  49,  54,  50,  52,  53,  124, 51,  49,  55,  56,  50,  55,  55,  46,
+    52,  54,  10,  49,  53,  57,  55,  124, 51,  49,  55,  54,  50,  52,  55,
+    46,  52,  56,  10,  49,  54,  53,  51,  124, 51,  49,  55,  51,  52,  53,
+    54,  46,  54,  52,  10,  50,  56,  52,  53,  124, 51,  49,  55,  49,  54,
+    49,  57,  46,  54,  49,  10,  49,  53,  57,  48,  54,  124, 51,  49,  55,
+    49,  49,  56,  55,  46,  53,  52,  10,  49,  56,  51,  48,  52,  124, 51,
+    49,  54,  56,  53,  55,  49,  46,  53,  48,  10,  49,  52,  48,  54,  56,
+    124, 51,  49,  54,  55,  51,  54,  55,  46,  54,  48,  10,  54,  56,  51,
+    55,  124, 51,  49,  54,  53,  48,  49,  50,  46,  52,  56,  10,  57,  52,
+    52,  54,  124, 51,  49,  54,  52,  52,  52,  54,  46,  53,  50,  10,  49,
+    56,  56,  56,  57,  124, 51,  49,  53,  54,  49,  52,  48,  46,  57,  54,
+    10,  49,  54,  53,  56,  55,  124, 51,  49,  53,  52,  50,  49,  48,  46,
+    50,  48,  10,  55,  55,  48,  53,  124, 51,  49,  53,  50,  57,  55,  55,
+    46,  51,  56,  10,  49,  49,  50,  48,  124, 51,  49,  53,  49,  53,  57,
+    49,  46,  49,  55,  10,  49,  55,  54,  54,  53,  124, 51,  49,  52,  56,
+    56,  52,  56,  46,  48,  48,  10,  53,  51,  49,  49,  124, 51,  49,  52,
+    54,  55,  50,  49,  46,  56,  54,  10,  49,  52,  49,  53,  55,  124, 51,
+    49,  52,  52,  55,  48,  55,  46,  51,  50,  10,  55,  57,  57,  54,  124,
+    51,  49,  51,  49,  51,  53,  49,  46,  48,  52,  10,  56,  54,  54,  51,
+    124, 51,  49,  51,  48,  53,  50,  54,  46,  51,  50,  10,  49,  56,  50,
+    55,  49,  124, 51,  49,  50,  55,  56,  48,  48,  46,  57,  54,  10,  54,
+    52,  52,  54,  124, 51,  49,  50,  53,  54,  56,  53,  46,  57,  54,  10,
+    54,  57,  55,  50,  124, 51,  49,  50,  53,  48,  48,  55,  46,  48,  54,
+    10,  50,  53,  55,  50,  124, 51,  49,  50,  51,  49,  56,  54,  46,  56,
+    51,  10,  49,  51,  53,  51,  54,  124, 51,  49,  50,  50,  53,  50,  55,
+    46,  53,  52,  10,  54,  49,  57,  54,  124, 51,  49,  50,  50,  49,  55,
+    50,  46,  52,  56,  10,  57,  51,  51,  56,  124, 51,  49,  50,  49,  50,
+    54,  50,  46,  52,  48,  10,  49,  49,  57,  57,  50,  124, 51,  49,  49,
+    56,  54,  52,  55,  46,  53,  53,  10,  50,  53,  56,  48,  124, 51,  49,
+    49,  56,  50,  56,  52,  46,  51,  55,  10,  57,  48,  57,  56,  124, 51,
+    49,  49,  55,  52,  57,  52,  46,  49,  48,  10,  53,  49,  49,  56,  124,
+    51,  49,  49,  50,  54,  54,  49,  46,  57,  54,  10,  49,  48,  49,  56,
+    52,  124, 51,  49,  48,  57,  50,  57,  51,  46,  52,  48,  10,  57,  57,
+    51,  50,  124, 51,  49,  48,  53,  56,  49,  56,  46,  50,  52,  10,  49,
+    56,  53,  52,  53,  124, 51,  49,  48,  50,  50,  55,  51,  46,  51,  50,
+    10,  49,  48,  57,  54,  51,  124, 51,  48,  57,  57,  51,  49,  52,  46,
+    53,  48,  10,  56,  52,  48,  53,  124, 51,  48,  57,  55,  49,  50,  49,
+    46,  49,  50,  10,  57,  48,  51,  55,  124, 51,  48,  57,  53,  49,  57,
+    53,  46,  48,  48,  10,  49,  55,  57,  124, 51,  48,  57,  49,  49,  48,
+    55,  46,  50,  56,  10,  49,  57,  51,  48,  124, 51,  48,  57,  48,  57,
+    49,  53,  46,  56,  48,  10,  49,  55,  55,  50,  51,  124, 51,  48,  57,
+    48,  54,  50,  52,  46,  54,  54,  10,  52,  51,  48,  56,  124, 51,  48,
+    56,  57,  52,  55,  50,  46,  55,  53,  10,  56,  55,  48,  50,  124, 51,
+    48,  56,  48,  49,  50,  57,  46,  57,  50,  10,  49,  56,  54,  50,  49,
+    124, 51,  48,  55,  57,  57,  56,  52,  46,  56,  48,  10,  52,  53,  48,
+    49,  124, 51,  48,  55,  57,  55,  56,  49,  46,  49,  48,  10,  51,  53,
+    57,  48,  124, 51,  48,  55,  57,  48,  52,  57,  46,  52,  50,  10,  49,
+    56,  50,  54,  52,  124, 51,  48,  55,  56,  56,  53,  56,  46,  52,  52,
+    10,  49,  53,  54,  52,  56,  124, 51,  48,  55,  56,  53,  54,  52,  46,
+    48,  54,  10,  53,  57,  57,  56,  124, 51,  48,  55,  51,  50,  54,  52,
+    46,  48,  48,  10,  49,  54,  57,  48,  52,  124, 51,  48,  55,  50,  54,
+    49,  48,  46,  56,  48,  10,  51,  55,  57,  52,  124, 51,  48,  55,  49,
+    51,  51,  51,  46,  48,  57,  10,  51,  49,  52,  55,  124, 51,  48,  54,
+    56,  52,  56,  53,  46,  51,  50,  10,  49,  55,  50,  50,  49,  124, 51,
+    48,  54,  56,  51,  51,  55,  46,  50,  50,  10,  52,  55,  48,  57,  124,
+    51,  48,  54,  55,  53,  50,  51,  46,  51,  49,  10,  49,  56,  48,  49,
+    55,  124, 51,  48,  54,  54,  55,  52,  51,  46,  52,  49,  10,  49,  53,
+    54,  49,  51,  124, 51,  48,  54,  51,  57,  56,  55,  46,  56,  54,  10,
+    49,  54,  50,  55,  49,  124, 51,  48,  53,  55,  48,  53,  49,  46,  51,
+    52,  10,  49,  51,  54,  50,  49,  124, 51,  48,  53,  52,  55,  55,  52,
+    46,  53,  57,  10,  49,  50,  57,  49,  57,  124, 51,  48,  53,  52,  53,
+    49,  56,  46,  53,  48,  10,  49,  50,  52,  57,  51,  124, 51,  48,  53,
+    48,  56,  51,  54,  46,  51,  48,  10,  49,  53,  56,  51,  56,  124, 51,
+    48,  53,  48,  54,  52,  53,  46,  57,  53,  10,  51,  50,  55,  51,  124,
+    51,  48,  52,  56,  57,  53,  53,  46,  49,  53,  10,  56,  51,  50,  52,
+    124, 51,  48,  52,  54,  48,  49,  49,  46,  50,  53,  10,  49,  51,  54,
+    50,  56,  124, 51,  48,  52,  53,  51,  50,  52,  46,  53,  48,  10,  53,
+    53,  50,  50,  124, 51,  48,  52,  52,  52,  48,  56,  46,  53,  48,  10,
+    50,  50,  48,  50,  124, 51,  48,  52,  51,  49,  51,  50,  46,  48,  53,
+    10,  49,  57,  48,  53,  50,  124, 51,  48,  52,  50,  53,  54,  54,  46,
+    53,  53,  10,  53,  55,  54,  55,  124, 51,  48,  52,  49,  56,  55,  49,
+    46,  55,  48,  10,  49,  55,  56,  57,  53,  124, 51,  48,  51,  54,  52,
+    53,  50,  46,  50,  50,  10,  49,  50,  53,  56,  54,  124, 51,  48,  51,
+    54,  51,  56,  54,  46,  51,  48,  10,  49,  50,  52,  50,  53,  124, 51,
+    48,  51,  53,  48,  52,  49,  46,  53,  50,  10,  49,  51,  53,  49,  55,
+    124, 51,  48,  51,  52,  51,  53,  49,  46,  52,  55,  10,  50,  51,  54,
+    51,  124, 51,  48,  51,  51,  51,  51,  54,  46,  54,  48,  10,  49,  53,
+    48,  54,  48,  124, 51,  48,  51,  50,  53,  57,  56,  46,  53,  49,  10,
+    54,  55,  54,  52,  124, 51,  48,  51,  50,  53,  57,  49,  46,  49,  48,
+    10,  51,  52,  48,  124, 51,  48,  51,  48,  53,  50,  50,  46,  48,  48,
+    10,  52,  55,  50,  51,  124, 51,  48,  50,  56,  57,  49,  48,  46,  50,
+    53,  10,  51,  53,  54,  54,  124, 51,  48,  50,  55,  56,  53,  56,  46,
+    54,  49,  10,  49,  55,  55,  57,  54,  124, 51,  48,  50,  54,  56,  51,
+    56,  46,  57,  54,  10,  49,  53,  51,  56,  52,  124, 51,  48,  50,  51,
+    55,  57,  50,  46,  54,  52,  10,  49,  54,  51,  51,  54,  124, 51,  48,
+    49,  48,  56,  49,  51,  46,  53,  54,  10,  54,  55,  57,  124, 51,  48,
+    49,  48,  55,  49,  51,  46,  51,  48,  10,  55,  53,  53,  52,  124, 51,
+    48,  49,  48,  54,  54,  55,  46,  56,  48,  10,  49,  52,  53,  53,  51,
+    124, 51,  48,  48,  57,  55,  53,  54,  46,  57,  54,  10,  56,  51,  55,
+    57,  124, 51,  48,  48,  57,  55,  52,  53,  46,  49,  55,  10,  49,  53,
+    52,  51,  54,  124, 51,  48,  48,  55,  52,  57,  57,  46,  55,  55,  10,
+    49,  50,  52,  55,  49,  124, 51,  48,  48,  51,  57,  57,  49,  46,  56,
+    54,  10,  49,  56,  48,  53,  57,  124, 51,  48,  48,  51,  48,  51,  55,
+    46,  53,  51,  10,  56,  53,  51,  54,  124, 51,  48,  48,  48,  55,  52,
+    54,  46,  48,  48,  10,  49,  57,  48,  51,  51,  124, 50,  57,  57,  57,
+    51,  55,  51,  46,  50,  56,  10,  49,  56,  49,  55,  57,  124, 50,  57,
+    57,  54,  49,  53,  49,  46,  50,  48,  10,  49,  48,  55,  49,  49,  124,
+    50,  57,  57,  54,  49,  52,  51,  46,  49,  55,  10,  49,  55,  50,  55,
+    49,  124, 50,  57,  57,  52,  50,  54,  52,  46,  55,  57,  10,  49,  51,
+    57,  51,  50,  124, 50,  57,  56,  57,  48,  50,  51,  46,  53,  56,  10,
+    51,  49,  48,  49,  124, 50,  57,  56,  55,  55,  56,  56,  46,  49,  54,
+    10,  49,  52,  53,  53,  48,  124, 50,  57,  55,  55,  56,  53,  51,  46,
+    54,  53,  10,  51,  48,  56,  48,  124, 50,  57,  55,  55,  50,  51,  50,
+    46,  53,  56,  10,  49,  52,  53,  51,  51,  124, 50,  57,  55,  54,  52,
+    57,  48,  46,  52,  57,  10,  49,  52,  52,  51,  57,  124, 50,  57,  55,
+    53,  51,  49,  51,  46,  50,  52,  10,  57,  50,  51,  55,  124, 50,  57,
+    55,  51,  49,  50,  52,  46,  55,  56,  10,  49,  50,  48,  53,  124, 50,
+    57,  55,  49,  52,  55,  48,  46,  50,  56,  10,  49,  50,  51,  54,  49,
+    124, 50,  57,  54,  51,  52,  49,  57,  46,  52,  55,  10,  52,  50,  57,
+    124, 50,  57,  54,  50,  54,  51,  49,  46,  56,  56,  10,  51,  57,  55,
+    48,  124, 50,  57,  54,  48,  52,  49,  56,  46,  52,  53,  10,  56,  52,
+    48,  51,  124, 50,  57,  53,  55,  54,  57,  56,  46,  52,  53,  10,  49,
+    48,  57,  56,  124, 50,  57,  53,  55,  53,  49,  52,  46,  48,  48,  10,
+    55,  57,  51,  50,  124, 50,  57,  53,  53,  48,  52,  54,  46,  49,  52,
+    10,  49,  54,  50,  54,  54,  124, 50,  57,  53,  50,  50,  57,  56,  46,
+    51,  56,  10,  49,  57,  51,  56,  54,  124, 50,  57,  52,  56,  56,  53,
+    52,  46,  52,  56,  10,  49,  51,  49,  52,  55,  124, 50,  57,  52,  55,
+    48,  51,  55,  46,  57,  49,  10,  50,  55,  50,  48,  124, 50,  57,  52,
+    55,  48,  49,  49,  46,  48,  56,  10,  51,  56,  52,  48,  124, 50,  57,
+    52,  52,  50,  49,  57,  46,  51,  53,  10,  49,  51,  52,  56,  50,  124,
+    50,  57,  52,  50,  52,  55,  52,  46,  56,  56,  10,  57,  52,  51,  54,
+    124, 50,  57,  52,  48,  51,  57,  54,  46,  50,  49,  10,  49,  57,  55,
+    55,  57,  124, 50,  57,  51,  55,  49,  48,  53,  46,  57,  54,  10,  49,
+    56,  48,  51,  50,  124, 50,  57,  51,  51,  50,  50,  52,  46,  51,  56,
+    10,  55,  55,  52,  51,  124, 50,  57,  51,  50,  55,  51,  51,  46,  55,
+    55,  10,  49,  52,  54,  50,  48,  124, 50,  57,  51,  48,  55,  54,  54,
+    46,  56,  57,  10,  52,  54,  48,  54,  124, 50,  57,  50,  55,  56,  51,
+    50,  46,  53,  57,  10,  49,  56,  48,  55,  54,  124, 50,  57,  50,  52,
+    49,  51,  52,  46,  56,  51,  10,  49,  57,  50,  55,  54,  124, 50,  57,
+    49,  56,  49,  55,  54,  46,  50,  48,  10,  55,  52,  56,  51,  124, 50,
+    57,  49,  53,  57,  49,  56,  46,  57,  53,  10,  56,  53,  55,  53,  124,
+    50,  57,  49,  53,  49,  51,  50,  46,  54,  52,  10,  49,  49,  48,  53,
+    50,  124, 50,  57,  49,  51,  49,  52,  48,  46,  56,  56,  10,  49,  55,
+    50,  53,  49,  124, 50,  57,  48,  56,  51,  52,  53,  46,  56,  48,  10,
+    56,  55,  56,  56,  124, 50,  57,  48,  55,  57,  51,  53,  46,  57,  51,
+    10,  49,  48,  57,  54,  48,  124, 50,  57,  48,  54,  53,  49,  49,  46,
+    49,  52,  10,  49,  56,  55,  56,  50,  124, 50,  57,  48,  51,  54,  52,
+    51,  46,  55,  56,  10,  49,  57,  57,  56,  56,  124, 50,  56,  57,  55,
+    52,  54,  49,  46,  53,  51,  10,  55,  50,  54,  124, 50,  56,  57,  54,
+    48,  48,  57,  46,  50,  55,  10,  49,  57,  57,  52,  50,  124, 50,  56,
+    57,  52,  50,  53,  49,  46,  51,  54,  10,  49,  48,  56,  54,  52,  124,
+    50,  56,  57,  50,  50,  53,  50,  46,  52,  56,  10,  49,  55,  56,  52,
+    48,  124, 50,  56,  57,  49,  53,  54,  51,  46,  50,  50,  10,  49,  56,
+    55,  49,  55,  124, 50,  56,  56,  56,  57,  51,  57,  46,  57,  54,  10,
+    49,  50,  51,  57,  49,  124, 50,  56,  56,  54,  48,  53,  49,  46,  51,
+    48,  10,  49,  56,  50,  49,  57,  124, 50,  56,  56,  53,  57,  50,  49,
+    46,  48,  54,  10,  49,  53,  49,  48,  48,  124, 50,  56,  56,  51,  51,
+    52,  50,  46,  51,  51,  10,  50,  52,  57,  49,  124, 50,  56,  56,  48,
+    51,  56,  53,  46,  55,  52,  10,  49,  50,  51,  56,  57,  124, 50,  56,
+    55,  57,  54,  57,  54,  46,  57,  54,  10,  51,  56,  56,  48,  124, 50,
+    56,  55,  55,  55,  55,  48,  46,  50,  52,  10,  49,  56,  53,  55,  57,
+    124, 50,  56,  55,  52,  53,  52,  50,  46,  52,  56,  10,  49,  51,  54,
+    52,  55,  124, 50,  56,  55,  51,  56,  51,  56,  46,  51,  52,  10,  49,
+    53,  55,  53,  56,  124, 50,  56,  55,  51,  56,  48,  52,  46,  57,  50,
+    10,  49,  50,  57,  49,  55,  124, 50,  56,  55,  51,  54,  53,  57,  46,
+    54,  48,  10,  49,  56,  56,  54,  54,  124, 50,  56,  55,  51,  54,  49,
+    54,  46,  50,  54,  10,  49,  51,  56,  57,  52,  124, 50,  56,  55,  50,
+    57,  56,  54,  46,  49,  50,  10,  49,  53,  50,  48,  48,  124, 50,  56,
+    55,  50,  53,  55,  49,  46,  57,  51,  10,  57,  54,  50,  56,  124, 50,
+    56,  55,  50,  52,  48,  52,  46,  53,  54,  10,  56,  53,  54,  56,  124,
+    50,  56,  55,  49,  53,  57,  56,  46,  48,  56,  10,  56,  51,  56,  57,
+    124, 50,  56,  55,  48,  50,  51,  55,  46,  56,  56,  10,  53,  55,  56,
+    56,  124, 50,  56,  54,  55,  50,  49,  48,  46,  49,  56,  10,  49,  57,
+    52,  53,  48,  124, 50,  56,  54,  51,  51,  49,  48,  46,  54,  54,  10,
+    57,  52,  52,  48,  124, 50,  56,  54,  51,  49,  54,  50,  46,  57,  50,
+    10,  49,  54,  55,  57,  53,  124, 50,  56,  54,  48,  49,  51,  53,  46,
+    52,  49,  10,  49,  57,  54,  52,  51,  124, 50,  56,  53,  56,  57,  56,
+    55,  46,  56,  48,  10,  49,  57,  55,  52,  124, 50,  56,  53,  54,  56,
+    50,  53,  46,  56,  52,  10,  49,  52,  54,  50,  50,  124, 50,  56,  53,
+    50,  48,  56,  57,  46,  49,  50,  10,  54,  56,  56,  53,  124, 50,  56,
+    53,  49,  52,  51,  55,  46,  54,  50,  10,  49,  50,  53,  51,  50,  124,
+    50,  56,  52,  56,  57,  57,  50,  46,  54,  52,  10,  49,  48,  56,  55,
+    124, 50,  56,  52,  55,  56,  53,  56,  46,  56,  48,  10,  53,  55,  55,
+    55,  124, 50,  56,  52,  54,  52,  48,  55,  46,  52,  49,  10,  53,  54,
+    50,  57,  124, 50,  56,  52,  54,  48,  55,  54,  46,  49,  50,  10,  54,
+    51,  49,  54,  124, 50,  56,  52,  48,  53,  52,  52,  46,  54,  53,  10,
+    49,  50,  55,  54,  55,  124, 50,  56,  52,  48,  53,  49,  52,  46,  49,
+    50,  10,  49,  50,  49,  51,  52,  124, 50,  56,  52,  48,  48,  51,  54,
+    46,  57,  49,  10,  49,  52,  52,  55,  54,  124, 50,  56,  51,  57,  56,
+    53,  51,  46,  48,  49,  10,  56,  48,  51,  124, 50,  56,  51,  56,  51,
+    56,  56,  46,  49,  54,  10,  49,  56,  57,  54,  52,  124, 50,  56,  51,
+    54,  57,  52,  50,  46,  52,  52,  10,  54,  48,  50,  48,  124, 50,  56,
+    51,  51,  52,  53,  57,  46,  50,  48,  10,  49,  48,  52,  48,  49,  124,
+    50,  56,  51,  50,  54,  56,  56,  46,  55,  52,  10,  49,  51,  50,  51,
+    124, 50,  56,  50,  57,  57,  54,  52,  46,  53,  48,  10,  49,  49,  53,
+    49,  124, 50,  56,  50,  57,  54,  54,  50,  46,  52,  52,  10,  49,  52,
+    53,  56,  124, 50,  56,  50,  52,  48,  51,  52,  46,  52,  51,  10,  50,
+    50,  55,  49,  124, 50,  56,  50,  48,  55,  53,  54,  46,  53,  51,  10,
+    49,  56,  55,  52,  48,  124, 50,  56,  49,  52,  49,  52,  48,  46,  56,
+    48,  10,  55,  51,  52,  56,  124, 50,  56,  49,  49,  55,  51,  48,  46,
+    57,  53,  10,  52,  50,  56,  49,  124, 50,  56,  48,  55,  49,  57,  48,
+    46,  53,  50,  10,  56,  48,  52,  51,  124, 50,  56,  48,  52,  55,  48,
+    54,  46,  50,  52,  10,  51,  56,  52,  51,  124, 50,  56,  48,  52,  50,
+    49,  55,  46,  57,  54,  10,  55,  56,  49,  51,  124, 50,  56,  48,  50,
+    51,  53,  48,  46,  56,  56,  10,  51,  52,  55,  124, 50,  56,  48,  50,
+    50,  52,  53,  46,  53,  50,  10,  55,  52,  53,  124, 50,  56,  48,  49,
+    55,  50,  53,  46,  49,  48,  10,  49,  48,  51,  56,  56,  124, 50,  55,
+    57,  57,  49,  55,  48,  46,  53,  56,  10,  49,  56,  49,  48,  48,  124,
+    50,  55,  57,  51,  51,  53,  56,  46,  53,  48,  10,  49,  57,  48,  52,
+    51,  124, 50,  55,  56,  57,  48,  49,  51,  46,  56,  48,  10,  49,  48,
+    54,  52,  52,  124, 50,  55,  56,  55,  55,  57,  55,  46,  48,  49,  10,
+    49,  54,  49,  55,  48,  124, 50,  55,  56,  55,  52,  48,  50,  46,  56,
+    48,  10,  51,  57,  56,  124, 50,  55,  56,  50,  55,  50,  57,  46,  48,
+    53,  10,  57,  51,  55,  48,  124, 50,  55,  56,  48,  48,  55,  56,  46,
+    49,  51,  10,  49,  52,  53,  48,  52,  124, 50,  55,  56,  48,  48,  51,
+    54,  46,  48,  52,  10,  49,  50,  49,  48,  124, 50,  55,  55,  56,  52,
+    56,  53,  46,  55,  54,  10,  49,  51,  51,  56,  53,  124, 50,  55,  55,
+    55,  52,  52,  53,  46,  54,  50,  10,  51,  55,  57,  57,  124, 50,  55,
+    55,  53,  50,  50,  51,  46,  54,  48,  10,  49,  49,  51,  50,  53,  124,
+    50,  55,  54,  57,  55,  54,  54,  46,  48,  50,  10,  51,  52,  56,  57,
+    124, 50,  55,  54,  57,  53,  53,  52,  46,  53,  50,  10,  49,  55,  49,
+    56,  49,  124, 50,  55,  54,  57,  48,  50,  56,  46,  53,  48,  10,  54,
+    57,  54,  52,  124, 50,  55,  54,  54,  54,  53,  51,  46,  55,  56,  10,
+    55,  51,  56,  49,  124, 50,  55,  54,  52,  56,  57,  56,  46,  56,  48,
+    10,  54,  50,  53,  51,  124, 50,  55,  54,  52,  51,  57,  52,  46,  54,
+    52,  10,  53,  57,  55,  53,  124, 50,  55,  54,  48,  56,  49,  57,  46,
+    55,  50,  10,  49,  49,  57,  57,  54,  124, 50,  55,  54,  48,  54,  56,
+    55,  46,  56,  54,  10,  55,  53,  55,  48,  124, 50,  55,  53,  56,  57,
+    55,  55,  46,  49,  50,  10,  52,  51,  56,  55,  124, 50,  55,  53,  55,
+    54,  55,  50,  46,  48,  48,  10,  57,  48,  49,  52,  124, 50,  55,  53,
+    53,  51,  54,  55,  46,  52,  50,  10,  57,  52,  48,  51,  124, 50,  55,
+    52,  56,  48,  50,  49,  46,  54,  54,  10,  49,  49,  54,  53,  51,  124,
+    50,  55,  51,  57,  55,  51,  49,  46,  48,  55,  10,  49,  55,  54,  57,
+    55,  124, 50,  55,  51,  57,  51,  49,  50,  46,  50,  57,  10,  57,  53,
+    56,  124, 50,  55,  51,  56,  48,  51,  50,  46,  48,  48,  10,  49,  56,
+    56,  49,  54,  124, 50,  55,  51,  55,  49,  52,  48,  46,  48,  48,  10,
+    49,  52,  49,  48,  52,  124, 50,  55,  51,  53,  48,  48,  56,  46,  54,
+    52,  10,  49,  53,  57,  54,  54,  124, 50,  55,  51,  50,  50,  53,  48,
+    46,  50,  48,  10,  49,  55,  57,  49,  50,  124, 50,  55,  50,  52,  49,
+    54,  48,  46,  57,  53,  10,  55,  48,  56,  57,  124, 50,  55,  50,  48,
+    49,  55,  48,  46,  48,  52,  10,  49,  54,  48,  51,  50,  124, 50,  55,
+    49,  56,  57,  55,  54,  46,  49,  56,  10,  49,  54,  56,  57,  49,  124,
+    50,  55,  49,  55,  50,  57,  51,  46,  51,  50,  10,  49,  57,  53,  55,
+    57,  124, 50,  55,  49,  54,  57,  48,  57,  46,  56,  54,  10,  49,  55,
+    52,  55,  48,  124, 50,  55,  49,  53,  48,  52,  56,  46,  56,  52,  10,
+    49,  50,  52,  48,  56,  124, 50,  55,  49,  50,  53,  53,  54,  46,  53,
+    50,  10,  52,  55,  54,  51,  124, 50,  55,  49,  49,  56,  48,  48,  46,
+    57,  48,  10,  49,  49,  51,  56,  124, 50,  55,  48,  57,  55,  48,  57,
+    46,  56,  49,  10,  55,  51,  54,  51,  124, 50,  55,  48,  56,  52,  49,
+    52,  46,  52,  48,  10,  55,  56,  55,  55,  124, 50,  55,  48,  53,  52,
+    51,  57,  46,  52,  53,  10,  49,  55,  53,  51,  50,  124, 50,  55,  48,
+    51,  54,  57,  56,  46,  54,  56,  10,  49,  48,  53,  49,  50,  124, 50,
+    55,  48,  49,  50,  51,  53,  46,  57,  50,  10,  49,  49,  57,  53,  55,
+    124, 50,  55,  48,  48,  49,  51,  51,  46,  50,  50,  10,  50,  52,  53,
+    53,  124, 50,  54,  57,  57,  53,  57,  51,  46,  56,  56,  10,  49,  53,
+    49,  49,  57,  124, 50,  54,  57,  54,  56,  54,  48,  46,  56,  48,  10,
+    57,  56,  54,  56,  124, 50,  54,  57,  54,  56,  48,  49,  46,  53,  50,
+    10,  49,  52,  49,  55,  50,  124, 50,  54,  57,  53,  51,  48,  55,  46,
+    52,  56,  10,  49,  54,  49,  50,  48,  124, 50,  54,  56,  57,  51,  51,
+    55,  46,  56,  50,  10,  49,  51,  57,  53,  56,  124, 50,  54,  55,  57,
+    48,  50,  53,  46,  50,  56,  10,  49,  53,  49,  54,  57,  124, 50,  54,
+    55,  54,  54,  56,  54,  46,  48,  52,  10,  50,  54,  52,  56,  124, 50,
+    54,  55,  50,  50,  51,  50,  46,  48,  48,  10,  54,  49,  54,  52,  124,
+    50,  54,  55,  49,  51,  49,  55,  46,  51,  50,  10,  49,  50,  55,  48,
+    49,  124, 50,  54,  54,  57,  50,  49,  54,  46,  52,  48,  10,  49,  54,
+    51,  56,  50,  124, 50,  54,  54,  57,  48,  51,  52,  46,  53,  52,  10,
+    49,  53,  53,  56,  56,  124, 50,  54,  54,  55,  50,  49,  50,  46,  49,
+    48,  10,  49,  52,  56,  51,  48,  124, 50,  54,  54,  54,  55,  53,  56,
+    46,  49,  53,  10,  57,  49,  49,  57,  124, 50,  54,  54,  53,  56,  49,
+    50,  46,  50,  52,  10,  49,  54,  50,  50,  124, 50,  54,  54,  53,  50,
+    48,  54,  46,  53,  48,  10,  56,  55,  56,  124, 50,  54,  54,  52,  48,
+    52,  53,  46,  55,  57,  10,  49,  51,  50,  54,  57,  124, 50,  54,  54,
+    50,  55,  56,  52,  46,  49,  50,  10,  54,  49,  57,  124, 50,  54,  53,
+    53,  52,  49,  55,  46,  54,  51,  10,  49,  56,  51,  56,  54,  124, 50,
+    54,  53,  51,  55,  57,  53,  46,  48,  50,  10,  50,  53,  48,  49,  124,
+    50,  54,  53,  50,  50,  54,  48,  46,  52,  48,  10,  50,  51,  49,  48,
+    124, 50,  54,  53,  49,  54,  51,  49,  46,  48,  57,  10,  49,  57,  52,
+    50,  48,  124, 50,  54,  52,  57,  51,  57,  53,  46,  54,  49,  10,  52,
+    56,  57,  53,  124, 50,  54,  52,  53,  49,  53,  50,  46,  50,  55,  10,
+    55,  53,  53,  51,  124, 50,  54,  52,  51,  54,  56,  50,  46,  48,  55,
+    10,  49,  55,  56,  49,  52,  124, 50,  54,  52,  50,  55,  56,  49,  46,
+    52,  52,  10,  49,  54,  48,  57,  55,  124, 50,  54,  52,  50,  53,  48,
+    48,  46,  48,  48,  10,  49,  48,  57,  57,  53,  124, 50,  54,  52,  48,
+    56,  49,  49,  46,  49,  54,  10,  49,  52,  56,  57,  53,  124, 50,  54,
+    51,  55,  55,  51,  51,  46,  55,  50,  10,  49,  56,  53,  52,  54,  124,
+    50,  54,  51,  55,  48,  50,  54,  46,  55,  49,  10,  57,  56,  55,  53,
+    124, 50,  54,  51,  49,  51,  53,  56,  46,  56,  48,  10,  57,  53,  57,
+    49,  124, 50,  54,  50,  54,  56,  57,  57,  46,  53,  52,  10,  54,  48,
+    48,  49,  124, 50,  54,  50,  53,  56,  57,  51,  46,  55,  54,  10,  55,
+    55,  51,  57,  124, 50,  54,  50,  52,  53,  55,  51,  46,  50,  56,  10,
+    49,  48,  52,  51,  49,  124, 50,  54,  50,  52,  51,  55,  57,  46,  53,
+    52,  10,  52,  53,  52,  52,  124, 50,  54,  49,  53,  51,  49,  51,  46,
+    55,  53,  10,  49,  54,  51,  56,  55,  124, 50,  54,  48,  51,  49,  57,
+    53,  46,  55,  54,  10,  49,  56,  51,  55,  53,  124, 50,  54,  48,  49,
+    52,  48,  55,  46,  56,  51,  10,  56,  51,  57,  53,  124, 50,  53,  57,
+    56,  55,  50,  56,  46,  52,  52,  10,  49,  56,  56,  53,  51,  124, 50,
+    53,  57,  51,  51,  53,  54,  46,  51,  54,  10,  52,  57,  48,  48,  124,
+    50,  53,  57,  50,  56,  49,  51,  46,  49,  53,  10,  49,  51,  48,  50,
+    124, 50,  53,  57,  50,  49,  57,  55,  46,  55,  54,  10,  49,  55,  48,
+    51,  50,  124, 50,  53,  56,  57,  56,  48,  54,  46,  52,  48,  10,  49,
+    52,  50,  57,  50,  124, 50,  53,  56,  57,  55,  52,  57,  46,  53,  54,
+    10,  52,  51,  124, 50,  53,  56,  55,  51,  53,  57,  46,  53,  56,  10,
+    53,  50,  50,  49,  124, 50,  53,  56,  55,  48,  50,  52,  46,  48,  52,
+    10,  51,  57,  55,  124, 50,  53,  55,  57,  55,  53,  49,  46,  52,  54,
+    10,  49,  55,  56,  57,  48,  124, 50,  53,  55,  57,  54,  55,  52,  46,
+    50,  52,  10,  49,  50,  49,  53,  55,  124, 50,  53,  55,  53,  53,  49,
+    48,  46,  52,  56,  10,  55,  51,  52,  48,  124, 50,  53,  55,  52,  54,
+    52,  53,  46,  56,  51,  10,  49,  57,  51,  54,  56,  124, 50,  53,  55,
+    50,  54,  49,  56,  46,  57,  53,  10,  56,  56,  52,  56,  124, 50,  53,
+    55,  48,  56,  49,  57,  46,  49,  53,  10,  49,  51,  55,  56,  57,  124,
+    50,  53,  55,  48,  50,  52,  51,  46,  50,  54,  10,  49,  52,  53,  57,
+    54,  124, 50,  53,  54,  56,  50,  51,  52,  46,  50,  52,  10,  56,  52,
+    48,  56,  124, 50,  53,  54,  55,  52,  51,  52,  46,  52,  49,  10,  49,
+    57,  55,  50,  54,  124, 50,  53,  54,  53,  55,  53,  48,  46,  52,  50,
+    10,  49,  51,  57,  54,  52,  124, 50,  53,  54,  53,  53,  55,  57,  46,
+    49,  50,  10,  55,  55,  52,  48,  124, 50,  53,  54,  51,  48,  50,  55,
+    46,  53,  48,  10,  49,  52,  55,  54,  56,  124, 50,  53,  54,  48,  51,
+    57,  50,  46,  54,  48,  10,  49,  49,  55,  51,  52,  124, 50,  53,  53,
+    57,  48,  54,  50,  46,  50,  50,  10,  49,  48,  50,  57,  52,  124, 50,
+    53,  53,  56,  50,  53,  55,  46,  57,  55,  10,  49,  53,  48,  51,  50,
+    124, 50,  53,  53,  55,  57,  50,  54,  46,  50,  50,  10,  57,  49,  50,
+    55,  124, 50,  53,  53,  54,  51,  55,  57,  46,  56,  48,  10,  50,  49,
+    56,  49,  124, 50,  53,  53,  51,  49,  55,  53,  46,  48,  48,  10,  49,
+    54,  54,  53,  51,  124, 50,  53,  53,  50,  50,  50,  57,  46,  54,  56,
+    10,  51,  56,  54,  54,  124, 50,  53,  52,  57,  57,  57,  52,  46,  55,
+    57,  10,  49,  54,  56,  49,  52,  124, 50,  53,  52,  56,  55,  49,  48,
+    46,  55,  54,  10,  49,  56,  54,  54,  124, 50,  53,  52,  53,  56,  51,
+    56,  46,  52,  48,  10,  51,  53,  49,  50,  124, 50,  53,  51,  50,  54,
+    50,  54,  46,  56,  48,  10,  52,  49,  52,  53,  124, 50,  53,  50,  57,
+    55,  56,  54,  46,  49,  53,  10,  49,  50,  49,  50,  48,  124, 50,  53,
+    50,  56,  50,  57,  56,  46,  55,  50,  10,  54,  52,  52,  124, 50,  53,
+    50,  56,  49,  50,  51,  46,  48,  53,  10,  49,  53,  51,  55,  57,  124,
+    50,  53,  50,  53,  49,  56,  49,  46,  48,  49,  10,  54,  51,  57,  50,
+    124, 50,  53,  50,  52,  48,  54,  51,  46,  48,  56,  10,  50,  54,  53,
+    50,  124, 50,  53,  50,  49,  52,  53,  54,  46,  56,  48,  10,  51,  51,
+    54,  51,  124, 50,  53,  49,  57,  50,  48,  50,  46,  50,  51,  10,  49,
+    57,  49,  54,  55,  124, 50,  53,  49,  55,  57,  57,  51,  46,  49,  56,
+    10,  49,  54,  48,  52,  50,  124, 50,  53,  49,  54,  53,  57,  57,  46,
+    57,  50,  10,  50,  56,  57,  50,  124, 50,  53,  49,  49,  56,  53,  52,
+    46,  52,  48,  10,  53,  55,  49,  49,  124, 50,  53,  48,  57,  52,  48,
+    49,  46,  55,  50,  10,  49,  52,  53,  57,  49,  124, 50,  53,  48,  54,
+    51,  52,  52,  46,  54,  57,  10,  54,  53,  54,  52,  124, 50,  53,  48,
+    54,  50,  55,  55,  46,  51,  52,  10,  49,  50,  51,  49,  124, 50,  53,
+    48,  53,  52,  50,  49,  46,  50,  52,  10,  53,  48,  52,  57,  124, 50,
+    53,  48,  50,  54,  48,  51,  46,  48,  48,  10,  49,  52,  53,  55,  54,
+    124, 50,  53,  48,  49,  54,  48,  54,  46,  54,  57,  10,  49,  48,  50,
+    49,  49,  124, 50,  53,  48,  48,  56,  53,  50,  46,  50,  48,  10,  50,
+    57,  51,  124, 50,  52,  57,  51,  49,  54,  56,  46,  52,  56,  10,  55,
+    51,  55,  49,  124, 50,  52,  57,  49,  49,  51,  52,  46,  54,  53,  10,
+    49,  56,  49,  53,  52,  124, 50,  52,  57,  49,  48,  52,  55,  46,  50,
+    48,  10,  57,  52,  57,  52,  124, 50,  52,  56,  57,  56,  50,  53,  46,
+    53,  50,  10,  49,  52,  56,  51,  54,  124, 50,  52,  56,  48,  52,  51,
+    50,  46,  52,  48,  10,  49,  57,  52,  55,  49,  124, 50,  52,  56,  48,
+    52,  48,  51,  46,  55,  53,  10,  56,  48,  50,  124, 50,  52,  55,  56,
+    57,  57,  56,  46,  51,  51,  10,  49,  50,  53,  52,  49,  124, 50,  52,
+    55,  55,  50,  52,  50,  46,  54,  48,  10,  49,  53,  48,  54,  53,  124,
+    50,  52,  55,  51,  53,  54,  51,  46,  57,  52,  10,  49,  53,  57,  57,
+    53,  124, 50,  52,  55,  50,  56,  48,  51,  46,  50,  48,  10,  57,  52,
+    48,  56,  124, 50,  52,  55,  49,  57,  53,  51,  46,  53,  54,  10,  57,
+    55,  55,  54,  124, 50,  52,  55,  48,  52,  52,  55,  46,  57,  48,  10,
+    49,  55,  51,  50,  53,  124, 50,  52,  54,  56,  57,  56,  57,  46,  48,
+    53,  10,  51,  51,  57,  49,  124, 50,  52,  54,  56,  51,  49,  55,  46,
+    55,  50,  10,  49,  54,  49,  50,  51,  124, 50,  52,  54,  55,  48,  50,
+    50,  46,  50,  50,  10,  49,  56,  55,  53,  56,  124, 50,  52,  54,  51,
+    55,  57,  56,  46,  48,  54,  10,  52,  48,  55,  124, 50,  52,  54,  48,
+    51,  48,  52,  46,  52,  55,  10,  54,  56,  52,  48,  124, 50,  52,  53,
+    54,  49,  55,  48,  46,  55,  56,  10,  57,  57,  57,  53,  124, 50,  52,
+    53,  53,  49,  53,  53,  46,  51,  54,  10,  51,  56,  55,  55,  124, 50,
+    52,  53,  51,  54,  57,  54,  46,  54,  53,  10,  53,  56,  49,  55,  124,
+    50,  52,  53,  50,  52,  57,  51,  46,  49,  51,  10,  49,  52,  49,  50,
+    50,  124, 50,  52,  53,  50,  50,  50,  54,  46,  50,  50,  10,  49,  54,
+    54,  57,  57,  124, 50,  52,  53,  48,  50,  55,  51,  46,  57,  56,  10,
+    56,  57,  50,  49,  124, 50,  52,  53,  48,  49,  49,  54,  46,  52,  56,
+    10,  49,  53,  49,  48,  51,  124, 50,  52,  52,  57,  56,  54,  49,  46,
+    50,  48,  10,  55,  54,  51,  55,  124, 50,  52,  52,  57,  54,  50,  56,
+    46,  55,  50,  10,  51,  48,  55,  54,  124, 50,  52,  52,  51,  57,  50,
+    55,  46,  51,  56,  10,  54,  54,  52,  56,  124, 50,  52,  52,  51,  50,
+    52,  56,  46,  57,  53,  10,  49,  55,  49,  49,  54,  124, 50,  52,  52,
+    50,  50,  54,  51,  46,  55,  50,  10,  49,  54,  52,  53,  124, 50,  52,
+    52,  48,  56,  51,  56,  46,  52,  48,  10,  51,  49,  56,  49,  124, 50,
+    52,  52,  48,  48,  49,  55,  46,  54,  48,  10,  53,  57,  54,  54,  124,
+    50,  52,  51,  49,  53,  53,  56,  46,  48,  56,  10,  49,  53,  56,  56,
+    50,  124, 50,  52,  50,  56,  57,  52,  55,  46,  51,  48,  10,  55,  53,
+    50,  57,  124, 50,  52,  50,  56,  51,  56,  49,  46,  50,  56,  10,  49,
+    50,  56,  51,  54,  124, 50,  52,  50,  55,  56,  57,  55,  46,  51,  51,
+    10,  49,  56,  48,  53,  50,  124, 50,  52,  50,  55,  54,  51,  55,  46,
+    55,  54,  10,  49,  51,  54,  49,  54,  124, 50,  52,  50,  54,  54,  51,
+    56,  46,  53,  48,  10,  49,  54,  54,  49,  53,  124, 50,  52,  50,  52,
+    55,  55,  53,  46,  48,  56,  10,  49,  56,  49,  52,  55,  124, 50,  52,
+    50,  52,  52,  49,  50,  46,  54,  56,  10,  52,  53,  56,  54,  124, 50,
+    52,  50,  52,  49,  50,  51,  46,  57,  48,  10,  49,  52,  52,  48,  51,
+    124, 50,  52,  50,  51,  49,  52,  49,  46,  57,  54,  10,  49,  49,  54,
+    48,  54,  124, 50,  52,  50,  50,  55,  57,  52,  46,  51,  49,  10,  49,
+    51,  53,  50,  54,  124, 50,  52,  50,  50,  50,  49,  50,  46,  56,  48,
+    10,  51,  54,  55,  55,  124, 50,  52,  50,  49,  52,  48,  52,  46,  52,
+    54,  10,  53,  53,  53,  51,  124, 50,  52,  49,  56,  53,  48,  54,  46,
+    50,  49,  10,  49,  50,  49,  48,  57,  124, 50,  52,  49,  54,  53,  49,
+    52,  46,  49,  55,  10,  49,  51,  49,  49,  56,  124, 50,  52,  49,  53,
+    57,  51,  49,  46,  56,  48,  10,  49,  53,  54,  51,  124, 50,  52,  48,
+    56,  56,  53,  53,  46,  52,  48,  10,  49,  54,  53,  57,  49,  124, 50,
+    52,  48,  56,  48,  52,  53,  46,  51,  57,  10,  54,  52,  49,  49,  124,
+    50,  52,  48,  52,  57,  49,  56,  46,  53,  51,  10,  49,  48,  50,  55,
+    50,  124, 50,  52,  48,  50,  56,  51,  52,  46,  52,  56,  10,  49,  48,
+    53,  57,  55,  124, 50,  52,  48,  48,  50,  52,  55,  46,  54,  56,  10,
+    49,  51,  55,  48,  48,  124, 50,  51,  57,  56,  48,  51,  53,  46,  56,
+    54,  10,  57,  53,  52,  56,  124, 50,  51,  57,  55,  49,  52,  55,  46,
+    57,  48,  10,  49,  52,  57,  54,  51,  124, 50,  51,  57,  53,  55,  56,
+    49,  46,  48,  57,  10,  49,  51,  51,  50,  53,  124, 50,  51,  57,  48,
+    54,  51,  55,  46,  53,  56,  10,  49,  51,  56,  54,  52,  124, 50,  51,
+    56,  56,  48,  54,  55,  46,  56,  56,  10,  55,  52,  53,  48,  124, 50,
+    51,  56,  51,  52,  52,  55,  46,  55,  49,  10,  57,  50,  55,  53,  124,
+    50,  51,  56,  50,  56,  54,  56,  46,  52,  48,  10,  53,  56,  50,  57,
+    124, 50,  51,  55,  56,  48,  51,  55,  46,  57,  50,  10,  49,  51,  52,
+    51,  55,  124, 50,  51,  55,  55,  56,  48,  54,  46,  53,  52,  10,  49,
+    51,  53,  57,  52,  124, 50,  51,  55,  53,  48,  52,  54,  46,  51,  48,
+    10,  49,  49,  52,  52,  50,  124, 50,  51,  55,  52,  53,  57,  49,  46,
+    48,  56,  10,  49,  53,  54,  49,  57,  124, 50,  51,  55,  52,  48,  53,
+    50,  46,  51,  56,  10,  57,  48,  54,  51,  124, 50,  51,  55,  52,  48,
+    51,  53,  46,  56,  52,  10,  53,  57,  57,  48,  124, 50,  51,  54,  56,
+    54,  56,  54,  46,  53,  48,  10,  55,  56,  49,  49,  124, 50,  51,  54,
+    51,  56,  50,  57,  46,  50,  54,  10,  57,  53,  50,  53,  124, 50,  51,
+    54,  50,  57,  55,  52,  46,  53,  51,  10,  53,  53,  57,  55,  124, 50,
+    51,  54,  49,  48,  51,  49,  46,  56,  52,  10,  56,  57,  54,  51,  124,
+    50,  51,  54,  48,  55,  55,  52,  46,  48,  48,  10,  49,  55,  48,  57,
+    124, 50,  51,  53,  57,  56,  51,  57,  46,  50,  57,  10,  49,  53,  56,
+    49,  52,  124, 50,  51,  53,  56,  54,  53,  54,  46,  54,  52,  10,  49,
+    55,  54,  49,  51,  124, 50,  51,  53,  55,  53,  49,  57,  46,  48,  52,
+    10,  53,  48,  50,  50,  124, 50,  51,  53,  52,  53,  53,  48,  46,  52,
+    53,  10,  49,  55,  55,  52,  48,  124, 50,  51,  53,  52,  50,  52,  50,
+    46,  56,  51,  10,  51,  51,  56,  56,  124, 50,  51,  53,  49,  48,  52,
+    50,  46,  50,  54,  10,  49,  51,  55,  55,  51,  124, 50,  51,  52,  56,
+    55,  51,  57,  46,  49,  50,  10,  49,  52,  52,  54,  55,  124, 50,  51,
+    52,  56,  54,  54,  53,  46,  48,  52,  10,  49,  49,  53,  52,  52,  124,
+    50,  51,  52,  53,  51,  50,  52,  46,  52,  53,  10,  51,  52,  57,  124,
+    50,  51,  52,  52,  54,  54,  52,  46,  49,  51,  10,  49,  48,  51,  53,
+    54,  124, 50,  51,  52,  48,  56,  54,  50,  46,  55,  50,  10,  49,  56,
+    50,  55,  50,  124, 50,  51,  51,  56,  55,  53,  52,  46,  54,  48,  10,
+    52,  54,  50,  55,  124, 50,  51,  51,  55,  52,  51,  48,  46,  56,  52,
+    10,  51,  50,  55,  124, 50,  51,  51,  53,  50,  57,  56,  46,  52,  54,
+    10,  49,  57,  56,  52,  54,  124, 50,  51,  51,  50,  50,  50,  52,  46,
+    55,  51,  10,  49,  48,  56,  49,  52,  124, 50,  51,  51,  48,  51,  49,
+    57,  46,  54,  48,  10,  49,  51,  49,  48,  50,  124, 50,  51,  50,  54,
+    49,  50,  50,  46,  55,  53,  10,  49,  56,  56,  54,  55,  124, 50,  51,
+    50,  51,  57,  55,  50,  46,  48,  48,  10,  50,  56,  50,  52,  124, 50,
+    51,  50,  51,  51,  49,  53,  46,  48,  56,  10,  49,  57,  49,  49,  55,
+    124, 50,  51,  49,  57,  57,  49,  49,  46,  49,  48,  10,  49,  57,  48,
+    54,  124, 50,  51,  49,  57,  55,  53,  55,  46,  54,  48,  10,  50,  52,
+    53,  124, 50,  51,  49,  57,  52,  53,  48,  46,  57,  48,  10,  49,  55,
+    51,  49,  56,  124, 50,  51,  49,  55,  56,  54,  48,  46,  51,  57,  10,
+    51,  56,  54,  50,  124, 50,  51,  49,  54,  52,  53,  51,  46,  55,  50,
+    10,  56,  49,  48,  48,  124, 50,  51,  49,  51,  56,  55,  52,  46,  49,
+    50,  10,  50,  57,  53,  56,  124, 50,  51,  49,  50,  50,  51,  57,  46,
+    52,  55,  10,  49,  48,  50,  54,  51,  124, 50,  51,  48,  56,  53,  49,
+    52,  46,  48,  54,  10,  49,  51,  56,  49,  52,  124, 50,  51,  48,  52,
+    57,  52,  48,  46,  52,  48,  10,  57,  51,  57,  52,  124, 50,  51,  48,
+    51,  49,  54,  49,  46,  55,  52,  10,  49,  56,  48,  56,  48,  124, 50,
+    50,  57,  57,  52,  49,  54,  46,  55,  56,  10,  49,  50,  55,  49,  124,
+    50,  50,  56,  57,  53,  50,  54,  46,  57,  56,  10,  51,  51,  50,  55,
+    124, 50,  50,  55,  56,  52,  55,  52,  46,  52,  56,  10,  56,  55,  52,
+    48,  124, 50,  50,  55,  56,  52,  48,  53,  46,  57,  50,  10,  56,  49,
+    49,  57,  124, 50,  50,  55,  54,  52,  50,  56,  46,  49,  55,  10,  51,
+    51,  54,  56,  124, 50,  50,  55,  52,  51,  55,  51,  46,  54,  50,  10,
+    55,  57,  54,  51,  124, 50,  50,  55,  50,  51,  48,  48,  46,  56,  48,
+    10,  50,  49,  53,  49,  124, 50,  50,  55,  48,  57,  51,  50,  46,  55,
+    50,  10,  49,  54,  57,  57,  53,  124, 50,  50,  55,  48,  50,  54,  52,
+    46,  54,  56,  10,  57,  57,  49,  56,  124, 50,  50,  54,  57,  55,  51,
+    51,  46,  48,  55,  10,  53,  48,  51,  124, 50,  50,  54,  56,  53,  51,
+    53,  46,  50,  53,  10,  49,  54,  54,  57,  50,  124, 50,  50,  53,  54,
+    52,  56,  52,  46,  53,  48,  10,  55,  57,  51,  124, 50,  50,  53,  52,
+    49,  57,  56,  46,  55,  50,  10,  49,  54,  52,  53,  53,  124, 50,  50,
+    53,  50,  51,  54,  49,  46,  56,  54,  10,  54,  54,  52,  52,  124, 50,
+    50,  52,  57,  53,  50,  49,  46,  56,  50,  10,  49,  55,  50,  56,  48,
+    124, 50,  50,  52,  57,  52,  51,  55,  46,  53,  48,  10,  54,  56,  49,
+    51,  124, 50,  50,  52,  56,  57,  56,  50,  46,  48,  48,  10,  52,  54,
+    55,  52,  124, 50,  50,  52,  54,  57,  49,  53,  46,  51,  50,  10,  49,
+    54,  51,  50,  53,  124, 50,  50,  52,  52,  51,  54,  57,  46,  56,  48,
+    10,  49,  56,  50,  124, 50,  50,  52,  51,  50,  57,  48,  46,  48,  48,
+    10,  52,  54,  50,  54,  124, 50,  50,  52,  50,  52,  55,  52,  46,  51,
+    53,  10,  49,  48,  56,  54,  48,  124, 50,  50,  52,  49,  50,  57,  49,
+    46,  54,  48,  10,  49,  52,  48,  51,  52,  124, 50,  50,  52,  49,  50,
+    50,  48,  46,  56,  48,  10,  50,  52,  55,  54,  124, 50,  50,  52,  48,
+    56,  53,  53,  46,  50,  48,  10,  52,  50,  53,  51,  124, 50,  50,  51,
+    57,  57,  56,  53,  46,  54,  52,  10,  51,  50,  49,  49,  124, 50,  50,
+    51,  57,  56,  55,  49,  46,  48,  50,  10,  49,  50,  57,  48,  124, 50,
+    50,  51,  51,  51,  49,  51,  46,  48,  48,  10,  56,  52,  55,  57,  124,
+    50,  50,  51,  50,  49,  56,  57,  46,  48,  52,  10,  49,  49,  56,  57,
+    53,  124, 50,  50,  51,  49,  54,  48,  55,  46,  48,  48,  10,  51,  52,
+    56,  55,  124, 50,  50,  51,  48,  49,  55,  49,  46,  54,  50,  10,  49,
+    52,  56,  55,  48,  124, 50,  50,  50,  57,  57,  49,  53,  46,  51,  55,
+    10,  49,  54,  51,  50,  56,  124, 50,  50,  50,  57,  52,  56,  51,  46,
+    57,  54,  10,  49,  56,  53,  56,  53,  124, 50,  50,  50,  56,  50,  49,
+    53,  46,  53,  48,  10,  55,  54,  51,  56,  124, 50,  50,  50,  56,  50,
+    48,  56,  46,  48,  56,  10,  53,  52,  51,  54,  124, 50,  50,  50,  53,
+    54,  55,  50,  46,  50,  56,  10,  49,  52,  53,  57,  52,  124, 50,  50,
+    50,  51,  48,  48,  53,  46,  48,  55,  10,  52,  53,  51,  50,  124, 50,
+    50,  49,  53,  55,  49,  49,  46,  48,  50,  10,  55,  53,  56,  54,  124,
+    50,  50,  49,  48,  53,  54,  50,  46,  53,  49,  10,  49,  49,  56,  55,
+    48,  124, 50,  50,  48,  53,  49,  56,  50,  46,  56,  50,  10,  49,  56,
+    52,  56,  55,  124, 50,  50,  48,  51,  54,  53,  51,  46,  54,  48,  10,
+    57,  49,  55,  57,  124, 50,  50,  48,  50,  55,  50,  48,  46,  53,  50,
+    10,  49,  54,  53,  48,  48,  124, 50,  50,  48,  49,  49,  56,  53,  46,
+    51,  49,  10,  51,  54,  55,  57,  124, 50,  50,  48,  48,  53,  57,  50,
+    46,  55,  48,  10,  49,  50,  56,  48,  51,  124, 50,  49,  57,  56,  50,
+    57,  53,  46,  48,  48,  10,  49,  56,  48,  53,  54,  124, 50,  49,  57,
+    54,  55,  52,  49,  46,  57,  48,  10,  49,  49,  51,  57,  54,  124, 50,
+    49,  57,  53,  54,  52,  53,  46,  54,  52,  10,  53,  48,  56,  55,  124,
+    50,  49,  57,  52,  49,  50,  48,  46,  55,  50,  10,  56,  48,  54,  55,
+    124, 50,  49,  57,  50,  48,  52,  56,  46,  54,  52,  10,  49,  53,  51,
+    53,  55,  124, 50,  49,  57,  49,  54,  52,  54,  46,  53,  56,  10,  52,
+    52,  57,  49,  124, 50,  49,  56,  57,  55,  49,  51,  46,  53,  48,  10,
+    50,  48,  56,  124, 50,  49,  56,  57,  48,  52,  54,  46,  56,  48,  10,
+    49,  48,  57,  53,  56,  124, 50,  49,  56,  56,  55,  54,  54,  46,  56,
+    50,  10,  57,  49,  50,  54,  124, 50,  49,  56,  56,  52,  49,  48,  46,
+    53,  48,  10,  49,  53,  48,  56,  52,  124, 50,  49,  56,  52,  51,  50,
+    55,  46,  48,  50,  10,  49,  56,  56,  53,  48,  124, 50,  49,  56,  51,
+    51,  48,  57,  46,  53,  50,  10,  51,  51,  57,  56,  124, 50,  49,  56,
+    48,  50,  53,  48,  46,  48,  48,  10,  49,  54,  49,  51,  55,  124, 50,
+    49,  55,  55,  51,  49,  56,  46,  55,  54,  10,  50,  49,  49,  124, 50,
+    49,  55,  52,  56,  48,  56,  46,  57,  54,  10,  49,  56,  52,  50,  50,
+    124, 50,  49,  55,  52,  51,  56,  49,  46,  48,  48,  10,  49,  53,  56,
+    52,  48,  124, 50,  49,  55,  51,  53,  49,  48,  46,  52,  48,  10,  49,
+    57,  53,  53,  51,  124, 50,  49,  55,  51,  48,  55,  57,  46,  55,  55,
+    10,  56,  50,  50,  49,  124, 50,  49,  54,  57,  57,  57,  50,  46,  49,
+    54,  10,  49,  55,  48,  48,  48,  124, 50,  49,  54,  57,  54,  49,  49,
+    46,  49,  54,  10,  54,  55,  53,  53,  124, 50,  49,  54,  56,  53,  48,
+    53,  46,  49,  53,  10,  49,  48,  56,  49,  55,  124, 50,  49,  54,  55,
+    55,  49,  48,  46,  54,  56,  10,  56,  51,  50,  55,  124, 50,  49,  54,
+    55,  54,  53,  48,  46,  54,  48,  10,  53,  52,  51,  124, 50,  49,  54,
+    55,  51,  54,  56,  46,  48,  48,  10,  52,  53,  53,  51,  124, 50,  49,
+    54,  51,  51,  55,  49,  46,  53,  50,  10,  49,  53,  48,  49,  57,  124,
+    50,  49,  54,  50,  50,  56,  56,  46,  48,  48,  10,  51,  51,  52,  124,
+    50,  49,  54,  50,  49,  55,  56,  46,  52,  56,  10,  56,  53,  49,  54,
+    124, 50,  49,  54,  49,  52,  55,  57,  46,  48,  52,  10,  49,  49,  51,
+    52,  57,  124, 50,  49,  53,  56,  57,  52,  49,  46,  56,  56,  10,  51,
+    57,  48,  50,  124, 50,  49,  53,  55,  48,  50,  55,  46,  56,  54,  10,
+    49,  52,  55,  51,  49,  124, 50,  49,  53,  53,  51,  48,  50,  46,  50,
+    52,  10,  51,  50,  54,  124, 50,  49,  53,  51,  51,  56,  48,  46,  48,
+    56,  10,  49,  49,  52,  48,  51,  124, 50,  49,  53,  49,  50,  52,  50,
+    46,  51,  48,  10,  49,  49,  54,  53,  55,  124, 50,  49,  53,  48,  52,
+    52,  54,  46,  48,  56,  10,  57,  52,  57,  54,  124, 50,  49,  52,  57,
+    50,  49,  57,  46,  48,  49,  10,  56,  49,  49,  48,  124, 50,  49,  52,
+    57,  49,  50,  48,  46,  49,  51,  10,  53,  49,  53,  51,  124, 50,  49,
+    52,  56,  53,  50,  55,  46,  50,  53,  10,  56,  56,  52,  124, 50,  49,
+    52,  56,  51,  50,  52,  46,  57,  56,  10,  56,  54,  51,  55,  124, 50,
+    49,  52,  54,  49,  56,  53,  46,  49,  48,  10,  50,  51,  54,  52,  124,
+    50,  49,  52,  53,  55,  57,  48,  46,  55,  50,  10,  49,  50,  51,  56,
+    54,  124, 50,  49,  52,  53,  48,  48,  49,  46,  52,  55,  10,  49,  48,
+    49,  51,  51,  124, 50,  49,  52,  52,  57,  48,  51,  46,  57,  54,  10,
+    57,  56,  57,  53,  124, 50,  49,  52,  51,  51,  50,  52,  46,  56,  48,
+    10,  49,  51,  55,  53,  53,  124, 50,  49,  52,  50,  53,  51,  57,  46,
+    52,  48,  10,  52,  51,  50,  55,  124, 50,  49,  51,  56,  53,  48,  49,
+    46,  52,  48,  10,  51,  51,  54,  57,  124, 50,  49,  51,  55,  52,  48,
+    56,  46,  55,  54,  10,  53,  56,  49,  53,  124, 50,  49,  51,  54,  57,
+    56,  53,  46,  48,  48,  10,  49,  57,  51,  53,  55,  124, 50,  49,  51,
+    50,  54,  53,  55,  46,  50,  56,  10,  50,  54,  55,  53,  124, 50,  49,
+    50,  52,  49,  53,  56,  46,  55,  50,  10,  49,  55,  56,  54,  57,  124,
+    50,  49,  50,  51,  57,  57,  49,  46,  55,  50,  10,  49,  49,  55,  48,
+    50,  124, 50,  49,  50,  50,  49,  51,  50,  46,  57,  57,  10,  49,  55,
+    50,  53,  55,  124, 50,  49,  49,  55,  56,  53,  48,  46,  54,  52,  10,
+    57,  57,  53,  50,  124, 50,  49,  49,  54,  54,  56,  54,  46,  51,  50,
+    10,  51,  56,  56,  49,  124, 50,  49,  49,  49,  52,  53,  55,  46,  49,
+    53,  10,  49,  48,  57,  53,  49,  124, 50,  49,  49,  49,  49,  56,  53,
+    46,  53,  56,  10,  50,  49,  50,  56,  124, 50,  49,  48,  57,  55,  48,
+    50,  46,  51,  48,  10,  54,  54,  57,  57,  124, 50,  49,  48,  54,  53,
+    55,  56,  46,  52,  48,  10,  51,  49,  53,  53,  124, 50,  49,  48,  51,
+    54,  51,  54,  46,  54,  52,  10,  49,  54,  54,  52,  57,  124, 50,  49,
+    48,  49,  57,  53,  54,  46,  50,  48,  10,  49,  53,  50,  53,  55,  124,
+    50,  49,  48,  48,  50,  57,  55,  46,  55,  53,  10,  57,  57,  55,  56,
+    124, 50,  48,  57,  57,  53,  54,  54,  46,  53,  54,  10,  49,  54,  56,
+    49,  48,  124, 50,  48,  57,  56,  51,  48,  49,  46,  52,  52,  10,  49,
+    48,  54,  53,  51,  124, 50,  48,  57,  51,  51,  56,  56,  46,  55,  48,
+    10,  49,  48,  52,  55,  54,  124, 50,  48,  57,  50,  55,  54,  54,  46,
+    52,  56,  10,  49,  48,  56,  56,  51,  124, 50,  48,  56,  55,  52,  57,
+    53,  46,  50,  56,  10,  57,  55,  48,  52,  124, 50,  48,  56,  54,  57,
+    54,  55,  46,  54,  49,  10,  49,  49,  49,  57,  124, 50,  48,  56,  53,
+    49,  56,  50,  46,  56,  52,  10,  49,  57,  49,  51,  57,  124, 50,  48,
+    55,  57,  55,  56,  56,  46,  51,  52,  10,  50,  49,  52,  52,  124, 50,
+    48,  55,  56,  51,  57,  49,  46,  49,  52,  10,  57,  49,  51,  53,  124,
+    50,  48,  55,  54,  51,  55,  55,  46,  56,  48,  10,  49,  56,  53,  52,
+    56,  124, 50,  48,  55,  53,  53,  56,  52,  46,  51,  50,  10,  49,  48,
+    53,  52,  53,  124, 50,  48,  55,  53,  50,  51,  48,  46,  51,  53,  10,
+    54,  50,  50,  48,  124, 50,  48,  55,  52,  51,  52,  49,  46,  55,  50,
+    10,  56,  54,  49,  54,  124, 50,  48,  55,  50,  56,  56,  55,  46,  54,
+    53,  10,  53,  50,  51,  48,  124, 50,  48,  55,  50,  49,  54,  49,  46,
+    55,  52,  10,  49,  51,  57,  49,  54,  124, 50,  48,  55,  48,  53,  48,
+    52,  46,  55,  50,  10,  52,  50,  57,  57,  124, 50,  48,  54,  57,  57,
+    50,  50,  46,  57,  54,  10,  56,  57,  52,  124, 50,  48,  54,  57,  54,
+    56,  56,  46,  49,  54,  10,  49,  55,  56,  52,  55,  124, 50,  48,  54,
+    51,  51,  54,  55,  46,  48,  52,  10,  49,  56,  56,  55,  57,  124, 50,
+    48,  54,  49,  57,  48,  50,  46,  50,  53,  10,  49,  51,  48,  51,  54,
+    124, 50,  48,  54,  49,  54,  48,  48,  46,  49,  55,  10,  49,  48,  54,
+    48,  54,  124, 50,  48,  54,  48,  52,  57,  50,  46,  52,  48,  10,  57,
+    52,  53,  52,  124, 50,  48,  54,  48,  48,  49,  54,  46,  52,  56,  10,
+    49,  49,  56,  124, 50,  48,  53,  57,  56,  48,  56,  46,  56,  54,  10,
+    57,  54,  48,  49,  124, 50,  48,  53,  57,  55,  49,  53,  46,  55,  54,
+    10,  49,  51,  55,  54,  57,  124, 50,  48,  53,  55,  54,  54,  56,  46,
+    48,  56,  10,  49,  57,  56,  55,  124, 50,  48,  53,  55,  50,  56,  57,
+    46,  50,  55,  10,  49,  51,  56,  54,  51,  124, 50,  48,  53,  53,  51,
+    54,  56,  46,  48,  48,  10,  49,  51,  53,  54,  50,  124, 50,  48,  53,
+    52,  55,  53,  52,  46,  50,  52,  10,  49,  56,  52,  48,  124, 50,  48,
+    53,  52,  49,  56,  51,  46,  57,  50,  10,  49,  55,  57,  57,  53,  124,
+    50,  48,  53,  51,  50,  50,  49,  46,  57,  48,  10,  49,  55,  51,  56,
+    57,  124, 50,  48,  53,  49,  49,  50,  56,  46,  50,  48,  10,  49,  53,
+    49,  54,  56,  124, 50,  48,  52,  53,  57,  56,  55,  46,  52,  57,  10,
+    50,  49,  51,  57,  124, 50,  48,  52,  53,  51,  54,  53,  46,  52,  48,
+    10,  52,  48,  50,  52,  124, 50,  48,  52,  52,  50,  52,  51,  46,  49,
+    48,  10,  56,  57,  54,  52,  124, 50,  48,  52,  49,  54,  52,  56,  46,
+    56,  53,  10,  49,  56,  49,  124, 50,  48,  52,  48,  49,  54,  55,  46,
+    48,  52,  10,  55,  54,  50,  56,  124, 50,  48,  51,  57,  53,  52,  56,
+    46,  57,  50,  10,  51,  124, 50,  48,  51,  56,  56,  52,  54,  46,  48,
+    57,  10,  49,  53,  53,  53,  51,  124, 50,  48,  51,  54,  57,  53,  56,
+    46,  57,  49,  10,  49,  49,  51,  53,  53,  124, 50,  48,  51,  53,  52,
+    48,  53,  46,  54,  48,  10,  49,  51,  48,  48,  54,  124, 50,  48,  51,
+    52,  57,  57,  49,  46,  50,  48,  10,  51,  48,  57,  49,  124, 50,  48,
+    51,  49,  51,  57,  51,  46,  53,  49,  10,  49,  50,  56,  49,  124, 50,
+    48,  51,  48,  54,  50,  56,  46,  52,  56,  10,  49,  52,  48,  56,  124,
+    50,  48,  50,  56,  54,  50,  49,  46,  54,  54,  10,  49,  56,  50,  49,
+    49,  124, 50,  48,  50,  52,  53,  51,  56,  46,  54,  55,  10,  50,  50,
+    56,  55,  124, 50,  48,  50,  48,  55,  53,  52,  46,  51,  50,  10,  54,
+    50,  50,  56,  124, 50,  48,  49,  57,  49,  57,  56,  46,  56,  50,  10,
+    52,  51,  54,  50,  124, 50,  48,  49,  56,  52,  57,  53,  46,  50,  53,
+    10,  49,  48,  56,  55,  51,  124, 50,  48,  49,  51,  50,  56,  48,  46,
+    51,  50,  10,  55,  51,  56,  51,  124, 50,  48,  48,  57,  53,  56,  49,
+    46,  57,  50,  10,  49,  51,  56,  54,  124, 50,  48,  48,  54,  53,  52,
+    52,  46,  50,  54,  10,  57,  56,  50,  48,  124, 50,  48,  48,  53,  56,
+    49,  53,  46,  55,  54,  10,  49,  56,  49,  51,  52,  124, 50,  48,  48,
+    51,  52,  48,  57,  46,  55,  51,  10,  49,  53,  55,  50,  55,  124, 50,
+    48,  48,  48,  54,  53,  52,  46,  53,  48,  10,  49,  53,  55,  124, 50,
+    48,  48,  48,  49,  52,  56,  46,  49,  54,  10,  49,  57,  53,  55,  49,
+    124, 49,  57,  57,  57,  56,  57,  49,  46,  49,  49,  10,  49,  55,  55,
+    50,  56,  124, 49,  57,  57,  55,  57,  52,  52,  46,  52,  48,  10,  53,
+    50,  55,  56,  124, 49,  57,  57,  54,  54,  52,  52,  46,  50,  49,  10,
+    49,  55,  55,  51,  55,  124, 49,  57,  57,  52,  54,  53,  51,  46,  55,
+    54,  10,  49,  48,  50,  50,  48,  124, 49,  57,  56,  57,  56,  57,  48,
+    46,  57,  56,  10,  49,  51,  57,  55,  124, 49,  57,  56,  52,  53,  48,
+    57,  46,  50,  50,  10,  54,  49,  57,  53,  124, 49,  57,  56,  51,  57,
+    50,  56,  46,  50,  54,  10,  52,  50,  55,  48,  124, 49,  57,  56,  51,
+    55,  50,  54,  46,  57,  53,  10,  49,  54,  57,  54,  53,  124, 49,  57,
+    56,  51,  50,  56,  54,  46,  50,  53,  10,  49,  54,  56,  51,  124, 49,
+    57,  56,  48,  54,  51,  56,  46,  54,  52,  10,  49,  51,  48,  56,  54,
+    124, 49,  57,  55,  56,  54,  48,  57,  46,  52,  48,  10,  55,  49,  50,
+    52,  124, 49,  57,  55,  52,  48,  51,  57,  46,  51,  56,  10,  53,  50,
+    49,  49,  124, 49,  57,  55,  51,  56,  52,  51,  46,  55,  54,  10,  54,
+    55,  57,  52,  124, 49,  57,  55,  51,  49,  52,  57,  46,  52,  55,  10,
+    50,  53,  55,  124, 49,  57,  55,  51,  48,  51,  53,  46,  52,  52,  10,
+    54,  57,  57,  53,  124, 49,  57,  54,  56,  50,  56,  49,  46,  53,  53,
+    10,  56,  52,  52,  55,  124, 49,  57,  54,  55,  50,  57,  50,  46,  55,
+    48,  10,  49,  53,  56,  55,  51,  124, 49,  57,  54,  55,  50,  53,  55,
+    46,  56,  57,  10,  49,  50,  56,  54,  50,  124, 49,  57,  54,  52,  48,
+    49,  52,  46,  49,  51,  10,  56,  50,  57,  53,  124, 49,  57,  54,  49,
+    52,  54,  55,  46,  48,  56,  10,  57,  51,  49,  124, 49,  57,  53,  56,
+    56,  50,  53,  46,  50,  50,  10,  54,  56,  55,  54,  124, 49,  57,  53,
+    55,  51,  53,  57,  46,  52,  56,  10,  49,  57,  51,  50,  124, 49,  57,
+    53,  52,  53,  57,  50,  46,  52,  48,  10,  49,  48,  54,  49,  124, 49,
+    57,  53,  50,  54,  56,  56,  46,  48,  54,  10,  49,  56,  49,  48,  56,
+    124, 49,  57,  53,  49,  49,  52,  51,  46,  54,  55,  10,  53,  49,  51,
+    56,  124, 49,  57,  53,  48,  56,  54,  49,  46,  48,  48,  10,  49,  50,
+    53,  57,  56,  124, 49,  57,  53,  48,  50,  49,  49,  46,  54,  49,  10,
+    49,  48,  56,  50,  57,  124, 49,  57,  52,  51,  57,  50,  52,  46,  54,
+    50,  10,  49,  49,  57,  53,  48,  124, 49,  57,  52,  49,  50,  49,  49,
+    46,  48,  48,  10,  49,  50,  48,  55,  54,  124, 49,  57,  51,  57,  51,
+    50,  51,  46,  57,  54,  10,  50,  49,  55,  54,  124, 49,  57,  51,  56,
+    54,  57,  49,  46,  51,  55,  10,  54,  54,  49,  54,  124, 49,  57,  51,
+    55,  52,  48,  49,  46,  56,  56,  10,  53,  56,  57,  51,  124, 49,  57,
+    51,  52,  51,  53,  56,  46,  53,  56,  10,  57,  55,  54,  124, 49,  57,
+    51,  51,  48,  54,  54,  46,  56,  48,  10,  49,  51,  49,  55,  51,  124,
+    49,  57,  51,  50,  53,  53,  55,  46,  53,  50,  10,  49,  52,  57,  52,
+    55,  124, 49,  57,  50,  57,  50,  50,  57,  46,  57,  56,  10,  49,  54,
+    56,  53,  55,  124, 49,  57,  50,  56,  56,  49,  52,  46,  56,  48,  10,
+    49,  51,  52,  48,  51,  124, 49,  57,  50,  56,  55,  48,  50,  46,  56,
+    56,  10,  52,  56,  49,  57,  124, 49,  57,  50,  54,  57,  54,  57,  46,
+    54,  56,  10,  49,  51,  49,  50,  55,  124, 49,  57,  50,  54,  57,  50,
+    57,  46,  56,  51,  10,  54,  56,  55,  49,  124, 49,  57,  50,  54,  55,
+    56,  55,  46,  54,  56,  10,  49,  53,  52,  54,  53,  124, 49,  57,  50,
+    53,  49,  52,  53,  46,  48,  57,  10,  49,  49,  51,  49,  124, 49,  57,
+    50,  48,  48,  48,  53,  46,  53,  48,  10,  49,  49,  56,  52,  53,  124,
+    49,  57,  49,  51,  53,  55,  54,  46,  52,  48,  10,  56,  51,  54,  52,
+    124, 49,  57,  48,  57,  49,  50,  50,  46,  50,  48,  10,  49,  54,  53,
+    56,  56,  124, 49,  57,  48,  52,  50,  55,  50,  46,  51,  55,  10,  54,
+    55,  53,  57,  124, 49,  57,  48,  51,  57,  48,  54,  46,  50,  57,  10,
+    49,  49,  53,  56,  54,  124, 49,  57,  48,  49,  56,  57,  53,  46,  54,
+    53,  10,  56,  49,  52,  53,  124, 49,  57,  48,  49,  55,  56,  55,  46,
+    54,  54,  10,  49,  55,  51,  51,  51,  124, 49,  56,  57,  55,  50,  57,
+    55,  46,  50,  48,  10,  49,  51,  50,  57,  48,  124, 49,  56,  57,  48,
+    54,  51,  51,  46,  55,  53,  10,  54,  52,  57,  57,  124, 49,  56,  56,
+    55,  54,  50,  49,  46,  48,  48,  10,  52,  56,  56,  49,  124, 49,  56,
+    56,  55,  53,  51,  53,  46,  57,  50,  10,  55,  49,  52,  55,  124, 49,
+    56,  56,  54,  55,  49,  48,  46,  50,  48,  10,  51,  56,  56,  51,  124,
+    49,  56,  56,  54,  53,  54,  55,  46,  55,  56,  10,  49,  56,  57,  49,
+    49,  124, 49,  56,  56,  53,  53,  57,  55,  46,  49,  50,  10,  49,  49,
+    51,  51,  54,  124, 49,  56,  56,  51,  53,  55,  51,  46,  54,  48,  10,
+    56,  54,  53,  51,  124, 49,  56,  56,  51,  50,  55,  53,  46,  55,  54,
+    10,  49,  57,  52,  55,  54,  124, 49,  56,  56,  49,  52,  57,  50,  46,
+    52,  56,  10,  49,  52,  55,  57,  57,  124, 49,  56,  56,  48,  53,  52,
+    51,  46,  52,  48,  10,  49,  52,  52,  57,  49,  124, 49,  56,  55,  57,
+    50,  49,  57,  46,  57,  50,  10,  49,  49,  56,  49,  53,  124, 49,  56,
+    55,  55,  52,  51,  52,  46,  51,  52,  10,  51,  49,  55,  51,  124, 49,
+    56,  55,  52,  51,  48,  50,  46,  49,  48,  10,  55,  49,  54,  49,  124,
+    49,  56,  55,  51,  48,  50,  51,  46,  52,  53,  10,  49,  52,  54,  51,
+    49,  124, 49,  56,  55,  51,  48,  49,  53,  46,  51,  48,  10,  52,  50,
+    52,  55,  124, 49,  56,  54,  57,  57,  49,  50,  46,  57,  54,  10,  51,
+    53,  54,  56,  124, 49,  56,  54,  53,  56,  50,  52,  46,  52,  48,  10,
+    49,  53,  48,  48,  124, 49,  56,  54,  53,  52,  53,  49,  46,  48,  51,
+    10,  49,  49,  56,  51,  51,  124, 49,  56,  54,  51,  54,  54,  53,  46,
+    50,  51,  10,  52,  57,  53,  124, 49,  56,  54,  48,  55,  55,  49,  46,
+    51,  48,  10,  54,  55,  55,  54,  124, 49,  56,  53,  53,  53,  56,  57,
+    46,  49,  55,  10,  49,  49,  51,  55,  52,  124, 49,  56,  53,  53,  50,
+    50,  49,  46,  49,  50,  10,  53,  54,  51,  55,  124, 49,  56,  53,  51,
+    55,  56,  50,  46,  49,  55,  10,  51,  53,  57,  55,  124, 49,  56,  53,
+    50,  56,  50,  54,  46,  56,  48,  10,  57,  56,  49,  124, 49,  56,  53,
+    50,  48,  56,  51,  46,  54,  48,  10,  49,  54,  48,  55,  54,  124, 49,
+    56,  53,  48,  51,  52,  57,  46,  54,  57,  10,  49,  55,  53,  57,  55,
+    124, 49,  56,  52,  53,  52,  50,  48,  46,  57,  53,  10,  49,  57,  54,
+    48,  57,  124, 49,  56,  52,  51,  49,  56,  53,  46,  52,  56,  10,  49,
+    48,  57,  57,  55,  124, 49,  56,  52,  51,  48,  55,  50,  46,  48,  50,
+    10,  51,  52,  48,  51,  124, 49,  56,  52,  50,  57,  55,  53,  46,  48,
+    48,  10,  56,  57,  55,  124, 49,  56,  52,  50,  56,  52,  53,  46,  49,
+    48,  10,  49,  54,  54,  57,  55,  124, 49,  56,  52,  48,  54,  51,  48,
+    46,  54,  56,  10,  49,  55,  54,  52,  52,  124, 49,  56,  52,  48,  53,
+    57,  55,  46,  56,  48,  10,  54,  52,  56,  53,  124, 49,  56,  51,  56,
+    56,  49,  50,  46,  48,  50,  10,  53,  52,  57,  50,  124, 49,  56,  51,
+    54,  50,  48,  50,  46,  56,  56,  10,  49,  50,  48,  51,  56,  124, 49,
+    56,  51,  53,  48,  55,  53,  46,  48,  54,  10,  57,  51,  50,  53,  124,
+    49,  56,  51,  50,  54,  51,  52,  46,  56,  52,  10,  49,  48,  54,  51,
+    55,  124, 49,  56,  51,  50,  51,  52,  55,  46,  52,  52,  10,  49,  49,
+    51,  49,  56,  124, 49,  56,  51,  48,  49,  53,  56,  46,  51,  57,  10,
+    52,  51,  53,  55,  124, 49,  56,  50,  56,  55,  51,  48,  46,  48,  48,
+    10,  49,  56,  53,  53,  51,  124, 49,  56,  50,  54,  51,  51,  53,  46,
+    50,  48,  10,  49,  50,  54,  50,  51,  124, 49,  56,  50,  53,  57,  53,
+    48,  46,  56,  53,  10,  57,  54,  49,  124, 49,  56,  50,  53,  56,  54,
+    57,  46,  54,  48,  10,  49,  54,  55,  55,  124, 49,  56,  50,  49,  56,
+    49,  54,  46,  57,  48,  10,  56,  50,  49,  49,  124, 49,  56,  50,  48,
+    52,  51,  50,  46,  53,  50,  10,  49,  57,  55,  49,  57,  124, 49,  56,
+    49,  57,  51,  51,  51,  46,  53,  53,  10,  49,  57,  54,  54,  51,  124,
+    49,  56,  49,  57,  48,  55,  52,  46,  51,  53,  10,  49,  54,  50,  57,
+    54,  124, 49,  56,  49,  56,  51,  53,  51,  46,  55,  55,  10,  49,  54,
+    53,  50,  55,  124, 49,  56,  49,  55,  56,  51,  52,  46,  52,  50,  10,
+    52,  57,  54,  52,  124, 49,  56,  49,  53,  52,  48,  48,  46,  48,  50,
+    10,  49,  55,  54,  57,  124, 49,  56,  49,  50,  57,  50,  57,  46,  50,
+    48,  10,  49,  51,  49,  50,  54,  124, 49,  56,  48,  56,  55,  57,  57,
+    46,  57,  54,  10,  55,  56,  53,  52,  124, 49,  56,  48,  55,  54,  48,
+    56,  46,  48,  54,  10,  49,  56,  51,  56,  48,  124, 49,  56,  48,  51,
+    54,  52,  49,  46,  50,  50,  10,  54,  53,  56,  52,  124, 49,  56,  48,
+    50,  51,  52,  54,  46,  57,  56,  10,  55,  54,  54,  53,  124, 49,  56,
+    48,  49,  55,  54,  53,  46,  51,  53,  10,  49,  54,  53,  53,  51,  124,
+    49,  55,  57,  54,  49,  52,  54,  46,  55,  56,  10,  49,  55,  55,  54,
+    49,  124, 49,  55,  57,  53,  48,  57,  53,  46,  55,  50,  10,  49,  49,
+    49,  55,  57,  124, 49,  55,  57,  52,  56,  57,  48,  46,  51,  48,  10,
+    49,  53,  49,  55,  49,  124, 49,  55,  57,  52,  49,  52,  56,  46,  55,
+    50,  10,  51,  48,  49,  56,  124, 49,  55,  57,  51,  49,  56,  51,  46,
+    56,  56,  10,  49,  53,  55,  52,  49,  124, 49,  55,  56,  56,  54,  49,
+    50,  46,  48,  48,  10,  53,  51,  51,  49,  124, 49,  55,  56,  51,  57,
+    48,  49,  46,  51,  53,  10,  57,  56,  54,  48,  124, 49,  55,  55,  53,
+    48,  55,  49,  46,  50,  54,  10,  55,  57,  56,  52,  124, 49,  55,  55,
+    52,  51,  48,  50,  46,  55,  53,  10,  49,  53,  51,  53,  52,  124, 49,
+    55,  55,  52,  50,  55,  48,  46,  55,  55,  10,  49,  55,  56,  56,  52,
+    124, 49,  55,  55,  52,  50,  49,  50,  46,  52,  52,  10,  49,  54,  50,
+    53,  55,  124, 49,  55,  55,  49,  56,  54,  57,  46,  55,  49,  10,  49,
+    48,  54,  57,  54,  124, 49,  55,  54,  56,  54,  52,  53,  46,  50,  48,
+    10,  50,  49,  48,  52,  124, 49,  55,  54,  55,  57,  48,  50,  46,  54,
+    52,  10,  49,  52,  52,  54,  53,  124, 49,  55,  54,  52,  57,  52,  54,
+    46,  52,  48,  10,  49,  48,  48,  56,  57,  124, 49,  55,  54,  52,  54,
+    57,  50,  46,  51,  50,  10,  54,  55,  49,  57,  124, 49,  55,  54,  50,
+    54,  57,  57,  46,  53,  52,  10,  51,  54,  52,  56,  124, 49,  55,  54,
+    48,  53,  57,  52,  46,  52,  50,  10,  55,  50,  52,  49,  124, 49,  55,
+    53,  57,  57,  49,  51,  46,  53,  57,  10,  49,  49,  49,  50,  50,  124,
+    49,  55,  53,  55,  52,  51,  48,  46,  48,  52,  10,  49,  55,  48,  49,
+    57,  124, 49,  55,  53,  50,  53,  54,  48,  46,  54,  53,  10,  49,  51,
+    56,  55,  55,  124, 49,  55,  52,  52,  50,  55,  49,  46,  49,  48,  10,
+    49,  53,  51,  50,  53,  124, 49,  55,  52,  51,  56,  50,  54,  46,  50,
+    54,  10,  49,  55,  56,  54,  48,  124, 49,  55,  51,  57,  56,  55,  48,
+    46,  52,  52,  10,  50,  50,  51,  54,  124, 49,  55,  51,  57,  55,  57,
+    53,  46,  56,  48,  10,  52,  52,  51,  54,  124, 49,  55,  51,  56,  55,
+    54,  48,  46,  51,  50,  10,  55,  55,  48,  49,  124, 49,  55,  51,  56,
+    54,  55,  48,  46,  52,  48,  10,  56,  49,  52,  55,  124, 49,  55,  51,
+    54,  56,  53,  53,  46,  49,  54,  10,  54,  54,  55,  54,  124, 49,  55,
+    51,  54,  51,  52,  49,  46,  52,  52,  10,  49,  57,  53,  48,  53,  124,
+    49,  55,  51,  53,  52,  49,  51,  46,  52,  51,  10,  57,  56,  56,  53,
+    124, 49,  55,  51,  49,  51,  54,  54,  46,  50,  54,  10,  50,  49,  49,
+    50,  124, 49,  55,  50,  53,  57,  51,  52,  46,  48,  56,  10,  53,  51,
+    51,  48,  124, 49,  55,  50,  50,  49,  57,  54,  46,  57,  56,  10,  51,
+    53,  54,  49,  124, 49,  55,  50,  48,  51,  55,  55,  46,  57,  54,  10,
+    49,  48,  49,  48,  52,  124, 49,  55,  49,  52,  52,  49,  57,  46,  49,
+    54,  10,  49,  54,  51,  54,  50,  124, 49,  55,  49,  50,  52,  53,  55,
+    46,  51,  56,  10,  49,  53,  53,  55,  51,  124, 49,  55,  49,  50,  51,
+    54,  53,  46,  52,  52,  10,  49,  53,  48,  48,  54,  124, 49,  55,  49,
+    49,  51,  56,  49,  46,  51,  53,  10,  49,  52,  54,  50,  57,  124, 49,
+    55,  48,  57,  57,  52,  50,  46,  48,  53,  10,  57,  54,  49,  50,  124,
+    49,  55,  48,  57,  53,  50,  56,  46,  51,  56,  10,  49,  57,  57,  49,
+    48,  124, 49,  55,  48,  57,  50,  49,  49,  46,  49,  53,  10,  49,  51,
+    49,  52,  53,  124, 49,  55,  48,  56,  57,  48,  55,  46,  52,  54,  10,
+    49,  49,  52,  57,  52,  124, 49,  55,  48,  55,  57,  55,  51,  46,  54,
+    56,  10,  49,  53,  56,  57,  53,  124, 49,  55,  48,  54,  57,  57,  57,
+    46,  52,  53,  10,  56,  50,  51,  57,  124, 49,  55,  48,  53,  52,  55,
+    57,  46,  49,  48,  10,  50,  52,  48,  51,  124, 49,  55,  48,  53,  51,
+    51,  49,  46,  49,  48,  10,  49,  57,  52,  51,  54,  124, 49,  55,  48,
+    50,  55,  48,  54,  46,  48,  48,  10,  51,  52,  55,  54,  124, 49,  55,
+    48,  50,  51,  51,  53,  46,  56,  48,  10,  54,  56,  50,  56,  124, 49,
+    55,  48,  50,  50,  57,  50,  46,  48,  56,  10,  55,  55,  49,  124, 49,
+    55,  48,  49,  53,  56,  57,  46,  53,  48,  10,  56,  52,  52,  56,  124,
+    49,  55,  48,  48,  51,  49,  50,  46,  52,  52,  10,  51,  55,  53,  53,
+    124, 49,  54,  57,  57,  48,  52,  55,  46,  48,  51,  10,  49,  51,  56,
+    57,  53,  124, 49,  54,  57,  56,  54,  55,  57,  46,  48,  51,  10,  57,
+    55,  56,  53,  124, 49,  54,  57,  56,  48,  53,  54,  46,  51,  55,  10,
+    54,  49,  56,  48,  124, 49,  54,  57,  53,  53,  55,  49,  46,  53,  51,
+    10,  53,  51,  50,  124, 49,  54,  57,  52,  51,  53,  54,  46,  49,  53,
+    10,  54,  55,  52,  49,  124, 49,  54,  57,  50,  53,  53,  50,  46,  52,
+    50,  10,  49,  57,  57,  54,  52,  124, 49,  54,  57,  50,  51,  54,  55,
+    46,  54,  52,  10,  51,  55,  52,  55,  124, 49,  54,  57,  49,  50,  52,
+    52,  46,  54,  48,  10,  51,  50,  53,  51,  124, 49,  54,  57,  48,  55,
+    49,  57,  46,  52,  50,  10,  49,  54,  49,  49,  57,  124, 49,  54,  56,
+    56,  51,  51,  57,  46,  50,  53,  10,  55,  49,  49,  51,  124, 49,  54,
+    56,  49,  57,  49,  49,  46,  48,  48,  10,  49,  50,  51,  54,  56,  124,
+    49,  54,  56,  49,  50,  49,  57,  46,  56,  48,  10,  49,  54,  51,  55,
+    56,  124, 49,  54,  55,  57,  55,  48,  53,  46,  54,  48,  10,  49,  51,
+    57,  51,  124, 49,  54,  55,  53,  53,  52,  53,  46,  51,  53,  10,  49,
+    49,  49,  49,  57,  124, 49,  54,  55,  53,  52,  53,  51,  46,  52,  52,
+    10,  52,  52,  54,  57,  124, 49,  54,  55,  52,  48,  50,  51,  46,  52,
+    57,  10,  54,  57,  53,  53,  124, 49,  54,  55,  50,  54,  49,  56,  46,
+    57,  48,  10,  49,  49,  53,  55,  57,  124, 49,  54,  55,  50,  51,  52,
+    53,  46,  51,  50,  10,  49,  57,  56,  57,  56,  124, 49,  54,  55,  49,
+    55,  56,  49,  46,  55,  48,  10,  49,  53,  51,  53,  49,  124, 49,  54,
+    53,  57,  50,  48,  52,  46,  51,  48,  10,  54,  49,  51,  51,  124, 49,
+    54,  53,  56,  50,  49,  53,  46,  52,  54,  10,  57,  49,  49,  48,  124,
+    49,  54,  53,  56,  48,  53,  52,  46,  54,  56,  10,  50,  57,  55,  57,
+    124, 49,  54,  53,  54,  48,  49,  54,  46,  55,  52,  10,  49,  56,  55,
+    54,  52,  124, 49,  54,  53,  51,  55,  48,  56,  46,  52,  56,  10,  56,
+    57,  57,  53,  124, 49,  54,  53,  51,  54,  50,  55,  46,  53,  56,  10,
+    49,  51,  48,  57,  54,  124, 49,  54,  53,  49,  52,  48,  56,  46,  54,
+    55,  10,  49,  53,  48,  54,  50,  124, 49,  54,  53,  48,  53,  52,  56,
+    46,  48,  50,  10,  55,  57,  50,  52,  124, 49,  54,  53,  48,  50,  48,
+    50,  46,  52,  48,  10,  49,  48,  48,  55,  54,  124, 49,  54,  52,  55,
+    57,  55,  48,  46,  50,  52,  10,  49,  53,  56,  53,  57,  124, 49,  54,
+    52,  54,  48,  51,  54,  46,  50,  56,  10,  49,  55,  57,  51,  50,  124,
+    49,  54,  52,  50,  54,  52,  48,  46,  54,  54,  10,  49,  57,  54,  57,
+    52,  124, 49,  54,  52,  50,  48,  56,  57,  46,  53,  48,  10,  49,  51,
+    56,  50,  55,  124, 49,  54,  52,  50,  48,  48,  49,  46,  51,  49,  10,
+    49,  55,  57,  54,  51,  124, 49,  54,  51,  57,  54,  56,  57,  46,  48,
+    48,  10,  49,  48,  54,  57,  56,  124, 49,  54,  51,  53,  56,  52,  56,
+    46,  50,  54,  10,  49,  56,  48,  48,  51,  124, 49,  54,  51,  51,  53,
+    51,  48,  46,  55,  56,  10,  56,  52,  49,  54,  124, 49,  54,  51,  51,
+    51,  54,  54,  46,  55,  55,  10,  52,  55,  54,  124, 49,  54,  51,  49,
+    49,  53,  52,  46,  48,  54,  10,  50,  56,  48,  54,  124, 49,  54,  51,
+    48,  55,  56,  50,  46,  56,  48,  10,  49,  50,  49,  50,  57,  124, 49,
+    54,  50,  56,  54,  49,  53,  46,  52,  55,  10,  49,  49,  50,  49,  53,
+    124, 49,  54,  50,  54,  54,  50,  52,  46,  55,  48,  10,  49,  52,  48,
+    54,  49,  124, 49,  54,  50,  52,  57,  51,  51,  46,  52,  52,  10,  53,
+    57,  53,  54,  124, 49,  54,  50,  51,  53,  56,  54,  46,  49,  48,  10,
+    57,  48,  52,  51,  124, 49,  54,  50,  50,  54,  55,  48,  46,  52,  48,
+    10,  49,  51,  50,  56,  55,  124, 49,  54,  50,  49,  57,  56,  48,  46,
+    51,  54,  10,  49,  49,  52,  49,  48,  124, 49,  54,  50,  49,  52,  50,
+    48,  46,  57,  48,  10,  49,  51,  57,  57,  48,  124, 49,  54,  50,  49,
+    50,  54,  56,  46,  50,  48,  10,  49,  50,  57,  53,  50,  124, 49,  54,
+    49,  57,  50,  49,  53,  46,  49,  56,  10,  49,  53,  49,  56,  49,  124,
+    49,  54,  49,  57,  48,  56,  56,  46,  54,  56,  10,  57,  55,  56,  52,
+    124, 49,  54,  49,  56,  49,  50,  48,  46,  53,  51,  10,  49,  48,  55,
+    51,  51,  124, 49,  54,  49,  54,  49,  54,  56,  46,  56,  56,  10,  49,
+    54,  48,  53,  52,  124, 49,  54,  49,  52,  53,  51,  49,  46,  50,  51,
+    10,  53,  56,  54,  52,  124, 49,  54,  49,  52,  51,  57,  55,  46,  56,
+    51,  10,  49,  56,  55,  53,  124, 49,  54,  49,  49,  57,  50,  55,  46,
+    48,  48,  10,  49,  55,  51,  56,  49,  124, 49,  54,  49,  49,  54,  54,
+    52,  46,  56,  48,  10,  49,  52,  53,  54,  50,  124, 49,  54,  48,  55,
+    52,  54,  55,  46,  57,  50,  10,  53,  55,  53,  124, 49,  54,  48,  53,
+    57,  52,  49,  46,  55,  51,  10,  50,  48,  48,  53,  124, 49,  54,  48,
+    53,  53,  57,  49,  46,  55,  50,  10,  52,  51,  51,  50,  124, 49,  54,
+    48,  53,  52,  52,  56,  46,  56,  51,  10,  52,  54,  53,  51,  124, 49,
+    54,  48,  50,  53,  57,  54,  46,  51,  48,  10,  49,  53,  52,  48,  51,
+    124, 49,  54,  48,  49,  56,  51,  48,  46,  52,  52,  10,  49,  55,  52,
+    51,  48,  124, 49,  53,  57,  57,  54,  56,  49,  46,  52,  50,  10,  52,
+    55,  57,  56,  124, 49,  53,  57,  51,  54,  51,  48,  46,  53,  48,  10,
+    49,  50,  57,  57,  49,  124, 49,  53,  57,  51,  51,  50,  49,  46,  53,
+    50,  10,  49,  53,  54,  53,  51,  124, 49,  53,  57,  51,  49,  51,  56,
+    46,  54,  54,  10,  49,  48,  48,  54,  54,  124, 49,  53,  57,  51,  48,
+    52,  57,  46,  48,  54,  10,  56,  56,  57,  50,  124, 49,  53,  57,  50,
+    49,  48,  48,  46,  57,  48,  10,  54,  55,  48,  56,  124, 49,  53,  57,
+    48,  49,  53,  57,  46,  49,  50,  10,  57,  56,  50,  53,  124, 49,  53,
+    56,  57,  52,  48,  51,  46,  57,  50,  10,  56,  50,  55,  49,  124, 49,
+    53,  56,  56,  52,  55,  53,  46,  52,  49,  10,  49,  55,  48,  56,  52,
+    124, 49,  53,  56,  52,  50,  56,  48,  46,  56,  56,  10,  52,  48,  48,
+    51,  124, 49,  53,  56,  51,  54,  51,  49,  46,  48,  48,  10,  56,  54,
+    57,  124, 49,  53,  56,  50,  54,  52,  51,  46,  49,  54,  10,  49,  54,
+    52,  48,  48,  124, 49,  53,  56,  50,  51,  49,  51,  46,  50,  48,  10,
+    49,  57,  48,  56,  56,  124, 49,  53,  56,  49,  55,  48,  56,  46,  53,
+    54,  10,  54,  53,  56,  49,  124, 49,  53,  56,  49,  51,  52,  54,  46,
+    56,  48,  10,  57,  52,  56,  49,  124, 49,  53,  56,  49,  48,  52,  56,
+    46,  54,  48,  10,  54,  48,  57,  50,  124, 49,  53,  56,  48,  56,  52,
+    54,  46,  52,  57,  10,  51,  54,  50,  52,  124, 49,  53,  55,  56,  55,
+    55,  55,  46,  51,  48,  10,  54,  53,  48,  51,  124, 49,  53,  55,  56,
+    53,  48,  55,  46,  55,  56,  10,  49,  52,  53,  53,  55,  124, 49,  53,
+    55,  56,  50,  56,  48,  46,  57,  54,  10,  50,  52,  50,  56,  124, 49,
+    53,  55,  55,  53,  52,  51,  46,  57,  50,  10,  49,  53,  53,  49,  51,
+    124, 49,  53,  55,  51,  53,  54,  48,  46,  50,  49,  10,  52,  54,  52,
+    49,  124, 49,  53,  55,  51,  51,  54,  51,  46,  53,  52,  10,  49,  48,
+    49,  53,  50,  124, 49,  53,  55,  48,  50,  49,  51,  46,  54,  48,  10,
+    53,  57,  51,  50,  124, 49,  53,  54,  54,  57,  48,  50,  46,  53,  50,
+    10,  55,  52,  56,  50,  124, 49,  53,  54,  49,  51,  50,  51,  46,  53,
+    48,  10,  49,  51,  55,  52,  53,  124, 49,  53,  53,  56,  51,  53,  56,
+    46,  51,  52,  10,  50,  50,  53,  49,  124, 49,  53,  53,  56,  50,  55,
+    52,  46,  55,  48,  10,  57,  56,  52,  53,  124, 49,  53,  53,  56,  48,
+    54,  56,  46,  49,  50,  10,  55,  54,  48,  51,  124, 49,  53,  53,  55,
+    51,  56,  56,  46,  50,  48,  10,  49,  56,  48,  57,  124, 49,  53,  53,
+    51,  56,  51,  55,  46,  50,  48,  10,  49,  56,  49,  50,  56,  124, 49,
+    53,  52,  55,  54,  52,  51,  46,  51,  54,  10,  56,  48,  56,  54,  124,
+    49,  53,  52,  51,  49,  57,  57,  46,  48,  52,  10,  49,  52,  57,  52,
+    56,  124, 49,  53,  52,  49,  55,  50,  49,  46,  53,  55,  10,  49,  54,
+    55,  50,  53,  124, 49,  53,  52,  48,  57,  52,  56,  46,  53,  48,  10,
+    50,  57,  57,  57,  124, 49,  53,  52,  48,  51,  49,  55,  46,  54,  54,
+    10,  56,  56,  54,  49,  124, 49,  53,  52,  48,  48,  48,  56,  46,  52,
+    55,  10,  49,  57,  54,  52,  124, 49,  53,  51,  56,  56,  49,  53,  46,
+    50,  53,  10,  49,  57,  51,  55,  52,  124, 49,  53,  51,  55,  56,  56,
+    52,  46,  55,  56,  10,  49,  53,  52,  50,  56,  124, 49,  53,  51,  53,
+    57,  57,  52,  46,  51,  54,  10,  55,  52,  52,  57,  124, 49,  53,  51,
+    52,  55,  56,  50,  46,  52,  56,  10,  49,  54,  56,  56,  52,  124, 49,
+    53,  51,  52,  53,  48,  57,  46,  49,  54,  10,  49,  48,  50,  55,  49,
+    124, 49,  53,  51,  52,  51,  57,  55,  46,  51,  52,  10,  49,  49,  55,
+    56,  50,  124, 49,  53,  50,  57,  57,  54,  51,  46,  50,  50,  10,  56,
+    49,  56,  52,  124, 49,  53,  50,  57,  55,  53,  48,  46,  55,  48,  10,
+    52,  53,  54,  48,  124, 49,  53,  50,  55,  52,  51,  51,  46,  50,  52,
+    10,  52,  54,  49,  54,  124, 49,  53,  50,  53,  51,  55,  52,  46,  52,
+    54,  10,  51,  56,  49,  52,  124, 49,  53,  50,  52,  48,  55,  55,  46,
+    48,  52,  10,  49,  55,  50,  54,  53,  124, 49,  53,  50,  51,  57,  51,
+    50,  46,  48,  56,  10,  49,  54,  53,  50,  48,  124, 49,  53,  50,  50,
+    57,  48,  54,  46,  50,  56,  10,  49,  48,  52,  55,  53,  124, 49,  53,
+    49,  56,  55,  48,  53,  46,  48,  54,  10,  53,  48,  57,  52,  124, 49,
+    53,  49,  55,  51,  49,  55,  46,  56,  51,  10,  56,  54,  50,  54,  124,
+    49,  53,  49,  53,  49,  52,  50,  46,  48,  55,  10,  49,  57,  56,  57,
+    53,  124, 49,  53,  49,  50,  50,  56,  54,  46,  54,  56,  10,  49,  57,
+    57,  51,  51,  124, 49,  53,  48,  54,  50,  51,  53,  46,  51,  54,  10,
+    54,  56,  53,  52,  124, 49,  53,  48,  53,  54,  50,  54,  46,  48,  48,
+    10,  49,  51,  57,  57,  53,  124, 49,  53,  48,  53,  53,  54,  50,  46,
+    49,  56,  10,  55,  49,  48,  50,  124, 49,  53,  48,  52,  57,  52,  53,
+    46,  54,  55,  10,  57,  48,  55,  57,  124, 49,  53,  48,  49,  50,  51,
+    55,  46,  50,  48,  10,  49,  56,  51,  50,  57,  124, 49,  53,  48,  48,
+    49,  52,  54,  46,  57,  48,  10,  51,  55,  52,  50,  124, 49,  52,  57,
+    54,  57,  57,  48,  46,  55,  55,  10,  49,  50,  51,  57,  53,  124, 49,
+    52,  57,  54,  57,  48,  52,  46,  52,  51,  10,  49,  50,  50,  49,  52,
+    124, 49,  52,  57,  54,  52,  56,  57,  46,  52,  48,  10,  49,  50,  50,
+    57,  56,  124, 49,  52,  57,  53,  53,  53,  52,  46,  51,  48,  10,  52,
+    57,  55,  56,  124, 49,  52,  57,  53,  51,  56,  57,  46,  53,  48,  10,
+    50,  57,  50,  55,  124, 49,  52,  57,  52,  50,  56,  48,  46,  49,  48,
+    10,  50,  49,  49,  57,  124, 49,  52,  57,  52,  49,  53,  49,  46,  49,
+    52,  10,  49,  53,  49,  52,  51,  124, 49,  52,  57,  50,  48,  51,  57,
+    46,  55,  53,  10,  49,  52,  53,  52,  56,  124, 49,  52,  56,  55,  52,
+    48,  54,  46,  54,  48,  10,  56,  52,  48,  124, 49,  52,  56,  54,  49,
+    50,  56,  46,  57,  56,  10,  53,  57,  48,  50,  124, 49,  52,  56,  54,
+    48,  57,  55,  46,  50,  56,  10,  49,  48,  54,  49,  52,  124, 49,  52,
+    56,  50,  49,  52,  52,  46,  55,  50,  10,  53,  56,  57,  53,  124, 49,
+    52,  56,  49,  51,  53,  54,  46,  56,  48,  10,  49,  53,  57,  53,  56,
+    124, 49,  52,  56,  48,  57,  53,  49,  46,  54,  48,  10,  49,  49,  52,
+    48,  56,  124, 49,  52,  55,  57,  57,  52,  56,  46,  57,  54,  10,  56,
+    52,  48,  55,  124, 49,  52,  55,  52,  50,  51,  54,  46,  48,  48,  10,
+    54,  50,  52,  51,  124, 49,  52,  55,  49,  48,  48,  55,  46,  56,  53,
+    10,  49,  48,  51,  56,  57,  124, 49,  52,  54,  57,  48,  48,  52,  46,
+    52,  54,  10,  49,  51,  56,  55,  49,  124, 49,  52,  54,  56,  57,  51,
+    56,  46,  54,  52,  10,  49,  57,  56,  49,  49,  124, 49,  52,  54,  52,
+    53,  57,  55,  46,  48,  57,  10,  49,  48,  52,  57,  53,  124, 49,  52,
+    54,  52,  50,  57,  48,  46,  52,  57,  10,  52,  51,  56,  57,  124, 49,
+    52,  54,  51,  48,  49,  48,  46,  56,  51,  10,  49,  51,  49,  49,  124,
+    49,  52,  54,  49,  55,  48,  51,  46,  51,  54,  10,  49,  55,  56,  55,
+    52,  124, 49,  52,  53,  57,  52,  48,  56,  46,  56,  56,  10,  54,  53,
+    57,  55,  124, 49,  52,  53,  56,  55,  54,  49,  46,  56,  55,  10,  49,
+    57,  50,  49,  49,  124, 49,  52,  53,  54,  55,  52,  49,  46,  54,  51,
+    10,  49,  50,  56,  55,  57,  124, 49,  52,  53,  54,  49,  55,  56,  46,
+    50,  52,  10,  56,  56,  52,  48,  124, 49,  52,  53,  53,  55,  51,  49,
+    46,  52,  54,  10,  49,  52,  55,  53,  53,  124, 49,  52,  53,  52,  56,
+    57,  48,  46,  54,  48,  10,  49,  54,  57,  53,  55,  124, 49,  52,  53,
+    52,  52,  54,  53,  46,  57,  54,  10,  57,  50,  53,  55,  124, 49,  52,
+    53,  52,  51,  56,  56,  46,  55,  54,  10,  53,  49,  57,  51,  124, 49,
+    52,  53,  52,  48,  49,  49,  46,  51,  50,  10,  54,  56,  56,  52,  124,
+    49,  52,  53,  50,  52,  55,  52,  46,  54,  48,  10,  49,  57,  57,  52,
+    56,  124, 49,  52,  53,  50,  48,  50,  52,  46,  48,  48,  10,  49,  53,
+    48,  55,  54,  124, 49,  52,  52,  56,  51,  57,  53,  46,  48,  48,  10,
+    49,  54,  48,  49,  54,  124, 49,  52,  52,  55,  53,  53,  55,  46,  52,
+    53,  10,  49,  49,  54,  57,  51,  124, 49,  52,  52,  53,  56,  51,  57,
+    46,  54,  56,  10,  54,  57,  55,  53,  124, 49,  52,  52,  48,  53,  49,
+    54,  46,  57,  54,  10,  52,  50,  57,  48,  124, 49,  52,  51,  57,  55,
+    54,  56,  46,  52,  54,  10,  49,  56,  57,  48,  48,  124, 49,  52,  51,
+    56,  55,  50,  50,  46,  49,  48,  10,  49,  52,  51,  56,  51,  124, 49,
+    52,  51,  56,  52,  55,  55,  46,  57,  50,  10,  49,  53,  48,  57,  56,
+    124, 49,  52,  51,  53,  57,  52,  49,  46,  55,  56,  10,  57,  51,  50,
+    50,  124, 49,  52,  51,  53,  50,  56,  50,  46,  56,  48,  10,  52,  53,
+    56,  124, 49,  52,  51,  51,  48,  52,  48,  46,  52,  53,  10,  49,  48,
+    48,  52,  50,  124, 49,  52,  51,  50,  57,  48,  54,  46,  51,  53,  10,
+    53,  48,  53,  50,  124, 49,  52,  51,  49,  57,  48,  48,  46,  57,  48,
+    10,  54,  54,  48,  48,  124, 49,  52,  51,  49,  49,  49,  54,  46,  53,
+    53,  10,  51,  54,  51,  48,  124, 49,  52,  50,  56,  54,  54,  53,  46,
+    48,  52,  10,  57,  54,  51,  54,  124, 49,  52,  50,  56,  49,  57,  51,
+    46,  56,  52,  10,  49,  54,  53,  49,  49,  124, 49,  52,  50,  55,  51,
+    48,  56,  46,  55,  52,  10,  52,  48,  52,  53,  124, 49,  52,  50,  55,
+    50,  52,  56,  46,  51,  53,  10,  49,  57,  53,  54,  50,  124, 49,  52,
+    50,  54,  51,  52,  56,  46,  56,  50,  10,  56,  56,  49,  52,  124, 49,
+    52,  50,  53,  54,  57,  48,  46,  48,  57,  10,  50,  54,  49,  54,  124,
+    49,  52,  50,  53,  49,  55,  56,  46,  48,  52,  10,  52,  53,  56,  55,
+    124, 49,  52,  50,  53,  49,  48,  57,  46,  52,  48,  10,  49,  52,  56,
+    124, 49,  52,  50,  52,  50,  51,  55,  46,  51,  55,  10,  50,  55,  49,
+    50,  124, 49,  52,  50,  51,  55,  56,  48,  46,  50,  54,  10,  49,  48,
+    56,  54,  51,  124, 49,  52,  50,  51,  51,  56,  54,  46,  49,  54,  10,
+    49,  54,  48,  57,  54,  124, 49,  52,  50,  49,  57,  52,  50,  46,  48,
+    57,  10,  49,  56,  57,  51,  54,  124, 49,  52,  50,  49,  57,  51,  56,
+    46,  54,  53,  10,  49,  56,  51,  50,  55,  124, 49,  52,  49,  57,  56,
+    55,  50,  46,  57,  50,  10,  49,  49,  54,  50,  48,  124, 49,  52,  49,
+    57,  48,  53,  48,  46,  49,  48,  10,  51,  55,  52,  48,  124, 49,  52,
+    49,  56,  54,  48,  57,  46,  56,  53,  10,  51,  52,  53,  55,  124, 49,
+    52,  49,  56,  54,  48,  51,  46,  53,  48,  10,  49,  49,  56,  53,  124,
+    49,  52,  49,  55,  54,  51,  55,  46,  52,  55,  10,  56,  49,  55,  56,
+    124, 49,  52,  49,  55,  51,  53,  55,  46,  50,  54,  10,  49,  55,  55,
+    57,  49,  124, 49,  52,  49,  51,  50,  57,  51,  46,  49,  51,  10,  49,
+    51,  54,  48,  56,  124, 49,  52,  49,  49,  51,  50,  51,  46,  49,  50,
+    10,  49,  55,  56,  52,  57,  124, 49,  52,  48,  57,  54,  49,  51,  46,
+    53,  48,  10,  54,  56,  49,  52,  124, 49,  52,  48,  54,  50,  50,  56,
+    46,  52,  48,  10,  49,  52,  48,  50,  50,  124, 49,  52,  48,  54,  49,
+    51,  56,  46,  48,  52,  10,  49,  52,  50,  51,  49,  124, 49,  52,  48,
+    51,  55,  55,  49,  46,  53,  50,  10,  49,  57,  53,  52,  54,  124, 49,
+    52,  48,  50,  56,  53,  52,  46,  54,  48,  10,  49,  57,  54,  49,  57,
+    124, 49,  52,  48,  50,  51,  56,  57,  46,  49,  54,  10,  53,  54,  48,
+    57,  124, 49,  52,  48,  50,  51,  48,  50,  46,  53,  52,  10,  53,  51,
+    52,  50,  124, 49,  52,  48,  49,  53,  54,  55,  46,  53,  57,  10,  51,
+    48,  56,  52,  124, 49,  52,  48,  49,  48,  57,  54,  46,  49,  48,  10,
+    53,  55,  48,  56,  124, 49,  52,  48,  48,  51,  51,  52,  46,  57,  48,
+    10,  49,  55,  57,  57,  56,  124, 49,  51,  57,  57,  56,  54,  50,  46,
+    52,  53,  10,  49,  57,  56,  53,  48,  124, 49,  51,  57,  55,  54,  51,
+    48,  46,  51,  51,  10,  49,  52,  48,  48,  52,  124, 49,  51,  57,  53,
+    52,  52,  51,  46,  49,  48,  10,  49,  51,  48,  55,  49,  124, 49,  51,
+    57,  52,  54,  53,  51,  46,  50,  52,  10,  50,  55,  57,  55,  124, 49,
+    51,  57,  51,  55,  52,  55,  46,  53,  56,  10,  50,  56,  54,  54,  124,
+    49,  51,  57,  50,  57,  52,  55,  46,  50,  53,  10,  49,  57,  56,  48,
+    57,  124, 49,  51,  56,  57,  48,  54,  55,  46,  54,  56,  10,  49,  51,
+    54,  48,  48,  124, 49,  51,  56,  48,  56,  54,  53,  46,  56,  48,  10,
+    49,  51,  54,  49,  52,  124, 49,  51,  56,  48,  54,  53,  52,  46,  51,
+    54,  10,  53,  56,  56,  52,  124, 49,  51,  56,  48,  51,  49,  57,  46,
+    55,  52,  10,  57,  52,  48,  52,  124, 49,  51,  55,  56,  54,  50,  51,
+    46,  54,  54,  10,  49,  48,  54,  53,  54,  124, 49,  51,  55,  54,  57,
+    53,  52,  46,  51,  50,  10,  49,  50,  51,  50,  52,  124, 49,  51,  55,
+    54,  53,  48,  50,  46,  52,  48,  10,  55,  51,  50,  53,  124, 49,  51,
+    55,  53,  48,  51,  48,  46,  52,  51,  10,  49,  51,  50,  57,  53,  124,
+    49,  51,  55,  51,  57,  56,  55,  46,  51,  52,  10,  49,  49,  56,  54,
+    52,  124, 49,  51,  55,  51,  53,  53,  53,  46,  54,  56,  10,  54,  57,
+    56,  55,  124, 49,  51,  55,  51,  52,  56,  49,  46,  53,  49,  10,  56,
+    51,  56,  54,  124, 49,  51,  55,  49,  56,  53,  52,  46,  52,  49,  10,
+    49,  48,  57,  49,  54,  124, 49,  51,  55,  48,  51,  55,  52,  46,  51,
+    50,  10,  49,  50,  56,  54,  55,  124, 49,  51,  54,  57,  48,  53,  56,
+    46,  49,  49,  10,  49,  52,  54,  54,  56,  124, 49,  51,  54,  57,  48,
+    52,  48,  46,  51,  52,  10,  49,  51,  51,  56,  51,  124, 49,  51,  54,
+    55,  51,  52,  50,  46,  51,  48,  10,  49,  56,  53,  55,  50,  124, 49,
+    51,  54,  54,  57,  53,  51,  46,  57,  54,  10,  49,  49,  53,  50,  124,
+    49,  51,  54,  54,  56,  54,  49,  46,  51,  56,  10,  54,  48,  49,  53,
+    124, 49,  51,  54,  54,  52,  53,  50,  46,  49,  56,  10,  51,  51,  52,
+    52,  124, 49,  51,  54,  54,  49,  56,  53,  46,  49,  53,  10,  55,  56,
+    56,  57,  124, 49,  51,  54,  53,  53,  50,  49,  46,  57,  50,  10,  49,
+    51,  51,  52,  53,  124, 49,  51,  54,  52,  48,  56,  56,  46,  56,  56,
+    10,  54,  50,  55,  54,  124, 49,  51,  54,  51,  52,  50,  49,  46,  54,
+    50,  10,  56,  48,  54,  57,  124, 49,  51,  54,  49,  56,  50,  52,  46,
+    50,  48,  10,  49,  55,  53,  48,  57,  124, 49,  51,  54,  48,  56,  57,
+    50,  46,  52,  57,  10,  49,  53,  49,  51,  55,  124, 49,  51,  53,  56,
+    54,  55,  56,  46,  48,  55,  10,  49,  55,  49,  54,  51,  124, 49,  51,
+    53,  55,  51,  57,  49,  46,  53,  50,  10,  52,  55,  48,  52,  124, 49,
+    51,  53,  54,  54,  57,  50,  46,  52,  48,  10,  56,  54,  48,  57,  124,
+    49,  51,  53,  54,  53,  55,  56,  46,  49,  57,  10,  49,  50,  54,  52,
+    52,  124, 49,  51,  53,  54,  48,  56,  56,  46,  49,  52,  10,  49,  55,
+    49,  52,  49,  124, 49,  51,  53,  54,  48,  50,  50,  46,  51,  56,  10,
+    49,  49,  56,  48,  53,  124, 49,  51,  53,  52,  56,  50,  54,  46,  55,
+    56,  10,  54,  51,  56,  54,  124, 49,  51,  53,  52,  49,  56,  55,  46,
+    50,  50,  10,  51,  48,  48,  52,  124, 49,  51,  53,  50,  49,  55,  51,
+    46,  52,  52,  10,  56,  54,  51,  52,  124, 49,  51,  53,  48,  50,  49,
+    49,  46,  56,  48,  10,  52,  51,  57,  57,  124, 49,  51,  52,  57,  56,
+    56,  49,  46,  50,  48,  10,  49,  48,  51,  54,  50,  124, 49,  51,  52,
+    57,  52,  49,  49,  46,  51,  52,  10,  49,  53,  55,  50,  124, 49,  51,
+    52,  56,  56,  51,  53,  46,  50,  48,  10,  55,  51,  53,  57,  124, 49,
+    51,  52,  56,  50,  50,  52,  46,  49,  48,  10,  49,  49,  56,  56,  52,
+    124, 49,  51,  52,  54,  54,  57,  54,  46,  56,  50,  10,  49,  49,  54,
+    55,  49,  124, 49,  51,  52,  54,  52,  50,  52,  46,  49,  53,  10,  53,
+    51,  53,  48,  124, 49,  51,  52,  54,  51,  53,  57,  46,  50,  56,  10,
+    51,  49,  49,  57,  124, 49,  51,  52,  53,  57,  57,  54,  46,  52,  56,
+    10,  53,  51,  48,  55,  124, 49,  51,  52,  53,  51,  53,  54,  46,  48,
+    48,  10,  49,  54,  49,  49,  55,  124, 49,  51,  52,  53,  48,  52,  53,
+    46,  49,  50,  10,  56,  55,  49,  53,  124, 49,  51,  52,  50,  54,  54,
+    53,  46,  55,  50,  10,  53,  51,  57,  56,  124, 49,  51,  52,  49,  49,
+    55,  57,  46,  50,  56,  10,  55,  54,  50,  55,  124, 49,  51,  51,  56,
+    56,  50,  48,  46,  53,  54,  10,  56,  52,  53,  55,  124, 49,  51,  51,
+    55,  55,  49,  52,  46,  54,  56,  10,  52,  57,  53,  56,  124, 49,  51,
+    51,  52,  55,  51,  50,  46,  55,  49,  10,  56,  52,  124, 49,  51,  51,
+    52,  49,  52,  54,  46,  55,  49,  10,  54,  57,  51,  50,  124, 49,  51,
+    51,  51,  50,  51,  53,  46,  51,  54,  10,  55,  53,  55,  124, 49,  51,
+    51,  50,  57,  50,  49,  46,  48,  55,  10,  52,  48,  55,  54,  124, 49,
+    51,  51,  50,  52,  52,  49,  46,  48,  48,  10,  49,  55,  53,  49,  124,
+    49,  51,  50,  57,  49,  49,  50,  46,  51,  50,  10,  49,  53,  55,  48,
+    49,  124, 49,  51,  50,  55,  48,  53,  50,  46,  49,  54,  10,  52,  49,
+    49,  57,  124, 49,  51,  50,  54,  53,  52,  57,  46,  57,  48,  10,  49,
+    53,  54,  50,  124, 49,  51,  50,  53,  54,  48,  52,  46,  50,  56,  10,
+    56,  55,  52,  49,  124, 49,  51,  50,  53,  53,  49,  55,  46,  54,  48,
+    10,  49,  49,  51,  53,  124, 49,  51,  50,  53,  52,  50,  50,  46,  55,
+    49,  10,  49,  48,  48,  50,  124, 49,  51,  50,  51,  52,  49,  56,  46,
+    54,  53,  10,  53,  56,  51,  50,  124, 49,  51,  50,  51,  48,  56,  53,
+    46,  55,  49,  10,  53,  51,  54,  56,  124, 49,  51,  50,  50,  55,  57,
+    51,  46,  57,  54,  10,  53,  51,  56,  50,  124, 49,  51,  50,  50,  54,
+    50,  56,  46,  56,  52,  10,  53,  54,  49,  54,  124, 49,  51,  49,  57,
+    48,  56,  50,  46,  50,  54,  10,  50,  56,  51,  50,  124, 49,  51,  49,
+    56,  54,  57,  49,  46,  57,  53,  10,  51,  56,  57,  53,  124, 49,  51,
+    49,  55,  56,  53,  56,  46,  52,  52,  10,  56,  54,  50,  57,  124, 49,
+    51,  49,  55,  55,  53,  54,  46,  53,  49,  10,  53,  55,  48,  57,  124,
+    49,  51,  49,  55,  48,  53,  56,  46,  54,  56,  10,  49,  56,  51,  56,
+    51,  124, 49,  51,  49,  54,  52,  53,  49,  46,  48,  53,  10,  49,  53,
+    55,  57,  55,  124, 49,  51,  49,  52,  56,  48,  54,  46,  54,  52,  10,
+    49,  57,  48,  48,  124, 49,  51,  49,  51,  54,  54,  48,  46,  52,  48,
+    10,  49,  51,  56,  56,  50,  124, 49,  51,  49,  48,  52,  53,  53,  46,
+    56,  54,  10,  54,  55,  56,  53,  124, 49,  51,  48,  57,  56,  55,  55,
+    46,  56,  48,  10,  49,  52,  56,  53,  53,  124, 49,  51,  48,  57,  50,
+    56,  48,  46,  55,  54,  10,  55,  55,  54,  49,  124, 49,  51,  48,  56,
+    54,  48,  50,  46,  50,  52,  10,  49,  52,  50,  54,  56,  124, 49,  51,
+    48,  54,  56,  49,  48,  46,  52,  48,  10,  54,  50,  53,  55,  124, 49,
+    51,  48,  54,  48,  53,  54,  46,  57,  54,  10,  49,  57,  48,  48,  50,
+    124, 49,  51,  48,  53,  53,  48,  57,  46,  53,  50,  10,  53,  48,  57,
+    53,  124, 49,  51,  48,  51,  55,  50,  57,  46,  48,  50,  10,  49,  48,
+    51,  50,  48,  124, 49,  51,  48,  49,  54,  53,  55,  46,  53,  56,  10,
+    55,  56,  50,  54,  124, 49,  50,  57,  57,  53,  54,  49,  46,  54,  56,
+    10,  49,  51,  51,  53,  57,  124, 49,  50,  57,  56,  55,  49,  55,  46,
+    49,  52,  10,  55,  52,  51,  54,  124, 49,  50,  57,  56,  49,  50,  55,
+    46,  51,  54,  10,  53,  54,  52,  52,  124, 49,  50,  57,  53,  48,  53,
+    53,  46,  55,  55,  10,  49,  49,  51,  50,  55,  124, 49,  50,  57,  48,
+    53,  50,  54,  46,  52,  49,  10,  53,  50,  55,  55,  124, 49,  50,  56,
+    57,  51,  50,  57,  46,  54,  53,  10,  49,  53,  57,  51,  50,  124, 49,
+    50,  56,  54,  50,  51,  53,  46,  56,  52,  10,  49,  52,  51,  50,  50,
+    124, 49,  50,  56,  52,  56,  48,  57,  46,  51,  54,  10,  49,  52,  52,
+    124, 49,  50,  56,  52,  50,  55,  48,  46,  49,  50,  10,  51,  48,  52,
+    51,  124, 49,  50,  56,  49,  49,  54,  50,  46,  55,  57,  10,  49,  54,
+    55,  56,  56,  124, 49,  50,  56,  48,  57,  53,  53,  46,  51,  52,  10,
+    49,  55,  49,  51,  54,  124, 49,  50,  56,  48,  52,  52,  51,  46,  49,
+    50,  10,  49,  50,  53,  54,  48,  124, 49,  50,  55,  57,  49,  49,  55,
+    46,  57,  53,  10,  49,  51,  56,  51,  51,  124, 49,  50,  55,  56,  56,
+    51,  52,  46,  55,  53,  10,  53,  52,  49,  52,  124, 49,  50,  55,  55,
+    56,  57,  51,  46,  50,  54,  10,  49,  50,  53,  56,  50,  124, 49,  50,
+    55,  55,  53,  57,  50,  46,  51,  50,  10,  52,  54,  52,  52,  124, 49,
+    50,  55,  55,  53,  51,  53,  46,  48,  48,  10,  49,  52,  48,  51,  50,
+    124, 49,  50,  55,  55,  48,  55,  55,  46,  56,  56,  10,  49,  56,  51,
+    50,  53,  124, 49,  50,  55,  49,  55,  49,  57,  46,  54,  56,  10,  55,
+    48,  55,  50,  124, 49,  50,  55,  49,  50,  50,  56,  46,  52,  56,  10,
+    49,  54,  56,  54,  56,  124, 49,  50,  54,  55,  52,  54,  57,  46,  52,
+    50,  10,  56,  49,  51,  55,  124, 49,  50,  54,  55,  52,  50,  53,  46,
+    56,  49,  10,  53,  57,  55,  54,  124, 49,  50,  54,  54,  50,  48,  54,
+    46,  56,  53,  10,  49,  52,  49,  50,  53,  124, 49,  50,  54,  53,  53,
+    54,  57,  46,  48,  53,  10,  49,  51,  50,  57,  57,  124, 49,  50,  54,
+    53,  50,  56,  55,  46,  53,  53,  10,  49,  56,  51,  55,  54,  124, 49,
+    50,  54,  52,  50,  52,  57,  46,  51,  48,  10,  54,  49,  53,  55,  124,
+    49,  50,  54,  49,  55,  53,  57,  46,  57,  50,  10,  53,  48,  48,  50,
+    124, 49,  50,  54,  49,  54,  54,  57,  46,  54,  52,  10,  49,  51,  51,
+    54,  56,  124, 49,  50,  54,  48,  57,  49,  56,  46,  54,  48,  10,  49,
+    53,  53,  56,  57,  124, 49,  50,  54,  48,  48,  53,  57,  46,  55,  54,
+    10,  50,  49,  52,  57,  124, 49,  50,  53,  56,  57,  56,  49,  46,  52,
+    52,  10,  57,  54,  51,  57,  124, 49,  50,  53,  54,  50,  56,  51,  46,
+    51,  56,  10,  49,  49,  54,  56,  57,  124, 49,  50,  53,  54,  48,  50,
+    55,  46,  57,  50,  10,  57,  48,  56,  51,  124, 49,  50,  52,  53,  57,
+    50,  52,  46,  50,  52,  10,  49,  54,  50,  51,  49,  124, 49,  50,  52,
+    50,  54,  50,  53,  46,  54,  53,  10,  53,  48,  56,  52,  124, 49,  50,
+    52,  50,  51,  56,  53,  46,  50,  56,  10,  49,  49,  54,  51,  52,  124,
+    49,  50,  52,  48,  55,  54,  48,  46,  49,  56,  10,  49,  53,  54,  49,
+    55,  124, 49,  50,  51,  57,  55,  51,  49,  46,  50,  53,  10,  57,  56,
+    54,  53,  124, 49,  50,  51,  55,  49,  56,  49,  46,  54,  50,  10,  49,
+    52,  50,  49,  50,  124, 49,  50,  51,  54,  51,  54,  53,  46,  53,  50,
+    10,  49,  48,  51,  50,  53,  124, 49,  50,  51,  53,  50,  50,  51,  46,
+    51,  54,  10,  49,  57,  53,  56,  50,  124, 49,  50,  51,  53,  49,  48,
+    53,  46,  55,  54,  10,  55,  52,  48,  124, 49,  50,  51,  52,  55,  52,
+    54,  46,  56,  49,  10,  49,  57,  50,  51,  49,  124, 49,  50,  51,  51,
+    54,  50,  51,  46,  49,  48,  10,  49,  54,  56,  52,  48,  124, 49,  50,
+    51,  51,  48,  54,  51,  46,  56,  53,  10,  53,  55,  48,  51,  124, 49,
+    50,  51,  49,  55,  52,  52,  46,  51,  51,  10,  53,  55,  54,  49,  124,
+    49,  50,  50,  57,  52,  51,  53,  46,  50,  48,  10,  49,  53,  54,  51,
+    48,  124, 49,  50,  50,  54,  54,  49,  49,  46,  54,  50,  10,  49,  48,
+    52,  48,  56,  124, 49,  50,  50,  52,  54,  57,  56,  46,  52,  48,  10,
+    57,  49,  55,  55,  124, 49,  50,  50,  49,  57,  52,  50,  46,  53,  49,
+    10,  49,  51,  51,  56,  57,  124, 49,  50,  50,  49,  54,  54,  54,  46,
+    55,  53,  10,  54,  49,  48,  52,  124, 49,  50,  50,  49,  53,  55,  55,
+    46,  57,  50,  10,  57,  54,  55,  51,  124, 49,  50,  49,  56,  56,  50,
+    54,  46,  54,  52,  10,  50,  55,  48,  55,  124, 49,  50,  49,  55,  49,
+    50,  52,  46,  52,  56,  10,  49,  56,  54,  55,  50,  124, 49,  50,  49,
+    52,  50,  48,  56,  46,  56,  48,  10,  53,  49,  49,  50,  124, 49,  50,
+    48,  57,  53,  57,  48,  46,  50,  48,  10,  54,  50,  54,  52,  124, 49,
+    50,  48,  56,  51,  49,  56,  46,  53,  48,  10,  49,  56,  52,  57,  54,
+    124, 49,  50,  48,  55,  56,  56,  49,  46,  55,  53,  10,  49,  48,  57,
+    55,  49,  124, 49,  50,  48,  55,  49,  56,  51,  46,  53,  50,  10,  49,
+    57,  48,  53,  57,  124, 49,  50,  48,  54,  55,  50,  57,  46,  57,  48,
+    10,  52,  51,  49,  124, 49,  50,  48,  53,  57,  51,  56,  46,  52,  52,
+    10,  51,  56,  50,  49,  124, 49,  50,  48,  49,  49,  57,  50,  46,  55,
+    53,  10,  56,  50,  54,  124, 49,  50,  48,  48,  52,  53,  52,  46,  54,
+    50,  10,  51,  51,  49,  55,  124, 49,  50,  48,  48,  52,  52,  48,  46,
+    57,  48,  10,  49,  57,  54,  56,  57,  124, 49,  49,  57,  56,  56,  57,
+    57,  46,  53,  50,  10,  49,  57,  54,  52,  49,  124, 49,  49,  57,  56,
+    55,  57,  55,  46,  57,  57,  10,  54,  51,  55,  57,  124, 49,  49,  57,
+    55,  49,  57,  53,  46,  53,  48,  10,  56,  49,  52,  124, 49,  49,  57,
+    52,  52,  49,  55,  46,  52,  48,  10,  49,  56,  54,  52,  51,  124, 49,
+    49,  57,  52,  48,  48,  48,  46,  55,  56,  10,  49,  49,  56,  54,  53,
+    124, 49,  49,  57,  51,  57,  54,  53,  46,  55,  54,  10,  49,  50,  51,
+    57,  51,  124, 49,  49,  57,  51,  56,  57,  54,  46,  56,  48,  10,  57,
+    50,  49,  56,  124, 49,  49,  57,  51,  54,  54,  48,  46,  53,  56,  10,
+    56,  54,  55,  52,  124, 49,  49,  57,  49,  56,  56,  49,  46,  51,  50,
+    10,  56,  53,  56,  50,  124, 49,  49,  57,  49,  56,  48,  52,  46,  48,
+    50,  10,  49,  51,  48,  56,  52,  124, 49,  49,  57,  49,  53,  48,  56,
+    46,  48,  48,  10,  49,  56,  56,  52,  52,  124, 49,  49,  57,  48,  50,
+    51,  57,  46,  57,  54,  10,  49,  54,  48,  54,  49,  124, 49,  49,  56,
+    57,  57,  51,  53,  46,  48,  48,  10,  54,  49,  51,  52,  124, 49,  49,
+    56,  53,  53,  53,  48,  46,  56,  48,  10,  56,  54,  50,  56,  124, 49,
+    49,  56,  51,  50,  52,  53,  46,  54,  48,  10,  56,  56,  56,  52,  124,
+    49,  49,  56,  49,  53,  52,  55,  46,  52,  56,  10,  55,  54,  57,  55,
+    124, 49,  49,  56,  49,  48,  51,  50,  46,  53,  48,  10,  57,  48,  52,
+    52,  124, 49,  49,  56,  48,  57,  50,  50,  46,  54,  48,  10,  49,  51,
+    50,  53,  55,  124, 49,  49,  56,  48,  49,  53,  56,  46,  53,  55,  10,
+    56,  48,  54,  54,  124, 49,  49,  55,  56,  56,  48,  56,  46,  49,  50,
+    10,  53,  56,  55,  54,  124, 49,  49,  55,  55,  51,  55,  54,  46,  56,
+    48,  10,  49,  52,  54,  57,  52,  124, 49,  49,  55,  55,  48,  53,  57,
+    46,  51,  49,  10,  49,  54,  48,  54,  50,  124, 49,  49,  55,  53,  51,
+    57,  49,  46,  48,  48,  10,  57,  49,  48,  52,  124, 49,  49,  55,  53,
+    49,  55,  56,  46,  57,  48,  10,  49,  49,  54,  48,  48,  124, 49,  49,
+    55,  53,  48,  57,  49,  46,  48,  54,  10,  49,  48,  51,  51,  55,  124,
+    49,  49,  55,  50,  54,  56,  52,  46,  57,  50,  10,  49,  57,  49,  56,
+    56,  124, 49,  49,  55,  50,  51,  52,  57,  46,  55,  56,  10,  56,  56,
+    51,  51,  124, 49,  49,  55,  49,  51,  55,  50,  46,  57,  51,  10,  54,
+    56,  57,  53,  124, 49,  49,  55,  48,  54,  48,  50,  46,  48,  55,  10,
+    49,  52,  49,  48,  48,  124, 49,  49,  54,  56,  56,  55,  56,  46,  52,
+    48,  10,  49,  51,  53,  51,  56,  124, 49,  49,  54,  56,  53,  53,  52,
+    46,  50,  56,  10,  51,  52,  48,  56,  124, 49,  49,  54,  54,  54,  52,
+    53,  46,  49,  54,  10,  49,  56,  54,  48,  124, 49,  49,  54,  53,  54,
+    55,  51,  46,  54,  56,  10,  49,  51,  52,  51,  54,  124, 49,  49,  54,
+    52,  50,  55,  56,  46,  55,  48,  10,  49,  57,  51,  50,  53,  124, 49,
+    49,  54,  50,  55,  51,  51,  46,  55,  48,  10,  55,  52,  48,  51,  124,
+    49,  49,  54,  49,  57,  56,  50,  46,  48,  48,  10,  52,  56,  56,  50,
+    124, 49,  49,  54,  49,  52,  48,  52,  46,  56,  49,  10,  49,  51,  49,
+    48,  53,  124, 49,  49,  54,  49,  51,  50,  48,  46,  53,  56,  10,  49,
+    55,  56,  56,  48,  124, 49,  49,  54,  49,  50,  53,  54,  46,  48,  50,
+    10,  49,  57,  50,  56,  52,  124, 49,  49,  54,  48,  57,  50,  55,  46,
+    54,  48,  10,  49,  51,  52,  55,  54,  124, 49,  49,  53,  57,  48,  51,
+    53,  46,  49,  53,  10,  49,  56,  57,  49,  51,  124, 49,  49,  53,  56,
+    50,  48,  56,  46,  51,  48,  10,  49,  56,  53,  50,  51,  124, 49,  49,
+    53,  56,  49,  51,  53,  46,  48,  48,  10,  49,  50,  53,  48,  56,  124,
+    49,  49,  53,  55,  53,  51,  56,  46,  52,  53,  10,  57,  48,  57,  48,
+    124, 49,  49,  53,  54,  51,  54,  50,  46,  54,  52,  10,  49,  55,  54,
+    53,  51,  124, 49,  49,  53,  52,  51,  51,  56,  46,  48,  56,  10,  51,
+    57,  50,  54,  124, 49,  49,  53,  50,  54,  53,  50,  46,  53,  50,  10,
+    49,  48,  49,  56,  51,  124, 49,  49,  52,  56,  51,  50,  52,  46,  53,
+    55,  10,  55,  53,  53,  54,  124, 49,  49,  52,  54,  50,  54,  56,  46,
+    49,  52,  10,  49,  54,  52,  51,  54,  124, 49,  49,  52,  50,  54,  53,
+    54,  46,  52,  55,  10,  52,  55,  52,  49,  124, 49,  49,  52,  49,  54,
+    49,  52,  46,  48,  48,  10,  49,  53,  54,  53,  49,  124, 49,  49,  52,
+    49,  52,  57,  55,  46,  57,  51,  10,  51,  49,  56,  51,  124, 49,  49,
+    52,  48,  48,  56,  49,  46,  51,  54,  10,  57,  53,  51,  50,  124, 49,
+    49,  51,  57,  57,  48,  50,  46,  53,  48,  10,  49,  54,  52,  48,  51,
+    124, 49,  49,  51,  57,  51,  48,  54,  46,  51,  55,  10,  50,  51,  54,
+    56,  124, 49,  49,  51,  55,  52,  50,  49,  46,  49,  54,  10,  51,  56,
+    56,  57,  124, 49,  49,  51,  54,  51,  57,  53,  46,  53,  48,  10,  50,
+    56,  56,  53,  124, 49,  49,  51,  53,  56,  51,  56,  46,  49,  52,  10,
+    55,  56,  53,  49,  124, 49,  49,  51,  53,  49,  49,  48,  46,  55,  54,
+    10,  49,  54,  50,  51,  52,  124, 49,  49,  51,  53,  48,  49,  55,  46,
+    50,  52,  10,  49,  50,  55,  52,  54,  124, 49,  49,  51,  52,  53,  51,
+    49,  46,  48,  52,  10,  50,  54,  52,  55,  124, 49,  49,  51,  50,  57,
+    52,  49,  46,  49,  50,  10,  53,  51,  55,  51,  124, 49,  49,  51,  50,
+    49,  53,  56,  46,  48,  49,  10,  49,  48,  51,  52,  48,  124, 49,  49,
+    51,  50,  48,  48,  52,  46,  50,  52,  10,  56,  56,  55,  51,  124, 49,
+    49,  51,  49,  57,  52,  57,  46,  50,  56,  10,  49,  49,  51,  50,  124,
+    49,  49,  51,  49,  51,  51,  56,  46,  56,  56,  10,  49,  53,  53,  57,
+    52,  124, 49,  49,  51,  49,  51,  50,  56,  46,  54,  50,  10,  52,  51,
+    55,  54,  124, 49,  49,  51,  48,  50,  56,  50,  46,  50,  48,  10,  50,
+    52,  48,  124, 49,  49,  50,  54,  54,  56,  50,  46,  52,  56,  10,  50,
+    50,  51,  49,  124, 49,  49,  50,  52,  52,  52,  55,  46,  49,  53,  10,
+    57,  50,  57,  124, 49,  49,  50,  49,  51,  56,  51,  46,  57,  50,  10,
+    49,  49,  53,  57,  57,  124, 49,  49,  49,  57,  51,  48,  55,  46,  50,
+    55,  10,  51,  55,  54,  53,  124, 49,  49,  49,  57,  48,  57,  51,  46,
+    53,  48,  10,  49,  55,  54,  51,  53,  124, 49,  49,  49,  56,  52,  50,
+    48,  46,  49,  54,  10,  55,  49,  49,  57,  124, 49,  49,  49,  56,  50,
+    56,  53,  46,  48,  56,  10,  49,  53,  49,  50,  49,  124, 49,  49,  49,
+    55,  55,  49,  53,  46,  51,  52,  10,  49,  49,  56,  53,  56,  124, 49,
+    49,  49,  54,  57,  54,  51,  46,  53,  52,  10,  49,  54,  57,  54,  51,
+    124, 49,  49,  49,  54,  57,  50,  57,  46,  52,  53,  10,  49,  54,  51,
+    53,  54,  124, 49,  49,  49,  51,  54,  52,  56,  46,  57,  56,  10,  54,
+    57,  50,  52,  124, 49,  49,  49,  50,  49,  57,  56,  46,  52,  48,  10,
+    49,  54,  50,  50,  51,  124, 49,  49,  49,  49,  50,  53,  55,  46,  48,
+    48,  10,  49,  56,  48,  57,  49,  124, 49,  49,  49,  48,  48,  52,  51,
+    46,  48,  50,  10,  49,  50,  54,  50,  56,  124, 49,  49,  48,  56,  57,
+    53,  52,  46,  56,  48,  10,  49,  54,  48,  52,  51,  124, 49,  49,  48,
+    56,  56,  51,  49,  46,  48,  53,  10,  57,  52,  48,  50,  124, 49,  49,
+    48,  56,  50,  57,  48,  46,  52,  56,  10,  55,  48,  56,  124, 49,  49,
+    48,  55,  48,  56,  52,  46,  48,  48,  10,  52,  48,  55,  56,  124, 49,
+    49,  48,  53,  57,  57,  51,  46,  57,  54,  10,  49,  55,  53,  57,  51,
+    124, 49,  49,  48,  52,  55,  49,  51,  46,  52,  48,  10,  49,  50,  55,
+    55,  54,  124, 49,  49,  48,  52,  51,  54,  50,  46,  53,  57,  10,  55,
+    53,  56,  51,  124, 49,  49,  48,  50,  56,  49,  51,  46,  53,  51,  10,
+    49,  52,  54,  49,  57,  124, 49,  49,  48,  50,  54,  55,  53,  46,  56,
+    48,  10,  56,  56,  52,  50,  124, 49,  49,  48,  48,  49,  49,  48,  46,
+    50,  54,  10,  52,  49,  57,  54,  124, 49,  48,  57,  57,  55,  50,  54,
+    46,  53,  53,  10,  50,  48,  49,  57,  124, 49,  48,  57,  56,  49,  55,
+    56,  46,  54,  52,  10,  54,  56,  54,  51,  124, 49,  48,  57,  55,  50,
+    52,  54,  46,  51,  54,  10,  54,  52,  56,  57,  124, 49,  48,  57,  54,
+    53,  48,  51,  46,  48,  55,  10,  50,  52,  53,  57,  124, 49,  48,  57,
+    52,  56,  49,  51,  46,  48,  52,  10,  49,  49,  57,  54,  52,  124, 49,
+    48,  57,  52,  52,  56,  53,  46,  48,  50,  10,  51,  50,  51,  54,  124,
+    49,  48,  57,  51,  57,  54,  57,  46,  56,  48,  10,  49,  55,  54,  52,
+    55,  124, 49,  48,  57,  51,  56,  48,  57,  46,  49,  53,  10,  49,  55,
+    54,  52,  56,  124, 49,  48,  57,  51,  49,  49,  52,  46,  54,  50,  10,
+    49,  49,  57,  124, 49,  48,  57,  50,  54,  56,  55,  46,  52,  56,  10,
+    57,  54,  50,  54,  124, 49,  48,  57,  50,  48,  56,  48,  46,  48,  48,
+    10,  57,  49,  50,  52,  124, 49,  48,  57,  49,  53,  54,  57,  46,  54,
+    56,  10,  49,  51,  49,  55,  53,  124, 49,  48,  56,  57,  56,  53,  49,
+    46,  55,  54,  10,  50,  53,  51,  50,  124, 49,  48,  56,  56,  55,  48,
+    54,  46,  51,  53,  10,  49,  54,  48,  56,  51,  124, 49,  48,  56,  56,
+    50,  57,  53,  46,  51,  57,  10,  56,  56,  55,  52,  124, 49,  48,  56,
+    54,  48,  49,  49,  46,  51,  52,  10,  49,  50,  56,  55,  50,  124, 49,
+    48,  56,  50,  57,  55,  48,  46,  51,  48,  10,  49,  57,  56,  50,  49,
+    124, 49,  48,  56,  50,  53,  50,  48,  46,  56,  52,  10,  52,  56,  48,
+    48,  124, 49,  48,  56,  48,  51,  56,  57,  46,  55,  48,  10,  49,  56,
+    54,  57,  54,  124, 49,  48,  55,  57,  54,  56,  53,  46,  51,  54,  10,
+    49,  57,  53,  52,  53,  124, 49,  48,  55,  57,  49,  56,  52,  46,  51,
+    51,  10,  49,  51,  49,  50,  48,  124, 49,  48,  55,  55,  55,  52,  50,
+    46,  50,  56,  10,  49,  48,  53,  56,  56,  124, 49,  48,  55,  54,  50,
+    48,  51,  46,  56,  51,  10,  49,  55,  54,  57,  54,  124, 49,  48,  55,
+    53,  48,  57,  50,  46,  55,  50,  10,  49,  52,  54,  53,  49,  124, 49,
+    48,  55,  51,  50,  50,  50,  46,  50,  51,  10,  57,  48,  51,  124, 49,
+    48,  55,  49,  49,  52,  54,  46,  55,  54,  10,  53,  56,  53,  56,  124,
+    49,  48,  55,  48,  50,  53,  57,  46,  52,  56,  10,  56,  51,  48,  50,
+    124, 49,  48,  54,  57,  53,  48,  52,  46,  56,  48,  10,  49,  56,  55,
+    50,  56,  124, 49,  48,  54,  57,  50,  50,  53,  46,  53,  49,  10,  49,
+    56,  48,  50,  54,  124, 49,  48,  54,  56,  53,  54,  57,  46,  48,  48,
+    10,  49,  57,  51,  56,  51,  124, 49,  48,  54,  54,  57,  48,  55,  46,
+    53,  56,  10,  49,  56,  54,  57,  48,  124, 49,  48,  54,  53,  57,  51,
+    48,  46,  57,  48,  10,  53,  57,  50,  52,  124, 49,  48,  54,  53,  49,
+    52,  51,  46,  49,  50,  10,  52,  56,  56,  48,  124, 49,  48,  54,  53,
+    48,  49,  49,  46,  55,  53,  10,  49,  50,  52,  51,  57,  124, 49,  48,
+    54,  52,  51,  56,  49,  46,  49,  57,  10,  49,  54,  53,  50,  57,  124,
+    49,  48,  54,  50,  51,  55,  49,  46,  55,  48,  10,  49,  57,  54,  53,
+    51,  124, 49,  48,  53,  55,  54,  56,  51,  46,  53,  54,  10,  51,  49,
+    51,  54,  124, 49,  48,  53,  54,  56,  49,  48,  46,  52,  52,  10,  49,
+    56,  57,  51,  50,  124, 49,  48,  53,  54,  49,  57,  51,  46,  54,  53,
+    10,  50,  49,  50,  52,  124, 49,  48,  53,  52,  49,  54,  48,  46,  53,
+    50,  10,  49,  54,  56,  53,  49,  124, 49,  48,  53,  50,  54,  52,  54,
+    46,  56,  52,  10,  49,  48,  49,  50,  51,  124, 49,  48,  53,  49,  54,
+    50,  52,  46,  48,  48,  10,  53,  54,  49,  56,  124, 49,  48,  52,  56,
+    52,  52,  55,  46,  57,  51,  10,  49,  57,  56,  53,  49,  124, 49,  48,
+    52,  53,  49,  56,  55,  46,  56,  53,  10,  49,  54,  50,  55,  56,  124,
+    49,  48,  52,  52,  56,  48,  56,  46,  51,  56,  10,  49,  49,  52,  55,
+    57,  124, 49,  48,  52,  52,  50,  55,  54,  46,  50,  50,  10,  49,  51,
+    50,  54,  51,  124, 49,  48,  52,  50,  48,  52,  54,  46,  50,  48,  10,
+    54,  48,  52,  49,  124, 49,  48,  52,  49,  49,  50,  51,  46,  51,  56,
+    10,  55,  49,  57,  51,  124, 49,  48,  52,  48,  52,  53,  53,  46,  51,
+    50,  10,  49,  57,  52,  48,  56,  124, 49,  48,  51,  57,  52,  51,  48,
+    46,  48,  49,  10,  49,  49,  50,  54,  48,  124, 49,  48,  51,  54,  56,
+    50,  56,  46,  53,  50,  10,  53,  49,  55,  57,  124, 49,  48,  51,  53,
+    54,  51,  51,  46,  52,  52,  10,  49,  51,  51,  49,  124, 49,  48,  51,
+    52,  51,  57,  56,  46,  48,  48,  10,  55,  55,  48,  54,  124, 49,  48,
+    51,  52,  50,  52,  57,  46,  52,  48,  10,  56,  52,  51,  54,  124, 49,
+    48,  51,  51,  53,  52,  57,  46,  51,  53,  10,  49,  56,  48,  49,  124,
+    49,  48,  51,  49,  56,  56,  54,  46,  48,  48,  10,  52,  49,  55,  48,
+    124, 49,  48,  51,  49,  54,  52,  50,  46,  57,  48,  10,  49,  49,  56,
+    50,  55,  124, 49,  48,  51,  49,  49,  51,  57,  46,  51,  57,  10,  49,
+    55,  49,  49,  52,  124, 49,  48,  50,  55,  57,  56,  53,  46,  56,  56,
+    10,  49,  56,  50,  55,  56,  124, 49,  48,  50,  54,  53,  56,  51,  46,
+    49,  49,  10,  49,  57,  57,  53,  124, 49,  48,  50,  53,  49,  54,  53,
+    46,  54,  56,  10,  55,  54,  54,  55,  124, 49,  48,  50,  50,  57,  56,
+    48,  46,  49,  53,  10,  54,  53,  53,  57,  124, 49,  48,  50,  49,  54,
+    51,  53,  46,  52,  53,  10,  49,  55,  52,  56,  56,  124, 49,  48,  50,
+    49,  54,  49,  50,  46,  49,  51,  10,  49,  54,  48,  53,  57,  124, 49,
+    48,  49,  57,  55,  56,  49,  46,  49,  57,  10,  55,  54,  51,  51,  124,
+    49,  48,  49,  56,  55,  56,  50,  46,  53,  55,  10,  49,  48,  48,  51,
+    50,  124, 49,  48,  49,  54,  56,  48,  57,  46,  53,  48,  10,  50,  56,
+    57,  57,  124, 49,  48,  49,  54,  52,  51,  56,  46,  55,  54,  10,  49,
+    52,  54,  50,  56,  124, 49,  48,  49,  54,  48,  51,  51,  46,  50,  48,
+    10,  49,  48,  49,  50,  54,  124, 49,  48,  49,  53,  56,  52,  54,  46,
+    55,  56,  10,  51,  56,  56,  52,  124, 49,  48,  49,  52,  52,  49,  51,
+    46,  53,  48,  10,  49,  54,  57,  49,  51,  124, 49,  48,  49,  51,  54,
+    48,  52,  46,  52,  48,  10,  49,  56,  54,  52,  52,  124, 49,  48,  49,
+    48,  50,  56,  56,  46,  49,  48,  10,  49,  57,  56,  55,  48,  124, 49,
+    48,  48,  55,  57,  49,  57,  46,  51,  54,  10,  49,  56,  53,  54,  52,
+    124, 49,  48,  48,  55,  52,  49,  54,  46,  50,  48,  10,  49,  48,  49,
+    55,  57,  124, 49,  48,  48,  52,  57,  50,  48,  46,  48,  48,  10,  56,
+    56,  51,  124, 49,  48,  48,  52,  54,  53,  48,  46,  54,  56,  10,  51,
+    54,  50,  55,  124, 49,  48,  48,  52,  52,  54,  49,  46,  48,  52,  10,
+    0};
+const uint8_t TPCH_ANSWERS_SF0_1_q12[] = {
+    108, 95,  115, 104, 105, 112, 109, 111, 100, 101, 124, 104, 105, 103,
+    104, 95,  108, 105, 110, 101, 95,  99,  111, 117, 110, 116, 124, 108,
+    111, 119, 95,  108, 105, 110, 101, 95,  99,  111, 117, 110, 116, 10,
+    77,  65,  73,  76,  124, 54,  52,  55,  124, 57,  52,  53,  10,  83,
+    72,  73,  80,  124, 54,  50,  48,  124, 57,  52,  51,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q13[] = {
+    99,  95,  99,  111, 117, 110, 116, 124, 99,  117, 115, 116, 100, 105, 115,
+    116, 10,  48,  124, 53,  48,  48,  48,  10,  49,  48,  124, 54,  54,  53,
+    10,  57,  124, 54,  53,  55,  10,  49,  49,  124, 54,  50,  49,  10,  49,
+    50,  124, 53,  54,  55,  10,  56,  124, 53,  54,  52,  10,  49,  51,  124,
+    52,  57,  50,  10,  49,  56,  124, 52,  56,  50,  10,  55,  124, 52,  56,
+    48,  10,  50,  48,  124, 52,  53,  54,  10,  49,  52,  124, 52,  53,  54,
+    10,  49,  54,  124, 52,  52,  57,  10,  49,  57,  124, 52,  52,  55,  10,
+    49,  53,  124, 52,  51,  50,  10,  49,  55,  124, 52,  50,  51,  10,  50,
+    49,  124, 52,  49,  50,  10,  50,  50,  124, 51,  55,  49,  10,  54,  124,
+    51,  51,  55,  10,  50,  51,  124, 51,  50,  51,  10,  50,  52,  124, 50,
+    53,  54,  10,  50,  53,  124, 50,  48,  52,  10,  53,  124, 50,  48,  52,
+    10,  50,  54,  124, 49,  53,  53,  10,  50,  55,  124, 49,  52,  49,  10,
+    50,  56,  124, 57,  55,  10,  52,  124, 57,  52,  10,  50,  57,  124, 54,
+    52,  10,  51,  124, 52,  56,  10,  51,  48,  124, 50,  55,  10,  51,  49,
+    124, 50,  54,  10,  51,  50,  124, 49,  52,  10,  51,  51,  124, 49,  49,
+    10,  50,  124, 49,  49,  10,  51,  52,  124, 54,  10,  51,  53,  124, 53,
+    10,  49,  124, 50,  10,  51,  54,  124, 49,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q14[] = {
+    112, 114, 111, 109, 111, 95, 114, 101, 118, 101, 110, 117,
+    101, 10,  49,  54,  46,  50, 56,  51,  56,  53,  53,  54,
+    56,  57,  48,  48,  53,  57, 55,  57,  53,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q15[] = {
+    115, 95,  115, 117, 112, 112, 107, 101, 121, 124, 115, 95,  110, 97,
+    109, 101, 124, 115, 95,  97,  100, 100, 114, 101, 115, 115, 124, 115,
+    95,  112, 104, 111, 110, 101, 124, 116, 111, 116, 97,  108, 95,  114,
+    101, 118, 101, 110, 117, 101, 10,  54,  55,  55,  124, 83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  54,  55,
+    55,  124, 84,  69,  74,  32,  76,  77,  107, 84,  110, 89,  53,  104,
+    112, 56,  97,  81,  99,  107, 122, 121, 98,  124, 50,  51,  45,  50,
+    57,  48,  45,  54,  51,  57,  45,  51,  51,  49,  53,  124, 49,  54,
+    49,  52,  52,  49,  48,  46,  50,  57,  50,  56,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q16[] = {
+    112, 95,  98,  114, 97,  110, 100, 124, 112, 95,  116, 121, 112, 101, 124,
+    112, 95,  115, 105, 122, 101, 124, 115, 117, 112, 112, 108, 105, 101, 114,
+    95,  99,  110, 116, 10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 55,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 55,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 55,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    55,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 51,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 51,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 51,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 51,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 51,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 51,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 51,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    51,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q17[] = {
+    97, 118, 103, 95, 121, 101, 97, 114, 108, 121, 10, 50, 51, 53, 49, 50,
+    46, 55,  53,  50, 56,  53,  55, 49,  52,  50,  56, 53, 55, 10, 0};
+const uint8_t TPCH_ANSWERS_SF0_1_q18[] = {
+    99,  95,  110, 97,  109, 101, 124, 99,  95,  99,  117, 115, 116, 107, 101,
+    121, 124, 111, 95,  111, 114, 100, 101, 114, 107, 101, 121, 124, 111, 95,
+    111, 114, 100, 101, 114, 100, 97,  116, 101, 124, 111, 95,  116, 111, 116,
+    97,  108, 112, 114, 105, 99,  101, 124, 115, 117, 109, 10,  67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  49,  54,  51,  57,
+    124, 49,  54,  51,  57,  124, 53,  48,  50,  56,  56,  54,  124, 49,  57,
+    57,  52,  45,  48,  52,  45,  49,  50,  124, 52,  53,  54,  52,  50,  51,
+    46,  56,  56,  124, 51,  49,  50,  10,  67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  48,  54,  54,  53,  53,  124, 54,  54,  53,
+    53,  124, 50,  57,  49,  53,  56,  124, 49,  57,  57,  53,  45,  49,  48,
+    45,  50,  49,  124, 52,  53,  50,  56,  48,  53,  46,  48,  50,  124, 51,
+    48,  53,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  49,  52,  49,  49,  48,  124, 49,  52,  49,  49,  48,  124, 53,  54,
+    53,  53,  55,  52,  124, 49,  57,  57,  53,  45,  48,  57,  45,  50,  52,
+    124, 52,  50,  53,  48,  57,  57,  46,  56,  53,  124, 51,  48,  49,  10,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  49,
+    55,  55,  53,  124, 49,  55,  55,  53,  124, 54,  56,  56,  50,  124, 49,
+    57,  57,  55,  45,  48,  52,  45,  48,  57,  124, 52,  48,  56,  51,  54,
+    56,  46,  49,  48,  124, 51,  48,  51,  10,  67,  117, 115, 116, 111, 109,
+    101, 114, 35,  48,  48,  48,  48,  49,  49,  52,  53,  57,  124, 49,  49,
+    52,  53,  57,  124, 53,  53,  49,  49,  51,  54,  124, 49,  57,  57,  51,
+    45,  48,  53,  45,  49,  57,  124, 51,  56,  54,  56,  49,  50,  46,  55,
+    52,  124, 51,  48,  56,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q19[] = {114, 101, 118, 101, 110, 117, 101,
+                                          10,  49,  54,  56,  53,  57,  55,
+                                          46,  50,  56,  54,  48,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q20[] = {
+    115, 95,  110, 97,  109, 101, 124, 115, 95,  97,  100, 100, 114, 101, 115,
+    115, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  49,  53,  55,  124, 49,  69,  109, 107, 67,  65,  112, 76,  53,
+    105, 70,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  49,  57,  55,  124, 51,  111, 89,  113, 79,  68,  68,  85,
+    71,  72,  51,  88,  115, 72,  88,  109, 80,  117, 122, 89,  72,  87,  53,
+    78,  76,  85,  51,  44,  79,  78,  90,  108, 10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  50,  56,  55,  124, 85,
+    81,  82,  56,  98,  85,  65,  52,  86,  50,  72,  120, 86,  98,  119, 57,
+    75,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  51,  55,  56,  124, 109, 76,  80,  74,  116, 112, 117, 52,  119,
+    79,  99,  32,  99,  83,  70,  122, 66,  82,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  53,  51,  48,  124, 48,
+    66,  118, 111, 101, 119, 67,  80,  103, 50,  115, 99,  79,  69,  102, 117,
+    76,  57,  51,  70,  82,  75,  113, 83,  120, 72,  109, 100, 104, 119, 49,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    48,  53,  53,  53,  124, 56,  76,  112, 48,  81,  87,  80,  76,  70,  88,
+    114, 74,  114, 88,  49,  115, 84,  87,  107, 65,  69,  100, 122, 85,  115,
+    104, 53,  107, 101, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  53,  53,  55,  124, 73,  72,  44,  118, 54,  51,
+    74,  82,  103, 88,  77,  107, 86,  104, 74,  79,  74,  32,  71,  120, 117,
+    114, 48,  87,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  55,  50,  57,  124, 67,  65,  79,  71,  89,  67,  66,
+    116, 84,  86,  84,  55,  97,  66,  49,  112, 54,  113, 72,  98,  120, 70,
+    54,  86,  86,  104, 88,  97,  72,  76,  103, 84,  112, 73,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  57,  51,
+    53,  124, 74,  72,  82,  83,  79,  116, 101, 114, 89,  103, 116, 52,  77,
+    84,  78,  111, 55,  99,  117, 112, 84,  122, 65,  44,  54,  77,  111, 78,
+    119, 32,  52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q21[] = {
+    115, 95,  110, 97,  109, 101, 124, 110, 117, 109, 119, 97,  105, 116, 10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    52,  52,  53,  124, 49,  54,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  48,  56,  50,  53,  124, 49,  54,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  55,
+    48,  57,  124, 49,  53,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  55,  54,  50,  124, 49,  53,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  51,  53,
+    55,  124, 49,  52,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  51,  57,  57,  124, 49,  52,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  52,  57,  54,
+    124, 49,  52,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  57,  55,  55,  124, 49,  51,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  49,  52,  52,  124,
+    49,  50,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  49,  56,  56,  124, 49,  50,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  52,  49,  53,  124, 49,
+    50,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  52,  55,  50,  124, 49,  50,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  54,  51,  51,  124, 49,  50,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    48,  55,  48,  56,  124, 49,  50,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  56,  56,  57,  124, 49,  50,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    51,  56,  48,  124, 49,  49,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  48,  54,  48,  50,  124, 49,  49,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  54,
+    53,  57,  124, 49,  49,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  56,  50,  49,  124, 49,  49,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  57,  50,
+    57,  124, 49,  49,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  50,  54,  50,  124, 49,  48,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  52,  54,  48,
+    124, 49,  48,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  52,  56,  54,  124, 49,  48,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  54,  54,  57,  124,
+    49,  48,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  55,  49,  56,  124, 49,  48,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  55,  55,  56,  124, 49,
+    48,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  49,  54,  55,  124, 57,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  53,  55,  56,  124, 57,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  54,
+    55,  51,  124, 57,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  54,  56,  55,  124, 57,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  48,  55,  52,  124,
+    56,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  53,  54,  53,  124, 56,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  54,  52,  56,  124, 56,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  57,
+    49,  56,  124, 56,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  52,  50,  55,  124, 55,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  53,  48,  51,  124,
+    55,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  54,  49,  48,  124, 55,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  54,  55,  48,  124, 55,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  56,
+    49,  49,  124, 55,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  49,  49,  52,  124, 54,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  51,  55,  57,  124,
+    54,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  52,  51,  54,  124, 54,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  53,  48,  48,  124, 54,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  54,
+    54,  48,  124, 54,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  55,  56,  56,  124, 54,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  56,  52,  54,  124,
+    54,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  57,  50,  48,  124, 52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF0_1_q22[] = {
+    99,  110, 116, 114, 121, 99,  111, 100, 101, 124, 110, 117, 109, 99, 117,
+    115, 116, 124, 116, 111, 116, 97,  99,  99,  116, 98,  97,  108, 10, 49,
+    51,  124, 57,  52,  124, 55,  49,  52,  48,  51,  53,  46,  48,  53, 10,
+    49,  55,  124, 57,  54,  124, 55,  50,  50,  53,  54,  48,  46,  49, 53,
+    10,  49,  56,  124, 57,  57,  124, 55,  51,  56,  48,  49,  50,  46, 53,
+    50,  10,  50,  51,  124, 57,  51,  124, 55,  48,  56,  50,  56,  53, 46,
+    50,  53,  10,  50,  57,  124, 56,  53,  124, 54,  51,  50,  54,  57, 51,
+    46,  52,  54,  10,  51,  48,  124, 56,  55,  124, 54,  52,  54,  55, 52,
+    56,  46,  48,  50,  10,  51,  49,  124, 56,  55,  124, 54,  52,  55, 51,
+    55,  50,  46,  53,  48,  10,  0};
+const char* TPCH_ANSWERS_SF0_1[] = {
+    (const char*)TPCH_ANSWERS_SF0_1_q01, (const char*)TPCH_ANSWERS_SF0_1_q02,
+    (const char*)TPCH_ANSWERS_SF0_1_q03, (const char*)TPCH_ANSWERS_SF0_1_q04,
+    (const char*)TPCH_ANSWERS_SF0_1_q05, (const char*)TPCH_ANSWERS_SF0_1_q06,
+    (const char*)TPCH_ANSWERS_SF0_1_q07, (const char*)TPCH_ANSWERS_SF0_1_q08,
+    (const char*)TPCH_ANSWERS_SF0_1_q09, (const char*)TPCH_ANSWERS_SF0_1_q10,
+    (const char*)TPCH_ANSWERS_SF0_1_q11, (const char*)TPCH_ANSWERS_SF0_1_q12,
+    (const char*)TPCH_ANSWERS_SF0_1_q13, (const char*)TPCH_ANSWERS_SF0_1_q14,
+    (const char*)TPCH_ANSWERS_SF0_1_q15, (const char*)TPCH_ANSWERS_SF0_1_q16,
+    (const char*)TPCH_ANSWERS_SF0_1_q17, (const char*)TPCH_ANSWERS_SF0_1_q18,
+    (const char*)TPCH_ANSWERS_SF0_1_q19, (const char*)TPCH_ANSWERS_SF0_1_q20,
+    (const char*)TPCH_ANSWERS_SF0_1_q21, (const char*)TPCH_ANSWERS_SF0_1_q22};
+const uint8_t TPCH_ANSWERS_SF1_q01[] = {
+    108, 95,  114, 101, 116, 117, 114, 110, 102, 108, 97,  103, 124, 108, 95,
+    108, 105, 110, 101, 115, 116, 97,  116, 117, 115, 124, 115, 117, 109, 95,
+    113, 116, 121, 124, 115, 117, 109, 95,  98,  97,  115, 101, 95,  112, 114,
+    105, 99,  101, 124, 115, 117, 109, 95,  100, 105, 115, 99,  95,  112, 114,
+    105, 99,  101, 124, 115, 117, 109, 95,  99,  104, 97,  114, 103, 101, 124,
+    97,  118, 103, 95,  113, 116, 121, 124, 97,  118, 103, 95,  112, 114, 105,
+    99,  101, 124, 97,  118, 103, 95,  100, 105, 115, 99,  124, 99,  111, 117,
+    110, 116, 95,  111, 114, 100, 101, 114, 10,  65,  124, 70,  124, 51,  55,
+    55,  51,  52,  49,  48,  55,  124, 53,  54,  53,  56,  54,  53,  53,  52,
+    52,  48,  48,  46,  55,  51,  124, 53,  51,  55,  53,  56,  50,  53,  55,
+    49,  51,  52,  46,  56,  55,  48,  48,  124, 53,  53,  57,  48,  57,  48,
+    54,  53,  50,  50,  50,  46,  56,  50,  55,  54,  57,  50,  124, 50,  53,
+    46,  53,  50,  50,  48,  124, 51,  56,  50,  55,  51,  46,  49,  50,  57,
+    55,  124, 48,  46,  48,  53,  48,  48,  124, 49,  52,  55,  56,  52,  57,
+    51,  10,  78,  124, 70,  124, 57,  57,  49,  52,  49,  55,  124, 49,  52,
+    56,  55,  53,  48,  52,  55,  49,  48,  46,  51,  56,  124, 49,  52,  49,
+    51,  48,  56,  50,  49,  54,  56,  46,  48,  53,  52,  49,  124, 49,  52,
+    54,  57,  54,  52,  57,  50,  50,  51,  46,  49,  57,  52,  51,  55,  53,
+    124, 50,  53,  46,  53,  49,  54,  53,  124, 51,  56,  50,  56,  52,  46,
+    52,  54,  55,  56,  124, 48,  46,  48,  53,  48,  49,  124, 51,  56,  56,
+    53,  52,  10,  78,  124, 79,  124, 55,  52,  52,  55,  54,  48,  52,  48,
+    124, 49,  49,  49,  55,  48,  49,  55,  50,  57,  54,  57,  55,  46,  55,
+    52,  124, 49,  48,  54,  49,  49,  56,  50,  51,  48,  51,  48,  55,  46,
+    54,  48,  53,  54,  124, 49,  49,  48,  51,  54,  55,  48,  52,  51,  56,
+    55,  50,  46,  52,  57,  55,  48,  49,  48,  124, 50,  53,  46,  53,  48,
+    50,  50,  124, 51,  56,  50,  52,  57,  46,  49,  49,  56,  48,  124, 48,
+    46,  48,  53,  48,  48,  124, 50,  57,  50,  48,  51,  55,  52,  10,  82,
+    124, 70,  124, 51,  55,  55,  49,  57,  55,  53,  51,  124, 53,  54,  53,
+    54,  56,  48,  52,  49,  51,  56,  48,  46,  57,  48,  124, 53,  51,  55,
+    52,  49,  50,  57,  50,  54,  56,  52,  46,  54,  48,  52,  48,  124, 53,
+    53,  56,  56,  57,  54,  49,  57,  49,  49,  57,  46,  56,  51,  49,  57,
+    51,  50,  124, 50,  53,  46,  53,  48,  53,  56,  124, 51,  56,  50,  53,
+    48,  46,  56,  53,  52,  54,  124, 48,  46,  48,  53,  48,  48,  124, 49,
+    52,  55,  56,  56,  55,  48,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q02[] = {
+    115, 95,  97,  99,  99,  116, 98,  97,  108, 124, 115, 95,  110, 97,  109,
+    101, 124, 110, 95,  110, 97,  109, 101, 124, 112, 95,  112, 97,  114, 116,
+    107, 101, 121, 124, 112, 95,  109, 102, 103, 114, 124, 115, 95,  97,  100,
+    100, 114, 101, 115, 115, 124, 115, 95,  112, 104, 111, 110, 101, 124, 115,
+    95,  99,  111, 109, 109, 101, 110, 116, 10,  57,  57,  51,  56,  46,  53,
+    51,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  53,  51,  53,  57,  124, 85,  78,  73,  84,  69,  68,  32,  75,  73,
+    78,  71,  68,  79,  77,  124, 49,  56,  53,  51,  53,  56,  124, 77,  97,
+    110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 98,  103,
+    120, 106, 50,  75,  48,  119, 49,  107, 74,  118, 120, 89,  108, 53,  109,
+    104, 67,  102, 111, 117, 44,  87,  124, 51,  51,  45,  52,  50,  57,  45,
+    55,  57,  48,  45,  54,  49,  51,  49,  124, 117, 114, 105, 111, 117, 115,
+    108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  114, 101, 113, 117,
+    101, 115, 116, 115, 32,  104, 97,  103, 10,  57,  57,  51,  55,  46,  56,
+    52,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  53,  57,  54,  57,  124, 82,  79,  77,  65,  78,  73,  65,  124, 49,
+    48,  56,  52,  51,  56,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  49,  124, 114, 100, 110, 109, 100, 57,  99,  56,  69,
+    71,  49,  69,  73,  65,  89,  89,  51,  76,  80,  86,  97,  52,  121, 85,
+    78,  120, 54,  79,  119, 121, 86,  97,  81,  124, 50,  57,  45,  53,  50,
+    48,  45,  54,  57,  50,  45,  51,  53,  51,  55,  124, 101, 102, 117, 108,
+    108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  105, 110, 115, 116,
+    114, 117, 99,  116, 105, 111, 110, 115, 46,  32,  114, 101, 103, 117, 108,
+    97,  114, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  97,  103, 97,
+    105, 110, 115, 116, 32,  116, 104, 101, 32,  115, 108, 121, 108, 121, 32,
+    102, 105, 110, 10,  57,  57,  51,  54,  46,  50,  50,  124, 83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  50,  53,  48,
+    124, 85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,
+    124, 50,  52,  57,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114,
+    101, 114, 35,  52,  124, 113, 88,  32,  65,  66,  48,  118, 80,  56,  109,
+    74,  69,  87,  101, 66,  117, 89,  57,  106, 114, 105, 124, 51,  51,  45,
+    51,  50,  48,  45,  50,  50,  56,  45,  50,  57,  53,  55,  124, 101, 116,
+    101, 99,  116, 32,  97,  98,  111, 117, 116, 32,  116, 104, 101, 32,  102,
+    117, 114, 105, 111, 117, 115, 108, 121, 32,  102, 105, 110, 97,  108, 32,
+    97,  99,  99,  111, 117, 110, 116, 115, 46,  32,  115, 108, 121, 108, 121,
+    32,  105, 114, 111, 110, 105, 99,  32,  112, 105, 110, 116, 111, 32,  98,
+    101, 97,  110, 115, 32,  115, 108, 101, 101, 112, 32,  105, 110, 115, 105,
+    100, 101, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108,
+    121, 10,  57,  57,  50,  51,  46,  55,  55,  124, 83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  51,  50,  52,  124, 71,
+    69,  82,  77,  65,  78,  89,  124, 50,  57,  56,  50,  49,  124, 77,  97,
+    110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 117, 88,
+    99,  110, 82,  55,  116, 118, 56,  55,  100, 71,  124, 49,  55,  45,  55,
+    55,  57,  45,  50,  57,  57,  45,  49,  56,  51,  57,  124, 97,  99,  107,
+    97,  103, 101, 115, 32,  98,  111, 111, 115, 116, 32,  98,  108, 105, 116,
+    104, 101, 108, 121, 46,  32,  98,  108, 105, 116, 104, 101, 108, 121, 32,
+    114, 101, 103, 117, 108, 97,  114, 32,  100, 101, 112, 111, 115, 105, 116,
+    115, 32,  99,  10,  57,  56,  55,  49,  46,  50,  50,  124, 83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,  51,  55,  51,
+    124, 71,  69,  82,  77,  65,  78,  89,  124, 52,  51,  56,  54,  56,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124,
+    105, 83,  76,  79,  51,  53,  122, 55,  65,  101, 124, 49,  55,  45,  56,
+    49,  51,  45,  52,  56,  53,  45,  56,  54,  51,  55,  124, 101, 116, 101,
+    99,  116, 32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  98,  111, 108,
+    100, 32,  97,  115, 121, 109, 112, 116, 111, 116, 101, 115, 46,  32,  102,
+    108, 117, 102, 102, 105, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,
+    112, 108, 97,  116, 101, 108, 101, 116, 115, 32,  119, 97,  107, 101, 32,
+    102, 117, 114, 105, 111, 117, 115, 108, 121, 59,  32,  98,  108, 105, 116,
+    10,  57,  56,  55,  48,  46,  55,  56,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  49,  50,  56,  54,  124, 71,  69,
+    82,  77,  65,  78,  89,  124, 56,  49,  50,  56,  53,  124, 77,  97,  110,
+    117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  50,  124, 51,  103, 113,
+    48,  109, 90,  76,  72,  73,  53,  79,  84,  77,  54,  32,  116, 66,  89,
+    109, 76,  84,  72,  90,  97,  117, 108, 67,  89,  110, 108, 69,  67,  122,
+    81,  55,  110, 106, 124, 49,  55,  45,  53,  49,  54,  45,  57,  50,  52,
+    45,  52,  53,  55,  52,  124, 32,  114, 101, 103, 117, 108, 97,  114, 32,
+    97,  99,  99,  111, 117, 110, 116, 115, 46,  32,  102, 117, 114, 105, 111,
+    117, 115, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108, 32,  99,  111,
+    117, 114, 116, 115, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101, 32,
+    102, 105, 10,  57,  56,  55,  48,  46,  55,  56,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  50,  56,  54,  124,
+    71,  69,  82,  77,  65,  78,  89,  124, 49,  56,  49,  50,  56,  53,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124,
+    51,  103, 113, 48,  109, 90,  76,  72,  73,  53,  79,  84,  77,  54,  32,
+    116, 66,  89,  109, 76,  84,  72,  90,  97,  117, 108, 67,  89,  110, 108,
+    69,  67,  122, 81,  55,  110, 106, 124, 49,  55,  45,  53,  49,  54,  45,
+    57,  50,  52,  45,  52,  53,  55,  52,  124, 32,  114, 101, 103, 117, 108,
+    97,  114, 32,  97,  99,  99,  111, 117, 110, 116, 115, 46,  32,  102, 117,
+    114, 105, 111, 117, 115, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108,
+    32,  99,  111, 117, 114, 116, 115, 32,  97,  98,  111, 118, 101, 32,  116,
+    104, 101, 32,  102, 105, 10,  57,  56,  53,  50,  46,  53,  50,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  57,
+    55,  51,  124, 82,  85,  83,  83,  73,  65,  124, 49,  56,  57,  55,  50,
+    124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  50,
+    124, 122, 86,  102, 85,  84,  51,  78,  112, 50,  50,  107, 85,  67,  48,
+    53,  116, 89,  87,  72,  66,  111, 116, 97,  82,  124, 51,  50,  45,  49,
+    56,  56,  45,  53,  57,  52,  45,  55,  48,  51,  56,  124, 114, 110, 115,
+    32,  119, 97,  107, 101, 32,  102, 105, 110, 97,  108, 32,  102, 111, 120,
+    101, 115, 46,  32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  117,
+    110, 117, 115, 117, 97,  108, 32,  100, 101, 112, 101, 110, 100, 101, 10,
+    57,  56,  52,  55,  46,  56,  51,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  56,  48,  57,  55,  124, 82,  85,  83,
+    83,  73,  65,  124, 49,  51,  48,  53,  53,  55,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  50,  124, 118, 101, 77,  82,
+    84,  81,  66,  109, 85,  82,  101, 115, 78,  118, 102, 68,  51,  124, 51,
+    50,  45,  51,  55,  53,  45,  54,  52,  48,  45,  51,  53,  57,  51,  124,
+    32,  116, 104, 101, 32,  115, 112, 101, 99,  105, 97,  108, 32,  101, 120,
+    99,  117, 115, 101, 115, 46,  32,  115, 105, 108, 101, 110, 116, 32,  115,
+    101, 110, 116, 105, 109, 101, 110, 116, 115, 32,  115, 101, 114, 118, 101,
+    32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  102, 105, 110, 97,
+    108, 32,  97,  99,  10,  57,  56,  52,  55,  46,  53,  55,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,  51,  52,
+    53,  124, 70,  82,  65,  78,  67,  69,  124, 56,  54,  51,  52,  52,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  49,  124,
+    54,  56,  121, 88,  32,  116, 71,  88,  65,  107, 86,  82,  83,  120, 85,
+    71,  78,  83,  106, 74,  100, 112, 116, 119, 32,  56,  79,  56,  55,  56,
+    120, 97,  70,  110, 97,  111, 81,  75,  124, 49,  54,  45,  56,  56,  54,
+    45,  55,  54,  54,  45,  55,  57,  52,  53,  124, 103, 101, 115, 46,  32,
+    115, 108, 121, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  114,
+    101, 113, 117, 101, 115, 116, 115, 32,  97,  114, 101, 46,  32,  114, 117,
+    116, 104, 108, 101, 115, 115, 44,  32,  101, 120, 112, 114, 101, 115, 115,
+    32,  101, 120, 99,  117, 115, 101, 115, 32,  99,  97,  106, 111, 108, 101,
+    32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  97,  99,  114, 111, 115,
+    115, 32,  116, 104, 101, 32,  117, 110, 117, 10,  57,  56,  52,  55,  46,
+    53,  55,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  54,  51,  52,  53,  124, 70,  82,  65,  78,  67,  69,  124, 49,
+    55,  51,  56,  50,  55,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  50,  124, 54,  56,  121, 88,  32,  116, 71,  88,  65,
+    107, 86,  82,  83,  120, 85,  71,  78,  83,  106, 74,  100, 112, 116, 119,
+    32,  56,  79,  56,  55,  56,  120, 97,  70,  110, 97,  111, 81,  75,  124,
+    49,  54,  45,  56,  56,  54,  45,  55,  54,  54,  45,  55,  57,  52,  53,
+    124, 103, 101, 115, 46,  32,  115, 108, 121, 108, 121, 32,  114, 101, 103,
+    117, 108, 97,  114, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  97,
+    114, 101, 46,  32,  114, 117, 116, 104, 108, 101, 115, 115, 44,  32,  101,
+    120, 112, 114, 101, 115, 115, 32,  101, 120, 99,  117, 115, 101, 115, 32,
+    99,  97,  106, 111, 108, 101, 32,  98,  108, 105, 116, 104, 101, 108, 121,
+    32,  97,  99,  114, 111, 115, 115, 32,  116, 104, 101, 32,  117, 110, 117,
+    10,  57,  56,  51,  54,  46,  57,  51,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  55,  51,  52,  50,  124, 82,  85,
+    83,  83,  73,  65,  124, 52,  56,  52,  49,  124, 77,  97,  110, 117, 102,
+    97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 105, 99,  70,  103, 84,
+    112, 90,  48,  84,  117, 65,  109, 49,  56,  56,  100, 118, 124, 51,  50,
+    45,  51,  57,  57,  45,  52,  49,  52,  45,  53,  51,  56,  53,  124, 98,
+    108, 105, 116, 104, 101, 108, 121, 32,  99,  97,  114, 101, 102, 117, 108,
+    108, 121, 32,  98,  111, 108, 100, 32,  116, 104, 101, 111, 100, 111, 108,
+    105, 116, 101, 115, 46,  32,  102, 117, 114, 10,  57,  56,  49,  55,  46,
+    49,  48,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  50,  51,  53,  50,  124, 82,  85,  83,  83,  73,  65,  124, 49,
+    50,  52,  56,  49,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  50,  124, 88,  102, 76,  67,  106, 55,  49,  72,  75,
+    72,  110, 80,  113, 103, 118, 115, 55,  75,  78,  103, 80,  75,  99,  79,
+    87,  111, 87,  120, 111, 50,  119, 124, 51,  50,  45,  53,  53,  49,  45,
+    56,  51,  49,  45,  49,  52,  51,  55,  124, 119, 97,  107, 101, 32,  99,
+    97,  114, 101, 102, 117, 108, 108, 121, 32,  97,  108, 111, 110, 103, 115,
+    105, 100, 101, 32,  111, 102, 32,  116, 104, 101, 32,  99,  97,  114, 101,
+    102, 117, 108, 108, 121, 32,  102, 105, 110, 97,  108, 32,  101, 120, 10,
+    57,  56,  49,  55,  46,  49,  48,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  50,  51,  53,  50,  124, 82,  85,  83,
+    83,  73,  65,  124, 49,  53,  50,  51,  53,  49,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  51,  124, 88,  102, 76,  67,
+    106, 55,  49,  72,  75,  72,  110, 80,  113, 103, 118, 115, 55,  75,  78,
+    103, 80,  75,  99,  79,  87,  111, 87,  120, 111, 50,  119, 124, 51,  50,
+    45,  53,  53,  49,  45,  56,  51,  49,  45,  49,  52,  51,  55,  124, 119,
+    97,  107, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  97,
+    108, 111, 110, 103, 115, 105, 100, 101, 32,  111, 102, 32,  116, 104, 101,
+    32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  102, 105, 110, 97,
+    108, 32,  101, 120, 10,  57,  55,  51,  57,  46,  56,  54,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  51,  56,
+    52,  124, 70,  82,  65,  78,  67,  69,  124, 49,  51,  56,  51,  53,  55,
+    124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  50,
+    124, 68,  48,  49,  88,  119, 88,  98,  99,  73,  76,  78,  119, 109, 114,
+    71,  83,  54,  90,  80,  114, 86,  104, 90,  120, 79,  52,  48,  105, 124,
+    49,  54,  45,  52,  57,  52,  45,  57,  49,  51,  45,  53,  57,  50,  53,
+    124, 115, 32,  97,  102, 116, 101, 114, 32,  116, 104, 101, 32,  102, 117,
+    114, 105, 111, 117, 115, 108, 121, 32,  98,  111, 108, 100, 32,  112, 97,
+    99,  107, 97,  103, 101, 115, 32,  115, 108, 101, 101, 112, 32,  102, 108,
+    117, 102, 102, 105, 108, 121, 32,  105, 100, 108, 121, 32,  102, 105, 110,
+    97,  108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 58,  32,  113, 117,
+    105, 99,  107, 108, 121, 32,  102, 105, 110, 97,  108, 10,  57,  55,  50,
+    49,  46,  57,  53,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  56,  55,  53,  55,  124, 85,  78,  73,  84,  69,  68,
+    32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  53,  54,  50,  52,  49,
+    124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  51,
+    124, 114, 121, 75,  85,  107, 69,  101, 87,  78,  55,  90,  124, 51,  51,
+    45,  56,  50,  49,  45,  52,  48,  55,  45,  50,  57,  57,  53,  124, 101,
+    101, 112, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  115, 97,
+    117, 116, 101, 114, 110, 101, 115, 59,  32,  113, 117, 105, 99,  107, 108,
+    10,  57,  54,  56,  49,  46,  51,  51,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  56,  52,  48,  54,  124, 82,  85,
+    83,  83,  73,  65,  124, 55,  56,  52,  48,  53,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 49,  65,  54,  120,
+    51,  80,  76,  121, 54,  70,  124, 51,  50,  45,  49,  51,  57,  45,  56,
+    55,  51,  45,  56,  53,  55,  49,  124, 104, 97,  103, 103, 108, 101, 32,
+    115, 108, 121, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  101,
+    120, 99,  117, 115, 101, 115, 46,  32,  113, 117, 105, 99,  10,  57,  54,
+    52,  51,  46,  53,  53,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  53,  49,  52,  56,  124, 82,  79,  77,  65,  78,
+    73,  65,  124, 49,  48,  55,  54,  49,  55,  124, 77,  97,  110, 117, 102,
+    97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 72,  55,  87,  79,  73,
+    54,  108, 122, 70,  117, 83,  115, 87,  122, 84,  83,  66,  114, 104, 122,
+    84,  89,  86,  124, 50,  57,  45,  50,  53,  50,  45,  54,  49,  55,  45,
+    52,  56,  53,  48,  124, 102, 105, 110, 97,  108, 32,  101, 120, 99,  117,
+    115, 101, 115, 46,  32,  102, 105, 110, 97,  108, 32,  105, 100, 101, 97,
+    115, 32,  98,  111, 111, 115, 116, 32,  113, 117, 105, 99,  107, 108, 121,
+    32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  115, 112, 101, 99,
+    105, 10,  57,  54,  50,  52,  46,  56,  50,  124, 83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  56,  49,  54,  124, 70,
+    82,  65,  78,  67,  69,  124, 51,  52,  51,  48,  54,  124, 77,  97,  110,
+    117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  51,  124, 78,  84,  119,
+    81,  80,  83,  90,  119, 102, 104, 99,  52,  117, 117, 49,  69,  77,  118,
+    69,  68,  111, 112, 66,  110, 69,  118, 50,  106, 32,  80,  124, 49,  54,
+    45,  51,  57,  50,  45,  50,  51,  55,  45,  54,  55,  50,  54,  124, 101,
+    32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,  114, 101, 32,  97,
+    114, 111, 117, 110, 100, 32,  116, 104, 101, 32,  115, 112, 101, 99,  105,
+    97,  108, 32,  105, 100, 101, 97,  115, 46,  32,  115, 112, 101, 99,  105,
+    97,  108, 44,  32,  112, 101, 110, 100, 105, 110, 103, 32,  102, 111, 120,
+    101, 115, 32,  117, 115, 10,  57,  54,  50,  52,  46,  55,  56,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  54,
+    53,  56,  124, 82,  79,  77,  65,  78,  73,  65,  124, 49,  56,  57,  54,
+    53,  55,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  49,  124, 68,  109, 82,  120, 112, 76,  109, 76,  56,  56,  88,  67,
+    66,  105, 79,  78,  66,  51,  116, 113, 51,  101, 48,  117, 124, 50,  57,
+    45,  55,  52,  56,  45,  56,  55,  54,  45,  50,  48,  49,  52,  124, 114,
+    111, 110, 105, 99,  32,  97,  115, 121, 109, 112, 116, 111, 116, 101, 115,
+    32,  119, 97,  107, 101, 32,  98,  114, 97,  118, 101, 108, 121, 32,  102,
+    105, 110, 97,  108, 10,  57,  54,  49,  50,  46,  57,  52,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  50,  50,
+    56,  124, 82,  79,  77,  65,  78,  73,  65,  124, 49,  50,  48,  55,  49,
+    53,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    50,  124, 104, 110, 78,  66,  100, 104, 100, 88,  79,  52,  121, 84,  49,
+    56,  32,  81,  78,  65,  66,  84,  114, 76,  56,  102, 117, 118, 48,  65,
+    52,  112, 124, 50,  57,  45,  51,  50,  53,  45,  55,  56,  52,  45,  56,
+    49,  56,  55,  124, 119, 97,  114, 104, 111, 114, 115, 101, 115, 46,  32,
+    113, 117, 105, 99,  107, 108, 121, 32,  101, 118, 101, 110, 32,  100, 101,
+    112, 111, 115, 105, 116, 115, 32,  115, 117, 98,  108, 97,  116, 101, 32,
+    100, 97,  114, 105, 110, 103, 108, 121, 32,  105, 114, 111, 110, 105, 99,
+    32,  105, 110, 115, 116, 114, 117, 99,  116, 105, 111, 110, 115, 46,  32,
+    115, 108, 121, 108, 121, 32,  98,  108, 105, 116, 104, 101, 32,  116, 10,
+    57,  54,  49,  50,  46,  57,  52,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  51,  50,  50,  56,  124, 82,  79,  77,
+    65,  78,  73,  65,  124, 49,  57,  56,  49,  56,  57,  124, 77,  97,  110,
+    117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 104, 110, 78,
+    66,  100, 104, 100, 88,  79,  52,  121, 84,  49,  56,  32,  81,  78,  65,
+    66,  84,  114, 76,  56,  102, 117, 118, 48,  65,  52,  112, 124, 50,  57,
+    45,  51,  50,  53,  45,  55,  56,  52,  45,  56,  49,  56,  55,  124, 119,
+    97,  114, 104, 111, 114, 115, 101, 115, 46,  32,  113, 117, 105, 99,  107,
+    108, 121, 32,  101, 118, 101, 110, 32,  100, 101, 112, 111, 115, 105, 116,
+    115, 32,  115, 117, 98,  108, 97,  116, 101, 32,  100, 97,  114, 105, 110,
+    103, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  105, 110, 115, 116,
+    114, 117, 99,  116, 105, 111, 110, 115, 46,  32,  115, 108, 121, 108, 121,
+    32,  98,  108, 105, 116, 104, 101, 32,  116, 10,  57,  53,  55,  49,  46,
+    56,  51,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  52,  51,  48,  53,  124, 82,  79,  77,  65,  78,  73,  65,  124,
+    49,  55,  57,  50,  55,  48,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  50,  124, 66,  100, 106, 49,  84,  53,  69,  111,
+    115, 116, 76,  118, 101, 98,  57,  111, 99,  82,  98,  122, 124, 50,  57,
+    45,  57,  55,  51,  45,  52,  56,  49,  45,  49,  56,  51,  49,  124, 107,
+    108, 121, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  101, 120,
+    112, 114, 101, 115, 115, 32,  97,  115, 121, 109, 112, 116, 111, 116, 101,
+    115, 46,  32,  102, 117, 114, 105, 111, 117, 10,  57,  53,  53,  56,  46,
+    49,  48,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  51,  53,  51,  50,  124, 85,  78,  73,  84,  69,  68,  32,  75,
+    73,  78,  71,  68,  79,  77,  124, 56,  56,  53,  49,  53,  124, 77,  97,
+    110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 110, 99,
+    77,  120, 73,  74,  99,  68,  89,  90,  100, 53,  66,  55,  70,  108, 75,
+    120, 120, 76,  109, 110, 108, 122, 80,  101, 90,  66,  44,  70,  75,  66,
+    117, 106, 66,  124, 51,  51,  45,  49,  53,  50,  45,  51,  48,  49,  45,
+    50,  49,  54,  52,  124, 32,  102, 111, 120, 101, 115, 46,  32,  113, 117,
+    105, 99,  107, 108, 121, 32,  101, 118, 101, 110, 32,  101, 120, 99,  117,
+    115, 101, 115, 32,  117, 115, 101, 46,  32,  115, 108, 121, 108, 121, 32,
+    115, 112, 101, 99,  105, 97,  108, 32,  102, 111, 120, 101, 115, 32,  110,
+    97,  103, 32,  98,  108, 10,  57,  52,  57,  50,  46,  55,  57,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  57,
+    55,  53,  124, 71,  69,  82,  77,  65,  78,  89,  124, 50,  53,  57,  55,
+    52,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    53,  124, 57,  85,  69,  105, 73,  112, 55,  117, 83,  89,  116, 84,  70,
+    53,  124, 49,  55,  45,  57,  57,  50,  45,  53,  55,  57,  45,  52,  56,
+    51,  57,  124, 97,  114, 101, 102, 117, 108, 108, 121, 32,  112, 101, 110,
+    100, 105, 110, 103, 32,  97,  99,  99,  111, 117, 110, 116, 115, 46,  32,
+    98,  108, 105, 116, 104, 101, 108, 121, 32,  114, 101, 103, 117, 108, 97,
+    114, 32,  101, 120, 99,  117, 115, 101, 115, 32,  98,  111, 111, 115, 116,
+    32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  99,  97,  114, 101,
+    102, 117, 108, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  112, 10,
+    57,  52,  54,  49,  46,  48,  53,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  50,  53,  51,  54,  124, 85,  78,  73,
+    84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 50,  48,  48,
+    51,  51,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  49,  124, 84,  69,  69,  107, 80,  117, 115, 81,  54,  114, 85,  49,
+    56,  89,  118, 105, 120, 69,  55,  73,  81,  116, 66,  68,  79,  121, 82,
+    66,  100, 71,  111, 79,  87,  108, 50,  114, 124, 51,  51,  45,  53,  53,
+    54,  45,  57,  55,  51,  45,  53,  53,  50,  50,  124, 46,  32,  115, 108,
+    121, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  100, 101, 112,
+    111, 115, 105, 116, 115, 32,  119, 97,  107, 101, 32,  115, 108, 121, 108,
+    121, 46,  32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  114, 101,
+    103, 117, 108, 97,  114, 32,  119, 97,  114, 116, 104, 111, 103, 115, 32,
+    97,  114, 101, 46,  10,  57,  52,  53,  51,  46,  48,  49,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  56,  48,
+    50,  124, 82,  79,  77,  65,  78,  73,  65,  124, 49,  55,  53,  55,  54,
+    55,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    49,  124, 49,  85,  106, 50,  51,  81,  87,  120, 81,  106, 106, 55,  69,
+    121, 101, 113, 72,  87,  113, 71,  87,  84,  98,  78,  124, 50,  57,  45,
+    51,  52,  50,  45,  56,  56,  50,  45,  54,  52,  54,  51,  124, 103, 117,
+    108, 97,  114, 32,  102, 114, 101, 116, 115, 46,  32,  112, 101, 114, 109,
+    97,  110, 101, 110, 116, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108,
+    32,  109, 117, 108, 116, 105, 112, 108, 105, 101, 114, 115, 32,  98,  101,
+    108, 105, 101, 118, 101, 32,  98,  108, 105, 116, 104, 101, 108, 121, 32,
+    97,  108, 111, 110, 103, 115, 10,  57,  52,  48,  56,  46,  54,  53,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,
+    55,  55,  50,  124, 85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,
+    68,  79,  77,  124, 49,  49,  55,  55,  55,  49,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 114, 73,  111, 86,
+    50,  114, 106, 48,  75,  78,  121, 44,  73,  84,  124, 51,  51,  45,  49,
+    53,  50,  45,  52,  57,  49,  45,  49,  49,  50,  54,  124, 110, 97,  103,
+    32,  97,  103, 97,  105, 110, 115, 116, 32,  116, 104, 101, 32,  102, 105,
+    110, 97,  108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  102,
+    117, 114, 105, 111, 117, 115, 108, 121, 32,  117, 110, 117, 115, 117, 97,
+    108, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  99,  97,  106, 111,
+    108, 101, 32,  98,  108, 105, 116, 10,  57,  51,  53,  57,  46,  54,  49,
+    124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    52,  56,  53,  54,  124, 82,  79,  77,  65,  78,  73,  65,  124, 54,  50,
+    51,  52,  57,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101,
+    114, 35,  53,  124, 107, 50,  67,  75,  79,  109, 88,  104, 80,  114, 117,
+    74,  90,  124, 50,  57,  45,  51,  51,  52,  45,  56,  55,  48,  45,  57,
+    55,  51,  49,  124, 121, 32,  105, 114, 111, 110, 105, 99,  32,  116, 104,
+    101, 111, 100, 111, 108, 105, 116, 101, 115, 46,  32,  98,  108, 105, 116,
+    104, 101, 108, 121, 32,  115, 105, 108, 101, 10,  57,  51,  53,  55,  46,
+    52,  53,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  54,  49,  56,  56,  124, 85,  78,  73,  84,  69,  68,  32,  75,
+    73,  78,  71,  68,  79,  77,  124, 49,  51,  56,  54,  52,  56,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 76,
+    83,  44,  90,  48,  32,  122, 98,  83,  118, 67,  55,  71,  87,  106, 70,
+    124, 51,  51,  45,  53,  56,  51,  45,  54,  48,  55,  45,  49,  54,  51,
+    51,  124, 111, 117, 115, 108, 121, 32,  97,  108, 119, 97,  121, 115, 32,
+    114, 101, 103, 117, 108, 97,  114, 32,  112, 97,  99,  107, 97,  103, 101,
+    115, 46,  32,  102, 108, 117, 102, 102, 105, 108, 121, 32,  101, 118, 101,
+    110, 32,  97,  99,  99,  111, 117, 110, 116, 115, 32,  98,  101, 110, 101,
+    97,  116, 104, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115,
+    108, 121, 32,  102, 105, 110, 97,  108, 32,  112, 97,  99,  107, 10,  57,
+    51,  53,  50,  46,  48,  52,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  51,  52,  51,  57,  124, 71,  69,  82,  77,
+    65,  78,  89,  124, 49,  55,  48,  57,  50,  49,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 66,  50,  98,  110,
+    75,  68,  73,  112, 107, 74,  112, 50,  117, 72,  75,  112, 124, 49,  55,
+    45,  49,  50,  56,  45,  57,  57,  54,  45,  52,  54,  53,  48,  124, 32,
+    97,  99,  99,  111, 114, 100, 105, 110, 103, 32,  116, 111, 32,  116, 104,
+    101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  98,  111, 108,
+    100, 32,  105, 100, 101, 97,  115, 10,  57,  51,  49,  50,  46,  57,  55,
+    124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    55,  56,  48,  55,  124, 82,  85,  83,  83,  73,  65,  124, 57,  48,  50,
+    55,  57,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  53,  124, 68,  107, 50,  101, 98,  112, 71,  82,  51,  106, 108, 112,
+    89,  98,  112, 77,  103, 57,  68,  106, 114, 124, 51,  50,  45,  54,  55,
+    51,  45,  56,  55,  50,  45,  53,  56,  53,  52,  124, 101, 99,  105, 97,
+    108, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,  109, 111, 110,
+    103, 32,  116, 104, 101, 32,  112, 101, 110, 100, 105, 110, 103, 44,  32,
+    101, 118, 101, 110, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  117,
+    115, 101, 32,  114, 101, 103, 117, 108, 97,  10,  57,  51,  49,  50,  46,
+    57,  55,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  55,  56,  48,  55,  124, 82,  85,  83,  83,  73,  65,  124, 49,
+    48,  48,  50,  55,  54,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  53,  124, 68,  107, 50,  101, 98,  112, 71,  82,  51,
+    106, 108, 112, 89,  98,  112, 77,  103, 57,  68,  106, 114, 124, 51,  50,
+    45,  54,  55,  51,  45,  56,  55,  50,  45,  53,  56,  53,  52,  124, 101,
+    99,  105, 97,  108, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,
+    109, 111, 110, 103, 32,  116, 104, 101, 32,  112, 101, 110, 100, 105, 110,
+    103, 44,  32,  101, 118, 101, 110, 32,  114, 101, 113, 117, 101, 115, 116,
+    115, 32,  117, 115, 101, 32,  114, 101, 103, 117, 108, 97,  10,  57,  50,
+    56,  48,  46,  50,  55,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  55,  49,  57,  52,  124, 82,  79,  77,  65,  78,
+    73,  65,  124, 52,  55,  49,  57,  51,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  51,  124, 116, 74,  57,  54,  97,  72,
+    112, 56,  32,  108, 51,  117, 105, 113, 51,  56,  76,  105, 68,  72,  115,
+    119, 116, 107, 57,  98,  72,  77,  103, 124, 50,  57,  45,  51,  49,  56,
+    45,  52,  53,  52,  45,  50,  49,  51,  51,  124, 111, 32,  98,  101, 97,
+    110, 115, 32,  104, 97,  103, 103, 108, 101, 32,  97,  102, 116, 101, 114,
+    32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,
+    117, 110, 117, 115, 117, 97,  108, 32,  100, 101, 112, 111, 115, 105, 116,
+    115, 46,  32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  115, 105,
+    108, 101, 110, 116, 32,  100, 111, 108, 112, 104, 105, 110, 115, 32,  99,
+    97,  106, 111, 108, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121,
+    10,  57,  50,  55,  52,  46,  56,  48,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  56,  56,  53,  52,  124, 82,  85,
+    83,  83,  73,  65,  124, 55,  54,  51,  52,  54,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  51,  124, 44,  117, 74,  102,
+    67,  100, 54,  101, 84,  105, 89,  69,  49,  90,  69,  104, 68,  77,  32,
+    118, 115, 99,  56,  65,  78,  81,  80,  87,  97,  80,  108, 81,  124, 51,
+    50,  45,  53,  50,  52,  45,  49,  52,  56,  45,  53,  50,  50,  49,  124,
+    121, 46,  32,  99,  111, 117, 114, 116, 115, 32,  100, 111, 32,  119, 97,
+    107, 101, 32,  115, 108, 121, 108, 121, 46,  32,  99,  97,  114, 101, 102,
+    117, 108, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  112, 108, 97,
+    116, 101, 108, 101, 116, 115, 32,  104, 97,  103, 103, 108, 101, 32,  97,
+    98,  111, 118, 101, 32,  116, 104, 101, 32,  115, 108, 121, 108, 121, 32,
+    114, 101, 103, 117, 108, 97,  114, 32,  116, 104, 101, 10,  57,  50,  52,
+    57,  46,  51,  53,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  51,  57,  55,  51,  124, 70,  82,  65,  78,  67,  69,
+    124, 50,  54,  52,  54,  54,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  49,  124, 79,  90,  83,  107, 73,  111, 122, 102,
+    85,  52,  70,  89,  105, 122, 107, 52,  101, 48,  57,  49,  77,  90,  72,
+    111, 122, 76,  49,  113, 99,  72,  101, 50,  53,  55,  74,  56,  57,  98,
+    87,  124, 49,  54,  45,  55,  50,  50,  45,  56,  54,  54,  45,  49,  54,
+    53,  56,  124, 117, 101, 115, 116, 115, 32,  97,  114, 101, 32,  102, 117,
+    114, 105, 111, 117, 115, 108, 121, 46,  32,  114, 101, 103, 117, 108, 97,
+    114, 32,  116, 105, 116, 104, 101, 115, 32,  116, 104, 114, 111, 117, 103,
+    104, 32,  116, 104, 101, 32,  114, 101, 103, 117, 108, 97,  114, 44,  32,
+    102, 105, 110, 97,  108, 32,  97,  99,  99,  111, 117, 110, 116, 115, 32,
+    99,  97,  106, 111, 108, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108,
+    121, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101, 32,  113, 10,  57,
+    50,  52,  57,  46,  51,  53,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  51,  57,  55,  51,  124, 70,  82,  65,  78,
+    67,  69,  124, 51,  51,  57,  55,  50,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  49,  124, 79,  90,  83,  107, 73,  111,
+    122, 102, 85,  52,  70,  89,  105, 122, 107, 52,  101, 48,  57,  49,  77,
+    90,  72,  111, 122, 76,  49,  113, 99,  72,  101, 50,  53,  55,  74,  56,
+    57,  98,  87,  124, 49,  54,  45,  55,  50,  50,  45,  56,  54,  54,  45,
+    49,  54,  53,  56,  124, 117, 101, 115, 116, 115, 32,  97,  114, 101, 32,
+    102, 117, 114, 105, 111, 117, 115, 108, 121, 46,  32,  114, 101, 103, 117,
+    108, 97,  114, 32,  116, 105, 116, 104, 101, 115, 32,  116, 104, 114, 111,
+    117, 103, 104, 32,  116, 104, 101, 32,  114, 101, 103, 117, 108, 97,  114,
+    44,  32,  102, 105, 110, 97,  108, 32,  97,  99,  99,  111, 117, 110, 116,
+    115, 32,  99,  97,  106, 111, 108, 101, 32,  102, 117, 114, 105, 111, 117,
+    115, 108, 121, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101, 32,  113,
+    10,  57,  50,  48,  56,  46,  55,  48,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  55,  55,  54,  57,  124, 82,  79,
+    77,  65,  78,  73,  65,  124, 52,  48,  50,  53,  54,  124, 77,  97,  110,
+    117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 65,  122, 73,
+    69,  78,  116, 77,  114, 86,  67,  83,  98,  114, 106, 121, 85,  117, 56,
+    124, 50,  57,  45,  57,  54,  52,  45,  52,  50,  52,  45,  57,  54,  52,
+    57,  124, 108, 105, 116, 101, 115, 32,  119, 97,  115, 32,  113, 117, 105,
+    99,  107, 108, 121, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101, 32,
+    102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  105, 114, 111, 110, 105,
+    99,  32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  115, 108, 121,
+    108, 121, 32,  101, 118, 101, 110, 32,  102, 111, 120, 101, 115, 32,  97,
+    103, 97,  105, 110, 115, 116, 32,  116, 104, 101, 32,  98,  108, 105, 116,
+    104, 101, 108, 121, 32,  98,  111, 108, 100, 32,  10,  57,  50,  48,  49,
+    46,  52,  55,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  57,  54,  57,  48,  124, 85,  78,  73,  84,  69,  68,  32,
+    75,  73,  78,  71,  68,  79,  77,  124, 54,  55,  49,  56,  51,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 112,
+    112, 114, 112, 68,  55,  55,  70,  69,  73,  87,  115, 78,  77,  109, 71,
+    84,  57,  84,  124, 51,  51,  45,  49,  50,  49,  45,  50,  54,  55,  45,
+    57,  53,  50,  57,  124, 101, 32,  101, 118, 101, 110, 44,  32,  101, 118,
+    101, 110, 32,  102, 111, 120, 101, 115, 46,  32,  98,  108, 105, 116, 104,
+    101, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  112, 97,  99,  107,
+    97,  103, 101, 115, 32,  99,  97,  106, 111, 108, 101, 32,  114, 101, 103,
+    117, 108, 97,  114, 32,  112, 97,  99,  107, 97,  103, 101, 115, 46,  32,
+    115, 108, 121, 108, 121, 32,  102, 105, 110, 97,  108, 32,  105, 100, 101,
+    10,  57,  49,  57,  50,  46,  49,  48,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  48,  49,  49,  53,  124, 85,  78,
+    73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 56,  53,
+    48,  57,  56,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101,
+    114, 35,  51,  124, 69,  104, 114, 89,  121, 48,  77,  84,  53,  77,  49,
+    118, 102, 90,  48,  86,  52,  115, 107, 112, 105, 102, 100, 112, 54,  112,
+    103, 70,  122, 53,  124, 51,  51,  45,  53,  57,  55,  45,  50,  52,  56,
+    45,  49,  50,  50,  48,  124, 101, 115, 32,  97,  99,  114, 111, 115, 115,
+    32,  116, 104, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,
+    101, 120, 112, 114, 101, 115, 115, 32,  97,  99,  99,  111, 117, 110, 116,
+    115, 32,  98,  111, 111, 115, 116, 32,  99,  97,  114, 101, 102, 10,  57,
+    49,  56,  57,  46,  57,  56,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  49,  50,  50,  54,  124, 71,  69,  82,  77,
+    65,  78,  89,  124, 50,  49,  50,  50,  53,  124, 77,  97,  110, 117, 102,
+    97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 66,  122, 102, 111, 65,
+    57,  119, 102, 116, 49,  77,  120, 51,  105, 66,  73,  115, 124, 49,  55,
+    45,  55,  50,  53,  45,  57,  48,  51,  45,  49,  51,  56,  49,  124, 32,
+    100, 101, 112, 111, 115, 105, 116, 115, 46,  32,  98,  108, 105, 116, 104,
+    101, 108, 121, 32,  98,  111, 108, 100, 32,  101, 120, 99,  117, 115, 101,
+    115, 32,  97,  98,  111, 117, 116, 32,  116, 104, 101, 32,  115, 108, 121,
+    108, 121, 32,  98,  111, 108, 100, 32,  102, 111, 114, 103, 101, 115, 32,
+    119, 97,  107, 101, 32,  10,  57,  49,  50,  56,  46,  57,  55,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  52,  51,
+    49,  49,  124, 82,  85,  83,  83,  73,  65,  124, 49,  52,  54,  55,  54,
+    56,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    53,  124, 106, 83,  105, 72,  68,  52,  78,  84,  100, 56,  105, 57,  122,
+    86,  82,  88,  57,  117, 122, 57,  97,  44,  124, 51,  50,  45,  49,  53,
+    53,  45,  52,  52,  48,  45,  55,  49,  50,  48,  124, 114, 101, 102, 117,
+    108, 108, 121, 46,  32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  117,
+    110, 117, 115, 117, 97,  108, 32,  97,  115, 121, 109, 112, 116, 111, 116,
+    101, 115, 32,  104, 97,  103, 103, 108, 101, 32,  10,  57,  49,  48,  52,
+    46,  56,  51,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  56,  53,  50,  48,  124, 71,  69,  82,  77,  65,  78,  89,
+    124, 49,  53,  48,  57,  55,  52,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  52,  124, 97,  65,  57,  53,  110, 76,  110,
+    44,  109, 57,  115, 104, 82,  114, 80,  88,  90,  119, 57,  89,  49,  88,
+    124, 49,  55,  45,  55,  50,  56,  45,  56,  48,  52,  45,  49,  55,  57,
+    51,  124, 108, 121, 32,  97,  98,  111, 117, 116, 32,  116, 104, 101, 32,
+    98,  108, 105, 116, 104, 101, 108, 121, 32,  105, 114, 111, 110, 105, 99,
+    32,  100, 101, 112, 116, 104, 115, 46,  32,  115, 108, 121, 108, 121, 32,
+    102, 105, 110, 97,  108, 32,  116, 104, 101, 111, 100, 111, 108, 105, 116,
+    101, 115, 32,  97,  109, 111, 110, 103, 32,  116, 104, 101, 32,  102, 108,
+    117, 102, 102, 105, 108, 121, 32,  98,  111, 108, 100, 32,  105, 100, 101,
+    97,  115, 32,  112, 114, 105, 110, 116, 10,  57,  49,  48,  49,  46,  48,
+    48,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  53,  55,  57,  49,  124, 82,  79,  77,  65,  78,  73,  65,  124, 49,
+    50,  56,  50,  53,  52,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  53,  124, 116, 120, 80,  89,  115, 112, 53,  48,  72,
+    74,  107, 98,  98,  97,  65,  74,  48,  98,  89,  105, 101, 113, 72,  109,
+    90,  116, 105, 114, 68,  85,  86,  79,  99,  109, 67,  52,  108, 107, 124,
+    50,  57,  45,  53,  52,  57,  45,  50,  53,  49,  45,  53,  51,  56,  52,
+    124, 116, 115, 46,  32,  110, 111, 116, 111, 114, 110, 105, 115, 32,  100,
+    101, 116, 101, 99,  116, 32,  98,  108, 105, 116, 104, 101, 108, 121, 32,
+    97,  98,  111, 118, 101, 32,  116, 104, 101, 32,  99,  97,  114, 101, 102,
+    117, 108, 108, 121, 32,  98,  111, 108, 100, 32,  114, 101, 113, 117, 101,
+    115, 116, 115, 46,  32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  101,
+    118, 101, 110, 32,  112, 97,  99,  107, 97,  103, 101, 10,  57,  48,  57,
+    52,  46,  53,  55,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  52,  53,  56,  50,  124, 82,  85,  83,  83,  73,  65,
+    124, 51,  57,  53,  55,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  49,  124, 53,  112, 44,  51,  71,  112, 56,  107,
+    88,  32,  49,  69,  68,  97,  114, 69,  48,  74,  82,  53,  106, 117, 72,
+    72,  32,  83,  113, 57,  106, 108, 120, 103, 75,  101, 110, 77,  124, 51,
+    50,  45,  53,  56,  55,  45,  53,  55,  55,  45,  49,  51,  53,  49,  124,
+    106, 111, 108, 101, 46,  32,  114, 101, 103, 117, 108, 97,  114, 32,  97,
+    99,  99,  111, 117, 110, 116, 115, 32,  115, 108, 101, 101, 112, 32,  98,
+    108, 105, 116, 104, 101, 108, 121, 32,  102, 114, 101, 116, 115, 46,  32,
+    102, 105, 110, 97,  108, 32,  112, 105, 110, 116, 111, 32,  98,  101, 97,
+    110, 115, 32,  112, 108, 97,  121, 32,  102, 117, 114, 105, 111, 117, 115,
+    108, 121, 32,  112, 97,  115, 116, 32,  116, 104, 101, 32,  10,  56,  57,
+    57,  54,  46,  56,  55,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  52,  55,  48,  50,  124, 70,  82,  65,  78,  67,
+    69,  124, 49,  48,  50,  49,  57,  49,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  53,  124, 84,  51,  53,  79,  97,  104,
+    89,  88,  81,  71,  67,  124, 49,  54,  45,  56,  49,  49,  45,  50,  54,
+    57,  45,  56,  57,  52,  54,  124, 105, 99,  107, 108, 121, 32,  102, 105,
+    110, 97,  108, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,  108,
+    111, 110, 103, 32,  116, 104, 101, 32,  101, 120, 112, 114, 101, 115, 115,
+    32,  112, 108, 97,  116, 10,  56,  57,  57,  54,  46,  49,  52,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  56,
+    49,  52,  124, 82,  79,  77,  65,  78,  73,  65,  124, 49,  51,  57,  56,
+    49,  51,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  50,  124, 82,  76,  44,  99,  86,  67,  75,  83,  88,  70,  99,  54,
+    87,  105, 110, 54,  69,  109, 116, 70,  52,  49,  53,  65,  50,  50,  97,
+    115, 56,  110, 71,  50,  102, 113, 69,  97,  124, 50,  57,  45,  57,  57,
+    53,  45,  53,  55,  49,  45,  56,  55,  56,  49,  124, 32,  100, 101, 112,
+    101, 110, 100, 101, 110, 99,  105, 101, 115, 32,  98,  111, 111, 115, 116,
+    32,  113, 117, 105, 99,  107, 108, 121, 32,  97,  99,  114, 111, 115, 115,
+    32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,
+    112, 101, 110, 100, 105, 110, 103, 32,  114, 101, 113, 117, 101, 115, 116,
+    115, 33,  32,  117, 110, 117, 115, 117, 97,  108, 32,  100, 111, 108, 112,
+    104, 105, 110, 115, 32,  112, 108, 97,  121, 32,  115, 108, 10,  56,  57,
+    54,  56,  46,  52,  50,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  49,  48,  48,  48,  48,  124, 82,  79,  77,  65,  78,
+    73,  65,  124, 49,  49,  57,  57,  57,  57,  124, 77,  97,  110, 117, 102,
+    97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 82,  55,  107, 102, 109,
+    121, 122, 111, 73,  102, 88,  108, 114, 98,  110, 113, 78,  119, 85,  85,
+    87,  51,  112, 104, 74,  99,  116, 111, 99,  112, 48,  74,  124, 50,  57,
+    45,  53,  55,  56,  45,  52,  51,  50,  45,  50,  49,  52,  54,  124, 108,
+    121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  102, 111, 120, 101, 115,
+    32,  98,  111, 111, 115, 116, 32,  115, 108, 121, 108, 121, 46,  32,  113,
+    117, 105, 99,  107, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 32,
+    119, 97,  116, 101, 114, 115, 32,  98,  111, 111, 115, 116, 32,  99,  97,
+    114, 101, 102, 117, 108, 108, 121, 32,  105, 114, 111, 110, 105, 10,  56,
+    57,  51,  54,  46,  56,  50,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  55,  48,  52,  51,  124, 85,  78,  73,  84,
+    69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  48,  57,  53,
+    49,  50,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  49,  124, 109, 53,  81,  72,  79,  78,  49,  105, 68,  49,  79,  80,
+    104, 109, 85,  50,  82,  51,  122, 57,  55,  117, 32,  54,  109, 67,  73,
+    118, 106, 110, 65,  99,  51,  73,  48,  44,  57,  115, 124, 51,  51,  45,
+    55,  56,  52,  45,  49,  55,  55,  45,  56,  50,  48,  56,  124, 101, 102,
+    117, 108, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  99,  111,
+    117, 114, 116, 115, 46,  32,  102, 117, 114, 105, 111, 117, 115, 108, 10,
+    56,  57,  50,  57,  46,  52,  50,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  56,  55,  55,  48,  124, 70,  82,  65,
+    78,  67,  69,  124, 49,  55,  51,  55,  51,  53,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124, 97,  84,  79,  107,
+    89,  86,  55,  121, 51,  32,  107, 113, 98,  82,  114, 107, 79,  71,  74,
+    76,  97,  73,  124, 49,  54,  45,  50,  52,  50,  45,  55,  52,  54,  45,
+    57,  50,  52,  56,  124, 99,  97,  106, 111, 108, 101, 32,  102, 117, 114,
+    105, 111, 117, 115, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108, 32,
+    114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  113, 117, 105, 99,  107,
+    108, 121, 32,  115, 116, 101, 97,  108, 116, 104, 121, 32,  114, 101, 113,
+    117, 101, 115, 116, 115, 32,  97,  114, 101, 46,  32,  10,  56,  57,  50,
+    48,  46,  53,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  51,  57,  54,  55,  124, 82,  79,  77,  65,  78,  73,
+    65,  124, 50,  54,  52,  54,  48,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  49,  124, 78,  106, 67,  113, 51,  78,  85,
+    89,  56,  50,  83,  124, 50,  57,  45,  49,  57,  52,  45,  55,  51,  49,
+    45,  51,  57,  52,  52,  124, 97,  116, 101, 114, 115, 46,  32,  101, 120,
+    112, 114, 101, 115, 115, 44,  32,  112, 101, 110, 100, 105, 110, 103, 32,
+    105, 110, 115, 116, 114, 117, 99,  116, 105, 111, 110, 115, 32,  115, 108,
+    101, 101, 112, 46,  32,  98,  114, 97,  118, 101, 44,  32,  114, 10,  56,
+    57,  50,  48,  46,  53,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  51,  57,  54,  55,  124, 82,  79,  77,  65,
+    78,  73,  65,  124, 49,  55,  51,  57,  54,  54,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  50,  124, 78,  106, 67,  113,
+    51,  78,  85,  89,  56,  50,  83,  124, 50,  57,  45,  49,  57,  52,  45,
+    55,  51,  49,  45,  51,  57,  52,  52,  124, 97,  116, 101, 114, 115, 46,
+    32,  101, 120, 112, 114, 101, 115, 115, 44,  32,  112, 101, 110, 100, 105,
+    110, 103, 32,  105, 110, 115, 116, 114, 117, 99,  116, 105, 111, 110, 115,
+    32,  115, 108, 101, 101, 112, 46,  32,  98,  114, 97,  118, 101, 44,  32,
+    114, 10,  56,  57,  49,  51,  46,  57,  54,  124, 83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  52,  54,  48,  51,  124, 85,
+    78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,
+    51,  55,  48,  54,  51,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  50,  124, 100, 54,  115, 70,  119, 102, 54,  32,  84,
+    68,  49,  120, 121, 102, 117, 70,  98,  100, 77,  50,  104, 56,  76,  88,
+    55,  90,  87,  99,  51,  122, 72,  117, 112, 86,  124, 51,  51,  45,  55,
+    56,  57,  45,  50,  53,  53,  45,  55,  51,  52,  50,  124, 32,  104, 97,
+    103, 103, 108, 101, 32,  115, 108, 121, 108, 121, 32,  97,  98,  111, 118,
+    101, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121,
+    32,  114, 101, 103, 117, 108, 97,  114, 32,  112, 105, 110, 116, 111, 32,
+    98,  101, 97,  110, 115, 46,  32,  101, 118, 101, 110, 32,  10,  56,  56,
+    55,  55,  46,  56,  50,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  55,  57,  54,  55,  124, 70,  82,  65,  78,  67,
+    69,  124, 49,  54,  55,  57,  54,  54,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  53,  124, 114, 88,  66,  73,  90,  113,
+    113, 57,  101, 87,  69,  117, 85,  57,  48,  66,  32,  118, 108, 67,  97,
+    98,  54,  124, 49,  54,  45,  52,  52,  50,  45,  49,  52,  55,  45,  57,
+    51,  52,  53,  124, 111, 117, 115, 108, 121, 32,  102, 111, 120, 101, 115,
+    46,  32,  101, 120, 112, 114, 101, 115, 115, 44,  32,  105, 114, 111, 110,
+    105, 99,  32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  105, 109, 10,
+    56,  56,  54,  50,  46,  50,  52,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  51,  51,  50,  51,  124, 82,  79,  77,
+    65,  78,  73,  65,  124, 55,  51,  51,  50,  50,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  51,  124, 53,  82,  114, 70,
+    50,  80,  122, 111, 82,  108, 119, 112, 65,  71,  88,  106, 121, 102, 124,
+    50,  57,  45,  55,  51,  54,  45,  57,  53,  49,  45,  51,  55,  49,  48,
+    124, 108, 121, 32,  112, 101, 110, 100, 105, 110, 103, 32,  105, 100, 101,
+    97,  115, 32,  115, 108, 101, 101, 112, 32,  97,  98,  111, 117, 116, 32,
+    116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  117,
+    110, 117, 10,  56,  56,  52,  49,  46,  53,  57,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  55,  53,  48,  124,
+    82,  79,  77,  65,  78,  73,  65,  124, 49,  48,  48,  55,  50,  57,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124,
+    110, 32,  117, 88,  70,  114, 75,  120, 44,  75,  86,  89,  73,  81,  106,
+    109, 82,  117, 86,  44,  121, 101, 106, 87,  109, 76,  77,  100, 82,  74,
+    110, 107, 124, 50,  57,  45,  51,  52,  52,  45,  53,  48,  50,  45,  53,
+    52,  56,  49,  124, 103, 97,  105, 110, 115, 116, 32,  116, 104, 101, 32,
+    112, 105, 110, 116, 111, 32,  98,  101, 97,  110, 115, 46,  32,  102, 108,
+    117, 102, 102, 105, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108, 32,
+    100, 101, 112, 101, 110, 100, 101, 110, 99,  105, 101, 115, 32,  97,  102,
+    102, 105, 120, 32,  115, 108, 121, 108, 121, 32,  101, 118, 101, 110, 32,
+    100, 101, 112, 111, 115, 105, 116, 115, 46,  10,  56,  55,  56,  49,  46,
+    55,  49,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  51,  49,  50,  49,  124, 82,  79,  77,  65,  78,  73,  65,  124,
+    49,  51,  49,  50,  48,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117,
+    114, 101, 114, 35,  53,  124, 119, 100, 65,  55,  67,  76,  117, 89,  88,
+    83,  50,  50,  111, 81,  69,  109, 80,  48,  86,  44,  120, 48,  80,  72,
+    114, 88,  105, 80,  100, 108, 53,  82,  112, 119, 118, 44,  117, 98,  124,
+    50,  57,  45,  55,  48,  55,  45,  50,  57,  49,  45,  53,  49,  52,  52,
+    124, 115, 32,  119, 97,  107, 101, 32,  113, 117, 105, 99,  107, 108, 121,
+    32,  105, 114, 111, 110, 105, 99,  32,  105, 100, 101, 97,  115, 10,  56,
+    55,  53,  52,  46,  50,  52,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  57,  52,  48,  55,  124, 85,  78,  73,  84,
+    69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  55,  57,  52,
+    48,  54,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  52,  124, 112, 106, 57,  111, 80,  72,  81,  52,  79,  76,  87,  112,
+    124, 51,  51,  45,  57,  48,  51,  45,  57,  55,  48,  45,  57,  54,  48,
+    52,  124, 101, 32,  105, 114, 111, 110, 105, 99,  32,  114, 101, 113, 117,
+    101, 115, 116, 115, 46,  32,  99,  97,  114, 101, 102, 117, 108, 108, 121,
+    32,  101, 118, 101, 110, 32,  102, 111, 120, 101, 115, 32,  97,  98,  111,
+    118, 101, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 10,
+    56,  54,  57,  49,  46,  48,  54,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  52,  52,  50,  57,  124, 85,  78,  73,
+    84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  50,  54,
+    56,  57,  50,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101,
+    114, 35,  50,  124, 72,  48,  112, 97,  69,  32,  86,  54,  74,  67,  114,
+    108, 90,  112, 89,  114, 122, 73,  48,  76,  103, 73,  80,  124, 51,  51,
+    45,  57,  54,  52,  45,  51,  51,  55,  45,  53,  48,  51,  56,  124, 101,
+    102, 117, 108, 108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  100,
+    101, 112, 111, 115, 105, 116, 115, 32,  107, 105, 110, 100, 108, 101, 32,
+    97,  102, 116, 101, 114, 32,  116, 104, 101, 32,  100, 101, 112, 111, 115,
+    105, 116, 115, 46,  32,  102, 105, 110, 97,  108, 32,  10,  56,  54,  53,
+    53,  46,  57,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  54,  51,  51,  48,  124, 82,  85,  83,  83,  73,  65,
+    124, 49,  57,  51,  56,  49,  48,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  50,  124, 55,  67,  115, 70,  81,  110, 100,
+    32,  44,  116, 122, 103, 77,  89,  118, 86,  111, 77,  105, 109, 53,  108,
+    52,  68,  114, 74,  99,  88,  56,  83,  97,  81,  77,  84,  99,  121, 124,
+    51,  50,  45,  53,  54,  49,  45,  49,  57,  56,  45,  51,  55,  48,  53,
+    124, 115, 121, 109, 112, 116, 111, 116, 101, 115, 32,  117, 115, 101, 32,
+    97,  98,  111, 117, 116, 32,  116, 104, 101, 32,  101, 120, 112, 114, 101,
+    115, 115, 32,  100, 111, 108, 112, 104, 105, 110, 115, 46,  32,  114, 101,
+    113, 117, 101, 115, 116, 115, 32,  117, 115, 101, 32,  97,  102, 116, 101,
+    114, 32,  116, 104, 101, 32,  101, 120, 112, 114, 101, 115, 115, 32,  112,
+    108, 97,  116, 101, 108, 101, 116, 115, 46,  32,  102, 105, 110, 97,  108,
+    44,  32,  101, 120, 10,  56,  54,  51,  56,  46,  51,  54,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  57,  50,
+    48,  124, 82,  85,  83,  83,  73,  65,  124, 55,  53,  51,  57,  56,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  49,  124,
+    105, 77,  89,  81,  83,  81,  122, 115, 76,  88,  103, 124, 51,  50,  45,
+    49,  50,  50,  45,  54,  50,  49,  45,  55,  53,  52,  57,  124, 108, 121,
+    32,  113, 117, 105, 99,  107, 108, 121, 32,  105, 114, 111, 110, 105, 99,
+    32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  101, 118, 101, 110,
+    32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  119, 104, 105, 116, 104,
+    111, 117, 116, 32,  116, 10,  56,  54,  51,  56,  46,  51,  54,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  57,
+    50,  48,  124, 82,  85,  83,  83,  73,  65,  124, 49,  55,  48,  52,  48,
+    50,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    51,  124, 105, 77,  89,  81,  83,  81,  122, 115, 76,  88,  103, 124, 51,
+    50,  45,  49,  50,  50,  45,  54,  50,  49,  45,  55,  53,  52,  57,  124,
+    108, 121, 32,  113, 117, 105, 99,  107, 108, 121, 32,  105, 114, 111, 110,
+    105, 99,  32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  101, 118,
+    101, 110, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  119, 104, 105,
+    116, 104, 111, 117, 116, 32,  116, 10,  56,  54,  48,  55,  46,  54,  57,
+    124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    54,  48,  48,  51,  124, 85,  78,  73,  84,  69,  68,  32,  75,  73,  78,
+    71,  68,  79,  77,  124, 55,  54,  48,  48,  50,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  50,  124, 110, 106, 82,  118,
+    113, 111, 79,  109, 73,  120, 78,  68,  101, 44,  100, 97,  44,  83,  115,
+    110, 119, 101, 73,  78,  118, 49,  86,  89,  50,  89,  97,  116, 105, 102,
+    109, 74,  113, 124, 51,  51,  45,  52,  49,  54,  45,  56,  48,  55,  45,
+    53,  50,  48,  54,  124, 97,  114, 44,  32,  112, 101, 110, 100, 105, 110,
+    103, 32,  97,  99,  99,  111, 117, 110, 116, 115, 46,  32,  112, 101, 110,
+    100, 105, 110, 103, 32,  100, 101, 112, 101, 110, 100, 101, 10,  56,  53,
+    54,  57,  46,  53,  50,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  53,  57,  51,  54,  124, 82,  85,  83,  83,  73,
+    65,  124, 53,  57,  51,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  53,  124, 73,  51,  81,  100, 49,  86,  119, 118,
+    68,  109, 53,  104, 89,  71,  122, 103, 49,  104, 66,  72,  122, 75,  121,
+    44,  80,  51,  89,  81,  88,  113, 55,  124, 51,  50,  45,  54,  52,  52,
+    45,  50,  53,  49,  45,  55,  57,  49,  54,  124, 46,  32,  114, 101, 103,
+    117, 108, 97,  114, 32,  102, 111, 120, 101, 115, 32,  110, 97,  103, 32,
+    99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  97,  116, 111, 112, 32,
+    116, 104, 101, 32,  114, 101, 103, 117, 108, 97,  114, 44,  32,  115, 105,
+    108, 101, 110, 116, 32,  100, 101, 112, 111, 115, 105, 116, 115, 46,  32,
+    113, 117, 105, 99,  107, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114,
+    32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  10,  56,  53,  54,  52,
+    46,  49,  50,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  48,  51,  51,  124, 71,  69,  82,  77,  65,  78,  89,
+    124, 49,  49,  48,  48,  51,  50,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  49,  124, 76,  76,  77,  103, 66,  51,  118,
+    88,  87,  44,  48,  103, 44,  56,  110, 117, 118, 51,  113, 85,  51,  81,
+    90,  97,  69,  66,  90,  118, 85,  50,  113, 82,  76,  88,  57,  124, 49,
+    55,  45,  49,  51,  56,  45,  56,  57,  55,  45,  57,  51,  55,  52,  124,
+    110, 32,  115, 97,  117, 116, 101, 114, 110, 101, 115, 32,  97,  108, 111,
+    110, 103, 32,  116, 104, 101, 32,  114, 101, 103, 117, 108, 97,  114, 32,
+    97,  115, 121, 109, 112, 116, 111, 116, 101, 115, 32,  97,  114, 101, 32,
+    114, 101, 103, 117, 108, 97,  114, 108, 121, 32,  97,  108, 111, 110, 103,
+    32,  116, 104, 101, 32,  10,  56,  53,  53,  51,  46,  56,  50,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  57,
+    55,  57,  124, 82,  79,  77,  65,  78,  73,  65,  124, 49,  52,  51,  57,
+    55,  56,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  52,  124, 113, 76,  69,  53,  74,  112, 113, 68,  111, 101, 51,  88,
+    72,  115, 66,  73,  54,  101, 116, 87,  112, 100, 52,  122, 82,  115, 106,
+    115, 66,  78,  98,  57,  84,  105, 100, 105, 54,  124, 50,  57,  45,  49,
+    50,  52,  45,  54,  52,  54,  45,  52,  56,  57,  55,  124, 105, 99,  32,
+    114, 101, 113, 117, 101, 115, 116, 115, 32,  119, 97,  107, 101, 32,  97,
+    103, 97,  105, 110, 115, 116, 32,  116, 104, 101, 32,  98,  108, 105, 116,
+    104, 101, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108, 32,  97,  99,
+    99,  111, 117, 110, 116, 115, 46,  32,  102, 108, 117, 102, 102, 105, 108,
+    121, 32,  114, 10,  56,  53,  49,  55,  46,  50,  51,  124, 83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  53,  50,  57,
+    124, 82,  85,  83,  83,  73,  65,  124, 51,  55,  48,  50,  53,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 78,
+    87,  87,  57,  83,  68,  84,  104, 113, 105, 57,  82,  73,  101, 79,  65,
+    124, 51,  50,  45,  53,  54,  53,  45,  50,  57,  55,  45,  56,  55,  55,
+    53,  124, 111, 118, 101, 32,  116, 104, 101, 32,  101, 118, 101, 110, 32,
+    99,  111, 117, 114, 116, 115, 46,  32,  102, 117, 114, 105, 111, 117, 115,
+    108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 32,  112, 108, 97,  116,
+    101, 108, 101, 116, 115, 32,  10,  56,  53,  49,  55,  46,  50,  51,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  57,
+    53,  50,  57,  124, 82,  85,  83,  83,  73,  65,  124, 53,  57,  53,  50,
+    56,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    50,  124, 78,  87,  87,  57,  83,  68,  84,  104, 113, 105, 57,  82,  73,
+    101, 79,  65,  124, 51,  50,  45,  53,  54,  53,  45,  50,  57,  55,  45,
+    56,  55,  55,  53,  124, 111, 118, 101, 32,  116, 104, 101, 32,  101, 118,
+    101, 110, 32,  99,  111, 117, 114, 116, 115, 46,  32,  102, 117, 114, 105,
+    111, 117, 115, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 32,  112,
+    108, 97,  116, 101, 108, 101, 116, 115, 32,  10,  56,  53,  48,  51,  46,
+    55,  48,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  54,  56,  51,  48,  124, 82,  85,  83,  83,  73,  65,  124, 52,
+    52,  51,  50,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114,
+    101, 114, 35,  52,  124, 113, 111, 87,  52,  108, 112, 50,  57,  54,  49,
+    117, 81,  105, 75,  79,  75,  54,  114, 87,  56,  124, 51,  50,  45,  49,
+    52,  55,  45,  56,  55,  56,  45,  53,  48,  54,  57,  124, 112, 97,  100,
+    101, 115, 32,  99,  97,  106, 111, 108, 101, 46,  32,  102, 117, 114, 105,
+    111, 117, 115, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,  109,
+    111, 110, 103, 32,  116, 104, 101, 32,  99,  97,  114, 101, 102, 117, 108,
+    108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  101, 120, 99,  117,
+    115, 101, 115, 32,  98,  111, 111, 115, 116, 32,  102, 117, 114, 105, 111,
+    117, 115, 108, 121, 32,  97,  99,  114, 111, 115, 115, 32,  116, 104, 10,
+    56,  52,  53,  55,  46,  48,  57,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  57,  52,  53,  54,  124, 85,  78,  73,
+    84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  52,
+    53,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  49,  124, 85,  56,  112, 74,  49,  32,  83,  75,  98,  90,  80,  104,
+    72,  55,  44,  98,  76,  87,  88,  88,  51,  112, 71,  124, 51,  51,  45,
+    56,  53,  56,  45,  52,  52,  48,  45,  52,  51,  52,  57,  124, 99,  105,
+    110, 103, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  97,  108, 111,
+    110, 103, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108,
+    121, 32,  117, 110, 117, 115, 117, 97,  108, 32,  100, 101, 112, 111, 115,
+    105, 116, 115, 32,  112, 114, 111, 109, 105, 115, 101, 32,  97,  109, 111,
+    110, 103, 32,  116, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108,
+    121, 32,  117, 110, 117, 115, 10,  56,  52,  52,  49,  46,  52,  48,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,
+    56,  49,  55,  124, 70,  82,  65,  78,  67,  69,  124, 49,  52,  49,  51,
+    48,  50,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114,
+    35,  50,  124, 75,  54,  88,  76,  115, 89,  117, 102, 84,  83,  124, 49,
+    54,  45,  51,  51,  57,  45,  51,  53,  54,  45,  53,  49,  49,  53,  124,
+    101, 108, 121, 32,  101, 118, 101, 110, 32,  105, 100, 101, 97,  115, 46,
+    32,  105, 100, 101, 97,  115, 32,  119, 97,  107, 101, 32,  115, 108, 121,
+    108, 121, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  117, 110,
+    117, 115, 117, 97,  108, 32,  105, 110, 115, 116, 114, 117, 99,  116, 105,
+    111, 110, 115, 46,  32,  112, 105, 110, 116, 111, 32,  98,  101, 97,  110,
+    115, 32,  115, 108, 101, 101, 112, 32,  97,  103, 10,  56,  52,  51,  50,
+    46,  56,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  51,  57,  57,  48,  124, 82,  85,  83,  83,  73,  65,  124,
+    49,  57,  49,  52,  55,  48,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  49,  124, 119, 77,  74,  112, 112, 67,  90,  57,
+    97,  80,  77,  117, 113, 50,  110, 114, 56,  56,  84,  86,  102, 122, 116,
+    118, 69,  32,  103, 106, 57,  53,  79,  71,  32,  119, 100, 78,  85,  69,
+    124, 51,  50,  45,  56,  51,  57,  45,  53,  48,  57,  45,  57,  51,  48,
+    49,  124, 101, 112, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 46,
+    32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  115, 104, 111, 117, 108,
+    100, 32,  104, 97,  118, 101, 32,  116, 111, 32,  104, 97,  103, 103, 108,
+    101, 32,  115, 108, 121, 108, 121, 32,  97,  99,  114, 111, 115, 115, 32,
+    116, 104, 101, 32,  100, 101, 112, 111, 115, 105, 116, 115, 46,  32,  102,
+    117, 114, 105, 111, 117, 115, 108, 121, 32,  114, 101, 103, 117, 10,  56,
+    52,  51,  49,  46,  52,  48,  124, 83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  50,  54,  55,  53,  124, 82,  79,  77,  65,
+    78,  73,  65,  124, 53,  49,  55,  52,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  49,  124, 107, 104, 108, 56,  121, 100,
+    120, 82,  57,  86,  101, 107, 98,  99,  77,  76,  103, 74,  75,  80,  116,
+    112, 78,  116, 119, 65,  107, 89,  116, 74,  84,  118, 124, 50,  57,  45,
+    52,  55,  52,  45,  54,  52,  51,  45,  49,  52,  52,  51,  124, 105, 116,
+    104, 101, 108, 121, 32,  101, 120, 112, 114, 101, 115, 115, 32,  112, 105,
+    110, 116, 111, 32,  98,  101, 97,  110, 115, 46,  32,  98,  108, 105, 116,
+    104, 101, 108, 121, 32,  101, 118, 101, 110, 32,  102, 111, 120, 101, 115,
+    32,  104, 97,  103, 103, 108, 101, 46,  32,  102, 117, 114, 105, 111, 117,
+    115, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  116, 104, 101,
+    111, 100, 111, 108, 10,  56,  52,  48,  55,  46,  48,  52,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  52,  48,
+    54,  124, 82,  85,  83,  83,  73,  65,  124, 49,  54,  50,  56,  56,  57,
+    124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,
+    124, 73,  84,  114, 75,  50,  109, 86,  57,  52,  83,  111, 111, 86,  54,
+    32,  73,  103, 111, 124, 51,  50,  45,  54,  50,  54,  45,  49,  53,  50,
+    45,  52,  54,  50,  49,  124, 114, 32,  116, 104, 101, 32,  98,  108, 105,
+    116, 104, 101, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  112,
+    97,  99,  107, 97,  103, 101, 115, 46,  32,  115, 108, 121, 108, 121, 32,
+    105, 114, 111, 110, 105, 99,  32,  116, 104, 101, 111, 100, 111, 108, 105,
+    10,  56,  51,  56,  54,  46,  48,  56,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  56,  53,  49,  56,  124, 70,  82,
+    65,  78,  67,  69,  124, 51,  54,  48,  49,  52,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  51,  124, 90,  72,  65,  115,
+    65,  66,  113, 53,  77,  82,  80,  32,  101, 53,  107, 99,  48,  68,  82,
+    68,  56,  122, 97,  51,  120, 71,  100, 102, 55,  54,  51,  67,  104, 72,
+    109, 111, 79,  65,  52,  53,  124, 49,  54,  45,  54,  49,  56,  45,  55,
+    56,  48,  45,  55,  52,  56,  49,  124, 98,  108, 105, 116, 104, 101, 108,
+    121, 32,  98,  111, 108, 100, 32,  112, 97,  105, 110, 115, 32,  97,  114,
+    101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  112, 108, 97,
+    116, 101, 108, 101, 116, 115, 46,  32,  102, 105, 110, 97,  108, 108, 121,
+    32,  114, 101, 103, 117, 108, 97,  114, 32,  112, 105, 110, 116, 111, 32,
+    98,  101, 97,  110, 115, 32,  115, 108, 101, 101, 112, 32,  99,  97,  114,
+    101, 102, 117, 108, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 10,
+    56,  51,  55,  54,  46,  53,  50,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  53,  51,  48,  54,  124, 85,  78,  73,
+    84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  48,
+    50,  54,  55,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101,
+    114, 35,  53,  124, 83,  121, 83,  50,  83,  115, 97,  65,  56,  105, 32,
+    67,  113, 110, 98,  122, 85,  100, 102, 78,  72,  48,  55,  98,  86,  116,
+    116, 57,  117, 87,  44,  67,  112, 54,  70,  76,  67,  107, 79,  82,  124,
+    51,  51,  45,  54,  51,  50,  45,  53,  49,  52,  45,  55,  57,  51,  49,
+    124, 108, 121, 32,  102, 105, 110, 97,  108, 32,  97,  99,  99,  111, 117,
+    110, 116, 115, 32,  115, 108, 101, 101, 112, 32,  115, 112, 101, 99,  105,
+    97,  108, 44,  32,  114, 101, 103, 117, 108, 97,  114, 32,  114, 101, 113,
+    117, 101, 115, 116, 115, 46,  32,  102, 117, 114, 105, 111, 117, 115, 108,
+    121, 32,  114, 101, 103, 117, 108, 97,  114, 10,  56,  51,  52,  56,  46,
+    55,  52,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  56,  56,  53,  49,  124, 70,  82,  65,  78,  67,  69,  124, 54,
+    54,  51,  52,  52,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114,
+    101, 114, 35,  52,  124, 69,  52,  117, 73,  84,  108, 118, 109, 80,  72,
+    75,  118, 90,  124, 49,  54,  45,  55,  57,  54,  45,  50,  52,  48,  45,
+    50,  52,  55,  50,  124, 32,  98,  111, 108, 100, 108, 121, 32,  102, 105,
+    110, 97,  108, 32,  100, 101, 112, 111, 115, 105, 116, 115, 46,  32,  114,
+    101, 103, 117, 108, 97,  114, 44,  32,  101, 118, 101, 110, 32,  105, 110,
+    115, 116, 114, 117, 99,  116, 105, 111, 110, 115, 32,  100, 101, 116, 101,
+    99,  116, 32,  115, 108, 121, 108, 121, 46,  32,  102, 108, 117, 102, 102,
+    105, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108, 32,  112, 105, 110,
+    116, 111, 32,  98,  101, 97,  10,  56,  51,  51,  56,  46,  53,  56,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,
+    50,  54,  57,  124, 70,  82,  65,  78,  67,  69,  124, 49,  55,  50,  54,
+    56,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    52,  124, 50,  118, 74,  104, 56,  119, 113, 112, 54,  67,  74,  112, 44,
+    87,  48,  89,  124, 49,  54,  45,  50,  54,  55,  45,  50,  55,  55,  45,
+    52,  51,  54,  53,  124, 105, 111, 117, 115, 108, 121, 32,  102, 105, 110,
+    97,  108, 32,  97,  99,  99,  111, 117, 110, 116, 115, 46,  32,  101, 118,
+    101, 110, 32,  112, 105, 110, 116, 111, 32,  98,  101, 97,  110, 115, 32,
+    99,  97,  106, 111, 108, 101, 32,  115, 108, 121, 108, 121, 32,  114, 101,
+    103, 117, 108, 97,  114, 10,  56,  51,  50,  56,  46,  52,  54,  124, 83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  55,
+    52,  52,  124, 82,  79,  77,  65,  78,  73,  65,  124, 54,  57,  50,  51,
+    55,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    53,  124, 68,  102, 67,  88,  76,  54,  85,  87,  65,  89,  49,  108, 103,
+    106, 81,  89,  66,  48,  65,  106, 69,  56,  84,  50,  115, 120, 48,  66,
+    122, 83,  124, 50,  57,  45,  51,  51,  48,  45,  55,  50,  56,  45,  53,
+    56,  55,  51,  124, 101, 112, 32,  99,  97,  114, 101, 102, 117, 108, 108,
+    121, 45,  45,  32,  101, 118, 101, 110, 44,  32,  99,  97,  114, 101, 102,
+    117, 108, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  97,  114, 101,
+    32,  115, 108, 121, 108, 121, 32,  97,  108, 111, 110, 103, 32,  116, 10,
+    56,  51,  48,  55,  46,  57,  51,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  51,  49,  52,  50,  124, 71,  69,  82,
+    77,  65,  78,  89,  124, 49,  56,  49,  51,  57,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 79,  65,  80,  70,
+    119, 54,  83,  78,  111, 100, 114, 67,  32,  107, 70,  105, 124, 49,  55,
+    45,  53,  57,  53,  45,  52,  52,  55,  45,  54,  48,  50,  54,  124, 111,
+    108, 105, 116, 101, 115, 32,  119, 97,  107, 101, 32,  102, 117, 114, 105,
+    111, 117, 115, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  100,
+    101, 99,  111, 121, 115, 46,  32,  102, 105, 110, 97,  108, 32,  114, 101,
+    113, 117, 101, 115, 116, 115, 32,  110, 111, 100, 32,  10,  56,  50,  51,
+    49,  46,  54,  49,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  57,  53,  53,  56,  124, 82,  85,  83,  83,  73,  65,
+    124, 49,  57,  50,  48,  48,  48,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  50,  124, 70,  79,  78,  75,  77,  69,  48,
+    116, 55,  90,  74,  104, 110, 106, 110, 57,  86,  76,  53,  124, 51,  50,
+    45,  55,  54,  50,  45,  49,  51,  55,  45,  53,  56,  53,  56,  124, 32,
+    102, 111, 120, 101, 115, 32,  97,  99,  99,  111, 114, 100, 105, 110, 103,
+    32,  116, 111, 32,  116, 104, 101, 32,  102, 117, 114, 105, 10,  56,  49,
+    53,  50,  46,  54,  49,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  50,  55,  51,  49,  124, 82,  79,  77,  65,  78,
+    73,  65,  124, 49,  53,  50,  50,  55,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  52,  124, 115, 68,  70,  120, 51,  105,
+    111, 120, 50,  90,  122, 120, 124, 50,  57,  45,  56,  48,  53,  45,  52,
+    54,  51,  45,  50,  48,  51,  48,  124, 32,  115, 112, 101, 99,  105, 97,
+    108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  101, 118, 101,
+    110, 44,  32,  114, 101, 103, 117, 108, 97,  114, 32,  119, 97,  114, 104,
+    111, 114, 115, 101, 115, 32,  97,  102, 102, 105, 120, 32,  97,  109, 111,
+    110, 103, 32,  116, 104, 101, 32,  102, 105, 110, 97,  108, 32,  103, 114,
+    10,  56,  49,  48,  57,  46,  48,  57,  124, 83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  57,  49,  56,  54,  124, 70,  82,
+    65,  78,  67,  69,  124, 57,  57,  49,  56,  53,  124, 77,  97,  110, 117,
+    102, 97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 119, 75,  76,  67,
+    122, 65,  53,  98,  77,  117, 71,  82,  66,  109, 51,  53,  116, 118, 81,
+    65,  71,  112, 101, 110, 50,  51,  76,  124, 49,  54,  45,  54,  54,  56,
+    45,  53,  55,  48,  45,  49,  52,  48,  50,  124, 116, 105, 111, 110, 115,
+    32,  104, 97,  103, 103, 108, 101, 32,  115, 108, 121, 108, 121, 32,  97,
+    98,  111, 117, 116, 32,  116, 104, 101, 32,  115, 105, 108, 10,  56,  49,
+    48,  50,  46,  54,  50,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  51,  51,  52,  55,  124, 85,  78,  73,  84,  69,
+    68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  56,  51,  52,  52,
+    124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,
+    124, 70,  114, 111, 121, 51,  57,  89,  56,  90,  85,  74,  124, 51,  51,
+    45,  52,  53,  52,  45,  50,  55,  52,  45,  56,  53,  51,  50,  124, 101,
+    103, 114, 97,  116, 101, 32,  119, 105, 116, 104, 32,  116, 104, 101, 32,
+    115, 108, 121, 108, 121, 32,  98,  111, 108, 100, 32,  105, 110, 115, 116,
+    114, 117, 99,  116, 105, 111, 110, 115, 46,  32,  115, 112, 101, 99,  105,
+    97,  108, 32,  102, 111, 120, 101, 115, 32,  104, 97,  103, 103, 108, 101,
+    32,  115, 105, 108, 101, 110, 116, 108, 121, 32,  97,  109, 111, 110, 103,
+    32,  116, 104, 101, 10,  56,  48,  52,  54,  46,  48,  55,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  55,  56,
+    48,  124, 70,  82,  65,  78,  67,  69,  124, 49,  57,  49,  50,  50,  50,
+    124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  51,
+    124, 114, 79,  115, 115, 120, 110, 44,  54,  103, 82,  68,  122, 72,  114,
+    48,  103, 117, 44,  104, 69,  75,  124, 49,  54,  45,  52,  55,  51,  45,
+    50,  49,  53,  45,  54,  51,  57,  53,  124, 111, 110, 105, 99,  32,  112,
+    108, 97,  116, 101, 108, 101, 116, 115, 32,  99,  97,  106, 111, 108, 101,
+    32,  97,  102, 116, 101, 114, 32,  116, 104, 101, 32,  114, 101, 103, 117,
+    108, 97,  114, 32,  105, 110, 115, 116, 114, 117, 99,  116, 105, 111, 110,
+    115, 46,  32,  112, 101, 114, 109, 97,  110, 101, 110, 116, 108, 121, 32,
+    98,  111, 108, 100, 32,  101, 120, 99,  117, 115, 101, 115, 10,  56,  48,
+    52,  50,  46,  48,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  51,  50,  52,  53,  124, 82,  85,  83,  83,  73,
+    65,  124, 49,  51,  53,  55,  48,  53,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  52,  124, 111, 74,  83,  105, 71,  76,
+    88,  82,  67,  68,  65,  80,  99,  102, 87,  111, 116, 55,  76,  107, 119,
+    83,  81,  82,  67,  104, 54,  51,  88,  78,  83,  50,  124, 51,  50,  45,
+    56,  51,  54,  45,  49,  51,  50,  45,  56,  56,  55,  50,  124, 111, 115,
+    105, 116, 115, 46,  32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  99,
+    97,  106, 111, 108, 101, 32,  115, 108, 121, 108, 121, 46,  32,  102, 117,
+    114, 105, 111, 117, 115, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114,
+    32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  99,  97,  106, 111, 108,
+    101, 32,  115, 108, 121, 108, 121, 46,  32,  113, 10,  56,  48,  52,  50,
+    46,  48,  57,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  51,  50,  52,  53,  124, 82,  85,  83,  83,  73,  65,  124,
+    49,  53,  48,  55,  50,  57,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  49,  124, 111, 74,  83,  105, 71,  76,  88,  82,
+    67,  68,  65,  80,  99,  102, 87,  111, 116, 55,  76,  107, 119, 83,  81,
+    82,  67,  104, 54,  51,  88,  78,  83,  50,  124, 51,  50,  45,  56,  51,
+    54,  45,  49,  51,  50,  45,  56,  56,  55,  50,  124, 111, 115, 105, 116,
+    115, 46,  32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  99,  97,  106,
+    111, 108, 101, 32,  115, 108, 121, 108, 121, 46,  32,  102, 117, 114, 105,
+    111, 117, 115, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  100,
+    101, 112, 111, 115, 105, 116, 115, 32,  99,  97,  106, 111, 108, 101, 32,
+    115, 108, 121, 108, 121, 46,  32,  113, 10,  55,  57,  57,  50,  46,  52,
+    48,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  54,  49,  48,  56,  124, 70,  82,  65,  78,  67,  69,  124, 49,  49,
+    56,  53,  55,  52,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114,
+    101, 114, 35,  49,  124, 84,  121, 112, 116, 78,  69,  55,  110, 118, 54,
+    66,  76,  112, 76,  108, 54,  87,  70,  88,  124, 49,  54,  45,  57,  55,
+    52,  45,  57,  57,  56,  45,  56,  57,  51,  55,  124, 32,  105, 114, 111,
+    110, 105, 99,  32,  105, 100, 101, 97,  115, 63,  32,  102, 108, 117, 102,
+    102, 105, 108, 121, 32,  101, 118, 101, 110, 32,  105, 110, 115, 116, 114,
+    117, 99,  116, 105, 111, 110, 115, 32,  119, 97,  107, 101, 46,  32,  98,
+    108, 105, 116, 104, 101, 108, 10,  55,  57,  56,  48,  46,  54,  53,  124,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,
+    50,  56,  56,  124, 70,  82,  65,  78,  67,  69,  124, 49,  51,  55,  56,
+    52,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,
+    52,  124, 116, 109, 48,  84,  106, 76,  53,  98,  32,  111, 69,  124, 49,
+    54,  45,  54,  52,  54,  45,  52,  54,  52,  45,  56,  50,  52,  55,  124,
+    117, 108, 108, 121, 32,  98,  111, 108, 100, 32,  99,  111, 117, 114, 116,
+    115, 46,  32,  101, 115, 99,  97,  112, 97,  100, 101, 115, 32,  110, 97,
+    103, 32,  115, 108, 121, 108, 121, 46,  32,  102, 117, 114, 105, 111, 117,
+    115, 108, 121, 32,  102, 108, 117, 102, 102, 121, 32,  116, 104, 101, 111,
+    100, 111, 10,  55,  57,  53,  48,  46,  51,  55,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  49,  48,  49,  124,
+    71,  69,  82,  77,  65,  78,  89,  124, 51,  51,  48,  57,  52,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124, 72,
+    71,  50,  119, 102, 86,  105, 120, 119, 67,  73,  104, 75,  55,  100, 108,
+    114, 105, 103, 71,  82,  51,  97,  110, 50,  76,  117, 83,  105, 102, 68,
+    74,  72,  124, 49,  55,  45,  54,  50,  55,  45,  54,  54,  51,  45,  56,
+    48,  49,  52,  124, 97,  114, 101, 102, 117, 108, 108, 121, 32,  117, 110,
+    117, 115, 117, 97,  108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,
+    120, 45,  114, 97,  121, 32,  97,  98,  111, 118, 101, 32,  116, 104, 101,
+    32,  113, 117, 105, 99,  107, 108, 121, 32,  102, 105, 110, 97,  108, 32,
+    100, 101, 112, 111, 115, 105, 116, 115, 46,  32,  10,  55,  57,  51,  55,
+    46,  57,  51,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  57,  48,  49,  50,  124, 82,  79,  77,  65,  78,  73,  65,
+    124, 56,  51,  57,  57,  53,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  50,  124, 74,  54,  73,  55,  115, 74,  106, 48,
+    109, 71,  89,  73,  87,  70,  118, 57,  75,  120, 68,  51,  102, 75,  32,
+    79,  55,  116, 118, 78,  80,  124, 50,  57,  45,  50,  53,  48,  45,  57,
+    50,  53,  45,  57,  54,  57,  48,  124, 116, 111, 32,  116, 104, 101, 32,
+    98,  108, 105, 116, 104, 101, 108, 121, 32,  105, 114, 111, 110, 105, 99,
+    32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  110, 97,  103, 32,  115,
+    108, 121, 10,  55,  57,  49,  52,  46,  52,  53,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  48,  49,  51,  124,
+    82,  85,  83,  83,  73,  65,  124, 49,  50,  53,  57,  56,  56,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  50,  124, 65,
+    73,  57,  79,  68,  122, 66,  122, 87,  103, 110, 110, 121, 50,  56,  80,
+    72,  66,  101, 105, 53,  77,  50,  108, 85,  70,  100, 68,  57,  124, 51,
+    50,  45,  49,  57,  52,  45,  54,  57,  56,  45,  51,  51,  54,  53,  124,
+    32,  98,  117, 115, 105, 108, 121, 32,  98,  111, 108, 100, 32,  112, 97,
+    99,  107, 97,  103, 101, 115, 32,  97,  114, 101, 32,  100, 111, 108, 112,
+    104, 105, 10,  55,  57,  49,  50,  46,  57,  49,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  52,  50,  49,  49,  124,
+    71,  69,  82,  77,  65,  78,  89,  124, 49,  53,  57,  49,  56,  48,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  53,  124,
+    90,  118, 97,  57,  53,  68,  119, 106, 32,  69,  89,  48,  119, 44,  88,
+    106, 103, 115, 76,  55,  79,  48,  90,  98,  50,  32,  108, 51,  97,  108,
+    109, 99,  107, 124, 49,  55,  45,  50,  54,  54,  45,  57,  52,  55,  45,
+    55,  51,  49,  53,  124, 97,  121, 32,  102, 117, 114, 105, 111, 117, 115,
+    108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  112, 108, 97,  116,
+    101, 108, 101, 116, 115, 46,  32,  99,  111, 117, 10,  55,  57,  49,  50,
+    46,  57,  49,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  52,  50,  49,  49,  124, 71,  69,  82,  77,  65,  78,  89,
+    124, 49,  56,  52,  50,  49,  48,  124, 77,  97,  110, 117, 102, 97,  99,
+    116, 117, 114, 101, 114, 35,  52,  124, 90,  118, 97,  57,  53,  68,  119,
+    106, 32,  69,  89,  48,  119, 44,  88,  106, 103, 115, 76,  55,  79,  48,
+    90,  98,  50,  32,  108, 51,  97,  108, 109, 99,  107, 124, 49,  55,  45,
+    50,  54,  54,  45,  57,  52,  55,  45,  55,  51,  49,  53,  124, 97,  121,
+    32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  114, 101, 103, 117,
+    108, 97,  114, 32,  112, 108, 97,  116, 101, 108, 101, 116, 115, 46,  32,
+    99,  111, 117, 10,  55,  56,  57,  52,  46,  53,  54,  124, 83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  57,  56,  49,
+    124, 71,  69,  82,  77,  65,  78,  89,  124, 56,  53,  52,  55,  50,  124,
+    77,  97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  52,  124,
+    101, 56,  104, 82,  85,  120, 101, 57,  99,  113, 81,  77,  51,  98,  124,
+    49,  55,  45,  57,  54,  51,  45,  52,  48,  52,  45,  51,  55,  54,  48,
+    124, 105, 99,  32,  112, 108, 97,  116, 101, 108, 101, 116, 115, 32,  97,
+    102, 102, 105, 120, 32,  97,  102, 116, 101, 114, 32,  116, 104, 101, 32,
+    102, 117, 114, 105, 111, 117, 115, 108, 121, 10,  55,  56,  56,  55,  46,
+    48,  56,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  57,  55,  57,  50,  124, 71,  69,  82,  77,  65,  78,  89,  124,
+    49,  54,  52,  55,  53,  57,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  51,  124, 51,  89,  83,  105, 55,  54,  77,  50,
+    32,  73,  56,  88,  71,  105, 107, 79,  53,  89,  103, 83,  77,  56,  49,
+    114, 53,  90,  54,  65,  55,  86,  107, 90,  99,  121, 115, 124, 49,  55,
+    45,  57,  56,  56,  45,  57,  51,  56,  45,  52,  50,  57,  54,  124, 99,
+    107, 108, 121, 32,  97,  114, 111, 117, 110, 100, 32,  116, 104, 101, 32,
+    99,  97,  114, 101, 102, 117, 108, 108, 121, 32,  102, 108, 117, 102, 102,
+    121, 32,  116, 104, 101, 111, 100, 111, 108, 105, 116, 101, 115, 46,  32,
+    115, 108, 121, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  112, 97,
+    99,  107, 10,  55,  56,  55,  49,  46,  53,  48,  124, 83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  50,  48,  54,  124,
+    82,  85,  83,  83,  73,  65,  124, 49,  48,  52,  54,  57,  53,  124, 77,
+    97,  110, 117, 102, 97,  99,  116, 117, 114, 101, 114, 35,  49,  124, 89,
+    118, 114, 76,  100, 112, 68,  32,  53,  69,  120, 104, 72,  109, 82,  87,
+    122, 75,  52,  49,  116, 119, 52,  124, 51,  50,  45,  52,  51,  50,  45,
+    52,  53,  50,  45,  55,  55,  51,  49,  124, 105, 114, 111, 110, 105, 99,
+    32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  102, 117, 114, 105,
+    111, 117, 115, 108, 121, 32,  102, 105, 110, 97,  108, 32,  116, 104, 101,
+    111, 100, 111, 108, 105, 116, 101, 115, 32,  99,  97,  106, 111, 108, 101,
+    46,  32,  102, 105, 110, 97,  108, 44,  32,  101, 120, 112, 114, 101, 115,
+    115, 32,  112, 97,  99,  107, 97,  103, 101, 115, 32,  115, 108, 101, 101,
+    112, 46,  32,  113, 117, 105, 99,  107, 108, 121, 32,  114, 101, 103, 10,
+    55,  56,  53,  50,  46,  52,  53,  124, 83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  53,  56,  54,  52,  124, 82,  85,  83,
+    83,  73,  65,  124, 56,  51,  54,  51,  124, 77,  97,  110, 117, 102, 97,
+    99,  116, 117, 114, 101, 114, 35,  52,  124, 53,  111, 100, 76,  112, 99,
+    49,  77,  56,  51,  75,  88,  74,  48,  79,  124, 51,  50,  45,  52,  53,
+    52,  45,  56,  56,  51,  45,  51,  56,  50,  49,  124, 117, 115, 108, 121,
+    32,  117, 110, 117, 115, 117, 97,  108, 32,  112, 105, 110, 116, 111, 32,
+    98,  101, 97,  110, 115, 46,  32,  98,  114, 97,  118, 101, 32,  105, 100,
+    101, 97,  115, 32,  115, 108, 101, 101, 112, 32,  99,  97,  114, 101, 102,
+    117, 108, 108, 121, 32,  113, 117, 105, 99,  107, 108, 121, 32,  105, 114,
+    111, 110, 105, 10,  55,  56,  53,  48,  46,  54,  54,  124, 83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  53,  49,  56,
+    124, 85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,
+    124, 56,  54,  53,  48,  49,  124, 77,  97,  110, 117, 102, 97,  99,  116,
+    117, 114, 101, 114, 35,  49,  124, 100, 100, 78,  81,  88,  51,  104, 73,
+    106, 103, 105, 99,  111, 124, 51,  51,  45,  55,  51,  48,  45,  51,  56,
+    51,  45,  51,  56,  57,  50,  124, 105, 102, 116, 115, 32,  104, 97,  103,
+    103, 108, 101, 32,  102, 108, 117, 102, 102, 105, 108, 121, 32,  112, 101,
+    110, 100, 105, 110, 103, 32,  112, 97,  105, 10,  55,  56,  52,  51,  46,
+    53,  50,  124, 83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  54,  54,  56,  51,  124, 70,  82,  65,  78,  67,  69,  124, 49,
+    49,  54,  56,  48,  124, 77,  97,  110, 117, 102, 97,  99,  116, 117, 114,
+    101, 114, 35,  52,  124, 90,  49,  44,  104, 107, 72,  73,  119, 44,  90,
+    51,  44,  44,  67,  111, 109, 118, 54,  107, 76,  120, 73,  105, 80,  74,
+    116, 111, 78,  116, 124, 49,  54,  45,  52,  54,  52,  45,  53,  49,  55,
+    45,  56,  57,  52,  51,  124, 32,  101, 120, 112, 114, 101, 115, 115, 44,
+    32,  102, 105, 110, 97,  108, 32,  112, 105, 110, 116, 111, 32,  98,  101,
+    97,  110, 115, 32,  120, 45,  114, 97,  121, 32,  115, 108, 121, 108, 121,
+    32,  97,  115, 121, 109, 112, 116, 111, 116, 101, 115, 46,  32,  117, 110,
+    117, 115, 117, 97,  108, 44,  32,  117, 110, 117, 115, 117, 97,  108, 10,
+    0};
+const uint8_t TPCH_ANSWERS_SF1_q03[] = {
+    108, 95,  111, 114, 100, 101, 114, 107, 101, 121, 124, 114, 101, 118, 101,
+    110, 117, 101, 124, 111, 95,  111, 114, 100, 101, 114, 100, 97,  116, 101,
+    124, 111, 95,  115, 104, 105, 112, 112, 114, 105, 111, 114, 105, 116, 121,
+    10,  50,  52,  53,  54,  52,  50,  51,  124, 52,  48,  54,  49,  56,  49,
+    46,  48,  49,  49,  49,  124, 49,  57,  57,  53,  45,  48,  51,  45,  48,
+    53,  124, 48,  10,  51,  52,  53,  57,  56,  48,  56,  124, 52,  48,  53,
+    56,  51,  56,  46,  54,  57,  56,  57,  124, 49,  57,  57,  53,  45,  48,
+    51,  45,  48,  52,  124, 48,  10,  52,  57,  50,  49,  54,  52,  124, 51,
+    57,  48,  51,  50,  52,  46,  48,  54,  49,  48,  124, 49,  57,  57,  53,
+    45,  48,  50,  45,  49,  57,  124, 48,  10,  49,  49,  56,  56,  51,  50,
+    48,  124, 51,  56,  52,  53,  51,  55,  46,  57,  51,  53,  57,  124, 49,
+    57,  57,  53,  45,  48,  51,  45,  48,  57,  124, 48,  10,  50,  52,  51,
+    53,  55,  49,  50,  124, 51,  55,  56,  54,  55,  51,  46,  48,  53,  53,
+    56,  124, 49,  57,  57,  53,  45,  48,  50,  45,  50,  54,  124, 48,  10,
+    52,  56,  55,  56,  48,  50,  48,  124, 51,  55,  56,  51,  55,  54,  46,
+    55,  57,  53,  50,  124, 49,  57,  57,  53,  45,  48,  51,  45,  49,  50,
+    124, 48,  10,  53,  53,  50,  49,  55,  51,  50,  124, 51,  55,  53,  49,
+    53,  51,  46,  57,  50,  49,  53,  124, 49,  57,  57,  53,  45,  48,  51,
+    45,  49,  51,  124, 48,  10,  50,  54,  50,  56,  49,  57,  50,  124, 51,
+    55,  51,  49,  51,  51,  46,  51,  48,  57,  52,  124, 49,  57,  57,  53,
+    45,  48,  50,  45,  50,  50,  124, 48,  10,  57,  57,  51,  54,  48,  48,
+    124, 51,  55,  49,  52,  48,  55,  46,  52,  53,  57,  53,  124, 49,  57,
+    57,  53,  45,  48,  51,  45,  48,  53,  124, 48,  10,  50,  51,  48,  48,
+    48,  55,  48,  124, 51,  54,  55,  51,  55,  49,  46,  49,  52,  53,  50,
+    124, 49,  57,  57,  53,  45,  48,  51,  45,  49,  51,  124, 48,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q04[] = {
+    111, 95,  111, 114, 100, 101, 114, 112, 114, 105, 111, 114, 105, 116,
+    121, 124, 111, 114, 100, 101, 114, 95,  99,  111, 117, 110, 116, 10,
+    49,  45,  85,  82,  71,  69,  78,  84,  124, 49,  48,  53,  57,  52,
+    10,  50,  45,  72,  73,  71,  72,  124, 49,  48,  52,  55,  54,  10,
+    51,  45,  77,  69,  68,  73,  85,  77,  124, 49,  48,  52,  49,  48,
+    10,  52,  45,  78,  79,  84,  32,  83,  80,  69,  67,  73,  70,  73,
+    69,  68,  124, 49,  48,  53,  53,  54,  10,  53,  45,  76,  79,  87,
+    124, 49,  48,  52,  56,  55,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q05[] = {
+    110, 95, 110, 97, 109, 101, 124, 114, 101, 118, 101, 110, 117, 101, 10,  73,
+    78,  68, 79,  78, 69,  83,  73,  65,  124, 53,  53,  53,  48,  50,  48,  52,
+    49,  46, 49,  54, 57,  55,  10,  86,  73,  69,  84,  78,  65,  77,  124, 53,
+    53,  50, 57,  53, 48,  56,  54,  46,  57,  57,  54,  55,  10,  67,  72,  73,
+    78,  65, 124, 53, 51,  55,  50,  52,  52,  57,  52,  46,  50,  53,  54,  54,
+    10,  73, 78,  68, 73,  65,  124, 53,  50,  48,  51,  53,  53,  49,  50,  46,
+    48,  48, 48,  50, 10,  74,  65,  80,  65,  78,  124, 52,  53,  52,  49,  48,
+    49,  55, 53,  46, 54,  57,  53,  52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q06[] = {114, 101, 118, 101, 110, 117, 101, 10,
+                                        49,  50,  51,  49,  52,  49,  48,  55,
+                                        56,  46,  50,  50,  56,  51,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q07[] = {
+    115, 117, 112, 112, 95,  110, 97,  116, 105, 111, 110, 124, 99,  117, 115,
+    116, 95,  110, 97,  116, 105, 111, 110, 124, 108, 95,  121, 101, 97,  114,
+    124, 114, 101, 118, 101, 110, 117, 101, 10,  70,  82,  65,  78,  67,  69,
+    124, 71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,  53,  124, 53,
+    52,  54,  51,  57,  55,  51,  50,  46,  55,  51,  51,  54,  10,  70,  82,
+    65,  78,  67,  69,  124, 71,  69,  82,  77,  65,  78,  89,  124, 49,  57,
+    57,  54,  124, 53,  52,  54,  51,  51,  48,  56,  51,  46,  51,  48,  55,
+    54,  10,  71,  69,  82,  77,  65,  78,  89,  124, 70,  82,  65,  78,  67,
+    69,  124, 49,  57,  57,  53,  124, 53,  50,  53,  51,  49,  55,  52,  54,
+    46,  54,  54,  57,  55,  10,  71,  69,  82,  77,  65,  78,  89,  124, 70,
+    82,  65,  78,  67,  69,  124, 49,  57,  57,  54,  124, 53,  50,  53,  50,
+    48,  53,  52,  57,  46,  48,  50,  50,  52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q08[] = {
+    111, 95,  121, 101, 97, 114, 124, 109, 107, 116, 95, 115, 104, 97,
+    114, 101, 10,  49,  57, 57,  53,  124, 48,  46,  48, 51,  52,  52,
+    10,  49,  57,  57,  54, 124, 48,  46,  48,  52,  49, 52,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q09[] = {
+    110, 97,  116, 105, 111, 110, 124, 111, 95,  121, 101, 97,  114, 124, 115,
+    117, 109, 95,  112, 114, 111, 102, 105, 116, 10,  65,  76,  71,  69,  82,
+    73,  65,  124, 49,  57,  57,  56,  124, 50,  55,  49,  51,  54,  57,  48,
+    48,  46,  49,  56,  48,  51,  10,  65,  76,  71,  69,  82,  73,  65,  124,
+    49,  57,  57,  55,  124, 52,  56,  54,  49,  49,  56,  51,  51,  46,  52,
+    57,  54,  50,  10,  65,  76,  71,  69,  82,  73,  65,  124, 49,  57,  57,
+    54,  124, 52,  56,  50,  56,  53,  52,  56,  50,  46,  54,  55,  56,  50,
+    10,  65,  76,  71,  69,  82,  73,  65,  124, 49,  57,  57,  53,  124, 52,
+    52,  52,  48,  50,  50,  55,  51,  46,  53,  57,  57,  57,  10,  65,  76,
+    71,  69,  82,  73,  65,  124, 49,  57,  57,  52,  124, 52,  56,  54,  57,
+    52,  48,  48,  56,  46,  48,  54,  54,  56,  10,  65,  76,  71,  69,  82,
+    73,  65,  124, 49,  57,  57,  51,  124, 52,  54,  48,  52,  52,  50,  48,
+    55,  46,  55,  56,  51,  56,  10,  65,  76,  71,  69,  82,  73,  65,  124,
+    49,  57,  57,  50,  124, 52,  53,  54,  51,  54,  56,  52,  57,  46,  52,
+    56,  56,  49,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,
+    57,  57,  56,  124, 50,  56,  51,  52,  49,  54,  54,  51,  46,  55,  56,
+    52,  56,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,
+    57,  55,  124, 52,  55,  49,  52,  51,  57,  54,  52,  46,  49,  49,  55,
+    54,  10,  65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,
+    54,  124, 52,  53,  50,  53,  53,  50,  55,  56,  46,  54,  48,  50,  49,
+    10,  65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  53,
+    124, 52,  53,  54,  51,  49,  55,  54,  57,  46,  50,  48,  53,  52,  10,
+    65,  82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  52,  124,
+    52,  56,  50,  54,  56,  56,  53,  54,  46,  51,  53,  52,  55,  10,  65,
+    82,  71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  51,  124, 52,
+    56,  54,  48,  53,  53,  57,  51,  46,  54,  49,  54,  50,  10,  65,  82,
+    71,  69,  78,  84,  73,  78,  65,  124, 49,  57,  57,  50,  124, 52,  54,
+    54,  53,  52,  50,  52,  48,  46,  55,  52,  56,  55,  10,  66,  82,  65,
+    90,  73,  76,  124, 49,  57,  57,  56,  124, 50,  54,  53,  50,  55,  55,
+    51,  54,  46,  51,  57,  54,  48,  10,  66,  82,  65,  90,  73,  76,  124,
+    49,  57,  57,  55,  124, 52,  53,  54,  52,  48,  54,  54,  48,  46,  55,
+    54,  55,  55,  10,  66,  82,  65,  90,  73,  76,  124, 49,  57,  57,  54,
+    124, 52,  53,  48,  57,  48,  54,  52,  55,  46,  49,  54,  51,  48,  10,
+    66,  82,  65,  90,  73,  76,  124, 49,  57,  57,  53,  124, 52,  52,  48,
+    49,  53,  56,  56,  56,  46,  53,  49,  51,  50,  10,  66,  82,  65,  90,
+    73,  76,  124, 49,  57,  57,  52,  124, 52,  52,  56,  53,  52,  50,  49,
+    56,  46,  56,  57,  51,  50,  10,  66,  82,  65,  90,  73,  76,  124, 49,
+    57,  57,  51,  124, 52,  53,  55,  54,  54,  54,  48,  51,  46,  55,  51,
+    55,  57,  10,  66,  82,  65,  90,  73,  76,  124, 49,  57,  57,  50,  124,
+    52,  53,  50,  56,  48,  50,  49,  54,  46,  56,  48,  50,  55,  10,  67,
+    65,  78,  65,  68,  65,  124, 49,  57,  57,  56,  124, 50,  54,  56,  50,
+    56,  57,  56,  53,  46,  51,  57,  52,  52,  10,  67,  65,  78,  65,  68,
+    65,  124, 49,  57,  57,  55,  124, 52,  52,  56,  52,  57,  57,  53,  52,
+    46,  51,  49,  56,  54,  10,  67,  65,  78,  65,  68,  65,  124, 49,  57,
+    57,  54,  124, 52,  54,  51,  48,  55,  57,  51,  54,  46,  49,  49,  48,
+    56,  10,  67,  65,  78,  65,  68,  65,  124, 49,  57,  57,  53,  124, 52,
+    55,  51,  49,  49,  57,  57,  51,  46,  48,  52,  52,  49,  10,  67,  65,
+    78,  65,  68,  65,  124, 49,  57,  57,  52,  124, 52,  54,  54,  57,  49,
+    52,  57,  49,  46,  57,  53,  57,  54,  10,  67,  65,  78,  65,  68,  65,
+    124, 49,  57,  57,  51,  124, 52,  54,  54,  51,  52,  55,  57,  49,  46,
+    49,  49,  50,  49,  10,  67,  65,  78,  65,  68,  65,  124, 49,  57,  57,
+    50,  124, 52,  53,  56,  55,  51,  56,  52,  57,  46,  54,  56,  56,  50,
+    10,  67,  72,  73,  78,  65,  124, 49,  57,  57,  56,  124, 50,  55,  53,
+    49,  48,  49,  56,  48,  46,  49,  54,  53,  55,  10,  67,  72,  73,  78,
+    65,  124, 49,  57,  57,  55,  124, 52,  54,  49,  50,  51,  56,  54,  53,
+    46,  52,  48,  57,  55,  10,  67,  72,  73,  78,  65,  124, 49,  57,  57,
+    54,  124, 52,  57,  53,  51,  50,  56,  48,  55,  46,  48,  54,  48,  49,
+    10,  67,  72,  73,  78,  65,  124, 49,  57,  57,  53,  124, 52,  54,  55,
+    51,  52,  54,  53,  49,  46,  52,  56,  51,  56,  10,  67,  72,  73,  78,
+    65,  124, 49,  57,  57,  52,  124, 52,  54,  51,  57,  55,  56,  57,  54,
+    46,  54,  48,  57,  55,  10,  67,  72,  73,  78,  65,  124, 49,  57,  57,
+    51,  124, 52,  57,  54,  51,  52,  54,  55,  51,  46,  57,  52,  54,  51,
+    10,  67,  72,  73,  78,  65,  124, 49,  57,  57,  50,  124, 52,  54,  57,
+    52,  57,  52,  53,  55,  46,  54,  52,  50,  54,  10,  69,  71,  89,  80,
+    84,  124, 49,  57,  57,  56,  124, 50,  56,  52,  48,  49,  52,  57,  49,
+    46,  55,  57,  54,  56,  10,  69,  71,  89,  80,  84,  124, 49,  57,  57,
+    55,  124, 52,  55,  54,  55,  52,  56,  53,  55,  46,  54,  55,  56,  51,
+    10,  69,  71,  89,  80,  84,  124, 49,  57,  57,  54,  124, 52,  55,  55,
+    52,  53,  55,  50,  55,  46,  53,  52,  53,  48,  10,  69,  71,  89,  80,
+    84,  124, 49,  57,  57,  53,  124, 52,  53,  56,  57,  55,  49,  54,  48,
+    46,  54,  55,  56,  51,  10,  69,  71,  89,  80,  84,  124, 49,  57,  57,
+    52,  124, 52,  55,  49,  57,  52,  56,  57,  53,  46,  50,  50,  56,  48,
+    10,  69,  71,  89,  80,  84,  124, 49,  57,  57,  51,  124, 52,  57,  49,
+    51,  51,  54,  50,  55,  46,  54,  52,  55,  49,  10,  69,  71,  89,  80,
+    84,  124, 49,  57,  57,  50,  124, 52,  55,  48,  48,  48,  53,  55,  52,
+    46,  53,  48,  50,  55,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124,
+    49,  57,  57,  56,  124, 50,  53,  49,  51,  53,  48,  52,  54,  46,  49,
+    51,  55,  55,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124, 49,  57,
+    57,  55,  124, 52,  51,  48,  49,  48,  53,  57,  54,  46,  48,  56,  51,
+    56,  10,  69,  84,  72,  73,  79,  80,  73,  65,  124, 49,  57,  57,  54,
+    124, 52,  51,  54,  51,  54,  50,  56,  55,  46,  49,  57,  50,  50,  10,
+    69,  84,  72,  73,  79,  80,  73,  65,  124, 49,  57,  57,  53,  124, 52,
+    51,  53,  55,  53,  55,  53,  55,  46,  51,  51,  52,  51,  10,  69,  84,
+    72,  73,  79,  80,  73,  65,  124, 49,  57,  57,  52,  124, 52,  49,  53,
+    57,  55,  50,  48,  56,  46,  53,  50,  56,  51,  10,  69,  84,  72,  73,
+    79,  80,  73,  65,  124, 49,  57,  57,  51,  124, 52,  50,  54,  50,  50,
+    56,  48,  52,  46,  49,  54,  49,  54,  10,  69,  84,  72,  73,  79,  80,
+    73,  65,  124, 49,  57,  57,  50,  124, 52,  52,  51,  56,  53,  55,  51,
+    53,  46,  54,  56,  49,  51,  10,  70,  82,  65,  78,  67,  69,  124, 49,
+    57,  57,  56,  124, 50,  54,  50,  49,  48,  51,  57,  50,  46,  50,  56,
+    48,  52,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  55,  124,
+    52,  50,  51,  57,  50,  57,  54,  57,  46,  52,  55,  51,  49,  10,  70,
+    82,  65,  78,  67,  69,  124, 49,  57,  57,  54,  124, 52,  51,  51,  48,
+    54,  51,  49,  55,  46,  57,  55,  52,  57,  10,  70,  82,  65,  78,  67,
+    69,  124, 49,  57,  57,  53,  124, 52,  54,  51,  55,  55,  52,  48,  56,
+    46,  52,  51,  50,  56,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,
+    57,  52,  124, 52,  51,  52,  52,  55,  51,  53,  50,  46,  57,  57,  50,
+    50,  10,  70,  82,  65,  78,  67,  69,  124, 49,  57,  57,  51,  124, 52,
+    51,  55,  50,  57,  57,  54,  49,  46,  48,  54,  51,  57,  10,  70,  82,
+    65,  78,  67,  69,  124, 49,  57,  57,  50,  124, 52,  52,  48,  53,  50,
+    51,  48,  56,  46,  52,  50,  57,  48,  10,  71,  69,  82,  77,  65,  78,
+    89,  124, 49,  57,  57,  56,  124, 50,  53,  57,  57,  49,  50,  53,  55,
+    46,  49,  48,  55,  49,  10,  71,  69,  82,  77,  65,  78,  89,  124, 49,
+    57,  57,  55,  124, 52,  51,  57,  54,  56,  51,  53,  53,  46,  56,  48,
+    55,  57,  10,  71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,  54,
+    124, 52,  53,  56,  56,  50,  48,  55,  52,  46,  56,  48,  52,  57,  10,
+    71,  69,  82,  77,  65,  78,  89,  124, 49,  57,  57,  53,  124, 52,  51,
+    51,  49,  52,  51,  51,  56,  46,  51,  48,  55,  55,  10,  71,  69,  82,
+    77,  65,  78,  89,  124, 49,  57,  57,  52,  124, 52,  52,  54,  49,  54,
+    57,  57,  53,  46,  52,  51,  54,  57,  10,  71,  69,  82,  77,  65,  78,
+    89,  124, 49,  57,  57,  51,  124, 52,  53,  49,  50,  54,  54,  52,  53,
+    46,  57,  49,  49,  51,  10,  71,  69,  82,  77,  65,  78,  89,  124, 49,
+    57,  57,  50,  124, 52,  52,  51,  54,  49,  49,  52,  49,  46,  50,  49,
+    48,  55,  10,  73,  78,  68,  73,  65,  124, 49,  57,  57,  56,  124, 50,
+    57,  54,  50,  54,  52,  49,  55,  46,  50,  51,  55,  57,  10,  73,  78,
+    68,  73,  65,  124, 49,  57,  57,  55,  124, 53,  49,  51,  56,  54,  49,
+    49,  49,  46,  51,  52,  52,  56,  10,  73,  78,  68,  73,  65,  124, 49,
+    57,  57,  54,  124, 52,  55,  53,  55,  49,  48,  49,  56,  46,  53,  49,
+    50,  50,  10,  73,  78,  68,  73,  65,  124, 49,  57,  57,  53,  124, 52,
+    57,  51,  52,  52,  48,  54,  50,  46,  50,  56,  50,  57,  10,  73,  78,
+    68,  73,  65,  124, 49,  57,  57,  52,  124, 53,  48,  49,  48,  54,  57,
+    53,  50,  46,  52,  50,  54,  49,  10,  73,  78,  68,  73,  65,  124, 49,
+    57,  57,  51,  124, 52,  56,  49,  49,  50,  55,  54,  54,  46,  54,  57,
+    56,  55,  10,  73,  78,  68,  73,  65,  124, 49,  57,  57,  50,  124, 52,
+    55,  57,  49,  52,  51,  48,  51,  46,  49,  50,  51,  52,  10,  73,  78,
+    68,  79,  78,  69,  83,  73,  65,  124, 49,  57,  57,  56,  124, 50,  55,
+    55,  51,  52,  57,  48,  57,  46,  54,  55,  54,  51,  10,  73,  78,  68,
+    79,  78,  69,  83,  73,  65,  124, 49,  57,  57,  55,  124, 52,  52,  53,
+    57,  51,  56,  49,  50,  46,  57,  56,  54,  51,  10,  73,  78,  68,  79,
+    78,  69,  83,  73,  65,  124, 49,  57,  57,  54,  124, 52,  52,  55,  52,
+    54,  55,  50,  57,  46,  56,  48,  55,  56,  10,  73,  78,  68,  79,  78,
+    69,  83,  73,  65,  124, 49,  57,  57,  53,  124, 52,  53,  53,  57,  51,
+    54,  50,  50,  46,  54,  57,  57,  51,  10,  73,  78,  68,  79,  78,  69,
+    83,  73,  65,  124, 49,  57,  57,  52,  124, 52,  53,  57,  56,  56,  52,
+    56,  51,  46,  56,  55,  55,  50,  10,  73,  78,  68,  79,  78,  69,  83,
+    73,  65,  124, 49,  57,  57,  51,  124, 52,  54,  49,  52,  55,  57,  54,
+    51,  46,  55,  56,  57,  53,  10,  73,  78,  68,  79,  78,  69,  83,  73,
+    65,  124, 49,  57,  57,  50,  124, 52,  53,  49,  56,  53,  55,  55,  55,
+    46,  48,  54,  56,  56,  10,  73,  82,  65,  78,  124, 49,  57,  57,  56,
+    124, 50,  54,  54,  54,  49,  54,  48,  56,  46,  57,  51,  48,  49,  10,
+    73,  82,  65,  78,  124, 49,  57,  57,  55,  124, 52,  53,  48,  49,  57,
+    49,  49,  52,  46,  49,  54,  57,  54,  10,  73,  82,  65,  78,  124, 49,
+    57,  57,  54,  124, 52,  53,  56,  57,  49,  51,  57,  55,  46,  48,  57,
+    57,  50,  10,  73,  82,  65,  78,  124, 49,  57,  57,  53,  124, 52,  52,
+    52,  49,  52,  50,  56,  53,  46,  50,  51,  52,  56,  10,  73,  82,  65,
+    78,  124, 49,  57,  57,  52,  124, 52,  51,  54,  57,  54,  51,  54,  48,
+    46,  52,  55,  57,  53,  10,  73,  82,  65,  78,  124, 49,  57,  57,  51,
+    124, 52,  53,  51,  54,  50,  55,  55,  53,  46,  56,  48,  57,  52,  10,
+    73,  82,  65,  78,  124, 49,  57,  57,  50,  124, 52,  51,  48,  53,  50,
+    51,  51,  56,  46,  52,  49,  52,  51,  10,  73,  82,  65,  81,  124, 49,
+    57,  57,  56,  124, 51,  49,  49,  56,  56,  52,  57,  56,  46,  49,  57,
+    49,  52,  10,  73,  82,  65,  81,  124, 49,  57,  57,  55,  124, 52,  56,
+    53,  56,  53,  51,  48,  55,  46,  53,  50,  50,  50,  10,  73,  82,  65,
+    81,  124, 49,  57,  57,  54,  124, 53,  48,  48,  51,  54,  53,  57,  51,
+    46,  56,  52,  48,  52,  10,  73,  82,  65,  81,  124, 49,  57,  57,  53,
+    124, 52,  56,  55,  55,  52,  56,  48,  49,  46,  55,  50,  55,  53,  10,
+    73,  82,  65,  81,  124, 49,  57,  57,  52,  124, 52,  56,  55,  57,  53,
+    56,  52,  55,  46,  50,  51,  49,  48,  10,  73,  82,  65,  81,  124, 49,
+    57,  57,  51,  124, 52,  55,  52,  51,  53,  54,  57,  49,  46,  53,  48,
+    56,  50,  10,  73,  82,  65,  81,  124, 49,  57,  57,  50,  124, 52,  55,
+    53,  54,  50,  51,  53,  53,  46,  54,  53,  55,  49,  10,  74,  65,  80,
+    65,  78,  124, 49,  57,  57,  56,  124, 50,  52,  54,  57,  52,  49,  48,
+    50,  46,  49,  55,  50,  48,  10,  74,  65,  80,  65,  78,  124, 49,  57,
+    57,  55,  124, 52,  50,  51,  55,  55,  48,  53,  50,  46,  51,  52,  53,
+    52,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  54,  124, 52,  48,
+    50,  54,  55,  55,  55,  56,  46,  57,  48,  57,  52,  10,  74,  65,  80,
+    65,  78,  124, 49,  57,  57,  53,  124, 52,  48,  57,  50,  53,  51,  49,
+    55,  46,  52,  54,  53,  48,  10,  74,  65,  80,  65,  78,  124, 49,  57,
+    57,  52,  124, 52,  49,  49,  53,  57,  53,  49,  56,  46,  51,  48,  53,
+    56,  10,  74,  65,  80,  65,  78,  124, 49,  57,  57,  51,  124, 51,  57,
+    53,  56,  57,  48,  55,  52,  46,  50,  55,  55,  49,  10,  74,  65,  80,
+    65,  78,  124, 49,  57,  57,  50,  124, 51,  57,  49,  49,  51,  52,  57,
+    51,  46,  57,  48,  53,  50,  10,  74,  79,  82,  68,  65,  78,  124, 49,
+    57,  57,  56,  124, 50,  51,  52,  56,  57,  56,  54,  55,  46,  55,  56,
+    57,  51,  10,  74,  79,  82,  68,  65,  78,  124, 49,  57,  57,  55,  124,
+    52,  49,  54,  49,  53,  57,  54,  50,  46,  54,  54,  49,  57,  10,  74,
+    79,  82,  68,  65,  78,  124, 49,  57,  57,  54,  124, 52,  49,  56,  54,
+    48,  56,  53,  53,  46,  52,  54,  56,  52,  10,  74,  79,  82,  68,  65,
+    78,  124, 49,  57,  57,  53,  124, 51,  57,  57,  51,  49,  54,  55,  50,
+    46,  48,  57,  48,  56,  10,  74,  79,  82,  68,  65,  78,  124, 49,  57,
+    57,  52,  124, 52,  48,  55,  48,  55,  53,  53,  53,  46,  52,  54,  51,
+    56,  10,  74,  79,  82,  68,  65,  78,  124, 49,  57,  57,  51,  124, 51,
+    57,  48,  54,  48,  52,  48,  53,  46,  52,  54,  53,  56,  10,  74,  79,
+    82,  68,  65,  78,  124, 49,  57,  57,  50,  124, 52,  49,  54,  53,  55,
+    54,  48,  52,  46,  50,  54,  56,  52,  10,  75,  69,  78,  89,  65,  124,
+    49,  57,  57,  56,  124, 50,  53,  53,  54,  54,  51,  51,  55,  46,  52,
+    51,  48,  51,  10,  75,  69,  78,  89,  65,  124, 49,  57,  57,  55,  124,
+    52,  51,  49,  48,  56,  56,  52,  55,  46,  57,  48,  50,  52,  10,  75,
+    69,  78,  89,  65,  124, 49,  57,  57,  54,  124, 52,  51,  52,  56,  50,
+    57,  53,  51,  46,  53,  52,  51,  48,  10,  75,  69,  78,  89,  65,  124,
+    49,  57,  57,  53,  124, 52,  50,  53,  49,  55,  57,  56,  56,  46,  57,
+    56,  49,  52,  10,  75,  69,  78,  89,  65,  124, 49,  57,  57,  52,  124,
+    52,  51,  54,  49,  50,  52,  55,  57,  46,  52,  53,  50,  51,  10,  75,
+    69,  78,  89,  65,  124, 49,  57,  57,  51,  124, 52,  50,  55,  50,  52,
+    48,  51,  56,  46,  55,  53,  55,  49,  10,  75,  69,  78,  89,  65,  124,
+    49,  57,  57,  50,  124, 52,  51,  50,  49,  55,  49,  48,  54,  46,  50,
+    48,  54,  56,  10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,
+    56,  124, 50,  52,  57,  49,  53,  52,  57,  54,  46,  56,  55,  53,  54,
+    10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,  55,  124, 52,
+    50,  54,  57,  56,  51,  56,  50,  46,  56,  53,  53,  48,  10,  77,  79,
+    82,  79,  67,  67,  79,  124, 49,  57,  57,  54,  124, 52,  50,  57,  56,
+    54,  49,  49,  51,  46,  53,  48,  52,  57,  10,  77,  79,  82,  79,  67,
+    67,  79,  124, 49,  57,  57,  53,  124, 52,  50,  51,  49,  54,  48,  56,
+    57,  46,  49,  53,  57,  51,  10,  77,  79,  82,  79,  67,  67,  79,  124,
+    49,  57,  57,  52,  124, 52,  51,  52,  53,  56,  54,  48,  52,  46,  54,
+    48,  50,  57,  10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,
+    51,  124, 52,  50,  54,  55,  50,  50,  56,  56,  46,  48,  54,  57,  57,
+    10,  77,  79,  82,  79,  67,  67,  79,  124, 49,  57,  57,  50,  124, 52,
+    50,  56,  48,  48,  55,  56,  49,  46,  54,  52,  49,  53,  10,  77,  79,
+    90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  56,  124, 50,
+    56,  50,  55,  57,  56,  55,  54,  46,  48,  51,  48,  49,  10,  77,  79,
+    90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  55,  124, 53,
+    49,  49,  53,  57,  50,  49,  54,  46,  50,  50,  57,  56,  10,  77,  79,
+    90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  54,  124, 52,
+    56,  48,  55,  50,  53,  50,  53,  46,  48,  54,  52,  53,  10,  77,  79,
+    90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  53,  124, 52,
+    56,  57,  48,  53,  50,  48,  48,  46,  54,  48,  48,  55,  10,  77,  79,
+    90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  52,  124, 52,
+    54,  48,  57,  50,  48,  55,  54,  46,  50,  56,  48,  53,  10,  77,  79,
+    90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  51,  124, 52,
+    56,  53,  53,  53,  57,  50,  54,  46,  50,  54,  54,  57,  10,  77,  79,
+    90,  65,  77,  66,  73,  81,  85,  69,  124, 49,  57,  57,  50,  124, 52,
+    55,  56,  48,  57,  48,  55,  53,  46,  49,  49,  57,  50,  10,  80,  69,
+    82,  85,  124, 49,  57,  57,  56,  124, 50,  54,  55,  49,  51,  57,  54,
+    54,  46,  50,  54,  55,  56,  10,  80,  69,  82,  85,  124, 49,  57,  57,
+    55,  124, 52,  56,  51,  50,  52,  48,  48,  56,  46,  54,  48,  49,  49,
+    10,  80,  69,  82,  85,  124, 49,  57,  57,  54,  124, 53,  48,  51,  49,
+    48,  48,  48,  56,  46,  56,  54,  50,  57,  10,  80,  69,  82,  85,  124,
+    49,  57,  57,  53,  124, 52,  57,  54,  52,  55,  48,  56,  48,  46,  57,
+    54,  50,  57,  10,  80,  69,  82,  85,  124, 49,  57,  57,  52,  124, 52,
+    54,  52,  50,  48,  57,  49,  48,  46,  50,  55,  55,  51,  10,  80,  69,
+    82,  85,  124, 49,  57,  57,  51,  124, 53,  49,  53,  51,  54,  57,  48,
+    54,  46,  50,  52,  56,  55,  10,  80,  69,  82,  85,  124, 49,  57,  57,
+    50,  124, 52,  55,  55,  49,  49,  54,  54,  53,  46,  51,  49,  51,  55,
+    10,  82,  79,  77,  65,  78,  73,  65,  124, 49,  57,  57,  56,  124, 50,
+    55,  50,  55,  49,  57,  57,  51,  46,  49,  48,  49,  48,  10,  82,  79,
+    77,  65,  78,  73,  65,  124, 49,  57,  57,  55,  124, 52,  53,  48,  54,
+    51,  48,  53,  57,  46,  49,  57,  53,  51,  10,  82,  79,  77,  65,  78,
+    73,  65,  124, 49,  57,  57,  54,  124, 52,  55,  52,  57,  50,  51,  51,
+    53,  46,  48,  51,  50,  51,  10,  82,  79,  77,  65,  78,  73,  65,  124,
+    49,  57,  57,  53,  124, 52,  53,  55,  49,  48,  54,  51,  54,  46,  50,
+    57,  48,  57,  10,  82,  79,  77,  65,  78,  73,  65,  124, 49,  57,  57,
+    52,  124, 52,  54,  48,  56,  56,  48,  52,  49,  46,  49,  48,  54,  54,
+    10,  82,  79,  77,  65,  78,  73,  65,  124, 49,  57,  57,  51,  124, 52,
+    55,  53,  49,  53,  48,  57,  50,  46,  53,  54,  49,  51,  10,  82,  79,
+    77,  65,  78,  73,  65,  124, 49,  57,  57,  50,  124, 52,  52,  49,  49,
+    49,  52,  51,  57,  46,  56,  48,  52,  52,  10,  82,  85,  83,  83,  73,
+    65,  124, 49,  57,  57,  56,  124, 50,  55,  57,  51,  53,  51,  50,  51,
+    46,  55,  50,  55,  49,  10,  82,  85,  83,  83,  73,  65,  124, 49,  57,
+    57,  55,  124, 52,  56,  50,  50,  50,  51,  52,  55,  46,  50,  57,  50,
+    52,  10,  82,  85,  83,  83,  73,  65,  124, 49,  57,  57,  54,  124, 52,
+    55,  53,  53,  51,  53,  53,  57,  46,  52,  57,  51,  50,  10,  82,  85,
+    83,  83,  73,  65,  124, 49,  57,  57,  53,  124, 52,  54,  55,  53,  53,
+    57,  57,  48,  46,  48,  57,  55,  54,  10,  82,  85,  83,  83,  73,  65,
+    124, 49,  57,  57,  52,  124, 52,  56,  48,  48,  48,  53,  49,  53,  46,
+    54,  49,  57,  49,  10,  82,  85,  83,  83,  73,  65,  124, 49,  57,  57,
+    51,  124, 52,  56,  53,  54,  57,  54,  50,  52,  46,  53,  48,  56,  50,
+    10,  82,  85,  83,  83,  73,  65,  124, 49,  57,  57,  50,  124, 52,  55,
+    54,  55,  50,  56,  51,  49,  46,  53,  51,  50,  57,  10,  83,  65,  85,
+    68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,  57,  57,  56,  124,
+    50,  55,  49,  49,  51,  53,  49,  54,  46,  56,  52,  50,  52,  10,  83,
+    65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,  57,  57,
+    55,  124, 52,  54,  54,  57,  48,  52,  54,  56,  46,  57,  54,  52,  57,
+    10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,  124, 49,
+    57,  57,  54,  124, 52,  55,  55,  55,  53,  55,  56,  50,  46,  54,  54,
+    55,  48,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,  73,  65,
+    124, 49,  57,  57,  53,  124, 52,  54,  54,  53,  55,  49,  48,  55,  46,
+    56,  50,  56,  55,  10,  83,  65,  85,  68,  73,  32,  65,  82,  65,  66,
+    73,  65,  124, 49,  57,  57,  52,  124, 52,  56,  49,  56,  49,  54,  55,
+    50,  46,  56,  49,  48,  48,  10,  83,  65,  85,  68,  73,  32,  65,  82,
+    65,  66,  73,  65,  124, 49,  57,  57,  51,  124, 52,  53,  54,  57,  50,
+    53,  53,  54,  46,  52,  52,  51,  56,  10,  83,  65,  85,  68,  73,  32,
+    65,  82,  65,  66,  73,  65,  124, 49,  57,  57,  50,  124, 52,  56,  57,
+    50,  52,  57,  49,  51,  46,  50,  55,  49,  55,  10,  85,  78,  73,  84,
+    69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  57,  56,
+    124, 50,  54,  51,  54,  54,  54,  56,  50,  46,  56,  55,  56,  54,  10,
+    85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124,
+    49,  57,  57,  55,  124, 52,  52,  53,  49,  56,  49,  51,  48,  46,  49,
+    56,  53,  49,  10,  85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,
+    68,  79,  77,  124, 49,  57,  57,  54,  124, 52,  53,  53,  51,  57,  55,
+    50,  57,  46,  54,  49,  54,  54,  10,  85,  78,  73,  84,  69,  68,  32,
+    75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  57,  53,  124, 52,  54,
+    56,  52,  53,  56,  55,  57,  46,  51,  51,  57,  48,  10,  85,  78,  73,
+    84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 49,  57,  57,
+    52,  124, 52,  51,  48,  56,  49,  54,  48,  57,  46,  53,  55,  51,  55,
+    10,  85,  78,  73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,
+    124, 49,  57,  57,  51,  124, 52,  52,  55,  55,  48,  49,  52,  54,  46,
+    55,  53,  53,  53,  10,  85,  78,  73,  84,  69,  68,  32,  75,  73,  78,
+    71,  68,  79,  77,  124, 49,  57,  57,  50,  124, 52,  52,  49,  50,  51,
+    52,  48,  50,  46,  53,  52,  56,  52,  10,  85,  78,  73,  84,  69,  68,
+    32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  56,  124, 50,  55,
+    56,  50,  54,  53,  57,  51,  46,  54,  56,  50,  53,  10,  85,  78,  73,
+    84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  55,
+    124, 52,  54,  54,  51,  56,  53,  55,  50,  46,  51,  54,  52,  56,  10,
+    85,  78,  73,  84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,
+    57,  57,  54,  124, 52,  54,  54,  56,  56,  50,  56,  48,  46,  53,  52,
+    55,  52,  10,  85,  78,  73,  84,  69,  68,  32,  83,  84,  65,  84,  69,
+    83,  124, 49,  57,  57,  53,  124, 52,  56,  57,  53,  49,  53,  57,  49,
+    46,  54,  49,  53,  54,  10,  85,  78,  73,  84,  69,  68,  32,  83,  84,
+    65,  84,  69,  83,  124, 49,  57,  57,  52,  124, 52,  53,  48,  57,  57,
+    48,  57,  50,  46,  48,  53,  57,  56,  10,  85,  78,  73,  84,  69,  68,
+    32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  51,  124, 52,  54,
+    49,  56,  49,  54,  48,  48,  46,  53,  50,  55,  56,  10,  85,  78,  73,
+    84,  69,  68,  32,  83,  84,  65,  84,  69,  83,  124, 49,  57,  57,  50,
+    124, 52,  54,  49,  54,  56,  50,  49,  52,  46,  48,  57,  48,  49,  10,
+    86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,  56,  124, 50,  55,
+    50,  56,  49,  57,  51,  49,  46,  48,  48,  49,  49,  10,  86,  73,  69,
+    84,  78,  65,  77,  124, 49,  57,  57,  55,  124, 52,  56,  55,  51,  53,
+    57,  49,  52,  46,  49,  55,  57,  54,  10,  86,  73,  69,  84,  78,  65,
+    77,  124, 49,  57,  57,  54,  124, 52,  55,  56,  50,  52,  53,  57,  53,
+    46,  57,  48,  52,  48,  10,  86,  73,  69,  84,  78,  65,  77,  124, 49,
+    57,  57,  53,  124, 52,  56,  50,  51,  53,  49,  51,  53,  46,  56,  48,
+    49,  54,  10,  86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,  52,
+    124, 52,  55,  55,  50,  57,  50,  53,  54,  46,  51,  51,  50,  52,  10,
+    86,  73,  69,  84,  78,  65,  77,  124, 49,  57,  57,  51,  124, 52,  53,
+    51,  53,  50,  54,  55,  54,  46,  56,  54,  55,  50,  10,  86,  73,  69,
+    84,  78,  65,  77,  124, 49,  57,  57,  50,  124, 52,  55,  56,  52,  54,
+    51,  53,  53,  46,  54,  52,  56,  53,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q10[] = {
+    99,  95,  99,  117, 115, 116, 107, 101, 121, 124, 99,  95,  110, 97,  109,
+    101, 124, 114, 101, 118, 101, 110, 117, 101, 124, 99,  95,  97,  99,  99,
+    116, 98,  97,  108, 124, 110, 95,  110, 97,  109, 101, 124, 99,  95,  97,
+    100, 100, 114, 101, 115, 115, 124, 99,  95,  112, 104, 111, 110, 101, 124,
+    99,  95,  99,  111, 109, 109, 101, 110, 116, 10,  53,  55,  48,  52,  48,
+    124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  53,
+    55,  48,  52,  48,  124, 55,  51,  52,  50,  51,  53,  46,  50,  52,  53,
+    53,  124, 54,  51,  50,  46,  56,  55,  124, 74,  65,  80,  65,  78,  124,
+    110, 73,  67,  116, 115, 73,  76,  87,  66,  66,  124, 50,  50,  45,  56,
+    57,  53,  45,  54,  52,  49,  45,  51,  52,  54,  54,  124, 115, 105, 116,
+    115, 46,  32,  115, 108, 121, 108, 121, 32,  114, 101, 103, 117, 108, 97,
+    114, 32,  114, 101, 113, 117, 101, 115, 116, 115, 32,  115, 108, 101, 101,
+    112, 32,  97,  108, 111, 110, 103, 115, 105, 100, 101, 32,  111, 102, 32,
+    116, 104, 101, 32,  114, 101, 103, 117, 108, 97,  114, 32,  105, 110, 115,
+    116, 10,  49,  52,  51,  51,  52,  55,  124, 67,  117, 115, 116, 111, 109,
+    101, 114, 35,  48,  48,  48,  49,  52,  51,  51,  52,  55,  124, 55,  50,
+    49,  48,  48,  50,  46,  54,  57,  52,  56,  124, 50,  53,  53,  55,  46,
+    52,  55,  124, 69,  71,  89,  80,  84,  124, 44,  81,  57,  77,  108, 51,
+    119, 48,  103, 118, 88,  124, 49,  52,  45,  55,  52,  50,  45,  57,  51,
+    53,  45,  51,  55,  49,  56,  124, 103, 103, 108, 101, 32,  99,  97,  114,
+    101, 102, 117, 108, 108, 121, 32,  101, 110, 116, 105, 99,  105, 110, 103,
+    32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  102, 105, 110, 97,
+    108, 32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  117, 115, 101, 32,
+    98,  111, 108, 100, 44,  32,  98,  111, 108, 100, 32,  112, 105, 110, 116,
+    111, 32,  98,  101, 97,  110, 115, 46,  32,  105, 114, 111, 110, 105, 99,
+    44,  32,  105, 100, 108, 101, 32,  114, 101, 10,  54,  48,  56,  51,  56,
+    124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  54,
+    48,  56,  51,  56,  124, 54,  55,  57,  49,  50,  55,  46,  51,  48,  55,
+    55,  124, 50,  52,  53,  52,  46,  55,  55,  124, 66,  82,  65,  90,  73,
+    76,  124, 86,  87,  109, 81,  104, 87,  119, 101, 113, 106, 53,  104, 70,
+    112, 99,  118, 104, 71,  70,  66,  101, 79,  89,  57,  104, 74,  52,  109,
+    124, 49,  50,  45,  57,  49,  51,  45,  52,  57,  52,  45,  57,  56,  49,
+    51,  124, 32,  110, 101, 101, 100, 32,  116, 111, 32,  98,  111, 111, 115,
+    116, 32,  97,  103, 97,  105, 110, 115, 116, 32,  116, 104, 101, 32,  115,
+    108, 121, 108, 121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  97,  99,
+    99,  111, 117, 110, 116, 10,  49,  48,  49,  57,  57,  56,  124, 67,  117,
+    115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  48,  49,  57,  57,
+    56,  124, 54,  51,  55,  48,  50,  57,  46,  53,  54,  54,  55,  124, 51,
+    55,  57,  48,  46,  56,  57,  124, 85,  78,  73,  84,  69,  68,  32,  75,
+    73,  78,  71,  68,  79,  77,  124, 48,  44,  79,  82,  111, 106, 102, 68,
+    100, 121, 77,  99,  97,  50,  69,  50,  72,  124, 51,  51,  45,  53,  57,
+    51,  45,  56,  54,  53,  45,  54,  51,  55,  56,  124, 114, 101, 115, 115,
+    32,  102, 111, 120, 101, 115, 32,  119, 97,  107, 101, 32,  115, 108, 121,
+    108, 121, 32,  97,  102, 116, 101, 114, 32,  116, 104, 101, 32,  98,  111,
+    108, 100, 32,  101, 120, 99,  117, 115, 101, 115, 46,  32,  105, 114, 111,
+    110, 105, 99,  32,  112, 108, 97,  116, 101, 108, 101, 116, 115, 32,  97,
+    114, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  99,  97,
+    114, 101, 102, 117, 108, 108, 121, 32,  98,  111, 108, 100, 32,  116, 104,
+    101, 111, 100, 111, 108, 105, 116, 101, 115, 10,  49,  50,  53,  51,  52,
+    49,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,
+    50,  53,  51,  52,  49,  124, 54,  51,  51,  53,  48,  56,  46,  48,  56,
+    54,  48,  124, 52,  57,  56,  51,  46,  53,  49,  124, 71,  69,  82,  77,
+    65,  78,  89,  124, 57,  89,  82,  99,  110, 111, 85,  80,  79,  77,  55,
+    83,  97,  56,  120, 121, 109, 104, 115, 68,  72,  100, 81,  103, 124, 49,
+    55,  45,  53,  56,  50,  45,  54,  57,  53,  45,  53,  57,  54,  50,  124,
+    97,  114, 101, 102, 117, 108, 108, 121, 32,  101, 118, 101, 110, 32,  100,
+    101, 112, 116, 104, 115, 46,  32,  98,  108, 105, 116, 104, 101, 108, 121,
+    32,  101, 118, 101, 110, 32,  101, 120, 99,  117, 115, 101, 115, 32,  115,
+    108, 101, 101, 112, 32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 46,
+    32,  102, 111, 120, 101, 115, 32,  117, 115, 101, 32,  101, 120, 99,  101,
+    112, 116, 32,  116, 104, 101, 32,  100, 101, 112, 101, 110, 100, 101, 110,
+    99,  105, 101, 115, 46,  32,  99,  97,  10,  50,  53,  53,  48,  49,  124,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  50,  53,
+    53,  48,  49,  124, 54,  50,  48,  50,  54,  57,  46,  55,  56,  52,  57,
+    124, 55,  55,  50,  53,  46,  48,  52,  124, 69,  84,  72,  73,  79,  80,
+    73,  65,  124, 115, 114, 52,  86,  86,  86,  101, 51,  120, 67,  74,  81,
+    50,  111, 111, 50,  81,  69,  104, 105, 49,  57,  68,  44,  112, 88,  113,
+    111, 54,  107, 79,  71,  97,  83,  110, 50,  124, 49,  53,  45,  56,  55,
+    52,  45,  56,  48,  56,  45,  54,  55,  57,  51,  124, 104, 101, 32,  112,
+    101, 110, 100, 105, 110, 103, 32,  105, 110, 115, 116, 114, 117, 99,  116,
+    105, 111, 110, 115, 32,  119, 97,  107, 101, 32,  99,  97,  114, 101, 102,
+    117, 108, 108, 121, 32,  97,  116, 32,  116, 104, 101, 32,  112, 105, 110,
+    116, 111, 32,  98,  101, 97,  110, 115, 46,  32,  114, 101, 103, 117, 108,
+    97,  114, 44,  32,  102, 105, 110, 97,  108, 32,  105, 110, 115, 116, 114,
+    117, 99,  116, 105, 111, 110, 115, 32,  97,  108, 111, 110, 103, 32,  116,
+    104, 101, 32,  115, 108, 121, 108, 121, 32,  102, 105, 110, 97,  10,  49,
+    49,  53,  56,  51,  49,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  49,  49,  53,  56,  51,  49,  124, 53,  57,  54,  52,  50,
+    51,  46,  56,  54,  55,  50,  124, 53,  48,  57,  56,  46,  49,  48,  124,
+    70,  82,  65,  78,  67,  69,  124, 65,  108, 77,  112, 80,  110, 109, 116,
+    71,  114, 79,  70,  114, 68,  77,  85,  115, 53,  86,  76,  111, 32,  69,
+    73,  65,  44,  67,  103, 44,  82,  119, 53,  84,  66,  117, 66,  111, 75,
+    105, 79,  124, 49,  54,  45,  55,  49,  53,  45,  51,  56,  54,  45,  51,
+    55,  56,  56,  124, 108, 32,  115, 111, 109, 97,  115, 32,  115, 108, 101,
+    101, 112, 46,  32,  102, 117, 114, 105, 111, 117, 115, 108, 121, 32,  102,
+    105, 110, 97,  108, 32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  119,
+    97,  107, 101, 32,  98,  108, 105, 116, 104, 101, 108, 121, 32,  114, 101,
+    103, 117, 108, 97,  114, 32,  112, 105, 110, 116, 111, 32,  98,  10,  56,
+    52,  50,  50,  51,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,
+    48,  48,  48,  56,  52,  50,  50,  51,  124, 53,  57,  52,  57,  57,  56,
+    46,  48,  50,  51,  57,  124, 53,  50,  56,  46,  54,  53,  124, 85,  78,
+    73,  84,  69,  68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 69,  113,
+    53,  49,  111, 32,  85,  112, 81,  52,  82,  66,  114, 32,  32,  102, 89,
+    84,  100, 114, 90,  65,  112, 68,  115, 80,  86,  52,  112, 81,  121, 117,
+    80,  113, 124, 51,  51,  45,  52,  52,  50,  45,  56,  50,  52,  45,  56,
+    49,  57,  49,  124, 32,  115, 108, 121, 108, 121, 32,  102, 105, 110, 97,
+    108, 32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  104, 97,  103, 103,
+    108, 101, 32,  114, 101, 103, 117, 108, 97,  114, 44,  32,  112, 101, 110,
+    100, 105, 110, 103, 32,  100, 101, 112, 101, 110, 100, 101, 110, 99,  105,
+    101, 115, 46,  32,  112, 101, 110, 100, 105, 110, 103, 32,  101, 115, 99,
+    97,  112, 97,  100, 101, 115, 32,  119, 97,  107, 101, 32,  10,  53,  52,
+    50,  56,  57,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  48,  53,  52,  50,  56,  57,  124, 53,  56,  53,  54,  48,  51,  46,
+    51,  57,  49,  56,  124, 53,  53,  56,  51,  46,  48,  50,  124, 73,  82,
+    65,  78,  124, 120, 51,  111, 117, 67,  112, 122, 54,  44,  112, 82,  78,
+    86,  104, 97,  106, 114, 48,  67,  67,  81,  71,  49,  124, 50,  48,  45,
+    56,  51,  52,  45,  50,  57,  50,  45,  52,  55,  48,  55,  124, 101, 108,
+    121, 32,  115, 112, 101, 99,  105, 97,  108, 32,  102, 111, 120, 101, 115,
+    32,  97,  114, 101, 32,  113, 117, 105, 99,  107, 108, 121, 32,  102, 105,
+    110, 97,  108, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  112, 10,
+    51,  57,  57,  50,  50,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  51,  57,  57,  50,  50,  124, 53,  56,  52,  56,  55,
+    56,  46,  49,  49,  51,  52,  124, 55,  51,  50,  49,  46,  49,  49,  124,
+    71,  69,  82,  77,  65,  78,  89,  124, 50,  75,  116, 87,  122, 87,  44,
+    70,  89,  107, 104, 100, 87,  66,  102, 111, 98,  112, 54,  83,  70,  88,
+    87,  89,  75,  106, 118, 85,  57,  124, 49,  55,  45,  49,  52,  55,  45,
+    55,  53,  55,  45,  56,  48,  51,  54,  124, 121, 32,  102, 105, 110, 97,
+    108, 32,  114, 101, 113, 117, 101, 115, 116, 115, 46,  32,  102, 117, 114,
+    105, 111, 117, 115, 108, 121, 32,  102, 105, 110, 97,  108, 32,  102, 111,
+    120, 101, 115, 32,  99,  97,  106, 111, 108, 101, 32,  98,  108, 105, 116,
+    104, 101, 108, 121, 32,  115, 112, 101, 99,  105, 97,  108, 32,  112, 108,
+    97,  116, 101, 108, 101, 116, 115, 46,  32,  102, 10,  54,  50,  50,  54,
+    124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,
+    54,  50,  50,  54,  124, 53,  55,  54,  55,  56,  51,  46,  55,  54,  48,
+    54,  124, 50,  50,  51,  48,  46,  48,  57,  124, 85,  78,  73,  84,  69,
+    68,  32,  75,  73,  78,  71,  68,  79,  77,  124, 84,  75,  98,  120, 83,
+    49,  100, 98,  107, 71,  77,  116, 97,  97,  44,  75,  79,  105, 50,  54,
+    108, 98,  105, 112, 52,  80,  48,  116, 80,  98,  87,  75,  48,  124, 51,
+    51,  45,  54,  53,  55,  45,  55,  48,  49,  45,  51,  51,  57,  49,  124,
+    101, 110, 100, 105, 110, 103, 32,  112, 108, 97,  116, 101, 108, 101, 116,
+    115, 32,  97,  108, 111, 110, 103, 32,  116, 104, 101, 32,  101, 120, 112,
+    114, 101, 115, 115, 32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  99,
+    97,  106, 111, 108, 101, 32,  99,  97,  114, 101, 102, 117, 108, 108, 121,
+    32,  102, 105, 110, 97,  108, 32,  10,  57,  50,  50,  124, 67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  48,  57,  50,  50,
+    124, 53,  55,  54,  55,  54,  55,  46,  53,  51,  51,  51,  124, 51,  56,
+    54,  57,  46,  50,  53,  124, 71,  69,  82,  77,  65,  78,  89,  124, 114,
+    115, 82,  57,  108, 82,  120, 121, 84,  100, 72,  98,  68,  79,  86,  116,
+    56,  110, 89,  98,  119, 106, 75,  53,  118, 65,  87,  72,  57,  115, 66,
+    124, 49,  55,  45,  57,  52,  53,  45,  57,  49,  54,  45,  57,  54,  52,
+    56,  124, 108, 117, 102, 102, 105, 108, 121, 32,  102, 108, 117, 102, 102,
+    121, 32,  100, 101, 112, 111, 115, 105, 116, 115, 46,  32,  112, 97,  99,
+    107, 97,  103, 101, 115, 32,  99,  10,  49,  52,  55,  57,  52,  54,  124,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  52,  55,
+    57,  52,  54,  124, 53,  55,  54,  52,  53,  53,  46,  49,  51,  50,  48,
+    124, 50,  48,  51,  48,  46,  49,  51,  124, 65,  76,  71,  69,  82,  73,
+    65,  124, 74,  113, 100, 116, 49,  107, 72,  65,  74,  116, 117, 84,  113,
+    72,  81,  75,  44,  66,  55,  32,  51,  116, 74,  104, 124, 49,  48,  45,
+    56,  56,  54,  45,  57,  53,  54,  45,  51,  49,  52,  51,  124, 105, 116,
+    104, 101, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  100, 101, 112,
+    111, 115, 105, 116, 115, 32,  104, 97,  103, 103, 108, 101, 32,  98,  108,
+    105, 116, 104, 101, 108, 121, 32,  105, 114, 111, 110, 105, 99,  32,  114,
+    101, 113, 117, 101, 115, 116, 115, 46,  32,  113, 117, 105, 99,  107, 108,
+    121, 32,  114, 101, 103, 117, 10,  49,  49,  53,  54,  52,  48,  124, 67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  49,  53,  54,
+    52,  48,  124, 53,  54,  57,  51,  52,  49,  46,  49,  57,  51,  51,  124,
+    54,  52,  51,  54,  46,  49,  48,  124, 65,  82,  71,  69,  78,  84,  73,
+    78,  65,  124, 54,  121, 75,  76,  73,  82,  82,  65,  105, 114, 85,  109,
+    66,  106, 75,  78,  79,  54,  90,  51,  124, 49,  49,  45,  52,  49,  49,
+    45,  53,  52,  51,  45,  52,  57,  48,  49,  124, 111, 115, 116, 32,  115,
+    108, 121, 108, 121, 32,  97,  108, 111, 110, 103, 32,  116, 104, 101, 32,
+    112, 97,  116, 116, 101, 114, 110, 115, 59,  32,  112, 105, 110, 116, 111,
+    32,  98,  101, 10,  55,  51,  54,  48,  54,  124, 67,  117, 115, 116, 111,
+    109, 101, 114, 35,  48,  48,  48,  48,  55,  51,  54,  48,  54,  124, 53,
+    54,  56,  54,  53,  54,  46,  56,  53,  55,  56,  124, 49,  55,  56,  53,
+    46,  54,  55,  124, 74,  65,  80,  65,  78,  124, 118, 120, 57,  44,  55,
+    65,  67,  86,  116, 111, 75,  110, 76,  99,  111, 65,  72,  71,  78,  89,
+    68,  70,  124, 50,  50,  45,  52,  51,  55,  45,  54,  53,  51,  45,  54,
+    57,  54,  54,  124, 104, 101, 32,  102, 117, 114, 105, 111, 117, 115, 108,
+    121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  105, 100, 101, 97,  115,
+    46,  32,  115, 108, 111, 119, 108, 121, 10,  49,  49,  48,  50,  52,  54,
+    124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  49,
+    48,  50,  52,  54,  124, 53,  54,  54,  56,  52,  50,  46,  57,  56,  49,
+    53,  124, 55,  55,  54,  51,  46,  51,  53,  124, 86,  73,  69,  84,  78,
+    65,  77,  124, 85,  103, 115, 76,  70,  76,  51,  114, 101, 110, 100, 65,
+    84,  122, 99,  72,  105, 124, 51,  49,  45,  57,  52,  51,  45,  52,  50,
+    54,  45,  57,  56,  51,  55,  124, 101, 103, 117, 108, 97,  114, 32,  100,
+    101, 112, 111, 115, 105, 116, 115, 32,  115, 101, 114, 118, 101, 32,  98,
+    108, 105, 116, 104, 101, 108, 121, 32,  97,  98,  111, 118, 101, 32,  116,
+    104, 101, 32,  102, 108, 10,  49,  52,  50,  53,  52,  57,  124, 67,  117,
+    115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  52,  50,  53,  52,
+    57,  124, 53,  54,  51,  53,  51,  55,  46,  50,  51,  54,  56,  124, 53,
+    48,  56,  53,  46,  57,  57,  124, 73,  78,  68,  79,  78,  69,  83,  73,
+    65,  124, 112, 74,  65,  109, 67,  104, 87,  88,  99,  116, 32,  72,  78,
+    106, 80,  122, 103, 111, 66,  85,  79,  103, 65,  72,  100, 117, 119, 119,
+    73,  82,  124, 49,  57,  45,  57,  53,  53,  45,  53,  54,  50,  45,  50,
+    51,  57,  56,  124, 115, 108, 101, 101, 112, 32,  112, 101, 110, 100, 105,
+    110, 103, 32,  99,  111, 117, 114, 116, 115, 46,  32,  105, 114, 111, 110,
+    105, 99,  32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  97,  103, 97,
+    105, 110, 115, 116, 32,  116, 104, 101, 32,  99,  97,  114, 101, 102, 117,
+    108, 108, 121, 32,  117, 110, 117, 115, 117, 97,  108, 32,  112, 108, 97,
+    116, 101, 108, 101, 116, 115, 32,  99,  97,  106, 111, 108, 101, 32,  99,
+    97,  114, 101, 102, 117, 108, 108, 121, 32,  101, 120, 112, 114, 101, 115,
+    115, 32,  97,  99,  99,  111, 117, 110, 116, 115, 46,  10,  49,  52,  54,
+    49,  52,  57,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  49,  52,  54,  49,  52,  57,  124, 53,  53,  55,  50,  53,  52,  46,
+    57,  56,  54,  53,  124, 49,  55,  57,  49,  46,  53,  53,  124, 82,  79,
+    77,  65,  78,  73,  65,  124, 32,  83,  84,  76,  119, 116, 108, 97,  66,
+    54,  124, 50,  57,  45,  55,  52,  52,  45,  49,  54,  52,  45,  54,  52,
+    56,  55,  124, 32,  111, 102, 32,  116, 104, 101, 32,  115, 108, 121, 108,
+    121, 32,  115, 105, 108, 101, 110, 116, 32,  97,  99,  99,  111, 117, 110,
+    116, 115, 46,  32,  113, 117, 105, 99,  107, 108, 121, 32,  102, 105, 110,
+    97,  108, 32,  97,  99,  99,  111, 117, 110, 116, 115, 32,  97,  99,  114,
+    111, 115, 115, 32,  116, 104, 101, 32,  10,  53,  50,  53,  50,  56,  124,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  53,  50,
+    53,  50,  56,  124, 53,  53,  54,  51,  57,  55,  46,  51,  53,  48,  57,
+    124, 53,  53,  49,  46,  55,  57,  124, 65,  82,  71,  69,  78,  84,  73,
+    78,  65,  124, 101, 108, 115, 121, 116, 56,  99,  57,  90,  44,  55,  99,
+    104, 124, 49,  49,  45,  50,  48,  56,  45,  49,  57,  50,  45,  51,  50,
+    48,  53,  124, 32,  100, 101, 112, 111, 115, 105, 116, 115, 32,  104, 105,
+    110, 100, 101, 114, 46,  32,  98,  108, 105, 116, 104, 101, 108, 121, 32,
+    112, 101, 110, 100, 105, 110, 103, 32,  97,  115, 121, 109, 112, 116, 111,
+    116, 101, 115, 32,  98,  114, 101, 97,  99,  104, 32,  115, 108, 121, 108,
+    121, 32,  114, 101, 103, 117, 108, 97,  114, 32,  114, 101, 10,  50,  51,
+    52,  51,  49,  124, 67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  48,  50,  51,  52,  51,  49,  124, 53,  53,  52,  50,  54,  57,  46,
+    53,  51,  54,  48,  124, 51,  51,  56,  49,  46,  56,  54,  124, 82,  79,
+    77,  65,  78,  73,  65,  124, 107, 75,  73,  53,  44,  67,  74,  65,  74,
+    81,  106, 81,  82,  81,  116, 79,  100, 67,  105, 70,  81,  124, 50,  57,
+    45,  57,  49,  53,  45,  52,  53,  56,  45,  50,  54,  53,  52,  124, 110,
+    117, 115, 117, 97,  108, 44,  32,  101, 118, 101, 110, 32,  105, 110, 115,
+    116, 114, 117, 99,  116, 105, 111, 110, 115, 58,  32,  102, 117, 114, 105,
+    111, 117, 115, 108, 121, 32,  115, 116, 101, 97,  108, 116, 104, 121, 32,
+    110, 10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q11[] = {
+    112, 115, 95,  112, 97,  114, 116, 107, 101, 121, 124, 118, 97,  108, 117,
+    101, 10,  49,  50,  57,  55,  54,  48,  124, 49,  55,  53,  51,  56,  52,
+    53,  54,  46,  56,  54,  10,  49,  54,  54,  55,  50,  54,  124, 49,  54,
+    53,  48,  51,  51,  53,  51,  46,  57,  50,  10,  49,  57,  49,  50,  56,
+    55,  124, 49,  54,  52,  55,  52,  56,  48,  49,  46,  57,  55,  10,  49,
+    54,  49,  55,  53,  56,  124, 49,  54,  49,  48,  49,  55,  53,  53,  46,
+    53,  52,  10,  51,  52,  52,  53,  50,  124, 49,  53,  57,  56,  51,  56,
+    52,  52,  46,  55,  50,  10,  49,  51,  57,  48,  51,  53,  124, 49,  53,
+    57,  48,  55,  48,  55,  56,  46,  51,  52,  10,  57,  52,  48,  51,  124,
+    49,  53,  52,  53,  49,  55,  53,  53,  46,  54,  50,  10,  49,  53,  52,
+    51,  53,  56,  124, 49,  53,  50,  49,  50,  57,  51,  55,  46,  56,  56,
+    10,  51,  56,  56,  50,  51,  124, 49,  53,  48,  54,  52,  56,  48,  50,
+    46,  56,  54,  10,  56,  53,  54,  48,  54,  124, 49,  53,  48,  53,  51,
+    57,  53,  55,  46,  49,  53,  10,  51,  51,  51,  53,  52,  124, 49,  52,
+    52,  48,  56,  50,  57,  55,  46,  52,  48,  10,  49,  53,  52,  55,  52,
+    55,  124, 49,  52,  52,  48,  55,  53,  56,  48,  46,  54,  56,  10,  56,
+    50,  56,  54,  53,  124, 49,  52,  50,  51,  53,  52,  56,  57,  46,  55,
+    56,  10,  55,  54,  48,  57,  52,  124, 49,  52,  48,  57,  52,  50,  52,
+    55,  46,  48,  52,  10,  50,  50,  50,  124, 49,  51,  57,  51,  55,  55,
+    55,  55,  46,  55,  52,  10,  49,  50,  49,  50,  55,  49,  124, 49,  51,
+    57,  48,  56,  51,  51,  54,  46,  48,  48,  10,  53,  53,  50,  50,  49,
+    124, 49,  51,  55,  49,  54,  49,  50,  48,  46,  52,  55,  10,  50,  50,
+    56,  49,  57,  124, 49,  51,  54,  54,  54,  52,  51,  52,  46,  50,  56,
+    10,  55,  54,  50,  56,  49,  124, 49,  51,  54,  52,  54,  56,  53,  51,
+    46,  54,  56,  10,  56,  53,  50,  57,  56,  124, 49,  51,  53,  56,  49,
+    49,  53,  52,  46,  57,  51,  10,  56,  53,  49,  53,  56,  124, 49,  51,
+    53,  53,  52,  57,  48,  52,  46,  48,  48,  10,  49,  51,  57,  54,  56,
+    52,  124, 49,  51,  53,  51,  53,  53,  51,  56,  46,  55,  50,  10,  51,
+    49,  48,  51,  52,  124, 49,  51,  52,  57,  56,  48,  50,  53,  46,  50,
+    53,  10,  56,  55,  51,  48,  53,  124, 49,  51,  52,  56,  50,  56,  52,
+    55,  46,  48,  52,  10,  49,  48,  49,  56,  49,  124, 49,  51,  52,  52,
+    53,  49,  52,  56,  46,  55,  53,  10,  54,  50,  51,  50,  51,  124, 49,
+    51,  52,  49,  49,  56,  50,  52,  46,  51,  48,  10,  50,  54,  52,  56,
+    57,  124, 49,  51,  51,  55,  55,  50,  53,  54,  46,  51,  56,  10,  57,
+    54,  52,  57,  51,  124, 49,  51,  51,  51,  57,  48,  53,  55,  46,  56,
+    51,  10,  53,  54,  53,  52,  56,  124, 49,  51,  51,  50,  57,  48,  49,
+    52,  46,  57,  55,  10,  53,  53,  53,  55,  54,  124, 49,  51,  51,  48,
+    54,  56,  52,  51,  46,  51,  53,  10,  49,  53,  57,  55,  53,  49,  124,
+    49,  51,  51,  48,  54,  54,  49,  52,  46,  52,  56,  10,  57,  50,  52,
+    48,  54,  124, 49,  51,  50,  56,  55,  52,  49,  52,  46,  53,  48,  10,
+    49,  56,  50,  54,  51,  54,  124, 49,  51,  50,  50,  51,  55,  50,  54,
+    46,  55,  52,  10,  49,  57,  57,  57,  54,  57,  124, 49,  51,  49,  51,
+    53,  50,  56,  56,  46,  50,  49,  10,  54,  50,  56,  54,  53,  124, 49,
+    51,  48,  48,  49,  57,  50,  54,  46,  57,  52,  10,  55,  50,  56,  52,
+    124, 49,  50,  57,  52,  53,  50,  57,  56,  46,  49,  57,  10,  49,  57,
+    55,  56,  54,  55,  124, 49,  50,  57,  52,  52,  53,  49,  48,  46,  53,
+    50,  10,  49,  49,  53,  54,  50,  124, 49,  50,  57,  51,  49,  53,  55,
+    53,  46,  53,  49,  10,  55,  53,  49,  54,  53,  124, 49,  50,  57,  49,
+    54,  57,  49,  56,  46,  49,  50,  10,  57,  55,  49,  55,  53,  124, 49,
+    50,  57,  49,  49,  50,  56,  51,  46,  53,  48,  10,  49,  52,  48,  56,
+    52,  48,  124, 49,  50,  56,  57,  54,  53,  54,  50,  46,  50,  51,  10,
+    54,  53,  50,  52,  49,  124, 49,  50,  56,  57,  48,  54,  48,  48,  46,
+    52,  54,  10,  49,  54,  54,  49,  50,  48,  124, 49,  50,  56,  55,  54,
+    57,  50,  55,  46,  50,  50,  10,  57,  48,  51,  53,  124, 49,  50,  56,
+    54,  51,  56,  50,  56,  46,  55,  48,  10,  49,  52,  52,  54,  49,  54,
+    124, 49,  50,  56,  53,  51,  53,  52,  57,  46,  51,  48,  10,  49,  55,
+    54,  55,  50,  51,  124, 49,  50,  56,  51,  50,  51,  48,  57,  46,  55,
+    52,  10,  49,  55,  48,  56,  56,  52,  124, 49,  50,  55,  57,  50,  49,
+    51,  54,  46,  53,  56,  10,  50,  57,  55,  57,  48,  124, 49,  50,  55,
+    50,  51,  51,  48,  48,  46,  51,  51,  10,  57,  53,  50,  49,  51,  124,
+    49,  50,  53,  53,  53,  52,  56,  51,  46,  55,  51,  10,  49,  56,  51,
+    56,  55,  51,  124, 49,  50,  53,  53,  48,  53,  51,  51,  46,  48,  53,
+    10,  49,  55,  49,  50,  51,  53,  124, 49,  50,  52,  55,  54,  53,  51,
+    56,  46,  51,  48,  10,  50,  49,  53,  51,  51,  124, 49,  50,  52,  51,
+    55,  56,  50,  49,  46,  51,  50,  10,  49,  55,  50,  57,  48,  124, 49,
+    50,  52,  51,  50,  49,  53,  57,  46,  53,  48,  10,  49,  53,  54,  51,
+    57,  55,  124, 49,  50,  50,  54,  48,  54,  50,  51,  46,  53,  48,  10,
+    49,  50,  50,  54,  49,  49,  124, 49,  50,  50,  50,  50,  56,  49,  50,
+    46,  57,  56,  10,  49,  51,  57,  49,  53,  53,  124, 49,  50,  50,  50,
+    48,  51,  49,  57,  46,  50,  53,  10,  49,  52,  54,  51,  49,  54,  124,
+    49,  50,  50,  49,  53,  56,  48,  48,  46,  54,  49,  10,  49,  55,  49,
+    51,  56,  49,  124, 49,  50,  49,  57,  57,  55,  51,  52,  46,  53,  50,
+    10,  49,  57,  56,  54,  51,  51,  124, 49,  50,  48,  55,  56,  50,  50,
+    54,  46,  57,  53,  10,  49,  54,  55,  52,  49,  55,  124, 49,  50,  48,
+    52,  54,  54,  51,  55,  46,  54,  50,  10,  53,  57,  53,  49,  50,  124,
+    49,  50,  48,  52,  51,  52,  54,  56,  46,  55,  54,  10,  51,  49,  54,
+    56,  56,  124, 49,  50,  48,  51,  52,  56,  57,  51,  46,  54,  52,  10,
+    49,  53,  57,  53,  56,  54,  124, 49,  50,  48,  48,  49,  53,  48,  53,
+    46,  56,  52,  10,  56,  57,  57,  51,  124, 49,  49,  57,  54,  51,  56,
+    49,  52,  46,  51,  48,  10,  49,  50,  48,  51,  48,  50,  124, 49,  49,
+    56,  53,  55,  55,  48,  55,  46,  53,  53,  10,  52,  51,  53,  51,  54,
+    124, 49,  49,  55,  55,  57,  51,  52,  48,  46,  53,  50,  10,  57,  53,
+    53,  50,  124, 49,  49,  55,  55,  54,  57,  48,  57,  46,  49,  54,  10,
+    56,  54,  50,  50,  51,  124, 49,  49,  55,  55,  50,  50,  48,  53,  46,
+    48,  56,  10,  53,  51,  55,  55,  54,  124, 49,  49,  55,  53,  56,  54,
+    54,  57,  46,  54,  53,  10,  49,  51,  49,  50,  56,  53,  124, 49,  49,
+    54,  49,  54,  57,  53,  51,  46,  55,  52,  10,  57,  49,  54,  50,  56,
+    124, 49,  49,  54,  49,  49,  49,  49,  52,  46,  56,  51,  10,  49,  54,
+    57,  54,  52,  52,  124, 49,  49,  53,  54,  55,  57,  53,  57,  46,  55,
+    50,  10,  49,  56,  50,  50,  57,  57,  124, 49,  49,  53,  54,  55,  52,
+    54,  50,  46,  48,  53,  10,  51,  51,  49,  48,  55,  124, 49,  49,  52,
+    53,  51,  56,  49,  56,  46,  55,  54,  10,  49,  48,  52,  49,  56,  52,
+    124, 49,  49,  52,  51,  54,  54,  53,  55,  46,  52,  52,  10,  54,  55,
+    48,  50,  55,  124, 49,  49,  52,  49,  57,  49,  50,  55,  46,  49,  52,
+    10,  49,  55,  54,  56,  54,  57,  124, 49,  49,  51,  55,  49,  52,  53,
+    49,  46,  55,  49,  10,  51,  48,  56,  56,  53,  124, 49,  49,  51,  54,
+    57,  54,  55,  52,  46,  55,  57,  10,  53,  52,  52,  50,  48,  124, 49,
+    49,  51,  52,  53,  48,  55,  54,  46,  56,  56,  10,  55,  50,  50,  52,
+    48,  124, 49,  49,  51,  49,  51,  57,  53,  49,  46,  48,  53,  10,  49,
+    55,  56,  55,  48,  56,  124, 49,  49,  50,  57,  52,  54,  51,  53,  46,
+    49,  55,  10,  56,  49,  50,  57,  56,  124, 49,  49,  50,  55,  51,  54,
+    56,  54,  46,  49,  51,  10,  49,  53,  56,  51,  50,  52,  124, 49,  49,
+    50,  52,  51,  52,  52,  50,  46,  55,  50,  10,  49,  49,  55,  48,  57,
+    53,  124, 49,  49,  50,  52,  50,  53,  51,  53,  46,  50,  52,  10,  49,
+    55,  54,  55,  57,  51,  124, 49,  49,  50,  51,  55,  55,  51,  51,  46,
+    51,  56,  10,  56,  54,  48,  57,  49,  124, 49,  49,  49,  55,  55,  55,
+    57,  51,  46,  55,  57,  10,  49,  49,  54,  48,  51,  51,  124, 49,  49,
+    49,  52,  53,  52,  51,  52,  46,  51,  54,  10,  49,  50,  57,  48,  53,
+    56,  124, 49,  49,  49,  49,  57,  49,  49,  50,  46,  50,  48,  10,  49,
+    57,  51,  55,  49,  52,  124, 49,  49,  49,  48,  52,  55,  48,  54,  46,
+    51,  57,  10,  49,  49,  55,  49,  57,  53,  124, 49,  49,  48,  55,  55,
+    50,  49,  55,  46,  57,  54,  10,  52,  57,  56,  53,  49,  124, 49,  49,
+    48,  52,  51,  55,  48,  49,  46,  55,  56,  10,  49,  57,  55,  57,  49,
+    124, 49,  49,  48,  51,  48,  54,  54,  50,  46,  54,  50,  10,  55,  53,
+    56,  48,  48,  124, 49,  49,  48,  49,  50,  52,  48,  49,  46,  54,  50,
+    10,  49,  54,  49,  53,  54,  50,  124, 49,  48,  57,  57,  54,  51,  55,
+    49,  46,  54,  57,  10,  49,  48,  49,  49,  57,  124, 49,  48,  57,  56,
+    48,  48,  49,  53,  46,  55,  53,  10,  51,  57,  49,  56,  53,  124, 49,
+    48,  57,  55,  48,  48,  52,  50,  46,  53,  54,  10,  52,  55,  50,  50,
+    51,  124, 49,  48,  57,  53,  48,  48,  50,  50,  46,  49,  51,  10,  49,
+    55,  53,  53,  57,  52,  124, 49,  48,  57,  52,  50,  57,  50,  51,  46,
+    48,  53,  10,  49,  49,  49,  50,  57,  53,  124, 49,  48,  56,  57,  51,
+    54,  55,  53,  46,  54,  49,  10,  49,  53,  53,  52,  52,  54,  124, 49,
+    48,  56,  53,  50,  55,  54,  52,  46,  53,  55,  10,  49,  53,  54,  51,
+    57,  49,  124, 49,  48,  56,  51,  57,  56,  49,  48,  46,  51,  56,  10,
+    52,  48,  56,  56,  52,  124, 49,  48,  56,  51,  55,  50,  51,  52,  46,
+    49,  57,  10,  49,  52,  49,  50,  56,  56,  124, 49,  48,  56,  51,  55,
+    49,  51,  48,  46,  50,  49,  10,  49,  53,  50,  51,  56,  56,  124, 49,
+    48,  56,  51,  48,  57,  55,  55,  46,  56,  50,  10,  51,  51,  52,  52,
+    57,  124, 49,  48,  56,  51,  48,  56,  53,  56,  46,  55,  50,  10,  49,
+    52,  57,  48,  51,  53,  124, 49,  48,  56,  50,  54,  49,  51,  48,  46,
+    48,  50,  10,  49,  54,  50,  54,  50,  48,  124, 49,  48,  56,  49,  52,
+    50,  55,  53,  46,  54,  56,  10,  49,  49,  56,  51,  50,  52,  124, 49,
+    48,  55,  57,  49,  55,  56,  56,  46,  49,  48,  10,  51,  56,  57,  51,
+    50,  124, 49,  48,  55,  55,  55,  53,  52,  49,  46,  55,  53,  10,  49,
+    50,  49,  50,  57,  52,  124, 49,  48,  55,  54,  52,  50,  50,  53,  46,
+    50,  50,  10,  52,  56,  55,  50,  49,  124, 49,  48,  55,  54,  50,  53,
+    56,  50,  46,  52,  57,  10,  54,  51,  51,  52,  50,  124, 49,  48,  55,
+    52,  48,  49,  51,  50,  46,  54,  48,  10,  53,  54,  49,  52,  124, 49,
+    48,  55,  50,  52,  54,  54,  56,  46,  56,  48,  10,  54,  50,  50,  54,
+    54,  124, 49,  48,  55,  49,  49,  49,  52,  51,  46,  49,  48,  10,  49,
+    48,  48,  50,  48,  50,  124, 49,  48,  54,  57,  54,  54,  55,  53,  46,
+    53,  53,  10,  49,  57,  55,  55,  52,  49,  124, 49,  48,  54,  56,  56,
+    53,  54,  48,  46,  55,  50,  10,  49,  54,  57,  49,  55,  56,  124, 49,
+    48,  54,  52,  56,  53,  50,  50,  46,  56,  48,  10,  53,  50,  55,  49,
+    124, 49,  48,  54,  51,  57,  51,  57,  50,  46,  54,  53,  10,  51,  52,
+    52,  57,  57,  124, 49,  48,  53,  56,  52,  49,  55,  55,  46,  49,  48,
+    10,  55,  49,  49,  48,  56,  124, 49,  48,  53,  54,  57,  49,  49,  55,
+    46,  53,  54,  10,  49,  51,  55,  49,  51,  50,  124, 49,  48,  53,  51,
+    57,  56,  56,  48,  46,  52,  55,  10,  55,  56,  52,  53,  49,  124, 49,
+    48,  53,  50,  52,  56,  55,  51,  46,  50,  52,  10,  49,  53,  48,  56,
+    50,  55,  124, 49,  48,  53,  48,  51,  56,  49,  48,  46,  52,  56,  10,
+    49,  48,  55,  50,  51,  55,  124, 49,  48,  52,  56,  56,  48,  51,  48,
+    46,  56,  52,  10,  49,  48,  49,  55,  50,  55,  124, 49,  48,  52,  55,
+    51,  53,  53,  56,  46,  49,  48,  10,  53,  56,  55,  48,  56,  124, 49,
+    48,  52,  54,  54,  50,  56,  48,  46,  52,  52,  10,  56,  57,  55,  54,
+    56,  124, 49,  48,  52,  54,  53,  52,  55,  55,  46,  50,  50,  10,  49,
+    52,  54,  52,  57,  51,  124, 49,  48,  52,  52,  52,  50,  57,  49,  46,
+    53,  56,  10,  53,  53,  52,  50,  52,  124, 49,  48,  52,  52,  52,  48,
+    48,  54,  46,  52,  56,  10,  49,  54,  53,  54,  48,  124, 49,  48,  52,
+    50,  53,  53,  55,  52,  46,  55,  52,  10,  49,  51,  51,  49,  49,  52,
+    124, 49,  48,  52,  49,  53,  48,  57,  55,  46,  57,  48,  10,  49,  57,
+    53,  56,  49,  48,  124, 49,  48,  52,  49,  51,  54,  50,  53,  46,  50,
+    48,  10,  55,  54,  54,  55,  51,  124, 49,  48,  51,  57,  49,  57,  55,
+    55,  46,  49,  56,  10,  57,  55,  51,  48,  53,  124, 49,  48,  51,  57,
+    48,  56,  57,  48,  46,  53,  55,  10,  49,  51,  52,  50,  49,  48,  124,
+    49,  48,  51,  56,  55,  50,  49,  48,  46,  48,  50,  10,  49,  56,  56,
+    53,  51,  54,  124, 49,  48,  51,  56,  54,  53,  50,  57,  46,  57,  50,
+    10,  49,  50,  50,  50,  53,  53,  124, 49,  48,  51,  51,  53,  55,  54,
+    48,  46,  51,  50,  10,  50,  54,  56,  50,  124, 49,  48,  51,  49,  50,
+    57,  54,  54,  46,  49,  48,  10,  52,  51,  56,  49,  52,  124, 49,  48,
+    51,  48,  51,  48,  56,  54,  46,  54,  49,  10,  51,  52,  55,  54,  55,
+    124, 49,  48,  50,  57,  48,  52,  48,  53,  46,  49,  56,  10,  49,  54,
+    53,  53,  56,  52,  124, 49,  48,  50,  55,  51,  55,  48,  53,  46,  56,
+    57,  10,  50,  50,  51,  49,  124, 49,  48,  50,  55,  48,  52,  49,  53,
+    46,  53,  53,  10,  49,  49,  49,  50,  53,  57,  124, 49,  48,  50,  54,
+    51,  50,  53,  54,  46,  53,  54,  10,  49,  57,  53,  53,  55,  56,  124,
+    49,  48,  50,  51,  57,  55,  57,  53,  46,  56,  50,  10,  50,  49,  48,
+    57,  51,  124, 49,  48,  50,  49,  55,  53,  51,  49,  46,  51,  48,  10,
+    50,  57,  56,  53,  54,  124, 49,  48,  50,  49,  54,  57,  51,  50,  46,
+    53,  52,  10,  49,  51,  51,  54,  56,  54,  124, 49,  48,  50,  49,  51,
+    51,  52,  53,  46,  55,  54,  10,  56,  55,  55,  52,  53,  124, 49,  48,
+    49,  56,  53,  53,  48,  57,  46,  52,  48,  10,  49,  51,  53,  49,  53,
+    51,  124, 49,  48,  49,  55,  57,  51,  55,  57,  46,  55,  48,  10,  49,
+    49,  55,  55,  51,  124, 49,  48,  49,  54,  55,  52,  49,  48,  46,  56,
+    52,  10,  55,  54,  51,  49,  54,  124, 49,  48,  49,  54,  53,  49,  53,
+    49,  46,  55,  48,  10,  49,  50,  51,  48,  55,  54,  124, 49,  48,  49,
+    54,  49,  50,  50,  53,  46,  55,  56,  10,  57,  49,  56,  57,  52,  124,
+    49,  48,  49,  51,  48,  52,  54,  50,  46,  49,  57,  10,  51,  57,  55,
+    52,  49,  124, 49,  48,  49,  50,  56,  51,  56,  55,  46,  53,  50,  10,
+    49,  49,  49,  55,  53,  51,  124, 49,  48,  49,  49,  57,  55,  56,  48,
+    46,  57,  56,  10,  49,  52,  50,  55,  50,  57,  124, 49,  48,  49,  48,
+    52,  55,  52,  56,  46,  56,  57,  10,  49,  49,  54,  55,  55,  53,  124,
+    49,  48,  48,  57,  55,  55,  53,  48,  46,  52,  50,  10,  49,  48,  50,
+    53,  56,  57,  124, 49,  48,  48,  51,  52,  55,  56,  52,  46,  51,  54,
+    10,  49,  56,  54,  50,  54,  56,  124, 49,  48,  48,  49,  50,  49,  56,
+    49,  46,  53,  55,  10,  52,  52,  53,  52,  53,  124, 49,  48,  48,  48,
+    48,  50,  56,  54,  46,  52,  56,  10,  50,  51,  51,  48,  55,  124, 57,
+    57,  54,  54,  53,  55,  55,  46,  53,  48,  10,  49,  50,  52,  50,  56,
+    49,  124, 57,  57,  51,  48,  48,  49,  56,  46,  57,  48,  10,  54,  57,
+    54,  48,  52,  124, 57,  57,  50,  53,  55,  51,  48,  46,  54,  52,  10,
+    50,  49,  57,  55,  49,  124, 57,  57,  48,  56,  57,  56,  50,  46,  48,
+    51,  10,  53,  56,  49,  52,  56,  124, 57,  56,  57,  53,  56,  57,  52,
+    46,  52,  48,  10,  49,  54,  53,  51,  50,  124, 57,  56,  56,  54,  53,
+    50,  57,  46,  57,  48,  10,  49,  53,  57,  49,  56,  48,  124, 57,  56,
+    56,  51,  55,  52,  52,  46,  52,  51,  10,  55,  52,  55,  51,  51,  124,
+    57,  56,  55,  55,  53,  56,  50,  46,  56,  56,  10,  51,  53,  49,  55,
+    51,  124, 57,  56,  53,  56,  50,  55,  53,  46,  57,  50,  10,  55,  49,
+    49,  54,  124, 57,  56,  53,  54,  56,  56,  49,  46,  48,  50,  10,  49,
+    50,  52,  54,  50,  48,  124, 57,  56,  51,  56,  53,  56,  57,  46,  49,
+    52,  10,  49,  50,  50,  49,  48,  56,  124, 57,  56,  50,  57,  57,  52,
+    57,  46,  51,  53,  10,  54,  55,  50,  48,  48,  124, 57,  56,  50,  56,
+    54,  57,  48,  46,  54,  57,  10,  49,  54,  52,  55,  55,  53,  124, 57,
+    56,  50,  49,  52,  50,  52,  46,  52,  52,  10,  57,  48,  51,  57,  124,
+    57,  56,  49,  54,  52,  52,  55,  46,  55,  50,  10,  49,  52,  57,  49,
+    50,  124, 57,  56,  48,  51,  49,  48,  50,  46,  50,  48,  10,  49,  57,
+    48,  57,  48,  54,  124, 57,  55,  57,  49,  51,  49,  53,  46,  55,  48,
+    10,  49,  51,  48,  51,  57,  56,  124, 57,  55,  56,  49,  54,  55,  52,
+    46,  50,  55,  10,  49,  49,  57,  51,  49,  48,  124, 57,  55,  55,  54,
+    57,  50,  55,  46,  50,  49,  10,  49,  48,  49,  51,  50,  124, 57,  55,
+    55,  48,  57,  51,  48,  46,  55,  56,  10,  49,  48,  55,  50,  49,  49,
+    124, 57,  55,  53,  55,  53,  56,  54,  46,  50,  53,  10,  49,  49,  51,
+    57,  53,  56,  124, 57,  55,  53,  55,  48,  54,  53,  46,  53,  48,  10,
+    51,  55,  48,  48,  57,  124, 57,  55,  52,  56,  51,  54,  50,  46,  54,
+    57,  10,  54,  54,  55,  52,  54,  124, 57,  55,  52,  51,  53,  50,  56,
+    46,  55,  54,  10,  49,  51,  52,  52,  56,  54,  124, 57,  55,  51,  49,
+    57,  50,  50,  46,  48,  48,  10,  49,  53,  57,  52,  53,  124, 57,  55,
+    51,  49,  48,  57,  54,  46,  52,  53,  10,  53,  53,  51,  48,  55,  124,
+    57,  55,  49,  55,  55,  52,  53,  46,  56,  48,  10,  53,  54,  51,  54,
+    50,  124, 57,  55,  49,  52,  57,  50,  50,  46,  56,  51,  10,  53,  55,
+    55,  50,  54,  124, 57,  55,  49,  49,  55,  57,  50,  46,  49,  48,  10,
+    53,  55,  50,  53,  54,  124, 57,  55,  48,  56,  54,  50,  49,  46,  48,
+    48,  10,  49,  49,  50,  50,  57,  50,  124, 57,  55,  48,  49,  54,  53,
+    51,  46,  48,  56,  10,  56,  55,  53,  49,  52,  124, 57,  54,  57,  57,
+    52,  57,  50,  46,  53,  51,  10,  49,  55,  52,  50,  48,  54,  124, 57,
+    54,  56,  48,  53,  54,  50,  46,  48,  50,  10,  55,  50,  56,  54,  53,
+    124, 57,  54,  55,  57,  48,  52,  51,  46,  51,  52,  10,  49,  49,  52,
+    51,  53,  55,  124, 57,  54,  55,  49,  48,  49,  55,  46,  52,  52,  10,
+    49,  49,  50,  56,  48,  55,  124, 57,  54,  54,  53,  48,  49,  57,  46,
+    50,  49,  10,  49,  49,  53,  50,  48,  51,  124, 57,  54,  54,  49,  48,
+    49,  56,  46,  55,  51,  10,  49,  55,  55,  52,  53,  52,  124, 57,  54,
+    53,  56,  57,  48,  54,  46,  51,  53,  10,  49,  54,  49,  50,  55,  53,
+    124, 57,  54,  51,  52,  51,  49,  51,  46,  55,  49,  10,  54,  49,  56,
+    57,  51,  124, 57,  54,  49,  55,  48,  57,  53,  46,  52,  52,  10,  49,
+    50,  50,  50,  49,  57,  124, 57,  54,  48,  52,  56,  56,  56,  46,  50,
+    48,  10,  49,  56,  51,  52,  50,  55,  124, 57,  54,  48,  49,  51,  54,
+    50,  46,  53,  56,  10,  53,  57,  49,  53,  56,  124, 57,  53,  57,  57,
+    55,  48,  53,  46,  57,  54,  10,  54,  49,  57,  51,  49,  124, 57,  53,
+    56,  52,  57,  49,  56,  46,  57,  56,  10,  53,  53,  51,  50,  124, 57,
+    53,  55,  57,  57,  54,  52,  46,  49,  52,  10,  50,  48,  49,  53,  56,
+    124, 57,  53,  55,  54,  55,  49,  52,  46,  51,  56,  10,  49,  54,  55,
+    49,  57,  57,  124, 57,  53,  53,  55,  52,  49,  51,  46,  48,  56,  10,
+    51,  56,  56,  54,  57,  124, 57,  53,  53,  48,  50,  55,  57,  46,  53,
+    51,  10,  56,  54,  57,  52,  57,  124, 57,  53,  52,  49,  57,  52,  51,
+    46,  55,  48,  10,  49,  57,  56,  53,  52,  52,  124, 57,  53,  51,  56,
+    54,  49,  51,  46,  57,  50,  10,  49,  57,  51,  55,  54,  50,  124, 57,
+    53,  51,  56,  50,  51,  56,  46,  57,  52,  10,  49,  48,  56,  56,  48,
+    55,  124, 57,  53,  51,  54,  50,  52,  55,  46,  49,  54,  10,  49,  54,
+    56,  51,  50,  52,  124, 57,  53,  51,  53,  54,  52,  55,  46,  57,  57,
+    10,  49,  49,  53,  53,  56,  56,  124, 57,  53,  51,  50,  49,  57,  53,
+    46,  48,  52,  10,  49,  52,  49,  51,  55,  50,  124, 57,  53,  50,  57,
+    55,  48,  50,  46,  49,  52,  10,  49,  55,  53,  49,  50,  48,  124, 57,
+    53,  50,  54,  48,  54,  56,  46,  54,  54,  10,  49,  54,  51,  56,  53,
+    49,  124, 57,  53,  50,  50,  56,  48,  56,  46,  56,  51,  10,  49,  54,
+    48,  57,  53,  52,  124, 57,  53,  50,  48,  51,  53,  57,  46,  52,  53,
+    10,  49,  49,  55,  55,  53,  55,  124, 57,  53,  49,  55,  56,  56,  50,
+    46,  56,  48,  10,  53,  50,  53,  57,  52,  124, 57,  53,  48,  56,  51,
+    50,  53,  46,  55,  54,  10,  54,  48,  57,  54,  48,  124, 57,  52,  57,
+    56,  56,  52,  51,  46,  48,  54,  10,  55,  48,  50,  55,  50,  124, 57,
+    52,  57,  53,  55,  55,  53,  46,  54,  50,  10,  52,  52,  48,  53,  48,
+    124, 57,  52,  57,  53,  53,  49,  53,  46,  51,  54,  10,  49,  53,  50,
+    50,  49,  51,  124, 57,  52,  57,  52,  55,  53,  54,  46,  57,  54,  10,
+    49,  50,  49,  50,  48,  51,  124, 57,  52,  57,  50,  54,  48,  49,  46,
+    51,  48,  10,  55,  48,  49,  49,  52,  124, 57,  52,  57,  49,  48,  49,
+    50,  46,  51,  48,  10,  49,  54,  55,  53,  56,  56,  124, 57,  52,  56,
+    52,  55,  52,  49,  46,  49,  49,  10,  49,  51,  54,  52,  53,  53,  124,
+    57,  52,  55,  54,  50,  52,  49,  46,  55,  56,  10,  52,  51,  53,  55,
+    124, 57,  52,  54,  52,  51,  53,  53,  46,  54,  52,  10,  54,  55,  56,
+    54,  124, 57,  52,  54,  51,  54,  51,  50,  46,  53,  55,  10,  54,  49,
+    51,  52,  53,  124, 57,  52,  53,  53,  51,  51,  54,  46,  55,  48,  10,
+    49,  54,  48,  56,  50,  54,  124, 57,  52,  52,  54,  55,  53,  52,  46,
+    56,  52,  10,  55,  49,  50,  55,  53,  124, 57,  52,  52,  48,  49,  51,
+    56,  46,  52,  48,  10,  55,  55,  55,  52,  54,  124, 57,  52,  51,  57,
+    49,  49,  56,  46,  51,  53,  10,  57,  49,  50,  56,  57,  124, 57,  52,
+    51,  55,  52,  55,  50,  46,  48,  48,  10,  53,  54,  55,  50,  51,  124,
+    57,  52,  51,  53,  49,  48,  50,  46,  49,  54,  10,  56,  54,  54,  52,
+    55,  124, 57,  52,  51,  52,  54,  48,  52,  46,  49,  56,  10,  49,  51,
+    49,  50,  51,  52,  124, 57,  52,  51,  50,  49,  50,  48,  46,  48,  48,
+    10,  49,  57,  56,  49,  50,  57,  124, 57,  52,  50,  55,  54,  53,  49,
+    46,  51,  54,  10,  49,  54,  53,  53,  51,  48,  124, 57,  52,  50,  54,
+    49,  57,  51,  46,  54,  56,  10,  54,  57,  50,  51,  51,  124, 57,  52,
+    50,  53,  48,  53,  51,  46,  57,  50,  10,  54,  50,  52,  51,  124, 57,
+    52,  50,  51,  51,  48,  52,  46,  54,  54,  10,  57,  48,  49,  49,  48,
+    124, 57,  52,  50,  48,  52,  50,  50,  46,  55,  48,  10,  49,  57,  49,
+    57,  56,  48,  124, 57,  52,  49,  57,  51,  54,  56,  46,  51,  54,  10,
+    51,  56,  52,  54,  49,  124, 57,  52,  49,  57,  51,  49,  54,  46,  48,
+    55,  10,  49,  54,  55,  56,  55,  51,  124, 57,  52,  49,  57,  48,  50,
+    52,  46,  52,  57,  10,  49,  53,  57,  51,  55,  51,  124, 57,  52,  49,
+    54,  57,  53,  48,  46,  49,  53,  10,  49,  50,  56,  55,  48,  55,  124,
+    57,  52,  49,  51,  52,  50,  56,  46,  53,  48,  10,  52,  53,  50,  54,
+    55,  124, 57,  52,  49,  48,  56,  54,  51,  46,  55,  56,  10,  52,  56,
+    52,  54,  48,  124, 57,  52,  48,  57,  55,  57,  51,  46,  57,  51,  10,
+    49,  57,  55,  54,  55,  50,  124, 57,  52,  48,  54,  56,  56,  55,  46,
+    54,  56,  10,  54,  48,  56,  56,  52,  124, 57,  52,  48,  51,  52,  52,
+    50,  46,  52,  48,  10,  49,  53,  50,  48,  57,  124, 57,  52,  48,  51,
+    50,  52,  53,  46,  51,  49,  10,  49,  51,  56,  48,  52,  57,  124, 57,
+    52,  48,  49,  50,  54,  50,  46,  49,  48,  10,  49,  57,  57,  50,  56,
+    54,  124, 57,  51,  57,  49,  55,  55,  48,  46,  55,  48,  10,  49,  57,
+    54,  50,  57,  124, 57,  51,  57,  49,  50,  51,  54,  46,  52,  48,  10,
+    49,  51,  52,  48,  49,  57,  124, 57,  51,  57,  48,  54,  49,  53,  46,
+    49,  53,  10,  49,  54,  57,  52,  55,  53,  124, 57,  51,  56,  55,  54,
+    51,  57,  46,  53,  56,  10,  49,  54,  53,  57,  49,  56,  124, 57,  51,
+    55,  57,  53,  49,  48,  46,  52,  52,  10,  49,  51,  53,  54,  48,  50,
+    124, 57,  51,  55,  52,  50,  53,  49,  46,  53,  52,  10,  49,  54,  50,
+    51,  50,  51,  124, 57,  51,  54,  55,  53,  54,  54,  46,  53,  49,  10,
+    57,  54,  50,  55,  55,  124, 57,  51,  54,  48,  56,  53,  48,  46,  54,
+    56,  10,  57,  56,  51,  51,  54,  124, 57,  51,  53,  57,  54,  55,  49,
+    46,  50,  57,  10,  49,  49,  57,  55,  56,  49,  124, 57,  51,  53,  54,
+    51,  57,  53,  46,  55,  51,  10,  51,  52,  52,  52,  48,  124, 57,  51,
+    53,  53,  51,  54,  53,  46,  48,  48,  10,  53,  55,  51,  54,  50,  124,
+    57,  51,  53,  53,  49,  56,  48,  46,  49,  48,  10,  49,  54,  55,  50,
+    51,  54,  124, 57,  51,  53,  50,  57,  55,  51,  46,  56,  52,  10,  51,
+    56,  52,  54,  51,  124, 57,  51,  52,  55,  53,  51,  48,  46,  57,  52,
+    10,  56,  54,  55,  52,  57,  124, 57,  51,  52,  54,  56,  50,  54,  46,
+    52,  52,  10,  49,  55,  48,  48,  48,  55,  124, 57,  51,  52,  53,  54,
+    57,  57,  46,  57,  48,  10,  49,  57,  51,  48,  56,  55,  124, 57,  51,
+    52,  51,  55,  52,  52,  46,  48,  48,  10,  49,  53,  48,  51,  56,  51,
+    124, 57,  51,  51,  50,  53,  55,  54,  46,  55,  53,  10,  54,  48,  57,
+    51,  50,  124, 57,  51,  50,  57,  53,  56,  50,  46,  48,  50,  10,  49,
+    50,  56,  52,  50,  48,  124, 57,  51,  50,  56,  50,  48,  54,  46,  51,
+    53,  10,  49,  54,  50,  49,  52,  53,  124, 57,  51,  50,  55,  55,  50,
+    50,  46,  56,  56,  10,  53,  53,  54,  56,  54,  124, 57,  51,  50,  48,
+    51,  48,  52,  46,  52,  48,  10,  49,  54,  51,  48,  56,  48,  124, 57,
+    51,  48,  52,  57,  49,  54,  46,  57,  54,  10,  49,  54,  48,  53,  56,
+    51,  124, 57,  51,  48,  51,  53,  49,  53,  46,  57,  50,  10,  49,  49,
+    56,  49,  53,  51,  124, 57,  50,  57,  56,  54,  48,  54,  46,  53,  54,
+    10,  49,  53,  50,  54,  51,  52,  124, 57,  50,  56,  50,  49,  56,  52,
+    46,  53,  55,  10,  56,  52,  55,  51,  49,  124, 57,  50,  55,  54,  53,
+    56,  54,  46,  57,  50,  10,  49,  49,  57,  57,  56,  57,  124, 57,  50,
+    55,  51,  56,  49,  52,  46,  50,  48,  10,  49,  49,  52,  53,  56,  52,
+    124, 57,  50,  54,  57,  54,  57,  56,  46,  54,  53,  10,  49,  51,  49,
+    56,  49,  55,  124, 57,  50,  54,  56,  53,  55,  48,  46,  48,  56,  10,
+    50,  57,  48,  54,  56,  124, 57,  50,  53,  54,  53,  56,  51,  46,  56,
+    56,  10,  52,  52,  49,  49,  54,  124, 57,  50,  53,  53,  57,  50,  50,
+    46,  48,  48,  10,  49,  49,  53,  56,  49,  56,  124, 57,  50,  53,  51,
+    51,  49,  49,  46,  57,  49,  10,  49,  48,  51,  51,  56,  56,  124, 57,
+    50,  51,  57,  50,  49,  56,  46,  48,  56,  10,  49,  56,  54,  49,  49,
+    56,  124, 57,  50,  51,  54,  50,  48,  57,  46,  49,  50,  10,  49,  53,
+    53,  56,  48,  57,  124, 57,  50,  51,  53,  52,  49,  48,  46,  56,  52,
+    10,  49,  52,  55,  48,  48,  51,  124, 57,  50,  51,  52,  56,  52,  55,
+    46,  57,  57,  10,  50,  55,  55,  54,  57,  124, 57,  50,  51,  50,  53,
+    49,  49,  46,  54,  52,  10,  49,  49,  50,  55,  55,  57,  124, 57,  50,
+    51,  49,  57,  50,  55,  46,  51,  54,  10,  49,  50,  52,  56,  53,  49,
+    124, 57,  50,  50,  56,  57,  56,  50,  46,  54,  56,  10,  49,  53,  56,
+    52,  56,  56,  124, 57,  50,  50,  55,  50,  49,  54,  46,  52,  48,  10,
+    56,  51,  51,  50,  56,  124, 57,  50,  50,  52,  55,  57,  50,  46,  50,
+    48,  10,  49,  51,  54,  55,  57,  55,  124, 57,  50,  50,  50,  57,  50,
+    55,  46,  48,  57,  10,  49,  52,  49,  55,  51,  48,  124, 57,  50,  49,
+    54,  51,  55,  48,  46,  54,  56,  10,  56,  55,  51,  48,  52,  124, 57,
+    50,  49,  53,  54,  57,  53,  46,  53,  48,  10,  49,  53,  54,  48,  48,
+    52,  124, 57,  50,  49,  53,  53,  53,  55,  46,  57,  48,  10,  49,  52,
+    48,  55,  52,  48,  124, 57,  50,  49,  53,  51,  50,  57,  46,  50,  48,
+    10,  49,  48,  48,  54,  52,  56,  124, 57,  50,  49,  50,  49,  56,  53,
+    46,  48,  56,  10,  49,  55,  52,  55,  55,  52,  124, 57,  50,  49,  49,
+    55,  49,  56,  46,  48,  48,  10,  51,  55,  54,  52,  52,  124, 57,  50,
+    49,  49,  53,  55,  56,  46,  54,  48,  10,  52,  56,  56,  48,  55,  124,
+    57,  50,  48,  57,  52,  57,  54,  46,  50,  52,  10,  57,  53,  57,  52,
+    48,  124, 57,  50,  48,  55,  57,  52,  56,  46,  52,  48,  10,  49,  52,
+    49,  53,  56,  54,  124, 57,  50,  48,  54,  54,  57,  57,  46,  50,  50,
+    10,  49,  52,  55,  50,  52,  56,  124, 57,  50,  48,  53,  54,  53,  52,
+    46,  57,  53,  10,  54,  49,  51,  55,  50,  124, 57,  50,  48,  53,  50,
+    50,  56,  46,  55,  54,  10,  53,  50,  57,  55,  48,  124, 57,  50,  48,
+    52,  52,  49,  53,  46,  57,  53,  10,  50,  54,  52,  51,  48,  124, 57,
+    50,  48,  51,  55,  49,  48,  46,  53,  49,  10,  50,  56,  53,  48,  52,
+    124, 57,  50,  48,  49,  54,  54,  57,  46,  50,  48,  10,  50,  53,  56,
+    49,  48,  124, 57,  49,  57,  56,  56,  55,  56,  46,  53,  48,  10,  49,
+    50,  53,  51,  50,  57,  124, 57,  49,  57,  56,  54,  56,  56,  46,  53,
+    48,  10,  49,  54,  55,  56,  54,  55,  124, 57,  49,  57,  52,  48,  50,
+    50,  46,  55,  50,  10,  49,  51,  52,  55,  54,  55,  124, 57,  49,  57,
+    49,  52,  52,  52,  46,  55,  50,  10,  49,  50,  55,  55,  52,  53,  124,
+    57,  49,  57,  49,  50,  55,  49,  46,  53,  54,  10,  54,  57,  50,  48,
+    56,  124, 57,  49,  56,  55,  49,  49,  48,  46,  48,  48,  10,  49,  53,
+    53,  50,  50,  50,  124, 57,  49,  56,  54,  52,  54,  57,  46,  49,  54,
+    10,  49,  57,  54,  57,  49,  54,  124, 57,  49,  56,  50,  57,  57,  53,
+    46,  56,  50,  10,  49,  57,  53,  53,  57,  48,  124, 57,  49,  55,  54,
+    51,  53,  51,  46,  49,  50,  10,  49,  54,  57,  49,  53,  53,  124, 57,
+    49,  55,  53,  49,  55,  54,  46,  48,  57,  10,  56,  49,  53,  53,  56,
+    124, 57,  49,  55,  49,  57,  52,  54,  46,  53,  48,  10,  49,  56,  53,
+    49,  51,  54,  124, 57,  49,  55,  49,  50,  57,  51,  46,  48,  52,  10,
+    49,  49,  52,  55,  57,  48,  124, 57,  49,  54,  56,  53,  48,  57,  46,
+    49,  48,  10,  49,  57,  52,  49,  52,  50,  124, 57,  49,  54,  53,  56,
+    51,  54,  46,  54,  49,  10,  49,  54,  55,  54,  51,  57,  124, 57,  49,
+    54,  49,  49,  54,  53,  46,  48,  48,  10,  49,  49,  50,  52,  49,  124,
+    57,  49,  54,  48,  55,  56,  57,  46,  52,  54,  10,  56,  50,  54,  50,
+    56,  124, 57,  49,  54,  48,  49,  53,  53,  46,  53,  52,  10,  52,  49,
+    51,  57,  57,  124, 57,  49,  52,  56,  51,  51,  56,  46,  48,  48,  10,
+    51,  48,  55,  53,  53,  124, 57,  49,  52,  54,  49,  57,  54,  46,  56,
+    52,  10,  54,  57,  52,  52,  124, 57,  49,  52,  51,  53,  55,  52,  46,
+    53,  56,  10,  54,  51,  50,  54,  124, 57,  49,  51,  56,  56,  48,  51,
+    46,  49,  54,  10,  49,  48,  49,  50,  57,  54,  124, 57,  49,  51,  53,
+    54,  53,  55,  46,  54,  50,  10,  49,  56,  49,  52,  55,  57,  124, 57,
+    49,  50,  49,  48,  57,  51,  46,  51,  48,  10,  55,  54,  56,  57,  56,
+    124, 57,  49,  50,  48,  57,  56,  51,  46,  49,  48,  10,  54,  52,  50,
+    55,  52,  124, 57,  49,  49,  56,  55,  52,  53,  46,  50,  53,  10,  49,
+    55,  53,  56,  50,  54,  124, 57,  49,  49,  55,  51,  56,  55,  46,  57,
+    57,  10,  49,  52,  50,  50,  49,  53,  124, 57,  49,  49,  54,  56,  55,
+    54,  46,  56,  56,  10,  49,  48,  51,  52,  49,  53,  124, 57,  49,  49,
+    51,  49,  50,  56,  46,  54,  50,  10,  49,  49,  57,  55,  54,  53,  124,
+    57,  49,  49,  48,  55,  54,  56,  46,  55,  57,  10,  49,  48,  55,  54,
+    50,  52,  124, 57,  49,  48,  56,  56,  51,  55,  46,  52,  53,  10,  56,
+    52,  50,  49,  53,  124, 57,  49,  48,  53,  50,  53,  55,  46,  51,  54,
+    10,  55,  51,  55,  55,  52,  124, 57,  49,  48,  50,  54,  53,  49,  46,
+    57,  50,  10,  49,  55,  51,  57,  55,  50,  124, 57,  49,  48,  50,  48,
+    54,  57,  46,  48,  48,  10,  54,  57,  56,  49,  55,  124, 57,  48,  57,
+    53,  53,  49,  51,  46,  56,  56,  10,  56,  54,  57,  52,  51,  124, 57,
+    48,  57,  50,  50,  53,  51,  46,  48,  48,  10,  49,  51,  56,  56,  53,
+    57,  124, 57,  48,  56,  55,  55,  49,  57,  46,  51,  48,  10,  49,  54,
+    50,  50,  55,  51,  124, 57,  48,  56,  53,  50,  57,  54,  46,  52,  56,
+    10,  49,  55,  53,  57,  52,  53,  124, 57,  48,  56,  48,  52,  48,  49,
+    46,  50,  49,  10,  49,  54,  56,  51,  54,  124, 57,  48,  55,  53,  55,
+    49,  53,  46,  52,  52,  10,  55,  48,  50,  50,  52,  124, 57,  48,  55,
+    53,  50,  54,  53,  46,  57,  53,  10,  49,  51,  57,  55,  54,  53,  124,
+    57,  48,  55,  52,  55,  53,  53,  46,  56,  57,  10,  51,  48,  51,  49,
+    57,  124, 57,  48,  55,  51,  50,  51,  51,  46,  49,  48,  10,  51,  56,
+    53,  49,  124, 57,  48,  55,  50,  54,  53,  55,  46,  50,  52,  10,  49,
+    56,  49,  50,  55,  49,  124, 57,  48,  55,  48,  54,  51,  49,  46,  53,
+    50,  10,  49,  54,  50,  49,  56,  52,  124, 57,  48,  54,  56,  56,  51,
+    53,  46,  55,  56,  10,  56,  49,  54,  56,  51,  124, 57,  48,  54,  55,
+    50,  53,  56,  46,  52,  55,  10,  49,  53,  51,  48,  50,  56,  124, 57,
+    48,  54,  55,  48,  49,  48,  46,  53,  49,  10,  49,  50,  51,  51,  50,
+    52,  124, 57,  48,  54,  49,  56,  55,  48,  46,  57,  53,  10,  49,  56,
+    54,  52,  56,  49,  124, 57,  48,  53,  56,  54,  48,  56,  46,  51,  48,
+    10,  49,  54,  55,  54,  56,  48,  124, 57,  48,  53,  50,  57,  48,  56,
+    46,  55,  54,  10,  49,  54,  53,  50,  57,  51,  124, 57,  48,  53,  48,
+    53,  52,  53,  46,  55,  48,  10,  49,  50,  50,  49,  52,  56,  124, 57,
+    48,  52,  54,  50,  57,  56,  46,  49,  55,  10,  49,  51,  56,  54,  48,
+    52,  124, 57,  48,  52,  53,  56,  52,  48,  46,  56,  48,  10,  55,  56,
+    56,  53,  49,  124, 57,  48,  52,  52,  56,  50,  50,  46,  54,  48,  10,
+    49,  51,  55,  50,  56,  48,  124, 57,  48,  52,  50,  51,  53,  53,  46,
+    51,  52,  10,  56,  56,  50,  51,  124, 57,  48,  52,  48,  56,  53,  53,
+    46,  49,  48,  10,  49,  54,  51,  57,  48,  48,  124, 57,  48,  52,  48,
+    56,  52,  56,  46,  52,  56,  10,  55,  53,  54,  48,  48,  124, 57,  48,
+    51,  53,  51,  57,  50,  46,  52,  53,  10,  56,  49,  54,  55,  54,  124,
+    57,  48,  51,  49,  57,  57,  57,  46,  52,  48,  10,  52,  54,  48,  51,
+    51,  124, 57,  48,  51,  49,  52,  54,  48,  46,  53,  56,  10,  49,  57,
+    52,  57,  49,  55,  124, 57,  48,  50,  56,  53,  48,  48,  46,  48,  48,
+    10,  49,  51,  51,  57,  51,  54,  124, 57,  48,  50,  54,  57,  52,  57,
+    46,  48,  50,  10,  51,  51,  49,  56,  50,  124, 57,  48,  50,  52,  57,
+    55,  49,  46,  49,  48,  10,  51,  52,  50,  50,  48,  124, 57,  48,  50,
+    49,  52,  56,  53,  46,  51,  57,  10,  50,  48,  49,  49,  56,  124, 57,
+    48,  49,  57,  57,  52,  50,  46,  54,  48,  10,  49,  55,  56,  50,  53,
+    56,  124, 57,  48,  49,  57,  56,  56,  49,  46,  54,  54,  10,  49,  53,
+    53,  54,  48,  124, 57,  48,  49,  55,  54,  56,  55,  46,  50,  56,  10,
+    49,  49,  49,  52,  50,  53,  124, 57,  48,  49,  54,  49,  57,  56,  46,
+    53,  54,  10,  57,  53,  57,  52,  50,  124, 57,  48,  49,  53,  53,  56,
+    53,  46,  49,  50,  10,  49,  51,  50,  55,  48,  57,  124, 57,  48,  49,
+    53,  50,  52,  48,  46,  49,  53,  10,  51,  57,  55,  51,  49,  124, 57,
+    48,  49,  52,  55,  52,  54,  46,  57,  53,  10,  49,  53,  52,  51,  48,
+    55,  124, 57,  48,  49,  50,  53,  55,  49,  46,  50,  48,  10,  50,  51,
+    55,  54,  57,  124, 57,  48,  48,  56,  49,  53,  55,  46,  54,  48,  10,
+    57,  51,  51,  50,  56,  124, 57,  48,  48,  55,  50,  49,  49,  46,  50,
+    48,  10,  49,  52,  50,  56,  50,  54,  124, 56,  57,  57,  56,  50,  57,
+    55,  46,  52,  52,  10,  49,  56,  56,  55,  57,  50,  124, 56,  57,  57,
+    54,  48,  49,  52,  46,  48,  48,  10,  54,  56,  55,  48,  51,  124, 56,
+    57,  57,  52,  57,  56,  50,  46,  50,  50,  10,  49,  52,  53,  50,  56,
+    48,  124, 56,  57,  57,  48,  57,  52,  49,  46,  48,  53,  10,  49,  53,
+    48,  55,  50,  53,  124, 56,  57,  56,  53,  54,  56,  54,  46,  49,  54,
+    10,  49,  55,  50,  48,  52,  54,  124, 56,  57,  56,  50,  52,  54,  57,
+    46,  53,  50,  10,  55,  48,  52,  55,  54,  124, 56,  57,  54,  55,  54,
+    50,  57,  46,  53,  48,  10,  49,  50,  52,  57,  56,  56,  124, 56,  57,
+    54,  54,  56,  48,  53,  46,  50,  50,  10,  49,  55,  57,  51,  55,  124,
+    56,  57,  54,  51,  51,  49,  57,  46,  55,  54,  10,  49,  55,  55,  51,
+    55,  50,  124, 56,  57,  53,  52,  56,  55,  51,  46,  54,  52,  10,  49,
+    51,  55,  57,  57,  52,  124, 56,  57,  53,  48,  57,  49,  54,  46,  55,
+    57,  10,  56,  52,  48,  49,  57,  124, 56,  57,  53,  48,  48,  51,  57,
+    46,  57,  56,  10,  52,  48,  51,  56,  57,  124, 56,  57,  52,  54,  49,
+    53,  56,  46,  50,  48,  10,  54,  57,  49,  56,  55,  124, 56,  57,  52,
+    49,  48,  53,  52,  46,  49,  52,  10,  52,  56,  54,  51,  124, 56,  57,
+    51,  57,  48,  52,  52,  46,  57,  50,  10,  53,  48,  52,  54,  53,  124,
+    56,  57,  51,  48,  53,  48,  51,  46,  49,  52,  10,  52,  51,  54,  56,
+    54,  124, 56,  57,  49,  53,  53,  52,  51,  46,  56,  52,  10,  49,  51,
+    49,  51,  53,  50,  124, 56,  57,  48,  57,  48,  53,  51,  46,  53,  57,
+    10,  49,  57,  56,  57,  49,  54,  124, 56,  57,  48,  54,  57,  52,  48,
+    46,  48,  51,  10,  49,  51,  53,  57,  51,  50,  124, 56,  57,  48,  53,
+    50,  56,  50,  46,  57,  53,  10,  49,  48,  52,  54,  55,  51,  124, 56,
+    57,  48,  51,  54,  56,  50,  46,  48,  48,  10,  49,  53,  50,  51,  48,
+    56,  124, 56,  57,  48,  51,  50,  52,  52,  46,  48,  56,  10,  49,  51,
+    53,  50,  57,  56,  124, 56,  57,  48,  48,  51,  50,  51,  46,  50,  48,
+    10,  49,  53,  54,  56,  55,  51,  124, 56,  56,  57,  57,  52,  50,  57,
+    46,  49,  48,  10,  49,  53,  55,  52,  53,  52,  124, 56,  56,  57,  55,
+    51,  51,  57,  46,  50,  48,  10,  55,  53,  52,  49,  53,  124, 56,  56,
+    57,  55,  48,  54,  56,  46,  48,  57,  10,  52,  54,  51,  50,  53,  124,
+    56,  56,  57,  53,  53,  54,  57,  46,  48,  57,  10,  49,  57,  54,  54,
+    124, 56,  56,  57,  53,  49,  49,  55,  46,  48,  54,  10,  50,  52,  53,
+    55,  54,  124, 56,  56,  57,  53,  48,  51,  52,  46,  55,  53,  10,  49,
+    57,  52,  50,  53,  124, 56,  56,  57,  48,  49,  53,  54,  46,  54,  48,
+    10,  49,  54,  57,  55,  51,  53,  124, 56,  56,  57,  48,  48,  56,  53,
+    46,  53,  54,  10,  51,  50,  50,  50,  53,  124, 56,  56,  56,  57,  56,
+    50,  57,  46,  50,  56,  10,  49,  50,  52,  53,  51,  55,  124, 56,  56,
+    56,  57,  55,  55,  48,  46,  55,  49,  10,  49,  52,  54,  51,  50,  55,
+    124, 56,  56,  56,  55,  56,  51,  54,  46,  50,  51,  10,  49,  50,  49,
+    53,  54,  50,  124, 56,  56,  56,  55,  55,  52,  48,  46,  52,  48,  10,
+    52,  52,  55,  51,  49,  124, 56,  56,  56,  50,  52,  52,  52,  46,  57,
+    53,  10,  57,  51,  49,  52,  49,  124, 56,  56,  56,  49,  56,  53,  48,
+    46,  56,  56,  10,  49,  56,  55,  56,  55,  49,  124, 56,  56,  55,  51,
+    53,  48,  54,  46,  49,  56,  10,  55,  49,  55,  48,  57,  124, 56,  56,
+    55,  51,  48,  53,  55,  46,  50,  56,  10,  49,  53,  49,  57,  49,  51,
+    124, 56,  56,  54,  57,  51,  50,  49,  46,  49,  55,  10,  51,  51,  55,
+    56,  54,  124, 56,  56,  54,  56,  57,  53,  53,  46,  51,  57,  10,  51,
+    53,  57,  48,  50,  124, 56,  56,  54,  56,  49,  50,  54,  46,  48,  54,
+    10,  50,  51,  53,  56,  56,  124, 56,  56,  54,  55,  55,  54,  57,  46,
+    57,  48,  10,  50,  52,  53,  48,  56,  124, 56,  56,  54,  55,  54,  49,
+    54,  46,  48,  48,  10,  49,  54,  49,  50,  56,  50,  124, 56,  56,  54,
+    54,  54,  54,  49,  46,  52,  51,  10,  49,  56,  56,  48,  54,  49,  124,
+    56,  56,  54,  50,  51,  48,  52,  46,  48,  48,  10,  49,  51,  50,  56,
+    52,  55,  124, 56,  56,  54,  50,  48,  56,  50,  46,  48,  48,  10,  49,
+    54,  54,  56,  52,  51,  124, 56,  56,  54,  49,  50,  48,  48,  46,  56,
+    48,  10,  51,  48,  54,  48,  57,  124, 56,  56,  54,  48,  50,  49,  52,
+    46,  55,  51,  10,  53,  54,  49,  57,  49,  124, 56,  56,  53,  54,  53,
+    52,  54,  46,  57,  54,  10,  49,  54,  48,  55,  52,  48,  124, 56,  56,
+    53,  50,  54,  56,  53,  46,  52,  51,  10,  55,  49,  50,  50,  57,  124,
+    56,  56,  52,  54,  49,  48,  54,  46,  57,  57,  10,  57,  49,  50,  48,
+    56,  124, 56,  56,  52,  53,  53,  52,  49,  46,  50,  56,  10,  49,  48,
+    57,  57,  53,  124, 56,  56,  52,  53,  51,  48,  54,  46,  53,  54,  10,
+    55,  56,  48,  57,  52,  124, 56,  56,  51,  57,  57,  51,  56,  46,  50,
+    57,  10,  51,  54,  52,  56,  57,  124, 56,  56,  51,  56,  53,  51,  56,
+    46,  49,  48,  10,  49,  57,  56,  52,  51,  55,  124, 56,  56,  51,  54,
+    52,  57,  52,  46,  56,  52,  10,  49,  53,  49,  54,  57,  51,  124, 56,
+    56,  51,  51,  56,  48,  55,  46,  54,  52,  10,  49,  56,  53,  51,  54,
+    55,  124, 56,  56,  50,  57,  55,  57,  49,  46,  51,  55,  10,  54,  53,
+    54,  56,  50,  124, 56,  56,  50,  48,  54,  50,  50,  46,  56,  57,  10,
+    54,  53,  52,  50,  49,  124, 56,  56,  49,  57,  51,  50,  57,  46,  50,
+    52,  10,  49,  50,  50,  50,  50,  53,  124, 56,  56,  49,  54,  56,  50,
+    49,  46,  56,  54,  10,  56,  53,  51,  51,  48,  124, 56,  56,  49,  49,
+    48,  49,  51,  46,  49,  54,  10,  54,  52,  53,  53,  53,  124, 56,  56,
+    49,  48,  54,  52,  51,  46,  49,  50,  10,  49,  48,  52,  49,  56,  56,
+    124, 56,  56,  48,  56,  50,  49,  49,  46,  48,  50,  10,  53,  52,  52,
+    49,  49,  124, 56,  56,  48,  53,  55,  48,  51,  46,  52,  48,  10,  51,
+    57,  52,  51,  56,  124, 56,  56,  48,  53,  50,  56,  50,  46,  53,  54,
+    10,  55,  48,  55,  57,  53,  124, 56,  56,  48,  48,  48,  54,  48,  46,
+    57,  50,  10,  50,  48,  51,  56,  51,  124, 56,  55,  57,  57,  48,  55,
+    51,  46,  50,  56,  10,  50,  49,  57,  53,  50,  124, 56,  55,  57,  56,
+    54,  50,  52,  46,  49,  57,  10,  54,  51,  53,  56,  52,  124, 56,  55,
+    57,  54,  53,  57,  48,  46,  48,  48,  10,  49,  53,  56,  55,  54,  56,
+    124, 56,  55,  57,  54,  52,  50,  50,  46,  57,  53,  10,  49,  54,  54,
+    53,  56,  56,  124, 56,  55,  57,  54,  50,  49,  52,  46,  51,  56,  10,
+    49,  50,  48,  54,  48,  48,  124, 56,  55,  57,  51,  53,  53,  56,  46,
+    48,  54,  10,  49,  53,  55,  50,  48,  50,  124, 56,  55,  56,  56,  50,
+    56,  55,  46,  56,  56,  10,  53,  53,  51,  53,  56,  124, 56,  55,  56,
+    54,  56,  50,  48,  46,  55,  53,  10,  49,  54,  56,  51,  50,  50,  124,
+    56,  55,  56,  54,  54,  55,  48,  46,  55,  51,  10,  50,  53,  49,  52,
+    51,  124, 56,  55,  56,  54,  51,  50,  52,  46,  56,  48,  10,  53,  51,
+    54,  56,  124, 56,  55,  56,  54,  50,  55,  52,  46,  49,  52,  10,  49,
+    49,  52,  48,  50,  53,  124, 56,  55,  56,  54,  50,  48,  49,  46,  49,
+    50,  10,  57,  55,  55,  52,  52,  124, 56,  55,  56,  53,  51,  49,  53,
+    46,  57,  52,  10,  49,  54,  52,  51,  50,  55,  124, 56,  55,  56,  52,
+    53,  48,  51,  46,  56,  54,  10,  55,  54,  53,  52,  50,  124, 56,  55,
+    56,  50,  54,  49,  51,  46,  50,  56,  10,  52,  55,  51,  49,  124, 56,
+    55,  55,  50,  56,  52,  54,  46,  55,  48,  10,  49,  53,  55,  53,  57,
+    48,  124, 56,  55,  55,  50,  48,  48,  54,  46,  52,  53,  10,  49,  53,
+    52,  50,  55,  54,  124, 56,  55,  55,  49,  55,  51,  51,  46,  57,  49,
+    10,  50,  56,  55,  48,  53,  124, 56,  55,  55,  49,  53,  55,  54,  46,
+    54,  52,  10,  49,  48,  48,  50,  50,  54,  124, 56,  55,  54,  57,  52,
+    53,  53,  46,  48,  48,  10,  49,  55,  57,  49,  57,  53,  124, 56,  55,
+    54,  57,  49,  56,  53,  46,  49,  54,  10,  49,  56,  52,  51,  53,  53,
+    124, 56,  55,  54,  56,  49,  49,  56,  46,  48,  53,  10,  49,  50,  48,
+    52,  48,  56,  124, 56,  55,  54,  56,  48,  49,  49,  46,  49,  50,  10,
+    54,  51,  49,  52,  53,  124, 56,  55,  54,  49,  57,  57,  49,  46,  57,
+    54,  10,  53,  51,  49,  51,  53,  124, 56,  55,  53,  51,  52,  57,  49,
+    46,  56,  48,  10,  49,  55,  51,  48,  55,  49,  124, 56,  55,  53,  48,
+    53,  48,  56,  46,  56,  48,  10,  52,  49,  48,  56,  55,  124, 56,  55,
+    52,  57,  52,  51,  54,  46,  55,  57,  10,  49,  57,  52,  56,  51,  48,
+    124, 56,  55,  52,  55,  52,  51,  56,  46,  52,  48,  10,  52,  51,  52,
+    57,  54,  124, 56,  55,  52,  51,  51,  53,  57,  46,  51,  48,  10,  51,
+    48,  50,  51,  53,  124, 56,  55,  52,  49,  54,  49,  49,  46,  48,  48,
+    10,  50,  54,  51,  57,  49,  124, 56,  55,  52,  49,  51,  57,  57,  46,
+    54,  52,  10,  49,  57,  49,  56,  49,  54,  124, 56,  55,  52,  48,  50,
+    53,  56,  46,  55,  50,  10,  52,  55,  54,  49,  54,  124, 56,  55,  51,
+    55,  50,  50,  57,  46,  54,  56,  10,  49,  53,  50,  49,  48,  49,  124,
+    56,  55,  51,  52,  52,  51,  50,  46,  55,  54,  10,  49,  54,  51,  55,
+    56,  52,  124, 56,  55,  51,  48,  53,  49,  52,  46,  51,  52,  10,  53,
+    49,  51,  52,  124, 56,  55,  50,  56,  52,  50,  52,  46,  54,  52,  10,
+    49,  53,  53,  50,  52,  49,  124, 56,  55,  50,  53,  52,  50,  57,  46,
+    56,  54,  10,  49,  56,  56,  56,  49,  52,  124, 56,  55,  50,  52,  49,
+    56,  50,  46,  52,  48,  10,  49,  52,  48,  55,  56,  50,  124, 56,  55,
+    50,  48,  51,  55,  56,  46,  55,  53,  10,  49,  53,  51,  49,  52,  49,
+    124, 56,  55,  49,  57,  52,  48,  55,  46,  53,  49,  10,  49,  54,  57,
+    51,  55,  51,  124, 56,  55,  49,  56,  54,  48,  57,  46,  48,  54,  10,
+    52,  49,  51,  51,  53,  124, 56,  55,  49,  52,  55,  55,  51,  46,  56,
+    48,  10,  49,  57,  55,  52,  53,  48,  124, 56,  55,  49,  52,  54,  49,
+    55,  46,  51,  50,  10,  56,  55,  48,  48,  52,  124, 56,  55,  49,  52,
+    48,  49,  55,  46,  55,  57,  10,  49,  56,  49,  56,  48,  52,  124, 56,
+    55,  49,  50,  50,  53,  55,  46,  55,  54,  10,  49,  50,  50,  56,  49,
+    52,  124, 56,  55,  49,  49,  49,  49,  57,  46,  49,  52,  10,  49,  48,
+    57,  57,  51,  57,  124, 56,  55,  48,  57,  49,  57,  51,  46,  49,  54,
+    10,  57,  56,  48,  57,  52,  124, 56,  55,  48,  56,  55,  56,  48,  46,
+    48,  52,  10,  55,  52,  54,  51,  48,  124, 56,  55,  48,  56,  48,  52,
+    48,  46,  55,  53,  10,  49,  57,  55,  50,  57,  49,  124, 56,  55,  48,
+    54,  53,  49,  57,  46,  48,  57,  10,  49,  56,  52,  49,  55,  51,  124,
+    56,  55,  48,  53,  52,  54,  55,  46,  52,  53,  10,  49,  57,  50,  49,
+    55,  53,  124, 56,  55,  48,  53,  52,  49,  49,  46,  49,  50,  10,  49,
+    57,  52,  55,  49,  124, 56,  55,  48,  50,  53,  51,  54,  46,  49,  50,
+    10,  49,  56,  48,  53,  50,  124, 56,  55,  48,  50,  49,  53,  53,  46,
+    55,  48,  10,  49,  51,  53,  53,  54,  48,  124, 56,  54,  57,  56,  49,
+    51,  55,  46,  55,  50,  10,  49,  53,  50,  55,  57,  49,  124, 56,  54,
+    57,  55,  51,  50,  53,  46,  56,  48,  10,  49,  55,  48,  57,  53,  51,
+    124, 56,  54,  57,  54,  57,  48,  57,  46,  49,  57,  10,  49,  49,  54,
+    49,  51,  55,  124, 56,  54,  57,  54,  54,  56,  55,  46,  49,  55,  10,
+    55,  55,  50,  50,  124, 56,  54,  57,  54,  53,  56,  57,  46,  52,  48,
+    10,  52,  57,  55,  56,  56,  124, 56,  54,  57,  52,  56,  52,  54,  46,
+    55,  49,  10,  49,  51,  50,  53,  50,  124, 56,  54,  57,  52,  56,  50,
+    50,  46,  52,  50,  10,  49,  50,  54,  51,  51,  124, 56,  54,  57,  52,
+    53,  53,  57,  46,  51,  54,  10,  49,  57,  51,  52,  51,  56,  124, 56,
+    54,  57,  48,  52,  50,  54,  46,  55,  50,  10,  49,  55,  51,  50,  54,
+    124, 56,  54,  56,  57,  51,  50,  57,  46,  49,  54,  10,  57,  54,  49,
+    50,  52,  124, 56,  54,  55,  57,  55,  57,  52,  46,  53,  56,  10,  49,
+    52,  51,  56,  48,  50,  124, 56,  54,  55,  54,  54,  50,  54,  46,  52,
+    56,  10,  51,  48,  51,  56,  57,  124, 56,  54,  55,  53,  56,  50,  54,
+    46,  54,  48,  10,  55,  53,  50,  53,  48,  124, 56,  54,  55,  53,  50,
+    53,  55,  46,  49,  52,  10,  55,  50,  54,  49,  51,  124, 56,  54,  55,
+    51,  53,  50,  52,  46,  57,  52,  10,  49,  50,  51,  53,  50,  48,  124,
+    56,  54,  55,  50,  52,  53,  54,  46,  50,  53,  10,  51,  50,  53,  124,
+    56,  54,  54,  55,  55,  52,  49,  46,  50,  56,  10,  49,  54,  55,  50,
+    57,  49,  124, 56,  54,  54,  55,  53,  53,  54,  46,  49,  56,  10,  49,
+    53,  48,  49,  49,  57,  124, 56,  54,  54,  51,  52,  48,  51,  46,  53,
+    52,  10,  56,  56,  52,  50,  48,  124, 56,  54,  54,  51,  51,  53,  53,
+    46,  52,  48,  10,  49,  55,  57,  55,  56,  52,  124, 56,  54,  53,  51,
+    48,  50,  49,  46,  51,  52,  10,  49,  51,  48,  56,  56,  52,  124, 56,
+    54,  53,  49,  57,  55,  48,  46,  48,  48,  10,  49,  55,  50,  54,  49,
+    49,  124, 56,  54,  52,  56,  50,  49,  55,  46,  48,  48,  10,  56,  53,
+    51,  55,  51,  124, 56,  54,  52,  55,  55,  57,  54,  46,  50,  50,  10,
+    49,  50,  50,  55,  49,  55,  124, 56,  54,  52,  54,  55,  53,  56,  46,
+    53,  52,  10,  49,  49,  51,  52,  51,  49,  124, 56,  54,  52,  54,  51,
+    52,  56,  46,  51,  52,  10,  54,  54,  48,  49,  53,  124, 56,  54,  52,
+    51,  51,  52,  57,  46,  52,  48,  10,  51,  51,  49,  52,  49,  124, 56,
+    54,  52,  51,  50,  52,  51,  46,  49,  56,  10,  54,  57,  55,  56,  54,
+    124, 56,  54,  51,  55,  51,  57,  54,  46,  57,  50,  10,  49,  56,  49,
+    56,  53,  55,  124, 56,  54,  51,  55,  51,  57,  51,  46,  50,  56,  10,
+    49,  50,  50,  57,  51,  57,  124, 56,  54,  51,  54,  51,  55,  56,  46,
+    48,  48,  10,  49,  57,  54,  50,  50,  51,  124, 56,  54,  51,  53,  51,
+    57,  49,  46,  48,  50,  10,  53,  48,  53,  51,  50,  124, 56,  54,  51,
+    50,  54,  52,  56,  46,  50,  52,  10,  53,  56,  49,  48,  50,  124, 56,
+    54,  51,  50,  54,  49,  52,  46,  53,  52,  10,  57,  51,  53,  56,  49,
+    124, 56,  54,  51,  50,  51,  55,  50,  46,  51,  54,  10,  53,  50,  56,
+    48,  52,  124, 56,  54,  51,  50,  49,  48,  57,  46,  50,  53,  10,  55,
+    53,  53,  124, 56,  54,  50,  55,  48,  57,  49,  46,  54,  56,  10,  49,
+    54,  53,  57,  55,  124, 56,  54,  50,  51,  51,  53,  55,  46,  48,  53,
+    10,  49,  49,  57,  48,  52,  49,  124, 56,  54,  50,  50,  51,  57,  55,
+    46,  48,  48,  10,  56,  57,  48,  53,  48,  124, 56,  54,  50,  49,  49,
+    56,  53,  46,  57,  56,  10,  57,  56,  54,  57,  54,  124, 56,  54,  50,
+    48,  55,  56,  52,  46,  56,  50,  10,  57,  52,  51,  57,  57,  124, 56,
+    54,  50,  48,  53,  50,  52,  46,  48,  48,  10,  49,  53,  49,  50,  57,
+    53,  124, 56,  54,  49,  54,  54,  55,  49,  46,  48,  50,  10,  53,  54,
+    52,  49,  55,  124, 56,  54,  49,  51,  52,  53,  48,  46,  51,  53,  10,
+    49,  50,  49,  51,  50,  50,  124, 56,  54,  49,  50,  57,  52,  56,  46,
+    50,  51,  10,  49,  50,  54,  56,  56,  51,  124, 56,  54,  49,  49,  51,
+    55,  51,  46,  52,  50,  10,  50,  57,  49,  53,  53,  124, 56,  54,  49,
+    48,  49,  54,  51,  46,  54,  52,  10,  49,  49,  52,  53,  51,  48,  124,
+    56,  54,  48,  56,  52,  55,  49,  46,  55,  52,  10,  49,  51,  49,  48,
+    48,  55,  124, 56,  54,  48,  55,  51,  57,  52,  46,  56,  50,  10,  49,
+    50,  56,  55,  49,  53,  124, 56,  54,  48,  54,  56,  51,  51,  46,  54,
+    50,  10,  55,  50,  53,  50,  50,  124, 56,  54,  48,  49,  52,  55,  57,
+    46,  57,  56,  10,  49,  52,  52,  48,  54,  49,  124, 56,  53,  57,  53,
+    55,  49,  56,  46,  55,  52,  10,  56,  51,  53,  48,  51,  124, 56,  53,
+    57,  53,  48,  51,  52,  46,  50,  48,  10,  49,  49,  50,  49,  57,  57,
+    124, 56,  53,  57,  48,  55,  49,  55,  46,  52,  52,  10,  57,  50,  50,
+    55,  124, 56,  53,  56,  55,  51,  53,  48,  46,  52,  50,  10,  49,  49,
+    54,  51,  49,  56,  124, 56,  53,  56,  53,  57,  49,  48,  46,  54,  54,
+    10,  52,  49,  50,  52,  56,  124, 56,  53,  56,  53,  53,  53,  57,  46,
+    54,  52,  10,  49,  53,  57,  51,  57,  56,  124, 56,  53,  56,  52,  56,
+    50,  49,  46,  48,  48,  10,  49,  48,  53,  57,  54,  54,  124, 56,  53,
+    56,  50,  51,  48,  56,  46,  55,  57,  10,  49,  51,  55,  56,  55,  54,
+    124, 56,  53,  56,  48,  54,  52,  49,  46,  51,  48,  10,  49,  50,  50,
+    50,  55,  50,  124, 56,  53,  56,  48,  52,  48,  48,  46,  55,  55,  10,
+    49,  57,  53,  55,  49,  55,  124, 56,  53,  55,  55,  50,  55,  56,  46,
+    49,  48,  10,  49,  54,  53,  50,  57,  53,  124, 56,  53,  55,  49,  49,
+    50,  49,  46,  57,  50,  10,  53,  56,  52,  48,  124, 56,  53,  55,  48,
+    55,  50,  56,  46,  55,  52,  10,  49,  50,  48,  56,  54,  48,  124, 56,
+    53,  55,  48,  54,  49,  48,  46,  52,  52,  10,  54,  54,  54,  57,  50,
+    124, 56,  53,  54,  55,  53,  52,  48,  46,  53,  50,  10,  49,  51,  53,
+    53,  57,  54,  124, 56,  53,  54,  51,  50,  55,  54,  46,  51,  49,  10,
+    49,  53,  48,  53,  55,  54,  124, 56,  53,  54,  50,  55,  57,  52,  46,
+    49,  48,  10,  55,  53,  48,  48,  124, 56,  53,  54,  50,  51,  57,  51,
+    46,  56,  52,  10,  49,  48,  55,  55,  49,  54,  124, 56,  53,  54,  49,
+    53,  52,  49,  46,  53,  54,  10,  49,  48,  48,  54,  49,  49,  124, 56,
+    53,  53,  57,  57,  57,  53,  46,  56,  53,  10,  49,  55,  49,  49,  57,
+    50,  124, 56,  53,  53,  55,  51,  57,  48,  46,  48,  56,  10,  49,  48,
+    55,  54,  54,  48,  124, 56,  53,  53,  54,  54,  57,  54,  46,  54,  48,
+    10,  49,  51,  52,  54,  49,  124, 56,  53,  53,  54,  53,  52,  53,  46,
+    49,  50,  10,  57,  48,  51,  49,  48,  124, 56,  53,  53,  53,  49,  51,
+    49,  46,  53,  49,  10,  49,  52,  49,  52,  57,  51,  124, 56,  53,  53,
+    51,  55,  56,  50,  46,  57,  51,  10,  55,  49,  50,  56,  54,  124, 56,
+    53,  53,  50,  54,  56,  50,  46,  48,  48,  10,  49,  51,  54,  52,  50,
+    51,  124, 56,  53,  53,  49,  51,  48,  48,  46,  55,  54,  10,  53,  52,
+    50,  52,  49,  124, 56,  53,  53,  48,  55,  56,  53,  46,  50,  53,  10,
+    49,  50,  48,  51,  50,  53,  124, 56,  53,  52,  57,  57,  55,  54,  46,
+    54,  48,  10,  52,  50,  52,  124, 56,  53,  52,  55,  53,  50,  55,  46,
+    49,  48,  10,  49,  57,  54,  53,  52,  51,  124, 56,  53,  52,  53,  57,
+    48,  55,  46,  48,  57,  10,  49,  51,  48,  52,  50,  124, 56,  53,  52,
+    50,  55,  49,  55,  46,  49,  56,  10,  53,  56,  51,  51,  50,  124, 56,
+    53,  51,  54,  48,  55,  52,  46,  54,  57,  10,  57,  49,  57,  49,  124,
+    56,  53,  51,  53,  54,  54,  51,  46,  57,  50,  10,  49,  51,  52,  51,
+    53,  55,  124, 56,  53,  51,  53,  52,  50,  57,  46,  57,  48,  10,  57,
+    54,  50,  48,  55,  124, 56,  53,  51,  52,  57,  48,  48,  46,  54,  48,
+    10,  57,  50,  50,  57,  50,  124, 56,  53,  51,  48,  54,  49,  56,  46,
+    55,  56,  10,  49,  56,  49,  48,  57,  51,  124, 56,  53,  50,  56,  51,
+    48,  51,  46,  53,  50,  10,  49,  48,  53,  48,  54,  52,  124, 56,  53,
+    50,  55,  52,  57,  49,  46,  54,  48,  10,  53,  57,  54,  51,  53,  124,
+    56,  53,  50,  54,  56,  53,  52,  46,  48,  56,  10,  49,  51,  54,  57,
+    55,  52,  124, 56,  53,  50,  52,  51,  53,  49,  46,  53,  54,  10,  49,
+    50,  54,  54,  57,  52,  124, 56,  53,  50,  50,  55,  56,  51,  46,  51,
+    55,  10,  54,  50,  52,  55,  124, 56,  53,  50,  50,  54,  48,  54,  46,
+    57,  48,  10,  49,  51,  57,  52,  52,  55,  124, 56,  53,  50,  50,  53,
+    50,  49,  46,  57,  50,  10,  57,  54,  51,  49,  51,  124, 56,  53,  50,
+    48,  57,  52,  57,  46,  57,  50,  10,  49,  48,  56,  52,  53,  52,  124,
+    56,  53,  50,  48,  57,  49,  54,  46,  50,  53,  10,  49,  56,  49,  50,
+    53,  52,  124, 56,  53,  49,  57,  52,  57,  54,  46,  49,  48,  10,  55,
+    49,  49,  49,  55,  124, 56,  53,  49,  57,  50,  50,  51,  46,  48,  48,
+    10,  49,  51,  49,  55,  48,  51,  124, 56,  53,  49,  55,  50,  49,  53,
+    46,  50,  56,  10,  53,  57,  51,  49,  50,  124, 56,  53,  49,  48,  53,
+    54,  56,  46,  51,  54,  10,  50,  57,  48,  51,  124, 56,  53,  48,  57,
+    57,  54,  48,  46,  51,  53,  10,  49,  48,  50,  56,  51,  56,  124, 56,
+    53,  48,  57,  53,  50,  55,  46,  54,  57,  10,  49,  54,  50,  56,  48,
+    54,  124, 56,  53,  48,  56,  57,  48,  54,  46,  48,  53,  10,  52,  49,
+    53,  50,  55,  124, 56,  53,  48,  56,  50,  50,  50,  46,  51,  54,  10,
+    49,  49,  56,  52,  49,  54,  124, 56,  53,  48,  53,  56,  53,  56,  46,
+    51,  54,  10,  49,  56,  48,  50,  48,  51,  124, 56,  53,  48,  53,  48,
+    50,  52,  46,  49,  54,  10,  49,  52,  55,  55,  51,  124, 56,  53,  48,
+    48,  53,  57,  56,  46,  50,  56,  10,  49,  52,  48,  52,  52,  54,  124,
+    56,  52,  57,  57,  53,  49,  52,  46,  50,  52,  10,  49,  57,  57,  54,
+    52,  49,  124, 56,  52,  57,  55,  51,  54,  50,  46,  53,  57,  10,  49,
+    48,  57,  50,  52,  48,  124, 56,  52,  57,  52,  54,  49,  55,  46,  49,
+    50,  10,  49,  53,  48,  50,  54,  56,  124, 56,  52,  57,  52,  49,  56,
+    56,  46,  51,  56,  10,  52,  53,  51,  49,  48,  124, 56,  52,  57,  50,
+    51,  56,  48,  46,  54,  53,  10,  51,  54,  53,  53,  50,  124, 56,  52,
+    57,  48,  55,  51,  51,  46,  54,  48,  10,  49,  57,  57,  54,  57,  48,
+    124, 56,  52,  57,  48,  49,  52,  53,  46,  56,  48,  10,  49,  56,  53,
+    51,  53,  51,  124, 56,  52,  56,  56,  55,  50,  54,  46,  54,  56,  10,
+    49,  54,  51,  54,  49,  53,  124, 56,  52,  56,  52,  57,  56,  53,  46,
+    48,  49,  10,  49,  57,  54,  53,  50,  48,  124, 56,  52,  56,  51,  53,
+    52,  53,  46,  48,  52,  10,  49,  51,  51,  52,  51,  56,  124, 56,  52,
+    56,  51,  52,  56,  50,  46,  51,  53,  10,  55,  55,  50,  56,  53,  124,
+    56,  52,  56,  49,  52,  52,  50,  46,  51,  50,  10,  53,  53,  56,  50,
+    52,  124, 56,  52,  55,  54,  56,  57,  51,  46,  57,  48,  10,  55,  54,
+    55,  53,  51,  124, 56,  52,  55,  53,  53,  50,  50,  46,  49,  50,  10,
+    52,  54,  49,  50,  57,  124, 56,  52,  55,  50,  55,  49,  55,  46,  57,
+    54,  10,  50,  56,  51,  53,  56,  124, 56,  52,  55,  50,  53,  49,  53,
+    46,  53,  48,  10,  57,  51,  49,  55,  124, 56,  52,  55,  50,  49,  52,
+    53,  46,  51,  50,  10,  51,  51,  56,  50,  51,  124, 56,  52,  54,  57,
+    55,  50,  49,  46,  52,  52,  10,  51,  57,  48,  53,  53,  124, 56,  52,
+    54,  57,  49,  52,  53,  46,  48,  55,  10,  57,  49,  52,  55,  49,  124,
+    56,  52,  54,  56,  56,  55,  52,  46,  53,  54,  10,  49,  52,  50,  50,
+    57,  57,  124, 56,  52,  54,  54,  48,  51,  57,  46,  53,  53,  10,  57,
+    55,  54,  55,  50,  124, 56,  52,  54,  52,  49,  49,  57,  46,  56,  48,
+    10,  49,  51,  52,  55,  49,  50,  124, 56,  52,  54,  49,  55,  56,  49,
+    46,  55,  57,  10,  49,  53,  55,  57,  56,  56,  124, 56,  52,  54,  48,
+    49,  50,  51,  46,  50,  48,  10,  49,  48,  50,  50,  56,  52,  124, 56,
+    52,  53,  56,  54,  53,  50,  46,  52,  52,  10,  55,  51,  53,  51,  51,
+    124, 56,  52,  53,  56,  52,  53,  51,  46,  51,  50,  10,  57,  48,  53,
+    57,  57,  124, 56,  52,  53,  55,  56,  55,  52,  46,  56,  54,  10,  49,
+    49,  50,  49,  54,  48,  124, 56,  52,  53,  55,  56,  54,  51,  46,  51,
+    54,  10,  49,  50,  52,  55,  57,  50,  124, 56,  52,  53,  55,  54,  51,
+    51,  46,  55,  48,  10,  54,  54,  48,  57,  55,  124, 56,  52,  53,  55,
+    53,  55,  51,  46,  49,  53,  10,  49,  54,  53,  50,  55,  49,  124, 56,
+    52,  53,  54,  57,  54,  57,  46,  48,  49,  10,  49,  52,  54,  57,  50,
+    53,  124, 56,  52,  53,  52,  56,  56,  55,  46,  57,  49,  10,  49,  54,
+    52,  50,  55,  55,  124, 56,  52,  53,  52,  56,  51,  56,  46,  53,  48,
+    10,  49,  51,  49,  50,  57,  48,  124, 56,  52,  53,  52,  56,  49,  49,
+    46,  50,  48,  10,  49,  55,  57,  51,  56,  54,  124, 56,  52,  53,  48,
+    57,  48,  57,  46,  57,  48,  10,  57,  48,  52,  56,  54,  124, 56,  52,
+    52,  55,  56,  55,  51,  46,  56,  54,  10,  49,  55,  53,  57,  50,  52,
+    124, 56,  52,  52,  52,  52,  50,  49,  46,  54,  54,  10,  49,  56,  53,
+    57,  50,  50,  124, 56,  52,  52,  50,  51,  57,  52,  46,  56,  56,  10,
+    51,  56,  52,  57,  50,  124, 56,  52,  51,  54,  52,  51,  56,  46,  51,
+    50,  10,  49,  55,  50,  53,  49,  49,  124, 56,  52,  51,  54,  50,  56,
+    55,  46,  51,  52,  10,  49,  51,  57,  53,  51,  57,  124, 56,  52,  51,
+    52,  49,  56,  48,  46,  50,  57,  10,  49,  49,  57,  50,  54,  124, 56,
+    52,  51,  51,  49,  57,  57,  46,  53,  50,  10,  53,  53,  56,  56,  57,
+    124, 56,  52,  51,  49,  52,  52,  57,  46,  56,  56,  10,  49,  54,  51,
+    48,  54,  56,  124, 56,  52,  51,  49,  49,  49,  54,  46,  52,  48,  10,
+    49,  51,  56,  55,  55,  50,  124, 56,  52,  50,  56,  52,  48,  54,  46,
+    51,  54,  10,  49,  50,  54,  56,  50,  49,  124, 56,  52,  50,  53,  49,
+    56,  48,  46,  54,  56,  10,  50,  50,  48,  57,  49,  124, 56,  52,  50,
+    48,  54,  56,  55,  46,  56,  56,  10,  53,  53,  57,  56,  49,  124, 56,
+    52,  49,  57,  52,  51,  52,  46,  51,  56,  10,  49,  48,  48,  57,  54,
+    48,  124, 56,  52,  49,  57,  52,  48,  51,  46,  52,  54,  10,  49,  55,
+    50,  53,  54,  56,  124, 56,  52,  49,  55,  57,  53,  53,  46,  50,  49,
+    10,  54,  51,  49,  51,  53,  124, 56,  52,  49,  53,  57,  52,  53,  46,
+    53,  51,  10,  49,  51,  55,  54,  53,  49,  124, 56,  52,  49,  51,  49,
+    55,  48,  46,  51,  53,  10,  49,  57,  49,  51,  53,  51,  124, 56,  52,
+    49,  51,  48,  51,  57,  46,  56,  52,  10,  54,  50,  57,  56,  56,  124,
+    56,  52,  49,  49,  53,  55,  49,  46,  52,  56,  10,  49,  48,  51,  52,
+    49,  55,  124, 56,  52,  49,  49,  53,  52,  49,  46,  49,  50,  10,  49,
+    50,  48,  53,  50,  124, 56,  52,  49,  49,  53,  49,  57,  46,  50,  56,
+    10,  49,  48,  52,  50,  54,  48,  124, 56,  52,  48,  56,  53,  49,  54,
+    46,  53,  53,  10,  49,  53,  55,  49,  50,  57,  124, 56,  52,  48,  53,
+    55,  51,  48,  46,  48,  56,  10,  55,  55,  50,  53,  52,  124, 56,  52,
+    48,  53,  53,  51,  55,  46,  50,  50,  10,  49,  49,  50,  57,  54,  54,
+    124, 56,  52,  48,  51,  53,  49,  50,  46,  56,  57,  10,  49,  54,  56,
+    49,  49,  52,  124, 56,  52,  48,  50,  55,  54,  52,  46,  53,  54,  10,
+    52,  57,  57,  52,  48,  124, 56,  52,  48,  50,  51,  50,  56,  46,  50,
+    48,  10,  53,  50,  48,  49,  55,  124, 56,  51,  57,  56,  55,  53,  51,
+    46,  54,  48,  10,  49,  55,  54,  49,  55,  57,  124, 56,  51,  57,  56,
+    48,  56,  55,  46,  48,  48,  10,  49,  48,  48,  50,  49,  53,  124, 56,
+    51,  57,  53,  57,  48,  54,  46,  54,  49,  10,  54,  49,  50,  53,  54,
+    124, 56,  51,  57,  50,  56,  49,  49,  46,  50,  48,  10,  49,  53,  51,
+    54,  54,  124, 56,  51,  56,  56,  57,  48,  55,  46,  56,  48,  10,  49,
+    48,  57,  52,  55,  57,  124, 56,  51,  56,  56,  48,  50,  55,  46,  50,
+    48,  10,  54,  54,  50,  48,  50,  124, 56,  51,  56,  54,  53,  50,  50,
+    46,  56,  51,  10,  56,  49,  55,  48,  55,  124, 56,  51,  56,  53,  55,
+    54,  49,  46,  49,  57,  10,  53,  49,  55,  50,  55,  124, 56,  51,  56,
+    53,  52,  50,  54,  46,  52,  48,  10,  57,  57,  56,  48,  124, 56,  51,
+    56,  50,  55,  53,  52,  46,  54,  50,  10,  49,  55,  52,  52,  48,  51,
+    124, 56,  51,  55,  56,  53,  55,  53,  46,  55,  51,  10,  53,  52,  53,
+    53,  56,  124, 56,  51,  55,  56,  48,  52,  49,  46,  57,  50,  10,  51,
+    49,  52,  49,  124, 56,  51,  55,  55,  51,  55,  56,  46,  50,  50,  10,
+    49,  51,  52,  56,  50,  57,  124, 56,  51,  55,  55,  49,  48,  53,  46,
+    53,  50,  10,  49,  52,  53,  48,  53,  54,  124, 56,  51,  55,  54,  57,
+    50,  48,  46,  55,  54,  10,  49,  57,  52,  48,  50,  48,  124, 56,  51,
+    55,  53,  49,  53,  55,  46,  54,  52,  10,  55,  49,  49,  55,  124, 56,
+    51,  55,  51,  57,  56,  50,  46,  50,  55,  10,  49,  50,  48,  49,  52,
+    54,  124, 56,  51,  55,  51,  55,  57,  54,  46,  50,  48,  10,  49,  50,
+    54,  56,  52,  51,  124, 56,  51,  55,  48,  55,  54,  49,  46,  50,  56,
+    10,  54,  50,  49,  49,  55,  124, 56,  51,  54,  57,  52,  57,  51,  46,
+    52,  52,  10,  49,  49,  49,  50,  50,  49,  124, 56,  51,  54,  55,  53,
+    50,  53,  46,  56,  49,  10,  49,  53,  57,  51,  51,  55,  124, 56,  51,
+    54,  54,  48,  57,  50,  46,  50,  54,  10,  49,  55,  51,  57,  48,  51,
+    124, 56,  51,  54,  53,  52,  50,  56,  46,  52,  56,  10,  49,  51,  54,
+    52,  51,  56,  124, 56,  51,  54,  52,  48,  54,  53,  46,  52,  53,  10,
+    53,  54,  54,  56,  52,  124, 56,  51,  54,  51,  49,  57,  56,  46,  48,
+    48,  10,  49,  51,  55,  53,  57,  55,  124, 56,  51,  54,  51,  49,  56,
+    53,  46,  57,  52,  10,  50,  48,  48,  51,  57,  124, 56,  51,  54,  49,
+    49,  51,  56,  46,  50,  52,  10,  49,  50,  49,  51,  50,  54,  124, 56,
+    51,  53,  57,  54,  51,  53,  46,  53,  50,  10,  52,  56,  52,  51,  53,
+    124, 56,  51,  53,  50,  56,  54,  51,  46,  49,  48,  10,  49,  55,  49,
+    50,  124, 56,  51,  52,  57,  49,  48,  55,  46,  48,  48,  10,  49,  54,
+    55,  49,  57,  48,  124, 56,  51,  52,  55,  50,  51,  56,  46,  55,  48,
+    10,  51,  50,  49,  49,  51,  124, 56,  51,  52,  54,  52,  53,  50,  46,
+    48,  52,  10,  52,  48,  53,  56,  48,  124, 56,  51,  52,  50,  57,  56,
+    51,  46,  51,  50,  10,  55,  52,  55,  56,  53,  124, 56,  51,  52,  50,
+    53,  49,  57,  46,  49,  51,  10,  49,  52,  55,  57,  57,  124, 56,  51,
+    52,  50,  50,  51,  54,  46,  55,  53,  10,  49,  55,  55,  50,  57,  49,
+    124, 56,  51,  52,  49,  55,  51,  54,  46,  56,  51,  10,  49,  57,  56,
+    57,  53,  54,  124, 56,  51,  52,  48,  51,  55,  48,  46,  54,  53,  10,
+    54,  57,  49,  55,  57,  124, 56,  51,  51,  56,  52,  54,  53,  46,  57,
+    57,  10,  49,  49,  56,  55,  54,  52,  124, 56,  51,  51,  55,  54,  49,
+    54,  46,  53,  54,  10,  49,  50,  56,  56,  49,  52,  124, 56,  51,  51,
+    54,  52,  51,  53,  46,  53,  54,  10,  56,  50,  55,  50,  57,  124, 56,
+    51,  51,  49,  55,  54,  54,  46,  56,  56,  10,  49,  53,  50,  48,  52,
+    56,  124, 56,  51,  51,  48,  54,  51,  56,  46,  57,  57,  10,  49,  55,
+    49,  48,  56,  53,  124, 56,  51,  50,  54,  50,  53,  57,  46,  53,  48,
+    10,  49,  50,  54,  55,  51,  48,  124, 56,  51,  50,  53,  57,  55,  52,
+    46,  52,  48,  10,  55,  55,  53,  50,  53,  124, 56,  51,  50,  51,  50,
+    56,  50,  46,  53,  48,  10,  49,  55,  48,  54,  53,  51,  124, 56,  51,
+    50,  50,  56,  52,  48,  46,  53,  48,  10,  53,  50,  53,  55,  124, 56,
+    51,  50,  48,  51,  53,  48,  46,  55,  56,  10,  54,  55,  51,  53,  48,
+    124, 56,  51,  49,  56,  57,  56,  55,  46,  53,  54,  10,  49,  48,  57,
+    48,  48,  56,  124, 56,  51,  49,  55,  56,  51,  54,  46,  53,  52,  10,
+    49,  57,  57,  48,  52,  51,  124, 56,  51,  49,  54,  54,  48,  51,  46,
+    53,  52,  10,  49,  51,  57,  57,  54,  57,  124, 56,  51,  49,  54,  53,
+    53,  49,  46,  53,  52,  10,  50,  50,  54,  51,  52,  124, 56,  51,  49,
+    54,  53,  51,  49,  46,  50,  52,  10,  49,  55,  51,  51,  48,  57,  124,
+    56,  51,  49,  53,  55,  53,  48,  46,  50,  53,  10,  49,  48,  56,  56,
+    55,  124, 56,  51,  49,  53,  48,  49,  57,  46,  51,  54,  10,  52,  50,
+    51,  57,  50,  124, 56,  51,  49,  50,  56,  57,  53,  46,  57,  54,  10,
+    49,  50,  54,  48,  52,  48,  124, 56,  51,  49,  50,  54,  50,  51,  46,
+    50,  48,  10,  49,  48,  49,  53,  57,  48,  124, 56,  51,  48,  52,  53,
+    53,  53,  46,  52,  50,  10,  52,  54,  56,  57,  49,  124, 56,  51,  48,
+    50,  49,  57,  50,  46,  49,  50,  10,  49,  51,  56,  55,  50,  49,  124,
+    56,  51,  48,  49,  55,  52,  53,  46,  54,  50,  10,  49,  49,  51,  55,
+    49,  53,  124, 56,  51,  48,  49,  53,  51,  51,  46,  50,  48,  10,  55,
+    56,  55,  55,  56,  124, 56,  50,  57,  57,  54,  56,  53,  46,  54,  52,
+    10,  49,  52,  50,  57,  48,  56,  124, 56,  50,  57,  57,  52,  52,  55,
+    46,  55,  55,  10,  54,  52,  52,  49,  57,  124, 56,  50,  57,  55,  54,
+    51,  49,  46,  56,  48,  10,  50,  49,  51,  57,  54,  124, 56,  50,  57,
+    54,  50,  55,  50,  46,  50,  55,  10,  52,  49,  56,  48,  124, 56,  50,
+    57,  53,  54,  52,  54,  46,  57,  50,  10,  54,  51,  53,  51,  52,  124,
+    56,  50,  57,  53,  51,  56,  51,  46,  54,  55,  10,  49,  51,  53,  57,
+    53,  55,  124, 56,  50,  57,  52,  51,  56,  57,  46,  56,  54,  10,  51,
+    48,  49,  50,  54,  124, 56,  50,  57,  49,  57,  50,  48,  46,  51,  50,
+    10,  49,  53,  56,  52,  50,  55,  124, 56,  50,  56,  56,  57,  51,  56,
+    46,  48,  48,  10,  49,  52,  53,  52,  53,  124, 56,  50,  56,  56,  51,
+    57,  53,  46,  57,  50,  10,  55,  53,  53,  52,  56,  124, 56,  50,  56,
+    56,  50,  56,  55,  46,  50,  48,  10,  54,  52,  52,  55,  51,  124, 56,
+    50,  56,  54,  49,  51,  55,  46,  52,  52,  10,  49,  52,  57,  53,  53,
+    51,  124, 56,  50,  56,  53,  55,  49,  52,  46,  56,  56,  10,  49,  53,
+    49,  50,  56,  52,  124, 56,  50,  56,  51,  53,  50,  54,  46,  54,  53,
+    10,  49,  55,  49,  48,  57,  49,  124, 56,  50,  56,  50,  57,  51,  52,
+    46,  51,  54,  10,  49,  57,  52,  50,  53,  54,  124, 56,  50,  55,  56,
+    57,  56,  53,  46,  51,  52,  10,  57,  53,  50,  124, 56,  50,  55,  54,
+    49,  51,  54,  46,  48,  48,  10,  49,  50,  49,  53,  52,  49,  124, 56,
+    50,  55,  53,  51,  57,  48,  46,  50,  54,  10,  49,  55,  55,  54,  54,
+    52,  124, 56,  50,  55,  53,  51,  49,  53,  46,  50,  48,  10,  53,  49,
+    49,  49,  55,  124, 56,  50,  55,  52,  53,  48,  52,  46,  51,  48,  10,
+    54,  54,  55,  55,  48,  124, 56,  50,  55,  51,  52,  48,  55,  46,  56,
+    48,  10,  51,  55,  50,  51,  56,  124, 56,  50,  55,  50,  55,  50,  56,
+    46,  48,  54,  10,  52,  54,  54,  55,  57,  124, 56,  50,  55,  48,  52,
+    56,  54,  46,  53,  53,  10,  49,  54,  53,  56,  53,  50,  124, 56,  50,
+    54,  56,  51,  49,  50,  46,  54,  48,  10,  57,  57,  52,  53,  56,  124,
+    56,  50,  54,  54,  53,  54,  52,  46,  52,  55,  10,  49,  49,  52,  53,
+    49,  57,  124, 56,  50,  54,  53,  52,  57,  51,  46,  53,  52,  10,  55,
+    50,  51,  49,  124, 56,  50,  54,  52,  56,  56,  49,  46,  53,  48,  10,
+    49,  57,  48,  51,  51,  124, 56,  50,  54,  52,  56,  50,  54,  46,  53,
+    54,  10,  49,  50,  53,  49,  50,  51,  124, 56,  50,  54,  50,  55,  51,
+    50,  46,  54,  53,  10,  49,  56,  54,  52,  50,  124, 56,  50,  54,  49,
+    53,  55,  56,  46,  57,  57,  10,  53,  48,  51,  56,  54,  124, 56,  50,
+    54,  49,  51,  56,  48,  46,  48,  53,  10,  49,  57,  51,  55,  55,  48,
+    124, 56,  50,  53,  57,  53,  55,  56,  46,  56,  50,  10,  55,  50,  55,
+    54,  124, 56,  50,  53,  56,  49,  48,  49,  46,  54,  48,  10,  49,  55,
+    56,  48,  52,  53,  124, 56,  50,  53,  51,  57,  48,  52,  46,  49,  53,
+    10,  52,  57,  48,  51,  51,  124, 56,  50,  53,  51,  54,  57,  54,  46,
+    50,  51,  10,  49,  56,  55,  49,  57,  53,  124, 56,  50,  53,  49,  51,
+    51,  52,  46,  53,  56,  10,  49,  48,  53,  57,  48,  124, 56,  50,  52,
+    57,  50,  50,  55,  46,  52,  48,  10,  49,  52,  51,  55,  55,  57,  124,
+    56,  50,  52,  55,  48,  53,  55,  46,  55,  48,  10,  51,  53,  50,  48,
+    53,  124, 56,  50,  52,  53,  54,  55,  53,  46,  49,  55,  10,  49,  57,
+    55,  50,  57,  124, 56,  50,  52,  53,  48,  56,  49,  46,  54,  48,  10,
+    49,  52,  52,  57,  52,  54,  124, 56,  50,  52,  48,  52,  55,  57,  46,
+    56,  48,  10,  49,  50,  51,  55,  56,  54,  124, 56,  50,  51,  57,  53,
+    56,  49,  46,  50,  52,  10,  55,  48,  56,  52,  51,  124, 56,  50,  51,
+    55,  57,  55,  51,  46,  50,  48,  10,  49,  49,  50,  52,  51,  55,  124,
+    56,  50,  51,  54,  57,  48,  55,  46,  53,  50,  10,  53,  52,  51,  54,
+    124, 56,  50,  51,  54,  48,  51,  57,  46,  53,  55,  10,  49,  54,  51,
+    55,  53,  52,  124, 56,  50,  51,  53,  52,  55,  49,  46,  49,  54,  10,
+    49,  49,  53,  57,  52,  53,  124, 56,  50,  51,  52,  56,  49,  49,  46,
+    51,  54,  10,  50,  55,  57,  49,  56,  124, 56,  50,  51,  51,  57,  53,
+    55,  46,  56,  56,  10,  49,  48,  53,  55,  49,  50,  124, 56,  50,  51,
+    51,  53,  55,  49,  46,  56,  54,  10,  52,  49,  48,  48,  55,  124, 56,
+    50,  50,  57,  52,  51,  49,  46,  55,  57,  10,  52,  48,  52,  55,  54,
+    124, 56,  50,  50,  54,  54,  52,  48,  46,  52,  49,  10,  49,  52,  53,
+    54,  50,  48,  124, 56,  50,  50,  49,  51,  55,  49,  46,  54,  48,  10,
+    55,  55,  55,  49,  124, 56,  50,  50,  48,  52,  49,  51,  46,  51,  51,
+    10,  56,  54,  52,  50,  52,  124, 56,  50,  49,  53,  53,  55,  50,  46,
+    54,  49,  10,  49,  50,  57,  49,  51,  55,  124, 56,  50,  49,  53,  52,
+    55,  56,  46,  52,  48,  10,  55,  54,  48,  50,  48,  124, 56,  50,  49,
+    48,  52,  57,  53,  46,  51,  54,  10,  49,  52,  48,  50,  49,  51,  124,
+    56,  50,  48,  57,  56,  51,  49,  46,  56,  48,  10,  51,  50,  51,  55,
+    57,  124, 56,  50,  48,  56,  51,  51,  56,  46,  56,  56,  10,  49,  51,
+    48,  54,  49,  54,  124, 56,  50,  48,  55,  55,  49,  53,  46,  55,  53,
+    10,  49,  57,  53,  52,  54,  57,  124, 56,  50,  48,  54,  54,  48,  57,
+    46,  56,  48,  10,  49,  57,  49,  56,  48,  53,  124, 56,  50,  48,  53,
+    49,  52,  55,  46,  55,  53,  10,  57,  48,  57,  48,  54,  124, 56,  50,
+    48,  48,  57,  53,  49,  46,  50,  48,  10,  49,  55,  48,  57,  49,  48,
+    124, 56,  49,  57,  53,  53,  53,  56,  46,  48,  49,  10,  49,  48,  53,
+    51,  57,  57,  124, 56,  49,  57,  51,  49,  50,  50,  46,  54,  51,  10,
+    49,  50,  51,  55,  57,  56,  124, 56,  49,  57,  50,  51,  56,  53,  46,
+    57,  55,  10,  57,  48,  50,  49,  56,  124, 56,  49,  57,  49,  54,  56,
+    57,  46,  49,  54,  10,  49,  49,  52,  55,  54,  54,  124, 56,  49,  56,
+    57,  51,  51,  57,  46,  53,  52,  10,  49,  49,  50,  56,  57,  124, 56,
+    49,  56,  55,  51,  53,  52,  46,  55,  50,  10,  49,  55,  56,  51,  48,
+    56,  124, 56,  49,  56,  53,  55,  53,  48,  46,  53,  48,  10,  55,  49,
+    50,  55,  49,  124, 56,  49,  56,  53,  53,  49,  57,  46,  50,  52,  10,
+    49,  49,  49,  53,  124, 56,  49,  56,  52,  57,  48,  51,  46,  51,  56,
+    10,  49,  53,  50,  54,  51,  54,  124, 56,  49,  56,  52,  53,  51,  48,
+    46,  55,  50,  10,  49,  53,  49,  54,  49,  57,  124, 56,  49,  56,  50,
+    57,  48,  57,  46,  48,  53,  10,  49,  49,  54,  57,  52,  51,  124, 56,
+    49,  56,  49,  48,  55,  50,  46,  54,  57,  10,  50,  56,  56,  57,  49,
+    124, 56,  49,  56,  49,  48,  53,  49,  46,  53,  52,  10,  52,  55,  48,
+    52,  57,  124, 56,  49,  56,  48,  57,  53,  53,  46,  48,  48,  10,  49,
+    53,  56,  56,  50,  55,  124, 56,  49,  56,  48,  52,  55,  48,  46,  57,
+    48,  10,  57,  50,  54,  50,  48,  124, 56,  49,  55,  57,  54,  55,  49,
+    46,  53,  53,  10,  50,  48,  56,  49,  52,  124, 56,  49,  55,  54,  57,
+    53,  51,  46,  53,  52,  10,  49,  55,  57,  51,  50,  51,  124, 56,  49,
+    55,  54,  55,  57,  53,  46,  53,  53,  10,  49,  57,  51,  52,  53,  51,
+    124, 56,  49,  55,  52,  51,  52,  51,  46,  57,  52,  10,  53,  54,  56,
+    56,  56,  124, 56,  49,  55,  51,  51,  52,  50,  46,  48,  48,  10,  50,
+    56,  48,  56,  55,  124, 56,  49,  54,  57,  56,  55,  54,  46,  51,  48,
+    10,  49,  54,  52,  50,  53,  52,  124, 56,  49,  54,  57,  54,  51,  50,
+    46,  51,  53,  10,  53,  55,  54,  54,  49,  124, 56,  49,  54,  56,  56,
+    52,  56,  46,  49,  54,  10,  55,  51,  54,  51,  124, 56,  49,  54,  55,
+    53,  51,  56,  46,  48,  53,  10,  49,  54,  52,  52,  57,  57,  124, 56,
+    49,  54,  55,  53,  49,  50,  46,  48,  56,  10,  49,  57,  55,  53,  53,
+    55,  124, 56,  49,  54,  53,  57,  52,  48,  46,  52,  53,  10,  53,  52,
+    57,  53,  124, 56,  49,  54,  52,  56,  48,  53,  46,  50,  50,  10,  57,
+    54,  54,  124, 56,  49,  54,  51,  56,  50,  52,  46,  55,  57,  10,  57,
+    56,  52,  51,  53,  124, 56,  49,  54,  49,  55,  55,  49,  46,  52,  53,
+    10,  49,  50,  55,  50,  50,  55,  124, 56,  49,  54,  49,  51,  52,  52,
+    46,  57,  50,  10,  49,  57,  52,  49,  48,  48,  124, 56,  49,  54,  48,
+    57,  55,  56,  46,  55,  56,  10,  52,  48,  49,  51,  52,  124, 56,  49,
+    54,  48,  51,  53,  56,  46,  48,  56,  10,  49,  48,  55,  51,  52,  49,
+    124, 56,  49,  53,  57,  57,  53,  50,  46,  48,  53,  10,  54,  55,  57,
+    48,  124, 56,  49,  53,  56,  55,  57,  50,  46,  54,  54,  10,  52,  51,
+    56,  53,  49,  124, 56,  49,  53,  55,  49,  48,  49,  46,  52,  48,  10,
+    53,  49,  50,  57,  53,  124, 56,  49,  53,  54,  52,  49,  57,  46,  50,
+    48,  10,  54,  57,  53,  49,  50,  124, 56,  49,  53,  49,  53,  51,  55,
+    46,  48,  48,  10,  49,  54,  52,  50,  55,  52,  124, 56,  49,  52,  57,
+    56,  54,  57,  46,  57,  51,  10,  49,  51,  48,  56,  53,  52,  124, 56,
+    49,  52,  53,  51,  51,  56,  46,  56,  53,  10,  49,  56,  54,  56,  54,
+    53,  124, 56,  49,  52,  51,  53,  56,  54,  46,  56,  50,  10,  49,  55,
+    54,  54,  50,  57,  124, 56,  49,  52,  49,  52,  49,  49,  46,  50,  48,
+    10,  49,  57,  51,  55,  51,  57,  124, 56,  49,  52,  49,  51,  55,  55,
+    46,  55,  55,  10,  54,  56,  49,  48,  124, 56,  49,  51,  57,  56,  50,
+    50,  46,  54,  48,  10,  50,  55,  55,  51,  50,  124, 56,  49,  51,  54,
+    55,  50,  52,  46,  57,  54,  10,  53,  48,  54,  49,  54,  124, 56,  49,
+    51,  52,  48,  56,  57,  46,  56,  50,  10,  49,  50,  51,  57,  48,  56,
+    124, 56,  49,  50,  56,  57,  50,  48,  46,  53,  52,  10,  49,  52,  48,
+    57,  57,  52,  124, 56,  49,  50,  56,  52,  55,  48,  46,  56,  50,  10,
+    57,  57,  48,  51,  57,  124, 56,  49,  50,  56,  50,  57,  48,  46,  55,
+    56,  10,  54,  50,  55,  51,  53,  124, 56,  49,  50,  52,  57,  52,  48,
+    46,  53,  48,  10,  52,  55,  56,  50,  57,  124, 56,  49,  50,  50,  55,
+    57,  54,  46,  53,  48,  10,  49,  57,  50,  54,  51,  53,  124, 56,  49,
+    50,  50,  54,  56,  55,  46,  53,  55,  10,  49,  57,  50,  52,  50,  57,
+    124, 56,  49,  49,  57,  50,  54,  56,  46,  48,  48,  10,  49,  52,  53,
+    56,  49,  50,  124, 56,  49,  49,  57,  49,  54,  53,  46,  54,  51,  10,
+    52,  50,  56,  57,  54,  124, 56,  49,  49,  56,  53,  50,  57,  46,  56,
+    48,  10,  49,  52,  54,  56,  55,  55,  124, 56,  49,  49,  56,  50,  54,
+    54,  46,  49,  54,  10,  54,  48,  56,  56,  50,  124, 56,  49,  49,  54,
+    48,  57,  53,  46,  48,  52,  10,  49,  56,  50,  53,  52,  124, 56,  49,
+    49,  52,  55,  56,  51,  46,  48,  52,  10,  49,  54,  53,  52,  54,  52,
+    124, 56,  49,  49,  52,  53,  55,  49,  46,  56,  48,  10,  53,  55,  57,
+    51,  54,  124, 56,  49,  49,  49,  57,  50,  55,  46,  50,  53,  10,  53,
+    50,  50,  50,  54,  124, 56,  49,  49,  48,  55,  50,  51,  46,  51,  50,
+    10,  49,  50,  56,  53,  55,  49,  124, 56,  49,  48,  54,  55,  56,  56,
+    46,  56,  48,  10,  49,  48,  48,  51,  48,  56,  124, 56,  49,  48,  53,
+    56,  51,  55,  46,  48,  52,  10,  56,  56,  55,  50,  124, 56,  49,  48,
+    50,  51,  57,  53,  46,  54,  50,  10,  53,  56,  56,  54,  55,  124, 56,
+    49,  48,  50,  48,  51,  51,  46,  49,  57,  10,  49,  52,  53,  49,  53,
+    51,  124, 56,  49,  48,  48,  50,  50,  50,  46,  56,  52,  10,  49,  55,
+    50,  48,  56,  56,  124, 56,  48,  57,  56,  49,  51,  56,  46,  50,  48,
+    10,  53,  57,  51,  57,  56,  124, 56,  48,  57,  53,  56,  52,  53,  46,
+    52,  53,  10,  56,  57,  51,  57,  53,  124, 56,  48,  57,  51,  53,  55,
+    54,  46,  49,  48,  10,  49,  55,  49,  57,  54,  49,  124, 56,  48,  57,
+    51,  53,  51,  56,  46,  48,  48,  10,  56,  56,  55,  51,  54,  124, 56,
+    48,  57,  48,  55,  54,  50,  46,  49,  54,  10,  49,  55,  52,  48,  53,
+    51,  124, 56,  48,  57,  48,  51,  53,  48,  46,  49,  49,  10,  49,  48,
+    50,  50,  51,  55,  124, 56,  48,  56,  57,  49,  48,  51,  46,  50,  50,
+    10,  52,  51,  48,  52,  49,  124, 56,  48,  56,  54,  53,  51,  55,  46,
+    57,  48,  10,  49,  49,  48,  50,  49,  57,  124, 56,  48,  56,  53,  50,
+    57,  54,  46,  57,  48,  10,  49,  50,  54,  55,  51,  56,  124, 56,  48,
+    56,  52,  49,  57,  57,  46,  50,  48,  10,  52,  52,  55,  56,  55,  124,
+    56,  48,  56,  51,  54,  50,  56,  46,  52,  48,  10,  51,  49,  50,  55,
+    55,  124, 56,  48,  56,  51,  53,  56,  48,  46,  55,  54,  10,  57,  51,
+    53,  57,  53,  124, 56,  48,  56,  50,  49,  56,  56,  46,  56,  48,  10,
+    49,  56,  57,  48,  52,  48,  124, 56,  48,  56,  48,  50,  53,  55,  46,
+    50,  49,  10,  53,  57,  56,  53,  49,  124, 56,  48,  55,  57,  48,  50,
+    52,  46,  50,  52,  10,  49,  55,  53,  49,  48,  48,  124, 56,  48,  55,
+    55,  57,  48,  52,  46,  48,  49,  10,  52,  51,  52,  50,  57,  124, 56,
+    48,  55,  54,  55,  50,  57,  46,  57,  54,  10,  49,  53,  52,  49,  57,
+    57,  124, 56,  48,  55,  52,  57,  52,  48,  46,  55,  54,  10,  54,  48,
+    57,  54,  51,  124, 56,  48,  55,  51,  56,  57,  52,  46,  52,  48,  10,
+    56,  55,  54,  56,  124, 56,  48,  55,  50,  55,  54,  48,  46,  57,  54,
+    10,  54,  54,  48,  57,  53,  124, 56,  48,  55,  49,  52,  50,  49,  46,
+    55,  48,  10,  49,  49,  49,  53,  53,  50,  124, 56,  48,  54,  56,  49,
+    56,  52,  46,  52,  56,  10,  50,  52,  53,  54,  51,  124, 56,  48,  54,
+    55,  53,  48,  48,  46,  52,  48,  10,  49,  54,  49,  54,  55,  124, 56,
+    48,  54,  55,  52,  57,  53,  46,  50,  52,  10,  49,  50,  54,  54,  50,
+    124, 56,  48,  54,  55,  50,  52,  56,  46,  56,  53,  10,  57,  52,  53,
+    52,  48,  124, 56,  48,  54,  51,  55,  50,  55,  46,  49,  54,  10,  50,
+    51,  51,  48,  56,  124, 56,  48,  54,  51,  52,  54,  51,  46,  49,  56,
+    10,  50,  55,  51,  57,  48,  124, 56,  48,  54,  50,  56,  50,  51,  46,
+    50,  53,  10,  49,  51,  48,  54,  54,  48,  124, 56,  48,  54,  50,  55,
+    56,  55,  46,  52,  56,  10,  56,  54,  48,  56,  124, 56,  48,  54,  50,
+    52,  49,  49,  46,  49,  54,  10,  49,  56,  49,  53,  53,  50,  124, 56,
+    48,  54,  50,  48,  48,  56,  46,  51,  48,  10,  49,  57,  57,  51,  49,
+    57,  124, 56,  48,  54,  48,  50,  52,  56,  46,  53,  54,  10,  53,  53,
+    52,  55,  53,  124, 56,  48,  53,  56,  56,  53,  48,  46,  57,  50,  10,
+    49,  52,  50,  55,  49,  49,  124, 56,  48,  53,  55,  57,  50,  54,  46,
+    53,  56,  10,  49,  48,  51,  52,  57,  57,  124, 56,  48,  53,  54,  57,
+    55,  56,  46,  48,  48,  10,  49,  48,  53,  57,  52,  51,  124, 56,  48,
+    53,  54,  54,  57,  56,  46,  55,  53,  10,  56,  52,  51,  50,  124, 56,
+    48,  53,  51,  48,  53,  50,  46,  49,  54,  10,  49,  52,  57,  51,  57,
+    50,  124, 56,  48,  52,  57,  54,  55,  53,  46,  54,  57,  10,  49,  48,
+    49,  50,  52,  56,  124, 56,  48,  52,  56,  56,  53,  53,  46,  52,  57,
+    10,  49,  52,  48,  57,  54,  50,  124, 56,  48,  52,  55,  50,  54,  48,
+    46,  55,  48,  10,  56,  55,  49,  48,  49,  124, 56,  48,  52,  54,  54,
+    53,  49,  46,  56,  51,  10,  49,  51,  51,  49,  48,  55,  124, 56,  48,
+    52,  54,  52,  55,  54,  46,  55,  51,  10,  52,  53,  49,  50,  54,  124,
+    56,  48,  52,  53,  57,  50,  52,  46,  52,  48,  10,  56,  55,  53,  48,
+    56,  124, 56,  48,  52,  50,  57,  54,  54,  46,  51,  57,  10,  49,  50,
+    52,  55,  49,  49,  124, 56,  48,  52,  50,  55,  50,  50,  46,  55,  50,
+    10,  49,  55,  51,  49,  54,  57,  124, 56,  48,  52,  50,  50,  50,  52,
+    46,  52,  49,  10,  49,  55,  53,  49,  54,  49,  124, 56,  48,  52,  49,
+    51,  51,  49,  46,  57,  56,  10,  49,  54,  55,  55,  56,  55,  124, 56,
+    48,  52,  48,  48,  55,  53,  46,  55,  56,  10,  51,  50,  52,  50,  124,
+    56,  48,  51,  56,  56,  53,  53,  46,  53,  51,  10,  49,  49,  52,  55,
+    56,  57,  124, 56,  48,  51,  56,  54,  50,  56,  46,  51,  53,  10,  52,
+    51,  56,  51,  51,  124, 56,  48,  51,  56,  53,  52,  53,  46,  56,  51,
+    10,  49,  52,  49,  49,  57,  56,  124, 56,  48,  51,  53,  49,  49,  48,
+    46,  55,  50,  10,  49,  51,  55,  50,  52,  56,  124, 56,  48,  51,  52,
+    49,  48,  57,  46,  51,  53,  10,  57,  54,  54,  55,  51,  124, 56,  48,
+    51,  51,  52,  57,  49,  46,  50,  48,  10,  51,  50,  49,  56,  48,  124,
+    56,  48,  51,  50,  51,  56,  48,  46,  55,  50,  10,  49,  54,  54,  52,
+    57,  51,  124, 56,  48,  51,  49,  57,  48,  50,  46,  52,  48,  10,  54,
+    54,  57,  53,  57,  124, 56,  48,  51,  49,  56,  51,  57,  46,  52,  48,
+    10,  56,  53,  54,  50,  56,  124, 56,  48,  50,  57,  54,  57,  51,  46,
+    52,  52,  10,  49,  49,  48,  57,  55,  49,  124, 56,  48,  50,  57,  52,
+    54,  57,  46,  55,  48,  10,  49,  51,  48,  51,  57,  53,  124, 56,  48,
+    50,  55,  52,  54,  51,  46,  57,  50,  10,  55,  55,  53,  55,  124, 56,
+    48,  50,  54,  56,  52,  48,  46,  51,  55,  10,  49,  55,  56,  52,  52,
+    54,  124, 56,  48,  50,  53,  51,  55,  57,  46,  48,  57,  10,  52,  49,
+    50,  57,  53,  124, 56,  48,  50,  52,  55,  56,  53,  46,  53,  51,  10,
+    49,  48,  48,  57,  53,  54,  124, 56,  48,  50,  52,  49,  55,  57,  46,
+    51,  48,  10,  49,  51,  49,  57,  49,  55,  124, 56,  48,  50,  49,  54,
+    48,  52,  46,  55,  56,  10,  50,  52,  50,  50,  52,  124, 56,  48,  50,
+    48,  52,  54,  51,  46,  53,  50,  10,  50,  48,  55,  51,  124, 56,  48,
+    50,  48,  48,  48,  57,  46,  54,  52,  10,  49,  50,  49,  54,  50,  50,
+    124, 56,  48,  49,  56,  52,  54,  50,  46,  49,  55,  10,  49,  52,  51,
+    53,  55,  124, 56,  48,  49,  54,  57,  48,  54,  46,  51,  48,  10,  49,
+    51,  53,  54,  48,  49,  124, 56,  48,  49,  54,  50,  48,  57,  46,  52,
+    52,  10,  53,  56,  52,  53,  56,  124, 56,  48,  49,  54,  49,  57,  50,
+    46,  53,  50,  10,  55,  51,  48,  51,  54,  124, 56,  48,  49,  53,  55,
+    57,  57,  46,  48,  48,  10,  49,  56,  52,  55,  50,  50,  124, 56,  48,
+    49,  53,  54,  56,  48,  46,  51,  49,  10,  49,  53,  49,  54,  54,  52,
+    124, 56,  48,  49,  52,  56,  50,  49,  46,  57,  54,  10,  49,  57,  53,
+    48,  57,  48,  124, 56,  48,  49,  50,  54,  56,  48,  46,  50,  48,  10,
+    49,  54,  50,  54,  48,  57,  124, 56,  48,  49,  49,  50,  52,  49,  46,
+    48,  48,  10,  56,  51,  53,  51,  50,  124, 56,  48,  48,  57,  55,  53,
+    51,  46,  56,  53,  10,  53,  48,  49,  54,  54,  124, 56,  48,  48,  55,
+    49,  51,  55,  46,  56,  57,  10,  49,  56,  49,  53,  54,  50,  124, 56,
+    48,  48,  54,  56,  48,  53,  46,  57,  54,  10,  49,  55,  53,  49,  54,
+    53,  124, 56,  48,  48,  53,  51,  49,  57,  46,  55,  54,  10,  54,  50,
+    53,  48,  48,  124, 56,  48,  48,  53,  51,  49,  54,  46,  50,  56,  10,
+    51,  54,  51,  52,  50,  124, 56,  48,  48,  52,  51,  51,  51,  46,  52,
+    48,  10,  49,  50,  56,  52,  51,  53,  124, 56,  48,  48,  52,  50,  52,
+    50,  46,  56,  56,  10,  57,  50,  53,  49,  54,  124, 56,  48,  48,  51,
+    56,  51,  54,  46,  56,  48,  10,  51,  48,  56,  48,  50,  124, 56,  48,
+    48,  51,  55,  49,  48,  46,  56,  56,  10,  49,  48,  55,  52,  49,  56,
+    124, 56,  48,  48,  48,  52,  51,  48,  46,  51,  48,  10,  52,  54,  54,
+    50,  48,  124, 55,  57,  57,  57,  55,  55,  56,  46,  51,  53,  10,  49,
+    57,  49,  56,  48,  51,  124, 55,  57,  57,  52,  55,  51,  52,  46,  49,
+    53,  10,  49,  48,  54,  51,  52,  51,  124, 55,  57,  57,  51,  48,  56,
+    55,  46,  55,  54,  10,  53,  57,  51,  54,  50,  124, 55,  57,  57,  48,
+    51,  57,  55,  46,  52,  54,  10,  56,  51,  50,  57,  124, 55,  57,  57,
+    48,  48,  53,  50,  46,  57,  48,  10,  55,  53,  49,  51,  51,  124, 55,
+    57,  56,  56,  50,  52,  52,  46,  48,  48,  10,  49,  55,  57,  48,  50,
+    51,  124, 55,  57,  56,  54,  56,  50,  57,  46,  54,  50,  10,  49,  51,
+    53,  56,  57,  57,  124, 55,  57,  56,  53,  55,  50,  54,  46,  54,  52,
+    10,  53,  56,  50,  52,  124, 55,  57,  56,  53,  51,  52,  48,  46,  48,
+    50,  10,  49,  52,  56,  53,  55,  57,  124, 55,  57,  56,  52,  56,  56,
+    57,  46,  53,  54,  10,  57,  53,  56,  56,  56,  124, 55,  57,  56,  52,
+    55,  51,  53,  46,  55,  50,  10,  57,  55,  57,  49,  124, 55,  57,  56,
+    50,  54,  57,  57,  46,  55,  57,  10,  49,  55,  48,  52,  51,  55,  124,
+    55,  57,  56,  50,  51,  55,  48,  46,  55,  50,  10,  51,  57,  55,  56,
+    50,  124, 55,  57,  55,  55,  56,  53,  56,  46,  50,  52,  10,  50,  48,
+    54,  48,  53,  124, 55,  57,  55,  55,  53,  53,  54,  46,  48,  48,  10,
+    50,  56,  54,  56,  50,  124, 55,  57,  55,  54,  57,  54,  48,  46,  48,
+    48,  10,  52,  50,  49,  55,  50,  124, 55,  57,  55,  51,  51,  57,  57,
+    46,  48,  48,  10,  53,  54,  49,  51,  55,  124, 55,  57,  55,  49,  52,
+    48,  53,  46,  52,  48,  10,  54,  52,  55,  50,  57,  124, 55,  57,  55,
+    48,  55,  54,  57,  46,  55,  50,  10,  57,  56,  54,  52,  51,  124, 55,
+    57,  54,  56,  54,  48,  51,  46,  55,  51,  10,  49,  53,  51,  55,  56,
+    55,  124, 55,  57,  54,  55,  53,  51,  53,  46,  53,  56,  10,  56,  57,
+    51,  50,  124, 55,  57,  54,  55,  50,  50,  50,  46,  49,  57,  10,  50,
+    48,  49,  51,  52,  124, 55,  57,  54,  53,  55,  49,  51,  46,  50,  56,
+    10,  49,  57,  55,  54,  51,  53,  124, 55,  57,  54,  51,  53,  48,  55,
+    46,  53,  56,  10,  56,  48,  52,  48,  56,  124, 55,  57,  54,  51,  51,
+    49,  50,  46,  49,  55,  10,  51,  55,  55,  50,  56,  124, 55,  57,  54,
+    49,  56,  55,  53,  46,  54,  56,  10,  50,  54,  54,  50,  52,  124, 55,
+    57,  54,  49,  55,  55,  50,  46,  51,  49,  10,  52,  52,  55,  51,  54,
+    124, 55,  57,  54,  49,  49,  52,  52,  46,  49,  48,  10,  50,  57,  55,
+    54,  51,  124, 55,  57,  54,  48,  54,  48,  53,  46,  48,  51,  10,  51,
+    54,  49,  52,  55,  124, 55,  57,  53,  57,  52,  54,  51,  46,  54,  56,
+    10,  49,  52,  54,  48,  52,  48,  124, 55,  57,  53,  55,  53,  56,  55,
+    46,  54,  54,  10,  49,  49,  53,  52,  54,  57,  124, 55,  57,  53,  55,
+    52,  56,  53,  46,  49,  52,  10,  49,  52,  50,  50,  55,  54,  124, 55,
+    57,  53,  54,  55,  57,  48,  46,  54,  51,  10,  49,  56,  49,  50,  56,
+    48,  124, 55,  57,  53,  52,  48,  51,  55,  46,  51,  53,  10,  49,  49,
+    53,  48,  57,  54,  124, 55,  57,  53,  51,  48,  52,  55,  46,  53,  53,
+    10,  49,  48,  57,  54,  53,  48,  124, 55,  57,  53,  50,  50,  53,  56,
+    46,  55,  51,  10,  57,  51,  56,  54,  50,  124, 55,  57,  53,  49,  57,
+    57,  50,  46,  50,  52,  10,  49,  53,  56,  51,  50,  53,  124, 55,  57,
+    53,  48,  55,  50,  56,  46,  51,  48,  10,  53,  53,  57,  53,  50,  124,
+    55,  57,  53,  48,  51,  56,  55,  46,  48,  54,  10,  49,  50,  50,  51,
+    57,  55,  124, 55,  57,  52,  55,  49,  48,  54,  46,  50,  55,  10,  50,
+    56,  49,  49,  52,  124, 55,  57,  52,  54,  57,  52,  53,  46,  55,  50,
+    10,  49,  49,  57,  54,  54,  124, 55,  57,  52,  53,  49,  57,  55,  46,
+    52,  56,  10,  52,  55,  56,  49,  52,  124, 55,  57,  52,  52,  48,  56,
+    51,  46,  48,  48,  10,  56,  53,  48,  57,  54,  124, 55,  57,  52,  51,
+    54,  57,  49,  46,  48,  54,  10,  53,  49,  54,  53,  55,  124, 55,  57,
+    52,  51,  53,  57,  51,  46,  55,  55,  10,  49,  57,  54,  54,  56,  48,
+    124, 55,  57,  52,  51,  53,  55,  56,  46,  56,  57,  10,  49,  51,  49,
+    52,  49,  124, 55,  57,  52,  50,  55,  51,  48,  46,  51,  52,  10,  49,
+    57,  51,  51,  50,  55,  124, 55,  57,  52,  49,  48,  51,  54,  46,  50,
+    53,  10,  49,  53,  50,  54,  49,  50,  124, 55,  57,  52,  48,  54,  54,
+    51,  46,  55,  49,  10,  49,  51,  57,  54,  56,  48,  124, 55,  57,  51,
+    57,  50,  52,  50,  46,  51,  54,  10,  51,  49,  49,  51,  52,  124, 55,
+    57,  51,  56,  51,  49,  56,  46,  51,  48,  10,  52,  53,  54,  51,  54,
+    124, 55,  57,  51,  55,  50,  52,  48,  46,  56,  53,  10,  53,  54,  54,
+    57,  52,  124, 55,  57,  51,  54,  48,  49,  53,  46,  57,  53,  10,  56,
+    49,  49,  52,  124, 55,  57,  51,  51,  57,  50,  49,  46,  56,  56,  10,
+    55,  49,  53,  49,  56,  124, 55,  57,  51,  50,  50,  54,  49,  46,  54,
+    57,  10,  55,  50,  57,  50,  50,  124, 55,  57,  51,  48,  52,  48,  48,
+    46,  54,  52,  10,  49,  52,  54,  54,  57,  57,  124, 55,  57,  50,  57,
+    49,  54,  55,  46,  52,  48,  10,  57,  50,  51,  56,  55,  124, 55,  57,
+    50,  56,  57,  55,  50,  46,  54,  55,  10,  49,  56,  54,  50,  56,  57,
+    124, 55,  57,  50,  56,  55,  56,  54,  46,  49,  57,  10,  57,  53,  57,
+    53,  50,  124, 55,  57,  50,  55,  57,  55,  50,  46,  55,  56,  10,  49,
+    57,  54,  53,  49,  52,  124, 55,  57,  50,  55,  49,  56,  48,  46,  55,
+    48,  10,  52,  52,  48,  51,  124, 55,  57,  50,  53,  55,  50,  57,  46,
+    48,  52,  10,  50,  50,  54,  55,  124, 55,  57,  50,  53,  54,  52,  57,
+    46,  51,  55,  10,  52,  53,  57,  50,  52,  124, 55,  57,  50,  53,  48,
+    52,  55,  46,  54,  56,  10,  49,  49,  52,  57,  51,  124, 55,  57,  49,
+    54,  55,  50,  50,  46,  50,  51,  10,  49,  48,  52,  52,  55,  56,  124,
+    55,  57,  49,  54,  50,  53,  51,  46,  54,  48,  10,  49,  54,  54,  55,
+    57,  52,  124, 55,  57,  49,  51,  56,  52,  50,  46,  48,  48,  10,  49,
+    54,  49,  57,  57,  53,  124, 55,  57,  49,  48,  56,  55,  52,  46,  50,
+    55,  10,  50,  51,  53,  51,  56,  124, 55,  57,  48,  57,  55,  53,  50,
+    46,  48,  54,  10,  52,  49,  48,  57,  51,  124, 55,  57,  48,  57,  53,
+    55,  57,  46,  57,  50,  10,  49,  49,  50,  48,  55,  51,  124, 55,  57,
+    48,  56,  54,  49,  55,  46,  53,  55,  10,  57,  50,  56,  49,  52,  124,
+    55,  57,  48,  56,  50,  54,  50,  46,  53,  48,  10,  56,  56,  57,  49,
+    57,  124, 55,  57,  48,  55,  57,  57,  50,  46,  53,  48,  10,  55,  57,
+    55,  53,  51,  124, 55,  57,  48,  55,  57,  51,  51,  46,  56,  56,  10,
+    49,  48,  56,  55,  54,  53,  124, 55,  57,  48,  53,  51,  51,  56,  46,
+    57,  56,  10,  49,  52,  54,  53,  51,  48,  124, 55,  57,  48,  53,  51,
+    51,  54,  46,  54,  48,  10,  55,  49,  52,  55,  53,  124, 55,  57,  48,
+    51,  51,  54,  55,  46,  53,  56,  10,  51,  54,  50,  56,  57,  124, 55,
+    57,  48,  49,  57,  52,  54,  46,  53,  48,  10,  54,  49,  55,  51,  57,
+    124, 55,  57,  48,  48,  55,  57,  52,  46,  48,  48,  10,  53,  50,  51,
+    51,  56,  124, 55,  56,  57,  56,  54,  51,  56,  46,  48,  56,  10,  49,
+    57,  52,  50,  57,  57,  124, 55,  56,  57,  56,  52,  50,  49,  46,  50,
+    52,  10,  49,  48,  53,  50,  51,  53,  124, 55,  56,  57,  55,  56,  50,
+    57,  46,  57,  52,  10,  55,  55,  50,  48,  55,  124, 55,  56,  57,  55,
+    55,  53,  50,  46,  55,  50,  10,  57,  54,  55,  49,  50,  124, 55,  56,
+    57,  55,  53,  55,  53,  46,  50,  55,  10,  49,  48,  49,  53,  55,  124,
+    55,  56,  57,  55,  48,  52,  54,  46,  50,  53,  10,  49,  55,  49,  49,
+    53,  52,  124, 55,  56,  57,  54,  56,  49,  52,  46,  53,  48,  10,  55,
+    57,  51,  55,  51,  124, 55,  56,  57,  54,  49,  56,  54,  46,  48,  48,
+    10,  49,  49,  51,  56,  48,  56,  124, 55,  56,  57,  51,  51,  53,  51,
+    46,  56,  56,  10,  50,  55,  57,  48,  49,  124, 55,  56,  57,  50,  57,
+    53,  50,  46,  48,  48,  10,  49,  50,  56,  56,  50,  48,  124, 55,  56,
+    57,  50,  56,  56,  50,  46,  55,  50,  10,  50,  53,  56,  57,  49,  124,
+    55,  56,  57,  48,  53,  49,  49,  46,  50,  48,  10,  49,  50,  50,  56,
+    49,  57,  124, 55,  56,  56,  56,  56,  56,  49,  46,  48,  50,  10,  49,
+    53,  52,  55,  51,  49,  124, 55,  56,  56,  56,  51,  48,  49,  46,  51,
+    51,  10,  49,  48,  49,  54,  55,  52,  124, 55,  56,  55,  57,  51,  50,
+    52,  46,  54,  48,  10,  53,  49,  57,  54,  56,  124, 55,  56,  55,  57,
+    49,  48,  50,  46,  50,  49,  10,  55,  50,  48,  55,  51,  124, 55,  56,
+    55,  55,  55,  51,  54,  46,  49,  49,  10,  53,  49,  56,  50,  124, 55,
+    56,  55,  52,  53,  50,  49,  46,  55,  51,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q12[] = {
+    108, 95,  115, 104, 105, 112, 109, 111, 100, 101, 124, 104, 105, 103, 104,
+    95,  108, 105, 110, 101, 95,  99,  111, 117, 110, 116, 124, 108, 111, 119,
+    95,  108, 105, 110, 101, 95,  99,  111, 117, 110, 116, 10,  77,  65,  73,
+    76,  124, 54,  50,  48,  50,  124, 57,  51,  50,  52,  10,  83,  72,  73,
+    80,  124, 54,  50,  48,  48,  124, 57,  50,  54,  50,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q13[] = {
+    99,  95,  99,  111, 117, 110, 116, 124, 99,  117, 115, 116, 100, 105, 115,
+    116, 10,  48,  124, 53,  48,  48,  48,  53,  10,  57,  124, 54,  54,  52,
+    49,  10,  49,  48,  124, 54,  53,  51,  50,  10,  49,  49,  124, 54,  48,
+    49,  52,  10,  56,  124, 53,  57,  51,  55,  10,  49,  50,  124, 53,  54,
+    51,  57,  10,  49,  51,  124, 53,  48,  50,  52,  10,  49,  57,  124, 52,
+    55,  57,  51,  10,  55,  124, 52,  54,  56,  55,  10,  49,  55,  124, 52,
+    53,  56,  55,  10,  49,  56,  124, 52,  53,  50,  57,  10,  50,  48,  124,
+    52,  53,  49,  54,  10,  49,  53,  124, 52,  53,  48,  53,  10,  49,  52,
+    124, 52,  52,  52,  54,  10,  49,  54,  124, 52,  50,  55,  51,  10,  50,
+    49,  124, 52,  49,  57,  48,  10,  50,  50,  124, 51,  54,  50,  51,  10,
+    54,  124, 51,  50,  54,  53,  10,  50,  51,  124, 51,  50,  50,  53,  10,
+    50,  52,  124, 50,  55,  52,  50,  10,  50,  53,  124, 50,  48,  56,  54,
+    10,  53,  124, 49,  57,  52,  56,  10,  50,  54,  124, 49,  54,  49,  50,
+    10,  50,  55,  124, 49,  49,  55,  57,  10,  52,  124, 49,  48,  48,  55,
+    10,  50,  56,  124, 56,  57,  51,  10,  50,  57,  124, 53,  57,  51,  10,
+    51,  124, 52,  49,  53,  10,  51,  48,  124, 51,  55,  54,  10,  51,  49,
+    124, 50,  50,  54,  10,  51,  50,  124, 49,  52,  56,  10,  50,  124, 49,
+    51,  52,  10,  51,  51,  124, 55,  53,  10,  51,  52,  124, 53,  48,  10,
+    51,  53,  124, 51,  55,  10,  49,  124, 49,  55,  10,  51,  54,  124, 49,
+    52,  10,  51,  56,  124, 53,  10,  51,  55,  124, 53,  10,  52,  48,  124,
+    52,  10,  52,  49,  124, 50,  10,  51,  57,  124, 49,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q14[] = {
+    112, 114, 111, 109, 111, 95, 114, 101, 118, 101, 110, 117, 101,
+    10,  49,  54,  46,  51,  56, 48,  55,  55,  56,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q15[] = {
+    115, 95,  115, 117, 112, 112, 107, 101, 121, 124, 115, 95,  110, 97,
+    109, 101, 124, 115, 95,  97,  100, 100, 114, 101, 115, 115, 124, 115,
+    95,  112, 104, 111, 110, 101, 124, 116, 111, 116, 97,  108, 95,  114,
+    101, 118, 101, 110, 117, 101, 10,  56,  52,  52,  57,  124, 83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  52,
+    52,  57,  124, 53,  66,  88,  87,  115, 74,  69,  82,  65,  50,  109,
+    80,  53,  79,  121, 79,  52,  124, 50,  48,  45,  52,  54,  57,  45,
+    56,  53,  54,  45,  56,  56,  55,  51,  124, 49,  55,  55,  50,  54,
+    50,  55,  46,  50,  48,  56,  55,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q16[] = {
+    112, 95,  98,  114, 97,  110, 100, 124, 112, 95,  116, 121, 112, 101, 124,
+    112, 95,  115, 105, 122, 101, 124, 115, 117, 112, 112, 108, 105, 101, 114,
+    95,  99,  110, 116, 10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 50,  56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 50,
+    55,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    50,  52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 50,  52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 50,  52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 50,  52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 50,  52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 50,  52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    50,  52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 50,  52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 50,  52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 50,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 50,  52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 50,  52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 50,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 50,  52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 50,  52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 50,  51,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 50,  51,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 50,  51,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 50,  48,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 50,  48,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 50,  48,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 50,  48,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 50,  48,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 50,  48,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 50,  48,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 50,  48,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 50,  48,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 50,
+    48,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 50,  48,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 50,
+    48,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 50,  48,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 50,
+    48,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 50,  48,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 50,
+    48,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 50,
+    48,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 50,  48,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 50,  48,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 50,  48,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 50,
+    48,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 50,
+    48,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 50,  48,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    50,  48,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 50,  48,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 50,  48,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 50,  48,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 49,  57,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,
+    54,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 49,  54,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  54,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 49,  54,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  54,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  54,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  54,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    49,  54,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  54,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 49,  53,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 49,  53,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,
+    53,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 49,  53,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 49,
+    50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 49,  50,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 49,  50,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 49,  50,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 49,  50,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 49,  50,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 49,  50,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 49,  49,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 49,
+    49,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 49,  49,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 49,  49,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 49,  49,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 49,  49,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 49,  49,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 49,  49,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    49,  49,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 49,  49,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    49,  49,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 49,  49,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    49,  49,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 49,  49,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 49,  49,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 56,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 56,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 56,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 56,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 56,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 56,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 56,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 55,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 55,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 55,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 55,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 55,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 55,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    55,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 55,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 55,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 55,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 55,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 55,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 55,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 55,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 55,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 55,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 55,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 55,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 55,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 55,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 55,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 55,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 55,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 55,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 55,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 54,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  49,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  49,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  50,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  50,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  51,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  52,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  52,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  49,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  49,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  50,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  50,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,
+    85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,
+    84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,
+    65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  51,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  51,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,
+    69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,
+    71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,
+    85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,
+    76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,
+    73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,
+    77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,
+    65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,
+    65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,
+    84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    52,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,
+    77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,  68,  32,  84,
+    73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  76,  65,  84,  69,
+    68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,
+    79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,
+    89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,
+    67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 69,  67,  79,  78,  79,  77,  89,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 69,  67,  79,  78,  79,  77,  89,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 69,  67,
+    79,  78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,
+    69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,
+    84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,
+    71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,
+    65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,
+    53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,
+    82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,
+    85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,
+    73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  65,  78,  79,  68,
+    73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,
+    80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,
+    68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,
+    68,  32,  83,  84,  69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,  77,  32,  80,  76,
+    65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,  69,  68,  73,  85,
+    77,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 77,
+    69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 77,  69,  68,  73,  85,  77,  32,  80,  76,  65,  84,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  66,  85,  82,  78,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 50,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,
+    65,  83,  83,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,
+    79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,
+    77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,  79,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,  82,  79,  77,
+    79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 80,
+    82,  79,  77,  79,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,
+    83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,
+    68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,
+    65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  65,  78,  79,  68,  73,  90,  69,  68,
+    32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,
+    79,  80,  80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,
+    85,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,
+    84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,
+    76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,
+    82,  78,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,  73,
+    78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,
+    65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  76,  65,
+    84,  69,  68,  32,  84,  73,  78,  124, 52,  53,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,
+    76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,
+    83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 51,  54,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    67,  79,  80,  80,  69,  82,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,
+    69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,
+    68,  32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,
+    73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,
+    76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  77,  65,  76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  83,  84,  69,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,  76,  76,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 50,  51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  77,  65,
+    76,  76,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,  80,  80,
+    69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  52,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  67,  79,
+    80,  80,  69,  82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100,
+    35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,
+    79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,
+    90,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,
+    124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,
+    69,  68,  32,  84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 49,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  78,  73,
+    67,  75,  69,  76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,
+    83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  57,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,
+    57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  66,  82,  85,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 49,  57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,
+    85,  82,  78,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124,
+    50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,
+    69,  68,  32,  66,  82,  65,  83,  83,  124, 51,  54,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,
+    124, 49,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,
+    72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  83,  84,
+    69,  69,  76,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,  76,  124, 52,  53,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,
+    32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,
+    78,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,  124, 52,
+    10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,
+    65,  82,  68,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,  84,
+    73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  66,  85,  82,  78,
+    73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,
+    124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  57,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  67,  79,  80,
+    80,  69,  82,  124, 57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  67,  79,  80,  80,  69,  82,  124, 52,  53,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,
+    76,  124, 51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,
+    32,  78,  73,  67,  75,  69,  76,  124, 49,  57,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  76,  65,  84,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124,
+    52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,
+    68,  65,  82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,
+    69,  76,  124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,
+    53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  76,  65,  84,
+    69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 49,  52,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 51,
+    54,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    66,  82,  65,  83,  83,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110,
+    100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,  82,  124,
+    51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,
+    65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,
+    32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 52,  10,  66,  114,
+    97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,
+    32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  67,  79,  80,  80,  69,
+    82,  124, 52,  53,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  124, 52,  10,
+    66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,
+    82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,
+    75,  69,  76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,
+    73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 51,  54,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 52,  57,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124,
+    83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,
+    69,  68,  32,  83,  84,  69,  69,  76,  124, 49,  52,  124, 52,  10,  66,
+    114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,
+    68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  83,  84,  69,  69,
+    76,  124, 50,  51,  124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,
+    124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,
+    72,  69,  68,  32,  84,  73,  78,  124, 57,  124, 52,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  84,  73,  78,  124, 49,  57,
+    124, 52,  10,  66,  114, 97,  110, 100, 35,  53,  53,  124, 83,  84,  65,
+    78,  68,  65,  82,  68,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,
+    84,  73,  78,  124, 51,  54,  124, 52,  10,  66,  114, 97,  110, 100, 35,
+    49,  49,  124, 83,  77,  65,  76,  76,  32,  66,  82,  85,  83,  72,  69,
+    68,  32,  84,  73,  78,  124, 49,  57,  124, 51,  10,  66,  114, 97,  110,
+    100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,  80,  76,  65,  84,
+    69,  68,  32,  78,  73,  67,  75,  69,  76,  124, 52,  53,  124, 51,  10,
+    66,  114, 97,  110, 100, 35,  49,  53,  124, 76,  65,  82,  71,  69,  32,
+    80,  79,  76,  73,  83,  72,  69,  68,  32,  78,  73,  67,  75,  69,  76,
+    124, 57,  124, 51,  10,  66,  114, 97,  110, 100, 35,  50,  49,  124, 80,
+    82,  79,  77,  79,  32,  66,  85,  82,  78,  73,  83,  72,  69,  68,  32,
+    83,  84,  69,  69,  76,  124, 52,  53,  124, 51,  10,  66,  114, 97,  110,
+    100, 35,  50,  50,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,  80,
+    76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124, 50,  51,  124,
+    51,  10,  66,  114, 97,  110, 100, 35,  50,  53,  124, 76,  65,  82,  71,
+    69,  32,  80,  76,  65,  84,  69,  68,  32,  83,  84,  69,  69,  76,  124,
+    49,  57,  124, 51,  10,  66,  114, 97,  110, 100, 35,  51,  50,  124, 83,
+    84,  65,  78,  68,  65,  82,  68,  32,  65,  78,  79,  68,  73,  90,  69,
+    68,  32,  67,  79,  80,  80,  69,  82,  124, 50,  51,  124, 51,  10,  66,
+    114, 97,  110, 100, 35,  51,  51,  124, 83,  77,  65,  76,  76,  32,  65,
+    78,  79,  68,  73,  90,  69,  68,  32,  66,  82,  65,  83,  83,  124, 57,
+    124, 51,  10,  66,  114, 97,  110, 100, 35,  51,  53,  124, 77,  69,  68,
+    73,  85,  77,  32,  65,  78,  79,  68,  73,  90,  69,  68,  32,  84,  73,
+    78,  124, 49,  57,  124, 51,  10,  66,  114, 97,  110, 100, 35,  53,  49,
+    124, 83,  77,  65,  76,  76,  32,  80,  76,  65,  84,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 50,  51,  124, 51,  10,  66,  114, 97,  110, 100,
+    35,  53,  50,  124, 77,  69,  68,  73,  85,  77,  32,  66,  82,  85,  83,
+    72,  69,  68,  32,  66,  82,  65,  83,  83,  124, 52,  53,  124, 51,  10,
+    66,  114, 97,  110, 100, 35,  53,  51,  124, 77,  69,  68,  73,  85,  77,
+    32,  66,  82,  85,  83,  72,  69,  68,  32,  84,  73,  78,  124, 52,  53,
+    124, 51,  10,  66,  114, 97,  110, 100, 35,  53,  52,  124, 69,  67,  79,
+    78,  79,  77,  89,  32,  80,  79,  76,  73,  83,  72,  69,  68,  32,  66,
+    82,  65,  83,  83,  124, 57,  124, 51,  10,  66,  114, 97,  110, 100, 35,
+    53,  53,  124, 80,  82,  79,  77,  79,  32,  80,  76,  65,  84,  69,  68,
+    32,  66,  82,  65,  83,  83,  124, 49,  57,  124, 51,  10,  66,  114, 97,
+    110, 100, 35,  53,  53,  124, 83,  84,  65,  78,  68,  65,  82,  68,  32,
+    80,  76,  65,  84,  69,  68,  32,  84,  73,  78,  124, 52,  57,  124, 51,
+    10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q17[] = {97,  118, 103, 95, 121, 101, 97, 114,
+                                        108, 121, 10,  51, 52,  56,  52, 48,
+                                        54,  46,  48,  53, 10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q18[] = {
+    99,  95,  110, 97,  109, 101, 124, 99,  95,  99,  117, 115, 116, 107, 101,
+    121, 124, 111, 95,  111, 114, 100, 101, 114, 107, 101, 121, 124, 111, 95,
+    111, 114, 100, 101, 114, 100, 97,  116, 101, 124, 111, 95,  116, 111, 116,
+    97,  108, 112, 114, 105, 99,  101, 124, 115, 117, 109, 10,  67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  50,  56,  49,  50,  48,
+    124, 49,  50,  56,  49,  50,  48,  124, 52,  55,  50,  50,  48,  50,  49,
+    124, 49,  57,  57,  52,  45,  48,  52,  45,  48,  55,  124, 53,  52,  52,
+    48,  56,  57,  46,  48,  57,  124, 51,  50,  51,  10,  67,  117, 115, 116,
+    111, 109, 101, 114, 35,  48,  48,  48,  49,  52,  52,  54,  49,  55,  124,
+    49,  52,  52,  54,  49,  55,  124, 51,  48,  52,  51,  50,  55,  48,  124,
+    49,  57,  57,  55,  45,  48,  50,  45,  49,  50,  124, 53,  51,  48,  54,
+    48,  52,  46,  52,  52,  124, 51,  49,  55,  10,  67,  117, 115, 116, 111,
+    109, 101, 114, 35,  48,  48,  48,  48,  49,  51,  57,  52,  48,  124, 49,
+    51,  57,  52,  48,  124, 50,  50,  51,  50,  57,  51,  50,  124, 49,  57,
+    57,  55,  45,  48,  52,  45,  49,  51,  124, 53,  50,  50,  55,  50,  48,
+    46,  54,  49,  124, 51,  48,  52,  10,  67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  54,  54,  55,  57,  48,  124, 54,  54,  55,
+    57,  48,  124, 50,  49,  57,  57,  55,  49,  50,  124, 49,  57,  57,  54,
+    45,  48,  57,  45,  51,  48,  124, 53,  49,  53,  53,  51,  49,  46,  56,
+    50,  124, 51,  50,  55,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  52,  54,  52,  51,  53,  124, 52,  54,  52,  51,  53,
+    124, 52,  55,  52,  53,  54,  48,  55,  124, 49,  57,  57,  55,  45,  48,
+    55,  45,  48,  51,  124, 53,  48,  56,  48,  52,  55,  46,  57,  57,  124,
+    51,  48,  57,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  48,  49,  53,  50,  55,  50,  124, 49,  53,  50,  55,  50,  124, 51,
+    56,  56,  51,  55,  56,  51,  124, 49,  57,  57,  51,  45,  48,  55,  45,
+    50,  56,  124, 53,  48,  48,  50,  52,  49,  46,  51,  51,  124, 51,  48,
+    50,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,
+    52,  54,  54,  48,  56,  124, 49,  52,  54,  54,  48,  56,  124, 51,  51,
+    52,  50,  52,  54,  56,  124, 49,  57,  57,  52,  45,  48,  54,  45,  49,
+    50,  124, 52,  57,  57,  55,  57,  52,  46,  53,  56,  124, 51,  48,  51,
+    10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  57,
+    54,  49,  48,  51,  124, 57,  54,  49,  48,  51,  124, 53,  57,  56,  52,
+    53,  56,  50,  124, 49,  57,  57,  50,  45,  48,  51,  45,  49,  54,  124,
+    52,  57,  52,  51,  57,  56,  46,  55,  57,  124, 51,  49,  50,  10,  67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  50,  52,  51,
+    52,  49,  124, 50,  52,  51,  52,  49,  124, 49,  52,  55,  52,  56,  49,
+    56,  124, 49,  57,  57,  50,  45,  49,  49,  45,  49,  53,  124, 52,  57,
+    49,  51,  52,  56,  46,  50,  54,  124, 51,  48,  50,  10,  67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  51,  55,  52,  52,  54,
+    124, 49,  51,  55,  52,  52,  54,  124, 53,  52,  56,  57,  52,  55,  53,
+    124, 49,  57,  57,  55,  45,  48,  53,  45,  50,  51,  124, 52,  56,  55,
+    55,  54,  51,  46,  50,  53,  124, 51,  49,  49,  10,  67,  117, 115, 116,
+    111, 109, 101, 114, 35,  48,  48,  48,  49,  48,  55,  53,  57,  48,  124,
+    49,  48,  55,  53,  57,  48,  124, 52,  50,  54,  55,  55,  53,  49,  124,
+    49,  57,  57,  52,  45,  49,  49,  45,  48,  52,  124, 52,  56,  53,  49,
+    52,  49,  46,  51,  56,  124, 51,  48,  49,  10,  67,  117, 115, 116, 111,
+    109, 101, 114, 35,  48,  48,  48,  48,  53,  48,  48,  48,  56,  124, 53,
+    48,  48,  48,  56,  124, 50,  51,  54,  54,  55,  53,  53,  124, 49,  57,
+    57,  54,  45,  49,  50,  45,  48,  57,  124, 52,  56,  51,  56,  57,  49,
+    46,  50,  54,  124, 51,  48,  50,  10,  67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  49,  53,  54,  49,  57,  124, 49,  53,  54,
+    49,  57,  124, 51,  55,  54,  55,  50,  55,  49,  124, 49,  57,  57,  54,
+    45,  48,  56,  45,  48,  55,  124, 52,  56,  48,  48,  56,  51,  46,  57,
+    54,  124, 51,  49,  56,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  55,  55,  50,  54,  48,  124, 55,  55,  50,  54,  48,
+    124, 49,  52,  51,  54,  53,  52,  52,  124, 49,  57,  57,  50,  45,  48,
+    57,  45,  49,  50,  124, 52,  55,  57,  52,  57,  57,  46,  52,  51,  124,
+    51,  48,  55,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  49,  48,  57,  51,  55,  57,  124, 49,  48,  57,  51,  55,  57,  124,
+    53,  55,  52,  54,  51,  49,  49,  124, 49,  57,  57,  54,  45,  49,  48,
+    45,  49,  48,  124, 52,  55,  56,  48,  54,  52,  46,  49,  49,  124, 51,
+    48,  50,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  53,  52,  54,  48,  50,  124, 53,  52,  54,  48,  50,  124, 53,  56,
+    51,  50,  51,  50,  49,  124, 49,  57,  57,  55,  45,  48,  50,  45,  48,
+    57,  124, 52,  55,  49,  50,  50,  48,  46,  48,  56,  124, 51,  48,  55,
+    10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  48,
+    53,  57,  57,  53,  124, 49,  48,  53,  57,  57,  53,  124, 50,  48,  57,
+    54,  55,  48,  53,  124, 49,  57,  57,  52,  45,  48,  55,  45,  48,  51,
+    124, 52,  54,  57,  54,  57,  50,  46,  53,  56,  124, 51,  48,  55,  10,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  52,  56,
+    56,  56,  53,  124, 49,  52,  56,  56,  56,  53,  124, 50,  57,  52,  50,
+    52,  54,  57,  124, 49,  57,  57,  50,  45,  48,  53,  45,  51,  49,  124,
+    52,  54,  57,  54,  51,  48,  46,  52,  52,  124, 51,  49,  51,  10,  67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  49,  52,  53,
+    56,  54,  124, 49,  49,  52,  53,  56,  54,  124, 53,  53,  49,  49,  51,
+    54,  124, 49,  57,  57,  51,  45,  48,  53,  45,  49,  57,  124, 52,  54,
+    57,  54,  48,  53,  46,  53,  57,  124, 51,  48,  56,  10,  67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  48,  53,  50,  54,  48,
+    124, 49,  48,  53,  50,  54,  48,  124, 53,  50,  57,  54,  49,  54,  55,
+    124, 49,  57,  57,  54,  45,  48,  57,  45,  48,  54,  124, 52,  54,  57,
+    51,  54,  48,  46,  53,  55,  124, 51,  48,  51,  10,  67,  117, 115, 116,
+    111, 109, 101, 114, 35,  48,  48,  48,  49,  52,  55,  49,  57,  55,  124,
+    49,  52,  55,  49,  57,  55,  124, 49,  50,  54,  51,  48,  49,  53,  124,
+    49,  57,  57,  55,  45,  48,  50,  45,  48,  50,  124, 52,  54,  55,  49,
+    52,  57,  46,  54,  55,  124, 51,  50,  48,  10,  67,  117, 115, 116, 111,
+    109, 101, 114, 35,  48,  48,  48,  48,  54,  52,  52,  56,  51,  124, 54,
+    52,  52,  56,  51,  124, 50,  55,  52,  53,  56,  57,  52,  124, 49,  57,
+    57,  54,  45,  48,  55,  45,  48,  52,  124, 52,  54,  54,  57,  57,  49,
+    46,  51,  53,  124, 51,  48,  52,  10,  67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  49,  51,  54,  53,  55,  51,  124, 49,  51,  54,
+    53,  55,  51,  124, 50,  55,  54,  49,  51,  55,  56,  124, 49,  57,  57,
+    54,  45,  48,  53,  45,  51,  49,  124, 52,  54,  49,  50,  56,  50,  46,
+    55,  51,  124, 51,  48,  49,  10,  67,  117, 115, 116, 111, 109, 101, 114,
+    35,  48,  48,  48,  48,  49,  54,  51,  56,  52,  124, 49,  54,  51,  56,
+    52,  124, 53,  48,  50,  56,  56,  54,  124, 49,  57,  57,  52,  45,  48,
+    52,  45,  49,  50,  124, 52,  53,  56,  51,  55,  56,  46,  57,  50,  124,
+    51,  49,  50,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  49,  49,  55,  57,  49,  57,  124, 49,  49,  55,  57,  49,  57,  124,
+    50,  56,  54,  57,  49,  53,  50,  124, 49,  57,  57,  54,  45,  48,  54,
+    45,  50,  48,  124, 52,  53,  54,  56,  49,  53,  46,  57,  50,  124, 51,
+    49,  55,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  49,  50,  50,  53,  49,  124, 49,  50,  50,  53,  49,  124, 55,  51,
+    53,  51,  54,  54,  124, 49,  57,  57,  51,  45,  49,  49,  45,  50,  52,
+    124, 52,  53,  53,  49,  48,  55,  46,  50,  54,  124, 51,  48,  57,  10,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  50,  48,
+    48,  57,  56,  124, 49,  50,  48,  48,  57,  56,  124, 49,  57,  55,  49,
+    54,  56,  48,  124, 49,  57,  57,  53,  45,  48,  54,  45,  49,  52,  124,
+    52,  53,  51,  52,  53,  49,  46,  50,  51,  124, 51,  48,  56,  10,  67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  54,  54,  48,
+    57,  56,  124, 54,  54,  48,  57,  56,  124, 53,  48,  48,  55,  52,  57,
+    48,  124, 49,  57,  57,  50,  45,  48,  56,  45,  48,  55,  124, 52,  53,
+    51,  52,  51,  54,  46,  49,  54,  124, 51,  48,  52,  10,  67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  49,  55,  48,  55,  54,
+    124, 49,  49,  55,  48,  55,  54,  124, 52,  50,  57,  48,  54,  53,  54,
+    124, 49,  57,  57,  55,  45,  48,  50,  45,  48,  53,  124, 52,  52,  57,
+    53,  52,  53,  46,  56,  53,  124, 51,  48,  49,  10,  67,  117, 115, 116,
+    111, 109, 101, 114, 35,  48,  48,  48,  49,  50,  57,  51,  55,  57,  124,
+    49,  50,  57,  51,  55,  57,  124, 52,  55,  50,  48,  52,  53,  52,  124,
+    49,  57,  57,  55,  45,  48,  54,  45,  48,  55,  124, 52,  52,  56,  54,
+    54,  53,  46,  55,  57,  124, 51,  48,  51,  10,  67,  117, 115, 116, 111,
+    109, 101, 114, 35,  48,  48,  48,  49,  50,  54,  56,  54,  53,  124, 49,
+    50,  54,  56,  54,  53,  124, 52,  55,  48,  50,  55,  53,  57,  124, 49,
+    57,  57,  52,  45,  49,  49,  45,  48,  55,  124, 52,  52,  55,  54,  48,
+    54,  46,  54,  53,  124, 51,  50,  48,  10,  67,  117, 115, 116, 111, 109,
+    101, 114, 35,  48,  48,  48,  48,  56,  56,  56,  55,  54,  124, 56,  56,
+    56,  55,  54,  124, 57,  56,  51,  50,  48,  49,  124, 49,  57,  57,  51,
+    45,  49,  50,  45,  51,  48,  124, 52,  52,  54,  55,  49,  55,  46,  52,
+    54,  124, 51,  48,  52,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  51,  54,  54,  49,  57,  124, 51,  54,  54,  49,  57,
+    124, 52,  56,  48,  54,  55,  50,  54,  124, 49,  57,  57,  53,  45,  48,
+    49,  45,  49,  55,  124, 52,  52,  54,  55,  48,  52,  46,  48,  57,  124,
+    51,  50,  56,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  49,  52,  49,  56,  50,  51,  124, 49,  52,  49,  56,  50,  51,  124,
+    50,  56,  48,  54,  50,  52,  53,  124, 49,  57,  57,  54,  45,  49,  50,
+    45,  50,  57,  124, 52,  52,  54,  50,  54,  57,  46,  49,  50,  124, 51,
+    49,  48,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  53,  51,  48,  50,  57,  124, 53,  51,  48,  50,  57,  124, 50,  54,
+    54,  50,  50,  49,  52,  124, 49,  57,  57,  51,  45,  48,  56,  45,  49,
+    51,  124, 52,  52,  54,  49,  52,  52,  46,  52,  57,  124, 51,  48,  50,
+    10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  49,
+    56,  49,  56,  56,  124, 49,  56,  49,  56,  56,  124, 51,  48,  51,  55,
+    52,  49,  52,  124, 49,  57,  57,  53,  45,  48,  49,  45,  50,  53,  124,
+    52,  52,  51,  56,  48,  55,  46,  50,  50,  124, 51,  48,  56,  10,  67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  54,  54,  53,
+    51,  51,  124, 54,  54,  53,  51,  51,  124, 50,  57,  49,  53,  56,  124,
+    49,  57,  57,  53,  45,  49,  48,  45,  50,  49,  124, 52,  52,  51,  53,
+    55,  54,  46,  53,  48,  124, 51,  48,  53,  10,  67,  117, 115, 116, 111,
+    109, 101, 114, 35,  48,  48,  48,  48,  51,  55,  55,  50,  57,  124, 51,
+    55,  55,  50,  57,  124, 52,  49,  51,  52,  51,  52,  49,  124, 49,  57,
+    57,  53,  45,  48,  54,  45,  50,  57,  124, 52,  52,  49,  48,  56,  50,
+    46,  57,  55,  124, 51,  48,  57,  10,  67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  48,  51,  53,  54,  54,  124, 51,  53,  54,
+    54,  124, 50,  51,  50,  57,  49,  56,  55,  124, 49,  57,  57,  56,  45,
+    48,  49,  45,  48,  52,  124, 52,  51,  57,  56,  48,  51,  46,  51,  54,
+    124, 51,  48,  52,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,
+    48,  48,  48,  52,  53,  53,  51,  56,  124, 52,  53,  53,  51,  56,  124,
+    52,  53,  50,  55,  53,  53,  51,  124, 49,  57,  57,  52,  45,  48,  53,
+    45,  50,  50,  124, 52,  51,  54,  50,  55,  53,  46,  51,  49,  124, 51,
+    48,  53,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  56,  49,  53,  56,  49,  124, 56,  49,  53,  56,  49,  124, 52,  55,
+    51,  57,  54,  53,  48,  124, 49,  57,  57,  53,  45,  49,  49,  45,  48,
+    52,  124, 52,  51,  53,  52,  48,  53,  46,  57,  48,  124, 51,  48,  53,
+    10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  49,
+    57,  57,  56,  57,  124, 49,  49,  57,  57,  56,  57,  124, 49,  53,  52,
+    52,  54,  52,  51,  124, 49,  57,  57,  55,  45,  48,  57,  45,  50,  48,
+    124, 52,  51,  52,  53,  54,  56,  46,  50,  53,  124, 51,  50,  48,  10,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  48,  51,
+    54,  56,  48,  124, 51,  54,  56,  48,  124, 51,  56,  54,  49,  49,  50,
+    51,  124, 49,  57,  57,  56,  45,  48,  55,  45,  48,  51,  124, 52,  51,
+    51,  53,  50,  53,  46,  57,  55,  124, 51,  48,  49,  10,  67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  49,  51,  49,  51,  49,
+    124, 49,  49,  51,  49,  51,  49,  124, 57,  54,  55,  51,  51,  52,  124,
+    49,  57,  57,  53,  45,  49,  50,  45,  49,  53,  124, 52,  51,  50,  57,
+    53,  55,  46,  55,  53,  124, 51,  48,  49,  10,  67,  117, 115, 116, 111,
+    109, 101, 114, 35,  48,  48,  48,  49,  52,  49,  48,  57,  56,  124, 49,
+    52,  49,  48,  57,  56,  124, 53,  54,  53,  53,  55,  52,  124, 49,  57,
+    57,  53,  45,  48,  57,  45,  50,  52,  124, 52,  51,  48,  57,  56,  54,
+    46,  54,  57,  124, 51,  48,  49,  10,  67,  117, 115, 116, 111, 109, 101,
+    114, 35,  48,  48,  48,  48,  57,  51,  51,  57,  50,  124, 57,  51,  51,
+    57,  50,  124, 53,  50,  48,  48,  49,  48,  50,  124, 49,  57,  57,  55,
+    45,  48,  49,  45,  50,  50,  124, 52,  50,  53,  52,  56,  55,  46,  53,
+    49,  124, 51,  48,  52,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,
+    48,  48,  48,  48,  49,  53,  54,  51,  49,  124, 49,  53,  54,  51,  49,
+    124, 49,  56,  52,  53,  48,  53,  55,  124, 49,  57,  57,  52,  45,  48,
+    53,  45,  49,  50,  124, 52,  49,  57,  56,  55,  57,  46,  53,  57,  124,
+    51,  48,  50,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,
+    48,  49,  49,  50,  57,  56,  55,  124, 49,  49,  50,  57,  56,  55,  124,
+    52,  52,  51,  57,  54,  56,  54,  124, 49,  57,  57,  54,  45,  48,  57,
+    45,  49,  55,  124, 52,  49,  56,  49,  54,  49,  46,  52,  57,  124, 51,
+    48,  53,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  49,  50,  53,  57,  57,  124, 49,  50,  53,  57,  57,  124, 52,  50,
+    53,  57,  53,  50,  52,  124, 49,  57,  57,  56,  45,  48,  50,  45,  49,
+    50,  124, 52,  49,  53,  50,  48,  48,  46,  54,  49,  124, 51,  48,  52,
+    10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  48,
+    53,  52,  49,  48,  124, 49,  48,  53,  52,  49,  48,  124, 52,  52,  55,
+    56,  51,  55,  49,  124, 49,  57,  57,  54,  45,  48,  51,  45,  48,  53,
+    124, 52,  49,  50,  55,  53,  52,  46,  53,  49,  124, 51,  48,  50,  10,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  49,  52,  57,
+    56,  52,  50,  124, 49,  52,  57,  56,  52,  50,  124, 53,  49,  53,  54,
+    53,  56,  49,  124, 49,  57,  57,  52,  45,  48,  53,  45,  51,  48,  124,
+    52,  49,  49,  51,  50,  57,  46,  51,  53,  124, 51,  48,  50,  10,  67,
+    117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  49,  48,  49,
+    50,  57,  124, 49,  48,  49,  50,  57,  124, 53,  56,  52,  57,  52,  52,
+    52,  124, 49,  57,  57,  52,  45,  48,  51,  45,  50,  49,  124, 52,  48,
+    57,  49,  50,  57,  46,  56,  53,  124, 51,  48,  57,  10,  67,  117, 115,
+    116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  54,  57,  57,  48,  52,
+    124, 54,  57,  57,  48,  52,  124, 49,  55,  52,  50,  52,  48,  51,  124,
+    49,  57,  57,  54,  45,  49,  48,  45,  49,  57,  124, 52,  48,  56,  53,
+    49,  51,  46,  48,  48,  124, 51,  48,  53,  10,  67,  117, 115, 116, 111,
+    109, 101, 114, 35,  48,  48,  48,  48,  49,  55,  55,  52,  54,  124, 49,
+    55,  55,  52,  54,  124, 54,  56,  56,  50,  124, 49,  57,  57,  55,  45,
+    48,  52,  45,  48,  57,  124, 52,  48,  56,  52,  52,  54,  46,  57,  51,
+    124, 51,  48,  51,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,
+    48,  48,  48,  49,  51,  48,  55,  50,  124, 49,  51,  48,  55,  50,  124,
+    49,  52,  56,  49,  57,  50,  53,  124, 49,  57,  57,  56,  45,  48,  51,
+    45,  49,  53,  124, 51,  57,  57,  49,  57,  53,  46,  52,  55,  124, 51,
+    48,  49,  10,  67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,
+    48,  56,  50,  52,  52,  49,  124, 56,  50,  52,  52,  49,  124, 56,  53,
+    55,  57,  53,  57,  124, 49,  57,  57,  52,  45,  48,  50,  45,  48,  55,
+    124, 51,  56,  50,  53,  55,  57,  46,  55,  52,  124, 51,  48,  53,  10,
+    67,  117, 115, 116, 111, 109, 101, 114, 35,  48,  48,  48,  48,  56,  56,
+    55,  48,  51,  124, 56,  56,  55,  48,  51,  124, 50,  57,  57,  53,  48,
+    55,  54,  124, 49,  57,  57,  52,  45,  48,  49,  45,  51,  48,  124, 51,
+    54,  51,  56,  49,  50,  46,  49,  50,  124, 51,  48,  50,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q19[] = {114, 101, 118, 101, 110, 117, 101, 10,
+                                        51,  48,  56,  51,  56,  52,  51,  46,
+                                        48,  53,  55,  56,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q20[] = {
+    115, 95,  110, 97,  109, 101, 124, 115, 95,  97,  100, 100, 114, 101, 115,
+    115, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  48,  50,  48,  124, 74,  116, 80,  113, 109, 49,  57,  69,  55,
+    116, 70,  32,  49,  53,  50,  82,  108, 49,  119, 81,  90,  56,  106, 48,
+    72,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  48,  57,  49,  124, 51,  53,  87,  86,  110, 85,  55,  71,  76,
+    78,  98,  81,  68,  99,  99,  50,  84,  65,  82,  97,  118, 71,  116, 107,
+    54,  82,  66,  54,  90,  67,  100, 52,  54,  85,  65,  89,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  50,  48,
+    53,  124, 65,  108, 114, 120, 53,  84,  78,  44,  104, 100, 110, 71,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    50,  56,  53,  124, 113, 32,  84,  77,  90,  69,  68,  121, 90,  116, 118,
+    32,  118, 85,  105, 70,  75,  66,  104, 84,  51,  78,  74,  108, 110, 73,
+    120, 112, 76,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  50,  56,  55,  124, 85,  81,  82,  56,  98,  85,  65,
+    52,  86,  50,  72,  120, 86,  98,  119, 57,  75,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  51,  53,  52,  124,
+    119, 83,  76,  99,  67,  87,  52,  48,  81,  56,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  51,  55,  56,  124,
+    109, 76,  80,  74,  116, 112, 117, 52,  119, 79,  99,  32,  99,  83,  70,
+    122, 66,  82,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  52,  48,  50,  124, 74,  82,  56,  118, 87,  111, 67,
+    116, 101, 74,  116, 74,  103, 51,  111, 107, 82,  112, 116, 48,  114, 50,
+    56,  75,  69,  111, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  53,  51,  48,  124, 48,  66,  118, 111, 101, 119,
+    67,  80,  103, 50,  115, 99,  79,  69,  102, 117, 76,  57,  51,  70,  82,
+    75,  113, 83,  120, 72,  109, 100, 104, 119, 49,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  53,  53,  53,  124,
+    56,  76,  112, 48,  81,  87,  80,  76,  70,  88,  114, 74,  114, 88,  49,
+    115, 84,  87,  107, 65,  69,  100, 122, 85,  115, 104, 53,  107, 101, 10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    54,  52,  48,  124, 70,  119, 119, 121, 70,  98,  103, 122, 55,  99,  32,
+    104, 72,  86,  105, 75,  71,  84,  48,  79,  66,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  55,  50,  57,  124,
+    67,  65,  79,  71,  89,  67,  66,  116, 84,  86,  84,  55,  97,  66,  49,
+    112, 54,  113, 72,  98,  120, 70,  54,  86,  86,  104, 88,  97,  72,  76,
+    103, 84,  112, 73,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  55,  51,  54,  124, 71,  85,  73,  89,  68,  102,
+    118, 53,  120, 67,  120, 76,  103, 68,  120, 54,  75,  81,  56,  107, 104,
+    89,  32,  110, 116, 86,  86,  110, 70,  113, 109, 102, 77,  75,  73,  103,
+    84,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  48,  55,  54,  49,  124, 116, 70,  56,  102, 77,  71,  97,  54,  72,
+    89,  52,  32,  119, 55,  55,  109, 68,  119, 84,  52,  114, 79,  50,  49,
+    107, 120, 119, 101, 55,  117, 84,  83,  89,  78,  87,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  56,  56,  55,
+    124, 121, 32,  109, 81,  55,  78,  72,  106, 86,  98,  100, 113, 110, 98,
+    89,  114, 57,  32,  76,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  57,  51,  53,  124, 74,  72,  82,  83,  79,
+    116, 101, 114, 89,  103, 116, 52,  77,  84,  78,  111, 55,  99,  117, 112,
+    84,  122, 65,  44,  54,  77,  111, 78,  119, 32,  52,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  57,  55,  53,
+    124, 49,  113, 111, 114, 77,  49,  121, 112, 66,  100, 119, 103, 80,  86,
+    117, 102, 54,  115, 77,  67,  75,  117, 70,  57,  68,  49,  114, 74,  78,
+    49,  105, 67,  84,  88,  75,  109, 97,  108, 83,  116, 10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  50,  54,  51,
+    124, 65,  97,  52,  32,  85,  69,  76,  83,  49,  74,  113, 89,  55,  113,
+    73,  106, 110, 105, 119, 67,  87,  105, 67,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  51,  54,  55,  124, 88,
+    89,  50,  56,  71,  109, 79,  113, 51,  101, 102, 79,  120, 79,  122, 66,
+    77,  109, 77,  76,  100, 109, 87,  106, 77,  112, 111, 10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  52,  50,  54,
+    124, 81,  98,  99,  111, 79,  48,  84,  85,  67,  108, 70,  83,  122, 102,
+    121, 57,  48,  76,  107, 32,  107, 10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  49,  52,  52,  54,  124, 71,  79,  74,
+    82,  106, 102, 100, 54,  90,  57,  85,  81,  44,  102, 105, 117, 80,  122,
+    54,  67,  79,  53,  71,  68,  71,  86,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  49,  53,  48,  48,  124, 119, 110,
+    69,  108, 86,  118, 102, 117, 121, 97,  80,  74,  82,  79,  121, 54,  120,
+    48,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  49,  54,  48,  50,  124, 121, 103, 100, 52,  105, 78,  81,  76,  81,
+    101, 86,  87,  87,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  49,  54,  50,  54,  124, 55,  74,  117, 100, 57,  116,
+    54,  120, 90,  78,  122, 108, 69,  66,  44,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  54,  56,  50,  124, 67,
+    51,  55,  71,  107, 118, 32,  55,  97,  53,  117, 106, 90,  57,  32,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,
+    55,  48,  48,  124, 85,  74,  101, 70,  111, 68,  76,  90,  50,  86,  116,
+    102, 108, 75,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  49,  55,  50,  54,  124, 56,  77,  57,  50,  84,  56,  121,
+    55,  106, 89,  88,  122, 109, 118, 67,  65,  78,  84,  116, 113, 82,  56,
+    71,  72,  117, 84,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  49,  55,  51,  48,  124, 97,  79,  83,  77,  48,  44,
+    98,  116, 80,  68,  115, 32,  85,  115, 67,  48,  54,  104, 105, 109, 74,
+    110, 44,  54,  110, 115, 119, 74,  71,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  49,  55,  52,  54,  124, 66,  52,
+    122, 77,  68,  79,  70,  99,  77,  71,  98,  107, 90,  81,  52,  88,  120,
+    65,  44,  85,  121, 97,  81,  111, 69,  87,  90,  122, 77,  83,  71,  73,
+    32,  119, 84,  115, 74,  112, 57,  78,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  49,  56,  48,  54,  124, 102, 82,
+    88,  87,  76,  121, 49,  56,  68,  102, 53,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  56,  53,  53,  124, 102,
+    52,  71,  85,  109, 114, 77,  67,  115, 51,  81,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  57,  51,  49,  124,
+    109, 66,  104, 80,  101, 55,  89,  74,  85,  49,  97,  89,  77,  112, 119,
+    84,  105, 82,  100, 105, 118, 108, 10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  50,  48,  50,  50,  124, 115, 78,  118,
+    77,  80,  108, 51,  84,  105, 78,  90,  66,  79,  89,  86,  51,  119, 50,
+    88,  88,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  50,  48,  51,  54,  124, 90,  44,  116, 121, 55,  122, 53,  99,
+    80,  72,  104, 54,  54,  105, 89,  53,  111, 112, 44,  113, 10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  48,  57,
+    54,  124, 72,  120, 117, 122, 77,  117, 102, 121, 65,  114, 98,  98,  102,
+    51,  117, 70,  82,  49,  54,  32,  69,  112, 85,  103, 71,  75,  82,  89,
+    104, 121, 104, 86,  79,  97,  115, 116, 51,  100, 54,  114, 10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  49,  49,
+    55,  124, 102, 57,  121, 71,  75,  104, 67,  70,  106, 104, 83,  52,  74,
+    114, 51,  83,  104, 48,  120, 32,  114, 100, 106, 103, 110, 116, 119, 72,
+    32,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  50,  50,  48,  52,  124, 121, 50,  69,  70,  32,  88,  85,  111, 44,
+    85,  121, 78,  111, 65,  81,  69,  72,  44,  103, 73,  97,  122, 67,  55,
+    97,  82,  71,  49,  122, 109, 117, 122, 122, 102, 10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  50,  49,  56,  124,
+    69,  99,  110, 49,  118, 87,  65,  87,  78,  117, 115, 71,  66,  44,  103,
+    87,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  50,  50,  52,  51,  124, 69,  56,  99,  109, 53,  89,  104, 77,  99,
+    54,  85,  82,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  50,  50,  52,  53,  124, 75,  115, 89,  65,  52,  52,  52,
+    53,  72,  99,  117, 103, 74,  65,  98,  51,  101, 67,  109, 118, 116, 85,
+    115, 108, 71,  65,  55,  81,  110, 101, 10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  50,  50,  56,  50,  124, 110, 56,
+    89,  90,  103, 83,  78,  117, 67,  52,  44,  105, 90,  55,  115, 53,  111,
+    72,  84,  77,  72,  78,  70,  100, 118, 57,  52,  68,  119, 90,  50,  114,
+    114, 85,  69,  98,  48,  112, 103, 68,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  50,  51,  48,  51,  124, 69,  111,
+    67,  52,  76,  67,  112, 85,  50,  99,  117, 69,  80,  75,  99,  75,  121,
+    84,  70,  121, 77,  71,  70,  66,  71,  107, 70,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  51,  51,  49,  124,
+    53,  57,  74,  89,  118, 87,  52,  108, 119, 57,  76,  84,  49,  44,  56,
+    44,  113, 119, 56,  119, 107, 111, 102, 10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  50,  51,  55,  51,  124, 97,  115,
+    106, 56,  117, 100, 55,  97,  69,  109, 71,  111, 72,  117, 105, 113, 73,
+    53,  113, 86,  90,  49,  114, 104, 112, 87,  83,  32,  104, 74,  99,  57,
+    116, 70,  57,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  50,  52,  49,  57,  124, 66,  116, 78,  112, 97,  79,  90,
+    87,  105, 86,  71,  86,  69,  53,  51,  82,  87,  76,  50,  50,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  53,
+    55,  49,  124, 105, 49,  54,  120, 75,  116, 44,  87,  79,  114, 74,  104,
+    108, 102, 32,  71,  107, 122, 115, 82,  100, 114, 100, 48,  52,  115, 90,
+    32,  53,  106, 101, 105, 57,  77,  116, 66,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  53,  56,  53,  124, 112,
+    122, 98,  67,  103, 67,  118, 89,  97,  120, 56,  50,  87,  113, 53,  44,
+    100, 71,  52,  120, 122, 121, 68,  77,  105, 82,  87,  56,  100, 10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  54,
+    50,  57,  124, 48,  113, 118, 48,  65,  87,  49,  66,  83,  122, 121, 82,
+    51,  32,  115, 68,  111, 68,  75,  49,  89,  79,  113, 109, 51,  50,  118,
+    49,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  50,  55,  50,  49,  124, 107, 53,  78,  108, 113, 101, 89,  104, 106,
+    101, 98,  56,  66,  103, 69,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  50,  55,  51,  48,  124, 71,  105, 108, 117,
+    57,  88,  76,  115, 69,  88,  44,  111, 85,  48,  69,  121, 115, 104, 118,
+    70,  84,  87,  115, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  50,  55,  55,  53,  124, 117, 110, 79,  70,  81,  111,
+    81,  112, 110, 87,  74,  74,  106, 10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  50,  55,  57,  57,  124, 71,  118, 32,
+    48,  114, 86,  102, 88,  75,  78,  77,  79,  84,  82,  98,  98,  120, 121,
+    48,  87,  52,  99,  85,  68,  97,  32,  55,  104, 50,  85,  89,  79,  113,
+    116, 50,  100, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  50,  57,  51,  52,  124, 70,  48,  121, 32,  112, 110, 100,
+    116, 118, 56,  114, 32,  118, 75,  88,  111, 74,  112, 10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  57,  52,  49,
+    124, 101, 81,  78,  78,  80,  82,  114, 83,  50,  55,  110, 103, 77,  71,
+    49,  117, 98,  44,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  51,  48,  50,  56,  124, 73,  67,  120, 115, 75,  52,
+    44,  52,  49,  72,  75,  100, 101, 52,  102, 82,  106, 87,  76,  116, 10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,
+    48,  57,  53,  124, 107, 117, 99,  100, 88,  73,  104, 74,  54,  73,  89,
+    115, 72,  121, 48,  65,  114, 69,  55,  110, 10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  49,  52,  51,  124, 75,
+    78,  67,  70,  75,  75,  85,  44,  83,  120, 56,  71,  106, 74,  84,  122,
+    85,  65,  76,  56,  66,  71,  73,  76,  103, 82,  73,  108, 72,  68,  112,
+    106, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  51,  49,  56,  53,  124, 75,  101, 81,  86,  88,  87,  111, 80,  76,
+    89,  70,  72,  90,  100, 118, 88,  99,  52,  99,  103, 53,  53,  32,  122,
+    103, 48,  54,  78,  110, 71,  105, 54,  57,  32,  78,  73,  56,  105, 104,
+    77,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  51,  49,  56,  57,  124, 111, 52,  78,  98,  117, 122, 84,  114, 57,
+    68,  72,  49,  119, 85,  53,  100, 112, 116, 57,  44,  78,  69,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  50,
+    48,  49,  124, 110, 83,  84,  116, 118, 32,  85,  105, 48,  121, 48,  66,
+    100, 122, 87,  98,  52,  84,  54,  115, 110, 117, 103, 73,  104, 69,  104,
+    110, 49,  52,  121, 77,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  51,  50,  49,  51,  124, 67,  117, 32,  57,  98,
+    88,  73,  32,  97,  90,  54,  67,  116, 76,  97,  49,  78,  55,  76,  88,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    51,  50,  55,  53,  124, 83,  117, 99,  87,  68,  117, 104, 89,  97,  104,
+    80,  51,  85,  119, 107, 77,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  51,  50,  56,  56,  124, 110, 110, 78,  76,
+    100, 122, 84,  109, 86,  54,  80,  48,  117, 102, 55,  121, 66,  67,  105,
+    75,  51,  102, 87,  116, 50,  85,  120, 72,  74,  48,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  51,  49,  52,
+    124, 73,  68,  73,  122, 54,  84,  101, 115, 65,  99,  88,  73,  54,  112,
+    88,  116, 122, 98,  79,  32,  117, 122, 101, 118, 88,  111, 110, 54,  67,
+    72,  57,  87,  65,  84,  102, 111, 10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  51,  51,  55,  51,  124, 74,  116, 83,
+    53,  101, 88,  83,  116, 68,  66,  80,  88,  100, 89,  99,  32,  112, 118,
+    113, 119, 75,  50,  81,  71,  99,  90,  120, 122, 82,  57,  44,  80,  73,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    51,  52,  50,  49,  124, 57,  74,  88,  78,  121, 83,  52,  86,  67,  77,
+    68,  76,  108, 52,  67,  120, 68,  108, 74,  32,  76,  48,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  52,  50,
+    50,  124, 111, 104, 67,  111, 109, 82,  66,  54,  77,  112, 52,  67,  53,
+    90,  73,  51,  73,  111, 79,  98,  109, 97,  119, 115, 122, 56,  119, 89,
+    49,  105, 83,  85,  44,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  51,  52,  52,  49,  124, 116, 119, 108, 104, 105,
+    116, 56,  48,  67,  54,  121, 56,  74,  106, 72,  67,  79,  51,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  53,
+    57,  48,  124, 32,  116, 84,  82,  111, 102, 102, 117, 65,  80,  49,  111,
+    80,  67,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  51,  54,  48,  55,  124, 71,  100, 65,  108, 106, 98,  50,  72,
+    118, 56,  114, 71,  76,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  51,  54,  50,  53,  124, 66,  50,  86,  83,  83,
+    53,  44,  50,  71,  86,  74,  81,  54,  116, 90,  97,  51,  55,  75,  100,
+    65,  109, 103, 32,  101, 114, 72,  112, 50,  106, 80,  103, 122, 10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  55,
+    50,  51,  124, 73,  49,  109, 66,  44,  100, 109, 116, 121, 74,  112, 102,
+    79,  56,  114, 100, 69,  104, 56,  32,  109, 121, 117, 104, 85,  86,  80,
+    101, 70,  115, 57,  66,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  51,  56,  52,  57,  124, 104, 75,  80,  49,  109,
+    82,  57,  71,  48,  85,  98,  88,  69,  52,  119, 119, 74,  85,  120, 66,
+    122, 32,  122, 90,  103, 97,  54,  106, 75,  114, 48,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  56,  57,  52,
+    124, 120, 119, 107, 111, 114, 65,  81,  69,  77,  102, 100, 71,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  57,
+    52,  49,  124, 99,  69,  80,  44,  86,  70,  97,  76,  112, 101, 57,  85,
+    90,  83,  99,  85,  52,  103, 65,  49,  105, 114, 82,  119, 116, 120, 10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  52,
+    48,  53,  57,  124, 121, 69,  109, 50,  49,  57,  65,  82,  57,  104, 90,
+    52,  109, 115, 78,  32,  119, 82,  69,  77,  55,  83,  32,  69,  65,  119,
+    115, 53,  102, 57,  76,  73,  49,  118, 111, 10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  52,  50,  48,  55,  124, 122,
+    108, 85,  87,  66,  119, 73,  99,  101, 87,  106, 71,  52,  72,  100, 89,
+    69,  56,  48,  77,  48,  86,  52,  120, 113, 73,  102, 117, 10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  52,  50,  51,
+    54,  124, 79,  70,  48,  106, 98,  122, 104, 69,  107, 73,  67,  117, 50,
+    122, 56,  66,  68,  82,  118, 69,  66,  71,  120, 52,  72,  32,  121, 48,
+    69,  111, 78,  104, 83,  99,  85,  56,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  52,  50,  55,  56,  124, 81,  112,
+    78,  78,  80,  67,  112, 117, 105, 53,  67,  114, 110, 73,  82,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  52,  50,
+    56,  49,  124, 44,  99,  118, 98,  106, 75,  114, 98,  75,  73,  117, 77,
+    120, 122, 48,  74,  49,  56,  86,  77,  114, 89,  88,  104, 110, 100, 73,
+    66,  118, 71,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  52,  51,  48,  52,  124, 75,  97,  111, 113, 115, 87,  82,
+    71,  48,  106, 103, 70,  66,  89,  111, 104, 54,  32,  79,  112, 106, 102,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    52,  51,  52,  54,  124, 57,  88,  44,  84,  85,  103, 109, 99,  118, 67,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    52,  52,  48,  54,  124, 114, 74,  44,  49,  81,  103, 120, 85,  53,  118,
+    121, 76,  98,  52,  54,  116, 48,  84,  71,  80,  52,  75,  50,  49,  74,
+    82,  120, 109, 81,  106, 66,  107, 105, 75,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  52,  52,  51,  48,  124, 117,
+    119, 56,  122, 103, 101, 56,  55,  102, 86,  107, 102, 51,  112, 109, 56,
+    87,  70,  120, 99,  32,  98,  100, 102, 117, 104, 115, 113, 101, 71,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  52,
+    53,  50,  55,  124, 67,  114, 66,  53,  51,  112, 68,  117, 75,  79,  72,
+    70,  52,  108, 85,  114, 90,  67,  88,  99,  107, 50,  88,  65,  52,  86,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    52,  54,  53,  53,  124, 86,  84,  100, 65,  112, 80,  87,  114, 121, 88,
+    99,  107, 88,  108, 83,  82,  99,  114, 105, 122, 66,  52,  100, 65,  87,
+    72,  107, 81,  98,  67,  119, 50,  102, 10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  52,  56,  53,  49,  124, 97,  72,
+    48,  117, 85,  106, 75,  102, 55,  84,  72,  112, 102, 82,  82,  69,  65,
+    66,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  52,  56,  55,  49,  124, 49,  66,  74,  66,  121, 86,  113, 52,  109,
+    68,  55,  56,  83,  121, 87,  114, 119, 80,  86,  44,  65,  108, 76,  78,
+    75,  85,  99,  82,  79,  85,  69,  54,  83,  117, 117, 120, 83,  77,  111,
+    86,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  52,  56,  56,  52,  124, 88,  89,  49,  90,  120, 103, 116, 77,  82,
+    68,  32,  68,  85,  81,  55,  108, 112, 100, 78,  114, 79,  105, 83,  114,
+    117, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  52,  57,  55,  53,  124, 108, 98,  65,  86,  98,  102, 103, 50,  85,
+    52,  117, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  53,  48,  55,  54,  124, 52,  70,  84,  74,  82,  74,  76,  75,
+    119, 105, 107, 69,  65,  117, 108, 103, 75,  52,  76,  106, 104, 87,  107,
+    72,  81,  120, 114, 112, 71,  98,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  53,  49,  57,  53,  124, 53,  67,  73,
+    88,  80,  90,  49,  81,  73,  79,  99,  74,  114, 49,  56,  77,  120, 90,
+    109, 76,  52,  74,  109, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  53,  50,  53,  54,  124, 100, 68,  79,  88,  121,
+    87,  84,  53,  113, 101, 80,  74,  69,  48,  66,  70,  67,  53,  102, 81,
+    55,  83,  80,  99,  100, 69,  73,  82,  100, 122, 121, 81,  101, 114, 98,
+    116, 101, 101, 108, 115, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  53,  50,  53,  55,  124, 77,  82,  75,  83,  56,
+    110, 106, 112, 84,  67,  81,  101, 72,  88,  97,  52,  113, 72,  51,  56,
+    90,  119, 76,  50,  50,  90,  89,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  53,  51,  48,  48,  124, 76,  51,  107,
+    89,  83,  51,  65,  66,  117, 54,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  53,  51,  50,  51,  124, 122, 101, 111,
+    71,  78,  66,  80,  110, 67,  116, 101, 67,  83,  119, 101, 106, 71,  115,
+    72,  112, 66,  50,  77,  117, 67,  97,  113, 120, 119, 48,  56,  85,  114,
+    65,  115, 80,  120, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  53,  51,  56,  54,  124, 55,  80,  85,  113, 113, 77,
+    106, 66,  52,  102, 53,  98,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  53,  52,  50,  54,  124, 83,  110, 115, 89,
+    99,  54,  55,  90,  65,  114, 32,  80,  87,  112, 103, 85,  90,  70,  72,
+    97,  44,  51,  72,  98,  112, 51,  57,  98,  119, 99,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  52,  54,  53,
+    124, 86,  88,  79,  50,  49,  78,  68,  49,  112, 57,  50,  85,  90,  88,
+    97,  44,  108, 81,  67,  107, 48,  49,  122, 69,  68,  112, 86,  115, 70,
+    82,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  53,  52,  56,  52,  124, 32,  81,  108, 78,  99,  97,  114, 65,  52,
+    84,  114, 108, 50,  48,  88,  82,  122, 98,  65,  73,  74,  113, 81,  90,
+    90,  102, 67,  89,  89,  66,  112, 67,  100, 44,  112, 122, 98,  32,  103,
+    67,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  53,  53,  48,  53,  124, 79,  89,  122, 80,  72,  108, 87,  88,  103,
+    118, 102, 98,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  53,  53,  48,  54,  124, 100, 68,  114, 76,  86,  117,
+    66,  115, 67,  52,  76,  112, 10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  53,  54,  51,  49,  124, 44,  87,  55,  53,
+    32,  73,  70,  115, 67,  89,  57,  104, 109, 112, 50,  112, 110, 75,  66,
+    101, 119, 55,  70,  119, 118, 57,  65,  111, 10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  54,  52,  50,  124, 50,
+    118, 103, 117, 113, 120, 88,  53,  87,  44,  122, 52,  114, 109, 83,  99,
+    84,  97,  118, 120, 49,  115, 70,  120, 48,  72,  98,  122, 102, 10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  54,
+    56,  54,  124, 77,  89,  57,  112, 103, 78,  79,  89,  55,  90,  101, 105,
+    73,  84,  116, 57,  114, 101, 10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  53,  55,  51,  48,  124, 87,  32,  71,  80,
+    44,  99,  56,  77,  118, 122, 115, 106, 119, 117, 71,  103, 83,  104, 81,
+    110, 88,  90,  54,  66,  68,  57,  108, 89,  79,  75,  84,  106, 90,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,
+    55,  51,  54,  124, 90,  78,  65,  114, 51,  56,  50,  74,  121, 50,  53,
+    56,  76,  66,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  53,  55,  51,  55,  124, 79,  69,  109, 52,  79,  57,  88,
+    89,  111, 88,  72,  117, 48,  78,  48,  113, 82,  86,  114, 99,  70,  50,
+    68,  87,  83,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  53,  55,  57,  55,  124, 49,  67,  48,  99,  77,  81,  118,
+    57,  80,  56,  111, 69,  53,  70,  82,  76,  100, 82,  76,  66,  53,  98,
+    111, 73,  65,  113, 114, 54,  67,  75,  120, 70,  56,  57,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  56,  55,
+    53,  124, 71,  103, 48,  122, 50,  74,  107, 115, 112, 82,  88,  74,  56,
+    116, 106, 117, 82,  117, 119, 56,  50,  108, 80,  53,  97,  101, 111, 49,
+    77,  89,  103, 51,  49,  120, 107, 81,  56,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  57,  55,  52,  124, 97,
+    109, 74,  57,  86,  73,  109, 48,  70,  102, 121, 122, 97,  51,  119, 77,
+    86,  87,  56,  118, 51,  116, 56,  75,  122, 57,  56,  53,  108, 74,  121,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    54,  48,  53,  57,  124, 88,  69,  44,  79,  119, 84,  101, 118, 104, 82,
+    117, 51,  89,  119, 70,  119, 105, 114, 49,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  54,  48,  54,  53,  124, 55,
+    73,  105, 89,  111, 117, 88,  52,  87,  55,  121, 86,  122, 102, 71,  115,
+    102, 120, 119, 51,  103, 57,  116, 85,  103, 74,  74,  70,  107, 119, 10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,
+    48,  57,  51,  124, 104, 104, 100, 54,  75,  44,  67,  78,  54,  55,  90,
+    118, 121, 111, 56,  90,  122, 85,  98,  32,  107, 88,  110, 85,  76,  79,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    54,  48,  57,  57,  124, 82,  49,  73,  70,  118, 98,  103, 50,  110, 55,
+    54,  98,  67,  103, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  54,  49,  48,  57,  124, 65,  50,  86,  75,  80,  77,
+    74,  88,  78,  103, 107, 68,  116, 70,  79,  98,  54,  55,  98,  107, 112,
+    118, 68,  80,  77,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  54,  50,  49,  55,  124, 97,  53,  100, 89,  88,  57,
+    50,  55,  82,  72,  78,  68,  54,  77,  81,  53,  107, 51,  54,  78,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,
+    50,  57,  55,  124, 85,  88,  53,  57,  110, 100, 99,  86,  85,  107, 55,
+    111, 116, 119, 79,  88,  44,  67,  50,  104, 10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  54,  52,  51,  53,  124, 118,
+    105, 75,  109, 85,  83,  51,  122, 115, 50,  81,  68,  99,  87,  109, 68,
+    68,  84,  79,  106, 107, 99,  83,  116, 10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  54,  52,  54,  51,  124, 85,  114,
+    118, 71,  78,  73,  89,  109, 99,  87,  83,  73,  67,  121, 70,  78,  116,
+    89,  71,  69,  106, 101, 114, 113, 110, 67,  102, 56,  122, 115, 108, 53,
+    88,  57,  100, 53,  72,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  54,  52,  55,  56,  124, 81,  97,  50,  98,  68,
+    73,  82,  70,  66,  69,  53,  88,  54,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  54,  53,  50,  49,  124, 81,  82,
+    114, 89,  115, 73,  106, 115, 117, 57,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  54,  54,  52,  50,  124, 101, 48,
+    111, 54,  79,  71,  56,  65,  57,  102, 105, 79,  56,  83,  115, 98,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,
+    54,  53,  57,  124, 74,  55,  102, 122, 68,  120, 110, 83,  110, 89,  108,
+    115, 52,  100, 54,  120, 114, 71,  57,  105, 69,  118, 57,  72,  71,  87,
+    32,  110, 77,  109, 70,  76,  120, 66,  90,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  54,  54,  54,  57,  124, 101,
+    97,  87,  50,  32,  117, 72,  85,  89,  87,  67,  84,  103, 86,  88,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,
+    55,  52,  56,  124, 65,  111, 48,  89,  32,  110, 68,  83,  75,  103, 111,
+    105, 56,  86,  97,  48,  79,  104, 109, 67,  74,  108, 10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,  55,  54,  49,
+    124, 69,  87,  72,  74,  117, 108, 101, 65,  112, 86,  67,  32,  110, 90,
+    106, 75,  66,  102, 119, 118, 65,  52,  56,  121, 99,  103, 70,  70,  81,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    54,  56,  48,  56,  124, 107, 107, 78,  89,  51,  68,  114, 82,  68,  109,
+    80,  106, 104, 74,  49,  120, 51,  72,  51,  117, 53,  103, 105, 66,  113,
+    67,  55,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  54,  56,  53,  56,  124, 77,  68,  70,  105, 100, 56,  83,  83,
+    86,  119, 113, 112, 74,  122, 52,  119, 55,  107, 73,  49,  48,  68,  89,
+    89,  121, 75,  118, 107, 50,  90,  86,  74,  114, 107, 106, 105, 72,  89,
+    90,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  54,  57,  52,  54,  124, 56,  67,  85,  56,  70,  68,  44,  107, 104,
+    55,  66,  79,  105, 119, 110, 10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  54,  57,  52,  57,  124, 70,  102, 117, 50,
+    54,  105, 74,  122, 107, 79,  103, 121, 103, 77,  114, 49,  107, 108, 73,
+    32,  101, 120, 90,  83,  88,  114, 119, 55,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  48,  55,  50,  124, 90,
+    121, 57,  116, 51,  83,  101, 90,  81,  114, 88,  57,  79,  69,  86,  85,
+    122, 84,  84,  82,  109, 90,  113, 100, 107, 83,  72,  70,  66,  103, 10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,
+    48,  57,  56,  124, 108, 88,  72,  83,  75,  48,  104, 111, 87,  99,  80,
+    80,  113, 120, 89,  100, 53,  67,  98,  106, 65,  51,  97,  52,  101, 112,
+    54,  78,  72,  65,  84,  118, 75,  111, 106, 100, 109, 117, 120, 10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  49,
+    51,  50,  124, 118, 67,  68,  119, 68,  48,  104, 113, 97,  105, 103, 88,
+    66,  83,  71,  51,  71,  114, 106, 111, 44,  108, 56,  56,  110, 57,  54,
+    56,  55,  111, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  55,  49,  51,  53,  124, 71,  122, 114, 110, 67,  104, 53,
+    84,  53,  86,  121, 70,  76,  97,  116, 83,  53,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  49,  52,  55,  124,
+    52,  115, 80,  90,  85,  72,  111, 85,  88,  118, 70,  102, 53,  50,  77,
+    118, 54,  109, 75,  112, 48,  75,  51,  108, 119, 107, 71,  72,  55,  86,
+    74,  98,  66,  65,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  55,  49,  54,  48,  124, 56,  65,  110, 107, 112, 55,
+    102, 112, 88,  79,  56,  65,  105, 55,  85,  109, 103, 110, 119, 69,  83,
+    112, 56,  87,  77,  88,  119, 48,  115, 118, 51,  73,  97,  98,  80,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,
+    49,  54,  57,  124, 122, 109, 79,  82,  86,  111, 89,  69,  67,  100, 83,
+    56,  83,  87,  68,  79,  86,  86,  99,  48,  79,  70,  68,  52,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  50,
+    55,  56,  124, 106, 89,  81,  77,  88,  65,  56,  84,  103, 53,  109, 83,
+    107, 53,  106, 122, 112, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  55,  51,  54,  53,  124, 87,  90,  117, 74,  57,
+    100, 102, 119, 97,  101, 105, 44,  86,  110, 68,  79,  121, 49,  52,  121,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    55,  51,  57,  56,  124, 54,  83,  77,  109, 85,  68,  49,  44,  44,  99,
+    109, 100, 54,  48,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  55,  52,  48,  50,  124, 88,  54,  53,  119, 86,  84,
+    77,  32,  116, 90,  65,  72,  69,  65,  56,  97,  86,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  52,  52,  56,
+    124, 117, 74,  74,  66,  52,  74,  104, 73,  84,  109, 105, 85,  97,  86,
+    53,  112, 81,  97,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  55,  52,  53,  56,  124, 113, 50,  120, 120, 79,  82,
+    66,  50,  71,  66,  122, 49,  70,  85,  76,  69,  78,  89,  97,  81,  111,
+    116, 49,  69,  105, 83,  75,  57,  90,  105, 75,  90,  85,  77,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  52,
+    55,  55,  124, 83,  69,  82,  72,  44,  119, 76,  74,  52,  115, 112, 119,
+    53,  106, 117, 72,  54,  48,  98,  66,  114, 117, 118, 56,  106, 48,  75,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    55,  53,  48,  57,  124, 66,  83,  48,  53,  85,  103, 104, 57,  67,  106,
+    105, 72,  106, 79,  99,  121, 56,  107, 84,  81,  103, 55,  101, 75,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,
+    53,  54,  49,  124, 65,  101, 79,  108, 75,  90,  86,  88,  44,  53,  112,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    55,  54,  49,  54,  124, 97,  114, 105, 67,  119, 106, 65,  115, 110, 73,
+    89,  48,  97,  106, 68,  82,  65,  49,  71,  90,  118, 56,  87,  74,  107,
+    114, 75,  77,  70,  74,  99,  87,  116, 72,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  55,  54,  48,  124, 105,
+    122, 98,  109, 90,  84,  98,  119, 79,  78,  109, 55,  103, 10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  56,  48,
+    49,  124, 86,  82,  76,  73,  48,  55,  90,  32,  85,  77,  69,  54,  80,
+    114, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  55,  56,  54,  53,  124, 87,  79,  110, 107, 111, 57,  48,  55,  85,
+    100, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  55,  56,  56,  53,  124, 121, 88,  122, 73,  79,  80,  74,  74,  86,
+    49,  67,  116, 55,  54,  66,  101, 90,  79,  104, 103, 101, 79,  113, 67,
+    81,  81,  105, 52,  75,  50,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  55,  57,  50,  54,  124, 110, 32,  115, 111,
+    108, 84,  44,  103, 82,  54,  117, 10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  55,  57,  57,  56,  124, 103, 68,  113,
+    56,  108, 113, 76,  50,  57,  108, 100, 67,  82,  78,  85,  79,  48,  81,
+    122, 112, 120, 53,  65,  82,  102, 68,  89,  98,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  48,  57,  48,  124,
+    78,  67,  68,  80,  104, 50,  119, 67,  110, 108, 51,  112, 100, 54,  73,
+    69,  50,  76,  66,  85,  117, 109, 57,  105, 75,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  50,  50,  52,  124,
+    56,  52,  117, 121, 82,  77,  48,  102, 53,  109, 97,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  50,  51,  49,
+    124, 106, 103, 84,  77,  107, 119, 114, 50,  72,  82,  48,  32,  55,  78,
+    66,  32,  98,  48,  119, 79,  66,  52,  117, 102, 112, 10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  50,  52,  51,
+    124, 90,  113, 116, 77,  98,  102, 71,  110, 65,  69,  116, 53,  115, 72,
+    107, 56,  73,  115, 51,  121, 75,  108, 102, 67,  83,  75,  114, 109, 73,
+    120, 79,  111, 101, 117, 99,  70,  105, 105, 107, 10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  51,  50,  51,  124,
+    85,  86,  105, 90,  83,  32,  49,  69,  113, 56,  119, 69,  114, 98,  99,
+    78,  74,  77,  57,  101, 79,  72,  82,  121, 69,  67,  116, 77,  97,  48,
+    113, 76,  111, 51,  100, 87,  112, 105, 113, 80,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  51,  54,  54,  124,
+    75,  84,  84,  83,  79,  110, 72,  90,  87,  112, 121, 52,  82,  99,  109,
+    104, 70,  119, 98,  55,  53,  65,  87,  73,  118, 114, 56,  57,  85,  109,
+    113, 112, 51,  100, 84,  116, 77,  56,  83,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  53,  51,  50,  124, 55,
+    79,  89,  82,  65,  88,  48,  86,  117, 53,  79,  110, 99,  108, 83,  85,
+    54,  49,  32,  117, 75,  32,  87,  117, 52,  57,  44,  73,  74,  109, 55,
+    51,  120, 74,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  56,  53,  57,  53,  124, 102, 106, 44,  73,  112, 85,  88,
+    107, 97,  88,  116, 114, 54,  52,  88,  100, 114, 110, 80,  111, 81,  65,
+    69,  79,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  56,  54,  49,  48,  124, 57,  75,  53,  75,  98,  83,  44,  119,
+    98,  87,  87,  89,  122, 54,  100, 56,  75,  115, 102, 82,  116, 103, 118,
+    51,  106, 52,  113, 115, 53,  85,  122, 53,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  54,  56,  51,  124, 76,
+    102, 120, 107, 79,  121, 75,  76,  66,  104, 57,  77,  107, 97,  113, 97,
+    68,  81,  106, 100, 112, 81,  52,  68,  107, 82,  65,  122, 100, 68,  73,
+    116, 70,  89,  44,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  56,  55,  48,  53,  124, 82,  109, 48,  121, 32,  97,
+    100, 78,  98,  117, 49,  87,  116, 73,  68,  56,  110, 82,  99,  88,  111,
+    77,  80,  110, 105, 67,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  56,  55,  52,  50,  124, 107, 69,  98,  70,  97,
+    110, 115, 103, 111, 98,  110, 79,  55,  54,  102, 44,  87,  48,  71,  103,
+    66,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  56,  56,  52,  49,  124, 106, 114, 83,  86,  102, 121, 90,  122, 77,
+    71,  81,  75,  89,  117, 32,  57,  105, 115, 69,  44,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  56,  55,  50,
+    124, 84,  110, 114, 87,  86,  108, 75,  117, 104, 99,  90,  99,  118, 118,
+    50,  99,  82,  56,  87,  113, 82,  51,  104, 103, 119, 111, 118, 98,  76,
+    102, 102, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  56,  56,  55,  57,  124, 65,  110, 56,  113, 48,  111, 82,  67,
+    98,  101, 49,  85,  86,  100, 101, 53,  109, 108, 32,  69,  108, 103, 113,
+    120, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  56,  57,  54,  55,  124, 90,  71,  118, 109, 106, 117, 101, 107, 114,
+    84,  109, 118, 67,  115, 100, 106, 69,  113, 54,  109, 86,  69,  106, 44,
+    74,  51,  121, 65,  50,  79,  121, 70,  104, 101, 10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  57,  55,  50,  124,
+    119, 89,  119, 108, 85,  115, 110, 86,  50,  49,  100, 88,  119, 73,  122,
+    99,  51,  122, 65,  53,  77,  102, 113, 110, 55,  104, 10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  48,  51,  50,
+    124, 66,  103, 48,  121, 32,  113, 85,  56,  78,  116, 88,  110, 115, 90,
+    112, 97,  54,  108, 100, 116, 10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  57,  48,  52,  51,  124, 87,  84,  99,  98,
+    119, 104, 106, 87,  65,  116, 52,  105, 49,  84,  105, 116, 50,  77,  111,
+    81,  119, 90,  90,  81,  86,  101, 90,  103, 73,  82,  77,  90,  52,  52,
+    69,  54,  97,  48,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  57,  50,  55,  56,  124, 97,  65,  50,  55,  115, 76,
+    117, 72,  82,  88,  112, 102, 51,  114, 44,  70,  79,  50,  76,  111, 110,
+    100, 99,  77,  76,  111, 10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  57,  51,  50,  54,  124, 52,  69,  73,  111, 48,
+    121, 116, 88,  85,  112, 83,  48,  76,  80,  44,  116, 74,  79,  72,  81,
+    82,  75,  73,  51,  97,  121, 121, 75,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  57,  52,  51,  48,  124, 74,  75,
+    57,  65,  69,  69,  77,  108, 121, 114, 10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  57,  53,  52,  57,  124, 75,  88,
+    57,  53,  79,  75,  54,  76,  83,  101, 116, 50,  87,  85,  105, 116, 80,
+    49,  44,  68,  76,  44,  82,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  57,  54,  48,  49,  124, 87,  90,  69,  85,
+    88,  85,  80,  99,  48,  57,  119, 86,  110, 68,  106, 53,  108, 54,  119,
+    102, 82,  79,  57,  117, 82,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  57,  55,  48,  57,  124, 65,  57,  68,  111,
+    80,  107, 50,  75,  110, 75,  71,  82,  98,  49,  50,  69,  116, 52,  103,
+    53,  51,  56,  54,  52,  44,  120, 103, 75,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  55,  53,  51,  124, 119,
+    102, 74,  53,  109, 80,  57,  69,  78,  84,  99,  71,  104, 108, 87,  109,
+    112, 68,  107, 103, 85,  49,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  57,  55,  57,  57,  124, 115, 87,  118, 100,
+    72,  52,  107, 81,  87,  99,  104, 52,  70,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  56,  49,  49,  124, 110,
+    88,  73,  120, 116, 66,  84,  54,  68,  49,  118, 54,  84,  67,  98,  50,
+    105, 77,  89,  107, 121, 85,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  57,  56,  49,  50,  124, 114, 98,  108, 57,
+    101, 117, 88,  70,  111, 80,  76,  108, 75,  81,  86,  89,  68,  86,  121,
+    82,  111, 117, 115, 108, 98,  98,  98,  75,  68,  72,  65,  107, 121, 88,
+    89,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  57,  56,  52,  54,  124, 87,  84,  122, 100, 118, 105, 104, 88,  98,
+    121, 113, 110, 120, 48,  74,  102, 98,  98,  86,  97,  120, 66,  79,  99,
+    79,  57,  100, 57,  51,  68,  89,  98,  116, 66,  104, 105, 32,  74,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  57,
+    56,  57,  57,  124, 85,  51,  78,  66,  113, 107, 32,  115, 32,  90,  122,
+    48,  54,  97,  108, 50,  109, 10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  57,  57,  55,  52,  124, 85,  118, 104, 48,
+    104, 87,  110, 103, 79,  117, 57,  54,  87,  103, 66,  44,  79,  97,  102,
+    66,  81,  79,  113, 119, 112, 87,  113, 122, 119, 103, 56,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q21[] = {
+    115, 95,  110, 97,  109, 101, 124, 110, 117, 109, 119, 97,  105, 116, 10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,
+    56,  50,  57,  124, 50,  48,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  53,  56,  48,  56,  124, 49,  56,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  50,
+    54,  50,  124, 49,  55,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  52,  57,  54,  124, 49,  55,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  49,  54,
+    48,  124, 49,  55,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  50,  51,  48,  49,  124, 49,  55,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  53,  52,  48,
+    124, 49,  55,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  51,  48,  54,  51,  124, 49,  55,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  49,  55,  56,  124,
+    49,  55,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  56,  51,  51,  49,  124, 49,  55,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  48,  48,  53,  124, 49,
+    54,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  50,  48,  57,  53,  124, 49,  54,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  53,  55,  57,  57,  124, 49,  54,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    53,  56,  52,  50,  124, 49,  54,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  54,  52,  53,  48,  124, 49,  54,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,
+    57,  51,  57,  124, 49,  54,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  57,  50,  48,  48,  124, 49,  54,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  55,
+    50,  55,  124, 49,  54,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  52,  56,  54,  124, 49,  53,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  53,  54,
+    53,  124, 49,  53,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  49,  48,  52,  54,  124, 49,  53,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  48,  52,  55,
+    124, 49,  53,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  49,  49,  54,  49,  124, 49,  53,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  51,  51,  54,  124,
+    49,  53,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  49,  52,  51,  53,  124, 49,  53,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  48,  55,  53,  124, 49,
+    53,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  51,  51,  51,  53,  124, 49,  53,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  53,  54,  52,  57,  124, 49,  53,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    54,  48,  50,  55,  124, 49,  53,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  54,  55,  57,  53,  124, 49,  53,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,
+    56,  48,  48,  124, 49,  53,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  54,  56,  50,  52,  124, 49,  53,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  49,
+    51,  49,  124, 49,  53,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  55,  51,  56,  50,  124, 49,  53,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  57,  49,
+    51,  124, 49,  53,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  57,  55,  56,  55,  124, 49,  53,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  54,  51,  51,
+    124, 49,  52,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  49,  57,  54,  48,  124, 49,  52,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  51,  50,  51,  124,
+    49,  52,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  50,  52,  57,  48,  124, 49,  52,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  57,  57,  51,  124, 49,
+    52,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  51,  49,  48,  49,  124, 49,  52,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  52,  52,  56,  57,  124, 49,  52,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    53,  52,  51,  53,  124, 49,  52,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  53,  53,  56,  51,  124, 49,  52,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,
+    55,  55,  52,  124, 49,  52,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  55,  53,  55,  57,  124, 49,  52,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  49,
+    56,  48,  124, 49,  52,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  56,  54,  57,  53,  124, 49,  52,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  50,  50,
+    52,  124, 49,  52,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  48,  51,  53,  55,  124, 49,  51,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  52,  51,  54,
+    124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  48,  54,  49,  48,  124, 49,  51,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  55,  56,  56,  124,
+    49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  48,  56,  56,  57,  124, 49,  51,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  48,  54,  50,  124, 49,
+    51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  49,  52,  57,  56,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  50,  48,  53,  54,  124, 49,  51,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    50,  51,  49,  50,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  50,  51,  52,  52,  124, 49,  51,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,
+    53,  57,  54,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  50,  54,  49,  53,  124, 49,  51,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  57,
+    55,  56,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  51,  48,  52,  56,  124, 49,  51,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  50,  51,
+    52,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  51,  55,  50,  55,  124, 49,  51,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  51,  56,  48,  54,
+    124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  52,  52,  55,  50,  124, 49,  51,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  53,  50,  51,  54,  124,
+    49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  53,  57,  48,  54,  124, 49,  51,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  54,  50,  52,  49,  124, 49,
+    51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  54,  51,  50,  54,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  54,  51,  56,  52,  124, 49,  51,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    54,  51,  57,  52,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  54,  54,  50,  52,  124, 49,  51,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,
+    54,  50,  57,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  54,  54,  56,  50,  124, 49,  51,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  54,  55,
+    51,  55,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  54,  56,  50,  53,  124, 49,  51,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  48,  50,
+    49,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  55,  52,  49,  55,  124, 49,  51,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  55,  52,  57,  55,
+    124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  55,  54,  48,  50,  124, 49,  51,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  56,  49,  51,  52,  124,
+    49,  51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  56,  50,  51,  52,  124, 49,  51,  10,  83,  117, 112, 112, 108,
+    105, 101, 114, 35,  48,  48,  48,  48,  48,  57,  52,  51,  53,  124, 49,
+    51,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,
+    48,  57,  52,  51,  54,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105,
+    101, 114, 35,  48,  48,  48,  48,  48,  57,  53,  54,  52,  124, 49,  51,
+    10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,
+    57,  56,  57,  54,  124, 49,  51,  10,  83,  117, 112, 112, 108, 105, 101,
+    114, 35,  48,  48,  48,  48,  48,  48,  51,  55,  57,  124, 49,  50,  10,
+    83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,
+    54,  55,  51,  124, 49,  50,  10,  83,  117, 112, 112, 108, 105, 101, 114,
+    35,  48,  48,  48,  48,  48,  48,  55,  54,  50,  124, 49,  50,  10,  83,
+    117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  48,  56,
+    49,  49,  124, 49,  50,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,
+    48,  48,  48,  48,  48,  48,  56,  50,  49,  124, 49,  50,  10,  83,  117,
+    112, 112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  51,  51,
+    55,  124, 49,  50,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,
+    48,  48,  48,  48,  49,  57,  49,  54,  124, 49,  50,  10,  83,  117, 112,
+    112, 108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  49,  57,  50,  53,
+    124, 49,  50,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,
+    48,  48,  48,  50,  48,  51,  57,  124, 49,  50,  10,  83,  117, 112, 112,
+    108, 105, 101, 114, 35,  48,  48,  48,  48,  48,  50,  51,  53,  55,  124,
+    49,  50,  10,  83,  117, 112, 112, 108, 105, 101, 114, 35,  48,  48,  48,
+    48,  48,  50,  52,  56,  51,  124, 49,  50,  10,  0};
+const uint8_t TPCH_ANSWERS_SF1_q22[] = {
+    99,  110, 116, 114, 121, 99,  111, 100, 101, 124, 110, 117, 109, 99,  117,
+    115, 116, 124, 116, 111, 116, 97,  99,  99,  116, 98,  97,  108, 10,  49,
+    51,  124, 56,  56,  56,  124, 54,  55,  51,  55,  55,  49,  51,  46,  57,
+    57,  10,  49,  55,  124, 56,  54,  49,  124, 54,  52,  54,  48,  53,  55,
+    51,  46,  55,  50,  10,  49,  56,  124, 57,  54,  52,  124, 55,  50,  51,
+    54,  54,  56,  55,  46,  52,  48,  10,  50,  51,  124, 56,  57,  50,  124,
+    54,  55,  48,  49,  52,  53,  55,  46,  57,  53,  10,  50,  57,  124, 57,
+    52,  56,  124, 55,  49,  53,  56,  56,  54,  54,  46,  54,  51,  10,  51,
+    48,  124, 57,  48,  57,  124, 54,  56,  48,  56,  52,  51,  54,  46,  49,
+    51,  10,  51,  49,  124, 57,  50,  50,  124, 54,  56,  48,  54,  54,  55,
+    48,  46,  49,  56,  10,  0};
+const char* TPCH_ANSWERS_SF1[] = {
+    (const char*)TPCH_ANSWERS_SF1_q01, (const char*)TPCH_ANSWERS_SF1_q02,
+    (const char*)TPCH_ANSWERS_SF1_q03, (const char*)TPCH_ANSWERS_SF1_q04,
+    (const char*)TPCH_ANSWERS_SF1_q05, (const char*)TPCH_ANSWERS_SF1_q06,
+    (const char*)TPCH_ANSWERS_SF1_q07, (const char*)TPCH_ANSWERS_SF1_q08,
+    (const char*)TPCH_ANSWERS_SF1_q09, (const char*)TPCH_ANSWERS_SF1_q10,
+    (const char*)TPCH_ANSWERS_SF1_q11, (const char*)TPCH_ANSWERS_SF1_q12,
+    (const char*)TPCH_ANSWERS_SF1_q13, (const char*)TPCH_ANSWERS_SF1_q14,
+    (const char*)TPCH_ANSWERS_SF1_q15, (const char*)TPCH_ANSWERS_SF1_q16,
+    (const char*)TPCH_ANSWERS_SF1_q17, (const char*)TPCH_ANSWERS_SF1_q18,
+    (const char*)TPCH_ANSWERS_SF1_q19, (const char*)TPCH_ANSWERS_SF1_q20,
+    (const char*)TPCH_ANSWERS_SF1_q21, (const char*)TPCH_ANSWERS_SF1_q22};
diff --git a/velox/tpch/gen/dbgen/permute.cpp b/velox/tpch/gen/dbgen/permute.cpp
new file mode 100644
index 0000000000000..eeb929667fe8c
--- /dev/null
+++ b/velox/tpch/gen/dbgen/permute.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ *//*
+ * permute.c -- a permutation generator for the query
+ *              sequences in TPC-H and TPC-R
+ */
+
+#include "dbgen/config.h" // @manual
+#include "dbgen/dss.h" // @manual
+
+DSS_HUGE NextRand(DSS_HUGE seed);
+void permute(long* set, int cnt, seed_t* seed);
+void permute_dist(distribution* d, seed_t* seed);
+long seed;
+char* eol[2] = {" ", "},"};
+
+#define MAX_QUERY 22
+#define ITERATIONS 1000
+#define UNSET 0
+
+void permute(long* a, int c, seed_t* seed) {
+  int i;
+  static DSS_HUGE source;
+  static long temp;
+
+  if (a != (long*)NULL) {
+    for (i = 0; i < c; i++) {
+      RANDOM(source, (long)i, (long)(c - 1), seed);
+      temp = *(a + source);
+      *(a + source) = *(a + i);
+      *(a + i) = temp;
+    }
+  }
+
+  return;
+}
+
+void permute_dist(distribution* d, seed_t* seed) {
+  int i;
+
+  if (d != NULL) {
+    if (d->permute == (long*)NULL) {
+      d->permute = (long*)malloc(sizeof(long) * DIST_SIZE(d));
+      MALLOC_CHECK(d->permute);
+    }
+    for (i = 0; i < DIST_SIZE(d); i++)
+      *(d->permute + i) = i;
+    permute(d->permute, DIST_SIZE(d), seed);
+  } else
+    INTERNAL_ERROR("Bad call to permute_dist");
+
+  return;
+}
diff --git a/velox/tpch/gen/dbgen/rnd.cpp b/velox/tpch/gen/dbgen/rnd.cpp
new file mode 100644
index 0000000000000..32d238f6d8ba5
--- /dev/null
+++ b/velox/tpch/gen/dbgen/rnd.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ *//*
+ * RANDOM.C -- Implements Park & Miller's "Minimum Standard" RNG
+ *
+ * (Reference:  CACM, Oct 1988, pp 1192-1201)
+ *
+ * NextRand:  Computes next random integer
+ * UnifInt:   Yields an long uniformly distributed between given bounds
+ * UnifReal: ields a real uniformly distributed between given bounds
+ * Exponential: Yields a real exponentially distributed with given mean
+ *
+ */
+
+#include "dbgen/config.h" // @manual
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include "dbgen/dss.h" // @manual
+#include "dbgen/rnd.h" // @manual
+
+const char* tpch_env_config PROTO((const char* tag, const char* dflt));
+void NthElement(DSS_HUGE, DSS_HUGE*);
+
+void dss_random(DSS_HUGE* tgt, DSS_HUGE lower, DSS_HUGE upper, seed_t* seed) {
+  *tgt = UnifInt(lower, upper, seed);
+  seed->usage += 1;
+
+  return;
+}
+
+void row_start(int t, DBGenContext* ctx) {
+  (void)t;
+  int i;
+  for (i = 0; i <= MAX_STREAM; i++)
+    ctx->Seed[i].usage = 0;
+
+  return;
+}
+
+void row_stop_h(int t, DBGenContext* ctx) {
+  int i;
+
+  /* need to allow for handling the master and detail together */
+  if (t == ORDER_LINE)
+    t = ORDER;
+  if (t == PART_PSUPP)
+    t = PART;
+
+  for (i = 0; i <= MAX_STREAM; i++)
+    if ((ctx->Seed[i].table == t) ||
+        (ctx->Seed[i].table == ctx->tdefs[t].child)) {
+      if (set_seeds && (ctx->Seed[i].usage > ctx->Seed[i].boundary)) {
+        fprintf(
+            stderr,
+            "\nSEED CHANGE: seed[%d].usage = " HUGE_FORMAT "\n",
+            i,
+            ctx->Seed[i].usage);
+        ctx->Seed[i].boundary = ctx->Seed[i].usage;
+      } else {
+        NthElement(
+            (ctx->Seed[i].boundary - ctx->Seed[i].usage), &ctx->Seed[i].value);
+#ifdef RNG_TEST
+        ctx->Seed[i].nCalls += ctx->Seed[i].boundary - ctx->Seed[i].usage;
+#endif
+      }
+    }
+  return;
+}
+
+void dump_seeds(int tbl, seed_t* seeds) {
+  int i;
+
+  for (i = 0; i <= MAX_STREAM; i++)
+    if (seeds[i].table == tbl)
+#ifdef RNG_TEST
+      printf(
+          "%d(" HUGE_FORMAT "):\t" HUGE_FORMAT "\n",
+          i,
+          seeds[i].nCalls,
+          seeds[i].value);
+#else
+      printf("%d:\t" HUGE_FORMAT "\n", i, seeds[i].value);
+#endif
+  return;
+}
+
+/******************************************************************
+
+   NextRand:  Computes next random integer
+
+*******************************************************************/
+
+/*
+ * long NextRand( long nSeed )
+ */
+DSS_HUGE
+NextRand(DSS_HUGE nSeed)
+
+/*
+ * nSeed is the previous random number; the returned value is the
+ * next random number. The routine generates all numbers in the
+ * range 1 .. nM-1.
+ */
+
+{
+  nSeed = (nSeed * 16807) % 2147483647;
+  return (nSeed);
+}
+
+/******************************************************************
+
+   UnifInt:  Yields an long uniformly distributed between given bounds
+
+*******************************************************************/
+
+/*
+ * long UnifInt( long nLow, long nHigh, seed_t *seed )
+ */
+DSS_HUGE
+UnifInt(DSS_HUGE nLow, DSS_HUGE nHigh, seed_t* seed)
+
+/*
+ * Returns an integer uniformly distributed between nLow and nHigh,
+ * including * the endpoints. Seed points to the random number stream.
+ */
+
+{
+  double dRange;
+  DSS_HUGE nTemp;
+  int32_t nLow32 = (int32_t)nLow, nHigh32 = (int32_t)nHigh;
+
+  if ((nHigh == MAX_LONG) && (nLow == 0)) {
+    dRange = (double)((DSS_HUGE)(nHigh32 - nLow32) + 1);
+  } else {
+    dRange = (double)(nHigh - nLow + 1);
+  }
+
+  seed->value = NextRand(seed->value);
+#ifdef RNG_TEST
+  seed->nCalls += 1;
+#endif
+  nTemp = (DSS_HUGE)(((double)seed->value / DBGenContext::dM) * (dRange));
+  return (nLow + nTemp);
+}
diff --git a/velox/tpch/gen/dbgen/rng64.cpp b/velox/tpch/gen/dbgen/rng64.cpp
new file mode 100644
index 0000000000000..a7254c2f67713
--- /dev/null
+++ b/velox/tpch/gen/dbgen/rng64.cpp
@@ -0,0 +1,140 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+/*
+ * $Id: rng64.c,v 1.7 2008/03/21 17:38:39 jms Exp $
+ *
+ * This software contains proprietary and confidential information of Gradient
+ * Systems Inc.  By accepting transfer of this copy, Recipient agrees
+ * to retain this software in confidence, to prevent disclosure to others, and
+ * to make no use of this software other than that for which it was delivered.
+ * This is an unpublished copyright work Gradient Systems, Inc.  Execpt as
+ * permitted by federal law, 17 USC 117, copying is strictly prohibited.
+ *
+ * Gradient Systems Inc. CONFIDENTIAL - (Gradient Systems Inc. Confidential
+ * when combined with the aggregated modules for this product)
+ * OBJECT CODE ONLY SOURCE MATERIALS
+ * (C) COPYRIGHT Gradient Systems Inc. 2003
+ *
+ * All Rights Reserved
+ * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF GRADIENT SYSTEMS, INC.
+ * The copyright notice above does not evidence any
+ * actual or intended publication of such source code.
+ *
+ * Revision History
+ * ===================
+ * $Log: rng64.c,v $
+ * Revision 1.7  2008/03/21 17:38:39  jms
+ * changes for 2.6.3
+ *
+ * Revision 1.6  2006/04/26 23:20:05  jms
+ * Data type clenaup for qgen
+ *
+ * Revision 1.5  2006/03/08 21:25:27  jms
+ * change to RNG64 to address overflow/underflow issues
+ *
+ * Revision 1.4  2005/10/25 17:26:38  jms
+ * check in integration between microsoft changes and baseline code
+ *
+ * Revision 1.3  2005/03/04 19:48:39  jms
+ * Changes from Doug Johnson to address very large scale factors
+ *
+ * Revision 1.2  2005/01/03 20:08:59  jms
+ * change line terminations
+ *
+ * Revision 1.1.1.1  2004/11/24 23:31:47  jms
+ * re-establish external server
+ *
+ * Revision 1.2  2004/02/18 16:45:30  jms
+ * remove C++ style comments for AIX compiler
+ *
+ * Revision 1.1.1.1  2003/08/08 21:57:34  jms
+ * recreation after CVS crash
+ *
+ * Revision 1.1  2003/08/08 21:57:34  jms
+ * first integration of rng64 for o_custkey and l_partkey
+ *
+ */
+#include "dbgen/rng64.h" // @manual
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void dss_random64(DSS_HUGE* tgt, DSS_HUGE nLow, DSS_HUGE nHigh, seed_t* seed) {
+  DSS_HUGE nTemp;
+
+  if (nLow > nHigh) {
+    nTemp = nLow;
+    nLow = nHigh;
+    nHigh = nTemp;
+  }
+
+  seed->value = NextRand64(seed->value);
+  nTemp = seed->value;
+  if (nTemp < 0)
+    nTemp = -nTemp;
+  nTemp %= (nHigh - nLow + 1);
+  *tgt = nLow + nTemp;
+  seed->usage += 1;
+#ifdef RNG_TEST
+  seed->nCalls += 1;
+#endif
+
+  return;
+}
+
+DSS_HUGE
+NextRand64(DSS_HUGE nSeed) {
+  DSS_HUGE a = (unsigned DSS_HUGE)RNG_A;
+  DSS_HUGE c = (unsigned DSS_HUGE)RNG_C;
+  nSeed = (nSeed * a + c); /* implicitely truncated to 64bits */
+
+  return (nSeed);
+}
+
+DSS_HUGE AdvanceRand64(DSS_HUGE nSeed, DSS_HUGE nCount) {
+  unsigned DSS_HUGE a = RNG_A;
+  unsigned DSS_HUGE c = RNG_C;
+  int nBit;
+  unsigned DSS_HUGE Apow = a, Dsum = c;
+
+  /* if nothing to do, do nothing ! */
+  if (nCount == 0)
+    return nSeed;
+
+  /* Recursively compute X(n) = A * X(n-1) + C */
+  /* */
+  /* explicitly: */
+  /* X(n) = A^n * X(0) + { A^(n-1) + A^(n-2) + ... A + 1 } * C */
+  /* */
+  /* we write this as: */
+  /* X(n) = Apow(n) * X(0) + Dsum(n) * C */
+  /* */
+  /* we use the following relations: */
+  /* Apow(n) = A^(n%2)*Apow(n/2)*Apow(n/2) */
+  /* Dsum(n) =   (n%2)*Apow(n/2)*Apow(n/2) + (Apow(n/2) + 1) * Dsum(n/2) */
+  /* */
+
+  /* first get the highest non-zero bit */
+  for (nBit = 0; (nCount >> nBit) != RNG_C; nBit++) {
+  }
+
+  /* go 1 bit at the time */
+  while (--nBit >= 0) {
+    Dsum *= (Apow + 1);
+    Apow = Apow * Apow;
+    if (((nCount >> nBit) % 2) == 1) { /* odd value */
+      Dsum += Apow;
+      Apow *= a;
+    }
+  }
+  nSeed = nSeed * Apow + Dsum * c;
+  return nSeed;
+}
diff --git a/velox/tpch/gen/dbgen/speed_seed.cpp b/velox/tpch/gen/dbgen/speed_seed.cpp
new file mode 100644
index 0000000000000..ab8dfee00cc88
--- /dev/null
+++ b/velox/tpch/gen/dbgen/speed_seed.cpp
@@ -0,0 +1,215 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+#include "dbgen/config.h" // @manual
+#include "dbgen/dss.h" // @manual
+#include "dbgen/rng64.h" // @manual
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/*  _tal long RandSeed = "Random^SeedFromTimestamp" (void); */
+
+#define ADVANCE_STREAM(stream, num_calls) advanceStream(stream, num_calls, 0)
+#define ADVANCE_STREAM64(stream, num_calls) advanceStream(stream, num_calls, 1)
+#define MAX_COLOR 92
+long name_bits[MAX_COLOR / BITS_PER_LONG];
+void fakeVStr(int nAvg, long nSeed, DSS_HUGE nCount);
+void NthElement(DSS_HUGE N, DSS_HUGE* StartSeed);
+
+void advanceStream(seed_t* seed, DSS_HUGE nCalls, int bUse64Bit) {
+  if (bUse64Bit)
+    seed->value = AdvanceRand64(seed->value, nCalls);
+  else
+    NthElement(nCalls, &seed->value);
+
+#ifdef RNG_TEST
+  seed->nCalls += nCalls;
+#endif
+
+  return;
+}
+
+/* WARNING!  This routine assumes the existence of 64-bit                 */
+/* integers.  The notation used here- "HUGE" is *not* ANSI standard. */
+/* Hopefully, you have this extension as well.  If not, use whatever      */
+/* nonstandard trick you need to in order to get 64 bit integers.         */
+/* The book says that this will work if MAXINT for the type you choose    */
+/* is at least 2**46  - 1, so 64 bits is more than you *really* need      */
+
+static DSS_HUGE Multiplier = 16807; /* or whatever nonstandard */
+static DSS_HUGE Modulus = 2147483647; /* trick you use to get 64 bit int */
+
+/* Advances value of Seed after N applications of the random number generator
+   with multiplier Mult and given Modulus.
+   NthElement(Seed[],count);
+
+   Theory:  We are using a generator of the form
+        X_n = [Mult * X_(n-1)]  mod Modulus.    It turns out that
+        X_n = [(Mult ** n) X_0] mod Modulus.
+   This can be computed using a divide-and-conquer technique, see
+   the code below.
+
+   In words, this means that if you want the value of the Seed after n
+   applications of the generator,  you multiply the initial value of the
+   Seed by the "super multiplier" which is the basic multiplier raised
+   to the nth power, and then take mod Modulus.
+*/
+
+/* Nth Element of sequence starting with StartSeed */
+void NthElement(DSS_HUGE N, DSS_HUGE* StartSeed) {
+  DSS_HUGE Z;
+  DSS_HUGE Mult;
+  static int ln = -1;
+
+  if ((verbose > 0) && ++ln % 1000 == 0) {
+    fprintf(stderr, "%c\b", lnoise[i]);
+  }
+  Mult = Multiplier;
+  Z = (DSS_HUGE)*StartSeed;
+  while (N > 0) {
+    if (N % 2 != 0) /* testing for oddness, this seems portable */
+      Z = (Mult * Z) % Modulus;
+    N = N / 2; /* integer division, truncates */
+    Mult = (Mult * Mult) % Modulus;
+  }
+  *StartSeed = Z;
+
+  return;
+}
+
+/* updates 'seed' using the tpch_a_rnd algorithm */
+void fake_tpch_a_rnd(int min, int max, seed_t* seed) {
+  DSS_HUGE len;
+  DSS_HUGE itcount;
+
+  RANDOM(len, min, max, seed);
+  if (len % 5L == 0)
+    itcount = len / 5;
+  else
+    itcount = len / 5 + 1L;
+  NthElement(itcount, &seed->usage);
+#ifdef RNG_TEST
+  seed->nCalls += itcount;
+#endif
+  return;
+}
+
+long sd_part(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
+  (void)child;
+  int i;
+
+  for (i = P_MFG_SD; i <= P_CNTR_SD; i++)
+    ADVANCE_STREAM(&ctx->Seed[i], skip_count);
+
+  ADVANCE_STREAM(&ctx->Seed[P_CMNT_SD], skip_count * 2);
+  ADVANCE_STREAM(&ctx->Seed[P_NAME_SD], skip_count * 92);
+
+  return (0L);
+}
+
+long sd_line(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
+  int i, j;
+
+  for (j = 0; j < O_LCNT_MAX; j++) {
+    for (i = L_QTY_SD; i <= L_RFLG_SD; i++)
+      /*
+                  if (ctx->scale_factor >= 30000 && i == L_PKEY_SD)
+                      ADVANCE_STREAM64(&ctx->Seed[i], skip_count);
+                  else
+      */
+      ADVANCE_STREAM(&ctx->Seed[i], skip_count);
+    ADVANCE_STREAM(&ctx->Seed[L_CMNT_SD], skip_count * 2);
+  }
+
+  /* need to special case this as the link between master and detail */
+  if (child == 1) {
+    ADVANCE_STREAM(&ctx->Seed[O_ODATE_SD], skip_count);
+    ADVANCE_STREAM(&ctx->Seed[O_LCNT_SD], skip_count);
+  }
+
+  return (0L);
+}
+
+long sd_order(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
+  (void)child;
+  ADVANCE_STREAM(&ctx->Seed[O_LCNT_SD], skip_count);
+  /*
+      if (ctx->scale_factor >= 30000)
+          ADVANCE_STREAM64(&ctx->Seed[O_CKEY_SD], skip_count);
+      else
+  */
+  ADVANCE_STREAM(&ctx->Seed[O_CKEY_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[O_CMNT_SD], skip_count * 2);
+  ADVANCE_STREAM(&ctx->Seed[O_SUPP_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[O_CLRK_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[O_PRIO_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[O_ODATE_SD], skip_count);
+
+  return (0L);
+}
+
+long sd_psupp(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
+  (void)child;
+
+  int j;
+
+  for (j = 0; j < SUPP_PER_PART; j++) {
+    ADVANCE_STREAM(&ctx->Seed[PS_QTY_SD], skip_count);
+    ADVANCE_STREAM(&ctx->Seed[PS_SCST_SD], skip_count);
+    ADVANCE_STREAM(&ctx->Seed[PS_CMNT_SD], skip_count * 2);
+  }
+
+  return (0L);
+}
+
+long sd_cust(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
+  (void)child;
+
+  ADVANCE_STREAM(&ctx->Seed[C_ADDR_SD], skip_count * 9);
+  ADVANCE_STREAM(&ctx->Seed[C_CMNT_SD], skip_count * 2);
+  ADVANCE_STREAM(&ctx->Seed[C_NTRG_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[C_PHNE_SD], 3L * skip_count);
+  ADVANCE_STREAM(&ctx->Seed[C_ABAL_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[C_MSEG_SD], skip_count);
+  return (0L);
+}
+
+long sd_supp(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
+  (void)child;
+
+  ADVANCE_STREAM(&ctx->Seed[S_NTRG_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[S_PHNE_SD], 3L * skip_count);
+  ADVANCE_STREAM(&ctx->Seed[S_ABAL_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[S_ADDR_SD], skip_count * 9);
+  ADVANCE_STREAM(&ctx->Seed[S_CMNT_SD], skip_count * 2);
+  ADVANCE_STREAM(&ctx->Seed[BBB_CMNT_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[BBB_JNK_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[BBB_OFFSET_SD], skip_count);
+  ADVANCE_STREAM(&ctx->Seed[BBB_TYPE_SD], skip_count); /* avoid one trudge */
+
+  return (0L);
+}
+
+long sd_nation(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
+  (void)child;
+
+  ADVANCE_STREAM(&ctx->Seed[N_CMNT_SD], skip_count * 2);
+
+  return (0L);
+}
+
+long sd_region(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
+  (void)child;
+
+  ADVANCE_STREAM(&ctx->Seed[R_CMNT_SD], skip_count * 2);
+
+  return (0L);
+}
diff --git a/velox/tpch/gen/dbgen/text.cpp b/velox/tpch/gen/dbgen/text.cpp
new file mode 100644
index 0000000000000..b28097ebecbb6
--- /dev/null
+++ b/velox/tpch/gen/dbgen/text.cpp
@@ -0,0 +1,273 @@
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under extension/tpch/dbgen/LICENSE
+ * in this repository.
+ *
+ * You may not use this file except in compliance with the License.
+ *
+ * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
+ */
+/*
+ * text.c --- pseaudo text generator for use in DBGEN 2.0
+ *
+ * Defined Routines:
+ *		dbg_text() -- select and translate a sentance form
+ */
+
+#ifdef TEXT_TEST
+#define DECLARER
+#endif /* TEST */
+
+#include "dbgen/config.h" // @manual
+
+#include <stdlib.h>
+#ifndef WIN32
+/* Change for Windows NT */
+#include <unistd.h>
+#endif /* WIN32 */
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <math.h>
+#include <signal.h>
+#include <stdio.h> /* */
+#include <string.h>
+#ifdef HP
+#include <strings.h>
+#endif
+#if (defined(WIN32) && !defined(_POSIX_))
+#include <process.h> // @manual
+#pragma warning(disable : 4201)
+#pragma warning(disable : 4214)
+#pragma warning(disable : 4514)
+#define WIN32_LEAN_AND_MEAN
+#define NOATOM
+#define NOGDICAPMASKS
+#define NOMETAFILE
+#define NOMINMAX
+#define NOMSG
+#define NOOPENFILE
+#define NORASTEROPS
+#define NOSCROLL
+#define NOSOUND
+#define NOSYSMETRICS
+#define NOTEXTMETRIC
+#define NOWH
+#define NOCOMM
+#define NOKANJI
+#define NOMCX
+#include <windows.h>
+#pragma warning(default : 4201)
+#pragma warning(default : 4214)
+#endif
+
+#include "dbgen/dss.h" // @manual
+
+static char* gen_text(char* dest, seed_t* seed, distribution* s) {
+  long i = 0;
+  DSS_HUGE j;
+
+  RANDOM(j, 1, s->list[s->count - 1].weight, seed);
+  while (s->list[i].weight < j)
+    i++;
+  char* src = s->list[i].text;
+  int ind = 0;
+  while (src[ind]) {
+    dest[ind] = src[ind];
+    ind++;
+  }
+  dest[ind] = ' ';
+  return dest + ind + 1;
+}
+
+#define NOUN_MAX_WEIGHT 340
+#define ADJECTIVES_MAX_WEIGHT 289
+#define ADVERBS_MAX_WEIGHT 262
+#define AUXILLARIES_MAX_WEIGHT 18
+#define VERBS_MAX_WEIGHT 174
+#define PREPOSITIONS_MAX_WEIGHT 456
+
+static char* noun_index[NOUN_MAX_WEIGHT + 1];
+static char* adjectives_index[ADJECTIVES_MAX_WEIGHT + 1];
+static char* adverbs_index[ADVERBS_MAX_WEIGHT + 1];
+static char* auxillaries_index[AUXILLARIES_MAX_WEIGHT + 1];
+static char* verbs_index[VERBS_MAX_WEIGHT + 1];
+static char* prepositions_index[PREPOSITIONS_MAX_WEIGHT + 1];
+
+static char* szTextPool;
+static long txtBufferSize = 0;
+
+// generate a lookup table for weight -> str
+static void gen_index(char** index, distribution* s) {
+  for (size_t w = 0; w <= s->list[s->count - 1].weight; w++) {
+    long i = 0;
+    while (s->list[i].weight < w)
+      i++;
+    index[w] = s->list[i].text;
+  }
+}
+
+static char*
+gen_text_index(char* dest, seed_t* seed, char** index, distribution* s) {
+  DSS_HUGE j;
+
+  RANDOM(j, 1, s->list[s->count - 1].weight, seed);
+  char* src = index[j];
+  int ind = 0;
+  while (src[ind]) {
+    dest[ind] = src[ind];
+    ind++;
+  }
+  dest[ind] = ' ';
+  return dest + ind + 1;
+}
+
+static char* gen_vp(char* dest, seed_t* seed) {
+  DSS_HUGE j;
+  RANDOM(j, 1, vp.list[vp.count - 1].weight, seed);
+  int index = 0;
+  index += vp.list[0].weight < j;
+  index += vp.list[1].weight < j;
+  index += vp.list[2].weight < j;
+
+  if (index == 0) {
+    dest = gen_text_index(dest, seed, verbs_index, &verbs);
+  } else if (index == 1) {
+    dest = gen_text_index(dest, seed, auxillaries_index, &auxillaries);
+    dest = gen_text_index(dest, seed, verbs_index, &verbs);
+  } else if (index == 2) {
+    dest = gen_text_index(dest, seed, verbs_index, &verbs);
+    dest = gen_text_index(dest, seed, adverbs_index, &adverbs);
+  } else {
+    dest = gen_text_index(dest, seed, auxillaries_index, &auxillaries);
+    dest = gen_text_index(dest, seed, verbs_index, &verbs);
+    dest = gen_text_index(dest, seed, adverbs_index, &adverbs);
+  }
+  return dest;
+}
+
+static char* gen_np(char* dest, seed_t* seed) {
+  DSS_HUGE j;
+  RANDOM(j, 1, np.list[np.count - 1].weight, seed);
+  int index = 0;
+  index += np.list[0].weight < j;
+  index += np.list[1].weight < j;
+  index += np.list[2].weight < j;
+
+  if (index == 0) {
+    dest = gen_text_index(dest, seed, noun_index, &nouns);
+  } else if (index == 1) {
+    dest = gen_text_index(dest, seed, adjectives_index, &adjectives);
+    dest = gen_text_index(dest, seed, noun_index, &nouns);
+  } else if (index == 2) {
+    dest = gen_text_index(dest, seed, adjectives_index, &adjectives);
+    dest[-1] = ',';
+    *(dest++) = ' ';
+    dest = gen_text_index(dest, seed, adjectives_index, &adjectives);
+    dest = gen_text_index(dest, seed, noun_index, &nouns);
+  } else {
+    dest = gen_text_index(dest, seed, adverbs_index, &adverbs);
+    dest = gen_text_index(dest, seed, adjectives_index, &adjectives);
+    dest = gen_text_index(dest, seed, noun_index, &nouns);
+  }
+  return dest;
+}
+
+static char* gen_preposition(char* dest, seed_t* seed) {
+  dest = gen_text_index(dest, seed, prepositions_index, &prepositions);
+  *(dest++) = 't';
+  *(dest++) = 'h';
+  *(dest++) = 'e';
+  *(dest++) = ' ';
+  return gen_np(dest, seed);
+}
+
+static char* gen_terminator(char* dest, seed_t* seed) {
+  dest = gen_text(--dest, seed, &terminators);
+  return dest - 1;
+}
+
+static char* gen_sentence(char* dest, seed_t* seed) {
+  DSS_HUGE j;
+  RANDOM(j, 1, grammar.list[grammar.count - 1].weight, seed);
+  int index = 0;
+  index += grammar.list[0].weight < j;
+  index += grammar.list[1].weight < j;
+  index += grammar.list[2].weight < j;
+  index += grammar.list[3].weight < j;
+
+  if (index == 0) {
+    dest = gen_np(dest, seed);
+    dest = gen_vp(dest, seed);
+    dest = gen_terminator(dest, seed);
+  } else if (index == 1) {
+    dest = gen_np(dest, seed);
+    dest = gen_vp(dest, seed);
+    dest = gen_preposition(dest, seed);
+    dest = gen_terminator(dest, seed);
+  } else if (index == 2) {
+    dest = gen_np(dest, seed);
+    dest = gen_vp(dest, seed);
+    dest = gen_np(dest, seed);
+    dest = gen_terminator(dest, seed);
+  } else if (index == 3) {
+    dest = gen_np(dest, seed);
+    dest = gen_preposition(dest, seed);
+    dest = gen_vp(dest, seed);
+    dest = gen_np(dest, seed);
+    dest = gen_terminator(dest, seed);
+  } else {
+    dest = gen_np(dest, seed);
+    dest = gen_preposition(dest, seed);
+    dest = gen_vp(dest, seed);
+    dest = gen_preposition(dest, seed);
+    dest = gen_terminator(dest, seed);
+  }
+  *dest = ' ';
+  return dest + 1;
+}
+
+/*
+ * init_text_pool() --
+ *    allocate and initialize the internal text pool buffer (szTextPool).
+ *    Make sure to call it before using dbg_text().
+ */
+void init_text_pool(long bSize, DBGenContext* ctx) {
+  gen_index(noun_index, &nouns);
+  gen_index(adjectives_index, &adjectives);
+  gen_index(adverbs_index, &adverbs);
+  gen_index(auxillaries_index, &auxillaries);
+  gen_index(verbs_index, &verbs);
+  gen_index(prepositions_index, &prepositions);
+
+  txtBufferSize = bSize;
+  szTextPool = (char*)malloc(bSize + 1 + 100);
+
+  char* ptr = szTextPool;
+  char* endptr = szTextPool + bSize + 1;
+  while (ptr < endptr) {
+    ptr = gen_sentence(ptr, &ctx->Seed[5]);
+  }
+  szTextPool[bSize] = '\0';
+}
+
+void free_text_pool() {
+  free(szTextPool);
+}
+
+/*
+ * dbg_text() --
+ *		produce ELIZA-like text of random, bounded length, truncating
+ *the last generated sentence as required
+ */
+void dbg_text(char* tgt, int min, int max, seed_t* seed) {
+  DSS_HUGE hgLength = 0, hgOffset;
+
+  RANDOM(hgOffset, 0, txtBufferSize - max, seed);
+  RANDOM(hgLength, min, max, seed);
+  strncpy(&tgt[0], &szTextPool[hgOffset], (int)hgLength);
+  tgt[hgLength] = '\0';
+
+  return;
+}
diff --git a/velox/tpch/gen/tests/CMakeLists.txt b/velox/tpch/gen/tests/CMakeLists.txt
index 4607d4801a3ee..9bd7c6bdd4b11 100644
--- a/velox/tpch/gen/tests/CMakeLists.txt
+++ b/velox/tpch/gen/tests/CMakeLists.txt
@@ -15,5 +15,10 @@ add_executable(velox_tpch_gen_test TpchGenTest.cpp)
 
 add_test(velox_tpch_gen_test velox_tpch_gen_test)
 
-target_link_libraries(velox_tpch_gen_test velox_tpch_gen velox_type
-                      velox_vector gtest gtest_main)
+target_link_libraries(
+  velox_tpch_gen_test
+  velox_tpch_gen
+  velox_type
+  velox_vector
+  GTest::gtest
+  GTest::gtest_main)
diff --git a/velox/tpch/gen/tests/TpchGenTest.cpp b/velox/tpch/gen/tests/TpchGenTest.cpp
index 39109f331230d..637907b499ad4 100644
--- a/velox/tpch/gen/tests/TpchGenTest.cpp
+++ b/velox/tpch/gen/tests/TpchGenTest.cpp
@@ -18,7 +18,6 @@
 #include "gtest/gtest.h"
 
 #include "velox/tpch/gen/TpchGen.h"
-#include "velox/type/StringView.h"
 #include "velox/vector/FlatVector.h"
 
 namespace {
@@ -30,8 +29,12 @@ using namespace facebook::velox::tpch;
 
 class TpchGenTestNationTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = memory::defaultMemoryManager().addLeafPool("TpchGenTestNationTest");
+    pool_ = memory::memoryManager()->addLeafPool("TpchGenTestNationTest");
   }
 
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -133,8 +136,12 @@ TEST_F(TpchGenTestNationTest, reproducible) {
 // Region.
 class TpchGenTestRegionTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = memory::defaultMemoryManager().addLeafPool("TpchGenTestRegionTest");
+    pool_ = memory::memoryManager()->addLeafPool("TpchGenTestRegionTest");
   }
 
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -195,8 +202,12 @@ TEST_F(TpchGenTestRegionTest, reproducible) {
 // Orders tests.
 class TpchGenTestOrdersTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = memory::defaultMemoryManager().addLeafPool("TpchGenTestOrdersTest");
+    pool_ = memory::memoryManager()->addLeafPool("TpchGenTestOrdersTest");
   }
 
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -301,9 +312,12 @@ TEST_F(TpchGenTestOrdersTest, reproducible) {
 // Lineitem.
 class TpchGenTestLineItemTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ =
-        memory::defaultMemoryManager().addLeafPool("TpchGenTestLineItemTest");
+    pool_ = memory::memoryManager()->addLeafPool("TpchGenTestLineItemTest");
   }
 
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -413,9 +427,12 @@ TEST_F(TpchGenTestLineItemTest, reproducible) {
 // Supplier.
 class TpchGenTestSupplierTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ =
-        memory::defaultMemoryManager().addLeafPool("TpchGenTestSupplierTest");
+    pool_ = memory::memoryManager()->addLeafPool("TpchGenTestSupplierTest");
   }
 
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -506,8 +523,12 @@ TEST_F(TpchGenTestSupplierTest, reproducible) {
 // Part.
 class TpchGenTestPartTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ = memory::defaultMemoryManager().addLeafPool("TpchGenTestPartTest");
+    pool_ = memory::memoryManager()->addLeafPool("TpchGenTestPartTest");
   }
 
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -591,9 +612,12 @@ TEST_F(TpchGenTestPartTest, reproducible) {
 // PartSupp.
 class TpchGenTestPartSuppTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ =
-        memory::defaultMemoryManager().addLeafPool("TpchGenTestPartSuppTest");
+    pool_ = memory::memoryManager()->addLeafPool("TpchGenTestPartSuppTest");
   }
 
   bool partSuppCheck(
@@ -736,9 +760,12 @@ TEST_F(TpchGenTestPartSuppTest, reproducible) {
 // Customer.
 class TpchGenTestCustomerTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
-    pool_ =
-        memory::defaultMemoryManager().addLeafPool("TpchGenTestCustomerTest");
+    pool_ = memory::memoryManager()->addLeafPool("TpchGenTestCustomerTest");
   }
 
   std::shared_ptr<memory::MemoryPool> pool_;
@@ -823,6 +850,6 @@ TEST_F(TpchGenTestCustomerTest, reproducible) {
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, false);
+  folly::Init init{&argc, &argv, false};
   return RUN_ALL_TESTS();
 }
diff --git a/velox/type/CMakeLists.txt b/velox/type/CMakeLists.txt
index 499cb521005d1..7a01444b85a89 100644
--- a/velox/type/CMakeLists.txt
+++ b/velox/type/CMakeLists.txt
@@ -15,15 +15,16 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
+add_subdirectory(parser)
 add_subdirectory(tz)
 add_subdirectory(fbhive)
 
-add_library(
+velox_add_library(
   velox_type
   Conversions.cpp
   DecimalUtil.cpp
-  DoubleUtil.cpp
   Filter.cpp
+  FloatingPointUtil.cpp
   HugeInt.cpp
   StringView.cpp
   StringView.h
@@ -34,7 +35,7 @@ add_library(
   Type.cpp
   Variant.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_type
   velox_type_tz
   velox_common_base
@@ -42,6 +43,7 @@ target_link_libraries(
   velox_exception
   velox_serialization
   velox_external_date
+  velox_status
   Boost::headers
   Folly::folly
   re2::re2)
diff --git a/velox/type/Conversions.cpp b/velox/type/Conversions.cpp
index a49e22898945e..c2cbdad99289f 100644
--- a/velox/type/Conversions.cpp
+++ b/velox/type/Conversions.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/type/Conversions.h"
+#include "velox/functions/lib/string/StringImpl.h"
 
 DEFINE_bool(
     experimental_enable_legacy_cast,
@@ -23,3 +24,83 @@ DEFINE_bool(
     " format of type conversions used for casting. This is a temporary solution"
     " that aims to facilitate a seamless transition for users who rely on the"
     " legacy behavior and hence can change in the future.");
+
+namespace facebook::velox::util {
+
+/// folly's tryTo doesn't ignore control characters or other unicode whitespace.
+/// We trim the string for control and unicode whitespace
+/// from both directions and return a StringView of the result.
+StringView trimWhiteSpace(const char* data, size_t length) {
+  if (length == 0) {
+    return StringView(data, 0);
+  }
+
+  int startIndex = 0;
+  int endIndex = length - 1;
+  const auto end = data + length;
+  int size = 0;
+
+  // We need to trim unicode chars and control chars
+  // from left side of the string.
+  for (auto i = 0; i < length;) {
+    size = 0;
+    auto isWhiteSpaceOrControlChar = false;
+
+    if (data[i] & 0x80) {
+      // Unicode - only check for whitespace.
+      auto codePoint = utf8proc_codepoint(data + i, end, size);
+      isWhiteSpaceOrControlChar =
+          velox::functions::stringImpl::isUnicodeWhiteSpace(codePoint);
+    } else {
+      // Ascii - Check for both whitespace and control chars
+      isWhiteSpaceOrControlChar =
+          velox::functions::stringImpl::isAsciiWhiteSpace(data[i]) ||
+          (data[i] > 0 && data[i] < 32);
+    }
+
+    if (!isWhiteSpaceOrControlChar) {
+      startIndex = i;
+      break;
+    }
+
+    i += size > 0 ? size : 1;
+  }
+
+  // Trim whitespace from right side.
+  for (auto i = length - 1; i > startIndex;) {
+    size = 0;
+    auto isWhiteSpaceOrControlChar = false;
+
+    if (data[i] & 0x80) {
+      // Unicode - only check for whitespace.
+      utf8proc_int32_t codePoint;
+      // Find the right codepoint
+      while ((codePoint = utf8proc_codepoint(data + i, end, size)) < 0 &&
+             i > startIndex) {
+        i--;
+      }
+      isWhiteSpaceOrControlChar =
+          velox::functions::stringImpl::isUnicodeWhiteSpace(codePoint);
+    } else {
+      // Ascii - check if control char or whitespace
+      isWhiteSpaceOrControlChar =
+          velox::functions::stringImpl::isAsciiWhiteSpace(data[i]) ||
+          (data[i] > 0 && data[i] < 32);
+    }
+
+    if (!isWhiteSpaceOrControlChar) {
+      endIndex = i;
+      break;
+    }
+
+    if (i > 0) {
+      i--;
+    }
+  }
+
+  // If we end on a unicode char make sure we add that to the end.
+  auto charSize = size > 0 ? size : 1;
+  return StringView(data + startIndex, endIndex - startIndex + charSize);
+}
+
+} // namespace facebook::velox::util
diff --git a/velox/type/Conversions.h b/velox/type/Conversions.h
index 18b0fbdc4a8f9..25847b1a99b55 100644
--- a/velox/type/Conversions.h
+++ b/velox/type/Conversions.h
@@ -17,10 +17,13 @@
 #pragma once
 
 #include <folly/Conv.h>
+#include <folly/Expected.h>
 #include <cctype>
 #include <string>
 #include <type_traits>
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/Status.h"
+#include "velox/type/CppToType.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/type/Type.h"
 
@@ -28,185 +31,358 @@ DECLARE_bool(experimental_enable_legacy_cast);
 
 namespace facebook::velox::util {
 
-template <TypeKind KIND, typename = void, bool TRUNCATE = false>
+struct PrestoCastPolicy {
+  static constexpr bool truncate = false;
+  static constexpr bool legacyCast = false;
+  // Throws if we encounter unicode when converting to int
+  // See issue : https://github.com/facebookincubator/velox/issues/10803
+  // Remove when unicode support is added.
+  static constexpr bool throwOnUnicode = true;
+};
+
+struct SparkCastPolicy {
+  static constexpr bool truncate = true;
+  static constexpr bool legacyCast = false;
+  static constexpr bool throwOnUnicode = false;
+};
+
+struct LegacyCastPolicy {
+  static constexpr bool truncate = false;
+  static constexpr bool legacyCast = true;
+  static constexpr bool throwOnUnicode = false;
+};
+
+template <TypeKind KIND, typename = void, typename TPolicy = PrestoCastPolicy>
 struct Converter {
-  template <typename T>
-  static typename TypeTraits<KIND>::NativeType cast(T) {
-    VELOX_UNSUPPORTED(
+  using TTo = typename TypeTraits<KIND>::NativeType;
+
+  template <typename TFrom>
+  static Expected<TTo> tryCast(TFrom) {
+    static const std::string kErrorMessage = fmt::format(
         "Conversion to {} is not supported", TypeTraits<KIND>::name);
+
+    return folly::makeUnexpected(Status::UserError(kErrorMessage));
   }
 };
 
-template <>
-struct Converter<TypeKind::BOOLEAN> {
+/// Casts a string to a boolean. Allows a fixed set of strings. Casting from
+/// other strings throws.
+/// @tparam TPolicy PrestoCastPolicy and LegacyCastPolicy allow `t, f, 1, 0,
+/// true, false` and their upper case equivalents. SparkCastPolicy additionally
+/// allows 'y, n, yes, no' and their upper case equivalents.
+template <typename TPolicy>
+Expected<bool> castToBoolean(const char* data, size_t len) {
+  const auto& TU = static_cast<int (*)(int)>(std::toupper);
+
+  if (len == 1) {
+    auto character = TU(data[0]);
+    if (character == 'T' || character == '1') {
+      return true;
+    }
+    if (character == 'F' || character == '0') {
+      return false;
+    }
+    if constexpr (std::is_same_v<TPolicy, SparkCastPolicy>) {
+      if (character == 'Y') {
+        return true;
+      }
+      if (character == 'N') {
+        return false;
+      }
+    }
+  }
+
+  // Case-insensitive 'true'.
+  if ((len == 4) && (TU(data[0]) == 'T') && (TU(data[1]) == 'R') &&
+      (TU(data[2]) == 'U') && (TU(data[3]) == 'E')) {
+    return true;
+  }
+
+  // Case-insensitive 'false'.
+  if ((len == 5) && (TU(data[0]) == 'F') && (TU(data[1]) == 'A') &&
+      (TU(data[2]) == 'L') && (TU(data[3]) == 'S') && (TU(data[4]) == 'E')) {
+    return false;
+  }
+
+  if constexpr (std::is_same_v<TPolicy, SparkCastPolicy>) {
+    // Case-insensitive 'yes'.
+    if ((len == 3) && (TU(data[0]) == 'Y') && (TU(data[1]) == 'E') &&
+        (TU(data[2]) == 'S')) {
+      return true;
+    }
+
+    // Case-insensitive 'no'.
+    if ((len == 2) && (TU(data[0]) == 'N') && (TU(data[1]) == 'O')) {
+      return false;
+    }
+  }
+
+  return folly::makeUnexpected(Status::UserError(
+      "Cannot cast {} to BOOLEAN", std::string_view(data, len)));
+}
+
+namespace detail {
+
+template <typename T, typename F>
+Expected<T> callFollyTo(const F& v) {
+  const auto result = folly::tryTo<T>(v);
+  if (result.hasError()) {
+    if (threadSkipErrorDetails()) {
+      return folly::makeUnexpected(Status::UserError());
+    }
+    return folly::makeUnexpected(Status::UserError(
+        "{}", folly::makeConversionError(result.error(), "").what()));
+  }
+
+  return result.value();
+}
+
+} // namespace detail
+
+/// To BOOLEAN converter.
+template <typename TPolicy>
+struct Converter<TypeKind::BOOLEAN, void, TPolicy> {
   using T = bool;
 
-  template <typename From>
-  static T cast(const From& v) {
-    return folly::to<T>(v);
+  template <typename TFrom>
+  static Expected<T> tryCast(const TFrom& v) {
+    if constexpr (TPolicy::truncate) {
+      return folly::makeUnexpected(
+          Status::UserError("Conversion to BOOLEAN is not supported"));
+    }
+
+    return detail::callFollyTo<T>(v);
   }
 
-  static T cast(folly::StringPiece v) {
-    return folly::to<T>(v);
+  static Expected<T> tryCast(folly::StringPiece v) {
+    return castToBoolean<TPolicy>(v.data(), v.size());
   }
 
-  static T cast(const StringView& v) {
-    return folly::to<T>(folly::StringPiece(v));
+  static Expected<T> tryCast(const StringView& v) {
+    return castToBoolean<TPolicy>(v.data(), v.size());
   }
 
-  static T cast(const std::string& v) {
-    return folly::to<T>(v);
+  static Expected<T> tryCast(const std::string& v) {
+    return castToBoolean<TPolicy>(v.data(), v.length());
+  }
+
+  static Expected<T> tryCast(const bool& v) {
+    return detail::callFollyTo<T>(v);
   }
 
-  static T cast(const Timestamp&) {
-    VELOX_UNSUPPORTED("Conversion of Timestamp to Boolean is not supported");
+  static Expected<T> tryCast(const float& v) {
+    if constexpr (TPolicy::truncate) {
+      if (std::isnan(v)) {
+        return false;
+      }
+      return v != 0;
+    } else {
+      return detail::callFollyTo<T>(v);
+    }
+  }
+
+  static Expected<T> tryCast(const double& v) {
+    if constexpr (TPolicy::truncate) {
+      if (std::isnan(v)) {
+        return false;
+      }
+      return v != 0;
+    } else {
+      return detail::callFollyTo<T>(v);
+    }
+  }
+
+  static Expected<T> tryCast(const int8_t& v) {
+    if constexpr (TPolicy::truncate) {
+      return T(v);
+    } else {
+      return detail::callFollyTo<T>(v);
+    }
+  }
+
+  static Expected<T> tryCast(const int16_t& v) {
+    if constexpr (TPolicy::truncate) {
+      return T(v);
+    } else {
+      return detail::callFollyTo<T>(v);
+    }
+  }
+
+  static Expected<T> tryCast(const int32_t& v) {
+    if constexpr (TPolicy::truncate) {
+      return T(v);
+    } else {
+      return detail::callFollyTo<T>(v);
+    }
+  }
+
+  static Expected<T> tryCast(const int64_t& v) {
+    if constexpr (TPolicy::truncate) {
+      return T(v);
+    } else {
+      return detail::callFollyTo<T>(v);
+    }
+  }
+
+  static Expected<T> tryCast(const Timestamp&) {
+    return folly::makeUnexpected(Status::UserError(
+        "Conversion of Timestamp to Boolean is not supported"));
   }
 };
 
-template <TypeKind KIND, bool TRUNCATE>
+/// Presto compatible trim of whitespace. This also trims
+/// control characters from both front and back and returns
+/// a StringView of the trimmed string.
+StringView trimWhiteSpace(const char* data, size_t length);
+
+/// To TINYINT, SMALLINT, INTEGER, BIGINT, and HUGEINT converter.
+template <TypeKind KIND, typename TPolicy>
 struct Converter<
     KIND,
     std::enable_if_t<
-        KIND == TypeKind::BOOLEAN || KIND == TypeKind::TINYINT ||
-            KIND == TypeKind::SMALLINT || KIND == TypeKind::INTEGER ||
-            KIND == TypeKind::BIGINT || KIND == TypeKind::HUGEINT,
+        KIND == TypeKind::TINYINT || KIND == TypeKind::SMALLINT ||
+            KIND == TypeKind::INTEGER || KIND == TypeKind::BIGINT ||
+            KIND == TypeKind::HUGEINT,
         void>,
-    TRUNCATE> {
+    TPolicy> {
   using T = typename TypeTraits<KIND>::NativeType;
 
   template <typename From>
-  static T cast(const From&) {
-    VELOX_UNSUPPORTED(
+  static Expected<T> tryCast(const From&) {
+    static const std::string kErrorMessage = fmt::format(
         "Conversion to {} is not supported", TypeTraits<KIND>::name);
+
+    return folly::makeUnexpected(Status::UserError(kErrorMessage));
   }
 
-  static T convertStringToInt(const folly::StringPiece v) {
-    // Handling boolean target case fist because it is in this scope
-    if constexpr (std::is_same_v<T, bool>) {
-      return folly::to<T>(v);
-    } else {
-      // Handling integer target cases
-      T result = 0;
-      int index = 0;
-      int len = v.size();
-      if (len == 0) {
-        VELOX_USER_FAIL("Cannot cast an empty string to an integral value.");
-      }
+  static Expected<T> convertStringToInt(const folly::StringPiece v) {
+    // Handling integer target cases
+    T result = 0;
+    int index = 0;
+    int len = v.size();
+    if (len == 0) {
+      return folly::makeUnexpected(Status::UserError(
+          "Cannot cast an empty string to an integral value."));
+    }
 
-      // Setting negative flag
-      bool negative = false;
-      // Setting decimalPoint flag
-      bool decimalPoint = false;
-      if (v[0] == '-') {
-        if (len == 1) {
-          VELOX_USER_FAIL("Cannot cast an '-' string to an integral value.");
-        }
-        negative = true;
-        index = 1;
+    // Setting negative flag
+    bool negative = false;
+    // Setting decimalPoint flag
+    bool decimalPoint = false;
+    if (v[0] == '-' || v[0] == '+') {
+      if (len == 1) {
+        return folly::makeUnexpected(Status::UserError(
+            "Cannot cast an '{}' string to an integral value.", v[0]));
       }
-      if (negative) {
-        for (; index < len; index++) {
-          // Truncate the decimal
-          if (!decimalPoint && v[index] == '.') {
-            decimalPoint = true;
-            if (++index == len) {
-              break;
-            }
-          }
-          if (!std::isdigit(v[index])) {
-            VELOX_USER_FAIL("Encountered a non-digit character");
-          }
-          if (!decimalPoint) {
-            result = result * 10 - (v[index] - '0');
-          }
-          // Overflow check
-          if (result > 0) {
-            VELOX_USER_FAIL("Value is too large for type");
+      negative = v[0] == '-';
+      index = 1;
+    }
+    if (negative) {
+      for (; index < len; index++) {
+        // Truncate the decimal
+        if (!decimalPoint && v[index] == '.') {
+          decimalPoint = true;
+          if (++index == len) {
+            break;
           }
         }
-      } else {
-        for (; index < len; index++) {
-          // Truncate the decimal
-          if (!decimalPoint && v[index] == '.') {
-            decimalPoint = true;
-            if (++index == len) {
-              break;
-            }
-          }
-          if (!std::isdigit(v[index])) {
-            VELOX_USER_FAIL("Encountered a non-digit character");
-          }
-          if (!decimalPoint) {
-            result = result * 10 + (v[index] - '0');
-          }
-          // Overflow check
-          if (result < 0) {
-            VELOX_USER_FAIL("Value is too large for type");
+        if (!std::isdigit(v[index])) {
+          return folly::makeUnexpected(
+              Status::UserError("Encountered a non-digit character"));
+        }
+        if (!decimalPoint) {
+          result = checkedMultiply<T>(result, 10, CppToType<T>::name);
+          result = checkedMinus<T>(result, v[index] - '0', CppToType<T>::name);
+        }
+      }
+    } else {
+      for (; index < len; index++) {
+        // Truncate the decimal
+        if (!decimalPoint && v[index] == '.') {
+          decimalPoint = true;
+          if (++index == len) {
+            break;
           }
         }
+        if (!std::isdigit(v[index])) {
+          return folly::makeUnexpected(
+              Status::UserError("Encountered a non-digit character"));
+        }
+        if (!decimalPoint) {
+          result = checkedMultiply<T>(result, 10, CppToType<T>::name);
+          result = checkedPlus<T>(result, v[index] - '0', CppToType<T>::name);
+        }
       }
-      // Final result
-      return result;
     }
+    // Final result
+    return result;
   }
 
-  static T cast(folly::StringPiece v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(folly::StringPiece v) {
+    if constexpr (TPolicy::truncate) {
       return convertStringToInt(v);
     } else {
-      return folly::to<T>(v);
+      auto trimmed = trimWhiteSpace(v.data(), v.size());
+      return detail::callFollyTo<T>(trimmed);
     }
   }
 
-  static T cast(const StringView& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const StringView& v) {
+    if constexpr (TPolicy::truncate) {
       return convertStringToInt(folly::StringPiece(v));
     } else {
-      return folly::to<T>(folly::StringPiece(v));
+      auto trimmed = trimWhiteSpace(v.data(), v.size());
+      return detail::callFollyTo<T>(trimmed);
     }
   }
 
-  static T cast(const std::string& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const std::string& v) {
+    if constexpr (TPolicy::truncate) {
       return convertStringToInt(v);
     } else {
-      return folly::to<T>(v);
+      auto trimmed = trimWhiteSpace(v.data(), v.length());
+      return detail::callFollyTo<T>(trimmed);
     }
   }
 
-  static T cast(const bool& v) {
+  static Expected<T> tryCast(const bool& v) {
     return folly::to<T>(v);
   }
 
   struct LimitType {
     static constexpr bool kByteOrSmallInt =
         std::is_same_v<T, int8_t> || std::is_same_v<T, int16_t>;
+
     static int64_t minLimit() {
       if (kByteOrSmallInt) {
         return std::numeric_limits<int32_t>::min();
       }
       return std::numeric_limits<T>::min();
     }
+
     static int64_t maxLimit() {
       if (kByteOrSmallInt) {
         return std::numeric_limits<int32_t>::max();
       }
       return std::numeric_limits<T>::max();
     }
+
     static T min() {
       if (kByteOrSmallInt) {
         return 0;
       }
       return std::numeric_limits<T>::min();
     }
+
     static T max() {
       if (kByteOrSmallInt) {
         return -1;
       }
       return std::numeric_limits<T>::max();
     }
+
     template <typename FP>
-    static T cast(const FP& v) {
+    static Expected<T> tryCast(const FP& v) {
       if (kByteOrSmallInt) {
         return T(int32_t(v));
       }
@@ -214,222 +390,293 @@ struct Converter<
     }
   };
 
-  static T cast(const float& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const float& v) {
+    if constexpr (TPolicy::truncate) {
       if (std::isnan(v)) {
         return 0;
       }
-      if constexpr (std::is_same_v<T, bool>) {
-        return v != 0;
-      }
+
       if constexpr (std::is_same_v<T, int128_t>) {
         return std::numeric_limits<int128_t>::max();
       } else if (v > LimitType::maxLimit()) {
         return LimitType::max();
-      }
-      if constexpr (std::is_same_v<T, int128_t>) {
-        return std::numeric_limits<int128_t>::min();
       } else if (v < LimitType::minLimit()) {
         return LimitType::min();
       }
-      return LimitType::cast(v);
+
+      return LimitType::tryCast(v);
     } else {
       if (std::isnan(v)) {
-        VELOX_USER_FAIL("Cannot cast NaN to an integral value.");
+        return folly::makeUnexpected(
+            Status::UserError("Cannot cast NaN to an integral value."));
       }
-      return folly::to<T>(std::round(v));
+      return detail::callFollyTo<T>(std::round(v));
     }
   }
 
-  static T cast(const double& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const double& v) {
+    if constexpr (TPolicy::truncate) {
       if (std::isnan(v)) {
         return 0;
       }
-      if constexpr (std::is_same_v<T, bool>) {
-        return v != 0;
-      }
+
       if constexpr (std::is_same_v<T, int128_t>) {
         return std::numeric_limits<int128_t>::max();
       } else if (v > LimitType::maxLimit()) {
         return LimitType::max();
-      }
-      if constexpr (std::is_same_v<T, int128_t>) {
-        return std::numeric_limits<int128_t>::min();
       } else if (v < LimitType::minLimit()) {
         return LimitType::min();
       }
-      return LimitType::cast(v);
+
+      return LimitType::tryCast(v);
     } else {
       if (std::isnan(v)) {
-        VELOX_USER_FAIL("Cannot cast NaN to an integral value.");
+        return folly::makeUnexpected(
+            Status::UserError("Cannot cast NaN to an integral value."));
       }
-      return folly::to<T>(std::round(v));
+      return detail::callFollyTo<T>(std::round(v));
     }
   }
 
-  static T cast(const int8_t& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const int8_t& v) {
+    if constexpr (TPolicy::truncate) {
       return T(v);
     } else {
-      return folly::to<T>(v);
+      return detail::callFollyTo<T>(v);
     }
   }
 
-  static T cast(const int16_t& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const int16_t& v) {
+    if constexpr (TPolicy::truncate) {
       return T(v);
     } else {
-      return folly::to<T>(v);
+      return detail::callFollyTo<T>(v);
     }
   }
 
-  static T cast(const int32_t& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const int32_t& v) {
+    if constexpr (TPolicy::truncate) {
       return T(v);
     } else {
-      return folly::to<T>(v);
+      return detail::callFollyTo<T>(v);
     }
   }
 
-  static T cast(const int64_t& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const int64_t& v) {
+    if constexpr (TPolicy::truncate) {
       return T(v);
     } else {
-      return folly::to<T>(v);
+      return detail::callFollyTo<T>(v);
     }
   }
 };
 
-template <TypeKind KIND, bool TRUNCATE>
+/// To REAL and DOUBLE converter.
+template <TypeKind KIND, typename TPolicy>
 struct Converter<
     KIND,
     std::enable_if_t<KIND == TypeKind::REAL || KIND == TypeKind::DOUBLE, void>,
-    TRUNCATE> {
+    TPolicy> {
   using T = typename TypeTraits<KIND>::NativeType;
 
   template <typename From>
-  static T cast(const From& v) {
-    return folly::to<T>(v);
+  static Expected<T> tryCast(const From& v) {
+    return detail::callFollyTo<T>(v);
   }
 
-  static T cast(folly::StringPiece v) {
-    return cast<folly::StringPiece>(v);
+  static Expected<T> tryCast(folly::StringPiece v) {
+    return tryCast<folly::StringPiece>(v);
   }
 
-  static T cast(const StringView& v) {
-    return cast<folly::StringPiece>(folly::StringPiece(v));
+  static Expected<T> tryCast(const StringView& v) {
+    return tryCast<folly::StringPiece>(folly::StringPiece(v));
   }
 
-  static T cast(const std::string& v) {
-    return cast<std::string>(v);
+  static Expected<T> tryCast(const std::string& v) {
+    return tryCast<std::string>(v);
   }
 
-  static T cast(const bool& v) {
-    return cast<bool>(v);
+  static Expected<T> tryCast(const bool& v) {
+    return tryCast<bool>(v);
   }
 
-  static T cast(const float& v) {
-    return cast<float>(v);
+  static Expected<T> tryCast(const float& v) {
+    return tryCast<float>(v);
   }
 
-  static T cast(const double& v) {
-    if constexpr (TRUNCATE) {
+  static Expected<T> tryCast(const double& v) {
+    if constexpr (TPolicy::truncate) {
       return T(v);
     } else {
-      return cast<double>(v);
+      return tryCast<double>(v);
     }
   }
 
-  static T cast(const int8_t& v) {
-    return cast<int8_t>(v);
+  static Expected<T> tryCast(const int8_t& v) {
+    return tryCast<int8_t>(v);
   }
 
-  static T cast(const int16_t& v) {
-    return cast<int16_t>(v);
+  static Expected<T> tryCast(const int16_t& v) {
+    return tryCast<int16_t>(v);
   }
 
   // Convert integer to double or float directly, not using folly, as it
   // might throw 'loss of precision' error.
-  static T cast(const int32_t& v) {
+  static Expected<T> tryCast(const int32_t& v) {
     return static_cast<T>(v);
   }
 
   // Convert large integer to double or float directly, not using folly, as it
   // might throw 'loss of precision' error.
-  static T cast(const int64_t& v) {
+  static Expected<T> tryCast(const int64_t& v) {
     return static_cast<T>(v);
   }
 
   // Convert large integer to double or float directly, not using folly, as it
   // might throw 'loss of precision' error.
-  static T cast(const int128_t& v) {
+  static Expected<T> tryCast(const int128_t& v) {
     return static_cast<T>(v);
   }
 
-  static T cast(const Timestamp&) {
-    VELOX_UNSUPPORTED(
-        "Conversion of Timestamp to Real or Double is not supported");
+  static Expected<T> tryCast(const Timestamp&) {
+    return folly::makeUnexpected(Status::UserError(
+        "Conversion of Timestamp to Real or Double is not supported"));
   }
 };
 
-template <bool TRUNCATE>
-struct Converter<TypeKind::VARBINARY, void, TRUNCATE> {
+/// To VARBINARY converter.
+template <typename TPolicy>
+struct Converter<TypeKind::VARBINARY, void, TPolicy> {
   // Same semantics of TypeKind::VARCHAR converter.
   template <typename T>
-  static std::string cast(const T& val) {
-    return Converter<TypeKind::VARCHAR, void, TRUNCATE>::cast(val);
+  static Expected<std::string> tryCast(const T& val) {
+    return Converter<TypeKind::VARCHAR, void, TPolicy>::tryCast(val);
   }
 };
 
-template <bool TRUNCATE>
-struct Converter<TypeKind::VARCHAR, void, TRUNCATE> {
+/// To VARCHAR converter.
+template <typename TPolicy>
+struct Converter<TypeKind::VARCHAR, void, TPolicy> {
   template <typename T>
-  static std::string cast(const T& val) {
+  static Expected<std::string> tryCast(const T& val) {
     if constexpr (std::is_same_v<T, double> || std::is_same_v<T, float>) {
-      auto stringValue = folly::to<std::string>(val);
-      if (!FLAGS_experimental_enable_legacy_cast &&
-          stringValue.find(".") == std::string::npos &&
-          isdigit(stringValue[stringValue.length() - 1])) {
-        stringValue += ".0";
+      if constexpr (TPolicy::legacyCast) {
+        auto str = folly::to<std::string>(val);
+        normalizeStandardNotation(str);
+        return str;
+      }
+
+      // Implementation below is close to String.of(double) of Java. For
+      // example, for some rare cases the result differs in precision by
+      // the least significant bit.
+      if (FOLLY_UNLIKELY(std::isinf(val) || std::isnan(val))) {
+        return folly::to<std::string>(val);
+      }
+      if ((val > -10'000'000 && val <= -0.001) ||
+          (val >= 0.001 && val < 10'000'000) || val == 0.0) {
+        auto str = fmt::format("{}", val);
+        normalizeStandardNotation(str);
+        return str;
       }
-      return stringValue;
+      // Precision of float is at most 8 significant decimal digits. Precision
+      // of double is at most 17 significant decimal digits.
+      auto str =
+          fmt::format(std::is_same_v<T, float> ? "{:.7E}" : "{:.16E}", val);
+      normalizeScientificNotation(str);
+      return str;
     }
+
     return folly::to<std::string>(val);
   }
 
-  static std::string cast(const Timestamp& val) {
+  static Expected<std::string> tryCast(const Timestamp& val) {
     TimestampToStringOptions options;
-    options.precision = TimestampToStringOptions::kMilliseconds;
+    options.precision = TimestampToStringOptions::Precision::kMilliseconds;
+    if constexpr (!TPolicy::legacyCast) {
+      options.zeroPaddingYear = true;
+      options.dateTimeSeparator = ' ';
+    }
     return val.toString(options);
   }
 
-  static std::string cast(const bool& val) {
+  static Expected<std::string> tryCast(const bool& val) {
     return val ? "true" : "false";
   }
-};
 
-// Allow conversions from string to TIMESTAMP type.
-template <bool TRUNCATE>
-struct Converter<TypeKind::TIMESTAMP, void, TRUNCATE> {
-  using T = typename TypeTraits<TypeKind::TIMESTAMP>::NativeType;
+  /// Normalize the given floating-point standard notation string in place, by
+  /// appending '.0' if it has only the integer part but no fractional part. For
+  /// example, for the given string '12345', replace it with '12345.0'.
+  static void normalizeStandardNotation(std::string& str) {
+    if (!FLAGS_experimental_enable_legacy_cast &&
+        str.find(".") == std::string::npos && isdigit(str[str.length() - 1])) {
+      str += ".0";
+    }
+  }
+
+  /// Normalize the given floating-point scientific notation string in place, by
+  /// removing the trailing 0s of the coefficient as well as the leading '+' and
+  /// 0s of the exponent. For example, for the given string '3.0000000E+005',
+  /// replace it with '3.0E5'. For '-1.2340000E-010', replace it with
+  /// '-1.234E-10'.
+  static void normalizeScientificNotation(std::string& str) {
+    size_t idxE = str.find('E');
+    VELOX_DCHECK_NE(
+        idxE,
+        std::string::npos,
+        "Expect a character 'E' in scientific notation.");
+
+    int endCoef = idxE - 1;
+    while (endCoef >= 0 && str[endCoef] == '0') {
+      --endCoef;
+    }
+    VELOX_DCHECK_GT(endCoef, 0, "Coefficient should not be all zeros.");
+
+    int pos = endCoef + 1;
+    if (str[endCoef] == '.') {
+      pos++;
+    }
+    str[pos++] = 'E';
+
+    int startExp = idxE + 1;
+    if (str[startExp] == '-') {
+      str[pos++] = '-';
+      startExp++;
+    }
+    while (startExp < str.length() &&
+           (str[startExp] == '0' || str[startExp] == '+')) {
+      startExp++;
+    }
+    VELOX_DCHECK_LT(
+        startExp, str.length(), "Exponent should not be all zeros.");
+    str.replace(pos, str.length() - startExp, str, startExp);
+    pos += str.length() - startExp;
+
+    str.resize(pos);
+  }
+};
 
+/// To TIMESTAMP converter.
+template <typename TPolicy>
+struct Converter<TypeKind::TIMESTAMP, void, TPolicy> {
   template <typename From>
-  static T cast(const From& /* v */) {
-    VELOX_UNSUPPORTED("Conversion to Timestamp is not supported");
-    return T();
+  static Expected<Timestamp> tryCast(const From& /* v */) {
+    return folly::makeUnexpected(
+        Status::UserError("Conversion to Timestamp is not supported"));
   }
 
-  static T cast(folly::StringPiece v) {
-    return fromTimestampString(v.data(), v.size());
+  static Expected<Timestamp> tryCast(folly::StringPiece v) {
+    return fromTimestampString(
+        v.data(), v.size(), TimestampParseMode::kPrestoCast);
   }
 
-  static T cast(const StringView& v) {
-    return fromTimestampString(v.data(), v.size());
+  static Expected<Timestamp> tryCast(const StringView& v) {
+    return fromTimestampString(
+        v.data(), v.size(), TimestampParseMode::kPrestoCast);
   }
 
-  static T cast(const std::string& v) {
-    return fromTimestampString(v.data(), v.size());
+  static Expected<Timestamp> tryCast(const std::string& v) {
+    return fromTimestampString(
+        v.data(), v.size(), TimestampParseMode::kPrestoCast);
   }
 };
 
diff --git a/velox/type/CppToType.h b/velox/type/CppToType.h
new file mode 100644
index 0000000000000..332026b14b6c9
--- /dev/null
+++ b/velox/type/CppToType.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+// TODO: move cppToType testing utilities.
+template <typename T>
+struct CppToType {};
+
+template <TypeKind KIND>
+struct CppToTypeBase : public TypeTraits<KIND> {
+  static auto create() {
+    return TypeFactory<KIND>::create();
+  }
+};
+
+template <>
+struct CppToType<int128_t> : public CppToTypeBase<TypeKind::HUGEINT> {};
+
+template <>
+struct CppToType<__uint128_t> : public CppToTypeBase<TypeKind::HUGEINT> {};
+
+template <>
+struct CppToType<int64_t> : public CppToTypeBase<TypeKind::BIGINT> {};
+
+template <>
+struct CppToType<uint64_t> : public CppToTypeBase<TypeKind::BIGINT> {};
+
+template <>
+struct CppToType<int32_t> : public CppToTypeBase<TypeKind::INTEGER> {};
+
+template <>
+struct CppToType<uint32_t> : public CppToTypeBase<TypeKind::INTEGER> {};
+
+template <>
+struct CppToType<int16_t> : public CppToTypeBase<TypeKind::SMALLINT> {};
+
+template <>
+struct CppToType<uint16_t> : public CppToTypeBase<TypeKind::SMALLINT> {};
+
+template <>
+struct CppToType<int8_t> : public CppToTypeBase<TypeKind::TINYINT> {};
+
+template <>
+struct CppToType<uint8_t> : public CppToTypeBase<TypeKind::TINYINT> {};
+
+template <>
+struct CppToType<bool> : public CppToTypeBase<TypeKind::BOOLEAN> {};
+
+template <>
+struct CppToType<folly::StringPiece> : public CppToTypeBase<TypeKind::VARCHAR> {
+};
+
+template <>
+struct CppToType<velox::StringView> : public CppToTypeBase<TypeKind::VARCHAR> {
+};
+
+template <>
+struct CppToType<std::string_view> : public CppToTypeBase<TypeKind::VARCHAR> {};
+
+template <>
+struct CppToType<std::string> : public CppToTypeBase<TypeKind::VARCHAR> {};
+
+template <>
+struct CppToType<const char*> : public CppToTypeBase<TypeKind::VARCHAR> {};
+
+template <>
+struct CppToType<folly::ByteRange> : public CppToTypeBase<TypeKind::VARBINARY> {
+};
+
+template <>
+struct CppToType<float> : public CppToTypeBase<TypeKind::REAL> {};
+
+template <>
+struct CppToType<double> : public CppToTypeBase<TypeKind::DOUBLE> {};
+
+template <>
+struct CppToType<Timestamp> : public CppToTypeBase<TypeKind::TIMESTAMP> {};
+
+// TODO: maybe do something smarter than just matching any shared_ptr, e.g. we
+// can declare "registered" types explicitly
+template <typename T>
+struct CppToType<std::shared_ptr<T>> : public CppToTypeBase<TypeKind::OPAQUE> {
+  // We override the type with the concrete specialization here!
+  // using NativeType = std::shared_ptr<T>;
+  static auto create() {
+    return OpaqueType::create<T>();
+  }
+};
+
+template <>
+struct CppToType<UnknownValue> : public CppToTypeBase<TypeKind::UNKNOWN> {};
+
+// todo: remaining cpp2type
+
+} // namespace facebook::velox
diff --git a/velox/type/DecimalUtil.cpp b/velox/type/DecimalUtil.cpp
index b602d07276dfe..f07b34a115283 100644
--- a/velox/type/DecimalUtil.cpp
+++ b/velox/type/DecimalUtil.cpp
@@ -23,7 +23,11 @@ std::string formatDecimal(uint8_t scale, int128_t unscaledValue) {
   VELOX_DCHECK_GE(scale, 0);
   VELOX_DCHECK_LT(
       static_cast<size_t>(scale), sizeof(DecimalUtil::kPowersOfTen));
+  const bool isFraction = (scale > 0);
   if (unscaledValue == 0) {
+    if (isFraction) {
+      return fmt::format("{:.{}f}", 0.0, scale);
+    }
     return "0";
   }
 
@@ -33,7 +37,6 @@ std::string formatDecimal(uint8_t scale, int128_t unscaledValue) {
   }
   int128_t integralPart = unscaledValue / DecimalUtil::kPowersOfTen[scale];
 
-  bool isFraction = (scale > 0);
   std::string fractionString;
   if (isFraction) {
     auto fraction =
@@ -51,7 +54,7 @@ std::string formatDecimal(uint8_t scale, int128_t unscaledValue) {
 }
 } // namespace
 
-std::string DecimalUtil::toString(const int128_t value, const TypePtr& type) {
+std::string DecimalUtil::toString(int128_t value, const TypePtr& type) {
   auto [precision, scale] = getDecimalPrecisionScale(*type);
   return formatDecimal(scale, value);
 }
@@ -86,4 +89,40 @@ int32_t DecimalUtil::toByteArray(int128_t value, char* out) {
   return length;
 }
 
+void DecimalUtil::computeAverage(
+    int128_t& avg,
+    int128_t sum,
+    int64_t count,
+    int64_t overflow) {
+  if (overflow == 0) {
+    divideWithRoundUp<int128_t, int128_t, int64_t>(
+        avg, sum, count, false, 0, 0);
+  } else {
+    VELOX_DCHECK_LE(overflow, count);
+    __uint128_t quotMul, remMul;
+    __int128_t quotSum, remSum;
+    __int128_t remTotal;
+    remMul = DecimalUtil::divideWithRoundUp<__uint128_t, __uint128_t, int64_t>(
+        quotMul, kOverflowMultiplier, count, true, 0, 0);
+    remMul *= overflow;
+    quotMul *= overflow;
+    remSum = DecimalUtil::divideWithRoundUp<__int128_t, __int128_t, int64_t>(
+        quotSum, sum, count, true, 0, 0);
+    DecimalUtil::divideWithRoundUp<__int128_t, __int128_t, int64_t>(
+        remTotal, remMul + remSum, count, true, 0, 0);
+    avg = quotMul + quotSum + remTotal;
+  }
+}
+
+int32_t DecimalUtil::maxStringViewSize(int precision, int scale) {
+  int32_t rowSize = precision + 1; // Number and symbol.
+  if (scale > 0) {
+    ++rowSize; // A dot.
+  }
+  if (precision == scale) {
+    ++rowSize; // Leading zero.
+  }
+  return rowSize;
+}
+
 } // namespace facebook::velox
diff --git a/velox/type/DecimalUtil.h b/velox/type/DecimalUtil.h
index 1507fbb5269a8..dc935b94cdc95 100644
--- a/velox/type/DecimalUtil.h
+++ b/velox/type/DecimalUtil.h
@@ -16,10 +16,14 @@
 
 #pragma once
 
+#include <charconv>
 #include <string>
 #include "velox/common/base/CheckedArithmetic.h"
+#include "velox/common/base/CountBits.h"
+#include "velox/common/base/Doubles.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Nulls.h"
+#include "velox/common/base/Status.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
@@ -79,8 +83,11 @@ class DecimalUtil {
   static constexpr int128_t kShortDecimalMax =
       kPowersOfTen[ShortDecimalType::kMaxPrecision] - 1;
 
+  static constexpr uint64_t kInt64Mask = ~(static_cast<uint64_t>(1) << 63);
+  static constexpr uint128_t kInt128Mask = (static_cast<uint128_t>(1) << 127);
+
   FOLLY_ALWAYS_INLINE static void valueInRange(int128_t value) {
-    VELOX_CHECK(
+    VELOX_USER_CHECK(
         (value >= kLongDecimalMin && value <= kLongDecimalMax),
         "Decimal overflow. Value '{}' is not in the range of Decimal Type",
         value);
@@ -95,7 +102,7 @@ class DecimalUtil {
   }
 
   /// Helper function to convert a decimal value to string.
-  static std::string toString(const int128_t value, const TypePtr& type);
+  static std::string toString(int128_t value, const TypePtr& type);
 
   template <typename T>
   inline static void fillDecimals(
@@ -143,12 +150,13 @@ class DecimalUtil {
   }
 
   template <typename TInput, typename TOutput>
-  inline static std::optional<TOutput> rescaleWithRoundUp(
-      const TInput inputValue,
-      const int fromPrecision,
-      const int fromScale,
-      const int toPrecision,
-      const int toScale) {
+  inline static Status rescaleWithRoundUp(
+      TInput inputValue,
+      int fromPrecision,
+      int fromScale,
+      int toPrecision,
+      int toScale,
+      TOutput& output) {
     int128_t rescaledValue = inputValue;
     auto scaleDifference = toScale - fromScale;
     bool isOverflow = false;
@@ -170,20 +178,19 @@ class DecimalUtil {
     }
     // Check overflow.
     if (!valueInPrecisionRange(rescaledValue, toPrecision) || isOverflow) {
-      VELOX_USER_FAIL(
+      return Status::UserError(
           "Cannot cast DECIMAL '{}' to DECIMAL({}, {})",
           DecimalUtil::toString(inputValue, DECIMAL(fromPrecision, fromScale)),
           toPrecision,
           toScale);
     }
-    return static_cast<TOutput>(rescaledValue);
+    output = static_cast<TOutput>(rescaledValue);
+    return Status::OK();
   }
 
   template <typename TInput, typename TOutput>
-  inline static std::optional<TOutput> rescaleInt(
-      const TInput inputValue,
-      const int toPrecision,
-      const int toScale) {
+  inline static std::optional<TOutput>
+  rescaleInt(TInput inputValue, int toPrecision, int toScale) {
     int128_t rescaledValue = static_cast<int128_t>(inputValue);
     bool isOverflow = __builtin_mul_overflow(
         rescaledValue, DecimalUtil::kPowersOfTen[toScale], &rescaledValue);
@@ -199,17 +206,88 @@ class DecimalUtil {
     return static_cast<TOutput>(rescaledValue);
   }
 
+  /// Rescales a floating point value to decimal value of given precision and
+  /// scale. Returns error status if fails.
+  /// @tparam TInput Either float or double.
+  /// @tparam TOutput Either int64_t or int128_t.
+  template <typename TInput, typename TOutput>
+  inline static Status rescaleFloatingPoint(
+      TInput value,
+      int precision,
+      int scale,
+      TOutput& output) {
+    if (!std::isfinite(value)) {
+      return Status::UserError("The input value should be finite.");
+    }
+
+    TInput maxValue;
+    if constexpr (std::is_same_v<TOutput, int64_t>) {
+      maxValue = kMaxDoubleBelowInt64Max;
+    } else {
+      maxValue = kMaxDoubleBelowInt128Max;
+    }
+
+    if (value <= std::numeric_limits<TOutput>::min() || value > maxValue) {
+      return Status::UserError("Result overflows.");
+    }
+
+    uint8_t digits;
+    if constexpr (std::is_same_v<TInput, float>) {
+      // A float provides between 6 and 7 decimal digits, so at least 6 digits
+      // are precise.
+      digits = 6;
+    } else {
+      // A double provides from 15 to 17 decimal digits, so at least 15 digits
+      // are precise.
+      digits = 15;
+    }
+
+    // Calculate the precise fractional digits.
+    const auto integralValue = static_cast<uint128_t>(std::abs(value));
+    const auto integralDigits =
+        integralValue == 0 ? 0 : countDigits(integralValue);
+    const auto fractionDigits = std::max(digits - integralDigits, 0);
+
+    // Scales up the input value with all the precise fractional digits kept.
+    // Convert value as long double type because 1) double * int128_t returns
+    // int128_t and fractional digits are lost. 2) we could also convert the
+    // int128_t value as double to avoid 'double * int128_t', but double
+    // multiplication gives inaccurate result on large numbers. For example,
+    // -3333030000000000000 * 1e3 = -3333030000000000065536. No need to
+    // consider the result becoming infinite as DOUBLE_MAX * 10^38 <
+    // LONG_DOUBLE_MAX.
+    long double scaledValue = std::round(
+        (long double)value * DecimalUtil::kPowersOfTen[fractionDigits]);
+    if (scale > fractionDigits) {
+      scaledValue *= DecimalUtil::kPowersOfTen[scale - fractionDigits];
+    } else {
+      scaledValue /= DecimalUtil::kPowersOfTen[fractionDigits - scale];
+    }
+
+    const auto result = folly::tryTo<TOutput>(std::round(scaledValue));
+    if (result.hasError()) {
+      return Status::UserError("Result overflows.");
+    }
+    const TOutput rescaledValue = result.value();
+    if (!valueInPrecisionRange<TOutput>(rescaledValue, precision)) {
+      return Status::UserError(
+          "Result cannot fit in the given precision {}.", precision);
+    }
+    output = rescaledValue;
+    return Status::OK();
+  }
+
   template <typename R, typename A, typename B>
   inline static R divideWithRoundUp(
       R& r,
-      const A& a,
-      const B& b,
+      A a,
+      B b,
       bool noRoundUp,
       uint8_t aRescale,
       uint8_t /*bRescale*/) {
-    VELOX_CHECK_NE(b, 0, "Division by zero");
+    VELOX_USER_CHECK_NE(b, 0, "Division by zero");
     int resultSign = 1;
-    A unsignedDividendRescaled(a);
+    R unsignedDividendRescaled(a);
     if (a < 0) {
       resultSign = -1;
       unsignedDividendRescaled *= -1;
@@ -229,7 +307,72 @@ class DecimalUtil {
       ++quotient;
     }
     r = quotient * resultSign;
-    return remainder;
+    return remainder * resultSign;
+  }
+
+  /// Returns the max required size to convert the decimal of this precision and
+  /// scale to varchar. A varchar's size is estimated with unscaled value
+  /// digits, dot, leading zero, and possible minus sign.
+  static int32_t maxStringViewSize(int precision, int scale);
+
+  /// @brief Convert the unscaled value of a decimal to string and write to raw
+  /// string buffer from start position.
+  /// @tparam T The type of input value.
+  /// @param unscaledValue The input unscaled value.
+  /// @param scale The scale of decimal.
+  /// @param maxSize The estimated max size of string.
+  /// @param startPosition The start position to write from.
+  /// @return The actual size of the string.
+  template <typename T>
+  static size_t castToString(
+      T unscaledValue,
+      int32_t scale,
+      int32_t maxSize,
+      char* const startPosition) {
+    char* writePosition = startPosition;
+    if (unscaledValue == 0) {
+      *writePosition++ = '0';
+      if (scale > 0) {
+        *writePosition++ = '.';
+        // Append trailing zeros.
+        std::memset(writePosition, '0', scale);
+        writePosition += scale;
+      }
+    } else {
+      if (unscaledValue < 0) {
+        *writePosition++ = '-';
+        unscaledValue = -unscaledValue;
+      }
+      auto [position, errorCode] = std::to_chars(
+          writePosition,
+          writePosition + maxSize,
+          unscaledValue / DecimalUtil::kPowersOfTen[scale]);
+      VELOX_DCHECK_EQ(
+          errorCode,
+          std::errc(),
+          "Failed to cast decimal to varchar: {}",
+          std::make_error_code(errorCode).message());
+      writePosition = position;
+
+      if (scale > 0) {
+        *writePosition++ = '.';
+        uint128_t fraction = unscaledValue % DecimalUtil::kPowersOfTen[scale];
+        // Append leading zeros.
+        int numLeadingZeros = std::max(scale - countDigits(fraction), 0);
+        std::memset(writePosition, '0', numLeadingZeros);
+        writePosition += numLeadingZeros;
+        // Append remaining fraction digits.
+        auto result =
+            std::to_chars(writePosition, writePosition + maxSize, fraction);
+        VELOX_DCHECK_EQ(
+            result.ec,
+            std::errc(),
+            "Failed to cast decimal to varchar: {}",
+            std::make_error_code(result.ec).message());
+        writePosition = result.ptr;
+      }
+    }
+    return writePosition - startPosition;
   }
 
   /*
@@ -237,8 +380,8 @@ class DecimalUtil {
    */
   inline static int64_t addUnsignedValues(
       int128_t& sum,
-      const int128_t& lhs,
-      const int128_t& rhs,
+      int128_t lhs,
+      int128_t rhs,
       bool isResultNegative) {
     __uint128_t unsignedSum = (__uint128_t)lhs + (__uint128_t)rhs;
     // Ignore overflow value.
@@ -247,8 +390,20 @@ class DecimalUtil {
     return (unsignedSum >> 127);
   }
 
+  /// Adds two signed 128-bit numbers (int128_t), calculates the sum, and
+  /// returns the overflow. It can be used to track the number of overflow when
+  /// adding a batch of input numbers. It takes lhs and rhs as input, and stores
+  /// their sum in result. overflow == 1 indicates upward overflow. overflow ==
+  /// -1 indicates downward overflow. overflow == 0 indicates no overflow.
+  /// Adding negative and non-negative numbers never overflows, so we can
+  /// directly add them. Adding two negative or two positive numbers may
+  /// overflow. To add numbers that may overflow, first convert both numbers to
+  /// unsigned 128-bit number (uint128_t), and perform the addition. The highest
+  /// bits in the result indicates overflow. Adjust the signs of sum and
+  /// overflow based on the signs of the inputs. The caller must sum up overflow
+  /// values and call adjustSumForOverflow after processing all inputs.
   inline static int64_t
-  addWithOverflow(int128_t& result, const int128_t& lhs, const int128_t& rhs) {
+  addWithOverflow(int128_t& result, int128_t lhs, int128_t rhs) {
     bool isLhsNegative = lhs < 0;
     bool isRhsNegative = rhs < 0;
     int64_t overflow = 0;
@@ -256,6 +411,8 @@ class DecimalUtil {
       // Both inputs of same time.
       if (isLhsNegative) {
         // Both negative, ignore signs and add.
+        VELOX_DCHECK_NE(lhs, std::numeric_limits<int128_t>::min());
+        VELOX_DCHECK_NE(rhs, std::numeric_limits<int128_t>::min());
         overflow = addUnsignedValues(result, -lhs, -rhs, true);
         overflow = -overflow;
       } else {
@@ -268,39 +425,36 @@ class DecimalUtil {
     return overflow;
   }
 
-  /*
-   * Computes average. If there is an overflow value uses the following
-   * expression to compute the average.
-   *                       ---                                         ---
-   *                      |    overflow_multiplier          sum          |
-   * average = overflow * |     -----------------  +  ---------------    |
-   *                      |         count              count * overflow  |
-   *                       ---                                         ---
-   */
-  inline static void computeAverage(
-      int128_t& avg,
-      const int128_t& sum,
-      const int64_t count,
-      const int64_t overflow) {
-    if (overflow == 0) {
-      divideWithRoundUp<int128_t, int128_t, int64_t>(
-          avg, sum, count, false, 0, 0);
-    } else {
-      __uint128_t sumA{0};
-      auto remainderA =
-          DecimalUtil::divideWithRoundUp<__uint128_t, __uint128_t, int64_t>(
-              sumA, kOverflowMultiplier, count, true, 0, 0);
-      double totalRemainder = (double)remainderA / count;
-      __uint128_t sumB{0};
-      auto remainderB =
-          DecimalUtil::divideWithRoundUp<__uint128_t, __int128_t, int64_t>(
-              sumB, sum, count * overflow, true, 0, 0);
-      totalRemainder += (double)remainderB / (count * overflow);
-      DecimalUtil::addWithOverflow(avg, sumA, sumB);
-      avg = avg * overflow + (int)(totalRemainder * overflow);
+  /// Corrects the sum result calculated using addWithOverflow. Since the sum
+  /// calculated by addWithOverflow only retains the lower 127 bits,
+  /// it may miss one calculation of +(1 << 127) or -(1 << 127).
+  /// Therefore, we need to make the following adjustments:
+  /// 1. If overflow = 1 && sum < 0, the calculation missed +(1 << 127).
+  /// Add 1 << 127 to the sum.
+  /// 2. If overflow = -1 && sum > 0, the calculation missed -(1 << 127).
+  /// Subtract 1 << 127 to the sum.
+  /// If an overflow indeed occurs and the result cannot be adjusted,
+  /// it will return std::nullopt.
+  inline static std::optional<int128_t> adjustSumForOverflow(
+      int128_t sum,
+      int64_t overflow) {
+    // Value is valid if the conditions below are true.
+    if ((overflow == 1 && sum < 0) || (overflow == -1 && sum > 0)) {
+      return static_cast<int128_t>(
+          DecimalUtil::kOverflowMultiplier * overflow + sum);
+    }
+    if (overflow != 0) {
+      // The actual overflow occurred.
+      return std::nullopt;
     }
+
+    return sum;
   }
 
+  /// avg = (sum + overflow * kOverflowMultiplier) / count
+  static void
+  computeAverage(int128_t& avg, int128_t sum, int64_t count, int64_t overflow);
+
   /// Origins from java side BigInteger#bitLength.
   ///
   /// Returns the number of bits in the minimal two's-complement
diff --git a/velox/type/DoubleUtil.cpp b/velox/type/DoubleUtil.cpp
deleted file mode 100644
index 7354e73697003..0000000000000
--- a/velox/type/DoubleUtil.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "velox/type/DoubleUtil.h"
-#include <array>
-
-namespace facebook::velox {
-
-const std::array<double, 309> DoubleUtil::kPowersOfTen = {
-    1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009, 1e010,
-    1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019, 1e020, 1e021,
-    1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029, 1e030, 1e031, 1e032,
-    1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039, 1e040, 1e041, 1e042, 1e043,
-    1e044, 1e045, 1e046, 1e047, 1e048, 1e049, 1e050, 1e051, 1e052, 1e053, 1e054,
-    1e055, 1e056, 1e057, 1e058, 1e059, 1e060, 1e061, 1e062, 1e063, 1e064, 1e065,
-    1e066, 1e067, 1e068, 1e069, 1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076,
-    1e077, 1e078, 1e079, 1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087,
-    1e088, 1e089, 1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098,
-    1e099, 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
-    1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, 1e120,
-    1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, 1e130, 1e131,
-    1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, 1e140, 1e141, 1e142,
-    1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, 1e150, 1e151, 1e152, 1e153,
-    1e154, 1e155, 1e156, 1e157, 1e158, 1e159, 1e160, 1e161, 1e162, 1e163, 1e164,
-    1e165, 1e166, 1e167, 1e168, 1e169, 1e170, 1e171, 1e172, 1e173, 1e174, 1e175,
-    1e176, 1e177, 1e178, 1e179, 1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186,
-    1e187, 1e188, 1e189, 1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197,
-    1e198, 1e199, 1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208,
-    1e209, 1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219,
-    1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229, 1e230,
-    1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239, 1e240, 1e241,
-    1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249, 1e250, 1e251, 1e252,
-    1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259, 1e260, 1e261, 1e262, 1e263,
-    1e264, 1e265, 1e266, 1e267, 1e268, 1e269, 1e270, 1e271, 1e272, 1e273, 1e274,
-    1e275, 1e276, 1e277, 1e278, 1e279, 1e280, 1e281, 1e282, 1e283, 1e284, 1e285,
-    1e286, 1e287, 1e288, 1e289, 1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296,
-    1e297, 1e298, 1e299, 1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307,
-    1e308};
-} // namespace facebook::velox
diff --git a/velox/type/DoubleUtil.h b/velox/type/DoubleUtil.h
deleted file mode 100644
index 755ee2996e867..0000000000000
--- a/velox/type/DoubleUtil.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <array>
-
-namespace facebook::velox {
-
-/// A static class that holds helper functions for DOUBLE type.
-class DoubleUtil {
- public:
-  static const std::array<double, 309> kPowersOfTen;
-
-}; // DoubleUtil
-} // namespace facebook::velox
diff --git a/velox/type/Filter.cpp b/velox/type/Filter.cpp
index 07d64b3b07630..d0f6932b4aad9 100644
--- a/velox/type/Filter.cpp
+++ b/velox/type/Filter.cpp
@@ -712,7 +712,6 @@ bool NegatedBytesValues::testingEquals(const Filter& other) const {
 
 folly::dynamic MultiRange::serialize() const {
   auto obj = Filter::serializeBase("MultiRange");
-  obj["nanAllowed"] = nanAllowed_;
   folly::dynamic arr = folly::dynamic::array;
   for (const auto& f : filters_) {
     arr.push_back(f->serialize());
@@ -723,7 +722,6 @@ folly::dynamic MultiRange::serialize() const {
 
 FilterPtr MultiRange::create(const folly::dynamic& obj) {
   auto nullAllowed = deserializeNullAllowed(obj);
-  auto nanAllowed = obj["nanAllowed"].asBool();
   folly::dynamic arr = obj["filters"];
   auto tmpFilters = ISerializable::deserialize<std::vector<Filter>>(arr);
 
@@ -733,14 +731,13 @@ FilterPtr MultiRange::create(const folly::dynamic& obj) {
     filters.emplace_back(f->clone());
   }
 
-  return std::make_unique<MultiRange>(
-      std::move(filters), nullAllowed, nanAllowed);
+  return std::make_unique<MultiRange>(std::move(filters), nullAllowed);
 }
 
 bool MultiRange::testingEquals(const Filter& other) const {
   auto otherMultiRange = dynamic_cast<const MultiRange*>(&other);
   auto res = otherMultiRange != nullptr && Filter::testingBaseEquals(other) &&
-      nanAllowed_ == otherMultiRange->nanAllowed_ &&
+
       filters_.size() == otherMultiRange->filters_.size();
 
   if (!res) {
@@ -1357,7 +1354,7 @@ std::unique_ptr<Filter> NegatedBytesRange::toMultiRange() const {
   if (accepted.size() == 1) {
     return accepted[0]->clone(nullAllowed_);
   }
-  return std::make_unique<MultiRange>(std::move(accepted), nullAllowed_, false);
+  return std::make_unique<MultiRange>(std::move(accepted), nullAllowed_);
 }
 
 bool NegatedBytesValues::testBytesRange(
@@ -1439,17 +1436,13 @@ std::unique_ptr<Filter> MultiRange::clone(
 
   if (nullAllowed) {
     return std::make_unique<MultiRange>(
-        std::move(filters), nullAllowed.value(), nanAllowed_);
+        std::move(filters), nullAllowed.value());
   } else {
-    return std::make_unique<MultiRange>(
-        std::move(filters), nullAllowed_, nanAllowed_);
+    return std::make_unique<MultiRange>(std::move(filters), nullAllowed_);
   }
 }
 
 bool MultiRange::testDouble(double value) const {
-  if (std::isnan(value)) {
-    return nanAllowed_;
-  }
   for (const auto& filter : filters_) {
     if (filter->testDouble(value)) {
       return true;
@@ -1459,9 +1452,6 @@ bool MultiRange::testDouble(double value) const {
 }
 
 bool MultiRange::testFloat(float value) const {
-  if (std::isnan(value)) {
-    return nanAllowed_;
-  }
   for (const auto& filter : filters_) {
     if (filter->testFloat(value)) {
       return true;
@@ -1554,7 +1544,6 @@ std::unique_ptr<Filter> MultiRange::mergeWith(const Filter* other) const {
     case FilterKind::kBytesRange:
     case FilterKind::kMultiRange: {
       bool bothNullAllowed = nullAllowed_ && other->testNull();
-      bool bothNanAllowed = nanAllowed_;
       std::vector<const Filter*> otherFilters;
 
       if (other->kind() == FilterKind::kMultiRange) {
@@ -1562,7 +1551,6 @@ std::unique_ptr<Filter> MultiRange::mergeWith(const Filter* other) const {
         for (auto const& filterOther : multiRangeOther->filters()) {
           otherFilters.emplace_back(filterOther.get());
         }
-        bothNanAllowed = bothNanAllowed && multiRangeOther->nanAllowed();
       } else {
         otherFilters.emplace_back(other);
       }
@@ -1614,8 +1602,7 @@ std::unique_ptr<Filter> MultiRange::mergeWith(const Filter* other) const {
       } else if (merged.size() == 1) {
         return merged.front()->clone(bothNullAllowed);
       } else {
-        return std::make_unique<MultiRange>(
-            std::move(merged), bothNullAllowed, bothNanAllowed);
+        return std::make_unique<MultiRange>(std::move(merged), bothNullAllowed);
       }
     }
     default:
@@ -2637,8 +2624,7 @@ std::unique_ptr<Filter> NegatedBytesValues::mergeWith(
           bytesRangeOther->upperUnbounded(),
           hiExclusive,
           false));
-      return std::make_unique<MultiRange>(
-          std::move(ranges), bothNullAllowed, false);
+      return std::make_unique<MultiRange>(std::move(ranges), bothNullAllowed);
     }
     default:
       VELOX_UNREACHABLE();
diff --git a/velox/type/Filter.h b/velox/type/Filter.h
index 69d12dc26b9d8..4a84992f71d04 100644
--- a/velox/type/Filter.h
+++ b/velox/type/Filter.h
@@ -310,6 +310,10 @@ class AlwaysFalse final : public Filter {
     return false;
   }
 
+  bool testNull() const final {
+    return false;
+  }
+
   bool testInt64(int64_t /* unused */) const final {
     return false;
   }
@@ -319,10 +323,19 @@ class AlwaysFalse final : public Filter {
     return false;
   }
 
+  bool testInt128(int128_t /* unused */) const final {
+    return false;
+  }
+
   bool testDouble(double /* unused */) const final {
     return false;
   }
 
+  bool testDoubleRange(double /*min*/, double /*max*/, bool /*hasNull*/)
+      const final {
+    return false;
+  }
+
   bool testFloat(float /* unused */) const final {
     return false;
   }
@@ -544,6 +557,10 @@ class IsNotNull final : public Filter {
     return true;
   }
 
+  bool testInt128(int128_t /* unused */) const final {
+    return true;
+  }
+
   bool testInt64Range(int64_t /*min*/, int64_t /*max*/, bool /*hasNull*/)
       const final {
     return true;
@@ -1260,7 +1277,6 @@ class AbstractRange : public Filter {
     return obj;
   }
 
- protected:
   const bool lowerUnbounded_;
   const bool lowerExclusive_;
   const bool upperUnbounded_;
@@ -1427,14 +1443,14 @@ class FloatingPointRange final : public AbstractRange {
         name,
         (lowerExclusive_ || lowerUnbounded_) ? "(" : "[",
         lowerUnbounded_ ? "-inf" : std::to_string(lower_),
-        upperUnbounded_ ? "+inf" : std::to_string(upper_),
-        (upperExclusive_ || upperUnbounded_) ? ")" : "]",
+        upperUnbounded_ ? "nan" : std::to_string(upper_),
+        (upperExclusive_ && !upperUnbounded_) ? ")" : "]",
         nullAllowed_ ? "with nulls" : "no nulls");
   }
 
   bool testFloatingPoint(T value) const {
     if (std::isnan(value)) {
-      return false;
+      return upperUnbounded_;
     }
     if (!lowerUnbounded_) {
       if (value < lower_) {
@@ -1480,6 +1496,10 @@ class FloatingPointRange final : public AbstractRange {
         result = values <= allUpper;
       }
     }
+    if (upperUnbounded_) {
+      auto nanResult = xsimd::isnan(values);
+      result = xsimd::bitwise_or(nanResult, result);
+    }
     return result;
   }
 
@@ -1804,6 +1824,11 @@ class TimestampRange final : public Filter {
         nullAllowed_ ? "with nulls" : "no nulls");
   }
 
+  bool testInt128(int128_t value) const final {
+    const auto& ts = reinterpret_cast<const Timestamp&>(value);
+    return ts >= lower_ && ts <= upper_;
+  }
+
   bool testTimestamp(Timestamp value) const override {
     return value >= lower_ && value <= upper_;
   }
@@ -2017,16 +2042,14 @@ class MultiRange final : public Filter {
   /// All entries must support the same data types.
   /// @param nullAllowed Null values are passing the filter if true. nullAllowed
   /// flags in the 'ranges' filters are ignored.
-  /// @param nanAllowed Not-a-Number floating point values are passing the
-  /// filter if true. Applies to floating point data types only. NaN values are
-  /// not further tested using contained filters.
+  /// TODO: remove redundant param `nanAllowed` after presto removes the use of
+  /// this param. For now, we set a default value to avoid breaking presto.
   MultiRange(
       std::vector<std::unique_ptr<Filter>> filters,
       bool nullAllowed,
-      bool nanAllowed)
+      bool nanAllowed = false)
       : Filter(true, nullAllowed, FilterKind::kMultiRange),
-        filters_(std::move(filters)),
-        nanAllowed_(nanAllowed) {}
+        filters_(std::move(filters)) {}
 
   folly::dynamic serialize() const override;
 
@@ -2058,15 +2081,10 @@ class MultiRange final : public Filter {
 
   std::unique_ptr<Filter> mergeWith(const Filter* other) const override final;
 
-  bool nanAllowed() const {
-    return nanAllowed_;
-  }
-
   bool testingEquals(const Filter& other) const final;
 
  private:
   const std::vector<std::unique_ptr<Filter>> filters_;
-  const bool nanAllowed_;
 };
 
 // Helper for applying filters to different types
diff --git a/velox/type/FloatingPointUtil.cpp b/velox/type/FloatingPointUtil.cpp
new file mode 100644
index 0000000000000..2e4fc9019b14c
--- /dev/null
+++ b/velox/type/FloatingPointUtil.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/type/FloatingPointUtil.h"
+#include <array>
+
+namespace facebook::velox {
+
+const std::array<double, 309> DoubleUtil::kPowersOfTen = {
+    1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009, 1e010,
+    1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019, 1e020, 1e021,
+    1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029, 1e030, 1e031, 1e032,
+    1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039, 1e040, 1e041, 1e042, 1e043,
+    1e044, 1e045, 1e046, 1e047, 1e048, 1e049, 1e050, 1e051, 1e052, 1e053, 1e054,
+    1e055, 1e056, 1e057, 1e058, 1e059, 1e060, 1e061, 1e062, 1e063, 1e064, 1e065,
+    1e066, 1e067, 1e068, 1e069, 1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076,
+    1e077, 1e078, 1e079, 1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087,
+    1e088, 1e089, 1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098,
+    1e099, 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
+    1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, 1e120,
+    1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, 1e130, 1e131,
+    1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, 1e140, 1e141, 1e142,
+    1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, 1e150, 1e151, 1e152, 1e153,
+    1e154, 1e155, 1e156, 1e157, 1e158, 1e159, 1e160, 1e161, 1e162, 1e163, 1e164,
+    1e165, 1e166, 1e167, 1e168, 1e169, 1e170, 1e171, 1e172, 1e173, 1e174, 1e175,
+    1e176, 1e177, 1e178, 1e179, 1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186,
+    1e187, 1e188, 1e189, 1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197,
+    1e198, 1e199, 1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208,
+    1e209, 1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219,
+    1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229, 1e230,
+    1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239, 1e240, 1e241,
+    1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249, 1e250, 1e251, 1e252,
+    1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259, 1e260, 1e261, 1e262, 1e263,
+    1e264, 1e265, 1e266, 1e267, 1e268, 1e269, 1e270, 1e271, 1e272, 1e273, 1e274,
+    1e275, 1e276, 1e277, 1e278, 1e279, 1e280, 1e281, 1e282, 1e283, 1e284, 1e285,
+    1e286, 1e287, 1e288, 1e289, 1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296,
+    1e297, 1e298, 1e299, 1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307,
+    1e308};
+} // namespace facebook::velox
diff --git a/velox/type/FloatingPointUtil.h b/velox/type/FloatingPointUtil.h
new file mode 100644
index 0000000000000..082d5d8c6c5ea
--- /dev/null
+++ b/velox/type/FloatingPointUtil.h
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <array>
+#include <cmath>
+#include <vector>
+
+#include <folly/container/F14Map.h>
+#include <folly/container/F14Set.h>
+
+namespace facebook::velox {
+
+/// Custom comparator and hash functors for floating point types. These are
+/// designed to ensure consistent NaN handling according to the following rules:
+/// -> NaN == NaN returns true, even for NaNs with differing binary
+///   representations.
+/// -> NaN is considered greater than infinity. There is no ordering between
+///    NaNs with differing binary representations.
+/// These can be passed to standard containers and functions like std::map and
+/// std::sort, etc.
+namespace util::floating_point {
+template <
+    typename FLOAT,
+    std::enable_if_t<std::is_floating_point<FLOAT>::value, bool> = true>
+struct NaNAwareEquals {
+  bool operator()(const FLOAT& lhs, const FLOAT& rhs) const {
+    if (std::isnan(lhs) && std::isnan(rhs)) {
+      return true;
+    }
+    return lhs == rhs;
+  }
+};
+
+template <
+    typename FLOAT,
+    std::enable_if_t<std::is_floating_point<FLOAT>::value, bool> = true>
+struct NaNAwareLessThan {
+  bool operator()(const FLOAT& lhs, const FLOAT& rhs) const {
+    if (!std::isnan(lhs) && std::isnan(rhs)) {
+      return true;
+    }
+    return lhs < rhs;
+  }
+};
+
+template <
+    typename FLOAT,
+    std::enable_if_t<std::is_floating_point<FLOAT>::value, bool> = true>
+struct NaNAwareLessThanEqual {
+  bool operator()(const FLOAT& lhs, const FLOAT& rhs) const {
+    if (std::isnan(rhs)) {
+      return true;
+    }
+    return lhs <= rhs;
+  }
+};
+
+template <
+    typename FLOAT,
+    std::enable_if_t<std::is_floating_point<FLOAT>::value, bool> = true>
+struct NaNAwareGreaterThan {
+  bool operator()(const FLOAT& lhs, const FLOAT& rhs) const {
+    if (std::isnan(lhs) && !std::isnan(rhs)) {
+      return true;
+    }
+    return lhs > rhs;
+  }
+};
+
+template <
+    typename FLOAT,
+    std::enable_if_t<std::is_floating_point<FLOAT>::value, bool> = true>
+struct NaNAwareGreaterThanEqual {
+  bool operator()(const FLOAT& lhs, const FLOAT& rhs) const {
+    if (std::isnan(lhs)) {
+      return true;
+    }
+    return lhs >= rhs;
+  }
+};
+
+template <
+    typename FLOAT,
+    std::enable_if_t<std::is_floating_point<FLOAT>::value, bool> = true>
+struct NaNAwareHash {
+  std::size_t operator()(const FLOAT& val) const noexcept {
+    static const std::size_t kNanHash =
+        folly::hasher<FLOAT>{}(std::numeric_limits<FLOAT>::quiet_NaN());
+    if (std::isnan(val)) {
+      return kNanHash;
+    }
+    return folly::hasher<FLOAT>{}(val);
+  }
+};
+
+// Utility struct to provide a clean way of defining a hash set and map type
+// using folly::F14FastSet and folly::F14FastMap respectively with overrides for
+// floating point types.
+template <typename Key>
+class HashSetNaNAware : public folly::F14FastSet<Key> {};
+
+template <>
+class HashSetNaNAware<float>
+    : public folly::
+          F14FastSet<float, NaNAwareHash<float>, NaNAwareEquals<float>> {};
+
+template <>
+class HashSetNaNAware<double>
+    : public folly::
+          F14FastSet<double, NaNAwareHash<double>, NaNAwareEquals<double>> {};
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Alloc = folly::f14::DefaultAlloc<std::pair<Key const, Mapped>>>
+struct HashMapNaNAwareTypeTraits {
+  using Type = folly::F14FastMap<
+      Key,
+      Mapped,
+      folly::f14::DefaultHasher<Key>,
+      folly::f14::DefaultKeyEqual<Key>,
+      Alloc>;
+};
+
+template <typename Mapped, typename Alloc>
+struct HashMapNaNAwareTypeTraits<float, Mapped, Alloc> {
+  using Type = folly::F14FastMap<
+      float,
+      Mapped,
+      NaNAwareHash<float>,
+      NaNAwareEquals<float>,
+      Alloc>;
+};
+
+template <typename Mapped, typename Alloc>
+struct HashMapNaNAwareTypeTraits<double, Mapped, Alloc> {
+  using Type = folly::F14FastMap<
+      double,
+      Mapped,
+      NaNAwareHash<double>,
+      NaNAwareEquals<double>,
+      Alloc>;
+};
+} // namespace util::floating_point
+
+/// A static class that holds helper functions for DOUBLE type.
+class DoubleUtil {
+ public:
+  static const std::array<double, 309> kPowersOfTen;
+
+}; // DoubleUtil
+} // namespace facebook::velox
diff --git a/velox/type/HugeInt.cpp b/velox/type/HugeInt.cpp
index c197aa3d25596..45e4a3079da15 100644
--- a/velox/type/HugeInt.cpp
+++ b/velox/type/HugeInt.cpp
@@ -39,7 +39,9 @@ int128_t HugeInt::parse(const std::string& str) {
   int128_t min = std::numeric_limits<int128_t>::min();
   for (; idx < str.size(); ++idx) {
     VELOX_CHECK(
-        std::isdigit(str[idx]), "Invalid character {} in the string.", str[idx])
+        std::isdigit(str[idx]),
+        "Invalid character {} in the string.",
+        str[idx]);
 
     // Throw error if the result is out of the range of int128_t, and return the
     // result before computing the last digit if the digit string would be the
diff --git a/velox/type/OpaqueCustomTypes.h b/velox/type/OpaqueCustomTypes.h
index fdb42d3d94a05..6450c1c47c880 100644
--- a/velox/type/OpaqueCustomTypes.h
+++ b/velox/type/OpaqueCustomTypes.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
@@ -33,11 +34,15 @@ class CastOperator;
 template <typename T, const char* customTypeName>
 class OpaqueCustomTypeRegister {
  public:
-  static void registerType() {
-    facebook::velox::registerCustomType(
+  static bool registerType() {
+    return facebook::velox::registerCustomType(
         customTypeName, std::make_unique<const TypeFactory>());
   }
 
+  static bool unregisterType() {
+    return facebook::velox::unregisterCustomType(customTypeName);
+  }
+
   // Type used in the simple function interface as CustomType<TypeT>.
   struct TypeT {
     using type = std::shared_ptr<T>;
diff --git a/velox/type/SimpleFunctionApi.h b/velox/type/SimpleFunctionApi.h
new file mode 100644
index 0000000000000..70848cfc79531
--- /dev/null
+++ b/velox/type/SimpleFunctionApi.h
@@ -0,0 +1,422 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/type/CppToType.h"
+
+namespace facebook::velox {
+
+template <typename UNDERLYING_TYPE>
+struct Variadic {
+  using underlying_type = UNDERLYING_TYPE;
+
+  Variadic() = delete;
+};
+
+// A type that can be used in simple function to represent any type.
+// Two Generics with the same type variables should bound to the same type.
+template <size_t id>
+struct TypeVariable {
+  static size_t getId() {
+    return id;
+  }
+};
+
+using T1 = TypeVariable<1>;
+using T2 = TypeVariable<2>;
+using T3 = TypeVariable<3>;
+using T4 = TypeVariable<4>;
+using T5 = TypeVariable<5>;
+using T6 = TypeVariable<6>;
+using T7 = TypeVariable<7>;
+using T8 = TypeVariable<8>;
+
+template <size_t id>
+struct IntegerVariable {
+  static size_t getId() {
+    return id;
+  }
+
+  static std::string name() {
+    return fmt::format("i{}", id);
+  }
+};
+
+using P1 = IntegerVariable<1>;
+using P2 = IntegerVariable<2>;
+using P3 = IntegerVariable<3>;
+using P4 = IntegerVariable<4>;
+using S1 = IntegerVariable<5>;
+using S2 = IntegerVariable<6>;
+using S3 = IntegerVariable<7>;
+using S4 = IntegerVariable<8>;
+
+template <typename P, typename S>
+struct ShortDecimal {
+ private:
+  ShortDecimal() {}
+};
+
+template <typename P, typename S>
+struct LongDecimal {
+ private:
+  LongDecimal() {}
+};
+
+struct AnyType {};
+
+template <typename T = AnyType, bool comparable = false, bool orderable = false>
+struct Generic {
+  Generic() = delete;
+  static_assert(!(orderable && !comparable), "Orderable implies comparable.");
+};
+
+using Any = Generic<>;
+
+template <typename T>
+using Comparable = Generic<T, true, false>;
+
+// Orderable implies comparable.
+template <typename T>
+using Orderable = Generic<T, true, true>;
+
+template <typename>
+struct isVariadicType : public std::false_type {};
+
+template <typename T>
+struct isVariadicType<Variadic<T>> : public std::true_type {};
+
+template <typename>
+struct isGenericType : public std::false_type {};
+
+template <typename T, bool comparable, bool orderable>
+struct isGenericType<Generic<T, comparable, orderable>>
+    : public std::true_type {};
+
+template <typename>
+struct isOpaqueType : public std::false_type {};
+
+template <typename T>
+struct isOpaqueType<std::shared_ptr<T>> : public std::true_type {};
+
+template <typename KEY, typename VALUE>
+struct Map {
+  using key_type = KEY;
+  using value_type = VALUE;
+
+  static_assert(
+      !isVariadicType<key_type>::value,
+      "Map keys cannot be Variadic");
+  static_assert(
+      !isVariadicType<value_type>::value,
+      "Map values cannot be Variadic");
+
+ private:
+  Map() {}
+};
+
+template <typename ELEMENT>
+struct Array {
+  using element_type = ELEMENT;
+
+  static_assert(
+      !isVariadicType<element_type>::value,
+      "Array elements cannot be Variadic");
+
+ private:
+  Array() {}
+};
+
+template <typename ELEMENT>
+using ArrayWriterT = Array<ELEMENT>;
+
+template <typename... T>
+struct Row {
+  template <size_t idx>
+  using type_at = typename std::tuple_element<idx, std::tuple<T...>>::type;
+
+  static const size_t size_ = sizeof...(T);
+
+  static_assert(
+      std::conjunction<std::bool_constant<!isVariadicType<T>::value>...>::value,
+      "Struct fields cannot be Variadic");
+
+ private:
+  Row() {}
+};
+
+struct DynamicRow {
+ private:
+  DynamicRow() {}
+};
+
+// T must be a struct with T::type being a built-in type and T::typeName
+// type name to use in FunctionSignature.
+template <typename T>
+struct CustomType {
+ private:
+  CustomType() {}
+};
+
+template <typename T>
+struct UnwrapCustomType {
+  using type = T;
+};
+
+template <typename T>
+struct UnwrapCustomType<CustomType<T>> {
+  using type = typename T::type;
+};
+
+struct IntervalDayTime {
+ private:
+  IntervalDayTime() {}
+};
+
+struct IntervalYearMonth {
+ private:
+  IntervalYearMonth() {}
+};
+
+struct Date {
+ private:
+  Date() {}
+};
+
+struct Varbinary {
+ private:
+  Varbinary() {}
+};
+
+struct Varchar {
+ private:
+  Varchar() {}
+};
+
+template <typename T>
+struct Constant {};
+
+template <typename T>
+struct UnwrapConstantType {
+  using type = T;
+};
+
+template <typename T>
+struct UnwrapConstantType<Constant<T>> {
+  using type = T;
+};
+
+template <typename T>
+struct isConstantType {
+  static constexpr bool value = false;
+};
+
+template <typename T>
+struct isConstantType<Constant<T>> {
+  static constexpr bool value = true;
+};
+
+template <typename... TArgs>
+struct ConstantChecker {
+  static constexpr bool isConstant[sizeof...(TArgs)] = {
+      isConstantType<TArgs>::value...};
+};
+
+/// CppToType templates for types introduced above.
+
+template <>
+struct CppToType<Varchar> : public CppToTypeBase<TypeKind::VARCHAR> {};
+
+template <>
+struct CppToType<Varbinary> : public CppToTypeBase<TypeKind::VARBINARY> {};
+
+template <>
+struct CppToType<Date> : public CppToTypeBase<TypeKind::INTEGER> {};
+
+template <typename T>
+struct CppToType<Generic<T>> : public CppToTypeBase<TypeKind::UNKNOWN> {};
+
+template <typename KEY, typename VAL>
+struct CppToType<Map<KEY, VAL>> : public TypeTraits<TypeKind::MAP> {
+  static auto create() {
+    return MAP(CppToType<KEY>::create(), CppToType<VAL>::create());
+  }
+};
+
+template <typename ELEMENT>
+struct CppToType<Array<ELEMENT>> : public TypeTraits<TypeKind::ARRAY> {
+  static auto create() {
+    return ARRAY(CppToType<ELEMENT>::create());
+  }
+};
+
+template <typename... T>
+struct CppToType<Row<T...>> : public TypeTraits<TypeKind::ROW> {
+  static auto create() {
+    return ROW({CppToType<T>::create()...});
+  }
+};
+
+template <>
+struct CppToType<DynamicRow> : public TypeTraits<TypeKind::ROW> {
+  static std::shared_ptr<const Type> create() {
+    throw std::logic_error{"can't determine exact type for DynamicRow"};
+  }
+};
+
+template <typename T>
+struct CppToType<CustomType<T>> : public CppToType<typename T::type> {
+  static auto create() {
+    return CppToType<typename T::type>::create();
+  }
+};
+
+/// SimpleTypeTrait template.
+
+template <typename P, typename S>
+struct SimpleTypeTrait<ShortDecimal<P, S>>
+    : public TypeTraits<TypeKind::BIGINT> {};
+
+template <typename P, typename S>
+struct SimpleTypeTrait<LongDecimal<P, S>>
+    : public TypeTraits<TypeKind::HUGEINT> {};
+
+template <>
+struct SimpleTypeTrait<Varchar> : public TypeTraits<TypeKind::VARCHAR> {};
+
+template <>
+struct SimpleTypeTrait<Varbinary> : public TypeTraits<TypeKind::VARBINARY> {};
+
+template <>
+struct SimpleTypeTrait<Date> : public SimpleTypeTrait<int32_t> {
+  static constexpr const char* name = "DATE";
+};
+
+template <>
+struct SimpleTypeTrait<IntervalDayTime> : public SimpleTypeTrait<int64_t> {
+  static constexpr const char* name = "INTERVAL DAY TO SECOND";
+};
+
+template <>
+struct SimpleTypeTrait<IntervalYearMonth> : public SimpleTypeTrait<int32_t> {
+  static constexpr const char* name = "INTERVAL YEAR TO MONTH";
+};
+
+template <typename T, bool comparable, bool orderable>
+struct SimpleTypeTrait<Generic<T, comparable, orderable>> {
+  static constexpr TypeKind typeKind = TypeKind::UNKNOWN;
+  static constexpr bool isPrimitiveType = false;
+  static constexpr bool isFixedWidth = false;
+};
+
+template <typename T>
+struct SimpleTypeTrait<std::shared_ptr<T>>
+    : public TypeTraits<TypeKind::OPAQUE> {};
+
+template <typename KEY, typename VAL>
+struct SimpleTypeTrait<Map<KEY, VAL>> : public TypeTraits<TypeKind::MAP> {};
+
+template <typename ELEMENT>
+struct SimpleTypeTrait<Array<ELEMENT>> : public TypeTraits<TypeKind::ARRAY> {};
+
+template <typename... T>
+struct SimpleTypeTrait<Row<T...>> : public TypeTraits<TypeKind::ROW> {};
+
+template <>
+struct SimpleTypeTrait<DynamicRow> : public TypeTraits<TypeKind::ROW> {};
+
+// T is also a simple type that represent the physical type of the custom type.
+template <typename T>
+struct SimpleTypeTrait<CustomType<T>>
+    : public SimpleTypeTrait<typename T::type> {
+  using physical_t = SimpleTypeTrait<typename T::type>;
+  static constexpr TypeKind typeKind = physical_t::typeKind;
+  static constexpr bool isPrimitiveType = physical_t::isPrimitiveType;
+  static constexpr bool isFixedWidth = physical_t::isFixedWidth;
+
+  // This is different than the physical type name.
+  static constexpr char* name = T::typeName;
+};
+
+/// MaterializeType template.
+
+template <typename T>
+struct MaterializeType {
+  using null_free_t = T;
+  using nullable_t = T;
+  static constexpr bool requiresMaterialization = false;
+};
+
+template <typename V>
+struct MaterializeType<Array<V>> {
+  using null_free_t = std::vector<typename MaterializeType<V>::null_free_t>;
+  using nullable_t =
+      std::vector<std::optional<typename MaterializeType<V>::nullable_t>>;
+  static constexpr bool requiresMaterialization = true;
+};
+
+template <typename K, typename V>
+struct MaterializeType<Map<K, V>> {
+  using key_t = typename MaterializeType<K>::null_free_t;
+
+  using nullable_t = folly::
+      F14FastMap<key_t, std::optional<typename MaterializeType<V>::nullable_t>>;
+
+  using null_free_t =
+      folly::F14FastMap<key_t, typename MaterializeType<V>::null_free_t>;
+  static constexpr bool requiresMaterialization = true;
+};
+
+template <typename... T>
+struct MaterializeType<Row<T...>> {
+  using nullable_t =
+      std::tuple<std::optional<typename MaterializeType<T>::nullable_t>...>;
+
+  using null_free_t = std::tuple<typename MaterializeType<T>::null_free_t...>;
+  static constexpr bool requiresMaterialization = true;
+};
+
+template <typename T>
+struct MaterializeType<std::shared_ptr<T>> {
+  using nullable_t = T;
+  using null_free_t = T;
+  static constexpr bool requiresMaterialization = false;
+};
+
+template <typename T>
+struct MaterializeType<CustomType<T>> {
+  using inner_materialize_t = MaterializeType<typename T::type>;
+  using nullable_t = typename inner_materialize_t::nullable_t;
+  using null_free_t = typename inner_materialize_t::null_free_t;
+  static constexpr bool requiresMaterialization =
+      inner_materialize_t::requiresMaterialization;
+};
+
+template <>
+struct MaterializeType<Varchar> {
+  using nullable_t = std::string;
+  using null_free_t = std::string;
+  static constexpr bool requiresMaterialization = false;
+};
+
+template <>
+struct MaterializeType<Varbinary> {
+  using nullable_t = std::string;
+  using null_free_t = std::string;
+  static constexpr bool requiresMaterialization = false;
+};
+
+} // namespace facebook::velox
diff --git a/velox/type/StringView.h b/velox/type/StringView.h
index fdf98de42de17..ea070efb3c9d0 100644
--- a/velox/type/StringView.h
+++ b/velox/type/StringView.h
@@ -296,8 +296,7 @@ namespace folly {
 template <>
 struct hasher<::facebook::velox::StringView> {
   size_t operator()(const ::facebook::velox::StringView view) const {
-    return hash::SpookyHashV2::Hash64(view.data(), view.size(), 0);
-    // return facebook::velox::bits::hashBytes(1, view.data(), view.size());
+    return facebook::velox::bits::hashBytes(1, view.data(), view.size());
   }
 };
 
diff --git a/velox/type/Subfield.cpp b/velox/type/Subfield.cpp
index 87e3de4a3490c..3994e6ee5ab64 100644
--- a/velox/type/Subfield.cpp
+++ b/velox/type/Subfield.cpp
@@ -40,7 +40,7 @@ Subfield::Subfield(
 Subfield::Subfield(std::vector<std::unique_ptr<Subfield::PathElement>>&& path)
     : path_(std::move(path)) {
   VELOX_CHECK_GE(path_.size(), 1);
-};
+}
 
 Subfield Subfield::clone() const {
   Subfield subfield;
diff --git a/velox/type/Subfield.h b/velox/type/Subfield.h
index 5aa74c5c8c630..9fc7f343b2147 100644
--- a/velox/type/Subfield.h
+++ b/velox/type/Subfield.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <boost/algorithm/string/replace.hpp>
+#include <fmt/format.h>
 #include <ostream>
 
 #include "velox/common/base/Exceptions.h"
@@ -95,7 +96,8 @@ class Subfield {
   class NestedField final : public PathElement {
    public:
     explicit NestedField(const std::string& name) : name_(name) {
-      VELOX_USER_CHECK_NE(name, "", "NestedFields must have non-empty names.");
+      VELOX_USER_CHECK(
+          !name.empty(), "NestedFields must have non-empty names.");
     }
 
     SubfieldKind kind() const override {
@@ -217,7 +219,6 @@ class Subfield {
     const std::string index_;
   };
 
- public:
   // Separators: the customized separators to tokenize field name.
   explicit Subfield(
       const std::string& path,
@@ -313,3 +314,22 @@ struct hash<::facebook::velox::common::Subfield> {
   }
 };
 } // namespace std
+
+template <>
+struct fmt::formatter<::facebook::velox::common::Subfield>
+    : formatter<std::string> {
+  auto format(const ::facebook::velox::common::Subfield& s, format_context& ctx)
+      const {
+    return formatter<std::string>::format(s.toString(), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<::facebook::velox::common::SubfieldKind>
+    : formatter<int> {
+  auto format(
+      const ::facebook::velox::common::SubfieldKind& s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/type/Timestamp.cpp b/velox/type/Timestamp.cpp
index 65024095bdc4c..4d84b8b7071eb 100644
--- a/velox/type/Timestamp.cpp
+++ b/velox/type/Timestamp.cpp
@@ -14,27 +14,26 @@
  * limitations under the License.
  */
 #include "velox/type/Timestamp.h"
+#include <charconv>
 #include <chrono>
-#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/CountBits.h"
 #include "velox/external/date/tz.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox {
-namespace {
-
-// Assuming tzID is in [1, 1680] range.
-// tzID - PrestoDB time zone ID.
-inline int64_t getPrestoTZOffsetInSeconds(int16_t tzID) {
-  // TODO(spershin): Maybe we need something better if we can (we could use
-  //  precomputed vector for PrestoDB timezones, for instance).
 
-  // PrestoDb time zone ids require some custom code.
-  // Mapping is 1-based and covers [-14:00, +14:00] range without 00:00.
-  return ((tzID <= 840) ? (tzID - 841) : (tzID - 840)) * 60;
+// static
+Timestamp Timestamp::fromDaysAndNanos(int32_t days, int64_t nanos) {
+  int64_t seconds =
+      (days - kJulianToUnixEpochDays) * kSecondsInDay + nanos / kNanosInSecond;
+  int64_t remainingNanos = nanos % kNanosInSecond;
+  if (remainingNanos < 0) {
+    remainingNanos += kNanosInSecond;
+    seconds--;
+  }
+  return Timestamp(seconds, remainingNanos);
 }
 
-} // namespace
-
 // static
 Timestamp Timestamp::now() {
   auto now = std::chrono::system_clock::now();
@@ -44,84 +43,68 @@ Timestamp Timestamp::now() {
   return fromMillis(epochMs);
 }
 
-void Timestamp::toGMT(const date::time_zone& zone) {
-  // Magic number -2^39 + 24*3600. This number and any number lower than that
-  // will cause time_zone::to_sys() to SIGABRT. We don't want that to happen.
-  if (seconds_ <= (-1096193779200l + 86400l)) {
-    VELOX_UNSUPPORTED(
-        "Timestamp out of bound for time zone adjustment {} seconds", seconds_);
-  }
-  date::local_time<std::chrono::seconds> localTime{
-      std::chrono::seconds(seconds_)};
-  std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>
-      sysTime = zone.to_sys(localTime, date::choose::latest);
-  seconds_ = sysTime.time_since_epoch().count();
-}
-
-void Timestamp::toGMT(int16_t tzID) {
-  if (tzID == 0) {
-    // No conversion required for time zone id 0, as it is '+00:00'.
-  } else if (tzID <= 1680) {
-    seconds_ -= getPrestoTZOffsetInSeconds(tzID);
-  } else {
-    // Other ids go this path.
-    toGMT(*date::locate_zone(util::getTimeZoneName(tzID)));
-  }
-}
+void Timestamp::toGMT(const tz::TimeZone& zone) {
+  std::chrono::seconds sysSeconds;
 
-namespace {
-void validateTimePoint(const std::chrono::time_point<
-                       std::chrono::system_clock,
-                       std::chrono::milliseconds>& timePoint) {
-  // Due to the limit of std::chrono we can only represent time in
-  // [-32767-01-01, 32767-12-31] date range
-  const auto minTimePoint = date::sys_days{
-      date::year_month_day(date::year::min(), date::month(1), date::day(1))};
-  const auto maxTimePoint = date::sys_days{
-      date::year_month_day(date::year::max(), date::month(12), date::day(31))};
-  if (timePoint < minTimePoint || timePoint > maxTimePoint) {
-    VELOX_USER_FAIL(
-        "Timestamp is outside of supported range of [{}-{}-{}, {}-{}-{}]",
-        (int)date::year::min(),
-        "01",
-        "01",
-        (int)date::year::max(),
-        "12",
-        "31");
+  try {
+    sysSeconds = zone.to_sys(std::chrono::seconds(seconds_));
+  } catch (const date::ambiguous_local_time&) {
+    // If the time is ambiguous, pick the earlier possibility to be consistent
+    // with Presto.
+    sysSeconds = zone.to_sys(
+        std::chrono::seconds(seconds_), tz::TimeZone::TChoose::kEarliest);
+  } catch (const date::nonexistent_local_time& error) {
+    // If the time does not exist, fail the conversion.
+    VELOX_USER_FAIL(error.what());
+  } catch (const std::invalid_argument& e) {
+    // Invalid argument means we hit a conversion not supported by
+    // external/date. Need to throw a RuntimeError so that try() statements do
+    // not suppress it.
+    VELOX_FAIL(e.what());
   }
+  seconds_ = sysSeconds.count();
 }
-} // namespace
 
 std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>
-Timestamp::toTimePoint() const {
+Timestamp::toTimePointMs(bool allowOverflow) const {
   using namespace std::chrono;
-  auto tp = time_point<system_clock, milliseconds>(milliseconds(toMillis()));
-  validateTimePoint(tp);
+  auto tp = time_point<system_clock, milliseconds>(
+      milliseconds(allowOverflow ? toMillisAllowOverflow() : toMillis()));
+  tz::validateRange(tp);
   return tp;
 }
 
-void Timestamp::toTimezone(const date::time_zone& zone) {
-  auto tp = toTimePoint();
-  auto epoch = zone.to_local(tp).time_since_epoch();
-  // NOTE: Round down to get the seconds of the current time point.
-  seconds_ = std::chrono::floor<std::chrono::seconds>(epoch).count();
+void Timestamp::toTimezone(const tz::TimeZone& zone) {
+  try {
+    seconds_ = zone.to_local(std::chrono::seconds(seconds_)).count();
+  } catch (const std::invalid_argument& e) {
+    // Invalid argument means we hit a conversion not supported by
+    // external/date. This is a special case where we intentionally throw
+    // VeloxRuntimeError to avoid it being suppressed by TRY().
+    VELOX_FAIL_UNSUPPORTED_INPUT_UNCATCHABLE(e.what());
+  }
 }
 
-void Timestamp::toTimezone(int16_t tzID) {
-  if (tzID == 0) {
-    // No conversion required for time zone id 0, as it is '+00:00'.
-  } else if (tzID <= 1680) {
-    seconds_ += getPrestoTZOffsetInSeconds(tzID);
-  } else {
-    // Other ids go this path.
-    toTimezone(*date::locate_zone(util::getTimeZoneName(tzID)));
-  }
+const tz::TimeZone& Timestamp::defaultTimezone() {
+  static const tz::TimeZone* kDefault = ({
+    // TODO: We are hard-coding PST/PDT here to be aligned with the current
+    // behavior in DWRF reader/writer.  Once they are fixed, we can use
+    // date::current_zone() here.
+    //
+    // See https://github.com/facebookincubator/velox/issues/8127
+    auto* tz = tz::locateZone("America/Los_Angeles");
+    VELOX_CHECK_NOT_NULL(tz);
+    tz;
+  });
+  return *kDefault;
 }
 
 namespace {
 
 constexpr int kTmYearBase = 1900;
 constexpr int64_t kLeapYearOffset = 4000000000ll;
+constexpr int64_t kSecondsPerHour = 3600;
+constexpr int64_t kSecondsPerDay = 24 * kSecondsPerHour;
 
 inline bool isLeap(int64_t y) {
   return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
@@ -134,33 +117,18 @@ inline int64_t leapThroughEndOf(int64_t y) {
   return y / 4 - y / 100 + y / 400;
 }
 
-const int monthLengths[][12] = {
-    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
-    {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
-};
+inline int64_t daysBetweenYears(int64_t y1, int64_t y2) {
+  return 365 * (y2 - y1) + leapThroughEndOf(y2 - 1) - leapThroughEndOf(y1 - 1);
+}
 
-// clang-format off
-const char intToStr[][3] = {
-    "00", "01", "02", "03", "04", "05", "06", "07", "08", "09",
-    "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
-    "20", "21", "22", "23", "24", "25", "26", "27", "28", "29",
-    "30", "31", "32", "33", "34", "35", "36", "37", "38", "39",
-    "40", "41", "42", "43", "44", "45", "46", "47", "48", "49",
-    "50", "51", "52", "53", "54", "55", "56", "57", "58", "59",
-    "60", "61",
+const int16_t daysBeforeFirstDayOfMonth[][12] = {
+    {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
+    {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335},
 };
-// clang-format on
-
-void appendSmallInt(int n, std::string& out) {
-  VELOX_DCHECK_LE(n, 61);
-  out.append(intToStr[n], 2);
-}
 
 } // namespace
 
-bool epochToUtc(int64_t epoch, std::tm& tm) {
-  constexpr int kSecondsPerHour = 3600;
-  constexpr int kSecondsPerDay = 24 * kSecondsPerHour;
+bool Timestamp::epochToCalendarUtc(int64_t epoch, std::tm& tm) {
   constexpr int kDaysPerYear = 365;
   int64_t days = epoch / kSecondsPerDay;
   int64_t rem = epoch % kSecondsPerDay;
@@ -183,8 +151,7 @@ bool epochToUtc(int64_t epoch, std::tm& tm) {
   bool leapYear;
   while (days < 0 || days >= kDaysPerYear + (leapYear = isLeap(y))) {
     auto newy = y + days / kDaysPerYear - (days < 0);
-    days -= (newy - y) * kDaysPerYear + leapThroughEndOf(newy - 1) -
-        leapThroughEndOf(y - 1);
+    days -= daysBetweenYears(y, newy);
     y = newy;
   }
   y -= kTmYearBase;
@@ -194,67 +161,188 @@ bool epochToUtc(int64_t epoch, std::tm& tm) {
   }
   tm.tm_year = y;
   tm.tm_yday = days;
-  auto* ip = monthLengths[leapYear];
-  for (tm.tm_mon = 0; days >= ip[tm.tm_mon]; ++tm.tm_mon) {
-    days = days - ip[tm.tm_mon];
-  }
-  tm.tm_mday = days + 1;
+  auto* months = daysBeforeFirstDayOfMonth[leapYear];
+  tm.tm_mon = std::upper_bound(months, months + 12, days) - months - 1;
+  tm.tm_mday = days - months[tm.tm_mon] + 1;
   tm.tm_isdst = 0;
   return true;
 }
 
-std::string tmToString(
+// static
+int64_t Timestamp::calendarUtcToEpoch(const std::tm& tm) {
+  static_assert(sizeof(decltype(tm.tm_year)) == 4);
+  // tm_year stores number of years since 1900.
+  int64_t year = tm.tm_year + 1900LL;
+  int64_t month = tm.tm_mon;
+  if (FOLLY_UNLIKELY(month > 11)) {
+    year += month / 12;
+    month %= 12;
+  } else if (FOLLY_UNLIKELY(month < 0)) {
+    auto yearsDiff = (-month + 11) / 12;
+    year -= yearsDiff;
+    month += 12 * yearsDiff;
+  }
+  // Getting number of days since beginning of the year.
+  auto dayOfYear =
+      -1ll + daysBeforeFirstDayOfMonth[isLeap(year)][month] + tm.tm_mday;
+  // Number of days since 1970-01-01.
+  auto daysSinceEpoch = daysBetweenYears(1970, year) + dayOfYear;
+  return kSecondsPerDay * daysSinceEpoch + kSecondsPerHour * tm.tm_hour +
+      60ll * tm.tm_min + tm.tm_sec;
+}
+
+StringView Timestamp::tmToStringView(
     const std::tm& tmValue,
-    int nanos,
-    const TimestampToStringOptions& options) {
-  VELOX_DCHECK_GE(nanos, 0);
+    uint64_t nanos,
+    const TimestampToStringOptions& options,
+    char* const startPosition) {
   VELOX_DCHECK_LT(nanos, 1'000'000'000);
-  int width = options.precision;
-  std::string out;
-  out.reserve(options.dateOnly ? 10 : 26 + width);
-  int n = kTmYearBase + tmValue.tm_year;
-  bool negative = n < 0;
-  if (negative) {
-    out += '-';
-    n = -n;
-  }
-  while (n > 0) {
-    out += '0' + n % 10;
-    n /= 10;
-  }
-  if (options.zeroPaddingYear && out.size() < negative + 4) {
-    while (out.size() < negative + 4) {
-      out += '0';
+
+  const auto appendDigits = [](const int value,
+                               const std::optional<uint32_t> minWidth,
+                               char* const position) {
+    const auto numDigits = countDigits(value);
+    uint32_t offset = 0;
+    // Append leading zeros when there is the requirement for minumum width.
+    if (minWidth.has_value() && numDigits < minWidth.value()) {
+      const auto leadingZeros = minWidth.value() - numDigits;
+      std::memset(position, '0', leadingZeros);
+      offset += leadingZeros;
     }
+    const auto [endPosition, errorCode] =
+        std::to_chars(position + offset, position + offset + numDigits, value);
+    VELOX_DCHECK_EQ(
+        errorCode,
+        std::errc(),
+        "Failed to convert value to varchar: {}.",
+        std::make_error_code(errorCode).message());
+    offset += numDigits;
+    return offset;
+  };
+
+  char* writePosition = startPosition;
+  if (options.mode != TimestampToStringOptions::Mode::kTimeOnly) {
+    int year = kTmYearBase + tmValue.tm_year;
+    const bool leadingPositiveSign = options.leadingPositiveSign && year > 9999;
+    const bool negative = year < 0;
+
+    // Sign.
+    if (negative) {
+      *writePosition++ = '-';
+      year = -year;
+    } else if (leadingPositiveSign) {
+      *writePosition++ = '+';
+    }
+
+    // Year.
+    writePosition += appendDigits(
+        year,
+        options.zeroPaddingYear ? std::optional<uint32_t>(4) : std::nullopt,
+        writePosition);
+
+    // Month.
+    *writePosition++ = '-';
+    writePosition += appendDigits(1 + tmValue.tm_mon, 2, writePosition);
+
+    // Day.
+    *writePosition++ = '-';
+    writePosition += appendDigits(tmValue.tm_mday, 2, writePosition);
+
+    if (options.mode == TimestampToStringOptions::Mode::kDateOnly) {
+      return StringView(startPosition, writePosition - startPosition);
+    }
+    *writePosition++ = options.dateTimeSeparator;
   }
-  std::reverse(out.begin() + negative, out.end());
-  out += '-';
-  appendSmallInt(1 + tmValue.tm_mon, out);
-  out += '-';
-  appendSmallInt(tmValue.tm_mday, out);
-  if (options.dateOnly) {
-    return out;
-  }
-  out += options.dateTimeSeparator;
-  appendSmallInt(tmValue.tm_hour, out);
-  out += ':';
-  appendSmallInt(tmValue.tm_min, out);
-  out += ':';
-  appendSmallInt(tmValue.tm_sec, out);
-  out += '.';
-  int offset = out.size();
-  if (options.precision == TimestampToStringOptions::kMilliseconds) {
+
+  // Hour.
+  writePosition += appendDigits(tmValue.tm_hour, 2, writePosition);
+
+  // Minute.
+  *writePosition++ = ':';
+  writePosition += appendDigits(tmValue.tm_min, 2, writePosition);
+
+  // Second.
+  *writePosition++ = ':';
+  writePosition += appendDigits(tmValue.tm_sec, 2, writePosition);
+
+  if (options.precision == TimestampToStringOptions::Precision::kMilliseconds) {
     nanos /= 1'000'000;
+  } else if (
+      options.precision == TimestampToStringOptions::Precision::kMicroseconds) {
+    nanos /= 1'000;
   }
-  while (nanos > 0) {
-    out += '0' + nanos % 10;
-    nanos /= 10;
+  if (options.skipTrailingZeros && nanos == 0) {
+    return StringView(startPosition, writePosition - startPosition);
   }
-  while (out.size() - offset < width) {
-    out += '0';
+
+  // Fractional part.
+  *writePosition++ = '.';
+  // Append leading zeros.
+  const auto numDigits = countDigits(nanos);
+  const auto precisionWidth = static_cast<int8_t>(options.precision);
+  std::memset(writePosition, '0', precisionWidth - numDigits);
+  writePosition += precisionWidth - numDigits;
+
+  // Append the remaining numeric digits.
+  if (options.skipTrailingZeros) {
+    std::optional<uint32_t> nonZeroOffset = std::nullopt;
+    int32_t offset = numDigits - 1;
+    // Write non-zero digits from end to start.
+    while (nanos > 0) {
+      if (nonZeroOffset.has_value() || nanos % 10 != 0) {
+        *(writePosition + offset) = '0' + nanos % 10;
+        if (!nonZeroOffset.has_value()) {
+          nonZeroOffset = offset;
+        }
+      }
+      --offset;
+      nanos /= 10;
+    }
+    writePosition += nonZeroOffset.value() + 1;
+  } else {
+    const auto [position, errorCode] =
+        std::to_chars(writePosition, writePosition + numDigits, nanos);
+    VELOX_DCHECK_EQ(
+        errorCode,
+        std::errc(),
+        "Failed to convert fractional part to chars: {}.",
+        std::make_error_code(errorCode).message());
+    writePosition = position;
+  }
+  return StringView(startPosition, writePosition - startPosition);
+}
+
+StringView Timestamp::tsToStringView(
+    const Timestamp& ts,
+    const TimestampToStringOptions& options,
+    char* const startPosition) {
+  std::tm tmValue;
+  VELOX_USER_CHECK(
+      epochToCalendarUtc(ts.getSeconds(), tmValue),
+      "Can't convert seconds to time: {}",
+      ts.getSeconds());
+  const uint64_t nanos = ts.getNanos();
+  return tmToStringView(tmValue, nanos, options, startPosition);
+}
+
+std::string::size_type getMaxStringLength(
+    const TimestampToStringOptions& options) {
+  const auto precisionWidth = static_cast<int8_t>(options.precision);
+  switch (options.mode) {
+    case TimestampToStringOptions::Mode::kDateOnly:
+      // Date format is %y-mm-dd, where y has 10 digits at maximum for int32.
+      // Possible sign is considered.
+      return 17;
+    case TimestampToStringOptions::Mode::kTimeOnly:
+      // hh:mm:ss.precision
+      return 9 + precisionWidth;
+    case TimestampToStringOptions::Mode::kFull:
+      // Timestamp format is %y-%m-%dT%h:%m:%s.precision, where y has 10 digits
+      // at maximum for int32. Possible sign is considered.
+      return 27 + precisionWidth;
+    default:
+      VELOX_UNREACHABLE();
   }
-  std::reverse(out.begin() + offset, out.end());
-  return out;
 }
 
 void parseTo(folly::StringPiece in, ::facebook::velox::Timestamp& out) {
diff --git a/velox/type/Timestamp.h b/velox/type/Timestamp.h
index 20db5bd2a6a58..f3b4c4cd1340a 100644
--- a/velox/type/Timestamp.h
+++ b/velox/type/Timestamp.h
@@ -24,33 +24,58 @@
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/type/StringView.h"
 
-namespace date {
-class time_zone;
+namespace facebook::velox {
+
+namespace tz {
+class TimeZone;
 }
 
-namespace facebook::velox {
+enum class TimestampPrecision : int8_t {
+  kMilliseconds = 3, // 10^3 milliseconds are equal to one second.
+  kMicroseconds = 6, // 10^6 microseconds are equal to one second.
+  kNanoseconds = 9, // 10^9 nanoseconds are equal to one second.
+};
 
 struct TimestampToStringOptions {
-  enum Precision : int8_t {
-    kMilliseconds = 3,
-    kNanoseconds = 9,
-  } precision = kNanoseconds;
+  using Precision = TimestampPrecision;
+
+  Precision precision = Precision::kNanoseconds;
+
+  // Whether to add a leading '+' when year is greater than 9999.
+  bool leadingPositiveSign = false;
+
+  /// Whether to skip trailing zeros of fractional part. E.g. when true,
+  /// '2000-01-01 12:21:56.129000' becomes '2000-01-01 12:21:56.129'.
+  bool skipTrailingZeros = false;
 
+  /// Whether padding zeros are added when the digits of year is less than 4.
+  /// E.g. when true, '1-01-01 05:17:32.000' becomes '0001-01-01 05:17:32.000',
+  /// '-03-24 13:20:00.000' becomes '0000-03-24 13:20:00.000', and '-1-11-29
+  /// 19:33:20.000' becomes '-0001-11-29 19:33:20.000'.
   bool zeroPaddingYear = false;
+
+  // The separator of date and time.
   char dateTimeSeparator = 'T';
-  bool dateOnly = false;
-};
 
-// Our own version of gmtime_r to avoid expensive calls to __tz_convert.  This
-// might not be very significant in micro benchmark, but is causing significant
-// context switching cost in real world queries with higher concurrency (71% of
-// time is on __tz_convert for some queries).
-//
-// Return whether the epoch second can be converted to a valid std::tm.
-bool epochToUtc(int64_t seconds, std::tm& out);
+  enum class Mode : int8_t {
+    /// ISO 8601 timestamp format: %Y-%m-%dT%H:%M:%S.nnnnnnnnn for nanoseconds
+    /// precision; %Y-%m-%dT%H:%M:%S.nnn for milliseconds precision.
+    kFull,
+    /// ISO 8601 date format: %Y-%m-%d.
+    kDateOnly,
+    /// ISO 8601 time format: %H:%M:%S.nnnnnnnnn for nanoseconds precision,
+    /// or %H:%M:%S.nnn for milliseconds precision.
+    kTimeOnly,
+  };
 
-std::string
-tmToString(const std::tm&, int nanos, const TimestampToStringOptions&);
+  Mode mode = Mode::kFull;
+
+  const tz::TimeZone* timeZone = nullptr;
+};
+
+/// Returns the max length of a converted string from timestamp.
+std::string::size_type getMaxStringLength(
+    const TimestampToStringOptions& options);
 
 struct Timestamp {
  public:
@@ -58,6 +83,11 @@ struct Timestamp {
   static constexpr int64_t kMicrosecondsInMillisecond = 1'000;
   static constexpr int64_t kNanosecondsInMicrosecond = 1'000;
   static constexpr int64_t kNanosecondsInMillisecond = 1'000'000;
+  static constexpr int64_t kNanosInSecond =
+      kNanosecondsInMillisecond * kMillisecondsInSecond;
+  // The number of days between the Julian epoch and the Unix epoch.
+  static constexpr int64_t kJulianToUnixEpochDays = 2440588LL;
+  static constexpr int64_t kSecondsInDay = 86400LL;
 
   // Limit the range of seconds to avoid some problems. Seconds should be
   // in the range [INT64_MIN/1000 - 1, INT64_MAX/1000].
@@ -83,6 +113,10 @@ struct Timestamp {
     VELOX_USER_DCHECK_LE(nanos, kMaxNanos, "Timestamp nanos out of range");
   }
 
+  /// Creates a timestamp from the number of days since the Julian epoch
+  /// and the number of nanoseconds.
+  static Timestamp fromDaysAndNanos(int32_t days, int64_t nanos);
+
   // Returns the current unix timestamp (ms precision).
   static Timestamp now();
 
@@ -100,6 +134,7 @@ struct Timestamp {
     return nanos_;
   }
 
+  // Keep it in header for getting inlined.
   int64_t toNanos() const {
     // int64 can store around 292 years in nanos ~ till 2262-04-12.
     // When an integer overflow occurs in the calculation,
@@ -116,22 +151,34 @@ struct Timestamp {
     }
   }
 
+  // Keep it in header for getting inlined.
   int64_t toMillis() const {
-    // When an integer overflow occurs in the calculation,
-    // an exception will be thrown.
-    try {
-      return checkedPlus(
-          checkedMultiply(seconds_, (int64_t)1'000),
-          (int64_t)(nanos_ / 1'000'000));
-    } catch (const std::exception& e) {
+    // We use int128_t to make sure the computation does not overflows since
+    // there are cases such that seconds*1000 does not fit in int64_t,
+    // but seconds*1000 + nanos does, an example is TimeStamp::minMillis().
+
+    // If the final result does not fit in int64_tw we throw.
+    __int128_t result =
+        (__int128_t)seconds_ * 1'000 + (int64_t)(nanos_ / 1'000'000);
+    if (result < std::numeric_limits<int64_t>::min() ||
+        result > std::numeric_limits<int64_t>::max()) {
       VELOX_USER_FAIL(
-          "Could not convert Timestamp({}, {}) to milliseconds, {}",
+          "Could not convert Timestamp({}, {}) to milliseconds",
           seconds_,
-          nanos_,
-          e.what());
+          nanos_);
     }
+    return result;
   }
 
+  // Keep it in header for getting inlined.
+  int64_t toMillisAllowOverflow() const {
+    // Similar to the above toMillis() except that overflowed integer is allowed
+    // as result.
+    auto result = seconds_ * 1'000 + (int64_t)(nanos_ / 1'000'000);
+    return result;
+  }
+
+  // Keep it in header for getting inlined.
   int64_t toMicros() const {
     // When an integer overflow occurs in the calculation,
     // an exception will be thrown.
@@ -148,10 +195,17 @@ struct Timestamp {
     }
   }
 
-  /// Due to the limit of std::chrono, throws if timestamp is outside of
+  /// Exports the current timestamp as a std::chrono::time_point of millisecond
+  /// precision. Note that the conversion may overflow since the internal
+  /// `seconds_` value will need to be multiplied by 1000.
+  ///
+  /// If `allowOverflow` is true, integer overflow is allowed in converting
+  /// to milliseconds.
+  ///
+  /// Due to the limit of velox/external/date, throws if timestamp is outside of
   /// [-32767-01-01, 32767-12-31] range.
   std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>
-  toTimePoint() const;
+  toTimePointMs(bool allowOverflow = false) const;
 
   static Timestamp fromMillis(int64_t millis) {
     if (millis >= 0 || millis % 1'000 == 0) {
@@ -162,6 +216,21 @@ struct Timestamp {
     return Timestamp(second, nano);
   }
 
+  static Timestamp fromMillisNoError(int64_t millis)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+  {
+    if (millis >= 0 || millis % 1'000 == 0) {
+      return Timestamp(millis / 1'000, (millis % 1'000) * 1'000'000);
+    }
+    auto second = millis / 1'000 - 1;
+    auto nano = ((millis - second * 1'000) % 1'000) * 1'000'000;
+    return Timestamp(second, nano);
+  }
+
   static Timestamp fromMicros(int64_t micros) {
     if (micros >= 0 || micros % 1'000'000 == 0) {
       return Timestamp(micros / 1'000'000, (micros % 1'000'000) * 1'000);
@@ -171,6 +240,21 @@ struct Timestamp {
     return Timestamp(second, nano);
   }
 
+  static Timestamp fromMicrosNoError(int64_t micros)
+#if defined(__has_feature)
+#if __has_feature(__address_sanitizer__)
+      __attribute__((__no_sanitize__("signed-integer-overflow")))
+#endif
+#endif
+  {
+    if (micros >= 0 || micros % 1'000'000 == 0) {
+      return Timestamp(micros / 1'000'000, (micros % 1'000'000) * 1'000);
+    }
+    auto second = micros / 1'000'000 - 1;
+    auto nano = ((micros - second * 1'000'000) % 1'000'000) * 1'000;
+    return Timestamp(second, nano);
+  }
+
   static Timestamp fromNanos(int64_t nanos) {
     if (nanos >= 0 || nanos % 1'000'000'000 == 0) {
       return Timestamp(nanos / 1'000'000'000, nanos % 1'000'000'000);
@@ -206,25 +290,71 @@ struct Timestamp {
     return Timestamp(kMaxSeconds, kMaxNanos);
   }
 
-  // Assuming the timestamp represents a time at zone, converts it to the GMT
-  // time at the same moment.
-  // Example: Timestamp ts{0, 0};
-  // ts.Timezone("America/Los_Angeles");
-  // ts.toString() returns January 1, 1970 08:00:00
-  void toGMT(const date::time_zone& zone);
-
-  // Same as above, but accepts PrestoDB time zone ID.
-  void toGMT(int16_t tzID);
+  /// Our own version of gmtime_r to avoid expensive calls to __tz_convert.
+  /// This might not be very significant in micro benchmark, but is causing
+  /// significant context switching cost in real world queries with higher
+  /// concurrency (71% of time is on __tz_convert for some queries).
+  ///
+  /// Return whether the epoch second can be converted to a valid std::tm.
+  static bool epochToCalendarUtc(int64_t seconds, std::tm& out);
+
+  /// Our own version of timegm to avoid expensive calls to __tz_convert.
+  ///
+  /// This function is guaranteed to give same result as std::timegm when it is
+  /// successful.
+  static int64_t calendarUtcToEpoch(const std::tm& tm);
+
+  /// Truncates a Timestamp value to the specified precision.
+  static Timestamp truncate(Timestamp ts, TimestampPrecision precision) {
+    switch (precision) {
+      case TimestampPrecision::kMilliseconds:
+        return Timestamp::fromMillis(ts.toMillis());
+      case TimestampPrecision::kMicroseconds:
+        return Timestamp::fromMicros(ts.toMicros());
+      case TimestampPrecision::kNanoseconds:
+        return ts;
+      default:
+        VELOX_UNREACHABLE();
+    }
+  }
 
-  // Assuming the timestamp represents a GMT time, converts it to the time at
-  // the same moment at zone.
-  // Example: Timestamp ts{0, 0};
-  // ts.Timezone("America/Los_Angeles");
-  // ts.toString() returns December 31, 1969 16:00:00
-  void toTimezone(const date::time_zone& zone);
+  /// Converts a std::tm to a time/date/timestamp string in ISO 8601 format
+  /// according to TimestampToStringOptions.
+  /// @param startPosition the start position of pre-allocated memory to write
+  /// string to.
+  static StringView tmToStringView(
+      const std::tm& tmValue,
+      uint64_t nanos,
+      const TimestampToStringOptions& options,
+      char* const startPosition);
+
+  /// Converts a timestamp to a time/date/timestamp string in ISO 8601 format
+  /// according to TimestampToStringOptions.
+  /// @param startPosition the start position of pre-allocated memory to write
+  /// string to.
+  static StringView tsToStringView(
+      const Timestamp& ts,
+      const TimestampToStringOptions& options,
+      char* const startPosition);
 
-  // Same as above, but accepts PrestoDB time zone ID.
-  void toTimezone(int16_t tzID);
+  // Assuming the timestamp represents a time at zone, converts it to the GMT
+  // time at the same moment. For example:
+  //
+  //  Timestamp ts{0, 0};
+  //  ts.Timezone("America/Los_Angeles");
+  //  ts.toString(); // returns January 1, 1970 08:00:00
+  void toGMT(const tz::TimeZone& zone);
+
+  /// Assuming the timestamp represents a GMT time, converts it to the time at
+  /// the same moment at zone. For example:
+  ///
+  ///  Timestamp ts{0, 0};
+  ///  ts.Timezone("America/Los_Angeles");
+  ///  ts.toString(); // returns December 31, 1969 16:00:00
+  void toTimezone(const tz::TimeZone& zone);
+
+  /// A default time zone that is same across the process.
+  static const tz::TimeZone& defaultTimezone();
 
   bool operator==(const Timestamp& b) const {
     return seconds_ == b.seconds_ && nanos_ == b.nanos_;
@@ -283,15 +413,19 @@ struct Timestamp {
   // Needed for serialization of FlatVector<Timestamp>
   operator StringView() const {
     return StringView("TODO: Implement");
-  };
+  }
 
   std::string toString(const TimestampToStringOptions& options = {}) const {
     std::tm tm;
     VELOX_USER_CHECK(
-        epochToUtc(seconds_, tm),
+        epochToCalendarUtc(seconds_, tm),
         "Can't convert seconds to time: {}",
         seconds_);
-    return tmToString(tm, nanos_, options);
+    std::string result;
+    result.resize(getMaxStringLength(options));
+    const auto view = tmToStringView(tm, nanos_, options, result.data());
+    result.resize(view.size());
+    return result;
   }
 
   operator std::string() const {
@@ -309,6 +443,11 @@ struct Timestamp {
     return obj;
   }
 
+  // Pretty printer for gtest.
+  friend void PrintTo(const Timestamp& timestamp, std::ostream* os) {
+    *os << "sec: " << timestamp.seconds_ << ", ns: " << timestamp.nanos_;
+  }
+
  private:
   int64_t seconds_;
   uint64_t nanos_;
@@ -359,3 +498,24 @@ struct hasher<::facebook::velox::Timestamp> {
 };
 
 } // namespace folly
+
+namespace fmt {
+template <>
+struct formatter<facebook::velox::TimestampToStringOptions::Precision>
+    : formatter<int> {
+  auto format(
+      facebook::velox::TimestampToStringOptions::Precision s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
+template <>
+struct formatter<facebook::velox::TimestampToStringOptions::Mode>
+    : formatter<int> {
+  auto format(
+      facebook::velox::TimestampToStringOptions::Mode s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
+} // namespace fmt
diff --git a/velox/type/TimestampConversion.cpp b/velox/type/TimestampConversion.cpp
index a867c20f29907..d99c227633297 100644
--- a/velox/type/TimestampConversion.cpp
+++ b/velox/type/TimestampConversion.cpp
@@ -41,8 +41,11 @@
  */
 
 #include "velox/type/TimestampConversion.h"
+#include <folly/Expected.h>
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/type/HugeInt.h"
+#include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::util {
 
@@ -105,20 +108,6 @@ constexpr int32_t kCumulativeYearDays[] = {
 
 namespace {
 
-// Enum to dictate parsing modes for date strings.
-//
-// kStrict: For date string conversion, align with DuckDB's implementation.
-//
-// kNonStrict: For timestamp string conversion, align with DuckDB's
-// implementation.
-//
-// kStandardCast: Strictly processes dates in the [+-](YYYY-MM-DD) format.
-// Align with Presto casting conventions.
-//
-// kNonStandardCast: Like standard but permits missing day/month and allows
-// trailing 'T' or spaces. Align with Spark SQL casting conventions.
-enum class ParseMode { kStrict, kNonStrict, kStandardCast, kNonStandardCast };
-
 inline bool characterIsSpace(char c) {
   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' ||
       c == '\r';
@@ -156,11 +145,65 @@ bool isValidWeekDate(int32_t weekYear, int32_t weekOfYear, int32_t dayOfWeek) {
   return true;
 }
 
+bool isValidWeekOfMonthDate(
+    int32_t year,
+    int32_t month,
+    int32_t weekOfMonth,
+    int32_t dayOfWeek) {
+  if (year < 1 || year > kMaxYear) {
+    return false;
+  }
+  if (month < 1 || month > 12) {
+    return false;
+  }
+
+  Expected<int64_t> daysSinceEpochOfFirstDayOfMonth =
+      daysSinceEpochFromDate(year, month, 1);
+  if (daysSinceEpochOfFirstDayOfMonth.hasError()) {
+    return false;
+  }
+  daysSinceEpochOfFirstDayOfMonth = daysSinceEpochOfFirstDayOfMonth.value();
+
+  // Calculates the actual number of week of month and validates if it is in the
+  // valid range.
+  const int32_t firstDayOfWeek =
+      extractISODayOfTheWeek(daysSinceEpochOfFirstDayOfMonth.value());
+  const int32_t firstWeekLength = 7 - firstDayOfWeek + 1;
+  const int32_t monthLength =
+      isLeapYear(year) ? kLeapDays[month] : kNormalDays[month];
+  const int32_t actualWeeks = 1 + ceil((monthLength - firstWeekLength) / 7.0);
+  if (weekOfMonth < 1 || weekOfMonth > actualWeeks) {
+    return false;
+  }
+
+  // Validate day of week.
+  // If dayOfWeek is before the first day of week, it is considered invalid.
+  if (weekOfMonth == 1 && dayOfWeek < firstDayOfWeek) {
+    return false;
+  }
+  const int32_t lastWeekLength = (monthLength - firstWeekLength) % 7;
+  // If dayOfWeek is after the last day of the last week of the month, it is
+  // considered invalid.
+  if (weekOfMonth == actualWeeks && lastWeekLength != 0 &&
+      dayOfWeek > lastWeekLength) {
+    return false;
+  }
+
+  return true;
+}
+
 inline bool validDate(int64_t daysSinceEpoch) {
   return daysSinceEpoch >= std::numeric_limits<int32_t>::min() &&
       daysSinceEpoch <= std::numeric_limits<int32_t>::max();
 }
 
+// Skip leading spaces.
+inline void skipSpaces(const char* buf, size_t len, size_t& pos) {
+  while (pos < len && characterIsSpace(buf[pos])) {
+    pos++;
+  }
+}
+
 bool tryParseDateString(
     const char* buf,
     size_t len,
@@ -177,10 +220,8 @@ bool tryParseDateString(
   int32_t year = 0;
   bool yearneg = false;
   int sep;
-
-  // Skip leading spaces.
-  while (pos < len && characterIsSpace(buf[pos])) {
-    pos++;
+  if (mode != ParseMode::kIso8601) {
+    skipSpaces(buf, len, pos);
   }
 
   if (pos >= len) {
@@ -217,8 +258,13 @@ bool tryParseDateString(
   }
 
   // No month or day.
-  if (mode == ParseMode::kNonStandardCast && pos == len) {
-    daysSinceEpoch = daysSinceEpochFromDate(year, 1, 1);
+  if ((mode == ParseMode::kSparkCast || mode == ParseMode::kIso8601) &&
+      pos == len) {
+    Expected<int64_t> expected = daysSinceEpochFromDate(year, 1, 1);
+    if (expected.hasError()) {
+      return false;
+    }
+    daysSinceEpoch = expected.value();
     return validDate(daysSinceEpoch);
   }
 
@@ -228,7 +274,8 @@ bool tryParseDateString(
 
   // Fetch the separator.
   sep = buf[pos++];
-  if (mode == ParseMode::kStandardCast || mode == ParseMode::kNonStandardCast) {
+  if (mode == ParseMode::kPrestoCast || mode == ParseMode::kSparkCast ||
+      mode == ParseMode::kIso8601) {
     // Only '-' is valid for cast.
     if (sep != '-') {
       return false;
@@ -246,8 +293,13 @@ bool tryParseDateString(
   }
 
   // No day.
-  if (mode == ParseMode::kNonStandardCast && pos == len) {
-    daysSinceEpoch = daysSinceEpochFromDate(year, month, 1);
+  if ((mode == ParseMode::kSparkCast || mode == ParseMode::kIso8601) &&
+      pos == len) {
+    Expected<int64_t> expected = daysSinceEpochFromDate(year, month, 1);
+    if (expected.hasError()) {
+      return false;
+    }
+    daysSinceEpoch = expected.value();
     return validDate(daysSinceEpoch);
   }
 
@@ -268,8 +320,16 @@ bool tryParseDateString(
     return false;
   }
 
-  if (mode == ParseMode::kStandardCast) {
-    daysSinceEpoch = daysSinceEpochFromDate(year, month, day);
+  if (mode == ParseMode::kPrestoCast || mode == ParseMode::kIso8601) {
+    Expected<int64_t> expected = daysSinceEpochFromDate(year, month, day);
+    if (expected.hasError()) {
+      return false;
+    }
+    daysSinceEpoch = expected.value();
+
+    if (mode == ParseMode::kPrestoCast) {
+      skipSpaces(buf, len, pos);
+    }
 
     if (pos == len) {
       return validDate(daysSinceEpoch);
@@ -279,8 +339,12 @@ bool tryParseDateString(
 
   // In non-standard cast mode, an optional trailing 'T' or space followed
   // by any optional characters are valid patterns.
-  if (mode == ParseMode::kNonStandardCast) {
-    daysSinceEpoch = daysSinceEpochFromDate(year, month, day);
+  if (mode == ParseMode::kSparkCast) {
+    Expected<int64_t> expected = daysSinceEpochFromDate(year, month, day);
+    if (expected.hasError()) {
+      return false;
+    }
+    daysSinceEpoch = expected.value();
 
     if (!validDate(daysSinceEpoch)) {
       return false;
@@ -311,11 +375,9 @@ bool tryParseDateString(
   }
 
   // In strict mode, check remaining string for non-space characters.
-  if (mode == ParseMode::kStrict) {
-    // Skip trailing spaces.
-    while (pos < len && characterIsSpace(buf[pos])) {
-      pos++;
-    }
+  if (mode == ParseMode::kStrict || mode == ParseMode::kIso8601) {
+    skipSpaces(buf, len, pos);
+
     // Check position. if end was not reached, non-space chars remaining.
     if (pos < len) {
       return false;
@@ -326,29 +388,56 @@ bool tryParseDateString(
       return false;
     }
   }
-
-  daysSinceEpoch = daysSinceEpochFromDate(year, month, day);
+  Expected<int64_t> expected = daysSinceEpochFromDate(year, month, day);
+  if (expected.hasError()) {
+    return false;
+  }
+  daysSinceEpoch = expected.value();
   return true;
 }
 
-// String format is hh:mm:ss.microseconds (microseconds are optional).
+void parseTimeSeparator(
+    const char* buf,
+    size_t& pos,
+    TimestampParseMode parseMode) {
+  switch (parseMode) {
+    case TimestampParseMode::kIso8601:
+      if (buf[pos] == 'T') {
+        pos++;
+      }
+      break;
+    case TimestampParseMode::kPrestoCast:
+      if (buf[pos] == ' ') {
+        pos++;
+      }
+      break;
+    case TimestampParseMode::kLegacyCast:
+    case TimestampParseMode::kSparkCast:
+      if (buf[pos] == ' ' || buf[pos] == 'T') {
+        pos++;
+      }
+      break;
+  }
+}
+
+// String format is hh:mm:ss.microseconds (seconds and microseconds are
+// optional).
 // ISO 8601
 bool tryParseTimeString(
     const char* buf,
     size_t len,
     size_t& pos,
     int64_t& result,
-    bool strict) {
-  int32_t hour = -1, min = -1, sec = -1, micros = -1;
+    TimestampParseMode parseMode) {
+  int32_t hour = 0, min = 0, sec = 0, micros = 0;
   pos = 0;
 
   if (len == 0) {
     return false;
   }
 
-  // Skip leading spaces.
-  while (pos < len && characterIsSpace(buf[pos])) {
-    pos++;
+  if (parseMode != TimestampParseMode::kIso8601) {
+    skipSpaces(buf, len, pos);
   }
 
   if (pos >= len) {
@@ -359,6 +448,7 @@ bool tryParseTimeString(
     return false;
   }
 
+  // Read the hours.
   if (!parseDoubleDigit(buf, len, pos, hour)) {
     return false;
   }
@@ -367,6 +457,10 @@ bool tryParseTimeString(
   }
 
   if (pos >= len) {
+    if (parseMode == TimestampParseMode::kIso8601) {
+      result = fromTime(hour, 0, 0, 0);
+      return true;
+    }
     return false;
   }
 
@@ -377,6 +471,7 @@ bool tryParseTimeString(
     return false;
   }
 
+  // Read the minutes.
   if (!parseDoubleDigit(buf, len, pos, min)) {
     return false;
   }
@@ -384,106 +479,93 @@ bool tryParseTimeString(
     return false;
   }
 
-  if (pos >= len) {
-    return false;
-  }
+  // Try to read seconds.
+  if (pos < len && buf[pos] == sep) {
+    ++pos;
+    if (!parseDoubleDigit(buf, len, pos, sec)) {
+      return false;
+    }
+    if (sec < 0 || sec > 60) {
+      return false;
+    }
 
-  if (buf[pos++] != sep) {
-    return false;
-  }
+    // Try to read microseconds.
+    if (pos < len) {
+      if (buf[pos] == '.') {
+        ++pos;
+      } else if (parseMode == TimestampParseMode::kIso8601 && buf[pos] == ',') {
+        ++pos;
+      }
 
-  if (!parseDoubleDigit(buf, len, pos, sec)) {
-    return false;
-  }
-  if (sec < 0 || sec > 60) {
-    return false;
-  }
+      if (pos >= len) {
+        return false;
+      }
 
-  micros = 0;
-  if (pos < len && buf[pos] == '.') {
-    pos++;
-    // We expect microseconds.
-    int32_t mult = 100000;
-    for (; pos < len && characterIsDigit(buf[pos]); pos++, mult /= 10) {
-      if (mult > 0) {
-        micros += (buf[pos] - '0') * mult;
+      // We expect microseconds.
+      int32_t mult = 100000;
+      for (; pos < len && characterIsDigit(buf[pos]); pos++, mult /= 10) {
+        if (mult > 0) {
+          micros += (buf[pos] - '0') * mult;
+        }
       }
     }
   }
 
-  // In strict mode, check remaining string for non-space characters.
-  if (strict) {
-    // Skip trailing spaces.
-    while (pos < len && characterIsSpace(buf[pos])) {
-      pos++;
-    }
-
-    // Check position. If end was not reached, non-space chars remaining.
-    if (pos < len) {
-      return false;
-    }
-  }
   result = fromTime(hour, min, sec, micros);
   return true;
 }
 
-bool tryParseUTCOffsetString(
+// String format is "YYYY-MM-DD hh:mm:ss.microseconds" (seconds and microseconds
+// are optional). ISO 8601
+bool tryParseTimestampString(
     const char* buf,
-    size_t& pos,
     size_t len,
-    int& hourOffset,
-    int& minuteOffset) {
-  minuteOffset = 0;
-  size_t curpos = pos;
-
-  // Parse the next 3 characters.
-  if (curpos + 3 > len) {
-    // No characters left to parse.
-    return false;
-  }
+    size_t& pos,
+    Timestamp& result,
+    TimestampParseMode parseMode) {
+  int64_t daysSinceEpoch = 0;
+  int64_t microsSinceMidnight = 0;
 
-  char sign_char = buf[curpos];
-  if (sign_char != '+' && sign_char != '-') {
-    // Expected either + or -
-    return false;
+  if (parseMode == TimestampParseMode::kIso8601) {
+    // Leading spaces are not allowed.
+    size_t startPos = pos;
+    skipSpaces(buf, len, pos);
+    if (pos > startPos) {
+      return false;
+    }
   }
 
-  curpos++;
-  if (!characterIsDigit(buf[curpos]) || !characterIsDigit(buf[curpos + 1])) {
-    // Expected +HH or -HH
+  if (parseMode == TimestampParseMode::kIso8601 && pos < len &&
+      buf[pos] == 'T') {
+    // No date. Assume 1970-01-01.
+  } else if (!tryParseDateString(
+                 buf,
+                 len,
+                 pos,
+                 daysSinceEpoch,
+                 parseMode == TimestampParseMode::kIso8601
+                     ? ParseMode::kSparkCast
+                     : ParseMode::kNonStrict)) {
     return false;
   }
 
-  hourOffset = (buf[curpos] - '0') * 10 + (buf[curpos + 1] - '0');
-
-  if (sign_char == '-') {
-    hourOffset = -hourOffset;
-  }
-  curpos += 2;
-
-  // Optional minute specifier: expected either "MM" or ":MM".
-  if (curpos >= len) {
-    // Done, nothing left.
-    pos = curpos;
+  if (pos == len) {
+    // No time: only a date.
+    result = fromDatetime(daysSinceEpoch, 0);
     return true;
   }
-  if (buf[curpos] == ':') {
-    curpos++;
-  }
 
-  if (curpos + 2 > len || !characterIsDigit(buf[curpos]) ||
-      !characterIsDigit(buf[curpos + 1])) {
-    // No MM specifier.
-    pos = curpos;
-    return true;
-  }
+  // Try to parse a time field.
+  parseTimeSeparator(buf, pos, parseMode);
 
-  // We have an MM specifier: parse it.
-  minuteOffset = (buf[curpos] - '0') * 10 + (buf[curpos + 1] - '0');
-  if (sign_char == '-') {
-    minuteOffset = -minuteOffset;
+  size_t timePos = 0;
+  if (!tryParseTimeString(
+          buf + pos, len - pos, timePos, microsSinceMidnight, parseMode)) {
+    return false;
   }
-  pos = curpos + 2;
+
+  pos += timePos;
+  result = fromDatetime(daysSinceEpoch, microsSinceMidnight);
   return true;
 }
 
@@ -516,7 +598,7 @@ bool isValidDayOfYear(int32_t year, int32_t dayOfYear) {
   return true;
 }
 
-int64_t lastDayOfMonthSinceEpochFromDate(const std::tm& dateTime) {
+Expected<int64_t> lastDayOfMonthSinceEpochFromDate(const std::tm& dateTime) {
   auto year = dateTime.tm_year + 1900;
   auto month = dateTime.tm_mon + 1;
   auto day = util::getMaxDayOfMonth(year, month);
@@ -527,11 +609,16 @@ int32_t getMaxDayOfMonth(int32_t year, int32_t month) {
   return isLeapYear(year) ? kLeapDays[month] : kNormalDays[month];
 }
 
-int64_t daysSinceEpochFromDate(int32_t year, int32_t month, int32_t day) {
+Expected<int64_t>
+daysSinceEpochFromDate(int32_t year, int32_t month, int32_t day) {
   int64_t daysSinceEpoch = 0;
 
   if (!isValidDate(year, month, day)) {
-    VELOX_USER_FAIL("Date out of range: {}-{}-{}", year, month, day);
+    if (threadSkipErrorDetails()) {
+      return folly::makeUnexpected(Status::UserError());
+    }
+    return folly::makeUnexpected(
+        Status::UserError("Date out of range: {}-{}-{}", year, month, day));
   }
   while (year < 1970) {
     year += kYearInterval;
@@ -548,70 +635,127 @@ int64_t daysSinceEpochFromDate(int32_t year, int32_t month, int32_t day) {
   return daysSinceEpoch;
 }
 
-int64_t daysSinceEpochFromWeekDate(
+Expected<int64_t> daysSinceEpochFromWeekDate(
     int32_t weekYear,
     int32_t weekOfYear,
     int32_t dayOfWeek) {
   if (!isValidWeekDate(weekYear, weekOfYear, dayOfWeek)) {
-    VELOX_USER_FAIL(
-        "Date out of range: {}-{}-{}", weekYear, weekOfYear, dayOfWeek);
+    if (threadSkipErrorDetails()) {
+      return folly::makeUnexpected(Status::UserError());
+    }
+    return folly::makeUnexpected(Status::UserError(
+        "Date out of range: {}-{}-{}", weekYear, weekOfYear, dayOfWeek));
   }
 
-  int64_t daysSinceEpochOfJanFourth = daysSinceEpochFromDate(weekYear, 1, 4);
-  int32_t firstDayOfWeekYear =
-      extractISODayOfTheWeek(daysSinceEpochOfJanFourth);
+  return daysSinceEpochFromDate(weekYear, 1, 4)
+      .then([&weekOfYear, &dayOfWeek](int64_t daysSinceEpochOfJanFourth) {
+        int32_t firstDayOfWeekYear =
+            extractISODayOfTheWeek(daysSinceEpochOfJanFourth);
 
-  return daysSinceEpochOfJanFourth - (firstDayOfWeekYear - 1) +
-      7 * (weekOfYear - 1) + dayOfWeek - 1;
+        return daysSinceEpochOfJanFourth - (firstDayOfWeekYear - 1) +
+            7 * (weekOfYear - 1) + dayOfWeek - 1;
+      });
 }
 
-int64_t daysSinceEpochFromDayOfYear(int32_t year, int32_t dayOfYear) {
-  if (!isValidDayOfYear(year, dayOfYear)) {
-    VELOX_USER_FAIL("Day of year out of range: {}", dayOfYear);
-  }
-  int64_t startOfYear = daysSinceEpochFromDate(year, 1, 1);
-  return startOfYear + (dayOfYear - 1);
+Expected<int64_t> daysSinceEpochFromWeekOfMonthDate(
+    int32_t year,
+    int32_t month,
+    int32_t weekOfMonth,
+    int32_t dayOfWeek,
+    bool lenient) {
+  if (!lenient &&
+      !isValidWeekOfMonthDate(year, month, weekOfMonth, dayOfWeek)) {
+    if (threadSkipErrorDetails()) {
+      return folly::makeUnexpected(Status::UserError());
+    }
+    return folly::makeUnexpected(Status::UserError(
+        "Date out of range: {}-{}-{}-{}", year, month, weekOfMonth, dayOfWeek));
+  }
+
+  // Adjusts the year and month to ensure month is within the range 1-12,
+  // accounting for overflow or underflow.
+  int32_t additionYears = 0;
+  if (month < 1) {
+    additionYears = month / 12 - 1;
+    month = 12 - abs(month) % 12;
+  } else if (month > 12) {
+    additionYears = (month - 1) / 12;
+    month = (month - 1) % 12 + 1;
+  }
+  year += additionYears;
+
+  return daysSinceEpochFromDate(year, month, 1)
+      .then(
+          [&dayOfWeek, &weekOfMonth](int64_t daysSinceEpochOfFirstDayOfMonth) {
+            const int32_t firstDayOfWeek =
+                extractISODayOfTheWeek(daysSinceEpochOfFirstDayOfMonth);
+            int32_t days;
+            if (dayOfWeek < 1) {
+              days = 7 - abs(dayOfWeek - 1) % 7;
+            } else if (dayOfWeek > 7) {
+              days = (dayOfWeek - 1) % 7;
+            } else {
+              days = dayOfWeek % 7;
+            }
+            return daysSinceEpochOfFirstDayOfMonth - (firstDayOfWeek - 1) +
+                7 * (weekOfMonth - 1) + days - 1;
+          });
 }
 
-int64_t fromDateString(const char* str, size_t len) {
-  int64_t daysSinceEpoch;
-  size_t pos = 0;
-
-  if (!tryParseDateString(str, len, pos, daysSinceEpoch, ParseMode::kStrict)) {
-    VELOX_USER_FAIL(
-        "Unable to parse date value: \"{}\", expected format is (YYYY-MM-DD)",
-        std::string(str, len));
+Expected<int64_t> daysSinceEpochFromDayOfYear(int32_t year, int32_t dayOfYear) {
+  if (!isValidDayOfYear(year, dayOfYear)) {
+    if (threadSkipErrorDetails()) {
+      return folly::makeUnexpected(Status::UserError());
+    }
+    return folly::makeUnexpected(
+        Status::UserError("Day of year out of range: {}", dayOfYear));
   }
-  return daysSinceEpoch;
+  return daysSinceEpochFromDate(year, 1, 1)
+      .then([&dayOfYear](int64_t startOfYear) {
+        return startOfYear + (dayOfYear - 1);
+      });
 }
 
-int32_t castFromDateString(const char* str, size_t len, bool isIso8601) {
+Expected<int32_t> fromDateString(const char* str, size_t len, ParseMode mode) {
   int64_t daysSinceEpoch;
   size_t pos = 0;
 
-  auto mode =
-      isIso8601 ? ParseMode::kStandardCast : ParseMode::kNonStandardCast;
   if (!tryParseDateString(str, len, pos, daysSinceEpoch, mode)) {
-    if (isIso8601) {
-      VELOX_USER_FAIL(
-          "Unable to parse date value: \"{}\"."
-          "Valid date string pattern is (YYYY-MM-DD), "
-          "and can be prefixed with [+-]",
-          std::string(str, len));
-    } else {
-      VELOX_USER_FAIL(
-          "Unable to parse date value: \"{}\"."
-          "Valid date string patterns include "
-          "(yyyy*, yyyy*-[m]m, yyyy*-[m]m-[d]d, "
-          "yyyy*-[m]m-[d]d *, yyyy*-[m]m-[d]dT*), "
-          "and any pattern prefixed with [+-]",
-          std::string(str, len));
+    if (threadSkipErrorDetails()) {
+      return folly::makeUnexpected(Status::UserError());
+    }
+
+    switch (mode) {
+      case ParseMode::kPrestoCast:
+        return folly::makeUnexpected(Status::UserError(
+            "Unable to parse date value: \"{}\". "
+            "Valid date string pattern is (YYYY-MM-DD), "
+            "and can be prefixed with [+-]",
+            std::string(str, len)));
+      case ParseMode::kSparkCast:
+        return folly::makeUnexpected(Status::UserError(
+            "Unable to parse date value: \"{}\". "
+            "Valid date string patterns include "
+            "([y]y*, [y]y*-[m]m*, [y]y*-[m]m*-[d]d*, "
+            "[y]y*-[m]m*-[d]d* *, [y]y*-[m]m*-[d]d*T*), "
+            "and any pattern prefixed with [+-]",
+            std::string(str, len)));
+      case ParseMode::kIso8601:
+        return folly::makeUnexpected(Status::UserError(
+            "Unable to parse date value: \"{}\". "
+            "Valid date string patterns include "
+            "([y]y*, [y]y*-[m]m*, [y]y*-[m]m*-[d]d*, "
+            "[y]y*-[m]m*-[d]d* *), "
+            "and any pattern prefixed with [+-]",
+            std::string(str, len)));
+      default:
+        VELOX_UNREACHABLE();
     }
   }
   return daysSinceEpoch;
 }
 
-int32_t extractISODayOfTheWeek(int32_t daysSinceEpoch) {
+int32_t extractISODayOfTheWeek(int64_t daysSinceEpoch) {
   // date of 0 is 1970-01-01, which was a Thursday (4)
   // -7 = 4
   // -6 = 5
@@ -630,10 +774,10 @@ int32_t extractISODayOfTheWeek(int32_t daysSinceEpoch) {
   // 7  = 4
   if (daysSinceEpoch < 0) {
     // negative date: start off at 4 and cycle downwards
-    return (7 - ((-int64_t(daysSinceEpoch) + 3) % 7));
+    return (7 - ((-int128_t(daysSinceEpoch) + 3) % 7));
   } else {
     // positive date: start off at 4 and cycle upwards
-    return ((int64_t(daysSinceEpoch) + 3) % 7) + 1;
+    return ((int128_t(daysSinceEpoch) + 3) % 7) + 1;
   }
 }
 
@@ -647,19 +791,6 @@ fromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
   return result;
 }
 
-int64_t fromTimeString(const char* str, size_t len) {
-  int64_t microsSinceMidnight;
-  size_t pos;
-
-  if (!tryParseTimeString(str, len, pos, microsSinceMidnight, true)) {
-    VELOX_USER_FAIL(
-        "Unable to parse time value: \"{}\", "
-        "expected format is (HH:MM:SS[.MS])",
-        std::string(str, len));
-  }
-  return microsSinceMidnight;
-}
-
 Timestamp fromDatetime(int64_t daysSinceEpoch, int64_t microsSinceMidnight) {
   int64_t secondsSinceEpoch =
       static_cast<int64_t>(daysSinceEpoch) * kSecsPerDay;
@@ -671,8 +802,11 @@ Timestamp fromDatetime(int64_t daysSinceEpoch, int64_t microsSinceMidnight) {
 
 namespace {
 
-void parserError(const char* str, size_t len) {
-  VELOX_USER_FAIL(
+Status parserError(const char* str, size_t len) {
+  if (threadSkipErrorDetails()) {
+    return Status::UserError();
+  }
+  return Status::UserError(
       "Unable to parse timestamp value: \"{}\", "
       "expected format is (YYYY-MM-DD HH:MM:SS[.MS])",
       std::string(str, len));
@@ -680,57 +814,97 @@ void parserError(const char* str, size_t len) {
 
 } // namespace
 
-Timestamp fromTimestampString(const char* str, size_t len) {
-  size_t pos;
-  int64_t daysSinceEpoch;
-  int64_t microsSinceMidnight;
+Expected<Timestamp>
+fromTimestampString(const char* str, size_t len, TimestampParseMode parseMode) {
+  size_t pos = 0;
+  Timestamp resultTimestamp;
 
-  if (!tryParseDateString(
-          str, len, pos, daysSinceEpoch, ParseMode::kNonStrict)) {
-    parserError(str, len);
+  if (!tryParseTimestampString(str, len, pos, resultTimestamp, parseMode)) {
+    return folly::makeUnexpected(parserError(str, len));
   }
+  skipSpaces(str, len, pos);
 
-  if (pos == len) {
-    // No time: only a date.
-    return fromDatetime(daysSinceEpoch, 0);
+  // If not all input was consumed.
+  if (pos < len) {
+    return folly::makeUnexpected(parserError(str, len));
   }
+  VELOX_CHECK_EQ(pos, len);
+  return resultTimestamp;
+}
 
-  // Try to parse a time field.
-  if (str[pos] == ' ' || str[pos] == 'T') {
-    pos++;
-  }
+Expected<std::pair<Timestamp, const tz::TimeZone*>>
+fromTimestampWithTimezoneString(
+    const char* str,
+    size_t len,
+    TimestampParseMode parseMode) {
+  size_t pos = 0;
+  Timestamp resultTimestamp;
 
-  size_t timePos = 0;
-  if (!tryParseTimeString(
-          str + pos, len - pos, timePos, microsSinceMidnight, false)) {
-    parserError(str, len);
+  if (!tryParseTimestampString(str, len, pos, resultTimestamp, parseMode)) {
+    return folly::makeUnexpected(parserError(str, len));
   }
 
-  pos += timePos;
-  auto timestamp = fromDatetime(daysSinceEpoch, microsSinceMidnight);
+  const tz::TimeZone* timeZone = nullptr;
+
+  if (pos < len && characterIsSpace(str[pos])) {
+    pos++;
+  }
 
+  // If there is anything left to parse, it must be a timezone definition.
   if (pos < len) {
-    // Skip a "Z" at the end (as per the ISO 8601 specs).
-    if (str[pos] == 'Z') {
-      pos++;
+    if (parseMode == TimestampParseMode::kIso8601) {
+      // Only +HH:MM and -HH:MM are supported. Minutes, seconds, etc. in the
+      // offset are optional.
+      if (str[pos] != 'Z' && str[pos] != '+' && str[pos] != '-') {
+        return folly::makeUnexpected(parserError(str, len));
+      }
     }
-    int hourOffset, minuteOffset;
-    if (tryParseUTCOffsetString(str, pos, len, hourOffset, minuteOffset)) {
-      int32_t secondOffset =
-          (hourOffset * kSecsPerHour) + (minuteOffset * kSecsPerMinute);
-      timestamp = Timestamp(
-          timestamp.getSeconds() - secondOffset, timestamp.getNanos());
+
+    size_t timezonePos = pos;
+    while (timezonePos < len && !characterIsSpace(str[timezonePos])) {
+      timezonePos++;
+    }
+
+    std::string_view timeZoneName(str + pos, timezonePos - pos);
+
+    if ((timeZone = tz::locateZone(timeZoneName, false)) == nullptr) {
+      return folly::makeUnexpected(
+          Status::UserError("Unknown timezone value: \"{}\"", timeZoneName));
     }
 
     // Skip any spaces at the end.
-    while (pos < len && characterIsSpace(str[pos])) {
-      pos++;
+    pos = timezonePos;
+    if (parseMode != TimestampParseMode::kIso8601) {
+      skipSpaces(str, len, pos);
     }
+
     if (pos < len) {
-      parserError(str, len);
+      return folly::makeUnexpected(parserError(str, len));
     }
   }
-  return timestamp;
+  return std::make_pair(resultTimestamp, timeZone);
+}
+
+int32_t toDate(const Timestamp& timestamp, const tz::TimeZone* timeZone_) {
+  auto convertToDate = [](const Timestamp& t) -> int32_t {
+    static const int32_t kSecsPerDay{86'400};
+    auto seconds = t.getSeconds();
+    if (seconds >= 0 || seconds % kSecsPerDay == 0) {
+      return seconds / kSecsPerDay;
+    }
+    // For division with negatives, minus 1 to compensate the discarded
+    // fractional part. e.g. -1/86'400 yields 0, yet it should be considered
+    // as -1 day.
+    return seconds / kSecsPerDay - 1;
+  };
+
+  if (timeZone_ != nullptr) {
+    Timestamp copy = timestamp;
+    copy.toTimezone(*timeZone_);
+    return convertToDate(copy);
+  }
+
+  return convertToDate(timestamp);
 }
 
 } // namespace facebook::velox::util
diff --git a/velox/type/TimestampConversion.h b/velox/type/TimestampConversion.h
index 0a4c3372190c6..fc43e776cf277 100644
--- a/velox/type/TimestampConversion.h
+++ b/velox/type/TimestampConversion.h
@@ -17,8 +17,13 @@
 #pragma once
 
 #include <cstdint>
+#include "velox/common/base/Status.h"
 #include "velox/type/Timestamp.h"
 
+namespace facebook::velox::tz {
+class TimeZone;
+}
+
 namespace facebook::velox::util {
 
 constexpr const int32_t kHoursPerDay{24};
@@ -43,6 +48,38 @@ constexpr const int32_t kMaxYear{292278994};
 constexpr const int32_t kYearInterval{400};
 constexpr const int32_t kDaysPerYearInterval{146097};
 
+/// Enum to dictate parsing modes for date strings.
+enum class ParseMode {
+  // For date string conversion, align with DuckDB's implementation.
+  kStrict,
+
+  // For timestamp string conversion, align with DuckDB's implementation.
+  kNonStrict,
+
+  // Accepts complete ISO 8601 format, i.e. [+-](YYYY-MM-DD). Allows leading and
+  // trailing spaces.
+  // Aligned with Presto casting conventions.
+  kPrestoCast,
+
+  // ISO-8601 format with optional leading or trailing spaces. Optional trailing
+  // 'T' is also allowed.
+  // Aligned with Spark SQL casting conventions.
+  //
+  // [+-][Y]Y*
+  // [+-][Y]Y*-[M]M
+  // [+-][Y]Y*-[M]M*-[D]D
+  // [+-][Y]Y*-[M]M*-[D]D *
+  // [+-][Y]Y*-[M]M*-[D]DT*
+  kSparkCast,
+
+  // ISO-8601 format. No leading or trailing spaces allowed.
+  //
+  // [+-][Y]Y*
+  // [+-][Y]Y*-[M]M
+  // [+-][Y]Y*-[M]M*-[D]D
+  kIso8601
+};
+
 // Returns true if leap year, false otherwise
 bool isLeapYear(int32_t year);
 
@@ -55,55 +92,72 @@ bool isValidDayOfYear(int32_t year, int32_t dayOfYear);
 // Returns max day of month for inputted month of inputted year
 int32_t getMaxDayOfMonth(int32_t year, int32_t month);
 
-// Returns last day of month since unix epoch (1970-01-01).
-int64_t lastDayOfMonthSinceEpochFromDate(const std::tm& dateTime);
+/// Computes the last day of month since unix epoch (1970-01-01).
+/// Returns UserError status if the date is invalid.
+Expected<int64_t> lastDayOfMonthSinceEpochFromDate(const std::tm& dateTime);
 
 /// Date conversions.
 
-/// Returns the (signed) number of days since unix epoch (1970-01-01).
-/// Throws VeloxUserError if the date is invalid.
-int64_t daysSinceEpochFromDate(int32_t year, int32_t month, int32_t day);
+/// Computes the (signed) number of days since unix epoch (1970-01-01).
+/// Returns UserError status if the date is invalid.
+Expected<int64_t>
+daysSinceEpochFromDate(int32_t year, int32_t month, int32_t day);
 
-/// Returns the (signed) number of days since unix epoch (1970-01-01).
-int64_t daysSinceEpochFromWeekDate(
+/// Computes the (signed) number of days since unix epoch (1970-01-01).
+/// Returns UserError status if the date is invalid.
+Expected<int64_t> daysSinceEpochFromWeekDate(
     int32_t weekYear,
     int32_t weekOfYear,
     int32_t dayOfWeek);
 
-/// Returns the (signed) number of days since unix epoch (1970-01-01).
-int64_t daysSinceEpochFromDayOfYear(int32_t year, int32_t dayOfYear);
-
-/// Returns the (signed) number of days since unix epoch (1970-01-01), following
-/// the "YYYY-MM-DD" format (ISO 8601). ' ', '/' and '\' are also acceptable
-/// separators. Negative years and a trailing "(BC)" are also supported.
-///
-/// Throws VeloxUserError if the format or date is invalid.
-int64_t fromDateString(const char* buf, size_t len);
-
-inline int64_t fromDateString(const StringView& str) {
-  return fromDateString(str.data(), str.size());
-}
-
-/// Cast string to date.
-/// When isIso8601 = true, only support "[+-]YYYY-MM-DD" format (ISO 8601).
-/// When isIso8601 = false, supported date formats include:
+/// Computes the signed number of days since the Unix epoch (1970-01-01). To
+/// align with Spark's SimpleDateFormat behavior, this function offers two
+/// modes: lenient and non-lenient. For non-lenient mode, dates before Jan 1, 1
+/// are not supported, and it returns an error status if the date is invalid.
+/// For lenient mode, it accepts a wider range of arguments.
+/// @param year Year. For non-lenient mode, it should be in the range [1,
+/// 292278994]. e.g: 1996, 2024. For lenient mode, it should be in the range
+/// [-292275055, 292278994].
+/// @param month Month of year. For non-lenient mode, it should be in the range
+/// [1, 12]. For example, 1 is January, 7 is July. For lenient mode, values
+/// greater than 12 wrap around to the start of the year, and values less than 1
+/// count backward from December. For example, 13 corresponds to January of the
+/// following year and -1 corresponds to November of the previous year.
+/// @param weekOfMonth Week of the month. For non-lenient mode, it should be in
+/// the range [1, depends on month]. For example, 1 is 1st week, 3 is 3rd week.
+/// For lenient mode, we consider days of the previous or next months as part of
+/// the specified weekOfMonth. For example, if weekOfMonth is 5 but the current
+/// month only has 4 weeks (such as February), the first week of March will be
+/// considered as the 5th week of February.
+/// @param dayOfWeek Day number of week. For non-lenient mode, it should be in
+/// the range [1, depends on month]. For example, 1 is Monday, 7 is Sunday. For
+/// lenient mode, we consider days of the previous or next months as part of the
+/// specified dayOfWeek.For example, if weekOfMonth is 1 and dayOfWeek is 1 but
+/// the month's first day is Saturday, the Monday of the last week of the
+/// previous month will be used.
+Expected<int64_t> daysSinceEpochFromWeekOfMonthDate(
+    int32_t year,
+    int32_t month,
+    int32_t weekOfMonth,
+    int32_t dayOfWeek,
+    bool lenient);
+
+/// Computes the (signed) number of days since unix epoch (1970-01-01).
+/// Returns UserError status if the date is invalid.
+Expected<int64_t> daysSinceEpochFromDayOfYear(int32_t year, int32_t dayOfYear);
+
+/// Cast string to date. Supported date formats vary, depending on input
+/// ParseMode. Refer to ParseMode enum for further info.
 ///
-/// `[+-]YYYY*`
-/// `[+-]YYYY*-[M]M`
-/// `[+-]YYYY*-[M]M-[D]D`
-/// `[+-]YYYY*-[M]M-[D]D `
-/// `[+-]YYYY*-[M]M-[D]D *`
-/// `[+-]YYYY*-[M]M-[D]DT*`
-///
-/// Throws VeloxUserError if the format or date is invalid.
-int32_t castFromDateString(const char* buf, size_t len, bool isIso8601);
+/// Returns Unexpected with UserError status if the format or date is invalid.
+Expected<int32_t> fromDateString(const char* buf, size_t len, ParseMode mode);
 
-inline int32_t castFromDateString(const StringView& str, bool isIso8601) {
-  return castFromDateString(str.data(), str.size(), isIso8601);
+inline Expected<int32_t> fromDateString(const StringView& str, ParseMode mode) {
+  return fromDateString(str.data(), str.size(), mode);
 }
 
 // Extracts the day of the week from the number of days since epoch
-int32_t extractISODayOfTheWeek(int32_t daysSinceEpoch);
+int32_t extractISODayOfTheWeek(int64_t daysSinceEpoch);
 
 /// Time conversions.
 
@@ -112,26 +166,96 @@ int32_t extractISODayOfTheWeek(int32_t daysSinceEpoch);
 int64_t
 fromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds);
 
-/// Parses the input string and returns the number of cumulative microseconds,
-/// following the "HH:MM:SS[.MS]" format (ISO 8601).
-//
-/// Throws VeloxUserError if the format or time is invalid.
-int64_t fromTimeString(const char* buf, size_t len);
-
-inline int64_t fromTimeString(const StringView& str) {
-  return fromTimeString(str.data(), str.size());
-}
-
 // Timestamp conversion
 
-/// Parses a full ISO 8601 timestamp string, following the format
-/// "YYYY-MM-DD HH:MM:SS[.MS] +00:00"
-Timestamp fromTimestampString(const char* buf, size_t len);
+enum class TimestampParseMode {
+  /// Accepted syntax:
+  // clang-format off
+  ///   datetime          = time | date-opt-time
+  ///   time              = 'T' time-element [offset]
+  ///   date-opt-time     = date-element ['T' [time-element] [offset]]
+  ///   date-element      = yyyy ['-' MM ['-' dd]]
+  ///   time-element      = HH [minute-element] | [fraction]
+  ///   minute-element    = ':' mm [second-element] | [fraction]
+  ///   second-element    = ':' ss [fraction]
+  ///   fraction          = ('.' | ',') digit+
+  ///   offset            = 'Z' | (('+' | '-') HH [':' mm [':' ss [('.' | ',') SSS]]])
+  // clang-format on
+  kIso8601,
+
+  /// Accepted syntax:
+  // clang-format off
+  ///   date-opt-time     = date-element [' ' [time-element] [[' '] [offset]]]
+  ///   date-element      = yyyy ['-' MM ['-' dd]]
+  ///   time-element      = HH [minute-element] | [fraction]
+  ///   minute-element    = ':' mm [second-element] | [fraction]
+  ///   second-element    = ':' ss [fraction]
+  ///   fraction          = '.' digit+
+  ///   offset            = 'Z' | ZZZ
+  // clang-format on
+  // Allows leading and trailing spaces.
+  kPrestoCast,
+
+  // Same as kPrestoCast, but allows 'T' separator between date and time.
+  kLegacyCast,
+
+  /// A Spark-compatible timestamp string. A mix of the above. Accepts T and
+  /// space as separator between date and time. Allows leading and trailing
+  /// spaces.
+  kSparkCast,
+};
+
+/// Parses a timestamp string using specified TimestampParseMode.
+///
+/// This function does not accept any timezone information in the string (e.g.
+/// UTC, Z, or a timezone offsets). This is because the returned timestamp does
+/// not contain timezone information; therefore, it would either be required for
+/// this function to convert the parsed timestamp (but we don't know the
+/// original timezone), or ignore the timezone information, which would be
+/// incorecct.
+///
+/// For a timezone-aware version of this function, check
+/// `fromTimestampWithTimezoneString()` below.
+Expected<Timestamp>
+fromTimestampString(const char* buf, size_t len, TimestampParseMode parseMode);
+
+inline Expected<Timestamp> fromTimestampString(
+    const StringView& str,
+    TimestampParseMode parseMode) {
+  return fromTimestampString(str.data(), str.size(), parseMode);
+}
 
-inline Timestamp fromTimestampString(const StringView& str) {
-  return fromTimestampString(str.data(), str.size());
+/// Parses a timestamp string using specified TimestampParseMode.
+///
+/// This is a timezone-aware version of the function above
+/// `fromTimestampString()` which returns both the parsed timestamp and the
+/// TimeZone pointer. It is up to the client to do the expected conversion based
+/// on these two values.
+///
+/// The timezone information at the end of the string may contain a timezone
+/// name (as defined in velox/type/tz/*), such as "UTC" or
+/// "America/Los_Angeles", or a timezone offset, like "+06:00" or "-09:30". The
+/// white space between the hour definition and timestamp is optional.
+///
+/// `nullptr` means no timezone information was found. Returns Unexpected with
+/// UserError status in case of parsing errors.
+Expected<std::pair<Timestamp, const tz::TimeZone*>>
+fromTimestampWithTimezoneString(
+    const char* buf,
+    size_t len,
+    TimestampParseMode parseMode);
+
+inline Expected<std::pair<Timestamp, const tz::TimeZone*>>
+fromTimestampWithTimezoneString(
+    const StringView& str,
+    TimestampParseMode parseMode) {
+  return fromTimestampWithTimezoneString(str.data(), str.size(), parseMode);
 }
 
 Timestamp fromDatetime(int64_t daysSinceEpoch, int64_t microsSinceMidnight);
 
+/// Returns the number of days since epoch for a given timestamp and optional
+/// time zone.
+int32_t toDate(const Timestamp& timestamp, const tz::TimeZone* timeZone_);
+
 } // namespace facebook::velox::util
diff --git a/velox/type/Tokenizer.cpp b/velox/type/Tokenizer.cpp
index f740596cede7e..24505ab32a768 100644
--- a/velox/type/Tokenizer.cpp
+++ b/velox/type/Tokenizer.cpp
@@ -157,7 +157,7 @@ bool Tokenizer::isUnquotedPathCharacter(char c) {
 }
 
 bool Tokenizer::isUnquotedSubscriptCharacter(char c) {
-  return c == '-' || c == '_' || isalnum(c);
+  return c == '-' || c == '_' || c == ' ' || isalnum(c);
 }
 
 std::unique_ptr<Subfield::PathElement> Tokenizer::matchQuotedSubscript() {
diff --git a/velox/type/Tree.h b/velox/type/Tree.h
index 290970480755a..269553f911e72 100644
--- a/velox/type/Tree.h
+++ b/velox/type/Tree.h
@@ -88,11 +88,11 @@ class Tree {
 
   const_iterator begin() const {
     return cbegin();
-  };
+  }
 
   const_iterator end() const {
     return cend();
-  };
+  }
 
   const_iterator cbegin() const {
     return const_iterator{*this, 0};
diff --git a/velox/type/Type.cpp b/velox/type/Type.cpp
index 697b5ccc93f16..17b88074f172e 100644
--- a/velox/type/Type.cpp
+++ b/velox/type/Type.cpp
@@ -14,12 +14,16 @@
  * limitations under the License.
  */
 
-#include "velox/type/Type.h"
+#include <velox/type/Type.h>
+
 #include <boost/algorithm/string.hpp>
+#include <fmt/format.h>
 #include <folly/Demangle.h>
 #include <re2/re2.h>
+
 #include <sstream>
 #include <typeindex>
+
 #include "velox/type/TimestampConversion.h"
 
 namespace std {
@@ -115,7 +119,7 @@ std::string mapTypeKindToName(const TypeKind& typeKind) {
   return found->second;
 }
 
-std::pair<int, int> getDecimalPrecisionScale(const Type& type) {
+std::pair<uint8_t, uint8_t> getDecimalPrecisionScale(const Type& type) {
   if (type.isShortDecimal()) {
     const auto& decimalType = static_cast<const ShortDecimalType&>(type);
     return {decimalType.precision(), decimalType.scale()};
@@ -307,33 +311,60 @@ std::vector<TypeParameter> createTypeParameters(
   return parameters;
 }
 
-// Returns children names index name -> first idx of occurence.
-const folly::F14FastMap<std::string, uint32_t> createdChildrenIndex(
-    const std::vector<std::string>& names) {
-  folly::F14FastMap<std::string, uint32_t> index;
-  index.reserve(names.size());
-  for (uint32_t i = 0; i < names.size(); ++i) {
-    if (index.find(names[i]) == index.end()) {
-      index[names[i]] = i;
+std::string namesAndTypesToString(
+    const std::vector<std::string>& names,
+    const std::vector<TypePtr>& types) {
+  std::stringstream ss;
+  ss << "[names: {";
+  if (!names.empty()) {
+    for (const auto& name : names) {
+      ss << "'" << name << "', ";
+    }
+    ss.seekp(-2, std::ios_base::cur);
+  } else {
+    ss << " ";
+  }
+  ss << "}, types: {";
+  if (!types.empty()) {
+    for (const auto& type : types) {
+      ss << (type ? type->toString() : "NULL") << ", ";
     }
+    ss.seekp(-2, std::ios_base::cur);
+  } else {
+    ss << " ";
   }
-  return index;
+  ss << "}]";
+  return ss.str();
 }
+
 } // namespace
 
 RowType::RowType(std::vector<std::string>&& names, std::vector<TypePtr>&& types)
-    : names_{std::move(names)},
-      children_{std::move(types)},
-      parameters_{createTypeParameters(children_)},
-      // TODO: lazily initialize index on first access instead.
-      childrenIndices_{createdChildrenIndex(names_)} {
-  VELOX_USER_CHECK_EQ(
-      names_.size(), children_.size(), "Mismatch names/types sizes");
+    : names_{std::move(names)}, children_{std::move(types)} {
+  VELOX_CHECK_EQ(
+      names_.size(),
+      children_.size(),
+      "Mismatch names/types sizes: {}",
+      namesAndTypesToString(names_, children_));
   for (auto& child : children_) {
-    VELOX_CHECK_NOT_NULL(child, "Child types cannot be null");
+    VELOX_CHECK_NOT_NULL(
+        child,
+        "Child types cannot be null: {}",
+        namesAndTypesToString(names_, children_));
+  }
+}
+
+RowType::~RowType() {
+  if (auto* parameters = parameters_.load()) {
+    delete parameters;
   }
 }
 
+std::unique_ptr<std::vector<TypeParameter>> RowType::makeParameters() const {
+  return std::make_unique<std::vector<TypeParameter>>(
+      createTypeParameters(children_));
+}
+
 uint32_t RowType::size() const {
   return children_.size();
 }
@@ -360,11 +391,11 @@ std::string makeFieldNotFoundErrorMessage(
 }
 } // namespace
 
-// Returns type of first child with matching name.
 const TypePtr& RowType::findChild(folly::StringPiece name) const {
-  auto idx = getChildIdxIfExists(std::string(name));
-  if (idx) {
-    return children_[*idx];
+  for (uint32_t i = 0; i < names_.size(); ++i) {
+    if (names_.at(i) == name) {
+      return children_.at(i);
+    }
   }
   VELOX_USER_FAIL(makeFieldNotFoundErrorMessage(name, names_));
 }
@@ -384,10 +415,9 @@ bool RowType::isComparable() const {
 }
 
 bool RowType::containsChild(std::string_view name) const {
-  return getChildIdxIfExists(std::string(name)).has_value();
+  return std::find(names_.begin(), names_.end(), name) != names_.end();
 }
 
-// Returns index of first child with matching name.
 uint32_t RowType::getChildIdx(const std::string& name) const {
   auto index = getChildIdxIfExists(name);
   if (!index.has_value()) {
@@ -398,9 +428,10 @@ uint32_t RowType::getChildIdx(const std::string& name) const {
 
 std::optional<uint32_t> RowType::getChildIdxIfExists(
     const std::string& name) const {
-  const auto it = childrenIndices_.find(name);
-  if (it != childrenIndices_.end()) {
-    return it->second;
+  for (uint32_t i = 0; i < names_.size(); i++) {
+    if (names_.at(i) == name) {
+      return i;
+    }
   }
   return std::nullopt;
 }
@@ -412,7 +443,7 @@ bool RowType::equivalent(const Type& other) const {
   if (!Type::hasSameTypeId(other)) {
     return false;
   }
-  auto& otherTyped = other.asRow();
+  const auto& otherTyped = other.asRow();
   if (otherTyped.size() != size()) {
     return false;
   }
@@ -425,13 +456,20 @@ bool RowType::equivalent(const Type& other) const {
 }
 
 bool RowType::equals(const Type& other) const {
-  if (!this->equivalent(other)) {
+  if (&other == this) {
+    return true;
+  }
+  if (!Type::hasSameTypeId(other)) {
+    return false;
+  }
+  const auto& otherTyped = other.asRow();
+  if (otherTyped.size() != size()) {
     return false;
   }
-  auto& otherTyped = other.asRow();
   for (size_t i = 0; i < size(); ++i) {
     // todo: case sensitivity
-    if (nameOf(i) != otherTyped.nameOf(i)) {
+    if (nameOf(i) != otherTyped.nameOf(i) ||
+        *childAt(i) != *otherTyped.childAt(i)) {
       return false;
     }
   }
@@ -696,25 +734,21 @@ std::shared_ptr<const RowType> ROW(
 }
 
 std::shared_ptr<const RowType> ROW(std::vector<TypePtr>&& types) {
-  std::vector<std::string> names;
-  names.reserve(types.size());
-  for (auto& p : types) {
-    names.push_back("");
-  }
+  std::vector<std::string> names(types.size(), "");
   return TypeFactory<TypeKind::ROW>::create(std::move(names), std::move(types));
 }
 
 std::shared_ptr<const MapType> MAP(TypePtr keyType, TypePtr valType) {
   return std::make_shared<const MapType>(
       std::move(keyType), std::move(valType));
-};
+}
 
 std::shared_ptr<const FunctionType> FUNCTION(
     std::vector<TypePtr>&& argumentTypes,
     TypePtr returnType) {
   return std::make_shared<const FunctionType>(
       std::move(argumentTypes), std::move(returnType));
-};
+}
 
 #define VELOX_DEFINE_SCALAR_ACCESSOR(KIND)                   \
   std::shared_ptr<const ScalarType<TypeKind::KIND>> KIND() { \
@@ -872,37 +906,6 @@ exec::CastOperatorPtr getCustomTypeCastOperator(const std::string& name) {
   return nullptr;
 }
 
-TypePtr fromKindToScalerType(TypeKind kind) {
-  switch (kind) {
-    case TypeKind::TINYINT:
-      return TINYINT();
-    case TypeKind::BOOLEAN:
-      return BOOLEAN();
-    case TypeKind::SMALLINT:
-      return SMALLINT();
-    case TypeKind::BIGINT:
-      return BIGINT();
-    case TypeKind::INTEGER:
-      return INTEGER();
-    case TypeKind::REAL:
-      return REAL();
-    case TypeKind::VARCHAR:
-      return VARCHAR();
-    case TypeKind::VARBINARY:
-      return VARBINARY();
-    case TypeKind::TIMESTAMP:
-      return TIMESTAMP();
-    case TypeKind::DOUBLE:
-      return DOUBLE();
-    case TypeKind::UNKNOWN:
-      return UNKNOWN();
-    default:
-      VELOX_UNSUPPORTED(
-          "Kind is not a scalar type: {}", mapTypeKindToName(kind));
-      return nullptr;
-  }
-}
-
 void toTypeSql(const TypePtr& type, std::ostream& out) {
   switch (type->kind()) {
     case TypeKind::ARRAY:
@@ -943,9 +946,14 @@ void toTypeSql(const TypePtr& type, std::ostream& out) {
 }
 
 std::string IntervalDayTimeType::valueToString(int64_t value) const {
-  static const char* kIntervalFormat = "%d %02d:%02d:%02d.%03d";
+  static const char* kIntervalFormat = "%s%lld %02d:%02d:%02d.%03d";
 
-  int64_t remainMillis = value;
+  int128_t remainMillis = value;
+  std::string sign{};
+  if (remainMillis < 0) {
+    sign = "-";
+    remainMillis = -remainMillis;
+  }
   const int64_t days = remainMillis / kMillisInDay;
   remainMillis -= days * kMillisInDay;
   const int64_t hours = remainMillis / kMillisInHour;
@@ -959,6 +967,7 @@ std::string IntervalDayTimeType::valueToString(int64_t value) const {
       buf,
       sizeof(buf),
       kIntervalFormat,
+      sign.c_str(),
       days,
       hours,
       minutes,
@@ -971,32 +980,49 @@ std::string IntervalDayTimeType::valueToString(int64_t value) const {
 std::string IntervalYearMonthType::valueToString(int32_t value) const {
   std::ostringstream oss;
   auto sign = "";
-  if (value < 0) {
+  int64_t longValue = value;
+  if (longValue < 0) {
     sign = "-";
-    value = -value;
+    longValue = -longValue;
   }
-  oss << fmt::format("{}{}-{}", sign, value / 12, value % 12);
+  oss << fmt::format("{}{}-{}", sign, longValue / 12, longValue % 12);
   return oss.str();
 }
 
 std::string DateType::toString(int32_t days) const {
+  return DateType::toIso8601(days);
+}
+
+std::string DateType::toIso8601(int32_t days) {
   // Find the number of seconds for the days_;
   // Casting 86400 to int64 to handle overflows gracefully.
   int64_t daySeconds = days * (int64_t)(86400);
   std::tm tmValue;
   VELOX_CHECK(
-      epochToUtc(daySeconds, tmValue), "Can't convert days to dates: {}", days);
+      Timestamp::epochToCalendarUtc(daySeconds, tmValue),
+      "Can't convert days to dates: {}",
+      days);
   TimestampToStringOptions options;
-  options.dateOnly = true;
-  return tmToString(tmValue, 0, options);
+  options.mode = TimestampToStringOptions::Mode::kDateOnly;
+  // Enable zero-padding for year, to ensure compliance with 'YYYY' format.
+  options.zeroPaddingYear = true;
+  std::string result;
+  result.resize(getMaxStringLength(options));
+  const auto view =
+      Timestamp::tmToStringView(tmValue, 0, options, result.data());
+  result.resize(view.size());
+  return result;
 }
 
 int32_t DateType::toDays(folly::StringPiece in) const {
-  return util::fromDateString(in.data(), in.size());
+  return toDays(in.data(), in.size());
 }
 
 int32_t DateType::toDays(const char* in, size_t len) const {
-  return util::fromDateString(in, len);
+  return util::fromDateString(in, len, util::ParseMode::kPrestoCast)
+      .thenOrThrow(folly::identity, [&](const Status& status) {
+        VELOX_USER_FAIL("{}", status.message());
+      });
 }
 
 namespace {
@@ -1021,7 +1047,7 @@ const SingletonTypeMap& singletonBuiltInTypes() {
       {"UNKNOWN", UNKNOWN()},
   };
   return kTypes;
-};
+}
 
 class DecimalParametricType {
  public:
diff --git a/velox/type/Type.h b/velox/type/Type.h
index a770e7ef0cd33..535bdd1e8ce09 100644
--- a/velox/type/Type.h
+++ b/velox/type/Type.h
@@ -15,12 +15,10 @@
  */
 #pragma once
 
-#include <fmt/core.h>
-#include <fmt/format.h>
-#include <folly/Format.h>
+#include <folly/CPortability.h>
 #include <folly/Range.h>
-#include <folly/String.h>
-#include <folly/json.h>
+#include <folly/dynamic.h>
+
 #include <cstdint>
 #include <cstring>
 #include <ctime>
@@ -33,7 +31,6 @@
 #include <typeindex>
 #include <vector>
 
-#include "folly/CPortability.h"
 #include "velox/common/base/ClassName.h"
 #include "velox/common/serialization/Serializable.h"
 #include "velox/type/HugeInt.h"
@@ -437,7 +434,8 @@ struct TypeParameter {
 ///                   BigintType
 class Type : public Tree<const TypePtr>, public velox::ISerializable {
  public:
-  explicit Type(TypeKind kind) : kind_{kind} {}
+  explicit Type(TypeKind kind, bool providesCustomComparison = false)
+      : kind_{kind}, providesCustomComparison_(providesCustomComparison) {}
 
   TypeKind kind() const {
     return kind_;
@@ -467,6 +465,13 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   /// are, while map types are not orderable.
   virtual bool isOrderable() const = 0;
 
+  /// Returns true if values of this type implements custom comparison and hash
+  /// functions. If this returns true the compare and hash functions in TypeBase
+  /// should be used instead of native implementations, e.g. ==, <, >, etc.
+  bool providesCustomComparison() const {
+    return providesCustomComparison_;
+  }
+
   /// Returns unique logical type name. It can be
   /// different from the physical type name returned by 'kindName()'.
   virtual const char* name() const = 0;
@@ -541,6 +546,7 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   VELOX_FLUENT_CAST(Row, ROW)
   VELOX_FLUENT_CAST(Opaque, OPAQUE)
   VELOX_FLUENT_CAST(UnKnown, UNKNOWN)
+  VELOX_FLUENT_CAST(Function, FUNCTION)
 
   const ShortDecimalType& asShortDecimal() const;
   const LongDecimalType& asLongDecimal() const;
@@ -562,6 +568,7 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
 
  private:
   const TypeKind kind_;
+  const bool providesCustomComparison_;
 
   VELOX_DEFINE_CLASS_NAME(Type)
 };
@@ -571,9 +578,16 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
 template <TypeKind KIND>
 class TypeBase : public Type {
  public:
-  using NativeType = TypeTraits<KIND>;
-
-  TypeBase() : Type{KIND} {}
+  using NativeType = typename TypeTraits<KIND>::NativeType;
+
+  explicit TypeBase(bool providesCustomComparison = false)
+      : Type{KIND, providesCustomComparison} {
+    if (providesCustomComparison) {
+      VELOX_CHECK(
+          isPrimitiveType() && isFixedWidth(),
+          "Custom comparisons are only supported for primite types that are fixed width.");
+    }
+  }
 
   bool isPrimitiveType() const override {
     return TypeTraits<KIND>::isPrimitiveType;
@@ -606,8 +620,35 @@ class TypeBase : public Type {
 };
 
 template <TypeKind KIND>
-class ScalarType : public TypeBase<KIND> {
+class CanProvideCustomComparisonType : public TypeBase<KIND> {
+ public:
+  explicit CanProvideCustomComparisonType(bool providesCustomComparison = false)
+      : TypeBase<KIND>{providesCustomComparison} {}
+
+  virtual int32_t compare(
+      const typename TypeBase<KIND>::NativeType& /*left*/,
+      const typename TypeBase<KIND>::NativeType& /*right*/) const {
+    VELOX_CHECK(
+        !this->providesCustomComparison(),
+        "Type {} is marked as providesCustomComparison but did not implement compare.");
+    VELOX_FAIL("Type {} does not provide custom comparison", this->name());
+  }
+
+  virtual uint64_t hash(
+      const typename TypeBase<KIND>::NativeType& /*value*/) const {
+    VELOX_CHECK(
+        !this->providesCustomComparison(),
+        "Type {} is marked as providesCustomComparison but did not implement hash.");
+    VELOX_FAIL("Type {} does not provide custom hash", this->name());
+  }
+};
+
+template <TypeKind KIND>
+class ScalarType : public CanProvideCustomComparisonType<KIND> {
  public:
+  explicit ScalarType(bool providesCustomComparison = false)
+      : CanProvideCustomComparisonType<KIND>{providesCustomComparison} {}
+
   uint32_t size() const override {
     return 0;
   }
@@ -659,14 +700,14 @@ const std::shared_ptr<const ScalarType<KIND>> ScalarType<KIND>::create() {
 
 /// This class represents the fixed-point numbers.
 /// The parameter "precision" represents the number of digits the
-/// Decimal Type can support and "scale" represents the number of digits to the
-/// right of the decimal point.
+/// Decimal Type can support and "scale" represents the number of digits to
+/// the right of the decimal point.
 template <TypeKind KIND>
 class DecimalType : public ScalarType<KIND> {
  public:
   static_assert(KIND == TypeKind::BIGINT || KIND == TypeKind::HUGEINT);
   static constexpr uint8_t kMaxPrecision = KIND == TypeKind::BIGINT ? 18 : 38;
-  static constexpr uint8_t kMinPrecision = KIND == TypeKind::BIGINT ? 0 : 19;
+  static constexpr uint8_t kMinPrecision = KIND == TypeKind::BIGINT ? 1 : 19;
 
   inline bool equivalent(const Type& other) const override {
     if (!Type::hasSameTypeId(other)) {
@@ -767,11 +808,13 @@ FOLLY_ALWAYS_INLINE bool isDecimalName(const std::string& name) {
   return (name == "DECIMAL");
 }
 
-std::pair<int, int> getDecimalPrecisionScale(const Type& type);
+std::pair<uint8_t, uint8_t> getDecimalPrecisionScale(const Type& type);
 
-class UnknownType : public TypeBase<TypeKind::UNKNOWN> {
+class UnknownType : public CanProvideCustomComparisonType<TypeKind::UNKNOWN> {
  public:
-  UnknownType() = default;
+  explicit UnknownType(bool proivdesCustomComparison = false)
+      : CanProvideCustomComparisonType<TypeKind::UNKNOWN>(
+            proivdesCustomComparison) {}
 
   uint32_t size() const override {
     return 0;
@@ -789,6 +832,14 @@ class UnknownType : public TypeBase<TypeKind::UNKNOWN> {
     return 0;
   }
 
+  bool isOrderable() const override {
+    return true;
+  }
+
+  bool isComparable() const override {
+    return true;
+  }
+
   bool equivalent(const Type& other) const override {
     return Type::hasSameTypeId(other);
   }
@@ -915,6 +966,8 @@ class RowType : public TypeBase<TypeKind::ROW> {
       std::vector<std::string>&& names,
       std::vector<std::shared_ptr<const Type>>&& types);
 
+  ~RowType() override;
+
   uint32_t size() const override;
 
   const std::shared_ptr<const Type>& childAt(uint32_t idx) const override;
@@ -961,14 +1014,24 @@ class RowType : public TypeBase<TypeKind::ROW> {
   }
 
   const std::vector<TypeParameter>& parameters() const override {
-    return parameters_;
+    auto* parameters = parameters_.load();
+    if (FOLLY_UNLIKELY(!parameters)) {
+      parameters = makeParameters().release();
+      std::vector<TypeParameter>* oldParameters = nullptr;
+      if (!parameters_.compare_exchange_strong(oldParameters, parameters)) {
+        delete parameters;
+        parameters = oldParameters;
+      }
+    }
+    return *parameters;
   }
 
  private:
+  std::unique_ptr<std::vector<TypeParameter>> makeParameters() const;
+
   const std::vector<std::string> names_;
   const std::vector<std::shared_ptr<const Type>> children_;
-  const std::vector<TypeParameter> parameters_;
-  const folly::F14FastMap<std::string, uint32_t> childrenIndices_;
+  mutable std::atomic<std::vector<TypeParameter>*> parameters_{nullptr};
 };
 
 using RowTypePtr = std::shared_ptr<const RowType>;
@@ -1059,11 +1122,12 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
   folly::dynamic serialize() const override;
   /// In special cases specific OpaqueTypes might want to serialize additional
   /// metadata. In those cases we need to deserialize it back. Since
-  /// OpaqueType::create<T>() returns canonical type for T without metadata, we
-  /// allow to create new instance here or return nullptr if the same one can be
-  /// used. Note that it's about deserialization of type itself, DeserializeFunc
-  /// above is about deserializing instances of the type. It's implemented as a
-  /// virtual member instead of a standalone registry just for convenience.
+  /// OpaqueType::create<T>() returns canonical type for T without metadata,
+  /// we allow to create new instance here or return nullptr if the same one
+  /// can be used. Note that it's about deserialization of type itself,
+  /// DeserializeFunc above is about deserializing instances of the type. It's
+  /// implemented as a virtual member instead of a standalone registry just
+  /// for convenience.
   virtual std::shared_ptr<const OpaqueType> deserializeExtra(
       const folly::dynamic& json) const;
 
@@ -1218,8 +1282,8 @@ class IntervalYearMonthType : public IntegerType {
   }
 
   /// Returns the interval 'value' (months) formatted as YEARS MONTHS.
-  /// For example, 14 months (INTERVAL '1-2' YEAR TO MONTH) would be represented
-  /// as 1-2; -14 months would be represents as -1-2.
+  /// For example, 14 months (INTERVAL '1-2' YEAR TO MONTH) would be
+  /// represented as 1-2; -14 months would be represents as -1-2.
   std::string valueToString(int32_t value) const;
 
   folly::dynamic serialize() const override {
@@ -1269,6 +1333,10 @@ class DateType : public IntegerType {
 
   std::string toString(int32_t days) const;
 
+  /// Returns a date, represented as days since epoch,
+  /// as an ISO 8601-formatted string.
+  static std::string toIso8601(int32_t days);
+
   int32_t toDays(folly::StringPiece in) const;
 
   int32_t toDays(const char* in, size_t len) const;
@@ -1480,6 +1548,70 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
     }                                                                    \
   }()
 
+#define VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(TEMPLATE_FUNC, T, typeKind, ...) \
+  [&]() {                                                                     \
+    switch (typeKind) {                                                       \
+      case ::facebook::velox::TypeKind::BOOLEAN: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::BOOLEAN>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::INTEGER: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::INTEGER>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::TINYINT: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::TINYINT>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::SMALLINT: {                           \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::SMALLINT>(       \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::BIGINT: {                             \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::BIGINT>(         \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::HUGEINT: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::HUGEINT>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::REAL: {                               \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::REAL>(           \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::DOUBLE: {                             \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::DOUBLE>(         \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::VARCHAR: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::VARCHAR>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::VARBINARY: {                          \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::VARBINARY>(      \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::TIMESTAMP: {                          \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::TIMESTAMP>(      \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::MAP: {                                \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::MAP>(            \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::ARRAY: {                              \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::ARRAY>(          \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::ROW: {                                \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::ROW>(            \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      default:                                                                \
+        VELOX_FAIL("not a known type kind: {}", mapTypeKindToName(typeKind)); \
+    }                                                                         \
+  }()
+
 #define VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(TEMPLATE_FUNC, typeKind, ...)   \
   [&]() {                                                                      \
     if ((typeKind) == ::facebook::velox::TypeKind::UNKNOWN) {                  \
@@ -1716,152 +1848,6 @@ std::shared_ptr<const Type> createType<TypeKind::OPAQUE>(
 
 #undef VELOX_SCALAR_ACCESSOR
 
-template <typename UNDERLYING_TYPE>
-struct Variadic {
-  using underlying_type = UNDERLYING_TYPE;
-
-  Variadic() = delete;
-};
-
-// A type that can be used in simple function to represent any type.
-// Two Generics with the same type variables should bound to the same type.
-template <size_t id>
-struct TypeVariable {
-  static size_t getId() {
-    return id;
-  }
-};
-
-using T1 = TypeVariable<1>;
-using T2 = TypeVariable<2>;
-using T3 = TypeVariable<3>;
-using T4 = TypeVariable<4>;
-using T5 = TypeVariable<5>;
-using T6 = TypeVariable<6>;
-using T7 = TypeVariable<7>;
-using T8 = TypeVariable<8>;
-
-struct AnyType {};
-
-template <typename T = AnyType>
-struct Generic {
-  Generic() = delete;
-};
-
-using Any = Generic<>;
-
-template <typename>
-struct isVariadicType : public std::false_type {};
-
-template <typename T>
-struct isVariadicType<Variadic<T>> : public std::true_type {};
-
-template <typename>
-struct isGenericType : public std::false_type {};
-
-template <typename T>
-struct isGenericType<Generic<T>> : public std::true_type {};
-
-template <typename>
-struct isOpaqueType : public std::false_type {};
-
-template <typename T>
-struct isOpaqueType<std::shared_ptr<T>> : public std::true_type {};
-
-template <typename KEY, typename VALUE>
-struct Map {
-  using key_type = KEY;
-  using value_type = VALUE;
-
-  static_assert(
-      !isVariadicType<key_type>::value,
-      "Map keys cannot be Variadic");
-  static_assert(
-      !isVariadicType<value_type>::value,
-      "Map values cannot be Variadic");
-
- private:
-  Map() {}
-};
-
-template <typename ELEMENT>
-struct Array {
-  using element_type = ELEMENT;
-
-  static_assert(
-      !isVariadicType<element_type>::value,
-      "Array elements cannot be Variadic");
-
- private:
-  Array() {}
-};
-
-template <typename ELEMENT>
-using ArrayWriterT = Array<ELEMENT>;
-
-template <typename... T>
-struct Row {
-  template <size_t idx>
-  using type_at = typename std::tuple_element<idx, std::tuple<T...>>::type;
-
-  static const size_t size_ = sizeof...(T);
-
-  static_assert(
-      std::conjunction<std::bool_constant<!isVariadicType<T>::value>...>::value,
-      "Struct fields cannot be Variadic");
-
- private:
-  Row() {}
-};
-
-struct DynamicRow {
- private:
-  DynamicRow() {}
-};
-
-// T must be a struct with T::type being a built-in type and T::typeName
-// type name to use in FunctionSignature.
-template <typename T>
-struct CustomType {
- private:
-  CustomType() {}
-};
-
-template <typename T>
-struct UnwrapCustomType {
-  using type = T;
-};
-
-template <typename T>
-struct UnwrapCustomType<CustomType<T>> {
-  using type = typename T::type;
-};
-
-struct IntervalDayTime {
- private:
-  IntervalDayTime() {}
-};
-
-struct IntervalYearMonth {
- private:
-  IntervalYearMonth() {}
-};
-
-struct Date {
- private:
-  Date() {}
-};
-
-struct Varbinary {
- private:
-  Varbinary() {}
-};
-
-struct Varchar {
- private:
-  Varchar() {}
-};
-
 template <typename T>
 struct SimpleTypeTrait {};
 
@@ -1889,206 +1875,12 @@ struct SimpleTypeTrait<double> : public TypeTraits<TypeKind::DOUBLE> {};
 template <>
 struct SimpleTypeTrait<bool> : public TypeTraits<TypeKind::BOOLEAN> {};
 
-template <>
-struct SimpleTypeTrait<Varchar> : public TypeTraits<TypeKind::VARCHAR> {};
-
-template <>
-struct SimpleTypeTrait<Varbinary> : public TypeTraits<TypeKind::VARBINARY> {};
-
 template <>
 struct SimpleTypeTrait<Timestamp> : public TypeTraits<TypeKind::TIMESTAMP> {};
 
-template <>
-struct SimpleTypeTrait<Date> : public SimpleTypeTrait<int32_t> {
-  static constexpr const char* name = "DATE";
-};
-
-template <>
-struct SimpleTypeTrait<IntervalDayTime> : public SimpleTypeTrait<int64_t> {
-  static constexpr const char* name = "INTERVAL DAY TO SECOND";
-};
-
-template <>
-struct SimpleTypeTrait<IntervalYearMonth> : public SimpleTypeTrait<int32_t> {
-  static constexpr const char* name = "INTERVAL YEAR TO MONTH";
-};
-
-template <typename T>
-struct SimpleTypeTrait<Generic<T>> {
-  static constexpr TypeKind typeKind = TypeKind::UNKNOWN;
-  static constexpr bool isPrimitiveType = false;
-  static constexpr bool isFixedWidth = false;
-};
-
-template <typename T>
-struct SimpleTypeTrait<std::shared_ptr<T>>
-    : public TypeTraits<TypeKind::OPAQUE> {};
-
-template <typename KEY, typename VAL>
-struct SimpleTypeTrait<Map<KEY, VAL>> : public TypeTraits<TypeKind::MAP> {};
-
-template <typename ELEMENT>
-struct SimpleTypeTrait<Array<ELEMENT>> : public TypeTraits<TypeKind::ARRAY> {};
-
-template <typename... T>
-struct SimpleTypeTrait<Row<T...>> : public TypeTraits<TypeKind::ROW> {};
-
-template <>
-struct SimpleTypeTrait<DynamicRow> : public TypeTraits<TypeKind::ROW> {};
-
-// T is also a simple type that represent the physical type of the custom type.
-template <typename T>
-struct SimpleTypeTrait<CustomType<T>>
-    : public SimpleTypeTrait<typename T::type> {
-  using physical_t = SimpleTypeTrait<typename T::type>;
-  static constexpr TypeKind typeKind = physical_t::typeKind;
-  static constexpr bool isPrimitiveType = physical_t::isPrimitiveType;
-  static constexpr bool isFixedWidth = physical_t::isFixedWidth;
-
-  // This is different than the physical type name.
-  static constexpr char* name = T::typeName;
-};
-
 template <>
 struct SimpleTypeTrait<UnknownValue> : public TypeTraits<TypeKind::UNKNOWN> {};
 
-// TODO: move cppToType testing utilities.
-template <typename T>
-struct CppToType {};
-
-template <TypeKind KIND>
-struct CppToTypeBase : public TypeTraits<KIND> {
-  static auto create() {
-    return TypeFactory<KIND>::create();
-  }
-};
-
-template <>
-struct CppToType<int128_t> : public CppToTypeBase<TypeKind::HUGEINT> {};
-
-template <>
-struct CppToType<__uint128_t> : public CppToTypeBase<TypeKind::HUGEINT> {};
-
-template <>
-struct CppToType<int64_t> : public CppToTypeBase<TypeKind::BIGINT> {};
-
-template <>
-struct CppToType<uint64_t> : public CppToTypeBase<TypeKind::BIGINT> {};
-
-template <>
-struct CppToType<int32_t> : public CppToTypeBase<TypeKind::INTEGER> {};
-
-template <>
-struct CppToType<uint32_t> : public CppToTypeBase<TypeKind::INTEGER> {};
-
-template <>
-struct CppToType<int16_t> : public CppToTypeBase<TypeKind::SMALLINT> {};
-
-template <>
-struct CppToType<uint16_t> : public CppToTypeBase<TypeKind::SMALLINT> {};
-
-template <>
-struct CppToType<int8_t> : public CppToTypeBase<TypeKind::TINYINT> {};
-
-template <>
-struct CppToType<uint8_t> : public CppToTypeBase<TypeKind::TINYINT> {};
-
-template <>
-struct CppToType<bool> : public CppToTypeBase<TypeKind::BOOLEAN> {};
-
-template <>
-struct CppToType<Varchar> : public CppToTypeBase<TypeKind::VARCHAR> {};
-
-template <>
-struct CppToType<folly::StringPiece> : public CppToTypeBase<TypeKind::VARCHAR> {
-};
-
-template <>
-struct CppToType<velox::StringView> : public CppToTypeBase<TypeKind::VARCHAR> {
-};
-
-template <>
-struct CppToType<std::string_view> : public CppToTypeBase<TypeKind::VARCHAR> {};
-
-template <>
-struct CppToType<std::string> : public CppToTypeBase<TypeKind::VARCHAR> {};
-
-template <>
-struct CppToType<const char*> : public CppToTypeBase<TypeKind::VARCHAR> {};
-
-template <>
-struct CppToType<Varbinary> : public CppToTypeBase<TypeKind::VARBINARY> {};
-
-template <>
-struct CppToType<folly::ByteRange> : public CppToTypeBase<TypeKind::VARBINARY> {
-};
-
-template <>
-struct CppToType<float> : public CppToTypeBase<TypeKind::REAL> {};
-
-template <>
-struct CppToType<double> : public CppToTypeBase<TypeKind::DOUBLE> {};
-
-template <>
-struct CppToType<Timestamp> : public CppToTypeBase<TypeKind::TIMESTAMP> {};
-
-template <>
-struct CppToType<Date> : public CppToTypeBase<TypeKind::INTEGER> {};
-
-template <typename T>
-struct CppToType<Generic<T>> : public CppToTypeBase<TypeKind::UNKNOWN> {};
-
-// TODO: maybe do something smarter than just matching any shared_ptr, e.g. we
-// can declare "registered" types explicitly
-template <typename T>
-struct CppToType<std::shared_ptr<T>> : public CppToTypeBase<TypeKind::OPAQUE> {
-  // We override the type with the concrete specialization here!
-  // using NativeType = std::shared_ptr<T>;
-  static auto create() {
-    return OpaqueType::create<T>();
-  }
-};
-
-template <typename KEY, typename VAL>
-struct CppToType<Map<KEY, VAL>> : public TypeTraits<TypeKind::MAP> {
-  static auto create() {
-    return MAP(CppToType<KEY>::create(), CppToType<VAL>::create());
-  }
-};
-
-template <typename ELEMENT>
-struct CppToType<Array<ELEMENT>> : public TypeTraits<TypeKind::ARRAY> {
-  static auto create() {
-    return ARRAY(CppToType<ELEMENT>::create());
-  }
-};
-
-template <typename... T>
-struct CppToType<Row<T...>> : public TypeTraits<TypeKind::ROW> {
-  static auto create() {
-    return ROW({CppToType<T>::create()...});
-  }
-};
-
-template <>
-struct CppToType<DynamicRow> : public TypeTraits<TypeKind::ROW> {
-  static std::shared_ptr<const Type> create() {
-    throw std::logic_error{"can't determine exact type for DynamicRow"};
-  }
-};
-
-template <>
-struct CppToType<UnknownValue> : public CppToTypeBase<TypeKind::UNKNOWN> {};
-
-template <typename T>
-struct CppToType<CustomType<T>> : public CppToType<typename T::type> {
-  static auto create() {
-    return CppToType<typename T::type>::create();
-  }
-};
-
-// todo: remaining cpp2type
-
 template <TypeKind KIND>
 static inline int32_t sizeOfTypeKindHelper() {
   return sizeof(typename TypeTraits<KIND>::NativeType);
@@ -2150,8 +1942,8 @@ using CastOperatorPtr = std::shared_ptr<const CastOperator>;
 
 } // namespace exec
 
-/// Associates custom types with their custom operators to be the payload in the
-/// custom type registry.
+/// Associates custom types with their custom operators to be the payload in
+/// the custom type registry.
 class CustomTypeFactories {
  public:
   virtual ~CustomTypeFactories() = default;
@@ -2166,9 +1958,9 @@ class CustomTypeFactories {
   virtual exec::CastOperatorPtr getCastOperator() const = 0;
 };
 
-/// Adds custom type to the registry if it doesn't exist already. No-op if type
-/// with specified name already exists. Returns true if type was added, false if
-/// type with the specified name already exists.
+/// Adds custom type to the registry if it doesn't exist already. No-op if
+/// type with specified name already exists. Returns true if type was added,
+/// false if type with the specified name already exists.
 bool registerCustomType(
     const std::string& name,
     std::unique_ptr<const CustomTypeFactories> factories);
@@ -2200,141 +1992,9 @@ void toAppend(
   result->append(type->toString());
 }
 
-template <typename T>
-struct MaterializeType {
-  using null_free_t = T;
-  using nullable_t = T;
-  static constexpr bool requiresMaterialization = false;
-};
-
-template <typename V>
-struct MaterializeType<Array<V>> {
-  using null_free_t = std::vector<typename MaterializeType<V>::null_free_t>;
-  using nullable_t =
-      std::vector<std::optional<typename MaterializeType<V>::nullable_t>>;
-  static constexpr bool requiresMaterialization = true;
-};
-
-template <typename K, typename V>
-struct MaterializeType<Map<K, V>> {
-  using key_t = typename MaterializeType<K>::null_free_t;
-
-  using nullable_t = folly::
-      F14FastMap<key_t, std::optional<typename MaterializeType<V>::nullable_t>>;
-
-  using null_free_t =
-      folly::F14FastMap<key_t, typename MaterializeType<V>::null_free_t>;
-  static constexpr bool requiresMaterialization = true;
-};
-
-template <typename... T>
-struct MaterializeType<Row<T...>> {
-  using nullable_t =
-      std::tuple<std::optional<typename MaterializeType<T>::nullable_t>...>;
-
-  using null_free_t = std::tuple<typename MaterializeType<T>::null_free_t...>;
-  static constexpr bool requiresMaterialization = true;
-};
-
-template <typename T>
-struct MaterializeType<std::shared_ptr<T>> {
-  using nullable_t = T;
-  using null_free_t = T;
-  static constexpr bool requiresMaterialization = false;
-};
-
-template <typename T>
-struct MaterializeType<CustomType<T>> {
-  using inner_materialize_t = MaterializeType<typename T::type>;
-  using nullable_t = typename inner_materialize_t::nullable_t;
-  using null_free_t = typename inner_materialize_t::null_free_t;
-  static constexpr bool requiresMaterialization =
-      inner_materialize_t::requiresMaterialization;
-};
-
-template <>
-struct MaterializeType<Varchar> {
-  using nullable_t = std::string;
-  using null_free_t = std::string;
-  static constexpr bool requiresMaterialization = false;
-};
-
-template <>
-struct MaterializeType<Varbinary> {
-  using nullable_t = std::string;
-  using null_free_t = std::string;
-  static constexpr bool requiresMaterialization = false;
-};
-
-// Recursively check that T and vectorType associate to the same TypeKind.
-template <typename T>
-struct CastTypeChecker {
-  static_assert(
-      CppToType<T>::maxSubTypes == 0,
-      "Complex types should be checked separately.");
-
-  static bool check(const TypePtr& vectorType) {
-    return CppToType<T>::typeKind == vectorType->kind();
-  }
-};
-
-template <>
-struct CastTypeChecker<DynamicRow> {
-  static bool check(const TypePtr& vectorType) {
-    return TypeKind::ROW == vectorType->kind();
-  }
-};
-
-template <typename T>
-struct CastTypeChecker<Generic<T>> {
-  static bool check(const TypePtr&) {
-    return true;
-  }
-};
-
-template <typename T>
-struct CastTypeChecker<Array<T>> {
-  static bool check(const TypePtr& vectorType) {
-    return TypeKind::ARRAY == vectorType->kind() &&
-        CastTypeChecker<T>::check(vectorType->childAt(0));
-  }
-};
-
-template <typename K, typename V>
-struct CastTypeChecker<Map<K, V>> {
-  static bool check(const TypePtr& vectorType) {
-    return TypeKind::MAP == vectorType->kind() &&
-        CastTypeChecker<K>::check(vectorType->childAt(0)) &&
-        CastTypeChecker<V>::check(vectorType->childAt(1));
-  }
-};
-
-template <typename... T>
-struct CastTypeChecker<Row<T...>> {
-  static bool check(const TypePtr& vectorType) {
-    int index = 0;
-    return TypeKind::ROW == vectorType->kind() &&
-        (CastTypeChecker<T>::check(vectorType->childAt(index++)) && ... &&
-         true);
-  }
-};
-
-/// Return the scalar type for a given 'kind'.
-TypePtr fromKindToScalerType(TypeKind kind);
-
 /// Appends type's SQL string to 'out'. Uses DuckDB SQL.
 void toTypeSql(const TypePtr& type, std::ostream& out);
 
-template <typename T>
-struct IsRowType {
-  static constexpr bool value = false;
-};
-
-template <typename... Ts>
-struct IsRowType<Row<Ts...>> {
-  static constexpr bool value = true;
-};
-
 } // namespace facebook::velox
 
 namespace folly {
@@ -2385,14 +2045,11 @@ class FormatValue<
 } // namespace folly
 
 template <>
-struct fmt::formatter<facebook::velox::TypeKind> {
-  constexpr auto parse(format_parse_context& ctx) {
-    return ctx.begin();
-  }
-
+struct fmt::formatter<facebook::velox::TypeKind> : fmt::formatter<string_view> {
   template <typename FormatContext>
-  auto format(const facebook::velox::TypeKind& k, FormatContext& ctx) const {
-    return format_to(ctx.out(), "{}", facebook::velox::mapTypeKindToName(k));
+  auto format(facebook::velox::TypeKind k, FormatContext& ctx) const {
+    return formatter<string_view>::format(
+        facebook::velox::mapTypeKindToName(k), ctx);
   }
 };
 
@@ -2400,13 +2057,10 @@ template <typename T>
 struct fmt::formatter<
     std::shared_ptr<T>,
     typename std::
-        enable_if_t<std::is_base_of_v<facebook::velox::Type, T>, char>> {
-  constexpr auto parse(format_parse_context& ctx) {
-    return ctx.begin();
-  }
-
+        enable_if_t<std::is_base_of_v<facebook::velox::Type, T>, char>>
+    : fmt::formatter<string_view> {
   template <typename FormatContext>
   auto format(const std::shared_ptr<T>& k, FormatContext& ctx) const {
-    return format_to(ctx.out(), "{}", k->toString());
+    return formatter<string_view>::format(k->toString(), ctx);
   }
 };
diff --git a/velox/type/Variant.cpp b/velox/type/Variant.cpp
index 6b20761d84cef..d9db54850d865 100644
--- a/velox/type/Variant.cpp
+++ b/velox/type/Variant.cpp
@@ -19,6 +19,7 @@
 #include "folly/json.h"
 #include "velox/common/encode/Base64.h"
 #include "velox/type/DecimalUtil.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/type/HugeInt.h"
 
 namespace facebook::velox {
@@ -272,9 +273,8 @@ std::string variant::toJson(const TypePtr& type) const {
       return target;
     }
     case TypeKind::HUGEINT: {
-      VELOX_CHECK(type->isLongDecimal()) {
-        return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
-      }
+      VELOX_CHECK(type->isLongDecimal());
+      return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
     }
     case TypeKind::TINYINT:
       [[fallthrough]];
@@ -399,9 +399,8 @@ std::string variant::toJsonUnsafe(const TypePtr& type) const {
       return target;
     }
     case TypeKind::HUGEINT: {
-      VELOX_CHECK(type && type->isLongDecimal()) {
-        return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
-      }
+      VELOX_CHECK(type && type->isLongDecimal());
+      return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
     }
     case TypeKind::TINYINT:
       [[fallthrough]];
@@ -670,7 +669,54 @@ variant variant::create(const folly::dynamic& variantobj) {
   }
 }
 
+template <TypeKind KIND>
+bool variant::lessThan(const variant& a, const variant& b) const {
+  using namespace facebook::velox::util::floating_point;
+  if (a.isNull() && !b.isNull()) {
+    return true;
+  }
+  if (a.isNull() || b.isNull()) {
+    return false;
+  }
+  using T = typename TypeTraits<KIND>::NativeType;
+  if constexpr (std::is_floating_point_v<T>) {
+    return NaNAwareLessThan<T>{}(a.value<KIND>(), b.value<KIND>());
+  }
+  return a.value<KIND>() < b.value<KIND>();
+}
+
+bool variant::operator<(const variant& other) const {
+  if (other.kind_ != this->kind_) {
+    return other.kind_ < this->kind_;
+  }
+  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(lessThan, kind_, *this, other);
+}
+
+template <TypeKind KIND>
+bool variant::equals(const variant& a, const variant& b) const {
+  using namespace facebook::velox::util::floating_point;
+  if (a.isNull() || b.isNull()) {
+    return false;
+  }
+  using T = typename TypeTraits<KIND>::NativeType;
+  if constexpr (std::is_floating_point_v<T>) {
+    return NaNAwareEquals<T>{}(a.value<KIND>(), b.value<KIND>());
+  }
+  return a.value<KIND>() == b.value<KIND>();
+}
+
+bool variant::equals(const variant& other) const {
+  if (other.kind_ != this->kind_) {
+    return false;
+  }
+  if (other.isNull()) {
+    return this->isNull();
+  }
+  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(equals, kind_, *this, other);
+}
+
 uint64_t variant::hash() const {
+  using namespace facebook::velox::util::floating_point;
   uint64_t hash = 0;
   if (isNull()) {
     return folly::Hash{}(static_cast<int32_t>(kind_));
@@ -690,9 +736,9 @@ uint64_t variant::hash() const {
     case TypeKind::BOOLEAN:
       return folly::Hash{}(value<TypeKind::BOOLEAN>());
     case TypeKind::REAL:
-      return folly::Hash{}(value<TypeKind::REAL>());
+      return NaNAwareHash<float>{}(value<TypeKind::REAL>());
     case TypeKind::DOUBLE:
-      return folly::Hash{}(value<TypeKind::DOUBLE>());
+      return NaNAwareHash<double>{}(value<TypeKind::DOUBLE>());
     case TypeKind::VARBINARY:
       return folly::Hash{}(value<TypeKind::VARBINARY>());
     case TypeKind::VARCHAR:
@@ -758,6 +804,10 @@ bool equalsFloatingPointWithEpsilonTyped(const variant& a, const variant& b) {
   if (std::isnan(f1) && std::isnan(f2)) {
     return true;
   }
+  if (std::isinf(f1)) {
+    // fabs(inf - inf) is indeterminate.
+    return f1 == f2;
+  }
 
   // Check if the numbers are really close -- needed
   // when comparing numbers near zero.
@@ -806,20 +856,70 @@ bool variant::lessThanWithEpsilon(const variant& other) const {
   return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(lessThan, kind_, *this, other);
 }
 
+namespace {
+
+// Compare variants of Array or Row type.
+template <TypeKind KIND>
+bool compareComplexTypeWithEpsilon(const variant& left, const variant& right) {
+  auto& leftContainer = left.value<KIND>();
+  auto& rightContainer = right.value<KIND>();
+  if (leftContainer.size() != rightContainer.size()) {
+    return false;
+  }
+  for (int32_t i = 0; i < leftContainer.size(); i++) {
+    if (!leftContainer[i].equalsWithEpsilon(rightContainer[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Compare variants of Map type.
+template <>
+bool compareComplexTypeWithEpsilon<TypeKind::MAP>(
+    const variant& left,
+    const variant& right) {
+  auto& leftMap = left.value<TypeKind::MAP>();
+  auto& rightMap = right.value<TypeKind::MAP>();
+  if (leftMap.size() != rightMap.size()) {
+    return false;
+  }
+  for (auto it = leftMap.begin(); it != leftMap.end(); ++it) {
+    auto otherIt = rightMap.find(it->first);
+    if (otherIt == rightMap.end()) {
+      return false;
+    }
+    if (!it->second.equalsWithEpsilon(otherIt->second)) {
+      return false;
+    }
+  }
+  return true;
+}
+} // namespace
+
 // Uses kEpsilon to compare floating point types (REAL and DOUBLE).
 // For testing purposes.
 bool variant::equalsWithEpsilon(const variant& other) const {
   if (other.kind_ != this->kind_) {
     return false;
   }
-  if (other.isNull()) {
-    return this->isNull();
+  if (other.isNull() || this->isNull()) {
+    return other.isNull() && this->isNull();
   }
   if ((kind_ == TypeKind::REAL) or (kind_ == TypeKind::DOUBLE)) {
     return equalsFloatingPointWithEpsilon(*this, other);
   }
 
-  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(equals, kind_, *this, other);
+  switch (kind_) {
+    case TypeKind::ARRAY:
+      return compareComplexTypeWithEpsilon<TypeKind::ARRAY>(*this, other);
+    case TypeKind::MAP:
+      return compareComplexTypeWithEpsilon<TypeKind::MAP>(*this, other);
+    case TypeKind::ROW:
+      return compareComplexTypeWithEpsilon<TypeKind::ROW>(*this, other);
+    default:
+      return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(equals, kind_, *this, other);
+  }
 }
 
 void variant::verifyArrayElements(const std::vector<variant>& inputs) {
diff --git a/velox/type/Variant.h b/velox/type/Variant.h
index 0f1451fffab29..6dbf86378ad39 100644
--- a/velox/type/Variant.h
+++ b/velox/type/Variant.h
@@ -19,11 +19,13 @@
 #include <map>
 
 #include <fmt/format.h>
+#include <folly/Conv.h>
 
 #include "folly/dynamic.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/VeloxException.h"
 #include "velox/type/Conversions.h"
+#include "velox/type/CppToType.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
@@ -129,24 +131,10 @@ class variant {
   variant(TypeKind kind, void* ptr) : kind_{kind}, ptr_{ptr} {}
 
   template <TypeKind KIND>
-  bool lessThan(const variant& a, const variant& b) const {
-    if (a.isNull() && !b.isNull()) {
-      return true;
-    }
-    if (a.isNull() || b.isNull()) {
-      return false;
-    }
-    return a.value<KIND>() < b.value<KIND>();
-  }
+  bool lessThan(const variant& a, const variant& b) const;
 
   template <TypeKind KIND>
-  bool equals(const variant& a, const variant& b) const {
-    if (a.isNull() || b.isNull()) {
-      return false;
-    }
-    // todo(youknowjack): centralize equality semantics
-    return a.value<KIND>() == b.value<KIND>();
-  }
+  bool equals(const variant& a, const variant& b) const;
 
   template <TypeKind KIND>
   void typedDestroy() {
@@ -366,22 +354,9 @@ class variant {
     return *this;
   }
 
-  bool operator<(const variant& other) const {
-    if (other.kind_ != this->kind_) {
-      return other.kind_ < this->kind_;
-    }
-    return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(lessThan, kind_, *this, other);
-  }
+  bool operator<(const variant& other) const;
 
-  bool equals(const variant& other) const {
-    if (other.kind_ != this->kind_) {
-      return false;
-    }
-    if (other.isNull()) {
-      return this->isNull();
-    }
-    return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(equals, kind_, *this, other);
-  }
+  bool equals(const variant& other) const;
 
   bool equalsWithNullEqualsNull(const variant& other) const {
     if (other.kind_ != this->kind_) {
@@ -578,7 +553,12 @@ struct VariantConverter {
     if (value.isNull()) {
       return variant{value.kind()};
     }
-    auto converted = util::Converter<ToKind>::cast(value.value<FromKind>());
+
+    const auto converted =
+        util::Converter<ToKind>::tryCast(value.value<FromKind>())
+            .thenOrThrow(folly::identity, [&](const Status& status) {
+              VELOX_USER_FAIL("{}", status.message());
+            });
     return {converted};
   }
 
diff --git a/velox/type/fbhive/CMakeLists.txt b/velox/type/fbhive/CMakeLists.txt
index 8db23f2f667fe..c6e7aa62319c7 100644
--- a/velox/type/fbhive/CMakeLists.txt
+++ b/velox/type/fbhive/CMakeLists.txt
@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_type_fbhive HiveTypeParser.cpp HiveTypeSerializer.cpp)
+velox_add_library(velox_type_fbhive HiveTypeParser.cpp HiveTypeSerializer.cpp)
 
-target_link_libraries(velox_type_fbhive velox_type)
+velox_link_libraries(velox_type_fbhive velox_type)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/type/fbhive/HiveTypeParser.cpp b/velox/type/fbhive/HiveTypeParser.cpp
index 331aacc854ba7..500c718093f82 100644
--- a/velox/type/fbhive/HiveTypeParser.cpp
+++ b/velox/type/fbhive/HiveTypeParser.cpp
@@ -80,7 +80,7 @@ std::shared_ptr<const Type> HiveTypeParser::parse(const std::string& ser) {
       "Input remaining after parsing the Hive type \"{}\"\n"
       "Remaining: \"{}\"",
       ser,
-      remaining_);
+      remaining_.toString());
   return result.type;
 }
 
@@ -142,7 +142,9 @@ Result HiveTypeParser::parseType() {
     }
   } else {
     VELOX_FAIL(fmt::format(
-        "Unexpected token {} at {}", nt.value, remaining_.toString()));
+        "Unexpected token {} at {}",
+        nt.value.toString(),
+        remaining_.toString()));
   }
 }
 
diff --git a/velox/type/fbhive/HiveTypeParser.h b/velox/type/fbhive/HiveTypeParser.h
index a7a983f58e02e..a35cea77fd3d2 100644
--- a/velox/type/fbhive/HiveTypeParser.h
+++ b/velox/type/fbhive/HiveTypeParser.h
@@ -22,7 +22,8 @@
 #include <string>
 #include <vector>
 
-#include "folly/Range.h"
+#include <folly/Range.h>
+
 #include "velox/type/TypeParser.h"
 
 namespace facebook::velox::type::fbhive {
diff --git a/velox/type/fbhive/tests/CMakeLists.txt b/velox/type/fbhive/tests/CMakeLists.txt
index 50d7cf32471ff..d7c4c456d9ed5 100644
--- a/velox/type/fbhive/tests/CMakeLists.txt
+++ b/velox/type/fbhive/tests/CMakeLists.txt
@@ -19,5 +19,10 @@ add_test(
   COMMAND velox_type_fbhive_test
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 
-target_link_libraries(velox_type_fbhive_test velox_type_fbhive
-                      velox_type gtest gtest_main gmock)
+target_link_libraries(
+  velox_type_fbhive_test
+  velox_type_fbhive
+  velox_type
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock)
diff --git a/velox/type/parser/CMakeLists.txt b/velox/type/parser/CMakeLists.txt
new file mode 100644
index 0000000000000..93d380e58b80c
--- /dev/null
+++ b/velox/type/parser/CMakeLists.txt
@@ -0,0 +1,40 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
+
+bison_target(
+  TypeParser TypeParser.yy ${CMAKE_CURRENT_BINARY_DIR}/TypeParser.yy.cc
+  DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/TypeParser.yy.h
+  COMPILE_FLAGS "-Werror -Wno-deprecated")
+
+flex_target(
+  TypeParserScanner TypeParser.ll ${CMAKE_CURRENT_BINARY_DIR}/Scanner.cpp
+  COMPILE_FLAGS "-Cf --prefix=veloxtp")
+
+add_flex_bison_dependency(TypeParserScanner TypeParser)
+
+if(VELOX_MONO_LIBRARY)
+  add_custom_target(
+    velox_type_parser_gen_src DEPENDS ${BISON_TypeParser_OUTPUTS}
+                                      ${FLEX_TypeParserScanner_OUTPUTS})
+  add_dependencies(velox velox_type_parser_gen_src)
+endif()
+velox_add_library(velox_type_parser ${BISON_TypeParser_OUTPUTS}
+                  ${FLEX_TypeParserScanner_OUTPUTS} ParserUtil.cpp)
+velox_include_directories(velox_type_parser PRIVATE ${PROJECT_BINARY_DIR}
+                                                    ${FLEX_INCLUDE_DIRS})
+velox_link_libraries(velox_type_parser velox_common_base)
diff --git a/velox/type/parser/ParserUtil.cpp b/velox/type/parser/ParserUtil.cpp
new file mode 100644
index 0000000000000..b7fa36ec27b9b
--- /dev/null
+++ b/velox/type/parser/ParserUtil.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+TypePtr typeFromString(
+    const std::string& type,
+    bool failIfNotRegistered = true) {
+  auto upper = type;
+  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
+  if (upper == "INT") {
+    upper = "INTEGER";
+  } else if (upper == "DOUBLE PRECISION") {
+    upper = "DOUBLE";
+  }
+  auto inferredType = getType(upper, {});
+  if (failIfNotRegistered) {
+    VELOX_CHECK(
+        inferredType, "Failed to parse type [{}]. Type not registered.", type);
+  }
+  return inferredType;
+}
+
+std::pair<std::string, std::shared_ptr<const Type>> inferTypeWithSpaces(
+    std::vector<std::string>& words,
+    bool cannotHaveFieldName = false) {
+  VELOX_CHECK_GE(words.size(), 2);
+  const auto& fieldName = words[0];
+  const auto allWords = folly::join(" ", words);
+  // Fail if cannotHaveFieldName = true.
+  auto type = typeFromString(allWords, cannotHaveFieldName);
+  if (type) {
+    return std::make_pair("", type);
+  }
+  return std::make_pair(
+      fieldName, typeFromString(allWords.substr(fieldName.size() + 1)));
+}
+
+} // namespace facebook::velox
diff --git a/velox/type/parser/ParserUtil.h b/velox/type/parser/ParserUtil.h
new file mode 100644
index 0000000000000..7906b8bbf29d6
--- /dev/null
+++ b/velox/type/parser/ParserUtil.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+/// Normalize Presto types such as INT and DOUBLE PRECISION and convert to Velox
+/// type.
+TypePtr typeFromString(
+    const std::string& type,
+    bool failIfNotRegistered = true);
+
+/// Convert words with spaces to a Velox type.
+/// First check if all the words are a Velox type.
+/// Then check if the first word is a field name and the remaining words are a
+/// Velox type. If cannotHaveFieldName = true, then all words must be a Velox
+/// type.
+std::pair<std::string, TypePtr> inferTypeWithSpaces(
+    std::vector<std::string>& words,
+    bool cannotHaveFieldName = false);
+
+} // namespace facebook::velox
diff --git a/velox/type/parser/Scanner.h b/velox/type/parser/Scanner.h
new file mode 100644
index 0000000000000..bc4a820c4c935
--- /dev/null
+++ b/velox/type/parser/Scanner.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cmath>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::type {
+
+class Scanner : public yyFlexLexer {
+ public:
+  Scanner(
+      std::istream& arg_yyin,
+      std::ostream& arg_yyout,
+      TypePtr& outputType,
+      const std::string_view input)
+      : yyFlexLexer(&arg_yyin, &arg_yyout),
+        outputType_(outputType),
+        input_(input){};
+  int lex(Parser::semantic_type* yylval);
+
+  void setType(TypePtr type) {
+    outputType_ = std::move(type);
+  }
+
+  // Store input to print it as part of the error message.
+  std::string_view input() {
+    return input_;
+  }
+
+ private:
+  TypePtr& outputType_;
+  const std::string_view input_;
+};
+
+} // namespace facebook::velox::type
diff --git a/velox/type/parser/TypeParser.h b/velox/type/parser/TypeParser.h
new file mode 100644
index 0000000000000..e7d08b7313d02
--- /dev/null
+++ b/velox/type/parser/TypeParser.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+/// Parses a type string in Presto format to Velox type.
+/// Example type strings:
+///    row(col0 bigint, varchar)
+///    array(bigint)
+///    map(bigint, array(bigint))
+///    function(bigint,bigint,bigint)
+/// The parsing is case-insensitive. i.e. 'Row' and 'row' are equal.
+/// Field names for rows are optional.
+/// Quoted field names are supported.
+/// All custom types need to be registered. An error is thrown otherwise.
+/// Uses the Type::getType API to convert a string to Velox type.
+TypePtr parseType(const std::string& typeText);
+
+} // namespace facebook::velox
diff --git a/velox/type/parser/TypeParser.ll b/velox/type/parser/TypeParser.ll
new file mode 100644
index 0000000000000..3bab4a169f994
--- /dev/null
+++ b/velox/type/parser/TypeParser.ll
@@ -0,0 +1,76 @@
+%{
+#include <vector>
+#include <memory>
+
+#include "velox/type/parser/TypeParser.yy.h"  // @manual
+#include "velox/type/parser/Scanner.h"
+#define YY_DECL int facebook::velox::type::Scanner::lex(facebook::velox::type::Parser::semantic_type *yylval)
+%}
+
+%option c++ noyywrap noyylineno nodefault caseless
+
+A   [A|a]
+B   [B|b]
+C   [C|c]
+D   [D|d]
+E   [E|e]
+F   [F|f]
+G   [G|g]
+H   [H|h]
+I   [I|i]
+J   [J|j]
+K   [K|k]
+L   [L|l]
+M   [M|m]
+O   [O|o]
+P   [P|p]
+R   [R|r]
+S   [S|s]
+T   [T|t]
+U   [U|u]
+W   [W|w]
+X   [X|x]
+Y   [Y|y]
+Z   [Z|z]
+
+WORD              ([[:alpha:][:alnum:]_]*)
+QUOTED_ID         (['"'][[:alnum:][:space:]_]*['"'])
+NUMBER            ([[:digit:]]+)
+VARIABLE          (VARCHAR|VARBINARY)
+
+%%
+
+"("                return Parser::token::LPAREN;
+")"                return Parser::token::RPAREN;
+","                return Parser::token::COMMA;
+(ARRAY)            return Parser::token::ARRAY;
+(MAP)              return Parser::token::MAP;
+(FUNCTION)         return Parser::token::FUNCTION;
+(DECIMAL)          return Parser::token::DECIMAL;
+(ROW)              return Parser::token::ROW;
+{VARIABLE}         yylval->build<std::string>(YYText()); return Parser::token::VARIABLE;
+{NUMBER}           yylval->build<long long>(folly::to<int>(YYText())); return Parser::token::NUMBER;
+{WORD}             yylval->build<std::string>(YYText()); return Parser::token::WORD;
+{QUOTED_ID}        yylval->build<std::string>(YYText()); return Parser::token::QUOTED_ID;
+<<EOF>>            return Parser::token::YYEOF;
+.               /* no action on unmatched input */
+
+%%
+
+int yyFlexLexer::yylex() {
+    throw std::runtime_error("Bad call to yyFlexLexer::yylex()");
+}
+
+#include "velox/type/parser/TypeParser.h"
+
+facebook::velox::TypePtr facebook::velox::parseType(const std::string& typeText)
+ {
+    std::istringstream is(typeText);
+    std::ostringstream os;
+    facebook::velox::TypePtr type;
+    facebook::velox::type::Scanner scanner{is, os, type, typeText};
+    facebook::velox::type::Parser parser{ &scanner };
+    parser.parse();
+    VELOX_CHECK(type, "Failed to parse type [{}]", typeText);
+    return type;
+}
diff --git a/velox/type/parser/TypeParser.yy b/velox/type/parser/TypeParser.yy
new file mode 100644
index 0000000000000..c53502d12eda2
--- /dev/null
+++ b/velox/type/parser/TypeParser.yy
@@ -0,0 +1,153 @@
+%{
+#include <FlexLexer.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/type/Type.h"
+#include "velox/type/parser/ParserUtil.h"
+%}
+%require "3.0.4"
+%language "C++"
+
+%define parser_class_name {Parser}
+%define api.namespace {facebook::velox::type}
+%define api.value.type variant
+%parse-param {Scanner* scanner}
+%define parse.error verbose
+
+%code requires
+{
+    namespace facebook::velox::type {
+        class Scanner;
+    } // namespace facebook::velox::type
+    namespace facebook::velox {
+        class Type;
+    } // namespace facebook::velox
+    struct RowArguments {
+       std::vector<std::string> names;
+       std::vector<std::shared_ptr<const facebook::velox::Type>> types;
+    };
+} // %code requires
+
+%code
+{
+    #include <velox/type/parser/Scanner.h>
+    #define yylex(x) scanner->lex(x)
+}
+
+%token               LPAREN RPAREN COMMA ARRAY MAP ROW FUNCTION DECIMAL
+%token <std::string> WORD VARIABLE QUOTED_ID
+%token <long long>   NUMBER
+%token YYEOF         0
+
+%nterm <std::shared_ptr<const Type>> type type_single_word 
+%nterm <std::shared_ptr<const Type>> special_type function_type decimal_type row_type array_type map_type variable_type
+%nterm <RowArguments> type_list_opt_names
+%nterm <std::vector<std::shared_ptr<const Type>>> type_list
+%nterm <std::pair<std::string, std::shared_ptr<const Type>>> named_type
+%nterm <std::vector<std::string>> type_with_spaces
+%nterm <std::string> field_name
+
+%start type_spec
+
+%%
+
+/* The grammar entry point. */
+type_spec : type                 { scanner->setType($1); }
+          | error                { yyerrok; }
+          ;
+
+type : type_single_word  { $$ = $1; }
+     | type_with_spaces  { $$ = inferTypeWithSpaces($1, true).second; }
+     ;
+
+type_single_word : WORD         { $$ = typeFromString($1); } // Handles most primitive types (e.g. bigint, etc).
+                 | special_type { $$ = $1; }
+
+special_type : array_type     { $$ = $1; }
+             | map_type       { $$ = $1; }
+             | row_type       { $$ = $1; }
+             | function_type  { $$ = $1; }
+             | variable_type  { $$ = $1; }
+             | decimal_type   { $$ = $1; }
+
+/* 
+ * Types with spaces have at least two words. They are joined in an 
+ * std::vector here, and resolved by `inferTypeWithSpaces()`. The first
+ * word is special to allow for tokens such as "map", "array", etc, to 
+ * be used as field names. 
+ */
+type_with_spaces : type_with_spaces WORD  { $1.push_back($2); $$ = std::move($1); }
+                 | field_name WORD        { $$.push_back($1); $$.push_back($2); }
+                 ;
+
+/* List of allowed field names. */
+field_name : WORD     { $$ = $1; }
+           | ARRAY    { $$ = "array"; }
+           | MAP      { $$ = "map"; }
+           | FUNCTION { $$ = "function"; }
+           | DECIMAL  { $$ = "decimal"; }
+           | ROW      { $$ = "row"; }
+           | VARIABLE { $$ = $1; }
+           ;
+
+/* 
+ * Varchar and varbinary have an optional `(int)`
+ * e.g. both `varchar` and `varchar(4)` are valid.
+ */
+variable_type : VARIABLE LPAREN NUMBER RPAREN  { $$ = typeFromString($1); }
+              | VARIABLE                       { $$ = typeFromString($1); }
+              ;
+
+decimal_type : DECIMAL LPAREN NUMBER COMMA NUMBER RPAREN { $$ = DECIMAL($3, $5); }
+             ;
+
+array_type : ARRAY LPAREN type RPAREN { $$ = ARRAY($3); }
+           ;
+
+map_type : MAP LPAREN type COMMA type RPAREN { $$ = MAP($3, $5); }
+         ;
+
+function_type : FUNCTION LPAREN type_list RPAREN { auto returnType = $3.back(); $3.pop_back();
+                                                   $$ = FUNCTION(std::move($3), returnType); }
+
+row_type : ROW LPAREN type_list_opt_names RPAREN  { $$ = ROW(std::move($3.names), std::move($3.types)); }
+         ;
+
+/* Consecutive list of types, separated by a comma. */
+type_list : type                   { $$.push_back($1); }
+          | type_list COMMA type   { $1.push_back($3); $$ = std::move($1); }
+          ;
+
+/* 
+ * Consecutive list of types which can optionally have a "name".
+ * Only allowed inside row definitions.
+ */
+type_list_opt_names : type_list_opt_names COMMA named_type   { $1.names.push_back($3.first); 
+                                                               $1.types.push_back($3.second);
+                                                               $$.names = std::move($1.names); 
+                                                               $$.types = std::move($1.types); }
+                    | named_type                             { $$.names.push_back($1.first); $$.types.push_back($1.second); }
+                    ;
+
+/*
+ * Named type is a type definition with an optional name. The name can be 
+ * quoted. Since types with spaces are allowed, there is potential ambiguity
+ * in definitions with multiple words, for example:
+ *
+ * > my type
+ * 
+ * Is "my" the name and "type" the type, or "my type" is the type name? We first
+ * check if there is a type matching all words ("my type"), and if not, check if 
+ * there is a type matching all but the first wor ("type") and assume the first 
+ * ("my") to be the field name. See `inferTypeWithSpaces()`.
+ */
+named_type : type_single_word        { $$ = std::make_pair("", $1); }
+           | field_name special_type { $$ = std::make_pair($1, $2); }
+           | type_with_spaces        { $$ = inferTypeWithSpaces($1, false); }
+           | QUOTED_ID type          { $1.erase(0, 1); $1.pop_back(); $$ = std::make_pair($1, $2); }  // Remove the quotes.
+           ;
+
+%%
+
+void facebook::velox::type::Parser::error(const std::string& msg) {
+  VELOX_FAIL("Failed to parse type [{}]. {}", scanner->input(), msg);
+}
diff --git a/velox/type/parser/tests/CMakeLists.txt b/velox/type/parser/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..5894a12867b38
--- /dev/null
+++ b/velox/type/parser/tests/CMakeLists.txt
@@ -0,0 +1,25 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_type_parser_test TypeParserTest.cpp)
+
+add_test(NAME velox_type_parser_test COMMAND velox_type_parser_test)
+
+target_link_libraries(
+  velox_type_parser_test
+  velox_type_parser
+  velox_type
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock)
diff --git a/velox/type/parser/tests/TypeParserTest.cpp b/velox/type/parser/tests/TypeParserTest.cpp
new file mode 100644
index 0000000000000..87af58afe19a2
--- /dev/null
+++ b/velox/type/parser/tests/TypeParserTest.cpp
@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/parser/TypeParser.h"
+
+namespace facebook::velox {
+namespace {
+
+class CustomType : public VarcharType {
+ public:
+  CustomType() = default;
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+};
+
+static const TypePtr& JSON() {
+  static const TypePtr instance{new CustomType()};
+  return instance;
+}
+
+static const TypePtr& TIMESTAMP_WITH_TIME_ZONE() {
+  static const TypePtr instance{new CustomType()};
+  return instance;
+}
+
+class TypeFactories : public CustomTypeFactories {
+ public:
+  TypeFactories(const TypePtr& type) : type_(type) {}
+
+  TypePtr getType() const override {
+    return type_;
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+ private:
+  TypePtr type_;
+};
+
+class TypeParserTest : public ::testing::Test {
+ private:
+  void SetUp() override {
+    // Register custom types with and without spaces.
+    registerCustomType("json", std::make_unique<const TypeFactories>(JSON()));
+    registerCustomType(
+        "timestamp with time zone",
+        std::make_unique<const TypeFactories>(TIMESTAMP_WITH_TIME_ZONE()));
+  }
+};
+
+TEST_F(TypeParserTest, booleanType) {
+  ASSERT_EQ(*parseType("boolean"), *BOOLEAN());
+}
+
+TEST_F(TypeParserTest, integerType) {
+  ASSERT_EQ(*parseType("int"), *INTEGER());
+  ASSERT_EQ(*parseType("integer"), *INTEGER());
+}
+
+TEST_F(TypeParserTest, varcharType) {
+  ASSERT_EQ(*parseType("varchar"), *VARCHAR());
+  ASSERT_EQ(*parseType("varchar(4)"), *VARCHAR());
+}
+
+TEST_F(TypeParserTest, varbinary) {
+  ASSERT_EQ(*parseType("varbinary"), *VARBINARY());
+}
+
+TEST_F(TypeParserTest, arrayType) {
+  ASSERT_EQ(*parseType("array(bigint)"), *ARRAY(BIGINT()));
+
+  ASSERT_EQ(*parseType("array(int)"), *ARRAY(INTEGER()));
+  ASSERT_EQ(*parseType("array(integer)"), *ARRAY(INTEGER()));
+
+  ASSERT_EQ(*parseType("array(array(bigint))"), *ARRAY(ARRAY(BIGINT())));
+
+  ASSERT_EQ(*parseType("array(array(int))"), *ARRAY(ARRAY(INTEGER())));
+
+  ASSERT_EQ(
+      *parseType("array(timestamp with time zone)"),
+      *ARRAY(TIMESTAMP_WITH_TIME_ZONE()));
+
+  ASSERT_EQ(*parseType("array(DECIMAL(10,5))"), *ARRAY(DECIMAL(10, 5)));
+}
+
+TEST_F(TypeParserTest, mapType) {
+  ASSERT_EQ(*parseType("map(bigint,bigint)"), *MAP(BIGINT(), BIGINT()));
+
+  ASSERT_EQ(
+      *parseType("map(timestamp with time zone,bigint)"),
+      *MAP(TIMESTAMP_WITH_TIME_ZONE(), BIGINT()));
+
+  ASSERT_EQ(
+      *parseType("map(timestamp with time zone, timestamp with time zone)"),
+      *MAP(TIMESTAMP_WITH_TIME_ZONE(), TIMESTAMP_WITH_TIME_ZONE()));
+
+  ASSERT_EQ(
+      *parseType("map(json, timestamp with time zone)"),
+      *MAP(JSON(), TIMESTAMP_WITH_TIME_ZONE()));
+
+  ASSERT_EQ(
+      *parseType("map(bigint,array(bigint))"), *MAP(BIGINT(), ARRAY(BIGINT())));
+
+  ASSERT_EQ(
+      *parseType("map(timestamp with time zone, varchar)"),
+      *MAP(TIMESTAMP_WITH_TIME_ZONE(), VARCHAR()));
+
+  ASSERT_EQ(
+      *parseType("map(bigint,map(bigint,map(varchar,bigint)))"),
+      *MAP(BIGINT(), MAP(BIGINT(), MAP(VARCHAR(), BIGINT()))));
+
+  ASSERT_EQ(
+      *parseType("maP(DECIMAL(10,5), DECIMAL(20, 4))"),
+      *MAP(DECIMAL(10, 5), DECIMAL(20, 4)));
+
+  // Complex types as map keys.
+  ASSERT_EQ(
+      *parseType("map(row(bigint),bigint)"), *MAP(ROW({BIGINT()}), BIGINT()));
+
+  ASSERT_EQ(
+      *parseType("map(array(double),bigint)"), *MAP(ARRAY(DOUBLE()), BIGINT()));
+
+  ASSERT_EQ(
+      *parseType("map(map(tinyint, varchar),bigint)"),
+      *MAP(MAP(TINYINT(), VARCHAR()), BIGINT()));
+}
+
+TEST_F(TypeParserTest, invalidType) {
+  VELOX_ASSERT_THROW(
+      parseType("blah()"),
+      "Failed to parse type [blah()]. "
+      "syntax error, unexpected LPAREN, expecting WORD");
+
+  VELOX_ASSERT_THROW(parseType("array()"), "Failed to parse type [array()]");
+
+  VELOX_ASSERT_THROW(parseType("map()"), "Failed to parse type [map()]");
+
+  VELOX_ASSERT_THROW(parseType("x"), "Failed to parse type [x]");
+
+  // Ensure this is not treated as a row type.
+  VELOX_ASSERT_THROW(
+      parseType("rowxxx(a)"),
+      "Failed to parse type [rowxxx(a)]. "
+      "syntax error, unexpected LPAREN, expecting WORD");
+}
+
+TEST_F(TypeParserTest, rowType) {
+  // Unnamed fields.
+  ASSERT_EQ(
+      *parseType("row(bigint,varchar, real, timestamp with time zone)"),
+      *ROW({BIGINT(), VARCHAR(), REAL(), TIMESTAMP_WITH_TIME_ZONE()}));
+
+  ASSERT_EQ(
+      *parseType("row(a bigint,b varchar,c real)"),
+      *ROW({"a", "b", "c"}, {BIGINT(), VARCHAR(), REAL()}));
+
+  ASSERT_EQ(
+      *parseType("row(a timestamp with time zone,b json,c real)"),
+      *ROW({"a", "b", "c"}, {TIMESTAMP_WITH_TIME_ZONE(), JSON(), REAL()}));
+
+  ASSERT_EQ(
+      *parseType("row(a bigint,b array(bigint),c row(a decimal(10,5)))"),
+      *ROW(
+          {"a", "b", "c"},
+          {BIGINT(), ARRAY(BIGINT()), ROW({"a"}, {DECIMAL(10, 5)})}));
+
+  // Quoted field name starting with number and scalar type.
+  ASSERT_EQ(
+      *parseType("row(\"12 tb\" bigint,b bigint,c bigint)"),
+      *ROW({"12 tb", "b", "c"}, {BIGINT(), BIGINT(), BIGINT()}));
+
+  ASSERT_EQ(
+      *parseType("row(\"a\" bigint, \"b\" array(varchar), "
+                 "\"c\" timestamp with time zone)"),
+      *ROW(
+          {"a", "b", "c"},
+          {BIGINT(), ARRAY(VARCHAR()), TIMESTAMP_WITH_TIME_ZONE()}));
+
+  ASSERT_EQ(
+      *parseType("row(a varchar(10),b row(a bigint))"),
+      *ROW({"a", "b"}, {VARCHAR(), ROW({"a"}, {BIGINT()})}));
+
+  ASSERT_EQ(
+      *parseType("array(row(col0 bigint,col1 double))"),
+      *ARRAY(ROW({"col0", "col1"}, {BIGINT(), DOUBLE()})));
+
+  ASSERT_EQ(
+      *parseType("row(col0 array(row(col0 bigint,col1 double)))"),
+      *ROW({"col0"}, {ARRAY(ROW({"col0", "col1"}, {BIGINT(), DOUBLE()}))}));
+
+  ASSERT_EQ(*parseType("row(bigint,varchar)"), *ROW({BIGINT(), VARCHAR()}));
+
+  ASSERT_EQ(
+      *parseType("row(bigint,array(bigint),row(a bigint))"),
+      *ROW({BIGINT(), ARRAY(BIGINT()), ROW({"a"}, {BIGINT()})}));
+
+  ASSERT_EQ(
+      *parseType("row(varchar(10),b row(bigint))"),
+      *ROW({"", "b"}, {VARCHAR(), ROW({BIGINT()})}));
+
+  ASSERT_EQ(
+      *parseType("array(row(col0 bigint,double))"),
+      *ARRAY(ROW({"col0", ""}, {BIGINT(), DOUBLE()})));
+
+  ASSERT_EQ(
+      *parseType("row(col0 array(row(bigint,double)))"),
+      *ROW({"col0"}, {ARRAY(ROW({BIGINT(), DOUBLE()}))}));
+
+  ASSERT_EQ(
+      *parseType("row(double double precision)"), *ROW({"double"}, {DOUBLE()}));
+
+  ASSERT_EQ(*parseType("row(double precision)"), *ROW({DOUBLE()}));
+
+  ASSERT_EQ(
+      *parseType("RoW(a bigint,b varchar)"),
+      *ROW({"a", "b"}, {BIGINT(), VARCHAR()}));
+
+  ASSERT_EQ(*parseType("row(array(Json))"), *ROW({ARRAY(JSON())}));
+
+  VELOX_ASSERT_THROW(
+      *parseType("row(col0 row(array(HyperLogLog)))"),
+      "Failed to parse type [HyperLogLog]. Type not registered.");
+
+  // Field type canonicalization.
+  ASSERT_EQ(*parseType("row(col iNt)"), *ROW({"col"}, {INTEGER()}));
+
+  // Can only have names within rows.
+  VELOX_ASSERT_THROW(
+      parseType("asd bigint"),
+      "Failed to parse type [asd bigint]. Type not registered.");
+}
+
+TEST_F(TypeParserTest, typesWithSpaces) {
+  // Type is not registered.
+  VELOX_ASSERT_THROW(
+      parseType("row(time time with time zone)"),
+      "Failed to parse type [time with time zone]. Type not registered.");
+
+  ASSERT_EQ(
+      *parseType("timestamp with time zone"), *TIMESTAMP_WITH_TIME_ZONE());
+
+  // Type is registered.
+  ASSERT_EQ(
+      *parseType("row(col0 timestamp with time zone)"),
+      *ROW({"col0"}, {TIMESTAMP_WITH_TIME_ZONE()}));
+
+  ASSERT_EQ(
+      *parseType("row(double double precision)"), *ROW({"double"}, {DOUBLE()}));
+
+  VELOX_ASSERT_THROW(
+      parseType("row(time with time zone)"),
+      "Failed to parse type [with time zone]");
+
+  ASSERT_EQ(*parseType("row(double precision)"), *ROW({DOUBLE()}));
+
+  ASSERT_EQ(
+      *parseType("row(INTERval DAY TO SECOND)"), *ROW({INTERVAL_DAY_TIME()}));
+
+  ASSERT_EQ(
+      *parseType("row(INTERVAL YEAR TO month)"), *ROW({INTERVAL_YEAR_MONTH()}));
+
+  // quoted field name with valid type with spaces.
+  ASSERT_EQ(
+      *parseType(
+          "row(\"timestamp with time zone\" timestamp with time zone,\"double\" double)"),
+      *ROW(
+          {"timestamp with time zone", "double"},
+          {TIMESTAMP_WITH_TIME_ZONE(), DOUBLE()}));
+
+  // quoted field name with invalid type with spaces.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "row(\"timestamp with time zone\" timestamp timestamp with time zone)"),
+      "Failed to parse type [timestamp timestamp with time zone]. Type not registered.");
+}
+
+TEST_F(TypeParserTest, intervalYearToMonthType) {
+  ASSERT_EQ(
+      *parseType("row(interval interval year to month)"),
+      *ROW({"interval"}, {INTERVAL_YEAR_MONTH()}));
+
+  ASSERT_EQ(
+      *parseType("row(interval year to month)"), *ROW({INTERVAL_YEAR_MONTH()}));
+}
+
+TEST_F(TypeParserTest, functionType) {
+  ASSERT_EQ(
+      *parseType("function(bigint,bigint,bigint)"),
+      *FUNCTION({BIGINT(), BIGINT()}, BIGINT()));
+  ASSERT_EQ(
+      *parseType("function(bigint,array(varchar),varchar)"),
+      *FUNCTION({BIGINT(), ARRAY(VARCHAR())}, VARCHAR()));
+}
+
+TEST_F(TypeParserTest, decimalType) {
+  ASSERT_EQ(*parseType("decimal(10, 5)"), *DECIMAL(10, 5));
+  ASSERT_EQ(*parseType("decimal(20,10)"), *DECIMAL(20, 10));
+
+  VELOX_ASSERT_THROW(parseType("decimal"), "Failed to parse type [decimal]");
+  VELOX_ASSERT_THROW(
+      parseType("decimal()"), "Failed to parse type [decimal()]");
+  VELOX_ASSERT_THROW(
+      parseType("decimal(20)"), "Failed to parse type [decimal(20)]");
+  VELOX_ASSERT_THROW(
+      parseType("decimal(, 20)"), "Failed to parse type [decimal(, 20)]");
+}
+
+// Checks that type names can also be field names.
+TEST_F(TypeParserTest, fieldNames) {
+  ASSERT_EQ(
+      *parseType("row(bigint bigint, map bigint, row bigint, array bigint, "
+                 "decimal bigint, function bigint, struct bigint, "
+                 "varchar map(bigint, tinyint), varbinary array(bigint))"),
+      *ROW(
+          {"bigint",
+           "map",
+           "row",
+           "array",
+           "decimal",
+           "function",
+           "struct",
+           "varchar",
+           "varbinary"},
+          {BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           MAP(BIGINT(), TINYINT()),
+           ARRAY(BIGINT())}));
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/CMakeLists.txt b/velox/type/tests/CMakeLists.txt
index e841b8820f7b8..a077a265a5fae 100644
--- a/velox/type/tests/CMakeLists.txt
+++ b/velox/type/tests/CMakeLists.txt
@@ -11,30 +11,34 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+add_subdirectory(utils)
+
 add_executable(
   velox_type_test
-  StringViewTest.cpp
-  TypeTest.cpp
+  ConversionsTest.cpp
   DecimalTest.cpp
   FilterTest.cpp
   FilterSerDeTest.cpp
+  FloatingPointUtilTest.cpp
   HugeIntTest.cpp
+  StringViewTest.cpp
   SubfieldTest.cpp
   TimestampConversionTest.cpp
-  VariantTest.cpp
-  TimestampTest.cpp)
+  TimestampTest.cpp
+  TypeTest.cpp
+  VariantTest.cpp)
 
 add_test(velox_type_test velox_type_test)
 
 target_link_libraries(
   velox_type_test
   velox_type
-  velox_serialization
-  velox_external_date
+  velox_type_test_lib
+  velox_common_base
   Folly::folly
-  gtest
-  gtest_main
-  gmock
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
   gflags::gflags
   glog::glog)
 
@@ -46,8 +50,8 @@ target_link_libraries(
   velox_serialization
   Folly::folly
   ${FOLLY_BENCHMARK}
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
 
@@ -60,8 +64,8 @@ target_link_libraries(
   velox_serialization
   Folly::folly
   ${FOLLY_BENCHMARK}
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
 
@@ -74,8 +78,8 @@ target_link_libraries(
   velox_serialization
   Folly::folly
   ${FOLLY_BENCHMARK}
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
 
@@ -88,8 +92,8 @@ target_link_libraries(
   velox_serialization
   Folly::folly
   ${FOLLY_BENCHMARK}
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
 
@@ -102,8 +106,8 @@ target_link_libraries(
   velox_serialization
   Folly::folly
   ${FOLLY_BENCHMARK}
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
 
@@ -114,7 +118,7 @@ target_link_libraries(
   velox_type
   Folly::folly
   ${FOLLY_BENCHMARK}
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   gflags::gflags
   glog::glog)
diff --git a/velox/type/tests/ConversionsTest.cpp b/velox/type/tests/ConversionsTest.cpp
new file mode 100644
index 0000000000000..f099a6e309543
--- /dev/null
+++ b/velox/type/tests/ConversionsTest.cpp
@@ -0,0 +1,1061 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/type/Conversions.h"
+#include "gtest/gtest.h"
+#include "velox/common/base/VeloxException.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/CppToType.h"
+
+using namespace facebook::velox;
+
+namespace facebook::velox::util {
+namespace {
+
+constexpr float kInf = std::numeric_limits<float>::infinity();
+constexpr float kNan = std::numeric_limits<float>::quiet_NaN();
+
+class ConversionsTest : public testing::Test {
+ protected:
+  template <typename TFrom, typename TTo>
+  static void testConversion(
+      std::vector<TFrom> input,
+      std::vector<TTo> expectedResult,
+      bool truncate = false,
+      bool legacyCast = false,
+      bool expectError = false) {
+    if (!expectError) {
+      VELOX_CHECK_EQ(input.size(), expectedResult.size());
+    }
+    const TypeKind toTypeKind = CppToType<TTo>::typeKind;
+
+    auto cast = [&](TFrom input) -> TTo {
+      Expected<TTo> result;
+      if (truncate & legacyCast) {
+        VELOX_NYI("No associated cast policy for truncate and legacy cast.");
+      } else if (!truncate & legacyCast) {
+        result = Converter<toTypeKind, void, LegacyCastPolicy>::tryCast(input);
+      } else if (truncate & !legacyCast) {
+        result = Converter<toTypeKind, void, SparkCastPolicy>::tryCast(input);
+      } else {
+        result = Converter<toTypeKind, void, PrestoCastPolicy>::tryCast(input);
+      }
+
+      return result.thenOrThrow(folly::identity, [](const Status& status) {
+        VELOX_USER_FAIL(status.message());
+      });
+    };
+
+    for (auto i = 0; i < input.size(); i++) {
+      if (expectError) {
+        ASSERT_ANY_THROW(cast(input[i])) << "Converting input at " << i;
+      } else {
+        TTo actual = cast(input[i]);
+        TTo expected = expectedResult[i];
+        if constexpr (std::is_floating_point_v<TTo>) {
+          if (std::isnan(actual)) {
+            ASSERT_TRUE(std::isnan(expected))
+                << ", when actual is NaN, and converting input at " << i;
+          } else if (std::isnan(expected)) {
+            ASSERT_TRUE(std::isnan(actual))
+                << ", when expected is NaN, and converting input at " << i;
+          } else {
+            ASSERT_EQ(actual, expected) << "Converting input at " << i;
+          }
+        } else {
+          ASSERT_EQ(actual, expected) << "Converting input at " << i;
+        }
+      }
+    }
+  }
+};
+
+TEST_F(ConversionsTest, toBoolean) {
+  // From integral types.
+  {
+    // When TRUNCATE = false.
+    testConversion<int8_t, bool>(
+        {
+            1,
+            0,
+            12,
+            -1,
+        },
+        {
+            true,
+            false,
+            true,
+            true,
+        },
+        /*truncate*/ false);
+
+    // When TRUNCATE = true.
+    testConversion<int8_t, bool>(
+        {
+            1,
+            0,
+            12,
+            -1,
+        },
+        {
+            true,
+            false,
+            true,
+            true,
+        },
+        /*truncate*/ true);
+  }
+
+  // From double.
+  {
+    // When TRUNCATE = false.
+    testConversion<double, bool>(
+        {
+            1.0,
+            1.1,
+            -1.0,
+            0.0000000000001,
+        },
+        {
+            true,
+            true,
+            true,
+            true,
+        },
+        /*truncate*/ false);
+
+    // When TRUNCATE = true.
+    testConversion<double, bool>(
+        {
+            1.0,
+            1.1,
+            -1.0,
+            0.0000000000001,
+        },
+        {
+            true,
+            true,
+            true,
+            true,
+        },
+        /*truncate*/ true);
+  }
+
+  // From float.
+  {
+    // When TRUNCATE = false.
+    testConversion<float, bool>(
+        {
+            0.1,
+            0.0,
+            -0.1,
+            kInf,
+            kNan,
+        },
+        {
+            true,
+            false,
+            true,
+            true,
+            true,
+        },
+        /*truncate*/ false);
+
+    // When TRUNCATE = true.
+    testConversion<float, bool>(
+        {
+            0.1,
+            0.0,
+            -0.1,
+            kInf,
+            kNan,
+        },
+        {
+            true,
+            false,
+            true,
+            true,
+            false,
+        },
+        /*truncate*/ true);
+  }
+
+  // From boolean.
+  {
+    testConversion<bool, bool>(
+        {
+            true,
+            false,
+        },
+        {
+            true,
+            false,
+        });
+  }
+
+  // From string.
+  {
+    // When TRUNCATE = false.
+    testConversion<std::string, bool>(
+        {
+            "1",
+            "0",
+            "t",
+            "true",
+            "f",
+            "false",
+        },
+        {
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+        },
+        /*truncate*/ false);
+
+    // When TRUNCATE = false, invalid cases.
+    testConversion<std::string, bool>(
+        {
+            "1.7E308",
+            "nan",
+            "infinity",
+            "12",
+            "-1",
+            "tr",
+            "tru",
+        },
+        {},
+        /*truncate*/ false,
+        false,
+        /*expectError*/ true);
+
+    // When TRUNCATE = true.
+    testConversion<std::string, bool>(
+        {
+            "1",
+            "0",
+            "t",
+            "true",
+            "f",
+            "false",
+        },
+        {
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+        },
+        /*truncate*/ true);
+
+    // When TRUNCATE = true, invalid cases.
+    testConversion<std::string, bool>(
+        {
+            "1.7E308",
+            "nan",
+            "infinity",
+            "12",
+            "-1",
+            "tr",
+            "tru",
+        },
+        {},
+        /*truncate*/ true,
+        false,
+        /*expectError*/ true);
+  }
+
+  // From timestamp.
+  {
+    // When TRUNCATE = false, invalid cases.
+    testConversion<Timestamp, bool>(
+        {Timestamp(946729316, 123)},
+        {},
+        /*truncate*/ false,
+        false,
+        /*expectError*/ true);
+
+    // When TRUNCATE = true, invalid cases.
+    testConversion<Timestamp, bool>(
+        {Timestamp(946729316, 123)},
+        {},
+        /*truncate*/ true,
+        false,
+        /*expectError*/ true);
+  }
+}
+
+TEST_F(ConversionsTest, toIntegeralTypes) {
+  // From double.
+  {
+    // When TRUNCATE = false.
+    testConversion<double, int64_t>(
+        {
+            12345.12,
+            12345.67,
+        },
+        {
+            12345,
+            12346,
+        },
+        /*truncate*/ false);
+    testConversion<double, int32_t>(
+        {
+            1.888,
+            2.5,
+            3.6,
+            100.44,
+            -100.101,
+        },
+        {
+            2,
+            3,
+            4,
+            100,
+            -100,
+        },
+        /*truncate*/ false);
+
+    // When TRUNCATE = false, invalid cases.
+    testConversion<double, int8_t>(
+        {
+            12345.67,
+            -12345.67,
+            127.8,
+        },
+        {},
+        /*truncate*/ false,
+        false,
+        /*expectError*/ true);
+
+    // When TRUNCATE = true.
+    testConversion<double, int64_t>(
+        {
+            12345.12,
+            12345.67,
+        },
+        {
+            12345,
+            12345,
+        },
+        /*truncate*/ true);
+    testConversion<double, int32_t>(
+        {
+            1.888,
+            2.5,
+            3.6,
+            100.44,
+            -100.101,
+        },
+        {
+            1,
+            2,
+            3,
+            100,
+            -100,
+        },
+        /*truncate*/ true);
+    testConversion<double, int8_t>(
+        {
+            12345.67,
+            -12345.67,
+            127.8,
+        },
+        {
+            57,
+            -57,
+            127,
+        },
+        /*truncate*/ true);
+    testConversion<double, int8_t>(
+        {
+            1,
+            256,
+            257,
+            2147483646,
+            2147483647,
+            2147483648,
+            -2147483646,
+            -2147483647,
+            -2147483648,
+            -2147483649,
+        },
+        {
+            1,
+            0,
+            1,
+            -2,
+            -1,
+            -1,
+            2,
+            1,
+            0,
+            0,
+        },
+        /*truncate*/ true);
+  }
+
+  // From float.
+  {
+    // When TRUNCATE = false, invalid cases.
+    testConversion<float, int64_t>(
+        {kInf, kNan}, {}, /*truncate*/ false, false, /*expectError*/ true);
+    testConversion<float, int32_t>(
+        {kNan}, {}, /*truncate*/ false, false, /*expectError*/ true);
+    testConversion<float, int16_t>(
+        {kNan}, {}, /*truncate*/ false, false, /*expectError*/ true);
+    testConversion<float, int8_t>(
+        {kNan}, {}, /*truncate*/ false, false, /*expectError*/ true);
+
+    // When TRUNCATE = true.
+    testConversion<float, int64_t>(
+        {kInf, kNan}, {9223372036854775807, 0}, /*truncate*/ true);
+    testConversion<float, int32_t>({kNan}, {0}, /*truncate*/ true);
+    testConversion<float, int16_t>({kNan}, {0}, /*truncate*/ true);
+    testConversion<float, int8_t>({kNan}, {0}, /*truncate*/ true);
+  }
+
+  // From string.
+  {
+    // When TRUNCATE = false.
+    testConversion<std::string, int16_t>(
+        {
+            "1",
+            "+1",
+            "-100",
+            "\u000f100",
+            "\u000f100\u000f",
+            // unicode space's interspaced with control chars
+            " -100\u000f",
+            " \u000f+100",
+            "\u001f101\u000e",
+            " \u001f-102\u000f ",
+        },
+        {1, 1, -100, 100, 100, -100, 100, 101, -102},
+        /*truncate*/ false);
+
+    // When TRUNCATE = false, invalid cases.
+    testConversion<std::string, int8_t>(
+        {
+            "1.2",
+            "1.23444",
+            ".2355",
+            "-1.8",
+            "1.",
+            "-1.",
+            "0.",
+            ".",
+            "-.",
+        },
+        {},
+        /*truncate*/ false,
+        false,
+        /*expectError*/ true);
+    testConversion<std::string, int8_t>(
+        {"1234567"}, {}, /*truncate*/ false, false, /*expectError*/ true);
+    testConversion<std::string, int64_t>(
+        {"1a",
+         "",
+         "1'234'567",
+         "1,234,567",
+         "infinity",
+         "nan",
+         // Unicode spaces and control chars and unicode at the end
+         // Should fail conversion since we do not support unicode digits
+         " \u001f-103٢\u000f ",
+         // All spaces
+         "   \u000f "},
+        {},
+        /*truncate*/ false,
+        false,
+        /*expectError*/ true);
+
+    // When TRUNCATE = true.
+    testConversion<std::string, int8_t>(
+        {
+            "1.2",
+            "1.23444",
+            ".2355",
+            "-1.8",
+            "1.",
+            "-1.",
+            "0.",
+            ".",
+            "-.",
+            "+1",
+        },
+        {
+            1,
+            1,
+            0,
+            -1,
+            1,
+            -1,
+            0,
+            0,
+            0,
+            1,
+        },
+        /*truncate*/ true);
+    testConversion<std::string, int64_t>(
+        {
+            "1a",
+            "",
+            "1'234'567",
+            "1,234,567",
+            "infinity",
+            "nan",
+        },
+        {},
+        /*truncate*/ true,
+        false,
+        /*expectError*/ true);
+  }
+
+  // From integral types.
+  {
+    // When TRUNCATE = false.
+    testConversion<int32_t, int8_t>(
+        {
+            2,
+            3,
+        },
+        {
+            2,
+            3,
+        },
+        /*truncate*/ false);
+
+    // When TRUNCATE = false, invalid cases.
+    testConversion<int32_t, int8_t>(
+        {
+            1234567,
+            -1234567,
+            1111111,
+            1000,
+            -100101,
+        },
+        {},
+        /*truncate*/ false,
+        false,
+        /*expectError*/ true);
+
+    // When TRUNCATE = true.
+    testConversion<int32_t, int8_t>(
+        {
+            1234567,
+            -1234567,
+            1111111,
+            2,
+            3,
+            1000,
+            -100101,
+        },
+        {
+            -121,
+            121,
+            71,
+            2,
+            3,
+            -24,
+            -5,
+        },
+        /*truncate*/ true);
+  }
+
+  // From boolean
+  {
+    testConversion<bool, int8_t>(
+        {
+            true,
+            false,
+        },
+        {
+            1,
+            0,
+        });
+  }
+}
+
+TEST_F(ConversionsTest, toString) {
+  // From integral types.
+  {
+    testConversion<int32_t, std::string>(
+        {
+            1,
+            2,
+            3,
+            100,
+            -100,
+        },
+        {
+            "1",
+            "2",
+            "3",
+            "100",
+            "-100",
+        });
+  }
+
+  // From double.
+  {
+    // When LEGACY_CAST = false.
+    testConversion<double, std::string>(
+        {
+            12345678901234567000.0,
+            123456789.01234567,
+            10'000'000.0,
+            12345.0,
+            0.001,
+            0.00012,
+            0.0,
+            -0.0,
+            -0.00012,
+            -0.001,
+            -12345.0,
+            -10'000'000.0,
+            -123456789.01234567,
+            -12345678901234567000.0,
+            std::numeric_limits<double>::infinity(),
+            -std::numeric_limits<double>::infinity(),
+            std::numeric_limits<double>::quiet_NaN(),
+            -std::numeric_limits<double>::quiet_NaN(),
+        },
+        {
+            "1.2345678901234567E19",
+            "1.2345678901234567E8",
+            "1.0E7",
+            "12345.0",
+            "0.001",
+            "1.2E-4",
+            "0.0",
+            "-0.0",
+            "-1.2E-4",
+            "-0.001",
+            "-12345.0",
+            "-1.0E7",
+            "-1.2345678901234567E8",
+            "-1.2345678901234567E19",
+            "Infinity",
+            "-Infinity",
+            "NaN",
+            "NaN",
+        },
+        false,
+        /*legacyCast*/ false);
+
+    // When LEGACY_CAST = true.
+    testConversion<double, std::string>(
+        {
+            12345678901234567000.0,
+            123456789.01234567,
+            10'000'000.0,
+            12345.0,
+            0.001,
+            0.00012,
+            0.0,
+            -0.0,
+            -0.00012,
+            -0.001,
+            -12345.0,
+            -10'000'000.0,
+            -123456789.01234567,
+            -12345678901234567000.0,
+            std::numeric_limits<double>::infinity(),
+            -std::numeric_limits<double>::infinity(),
+            std::numeric_limits<double>::quiet_NaN(),
+            -std::numeric_limits<double>::quiet_NaN(),
+        },
+        {
+            "12345678901234567000.0",
+            "123456789.01234567",
+            "10000000.0",
+            "12345.0",
+            "0.001",
+            "0.00012",
+            "0.0",
+            "-0.0",
+            "-0.00012",
+            "-0.001",
+            "-12345.0",
+            "-10000000.0",
+            "-123456789.01234567",
+            "-12345678901234567000.0",
+            "Infinity",
+            "-Infinity",
+            "NaN",
+            "NaN",
+        },
+        false,
+        /*legacyCast*/ true);
+  }
+
+  // From float.
+  {
+    // When LEGACY_CAST = false.
+    testConversion<float, std::string>(
+        {
+            12345678000000000000.0,
+            123456780.0,
+            10'000'000.0,
+            12345.0,
+            0.001,
+            0.00012,
+            0.0,
+            -0.0,
+            -0.00012,
+            -0.001,
+            -12345.0,
+            -10'000'000.0,
+            -123456780.0,
+            -12345678000000000000.0,
+            std::numeric_limits<float>::infinity(),
+            -std::numeric_limits<float>::infinity(),
+            std::numeric_limits<float>::quiet_NaN(),
+            -std::numeric_limits<float>::quiet_NaN(),
+        },
+        {
+            "1.2345678E19",
+            "1.2345678E8",
+            "1.0E7",
+            "12345.0",
+            "0.001",
+            "1.2E-4",
+            "0.0",
+            "-0.0",
+            "-1.2E-4",
+            "-0.001",
+            "-12345.0",
+            "-1.0E7",
+            "-1.2345678E8",
+            "-1.2345678E19",
+            "Infinity",
+            "-Infinity",
+            "NaN",
+            "NaN",
+        },
+        false,
+        /*legacyCast*/ false);
+
+    // When LEGACY_CAST = true.
+    testConversion<float, std::string>(
+        {
+            12345678000000000000.0,
+            123456780.0,
+            10'000'000.0,
+            12345.0,
+            0.001,
+            0.00012,
+            0.0,
+            -0.0,
+            -0.00012,
+            -0.001,
+            -12345.0,
+            -10'000'000.0,
+            -123456780.0,
+            -12345678000000000000.0,
+            std::numeric_limits<float>::infinity(),
+            -std::numeric_limits<float>::infinity(),
+            std::numeric_limits<float>::quiet_NaN(),
+            -std::numeric_limits<float>::quiet_NaN(),
+        },
+        {
+            "12345678295994466000.0",
+            "123456784.0",
+            "10000000.0",
+            "12345.0",
+            "0.0010000000474974513",
+            "0.00011999999696854502",
+            "0.0",
+            "-0.0",
+            "-0.00011999999696854502",
+            "-0.0010000000474974513",
+            "-12345.0",
+            "-10000000.0",
+            "-123456784.0",
+            "-12345678295994466000.0",
+            "Infinity",
+            "-Infinity",
+            "NaN",
+            "NaN",
+        },
+        false,
+        /*legacyCast*/ true);
+  }
+
+  // From Timestamp.
+  {
+    // When LEGACY_CAST = false.
+    testConversion<Timestamp, std::string>(
+        {
+            Timestamp(-946684800, 0),
+            Timestamp(-7266, 0),
+            Timestamp(0, 0),
+            Timestamp(946684800, 0),
+            Timestamp(9466848000, 0),
+            Timestamp(94668480000, 0),
+            Timestamp(946729316, 0),
+            Timestamp(946729316, 123),
+            Timestamp(946729316, 129900000),
+            Timestamp(7266, 0),
+            Timestamp(-50049331200, 0),
+            Timestamp(253405036800, 0),
+            Timestamp(-62480037600, 0),
+        },
+        {
+            "1940-01-02 00:00:00.000",
+            "1969-12-31 21:58:54.000",
+            "1970-01-01 00:00:00.000",
+            "2000-01-01 00:00:00.000",
+            "2269-12-29 00:00:00.000",
+            "4969-12-04 00:00:00.000",
+            "2000-01-01 12:21:56.000",
+            "2000-01-01 12:21:56.000",
+            "2000-01-01 12:21:56.129",
+            "1970-01-01 02:01:06.000",
+            "0384-01-01 08:00:00.000",
+            "10000-02-01 16:00:00.000",
+            "-0010-02-01 10:00:00.000",
+        },
+        false,
+        /*legacyCast*/ false);
+
+    // When LEGACY_CAST = true.
+    testConversion<Timestamp, std::string>(
+        {
+            Timestamp(946729316, 123),
+            Timestamp(-50049331200, 0),
+            Timestamp(253405036800, 0),
+            Timestamp(-62480037600, 0),
+        },
+        {
+            "2000-01-01T12:21:56.000",
+            "384-01-01T08:00:00.000",
+            "10000-02-01T16:00:00.000",
+            "-10-02-01T10:00:00.000",
+        },
+        false,
+        /*legacyCast*/ true);
+  }
+}
+
+TEST_F(ConversionsTest, toRealAndDouble) {
+  // From integral types.
+  {
+    testConversion<int8_t, float>({1}, {1.0}, /*truncate*/ false);
+    testConversion<int32_t, double>(
+        {
+            1,
+            2,
+            3,
+            100,
+            -100,
+        },
+        {
+            1.0,
+            2.0,
+            3.0,
+            100.0,
+            -100.0,
+        });
+  }
+
+  // From double.
+  {
+    // When TRUNCATE = false.
+    testConversion<double, float>(
+        {
+            1.888,
+            2.5,
+            3.6,
+            100.44,
+            -100.101,
+            1.0,
+            -2.0,
+        },
+        {
+            1.888,
+            2.5,
+            3.6,
+            100.44,
+            -100.101,
+            1.0,
+            -2.0,
+        },
+        /*truncate*/ false);
+    testConversion<double, double>(
+        {
+            1.888,
+            2.5,
+            3.6,
+            100.44,
+            -100.101,
+            1.0,
+            -2.0,
+        },
+        {
+            1.888,
+            2.5,
+            3.6,
+            100.44,
+            -100.101,
+            1.0,
+            -2.0,
+        },
+        /*truncate*/ false);
+
+    // When TRUNCATE = false, invalid cases.
+    testConversion<double, float>(
+        {1.7E308}, {}, /*truncate*/ false, false, /*expectError*/ true);
+
+    // When TRUNCATE = true.
+    testConversion<double, float>({1.7E308}, {kInf}, /*truncate*/ true);
+  }
+
+  // From string.
+  {
+    // When TRUNCATE = false.
+    testConversion<std::string, float>(
+        {
+            "1.7E308",   "1.",           "1",
+            ".1324",     "1.2345678E19", "1.2345678E8",
+            "1.0E7",     "12345.0",      "0.001",
+            "1.2E-4",    "0.0",          "-0.0",
+            "-1.2E-4",   "-0.001",       "-12345.0",
+            "-1.0E7",    "-1.2345678E8", "-1.2345678E19",
+            " 123",      "123 ",         " 123 ",
+            "infinity",  "-infinity",    "InfiNiTy",
+            "-InfiNiTy", "Inf",          "-Inf",
+            "nan",       "nAn",
+        },
+        {
+            kInf,
+            1.0,
+            1.0,
+            0.1324,
+            12345678000000000000.0,
+            123456780.0,
+            10'000'000.0,
+            12345.0,
+            0.001,
+            0.00012,
+            0.0,
+            -0.0,
+            -0.00012,
+            -0.001,
+            -12345.0,
+            -10'000'000.0,
+            -123456780.0,
+            -12345678000000000000.0,
+            123.0,
+            123.0,
+            123.0,
+            kInf,
+            -kInf,
+            kInf,
+            -kInf,
+            kInf,
+            -kInf,
+            kNan,
+            kNan,
+        },
+        /*truncate*/ false);
+
+    // When TRUNCATE = false, invalid cases.
+    testConversion<std::string, float>(
+        {
+            "1.2a",
+            "1.2.3",
+            "1.2EE4",
+            "123.4f",
+            "123.4F",
+            "123.4d",
+            "123.4D",
+            "In",
+            "Infx",
+            "-Infx",
+            "nanx",
+            "na",
+            "infinit",
+            "infinityx",
+            "-infinityx",
+        },
+        {},
+        /*truncate*/ false,
+        false,
+        /*expectError*/ true);
+  }
+
+  // From Timestamp.
+  {
+    // Invalid cases.
+    testConversion<Timestamp, float>(
+        {Timestamp(946729316, 123)},
+        {},
+        /*truncate*/ false,
+        false,
+        /*expectError*/ true);
+  }
+}
+
+TEST_F(ConversionsTest, toTimestamp) {
+  // From string.
+  {
+    testConversion<std::string, Timestamp>(
+        {
+            "1970-01-01",
+            "2000-01-01",
+            "1970-01-01 00:00:00",
+            "2000-01-01 12:21:56",
+            "1970-01-01 00:01",
+        },
+        {
+            Timestamp(0, 0),
+            Timestamp(946684800, 0),
+            Timestamp(0, 0),
+            Timestamp(946729316, 0),
+            Timestamp(60, 0),
+        });
+
+    // Invalid case.
+    testConversion<std::string, Timestamp>(
+        {"2012-Oct-01"}, {}, false, false, /*expectError*/ true);
+  }
+
+  // From integral types, invalid cases.
+  {
+    testConversion<int8_t, Timestamp>(
+        {123}, {}, false, false, /*expectError*/ true);
+    testConversion<int16_t, Timestamp>(
+        {12345}, {}, false, false, /*expectError*/ true);
+    testConversion<int32_t, Timestamp>(
+        {123456}, {}, false, false, /*expectError*/ true);
+    testConversion<int64_t, Timestamp>(
+        {123456}, {}, false, false, /*expectError*/ true);
+  }
+
+  // From floating-point types, invalid cases.
+  {
+    testConversion<float, Timestamp>(
+        {123456.78}, {}, false, false, /*expectError*/ true);
+    testConversion<double, Timestamp>(
+        {123456.78}, {}, false, false, /*expectError*/ true);
+  }
+}
+} // namespace
+} // namespace facebook::velox::util
diff --git a/velox/type/tests/DecimalTest.cpp b/velox/type/tests/DecimalTest.cpp
index 10de56c3aece7..7b2bf29139085 100644
--- a/velox/type/tests/DecimalTest.cpp
+++ b/velox/type/tests/DecimalTest.cpp
@@ -20,9 +20,84 @@
 #include "velox/type/DecimalUtil.h"
 
 namespace facebook::velox {
-
 namespace {
 
+template <typename TInput>
+void assertRescaleFloatingPoint(
+    TInput value,
+    const TypePtr& type,
+    int128_t expectedValue) {
+  SCOPED_TRACE(fmt::format("value: {}, type: {}", value, type->toString()));
+  const auto [precision, scale] = getDecimalPrecisionScale(*type);
+  int128_t actualValue;
+  Status status;
+  if (precision > ShortDecimalType::kMaxPrecision) {
+    int128_t result;
+    status = DecimalUtil::rescaleFloatingPoint<TInput, int128_t>(
+        value, precision, scale, result);
+    actualValue = result;
+  } else {
+    int64_t result;
+    status = DecimalUtil::rescaleFloatingPoint<TInput, int64_t>(
+        value, precision, scale, result);
+    actualValue = result;
+  }
+  ASSERT_TRUE(status.ok());
+  ASSERT_EQ(actualValue, expectedValue);
+}
+
+void assertRescaleDouble(
+    double value,
+    const TypePtr& type,
+    int128_t expectedValue) {
+  assertRescaleFloatingPoint<double>(value, type, expectedValue);
+}
+
+void assertRescaleReal(
+    float value,
+    const TypePtr& type,
+    int128_t expectedValue) {
+  assertRescaleFloatingPoint<float>(value, type, expectedValue);
+}
+
+template <typename TInput>
+void assertRescaleFloatingPointFail(
+    TInput value,
+    const TypePtr& type,
+    const std::string& expectedErrorMessage) {
+  SCOPED_TRACE(fmt::format("value: {}, type: {}", value, type->toString()));
+  const auto [precision, scale] = getDecimalPrecisionScale(*type);
+  if (precision > ShortDecimalType::kMaxPrecision) {
+    int128_t result;
+    VELOX_ASSERT_ERROR_STATUS(
+        (DecimalUtil::rescaleFloatingPoint<TInput, int128_t>(
+            value, precision, scale, result)),
+        StatusCode::kUserError,
+        expectedErrorMessage);
+  } else {
+    int64_t result;
+    VELOX_ASSERT_ERROR_STATUS(
+        (DecimalUtil::rescaleFloatingPoint<TInput, int64_t>(
+            value, precision, scale, result)),
+        StatusCode::kUserError,
+        expectedErrorMessage);
+  }
+}
+
+void assertRescaleDoubleFail(
+    double value,
+    const TypePtr& type,
+    const std::string& expectedErrorMessage) {
+  assertRescaleFloatingPointFail<double>(value, type, expectedErrorMessage);
+}
+
+void assertRescaleRealFail(
+    float value,
+    const TypePtr& type,
+    const std::string& expectedErrorMessage) {
+  assertRescaleFloatingPointFail<float>(value, type, expectedErrorMessage);
+}
+
 void testToByteArray(int128_t value, int8_t* expected, int32_t size) {
   char out[size];
   int32_t length = DecimalUtil::toByteArray(value, out);
@@ -31,6 +106,32 @@ void testToByteArray(int128_t value, int8_t* expected, int32_t size) {
   EXPECT_EQ(std::memcmp(expected, out, length), 0);
 }
 
+template <typename T>
+void testcastToString(
+    T unscaleValue,
+    int precision,
+    int scale,
+    int maxStringSize,
+    const std::string& expected) {
+  char out[maxStringSize];
+  auto actualSize =
+      DecimalUtil::castToString<T>(unscaleValue, scale, maxStringSize, out);
+  EXPECT_EQ(expected.size(), actualSize);
+  EXPECT_EQ(std::memcmp(expected.data(), out, expected.size()), 0);
+}
+
+void testMaxStringViewSize(
+    int precision,
+    int scale,
+    int expectedMaxStringSize) {
+  EXPECT_EQ(
+      DecimalUtil::maxStringViewSize(precision, scale), expectedMaxStringSize);
+}
+
+std::string zeros(uint32_t numZeros) {
+  return std::string(numZeros, '0');
+}
+
 TEST(DecimalTest, toString) {
   EXPECT_EQ(std::to_string(HugeInt::build(0, 0)), "0");
   EXPECT_EQ(std::to_string(HugeInt::build(0, 1)), "1");
@@ -60,7 +161,7 @@ TEST(DecimalTest, decimalToString) {
   ASSERT_EQ("1.000", DecimalUtil::toString(1000, DECIMAL(20, 3)));
   ASSERT_EQ("0.0000001000", DecimalUtil::toString(1000, DECIMAL(20, 10)));
   ASSERT_EQ("-0.001000", DecimalUtil::toString(-1000, DECIMAL(20, 6)));
-  ASSERT_EQ("0", DecimalUtil::toString(0, DECIMAL(20, 9)));
+  ASSERT_EQ("0.000000000", DecimalUtil::toString(0, DECIMAL(20, 9)));
 
   const auto minShortDecimal =
       DecimalUtil::toString(DecimalUtil::kShortDecimalMin, DECIMAL(18, 0));
@@ -193,5 +294,268 @@ TEST(DecimalTest, valueInPrecisionRange) {
       DecimalUtil::kLongDecimalMin - 1, LongDecimalType::kMaxPrecision));
 }
 
+TEST(DecimalTest, computeAverage) {
+  auto validateSameValues = [](int128_t value, int64_t maxCount) {
+    SCOPED_TRACE(fmt::format("value={} maxCount={}", value, maxCount));
+    int128_t sum = 0;
+    int64_t overflow = 0;
+    for (int64_t i = 1; i <= maxCount; ++i) {
+      overflow += DecimalUtil::addWithOverflow(sum, sum, value);
+      int128_t avg;
+      DecimalUtil::computeAverage(avg, sum, i, overflow);
+      ASSERT_EQ(avg, value);
+    }
+  };
+  validateSameValues(DecimalUtil::kLongDecimalMin, 1'000'000);
+  validateSameValues(DecimalUtil::kLongDecimalMax, 1'000'000);
+}
+
+TEST(DecimalAggregateTest, adjustSumForOverflow) {
+  struct SumWithOverflow {
+    int128_t sum{0};
+    int64_t overflow{0};
+
+    void add(int128_t input) {
+      overflow += DecimalUtil::addWithOverflow(sum, sum, input);
+    }
+
+    std::optional<int128_t> adjustedSum() const {
+      return DecimalUtil::adjustSumForOverflow(sum, overflow);
+    }
+
+    void reset() {
+      sum = 0;
+      overflow = 0;
+    }
+  };
+
+  SumWithOverflow accumulator;
+  // kLongDecimalMax + kLongDecimalMax will trigger one upward overflow, and the
+  // final sum result calculated by DecimalUtil::addWithOverflow is negative.
+  // DecimalUtil::adjustSumForOverflow can adjust the sum to kLongDecimalMax
+  // correctly.
+  accumulator.add(DecimalUtil::kLongDecimalMax);
+  accumulator.add(DecimalUtil::kLongDecimalMax);
+  accumulator.add(DecimalUtil::kLongDecimalMin);
+  EXPECT_EQ(accumulator.adjustedSum(), DecimalUtil::kLongDecimalMax);
+
+  accumulator.reset();
+  // kLongDecimalMin + kLongDecimalMin will trigger one downward overflow, and
+  // the final sum result calculated by DecimalUtil::addWithOverflow is
+  // positive. DecimalUtil::adjustSumForOverflow can adjust the sum to
+  // kLongDecimalMin correctly.
+  accumulator.add(DecimalUtil::kLongDecimalMin);
+  accumulator.add(DecimalUtil::kLongDecimalMin);
+  accumulator.add(DecimalUtil::kLongDecimalMax);
+  EXPECT_EQ(accumulator.adjustedSum(), DecimalUtil::kLongDecimalMin);
+
+  accumulator.reset();
+  // These inputs will eventually trigger an upward overflow, and
+  // DecimalUtil::adjustSumForOverflow will return std::nullopt.
+  accumulator.add(DecimalUtil::kLongDecimalMax);
+  accumulator.add(DecimalUtil::kLongDecimalMax);
+  EXPECT_FALSE(accumulator.adjustedSum().has_value());
+
+  accumulator.reset();
+  // These inputs will eventually trigger a downward overflow, and
+  // DecimalUtil::adjustSumForOverflow will return std::nullopt.
+  accumulator.add(DecimalUtil::kLongDecimalMin);
+  accumulator.add(DecimalUtil::kLongDecimalMin);
+  EXPECT_FALSE(accumulator.adjustedSum().has_value());
+}
+
+TEST(DecimalTest, rescaleDouble) {
+  assertRescaleDouble(-3333.03, DECIMAL(10, 4), -33'330'300);
+  assertRescaleDouble(-3333.03, DECIMAL(20, 1), -33'330);
+  assertRescaleDouble(
+      -3333.03, DECIMAL(38, 18), HugeInt::parse("-333303" + zeros(16)));
+
+  assertRescaleDouble(-2222.02, DECIMAL(10, 4), -22'220'200);
+  assertRescaleDouble(-2222.02, DECIMAL(20, 1), -22'220);
+  assertRescaleDouble(
+      -2222.02, DECIMAL(38, 18), HugeInt::parse("-222202" + zeros(16)));
+
+  assertRescaleDouble(-1.0, DECIMAL(10, 4), -10'000);
+  assertRescaleDouble(-1.0, DECIMAL(20, 1), -10);
+  assertRescaleDouble(-1.0, DECIMAL(38, 18), -1'000'000'000'000'000'000);
+
+  assertRescaleDouble(0.00, DECIMAL(10, 4), 0);
+  assertRescaleDouble(0.00, DECIMAL(20, 1), 0);
+  assertRescaleDouble(0.00, DECIMAL(38, 18), 0);
+
+  assertRescaleDouble(100, DECIMAL(10, 4), 1'000'000);
+  assertRescaleDouble(100, DECIMAL(20, 1), 1'000);
+  assertRescaleDouble(100, DECIMAL(38, 18), HugeInt::parse("100" + zeros(18)));
+
+  assertRescaleDouble(99999.99, DECIMAL(10, 4), 999'999'900);
+  assertRescaleDouble(99999.99, DECIMAL(20, 1), 1'000'000);
+  assertRescaleDouble(
+      99999.99, DECIMAL(38, 18), HugeInt::parse("9999999" + zeros(16)));
+
+  assertRescaleDouble(0.95, DECIMAL(3, 1), 10);
+  assertRescaleDouble(
+      10.03, DECIMAL(38, 18), HugeInt::parse("1003" + zeros(16)));
+  assertRescaleDouble(0.034567890, DECIMAL(38, 18), 34'567'890'000'000'000);
+  assertRescaleDouble(
+      0.999999999999999, DECIMAL(38, 18), 999'999'999'999'999'000);
+  assertRescaleDouble(
+      0.123456789123123, DECIMAL(38, 18), 123'456'789'123'123'000);
+  assertRescaleDouble(21.54551, DECIMAL(12, 3), 21546);
+
+  assertRescaleDouble(std::numeric_limits<double>::min(), DECIMAL(38, 2), 0);
+
+  // Test for overflows.
+  std::vector<double> invalidInputs = {
+      9999999999999999999999.99,
+      static_cast<double>(
+          static_cast<int128_t>(std::numeric_limits<int64_t>::max()) + 1),
+      static_cast<double>(
+          static_cast<int128_t>(std::numeric_limits<int64_t>::min()) - 1),
+      static_cast<double>(DecimalUtil::kShortDecimalMax),
+      static_cast<double>(DecimalUtil::kShortDecimalMin),
+      static_cast<double>(DecimalUtil::kLongDecimalMax),
+      static_cast<double>(DecimalUtil::kLongDecimalMin),
+      std::numeric_limits<double>::max(),
+      std::numeric_limits<double>::lowest()};
+  std::vector<TypePtr> toTypes = {
+      DECIMAL(10, 2),
+      DECIMAL(18, 0),
+      DECIMAL(18, 0),
+      DECIMAL(10, 2),
+      DECIMAL(10, 2),
+      DECIMAL(20, 2),
+      DECIMAL(20, 2),
+      DECIMAL(38, 0),
+      DECIMAL(38, 0)};
+  for (int32_t i = 0; i < invalidInputs.size(); i++) {
+    assertRescaleDoubleFail(invalidInputs[i], toTypes[i], "Result overflows.");
+  }
+
+  assertRescaleDoubleFail(
+      NAN, DECIMAL(10, 2), "The input value should be finite.");
+  assertRescaleDoubleFail(
+      INFINITY, DECIMAL(10, 2), "The input value should be finite.");
+  assertRescaleDoubleFail(
+      99999.99, DECIMAL(6, 4), "Result cannot fit in the given precision 6.");
+}
+
+TEST(DecimalTest, rescaleReal) {
+  assertRescaleReal(-3333.03, DECIMAL(10, 4), -33'330'300);
+  assertRescaleReal(-3333.03, DECIMAL(20, 1), -33'330);
+  assertRescaleReal(
+      -3333.03, DECIMAL(38, 18), HugeInt::parse("-333303" + zeros(16)));
+
+  assertRescaleReal(-2222.02, DECIMAL(10, 4), -22'220'200);
+  assertRescaleReal(-2222.02, DECIMAL(20, 1), -22'220);
+  assertRescaleReal(
+      -2222.02, DECIMAL(38, 18), HugeInt::parse("-222202" + zeros(16)));
+
+  assertRescaleReal(-1.0, DECIMAL(10, 4), -10'000);
+  assertRescaleReal(-1.0, DECIMAL(20, 1), -10);
+  assertRescaleReal(-1.0, DECIMAL(38, 18), -1'000'000'000'000'000'000);
+
+  assertRescaleReal(0.00, DECIMAL(10, 4), 0);
+  assertRescaleReal(0.00, DECIMAL(20, 1), 0);
+  assertRescaleReal(0.00, DECIMAL(38, 18), 0);
+
+  assertRescaleReal(100, DECIMAL(10, 4), 1'000'000);
+  assertRescaleReal(100, DECIMAL(20, 1), 1'000);
+  assertRescaleReal(100, DECIMAL(38, 18), HugeInt::parse("100" + zeros(18)));
+
+  assertRescaleReal(9999.99, DECIMAL(10, 4), 99'999'900);
+  assertRescaleReal(9999.99, DECIMAL(20, 1), 100'000);
+  assertRescaleReal(
+      9999.99, DECIMAL(38, 18), HugeInt::parse("999999" + zeros(16)));
+
+  assertRescaleReal(0.95, DECIMAL(3, 1), 10);
+  assertRescaleReal(10.03, DECIMAL(38, 18), HugeInt::parse("1003" + zeros(16)));
+  assertRescaleReal(0.034567, DECIMAL(38, 18), 34'567'000'000'000'000);
+  assertRescaleReal(
+      0.999999999999999, DECIMAL(38, 18), 1'000'000'000'000'000'000);
+  assertRescaleReal(0.123456, DECIMAL(38, 18), 123'456'000'000'000'000);
+  assertRescaleReal(21.5455, DECIMAL(12, 3), 21546);
+
+  assertRescaleReal(std::numeric_limits<float>::min(), DECIMAL(38, 2), 0);
+
+  // Test for overflows.
+  std::vector<float> invalidInputs = {
+      std::numeric_limits<float>::max(),
+      std::numeric_limits<float>::lowest(),
+      9999999999999999999999.99,
+      static_cast<float>(
+          static_cast<int128_t>(std::numeric_limits<int64_t>::max()) + 1),
+      static_cast<float>(
+          static_cast<int128_t>(std::numeric_limits<int64_t>::min()) - 1),
+      static_cast<float>(DecimalUtil::kShortDecimalMax),
+      static_cast<float>(DecimalUtil::kShortDecimalMin),
+      static_cast<float>(DecimalUtil::kLongDecimalMax),
+      static_cast<float>(DecimalUtil::kLongDecimalMin),
+  };
+  std::vector<TypePtr> toTypes = {
+      DECIMAL(38, 0),
+      DECIMAL(38, 0),
+      DECIMAL(10, 2),
+      DECIMAL(18, 0),
+      DECIMAL(18, 0),
+      DECIMAL(10, 2),
+      DECIMAL(10, 2),
+      DECIMAL(20, 2),
+      DECIMAL(20, 2)};
+  for (int32_t i = 0; i < invalidInputs.size(); i++) {
+    assertRescaleRealFail(invalidInputs[i], toTypes[i], "Result overflows.");
+  }
+
+  assertRescaleRealFail(
+      99999.99, DECIMAL(6, 4), "Result cannot fit in the given precision 6.");
+  assertRescaleRealFail(
+      NAN, DECIMAL(10, 2), "The input value should be finite.");
+  assertRescaleRealFail(
+      INFINITY, DECIMAL(10, 2), "The input value should be finite.");
+}
+
+TEST(DecimalTest, maxStringViewSize) {
+  testMaxStringViewSize(10, 0, 11);
+  testMaxStringViewSize(10, 1, 12);
+  testMaxStringViewSize(10, 10, 13);
+}
+
+TEST(DecimalTest, castToString) {
+  testcastToString<int64_t>(12, 10, 0, 11, "12");
+  testcastToString<int64_t>(12, 10, 1, 12, "1.2");
+  testcastToString<int64_t>(12, 10, 3, 12, "0.012");
+  testcastToString<int64_t>(-12, 10, 3, 12, "-0.012");
+  testcastToString<int64_t>(12, 5, 5, 8, "0.00012");
+  testcastToString<int64_t>(-12, 5, 5, 8, "-0.00012");
+  testcastToString<int64_t>(-12, 5, 5, 8, "-0.00012");
+  testcastToString<int64_t>(
+      DecimalUtil::kShortDecimalMax, 18, 0, 19, std::string(18, '9'));
+  testcastToString<int64_t>(
+      DecimalUtil::kShortDecimalMin, 18, 0, 19, "-" + std::string(18, '9'));
+
+  testcastToString<int128_t>(
+      HugeInt::parse("-18446744073709551616"),
+      20,
+      0,
+      21,
+      "-18446744073709551616");
+
+  testcastToString<int128_t>(
+      HugeInt::parse("-18446744073709551616"),
+      20,
+      3,
+      22,
+      "-18446744073709551.616");
+
+  testcastToString<int128_t>(
+      HugeInt::parse("-12345678901234567890"),
+      20,
+      20,
+      23,
+      "-0.12345678901234567890");
+  testcastToString<int128_t>(
+      DecimalUtil::kLongDecimalMax, 38, 0, 39, std::string(38, '9'));
+  testcastToString<int128_t>(
+      DecimalUtil::kLongDecimalMin, 38, 0, 39, "-" + std::string(38, '9'));
+}
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/type/tests/FilterBenchmark.cpp b/velox/type/tests/FilterBenchmark.cpp
index ead694fe61dcb..c699b4da1e959 100644
--- a/velox/type/tests/FilterBenchmark.cpp
+++ b/velox/type/tests/FilterBenchmark.cpp
@@ -70,7 +70,7 @@ BENCHMARK_RELATIVE(simdSparse) {
 int32_t main(int32_t argc, char* argv[]) {
   constexpr int32_t kNumValues = 1000000;
   constexpr int32_t kFilterValues = 1000;
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   std::vector<int64_t> filterValues;
   filterValues.reserve(kFilterValues);
diff --git a/velox/type/tests/FilterSerDeTest.cpp b/velox/type/tests/FilterSerDeTest.cpp
index 03bd2dd363a00..0b4c52c1a9021 100644
--- a/velox/type/tests/FilterSerDeTest.cpp
+++ b/velox/type/tests/FilterSerDeTest.cpp
@@ -152,7 +152,7 @@ TEST_F(FilterSerDeTest, multiFilter) {
   filters.emplace_back(std::make_unique<BytesRange>(
       "ABCD", true, true, "FFFF", false, true, false));
 
-  MultiRange multiRange(std::move(filters), true, true);
+  MultiRange multiRange(std::move(filters), true);
   testSerde(multiRange);
 }
 
diff --git a/velox/type/tests/FilterTest.cpp b/velox/type/tests/FilterTest.cpp
index e7c10677fddc7..339b678adba3d 100644
--- a/velox/type/tests/FilterTest.cpp
+++ b/velox/type/tests/FilterTest.cpp
@@ -644,6 +644,8 @@ TEST(FilterTest, doubleRange) {
   EXPECT_FALSE(filter->testNull());
   EXPECT_FALSE(filter->testDouble(1.2));
   EXPECT_FALSE(filter->testDouble(-19.267));
+  EXPECT_TRUE(filter->testDouble(std::nanf("nan1")));
+  EXPECT_TRUE(filter->testDouble(std::nanf("nan2")));
   {
     double n4[] = {-1e100, std::nan("nan"), 1.3, 1e200};
     checkSimd(filter.get(), n4, verify);
@@ -705,6 +707,19 @@ TEST(FilterTest, floatRange) {
     checkSimd(filter.get(), n8, verify);
   }
 
+  filter = greaterThanFloat(1.2);
+  EXPECT_FALSE(filter->testFloat(1.1f));
+
+  EXPECT_FALSE(filter->testNull());
+  EXPECT_FALSE(filter->testFloat(1.2f));
+  EXPECT_TRUE(filter->testFloat(15.632f));
+  EXPECT_TRUE(filter->testFloat(std::nanf("nan1")));
+  EXPECT_TRUE(filter->testFloat(std::nanf("nan2")));
+  {
+    float n8[] = {1.0, std::nanf("nan"), 1.3, 1e20, -1e20, 0, 1.1, 1.2};
+    checkSimd(filter.get(), n8, verify);
+  }
+
   EXPECT_THROW(
       betweenFloat(std::nanf("NAN"), std::nanf("NAN")), VeloxRuntimeError)
       << "able to create a FloatRange with NaN";
@@ -1035,7 +1050,7 @@ TEST(FilterTest, multiRange) {
   EXPECT_TRUE(filter->testDouble(1.3));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testDouble(std::nan("nan")));
+  EXPECT_TRUE(filter->testDouble(std::nan("nan")));
   EXPECT_FALSE(filter->testDouble(1.2));
 
   filter = orFilter(lessThanFloat(1.2), greaterThanFloat(1.2));
@@ -1044,7 +1059,7 @@ TEST(FilterTest, multiRange) {
   EXPECT_TRUE(filter->testFloat(1.1f));
   EXPECT_FALSE(filter->testFloat(1.2f));
   EXPECT_TRUE(filter->testFloat(1.3f));
-  EXPECT_FALSE(filter->testFloat(std::nanf("nan")));
+  EXPECT_TRUE(filter->testFloat(std::nanf("nan")));
 
   // != ''
   filter = orFilter(lessThan(""), greaterThan(""));
@@ -1054,51 +1069,39 @@ TEST(FilterTest, multiRange) {
 
 TEST(FilterTest, multiRangeWithNaNs) {
   // x <> 1.2 with nanAllowed true
-  auto filter =
-      orFilter(lessThanFloat(1.2), greaterThanFloat(1.2), false, true);
+  auto filter = orFilter(lessThanFloat(1.2), greaterThanFloat(1.2), false);
   EXPECT_TRUE(filter->testFloat(std::nanf("nan")));
   EXPECT_FALSE(filter->testFloat(1.2f));
   EXPECT_TRUE(filter->testFloat(1.1f));
 
-  filter = orFilter(lessThanDouble(1.2), greaterThanDouble(1.2), false, true);
+  filter = orFilter(lessThanDouble(1.2), greaterThanDouble(1.2), false);
   EXPECT_TRUE(filter->testDouble(std::nan("nan")));
   EXPECT_FALSE(filter->testDouble(1.2));
   EXPECT_TRUE(filter->testDouble(1.1));
 
   // x <> 1.2 with nanAllowed false
   filter = orFilter(lessThanFloat(1.2), greaterThanFloat(1.2));
-  EXPECT_FALSE(filter->testFloat(std::nanf("nan")));
+  EXPECT_TRUE(filter->testFloat(std::nanf("nan")));
   EXPECT_TRUE(filter->testFloat(1.0f));
 
   filter = orFilter(lessThanDouble(1.2), greaterThanDouble(1.2));
-  EXPECT_FALSE(filter->testDouble(std::nan("nan")));
+  EXPECT_TRUE(filter->testDouble(std::nan("nan")));
   EXPECT_TRUE(filter->testDouble(1.4));
 
   // x NOT IN (1.2, 1.3) with nanAllowed true
-  filter = orFilter(lessThanFloat(1.2), greaterThanFloat(1.3), false, true);
+  filter = orFilter(lessThanFloat(1.2), greaterThanFloat(1.3), false);
   EXPECT_TRUE(filter->testFloat(std::nanf("nan")));
   EXPECT_FALSE(filter->testFloat(1.2f));
   EXPECT_FALSE(filter->testFloat(1.3f));
   EXPECT_TRUE(filter->testFloat(1.4f));
   EXPECT_TRUE(filter->testFloat(1.1f));
 
-  filter = orFilter(lessThanDouble(1.2), greaterThanDouble(1.3), false, true);
+  filter = orFilter(lessThanDouble(1.2), greaterThanDouble(1.3), false);
   EXPECT_TRUE(filter->testDouble(std::nan("nan")));
   EXPECT_FALSE(filter->testDouble(1.2));
   EXPECT_FALSE(filter->testDouble(1.3));
   EXPECT_TRUE(filter->testDouble(1.4));
   EXPECT_TRUE(filter->testDouble(1.1));
-
-  // x NOT IN (1.2) with nanAllowed false
-  filter = orFilter(lessThanFloat(1.2), greaterThanFloat(1.2));
-  EXPECT_FALSE(filter->testFloat(std::nanf("nan")));
-  EXPECT_FALSE(filter->testFloat(1.2f));
-  EXPECT_TRUE(filter->testFloat(1.3f));
-
-  filter = orFilter(lessThanDouble(1.2), greaterThanDouble(1.2));
-  EXPECT_FALSE(filter->testDouble(std::nan("nan")));
-  EXPECT_FALSE(filter->testDouble(1.2));
-  EXPECT_TRUE(filter->testDouble(1.3));
 }
 
 TEST(FilterTest, createBigintValues) {
@@ -1310,8 +1313,8 @@ void testMergeWithBytes(Filter* left, Filter* right) {
         merged->testBytes(test.data(), test.size()),
         left->testBytes(test.data(), test.size()) &&
             right->testBytes(test.data(), test.size()))
-        << test << " "
-        << "left: " << left->toString() << ", right: " << right->toString()
+        << test << " " << "left: " << left->toString()
+        << ", right: " << right->toString()
         << ", merged: " << merged->toString();
   }
 }
diff --git a/velox/type/tests/FloatingPointUtilTest.cpp b/velox/type/tests/FloatingPointUtilTest.cpp
new file mode 100644
index 0000000000000..c603d18d0e5dd
--- /dev/null
+++ b/velox/type/tests/FloatingPointUtilTest.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <utility>
+
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox {
+namespace {
+
+template <typename T>
+void testFloatingPoint() {
+  using namespace util::floating_point;
+
+  static const T kNaN = std::numeric_limits<T>::quiet_NaN();
+  static const T kSNAN = std::numeric_limits<T>::signaling_NaN();
+  static const T kInf = std::numeric_limits<T>::infinity();
+
+  ASSERT_TRUE(NaNAwareEquals<T>{}(kNaN, kNaN));
+  ASSERT_TRUE(NaNAwareEquals<T>{}(kNaN, kSNAN));
+  ASSERT_FALSE(NaNAwareEquals<T>{}(kNaN, 0.0));
+
+  ASSERT_FALSE(NaNAwareLessThan<T>{}(kNaN, kNaN));
+  ASSERT_FALSE(NaNAwareLessThan<T>{}(kNaN, kSNAN));
+  ASSERT_FALSE(NaNAwareLessThan<T>{}(kNaN, kInf));
+  ASSERT_TRUE(NaNAwareLessThan<T>{}(kInf, kNaN));
+
+  ASSERT_TRUE(NaNAwareLessThanEqual<T>{}(kNaN, kNaN));
+  ASSERT_TRUE(NaNAwareLessThanEqual<T>{}(kNaN, kSNAN));
+  ASSERT_TRUE(NaNAwareLessThanEqual<T>{}(kInf, kNaN));
+  ASSERT_TRUE(NaNAwareLessThanEqual<T>{}(0.0, kInf));
+  ASSERT_FALSE(NaNAwareLessThanEqual<T>{}(kNaN, kInf));
+  ASSERT_FALSE(NaNAwareLessThanEqual<T>{}(kNaN, 0.0));
+
+  ASSERT_FALSE(NaNAwareGreaterThan<T>{}(kNaN, kNaN));
+  ASSERT_FALSE(NaNAwareGreaterThan<T>{}(kNaN, kSNAN));
+  ASSERT_FALSE(NaNAwareGreaterThan<T>{}(kInf, kNaN));
+  ASSERT_TRUE(NaNAwareGreaterThan<T>{}(kNaN, kInf));
+
+  ASSERT_TRUE(NaNAwareGreaterThanEqual<T>{}(kNaN, kNaN));
+  ASSERT_TRUE(NaNAwareGreaterThanEqual<T>{}(kNaN, kSNAN));
+  ASSERT_FALSE(NaNAwareGreaterThanEqual<T>{}(kInf, kNaN));
+  ASSERT_FALSE(NaNAwareGreaterThanEqual<T>{}(0.0, kInf));
+  ASSERT_TRUE(NaNAwareGreaterThanEqual<T>{}(kNaN, kInf));
+  ASSERT_TRUE(NaNAwareGreaterThanEqual<T>{}(kNaN, 0.0));
+
+  ASSERT_EQ(NaNAwareHash<T>{}(kNaN), NaNAwareHash<T>{}(kSNAN));
+  ASSERT_EQ(NaNAwareHash<T>{}(kNaN), NaNAwareHash<T>{}(kNaN));
+  ASSERT_EQ(NaNAwareHash<T>{}(0.0), NaNAwareHash<T>{}(0.0));
+  ASSERT_EQ(NaNAwareHash<T>{}(kInf), NaNAwareHash<T>{}(kInf));
+  ASSERT_NE(NaNAwareHash<T>{}(kNaN), NaNAwareHash<T>{}(kInf));
+  ASSERT_NE(NaNAwareHash<T>{}(kNaN), NaNAwareHash<T>{}(0.0));
+}
+
+TEST(FloatingPointUtilTest, basic) {
+  testFloatingPoint<float>();
+  testFloatingPoint<double>();
+}
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/NegatedBigintRangeBenchmark.cpp b/velox/type/tests/NegatedBigintRangeBenchmark.cpp
index 4c4c4369de0d2..7da7b4073a7eb 100644
--- a/velox/type/tests/NegatedBigintRangeBenchmark.cpp
+++ b/velox/type/tests/NegatedBigintRangeBenchmark.cpp
@@ -118,7 +118,7 @@ DEFINE_RANGE_BENCHMARKS(9000)
 DEFINE_RANGE_BENCHMARKS(9900)
 
 int32_t main(int32_t argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   constexpr int32_t kNumValues = 1000000;
   constexpr int64_t distinctVals = 20001; // -10000 to 10000
   const std::vector<int64_t> pctZeros = {0, 1, 5, 10, 50, 90, 95, 99, 100};
diff --git a/velox/type/tests/NegatedBytesRangeBenchmark.cpp b/velox/type/tests/NegatedBytesRangeBenchmark.cpp
index fe0a0d0b5cbb0..8459e6db74e6c 100644
--- a/velox/type/tests/NegatedBytesRangeBenchmark.cpp
+++ b/velox/type/tests/NegatedBytesRangeBenchmark.cpp
@@ -129,7 +129,7 @@ DEFINE_BENCHMARKS(100, 94)
 DEFINE_BENCHMARKS(100, 98)
 
 int32_t main(int32_t argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   constexpr int32_t kNumValues = 1000000;
   constexpr int32_t kStringPoolSize = 20000;
   const std::vector<int32_t> stringLengths = {2, 3, 5, 10, 100};
@@ -169,8 +169,8 @@ int32_t main(int32_t argc, char** argv) {
           "", true, false, lo, false, true, false));
       rangeFilters.emplace_back(std::make_unique<common::BytesRange>(
           hi, false, false, "", true, false, false));
-      multiRanges.emplace_back(std::make_unique<common::MultiRange>(
-          std::move(rangeFilters), false, false));
+      multiRanges.emplace_back(
+          std::make_unique<common::MultiRange>(std::move(rangeFilters), false));
 
       LOG(INFO) << "Generated filter for length " << len << " with percentage "
                 << pct;
diff --git a/velox/type/tests/NegatedBytesValuesBenchmark.cpp b/velox/type/tests/NegatedBytesValuesBenchmark.cpp
index 3217e6c316f8d..78da7f714dca5 100644
--- a/velox/type/tests/NegatedBytesValuesBenchmark.cpp
+++ b/velox/type/tests/NegatedBytesValuesBenchmark.cpp
@@ -121,7 +121,7 @@ DEFINE_BENCHMARKS(100, 1000)
 DEFINE_BENCHMARKS(100, 10000)
 
 int32_t main(int32_t argc, char* argv[]) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   constexpr int32_t k_num_values = 1000000;
   constexpr int32_t k_string_pool_size = 20000;
   const std::vector<int32_t> string_lengths = {1, 2, 5, 10, 100};
@@ -178,7 +178,7 @@ int32_t main(int32_t argc, char* argv[]) {
       range_filters.emplace_back(std::make_unique<common::BytesRange>(
           *back, false, true, "", true, true, false));
       multi_ranges.emplace_back(std::make_unique<common::MultiRange>(
-          std::move(range_filters), false, false));
+          std::move(range_filters), false));
 
       LOG(INFO) << "Generated filter for length " << len << " with size "
                 << size;
diff --git a/velox/type/tests/NegatedValuesFilterBenchmark.cpp b/velox/type/tests/NegatedValuesFilterBenchmark.cpp
index b613911cc24f1..62393b9124b1d 100644
--- a/velox/type/tests/NegatedValuesFilterBenchmark.cpp
+++ b/velox/type/tests/NegatedValuesFilterBenchmark.cpp
@@ -125,7 +125,7 @@ int32_t main(int32_t argc, char* argv[]) {
       1000, 1000, 10000, 10, 1000, 1000, 1000};
   std::vector<std::vector<int64_t>> rejectedValues;
 
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
 
   rejectedValues.reserve(kFilterSizes.size());
   for (auto i = 0; i < kFilterSizes.size(); ++i) {
diff --git a/velox/type/tests/StringViewBenchmark.cpp b/velox/type/tests/StringViewBenchmark.cpp
index d4cb5e63423c6..c710b21df57d0 100644
--- a/velox/type/tests/StringViewBenchmark.cpp
+++ b/velox/type/tests/StringViewBenchmark.cpp
@@ -53,7 +53,7 @@ BENCHMARK_PARAM(runStringViewCreate, NON_INLINE_SIZE);
 } // namespace facebook::velox
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/type/tests/SubfieldTest.cpp b/velox/type/tests/SubfieldTest.cpp
index ea2393d2e17d1..7edeab16aeb80 100644
--- a/velox/type/tests/SubfieldTest.cpp
+++ b/velox/type/tests/SubfieldTest.cpp
@@ -57,6 +57,9 @@ void testColumnName(
 }
 
 TEST(SubfieldTest, columnNamesWithSpecialCharacters) {
+  testColumnName("two words");
+  testColumnName("two  words");
+  testColumnName("one two three");
   testColumnName("$bucket");
   testColumnName("apollo-11");
   testColumnName("a/b/c:12");
diff --git a/velox/type/tests/TimestampConversionTest.cpp b/velox/type/tests/TimestampConversionTest.cpp
index 4763eb9d882e5..9250efdb2e7b1 100644
--- a/velox/type/tests/TimestampConversionTest.cpp
+++ b/velox/type/tests/TimestampConversionTest.cpp
@@ -18,439 +18,572 @@
 #include <gmock/gmock.h>
 #include "velox/common/base/VeloxException.h"
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/external/date/tz.h"
 #include "velox/type/Timestamp.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::util {
 namespace {
 
-TEST(DateTimeUtilTest, fromDate) {
-  EXPECT_EQ(0, daysSinceEpochFromDate(1970, 1, 1));
-  EXPECT_EQ(1, daysSinceEpochFromDate(1970, 1, 2));
-  EXPECT_EQ(365, daysSinceEpochFromDate(1971, 1, 1));
-  EXPECT_EQ(730, daysSinceEpochFromDate(1972, 1, 1)); // leap year.
-  EXPECT_EQ(1096, daysSinceEpochFromDate(1973, 1, 1));
+Timestamp parseTimestamp(
+    const StringView& timestamp,
+    TimestampParseMode parseMode = TimestampParseMode::kPrestoCast) {
+  return fromTimestampString(timestamp, parseMode)
+      .thenOrThrow(folly::identity, [&](const Status& status) {
+        VELOX_USER_FAIL("{}", status.message());
+      });
+}
+
+int32_t parseDate(const StringView& str, ParseMode mode) {
+  return fromDateString(str.data(), str.size(), mode)
+      .thenOrThrow(folly::identity, [&](const Status& status) {
+        VELOX_USER_FAIL("{}", status.message());
+      });
+}
 
-  EXPECT_EQ(10957, daysSinceEpochFromDate(2000, 1, 1));
-  EXPECT_EQ(18474, daysSinceEpochFromDate(2020, 7, 31));
+std::pair<Timestamp, const tz::TimeZone*> parseTimestampWithTimezone(
+    const StringView& str,
+    TimestampParseMode parseMode = TimestampParseMode::kPrestoCast) {
+  return fromTimestampWithTimezoneString(str.data(), str.size(), parseMode)
+      .thenOrThrow(folly::identity, [&](const Status& status) {
+        VELOX_USER_FAIL("{}", status.message());
+      });
+}
+
+TEST(DateTimeUtilTest, fromDate) {
+  auto testDaysSinceEpochFromDate =
+      [](int32_t year, int32_t month, int32_t day) {
+        Expected<int64_t> daysSinceEpoch =
+            util::daysSinceEpochFromDate(year, month, day);
+        EXPECT_FALSE(daysSinceEpoch.hasError());
+        return daysSinceEpoch.value();
+      };
+  EXPECT_EQ(0, testDaysSinceEpochFromDate(1970, 1, 1));
+  EXPECT_EQ(1, testDaysSinceEpochFromDate(1970, 1, 2));
+  EXPECT_EQ(365, testDaysSinceEpochFromDate(1971, 1, 1));
+  EXPECT_EQ(730, testDaysSinceEpochFromDate(1972, 1, 1)); // leap year.
+  EXPECT_EQ(1096, testDaysSinceEpochFromDate(1973, 1, 1));
+
+  EXPECT_EQ(10957, testDaysSinceEpochFromDate(2000, 1, 1));
+  EXPECT_EQ(18474, testDaysSinceEpochFromDate(2020, 7, 31));
 
   // Before unix epoch.
-  EXPECT_EQ(-1, daysSinceEpochFromDate(1969, 12, 31));
-  EXPECT_EQ(-365, daysSinceEpochFromDate(1969, 1, 1));
-  EXPECT_EQ(-731, daysSinceEpochFromDate(1968, 1, 1)); // leap year.
-  EXPECT_EQ(-719528, daysSinceEpochFromDate(0, 1, 1));
+  EXPECT_EQ(-1, testDaysSinceEpochFromDate(1969, 12, 31));
+  EXPECT_EQ(-365, testDaysSinceEpochFromDate(1969, 1, 1));
+  EXPECT_EQ(-731, testDaysSinceEpochFromDate(1968, 1, 1)); // leap year.
+  EXPECT_EQ(-719528, testDaysSinceEpochFromDate(0, 1, 1));
 
   // Negative year - BC.
-  EXPECT_EQ(-719529, daysSinceEpochFromDate(-1, 12, 31));
-  EXPECT_EQ(-719893, daysSinceEpochFromDate(-1, 1, 1));
+  EXPECT_EQ(-719529, testDaysSinceEpochFromDate(-1, 12, 31));
+  EXPECT_EQ(-719893, testDaysSinceEpochFromDate(-1, 1, 1));
 }
 
 TEST(DateTimeUtilTest, fromDateInvalid) {
-  EXPECT_THROW(daysSinceEpochFromDate(1970, 1, -1), VeloxUserError);
-  EXPECT_THROW(daysSinceEpochFromDate(1970, -1, 1), VeloxUserError);
-  EXPECT_THROW(daysSinceEpochFromDate(1970, 0, 1), VeloxUserError);
-  EXPECT_THROW(daysSinceEpochFromDate(1970, 13, 1), VeloxUserError);
-  EXPECT_THROW(daysSinceEpochFromDate(1970, 1, 32), VeloxUserError);
-  EXPECT_THROW(
-      daysSinceEpochFromDate(1970, 2, 29), VeloxUserError); // non-leap.
-  EXPECT_THROW(daysSinceEpochFromDate(1970, 6, 31), VeloxUserError);
+  auto testDaysSinceEpochFromDateInvalid =
+      [](int32_t year, int32_t month, int32_t day, const std::string& error) {
+        Expected<int64_t> expected =
+            util::daysSinceEpochFromDate(year, month, day);
+        EXPECT_TRUE(expected.hasError());
+        EXPECT_TRUE(expected.error().isUserError());
+        EXPECT_EQ(expected.error().message(), error);
+      };
+  EXPECT_NO_THROW(testDaysSinceEpochFromDateInvalid(
+      1970, 1, -1, "Date out of range: 1970-1--1"));
+  EXPECT_NO_THROW(testDaysSinceEpochFromDateInvalid(
+      1970, -1, 1, "Date out of range: 1970--1-1"));
+  EXPECT_NO_THROW(testDaysSinceEpochFromDateInvalid(
+      1970, 0, 1, "Date out of range: 1970-0-1"));
+  EXPECT_NO_THROW(testDaysSinceEpochFromDateInvalid(
+      1970, 13, 1, "Date out of range: 1970-13-1"));
+  EXPECT_NO_THROW(testDaysSinceEpochFromDateInvalid(
+      1970, 1, 32, "Date out of range: 1970-1-32"));
+  EXPECT_NO_THROW(testDaysSinceEpochFromDateInvalid(
+      1970, 2, 29, "Date out of range: 1970-2-29")); // non-leap.
+  EXPECT_NO_THROW(testDaysSinceEpochFromDateInvalid(
+      1970, 6, 31, "Date out of range: 1970-6-31"));
 }
 
-TEST(DateTimeUtilTest, fromDateString) {
-  EXPECT_EQ(10957, fromDateString("2000-01-01"));
-  EXPECT_EQ(0, fromDateString("1970-01-01"));
-  EXPECT_EQ(1, fromDateString("1970-01-02"));
-
-  // Single character
-  EXPECT_EQ(1, fromDateString("1970-1-2"));
-
-  // Old and negative years.
-  EXPECT_EQ(-719528, fromDateString("0-1-1"));
-  EXPECT_EQ(-719162, fromDateString("1-1-1"));
-  EXPECT_EQ(-719893, fromDateString("-1-1-1"));
-  EXPECT_EQ(-720258, fromDateString("-2-1-1"));
-
-  // 1BC is equal 0-1-1.
-  EXPECT_EQ(-719528, fromDateString("1-1-1 (BC)"));
-  EXPECT_EQ(-719893, fromDateString("2-1-1 (BC)"));
-
-  // Leading zeros and spaces.
-  EXPECT_EQ(-719162, fromDateString("00001-1-1"));
-  EXPECT_EQ(-719162, fromDateString(" 1-1-1"));
-  EXPECT_EQ(-719162, fromDateString("     1-1-1"));
-  EXPECT_EQ(-719162, fromDateString("\t1-1-1"));
-  EXPECT_EQ(-719162, fromDateString("  \t    \n 00001-1-1  \n"));
-
-  // Different separators.
-  EXPECT_EQ(-719162, fromDateString("1/1/1"));
-  EXPECT_EQ(-719162, fromDateString("1 1 1"));
-  EXPECT_EQ(-719162, fromDateString("1\\1\\1"));
-
-  // Other string types.
-  EXPECT_EQ(0, fromDateString(StringView("1970-01-01")));
-}
+TEST(DateTimeUtilTest, daysSinceEpochFromWeekOfMonthDateLenient) {
+  auto daysSinceEpoch =
+      [](int32_t year, int32_t month, int32_t weekOfMonth, int32_t dayOfWeek) {
+        auto result = util::daysSinceEpochFromWeekOfMonthDate(
+            year, month, weekOfMonth, dayOfWeek, true);
+        EXPECT_TRUE(!result.hasError());
+        return result.value();
+      };
+
+  EXPECT_EQ(4, daysSinceEpoch(1970, 1, 2, 1));
+  EXPECT_EQ(361, daysSinceEpoch(1971, 1, 1, 1));
+  EXPECT_EQ(396, daysSinceEpoch(1971, 2, 1, 1));
+
+  EXPECT_EQ(10952, daysSinceEpoch(2000, 1, 1, 1));
+  EXPECT_EQ(19905, daysSinceEpoch(2024, 7, 1, 1));
+
+  // Before unix epoch.
+  EXPECT_EQ(-3, daysSinceEpoch(1970, 1, 1, 1));
+  EXPECT_EQ(-2, daysSinceEpoch(1970, 1, 1, 2));
+  EXPECT_EQ(-31, daysSinceEpoch(1969, 12, 1, 1));
+  EXPECT_EQ(-367, daysSinceEpoch(1969, 1, 1, 1));
+  EXPECT_EQ(-724, daysSinceEpoch(1968, 1, 2, 1));
+  EXPECT_EQ(-719533, daysSinceEpoch(0, 1, 1, 1));
 
-TEST(DateTimeUtilTest, fromDateStrInvalid) {
-  EXPECT_THROW(fromDateString(""), VeloxUserError);
-  EXPECT_THROW(fromDateString("     "), VeloxUserError);
-  EXPECT_THROW(fromDateString("2000"), VeloxUserError);
+  // Negative year - BC.
+  EXPECT_EQ(-719561, daysSinceEpoch(-1, 12, 1, 1));
+  EXPECT_EQ(-719897, daysSinceEpoch(-1, 1, 1, 1));
+
+  // Day in the previous month.
+  EXPECT_EQ(19783, daysSinceEpoch(2024, 2, 5, 5));
+  // Day in the next month.
+  EXPECT_EQ(19751, daysSinceEpoch(2024, 2, 1, 1));
+
+  // Out of range day of week.
+  EXPECT_EQ(338, daysSinceEpoch(1970, 12, 1, 0));
+  EXPECT_EQ(337, daysSinceEpoch(1970, 12, 1, -1));
+  EXPECT_EQ(337, daysSinceEpoch(1970, 12, 1, -8));
+
+  EXPECT_EQ(332, daysSinceEpoch(1970, 12, 1, 8));
+  EXPECT_EQ(333, daysSinceEpoch(1970, 12, 1, 9));
+  EXPECT_EQ(336, daysSinceEpoch(1970, 12, 1, 19));
+
+  // Out of range month.
+  EXPECT_EQ(-3, daysSinceEpoch(1970, 1, 1, 1));
+  EXPECT_EQ(207, daysSinceEpoch(1970, 8, 1, 1));
+  EXPECT_EQ(361, daysSinceEpoch(1970, 13, 1, 1));
+
+  EXPECT_EQ(-31, daysSinceEpoch(1970, 0, 1, 1));
+  EXPECT_EQ(-66, daysSinceEpoch(1970, -1, 1, 1));
+  EXPECT_EQ(-430, daysSinceEpoch(1970, -13, 1, 1));
+
+  // Out of range year.
+  auto result =
+      util::daysSinceEpochFromWeekOfMonthDate(292278995, 1, 1, 1, true);
+  EXPECT_EQ(result.error().message(), "Date out of range: 292278995-1-1");
+}
 
-  // Different separators.
-  EXPECT_THROW(fromDateString("2000/01-01"), VeloxUserError);
-  EXPECT_THROW(fromDateString("2000 01-01"), VeloxUserError);
+TEST(DateTimeUtilTest, extractISODayOfTheWeek) {
+  EXPECT_EQ(
+      4, util::extractISODayOfTheWeek(std::numeric_limits<int64_t>::max()));
+  EXPECT_EQ(
+      3, util::extractISODayOfTheWeek(std::numeric_limits<int64_t>::min()));
+  EXPECT_EQ(1, util::extractISODayOfTheWeek(-10));
+  EXPECT_EQ(7, util::extractISODayOfTheWeek(10));
+}
 
-  // Trailing characters.
-  EXPECT_THROW(fromDateString("2000-01-01   asdf"), VeloxUserError);
-  EXPECT_THROW(fromDateString("2000-01-01 0"), VeloxUserError);
+TEST(DateTimeUtilTest, daysSinceEpochFromWeekOfMonthDateNonLenient) {
+  auto daysSinceEpochReturnError = [](int32_t year,
+                                      int32_t month,
+                                      int32_t weekOfMonth,
+                                      int32_t dayOfWeek,
+                                      const std::string& error) {
+    auto result = util::daysSinceEpochFromWeekOfMonthDate(
+        year, month, weekOfMonth, dayOfWeek, false);
+    EXPECT_TRUE(result.error().isUserError());
+    EXPECT_EQ(result.error().message(), error);
+  };
 
-  // Too large of a year.
-  EXPECT_THROW(fromDateString("1000000"), VeloxUserError);
-  EXPECT_THROW(fromDateString("-1000000"), VeloxUserError);
+  EXPECT_NO_THROW(daysSinceEpochReturnError(
+      292278995, 1, 1, 1, "Date out of range: 292278995-1-1-1"));
+  EXPECT_NO_THROW(daysSinceEpochReturnError(
+      2024, 0, 1, 1, "Date out of range: 2024-0-1-1"));
+  EXPECT_NO_THROW(daysSinceEpochReturnError(
+      2024, 13, 1, 1, "Date out of range: 2024-13-1-1"));
+  EXPECT_NO_THROW(daysSinceEpochReturnError(
+      2024, 1, 6, 1, "Date out of range: 2024-1-6-1"));
+  EXPECT_NO_THROW(daysSinceEpochReturnError(
+      2024, 2, 1, 1, "Date out of range: 2024-2-1-1"));
+  EXPECT_NO_THROW(daysSinceEpochReturnError(
+      2024, 2, 5, 5, "Date out of range: 2024-2-5-5"));
+
+  auto daysSinceEpochReturnValues =
+      [](int32_t year, int32_t month, int32_t weekOfMonth, int32_t dayOfWeek) {
+        auto result = util::daysSinceEpochFromWeekOfMonthDate(
+            year, month, weekOfMonth, dayOfWeek, false);
+        EXPECT_TRUE(!result.hasError());
+        return result.value();
+      };
+
+  EXPECT_EQ(-724, daysSinceEpochReturnValues(1968, 1, 2, 1));
+  EXPECT_EQ(4, daysSinceEpochReturnValues(1970, 1, 2, 1));
+  EXPECT_EQ(396, daysSinceEpochReturnValues(1971, 2, 1, 1));
+  EXPECT_EQ(19905, daysSinceEpochReturnValues(2024, 7, 1, 1));
 }
 
-TEST(DateTimeUtilTest, castFromDateString) {
-  for (bool isIso8601 : {true, false}) {
-    EXPECT_EQ(0, castFromDateString("1970-01-01", isIso8601));
-    EXPECT_EQ(3789742, castFromDateString("12345-12-18", isIso8601));
+TEST(DateTimeUtilTest, fromDateString) {
+  for (ParseMode mode : {ParseMode::kPrestoCast, ParseMode::kSparkCast}) {
+    EXPECT_EQ(0, parseDate("1970-01-01", mode));
+    EXPECT_EQ(3789742, parseDate("12345-12-18", mode));
 
-    EXPECT_EQ(1, castFromDateString("1970-1-2", isIso8601));
-    EXPECT_EQ(1, castFromDateString("1970-01-2", isIso8601));
-    EXPECT_EQ(1, castFromDateString("1970-1-02", isIso8601));
+    EXPECT_EQ(1, parseDate("1970-1-2", mode));
+    EXPECT_EQ(1, parseDate("1970-01-2", mode));
+    EXPECT_EQ(1, parseDate("1970-1-02", mode));
 
-    EXPECT_EQ(1, castFromDateString("+1970-01-02", isIso8601));
-    EXPECT_EQ(-719893, castFromDateString("-1-1-1", isIso8601));
+    EXPECT_EQ(1, parseDate("+1970-01-02", mode));
+    EXPECT_EQ(-719893, parseDate("-1-1-1", mode));
 
-    EXPECT_EQ(0, castFromDateString(" 1970-01-01", isIso8601));
+    EXPECT_EQ(0, parseDate(" 1970-01-01", mode));
+    EXPECT_EQ(0, parseDate("1970-01-01 ", mode));
+    EXPECT_EQ(0, parseDate(" 1970-01-01 ", mode));
   }
 
-  EXPECT_EQ(3789391, castFromDateString("12345", false));
-  EXPECT_EQ(16436, castFromDateString("2015", false));
-  EXPECT_EQ(16495, castFromDateString("2015-03", false));
-  EXPECT_EQ(16512, castFromDateString("2015-03-18T", false));
-  EXPECT_EQ(16512, castFromDateString("2015-03-18T123123", false));
-  EXPECT_EQ(16512, castFromDateString("2015-03-18 123142", false));
-  EXPECT_EQ(16512, castFromDateString("2015-03-18 (BC)", false));
-
-  EXPECT_EQ(0, castFromDateString("1970-01-01 ", false));
-  EXPECT_EQ(0, castFromDateString(" 1970-01-01 ", false));
+  EXPECT_EQ(3789391, parseDate("12345", ParseMode::kSparkCast));
+  EXPECT_EQ(16436, parseDate("2015", ParseMode::kSparkCast));
+  EXPECT_EQ(16495, parseDate("2015-03", ParseMode::kSparkCast));
+  EXPECT_EQ(16512, parseDate("2015-03-18T", ParseMode::kSparkCast));
+  EXPECT_EQ(16512, parseDate("2015-03-18T123123", ParseMode::kSparkCast));
+  EXPECT_EQ(16512, parseDate("2015-03-18 123142", ParseMode::kSparkCast));
+  EXPECT_EQ(16512, parseDate("2015-03-18 (BC)", ParseMode::kSparkCast));
 }
 
-TEST(DateTimeUtilTest, castFromDateStringInvalid) {
+TEST(DateTimeUtilTest, fromDateStringInvalid) {
   auto testCastFromDateStringInvalid = [&](const StringView& str,
-                                           bool isIso8601) {
-    if (isIso8601) {
+                                           ParseMode mode) {
+    if (mode == ParseMode::kPrestoCast) {
       VELOX_ASSERT_THROW(
-          castFromDateString(str, isIso8601),
+          parseDate(str, mode),
           fmt::format(
-              "Unable to parse date value: \"{}\"."
+              "Unable to parse date value: \"{}\". "
               "Valid date string pattern is (YYYY-MM-DD), "
               "and can be prefixed with [+-]",
               std::string(str.data(), str.size())));
-    } else {
+    } else if (mode == ParseMode::kSparkCast) {
+      VELOX_ASSERT_THROW(
+          parseDate(str, mode),
+          fmt::format(
+              "Unable to parse date value: \"{}\". "
+              "Valid date string patterns include "
+              "([y]y*, [y]y*-[m]m*, [y]y*-[m]m*-[d]d*, "
+              "[y]y*-[m]m*-[d]d* *, [y]y*-[m]m*-[d]d*T*), "
+              "and any pattern prefixed with [+-]",
+              std::string(str.data(), str.size())));
+    } else if (mode == ParseMode::kIso8601) {
       VELOX_ASSERT_THROW(
-          castFromDateString(str, isIso8601),
+          parseDate(str, mode),
           fmt::format(
-              "Unable to parse date value: \"{}\"."
+              "Unable to parse date value: \"{}\". "
               "Valid date string patterns include "
-              "(yyyy*, yyyy*-[m]m, yyyy*-[m]m-[d]d, "
-              "yyyy*-[m]m-[d]d *, yyyy*-[m]m-[d]dT*), "
+              "([y]y*, [y]y*-[m]m*, [y]y*-[m]m*-[d]d*, "
+              "[y]y*-[m]m*-[d]d* *), "
               "and any pattern prefixed with [+-]",
               std::string(str.data(), str.size())));
     }
   };
 
-  for (bool isIso8601 : {true, false}) {
-    testCastFromDateStringInvalid("2012-Oct-23", isIso8601);
-    testCastFromDateStringInvalid("2012-Oct-23", isIso8601);
-    testCastFromDateStringInvalid("2015-03-18X", isIso8601);
-    testCastFromDateStringInvalid("2015/03/18", isIso8601);
-    testCastFromDateStringInvalid("2015.03.18", isIso8601);
-    testCastFromDateStringInvalid("20150318", isIso8601);
-    testCastFromDateStringInvalid("2015-031-8", isIso8601);
+  for (ParseMode mode : {ParseMode::kPrestoCast, ParseMode::kSparkCast}) {
+    testCastFromDateStringInvalid("2012-Oct-23", mode);
+    testCastFromDateStringInvalid("2012-Oct-23", mode);
+    testCastFromDateStringInvalid("2015-03-18X", mode);
+    testCastFromDateStringInvalid("2015/03/18", mode);
+    testCastFromDateStringInvalid("2015.03.18", mode);
+    testCastFromDateStringInvalid("20150318", mode);
+    testCastFromDateStringInvalid("2015-031-8", mode);
   }
 
-  testCastFromDateStringInvalid("12345", true);
-  testCastFromDateStringInvalid("2015", true);
-  testCastFromDateStringInvalid("2015-03", true);
-  testCastFromDateStringInvalid("2015-03-18 123412", true);
-  testCastFromDateStringInvalid("2015-03-18T", true);
-  testCastFromDateStringInvalid("2015-03-18T123412", true);
-  testCastFromDateStringInvalid("2015-03-18 (BC)", true);
-
-  testCastFromDateStringInvalid("1970-01-01 ", true);
-  testCastFromDateStringInvalid(" 1970-01-01 ", true);
+  testCastFromDateStringInvalid("12345", ParseMode::kStrict);
+  testCastFromDateStringInvalid("2015", ParseMode::kStrict);
+  testCastFromDateStringInvalid("2015-03", ParseMode::kStrict);
+  testCastFromDateStringInvalid("2015-03-18 123412", ParseMode::kStrict);
+  testCastFromDateStringInvalid("2015-03-18T", ParseMode::kStrict);
+  testCastFromDateStringInvalid("2015-03-18T123412", ParseMode::kStrict);
+  testCastFromDateStringInvalid("2015-03-18 (BC)", ParseMode::kStrict);
+  testCastFromDateStringInvalid("1970-01-01 ", ParseMode::kStrict);
+  testCastFromDateStringInvalid(" 1970-01-01 ", ParseMode::kStrict);
+
+  testCastFromDateStringInvalid("1970-01-01T01:00:47", ParseMode::kIso8601);
+  testCastFromDateStringInvalid("1970-01-01T01:00:47.000", ParseMode::kIso8601);
 }
 
-TEST(DateTimeUtilTest, fromTimeString) {
-  EXPECT_EQ(0, fromTimeString("00:00:00"));
-  EXPECT_EQ(0, fromTimeString("00:00:00.00"));
-  EXPECT_EQ(1, fromTimeString("00:00:00.000001"));
-  EXPECT_EQ(10, fromTimeString("00:00:00.00001"));
-  EXPECT_EQ(100, fromTimeString("00:00:00.0001"));
-  EXPECT_EQ(1000, fromTimeString("00:00:00.001"));
-  EXPECT_EQ(10000, fromTimeString("00:00:00.01"));
-  EXPECT_EQ(100000, fromTimeString("00:00:00.1"));
-  EXPECT_EQ(1'000'000, fromTimeString("00:00:01"));
-  EXPECT_EQ(60'000'000, fromTimeString("00:01:00"));
-  EXPECT_EQ(3'600'000'000, fromTimeString("01:00:00"));
-
-  // 1 day minus 1 second.
-  EXPECT_EQ(86'399'000'000, fromTimeString("23:59:59"));
-
-  // Single digit.
-  EXPECT_EQ(0, fromTimeString("0:0:0.0"));
-  EXPECT_EQ(3'661'000'000, fromTimeString("1:1:1"));
-
-  // Leading and trailing spaces.
-  EXPECT_EQ(0, fromTimeString("   \t \n 00:00:00.00  \t"));
+// bash command to verify:
+// $ date -d "2000-01-01 12:21:56Z" +%s
+// ('Z' at the end means UTC).
+TEST(DateTimeUtilTest, fromTimestampString) {
+  EXPECT_EQ(Timestamp(0, 0), parseTimestamp("1970-01-01"));
+  EXPECT_EQ(Timestamp(946684800, 0), parseTimestamp("2000-01-01"));
+
+  EXPECT_EQ(Timestamp(0, 0), parseTimestamp("1970-01-01 00:00"));
+  EXPECT_EQ(Timestamp(0, 0), parseTimestamp("1970-01-01 00:00:00"));
+  EXPECT_EQ(Timestamp(0, 0), parseTimestamp("1970-01-01 00:00:00    "));
+
+  EXPECT_EQ(Timestamp(946729316, 0), parseTimestamp("2000-01-01 12:21:56"));
+  EXPECT_EQ(
+      Timestamp(946729316, 0),
+      parseTimestamp("2000-01-01T12:21:56", TimestampParseMode::kIso8601));
 }
 
-TEST(DateTimeUtilTest, fromTimeStrInvalid) {
-  EXPECT_THROW(fromTimeString(""), VeloxUserError);
-  EXPECT_THROW(fromTimeString("00"), VeloxUserError);
-  EXPECT_THROW(fromTimeString("00:00"), VeloxUserError);
+TEST(DateTimeUtilTest, fromTimestampStringInvalid) {
+  const std::string_view parserError = "Unable to parse timestamp value: ";
+  const std::string_view overflowError = "integer overflow: ";
+  const std::string_view timezoneError = "Unknown timezone value: ";
 
-  // Invalid hour, minutes and seconds.
-  EXPECT_THROW(fromTimeString("24:00:00"), VeloxUserError);
-  EXPECT_THROW(fromTimeString("00:61:00"), VeloxUserError);
-  EXPECT_THROW(fromTimeString("00:00:61"), VeloxUserError);
+  // Needs at least a date.
+  VELOX_ASSERT_THROW(parseTimestamp(""), parserError);
+  VELOX_ASSERT_THROW(parseTimestamp("00:00:00"), parserError);
 
-  // Trailing characters.
-  EXPECT_THROW(fromTimeString("00:00:00   12"), VeloxUserError);
+  // Integer overflow during timestamp parsing.
+  VELOX_ASSERT_THROW(
+      parseTimestamp("2773581570-01-01 00:00:00-asd"), overflowError);
+  VELOX_ASSERT_THROW(
+      parseTimestamp("-2147483648-01-01 00:00:00-asd"), overflowError);
+
+  // Unexpected timezone definition.
+  VELOX_ASSERT_THROW(parseTimestamp("1970-01-01 00:00:00     a"), parserError);
+  VELOX_ASSERT_THROW(parseTimestamp("1970-01-01 00:00:00Z"), parserError);
+  VELOX_ASSERT_THROW(parseTimestamp("1970-01-01 00:00:00Z"), parserError);
+  VELOX_ASSERT_THROW(parseTimestamp("1970-01-01 00:00:00 UTC"), parserError);
+  VELOX_ASSERT_THROW(
+      parseTimestamp("1970-01-01 00:00:00 America/Los_Angeles"), parserError);
+
+  // Cannot have spaces after T.
+  VELOX_ASSERT_THROW(
+      parseTimestamp("2000-01-01T 12:21:56", TimestampParseMode::kIso8601),
+      parserError);
+
+  // Parse timestamp with (broken) timezones.
+  VELOX_ASSERT_THROW(
+      parseTimestampWithTimezone("1970-01-01 00:00:00-asd"), timezoneError);
+  VELOX_ASSERT_THROW(
+      parseTimestampWithTimezone("1970-01-01 00:00:00Z UTC"), parserError);
+  VELOX_ASSERT_THROW(
+      parseTimestampWithTimezone("1970-01-01 00:00:00+00:00:00"),
+      timezoneError);
+
+  // Can't have multiple spaces.
+  VELOX_ASSERT_THROW(
+      parseTimestampWithTimezone("1970-01-01 00:00:00  UTC"), timezoneError);
 }
 
-// bash command to verify:
-// $ date -d "2000-01-01 12:21:56Z" +%s
-// ('Z' at the end means UTC).
-TEST(DateTimeUtilTest, fromTimestampString) {
-  EXPECT_EQ(Timestamp(0, 0), fromTimestampString("1970-01-01"));
-  EXPECT_EQ(Timestamp(946684800, 0), fromTimestampString("2000-01-01"));
+TEST(DateTimeUtilTest, fromTimestampWithTimezoneString) {
+  // -1 means no timezone information.
+  auto expected =
+      std::make_pair<Timestamp, const tz::TimeZone*>(Timestamp(0, 0), nullptr);
+  EXPECT_EQ(parseTimestampWithTimezone("1970-01-01 00:00:00"), expected);
 
-  EXPECT_EQ(Timestamp(0, 0), fromTimestampString("1970-01-01 00:00:00"));
-  EXPECT_EQ(
-      Timestamp(946729316, 0), fromTimestampString("2000-01-01 12:21:56"));
+  // Test timezone offsets.
   EXPECT_EQ(
-      Timestamp(946729316, 0), fromTimestampString("2000-01-01T12:21:56"));
-  EXPECT_EQ(
-      Timestamp(946729316, 0), fromTimestampString("2000-01-01T 12:21:56"));
-
-  // Test UTC offsets.
+      parseTimestampWithTimezone("1970-01-01 00:00:00 -02:00"),
+      std::make_pair(Timestamp(0, 0), tz::locateZone("-02:00")));
   EXPECT_EQ(
-      Timestamp(7200, 0), fromTimestampString("1970-01-01 00:00:00-02:00"));
+      parseTimestampWithTimezone("1970-01-01 00:00:00+13:36"),
+      std::make_pair(Timestamp(0, 0), tz::locateZone("+13:36")));
   EXPECT_EQ(
-      Timestamp(946697400, 0),
-      fromTimestampString("2000-01-01 00:00:00Z-03:30"));
+      parseTimestampWithTimezone("1970-01-01 00:00:00 -11"),
+      std::make_pair(Timestamp(0, 0), tz::locateZone("-11:00")));
   EXPECT_EQ(
-      Timestamp(1587583417, 0),
-      fromTimestampString("2020-04-23 04:23:37+09:00"));
-}
+      parseTimestampWithTimezone("1970-01-01 00:00:00 +0000"),
+      std::make_pair(Timestamp(0, 0), tz::locateZone("+00:00")));
 
-TEST(DateTimeUtilTest, fromTimestampStrInvalid) {
-  // Needs at least a date.
-  EXPECT_THROW(fromTimestampString(""), VeloxUserError);
-  EXPECT_THROW(fromTimestampString("00:00:00"), VeloxUserError);
+  EXPECT_EQ(
+      parseTimestampWithTimezone("1970-01-01 00:00:00Z"),
+      std::make_pair(Timestamp(0, 0), tz::locateZone("UTC")));
 
-  // Broken UTC offsets.
-  EXPECT_THROW(fromTimestampString("1970-01-01 00:00:00-asd"), VeloxUserError);
-  EXPECT_THROW(
-      fromTimestampString("1970-01-01 00:00:00+00:00:00"), VeloxUserError);
+  EXPECT_EQ(
+      parseTimestampWithTimezone("1970-01-01 00:01:00 UTC"),
+      std::make_pair(Timestamp(60, 0), tz::locateZone("UTC")));
 
-  // Integer overflow during timestamp parsing.
-  EXPECT_THROW(
-      fromTimestampString("2773581570-01-01 00:00:00-asd"), VeloxUserError);
-  EXPECT_THROW(
-      fromTimestampString("-2147483648-01-01 00:00:00-asd"), VeloxUserError);
+  EXPECT_EQ(
+      parseTimestampWithTimezone("1970-01-01 00:00:01 America/Los_Angeles"),
+      std::make_pair(Timestamp(1, 0), tz::locateZone("America/Los_Angeles")));
 }
 
 TEST(DateTimeUtilTest, toGMT) {
-  auto* laZone = date::locate_zone("America/Los_Angeles");
+  auto* laZone = tz::locateZone("America/Los_Angeles");
 
   // The GMT time when LA gets to "1970-01-01 00:00:00" (8h ahead).
-  auto ts = fromTimestampString("1970-01-01 00:00:00");
+  auto ts = parseTimestamp("1970-01-01 00:00:00");
   ts.toGMT(*laZone);
-  EXPECT_EQ(ts, fromTimestampString("1970-01-01 08:00:00"));
+  EXPECT_EQ(ts, parseTimestamp("1970-01-01 08:00:00"));
 
   // Set on a random date/time and try some variations.
-  ts = fromTimestampString("2020-04-23 04:23:37");
+  ts = parseTimestamp("2020-04-23 04:23:37.926");
 
   // To LA:
   auto tsCopy = ts;
   tsCopy.toGMT(*laZone);
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 11:23:37"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 11:23:37.926"));
 
   // To Sao Paulo:
   tsCopy = ts;
-  tsCopy.toGMT(*date::locate_zone("America/Sao_Paulo"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 07:23:37"));
+  tsCopy.toGMT(*tz::locateZone("America/Sao_Paulo"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 07:23:37.926"));
 
   // Moscow:
   tsCopy = ts;
-  tsCopy.toGMT(*date::locate_zone("Europe/Moscow"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 01:23:37"));
+  tsCopy.toGMT(*tz::locateZone("Europe/Moscow"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 01:23:37.926"));
 
   // Probe LA's daylight savings boundary (starts at 2021-13-14 02:00am).
   // Before it starts, 8h offset:
-  ts = fromTimestampString("2021-03-14 00:00:00");
+  ts = parseTimestamp("2021-03-14 00:00:00");
   ts.toGMT(*laZone);
-  EXPECT_EQ(ts, fromTimestampString("2021-03-14 08:00:00"));
+  EXPECT_EQ(ts, parseTimestamp("2021-03-14 08:00:00"));
 
   // After it starts, 7h offset:
-  ts = fromTimestampString("2021-03-14 08:00:00");
+  ts = parseTimestamp("2021-03-14 08:00:00");
   ts.toGMT(*laZone);
-  EXPECT_EQ(ts, fromTimestampString("2021-03-14 15:00:00"));
+  EXPECT_EQ(ts, parseTimestamp("2021-03-14 15:00:00"));
+
+  // Ambiguous time 2019-11-03 01:00:00.
+  // It could be 2019-11-03 01:00:00 PDT == 2019-11-03 08:00:00 UTC
+  // or 2019-11-03 01:00:00 PST == 2019-11-03 09:00:00 UTC.
+  ts = parseTimestamp("2019-11-03 01:00:00");
+  ts.toGMT(*laZone);
+  EXPECT_EQ(ts, parseTimestamp("2019-11-03 08:00:00"));
+
+  // Nonexistent time 2019-03-10 02:00:00.
+  // It is in a gap between 2019-03-10 02:00:00 PST and 2019-03-10 03:00:00 PDT
+  // which are both equivalent to 2019-03-10 10:00:00 UTC.
+  ts = parseTimestamp("2019-03-10 02:00:00");
+  EXPECT_THROW(ts.toGMT(*laZone), VeloxUserError);
 }
 
 TEST(DateTimeUtilTest, toTimezone) {
-  auto* laZone = date::locate_zone("America/Los_Angeles");
+  auto* laZone = tz::locateZone("America/Los_Angeles");
 
   // The LA time when GMT gets to "1970-01-01 00:00:00" (8h behind).
-  auto ts = fromTimestampString("1970-01-01 00:00:00");
+  auto ts = parseTimestamp("1970-01-01 00:00:00");
   ts.toTimezone(*laZone);
-  EXPECT_EQ(ts, fromTimestampString("1969-12-31 16:00:00"));
+  EXPECT_EQ(ts, parseTimestamp("1969-12-31 16:00:00"));
 
   // Set on a random date/time and try some variations.
-  ts = fromTimestampString("2020-04-23 04:23:37");
+  ts = parseTimestamp("2020-04-23 04:23:37");
 
   // To LA:
   auto tsCopy = ts;
   tsCopy.toTimezone(*laZone);
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-22 21:23:37"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-22 21:23:37"));
 
   // To Sao Paulo:
   tsCopy = ts;
-  tsCopy.toTimezone(*date::locate_zone("America/Sao_Paulo"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 01:23:37"));
+  tsCopy.toTimezone(*tz::locateZone("America/Sao_Paulo"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 01:23:37"));
 
   // Moscow:
   tsCopy = ts;
-  tsCopy.toTimezone(*date::locate_zone("Europe/Moscow"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 07:23:37"));
+  tsCopy.toTimezone(*tz::locateZone("Europe/Moscow"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 07:23:37"));
 
   // Probe LA's daylight savings boundary (starts at 2021-13-14 02:00am).
   // Before it starts, 8h offset:
-  ts = fromTimestampString("2021-03-14 00:00:00");
+  ts = parseTimestamp("2021-03-14 00:00:00");
   ts.toTimezone(*laZone);
-  EXPECT_EQ(ts, fromTimestampString("2021-03-13 16:00:00"));
+  EXPECT_EQ(ts, parseTimestamp("2021-03-13 16:00:00"));
 
   // After it starts, 7h offset:
-  ts = fromTimestampString("2021-03-15 00:00:00");
+  ts = parseTimestamp("2021-03-15 00:00:00");
   ts.toTimezone(*laZone);
-  EXPECT_EQ(ts, fromTimestampString("2021-03-14 17:00:00"));
+  EXPECT_EQ(ts, parseTimestamp("2021-03-14 17:00:00"));
 }
 
 TEST(DateTimeUtilTest, toGMTFromID) {
   // The GMT time when LA gets to "1970-01-01 00:00:00" (8h ahead).
-  auto ts = fromTimestampString("1970-01-01 00:00:00");
-  ts.toGMT(util::getTimeZoneID("America/Los_Angeles"));
-  EXPECT_EQ(ts, fromTimestampString("1970-01-01 08:00:00"));
+  auto ts = parseTimestamp("1970-01-01 00:00:00");
+  ts.toGMT(*tz::locateZone("America/Los_Angeles"));
+  EXPECT_EQ(ts, parseTimestamp("1970-01-01 08:00:00"));
 
   // Set on a random date/time and try some variations.
-  ts = fromTimestampString("2020-04-23 04:23:37");
+  ts = parseTimestamp("2020-04-23 04:23:37");
 
   // To LA:
   auto tsCopy = ts;
-  tsCopy.toGMT(util::getTimeZoneID("America/Los_Angeles"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 11:23:37"));
+  tsCopy.toGMT(*tz::locateZone("America/Los_Angeles"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 11:23:37"));
 
   // To Sao Paulo:
   tsCopy = ts;
-  tsCopy.toGMT(util::getTimeZoneID("America/Sao_Paulo"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 07:23:37"));
+  tsCopy.toGMT(*tz::locateZone("America/Sao_Paulo"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 07:23:37"));
 
   // Moscow:
   tsCopy = ts;
-  tsCopy.toGMT(util::getTimeZoneID("Europe/Moscow"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 01:23:37"));
+  tsCopy.toGMT(*tz::locateZone("Europe/Moscow"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 01:23:37"));
 
   // Numerical time zones: +HH:MM and -HH:MM
   tsCopy = ts;
-  tsCopy.toGMT(util::getTimeZoneID("+14:00"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-22 14:23:37"));
+  tsCopy.toGMT(*tz::locateZone("+14:00"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-22 14:23:37"));
 
   tsCopy = ts;
-  tsCopy.toGMT(util::getTimeZoneID("-14:00"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 18:23:37"));
+  tsCopy.toGMT(*tz::locateZone("-14:00"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 18:23:37"));
 
   tsCopy = ts;
-  tsCopy.toGMT(0); // "+00:00" is not in the time zone id map
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 04:23:37"));
+  tsCopy.toGMT(*tz::locateZone("+00:00"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 04:23:37"));
 
   tsCopy = ts;
-  tsCopy.toGMT(util::getTimeZoneID("-00:01"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 04:24:37"));
+  tsCopy.toGMT(*tz::locateZone("-00:01"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 04:24:37"));
 
   tsCopy = ts;
-  tsCopy.toGMT(util::getTimeZoneID("+00:01"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 04:22:37"));
+  tsCopy.toGMT(*tz::locateZone("+00:01"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 04:22:37"));
 
   // Probe LA's daylight savings boundary (starts at 2021-13-14 02:00am).
   // Before it starts, 8h offset:
-  ts = fromTimestampString("2021-03-14 00:00:00");
-  ts.toGMT(util::getTimeZoneID("America/Los_Angeles"));
-  EXPECT_EQ(ts, fromTimestampString("2021-03-14 08:00:00"));
+  ts = parseTimestamp("2021-03-14 00:00:00");
+  ts.toGMT(*tz::locateZone("America/Los_Angeles"));
+  EXPECT_EQ(ts, parseTimestamp("2021-03-14 08:00:00"));
 
   // After it starts, 7h offset:
-  ts = fromTimestampString("2021-03-15 00:00:00");
-  ts.toGMT(util::getTimeZoneID("America/Los_Angeles"));
-  EXPECT_EQ(ts, fromTimestampString("2021-03-15 07:00:00"));
+  ts = parseTimestamp("2021-03-15 00:00:00");
+  ts.toGMT(*tz::locateZone("America/Los_Angeles"));
+  EXPECT_EQ(ts, parseTimestamp("2021-03-15 07:00:00"));
 }
 
 TEST(DateTimeUtilTest, toTimezoneFromID) {
   // The LA time when GMT gets to "1970-01-01 00:00:00" (8h behind).
-  auto ts = fromTimestampString("1970-01-01 00:00:00");
-  ts.toTimezone(util::getTimeZoneID("America/Los_Angeles"));
-  EXPECT_EQ(ts, fromTimestampString("1969-12-31 16:00:00"));
+  auto ts = parseTimestamp("1970-01-01 00:00:00");
+  ts.toTimezone(*tz::locateZone("America/Los_Angeles"));
+  EXPECT_EQ(ts, parseTimestamp("1969-12-31 16:00:00"));
 
   // Set on a random date/time and try some variations.
-  ts = fromTimestampString("2020-04-23 04:23:37");
+  ts = parseTimestamp("2020-04-23 04:23:37");
 
   // To LA:
   auto tsCopy = ts;
-  tsCopy.toTimezone(util::getTimeZoneID("America/Los_Angeles"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-22 21:23:37"));
+  tsCopy.toTimezone(*tz::locateZone("America/Los_Angeles"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-22 21:23:37"));
 
   // To Sao Paulo:
   tsCopy = ts;
-  tsCopy.toTimezone(util::getTimeZoneID("America/Sao_Paulo"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 01:23:37"));
+  tsCopy.toTimezone(*tz::locateZone("America/Sao_Paulo"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 01:23:37"));
 
   // Moscow:
   tsCopy = ts;
-  tsCopy.toTimezone(util::getTimeZoneID("Europe/Moscow"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 07:23:37"));
+  tsCopy.toTimezone(*tz::locateZone("Europe/Moscow"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 07:23:37"));
 
   // Numerical time zones: +HH:MM and -HH:MM
   tsCopy = ts;
-  tsCopy.toTimezone(util::getTimeZoneID("+14:00"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 18:23:37"));
+  tsCopy.toTimezone(*tz::locateZone("+14:00"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 18:23:37"));
 
   tsCopy = ts;
-  tsCopy.toTimezone(util::getTimeZoneID("-14:00"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-22 14:23:37"));
+  tsCopy.toTimezone(*tz::locateZone("-14:00"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-22 14:23:37"));
 
   tsCopy = ts;
-  tsCopy.toTimezone(0); // "+00:00" is not in the time zone id map
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 04:23:37"));
+  tsCopy.toTimezone(*tz::locateZone("+00:00"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 04:23:37"));
 
   tsCopy = ts;
-  tsCopy.toTimezone(util::getTimeZoneID("-00:01"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 04:22:37"));
+  tsCopy.toTimezone(*tz::locateZone("-00:01"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 04:22:37"));
 
   tsCopy = ts;
-  tsCopy.toTimezone(util::getTimeZoneID("+00:01"));
-  EXPECT_EQ(tsCopy, fromTimestampString("2020-04-23 04:24:37"));
+  tsCopy.toTimezone(*tz::locateZone("+00:01"));
+  EXPECT_EQ(tsCopy, parseTimestamp("2020-04-23 04:24:37"));
 
   // Probe LA's daylight savings boundary (starts at 2021-13-14 02:00am).
   // Before it starts, 8h offset:
-  ts = fromTimestampString("2021-03-14 00:00:00");
-  ts.toTimezone(util::getTimeZoneID("America/Los_Angeles"));
-  EXPECT_EQ(ts, fromTimestampString("2021-03-13 16:00:00"));
+  ts = parseTimestamp("2021-03-14 00:00:00");
+  ts.toTimezone(*tz::locateZone("America/Los_Angeles"));
+  EXPECT_EQ(ts, parseTimestamp("2021-03-13 16:00:00"));
 
   // After it starts, 7h offset:
-  ts = fromTimestampString("2021-03-15 00:00:00");
-  ts.toTimezone(util::getTimeZoneID("America/Los_Angeles"));
-  EXPECT_EQ(ts, fromTimestampString("2021-03-14 17:00:00"));
+  ts = parseTimestamp("2021-03-15 00:00:00");
+  ts.toTimezone(*tz::locateZone("America/Los_Angeles"));
+  EXPECT_EQ(ts, parseTimestamp("2021-03-14 17:00:00"));
 }
 
 } // namespace
diff --git a/velox/type/tests/TimestampTest.cpp b/velox/type/tests/TimestampTest.cpp
index 68dfba7423c95..9e344cf999349 100644
--- a/velox/type/tests/TimestampTest.cpp
+++ b/velox/type/tests/TimestampTest.cpp
@@ -18,12 +18,48 @@
 #include <random>
 
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/external/date/tz.h"
 #include "velox/type/Timestamp.h"
+#include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox {
 namespace {
 
+std::string timestampToString(
+    Timestamp ts,
+    const TimestampToStringOptions& options) {
+  std::tm tm;
+  Timestamp::epochToCalendarUtc(ts.getSeconds(), tm);
+  std::string result;
+  result.resize(getMaxStringLength(options));
+  const auto view = Timestamp::tsToStringView(ts, options, result.data());
+  result.resize(view.size());
+  return result;
+}
+
+TEST(TimestampTest, fromDaysAndNanos) {
+  EXPECT_EQ(
+      Timestamp(Timestamp::kSecondsInDay + 2, 1),
+      Timestamp::fromDaysAndNanos(
+          Timestamp::kJulianToUnixEpochDays + 1,
+          2 * Timestamp::kNanosInSecond + 1));
+  EXPECT_EQ(
+      Timestamp(Timestamp::kSecondsInDay + 2, 0),
+      Timestamp::fromDaysAndNanos(
+          Timestamp::kJulianToUnixEpochDays + 1,
+          2 * Timestamp::kNanosInSecond));
+  EXPECT_EQ(
+      Timestamp(
+          Timestamp::kSecondsInDay * 5 - 3, Timestamp::kNanosInSecond - 6),
+      Timestamp::fromDaysAndNanos(
+          Timestamp::kJulianToUnixEpochDays + 5,
+          -2 * Timestamp::kNanosInSecond - 6));
+  EXPECT_EQ(
+      Timestamp(Timestamp::kSecondsInDay * 5 - 2, 0),
+      Timestamp::fromDaysAndNanos(
+          Timestamp::kJulianToUnixEpochDays + 5,
+          -2 * Timestamp::kNanosInSecond));
+}
+
 TEST(TimestampTest, fromMillisAndMicros) {
   int64_t positiveSecond = 10'000;
   int64_t negativeSecond = -10'000;
@@ -116,6 +152,8 @@ TEST(TimestampTest, arithmeticOverflow) {
           "Could not convert Timestamp({}, {}) to nanoseconds",
           negativeSecond,
           0));
+  ASSERT_NO_THROW(Timestamp::minMillis().toMillis());
+  ASSERT_NO_THROW(Timestamp::maxMillis().toMillis());
 }
 
 TEST(TimestampTest, toAppend) {
@@ -202,7 +240,7 @@ TEST(TimestampTest, toStringPrestoCastBehavior) {
   auto kMin = Timestamp(Timestamp::kMinSeconds, 0);
   auto kMax = Timestamp(Timestamp::kMaxSeconds, Timestamp::kMaxNanos);
   TimestampToStringOptions options = {
-      .precision = TimestampToStringOptions::kMilliseconds,
+      .precision = TimestampToStringOptions::Precision::kMilliseconds,
       .zeroPaddingYear = true,
       .dateTimeSeparator = ' ',
   };
@@ -220,6 +258,17 @@ TEST(TimestampTest, toStringPrestoCastBehavior) {
 }
 
 namespace {
+
+uint64_t randomSeed() {
+  if (const char* env = getenv("VELOX_TEST_USE_RANDOM_SEED")) {
+    auto seed = std::random_device{}();
+    LOG(INFO) << "Random seed: " << seed;
+    return seed;
+  } else {
+    return 42;
+  }
+}
+
 std::string toStringAlt(
     const Timestamp& t,
     TimestampToStringOptions::Precision precision) {
@@ -227,7 +276,7 @@ std::string toStringAlt(
   std::tm tmValue;
   VELOX_CHECK_NOT_NULL(gmtime_r((const time_t*)&seconds, &tmValue));
   auto width = static_cast<int>(precision);
-  auto value = precision == TimestampToStringOptions::kMilliseconds
+  auto value = precision == TimestampToStringOptions::Precision::kMilliseconds
       ? t.getNanos() / 1'000'000
       : t.getNanos();
   std::ostringstream oss;
@@ -235,20 +284,39 @@ std::string toStringAlt(
   oss << '.' << std::setfill('0') << std::setw(width) << value;
   return oss.str();
 }
+
+bool checkUtcToEpoch(int year, int mon, int mday, int hour, int min, int sec) {
+  SCOPED_TRACE(fmt::format(
+      "{}-{:02}-{:02} {:02}:{:02}:{:02}", year, mon, mday, hour, min, sec));
+  std::tm tm{};
+  tm.tm_sec = sec;
+  tm.tm_min = min;
+  tm.tm_hour = hour;
+  tm.tm_mday = mday;
+  tm.tm_mon = mon;
+  tm.tm_year = year;
+  errno = 0;
+  auto expected = timegm(&tm);
+  bool error = expected == -1 && errno != 0;
+  auto actual = Timestamp::calendarUtcToEpoch(tm);
+  if (!error) {
+    EXPECT_EQ(actual, expected);
+  }
+  return !error;
+}
+
 } // namespace
 
 TEST(TimestampTest, compareWithToStringAlt) {
-  uint64_t seed = 42;
-  // seed = std::random_device{}();
-  std::default_random_engine gen(seed);
+  std::default_random_engine gen(randomSeed());
   std::uniform_int_distribution<int64_t> distSec(
       Timestamp::kMinSeconds, Timestamp::kMaxSeconds);
   std::uniform_int_distribution<uint64_t> distNano(0, Timestamp::kMaxNanos);
-  for (int i = 0; i < 10000; ++i) {
+  for (int i = 0; i < 10'000; ++i) {
     Timestamp t(distSec(gen), distNano(gen));
     for (auto precision :
-         {TimestampToStringOptions::kMilliseconds,
-          TimestampToStringOptions::kNanoseconds}) {
+         {TimestampToStringOptions::Precision::kMilliseconds,
+          TimestampToStringOptions::Precision::kNanoseconds}) {
       TimestampToStringOptions options{};
       options.precision = precision;
       ASSERT_EQ(t.toString(options), toStringAlt(t, precision))
@@ -257,6 +325,38 @@ TEST(TimestampTest, compareWithToStringAlt) {
   }
 }
 
+TEST(TimestampTest, utcToEpoch) {
+  ASSERT_TRUE(checkUtcToEpoch(1970, 1, 1, 0, 0, 0));
+  ASSERT_TRUE(checkUtcToEpoch(2001, 11, 12, 18, 31, 1));
+  ASSERT_TRUE(checkUtcToEpoch(1969, 12, 31, 23, 59, 59));
+  ASSERT_TRUE(checkUtcToEpoch(1969, 12, 31, 23, 59, 58));
+  ASSERT_TRUE(checkUtcToEpoch(INT32_MAX, 11, 30, 23, 59, 59));
+  ASSERT_TRUE(checkUtcToEpoch(INT32_MIN, 1, 1, 0, 0, 0));
+  ASSERT_TRUE(checkUtcToEpoch(
+      INT32_MAX - INT32_MAX / 11,
+      INT32_MAX,
+      INT32_MAX,
+      INT32_MAX,
+      INT32_MAX,
+      INT32_MAX));
+  ASSERT_TRUE(checkUtcToEpoch(
+      INT32_MIN - INT32_MIN / 11,
+      INT32_MIN,
+      INT32_MIN,
+      INT32_MIN,
+      INT32_MIN,
+      INT32_MIN));
+}
+
+TEST(TimestampTest, utcToEpochRandomInputs) {
+  std::default_random_engine gen(randomSeed());
+  std::uniform_int_distribution<int32_t> dist(INT32_MIN, INT32_MAX);
+  for (int i = 0; i < 10'000; ++i) {
+    checkUtcToEpoch(
+        dist(gen), dist(gen), dist(gen), dist(gen), dist(gen), dist(gen));
+  }
+}
+
 TEST(TimestampTest, increaseOperator) {
   auto ts = Timestamp(0, 999999998);
   EXPECT_EQ("1970-01-01T00:00:00.999999998", ts.toString());
@@ -290,46 +390,224 @@ TEST(TimestampTest, decreaseOperator) {
 }
 
 TEST(TimestampTest, outOfRange) {
-  auto* timezone = date::locate_zone("GMT");
-  Timestamp t(-3217830796800, 0);
-
+  // There are two ranges for timezone conversion.
+  //
+  // #1. external/date cannot handle years larger than 32k (date::year::max()).
+  // Any conversions exceeding that threshold will fail right away.
+  auto* timezone = tz::locateZone("GMT");
+  Timestamp t1(-3217830796800, 0);
+
+  std::string expected = "Timepoint is outside of supported year range";
+  VELOX_ASSERT_THROW(t1.toTimePointMs(), expected);
+  VELOX_ASSERT_THROW(t1.toTimezone(*timezone), expected);
+
+  timezone = tz::locateZone("America/Los_Angeles");
+  VELOX_ASSERT_THROW(t1.toGMT(*timezone), expected);
+
+  // #2. external/date doesn't understand OS_TZDB repetition rules. Therefore,
+  // for timezones with pre-defined repetition rules for daylight savings, for
+  // example, it will throw for anything larger than 2037 (which is what is
+  // currently materialized in OS_TZDBs). America/Los_Angeles is an example of
+  // such timezone.
+  Timestamp t2(32517359891, 0);
   VELOX_ASSERT_THROW(
-      t.toTimePoint(), "Timestamp is outside of supported range");
+      t2.toTimezone(*timezone),
+      "Unable to convert timezone 'America/Los_Angeles' past");
+}
+
+// In debug mode, Timestamp constructor will throw exception if range check
+// fails.
+#ifdef NDEBUG
+TEST(TimestampTest, overflow) {
+  Timestamp t(std::numeric_limits<int64_t>::max(), 0);
   VELOX_ASSERT_THROW(
-      t.toTimezone(*timezone), "Timestamp is outside of supported range");
+      t.toTimePointMs(false),
+      fmt::format(
+          "Could not convert Timestamp({}, {}) to milliseconds",
+          std::numeric_limits<int64_t>::max(),
+          0));
+  ASSERT_NO_THROW(t.toTimePointMs(true));
+}
+#endif
+
+void checkTm(const std::tm& actual, const std::tm& expected) {
+  ASSERT_EQ(expected.tm_year, actual.tm_year);
+  ASSERT_EQ(expected.tm_yday, actual.tm_yday);
+  ASSERT_EQ(expected.tm_mon, actual.tm_mon);
+  ASSERT_EQ(expected.tm_mday, actual.tm_mday);
+  ASSERT_EQ(expected.tm_wday, actual.tm_wday);
+  ASSERT_EQ(expected.tm_hour, actual.tm_hour);
+  ASSERT_EQ(expected.tm_min, actual.tm_min);
+  ASSERT_EQ(expected.tm_sec, actual.tm_sec);
+}
+
+std::string tmToString(
+    const std::tm& tmValue,
+    uint64_t nanos,
+    const std::string& format,
+    const TimestampToStringOptions& options) {
+  auto width = static_cast<int>(options.precision);
+  auto value =
+      options.precision == TimestampToStringOptions::Precision::kMilliseconds
+      ? nanos / 1'000'000
+      : nanos;
+
+  std::ostringstream oss;
+  oss << std::put_time(&tmValue, format.c_str());
+
+  if (options.mode != TimestampToStringOptions::Mode::kDateOnly) {
+    oss << '.' << std::setfill('0') << std::setw(width) << value;
+  }
+
+  return oss.str();
 }
 
 TEST(TimestampTest, epochToUtc) {
-  std::tm tm;
-  ASSERT_FALSE(epochToUtc(-(1ll << 60), tm));
-  ASSERT_FALSE(epochToUtc(1ll << 60, tm));
+  std::tm tm{};
+  ASSERT_FALSE(Timestamp::epochToCalendarUtc(-(1ll << 60), tm));
+  ASSERT_FALSE(Timestamp::epochToCalendarUtc(1ll << 60, tm));
 }
 
 TEST(TimestampTest, randomEpochToUtc) {
   uint64_t seed = 42;
-  // seed = std::random_device{}();
   std::default_random_engine gen(seed);
   std::uniform_int_distribution<time_t> dist(
       std::numeric_limits<time_t>::min(), std::numeric_limits<time_t>::max());
-  std::tm actual, expected;
-  for (int i = 0; i < 10000; ++i) {
+  std::tm actual{};
+  std::tm expected{};
+  for (int i = 0; i < 10'000; ++i) {
     auto epoch = dist(gen);
     SCOPED_TRACE(fmt::format("epoch={}", epoch));
     if (gmtime_r(&epoch, &expected)) {
-      ASSERT_TRUE(epochToUtc(epoch, actual));
-      ASSERT_EQ(expected.tm_year, actual.tm_year);
-      ASSERT_EQ(expected.tm_yday, actual.tm_yday);
-      ASSERT_EQ(expected.tm_mon, actual.tm_mon);
-      ASSERT_EQ(expected.tm_mday, actual.tm_mday);
-      ASSERT_EQ(expected.tm_wday, actual.tm_wday);
-      ASSERT_EQ(expected.tm_hour, actual.tm_hour);
-      ASSERT_EQ(expected.tm_min, actual.tm_min);
-      ASSERT_EQ(expected.tm_sec, actual.tm_sec);
+      ASSERT_TRUE(Timestamp::epochToCalendarUtc(epoch, actual));
+      checkTm(actual, expected);
     } else {
-      ASSERT_FALSE(epochToUtc(epoch, actual));
+      ASSERT_FALSE(Timestamp::epochToCalendarUtc(epoch, actual));
     }
   }
 }
 
+void testTmToString(
+    const std::string& format,
+    const TimestampToStringOptions::Mode mode) {
+  uint64_t seed = 42;
+  std::default_random_engine gen(seed);
+
+  std::uniform_int_distribution<time_t> dist(
+      std::numeric_limits<time_t>::min(), std::numeric_limits<time_t>::max());
+  std::uniform_int_distribution<int> nanosDist(0, Timestamp::kMaxNanos);
+
+  std::tm actual{};
+  std::tm expected{};
+
+  TimestampToStringOptions options;
+  options.mode = mode;
+
+  const std::vector<TimestampToStringOptions::Precision> precisions = {
+      TimestampToStringOptions::Precision::kMilliseconds,
+      TimestampToStringOptions::Precision::kNanoseconds};
+
+  for (auto precision : precisions) {
+    options.precision = precision;
+    for (int i = 0; i < 10'000; ++i) {
+      auto epoch = dist(gen);
+      auto nanos = nanosDist(gen);
+      SCOPED_TRACE(fmt::format(
+          "epoch={}, nanos={}, mode={}, precision={}",
+          epoch,
+          nanos,
+          mode,
+          precision));
+      if (gmtime_r(&epoch, &expected)) {
+        ASSERT_TRUE(Timestamp::epochToCalendarUtc(epoch, actual));
+        checkTm(actual, expected);
+
+        std::string actualString;
+        actualString.resize(getMaxStringLength(options));
+        const auto view = Timestamp::tmToStringView(
+            actual, nanos, options, actualString.data());
+        actualString.resize(view.size());
+        auto expectedString = tmToString(expected, nanos, format, options);
+        ASSERT_EQ(expectedString, actualString);
+      } else {
+        ASSERT_FALSE(Timestamp::epochToCalendarUtc(epoch, actual));
+      }
+    }
+  }
+}
+
+TEST(TimestampTest, tmToStringDateOnly) {
+  // %F - equivalent to "%Y-%m-%d" (the ISO 8601 date format)
+  testTmToString("%F", TimestampToStringOptions::Mode::kDateOnly);
+}
+
+TEST(TimestampTest, tmToStringTimeOnly) {
+  // %T - equivalent to "%H:%M:%S" (the ISO 8601 time format)
+  testTmToString("%T", TimestampToStringOptions::Mode::kTimeOnly);
+}
+
+TEST(TimestampTest, tmToStringTimestamp) {
+  // %FT%T - equivalent to "%Y-%m-%dT%H:%M:%S" (the ISO 8601 timestamp format)
+  testTmToString("%FT%T", TimestampToStringOptions::Mode::kFull);
+}
+
+TEST(TimestampTest, leadingPositiveSign) {
+  TimestampToStringOptions options = {
+      .leadingPositiveSign = true,
+      .zeroPaddingYear = true,
+      .dateTimeSeparator = ' ',
+  };
+
+  ASSERT_EQ(
+      timestampToString(Timestamp(253402231016, 0), options),
+      "9999-12-31 04:36:56.000000000");
+  ASSERT_EQ(
+      timestampToString(Timestamp(253405036800, 0), options),
+      "+10000-02-01 16:00:00.000000000");
+}
+
+TEST(TimestampTest, skipTrailingZeros) {
+  TimestampToStringOptions options = {
+      .precision = TimestampToStringOptions::Precision::kMicroseconds,
+      .skipTrailingZeros = true,
+      .zeroPaddingYear = true,
+      .dateTimeSeparator = ' ',
+  };
+
+  ASSERT_EQ(
+      timestampToString(Timestamp(-946684800, 0), options),
+      "1940-01-02 00:00:00");
+  ASSERT_EQ(timestampToString(Timestamp(0, 0), options), "1970-01-01 00:00:00");
+  ASSERT_EQ(
+      timestampToString(Timestamp(0, 365), options), "1970-01-01 00:00:00");
+  ASSERT_EQ(
+      timestampToString(Timestamp(0, 65873), options),
+      "1970-01-01 00:00:00.000065");
+  ASSERT_EQ(
+      timestampToString(Timestamp(94668480000, 0), options),
+      "4969-12-04 00:00:00");
+  ASSERT_EQ(
+      timestampToString(Timestamp(946729316, 129999999), options),
+      "2000-01-01 12:21:56.129999");
+  ASSERT_EQ(
+      timestampToString(Timestamp(946729316, 129990000), options),
+      "2000-01-01 12:21:56.12999");
+  ASSERT_EQ(
+      timestampToString(Timestamp(946729316, 129900000), options),
+      "2000-01-01 12:21:56.1299");
+  ASSERT_EQ(
+      timestampToString(Timestamp(946729316, 129000000), options),
+      "2000-01-01 12:21:56.129");
+  ASSERT_EQ(
+      timestampToString(Timestamp(946729316, 129010000), options),
+      "2000-01-01 12:21:56.12901");
+  ASSERT_EQ(
+      timestampToString(Timestamp(946729316, 129001000), options),
+      "2000-01-01 12:21:56.129001");
+  ASSERT_EQ(
+      timestampToString(Timestamp(-50049331200, 726600000), options),
+      "0384-01-01 08:00:00.7266");
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/type/tests/TypeTest.cpp b/velox/type/tests/TypeTest.cpp
index 534c021c6c2ec..1bf8d6d384e5a 100644
--- a/velox/type/tests/TypeTest.cpp
+++ b/velox/type/tests/TypeTest.cpp
@@ -16,6 +16,9 @@
 #include "velox/type/Type.h"
 #include <sstream>
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/CppToType.h"
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/tests/utils/CustomTypesForTesting.h"
 
 using namespace facebook;
 using namespace facebook::velox;
@@ -32,6 +35,28 @@ void testTypeSerde(const TypePtr& type) {
 }
 } // namespace
 
+TEST(TypeTest, constructorThrow) {
+  EXPECT_NO_THROW(RowType({"a", "b"}, {VARCHAR(), INTEGER()}));
+
+  EXPECT_THROW(RowType({"a"}, {VARCHAR(), INTEGER()}), VeloxRuntimeError);
+  VELOX_ASSERT_THROW(
+      RowType({"a"}, {VARCHAR(), INTEGER()}),
+      "Mismatch names/types sizes: "
+      "[names: {'a'}, types: {VARCHAR, INTEGER}]");
+
+  EXPECT_THROW(RowType({"a", "b"}, {}), VeloxRuntimeError);
+  VELOX_ASSERT_THROW(
+      RowType({"a", "b"}, {}),
+      "Mismatch names/types sizes: "
+      "[names: {'a', 'b'}, types: { }]");
+
+  EXPECT_THROW(RowType({"a", "b"}, {VARCHAR(), nullptr}), VeloxRuntimeError);
+  VELOX_ASSERT_THROW(
+      RowType({"a", "b"}, {VARCHAR(), nullptr}),
+      "Child types cannot be null: "
+      "[names: {'a', 'b'}, types: {VARCHAR, NULL}]");
+}
+
 TEST(TypeTest, array) {
   auto arrayType = ARRAY(ARRAY(ARRAY(INTEGER())));
   EXPECT_EQ("ARRAY<ARRAY<ARRAY<INTEGER>>>", arrayType->toString());
@@ -184,9 +209,28 @@ TEST(TypeTest, intervalYearMonth) {
   month = kMonthInYear * -2 + -1;
   EXPECT_EQ("-2-1", INTERVAL_YEAR_MONTH()->valueToString(month));
 
+  EXPECT_EQ(
+      "-178956970-8",
+      INTERVAL_YEAR_MONTH()->valueToString(
+          std::numeric_limits<int32_t>::min()));
+
   testTypeSerde(interval);
 }
 
+TEST(TypeTest, unknown) {
+  auto type = UNKNOWN();
+  EXPECT_EQ(type->toString(), "UNKNOWN");
+  EXPECT_EQ(type->size(), 0);
+  EXPECT_THROW(type->childAt(0), std::invalid_argument);
+  EXPECT_EQ(type->kind(), TypeKind::UNKNOWN);
+  EXPECT_STREQ(type->kindName(), "UNKNOWN");
+  EXPECT_EQ(type->begin(), type->end());
+  EXPECT_TRUE(type->isComparable());
+  EXPECT_TRUE(type->isOrderable());
+
+  testTypeSerde(type);
+}
+
 TEST(TypeTest, shortDecimal) {
   auto shortDecimal = DECIMAL(10, 5);
   EXPECT_EQ(shortDecimal->toString(), "DECIMAL(10, 5)");
@@ -199,6 +243,9 @@ TEST(TypeTest, shortDecimal) {
   EXPECT_NE(*DECIMAL(9, 5), *shortDecimal);
   EXPECT_NE(*DECIMAL(10, 4), *shortDecimal);
 
+  VELOX_ASSERT_THROW(
+      DECIMAL(0, 0), "Precision of decimal type must be at least 1");
+
   EXPECT_STREQ(shortDecimal->name(), "DECIMAL");
   EXPECT_EQ(shortDecimal->parameters().size(), 2);
   EXPECT_TRUE(
@@ -429,6 +476,33 @@ TEST(TypeTest, emptyRow) {
   testTypeSerde(row);
 }
 
+TEST(TypeTest, rowParametersMultiThreaded) {
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  for (int i = 0; i < 20'000; ++i) {
+    auto name = fmt::format("c{}", i);
+    names.push_back(name);
+    types.push_back(ROW({name}, {BIGINT()}));
+  }
+  auto type = ROW(std::move(names), std::move(types));
+  constexpr int kNumThreads = 72;
+  const std::vector<TypeParameter>* parameters[kNumThreads];
+  std::vector<std::thread> threads;
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&, i] { parameters[i] = &type->parameters(); });
+  }
+  for (auto& thread : threads) {
+    thread.join();
+  }
+  for (int i = 1; i < kNumThreads; ++i) {
+    ASSERT_TRUE(parameters[i] == parameters[0]);
+  }
+  ASSERT_EQ(parameters[0]->size(), type->size());
+  for (int i = 0; i < parameters[0]->size(); ++i) {
+    ASSERT_TRUE((*parameters[0])[i].type.get() == type->childAt(i).get());
+  }
+}
+
 class Foo {};
 class Bar {};
 
@@ -586,11 +660,16 @@ TEST(TypeTest, equality) {
   EXPECT_FALSE(
       *ROW({{"a", INTEGER()}, {"b", REAL()}}) ==
       *ROW({{"a", INTEGER()}, {"d", REAL()}}));
+  EXPECT_FALSE(
+      *ROW({{"a", ROW({{"x", INTEGER()}, {"y", INTEGER()}})}}) ==
+      *ROW({{"a", ROW({{"x", INTEGER()}, {"z", INTEGER()}})}}));
+  EXPECT_FALSE(
+      *ROW({{"a", ROW({{"x", INTEGER()}, {"y", INTEGER()}})}}) ==
+      *ARRAY(INTEGER()));
 
   // mix
   EXPECT_FALSE(MAP(REAL(), INTEGER())
-                   ->
-                   operator==(*ROW({{"a", REAL()}, {"b", INTEGER()}})));
+                   ->operator==(*ROW({{"a", REAL()}, {"b", INTEGER()}})));
   EXPECT_FALSE(ARRAY(REAL())->operator==(*ROW({{"a", REAL()}})));
 }
 
@@ -615,6 +694,7 @@ TEST(TypeTest, cpp2Type) {
 TEST(TypeTest, equivalent) {
   EXPECT_TRUE(ROW({{"a", BIGINT()}})->equivalent(*ROW({{"b", BIGINT()}})));
   EXPECT_FALSE(ROW({{"a", BIGINT()}})->equivalent(*ROW({{"a", INTEGER()}})));
+  EXPECT_TRUE(ROW({{"a", BIGINT()}})->equivalent(*ROW({{"b", BIGINT()}})));
   EXPECT_TRUE(MAP(BIGINT(), BIGINT())->equivalent(*MAP(BIGINT(), BIGINT())));
   EXPECT_FALSE(
       MAP(BIGINT(), BIGINT())->equivalent(*MAP(BIGINT(), ARRAY(BIGINT()))));
@@ -755,7 +835,7 @@ TEST(TypeTest, follySformat) {
           "{}", ROW({{"a", BOOLEAN()}, {"b", VARCHAR()}, {"c", BIGINT()}})));
 }
 
-TEST(TypeTest, unknown) {
+TEST(TypeTest, unknownArray) {
   auto unknownArray = ARRAY(UNKNOWN());
   EXPECT_TRUE(unknownArray->containsUnknown());
 
@@ -772,36 +852,6 @@ TEST(TypeTest, isVariadicType) {
   EXPECT_FALSE((isVariadicType<Map<int8_t, Date>>::value));
 }
 
-TEST(TypeTest, fromKindToScalerType) {
-  for (const TypeKind& kind :
-       {TypeKind::BOOLEAN,
-        TypeKind::TINYINT,
-        TypeKind::SMALLINT,
-        TypeKind::INTEGER,
-        TypeKind::BIGINT,
-        TypeKind::REAL,
-        TypeKind::DOUBLE,
-        TypeKind::VARCHAR,
-        TypeKind::VARBINARY,
-        TypeKind::TIMESTAMP,
-        TypeKind::UNKNOWN}) {
-    SCOPED_TRACE(mapTypeKindToName(kind));
-    auto type = fromKindToScalerType(kind);
-    ASSERT_EQ(type->kind(), kind);
-  }
-
-  for (const TypeKind& kind :
-       {TypeKind::ARRAY,
-        TypeKind::MAP,
-        TypeKind::ROW,
-        TypeKind::OPAQUE,
-        TypeKind::FUNCTION,
-        TypeKind::INVALID}) {
-    SCOPED_TRACE(mapTypeKindToName(kind));
-    EXPECT_ANY_THROW(fromKindToScalerType(kind));
-  }
-}
-
 TEST(TypeTest, rowEquvialentCheckWithChildRowsWithDifferentNames) {
   std::vector<TypePtr> types;
   std::vector<TypePtr> typesWithDifferentNames;
@@ -941,3 +991,54 @@ TEST(TypeTest, functionTypeEquivalent) {
 
   EXPECT_TRUE(functionType->equivalent(*otherFunctionType));
 }
+
+TEST(TypeTest, providesCustomComparison) {
+  // None of the builtin types provide custom comparison.
+  EXPECT_FALSE(BOOLEAN()->providesCustomComparison());
+  EXPECT_FALSE(TINYINT()->providesCustomComparison());
+  EXPECT_FALSE(SMALLINT()->providesCustomComparison());
+  EXPECT_FALSE(INTEGER()->providesCustomComparison());
+  EXPECT_FALSE(BIGINT()->providesCustomComparison());
+  EXPECT_FALSE(HUGEINT()->providesCustomComparison());
+  EXPECT_FALSE(REAL()->providesCustomComparison());
+  EXPECT_FALSE(DOUBLE()->providesCustomComparison());
+  EXPECT_FALSE(VARCHAR()->providesCustomComparison());
+  EXPECT_FALSE(VARBINARY()->providesCustomComparison());
+  EXPECT_FALSE(TIMESTAMP()->providesCustomComparison());
+  EXPECT_FALSE(DATE()->providesCustomComparison());
+  EXPECT_FALSE(ARRAY(INTEGER())->providesCustomComparison());
+  EXPECT_FALSE(MAP(INTEGER(), INTEGER())->providesCustomComparison());
+  EXPECT_FALSE(ROW({INTEGER()})->providesCustomComparison());
+  EXPECT_FALSE(DECIMAL(10, 5)->providesCustomComparison());
+  EXPECT_FALSE(UNKNOWN()->providesCustomComparison());
+  EXPECT_FALSE(INTERVAL_YEAR_MONTH()->providesCustomComparison());
+  EXPECT_FALSE(INTERVAL_DAY_TIME()->providesCustomComparison());
+  EXPECT_FALSE(FUNCTION({INTEGER()}, INTEGER())->providesCustomComparison());
+
+  // This custom type does provide custom comparison.
+  EXPECT_TRUE(
+      test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON()->providesCustomComparison());
+  EXPECT_EQ(0, test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON()->compare(0, 0));
+  EXPECT_EQ(
+      8633297058295171728, test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON()->hash(0));
+
+  // BIGINT does not provide custom comparison so calling compare or hash on it
+  // should fail.
+  EXPECT_THROW(BIGINT()->compare(0, 0), VeloxRuntimeError);
+  EXPECT_THROW(BIGINT()->hash(0), VeloxRuntimeError);
+
+  // This type claims it providesCustomComparison but does not implement the
+  // compare and hash functions so invoking them should still fail.
+  EXPECT_TRUE(test::BIGINT_TYPE_WITH_INVALID_CUSTOM_COMPARISON()
+                  ->providesCustomComparison());
+  EXPECT_THROW(
+      test::BIGINT_TYPE_WITH_INVALID_CUSTOM_COMPARISON()->compare(0, 0),
+      VeloxRuntimeError);
+  EXPECT_THROW(
+      test::BIGINT_TYPE_WITH_INVALID_CUSTOM_COMPARISON()->hash(0),
+      VeloxRuntimeError);
+
+  // We do not support variable width custom comparison for variable width
+  // types, so attempting to instantiate one should fail.
+  EXPECT_THROW(test::VARCHAR_TYPE_WITH_CUSTOM_COMPARISON(), VeloxRuntimeError);
+}
diff --git a/velox/type/tests/VariantTest.cpp b/velox/type/tests/VariantTest.cpp
index 9b58d0fc4678d..9882c76cb4a7b 100644
--- a/velox/type/tests/VariantTest.cpp
+++ b/velox/type/tests/VariantTest.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/type/Variant.h"
 #include <gtest/gtest.h>
-#include <velox/type/Type.h>
 #include <numeric>
 #include "velox/common/base/tests/GTestUtils.h"
 
@@ -198,6 +197,33 @@ TEST(VariantTest, equalsWithEpsilonFloat) {
   ASSERT_FALSE(variant(sum1).equalsWithEpsilon(variant(sum3)));
 }
 
+TEST(VariantTest, mapWithNaNKey) {
+  // Verify that map variants treat all NaN keys as equivalent and comparable
+  // (consider them the largest) with other values.
+  static const double KNan = std::numeric_limits<double>::quiet_NaN();
+  auto mapType = MAP(DOUBLE(), INTEGER());
+  {
+    // NaN added at the start of insertions.
+    std::map<variant, variant> mapVariant;
+    mapVariant.insert({variant(KNan), variant(1)});
+    mapVariant.insert({variant(1.2), variant(2)});
+    mapVariant.insert({variant(12.4), variant(3)});
+    EXPECT_EQ(
+        "[{\"key\":1.2,\"value\":2},{\"key\":12.4,\"value\":3},{\"key\":\"NaN\",\"value\":1}]",
+        variant::map(mapVariant).toJson(mapType));
+  }
+  {
+    // NaN added in the middle of insertions.
+    std::map<variant, variant> mapVariant;
+    mapVariant.insert({variant(1.2), variant(2)});
+    mapVariant.insert({variant(KNan), variant(1)});
+    mapVariant.insert({variant(12.4), variant(3)});
+    EXPECT_EQ(
+        "[{\"key\":1.2,\"value\":2},{\"key\":12.4,\"value\":3},{\"key\":\"NaN\",\"value\":1}]",
+        variant::map(mapVariant).toJson(mapType));
+  }
+}
+
 TEST(VariantTest, serialize) {
   // Null values.
   testSerDe(variant(TypeKind::BOOLEAN));
diff --git a/velox/type/tests/utils/CMakeLists.txt b/velox/type/tests/utils/CMakeLists.txt
new file mode 100644
index 0000000000000..54a2bced108f2
--- /dev/null
+++ b/velox/type/tests/utils/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+add_library(velox_type_test_lib INTERFACE)
+
+target_link_libraries(
+  velox_type_test_lib
+  INTERFACE velox_type)
diff --git a/velox/type/tests/utils/CustomTypesForTesting.h b/velox/type/tests/utils/CustomTypesForTesting.h
new file mode 100644
index 0000000000000..ed46f8a219e22
--- /dev/null
+++ b/velox/type/tests/utils/CustomTypesForTesting.h
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/type/Type.h"
+
+namespace facebook::velox::test {
+// A custom type that provides custom comparison and hash functions.
+class BigintTypeWithCustomComparison : public BigintType {
+  BigintTypeWithCustomComparison() : BigintType(true) {}
+
+ public:
+  static const std::shared_ptr<const BigintTypeWithCustomComparison>& get() {
+    static const std::shared_ptr<const BigintTypeWithCustomComparison>
+        instance = std::shared_ptr<BigintTypeWithCustomComparison>(
+            new BigintTypeWithCustomComparison());
+
+    return instance;
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  // For the purposes of testing, this type only compares the bottom 8 bits of
+  // values.
+  int32_t compare(const int64_t& left, const int64_t& right) const override {
+    int64_t leftTruncated = left & 0xff;
+    int64_t rightTruncated = right & 0xff;
+
+    return leftTruncated < rightTruncated ? -1
+        : leftTruncated == rightTruncated ? 0
+                                          : 1;
+  }
+
+  uint64_t hash(const int64_t& value) const override {
+    return folly::hasher<int64_t>()(value & 0xff);
+  }
+
+  const char* name() const override {
+    return "BIGINT TYPE WITH CUSTOM COMPARISON";
+  }
+
+  const std::vector<TypeParameter>& parameters() const override {
+    static const std::vector<TypeParameter> kEmpty = {};
+    return kEmpty;
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "Type";
+    obj["type"] = name();
+    return obj;
+  }
+};
+
+inline std::shared_ptr<const BigintTypeWithCustomComparison>
+BIGINT_TYPE_WITH_CUSTOM_COMPARISON() {
+  return BigintTypeWithCustomComparison::get();
+}
+
+// A custom type that declares it providesCustomComparison but does not
+// implement the compare or hash functions. This is not supported.
+class BigintTypeWithInvalidCustomComparison : public BigintType {
+  BigintTypeWithInvalidCustomComparison() : BigintType(true) {}
+
+ public:
+  static const std::shared_ptr<const BigintTypeWithInvalidCustomComparison>&
+  get() {
+    static const std::shared_ptr<const BigintTypeWithInvalidCustomComparison>
+        instance = std::shared_ptr<BigintTypeWithInvalidCustomComparison>(
+            new BigintTypeWithInvalidCustomComparison());
+
+    return instance;
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  const char* name() const override {
+    return "BIGINT TYPE WITH INVALID CUSTOM COMPARISON";
+  }
+
+  const std::vector<TypeParameter>& parameters() const override {
+    static const std::vector<TypeParameter> kEmpty = {};
+    return kEmpty;
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "Type";
+    obj["type"] = name();
+    return obj;
+  }
+};
+
+inline std::shared_ptr<const BigintTypeWithInvalidCustomComparison>
+BIGINT_TYPE_WITH_INVALID_CUSTOM_COMPARISON() {
+  return BigintTypeWithInvalidCustomComparison::get();
+}
+
+// A custom type that is not fixed width that provides custom comparison and
+// hash functions. This is not currently supported.
+class VarcharTypeWithCustomComparison : public VarcharType {
+  VarcharTypeWithCustomComparison() : VarcharType(true) {}
+
+ public:
+  static const std::shared_ptr<const VarcharTypeWithCustomComparison>& get() {
+    static const std::shared_ptr<const VarcharTypeWithCustomComparison>
+        instance = std::shared_ptr<VarcharTypeWithCustomComparison>(
+            new VarcharTypeWithCustomComparison());
+
+    return instance;
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  // For the purposes of testing, this type only compares the bottom 8 bits of
+  // values.
+  int32_t compare(const StringView& left, const StringView& right)
+      const override {
+    return left.compare(right);
+  }
+
+  uint64_t hash(const StringView& value) const override {
+    return folly::hasher<StringView>()(value);
+  }
+
+  const char* name() const override {
+    return "VARCHAR TYPE WITH CUSTOM COMPARISON";
+  }
+
+  const std::vector<TypeParameter>& parameters() const override {
+    static const std::vector<TypeParameter> kEmpty = {};
+    return kEmpty;
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "Type";
+    obj["type"] = name();
+    return obj;
+  }
+};
+
+inline std::shared_ptr<const VarcharTypeWithCustomComparison>
+VARCHAR_TYPE_WITH_CUSTOM_COMPARISON() {
+  return VarcharTypeWithCustomComparison::get();
+}
+} // namespace facebook::velox::test
diff --git a/velox/type/tz/CMakeLists.txt b/velox/type/tz/CMakeLists.txt
index af1a05d888d56..b7d96feb12626 100644
--- a/velox/type/tz/CMakeLists.txt
+++ b/velox/type/tz/CMakeLists.txt
@@ -14,6 +14,13 @@
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
-add_library(velox_type_tz TimeZoneMap.h TimeZoneDatabase.cpp TimeZoneMap.cpp)
+velox_add_library(velox_type_tz TimeZoneMap.h TimeZoneDatabase.cpp
+                  TimeZoneMap.cpp)
 
-target_link_libraries(velox_type_tz Boost::regex fmt::fmt Folly::folly)
+velox_link_libraries(
+  velox_type_tz
+  velox_exception
+  velox_external_date
+  Boost::regex
+  fmt::fmt
+  Folly::folly)
diff --git a/velox/type/tz/TimeZoneDatabase.cpp b/velox/type/tz/TimeZoneDatabase.cpp
index 9687e4d2002eb..8a6b47cb1e244 100644
--- a/velox/type/tz/TimeZoneDatabase.cpp
+++ b/velox/type/tz/TimeZoneDatabase.cpp
@@ -26,2242 +26,2248 @@
 
 #include <string>
 #include <unordered_map>
+#include <vector>
 
-namespace facebook::velox::util {
+namespace facebook::velox::tz {
 
-const std::unordered_map<int64_t, std::string>& getTimeZoneDB() {
-  static std::unordered_map<int64_t, std::string> tzDB = {
-      {0, "+00:00"},
-      {1, "-14:00"},
-      {2, "-13:59"},
-      {3, "-13:58"},
-      {4, "-13:57"},
-      {5, "-13:56"},
-      {6, "-13:55"},
-      {7, "-13:54"},
-      {8, "-13:53"},
-      {9, "-13:52"},
-      {10, "-13:51"},
-      {11, "-13:50"},
-      {12, "-13:49"},
-      {13, "-13:48"},
-      {14, "-13:47"},
-      {15, "-13:46"},
-      {16, "-13:45"},
-      {17, "-13:44"},
-      {18, "-13:43"},
-      {19, "-13:42"},
-      {20, "-13:41"},
-      {21, "-13:40"},
-      {22, "-13:39"},
-      {23, "-13:38"},
-      {24, "-13:37"},
-      {25, "-13:36"},
-      {26, "-13:35"},
-      {27, "-13:34"},
-      {28, "-13:33"},
-      {29, "-13:32"},
-      {30, "-13:31"},
-      {31, "-13:30"},
-      {32, "-13:29"},
-      {33, "-13:28"},
-      {34, "-13:27"},
-      {35, "-13:26"},
-      {36, "-13:25"},
-      {37, "-13:24"},
-      {38, "-13:23"},
-      {39, "-13:22"},
-      {40, "-13:21"},
-      {41, "-13:20"},
-      {42, "-13:19"},
-      {43, "-13:18"},
-      {44, "-13:17"},
-      {45, "-13:16"},
-      {46, "-13:15"},
-      {47, "-13:14"},
-      {48, "-13:13"},
-      {49, "-13:12"},
-      {50, "-13:11"},
-      {51, "-13:10"},
-      {52, "-13:09"},
-      {53, "-13:08"},
-      {54, "-13:07"},
-      {55, "-13:06"},
-      {56, "-13:05"},
-      {57, "-13:04"},
-      {58, "-13:03"},
-      {59, "-13:02"},
-      {60, "-13:01"},
-      {61, "-13:00"},
-      {62, "-12:59"},
-      {63, "-12:58"},
-      {64, "-12:57"},
-      {65, "-12:56"},
-      {66, "-12:55"},
-      {67, "-12:54"},
-      {68, "-12:53"},
-      {69, "-12:52"},
-      {70, "-12:51"},
-      {71, "-12:50"},
-      {72, "-12:49"},
-      {73, "-12:48"},
-      {74, "-12:47"},
-      {75, "-12:46"},
-      {76, "-12:45"},
-      {77, "-12:44"},
-      {78, "-12:43"},
-      {79, "-12:42"},
-      {80, "-12:41"},
-      {81, "-12:40"},
-      {82, "-12:39"},
-      {83, "-12:38"},
-      {84, "-12:37"},
-      {85, "-12:36"},
-      {86, "-12:35"},
-      {87, "-12:34"},
-      {88, "-12:33"},
-      {89, "-12:32"},
-      {90, "-12:31"},
-      {91, "-12:30"},
-      {92, "-12:29"},
-      {93, "-12:28"},
-      {94, "-12:27"},
-      {95, "-12:26"},
-      {96, "-12:25"},
-      {97, "-12:24"},
-      {98, "-12:23"},
-      {99, "-12:22"},
-      {100, "-12:21"},
-      {101, "-12:20"},
-      {102, "-12:19"},
-      {103, "-12:18"},
-      {104, "-12:17"},
-      {105, "-12:16"},
-      {106, "-12:15"},
-      {107, "-12:14"},
-      {108, "-12:13"},
-      {109, "-12:12"},
-      {110, "-12:11"},
-      {111, "-12:10"},
-      {112, "-12:09"},
-      {113, "-12:08"},
-      {114, "-12:07"},
-      {115, "-12:06"},
-      {116, "-12:05"},
-      {117, "-12:04"},
-      {118, "-12:03"},
-      {119, "-12:02"},
-      {120, "-12:01"},
-      {121, "-12:00"},
-      {122, "-11:59"},
-      {123, "-11:58"},
-      {124, "-11:57"},
-      {125, "-11:56"},
-      {126, "-11:55"},
-      {127, "-11:54"},
-      {128, "-11:53"},
-      {129, "-11:52"},
-      {130, "-11:51"},
-      {131, "-11:50"},
-      {132, "-11:49"},
-      {133, "-11:48"},
-      {134, "-11:47"},
-      {135, "-11:46"},
-      {136, "-11:45"},
-      {137, "-11:44"},
-      {138, "-11:43"},
-      {139, "-11:42"},
-      {140, "-11:41"},
-      {141, "-11:40"},
-      {142, "-11:39"},
-      {143, "-11:38"},
-      {144, "-11:37"},
-      {145, "-11:36"},
-      {146, "-11:35"},
-      {147, "-11:34"},
-      {148, "-11:33"},
-      {149, "-11:32"},
-      {150, "-11:31"},
-      {151, "-11:30"},
-      {152, "-11:29"},
-      {153, "-11:28"},
-      {154, "-11:27"},
-      {155, "-11:26"},
-      {156, "-11:25"},
-      {157, "-11:24"},
-      {158, "-11:23"},
-      {159, "-11:22"},
-      {160, "-11:21"},
-      {161, "-11:20"},
-      {162, "-11:19"},
-      {163, "-11:18"},
-      {164, "-11:17"},
-      {165, "-11:16"},
-      {166, "-11:15"},
-      {167, "-11:14"},
-      {168, "-11:13"},
-      {169, "-11:12"},
-      {170, "-11:11"},
-      {171, "-11:10"},
-      {172, "-11:09"},
-      {173, "-11:08"},
-      {174, "-11:07"},
-      {175, "-11:06"},
-      {176, "-11:05"},
-      {177, "-11:04"},
-      {178, "-11:03"},
-      {179, "-11:02"},
-      {180, "-11:01"},
-      {181, "-11:00"},
-      {182, "-10:59"},
-      {183, "-10:58"},
-      {184, "-10:57"},
-      {185, "-10:56"},
-      {186, "-10:55"},
-      {187, "-10:54"},
-      {188, "-10:53"},
-      {189, "-10:52"},
-      {190, "-10:51"},
-      {191, "-10:50"},
-      {192, "-10:49"},
-      {193, "-10:48"},
-      {194, "-10:47"},
-      {195, "-10:46"},
-      {196, "-10:45"},
-      {197, "-10:44"},
-      {198, "-10:43"},
-      {199, "-10:42"},
-      {200, "-10:41"},
-      {201, "-10:40"},
-      {202, "-10:39"},
-      {203, "-10:38"},
-      {204, "-10:37"},
-      {205, "-10:36"},
-      {206, "-10:35"},
-      {207, "-10:34"},
-      {208, "-10:33"},
-      {209, "-10:32"},
-      {210, "-10:31"},
-      {211, "-10:30"},
-      {212, "-10:29"},
-      {213, "-10:28"},
-      {214, "-10:27"},
-      {215, "-10:26"},
-      {216, "-10:25"},
-      {217, "-10:24"},
-      {218, "-10:23"},
-      {219, "-10:22"},
-      {220, "-10:21"},
-      {221, "-10:20"},
-      {222, "-10:19"},
-      {223, "-10:18"},
-      {224, "-10:17"},
-      {225, "-10:16"},
-      {226, "-10:15"},
-      {227, "-10:14"},
-      {228, "-10:13"},
-      {229, "-10:12"},
-      {230, "-10:11"},
-      {231, "-10:10"},
-      {232, "-10:09"},
-      {233, "-10:08"},
-      {234, "-10:07"},
-      {235, "-10:06"},
-      {236, "-10:05"},
-      {237, "-10:04"},
-      {238, "-10:03"},
-      {239, "-10:02"},
-      {240, "-10:01"},
-      {241, "-10:00"},
-      {242, "-09:59"},
-      {243, "-09:58"},
-      {244, "-09:57"},
-      {245, "-09:56"},
-      {246, "-09:55"},
-      {247, "-09:54"},
-      {248, "-09:53"},
-      {249, "-09:52"},
-      {250, "-09:51"},
-      {251, "-09:50"},
-      {252, "-09:49"},
-      {253, "-09:48"},
-      {254, "-09:47"},
-      {255, "-09:46"},
-      {256, "-09:45"},
-      {257, "-09:44"},
-      {258, "-09:43"},
-      {259, "-09:42"},
-      {260, "-09:41"},
-      {261, "-09:40"},
-      {262, "-09:39"},
-      {263, "-09:38"},
-      {264, "-09:37"},
-      {265, "-09:36"},
-      {266, "-09:35"},
-      {267, "-09:34"},
-      {268, "-09:33"},
-      {269, "-09:32"},
-      {270, "-09:31"},
-      {271, "-09:30"},
-      {272, "-09:29"},
-      {273, "-09:28"},
-      {274, "-09:27"},
-      {275, "-09:26"},
-      {276, "-09:25"},
-      {277, "-09:24"},
-      {278, "-09:23"},
-      {279, "-09:22"},
-      {280, "-09:21"},
-      {281, "-09:20"},
-      {282, "-09:19"},
-      {283, "-09:18"},
-      {284, "-09:17"},
-      {285, "-09:16"},
-      {286, "-09:15"},
-      {287, "-09:14"},
-      {288, "-09:13"},
-      {289, "-09:12"},
-      {290, "-09:11"},
-      {291, "-09:10"},
-      {292, "-09:09"},
-      {293, "-09:08"},
-      {294, "-09:07"},
-      {295, "-09:06"},
-      {296, "-09:05"},
-      {297, "-09:04"},
-      {298, "-09:03"},
-      {299, "-09:02"},
-      {300, "-09:01"},
-      {301, "-09:00"},
-      {302, "-08:59"},
-      {303, "-08:58"},
-      {304, "-08:57"},
-      {305, "-08:56"},
-      {306, "-08:55"},
-      {307, "-08:54"},
-      {308, "-08:53"},
-      {309, "-08:52"},
-      {310, "-08:51"},
-      {311, "-08:50"},
-      {312, "-08:49"},
-      {313, "-08:48"},
-      {314, "-08:47"},
-      {315, "-08:46"},
-      {316, "-08:45"},
-      {317, "-08:44"},
-      {318, "-08:43"},
-      {319, "-08:42"},
-      {320, "-08:41"},
-      {321, "-08:40"},
-      {322, "-08:39"},
-      {323, "-08:38"},
-      {324, "-08:37"},
-      {325, "-08:36"},
-      {326, "-08:35"},
-      {327, "-08:34"},
-      {328, "-08:33"},
-      {329, "-08:32"},
-      {330, "-08:31"},
-      {331, "-08:30"},
-      {332, "-08:29"},
-      {333, "-08:28"},
-      {334, "-08:27"},
-      {335, "-08:26"},
-      {336, "-08:25"},
-      {337, "-08:24"},
-      {338, "-08:23"},
-      {339, "-08:22"},
-      {340, "-08:21"},
-      {341, "-08:20"},
-      {342, "-08:19"},
-      {343, "-08:18"},
-      {344, "-08:17"},
-      {345, "-08:16"},
-      {346, "-08:15"},
-      {347, "-08:14"},
-      {348, "-08:13"},
-      {349, "-08:12"},
-      {350, "-08:11"},
-      {351, "-08:10"},
-      {352, "-08:09"},
-      {353, "-08:08"},
-      {354, "-08:07"},
-      {355, "-08:06"},
-      {356, "-08:05"},
-      {357, "-08:04"},
-      {358, "-08:03"},
-      {359, "-08:02"},
-      {360, "-08:01"},
-      {361, "-08:00"},
-      {362, "-07:59"},
-      {363, "-07:58"},
-      {364, "-07:57"},
-      {365, "-07:56"},
-      {366, "-07:55"},
-      {367, "-07:54"},
-      {368, "-07:53"},
-      {369, "-07:52"},
-      {370, "-07:51"},
-      {371, "-07:50"},
-      {372, "-07:49"},
-      {373, "-07:48"},
-      {374, "-07:47"},
-      {375, "-07:46"},
-      {376, "-07:45"},
-      {377, "-07:44"},
-      {378, "-07:43"},
-      {379, "-07:42"},
-      {380, "-07:41"},
-      {381, "-07:40"},
-      {382, "-07:39"},
-      {383, "-07:38"},
-      {384, "-07:37"},
-      {385, "-07:36"},
-      {386, "-07:35"},
-      {387, "-07:34"},
-      {388, "-07:33"},
-      {389, "-07:32"},
-      {390, "-07:31"},
-      {391, "-07:30"},
-      {392, "-07:29"},
-      {393, "-07:28"},
-      {394, "-07:27"},
-      {395, "-07:26"},
-      {396, "-07:25"},
-      {397, "-07:24"},
-      {398, "-07:23"},
-      {399, "-07:22"},
-      {400, "-07:21"},
-      {401, "-07:20"},
-      {402, "-07:19"},
-      {403, "-07:18"},
-      {404, "-07:17"},
-      {405, "-07:16"},
-      {406, "-07:15"},
-      {407, "-07:14"},
-      {408, "-07:13"},
-      {409, "-07:12"},
-      {410, "-07:11"},
-      {411, "-07:10"},
-      {412, "-07:09"},
-      {413, "-07:08"},
-      {414, "-07:07"},
-      {415, "-07:06"},
-      {416, "-07:05"},
-      {417, "-07:04"},
-      {418, "-07:03"},
-      {419, "-07:02"},
-      {420, "-07:01"},
-      {421, "-07:00"},
-      {422, "-06:59"},
-      {423, "-06:58"},
-      {424, "-06:57"},
-      {425, "-06:56"},
-      {426, "-06:55"},
-      {427, "-06:54"},
-      {428, "-06:53"},
-      {429, "-06:52"},
-      {430, "-06:51"},
-      {431, "-06:50"},
-      {432, "-06:49"},
-      {433, "-06:48"},
-      {434, "-06:47"},
-      {435, "-06:46"},
-      {436, "-06:45"},
-      {437, "-06:44"},
-      {438, "-06:43"},
-      {439, "-06:42"},
-      {440, "-06:41"},
-      {441, "-06:40"},
-      {442, "-06:39"},
-      {443, "-06:38"},
-      {444, "-06:37"},
-      {445, "-06:36"},
-      {446, "-06:35"},
-      {447, "-06:34"},
-      {448, "-06:33"},
-      {449, "-06:32"},
-      {450, "-06:31"},
-      {451, "-06:30"},
-      {452, "-06:29"},
-      {453, "-06:28"},
-      {454, "-06:27"},
-      {455, "-06:26"},
-      {456, "-06:25"},
-      {457, "-06:24"},
-      {458, "-06:23"},
-      {459, "-06:22"},
-      {460, "-06:21"},
-      {461, "-06:20"},
-      {462, "-06:19"},
-      {463, "-06:18"},
-      {464, "-06:17"},
-      {465, "-06:16"},
-      {466, "-06:15"},
-      {467, "-06:14"},
-      {468, "-06:13"},
-      {469, "-06:12"},
-      {470, "-06:11"},
-      {471, "-06:10"},
-      {472, "-06:09"},
-      {473, "-06:08"},
-      {474, "-06:07"},
-      {475, "-06:06"},
-      {476, "-06:05"},
-      {477, "-06:04"},
-      {478, "-06:03"},
-      {479, "-06:02"},
-      {480, "-06:01"},
-      {481, "-06:00"},
-      {482, "-05:59"},
-      {483, "-05:58"},
-      {484, "-05:57"},
-      {485, "-05:56"},
-      {486, "-05:55"},
-      {487, "-05:54"},
-      {488, "-05:53"},
-      {489, "-05:52"},
-      {490, "-05:51"},
-      {491, "-05:50"},
-      {492, "-05:49"},
-      {493, "-05:48"},
-      {494, "-05:47"},
-      {495, "-05:46"},
-      {496, "-05:45"},
-      {497, "-05:44"},
-      {498, "-05:43"},
-      {499, "-05:42"},
-      {500, "-05:41"},
-      {501, "-05:40"},
-      {502, "-05:39"},
-      {503, "-05:38"},
-      {504, "-05:37"},
-      {505, "-05:36"},
-      {506, "-05:35"},
-      {507, "-05:34"},
-      {508, "-05:33"},
-      {509, "-05:32"},
-      {510, "-05:31"},
-      {511, "-05:30"},
-      {512, "-05:29"},
-      {513, "-05:28"},
-      {514, "-05:27"},
-      {515, "-05:26"},
-      {516, "-05:25"},
-      {517, "-05:24"},
-      {518, "-05:23"},
-      {519, "-05:22"},
-      {520, "-05:21"},
-      {521, "-05:20"},
-      {522, "-05:19"},
-      {523, "-05:18"},
-      {524, "-05:17"},
-      {525, "-05:16"},
-      {526, "-05:15"},
-      {527, "-05:14"},
-      {528, "-05:13"},
-      {529, "-05:12"},
-      {530, "-05:11"},
-      {531, "-05:10"},
-      {532, "-05:09"},
-      {533, "-05:08"},
-      {534, "-05:07"},
-      {535, "-05:06"},
-      {536, "-05:05"},
-      {537, "-05:04"},
-      {538, "-05:03"},
-      {539, "-05:02"},
-      {540, "-05:01"},
-      {541, "-05:00"},
-      {542, "-04:59"},
-      {543, "-04:58"},
-      {544, "-04:57"},
-      {545, "-04:56"},
-      {546, "-04:55"},
-      {547, "-04:54"},
-      {548, "-04:53"},
-      {549, "-04:52"},
-      {550, "-04:51"},
-      {551, "-04:50"},
-      {552, "-04:49"},
-      {553, "-04:48"},
-      {554, "-04:47"},
-      {555, "-04:46"},
-      {556, "-04:45"},
-      {557, "-04:44"},
-      {558, "-04:43"},
-      {559, "-04:42"},
-      {560, "-04:41"},
-      {561, "-04:40"},
-      {562, "-04:39"},
-      {563, "-04:38"},
-      {564, "-04:37"},
-      {565, "-04:36"},
-      {566, "-04:35"},
-      {567, "-04:34"},
-      {568, "-04:33"},
-      {569, "-04:32"},
-      {570, "-04:31"},
-      {571, "-04:30"},
-      {572, "-04:29"},
-      {573, "-04:28"},
-      {574, "-04:27"},
-      {575, "-04:26"},
-      {576, "-04:25"},
-      {577, "-04:24"},
-      {578, "-04:23"},
-      {579, "-04:22"},
-      {580, "-04:21"},
-      {581, "-04:20"},
-      {582, "-04:19"},
-      {583, "-04:18"},
-      {584, "-04:17"},
-      {585, "-04:16"},
-      {586, "-04:15"},
-      {587, "-04:14"},
-      {588, "-04:13"},
-      {589, "-04:12"},
-      {590, "-04:11"},
-      {591, "-04:10"},
-      {592, "-04:09"},
-      {593, "-04:08"},
-      {594, "-04:07"},
-      {595, "-04:06"},
-      {596, "-04:05"},
-      {597, "-04:04"},
-      {598, "-04:03"},
-      {599, "-04:02"},
-      {600, "-04:01"},
-      {601, "-04:00"},
-      {602, "-03:59"},
-      {603, "-03:58"},
-      {604, "-03:57"},
-      {605, "-03:56"},
-      {606, "-03:55"},
-      {607, "-03:54"},
-      {608, "-03:53"},
-      {609, "-03:52"},
-      {610, "-03:51"},
-      {611, "-03:50"},
-      {612, "-03:49"},
-      {613, "-03:48"},
-      {614, "-03:47"},
-      {615, "-03:46"},
-      {616, "-03:45"},
-      {617, "-03:44"},
-      {618, "-03:43"},
-      {619, "-03:42"},
-      {620, "-03:41"},
-      {621, "-03:40"},
-      {622, "-03:39"},
-      {623, "-03:38"},
-      {624, "-03:37"},
-      {625, "-03:36"},
-      {626, "-03:35"},
-      {627, "-03:34"},
-      {628, "-03:33"},
-      {629, "-03:32"},
-      {630, "-03:31"},
-      {631, "-03:30"},
-      {632, "-03:29"},
-      {633, "-03:28"},
-      {634, "-03:27"},
-      {635, "-03:26"},
-      {636, "-03:25"},
-      {637, "-03:24"},
-      {638, "-03:23"},
-      {639, "-03:22"},
-      {640, "-03:21"},
-      {641, "-03:20"},
-      {642, "-03:19"},
-      {643, "-03:18"},
-      {644, "-03:17"},
-      {645, "-03:16"},
-      {646, "-03:15"},
-      {647, "-03:14"},
-      {648, "-03:13"},
-      {649, "-03:12"},
-      {650, "-03:11"},
-      {651, "-03:10"},
-      {652, "-03:09"},
-      {653, "-03:08"},
-      {654, "-03:07"},
-      {655, "-03:06"},
-      {656, "-03:05"},
-      {657, "-03:04"},
-      {658, "-03:03"},
-      {659, "-03:02"},
-      {660, "-03:01"},
-      {661, "-03:00"},
-      {662, "-02:59"},
-      {663, "-02:58"},
-      {664, "-02:57"},
-      {665, "-02:56"},
-      {666, "-02:55"},
-      {667, "-02:54"},
-      {668, "-02:53"},
-      {669, "-02:52"},
-      {670, "-02:51"},
-      {671, "-02:50"},
-      {672, "-02:49"},
-      {673, "-02:48"},
-      {674, "-02:47"},
-      {675, "-02:46"},
-      {676, "-02:45"},
-      {677, "-02:44"},
-      {678, "-02:43"},
-      {679, "-02:42"},
-      {680, "-02:41"},
-      {681, "-02:40"},
-      {682, "-02:39"},
-      {683, "-02:38"},
-      {684, "-02:37"},
-      {685, "-02:36"},
-      {686, "-02:35"},
-      {687, "-02:34"},
-      {688, "-02:33"},
-      {689, "-02:32"},
-      {690, "-02:31"},
-      {691, "-02:30"},
-      {692, "-02:29"},
-      {693, "-02:28"},
-      {694, "-02:27"},
-      {695, "-02:26"},
-      {696, "-02:25"},
-      {697, "-02:24"},
-      {698, "-02:23"},
-      {699, "-02:22"},
-      {700, "-02:21"},
-      {701, "-02:20"},
-      {702, "-02:19"},
-      {703, "-02:18"},
-      {704, "-02:17"},
-      {705, "-02:16"},
-      {706, "-02:15"},
-      {707, "-02:14"},
-      {708, "-02:13"},
-      {709, "-02:12"},
-      {710, "-02:11"},
-      {711, "-02:10"},
-      {712, "-02:09"},
-      {713, "-02:08"},
-      {714, "-02:07"},
-      {715, "-02:06"},
-      {716, "-02:05"},
-      {717, "-02:04"},
-      {718, "-02:03"},
-      {719, "-02:02"},
-      {720, "-02:01"},
-      {721, "-02:00"},
-      {722, "-01:59"},
-      {723, "-01:58"},
-      {724, "-01:57"},
-      {725, "-01:56"},
-      {726, "-01:55"},
-      {727, "-01:54"},
-      {728, "-01:53"},
-      {729, "-01:52"},
-      {730, "-01:51"},
-      {731, "-01:50"},
-      {732, "-01:49"},
-      {733, "-01:48"},
-      {734, "-01:47"},
-      {735, "-01:46"},
-      {736, "-01:45"},
-      {737, "-01:44"},
-      {738, "-01:43"},
-      {739, "-01:42"},
-      {740, "-01:41"},
-      {741, "-01:40"},
-      {742, "-01:39"},
-      {743, "-01:38"},
-      {744, "-01:37"},
-      {745, "-01:36"},
-      {746, "-01:35"},
-      {747, "-01:34"},
-      {748, "-01:33"},
-      {749, "-01:32"},
-      {750, "-01:31"},
-      {751, "-01:30"},
-      {752, "-01:29"},
-      {753, "-01:28"},
-      {754, "-01:27"},
-      {755, "-01:26"},
-      {756, "-01:25"},
-      {757, "-01:24"},
-      {758, "-01:23"},
-      {759, "-01:22"},
-      {760, "-01:21"},
-      {761, "-01:20"},
-      {762, "-01:19"},
-      {763, "-01:18"},
-      {764, "-01:17"},
-      {765, "-01:16"},
-      {766, "-01:15"},
-      {767, "-01:14"},
-      {768, "-01:13"},
-      {769, "-01:12"},
-      {770, "-01:11"},
-      {771, "-01:10"},
-      {772, "-01:09"},
-      {773, "-01:08"},
-      {774, "-01:07"},
-      {775, "-01:06"},
-      {776, "-01:05"},
-      {777, "-01:04"},
-      {778, "-01:03"},
-      {779, "-01:02"},
-      {780, "-01:01"},
-      {781, "-01:00"},
-      {782, "-00:59"},
-      {783, "-00:58"},
-      {784, "-00:57"},
-      {785, "-00:56"},
-      {786, "-00:55"},
-      {787, "-00:54"},
-      {788, "-00:53"},
-      {789, "-00:52"},
-      {790, "-00:51"},
-      {791, "-00:50"},
-      {792, "-00:49"},
-      {793, "-00:48"},
-      {794, "-00:47"},
-      {795, "-00:46"},
-      {796, "-00:45"},
-      {797, "-00:44"},
-      {798, "-00:43"},
-      {799, "-00:42"},
-      {800, "-00:41"},
-      {801, "-00:40"},
-      {802, "-00:39"},
-      {803, "-00:38"},
-      {804, "-00:37"},
-      {805, "-00:36"},
-      {806, "-00:35"},
-      {807, "-00:34"},
-      {808, "-00:33"},
-      {809, "-00:32"},
-      {810, "-00:31"},
-      {811, "-00:30"},
-      {812, "-00:29"},
-      {813, "-00:28"},
-      {814, "-00:27"},
-      {815, "-00:26"},
-      {816, "-00:25"},
-      {817, "-00:24"},
-      {818, "-00:23"},
-      {819, "-00:22"},
-      {820, "-00:21"},
-      {821, "-00:20"},
-      {822, "-00:19"},
-      {823, "-00:18"},
-      {824, "-00:17"},
-      {825, "-00:16"},
-      {826, "-00:15"},
-      {827, "-00:14"},
-      {828, "-00:13"},
-      {829, "-00:12"},
-      {830, "-00:11"},
-      {831, "-00:10"},
-      {832, "-00:09"},
-      {833, "-00:08"},
-      {834, "-00:07"},
-      {835, "-00:06"},
-      {836, "-00:05"},
-      {837, "-00:04"},
-      {838, "-00:03"},
-      {839, "-00:02"},
-      {840, "-00:01"},
-      {841, "+00:01"},
-      {842, "+00:02"},
-      {843, "+00:03"},
-      {844, "+00:04"},
-      {845, "+00:05"},
-      {846, "+00:06"},
-      {847, "+00:07"},
-      {848, "+00:08"},
-      {849, "+00:09"},
-      {850, "+00:10"},
-      {851, "+00:11"},
-      {852, "+00:12"},
-      {853, "+00:13"},
-      {854, "+00:14"},
-      {855, "+00:15"},
-      {856, "+00:16"},
-      {857, "+00:17"},
-      {858, "+00:18"},
-      {859, "+00:19"},
-      {860, "+00:20"},
-      {861, "+00:21"},
-      {862, "+00:22"},
-      {863, "+00:23"},
-      {864, "+00:24"},
-      {865, "+00:25"},
-      {866, "+00:26"},
-      {867, "+00:27"},
-      {868, "+00:28"},
-      {869, "+00:29"},
-      {870, "+00:30"},
-      {871, "+00:31"},
-      {872, "+00:32"},
-      {873, "+00:33"},
-      {874, "+00:34"},
-      {875, "+00:35"},
-      {876, "+00:36"},
-      {877, "+00:37"},
-      {878, "+00:38"},
-      {879, "+00:39"},
-      {880, "+00:40"},
-      {881, "+00:41"},
-      {882, "+00:42"},
-      {883, "+00:43"},
-      {884, "+00:44"},
-      {885, "+00:45"},
-      {886, "+00:46"},
-      {887, "+00:47"},
-      {888, "+00:48"},
-      {889, "+00:49"},
-      {890, "+00:50"},
-      {891, "+00:51"},
-      {892, "+00:52"},
-      {893, "+00:53"},
-      {894, "+00:54"},
-      {895, "+00:55"},
-      {896, "+00:56"},
-      {897, "+00:57"},
-      {898, "+00:58"},
-      {899, "+00:59"},
-      {900, "+01:00"},
-      {901, "+01:01"},
-      {902, "+01:02"},
-      {903, "+01:03"},
-      {904, "+01:04"},
-      {905, "+01:05"},
-      {906, "+01:06"},
-      {907, "+01:07"},
-      {908, "+01:08"},
-      {909, "+01:09"},
-      {910, "+01:10"},
-      {911, "+01:11"},
-      {912, "+01:12"},
-      {913, "+01:13"},
-      {914, "+01:14"},
-      {915, "+01:15"},
-      {916, "+01:16"},
-      {917, "+01:17"},
-      {918, "+01:18"},
-      {919, "+01:19"},
-      {920, "+01:20"},
-      {921, "+01:21"},
-      {922, "+01:22"},
-      {923, "+01:23"},
-      {924, "+01:24"},
-      {925, "+01:25"},
-      {926, "+01:26"},
-      {927, "+01:27"},
-      {928, "+01:28"},
-      {929, "+01:29"},
-      {930, "+01:30"},
-      {931, "+01:31"},
-      {932, "+01:32"},
-      {933, "+01:33"},
-      {934, "+01:34"},
-      {935, "+01:35"},
-      {936, "+01:36"},
-      {937, "+01:37"},
-      {938, "+01:38"},
-      {939, "+01:39"},
-      {940, "+01:40"},
-      {941, "+01:41"},
-      {942, "+01:42"},
-      {943, "+01:43"},
-      {944, "+01:44"},
-      {945, "+01:45"},
-      {946, "+01:46"},
-      {947, "+01:47"},
-      {948, "+01:48"},
-      {949, "+01:49"},
-      {950, "+01:50"},
-      {951, "+01:51"},
-      {952, "+01:52"},
-      {953, "+01:53"},
-      {954, "+01:54"},
-      {955, "+01:55"},
-      {956, "+01:56"},
-      {957, "+01:57"},
-      {958, "+01:58"},
-      {959, "+01:59"},
-      {960, "+02:00"},
-      {961, "+02:01"},
-      {962, "+02:02"},
-      {963, "+02:03"},
-      {964, "+02:04"},
-      {965, "+02:05"},
-      {966, "+02:06"},
-      {967, "+02:07"},
-      {968, "+02:08"},
-      {969, "+02:09"},
-      {970, "+02:10"},
-      {971, "+02:11"},
-      {972, "+02:12"},
-      {973, "+02:13"},
-      {974, "+02:14"},
-      {975, "+02:15"},
-      {976, "+02:16"},
-      {977, "+02:17"},
-      {978, "+02:18"},
-      {979, "+02:19"},
-      {980, "+02:20"},
-      {981, "+02:21"},
-      {982, "+02:22"},
-      {983, "+02:23"},
-      {984, "+02:24"},
-      {985, "+02:25"},
-      {986, "+02:26"},
-      {987, "+02:27"},
-      {988, "+02:28"},
-      {989, "+02:29"},
-      {990, "+02:30"},
-      {991, "+02:31"},
-      {992, "+02:32"},
-      {993, "+02:33"},
-      {994, "+02:34"},
-      {995, "+02:35"},
-      {996, "+02:36"},
-      {997, "+02:37"},
-      {998, "+02:38"},
-      {999, "+02:39"},
-      {1000, "+02:40"},
-      {1001, "+02:41"},
-      {1002, "+02:42"},
-      {1003, "+02:43"},
-      {1004, "+02:44"},
-      {1005, "+02:45"},
-      {1006, "+02:46"},
-      {1007, "+02:47"},
-      {1008, "+02:48"},
-      {1009, "+02:49"},
-      {1010, "+02:50"},
-      {1011, "+02:51"},
-      {1012, "+02:52"},
-      {1013, "+02:53"},
-      {1014, "+02:54"},
-      {1015, "+02:55"},
-      {1016, "+02:56"},
-      {1017, "+02:57"},
-      {1018, "+02:58"},
-      {1019, "+02:59"},
-      {1020, "+03:00"},
-      {1021, "+03:01"},
-      {1022, "+03:02"},
-      {1023, "+03:03"},
-      {1024, "+03:04"},
-      {1025, "+03:05"},
-      {1026, "+03:06"},
-      {1027, "+03:07"},
-      {1028, "+03:08"},
-      {1029, "+03:09"},
-      {1030, "+03:10"},
-      {1031, "+03:11"},
-      {1032, "+03:12"},
-      {1033, "+03:13"},
-      {1034, "+03:14"},
-      {1035, "+03:15"},
-      {1036, "+03:16"},
-      {1037, "+03:17"},
-      {1038, "+03:18"},
-      {1039, "+03:19"},
-      {1040, "+03:20"},
-      {1041, "+03:21"},
-      {1042, "+03:22"},
-      {1043, "+03:23"},
-      {1044, "+03:24"},
-      {1045, "+03:25"},
-      {1046, "+03:26"},
-      {1047, "+03:27"},
-      {1048, "+03:28"},
-      {1049, "+03:29"},
-      {1050, "+03:30"},
-      {1051, "+03:31"},
-      {1052, "+03:32"},
-      {1053, "+03:33"},
-      {1054, "+03:34"},
-      {1055, "+03:35"},
-      {1056, "+03:36"},
-      {1057, "+03:37"},
-      {1058, "+03:38"},
-      {1059, "+03:39"},
-      {1060, "+03:40"},
-      {1061, "+03:41"},
-      {1062, "+03:42"},
-      {1063, "+03:43"},
-      {1064, "+03:44"},
-      {1065, "+03:45"},
-      {1066, "+03:46"},
-      {1067, "+03:47"},
-      {1068, "+03:48"},
-      {1069, "+03:49"},
-      {1070, "+03:50"},
-      {1071, "+03:51"},
-      {1072, "+03:52"},
-      {1073, "+03:53"},
-      {1074, "+03:54"},
-      {1075, "+03:55"},
-      {1076, "+03:56"},
-      {1077, "+03:57"},
-      {1078, "+03:58"},
-      {1079, "+03:59"},
-      {1080, "+04:00"},
-      {1081, "+04:01"},
-      {1082, "+04:02"},
-      {1083, "+04:03"},
-      {1084, "+04:04"},
-      {1085, "+04:05"},
-      {1086, "+04:06"},
-      {1087, "+04:07"},
-      {1088, "+04:08"},
-      {1089, "+04:09"},
-      {1090, "+04:10"},
-      {1091, "+04:11"},
-      {1092, "+04:12"},
-      {1093, "+04:13"},
-      {1094, "+04:14"},
-      {1095, "+04:15"},
-      {1096, "+04:16"},
-      {1097, "+04:17"},
-      {1098, "+04:18"},
-      {1099, "+04:19"},
-      {1100, "+04:20"},
-      {1101, "+04:21"},
-      {1102, "+04:22"},
-      {1103, "+04:23"},
-      {1104, "+04:24"},
-      {1105, "+04:25"},
-      {1106, "+04:26"},
-      {1107, "+04:27"},
-      {1108, "+04:28"},
-      {1109, "+04:29"},
-      {1110, "+04:30"},
-      {1111, "+04:31"},
-      {1112, "+04:32"},
-      {1113, "+04:33"},
-      {1114, "+04:34"},
-      {1115, "+04:35"},
-      {1116, "+04:36"},
-      {1117, "+04:37"},
-      {1118, "+04:38"},
-      {1119, "+04:39"},
-      {1120, "+04:40"},
-      {1121, "+04:41"},
-      {1122, "+04:42"},
-      {1123, "+04:43"},
-      {1124, "+04:44"},
-      {1125, "+04:45"},
-      {1126, "+04:46"},
-      {1127, "+04:47"},
-      {1128, "+04:48"},
-      {1129, "+04:49"},
-      {1130, "+04:50"},
-      {1131, "+04:51"},
-      {1132, "+04:52"},
-      {1133, "+04:53"},
-      {1134, "+04:54"},
-      {1135, "+04:55"},
-      {1136, "+04:56"},
-      {1137, "+04:57"},
-      {1138, "+04:58"},
-      {1139, "+04:59"},
-      {1140, "+05:00"},
-      {1141, "+05:01"},
-      {1142, "+05:02"},
-      {1143, "+05:03"},
-      {1144, "+05:04"},
-      {1145, "+05:05"},
-      {1146, "+05:06"},
-      {1147, "+05:07"},
-      {1148, "+05:08"},
-      {1149, "+05:09"},
-      {1150, "+05:10"},
-      {1151, "+05:11"},
-      {1152, "+05:12"},
-      {1153, "+05:13"},
-      {1154, "+05:14"},
-      {1155, "+05:15"},
-      {1156, "+05:16"},
-      {1157, "+05:17"},
-      {1158, "+05:18"},
-      {1159, "+05:19"},
-      {1160, "+05:20"},
-      {1161, "+05:21"},
-      {1162, "+05:22"},
-      {1163, "+05:23"},
-      {1164, "+05:24"},
-      {1165, "+05:25"},
-      {1166, "+05:26"},
-      {1167, "+05:27"},
-      {1168, "+05:28"},
-      {1169, "+05:29"},
-      {1170, "+05:30"},
-      {1171, "+05:31"},
-      {1172, "+05:32"},
-      {1173, "+05:33"},
-      {1174, "+05:34"},
-      {1175, "+05:35"},
-      {1176, "+05:36"},
-      {1177, "+05:37"},
-      {1178, "+05:38"},
-      {1179, "+05:39"},
-      {1180, "+05:40"},
-      {1181, "+05:41"},
-      {1182, "+05:42"},
-      {1183, "+05:43"},
-      {1184, "+05:44"},
-      {1185, "+05:45"},
-      {1186, "+05:46"},
-      {1187, "+05:47"},
-      {1188, "+05:48"},
-      {1189, "+05:49"},
-      {1190, "+05:50"},
-      {1191, "+05:51"},
-      {1192, "+05:52"},
-      {1193, "+05:53"},
-      {1194, "+05:54"},
-      {1195, "+05:55"},
-      {1196, "+05:56"},
-      {1197, "+05:57"},
-      {1198, "+05:58"},
-      {1199, "+05:59"},
-      {1200, "+06:00"},
-      {1201, "+06:01"},
-      {1202, "+06:02"},
-      {1203, "+06:03"},
-      {1204, "+06:04"},
-      {1205, "+06:05"},
-      {1206, "+06:06"},
-      {1207, "+06:07"},
-      {1208, "+06:08"},
-      {1209, "+06:09"},
-      {1210, "+06:10"},
-      {1211, "+06:11"},
-      {1212, "+06:12"},
-      {1213, "+06:13"},
-      {1214, "+06:14"},
-      {1215, "+06:15"},
-      {1216, "+06:16"},
-      {1217, "+06:17"},
-      {1218, "+06:18"},
-      {1219, "+06:19"},
-      {1220, "+06:20"},
-      {1221, "+06:21"},
-      {1222, "+06:22"},
-      {1223, "+06:23"},
-      {1224, "+06:24"},
-      {1225, "+06:25"},
-      {1226, "+06:26"},
-      {1227, "+06:27"},
-      {1228, "+06:28"},
-      {1229, "+06:29"},
-      {1230, "+06:30"},
-      {1231, "+06:31"},
-      {1232, "+06:32"},
-      {1233, "+06:33"},
-      {1234, "+06:34"},
-      {1235, "+06:35"},
-      {1236, "+06:36"},
-      {1237, "+06:37"},
-      {1238, "+06:38"},
-      {1239, "+06:39"},
-      {1240, "+06:40"},
-      {1241, "+06:41"},
-      {1242, "+06:42"},
-      {1243, "+06:43"},
-      {1244, "+06:44"},
-      {1245, "+06:45"},
-      {1246, "+06:46"},
-      {1247, "+06:47"},
-      {1248, "+06:48"},
-      {1249, "+06:49"},
-      {1250, "+06:50"},
-      {1251, "+06:51"},
-      {1252, "+06:52"},
-      {1253, "+06:53"},
-      {1254, "+06:54"},
-      {1255, "+06:55"},
-      {1256, "+06:56"},
-      {1257, "+06:57"},
-      {1258, "+06:58"},
-      {1259, "+06:59"},
-      {1260, "+07:00"},
-      {1261, "+07:01"},
-      {1262, "+07:02"},
-      {1263, "+07:03"},
-      {1264, "+07:04"},
-      {1265, "+07:05"},
-      {1266, "+07:06"},
-      {1267, "+07:07"},
-      {1268, "+07:08"},
-      {1269, "+07:09"},
-      {1270, "+07:10"},
-      {1271, "+07:11"},
-      {1272, "+07:12"},
-      {1273, "+07:13"},
-      {1274, "+07:14"},
-      {1275, "+07:15"},
-      {1276, "+07:16"},
-      {1277, "+07:17"},
-      {1278, "+07:18"},
-      {1279, "+07:19"},
-      {1280, "+07:20"},
-      {1281, "+07:21"},
-      {1282, "+07:22"},
-      {1283, "+07:23"},
-      {1284, "+07:24"},
-      {1285, "+07:25"},
-      {1286, "+07:26"},
-      {1287, "+07:27"},
-      {1288, "+07:28"},
-      {1289, "+07:29"},
-      {1290, "+07:30"},
-      {1291, "+07:31"},
-      {1292, "+07:32"},
-      {1293, "+07:33"},
-      {1294, "+07:34"},
-      {1295, "+07:35"},
-      {1296, "+07:36"},
-      {1297, "+07:37"},
-      {1298, "+07:38"},
-      {1299, "+07:39"},
-      {1300, "+07:40"},
-      {1301, "+07:41"},
-      {1302, "+07:42"},
-      {1303, "+07:43"},
-      {1304, "+07:44"},
-      {1305, "+07:45"},
-      {1306, "+07:46"},
-      {1307, "+07:47"},
-      {1308, "+07:48"},
-      {1309, "+07:49"},
-      {1310, "+07:50"},
-      {1311, "+07:51"},
-      {1312, "+07:52"},
-      {1313, "+07:53"},
-      {1314, "+07:54"},
-      {1315, "+07:55"},
-      {1316, "+07:56"},
-      {1317, "+07:57"},
-      {1318, "+07:58"},
-      {1319, "+07:59"},
-      {1320, "+08:00"},
-      {1321, "+08:01"},
-      {1322, "+08:02"},
-      {1323, "+08:03"},
-      {1324, "+08:04"},
-      {1325, "+08:05"},
-      {1326, "+08:06"},
-      {1327, "+08:07"},
-      {1328, "+08:08"},
-      {1329, "+08:09"},
-      {1330, "+08:10"},
-      {1331, "+08:11"},
-      {1332, "+08:12"},
-      {1333, "+08:13"},
-      {1334, "+08:14"},
-      {1335, "+08:15"},
-      {1336, "+08:16"},
-      {1337, "+08:17"},
-      {1338, "+08:18"},
-      {1339, "+08:19"},
-      {1340, "+08:20"},
-      {1341, "+08:21"},
-      {1342, "+08:22"},
-      {1343, "+08:23"},
-      {1344, "+08:24"},
-      {1345, "+08:25"},
-      {1346, "+08:26"},
-      {1347, "+08:27"},
-      {1348, "+08:28"},
-      {1349, "+08:29"},
-      {1350, "+08:30"},
-      {1351, "+08:31"},
-      {1352, "+08:32"},
-      {1353, "+08:33"},
-      {1354, "+08:34"},
-      {1355, "+08:35"},
-      {1356, "+08:36"},
-      {1357, "+08:37"},
-      {1358, "+08:38"},
-      {1359, "+08:39"},
-      {1360, "+08:40"},
-      {1361, "+08:41"},
-      {1362, "+08:42"},
-      {1363, "+08:43"},
-      {1364, "+08:44"},
-      {1365, "+08:45"},
-      {1366, "+08:46"},
-      {1367, "+08:47"},
-      {1368, "+08:48"},
-      {1369, "+08:49"},
-      {1370, "+08:50"},
-      {1371, "+08:51"},
-      {1372, "+08:52"},
-      {1373, "+08:53"},
-      {1374, "+08:54"},
-      {1375, "+08:55"},
-      {1376, "+08:56"},
-      {1377, "+08:57"},
-      {1378, "+08:58"},
-      {1379, "+08:59"},
-      {1380, "+09:00"},
-      {1381, "+09:01"},
-      {1382, "+09:02"},
-      {1383, "+09:03"},
-      {1384, "+09:04"},
-      {1385, "+09:05"},
-      {1386, "+09:06"},
-      {1387, "+09:07"},
-      {1388, "+09:08"},
-      {1389, "+09:09"},
-      {1390, "+09:10"},
-      {1391, "+09:11"},
-      {1392, "+09:12"},
-      {1393, "+09:13"},
-      {1394, "+09:14"},
-      {1395, "+09:15"},
-      {1396, "+09:16"},
-      {1397, "+09:17"},
-      {1398, "+09:18"},
-      {1399, "+09:19"},
-      {1400, "+09:20"},
-      {1401, "+09:21"},
-      {1402, "+09:22"},
-      {1403, "+09:23"},
-      {1404, "+09:24"},
-      {1405, "+09:25"},
-      {1406, "+09:26"},
-      {1407, "+09:27"},
-      {1408, "+09:28"},
-      {1409, "+09:29"},
-      {1410, "+09:30"},
-      {1411, "+09:31"},
-      {1412, "+09:32"},
-      {1413, "+09:33"},
-      {1414, "+09:34"},
-      {1415, "+09:35"},
-      {1416, "+09:36"},
-      {1417, "+09:37"},
-      {1418, "+09:38"},
-      {1419, "+09:39"},
-      {1420, "+09:40"},
-      {1421, "+09:41"},
-      {1422, "+09:42"},
-      {1423, "+09:43"},
-      {1424, "+09:44"},
-      {1425, "+09:45"},
-      {1426, "+09:46"},
-      {1427, "+09:47"},
-      {1428, "+09:48"},
-      {1429, "+09:49"},
-      {1430, "+09:50"},
-      {1431, "+09:51"},
-      {1432, "+09:52"},
-      {1433, "+09:53"},
-      {1434, "+09:54"},
-      {1435, "+09:55"},
-      {1436, "+09:56"},
-      {1437, "+09:57"},
-      {1438, "+09:58"},
-      {1439, "+09:59"},
-      {1440, "+10:00"},
-      {1441, "+10:01"},
-      {1442, "+10:02"},
-      {1443, "+10:03"},
-      {1444, "+10:04"},
-      {1445, "+10:05"},
-      {1446, "+10:06"},
-      {1447, "+10:07"},
-      {1448, "+10:08"},
-      {1449, "+10:09"},
-      {1450, "+10:10"},
-      {1451, "+10:11"},
-      {1452, "+10:12"},
-      {1453, "+10:13"},
-      {1454, "+10:14"},
-      {1455, "+10:15"},
-      {1456, "+10:16"},
-      {1457, "+10:17"},
-      {1458, "+10:18"},
-      {1459, "+10:19"},
-      {1460, "+10:20"},
-      {1461, "+10:21"},
-      {1462, "+10:22"},
-      {1463, "+10:23"},
-      {1464, "+10:24"},
-      {1465, "+10:25"},
-      {1466, "+10:26"},
-      {1467, "+10:27"},
-      {1468, "+10:28"},
-      {1469, "+10:29"},
-      {1470, "+10:30"},
-      {1471, "+10:31"},
-      {1472, "+10:32"},
-      {1473, "+10:33"},
-      {1474, "+10:34"},
-      {1475, "+10:35"},
-      {1476, "+10:36"},
-      {1477, "+10:37"},
-      {1478, "+10:38"},
-      {1479, "+10:39"},
-      {1480, "+10:40"},
-      {1481, "+10:41"},
-      {1482, "+10:42"},
-      {1483, "+10:43"},
-      {1484, "+10:44"},
-      {1485, "+10:45"},
-      {1486, "+10:46"},
-      {1487, "+10:47"},
-      {1488, "+10:48"},
-      {1489, "+10:49"},
-      {1490, "+10:50"},
-      {1491, "+10:51"},
-      {1492, "+10:52"},
-      {1493, "+10:53"},
-      {1494, "+10:54"},
-      {1495, "+10:55"},
-      {1496, "+10:56"},
-      {1497, "+10:57"},
-      {1498, "+10:58"},
-      {1499, "+10:59"},
-      {1500, "+11:00"},
-      {1501, "+11:01"},
-      {1502, "+11:02"},
-      {1503, "+11:03"},
-      {1504, "+11:04"},
-      {1505, "+11:05"},
-      {1506, "+11:06"},
-      {1507, "+11:07"},
-      {1508, "+11:08"},
-      {1509, "+11:09"},
-      {1510, "+11:10"},
-      {1511, "+11:11"},
-      {1512, "+11:12"},
-      {1513, "+11:13"},
-      {1514, "+11:14"},
-      {1515, "+11:15"},
-      {1516, "+11:16"},
-      {1517, "+11:17"},
-      {1518, "+11:18"},
-      {1519, "+11:19"},
-      {1520, "+11:20"},
-      {1521, "+11:21"},
-      {1522, "+11:22"},
-      {1523, "+11:23"},
-      {1524, "+11:24"},
-      {1525, "+11:25"},
-      {1526, "+11:26"},
-      {1527, "+11:27"},
-      {1528, "+11:28"},
-      {1529, "+11:29"},
-      {1530, "+11:30"},
-      {1531, "+11:31"},
-      {1532, "+11:32"},
-      {1533, "+11:33"},
-      {1534, "+11:34"},
-      {1535, "+11:35"},
-      {1536, "+11:36"},
-      {1537, "+11:37"},
-      {1538, "+11:38"},
-      {1539, "+11:39"},
-      {1540, "+11:40"},
-      {1541, "+11:41"},
-      {1542, "+11:42"},
-      {1543, "+11:43"},
-      {1544, "+11:44"},
-      {1545, "+11:45"},
-      {1546, "+11:46"},
-      {1547, "+11:47"},
-      {1548, "+11:48"},
-      {1549, "+11:49"},
-      {1550, "+11:50"},
-      {1551, "+11:51"},
-      {1552, "+11:52"},
-      {1553, "+11:53"},
-      {1554, "+11:54"},
-      {1555, "+11:55"},
-      {1556, "+11:56"},
-      {1557, "+11:57"},
-      {1558, "+11:58"},
-      {1559, "+11:59"},
-      {1560, "+12:00"},
-      {1561, "+12:01"},
-      {1562, "+12:02"},
-      {1563, "+12:03"},
-      {1564, "+12:04"},
-      {1565, "+12:05"},
-      {1566, "+12:06"},
-      {1567, "+12:07"},
-      {1568, "+12:08"},
-      {1569, "+12:09"},
-      {1570, "+12:10"},
-      {1571, "+12:11"},
-      {1572, "+12:12"},
-      {1573, "+12:13"},
-      {1574, "+12:14"},
-      {1575, "+12:15"},
-      {1576, "+12:16"},
-      {1577, "+12:17"},
-      {1578, "+12:18"},
-      {1579, "+12:19"},
-      {1580, "+12:20"},
-      {1581, "+12:21"},
-      {1582, "+12:22"},
-      {1583, "+12:23"},
-      {1584, "+12:24"},
-      {1585, "+12:25"},
-      {1586, "+12:26"},
-      {1587, "+12:27"},
-      {1588, "+12:28"},
-      {1589, "+12:29"},
-      {1590, "+12:30"},
-      {1591, "+12:31"},
-      {1592, "+12:32"},
-      {1593, "+12:33"},
-      {1594, "+12:34"},
-      {1595, "+12:35"},
-      {1596, "+12:36"},
-      {1597, "+12:37"},
-      {1598, "+12:38"},
-      {1599, "+12:39"},
-      {1600, "+12:40"},
-      {1601, "+12:41"},
-      {1602, "+12:42"},
-      {1603, "+12:43"},
-      {1604, "+12:44"},
-      {1605, "+12:45"},
-      {1606, "+12:46"},
-      {1607, "+12:47"},
-      {1608, "+12:48"},
-      {1609, "+12:49"},
-      {1610, "+12:50"},
-      {1611, "+12:51"},
-      {1612, "+12:52"},
-      {1613, "+12:53"},
-      {1614, "+12:54"},
-      {1615, "+12:55"},
-      {1616, "+12:56"},
-      {1617, "+12:57"},
-      {1618, "+12:58"},
-      {1619, "+12:59"},
-      {1620, "+13:00"},
-      {1621, "+13:01"},
-      {1622, "+13:02"},
-      {1623, "+13:03"},
-      {1624, "+13:04"},
-      {1625, "+13:05"},
-      {1626, "+13:06"},
-      {1627, "+13:07"},
-      {1628, "+13:08"},
-      {1629, "+13:09"},
-      {1630, "+13:10"},
-      {1631, "+13:11"},
-      {1632, "+13:12"},
-      {1633, "+13:13"},
-      {1634, "+13:14"},
-      {1635, "+13:15"},
-      {1636, "+13:16"},
-      {1637, "+13:17"},
-      {1638, "+13:18"},
-      {1639, "+13:19"},
-      {1640, "+13:20"},
-      {1641, "+13:21"},
-      {1642, "+13:22"},
-      {1643, "+13:23"},
-      {1644, "+13:24"},
-      {1645, "+13:25"},
-      {1646, "+13:26"},
-      {1647, "+13:27"},
-      {1648, "+13:28"},
-      {1649, "+13:29"},
-      {1650, "+13:30"},
-      {1651, "+13:31"},
-      {1652, "+13:32"},
-      {1653, "+13:33"},
-      {1654, "+13:34"},
-      {1655, "+13:35"},
-      {1656, "+13:36"},
-      {1657, "+13:37"},
-      {1658, "+13:38"},
-      {1659, "+13:39"},
-      {1660, "+13:40"},
-      {1661, "+13:41"},
-      {1662, "+13:42"},
-      {1663, "+13:43"},
-      {1664, "+13:44"},
-      {1665, "+13:45"},
-      {1666, "+13:46"},
-      {1667, "+13:47"},
-      {1668, "+13:48"},
-      {1669, "+13:49"},
-      {1670, "+13:50"},
-      {1671, "+13:51"},
-      {1672, "+13:52"},
-      {1673, "+13:53"},
-      {1674, "+13:54"},
-      {1675, "+13:55"},
-      {1676, "+13:56"},
-      {1677, "+13:57"},
-      {1678, "+13:58"},
-      {1679, "+13:59"},
-      {1680, "+14:00"},
-      {1681, "Africa/Abidjan"},
-      {1682, "Africa/Accra"},
-      {1683, "Africa/Addis_Ababa"},
-      {1684, "Africa/Algiers"},
-      {1685, "Africa/Asmara"},
-      {1686, "Africa/Asmera"},
-      {1687, "Africa/Bamako"},
-      {1688, "Africa/Bangui"},
-      {1689, "Africa/Banjul"},
-      {1690, "Africa/Bissau"},
-      {1691, "Africa/Blantyre"},
-      {1692, "Africa/Brazzaville"},
-      {1693, "Africa/Bujumbura"},
-      {1694, "Africa/Cairo"},
-      {1695, "Africa/Casablanca"},
-      {1696, "Africa/Ceuta"},
-      {1697, "Africa/Conakry"},
-      {1698, "Africa/Dakar"},
-      {1699, "Africa/Dar_es_Salaam"},
-      {1700, "Africa/Djibouti"},
-      {1701, "Africa/Douala"},
-      {1702, "Africa/El_Aaiun"},
-      {1703, "Africa/Freetown"},
-      {1704, "Africa/Gaborone"},
-      {1705, "Africa/Harare"},
-      {1706, "Africa/Johannesburg"},
-      {1707, "Africa/Juba"},
-      {1708, "Africa/Kampala"},
-      {1709, "Africa/Khartoum"},
-      {1710, "Africa/Kigali"},
-      {1711, "Africa/Kinshasa"},
-      {1712, "Africa/Lagos"},
-      {1713, "Africa/Libreville"},
-      {1714, "Africa/Lome"},
-      {1715, "Africa/Luanda"},
-      {1716, "Africa/Lubumbashi"},
-      {1717, "Africa/Lusaka"},
-      {1718, "Africa/Malabo"},
-      {1719, "Africa/Maputo"},
-      {1720, "Africa/Maseru"},
-      {1721, "Africa/Mbabane"},
-      {1722, "Africa/Mogadishu"},
-      {1723, "Africa/Monrovia"},
-      {1724, "Africa/Nairobi"},
-      {1725, "Africa/Ndjamena"},
-      {1726, "Africa/Niamey"},
-      {1727, "Africa/Nouakchott"},
-      {1728, "Africa/Ouagadougou"},
-      {1729, "Africa/Porto-Novo"},
-      {1730, "Africa/Sao_Tome"},
-      {1731, "Africa/Timbuktu"},
-      {1732, "Africa/Tripoli"},
-      {1733, "Africa/Tunis"},
-      {1734, "Africa/Windhoek"},
-      {1735, "America/Adak"},
-      {1736, "America/Anchorage"},
-      {1737, "America/Anguilla"},
-      {1738, "America/Antigua"},
-      {1739, "America/Araguaina"},
-      {1740, "America/Argentina/Buenos_Aires"},
-      {1741, "America/Argentina/Catamarca"},
-      {1742, "America/Argentina/ComodRivadavia"},
-      {1743, "America/Argentina/Cordoba"},
-      {1744, "America/Argentina/Jujuy"},
-      {1745, "America/Argentina/La_Rioja"},
-      {1746, "America/Argentina/Mendoza"},
-      {1747, "America/Argentina/Rio_Gallegos"},
-      {1748, "America/Argentina/Salta"},
-      {1749, "America/Argentina/San_Juan"},
-      {1750, "America/Argentina/San_Luis"},
-      {1751, "America/Argentina/Tucuman"},
-      {1752, "America/Argentina/Ushuaia"},
-      {1753, "America/Aruba"},
-      {1754, "America/Asuncion"},
-      {1755, "America/Atikokan"},
-      {1756, "America/Atka"},
-      {1757, "America/Bahia"},
-      {1758, "America/Bahia_Banderas"},
-      {1759, "America/Barbados"},
-      {1760, "America/Belem"},
-      {1761, "America/Belize"},
-      {1762, "America/Blanc-Sablon"},
-      {1763, "America/Boa_Vista"},
-      {1764, "America/Bogota"},
-      {1765, "America/Boise"},
-      {1766, "America/Buenos_Aires"},
-      {1767, "America/Cambridge_Bay"},
-      {1768, "America/Campo_Grande"},
-      {1769, "America/Cancun"},
-      {1770, "America/Caracas"},
-      {1771, "America/Catamarca"},
-      {1772, "America/Cayenne"},
-      {1773, "America/Cayman"},
-      {1774, "America/Chicago"},
-      {1775, "America/Chihuahua"},
-      {1776, "America/Coral_Harbour"},
-      {1777, "America/Cordoba"},
-      {1778, "America/Costa_Rica"},
-      {1779, "America/Cuiaba"},
-      {1780, "America/Curacao"},
-      {1781, "America/Danmarkshavn"},
-      {1782, "America/Dawson"},
-      {1783, "America/Dawson_Creek"},
-      {1784, "America/Denver"},
-      {1785, "America/Detroit"},
-      {1786, "America/Dominica"},
-      {1787, "America/Edmonton"},
-      {1788, "America/Eirunepe"},
-      {1789, "America/El_Salvador"},
-      {1790, "America/Ensenada"},
-      {1791, "America/Fort_Wayne"},
-      {1792, "America/Fortaleza"},
-      {1793, "America/Glace_Bay"},
-      {1794, "America/Godthab"},
-      {1795, "America/Goose_Bay"},
-      {1796, "America/Grand_Turk"},
-      {1797, "America/Grenada"},
-      {1798, "America/Guadeloupe"},
-      {1799, "America/Guatemala"},
-      {1800, "America/Guayaquil"},
-      {1801, "America/Guyana"},
-      {1802, "America/Halifax"},
-      {1803, "America/Havana"},
-      {1804, "America/Hermosillo"},
-      {1805, "America/Indiana/Indianapolis"},
-      {1806, "America/Indiana/Knox"},
-      {1807, "America/Indiana/Marengo"},
-      {1808, "America/Indiana/Petersburg"},
-      {1809, "America/Indiana/Tell_City"},
-      {1810, "America/Indiana/Vevay"},
-      {1811, "America/Indiana/Vincennes"},
-      {1812, "America/Indiana/Winamac"},
-      {1813, "America/Indianapolis"},
-      {1814, "America/Inuvik"},
-      {1815, "America/Iqaluit"},
-      {1816, "America/Jamaica"},
-      {1817, "America/Jujuy"},
-      {1818, "America/Juneau"},
-      {1819, "America/Kentucky/Louisville"},
-      {1820, "America/Kentucky/Monticello"},
-      {1821, "America/Knox_IN"},
-      {1822, "America/Kralendijk"},
-      {1823, "America/La_Paz"},
-      {1824, "America/Lima"},
-      {1825, "America/Los_Angeles"},
-      {1826, "America/Louisville"},
-      {1827, "America/Lower_Princes"},
-      {1828, "America/Maceio"},
-      {1829, "America/Managua"},
-      {1830, "America/Manaus"},
-      {1831, "America/Marigot"},
-      {1832, "America/Martinique"},
-      {1833, "America/Matamoros"},
-      {1834, "America/Mazatlan"},
-      {1835, "America/Mendoza"},
-      {1836, "America/Menominee"},
-      {1837, "America/Merida"},
-      {1838, "America/Metlakatla"},
-      {1839, "America/Mexico_City"},
-      {1840, "America/Miquelon"},
-      {1841, "America/Moncton"},
-      {1842, "America/Monterrey"},
-      {1843, "America/Montevideo"},
-      {1844, "America/Montreal"},
-      {1845, "America/Montserrat"},
-      {1846, "America/Nassau"},
-      {1847, "America/New_York"},
-      {1848, "America/Nipigon"},
-      {1849, "America/Nome"},
-      {1850, "America/Noronha"},
-      {1851, "America/North_Dakota/Beulah"},
-      {1852, "America/North_Dakota/Center"},
-      {1853, "America/North_Dakota/New_Salem"},
-      {1854, "America/Ojinaga"},
-      {1855, "America/Panama"},
-      {1856, "America/Pangnirtung"},
-      {1857, "America/Paramaribo"},
-      {1858, "America/Phoenix"},
-      {1859, "America/Port-au-Prince"},
-      {1860, "America/Port_of_Spain"},
-      {1861, "America/Porto_Acre"},
-      {1862, "America/Porto_Velho"},
-      {1863, "America/Puerto_Rico"},
-      {1864, "America/Rainy_River"},
-      {1865, "America/Rankin_Inlet"},
-      {1866, "America/Recife"},
-      {1867, "America/Regina"},
-      {1868, "America/Resolute"},
-      {1869, "America/Rio_Branco"},
-      {1870, "America/Rosario"},
-      {1871, "America/Santa_Isabel"},
-      {1872, "America/Santarem"},
-      {1873, "America/Santiago"},
-      {1874, "America/Santo_Domingo"},
-      {1875, "America/Sao_Paulo"},
-      {1876, "America/Scoresbysund"},
-      {1877, "America/Shiprock"},
-      {1878, "America/Sitka"},
-      {1879, "America/St_Barthelemy"},
-      {1880, "America/St_Johns"},
-      {1881, "America/St_Kitts"},
-      {1882, "America/St_Lucia"},
-      {1883, "America/St_Thomas"},
-      {1884, "America/St_Vincent"},
-      {1885, "America/Swift_Current"},
-      {1886, "America/Tegucigalpa"},
-      {1887, "America/Thule"},
-      {1888, "America/Thunder_Bay"},
-      {1889, "America/Tijuana"},
-      {1890, "America/Toronto"},
-      {1891, "America/Tortola"},
-      {1892, "America/Vancouver"},
-      {1893, "America/Virgin"},
-      {1894, "America/Whitehorse"},
-      {1895, "America/Winnipeg"},
-      {1896, "America/Yakutat"},
-      {1897, "America/Yellowknife"},
-      {1898, "Antarctica/Casey"},
-      {1899, "Antarctica/Davis"},
-      {1900, "Antarctica/DumontDUrville"},
-      {1901, "Antarctica/Macquarie"},
-      {1902, "Antarctica/Mawson"},
-      {1903, "Antarctica/McMurdo"},
-      {1904, "Antarctica/Palmer"},
-      {1905, "Antarctica/Rothera"},
-      {1906, "Antarctica/South_Pole"},
-      {1907, "Antarctica/Syowa"},
-      {1908, "Antarctica/Vostok"},
-      {1909, "Arctic/Longyearbyen"},
-      {1910, "Asia/Aden"},
-      {1911, "Asia/Almaty"},
-      {1912, "Asia/Amman"},
-      {1913, "Asia/Anadyr"},
-      {1914, "Asia/Aqtau"},
-      {1915, "Asia/Aqtobe"},
-      {1916, "Asia/Ashgabat"},
-      {1917, "Asia/Ashkhabad"},
-      {1918, "Asia/Baghdad"},
-      {1919, "Asia/Bahrain"},
-      {1920, "Asia/Baku"},
-      {1921, "Asia/Bangkok"},
-      {1922, "Asia/Beirut"},
-      {1923, "Asia/Bishkek"},
-      {1924, "Asia/Brunei"},
-      {1925, "Asia/Calcutta"},
-      {1926, "Asia/Choibalsan"},
-      {1927, "Asia/Chongqing"},
-      {1928, "Asia/Chungking"},
-      {1929, "Asia/Colombo"},
-      {1930, "Asia/Dacca"},
-      {1931, "Asia/Damascus"},
-      {1932, "Asia/Dhaka"},
-      {1933, "Asia/Dili"},
-      {1934, "Asia/Dubai"},
-      {1935, "Asia/Dushanbe"},
-      {1936, "Asia/Gaza"},
-      {1937, "Asia/Harbin"},
-      {1938, "Asia/Hebron"},
-      {1939, "Asia/Ho_Chi_Minh"},
-      {1940, "Asia/Hong_Kong"},
-      {1941, "Asia/Hovd"},
-      {1942, "Asia/Irkutsk"},
-      {1943, "Asia/Istanbul"},
-      {1944, "Asia/Jakarta"},
-      {1945, "Asia/Jayapura"},
-      {1946, "Asia/Jerusalem"},
-      {1947, "Asia/Kabul"},
-      {1948, "Asia/Kamchatka"},
-      {1949, "Asia/Karachi"},
-      {1950, "Asia/Kashgar"},
-      {1951, "Asia/Kathmandu"},
-      {1952, "Asia/Katmandu"},
-      {1953, "Asia/Kolkata"},
-      {1954, "Asia/Krasnoyarsk"},
-      {1955, "Asia/Kuala_Lumpur"},
-      {1956, "Asia/Kuching"},
-      {1957, "Asia/Kuwait"},
-      {1958, "Asia/Macao"},
-      {1959, "Asia/Macau"},
-      {1960, "Asia/Magadan"},
-      {1961, "Asia/Makassar"},
-      {1962, "Asia/Manila"},
-      {1963, "Asia/Muscat"},
-      {1964, "Asia/Nicosia"},
-      {1965, "Asia/Novokuznetsk"},
-      {1966, "Asia/Novosibirsk"},
-      {1967, "Asia/Omsk"},
-      {1968, "Asia/Oral"},
-      {1969, "Asia/Phnom_Penh"},
-      {1970, "Asia/Pontianak"},
-      {1971, "Asia/Pyongyang"},
-      {1972, "Asia/Qatar"},
-      {1973, "Asia/Qyzylorda"},
-      {1974, "Asia/Rangoon"},
-      {1975, "Asia/Riyadh"},
-      {1976, "Asia/Saigon"},
-      {1977, "Asia/Sakhalin"},
-      {1978, "Asia/Samarkand"},
-      {1979, "Asia/Seoul"},
-      {1980, "Asia/Shanghai"},
-      {1981, "Asia/Singapore"},
-      {1982, "Asia/Taipei"},
-      {1983, "Asia/Tashkent"},
-      {1984, "Asia/Tbilisi"},
-      {1985, "Asia/Tehran"},
-      {1986, "Asia/Tel_Aviv"},
-      {1987, "Asia/Thimbu"},
-      {1988, "Asia/Thimphu"},
-      {1989, "Asia/Tokyo"},
-      {1990, "Asia/Ujung_Pandang"},
-      {1991, "Asia/Ulaanbaatar"},
-      {1992, "Asia/Ulan_Bator"},
-      {1993, "Asia/Urumqi"},
-      {1994, "Asia/Vientiane"},
-      {1995, "Asia/Vladivostok"},
-      {1996, "Asia/Yakutsk"},
-      {1997, "Asia/Yekaterinburg"},
-      {1998, "Asia/Yerevan"},
-      {1999, "Atlantic/Azores"},
-      {2000, "Atlantic/Bermuda"},
-      {2001, "Atlantic/Canary"},
-      {2002, "Atlantic/Cape_Verde"},
-      {2003, "Atlantic/Faeroe"},
-      {2004, "Atlantic/Faroe"},
-      {2005, "Atlantic/Jan_Mayen"},
-      {2006, "Atlantic/Madeira"},
-      {2007, "Atlantic/Reykjavik"},
-      {2008, "Atlantic/South_Georgia"},
-      {2009, "Atlantic/St_Helena"},
-      {2010, "Atlantic/Stanley"},
-      {2011, "Australia/ACT"},
-      {2012, "Australia/Adelaide"},
-      {2013, "Australia/Brisbane"},
-      {2014, "Australia/Broken_Hill"},
-      {2015, "Australia/Canberra"},
-      {2016, "Australia/Currie"},
-      {2017, "Australia/Darwin"},
-      {2018, "Australia/Eucla"},
-      {2019, "Australia/Hobart"},
-      {2020, "Australia/LHI"},
-      {2021, "Australia/Lindeman"},
-      {2022, "Australia/Lord_Howe"},
-      {2023, "Australia/Melbourne"},
-      {2024, "Australia/NSW"},
-      {2025, "Australia/North"},
-      {2026, "Australia/Perth"},
-      {2027, "Australia/Queensland"},
-      {2028, "Australia/South"},
-      {2029, "Australia/Sydney"},
-      {2030, "Australia/Tasmania"},
-      {2031, "Australia/Victoria"},
-      {2032, "Australia/West"},
-      {2033, "Australia/Yancowinna"},
-      {2034, "Brazil/Acre"},
-      {2035, "Brazil/DeNoronha"},
-      {2036, "Brazil/East"},
-      {2037, "Brazil/West"},
-      {2038, "Canada/Atlantic"},
-      {2039, "Canada/Central"},
-      {2041, "Canada/Eastern"},
-      {2042, "Canada/Mountain"},
-      {2043, "Canada/Newfoundland"},
-      {2044, "Canada/Pacific"},
-      {2045, "Canada/Saskatchewan"},
-      {2046, "Canada/Yukon"},
-      {2047, "Chile/Continental"},
-      {2048, "Chile/EasterIsland"},
-      {2049, "Europe/Amsterdam"},
-      {2050, "Europe/Andorra"},
-      {2051, "Europe/Athens"},
-      {2052, "Europe/Belfast"},
-      {2053, "Europe/Belgrade"},
-      {2054, "Europe/Berlin"},
-      {2055, "Europe/Bratislava"},
-      {2056, "Europe/Brussels"},
-      {2057, "Europe/Bucharest"},
-      {2058, "Europe/Budapest"},
-      {2059, "Europe/Chisinau"},
-      {2060, "Europe/Copenhagen"},
-      {2061, "Europe/Dublin"},
-      {2062, "Europe/Gibraltar"},
-      {2063, "Europe/Guernsey"},
-      {2064, "Europe/Helsinki"},
-      {2065, "Europe/Isle_of_Man"},
-      {2066, "Europe/Istanbul"},
-      {2067, "Europe/Jersey"},
-      {2068, "Europe/Kaliningrad"},
-      {2069, "Europe/Kiev"},
-      {2070, "Europe/Lisbon"},
-      {2071, "Europe/Ljubljana"},
-      {2072, "Europe/London"},
-      {2073, "Europe/Luxembourg"},
-      {2074, "Europe/Madrid"},
-      {2075, "Europe/Malta"},
-      {2076, "Europe/Mariehamn"},
-      {2077, "Europe/Minsk"},
-      {2078, "Europe/Monaco"},
-      {2079, "Europe/Moscow"},
-      {2080, "Europe/Nicosia"},
-      {2081, "Europe/Oslo"},
-      {2082, "Europe/Paris"},
-      {2083, "Europe/Podgorica"},
-      {2084, "Europe/Prague"},
-      {2085, "Europe/Riga"},
-      {2086, "Europe/Rome"},
-      {2087, "Europe/Samara"},
-      {2088, "Europe/San_Marino"},
-      {2089, "Europe/Sarajevo"},
-      {2090, "Europe/Simferopol"},
-      {2091, "Europe/Skopje"},
-      {2092, "Europe/Sofia"},
-      {2093, "Europe/Stockholm"},
-      {2094, "Europe/Tallinn"},
-      {2095, "Europe/Tirane"},
-      {2096, "Europe/Tiraspol"},
-      {2097, "Europe/Uzhgorod"},
-      {2098, "Europe/Vaduz"},
-      {2099, "Europe/Vatican"},
-      {2100, "Europe/Vienna"},
-      {2101, "Europe/Vilnius"},
-      {2102, "Europe/Volgograd"},
-      {2103, "Europe/Warsaw"},
-      {2104, "Europe/Zagreb"},
-      {2105, "Europe/Zaporozhye"},
-      {2106, "Europe/Zurich"},
-      {2107, "Indian/Antananarivo"},
-      {2108, "Indian/Chagos"},
-      {2109, "Indian/Christmas"},
-      {2110, "Indian/Cocos"},
-      {2111, "Indian/Comoro"},
-      {2112, "Indian/Kerguelen"},
-      {2113, "Indian/Mahe"},
-      {2114, "Indian/Maldives"},
-      {2115, "Indian/Mauritius"},
-      {2116, "Indian/Mayotte"},
-      {2117, "Indian/Reunion"},
-      {2118, "Mexico/BajaNorte"},
-      {2119, "Mexico/BajaSur"},
-      {2120, "Mexico/General"},
-      {2121, "Pacific/Apia"},
-      {2122, "Pacific/Auckland"},
-      {2123, "Pacific/Chatham"},
-      {2124, "Pacific/Chuuk"},
-      {2125, "Pacific/Easter"},
-      {2126, "Pacific/Efate"},
-      {2127, "Pacific/Enderbury"},
-      {2128, "Pacific/Fakaofo"},
-      {2129, "Pacific/Fiji"},
-      {2130, "Pacific/Funafuti"},
-      {2131, "Pacific/Galapagos"},
-      {2132, "Pacific/Gambier"},
-      {2133, "Pacific/Guadalcanal"},
-      {2134, "Pacific/Guam"},
-      {2135, "Pacific/Honolulu"},
-      {2136, "Pacific/Johnston"},
-      {2137, "Pacific/Kiritimati"},
-      {2138, "Pacific/Kosrae"},
-      {2139, "Pacific/Kwajalein"},
-      {2140, "Pacific/Majuro"},
-      {2141, "Pacific/Marquesas"},
-      {2142, "Pacific/Midway"},
-      {2143, "Pacific/Nauru"},
-      {2144, "Pacific/Niue"},
-      {2145, "Pacific/Norfolk"},
-      {2146, "Pacific/Noumea"},
-      {2147, "Pacific/Pago_Pago"},
-      {2148, "Pacific/Palau"},
-      {2149, "Pacific/Pitcairn"},
-      {2150, "Pacific/Pohnpei"},
-      {2151, "Pacific/Ponape"},
-      {2152, "Pacific/Port_Moresby"},
-      {2153, "Pacific/Rarotonga"},
-      {2154, "Pacific/Saipan"},
-      {2155, "Pacific/Samoa"},
-      {2156, "Pacific/Tahiti"},
-      {2157, "Pacific/Tarawa"},
-      {2158, "Pacific/Tongatapu"},
-      {2159, "Pacific/Truk"},
-      {2160, "Pacific/Wake"},
-      {2161, "Pacific/Wallis"},
-      {2162, "Pacific/Yap"},
-      {2163, "US/Alaska"},
-      {2164, "US/Aleutian"},
-      {2165, "US/Arizona"},
-      {2166, "US/Central"},
-      {2167, "US/East-Indiana"},
-      {2168, "US/Eastern"},
-      {2169, "US/Hawaii"},
-      {2170, "US/Indiana-Starke"},
-      {2171, "US/Michigan"},
-      {2172, "US/Mountain"},
-      {2173, "US/Pacific"},
-      {2175, "US/Samoa"},
-      {2176, "CET"},
-      {2177, "CST6CDT"},
-      {2178, "Cuba"},
-      {2179, "EET"},
-      {2181, "EST5EDT"},
-      {2182, "Egypt"},
-      {2183, "Eire"},
-      {2184, "GB"},
-      {2185, "GB-Eire"},
-      {2187, "Hongkong"},
-      {2188, "Iceland"},
-      {2189, "Iran"},
-      {2190, "Israel"},
-      {2191, "Jamaica"},
-      {2192, "Japan"},
-      {2193, "Kwajalein"},
-      {2194, "Libya"},
-      {2195, "MET"},
-      {2197, "MST7MDT"},
-      {2198, "NZ"},
-      {2199, "NZ-CHAT"},
-      {2200, "Navajo"},
-      {2201, "PRC"},
-      {2202, "PST8PDT"},
-      {2203, "Poland"},
-      {2204, "Portugal"},
-      {2205, "ROK"},
-      {2206, "Singapore"},
-      {2207, "Turkey"},
-      {2208, "W-SU"},
-      {2209, "WET"},
-      {2210, "America/Creston"},
-      {2211, "Antarctica/Troll"},
-      {2212, "Asia/Khandyga"},
-      {2213, "Asia/Ust-Nera"},
-      {2214, "Europe/Busingen"},
-      {2215, "Asia/Chita"},
-      {2216, "Asia/Srednekolymsk"},
-      {2217, "Pacific/Bougainville"},
-      {2218, "America/Fort_Nelson"},
-      {2219, "Asia/Barnaul"},
-      {2220, "Asia/Tomsk"},
-      {2221, "Europe/Astrakhan"},
-      {2222, "Europe/Kirov"},
-      {2223, "Europe/Ulyanovsk"},
-      {2224, "Asia/Yangon"},
-      {2225, "America/Punta_Arenas"},
-      {2226, "Asia/Atyrau"},
-      {2227, "Asia/Famagusta"},
-      {2228, "Europe/Saratov"},
-      {2229, "Asia/Qostanay"},
-      {2230, "America/Nuuk"},
-      {2231, "Pacific/Kanton"},
-      {2232, "Europe/Kyiv"},
-      {2233, "America/Ciudad_Juarez"},
-  };
-  return tzDB;
+const std::vector<std::pair<int16_t, std::string>>& getTimeZoneEntries() {
+  static auto* tzDB = new std::vector<std::pair<int16_t, std::string>>([] {
+    // Work around clang compiler bug causing multi-hour compilation
+    // with -fsanitize=fuzzer
+    // https://github.com/llvm/llvm-project/issues/75666
+    return std::vector<std::pair<int16_t, std::string>>{
+        {0, "+00:00"},
+        {1, "-14:00"},
+        {2, "-13:59"},
+        {3, "-13:58"},
+        {4, "-13:57"},
+        {5, "-13:56"},
+        {6, "-13:55"},
+        {7, "-13:54"},
+        {8, "-13:53"},
+        {9, "-13:52"},
+        {10, "-13:51"},
+        {11, "-13:50"},
+        {12, "-13:49"},
+        {13, "-13:48"},
+        {14, "-13:47"},
+        {15, "-13:46"},
+        {16, "-13:45"},
+        {17, "-13:44"},
+        {18, "-13:43"},
+        {19, "-13:42"},
+        {20, "-13:41"},
+        {21, "-13:40"},
+        {22, "-13:39"},
+        {23, "-13:38"},
+        {24, "-13:37"},
+        {25, "-13:36"},
+        {26, "-13:35"},
+        {27, "-13:34"},
+        {28, "-13:33"},
+        {29, "-13:32"},
+        {30, "-13:31"},
+        {31, "-13:30"},
+        {32, "-13:29"},
+        {33, "-13:28"},
+        {34, "-13:27"},
+        {35, "-13:26"},
+        {36, "-13:25"},
+        {37, "-13:24"},
+        {38, "-13:23"},
+        {39, "-13:22"},
+        {40, "-13:21"},
+        {41, "-13:20"},
+        {42, "-13:19"},
+        {43, "-13:18"},
+        {44, "-13:17"},
+        {45, "-13:16"},
+        {46, "-13:15"},
+        {47, "-13:14"},
+        {48, "-13:13"},
+        {49, "-13:12"},
+        {50, "-13:11"},
+        {51, "-13:10"},
+        {52, "-13:09"},
+        {53, "-13:08"},
+        {54, "-13:07"},
+        {55, "-13:06"},
+        {56, "-13:05"},
+        {57, "-13:04"},
+        {58, "-13:03"},
+        {59, "-13:02"},
+        {60, "-13:01"},
+        {61, "-13:00"},
+        {62, "-12:59"},
+        {63, "-12:58"},
+        {64, "-12:57"},
+        {65, "-12:56"},
+        {66, "-12:55"},
+        {67, "-12:54"},
+        {68, "-12:53"},
+        {69, "-12:52"},
+        {70, "-12:51"},
+        {71, "-12:50"},
+        {72, "-12:49"},
+        {73, "-12:48"},
+        {74, "-12:47"},
+        {75, "-12:46"},
+        {76, "-12:45"},
+        {77, "-12:44"},
+        {78, "-12:43"},
+        {79, "-12:42"},
+        {80, "-12:41"},
+        {81, "-12:40"},
+        {82, "-12:39"},
+        {83, "-12:38"},
+        {84, "-12:37"},
+        {85, "-12:36"},
+        {86, "-12:35"},
+        {87, "-12:34"},
+        {88, "-12:33"},
+        {89, "-12:32"},
+        {90, "-12:31"},
+        {91, "-12:30"},
+        {92, "-12:29"},
+        {93, "-12:28"},
+        {94, "-12:27"},
+        {95, "-12:26"},
+        {96, "-12:25"},
+        {97, "-12:24"},
+        {98, "-12:23"},
+        {99, "-12:22"},
+        {100, "-12:21"},
+        {101, "-12:20"},
+        {102, "-12:19"},
+        {103, "-12:18"},
+        {104, "-12:17"},
+        {105, "-12:16"},
+        {106, "-12:15"},
+        {107, "-12:14"},
+        {108, "-12:13"},
+        {109, "-12:12"},
+        {110, "-12:11"},
+        {111, "-12:10"},
+        {112, "-12:09"},
+        {113, "-12:08"},
+        {114, "-12:07"},
+        {115, "-12:06"},
+        {116, "-12:05"},
+        {117, "-12:04"},
+        {118, "-12:03"},
+        {119, "-12:02"},
+        {120, "-12:01"},
+        {121, "-12:00"},
+        {122, "-11:59"},
+        {123, "-11:58"},
+        {124, "-11:57"},
+        {125, "-11:56"},
+        {126, "-11:55"},
+        {127, "-11:54"},
+        {128, "-11:53"},
+        {129, "-11:52"},
+        {130, "-11:51"},
+        {131, "-11:50"},
+        {132, "-11:49"},
+        {133, "-11:48"},
+        {134, "-11:47"},
+        {135, "-11:46"},
+        {136, "-11:45"},
+        {137, "-11:44"},
+        {138, "-11:43"},
+        {139, "-11:42"},
+        {140, "-11:41"},
+        {141, "-11:40"},
+        {142, "-11:39"},
+        {143, "-11:38"},
+        {144, "-11:37"},
+        {145, "-11:36"},
+        {146, "-11:35"},
+        {147, "-11:34"},
+        {148, "-11:33"},
+        {149, "-11:32"},
+        {150, "-11:31"},
+        {151, "-11:30"},
+        {152, "-11:29"},
+        {153, "-11:28"},
+        {154, "-11:27"},
+        {155, "-11:26"},
+        {156, "-11:25"},
+        {157, "-11:24"},
+        {158, "-11:23"},
+        {159, "-11:22"},
+        {160, "-11:21"},
+        {161, "-11:20"},
+        {162, "-11:19"},
+        {163, "-11:18"},
+        {164, "-11:17"},
+        {165, "-11:16"},
+        {166, "-11:15"},
+        {167, "-11:14"},
+        {168, "-11:13"},
+        {169, "-11:12"},
+        {170, "-11:11"},
+        {171, "-11:10"},
+        {172, "-11:09"},
+        {173, "-11:08"},
+        {174, "-11:07"},
+        {175, "-11:06"},
+        {176, "-11:05"},
+        {177, "-11:04"},
+        {178, "-11:03"},
+        {179, "-11:02"},
+        {180, "-11:01"},
+        {181, "-11:00"},
+        {182, "-10:59"},
+        {183, "-10:58"},
+        {184, "-10:57"},
+        {185, "-10:56"},
+        {186, "-10:55"},
+        {187, "-10:54"},
+        {188, "-10:53"},
+        {189, "-10:52"},
+        {190, "-10:51"},
+        {191, "-10:50"},
+        {192, "-10:49"},
+        {193, "-10:48"},
+        {194, "-10:47"},
+        {195, "-10:46"},
+        {196, "-10:45"},
+        {197, "-10:44"},
+        {198, "-10:43"},
+        {199, "-10:42"},
+        {200, "-10:41"},
+        {201, "-10:40"},
+        {202, "-10:39"},
+        {203, "-10:38"},
+        {204, "-10:37"},
+        {205, "-10:36"},
+        {206, "-10:35"},
+        {207, "-10:34"},
+        {208, "-10:33"},
+        {209, "-10:32"},
+        {210, "-10:31"},
+        {211, "-10:30"},
+        {212, "-10:29"},
+        {213, "-10:28"},
+        {214, "-10:27"},
+        {215, "-10:26"},
+        {216, "-10:25"},
+        {217, "-10:24"},
+        {218, "-10:23"},
+        {219, "-10:22"},
+        {220, "-10:21"},
+        {221, "-10:20"},
+        {222, "-10:19"},
+        {223, "-10:18"},
+        {224, "-10:17"},
+        {225, "-10:16"},
+        {226, "-10:15"},
+        {227, "-10:14"},
+        {228, "-10:13"},
+        {229, "-10:12"},
+        {230, "-10:11"},
+        {231, "-10:10"},
+        {232, "-10:09"},
+        {233, "-10:08"},
+        {234, "-10:07"},
+        {235, "-10:06"},
+        {236, "-10:05"},
+        {237, "-10:04"},
+        {238, "-10:03"},
+        {239, "-10:02"},
+        {240, "-10:01"},
+        {241, "-10:00"},
+        {242, "-09:59"},
+        {243, "-09:58"},
+        {244, "-09:57"},
+        {245, "-09:56"},
+        {246, "-09:55"},
+        {247, "-09:54"},
+        {248, "-09:53"},
+        {249, "-09:52"},
+        {250, "-09:51"},
+        {251, "-09:50"},
+        {252, "-09:49"},
+        {253, "-09:48"},
+        {254, "-09:47"},
+        {255, "-09:46"},
+        {256, "-09:45"},
+        {257, "-09:44"},
+        {258, "-09:43"},
+        {259, "-09:42"},
+        {260, "-09:41"},
+        {261, "-09:40"},
+        {262, "-09:39"},
+        {263, "-09:38"},
+        {264, "-09:37"},
+        {265, "-09:36"},
+        {266, "-09:35"},
+        {267, "-09:34"},
+        {268, "-09:33"},
+        {269, "-09:32"},
+        {270, "-09:31"},
+        {271, "-09:30"},
+        {272, "-09:29"},
+        {273, "-09:28"},
+        {274, "-09:27"},
+        {275, "-09:26"},
+        {276, "-09:25"},
+        {277, "-09:24"},
+        {278, "-09:23"},
+        {279, "-09:22"},
+        {280, "-09:21"},
+        {281, "-09:20"},
+        {282, "-09:19"},
+        {283, "-09:18"},
+        {284, "-09:17"},
+        {285, "-09:16"},
+        {286, "-09:15"},
+        {287, "-09:14"},
+        {288, "-09:13"},
+        {289, "-09:12"},
+        {290, "-09:11"},
+        {291, "-09:10"},
+        {292, "-09:09"},
+        {293, "-09:08"},
+        {294, "-09:07"},
+        {295, "-09:06"},
+        {296, "-09:05"},
+        {297, "-09:04"},
+        {298, "-09:03"},
+        {299, "-09:02"},
+        {300, "-09:01"},
+        {301, "-09:00"},
+        {302, "-08:59"},
+        {303, "-08:58"},
+        {304, "-08:57"},
+        {305, "-08:56"},
+        {306, "-08:55"},
+        {307, "-08:54"},
+        {308, "-08:53"},
+        {309, "-08:52"},
+        {310, "-08:51"},
+        {311, "-08:50"},
+        {312, "-08:49"},
+        {313, "-08:48"},
+        {314, "-08:47"},
+        {315, "-08:46"},
+        {316, "-08:45"},
+        {317, "-08:44"},
+        {318, "-08:43"},
+        {319, "-08:42"},
+        {320, "-08:41"},
+        {321, "-08:40"},
+        {322, "-08:39"},
+        {323, "-08:38"},
+        {324, "-08:37"},
+        {325, "-08:36"},
+        {326, "-08:35"},
+        {327, "-08:34"},
+        {328, "-08:33"},
+        {329, "-08:32"},
+        {330, "-08:31"},
+        {331, "-08:30"},
+        {332, "-08:29"},
+        {333, "-08:28"},
+        {334, "-08:27"},
+        {335, "-08:26"},
+        {336, "-08:25"},
+        {337, "-08:24"},
+        {338, "-08:23"},
+        {339, "-08:22"},
+        {340, "-08:21"},
+        {341, "-08:20"},
+        {342, "-08:19"},
+        {343, "-08:18"},
+        {344, "-08:17"},
+        {345, "-08:16"},
+        {346, "-08:15"},
+        {347, "-08:14"},
+        {348, "-08:13"},
+        {349, "-08:12"},
+        {350, "-08:11"},
+        {351, "-08:10"},
+        {352, "-08:09"},
+        {353, "-08:08"},
+        {354, "-08:07"},
+        {355, "-08:06"},
+        {356, "-08:05"},
+        {357, "-08:04"},
+        {358, "-08:03"},
+        {359, "-08:02"},
+        {360, "-08:01"},
+        {361, "-08:00"},
+        {362, "-07:59"},
+        {363, "-07:58"},
+        {364, "-07:57"},
+        {365, "-07:56"},
+        {366, "-07:55"},
+        {367, "-07:54"},
+        {368, "-07:53"},
+        {369, "-07:52"},
+        {370, "-07:51"},
+        {371, "-07:50"},
+        {372, "-07:49"},
+        {373, "-07:48"},
+        {374, "-07:47"},
+        {375, "-07:46"},
+        {376, "-07:45"},
+        {377, "-07:44"},
+        {378, "-07:43"},
+        {379, "-07:42"},
+        {380, "-07:41"},
+        {381, "-07:40"},
+        {382, "-07:39"},
+        {383, "-07:38"},
+        {384, "-07:37"},
+        {385, "-07:36"},
+        {386, "-07:35"},
+        {387, "-07:34"},
+        {388, "-07:33"},
+        {389, "-07:32"},
+        {390, "-07:31"},
+        {391, "-07:30"},
+        {392, "-07:29"},
+        {393, "-07:28"},
+        {394, "-07:27"},
+        {395, "-07:26"},
+        {396, "-07:25"},
+        {397, "-07:24"},
+        {398, "-07:23"},
+        {399, "-07:22"},
+        {400, "-07:21"},
+        {401, "-07:20"},
+        {402, "-07:19"},
+        {403, "-07:18"},
+        {404, "-07:17"},
+        {405, "-07:16"},
+        {406, "-07:15"},
+        {407, "-07:14"},
+        {408, "-07:13"},
+        {409, "-07:12"},
+        {410, "-07:11"},
+        {411, "-07:10"},
+        {412, "-07:09"},
+        {413, "-07:08"},
+        {414, "-07:07"},
+        {415, "-07:06"},
+        {416, "-07:05"},
+        {417, "-07:04"},
+        {418, "-07:03"},
+        {419, "-07:02"},
+        {420, "-07:01"},
+        {421, "-07:00"},
+        {422, "-06:59"},
+        {423, "-06:58"},
+        {424, "-06:57"},
+        {425, "-06:56"},
+        {426, "-06:55"},
+        {427, "-06:54"},
+        {428, "-06:53"},
+        {429, "-06:52"},
+        {430, "-06:51"},
+        {431, "-06:50"},
+        {432, "-06:49"},
+        {433, "-06:48"},
+        {434, "-06:47"},
+        {435, "-06:46"},
+        {436, "-06:45"},
+        {437, "-06:44"},
+        {438, "-06:43"},
+        {439, "-06:42"},
+        {440, "-06:41"},
+        {441, "-06:40"},
+        {442, "-06:39"},
+        {443, "-06:38"},
+        {444, "-06:37"},
+        {445, "-06:36"},
+        {446, "-06:35"},
+        {447, "-06:34"},
+        {448, "-06:33"},
+        {449, "-06:32"},
+        {450, "-06:31"},
+        {451, "-06:30"},
+        {452, "-06:29"},
+        {453, "-06:28"},
+        {454, "-06:27"},
+        {455, "-06:26"},
+        {456, "-06:25"},
+        {457, "-06:24"},
+        {458, "-06:23"},
+        {459, "-06:22"},
+        {460, "-06:21"},
+        {461, "-06:20"},
+        {462, "-06:19"},
+        {463, "-06:18"},
+        {464, "-06:17"},
+        {465, "-06:16"},
+        {466, "-06:15"},
+        {467, "-06:14"},
+        {468, "-06:13"},
+        {469, "-06:12"},
+        {470, "-06:11"},
+        {471, "-06:10"},
+        {472, "-06:09"},
+        {473, "-06:08"},
+        {474, "-06:07"},
+        {475, "-06:06"},
+        {476, "-06:05"},
+        {477, "-06:04"},
+        {478, "-06:03"},
+        {479, "-06:02"},
+        {480, "-06:01"},
+        {481, "-06:00"},
+        {482, "-05:59"},
+        {483, "-05:58"},
+        {484, "-05:57"},
+        {485, "-05:56"},
+        {486, "-05:55"},
+        {487, "-05:54"},
+        {488, "-05:53"},
+        {489, "-05:52"},
+        {490, "-05:51"},
+        {491, "-05:50"},
+        {492, "-05:49"},
+        {493, "-05:48"},
+        {494, "-05:47"},
+        {495, "-05:46"},
+        {496, "-05:45"},
+        {497, "-05:44"},
+        {498, "-05:43"},
+        {499, "-05:42"},
+        {500, "-05:41"},
+        {501, "-05:40"},
+        {502, "-05:39"},
+        {503, "-05:38"},
+        {504, "-05:37"},
+        {505, "-05:36"},
+        {506, "-05:35"},
+        {507, "-05:34"},
+        {508, "-05:33"},
+        {509, "-05:32"},
+        {510, "-05:31"},
+        {511, "-05:30"},
+        {512, "-05:29"},
+        {513, "-05:28"},
+        {514, "-05:27"},
+        {515, "-05:26"},
+        {516, "-05:25"},
+        {517, "-05:24"},
+        {518, "-05:23"},
+        {519, "-05:22"},
+        {520, "-05:21"},
+        {521, "-05:20"},
+        {522, "-05:19"},
+        {523, "-05:18"},
+        {524, "-05:17"},
+        {525, "-05:16"},
+        {526, "-05:15"},
+        {527, "-05:14"},
+        {528, "-05:13"},
+        {529, "-05:12"},
+        {530, "-05:11"},
+        {531, "-05:10"},
+        {532, "-05:09"},
+        {533, "-05:08"},
+        {534, "-05:07"},
+        {535, "-05:06"},
+        {536, "-05:05"},
+        {537, "-05:04"},
+        {538, "-05:03"},
+        {539, "-05:02"},
+        {540, "-05:01"},
+        {541, "-05:00"},
+        {542, "-04:59"},
+        {543, "-04:58"},
+        {544, "-04:57"},
+        {545, "-04:56"},
+        {546, "-04:55"},
+        {547, "-04:54"},
+        {548, "-04:53"},
+        {549, "-04:52"},
+        {550, "-04:51"},
+        {551, "-04:50"},
+        {552, "-04:49"},
+        {553, "-04:48"},
+        {554, "-04:47"},
+        {555, "-04:46"},
+        {556, "-04:45"},
+        {557, "-04:44"},
+        {558, "-04:43"},
+        {559, "-04:42"},
+        {560, "-04:41"},
+        {561, "-04:40"},
+        {562, "-04:39"},
+        {563, "-04:38"},
+        {564, "-04:37"},
+        {565, "-04:36"},
+        {566, "-04:35"},
+        {567, "-04:34"},
+        {568, "-04:33"},
+        {569, "-04:32"},
+        {570, "-04:31"},
+        {571, "-04:30"},
+        {572, "-04:29"},
+        {573, "-04:28"},
+        {574, "-04:27"},
+        {575, "-04:26"},
+        {576, "-04:25"},
+        {577, "-04:24"},
+        {578, "-04:23"},
+        {579, "-04:22"},
+        {580, "-04:21"},
+        {581, "-04:20"},
+        {582, "-04:19"},
+        {583, "-04:18"},
+        {584, "-04:17"},
+        {585, "-04:16"},
+        {586, "-04:15"},
+        {587, "-04:14"},
+        {588, "-04:13"},
+        {589, "-04:12"},
+        {590, "-04:11"},
+        {591, "-04:10"},
+        {592, "-04:09"},
+        {593, "-04:08"},
+        {594, "-04:07"},
+        {595, "-04:06"},
+        {596, "-04:05"},
+        {597, "-04:04"},
+        {598, "-04:03"},
+        {599, "-04:02"},
+        {600, "-04:01"},
+        {601, "-04:00"},
+        {602, "-03:59"},
+        {603, "-03:58"},
+        {604, "-03:57"},
+        {605, "-03:56"},
+        {606, "-03:55"},
+        {607, "-03:54"},
+        {608, "-03:53"},
+        {609, "-03:52"},
+        {610, "-03:51"},
+        {611, "-03:50"},
+        {612, "-03:49"},
+        {613, "-03:48"},
+        {614, "-03:47"},
+        {615, "-03:46"},
+        {616, "-03:45"},
+        {617, "-03:44"},
+        {618, "-03:43"},
+        {619, "-03:42"},
+        {620, "-03:41"},
+        {621, "-03:40"},
+        {622, "-03:39"},
+        {623, "-03:38"},
+        {624, "-03:37"},
+        {625, "-03:36"},
+        {626, "-03:35"},
+        {627, "-03:34"},
+        {628, "-03:33"},
+        {629, "-03:32"},
+        {630, "-03:31"},
+        {631, "-03:30"},
+        {632, "-03:29"},
+        {633, "-03:28"},
+        {634, "-03:27"},
+        {635, "-03:26"},
+        {636, "-03:25"},
+        {637, "-03:24"},
+        {638, "-03:23"},
+        {639, "-03:22"},
+        {640, "-03:21"},
+        {641, "-03:20"},
+        {642, "-03:19"},
+        {643, "-03:18"},
+        {644, "-03:17"},
+        {645, "-03:16"},
+        {646, "-03:15"},
+        {647, "-03:14"},
+        {648, "-03:13"},
+        {649, "-03:12"},
+        {650, "-03:11"},
+        {651, "-03:10"},
+        {652, "-03:09"},
+        {653, "-03:08"},
+        {654, "-03:07"},
+        {655, "-03:06"},
+        {656, "-03:05"},
+        {657, "-03:04"},
+        {658, "-03:03"},
+        {659, "-03:02"},
+        {660, "-03:01"},
+        {661, "-03:00"},
+        {662, "-02:59"},
+        {663, "-02:58"},
+        {664, "-02:57"},
+        {665, "-02:56"},
+        {666, "-02:55"},
+        {667, "-02:54"},
+        {668, "-02:53"},
+        {669, "-02:52"},
+        {670, "-02:51"},
+        {671, "-02:50"},
+        {672, "-02:49"},
+        {673, "-02:48"},
+        {674, "-02:47"},
+        {675, "-02:46"},
+        {676, "-02:45"},
+        {677, "-02:44"},
+        {678, "-02:43"},
+        {679, "-02:42"},
+        {680, "-02:41"},
+        {681, "-02:40"},
+        {682, "-02:39"},
+        {683, "-02:38"},
+        {684, "-02:37"},
+        {685, "-02:36"},
+        {686, "-02:35"},
+        {687, "-02:34"},
+        {688, "-02:33"},
+        {689, "-02:32"},
+        {690, "-02:31"},
+        {691, "-02:30"},
+        {692, "-02:29"},
+        {693, "-02:28"},
+        {694, "-02:27"},
+        {695, "-02:26"},
+        {696, "-02:25"},
+        {697, "-02:24"},
+        {698, "-02:23"},
+        {699, "-02:22"},
+        {700, "-02:21"},
+        {701, "-02:20"},
+        {702, "-02:19"},
+        {703, "-02:18"},
+        {704, "-02:17"},
+        {705, "-02:16"},
+        {706, "-02:15"},
+        {707, "-02:14"},
+        {708, "-02:13"},
+        {709, "-02:12"},
+        {710, "-02:11"},
+        {711, "-02:10"},
+        {712, "-02:09"},
+        {713, "-02:08"},
+        {714, "-02:07"},
+        {715, "-02:06"},
+        {716, "-02:05"},
+        {717, "-02:04"},
+        {718, "-02:03"},
+        {719, "-02:02"},
+        {720, "-02:01"},
+        {721, "-02:00"},
+        {722, "-01:59"},
+        {723, "-01:58"},
+        {724, "-01:57"},
+        {725, "-01:56"},
+        {726, "-01:55"},
+        {727, "-01:54"},
+        {728, "-01:53"},
+        {729, "-01:52"},
+        {730, "-01:51"},
+        {731, "-01:50"},
+        {732, "-01:49"},
+        {733, "-01:48"},
+        {734, "-01:47"},
+        {735, "-01:46"},
+        {736, "-01:45"},
+        {737, "-01:44"},
+        {738, "-01:43"},
+        {739, "-01:42"},
+        {740, "-01:41"},
+        {741, "-01:40"},
+        {742, "-01:39"},
+        {743, "-01:38"},
+        {744, "-01:37"},
+        {745, "-01:36"},
+        {746, "-01:35"},
+        {747, "-01:34"},
+        {748, "-01:33"},
+        {749, "-01:32"},
+        {750, "-01:31"},
+        {751, "-01:30"},
+        {752, "-01:29"},
+        {753, "-01:28"},
+        {754, "-01:27"},
+        {755, "-01:26"},
+        {756, "-01:25"},
+        {757, "-01:24"},
+        {758, "-01:23"},
+        {759, "-01:22"},
+        {760, "-01:21"},
+        {761, "-01:20"},
+        {762, "-01:19"},
+        {763, "-01:18"},
+        {764, "-01:17"},
+        {765, "-01:16"},
+        {766, "-01:15"},
+        {767, "-01:14"},
+        {768, "-01:13"},
+        {769, "-01:12"},
+        {770, "-01:11"},
+        {771, "-01:10"},
+        {772, "-01:09"},
+        {773, "-01:08"},
+        {774, "-01:07"},
+        {775, "-01:06"},
+        {776, "-01:05"},
+        {777, "-01:04"},
+        {778, "-01:03"},
+        {779, "-01:02"},
+        {780, "-01:01"},
+        {781, "-01:00"},
+        {782, "-00:59"},
+        {783, "-00:58"},
+        {784, "-00:57"},
+        {785, "-00:56"},
+        {786, "-00:55"},
+        {787, "-00:54"},
+        {788, "-00:53"},
+        {789, "-00:52"},
+        {790, "-00:51"},
+        {791, "-00:50"},
+        {792, "-00:49"},
+        {793, "-00:48"},
+        {794, "-00:47"},
+        {795, "-00:46"},
+        {796, "-00:45"},
+        {797, "-00:44"},
+        {798, "-00:43"},
+        {799, "-00:42"},
+        {800, "-00:41"},
+        {801, "-00:40"},
+        {802, "-00:39"},
+        {803, "-00:38"},
+        {804, "-00:37"},
+        {805, "-00:36"},
+        {806, "-00:35"},
+        {807, "-00:34"},
+        {808, "-00:33"},
+        {809, "-00:32"},
+        {810, "-00:31"},
+        {811, "-00:30"},
+        {812, "-00:29"},
+        {813, "-00:28"},
+        {814, "-00:27"},
+        {815, "-00:26"},
+        {816, "-00:25"},
+        {817, "-00:24"},
+        {818, "-00:23"},
+        {819, "-00:22"},
+        {820, "-00:21"},
+        {821, "-00:20"},
+        {822, "-00:19"},
+        {823, "-00:18"},
+        {824, "-00:17"},
+        {825, "-00:16"},
+        {826, "-00:15"},
+        {827, "-00:14"},
+        {828, "-00:13"},
+        {829, "-00:12"},
+        {830, "-00:11"},
+        {831, "-00:10"},
+        {832, "-00:09"},
+        {833, "-00:08"},
+        {834, "-00:07"},
+        {835, "-00:06"},
+        {836, "-00:05"},
+        {837, "-00:04"},
+        {838, "-00:03"},
+        {839, "-00:02"},
+        {840, "-00:01"},
+        {841, "+00:01"},
+        {842, "+00:02"},
+        {843, "+00:03"},
+        {844, "+00:04"},
+        {845, "+00:05"},
+        {846, "+00:06"},
+        {847, "+00:07"},
+        {848, "+00:08"},
+        {849, "+00:09"},
+        {850, "+00:10"},
+        {851, "+00:11"},
+        {852, "+00:12"},
+        {853, "+00:13"},
+        {854, "+00:14"},
+        {855, "+00:15"},
+        {856, "+00:16"},
+        {857, "+00:17"},
+        {858, "+00:18"},
+        {859, "+00:19"},
+        {860, "+00:20"},
+        {861, "+00:21"},
+        {862, "+00:22"},
+        {863, "+00:23"},
+        {864, "+00:24"},
+        {865, "+00:25"},
+        {866, "+00:26"},
+        {867, "+00:27"},
+        {868, "+00:28"},
+        {869, "+00:29"},
+        {870, "+00:30"},
+        {871, "+00:31"},
+        {872, "+00:32"},
+        {873, "+00:33"},
+        {874, "+00:34"},
+        {875, "+00:35"},
+        {876, "+00:36"},
+        {877, "+00:37"},
+        {878, "+00:38"},
+        {879, "+00:39"},
+        {880, "+00:40"},
+        {881, "+00:41"},
+        {882, "+00:42"},
+        {883, "+00:43"},
+        {884, "+00:44"},
+        {885, "+00:45"},
+        {886, "+00:46"},
+        {887, "+00:47"},
+        {888, "+00:48"},
+        {889, "+00:49"},
+        {890, "+00:50"},
+        {891, "+00:51"},
+        {892, "+00:52"},
+        {893, "+00:53"},
+        {894, "+00:54"},
+        {895, "+00:55"},
+        {896, "+00:56"},
+        {897, "+00:57"},
+        {898, "+00:58"},
+        {899, "+00:59"},
+        {900, "+01:00"},
+        {901, "+01:01"},
+        {902, "+01:02"},
+        {903, "+01:03"},
+        {904, "+01:04"},
+        {905, "+01:05"},
+        {906, "+01:06"},
+        {907, "+01:07"},
+        {908, "+01:08"},
+        {909, "+01:09"},
+        {910, "+01:10"},
+        {911, "+01:11"},
+        {912, "+01:12"},
+        {913, "+01:13"},
+        {914, "+01:14"},
+        {915, "+01:15"},
+        {916, "+01:16"},
+        {917, "+01:17"},
+        {918, "+01:18"},
+        {919, "+01:19"},
+        {920, "+01:20"},
+        {921, "+01:21"},
+        {922, "+01:22"},
+        {923, "+01:23"},
+        {924, "+01:24"},
+        {925, "+01:25"},
+        {926, "+01:26"},
+        {927, "+01:27"},
+        {928, "+01:28"},
+        {929, "+01:29"},
+        {930, "+01:30"},
+        {931, "+01:31"},
+        {932, "+01:32"},
+        {933, "+01:33"},
+        {934, "+01:34"},
+        {935, "+01:35"},
+        {936, "+01:36"},
+        {937, "+01:37"},
+        {938, "+01:38"},
+        {939, "+01:39"},
+        {940, "+01:40"},
+        {941, "+01:41"},
+        {942, "+01:42"},
+        {943, "+01:43"},
+        {944, "+01:44"},
+        {945, "+01:45"},
+        {946, "+01:46"},
+        {947, "+01:47"},
+        {948, "+01:48"},
+        {949, "+01:49"},
+        {950, "+01:50"},
+        {951, "+01:51"},
+        {952, "+01:52"},
+        {953, "+01:53"},
+        {954, "+01:54"},
+        {955, "+01:55"},
+        {956, "+01:56"},
+        {957, "+01:57"},
+        {958, "+01:58"},
+        {959, "+01:59"},
+        {960, "+02:00"},
+        {961, "+02:01"},
+        {962, "+02:02"},
+        {963, "+02:03"},
+        {964, "+02:04"},
+        {965, "+02:05"},
+        {966, "+02:06"},
+        {967, "+02:07"},
+        {968, "+02:08"},
+        {969, "+02:09"},
+        {970, "+02:10"},
+        {971, "+02:11"},
+        {972, "+02:12"},
+        {973, "+02:13"},
+        {974, "+02:14"},
+        {975, "+02:15"},
+        {976, "+02:16"},
+        {977, "+02:17"},
+        {978, "+02:18"},
+        {979, "+02:19"},
+        {980, "+02:20"},
+        {981, "+02:21"},
+        {982, "+02:22"},
+        {983, "+02:23"},
+        {984, "+02:24"},
+        {985, "+02:25"},
+        {986, "+02:26"},
+        {987, "+02:27"},
+        {988, "+02:28"},
+        {989, "+02:29"},
+        {990, "+02:30"},
+        {991, "+02:31"},
+        {992, "+02:32"},
+        {993, "+02:33"},
+        {994, "+02:34"},
+        {995, "+02:35"},
+        {996, "+02:36"},
+        {997, "+02:37"},
+        {998, "+02:38"},
+        {999, "+02:39"},
+        {1000, "+02:40"},
+        {1001, "+02:41"},
+        {1002, "+02:42"},
+        {1003, "+02:43"},
+        {1004, "+02:44"},
+        {1005, "+02:45"},
+        {1006, "+02:46"},
+        {1007, "+02:47"},
+        {1008, "+02:48"},
+        {1009, "+02:49"},
+        {1010, "+02:50"},
+        {1011, "+02:51"},
+        {1012, "+02:52"},
+        {1013, "+02:53"},
+        {1014, "+02:54"},
+        {1015, "+02:55"},
+        {1016, "+02:56"},
+        {1017, "+02:57"},
+        {1018, "+02:58"},
+        {1019, "+02:59"},
+        {1020, "+03:00"},
+        {1021, "+03:01"},
+        {1022, "+03:02"},
+        {1023, "+03:03"},
+        {1024, "+03:04"},
+        {1025, "+03:05"},
+        {1026, "+03:06"},
+        {1027, "+03:07"},
+        {1028, "+03:08"},
+        {1029, "+03:09"},
+        {1030, "+03:10"},
+        {1031, "+03:11"},
+        {1032, "+03:12"},
+        {1033, "+03:13"},
+        {1034, "+03:14"},
+        {1035, "+03:15"},
+        {1036, "+03:16"},
+        {1037, "+03:17"},
+        {1038, "+03:18"},
+        {1039, "+03:19"},
+        {1040, "+03:20"},
+        {1041, "+03:21"},
+        {1042, "+03:22"},
+        {1043, "+03:23"},
+        {1044, "+03:24"},
+        {1045, "+03:25"},
+        {1046, "+03:26"},
+        {1047, "+03:27"},
+        {1048, "+03:28"},
+        {1049, "+03:29"},
+        {1050, "+03:30"},
+        {1051, "+03:31"},
+        {1052, "+03:32"},
+        {1053, "+03:33"},
+        {1054, "+03:34"},
+        {1055, "+03:35"},
+        {1056, "+03:36"},
+        {1057, "+03:37"},
+        {1058, "+03:38"},
+        {1059, "+03:39"},
+        {1060, "+03:40"},
+        {1061, "+03:41"},
+        {1062, "+03:42"},
+        {1063, "+03:43"},
+        {1064, "+03:44"},
+        {1065, "+03:45"},
+        {1066, "+03:46"},
+        {1067, "+03:47"},
+        {1068, "+03:48"},
+        {1069, "+03:49"},
+        {1070, "+03:50"},
+        {1071, "+03:51"},
+        {1072, "+03:52"},
+        {1073, "+03:53"},
+        {1074, "+03:54"},
+        {1075, "+03:55"},
+        {1076, "+03:56"},
+        {1077, "+03:57"},
+        {1078, "+03:58"},
+        {1079, "+03:59"},
+        {1080, "+04:00"},
+        {1081, "+04:01"},
+        {1082, "+04:02"},
+        {1083, "+04:03"},
+        {1084, "+04:04"},
+        {1085, "+04:05"},
+        {1086, "+04:06"},
+        {1087, "+04:07"},
+        {1088, "+04:08"},
+        {1089, "+04:09"},
+        {1090, "+04:10"},
+        {1091, "+04:11"},
+        {1092, "+04:12"},
+        {1093, "+04:13"},
+        {1094, "+04:14"},
+        {1095, "+04:15"},
+        {1096, "+04:16"},
+        {1097, "+04:17"},
+        {1098, "+04:18"},
+        {1099, "+04:19"},
+        {1100, "+04:20"},
+        {1101, "+04:21"},
+        {1102, "+04:22"},
+        {1103, "+04:23"},
+        {1104, "+04:24"},
+        {1105, "+04:25"},
+        {1106, "+04:26"},
+        {1107, "+04:27"},
+        {1108, "+04:28"},
+        {1109, "+04:29"},
+        {1110, "+04:30"},
+        {1111, "+04:31"},
+        {1112, "+04:32"},
+        {1113, "+04:33"},
+        {1114, "+04:34"},
+        {1115, "+04:35"},
+        {1116, "+04:36"},
+        {1117, "+04:37"},
+        {1118, "+04:38"},
+        {1119, "+04:39"},
+        {1120, "+04:40"},
+        {1121, "+04:41"},
+        {1122, "+04:42"},
+        {1123, "+04:43"},
+        {1124, "+04:44"},
+        {1125, "+04:45"},
+        {1126, "+04:46"},
+        {1127, "+04:47"},
+        {1128, "+04:48"},
+        {1129, "+04:49"},
+        {1130, "+04:50"},
+        {1131, "+04:51"},
+        {1132, "+04:52"},
+        {1133, "+04:53"},
+        {1134, "+04:54"},
+        {1135, "+04:55"},
+        {1136, "+04:56"},
+        {1137, "+04:57"},
+        {1138, "+04:58"},
+        {1139, "+04:59"},
+        {1140, "+05:00"},
+        {1141, "+05:01"},
+        {1142, "+05:02"},
+        {1143, "+05:03"},
+        {1144, "+05:04"},
+        {1145, "+05:05"},
+        {1146, "+05:06"},
+        {1147, "+05:07"},
+        {1148, "+05:08"},
+        {1149, "+05:09"},
+        {1150, "+05:10"},
+        {1151, "+05:11"},
+        {1152, "+05:12"},
+        {1153, "+05:13"},
+        {1154, "+05:14"},
+        {1155, "+05:15"},
+        {1156, "+05:16"},
+        {1157, "+05:17"},
+        {1158, "+05:18"},
+        {1159, "+05:19"},
+        {1160, "+05:20"},
+        {1161, "+05:21"},
+        {1162, "+05:22"},
+        {1163, "+05:23"},
+        {1164, "+05:24"},
+        {1165, "+05:25"},
+        {1166, "+05:26"},
+        {1167, "+05:27"},
+        {1168, "+05:28"},
+        {1169, "+05:29"},
+        {1170, "+05:30"},
+        {1171, "+05:31"},
+        {1172, "+05:32"},
+        {1173, "+05:33"},
+        {1174, "+05:34"},
+        {1175, "+05:35"},
+        {1176, "+05:36"},
+        {1177, "+05:37"},
+        {1178, "+05:38"},
+        {1179, "+05:39"},
+        {1180, "+05:40"},
+        {1181, "+05:41"},
+        {1182, "+05:42"},
+        {1183, "+05:43"},
+        {1184, "+05:44"},
+        {1185, "+05:45"},
+        {1186, "+05:46"},
+        {1187, "+05:47"},
+        {1188, "+05:48"},
+        {1189, "+05:49"},
+        {1190, "+05:50"},
+        {1191, "+05:51"},
+        {1192, "+05:52"},
+        {1193, "+05:53"},
+        {1194, "+05:54"},
+        {1195, "+05:55"},
+        {1196, "+05:56"},
+        {1197, "+05:57"},
+        {1198, "+05:58"},
+        {1199, "+05:59"},
+        {1200, "+06:00"},
+        {1201, "+06:01"},
+        {1202, "+06:02"},
+        {1203, "+06:03"},
+        {1204, "+06:04"},
+        {1205, "+06:05"},
+        {1206, "+06:06"},
+        {1207, "+06:07"},
+        {1208, "+06:08"},
+        {1209, "+06:09"},
+        {1210, "+06:10"},
+        {1211, "+06:11"},
+        {1212, "+06:12"},
+        {1213, "+06:13"},
+        {1214, "+06:14"},
+        {1215, "+06:15"},
+        {1216, "+06:16"},
+        {1217, "+06:17"},
+        {1218, "+06:18"},
+        {1219, "+06:19"},
+        {1220, "+06:20"},
+        {1221, "+06:21"},
+        {1222, "+06:22"},
+        {1223, "+06:23"},
+        {1224, "+06:24"},
+        {1225, "+06:25"},
+        {1226, "+06:26"},
+        {1227, "+06:27"},
+        {1228, "+06:28"},
+        {1229, "+06:29"},
+        {1230, "+06:30"},
+        {1231, "+06:31"},
+        {1232, "+06:32"},
+        {1233, "+06:33"},
+        {1234, "+06:34"},
+        {1235, "+06:35"},
+        {1236, "+06:36"},
+        {1237, "+06:37"},
+        {1238, "+06:38"},
+        {1239, "+06:39"},
+        {1240, "+06:40"},
+        {1241, "+06:41"},
+        {1242, "+06:42"},
+        {1243, "+06:43"},
+        {1244, "+06:44"},
+        {1245, "+06:45"},
+        {1246, "+06:46"},
+        {1247, "+06:47"},
+        {1248, "+06:48"},
+        {1249, "+06:49"},
+        {1250, "+06:50"},
+        {1251, "+06:51"},
+        {1252, "+06:52"},
+        {1253, "+06:53"},
+        {1254, "+06:54"},
+        {1255, "+06:55"},
+        {1256, "+06:56"},
+        {1257, "+06:57"},
+        {1258, "+06:58"},
+        {1259, "+06:59"},
+        {1260, "+07:00"},
+        {1261, "+07:01"},
+        {1262, "+07:02"},
+        {1263, "+07:03"},
+        {1264, "+07:04"},
+        {1265, "+07:05"},
+        {1266, "+07:06"},
+        {1267, "+07:07"},
+        {1268, "+07:08"},
+        {1269, "+07:09"},
+        {1270, "+07:10"},
+        {1271, "+07:11"},
+        {1272, "+07:12"},
+        {1273, "+07:13"},
+        {1274, "+07:14"},
+        {1275, "+07:15"},
+        {1276, "+07:16"},
+        {1277, "+07:17"},
+        {1278, "+07:18"},
+        {1279, "+07:19"},
+        {1280, "+07:20"},
+        {1281, "+07:21"},
+        {1282, "+07:22"},
+        {1283, "+07:23"},
+        {1284, "+07:24"},
+        {1285, "+07:25"},
+        {1286, "+07:26"},
+        {1287, "+07:27"},
+        {1288, "+07:28"},
+        {1289, "+07:29"},
+        {1290, "+07:30"},
+        {1291, "+07:31"},
+        {1292, "+07:32"},
+        {1293, "+07:33"},
+        {1294, "+07:34"},
+        {1295, "+07:35"},
+        {1296, "+07:36"},
+        {1297, "+07:37"},
+        {1298, "+07:38"},
+        {1299, "+07:39"},
+        {1300, "+07:40"},
+        {1301, "+07:41"},
+        {1302, "+07:42"},
+        {1303, "+07:43"},
+        {1304, "+07:44"},
+        {1305, "+07:45"},
+        {1306, "+07:46"},
+        {1307, "+07:47"},
+        {1308, "+07:48"},
+        {1309, "+07:49"},
+        {1310, "+07:50"},
+        {1311, "+07:51"},
+        {1312, "+07:52"},
+        {1313, "+07:53"},
+        {1314, "+07:54"},
+        {1315, "+07:55"},
+        {1316, "+07:56"},
+        {1317, "+07:57"},
+        {1318, "+07:58"},
+        {1319, "+07:59"},
+        {1320, "+08:00"},
+        {1321, "+08:01"},
+        {1322, "+08:02"},
+        {1323, "+08:03"},
+        {1324, "+08:04"},
+        {1325, "+08:05"},
+        {1326, "+08:06"},
+        {1327, "+08:07"},
+        {1328, "+08:08"},
+        {1329, "+08:09"},
+        {1330, "+08:10"},
+        {1331, "+08:11"},
+        {1332, "+08:12"},
+        {1333, "+08:13"},
+        {1334, "+08:14"},
+        {1335, "+08:15"},
+        {1336, "+08:16"},
+        {1337, "+08:17"},
+        {1338, "+08:18"},
+        {1339, "+08:19"},
+        {1340, "+08:20"},
+        {1341, "+08:21"},
+        {1342, "+08:22"},
+        {1343, "+08:23"},
+        {1344, "+08:24"},
+        {1345, "+08:25"},
+        {1346, "+08:26"},
+        {1347, "+08:27"},
+        {1348, "+08:28"},
+        {1349, "+08:29"},
+        {1350, "+08:30"},
+        {1351, "+08:31"},
+        {1352, "+08:32"},
+        {1353, "+08:33"},
+        {1354, "+08:34"},
+        {1355, "+08:35"},
+        {1356, "+08:36"},
+        {1357, "+08:37"},
+        {1358, "+08:38"},
+        {1359, "+08:39"},
+        {1360, "+08:40"},
+        {1361, "+08:41"},
+        {1362, "+08:42"},
+        {1363, "+08:43"},
+        {1364, "+08:44"},
+        {1365, "+08:45"},
+        {1366, "+08:46"},
+        {1367, "+08:47"},
+        {1368, "+08:48"},
+        {1369, "+08:49"},
+        {1370, "+08:50"},
+        {1371, "+08:51"},
+        {1372, "+08:52"},
+        {1373, "+08:53"},
+        {1374, "+08:54"},
+        {1375, "+08:55"},
+        {1376, "+08:56"},
+        {1377, "+08:57"},
+        {1378, "+08:58"},
+        {1379, "+08:59"},
+        {1380, "+09:00"},
+        {1381, "+09:01"},
+        {1382, "+09:02"},
+        {1383, "+09:03"},
+        {1384, "+09:04"},
+        {1385, "+09:05"},
+        {1386, "+09:06"},
+        {1387, "+09:07"},
+        {1388, "+09:08"},
+        {1389, "+09:09"},
+        {1390, "+09:10"},
+        {1391, "+09:11"},
+        {1392, "+09:12"},
+        {1393, "+09:13"},
+        {1394, "+09:14"},
+        {1395, "+09:15"},
+        {1396, "+09:16"},
+        {1397, "+09:17"},
+        {1398, "+09:18"},
+        {1399, "+09:19"},
+        {1400, "+09:20"},
+        {1401, "+09:21"},
+        {1402, "+09:22"},
+        {1403, "+09:23"},
+        {1404, "+09:24"},
+        {1405, "+09:25"},
+        {1406, "+09:26"},
+        {1407, "+09:27"},
+        {1408, "+09:28"},
+        {1409, "+09:29"},
+        {1410, "+09:30"},
+        {1411, "+09:31"},
+        {1412, "+09:32"},
+        {1413, "+09:33"},
+        {1414, "+09:34"},
+        {1415, "+09:35"},
+        {1416, "+09:36"},
+        {1417, "+09:37"},
+        {1418, "+09:38"},
+        {1419, "+09:39"},
+        {1420, "+09:40"},
+        {1421, "+09:41"},
+        {1422, "+09:42"},
+        {1423, "+09:43"},
+        {1424, "+09:44"},
+        {1425, "+09:45"},
+        {1426, "+09:46"},
+        {1427, "+09:47"},
+        {1428, "+09:48"},
+        {1429, "+09:49"},
+        {1430, "+09:50"},
+        {1431, "+09:51"},
+        {1432, "+09:52"},
+        {1433, "+09:53"},
+        {1434, "+09:54"},
+        {1435, "+09:55"},
+        {1436, "+09:56"},
+        {1437, "+09:57"},
+        {1438, "+09:58"},
+        {1439, "+09:59"},
+        {1440, "+10:00"},
+        {1441, "+10:01"},
+        {1442, "+10:02"},
+        {1443, "+10:03"},
+        {1444, "+10:04"},
+        {1445, "+10:05"},
+        {1446, "+10:06"},
+        {1447, "+10:07"},
+        {1448, "+10:08"},
+        {1449, "+10:09"},
+        {1450, "+10:10"},
+        {1451, "+10:11"},
+        {1452, "+10:12"},
+        {1453, "+10:13"},
+        {1454, "+10:14"},
+        {1455, "+10:15"},
+        {1456, "+10:16"},
+        {1457, "+10:17"},
+        {1458, "+10:18"},
+        {1459, "+10:19"},
+        {1460, "+10:20"},
+        {1461, "+10:21"},
+        {1462, "+10:22"},
+        {1463, "+10:23"},
+        {1464, "+10:24"},
+        {1465, "+10:25"},
+        {1466, "+10:26"},
+        {1467, "+10:27"},
+        {1468, "+10:28"},
+        {1469, "+10:29"},
+        {1470, "+10:30"},
+        {1471, "+10:31"},
+        {1472, "+10:32"},
+        {1473, "+10:33"},
+        {1474, "+10:34"},
+        {1475, "+10:35"},
+        {1476, "+10:36"},
+        {1477, "+10:37"},
+        {1478, "+10:38"},
+        {1479, "+10:39"},
+        {1480, "+10:40"},
+        {1481, "+10:41"},
+        {1482, "+10:42"},
+        {1483, "+10:43"},
+        {1484, "+10:44"},
+        {1485, "+10:45"},
+        {1486, "+10:46"},
+        {1487, "+10:47"},
+        {1488, "+10:48"},
+        {1489, "+10:49"},
+        {1490, "+10:50"},
+        {1491, "+10:51"},
+        {1492, "+10:52"},
+        {1493, "+10:53"},
+        {1494, "+10:54"},
+        {1495, "+10:55"},
+        {1496, "+10:56"},
+        {1497, "+10:57"},
+        {1498, "+10:58"},
+        {1499, "+10:59"},
+        {1500, "+11:00"},
+        {1501, "+11:01"},
+        {1502, "+11:02"},
+        {1503, "+11:03"},
+        {1504, "+11:04"},
+        {1505, "+11:05"},
+        {1506, "+11:06"},
+        {1507, "+11:07"},
+        {1508, "+11:08"},
+        {1509, "+11:09"},
+        {1510, "+11:10"},
+        {1511, "+11:11"},
+        {1512, "+11:12"},
+        {1513, "+11:13"},
+        {1514, "+11:14"},
+        {1515, "+11:15"},
+        {1516, "+11:16"},
+        {1517, "+11:17"},
+        {1518, "+11:18"},
+        {1519, "+11:19"},
+        {1520, "+11:20"},
+        {1521, "+11:21"},
+        {1522, "+11:22"},
+        {1523, "+11:23"},
+        {1524, "+11:24"},
+        {1525, "+11:25"},
+        {1526, "+11:26"},
+        {1527, "+11:27"},
+        {1528, "+11:28"},
+        {1529, "+11:29"},
+        {1530, "+11:30"},
+        {1531, "+11:31"},
+        {1532, "+11:32"},
+        {1533, "+11:33"},
+        {1534, "+11:34"},
+        {1535, "+11:35"},
+        {1536, "+11:36"},
+        {1537, "+11:37"},
+        {1538, "+11:38"},
+        {1539, "+11:39"},
+        {1540, "+11:40"},
+        {1541, "+11:41"},
+        {1542, "+11:42"},
+        {1543, "+11:43"},
+        {1544, "+11:44"},
+        {1545, "+11:45"},
+        {1546, "+11:46"},
+        {1547, "+11:47"},
+        {1548, "+11:48"},
+        {1549, "+11:49"},
+        {1550, "+11:50"},
+        {1551, "+11:51"},
+        {1552, "+11:52"},
+        {1553, "+11:53"},
+        {1554, "+11:54"},
+        {1555, "+11:55"},
+        {1556, "+11:56"},
+        {1557, "+11:57"},
+        {1558, "+11:58"},
+        {1559, "+11:59"},
+        {1560, "+12:00"},
+        {1561, "+12:01"},
+        {1562, "+12:02"},
+        {1563, "+12:03"},
+        {1564, "+12:04"},
+        {1565, "+12:05"},
+        {1566, "+12:06"},
+        {1567, "+12:07"},
+        {1568, "+12:08"},
+        {1569, "+12:09"},
+        {1570, "+12:10"},
+        {1571, "+12:11"},
+        {1572, "+12:12"},
+        {1573, "+12:13"},
+        {1574, "+12:14"},
+        {1575, "+12:15"},
+        {1576, "+12:16"},
+        {1577, "+12:17"},
+        {1578, "+12:18"},
+        {1579, "+12:19"},
+        {1580, "+12:20"},
+        {1581, "+12:21"},
+        {1582, "+12:22"},
+        {1583, "+12:23"},
+        {1584, "+12:24"},
+        {1585, "+12:25"},
+        {1586, "+12:26"},
+        {1587, "+12:27"},
+        {1588, "+12:28"},
+        {1589, "+12:29"},
+        {1590, "+12:30"},
+        {1591, "+12:31"},
+        {1592, "+12:32"},
+        {1593, "+12:33"},
+        {1594, "+12:34"},
+        {1595, "+12:35"},
+        {1596, "+12:36"},
+        {1597, "+12:37"},
+        {1598, "+12:38"},
+        {1599, "+12:39"},
+        {1600, "+12:40"},
+        {1601, "+12:41"},
+        {1602, "+12:42"},
+        {1603, "+12:43"},
+        {1604, "+12:44"},
+        {1605, "+12:45"},
+        {1606, "+12:46"},
+        {1607, "+12:47"},
+        {1608, "+12:48"},
+        {1609, "+12:49"},
+        {1610, "+12:50"},
+        {1611, "+12:51"},
+        {1612, "+12:52"},
+        {1613, "+12:53"},
+        {1614, "+12:54"},
+        {1615, "+12:55"},
+        {1616, "+12:56"},
+        {1617, "+12:57"},
+        {1618, "+12:58"},
+        {1619, "+12:59"},
+        {1620, "+13:00"},
+        {1621, "+13:01"},
+        {1622, "+13:02"},
+        {1623, "+13:03"},
+        {1624, "+13:04"},
+        {1625, "+13:05"},
+        {1626, "+13:06"},
+        {1627, "+13:07"},
+        {1628, "+13:08"},
+        {1629, "+13:09"},
+        {1630, "+13:10"},
+        {1631, "+13:11"},
+        {1632, "+13:12"},
+        {1633, "+13:13"},
+        {1634, "+13:14"},
+        {1635, "+13:15"},
+        {1636, "+13:16"},
+        {1637, "+13:17"},
+        {1638, "+13:18"},
+        {1639, "+13:19"},
+        {1640, "+13:20"},
+        {1641, "+13:21"},
+        {1642, "+13:22"},
+        {1643, "+13:23"},
+        {1644, "+13:24"},
+        {1645, "+13:25"},
+        {1646, "+13:26"},
+        {1647, "+13:27"},
+        {1648, "+13:28"},
+        {1649, "+13:29"},
+        {1650, "+13:30"},
+        {1651, "+13:31"},
+        {1652, "+13:32"},
+        {1653, "+13:33"},
+        {1654, "+13:34"},
+        {1655, "+13:35"},
+        {1656, "+13:36"},
+        {1657, "+13:37"},
+        {1658, "+13:38"},
+        {1659, "+13:39"},
+        {1660, "+13:40"},
+        {1661, "+13:41"},
+        {1662, "+13:42"},
+        {1663, "+13:43"},
+        {1664, "+13:44"},
+        {1665, "+13:45"},
+        {1666, "+13:46"},
+        {1667, "+13:47"},
+        {1668, "+13:48"},
+        {1669, "+13:49"},
+        {1670, "+13:50"},
+        {1671, "+13:51"},
+        {1672, "+13:52"},
+        {1673, "+13:53"},
+        {1674, "+13:54"},
+        {1675, "+13:55"},
+        {1676, "+13:56"},
+        {1677, "+13:57"},
+        {1678, "+13:58"},
+        {1679, "+13:59"},
+        {1680, "+14:00"},
+        {1681, "Africa/Abidjan"},
+        {1682, "Africa/Accra"},
+        {1683, "Africa/Addis_Ababa"},
+        {1684, "Africa/Algiers"},
+        {1685, "Africa/Asmara"},
+        {1686, "Africa/Asmera"},
+        {1687, "Africa/Bamako"},
+        {1688, "Africa/Bangui"},
+        {1689, "Africa/Banjul"},
+        {1690, "Africa/Bissau"},
+        {1691, "Africa/Blantyre"},
+        {1692, "Africa/Brazzaville"},
+        {1693, "Africa/Bujumbura"},
+        {1694, "Africa/Cairo"},
+        {1695, "Africa/Casablanca"},
+        {1696, "Africa/Ceuta"},
+        {1697, "Africa/Conakry"},
+        {1698, "Africa/Dakar"},
+        {1699, "Africa/Dar_es_Salaam"},
+        {1700, "Africa/Djibouti"},
+        {1701, "Africa/Douala"},
+        {1702, "Africa/El_Aaiun"},
+        {1703, "Africa/Freetown"},
+        {1704, "Africa/Gaborone"},
+        {1705, "Africa/Harare"},
+        {1706, "Africa/Johannesburg"},
+        {1707, "Africa/Juba"},
+        {1708, "Africa/Kampala"},
+        {1709, "Africa/Khartoum"},
+        {1710, "Africa/Kigali"},
+        {1711, "Africa/Kinshasa"},
+        {1712, "Africa/Lagos"},
+        {1713, "Africa/Libreville"},
+        {1714, "Africa/Lome"},
+        {1715, "Africa/Luanda"},
+        {1716, "Africa/Lubumbashi"},
+        {1717, "Africa/Lusaka"},
+        {1718, "Africa/Malabo"},
+        {1719, "Africa/Maputo"},
+        {1720, "Africa/Maseru"},
+        {1721, "Africa/Mbabane"},
+        {1722, "Africa/Mogadishu"},
+        {1723, "Africa/Monrovia"},
+        {1724, "Africa/Nairobi"},
+        {1725, "Africa/Ndjamena"},
+        {1726, "Africa/Niamey"},
+        {1727, "Africa/Nouakchott"},
+        {1728, "Africa/Ouagadougou"},
+        {1729, "Africa/Porto-Novo"},
+        {1730, "Africa/Sao_Tome"},
+        {1731, "Africa/Timbuktu"},
+        {1732, "Africa/Tripoli"},
+        {1733, "Africa/Tunis"},
+        {1734, "Africa/Windhoek"},
+        {1735, "America/Adak"},
+        {1736, "America/Anchorage"},
+        {1737, "America/Anguilla"},
+        {1738, "America/Antigua"},
+        {1739, "America/Araguaina"},
+        {1740, "America/Argentina/Buenos_Aires"},
+        {1741, "America/Argentina/Catamarca"},
+        {1742, "America/Argentina/ComodRivadavia"},
+        {1743, "America/Argentina/Cordoba"},
+        {1744, "America/Argentina/Jujuy"},
+        {1745, "America/Argentina/La_Rioja"},
+        {1746, "America/Argentina/Mendoza"},
+        {1747, "America/Argentina/Rio_Gallegos"},
+        {1748, "America/Argentina/Salta"},
+        {1749, "America/Argentina/San_Juan"},
+        {1750, "America/Argentina/San_Luis"},
+        {1751, "America/Argentina/Tucuman"},
+        {1752, "America/Argentina/Ushuaia"},
+        {1753, "America/Aruba"},
+        {1754, "America/Asuncion"},
+        {1755, "America/Atikokan"},
+        {1756, "America/Atka"},
+        {1757, "America/Bahia"},
+        {1758, "America/Bahia_Banderas"},
+        {1759, "America/Barbados"},
+        {1760, "America/Belem"},
+        {1761, "America/Belize"},
+        {1762, "America/Blanc-Sablon"},
+        {1763, "America/Boa_Vista"},
+        {1764, "America/Bogota"},
+        {1765, "America/Boise"},
+        {1766, "America/Buenos_Aires"},
+        {1767, "America/Cambridge_Bay"},
+        {1768, "America/Campo_Grande"},
+        {1769, "America/Cancun"},
+        {1770, "America/Caracas"},
+        {1771, "America/Catamarca"},
+        {1772, "America/Cayenne"},
+        {1773, "America/Cayman"},
+        {1774, "America/Chicago"},
+        {1775, "America/Chihuahua"},
+        {1776, "America/Coral_Harbour"},
+        {1777, "America/Cordoba"},
+        {1778, "America/Costa_Rica"},
+        {1779, "America/Cuiaba"},
+        {1780, "America/Curacao"},
+        {1781, "America/Danmarkshavn"},
+        {1782, "America/Dawson"},
+        {1783, "America/Dawson_Creek"},
+        {1784, "America/Denver"},
+        {1785, "America/Detroit"},
+        {1786, "America/Dominica"},
+        {1787, "America/Edmonton"},
+        {1788, "America/Eirunepe"},
+        {1789, "America/El_Salvador"},
+        {1790, "America/Ensenada"},
+        {1791, "America/Fort_Wayne"},
+        {1792, "America/Fortaleza"},
+        {1793, "America/Glace_Bay"},
+        {1794, "America/Godthab"},
+        {1795, "America/Goose_Bay"},
+        {1796, "America/Grand_Turk"},
+        {1797, "America/Grenada"},
+        {1798, "America/Guadeloupe"},
+        {1799, "America/Guatemala"},
+        {1800, "America/Guayaquil"},
+        {1801, "America/Guyana"},
+        {1802, "America/Halifax"},
+        {1803, "America/Havana"},
+        {1804, "America/Hermosillo"},
+        {1805, "America/Indiana/Indianapolis"},
+        {1806, "America/Indiana/Knox"},
+        {1807, "America/Indiana/Marengo"},
+        {1808, "America/Indiana/Petersburg"},
+        {1809, "America/Indiana/Tell_City"},
+        {1810, "America/Indiana/Vevay"},
+        {1811, "America/Indiana/Vincennes"},
+        {1812, "America/Indiana/Winamac"},
+        {1813, "America/Indianapolis"},
+        {1814, "America/Inuvik"},
+        {1815, "America/Iqaluit"},
+        {1816, "America/Jamaica"},
+        {1817, "America/Jujuy"},
+        {1818, "America/Juneau"},
+        {1819, "America/Kentucky/Louisville"},
+        {1820, "America/Kentucky/Monticello"},
+        {1821, "America/Knox_IN"},
+        {1822, "America/Kralendijk"},
+        {1823, "America/La_Paz"},
+        {1824, "America/Lima"},
+        {1825, "America/Los_Angeles"},
+        {1826, "America/Louisville"},
+        {1827, "America/Lower_Princes"},
+        {1828, "America/Maceio"},
+        {1829, "America/Managua"},
+        {1830, "America/Manaus"},
+        {1831, "America/Marigot"},
+        {1832, "America/Martinique"},
+        {1833, "America/Matamoros"},
+        {1834, "America/Mazatlan"},
+        {1835, "America/Mendoza"},
+        {1836, "America/Menominee"},
+        {1837, "America/Merida"},
+        {1838, "America/Metlakatla"},
+        {1839, "America/Mexico_City"},
+        {1840, "America/Miquelon"},
+        {1841, "America/Moncton"},
+        {1842, "America/Monterrey"},
+        {1843, "America/Montevideo"},
+        {1844, "America/Montreal"},
+        {1845, "America/Montserrat"},
+        {1846, "America/Nassau"},
+        {1847, "America/New_York"},
+        {1848, "America/Nipigon"},
+        {1849, "America/Nome"},
+        {1850, "America/Noronha"},
+        {1851, "America/North_Dakota/Beulah"},
+        {1852, "America/North_Dakota/Center"},
+        {1853, "America/North_Dakota/New_Salem"},
+        {1854, "America/Ojinaga"},
+        {1855, "America/Panama"},
+        {1856, "America/Pangnirtung"},
+        {1857, "America/Paramaribo"},
+        {1858, "America/Phoenix"},
+        {1859, "America/Port-au-Prince"},
+        {1860, "America/Port_of_Spain"},
+        {1861, "America/Porto_Acre"},
+        {1862, "America/Porto_Velho"},
+        {1863, "America/Puerto_Rico"},
+        {1864, "America/Rainy_River"},
+        {1865, "America/Rankin_Inlet"},
+        {1866, "America/Recife"},
+        {1867, "America/Regina"},
+        {1868, "America/Resolute"},
+        {1869, "America/Rio_Branco"},
+        {1870, "America/Rosario"},
+        {1871, "America/Santa_Isabel"},
+        {1872, "America/Santarem"},
+        {1873, "America/Santiago"},
+        {1874, "America/Santo_Domingo"},
+        {1875, "America/Sao_Paulo"},
+        {1876, "America/Scoresbysund"},
+        {1877, "America/Shiprock"},
+        {1878, "America/Sitka"},
+        {1879, "America/St_Barthelemy"},
+        {1880, "America/St_Johns"},
+        {1881, "America/St_Kitts"},
+        {1882, "America/St_Lucia"},
+        {1883, "America/St_Thomas"},
+        {1884, "America/St_Vincent"},
+        {1885, "America/Swift_Current"},
+        {1886, "America/Tegucigalpa"},
+        {1887, "America/Thule"},
+        {1888, "America/Thunder_Bay"},
+        {1889, "America/Tijuana"},
+        {1890, "America/Toronto"},
+        {1891, "America/Tortola"},
+        {1892, "America/Vancouver"},
+        {1893, "America/Virgin"},
+        {1894, "America/Whitehorse"},
+        {1895, "America/Winnipeg"},
+        {1896, "America/Yakutat"},
+        {1897, "America/Yellowknife"},
+        {1898, "Antarctica/Casey"},
+        {1899, "Antarctica/Davis"},
+        {1900, "Antarctica/DumontDUrville"},
+        {1901, "Antarctica/Macquarie"},
+        {1902, "Antarctica/Mawson"},
+        {1903, "Antarctica/McMurdo"},
+        {1904, "Antarctica/Palmer"},
+        {1905, "Antarctica/Rothera"},
+        {1906, "Antarctica/South_Pole"},
+        {1907, "Antarctica/Syowa"},
+        {1908, "Antarctica/Vostok"},
+        {1909, "Arctic/Longyearbyen"},
+        {1910, "Asia/Aden"},
+        {1911, "Asia/Almaty"},
+        {1912, "Asia/Amman"},
+        {1913, "Asia/Anadyr"},
+        {1914, "Asia/Aqtau"},
+        {1915, "Asia/Aqtobe"},
+        {1916, "Asia/Ashgabat"},
+        {1917, "Asia/Ashkhabad"},
+        {1918, "Asia/Baghdad"},
+        {1919, "Asia/Bahrain"},
+        {1920, "Asia/Baku"},
+        {1921, "Asia/Bangkok"},
+        {1922, "Asia/Beirut"},
+        {1923, "Asia/Bishkek"},
+        {1924, "Asia/Brunei"},
+        {1925, "Asia/Calcutta"},
+        {1926, "Asia/Choibalsan"},
+        {1927, "Asia/Chongqing"},
+        {1928, "Asia/Chungking"},
+        {1929, "Asia/Colombo"},
+        {1930, "Asia/Dacca"},
+        {1931, "Asia/Damascus"},
+        {1932, "Asia/Dhaka"},
+        {1933, "Asia/Dili"},
+        {1934, "Asia/Dubai"},
+        {1935, "Asia/Dushanbe"},
+        {1936, "Asia/Gaza"},
+        {1937, "Asia/Harbin"},
+        {1938, "Asia/Hebron"},
+        {1939, "Asia/Ho_Chi_Minh"},
+        {1940, "Asia/Hong_Kong"},
+        {1941, "Asia/Hovd"},
+        {1942, "Asia/Irkutsk"},
+        {1943, "Asia/Istanbul"},
+        {1944, "Asia/Jakarta"},
+        {1945, "Asia/Jayapura"},
+        {1946, "Asia/Jerusalem"},
+        {1947, "Asia/Kabul"},
+        {1948, "Asia/Kamchatka"},
+        {1949, "Asia/Karachi"},
+        {1950, "Asia/Kashgar"},
+        {1951, "Asia/Kathmandu"},
+        {1952, "Asia/Katmandu"},
+        {1953, "Asia/Kolkata"},
+        {1954, "Asia/Krasnoyarsk"},
+        {1955, "Asia/Kuala_Lumpur"},
+        {1956, "Asia/Kuching"},
+        {1957, "Asia/Kuwait"},
+        {1958, "Asia/Macao"},
+        {1959, "Asia/Macau"},
+        {1960, "Asia/Magadan"},
+        {1961, "Asia/Makassar"},
+        {1962, "Asia/Manila"},
+        {1963, "Asia/Muscat"},
+        {1964, "Asia/Nicosia"},
+        {1965, "Asia/Novokuznetsk"},
+        {1966, "Asia/Novosibirsk"},
+        {1967, "Asia/Omsk"},
+        {1968, "Asia/Oral"},
+        {1969, "Asia/Phnom_Penh"},
+        {1970, "Asia/Pontianak"},
+        {1971, "Asia/Pyongyang"},
+        {1972, "Asia/Qatar"},
+        {1973, "Asia/Qyzylorda"},
+        {1974, "Asia/Rangoon"},
+        {1975, "Asia/Riyadh"},
+        {1976, "Asia/Saigon"},
+        {1977, "Asia/Sakhalin"},
+        {1978, "Asia/Samarkand"},
+        {1979, "Asia/Seoul"},
+        {1980, "Asia/Shanghai"},
+        {1981, "Asia/Singapore"},
+        {1982, "Asia/Taipei"},
+        {1983, "Asia/Tashkent"},
+        {1984, "Asia/Tbilisi"},
+        {1985, "Asia/Tehran"},
+        {1986, "Asia/Tel_Aviv"},
+        {1987, "Asia/Thimbu"},
+        {1988, "Asia/Thimphu"},
+        {1989, "Asia/Tokyo"},
+        {1990, "Asia/Ujung_Pandang"},
+        {1991, "Asia/Ulaanbaatar"},
+        {1992, "Asia/Ulan_Bator"},
+        {1993, "Asia/Urumqi"},
+        {1994, "Asia/Vientiane"},
+        {1995, "Asia/Vladivostok"},
+        {1996, "Asia/Yakutsk"},
+        {1997, "Asia/Yekaterinburg"},
+        {1998, "Asia/Yerevan"},
+        {1999, "Atlantic/Azores"},
+        {2000, "Atlantic/Bermuda"},
+        {2001, "Atlantic/Canary"},
+        {2002, "Atlantic/Cape_Verde"},
+        {2003, "Atlantic/Faeroe"},
+        {2004, "Atlantic/Faroe"},
+        {2005, "Atlantic/Jan_Mayen"},
+        {2006, "Atlantic/Madeira"},
+        {2007, "Atlantic/Reykjavik"},
+        {2008, "Atlantic/South_Georgia"},
+        {2009, "Atlantic/St_Helena"},
+        {2010, "Atlantic/Stanley"},
+        {2011, "Australia/ACT"},
+        {2012, "Australia/Adelaide"},
+        {2013, "Australia/Brisbane"},
+        {2014, "Australia/Broken_Hill"},
+        {2015, "Australia/Canberra"},
+        {2016, "Australia/Currie"},
+        {2017, "Australia/Darwin"},
+        {2018, "Australia/Eucla"},
+        {2019, "Australia/Hobart"},
+        {2020, "Australia/LHI"},
+        {2021, "Australia/Lindeman"},
+        {2022, "Australia/Lord_Howe"},
+        {2023, "Australia/Melbourne"},
+        {2024, "Australia/NSW"},
+        {2025, "Australia/North"},
+        {2026, "Australia/Perth"},
+        {2027, "Australia/Queensland"},
+        {2028, "Australia/South"},
+        {2029, "Australia/Sydney"},
+        {2030, "Australia/Tasmania"},
+        {2031, "Australia/Victoria"},
+        {2032, "Australia/West"},
+        {2033, "Australia/Yancowinna"},
+        {2034, "Brazil/Acre"},
+        {2035, "Brazil/DeNoronha"},
+        {2036, "Brazil/East"},
+        {2037, "Brazil/West"},
+        {2038, "Canada/Atlantic"},
+        {2039, "Canada/Central"},
+        {2041, "Canada/Eastern"},
+        {2042, "Canada/Mountain"},
+        {2043, "Canada/Newfoundland"},
+        {2044, "Canada/Pacific"},
+        {2045, "Canada/Saskatchewan"},
+        {2046, "Canada/Yukon"},
+        {2047, "Chile/Continental"},
+        {2048, "Chile/EasterIsland"},
+        {2049, "Europe/Amsterdam"},
+        {2050, "Europe/Andorra"},
+        {2051, "Europe/Athens"},
+        {2052, "Europe/Belfast"},
+        {2053, "Europe/Belgrade"},
+        {2054, "Europe/Berlin"},
+        {2055, "Europe/Bratislava"},
+        {2056, "Europe/Brussels"},
+        {2057, "Europe/Bucharest"},
+        {2058, "Europe/Budapest"},
+        {2059, "Europe/Chisinau"},
+        {2060, "Europe/Copenhagen"},
+        {2061, "Europe/Dublin"},
+        {2062, "Europe/Gibraltar"},
+        {2063, "Europe/Guernsey"},
+        {2064, "Europe/Helsinki"},
+        {2065, "Europe/Isle_of_Man"},
+        {2066, "Europe/Istanbul"},
+        {2067, "Europe/Jersey"},
+        {2068, "Europe/Kaliningrad"},
+        {2069, "Europe/Kiev"},
+        {2070, "Europe/Lisbon"},
+        {2071, "Europe/Ljubljana"},
+        {2072, "Europe/London"},
+        {2073, "Europe/Luxembourg"},
+        {2074, "Europe/Madrid"},
+        {2075, "Europe/Malta"},
+        {2076, "Europe/Mariehamn"},
+        {2077, "Europe/Minsk"},
+        {2078, "Europe/Monaco"},
+        {2079, "Europe/Moscow"},
+        {2080, "Europe/Nicosia"},
+        {2081, "Europe/Oslo"},
+        {2082, "Europe/Paris"},
+        {2083, "Europe/Podgorica"},
+        {2084, "Europe/Prague"},
+        {2085, "Europe/Riga"},
+        {2086, "Europe/Rome"},
+        {2087, "Europe/Samara"},
+        {2088, "Europe/San_Marino"},
+        {2089, "Europe/Sarajevo"},
+        {2090, "Europe/Simferopol"},
+        {2091, "Europe/Skopje"},
+        {2092, "Europe/Sofia"},
+        {2093, "Europe/Stockholm"},
+        {2094, "Europe/Tallinn"},
+        {2095, "Europe/Tirane"},
+        {2096, "Europe/Tiraspol"},
+        {2097, "Europe/Uzhgorod"},
+        {2098, "Europe/Vaduz"},
+        {2099, "Europe/Vatican"},
+        {2100, "Europe/Vienna"},
+        {2101, "Europe/Vilnius"},
+        {2102, "Europe/Volgograd"},
+        {2103, "Europe/Warsaw"},
+        {2104, "Europe/Zagreb"},
+        {2105, "Europe/Zaporozhye"},
+        {2106, "Europe/Zurich"},
+        {2107, "Indian/Antananarivo"},
+        {2108, "Indian/Chagos"},
+        {2109, "Indian/Christmas"},
+        {2110, "Indian/Cocos"},
+        {2111, "Indian/Comoro"},
+        {2112, "Indian/Kerguelen"},
+        {2113, "Indian/Mahe"},
+        {2114, "Indian/Maldives"},
+        {2115, "Indian/Mauritius"},
+        {2116, "Indian/Mayotte"},
+        {2117, "Indian/Reunion"},
+        {2118, "Mexico/BajaNorte"},
+        {2119, "Mexico/BajaSur"},
+        {2120, "Mexico/General"},
+        {2121, "Pacific/Apia"},
+        {2122, "Pacific/Auckland"},
+        {2123, "Pacific/Chatham"},
+        {2124, "Pacific/Chuuk"},
+        {2125, "Pacific/Easter"},
+        {2126, "Pacific/Efate"},
+        {2127, "Pacific/Enderbury"},
+        {2128, "Pacific/Fakaofo"},
+        {2129, "Pacific/Fiji"},
+        {2130, "Pacific/Funafuti"},
+        {2131, "Pacific/Galapagos"},
+        {2132, "Pacific/Gambier"},
+        {2133, "Pacific/Guadalcanal"},
+        {2134, "Pacific/Guam"},
+        {2135, "Pacific/Honolulu"},
+        {2136, "Pacific/Johnston"},
+        {2137, "Pacific/Kiritimati"},
+        {2138, "Pacific/Kosrae"},
+        {2139, "Pacific/Kwajalein"},
+        {2140, "Pacific/Majuro"},
+        {2141, "Pacific/Marquesas"},
+        {2142, "Pacific/Midway"},
+        {2143, "Pacific/Nauru"},
+        {2144, "Pacific/Niue"},
+        {2145, "Pacific/Norfolk"},
+        {2146, "Pacific/Noumea"},
+        {2147, "Pacific/Pago_Pago"},
+        {2148, "Pacific/Palau"},
+        {2149, "Pacific/Pitcairn"},
+        {2150, "Pacific/Pohnpei"},
+        {2151, "Pacific/Ponape"},
+        {2152, "Pacific/Port_Moresby"},
+        {2153, "Pacific/Rarotonga"},
+        {2154, "Pacific/Saipan"},
+        {2155, "Pacific/Samoa"},
+        {2156, "Pacific/Tahiti"},
+        {2157, "Pacific/Tarawa"},
+        {2158, "Pacific/Tongatapu"},
+        {2159, "Pacific/Truk"},
+        {2160, "Pacific/Wake"},
+        {2161, "Pacific/Wallis"},
+        {2162, "Pacific/Yap"},
+        {2163, "US/Alaska"},
+        {2164, "US/Aleutian"},
+        {2165, "US/Arizona"},
+        {2166, "US/Central"},
+        {2167, "US/East-Indiana"},
+        {2168, "US/Eastern"},
+        {2169, "US/Hawaii"},
+        {2170, "US/Indiana-Starke"},
+        {2171, "US/Michigan"},
+        {2172, "US/Mountain"},
+        {2173, "US/Pacific"},
+        {2175, "US/Samoa"},
+        {2176, "CET"},
+        {2177, "CST6CDT"},
+        {2178, "Cuba"},
+        {2179, "EET"},
+        {2181, "EST5EDT"},
+        {2182, "Egypt"},
+        {2183, "Eire"},
+        {2184, "GB"},
+        {2185, "GB-Eire"},
+        {2187, "Hongkong"},
+        {2188, "Iceland"},
+        {2189, "Iran"},
+        {2190, "Israel"},
+        {2191, "Jamaica"},
+        {2192, "Japan"},
+        {2193, "Kwajalein"},
+        {2194, "Libya"},
+        {2195, "MET"},
+        {2197, "MST7MDT"},
+        {2198, "NZ"},
+        {2199, "NZ-CHAT"},
+        {2200, "Navajo"},
+        {2201, "PRC"},
+        {2202, "PST8PDT"},
+        {2203, "Poland"},
+        {2204, "Portugal"},
+        {2205, "ROK"},
+        {2206, "Singapore"},
+        {2207, "Turkey"},
+        {2208, "W-SU"},
+        {2209, "WET"},
+        {2210, "America/Creston"},
+        {2211, "Antarctica/Troll"},
+        {2212, "Asia/Khandyga"},
+        {2213, "Asia/Ust-Nera"},
+        {2214, "Europe/Busingen"},
+        {2215, "Asia/Chita"},
+        {2216, "Asia/Srednekolymsk"},
+        {2217, "Pacific/Bougainville"},
+        {2218, "America/Fort_Nelson"},
+        {2219, "Asia/Barnaul"},
+        {2220, "Asia/Tomsk"},
+        {2221, "Europe/Astrakhan"},
+        {2222, "Europe/Kirov"},
+        {2223, "Europe/Ulyanovsk"},
+        {2224, "Asia/Yangon"},
+        {2225, "America/Punta_Arenas"},
+        {2226, "Asia/Atyrau"},
+        {2227, "Asia/Famagusta"},
+        {2228, "Europe/Saratov"},
+        {2229, "Asia/Qostanay"},
+        {2230, "America/Nuuk"},
+        {2231, "Pacific/Kanton"},
+        {2232, "Europe/Kyiv"},
+        {2233, "America/Ciudad_Juarez"},
+    };
+  }());
+  return *tzDB;
 }
 
-} // namespace facebook::velox::util
+} // namespace facebook::velox::tz
diff --git a/velox/type/tz/TimeZoneMap.cpp b/velox/type/tz/TimeZoneMap.cpp
index 443f062e1ab4b..93dacadba6779 100644
--- a/velox/type/tz/TimeZoneMap.cpp
+++ b/velox/type/tz/TimeZoneMap.cpp
@@ -15,46 +15,350 @@
  */
 
 #include "velox/type/tz/TimeZoneMap.h"
+
+#include <boost/algorithm/string.hpp>
 #include <fmt/core.h>
 #include <folly/container/F14Map.h>
+#include <folly/container/F14Set.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/external/date/tz.h"
 
-namespace facebook::velox::util {
+using facebook::velox::common::testutil::TestValue;
 
-// Defined on TimeZoneDatabase.cpp
-extern const std::unordered_map<int64_t, std::string>& getTimeZoneDB();
+namespace facebook::velox::tz {
 
-std::string getTimeZoneName(int64_t timeZoneID) {
-  const auto& tzDB = getTimeZoneDB();
-  auto it = tzDB.find(timeZoneID);
-  if (it == tzDB.end()) {
-    throw std::runtime_error(
-        fmt::format("Unable to resolve timeZoneID '{}'.", timeZoneID));
+using TTimeZoneDatabase = std::vector<std::unique_ptr<TimeZone>>;
+using TTimeZoneIndex = folly::F14FastMap<std::string, const TimeZone*>;
+
+// Defined in TimeZoneDatabase.cpp
+extern const std::vector<std::pair<int16_t, std::string>>& getTimeZoneEntries();
+
+namespace {
+
+// Returns the offset in minutes for a specific time zone offset in the
+// database. Do not call for tzID 0 (UTC / "+00:00").
+inline std::chrono::minutes getTimeZoneOffset(int16_t tzID) {
+  return std::chrono::minutes{(tzID <= 840) ? (tzID - 841) : (tzID - 840)};
+}
+
+const date::time_zone* locateZoneImpl(std::string_view tz_name) {
+  TestValue::adjust("facebook::velox::tz::locateZoneImpl", &tz_name);
+  const date::time_zone* zone = date::locate_zone(tz_name);
+  return zone;
+}
+
+// Flattens the input vector of pairs into a vector, assuming that the
+// timezoneIDs are (mostly) sequential. Note that since they are "mostly"
+// senquential, the vector can have holes. But it is still more efficient than
+// looking up on a map.
+TTimeZoneDatabase buildTimeZoneDatabase(
+    const std::vector<std::pair<int16_t, std::string>>& dbInput) {
+  TTimeZoneDatabase tzDatabase;
+  tzDatabase.resize(dbInput.back().first + 1);
+
+  for (const auto& entry : dbInput) {
+    std::unique_ptr<TimeZone> timeZonePtr;
+
+    if (entry.first == 0) {
+      timeZonePtr =
+          std::make_unique<TimeZone>("UTC", entry.first, locateZoneImpl("UTC"));
+    } else if (entry.first <= 1680) {
+      std::chrono::minutes offset = getTimeZoneOffset(entry.first);
+      timeZonePtr =
+          std::make_unique<TimeZone>(entry.second, entry.first, offset);
+    }
+    // Every single other time zone entry (outside of offsets) needs to be
+    // available in external/date or this will throw.
+    else {
+      const date::time_zone* zone;
+      try {
+        zone = locateZoneImpl(entry.second);
+      } catch (date::invalid_timezone& err) {
+        // When this exception is thrown, it typically means the time zone name
+        // we are trying to locate cannot be found from OS's time zone database.
+        // Thus, we just command a "continue;" to skip the creation of the
+        // corresponding TimeZone object.
+        //
+        // Then, once this time zone is requested at runtime, a runtime error
+        // will be thrown and caller is expected to handle that error in code.
+        LOG(WARNING) << "Unable to load [" << entry.second
+                     << "] from local timezone database: " << err.what();
+        continue;
+      }
+      timeZonePtr = std::make_unique<TimeZone>(entry.second, entry.first, zone);
+    }
+    tzDatabase[entry.first] = std::move(timeZonePtr);
   }
-  return it->second;
+  return tzDatabase;
 }
 
-namespace {
-folly::F14FastMap<std::string_view, int64_t> makeReverseMap(
-    const std::unordered_map<int64_t, std::string>& map) {
-  folly::F14FastMap<std::string_view, int64_t> reversed;
-  reversed.reserve(map.size());
-  for (const auto& entry : map) {
-    reversed.emplace(entry.second, entry.first);
+const TTimeZoneDatabase& getTimeZoneDatabase() {
+  static TTimeZoneDatabase timeZoneDatabase =
+      buildTimeZoneDatabase(getTimeZoneEntries());
+  return timeZoneDatabase;
+}
+
+// Reverses the vector of pairs into a map key'ed by the timezone name for
+// reverse look ups.
+TTimeZoneIndex buildTimeZoneIndex(const TTimeZoneDatabase& tzDatabase) {
+  TTimeZoneIndex reversed;
+  reversed.reserve(tzDatabase.size() + 2);
+
+  for (int16_t i = 0; i < tzDatabase.size(); ++i) {
+    if (tzDatabase[i] != nullptr) {
+      reversed.emplace(
+          boost::algorithm::to_lower_copy(tzDatabase[i]->name()),
+          tzDatabase[i].get());
+    }
   }
+
+  // Add aliases to UTC.
+  reversed.emplace("+00:00", tzDatabase.front().get());
+  reversed.emplace("-00:00", tzDatabase.front().get());
   return reversed;
 }
+
+const TTimeZoneIndex& getTimeZoneIndex() {
+  static TTimeZoneIndex timeZoneIndex =
+      buildTimeZoneIndex(getTimeZoneDatabase());
+  return timeZoneIndex;
+}
+
+inline bool isDigit(char c) {
+  return c >= '0' && c <= '9';
+}
+
+inline bool startsWith(std::string_view str, const char* prefix) {
+  return str.rfind(prefix, 0) == 0;
+}
+
+inline bool isTimeZoneOffset(std::string_view str) {
+  return str.size() >= 3 && (str[0] == '+' || str[0] == '-');
+}
+
+// The timezone parsing logic follows what is defined here:
+//   https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+inline bool isUtcEquivalentName(std::string_view zone) {
+  static folly::F14FastSet<std::string> utcSet = {
+      "utc", "uct", "gmt", "gmt0", "greenwich", "universal", "zulu", "z"};
+  return utcSet.find(zone) != utcSet.end();
+}
+
+// This function tries to apply two normalization rules to time zone offsets:
+//
+// 1. If the offset only defines the hours portion, assume minutes are zeroed
+// out (e.g. "+00" -> "+00:00")
+//
+// 2. Check if the ':' in between in missing; if so, correct the offset string
+// (e.g. "+0000" -> "+00:00").
+//
+// This function assumes the first character is either '+' or '-'.
+std::string normalizeTimeZoneOffset(const std::string& zoneOffset) {
+  if (zoneOffset.size() == 3 && isDigit(zoneOffset[1]) &&
+      isDigit(zoneOffset[2])) {
+    return zoneOffset + ":00";
+  } else if (
+      zoneOffset.size() == 5 && isDigit(zoneOffset[1]) &&
+      isDigit(zoneOffset[2]) && isDigit(zoneOffset[3]) &&
+      isDigit(zoneOffset[4])) {
+    return zoneOffset.substr(0, 3) + ':' + zoneOffset.substr(3, 2);
+  }
+  return zoneOffset;
+}
+
+std::string normalizeTimeZone(const std::string& originalZoneId) {
+  // If this is an offset that hasn't matched, check if this is an incomplete
+  // offset.
+  if (isTimeZoneOffset(originalZoneId)) {
+    return normalizeTimeZoneOffset(originalZoneId);
+  }
+
+  // Otherwise, try other time zone name normalizations.
+  std::string_view zoneId = originalZoneId;
+  const bool startsWithEtc = startsWith(zoneId, "etc/");
+
+  if (startsWithEtc) {
+    zoneId = zoneId.substr(4);
+  }
+
+  // ETC/GMT, ETC/GREENWICH, and others are all valid and link to GMT.
+  if (isUtcEquivalentName(zoneId)) {
+    return "utc";
+  }
+
+  // Check for Etc/GMT(+/-)H[H] pattern.
+  if (startsWithEtc) {
+    if (zoneId.size() > 4 && startsWith(zoneId, "gmt")) {
+      zoneId = zoneId.substr(3);
+      char signChar = zoneId[0];
+
+      if (signChar == '+' || signChar == '-') {
+        // ETC flips the sign.
+        signChar = (signChar == '-') ? '+' : '-';
+
+        // Extract the tens and ones characters for the hour.
+        char hourTens;
+        char hourOnes;
+
+        if (zoneId.size() == 2) {
+          hourTens = '0';
+          hourOnes = zoneId[1];
+        } else {
+          hourTens = zoneId[1];
+          hourOnes = zoneId[2];
+        }
+
+        // Prevent it from returning -00:00, which is just utc.
+        if (hourTens == '0' && hourOnes == '0') {
+          return "utc";
+        }
+
+        if (isDigit(hourTens) && isDigit(hourOnes)) {
+          return std::string() + signChar + hourTens + hourOnes + ":00";
+        }
+      }
+    }
+  }
+  return originalZoneId;
+}
+
+template <typename TDuration>
+void validateRangeImpl(time_point<TDuration> timePoint) {
+  using namespace velox::date;
+  static constexpr auto kMinYear = date::year::min();
+  static constexpr auto kMaxYear = date::year::max();
+
+  auto year = year_month_day(floor<days>(timePoint)).year();
+
+  if (year < kMinYear || year > kMaxYear) {
+    // This is a special case where we intentionally throw
+    // VeloxRuntimeError to avoid it being suppressed by TRY().
+    VELOX_FAIL_UNSUPPORTED_INPUT_UNCATCHABLE(
+        "Timepoint is outside of supported year range: [{}, {}], got {}",
+        (int)kMinYear,
+        (int)kMaxYear,
+        (int)year);
+  }
+}
+
 } // namespace
 
-int64_t getTimeZoneID(std::string_view timeZone) {
-  static folly::F14FastMap<std::string_view, int64_t> nameToIdMap =
-      makeReverseMap(getTimeZoneDB());
+void validateRange(time_point<std::chrono::seconds> timePoint) {
+  validateRangeImpl(timePoint);
+}
+
+void validateRange(time_point<std::chrono::milliseconds> timePoint) {
+  validateRangeImpl(timePoint);
+}
+
+std::string getTimeZoneName(int64_t timeZoneID) {
+  return locateZone(timeZoneID, true)->name();
+}
+
+const TimeZone* locateZone(int16_t timeZoneID, bool failOnError) {
+  const auto& timeZoneDatabase = getTimeZoneDatabase();
+
+  // Check if timeZoneID does not exceed the vector size or is one of the
+  // "holes".
+  if (timeZoneID > timeZoneDatabase.size() ||
+      timeZoneDatabase[timeZoneID] == nullptr) {
+    if (failOnError) {
+      VELOX_FAIL("Unable to resolve timeZoneID '{}'", timeZoneID);
+    }
+    return nullptr;
+  }
+  return timeZoneDatabase[timeZoneID].get();
+}
+
+const TimeZone* locateZone(std::string_view timeZone, bool failOnError) {
+  const auto& timeZoneIndex = getTimeZoneIndex();
+
+  std::string timeZoneLowered;
+  boost::algorithm::to_lower_copy(
+      std::back_inserter(timeZoneLowered), timeZone);
+
+  auto it = timeZoneIndex.find(timeZoneLowered);
+  if (it != timeZoneIndex.end()) {
+    return it->second;
+  }
 
-  auto it = nameToIdMap.find(timeZone);
-  if (it == nameToIdMap.end()) {
-    throw std::runtime_error(fmt::format("Unknown time zone: {}", timeZone));
+  // If an exact match wasn't found, try to normalize the timezone name.
+  it = timeZoneIndex.find(normalizeTimeZone(timeZoneLowered));
+  if (it != timeZoneIndex.end()) {
+    return it->second;
   }
 
-  return it->second;
+  if (failOnError) {
+    VELOX_USER_FAIL("Unknown time zone: '{}'", timeZone);
+  }
+  return nullptr;
+}
+
+int16_t getTimeZoneID(std::string_view timeZone, bool failOnError) {
+  const TimeZone* tz = locateZone(timeZone, failOnError);
+  return tz == nullptr ? -1 : tz->id();
+}
+
+int16_t getTimeZoneID(int32_t offsetMinutes) {
+  static constexpr int32_t kMinOffset = -14 * 60;
+  static constexpr int32_t kMaxOffset = 14 * 60;
+
+  if (offsetMinutes == 0) {
+    return 0;
+  }
+
+  VELOX_USER_CHECK_LE(
+      kMinOffset,
+      offsetMinutes,
+      "Invalid timezone offset minutes: {}",
+      offsetMinutes);
+  VELOX_USER_CHECK_LE(
+      offsetMinutes,
+      kMaxOffset,
+      "Invalid timezone offset minutes: {}",
+      offsetMinutes);
+
+  if (offsetMinutes < 0) {
+    return 1 + (offsetMinutes - kMinOffset);
+  } else {
+    return offsetMinutes - kMinOffset;
+  }
+}
+
+TimeZone::seconds TimeZone::to_sys(
+    TimeZone::seconds timestamp,
+    TimeZone::TChoose choose) const {
+  date::local_seconds timePoint{timestamp};
+  validateRange(date::sys_seconds{timestamp});
+
+  if (tz_ == nullptr) {
+    // We can ignore `choose` as time offset conversions are always linear.
+    return (timePoint - offset_).time_since_epoch();
+  }
+
+  if (choose == TimeZone::TChoose::kFail) {
+    // By default, throws.
+    return date::zoned_time{tz_, timePoint}.get_sys_time().time_since_epoch();
+  }
+
+  auto dateChoose = (choose == TimeZone::TChoose::kEarliest)
+      ? date::choose::earliest
+      : date::choose::latest;
+  return date::zoned_time{tz_, timePoint, dateChoose}
+      .get_sys_time()
+      .time_since_epoch();
+}
+
+TimeZone::seconds TimeZone::to_local(TimeZone::seconds timestamp) const {
+  date::sys_seconds timePoint{timestamp};
+  validateRange(timePoint);
+
+  // If this is an offset time zone.
+  if (tz_ == nullptr) {
+    return (timePoint + offset_).time_since_epoch();
+  }
+  return date::zoned_time{tz_, timePoint}.get_local_time().time_since_epoch();
 }
 
-} // namespace facebook::velox::util
+} // namespace facebook::velox::tz
diff --git a/velox/type/tz/TimeZoneMap.h b/velox/type/tz/TimeZoneMap.h
index 0cb3f8266efaa..b5393d366fab1 100644
--- a/velox/type/tz/TimeZoneMap.h
+++ b/velox/type/tz/TimeZoneMap.h
@@ -16,14 +16,142 @@
 
 #pragma once
 
+#include <chrono>
 #include <string>
 
-namespace facebook::velox::util {
+namespace facebook::velox::date {
+class time_zone;
+}
 
-// Returns the timezone name associated with timeZoneID.
+namespace facebook::velox::tz {
+
+/// This library provides time zone management primitives. It maintains an
+/// internal static database which is contructed lazily based on the first
+/// access, based on TimeZoneDatabase.cpp and the local tzdata installed in your
+/// system (through velox/external/date).
+///
+/// It provides functions for one to lookup TimeZone pointers based on time zone
+/// name or ID, and to performance timestamp conversion across time zones.
+///
+/// This library provides a layer of functionality on top of
+/// velox/external/date, so do not use the external library directly for
+/// time zone routines.
+
+class TimeZone;
+
+/// Returns a TimeZone pointer based on a time zone name. This makes an hash
+/// map access, and will construct the index on the first access. `failOnError`
+/// controls whether to throw or return nullptr in case the time zone was not
+/// found.
+const TimeZone* locateZone(std::string_view timeZone, bool failOnError = true);
+
+/// Returns a TimeZone pointer based on a time zone ID. This makes a simple
+/// vector access, and will construct the index on the first access.
+/// `failOnError` controls whether to throw or return nullptr in case the time
+/// zone ID was not valid.
+const TimeZone* locateZone(int16_t timeZoneID, bool failOnError = true);
+
+/// Returns the timezone name associated with timeZoneID.
 std::string getTimeZoneName(int64_t timeZoneID);
 
-// Returns the timeZoneID for the timezone name.
-int64_t getTimeZoneID(std::string_view timeZone);
+/// Returns the timeZoneID for the timezone name.
+/// If failOnError = true, throws an exception for unrecognized timezone.
+/// Otherwise, returns -1.
+int16_t getTimeZoneID(std::string_view timeZone, bool failOnError = true);
+
+/// Returns the timeZoneID for a given offset in minutes. The offset must be in
+/// [-14:00, +14:00] range.
+int16_t getTimeZoneID(int32_t offsetMinutes);
+
+// Validates that the time point can be safely used by the external date
+// library.
+template <typename T>
+using time_point = std::chrono::time_point<std::chrono::system_clock, T>;
+
+void validateRange(time_point<std::chrono::seconds> timePoint);
+void validateRange(time_point<std::chrono::milliseconds> timePoint);
+
+/// TimeZone is the proxy object for time zone management. It provides access to
+/// time zone names, their IDs (as defined in TimeZoneDatabase.cpp and
+/// consistent with Presto), and utilities for timestamp conversion across
+/// timezones by leveraging the .to_sys() and .to_local() methods as documented
+/// in:
+///
+///   https://howardhinnant.github.io/date/tz.html
+///
+/// Do not create your own objects; rather, look up a pointer by using one of
+/// the methods above.
+class TimeZone {
+ public:
+  // Constructor for regular time zones with a name and a pointer to
+  // external/date time zone database (from tzdata).
+  TimeZone(
+      std::string_view timeZoneName,
+      int16_t timeZoneID,
+      const date::time_zone* tz)
+      : tz_(tz),
+        offset_(0),
+        timeZoneName_(timeZoneName),
+        timeZoneID_(timeZoneID) {}
+
+  // Constructor for time zone offsets ("+00:00").
+  TimeZone(
+      std::string_view timeZoneName,
+      int16_t timeZoneID,
+      std::chrono::minutes offset)
+      : tz_(nullptr),
+        offset_(offset),
+        timeZoneName_(timeZoneName),
+        timeZoneID_(timeZoneID) {}
+
+  // Do not copy it.
+  TimeZone(const TimeZone&) = delete;
+  TimeZone& operator=(const TimeZone&) = delete;
+
+  using seconds = std::chrono::seconds;
+
+  /// Converts a local time (the time as perceived in the user time zone
+  /// represented by this object) to a system time (the corresponding time in
+  /// GMT at the same instant).
+  ///
+  /// Conversions from local time to GMT are non-linear and may be ambiguous
+  /// during day light savings transitions, or non existent. By default (kFail),
+  /// `to_sys()` will throw `date::ambiguous_local_time` and
+  /// `date::nonexistent_local_time` in these cases.
+  ///
+  /// You can overwrite the behavior in ambiguous conversions by setting the
+  /// TChoose flag, but it will still throws in case of nonexistent conversions.
+  enum class TChoose {
+    kFail = 0,
+    kEarliest = 1,
+    kLatest = 2,
+  };
+
+  seconds to_sys(seconds timestamp, TChoose choose = TChoose::kFail) const;
+
+  /// Do the opposite conversion. Taking a system time (the time as perceived in
+  /// GMT), convert to the same instant in time as observed in the user local
+  /// time represented by this object). Note that this conversion is not
+  /// susceptible to the error above.
+  seconds to_local(seconds timestamp) const;
+
+  const std::string& name() const {
+    return timeZoneName_;
+  }
+
+  int16_t id() const {
+    return timeZoneID_;
+  }
+
+  const date::time_zone* tz() const {
+    return tz_;
+  }
+
+ private:
+  const date::time_zone* tz_{nullptr};
+  const std::chrono::minutes offset_{0};
+  const std::string timeZoneName_;
+  const int16_t timeZoneID_;
+};
 
-} // namespace facebook::velox::util
+} // namespace facebook::velox::tz
diff --git a/velox/type/tz/gen_timezone_database.py b/velox/type/tz/gen_timezone_database.py
index 2ba00f1f663a1..68d53ef1ad9ea 100755
--- a/velox/type/tz/gen_timezone_database.py
+++ b/velox/type/tz/gen_timezone_database.py
@@ -48,21 +48,27 @@
 
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace facebook::velox::util {
 
-const std::unordered_map<int64_t, std::string>& getTimeZoneDB() {
-  static std::unordered_map<int64_t, std::string> tzDB = {
+const std::vector<std::pair<int16_t, std::string>>& getTimeZoneEntries() {
+  static auto* tzDB = new std::vector<std::pair<int16_t, std::string>>([] {
+    // Work around clang compiler bug causing multi-hour compilation
+    // with -fsanitize=fuzzer
+    // https://github.com/llvm/llvm-project/issues/75666
+    return std::vector<std::pair<int16_t, std::string>>{
 $entries
-  };
-  return tzDB;
+    };
+  }());
+  return *tzDB;
 }
 
 } // namespace facebook::velox::util\
 """
 )
 
-entry_template = Template('      {$tz_id, "$tz_name"},')
+entry_template = Template('        {$tz_id, "$tz_name"},')
 
 
 def parse_arguments():
diff --git a/velox/type/tz/tests/CMakeLists.txt b/velox/type/tz/tests/CMakeLists.txt
index 6ace92f58a554..5c17513afaad0 100644
--- a/velox/type/tz/tests/CMakeLists.txt
+++ b/velox/type/tz/tests/CMakeLists.txt
@@ -13,7 +13,25 @@
 # limitations under the License.
 
 add_executable(velox_type_tz_test TimeZoneMapTest.cpp)
-
 add_test(velox_type_tz_test velox_type_tz_test)
 
-target_link_libraries(velox_type_tz_test velox_type_tz gtest gtest_main pthread)
+target_link_libraries(
+  velox_type_tz_test
+  velox_type_tz
+  velox_exception
+  GTest::gtest
+  GTest::gtest_main
+  pthread)
+
+add_executable(velox_type_tz_ext_invalid_test
+               TimeZoneMapExternalInvalidTest.cpp)
+add_test(velox_type_tz_ext_invalid_test velox_type_tz_ext_invalid_test)
+
+target_link_libraries(
+  velox_type_tz_ext_invalid_test
+  velox_type_tz
+  velox_test_util
+  velox_exception
+  GTest::gtest
+  GTest::gtest_main
+  pthread)
diff --git a/velox/type/tz/tests/TimeZoneMapExternalInvalidTest.cpp b/velox/type/tz/tests/TimeZoneMapExternalInvalidTest.cpp
new file mode 100644
index 0000000000000..b5668f929d72e
--- /dev/null
+++ b/velox/type/tz/tests/TimeZoneMapExternalInvalidTest.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/external/date/tz.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox::tz {
+namespace {
+
+using namespace std::chrono;
+
+DEBUG_ONLY_TEST(TimeZoneMapExternalInvalidTest, externalInvalid) {
+  const int16_t testZoneId = 1681;
+  const std::string testZone = "Africa/Abidjan";
+  common::testutil::TestValue::enable();
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::tz::locateZoneImpl",
+      std::function<void(std::string_view * tz_name)>(
+          [&](std::string_view* tz_name) -> void {
+            if (*tz_name == testZone) {
+              // Emulates an invalid_timezone error thrown from external API
+              // date::locate_zone. In real scenarios, this could happen when
+              // the timezone is not found in operating system's timezone list.
+              throw date::invalid_timezone(std::string(*tz_name));
+            }
+          }));
+
+  VELOX_ASSERT_THROW(
+      getTimeZoneName(testZoneId), "Unable to resolve timeZoneID");
+  VELOX_ASSERT_THROW(getTimeZoneID(testZone), "Unknown time zone");
+
+  EXPECT_EQ("UTC", getTimeZoneName(0));
+  EXPECT_EQ(0, getTimeZoneID("+00:00"));
+  EXPECT_EQ("Africa/Accra", getTimeZoneName(1682));
+  EXPECT_EQ(1682, getTimeZoneID("Africa/Accra"));
+}
+} // namespace
+} // namespace facebook::velox::tz
diff --git a/velox/type/tz/tests/TimeZoneMapTest.cpp b/velox/type/tz/tests/TimeZoneMapTest.cpp
index c5b89f6d696a2..c56d6ef9c3acd 100644
--- a/velox/type/tz/tests/TimeZoneMapTest.cpp
+++ b/velox/type/tz/tests/TimeZoneMapTest.cpp
@@ -16,33 +16,223 @@
 
 #include <gtest/gtest.h>
 
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/external/date/date.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
-namespace facebook::velox::util {
+namespace facebook::velox::tz {
 namespace {
 
-TEST(TimeZoneMapTest, simple) {
+using namespace std::chrono;
+
+TEST(TimeZoneMapTest, locateZoneID) {
+  auto locateZoneID = [&](std::string_view name) {
+    const auto* tz = locateZone(name);
+    EXPECT_NE(tz, nullptr);
+    return tz->id();
+  };
+
+  EXPECT_EQ(0, locateZoneID("UTC"));
+  EXPECT_EQ(0, locateZoneID("+00:00"));
+  EXPECT_EQ(0, locateZoneID("-00:00"));
+  EXPECT_EQ(831, locateZoneID("-00:10"));
+  EXPECT_EQ(462, locateZoneID("-06:19"));
+  EXPECT_EQ(1315, locateZoneID("+07:55"));
+  EXPECT_EQ(1680, locateZoneID("+14:00"));
+  EXPECT_EQ(1720, locateZoneID("Africa/Maseru"));
+  EXPECT_EQ(2141, locateZoneID("Pacific/Marquesas"));
+  EXPECT_EQ(2215, locateZoneID("Asia/Chita"));
+  EXPECT_EQ(2233, locateZoneID("America/Ciudad_Juarez"));
+}
+
+TEST(TimeZoneMapTest, locateZoneUTCAlias) {
+  auto locateZoneID = [&](std::string_view name) {
+    const auto* tz = locateZone(name);
+    EXPECT_NE(tz, nullptr);
+    return tz->name();
+  };
+
+  // Ensure all of these aliases resolve to a time zone called "UTC".
+  EXPECT_EQ("UTC", locateZoneID("UTC"));
+  EXPECT_EQ("UTC", locateZoneID("gmt"));
+  EXPECT_EQ("UTC", locateZoneID("Z"));
+  EXPECT_EQ("UTC", locateZoneID("zulu"));
+  EXPECT_EQ("UTC", locateZoneID("Greenwich"));
+  EXPECT_EQ("UTC", locateZoneID("gmt0"));
+  EXPECT_EQ("UTC", locateZoneID("GMT"));
+  EXPECT_EQ("UTC", locateZoneID("uct"));
+  EXPECT_EQ("UTC", locateZoneID("+00:00"));
+  EXPECT_EQ("UTC", locateZoneID("-00:00"));
+}
+
+TEST(TimeZoneMapTest, offsetToLocal) {
+  auto toLocalTime = [&](std::string_view name, size_t ts) {
+    const auto* tz = locateZone(name);
+    EXPECT_NE(tz, nullptr);
+    return tz->to_local(seconds{ts}).count();
+  };
+
+  // Ensure all of these aliases resolve to a time zone called "UTC".
+  EXPECT_EQ(0, toLocalTime("+00:00", 0));
+  EXPECT_EQ(60, toLocalTime("+00:01", 0));
+  EXPECT_EQ(-60, toLocalTime("-00:01", 0));
+  EXPECT_EQ(3600, toLocalTime("+01:00", 0));
+  EXPECT_EQ(-3660, toLocalTime("-01:01", 0));
+
+  // In "2024-07-25", America/Los_Angeles was in daylight savings time (UTC-07).
+  size_t ts = 1721890800;
+  EXPECT_EQ(toLocalTime("-07:00", ts), toLocalTime("America/Los_Angeles", ts));
+  EXPECT_NE(toLocalTime("-08:00", ts), toLocalTime("America/Los_Angeles", ts));
+
+  // In "2024-01-01", it was not (UTC-08).
+  ts = 1704096000;
+  EXPECT_EQ(toLocalTime("-08:00", ts), toLocalTime("America/Los_Angeles", ts));
+  EXPECT_NE(toLocalTime("-07:00", ts), toLocalTime("America/Los_Angeles", ts));
+}
+
+TEST(TimeZoneMapTest, offsetToSys) {
+  auto toSysTime = [&](std::string_view name, size_t ts) {
+    const auto* tz = locateZone(name);
+    EXPECT_NE(tz, nullptr);
+    return tz->to_sys(seconds{ts}).count();
+  };
+
+  // Ensure all of these aliases resolve to a time zone called "UTC".
+  EXPECT_EQ(0, toSysTime("+00:00", 0));
+  EXPECT_EQ(-60, toSysTime("+00:01", 0));
+  EXPECT_EQ(+60, toSysTime("-00:01", 0));
+  EXPECT_EQ(-3600, toSysTime("+01:00", 0));
+  EXPECT_EQ(+3660, toSysTime("-01:01", 0));
+
+  // In "2024-07-25", America/Los_Angeles was in daylight savings time (UTC-07).
+  size_t ts = 1721890800;
+  EXPECT_EQ(toSysTime("-07:00", ts), toSysTime("America/Los_Angeles", ts));
+  EXPECT_NE(toSysTime("-08:00", ts), toSysTime("America/Los_Angeles", ts));
+
+  // In "2024-01-01", it was not (UTC-08).
+  ts = 1704096000;
+  EXPECT_EQ(toSysTime("-08:00", ts), toSysTime("America/Los_Angeles", ts));
+  EXPECT_NE(toSysTime("-07:00", ts), toSysTime("America/Los_Angeles", ts));
+}
+
+TEST(TimeZoneMapTest, timePointBoundary) {
+  using namespace date;
+
+  const auto* tz = locateZone("+00:01");
+  EXPECT_NE(tz, nullptr);
+
+  auto trySysYear = [&](year y) {
+    auto date = year_month_day(y, month(1), day(1));
+    return tz->to_sys(sys_days{date}.time_since_epoch());
+  };
+
+  auto tryLocalYear = [&](year y) {
+    auto date = year_month_day(y, month(1), day(1));
+    return tz->to_local(sys_days{date}.time_since_epoch());
+  };
+
+  EXPECT_NO_THROW(trySysYear(year(0)));
+  EXPECT_NO_THROW(trySysYear(year::max()));
+  EXPECT_NO_THROW(trySysYear(year::min()));
+
+  EXPECT_NO_THROW(tryLocalYear(year(0)));
+  EXPECT_NO_THROW(tryLocalYear(year::max()));
+  EXPECT_NO_THROW(tryLocalYear(year::min()));
+
+  std::string expected = "Timepoint is outside of supported year range";
+  VELOX_ASSERT_THROW(trySysYear(year(int(year::max()) + 1)), expected);
+  VELOX_ASSERT_THROW(trySysYear(year(int(year::min()) - 1)), expected);
+
+  VELOX_ASSERT_THROW(tryLocalYear(year(int(year::max()) + 1)), expected);
+  VELOX_ASSERT_THROW(tryLocalYear(year(int(year::min()) - 1)), expected);
+
+  // This time point triggers an assertion failure in external/date. Make sure
+  // we catch and throw before getting to that point.
+  VELOX_ASSERT_THROW(tz->to_sys(seconds{-1096193779200l - 86400l}), expected);
+}
+
+TEST(TimeZoneMapTest, getTimeZoneName) {
   EXPECT_EQ("America/Los_Angeles", getTimeZoneName(1825));
   EXPECT_EQ("Europe/Moscow", getTimeZoneName(2079));
   EXPECT_EQ("Pacific/Kanton", getTimeZoneName(2231));
   EXPECT_EQ("Europe/Kyiv", getTimeZoneName(2232));
   EXPECT_EQ("America/Ciudad_Juarez", getTimeZoneName(2233));
   EXPECT_EQ("-00:01", getTimeZoneName(840));
+  EXPECT_EQ("UTC", getTimeZoneName(0));
+}
 
+TEST(TimeZoneMapTest, getTimeZoneID) {
   EXPECT_EQ(1825, getTimeZoneID("America/Los_Angeles"));
   EXPECT_EQ(2079, getTimeZoneID("Europe/Moscow"));
   EXPECT_EQ(2231, getTimeZoneID("Pacific/Kanton"));
   EXPECT_EQ(2232, getTimeZoneID("Europe/Kyiv"));
   EXPECT_EQ(2233, getTimeZoneID("America/Ciudad_Juarez"));
+  EXPECT_EQ(0, getTimeZoneID("UTC"));
+  EXPECT_EQ(0, getTimeZoneID("GMT"));
+  EXPECT_EQ(0, getTimeZoneID("Z"));
+  EXPECT_EQ(0, getTimeZoneID("z"));
+  EXPECT_EQ(0, getTimeZoneID("greenwich"));
+  EXPECT_EQ(0, getTimeZoneID("ETC/GMT"));
+  EXPECT_EQ(0, getTimeZoneID("ETC/GMT0"));
+  EXPECT_EQ(0, getTimeZoneID("ETC/UCT"));
+  EXPECT_EQ(0, getTimeZoneID("ETC/universal"));
+  EXPECT_EQ(0, getTimeZoneID("etc/zulu"));
+
+  // (+/-)XX:MM format.
   EXPECT_EQ(840, getTimeZoneID("-00:01"));
   EXPECT_EQ(0, getTimeZoneID("+00:00"));
+  EXPECT_EQ(0, getTimeZoneID("-00:00"));
+  EXPECT_EQ(454, getTimeZoneID("-06:27"));
+  EXPECT_EQ(541, getTimeZoneID("-05:00"));
+  EXPECT_EQ(1140, getTimeZoneID("+05:00"));
+
+  // Incomplete time zone offsets.
+  EXPECT_EQ(1140, getTimeZoneID("+05"));
+  EXPECT_EQ(1140, getTimeZoneID("+0500"));
+  EXPECT_EQ(1150, getTimeZoneID("+0510"));
+  EXPECT_EQ(181, getTimeZoneID("-1100"));
+  EXPECT_EQ(181, getTimeZoneID("-11"));
+  EXPECT_EQ(0, getTimeZoneID("+0000"));
+
+  EXPECT_EQ(0, getTimeZoneID("etc/GMT+0"));
+  EXPECT_EQ(0, getTimeZoneID("etc/GMT-0"));
+  EXPECT_EQ(1020, getTimeZoneID("etc/GMT-3"));
+  EXPECT_EQ(301, getTimeZoneID("etc/GMT+9"));
+  EXPECT_EQ(1680, getTimeZoneID("etc/GMT-14"));
+
+  // Case insensitive.
+  EXPECT_EQ(0, getTimeZoneID("utc"));
+  EXPECT_EQ(1825, getTimeZoneID("america/los_angeles"));
+  EXPECT_EQ(1825, getTimeZoneID("aMERICa/los_angeles"));
+}
+
+TEST(TimeZoneMapTest, getTimeZoneIDFromOffset) {
+  auto nameFromOffset = [&](int32_t offset) {
+    return getTimeZoneName(getTimeZoneID(offset));
+  };
+
+  // "+00:00" is an alias to UTC.
+  EXPECT_EQ("UTC", nameFromOffset(0));
+  EXPECT_EQ("+05:30", nameFromOffset(5 * 60 + 30));
+  EXPECT_EQ("-08:00", nameFromOffset(-8 * 60));
+  EXPECT_EQ("+02:17", nameFromOffset(2 * 60 + 17));
+
+  VELOX_ASSERT_THROW(getTimeZoneID(15'000), "Invalid timezone offset");
+  VELOX_ASSERT_THROW(getTimeZoneID(-15'000), "Invalid timezone offset");
 }
 
 TEST(TimeZoneMapTest, invalid) {
-  EXPECT_THROW(getTimeZoneName(99999999), std::runtime_error);
+  VELOX_ASSERT_THROW(getTimeZoneName(99999999), "Unable to resolve timeZoneID");
+  VELOX_ASSERT_THROW(getTimeZoneID("This is a test"), "Unknown time zone");
+
+  VELOX_ASSERT_THROW(getTimeZoneID("ETC/05:00"), "Unknown time zone");
+  VELOX_ASSERT_THROW(getTimeZoneID("ETC+05:00"), "Unknown time zone");
 
-  EXPECT_THROW(getTimeZoneID("This is a test"), std::runtime_error);
+  VELOX_ASSERT_THROW(getTimeZoneID("etc/GMT-15"), "Unknown time zone");
+  VELOX_ASSERT_THROW(getTimeZoneID("etc/GMT+ab"), "Unknown time zone");
+  VELOX_ASSERT_THROW(getTimeZoneID("etc/GMT+300"), "Unknown time zone");
 }
 
 } // namespace
-} // namespace facebook::velox::util
+} // namespace facebook::velox::tz
diff --git a/velox/vector/BaseVector.cpp b/velox/vector/BaseVector.cpp
index cd959a1dc1a71..2ae0d69212ff4 100644
--- a/velox/vector/BaseVector.cpp
+++ b/velox/vector/BaseVector.cpp
@@ -19,11 +19,13 @@
 #include "velox/type/Type.h"
 #include "velox/type/Variant.h"
 #include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
 #include "velox/vector/DictionaryVector.h"
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/LazyVector.h"
 #include "velox/vector/SequenceVector.h"
 #include "velox/vector/TypeAliases.h"
+#include "velox/vector/VectorEncoding.h"
 #include "velox/vector/VectorPool.h"
 #include "velox/vector/VectorTypeUtils.h"
 
@@ -54,7 +56,7 @@ BaseVector::BaseVector(
 
   if (nulls_) {
     int32_t bytes = byteSize<bool>(length_);
-    VELOX_CHECK(nulls_->capacity() >= bytes);
+    VELOX_CHECK_GE(nulls_->capacity(), bytes);
     if (nulls_->size() < bytes) {
       // Set the size so that values get preserved by resize. Do not
       // set if already large enough, so that it is safe to take a
@@ -68,9 +70,9 @@ BaseVector::BaseVector(
 void BaseVector::ensureNullsCapacity(
     vector_size_t minimumSize,
     bool setNotNull) {
-  auto fill = setNotNull ? bits::kNotNull : bits::kNull;
+  const auto fill = setNotNull ? bits::kNotNull : bits::kNull;
   // Ensure the size of nulls_ is always at least as large as length_.
-  auto size = std::max(minimumSize, length_);
+  const auto size = std::max<vector_size_t>(minimumSize, length_);
   if (nulls_ && !nulls_->isView() && nulls_->unique()) {
     if (nulls_->capacity() < bits::nbytes(size)) {
       AlignedBuffer::reallocate<bool>(&nulls_, size, fill);
@@ -87,10 +89,10 @@ void BaseVector::ensureNullsCapacity(
   } else {
     auto newNulls = AlignedBuffer::allocate<bool>(size, pool_, fill);
     if (nulls_) {
-      memcpy(
+      ::memcpy(
           newNulls->asMutable<char>(),
           nulls_->as<char>(),
-          byteSize<bool>(std::min(length_, size)));
+          byteSize<bool>(std::min<vector_size_t>(length_, size)));
     }
     nulls_ = std::move(newNulls);
     rawNulls_ = nulls_->as<uint64_t>();
@@ -104,7 +106,7 @@ uint64_t BaseVector::byteSize<bool>(vector_size_t count) {
 
 void BaseVector::resize(vector_size_t size, bool setNotNull) {
   if (nulls_) {
-    auto bytes = byteSize<bool>(size);
+    const auto bytes = byteSize<bool>(size);
     if (length_ < size || nulls_->isView()) {
       ensureNullsCapacity(size, setNotNull);
     }
@@ -122,7 +124,7 @@ static VectorPtr addDictionary(
   auto pool = vector->pool();
   return std::make_shared<
       DictionaryVector<typename KindToFlatVector<kind>::WrapperType>>(
-      pool, nulls, size, std::move(vector), std::move(indices));
+      pool, std::move(nulls), size, std::move(vector), std::move(indices));
 }
 
 // static
@@ -191,7 +193,7 @@ static VectorPtr addConstant(
     bool copyBase) {
   using T = typename KindToFlatVector<kind>::WrapperType;
 
-  auto pool = vector->pool();
+  auto* pool = vector->pool();
 
   if (vector->isNullAt(index)) {
     if constexpr (std::is_same_v<T, ComplexType>) {
@@ -219,7 +221,7 @@ static VectorPtr addConstant(
       index = constVector->index();
       vector = vector->valueVector();
     } else if (vector->encoding() == VectorEncoding::Simple::DICTIONARY) {
-      BufferPtr indices = vector->as<DictionaryVector<T>>()->indices();
+      const BufferPtr& indices = vector->as<DictionaryVector<T>>()->indices();
       index = indices->as<vector_size_t>()[index];
       vector = vector->valueVector();
     } else {
@@ -244,11 +246,26 @@ VectorPtr BaseVector::wrapInConstant(
     vector_size_t index,
     VectorPtr vector,
     bool copyBase) {
-  auto kind = vector->typeKind();
+  const auto kind = vector->typeKind();
   return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
       addConstant, kind, length, index, std::move(vector), copyBase);
 }
 
+std::optional<bool> BaseVector::equalValueAt(
+    const BaseVector* other,
+    vector_size_t index,
+    vector_size_t otherIndex,
+    CompareFlags::NullHandlingMode nullHandlingMode) const {
+  const CompareFlags compareFlags = CompareFlags::equality(nullHandlingMode);
+  std::optional<int32_t> result =
+      compare(other, index, otherIndex, compareFlags);
+  if (result.has_value()) {
+    return result.value() == 0;
+  }
+
+  return std::nullopt;
+}
+
 template <TypeKind kind>
 static VectorPtr createEmpty(
     vector_size_t size,
@@ -283,11 +300,10 @@ VectorPtr BaseVector::createInternal(
   switch (kind) {
     case TypeKind::ROW: {
       std::vector<VectorPtr> children;
-      auto rowType = type->as<TypeKind::ROW>();
-      // Children are reserved the parent size but are set to 0 elements.
+      auto& rowType = type->as<TypeKind::ROW>();
+      // Children are reserved the parent size and accessible for those rows.
       for (int32_t i = 0; i < rowType.size(); ++i) {
         children.push_back(create(rowType.childAt(i), size, pool));
-        children.back()->resize(0);
       }
       return std::make_shared<RowVector>(
           pool, type, nullptr, size, std::move(children));
@@ -295,7 +311,7 @@ VectorPtr BaseVector::createInternal(
     case TypeKind::ARRAY: {
       BufferPtr sizes = allocateSizes(size, pool);
       BufferPtr offsets = allocateOffsets(size, pool);
-      auto elementType = type->as<TypeKind::ARRAY>().elementType();
+      const auto& elementType = type->as<TypeKind::ARRAY>().elementType();
       auto elements = create(elementType, 0, pool);
       return std::make_shared<ArrayVector>(
           pool,
@@ -309,8 +325,8 @@ VectorPtr BaseVector::createInternal(
     case TypeKind::MAP: {
       BufferPtr sizes = allocateSizes(size, pool);
       BufferPtr offsets = allocateOffsets(size, pool);
-      auto keyType = type->as<TypeKind::MAP>().keyType();
-      auto valueType = type->as<TypeKind::MAP>().valueType();
+      const auto& keyType = type->as<TypeKind::MAP>().keyType();
+      const auto& valueType = type->as<TypeKind::MAP>().valueType();
       auto keys = create(keyType, 0, pool);
       auto values = create(valueType, 0, pool);
       return std::make_shared<MapVector>(
@@ -326,7 +342,12 @@ VectorPtr BaseVector::createInternal(
     case TypeKind::UNKNOWN: {
       BufferPtr nulls = allocateNulls(size, pool, bits::kNull);
       return std::make_shared<FlatVector<UnknownValue>>(
-          pool, UNKNOWN(), nulls, size, nullptr, std::vector<BufferPtr>());
+          pool,
+          UNKNOWN(),
+          std::move(nulls),
+          size,
+          nullptr,
+          std::vector<BufferPtr>());
     }
     default:
       return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
@@ -358,16 +379,14 @@ void BaseVector::copyNulls(
 }
 
 void BaseVector::addNulls(const uint64_t* bits, const SelectivityVector& rows) {
+  if (bits == nullptr || !rows.hasSelections()) {
+    return;
+  }
   VELOX_CHECK(isNullsWritable());
-  VELOX_CHECK(length_ >= rows.end());
+  VELOX_CHECK_GE(length_, rows.end());
   ensureNulls();
   auto target = nulls_->asMutable<uint64_t>();
   const uint64_t* selected = rows.asRange().bits();
-  if (!bits) {
-    // A 1 in rows makes a 0 in nulls.
-    bits::andWithNegatedBits(target, selected, rows.begin(), rows.end());
-    return;
-  }
   // A 0 in bits with a 1 in rows makes a 0 in nulls.
   bits::forEachWord(
       rows.begin(),
@@ -380,13 +399,27 @@ void BaseVector::addNulls(const uint64_t* bits, const SelectivityVector& rows) {
       });
 }
 
-void BaseVector::clearNulls(const SelectivityVector& rows) {
+void BaseVector::addNulls(const SelectivityVector& nullRows) {
+  if (!nullRows.hasSelections()) {
+    return;
+  }
+  VELOX_CHECK(isNullsWritable());
+  VELOX_CHECK_GE(length_, nullRows.end());
+  ensureNulls();
+  auto target = nulls_->asMutable<uint64_t>();
+  const uint64_t* selected = nullRows.asRange().bits();
+  // A 1 in rows makes a 0 in nulls.
+  bits::andWithNegatedBits(target, selected, nullRows.begin(), nullRows.end());
+  return;
+}
+
+void BaseVector::clearNulls(const SelectivityVector& nonNullRows) {
   VELOX_CHECK(isNullsWritable());
   if (!nulls_) {
     return;
   }
 
-  if (rows.isAllSelected() && rows.end() == length_) {
+  if (nonNullRows.isAllSelected() && nonNullRows.end() == length_) {
     nulls_ = nullptr;
     rawNulls_ = nullptr;
     nullCount_ = 0;
@@ -396,9 +429,9 @@ void BaseVector::clearNulls(const SelectivityVector& rows) {
   auto rawNulls = nulls_->asMutable<uint64_t>();
   bits::orBits(
       rawNulls,
-      rows.asRange().bits(),
-      std::min(length_, rows.begin()),
-      std::min(length_, rows.end()));
+      nonNullRows.asRange().bits(),
+      std::min<vector_size_t>(length_, nonNullRows.begin()),
+      std::min<vector_size_t>(length_, nonNullRows.end()));
   nullCount_ = std::nullopt;
 }
 
@@ -415,8 +448,8 @@ void BaseVector::clearNulls(vector_size_t begin, vector_size_t end) {
     return;
   }
 
-  auto rawNulls = nulls_->asMutable<uint64_t>();
-  bits::fillBits(rawNulls, begin, end, true);
+  auto* rawNulls = nulls_->asMutable<uint64_t>();
+  bits::fillBits(rawNulls, begin, end, bits::kNotNull);
   nullCount_ = std::nullopt;
 }
 
@@ -435,27 +468,33 @@ void BaseVector::setNulls(const BufferPtr& nulls) {
 
 // static
 void BaseVector::resizeIndices(
-    vector_size_t size,
+    vector_size_t currentSize,
+    vector_size_t newSize,
     velox::memory::MemoryPool* pool,
-    BufferPtr* indices,
-    const vector_size_t** raw) {
-  const auto newNumBytes = byteSize<vector_size_t>(size);
-  if (indices->get() && !indices->get()->isView() && indices->get()->unique()) {
-    if (indices->get()->size() < newNumBytes) {
-      AlignedBuffer::reallocate<vector_size_t>(indices, size, 0);
+    BufferPtr& indices,
+    const vector_size_t** rawIndices) {
+  const auto newNumBytes = byteSize<vector_size_t>(newSize);
+  if (indices != nullptr && !indices->isView() && indices->unique()) {
+    if (indices->size() < newNumBytes) {
+      AlignedBuffer::reallocate<vector_size_t>(&indices, newSize, 0);
+    }
+    // indices->size() may cover more indices than currentSize.
+    if (newSize > currentSize) {
+      auto* raw = indices->asMutable<vector_size_t>();
+      std::fill(raw + currentSize, raw + newSize, 0);
     }
   } else {
-    auto newIndices = AlignedBuffer::allocate<vector_size_t>(size, pool, 0);
-    if (indices->get()) {
-      auto dst = newIndices->asMutable<vector_size_t>();
-      auto src = indices->get()->as<vector_size_t>();
-      auto numCopyBytes =
-          std::min<vector_size_t>(indices->get()->size(), newNumBytes);
+    auto newIndices = AlignedBuffer::allocate<vector_size_t>(newSize, pool, 0);
+    if (indices != nullptr) {
+      auto* dst = newIndices->asMutable<vector_size_t>();
+      const auto* src = indices->as<vector_size_t>();
+      const auto numCopyBytes = std::min<vector_size_t>(
+          byteSize<vector_size_t>(currentSize), newNumBytes);
       memcpy(dst, src, numCopyBytes);
     }
-    *indices = newIndices;
+    indices = newIndices;
   }
-  *raw = indices->get()->asMutable<vector_size_t>();
+  *rawIndices = indices->asMutable<vector_size_t>();
 }
 
 std::string BaseVector::toSummaryString() const {
@@ -555,7 +594,7 @@ void BaseVector::ensureWritable(
     }
     return;
   }
-  auto resultType = result->type();
+  const auto& resultType = result->type();
   bool isUnknownType = resultType->containsUnknown();
   if (result->encoding() == VectorEncoding::Simple::LAZY) {
     result = BaseVector::loadedVectorShared(result);
@@ -670,36 +709,21 @@ void BaseVector::copy(
     const BaseVector* source,
     const SelectivityVector& rows,
     const vector_size_t* toSourceRow) {
-  // Check if there are rows that do not exist in 'source'. Remove these from
-  // 'ranges'.
-  // TODO Update the callers and remove this logic.
-
+  if (!rows.hasSelections()) {
+    return;
+  }
   std::vector<CopyRange> ranges;
   if (toSourceRow == nullptr) {
-    if (source->size() < rows.end()) {
-      SelectivityVector trimmedRows = rows;
-      trimmedRows.setValidRange(source->size(), rows.end(), false);
-      trimmedRows.updateBounds();
-
-      ranges = toCopyRanges(trimmedRows);
-    } else {
-      ranges = toCopyRanges(rows);
-    }
+    VELOX_CHECK_GE(source->size(), rows.end());
+    ranges = toCopyRanges(rows);
   } else {
     ranges.reserve(rows.end());
     rows.applyToSelected([&](vector_size_t row) {
       const auto sourceRow = toSourceRow[row];
-      if (sourceRow >= source->size()) {
-        return;
-      }
+      VELOX_DCHECK_GT(source->size(), sourceRow);
       ranges.push_back({sourceRow, row, 1});
     });
   }
-
-  if (ranges.empty()) {
-    return;
-  }
-
   copyRanges(source, ranges);
 }
 
@@ -738,11 +762,24 @@ const VectorPtr& BaseVector::loadedVectorShared(const VectorPtr& vector) {
 VectorPtr BaseVector::transpose(BufferPtr indices, VectorPtr&& source) {
   // TODO: Reuse the indices if 'source' is already a dictionary and
   // there are no other users of its indices.
+  vector_size_t size = indices->size() / sizeof(vector_size_t);
   return wrapInDictionary(
-      BufferPtr(nullptr),
-      indices,
-      indices->size() / sizeof(vector_size_t),
-      std::move(source));
+      BufferPtr(nullptr), std::move(indices), size, std::move(source));
+}
+
+// static
+const VectorPtr& BaseVector::wrappedVectorShared(const VectorPtr& vector) {
+  switch (vector->encoding()) {
+    case VectorEncoding::Simple::CONSTANT:
+    case VectorEncoding::Simple::DICTIONARY:
+    case VectorEncoding::Simple::SEQUENCE:
+      return vector->valueVector() ? wrappedVectorShared(vector->valueVector())
+                                   : vector;
+    case VectorEncoding::Simple::LAZY:
+      return wrappedVectorShared(loadedVectorShared(vector));
+    default:
+      return vector;
+  }
 }
 
 bool isLazyNotLoaded(const BaseVector& vector) {
@@ -756,6 +793,7 @@ bool isLazyNotLoaded(const BaseVector& vector) {
       // deeper.
       return isLazyNotLoaded(*vector.asUnchecked<LazyVector>()->loadedVector());
     case VectorEncoding::Simple::DICTIONARY:
+      [[fallthrough]];
     case VectorEncoding::Simple::SEQUENCE:
       return isLazyNotLoaded(*vector.valueVector());
     case VectorEncoding::Simple::CONSTANT:
@@ -827,7 +865,7 @@ void BaseVector::flattenVector(VectorPtr& vector) {
       return;
     }
     case VectorEncoding::Simple::LAZY: {
-      auto loadedVector =
+      auto& loadedVector =
           vector->asUnchecked<LazyVector>()->loadedVectorShared();
       BaseVector::flattenVector(loadedVector);
       return;
@@ -853,7 +891,7 @@ void BaseVector::reuseNulls() {
   // there is at least one null bit set. Reset otherwise.
   if (nulls_) {
     if (nulls_->isMutable()) {
-      if (0 == BaseVector::countNulls(nulls_, length_)) {
+      if (BaseVector::countNulls(nulls_, length_) == 0) {
         nulls_ = nullptr;
         rawNulls_ = nullptr;
       }
@@ -1015,4 +1053,92 @@ std::string printIndices(
   return out.str();
 }
 
+template <TypeKind Kind>
+bool isAllSameFlat(const BaseVector& vector, vector_size_t size) {
+  using T = typename KindToFlatVector<Kind>::WrapperType;
+  auto flat = vector.asUnchecked<FlatVector<T>>();
+  auto rawValues = flat->rawValues();
+  if (vector.size() == 0) {
+    return false;
+  }
+  T first = rawValues[0];
+  for (auto i = 1; i < size; ++i) {
+    if (first != rawValues[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <>
+bool isAllSameFlat<TypeKind::BOOLEAN>(
+    const BaseVector& vector,
+    vector_size_t size) {
+  auto& values = vector.asUnchecked<FlatVector<bool>>()->values();
+  auto* bits = values->as<uint64_t>();
+  // Check the all true and all false separately. Easier for compiler if the
+  // last argument is constant.
+  if ((bits[0] & 1) == 1) {
+    return bits ::isAllSet(bits, 0, size, true);
+  }
+  return bits ::isAllSet(bits, 0, size, false);
+}
+
+// static
+VectorPtr BaseVector::constantify(const VectorPtr& input, DecodedVector* temp) {
+  auto& vector = BaseVector::loadedVectorShared(input);
+
+  // If this is already a constant or empty or single element, it can stay as
+  // is.
+  if (vector->encoding() == VectorEncoding::Simple::CONSTANT ||
+      vector->size() < 2) {
+    return nullptr;
+  }
+  // If there is a null, values will either not all be the same or all be null,
+  // which can just as well be left as is.
+  if (vector->isNullAt(0)) {
+    return nullptr;
+  }
+  // Quick return if first and last are different.
+  if (!vector->equalValueAt(vector.get(), 0, vector->size() - 1)) {
+    return nullptr;
+  }
+  DecodedVector localDecoded;
+  DecodedVector* decoded = temp ? temp : &localDecoded;
+  decoded->decode(*vector);
+  if (!decoded->isIdentityMapping()) {
+    auto indices = decoded->indices();
+    auto first = indices[0];
+    for (auto i = 1; i < vector->size(); ++i) {
+      if (indices[i] != first) {
+        if (decoded->isNullAt(i)) {
+          return nullptr;
+        }
+        if (!decoded->base()->equalValueAt(
+                decoded->base(), first, indices[i])) {
+          return nullptr;
+        }
+      }
+    }
+    return BaseVector::wrapInConstant(vector->size(), 0, vector);
+  }
+  if (vector->mayHaveNulls()) {
+    return nullptr;
+  }
+  if (vector->encoding() == VectorEncoding::Simple::FLAT) {
+    if (!VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+            isAllSameFlat, vector->typeKind(), *vector, vector->size() - 1)) {
+      return nullptr;
+    }
+  } else {
+    for (auto i = 1; i < vector->size() - 1; ++i) {
+      if (!vector->equalValueAt(vector.get(), 0, i)) {
+        return nullptr;
+      }
+    }
+  }
+
+  return BaseVector::wrapInConstant(vector->size(), 0, vector);
+}
+
 } // namespace facebook::velox
diff --git a/velox/vector/BaseVector.h b/velox/vector/BaseVector.h
index f986969166179..74478e2f70301 100644
--- a/velox/vector/BaseVector.h
+++ b/velox/vector/BaseVector.h
@@ -52,20 +52,20 @@ class VectorPool;
 class BaseVector;
 using VectorPtr = std::shared_ptr<BaseVector>;
 
-// Set of options that validate() accepts.
+/// Set of options that validate() accepts.
 struct VectorValidateOptions {
-  // If set to true then an unloaded lazy vector is loaded and validate is
-  // called on the loaded vector. NOTE: loading a vector is non-trivial and
-  // can modify how it's handled by downstream code-paths.
+  /// If set to true then an unloaded lazy vector is loaded and validate is
+  /// called on the loaded vector. NOTE: loading a vector is non-trivial and
+  /// can modify how it's handled by downstream code-paths.
   bool loadLazy = false;
 
-  // Any optional checks you want to execute on the vector.
+  /// Any optional checks you want to execute on the vector.
   std::function<void(const BaseVector&)> callback;
 };
 
-/**
- * Base class for all columnar-based vectors of any type.
- */
+class DecodedVector;
+
+/// Base class for all columnar-based vectors of any type.
 class BaseVector {
  public:
   BaseVector(const BaseVector&) = delete;
@@ -94,13 +94,14 @@ class BaseVector {
     return encoding() == VectorEncoding::Simple::LAZY;
   }
 
-  // Returns false if vector has no nulls. Return true if vector may have nulls.
+  /// Returns false if vector has no nulls. Return true if vector may have
+  /// nulls.
   virtual bool mayHaveNulls() const {
     return rawNulls_;
   }
 
-  // Returns false if this vector and all of its children have no nulls. Returns
-  // true if this vector or any of its children may have nulls.
+  /// Returns false if this vector and all of its children have no nulls.
+  /// Returns true if this vector or any of its children may have nulls.
   virtual bool mayHaveNullsRecursive() const {
     return mayHaveNulls();
   }
@@ -122,18 +123,26 @@ class BaseVector {
     return dynamic_cast<const T*>(this);
   }
 
-  // Use when the type of 'this' is already known. dynamic_cast() is slow.
+  /// Use when the type of 'this' is already known. dynamic_cast() is slow.
   template <typename T>
   T* asUnchecked() {
     static_assert(std::is_base_of_v<BaseVector, T>);
-    DCHECK(dynamic_cast<const T*>(this) != nullptr);
+    VELOX_DCHECK_NOT_NULL(
+        dynamic_cast<const T*>(this),
+        "Wrong type cast expected {}, but got {}",
+        typeid(T).name(),
+        typeid(*this).name());
     return static_cast<T*>(this);
   }
 
   template <typename T>
   const T* asUnchecked() const {
     static_assert(std::is_base_of_v<BaseVector, T>);
-    DCHECK(dynamic_cast<const T*>(this) != nullptr);
+    VELOX_DCHECK_NOT_NULL(
+        dynamic_cast<const T*>(this),
+        "Wrong type cast expected {}, but got {}",
+        typeid(T).name(),
+        typeid(*this).name());
     return static_cast<const T*>(this);
   }
 
@@ -177,25 +186,46 @@ class BaseVector {
     return type_;
   }
 
+  /// Changes vector type. The new type can have a different
+  /// logical representation while maintaining the same physical type.
+  /// Additionally, note that the caller must ensure that this vector is not
+  /// shared, i.e. singly-referenced.
+  virtual void setType(const TypePtr& type) {
+    VELOX_CHECK_NOT_NULL(type);
+    VELOX_CHECK(
+        type_->kindEquals(type),
+        "Cannot change vector type from {} to {}. The old and new types can be different logical types, but the underlying physical types must match.",
+        type_,
+        type);
+    type_ = type;
+  }
+
   TypeKind typeKind() const {
     return typeKind_;
   }
 
-  /**
-   * Returns a smart pointer to the null bitmap data for this
-   * vector. May hold nullptr if there are no nulls. Not const because
-   * some vectors may generate this on first access.
-   */
+  /// Returns a smart pointer to the null bitmap data for this vector. May hold
+  /// nullptr if there are no nulls. Not const because some vectors may generate
+  /// this on first access. For ConstantVector, this method returns a BufferPtr
+  /// of only size 1. For DictionaryVector, this method returns a BufferPtr for
+  /// only nulls in the top-level layer.
   const BufferPtr& nulls() const {
     return nulls_;
   }
 
+  /// Returns a pointer to the raw null bitmap buffer of this vector. Notice
+  /// that users should not used this API to access nulls directly of a
+  /// ConstantVector or DictionaryVector. If the vector is a ConstantVector,
+  /// rawNulls_ is only of size 1. If the vector is a DictionaryVector,
+  /// rawNulls_ points to a raw buffer of only nulls in the top-level layer.
+  /// Nulls of a ConstantVector or DictionaryVector can be accessed through the
+  /// isNullAt() API or DecodedVector.
   const uint64_t* rawNulls() const {
     return rawNulls_;
   }
 
-  // Ensures that nulls are writable (mutable and single referenced for
-  // BaseVector::length_).
+  /// Ensures that nulls are writable (mutable and single referenced for
+  /// BaseVector::length_).
   uint64_t* mutableRawNulls() {
     ensureNulls();
     return const_cast<uint64_t*>(rawNulls_);
@@ -210,9 +240,7 @@ class BaseVector {
     return distinctValueCount_;
   }
 
-  /**
-   * @return the number of rows of data in this vector
-   */
+  /// @return the number of rows of data in this vector
   vector_size_t size() const {
     return length_;
   }
@@ -224,49 +252,49 @@ class BaseVector {
     copy(other, previousSize, 0, other->size());
   }
 
-  /**
-   * @return the number of bytes this vector takes on disk when in a compressed
-   * and serialized format
-   */
+  /// @return the number of bytes this vector takes on disk when in a compressed
+  /// and serialized format
   std::optional<ByteCount> storageBytes() const {
     return storageByteCount_;
   }
 
-  /**
-   * @return the number of bytes required to naively represent all of the data
-   * in this vector - the raw data size if not in a compressed or otherwise
-   * optimized format
-   */
+  /// @return the number of bytes required to naively represent all of the data
+  /// in this vector - the raw data size if not in a compressed or otherwise
+  /// optimized format
   std::optional<ByteCount> representedBytes() const {
     return representedByteCount_;
   }
 
-  /**
-   * @return the number of bytes required to hold this vector in memory
-   */
+  /// @return the number of bytes required to hold this vector in memory
   ByteCount inMemoryBytes() const {
     return inMemoryBytes_;
   }
 
-  /**
-   * @return true if this vector has the same value at the given index as the
-   * other vector at the other vector's index (including if both are null),
-   * false otherwise
-   * @throws if the type_ of other doesn't match the type_ of this
-   */
+  /// @return true if this vector has the same value at the given index as the
+  /// other vector at the other vector's index (including if both are null),
+  /// false otherwise
+  /// @throws if the type_ of other doesn't match the type_ of this
   virtual bool equalValueAt(
       const BaseVector* other,
       vector_size_t index,
       vector_size_t otherIndex) const {
-    static constexpr CompareFlags kEqualValueAtFlags = {
-        false,
-        false,
-        true /*equalOnly*/,
-        CompareFlags::NullHandlingMode::NoStop /*nullHandlingMode**/};
-    // Will always have value because nullHandlingMode is NoStop.
+    static constexpr CompareFlags kEqualValueAtFlags =
+        CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
+
+    // Will always have value because nullHandlingMode is NullAsValue.
     return compare(other, index, otherIndex, kEqualValueAtFlags).value() == 0;
   }
 
+  /// Returns true if this vector has the same value at the given index as the
+  /// other vector at the other vector's index (including if both are null when
+  /// nullHandlingMode is NullAsValue), false otherwise. If nullHandlingMode is
+  /// StopAtNull, returns std::nullopt if null encountered.
+  virtual std::optional<bool> equalValueAt(
+      const BaseVector* other,
+      vector_size_t index,
+      vector_size_t otherIndex,
+      CompareFlags::NullHandlingMode nullHandlingMode) const;
+
   int32_t compare(
       const BaseVector* other,
       vector_size_t index,
@@ -279,7 +307,7 @@ class BaseVector {
   /// than 'other' at 'otherIndex', 0 if equal and > 0 otherwise.
   /// When CompareFlags is DESCENDING, returns < 0 if 'this' at 'index' is
   /// larger than 'other' at 'otherIndex', 0 if equal and < 0 otherwise. If
-  /// flags.nullHandlingMode is not NoStop, the function may returns
+  /// flags.nullHandlingMode is not NullAsValue, the function may returns
   /// std::nullopt if null encountered.
   virtual std::optional<int32_t> compare(
       const BaseVector* other,
@@ -320,14 +348,10 @@ class BaseVector {
       vector_size_t size,
       CompareFlags flags);
 
-  /**
-   * @return the hash of the value at the given index in this vector
-   */
+  /// @return the hash of the value at the given index in this vector
   virtual uint64_t hashValueAt(vector_size_t index) const = 0;
 
-  /**
-   * @return a new vector that contains the hashes for all entries
-   */
+  /// @return a new vector that contains the hashes for all entries
   virtual std::unique_ptr<SimpleVector<uint64_t>> hashAll() const = 0;
 
   /// Returns true if this vector is encoded as flat (FlatVector).
@@ -340,35 +364,37 @@ class BaseVector {
     return encoding_ == VectorEncoding::Simple::CONSTANT;
   }
 
-  // Returns true if this vector has a scalar type. If so, values are
-  // accessed by valueAt after casting the vector to a type()
-  // dependent instantiation of SimpleVector<T>.
+  /// Returns true if this vector has a scalar type. If so, values are
+  /// accessed by valueAt after casting the vector to a type()
+  /// dependent instantiation of SimpleVector<T>.
   virtual bool isScalar() const {
     return false;
   }
 
-  // Returns the scalar or complex vector wrapped inside any nesting of
-  // dictionary, sequence or constant vectors.
+  /// Returns the scalar or complex vector wrapped inside any nesting of
+  /// dictionary, sequence or constant vectors.
   virtual const BaseVector* wrappedVector() const {
     return this;
   }
 
-  // Returns the index to apply for 'index' in the vector returned by
-  // wrappedVector(). Translates the index over any nesting of
-  // dictionaries, sequences and constants.
+  static const VectorPtr& wrappedVectorShared(const VectorPtr& vector);
+
+  /// Returns the index to apply for 'index' in the vector returned by
+  /// wrappedVector(). Translates the index over any nesting of dictionaries,
+  /// sequences and constants.
   virtual vector_size_t wrappedIndex(vector_size_t index) const {
     return index;
   }
 
-  // Sets the null indicator at 'idx'. 'true' means null.
-  FOLLY_ALWAYS_INLINE virtual void setNull(vector_size_t idx, bool value) {
+  /// Sets the null indicator at 'idx'. This API throws if the vector is a
+  /// ConstantVector.
+  FOLLY_ALWAYS_INLINE virtual void setNull(vector_size_t idx, bool isNull) {
     VELOX_DCHECK(idx >= 0 && idx < length_);
-    if (!nulls_ && !value) {
+    if (!nulls_ && !isNull) {
       return;
     }
     ensureNulls();
-    bits::setBit(
-        nulls_->asMutable<uint64_t>(), idx, bits::kNull ? value : !value);
+    bits::setNull(nulls_->asMutable<uint64_t>(), idx, isNull);
   }
 
   struct CopyRange {
@@ -399,19 +425,26 @@ class BaseVector {
     return countNulls(nulls, 0, size);
   }
 
-  // Returns whether or not the nulls buffer can be modified.
-  // This does not guarantee the existence of the nulls buffer, if using this
-  // within BaseVector you still may need to call ensureNulls.
+  /// Returns whether or not the nulls buffer can be modified.
+  /// This does not guarantee the existence of the nulls buffer, if using this
+  /// within BaseVector you still may need to call ensureNulls.
   virtual bool isNullsWritable() const {
     return !nulls_ || (nulls_->isMutable());
   }
 
-  // Sets null when 'nulls' has null value for a row in 'rows'
-  virtual void addNulls(const uint64_t* bits, const SelectivityVector& rows);
+  /// Sets null when 'nulls' has a null value for active rows in 'rows'.
+  /// Is a no-op 'nulls' is a nullptr or 'rows' has no selections. This API
+  /// throws if the vector is a ConstantVector.
+  virtual void addNulls(const uint64_t* nulls, const SelectivityVector& rows);
 
-  // Clears null when 'nulls' has non-null value for a row in 'rows'
-  virtual void clearNulls(const SelectivityVector& rows);
+  /// Sets nulls for all active row in 'nullRows'. Is a no-op if nullRows has no
+  /// selections. This API throws if the vector is a ConstantVector.
+  virtual void addNulls(const SelectivityVector& nullRows);
 
+  /// Clears nulls for all active rows in 'nonNullRows'
+  virtual void clearNulls(const SelectivityVector& nonNullRows);
+
+  /// Clears nulls for all row indices in range [begin, end).
   virtual void clearNulls(vector_size_t begin, vector_size_t end);
 
   void clearAllNulls() {
@@ -420,27 +453,30 @@ class BaseVector {
 
   void reuseNulls();
 
-  // Sets the size to 'newSize' and ensures there is space for the
-  // indicated number of nulls and top level values (eg. values for Flat,
-  // indices for Dictionary, etc). Any immutable buffers that need to be resized
-  // are copied. 'setNotNull' indicates if nulls in range [oldSize, newSize]
-  // should be set to not null.
-  // Note: caller must ensure that the vector is writable; for instance have
-  // recursively single referenced buffers and vectors.
+  /// Sets the size to 'newSize' and ensures there is space for the
+  /// indicated number of nulls and top level values (eg. values for Flat,
+  /// indices for Dictionary, etc). Any immutable buffers that need to be
+  /// resized are copied. 'setNotNull' indicates if nulls in range [oldSize,
+  /// newSize] should be set to not null. Note: caller must ensure that the
+  /// vector is writable; for instance have recursively single referenced
+  /// buffers and vectors.
   virtual void resize(vector_size_t newSize, bool setNotNull = true);
 
-  // Sets the rows of 'this' given by 'rows' to
-  // 'source.valueAt(toSourceRow ? toSourceRow[row] : row)', where
-  // 'row' iterates over 'rows'.
+  /// Sets the rows of 'this' given by 'rows' to
+  /// 'source.valueAt(toSourceRow ? toSourceRow[row] : row)', where
+  /// 'row' iterates over 'rows'. All active 'row' in 'rows' must map to a valid
+  /// row in the 'source'.
   virtual void copy(
       const BaseVector* source,
       const SelectivityVector& rows,
       const vector_size_t* toSourceRow);
 
-  // Utility for making a deep copy of a whole vector.
-  static VectorPtr copy(const BaseVector& vector) {
-    auto result =
-        BaseVector::create(vector.type(), vector.size(), vector.pool());
+  /// Utility for making a deep copy of a whole vector.
+  static VectorPtr copy(
+      const BaseVector& vector,
+      velox::memory::MemoryPool* pool = nullptr) {
+    auto result = BaseVector::create(
+        vector.type(), vector.size(), pool ? pool : vector.pool());
     result->copy(&vector, 0, 0, vector.size());
     return result;
   }
@@ -457,29 +493,34 @@ class BaseVector {
     copyRanges(source, folly::Range(&range, 1));
   }
 
-  /// Converts SelectivityVetor into a list of CopyRanges having sourceIndex ==
+  /// Converts SelectivityVector into a list of CopyRanges having sourceIndex ==
   /// targetIndex. Aims to produce as few ranges as possible. If all rows are
   /// selected, returns a single range.
   static std::vector<CopyRange> toCopyRanges(const SelectivityVector& rows);
 
-  // Copy multiple ranges at once.  This is more efficient than calling `copy`
-  // multiple times, especially for ARRAY, MAP, and VARCHAR.
+  /// Copy multiple ranges at once.  This is more efficient than calling `copy`
+  /// multiple times, especially for ARRAY, MAP, and VARCHAR.
   virtual void copyRanges(
       const BaseVector* /*source*/,
       const folly::Range<const CopyRange*>& /*ranges*/) {
     VELOX_UNSUPPORTED("Can only copy into flat or complex vectors");
   }
 
-  // Construct a zero-copy slice of the vector with the indicated offset and
-  // length.
+  /// This makes a deep copy of the Vector allocating new child Vectors and
+  /// Buffers recursively.  Unlike copy, this preserves encodings recursively.
+  virtual VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const = 0;
+
+  /// Construct a zero-copy slice of the vector with the indicated offset and
+  /// length.
   virtual VectorPtr slice(vector_size_t offset, vector_size_t length) const = 0;
 
-  // Returns a vector of the type of 'source' where 'indices' contains
-  // an index into 'source' for each element of 'source'. The
-  // resulting vector has position i set to source[i]. This is
-  // equivalent to wrapping 'source' in a dictionary with 'indices'
-  // but this may reuse structure if said structure is uniquely owned
-  // or if a copy is more efficient than dictionary wrapping.
+  /// Returns a vector of the type of 'source' where 'indices' contains
+  /// an index into 'source' for each element of 'source'. The
+  /// resulting vector has position i set to source[i]. This is
+  /// equivalent to wrapping 'source' in a dictionary with 'indices'
+  /// but this may reuse structure if said structure is uniquely owned
+  /// or if a copy is more efficient than dictionary wrapping.
   static VectorPtr transpose(BufferPtr indices, VectorPtr&& source);
 
   static VectorPtr createConstant(
@@ -502,33 +543,33 @@ class BaseVector {
   static VectorPtr
   wrapInSequence(BufferPtr lengths, vector_size_t size, VectorPtr vector);
 
-  // Creates a ConstantVector of specified length and value coming from the
-  // 'index' element of the 'vector'. Peels off any encodings of the 'vector'
-  // before making a new ConstantVector. The result vector is either a
-  // ConstantVector holding a scalar value or a ConstantVector wrapping flat or
-  // lazy vector. The result cannot be a wrapping over another constant or
-  // dictionary vector. If copyBase is true and the result vector wraps a
-  // vector, the wrapped vector is newly constructed by copying the value from
-  // the original, guaranteeing no Vectors are shared with 'vector'.
+  /// Creates a ConstantVector of specified length and value coming from the
+  /// 'index' element of the 'vector'. Peels off any encodings of the 'vector'
+  /// before making a new ConstantVector. The result vector is either a
+  /// ConstantVector holding a scalar value or a ConstantVector wrapping flat or
+  /// lazy vector. The result cannot be a wrapping over another constant or
+  /// dictionary vector. If copyBase is true and the result vector wraps a
+  /// vector, the wrapped vector is newly constructed by copying the value from
+  /// the original, guaranteeing no Vectors are shared with 'vector'.
   static VectorPtr wrapInConstant(
       vector_size_t length,
       vector_size_t index,
       VectorPtr vector,
       bool copyBase = false);
 
-  // Makes 'result' writable for 'rows'. A wrapper (e.g. dictionary, constant,
-  // sequence) is flattened and a multiply referenced flat vector is copied.
-  // The content of 'rows' is not copied, as these values are intended to be
-  // overwritten.
-  //
-  // After invoking this function, the 'result' is guaranteed to be a flat
-  // uniquely-referenced vector with all data-dependent flags reset.
-  //
-  // Use SelectivityVector::empty() to make the 'result' writable and preserve
-  // all current values.
-  //
-  // If 'result' is a lazy vector, then caller needs to ensure it is unique in
-  // order to re-use the loaded vector. Otherwise, a copy would be created.
+  /// Makes 'result' writable for 'rows'. A wrapper (e.g. dictionary, constant,
+  /// sequence) is flattened and a multiply referenced flat vector is copied.
+  /// The content of 'rows' is not copied, as these values are intended to be
+  /// overwritten.
+  ///
+  /// After invoking this function, the 'result' is guaranteed to be a flat
+  /// uniquely-referenced vector with all data-dependent flags reset.
+  ///
+  /// Use SelectivityVector::empty() to make the 'result' writable and preserve
+  /// all current values.
+  ///
+  /// If 'result' is a lazy vector, then caller needs to ensure it is unique in
+  /// order to re-use the loaded vector. Otherwise, a copy would be created.
   static void ensureWritable(
       const SelectivityVector& rows,
       const TypePtr& type,
@@ -538,14 +579,15 @@ class BaseVector {
 
   virtual void ensureWritable(const SelectivityVector& rows);
 
-  // Returns true if the following conditions hold:
-  //  * The vector is singly referenced.
-  //  * The vector has a Flat-like encoding (Flat, Array, Map, Row).
-  //  * Any child Buffers are mutable  and singly referenced.
-  //  * All of these conditions hold for child Vectors recursively.
-  // This function is templated rather than taking a std::shared_ptr<BaseVector>
-  // because if we were to do that the compiler would allocate a new shared_ptr
-  // when this function is called making it not unique.
+  /// Returns true if the following conditions hold:
+  ///  * The vector is singly referenced.
+  ///  * The vector has a Flat-like encoding (Flat, Array, Map, Row).
+  ///  * Any child Buffers are mutable  and singly referenced.
+  ///  * All of these conditions hold for child Vectors recursively.
+  /// This function is templated rather than taking a
+  /// std::shared_ptr<BaseVector> because if we were to do that the compiler
+  /// would allocate a new shared_ptr when this function is called making it not
+  /// unique.
   template <typename T>
   static bool isVectorWritable(const std::shared_ptr<T>& vector) {
     if (!vector.unique()) {
@@ -559,7 +601,13 @@ class BaseVector {
     return false;
   }
 
-  // Flattens the input vector and all of its children.
+  /// If 'vector' consists of a single value and is longer than one,
+  /// returns an equivalent constant vector, else nullptr.
+  static VectorPtr constantify(
+      const std::shared_ptr<BaseVector>& vector,
+      DecodedVector* decoded = nullptr);
+
+  /// Flattens the input vector and all of its children.
   static void flattenVector(VectorPtr& vector);
 
   template <typename T>
@@ -567,13 +615,17 @@ class BaseVector {
     return sizeof(T) * count;
   }
 
-  // If 'vector' is a wrapper, returns the underlying values vector. This is
-  // virtual and defined here because we must be able to access this in type
-  // agnostic code without a switch on all data types.
+  /// If 'vector' is a wrapper, returns the underlying values vector. This is
+  /// virtual and defined here because we must be able to access this in type
+  /// agnostic code without a switch on all data types.
   virtual const VectorPtr& valueVector() const {
     VELOX_UNSUPPORTED("Vector is not a wrapper");
   }
 
+  virtual VectorPtr& valueVector() {
+    VELOX_UNSUPPORTED("Vector is not a wrapper");
+  }
+
   virtual BaseVector* loadedVector() {
     return this;
   }
@@ -592,8 +644,8 @@ class BaseVector {
     VELOX_UNSUPPORTED("Only flat vectors have a values buffer");
   }
 
-  // If 'this' is a wrapper, returns the wrap info, interpretation depends on
-  // encoding.
+  /// If 'this' is a wrapper, returns the wrap info, interpretation depends on
+  /// encoding.
   virtual BufferPtr wrapInfo() const {
     throw std::runtime_error("Vector is not a wrapper");
   }
@@ -613,37 +665,32 @@ class BaseVector {
     return vector ? vector : create(type, 0, pool);
   }
 
+  /// Set 'nulls' to be the nulls buffer of this vector. This API should not be
+  /// used on ConstantVector.
   void setNulls(const BufferPtr& nulls);
 
+  /// Reset the nulls buffer of this vector to be empty. This API should not be
+  /// used on ConstantVector.
   void resetNulls() {
     setNulls(nullptr);
   }
 
-  void
-  clearIndices(BufferPtr& indices, vector_size_t start, vector_size_t end) {
-    if (start == end) {
-      return;
-    }
-    auto* data = indices->asMutable<vector_size_t>();
-    std::fill(data + start, data + end, 0);
-  }
-
-  /// Ensures that '*indices' is singly-referenced and has space for 'size'
-  /// elements. Sets elements between the old and new sizes to 0 if
-  /// the new size > old size.
+  /// Ensures that 'indices' is singly-referenced and has space for 'newSize'
+  /// elements. Sets elements between the 'currentSize' and 'newSize' to 0 if
+  /// 'newSize' > 'currentSize'.
   ///
-  /// If '*indices' is nullptr, read-only, not uniquely-referenced, or doesn't
-  /// have capacity for 'size' elements allocates new buffer and copies data to
-  /// it. Updates '*raw' to point to element 0 of
-  /// (*indices)->as<vector_size_t>().
+  /// If 'indices' is nullptr, read-only, not uniquely-referenced, or doesn't
+  /// have capacity for 'newSize' elements allocates new buffer and copies data
+  /// to it. Updates '*rawIndices' to point to the start of 'indices' buffer.
   static void resizeIndices(
-      vector_size_t size,
+      vector_size_t currentSize,
+      vector_size_t newSize,
       velox::memory::MemoryPool* pool,
-      BufferPtr* indices,
-      const vector_size_t** raw);
+      BufferPtr& indices,
+      const vector_size_t** rawIndices);
 
-  // Makes sure '*buffer' has space for 'size' items of T and is writable. Sets
-  // 'raw' to point to the writable contents of '*buffer'.
+  /// Makes sure '*buffer' has space for 'size' items of T and is writable. Sets
+  /// 'raw' to point to the writable contents of '*buffer'.
   template <typename T, typename RawT>
   static void ensureBuffer(
       vector_size_t size,
@@ -669,7 +716,7 @@ class BaseVector {
     (*buffer)->setSize(minBytes);
   }
 
-  // Returns the byte size of memory that is kept live through 'this'.
+  /// Returns the byte size of memory that is kept live through 'this'.
   virtual uint64_t retainedSize() const {
     return nulls_ ? nulls_->capacity() : 0;
   }
@@ -747,14 +794,6 @@ class BaseVector {
     return toString(from, to, "\n");
   }
 
-  void setCodegenOutput() {
-    isCodegenOutput_ = true;
-  }
-
-  bool isCodegenOutput() const {
-    return isCodegenOutput_;
-  }
-
   /// Marks the vector as containing or being a lazy vector and being wrapped.
   /// Should only be used if 'this' is lazy or has a nested lazy vector.
   /// Returns true if this is the first time it was wrapped, else returns false.
@@ -787,36 +826,36 @@ class BaseVector {
   compareNulls(bool thisNull, bool otherNull, CompareFlags flags) {
     DCHECK(thisNull || otherNull);
     switch (flags.nullHandlingMode) {
-      case CompareFlags::NullHandlingMode::StopAtNull:
-        return std::nullopt;
-      case CompareFlags::NullHandlingMode::NoStop:
-      default:
-        break;
-    }
-
-    if (thisNull) {
-      if (otherNull) {
-        return 0;
-      }
-      return flags.nullsFirst ? -1 : 1;
-    }
-    if (otherNull) {
-      return flags.nullsFirst ? 1 : -1;
+      case CompareFlags::NullHandlingMode::kNullAsIndeterminate:
+        if (flags.equalsOnly) {
+          return kIndeterminate;
+        } else {
+          VELOX_USER_FAIL("Ordering nulls is not supported");
+        }
+      case CompareFlags::NullHandlingMode::kNullAsValue:
+        if (thisNull && otherNull) {
+          return 0;
+        }
+
+        if (flags.nullsFirst) {
+          return thisNull ? -1 : 1;
+        }
+        return thisNull ? 1 : -1;
     }
 
     VELOX_UNREACHABLE(
         "The function should be called only if one of the inputs is null");
   }
 
-  // Reset data-dependent flags to the "unknown" status. This is needed whenever
-  // a vector is mutated because the modification may invalidate these flags.
-  // Currently, we call this function in BaseVector::ensureWritable() and
-  // BaseVector::prepareForReuse() that are expected to be called before any
-  // vector mutation.
-  //
-  // Per-vector flags are reset to default values. Per-row flags are reset only
-  // at the selected rows. If rows is a nullptr, per-row flags are reset at all
-  // rows.
+  /// Reset data-dependent flags to the "unknown" status. This is needed
+  /// whenever a vector is mutated because the modification may invalidate these
+  /// flags. Currently, we call this function in BaseVector::ensureWritable()
+  /// and BaseVector::prepareForReuse() that are expected to be called before
+  /// any vector mutation.
+  ///
+  /// Per-vector flags are reset to default values. Per-row flags are reset only
+  /// at the selected rows. If rows is a nullptr, per-row flags are reset at all
+  /// rows.
   virtual void resetDataDependentFlags(const SelectivityVector* /*rows*/) {
     nullCount_ = std::nullopt;
     distinctValueCount_ = std::nullopt;
@@ -825,20 +864,18 @@ class BaseVector {
   }
 
  protected:
-  /// Returns a brief summary of the vector. The default implementation includes
-  /// encoding, type, number of rows and number of nulls.
-  ///
-  /// For example,
-  ///     [FLAT INTEGER: 3 elements, no nulls]
-  ///     [DICTIONARY INTEGER: 5 elements, 1 nulls]
+  // Returns a brief summary of the vector. The default implementation includes
+  // encoding, type, number of rows and number of nulls.
+  //
+  // For example,
+  //     [FLAT INTEGER: 3 elements, no nulls]
+  //     [DICTIONARY INTEGER: 5 elements, 1 nulls]
   virtual std::string toSummaryString() const;
 
-  /*
-   * Allocates or reallocates nulls_ with at least the given size if nulls_
-   * hasn't been allocated yet or has been allocated with a smaller capacity.
-   * Ensures that nulls are writable (mutable and single referenced for
-   * minimumSize).
-   */
+  // Allocates or reallocates nulls_ with at least the given size if nulls_
+  // hasn't been allocated yet or has been allocated with a smaller capacity.
+  // Ensures that nulls are writable (mutable and single referenced for
+  // minimumSize).
   void ensureNullsCapacity(vector_size_t minimumSize, bool setNotNull = false);
 
   void ensureNulls() {
@@ -861,21 +898,19 @@ class BaseVector {
     return sliceBuffer(*BOOLEAN(), nulls_, offset, length, pool_);
   }
 
-  const TypePtr type_;
+  TypePtr type_;
   const TypeKind typeKind_;
   const VectorEncoding::Simple encoding_;
   BufferPtr nulls_;
   // Caches raw pointer to 'nulls->as<uint64_t>().
   const uint64_t* rawNulls_ = nullptr;
   velox::memory::MemoryPool* pool_;
-  vector_size_t length_ = 0;
-
-  /**
-   * Holds the number of nulls in the vector. If the number of nulls
-   * is not available, it is set to std::nullopt. Setting the value to
-   * zero does have implications (SIMD operations need null count to be
-   * zero) and is not the same as std::nullopt.
-   */
+  tsan_atomic<vector_size_t> length_{0};
+
+  // Holds the number of nulls in the vector. If the number of nulls is not
+  // available, it is set to std::nullopt. Setting the value to zero does have
+  // implications (SIMD operations need null count to be zero) and is not the
+  // same as std::nullopt.
   std::optional<vector_size_t> nullCount_;
   std::optional<vector_size_t> distinctValueCount_;
   std::optional<ByteCount> representedByteCount_;
@@ -888,16 +923,14 @@ class BaseVector {
       vector_size_t size,
       velox::memory::MemoryPool* pool);
 
-  bool isCodegenOutput_ = false;
-
   friend class LazyVector;
 
-  /// Is true if this vector is a lazy vector or contains one and is being
-  /// wrapped. Keeping track of this helps to enforce the invariant that an
-  /// unloaded lazy vector should not be wrapped by two separate top level
-  /// vectors. This would ensure we avoid it being loaded for two separate set
-  /// of rows.
-  bool containsLazyAndIsWrapped_{false};
+  // Is true if this vector is a lazy vector or contains one and is being
+  // wrapped. Keeping track of this helps to enforce the invariant that an
+  // unloaded lazy vector should not be wrapped by two separate top level
+  // vectors. This would ensure we avoid it being loaded for two separate set
+  // of rows.
+  std::atomic_bool containsLazyAndIsWrapped_{false};
 
   // Whether we should use Expr::evalWithMemo to cache the result of evaluation
   // on dictionary values (this vector).  Set to false when the dictionary
@@ -907,7 +940,7 @@ class BaseVector {
 };
 
 /// Loops over rows in 'ranges' and invokes 'func' for each row.
-/// @param TFunc A void function taking two arguments: targetIndex and
+/// @param func A void function taking two arguments: targetIndex and
 /// sourceIndex.
 template <typename TFunc>
 void applyToEachRow(
@@ -921,7 +954,7 @@ void applyToEachRow(
 }
 
 /// Loops over 'ranges' and invokes 'func' for each range.
-/// @param TFunc A void function taking 3 arguments: targetIndex, sourceIndex
+/// @param func A void function taking 3 arguments: targetIndex, sourceIndex
 /// and count.
 template <typename TFunc>
 void applyToEachRange(
@@ -940,18 +973,18 @@ inline uint64_t BaseVector::byteSize<UnknownValue>(vector_size_t) {
   return 0;
 }
 
-// Returns true if vector is a Lazy vector, possibly wrapped, that hasn't
-// been loaded yet.
+/// Returns true if vector is a Lazy vector, possibly wrapped, that hasn't
+/// been loaded yet.
 bool isLazyNotLoaded(const BaseVector& vector);
 
-// Allocates a buffer to fit at least 'size' indices and initializes them to
-// zero.
+/// Allocates a buffer to fit at least 'size' indices and initializes them to
+/// zero.
 inline BufferPtr allocateIndices(vector_size_t size, memory::MemoryPool* pool) {
   return AlignedBuffer::allocate<vector_size_t>(size, pool, 0);
 }
 
-// Allocates a buffer to fit at least 'size' null bits and initializes them to
-// the provided 'initValue' which has a default value of non-null.
+/// Allocates a buffer to fit at least 'size' null bits and initializes them to
+/// the provided 'initValue' which has a default value of non-null.
 inline BufferPtr allocateNulls(
     vector_size_t size,
     memory::MemoryPool* pool,
@@ -959,18 +992,18 @@ inline BufferPtr allocateNulls(
   return AlignedBuffer::allocate<bool>(size, pool, initValue);
 }
 
-// Returns a summary of the null bits in the specified buffer and prints out
-// first 'maxBitsToPrint' bits. Automatically adjusts if 'maxBitsToPrint' is
-// greater than total number of bits available.
-// For example: 3 out of 8 rows are null: .nn.n...
+/// Returns a summary of the null bits in the specified buffer and prints out
+/// first 'maxBitsToPrint' bits. Automatically adjusts if 'maxBitsToPrint' is
+/// greater than total number of bits available.
+/// For example: 3 out of 8 rows are null: .nn.n...
 std::string printNulls(
     const BufferPtr& nulls,
     vector_size_t maxBitsToPrint = 30);
 
-// Returns a summary of the indices buffer and prints out first
-// 'maxIndicesToPrint' indices. Automatically adjusts if 'maxIndicesToPrint' is
-// greater than total number of indices available.
-// For example: 5 unique indices out of 6: 34, 79, 11, 0, 0, 33.
+/// Returns a summary of the indices buffer and prints out first
+/// 'maxIndicesToPrint' indices. Automatically adjusts if 'maxIndicesToPrint' is
+/// greater than total number of indices available.
+/// For example: 5 unique indices out of 6: 34, 79, 11, 0, 0, 33.
 std::string printIndices(
     const BufferPtr& indices,
     vector_size_t maxIndicesToPrint = 10);
@@ -980,8 +1013,8 @@ std::string printIndices(
 
 namespace folly {
 
-// Allow VectorEncoding::Simple to be transparently used by folly::sformat.
-// e.g: folly::sformat("type: {}", encodingType);
+/// Allow VectorEncoding::Simple to be transparently used by folly::sformat.
+/// e.g: folly::sformat("type: {}", encodingType);
 template <>
 class FormatValue<facebook::velox::VectorEncoding::Simple> {
  public:
diff --git a/velox/vector/BiasVector.h b/velox/vector/BiasVector.h
index 158f39ae093fc..2a2e43a6de9bd 100644
--- a/velox/vector/BiasVector.h
+++ b/velox/vector/BiasVector.h
@@ -163,6 +163,24 @@ class BiasVector : public SimpleVector<T> {
     VELOX_NYI();
   }
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const override {
+    auto selfPool = pool ? pool : BaseVector::pool_;
+    return std::make_shared<BiasVector<T>>(
+        selfPool,
+        AlignedBuffer::copy(selfPool, BaseVector::nulls_),
+        BaseVector::length_,
+        valueType_,
+        AlignedBuffer::copy(selfPool, values_),
+        bias_,
+        SimpleVector<T>::stats_,
+        BaseVector::distinctValueCount_,
+        BaseVector::nullCount_,
+        SimpleVector<T>::isSorted_,
+        BaseVector::representedByteCount_,
+        BaseVector::storageByteCount_);
+  }
+
  private:
   template <typename U>
   inline xsimd::batch<T> loadSIMDInternal(size_t byteOffset) const {
diff --git a/velox/vector/CMakeLists.txt b/velox/vector/CMakeLists.txt
index 40061e1de8f01..2f84505659503 100644
--- a/velox/vector/CMakeLists.txt
+++ b/velox/vector/CMakeLists.txt
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(
+velox_add_library(
   velox_vector
   BaseVector.cpp
   ComplexVector.cpp
@@ -21,22 +21,29 @@ add_library(
   LazyVector.cpp
   SelectivityVector.cpp
   SequenceVector.cpp
-  VectorSaver.cpp
+  SimpleVector.cpp
+  VariantToVector.cpp
   VectorEncoding.cpp
+  VectorMap.cpp
   VectorPool.cpp
   VectorPrinter.cpp
-  VectorStream.cpp
-  VariantToVector.cpp)
+  VectorSaver.cpp
+  VectorStream.cpp)
 
-target_link_libraries(velox_vector velox_encode velox_memory velox_time
-                      velox_type velox_buffer)
+velox_link_libraries(
+  velox_vector
+  velox_encode
+  velox_memory
+  velox_time
+  velox_type
+  velox_buffer)
 
 add_subdirectory(arrow)
 add_subdirectory(fuzzer)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
-elseif(${VELOX_BUILD_TEST_UTILS})
+elseif(${VELOX_BUILD_TEST_UTILS} OR ${VELOX_BUILD_VECTOR_TEST_UTILS})
   add_subdirectory(tests/utils)
 endif()
 
diff --git a/velox/vector/ComplexVector.cpp b/velox/vector/ComplexVector.cpp
index 2ea5b40d5133d..041d67cb1458c 100644
--- a/velox/vector/ComplexVector.cpp
+++ b/velox/vector/ComplexVector.cpp
@@ -17,6 +17,7 @@
 #include <optional>
 #include <sstream>
 
+#include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/ComplexVector.h"
@@ -108,6 +109,7 @@ std::optional<int32_t> RowVector::compare(
   }
 
   auto compareSize = std::min(children_.size(), otherRow->children_.size());
+  bool resultIsindeterminate = false;
   for (int32_t i = 0; i < compareSize; ++i) {
     BaseVector* child = children_[i].get();
     BaseVector* otherChild = otherRow->childAt(i).get();
@@ -127,14 +129,20 @@ std::optional<int32_t> RowVector::compare(
     auto wrappedOtherIndex = other->wrappedIndex(otherIndex);
     auto result = child->compare(
         otherChild->loadedVector(), index, wrappedOtherIndex, flags);
-    if (flags.mayStopAtNull() && !result.has_value()) {
-      return std::nullopt;
-    }
-
-    if (result.value()) {
+    if (result == kIndeterminate) {
+      VELOX_DCHECK(
+          flags.equalsOnly,
+          "Compare should have thrown when null is encountered in child.");
+      resultIsindeterminate = true;
+    } else if (result.value() != 0) {
+      // If values are not equal no need to continue looping.
       return result;
     }
   }
+
+  if (resultIsindeterminate) {
+    return kIndeterminate;
+  }
   return children_.size() - otherRow->children_.size();
 }
 
@@ -187,6 +195,9 @@ void RowVector::copy(
 
   // Copy non-null values.
   SelectivityVector nonNullRows = rows;
+  if (!toSourceRow) {
+    VELOX_CHECK_GE(source->size(), rows.end());
+  }
 
   DecodedVector decodedSource(*source);
   if (decodedSource.isIdentityMapping()) {
@@ -194,6 +205,7 @@ void RowVector::copy(
       auto rawNulls = source->rawNulls();
       rows.applyToSelected([&](auto row) {
         auto idx = toSourceRow ? toSourceRow[row] : row;
+        VELOX_DCHECK_GT(source->size(), idx);
         if (bits::isBitNull(rawNulls, idx)) {
           nonNullRows.setValid(row, false);
         }
@@ -213,11 +225,12 @@ void RowVector::copy(
       }
     }
   } else {
-    auto nulls = decodedSource.nulls();
+    auto nulls = decodedSource.nulls(nullptr);
 
     if (nulls) {
       rows.applyToSelected([&](auto row) {
         auto idx = toSourceRow ? toSourceRow[row] : row;
+        VELOX_DCHECK_GT(source->size(), idx);
         if (bits::isBitNull(nulls, idx)) {
           nonNullRows.setValid(row, false);
         }
@@ -266,6 +279,13 @@ void RowVector::copy(
   }
 }
 
+void RowVector::setType(const TypePtr& type) {
+  BaseVector::setType(type);
+  for (auto i = 0; i < childrenSize_; i++) {
+    children_[i]->setType(type_->asRow().childAt(i));
+  }
+}
+
 namespace {
 
 // Runs quick checks to determine whether input vector has only null values.
@@ -522,8 +542,9 @@ void ArrayVectorBase::copyRangesImpl(
 
   auto sourceArray = leafSource->asUnchecked<ArrayVectorBase>();
   auto setNotNulls = mayHaveNulls() || source->mayHaveNulls();
-  auto* mutableOffsets = offsets_->asMutable<vector_size_t>();
-  auto* mutableSizes = sizes_->asMutable<vector_size_t>();
+  auto* mutableOffsets =
+      this->mutableOffsets(length_)->asMutable<vector_size_t>();
+  auto* mutableSizes = this->mutableSizes(length_)->asMutable<vector_size_t>();
   vector_size_t childSize = targetValues->get()->size();
   if (ranges.size() == 1 && ranges.back().count == 1) {
     auto& range = ranges.back();
@@ -593,7 +614,7 @@ void ArrayVectorBase::copyRangesImpl(
 
         mutableOffsets[targetIndex] = childSize;
         mutableSizes[targetIndex] = copySize;
-        childSize += copySize;
+        childSize = checkedPlus<vector_size_t>(childSize, copySize);
       }
     });
 
@@ -608,38 +629,258 @@ void ArrayVectorBase::copyRangesImpl(
 
 void RowVector::validate(const VectorValidateOptions& options) const {
   BaseVector::validate(options);
+  vector_size_t lastNonNullIndex{size()};
+
+  if (nulls_) {
+    lastNonNullIndex = bits::findLastBit(nulls_->as<uint64_t>(), 0, size());
+  }
+
   for (auto& child : children_) {
+    // TODO: Currently we arent checking for null children on ROWs
+    // since there are cases in SelectiveStructReader/DWIO/Koski where
+    // ROW Vectors with null children are created.
     if (child != nullptr) {
       child->validate(options);
+      if (child->size() < size()) {
+        VELOX_CHECK_NOT_NULL(
+            nulls_,
+            "Child vector has size less than parent and parent has no nulls.");
+
+        VELOX_CHECK_GT(
+            child->size(),
+            lastNonNullIndex,
+            "Child vector has size less than last non null row.");
+      }
     }
   }
 }
 
-void ArrayVectorBase::checkRanges() const {
-  std::unordered_map<vector_size_t, vector_size_t> seenElements;
-  seenElements.reserve(size());
+void RowVector::unsafeResize(vector_size_t newSize, bool setNotNull) {
+  BaseVector::resize(newSize, setNotNull);
+}
 
-  for (vector_size_t i = 0; i < size(); ++i) {
-    auto size = sizeAt(i);
-    auto offset = offsetAt(i);
-
-    for (vector_size_t j = 0; j < size; ++j) {
-      auto it = seenElements.find(offset + j);
-      if (it != seenElements.end()) {
-        VELOX_FAIL(
-            "checkRanges() found overlap at idx {}: element {} has offset {} "
-            "and size {}, and element {} has offset {} and size {}.",
-            offset + j,
-            it->second,
-            offsetAt(it->second),
-            sizeAt(it->second),
-            i,
-            offset,
-            size);
+void RowVector::resize(vector_size_t newSize, bool setNotNull) {
+  const auto oldSize = size();
+  BaseVector::resize(newSize, setNotNull);
+
+  // Resize all the children.
+  for (auto& child : children_) {
+    if (child != nullptr) {
+      if (child->isLazy()) {
+        VELOX_FAIL("Resize on a lazy vector is not allowed");
+      }
+
+      // If we are just reducing the size of the vector, its safe
+      // to skip uniqueness check since effectively we are just changing
+      // the length.
+      if (newSize > oldSize) {
+        VELOX_CHECK(child.unique(), "Resizing shared child vector");
+        child->resize(newSize, setNotNull);
+      }
+    }
+  }
+}
+
+namespace {
+
+struct Wrapper {
+  const VectorPtr& dictionary;
+
+  // Combined nulls and indices from this dictionary node to the root.
+  BufferPtr nulls;
+  BufferPtr indices;
+};
+
+void combineWrappers(
+    std::vector<Wrapper>& wrappers,
+    vector_size_t size,
+    memory::MemoryPool* pool) {
+  std::vector<BufferPtr> wrapInfos(wrappers.size());
+  std::vector<const vector_size_t*> sourceIndices(wrappers.size());
+  uint64_t* rawNulls = nullptr;
+  for (int i = 0; i < wrappers.size(); ++i) {
+    wrapInfos[i] = wrappers[i].dictionary->wrapInfo();
+    VELOX_CHECK_NOT_NULL(wrapInfos[i]);
+    sourceIndices[i] = wrapInfos[i]->as<vector_size_t>();
+    if (!rawNulls && wrappers[i].dictionary->nulls()) {
+      wrappers.back().nulls = allocateNulls(size, pool);
+      rawNulls = wrappers.back().nulls->asMutable<uint64_t>();
+    }
+  }
+  wrappers.back().indices = allocateIndices(size, pool);
+  auto* rawIndices = wrappers.back().indices->asMutable<vector_size_t>();
+  for (vector_size_t j = 0; j < size; ++j) {
+    auto index = j;
+    bool isNull = false;
+    for (int i = 0; i < wrappers.size(); ++i) {
+      if (wrappers[i].dictionary->isNullAt(index)) {
+        isNull = true;
+        break;
+      }
+      index = sourceIndices[i][index];
+    }
+    if (isNull) {
+      bits::setNull(rawNulls, j);
+    } else {
+      rawIndices[j] = index;
+    }
+  }
+}
+
+VectorPtr wrapInDictionary(
+    std::vector<Wrapper>& wrappers,
+    vector_size_t size,
+    const VectorPtr& values,
+    memory::MemoryPool* pool) {
+  if (wrappers.empty()) {
+    VELOX_CHECK_LE(size, values->size());
+    return values;
+  }
+  VELOX_CHECK_LE(size, wrappers.front().dictionary->size());
+  if (wrappers.size() == 1) {
+    if (wrappers.front().dictionary->valueVector() == values) {
+      return wrappers.front().dictionary;
+    }
+    return BaseVector::wrapInDictionary(
+        wrappers.front().dictionary->nulls(),
+        wrappers.front().dictionary->wrapInfo(),
+        size,
+        values);
+  }
+  if (!wrappers.back().indices) {
+    VELOX_CHECK_NULL(wrappers.back().nulls);
+    combineWrappers(wrappers, size, pool);
+  }
+  return BaseVector::wrapInDictionary(
+      wrappers.back().nulls, wrappers.back().indices, size, values);
+}
+
+VectorPtr pushDictionaryToRowVectorLeavesImpl(
+    std::vector<Wrapper>& wrappers,
+    vector_size_t size,
+    const VectorPtr& values,
+    memory::MemoryPool* pool) {
+  switch (values->encoding()) {
+    case VectorEncoding::Simple::LAZY: {
+      auto* lazy = values->asUnchecked<LazyVector>();
+      VELOX_CHECK(lazy->isLoaded());
+      return pushDictionaryToRowVectorLeavesImpl(
+          wrappers, size, lazy->loadedVectorShared(), pool);
+    }
+    case VectorEncoding::Simple::ROW: {
+      VELOX_CHECK_EQ(values->typeKind(), TypeKind::ROW);
+      for (auto& wrapper : wrappers) {
+        if (wrapper.dictionary->nulls()) {
+          return wrapInDictionary(wrappers, size, values, pool);
+        }
+      }
+      auto children = values->asUnchecked<RowVector>()->children();
+      for (auto& child : children) {
+        if (child) {
+          child =
+              pushDictionaryToRowVectorLeavesImpl(wrappers, size, child, pool);
+        }
       }
-      seenElements.emplace(offset + j, i);
+      return std::make_shared<RowVector>(
+          pool,
+          values->type(),
+          values->nulls(),
+          values->size(),
+          std::move(children));
+    }
+    case VectorEncoding::Simple::DICTIONARY: {
+      Wrapper wrapper{values, nullptr, nullptr};
+      wrappers.push_back(wrapper);
+      auto result = pushDictionaryToRowVectorLeavesImpl(
+          wrappers, size, values->valueVector(), pool);
+      wrappers.pop_back();
+      return result;
+    }
+    default:
+      return wrapInDictionary(wrappers, size, values, pool);
+  }
+}
+
+} // namespace
+
+VectorPtr RowVector::pushDictionaryToRowVectorLeaves(const VectorPtr& input) {
+  std::vector<Wrapper> wrappers;
+  return pushDictionaryToRowVectorLeavesImpl(
+      wrappers, input->size(), input, input->pool());
+}
+
+namespace {
+
+// Returns the next non-null non-empty array/map on or after `index'.
+template <bool kHasNulls>
+vector_size_t nextNonEmpty(
+    vector_size_t i,
+    vector_size_t size,
+    const uint64_t* nulls,
+    const vector_size_t* sizes) {
+  while (i < size &&
+         ((kHasNulls && bits::isBitNull(nulls, i)) || sizes[i] <= 0)) {
+    ++i;
+  }
+  return i;
+}
+
+template <bool kHasNulls>
+bool maybeHaveOverlappingRanges(
+    vector_size_t size,
+    const uint64_t* nulls,
+    const vector_size_t* offsets,
+    const vector_size_t* sizes) {
+  vector_size_t curr = 0;
+  curr = nextNonEmpty<kHasNulls>(curr, size, nulls, sizes);
+  if (curr >= size) {
+    return false;
+  }
+  for (;;) {
+    auto next = nextNonEmpty<kHasNulls>(curr + 1, size, nulls, sizes);
+    if (next >= size) {
+      return false;
+    }
+    // This also implicitly ensures offsets[curr] <= offsets[next].
+    if (offsets[curr] + sizes[curr] > offsets[next]) {
+      return true;
+    }
+    curr = next;
+  }
+}
+
+} // namespace
+
+// static
+bool ArrayVectorBase::hasOverlappingRanges(
+    vector_size_t size,
+    const uint64_t* nulls,
+    const vector_size_t* offsets,
+    const vector_size_t* sizes) {
+  if (!(nulls
+            ? maybeHaveOverlappingRanges<true>(size, nulls, offsets, sizes)
+            : maybeHaveOverlappingRanges<false>(size, nulls, offsets, sizes))) {
+    return false;
+  }
+  std::vector<vector_size_t> indices;
+  indices.reserve(size);
+  for (vector_size_t i = 0; i < size; ++i) {
+    const bool isNull = nulls && bits::isBitNull(nulls, i);
+    if (!isNull && sizes[i] > 0) {
+      indices.push_back(i);
     }
   }
+  std::sort(indices.begin(), indices.end(), [&](auto i, auto j) {
+    return offsets[i] < offsets[j];
+  });
+  for (vector_size_t i = 1; i < indices.size(); ++i) {
+    auto j = indices[i - 1];
+    auto k = indices[i];
+    if (offsets[j] + sizes[j] > offsets[k]) {
+      return true;
+    }
+  }
+  return false;
 }
 
 void ArrayVectorBase::validateArrayVectorBase(
@@ -666,7 +907,7 @@ void ArrayVectorBase::validateArrayVectorBase(
         rawOffsets_[i],
         0,
         "ArrayVectorBase offset must be greater than zero. Index: {}.",
-        i)
+        i);
     VELOX_CHECK_LT(
         rawOffsets_[i] + rawSizes_[i] - 1,
         minChildVectorSize,
@@ -694,17 +935,23 @@ std::optional<int32_t> compareArrays(
     return 1;
   }
   auto compareSize = std::min(leftRange.size, rightRange.size);
+  bool resultIsindeterminate = false;
   for (auto i = 0; i < compareSize; ++i) {
     auto result =
         left.compare(&right, leftRange.begin + i, rightRange.begin + i, flags);
-    if (flags.mayStopAtNull() && !result.has_value()) {
-      // Null is encountered.
-      return std::nullopt;
-    }
-    if (result.value() != 0) {
+    if (result == kIndeterminate) {
+      VELOX_DCHECK(
+          flags.equalsOnly,
+          "Compare should have thrown when null is encountered in child.");
+      resultIsindeterminate = true;
+    } else if (result.value() != 0) {
       return result;
     }
   }
+  if (resultIsindeterminate) {
+    return kIndeterminate;
+  }
+
   int result = leftRange.size - rightRange.size;
   return flags.ascending ? result : result * -1;
 }
@@ -719,17 +966,26 @@ std::optional<int32_t> compareArrays(
     // return early if not caring about collation order.
     return 1;
   }
+
   auto compareSize = std::min(leftRange.size(), rightRange.size());
+
+  bool resultIsindeterminate = false;
   for (auto i = 0; i < compareSize; ++i) {
     auto result = left.compare(&right, leftRange[i], rightRange[i], flags);
-    if (flags.mayStopAtNull() && !result.has_value()) {
-      // Null is encountered.
-      return std::nullopt;
-    }
-    if (result.value() != 0) {
+    if (result == kIndeterminate) {
+      VELOX_DCHECK(
+          flags.equalsOnly,
+          "Compare should have thrown when null is encountered in child.");
+      resultIsindeterminate = true;
+    } else if (result.value() != 0) {
       return result;
     }
   }
+
+  if (resultIsindeterminate) {
+    return kIndeterminate;
+  }
+
   int result = leftRange.size() - rightRange.size();
   return flags.ascending ? result : result * -1;
 }
@@ -794,6 +1050,11 @@ std::optional<int32_t> ArrayVector::compare(
       flags);
 }
 
+void ArrayVector::setType(const TypePtr& type) {
+  BaseVector::setType(type);
+  elements_->setType(type_->asArray().elementType());
+}
+
 namespace {
 uint64_t hashArray(
     uint64_t hash,
@@ -966,6 +1227,9 @@ std::optional<int32_t> MapVector::compare(
     vector_size_t index,
     vector_size_t otherIndex,
     CompareFlags flags) const {
+  VELOX_CHECK(
+      flags.nullAsValue() || flags.equalsOnly, "Map is not orderable type");
+
   bool isNull = isNullAt(index);
   bool otherNull = other->isNullAt(otherIndex);
   if (isNull || otherNull) {
@@ -1001,16 +1265,13 @@ std::optional<int32_t> MapVector::compare(
 
   auto result =
       compareArrays(*keys_, *otherMap->keys_, leftIndices, rightIndices, flags);
-  VELOX_DCHECK(result.has_value(), "keys can not have null");
+  VELOX_DCHECK(result.has_value(), "Keys may not have nulls or nested nulls");
 
-  if (flags.mayStopAtNull() && !result.has_value()) {
-    return std::nullopt;
-  }
-
-  // Keys are not the same.
+  // Keys are not the same, values not compared.
   if (result.value()) {
     return result;
   }
+
   return compareArrays(
       *values_, *otherMap->values_, leftIndices, rightIndices, flags);
 }
@@ -1047,6 +1308,13 @@ bool MapVector::isSorted(vector_size_t index) const {
   return true;
 }
 
+void MapVector::setType(const TypePtr& type) {
+  BaseVector::setType(type);
+  const auto& mapType = type_->asMap();
+  keys_->setType(mapType.keyType());
+  values_->setType(mapType.valueType());
+}
+
 // static
 void MapVector::canonicalize(
     const std::shared_ptr<MapVector>& map,
@@ -1236,13 +1504,209 @@ void MapVector::copyRanges(
   copyRangesImpl(source, ranges, &values_, &keys_);
 }
 
+namespace {
+
+struct UpdateSource {
+  vector_size_t entryIndex;
+  int8_t sourceIndex;
+};
+
+template <typename T>
+class UpdateMapRow {
+ public:
+  void insert(
+      const DecodedVector* decoded,
+      vector_size_t entryIndex,
+      int8_t sourceIndex) {
+    values_[decoded->valueAt<T>(entryIndex)] = {entryIndex, sourceIndex};
+  }
+
+  template <typename F>
+  void forEachEntry(F&& func) {
+    for (auto& [_, source] : values_) {
+      func(source);
+    }
+  }
+
+  void clear() {
+    values_.clear();
+  }
+
+ private:
+  folly::F14FastMap<T, UpdateSource> values_;
+};
+
+template <>
+class UpdateMapRow<void> {
+ public:
+  void insert(
+      const DecodedVector* decoded,
+      vector_size_t entryIndex,
+      int8_t sourceIndex) {
+    references_[{decoded->base(), decoded->index(entryIndex)}] = {
+        entryIndex, sourceIndex};
+  }
+
+  template <typename F>
+  void forEachEntry(F&& func) {
+    for (auto& [_, source] : references_) {
+      func(source);
+    }
+  }
+
+  void clear() {
+    references_.clear();
+  }
+
+ private:
+  struct Reference {
+    const BaseVector* base;
+    vector_size_t index;
+
+    bool operator==(const Reference& other) const {
+      return base->equalValueAt(other.base, index, other.index);
+    }
+  };
+
+  struct ReferenceHasher {
+    uint64_t operator()(const Reference& key) const {
+      return key.base->hashValueAt(key.index);
+    }
+  };
+
+  folly::F14FastMap<Reference, UpdateSource, ReferenceHasher> references_;
+};
+
+} // namespace
+
+template <TypeKind kKeyTypeKind>
+MapVectorPtr MapVector::updateImpl(
+    const std::vector<MapVectorPtr>& others) const {
+  auto newNulls = nulls();
+  bool allocatedNewNulls = false;
+  for (auto& other : others) {
+    if (!other->nulls()) {
+      continue;
+    }
+    if (!newNulls) {
+      newNulls = other->nulls();
+      continue;
+    }
+    if (!allocatedNewNulls) {
+      auto* prevNewNulls = newNulls->as<uint64_t>();
+      newNulls = allocateNulls(size(), pool());
+      allocatedNewNulls = true;
+      bits::andBits(
+          newNulls->asMutable<uint64_t>(),
+          prevNewNulls,
+          other->rawNulls(),
+          0,
+          size());
+    } else {
+      bits::andBits(
+          newNulls->asMutable<uint64_t>(), other->rawNulls(), 0, size());
+    }
+  }
+
+  auto newOffsets = allocateIndices(size(), pool());
+  auto* rawNewOffsets = newOffsets->asMutable<vector_size_t>();
+  auto newSizes = allocateIndices(size(), pool());
+  auto* rawNewSizes = newSizes->asMutable<vector_size_t>();
+
+  std::vector<DecodedVector> keys;
+  keys.reserve(1 + others.size());
+  keys.emplace_back(*keys_);
+  for (auto& other : others) {
+    VELOX_CHECK(*keys_->type() == *other->keys_->type());
+    keys.emplace_back(*other->keys_);
+  }
+  std::vector<std::vector<BaseVector::CopyRange>> ranges(1 + others.size());
+
+  // Subscript symbols in this function:
+  //
+  // i : Top level row index.
+  // j, jj : Key/value vector index.  `jj' is the offset version of `j'.
+  // k : Index into `others' and `ranges' for choosing a map vector.
+  UpdateMapRow<typename TypeTraits<kKeyTypeKind>::NativeType> mapRow;
+  vector_size_t numEntries = 0;
+  for (vector_size_t i = 0; i < size(); ++i) {
+    rawNewOffsets[i] = numEntries;
+    if (newNulls && bits::isBitNull(newNulls->as<uint64_t>(), i)) {
+      rawNewSizes[i] = 0;
+      continue;
+    }
+    bool needUpdate = false;
+    for (auto& other : others) {
+      if (other->sizeAt(i) > 0) {
+        needUpdate = true;
+        break;
+      }
+    }
+    if (!needUpdate) {
+      // Fast path for no update on current row.
+      rawNewSizes[i] = sizeAt(i);
+      if (sizeAt(i) > 0) {
+        ranges[0].push_back({offsetAt(i), numEntries, sizeAt(i)});
+        numEntries += sizeAt(i);
+      }
+      continue;
+    }
+    for (int k = 0; k < keys.size(); ++k) {
+      auto* vector = k == 0 ? this : others[k - 1].get();
+      auto offset = vector->offsetAt(i);
+      auto size = vector->sizeAt(i);
+      for (vector_size_t j = 0; j < size; ++j) {
+        auto jj = offset + j;
+        VELOX_DCHECK(!keys[k].isNullAt(jj));
+        mapRow.insert(&keys[k], jj, k);
+      }
+    }
+    vector_size_t newSize = 0;
+    mapRow.forEachEntry([&](UpdateSource source) {
+      ranges[source.sourceIndex].push_back(
+          {source.entryIndex, numEntries + newSize, 1});
+      ++newSize;
+    });
+    mapRow.clear();
+    rawNewSizes[i] = newSize;
+    numEntries += newSize;
+  }
+
+  auto newKeys = BaseVector::create(mapKeys()->type(), numEntries, pool());
+  auto newValues = BaseVector::create(mapValues()->type(), numEntries, pool());
+  for (int k = 0; k < ranges.size(); ++k) {
+    auto* vector = k == 0 ? this : others[k - 1].get();
+    newKeys->copyRanges(vector->mapKeys().get(), ranges[k]);
+    newValues->copyRanges(vector->mapValues().get(), ranges[k]);
+  }
+
+  return std::make_shared<MapVector>(
+      pool(),
+      type(),
+      std::move(newNulls),
+      size(),
+      std::move(newOffsets),
+      std::move(newSizes),
+      std::move(newKeys),
+      std::move(newValues));
+}
+
+MapVectorPtr MapVector::update(const std::vector<MapVectorPtr>& others) const {
+  VELOX_CHECK(!others.empty());
+  VELOX_CHECK(others.size() < std::numeric_limits<int8_t>::max());
+  for (auto& other : others) {
+    VELOX_CHECK_EQ(size(), other->size());
+  }
+  return VELOX_DYNAMIC_TYPE_DISPATCH(updateImpl, keys_->typeKind(), others);
+}
+
 void RowVector::appendNulls(vector_size_t numberOfRows) {
   VELOX_CHECK_GE(numberOfRows, 0);
   if (numberOfRows == 0) {
     return;
   }
-  auto newSize = numberOfRows + BaseVector::length_;
-  auto oldSize = BaseVector::length_;
+  const vector_size_t newSize = numberOfRows + BaseVector::length_;
+  const vector_size_t oldSize = BaseVector::length_;
   BaseVector::resize(newSize, false);
   bits::fillBits(mutableRawNulls(), oldSize, newSize, bits::kNull);
 }
diff --git a/velox/vector/ComplexVector.h b/velox/vector/ComplexVector.h
index 5f8f546cf1eeb..eb45cc08bfcc8 100644
--- a/velox/vector/ComplexVector.h
+++ b/velox/vector/ComplexVector.h
@@ -109,22 +109,40 @@ class RowVector : public BaseVector {
     return childrenSize_;
   }
 
-  // Resize a row vector by adding trailing nulls to the top level row without
-  // resizing children.
-  // Caller should ensure that the vector is unique before calling this method.
+  /// Resize a row vector by adding trailing nulls to the top level row without
+  /// resizing children.
+  /// Caller should ensure that the vector is unique before calling this method.
   void appendNulls(vector_size_t numberOfRows);
 
   /// Get the child vector at a given offset.
   VectorPtr& childAt(column_index_t index) {
-    VELOX_USER_CHECK_LT(index, childrenSize_);
+    VELOX_CHECK_LT(
+        index,
+        childrenSize_,
+        "Trying to access non-existing child in RowVector: {}",
+        toString());
     return children_[index];
   }
 
   const VectorPtr& childAt(column_index_t index) const {
-    VELOX_USER_CHECK_LT(index, childrenSize_);
+    VELOX_CHECK_LT(
+        index,
+        childrenSize_,
+        "Trying to access non-existing child in RowVector: {}",
+        toString());
     return children_[index];
   }
 
+  /// Returns child vector for the specified field name. Throws if field with
+  /// specified name doesn't exist.
+  VectorPtr& childAt(const std::string& name) {
+    return children_[type_->asRow().getChildIdx(name)];
+  }
+
+  const VectorPtr& childAt(const std::string& name) const {
+    return children_[type_->asRow().getChildIdx(name)];
+  }
+
   std::vector<VectorPtr>& children() {
     return children_;
   }
@@ -133,6 +151,8 @@ class RowVector : public BaseVector {
     return children_;
   }
 
+  void setType(const TypePtr& type) override;
+
   void copy(
       const BaseVector* source,
       vector_size_t targetIndex,
@@ -148,6 +168,24 @@ class RowVector : public BaseVector {
       const BaseVector* source,
       const folly::Range<const CopyRange*>& ranges) override;
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const override {
+    std::vector<VectorPtr> copiedChildren(children_.size());
+
+    for (auto i = 0; i < children_.size(); ++i) {
+      copiedChildren[i] = children_[i]->copyPreserveEncodings(pool);
+    }
+
+    auto selfPool = pool ? pool : pool_;
+    return std::make_shared<RowVector>(
+        selfPool,
+        type_,
+        AlignedBuffer::copy(selfPool, nulls_),
+        length_,
+        copiedChildren,
+        nullCount_);
+  }
+
   uint64_t retainedSize() const override {
     auto size = BaseVector::retainedSize();
     for (auto& child : children_) {
@@ -196,6 +234,32 @@ class RowVector : public BaseVector {
 
   void validate(const VectorValidateOptions& options) const override;
 
+  /// Only calls BaseVector::resize and doesnt resize the children.
+  /// This function is present for backwards compatibility,
+  /// until the few places that require it are migrated over.
+  void unsafeResize(vector_size_t newSize, bool setNotNull = true);
+
+  /// Resizes the parent row container and also recursively resizes the
+  /// children. Note that this function will throw if the children are not
+  /// uniquely referenced by the parent when increasing the size.
+  /// Note : If the child is null, then it will stay null after the resize.
+  void resize(vector_size_t newSize, bool setNotNull = true) override;
+
+  /// Push all dictionary encoding to the leave vectors of a RowVector tree
+  /// (i.e. we traverse the tree consists of RowVectors, possibly wrapped in
+  /// DictionaryVector, and no traverse into other complex types like array or
+  /// map children).  If the wrapper introduce nulls on RowVector, we don't push
+  /// the dictionary into that RowVector.  The input vector should not contain
+  /// any unloaded lazy.
+  ///
+  /// This is used for example in writing Nimble ArrayWithOffsets and
+  /// SlidingWindowMap.
+  static VectorPtr pushDictionaryToRowVectorLeaves(const VectorPtr& input);
+
+  VectorPtr& rawVectorForBatchReader() {
+    return rawVectorForBatchReader_;
+  }
+
  private:
   vector_size_t childSize() const {
     bool allConstant = false;
@@ -239,10 +303,14 @@ class RowVector : public BaseVector {
   // loadedVector is called, and reset to false when updateContainsLazyNotLoaded
   // is called (i.e. some children are likely updated to lazy).
   mutable bool childrenLoaded_ = false;
+
+  // For some non-selective reader, we need to keep the original vector that is
+  // unprojected and unfilterd, and reuse its memory.
+  VectorPtr rawVectorForBatchReader_;
 };
 
-// Common parent class for ARRAY and MAP vectors.  Contains 'offsets' and
-// 'sizes' data and provide manipulations on them.
+/// Common parent class for ARRAY and MAP vectors.  Contains 'offsets' and
+/// 'sizes' data and provide manipulations on them.
 struct ArrayVectorBase : BaseVector {
   ArrayVectorBase(const ArrayVectorBase&) = delete;
   const BufferPtr& offsets() const {
@@ -270,27 +338,25 @@ struct ArrayVectorBase : BaseVector {
   }
 
   BufferPtr mutableOffsets(size_t size) {
-    BaseVector::resizeIndices(size, pool_, &offsets_, &rawOffsets_);
+    BaseVector::resizeIndices(length_, size, pool_, offsets_, &rawOffsets_);
     return offsets_;
   }
 
   BufferPtr mutableSizes(size_t size) {
-    BaseVector::resizeIndices(size, pool_, &sizes_, &rawSizes_);
+    BaseVector::resizeIndices(length_, size, pool_, sizes_, &rawSizes_);
     return sizes_;
   }
 
   void resize(vector_size_t size, bool setNotNull = true) override {
     if (BaseVector::length_ < size) {
-      BaseVector::resizeIndices(size, pool_, &offsets_, &rawOffsets_);
-      BaseVector::resizeIndices(size, pool_, &sizes_, &rawSizes_);
-      clearIndices(sizes_, length_, size);
-      // No need to clear offset indices since we set sizes to 0.
+      BaseVector::resizeIndices(length_, size, pool_, offsets_, &rawOffsets_);
+      BaseVector::resizeIndices(length_, size, pool_, sizes_, &rawSizes_);
     }
     BaseVector::resize(size, setNotNull);
   }
 
-  // Its the caller responsibility to make sure that `offsets_` and `sizes_` are
-  // safe to write at index i, i.ex not shared, or not large enough.
+  /// Its the caller responsibility to make sure that `offsets_` and `sizes_`
+  /// are safe to write at index i, i.ex not shared, or not large enough.
   void
   setOffsetAndSize(vector_size_t i, vector_size_t offset, vector_size_t size) {
     DCHECK_LT(i, BaseVector::length_);
@@ -298,9 +364,18 @@ struct ArrayVectorBase : BaseVector {
     sizes_->asMutable<vector_size_t>()[i] = size;
   }
 
-  /// Verify that an ArrayVector/MapVector does not contain overlapping [offset,
-  /// size] ranges. Throws in case overlaps are found.
-  void checkRanges() const;
+  /// Check if there is any overlapping [offset, size] ranges.
+  bool hasOverlappingRanges() const {
+    return hasOverlappingRanges(size(), rawNulls(), rawOffsets_, rawSizes_);
+  }
+
+  /// Check if there is any overlapping [offset, size] ranges for any non-null
+  /// non-empty rows.
+  static bool hasOverlappingRanges(
+      vector_size_t size,
+      const uint64_t* nulls,
+      const vector_size_t* offsets,
+      const vector_size_t* sizes);
 
  protected:
   ArrayVectorBase(
@@ -407,10 +482,26 @@ class ArrayVector : public ArrayVectorBase {
         std::move(elements), type()->childAt(0), pool_);
   }
 
+  void setType(const TypePtr& type) override;
+
   void copyRanges(
       const BaseVector* source,
       const folly::Range<const CopyRange*>& ranges) override;
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const override {
+    auto selfPool = pool ? pool : pool_;
+    return std::make_shared<ArrayVector>(
+        selfPool,
+        type_,
+        AlignedBuffer::copy(selfPool, nulls_),
+        length_,
+        AlignedBuffer::copy(selfPool, offsets_),
+        AlignedBuffer::copy(selfPool, sizes_),
+        elements_->copyPreserveEncodings(pool),
+        nullCount_);
+  }
+
   uint64_t retainedSize() const override {
     return BaseVector::retainedSize() + offsets_->capacity() +
         sizes_->capacity() + elements_->retainedSize();
@@ -523,6 +614,8 @@ class MapVector : public ArrayVectorBase {
     return values_;
   }
 
+  void setType(const TypePtr& type) override;
+
   bool hasSortedKeys() const {
     return sortedKeys_;
   }
@@ -538,6 +631,22 @@ class MapVector : public ArrayVectorBase {
       const BaseVector* source,
       const folly::Range<const CopyRange*>& ranges) override;
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const override {
+    auto selfPool = pool ? pool : pool_;
+    return std::make_shared<MapVector>(
+        selfPool,
+        type_,
+        AlignedBuffer::copy(selfPool, nulls_),
+        length_,
+        AlignedBuffer::copy(selfPool, offsets_),
+        AlignedBuffer::copy(selfPool, sizes_),
+        keys_->copyPreserveEncodings(pool),
+        values_->copyPreserveEncodings(pool),
+        nullCount_,
+        sortedKeys_);
+  }
+
   uint64_t retainedSize() const override {
     return BaseVector::retainedSize() + offsets_->capacity() +
         sizes_->capacity() + keys_->retainedSize() + values_->retainedSize();
@@ -549,17 +658,17 @@ class MapVector : public ArrayVectorBase {
 
   std::string toString(vector_size_t index) const override;
 
-  // Sorts all maps smallest key first. This enables linear time
-  // comparison and log time lookup.  This may only be done if there
-  // are no other references to 'map'. Checks that 'map' is uniquely
-  // referenced. This is guaranteed after construction or when
-  // retrieving values from aggregation or join row containers.
+  /// Sorts all maps smallest key first. This enables linear time
+  /// comparison and log time lookup.  This may only be done if there
+  /// are no other references to 'map'. Checks that 'map' is uniquely
+  /// referenced. This is guaranteed after construction or when
+  /// retrieving values from aggregation or join row containers.
   static void canonicalize(
       const std::shared_ptr<MapVector>& map,
       bool useStableSort = false);
 
-  // Returns indices into the map at 'index' such
-  // that keys[indices[i]] < keys[indices[i + 1]].
+  /// Returns indices into the map at 'index' such
+  /// that keys[indices[i]] < keys[indices[i + 1]].
   std::vector<vector_size_t> sortedKeyIndices(vector_size_t index) const;
 
   void ensureWritable(const SelectivityVector& rows) override;
@@ -581,6 +690,14 @@ class MapVector : public ArrayVectorBase {
 
   void validate(const VectorValidateOptions& options) const override;
 
+  /// Update this map vector (base) with a list of map vectors (updates) of same
+  /// size.  Maps are updated row-wise, i.e. for a certain key in each row, we
+  /// keep the entry from the last update map containing the key.  If no update
+  /// map contains the key, we use the entry from base.  Any null map in either
+  /// base or updates creates a null row in the result.
+  std::shared_ptr<MapVector> update(
+      const std::vector<std::shared_ptr<MapVector>>& others) const;
+
  protected:
   virtual void resetDataDependentFlags(const SelectivityVector* rows) override {
     BaseVector::resetDataDependentFlags(rows);
@@ -596,6 +713,10 @@ class MapVector : public ArrayVectorBase {
   // get elements in key order in each map.
   BufferPtr elementIndices() const;
 
+  template <TypeKind kKeyTypeKind>
+  std::shared_ptr<MapVector> updateImpl(
+      const std::vector<std::shared_ptr<MapVector>>& others) const;
+
   VectorPtr keys_;
   VectorPtr values_;
   bool sortedKeys_;
@@ -616,4 +737,5 @@ inline BufferPtr allocateOffsets(vector_size_t size, memory::MemoryPool* pool) {
 inline BufferPtr allocateSizes(vector_size_t size, memory::MemoryPool* pool) {
   return AlignedBuffer::allocate<vector_size_t>(size, pool, 0);
 }
+
 } // namespace facebook::velox
diff --git a/velox/vector/ConstantVector.h b/velox/vector/ConstantVector.h
index 9eb41b6e6cad8..839335ba5e498 100644
--- a/velox/vector/ConstantVector.h
+++ b/velox/vector/ConstantVector.h
@@ -88,13 +88,13 @@ class ConstantVector final : public SimpleVector<T> {
     }
   }
 
-  // Creates constant vector with value coming from 'index' element of the
-  // 'base' vector. Base vector can be flat or lazy vector. Base vector cannot
-  // be a constant or dictionary vector. Use BaseVector::wrapInConstant to
-  // automatically peel off encodings of the base vector.
-  //
-  // If base vector is lazy and has not been loaded yet, loading will be delayed
-  // until loadedVector() is called.
+  /// Creates constant vector with value coming from 'index' element of the
+  /// 'base' vector. Base vector can be flat or lazy vector. Base vector cannot
+  /// be a constant or dictionary vector. Use BaseVector::wrapInConstant to
+  /// automatically peel off encodings of the base vector.
+  ///
+  /// If base vector is lazy and has not been loaded yet, loading will be
+  /// delayed until loadedVector() is called.
   ConstantVector(
       velox::memory::MemoryPool* pool,
       vector_size_t length,
@@ -129,7 +129,11 @@ class ConstantVector final : public SimpleVector<T> {
     setInternalState();
   }
 
-  virtual ~ConstantVector() override = default;
+  virtual ~ConstantVector() override {
+    if (valueVector_) {
+      valueVector_->clearContainingLazyAndWrapped();
+    }
+  }
 
   bool isNullAt(vector_size_t /*idx*/) const override {
     VELOX_DCHECK(initialized_);
@@ -180,13 +184,9 @@ class ConstantVector final : public SimpleVector<T> {
     return &value_;
   }
 
-  /**
-   * Loads a 256bit vector of data at the virtual byteOffset given
-   * Note this method is implemented on each vector type, but is intentionally
-   * not virtual for performance reasons
-   *
-   * @param byteOffset - the byte offset to laod from
-   */
+  /// Loads a 256bit vector of data at the virtual byteOffset given
+  /// Note this method is implemented on each vector type, but is intentionally
+  /// not virtual for performance reasons
   xsimd::batch<T> loadSIMDValueBufferAt(size_t /* byteOffset */) const {
     VELOX_DCHECK(initialized_);
     return valueBuffer_;
@@ -243,20 +243,28 @@ class ConstantVector final : public SimpleVector<T> {
         kDummy);
   }
 
-  // Base vector if isScalar() is false (e.g. complex type vector) or if base
-  // vector is a lazy vector that hasn't been loaded yet.
+  /// Base vector if isScalar() is false (e.g. complex type vector) or if base
+  /// vector is a lazy vector that hasn't been loaded yet.
   const VectorPtr& valueVector() const override {
     return valueVector_;
   }
 
-  // Index of the element of the base vector that determines the value of this
-  // constant vector.
+  VectorPtr& valueVector() override {
+    return valueVector_;
+  }
+
+  /// Index of the element of the base vector that determines the value of this
+  /// constant vector.
   vector_size_t index() const {
     return index_;
   }
 
-  void resize(vector_size_t size, bool setNotNull = true) override {
-    BaseVector::length_ = size;
+  void resize(vector_size_t newSize, bool /*setNotNull*/ = true) override {
+    BaseVector::length_ = newSize;
+    if constexpr (std::is_same_v<T, StringView>) {
+      SimpleVector<StringView>::resizeIsAsciiIfNotEmpty(
+          newSize, SimpleVector<StringView>::getAllIsAscii());
+    }
   }
 
   VectorPtr slice(vector_size_t /*offset*/, vector_size_t length)
@@ -288,6 +296,10 @@ class ConstantVector final : public SimpleVector<T> {
     }
   }
 
+  void addNulls(const SelectivityVector& /*rows*/) override {
+    VELOX_FAIL("addNulls not supported");
+  }
+
   std::optional<int32_t> compare(
       const BaseVector* other,
       vector_size_t index,
@@ -344,6 +356,29 @@ class ConstantVector final : public SimpleVector<T> {
     }
   }
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const override {
+    auto selfPool = pool ? pool : BaseVector::pool_;
+    if (valueVector_) {
+      return std::make_shared<ConstantVector<T>>(
+          selfPool,
+          BaseVector::length_,
+          index_,
+          valueVector_->copyPreserveEncodings(pool),
+          SimpleVector<T>::stats_);
+    }
+
+    return std::make_shared<ConstantVector<T>>(
+        selfPool,
+        BaseVector::length_,
+        isNull_,
+        BaseVector::type_,
+        T(value_),
+        SimpleVector<T>::stats_,
+        BaseVector::representedByteCount_,
+        BaseVector::storageByteCount_);
+  }
+
  protected:
   std::string toSummaryString() const override {
     std::stringstream out;
@@ -364,10 +399,14 @@ class ConstantVector final : public SimpleVector<T> {
       // Do not load Lazy vector
       return;
     }
+    // Ensure any internal state in valueVector_ is initialized, and it points
+    // to the loaded vector underneath any lazy layers.
+    valueVector_ = BaseVector::loadedVectorShared(valueVector_);
 
     isNull_ = valueVector_->isNullAt(index_);
     BaseVector::distinctValueCount_ = isNull_ ? 0 : 1;
-    BaseVector::nullCount_ = isNull_ ? BaseVector::length_ : 0;
+    const vector_size_t vectorSize = BaseVector::length_;
+    BaseVector::nullCount_ = isNull_ ? vectorSize : 0;
     if (valueVector_->isScalar()) {
       auto simple = valueVector_->loadedVector()->as<SimpleVector<T>>();
       isNull_ = simple->isNullAt(index_);
diff --git a/velox/vector/DecodedVector.cpp b/velox/vector/DecodedVector.cpp
index 16d81d28fd541..9d7f2e0882158 100644
--- a/velox/vector/DecodedVector.cpp
+++ b/velox/vector/DecodedVector.cpp
@@ -42,13 +42,14 @@ const std::vector<vector_size_t>& DecodedVector::consecutiveIndices() {
 const std::vector<vector_size_t>& DecodedVector::zeroIndices() {
   static std::vector<vector_size_t> indices(10'000);
   return indices;
-};
+}
 
 void DecodedVector::decode(
     const BaseVector& vector,
     const SelectivityVector* rows,
     bool loadLazy) {
   reset(end(vector.size(), rows));
+  partialRowsDecoded_ = rows != nullptr;
   loadLazy_ = loadLazy;
   bool isTopLevelLazyAndLoaded =
       vector.isLazy() && vector.asUnchecked<LazyVector>()->isLoaded();
@@ -413,7 +414,7 @@ VectorPtr DecodedVector::wrap(
       std::move(data));
 }
 
-const uint64_t* DecodedVector::nulls() {
+const uint64_t* DecodedVector::nulls(const SelectivityVector* rows) {
   if (allNulls_.has_value()) {
     return allNulls_.value();
   }
@@ -433,9 +434,19 @@ const uint64_t* DecodedVector::nulls() {
       // Copy base nulls.
       copiedNulls_.resize(bits::nwords(size_));
       auto* rawCopiedNulls = copiedNulls_.data();
-      for (auto i = 0; i < size_; ++i) {
-        bits::setNull(rawCopiedNulls, i, bits::isBitNull(nulls_, indices_[i]));
+      VELOX_CHECK(
+          partialRowsDecoded_ == (rows != nullptr),
+          "DecodedVector::nulls() must be called with the same rows as decode()");
+      if (rows != nullptr) {
+        // Partial consistency check: The end may be less than the decode time
+        // end but not greater.
+        VELOX_CHECK_LE(rows->end(), size_);
       }
+      auto baseSize = baseVector_->size();
+      applyToRows(rows, [&](auto i) {
+        VELOX_DCHECK_LT(indices_[i], baseSize);
+        bits::setNull(rawCopiedNulls, i, bits::isBitNull(nulls_, indices_[i]));
+      });
       allNulls_ = copiedNulls_.data();
     }
   }
@@ -454,4 +465,12 @@ void DecodedVector::applyToRows(const SelectivityVector* rows, Func&& func)
     }
   }
 }
+
+std::string DecodedVector::toString(vector_size_t idx) const {
+  if (isNullAt(idx)) {
+    return "null";
+  }
+
+  return baseVector_->toString(index(idx));
+}
 } // namespace facebook::velox
diff --git a/velox/vector/DecodedVector.h b/velox/vector/DecodedVector.h
index d7ff26ea9a6cb..4da24b75d062b 100644
--- a/velox/vector/DecodedVector.h
+++ b/velox/vector/DecodedVector.h
@@ -144,9 +144,10 @@ class DecodedVector {
   ///
   ///  nulls() ? bits::isBitNull(nulls(), i) : false
   ///
-  /// returns the null flag for top-level row 'i' given that 'i' is one of the
-  /// rows specified for decoding.
-  const uint64_t* nulls();
+  /// Only bit positions for decoded rows are valid. If 'rows' were
+  /// specified with decode(), the same rows have to be specified
+  /// here.
+  const uint64_t* nulls(const SelectivityVector* rows = nullptr);
 
   /// Returns true if wrappings may have added nulls.
   bool hasExtraNulls() const {
@@ -229,6 +230,9 @@ class DecodedVector {
     return isConstantMapping_;
   }
 
+  /// Returns string representation of the value in the specified row.
+  std::string toString(vector_size_t idx) const;
+
   /////////////////////////////////////////////////////////////////
   /// BEGIN: Members that must only be used by PeeledEncoding class.
   /// See class comment for more details.
@@ -404,6 +408,10 @@ class DecodedVector {
 
   bool loadLazy_ = false;
 
+  // True if decode() was called with rows != nullptr. If so, nulls() must also
+  // be called with the same 'rows'.
+  bool partialRowsDecoded_{true};
+
   // Index of an element of the baseVector_ that points to a constant value of
   // complex type. Applies only when isConstantMapping_ is true and baseVector_
   // is of complex type (array, map, row).
diff --git a/velox/vector/DictionaryVector-inl.h b/velox/vector/DictionaryVector-inl.h
index 1175d1bb26a39..add6dcf5a5512 100644
--- a/velox/vector/DictionaryVector-inl.h
+++ b/velox/vector/DictionaryVector-inl.h
@@ -40,6 +40,9 @@ void DictionaryVector<T>::setInternalState() {
     // Do not load Lazy vector
     return;
   }
+  // Ensure any internal state in dictionaryValues_ is initialized, and it
+  // points to the loaded vector underneath any lazy layers.
+  dictionaryValues_ = BaseVector::loadedVectorShared(dictionaryValues_);
 
   if (dictionaryValues_->isScalar()) {
     scalarDictionaryValues_ =
diff --git a/velox/vector/DictionaryVector.h b/velox/vector/DictionaryVector.h
index 84d021a8bdc79..87c210bf4a1fd 100644
--- a/velox/vector/DictionaryVector.h
+++ b/velox/vector/DictionaryVector.h
@@ -15,11 +15,10 @@
  */
 #pragma once
 
+#include <folly/container/F14Map.h>
 #include <memory>
 #include <type_traits>
 
-#include <folly/container/F14Map.h>
-
 #include "velox/common/base/SimdUtil.h"
 #include "velox/vector/LazyVector.h"
 #include "velox/vector/SimpleVector.h"
@@ -65,7 +64,9 @@ class DictionaryVector : public SimpleVector<T> {
       std::optional<ByteCount> representedBytes = std::nullopt,
       std::optional<ByteCount> storageByteCount = std::nullopt);
 
-  virtual ~DictionaryVector() override = default;
+  virtual ~DictionaryVector() override {
+    dictionaryValues_->clearContainingLazyAndWrapped();
+  }
 
   bool mayHaveNulls() const override {
     VELOX_DCHECK(initialized_);
@@ -122,16 +123,25 @@ class DictionaryVector : public SimpleVector<T> {
     return indices_;
   }
 
+  inline BufferPtr& indices() {
+    return indices_;
+  }
+
   const VectorPtr& valueVector() const override {
     return dictionaryValues_;
   }
 
+  VectorPtr& valueVector() override {
+    return dictionaryValues_;
+  }
+
   BufferPtr wrapInfo() const override {
     return indices_;
   }
 
   BufferPtr mutableIndices(vector_size_t size) {
-    BaseVector::resizeIndices(size, BaseVector::pool_, &indices_, &rawIndices_);
+    BaseVector::resizeIndices(
+        BaseVector::length_, size, BaseVector::pool_, indices_, &rawIndices_);
     return indices_;
   }
 
@@ -159,6 +169,7 @@ class DictionaryVector : public SimpleVector<T> {
     rows.updateBounds();
 
     LazyVector::ensureLoadedRows(dictionaryValues_, rows);
+    dictionaryValues_ = BaseVector::loadedVectorShared(dictionaryValues_);
     setInternalState();
     return this;
   }
@@ -187,6 +198,7 @@ class DictionaryVector : public SimpleVector<T> {
   }
 
   void setDictionaryValues(VectorPtr dictionaryValues) {
+    dictionaryValues_->clearContainingLazyAndWrapped();
     dictionaryValues_ = dictionaryValues;
     initialized_ = false;
     setInternalState();
@@ -198,10 +210,16 @@ class DictionaryVector : public SimpleVector<T> {
   void resize(vector_size_t size, bool setNotNull = true) override {
     if (size > BaseVector::length_) {
       BaseVector::resizeIndices(
-          size, BaseVector::pool(), &indices_, &rawIndices_);
-      this->clearIndices(indices_, BaseVector::length_, size);
+          BaseVector::length_,
+          size,
+          BaseVector::pool(),
+          indices_,
+          &rawIndices_);
     }
 
+    // TODO Fix the case when base vector is empty.
+    // https://github.com/facebookincubator/velox/issues/7828
+
     BaseVector::resize(size, setNotNull);
   }
 
@@ -209,6 +227,23 @@ class DictionaryVector : public SimpleVector<T> {
 
   void validate(const VectorValidateOptions& options) const override;
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const override {
+    auto selfPool = pool ? pool : BaseVector::pool_;
+    return std::make_shared<DictionaryVector<T>>(
+        selfPool,
+        AlignedBuffer::copy(selfPool, BaseVector::nulls_),
+        BaseVector::length_,
+        dictionaryValues_->copyPreserveEncodings(),
+        AlignedBuffer::copy(selfPool, indices_),
+        SimpleVector<T>::stats_,
+        BaseVector::distinctValueCount_,
+        BaseVector::nullCount_,
+        SimpleVector<T>::isSorted_,
+        BaseVector::representedByteCount_,
+        BaseVector::storageByteCount_);
+  }
+
  private:
   // return the dictionary index for the specified vector index.
   inline vector_size_t getDictionaryIndex(vector_size_t idx) const {
diff --git a/velox/vector/FlatVector-inl.h b/velox/vector/FlatVector-inl.h
index 5dbad5eae5599..d56037114e7d0 100644
--- a/velox/vector/FlatVector-inl.h
+++ b/velox/vector/FlatVector-inl.h
@@ -15,11 +15,12 @@
  */
 #include <folly/hash/Hash.h>
 
-#include <velox/vector/BaseVector.h>
+#include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/SimdUtil.h"
 #include "velox/vector/BuilderTypeUtils.h"
 #include "velox/vector/ConstantVector.h"
+#include "velox/vector/DecodedVector.h"
 #include "velox/vector/TypeAliases.h"
 
 namespace facebook {
@@ -84,23 +85,14 @@ std::unique_ptr<SimpleVector<uint64_t>> FlatVector<T>::hashAll() const {
   auto hashData = hashBuffer->asMutable<uint64_t>();
 
   if (rawValues_ != nullptr) { // non all-null case
-    if constexpr (std::is_same_v<T, StringView>) {
-      folly::hasher<folly::StringPiece> stringHasher;
-      for (size_t i = 0; i < BaseVector::length_; ++i) {
-        auto view = valueAt(i);
-        folly::StringPiece piece(view.data(), view.size());
-        hashData[i] = stringHasher(piece);
-      }
-    } else {
-      folly::hasher<T> hasher;
-      for (size_t i = 0; i < BaseVector::length_; ++i) {
-        hashData[i] = hasher(valueAtFast(i));
-      }
+    folly::hasher<T> hasher;
+    for (size_t i = 0; i < BaseVector::length_; ++i) {
+      hashData[i] = hasher(valueAtFast(i));
     }
   }
 
   // overwrite the null hash values
-  if (BaseVector::getNullCount().value_or(1) > 0) {
+  if (BaseVector::rawNulls_ != nullptr) {
     for (size_t i = 0; i < BaseVector::length_; ++i) {
       if (bits::isBitNull(BaseVector::rawNulls_, i)) {
         hashData[i] = BaseVector::kNullHash;
@@ -143,14 +135,17 @@ void FlatVector<T>::copyValuesAndNulls(
     const vector_size_t* toSourceRow) {
   if (source->typeKind() == TypeKind::UNKNOWN) {
     auto* rawNulls = BaseVector::mutableRawNulls();
-    rows.applyToSelected([&](auto row) { bits::setNull(rawNulls, row, true); });
+    rows.setNulls(rawNulls);
     return;
   }
 
   source = source->loadedVector();
   VELOX_CHECK_EQ(BaseVector::typeKind(), source->typeKind());
   VELOX_CHECK_GE(BaseVector::length_, rows.end());
-  const uint64_t* sourceNulls = source->rawNulls();
+  if (!toSourceRow) {
+    VELOX_CHECK_GE(source->size(), rows.end());
+  }
+
   uint64_t* rawNulls = const_cast<uint64_t*>(BaseVector::rawNulls_);
   if (source->mayHaveNulls()) {
     rawNulls = BaseVector::mutableRawNulls();
@@ -166,8 +161,7 @@ void FlatVector<T>::copyValuesAndNulls(
     auto* flatSource = source->asUnchecked<FlatVector<T>>();
     if (flatSource->values() == nullptr) {
       // All source values are null.
-      rows.applyToSelected(
-          [&](auto row) { bits::setNull(rawNulls, row, true); });
+      rows.setNulls(rawNulls);
       return;
     }
 
@@ -176,19 +170,29 @@ void FlatVector<T>::copyValuesAndNulls(
       auto* sourceValues = flatSource->template rawValues<uint64_t>();
       if (toSourceRow) {
         rows.applyToSelected([&](auto row) {
-          int32_t sourceRow = toSourceRow[row];
+          auto sourceRow = toSourceRow[row];
+          VELOX_DCHECK_GT(source->size(), sourceRow);
           bits::setBit(rawValues, row, bits::isBitSet(sourceValues, sourceRow));
         });
       } else {
-        rows.applyToSelected([&](auto row) {
-          bits::setBit(rawValues, row, bits::isBitSet(sourceValues, row));
-        });
+        const auto numBits = rows.countSelected();
+        if (numBits == rows.end() - rows.begin()) {
+          // Fast path for copying contiguous range of bits.
+          bits::copyBits(
+              sourceValues, rows.begin(), rawValues, rows.begin(), numBits);
+        } else {
+          rows.applyToSelected([&](auto row) {
+            bits::setBit(rawValues, row, bits::isBitSet(sourceValues, row));
+          });
+        }
       }
     } else {
       auto* sourceValues = flatSource->rawValues();
       if (toSourceRow) {
         rows.applyToSelected([&](auto row) {
-          rawValues_[row] = sourceValues[toSourceRow[row]];
+          auto sourceRow = toSourceRow[row];
+          VELOX_DCHECK_GT(source->size(), sourceRow);
+          rawValues_[row] = sourceValues[sourceRow];
         });
       } else {
         rows.applyToSelected(
@@ -197,26 +201,26 @@ void FlatVector<T>::copyValuesAndNulls(
     }
 
     if (rawNulls) {
+      const uint64_t* sourceNulls = source->rawNulls();
+
       if (!sourceNulls) {
-        rows.applyToSelected(
-            [&](vector_size_t row) { bits::setNull(rawNulls, row, false); });
+        rows.clearNulls(rawNulls);
       } else {
         if (toSourceRow) {
           rows.applyToSelected([&](auto row) {
             auto sourceRow = toSourceRow[row];
+            VELOX_DCHECK_GT(source->size(), sourceRow);
             bits::setNull(
                 rawNulls, row, bits::isBitNull(sourceNulls, sourceRow));
           });
         } else {
-          rows.applyToSelected([&](vector_size_t row) {
-            bits::setNull(rawNulls, row, bits::isBitNull(sourceNulls, row));
-          });
+          rows.copyNulls(rawNulls, sourceNulls);
         }
       }
     }
   } else if (source->isConstantEncoding()) {
     if (source->isNullAt(0)) {
-      BaseVector::addNulls(nullptr, rows);
+      BaseVector::addNulls(rows);
       return;
     }
     auto constant = source->asUnchecked<ConstantVector<T>>();
@@ -236,24 +240,48 @@ void FlatVector<T>::copyValuesAndNulls(
 
     rows.clearNulls(rawNulls);
   } else {
-    auto sourceVector = source->asUnchecked<SimpleVector<T>>();
-    rows.applyToSelected([&](auto row) {
-      auto sourceRow = toSourceRow ? toSourceRow[row] : row;
-      if (!source->isNullAt(sourceRow)) {
-        if constexpr (std::is_same_v<T, bool>) {
-          auto* rawValues = reinterpret_cast<uint64_t*>(rawValues_);
-          bits::setBit(rawValues, row, sourceVector->valueAt(sourceRow));
-        } else {
-          rawValues_[row] = sourceVector->valueAt(sourceRow);
+    DecodedVector decoded(*source);
+    if (toSourceRow == nullptr) {
+      rows.applyToSelected([&](auto row) {
+        if (!decoded.isNullAt(row)) {
+          if constexpr (std::is_same_v<T, bool>) {
+            auto* rawValues = reinterpret_cast<uint64_t*>(rawValues_);
+            bits::setBit(rawValues, row, decoded.valueAt<T>(row));
+          } else {
+            rawValues_[row] = decoded.valueAt<T>(row);
+          }
         }
+      });
 
-        if (rawNulls) {
-          bits::clearNull(rawNulls, row);
+      if (rawNulls != nullptr) {
+        auto* sourceNulls = decoded.nulls();
+        if (sourceNulls == nullptr) {
+          rows.clearNulls(rawNulls);
+        } else {
+          rows.copyNulls(rawNulls, sourceNulls);
         }
-      } else {
-        bits::setNull(rawNulls, row);
       }
-    });
+
+    } else {
+      rows.applyToSelected([&](auto row) {
+        const auto sourceRow = toSourceRow[row];
+        VELOX_DCHECK_GT(source->size(), sourceRow);
+        if (!decoded.isNullAt(sourceRow)) {
+          if constexpr (std::is_same_v<T, bool>) {
+            auto* rawValues = reinterpret_cast<uint64_t*>(rawValues_);
+            bits::setBit(rawValues, row, decoded.valueAt<T>(sourceRow));
+          } else {
+            rawValues_[row] = decoded.valueAt<T>(sourceRow);
+          }
+
+          if (rawNulls) {
+            bits::clearNull(rawNulls, row);
+          }
+        } else {
+          bits::setNull(rawNulls, row);
+        }
+      });
+    }
   }
 }
 
@@ -402,7 +430,7 @@ VectorPtr FlatVector<T>::slice(vector_size_t offset, vector_size_t length)
 
 template <typename T>
 void FlatVector<T>::resize(vector_size_t newSize, bool setNotNull) {
-  auto previousSize = BaseVector::length_;
+  const vector_size_t previousSize = BaseVector::length_;
   if (newSize == previousSize) {
     return;
   }
@@ -414,8 +442,9 @@ void FlatVector<T>::resize(vector_size_t newSize, bool setNotNull) {
   if constexpr (std::is_same_v<T, StringView>) {
     resizeValues(newSize, StringView());
     if (newSize < previousSize) {
-      auto vector = this->template asUnchecked<SimpleVector<StringView>>();
-      vector->invalidateIsAscii();
+      // If we downsize, just invalidate ascii, because we might have become
+      // 'all ascii' from 'not all ascii'.
+      SimpleVector<StringView>::invalidateIsAscii();
     } else {
       // Properly init stringView objects. This is useful when vectors are
       // re-used where the size changes but not the capacity.
@@ -425,9 +454,10 @@ void FlatVector<T>::resize(vector_size_t newSize, bool setNotNull) {
       for (auto index = previousSize; index < newSize; ++index) {
         new (&stringViews[index]) StringView();
       }
+      SimpleVector<StringView>::resizeIsAsciiIfNotEmpty(newSize, false);
     }
     if (newSize == 0) {
-      clearStringBuffers();
+      keepAtMostOneStringBuffer();
     }
   } else {
     resizeValues(newSize, std::nullopt);
@@ -447,14 +477,16 @@ void FlatVector<T>::ensureWritable(const SelectivityVector& rows) {
       newValues = AlignedBuffer::allocate<T>(newSize, BaseVector::pool_);
     }
 
-    SelectivityVector rowsToCopy(BaseVector::length_);
-    rowsToCopy.deselect(rows);
-
     if constexpr (std::is_same_v<T, bool>) {
       auto rawNewValues = newValues->asMutable<uint64_t>();
-      std::memcpy(rawNewValues, rawValues_, values_->size());
+      std::memcpy(
+          rawNewValues,
+          rawValues_,
+          std::min(values_->size(), newValues->size()));
     } else {
       auto rawNewValues = newValues->asMutable<T>();
+      SelectivityVector rowsToCopy(BaseVector::length_);
+      rowsToCopy.deselect(rows);
       rowsToCopy.applyToSelected(
           [&](vector_size_t row) { rawNewValues[row] = rawValues_[row]; });
     }
@@ -512,11 +544,11 @@ void FlatVector<T>::resizeValues(
       auto len = std::min(values_->size(), newValues->size());
       memcpy(dst, src, len);
     } else {
-      auto previousSize = BaseVector::length_;
-      auto rawOldValues = newValues->asMutable<T>();
-      auto rawNewValues = newValues->asMutable<T>();
-      auto len = std::min<vector_size_t>(newSize, previousSize);
-      for (vector_size_t row = 0; row < len; row++) {
+      const vector_size_t previousSize = BaseVector::length_;
+      auto* rawOldValues = newValues->asMutable<T>();
+      auto* rawNewValues = newValues->asMutable<T>();
+      const auto len = std::min<vector_size_t>(newSize, previousSize);
+      for (vector_size_t row = 0; row < len; ++row) {
         rawNewValues[row] = rawOldValues[row];
       }
     }
diff --git a/velox/vector/FlatVector.cpp b/velox/vector/FlatVector.cpp
index 684e04b3c3ed0..8bdbaadc11480 100644
--- a/velox/vector/FlatVector.cpp
+++ b/velox/vector/FlatVector.cpp
@@ -39,7 +39,9 @@ Range<bool> FlatVector<bool>::asRange() const {
 
 template <>
 void FlatVector<bool>::set(vector_size_t idx, bool value) {
-  VELOX_DCHECK(idx < BaseVector::length_);
+  VELOX_DCHECK_LT(idx, BaseVector::length_);
+  ensureValues();
+  VELOX_DCHECK(!values_->isView());
   if (BaseVector::rawNulls_) {
     BaseVector::setNull(idx, false);
   }
@@ -47,7 +49,9 @@ void FlatVector<bool>::set(vector_size_t idx, bool value) {
 }
 
 template <>
-Buffer* FlatVector<StringView>::getBufferWithSpace(vector_size_t size) {
+Buffer* FlatVector<StringView>::getBufferWithSpace(
+    size_t size,
+    bool exactSize) {
   VELOX_DCHECK_GE(stringBuffers_.size(), stringBufferSet_.size());
 
   // Check if the last buffer is uniquely referenced and has enough space.
@@ -59,7 +63,7 @@ Buffer* FlatVector<StringView>::getBufferWithSpace(vector_size_t size) {
   }
 
   // Allocate a new buffer.
-  int32_t newSize = std::max(kInitialStringSize, size);
+  const size_t newSize = exactSize ? size : std::max(kInitialStringSize, size);
   BufferPtr newBuffer = AlignedBuffer::allocate<char>(newSize, pool());
   newBuffer->setSize(0);
   addStringBuffer(newBuffer);
@@ -67,8 +71,10 @@ Buffer* FlatVector<StringView>::getBufferWithSpace(vector_size_t size) {
 }
 
 template <>
-char* FlatVector<StringView>::getRawStringBufferWithSpace(vector_size_t size) {
-  Buffer* buffer = getBufferWithSpace(size);
+char* FlatVector<StringView>::getRawStringBufferWithSpace(
+    size_t size,
+    bool exactSize) {
+  Buffer* buffer = getBufferWithSpace(size, exactSize);
   char* rawBuffer = buffer->asMutable<char>() + buffer->size();
   buffer->setSize(buffer->size() + size);
   return rawBuffer;
@@ -85,18 +91,7 @@ void FlatVector<StringView>::prepareForReuse() {
     rawValues_ = nullptr;
   }
 
-  // Check string buffers. Keep at most one singly-referenced buffer if it is
-  // not too large.
-  if (!stringBuffers_.empty()) {
-    auto& firstBuffer = stringBuffers_.front();
-    if (firstBuffer->isMutable() &&
-        firstBuffer->capacity() <= kMaxStringSizeForReuse) {
-      firstBuffer->setSize(0);
-      setStringBuffers({firstBuffer});
-    } else {
-      clearStringBuffers();
-    }
-  }
+  keepAtMostOneStringBuffer();
 
   // Clear the StringViews to avoid referencing freed memory.
   if (rawValues_) {
@@ -108,7 +103,9 @@ void FlatVector<StringView>::prepareForReuse() {
 
 template <>
 void FlatVector<StringView>::set(vector_size_t idx, StringView value) {
-  VELOX_DCHECK(idx < BaseVector::length_);
+  VELOX_DCHECK_LT(idx, BaseVector::length_);
+  ensureValues();
+  VELOX_DCHECK(!values_->isView());
   if (BaseVector::rawNulls_) {
     BaseVector::setNull(idx, false);
   }
@@ -131,12 +128,13 @@ template <>
 void FlatVector<StringView>::setNoCopy(
     const vector_size_t idx,
     const StringView& value) {
-  VELOX_DCHECK(idx < BaseVector::length_);
+  VELOX_DCHECK_LT(idx, BaseVector::length_);
+  ensureValues();
   VELOX_DCHECK(!values_->isView());
-  rawValues_[idx] = value;
   if (BaseVector::nulls_) {
     BaseVector::setNull(idx, false);
   }
+  rawValues_[idx] = value;
 }
 
 template <>
@@ -281,14 +279,44 @@ void FlatVector<StringView>::copy(
     copyValuesAndNulls(source, rows, toSourceRow);
     acquireSharedStringBuffers(source);
   } else {
+    DecodedVector decoded(*source);
+    uint64_t* rawNulls = const_cast<uint64_t*>(BaseVector::rawNulls_);
+    if (decoded.mayHaveNulls()) {
+      rawNulls = BaseVector::mutableRawNulls();
+    }
+
+    size_t totalBytes = 0;
     rows.applyToSelected([&](vector_size_t row) {
-      auto sourceRow = toSourceRow ? toSourceRow[row] : row;
-      if (source->isNullAt(sourceRow)) {
-        setNull(row, true);
+      const auto sourceRow = toSourceRow ? toSourceRow[row] : row;
+      if (decoded.isNullAt(sourceRow)) {
+        bits::setNull(rawNulls, row);
       } else {
-        set(row, leaf->valueAt(source->wrappedIndex(sourceRow)));
+        if (rawNulls) {
+          bits::clearNull(rawNulls, row);
+        }
+        auto v = decoded.valueAt<StringView>(sourceRow);
+        if (v.isInline()) {
+          rawValues_[row] = v;
+        } else {
+          totalBytes += v.size();
+        }
       }
     });
+
+    if (totalBytes > 0) {
+      auto* buffer = getRawStringBufferWithSpace(totalBytes);
+      rows.applyToSelected([&](vector_size_t row) {
+        const auto sourceRow = toSourceRow ? toSourceRow[row] : row;
+        if (!decoded.isNullAt(sourceRow)) {
+          auto v = decoded.valueAt<StringView>(sourceRow);
+          if (!v.isInline()) {
+            memcpy(buffer, v.data(), v.size());
+            rawValues_[row] = StringView(buffer, v.size());
+            buffer += v.size();
+          }
+        }
+      });
+    }
   }
 
   if (auto stringVector = source->as<SimpleVector<StringView>>()) {
@@ -296,13 +324,13 @@ void FlatVector<StringView>::copy(
       setIsAscii(ascii.value(), rows);
     } else {
       // ASCII-ness for the 'rows' is not known.
-      ensureIsAsciiCapacity(rows.end());
+      ensureIsAsciiCapacity();
       // If we arent All ascii, then invalidate
       // because the remaining selected rows might be ascii
       if (!asciiInfo.isAllAscii()) {
         invalidateIsAscii();
       } else {
-        asciiInfo.asciiSetRows().deselect(rows);
+        asciiInfo.writeLockedAsciiComputedRows()->deselect(rows);
       }
     }
   }
@@ -340,7 +368,7 @@ void FlatVector<StringView>::validate(
       VELOX_CHECK(
           isValid,
           "String view at idx {} points outside of the string buffers",
-          i)
+          i);
     }
   }
 }
diff --git a/velox/vector/FlatVector.h b/velox/vector/FlatVector.h
index 802d779bbecc5..3d680914c23ca 100644
--- a/velox/vector/FlatVector.h
+++ b/velox/vector/FlatVector.h
@@ -28,9 +28,9 @@
 
 namespace facebook::velox {
 
-// FlatVector is marked final to allow for inlining on virtual methods called
-// on a pointer that has the static type FlatVector<T>; this can be a
-// significant performance win when these methods are called in loops.
+/// FlatVector is marked final to allow for inlining on virtual methods called
+/// on a pointer that has the static type FlatVector<T>; this can be a
+/// significant performance win when these methods are called in loops.
 template <typename T>
 class FlatVector final : public SimpleVector<T> {
  public:
@@ -43,14 +43,14 @@ class FlatVector final : public SimpleVector<T> {
        std::is_same_v<T, int16_t> || std::is_same_v<T, int8_t> ||
        std::is_same_v<T, bool> || std::is_same_v<T, size_t>);
 
-  // Minimum size of a string buffer. 32 KB value is chosen to ensure that a
-  // single buffer is sufficient for a "typical" vector: 1K rows, medium size
-  // strings.
-  static constexpr vector_size_t kInitialStringSize =
+  /// Minimum size of a string buffer. 32 KB value is chosen to ensure that a
+  /// single buffer is sufficient for a "typical" vector: 1K rows, medium size
+  /// strings.
+  static constexpr size_t kInitialStringSize =
       (32 * 1024) - sizeof(AlignedBuffer);
   /// Maximum size of a string buffer to re-use (see
   /// BaseVector::prepareForReuse): 1MB.
-  static constexpr vector_size_t kMaxStringSizeForReuse =
+  static constexpr size_t kMaxStringSizeForReuse =
       (1 << 20) - sizeof(AlignedBuffer);
 
   FlatVector(
@@ -86,6 +86,13 @@ class FlatVector final : public SimpleVector<T> {
         values_ || BaseVector::nulls_,
         "FlatVector needs to either have values or nulls");
     if (!values_) {
+      // Make sure that all rows are null.
+      auto cnt =
+          bits::countNonNulls(BaseVector::rawNulls_, 0, BaseVector::length_);
+      VELOX_CHECK_EQ(
+          0,
+          cnt,
+          "FlatVector with null values buffer must have all rows set to null");
       return;
     }
     auto byteSize = BaseVector::byteSize<T>(BaseVector::length_);
@@ -114,28 +121,23 @@ class FlatVector final : public SimpleVector<T> {
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
-  /**
-   * Loads a SIMD vector of data at the virtual byteOffset given
-   * Note this method is implemented on each vector type, but is intentionally
-   * not virtual for performance reasons
-   *
-   * @param byteOffset - the byte offset to load from
-   */
+  /// Loads a SIMD vector of data at the virtual byteOffset given
+  /// Note this method is implemented on each vector type, but is intentionally
+  /// not virtual for performance reasons.
+  /// 'index' indicates the byte offset to load from
   xsimd::batch<T> loadSIMDValueBufferAt(size_t index) const;
 
-  // dictionary vector makes internal usehere for SIMD functions
+  /// dictionary vector makes internal usehere for SIMD functions
   template <typename X>
   friend class DictionaryVector;
 
-  // Sequence vector needs to get shared_ptr to value array
+  /// Sequence vector needs to get shared_ptr to value array
   template <typename X>
   friend class SequenceVector;
 
-  /**
-   * @return a smart pointer holding the values for
-   * this vector. This is used during execution to process over the subset of
-   * values when possible.
-   */
+  /// Returns a smart pointer holding the values for
+  /// this vector. This is used during execution to process over the subset of
+  /// values when possible.
   const BufferPtr& values() const override {
     return values_;
   }
@@ -181,16 +183,12 @@ class FlatVector final : public SimpleVector<T> {
     return values_;
   }
 
-  /**
-   * @return true if this number of comparison values on this vector should use
-   * simd for equality constraint filtering, false to use standard set
-   * examination filtering.
-   */
+  /// Returns true if this number of comparison values on this vector should use
+  /// simd for equality constraint filtering, false to use standard set
+  /// examination filtering.
   bool useSimdEquality(size_t numCmpVals) const;
 
-  /**
-   * @return the raw values of this vector as a continuous array.
-   */
+  /// Returns the raw values of this vector as a continuous array.
   const T* rawValues() const;
 
   const void* valuesAsVoid() const override {
@@ -202,8 +200,8 @@ class FlatVector final : public SimpleVector<T> {
     return reinterpret_cast<const As*>(rawValues_);
   }
 
-  // Bool uses compact representation, use mutableRawValues<uint64_t> and
-  // bits::setBit instead.
+  /// Bool uses compact representation, use mutableRawValues<uint64_t> and
+  /// bits::setBit instead.
   T* mutableRawValues() {
     if (!(values_ && values_->isMutable())) {
       BufferPtr newValues =
@@ -227,8 +225,16 @@ class FlatVector final : public SimpleVector<T> {
 
   Range<T> asRange() const;
 
+  void setNull(vector_size_t idx, bool isNull) override {
+    BaseVector::setNull(idx, isNull);
+    if (!isNull) {
+      ensureValues();
+    }
+  }
+
   void set(vector_size_t idx, T value) {
-    VELOX_DCHECK(idx < BaseVector::length_);
+    VELOX_DCHECK_LT(idx, BaseVector::length_);
+    ensureValues();
     VELOX_DCHECK(!values_->isView());
     rawValues_[idx] = value;
     if (BaseVector::nulls_) {
@@ -266,6 +272,23 @@ class FlatVector final : public SimpleVector<T> {
       const BaseVector* source,
       const folly::Range<const BaseVector::CopyRange*>& ranges) override;
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const override {
+    return std::make_shared<FlatVector<T>>(
+        pool ? pool : BaseVector::pool_,
+        BaseVector::type_,
+        AlignedBuffer::copy(BaseVector::pool_, BaseVector::nulls_),
+        BaseVector::length_,
+        AlignedBuffer::copy(BaseVector::pool_, values_),
+        std::vector<BufferPtr>(stringBuffers_),
+        SimpleVector<T>::stats_,
+        BaseVector::distinctValueCount_,
+        BaseVector::nullCount_,
+        SimpleVector<T>::isSorted_,
+        BaseVector::representedByteCount_,
+        BaseVector::storageByteCount_);
+  }
+
   void resize(vector_size_t newSize, bool setNotNull = true) override;
 
   VectorPtr slice(vector_size_t offset, vector_size_t length) const override;
@@ -378,12 +401,10 @@ class FlatVector final : public SimpleVector<T> {
     return size;
   }
 
-  /**
-   * Used for vectors of type VARCHAR and VARBINARY to hold data referenced by
-   * StringView's. It is safe to share these among multiple vectors. These
-   * buffers are append only. It is allowed to append data, but it is prohibited
-   * to modify already written data.
-   */
+  /// Used for vectors of type VARCHAR and VARBINARY to hold data referenced by
+  /// StringView's. It is safe to share these among multiple vectors. These
+  /// buffers are append only. It is allowed to append data, but it is
+  /// prohibited to modify already written data.
   const std::vector<BufferPtr>& stringBuffers() const {
     return stringBuffers_;
   }
@@ -423,28 +444,47 @@ class FlatVector final : public SimpleVector<T> {
     return true;
   }
 
-  // Acquire ownership for any string buffer that appears in source, the
-  // function does nothing if the vector type is not Varchar or Varbinary.
-  // The function throws if input encoding is lazy.
+  /// Acquire ownership for any string buffer that appears in source, the
+  /// function does nothing if the vector type is not Varchar or Varbinary.
+  /// The function throws if input encoding is lazy.
   void acquireSharedStringBuffers(const BaseVector* source);
 
-  // Acquire ownership for any string buffer that appears in source or any
-  // of its children recursively. The function throws if input encoding is lazy.
+  /// Acquire ownership for any string buffer that appears in source or any
+  /// of its children recursively. The function throws if input encoding is
+  /// lazy.
   void acquireSharedStringBuffersRecursive(const BaseVector* source);
 
-  Buffer* getBufferWithSpace(vector_size_t /* unused */) {
+  /// This API is available only for string vectors (T = StringView).
+  /// Prefer getRawStringBufferWithSpace(bytes) API as it is easier to use
+  /// safely.
+  ///
+  /// Returns a string buffer with enough capacity to fit 'size' more bytes.
+  /// This could be an existing or newly allocated buffer. The caller must not
+  /// assume that the buffer is empty and must use Buffer::size() API to find
+  /// the start of the writable memory. The caller must also call
+  /// Buffer::setSize(n) to update the size of the buffer to include newly
+  /// written content ('n' cannot exceed 'size', but can be less than 'size').
+  /// The caller must ensure not to write more then 'size' bytes.
+  ///
+  /// If allocates new buffer and 'exactSize' is true, allocates 'size' bytes.
+  /// Otherwise, allocates at least kInitialStringSize bytes.
+  Buffer* getBufferWithSpace(size_t /*size*/, bool exactSize = false) {
     return nullptr;
   }
 
-  // Finds an existing string buffer that's singly-referenced (not shared) and
-  // have enough unused capacity to fit 'size' bytes. If found, resizes the
-  // buffer to add 'size' bytes and returns a pointer to the start of writable
-  // memory. If not found, allocates new buffer, adds it to 'stringBuffers',
-  // sets buffer size to 'size' and returns a pointer to the start of writable
-  // memory.
-  // The caller needs to make sure not to write more then 'size' bytes.
-
-  char* getRawStringBufferWithSpace(vector_size_t /* size */) {
+  /// This API is available only for string vectors (T = StringView).
+  ///
+  /// Finds an existing string buffer that's singly-referenced (not shared) and
+  /// have enough unused capacity to fit 'size' bytes. If found, resizes the
+  /// buffer to add 'size' bytes and returns a pointer to the start of writable
+  /// memory. If not found, allocates new buffer, adds it to 'stringBuffers',
+  /// sets buffer size to 'size' and returns a pointer to the start of writable
+  /// memory.
+  /// The caller must ensure not to write more then 'size' bytes.
+  ///
+  /// If allocates new buffer and 'exactSize' is true, allocates 'size' bytes.
+  /// Otherwise, allocates at least kInitialStringSize bytes.
+  char* getRawStringBufferWithSpace(size_t /*size*/, bool exactSize = false) {
     return nullptr;
   }
 
@@ -469,7 +509,22 @@ class FlatVector final : public SimpleVector<T> {
     }
   }
 
+  void unsafeSetSize(vector_size_t newSize) {
+    this->length_ = newSize;
+  }
+
+  void unsafeSetValues(BufferPtr values) {
+    values_ = std::move(values);
+    rawValues_ = values_ ? const_cast<T*>(values_->as<T>()) : nullptr;
+  }
+
  private:
+  void ensureValues() {
+    if (rawValues_ == nullptr) {
+      mutableRawValues();
+    }
+  }
+
   void copyValuesAndNulls(
       const BaseVector* source,
       const SelectivityVector& rows,
@@ -482,6 +537,23 @@ class FlatVector final : public SimpleVector<T> {
       vector_size_t newSize,
       const std::optional<T>& initialValue);
 
+  // Check string buffers. Keep at most one singly-referenced buffer if it is
+  // not too large.
+  void keepAtMostOneStringBuffer() {
+    if (stringBuffers_.empty()) {
+      return;
+    }
+
+    auto& firstBuffer = stringBuffers_.front();
+    if (firstBuffer->isMutable() &&
+        firstBuffer->capacity() <= kMaxStringSizeForReuse) {
+      firstBuffer->setSize(0);
+      setStringBuffers({firstBuffer});
+    } else {
+      clearStringBuffers();
+    }
+  }
+
   // Contiguous values.
   // If strings, these are velox::StringViews into memory held by
   // 'stringBuffers_'
@@ -533,10 +605,12 @@ void FlatVector<StringView>::validate(
     const VectorValidateOptions& options) const;
 
 template <>
-Buffer* FlatVector<StringView>::getBufferWithSpace(vector_size_t size);
+Buffer* FlatVector<StringView>::getBufferWithSpace(size_t size, bool exactSize);
 
 template <>
-char* FlatVector<StringView>::getRawStringBufferWithSpace(vector_size_t size);
+char* FlatVector<StringView>::getRawStringBufferWithSpace(
+    size_t size,
+    bool exactSize);
 
 template <>
 void FlatVector<StringView>::prepareForReuse();
@@ -544,13 +618,6 @@ void FlatVector<StringView>::prepareForReuse();
 template <typename T>
 using FlatVectorPtr = std::shared_ptr<FlatVector<T>>;
 
-// Error vector uses an opaque flat vector to store std::exception_ptr.
-// Since opaque types are stored as shared_ptr<void>, this ends up being a
-// double pointer in the form of std::shared_ptr<std::exception_ptr>. This is
-// fine since we only need to actually follow the pointer in failure cases.
-using ErrorVector = FlatVector<std::shared_ptr<void>>;
-using ErrorVectorPtr = std::shared_ptr<ErrorVector>;
-
 } // namespace facebook::velox
 
 #include "velox/vector/FlatVector-inl.h"
diff --git a/velox/vector/FunctionVector.h b/velox/vector/FunctionVector.h
index c7fc6e69c9a4b..422505c9d9e51 100644
--- a/velox/vector/FunctionVector.h
+++ b/velox/vector/FunctionVector.h
@@ -22,6 +22,9 @@ namespace facebook::velox {
 
 namespace exec {
 class EvalCtx;
+class EvalErrors;
+
+using EvalErrorsPtr = std::shared_ptr<EvalErrors>;
 } // namespace exec
 
 // Represents a function with possible captures.
@@ -67,7 +70,7 @@ class Callable {
       const BufferPtr& wrapCapture,
       exec::EvalCtx* context,
       const std::vector<VectorPtr>& args,
-      ErrorVectorPtr& elementErrors,
+      exec::EvalErrorsPtr& elementErrors,
       VectorPtr* result) = 0;
 };
 
@@ -193,6 +196,11 @@ class FunctionVector : public BaseVector {
     VELOX_NYI();
   }
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* /* pool */ = nullptr) const override {
+    VELOX_UNSUPPORTED("copyPreserveEncodings not defined for FunctionVector");
+  }
+
  private:
   std::vector<std::shared_ptr<Callable>> functions_;
   std::vector<SelectivityVector> rowSets_;
diff --git a/velox/vector/LazyVector.cpp b/velox/vector/LazyVector.cpp
index c0b12a15e3956..d0cc09c3d59e1 100644
--- a/velox/vector/LazyVector.cpp
+++ b/velox/vector/LazyVector.cpp
@@ -57,27 +57,9 @@ void VectorLoader::load(
     ValueHook* hook,
     vector_size_t resultSize,
     VectorPtr* result) {
-  {
-    DeltaCpuWallTimer timer([&](auto& delta) { writeIOTiming(delta); });
-    loadInternal(rows, hook, resultSize, result);
-  }
-
-  if (hook) {
-    // Record number of rows loaded directly into ValueHook bypassing
-    // materialization into vector. This counter can be used to understand
-    // whether aggregation pushdown is happening or not.
-    addThreadLocalRuntimeStat("loadedToValueHook", RuntimeCounter(rows.size()));
-  }
-}
-
-void VectorLoader::loadInternal(
-    const SelectivityVector& rows,
-    ValueHook* hook,
-    vector_size_t resultSize,
-    VectorPtr* result) {
   if (rows.isAllSelected()) {
     const auto& indices = DecodedVector::consecutiveIndices();
-    assert(!indices.empty());
+    VELOX_DCHECK(!indices.empty());
     if (rows.end() <= indices.size()) {
       load(
           RowSet(&indices[rows.begin()], rows.end() - rows.begin()),
@@ -87,9 +69,9 @@ void VectorLoader::loadInternal(
       return;
     }
   }
-  std::vector<vector_size_t> positions(rows.countSelected());
-  int index = 0;
-  rows.applyToSelected([&](vector_size_t row) { positions[index++] = row; });
+  raw_vector<vector_size_t> positions(rows.countSelected());
+  simd::indicesOfSetBits(
+      rows.allBits(), rows.begin(), rows.end(), positions.data());
   load(positions, hook, resultSize, result);
 }
 
@@ -271,4 +253,28 @@ void LazyVector::load(RowSet rows, ValueHook* hook) const {
   }
 }
 
+void LazyVector::loadVectorInternal() const {
+  if (!allLoaded_) {
+    if (!vector_) {
+      vector_ = BaseVector::create(type_, 0, pool_);
+    }
+    SelectivityVector allRows(BaseVector::length_);
+    loader_->load(allRows, nullptr, size(), &vector_);
+    VELOX_CHECK_NOT_NULL(vector_);
+    if (vector_->encoding() == VectorEncoding::Simple::LAZY) {
+      vector_ = vector_->asUnchecked<LazyVector>()->loadedVectorShared();
+    } else {
+      // If the load produced a wrapper, load the wrapped vector.
+      vector_->loadedVector();
+    }
+    allLoaded_ = true;
+    const_cast<LazyVector*>(this)->BaseVector::nulls_ = vector_->nulls_;
+    if (BaseVector::nulls_) {
+      const_cast<LazyVector*>(this)->BaseVector::rawNulls_ =
+          BaseVector::nulls_->as<uint64_t>();
+    }
+  } else {
+    VELOX_CHECK_NOT_NULL(vector_);
+  }
+}
 } // namespace facebook::velox
diff --git a/velox/vector/LazyVector.h b/velox/vector/LazyVector.h
index dd373fb85f046..30354af615abe 100644
--- a/velox/vector/LazyVector.h
+++ b/velox/vector/LazyVector.h
@@ -35,12 +35,19 @@ using RowSet = folly::Range<const vector_size_t*>;
 // way one can bypass copying data into a vector before use.
 class ValueHook {
  public:
-  // Type and constants for identifying specific hooks. Loaders may
-  // have hook-specialized template instantiations for some
-  // operations. We do not make a complete enumeration of all hooks in
-  // the base class.
-  using Kind = int32_t;
-  static constexpr Kind kGeneric = 0;
+  // Type and constants for identifying specific hooks.  Loaders may have
+  // hook-specialized template instantiations for some operations.
+  enum Kind {
+    kGeneric,
+    kBigintSum,
+    kBigintSumOverflow,
+    kDoubleSum,
+    kBigintMax,
+    kBigintMin,
+    kFloatingPointMax,
+    kFloatingPointMin,
+  };
+
   static constexpr bool kSkipNulls = true;
 
   virtual ~ValueHook() = default;
@@ -55,18 +62,113 @@ class ValueHook {
 
   virtual void addNull(vector_size_t /*index*/) {}
 
-  virtual void addValue(vector_size_t row, const void* value) = 0;
+  virtual void addValue(vector_size_t /*row*/, int64_t /*value*/) {
+    VELOX_UNSUPPORTED();
+  }
+
+  virtual void addValue(vector_size_t /*row*/, int128_t /*value*/) {
+    VELOX_UNSUPPORTED();
+  }
+
+  virtual void addValue(vector_size_t /*row*/, float /*value*/) {
+    VELOX_UNSUPPORTED();
+  }
+
+  virtual void addValue(vector_size_t /*row*/, double /*value*/) {
+    VELOX_UNSUPPORTED();
+  }
+
+  virtual void addValue(vector_size_t /*row*/, folly::StringPiece /*value*/) {
+    VELOX_UNSUPPORTED();
+  }
+
+  // Fallback implementation of bulk path for addValues.  Actual hooks are
+  // expected to override these if they are not inlined in reader.
+  virtual void
+  addValues(const vector_size_t* rows, const bool* values, vector_size_t size) {
+    for (auto i = 0; i < size; ++i) {
+      addValueTyped(rows[i], values[i]);
+    }
+  }
 
-  // Fallback implementation of bulk path for addValues. Actual
-  // hooks are expected o override tis.
   virtual void addValues(
       const vector_size_t* rows,
-      const void* values,
-      vector_size_t size,
-      uint8_t valueWidth) {
-    auto valuesAsChar = reinterpret_cast<const char*>(values);
+      const int8_t* values,
+      vector_size_t size) {
+    for (auto i = 0; i < size; ++i) {
+      addValueTyped(rows[i], values[i]);
+    }
+  }
+
+  virtual void addValues(
+      const vector_size_t* rows,
+      const int16_t* values,
+      vector_size_t size) {
+    for (auto i = 0; i < size; ++i) {
+      addValueTyped(rows[i], values[i]);
+    }
+  }
+
+  virtual void addValues(
+      const vector_size_t* rows,
+      const int32_t* values,
+      vector_size_t size) {
     for (auto i = 0; i < size; ++i) {
-      addValue(rows[i], valuesAsChar + valueWidth * i);
+      addValueTyped(rows[i], values[i]);
+    }
+  }
+
+  virtual void addValues(
+      const vector_size_t* rows,
+      const int64_t* values,
+      vector_size_t size) {
+    for (auto i = 0; i < size; ++i) {
+      addValue(rows[i], values[i]);
+    }
+  }
+
+  virtual void addValues(
+      const vector_size_t* rows,
+      const int128_t* values,
+      vector_size_t size) {
+    for (auto i = 0; i < size; ++i) {
+      addValue(rows[i], values[i]);
+    }
+  }
+
+  virtual void addValues(
+      const vector_size_t* rows,
+      const float* values,
+      vector_size_t size) {
+    for (auto i = 0; i < size; ++i) {
+      addValue(rows[i], values[i]);
+    }
+  }
+
+  virtual void addValues(
+      const vector_size_t* rows,
+      const double* values,
+      vector_size_t size) {
+    for (auto i = 0; i < size; ++i) {
+      addValue(rows[i], values[i]);
+    }
+  }
+
+  virtual void addValues(
+      const vector_size_t* rows,
+      const StringView* values,
+      vector_size_t size) {
+    for (auto i = 0; i < size; ++i) {
+      addValue(rows[i], values[i]);
+    }
+  }
+
+  template <typename T>
+  void addValueTyped(vector_size_t row, T value) {
+    if constexpr (std::is_integral_v<T> && sizeof(T) < sizeof(int64_t)) {
+      addValue(row, static_cast<int64_t>(value));
+    } else {
+      addValue(row, value);
     }
   }
 };
@@ -105,12 +207,6 @@ class VectorLoader {
       ValueHook* hook,
       vector_size_t resultSize,
       VectorPtr* result) = 0;
-
-  virtual void loadInternal(
-      const SelectivityVector& rows,
-      ValueHook* hook,
-      vector_size_t resultSize,
-      VectorPtr* result);
 };
 
 // Vector class which produces values on first use. This is used for
@@ -148,6 +244,7 @@ class LazyVector : public BaseVector {
     loader_ = std::move(loader);
     allLoaded_ = false;
     containsLazyAndIsWrapped_ = false;
+    resetNulls();
   }
 
   inline bool isLoaded() const {
@@ -188,29 +285,13 @@ class LazyVector : public BaseVector {
   // Returns a shared_ptr to the vector holding the values. If vector is not
   // loaded, loads all the rows, otherwise returns the loaded vector which can
   // have partially loaded rows.
+  VectorPtr& loadedVectorShared() {
+    loadVectorInternal();
+    return vector_;
+  }
+
   const VectorPtr& loadedVectorShared() const {
-    if (!allLoaded_) {
-      if (!vector_) {
-        vector_ = BaseVector::create(type_, 0, pool_);
-      }
-      SelectivityVector allRows(BaseVector::length_);
-      loader_->load(allRows, nullptr, size(), &vector_);
-      VELOX_CHECK(vector_);
-      if (vector_->encoding() == VectorEncoding::Simple::LAZY) {
-        vector_ = vector_->asUnchecked<LazyVector>()->loadedVectorShared();
-      } else {
-        // If the load produced a wrapper, load the wrapped vector.
-        vector_->loadedVector();
-      }
-      allLoaded_ = true;
-      const_cast<LazyVector*>(this)->BaseVector::nulls_ = vector_->nulls_;
-      if (BaseVector::nulls_) {
-        const_cast<LazyVector*>(this)->BaseVector::rawNulls_ =
-            BaseVector::nulls_->as<uint64_t>();
-      }
-    } else {
-      VELOX_CHECK(vector_);
-    }
+    loadVectorInternal();
     return vector_;
   }
 
@@ -280,6 +361,11 @@ class LazyVector : public BaseVector {
 
   void validate(const VectorValidateOptions& options) const override;
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* /* pool */ = nullptr) const override {
+    VELOX_UNSUPPORTED("copyPreserveEncodings not defined for LazyVector");
+  }
+
  private:
   static void ensureLoadedRowsImpl(
       const VectorPtr& vector,
@@ -287,10 +373,12 @@ class LazyVector : public BaseVector {
       const SelectivityVector& rows,
       SelectivityVector& baseRows);
 
+  void loadVectorInternal() const;
+
   std::unique_ptr<VectorLoader> loader_;
 
   // True if all values are loaded.
-  mutable bool allLoaded_ = false;
+  mutable tsan_atomic<bool> allLoaded_{false};
   // Vector to hold loaded values. This may be present before load for
   // reuse. If loading is with ValueHook, this will not be created.
   mutable VectorPtr vector_;
diff --git a/velox/vector/SelectivityVector.cpp b/velox/vector/SelectivityVector.cpp
index d46cc4197f0ac..7967f815c60ae 100644
--- a/velox/vector/SelectivityVector.cpp
+++ b/velox/vector/SelectivityVector.cpp
@@ -54,6 +54,40 @@ std::string SelectivityVector::toString(
   return out.str();
 }
 
+void SelectivityVector::copyNulls(uint64_t* dest, const uint64_t* src) const {
+  if (isAllSelected()) {
+    bits::copyBits(src, 0, dest, 0, size_);
+    return;
+  }
+
+  const auto* rowBits = bits_.data();
+
+  bits::forEachWord(
+      begin_,
+      end_,
+      [dest, src, rowBits](int32_t idx, uint64_t mask) {
+        // Set 'dest' to 0 for selected rows.
+        dest[idx] = (dest[idx] & ~mask) | (mask & dest[idx] & ~rowBits[idx]);
+
+        // Set 'copySrc' to 0 for non-selected rows.
+        uint64_t copySrc =
+            (src[idx] & ~mask) | (mask & src[idx] & rowBits[idx]);
+
+        // Combine 'dest' and 'copySrc' with an OR.
+        dest[idx] = (dest[idx] & ~mask) | (mask & (dest[idx] | copySrc));
+      },
+      [dest, src, rowBits](int32_t idx) {
+        // Set 'dest' to 0 for selected rows.
+        dest[idx] = dest[idx] & ~rowBits[idx];
+
+        // Set 'copySrc' to 0 for non-selected rows.
+        uint64_t copySrc = src[idx] & rowBits[idx];
+
+        // Combine 'dest' and 'copySrc' with an OR.
+        dest[idx] = dest[idx] | copySrc;
+      });
+}
+
 void translateToInnerRows(
     const SelectivityVector& outerRows,
     const vector_size_t* indices,
diff --git a/velox/vector/SelectivityVector.h b/velox/vector/SelectivityVector.h
index f0a890040db01..1fea95247fac0 100644
--- a/velox/vector/SelectivityVector.h
+++ b/velox/vector/SelectivityVector.h
@@ -24,6 +24,7 @@
 #include "velox/buffer/Buffer.h"
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/Macros.h"
 #include "velox/common/base/Range.h"
 #include "velox/vector/TypeAliases.h"
 
@@ -134,6 +135,10 @@ class SelectivityVector {
     return MutableRange<bool>(bits_.data(), begin_, end_);
   }
 
+  const uint64_t* allBits() const {
+    return bits_.data();
+  }
+
   vector_size_t begin() const {
     return begin_;
   }
@@ -156,7 +161,9 @@ class SelectivityVector {
     bits::fillBits(bits_.data(), 0, size_, false);
     begin_ = 0;
     end_ = 0;
+    VELOX_SUPPRESS_STRINGOP_OVERFLOW_WARNING
     allSelected_ = false;
+    VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
   }
 
   /**
@@ -248,6 +255,14 @@ class SelectivityVector {
         nulls->asMutable<uint64_t>(), bits_.data(), begin_, end_);
   }
 
+  void setNulls(uint64_t* rawNulls) const {
+    VELOX_CHECK_NOT_NULL(rawNulls);
+    bits::andWithNegatedBits(rawNulls, bits_.data(), begin_, end_);
+  }
+
+  /// Copy null bits from 'src' to 'dest' for active rows.
+  void copyNulls(uint64_t* dest, const uint64_t* src) const;
+
   /// Merges the valid vector of another SelectivityVector by or'ing
   /// them together. This is used to support memoization where a state
   /// may acquire new values over time. Grows 'this' if size of 'other' exceeds
@@ -279,7 +294,9 @@ class SelectivityVector {
     if (begin_ == -1) {
       begin_ = 0;
       end_ = 0;
+      VELOX_SUPPRESS_STRINGOP_OVERFLOW_WARNING
       allSelected_ = false;
+      VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
       return;
     }
     end_ = bits::findLastBit(bits_.data(), begin_, size_) + 1;
@@ -425,7 +442,8 @@ class SelectivityIterator {
 template <typename Callable>
 inline void SelectivityVector::applyToSelected(Callable func) const {
   if (isAllSelected()) {
-    for (vector_size_t row = begin_; row < end_; ++row) {
+    const auto end = end_;
+    for (vector_size_t row = begin_; row < end; ++row) {
       func(row);
     }
   } else {
diff --git a/velox/vector/SequenceVector-inl.h b/velox/vector/SequenceVector-inl.h
index 2480306d45d69..940ff5c0f9872 100644
--- a/velox/vector/SequenceVector-inl.h
+++ b/velox/vector/SequenceVector-inl.h
@@ -47,7 +47,6 @@ SequenceVector<T>::SequenceVector(
           storageByteCount),
       sequenceValues_(std::move(sequenceValues)),
       sequenceLengths_(std::move(sequenceLengths)) {
-  VELOX_CHECK_GE(length, 0, "Must provide length >= 0");
   VELOX_CHECK(sequenceLengths_ != nullptr, "Sequence Lengths must be not null");
   VELOX_CHECK_EQ(
       sequenceLengths_->size(),
@@ -71,14 +70,12 @@ void SequenceVector<T>::setInternalState() {
 template <typename T>
 bool SequenceVector<T>::isNullAtFast(vector_size_t idx) const {
   size_t offset = offsetOfIndex(idx);
-  DCHECK(offset >= 0) << "Invalid index";
   return sequenceValues_->isNullAt(offset);
 }
 
 template <typename T>
 const T SequenceVector<T>::valueAtFast(vector_size_t idx) const {
   size_t offset = offsetOfIndex(idx);
-  VELOX_DCHECK_GE(offset, 0, "Invalid index");
   return scalarSequenceValues_->valueAt(offset);
 }
 
diff --git a/velox/vector/SequenceVector.h b/velox/vector/SequenceVector.h
index 152567c300934..bed33cf0428ff 100644
--- a/velox/vector/SequenceVector.h
+++ b/velox/vector/SequenceVector.h
@@ -75,7 +75,6 @@ class SequenceVector : public SimpleVector<T> {
       }
 
       size_t offset = offsetOfIndex(idx);
-      VELOX_DCHECK_GE(offset, 0);
       return sequenceValues_->containsNullAt(offset);
     } else {
       return isNullAt(idx);
@@ -126,6 +125,10 @@ class SequenceVector : public SimpleVector<T> {
     return sequenceValues_;
   }
 
+  VectorPtr& valueVector() override {
+    return sequenceValues_;
+  }
+
   BufferPtr getSequenceLengths() const {
     return sequenceLengths_;
   }
@@ -172,6 +175,10 @@ class SequenceVector : public SimpleVector<T> {
     throw std::runtime_error("addNulls not supported");
   }
 
+  void addNulls(const SelectivityVector& rows) override {
+    throw std::runtime_error("addNulls not supported");
+  }
+
   std::string toString(vector_size_t index) const override {
     if (BaseVector::isNullAt(index)) {
       return "null";
@@ -191,6 +198,22 @@ class SequenceVector : public SimpleVector<T> {
     return false;
   }
 
+  VectorPtr copyPreserveEncodings(
+      velox::memory::MemoryPool* pool = nullptr) const override {
+    auto selfPool = pool ? pool : BaseVector::pool_;
+    return std::make_shared<SequenceVector<T>>(
+        selfPool,
+        BaseVector::length_,
+        sequenceValues_->copyPreserveEncodings(),
+        AlignedBuffer::copy(selfPool, sequenceLengths_),
+        SimpleVector<T>::stats_,
+        BaseVector::distinctValueCount_,
+        BaseVector::nullCount_,
+        SimpleVector<T>::isSorted_,
+        BaseVector::representedByteCount_,
+        BaseVector::storageByteCount_);
+  }
+
  private:
   // Prepares for use after construction.
   void setInternalState();
diff --git a/velox/vector/SimpleVector.cpp b/velox/vector/SimpleVector.cpp
new file mode 100644
index 0000000000000..b616c743de276
--- /dev/null
+++ b/velox/vector/SimpleVector.cpp
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/vector/SimpleVector.h"
+
+namespace facebook::velox {
+
+template <>
+void SimpleVector<StringView>::validate(
+    const VectorValidateOptions& options) const {
+  BaseVector::validate(options);
+
+  // We only validate the right size of ascii info, if it has any selection.
+  auto rlockedAsciiComputedRows{asciiInfo.readLockedAsciiComputedRows()};
+  if (rlockedAsciiComputedRows->hasSelections()) {
+    VELOX_CHECK_GE(rlockedAsciiComputedRows->size(), size());
+  }
+}
+
+} // namespace facebook::velox
diff --git a/velox/vector/SimpleVector.h b/velox/vector/SimpleVector.h
index 89416af24af63..da17789c3e6a8 100644
--- a/velox/vector/SimpleVector.h
+++ b/velox/vector/SimpleVector.h
@@ -22,12 +22,14 @@
 
 #include <folly/FixedString.h>
 #include <folly/String.h>
+#include <folly/Synchronized.h>
 #include <folly/container/F14Map.h>
 #include <folly/hash/Hash.h>
 #include <glog/logging.h>
 
 #include "velox/functions/lib/string/StringCore.h"
 #include "velox/type/DecimalUtil.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/TypeAliases.h"
@@ -46,44 +48,57 @@ struct SimpleVectorStats {
 };
 
 struct AsciiInfo {
-  bool& isAllAscii() {
-    return *isAllAscii_;
+  /// Returns true if ascii was processed for all rows and false otherwise.
+  bool isAllAscii() const {
+    return isAllAscii_;
   }
 
-  SelectivityVector& asciiSetRows() {
-    return *asciiSetRows_;
+  /// Sets isAllAscii boolean flag.
+  void setIsAllAscii(bool f) {
+    isAllAscii_ = f;
   }
 
-  const bool& isAllAscii() const {
-    return *isAllAscii_;
+  /// Returns locked for read bit vector with bits set for rows where ascii was
+  /// processed.
+  auto readLockedAsciiComputedRows() const {
+    return asciiComputedRows_.rlock();
   }
 
-  const SelectivityVector& asciiSetRows() const {
-    return *asciiSetRows_;
+  /// Returns locked for write bit vector with bits set for rows where ascii was
+  /// processed.
+  auto writeLockedAsciiComputedRows() {
+    return asciiComputedRows_.wlock();
   }
 
-  // isAllAscii_ and asciiSetRows_ are thread local because input vectors can be
-  // shared across threads, hence this make their mutation thread safe.
-  // Those are the only two fields that are allowed to mutated in the expression
-  // eval inputs vectors.
+  /// Returns upgradable locked bit vector with bits set for rows where ascii
+  /// was processed.
+  auto upgradableLockedAsciiComputedRows() {
+    return asciiComputedRows_.ulock();
+  }
+
+ private:
+  // isAllAscii_ and asciiComputedRows_ are thread-safe because input vectors
+  // can be shared across threads, hence this make their mutation thread safe.
+  // Those are the only two fields that are allowed to be mutated in the
+  // expression eval inputs vectors.
 
-  // True is all strings in asciiSetRows_ are ASCII.
-  folly::ThreadLocal<bool> isAllAscii_{[] { return new bool(false); }};
+  // True is all strings in asciiComputedRows_ are ASCII.
+  std::atomic_bool isAllAscii_{false};
 
-  // If T is StringView, store set of rows
-  // where we have computed asciiness. A set bit means the row was processed.
-  folly::ThreadLocal<SelectivityVector> asciiSetRows_;
+  // If T is StringView, store set of rows where we have computed asciiness.
+  // A set bit means the row was processed.
+  folly::Synchronized<SelectivityVector> asciiComputedRows_;
 };
 
-// This class abstracts over various Columnar Storage Formats such that Velox
-// can select the most appropriate one on a per field / per block basis.
-// The goal is to use the most appropriate type to optimize for:
-//   - Lazy deserialization if desired.
-//   - serialization / rehydration cost, ideally we use a smart view into the
-//     data without fully rehydrating.
-//   - serialized bytes
-//   - cpu cost of filtering
-//   - optimize aggregation of sequential values
+/// This class abstracts over various Columnar Storage Formats such that Velox
+/// can select the most appropriate one on a per field / per block basis.
+/// The goal is to use the most appropriate type to optimize for:
+///   - Lazy deserialization if desired.
+///   - serialization / rehydration cost, ideally we use a smart view into the
+///     data without fully rehydrating.
+///   - serialized bytes
+///   - cpu cost of filtering
+///   - optimize aggregation of sequential values
 template <typename T>
 class SimpleVector : public BaseVector {
  public:
@@ -149,12 +164,22 @@ class SimpleVector : public BaseVector {
     return {flags.ascending ? result : result * -1};
   }
 
+  void validate(const VectorValidateOptions& options) const override {
+    BaseVector::validate(options);
+  }
+
   /**
    * @return the hash of the value at the given index in this vector
    */
   uint64_t hashValueAt(vector_size_t index) const override {
-    return isNullAt(index) ? BaseVector::kNullHash
-                           : folly::hasher<T>{}(valueAt(index));
+    if constexpr (std::is_floating_point_v<T>) {
+      return isNullAt(index)
+          ? BaseVector::kNullHash
+          : util::floating_point::NaNAwareHash<T>{}(valueAt(index));
+    } else {
+      return isNullAt(index) ? BaseVector::kNullHash
+                             : folly::hasher<T>{}(valueAt(index));
+    }
   }
 
   std::optional<bool> isSorted() const {
@@ -221,15 +246,16 @@ class SimpleVector : public BaseVector {
   isAscii(
       const SelectivityVector& rows,
       const vector_size_t* rowMappings = nullptr) const {
-    VELOX_CHECK(rows.hasSelections())
-    if (asciiInfo.asciiSetRows().hasSelections()) {
+    VELOX_CHECK(rows.hasSelections());
+    auto rlockedAsciiComputedRows{asciiInfo.readLockedAsciiComputedRows()};
+    if (rlockedAsciiComputedRows->hasSelections()) {
       if (rowMappings) {
         bool isSubset = rows.template testSelected([&](auto row) {
-          return asciiInfo.asciiSetRows().isValid(rowMappings[row]);
+          return rlockedAsciiComputedRows->isValid(rowMappings[row]);
         });
         return isSubset ? std::optional(asciiInfo.isAllAscii()) : std::nullopt;
       }
-      if (rows.isSubset(asciiInfo.asciiSetRows())) {
+      if (rows.isSubset(*rlockedAsciiComputedRows)) {
         return asciiInfo.isAllAscii();
       }
     }
@@ -243,9 +269,10 @@ class SimpleVector : public BaseVector {
   template <typename U = T>
   typename std::enable_if_t<std::is_same_v<U, StringView>, std::optional<bool>>
   isAscii(vector_size_t index) const {
-    VELOX_CHECK_GE(index, 0)
-    if (asciiInfo.asciiSetRows().size() > index &&
-        asciiInfo.asciiSetRows().isValid(index)) {
+    VELOX_CHECK_GE(index, 0);
+    auto rlockedAsciiComputedRows{asciiInfo.readLockedAsciiComputedRows()};
+    if (index < rlockedAsciiComputedRows->size() &&
+        rlockedAsciiComputedRows->isValid(index)) {
       return asciiInfo.isAllAscii();
     }
     return std::nullopt;
@@ -256,10 +283,10 @@ class SimpleVector : public BaseVector {
   template <typename U = T>
   typename std::enable_if_t<std::is_same_v<U, StringView>, bool>
   computeAndSetIsAscii(const SelectivityVector& rows) {
-    if (rows.isSubset(asciiInfo.asciiSetRows())) {
+    if (rows.isSubset(*asciiInfo.readLockedAsciiComputedRows())) {
       return asciiInfo.isAllAscii();
     }
-    ensureIsAsciiCapacity(rows.end());
+    ensureIsAsciiCapacity();
     bool isAllAscii = true;
     rows.template applyToSelected([&](auto row) {
       if (!isNullAt(row)) {
@@ -270,13 +297,14 @@ class SimpleVector : public BaseVector {
     });
 
     // Set isAllAscii flag, it will unset if we encounter any utf.
-    if (!asciiInfo.asciiSetRows().hasSelections()) {
-      asciiInfo.isAllAscii() = isAllAscii;
+    auto wlockedAsciiComputedRows = asciiInfo.writeLockedAsciiComputedRows();
+    if (!wlockedAsciiComputedRows->hasSelections()) {
+      asciiInfo.setIsAllAscii(isAllAscii);
     } else {
-      asciiInfo.isAllAscii() &= isAllAscii;
+      asciiInfo.setIsAllAscii(asciiInfo.isAllAscii() & isAllAscii);
     }
 
-    asciiInfo.asciiSetRows().select(rows);
+    wlockedAsciiComputedRows->select(rows);
     return asciiInfo.isAllAscii();
   }
 
@@ -284,8 +312,8 @@ class SimpleVector : public BaseVector {
   template <typename U = T>
   typename std::enable_if_t<std::is_same_v<U, StringView>, void>
   invalidateIsAscii() {
-    asciiInfo.asciiSetRows().clearAll();
-    asciiInfo.isAllAscii() = false;
+    asciiInfo.writeLockedAsciiComputedRows()->clearAll();
+    asciiInfo.setIsAllAscii(false);
   }
 
   /// Explicitly set asciness.
@@ -293,31 +321,78 @@ class SimpleVector : public BaseVector {
   typename std::enable_if_t<std::is_same_v<U, StringView>, void> setIsAscii(
       bool ascii,
       const SelectivityVector& rows) {
-    ensureIsAsciiCapacity(rows.end());
-    if (asciiInfo.asciiSetRows().hasSelections() &&
-        !asciiInfo.asciiSetRows().isSubset(rows)) {
-      asciiInfo.isAllAscii() &= ascii;
+    ensureIsAsciiCapacity();
+    auto wlockedAsciiComputedRows = asciiInfo.writeLockedAsciiComputedRows();
+    if (wlockedAsciiComputedRows->hasSelections() &&
+        !wlockedAsciiComputedRows->isSubset(rows)) {
+      asciiInfo.setIsAllAscii(asciiInfo.isAllAscii() & ascii);
     } else {
-      asciiInfo.isAllAscii() = ascii;
+      asciiInfo.setIsAllAscii(ascii);
     }
 
-    asciiInfo.asciiSetRows().select(rows);
+    wlockedAsciiComputedRows->select(rows);
   }
 
   template <typename U = T>
   typename std::enable_if_t<std::is_same_v<U, StringView>, void> setAllIsAscii(
       bool ascii) {
-    ensureIsAsciiCapacity(length_);
-    asciiInfo.isAllAscii() = ascii;
-    asciiInfo.asciiSetRows().setAll();
+    ensureIsAsciiCapacity();
+    asciiInfo.setIsAllAscii(ascii);
+    asciiInfo.writeLockedAsciiComputedRows()->setAll();
+  }
+
+  template <typename U = T>
+  typename std::enable_if_t<std::is_same_v<U, StringView>, bool> getAllIsAscii()
+      const {
+    return asciiInfo.isAllAscii();
+  }
+
+  /// Provides const access to asciiInfo. Used for tests only.
+  template <typename U = T>
+  typename std::enable_if_t<std::is_same_v<U, StringView>, const AsciiInfo&>
+  testGetAsciiInfo() const {
+    return asciiInfo;
+  }
+
+  FOLLY_ALWAYS_INLINE static int comparePrimitiveAsc(
+      const T& left,
+      const T& right) {
+    if constexpr (std::is_floating_point<T>::value) {
+      bool isLeftNan = std::isnan(left);
+      bool isRightNan = std::isnan(right);
+      if (isLeftNan) {
+        return isRightNan ? 0 : 1;
+      }
+      if (isRightNan) {
+        return -1;
+      }
+    }
+    return left < right ? -1 : left == right ? 0 : 1;
   }
 
  protected:
   template <typename U = T>
   typename std::enable_if_t<std::is_same_v<U, StringView>, void>
-  ensureIsAsciiCapacity(vector_size_t size) {
-    if (asciiInfo.asciiSetRows().size() < size) {
-      asciiInfo.asciiSetRows().resize(size, false);
+  ensureIsAsciiCapacity() {
+    auto ulockedAsciiComputedRows{
+        asciiInfo.upgradableLockedAsciiComputedRows()};
+    if (ulockedAsciiComputedRows->size() < length_) {
+      ulockedAsciiComputedRows.moveFromUpgradeToWrite()->resize(length_, false);
+    }
+  }
+
+  /// Ensure asciiInfo is of the correct size. But only if it is not empty.
+  template <typename U = T>
+  typename std::enable_if_t<std::is_same_v<U, StringView>, void>
+  resizeIsAsciiIfNotEmpty(vector_size_t size, bool newAscii) {
+    auto ulockedAsciiComputedRows{
+        asciiInfo.upgradableLockedAsciiComputedRows()};
+    if (ulockedAsciiComputedRows->hasSelections()) {
+      if (ulockedAsciiComputedRows->size() < size) {
+        ulockedAsciiComputedRows.moveFromUpgradeToWrite()->resize(
+            size, newAscii);
+        asciiInfo.setIsAllAscii(asciiInfo.isAllAscii() & newAscii);
+      }
     }
   }
 
@@ -347,21 +422,6 @@ class SimpleVector : public BaseVector {
         sizeof(T));
   }
 
- protected:
-  int comparePrimitiveAsc(const T& left, const T& right) const {
-    if constexpr (std::is_floating_point<T>::value) {
-      bool isLeftNan = std::isnan(left);
-      bool isRightNan = std::isnan(right);
-      if (isLeftNan) {
-        return isRightNan ? 0 : 1;
-      }
-      if (isRightNan) {
-        return -1;
-      }
-    }
-    return left < right ? -1 : left == right ? 0 : 1;
-  }
-
   virtual void resetDataDependentFlags(const SelectivityVector* rows) override {
     BaseVector::resetDataDependentFlags(rows);
     isSorted_ = std::nullopt;
@@ -369,11 +429,9 @@ class SimpleVector : public BaseVector {
 
     if constexpr (std::is_same_v<T, StringView>) {
       if (rows) {
-        asciiInfo.asciiSetRows().deselect(*rows);
-
+        asciiInfo.writeLockedAsciiComputedRows()->deselect(*rows);
       } else {
-        asciiInfo.asciiSetRows().clearAll();
-        asciiInfo.isAllAscii() = false;
+        invalidateIsAscii();
       }
     }
   }
@@ -387,7 +445,11 @@ class SimpleVector : public BaseVector {
 
   std::conditional_t<std::is_same_v<T, StringView>, AsciiInfo, int> asciiInfo;
   SimpleVectorStats<T> stats_;
-}; // namespace velox
+};
+
+template <>
+void SimpleVector<StringView>::validate(
+    const VectorValidateOptions& options) const;
 
 template <>
 inline std::optional<int32_t> SimpleVector<ComplexType>::compare(
diff --git a/velox/vector/VectorMap.cpp b/velox/vector/VectorMap.cpp
new file mode 100644
index 0000000000000..f93957c967dc5
--- /dev/null
+++ b/velox/vector/VectorMap.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/vector/VectorMap.h"
+#include "velox/vector/FlatVector.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox {
+
+VectorMap::VectorMap(BaseVector& alphabet)
+    : alphabet_(&alphabet),
+      isString_(
+          alphabet_->typeKind() == TypeKind::VARCHAR ||
+          alphabet_->typeKind() == TypeKind::VARBINARY),
+      fixedWidth_(
+          alphabet_->type()->isFixedWidth()
+              ? alphabet_->type()->cppSizeInBytes()
+              : kVariableWidth) {
+  auto size = alphabet_->size();
+  // We reserve the size. The assumption is that we run this on an alphabet of a
+  // dictionary vector in preparation for adding elements, so the values are
+  // expected to be distinct.
+  if (isString_) {
+    distinctStrings_.reserve(size);
+  } else {
+    distinctSet_.reserve(size);
+  }
+  for (auto i = 0; i < size; ++i) {
+    addOne(*alphabet_, i, false);
+  }
+}
+
+VectorMap::VectorMap(
+    const TypePtr& type,
+    memory::MemoryPool* pool,
+    int32_t reserve)
+    : isString_(
+          type->kind() == TypeKind::VARCHAR ||
+          type->kind() == TypeKind::VARBINARY),
+      fixedWidth_(
+          type->isFixedWidth() ? type->cppSizeInBytes() : kVariableWidth) {
+  alphabetOwned_ = BaseVector::create(type, 0, pool);
+  alphabet_ = alphabetOwned_.get();
+  if (isString_) {
+    distinctStrings_.reserve(reserve);
+  } else {
+    distinctSet_.reserve(reserve);
+  }
+}
+
+vector_size_t VectorMap::addOne(
+    const BaseVector& topVector,
+    vector_size_t topIndex,
+    bool insertToAlphabet) {
+  const BaseVector* vector = &topVector;
+  vector_size_t index = topIndex;
+  if (topVector.encoding() != VectorEncoding::Simple::FLAT) {
+    vector = topVector.wrappedVector();
+    index = topVector.wrappedIndex(topIndex);
+  }
+  if (LIKELY(isString_)) {
+    StringView string;
+    bool isNull = vector->isNullAt(index);
+    if (UNLIKELY(isNull)) {
+      if (nullIndex_ != kNoNullIndex) {
+        return nullIndex_;
+      }
+    } else {
+      if (LIKELY(vector->encoding() == VectorEncoding::Simple::FLAT)) {
+        string = vector->asUnchecked<FlatVector<StringView>>()->valueAt(index);
+      } else {
+        string = vector->asUnchecked<ConstantVector<StringView>>()->valueAt(0);
+      }
+      auto it = distinctStrings_.find(string);
+      if (it != distinctStrings_.end()) {
+        return it->second;
+      }
+    }
+  } else {
+    auto it = distinctSet_.find(VectorValueSetEntry{vector, index});
+    if (it != distinctSet_.end()) {
+      return it->index;
+    }
+  }
+  int32_t newIndex;
+  if (insertToAlphabet) {
+    VELOX_CHECK(alphabet_ == alphabetOwned_.get());
+    newIndex = alphabet_->size();
+    alphabet_->resize(newIndex + 1);
+    alphabetSizes_.resize(newIndex + 1);
+    alphabet_->copy(vector, newIndex, index, 1);
+  } else {
+    newIndex = topIndex;
+    if (alphabetSizes_.size() < newIndex + 1) {
+      alphabetSizes_.resize(newIndex + 1);
+    }
+  }
+  const bool isNull = vector->isNullAt(index);
+  if (isNull) {
+    alphabetSizes_[newIndex] = 0;
+    nullIndex_ = newIndex;
+  } else if (isString_) {
+    // Add 4 for length.
+    alphabetSizes_[newIndex] = alphabet_->asUnchecked<FlatVector<StringView>>()
+                                   ->valueAt(newIndex)
+                                   .size() +
+        4;
+  } else if (fixedWidth_ == kVariableWidth) {
+    Scratch scratch;
+    ScratchPtr<vector_size_t, 1> indicesHolder(scratch);
+    ScratchPtr<vector_size_t*, 1> sizesHolder(scratch);
+    auto sizeIndices = indicesHolder.get(1);
+    sizeIndices[0] = newIndex;
+    auto sizes = sizesHolder.get(1);
+    alphabetSizes_[newIndex] = 0;
+    sizes[0] = &alphabetSizes_[newIndex];
+    getVectorSerde()->estimateSerializedSize(
+        alphabet_,
+        folly::Range<const vector_size_t*>(sizeIndices, 1),
+        sizes,
+        scratch);
+  }
+  if (isString_) {
+    if (!isNull) {
+      distinctStrings_[alphabet_->asUnchecked<FlatVector<StringView>>()
+                           ->valueAt(newIndex)] = newIndex;
+    }
+  } else {
+    distinctSet_.insert(VectorValueSetEntry{alphabet_, newIndex});
+  }
+  return newIndex;
+}
+
+void VectorMap::addMultiple(
+    BaseVector& vector,
+    folly::Range<const vector_size_t*> rows,
+    bool insertToAlphabet,
+    vector_size_t* ids) {
+  auto size = rows.size();
+  for (auto i = 0; i < size; ++i) {
+    ids[i] = addOne(vector, rows[i], insertToAlphabet);
+  }
+}
+
+} // namespace facebook::velox
diff --git a/velox/vector/VectorMap.h b/velox/vector/VectorMap.h
new file mode 100644
index 0000000000000..bdefd9c1bae0b
--- /dev/null
+++ b/velox/vector/VectorMap.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/container/F14Set.h>
+#include "velox/common/base/RawVector.h"
+#include "velox/vector/BaseVector.h"
+
+namespace facebook::velox {
+
+struct VectorValueSetEntry {
+  const BaseVector* vector;
+  vector_size_t index;
+};
+
+struct VectorValueSetHasher {
+  size_t operator()(const VectorValueSetEntry& entry) const {
+    return entry.vector->hashValueAt(entry.index);
+  }
+};
+
+struct VectorValueSetComparer {
+  bool operator()(
+      const VectorValueSetEntry& left,
+      const VectorValueSetEntry& right) const {
+    return left.vector->equalValueAt(right.vector, left.index, right.index);
+  }
+};
+
+using VectorValueSet = folly::F14FastSet<
+    VectorValueSetEntry,
+    VectorValueSetHasher,
+    VectorValueSetComparer>;
+
+/// A map translating values in a vector to positions in an alphabet
+/// vector. if the values are complex type or variable length, also
+/// keeps track of the serialized size of the values. Usable for
+/// ad-hoc reencoding for serialization.
+class VectorMap {
+ public:
+  // Constructs 'this' to index the distinct elements in 'alphabet'. 'alphabet'
+  // is not changed and not owned. For example, when concatenating two
+  // dictionaries, the first initializes the map.
+  explicit VectorMap(BaseVector& alphabet);
+
+  // Constructs an empty map initializing alphabet to an empty vector of 'type'.
+  // Alphabet is owned. 'reserve' is the expected count of distinct values.
+  VectorMap(
+      const TypePtr& type,
+      memory::MemoryPool* pool,
+      int32_t reserve = 32);
+
+  /// Assigns a zero-based id to each distinct value in 'vector' at positions
+  /// 'rows'. The ids are returned in 'ids'. If insertToAlphabet is true and the
+  /// value is not previously in alphabet_, the value is added to it. Alphabet
+  /// must be owned if insertToAlphabet is true.
+  void addMultiple(
+      BaseVector& vector,
+      folly::Range<const vector_size_t*> rows,
+      bool insertToAlphabet,
+      vector_size_t* ids);
+
+  // Gets/assigns s an id to single value. The meaning of parameters is as in
+  // addMultiple().
+  vector_size_t addOne(
+      const BaseVector& vector,
+      vector_size_t row,
+      bool insertToAlphabet = true);
+
+  /// Returns the number of distinct values in 'this'.
+  vector_size_t size() const {
+    return isString_ ? distinctStrings_.size() + (nullIndex_ != kNoNullIndex)
+                     : distinctSet_.size();
+  }
+
+  /// Returns the approximate serialized binary length of the 'index'th value in
+  /// 'alphabet_'. The type must be a variable length type.
+  vector_size_t lengthAt(vector_size_t index) const {
+    VELOX_DCHECK_EQ(fixedWidth_, kVariableWidth);
+    return alphabetSizes_[index];
+  }
+
+  const VectorPtr& alphabetOwned() const {
+    return alphabetOwned_;
+  }
+
+ private:
+  static constexpr vector_size_t kNoNullIndex = -1;
+  static constexpr int32_t kVariableWidth = -1;
+
+  // Vector containing all the distinct values.
+  BaseVector* alphabet_;
+
+  // Optional owning pointer to 'alphabet_'.
+  VectorPtr alphabetOwned_;
+
+  // Map from value in 'alphabet_' to the index in 'alphabet_'.
+  VectorValueSet distinctSet_;
+
+  // Map from string value in 'alphabet_' to index in 'alphabet_'. Used only if
+  // 'alphabet_' is a FlatVector<StringView>.
+  folly::F14FastMap<StringView, int32_t> distinctStrings_;
+
+  // Index of null value in 'alphabet_'.
+  vector_size_t nullIndex_{kNoNullIndex};
+
+  // Serialized size estimate for the corresponding element of 'alphabet'.
+  raw_vector<vector_size_t> alphabetSizes_;
+
+  // True if  using 'distinctStrings_'
+  const bool isString_;
+
+  const int32_t fixedWidth_;
+};
+
+} // namespace facebook::velox
diff --git a/velox/vector/VectorSaver.cpp b/velox/vector/VectorSaver.cpp
index 16e2d04f9b131..e419d0586f124 100644
--- a/velox/vector/VectorSaver.cpp
+++ b/velox/vector/VectorSaver.cpp
@@ -416,7 +416,9 @@ void writeRowVector(const BaseVector& vector, std::ostream& out) {
   // Nulls buffer.
   writeOptionalBuffer(vector.nulls(), out);
 
-  auto rowVector = vector.as<RowVector>();
+  const auto* rowVector = vector.as<RowVector>();
+  VELOX_CHECK_NOT_NULL(
+      rowVector, "Expected a RowVector, got: {}", vector.toString());
 
   // Child vectors.
   auto numChildren = rowVector->childrenSize();
@@ -626,17 +628,13 @@ void saveVector(const BaseVector& vector, std::ostream& out) {
   }
 }
 
-void saveVectorToFile(
-    const BaseVector* FOLLY_NONNULL vector,
-    const char* FOLLY_NONNULL filePath) {
+void saveVectorToFile(const BaseVector* vector, const char* filePath) {
   std::ofstream outputFile(filePath, std::ofstream::binary);
   saveVector(*vector, outputFile);
   outputFile.close();
 }
 
-void saveStringToFile(
-    const std::string& content,
-    const char* FOLLY_NONNULL filePath) {
+void saveStringToFile(const std::string& content, const char* filePath) {
   std::ofstream outputFile(filePath, std::ofstream::binary);
   outputFile.write(content.data(), content.size());
   outputFile.close();
@@ -674,8 +672,8 @@ VectorPtr restoreVector(std::istream& in, memory::MemoryPool* pool) {
 }
 
 VectorPtr restoreVectorFromFile(
-    const char* FOLLY_NONNULL filePath,
-    memory::MemoryPool* FOLLY_NONNULL pool) {
+    const char* filePath,
+    memory::MemoryPool* pool) {
   std::ifstream inputFile(filePath, std::ifstream::binary);
   VELOX_CHECK(!inputFile.fail(), "Cannot open file: {}", filePath);
 
@@ -684,7 +682,7 @@ VectorPtr restoreVectorFromFile(
   return result;
 }
 
-std::string restoreStringFromFile(const char* FOLLY_NONNULL filePath) {
+std::string restoreStringFromFile(const char* filePath) {
   std::ifstream inputFile(filePath, std::ifstream::binary);
   VELOX_CHECK(!inputFile.fail(), "Cannot open file: {}", filePath);
 
@@ -777,3 +775,10 @@ SelectivityVector restoreSelectivityVector(std::istream& in) {
 }
 
 } // namespace facebook::velox
+
+template <>
+struct fmt::formatter<facebook::velox::Encoding> : formatter<int> {
+  auto format(facebook::velox::Encoding s, format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/vector/VectorSaver.h b/velox/vector/VectorSaver.h
index b4b3c2adbd922..39a25c374cbee 100644
--- a/velox/vector/VectorSaver.h
+++ b/velox/vector/VectorSaver.h
@@ -37,40 +37,30 @@ void saveVector(const BaseVector& vector, std::ostream& out);
 /// Serializes the vector into binary format and writes it to a new file in
 /// 'filePath'. The serialization preserved encoding. Exceptions will be thrown
 /// if any error occurs while writing.
-void saveVectorToFile(
-    const BaseVector* FOLLY_NONNULL vector,
-    const char* FOLLY_NONNULL filePath);
+void saveVectorToFile(const BaseVector* vector, const char* filePath);
 
 /// Writes 'content' to a new file in 'filePath'. Exceptions will be thrown if
 /// any error occurs while writing.
-void saveStringToFile(
-    const std::string& content,
-    const char* FOLLY_NONNULL filePath);
+void saveStringToFile(const std::string& content, const char* filePath);
 
 /// Deserializes a vector serialized by 'save' from the provided input stream.
-VectorPtr restoreVector(
-    std::istream& in,
-    memory::MemoryPool* FOLLY_NONNULL pool);
+VectorPtr restoreVector(std::istream& in, memory::MemoryPool* pool);
 
 /// Reads and deserializes a vector from a file stored by saveVectorToFile()
 /// method call
-VectorPtr restoreVectorFromFile(
-    const char* FOLLY_NONNULL filePath,
-    memory::MemoryPool* FOLLY_NONNULL pool);
+VectorPtr restoreVectorFromFile(const char* filePath, memory::MemoryPool* pool);
 
 /// Reads a string from a file stored by saveStringToFile() method
-std::string restoreStringFromFile(const char* FOLLY_NONNULL filePath);
+std::string restoreStringFromFile(const char* filePath);
 
 // Write the vector to a file. Contents would include the size of the list
 // followed by all the values.
 template <typename T>
-void saveStdVectorToFile(
-    const std::vector<T>& list,
-    const char* FOLLY_NONNULL filePath);
+void saveStdVectorToFile(const std::vector<T>& list, const char* filePath);
 
 // Reads a std::vector from a file stored by saveStdVectorToFile() method.
 template <typename T>
-std::vector<T> restoreStdVectorFromFile(const char* FOLLY_NONNULL filePath);
+std::vector<T> restoreStdVectorFromFile(const char* filePath);
 
 /// Serializes a SelectivityVector into binary format and writes it to the
 /// provided output stream.
diff --git a/velox/vector/VectorStream.cpp b/velox/vector/VectorStream.cpp
index e88324ebf9258..18bdb103f357f 100644
--- a/velox/vector/VectorStream.cpp
+++ b/velox/vector/VectorStream.cpp
@@ -15,15 +15,51 @@
  */
 #include "velox/vector/VectorStream.h"
 #include <memory>
+#include "velox/common/base/RawVector.h"
 
 namespace facebook::velox {
+namespace {
+// An adapter class that can be used to convert a VectorSerializer into a
+// BatchVectorSerializer for VectorSerdes that don't want to implement a
+// separate serializer.
+class DefaultBatchVectorSerializer : public BatchVectorSerializer {
+ public:
+  DefaultBatchVectorSerializer(
+      memory::MemoryPool* pool,
+      VectorSerde* serde,
+      const VectorSerde::Options* options)
+      : pool_(pool), serde_(serde), options_(options) {}
 
-void VectorSerializer::append(const RowVectorPtr& vector) {
-  const IndexRange allRows{0, vector->size()};
-  append(vector, folly::Range(&allRows, 1));
-}
+  void serialize(
+      const RowVectorPtr& vector,
+      const folly::Range<const IndexRange*>& ranges,
+      Scratch& scratch,
+      OutputStream* stream) override {
+    size_t numRows = 0;
+    for (const auto& range : ranges) {
+      numRows += range.size;
+    }
 
-namespace {
+    StreamArena arena(pool_);
+    auto serializer = serde_->createIterativeSerializer(
+        asRowType(vector->type()), numRows, &arena, options_);
+    serializer->append(vector, ranges, scratch);
+    serializer->flush(stream);
+  }
+
+  void estimateSerializedSize(
+      VectorPtr vector,
+      const folly::Range<const IndexRange*>& ranges,
+      vector_size_t** sizes,
+      Scratch& scratch) override {
+    serde_->estimateSerializedSize(vector.get(), ranges, sizes, scratch);
+  }
+
+ private:
+  memory::MemoryPool* const pool_;
+  VectorSerde* const serde_;
+  const VectorSerde::Options* const options_;
+};
 
 std::unique_ptr<VectorSerde>& getVectorSerdeImpl() {
   static std::unique_ptr<VectorSerde> serde;
@@ -39,6 +75,25 @@ getNamedVectorSerdeImpl() {
 
 } // namespace
 
+void IterativeVectorSerializer::append(const RowVectorPtr& vector) {
+  const IndexRange allRows{0, vector->size()};
+  Scratch scratch;
+  append(vector, folly::Range(&allRows, 1), scratch);
+}
+
+void BatchVectorSerializer::serialize(
+    const RowVectorPtr& vector,
+    OutputStream* stream) {
+  const IndexRange allRows{0, vector->size()};
+  serialize(vector, folly::Range(&allRows, 1), stream);
+}
+
+std::unique_ptr<BatchVectorSerializer> VectorSerde::createBatchSerializer(
+    memory::MemoryPool* pool,
+    const Options* options) {
+  return std::make_unique<DefaultBatchVectorSerializer>(pool, this, options);
+}
+
 VectorSerde* getVectorSerde() {
   auto serde = getVectorSerdeImpl().get();
   VELOX_CHECK_NOT_NULL(serde, "Vector serde is not registered.");
@@ -97,13 +152,21 @@ void VectorStreamGroup::createStreamTree(
     RowTypePtr type,
     int32_t numRows,
     const VectorSerde::Options* options) {
-  serializer_ = serde_->createSerializer(type, numRows, this, options);
+  serializer_ = serde_->createIterativeSerializer(type, numRows, this, options);
 }
 
 void VectorStreamGroup::append(
     const RowVectorPtr& vector,
-    const folly::Range<const IndexRange*>& ranges) {
-  serializer_->append(vector, ranges);
+    const folly::Range<const IndexRange*>& ranges,
+    Scratch& scratch) {
+  serializer_->append(vector, ranges, scratch);
+}
+
+void VectorStreamGroup::append(
+    const RowVectorPtr& vector,
+    const folly::Range<const vector_size_t*>& rows,
+    Scratch& scratch) {
+  serializer_->append(vector, rows, scratch);
 }
 
 void VectorStreamGroup::append(const RowVectorPtr& vector) {
@@ -116,15 +179,25 @@ void VectorStreamGroup::flush(OutputStream* out) {
 
 // static
 void VectorStreamGroup::estimateSerializedSize(
-    VectorPtr vector,
+    const BaseVector* vector,
     const folly::Range<const IndexRange*>& ranges,
-    vector_size_t** sizes) {
-  getVectorSerde()->estimateSerializedSize(vector, ranges, sizes);
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  getVectorSerde()->estimateSerializedSize(vector, ranges, sizes, scratch);
+}
+
+// static
+void VectorStreamGroup::estimateSerializedSize(
+    const BaseVector* vector,
+    folly::Range<const vector_size_t*> rows,
+    vector_size_t** sizes,
+    Scratch& scratch) {
+  getVectorSerde()->estimateSerializedSize(vector, rows, sizes, scratch);
 }
 
 // static
 void VectorStreamGroup::read(
-    ByteStream* source,
+    ByteInputStream* source,
     velox::memory::MemoryPool* pool,
     RowTypePtr type,
     RowVectorPtr* result,
@@ -148,7 +221,8 @@ folly::IOBuf rowVectorToIOBuf(
   streamGroup->createStreamTree(asRowType(rowVector->type()), rangeEnd);
 
   IndexRange range{0, rangeEnd};
-  streamGroup->append(rowVector, folly::Range<IndexRange*>(&range, 1));
+  Scratch scratch;
+  streamGroup->append(rowVector, folly::Range<IndexRange*>(&range, 1), scratch);
 
   IOBufOutputStream stream(pool);
   streamGroup->flush(&stream);
@@ -168,15 +242,15 @@ RowVectorPtr IOBufToRowVector(
         const_cast<uint8_t*>(range.data()), (int32_t)range.size(), 0});
   }
 
-  ByteStream byteStream;
-  byteStream.resetInput(std::move(ranges));
+  auto byteStream = std::make_unique<BufferInputStream>(std::move(ranges));
   RowVectorPtr outputVector;
 
   // If not supplied, use the default one.
   if (serde == nullptr) {
     serde = getVectorSerde();
   }
-  serde->deserialize(&byteStream, &pool, outputType, &outputVector, nullptr);
+  serde->deserialize(
+      byteStream.get(), &pool, outputType, &outputVector, nullptr);
   return outputVector;
 }
 
diff --git a/velox/vector/VectorStream.h b/velox/vector/VectorStream.h
index 6b44dfbb7258f..b8304bdc2e280 100644
--- a/velox/vector/VectorStream.h
+++ b/velox/vector/VectorStream.h
@@ -15,7 +15,11 @@
  */
 #pragma once
 
+#include <folly/Range.h>
 #include "velox/buffer/Buffer.h"
+#include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/base/Scratch.h"
+#include "velox/common/compression/Compression.h"
 #include "velox/common/memory/ByteStream.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/common/memory/MemoryAllocator.h"
@@ -31,18 +35,44 @@ struct IndexRange {
   vector_size_t size;
 };
 
-class VectorSerializer {
+/// Serializer that can iteratively build up a buffer of serialized rows from
+/// one or more RowVectors.
+///
+/// Uses successive calls to `append` to add more rows to the serialization
+/// buffer.  Then call `flush` to write the aggregate serialized data to an
+/// OutputStream.
+class IterativeVectorSerializer {
  public:
-  virtual ~VectorSerializer() = default;
+  virtual ~IterativeVectorSerializer() = default;
 
   /// Serialize a subset of rows in a vector.
   virtual void append(
       const RowVectorPtr& vector,
-      const folly::Range<const IndexRange*>& ranges) = 0;
+      const folly::Range<const IndexRange*>& ranges,
+      Scratch& scratch) = 0;
+
+  virtual void append(
+      const RowVectorPtr& vector,
+      const folly::Range<const IndexRange*>& ranges) {
+    Scratch scratch;
+    append(vector, ranges, scratch);
+  }
+
+  virtual void append(
+      const RowVectorPtr& vector,
+      const folly::Range<const vector_size_t*>& rows,
+      Scratch& scratch) {
+    VELOX_UNSUPPORTED();
+  }
 
   /// Serialize all rows in a vector.
   void append(const RowVectorPtr& vector);
 
+  // True if supports append with folly::Range<vector_size_t*>.
+  virtual bool supportsAppendRows() const {
+    return false;
+  }
+
   /// Returns the maximum serialized size of the data previously added via
   /// 'append' methods. Can be used to allocate buffer of exact or maximum size
   /// before calling 'flush'.
@@ -58,6 +88,51 @@ class VectorSerializer {
 
   /// Write serialized data to 'stream'.
   virtual void flush(OutputStream* stream) = 0;
+
+  /// Resets 'this' to post construction state.
+  virtual void clear() {
+    VELOX_UNSUPPORTED("clear");
+  }
+
+  /// Returns serializer-dependent counters, e.g. about compression, data
+  /// distribution, encoding etc.
+  virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() {
+    return {};
+  }
+};
+
+/// Serializer that writes a subset of rows from a single RowVector to the
+/// OutputStream.
+///
+/// Each serialize() call serializes the specified range(s) of `vector` and
+/// write them to the output stream.
+class BatchVectorSerializer {
+ public:
+  virtual ~BatchVectorSerializer() = default;
+
+  /// Serializes a subset of rows in a vector.
+  virtual void serialize(
+      const RowVectorPtr& vector,
+      const folly::Range<const IndexRange*>& ranges,
+      Scratch& scratch,
+      OutputStream* stream) = 0;
+
+  virtual void serialize(
+      const RowVectorPtr& vector,
+      const folly::Range<const IndexRange*>& ranges,
+      OutputStream* stream) {
+    Scratch scratch;
+    serialize(vector, ranges, scratch, stream);
+  }
+
+  virtual void estimateSerializedSize(
+      VectorPtr vector,
+      const folly::Range<const IndexRange*>& ranges,
+      vector_size_t** sizes,
+      Scratch& scratch) = 0;
+
+  /// Serializes all rows in a vector.
+  void serialize(const RowVectorPtr& vector, OutputStream* stream);
 };
 
 class VectorSerde {
@@ -67,26 +142,97 @@ class VectorSerde {
   // Lets the caller pass options to the Serde. This can be extended to add
   // custom options by each of its extended classes.
   struct Options {
-    virtual ~Options() {}
+    Options() = default;
+
+    explicit Options(common::CompressionKind _compressionKind)
+        : compressionKind(_compressionKind) {}
+
+    virtual ~Options() = default;
+
+    common::CompressionKind compressionKind{
+        common::CompressionKind::CompressionKind_NONE};
   };
 
+  /// Adds the serialized size of vector at 'rows[i]' to '*sizes[i]'.
   virtual void estimateSerializedSize(
-      VectorPtr vector,
+      const BaseVector* /*vector*/,
+      folly::Range<const vector_size_t*> rows,
+      vector_size_t** sizes,
+      Scratch& scratch) {
+    VELOX_UNSUPPORTED();
+  }
+
+  /// Adds the serialized sizes of the rows of 'vector' in 'ranges[i]' to
+  /// '*sizes[i]'.
+  virtual void estimateSerializedSize(
+      const BaseVector* /*vector*/,
       const folly::Range<const IndexRange*>& ranges,
-      vector_size_t** sizes) = 0;
+      vector_size_t** sizes,
+      Scratch& scratch) {
+    VELOX_UNSUPPORTED();
+  }
 
-  virtual std::unique_ptr<VectorSerializer> createSerializer(
+  virtual void estimateSerializedSize(
+      const BaseVector* vector,
+      const folly::Range<const IndexRange*>& ranges,
+      vector_size_t** sizes) {
+    Scratch scratch;
+    estimateSerializedSize(vector, ranges, sizes, scratch);
+  }
+
+  /// Creates a Vector Serializer that iteratively builds up a buffer of
+  /// serialized rows from one or more RowVectors via append, and then writes to
+  /// an OutputSteam via flush.
+  ///
+  /// This is more appropriate if the use case involves many small writes, e.g.
+  /// partitioning a RowVector across multiple destinations.
+  virtual std::unique_ptr<IterativeVectorSerializer> createIterativeSerializer(
       RowTypePtr type,
       int32_t numRows,
       StreamArena* streamArena,
       const Options* options = nullptr) = 0;
 
+  /// Creates a Vector Serializer that writes a subset of rows from a single
+  /// RowVector to the OutputStream via a single serialize API.
+  ///
+  /// This is more appropriate if the use case involves large writes, e.g.
+  /// sending an entire RowVector to a particular destination.
+  virtual std::unique_ptr<BatchVectorSerializer> createBatchSerializer(
+      memory::MemoryPool* pool,
+      const Options* options = nullptr);
+
   virtual void deserialize(
-      ByteStream* source,
+      ByteInputStream* source,
       velox::memory::MemoryPool* pool,
       RowTypePtr type,
       RowVectorPtr* result,
       const Options* options = nullptr) = 0;
+
+  /// Returns true if implements 'deserialize' API with 'resultOffset' to allow
+  /// for appending deserialized data to an existing vector.
+  virtual bool supportsAppendInDeserialize() const {
+    return false;
+  }
+
+  /// Deserializes data from 'source' and appends to 'result' vector starting at
+  /// 'resultOffset'.
+  /// @param result Result vector to append new data to. Can be null only if
+  /// 'resultOffset' is zero.
+  /// @param resultOffset Must be greater than or equal to zero. If > 0, must be
+  /// less than or equal to the size of 'result'.
+  virtual void deserialize(
+      ByteInputStream* source,
+      velox::memory::MemoryPool* pool,
+      RowTypePtr type,
+      RowVectorPtr* result,
+      vector_size_t resultOffset,
+      const Options* options = nullptr) {
+    if (resultOffset == 0) {
+      deserialize(source, pool, type, result, options);
+      return;
+    }
+    VELOX_UNSUPPORTED();
+  }
 };
 
 /// Register/deregister the "default" vector serde.
@@ -117,7 +263,7 @@ class VectorStreamGroup : public StreamArena {
  public:
   /// If `serde` is not specified, fallback to the default registered.
   explicit VectorStreamGroup(
-      memory::MemoryPool* FOLLY_NONNULL pool,
+      memory::MemoryPool* pool,
       VectorSerde* serde = nullptr)
       : StreamArena(pool),
         serde_(serde != nullptr ? serde : getVectorSerde()) {}
@@ -127,14 +273,43 @@ class VectorStreamGroup : public StreamArena {
       int32_t numRows,
       const VectorSerde::Options* options = nullptr);
 
+  /// Increments sizes[i] for each ith row in 'rows' in 'vector'.
   static void estimateSerializedSize(
-      VectorPtr vector,
+      const BaseVector* vector,
+      folly::Range<const vector_size_t*> rows,
+      vector_size_t** sizes,
+      Scratch& scratch);
+
+  static void estimateSerializedSize(
+      const BaseVector* vector,
+      const folly::Range<const IndexRange*>& ranges,
+      vector_size_t** sizes,
+      Scratch& scratch);
+
+  static inline void estimateSerializedSize(
+      const BaseVector* vector,
       const folly::Range<const IndexRange*>& ranges,
-      vector_size_t** sizes);
+      vector_size_t** sizes) {
+    Scratch scratch;
+    estimateSerializedSize(vector, ranges, sizes, scratch);
+  }
 
   void append(
       const RowVectorPtr& vector,
-      const folly::Range<const IndexRange*>& ranges);
+      const folly::Range<const IndexRange*>& ranges,
+      Scratch& scratch);
+
+  void append(
+      const RowVectorPtr& vector,
+      const folly::Range<const IndexRange*>& ranges) {
+    Scratch scratch;
+    append(vector, ranges, scratch);
+  }
+
+  void append(
+      const RowVectorPtr& vector,
+      const folly::Range<const vector_size_t*>& rows,
+      Scratch& scratch);
 
   void append(const RowVectorPtr& vector);
 
@@ -143,14 +318,28 @@ class VectorStreamGroup : public StreamArena {
 
   // Reads data in wire format. Returns the RowVector in 'result'.
   static void read(
-      ByteStream* source,
+      ByteInputStream* source,
       velox::memory::MemoryPool* pool,
       RowTypePtr type,
       RowVectorPtr* result,
       const VectorSerde::Options* options = nullptr);
 
+  void clear() override {
+    StreamArena::clear();
+    serializer_->clear();
+  }
+
+  /// Returns serializer-dependent counters, e.g. about compression, data
+  /// distribution, encoding etc.
+  std::unordered_map<std::string, RuntimeCounter> runtimeStats() {
+    if (!serializer_) {
+      return {};
+    }
+    return serializer_->runtimeStats();
+  }
+
  private:
-  std::unique_ptr<VectorSerializer> serializer_;
+  std::unique_ptr<IterativeVectorSerializer> serializer_;
   VectorSerde* serde_{nullptr};
 };
 
diff --git a/velox/vector/arrow/Abi.h b/velox/vector/arrow/Abi.h
index 86b72419f7475..16c48a544dc95 100644
--- a/velox/vector/arrow/Abi.h
+++ b/velox/vector/arrow/Abi.h
@@ -25,9 +25,11 @@
 extern "C" {
 #endif
 
-// Add a definition check here to avoid duplication with the definition
-// included from velox/external/duckdb/duckdb.hpp.
-#ifndef ARROW_FLAG_DICTIONARY_ORDERED
+// These macros prevent re-definition in case multiple headers try to define
+// them.
+#ifndef ARROW_C_DATA_INTERFACE
+#define ARROW_C_DATA_INTERFACE
+
 #define ARROW_FLAG_DICTIONARY_ORDERED 1
 #define ARROW_FLAG_NULLABLE 2
 #define ARROW_FLAG_MAP_KEYS_SORTED 4
@@ -65,8 +67,13 @@ struct ArrowArray {
   void* private_data;
 };
 
+#endif // ARROW_C_DATA_INTERFACE
+
 // EXPERIMENTAL: C stream interface
 
+#ifndef ARROW_C_STREAM_INTERFACE
+#define ARROW_C_STREAM_INTERFACE
+
 struct ArrowArrayStream {
   // Callback to get the stream type
   // (will be the same for all arrays in the stream).
@@ -105,7 +112,7 @@ struct ArrowArrayStream {
   void* private_data;
 };
 
-#endif
+#endif // ARROW_C_STREAM_INTERFACE
 
 #ifdef __cplusplus
 }
diff --git a/velox/vector/arrow/Bridge.cpp b/velox/vector/arrow/Bridge.cpp
index 9fb09e2f92a6c..d4bf16bf3afcb 100644
--- a/velox/vector/arrow/Bridge.cpp
+++ b/velox/vector/arrow/Bridge.cpp
@@ -21,7 +21,9 @@
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/vector/ComplexVector.h"
+#include "velox/vector/DictionaryVector.h"
 #include "velox/vector/FlatVector.h"
+#include "velox/vector/VectorTypeUtils.h"
 #include "velox/vector/arrow/Abi.h"
 
 namespace facebook::velox {
@@ -36,10 +38,20 @@ static constexpr size_t kMaxBuffers{3};
 // carried by ArrowArray.private_data
 class VeloxToArrowBridgeHolder {
  public:
-  VeloxToArrowBridgeHolder() {
-    for (size_t i = 0; i < kMaxBuffers; ++i) {
+  VeloxToArrowBridgeHolder() = default;
+
+  // Call to this method may require a call to `getArrowBuffers()` in order to
+  // re-acquire the underlying buffer
+  void resizeBuffers(size_t bufferCount) {
+    if (bufferCount <= numBuffers_) {
+      return;
+    }
+    buffers_.resize(bufferCount);
+    bufferPtrs_.resize(bufferCount);
+    for (size_t i = numBuffers_; i < bufferCount; i++) {
       buffers_[i] = nullptr;
     }
+    numBuffers_ = bufferCount;
   }
 
   // Acquires a buffer at index `idx`.
@@ -56,7 +68,7 @@ class VeloxToArrowBridgeHolder {
   }
 
   const void** getArrowBuffers() {
-    return buffers_;
+    return (const void**)&(buffers_[0]);
   }
 
   // Allocates space for `numChildren` ArrowArray pointers.
@@ -86,12 +98,15 @@ class VeloxToArrowBridgeHolder {
   }
 
  private:
+  // Holds the count of total buffers
+  size_t numBuffers_ = kMaxBuffers;
+
   // Holds the pointers to the arrow buffers.
-  const void* buffers_[kMaxBuffers];
+  std::vector<const void*> buffers_{numBuffers_, nullptr};
 
   // Holds ownership over the Buffers being referenced by the buffers vector
   // above.
-  BufferPtr bufferPtrs_[kMaxBuffers];
+  std::vector<BufferPtr> bufferPtrs_{numBuffers_};
 
   // Auxiliary buffers to hold ownership over ArrowArray children structures.
   std::vector<std::unique_ptr<ArrowArray>> childrenPtrs_;
@@ -122,21 +137,26 @@ struct VeloxToArrowSchemaBridgeHolder {
 
   std::unique_ptr<ArrowSchema> dictionary;
 
-  // Buffer required to generate a decimal format.
+  // Buffer required to generate a decimal format or timestamp with timezone
+  // format.
   std::string formatBuffer;
-};
 
-void setUniqueChild(
-    std::unique_ptr<ArrowSchema>&& child,
-    VeloxToArrowSchemaBridgeHolder& holder,
-    ArrowSchema& schema) {
-  holder.childrenOwned.resize(1);
-  holder.childrenRaw.resize(1);
-  holder.childrenOwned[0] = std::move(child);
-  schema.children = holder.childrenRaw.data();
-  schema.n_children = 1;
-  schema.children[0] = holder.childrenOwned[0].get();
-}
+  void setChildAtIndex(
+      size_t index,
+      std::unique_ptr<ArrowSchema>&& child,
+      ArrowSchema& schema) {
+    if (index >= childrenOwned.size()) {
+      childrenOwned.resize(index + 1);
+    }
+    if (index >= childrenRaw.size()) {
+      childrenRaw.resize(index + 1);
+    }
+    childrenOwned[index] = std::move(child);
+    schema.children = childrenRaw.data();
+    schema.n_children = childrenOwned.size();
+    schema.children[index] = childrenOwned[index].get();
+  }
+};
 
 // Release function for ArrowArray. Arrow standard requires it to recurse down
 // to children and dictionary arrays, and set release and private_data to null
@@ -206,9 +226,37 @@ static void releaseArrowSchema(ArrowSchema* arrowSchema) {
   arrowSchema->private_data = nullptr;
 }
 
+const char* exportArrowFormatTimestampStr(
+    const ArrowOptions& options,
+    std::string& formatBuffer) {
+  switch (options.timestampUnit) {
+    case TimestampUnit::kSecond:
+      formatBuffer = "tss:";
+      break;
+    case TimestampUnit::kMilli:
+      formatBuffer = "tsm:";
+      break;
+    case TimestampUnit::kMicro:
+      formatBuffer = "tsu:";
+      break;
+    case TimestampUnit::kNano:
+      formatBuffer = "tsn:";
+      break;
+    default:
+      VELOX_UNREACHABLE();
+  }
+
+  if (options.timestampTimeZone.has_value()) {
+    formatBuffer += options.timestampTimeZone.value();
+  }
+
+  return formatBuffer.c_str();
+}
+
 // Returns the Arrow C data interface format type for a given Velox type.
 const char* exportArrowFormatStr(
     const TypePtr& type,
+    const ArrowOptions& options,
     std::string& formatBuffer) {
   if (type->isDecimal()) {
     // Decimal types encode the precision, scale values.
@@ -229,6 +277,9 @@ const char* exportArrowFormatStr(
       if (type->isDate()) {
         return "tdD";
       }
+      if (type->isIntervalYearMonth()) {
+        return "tiM";
+      }
       return "i"; // int32
     case TypeKind::BIGINT:
       return "l"; // int64
@@ -239,14 +290,19 @@ const char* exportArrowFormatStr(
     // We always map VARCHAR and VARBINARY to the "small" version (lower case
     // format string), which uses 32 bit offsets.
     case TypeKind::VARCHAR:
+      if (options.exportToStringView) {
+        return "vu";
+      }
       return "u"; // utf-8 string
     case TypeKind::VARBINARY:
+      if (options.exportToStringView) {
+        return "vz";
+      }
       return "z"; // binary
-
+    case TypeKind::UNKNOWN:
+      return "n"; // NullType
     case TypeKind::TIMESTAMP:
-      // TODO: need to figure out how we'll map this since in Velox we currently
-      // store timestamps as two int64s (epoch in sec and nanos).
-      return "ttn"; // time64 [nanoseconds]
+      return exportArrowFormatTimestampStr(options, formatBuffer);
     // Complex/nested types.
     case TypeKind::ARRAY:
       static_assert(sizeof(vector_size_t) == 4);
@@ -261,6 +317,21 @@ const char* exportArrowFormatStr(
   }
 }
 
+std::unique_ptr<ArrowSchema> newArrowSchema(
+    const char* format = nullptr,
+    const char* name = nullptr) {
+  auto arrowSchema = std::make_unique<ArrowSchema>();
+  arrowSchema->format = format;
+  arrowSchema->name = name;
+  arrowSchema->metadata = nullptr;
+  arrowSchema->flags = 0;
+  arrowSchema->n_children = 0;
+  arrowSchema->children = nullptr;
+  arrowSchema->dictionary = nullptr;
+  arrowSchema->release = releaseArrowSchema;
+  return arrowSchema;
+}
+
 // A filter representation that can also keep the order.
 struct Selection {
   explicit Selection(vector_size_t total) : total_(total) {}
@@ -310,14 +381,82 @@ struct Selection {
   vector_size_t total_;
 };
 
+// Gather values from timestamp buffer. Nulls are skipped.
+void gatherFromTimestampBuffer(
+    const BaseVector& vec,
+    const Selection& rows,
+    TimestampUnit unit,
+    Buffer& out) {
+  auto src = (*vec.values()).as<Timestamp>();
+  auto dst = out.asMutable<int64_t>();
+  vector_size_t j = 0; // index into dst
+  if (!vec.mayHaveNulls() || vec.getNullCount() == 0) {
+    switch (unit) {
+      case TimestampUnit::kSecond:
+        rows.apply([&](vector_size_t i) { dst[j++] = src[i].getSeconds(); });
+        break;
+      case TimestampUnit::kMilli:
+        rows.apply([&](vector_size_t i) { dst[j++] = src[i].toMillis(); });
+        break;
+      case TimestampUnit::kMicro:
+        rows.apply([&](vector_size_t i) { dst[j++] = src[i].toMicros(); });
+        break;
+      case TimestampUnit::kNano:
+        rows.apply([&](vector_size_t i) { dst[j++] = src[i].toNanos(); });
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+    return;
+  }
+  switch (unit) {
+    case TimestampUnit::kSecond:
+      rows.apply([&](vector_size_t i) {
+        if (!vec.isNullAt(i)) {
+          dst[j] = src[i].getSeconds();
+        }
+        j++;
+      });
+      break;
+    case TimestampUnit::kMilli:
+      rows.apply([&](vector_size_t i) {
+        if (!vec.isNullAt(i)) {
+          dst[j] = src[i].toMillis();
+        }
+        j++;
+      });
+      break;
+    case TimestampUnit::kMicro:
+      rows.apply([&](vector_size_t i) {
+        if (!vec.isNullAt(i)) {
+          dst[j] = src[i].toMicros();
+        };
+        j++;
+      });
+      break;
+    case TimestampUnit::kNano:
+      rows.apply([&](vector_size_t i) {
+        if (!vec.isNullAt(i)) {
+          dst[j] = src[i].toNanos();
+        }
+        j++;
+      });
+      break;
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
 void gatherFromBuffer(
     const Type& type,
     const Buffer& buf,
     const Selection& rows,
+    const ArrowOptions& options,
     Buffer& out) {
   auto src = buf.as<uint8_t>();
   auto dst = out.asMutable<uint8_t>();
   vector_size_t j = 0; // index into dst
+
   if (type.kind() == TypeKind::BOOLEAN) {
     rows.apply([&](vector_size_t i) {
       bits::setBit(dst, j++, bits::isBitSet(src, i));
@@ -335,9 +474,175 @@ void gatherFromBuffer(
   }
 }
 
-void exportNulls(
+// Optionally, holds shared_ptrs pointing to the ArrowArray object that
+// holds the buffer and the ArrowSchema object that describes the ArrowArray,
+// which will be released to signal that we will no longer hold on to the data
+// and the shared_ptr deleters should run the release procedures if no one
+// else is referencing the objects.
+struct BufferViewReleaser {
+  BufferViewReleaser() : BufferViewReleaser(nullptr, nullptr) {}
+  BufferViewReleaser(
+      std::shared_ptr<ArrowSchema> arrowSchema,
+      std::shared_ptr<ArrowArray> arrowArray)
+      : schemaReleaser_(std::move(arrowSchema)),
+        arrayReleaser_(std::move(arrowArray)) {}
+
+  void addRef() const {}
+  void release() const {}
+
+ private:
+  const std::shared_ptr<ArrowSchema> schemaReleaser_;
+  const std::shared_ptr<ArrowArray> arrayReleaser_;
+};
+
+// Wraps a naked pointer using a Velox buffer view, without copying it. Adding a
+// dummy releaser as the buffer lifetime is fully controlled by the client of
+// the API.
+BufferPtr wrapInBufferViewAsViewer(const void* buffer, size_t length) {
+  static const BufferViewReleaser kViewerReleaser;
+  return BufferView<BufferViewReleaser>::create(
+      static_cast<const uint8_t*>(buffer), length, kViewerReleaser);
+}
+
+// Wraps a naked pointer using a Velox buffer view, without copying it. This
+// buffer view uses shared_ptr to manage reference counting and releasing for
+// the ArrowSchema object and the ArrowArray object.
+BufferPtr wrapInBufferViewAsOwner(
+    const void* buffer,
+    size_t length,
+    std::shared_ptr<ArrowSchema> schemaReleaser,
+    std::shared_ptr<ArrowArray> arrayReleaser) {
+  return BufferView<BufferViewReleaser>::create(
+      static_cast<const uint8_t*>(buffer),
+      length,
+      {std::move(schemaReleaser), std::move(arrayReleaser)});
+}
+
+std::optional<int64_t> optionalNullCount(int64_t value) {
+  return value == -1 ? std::nullopt : std::optional<int64_t>(value);
+}
+
+// Dispatch based on the type.
+template <TypeKind kind>
+VectorPtr createFlatVector(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    BufferPtr nulls,
+    size_t length,
+    BufferPtr values,
+    int64_t nullCount) {
+  using T = typename TypeTraits<kind>::NativeType;
+  return std::make_shared<FlatVector<T>>(
+      pool,
+      type,
+      nulls,
+      length,
+      values,
+      std::vector<BufferPtr>(),
+      SimpleVectorStats<T>{},
+      std::nullopt,
+      optionalNullCount(nullCount));
+}
+
+using WrapInBufferViewFunc =
+    std::function<BufferPtr(const void* buffer, size_t length)>;
+
+VectorPtr createStringFlatVectorFromUtf8View(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    BufferPtr nulls,
+    const ArrowArray& arrowArray,
+    WrapInBufferViewFunc wrapInBufferView) {
+  int64_t num_buffers = arrowArray.n_buffers;
+  VELOX_USER_CHECK_GE(
+      num_buffers,
+      3,
+      "Expecting three or more buffers as input for string view types.");
+
+  // The last C data buffer stores buffer sizes
+  auto* bufferSizes = (uint64_t*)arrowArray.buffers[num_buffers - 1];
+  std::vector<BufferPtr> stringViewBuffers(num_buffers - 3);
+
+  // Skipping buffer_id = 0 (nulls buffer) and buffer_id = 1 (values buffer)
+  for (int32_t buffer_id = 2; buffer_id < num_buffers - 1; ++buffer_id) {
+    stringViewBuffers[buffer_id - 2] = wrapInBufferView(
+        arrowArray.buffers[buffer_id], bufferSizes[buffer_id - 2]);
+  }
+
+  BufferPtr stringViews =
+      AlignedBuffer::allocate<StringView>(arrowArray.length, pool);
+  auto* rawStringViews = stringViews->asMutable<uint64_t>();
+  auto* rawNulls = nulls->as<uint64_t>();
+
+  // Full copy for inline strings (length <= 12). For non-inline strings,
+  // convert 16-byte Arrow Utf8View [4-byte length, 4-byte prefix, 4-byte
+  // buffer-index, 4-byte buffer-offset] to 16-byte Velox StringView [4-byte
+  // length, 4-byte prefix, 8-byte buffer-ptr]
+  for (int32_t idx_64 = 0; idx_64 < arrowArray.length; ++idx_64) {
+    auto* view = (uint32_t*)(&((uint64_t*)arrowArray.buffers[1])[2 * idx_64]);
+    rawStringViews[2 * idx_64] = *(uint64_t*)view;
+    if (view[0] > 12)
+      rawStringViews[2 * idx_64 + 1] =
+          (uint64_t)arrowArray.buffers[2 + view[2]] + view[3];
+    else
+      rawStringViews[2 * idx_64 + 1] = *(uint64_t*)&view[2];
+  }
+
+  return std::make_shared<FlatVector<StringView>>(
+      pool,
+      type,
+      nulls,
+      arrowArray.length,
+      std::move(stringViews),
+      std::move(stringViewBuffers),
+      SimpleVectorStats<StringView>{},
+      std::nullopt,
+      optionalNullCount(arrowArray.null_count));
+}
+
+template <typename TOffset>
+VectorPtr createStringFlatVector(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    BufferPtr nulls,
+    size_t length,
+    const TOffset* offsets,
+    const char* values,
+    int64_t nullCount,
+    WrapInBufferViewFunc wrapInBufferView) {
+  BufferPtr stringViews = AlignedBuffer::allocate<StringView>(length, pool);
+  auto rawStringViews = stringViews->asMutable<StringView>();
+  bool shouldAcquireStringBuffer = false;
+
+  for (size_t i = 0; i < length; ++i) {
+    rawStringViews[i] =
+        StringView(values + offsets[i], offsets[i + 1] - offsets[i]);
+    shouldAcquireStringBuffer |= !rawStringViews[i].isInline();
+  }
+
+  std::vector<BufferPtr> stringViewBuffers;
+  if (shouldAcquireStringBuffer) {
+    stringViewBuffers.emplace_back(wrapInBufferView(values, offsets[length]));
+  }
+
+  return std::make_shared<FlatVector<StringView>>(
+      pool,
+      type,
+      nulls,
+      length,
+      stringViews,
+      std::move(stringViewBuffers),
+      SimpleVectorStats<StringView>{},
+      std::nullopt,
+      optionalNullCount(nullCount));
+}
+
+// This functions does two things: (a) sets the value of null_count, and (b)
+// the validity buffer (if there is at least one null row).
+void exportValidityBitmap(
     const BaseVector& vec,
     const Selection& rows,
+    const ArrowOptions& options,
     ArrowArray& out,
     memory::MemoryPool* pool,
     VeloxToArrowBridgeHolder& holder) {
@@ -345,40 +650,164 @@ void exportNulls(
     out.null_count = 0;
     return;
   }
-  if (!rows.changed()) {
-    holder.setBuffer(0, vec.nulls());
-    out.null_count = vec.getNullCount().value_or(-1);
-    return;
+
+  auto nulls = vec.nulls();
+
+  // If we're only exporting a subset, create a new validity buffer.
+  if (rows.changed()) {
+    nulls = AlignedBuffer::allocate<bool>(out.length, pool);
+    gatherFromBuffer(*BOOLEAN(), *vec.nulls(), rows, options, *nulls);
+  }
+
+  // Set null counts.
+  if (!rows.changed() && (vec.getNullCount() != std::nullopt)) {
+    out.null_count = *vec.getNullCount();
+  } else {
+    out.null_count = BaseVector::countNulls(nulls, rows.count());
+  }
+
+  if (out.null_count > 0) {
+    holder.setBuffer(0, nulls);
+  }
+}
+
+bool isFlatScalarZeroCopy(const TypePtr& type) {
+  // - Short decimals need to be converted to 128 bit values as they are
+  // mapped to Arrow Decimal128.
+  // - Velox's Timestamp representation (2x 64bit values) does not have an
+  // equivalent in Arrow.
+  return !type->isShortDecimal() && !type->isTimestamp();
+}
+
+// Returns the size of a single element of a given `type` in the target arrow
+// buffer.
+size_t getArrowElementSize(const TypePtr& type) {
+  if (type->isShortDecimal()) {
+    return sizeof(int128_t);
+  } else if (type->isTimestamp()) {
+    return sizeof(int64_t);
+  } else {
+    return type->cppSizeInBytes();
   }
-  auto nulls = AlignedBuffer::allocate<bool>(out.length, pool);
-  gatherFromBuffer(*BOOLEAN(), *vec.nulls(), rows, *nulls);
-  holder.setBuffer(0, nulls);
-  out.null_count = -1;
 }
 
 void exportValues(
     const BaseVector& vec,
     const Selection& rows,
+    const ArrowOptions& options,
     ArrowArray& out,
     memory::MemoryPool* pool,
     VeloxToArrowBridgeHolder& holder) {
+  const auto& type = vec.type();
   out.n_buffers = 2;
-  // Short decimals need to be converted to 128 bit values as they are mapped
-  // to Arrow Decimal128.
-  if (!rows.changed() && !vec.type()->isShortDecimal()) {
+
+  if (!rows.changed() && isFlatScalarZeroCopy(type)) {
     holder.setBuffer(1, vec.values());
     return;
   }
-  auto size = vec.type()->isShortDecimal() ? sizeof(int128_t)
-                                           : vec.type()->cppSizeInBytes();
-  auto values = vec.type()->isBoolean()
+
+  // Otherwise we will need a new buffer and copy the data.
+  auto size = getArrowElementSize(type);
+  auto values = type->isBoolean()
       ? AlignedBuffer::allocate<bool>(out.length, pool)
       : AlignedBuffer::allocate<uint8_t>(
             checkedMultiply<size_t>(out.length, size), pool);
-  gatherFromBuffer(*vec.type(), *vec.values(), rows, *values);
+  if (type->kind() == TypeKind::TIMESTAMP) {
+    gatherFromTimestampBuffer(vec, rows, options.timestampUnit, *values);
+  } else {
+    gatherFromBuffer(*type, *vec.values(), rows, options, *values);
+  }
   holder.setBuffer(1, values);
 }
 
+void exportViews(
+    const FlatVector<StringView>& vec,
+    const Selection& rows,
+    ArrowArray& out,
+    memory::MemoryPool* pool,
+    VeloxToArrowBridgeHolder& holder) {
+  auto stringBuffers = vec.stringBuffers();
+  size_t numStringBuffers = stringBuffers.size();
+  // Buffers for nulls, values, variadic_buffer_sizes, and all stringBuffers.
+  size_t numBuffers = 3 + numStringBuffers;
+
+  // Resize and reassign holder buffers.
+  holder.resizeBuffers(numBuffers);
+  out.buffers = holder.getArrowBuffers();
+
+  // Given the difference b/w structures of the non-inline Arrow Utf8View and
+  // Velox::StringView as
+  //
+  // Velox: [4-byte len, 4-byte prefix, 8-byte pointer]
+  // Arrow: [4-byte len, 4-byte prefix, 4-byte buffer_idx, 4-byte buffer_offset]
+  //
+  // Velox::StringView only has a pointer to the buffer but Arrow requires the
+  // exact index to the string buffer for that value the offset from the start
+  // of this buffer. Hence, we must obtain this buffer's index and offset from
+  // stringBuffers_. This is done in two parts:
+  // 1. Create a vector to store stringBuffer indices and sort this vector by
+  //    lowest to highest buffer pointer address to prepare for binary search.
+  // 2. Find the correct string buffer with binary search using the velox
+  //    buffer-pointer as key on the sorted vector of buffer indices.
+  //    We optimize further by caching the previous buffer's address and index
+  //    and only search again if the key pointer does not lie within the cached
+  //    buffer.
+
+  // Vector to store stringBuffer indices.
+  std::vector<int32_t> stringBufferVec(numStringBuffers);
+
+  BufferPtr variadicBufferSizes =
+      AlignedBuffer::allocate<size_t>(numStringBuffers, pool);
+  auto rawVariadicBufferSizes = variadicBufferSizes->asMutable<uint64_t>();
+  for (int32_t idx = 0; idx < numStringBuffers; ++idx) {
+    rawVariadicBufferSizes[idx] = stringBuffers[idx]->size();
+    holder.setBuffer(2 + idx, stringBuffers[idx]);
+    // 1a. Insert index into the vector.
+    stringBufferVec[idx] = idx;
+  }
+  holder.setBuffer(numBuffers - 1, variadicBufferSizes);
+  out.n_buffers = numBuffers;
+
+  // 1b. Sorting cache for fast binary search of [4-byte buffer-idx, 4-byte
+  // buffer-offset] from stringBufferVec with key [8-byte buffer-ptr].
+  std::stable_sort(
+      stringBufferVec.begin(),
+      stringBufferVec.end(),
+      [&out](const auto& lhs, const auto& rhs) {
+        return ((uint64_t*)&out.buffers[2])[lhs] <
+            ((uint64_t*)&out.buffers[2])[rhs];
+      });
+
+  auto utf8Views = (uint64_t*)out.buffers[1];
+  int32_t bufferIdxCache = 0;
+  uint64_t bufferAddrCache = 0;
+
+  rows.apply([&](vector_size_t i) {
+    auto view = (uint32_t*)&utf8Views[2 * i];
+    if (!vec.isNullAt(i) && view[0] > 12) {
+      uint64_t currAddr = *(uint64_t*)&view[2];
+      // 2. Search for correct index with the buffer-pointer as key. Cache the
+      // found buffer's address and index in bufferAddrCache and bufferIdxCache
+      // respectively
+      if (i == 0 ||
+          (currAddr - bufferAddrCache) >
+              rawVariadicBufferSizes[bufferIdxCache]) {
+        auto it = std::prev(std::upper_bound(
+            stringBufferVec.begin(),
+            stringBufferVec.end(),
+            currAddr,
+            [&out](const auto& lhs, const auto& rhs) {
+              return lhs < ((uint64_t*)&out.buffers[2])[rhs];
+            }));
+        bufferAddrCache = ((uint64_t*)&out.buffers[2])[*it];
+        bufferIdxCache = *it;
+      }
+      view[2] = bufferIdxCache;
+      view[3] = currAddr - bufferAddrCache;
+    }
+  });
+}
+
 void exportStrings(
     const FlatVector<StringView>& vec,
     const Selection& rows,
@@ -415,6 +844,7 @@ void exportStrings(
 void exportFlat(
     const BaseVector& vec,
     const Selection& rows,
+    const ArrowOptions& options,
     ArrowArray& out,
     memory::MemoryPool* pool,
     VeloxToArrowBridgeHolder& holder) {
@@ -429,12 +859,27 @@ void exportFlat(
     case TypeKind::HUGEINT:
     case TypeKind::REAL:
     case TypeKind::DOUBLE:
-      exportValues(vec, rows, out, pool, holder);
+    case TypeKind::TIMESTAMP:
+    case TypeKind::UNKNOWN:
+      exportValues(vec, rows, options, out, pool, holder);
       break;
     case TypeKind::VARCHAR:
     case TypeKind::VARBINARY:
-      exportStrings(
-          *vec.asUnchecked<FlatVector<StringView>>(), rows, out, pool, holder);
+      if (options.exportToStringView) {
+        exportValues(vec, rows, options, out, pool, holder);
+        exportViews(
+            *vec.asUnchecked<FlatVector<StringView>>(),
+            rows,
+            out,
+            pool,
+            holder);
+      } else
+        exportStrings(
+            *vec.asUnchecked<FlatVector<StringView>>(),
+            rows,
+            out,
+            pool,
+            holder);
       break;
     default:
       VELOX_NYI(
@@ -443,15 +888,17 @@ void exportFlat(
   }
 }
 
-void exportBase(
+void exportToArrowImpl(
     const BaseVector&,
     const Selection&,
+    const ArrowOptions& options,
     ArrowArray&,
     memory::MemoryPool*);
 
 void exportRows(
     const RowVector& vec,
     const Selection& rows,
+    const ArrowOptions& options,
     ArrowArray& out,
     memory::MemoryPool* pool,
     VeloxToArrowBridgeHolder& holder) {
@@ -461,9 +908,10 @@ void exportRows(
   out.children = holder.getChildrenArrays();
   for (column_index_t i = 0; i < vec.childrenSize(); ++i) {
     try {
-      exportBase(
+      exportToArrowImpl(
           *vec.childAt(i)->loadedVector(),
           rows,
+          options,
           *holder.allocateChild(i),
           pool);
     } catch (const VeloxException&) {
@@ -494,14 +942,18 @@ void exportOffsets(
     memory::MemoryPool* pool,
     VeloxToArrowBridgeHolder& holder,
     Selection& childRows) {
+  VELOX_CHECK_GE(vec.size(), rows.count());
+
   auto offsets = AlignedBuffer::allocate<vector_size_t>(
       checkedPlus<size_t>(out.length, 1), pool);
   auto rawOffsets = offsets->asMutable<vector_size_t>();
+
   if (!rows.changed() && isCompact(vec)) {
-    memcpy(rawOffsets, vec.rawOffsets(), sizeof(vector_size_t) * vec.size());
-    rawOffsets[vec.size()] = vec.size() == 0
+    vector_size_t rowCount = rows.count();
+    memcpy(rawOffsets, vec.rawOffsets(), sizeof(vector_size_t) * rowCount);
+    rawOffsets[rowCount] = rowCount == 0
         ? 0
-        : vec.offsetAt(vec.size() - 1) + vec.sizeAt(vec.size() - 1);
+        : vec.offsetAt(rowCount - 1) + vec.sizeAt(rowCount - 1);
   } else {
     childRows.clearAll();
     // j: Index of element we are writing.
@@ -524,15 +976,17 @@ void exportOffsets(
 void exportArrays(
     const ArrayVector& vec,
     const Selection& rows,
+    const ArrowOptions& options,
     ArrowArray& out,
     memory::MemoryPool* pool,
     VeloxToArrowBridgeHolder& holder) {
   Selection childRows(vec.elements()->size());
   exportOffsets(vec, rows, out, pool, holder, childRows);
   holder.resizeChildren(1);
-  exportBase(
+  exportToArrowImpl(
       *vec.elements()->loadedVector(),
       childRows,
+      options,
       *holder.allocateChild(0),
       pool);
   out.n_children = 1;
@@ -542,6 +996,7 @@ void exportArrays(
 void exportMaps(
     const MapVector& vec,
     const Selection& rows,
+    const ArrowOptions& options,
     ArrowArray& out,
     memory::MemoryPool* pool,
     VeloxToArrowBridgeHolder& holder) {
@@ -554,14 +1009,47 @@ void exportMaps(
   Selection childRows(child.size());
   exportOffsets(vec, rows, out, pool, holder, childRows);
   holder.resizeChildren(1);
-  exportBase(child, childRows, *holder.allocateChild(0), pool);
+  exportToArrowImpl(child, childRows, options, *holder.allocateChild(0), pool);
   out.n_children = 1;
   out.children = holder.getChildrenArrays();
 }
 
+template <TypeKind kind>
+void flattenAndExport(
+    const BaseVector& vec,
+    const Selection& rows,
+    const ArrowOptions& options,
+    ArrowArray& out,
+    memory::MemoryPool* pool,
+    VeloxToArrowBridgeHolder& holder) {
+  using NativeType = typename velox::TypeTraits<kind>::NativeType;
+  SelectivityVector allRows(vec.size());
+  DecodedVector decoded(vec, allRows);
+  auto flatVector = BaseVector::create<FlatVector<NativeType>>(
+      vec.type(), decoded.size(), pool);
+
+  if (decoded.mayHaveNulls()) {
+    allRows.applyToSelected([&](vector_size_t row) {
+      if (decoded.isNullAt(row)) {
+        flatVector->setNull(row, true);
+      } else {
+        flatVector->set(row, decoded.valueAt<NativeType>(row));
+      }
+    });
+    exportValidityBitmap(*flatVector, rows, options, out, pool, holder);
+    exportFlat(*flatVector, rows, options, out, pool, holder);
+  } else {
+    allRows.applyToSelected([&](vector_size_t row) {
+      flatVector->set(row, decoded.valueAt<NativeType>(row));
+    });
+    exportFlat(*flatVector, rows, options, out, pool, holder);
+  }
+}
+
 void exportDictionary(
     const BaseVector& vec,
     const Selection& rows,
+    const ArrowOptions& options,
     ArrowArray& out,
     memory::MemoryPool* pool,
     VeloxToArrowBridgeHolder& holder) {
@@ -569,19 +1057,112 @@ void exportDictionary(
   out.n_children = 0;
   if (rows.changed()) {
     auto indices = AlignedBuffer::allocate<vector_size_t>(out.length, pool);
-    gatherFromBuffer(*INTEGER(), *vec.wrapInfo(), rows, *indices);
+    gatherFromBuffer(*INTEGER(), *vec.wrapInfo(), rows, options, *indices);
     holder.setBuffer(1, indices);
   } else {
     holder.setBuffer(1, vec.wrapInfo());
   }
   auto& values = *vec.valueVector()->loadedVector();
   out.dictionary = holder.allocateDictionary();
-  exportBase(values, Selection(values.size()), *out.dictionary, pool);
+  exportToArrowImpl(
+      values, Selection(values.size()), options, *out.dictionary, pool);
+}
+
+void exportFlattenedVector(
+    const BaseVector& vec,
+    const Selection& rows,
+    const ArrowOptions& options,
+    ArrowArray& out,
+    memory::MemoryPool* pool,
+    VeloxToArrowBridgeHolder& holder) {
+  VELOX_CHECK(
+      vec.valueVector() == nullptr || vec.wrappedVector()->isFlatEncoding(),
+      "An unsupported nested encoding was found.");
+  VELOX_CHECK(vec.isScalar(), "Flattening is only supported for scalar types.");
+  VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      flattenAndExport, vec.typeKind(), vec, rows, options, out, pool, holder);
+}
+
+void exportConstantValue(
+    const BaseVector& vec,
+    const ArrowOptions& options,
+    ArrowArray& out,
+    memory::MemoryPool* pool) {
+  VectorPtr valuesVector;
+  Selection selection(1);
+
+  // If it's a complex type, then ConstantVector is wrapped around an inner
+  // complex vector. Take that vector and the correct index.
+  if (vec.type()->size() > 0) {
+    valuesVector = vec.valueVector();
+    selection.clearAll();
+    selection.addRange(vec.as<ConstantVector<ComplexType>>()->index(), 1);
+  } else {
+    // If this is a scalar type, then ConstantVector does not have a vector
+    // inside. Wrap the single value in a flat vector with a single element to
+    // export it to an ArrowArray.
+    size_t bufferSize = (vec.type()->isVarchar() || vec.type()->isVarbinary())
+        ? sizeof(StringView)
+        : vec.type()->cppSizeInBytes();
+
+    valuesVector = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        createFlatVector,
+        vec.typeKind(),
+        pool,
+        vec.type(),
+        vec.nulls(),
+        1,
+        wrapInBufferViewAsViewer(vec.valuesAsVoid(), bufferSize),
+        vec.mayHaveNulls() ? 1 : 0);
+  }
+  exportToArrowImpl(*valuesVector, selection, options, out, pool);
+}
+
+// Velox constant vectors are exported as Arrow REE containing a single run
+// equals to the vector size.
+void exportConstant(
+    const BaseVector& vec,
+    const Selection& rows,
+    const ArrowOptions& options,
+    ArrowArray& out,
+    memory::MemoryPool* pool,
+    VeloxToArrowBridgeHolder& holder) {
+  // As per Arrow spec, REE has zero buffers and two children, `run_ends` and
+  // `values`.
+  out.n_buffers = 0;
+  out.buffers = nullptr;
+
+  out.n_children = 2;
+  holder.resizeChildren(2);
+  out.children = holder.getChildrenArrays();
+  exportConstantValue(vec, options, *holder.allocateChild(1), pool);
+
+  // Create the run ends child.
+  auto* runEnds = holder.allocateChild(0);
+  auto runEndsHolder = std::make_unique<VeloxToArrowBridgeHolder>();
+
+  runEnds->buffers = runEndsHolder->getArrowBuffers();
+  runEnds->length = 1;
+  runEnds->offset = 0;
+  runEnds->null_count = 0;
+  runEnds->n_buffers = 2;
+  runEnds->n_children = 0;
+  runEnds->children = nullptr;
+  runEnds->dictionary = nullptr;
+
+  // Allocate single runs buffer with the run set as size.
+  auto runsBuffer = AlignedBuffer::allocate<int32_t>(1, pool);
+  runsBuffer->asMutable<int32_t>()[0] = vec.size();
+  runEndsHolder->setBuffer(1, runsBuffer);
+
+  runEnds->private_data = runEndsHolder.release();
+  runEnds->release = releaseArrowArray;
 }
 
-void exportBase(
+void exportToArrowImpl(
     const BaseVector& vec,
     const Selection& rows,
+    const ArrowOptions& options,
     ArrowArray& out,
     memory::MemoryPool* pool) {
   auto holder = std::make_unique<VeloxToArrowBridgeHolder>();
@@ -589,22 +1170,33 @@ void exportBase(
   out.length = rows.count();
   out.offset = 0;
   out.dictionary = nullptr;
-  exportNulls(vec, rows, out, pool, *holder);
+  exportValidityBitmap(vec, rows, options, out, pool, *holder);
+
   switch (vec.encoding()) {
     case VectorEncoding::Simple::FLAT:
-      exportFlat(vec, rows, out, pool, *holder);
+      exportFlat(vec, rows, options, out, pool, *holder);
       break;
     case VectorEncoding::Simple::ROW:
-      exportRows(*vec.asUnchecked<RowVector>(), rows, out, pool, *holder);
+      exportRows(
+          *vec.asUnchecked<RowVector>(), rows, options, out, pool, *holder);
       break;
     case VectorEncoding::Simple::ARRAY:
-      exportArrays(*vec.asUnchecked<ArrayVector>(), rows, out, pool, *holder);
+      exportArrays(
+          *vec.asUnchecked<ArrayVector>(), rows, options, out, pool, *holder);
       break;
     case VectorEncoding::Simple::MAP:
-      exportMaps(*vec.asUnchecked<MapVector>(), rows, out, pool, *holder);
+      exportMaps(
+          *vec.asUnchecked<MapVector>(), rows, options, out, pool, *holder);
       break;
     case VectorEncoding::Simple::DICTIONARY:
-      exportDictionary(vec, rows, out, pool, *holder);
+      options.flattenDictionary
+          ? exportFlattenedVector(vec, rows, options, out, pool, *holder)
+          : exportDictionary(vec, rows, options, out, pool, *holder);
+      break;
+    case VectorEncoding::Simple::CONSTANT:
+      options.flattenConstant
+          ? exportFlattenedVector(vec, rows, options, out, pool, *holder)
+          : exportConstant(vec, rows, options, out, pool, *holder);
       break;
     default:
       VELOX_NYI("{} cannot be exported to Arrow yet.", vec.encoding());
@@ -613,120 +1205,47 @@ void exportBase(
   out.release = releaseArrowArray;
 }
 
-} // namespace
+// Parses the velox decimal format from the given arrow format.
+// The input format string should be in the form "d:precision,scale<,bitWidth>".
+// bitWidth is not required and must be 128 if provided.
+TypePtr parseDecimalFormat(const char* format) {
+  std::string invalidFormatMsg =
+      "Unable to convert '{}' ArrowSchema decimal format to Velox decimal";
+  try {
+    std::string::size_type sz;
+    std::string formatStr(format);
+
+    auto firstCommaIdx = formatStr.find(',', 2);
+    auto secondCommaIdx = formatStr.find(',', firstCommaIdx + 1);
+
+    if (firstCommaIdx == std::string::npos ||
+        formatStr.size() == firstCommaIdx + 1 ||
+        (secondCommaIdx != std::string::npos &&
+         formatStr.size() == secondCommaIdx + 1)) {
+      VELOX_USER_FAIL(invalidFormatMsg, format);
+    }
 
-void exportToArrow(
-    const VectorPtr& vector,
-    ArrowArray& arrowArray,
-    memory::MemoryPool* pool) {
-  exportBase(*vector, Selection(vector->size()), arrowArray, pool);
-}
-
-void exportToArrow(const VectorPtr& vec, ArrowSchema& arrowSchema) {
-  auto& type = vec->type();
-
-  arrowSchema.name = nullptr;
-
-  // No additional metadata for now.
-  arrowSchema.metadata = nullptr;
-
-  // All supported types are semantically nullable.
-  arrowSchema.flags = ARROW_FLAG_NULLABLE;
-
-  // Allocate private data buffer holder and recurse down to children types.
-  auto bridgeHolder = std::make_unique<VeloxToArrowSchemaBridgeHolder>();
-
-  if (vec->encoding() == VectorEncoding::Simple::DICTIONARY) {
-    arrowSchema.n_children = 0;
-    arrowSchema.children = nullptr;
-    arrowSchema.format = "i";
-    bridgeHolder->dictionary = std::make_unique<ArrowSchema>();
-    arrowSchema.dictionary = bridgeHolder->dictionary.get();
-    exportToArrow(vec->valueVector(), *arrowSchema.dictionary);
-
-  } else {
-    arrowSchema.format = exportArrowFormatStr(type, bridgeHolder->formatBuffer);
-    arrowSchema.dictionary = nullptr;
-
-    if (type->kind() == TypeKind::MAP) {
-      // Need to wrap the key and value types in a struct type.
-      VELOX_DCHECK_EQ(type->size(), 2);
-      auto child = std::make_unique<ArrowSchema>();
-      auto& maps = *vec->asUnchecked<MapVector>();
-      auto rows = std::make_shared<RowVector>(
-          nullptr,
-          ROW({"key", "value"}, {type->childAt(0), type->childAt(1)}),
-          nullptr,
-          0,
-          std::vector<VectorPtr>{maps.mapKeys(), maps.mapValues()},
-          maps.getNullCount());
-      exportToArrow(rows, *child);
-      child->name = "entries";
-      setUniqueChild(std::move(child), *bridgeHolder, arrowSchema);
-
-    } else if (type->kind() == TypeKind::ARRAY) {
-      auto child = std::make_unique<ArrowSchema>();
-      auto& arrays = *vec->asUnchecked<ArrayVector>();
-      exportToArrow(arrays.elements(), *child);
-      // Name is required, and "item" is the default name used in arrow itself.
-      child->name = "item";
-      setUniqueChild(std::move(child), *bridgeHolder, arrowSchema);
-
-    } else if (type->kind() == TypeKind::ROW) {
-      auto& rows = *vec->asUnchecked<RowVector>();
-      auto numChildren = rows.childrenSize();
-      bridgeHolder->childrenRaw.resize(numChildren);
-      bridgeHolder->childrenOwned.resize(numChildren);
-
-      // Hold the shared_ptr so we can set the ArrowSchema.name pointer to its
-      // internal `name` string.
-      bridgeHolder->rowType = std::static_pointer_cast<const RowType>(type);
-
-      arrowSchema.children = bridgeHolder->childrenRaw.data();
-      arrowSchema.n_children = numChildren;
-
-      for (size_t i = 0; i < numChildren; ++i) {
-        // Recurse down the children. We use the same trick of temporarily
-        // holding the buffer in a unique_ptr so it doesn't leak if the
-        // recursion throws.
-        //
-        // But this is more nuanced: for types with a list of children (like
-        // row/structs), if one of the children throws, we need to make sure we
-        // call release() on the children that have already been created before
-        // we re-throw the exception back to the client, or memory will leak.
-        // This is needed because Arrow doesn't define what the client needs to
-        // do if the conversion fails, so we can't expect the client to call the
-        // release() method.
-        try {
-          auto& currentSchema = bridgeHolder->childrenOwned[i];
-          currentSchema = std::make_unique<ArrowSchema>();
-          exportToArrow(rows.childAt(i), *currentSchema);
-          currentSchema->name = bridgeHolder->rowType->nameOf(i).data();
-          arrowSchema.children[i] = currentSchema.get();
-        } catch (const VeloxException& e) {
-          // Release any children that have already been built before
-          // re-throwing the exception back to the client.
-          for (size_t j = 0; j < i; ++j) {
-            arrowSchema.children[j]->release(arrowSchema.children[j]);
-          }
-          throw;
-        }
-      }
-
-    } else {
-      VELOX_DCHECK_EQ(type->size(), 0);
-      arrowSchema.n_children = 0;
-      arrowSchema.children = nullptr;
+    // Parse "d:".
+    int precision = std::stoi(&format[2], &sz);
+    int scale = std::stoi(&format[firstCommaIdx + 1], &sz);
+    // If bitwidth is provided, check if it is equal to 128.
+    if (secondCommaIdx != std::string::npos) {
+      int bitWidth = std::stoi(&format[secondCommaIdx + 1], &sz);
+      VELOX_USER_CHECK_EQ(
+          bitWidth,
+          128,
+          "Conversion failed for '{}'. Velox decimal does not support custom bitwidth.",
+          format);
     }
+    return DECIMAL(precision, scale);
+  } catch (std::invalid_argument&) {
+    VELOX_USER_FAIL(invalidFormatMsg, format);
   }
-
-  // Set release callback.
-  arrowSchema.release = releaseArrowSchema;
-  arrowSchema.private_data = bridgeHolder.release();
 }
 
-TypePtr importFromArrow(const ArrowSchema& arrowSchema) {
-  const char* format = arrowSchema.format;
+TypePtr importFromArrowImpl(
+    const char* format,
+    const ArrowSchema& arrowSchema) {
   VELOX_CHECK_NOT_NULL(format);
 
   switch (format[0]) {
@@ -744,6 +1263,8 @@ TypePtr importFromArrow(const ArrowSchema& arrowSchema) {
       return REAL();
     case 'g':
       return DOUBLE();
+    case 'n':
+      return UNKNOWN();
 
     // Map both utf-8 and large utf-8 string to varchar.
     case 'u':
@@ -755,30 +1276,30 @@ TypePtr importFromArrow(const ArrowSchema& arrowSchema) {
     case 'Z':
       return VARBINARY();
 
+    case 'v':
+      if (format[1] == 'u') {
+        return VARCHAR();
+      }
+      if (format[1] == 'z') {
+        return VARBINARY();
+      }
+      break;
+
     case 't': // temporal types.
-      // Mapping it to ttn for now.
-      if (format[1] == 't' && format[2] == 'n') {
+      if (format[1] == 's') {
         return TIMESTAMP();
       }
       if (format[1] == 'd' && format[2] == 'D') {
         return DATE();
       }
+      if (format[1] == 'i' && format[2] == 'M') {
+        return INTERVAL_YEAR_MONTH();
+      }
       break;
 
-    case 'd': { // decimal types.
-      try {
-        std::string::size_type sz;
-        // Parse "d:".
-        int precision = std::stoi(&format[2], &sz);
-        // Parse ",".
-        int scale = std::stoi(&format[2 + sz + 1], &sz);
-        return DECIMAL(precision, scale);
-      } catch (std::invalid_argument& err) {
-        VELOX_USER_FAIL(
-            "Unable to convert '{}' ArrowSchema decimal format to Velox decimal",
-            format);
-      }
-    }
+    case 'd':
+      // decimal types.
+      return parseDecimalFormat(format);
 
     // Complex types.
     case '+': {
@@ -822,6 +1343,13 @@ TypePtr importFromArrow(const ArrowSchema& arrowSchema) {
           return ROW(std::move(childNames), std::move(childTypes));
         }
 
+        // Run-end-encoding (REE).
+        case 'r':
+          VELOX_CHECK_EQ(arrowSchema.n_children, 2);
+          VELOX_CHECK_NOT_NULL(arrowSchema.children[1]);
+          // The Velox type is the type of the `values` child.
+          return importFromArrow(*arrowSchema.children[1]);
+
         default:
           break;
       }
@@ -834,115 +1362,190 @@ TypePtr importFromArrow(const ArrowSchema& arrowSchema) {
       "Unable to convert '{}' ArrowSchema format type to Velox.", format);
 }
 
-namespace {
-// Optionally, holds shared_ptrs pointing to the ArrowArray object that
-// holds the buffer and the ArrowSchema object that describes the ArrowArray,
-// which will be released to signal that we will no longer hold on to the data
-// and the shared_ptr deleters should run the release procedures if no one
-// else is referencing the objects.
-struct BufferViewReleaser {
-  BufferViewReleaser() : BufferViewReleaser(nullptr, nullptr) {}
-  BufferViewReleaser(
-      std::shared_ptr<ArrowSchema> arrowSchema,
-      std::shared_ptr<ArrowArray> arrowArray)
-      : schemaReleaser_(std::move(arrowSchema)),
-        arrayReleaser_(std::move(arrowArray)) {}
+} // namespace
 
-  void addRef() const {}
-  void release() const {}
+void exportToArrow(
+    const VectorPtr& vector,
+    ArrowArray& arrowArray,
+    memory::MemoryPool* pool,
+    const ArrowOptions& options) {
+  exportToArrowImpl(
+      *vector, Selection(vector->size()), options, arrowArray, pool);
+}
 
- private:
-  const std::shared_ptr<ArrowSchema> schemaReleaser_;
-  const std::shared_ptr<ArrowArray> arrayReleaser_;
-};
+void exportToArrow(
+    const VectorPtr& vec,
+    ArrowSchema& arrowSchema,
+    const ArrowOptions& options) {
+  auto& type = vec->type();
 
-// Wraps a naked pointer using a Velox buffer view, without copying it. Adding a
-// dummy releaser as the buffer lifetime is fully controled by the client of the
-// API.
-BufferPtr wrapInBufferViewAsViewer(const void* buffer, size_t length) {
-  static const BufferViewReleaser kViewerReleaser;
-  return BufferView<BufferViewReleaser>::create(
-      static_cast<const uint8_t*>(buffer), length, kViewerReleaser);
-}
+  arrowSchema.name = nullptr;
 
-// Wraps a naked pointer using a Velox buffer view, without copying it. This
-// buffer view uses shared_ptr to manage reference counting and releasing for
-// the ArrowSchema object and the ArrowArray object
-BufferPtr wrapInBufferViewAsOwner(
-    const void* buffer,
-    size_t length,
-    std::shared_ptr<ArrowSchema> schemaReleaser,
-    std::shared_ptr<ArrowArray> arrayReleaser) {
-  return BufferView<BufferViewReleaser>::create(
-      static_cast<const uint8_t*>(buffer),
-      length,
-      {std::move(schemaReleaser), std::move(arrayReleaser)});
-}
+  // No additional metadata for now.
+  arrowSchema.metadata = nullptr;
 
-std::optional<int64_t> optionalNullCount(int64_t value) {
-  return value == -1 ? std::nullopt : std::optional<int64_t>(value);
-}
+  // All supported types are semantically nullable.
+  arrowSchema.flags = ARROW_FLAG_NULLABLE;
 
-// Dispatch based on the type.
-template <TypeKind kind>
-VectorPtr createFlatVector(
-    memory::MemoryPool* pool,
-    const TypePtr& type,
-    BufferPtr nulls,
-    size_t length,
-    BufferPtr values,
-    int64_t nullCount) {
-  using T = typename TypeTraits<kind>::NativeType;
-  return std::make_shared<FlatVector<T>>(
-      pool,
-      type,
-      nulls,
-      length,
-      values,
-      std::vector<BufferPtr>(),
-      SimpleVectorStats<T>{},
-      std::nullopt,
-      optionalNullCount(nullCount));
-}
+  // Allocate private data buffer holder and recurse down to children types.
+  auto bridgeHolder = std::make_unique<VeloxToArrowSchemaBridgeHolder>();
 
-using WrapInBufferViewFunc =
-    std::function<BufferPtr(const void* buffer, size_t length)>;
+  if (vec->encoding() == VectorEncoding::Simple::DICTIONARY) {
+    arrowSchema.n_children = 0;
+    arrowSchema.children = nullptr;
+    if (options.flattenDictionary) {
+      // Dictionary data is flattened. Set the underlying data types.
+      arrowSchema.dictionary = nullptr;
+      arrowSchema.format =
+          exportArrowFormatStr(type, options, bridgeHolder->formatBuffer);
+    } else {
+      arrowSchema.format = "i";
+      bridgeHolder->dictionary = std::make_unique<ArrowSchema>();
+      arrowSchema.dictionary = bridgeHolder->dictionary.get();
+      exportToArrow(vec->valueVector(), *arrowSchema.dictionary, options);
+    }
+  } else if (
+      vec->encoding() == VectorEncoding::Simple::CONSTANT &&
+      !options.flattenConstant) {
+    // Arrow REE spec available in
+    //  https://arrow.apache.org/docs/format/Columnar.html#run-end-encoded-layout
+    arrowSchema.format = "+r";
+    arrowSchema.dictionary = nullptr;
 
-template <typename TOffset>
-VectorPtr createStringFlatVector(
-    memory::MemoryPool* pool,
-    const TypePtr& type,
-    BufferPtr nulls,
-    size_t length,
-    const TOffset* offsets,
-    const char* values,
-    int64_t nullCount,
-    WrapInBufferViewFunc wrapInBufferView) {
-  BufferPtr stringViews = AlignedBuffer::allocate<StringView>(length, pool);
-  auto rawStringViews = stringViews->asMutable<StringView>();
-  bool shouldAcquireStringBuffer = false;
+    // Set up the `values` child.
+    auto valuesChild = newArrowSchema();
+    const auto& valueVector = vec->valueVector();
 
-  for (size_t i = 0; i < length; ++i) {
-    rawStringViews[i] =
-        StringView(values + offsets[i], offsets[i + 1] - offsets[i]);
-    shouldAcquireStringBuffer |= !rawStringViews[i].isInline();
-  }
+    // Contants of complex types are stored in the `values` vector.
+    if (valueVector != nullptr) {
+      exportToArrow(valueVector, *valuesChild, options);
+    } else {
+      valuesChild->format =
+          exportArrowFormatStr(type, options, bridgeHolder->formatBuffer);
+    }
+    valuesChild->name = "values";
 
-  std::vector<BufferPtr> stringViewBuffers;
-  if (shouldAcquireStringBuffer) {
-    stringViewBuffers.emplace_back(wrapInBufferView(values, offsets[length]));
+    bridgeHolder->setChildAtIndex(
+        0, newArrowSchema("i", "run_ends"), arrowSchema);
+    bridgeHolder->setChildAtIndex(1, std::move(valuesChild), arrowSchema);
+  } else {
+    arrowSchema.format =
+        exportArrowFormatStr(type, options, bridgeHolder->formatBuffer);
+    arrowSchema.dictionary = nullptr;
+
+    if (type->kind() == TypeKind::MAP) {
+      // Need to wrap the key and value types in a struct type.
+      VELOX_DCHECK_EQ(type->size(), 2);
+      auto child = std::make_unique<ArrowSchema>();
+      auto& maps = *vec->asUnchecked<MapVector>();
+      auto rows = std::make_shared<RowVector>(
+          nullptr,
+          ROW({"key", "value"}, {type->childAt(0), type->childAt(1)}),
+          nullptr,
+          0,
+          std::vector<VectorPtr>{maps.mapKeys(), maps.mapValues()},
+          maps.getNullCount());
+      exportToArrow(rows, *child, options);
+      child->name = "entries";
+      bridgeHolder->setChildAtIndex(0, std::move(child), arrowSchema);
+
+    } else if (type->kind() == TypeKind::ARRAY) {
+      auto child = std::make_unique<ArrowSchema>();
+      auto& arrays = *vec->asUnchecked<ArrayVector>();
+      exportToArrow(arrays.elements(), *child, options);
+      // Name is required, and "item" is the default name used in arrow itself.
+      child->name = "item";
+      bridgeHolder->setChildAtIndex(0, std::move(child), arrowSchema);
+
+    } else if (type->kind() == TypeKind::ROW) {
+      auto& rows = *vec->asUnchecked<RowVector>();
+      auto numChildren = rows.childrenSize();
+      bridgeHolder->childrenRaw.resize(numChildren);
+      bridgeHolder->childrenOwned.resize(numChildren);
+
+      // Hold the shared_ptr so we can set the ArrowSchema.name pointer to its
+      // internal `name` string.
+      bridgeHolder->rowType = std::static_pointer_cast<const RowType>(type);
+
+      arrowSchema.children = bridgeHolder->childrenRaw.data();
+      arrowSchema.n_children = numChildren;
+
+      for (size_t i = 0; i < numChildren; ++i) {
+        // Recurse down the children. We use the same trick of temporarily
+        // holding the buffer in a unique_ptr so it doesn't leak if the
+        // recursion throws.
+        //
+        // But this is more nuanced: for types with a list of children (like
+        // row/structs), if one of the children throws, we need to make sure we
+        // call release() on the children that have already been created before
+        // we re-throw the exception back to the client, or memory will leak.
+        // This is needed because Arrow doesn't define what the client needs to
+        // do if the conversion fails, so we can't expect the client to call the
+        // release() method.
+        try {
+          auto& currentSchema = bridgeHolder->childrenOwned[i];
+          currentSchema = std::make_unique<ArrowSchema>();
+          exportToArrow(rows.childAt(i), *currentSchema, options);
+          currentSchema->name = bridgeHolder->rowType->nameOf(i).data();
+          arrowSchema.children[i] = currentSchema.get();
+        } catch (const VeloxException&) {
+          // Release any children that have already been built before
+          // re-throwing the exception back to the client.
+          for (size_t j = 0; j < i; ++j) {
+            arrowSchema.children[j]->release(arrowSchema.children[j]);
+          }
+          throw;
+        }
+      }
+
+    } else {
+      VELOX_DCHECK_EQ(type->size(), 0);
+      arrowSchema.n_children = 0;
+      arrowSchema.children = nullptr;
+    }
   }
 
-  return std::make_shared<FlatVector<StringView>>(
-      pool,
-      type,
-      nulls,
-      length,
-      stringViews,
-      std::move(stringViewBuffers),
-      SimpleVectorStats<StringView>{},
-      std::nullopt,
-      optionalNullCount(nullCount));
+  // Set release callback.
+  arrowSchema.release = releaseArrowSchema;
+  arrowSchema.private_data = bridgeHolder.release();
+}
+
+TypePtr importFromArrow(const ArrowSchema& arrowSchema) {
+  // For dictionaries, format encodes the index type, while the dictionary value
+  // is encoded in the dictionary member, as per
+  // https://arrow.apache.org/docs/format/CDataInterface.html#dictionary-encoded-arrays.
+
+  const char* format = arrowSchema.dictionary ? arrowSchema.dictionary->format
+                                              : arrowSchema.format;
+  ArrowSchema schema =
+      arrowSchema.dictionary ? *arrowSchema.dictionary : arrowSchema;
+  return importFromArrowImpl(format, schema);
+}
+
+namespace {
+
+TimestampUnit getTimestampUnit(const ArrowSchema& arrowSchema) {
+  const char* format = arrowSchema.dictionary ? arrowSchema.dictionary->format
+                                              : arrowSchema.format;
+  VELOX_USER_CHECK_NOT_NULL(format);
+  VELOX_USER_CHECK_GE(
+      strlen(format),
+      3,
+      "The arrow format string of timestamp should contain 'ts' and unit char.");
+  VELOX_USER_CHECK_EQ(format[0], 't', "The first character should be 't'.");
+  VELOX_USER_CHECK_EQ(format[1], 's', "The second character should be 's'.");
+  switch (format[2]) {
+    case 's':
+      return TimestampUnit::kSecond;
+    case 'm':
+      return TimestampUnit::kMilli;
+    case 'u':
+      return TimestampUnit::kMicro;
+    case 'n':
+      return TimestampUnit::kNano;
+    default:
+      VELOX_UNREACHABLE();
+  }
 }
 
 VectorPtr importFromArrowImpl(
@@ -1077,6 +1680,189 @@ VectorPtr createDictionaryVector(
       std::move(wrapped));
 }
 
+VectorPtr createVectorFromReeArray(
+    memory::MemoryPool* pool,
+    const ArrowSchema& arrowSchema,
+    const ArrowArray& arrowArray,
+    bool isViewer) {
+  VELOX_CHECK_EQ(arrowArray.n_children, 2);
+  VELOX_CHECK_EQ(arrowSchema.n_children, 2);
+
+  // REE cannot have top level nulls.
+  VELOX_CHECK_EQ(arrowArray.null_count, 0);
+
+  auto values = importFromArrowImpl(
+      *arrowSchema.children[1], *arrowArray.children[1], pool, isViewer);
+
+  const auto& runEndSchema = *arrowSchema.children[0];
+  auto runEndType = importFromArrowImpl(runEndSchema.format, runEndSchema);
+  VELOX_CHECK_EQ(
+      runEndType->kind(),
+      TypeKind::INTEGER,
+      "Only int32 run lengths are supported for REE arrow conversion.");
+
+  // If there is more than one run, we turn it into a dictionary.
+  if (values->size() > 1) {
+    const auto& runsArray = *arrowArray.children[0];
+    VELOX_CHECK_EQ(runsArray.n_buffers, 2);
+
+    // REE runs cannot be null.
+    VELOX_CHECK_EQ(runsArray.null_count, 0);
+
+    const auto* runsBuffer = static_cast<const int32_t*>(runsArray.buffers[1]);
+    VELOX_CHECK_NOT_NULL(runsBuffer);
+
+    auto indices = allocateIndices(arrowArray.length, pool);
+    auto rawIndices = indices->asMutable<vector_size_t>();
+
+    size_t cursor = 0;
+    for (size_t i = 0; i < runsArray.length; ++i) {
+      while (cursor < runsBuffer[i]) {
+        rawIndices[cursor++] = i;
+      }
+    }
+    return BaseVector::wrapInDictionary(
+        nullptr, indices, arrowArray.length, values);
+  }
+  // Otherwise (single or zero runs), turn it into a constant.
+  else if (values->size() == 1) {
+    return BaseVector::wrapInConstant(arrowArray.length, 0, values);
+  } else {
+    return BaseVector::createNullConstant(values->type(), 0, pool);
+  }
+}
+
+// Set valid timestamp values according to the input and timestamp unit.
+void setTimestamps(
+    const int64_t* input,
+    int64_t length,
+    TimestampUnit unit,
+    Timestamp* rawTimestamps) {
+  switch (unit) {
+    case TimestampUnit::kSecond: {
+      for (int64_t i = 0; i < length; ++i) {
+        rawTimestamps[i] = Timestamp(input[i], 0);
+      }
+      break;
+    }
+    case TimestampUnit::kMilli: {
+      for (int64_t i = 0; i < length; ++i) {
+        rawTimestamps[i] = Timestamp::fromMillis(input[i]);
+      }
+      break;
+    }
+    case TimestampUnit::kMicro: {
+      for (int64_t i = 0; i < length; ++i) {
+        rawTimestamps[i] = Timestamp::fromMicros(input[i]);
+      }
+      break;
+    }
+    case TimestampUnit::kNano: {
+      for (int64_t i = 0; i < length; ++i) {
+        rawTimestamps[i] = Timestamp::fromNanos(input[i]);
+      }
+      break;
+    }
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
+// Set valid timestamp values according to the input and timestamp unit. Nulls
+// are skipped.
+void setTimestamps(
+    const int64_t* input,
+    BufferPtr nulls,
+    int64_t length,
+    TimestampUnit unit,
+    Timestamp* rawTimestamps) {
+  const auto* rawNulls = nulls->as<const uint64_t>();
+  switch (unit) {
+    case TimestampUnit::kSecond: {
+      for (size_t i = 0; i < length; ++i) {
+        if (!bits::isBitNull(rawNulls, i)) {
+          rawTimestamps[i] = Timestamp(input[i], 0);
+        }
+      }
+      break;
+    }
+    case TimestampUnit::kMilli: {
+      for (size_t i = 0; i < length; ++i) {
+        if (!bits::isBitNull(rawNulls, i)) {
+          rawTimestamps[i] = Timestamp::fromMillis(input[i]);
+        }
+      }
+      break;
+    }
+    case TimestampUnit::kMicro: {
+      for (size_t i = 0; i < length; ++i) {
+        if (!bits::isBitNull(rawNulls, i)) {
+          rawTimestamps[i] = Timestamp::fromMicros(input[i]);
+        }
+      }
+      break;
+    }
+    case TimestampUnit::kNano: {
+      for (size_t i = 0; i < length; ++i) {
+        if (!bits::isBitNull(rawNulls, i)) {
+          rawTimestamps[i] = Timestamp::fromNanos(input[i]);
+        }
+      }
+      break;
+    }
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
+VectorPtr createTimestampVector(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    TimestampUnit unit,
+    BufferPtr nulls,
+    const int64_t* input,
+    size_t length,
+    int64_t nullCount) {
+  BufferPtr timestamps = AlignedBuffer::allocate<Timestamp>(length, pool);
+  auto* rawTimestamps = timestamps->asMutable<Timestamp>();
+  if (nulls == nullptr) {
+    setTimestamps(input, length, unit, rawTimestamps);
+  } else if (length > nullCount) {
+    setTimestamps(input, nulls, length, unit, rawTimestamps);
+  }
+  return std::make_shared<FlatVector<Timestamp>>(
+      pool,
+      type,
+      nulls,
+      length,
+      timestamps,
+      std::vector<BufferPtr>(),
+      SimpleVectorStats<Timestamp>{},
+      std::nullopt,
+      optionalNullCount(nullCount));
+}
+
+VectorPtr createShortDecimalVector(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    BufferPtr nulls,
+    const int128_t* input,
+    size_t length,
+    int64_t nullCount) {
+  auto values = AlignedBuffer::allocate<int64_t>(length, pool);
+  auto rawValues = values->asMutable<int64_t>();
+  for (size_t i = 0; i < length; ++i) {
+    memcpy(rawValues + i, input + i, sizeof(int64_t));
+  }
+
+  return createFlatVector<TypeKind::BIGINT>(
+      pool, type, nulls, length, values, nullCount);
+}
+
+bool isREE(const ArrowSchema& arrowSchema) {
+  return arrowSchema.format[0] == '+' && arrowSchema.format[1] == 'r';
+}
+
 VectorPtr importFromArrowImpl(
     ArrowSchema& arrowSchema,
     ArrowArray& arrowArray,
@@ -1113,12 +1899,30 @@ VectorPtr importFromArrowImpl(
   }
 
   if (arrowSchema.dictionary) {
+    auto indexType = importFromArrowImpl(arrowSchema.format, arrowSchema);
     return createDictionaryVector(
-        pool, type, nulls, arrowSchema, arrowArray, isViewer, wrapInBufferView);
+        pool,
+        indexType,
+        nulls,
+        arrowSchema,
+        arrowArray,
+        isViewer,
+        wrapInBufferView);
+  }
+
+  if (isREE(arrowSchema)) {
+    return createVectorFromReeArray(pool, arrowSchema, arrowArray, isViewer);
   }
 
   // String data types (VARCHAR and VARBINARY).
   if (type->isVarchar() || type->isVarbinary()) {
+    // Import StringView from Utf8View/BinaryView (Zero-copy)
+    if (arrowSchema.format[0] == 'v') {
+      return createStringFlatVectorFromUtf8View(
+          pool, type, nulls, arrowArray, wrapInBufferView);
+    }
+
+    // Import StringView from Utf8/Binary
     VELOX_USER_CHECK_EQ(
         arrowArray.n_buffers,
         3,
@@ -1132,9 +1936,25 @@ VectorPtr importFromArrowImpl(
         static_cast<const char*>(arrowArray.buffers[2]), // values
         arrowArray.null_count,
         wrapInBufferView);
-  }
-  // Row/structs.
-  if (type->isRow()) {
+  } else if (type->isTimestamp()) {
+    return createTimestampVector(
+        pool,
+        type,
+        getTimestampUnit(arrowSchema),
+        nulls,
+        static_cast<const int64_t*>(arrowArray.buffers[1]),
+        arrowArray.length,
+        arrowArray.null_count);
+  } else if (type->isShortDecimal()) {
+    return createShortDecimalVector(
+        pool,
+        type,
+        nulls,
+        static_cast<const int128_t*>(arrowArray.buffers[1]),
+        arrowArray.length,
+        arrowArray.null_count);
+  } else if (type->isRow()) {
+    // Row/structs.
     return createRowVector(
         pool,
         std::dynamic_pointer_cast<const RowType>(type),
@@ -1142,36 +1962,36 @@ VectorPtr importFromArrowImpl(
         arrowSchema,
         arrowArray,
         isViewer);
-  }
-  if (type->isArray()) {
+  } else if (type->isArray()) {
     return createArrayVector(
         pool, type, nulls, arrowSchema, arrowArray, isViewer, wrapInBufferView);
-  }
-  if (type->isMap()) {
+  } else if (type->isMap()) {
     return createMapVector(
         pool, type, nulls, arrowSchema, arrowArray, isViewer, wrapInBufferView);
-  }
-  // Other primitive types.
-  VELOX_CHECK(
-      type->isPrimitiveType(),
-      "Conversion of '{}' from Arrow not supported yet.",
-      type->toString());
-
-  // Wrap the values buffer into a Velox BufferView - zero-copy.
-  VELOX_USER_CHECK_EQ(
-      arrowArray.n_buffers, 2, "Primitive types expect two buffers as input.");
-  auto values = wrapInBufferView(
-      arrowArray.buffers[1], arrowArray.length * type->cppSizeInBytes());
+  } else if (type->isPrimitiveType()) {
+    // Other primitive types.
 
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-      createFlatVector,
-      type->kind(),
-      pool,
-      type,
-      nulls,
-      arrowArray.length,
-      values,
-      arrowArray.null_count);
+    // Wrap the values buffer into a Velox BufferView - zero-copy.
+    VELOX_USER_CHECK_EQ(
+        arrowArray.n_buffers,
+        2,
+        "Primitive types expect two buffers as input.");
+    auto values = wrapInBufferView(
+        arrowArray.buffers[1], arrowArray.length * type->cppSizeInBytes());
+
+    return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        createFlatVector,
+        type->kind(),
+        pool,
+        type,
+        nulls,
+        arrowArray.length,
+        values,
+        arrowArray.null_count);
+  } else {
+    VELOX_FAIL(
+        "Conversion of '{}' from Arrow not supported yet.", type->toString());
+  }
 }
 
 VectorPtr importFromArrowImpl(
diff --git a/velox/vector/arrow/Bridge.h b/velox/vector/arrow/Bridge.h
index faeb571d38169..5c7194a872366 100644
--- a/velox/vector/arrow/Bridge.h
+++ b/velox/vector/arrow/Bridge.h
@@ -25,6 +25,22 @@
 struct ArrowArray;
 struct ArrowSchema;
 
+enum class TimestampUnit : uint8_t {
+  kSecond = 0 /*10^0 second is equal to 1 second*/,
+  kMilli = 3 /*10^3 milliseconds are equal to 1 second*/,
+  kMicro = 6 /*10^6 microseconds are equal to 1 second*/,
+  kNano = 9 /*10^9 nanoseconds are equal to 1 second*/
+};
+
+struct ArrowOptions {
+  bool flattenDictionary{false};
+  bool flattenConstant{false};
+  TimestampUnit timestampUnit = TimestampUnit::kNano;
+  std::optional<std::string> timestampTimeZone{std::nullopt};
+  // Export VARCHAR and VARBINARY to Arrow 15 StringView format
+  bool exportToStringView = false;
+};
+
 namespace facebook::velox {
 
 /// Export a generic Velox Vector to an ArrowArray, as defined by Arrow's C data
@@ -57,7 +73,8 @@ namespace facebook::velox {
 void exportToArrow(
     const VectorPtr& vector,
     ArrowArray& arrowArray,
-    memory::MemoryPool* pool);
+    memory::MemoryPool* pool,
+    const ArrowOptions& options = ArrowOptions{});
 
 /// Export the type of a Velox vector to an ArrowSchema.
 ///
@@ -78,7 +95,10 @@ void exportToArrow(
 ///
 /// NOTE: Since Arrow couples type and encoding, we need both Velox type and
 /// actual data (containing encoding) to create an ArrowSchema.
-void exportToArrow(const VectorPtr&, ArrowSchema&);
+void exportToArrow(
+    const VectorPtr&,
+    ArrowSchema&,
+    const ArrowOptions& = ArrowOptions{});
 
 /// Import an ArrowSchema into a Velox Type object.
 ///
diff --git a/velox/vector/arrow/CMakeLists.txt b/velox/vector/arrow/CMakeLists.txt
index 31038b1a41f5c..ed3733205fbf2 100644
--- a/velox/vector/arrow/CMakeLists.txt
+++ b/velox/vector/arrow/CMakeLists.txt
@@ -11,10 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-add_library(velox_arrow_bridge Bridge.cpp)
+velox_add_library(velox_arrow_bridge Bridge.cpp)
 
-target_link_libraries(velox_arrow_bridge velox_memory velox_type velox_buffer
-                      velox_exception)
+velox_link_libraries(
+  velox_arrow_bridge
+  velox_memory
+  velox_type
+  velox_buffer
+  velox_exception)
 
 if(VELOX_BUILD_TESTING AND VELOX_ENABLE_ARROW)
   add_subdirectory(tests)
diff --git a/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp b/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp
index e4c9d93e8234b..bd07abdfcc71e 100644
--- a/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp
+++ b/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp
@@ -24,41 +24,105 @@
 #include "velox/core/QueryCtx.h"
 #include "velox/vector/arrow/Bridge.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
+namespace facebook::velox::test {
 namespace {
 
-using namespace facebook::velox;
-
 void mockSchemaRelease(ArrowSchema*) {}
 void mockArrayRelease(ArrowArray*) {}
 
-void exportToArrow(const TypePtr& type, ArrowSchema& out) {
-  auto pool = &facebook::velox::memory::deprecatedSharedLeafPool();
-  exportToArrow(BaseVector::create(type, 0, pool), out);
-}
+template <typename T>
+struct VeloxToArrowType {
+  using type = T;
+};
+
+template <>
+struct VeloxToArrowType<Timestamp> {
+  using type = int64_t;
+};
 
 class ArrowBridgeArrayExportTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   template <typename T>
   void testFlatVector(
       const std::vector<std::optional<T>>& inputData,
       const TypePtr& type = CppToType<T>::create()) {
-    const bool isString =
-        std::is_same_v<T, StringView> or std::is_same_v<T, std::string>;
-
     auto flatVector = vectorMaker_.flatVectorNullable(inputData, type);
     ArrowArray arrowArray;
-    exportToArrow(flatVector, arrowArray, pool_.get());
+    velox::exportToArrow(flatVector, arrowArray, pool_.get(), options_);
+
+    validateArray(inputData, arrowArray);
+
+    arrowArray.release(&arrowArray);
+    EXPECT_EQ(nullptr, arrowArray.release);
+    EXPECT_EQ(nullptr, arrowArray.private_data);
+  }
+
+  template <typename T>
+  void testArrayVector(const T& inputData) {
+    auto arrayVector = vectorMaker_.arrayVectorNullable(inputData);
+    ArrowArray arrowArray;
+    velox::exportToArrow(arrayVector, arrowArray, pool_.get(), options_);
+
+    validateListArray(inputData, arrowArray);
+
+    arrowArray.release(&arrowArray);
+    EXPECT_EQ(nullptr, arrowArray.release);
+    EXPECT_EQ(nullptr, arrowArray.private_data);
+  }
+
+  // Construct and test a constant vector based on a scalar value.
+  template <typename T>
+  void testConstant(
+      const T& input,
+      size_t vectorSize = 1000,
+      const TypePtr& type = CppToType<T>::create()) {
+    VectorPtr vector = BaseVector::createConstant(
+        type, variant(input), vectorSize, pool_.get());
+    testConstantVector<true /*isScalar*/, T>(vector, input);
+  }
+
+  // Test arrow conversion based on a constant vector already constructed.
+  template <bool isScalar, typename T, typename TInput>
+  void testConstantVector(
+      const VectorPtr& constantVector,
+      const TInput& input) {
+    ArrowArray arrowArray;
+    velox::exportToArrow(constantVector, arrowArray, pool_.get(), options_);
+    validateConstant<isScalar, T>(
+        input,
+        constantVector->size(),
+        constantVector->mayHaveNulls(),
+        arrowArray);
+
+    arrowArray.release(&arrowArray);
+    EXPECT_EQ(nullptr, arrowArray.release);
+    EXPECT_EQ(nullptr, arrowArray.private_data);
+  }
+
+  // Helper functions for verification.
+
+  template <typename T>
+  void validateArray(
+      const std::vector<std::optional<T>>& inputData,
+      const ArrowArray& arrowArray) {
+    const bool isString =
+        std::is_same_v<T, StringView> or std::is_same_v<T, std::string>;
 
-    size_t nullCount =
-        std::count(inputData.begin(), inputData.end(), std::nullopt);
     EXPECT_EQ(inputData.size(), arrowArray.length);
-    EXPECT_EQ(nullCount, arrowArray.null_count);
     EXPECT_EQ(0, arrowArray.offset);
     EXPECT_EQ(0, arrowArray.n_children);
 
     EXPECT_EQ(nullptr, arrowArray.children);
     EXPECT_EQ(nullptr, arrowArray.dictionary);
+    EXPECT_NE(nullptr, arrowArray.release);
+
+    validateNulls(inputData, arrowArray);
 
     // Validate array contents.
     if constexpr (isString) {
@@ -66,26 +130,20 @@ class ArrowBridgeArrayExportTest : public testing::Test {
     } else {
       validateNumericalArray(inputData, arrowArray);
     }
-
-    arrowArray.release(&arrowArray);
-    EXPECT_EQ(nullptr, arrowArray.release);
-    EXPECT_EQ(nullptr, arrowArray.private_data);
   }
 
   template <typename T>
   void validateNumericalArray(
       const std::vector<std::optional<T>>& inputData,
       const ArrowArray& arrowArray) {
+    using TArrow = typename VeloxToArrowType<T>::type;
+
     ASSERT_EQ(2, arrowArray.n_buffers); // null and values buffers.
+    ASSERT_NE(nullptr, arrowArray.buffers);
 
     const uint64_t* nulls = static_cast<const uint64_t*>(arrowArray.buffers[0]);
-    const T* values = static_cast<const T*>(arrowArray.buffers[1]);
+    const TArrow* values = static_cast<const TArrow*>(arrowArray.buffers[1]);
 
-    if (arrowArray.null_count == 0) {
-      EXPECT_EQ(nulls, nullptr);
-    } else {
-      EXPECT_NE(nulls, nullptr);
-    }
     EXPECT_NE(values, nullptr);
 
     for (size_t i = 0; i < inputData.size(); ++i) {
@@ -100,9 +158,14 @@ class ArrowBridgeArrayExportTest : public testing::Test {
         if constexpr (std::is_same_v<T, bool>) {
           EXPECT_EQ(
               inputData[i],
-              bits::isBitSet(reinterpret_cast<const uint64_t*>(values), i));
+              bits::isBitSet(reinterpret_cast<const uint64_t*>(values), i))
+              << "mismatch at index " << i;
+        } else if constexpr (std::is_same_v<T, Timestamp>) {
+          EXPECT_TRUE(validateTimestamp(
+              inputData[i].value(), options_.timestampUnit, values[i]))
+              << "mismatch at index " << i;
         } else {
-          EXPECT_EQ(inputData[i], values[i]);
+          EXPECT_EQ(inputData[i], values[i]) << "mismatch at index " << i;
         }
       }
     }
@@ -113,16 +176,12 @@ class ArrowBridgeArrayExportTest : public testing::Test {
       const std::vector<std::optional<T>>& inputData,
       const ArrowArray& arrowArray) {
     ASSERT_EQ(3, arrowArray.n_buffers); // null, values, and offsets buffers.
+    ASSERT_NE(nullptr, arrowArray.buffers);
 
     const uint64_t* nulls = static_cast<const uint64_t*>(arrowArray.buffers[0]);
     const char* values = static_cast<const char*>(arrowArray.buffers[2]);
     const int32_t* offsets = static_cast<const int32_t*>(arrowArray.buffers[1]);
 
-    if (arrowArray.null_count == 0) {
-      EXPECT_EQ(nulls, nullptr);
-    } else {
-      EXPECT_NE(nulls, nullptr);
-    }
     EXPECT_NE(values, nullptr);
     EXPECT_NE(offsets, nullptr);
 
@@ -143,6 +202,114 @@ class ArrowBridgeArrayExportTest : public testing::Test {
     }
   }
 
+  // Validate nulls and returns whether this array uses Arrow's Null Layout.
+  template <typename T>
+  void validateNulls(
+      const std::vector<std::optional<T>>& inputData,
+      const ArrowArray& arrowArray) {
+    size_t nullCount =
+        std::count(inputData.begin(), inputData.end(), std::nullopt);
+    EXPECT_EQ(arrowArray.null_count, nullCount);
+
+    if (arrowArray.null_count == 0) {
+      EXPECT_EQ(arrowArray.buffers[0], nullptr);
+    } else {
+      EXPECT_NE(arrowArray.buffers[0], nullptr);
+      EXPECT_EQ(
+          arrowArray.null_count,
+          bits::countNulls(
+              static_cast<const uint64_t*>(arrowArray.buffers[0]),
+              0,
+              inputData.size()));
+    }
+  }
+
+  template <typename T>
+  void validateListArray(
+      const std::vector<std::optional<std::vector<std::optional<T>>>>&
+          inputData,
+      const ArrowArray& arrowArray) {
+    const bool isString =
+        std::is_same_v<T, StringView> or std::is_same_v<T, std::string>;
+
+    EXPECT_EQ(inputData.size(), arrowArray.length);
+    EXPECT_EQ(0, arrowArray.offset);
+    EXPECT_EQ(1, arrowArray.n_children);
+
+    EXPECT_NE(nullptr, arrowArray.children);
+    EXPECT_EQ(nullptr, arrowArray.dictionary);
+    EXPECT_NE(nullptr, arrowArray.release);
+
+    validateNulls(inputData, arrowArray);
+
+    std::vector<std::optional<T>> flattenedData;
+    for (const auto& item : inputData) {
+      if (item) {
+        flattenedData.insert(flattenedData.end(), item->begin(), item->end());
+      }
+    }
+
+    // Validate offsets.
+    auto* offsets = static_cast<const vector_size_t*>(arrowArray.buffers[1]);
+    vector_size_t offset = 0;
+
+    for (size_t i = 0; i < inputData.size(); ++i) {
+      if (inputData[i]) {
+        EXPECT_EQ(offset, offsets[i]);
+        offset += inputData[i]->size();
+      }
+    }
+    EXPECT_EQ(offset, offsets[inputData.size()]); // validate last offset.
+
+    // Validate child array contents.
+    auto* childArray = arrowArray.children[0];
+
+    if constexpr (isString) {
+      validateStringArray(flattenedData, *childArray);
+    } else {
+      validateNumericalArray(flattenedData, *childArray);
+    }
+  }
+
+  template <bool isScalar, typename T, typename TInput>
+  void validateConstant(
+      const TInput& inputData,
+      size_t vectorSize,
+      bool isNullConstant,
+      const ArrowArray& arrowArray) {
+    using TRunEnds = int32_t;
+
+    // Validate base REE array.
+    EXPECT_EQ(vectorSize, arrowArray.length);
+    if (isNullConstant) {
+      EXPECT_EQ(vectorSize, arrowArray.null_count);
+    } else {
+      EXPECT_EQ(0, arrowArray.null_count);
+    }
+    EXPECT_EQ(0, arrowArray.offset);
+    EXPECT_EQ(0, arrowArray.n_buffers);
+    EXPECT_EQ(nullptr, arrowArray.buffers);
+    EXPECT_EQ(nullptr, arrowArray.dictionary);
+    EXPECT_NE(nullptr, arrowArray.release);
+
+    // Validate children.
+    EXPECT_EQ(2, arrowArray.n_children); // run_ends and values children.
+    EXPECT_NE(nullptr, arrowArray.children);
+
+    const auto& runEnds = *arrowArray.children[0];
+    const auto& values = *arrowArray.children[1];
+
+    // Validate values.
+    if constexpr (isScalar) {
+      validateArray<T>({inputData}, values);
+    } else {
+      validateListArray<T>({{{inputData}}}, values);
+    }
+
+    // Validate run ends - single run of the vector size.
+    validateArray<TRunEnds>({vectorSize}, runEnds);
+  }
+
   ArrowSchema makeArrowSchema(const char* format) {
     return ArrowSchema{
         .format = format,
@@ -186,11 +353,43 @@ class ArrowBridgeArrayExportTest : public testing::Test {
     return ans;
   }
 
+  void exportToArrow(const TypePtr& type, ArrowSchema& out) {
+    velox::exportToArrow(
+        BaseVector::create(type, 0, pool_.get()), out, options_);
+  }
+
   // Boiler plate structures required by vectorMaker.
-  std::shared_ptr<core::QueryCtx> queryCtx_{std::make_shared<core::QueryCtx>()};
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  ArrowOptions options_;
+  std::shared_ptr<core::QueryCtx> queryCtx_{velox::core::QueryCtx::create()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   core::ExecCtx execCtx_{pool_.get(), queryCtx_.get()};
   facebook::velox::test::VectorMaker vectorMaker_{execCtx_.pool()};
+
+ private:
+  // Converts timestamp as bigint according to unit, and compares it with the
+  // actual value.
+  bool
+  validateTimestamp(Timestamp ts, TimestampUnit unit, int64_t actualValue) {
+    int64_t expectedValue;
+    switch (unit) {
+      case TimestampUnit::kSecond:
+        expectedValue = ts.getSeconds();
+        break;
+      case TimestampUnit::kMilli:
+        expectedValue = ts.toMillis();
+        break;
+      case TimestampUnit::kMicro:
+        expectedValue = ts.toMicros();
+        break;
+      case TimestampUnit::kNano:
+        expectedValue = ts.toNanos();
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+    return expectedValue == actualValue;
+  }
 };
 
 TEST_F(ArrowBridgeArrayExportTest, flatNotNull) {
@@ -200,7 +399,7 @@ TEST_F(ArrowBridgeArrayExportTest, flatNotNull) {
     // Make sure that ArrowArray is correctly acquiring ownership, even after
     // the initial vector shared_ptr is gone.
     auto flatVector = vectorMaker_.flatVector(inputData);
-    exportToArrow(flatVector, arrowArray, pool_.get());
+    velox::exportToArrow(flatVector, arrowArray, pool_.get(), options_);
   }
 
   EXPECT_EQ(inputData.size(), arrowArray.length);
@@ -322,6 +521,32 @@ TEST_F(ArrowBridgeArrayExportTest, flatDate) {
       DATE());
 }
 
+TEST_F(ArrowBridgeArrayExportTest, flatTimestamp) {
+  for (TimestampUnit unit :
+       {TimestampUnit::kSecond,
+        TimestampUnit::kMilli,
+        TimestampUnit::kMicro,
+        TimestampUnit::kNano}) {
+    options_.timestampUnit = unit;
+    testFlatVector<Timestamp>(
+        {
+            Timestamp(0, 0),
+            std::nullopt,
+            Timestamp(1699300965, 12'349),
+            Timestamp(-2208960000, 0), // 1900-01-01
+            Timestamp(3155788800, 999'999'999),
+            std::nullopt,
+        },
+        TIMESTAMP());
+  }
+
+  // Out of range. If nanosecond precision is represented in Arrow, timestamps
+  // starting around 2263-01-01 should overflow and throw a user exception.
+  EXPECT_THROW(
+      testFlatVector<Timestamp>({Timestamp(9246211200, 0)}, TIMESTAMP()),
+      VeloxUserError);
+}
+
 TEST_F(ArrowBridgeArrayExportTest, flatString) {
   testFlatVector<std::string>({
       "my string",
@@ -352,7 +577,7 @@ TEST_F(ArrowBridgeArrayExportTest, rowVector) {
   });
 
   ArrowArray arrowArray;
-  exportToArrow(vector, arrowArray, pool_.get());
+  velox::exportToArrow(vector, arrowArray, pool_.get(), options_);
 
   EXPECT_EQ(col1.size(), arrowArray.length);
   EXPECT_EQ(0, arrowArray.null_count);
@@ -389,7 +614,7 @@ TEST_F(ArrowBridgeArrayExportTest, rowVectorNullable) {
   vector->setNullCount(3);
 
   ArrowArray arrowArray;
-  exportToArrow(vector, arrowArray, pool_.get());
+  velox::exportToArrow(vector, arrowArray, pool_.get(), options_);
 
   EXPECT_EQ(col1.size(), arrowArray.length);
   EXPECT_EQ(3, arrowArray.null_count);
@@ -417,7 +642,8 @@ TEST_F(ArrowBridgeArrayExportTest, rowVectorNullable) {
 
 TEST_F(ArrowBridgeArrayExportTest, rowVectorEmpty) {
   ArrowArray arrowArray;
-  exportToArrow(vectorMaker_.rowVector({}), arrowArray, pool_.get());
+  velox::exportToArrow(
+      vectorMaker_.rowVector({}), arrowArray, pool_.get(), options_);
   EXPECT_EQ(0, arrowArray.n_children);
   EXPECT_EQ(1, arrowArray.n_buffers);
   EXPECT_EQ(nullptr, arrowArray.children);
@@ -425,13 +651,53 @@ TEST_F(ArrowBridgeArrayExportTest, rowVectorEmpty) {
   arrowArray.release(&arrowArray);
 }
 
+// Generates row vector with children longer than its size to ensure it doesn't
+// break export.
+TEST_F(ArrowBridgeArrayExportTest, rowVectorLongerChildren) {
+  auto identity = [](auto row) { return row; };
+
+  // VectorMaker sets the RowVector size to the size of the first vector in the
+  // list.
+  const size_t rowVectorSize = 2;
+
+  auto vector = vectorMaker_.rowVector({
+      vectorMaker_.flatVector<int64_t>(rowVectorSize),
+      vectorMaker_.flatVector<double>(1024),
+      vectorMaker_.arrayVector<int64_t>(128, identity, identity),
+      vectorMaker_.mapVector<int64_t, int64_t>(
+          64, identity, identity, identity),
+  });
+
+  ArrowArray arrowArray;
+  velox::exportToArrow(vector, arrowArray, pool_.get(), options_);
+
+  EXPECT_EQ(vector->size(), arrowArray.length);
+  EXPECT_EQ(0, arrowArray.null_count);
+  EXPECT_EQ(0, arrowArray.offset);
+  EXPECT_EQ(1, arrowArray.n_buffers);
+  EXPECT_EQ(nullptr, arrowArray.dictionary);
+
+  EXPECT_EQ(vector->childrenSize(), arrowArray.n_children);
+  EXPECT_NE(nullptr, arrowArray.children);
+
+  EXPECT_EQ(2, arrowArray.children[0]->length);
+  EXPECT_EQ(2, arrowArray.children[1]->length);
+  EXPECT_EQ(2, arrowArray.children[2]->length);
+  EXPECT_EQ(2, arrowArray.children[3]->length);
+
+  arrowArray.release(&arrowArray);
+  EXPECT_EQ(nullptr, arrowArray.release);
+  EXPECT_EQ(nullptr, arrowArray.private_data);
+}
+
 std::shared_ptr<arrow::Array> toArrow(
     const VectorPtr& vec,
+    const ArrowOptions& options,
     memory::MemoryPool* pool) {
   ArrowSchema schema;
   ArrowArray array;
-  exportToArrow(vec, schema);
-  exportToArrow(vec, array, pool);
+  exportToArrow(vec, schema, options);
+  exportToArrow(vec, array, pool, options);
   EXPECT_OK_AND_ASSIGN(auto type, arrow::ImportType(&schema));
   EXPECT_OK_AND_ASSIGN(auto ans, arrow::ImportArray(&array, type));
   return ans;
@@ -447,9 +713,25 @@ void validateOffsets(
   }
 }
 
+template <typename T>
+using TArrayContainer =
+    std::vector<std::optional<std::vector<std::optional<T>>>>;
+
 TEST_F(ArrowBridgeArrayExportTest, arraySimple) {
+  TArrayContainer<int64_t> data1 = {{{1, 2, 3}}, {{4, 5}}};
+  testArrayVector(data1);
+
+  TArrayContainer<int64_t> data2 = {
+      {{1, 2, 3}}, std::nullopt, {{4, std::nullopt, 5}}};
+  testArrayVector(data2);
+
+  TArrayContainer<StringView> data3 = {{{"a", "b", "c"}}, {{"d", "e"}}};
+  testArrayVector(data3);
+}
+
+TEST_F(ArrowBridgeArrayExportTest, arrayCrossValidate) {
   auto vec = vectorMaker_.arrayVector<int64_t>({{1, 2, 3}, {4, 5}});
-  auto array = toArrow(vec, pool_.get());
+  auto array = toArrow(vec, options_, pool_.get());
   ASSERT_OK(array->ValidateFull());
   EXPECT_EQ(array->null_count(), 0);
   ASSERT_EQ(*array->type(), *arrow::list(arrow::int64()));
@@ -463,6 +745,28 @@ TEST_F(ArrowBridgeArrayExportTest, arraySimple) {
   }
 }
 
+TEST_F(ArrowBridgeArrayExportTest, arrayDictionary) {
+  auto vec = ({
+    auto indices = makeBuffer<vector_size_t>({1, 2, 0});
+    auto wrapped = vectorMaker_.flatVector<int64_t>({1, 2, 3});
+    auto inner = BaseVector::wrapInDictionary(nullptr, indices, 3, wrapped);
+    auto offsets = makeBuffer<vector_size_t>({2, 0});
+    auto sizes = makeBuffer<vector_size_t>({1, 1});
+    std::make_shared<ArrayVector>(
+        pool_.get(), ARRAY(inner->type()), nullptr, 2, offsets, sizes, inner);
+  });
+
+  ArrowSchema schema;
+  ArrowArray data;
+  velox::exportToArrow(vec, schema, options_);
+  velox::exportToArrow(vec, data, vec->pool(), options_);
+
+  auto result = importFromArrowAsViewer(schema, data, vec->pool());
+  test::assertEqualVectors(result, vec);
+  schema.release(&schema);
+  data.release(&data);
+}
+
 TEST_F(ArrowBridgeArrayExportTest, arrayGap) {
   auto elements = vectorMaker_.flatVector<int64_t>({1, 2, 3, 4, 5});
   elements->setNull(3, true);
@@ -471,7 +775,7 @@ TEST_F(ArrowBridgeArrayExportTest, arrayGap) {
   auto sizes = makeBuffer<vector_size_t>({2, 2});
   auto vec = std::make_shared<ArrayVector>(
       pool_.get(), ARRAY(BIGINT()), nullptr, 2, offsets, sizes, elements);
-  auto array = toArrow(vec, pool_.get());
+  auto array = toArrow(vec, options_, pool_.get());
   ASSERT_OK(array->ValidateFull());
   EXPECT_EQ(array->null_count(), 0);
   ASSERT_EQ(*array->type(), *arrow::list(arrow::int64()));
@@ -496,7 +800,7 @@ TEST_F(ArrowBridgeArrayExportTest, arrayReorder) {
   auto sizes = makeBuffer<vector_size_t>({2, 2});
   auto vec = std::make_shared<ArrayVector>(
       pool_.get(), ARRAY(BIGINT()), nullptr, 2, offsets, sizes, elements);
-  auto array = toArrow(vec, pool_.get());
+  auto array = toArrow(vec, options_, pool_.get());
   ASSERT_OK(array->ValidateFull());
   EXPECT_EQ(array->null_count(), 0);
   ASSERT_EQ(*array->type(), *arrow::list(arrow::int64()));
@@ -526,7 +830,7 @@ TEST_F(ArrowBridgeArrayExportTest, arrayNested) {
     std::make_shared<ArrayVector>(
         pool_.get(), ARRAY(inner->type()), nullptr, 2, offsets, sizes, inner);
   });
-  auto array = toArrow(vec, pool_.get());
+  auto array = toArrow(vec, options_, pool_.get());
   ASSERT_OK(array->ValidateFull());
   ASSERT_EQ(*array->type(), *arrow::list(arrow::list(arrow::int64())));
   auto& listArray = static_cast<const arrow::ListArray&>(*array);
@@ -543,7 +847,7 @@ TEST_F(ArrowBridgeArrayExportTest, mapSimple) {
   auto allOnes = [](vector_size_t) { return 1; };
   auto vec =
       vectorMaker_.mapVector<int64_t, int64_t>(2, allOnes, allOnes, allOnes);
-  auto array = toArrow(vec, pool_.get());
+  auto array = toArrow(vec, options_, pool_.get());
   ASSERT_OK(array->ValidateFull());
   EXPECT_EQ(array->null_count(), 0);
   ASSERT_EQ(*array->type(), *arrow::map(arrow::int64(), arrow::int64()));
@@ -578,7 +882,7 @@ TEST_F(ArrowBridgeArrayExportTest, mapNested) {
     std::make_shared<MapVector>(
         pool_.get(), type, nullptr, 2, offsets, sizes, keys, inner);
   });
-  auto array = toArrow(vec, pool_.get());
+  auto array = toArrow(vec, options_, pool_.get());
   ASSERT_OK(array->ValidateFull());
   EXPECT_EQ(array->null_count(), 0);
   ASSERT_EQ(
@@ -604,13 +908,61 @@ TEST_F(ArrowBridgeArrayExportTest, mapNested) {
   EXPECT_EQ(values.Value(1), 0);
 }
 
+TEST_F(ArrowBridgeArrayExportTest, mapTimestamp) {
+  const auto keys =
+      vectorMaker_.flatVector<int32_t>(5, [](vector_size_t i) { return i; });
+  auto values = vectorMaker_.flatVector<Timestamp>(
+      5, [](vector_size_t row) { return Timestamp(row, row); });
+  const auto offsets = makeBuffer<vector_size_t>({1, 4, 2});
+  const auto sizes = makeBuffer<vector_size_t>({1, 1, 1});
+  const auto type = MAP(INTEGER(), TIMESTAMP());
+  auto vec = std::make_shared<MapVector>(
+      pool_.get(), type, nullptr, 3, offsets, sizes, keys, values);
+  auto array = toArrow(vec, options_, pool_.get());
+  ASSERT_OK(array->ValidateFull());
+  EXPECT_EQ(array->null_count(), 0);
+  ASSERT_EQ(
+      *array->type(),
+      *arrow::map(arrow::int32(), arrow::timestamp(arrow::TimeUnit::NANO)));
+  {
+    auto& mapArray = static_cast<const arrow::MapArray&>(*array);
+    auto& values = static_cast<const arrow::TimestampArray&>(*mapArray.items());
+    ASSERT_EQ(values.length(), 3);
+    EXPECT_EQ(values.Value(0), 1'000'000'001L);
+    EXPECT_EQ(values.Value(1), 4'000'000'004L);
+    EXPECT_EQ(values.Value(2), 2'000'000'002L);
+  }
+
+  // Nullable timestamp vector.
+  values = vectorMaker_.flatVector<Timestamp>(
+      5,
+      [](vector_size_t row) { return Timestamp(row, row); },
+      [](vector_size_t row) { return row % 2 == 1; });
+  vec = std::make_shared<MapVector>(
+      pool_.get(), type, nullptr, 3, offsets, sizes, keys, values);
+  array = toArrow(vec, options_, pool_.get());
+  ASSERT_OK(array->ValidateFull());
+  EXPECT_EQ(array->null_count(), 0);
+  ASSERT_EQ(
+      *array->type(),
+      *arrow::map(arrow::int32(), arrow::timestamp(arrow::TimeUnit::NANO)));
+  {
+    auto& mapArray = static_cast<const arrow::MapArray&>(*array);
+    auto& values = static_cast<const arrow::TimestampArray&>(*mapArray.items());
+    ASSERT_EQ(values.length(), 3);
+    EXPECT_TRUE(values.IsNull(0));
+    EXPECT_EQ(values.Value(1), 4'000'000'004L);
+    EXPECT_EQ(values.Value(2), 2'000'000'002L);
+  }
+}
+
 TEST_F(ArrowBridgeArrayExportTest, dictionarySimple) {
   auto vec = BaseVector::wrapInDictionary(
       nullptr,
       allocateIndices(3, pool_.get()),
       3,
       vectorMaker_.flatVector<int64_t>({1, 2, 3}));
-  auto array = toArrow(vec, pool_.get());
+  auto array = toArrow(vec, options_, pool_.get());
   ASSERT_OK(array->ValidateFull());
   ASSERT_EQ(*array->type(), *arrow::dictionary(arrow::int32(), arrow::int64()));
   auto& dict = static_cast<const arrow::DictionaryArray&>(*array);
@@ -636,7 +988,7 @@ TEST_F(ArrowBridgeArrayExportTest, dictionaryNested) {
     std::make_shared<ArrayVector>(
         pool_.get(), ARRAY(inner->type()), nullptr, 2, offsets, sizes, inner);
   });
-  auto array = toArrow(vec, pool_.get());
+  auto array = toArrow(vec, options_, pool_.get());
   ASSERT_OK(array->ValidateFull());
   ASSERT_EQ(
       *array->type(),
@@ -655,17 +1007,59 @@ TEST_F(ArrowBridgeArrayExportTest, dictionaryNested) {
   EXPECT_EQ(values.Value(2), 3);
 }
 
-TEST_F(ArrowBridgeArrayExportTest, unsupported) {
-  ArrowArray arrowArray;
-  VectorPtr vector;
+TEST_F(ArrowBridgeArrayExportTest, constants) {
+  testConstant((int64_t)987654321);
+  testConstant((int32_t)1234);
+  testConstant((float)44.3);
+  testConstant(true);
+  testConstant(StringView("inlined"));
+
+  // Null constant.
+  VectorPtr vector =
+      BaseVector::createNullConstant(TINYINT(), 2048, pool_.get());
+  testConstantVector<true, int8_t>(
+      vector, std::vector<std::optional<int8_t>>{std::nullopt});
+}
+
+TEST_F(ArrowBridgeArrayExportTest, constantComplex) {
+  auto innerArray =
+      vectorMaker_.arrayVector<int64_t>({{1, 2, 3}, {4, 5}, {6, 7, 8, 9}});
+
+  // Wrap around different indices.
+  VectorPtr vector = BaseVector::wrapInConstant(100, 1, innerArray);
+  testConstantVector<false, int64_t>(
+      vector, std::vector<std::optional<int64_t>>{4, 5});
+
+  vector = BaseVector::wrapInConstant(100, 0, innerArray);
+  testConstantVector<false, int64_t>(
+      vector, std::vector<std::optional<int64_t>>{1, 2, 3});
+}
+
+TEST_F(ArrowBridgeArrayExportTest, constantCrossValidate) {
+  auto vector =
+      BaseVector::createConstant(VARCHAR(), "hello", 100, pool_.get());
+  auto array = toArrow(vector, options_, pool_.get());
 
-  // Timestamps.
-  vector = vectorMaker_.flatVectorNullable<Timestamp>({});
-  EXPECT_THROW(exportToArrow(vector, arrowArray, pool_.get()), VeloxException);
+  ASSERT_OK(array->ValidateFull());
+  EXPECT_EQ(array->null_count(), 0);
+  ASSERT_EQ(
+      *array->type(), *arrow::run_end_encoded(arrow::int32(), arrow::utf8()));
+  const auto& reeArray = static_cast<const arrow::RunEndEncodedArray&>(*array);
+
+  const auto& runEnds = reeArray.run_ends();
+  const auto& values = reeArray.values();
 
-  // Constant encoding.
-  vector = BaseVector::createConstant(INTEGER(), variant(10), 10, pool_.get());
-  EXPECT_THROW(exportToArrow(vector, arrowArray, pool_.get()), VeloxException);
+  ASSERT_EQ(*runEnds->type(), *arrow::int32());
+  ASSERT_EQ(*values->type(), *arrow::utf8());
+
+  const auto& valuesArray = static_cast<const arrow::StringArray&>(*values);
+  const auto& runEndsArray = static_cast<const arrow::Int32Array&>(*runEnds);
+
+  ASSERT_EQ(valuesArray.length(), 1);
+  ASSERT_EQ(runEndsArray.length(), 1);
+
+  EXPECT_EQ(valuesArray.GetString(0), std::string("hello"));
+  EXPECT_EQ(runEndsArray.Value(0), 100);
 }
 
 class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
@@ -694,13 +1088,14 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
   ArrowArray fillArrowArray(
       const std::vector<std::optional<T>>& inputValues,
       ArrowContextHolder& holder) {
+    using TArrow = typename VeloxToArrowType<T>::type;
     int64_t length = inputValues.size();
     int64_t nullCount = 0;
 
-    holder.values = AlignedBuffer::allocate<T>(length, pool_.get());
+    holder.values = AlignedBuffer::allocate<TArrow>(length, pool_.get());
     holder.nulls = AlignedBuffer::allocate<uint64_t>(length, pool_.get());
 
-    auto rawValues = holder.values->asMutable<T>();
+    auto rawValues = holder.values->asMutable<TArrow>();
     auto rawNulls = holder.nulls->asMutable<uint64_t>();
 
     for (size_t i = 0; i < length; ++i) {
@@ -772,21 +1167,31 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
   // Takes a vector with input data, generates an input ArrowArray and Velox
   // Vector (using vector maker). Then converts ArrowArray into Velox vector and
   // assert that both Velox vectors are semantically the same.
-  template <typename T>
+  template <typename TOutput, typename TInput = TOutput>
   void testArrowImport(
       const char* format,
-      const std::vector<std::optional<T>>& inputValues) {
+      const std::vector<std::optional<TInput>>& inputValues) {
     ArrowContextHolder holder;
     auto arrowArray = fillArrowArray(inputValues, holder);
 
     auto arrowSchema = makeArrowSchema(format);
     auto output = importFromArrow(arrowSchema, arrowArray, pool_.get());
-    assertVectorContent(inputValues, output, arrowArray.null_count);
+    if constexpr (
+        std::is_same_v<TInput, int64_t> && std::is_same_v<TOutput, Timestamp>) {
+      assertTimestampVectorContent(
+          inputValues, output, arrowArray.null_count, format);
+    } else if constexpr (
+        std::is_same_v<TInput, int128_t> && std::is_same_v<TOutput, int64_t>) {
+      assertShortDecimalVectorContent(
+          inputValues, output, arrowArray.null_count);
+    } else {
+      assertVectorContent(inputValues, output, arrowArray.null_count);
+    }
 
     // Buffer views are not reusable. Strings might need to create an additional
     // buffer, depending on the string sizes, in which case the buffers could be
     // reusable. So we don't check them in here.
-    if constexpr (!std::is_same_v<T, std::string>) {
+    if constexpr (!std::is_same_v<TInput, std::string>) {
       EXPECT_FALSE(BaseVector::isVectorWritable(output));
     } else {
       size_t totalLength = 0;
@@ -857,16 +1262,26 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     testArrowImport<double>("g", {std::nullopt});
     testArrowImport<double>("g", {-99.9, 4.3, 31.1, 129.11, -12});
     testArrowImport<float>("f", {-99.9, 4.3, 31.1, 129.11, -12});
+
+    for (const auto tsString : {"tss:", "tsm:", "tsu:", "tsn:"}) {
+      testArrowImport<Timestamp, int64_t>(
+          tsString, {0, std::nullopt, Timestamp::kMaxSeconds});
+    }
+
+    testArrowImport<int64_t, int128_t>(
+        "d:5,2", {1, -1, 0, 12345, -12345, std::nullopt});
   }
 
-  void testImportWithoutNullsBuffer() {
-    std::vector<std::optional<int64_t>> inputValues = {1, 2, 3, 4, 5};
+  template <typename TOutput, typename TInput>
+  void testImportWithoutNullsBuffer(
+      std::vector<std::optional<TInput>> inputValues,
+      const char* format) {
     auto length = inputValues.size();
 
     // Construct Arrow array without nulls value and nulls buffer
     ArrowContextHolder holder1;
-    holder1.values = AlignedBuffer::allocate<int64_t>(length, pool_.get());
-    auto rawValues1 = holder1.values->asMutable<int64_t>();
+    holder1.values = AlignedBuffer::allocate<TInput>(length, pool_.get());
+    auto rawValues1 = holder1.values->asMutable<TInput>();
     for (size_t i = 0; i < length; ++i) {
       rawValues1[i] = *inputValues[i];
     }
@@ -874,23 +1289,29 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     holder1.buffers[0] = nullptr;
     holder1.buffers[1] = (const void*)rawValues1;
     auto arrowArray1 = makeArrowArray(holder1.buffers, 2, length, 0);
-    auto arrowSchema1 = makeArrowSchema("l");
+    auto arrowSchema1 = makeArrowSchema(format);
 
     auto output = importFromArrow(arrowSchema1, arrowArray1, pool_.get());
-    assertVectorContent(inputValues, output, arrowArray1.null_count);
+    if constexpr (
+        std::is_same_v<TInput, int64_t> && std::is_same_v<TOutput, Timestamp>) {
+      assertTimestampVectorContent(
+          inputValues, output, arrowArray1.null_count, format);
+    } else {
+      assertVectorContent(inputValues, output, arrowArray1.null_count);
+    }
 
     // However, convert from an Arrow array without nulls buffer but non-zero
     // null count should fail
     ArrowContextHolder holder2;
-    holder2.values = AlignedBuffer::allocate<int64_t>(length, pool_.get());
-    auto rawValues2 = holder2.values->asMutable<int64_t>();
+    holder2.values = AlignedBuffer::allocate<TInput>(length, pool_.get());
+    auto rawValues2 = holder2.values->asMutable<TInput>();
     for (size_t i = 0; i < length; ++i) {
       rawValues2[i] = *inputValues[i];
     }
 
     holder2.buffers[0] = nullptr;
     holder2.buffers[1] = (const void*)rawValues2;
-    auto arrowSchema2 = makeArrowSchema("l");
+    auto arrowSchema2 = makeArrowSchema(format);
     auto arrowArray2 = makeArrowArray(holder2.buffers, 2, length, 1);
     EXPECT_THROW(
         importFromArrow(arrowSchema2, arrowArray2, pool_.get()),
@@ -929,6 +1350,62 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
   }
 
  private:
+  // Creates short decimals from int128 and asserts the content of actual vector
+  // with the expected values.
+  void assertShortDecimalVectorContent(
+      const std::vector<std::optional<int128_t>>& expectedValues,
+      const VectorPtr& actual,
+      size_t nullCount) {
+    std::vector<std::optional<int64_t>> decValues;
+    decValues.reserve(expectedValues.size());
+    for (const auto& value : expectedValues) {
+      if (value) {
+        decValues.emplace_back(static_cast<int64_t>(*value));
+      } else {
+        decValues.emplace_back(std::nullopt);
+      }
+    }
+    assertVectorContent(decValues, actual, nullCount);
+  }
+
+  // Creates timestamp from bigint and asserts the content of actual vector with
+  // the expected timestamp values.
+  void assertTimestampVectorContent(
+      const std::vector<std::optional<int64_t>>& expectedValues,
+      const VectorPtr& actual,
+      size_t nullCount,
+      const char* format) {
+    VELOX_USER_CHECK_GE(
+        strlen(format), 3, "At least three characters are expected.");
+    std::vector<std::optional<Timestamp>> tsValues;
+    tsValues.reserve(expectedValues.size());
+    for (const auto& value : expectedValues) {
+      if (!value.has_value()) {
+        tsValues.emplace_back(std::nullopt);
+      } else {
+        Timestamp ts;
+        switch (format[2]) {
+          case 's':
+            ts = Timestamp(value.value(), 0);
+            break;
+          case 'm':
+            ts = Timestamp::fromMillis(value.value());
+            break;
+          case 'u':
+            ts = Timestamp::fromMicros(value.value());
+            break;
+          case 'n':
+            ts = Timestamp::fromNanos(value.value());
+            break;
+          default:
+            VELOX_UNREACHABLE();
+        }
+        tsValues.emplace_back(ts);
+      }
+    }
+    assertVectorContent(tsValues, actual, nullCount);
+  }
+
   void testImportRowFull() {
     // Manually create a ROW type.
     ArrowSchema arrowSchema;
@@ -1016,14 +1493,12 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
   }
 
  private:
-  template <typename F>
-  void testArrowRoundTrip(const arrow::Array& array, F validateVector) {
+  void toVeloxVector(const arrow::Array& array, VectorPtr& outVector) {
     ArrowSchema schema;
     ArrowArray data;
     ASSERT_OK(arrow::ExportType(*array.type(), &schema));
     ASSERT_OK(arrow::ExportArray(array, &data));
-    auto vec = importFromArrow(schema, data, pool_.get());
-    validateVector(*vec);
+    outVector = importFromArrow(schema, data, pool_.get());
     if (isViewer()) {
       // These release calls just decrease the refcount; there are still
       // references to keep the data alive from the original Arrow array.
@@ -1033,8 +1508,21 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
       EXPECT_FALSE(schema.release);
       EXPECT_FALSE(data.release);
     }
-    exportToArrow(vec, schema);
-    exportToArrow(vec, data, pool_.get());
+  }
+
+  template <typename F>
+  void testArrowRoundTrip(
+      const arrow::Array& array,
+      F validateVector,
+      const ArrowOptions& options = ArrowOptions{}) {
+    VectorPtr vec;
+    toVeloxVector(array, vec);
+    validateVector(*vec);
+
+    ArrowSchema schema;
+    ArrowArray data;
+    velox::exportToArrow(vec, schema, options);
+    velox::exportToArrow(vec, data, pool_.get(), options);
     ASSERT_OK_AND_ASSIGN(auto arrowType, arrow::ImportType(&schema));
     ASSERT_OK_AND_ASSIGN(auto array2, arrow::ImportArray(&data, arrowType));
     ASSERT_OK(array2->ValidateFull());
@@ -1097,6 +1585,160 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     });
   }
 
+  void testImportStringView() {
+    arrow::StringViewBuilder sb(arrow::default_memory_pool());
+    ASSERT_OK(sb.Append("hello world", 11));
+    ASSERT_OK(sb.Append("larger string which should not be inlined...", 44));
+    ASSERT_OK(sb.AppendNull());
+    ASSERT_OK(sb.Append("hello", 5));
+    ASSERT_OK(sb.Append("", 0));
+    ASSERT_OK(sb.Append("my string", 9));
+    ASSERT_OK(sb.Append("another slightly longer string", 30));
+    ASSERT_OK(sb.AppendNull());
+    ASSERT_OK(sb.Append("a", 1));
+    ASSERT_OK(sb.Append(
+        "another even longer string to ensure it's for sure not stored inline!!!",
+        71));
+    ASSERT_OK(sb.AppendNull());
+    ASSERT_OK(sb.AppendNull());
+    ASSERT_OK_AND_ASSIGN(auto array, sb.Finish());
+    const void* stringBuffers = array->data()->buffers[2]->data();
+
+    testArrowRoundTrip(
+        *array,
+        [stringBuffers](const BaseVector& vec) {
+          // assert zero-copy import to velox for stringBuffers
+          ASSERT_EQ(
+              vec.asFlatVector<StringView>()
+                  ->stringBuffers()
+                  .data()
+                  ->get()
+                  ->as<void*>(),
+              stringBuffers);
+          ASSERT_EQ(*vec.type(), *VARCHAR());
+          EXPECT_EQ(vec.size(), 12);
+        },
+        ArrowOptions{.exportToStringView = true});
+  }
+
+  void testImportREE() {
+    testImportREENoRuns();
+    testImportREESingleRun();
+    testImportREEMultipleRuns();
+  }
+
+  void testImportREENoRuns() {
+    auto pool = arrow::default_memory_pool();
+
+    arrow::RunEndEncodedBuilder reeInt32(
+        pool,
+        std::make_shared<arrow::Int32Builder>(pool),
+        std::make_shared<arrow::Int32Builder>(pool),
+        run_end_encoded(arrow::int32(), arrow::int32()));
+    ASSERT_OK_AND_ASSIGN(auto array, reeInt32.Finish());
+
+    VectorPtr vector;
+    toVeloxVector(*array, vector);
+
+    ASSERT_EQ(*vector->type(), *INTEGER());
+    EXPECT_EQ(vector->encoding(), VectorEncoding::Simple::CONSTANT);
+    EXPECT_EQ(vector->size(), 0);
+  }
+
+  void testImportREESingleRun() {
+    auto pool = arrow::default_memory_pool();
+
+    // Simple integer column.
+    arrow::RunEndEncodedBuilder reeInt32(
+        pool,
+        std::make_shared<arrow::Int32Builder>(pool),
+        std::make_shared<arrow::Int32Builder>(pool),
+        run_end_encoded(arrow::int32(), arrow::int32()));
+    ASSERT_OK(reeInt32.AppendScalar(*arrow::MakeScalar<int32_t>(123), 20));
+    ASSERT_OK_AND_ASSIGN(auto array, reeInt32.Finish());
+
+    validateImportREESingleRun(*array, INTEGER(), 20);
+
+    // String column.
+    arrow::RunEndEncodedBuilder reeString(
+        pool,
+        std::make_shared<arrow::Int32Builder>(pool),
+        std::make_shared<arrow::StringBuilder>(pool),
+        run_end_encoded(arrow::int32(), arrow::utf8()));
+    ASSERT_OK(reeString.AppendScalar(*arrow::MakeScalar("bla"), 199));
+    ASSERT_OK_AND_ASSIGN(array, reeString.Finish());
+
+    validateImportREESingleRun(*array, VARCHAR(), 199);
+
+    // Array/List.
+    auto valuesBuilder = std::make_shared<arrow::FloatBuilder>(pool);
+    auto listBuilder =
+        std::make_shared<arrow::ListBuilder>(pool, valuesBuilder);
+    ASSERT_OK(listBuilder->Append());
+    ASSERT_OK(valuesBuilder->Append(1.1));
+    ASSERT_OK(valuesBuilder->Append(2.2));
+    ASSERT_OK(valuesBuilder->Append(3.3));
+    ASSERT_OK(valuesBuilder->Append(4.4));
+    ASSERT_OK_AND_ASSIGN(auto listArray, listBuilder->Finish());
+
+    auto runEndBuilder = std::make_shared<arrow::Int32Builder>(pool);
+    ASSERT_OK(runEndBuilder->Append(123));
+    ASSERT_OK_AND_ASSIGN(auto runEndsArray, runEndBuilder->Finish());
+
+    // Create a list containing [1.1, 2.2, 3.3, 4.4] and repeat it 123 times.
+    ASSERT_OK_AND_ASSIGN(
+        array, arrow::RunEndEncodedArray::Make(123, runEndsArray, listArray));
+    validateImportREESingleRun(*array, ARRAY(REAL()), 123);
+  }
+
+  void validateImportREESingleRun(
+      const arrow::Array& array,
+      const TypePtr& expectedType,
+      size_t expectedSize) {
+    testArrowRoundTrip(array, [&](const BaseVector& vec) {
+      ASSERT_EQ(*vec.type(), *expectedType);
+      EXPECT_EQ(vec.encoding(), VectorEncoding::Simple::CONSTANT);
+      EXPECT_EQ(vec.size(), expectedSize);
+    });
+  }
+
+  void testImportREEMultipleRuns() {
+    auto pool = arrow::default_memory_pool();
+
+    // Simple integer column.
+    arrow::RunEndEncodedBuilder reeInt32(
+        pool,
+        std::make_shared<arrow::Int32Builder>(pool),
+        std::make_shared<arrow::Int32Builder>(pool),
+        run_end_encoded(arrow::int32(), arrow::int32()));
+    ASSERT_OK(reeInt32.AppendScalar(*arrow::MakeScalar<int32_t>(123), 20));
+    ASSERT_OK(reeInt32.AppendScalar(*arrow::MakeScalar<int32_t>(321), 2));
+    ASSERT_OK(reeInt32.AppendNulls(10));
+    ASSERT_OK(reeInt32.AppendScalar(*arrow::MakeScalar<int32_t>(50), 30));
+    ASSERT_OK_AND_ASSIGN(auto array, reeInt32.Finish());
+
+    VectorPtr vector;
+    toVeloxVector(*array, vector);
+
+    ASSERT_EQ(*vector->type(), *INTEGER());
+    EXPECT_EQ(vector->encoding(), VectorEncoding::Simple::DICTIONARY);
+    EXPECT_EQ(vector->size(), 62);
+
+    DecodedVector decoded(*vector);
+    EXPECT_TRUE(decoded.mayHaveNulls());
+    EXPECT_FALSE(decoded.isNullAt(0));
+    EXPECT_EQ(decoded.valueAt<int32_t>(0), 123);
+    EXPECT_EQ(decoded.valueAt<int32_t>(1), 123);
+    EXPECT_EQ(decoded.valueAt<int32_t>(19), 123);
+    EXPECT_EQ(decoded.valueAt<int32_t>(20), 321);
+    EXPECT_EQ(decoded.valueAt<int32_t>(21), 321);
+    EXPECT_TRUE(decoded.isNullAt(22));
+    EXPECT_TRUE(decoded.isNullAt(31));
+    EXPECT_EQ(decoded.valueAt<int32_t>(32), 50);
+    EXPECT_EQ(decoded.valueAt<int32_t>(33), 50);
+    EXPECT_EQ(decoded.valueAt<int32_t>(61), 50);
+  }
+
   void testImportFailures() {
     ArrowSchema arrowSchema;
     ArrowArray arrowArray;
@@ -1155,7 +1797,8 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     EXPECT_NO_THROW(importFromArrow(arrowSchema, arrowArray, pool_.get()));
   }
 
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 class ArrowBridgeArrayImportAsViewerTest : public ArrowBridgeArrayImportTest {
@@ -1177,13 +1820,19 @@ TEST_F(ArrowBridgeArrayImportAsViewerTest, scalar) {
 }
 
 TEST_F(ArrowBridgeArrayImportAsViewerTest, without_nulls_buffer) {
-  testImportWithoutNullsBuffer();
+  std::vector<std::optional<int64_t>> inputValues = {1, 2, 3, 4, 5};
+  testImportWithoutNullsBuffer<int64_t>(inputValues, "l");
+  testImportWithoutNullsBuffer<Timestamp>(inputValues, "tsn:");
 }
 
 TEST_F(ArrowBridgeArrayImportAsViewerTest, string) {
   testImportString();
 }
 
+TEST_F(ArrowBridgeArrayImportAsViewerTest, stringview) {
+  testImportStringView();
+}
+
 TEST_F(ArrowBridgeArrayImportAsViewerTest, row) {
   testImportRow();
 }
@@ -1200,6 +1849,10 @@ TEST_F(ArrowBridgeArrayImportAsViewerTest, dictionary) {
   testImportDictionary();
 }
 
+TEST_F(ArrowBridgeArrayImportAsViewerTest, ree) {
+  testImportREE();
+}
+
 TEST_F(ArrowBridgeArrayImportAsViewerTest, failures) {
   testImportFailures();
 }
@@ -1224,13 +1877,19 @@ TEST_F(ArrowBridgeArrayImportAsOwnerTest, scalar) {
 }
 
 TEST_F(ArrowBridgeArrayImportAsOwnerTest, without_nulls_buffer) {
-  testImportWithoutNullsBuffer();
+  std::vector<std::optional<int64_t>> inputValues = {1, 2, 3, 4, 5};
+  testImportWithoutNullsBuffer<int64_t>(inputValues, "l");
+  testImportWithoutNullsBuffer<Timestamp>(inputValues, "tsn:");
 }
 
 TEST_F(ArrowBridgeArrayImportAsOwnerTest, string) {
   testImportString();
 }
 
+TEST_F(ArrowBridgeArrayImportAsOwnerTest, stringview) {
+  testImportStringView();
+}
+
 TEST_F(ArrowBridgeArrayImportAsOwnerTest, row) {
   testImportRow();
 }
@@ -1247,6 +1906,10 @@ TEST_F(ArrowBridgeArrayImportAsOwnerTest, dictionary) {
   testImportDictionary();
 }
 
+TEST_F(ArrowBridgeArrayImportAsOwnerTest, ree) {
+  testImportREE();
+}
+
 TEST_F(ArrowBridgeArrayImportAsOwnerTest, failures) {
   testImportFailures();
 }
@@ -1298,3 +1961,4 @@ TEST_F(ArrowBridgeArrayImportAsOwnerTest, releaseCalled) {
 }
 
 } // namespace
+} // namespace facebook::velox::test
diff --git a/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp b/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
index 9b3a1ad3c8b92..998a7ede61827 100644
--- a/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
+++ b/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
@@ -22,33 +22,50 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/vector/arrow/Bridge.h"
 
+namespace facebook::velox::test {
 namespace {
 
-using namespace facebook::velox;
 static void mockRelease(ArrowSchema*) {}
 
-void exportToArrow(const TypePtr& type, ArrowSchema& out) {
-  auto pool = &facebook::velox::memory::deprecatedSharedLeafPool();
-  exportToArrow(BaseVector::create(type, 0, pool), out);
-}
-
 class ArrowBridgeSchemaExportTest : public testing::Test {
  protected:
-  void testScalarType(const TypePtr& type, const char* arrowFormat) {
-    ArrowSchema arrowSchema;
-    exportToArrow(type, arrowSchema);
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
 
-    EXPECT_EQ(std::string{arrowFormat}, std::string{arrowSchema.format});
-    EXPECT_EQ(nullptr, arrowSchema.name);
+  void testScalarType(
+      const TypePtr& type,
+      const char* arrowFormat,
+      const ArrowOptions& options = ArrowOptions{}) {
+    ArrowSchema arrowSchema;
+    exportToArrow(type, arrowSchema, options);
 
-    EXPECT_EQ(0, arrowSchema.n_children);
-    EXPECT_EQ(nullptr, arrowSchema.children);
+    verifyScalarType(arrowSchema, arrowFormat);
 
     arrowSchema.release(&arrowSchema);
     EXPECT_EQ(nullptr, arrowSchema.release);
     EXPECT_EQ(nullptr, arrowSchema.private_data);
   }
 
+  void verifyScalarType(
+      const ArrowSchema& arrowSchema,
+      const char* arrowFormat,
+      const char* name = nullptr) {
+    EXPECT_STREQ(arrowFormat, arrowSchema.format);
+    if (name == nullptr) {
+      EXPECT_EQ(nullptr, arrowSchema.name);
+    } else {
+      EXPECT_STREQ(name, arrowSchema.name);
+    }
+    EXPECT_EQ(nullptr, arrowSchema.metadata);
+    EXPECT_EQ(arrowSchema.flags | ARROW_FLAG_NULLABLE, ARROW_FLAG_NULLABLE);
+
+    EXPECT_EQ(0, arrowSchema.n_children);
+    EXPECT_EQ(nullptr, arrowSchema.children);
+    EXPECT_EQ(nullptr, arrowSchema.dictionary);
+    EXPECT_NE(nullptr, arrowSchema.release);
+  }
+
   // Doesn't check the actual format string of the scalar leaf types (this is
   // tested by the function above), but tests that the types are nested in the
   // correct way.
@@ -65,13 +82,13 @@ class ArrowBridgeSchemaExportTest : public testing::Test {
 
   void verifyNestedType(const TypePtr& type, ArrowSchema* schema) {
     if (type->kind() == TypeKind::ARRAY) {
-      EXPECT_EQ(std::string{"+l"}, std::string{schema->format});
+      EXPECT_STREQ("+l", schema->format);
     } else if (type->kind() == TypeKind::MAP) {
-      EXPECT_EQ(std::string{"+m"}, std::string{schema->format});
+      EXPECT_STREQ("+m", schema->format);
       ASSERT_EQ(schema->n_children, 1);
       schema = schema->children[0];
     } else if (type->kind() == TypeKind::ROW) {
-      EXPECT_EQ(std::string{"+s"}, std::string{schema->format});
+      EXPECT_STREQ("+s", schema->format);
     }
     // Scalar type.
     else {
@@ -91,6 +108,66 @@ class ArrowBridgeSchemaExportTest : public testing::Test {
     }
   }
 
+  void testConstant(
+      const TypePtr& type,
+      const char* arrowFormat,
+      const ArrowOptions& options = ArrowOptions{}) {
+    ArrowSchema arrowSchema;
+    const bool isScalar = (type->size() == 0);
+    const bool constantSize = 100;
+
+    // If scalar, create the constant vector directly; if complex type, create a
+    // complex vector first, then wrap it in a dictionary.
+    auto constantVector = isScalar
+        ? BaseVector::createConstant(
+              type, variant(type->kind()), constantSize, pool_.get())
+        : BaseVector::wrapInConstant(
+              constantSize,
+              3, // index to use for the constant
+              BaseVector::create(type, 100, pool_.get()));
+
+    velox::exportToArrow(constantVector, arrowSchema, options);
+
+    EXPECT_STREQ("+r", arrowSchema.format);
+    EXPECT_EQ(nullptr, arrowSchema.name);
+
+    EXPECT_EQ(2, arrowSchema.n_children);
+    EXPECT_NE(nullptr, arrowSchema.children);
+    EXPECT_EQ(nullptr, arrowSchema.dictionary);
+
+    // Validate run_ends.
+    EXPECT_NE(nullptr, arrowSchema.children[0]);
+    const auto& runEnds = *arrowSchema.children[0];
+
+    EXPECT_STREQ("i", runEnds.format);
+    EXPECT_STREQ("run_ends", runEnds.name);
+    EXPECT_EQ(0, runEnds.n_children);
+    EXPECT_EQ(nullptr, runEnds.children);
+    EXPECT_EQ(nullptr, runEnds.dictionary);
+
+    // Validate values.
+    EXPECT_NE(nullptr, arrowSchema.children[1]);
+
+    if (isScalar) {
+      verifyScalarType(*arrowSchema.children[1], arrowFormat, "values");
+    } else {
+      EXPECT_STREQ(arrowFormat, arrowSchema.children[1]->format);
+      verifyNestedType(type, arrowSchema.children[1]);
+    }
+
+    arrowSchema.release(&arrowSchema);
+    EXPECT_EQ(nullptr, arrowSchema.release);
+    EXPECT_EQ(nullptr, arrowSchema.private_data);
+  }
+
+  void exportToArrow(
+      const TypePtr& type,
+      ArrowSchema& out,
+      const ArrowOptions& options = ArrowOptions{}) {
+    velox::exportToArrow(
+        BaseVector::create(type, 0, pool_.get()), out, options);
+  }
+
   ArrowSchema makeArrowSchema(const char* format) {
     return ArrowSchema{
         .format = format,
@@ -104,6 +181,9 @@ class ArrowBridgeSchemaExportTest : public testing::Test {
         .private_data = nullptr,
     };
   }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 TEST_F(ArrowBridgeSchemaExportTest, scalar) {
@@ -120,11 +200,41 @@ TEST_F(ArrowBridgeSchemaExportTest, scalar) {
   testScalarType(VARCHAR(), "u");
   testScalarType(VARBINARY(), "z");
 
-  testScalarType(TIMESTAMP(), "ttn");
+  // Test default timezone
+  testScalarType(
+      TIMESTAMP(), "tss:", {.timestampUnit = TimestampUnit::kSecond});
+  testScalarType(TIMESTAMP(), "tsm:", {.timestampUnit = TimestampUnit::kMilli});
+  testScalarType(TIMESTAMP(), "tsu:", {.timestampUnit = TimestampUnit::kMicro});
+  testScalarType(TIMESTAMP(), "tsn:", {.timestampUnit = TimestampUnit::kNano});
+
+  testScalarType(VARCHAR(), "vu", {.exportToStringView = true});
+  testScalarType(VARBINARY(), "vz", {.exportToStringView = true});
+
+  // Test specific timezone
+  testScalarType(
+      TIMESTAMP(),
+      "tss:+01:0",
+      {.timestampUnit = TimestampUnit::kSecond, .timestampTimeZone = "+01:0"});
+  testScalarType(
+      TIMESTAMP(),
+      "tsm:+01:0",
+      {.timestampUnit = TimestampUnit::kMilli, .timestampTimeZone = "+01:0"});
+  testScalarType(
+      TIMESTAMP(),
+      "tsu:+01:0",
+      {.timestampUnit = TimestampUnit::kMicro, .timestampTimeZone = "+01:0"});
+  testScalarType(
+      TIMESTAMP(),
+      "tsn:+01:0",
+      {.timestampUnit = TimestampUnit::kNano, .timestampTimeZone = "+01:0"});
+
   testScalarType(DATE(), "tdD");
+  testScalarType(INTERVAL_YEAR_MONTH(), "tiM");
 
   testScalarType(DECIMAL(10, 4), "d:10,4");
   testScalarType(DECIMAL(20, 15), "d:20,15");
+
+  testScalarType(UNKNOWN(), "n");
 }
 
 TEST_F(ArrowBridgeSchemaExportTest, nested) {
@@ -161,18 +271,23 @@ TEST_F(ArrowBridgeSchemaExportTest, nested) {
           }));
 }
 
-TEST_F(ArrowBridgeSchemaExportTest, unsupported) {
-  // Try some combination of unsupported types to ensure there's no crash or
-  // memory leak in failure scenarios.
-  EXPECT_THROW(testScalarType(UNKNOWN(), ""), VeloxException);
-
-  EXPECT_THROW(testScalarType(ARRAY(UNKNOWN()), ""), VeloxException);
-  EXPECT_THROW(testScalarType(MAP(UNKNOWN(), INTEGER()), ""), VeloxException);
-  EXPECT_THROW(testScalarType(MAP(BIGINT(), UNKNOWN()), ""), VeloxException);
-
-  EXPECT_THROW(testScalarType(ROW({BIGINT(), UNKNOWN()}), ""), VeloxException);
-  EXPECT_THROW(
-      testScalarType(ROW({BIGINT(), REAL(), UNKNOWN()}), ""), VeloxException);
+TEST_F(ArrowBridgeSchemaExportTest, constant) {
+  testConstant(TINYINT(), "c");
+  testConstant(INTEGER(), "i");
+  testConstant(BOOLEAN(), "b");
+  testConstant(DOUBLE(), "g");
+  testConstant(VARCHAR(), "u");
+  testConstant(VARCHAR(), "vu", {.exportToStringView = true});
+  testConstant(DATE(), "tdD");
+  testConstant(INTERVAL_YEAR_MONTH(), "tiM");
+  testConstant(UNKNOWN(), "n");
+
+  testConstant(ARRAY(INTEGER()), "+l");
+  testConstant(ARRAY(UNKNOWN()), "+l");
+  testConstant(MAP(BOOLEAN(), REAL()), "+m");
+  testConstant(MAP(UNKNOWN(), REAL()), "+m");
+  testConstant(ROW({TIMESTAMP(), DOUBLE()}), "+s");
+  testConstant(ROW({UNKNOWN(), UNKNOWN()}), "+s");
 }
 
 class ArrowBridgeSchemaImportTest : public ArrowBridgeSchemaExportTest {
@@ -184,13 +299,41 @@ class ArrowBridgeSchemaImportTest : public ArrowBridgeSchemaExportTest {
     return type;
   }
 
-  TypePtr testSchemaImportComplex(
+  TypePtr testSchemaDictionaryImport(const char* indexFmt, ArrowSchema schema) {
+    auto dictionarySchema = makeArrowSchema(indexFmt);
+    dictionarySchema.dictionary = &schema;
+
+    auto type = importFromArrow(dictionarySchema);
+    dictionarySchema.release(&dictionarySchema);
+    return type;
+  }
+
+  TypePtr testSchemaReeImport(const char* valuesFmt) {
+    auto reeSchema = makeArrowSchema("+r");
+    auto runsSchema = makeArrowSchema("i");
+    auto valuesSchema = makeArrowSchema(valuesFmt);
+
+    std::vector<ArrowSchema*> schemas{&runsSchema, &valuesSchema};
+    reeSchema.n_children = 2;
+    reeSchema.children = schemas.data();
+
+    auto type = importFromArrow(reeSchema);
+    reeSchema.release(&reeSchema);
+    return type;
+  }
+
+  ArrowSchema makeComplexArrowSchema(
+      std::vector<ArrowSchema>& schemas,
+      std::vector<ArrowSchema*>& schemaPtrs,
+      std::vector<ArrowSchema>& mapSchemas,
+      std::vector<ArrowSchema*>& mapSchemaPtrs,
       const char* mainFormat,
       const std::vector<const char*>& childrenFormat,
       const std::vector<const char*>& colNames = {}) {
-    std::vector<ArrowSchema> schemas;
-    std::vector<ArrowSchema*> schemaPtrs;
-
+    schemas.clear();
+    schemaPtrs.clear();
+    mapSchemas.clear();
+    mapSchemaPtrs.clear();
     schemas.resize(childrenFormat.size());
     schemaPtrs.resize(childrenFormat.size());
 
@@ -205,18 +348,40 @@ class ArrowBridgeSchemaImportTest : public ArrowBridgeSchemaExportTest {
     auto mainSchema = makeArrowSchema(mainFormat);
     if (strcmp(mainFormat, "+m") == 0) {
       // Arrow wraps key and value in a struct.
-      auto child = makeArrowSchema("+s");
-      auto children = &child;
-      child.n_children = schemaPtrs.size();
-      child.children = schemaPtrs.data();
+      mapSchemas.resize(1);
+      mapSchemaPtrs.resize(1);
+      mapSchemas[0] = makeArrowSchema("+s");
+      auto* child = &mapSchemas[0];
+      mapSchemaPtrs[0] = &mapSchemas[0];
+      child->n_children = schemaPtrs.size();
+      child->children = schemaPtrs.data();
       mainSchema.n_children = 1;
-      mainSchema.children = &children;
-      return importFromArrow(mainSchema);
+      mainSchema.children = mapSchemaPtrs.data();
     } else {
       mainSchema.n_children = (int64_t)schemaPtrs.size();
       mainSchema.children = schemaPtrs.data();
-      return importFromArrow(mainSchema);
     }
+
+    return mainSchema;
+  }
+
+  TypePtr testSchemaImportComplex(
+      const char* mainFormat,
+      const std::vector<const char*>& childrenFormat,
+      const std::vector<const char*>& colNames = {}) {
+    std::vector<ArrowSchema> schemas;
+    std::vector<ArrowSchema> mapSchemas;
+    std::vector<ArrowSchema*> schemaPtrs;
+    std::vector<ArrowSchema*> mapSchemaPtrs;
+    auto type = importFromArrow(makeComplexArrowSchema(
+        schemas,
+        schemaPtrs,
+        mapSchemas,
+        mapSchemaPtrs,
+        mainFormat,
+        childrenFormat,
+        colNames));
+    return type;
   }
 };
 
@@ -234,22 +399,44 @@ TEST_F(ArrowBridgeSchemaImportTest, scalar) {
   EXPECT_EQ(*VARBINARY(), *testSchemaImport("z"));
   EXPECT_EQ(*VARBINARY(), *testSchemaImport("Z"));
 
+  EXPECT_EQ(*VARCHAR(), *testSchemaImport("vu"));
+  EXPECT_EQ(*VARBINARY(), *testSchemaImport("vz"));
+
   // Temporal.
-  EXPECT_EQ(*TIMESTAMP(), *testSchemaImport("ttn"));
+  EXPECT_EQ(*TIMESTAMP(), *testSchemaImport("tsn:"));
   EXPECT_EQ(*DATE(), *testSchemaImport("tdD"));
+  EXPECT_EQ(*INTERVAL_YEAR_MONTH(), *testSchemaImport("tiM"));
 
   EXPECT_EQ(*DECIMAL(10, 4), *testSchemaImport("d:10,4"));
   EXPECT_EQ(*DECIMAL(20, 15), *testSchemaImport("d:20,15"));
   VELOX_ASSERT_THROW(
       *testSchemaImport("d2,15"),
       "Unable to convert 'd2,15' ArrowSchema decimal format to Velox decimal");
+  EXPECT_EQ(*DECIMAL(10, 4), *testSchemaImport("d:10,4,128"));
+  VELOX_ASSERT_THROW(
+      *testSchemaImport("d:10,4,256"),
+      "Conversion failed for 'd:10,4,256'. Velox decimal does not support custom bitwidth.");
+  VELOX_ASSERT_THROW(
+      *testSchemaImport("d:10,4,"),
+      "Unable to convert 'd:10,4,' ArrowSchema decimal format to Velox decimal");
+  VELOX_ASSERT_THROW(
+      *testSchemaImport("d:10"),
+      "Unable to convert 'd:10' ArrowSchema decimal format to Velox decimal");
+  VELOX_ASSERT_THROW(
+      *testSchemaImport("d:"),
+      "Unable to convert 'd:' ArrowSchema decimal format to Velox decimal");
+  VELOX_ASSERT_THROW(
+      *testSchemaImport("d:10,"),
+      "Unable to convert 'd:10,' ArrowSchema decimal format to Velox decimal");
 }
 
 TEST_F(ArrowBridgeSchemaImportTest, complexTypes) {
   // Array.
   EXPECT_EQ(*ARRAY(BIGINT()), *testSchemaImportComplex("+l", {"l"}));
-  EXPECT_EQ(*ARRAY(TIMESTAMP()), *testSchemaImportComplex("+l", {"ttn"}));
+  EXPECT_EQ(*ARRAY(TIMESTAMP()), *testSchemaImportComplex("+l", {"tsn:"}));
   EXPECT_EQ(*ARRAY(DATE()), *testSchemaImportComplex("+l", {"tdD"}));
+  EXPECT_EQ(
+      *ARRAY(INTERVAL_YEAR_MONTH()), *testSchemaImportComplex("+l", {"tiM"}));
   EXPECT_EQ(*ARRAY(VARCHAR()), *testSchemaImportComplex("+l", {"U"}));
 
   EXPECT_EQ(*ARRAY(DECIMAL(10, 4)), *testSchemaImportComplex("+l", {"d:10,4"}));
@@ -276,7 +463,6 @@ TEST_F(ArrowBridgeSchemaImportTest, complexTypes) {
 }
 
 TEST_F(ArrowBridgeSchemaImportTest, unsupported) {
-  EXPECT_THROW(testSchemaImport("n"), VeloxUserError);
   EXPECT_THROW(testSchemaImport("C"), VeloxUserError);
   EXPECT_THROW(testSchemaImport("S"), VeloxUserError);
   EXPECT_THROW(testSchemaImport("I"), VeloxUserError);
@@ -289,7 +475,6 @@ TEST_F(ArrowBridgeSchemaImportTest, unsupported) {
   EXPECT_THROW(testSchemaImport("tts"), VeloxUserError);
   EXPECT_THROW(testSchemaImport("ttm"), VeloxUserError);
   EXPECT_THROW(testSchemaImport("tDs"), VeloxUserError);
-  EXPECT_THROW(testSchemaImport("tiM"), VeloxUserError);
 
   EXPECT_THROW(testSchemaImport("+"), VeloxUserError);
   EXPECT_THROW(testSchemaImport("+L"), VeloxUserError);
@@ -301,18 +486,36 @@ TEST_F(ArrowBridgeSchemaImportTest, unsupported) {
 
 class ArrowBridgeSchemaTest : public testing::Test {
  protected:
-  void roundtripTest(const TypePtr& inputType) {
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void roundtripTest(
+      const TypePtr& inputType,
+      const ArrowOptions& options = ArrowOptions{}) {
     ArrowSchema arrowSchema;
-    exportToArrow(inputType, arrowSchema);
+    exportToArrow(inputType, arrowSchema, options);
     auto outputType = importFromArrow(arrowSchema);
     arrowSchema.release(&arrowSchema);
     EXPECT_EQ(*inputType, *outputType);
   }
+
+  void exportToArrow(
+      const TypePtr& type,
+      ArrowSchema& out,
+      const ArrowOptions& options = ArrowOptions{}) {
+    velox::exportToArrow(
+        BaseVector::create(type, 0, pool_.get()), out, options);
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 TEST_F(ArrowBridgeSchemaTest, roundtrip) {
   roundtripTest(BOOLEAN());
   roundtripTest(VARCHAR());
+  roundtripTest(VARCHAR(), {.exportToStringView = true});
   roundtripTest(REAL());
   roundtripTest(ARRAY(DOUBLE()));
   roundtripTest(ARRAY(ARRAY(ARRAY(ARRAY(VARBINARY())))));
@@ -333,6 +536,7 @@ TEST_F(ArrowBridgeSchemaTest, validateInArrow) {
   const std::pair<TypePtr, std::shared_ptr<arrow::DataType>> kTypes[] = {
       {BOOLEAN(), arrow::boolean()},
       {VARCHAR(), arrow::utf8()},
+      {VARCHAR(), arrow::utf8_view()},
       {DECIMAL(10, 4), arrow::decimal(10, 4)},
       {DECIMAL(20, 15), arrow::decimal(20, 15)},
       {ARRAY(DOUBLE()), arrow::list(arrow::float64())},
@@ -347,11 +551,121 @@ TEST_F(ArrowBridgeSchemaTest, validateInArrow) {
     VLOG(1) << "Validating conversion between " << tv->toString() << " and "
             << ta->ToString();
     ArrowSchema schema;
-    exportToArrow(tv, schema);
+    ta == arrow::utf8_view()
+        ? exportToArrow(tv, schema, {.exportToStringView = true})
+        : exportToArrow(tv, schema);
     ASSERT_OK_AND_ASSIGN(auto actual, arrow::ImportType(&schema));
     ASSERT_FALSE(schema.release);
     EXPECT_EQ(*actual, *ta);
   }
 }
 
+TEST_F(ArrowBridgeSchemaImportTest, dictionaryTypeTest) {
+  // Primitive types
+  EXPECT_EQ(DOUBLE(), testSchemaDictionaryImport("i", makeArrowSchema("g")));
+  EXPECT_EQ(BOOLEAN(), testSchemaDictionaryImport("i", makeArrowSchema("b")));
+  EXPECT_EQ(TINYINT(), testSchemaDictionaryImport("i", makeArrowSchema("c")));
+  EXPECT_EQ(INTEGER(), testSchemaDictionaryImport("i", makeArrowSchema("i")));
+  EXPECT_EQ(SMALLINT(), testSchemaDictionaryImport("i", makeArrowSchema("s")));
+  EXPECT_EQ(BIGINT(), testSchemaDictionaryImport("i", makeArrowSchema("l")));
+  EXPECT_EQ(REAL(), testSchemaDictionaryImport("i", makeArrowSchema("f")));
+  EXPECT_EQ(VARCHAR(), testSchemaDictionaryImport("i", makeArrowSchema("u")));
+
+  std::vector<ArrowSchema> schemas;
+  std::vector<ArrowSchema> mapSchemas;
+  std::vector<ArrowSchema*> mapSchemaPtrs;
+  std::vector<ArrowSchema*> schemaPtrs;
+
+  // Arrays
+  EXPECT_EQ(
+      *ARRAY(BIGINT()),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas, schemaPtrs, mapSchemas, mapSchemaPtrs, "+l", {"l"})));
+  EXPECT_EQ(
+      *ARRAY(TIMESTAMP()),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas, schemaPtrs, mapSchemas, mapSchemaPtrs, "+l", {"tsn:"})));
+  EXPECT_EQ(
+      *ARRAY(DATE()),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas, schemaPtrs, mapSchemas, mapSchemaPtrs, "+l", {"tdD"})));
+  EXPECT_EQ(
+      *ARRAY(INTERVAL_YEAR_MONTH()),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas, schemaPtrs, mapSchemas, mapSchemaPtrs, "+l", {"tiM"})));
+  EXPECT_EQ(
+      *ARRAY(VARCHAR()),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas, schemaPtrs, mapSchemas, mapSchemaPtrs, "+l", {"U"})));
+
+  // Maps
+  EXPECT_EQ(
+      *MAP(VARCHAR(), BOOLEAN()),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas,
+              schemaPtrs,
+              mapSchemas,
+              mapSchemaPtrs,
+              "+m",
+              {"U", "b"})));
+  EXPECT_EQ(
+      *MAP(SMALLINT(), REAL()),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas,
+              schemaPtrs,
+              mapSchemas,
+              mapSchemaPtrs,
+              "+m",
+              {"s", "f"})));
+
+  // Rows
+  EXPECT_EQ(
+      *ROW({SMALLINT(), REAL()}),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas,
+              schemaPtrs,
+              mapSchemas,
+              mapSchemaPtrs,
+              "+s",
+              {"s", "f"})));
+
+  // Named Row
+  EXPECT_EQ(
+      *ROW({"col1", "col2"}, {SMALLINT(), REAL()}),
+      *testSchemaDictionaryImport(
+          "i",
+          makeComplexArrowSchema(
+              schemas,
+              schemaPtrs,
+              mapSchemas,
+              mapSchemaPtrs,
+              "+s",
+              {"s", "f"},
+              {"col1", "col2"})));
+}
+
+TEST_F(ArrowBridgeSchemaImportTest, reeTypeTest) {
+  // Ensure REE just returns the type of the inner `values` child.
+  EXPECT_EQ(DOUBLE(), testSchemaReeImport("g"));
+  EXPECT_EQ(INTEGER(), testSchemaReeImport("i"));
+  EXPECT_EQ(BIGINT(), testSchemaReeImport("l"));
+}
+
 } // namespace
+} // namespace facebook::velox::test
diff --git a/velox/vector/arrow/tests/CMakeLists.txt b/velox/vector/arrow/tests/CMakeLists.txt
index 0a2af976e0b52..c4a396812afe0 100644
--- a/velox/vector/arrow/tests/CMakeLists.txt
+++ b/velox/vector/arrow/tests/CMakeLists.txt
@@ -22,7 +22,7 @@ target_link_libraries(
   velox_arrow_bridge
   velox_vector_test_lib
   arrow
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   glog::glog
   dl)
diff --git a/velox/vector/benchmarks/CMakeLists.txt b/velox/vector/benchmarks/CMakeLists.txt
index 0ebca6e668541..09d4a20f4b341 100644
--- a/velox/vector/benchmarks/CMakeLists.txt
+++ b/velox/vector/benchmarks/CMakeLists.txt
@@ -13,18 +13,33 @@
 # limitations under the License.
 add_executable(velox_vector_hash_all_benchmark SimpleVectorHashAllBenchmark.cpp)
 
-target_link_libraries(velox_vector_hash_all_benchmark velox_vector Folly::folly
-                      ${FOLLY_BENCHMARK} fmt::fmt)
+target_link_libraries(
+  velox_vector_hash_all_benchmark
+  velox_vector
+  Folly::folly
+  ${FOLLY_BENCHMARK}
+  fmt::fmt)
 # This is a workaround for the use of VectorTestUtils.h which include gtest.h
-target_link_libraries(velox_vector_hash_all_benchmark gtest)
+target_link_libraries(
+  velox_vector_hash_all_benchmark GTest::gtest)
 
 add_executable(velox_vector_selectivity_vector_benchmark
                SelectivityVectorBenchmark.cpp)
 
-target_link_libraries(velox_vector_selectivity_vector_benchmark velox_vector
-                      Folly::folly ${FOLLY_BENCHMARK})
+target_link_libraries(
+  velox_vector_selectivity_vector_benchmark velox_vector Folly::folly
+  ${FOLLY_BENCHMARK})
 
 add_executable(copy_benchmark CopyBenchmark.cpp)
 
-target_link_libraries(copy_benchmark velox_vector_test_lib Folly::folly
-                      ${FOLLY_BENCHMARK})
+target_link_libraries(
+  copy_benchmark velox_vector_test_lib Folly::folly ${FOLLY_BENCHMARK})
+
+add_executable(velox_vector_map_update_benchmark MapUpdateBenchmark.cpp)
+target_link_libraries(
+  velox_vector_map_update_benchmark
+  velox_vector_test_lib
+  Folly::folly
+  ${FOLLY_BENCHMARK}
+  gflags::gflags
+  glog::glog)
diff --git a/velox/vector/benchmarks/CopyBenchmark.cpp b/velox/vector/benchmarks/CopyBenchmark.cpp
index d021db3482ad8..bd7f2c7db6972 100644
--- a/velox/vector/benchmarks/CopyBenchmark.cpp
+++ b/velox/vector/benchmarks/CopyBenchmark.cpp
@@ -68,7 +68,8 @@ size_t runBenchmark(
 
 BENCHMARK_MULTI(copyArray) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -84,7 +85,8 @@ BENCHMARK_MULTI(copyArray) {
 
 BENCHMARK_MULTI(copyArrayWithNulls) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -101,7 +103,8 @@ BENCHMARK_MULTI(copyArrayWithNulls) {
 
 BENCHMARK_MULTI(copyArrayDictionaryEncoded) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -131,7 +134,8 @@ BENCHMARK_MULTI(copyArrayDictionaryEncoded) {
 
 BENCHMARK_MULTI(copyArrayOneAtATime) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -147,7 +151,8 @@ BENCHMARK_MULTI(copyArrayOneAtATime) {
 
 BENCHMARK_MULTI(copyArrayTwoAtATime) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -163,7 +168,8 @@ BENCHMARK_MULTI(copyArrayTwoAtATime) {
 
 BENCHMARK_MULTI(copyArrayOfVarchar) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 50'000;
@@ -192,7 +198,8 @@ BENCHMARK_MULTI(copyArrayOfVarchar) {
 
 BENCHMARK_MULTI(copyArrayOfArray) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -220,7 +227,8 @@ BENCHMARK_MULTI(copyArrayOfArray) {
 
 BENCHMARK_MULTI(copyMap) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -238,7 +246,8 @@ BENCHMARK_MULTI(copyMap) {
 
 BENCHMARK_MULTI(copyMapWithNulls) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -257,7 +266,8 @@ BENCHMARK_MULTI(copyMapWithNulls) {
 
 BENCHMARK_MULTI(copyMapDictionaryEncoded) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -290,7 +300,8 @@ BENCHMARK_MULTI(copyMapDictionaryEncoded) {
 
 BENCHMARK_MULTI(copyMapOneAtATime) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -308,7 +319,8 @@ BENCHMARK_MULTI(copyMapOneAtATime) {
 
 BENCHMARK_MULTI(copyMapTwoAtATime) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
 
   const vector_size_t size = 1'000;
@@ -326,7 +338,8 @@ BENCHMARK_MULTI(copyMapTwoAtATime) {
 
 BENCHMARK_MULTI(copyStructNonContiguous) {
   folly::BenchmarkSuspender suspender;
-  std::shared_ptr<memory::MemoryPool> pool{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool{
+      memory::memoryManager()->addLeafPool()};
   test::VectorMaker vectorMaker{pool.get()};
   constexpr vector_size_t kSize = 2'000;
   std::vector<VectorPtr> children = {
@@ -351,8 +364,8 @@ BENCHMARK_MULTI(copyStructNonContiguous) {
 } // namespace facebook::velox
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
-
+  folly::Init init{&argc, &argv};
+  facebook::velox::memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/vector/benchmarks/MapUpdateBenchmark.cpp b/velox/vector/benchmarks/MapUpdateBenchmark.cpp
new file mode 100644
index 0000000000000..79d1eb138a1b7
--- /dev/null
+++ b/velox/vector/benchmarks/MapUpdateBenchmark.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include <random>
+
+DEFINE_int32(seed, 0, "Random seed");
+
+namespace facebook::velox {
+namespace {
+
+MapVectorPtr generateBase(
+    memory::MemoryPool* pool,
+    std::default_random_engine& gen) {
+  constexpr int kSize = 1000;
+  constexpr int kMapSize = 10;
+  test::VectorMaker maker(pool);
+  std::uniform_real_distribution valueDist;
+  return maker.mapVector<int64_t, double>(
+      kSize,
+      [&](auto /*i*/) { return kMapSize; },
+      [](auto /*i*/, auto j) { return j; },
+      [&](auto /*i*/, auto /*j*/) { return valueDist(gen); });
+}
+
+MapVectorPtr generateUpdate(
+    memory::MemoryPool* pool,
+    std::default_random_engine& gen,
+    const MapVector& base) {
+  constexpr int kMapSize = 5;
+  auto offsets = allocateIndices(base.size(), pool);
+  auto* rawOffsets = offsets->asMutable<vector_size_t>();
+  rawOffsets[0] = 0;
+  for (int i = 1; i < base.size(); ++i) {
+    rawOffsets[i] = rawOffsets[i - 1] + kMapSize;
+  }
+  auto sizes = allocateIndices(base.size(), pool);
+  auto* rawSizes = sizes->asMutable<vector_size_t>();
+  std::fill(rawSizes, rawSizes + base.size(), kMapSize);
+  int64_t keyCandidates[10];
+  std::iota(std::begin(keyCandidates), std::end(keyCandidates), 0);
+  auto keys = BaseVector::create<FlatVector<int64_t>>(
+      BIGINT(), kMapSize * base.size(), pool);
+  for (int i = 0; i < base.size(); ++i) {
+    std::shuffle(std::begin(keyCandidates), std::end(keyCandidates), gen);
+    for (int j = 0; j < kMapSize; ++j) {
+      keys->set(j + i * kMapSize, keyCandidates[j]);
+    }
+  }
+  test::VectorMaker maker(pool);
+  std::uniform_real_distribution valueDist;
+  auto values = maker.flatVector<double>(
+      kMapSize * base.size(), [&](auto /*i*/) { return valueDist(gen); });
+  return std::make_shared<MapVector>(
+      pool,
+      base.type(),
+      nullptr,
+      base.size(),
+      std::move(offsets),
+      std::move(sizes),
+      std::move(keys),
+      std::move(values));
+}
+
+} // namespace
+} // namespace facebook::velox
+
+int main(int argc, char* argv[]) {
+  using namespace facebook::velox;
+  folly::Init follyInit(&argc, &argv);
+  if (gflags::GetCommandLineFlagInfoOrDie("seed").is_default) {
+    FLAGS_seed = std::random_device{}();
+    LOG(INFO) << "Use generated random seed " << FLAGS_seed;
+  }
+
+  memory::MemoryManager::initialize({});
+  auto pool = memory::memoryManager()->addLeafPool();
+  std::default_random_engine gen(FLAGS_seed);
+  auto base = generateBase(pool.get(), gen);
+  auto update = generateUpdate(pool.get(), gen, *base);
+
+  folly::addBenchmark(__FILE__, "int64 keys", [&] {
+    auto result = base->update({update});
+    folly::doNotOptimizeAway(result);
+    return base->size();
+  });
+  folly::runBenchmarks();
+
+  return 0;
+}
diff --git a/velox/vector/benchmarks/NthBitBenchmark.cpp b/velox/vector/benchmarks/NthBitBenchmark.cpp
index d6a4043c53b59..c7d26ed60b95d 100644
--- a/velox/vector/benchmarks/NthBitBenchmark.cpp
+++ b/velox/vector/benchmarks/NthBitBenchmark.cpp
@@ -117,7 +117,7 @@ BENCHMARK_RELATIVE_PARAM(BM_setNthBit_shift_false_unsigned, 1000000);
 BENCHMARK_DRAW_LINE();
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/vector/benchmarks/SelectivityVectorBenchmark.cpp b/velox/vector/benchmarks/SelectivityVectorBenchmark.cpp
index a2678843b6a08..61f4ccecc9021 100644
--- a/velox/vector/benchmarks/SelectivityVectorBenchmark.cpp
+++ b/velox/vector/benchmarks/SelectivityVectorBenchmark.cpp
@@ -308,7 +308,7 @@ BENCHMARK_DRAW_LINE();
 // buck run @mode/opt-clang-thinlto \
 //   velox/vector/benchmarks:selectivity_vector_benchmark
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/vector/benchmarks/SimpleVectorHashAllBenchmark.cpp b/velox/vector/benchmarks/SimpleVectorHashAllBenchmark.cpp
index e4f36d0f77b68..374c274496474 100644
--- a/velox/vector/benchmarks/SimpleVectorHashAllBenchmark.cpp
+++ b/velox/vector/benchmarks/SimpleVectorHashAllBenchmark.cpp
@@ -89,7 +89,7 @@ void vectorBenchmark(
     bool sequences,
     VectorEncoding::Simple encoding) {
   folly::BenchmarkSuspender suspender;
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   VectorMaker vectorMaker(pool.get());
 
   for (size_t k = 0; k < iterations; ++k) {
@@ -467,7 +467,8 @@ BENCHMARK_DRAW_LINE();
 } // namespace facebook::velox::test
 
 int main(int argc, char** argv) {
-  folly::init(&argc, &argv);
+  folly::Init init{&argc, &argv};
+  facebook::velox::memory::MemoryManager::initialize({});
   folly::runBenchmarks();
   return 0;
 }
diff --git a/velox/vector/fuzzer/CMakeLists.txt b/velox/vector/fuzzer/CMakeLists.txt
index 33a97cec65c1b..43b8cc83746d6 100644
--- a/velox/vector/fuzzer/CMakeLists.txt
+++ b/velox/vector/fuzzer/CMakeLists.txt
@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_vector_fuzzer VectorFuzzer.cpp GeneratorSpec.cpp Utils.cpp)
+add_library(velox_vector_fuzzer GeneratorSpec.cpp Utils.cpp VectorFuzzer.cpp)
 
-target_link_libraries(velox_vector_fuzzer velox_type velox_vector)
+target_link_libraries(
+  velox_vector_fuzzer velox_type velox_vector)
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   target_compile_options(velox_vector_fuzzer
                          PRIVATE -Wno-deprecated-declarations)
diff --git a/velox/vector/fuzzer/GeneratorSpec.h b/velox/vector/fuzzer/GeneratorSpec.h
index e1d7b3652bf92..d3f9a90bb88b1 100644
--- a/velox/vector/fuzzer/GeneratorSpec.h
+++ b/velox/vector/fuzzer/GeneratorSpec.h
@@ -79,7 +79,7 @@ class ScalarGeneratorSpec : public GeneratorSpec {
       : GeneratorSpec(type, nullProbability),
         distribution_(std::forward<Distribution>(distribution)) {
     using TCpp = typename TypeTraits<KIND>::NativeType;
-    using Ret = std::result_of_t<Distribution(FuzzerGenerator&)>;
+    using Ret = std::invoke_result_t<Distribution, FuzzerGenerator&>;
     static_assert(std::is_convertible_v<Ret, TCpp>);
   }
 
@@ -143,7 +143,7 @@ class ArrayGeneratorSpec : public GeneratorSpec {
       : GeneratorSpec(type, nullProbability),
         elements_(elements),
         lengthDistribution_(std::forward<Distribution>(lengthDistribution)) {
-    using Ret = std::result_of_t<Distribution(FuzzerGenerator&)>;
+    using Ret = std::invoke_result_t<Distribution, FuzzerGenerator&>;
     static_assert(std::is_convertible_v<Ret, vector_size_t>);
   }
 
@@ -190,7 +190,7 @@ class MapGeneratorSpec : public GeneratorSpec {
         keys_(keys),
         values_(values),
         lengthDistribution_(std::forward<Distribution>(lengthDistribution)) {
-    using Ret = std::result_of_t<Distribution(FuzzerGenerator&)>;
+    using Ret = std::invoke_result_t<Distribution, FuzzerGenerator&>;
     static_assert(std::is_convertible_v<Ret, vector_size_t>);
   }
 
@@ -240,7 +240,7 @@ class EncoderSpec : public GeneratorSpec {
         base_(base),
         encoding_(std::forward<Distribution>(encodingDistribution)),
         nesting_(minNesting, maxNesting) {
-    using Ret = std::result_of_t<Distribution(FuzzerGenerator&)>;
+    using Ret = std::invoke_result_t<Distribution, FuzzerGenerator&>;
     static_assert(std::is_convertible_v<Ret, EncoderSpecCodes>);
   }
 
@@ -286,7 +286,7 @@ class EncoderSpec : public GeneratorSpec {
         break;
       }
       default: {
-        VELOX_UNREACHABLE()
+        VELOX_UNREACHABLE();
         break;
       }
     }
diff --git a/velox/vector/fuzzer/VectorFuzzer.cpp b/velox/vector/fuzzer/VectorFuzzer.cpp
index ced03dbf17151..075e905e638ba 100644
--- a/velox/vector/fuzzer/VectorFuzzer.cpp
+++ b/velox/vector/fuzzer/VectorFuzzer.cpp
@@ -118,26 +118,51 @@ int128_t rand(FuzzerGenerator& rng) {
   return HugeInt::build(rand<int64_t>(rng), rand<uint64_t>(rng));
 }
 
+template <typename T, typename std::enable_if_t<std::is_integral_v<T>, int> = 0>
+T rand(FuzzerGenerator& rng, T min, T max) {
+  return boost::random::uniform_int_distribution<T>(min, max)(rng);
+}
+
 Timestamp randTimestamp(FuzzerGenerator& rng, VectorFuzzer::Options opts) {
+  // Generate timestamps only in the valid range to avoid datetime functions,
+  // such as try_cast(varchar as timestamp), throwing VeloxRuntimeError in
+  // fuzzers.
+  constexpr int64_t min = -2'140'671'600;
+  constexpr int64_t max = 2'140'671'600;
+  constexpr int64_t microInSecond = 1'000'000;
+  constexpr int64_t millisInSecond = 1'000;
+
   switch (opts.timestampPrecision) {
     case VectorFuzzer::Options::TimestampPrecision::kNanoSeconds:
-      return Timestamp(rand<int32_t>(rng), (rand<int64_t>(rng) % MAX_NANOS));
+      return Timestamp(
+          rand<int64_t>(rng, min, max), (rand<int64_t>(rng) % MAX_NANOS));
     case VectorFuzzer::Options::TimestampPrecision::kMicroSeconds:
-      return Timestamp::fromMicros(rand<int64_t>(rng));
+      return Timestamp::fromMicros(
+          rand<int64_t>(rng, min, max) * microInSecond +
+          rand<int64_t>(rng, -microInSecond, microInSecond));
     case VectorFuzzer::Options::TimestampPrecision::kMilliSeconds:
-      return Timestamp::fromMillis(rand<int64_t>(rng));
+      return Timestamp::fromMillis(
+          rand<int64_t>(rng, min, max) * millisInSecond +
+          rand<int64_t>(rng, -millisInSecond, millisInSecond));
     case VectorFuzzer::Options::TimestampPrecision::kSeconds:
-      return Timestamp(rand<int32_t>(rng), 0);
+      return Timestamp(rand<int64_t>(rng, min, max), 0);
   }
   return {}; // no-op.
 }
 
+int32_t randDate(FuzzerGenerator& rng) {
+  constexpr int64_t min = -24'450;
+  constexpr int64_t max = 24'450;
+  return rand<int32_t>(rng, min, max);
+}
+
 size_t getElementsVectorLength(
     const VectorFuzzer::Options& opts,
     vector_size_t size) {
-  if (opts.containerVariableLength == false &&
-      size * opts.containerLength > opts.complexElementsMaxSize) {
-    VELOX_USER_FAIL(
+  if (!opts.containerVariableLength) {
+    VELOX_USER_CHECK_LE(
+        size * opts.containerLength,
+        opts.complexElementsMaxSize,
         "Requested fixed opts.containerVariableLength can't be satisfied: "
         "increase opts.complexElementsMaxSize, reduce opts.containerLength"
         " or make opts.containerVariableLength=true");
@@ -250,6 +275,9 @@ VectorPtr fuzzConstantPrimitiveImpl(
   if constexpr (std::is_same_v<TCpp, Timestamp>) {
     return std::make_shared<ConstantVector<TCpp>>(
         pool, size, false, type, randTimestamp(rng, opts));
+  } else if (type->isDate()) {
+    return std::make_shared<ConstantVector<int32_t>>(
+        pool, size, false, type, randDate(rng));
   } else if (type->isShortDecimal()) {
     return std::make_shared<ConstantVector<int64_t>>(
         pool, size, false, type, randShortDecimal(type, rng));
@@ -293,6 +321,12 @@ void fuzzFlatPrimitiveImpl(
       } else {
         VELOX_NYI();
       }
+    } else if constexpr (std::is_same_v<TCpp, int32_t>) {
+      if (vector->type()->isDate()) {
+        flatVector->set(i, randDate(rng));
+      } else {
+        flatVector->set(i, rand<TCpp>(rng));
+      }
     } else {
       flatVector->set(i, rand<TCpp>(rng));
     }
@@ -436,6 +470,14 @@ VectorPtr VectorFuzzer::fuzzConstant(const TypePtr& type, vector_size_t size) {
 
   ScopedOptions restorer(this);
   opts_.allowLazyVector = false;
+  // Have a lower cap on repeated sizes inside constant. Otherwise will OOM when
+  // flattening.
+  if (opts_.maxConstantContainerSize.has_value()) {
+    opts_.containerLength = std::min<int32_t>(
+        opts_.maxConstantContainerSize.value(), opts_.containerLength);
+    opts_.complexElementsMaxSize = std::min<int32_t>(
+        opts_.maxConstantContainerSize.value(), opts_.complexElementsMaxSize);
+  }
   return BaseVector::wrapInConstant(
       size, constantIndex, fuzz(type, innerVectorSize));
 }
@@ -463,24 +505,28 @@ VectorPtr VectorFuzzer::fuzzFlat(const TypePtr& type, vector_size_t size) {
   }
   // Arrays.
   else if (type->isArray()) {
-    return fuzzArray(
-        fuzzFlat(
-            type->asArray().elementType(),
-            getElementsVectorLength(opts_, size)),
-        size);
+    const auto& elementType = type->asArray().elementType();
+    auto elementsLength = getElementsVectorLength(opts_, size);
+
+    auto elements = opts_.containerHasNulls
+        ? fuzzFlat(elementType, elementsLength)
+        : fuzzFlatNotNull(elementType, elementsLength);
+    return fuzzArray(elements, size);
   }
   // Maps.
   else if (type->isMap()) {
     // Do not initialize keys and values inline in the fuzzMap call as C++ does
     // not specify the order they'll be called in, leading to inconsistent
     // results across platforms.
-    auto keys = opts_.normalizeMapKeys
-        ? fuzzFlatNotNull(
-              type->asMap().keyType(), getElementsVectorLength(opts_, size))
-        : fuzzFlat(
-              type->asMap().keyType(), getElementsVectorLength(opts_, size));
-    auto values = fuzzFlat(
-        type->asMap().valueType(), getElementsVectorLength(opts_, size));
+    const auto& keyType = type->asMap().keyType();
+    const auto& valueType = type->asMap().valueType();
+    auto length = getElementsVectorLength(opts_, size);
+
+    auto keys = opts_.normalizeMapKeys || !opts_.containerHasNulls
+        ? fuzzFlatNotNull(keyType, length)
+        : fuzzFlat(keyType, length);
+    auto values = opts_.containerHasNulls ? fuzzFlat(valueType, length)
+                                          : fuzzFlatNotNull(valueType, length);
     return fuzzMap(keys, values, size);
   }
   // Rows.
@@ -490,7 +536,9 @@ VectorPtr VectorFuzzer::fuzzFlat(const TypePtr& type, vector_size_t size) {
     childrenVectors.reserve(rowType.children().size());
 
     for (const auto& childType : rowType.children()) {
-      childrenVectors.emplace_back(fuzzFlat(childType, size));
+      childrenVectors.emplace_back(
+          opts_.containerHasNulls ? fuzzFlat(childType, size)
+                                  : fuzzFlatNotNull(childType, size));
     }
 
     return fuzzRow(std::move(childrenVectors), rowType.names(), size);
@@ -533,23 +581,29 @@ VectorPtr VectorFuzzer::fuzzComplex(const TypePtr& type, vector_size_t size) {
     case TypeKind::ROW:
       return fuzzRow(std::dynamic_pointer_cast<const RowType>(type), size);
 
-    case TypeKind::ARRAY:
-      return fuzzArray(
-          fuzz(
-              type->asArray().elementType(),
-              getElementsVectorLength(opts_, size)),
-          size);
+    case TypeKind::ARRAY: {
+      const auto& elementType = type->asArray().elementType();
+      auto elementsLength = getElementsVectorLength(opts_, size);
+
+      auto elements = opts_.containerHasNulls
+          ? fuzz(elementType, elementsLength)
+          : fuzzNotNull(elementType, elementsLength);
+      return fuzzArray(elements, size);
+    }
 
     case TypeKind::MAP: {
       // Do not initialize keys and values inline in the fuzzMap call as C++
       // does not specify the order they'll be called in, leading to
       // inconsistent results across platforms.
-      auto keys = opts_.normalizeMapKeys
-          ? fuzzNotNull(
-                type->asMap().keyType(), getElementsVectorLength(opts_, size))
-          : fuzz(type->asMap().keyType(), getElementsVectorLength(opts_, size));
-      auto values =
-          fuzz(type->asMap().valueType(), getElementsVectorLength(opts_, size));
+      const auto& keyType = type->asMap().keyType();
+      const auto& valueType = type->asMap().valueType();
+      auto length = getElementsVectorLength(opts_, size);
+
+      auto keys = opts_.normalizeMapKeys || !opts_.containerHasNulls
+          ? fuzzNotNull(keyType, length)
+          : fuzz(keyType, length);
+      auto values = opts_.containerHasNulls ? fuzz(valueType, length)
+                                            : fuzzNotNull(valueType, length);
       return fuzzMap(keys, values, size);
     }
 
@@ -619,7 +673,7 @@ ArrayVectorPtr VectorFuzzer::fuzzArray(
   return std::make_shared<ArrayVector>(
       pool_,
       ARRAY(elements->type()),
-      opts_.containerHasNulls ? fuzzNulls(size) : nullptr,
+      fuzzNulls(size),
       size,
       offsets,
       sizes,
@@ -676,7 +730,7 @@ MapVectorPtr VectorFuzzer::fuzzMap(
   return std::make_shared<MapVector>(
       pool_,
       MAP(keys->type(), values->type()),
-      opts_.containerHasNulls ? fuzzNulls(size) : nullptr,
+      fuzzNulls(size),
       size,
       offsets,
       sizes,
@@ -715,7 +769,7 @@ RowVectorPtr VectorFuzzer::fuzzRow(
   return std::make_shared<RowVector>(
       pool_,
       ROW(std::move(childrenNames), std::move(types)),
-      opts_.containerHasNulls ? fuzzNulls(size) : nullptr,
+      fuzzNulls(size),
       size,
       std::move(children));
 }
@@ -731,11 +785,7 @@ RowVectorPtr VectorFuzzer::fuzzRow(
   }
 
   return std::make_shared<RowVector>(
-      pool_,
-      ROW(std::move(types)),
-      opts_.containerHasNulls ? fuzzNulls(size) : nullptr,
-      size,
-      std::move(children));
+      pool_, ROW(std::move(types)), fuzzNulls(size), size, std::move(children));
 }
 
 RowVectorPtr VectorFuzzer::fuzzRow(const RowTypePtr& rowType) {
@@ -749,14 +799,20 @@ RowVectorPtr VectorFuzzer::fuzzRow(
     vector_size_t size,
     bool allowTopLevelNulls) {
   std::vector<VectorPtr> children;
+  children.reserve(rowType->size());
+
   for (auto i = 0; i < rowType->size(); ++i) {
-    children.push_back(fuzz(rowType->childAt(i), size));
+    children.push_back(
+        opts_.containerHasNulls ? fuzz(rowType->childAt(i), size)
+                                : fuzzNotNull(rowType->childAt(i), size));
   }
 
-  auto nulls =
-      allowTopLevelNulls && opts_.containerHasNulls ? fuzzNulls(size) : nullptr;
   return std::make_shared<RowVector>(
-      pool_, rowType, nulls, size, std::move(children));
+      pool_,
+      rowType,
+      allowTopLevelNulls ? fuzzNulls(size) : nullptr,
+      size,
+      std::move(children));
 }
 
 BufferPtr VectorFuzzer::fuzzNulls(vector_size_t size) {
@@ -799,6 +855,12 @@ TypePtr VectorFuzzer::randOrderableType(int maxDepth) {
   return velox::randOrderableType(rng_, maxDepth);
 }
 
+TypePtr VectorFuzzer::randOrderableType(
+    const std::vector<TypePtr>& scalarTypes,
+    int maxDepth) {
+  return velox::randOrderableType(rng_, scalarTypes, maxDepth);
+}
+
 TypePtr VectorFuzzer::randType(
     const std::vector<TypePtr>& scalarTypes,
     int maxDepth) {
@@ -948,14 +1010,7 @@ VectorPtr VectorLoaderWrap::makeEncodingPreservedCopy(
   if (decoded.isConstantMapping() || decoded.isIdentityMapping()) {
     VectorPtr result;
     BaseVector::ensureWritable(rows, vector_->type(), vector_->pool(), result);
-    if (result->typeKind() == TypeKind::ROW) {
-      // Avoid calling resize on all children by adding top level nulls only.
-      // We know from the check above that result is unique and isNullsWritable.
-      result->asUnchecked<RowVector>()->appendNulls(
-          vectorSize - result->size());
-    } else {
-      result->resize(vectorSize);
-    }
+    result->resize(vectorSize);
     result->copy(vector_.get(), rows, nullptr);
     return result;
   }
@@ -983,15 +1038,15 @@ VectorPtr VectorLoaderWrap::makeEncodingPreservedCopy(
       [&](auto row) { rawIndices[row] = decodedIndices[row]; });
 
   BufferPtr nulls = nullptr;
-  if (decoded.nulls() || vectorSize > rows.end()) {
+  if (decoded.nulls(&rows) || vectorSize > rows.end()) {
     // We fill [rows.end(), vectorSize) with nulls then copy nulls for selected
     // baseRows.
     nulls = allocateNulls(vectorSize, vector_->pool(), bits::kNull);
     if (baseRows.hasSelections()) {
-      if (decoded.nulls()) {
+      if (decoded.nulls(&rows)) {
         std::memcpy(
             nulls->asMutable<uint64_t>(),
-            decoded.nulls(),
+            decoded.nulls(&rows),
             bits::nbytes(rows.end()));
       } else {
         bits::fillBits(
@@ -1004,9 +1059,7 @@ VectorPtr VectorLoaderWrap::makeEncodingPreservedCopy(
       std::move(nulls), std::move(indices), vectorSize, baseResult);
 }
 
-namespace {
-
-const std::vector<TypePtr> defaultScalarTypes() {
+const std::vector<TypePtr>& defaultScalarTypes() {
   // @TODO Add decimal TypeKinds to randType.
   // Refer https://github.com/facebookincubator/velox/issues/3942
   static std::vector<TypePtr> kScalarTypes{
@@ -1025,33 +1078,11 @@ const std::vector<TypePtr> defaultScalarTypes() {
   };
   return kScalarTypes;
 }
-} // namespace
 
 TypePtr randType(FuzzerGenerator& rng, int maxDepth) {
   return randType(rng, defaultScalarTypes(), maxDepth);
 }
 
-TypePtr randOrderableType(FuzzerGenerator& rng, int maxDepth) {
-  // Should we generate a scalar type?
-  if (maxDepth <= 1 || rand<bool>(rng)) {
-    return randType(rng, 0);
-  }
-
-  // ARRAY or ROW?
-  if (rand<bool>(rng)) {
-    return ARRAY(randOrderableType(rng, maxDepth - 1));
-  }
-
-  auto numFields = 1 + rand<uint32_t>(rng) % 7;
-  std::vector<std::string> names;
-  std::vector<TypePtr> fields;
-  for (int i = 0; i < numFields; ++i) {
-    names.push_back(fmt::format("f{}", i));
-    fields.push_back(randOrderableType(rng, maxDepth - 1));
-  }
-  return ROW(std::move(names), std::move(fields));
-}
-
 TypePtr randType(
     FuzzerGenerator& rng,
     const std::vector<TypePtr>& scalarTypes,
@@ -1073,6 +1104,34 @@ TypePtr randType(
   }
 }
 
+TypePtr randOrderableType(FuzzerGenerator& rng, int maxDepth) {
+  return randOrderableType(rng, defaultScalarTypes(), maxDepth);
+}
+
+TypePtr randOrderableType(
+    FuzzerGenerator& rng,
+    const std::vector<TypePtr>& scalarTypes,
+    int maxDepth) {
+  // Should we generate a scalar type?
+  if (maxDepth <= 1 || rand<bool>(rng)) {
+    return randType(rng, scalarTypes, 0);
+  }
+
+  // ARRAY or ROW?
+  if (rand<bool>(rng)) {
+    return ARRAY(randOrderableType(rng, scalarTypes, maxDepth - 1));
+  }
+
+  auto numFields = 1 + rand<uint32_t>(rng) % 7;
+  std::vector<std::string> names;
+  std::vector<TypePtr> fields;
+  for (int i = 0; i < numFields; ++i) {
+    names.push_back(fmt::format("f{}", i));
+    fields.push_back(randOrderableType(rng, scalarTypes, maxDepth - 1));
+  }
+  return ROW(std::move(names), std::move(fields));
+}
+
 RowTypePtr randRowType(FuzzerGenerator& rng, int maxDepth) {
   return randRowType(rng, defaultScalarTypes(), maxDepth);
 }
diff --git a/velox/vector/fuzzer/VectorFuzzer.h b/velox/vector/fuzzer/VectorFuzzer.h
index 4ac66326aa629..e4a6ec21581f2 100644
--- a/velox/vector/fuzzer/VectorFuzzer.h
+++ b/velox/vector/fuzzer/VectorFuzzer.h
@@ -87,11 +87,14 @@ class VectorFuzzer {
     /// double between 0 and 1).
     double nullRatio{0};
 
-    /// If true, fuzzer will generate top-level nulls for containers
-    /// (arrays/maps/rows), i.e, nulls for the containers themselves, not the
-    /// elements.
+    /// If false, fuzzer will not generate nulls for elements within containers
+    /// (arrays/maps/rows). It might still generate null for the container
+    /// itself.
     ///
-    /// The amount of nulls are controlled by `nullRatio`.
+    /// The amount of nulls (if true) is controlled by `nullRatio`.
+    ///
+    /// If you want to prevent the top-level row containers from being null, see
+    /// `fuzzInputRow()` instead.
     bool containerHasNulls{true};
 
     /// If true, fuzzer will generate top-level nulls for dictionaries.
@@ -122,6 +125,9 @@ class VectorFuzzer {
     /// generating nested vectors (arrays, maps, and rows).
     size_t complexElementsMaxSize{10000};
 
+    /// maximum size of array/map wrapped inside constant.
+    std::optional<int32_t> maxConstantContainerSize{std::nullopt};
+
     /// If true, generated map keys are normalized (unique and not-null).
     bool normalizeMapKeys{true};
 
@@ -143,12 +149,12 @@ class VectorFuzzer {
   };
 
   VectorFuzzer(
-      VectorFuzzer::Options options,
+      const VectorFuzzer::Options& options,
       memory::MemoryPool* pool,
       size_t seed = 123456)
       : opts_(options), pool_(pool), rng_(seed) {}
 
-  void setOptions(VectorFuzzer::Options options) {
+  void setOptions(const VectorFuzzer::Options& options) {
     opts_ = options;
   }
 
@@ -156,118 +162,123 @@ class VectorFuzzer {
     return opts_;
   }
 
-  // Returns a "fuzzed" vector, containing randomized data, nulls, and indices
-  // vector (dictionary). Returns a vector containing `opts_.vectorSize` or
-  // `size` elements.
+  /// Returns a "fuzzed" vector, containing randomized data, nulls, and indices
+  /// vector (dictionary). Returns a vector containing `opts_.vectorSize` or
+  /// `size` elements.
   VectorPtr fuzz(const TypePtr& type);
   VectorPtr fuzz(const TypePtr& type, vector_size_t size);
 
-  // Returns a "fuzzed" vector containing randomized data customized according
-  // to generatorSpec.
+  /// Returns a "fuzzed" vector containing randomized data customized according
+  /// to generatorSpec.
   VectorPtr fuzz(const GeneratorSpec& generatorSpec);
 
-  // Same as above, but returns a vector without nulls (regardless of the value
-  // of opts.nullRatio).
+  /// Same as above, but returns a vector without nulls (regardless of the value
+  /// of opts.nullRatio).
   VectorPtr fuzzNotNull(const TypePtr& type);
   VectorPtr fuzzNotNull(const TypePtr& type, vector_size_t size);
 
-  // Returns a flat vector or a complex vector with flat children with
-  // randomized data and nulls. Returns a vector containing `opts_.vectorSize`
-  // or `size` elements.
+  /// Returns a flat vector or a complex vector with flat children with
+  /// randomized data and nulls. Returns a vector containing `opts_.vectorSize`
+  /// or `size` elements.
   VectorPtr fuzzFlat(const TypePtr& type);
   VectorPtr fuzzFlat(const TypePtr& type, vector_size_t size);
 
-  // Same as above, but returns a vector without nulls (regardless of the value
-  // of opts.nullRatio).
+  /// Same as above, but returns a vector without nulls (regardless of the value
+  /// of opts.nullRatio).
   VectorPtr fuzzFlatNotNull(const TypePtr& type);
   VectorPtr fuzzFlatNotNull(const TypePtr& type, vector_size_t size);
 
-  // Returns a random constant vector (which could be a null constant). Returns
-  // a vector with size set to `opts_.vectorSize` or 'size'.
+  /// Returns a random constant vector (which could be a null constant). Returns
+  /// a vector with size set to `opts_.vectorSize` or 'size'.
   VectorPtr fuzzConstant(const TypePtr& type);
   VectorPtr fuzzConstant(const TypePtr& type, vector_size_t size);
 
-  // Wraps `vector` using a randomized indices vector, returning a
-  // DictionaryVector which has same number of indices as the underlying
-  // `vector` size.
+  /// Wraps `vector` using a randomized indices vector, returning a
+  /// DictionaryVector which has same number of indices as the underlying
+  /// `vector` size.
   VectorPtr fuzzDictionary(const VectorPtr& vector);
   VectorPtr fuzzDictionary(const VectorPtr& vector, vector_size_t size);
 
-  // Uses `elements` as the internal elements vector, wrapping them into an
-  // ArrayVector of `size` rows.
-  //
-  // The number of elements per array row is based on the size of the
-  // `elements` vector and `size`, and either fixed or variable (depending on
-  // `opts.containerVariableLength`).
+  /// Uses `elements` as the internal elements vector, wrapping them into an
+  /// ArrayVector of `size` rows.
+  ///
+  /// The number of elements per array row is based on the size of the
+  /// `elements` vector and `size`, and either fixed or variable (depending on
+  /// `opts.containerVariableLength`).
   ArrayVectorPtr fuzzArray(const VectorPtr& elements, vector_size_t size);
 
-  // Uses `keys` and `values` as the internal elements vectors, wrapping them
-  // into a MapVector of `size` rows.
-  //
-  // The number of elements per map row is based on the size of the `keys` and
-  // `values` vectors and `size`, and either fixed or variable (depending on
-  // `opts.containerVariableLength`).
-  //
-  // If opt.normalizeMapKeys is true, keys will be normalized - duplicated key
-  // values for a particular element will be removed/skipped. In that case, this
-  // method throws if the keys vector has nulls.
+  /// Uses `keys` and `values` as the internal elements vectors, wrapping them
+  /// into a MapVector of `size` rows.
+  ///
+  /// The number of elements per map row is based on the size of the `keys` and
+  /// `values` vectors and `size`, and either fixed or variable (depending on
+  /// `opts.containerVariableLength`).
+  ///
+  /// If opt.normalizeMapKeys is true, keys will be normalized - duplicated key
+  /// values for a particular element will be removed/skipped. In that case,
+  /// this method throws if the keys vector has nulls.
   MapVectorPtr
   fuzzMap(const VectorPtr& keys, const VectorPtr& values, vector_size_t size);
 
-  // Returns a "fuzzed" row vector with randomized data and nulls.
+  /// Returns a "fuzzed" row vector with randomized data and nulls.
   RowVectorPtr fuzzRow(const RowTypePtr& rowType);
 
-  // If allowTopLevelNulls is false, the top level row wont have nulls.
+  /// If allowTopLevelNulls is false, the top level row wont have nulls.
   RowVectorPtr fuzzRow(
       const RowTypePtr& rowType,
       vector_size_t size,
       bool allowTopLevelNulls = true);
 
-  // Returns a RowVector based on the provided vectors, fuzzing its top-level
-  // null buffer.
+  /// Returns a RowVector based on the provided vectors, fuzzing its top-level
+  /// null buffer.
   RowVectorPtr fuzzRow(
       std::vector<VectorPtr>&& children,
       std::vector<std::string> childrenNames,
       vector_size_t size);
 
-  // Returns a RowVector based on the provided vectors, fuzzing its top-level
-  // null buffer.
+  /// Returns a RowVector based on the provided vectors, fuzzing its top-level
+  /// null buffer.
   RowVectorPtr fuzzRow(std::vector<VectorPtr>&& children, vector_size_t size);
 
-  // Same as the function above, but never return nulls for the top-level row
-  // elements.
+  /// Same as the function above, but never return nulls for the top-level row
+  /// elements.
   RowVectorPtr fuzzInputRow(const RowTypePtr& rowType);
 
   /// Same as the function above, but all generated vectors are flat, i.e. no
   /// constant or dictionary-encoded vectors at any level.
   RowVectorPtr fuzzInputFlatRow(const RowTypePtr& rowType);
 
-  // Generates a random type, including maps, vectors, and arrays. maxDepth
-  // limits the maximum level of nesting for complex types. maxDepth <= 1 means
-  // no complex types are allowed.
-  //
-  // There are no options to control type generation yet; these may be added in
-  // the future.
+  /// Generates a random type, including maps, vectors, and arrays. maxDepth
+  /// limits the maximum level of nesting for complex types. maxDepth <= 1 means
+  /// no complex types are allowed.
+  ///
+  /// There are no options to control type generation yet; these may be added in
+  /// the future.
   TypePtr randType(int maxDepth = 5);
 
+  TypePtr randType(const std::vector<TypePtr>& scalarTypes, int maxDepth = 5);
+
   /// Same as the function above, but only generate orderable types.
   /// MAP types are not generated as they are not orderable.
   TypePtr randOrderableType(int maxDepth = 5);
 
-  TypePtr randType(const std::vector<TypePtr>& scalarTypes, int maxDepth = 5);
+  TypePtr randOrderableType(
+      const std::vector<TypePtr>& scalarTypes,
+      int maxDepth = 5);
+
   RowTypePtr randRowType(int maxDepth = 5);
   RowTypePtr randRowType(
       const std::vector<TypePtr>& scalarTypes,
       int maxDepth = 5);
 
-  // Generates short decimal TypePtr with random precision and scale.
+  /// Generates short decimal TypePtr with random precision and scale.
   inline TypePtr randShortDecimalType() {
     auto [precision, scale] =
         randPrecisionScale(ShortDecimalType::kMaxPrecision);
     return DECIMAL(precision, scale);
   }
 
-  // Generates long decimal TypePtr with random precision and scale.
+  /// Generates long decimal TypePtr with random precision and scale.
   inline TypePtr randLongDecimalType() {
     auto [precision, scale] =
         randPrecisionScale(LongDecimalType::kMaxPrecision);
@@ -283,40 +294,40 @@ class VectorFuzzer {
     return boost::random::uniform_01<double>()(rng_) < n;
   }
 
-  // Wraps the given vector in a LazyVector. If there are multiple dictionary
-  // layers then the lazy wrap is applied over the innermost dictionary layer.
+  /// Wraps the given vector in a LazyVector. If there are multiple dictionary
+  /// layers then the lazy wrap is applied over the innermost dictionary layer.
   static VectorPtr wrapInLazyVector(VectorPtr baseVector);
 
-  // Randomly applies wrapInLazyVector() to the children of the given input row
-  // vector. Must only be used for input row vectors where all children are
-  // non-null and non-lazy. Is useful when the input rowVector needs to be
-  // re-used between multiple evaluations.
+  /// Randomly applies wrapInLazyVector() to the children of the given input row
+  /// vector. Must only be used for input row vectors where all children are
+  /// non-null and non-lazy. Is useful when the input rowVector needs to be
+  /// re-used between multiple evaluations.
   RowVectorPtr fuzzRowChildrenToLazy(RowVectorPtr rowVector);
 
-  // Returns a copy of 'rowVector' but with the columns having indices listed in
-  // 'columnsToWrapInLazy' wrapped in lazy encoding. Must only be used for input
-  // row vectors where all children are non-null and non-lazy.
-  // 'columnsToWrapInLazy' can contain negative column indices that represent
-  // lazy vectors that should be preloaded before being fed to the evaluator.
-  // This list is sorted on the absolute value of the entries.
+  /// Returns a copy of 'rowVector' but with the columns having indices listed
+  /// in 'columnsToWrapInLazy' wrapped in lazy encoding. Must only be used for
+  /// input row vectors where all children are non-null and non-lazy.
+  /// 'columnsToWrapInLazy' can contain negative column indices that represent
+  /// lazy vectors that should be preloaded before being fed to the evaluator.
+  /// This list is sorted on the absolute value of the entries.
   static RowVectorPtr fuzzRowChildrenToLazy(
       RowVectorPtr rowVector,
       const std::vector<int>& columnsToWrapInLazy);
 
-  // Generate a random null buffer.
+  /// Generate a random null buffer.
   BufferPtr fuzzNulls(vector_size_t size);
 
-  // Generate a random indices buffer of 'size' with maximum possible index
-  // pointing to (baseVectorSize-1).
+  /// Generate a random indices buffer of 'size' with maximum possible index
+  /// pointing to (baseVectorSize-1).
   BufferPtr fuzzIndices(vector_size_t size, vector_size_t baseVectorSize);
 
  private:
   // Generates a flat vector for primitive types.
   VectorPtr fuzzFlatPrimitive(const TypePtr& type, vector_size_t size);
 
-  /// Generates random precision in range [1, maxPrecision]
+  // Generates random precision in range [1, maxPrecision]
   // and scale in range [0, random precision generated].
-  /// @param maximum precision.
+  // @param maximum precision.
   std::pair<int8_t, int8_t> randPrecisionScale(int8_t maxPrecision);
 
   // Returns a complex vector with randomized data and nulls.  The children and
@@ -356,11 +367,16 @@ class VectorFuzzer {
 /// no complex types are allowed.
 TypePtr randType(FuzzerGenerator& rng, int maxDepth = 5);
 
+TypePtr randType(
+    FuzzerGenerator& rng,
+    const std::vector<TypePtr>& scalarTypes,
+    int maxDepth = 5);
+
 /// Same as the function above, but only generate orderable types.
 /// MAP types are not generated as they are not orderable.
 TypePtr randOrderableType(FuzzerGenerator& rng, int maxDepth = 5);
 
-TypePtr randType(
+TypePtr randOrderableType(
     FuzzerGenerator& rng,
     const std::vector<TypePtr>& scalarTypes,
     int maxDepth = 5);
@@ -373,4 +389,7 @@ RowTypePtr randRowType(
     const std::vector<TypePtr>& scalarTypes,
     int maxDepth = 5);
 
+/// Default set of scalar types to be chosen from when generating random types.
+const std::vector<TypePtr>& defaultScalarTypes();
+
 } // namespace facebook::velox
diff --git a/velox/vector/fuzzer/examples/ArrayGeneratorExample.cpp b/velox/vector/fuzzer/examples/ArrayGeneratorExample.cpp
index 4c9307da64871..23b423dd7256d 100644
--- a/velox/vector/fuzzer/examples/ArrayGeneratorExample.cpp
+++ b/velox/vector/fuzzer/examples/ArrayGeneratorExample.cpp
@@ -38,7 +38,8 @@ int main() {
   auto uniform = std::uniform_int_distribution<int32_t>(lo, hi);
 
   FuzzerGenerator rng;
-  auto pool = memory::addDefaultLeafMemoryPool();
+  memory::MemoryManager::initialize({});
+  auto pool = memory::memoryManager()->addLeafPool();
 
   GeneratorSpecPtr randomArray =
       RANDOM_ARRAY(RANDOM_DOUBLE(normal, nullProbability), uniform);
diff --git a/velox/vector/fuzzer/examples/EncodingGeneratorExample.cpp b/velox/vector/fuzzer/examples/EncodingGeneratorExample.cpp
index 99cee3d38f208..30c99be339ebd 100644
--- a/velox/vector/fuzzer/examples/EncodingGeneratorExample.cpp
+++ b/velox/vector/fuzzer/examples/EncodingGeneratorExample.cpp
@@ -47,7 +47,8 @@ int main() {
   };
 
   FuzzerGenerator rng;
-  auto pool = memory::addDefaultLeafMemoryPool();
+  memory::MemoryManager::initialize({});
+  auto pool = memory::memoryManager()->addLeafPool();
   GeneratorSpecPtr encodedNormalDoubleGenerator =
       ENCODE(RANDOM_DOUBLE(normal, nullProbability), encoding, 1, 5, 0.3);
 
diff --git a/velox/vector/fuzzer/examples/MapGeneratorExample.cpp b/velox/vector/fuzzer/examples/MapGeneratorExample.cpp
index a1f04cc157936..7feaac6dc9003 100644
--- a/velox/vector/fuzzer/examples/MapGeneratorExample.cpp
+++ b/velox/vector/fuzzer/examples/MapGeneratorExample.cpp
@@ -39,7 +39,8 @@ int main() {
   auto normal = std::normal_distribution<double>(mu, sigma);
 
   FuzzerGenerator rng;
-  auto pool = memory::addDefaultLeafMemoryPool();
+  memory::MemoryManager::initialize({});
+  auto pool = memory::memoryManager()->addLeafPool();
 
   GeneratorSpecPtr randomMap =
       RANDOM_MAP(RANDOM_INTEGER(uniform), RANDOM_DOUBLE(normal), lengthDist);
diff --git a/velox/vector/fuzzer/examples/RowGeneratorExample.cpp b/velox/vector/fuzzer/examples/RowGeneratorExample.cpp
index 30d5b0439f1c4..9e96dfff9be0e 100644
--- a/velox/vector/fuzzer/examples/RowGeneratorExample.cpp
+++ b/velox/vector/fuzzer/examples/RowGeneratorExample.cpp
@@ -39,7 +39,8 @@ int main() {
   auto bernoulli = std::bernoulli_distribution(p);
 
   FuzzerGenerator rng;
-  auto pool = memory::addDefaultLeafMemoryPool();
+  memory::MemoryManager::initialize({});
+  auto pool = memory::memoryManager()->addLeafPool();
 
   GeneratorSpecPtr randomRow = RANDOM_ROW(
       {RANDOM_INTEGER(uniform),
diff --git a/velox/vector/fuzzer/examples/ScalarGeneratorExample.cpp b/velox/vector/fuzzer/examples/ScalarGeneratorExample.cpp
index 7abb1dd2e1a30..67acbd8fa76f3 100644
--- a/velox/vector/fuzzer/examples/ScalarGeneratorExample.cpp
+++ b/velox/vector/fuzzer/examples/ScalarGeneratorExample.cpp
@@ -49,7 +49,8 @@ int main() {
   };
 
   FuzzerGenerator rng;
-  auto pool = memory::addDefaultLeafMemoryPool();
+  memory::MemoryManager::initialize({});
+  auto pool = memory::memoryManager()->addLeafPool();
 
   GeneratorSpecPtr uniformIntGenerator =
       RANDOM_INTEGER(uniform, nullProbability);
diff --git a/velox/vector/fuzzer/tests/CMakeLists.txt b/velox/vector/fuzzer/tests/CMakeLists.txt
index 760dca8ad112c..4b8fdb65f5d08 100644
--- a/velox/vector/fuzzer/tests/CMakeLists.txt
+++ b/velox/vector/fuzzer/tests/CMakeLists.txt
@@ -15,5 +15,10 @@ add_executable(velox_vector_fuzzer_test VectorFuzzerTest.cpp)
 
 add_test(velox_vector_fuzzer_test velox_vector_fuzzer_test)
 
-target_link_libraries(velox_vector_fuzzer_test velox_vector_fuzzer velox_memory
-                      gtest gtest_main gmock)
+target_link_libraries(
+  velox_vector_fuzzer_test
+  velox_vector_fuzzer
+  velox_memory
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock)
diff --git a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
index 9fe1b08925dca..78827c6ba17e1 100644
--- a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
+++ b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
@@ -27,6 +27,10 @@ namespace {
 
 class VectorFuzzerTest : public testing::Test {
  public:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   memory::MemoryPool* pool() const {
     return pool_.get();
   }
@@ -78,7 +82,8 @@ class VectorFuzzerTest : public testing::Test {
   void validateMaxSizes(VectorPtr vector, size_t maxSize);
 
  private:
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 };
 
 TEST_F(VectorFuzzerTest, flatPrimitive) {
@@ -415,6 +420,100 @@ TEST_F(VectorFuzzerTest, row) {
       vector->type()->asRow().names(), ::testing::ElementsAre("c0", "c1"));
 }
 
+TEST_F(VectorFuzzerTest, containerHasNulls) {
+  auto countNulls = [](const VectorPtr& vec) {
+    if (!vec->nulls()) {
+      return 0;
+    }
+    return BaseVector::countNulls(vec->nulls(), vec->size());
+  };
+
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 1000;
+  opts.nullRatio = 0.5;
+  opts.normalizeMapKeys = false;
+  opts.containerHasNulls = true;
+
+  {
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto arrayVector = fuzzer.fuzz(ARRAY(BIGINT()));
+    auto mapVector = fuzzer.fuzz(MAP(BIGINT(), BIGINT()));
+    auto rowVector = fuzzer.fuzz(ROW({BIGINT(), BIGINT()}));
+
+    // Check that both top level and elements have nulls.
+    EXPECT_GT(countNulls(arrayVector), 0);
+    EXPECT_GT(countNulls(mapVector), 0);
+    EXPECT_GT(countNulls(rowVector), 0);
+
+    auto arrayElements = arrayVector->as<ArrayVector>()->elements();
+    auto mapKeys = mapVector->as<MapVector>()->mapKeys();
+    auto mapValues = mapVector->as<MapVector>()->mapValues();
+    auto rowCol0 = rowVector->as<RowVector>()->childAt(0);
+    auto rowCol1 = rowVector->as<RowVector>()->childAt(1);
+
+    EXPECT_GT(countNulls(arrayElements), 0);
+    EXPECT_GT(countNulls(mapKeys), 0);
+    EXPECT_GT(countNulls(mapValues), 0);
+    EXPECT_GT(countNulls(rowCol0), 0);
+    EXPECT_GT(countNulls(rowCol1), 0);
+  }
+
+  // Test with containerHasNulls false.
+  {
+    opts.containerHasNulls = false;
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto arrayVector = fuzzer.fuzz(ARRAY(BIGINT()));
+    auto mapVector = fuzzer.fuzz(MAP(BIGINT(), BIGINT()));
+    auto rowVector = fuzzer.fuzz(ROW({BIGINT(), BIGINT()}));
+
+    // Check that both top level and elements have nulls.
+    EXPECT_GT(countNulls(arrayVector), 0);
+    EXPECT_GT(countNulls(mapVector), 0);
+    EXPECT_GT(countNulls(rowVector), 0);
+
+    auto arrayElements = arrayVector->as<ArrayVector>()->elements();
+    auto mapKeys = mapVector->as<MapVector>()->mapKeys();
+    auto mapValues = mapVector->as<MapVector>()->mapValues();
+    auto rowCol0 = rowVector->as<RowVector>()->childAt(0);
+    auto rowCol1 = rowVector->as<RowVector>()->childAt(1);
+
+    EXPECT_EQ(countNulls(arrayElements), 0);
+    EXPECT_EQ(countNulls(mapKeys), 0);
+    EXPECT_EQ(countNulls(mapValues), 0);
+    EXPECT_EQ(countNulls(rowCol0), 0);
+    EXPECT_EQ(countNulls(rowCol1), 0);
+  }
+
+  // Test with containerHasNulls false. Flat vector version.
+  {
+    opts.containerHasNulls = false;
+    VectorFuzzer fuzzer(opts, pool());
+
+    auto arrayVector = fuzzer.fuzzFlat(ARRAY(BIGINT()));
+    auto mapVector = fuzzer.fuzzFlat(MAP(BIGINT(), BIGINT()));
+    auto rowVector = fuzzer.fuzzFlat(ROW({BIGINT(), BIGINT()}));
+
+    // Check that both top level and elements have nulls.
+    EXPECT_GT(countNulls(arrayVector), 0);
+    EXPECT_GT(countNulls(mapVector), 0);
+    EXPECT_GT(countNulls(rowVector), 0);
+
+    auto arrayElements = arrayVector->as<ArrayVector>()->elements();
+    auto mapKeys = mapVector->as<MapVector>()->mapKeys();
+    auto mapValues = mapVector->as<MapVector>()->mapValues();
+    auto rowCol0 = rowVector->as<RowVector>()->childAt(0);
+    auto rowCol1 = rowVector->as<RowVector>()->childAt(1);
+
+    EXPECT_EQ(countNulls(arrayElements), 0);
+    EXPECT_EQ(countNulls(mapKeys), 0);
+    EXPECT_EQ(countNulls(mapValues), 0);
+    EXPECT_EQ(countNulls(rowCol0), 0);
+    EXPECT_EQ(countNulls(rowCol1), 0);
+  }
+}
+
 FlatVectorPtr<Timestamp> genTimestampVector(
     VectorFuzzer::Options::TimestampPrecision precision,
     size_t vectorSize,
diff --git a/velox/vector/tests/BiasVectorTest.cpp b/velox/vector/tests/BiasVectorTest.cpp
index 71e54ad8db9cb..748362180cef1 100644
--- a/velox/vector/tests/BiasVectorTest.cpp
+++ b/velox/vector/tests/BiasVectorTest.cpp
@@ -24,8 +24,12 @@ namespace facebook::velox::test {
 
 class BiasVectorTestBase : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   std::shared_ptr<velox::memory::MemoryPool> pool_{
-      memory::addDefaultLeafMemoryPool()};
+      memory::memoryManager()->addLeafPool()};
   VectorMaker vectorMaker_{pool_.get()};
 };
 
diff --git a/velox/vector/tests/CMakeLists.txt b/velox/vector/tests/CMakeLists.txt
index 2bddb76147a5a..cd60657f123b1 100644
--- a/velox/vector/tests/CMakeLists.txt
+++ b/velox/vector/tests/CMakeLists.txt
@@ -15,24 +15,26 @@ add_subdirectory(utils)
 
 add_executable(
   velox_vector_test
-  VectorCompareTest.cpp
-  VectorSaverTest.cpp
-  VectorMakerTest.cpp
-  VectorPoolTest.cpp
-  VectorPrinterTest.cpp
-  VectorTest.cpp
-  VectorStreamTest.cpp
-  VectorToStringTest.cpp
-  VectorEstimateFlatSizeTest.cpp
-  VectorPrepareForReuseTest.cpp
+  CopyPreserveEncodingsTest.cpp
   DecodedVectorTest.cpp
-  SelectivityVectorTest.cpp
+  EncodingTest.cpp
   EnsureWritableVectorTest.cpp
   IsWritableVectorTest.cpp
   LazyVectorTest.cpp
   MayHaveNullsRecursiveTest.cpp
+  SelectivityVectorTest.cpp
   VariantToVectorTest.cpp
-  VectorTestUtils.cpp)
+  VectorCompareTest.cpp
+  VectorEstimateFlatSizeTest.cpp
+  VectorMakerTest.cpp
+  VectorPoolTest.cpp
+  VectorPrepareForReuseTest.cpp
+  VectorPrinterTest.cpp
+  VectorSaverTest.cpp
+  VectorStreamTest.cpp
+  VectorTest.cpp
+  VectorTestUtils.cpp
+  VectorToStringTest.cpp)
 
 add_test(velox_vector_test velox_vector_test)
 
@@ -55,8 +57,8 @@ target_link_libraries(
   Boost::regex
   Boost::thread
   Boost::system
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   Folly::folly
   gflags::gflags
   glog::glog
@@ -73,8 +75,8 @@ target_link_libraries(
   velox_buffer
   velox_type
   velox_vector_test_lib
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   Folly::folly
   gflags::gflags
   glog::glog
@@ -88,8 +90,8 @@ target_link_libraries(
   bias_vector_test
   velox_vector
   Boost::filesystem
-  gtest
-  gtest_main
+  GTest::gtest
+  GTest::gtest_main
   Folly::folly
   gflags::gflags
   glog::glog
diff --git a/velox/vector/tests/CopyPreserveEncodingsTest.cpp b/velox/vector/tests/CopyPreserveEncodingsTest.cpp
new file mode 100644
index 0000000000000..83e71e76c74aa
--- /dev/null
+++ b/velox/vector/tests/CopyPreserveEncodingsTest.cpp
@@ -0,0 +1,368 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::test {
+
+class CopyPreserveEncodingsTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<velox::memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  VectorMaker vectorMaker_{pool_.get()};
+
+  enum class TestOptions {
+    WITH_NULLS,
+  };
+
+  std::vector<std::optional<int32_t>> generateIntInput() {
+    return generateIntInput(false);
+  }
+
+  std::vector<std::optional<int32_t>> generateIntInputWithNulls() {
+    return generateIntInput(true);
+  }
+
+  ArrayVectorPtr generateArrayVector(
+      const std::unordered_set<TestOptions>& testOptions = {}) {
+    std::function<bool(vector_size_t)> noNulls = nullptr;
+
+    return vectorMaker_.arrayVector<int32_t>(
+        10,
+        [](vector_size_t row) { return row; },
+        [](vector_size_t idx) { return idx; },
+        testOptions.count(TestOptions::WITH_NULLS) > 0
+            ? [](vector_size_t row) { return row % 5 == 0; }
+            : noNulls,
+        testOptions.count(TestOptions::WITH_NULLS) > 0
+            ? [](vector_size_t idx) { return idx % 7 == 0; }
+            : noNulls);
+  }
+
+  MapVectorPtr generateMapVector(
+      const std::unordered_set<TestOptions>& testOptions = {}) {
+    std::function<bool(vector_size_t)> noNulls = nullptr;
+
+    return vectorMaker_.mapVector<int32_t, int32_t>(
+        10,
+        [](vector_size_t row) { return row; },
+        [](vector_size_t idx) { return idx; },
+        [](vector_size_t idx) { return idx % 10; },
+        testOptions.count(TestOptions::WITH_NULLS) > 0
+            ? [&](vector_size_t row) { return row % 5 == 0; }
+            : noNulls,
+        testOptions.count(TestOptions::WITH_NULLS) > 0
+            ? [&](vector_size_t row) { return row % 7 == 0; }
+            : noNulls);
+  }
+
+  template <TypeKind kind>
+  void validateCopyPreserveEncodingsSimpleVector(
+      const VectorPtr& base,
+      const VectorPtr& copy) {
+    using T = typename TypeTraits<kind>::NativeType;
+
+    switch (base->encoding()) {
+      case VectorEncoding::Simple::BIASED: {
+        auto* baseBiased = base->as<BiasVector<T>>();
+        auto* copyBiased = copy->as<BiasVector<T>>();
+        ASSERT_NE(baseBiased->values(), copyBiased->values());
+        break;
+      }
+      case VectorEncoding::Simple::CONSTANT: {
+        auto* baseConstant = base->as<ConstantVector<T>>();
+        auto* copyConstant = copy->as<ConstantVector<T>>();
+        if (baseConstant->valueVector() != nullptr) {
+          validateCopyPreserveEncodings(
+              baseConstant->valueVector(), copyConstant->valueVector());
+        }
+        break;
+      }
+      case VectorEncoding::Simple::DICTIONARY: {
+        auto* baseDictionary = base->as<DictionaryVector<T>>();
+        auto* copyDictionary = copy->as<DictionaryVector<T>>();
+        validateCopyPreserveEncodings(
+            baseDictionary->valueVector(), copyDictionary->valueVector());
+        ASSERT_NE(baseDictionary->indices(), copyDictionary->indices());
+        break;
+      }
+      case VectorEncoding::Simple::FLAT: {
+        auto* baseFlat = base->as<FlatVector<T>>();
+        auto* copyFlat = copy->as<FlatVector<T>>();
+        ASSERT_NE(baseFlat->values(), copyFlat->values());
+        break;
+      }
+      case VectorEncoding::Simple::SEQUENCE: {
+        auto* baseSequence = base->as<SequenceVector<T>>();
+        auto* copySequence = copy->as<SequenceVector<T>>();
+        validateCopyPreserveEncodings(
+            baseSequence->valueVector(), copySequence->valueVector());
+        ASSERT_NE(
+            baseSequence->getSequenceLengths(),
+            copySequence->getSequenceLengths());
+        break;
+      }
+      default:
+        VELOX_FAIL(
+            "{} is not a supported SimpleVector encoding", base->encoding());
+    }
+  }
+
+  void validateCopyPreserveEncodings(
+      const VectorPtr& base,
+      const VectorPtr& copy) {
+    ASSERT_NE(base, copy);
+    ASSERT_EQ(base->encoding(), copy->encoding());
+
+    if (base->nulls() == nullptr) {
+      ASSERT_EQ(copy->nulls(), nullptr);
+    } else {
+      ASSERT_NE(base->nulls(), copy->nulls());
+    }
+
+    switch (base->encoding()) {
+      case VectorEncoding::Simple::ARRAY: {
+        auto* baseArray = base->as<ArrayVector>();
+        auto* copyArray = copy->as<ArrayVector>();
+        ASSERT_NE(baseArray->offsets(), copyArray->offsets());
+        ASSERT_NE(baseArray->sizes(), copyArray->sizes());
+        validateCopyPreserveEncodings(
+            baseArray->elements(), copyArray->elements());
+        break;
+      }
+      case VectorEncoding::Simple::ROW: {
+        auto* baseRow = base->as<RowVector>();
+        auto* copyRow = copy->as<RowVector>();
+        ASSERT_EQ(baseRow->childrenSize(), copyRow->childrenSize());
+        for (int i = 0; i < baseRow->childrenSize(); i++) {
+          validateCopyPreserveEncodings(
+              baseRow->childAt(i), copyRow->childAt(i));
+        }
+        break;
+      }
+      case VectorEncoding::Simple::MAP: {
+        auto* baseMap = base->as<MapVector>();
+        auto* copyMap = copy->as<MapVector>();
+        ASSERT_NE(baseMap->offsets(), copyMap->offsets());
+        ASSERT_NE(baseMap->sizes(), copyMap->sizes());
+        validateCopyPreserveEncodings(baseMap->mapKeys(), copyMap->mapKeys());
+        validateCopyPreserveEncodings(
+            baseMap->mapValues(), copyMap->mapValues());
+        break;
+      }
+      case VectorEncoding::Simple::BIASED:
+      case VectorEncoding::Simple::CONSTANT:
+      case VectorEncoding::Simple::DICTIONARY:
+      case VectorEncoding::Simple::FLAT:
+      case VectorEncoding::Simple::SEQUENCE:
+        VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+            validateCopyPreserveEncodingsSimpleVector,
+            base->typeKind(),
+            base,
+            copy);
+        break;
+      default:
+        VELOX_FAIL("{} is not a supported encoding", base->encoding());
+    }
+  }
+
+ private:
+  std::vector<std::optional<int32_t>> generateIntInput(bool withNulls) {
+    std::vector<std::optional<int32_t>> input;
+    for (int32_t i = 0; i < 10; ++i) {
+      if (withNulls && i % 5 == 0) {
+        input.push_back(std::nullopt);
+      } else {
+        input.push_back(i);
+      }
+    }
+
+    return input;
+  }
+};
+
+TEST_F(CopyPreserveEncodingsTest, biasHasNulls) {
+  auto biasVector = vectorMaker_.biasVector(generateIntInputWithNulls());
+  auto copy = biasVector->copyPreserveEncodings();
+
+  assertEqualVectors(biasVector, copy);
+  validateCopyPreserveEncodings(biasVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, biasNoNulls) {
+  auto biasVector = vectorMaker_.biasVector(generateIntInput());
+  auto copy = biasVector->copyPreserveEncodings();
+
+  assertEqualVectors(biasVector, copy);
+  validateCopyPreserveEncodings(biasVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, arrayHasNulls) {
+  auto arrayVector = generateArrayVector({TestOptions::WITH_NULLS});
+  auto copy = arrayVector->copyPreserveEncodings();
+
+  assertEqualVectors(arrayVector, copy);
+  validateCopyPreserveEncodings(arrayVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, arrayNoNulls) {
+  auto arrayVector = generateArrayVector();
+  auto copy = arrayVector->copyPreserveEncodings();
+
+  assertEqualVectors(arrayVector, copy);
+  validateCopyPreserveEncodings(arrayVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, mapHasNulls) {
+  auto mapVector = generateMapVector({TestOptions::WITH_NULLS});
+  auto copy = mapVector->copyPreserveEncodings();
+
+  assertEqualVectors(mapVector, copy);
+  validateCopyPreserveEncodings(mapVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, mapNoNulls) {
+  auto mapVector = generateMapVector();
+  auto copy = mapVector->copyPreserveEncodings();
+
+  assertEqualVectors(mapVector, copy);
+  validateCopyPreserveEncodings(mapVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, rowHasNulls) {
+  auto rowVector = vectorMaker_.rowVector(
+      {vectorMaker_.flatVectorNullable(generateIntInput()),
+       generateArrayVector(),
+       generateMapVector()});
+
+  rowVector->setNull(3, true);
+  auto copy = rowVector->copyPreserveEncodings();
+
+  assertEqualVectors(rowVector, copy);
+  validateCopyPreserveEncodings(rowVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, rowNoNulls) {
+  auto rowVector = vectorMaker_.rowVector(
+      {vectorMaker_.flatVectorNullable(generateIntInput()),
+       generateArrayVector(),
+       generateMapVector()});
+  auto copy = rowVector->copyPreserveEncodings();
+
+  assertEqualVectors(rowVector, copy);
+  validateCopyPreserveEncodings(rowVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, constantNull) {
+  auto constantVector = vectorMaker_.constantVector<int32_t>({std::nullopt});
+  auto copy = constantVector->copyPreserveEncodings();
+
+  assertEqualVectors(constantVector, copy);
+  validateCopyPreserveEncodings(constantVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, constantNoNulls) {
+  auto constantVector = vectorMaker_.constantVector<int32_t>({1});
+  auto copy = constantVector->copyPreserveEncodings();
+
+  assertEqualVectors(constantVector, copy);
+  validateCopyPreserveEncodings(constantVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, dictionaryHasNulls) {
+  auto dictionaryVector =
+      vectorMaker_.dictionaryVector(generateIntInputWithNulls());
+  auto copy = dictionaryVector->copyPreserveEncodings();
+
+  assertEqualVectors(dictionaryVector, copy);
+  validateCopyPreserveEncodings(dictionaryVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, dictionaryNoNulls) {
+  auto dictionaryVector = vectorMaker_.dictionaryVector(generateIntInput());
+  auto copy = dictionaryVector->copyPreserveEncodings();
+
+  assertEqualVectors(dictionaryVector, copy);
+  validateCopyPreserveEncodings(dictionaryVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, flatHasNulls) {
+  auto flatVector =
+      vectorMaker_.flatVectorNullable(generateIntInputWithNulls());
+  auto copy = flatVector->copyPreserveEncodings();
+
+  assertEqualVectors(flatVector, copy);
+  validateCopyPreserveEncodings(flatVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, flatNoNulls) {
+  auto flatVector = vectorMaker_.flatVectorNullable(generateIntInput());
+  auto copy = flatVector->copyPreserveEncodings();
+
+  assertEqualVectors(flatVector, copy);
+  validateCopyPreserveEncodings(flatVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, lazyNoNulls) {
+  auto lazyVector = vectorMaker_.lazyFlatVector<int32_t>(
+      10, [](vector_size_t row) { return row; });
+
+  VELOX_ASSERT_THROW(
+      lazyVector->copyPreserveEncodings(),
+      "copyPreserveEncodings not defined for LazyVector");
+}
+
+TEST_F(CopyPreserveEncodingsTest, sequenceHasNulls) {
+  auto sequenceVector =
+      vectorMaker_.sequenceVector(generateIntInputWithNulls());
+  auto copy = sequenceVector->copyPreserveEncodings();
+
+  assertEqualVectors(sequenceVector, copy);
+  validateCopyPreserveEncodings(sequenceVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, sequenceNoNulls) {
+  auto sequenceVector = vectorMaker_.sequenceVector(generateIntInput());
+  auto copy = sequenceVector->copyPreserveEncodings();
+
+  assertEqualVectors(sequenceVector, copy);
+  validateCopyPreserveEncodings(sequenceVector, copy);
+}
+
+TEST_F(CopyPreserveEncodingsTest, newMemoryPool) {
+  auto dictionaryVector = vectorMaker_.dictionaryVector(generateIntInput());
+
+  auto sourcePool = dictionaryVector->pool();
+  auto targetPool = memory::memoryManager()->addLeafPool();
+  auto preCopySrcMemory = sourcePool->usedBytes();
+  ASSERT_EQ(0, targetPool->usedBytes());
+
+  auto copy = dictionaryVector->copyPreserveEncodings(targetPool.get());
+  assertEqualVectors(dictionaryVector, copy);
+  validateCopyPreserveEncodings(dictionaryVector, copy);
+
+  EXPECT_EQ(preCopySrcMemory, sourcePool->usedBytes());
+  EXPECT_EQ(preCopySrcMemory, targetPool->usedBytes());
+}
+} // namespace facebook::velox::test
diff --git a/velox/vector/tests/DecodedVectorTest.cpp b/velox/vector/tests/DecodedVectorTest.cpp
index b84f9b87c46e9..c9c3f6be9f5bb 100644
--- a/velox/vector/tests/DecodedVectorTest.cpp
+++ b/velox/vector/tests/DecodedVectorTest.cpp
@@ -32,6 +32,10 @@ namespace facebook::velox::test {
 
 class DecodedVectorTest : public testing::Test, public VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   DecodedVectorTest() : allSelected_(10010), halfSelected_(10010) {
     allSelected_.setAll();
     halfSelected_.setAll();
@@ -40,19 +44,26 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
     }
   }
 
-  void assertNoNulls(DecodedVector& decodedVector) {
-    ASSERT_TRUE(decodedVector.nulls() == nullptr);
+  void assertNoNulls(
+      DecodedVector& decodedVector,
+      const SelectivityVector* rows = nullptr) {
+    ASSERT_TRUE(decodedVector.nulls(nullptr) == nullptr);
     for (auto i = 0; i < decodedVector.size(); ++i) {
       ASSERT_FALSE(decodedVector.isNullAt(i));
     }
   }
 
-  void assertNulls(const VectorPtr& vector, DecodedVector& decodedVector) {
+  void assertNulls(
+      const VectorPtr& vector,
+      DecodedVector& decodedVector,
+      const SelectivityVector* rows = nullptr) {
     SCOPED_TRACE(vector->toString(true));
-    ASSERT_TRUE(decodedVector.nulls() != nullptr);
+    ASSERT_TRUE(decodedVector.nulls(rows) != nullptr);
     for (auto i = 0; i < decodedVector.size(); ++i) {
       ASSERT_EQ(decodedVector.isNullAt(i), vector->isNullAt(i));
-      ASSERT_EQ(bits::isBitNull(decodedVector.nulls(), i), vector->isNullAt(i));
+      ASSERT_EQ(
+          bits::isBitNull(decodedVector.nulls(nullptr), i),
+          vector->isNullAt(i));
     }
   }
 
@@ -137,7 +148,7 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
     auto check = [&](auto& decoded) {
       EXPECT_TRUE(decoded.isConstantMapping());
       EXPECT_TRUE(!decoded.isIdentityMapping());
-      EXPECT_TRUE(decoded.nulls() == nullptr);
+      EXPECT_TRUE(decoded.nulls(nullptr) == nullptr);
       for (int32_t i = 0; i < 100; i++) {
         EXPECT_FALSE(decoded.isNullAt(i));
         EXPECT_EQ(decoded.template valueAt<T>(i), value);
@@ -167,13 +178,13 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
       EXPECT_EQ(base->encoding(), decoded.base()->encoding());
       bool isNull = base->isNullAt(index);
       if (isNull) {
-        EXPECT_TRUE(decoded.nulls() != nullptr);
+        EXPECT_TRUE(decoded.nulls(nullptr) != nullptr);
         for (int32_t i = 0; i < 100; i++) {
           EXPECT_TRUE(decoded.isNullAt(i)) << "at " << i;
-          EXPECT_TRUE(bits::isBitNull(decoded.nulls(), i)) << "at " << i;
+          EXPECT_TRUE(bits::isBitNull(decoded.nulls(nullptr), i)) << "at " << i;
         }
       } else {
-        EXPECT_TRUE(decoded.nulls() == nullptr);
+        EXPECT_TRUE(decoded.nulls(nullptr) == nullptr);
         for (int32_t i = 0; i < 100; i++) {
           EXPECT_FALSE(decoded.isNullAt(i));
           EXPECT_TRUE(
@@ -243,10 +254,10 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
       }
       EXPECT_TRUE(decoded.isConstantMapping());
       EXPECT_TRUE(!decoded.isIdentityMapping());
-      ASSERT_TRUE(decoded.nulls() != nullptr);
+      ASSERT_TRUE(decoded.nulls(nullptr) != nullptr);
       for (int32_t i = 0; i < 100; i++) {
         EXPECT_TRUE(decoded.isNullAt(i));
-        EXPECT_TRUE(bits::isBitNull(decoded.nulls(), i));
+        EXPECT_TRUE(bits::isBitNull(decoded.nulls(nullptr), i));
       }
     };
 
@@ -328,7 +339,7 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
     auto check = [&](auto& decoded) {
       ASSERT_FALSE(decoded.isIdentityMapping());
       ASSERT_FALSE(decoded.isConstantMapping());
-      ASSERT_TRUE(decoded.nulls() != nullptr);
+      ASSERT_TRUE(decoded.nulls(nullptr) != nullptr);
       for (auto i = 0; i < dictionarySize; i++) {
         if (i % 2 == 0) {
           ASSERT_TRUE(decoded.isNullAt(i)) << "at " << i;
@@ -337,7 +348,8 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
         }
         ASSERT_EQ(decoded.isNullAt(i), dictionaryVector->isNullAt(i));
         ASSERT_EQ(
-            bits::isBitNull(decoded.nulls(), i), dictionaryVector->isNullAt(i));
+            bits::isBitNull(decoded.nulls(nullptr), i),
+            dictionaryVector->isNullAt(i));
       }
     };
 
@@ -602,7 +614,7 @@ TEST_F(DecodedVectorTest, dictionaryOverLazy) {
     checkUnloaded(decoded);
   }
   dictionaryVector->loadedVector();
-  EXPECT_TRUE(dictionaryVector->valueVector()->as<LazyVector>()->isLoaded());
+  EXPECT_TRUE(!dictionaryVector->valueVector()->isLazy());
   {
     SelectivityVector selection(dictionarySize);
     DecodedVector decoded(*dictionaryVector, selection, false);
@@ -1183,14 +1195,14 @@ TEST_F(DecodedVectorTest, flatNulls) {
   }
 
   // Flat vector with nulls.
-  auto flatWithNulls = makeFlatVector<int64_t>(
-      100, [](auto row) { return row; }, nullEvery(7));
+  auto flatWithNulls =
+      makeFlatVector<int64_t>(100, [](auto row) { return row; }, nullEvery(7));
 
   auto check = [&](auto& d) {
-    ASSERT_TRUE(d.nulls() != nullptr);
+    ASSERT_TRUE(d.nulls(nullptr) != nullptr);
     for (auto i = 0; i < 100; ++i) {
       ASSERT_EQ(d.isNullAt(i), i % 7 == 0);
-      ASSERT_EQ(bits::isBitNull(d.nulls(), i), i % 7 == 0);
+      ASSERT_EQ(bits::isBitNull(d.nulls(nullptr), i), i % 7 == 0);
     }
   };
 
@@ -1211,13 +1223,13 @@ TEST_F(DecodedVectorTest, dictionaryOverFlatNulls) {
   DecodedVector d;
 
   auto flatNoNulls = makeFlatVector<int64_t>(100, [](auto row) { return row; });
-  auto flatWithNulls = makeFlatVector<int64_t>(
-      100, [](auto row) { return row; }, nullEvery(7));
+  auto flatWithNulls =
+      makeFlatVector<int64_t>(100, [](auto row) { return row; }, nullEvery(7));
 
   auto decodeAndCheckNulls = [&](auto& vector) {
     {
       d.decode(*vector, rows);
-      assertNulls(vector, d);
+      assertNulls(vector, d, &rows);
     }
 
     {
@@ -1229,7 +1241,7 @@ TEST_F(DecodedVectorTest, dictionaryOverFlatNulls) {
   auto decodeAndCheckNotNulls = [&](auto& vector) {
     {
       d.decode(*vector, rows);
-      assertNoNulls(d);
+      assertNoNulls(d, &rows);
     }
 
     {
@@ -1427,4 +1439,51 @@ TEST_F(DecodedVectorTest, previousIndicesInReUsedDecodedVector) {
   EXPECT_EQ(rawIndices[0], 0);
 }
 
+TEST_F(DecodedVectorTest, toString) {
+  auto vector = makeNullableFlatVector<int32_t>({1, std::nullopt, 3});
+  {
+    DecodedVector decoded(*vector);
+    EXPECT_EQ("1", decoded.toString(0));
+    EXPECT_EQ("null", decoded.toString(1));
+    EXPECT_EQ("3", decoded.toString(2));
+  }
+
+  auto dict = wrapInDictionary(makeIndicesInReverse(3), vector);
+  {
+    DecodedVector decoded(*dict);
+    EXPECT_EQ("3", decoded.toString(0));
+    EXPECT_EQ("null", decoded.toString(1));
+    EXPECT_EQ("1", decoded.toString(2));
+  }
+
+  auto constant = makeConstant<int32_t>(123, 10);
+  {
+    DecodedVector decoded(*constant);
+    EXPECT_EQ("123", decoded.toString(0));
+    EXPECT_EQ("123", decoded.toString(1));
+    EXPECT_EQ("123", decoded.toString(2));
+  }
+
+  constant = makeNullConstant(TypeKind::INTEGER, 5);
+  {
+    DecodedVector decoded(*constant);
+    EXPECT_EQ("null", decoded.toString(0));
+    EXPECT_EQ("null", decoded.toString(1));
+    EXPECT_EQ("null", decoded.toString(2));
+  }
+
+  dict = BaseVector::wrapInDictionary(
+      makeNulls(10, nullEvery(2)),
+      makeIndices(10, [](auto row) { return row % 3; }),
+      10,
+      makeFlatVector<int32_t>({1, 2, 3}));
+  {
+    DecodedVector decoded(*dict);
+    EXPECT_EQ("null", decoded.toString(0));
+    EXPECT_EQ("2", decoded.toString(1));
+    EXPECT_EQ("null", decoded.toString(2));
+    EXPECT_EQ("1", decoded.toString(3));
+  }
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/vector/tests/EncodingTest.cpp b/velox/vector/tests/EncodingTest.cpp
new file mode 100644
index 0000000000000..3ec1a77e676a4
--- /dev/null
+++ b/velox/vector/tests/EncodingTest.cpp
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/VectorMap.h"
+#include "velox/vector/tests/VectorTestUtils.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+class EncodingTest : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+    if (!isRegisteredVectorSerde()) {
+      facebook::velox::serializer::presto::PrestoVectorSerde::
+          registerVectorSerde();
+    }
+  }
+
+  EncodingTest() = default;
+
+  template <typename T>
+  T testValue(int32_t i, BufferPtr& space) {
+    return i;
+  }
+
+  VectorPtr mapFromScalar(VectorPtr vector, int itemsPerMap) {
+    auto keys = makeFlatVector<int32_t>(
+        vector->size(), [&](auto row) { return row % itemsPerMap; });
+    auto numMaps = bits::roundUp(vector->size(), itemsPerMap) / itemsPerMap;
+    auto sizes = makeIndices(numMaps, [&](auto) { return itemsPerMap; });
+    auto offsets =
+        makeIndices(numMaps, [&](auto row) { return row * itemsPerMap; });
+    return std::make_shared<MapVector>(
+        pool_.get(),
+        MAP(keys->type(), vector->type()),
+        BufferPtr(nullptr),
+        numMaps,
+        offsets,
+        sizes,
+        keys,
+        vector);
+  }
+
+  template <TypeKind KIND>
+  VectorPtr createScalar(
+      TypePtr type,
+      vector_size_t size,
+      int32_t numDistinct,
+      int32_t step,
+      bool withNulls) {
+    using T = typename TypeTraits<KIND>::NativeType;
+    BufferPtr buffer;
+    VectorPtr base = BaseVector::create(type, size, pool());
+    auto flat = std::dynamic_pointer_cast<FlatVector<T>>(base);
+    for (int32_t i = 0; i < flat->size(); ++i) {
+      if (withNulls && i % 3 == 0) {
+        flat->setNull(i, true);
+      } else {
+        flat->set(i, testValue<T>((i % numDistinct) * step, buffer));
+      }
+    }
+    return base;
+  }
+
+  template <TypeKind kind>
+  void checkTypeEncoding(const TypePtr& type) {
+    auto vector = createScalar<kind>(type, 1000, 1, 0, false);
+    auto constant = BaseVector::constantify(vector);
+    assertEqualVectors(vector, constant);
+    auto indices =
+        makeIndices(vector->size(), [](auto row) { return row / 2; });
+    auto wrappedVector = BaseVector::wrapInDictionary(
+        BufferPtr(nullptr), indices, vector->size(), vector);
+    assertEqualVectors(constant, BaseVector::constantify(wrappedVector));
+
+    auto row = makeRowVector({"c0"}, {vector});
+    auto constantRow = BaseVector::constantify(row);
+    assertEqualVectors(row, constantRow);
+
+    vector = createScalar<kind>(type, 1000, 1, 0, true);
+    // A nullable vector does not make a constant.
+    EXPECT_TRUE(BaseVector::constantify(vector) == nullptr);
+    // It has 2 values, null and the single value.
+    checkDictionarize(vector, 2);
+
+    if (kind == TypeKind::BOOLEAN || kind == TypeKind::TINYINT) {
+      return;
+    }
+
+    vector = createScalar<kind>(type, 1000, 1000, 1, false);
+
+    // A vector with different values does not make a constant.
+    EXPECT_TRUE(BaseVector::constantify(vector) == nullptr);
+    checkDictionarize(vector, 1000);
+    row = makeRowVector({"c0"}, {vector});
+    EXPECT_TRUE(BaseVector::constantify(row) == nullptr);
+
+    checkDictionarize(row, 1000);
+
+    vector = createScalar<kind>(type, 1000, 10, 1, false);
+    // The vector has values repeating in in a 10 value cycle. If each 10 values
+    // are map values with the same key, the map from the base is constant. If
+    // we take every 5 consecutive values as map values with the same keys, we
+    // have 2 distinct maps.
+    auto map = mapFromScalar(vector, 10);
+    auto constantMap = BaseVector::constantify(map);
+    assertEqualVectors(map, constantMap);
+    map = mapFromScalar(vector, 5);
+    EXPECT_TRUE(BaseVector::constantify(map) == nullptr);
+    checkDictionarize(map, 2);
+  }
+
+  void checkDictionarize(const VectorPtr& vector, int expectDistincts) {
+    auto indices =
+        AlignedBuffer::allocate<vector_size_t>(vector->size(), pool_.get());
+    VectorMap map(*vector);
+    EXPECT_EQ(expectDistincts, map.size());
+
+    VectorMap map2(vector->type(), pool_.get());
+    raw_vector<vector_size_t> temp;
+    folly::Range<const vector_size_t*> rows(
+        iota(vector->size(), temp), vector->size());
+    map2.addMultiple(*vector, rows, true, indices->asMutable<vector_size_t>());
+    EXPECT_EQ(expectDistincts, map2.size());
+    assertEqualVectors(
+        vector,
+        BaseVector::wrapInDictionary(
+            BufferPtr(nullptr), indices, vector->size(), map2.alphabetOwned()));
+    if (vector->typeKind() == TypeKind::VARCHAR ||
+        vector->typeKind() == TypeKind::VARBINARY) {
+      for (auto i = 0; i < vector->size(); ++i) {
+        auto length = vector->isNullAt(i)
+            ? 0
+            : vector->as<SimpleVector<StringView>>()->valueAt(i).size() + 4;
+        EXPECT_EQ(map2.lengthAt(indices->as<int32_t>()[i]), length);
+      }
+    }
+  }
+};
+
+template <>
+int128_t EncodingTest::testValue<int128_t>(int32_t i, BufferPtr& /*space*/) {
+  return HugeInt::build(i % 2 ? (i * -1) : i, 0xAAAAAAAAAAAAAAAA);
+}
+
+template <>
+StringView EncodingTest::testValue(int32_t n, BufferPtr& buffer) {
+  if (!buffer || buffer->capacity() < 1000) {
+    buffer = AlignedBuffer::allocate<char>(1000, pool());
+  }
+  std::stringstream out;
+  out << n;
+  for (int32_t i = 0; i < n % 20; ++i) {
+    out << " " << i * i;
+  }
+  std::string str = out.str();
+  EXPECT_LE(str.size(), buffer->capacity());
+  memcpy(buffer->asMutable<char>(), str.data(), str.size());
+  return StringView(buffer->as<char>(), str.size());
+}
+
+template <>
+bool EncodingTest::testValue(int32_t i, BufferPtr& /*space*/) {
+  return (i % 2) == 1;
+}
+
+template <>
+Timestamp EncodingTest::testValue(int32_t i, BufferPtr& /*space*/) {
+  // Return even milliseconds.
+  return Timestamp(i * 1000, (i % 1000) * 1000000);
+}
+
+TEST_F(EncodingTest, basic) {
+  checkTypeEncoding<TypeKind::BOOLEAN>(BOOLEAN());
+  checkTypeEncoding<TypeKind::TINYINT>(TINYINT());
+  checkTypeEncoding<TypeKind::SMALLINT>(SMALLINT());
+  checkTypeEncoding<TypeKind::INTEGER>(INTEGER());
+  checkTypeEncoding<TypeKind::BIGINT>(BIGINT());
+  checkTypeEncoding<TypeKind::VARCHAR>(VARCHAR());
+  checkTypeEncoding<TypeKind::TIMESTAMP>(TIMESTAMP());
+}
diff --git a/velox/vector/tests/EnsureWritableVectorTest.cpp b/velox/vector/tests/EnsureWritableVectorTest.cpp
index 670c82323cd01..26cd065b7b5ea 100644
--- a/velox/vector/tests/EnsureWritableVectorTest.cpp
+++ b/velox/vector/tests/EnsureWritableVectorTest.cpp
@@ -16,26 +16,23 @@
 #include <gtest/gtest.h>
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/tests/VectorTestUtils.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox;
+using namespace facebook::velox::test;
 
-class EnsureWritableVectorTest : public testing::Test {
+class EnsureWritableVectorTest : public testing::Test, public VectorTestBase {
  protected:
-  void SetUp() override {
-    pool_ = memory::addDefaultLeafMemoryPool();
-    vectorMaker_ = std::make_unique<test::VectorMaker>(pool_.get());
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
   }
-
-  std::shared_ptr<memory::MemoryPool> pool_;
-  std::unique_ptr<test::VectorMaker> vectorMaker_;
 };
 
 TEST_F(EnsureWritableVectorTest, flat) {
   SelectivityVector rows(1'000);
 
   VectorPtr result;
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool(), result);
   ASSERT_TRUE(result);
   ASSERT_EQ(rows.size(), result->size());
   ASSERT_EQ(TypeKind::BIGINT, result->typeKind());
@@ -54,14 +51,14 @@ TEST_F(EnsureWritableVectorTest, flat) {
   // as-is
   auto* rawNulls = flatResult->nulls().get();
   auto* rawValues = flatResult->values().get();
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool(), result);
   ASSERT_EQ(flatResult, result.get());
   ASSERT_EQ(rawNulls, flatResult->nulls().get());
   ASSERT_EQ(rawValues, flatResult->values().get());
 
   // Resize upwards singly-referenced vector with singly referenced buffers
   rows.resize(2'000);
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool(), result);
   ASSERT_EQ(rows.size(), result->size());
   ASSERT_EQ(flatResult, result.get());
   rawNulls = flatResult->nulls().get();
@@ -77,7 +74,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
 
   // Resize downwards
   rows.resize(1'024);
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool(), result);
   ASSERT_EQ(2'000, result->size());
   ASSERT_EQ(rawNulls, flatResult->nulls().get());
   ASSERT_EQ(rawValues, flatResult->values().get());
@@ -85,7 +82,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
   // Add second reference to the vector -> new vector should be allocated
   auto resultCopy = result;
 
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool(), result);
   ASSERT_NE(flatResult, result.get());
   flatResult = result->asFlatVector<int64_t>();
   ASSERT_NE(rawNulls, flatResult->nulls().get());
@@ -116,7 +113,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
   resultCopy.reset();
   auto nullsCopy = result->nulls();
 
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool(), result);
   ASSERT_EQ(flatResult, result.get());
   ASSERT_NE(rawNulls, flatResult->nulls().get());
   rawNulls = flatResult->nulls().get();
@@ -138,7 +135,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
   // Add a reference to values buffer
   auto valuesCopy = result->values();
 
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool(), result);
   ASSERT_EQ(flatResult, result.get());
   ASSERT_EQ(rawNulls, flatResult->nulls().get());
   ASSERT_NE(rawValues, flatResult->values().get());
@@ -163,7 +160,7 @@ TEST_F(EnsureWritableVectorTest, flatStrings) {
   SelectivityVector rows(1'000);
 
   VectorPtr result;
-  BaseVector::ensureWritable(rows, VARCHAR(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, VARCHAR(), pool(), result);
   ASSERT_TRUE(result);
   ASSERT_EQ(rows.size(), result->size());
   ASSERT_EQ(TypeKind::VARCHAR, result->typeKind());
@@ -177,7 +174,7 @@ TEST_F(EnsureWritableVectorTest, flatStrings) {
   // buffer.
   auto valuesCopy = result->values();
 
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool(), result);
   ASSERT_TRUE(result);
   ASSERT_EQ(rows.size(), result->size());
   ASSERT_EQ(TypeKind::VARCHAR, result->typeKind());
@@ -372,7 +369,7 @@ struct MapVectorPointers : public VectorPointersBase<MapVector> {
 TEST_F(EnsureWritableVectorTest, dictionary) {
   vector_size_t dictionarySize = 100;
   vector_size_t size = 1'000;
-  auto dictionary = BaseVector::create(BIGINT(), dictionarySize, pool_.get());
+  auto dictionary = BaseVector::create(BIGINT(), dictionarySize, pool());
   for (vector_size_t i = 0; i < dictionarySize; i++) {
     if (i % 5 == 0) {
       dictionary->setNull(i, true);
@@ -381,7 +378,7 @@ TEST_F(EnsureWritableVectorTest, dictionary) {
     }
   }
 
-  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(size, pool_.get());
+  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(size, pool());
   auto* rawIndices = indices->asMutable<vector_size_t>();
   for (vector_size_t i = 0; i < size; i++) {
     rawIndices[i] = i % dictionarySize;
@@ -391,7 +388,7 @@ TEST_F(EnsureWritableVectorTest, dictionary) {
       BufferPtr(nullptr), indices, size, dictionary);
 
   auto oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, BIGINT(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, BIGINT(), pool(), result);
   ASSERT_EQ(size, result->size());
   ASSERT_EQ(TypeKind::BIGINT, result->typeKind());
   ASSERT_EQ(VectorEncoding::Simple::FLAT, result->encoding());
@@ -413,9 +410,9 @@ TEST_F(EnsureWritableVectorTest, constant) {
   {
     const vector_size_t size = 100;
     auto constant = BaseVector::createConstant(
-        BIGINT(), variant::create<TypeKind::BIGINT>(123), size, pool_.get());
+        BIGINT(), variant::create<TypeKind::BIGINT>(123), size, pool());
     BaseVector::ensureWritable(
-        SelectivityVector::empty(), BIGINT(), pool_.get(), constant);
+        SelectivityVector::empty(), BIGINT(), pool(), constant);
     EXPECT_EQ(VectorEncoding::Simple::FLAT, constant->encoding());
     EXPECT_EQ(size, constant->size());
   }
@@ -425,11 +422,11 @@ TEST_F(EnsureWritableVectorTest, constant) {
   {
     const vector_size_t selectivityVectorSize = 100;
     auto constant = BaseVector::createConstant(
-        BIGINT(), variant::create<TypeKind::BIGINT>(123), 1, pool_.get());
+        BIGINT(), variant::create<TypeKind::BIGINT>(123), 1, pool());
     SelectivityVector rows(selectivityVectorSize);
     rows.setValid(99, false);
     rows.updateBounds();
-    BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), constant);
+    BaseVector::ensureWritable(rows, BIGINT(), pool(), constant);
     EXPECT_EQ(VectorEncoding::Simple::FLAT, constant->encoding());
     EXPECT_EQ(99, constant->size());
   }
@@ -443,11 +440,11 @@ TEST_F(EnsureWritableVectorTest, constant) {
         BIGINT(),
         variant::create<TypeKind::BIGINT>(123),
         constantVectorSize,
-        pool_.get());
+        pool());
     BaseVector::ensureWritable(
         SelectivityVector::empty(selectivityVectorSize),
         BIGINT(),
-        pool_.get(),
+        pool(),
         constant);
     EXPECT_EQ(VectorEncoding::Simple::FLAT, constant->encoding());
     EXPECT_EQ(constantVectorSize, constant->size());
@@ -456,13 +453,13 @@ TEST_F(EnsureWritableVectorTest, constant) {
 
 TEST_F(EnsureWritableVectorTest, array) {
   vector_size_t size = 1'000;
-  auto a = vectorMaker_->arrayVector<int32_t>(
+  auto a = makeArrayVector<int32_t>(
       size,
       /*sizeAt*/ [](vector_size_t row) { return row % 5; },
       /*valueAt*/ [](vector_size_t row) { return row; },
       /*isNullAt*/ test::VectorMaker::nullEvery(7));
 
-  auto b = vectorMaker_->arrayVector<int32_t>(
+  auto b = makeArrayVector<int32_t>(
       size,
       /*sizeAt*/ [](vector_size_t row) { return row % 7; },
       /*valueAt*/ [](vector_size_t row) { return row * 2; },
@@ -470,7 +467,7 @@ TEST_F(EnsureWritableVectorTest, array) {
 
   SelectivityVector rows(size);
   VectorPtr result;
-  BaseVector::ensureWritable(rows, ARRAY(INTEGER()), pool_.get(), result);
+  BaseVector::ensureWritable(rows, ARRAY(INTEGER()), pool(), result);
   ASSERT_EQ(size, result->size());
   ASSERT_TRUE(ARRAY(INTEGER())->kindEquals(result->type()));
   ASSERT_EQ(VectorEncoding::Simple::ARRAY, result->encoding());
@@ -482,7 +479,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   ASSERT_FALSE(result.unique());
 
   auto oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   ASSERT_TRUE(result.unique());
   ASSERT_NE(resultCopy.get(), result.get());
 
@@ -502,7 +499,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   }
 
   // Singly referenced array vector; multiply-referenced elements vector
-  result = BaseVector::create(result->type(), rows.size(), pool_.get());
+  result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   ArrayVectorPointers pointers;
@@ -511,7 +508,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   pointers.setElementsUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool(), result);
   pointers.assertPointers(result);
 
   // Verify that even rows were copied over
@@ -533,7 +530,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   }
 
   // Singly referenced array vector; multiply-referenced offsets buffer
-  result = BaseVector::create(result->type(), rows.size(), pool_.get());
+  result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
@@ -541,7 +538,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   pointers.setOffsetsUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
@@ -555,7 +552,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   assertEqualOffsetsOrSizes(a->offsets(), offsetsCopy, a->size(), isNullAt(a));
 
   // Singly referenced array vector; multiply-referenced sizes buffer
-  result = BaseVector::create(result->type(), rows.size(), pool_.get());
+  result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
@@ -563,7 +560,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   pointers.setSizesUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
@@ -579,14 +576,14 @@ TEST_F(EnsureWritableVectorTest, array) {
 
 TEST_F(EnsureWritableVectorTest, map) {
   vector_size_t size = 1'000;
-  auto a = vectorMaker_->mapVector<int32_t, int32_t>(
+  auto a = makeMapVector<int32_t, int32_t>(
       size,
       /*sizeAt*/ [](vector_size_t row) { return row % 5; },
       /*keyAt*/ [](vector_size_t row) { return row; },
       /*valueAt*/ [](vector_size_t row) { return row + 10; },
       /*isNullAt*/ test::VectorMaker::nullEvery(7));
 
-  auto b = vectorMaker_->mapVector<int32_t, int32_t>(
+  auto b = makeMapVector<int32_t, int32_t>(
       size,
       /*sizeAt*/ [](vector_size_t row) { return row % 7; },
       /*keyAt*/ [](vector_size_t row) { return row * 2; },
@@ -595,8 +592,7 @@ TEST_F(EnsureWritableVectorTest, map) {
 
   SelectivityVector rows(size);
   VectorPtr result;
-  BaseVector::ensureWritable(
-      rows, MAP(INTEGER(), INTEGER()), pool_.get(), result);
+  BaseVector::ensureWritable(rows, MAP(INTEGER(), INTEGER()), pool(), result);
   ASSERT_EQ(size, result->size());
   ASSERT_TRUE(MAP(INTEGER(), INTEGER())->kindEquals(result->type()));
   ASSERT_EQ(VectorEncoding::Simple::MAP, result->encoding());
@@ -608,7 +604,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   ASSERT_FALSE(result.unique());
 
   auto oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   ASSERT_TRUE(result.unique());
   ASSERT_NE(resultCopy.get(), result.get());
 
@@ -628,7 +624,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   }
 
   // Singly referenced map vector; multiply-referenced keys vector
-  result = BaseVector::create(result->type(), rows.size(), pool_.get());
+  result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   MapVectorPointers pointers;
@@ -637,7 +633,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.setKeysUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool(), result);
   pointers.assertPointers(result);
 
   // Verify that even rows were copied over
@@ -658,7 +654,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   }
 
   // Singly referenced map vector; multiply-referenced keys vector
-  result = BaseVector::create(result->type(), rows.size(), pool_.get());
+  result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
@@ -666,7 +662,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.setValuesUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool(), result);
   pointers.assertPointers(result);
 
   // Verify that even rows were copied over
@@ -688,7 +684,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   }
 
   // Singly referenced map vector; multiply-referenced offsets buffer
-  result = BaseVector::create(result->type(), rows.size(), pool_.get());
+  result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
@@ -696,7 +692,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.setOffsetsUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
@@ -710,7 +706,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   assertEqualOffsetsOrSizes(a->offsets(), offsetsCopy, a->size(), isNullAt(a));
 
   // Singly referenced map vector; multiply-referenced sizes buffer
-  result = BaseVector::create(result->type(), rows.size(), pool_.get());
+  result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
@@ -718,7 +714,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.setSizesUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
@@ -734,16 +730,16 @@ TEST_F(EnsureWritableVectorTest, map) {
 
 TEST_F(EnsureWritableVectorTest, allNullArray) {
   vector_size_t size = 1'000;
-  auto a = vectorMaker_->arrayVector<int64_t>(
+  auto a = makeArrayVector<int64_t>(
       size,
       /*sizeAt*/ [](vector_size_t row) { return row % 5; },
       /*valueAt*/ [](vector_size_t row) { return row; },
       /*isNullAt*/ test::VectorMaker::nullEvery(7));
 
-  VectorPtr result = vectorMaker_->allNullArrayVector(size, BIGINT());
+  VectorPtr result = makeAllNullArrayVector(size, BIGINT());
 
   SelectivityVector oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
 
   result->copy(a.get(), oddRows, nullptr);
 
@@ -756,10 +752,10 @@ TEST_F(EnsureWritableVectorTest, allNullArray) {
   }
 
   // Multiply-references array vector; should be copied
-  result = vectorMaker_->allNullArrayVector(size, BIGINT());
+  result = makeAllNullArrayVector(size, BIGINT());
   auto resultCopy = result;
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   ASSERT_NE(resultCopy.get(), result.get());
 
   result->copy(a.get(), oddRows, nullptr);
@@ -776,7 +772,7 @@ TEST_F(EnsureWritableVectorTest, allNullArray) {
 
 TEST_F(EnsureWritableVectorTest, allNullMap) {
   vector_size_t size = 1'000;
-  auto a = vectorMaker_->mapVector<int64_t, StringView>(
+  auto a = makeMapVector<int64_t, StringView>(
       size,
       /*sizeAt*/ [](vector_size_t row) { return row % 5; },
       /*keyAt*/ [](vector_size_t row) { return row; },
@@ -786,10 +782,10 @@ TEST_F(EnsureWritableVectorTest, allNullMap) {
       },
       /*isNullAt*/ test::VectorMaker::nullEvery(7));
 
-  VectorPtr result = vectorMaker_->allNullMapVector(size, BIGINT(), VARCHAR());
+  VectorPtr result = makeAllNullMapVector(size, BIGINT(), VARCHAR());
 
   SelectivityVector oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
 
   result->copy(a.get(), oddRows, nullptr);
 
@@ -802,10 +798,10 @@ TEST_F(EnsureWritableVectorTest, allNullMap) {
   }
 
   // Multiply-referenced vector; should be copied
-  result = vectorMaker_->allNullMapVector(size, BIGINT(), VARCHAR());
+  result = makeAllNullMapVector(size, BIGINT(), VARCHAR());
   auto resultCopy = result;
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   ASSERT_NE(resultCopy.get(), result.get());
 
   result->copy(a.get(), oddRows, nullptr);
@@ -821,27 +817,50 @@ TEST_F(EnsureWritableVectorTest, allNullMap) {
 }
 
 TEST_F(EnsureWritableVectorTest, booleanFlatVector) {
-  VectorPtr vector =
-      vectorMaker_->flatVector<bool>(100, [](auto /*row*/) { return true; });
-
-  // Make sure vector::values_ buffer is not uniquely referenced so that the
-  // branch in the FlatVector::ensureWritable() that copy old values to new
-  // buffer is executed.
-  auto another = vector->asFlatVector<bool>()->values();
-
-  SelectivityVector rows{200, false};
-  rows.setValidRange(16, 32, true);
-  rows.updateBounds();
-
-  auto vectorPtr = vector.get();
-  ASSERT_NO_THROW(
-      BaseVector::ensureWritable(rows, BOOLEAN(), pool_.get(), vector));
-  ASSERT_EQ(vectorPtr, vector.get());
-  ASSERT_NE(another->as<void>(), vector->valuesAsVoid());
+  auto testEnsureWritable = [this](VectorPtr& vector, SelectivityVector& rows) {
+    // Make sure vector::values_ buffer is not uniquely referenced so that
+    // the branch in the FlatVector::ensureWritable() that copy old values
+    // to new buffer is executed.
+    auto another = vector->asFlatVector<bool>()->values();
+
+    auto vectorPtr = vector.get();
+    ASSERT_NO_THROW(
+        BaseVector::ensureWritable(rows, BOOLEAN(), pool(), vector));
+    ASSERT_EQ(vectorPtr, vector.get());
+    ASSERT_NE(another->as<void>(), vector->valuesAsVoid());
+  };
+
+  {
+    VectorPtr vector =
+        makeFlatVector<bool>(100, [](auto /*row*/) { return true; });
+
+    SelectivityVector rows{200, false};
+    rows.setValidRange(16, 32, true);
+    rows.updateBounds();
+
+    testEnsureWritable(vector, rows);
+  }
+
+  {
+    auto value = AlignedBuffer::allocate<bool>(1000, pool(), true);
+    // Create a FlatVector with a length smaller than the value buffer.
+    VectorPtr vector = std::make_shared<FlatVector<bool>>(
+        pool(),
+        BOOLEAN(),
+        nullptr,
+        100,
+        std::move(value),
+        std::vector<BufferPtr>());
+
+    // Create rows with a length smaller than the value buffer to ensure that
+    // the newly created vector is also smaller.
+    SelectivityVector rows{100, true};
+
+    testEnsureWritable(vector, rows);
+  }
 }
 
 TEST_F(EnsureWritableVectorTest, dataDependentFlags) {
-  auto pool = pool_.get();
   auto size = 10;
 
   auto ensureWritableStatic = [](VectorPtr& vector) {
@@ -856,7 +875,7 @@ TEST_F(EnsureWritableVectorTest, dataDependentFlags) {
   {
     SCOPED_TRACE("Flat");
     auto createVector = [&]() {
-      return test::makeFlatVectorWithFlags<TypeKind::VARCHAR>(size, pool);
+      return test::makeFlatVectorWithFlags<TypeKind::VARCHAR>(size, pool());
     };
 
     test::checkVectorFlagsReset(
@@ -869,7 +888,7 @@ TEST_F(EnsureWritableVectorTest, dataDependentFlags) {
   {
     SCOPED_TRACE("Constant");
     auto createVector = [&]() {
-      return test::makeConstantVectorWithFlags<TypeKind::VARCHAR>(size, pool);
+      return test::makeConstantVectorWithFlags<TypeKind::VARCHAR>(size, pool());
     };
 
     test::checkVectorFlagsReset(
@@ -880,7 +899,8 @@ TEST_F(EnsureWritableVectorTest, dataDependentFlags) {
   {
     SCOPED_TRACE("Dictionary");
     auto createVector = [&]() {
-      return test::makeDictionaryVectorWithFlags<TypeKind::VARCHAR>(size, pool);
+      return test::makeDictionaryVectorWithFlags<TypeKind::VARCHAR>(
+          size, pool());
     };
 
     test::checkVectorFlagsReset(
@@ -892,7 +912,7 @@ TEST_F(EnsureWritableVectorTest, dataDependentFlags) {
     SCOPED_TRACE("Map");
     auto createVector = [&]() {
       return test::makeMapVectorWithFlags<TypeKind::VARCHAR, TypeKind::VARCHAR>(
-          size, pool);
+          size, pool());
     };
 
     test::checkVectorFlagsReset(
diff --git a/velox/vector/tests/IsWritableVectorTest.cpp b/velox/vector/tests/IsWritableVectorTest.cpp
index 9136a357dbfc8..1c140cc293441 100644
--- a/velox/vector/tests/IsWritableVectorTest.cpp
+++ b/velox/vector/tests/IsWritableVectorTest.cpp
@@ -17,16 +17,15 @@
 #include <gtest/gtest.h>
 #include <velox/buffer/Buffer.h>
 #include "velox/vector/ComplexVector.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::test;
 
-class IsWritableVectorTest : public testing::Test {
+class IsWritableVectorTest : public testing::Test, public VectorTestBase {
  protected:
-  void SetUp() override {
-    pool_ = memory::addDefaultLeafMemoryPool();
-    vectorMaker_ = std::make_unique<VectorMaker>(pool_.get());
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
   }
 
   // We use templates here to avoid the compiler automatically creating new
@@ -100,21 +99,17 @@ class IsWritableVectorTest : public testing::Test {
       ASSERT_FALSE(BaseVector::isVectorWritable(vector));
     }
   }
-
-  std::shared_ptr<memory::MemoryPool> pool_;
-  std::unique_ptr<VectorMaker> vectorMaker_;
 };
 
 TEST_F(IsWritableVectorTest, flatVector) {
-  auto flatVector = vectorMaker_->flatVector(std::vector<int32_t>{1, 2, 3});
+  auto flatVector = makeFlatVector<int32_t>({1, 2, 3});
 
   basicTest(flatVector);
   testBufferPtr(flatVector, flatVector->values());
 }
 
 TEST_F(IsWritableVectorTest, arrayVector) {
-  auto arrayVector =
-      vectorMaker_->arrayVector<int32_t>({{1, 2}, {3, 4}, {5, 6}});
+  auto arrayVector = makeArrayVector<int32_t>({{1, 2}, {3, 4}, {5, 6}});
 
   basicTest(arrayVector);
   testBufferPtr(arrayVector, arrayVector->offsets());
@@ -123,10 +118,10 @@ TEST_F(IsWritableVectorTest, arrayVector) {
 }
 
 TEST_F(IsWritableVectorTest, mapVector) {
-  auto mapVector = vectorMaker_->mapVector(
+  auto mapVector = makeMapVector(
       {0, 2, 4, 6},
-      vectorMaker_->flatVector<int32_t>({1, 2, 3, 4, 5, 6}),
-      vectorMaker_->flatVector<int32_t>({1, 2, 3, 4, 5, 6}));
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}));
 
   basicTest(mapVector);
   testBufferPtr(mapVector, mapVector->offsets());
@@ -136,10 +131,10 @@ TEST_F(IsWritableVectorTest, mapVector) {
 }
 
 TEST_F(IsWritableVectorTest, rowVector) {
-  auto rowVector = vectorMaker_->rowVector(
-      {vectorMaker_->flatVector<int32_t>({1, 2, 3, 4, 5, 6}),
-       vectorMaker_->flatVector<int32_t>({1, 2, 3, 4, 5, 6}),
-       vectorMaker_->flatVector<int32_t>({1, 2, 3, 4, 5, 6})});
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+       makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+       makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6})});
 
   basicTest(rowVector);
   testChildVector(rowVector, rowVector->childAt(0));
diff --git a/velox/vector/tests/LazyVectorTest.cpp b/velox/vector/tests/LazyVectorTest.cpp
index e1d0ddb2bc105..2ad3cbc8e4464 100644
--- a/velox/vector/tests/LazyVectorTest.cpp
+++ b/velox/vector/tests/LazyVectorTest.cpp
@@ -22,7 +22,12 @@
 using namespace facebook::velox;
 using namespace facebook::velox::test;
 
-class LazyVectorTest : public testing::Test, public VectorTestBase {};
+class LazyVectorTest : public testing::Test, public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 TEST_F(LazyVectorTest, lazyInDictionary) {
   // We have a dictionary over LazyVector. We load for some indices in
@@ -59,10 +64,7 @@ TEST_F(LazyVectorTest, lazyInDictionary) {
   rows.updateBounds();
   LazyVector::ensureLoadedRows(wrapped, rows);
   EXPECT_EQ(wrapped->encoding(), VectorEncoding::Simple::DICTIONARY);
-  EXPECT_EQ(wrapped->valueVector()->encoding(), VectorEncoding::Simple::LAZY);
-  EXPECT_EQ(
-      wrapped->valueVector()->loadedVector()->encoding(),
-      VectorEncoding::Simple::FLAT);
+  EXPECT_EQ(wrapped->valueVector()->encoding(), VectorEncoding::Simple::FLAT);
 
   EXPECT_EQ(loadedRows, (std::vector<vector_size_t>{0, 5}));
   assertCopyableVector(wrapped);
@@ -605,3 +607,41 @@ TEST_F(LazyVectorTest, lazyWithDictionaryInConstant) {
     EXPECT_EQ(constant->as<SimpleVector<int32_t>>()->valueAt(i), 7);
   }
 }
+
+TEST_F(LazyVectorTest, reset) {
+  static constexpr int32_t kVectorSize = 10;
+  auto loader = [&](RowSet rows) {
+    return makeFlatVector<int32_t>(
+        rows.back() + 1, [](auto row) { return row; });
+  };
+  LazyVector lazy(
+      pool_.get(),
+      INTEGER(),
+      kVectorSize,
+      std::make_unique<test::SimpleVectorLoader>(loader));
+  lazy.setNull(0, true);
+  lazy.reset(std::make_unique<test::SimpleVectorLoader>(loader), kVectorSize);
+  ASSERT_EQ(lazy.nulls(), nullptr);
+}
+
+TEST_F(LazyVectorTest, runtimeStats) {
+  TestRuntimeStatWriter writer;
+  RuntimeStatWriterScopeGuard guard(&writer);
+  auto lazy = std::make_shared<LazyVector>(
+      pool_.get(),
+      INTEGER(),
+      10,
+      std::make_unique<test::SimpleVectorLoader>([&](auto rows) {
+        return makeFlatVector<int32_t>(rows.back() + 1, folly::identity);
+      }));
+  ASSERT_EQ(lazy->loadedVector()->size(), 10);
+  auto stats = writer.stats();
+  std::sort(stats.begin(), stats.end(), [](auto& x, auto& y) {
+    return x.first < y.first;
+  });
+  ASSERT_EQ(stats.size(), 2);
+  ASSERT_EQ(stats[0].first, LazyVector::kCpuNanos);
+  ASSERT_GE(stats[0].second.value, 0);
+  ASSERT_EQ(stats[1].first, LazyVector::kWallNanos);
+  ASSERT_GE(stats[1].second.value, 0);
+}
diff --git a/velox/vector/tests/MayHaveNullsRecursiveTest.cpp b/velox/vector/tests/MayHaveNullsRecursiveTest.cpp
index f7602c737948f..23ee3dec0de71 100644
--- a/velox/vector/tests/MayHaveNullsRecursiveTest.cpp
+++ b/velox/vector/tests/MayHaveNullsRecursiveTest.cpp
@@ -22,8 +22,12 @@ namespace facebook::velox::test {
 
 class MayHaveNullsRecursiveTest : public testing::Test {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   std::shared_ptr<velox::memory::MemoryPool> pool_{
-      memory::addDefaultLeafMemoryPool()};
+      memory::memoryManager()->addLeafPool()};
   VectorMaker vectorMaker_{pool_.get()};
 
   enum class TestOptions {
diff --git a/velox/vector/tests/SelectivityVectorTest.cpp b/velox/vector/tests/SelectivityVectorTest.cpp
index ee1c8e7723856..5c1430e499c0a 100644
--- a/velox/vector/tests/SelectivityVectorTest.cpp
+++ b/velox/vector/tests/SelectivityVectorTest.cpp
@@ -18,9 +18,9 @@
 
 #include <gtest/gtest.h>
 
-namespace facebook {
-namespace velox {
-namespace test {
+#include "velox/common/base/Nulls.h"
+
+namespace facebook::velox {
 namespace {
 
 void assertState(
@@ -98,7 +98,7 @@ void setValid_normal(bool setToValue) {
   }
 }
 
-}; // namespace
+} // namespace
 
 TEST(SelectivityVectorTest, setValid_true_normal) {
   setValid_normal(true);
@@ -531,6 +531,92 @@ TEST(SelectivityVectorTest, toString) {
       "147 out of 1024 rows selected between 0 and 1023: 0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98, 105, 112, 119, 126, 133, 140, 147, 154, 161, 168, 175, 182, 189, 196, 203, 210, 217, 224, 231, 238, 245, 252, 259, 266, 273, 280, 287, 294, 301, 308, 315, 322, 329, 336, 343, 350, 357, 364, 371, 378, 385, 392, 399, 406, 413, 420, 427, 434, 441, 448, 455, 462, 469, 476, 483, 490, 497, 504, 511, 518, 525, 532, 539, 546, 553, 560, 567, 574, 581, 588, 595, 602, 609, 616, 623, 630, 637, 644, 651, 658, 665, 672, 679, 686, 693, 700, 707, 714, 721, 728, 735, 742, 749, 756, 763, 770, 777, 784, 791, 798, 805, 812, 819, 826, 833, 840, 847, 854, 861, 868, 875, 882, 889, 896, 903, 910, 917, 924, 931, 938, 945, 952, 959, 966, 973, 980, 987, 994, 1001, 1008, 1015, 1022");
 }
 
-} // namespace test
-} // namespace velox
-} // namespace facebook
+TEST(SelectivityVectorTest, copyNulls) {
+  // nnnnn.....nnnnn.....
+  std::vector<uint64_t> dest(bits::nwords(1024));
+  for (auto i = 0; i < 1024; ++i) {
+    bits::setNull(dest.data(), i, i % 10 < 5);
+  }
+
+  // ..nn..nn..nn..nn..nn
+  std::vector<uint64_t> src(bits::nwords(512));
+  for (auto i = 0; i < 512; ++i) {
+    bits::setNull(src.data(), i, i % 4 >= 2);
+  }
+
+  // Copy even rows. Skip some at the start and end.
+  {
+    SelectivityVector rows(512);
+    for (auto i = 0; i < rows.size(); ++i) {
+      rows.setValid(i, i % 2 == 0);
+    }
+    rows.setValidRange(0, 7, false);
+    rows.setValidRange(501, 512, false);
+    rows.updateBounds();
+
+    auto test = dest;
+    rows.copyNulls(test.data(), src.data());
+
+    for (auto i = 0; i < rows.size(); ++i) {
+      const auto isNull = bits::isBitNull(test.data(), i);
+      if (rows.isValid(i)) {
+        ASSERT_EQ(bits::isBitNull(src.data(), i), isNull);
+      } else {
+        ASSERT_EQ(bits::isBitNull(dest.data(), i), isNull);
+      }
+    }
+
+    for (auto i = rows.size(); i < 1024; ++i) {
+      const auto isNull = bits::isBitNull(test.data(), i);
+      ASSERT_EQ(bits::isBitNull(dest.data(), i), isNull);
+    }
+  }
+
+  // Copy odd rows.
+  {
+    SelectivityVector rows(512);
+    for (auto i = 0; i < rows.size(); ++i) {
+      rows.setValid(i, i % 2 != 0);
+    }
+    rows.setValidRange(0, 7, false);
+    rows.setValidRange(501, 512, false);
+    rows.updateBounds();
+
+    auto test = dest;
+    rows.copyNulls(test.data(), src.data());
+
+    for (auto i = 0; i < rows.size(); ++i) {
+      const auto isNull = bits::isBitNull(test.data(), i);
+      if (rows.isValid(i)) {
+        ASSERT_EQ(bits::isBitNull(src.data(), i), isNull);
+      } else {
+        ASSERT_EQ(bits::isBitNull(dest.data(), i), isNull);
+      }
+    }
+
+    for (auto i = rows.size(); i < 1024; ++i) {
+      const auto isNull = bits::isBitNull(test.data(), i);
+      ASSERT_EQ(bits::isBitNull(dest.data(), i), isNull);
+    }
+  }
+
+  // Copy all rows.
+  {
+    SelectivityVector rows(478);
+
+    auto test = dest;
+    rows.copyNulls(test.data(), src.data());
+
+    for (auto i = 0; i < rows.size(); ++i) {
+      const auto isNull = bits::isBitNull(test.data(), i);
+      EXPECT_EQ(bits::isBitNull(src.data(), i), isNull) << i;
+    }
+
+    for (auto i = rows.size(); i < 1024; ++i) {
+      const auto isNull = bits::isBitNull(test.data(), i);
+      ASSERT_EQ(bits::isBitNull(dest.data(), i), isNull);
+    }
+  }
+}
+
+} // namespace facebook::velox
diff --git a/velox/vector/tests/SimpleVectorTest.cpp b/velox/vector/tests/SimpleVectorTest.cpp
index dea4292a8118e..9f2e30af95d9b 100644
--- a/velox/vector/tests/SimpleVectorTest.cpp
+++ b/velox/vector/tests/SimpleVectorTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include <algorithm>
+#include <functional>
 
 #include <fmt/core.h>
 #include <glog/logging.h>
@@ -25,6 +26,7 @@
 #include <folly/dynamic.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/FloatingPointUtil.h"
 #include "velox/vector/BuilderTypeUtils.h"
 #include "velox/vector/SimpleVector.h"
 #include "velox/vector/tests/SimpleVectorTestHelper.h"
@@ -129,21 +131,38 @@ TEST_F(SimpleVectorNonParameterizedTest, BasicRoundTrip) {
 }
 
 TEST_F(SimpleVectorNonParameterizedTest, ThreadSafeAsciiCompute) {
+  const size_t numRows{100};
+  const size_t numThreads{10};
+
   std::vector<std::thread> tasks;
-  SelectivityVector rows(10000);
+  SelectivityVector rows(numRows);
   VectorPtr vectorBase;
   BaseVector::ensureWritable(rows, VARCHAR(), pool_.get(), vectorBase);
   auto vector = vectorBase->as<FlatVector<StringView>>();
-  for (int i = 0; i < 10000; i++) {
+  for (int i = 0; i < numRows; i++) {
     vector->set(i, "dsfdsfsdfdsfds"_sv);
   }
 
-  for (int i = 0; i < 100; i++) {
+  for (int i = 0; i < numThreads; i++) {
     tasks.emplace_back([&]() {
-      for (int j = 0; j < 100; j++) {
+      for (int j = 0; j < numRows; j++) {
         vector->invalidateIsAscii();
+        for (auto row = 0; row < vector->size(); ++row) {
+          ASSERT_FALSE(vector->isAscii(row));
+        }
+      }
+    });
+  }
+  for (auto& thread : tasks) {
+    thread.join();
+  }
+  tasks.clear();
+
+  for (int i = 0; i < numThreads; i++) {
+    tasks.emplace_back([&]() {
+      for (int j = 0; j < numRows; j++) {
         vector->computeAndSetIsAscii(rows);
-        for (int k = 0; k < vector->size(); k++) {
+        for (auto k = 0; k < vector->size(); k++) {
           ASSERT_TRUE(vector->isAscii(k));
         }
       }
@@ -388,6 +407,112 @@ TEST_F(SimpleVectorNonParameterizedTest, setAscii) {
   }
 }
 
+TEST_F(SimpleVectorNonParameterizedTest, stringsAsciiResize) {
+  std::vector<std::string> largeStrings = {
+      std::string(20, '.'),
+      std::string(30, '-'),
+      std::string(40, '='),
+  };
+  const size_t numRows{1'000};
+  SelectivityVector allRows(numRows, true);
+  auto stringAt = [&](auto row) {
+    return row % 3 == 0 ? StringView(largeStrings[(row / 3) % 3]) : ""_sv;
+  };
+
+  const AsciiInfo* asciiInfo{nullptr};
+  const AsciiInfo* constAsciiInfo{nullptr};
+
+  // Create a flat and const string vectors. Ensure ascii info is computed.
+  VectorPtr vector = maker_.flatVector<StringView>(numRows, stringAt, nullptr);
+  vector->as<SimpleVector<StringView>>()->computeAndSetIsAscii(allRows);
+  vector->validate();
+
+  VectorPtr constVector = BaseVector::createConstant(
+      VARCHAR(), largeStrings[0], numRows, pool_.get());
+  constVector->as<SimpleVector<StringView>>()->computeAndSetIsAscii(allRows);
+  constVector->validate();
+
+  asciiInfo = &vector->as<SimpleVector<StringView>>()->testGetAsciiInfo();
+  EXPECT_TRUE(asciiInfo->readLockedAsciiComputedRows()->hasSelections());
+  EXPECT_EQ(vector->size(), asciiInfo->readLockedAsciiComputedRows()->size());
+  EXPECT_TRUE(asciiInfo->isAllAscii());
+
+  constAsciiInfo =
+      &constVector->as<SimpleVector<StringView>>()->testGetAsciiInfo();
+  EXPECT_TRUE(constAsciiInfo->readLockedAsciiComputedRows()->hasSelections());
+  EXPECT_EQ(
+      vector->size(), constAsciiInfo->readLockedAsciiComputedRows()->size());
+  EXPECT_TRUE(constAsciiInfo->isAllAscii());
+
+  // Now resize the vectors and see that ascii info is correct.
+  vector->resize(numRows * 2);
+  vector->validate();
+  constVector->resize(numRows * 2);
+  constVector->validate();
+
+  asciiInfo = &vector->as<SimpleVector<StringView>>()->testGetAsciiInfo();
+  EXPECT_TRUE(asciiInfo->readLockedAsciiComputedRows()->hasSelections());
+  EXPECT_EQ(vector->size(), asciiInfo->readLockedAsciiComputedRows()->size());
+  // In a flat vector the new rows will have false asciiness.
+  EXPECT_FALSE(asciiInfo->isAllAscii());
+
+  constAsciiInfo =
+      &constVector->as<SimpleVector<StringView>>()->testGetAsciiInfo();
+  EXPECT_TRUE(constAsciiInfo->readLockedAsciiComputedRows()->hasSelections());
+  EXPECT_EQ(
+      constVector->size(),
+      constAsciiInfo->readLockedAsciiComputedRows()->size());
+  // In a constant vector the new rows will have the same asciiness.
+  EXPECT_TRUE(constAsciiInfo->isAllAscii());
+
+  // Now tests the prepareForReuse with the same size.
+  allRows.resize(numRows * 2, true);
+  vector->as<SimpleVector<StringView>>()->computeAndSetIsAscii(allRows);
+  constVector->as<SimpleVector<StringView>>()->computeAndSetIsAscii(allRows);
+
+  BaseVector::prepareForReuse(vector, vector->size());
+  vector->validate();
+  // Note that constant vector turns to non-const here, because const cannot be
+  // reused for some reason.
+  BaseVector::prepareForReuse(constVector, constVector->size());
+  vector->validate();
+
+  asciiInfo = &vector->as<SimpleVector<StringView>>()->testGetAsciiInfo();
+  EXPECT_FALSE(asciiInfo->readLockedAsciiComputedRows()->hasSelections());
+  EXPECT_EQ(numRows * 2, asciiInfo->readLockedAsciiComputedRows()->size());
+  EXPECT_FALSE(asciiInfo->isAllAscii());
+
+  constAsciiInfo =
+      &constVector->as<SimpleVector<StringView>>()->testGetAsciiInfo();
+  EXPECT_FALSE(constAsciiInfo->readLockedAsciiComputedRows()->hasSelections());
+  EXPECT_EQ(0, constAsciiInfo->readLockedAsciiComputedRows()->size());
+  EXPECT_FALSE(constAsciiInfo->isAllAscii());
+
+  // Now tests the prepareForReuse with the new size
+  constVector = BaseVector::createConstant(
+      VARCHAR(), largeStrings[0], numRows * 2, pool_.get());
+  vector->as<SimpleVector<StringView>>()->computeAndSetIsAscii(allRows);
+  constVector->as<SimpleVector<StringView>>()->computeAndSetIsAscii(allRows);
+
+  BaseVector::prepareForReuse(vector, numRows * 4);
+  vector->validate();
+  // Note that constant vector turns to non-const here, because const cannot be
+  // reused for some reason.
+  BaseVector::prepareForReuse(constVector, numRows * 4);
+  vector->validate();
+
+  asciiInfo = &vector->as<SimpleVector<StringView>>()->testGetAsciiInfo();
+  EXPECT_FALSE(asciiInfo->readLockedAsciiComputedRows()->hasSelections());
+  EXPECT_EQ(numRows * 2, asciiInfo->readLockedAsciiComputedRows()->size());
+  EXPECT_FALSE(asciiInfo->isAllAscii());
+
+  constAsciiInfo =
+      &constVector->as<SimpleVector<StringView>>()->testGetAsciiInfo();
+  EXPECT_FALSE(constAsciiInfo->readLockedAsciiComputedRows()->hasSelections());
+  EXPECT_EQ(0, constAsciiInfo->readLockedAsciiComputedRows()->size());
+  EXPECT_FALSE(constAsciiInfo->isAllAscii());
+}
+
 VELOX_TYPED_TEST_SUITE(SimpleVectorTypedTest, SimpleTypes);
 
 TYPED_TEST(SimpleVectorTypedTest, vectorAccessTest) {
@@ -526,12 +651,17 @@ VELOX_TYPED_TEST_SUITE(SimpleVectorUnaryTypedTest, SimpleTypes);
 
 TYPED_TEST(SimpleVectorUnaryTypedTest, hashAll) {
   LOG(INFO) << "hashAll: " << type_name<TypeParam>();
-  folly::hasher<TypeParam> hasher;
+  std::function<size_t(TypeParam)> hasher;
+  if constexpr (std::is_floating_point_v<TypeParam>) {
+    hasher = util::floating_point::NaNAwareHash<TypeParam>{};
+  } else {
+    hasher = folly::hasher<TypeParam>{};
+  }
   auto hashTest = [&hasher](SimpleVector<TypeParam>* vector) {
     auto hashes = vector->hashAll();
     for (size_t i = 0; i < vector->size(); ++i) {
-      auto expected = vector->isNullAt(i) ? BaseVector::kNullHash
-                                          : hasher(vector->valueAt(i));
+      uint64_t expected = vector->isNullAt(i) ? BaseVector::kNullHash
+                                              : hasher(vector->valueAt(i));
       EXPECT_EQ(hashes->valueAt(i), expected);
     }
   };
diff --git a/velox/vector/tests/SimpleVectorTestHelper.h b/velox/vector/tests/SimpleVectorTestHelper.h
index 7a31bbd0325e1..fe8e7f3df4f92 100644
--- a/velox/vector/tests/SimpleVectorTestHelper.h
+++ b/velox/vector/tests/SimpleVectorTestHelper.h
@@ -102,7 +102,12 @@ class SimpleVectorTest : public ::testing::Test {
   }
 
  protected:
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   VectorMaker maker_{pool_.get()};
 };
 
diff --git a/velox/vector/tests/TestingDictionaryArrayElementsFunction.h b/velox/vector/tests/TestingDictionaryArrayElementsFunction.h
index 211adb54ab8f1..12e5c63d99466 100644
--- a/velox/vector/tests/TestingDictionaryArrayElementsFunction.h
+++ b/velox/vector/tests/TestingDictionaryArrayElementsFunction.h
@@ -26,8 +26,14 @@ class TestingDictionaryArrayElementsFunction : public exec::VectorFunction {
  public:
   TestingDictionaryArrayElementsFunction() {}
 
-  bool isDefaultNullBehavior() const override {
-    return false;
+  static void registerFunction() {
+    exec::registerVectorFunction(
+        "testing_dictionary_array_elements",
+        test::TestingDictionaryArrayElementsFunction::signatures(),
+        std::make_unique<test::TestingDictionaryArrayElementsFunction>(),
+        exec::VectorFunctionMetadataBuilder()
+            .defaultNullBehavior(false)
+            .build());
   }
 
   void apply(
diff --git a/velox/vector/tests/TestingDictionaryFunction.h b/velox/vector/tests/TestingDictionaryFunction.h
index c13684e3f9a3e..bcba314fc2c80 100644
--- a/velox/vector/tests/TestingDictionaryFunction.h
+++ b/velox/vector/tests/TestingDictionaryFunction.h
@@ -28,10 +28,6 @@ class TestingDictionaryFunction : public exec::VectorFunction {
   TestingDictionaryFunction(vector_size_t trailingNulls = 0)
       : trailingNulls_(trailingNulls) {}
 
-  bool isDefaultNullBehavior() const override {
-    return false;
-  }
-
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
diff --git a/velox/vector/tests/VariantToVectorTest.cpp b/velox/vector/tests/VariantToVectorTest.cpp
index 07e54c0906759..554d6b2b273ea 100644
--- a/velox/vector/tests/VariantToVectorTest.cpp
+++ b/velox/vector/tests/VariantToVectorTest.cpp
@@ -25,9 +25,14 @@
 using namespace facebook::velox;
 
 class VariantToVectorTest : public testing::Test {
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
 
  public:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   template <TypeKind KIND>
   void testCreateVector(
       const TypePtr& type,
diff --git a/velox/vector/tests/VectorCompareTest.cpp b/velox/vector/tests/VectorCompareTest.cpp
index 36aa8e3987d2e..79e2afd266ec0 100644
--- a/velox/vector/tests/VectorCompareTest.cpp
+++ b/velox/vector/tests/VectorCompareTest.cpp
@@ -18,210 +18,393 @@
 #include <gtest/gtest.h>
 #include <optional>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox {
+
+static constexpr int32_t kNeq = 1;
+static constexpr int32_t kEq = 0;
+
 class VectorCompareTest : public testing::Test,
                           public velox::test::VectorTestBase {
  public:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   bool static constexpr kExpectNull = true;
   bool static constexpr kExpectNotNull = false;
   bool static constexpr kEqualsOnly = true;
 
-  void testCompareWithStopAtNull(
+  CompareFlags kEquality = CompareFlags::equality(
+      CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+  CompareFlags kOrderingAsc = {
+      .ascending = true,
+      .nullHandlingMode = CompareFlags::NullHandlingMode::kNullAsIndeterminate};
+  CompareFlags kOrderingDesc = {
+      .ascending = false,
+      .nullHandlingMode = CompareFlags::NullHandlingMode::kNullAsIndeterminate};
+  void testCompare(
       const VectorPtr& vector,
       vector_size_t index1,
       vector_size_t index2,
-      bool expectNull,
-      bool equalsOnly = false) {
-    CompareFlags testFlags;
-    testFlags.nullHandlingMode = CompareFlags::NullHandlingMode::StopAtNull;
-    testFlags.equalsOnly = equalsOnly;
-
-    ASSERT_EQ(
-        expectNull,
-        !vector->compare(vector.get(), index1, index2, testFlags).has_value());
-
-    ASSERT_TRUE(vector->compare(vector.get(), index1, index2, CompareFlags())
-                    .has_value());
+      CompareFlags testFlags,
+      std::optional<int32_t> expectedResult) {
+    testCompare(vector, index1, vector, index2, testFlags, expectedResult);
+  }
+
+  void testCompare(
+      const VectorPtr& vector1,
+      vector_size_t index1,
+      const VectorPtr& vector2,
+      vector_size_t index2,
+      CompareFlags testFlags,
+      std::optional<int32_t> expectedResult) {
+    if (testFlags.equalsOnly && expectedResult.has_value() &&
+        expectedResult.value() != kEq) {
+      // If we are checking for non-equality we just check that output is 0.
+      ASSERT_NE(
+          0,
+          vector1->compare(vector2.get(), index1, index2, testFlags).value());
+
+      // Test that NullAsIndeterminate results matche NullAsValue results when
+      // results are determined.
+      testFlags.nullHandlingMode = CompareFlags::NullHandlingMode::kNullAsValue;
+      ASSERT_NE(
+          0,
+          vector1->compare(vector2.get(), index1, index2, testFlags).value());
+    } else {
+      ASSERT_EQ(
+          expectedResult,
+          vector1->compare(vector2.get(), index1, index2, testFlags));
+
+      // Test that NullAsIndeterminate results matche NullAsValue results when
+      // results are determined.
+      if (expectedResult.has_value()) {
+        testFlags.nullHandlingMode =
+            CompareFlags::NullHandlingMode::kNullAsValue;
+
+        ASSERT_EQ(
+            expectedResult,
+            vector1->compare(vector2.get(), index1, index2, testFlags));
+      }
+    }
+  }
+
+  void testOrderingThrow(
+      const VectorPtr& vector,
+      vector_size_t index1,
+      vector_size_t index2) {
+    testOrderingThrow(vector, index1, vector, index2);
+    testOrderingThrow(vector, index2, vector, index1);
+  }
+
+  void testOrderingThrow(
+      const VectorPtr& vector1,
+      vector_size_t index1,
+      const VectorPtr& vector2,
+      vector_size_t index2) {
+    VELOX_ASSERT_THROW(
+        testCompare(
+            vector1, index1, vector2, index2, kOrderingDesc, kIndeterminate),
+        "Ordering nulls is not supported");
+    VELOX_ASSERT_THROW(
+        testCompare(
+            vector1, index1, vector2, index2, kOrderingAsc, kIndeterminate),
+        "Ordering nulls is not supported");
   }
 };
 
-TEST_F(VectorCompareTest, compareStopAtNullFlat) {
-  auto flatVector = vectorMaker_.flatVectorNullable<int32_t>({1, std::nullopt});
+TEST_F(VectorCompareTest, compareNullAsIndeterminateFlat) {
+  auto flatVector =
+      vectorMaker_.flatVectorNullable<int32_t>({1, std::nullopt, 3});
+
+  // Test equality.
+  {
+    testCompare(flatVector, 0, 0, kEquality, kEq);
+    testCompare(flatVector, 0, 2, kEquality, kNeq);
+    testCompare(flatVector, 0, 1, kEquality, kIndeterminate);
+    testCompare(flatVector, 1, 0, kEquality, kIndeterminate);
+    testCompare(flatVector, 1, 1, kEquality, kIndeterminate);
+  }
+
+  // Test ordering with nulls.
+  {
+    testOrderingThrow(flatVector, 0, 1);
+    testOrderingThrow(flatVector, 1, 0);
+    testOrderingThrow(flatVector, 1, 1);
+  }
 
-  testCompareWithStopAtNull(flatVector, 0, 0, kExpectNotNull);
-  testCompareWithStopAtNull(flatVector, 0, 1, kExpectNull);
-  testCompareWithStopAtNull(flatVector, 1, 0, kExpectNull);
-  testCompareWithStopAtNull(flatVector, 1, 1, kExpectNull);
+  // Test ordering.
+  {
+    testCompare(flatVector, 0, 0, kOrderingDesc, 0);
+    testCompare(flatVector, 0, 2, kOrderingDesc, 1);
+    testCompare(flatVector, 2, 0, kOrderingDesc, -1);
+
+    testCompare(flatVector, 0, 0, kOrderingAsc, 0);
+    testCompare(flatVector, 0, 2, kOrderingAsc, -1);
+    testCompare(flatVector, 2, 0, kOrderingAsc, 1);
+  }
 }
 
 // Test SimpleVector<ComplexType>::compare()
-TEST_F(VectorCompareTest, compareStopAtNullSimpleComplex) {
-  CompareFlags testFlags;
-  testFlags.nullHandlingMode = CompareFlags::NullHandlingMode::StopAtNull;
+TEST_F(VectorCompareTest, compareNullAsIndeterminateSimpleOfComplex) {
+  auto flatVector = vectorMaker_.arrayVectorNullable<int32_t>(
+      {{{1, 2, 3}}, std::nullopt, {{1, 2, 4}}});
 
-  auto flatVector =
-      vectorMaker_.arrayVectorNullable<int32_t>({{{1, 2, 3}}, std::nullopt});
-  // Test constant.
   auto constantVectorNull = BaseVector::wrapInConstant(2, 1, flatVector);
-  auto constantVectorNotNull = BaseVector::wrapInConstant(2, 0, flatVector);
-
-  EXPECT_FALSE(
-      constantVectorNull->compare(constantVectorNull.get(), 0, 1, testFlags)
-          .has_value());
-  EXPECT_TRUE(constantVectorNotNull
-                  ->compare(constantVectorNotNull.get(), 0, 1, testFlags)
-                  .has_value());
-  EXPECT_FALSE(
-      constantVectorNull->compare(constantVectorNotNull.get(), 0, 1, testFlags)
-          .has_value());
-  EXPECT_FALSE(
-      constantVectorNotNull->compare(constantVectorNull.get(), 0, 1, testFlags)
-          .has_value());
-  // Test dictionary.
-  auto indices = makeIndicesInReverse(2);
+  auto constantVectorOne = BaseVector::wrapInConstant(2, 0, flatVector);
+  auto constantVectorTwo = BaseVector::wrapInConstant(2, 2, flatVector);
+
+  auto indices = makeIndices({0, 1, 2});
   auto dictionary =
-      BaseVector::wrapInDictionary(nullptr, indices, 2, flatVector);
-  EXPECT_FALSE(
-      dictionary->compare(dictionary.get(), 0, 1, testFlags).has_value());
-  EXPECT_FALSE(
-      dictionary->compare(dictionary.get(), 0, 0, testFlags).has_value());
-  EXPECT_TRUE(
-      dictionary->compare(dictionary.get(), 1, 1, testFlags).has_value());
+      BaseVector::wrapInDictionary(nullptr, indices, 3, flatVector);
+
+  // Test equality with nulls.
+  {
+    CompareFlags equalityFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    // Constat vector.
+    testCompare(
+        constantVectorNull, 0, constantVectorOne, 1, kEquality, kIndeterminate);
+
+    testCompare(
+        constantVectorOne, 0, constantVectorNull, 1, kEquality, kIndeterminate);
+
+    testCompare(
+        constantVectorNull,
+        0,
+        constantVectorNull,
+        1,
+        kEquality,
+        kIndeterminate);
+
+    // Dictionary vector.
+    testCompare(dictionary, 0, 1, kEquality, kIndeterminate);
+    testCompare(dictionary, 1, 0, kEquality, kIndeterminate);
+    testCompare(dictionary, 1, 1, kEquality, kIndeterminate);
+  }
+
+  // Test ordering with nulls.
+  {
+    // Constat vector.
+    testOrderingThrow(constantVectorNull, 0, constantVectorOne, 1);
+
+    testOrderingThrow(constantVectorOne, 0, constantVectorNull, 1);
+
+    testOrderingThrow(constantVectorNull, 0, constantVectorNull, 1);
+
+    // Dictionary vector.
+    testOrderingThrow(dictionary, 0, 1);
+    testOrderingThrow(dictionary, 1, 0);
+    testOrderingThrow(dictionary, 1, 1);
+  }
+
+  // Some tests without nulls.
+  testCompare(constantVectorOne, 0, constantVectorOne, 1, kEquality, kEq);
+  testCompare(constantVectorOne, 0, constantVectorOne, 1, kOrderingDesc, 0);
+  testCompare(constantVectorOne, 0, constantVectorOne, 1, kOrderingAsc, 0);
+
+  testCompare(constantVectorOne, 0, constantVectorTwo, 1, kEquality, kNeq);
+  testCompare(constantVectorOne, 0, constantVectorTwo, 1, kOrderingDesc, 1);
+  testCompare(constantVectorOne, 0, constantVectorTwo, 1, kOrderingAsc, -1);
+
+  testCompare(dictionary, 0, 2, kOrderingAsc, -1);
+  testCompare(dictionary, 0, 2, kOrderingDesc, 1);
+  testCompare(dictionary, 2, 2, kEquality, kEq);
 }
 
-TEST_F(VectorCompareTest, compareStopAtNullArray) {
-  auto test = [&](const std::optional<std::vector<std::optional<int64_t>>>&
-                      array1,
-                  const std::optional<std::vector<std::optional<int64_t>>>&
-                      array2,
-                  bool expectNull,
-                  bool equalsOnly = false) {
-    auto vector = vectorMaker_.arrayVectorNullable<int64_t>({array1, array2});
-    testCompareWithStopAtNull(vector, 0, 1, expectNull, equalsOnly);
+TEST_F(VectorCompareTest, compareNullAsIndeterminateArray) {
+  auto test = [&](const std::string& array1,
+                  const std::string& array2,
+                  CompareFlags flags,
+                  std::optional<int32_t> expected) {
+    auto vector = vectorMaker_.arrayVectorFromJson<int64_t>({array1, array2});
+    testCompare(vector, 0, 1, flags, expected);
+  };
+
+  auto orderingThrow = [&](const std::string& array1,
+                           const std::string& array2) {
+    auto vector = vectorMaker_.arrayVectorFromJson<int64_t>({array1, array2});
+    testOrderingThrow(vector, 0, 1);
   };
 
-  test(std::nullopt, std::nullopt, kExpectNull);
-  test(std::nullopt, {{1}}, kExpectNull);
-  test({{1}}, std::nullopt, kExpectNull);
-
-  test({{1, 2, 3}}, {{1, 2, 3}}, kExpectNotNull);
-
-  // Checking the first element is enough to determine the result of the
-  // compare.
-  test({{1, std::nullopt}}, {{6, 2}}, kExpectNotNull);
-
-  test({{1, std::nullopt}}, {{1, 2}}, kExpectNull);
-
-  // When two arrays are of different sizes the checked elements are:
-  // equalsOnly=true  -> none.
-  // equalsOnly=false -> the size of the smallest.
-  test({{}}, {{std::nullopt, std::nullopt}}, kExpectNotNull);
-  test({{1, 2}}, {{1, 2, std::nullopt}}, kExpectNotNull);
-  test({{std::nullopt}}, {{std::nullopt, std::nullopt}}, kExpectNull);
-
-  // Since the two arrays are of different size and equalsOnly is enabled, no
-  // elements is read and hence no null encountered.
-  test(
-      {{std::nullopt, std::nullopt}},
-      {{std::nullopt, std::nullopt, std::nullopt}},
-      kExpectNotNull,
-      kEqualsOnly);
-
-  // Since kEqualsOnly = false, the first two elements will be read.
-  test(
-      {{std::nullopt, std::nullopt}},
-      {{std::nullopt, std::nullopt, std::nullopt}},
-      kExpectNull);
-
-  test(
-      {{std::nullopt, std::nullopt}},
-      {{std::nullopt, std::nullopt}},
-      kExpectNull,
-      kEqualsOnly);
-
-  test(
-      {{std::nullopt, std::nullopt}},
-      {{std::nullopt, std::nullopt}},
-      kExpectNull);
+  // Top level nulls.
+  orderingThrow("null", "null");
+  orderingThrow("null", "[]");
+  orderingThrow("[]", "null");
+
+  test("null", "[1, 2]", kEquality, kIndeterminate);
+  test("null", "null", kEquality, kIndeterminate);
+  test("[]", "null", kEquality, kIndeterminate);
+
+  // Testing equality.
+  {
+    // False dominates indeterminate.
+    test("[null, 1]", "[null, 2]", kEquality, kNeq);
+    test("[1, null]", "[2, null]", kEquality, kNeq);
+
+    // If the mode is equality and the arrays have different lengths, then
+    // values are not read.
+    test("[null]", "[null, null]", kEquality, kNeq);
+    test("[]", "[null, null]", kEquality, kNeq);
+    test("[1]", "[2, null, null]", kEquality, kNeq);
+
+    // Indeterminate dominates true.
+    test("[1, null]", "[1, null]", kEquality, kIndeterminate);
+    test("[1, 1, 2]", "[1, 1, null]", kEquality, kIndeterminate);
+    test("[1, 1, 2]", "[null, 1, 2]", kEquality, kIndeterminate);
+    test("[null,1 , 2]", "[1, 1, 2]", kEquality, kIndeterminate);
+
+    test("[1, 2]", "[1, 2]", kEquality, kEq);
+    test("[1, 2]", "[1, 3]", kEquality, kNeq);
+    test("[1, 2]", "[1, 2, 3]", kEquality, kNeq);
+  }
+
+  // Testing ordering.
+  {
+    orderingThrow("[null]", "[null]");
+    orderingThrow("[null]", "[1]");
+    orderingThrow("[null]", "[1, 2]");
+    orderingThrow("[1, 2, null]", "[1, 2, null]");
+
+    // Only elements between 0 and min size are read.
+    test("[1]", "[1, null, 3]", kOrderingAsc, -2);
+    test("[1]", "[1, null, 3]", kOrderingDesc, 2);
+    test("[1, null, 3]", "[1]", kOrderingAsc, 2);
+    test("[1, null, 3]", "[1]", kOrderingDesc, -2);
+
+    // If order is determined before null is seen, no throw happen and null is
+    // not read.
+    test("[1, 2, null]", "[1, 3, null]", kOrderingAsc, -1);
+    test("[1, 2, null]", "[1, 3, null]", kOrderingDesc, 1);
+    test("[1, 3, null]", "[1, 2, null]", kOrderingAsc, 1);
+    test("[1, 3, null]", "[1, 2, null]", kOrderingDesc, -1);
+  }
 }
 
-TEST_F(VectorCompareTest, compareStopAtNullMap) {
-  using map_t =
-      std::optional<std::vector<std::pair<int64_t, std::optional<int64_t>>>>;
-  auto test = [&](const map_t& map1,
-                  const map_t& map2,
-                  bool expectNull,
-                  bool equalsOnly = false) {
-    auto vector = makeNullableMapVector<int64_t, int64_t>({map1, map2});
-    testCompareWithStopAtNull(vector, 0, 1, expectNull, equalsOnly);
+TEST_F(VectorCompareTest, compareNullAsIndeterminateNullMap) {
+  auto test = [&](const std::string& map1,
+                  const std::string& map2,
+                  CompareFlags flags,
+                  std::optional<int32_t> expected) {
+    auto vector = makeMapVectorFromJson<int64_t, int64_t>({map1, map2});
+    testCompare(vector, 0, 1, flags, expected);
   };
 
-  test({{{1, 2}, {3, 4}}}, {{{1, 2}, {3, 4}}}, kExpectNotNull);
-
-  // Null map entries.
-  test(std::nullopt, {{{1, 2}, {3, 4}}}, kExpectNull);
-  test({{{1, 2}, {3, 4}}}, std::nullopt, kExpectNull);
-
-  // Null in values should be read.
-  test({{{1, std::nullopt}, {3, 4}}}, {{{1, 2}, {3, 4}}}, kExpectNull);
-  test({{{1, 2}, {3, 4}}}, {{{1, 2}, {3, std::nullopt}}}, kExpectNull);
-  test(
-      {{{1, std::nullopt}, {2, std::nullopt}}},
-      {{{1, std::nullopt}, {2, std::nullopt}}},
-      kExpectNull);
-
-  // Compare will find results before reading null.
-  // All keys are compared before values.
-  test({{{1, std::nullopt}, {3, 4}}}, {{{2, 2}, {3, 4}}}, kExpectNotNull);
-  test(
-      {{{1, std::nullopt}, {2, std::nullopt}}},
-      {{{1, std::nullopt}, {3, std::nullopt}}},
-      kExpectNotNull);
-  test(
-      {{{2, std::nullopt}, {1, std::nullopt}}},
-      {{{1, std::nullopt}, {3, std::nullopt}}},
-      kExpectNotNull);
-
-  // Different sizes.
-  test({{{1, 2}, {1, std::nullopt}}}, {{{1, std::nullopt}}}, kExpectNotNull);
-  test(
-      {{{1, 2}, {1, std::nullopt}}},
-      {{{1, std::nullopt}}},
-      kExpectNotNull,
-      kEqualsOnly);
+  // Map is NOT orderable in NullAsIndeterminate mode.
+  VELOX_ASSERT_THROW(
+      test("{}", "{}", kOrderingAsc, kIndeterminate),
+      "Map is not orderable type");
+  VELOX_ASSERT_THROW(
+      test("{}", "{}", kOrderingDesc, kIndeterminate),
+      "Map is not orderable type");
+
+  // Map is orderable in NullAsValue mode.
+  test("{}", "{}", CompareFlags{.ascending = true}, 0);
+  test("{}", "{}", CompareFlags{.ascending = false}, 0);
+
+  // Only need to check equality.
+
+  // Top level nulls.
+  test("null", "{}", kEquality, kIndeterminate);
+
+  // If keys are different, values are not looked at. Note that keys cant be
+  // null or contain nested nulls in presto.
+  test("{1: null, 2: null}", "{1: null, 3: null}", kEquality, kNeq);
+  test("{1: null, 2: null}", "{1: null}", kEquality, kNeq);
+
+  // If keys are equal, values are compared as arrays.
+  // == [null, null] = [null, null]
+  test("{1: null, 2: null}", "{1: null, 2: null}", kEquality, kIndeterminate);
+
+  // == [1, null] = [2, null]
+  test("{1: 1, 2: null}", "{1: 2, 2: null}", kEquality, kNeq);
+  test("{1: 2, 2: null}", "{1: 1, 2: null}", kEquality, kNeq);
+
+  // == [null, 1] = [null, 2]
+  test("{1: null, 2: 1}", "{1: null, 2: 2}", kEquality, kNeq);
+  test("{1: null, 2: 2}", "{1: null, 2: 1}", kEquality, kNeq);
 }
 
-TEST_F(VectorCompareTest, compareStopAtNullRow) {
+TEST_F(VectorCompareTest, compareNullAsIndeterminateRow) {
   auto test =
       [&](const std::tuple<std::optional<int64_t>, std::optional<int64_t>>&
               row1,
           const std::tuple<std::optional<int64_t>, std::optional<int64_t>>&
               row2,
-          bool expectNull,
-          bool equalsOnly = false) {
+          CompareFlags testFlags,
+          const std::optional<int32_t> expected) {
         auto vector = vectorMaker_.rowVector(
             {vectorMaker_.flatVectorNullable<int64_t>(
                  {std::get<0>(row1), std::get<0>(row2)}),
              vectorMaker_.flatVectorNullable<int64_t>(
                  {std::get<1>(row1), std::get<1>(row2)})});
+        testCompare(vector, 0, 1, testFlags, expected);
+      };
 
-        testCompareWithStopAtNull(vector, 0, 1, expectNull, equalsOnly);
+  auto orderingThrow =
+      [&](const std::tuple<std::optional<int64_t>, std::optional<int64_t>>&
+              row1,
+          const std::tuple<std::optional<int64_t>, std::optional<int64_t>>&
+              row2) {
+        auto vector = vectorMaker_.rowVector(
+            {vectorMaker_.flatVectorNullable<int64_t>(
+                 {std::get<0>(row1), std::get<0>(row2)}),
+             vectorMaker_.flatVectorNullable<int64_t>(
+                 {std::get<1>(row1), std::get<1>(row2)})});
+        testOrderingThrow(vector, 0, 1);
       };
 
-  test({1, 2}, {2, 3}, kExpectNotNull);
-  test({1, 2}, {1, 2}, kExpectNotNull);
-  test({2, std::nullopt}, {1, 2}, kExpectNotNull);
+  // Top level nulls.
+  {
+    auto vector = vectorMaker_.rowVector(
+        {vectorMaker_.flatVector<int64_t>(0),
+         vectorMaker_.flatVector<int64_t>(0)});
+    ASSERT_EQ(vector->size(), 0);
+    vector->appendNulls(2);
+    testCompare(vector, 0, 1, kEquality, kIndeterminate);
+    testOrderingThrow(vector, 0, 1);
+  }
+
+  const auto kNull = std::nullopt;
+
+  // Testing equality.
+  {
+    // False dominates indeterminate.
+    test({kNull, 1}, {kNull, 2}, kEquality, kNeq);
+    test({kNull, 2}, {kNull, 1}, kEquality, kNeq);
+
+    // Indeterminate dominates true.
+    test({1, kNull}, {1, kNull}, kEquality, kIndeterminate);
+    test({kNull, 1}, {kNull, 1}, kEquality, kIndeterminate);
 
-  test({1, 2}, {1, std::nullopt}, kExpectNull);
-  test({1, std::nullopt}, {1, 2}, kExpectNull);
-  test({1, 2}, {std::nullopt, 2}, kExpectNull);
+    test({1, 2}, {1, 2}, kEquality, kEq);
+    test({1, 2}, {1, 3}, kEquality, kNeq);
+  }
+
+  // Testing ordering.
+  {
+    orderingThrow({kNull, kNull}, {kNull, kNull});
+    orderingThrow({1, kNull}, {1, kNull});
+    orderingThrow({1, kNull}, {kNull, kNull});
+    orderingThrow({kNull, kNull}, {1, kNull});
+
+    // If order is determined before null is seen, no throw happens and null is
+    // not read.
+    test({1, kNull}, {2, kNull}, kOrderingAsc, -1);
+    test({1, kNull}, {2, kNull}, kOrderingDesc, 1);
+    test({2, kNull}, {1, kNull}, kOrderingDesc, -1);
+    test({2, kNull}, {1, kNull}, kOrderingAsc, 1);
+  }
 }
 
 TEST_F(VectorCompareTest, CompareWithNullChildVector) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   test::VectorMaker maker{pool.get()};
   auto rowType = ROW({"a", "b", "c"}, {INTEGER(), INTEGER(), INTEGER()});
   const auto& rowVector1 = std::make_shared<RowVector>(
diff --git a/velox/vector/tests/VectorEstimateFlatSizeTest.cpp b/velox/vector/tests/VectorEstimateFlatSizeTest.cpp
index cc12d0ee9954f..4fa79ea5870d8 100644
--- a/velox/vector/tests/VectorEstimateFlatSizeTest.cpp
+++ b/velox/vector/tests/VectorEstimateFlatSizeTest.cpp
@@ -23,6 +23,10 @@ class VectorEstimateFlatSizeTest : public testing::Test,
  protected:
   using test::VectorTestBase::makeArrayVector;
 
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   ArrayVectorPtr makeArrayVector(
       const TypePtr& type,
       vector_size_t size,
diff --git a/velox/vector/tests/VectorMakerTest.cpp b/velox/vector/tests/VectorMakerTest.cpp
index 3fcf260305f0a..c2887fb4044ed 100644
--- a/velox/vector/tests/VectorMakerTest.cpp
+++ b/velox/vector/tests/VectorMakerTest.cpp
@@ -19,13 +19,19 @@
 #include "velox/common/base/VeloxException.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox;
 using facebook::velox::test::VectorMaker;
 
 class VectorMakerTest : public ::testing::Test {
  protected:
-  std::shared_ptr<memory::MemoryPool> pool_{memory::addDefaultLeafMemoryPool()};
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
   VectorMaker maker_{pool_.get()};
 };
 
@@ -458,6 +464,62 @@ TEST_F(VectorMakerTest, arrayVectorFromJson) {
   }
 }
 
+TEST_F(VectorMakerTest, nestedArrayVectorFromJson) {
+  auto arrayVector = maker_.nestedArrayVectorFromJson<int32_t>(
+      {"[[1, 2], [2, 3, 4], [null, 7]]",
+       "[[1, 3, 7, 9], []]",
+       "[]",
+       "[null]",
+       "[[1, 2, null], [], null]",
+       "null",
+       "[[1,2,3],[],[4,5]]"});
+
+  VectorPtr expectedVector = maker_.arrayVectorNullable<int32_t>({
+      {{1, 2}},
+      {{2, 3, 4}},
+      {{std::nullopt, 7}},
+      {{1, 3, 7, 9}},
+      {{}},
+      {{std::nullopt}},
+      {{1, 2, std::nullopt}},
+      {{}},
+      std::nullopt,
+      {{1, 2, 3}},
+      {{}},
+      {{4, 5}},
+  });
+
+  VectorPtr elementsOfArrayVector = arrayVector->elements();
+
+  EXPECT_EQ(*arrayVector->elements()->type(), *ARRAY(INTEGER()));
+  EXPECT_TRUE(arrayVector->elements()->mayHaveNulls());
+
+  auto rowOfArrays = arrayVector->elements();
+
+  // 7 rows in array of arrays
+  EXPECT_EQ(7, arrayVector->size());
+
+  EXPECT_EQ(3, arrayVector->sizeAt(0));
+  EXPECT_EQ(2, arrayVector->sizeAt(1));
+
+  // Empty inner array
+  EXPECT_EQ(0, arrayVector->sizeAt(2));
+  EXPECT_FALSE(arrayVector->isNullAt(2));
+
+  // inner array with null
+  EXPECT_EQ(1, arrayVector->sizeAt(3));
+  EXPECT_FALSE(arrayVector->isNullAt(3));
+
+  EXPECT_EQ(3, arrayVector->sizeAt(4));
+
+  EXPECT_EQ(0, arrayVector->sizeAt(5));
+  EXPECT_TRUE(arrayVector->isNullAt(5));
+
+  EXPECT_EQ(3, arrayVector->sizeAt(6));
+
+  test::assertEqualVectors(expectedVector, elementsOfArrayVector);
+}
+
 TEST_F(VectorMakerTest, arrayOfRowVector) {
   std::vector<std::vector<variant>> data = {
       {
diff --git a/velox/vector/tests/VectorPoolTest.cpp b/velox/vector/tests/VectorPoolTest.cpp
index a000dbdbcc9c6..80a70886e82b9 100644
--- a/velox/vector/tests/VectorPoolTest.cpp
+++ b/velox/vector/tests/VectorPoolTest.cpp
@@ -20,7 +20,12 @@
 
 namespace facebook::velox::test {
 
-class VectorPoolTest : public testing::Test, public test::VectorTestBase {};
+class VectorPoolTest : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 TEST_F(VectorPoolTest, basic) {
   VectorPool vectorPool(pool());
diff --git a/velox/vector/tests/VectorPrepareForReuseTest.cpp b/velox/vector/tests/VectorPrepareForReuseTest.cpp
index 6977a03d00f25..a1ab89a310700 100644
--- a/velox/vector/tests/VectorPrepareForReuseTest.cpp
+++ b/velox/vector/tests/VectorPrepareForReuseTest.cpp
@@ -22,6 +22,10 @@ using namespace facebook::velox;
 class VectorPrepareForReuseTest : public testing::Test,
                                   public test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   VectorPrepareForReuseTest() = default;
 };
 
@@ -224,6 +228,40 @@ TEST_F(VectorPrepareForReuseTest, arrays) {
   ASSERT_EQ(originalSize, vector->retainedSize());
 }
 
+TEST_F(VectorPrepareForReuseTest, arrayOfStrings) {
+  VectorPtr vector = makeArrayVector<std::string>(
+      1'000,
+      [](auto /*row*/) { return 1; },
+      [](auto row, auto index) {
+        return std::string(20 + index, 'a' + row % 5);
+      });
+  auto originalSize = vector->retainedSize();
+  BaseVector* originalVector = vector.get();
+
+  MemoryAllocationChecker allocationChecker(pool());
+  BaseVector::prepareForReuse(vector, vector->size());
+  ASSERT_EQ(originalVector, vector.get());
+  ASSERT_EQ(originalSize, vector->retainedSize());
+
+  auto* arrayVector = vector->as<ArrayVector>();
+  for (auto i = 0; i < 1'000; i++) {
+    ASSERT_EQ(0, arrayVector->sizeAt(i));
+    ASSERT_EQ(0, arrayVector->offsetAt(i));
+  }
+
+  // Cannot use BaseVector::copy because it is too smart and acquired string
+  // buffers instead of copying the strings.
+  auto* elementsVector = arrayVector->elements()->as<FlatVector<StringView>>();
+  elementsVector->resize(1'000);
+  for (auto i = 0; i < 1'000; i++) {
+    arrayVector->setOffsetAndSize(i, i, 1);
+    std::string newValue(21, 'b' + i % 7);
+    elementsVector->set(i, StringView(newValue));
+  }
+
+  ASSERT_EQ(originalSize, vector->retainedSize());
+}
+
 TEST_F(VectorPrepareForReuseTest, dataDependentFlags) {
   auto size = 10;
 
diff --git a/velox/vector/tests/VectorPrinterTest.cpp b/velox/vector/tests/VectorPrinterTest.cpp
index 7d0b3a01adaa3..bbc5436f15ec3 100644
--- a/velox/vector/tests/VectorPrinterTest.cpp
+++ b/velox/vector/tests/VectorPrinterTest.cpp
@@ -19,7 +19,12 @@
 
 namespace facebook::velox::test {
 
-class VectorPrinterTest : public testing::Test, public VectorTestBase {};
+class VectorPrinterTest : public testing::Test, public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 // Sanity check that printVector doesn't fail or crash.
 TEST_F(VectorPrinterTest, basic) {
diff --git a/velox/vector/tests/VectorSaverTest.cpp b/velox/vector/tests/VectorSaverTest.cpp
index f494ca51d1c4c..144f33f55f3a1 100644
--- a/velox/vector/tests/VectorSaverTest.cpp
+++ b/velox/vector/tests/VectorSaverTest.cpp
@@ -29,6 +29,10 @@ namespace facebook::velox::test {
 
 class VectorSaverTest : public testing::Test, public VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   VectorSaverTest() {
     registerJsonType();
     registerHyperLogLogType();
@@ -50,6 +54,12 @@ class VectorSaverTest : public testing::Test, public VectorTestBase {
     // are the same.
     switch (expected->encoding()) {
       case VectorEncoding::Simple::CONSTANT:
+        if (expected->isNullAt(0)) {
+          // No need to compare value vector as deserialized RowVector can have
+          // different values in its flat children of size 1.
+          break;
+        }
+        [[fallthrough]];
       case VectorEncoding::Simple::DICTIONARY:
         if (expected->valueVector()) {
           ASSERT_TRUE(actual->valueVector() != nullptr);
@@ -110,11 +120,11 @@ class VectorSaverTest : public testing::Test, public VectorTestBase {
   VectorPtr takeRoundTrip(const VectorPtr& vector) {
     auto path = exec::test::TempFilePath::create();
 
-    std::ofstream outputFile(path->path, std::ofstream::binary);
+    std::ofstream outputFile(path->getPath(), std::ofstream::binary);
     saveVector(*vector, outputFile);
     outputFile.close();
 
-    std::ifstream inputFile(path->path, std::ifstream::binary);
+    std::ifstream inputFile(path->getPath(), std::ifstream::binary);
     auto copy = restoreVector(inputFile, pool());
     inputFile.close();
     return copy;
@@ -129,11 +139,11 @@ class VectorSaverTest : public testing::Test, public VectorTestBase {
   void testTypeRoundTrip(const TypePtr& type) {
     auto path = exec::test::TempFilePath::create();
 
-    std::ofstream outputFile(path->path, std::ofstream::binary);
+    std::ofstream outputFile(path->getPath(), std::ofstream::binary);
     saveType(type, outputFile);
     outputFile.close();
 
-    std::ifstream inputFile(path->path, std::ifstream::binary);
+    std::ifstream inputFile(path->getPath(), std::ifstream::binary);
     auto copy = restoreType(inputFile);
     inputFile.close();
 
@@ -166,8 +176,8 @@ class VectorSaverTest : public testing::Test, public VectorTestBase {
     testRoundTrip(makeFlatVector<T>(10'000, [](auto row) { return row; }));
 
     // Long vector with nulls.
-    testRoundTrip(makeFlatVector<T>(
-        10'000, [](auto row) { return row; }, nullEvery(17)));
+    testRoundTrip(
+        makeFlatVector<T>(10'000, [](auto row) { return row; }, nullEvery(17)));
   }
 
   // Verifies that the lazy vectors have the right internal state and loaded
@@ -615,8 +625,8 @@ TEST_F(VectorSaverTest, LazyVector) {
 TEST_F(VectorSaverTest, stdVector) {
   std::vector<column_index_t> intVector = {1, 2, 3, 4, 5};
   auto path = exec::test::TempFilePath::create();
-  saveStdVectorToFile<column_index_t>(intVector, path->path.c_str());
-  auto copy = restoreStdVectorFromFile<column_index_t>(path->path.c_str());
+  saveStdVectorToFile<column_index_t>(intVector, path->getPath().c_str());
+  auto copy = restoreStdVectorFromFile<column_index_t>(path->getPath().c_str());
   ASSERT_EQ(intVector, copy);
 }
 
@@ -651,7 +661,8 @@ TEST_F(VectorSaverTest, exceptionContext) {
   };
 
   VectorPtr data = makeFlatVector<int64_t>({1, 2, 3, 4, 5});
-  VectorSaverInfo info{tempDirectory.get()->path.c_str(), data.get()};
+  const auto path = tempDirectory->getPath();
+  VectorSaverInfo info{path.c_str(), data.get()};
   {
     ExceptionContextSetter context({messageFunction, &info});
     try {
diff --git a/velox/vector/tests/VectorStreamTest.cpp b/velox/vector/tests/VectorStreamTest.cpp
index 5fde74f8db6cb..806bb28eda1ab 100644
--- a/velox/vector/tests/VectorStreamTest.cpp
+++ b/velox/vector/tests/VectorStreamTest.cpp
@@ -21,11 +21,11 @@ namespace facebook::velox::test {
 
 class MockVectorSerde : public VectorSerde {
   void estimateSerializedSize(
-      VectorPtr vector,
+      const BaseVector* /*vector*/,
       const folly::Range<const IndexRange*>& ranges,
       vector_size_t** sizes) override {}
 
-  std::unique_ptr<VectorSerializer> createSerializer(
+  std::unique_ptr<IterativeVectorSerializer> createIterativeSerializer(
       RowTypePtr type,
       int32_t numRows,
       StreamArena* streamArena,
@@ -34,7 +34,7 @@ class MockVectorSerde : public VectorSerde {
   };
 
   void deserialize(
-      ByteStream* source,
+      ByteInputStream* source,
       velox::memory::MemoryPool* pool,
       RowTypePtr type,
       RowVectorPtr* result,
diff --git a/velox/vector/tests/VectorTest.cpp b/velox/vector/tests/VectorTest.cpp
index 9180897874cc1..3a5525412b025 100644
--- a/velox/vector/tests/VectorTest.cpp
+++ b/velox/vector/tests/VectorTest.cpp
@@ -16,7 +16,9 @@
 
 #include <glog/logging.h>
 #include <gtest/gtest.h>
+#include <cstdint>
 #include <functional>
+#include <limits>
 #include <optional>
 
 #include "velox/common/base/tests/GTestUtils.h"
@@ -25,8 +27,10 @@
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DecodedVector.h"
+#include "velox/vector/DictionaryVector.h"
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/LazyVector.h"
+#include "velox/vector/SelectivityVector.h"
 #include "velox/vector/SimpleVector.h"
 #include "velox/vector/TypeAliases.h"
 #include "velox/vector/VectorTypeUtils.h"
@@ -74,7 +78,11 @@ class TestingLoader : public VectorLoader {
         }
       } else {
         T value = values->valueAt(row);
-        hook->addValue(i, &value);
+        if constexpr (std::is_same_v<T, Timestamp>) {
+          VELOX_FAIL();
+        } else {
+          hook->addValueTyped(i, value);
+        }
       }
     }
   }
@@ -101,6 +109,10 @@ int NonPOD::alive = 0;
 
 class VectorTest : public testing::Test, public test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
   void SetUp() override {
     if (!isRegisteredVectorSerde()) {
       facebook::velox::serializer::presto::PrestoVectorSerde::
@@ -117,7 +129,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
   VectorPtr createScalar(TypePtr type, vector_size_t size, bool withNulls) {
     using T = typename TypeTraits<KIND>::NativeType;
     BufferPtr buffer;
-    VectorPtr base = BaseVector::create(type, size, pool_.get());
+    VectorPtr base = BaseVector::create(type, size, pool());
     auto flat = std::dynamic_pointer_cast<FlatVector<T>>(base);
     for (int32_t i = 0; i < flat->size(); ++i) {
       if (withNulls && i % 3 == 0) {
@@ -134,7 +146,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
         ROW({"child_bigint", "child_string"}, {BIGINT(), VARCHAR()});
     auto parentType =
         ROW({"parent_bigint", "parent_row"}, {BIGINT(), childType});
-    auto baseRow = BaseVector::create(parentType, numRows, pool_.get());
+    auto baseRow = BaseVector::create(parentType, numRows, pool());
     auto row = baseRow->as<RowVector>();
     EXPECT_EQ(row->size(), numRows);
     EXPECT_EQ(row->nulls(), nullptr);
@@ -143,7 +155,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
         createScalar<TypeKind::BIGINT>(BIGINT(), numRows, withNulls),
         createScalar<TypeKind::VARCHAR>(VARCHAR(), numRows, withNulls)};
     auto childRow = std::make_shared<RowVector>(
-        pool_.get(),
+        pool(),
         childType,
         BufferPtr(nullptr),
         numRows,
@@ -151,7 +163,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
         0 /*nullCount*/);
     BufferPtr nulls;
     if (withNulls) {
-      nulls = AlignedBuffer::allocate<bool>(numRows, pool_.get());
+      nulls = allocateNulls(numRows, pool());
       int32_t childCounter = 0;
       auto rawNulls = nulls->asMutable<uint64_t>();
       for (int32_t i = 0; i < numRows; ++i) {
@@ -161,7 +173,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     std::vector<VectorPtr> parentFields = {
         createScalar<TypeKind::BIGINT>(BIGINT(), numRows, withNulls), childRow};
     return std::make_shared<RowVector>(
-        pool_.get(),
+        pool(),
         parentType,
         nulls,
         numRows,
@@ -176,16 +188,15 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
       BufferPtr* offsets,
       BufferPtr* sizes,
       int forceWidth) {
-    *offsets = AlignedBuffer::allocate<vector_size_t>(numRows, pool_.get());
+    *offsets = AlignedBuffer::allocate<vector_size_t>(numRows, pool());
     auto* rawOffsets = (*offsets)->asMutable<vector_size_t>();
 
-    *sizes = AlignedBuffer::allocate<vector_size_t>(numRows, pool_.get());
+    *sizes = AlignedBuffer::allocate<vector_size_t>(numRows, pool());
     auto* rawSizes = (*sizes)->asMutable<vector_size_t>();
 
     uint64_t* rawNulls = nullptr;
     if (withNulls) {
-      *nulls =
-          AlignedBuffer::allocate<bool>(numRows, pool_.get(), bits::kNotNull);
+      *nulls = allocateNulls(numRows, pool());
       rawNulls = (*nulls)->asMutable<uint64_t>();
     }
     int32_t offset = 0;
@@ -216,7 +227,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
         createRepeated(numRows, withNulls, &nulls, &offsets, &sizes, 0);
     VectorPtr elements = createRow(numElements, withNulls);
     return std::make_shared<ArrayVector>(
-        pool_.get(),
+        pool(),
         ARRAY(elements->type()),
         nulls,
         numRows,
@@ -237,7 +248,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
   template <TypeKind KIND>
   void testFlat(TypePtr type, vector_size_t size, bool withNulls) {
     using T = typename TypeTraits<KIND>::NativeType;
-    VectorPtr base = BaseVector::create(type, size, pool_.get());
+    VectorPtr base = BaseVector::create(type, size, pool());
     auto flat = std::dynamic_pointer_cast<FlatVector<T>>(base);
     ASSERT_NE(flat.get(), nullptr);
     EXPECT_EQ(flat->size(), size);
@@ -373,7 +384,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     auto kind = source->typeKind();
     auto isSmall = kind == TypeKind::BOOLEAN || kind == TypeKind::TINYINT;
     auto sourceSize = source->size();
-    auto target = BaseVector::create(source->type(), sourceSize, pool_.get());
+    auto target = BaseVector::create(source->type(), sourceSize, pool());
     // Writes target out of sequence by copying the first half of
     // source to odd positions and the second half to even positions.
     auto even = selectEven(sourceSize);
@@ -395,7 +406,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     SelectivityVector allRows(sourceSize);
     DecodedVector decoded(*source, allRows);
     auto base = decoded.base();
-    auto nulls = decoded.nulls();
+    auto nulls = decoded.nulls(&allRows);
     auto indices = decoded.indices();
     for (int32_t i = 0; i < sourceSize; ++i) {
       if (i % 2 == 0) {
@@ -489,12 +500,11 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     BufferPtr dictionaryNulls;
     uint64_t* rawNulls = nullptr;
     if (source->mayHaveNulls()) {
-      dictionaryNulls = AlignedBuffer::allocate<bool>(
-          sourceSize, pool_.get(), bits::kNotNull);
+      dictionaryNulls = allocateNulls(sourceSize, pool());
       rawNulls = dictionaryNulls->asMutable<uint64_t>();
     }
     BufferPtr indices =
-        AlignedBuffer::allocate<vector_size_t>(sourceSize, pool_.get());
+        AlignedBuffer::allocate<vector_size_t>(sourceSize, pool());
     for (int32_t i = 0; i < sourceSize; ++i) {
       indices->asMutable<vector_size_t>()[i] = sourceSize - i - 1;
       if (rawNulls && (i + level) % 11 == 0) {
@@ -704,8 +714,7 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
       BufferPtr nulls;
       uint64_t* rawNulls = nullptr;
       if (slice->mayHaveNulls()) {
-        nulls = AlignedBuffer::allocate<bool>(
-            slice->size(), slice->pool(), bits::kNotNull);
+        nulls = allocateNulls(slice->size(), slice->pool());
         rawNulls = nulls->asMutable<uint64_t>();
       }
       BufferPtr indices =
@@ -749,10 +758,10 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     }
   }
 
-  void prepareInput(ByteStream* input, std::string& string) {
+  std::unique_ptr<ByteInputStream> prepareInput(std::string& string) {
     // Put 'string' in 'input' in many pieces.
+    const int32_t size = string.size();
     std::vector<ByteRange> ranges;
-    int32_t size = string.size();
     for (int32_t i = 0; i < 10; ++i) {
       int32_t start = i * (size / 10);
       int32_t end = (i == 9) ? size : (i + 1) * (size / 10);
@@ -761,7 +770,8 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
       ranges.back().size = end - start;
       ranges.back().position = 0;
     }
-    input->resetInput(std::move(ranges));
+
+    return std::make_unique<BufferInputStream>(std::move(ranges));
   }
 
   void checkSizes(
@@ -808,10 +818,10 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     auto sourceRow = makeRowVector({"c"}, {source});
     auto sourceRowType = asRowType(sourceRow->type());
 
-    VectorStreamGroup even(pool_.get());
+    VectorStreamGroup even(pool());
     even.createStreamTree(sourceRowType, source->size() / 4);
 
-    VectorStreamGroup odd(pool_.get());
+    VectorStreamGroup odd(pool());
     odd.createStreamTree(sourceRowType, source->size() / 3);
 
     std::vector<IndexRange> evenIndices;
@@ -837,9 +847,9 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     }
 
     VectorStreamGroup::estimateSerializedSize(
-        source, evenIndices, evenSizePointers.data());
+        source.get(), evenIndices, evenSizePointers.data());
     VectorStreamGroup::estimateSerializedSize(
-        source, oddIndices, oddSizePointers.data());
+        source.get(), oddIndices, oddSizePointers.data());
     even.append(
         sourceRow, folly::Range(evenIndices.data(), evenIndices.size() / 2));
     even.append(
@@ -865,11 +875,10 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     auto evenString = evenStream.str();
     checkSizes(source.get(), evenSizes, evenString);
 
-    ByteStream input;
-    prepareInput(&input, evenString);
+    auto evenInput = prepareInput(evenString);
 
     RowVectorPtr resultRow;
-    VectorStreamGroup::read(&input, pool_.get(), sourceRowType, &resultRow);
+    VectorStreamGroup::read(evenInput.get(), pool(), sourceRowType, &resultRow);
     VectorPtr result = resultRow->childAt(0);
     switch (source->encoding()) {
       case VectorEncoding::Simple::FLAT:
@@ -896,9 +905,9 @@ class VectorTest : public testing::Test, public test::VectorTestBase {
     }
 
     auto oddString = oddStream.str();
-    prepareInput(&input, oddString);
+    auto oddInput = prepareInput(oddString);
 
-    VectorStreamGroup::read(&input, pool_.get(), sourceRowType, &resultRow);
+    VectorStreamGroup::read(oddInput.get(), pool(), sourceRowType, &resultRow);
     result = resultRow->childAt(0);
     for (int32_t i = 0; i < oddIndices.size(); ++i) {
       EXPECT_TRUE(result->equalValueAt(source.get(), i, oddIndices[i].begin))
@@ -930,7 +939,7 @@ int128_t VectorTest::testValue<int128_t>(int32_t i, BufferPtr& /*space*/) {
 template <>
 StringView VectorTest::testValue(int32_t n, BufferPtr& buffer) {
   if (!buffer || buffer->capacity() < 1000) {
-    buffer = AlignedBuffer::allocate<char>(1000, pool_.get());
+    buffer = AlignedBuffer::allocate<char>(1000, pool());
   }
   std::stringstream out;
   out << n;
@@ -966,7 +975,7 @@ VectorPtr VectorTest::createMap(int32_t numRows, bool withNulls) {
   int32_t numElements =
       createRepeated(numRows, withNulls, &nulls, &offsets, &sizes, 0);
   VectorPtr elements = createRow(numElements, withNulls);
-  auto keysBase = BaseVector::create(VARCHAR(), 7, pool_.get());
+  auto keysBase = BaseVector::create(VARCHAR(), 7, pool());
   auto flatKeys = keysBase->as<FlatVector<StringView>>();
   for (int32_t i = 0; i < keysBase->size(); ++i) {
     BufferPtr buffer;
@@ -974,7 +983,7 @@ VectorPtr VectorTest::createMap(int32_t numRows, bool withNulls) {
   }
 
   auto indices =
-      AlignedBuffer::allocate<vector_size_t>(elements->size(), pool_.get());
+      AlignedBuffer::allocate<vector_size_t>(elements->size(), pool());
 
   auto rawSizes = sizes->as<vector_size_t>();
   int32_t offset = 0;
@@ -991,7 +1000,7 @@ VectorPtr VectorTest::createMap(int32_t numRows, bool withNulls) {
       elements->size(),
       std::move(keysBase));
   return std::make_shared<MapVector>(
-      pool_.get(),
+      pool(),
       MAP(VARCHAR(), elements->type()),
       nulls,
       numRows,
@@ -1038,7 +1047,7 @@ TEST_F(VectorTest, createOpaque) {
 }
 
 TEST_F(VectorTest, getOrCreateEmpty) {
-  auto empty = BaseVector::getOrCreateEmpty(nullptr, VARCHAR(), pool_.get());
+  auto empty = BaseVector::getOrCreateEmpty(nullptr, VARCHAR(), pool());
   EXPECT_NE(empty, nullptr);
   EXPECT_EQ(empty->size(), 0);
   EXPECT_EQ(empty->type(), VARCHAR());
@@ -1051,10 +1060,36 @@ TEST_F(VectorTest, row) {
   baseRow = createRow(vectorSize_, true);
   testCopy(baseRow, numIterations_);
   testSlices(baseRow);
-  auto allNull =
-      BaseVector::createNullConstant(baseRow->type(), 50, pool_.get());
+  auto allNull = BaseVector::createNullConstant(baseRow->type(), 50, pool());
   testCopy(allNull, numIterations_);
   testSlices(allNull);
+  // created from BaseVector::Create()
+  baseRow = BaseVector::create(baseRow->type(), vectorSize_, pool());
+  testCopy(baseRow, numIterations_);
+  testSlices(baseRow);
+
+  // Check child accessors throws.
+  auto rowVector = baseRow->as<RowVector>();
+  EXPECT_NO_THROW(rowVector->childAt(1)->size());
+  EXPECT_NO_THROW(rowVector->childAt(1)->resize(vectorSize_));
+
+  EXPECT_THROW(rowVector->childAt(3)->size(), VeloxRuntimeError);
+  VELOX_ASSERT_THROW(
+      rowVector->childAt(3)->size(),
+      "Trying to access non-existing child in RowVector:");
+
+  EXPECT_THROW(rowVector->childAt(3)->resize(vectorSize_), VeloxRuntimeError);
+  VELOX_ASSERT_THROW(
+      rowVector->childAt(3)->resize(vectorSize_),
+      "Trying to access non-existing child in RowVector:");
+
+  ASSERT_EQ(
+      rowVector->childAt("parent_bigint").get(), rowVector->childAt(0).get());
+  ASSERT_EQ(
+      rowVector->childAt("parent_row").get(), rowVector->childAt(1).get());
+  VELOX_ASSERT_THROW(
+      rowVector->childAt("foo"),
+      "Field not found: foo. Available fields are: parent_bigint, parent_row.");
 }
 
 TEST_F(VectorTest, array) {
@@ -1064,8 +1099,7 @@ TEST_F(VectorTest, array) {
   baseArray = createArray(vectorSize_, true);
   testCopy(baseArray, numIterations_);
   testSlices(baseArray);
-  auto allNull =
-      BaseVector::createNullConstant(baseArray->type(), 50, pool_.get());
+  auto allNull = BaseVector::createNullConstant(baseArray->type(), 50, pool());
   testCopy(allNull, numIterations_);
   testSlices(allNull);
 }
@@ -1077,8 +1111,7 @@ TEST_F(VectorTest, map) {
   baseMap = createRow(vectorSize_, true);
   testCopy(baseMap, numIterations_);
   testSlices(baseMap);
-  auto allNull =
-      BaseVector::createNullConstant(baseMap->type(), 50, pool_.get());
+  auto allNull = BaseVector::createNullConstant(baseMap->type(), 50, pool());
   testCopy(allNull, numIterations_);
   testSlices(allNull);
 }
@@ -1086,7 +1119,7 @@ TEST_F(VectorTest, map) {
 TEST_F(VectorTest, unknown) {
   // Creates a const UNKNOWN vector.
   auto constUnknownVector = BaseVector::createConstant(
-      UNKNOWN(), variant(TypeKind::UNKNOWN), 123, pool_.get());
+      UNKNOWN(), variant(TypeKind::UNKNOWN), 123, pool());
   ASSERT_FALSE(constUnknownVector->isScalar());
   ASSERT_EQ(TypeKind::UNKNOWN, constUnknownVector->typeKind());
   ASSERT_EQ(123, constUnknownVector->size());
@@ -1095,7 +1128,7 @@ TEST_F(VectorTest, unknown) {
   }
 
   // Create an int vector and copy UNKNOWN const vector into it.
-  auto intVector = BaseVector::create(BIGINT(), 10, pool_.get());
+  auto intVector = BaseVector::create(BIGINT(), 10, pool());
   ASSERT_FALSE(intVector->isNullAt(0));
   ASSERT_FALSE(intVector->mayHaveNulls());
   intVector->copy(constUnknownVector.get(), 0, 0, 1);
@@ -1115,7 +1148,7 @@ TEST_F(VectorTest, unknown) {
   EXPECT_ANY_THROW(constUnknownVector->copy(intVector.get(), rows, nullptr));
 
   // Create a flat UNKNOWN vector.
-  auto unknownVector = BaseVector::create(UNKNOWN(), 10, pool_.get());
+  auto unknownVector = BaseVector::create(UNKNOWN(), 10, pool());
   ASSERT_EQ(VectorEncoding::Simple::FLAT, unknownVector->encoding());
   ASSERT_FALSE(unknownVector->isScalar());
   for (int i = 0; i < unknownVector->size(); ++i) {
@@ -1373,8 +1406,8 @@ TEST_F(VectorTest, copyFromUnknown) {
 TEST_F(VectorTest, wrapInConstant) {
   // wrap flat vector
   const vector_size_t size = 1'000;
-  auto flatVector = makeFlatVector<int32_t>(
-      size, [](auto row) { return row; }, nullEvery(7));
+  auto flatVector =
+      makeFlatVector<int32_t>(size, [](auto row) { return row; }, nullEvery(7));
 
   auto constVector = std::dynamic_pointer_cast<ConstantVector<int32_t>>(
       BaseVector::wrapInConstant(size, 5, flatVector));
@@ -1392,13 +1425,13 @@ TEST_F(VectorTest, wrapInConstant) {
   }
 
   // wrap dictionary vector
-  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(size, pool_.get());
+  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(size, pool());
   auto rawIndices = indices->asMutable<vector_size_t>();
   for (auto i = 0; i < size; i++) {
     rawIndices[i] = 2 * i % size;
   }
 
-  BufferPtr nulls = AlignedBuffer::allocate<bool>(size, pool_.get());
+  BufferPtr nulls = allocateNulls(size, pool());
   auto rawNulls = nulls->asMutable<uint64_t>();
   for (auto i = 0; i < size; i++) {
     bits::setNull(rawNulls, i, i % 11 == 0);
@@ -1426,7 +1459,7 @@ TEST_F(VectorTest, wrapInConstant) {
   auto arrayVector = makeArrayVector<int32_t>(
       size, [](auto) { return 10; }, [](auto i) { return i; }, nullEvery(7));
   auto constBaseVector = std::make_shared<ConstantVector<ComplexType>>(
-      pool_.get(), size, 3, arrayVector);
+      pool(), size, 3, arrayVector);
   auto constArrayVector =
       std::dynamic_pointer_cast<ConstantVector<ComplexType>>(
           BaseVector::wrapInConstant(size, 22, constBaseVector));
@@ -1439,20 +1472,34 @@ TEST_F(VectorTest, wrapInConstant) {
 
   // Wrap constant with valueVector and null value.
   constBaseVector = std::make_shared<ConstantVector<ComplexType>>(
-      pool_.get(), size, 7, arrayVector);
+      pool(), size, 7, arrayVector);
   constArrayVector = std::dynamic_pointer_cast<ConstantVector<ComplexType>>(
       BaseVector::wrapInConstant(size, 22, constBaseVector, true));
   EXPECT_NE(constArrayVector->valueVector(), nullptr);
   for (auto i = 0; i < size; i++) {
     ASSERT_TRUE(constArrayVector->isNullAt(i));
   }
+
+  // Wrap a loaded lazy complex vector that will be retained as a valueVector.
+  // Ensure the lazy layer is stripped away and the valueVector points to the
+  // loaded Vector underneath it.
+  auto lazyOverArray = std::make_shared<LazyVector>(
+      pool(),
+      arrayVector->type(),
+      size,
+      std::make_unique<TestingLoader>(arrayVector));
+  lazyOverArray->loadedVector();
+  EXPECT_TRUE(lazyOverArray->isLoaded());
+  constArrayVector = std::dynamic_pointer_cast<ConstantVector<ComplexType>>(
+      BaseVector::wrapInConstant(size, 22, lazyOverArray));
+  EXPECT_FALSE(constArrayVector->valueVector()->isLazy());
 }
 
 TEST_F(VectorTest, wrapInConstantWithCopy) {
   // Wrap flat vector.
   const vector_size_t size = 1'000;
-  auto flatVector = makeFlatVector<int32_t>(
-      size, [](auto row) { return row; }, nullEvery(7));
+  auto flatVector =
+      makeFlatVector<int32_t>(size, [](auto row) { return row; }, nullEvery(7));
 
   auto constVector = std::dynamic_pointer_cast<ConstantVector<int32_t>>(
       BaseVector::wrapInConstant(size, 5, flatVector, true));
@@ -1470,13 +1517,13 @@ TEST_F(VectorTest, wrapInConstantWithCopy) {
   }
 
   // Wrap dictionary vector.
-  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(size, pool_.get());
+  BufferPtr indices = AlignedBuffer::allocate<vector_size_t>(size, pool());
   auto rawIndices = indices->asMutable<vector_size_t>();
   for (auto i = 0; i < size; i++) {
     rawIndices[i] = 2 * i % size;
   }
 
-  BufferPtr nulls = AlignedBuffer::allocate<bool>(size, pool_.get());
+  BufferPtr nulls = allocateNulls(size, pool());
   auto rawNulls = nulls->asMutable<uint64_t>();
   for (auto i = 0; i < size; i++) {
     bits::setNull(rawNulls, i, i % 11 == 0);
@@ -1497,7 +1544,7 @@ TEST_F(VectorTest, wrapInConstantWithCopy) {
   auto arrayVector = makeArrayVector<int32_t>(
       size, [](auto) { return 10; }, [](auto i) { return i; }, nullEvery(7));
   auto constBaseVector = std::make_shared<ConstantVector<ComplexType>>(
-      pool_.get(), size, 3, arrayVector);
+      pool(), size, 3, arrayVector);
   auto constArrayVector =
       std::dynamic_pointer_cast<ConstantVector<ComplexType>>(
           BaseVector::wrapInConstant(size, 22, constBaseVector, true));
@@ -1510,7 +1557,7 @@ TEST_F(VectorTest, wrapInConstantWithCopy) {
 
   // Wrap constant with valueVector and null value.
   constBaseVector = std::make_shared<ConstantVector<ComplexType>>(
-      pool_.get(), size, 7, arrayVector);
+      pool(), size, 7, arrayVector);
   constArrayVector = std::dynamic_pointer_cast<ConstantVector<ComplexType>>(
       BaseVector::wrapInConstant(size, 22, constBaseVector, true));
   EXPECT_NE(constArrayVector->valueVector(), nullptr);
@@ -1520,6 +1567,91 @@ TEST_F(VectorTest, wrapInConstantWithCopy) {
   }
 }
 
+TEST_F(VectorTest, rowResize) {
+  auto testRowResize = [&](const VectorPtr& vector, bool setNotNull) {
+    auto rowVector = vector->as<RowVector>();
+    for (auto& child : rowVector->children()) {
+      VELOX_CHECK(child.unique());
+    }
+    auto oldSize = rowVector->size();
+    auto newSize = oldSize * 2;
+
+    rowVector->resize(newSize, setNotNull);
+
+    EXPECT_EQ(rowVector->size(), newSize);
+
+    for (auto& child : rowVector->children()) {
+      EXPECT_EQ(child->size(), newSize);
+    }
+
+    if (setNotNull) {
+      for (int i = oldSize; i < newSize; i++) {
+        EXPECT_EQ(rowVector->isNullAt(i), !setNotNull);
+        for (auto& child : rowVector->children()) {
+          EXPECT_EQ(child->isNullAt(i), !setNotNull);
+        }
+      }
+    }
+  };
+
+  // FlatVectors.
+  auto rowVector =
+      makeRowVector({makeFlatVector<int32_t>(10), makeFlatVector<int64_t>(10)});
+  testRowResize(rowVector, bits::kNull);
+
+  rowVector =
+      makeRowVector({makeFlatVector<int32_t>(10), makeFlatVector<double>(10)});
+  testRowResize(rowVector, bits::kNotNull);
+
+  rowVector = makeRowVector({makeFlatVector<StringView>(10)});
+  testRowResize(rowVector, bits::kNotNull);
+  rowVector = makeRowVector({makeFlatVector<StringView>(10)});
+  testRowResize(rowVector, bits::kNull);
+
+  // Dictionaries.
+  rowVector = makeRowVector({BaseVector::wrapInDictionary(
+      nullptr,
+      makeIndices(10, [](auto row) { return row; }),
+      10,
+      BaseVector::wrapInDictionary(
+          nullptr,
+          makeIndices(10, [](auto row) { return row; }),
+          10,
+          makeFlatVector<int32_t>(10)))});
+  testRowResize(rowVector, bits::kNotNull);
+
+  // Constants.
+  rowVector = makeRowVector({BaseVector::wrapInConstant(
+      10,
+      5,
+      makeArrayVector<int32_t>(
+          10,
+          [](auto row) { return row % 5 + 1; },
+          [](auto row, auto index) { return row * 2 + index; }))});
+  testRowResize(rowVector, bits::kNotNull);
+
+  // Complex Types.
+  rowVector = makeRowVector(
+      {makeArrayVector<int32_t>(
+           10,
+           [](auto row) { return row % 5 + 1; },
+           [](auto row, auto index) { return row * 2 + index; }),
+       makeMapVector<int32_t, int64_t>(
+           10,
+           [](auto row) { return row % 5; },
+           [](auto row) { return row % 7; },
+           [](auto row) { return row % 5; },
+           nullEvery(9))});
+  testRowResize(rowVector, bits::kNotNull);
+
+  // Resize on lazy children will result in an exception.
+  auto rowWithLazyChild = makeRowVector({makeLazyFlatVector<int32_t>(
+      10,
+      [&](vector_size_t i) { return i % 5; },
+      [](vector_size_t i) { return i % 7 == 0; })});
+  EXPECT_THROW(rowWithLazyChild->resize(20), VeloxException);
+}
+
 TEST_F(VectorTest, wrapConstantInDictionary) {
   // Wrap Constant in Dictionary with no extra nulls. Expect Constant.
   auto indices = makeIndices(10, [](auto row) { return row % 2; });
@@ -1527,7 +1659,7 @@ TEST_F(VectorTest, wrapConstantInDictionary) {
       nullptr,
       indices,
       10,
-      BaseVector::createConstant(INTEGER(), 7, 100, pool_.get()));
+      BaseVector::createConstant(INTEGER(), 7, 100, pool()));
   ASSERT_EQ(vector->encoding(), VectorEncoding::Simple::CONSTANT);
   auto constantVector =
       std::dynamic_pointer_cast<ConstantVector<int32_t>>(vector);
@@ -1542,7 +1674,7 @@ TEST_F(VectorTest, wrapConstantInDictionary) {
       nulls,
       indices,
       10,
-      BaseVector::createConstant(INTEGER(), 11, 100, pool_.get()));
+      BaseVector::createConstant(INTEGER(), 11, 100, pool()));
   ASSERT_EQ(vector->encoding(), VectorEncoding::Simple::DICTIONARY);
   auto dictVector = std::dynamic_pointer_cast<SimpleVector<int32_t>>(vector);
   for (auto i = 0; i < 10; ++i) {
@@ -1556,7 +1688,7 @@ TEST_F(VectorTest, wrapConstantInDictionary) {
 }
 
 TEST_F(VectorTest, setFlatVectorStringView) {
-  auto vector = BaseVector::create(VARCHAR(), 1, pool_.get());
+  auto vector = BaseVector::create(VARCHAR(), 1, pool());
   auto flat = vector->asFlatVector<StringView>();
   EXPECT_EQ(0, flat->stringBuffers().size());
 
@@ -1568,7 +1700,7 @@ TEST_F(VectorTest, setFlatVectorStringView) {
   EXPECT_EQ(originalString.size(), flat->stringBuffers()[0]->size());
 
   // Make a copy of the vector. Verify that string buffer is shared.
-  auto copy = BaseVector::create(VARCHAR(), 1, pool_.get());
+  auto copy = BaseVector::create(VARCHAR(), 1, pool());
   copy->copy(flat, 0, 0, 1);
 
   auto flatCopy = copy->asFlatVector<StringView>();
@@ -1589,7 +1721,7 @@ TEST_F(VectorTest, resizeAtConstruction) {
   const size_t realSize = 10;
 
   vector_size_t oldByteSize = BaseVector::byteSize<int64_t>(realSize);
-  BufferPtr values = AlignedBuffer::allocate<char>(oldByteSize, pool_.get());
+  BufferPtr values = AlignedBuffer::allocate<char>(oldByteSize, pool());
 
   EXPECT_EQ(oldByteSize, values->size());
   EXPECT_GE(values->capacity(), values->size());
@@ -1605,7 +1737,7 @@ TEST_F(VectorTest, resizeAtConstruction) {
 
   // Now create a FlatVector with the resized buffer.
   auto flat = std::make_shared<FlatVector<int64_t>>(
-      pool_.get(),
+      pool(),
       BIGINT(),
       BufferPtr(nullptr),
       realSize,
@@ -1627,17 +1759,34 @@ TEST_F(VectorTest, resizeStringAsciiness) {
   ASSERT_FALSE(stringVector->isAscii(rows));
 }
 
+TEST_F(VectorTest, resizeZeroString) {
+  auto vector = makeFlatVector<std::string>(
+      {"This is a string",
+       "This is another string",
+       "This is the third string"});
+  ASSERT_EQ(1, vector->stringBuffers().size());
+  ASSERT_LT(0, vector->stringBuffers()[0]->size());
+
+  const auto capacity = vector->stringBuffers()[0]->capacity();
+  ASSERT_GT(capacity, 0);
+
+  vector->resize(0);
+  ASSERT_EQ(1, vector->stringBuffers().size());
+  ASSERT_EQ(0, vector->stringBuffers()[0]->size());
+  ASSERT_EQ(capacity, vector->stringBuffers()[0]->capacity());
+}
+
 TEST_F(VectorTest, copyNoRows) {
   {
     auto source = makeFlatVector<int32_t>({1, 2, 3});
-    auto target = BaseVector::create(INTEGER(), 10, pool_.get());
+    auto target = BaseVector::create(INTEGER(), 10, pool());
     SelectivityVector rows(3, false);
     target->copy(source.get(), rows, nullptr);
   }
 
   {
     auto source = makeFlatVector<StringView>({"a", "b", "c"});
-    auto target = BaseVector::create(VARCHAR(), 10, pool_.get());
+    auto target = BaseVector::create(VARCHAR(), 10, pool());
     SelectivityVector rows(3, false);
     target->copy(source.get(), rows, nullptr);
   }
@@ -1721,7 +1870,7 @@ class VectorCreateConstantTest : public VectorTest {
     using TCpp = typename TypeTraits<KIND>::NativeType;
     variant var = variant::create<KIND>(val);
 
-    auto baseVector = BaseVector::createConstant(type, var, size_, pool_.get());
+    auto baseVector = BaseVector::createConstant(type, var, size_, pool());
     auto simpleVector = baseVector->template as<SimpleVector<TCpp>>();
     ASSERT_TRUE(simpleVector != nullptr);
 
@@ -1775,7 +1924,7 @@ class VectorCreateConstantTest : public VectorTest {
   template <TypeKind KIND>
   void testNullConstant(const TypePtr& type) {
     ASSERT_EQ(KIND, type->kind());
-    auto baseVector = BaseVector::createNullConstant(type, size_, pool_.get());
+    auto baseVector = BaseVector::createNullConstant(type, size_, pool());
     auto simpleVector = baseVector->template as<
         SimpleVector<typename KindToFlatVector<KIND>::WrapperType>>();
     ASSERT_TRUE(simpleVector != nullptr);
@@ -1871,12 +2020,12 @@ class TestingHook : public ValueHook {
     return false;
   }
 
-  void addValue(vector_size_t row, const void* value) override {
+  void addValue(vector_size_t row, int64_t value) override {
     if (values_->isNullAt(rows_[row])) {
       ++errors_;
     } else {
       auto original = values_->valueAt(rows_[row]);
-      if (original != *reinterpret_cast<const int64_t*>(value)) {
+      if (original != value) {
         ++errors_;
       }
     }
@@ -1894,7 +2043,7 @@ class TestingHook : public ValueHook {
 TEST_F(VectorTest, valueHook) {
   VectorPtr values = createScalar<TypeKind::BIGINT>(BIGINT(), 1000, true);
   auto lazy = std::make_shared<LazyVector>(
-      pool_.get(),
+      pool(),
       BIGINT(),
       values->size(),
       std::make_unique<TestingLoader>(values));
@@ -1924,7 +2073,7 @@ TEST_F(VectorTest, byteSize) {
 
 TEST_F(VectorTest, clearNulls) {
   auto vectorSize = 100;
-  auto vector = BaseVector::create(INTEGER(), vectorSize, pool_.get());
+  auto vector = BaseVector::create(INTEGER(), vectorSize, pool());
   ASSERT_FALSE(vector->mayHaveNulls());
 
   // No op if doesn't have nulls
@@ -1977,7 +2126,7 @@ TEST_F(VectorTest, setStringToNull) {
       kSize, [](auto /*row*/) { return StringView("Non-inlined string"); });
   target->setNull(kSize - 1, true);
   auto unknownNull = std::make_shared<ConstantVector<UnknownValue>>(
-      pool_.get(), kSize, true, UNKNOWN(), UnknownValue());
+      pool(), kSize, true, UNKNOWN(), UnknownValue());
 
   auto stringNull = BaseVector::wrapInConstant(kSize, kSize - 1, target);
   SelectivityVector rows(kSize, false);
@@ -1990,10 +2139,9 @@ TEST_F(VectorTest, setStringToNull) {
   rows.updateBounds();
   target->copy(stringNull.get(), rows, nullptr);
   EXPECT_TRUE(target->isNullAt(4));
-  auto nulls = AlignedBuffer::allocate<uint64_t>(
-      bits::nwords(kSize), pool_.get(), bits::kNull64);
+  auto nulls = allocateNulls(kSize, pool(), bits::kNull);
   auto flatNulls = std::make_shared<FlatVector<UnknownValue>>(
-      pool_.get(),
+      pool(),
       UNKNOWN(),
       nulls,
       kSize,
@@ -2008,7 +2156,7 @@ TEST_F(VectorTest, setStringToNull) {
 
 TEST_F(VectorTest, clearAllNulls) {
   auto vectorSize = 100;
-  auto vector = BaseVector::create(INTEGER(), vectorSize, pool_.get());
+  auto vector = BaseVector::create(INTEGER(), vectorSize, pool());
   ASSERT_FALSE(vector->mayHaveNulls());
 
   auto rawNulls = vector->mutableRawNulls();
@@ -2033,7 +2181,7 @@ TEST_F(VectorTest, multipleDictionariesOverLazy) {
   vector_size_t size = 10;
   auto indices = makeIndices(size, [&](auto row) { return size - row - 1; });
   auto lazy = std::make_shared<LazyVector>(
-      pool_.get(),
+      pool(),
       INTEGER(),
       size,
       std::make_unique<TestingLoader>(
@@ -2060,8 +2208,8 @@ TEST_F(VectorTest, selectiveLoadingOfLazyDictionaryNested) {
 
   auto loader = std::make_unique<TestingLoader>(data);
   auto loaderPtr = loader.get();
-  auto lazyVector = std::make_shared<LazyVector>(
-      pool_.get(), INTEGER(), size, std::move(loader));
+  auto lazyVector =
+      std::make_shared<LazyVector>(pool(), INTEGER(), size, std::move(loader));
 
   auto indicesInner =
       makeIndices(size, [&](auto row) { return (row % 2 == 0) ? row : 0; });
@@ -2088,7 +2236,7 @@ TEST_F(VectorTest, nestedLazy) {
   auto indexAt = [](vector_size_t) { return 0; };
   auto makeLazy = [&]() {
     return std::make_shared<LazyVector>(
-        pool_.get(),
+        pool(),
         INTEGER(),
         size,
         std::make_unique<TestingLoader>(
@@ -2104,6 +2252,13 @@ TEST_F(VectorTest, nestedLazy) {
       "An unloaded lazy vector cannot be wrapped by two different top level"
       " vectors.");
 
+  // Verify that if the original dictionary layer is destroyed without loading
+  // the underlying vector then the lazy vector can be wrapped in a new encoding
+  // layer.
+  dict.reset();
+  dict = BaseVector::wrapInDictionary(
+      nullptr, makeIndices(size, indexAt), size, lazy);
+
   // Verify that the unloaded dictionary can be nested as long as it has one top
   // level vector.
   EXPECT_NO_THROW(BaseVector::wrapInDictionary(
@@ -2117,6 +2272,23 @@ TEST_F(VectorTest, nestedLazy) {
   EXPECT_TRUE(lazy->isLoaded());
 }
 
+TEST_F(VectorTest, wrapInDictionaryOverLoadedLazy) {
+  // Ensure the lazy layer is stripped away and the dictionaryValues vector
+  // points to the loaded Vector underneath it.
+  vector_size_t size = 10;
+  auto lazy = std::make_shared<LazyVector>(
+      pool(),
+      INTEGER(),
+      size,
+      std::make_unique<TestingLoader>(
+          makeFlatVector<int64_t>(size, [](auto row) { return row; })));
+  lazy->loadedVector();
+  EXPECT_TRUE(lazy->isLoaded());
+  auto dict = wrapInDictionary(makeIndices(size, folly::identity), size, lazy);
+  auto valuesVector = dict->valueVector();
+  EXPECT_FALSE(valuesVector->isLazy());
+}
+
 TEST_F(VectorTest, dictionaryResize) {
   vector_size_t size = 10;
   std::vector<int64_t> elements{0, 1, 2, 3, 4};
@@ -2193,9 +2365,9 @@ TEST_F(VectorTest, acquireSharedStringBuffers) {
   std::vector<BufferPtr> buffers;
   const int bufferSize = 100;
   for (int i = 0; i < numBuffers; ++i) {
-    buffers.push_back(AlignedBuffer::allocate<char>(bufferSize, pool_.get()));
+    buffers.push_back(AlignedBuffer::allocate<char>(bufferSize, pool()));
   }
-  auto vector = BaseVector::create(VARCHAR(), 100, pool_.get());
+  auto vector = BaseVector::create(VARCHAR(), 100, pool());
   auto flatVector = vector->as<FlatVector<StringView>>();
   EXPECT_EQ(0, flatVector->stringBuffers().size());
 
@@ -2211,7 +2383,7 @@ TEST_F(VectorTest, acquireSharedStringBuffers) {
   int numSourceVectors = 2;
   std::vector<VectorPtr> sourceVectors;
   for (int i = 0; i < numSourceVectors; ++i) {
-    sourceVectors.push_back(BaseVector::create(VARCHAR(), 100, pool_.get()));
+    sourceVectors.push_back(BaseVector::create(VARCHAR(), 100, pool()));
     sourceVectors.back()->asFlatVector<StringView>()->setStringBuffers(
         {buffers[i]});
   }
@@ -2240,12 +2412,12 @@ TEST_F(VectorTest, acquireSharedStringBuffers) {
   auto arrayVector = makeArrayVector<int32_t>({});
   ASSERT_NO_THROW(flatVector->acquireSharedStringBuffers(arrayVector.get()));
 
-  auto unkownVector = BaseVector::create(UNKNOWN(), 100, pool_.get());
+  auto unkownVector = BaseVector::create(UNKNOWN(), 100, pool());
   ASSERT_NO_THROW(flatVector->acquireSharedStringBuffers(unkownVector.get()));
 }
 
 TEST_F(VectorTest, acquireSharedStringBuffersRecursive) {
-  auto vector = BaseVector::create(VARCHAR(), 100, pool_.get());
+  auto vector = BaseVector::create(VARCHAR(), 100, pool());
   auto flatVector = vector->as<FlatVector<StringView>>();
 
   auto testWithEncodings = [&](const VectorPtr& source,
@@ -2262,7 +2434,7 @@ TEST_F(VectorTest, acquireSharedStringBuffersRecursive) {
 
     // Dictionary Vector.
     BufferPtr indices =
-        AlignedBuffer::allocate<vector_size_t>(source->size(), pool_.get());
+        AlignedBuffer::allocate<vector_size_t>(source->size(), pool());
     for (int32_t i = 0; i < source->size(); ++i) {
       indices->asMutable<vector_size_t>()[i] = source->size() - i - 1;
     }
@@ -2451,7 +2623,7 @@ TEST_F(VectorTest, mapSliceMutability) {
 TEST_F(VectorTest, lifetime) {
   ASSERT_DEATH(
       {
-        auto childPool = memory::addDefaultLeafMemoryPool();
+        auto childPool = memory::memoryManager()->addLeafPool();
         auto v = BaseVector::create(INTEGER(), 10, childPool.get());
 
         // BUG: Memory pool needs to stay alive until all memory allocated from
@@ -2579,10 +2751,7 @@ TEST_F(VectorTest, flattenVector) {
   test(row, true);
 
   VectorPtr lazy = std::make_shared<LazyVector>(
-      pool_.get(),
-      INTEGER(),
-      flat->size(),
-      std::make_unique<TestingLoader>(flat));
+      pool(), INTEGER(), flat->size(), std::make_unique<TestingLoader>(flat));
   test(lazy, true);
 
   // Constant
@@ -2596,6 +2765,12 @@ TEST_F(VectorTest, flattenVector) {
   test(dictionary, false);
   EXPECT_TRUE(dictionary->isFlatEncoding());
 
+  VectorPtr lazyDictionary =
+      wrapInLazyDictionary(makeFlatVector<int32_t>({1, 2, 3}));
+  test(lazyDictionary, true);
+  EXPECT_TRUE(lazyDictionary->isLazy());
+  EXPECT_TRUE(lazyDictionary->loadedVector()->isFlatEncoding());
+
   // Array with constant elements.
   auto* arrayVector = array->as<ArrayVector>();
   arrayVector->elements() = BaseVector::wrapInConstant(100, 1, flat);
@@ -2707,7 +2882,7 @@ TEST_F(VectorTest, resizeArrayAndMapResetOffsets) {
 
   // Test array.
   {
-    auto offsets = makeIndices({1, 1, 1, 1});
+    auto offsets = makeIndices({0, 1, 2, 3});
     auto sizes = makeIndices({1, 1, 1, 1});
 
     auto* rawSizes = sizes->as<vector_size_t>();
@@ -2732,7 +2907,7 @@ TEST_F(VectorTest, resizeArrayAndMapResetOffsets) {
 
   // Test map.
   {
-    auto offsets = makeIndices({1, 1, 1, 1});
+    auto offsets = makeIndices({0, 1, 2, 3});
     auto sizes = makeIndices({1, 1, 1, 1});
 
     auto* rawSizes = sizes->as<vector_size_t>();
@@ -2773,6 +2948,26 @@ TEST_F(VectorTest, getRawStringBufferWithSpace) {
   auto expected = makeFlatVector<StringView>(
       {"ee", "I'm replace 123456789", "rryy", "12345678901234"});
   test::assertEqualVectors(expected, vector);
+
+  // Use up all but 5 bytes in the 'lastBuffer', then ask for buffer with at
+  // least 6 bytes of space. Expect a fairly large new buffer.
+  lastBuffer->setSize(lastBuffer->capacity() - 5);
+  rawBuffer = vector->getRawStringBufferWithSpace(6);
+  ASSERT_EQ(vector->stringBuffers().size(), 2);
+
+  lastBuffer = vector->stringBuffers().back();
+  ASSERT_EQ(6, lastBuffer->size());
+  ASSERT_EQ(49056, lastBuffer->capacity());
+
+  // Use up all bytes in 'lastBuffer, then ask for buffer with exactly one byte
+  // of space. Expect a small new buffer.
+  lastBuffer->setSize(lastBuffer->capacity());
+
+  rawBuffer = vector->getRawStringBufferWithSpace(1, true /*exactSize*/);
+  ASSERT_EQ(vector->stringBuffers().size(), 3);
+  lastBuffer = vector->stringBuffers().back();
+  ASSERT_EQ(1, lastBuffer->size());
+  ASSERT_EQ(32, lastBuffer->capacity());
 }
 
 TEST_F(VectorTest, getRawStringBufferWithSpaceNoExistingBuffer) {
@@ -3082,5 +3277,661 @@ TEST_F(VectorTest, appendNulls) {
   // Append negative.
   EXPECT_ANY_THROW(rowVector->appendNulls(-1));
 }
+
+TEST_F(VectorTest, primitiveTypeNullEqual) {
+  auto base = makeNullableFlatVector<int32_t>({1, 2, std::nullopt});
+  auto other = makeNullableFlatVector<int32_t>({1, std::nullopt, 1});
+
+  auto equalNoStop = [&](vector_size_t i, vector_size_t j) {
+    return base
+        ->equalValueAt(
+            other.get(), i, j, CompareFlags::NullHandlingMode::kNullAsValue)
+        .value();
+  };
+
+  auto equalStopAtNull = [&](vector_size_t i, vector_size_t j) {
+    return base->equalValueAt(
+        other.get(),
+        i,
+        j,
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  };
+
+  // No null compare.
+  ASSERT_TRUE(equalNoStop(0, 0));
+  ASSERT_TRUE(equalStopAtNull(0, 0).value());
+
+  // Null compare in NullAsValue mode.
+  ASSERT_FALSE(equalNoStop(1, 1));
+  ASSERT_FALSE(equalNoStop(2, 2));
+
+  // Null compare in StopAtNull mode.
+  ASSERT_FALSE(equalStopAtNull(1, 1).has_value());
+  ASSERT_FALSE(equalStopAtNull(2, 2).has_value());
+}
+
+TEST_F(VectorTest, complexTypeNullEqual) {
+  auto base =
+      makeArrayVectorFromJson<int32_t>({"[0, 1]", "[2, 2]", "[2, null]"});
+  auto other =
+      makeArrayVectorFromJson<int32_t>({"[0, 1]", "[2, null]", "[1, 2]"});
+  auto equalNoStop = [&](vector_size_t i, vector_size_t j) {
+    return base
+        ->equalValueAt(
+            other.get(), i, j, CompareFlags::NullHandlingMode::kNullAsValue)
+        .value();
+  };
+
+  auto equalStopAtNull = [&](vector_size_t i, vector_size_t j) {
+    return base->equalValueAt(
+        other.get(),
+        i,
+        j,
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  };
+
+  // No null compare, [0, 1] vs [0, 1].
+  ASSERT_TRUE(equalNoStop(0, 0));
+  ASSERT_TRUE(equalStopAtNull(0, 0).value());
+
+  // No null compare, [2, null] vs [1, 2].
+  ASSERT_FALSE(equalNoStop(2, 2));
+  ASSERT_FALSE(equalStopAtNull(2, 2).value());
+
+  // Null compare in NullAsValue mode, [2, 2] vs [2, null].
+  ASSERT_FALSE(equalNoStop(1, 1));
+
+  // Null compare in StopAtNull mode, [2, 2] vs [2, null].
+  ASSERT_FALSE(equalStopAtNull(1, 1).has_value());
+}
+
+TEST_F(VectorTest, dictionaryNullEqual) {
+  auto base =
+      makeArrayVectorFromJson<int32_t>({"[0, 1]", "[2, 2]", "[2, null]"});
+  auto other =
+      makeArrayVectorFromJson<int32_t>({"[0, 1]", "[2, null]", "[1, 2]"});
+  auto baseVectorSize = base->size();
+  auto kTopLevelVectorSize = baseVectorSize * 2;
+  BufferPtr indices = test::makeIndices(
+      kTopLevelVectorSize,
+      [&](vector_size_t i) { return i % baseVectorSize; },
+      pool());
+  auto dictVector =
+      BaseVector::wrapInDictionary(nullptr, indices, kTopLevelVectorSize, base);
+
+  auto equalNoStop = [&](vector_size_t i, vector_size_t j) {
+    return dictVector
+        ->equalValueAt(
+            other.get(), i, j, CompareFlags::NullHandlingMode::kNullAsValue)
+        .value();
+  };
+
+  auto equalStopAtNull = [&](vector_size_t i, vector_size_t j) {
+    return dictVector->equalValueAt(
+        other.get(),
+        i,
+        j,
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  };
+
+  for (vector_size_t i = 0; i < 2; ++i) {
+    // No null compare, [0, 1] vs [0, 1].
+    ASSERT_TRUE(equalNoStop(i * baseVectorSize, 0));
+    ASSERT_TRUE(equalStopAtNull(i * baseVectorSize, 0).value());
+
+    // No null compare, [2, null] vs [1. 2].
+    ASSERT_FALSE(equalNoStop(2 + i * baseVectorSize, 2));
+    ASSERT_FALSE(equalStopAtNull(2 + i * baseVectorSize, 2).value());
+
+    // Null compare in NullAsValue mode, [2, 2] vs [2, null].
+    ASSERT_FALSE(equalNoStop(1 + i * baseVectorSize, 1));
+
+    // Null compare in StopAtNull mode, [2, 2] vs [2, null].
+    ASSERT_FALSE(equalStopAtNull(1 + i * baseVectorSize, 1).has_value());
+  }
+}
+
+TEST_F(VectorTest, constantNullEqual) {
+  auto base =
+      makeArrayVectorFromJson<int32_t>({"[0, 1]", "[2, 2]", "[2, null]"});
+  auto other =
+      makeArrayVectorFromJson<int32_t>({"[0, 1]", "[2, null]", "[1, 2]"});
+  auto baseVectorSize = base->size();
+  auto kTopLevelVectorSize = baseVectorSize * 2;
+  // [2, null]
+  auto constantVector =
+      BaseVector::wrapInConstant(kTopLevelVectorSize, 2, base);
+
+  auto equalNoStop = [&](vector_size_t i, vector_size_t j) {
+    return constantVector
+        ->equalValueAt(
+            other.get(), i, j, CompareFlags::NullHandlingMode::kNullAsValue)
+        .value();
+  };
+
+  auto equalStopAtNull = [&](vector_size_t i, vector_size_t j) {
+    return constantVector->equalValueAt(
+        other.get(),
+        i,
+        j,
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+  };
+
+  // No null compare, [2, null] vs [0, 1], [2, null] vs [1, 2].
+  ASSERT_FALSE(equalNoStop(0, 0));
+  ASSERT_FALSE(equalStopAtNull(0, 2).value());
+
+  // Null compare in NullAsValue mode, [2, null] vs [2, null].
+  ASSERT_TRUE(equalNoStop(0, 1));
+
+  // Null compare in StopAtNull mode, [2, null] vs [2, null].
+  ASSERT_FALSE(equalStopAtNull(0, 1).has_value());
+}
+
+TEST_F(VectorTest, dictionaryLoadedVectorRemoveLazy) {
+  auto makeTestVector = [&]() {
+    auto lazy = makeLazyFlatVector<int64_t>(3, [&](auto row) { return row; });
+    auto dictVector =
+        BaseVector::wrapInDictionary(nullptr, makeIndices({0, 1, 2}), 3, lazy);
+    return dictVector;
+  };
+
+  {
+    auto vector = makeTestVector();
+    vector->loadedVector();
+    EXPECT_FALSE(
+        vector->as<DictionaryVector<int64_t>>()->valueVector()->isLazy());
+  }
+
+  {
+    auto vector = makeTestVector();
+    LazyVector::ensureLoadedRows(vector, SelectivityVector(3));
+    EXPECT_FALSE(
+        vector->as<DictionaryVector<int64_t>>()->valueVector()->isLazy());
+  }
+
+  {
+    auto vector = makeRowVector({makeTestVector()});
+    vector->loadedVector();
+    EXPECT_FALSE(vector->as<RowVector>()
+                     ->childAt(0)
+                     ->as<DictionaryVector<int64_t>>()
+                     ->valueVector()
+                     ->isLazy());
+  }
+
+  {
+    auto vector = makeRowVector({makeTestVector()});
+    LazyVector::ensureLoadedRows(vector, SelectivityVector(3));
+    EXPECT_FALSE(vector->as<RowVector>()
+                     ->childAt(0)
+                     ->as<DictionaryVector<int64_t>>()
+                     ->valueVector()
+                     ->isLazy());
+  }
+}
+
+template <typename T>
+FlatVectorPtr<T> makeFlatNullValues(
+    vector_size_t size,
+    const TypePtr& type,
+    BufferPtr nulls,
+    memory::MemoryPool* pool) {
+  return std::make_shared<FlatVector<T>>(
+      pool,
+      type,
+      nulls,
+      size,
+      nullptr, // values
+      std::vector<BufferPtr>{});
+}
+
+TEST_F(VectorTest, flatAllNulls) {
+  // Create FlatVector of all nulls with null values buffer.
+  vector_size_t size = 1'000;
+
+  VELOX_ASSERT_THROW(
+      makeFlatNullValues<int64_t>(
+          size, BIGINT(), allocateNulls(size, pool()), pool()),
+      "FlatVector with null values buffer must have all rows set to null")
+
+  auto nulls = allocateNulls(size, pool(), bits::kNull);
+
+  // BIGINT. set API.
+  {
+    auto flat = makeFlatNullValues<int64_t>(size, BIGINT(), nulls, pool());
+
+    for (auto i = 0; i < size; ++i) {
+      ASSERT_TRUE(flat->isNullAt(i));
+    }
+
+    // Change some rows to non-null.
+    flat->set(7, 123LL);
+    ASSERT_FALSE(flat->isNullAt(7));
+    ASSERT_EQ(123LL, flat->valueAt(7));
+
+    for (auto i = 0; i < size; ++i) {
+      if (i != 7) {
+        ASSERT_TRUE(flat->isNullAt(i));
+      }
+    }
+  }
+
+  // BIGINT. setNull API.
+  {
+    auto flat = makeFlatNullValues<int64_t>(size, BIGINT(), nulls, pool());
+
+    for (auto i = 0; i < size; ++i) {
+      ASSERT_TRUE(flat->isNullAt(i));
+    }
+
+    // Change some rows to non-null.
+    flat->setNull(7, false);
+    ASSERT_FALSE(flat->isNullAt(7));
+    ASSERT_NO_THROW(flat->valueAt(7));
+
+    for (auto i = 0; i < size; ++i) {
+      if (i != 7) {
+        ASSERT_TRUE(flat->isNullAt(i));
+      }
+    }
+  }
+
+  // BOOLEAN.
+  {
+    auto flat = makeFlatNullValues<bool>(size, BIGINT(), nulls, pool());
+
+    for (auto i = 0; i < size; ++i) {
+      ASSERT_TRUE(flat->isNullAt(i));
+    }
+
+    // Change some rows to non-null.
+    flat->set(7, true);
+    ASSERT_FALSE(flat->isNullAt(7));
+    ASSERT_EQ(true, flat->valueAt(7));
+
+    flat->set(11, false);
+    ASSERT_FALSE(flat->isNullAt(11));
+    ASSERT_EQ(false, flat->valueAt(11));
+
+    for (auto i = 0; i < size; ++i) {
+      if (i != 7 && i != 11) {
+        ASSERT_TRUE(flat->isNullAt(i));
+      }
+    }
+  }
+
+  // VARCHAR with set.
+  {
+    auto flat = makeFlatNullValues<StringView>(size, VARCHAR(), nulls, pool());
+
+    for (auto i = 0; i < size; ++i) {
+      ASSERT_TRUE(flat->isNullAt(i));
+    }
+
+    // Change some rows to non-null.
+    flat->set(7, "Testing is time consuming");
+    ASSERT_FALSE(flat->isNullAt(7));
+    ASSERT_EQ("Testing is time consuming", flat->valueAt(7).str());
+
+    for (auto i = 0; i < size; ++i) {
+      if (i != 7) {
+        ASSERT_TRUE(flat->isNullAt(i));
+      }
+    }
+  }
+
+  // VARCHAR with setNoCopy.
+  {
+    auto flat = makeFlatNullValues<StringView>(size, VARCHAR(), nulls, pool());
+
+    for (auto i = 0; i < size; ++i) {
+      ASSERT_TRUE(flat->isNullAt(i));
+    }
+
+    // Change some rows to non-null.
+    flat->setNoCopy(7, "Short");
+    ASSERT_FALSE(flat->isNullAt(7));
+    ASSERT_EQ("Short", flat->valueAt(7).str());
+
+    for (auto i = 0; i < size; ++i) {
+      if (i != 7) {
+        ASSERT_TRUE(flat->isNullAt(i));
+      }
+    }
+  }
+}
+
+TEST_F(VectorTest, hashAll) {
+  auto data = makeFlatVector<int32_t>({1, 2, 3});
+  ASSERT_TRUE(data->getNullCount().has_value());
+
+  auto hashes = data->hashAll();
+
+  // Make a similar vector, but without stats, e.g. nullCount unset.
+  auto copy = std::make_shared<FlatVector<int32_t>>(
+      pool(), INTEGER(), nullptr, 3, data->values(), std::vector<BufferPtr>{});
+  ASSERT_FALSE(copy->getNullCount().has_value());
+
+  auto hashesCopy = copy->hashAll();
+
+  for (auto i = 0; i < 3; ++i) {
+    ASSERT_EQ(hashes->valueAt(i), hashesCopy->valueAt(i));
+  }
+}
+
+TEST_F(VectorTest, setType) {
+  auto test = [&](auto& type, auto& newType, auto& invalidNewType) {
+    auto vector = BaseVector::create(type, 1'000, pool());
+
+    vector->setType(newType);
+    EXPECT_EQ(vector->type()->toString(), newType->toString());
+
+    VELOX_ASSERT_RUNTIME_THROW(
+        vector->setType(invalidNewType),
+        fmt::format(
+            "Cannot change vector type from {} to {}. The old and new types can be different logical types, but the underlying physical types must match.",
+            newType->toString(),
+            invalidNewType->toString()));
+  };
+
+  // ROW
+  auto type = ROW({"aa"}, {BIGINT()});
+  auto newType = ROW({"bb"}, {BIGINT()});
+  auto invalidNewType = ROW({"bb"}, {VARCHAR()});
+  test(type, newType, invalidNewType);
+
+  // ROW(ROW)
+  type = ROW({"a", "b"}, {ROW({"c", "d"}, {BIGINT(), BIGINT()}), BIGINT()});
+  newType =
+      ROW({"a", "b"}, {ROW({"cc", "dd"}, {BIGINT(), BIGINT()}), BIGINT()});
+  invalidNewType =
+      ROW({"a", "b"}, {ROW({"cc", "dd"}, {VARCHAR(), BIGINT()}), BIGINT()});
+  test(type, newType, invalidNewType);
+
+  // ARRAY(ROW)
+  type =
+      ROW({"a", "b"}, {ARRAY(ROW({"c", "d"}, {BIGINT(), BIGINT()})), BIGINT()});
+  newType = ROW(
+      {"a", "b"}, {ARRAY(ROW({"cc", "dd"}, {BIGINT(), BIGINT()})), BIGINT()});
+  invalidNewType = ROW(
+      {"a", "b"}, {ARRAY(ROW({"cc", "dd"}, {VARCHAR(), BIGINT()})), BIGINT()});
+  test(type, newType, invalidNewType);
+
+  // MAP(ROW)
+  type =
+      ROW({"a", "b"},
+          {MAP(ROW({"c", "d"}, {BIGINT(), BIGINT()}),
+               ROW({"e", "f"}, {BIGINT(), BIGINT()})),
+           BIGINT()});
+  newType =
+      ROW({"a", "b"},
+          {MAP(ROW({"cc", "dd"}, {BIGINT(), BIGINT()}),
+               ROW({"ee", "ff"}, {BIGINT(), BIGINT()})),
+           BIGINT()});
+  invalidNewType =
+      ROW({"a", "b"},
+          {MAP(ROW({"cc", "dd"}, {VARCHAR(), BIGINT()}),
+               ROW({"ee", "ff"}, {VARCHAR(), BIGINT()})),
+           BIGINT()});
+  test(type, newType, invalidNewType);
+}
+
+TEST_F(VectorTest, getLargeStringBuffer) {
+  auto vector = makeFlatVector<StringView>({});
+  size_t size = size_t(std::numeric_limits<int32_t>::max()) + 1;
+  auto* buffer = vector->getBufferWithSpace(size);
+  EXPECT_GE(buffer->capacity(), size);
+}
+
+TEST_F(VectorTest, mapUpdate) {
+  auto base = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 1}, {2, 1}}},
+      {{}},
+      {{{3, 1}}},
+      std::nullopt,
+      {{{4, 1}}},
+  });
+  auto update = makeNullableMapVector<int64_t, int64_t>({
+      {{{2, 2}, {3, 2}}},
+      {{{4, 2}}},
+      {{}},
+      {{{5, 2}}},
+      std::nullopt,
+  });
+  auto expected = makeNullableMapVector<int64_t, int64_t>({
+      {{{2, 2}, {3, 2}, {1, 1}}},
+      {{{4, 2}}},
+      {{{3, 1}}},
+      std::nullopt,
+      std::nullopt,
+  });
+  auto actual = base->update({update});
+  ASSERT_EQ(actual->size(), expected->size());
+  for (int i = 0; i < actual->size(); ++i) {
+    ASSERT_TRUE(actual->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(VectorTest, mapUpdateRowKeyType) {
+  auto base = makeMapVector(
+      {0, 2},
+      makeRowVector({
+          makeFlatVector<int64_t>({1, 2}),
+          makeFlatVector<int64_t>({1, 2}),
+      }),
+      makeFlatVector<int64_t>({1, 1}));
+  auto update = makeMapVector(
+      {0, 2},
+      makeRowVector({
+          makeFlatVector<int64_t>({2, 3}),
+          makeFlatVector<int64_t>({2, 3}),
+      }),
+      makeFlatVector<int64_t>({2, 2}));
+  auto expected = makeMapVector(
+      {0, 3},
+      makeRowVector({
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatVector<int64_t>({1, 2, 3}),
+      }),
+      makeFlatVector<int64_t>({1, 2, 2}));
+  auto actual = base->update({update});
+  ASSERT_EQ(actual->size(), expected->size());
+  for (int i = 0; i < actual->size(); ++i) {
+    ASSERT_TRUE(actual->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(VectorTest, mapUpdateNullMapValue) {
+  auto base = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 1}, {2, 1}}},
+  });
+  auto update = makeNullableMapVector<int64_t, int64_t>({
+      {{{2, std::nullopt}, {3, 2}}},
+  });
+  auto expected = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 1}, {2, std::nullopt}, {3, 2}}},
+  });
+  auto actual = base->update({update});
+  ASSERT_EQ(actual->size(), expected->size());
+  for (int i = 0; i < actual->size(); ++i) {
+    ASSERT_TRUE(actual->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(VectorTest, mapUpdateMultipleUpdates) {
+  auto base = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 1}, {2, 1}}},
+      {{}},
+      {{{3, 1}}},
+      std::nullopt,
+      {{{4, 1}}},
+  });
+  std::vector<MapVectorPtr> updates = {
+      makeNullableMapVector<int64_t, int64_t>({
+          {{{2, 2}, {3, 2}}},
+          {{{4, 2}}},
+          {{}},
+          {{{5, 2}}},
+          std::nullopt,
+      }),
+      makeNullableMapVector<int64_t, int64_t>({
+          {{{3, 3}, {4, 3}}},
+          std::nullopt,
+          {{}},
+          {{}},
+          {{}},
+      }),
+  };
+  auto expected = makeNullableMapVector<int64_t, int64_t>({
+      {{{1, 1}, {2, 2}, {3, 3}, {4, 3}}},
+      std::nullopt,
+      {{{3, 1}}},
+      std::nullopt,
+      std::nullopt,
+  });
+  auto actual = base->update(updates);
+  ASSERT_EQ(actual->size(), expected->size());
+  for (int i = 0; i < actual->size(); ++i) {
+    ASSERT_TRUE(actual->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(VectorTest, pushDictionaryToRowVectorLeaves) {
+  auto iota = makeFlatVector<int64_t>(10, folly::identity);
+  auto output = RowVector::pushDictionaryToRowVectorLeaves(iota);
+  ASSERT_EQ(output, iota);
+
+  auto input = wrapInDictionary(makeIndicesInReverse(10), iota);
+  output = RowVector::pushDictionaryToRowVectorLeaves(input);
+  ASSERT_EQ(output, input);
+
+  {
+    SCOPED_TRACE("General");
+    input = wrapInDictionary(
+        makeIndicesInReverse(10),
+        makeRowVector({
+            // c0
+            iota,
+            // c1
+            makeRowVector({iota}),
+            // c2
+            BaseVector::wrapInDictionary(
+                makeNulls(10, nullEvery(3)),
+                makeIndicesInReverse(10),
+                10,
+                iota),
+            // c3
+            iota,
+            // c4
+            wrapInDictionary(
+                makeIndicesInReverse(10),
+                makeRowVector({
+                    iota,
+                    wrapInDictionary(makeIndicesInReverse(10), iota),
+                    iota,
+                })),
+            // c5
+            BaseVector::wrapInDictionary(
+                makeNulls(10, nullEvery(7)),
+                makeIndicesInReverse(10),
+                10,
+                makeRowVector({iota, iota})),
+        }));
+    output = RowVector::pushDictionaryToRowVectorLeaves(input);
+    test::assertEqualVectors(input, output);
+    ASSERT_EQ(output->encoding(), VectorEncoding::Simple::ROW);
+    auto* outputRow = output->asUnchecked<RowVector>();
+    auto& c0 = outputRow->childAt(0);
+    ASSERT_EQ(c0->encoding(), VectorEncoding::Simple::DICTIONARY);
+    ASSERT_EQ(c0->wrapInfo().get(), input->wrapInfo().get());
+    auto& c1 = outputRow->childAt(1);
+    ASSERT_EQ(c1->encoding(), VectorEncoding::Simple::ROW);
+    auto* c1Row = c1->asUnchecked<RowVector>();
+    auto& c1c0 = c1Row->childAt(0);
+    ASSERT_EQ(c1c0->encoding(), VectorEncoding::Simple::DICTIONARY);
+    ASSERT_EQ(c1c0->wrapInfo().get(), c0->wrapInfo().get());
+    auto& c2 = outputRow->childAt(2);
+    ASSERT_EQ(c2->encoding(), VectorEncoding::Simple::DICTIONARY);
+    auto& c3 = outputRow->childAt(3);
+    ASSERT_EQ(c3->encoding(), VectorEncoding::Simple::DICTIONARY);
+    ASSERT_EQ(c3->wrapInfo().get(), c0->wrapInfo().get());
+    auto& c4 = outputRow->childAt(4);
+    ASSERT_EQ(c4->encoding(), VectorEncoding::Simple::ROW);
+    auto* c4Row = c4->asUnchecked<RowVector>();
+    auto& c4c0 = c4Row->childAt(0);
+    ASSERT_EQ(c4c0->encoding(), VectorEncoding::Simple::DICTIONARY);
+    auto& c4c1 = c4Row->childAt(1);
+    ASSERT_EQ(c4c1->encoding(), VectorEncoding::Simple::DICTIONARY);
+    auto& c4c2 = c4Row->childAt(2);
+    ASSERT_EQ(c4c2->encoding(), VectorEncoding::Simple::DICTIONARY);
+    ASSERT_EQ(c4c0->wrapInfo().get(), c4c2->wrapInfo().get());
+    auto& c5 = outputRow->childAt(5);
+    ASSERT_EQ(c5->encoding(), VectorEncoding::Simple::DICTIONARY);
+    ASSERT_EQ(c5->valueVector()->encoding(), VectorEncoding::Simple::ROW);
+    auto* c5Row = c5->valueVector()->asUnchecked<RowVector>();
+    auto& c5c0 = c5Row->childAt(0);
+    ASSERT_EQ(c5c0->encoding(), VectorEncoding::Simple::FLAT);
+    auto& c5c1 = c5Row->childAt(1);
+    ASSERT_EQ(c5c1->encoding(), VectorEncoding::Simple::FLAT);
+  }
+}
+
+TEST_F(VectorTest, arrayCopyTargetNullOffsets) {
+  auto target = BaseVector::create(ARRAY(BIGINT()), 11, pool());
+  auto offsetsRef = target->asUnchecked<ArrayVector>()->offsets();
+  ASSERT_TRUE(offsetsRef);
+  BaseVector::prepareForReuse(target, target->size());
+  ASSERT_FALSE(target->asUnchecked<ArrayVector>()->offsets());
+  auto source = makeArrayVector<int64_t>(
+      11, [](auto) { return 1; }, [](auto i, auto) { return i; });
+  target->copy(source.get(), 0, 0, source->size());
+  test::assertEqualVectors(source, target);
+}
+
+TEST_F(VectorTest, testOverSizedArray) {
+  // Verify that flattening an array/map cannot result in a values vector
+  // greater than vector_size_t
+  auto flat = makeFlatVector<int32_t>(1000, [](auto /*row*/) { return 1; });
+  std::vector<vector_size_t> offsets(1, 0);
+  auto array = makeArrayVector(offsets, flat);
+  auto constArray = BaseVector::wrapInConstant(21474830, 0, array);
+  EXPECT_THROW(BaseVector::flattenVector(constArray), VeloxUserError);
+}
+
+TEST_F(VectorTest, hasOverlappingRanges) {
+  auto test = [this](
+                  vector_size_t length,
+                  const std::vector<bool>& nulls,
+                  const std::vector<vector_size_t>& offsets,
+                  const std::vector<vector_size_t>& sizes,
+                  bool overlap) {
+    auto makeArray = [&] {
+      return std::make_shared<ArrayVector>(
+          pool(),
+          ARRAY(BIGINT()),
+          makeNulls(nulls),
+          length,
+          makeIndices(length, [&](auto i) { return offsets[i]; }),
+          makeIndices(length, [&](auto i) { return sizes[i]; }),
+          makeNullConstant(
+              TypeKind::BIGINT, std::numeric_limits<vector_size_t>::max()));
+    };
+    if (!overlap) {
+      ASSERT_FALSE(makeArray()->hasOverlappingRanges());
+    } else {
+      ASSERT_TRUE(makeArray()->hasOverlappingRanges());
+    }
+  };
+  test(3, {false, false, false}, {0, 1, 2}, {1, 1, 1}, false);
+  test(3, {false, true, false}, {0, 0, 2}, {1, 1, 1}, false);
+  test(3, {false, false, false}, {0, 0, 2}, {1, 0, 1}, false);
+  test(3, {false, false, false}, {0, 0, 2}, {1, 1, 1}, true);
+  test(3, {false, false, false}, {2, 1, 0}, {1, 1, 1}, false);
+  test(3, {false, false, false}, {2, 1, 0}, {1, 2, 1}, true);
+  test(2, {false, false}, {0, 1}, {3, 1}, true);
+  test(2, {false, false}, {1, 0}, {1, 3}, true);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/vector/tests/VectorTestUtils.h b/velox/vector/tests/VectorTestUtils.h
index df594fa488e6b..be04bb3101062 100644
--- a/velox/vector/tests/VectorTestUtils.h
+++ b/velox/vector/tests/VectorTestUtils.h
@@ -83,7 +83,7 @@ class VectorGeneratedData {
 
   // In case T is StringView, the buffer below holds their actual data.
   std::shared_ptr<memory::MemoryPool> scopedPool =
-      memory::addDefaultLeafMemoryPool();
+      memory::memoryManager()->addLeafPool();
   StringViewBufferHolder stringViewBufferHolder_ =
       StringViewBufferHolder(scopedPool.get());
 };
@@ -212,8 +212,7 @@ void assertVector(
 
     if (isNull) {
       if (dbgPrintVec) {
-        LOG(INFO) << "[" << i << "]:"
-                  << "NULL";
+        LOG(INFO) << "[" << i << "]:" << "NULL";
       }
       EXPECT_EQ(isNull, actualIsNull);
     } else {
@@ -271,7 +270,7 @@ template <typename T>
 SimpleVectorPtr<T> createAndAssert(
     const ExpectedData<T>& expected,
     VectorEncoding::Simple encoding) {
-  auto pool = memory::addDefaultLeafMemoryPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   VectorMaker maker(pool.get());
 
   auto vector = maker.encodedVector(encoding, expected);
diff --git a/velox/vector/tests/VectorToStringTest.cpp b/velox/vector/tests/VectorToStringTest.cpp
index 4e702894a7ce9..ef230eef7b119 100644
--- a/velox/vector/tests/VectorToStringTest.cpp
+++ b/velox/vector/tests/VectorToStringTest.cpp
@@ -17,7 +17,12 @@
 
 namespace facebook::velox::test {
 
-class VectorToStringTest : public testing::Test, public VectorTestBase {};
+class VectorToStringTest : public testing::Test, public VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+};
 
 TEST_F(VectorToStringTest, flatIntegers) {
   // No nulls.
@@ -28,8 +33,8 @@ TEST_F(VectorToStringTest, flatIntegers) {
   ASSERT_EQ(flat->toString(3, 8, ", ", false), "4, 5, 6, 7, 8");
 
   // With nulls.
-  flat = makeFlatVector<int32_t>(
-      100, [](auto row) { return row; }, nullEvery(3));
+  flat =
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }, nullEvery(3));
   ASSERT_EQ(flat->toString(), "[FLAT INTEGER: 100 elements, 34 nulls]");
   ASSERT_EQ(flat->toString(true), "[FLAT INTEGER: 100 elements, 34 nulls]");
   ASSERT_EQ(flat->toString(1), "1");
@@ -114,7 +119,7 @@ TEST_F(VectorToStringTest, decimals) {
       "1: 35.610\n"
       "2: -314.159\n"
       "3: 0.007\n"
-      "4: 0");
+      "4: 0.000");
 
   auto longDecimalFlatVector =
       makeFlatVector<int128_t>({1000265, 35610, -314159, 7, 0}, DECIMAL(20, 4));
@@ -127,7 +132,7 @@ TEST_F(VectorToStringTest, decimals) {
       "1: 3.5610\n"
       "2: -31.4159\n"
       "3: 0.0007\n"
-      "4: 0");
+      "4: 0.0000");
 }
 
 TEST_F(VectorToStringTest, nullableDecimals) {
diff --git a/velox/vector/tests/VectorValueGenerator.h b/velox/vector/tests/VectorValueGenerator.h
index 0945cb70dc491..90bcc6b590f70 100644
--- a/velox/vector/tests/VectorValueGenerator.h
+++ b/velox/vector/tests/VectorValueGenerator.h
@@ -23,6 +23,7 @@
 
 #include "velox/buffer/StringViewBufferHolder.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/type/CppToType.h"
 #include "velox/type/DecimalUtil.h"
 #include "velox/type/StringView.h"
 #include "velox/type/Type.h"
diff --git a/velox/vector/tests/utils/CMakeLists.txt b/velox/vector/tests/utils/CMakeLists.txt
index 8b7d335db7abe..3898fd2626ffc 100644
--- a/velox/vector/tests/utils/CMakeLists.txt
+++ b/velox/vector/tests/utils/CMakeLists.txt
@@ -13,5 +13,5 @@
 # limitations under the License.
 add_library(velox_vector_test_lib VectorMaker.cpp VectorTestBase.cpp)
 
-target_link_libraries(velox_vector_test_lib velox_exec velox_vector gtest
-                      gtest_main)
+target_link_libraries(
+  velox_vector_test_lib velox_vector GTest::gtest GTest::gtest_main)
diff --git a/velox/vector/tests/utils/VectorMaker-inl.h b/velox/vector/tests/utils/VectorMaker-inl.h
index 1b1a223594265..ef813b0e736ab 100644
--- a/velox/vector/tests/utils/VectorMaker-inl.h
+++ b/velox/vector/tests/utils/VectorMaker-inl.h
@@ -17,7 +17,6 @@
 #include <algorithm>
 
 #include "velox/vector/SimpleVector.h"
-#include "velox/vector/tests/utils/VectorMakerStats.h"
 
 namespace facebook::velox::test {
 
@@ -39,7 +38,7 @@ BufferPtr buildBiasedBuffer(
 }
 
 template <typename T>
-BiasVectorPtr<VectorMaker::EvalType<T>> VectorMaker::biasVector(
+BiasVectorPtr<EvalType<T>> VectorMaker::biasVector(
     const std::vector<std::optional<T>>& data) {
   VELOX_CHECK_GT(data.size(), 1);
   using TEvalType = EvalType<T>;
@@ -125,7 +124,7 @@ void sequenceEncode(
 }
 
 template <typename T>
-SequenceVectorPtr<VectorMaker::EvalType<T>> VectorMaker::sequenceVector(
+SequenceVectorPtr<EvalType<T>> VectorMaker::sequenceVector(
     const std::vector<std::optional<T>>& data) {
   using TEvalType = EvalType<T>;
 
@@ -146,7 +145,7 @@ SequenceVectorPtr<VectorMaker::EvalType<T>> VectorMaker::sequenceVector(
 }
 
 template <typename T>
-ConstantVectorPtr<VectorMaker::EvalType<T>> VectorMaker::constantVector(
+ConstantVectorPtr<EvalType<T>> VectorMaker::constantVector(
     const std::vector<std::optional<T>>& data) {
   VELOX_CHECK_GT(data.size(), 0);
   using TEvalType = EvalType<T>;
@@ -169,7 +168,7 @@ ConstantVectorPtr<VectorMaker::EvalType<T>> VectorMaker::constantVector(
 }
 
 template <typename T>
-DictionaryVectorPtr<VectorMaker::EvalType<T>> VectorMaker::dictionaryVector(
+DictionaryVectorPtr<EvalType<T>> VectorMaker::dictionaryVector(
     const std::vector<std::optional<T>>& data) {
   using TEvalType = EvalType<T>;
 
@@ -219,7 +218,7 @@ DictionaryVectorPtr<VectorMaker::EvalType<T>> VectorMaker::dictionaryVector(
 }
 
 template <typename T>
-FlatVectorPtr<VectorMaker::EvalType<T>> VectorMaker::flatVectorNullable(
+FlatVectorPtr<EvalType<T>> VectorMaker::flatVectorNullable(
     const std::vector<std::optional<T>>& data,
     const TypePtr& type) {
   using TEvalType = EvalType<T>;
@@ -251,7 +250,7 @@ FlatVectorPtr<VectorMaker::EvalType<T>> VectorMaker::flatVectorNullable(
 }
 
 template <typename T>
-FlatVectorPtr<VectorMaker::EvalType<T>> VectorMaker::flatVector(
+FlatVectorPtr<EvalType<T>> VectorMaker::flatVector(
     const std::vector<T>& data,
     const TypePtr& type) {
   using TEvalType = EvalType<T>;
diff --git a/velox/vector/tests/utils/VectorMaker.cpp b/velox/vector/tests/utils/VectorMaker.cpp
index 7adf68c3584a8..c49d1ab222495 100644
--- a/velox/vector/tests/utils/VectorMaker.cpp
+++ b/velox/vector/tests/utils/VectorMaker.cpp
@@ -225,7 +225,7 @@ ArrayVectorPtr VectorMaker::arrayVector(
     auto rawNulls = nullsBuffer->asMutable<uint64_t>();
 
     for (int i = 0; i < nulls.size(); i++) {
-      VELOX_CHECK_EQ(rawSizes[nulls[i]], 0)
+      VELOX_CHECK_EQ(rawSizes[nulls[i]], 0);
       bits::setNull(rawNulls, nulls[i]);
     }
   }
@@ -266,7 +266,7 @@ MapVectorPtr VectorMaker::mapVector(
     auto rawNulls = nullsBuffer->asMutable<uint64_t>();
 
     for (int i = 0; i < nulls.size(); i++) {
-      VELOX_CHECK_EQ(rawSizes[nulls[i]], 0)
+      VELOX_CHECK_EQ(rawSizes[nulls[i]], 0);
       bits::setNull(rawNulls, nulls[i]);
     }
   }
diff --git a/velox/vector/tests/utils/VectorMaker.h b/velox/vector/tests/utils/VectorMaker.h
index 1f338e168e0d6..a047930dd035c 100644
--- a/velox/vector/tests/utils/VectorMaker.h
+++ b/velox/vector/tests/utils/VectorMaker.h
@@ -22,6 +22,7 @@
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/SequenceVector.h"
 #include "velox/vector/SimpleVector.h"
+#include "velox/vector/tests/utils/VectorMakerStats.h"
 
 namespace facebook::velox::test {
 
@@ -116,9 +117,6 @@ class VectorMaker {
       const std::shared_ptr<const RowType>& rowType,
       vector_size_t size);
 
-  template <typename T>
-  using EvalType = typename CppToType<T>::NativeType;
-
   template <typename T>
   FlatVectorPtr<EvalType<T>> flatVector(
       vector_size_t size,
@@ -369,16 +367,16 @@ class VectorMaker {
     auto numElements =
         createOffsetsAndSizes(size, sizeAt, isNullAt, &nulls, &offsets, &sizes);
 
-    auto flatVector =
-        BaseVector::create<FlatVector<T>>(type->childAt(0), numElements, pool_);
+    auto flatVector = BaseVector::create<FlatVector<EvalType<T>>>(
+        type->childAt(0), numElements, pool_);
     vector_size_t currentIndex = 0;
     for (vector_size_t i = 0; i < size; ++i) {
       if (isNullAt && isNullAt(i)) {
         continue;
       }
       for (vector_size_t j = 0; j < sizeAt(i); ++j) {
-        auto ret = valueAt(i, j);
-        flatVector->set(currentIndex, valueAt(i, j));
+        auto value = valueAt(i, j);
+        flatVector->set(currentIndex, EvalType<T>(value));
         currentIndex++;
       }
     }
@@ -590,21 +588,62 @@ class VectorMaker {
         arrays.push_back(std::nullopt);
         continue;
       }
-
       std::vector<std::optional<T>> elements;
-      for (const auto& element : arrayObject) {
-        if (element.isNull()) {
-          // Null element.
-          elements.push_back(std::nullopt);
+      appendElementsFromJsonArray(arrayObject, elements);
+      arrays.push_back(elements);
+    }
+    return arrayVectorNullable<T>(arrays, arrayType);
+  }
+
+  /// Creates an ArrayVector from a list of JSON arrays of arrays.
+  ///
+  /// JSON array of arrays can represent a null array, an empty array or array
+  /// with null elements.
+  ///
+  /// Examples:
+  /// [[1, 2], [2, 3, 4], [null, 7]]
+  /// [[1, 3, 7, 9], []]
+  /// [] - empty array of arrays
+  /// null - null array of arrays
+  /// [null] - array of null array
+  /// [[]]
+  ///
+  /// @tparam T Type of array elements.
+  /// @param jsonArrays A list of JSON arrays. JSON array cannot be an empty
+  /// string.
+  template <typename T>
+  ArrayVectorPtr nestedArrayVectorFromJson(
+      const std::vector<std::string>& jsonArrays,
+      const TypePtr& arrayType = ARRAY(CppToType<T>::create())) {
+    std::vector<std::optional<std::vector<std::optional<T>>>> baseVector;
+    std::vector<vector_size_t> offsets;
+    std::vector<vector_size_t> nulls;
+    const std::vector<std::optional<T>> empty;
+    int offset = 0;
+    for (auto i = 0; i < jsonArrays.size(); i++) {
+      const auto& jsonArray = jsonArrays.at(i);
+      VELOX_CHECK(!jsonArray.empty());
+      const folly::dynamic arraysObject = folly::parseJson(jsonArray);
+      offsets.push_back(offset);
+      if (arraysObject.isNull()) {
+        // Null array.
+        nulls.push_back(i);
+        continue;
+      }
+      for (const auto& nestedArray : arraysObject) {
+        if (nestedArray.isNull()) {
+          // Null nested array
+          baseVector.push_back(std::nullopt);
         } else {
-          elements.push_back(detail::jsonValue<T>(element));
+          std::vector<std::optional<T>> elements;
+          appendElementsFromJsonArray(nestedArray, elements);
+          baseVector.push_back(elements);
         }
       }
-
-      arrays.push_back(elements);
+      offset += arraysObject.size();
     }
-
-    return arrayVectorNullable<T>(arrays, arrayType);
+    auto baseArrayVector = arrayVectorNullable<T>(baseVector, arrayType);
+    return arrayVector(offsets, baseArrayVector, nulls);
   }
 
   ArrayVectorPtr allNullArrayVector(
@@ -758,9 +797,10 @@ class VectorMaker {
   ///  {} - empty map
   ///  null - null map
   ///
-  /// @tparam K Type of map keys. Must be an integer: int8_t, int16_t,
-  /// int32_t, int64_t.
-  /// @tparam V Type of map value. Can be an integer or a floating point number.
+  /// @tparam K Type of map keys. Must be a std::string or an integer: int8_t,
+  /// int16_t, int32_t, int64_t.
+  /// @tparam V Type of map value. Can be an integer or a floating point
+  /// number.
   /// @param jsonMaps A list of JSON maps. JSON map cannot be an empty
   /// string.
   template <typename K, typename V>
@@ -770,7 +810,9 @@ class VectorMaker {
           MAP(CppToType<K>::create(), CppToType<V>::create())) {
     static_assert(
         std::is_same_v<K, int8_t> || std::is_same_v<K, int16_t> ||
-        std::is_same_v<K, int32_t> || std::is_same_v<K, int64_t>);
+        std::is_same_v<K, int32_t> || std::is_same_v<K, int64_t> ||
+        std::is_same_v<K, float> || std::is_same_v<K, double> ||
+        std::is_same_v<K, std::string>);
 
     std::vector<std::optional<std::vector<std::pair<K, std::optional<V>>>>>
         maps;
@@ -779,6 +821,8 @@ class VectorMaker {
 
       folly::json::serialization_opts options;
       options.convert_int_keys = true;
+      options.allow_non_string_keys = true;
+      options.allow_nan_inf = true;
       folly::dynamic mapObject = folly::parseJson(jsonMap, options);
       if (mapObject.isNull()) {
         // Null map.
@@ -847,9 +891,9 @@ class VectorMaker {
     return flatVector;
   }
 
-  /// Create an ArrayVector from a vector of offsets and a base element vector.
-  /// The size of the arrays is computed from the difference of offsets.
-  /// An optional vector of nulls can be passed to specify null rows.
+  /// Create an ArrayVector from a vector of offsets and a base element
+  /// vector. The size of the arrays is computed from the difference of
+  /// offsets. An optional vector of nulls can be passed to specify null rows.
   /// The offset for a null value must match previous offset
   /// i.e size computed should be zero.
   /// E.g arrayVector({0, 2 ,2}, elements, {1}) creates an array vector
@@ -882,6 +926,19 @@ class VectorMaker {
       BufferPtr* offsets,
       BufferPtr* sizes);
 
+  template <typename T>
+  void appendElementsFromJsonArray(
+      const folly::dynamic& arrayObject,
+      std::vector<std::optional<T>>& elements) {
+    for (const auto& element : arrayObject) {
+      if (element.isNull()) {
+        elements.push_back(std::nullopt);
+      } else {
+        elements.push_back(detail::jsonValue<T>(element));
+      }
+    }
+  }
+
   memory::MemoryPool* pool_;
 };
 
diff --git a/velox/vector/tests/utils/VectorMakerStats.h b/velox/vector/tests/utils/VectorMakerStats.h
index 7815704e2344a..e76246dd64fed 100644
--- a/velox/vector/tests/utils/VectorMakerStats.h
+++ b/velox/vector/tests/utils/VectorMakerStats.h
@@ -19,9 +19,47 @@
 #include <optional>
 #include <unordered_set>
 
+#include "velox/type/Type.h"
 #include "velox/vector/SimpleVector.h"
 
 namespace facebook::velox::test {
+template <typename T>
+struct EvalTypeHelper {
+  using Type = typename CppToType<T>::NativeType;
+};
+
+template <typename T>
+struct EvalTypeHelper<std::optional<T>> {
+  using Type = typename EvalTypeHelper<T>::Type;
+};
+
+template <>
+struct EvalTypeHelper<uint8_t> {
+  using Type = uint8_t;
+};
+
+template <>
+struct EvalTypeHelper<uint16_t> {
+  using Type = uint16_t;
+};
+
+template <>
+struct EvalTypeHelper<uint32_t> {
+  using Type = uint32_t;
+};
+
+template <>
+struct EvalTypeHelper<uint64_t> {
+  using Type = uint64_t;
+};
+
+template <>
+struct EvalTypeHelper<uint128_t> {
+  using Type = uint128_t;
+};
+
+template <typename T>
+using EvalType = typename EvalTypeHelper<T>::Type;
 
 // Struct that caries metadata about a vector of nullable elements.
 template <typename T>
@@ -48,19 +86,40 @@ class VectorMakerStats {
   std::unordered_set<T> distinctSet_;
 };
 
+template <>
+class VectorMakerStats<UnknownValue> {
+ public:
+  void addElement(const UnknownValue& val) {
+    VELOX_UNREACHABLE();
+  }
+
+  size_t distinctCount() const {
+    return 1;
+  }
+
+  SimpleVectorStats<UnknownValue> asSimpleVectorStats() {
+    return {min, max};
+  }
+
+  std::optional<UnknownValue> min;
+  std::optional<UnknownValue> max;
+  size_t nullCount{0};
+  bool isSorted{false};
+};
+
 // Generates VectorMakerStats for a given vector of nullable elements.
 template <typename T>
-VectorMakerStats<typename CppToType<T>::NativeType> genVectorMakerStats(
+VectorMakerStats<EvalType<T>> genVectorMakerStats(
     const std::vector<std::optional<T>>& data) {
-  using NativeType = typename CppToType<T>::NativeType;
-  VectorMakerStats<NativeType> result;
+  using TEvalType = EvalType<T>;
+  VectorMakerStats<TEvalType> result;
 
   // Count distinct and null elements.
   for (const auto& val : data) {
     if (val == std::nullopt) {
       ++result.nullCount;
     } else {
-      result.addElement(static_cast<NativeType>(*val));
+      result.addElement(static_cast<TEvalType>(*val));
     }
   }
 
@@ -70,7 +129,7 @@ VectorMakerStats<typename CppToType<T>::NativeType> genVectorMakerStats(
   // Calculate min and max (skip null elements).
   for (const auto& val : data) {
     if (val != std::nullopt) {
-      auto nativeVal = static_cast<NativeType>(*val);
+      auto nativeVal = static_cast<TEvalType>(*val);
       result.min = (result.min == std::nullopt)
           ? nativeVal
           : std::min(*result.min, nativeVal);
@@ -84,21 +143,20 @@ VectorMakerStats<typename CppToType<T>::NativeType> genVectorMakerStats(
 
 // Generates VectorMakerStats for a given vector of non-nullable elements.
 template <typename T>
-VectorMakerStats<typename CppToType<T>::NativeType> genVectorMakerStats(
-    const std::vector<T>& data) {
-  using NativeType = typename CppToType<T>::NativeType;
-  VectorMakerStats<NativeType> result;
+VectorMakerStats<EvalType<T>> genVectorMakerStats(const std::vector<T>& data) {
+  using TEvalType = EvalType<T>;
+  VectorMakerStats<TEvalType> result;
   for (const auto& val : data) {
-    result.addElement(static_cast<NativeType>(val));
+    result.addElement(static_cast<TEvalType>(val));
   }
 
   result.isSorted = std::is_sorted(data.begin(), data.end());
   const auto& [min, max] = std::minmax_element(data.begin(), data.end());
   if (min != data.end()) {
-    result.min = static_cast<NativeType>(*min);
+    result.min = static_cast<TEvalType>(*min);
   }
   if (max != data.end()) {
-    result.max = static_cast<NativeType>(*max);
+    result.max = static_cast<TEvalType>(*max);
   }
   return result;
 }
diff --git a/velox/vector/tests/utils/VectorTestBase.cpp b/velox/vector/tests/utils/VectorTestBase.cpp
index e2312d28ae6be..d0a172f2023c7 100644
--- a/velox/vector/tests/utils/VectorTestBase.cpp
+++ b/velox/vector/tests/utils/VectorTestBase.cpp
@@ -110,15 +110,36 @@ BufferPtr VectorTestBase::makeNulls(const std::vector<bool>& values) {
   return nulls;
 }
 
-std::vector<RowVectorPtr> VectorTestBase::split(const RowVectorPtr& vector) {
+std::vector<RowVectorPtr> VectorTestBase::split(
+    const RowVectorPtr& vector,
+    int32_t n) {
   const auto numRows = vector->size();
-  VELOX_CHECK_GE(numRows, 2);
+  VELOX_CHECK_GE(numRows, n);
 
-  const auto n = numRows / 2;
-  return {
-      std::dynamic_pointer_cast<RowVector>(vector->slice(0, n)),
-      std::dynamic_pointer_cast<RowVector>(vector->slice(n, numRows - n)),
-  };
+  const auto numRowsPerVector = numRows / n;
+  std::vector<RowVectorPtr> vectors;
+
+  vector_size_t offset = 0;
+  for (auto i = 0; i < n - 1; ++i) {
+    vectors.push_back(std::dynamic_pointer_cast<RowVector>(
+        vector->slice(offset, numRowsPerVector)));
+    offset += numRowsPerVector;
+  }
+
+  vectors.push_back(std::dynamic_pointer_cast<RowVector>(
+      vector->slice(offset, numRows - offset)));
+  return vectors;
+}
+
+VectorPtr VectorTestBase::asArray(VectorPtr elements) {
+  auto* pool = elements->pool();
+  auto arrayType = ARRAY(elements->type());
+
+  BufferPtr sizes =
+      AlignedBuffer::allocate<vector_size_t>(1, pool, elements->size());
+  BufferPtr offsets = allocateOffsets(1, pool);
+  return std::make_shared<ArrayVector>(
+      pool, arrayType, nullptr, 1, offsets, sizes, std::move(elements));
 }
 
 void assertEqualVectors(const VectorPtr& expected, const VectorPtr& actual) {
diff --git a/velox/vector/tests/utils/VectorTestBase.h b/velox/vector/tests/utils/VectorTestBase.h
index 457bdbd284022..b0a363527d9ca 100644
--- a/velox/vector/tests/utils/VectorTestBase.h
+++ b/velox/vector/tests/utils/VectorTestBase.h
@@ -18,10 +18,14 @@
 #include <folly/Executor.h>
 #include <folly/executors/CPUThreadPoolExecutor.h>
 
+#include "velox/common/base/RuntimeMetrics.h"
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
 
 #include <gtest/gtest.h>
+#include <optional>
+#include "velox/type/CppToType.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
 
 namespace facebook::velox::test {
 
@@ -52,9 +56,6 @@ class VectorTestBase {
 
   ~VectorTestBase();
 
-  template <typename T>
-  using EvalType = typename CppToType<T>::NativeType;
-
   static std::shared_ptr<const RowType> makeRowType(
       std::vector<std::shared_ptr<const Type>>&& types) {
     return velox::test::VectorMaker::rowType(
@@ -130,28 +131,54 @@ class VectorTestBase {
     return vectorMaker_.rowVector(rowType, size);
   }
 
-  /// Splits input vector into 2. First half of rows goes to first vector, the
-  /// rest to the second vector. Input vector must have at least 2 rows.
-  /// @return 2 vectors
-  std::vector<RowVectorPtr> split(const RowVectorPtr& vector);
+  RowVectorPtr makeRowVector(
+      const RowTypePtr& type,
+      const VectorFuzzer::Options& fuzzerOpts) {
+    VectorFuzzer fuzzer(fuzzerOpts, pool());
+    return fuzzer.fuzzRow(type);
+  }
+
+  std::vector<RowVectorPtr> createVectors(
+      const RowTypePtr& type,
+      uint64_t byteSize,
+      const VectorFuzzer::Options& fuzzerOpts) {
+    VectorFuzzer fuzzer(fuzzerOpts, pool());
+    uint64_t totalSize{0};
+    std::vector<RowVectorPtr> vectors;
+    while (totalSize < byteSize) {
+      vectors.push_back(fuzzer.fuzzInputRow(type));
+      totalSize += vectors.back()->estimateFlatSize();
+    }
+    return vectors;
+  }
 
-  // Returns a one element ArrayVector with 'vector' as elements of array at 0.
-  VectorPtr asArray(VectorPtr vector) {
-    BufferPtr sizes = AlignedBuffer::allocate<vector_size_t>(
-        1, vector->pool(), vector->size());
-    BufferPtr offsets =
-        AlignedBuffer::allocate<vector_size_t>(1, vector->pool(), 0);
-    return std::make_shared<ArrayVector>(
-        vector->pool(),
-        ARRAY(vector->type()),
-        BufferPtr(nullptr),
-        1,
-        offsets,
-        sizes,
-        vector,
-        0);
+  std::vector<RowVectorPtr>
+  createVectors(const RowTypePtr& type, size_t vectorSize, uint64_t byteSize) {
+    return createVectors(type, byteSize, {.vectorSize = vectorSize});
   }
 
+  std::vector<RowVectorPtr> createVectors(
+      uint32_t numVectors,
+      const RowTypePtr& type,
+      const VectorFuzzer::Options& fuzzerOpts = {}) {
+    VectorFuzzer fuzzer(fuzzerOpts, pool());
+    std::vector<RowVectorPtr> vectors;
+    vectors.reserve(numVectors);
+    for (int i = 0; i < numVectors; ++i) {
+      vectors.emplace_back(fuzzer.fuzzRow(type));
+    }
+    return vectors;
+  }
+
+  /// Splits input vector into 'n' vectors evenly. Input vector must have at
+  /// least 'n' rows.
+  /// @return 'n' vectors
+  std::vector<RowVectorPtr> split(const RowVectorPtr& vector, int32_t n = 2);
+
+  /// Returns a one element ArrayVector with 'elements' as elements of array at
+  /// 0.
+  VectorPtr asArray(VectorPtr elements);
+
   template <typename T>
   FlatVectorPtr<EvalType<T>> makeFlatVector(
       vector_size_t size,
@@ -282,7 +309,7 @@ class VectorTestBase {
       if (!vector.has_value()) {
         bits::setNull(rawNulls, i, true);
         rawSizes[i] = 0;
-        rawOffsets[i] = 0;
+        rawOffsets[i] = (i == 0) ? 0 : rawOffsets[i - 1] + rawSizes[i - 1];
       } else {
         flattenedData.insert(
             flattenedData.end(), vector->begin(), vector->end());
@@ -474,6 +501,20 @@ class VectorTestBase {
         size, sizeAt, valueAt, isNullAt, valueIsNullAt, arrayType);
   }
 
+  /// Similar to makeArrayVectorFromJson. Creates an ArrayVector from list of
+  /// JSON arrays of arrays.
+  /// @tparam T Type of array elements. Must be an integer: int8_t, int16_t,
+  /// int32_t, int64_t.
+  /// @param jsonArrays A list of JSON arrays. JSON array cannot be an empty
+  /// string.
+  /// @param arrayType type of array elements.
+  template <typename T>
+  ArrayVectorPtr makeNestedArrayVectorFromJson(
+      const std::vector<std::string>& jsonArrays,
+      const TypePtr& arrayType = ARRAY(CppToType<T>::create())) {
+    return vectorMaker_.nestedArrayVectorFromJson<T>(jsonArrays, arrayType);
+  }
+
   template <typename T>
   ArrayVectorPtr makeArrayVector(
       vector_size_t size,
@@ -724,13 +765,72 @@ class VectorTestBase {
     return pool_.get();
   }
 
+  // Create LazyVector that produces a flat vector and asserts that is is being
+  // loaded for a specific set of rows.
+  template <typename T>
+  std::shared_ptr<LazyVector> makeLazyFlatVector(
+      vector_size_t size,
+      std::function<T(vector_size_t /*row*/)> valueAt,
+      std::function<bool(vector_size_t /*row*/)> isNullAt =
+          [](vector_size_t row) { return false; },
+      std::optional<vector_size_t> expectedSize = std::nullopt,
+      const std::optional<
+          std::function<vector_size_t(vector_size_t /*index*/)>>&
+          expectedRowAt = std::nullopt) {
+    return std::make_shared<LazyVector>(
+        pool(),
+        CppToType<T>::create(),
+        size,
+        std::make_unique<SimpleVectorLoader>([=](RowSet rows) {
+          if (expectedSize.has_value()) {
+            VELOX_CHECK_EQ(rows.size(), *expectedSize);
+          }
+          if (expectedRowAt.has_value()) {
+            for (auto i = 0; i < rows.size(); i++) {
+              VELOX_CHECK_EQ(rows[i], (*expectedRowAt)(i));
+            }
+          }
+          return makeFlatVector<T>(size, valueAt, isNullAt);
+        }));
+  }
+
+  VectorPtr wrapInLazyDictionary(VectorPtr vector) {
+    return std::make_shared<LazyVector>(
+        pool(),
+        vector->type(),
+        vector->size(),
+        std::make_unique<SimpleVectorLoader>([=](RowSet /*rows*/) {
+          auto indices =
+              makeIndices(vector->size(), [](auto row) { return row; });
+          return wrapInDictionary(indices, vector->size(), vector);
+        }));
+  }
+
   std::shared_ptr<memory::MemoryPool> rootPool_{
-      memory::defaultMemoryManager().addRootPool()};
+      memory::memoryManager()->addRootPool()};
   std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild("leaf")};
   velox::test::VectorMaker vectorMaker_{pool_.get()};
   std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
           std::thread::hardware_concurrency())};
+  std::shared_ptr<folly::Executor> spillExecutor_{
+      std::make_shared<folly::CPUThreadPoolExecutor>(
+          std::thread::hardware_concurrency())};
+};
+
+class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
+ public:
+  void addRuntimeStat(const std::string& name, const RuntimeCounter& value)
+      override {
+    stats_.emplace_back(name, value);
+  }
+
+  const std::vector<std::pair<std::string, RuntimeCounter>>& stats() const {
+    return stats_;
+  }
+
+ private:
+  std::vector<std::pair<std::string, RuntimeCounter>> stats_;
 };
 
 } // namespace facebook::velox::test
diff --git a/website/README.md b/website/README.md
index aaba2fa1e16ee..9ebdfccf492c6 100644
--- a/website/README.md
+++ b/website/README.md
@@ -26,16 +26,9 @@ This command generates static content into the `build` directory and can be serv
 
 ### Deployment
 
-Using SSH:
-
-```
-$ USE_SSH=true yarn deploy
-```
-
-Not using SSH:
-
-```
-$ GIT_USER=<Your GitHub username> yarn deploy
-```
-
-If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.
+Velox's website is automatically deployed using
+[Netlify](https://www.netlify.com/). Whenever a pull request changing one of
+the files under *velox/website* is submitted, a live preview link is generated
+by Netlify. The link is posted in the pull request as a comment by the Netlify
+bot. When the pull request is merged, the changes are automatically deployed to
+the website by Netlify. 
diff --git a/website/blog/2024-01-27-like-optimization.mdx b/website/blog/2024-01-27-like-optimization.mdx
new file mode 100644
index 0000000000000..57ba15f647c74
--- /dev/null
+++ b/website/blog/2024-01-27-like-optimization.mdx
@@ -0,0 +1,147 @@
+---
+slug: like
+title: "Improve LIKE's performance"
+authors: [xumingming]
+tags: [tech-blog,performance]
+---
+
+## What is LIKE?
+
+<a href="https://prestodb.io/docs/current/functions/comparison.html#like">LIKE</a> is a very useful SQL operator.
+It is used to do string pattern matching. The following examples for LIKE usage are from the Presto doc:
+
+```
+SELECT * FROM (VALUES ('abc'), ('bcd'), ('cde')) AS t (name)
+WHERE name LIKE '%b%'
+--returns 'abc' and  'bcd'
+
+SELECT * FROM (VALUES ('abc'), ('bcd'), ('cde')) AS t (name)
+WHERE name LIKE '_b%'
+--returns 'abc'
+
+SELECT * FROM (VALUES ('a_c'), ('_cd'), ('cde')) AS t (name)
+WHERE name LIKE '%#_%' ESCAPE '#'
+--returns 'a_c' and  '_cd'
+```
+
+These examples show the basic usage of LIKE:
+
+- Use `%` to match zero or more characters.
+- Use `_` to match exactly one character.
+- If we need to match `%` and `_` literally, we can specify an escape char to escape them.
+
+When we use Velox as the backend to evaluate Presto's query, LIKE operation is translated
+into Velox's function call, e.g. `name LIKE '%b%'` is translated to
+`like(name, '%b%')`. Internally Velox converts the pattern string into a regular
+expression and then uses regular expression library <a href="https://github.com/google/re2">RE2</a>
+to do the pattern matching. RE2 is a very good regular expression library. It is fast
+and safe, which gives Velox LIKE function a good performance. But some popularly used simple patterns
+can be optimized using direct simple C++ string functions instead of regex.
+e.g. Pattern `hello%` matches inputs that start with `hello`, which can be implemented by direct memory
+comparison of prefix ('hello' in this case) bytes of input:
+
+```
+// Match the first 'length' characters of string 'input' and prefix pattern.
+bool matchPrefixPattern(
+    StringView input,
+    const std::string& pattern,
+    size_t length) {
+  return input.size() >= length &&
+      std::memcmp(input.data(), pattern.data(), length) == 0;
+}
+```
+
+It is much faster than using RE2. Benchmark shows it gives us a 750x speedup. We can do similar
+optimizations for some other patterns:
+
+- `%hello`: matches inputs that end with `hello`. It can be optimized by direct memory comparison of suffix bytes of the inputs.
+- `%hello%`: matches inputs that contain `hello`. It can be optimized by using `std::string_view::find` to check whether inputs contain `hello`.
+
+These simple patterns are straightforward to optimize. There are some more relaxed patterns that
+are not so straightforward:
+
+- `hello_velox%`: matches inputs that start with 'hello', followed by any character, then followed by 'velox'.
+- `%hello_velox`: matches inputs that end with 'hello', followed by any character, then followed by 'velox'.
+- `%hello_velox%`: matches inputs that contain both 'hello' and 'velox', and there is a single character separating them.
+
+Although these patterns look similar to previous ones, but they are not so straightforward
+to optimize, `_` here matches any single character, we can not simply use memory comparison to
+do the matching. And if user's input is not pure ASCII, `_` might match more than one byte which
+makes the implementation even more complex. Also note that the above patterns are just for
+illustrative purpose. Actual patterns can be more complex. e.g. `h_e_l_l_o`, so trivial algorithm
+will not work.
+
+## Optimizing Relaxed Patterns
+
+We optimized these patterns as follows. First, we split the patterns into a list of sub patterns, e.g.
+`hello_velox%` is split into sub-patterns: `hello`, `_`, `velox`, `%`, because there is
+a `%` at the end, we determine it as a `kRelaxedPrefix` pattern, which means we need to do some prefix
+matching, but it is not a trivial prefix matching, we need to match three sub-patterns:
+
+- kLiteralString: hello
+- kSingleCharWildcard: _
+- kLiteralString: velox
+
+For `kLiteralString` we simply do a memory comparison:
+
+```
+if (subPattern.kind == SubPatternKind::kLiteralString &&
+    std::memcmp(
+        input.data() + start + subPattern.start,
+        patternMetadata.fixedPattern().data() + subPattern.start,
+        subPattern.length) != 0) {
+  return false;
+}
+```
+
+Note that since it is a memory comparison, it handles both pure ASCII inputs and inputs that
+contain Unicode characters.
+
+Matching `_` is more complex considering that there are variable length multi-bytes character in
+unicode inputs. Fortunately there are existing libraries which provides unicode related operations: <a href="https://juliastrings.github.io/utf8proc/">utf8proc</a>.
+It provides functions that tells us whether a byte in input is the start of a character or not,
+how many bytes current character consists of etc. So to match a sequence of `_` our algorithm is:
+
+```
+if (subPattern.kind == SubPatternKind::kSingleCharWildcard) {
+  // Match every single char wildcard.
+  for (auto i = 0; i < subPattern.length; i++) {
+    if (cursor >= input.size()) {
+      return false;
+    }
+
+    auto numBytes = unicodeCharLength(input.data() + cursor);
+    cursor += numBytes;
+  }
+}
+```
+
+Here:
+
+- `cursor` is the index in the input we are trying to match.
+- `unicodeCharLength` is a function which wraps utf8proc function to determine how many bytes current character consists of.
+
+So the logic is basically repeatedly calculate size of current character and skip it.
+
+It seems not that complex, but we should note that this logic is not effective for pure ASCII input.
+Every character is one byte in pure ASCII input. So to match a sequence of `_`, we don't need to calculate the size
+of each character and compare in a for-loop. In fact, we don't need to explicitly match `_` for pure ASCII input as well.
+We can use the following logic instead:
+```
+for (const auto& subPattern : patternMetadata.subPatterns()) {
+    if (subPattern.kind == SubPatternKind::kLiteralString &&
+        std::memcmp(
+            input.data() + start + subPattern.start,
+            patternMetadata.fixedPattern().data() + subPattern.start,
+            subPattern.length) != 0) {
+      return false;
+    }
+}
+```
+
+It only matches the kLiteralString pattern at the right position of the inputs, `_` is automatically
+matched(actually skipped). No need to match it explicitly. With this optimization we get 40x speedup
+for kRelaxedPrefix patterns, 100x speedup for kRelaxedSuffix patterns.
+
+Thank you <a href="https://github.com/mbasmanova">Maria Basmanova</a> for spending a lot of time
+reviewing the code.
diff --git a/website/blog/2024-05-31-optimize-try-more.mdx b/website/blog/2024-05-31-optimize-try-more.mdx
new file mode 100644
index 0000000000000..dc4b6edc5ce37
--- /dev/null
+++ b/website/blog/2024-05-31-optimize-try-more.mdx
@@ -0,0 +1,355 @@
+---
+slug: optimize-try-more
+title: Further Optimizing TRY_CAST and TRY
+authors: [mbasmanova]
+tags: [tech-blog,expressions]
+---
+
+## TL;DR
+
+Queries that use TRY or TRY_CAST may experience poor performance and high CPU
+usage due to excessive exception throwing. We optimized CAST to indicate
+failure without throwing and introduced a mechanism for scalar functions to do
+the same. Microbenchmark measuring worst case performance of CAST improved
+100x. Samples of production queries show 30x cpu time improvement.
+
+## TRY and TRY(CAST)
+
+TRY construct can be applied to any expression to suppress errors and turn them
+into NULL results. TRY_CAST is a version of CAST that suppresses errors and
+returns NULL instead.
+
+For example, `parse_datetime('2024-05-', 'YYYY-MM-DD')` fails:
+
+```
+	 Invalid format: "2024-05-" is too short
+```
+
+, but `TRY(parse_datetime('2024-05-', 'YYYY-MM-DD'))` succeeds and returns NULL.
+
+Similarly, `CAST('foo' AS INTEGER)` fails:
+
+```
+	Cannot cast 'foo' to INT
+```
+
+, but `TRY_CAST('foo' AS INTEGER)` succeeds and returns NULL.
+
+## TRY_CAST vs. TRY(CAST)
+
+TRY can wrap any expression, so one can wrap CAST as well:
+
+```
+  TRY(CAST('foo' AS INTEGER))
+```
+
+Wrapping CAST in TRY is similar to TRY_CAST, but not equivalent. TRY_CAST
+suppresses only cast errors, while TRY suppresses any error in the expression
+tree.
+
+For example, `CAST(1/0 AS VARCHAR)` fails:
+
+```
+  Division by zero
+```
+
+, `TRY_CAST(1/0 AS VARCHAR)` also fails:
+
+```
+  Division by zero
+```
+
+, but `TRY(CAST(1/0 AS VARCHAR))` succeeds and returns NULL.
+
+In this case, the error is generated by division operation (1/0). TRY_CAST
+cannot suppress that error, but TRY can. More generally, TRY(CAST(...))
+suppresses all errors in all expressions that are evaluated to produce
+an input for CAST as well as errors in CAST itself, but TRY_CAST suppresses
+errors in CAST only.
+
+## What happens when many rows fail?
+
+In most cases only a fraction of rows generates an error. However, there are
+queries where a large percentage of rows fail. In these cases, a lot of CPU
+time goes into handling exceptions.
+
+For example, one Prestissimo query used 3 weeks of CPU time, 93% of
+which was spent processing try(date_parse(...)) expressions where most rows
+failed. Here is a profile for that query that shows that all the time went into
+stack unwinding:
+
+<figure>
+ <img src="/img/optimize-try-more-profile1.png"/>
+</figure>
+
+This query processes 14B rows, ~70% of which fail in date_parse(...) function
+due to the date string being empty.
+
+```
+    presto> select try(date_parse('', '%Y-%m-%d'));
+     _col0
+    -------
+     NULL
+    (1 row)
+
+
+    – TRY suppressed Invalid format: "" error and produced a NULL.
+```
+
+Velox tracks the number of suppressed exceptions per operator / plan node and
+reports these as numSilentThrow runtime stat. For this query, Velox reported
+21B throws for a single FilterProject node that processed 14B rows. Before the
+optimizations, each failing row used to throw twice. An <a href="https://velox-lib.io/blog/optimize-try_cast.">earlier blog post</a>
+from <a href="https://www.linkedin.com/in/laith-sakka-629ab384/">Laith Sakka</a> explains why.
+After the optimizations this query’s CPU time dropped
+to 17h: 30x difference from the original cpu time. Compared to
+Presto Java, this query uses 4x less cpu time (originally it used 6x more).
+
+<figure>
+ <img src="/img/optimize-try-more-numSilentThrow.png"/>
+</figure>
+
+We observed similar issues with queries that use other functions that parse
+strings as well as casts from strings.
+
+## Solution
+
+To avoid the performance penalty of throwing exceptions we need to report errors
+differently. Google’s <a href="https://abseil.io/docs/cpp/guides/status">Abseil</a> library uses absl::Status to return errors from
+void functions and absl::StatusOr to return value or error from non-void
+functions. <a href="https://arrow.apache.org/cookbook/cpp/basic.html#id8">Arrow</a> library
+has similar Status and Result. Our own Folly has <a href="https://github.com/facebook/folly/blob/main/folly/Expected.h">folly::Expected</a>.
+Inspired by these examples we introduced <a href="https://github.com/facebookincubator/velox/pull/8084">velox::Status</a> and <a href="https://github.com/facebookincubator/velox/pull/9858">velox::Expected</a>.
+
+velox::Status holds a generic error code and an error message.
+
+`velox::Expected<T>` is a typedef for `folly::Expected<T, velox::Status>`.
+
+For example, a non-throwing modulo operation can be implemented like this:
+
+```
+  Expected<int> mod(int a, int b) {
+    if (b == 0) {
+      return folly::makeUnexpected(Status::UserError(“Division by zero”));
+    }
+
+    return a % b;
+  }
+```
+
+## Non-throwing Simple Functions
+
+We extended the Simple Function API to allow authoring non-throwing scalar
+functions. The function author can now define a ‘call’ method that returns
+Status. Such a function can indicate an error by returning a non-OK status.
+
+```
+  Status call(result&, arg1, arg2,..)
+```
+
+These functions are still allowed to throw and exceptions will be handled
+properly, but not throwing improves performance of expressions that use TRY.
+
+Modulo SQL function would look like this:
+
+```
+    template <typename TExec>
+    struct NoThrowModFunction {
+      VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+      Status call(int64_t& result, const int64_t& a, const int64_t& b) {
+        if (b == 0) {
+          return Status::UserError("Division by zero");
+        }
+
+        result = a % b;
+        return Status::OK();
+      }
+    };
+```
+
+We changed date_parse, parse_datetime, and from_iso8601_date Presto functions
+to use the new API and report errors without throwing.
+
+## Non-throwing Vector functions
+
+Vector functions can implement non-throwing behavior by leveraging the new
+EvalCtx::setStatus(row, status) API. However, nowadays we expect virtually all
+functions to be written using Simple Function API.
+
+## Non-throwing CAST
+
+CAST is complex. A single name refers to multiple dozen individual operations.
+The full matrix of <a href="https://facebookincubator.github.io/velox/functions/presto/conversion.html#supported-conversions">supported conversions</a> is available in the Velox
+documentation. Not all casts throw. For example, cast from an integer to a
+string does not throw. However, casts from strings may fail in multiple ways. A
+common failure scenario is cast from an empty string. Laith Sakka optimized
+this use case earlier.
+
+```
+> select cast('' as integer);
+Cannot cast '' to INT
+```
+
+However, we are also seeing failures in casting non-empty strings and NaN floating point values to integers.
+
+```
+> select cast(nan() as bigint);
+Unable to cast NaN to bigint
+
+> select cast('123x' as integer);
+Cannot cast '123x' to INT
+```
+
+CAST from string to integer and floating point value is implemented using
+`folly::to` template. Luckily there is a non-throwing version: `folly::tryTo`.
+We changed our CAST implementation to use `folly::tryTo` to avoid throwing.
+Not throwing helped improve performance of TRY_CAST by 20x.
+
+Still, the profile showed that there is room for further improvement.
+
+## Do not produce or store error messages under TRY
+
+After switching to non-throwing implementation, the profile showed that half the
+cpu time went into folly::makeConversionError. folly::tryTo returns result or
+ConversionCode enum. CAST uses folly::makeConversionError to convert
+ConversionCode into a user-friendly error message. This involves allocating and
+populating a string for the error message, copying it into the std::range_error
+object, then copying it again into Status. This error message is very helpful
+if it is being propagated all the way to the user, but it is not needed if the
+error is suppressed via TRY or TRY_CAST.
+
+<figure>
+ <img src="/img/optimize-try-more-profile2.png"/>
+</figure>
+
+To solve this problem we introduced a thread-local flag, threadSkipErrorDetails,
+that indicates whether Status needs to include a detailed error message or not.
+By default, this flag is ‘false’, but TRY and TRY_CAST set it to ‘true’. CAST
+logic checks this flag to decide whether to call folly::makeConversionError or
+not. This change gives a 3x performance boost to TRY_CAST and 2x
+to TRY.
+
+
+```
+    if (threadSkipErrorDetails()) {
+      return folly::makeUnexpected(Status::UserError());
+    }
+
+    return folly::makeUnexpected(Status::UserError(
+        "{}", folly::makeConversionError(result.error(), "").what()));
+```
+
+
+After this optimization, we observed that TRY(CAST(...)) is up to 5x slower than
+TRY_CAST when many rows fail.
+
+The profile revealed that 30% of cpu time went to
+EvalCtx::ensureErrorsVectorSize. For every row that fails, we call
+EvalCtx::ensureErrorsVectorSize to resize the error vector to accommodate that
+row. When many rows fail we end up resizing a lot: resize(1), resize(2),
+resize(3),...resize(n). We fixed this by pre-allocating the error vector in the TRY
+expression.
+
+Another 30% of cpu time went into managing reference counts for
+`std::shared_ptr<std::exception_ptr>` stored in the errors vector. We do not need
+error details for TRY, hence, no need to store these values. We fixed this by
+making error values in error vector optional and updating EvalCtx::setStatus to
+skip writing these under TRY.
+
+<figure>
+ <img src="/img/optimize-try-more-profile3.png"/>
+</figure>
+
+After all these optimizations, the microbenchmark that measures performance of
+casting invalid strings into integers showed 100x improvement. The benchmark
+evaluates 4 expressions:
+
+* TRY_CAST(‘’ AS INTEGER)
+* TRY(CAST(‘’ AS INTEGER))
+* TRY_CAST(‘$’ AS INTEGER)
+* TRY(CAST(‘$’ AS INTEGER))
+
+When we started, the benchmark results were:
+
+```
+===============================================================
+[...]hmarks/ExpressionBenchmarkBuilder.cpp     relative  time/iter   iters/s
+================================================================
+cast##try_cast_invalid_empty_input                          2.40ms    417.47
+cast##tryexpr_cast_invalid_empty_input                    402.63ms      2.48
+cast##try_cast_invalid_nan                                392.14ms      2.55
+cast##tryexpr_cast_invalid_nan                            827.09ms      1.21
+```
+
+At the end the numbers improved 100x:
+
+```
+cast##try_cast_invalid_empty_input                          2.16ms    463.62
+cast##tryexpr_cast_invalid_empty_input                      4.29ms    232.95
+cast##try_cast_invalid_nan                                  5.47ms    182.83
+cast##tryexpr_cast_invalid_nan                              7.76ms    128.81
+```
+
+Note: The performance of TRY_CAST(‘’ AS INTEGER) hasn’t changed because this
+particular use case has been optimized by Laith Sakka earlier.
+
+## Next steps
+
+We can identify queries with a high percentage of numSilentThrow rows and
+change throwing functions to not throw.
+
+For simple functions this involves changing the ‘call’ method to return Status
+and replacing ‘throw’ statements with return Status::UserError(...). You get
+extra points for producing error messages conditionally based on thread-local
+flag threadSkipErrorDetails().
+
+```
+template <typename TExec>
+struct NoThrowModFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  Status call(int64_t& result, const int64_t& a, const int64_t& b) {
+    if (b == 0) {
+      If (threadSkipErrorDetails()) {
+          return Status::UserError();
+      }
+      return Status::UserError("Division by zero");
+    }
+
+    result = a % b;
+    return Status::OK();
+  }
+};
+```
+
+We are changing CAST(varchar AS date) to not throw.
+
+We provided a non-throwing ‘call’ API for simple functions that never return a
+NULL for a non-NULL input. This covers the majority of Presto functions. For
+completeness, we would want to provide non-throwing ‘call’ APIs for all other
+use cases:
+
+- bool call() for returning NULL sometimes
+- callAscii for processing all-ASCII inputs
+- callNullable for processing possibly NULL inputs
+- callNullFree for processing complex inputs with all NULLs removed.
+
+## Acknowledgements
+
+Thank you <a href="https://www.linkedin.com/in/laith-sakka-629ab384/">Laith Sakka</a>
+for doing the initial work to investigate and optimize TRY_CAST for empty strings
+and sharing your findings in a blog post.
+
+Thank you <a href="https://www.linkedin.com/in/orrierling">Orri Erling</a> for
+adding numSilentThrow runtime stat to report number of suppressed exceptions.
+
+Thank you <a href="https://www.linkedin.com/in/pedro-pedreira/">Pedro Eugenio Rocha Pedreira</a>
+for introducing the velox::Status class.
+
+Thank you <a href="https://www.linkedin.com/in/bikramjeet-vig/">Bikramjeet Vig</a>,
+<a href="https://www.linkedin.com/in/gongchuo-lu-23bb251b/">Jimmy Lu</a>,
+<a href="https://www.linkedin.com/in/orrierling">Orri Erling</a>,
+<a href="https://www.linkedin.com/in/pedro-pedreira/">Pedro Eugenio Rocha Pedreira</a> and
+<a href="https://www.linkedin.com/in/xiaoxuanmeng">Xiaoxuan Meng</a> for brainstorming and
+helping with code reviews.
\ No newline at end of file
diff --git a/website/blog/2024-08-23-ci-migration.mdx b/website/blog/2024-08-23-ci-migration.mdx
new file mode 100644
index 0000000000000..398c17279b607
--- /dev/null
+++ b/website/blog/2024-08-23-ci-migration.mdx
@@ -0,0 +1,78 @@
+---
+slug: ci-migration
+title: "Optimizing and Migrating Velox CI Workloads to Github Actions"
+authors: [jwujciak, kgpai]
+tags: [tech-blog, packaging]
+---
+
+<figure>
+ <img src="/img/abstract-white-background.jpg" height= "100%" width="100%"/>
+</figure>
+
+## TL;DR
+
+In late 2023, the Meta OSS (Open Source Software) Team requested all Meta teams to move the CI deployments from CircleCI to Github Actions. [Voltron Data](http://voltrondata.com) and Meta in collaboration migrated all the deployed Velox CI jobs. For the year 2024, Velox CI spend was on track to overshoot the allocated resources by a considerable amount of money. As part of this migration effort, the CI workloads were consolidated and optimized by Q2 2024, bringing down the projected 2024 CI spend by 51%.
+
+## Velox’s Continuous Integration Workload
+
+Continuous Integration (CI) is crucial for Velox’s success as an open source project as it helps protect from bugs and errors, reduces likelihood of conflicts and leads to increased community trust in the project. This is to ensure the Velox builds works well on a myriad of system architectures, operating systems and compilers - along with the ones used internally at Meta. The OSS build version of Velox also supports additional features that aren't used internally in Meta (for example, support for Cloud blob stores, etc.).
+
+When a pull request is submitted to Velox, the following jobs are executed:
+
+1. Linting and Formatting workflows:
+    1. Header checks
+    2. License checks
+    3. Basic Linters 
+2. Ensure Velox builds on various platforms
+    1. MacOS (Intel, M1)
+    2. Linux (Ubuntu/Centos)
+3. Ensure Velox builds under its various configurations
+    1. Debug / Release builds
+    2. Build default Velox build
+    3. Build Velox with support for Parquet, Arrow and External Adapters (S3/HDFS/GCS etc.)
+    4. PyVelox builds
+4. Run prerequisite tests 
+    1. Unit Tests
+    2. Benchmarking Tests
+        1. [Conbench](https://velox-conbench.voltrondata.run/runs/5bd139fffa9b4e0eb020da4d63211121/) is used to store and compare results, and also alert users on regressions
+    3. Various Fuzzer Tests (Expression / Aggregation/ Exchange / Join etc) 
+    4. Signature Check and Biased Fuzzer Tests ( Expression / Aggregation)
+    5. Fuzzer Tests using Presto as source of truth
+5. Docker Image build jobs
+    1. If an underlying dependency is changed, a new Docker CI image is built for
+        1. Ubuntu Linux
+        2. Centos
+        3. Presto Linux image
+6. Documentation build and publish Job
+    1. If underlying documentation is changed, Velox documentation pages are rebuilt and published
+    2. Netlify is used for publishing Velox web pages
+
+## Velox CI Optimization
+
+Previous implementation of CI in CircleCI grew organically and was unoptimized, resulting in long build times, and also significantly costlier. This opportunity to migrate to Github Actions helped to take a holistic view of CI deployments and actively optimized to reduce build times and CI spend. Note however, that there has been continued investment in reducing test times to further improve Velox reliability, stability and developer experience. Some of the optimizations completed are:  
+
+1. **Persisting build artifacts across builds**: During every build, the object files and binaries produced are cached. In addition to this, artifacts such as scalar function signatures and aggregate function signatures are produced. These signatures are used to compare with the baseline version, by comparing against the changes in the current PR to determine if the current changes are backwards incompatible or bias the newly added changes. Using a stash to persist these artifacts helps save one build cycle.
+
+2. **Optimizing our Instances**: Building Velox is Memory and CPU intensive job. Some beefy instances (16-core machines) are used to build Velox. After the build, the build artifacts are copied to smaller instances (4 core machines) to run fuzzer tests and other jobs. Since these fuzzers often run for an hour and are less intensive than the build process, it resulted in significant CI savings while increasing the test coverage.
+
+## Instrumenting Velox CI Builds
+
+Velox CI builds were instrumented in Conbench so that it can capture various metrics about the builds: 
+1. Build times at translation unit / library/ project level.
+2. Binary sizes produced at TLU/ .a,.so / executable level.
+3. Memory pressure 
+4. Measure across time how our changes affect binary sizes 
+
+A nightly job is run to capture these build metrics and it is uploaded to Conbench. Velox build metrics report is available here: [Velox Build Metrics Report](https://facebookincubator.github.io/velox/bm-report/)
+
+<a href="https://facebookincubator.github.io/velox/bm-report/"> <img src="/img/velox-build-metrics.png" height= "100%" width="100%"/> </a>
+
+## Acknowledgements
+
+A large part of the credit goes to Jacob Wujciak and the team at Voltron Data. We would also like to thank other collaborators in the Open Source Community and at Meta, including but not limited to: 
+
+**Meta**: Sridhar Anumandla, Pedro Eugenio Rocha Pedreira, Deepak Majeti, Meta OSS Team, and others
+
+**Voltron Data**: Jacob Wujciak, Austin Dickey, Marcus Hanwell, Sri Nadukudy, and others
+
+
diff --git a/website/blog/authors.yml b/website/blog/authors.yml
index 1ceeec1ead2db..82ac28b151b36 100644
--- a/website/blog/authors.yml
+++ b/website/blog/authors.yml
@@ -54,3 +54,8 @@ raulcd:
   url: https://github.com/raulcd
   image_url: https://github.com/raulcd.png
 
+xumingming:
+  name: James Xu
+  title: Software Engineer @ Alibaba
+  url: https://github.com/xumingming
+  image_url: https://github.com/xumingming.png
diff --git a/website/docs/community/01-design-philosophy.md b/website/docs/community/01-design-philosophy.md
new file mode 100644
index 0000000000000..83902c8606b1c
--- /dev/null
+++ b/website/docs/community/01-design-philosophy.md
@@ -0,0 +1,90 @@
+---
+id: design-philosophy
+title: Design Philosophy
+---
+
+## Summary
+
+This page lists a set of directional principles and values meant to guide
+contributors and maintainers as they develop the Velox project. These are not
+meant to be hard-and-fast rules, but to inform decision making and help guide
+discussions that may come up during the development of Velox. 
+
+## Velox Mission
+
+The Velox project aspires to:
+
+> “Accelerate data management systems by providing a **reliable** and
+> **unified** **state-of-the-art** **open-source** execution platform”
+
+The *Velox community* is composed of a set of highly-skilled individuals with the
+shared purpose of achieving this mission through the development and
+maintenance of the **Velox open-source library** and its ecosystem. In order to
+support and inform community efforts as we progress towards achieving the
+mission, a few overarching principles and values are highlighted below.
+
+## Velox Principles
+
+* **Reliable.** To become the true execution underpinnings for data management
+  systems across the industry, Velox strives for excellence in reliability.
+  This means that as a community we heavily invest in enhancing our test
+  infrastructure, and building sophisticated database testing and validation
+  frameworks. During Velox development, we do not compromise on stability,
+  reliability, or correctness.
+
+* **Unified.** We envision that by unifying execution across data management
+  systems (hence reducing the existing fragmentation), we can be more efficient
+  as an engineering community. Therefore, Velox aspires to provide components
+  which are engine- and dialect-agnostic, containing extensibility APIs through
+  which the behavior of the library can be extended to match a desired
+  semantic.
+
+* **State-of-the-art.** As a unified platform, we believe in the opportunity of
+  centralizing advanced optimizations and techniques previously only available
+  in individual monolithic systems (many of which proprietary), making them
+  easily available everywhere. Although there is a large set of optimizations
+  that can be added (each adding a layer of complexity), we prioritize adding
+  the features that provide the largest performance improvement to real
+  workloads - as opposed to synthetic benchmarks.
+
+* **Open-source.** We take the old saying by heart: “if you want to go fast, go
+  alone; if you want to go far, go together”. We believe that by developing
+  Velox as a community, there is an opportunity to create a virtuous cycle
+  between developers who would like to leverage state-of-the-art execution in
+  their systems; and developers, researchers, and hardware vendors who would
+  like their techniques and hardware platforms to be pervasively adopted in the
+  industry.
+
+## Velox Values
+
+* **High quality.** The development process in Velox is optimized for ensuring
+  (a) reliability and high-quality, and (b) ease of maintenance in the long
+  term, not for the productivity of the developer adding the feature.
+
+* **Test and verification.** Every change in Velox should be accompanied by
+  tests, and a summary describing how the correctness of the change can be
+  verified. Oftentimes, extensions to Velox’s automated testing infrastructure
+  (fuzzers) should also be added by the author to further validate correctness.
+
+* **Readability.** As a library, Velox coding is optimized for the reader, not
+  the writer. We appropriately add comments to our code, document APIs, and
+  produce [documentation](https://facebookincubator.github.io/velox/) about the
+  main library components. It might take longer to write, but eases maintenance
+  and other enhancements in the long run.
+
+* **Code consistency.** The Velox codebase favors consistency over personal
+  preference. When contributing code, first review and follow the
+  [CONTRIBUTING.md](https://github.com/facebookincubator/velox/blob/main/CONTRIBUTING.md)
+  guidelines, and strictly adhere to our
+  [CODING_STYLE.md](https://github.com/facebookincubator/velox/blob/main/CODING_STYLE.md)
+  document.
+
+* **Data-driven.** As an execution engine, there is a large number of
+  optimizations that can be implemented to improve performance. We prioritize
+  the ones that have clear data (in the form of benchmarks based on real-world
+  use cases) supporting their efficacy.
+
+* **Adaptivity.** Exposing too many configuration knobs to users increases the
+  API complexity, and makes it more error-prone. As much as possible, we try to
+  make the library self-adapt to find optimal execution configurations.
+
diff --git a/website/docs/community/02-technical-governance.md b/website/docs/community/02-technical-governance.md
new file mode 100644
index 0000000000000..b591ba723ef96
--- /dev/null
+++ b/website/docs/community/02-technical-governance.md
@@ -0,0 +1,278 @@
+---
+id: technical-governance
+title: Technical Governance
+---
+
+This document describes the Velox technical governance structure, how it
+operates, and the decision-making process behind the project.
+
+## Summary
+
+The Velox community is composed of a set of highly-skilled individuals with the
+shared purpose of achieving the project mission. The project adopts a
+hierarchical technical governance structure, solely based on individuals and
+their merit in the community. Velox’s governing structure is composed of:
+
+* A community of **contributors** who file issues, make pull requests, ask and
+  answer questions, and overall contribute to the project.
+* A small set of **component maintainers** who are responsible for supporting,
+  enhancing, and maintaining the health of each component of the Velox library.
+* They are supported by a **project leadership council (PLC)**, responsible for
+  long-term direction and strategy of the project.
+  * The leadership council has a **chair** who is responsible for settling
+    eventual disputes.
+
+All maintainers are expected to have a strong bias towards [Velox’s design
+philosophy.](./design-philosophy)
+
+Beyond the maintainers, the community is encouraged to contribute, file issues,
+make proposals, review pull requests, help answer questions, publish blog
+posts, share best practices, and be present in the community. Given
+contributions, technical skills, and willingness to invest, anyone can be
+accepted as a maintainer and granted responsibility over parts of the codebase.
+
+Technical governance is merit-based and strictly separated from business
+governance. Separating technical from business governance ensures that the only
+way for an individual to join the technical governance body is through
+continued contributions and demonstration of deep technical skills in the
+domain, great judgment, and alignment with project principles and philosophy. 
+
+Furthermore, membership in the technical governance body is for **individuals**,
+not companies. That is, there are no seats reserved for specific companies, and
+membership is associated with the person rather than their affiliation. 
+
+## Technical Governance Structure
+
+### Component Maintainers
+
+Due to its large breadth and complexity, Velox’s codebase is organized into a
+few logical components. Note that these components are logical and do not
+necessarily reflect a strict physical separation of files and directories,
+although in some cases they do.
+
+Each Velox component will have its own set of maintainers, composed of a set of
+highly-skilled individuals who have continually demonstrated strong technical
+expertise, engagement, great technical judgment, and ownership over that
+component. They are responsible for:
+
+* Review and approve pull requests.
+* Respond to bug reports and questions about the component.
+* Participate in design discussions about the component.
+* Maintain and improve codebase health, fix broken and flaky tests, fuzzer
+  found bugs, and other CI issues.
+* Improve test and performance coverage.
+* Enhance component design and APIs.
+* Produce and keep documentation up-to-date. 
+
+Component maintainers have independence over local decisions affecting their
+component, given alignment with project principles. They also have the right to
+dispute decisions made by other component maintainers - especially if it
+affects them. When disputes are made, the component maintainer group should
+provide a reasonable explanation of the dispute, the relevant arguments, and
+the resolution. 
+
+In the exceptional cases where component maintainers cannot come to a
+conclusion themselves, they may escalate it to the PLC for review. The
+escalations are resolved by the PLC in accordance with their rules and
+procedures.
+
+### Project Leadership Council - PLC
+
+The project leadership council is a small group of highly-skilled individuals
+who have demonstrated deep and broad expertise in the domain of query execution
+and data management, and are actively engaged in the community. They have a
+deep understanding of the Velox codebase and all of its integrations, and are
+responsible for the project leadership, long-term direction, and strategy. PLC
+members are also accountable for upholding the project principles and
+philosophy. They are responsible for:
+
+* Long-term directional leadership of the project.
+* Dispute local decisions when in conflict with project values, principles, or
+  direction.
+* Negotiating and resolving contentious issues, upkeeping the project’s best
+  interest.
+* Receiving broad requests for changes from project stakeholders and evaluating
+  them.
+  * Localized component-level requests are handled by component maintainers.
+* Nominate and confirm component maintainers and other PLC members.
+
+The project leadership council as a group has the power to dispute decisions
+made at the component maintainer level, and to resolve disputes using their
+best judgment. PLC members should publicly articulate their decision-making,
+and give a clear reasoning for their decisions, vetoes, and dispute resolution.
+
+### Project Leadership Council Chair
+
+To ensure the PLC can always reach a decision, they have an assigned and
+publicly declared chair amongst them. The chair is responsible for settling
+disputes in exceptional cases where the PLC could not come to a consensus. The
+PLC chair should publicly articulate their decision-making, and give a clear
+reasoning for their decisions.
+
+## Voting and Nominations
+
+### The Principles
+
+* Membership in maintainer groups is given to **individuals** on **merit
+  basis** after they demonstrated strong expertise of the component through
+  contributions, code reviews, design discussions, and community engagement.
+* For membership in the maintainer group, the individual has to demonstrate
+  strong and continued alignment with the project principles, philosophy, and
+  technical direction.
+* Component maintainers must demonstrate exceptional code review skills,
+  proactiveness and thoroughness, in addition to great technical judgment.
+* Component maintainers must demonstrate a deep care for engineering
+  excellence, testability, API modularity, documentation, and more, keeping a
+  high bar for Velox’s codebase. 
+* In order to be considered, individuals must have demonstrated contributions
+  for a sustained period of time, typically in the order of 6 months or longer.
+  * This means maintainer group membership is *lagging*, not *leading*.
+* No term limits for component maintainers, PLC members, or PLC chair.
+* Light criteria of moving component maintenance or PLC members to *emeritus*
+  status if they don’t actively participate over long periods of time. 
+* The membership is for an individual, not a company.
+
+### The Process for Nomination
+
+* Anyone in the community can nominate a person to become a component
+  maintainer.
+* Periodically, the project leadership council will go through the nominations,
+  do light filtering around spam or desk-rejection, and draw up a list of
+  potential nominees.
+* PLC members may request for more information on the nominee. The information
+  should consist of:
+  * The nominees depth and breadth of code, review, and design contributions on
+    the component.
+  * Testimonials (positive and negative) of the nominee’s interactions with the
+    maintainers, users, and the community.
+  * General testimonials of support from the maintainers.
+* The PLC then evaluates all information and makes a final decision through
+  majority vote to confirm or decline the nomination. 
+
+### Nominating Core Maintainers
+
+* Any PLC member or component maintainer can nominate someone to become a PLC
+  member.
+* PLC members are responsible for evaluating the nomination.
+* The PLC may requests for additional information around the strength of the
+  candidate to be a PLC member:
+  * Evidence that the individual is in fact helping drive the overall project
+    direction.
+  * List the individual’s contributions to the project.
+  * Letters of support from other component maintainers or PLC members.
+  * General letters of support from stakeholders within the Velox community.
+  * Any new relevant information that is befitting for the candidacy.
+* The PLC evaluates all information and makes a final decision through
+  unanimous vote to confirm or decline the nomination, with a clear public
+  articulation of their reasoning behind the decision.
+
+### The Process for Removal
+
+* Similar to the process for nomination, anyone in the community can nominate a
+  person to be removed from a component maintainer position or from the PLC.
+  * A person can also self-nominate to be removed.
+  * Individuals may also be moved to emeritus status after a year of continued
+    inactivity in the community. 
+* The PLC (excluding persons with conflict of interest) will request and
+  evaluate the provided evidence, such as Code of Conduct violations or
+  activity outside the scope of the project that may conflict with the
+  project’s values.
+* The PLC then evaluates all information and makes a final decision through
+  unanimous vote to confirm or decline the removal, with a clear public
+  articulation of their reasoning behind the decision.
+
+### PLC Chair Substitution
+
+* A super-majority of PLC members (75%) can choose to remove the PLC chair.
+* After a removal of the PLC chair or in unforeseen circumstances (such as
+  permanent unavailability of the current PLC chair), the project leadership
+  council will follow a ranked-choice voting method to elect a new chair.
+
+## Decision Making
+
+### Uncontroversial Changes
+
+Primary work happens through Issues, Discussions, and pull requests on GitHub.
+Component maintainers ultimately approve pull requests allowing them to be
+merged without further process.
+
+Notifying relevant experts about an issue or a pull request is important.
+Reviews from experts in the given interest area are strongly preferred,
+especially on pull request approvals. Failure to do so might end up with the
+change being reverted by the relevant expert. Contributors are also encouraged
+to find local experts using git log/blame. 
+
+The component maintainers along with pull request authors themselves are
+responsible for finding and notifying experts to help review a particular
+change.
+
+### Controversial Decision Process
+
+Substantial changes in a given interest area require a GitHub Issue to be
+opened for discussion. Components maintainers are responsible for participating
+in the discussion, reviewing, providing feedback, and eventually approving the
+changes. If disputes are made over the change, component maintainers are
+responsible for settling the issue, or ultimately escalating to the PLC in case
+they cannot reach consensus. 
+
+### Re-Scope Project Components
+
+The PLC is responsible for taking decisions on adding, removing, and re-scoping
+project components. They invite proposals from members in the community
+(including themselves) for such changes, and should publicly articulate the
+reasoning behind the decision.
+
+### Changes to Governance Mechanics
+
+Any changes to this document or the overall technical governance mechanics of
+the project needs to be voted and unanimously approved by PLC members.
+
+## General Project Policies
+
+Velox participants acknowledge that the copyright in all new contributions will
+be retained by the copyright holder as independent works of authorship and that
+no contributor or copyright holder will be required to assign copyrights to the
+project. Except as described below, all code contributions to the project must
+be made using the Apache 2.0 License available here:
+
+[https://www.apache.org/licenses/LICENSE-2.0
+](https://www.apache.org/licenses/LICENSE-2.0) (the "Project License"). 
+
+All outbound code will be made available under the Project License. The
+maintainers may approve the use of an alternative open license or licenses for
+inbound or outbound contributions on an exception basis.
+
+## FAQ
+
+**Q: I would like to help and get engaged with the community. Where do I
+start?**
+The Velox [contributing
+guide](https://github.com/facebookincubator/velox/blob/main/CONTRIBUTING.md)
+provides guidelines on how new community members can get involved in the
+project. 
+
+**Q: Is it possible for an external contributor to become a maintainer and be
+granted responsibilities over parts of the codebase?**
+This is absolutely possible. The first step is to start contributing to the
+existing project area and supporting its health and success. In addition to
+this, you can make a proposal through a GitHub issue for new functionality or
+changes to improve the project area.
+
+**Q: What if I am a company looking to use Velox internally for development, can
+I be granted or purchase a maintainer or PLC member status?**
+No, the Velox project is strictly driven by highly-skilled technical
+individuals, and membership in these groups is based on merit in the community.
+
+**Q: How do I contribute code to the project?**
+If the change is relatively minor, a pull request on GitHub can be opened up
+immediately for review by the project maintainers. For larger changes, please
+open an Issue to make a proposal to discuss prior. Please also see the 
+[Velox Contributor Guide](https://github.com/facebookincubator/velox/blob/main/CONTRIBUTING.md)
+for contribution guidelines.
+
+**Q: Can I become a committer on the project?**
+Unfortunately, the commit process to Velox involves an interaction with Meta’s
+infrastructure that currently can only be triggered by Meta employees.
+Maintainers, however, have the authority to approve PRs, which then get merged
+without further process by a Meta-employee-based oncall rotation. We intend to
+improve our tooling to relax this restriction in the future. 
diff --git a/website/docs/community/03-components-and-maintainers.md b/website/docs/community/03-components-and-maintainers.md
new file mode 100644
index 0000000000000..483d7d7e09db0
--- /dev/null
+++ b/website/docs/community/03-components-and-maintainers.md
@@ -0,0 +1,95 @@
+---
+id: components-and-maintainers
+title: Components and Maintainers
+---
+
+## Summary
+
+This page lists individuals of interest in the Velox community, as described in
+the [Technical Governance Mechanics](./technical-governance)
+page. It is meant to be used by contributors and other stakeholders as a
+blueprint to find individuals responsible for different aspects of the project
+and codebase.
+
+Maintainership status is *lagging*, not *leading*, and it is only acquired
+through active participation and demonstration of skills and domain-specific
+knowledge. All individuals listed in this page are expected to uphold
+[Velox’s mission, design philosophy, and principles](./design-philosophy). 
+
+## Project Leadership Council - PLC
+
+The PLC is reponsible for the long-term directional leadership of the project:
+
+* Masha Basmanova - [mbasmanova](https://github.com/mbasmanova) / mbasmanova@meta.com - **Chair**
+* Orri Erling - [oerling](https://github.com/oerling) / oerling@meta.com
+* Pedro Pedreira - [pedroerp](https://github.com/pedroerp) / pedroerp@meta.com
+* Xiaoxuan Meng - [xiaoxmeng](https://github.com/xiaoxmeng) / xiaoxmeng@meta.com
+
+## Component Maintainers
+
+Component maintainers are responsible for triaging, reviewing, and approving
+pull requests concerning the component. They also maintain, enhance,
+and advocate for improvements in component design, tests, CI health, and
+developer documentation.
+
+Before working on a new feature or optimization, please review our
+[CONTRIBUTING.md](https://github.com/facebookincubator/velox/blob/main/CONTRIBUTING.md)
+guide and initiate a discussion on Github with the people listed as
+maintainers of that component. 
+
+### Vectors, Types, Arrow Bindings:
+
+* Jimmy Lu - [Yuhta](https://github.com/Yuhta) / jimmylu@meta.com
+* Masha Basmanova - [mbasmanova](https://github.com/mbasmanova) / mbasmanova@meta.com
+* Pedro Pedreira - [pedroerp](https://github.com/pedroerp) / pedroerp@meta.com
+
+### Expression Evaluation
+
+* Masha Basmanova - [mbasmanova](https://github.com/mbasmanova) / mbasmanova@meta.com
+
+### Operators
+
+* Jimmy Lu - [Yuhta](https://github.com/Yuhta) / jimmylu@meta.com
+* Masha Basmanova - [mbasmanova](https://github.com/mbasmanova) / mbasmanova@meta.com
+* Xiaoxuan Meng - [xiaoxmeng](https://github.com/xiaoxmeng) / xiaoxmeng@meta.com
+
+### Presto Functions
+
+* Jimmy Lu - [Yuhta](https://github.com/Yuhta) / jimmylu@meta.com
+* Masha Basmanova - [mbasmanova](https://github.com/mbasmanova) / mbasmanova@meta.com
+
+### Spark Functions
+
+* Rui Mo - [rui-mo](https://github.com/rui-mo) / rui.mo@intel.com
+
+### Memory Management
+
+* Xiaoxuan Meng - [xiaoxmeng](https://github.com/xiaoxmeng) / xiaoxmeng@meta.com
+
+### IO, Cache, Hive connector, and File reader/writers
+
+* Jimmy Lu - [Yuhta](https://github.com/Yuhta) / jimmylu@meta.com
+* Xiaoxuan Meng - [xiaoxmeng](https://github.com/xiaoxmeng) / xiaoxmeng@meta.com
+
+#### Parquet
+
+* Deepak Majeti - [majetideepak](https://github.com/majetideepak) / deepak.majeti@ibm.com
+
+#### ORC, DWRF, and Nimble
+
+* Jimmy Lu - [Yuhta](https://github.com/Yuhta) / jimmylu@meta.com
+
+### Storage Adapters (S3/HDFS/GCS/ABFS)
+
+* Deepak Majeti - [majetideepak](https://github.com/majetideepak) / deepak.majeti@ibm.com
+
+### Builds and CI
+
+* Deepak Majeti - [majetideepak](https://github.com/majetideepak) / deepak.majeti@ibm.com
+* Jacob Wujciak-Jens - [assignUser](https://github.com/assignUser) / jacob@voltrondata.com
+* Krishna Pai - [kgpai](https://github.com/kgpai) / kpai@meta.com
+
+### Fuzzers and Test Frameworks
+
+* Masha Basmanova - [mbasmanova](https://github.com/mbasmanova) / mbasmanova@meta.com
+* Pedro Pedreira - [pedroerp](https://github.com/pedroerp) / pedroerp@meta.com
diff --git a/website/docs/community/index.md b/website/docs/community/index.md
new file mode 100644
index 0000000000000..79ccf95254970
--- /dev/null
+++ b/website/docs/community/index.md
@@ -0,0 +1,15 @@
+---
+slug: /community/
+---
+
+# Community
+
+Velox is a project created and 
+[open sourced by Meta in 2023](https://engineering.fb.com/2023/03/09/open-source/velox-open-source-execution-engine/). 
+Today, Velox is developed and maintained by a community of 200+ individuals from
+20+ different organizations. This page contains more information about Velox's
+open source community.
+
+* [Design Philosophy, Principles, and Values](./design-philosophy)
+* [Technical Governance](./technical-governance)
+* [Components and Maintainers](./components-and-maintainers)
diff --git a/website/docs/intro.md b/website/docs/intro.md
deleted file mode 100644
index 6ce1c895db589..0000000000000
--- a/website/docs/intro.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-id: roadmap
-title: Roadmap
-slug: /
----
-- Add support for DECIMAL type.
-- Add support for window functions.
-- Add support for converting Velox plan fragments to and from Substrait representation.
-- Make it easier to build Velox on a variety of platforms.
-- Improve reliability by setting up performance testing for each PR.
-- Make it easier to debug failures, crashes and incorrect results.
-- Introduce simple aggregate function API for better authoring experience.
-- Expand test coverage for vectors and expression evaluation.
diff --git a/website/docusaurus.config.js b/website/docusaurus.config.js
index 26f9d3d664ce3..d682d7376c912 100644
--- a/website/docusaurus.config.js
+++ b/website/docusaurus.config.js
@@ -70,8 +70,8 @@ const config = {
             position: 'left',
           },
           {
-            href: '/docs',
-            label: 'Roadmap',
+            href: '/docs/community/',
+            label: 'Community',
             position: 'left',
           },
           {
diff --git a/website/package-lock.json b/website/package-lock.json
index d1dd170d7141f..fd65134821738 100644
--- a/website/package-lock.json
+++ b/website/package-lock.json
@@ -12,6 +12,7 @@
         "@docusaurus/plugin-google-gtag": "^2.0.1",
         "@docusaurus/preset-classic": "2.0.1",
         "@mdx-js/react": "^1.6.22",
+        "axios": "^0.28.0",
         "clsx": "^1.2.1",
         "prism-react-renderer": "^1.3.5",
         "react": "^17.0.2",
@@ -182,16 +183,81 @@
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz",
-      "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==",
+      "version": "7.22.13",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz",
+      "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==",
       "dependencies": {
-        "@babel/highlight": "^7.18.6"
+        "@babel/highlight": "^7.22.13",
+        "chalk": "^2.4.2"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/code-frame/node_modules/ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dependencies": {
+        "color-convert": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/@babel/code-frame/node_modules/chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dependencies": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/@babel/code-frame/node_modules/color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dependencies": {
+        "color-name": "1.1.3"
+      }
+    },
+    "node_modules/@babel/code-frame/node_modules/color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="
+    },
+    "node_modules/@babel/code-frame/node_modules/escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/@babel/code-frame/node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/@babel/code-frame/node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/@babel/compat-data": {
       "version": "7.18.8",
       "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.8.tgz",
@@ -238,12 +304,13 @@
       }
     },
     "node_modules/@babel/generator": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.10.tgz",
-      "integrity": "sha512-0+sW7e3HjQbiHbj1NeU/vN8ornohYlacAfZIaXhdoGweQqgcNy69COVciYYqEXJ/v+9OBA7Frxm4CVAuNqKeNA==",
+      "version": "7.23.0",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.23.0.tgz",
+      "integrity": "sha512-lN85QRR+5IbYrMWM6Y4pE/noaQtg4pNiqeNGX60eqOfo6gtEj6uw/JagelB8vVztSd7R6M5n1+PQkDbHbBRU4g==",
       "dependencies": {
-        "@babel/types": "^7.18.10",
+        "@babel/types": "^7.23.0",
         "@jridgewell/gen-mapping": "^0.3.2",
+        "@jridgewell/trace-mapping": "^0.3.17",
         "jsesc": "^2.5.1"
       },
       "engines": {
@@ -371,9 +438,9 @@
       }
     },
     "node_modules/@babel/helper-environment-visitor": {
-      "version": "7.18.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz",
-      "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==",
+      "version": "7.22.20",
+      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.20.tgz",
+      "integrity": "sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==",
       "engines": {
         "node": ">=6.9.0"
       }
@@ -390,23 +457,23 @@
       }
     },
     "node_modules/@babel/helper-function-name": {
-      "version": "7.18.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.18.9.tgz",
-      "integrity": "sha512-fJgWlZt7nxGksJS9a0XdSaI4XvpExnNIgRP+rVefWh5U7BL8pPuir6SJUmFKRfjWQ51OtWSzwOxhaH/EBWWc0A==",
+      "version": "7.23.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.23.0.tgz",
+      "integrity": "sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==",
       "dependencies": {
-        "@babel/template": "^7.18.6",
-        "@babel/types": "^7.18.9"
+        "@babel/template": "^7.22.15",
+        "@babel/types": "^7.23.0"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-hoist-variables": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz",
-      "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==",
+      "version": "7.22.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz",
+      "integrity": "sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==",
       "dependencies": {
-        "@babel/types": "^7.18.6"
+        "@babel/types": "^7.22.5"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -526,28 +593,28 @@
       }
     },
     "node_modules/@babel/helper-split-export-declaration": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz",
-      "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==",
+      "version": "7.22.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz",
+      "integrity": "sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==",
       "dependencies": {
-        "@babel/types": "^7.18.6"
+        "@babel/types": "^7.22.5"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-string-parser": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.18.10.tgz",
-      "integrity": "sha512-XtIfWmeNY3i4t7t4D2t02q50HvqHybPqW2ki1kosnvWCwuCMeo81Jf0gwr85jy/neUdg5XDdeFE/80DXiO+njw==",
+      "version": "7.22.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz",
+      "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.18.6.tgz",
-      "integrity": "sha512-MmetCkz9ej86nJQV+sFCxoGGrUbU3q02kgLciwkrt9QqEB7cP39oKEY0PakknEO0Gu20SskMRi+AYZ3b1TpN9g==",
+      "version": "7.22.20",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz",
+      "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==",
       "engines": {
         "node": ">=6.9.0"
       }
@@ -588,12 +655,12 @@
       }
     },
     "node_modules/@babel/highlight": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz",
-      "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==",
+      "version": "7.22.20",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.20.tgz",
+      "integrity": "sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.18.6",
-        "chalk": "^2.0.0",
+        "@babel/helper-validator-identifier": "^7.22.20",
+        "chalk": "^2.4.2",
         "js-tokens": "^4.0.0"
       },
       "engines": {
@@ -665,9 +732,9 @@
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.10.tgz",
-      "integrity": "sha512-TYk3OA0HKL6qNryUayb5UUEhM/rkOQozIBEA5ITXh5DWrSp0TlUQXMyZmnWxG/DizSWBeeQ0Zbc5z8UGaaqoeg==",
+      "version": "7.23.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.23.0.tgz",
+      "integrity": "sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw==",
       "bin": {
         "parser": "bin/babel-parser.js"
       },
@@ -1908,31 +1975,31 @@
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.10.tgz",
-      "integrity": "sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA==",
+      "version": "7.22.15",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.15.tgz",
+      "integrity": "sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==",
       "dependencies": {
-        "@babel/code-frame": "^7.18.6",
-        "@babel/parser": "^7.18.10",
-        "@babel/types": "^7.18.10"
+        "@babel/code-frame": "^7.22.13",
+        "@babel/parser": "^7.22.15",
+        "@babel/types": "^7.22.15"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.10.tgz",
-      "integrity": "sha512-J7ycxg0/K9XCtLyHf0cz2DqDihonJeIo+z+HEdRe9YuT8TY4A66i+Ab2/xZCEW7Ro60bPCBBfqqboHSamoV3+g==",
-      "dependencies": {
-        "@babel/code-frame": "^7.18.6",
-        "@babel/generator": "^7.18.10",
-        "@babel/helper-environment-visitor": "^7.18.9",
-        "@babel/helper-function-name": "^7.18.9",
-        "@babel/helper-hoist-variables": "^7.18.6",
-        "@babel/helper-split-export-declaration": "^7.18.6",
-        "@babel/parser": "^7.18.10",
-        "@babel/types": "^7.18.10",
+      "version": "7.23.2",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.23.2.tgz",
+      "integrity": "sha512-azpe59SQ48qG6nu2CzcMLbxUudtN+dOM9kDbUqGq3HXUJRlo7i8fvPoxQUzYgLZ4cMVmuZgm8vvBpNeRhd6XSw==",
+      "dependencies": {
+        "@babel/code-frame": "^7.22.13",
+        "@babel/generator": "^7.23.0",
+        "@babel/helper-environment-visitor": "^7.22.20",
+        "@babel/helper-function-name": "^7.23.0",
+        "@babel/helper-hoist-variables": "^7.22.5",
+        "@babel/helper-split-export-declaration": "^7.22.6",
+        "@babel/parser": "^7.23.0",
+        "@babel/types": "^7.23.0",
         "debug": "^4.1.0",
         "globals": "^11.1.0"
       },
@@ -1941,12 +2008,12 @@
       }
     },
     "node_modules/@babel/types": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.10.tgz",
-      "integrity": "sha512-MJvnbEiiNkpjo+LknnmRrqbY1GPUUggjv+wQVjetM/AONoupqRALB7I6jGqNUAZsKcRIEu2J6FRFvsczljjsaQ==",
+      "version": "7.23.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.23.0.tgz",
+      "integrity": "sha512-0oIyUfKoI3mSqMvsxBdclDwxXKXAUA8v/apZbc+iSyARYou1o8ZGDxbUYyLFoW2arqS2jDGqJuZvv1d/io1axg==",
       "dependencies": {
-        "@babel/helper-string-parser": "^7.18.10",
-        "@babel/helper-validator-identifier": "^7.18.6",
+        "@babel/helper-string-parser": "^7.22.5",
+        "@babel/helper-validator-identifier": "^7.22.20",
         "to-fast-properties": "^2.0.0"
       },
       "engines": {
@@ -2610,12 +2677,12 @@
       "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
     },
     "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz",
-      "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==",
+      "version": "0.3.20",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.20.tgz",
+      "integrity": "sha512-R8LcPeWZol2zR8mmH3JeKQ6QRCFb7XgUhV9ZlGhHLGyg4wpPiPZNQOOWhFZhxKw8u//yTbNGI42Bx/3paXEQ+Q==",
       "dependencies": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
     "node_modules/@leichtgewicht/ip-codec": {
@@ -3740,6 +3807,11 @@
       "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
       "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA=="
     },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
     "node_modules/at-least-node": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
@@ -3781,11 +3853,13 @@
       }
     },
     "node_modules/axios": {
-      "version": "0.25.0",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-0.25.0.tgz",
-      "integrity": "sha512-cD8FOb0tRH3uuEe6+evtAbgJtfxr7ly3fQjYcMcuPlgkwVS9xboaVIpcDV+cYQe+yGykgwZCs1pzjntcGa6l5g==",
+      "version": "0.28.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-0.28.0.tgz",
+      "integrity": "sha512-Tu7NYoGY4Yoc7I+Npf9HhUMtEEpV7ZiLH9yndTCoNhcpBH0kwcvFbzYN9/u5QKI5A6uefjsNNWaz5olJVYS62Q==",
       "dependencies": {
-        "follow-redirects": "^1.14.7"
+        "follow-redirects": "^1.15.0",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
       }
     },
     "node_modules/babel-loader": {
@@ -4038,9 +4112,9 @@
       }
     },
     "node_modules/browserslist": {
-      "version": "4.21.3",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.3.tgz",
-      "integrity": "sha512-898rgRXLAyRkM1GryrrBHGkqA5hlpkV5MhtZwg9QXeiyLUYs2k00Un05aX5l2/yJIOObYKOpS2JNo8nJDE7fWQ==",
+      "version": "4.23.0",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.0.tgz",
+      "integrity": "sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==",
       "funding": [
         {
           "type": "opencollective",
@@ -4049,13 +4123,17 @@
         {
           "type": "tidelift",
           "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
         }
       ],
       "dependencies": {
-        "caniuse-lite": "^1.0.30001370",
-        "electron-to-chromium": "^1.4.202",
-        "node-releases": "^2.0.6",
-        "update-browserslist-db": "^1.0.5"
+        "caniuse-lite": "^1.0.30001587",
+        "electron-to-chromium": "^1.4.668",
+        "node-releases": "^2.0.14",
+        "update-browserslist-db": "^1.0.13"
       },
       "bin": {
         "browserslist": "cli.js"
@@ -4184,9 +4262,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001373",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001373.tgz",
-      "integrity": "sha512-pJYArGHrPp3TUqQzFYRmP/lwJlj8RCbVe3Gd3eJQkAV8SAC6b19XS9BjMvRdvaS8RMkaTN8ZhoHP6S1y8zzwEQ==",
+      "version": "1.0.30001588",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001588.tgz",
+      "integrity": "sha512-+hVY9jE44uKLkH0SrUTqxjxqNTOWHsbnQDIKjwkZ3lNTzUUVdBLBGXtj/q5Mp5u98r3droaZAewQuEDzjQdZlQ==",
       "funding": [
         {
           "type": "opencollective",
@@ -4195,6 +4273,10 @@
         {
           "type": "tidelift",
           "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
         }
       ]
     },
@@ -4461,6 +4543,17 @@
         "node": ">=10"
       }
     },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/comma-separated-tokens": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz",
@@ -4737,26 +4830,17 @@
       }
     },
     "node_modules/core-js-compat": {
-      "version": "3.24.1",
-      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.24.1.tgz",
-      "integrity": "sha512-XhdNAGeRnTpp8xbD+sR/HFDK9CbeeeqXT6TuofXh3urqEevzkWmLRgrVoykodsw8okqo2pu1BOmuCKrHx63zdw==",
+      "version": "3.36.0",
+      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.36.0.tgz",
+      "integrity": "sha512-iV9Pd/PsgjNWBXeq8XRtWVSgz2tKAfhfvBs7qxYty+RlRd+OCksaWmOnc4JKrTc1cToXL1N0s3l/vwlxPtdElw==",
       "dependencies": {
-        "browserslist": "^4.21.3",
-        "semver": "7.0.0"
+        "browserslist": "^4.22.3"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/core-js"
       }
     },
-    "node_modules/core-js-compat/node_modules/semver": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.0.0.tgz",
-      "integrity": "sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
     "node_modules/core-js-pure": {
       "version": "3.24.1",
       "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.24.1.tgz",
@@ -5198,6 +5282,14 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
     "node_modules/depd": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
@@ -5425,9 +5517,9 @@
       "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.4.210",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.210.tgz",
-      "integrity": "sha512-kSiX4tuyZijV7Cz0MWVmGT8K2siqaOA4Z66K5dCttPPRh0HicOcOAEj1KlC8O8J1aOS/1M8rGofOzksLKaHWcQ=="
+      "version": "1.4.679",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.679.tgz",
+      "integrity": "sha512-NhQMsz5k0d6m9z3qAxnsOR/ebal4NAGsrNVRwcDo4Kc/zQ7KdsTKZUxZoygHcVRb0QDW3waEDIcE3isZ79RP6g=="
     },
     "node_modules/emoji-regex": {
       "version": "9.2.2",
@@ -5504,9 +5596,9 @@
       "integrity": "sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ=="
     },
     "node_modules/escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
+      "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==",
       "engines": {
         "node": ">=6"
       }
@@ -5595,9 +5687,9 @@
       }
     },
     "node_modules/eta": {
-      "version": "1.12.3",
-      "resolved": "https://registry.npmjs.org/eta/-/eta-1.12.3.tgz",
-      "integrity": "sha512-qHixwbDLtekO/d51Yr4glcaUJCIjGVJyTzuqV4GPlgZo1YpgOKG+avQynErZIYrfM6JIJdtiG2Kox8tbb+DoGg==",
+      "version": "1.14.2",
+      "resolved": "https://registry.npmjs.org/eta/-/eta-1.14.2.tgz",
+      "integrity": "sha512-wZmJAV7EFUG5W8XNXSazIdichnWEhGB1OWg4tnXWPj0CPNUcFdgorGNO6N9p6WBUgoUe4P0OziJYn1+6zxP2aQ==",
       "engines": {
         "node": ">=6.0.0"
       },
@@ -6005,9 +6097,9 @@
       }
     },
     "node_modules/follow-redirects": {
-      "version": "1.15.1",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.1.tgz",
-      "integrity": "sha512-yLAMQs+k0b2m7cVxpS1VKJVvoz7SS9Td1zss3XRwXj+ZDH00RJgnuLx7E44wx02kQLrdM3aOOy+FpzS7+8OizA==",
+      "version": "1.15.5",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.5.tgz",
+      "integrity": "sha512-vSFWUON1B+yAw1VN4xMfxgn5fTUiaOzAJCKBwIIgT/+7CuGy9+r+5gITvP62j3RmaD5Ph65UaERdOSRGUzZtgw==",
       "funding": [
         {
           "type": "individual",
@@ -6115,6 +6207,19 @@
         "node": ">=6"
       }
     },
+    "node_modules/form-data": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/forwarded": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -7868,9 +7973,15 @@
       }
     },
     "node_modules/nanoid": {
-      "version": "3.3.4",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.4.tgz",
-      "integrity": "sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==",
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz",
+      "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
       "bin": {
         "nanoid": "bin/nanoid.cjs"
       },
@@ -7936,9 +8047,9 @@
       }
     },
     "node_modules/node-releases": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz",
-      "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg=="
+      "version": "2.0.14",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz",
+      "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw=="
     },
     "node_modules/normalize-path": {
       "version": "3.0.0",
@@ -8424,9 +8535,9 @@
       }
     },
     "node_modules/postcss": {
-      "version": "8.4.14",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.14.tgz",
-      "integrity": "sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==",
+      "version": "8.4.35",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.35.tgz",
+      "integrity": "sha512-u5U8qYpBCpN13BsiEB0CbR1Hhh4Gc0zLFuedrHJKMctHCHAGrMdG0PRM/KErzAL3CU6/eckEtmHNB3x6e3c0vA==",
       "funding": [
         {
           "type": "opencollective",
@@ -8435,10 +8546,14 @@
         {
           "type": "tidelift",
           "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
         }
       ],
       "dependencies": {
-        "nanoid": "^3.3.4",
+        "nanoid": "^3.3.7",
         "picocolors": "^1.0.0",
         "source-map-js": "^1.0.2"
       },
@@ -9093,6 +9208,11 @@
         "node": ">= 0.10"
       }
     },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
     "node_modules/pump": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
@@ -11337,9 +11457,9 @@
       }
     },
     "node_modules/update-browserslist-db": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.5.tgz",
-      "integrity": "sha512-dteFFpCyvuDdr9S/ff1ISkKt/9YZxKjI9WlRR99c180GaztJtRa/fn18FdxGVKVsnPY7/a/FDN68mcvUmP4U7Q==",
+      "version": "1.0.13",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz",
+      "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==",
       "funding": [
         {
           "type": "opencollective",
@@ -11348,6 +11468,10 @@
         {
           "type": "tidelift",
           "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
         }
       ],
       "dependencies": {
@@ -11355,7 +11479,7 @@
         "picocolors": "^1.0.0"
       },
       "bin": {
-        "browserslist-lint": "cli.js"
+        "update-browserslist-db": "cli.js"
       },
       "peerDependencies": {
         "browserslist": ">= 4.21.0"
@@ -11704,6 +11828,14 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/wait-on/node_modules/axios": {
+      "version": "0.25.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-0.25.0.tgz",
+      "integrity": "sha512-cD8FOb0tRH3uuEe6+evtAbgJtfxr7ly3fQjYcMcuPlgkwVS9xboaVIpcDV+cYQe+yGykgwZCs1pzjntcGa6l5g==",
+      "dependencies": {
+        "follow-redirects": "^1.14.7"
+      }
+    },
     "node_modules/watchpack": {
       "version": "2.4.0",
       "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz",
@@ -12472,11 +12604,63 @@
       }
     },
     "@babel/code-frame": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz",
-      "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==",
+      "version": "7.22.13",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz",
+      "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==",
       "requires": {
-        "@babel/highlight": "^7.18.6"
+        "@babel/highlight": "^7.22.13",
+        "chalk": "^2.4.2"
+      },
+      "dependencies": {
+        "ansi-styles": {
+          "version": "3.2.1",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+          "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+          "requires": {
+            "color-convert": "^1.9.0"
+          }
+        },
+        "chalk": {
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+          "requires": {
+            "ansi-styles": "^3.2.1",
+            "escape-string-regexp": "^1.0.5",
+            "supports-color": "^5.3.0"
+          }
+        },
+        "color-convert": {
+          "version": "1.9.3",
+          "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+          "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+          "requires": {
+            "color-name": "1.1.3"
+          }
+        },
+        "color-name": {
+          "version": "1.1.3",
+          "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+          "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="
+        },
+        "escape-string-regexp": {
+          "version": "1.0.5",
+          "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+          "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg=="
+        },
+        "has-flag": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+          "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw=="
+        },
+        "supports-color": {
+          "version": "5.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+          "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        }
       }
     },
     "@babel/compat-data": {
@@ -12514,12 +12698,13 @@
       }
     },
     "@babel/generator": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.10.tgz",
-      "integrity": "sha512-0+sW7e3HjQbiHbj1NeU/vN8ornohYlacAfZIaXhdoGweQqgcNy69COVciYYqEXJ/v+9OBA7Frxm4CVAuNqKeNA==",
+      "version": "7.23.0",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.23.0.tgz",
+      "integrity": "sha512-lN85QRR+5IbYrMWM6Y4pE/noaQtg4pNiqeNGX60eqOfo6gtEj6uw/JagelB8vVztSd7R6M5n1+PQkDbHbBRU4g==",
       "requires": {
-        "@babel/types": "^7.18.10",
+        "@babel/types": "^7.23.0",
         "@jridgewell/gen-mapping": "^0.3.2",
+        "@jridgewell/trace-mapping": "^0.3.17",
         "jsesc": "^2.5.1"
       },
       "dependencies": {
@@ -12614,9 +12799,9 @@
       }
     },
     "@babel/helper-environment-visitor": {
-      "version": "7.18.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz",
-      "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg=="
+      "version": "7.22.20",
+      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.20.tgz",
+      "integrity": "sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA=="
     },
     "@babel/helper-explode-assignable-expression": {
       "version": "7.18.6",
@@ -12627,20 +12812,20 @@
       }
     },
     "@babel/helper-function-name": {
-      "version": "7.18.9",
-      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.18.9.tgz",
-      "integrity": "sha512-fJgWlZt7nxGksJS9a0XdSaI4XvpExnNIgRP+rVefWh5U7BL8pPuir6SJUmFKRfjWQ51OtWSzwOxhaH/EBWWc0A==",
+      "version": "7.23.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.23.0.tgz",
+      "integrity": "sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==",
       "requires": {
-        "@babel/template": "^7.18.6",
-        "@babel/types": "^7.18.9"
+        "@babel/template": "^7.22.15",
+        "@babel/types": "^7.23.0"
       }
     },
     "@babel/helper-hoist-variables": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz",
-      "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==",
+      "version": "7.22.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz",
+      "integrity": "sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==",
       "requires": {
-        "@babel/types": "^7.18.6"
+        "@babel/types": "^7.22.5"
       }
     },
     "@babel/helper-member-expression-to-functions": {
@@ -12727,22 +12912,22 @@
       }
     },
     "@babel/helper-split-export-declaration": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz",
-      "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==",
+      "version": "7.22.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz",
+      "integrity": "sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==",
       "requires": {
-        "@babel/types": "^7.18.6"
+        "@babel/types": "^7.22.5"
       }
     },
     "@babel/helper-string-parser": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.18.10.tgz",
-      "integrity": "sha512-XtIfWmeNY3i4t7t4D2t02q50HvqHybPqW2ki1kosnvWCwuCMeo81Jf0gwr85jy/neUdg5XDdeFE/80DXiO+njw=="
+      "version": "7.22.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz",
+      "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw=="
     },
     "@babel/helper-validator-identifier": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.18.6.tgz",
-      "integrity": "sha512-MmetCkz9ej86nJQV+sFCxoGGrUbU3q02kgLciwkrt9QqEB7cP39oKEY0PakknEO0Gu20SskMRi+AYZ3b1TpN9g=="
+      "version": "7.22.20",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz",
+      "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A=="
     },
     "@babel/helper-validator-option": {
       "version": "7.18.6",
@@ -12771,12 +12956,12 @@
       }
     },
     "@babel/highlight": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz",
-      "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==",
+      "version": "7.22.20",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.20.tgz",
+      "integrity": "sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==",
       "requires": {
-        "@babel/helper-validator-identifier": "^7.18.6",
-        "chalk": "^2.0.0",
+        "@babel/helper-validator-identifier": "^7.22.20",
+        "chalk": "^2.4.2",
         "js-tokens": "^4.0.0"
       },
       "dependencies": {
@@ -12832,9 +13017,9 @@
       }
     },
     "@babel/parser": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.10.tgz",
-      "integrity": "sha512-TYk3OA0HKL6qNryUayb5UUEhM/rkOQozIBEA5ITXh5DWrSp0TlUQXMyZmnWxG/DizSWBeeQ0Zbc5z8UGaaqoeg=="
+      "version": "7.23.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.23.0.tgz",
+      "integrity": "sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw=="
     },
     "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": {
       "version": "7.18.6",
@@ -13635,39 +13820,39 @@
       }
     },
     "@babel/template": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.10.tgz",
-      "integrity": "sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA==",
+      "version": "7.22.15",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.15.tgz",
+      "integrity": "sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==",
       "requires": {
-        "@babel/code-frame": "^7.18.6",
-        "@babel/parser": "^7.18.10",
-        "@babel/types": "^7.18.10"
+        "@babel/code-frame": "^7.22.13",
+        "@babel/parser": "^7.22.15",
+        "@babel/types": "^7.22.15"
       }
     },
     "@babel/traverse": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.10.tgz",
-      "integrity": "sha512-J7ycxg0/K9XCtLyHf0cz2DqDihonJeIo+z+HEdRe9YuT8TY4A66i+Ab2/xZCEW7Ro60bPCBBfqqboHSamoV3+g==",
-      "requires": {
-        "@babel/code-frame": "^7.18.6",
-        "@babel/generator": "^7.18.10",
-        "@babel/helper-environment-visitor": "^7.18.9",
-        "@babel/helper-function-name": "^7.18.9",
-        "@babel/helper-hoist-variables": "^7.18.6",
-        "@babel/helper-split-export-declaration": "^7.18.6",
-        "@babel/parser": "^7.18.10",
-        "@babel/types": "^7.18.10",
+      "version": "7.23.2",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.23.2.tgz",
+      "integrity": "sha512-azpe59SQ48qG6nu2CzcMLbxUudtN+dOM9kDbUqGq3HXUJRlo7i8fvPoxQUzYgLZ4cMVmuZgm8vvBpNeRhd6XSw==",
+      "requires": {
+        "@babel/code-frame": "^7.22.13",
+        "@babel/generator": "^7.23.0",
+        "@babel/helper-environment-visitor": "^7.22.20",
+        "@babel/helper-function-name": "^7.23.0",
+        "@babel/helper-hoist-variables": "^7.22.5",
+        "@babel/helper-split-export-declaration": "^7.22.6",
+        "@babel/parser": "^7.23.0",
+        "@babel/types": "^7.23.0",
         "debug": "^4.1.0",
         "globals": "^11.1.0"
       }
     },
     "@babel/types": {
-      "version": "7.18.10",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.10.tgz",
-      "integrity": "sha512-MJvnbEiiNkpjo+LknnmRrqbY1GPUUggjv+wQVjetM/AONoupqRALB7I6jGqNUAZsKcRIEu2J6FRFvsczljjsaQ==",
+      "version": "7.23.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.23.0.tgz",
+      "integrity": "sha512-0oIyUfKoI3mSqMvsxBdclDwxXKXAUA8v/apZbc+iSyARYou1o8ZGDxbUYyLFoW2arqS2jDGqJuZvv1d/io1axg==",
       "requires": {
-        "@babel/helper-string-parser": "^7.18.10",
-        "@babel/helper-validator-identifier": "^7.18.6",
+        "@babel/helper-string-parser": "^7.22.5",
+        "@babel/helper-validator-identifier": "^7.22.20",
         "to-fast-properties": "^2.0.0"
       }
     },
@@ -14171,12 +14356,12 @@
       "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
     },
     "@jridgewell/trace-mapping": {
-      "version": "0.3.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz",
-      "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==",
+      "version": "0.3.20",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.20.tgz",
+      "integrity": "sha512-R8LcPeWZol2zR8mmH3JeKQ6QRCFb7XgUhV9ZlGhHLGyg4wpPiPZNQOOWhFZhxKw8u//yTbNGI42Bx/3paXEQ+Q==",
       "requires": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
     "@leichtgewicht/ip-codec": {
@@ -15060,6 +15245,11 @@
       "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
       "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA=="
     },
+    "asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
     "at-least-node": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
@@ -15079,11 +15269,13 @@
       }
     },
     "axios": {
-      "version": "0.25.0",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-0.25.0.tgz",
-      "integrity": "sha512-cD8FOb0tRH3uuEe6+evtAbgJtfxr7ly3fQjYcMcuPlgkwVS9xboaVIpcDV+cYQe+yGykgwZCs1pzjntcGa6l5g==",
+      "version": "0.28.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-0.28.0.tgz",
+      "integrity": "sha512-Tu7NYoGY4Yoc7I+Npf9HhUMtEEpV7ZiLH9yndTCoNhcpBH0kwcvFbzYN9/u5QKI5A6uefjsNNWaz5olJVYS62Q==",
       "requires": {
-        "follow-redirects": "^1.14.7"
+        "follow-redirects": "^1.15.0",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
       }
     },
     "babel-loader": {
@@ -15288,14 +15480,14 @@
       }
     },
     "browserslist": {
-      "version": "4.21.3",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.3.tgz",
-      "integrity": "sha512-898rgRXLAyRkM1GryrrBHGkqA5hlpkV5MhtZwg9QXeiyLUYs2k00Un05aX5l2/yJIOObYKOpS2JNo8nJDE7fWQ==",
+      "version": "4.23.0",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.0.tgz",
+      "integrity": "sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==",
       "requires": {
-        "caniuse-lite": "^1.0.30001370",
-        "electron-to-chromium": "^1.4.202",
-        "node-releases": "^2.0.6",
-        "update-browserslist-db": "^1.0.5"
+        "caniuse-lite": "^1.0.30001587",
+        "electron-to-chromium": "^1.4.668",
+        "node-releases": "^2.0.14",
+        "update-browserslist-db": "^1.0.13"
       }
     },
     "buffer-from": {
@@ -15387,9 +15579,9 @@
       }
     },
     "caniuse-lite": {
-      "version": "1.0.30001373",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001373.tgz",
-      "integrity": "sha512-pJYArGHrPp3TUqQzFYRmP/lwJlj8RCbVe3Gd3eJQkAV8SAC6b19XS9BjMvRdvaS8RMkaTN8ZhoHP6S1y8zzwEQ=="
+      "version": "1.0.30001588",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001588.tgz",
+      "integrity": "sha512-+hVY9jE44uKLkH0SrUTqxjxqNTOWHsbnQDIKjwkZ3lNTzUUVdBLBGXtj/q5Mp5u98r3droaZAewQuEDzjQdZlQ=="
     },
     "ccount": {
       "version": "1.1.0",
@@ -15572,6 +15764,14 @@
       "resolved": "https://registry.npmjs.org/combine-promises/-/combine-promises-1.1.0.tgz",
       "integrity": "sha512-ZI9jvcLDxqwaXEixOhArm3r7ReIivsXkpbyEWyeOhzz1QS0iSgBPnWvEqvIQtYyamGCYA88gFhmUrs9hrrQ0pg=="
     },
+    "combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "requires": {
+        "delayed-stream": "~1.0.0"
+      }
+    },
     "comma-separated-tokens": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz",
@@ -15773,19 +15973,11 @@
       "integrity": "sha512-0QTBSYSUZ6Gq21utGzkfITDylE8jWC9Ne1D2MrhvlsZBI1x39OdDIVbzSqtgMndIy6BlHxBXpMGqzZmnztg2rg=="
     },
     "core-js-compat": {
-      "version": "3.24.1",
-      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.24.1.tgz",
-      "integrity": "sha512-XhdNAGeRnTpp8xbD+sR/HFDK9CbeeeqXT6TuofXh3urqEevzkWmLRgrVoykodsw8okqo2pu1BOmuCKrHx63zdw==",
+      "version": "3.36.0",
+      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.36.0.tgz",
+      "integrity": "sha512-iV9Pd/PsgjNWBXeq8XRtWVSgz2tKAfhfvBs7qxYty+RlRd+OCksaWmOnc4JKrTc1cToXL1N0s3l/vwlxPtdElw==",
       "requires": {
-        "browserslist": "^4.21.3",
-        "semver": "7.0.0"
-      },
-      "dependencies": {
-        "semver": {
-          "version": "7.0.0",
-          "resolved": "https://registry.npmjs.org/semver/-/semver-7.0.0.tgz",
-          "integrity": "sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A=="
-        }
+        "browserslist": "^4.22.3"
       }
     },
     "core-js-pure": {
@@ -16081,6 +16273,11 @@
         "slash": "^3.0.0"
       }
     },
+    "delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="
+    },
     "depd": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
@@ -16259,9 +16456,9 @@
       "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
     },
     "electron-to-chromium": {
-      "version": "1.4.210",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.210.tgz",
-      "integrity": "sha512-kSiX4tuyZijV7Cz0MWVmGT8K2siqaOA4Z66K5dCttPPRh0HicOcOAEj1KlC8O8J1aOS/1M8rGofOzksLKaHWcQ=="
+      "version": "1.4.679",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.679.tgz",
+      "integrity": "sha512-NhQMsz5k0d6m9z3qAxnsOR/ebal4NAGsrNVRwcDo4Kc/zQ7KdsTKZUxZoygHcVRb0QDW3waEDIcE3isZ79RP6g=="
     },
     "emoji-regex": {
       "version": "9.2.2",
@@ -16319,9 +16516,9 @@
       "integrity": "sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ=="
     },
     "escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw=="
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
+      "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA=="
     },
     "escape-goat": {
       "version": "2.1.1",
@@ -16378,9 +16575,9 @@
       "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="
     },
     "eta": {
-      "version": "1.12.3",
-      "resolved": "https://registry.npmjs.org/eta/-/eta-1.12.3.tgz",
-      "integrity": "sha512-qHixwbDLtekO/d51Yr4glcaUJCIjGVJyTzuqV4GPlgZo1YpgOKG+avQynErZIYrfM6JIJdtiG2Kox8tbb+DoGg=="
+      "version": "1.14.2",
+      "resolved": "https://registry.npmjs.org/eta/-/eta-1.14.2.tgz",
+      "integrity": "sha512-wZmJAV7EFUG5W8XNXSazIdichnWEhGB1OWg4tnXWPj0CPNUcFdgorGNO6N9p6WBUgoUe4P0OziJYn1+6zxP2aQ=="
     },
     "etag": {
       "version": "1.8.1",
@@ -16696,9 +16893,9 @@
       }
     },
     "follow-redirects": {
-      "version": "1.15.1",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.1.tgz",
-      "integrity": "sha512-yLAMQs+k0b2m7cVxpS1VKJVvoz7SS9Td1zss3XRwXj+ZDH00RJgnuLx7E44wx02kQLrdM3aOOy+FpzS7+8OizA=="
+      "version": "1.15.5",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.5.tgz",
+      "integrity": "sha512-vSFWUON1B+yAw1VN4xMfxgn5fTUiaOzAJCKBwIIgT/+7CuGy9+r+5gITvP62j3RmaD5Ph65UaERdOSRGUzZtgw=="
     },
     "fork-ts-checker-webpack-plugin": {
       "version": "6.5.2",
@@ -16760,6 +16957,16 @@
         }
       }
     },
+    "form-data": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "requires": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      }
+    },
     "forwarded": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -18018,9 +18225,9 @@
       }
     },
     "nanoid": {
-      "version": "3.3.4",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.4.tgz",
-      "integrity": "sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw=="
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz",
+      "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g=="
     },
     "negotiator": {
       "version": "0.6.3",
@@ -18063,9 +18270,9 @@
       "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA=="
     },
     "node-releases": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz",
-      "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg=="
+      "version": "2.0.14",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz",
+      "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw=="
     },
     "normalize-path": {
       "version": "3.0.0",
@@ -18413,11 +18620,11 @@
       }
     },
     "postcss": {
-      "version": "8.4.14",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.14.tgz",
-      "integrity": "sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==",
+      "version": "8.4.35",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.35.tgz",
+      "integrity": "sha512-u5U8qYpBCpN13BsiEB0CbR1Hhh4Gc0zLFuedrHJKMctHCHAGrMdG0PRM/KErzAL3CU6/eckEtmHNB3x6e3c0vA==",
       "requires": {
-        "nanoid": "^3.3.4",
+        "nanoid": "^3.3.7",
         "picocolors": "^1.0.0",
         "source-map-js": "^1.0.2"
       }
@@ -18827,6 +19034,11 @@
         }
       }
     },
+    "proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
     "pump": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
@@ -20478,9 +20690,9 @@
       "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="
     },
     "update-browserslist-db": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.5.tgz",
-      "integrity": "sha512-dteFFpCyvuDdr9S/ff1ISkKt/9YZxKjI9WlRR99c180GaztJtRa/fn18FdxGVKVsnPY7/a/FDN68mcvUmP4U7Q==",
+      "version": "1.0.13",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz",
+      "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==",
       "requires": {
         "escalade": "^3.1.1",
         "picocolors": "^1.0.0"
@@ -20715,6 +20927,16 @@
         "lodash": "^4.17.21",
         "minimist": "^1.2.5",
         "rxjs": "^7.5.4"
+      },
+      "dependencies": {
+        "axios": {
+          "version": "0.25.0",
+          "resolved": "https://registry.npmjs.org/axios/-/axios-0.25.0.tgz",
+          "integrity": "sha512-cD8FOb0tRH3uuEe6+evtAbgJtfxr7ly3fQjYcMcuPlgkwVS9xboaVIpcDV+cYQe+yGykgwZCs1pzjntcGa6l5g==",
+          "requires": {
+            "follow-redirects": "^1.14.7"
+          }
+        }
       }
     },
     "watchpack": {
diff --git a/website/package.json b/website/package.json
index 6c4eaaf2a15f4..cc3358699adda 100644
--- a/website/package.json
+++ b/website/package.json
@@ -18,6 +18,7 @@
     "@docusaurus/plugin-google-gtag": "^2.0.1",
     "@docusaurus/preset-classic": "2.0.1",
     "@mdx-js/react": "^1.6.22",
+    "axios": "^0.28.0",
     "clsx": "^1.2.1",
     "prism-react-renderer": "^1.3.5",
     "react": "^17.0.2",
diff --git a/website/src/components/VeloxConBanner/index.js b/website/src/components/VeloxConBanner/index.js
new file mode 100644
index 0000000000000..3bd4a15b89b0e
--- /dev/null
+++ b/website/src/components/VeloxConBanner/index.js
@@ -0,0 +1,23 @@
+import React from 'react';
+import clsx from 'clsx';
+import styles from './styles.module.css';
+import useBaseUrl from "@docusaurus/useBaseUrl";
+
+
+
+export default function VeloxConBanner() {
+  return (
+    <section className={styles.banner}>
+      <div className="container">
+        <div className="row">
+          <div className="col col--9">
+            <h2>See the VeloxCon 2024 Recordings</h2>
+          </div>
+          <div className="col col--3">
+            <a className="button button--info button--lg" href="https://www.youtube.com/playlist?list=PLJvBe8nQAEsEBSoUY0lRFVZr2_YeHYkUR" target="_blank" rel="noopener noreferrer">Watch</a>
+          </div>
+        </div>
+      </div>
+    </section>
+  );
+}
diff --git a/website/src/components/VeloxConBanner/styles.module.css b/website/src/components/VeloxConBanner/styles.module.css
new file mode 100644
index 0000000000000..f670fe2fc7da9
--- /dev/null
+++ b/website/src/components/VeloxConBanner/styles.module.css
@@ -0,0 +1,20 @@
+.banner {
+  display: flex;
+  align-items: center;
+  padding: 1rem 0;
+  width: 100%;
+  background: url("/static/img/banner-pattern.svg") center center #143d99;
+  color: #fff;
+}
+
+.banner >div>div {
+  max-width: 600px;
+  justify-content: space-around;
+  align-items: center;
+  margin: 0 auto;
+  text-align:center;
+}
+
+.banner h2, .banner p {
+  margin-bottom: 5px;
+}
diff --git a/website/src/pages/index.js b/website/src/pages/index.js
index ba4660e44b70e..989dccf7d4065 100644
--- a/website/src/pages/index.js
+++ b/website/src/pages/index.js
@@ -4,6 +4,7 @@ import Link from '@docusaurus/Link';
 import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
 import Layout from '@theme/Layout';
 import HomepageFeatures from '@site/src/components/HomepageFeatures';
+import VeloxConBanner from '@site/src/components/VeloxConBanner';
 import useBaseUrl from '@docusaurus/useBaseUrl';
 
 import styles from './index.module.css';
@@ -52,6 +53,7 @@ export default function Home() {
       description="Description will go into a meta tag in <head />">
       <HomepageHeader />
       <main>
+          <VeloxConBanner />
           <section className={styles.features}>
               <div className="container">
                   <div className="row">
diff --git a/website/static/img/abstract-white-background.jpg b/website/static/img/abstract-white-background.jpg
new file mode 100644
index 0000000000000..c6b60317fa19c
Binary files /dev/null and b/website/static/img/abstract-white-background.jpg differ
diff --git a/website/static/img/banner-pattern.svg b/website/static/img/banner-pattern.svg
new file mode 100644
index 0000000000000..44c0b038939fb
--- /dev/null
+++ b/website/static/img/banner-pattern.svg
@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Layer_2" data-name="Layer 2" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 1675 1450">
+  <defs>
+    <style>
+      .cls-1 {
+        clip-path: url(#clippath);
+      }
+
+      .cls-2 {
+        stroke-width: 0px;
+      }
+
+      .cls-2, .cls-3 {
+        fill: none;
+      }
+
+      .cls-3 {
+        opacity: .15;
+        stroke: #fff;
+        stroke-miterlimit: 10;
+        stroke-width: 10px;
+      }
+    </style>
+    <clipPath id="clippath">
+      <rect class="cls-2" width="1675" height="1450"/>
+    </clipPath>
+  </defs>
+  <g id="Layer_1-2" data-name="Layer 1">
+    <g class="cls-1">
+      <polygon class="cls-3" points="418.75 243.73 418.75 -238.66 0 -479.85 -418.75 -238.66 -418.75 243.73 0 484.92 418.75 243.73"/>
+      <polygon class="cls-3" points="1256.25 243.73 1256.25 -238.66 837.5 -479.85 418.75 -238.66 418.75 243.73 837.5 484.92 1256.25 243.73"/>
+      <polygon class="cls-3" points="2093.75 243.73 2093.75 -238.66 1675 -479.85 1256.25 -238.66 1256.25 243.73 1675 484.92 2093.75 243.73"/>
+      <polygon class="cls-3" points="418.75 1690.9 418.75 1208.51 0 967.31 -418.75 1208.51 -418.75 1690.9 0 1932.09 418.75 1690.9"/>
+      <polygon class="cls-3" points="1256.25 1690.9 1256.25 1208.51 837.5 967.31 418.75 1208.51 418.75 1690.9 837.5 1932.09 1256.25 1690.9"/>
+      <polygon class="cls-3" points="2093.75 1690.9 2093.75 1208.51 1675 967.31 1256.25 1208.51 1256.25 1690.9 1675 1932.09 2093.75 1690.9"/>
+      <polygon class="cls-3" points="0 967.31 0 484.92 -418.75 243.73 -837.5 484.92 -837.5 967.31 -418.75 1208.51 0 967.31"/>
+      <polygon class="cls-3" points="837.5 967.31 837.5 484.92 418.75 243.73 0 484.92 0 967.31 418.75 1208.51 837.5 967.31"/>
+      <polygon class="cls-3" points="1675 967.31 1675 484.92 1256.25 243.73 837.5 484.92 837.5 967.31 1256.25 1208.51 1675 967.31"/>
+      <polygon class="cls-3" points="2512.5 967.31 2512.5 484.92 2093.75 243.73 1675 484.92 1675 967.31 2093.75 1208.51 2512.5 967.31"/>
+      <line class="cls-3" x1="1256.25" y1="726.12" x2="1465.63" y2="605.52"/>
+      <line class="cls-3" x1="1046.88" y1="605.52" x2="1256.25" y2="726.12"/>
+      <line class="cls-3" x1="1256.25" y1="967.31" x2="1256.25" y2="726.12"/>
+      <line class="cls-3" x1="418.75" y1="726.12" x2="628.13" y2="605.52"/>
+      <line class="cls-3" x1="209.38" y1="605.52" x2="418.75" y2="726.12"/>
+      <line class="cls-3" x1="418.75" y1="967.31" x2="418.75" y2="726.12"/>
+      <g>
+        <line class="cls-3" x1="1675" y1="967.31" x2="1884.38" y2="846.72"/>
+        <line class="cls-3" x1="1465.63" y1="846.72" x2="1675" y2="967.31"/>
+        <line class="cls-3" x1="1675" y1="1208.51" x2="1675" y2="967.31"/>
+      </g>
+      <g>
+        <line class="cls-3" x1="837.5" y1="967.31" x2="1046.88" y2="846.72"/>
+        <line class="cls-3" x1="628.13" y1="846.72" x2="837.5" y2="967.31"/>
+        <line class="cls-3" x1="837.5" y1="1208.51" x2="837.5" y2="967.31"/>
+      </g>
+      <g>
+        <line class="cls-3" x1="0" y1="967.31" x2="209.38" y2="846.72"/>
+        <line class="cls-3" x1="-209.37" y1="846.72" x2="0" y2="967.31"/>
+        <line class="cls-3" x1="0" y1="1208.51" x2="0" y2="967.31"/>
+      </g>
+      <g>
+        <line class="cls-3" x1="1256.25" y1="243.73" x2="1465.62" y2="123.13"/>
+        <line class="cls-3" x1="1046.87" y1="123.13" x2="1256.25" y2="243.73"/>
+        <line class="cls-3" x1="1256.25" y1="484.92" x2="1256.25" y2="243.73"/>
+      </g>
+      <g>
+        <line class="cls-3" x1="418.75" y1="243.73" x2="628.13" y2="123.13"/>
+        <line class="cls-3" x1="209.38" y1="123.13" x2="418.75" y2="243.73"/>
+        <line class="cls-3" x1="418.75" y1="484.92" x2="418.75" y2="243.73"/>
+      </g>
+      <g>
+        <line class="cls-3" x1="837.5" x2="1046.87" y2="-120.6"/>
+        <line class="cls-3" x1="628.12" y1="-120.6" x2="837.5"/>
+        <line class="cls-3" x1="837.5" y1="241.19" x2="837.5"/>
+      </g>
+      <g>
+        <line class="cls-3" x1="1675" x2="1884.37" y2="-120.6"/>
+        <line class="cls-3" x1="1465.62" y1="-120.6" x2="1675"/>
+        <line class="cls-3" x1="1675" y1="241.19" x2="1675"/>
+      </g>
+      <g>
+        <line class="cls-3" x2="209.37" y2="-120.6"/>
+        <line class="cls-3" x1="-209.38" y1="-120.6"/>
+        <line class="cls-3" x1="0" y1="241.19"/>
+      </g>
+      <g>
+        <line class="cls-3" x1="837.5" y1="1450" x2="1046.87" y2="1329.4"/>
+        <line class="cls-3" x1="628.12" y1="1329.4" x2="837.5" y2="1450"/>
+        <line class="cls-3" x1="837.5" y1="1691.19" x2="837.5" y2="1450"/>
+      </g>
+      <g>
+        <line class="cls-3" x1="1675" y1="1450" x2="1884.37" y2="1329.4"/>
+        <line class="cls-3" x1="1465.62" y1="1329.4" x2="1675" y2="1450"/>
+        <line class="cls-3" x1="1675" y1="1691.19" x2="1675" y2="1450"/>
+      </g>
+      <g>
+        <line class="cls-3" y1="1450" x2="209.37" y2="1329.4"/>
+        <line class="cls-3" x1="-209.38" y1="1329.4" y2="1450"/>
+        <line class="cls-3" x1="0" y1="1691.19" y2="1450"/>
+      </g>
+    </g>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/website/static/img/optimize-try-more-numSilentThrow.png b/website/static/img/optimize-try-more-numSilentThrow.png
new file mode 100644
index 0000000000000..9936889812b4d
Binary files /dev/null and b/website/static/img/optimize-try-more-numSilentThrow.png differ
diff --git a/website/static/img/optimize-try-more-profile1.png b/website/static/img/optimize-try-more-profile1.png
new file mode 100644
index 0000000000000..9aa07e7883d5b
Binary files /dev/null and b/website/static/img/optimize-try-more-profile1.png differ
diff --git a/website/static/img/optimize-try-more-profile2.png b/website/static/img/optimize-try-more-profile2.png
new file mode 100644
index 0000000000000..43dad81f7c0fb
Binary files /dev/null and b/website/static/img/optimize-try-more-profile2.png differ
diff --git a/website/static/img/optimize-try-more-profile3.png b/website/static/img/optimize-try-more-profile3.png
new file mode 100644
index 0000000000000..dfe5c0bb05dae
Binary files /dev/null and b/website/static/img/optimize-try-more-profile3.png differ
diff --git a/website/static/img/velox-build-metrics.png b/website/static/img/velox-build-metrics.png
new file mode 100644
index 0000000000000..f3ee4694448ee
Binary files /dev/null and b/website/static/img/velox-build-metrics.png differ
diff --git a/website/yarn.lock b/website/yarn.lock
new file mode 100644
index 0000000000000..533e1189d4e8b
--- /dev/null
+++ b/website/yarn.lock
@@ -0,0 +1,7961 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@algolia/autocomplete-core@1.9.3":
+  version "1.9.3"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-core/-/autocomplete-core-1.9.3.tgz#1d56482a768c33aae0868c8533049e02e8961be7"
+  integrity sha512-009HdfugtGCdC4JdXUbVJClA0q0zh24yyePn+KUGk3rP7j8FEe/m5Yo/z65gn6nP/cM39PxpzqKrL7A6fP6PPw==
+  dependencies:
+    "@algolia/autocomplete-plugin-algolia-insights" "1.9.3"
+    "@algolia/autocomplete-shared" "1.9.3"
+
+"@algolia/autocomplete-plugin-algolia-insights@1.9.3":
+  version "1.9.3"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.9.3.tgz#9b7f8641052c8ead6d66c1623d444cbe19dde587"
+  integrity sha512-a/yTUkcO/Vyy+JffmAnTWbr4/90cLzw+CC3bRbhnULr/EM0fGNvM13oQQ14f2moLMcVDyAx/leczLlAOovhSZg==
+  dependencies:
+    "@algolia/autocomplete-shared" "1.9.3"
+
+"@algolia/autocomplete-preset-algolia@1.9.3":
+  version "1.9.3"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.9.3.tgz#64cca4a4304cfcad2cf730e83067e0c1b2f485da"
+  integrity sha512-d4qlt6YmrLMYy95n5TB52wtNDr6EgAIPH81dvvvW8UmuWRgxEtY0NJiPwl/h95JtG2vmRM804M0DSwMCNZlzRA==
+  dependencies:
+    "@algolia/autocomplete-shared" "1.9.3"
+
+"@algolia/autocomplete-shared@1.9.3":
+  version "1.9.3"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-shared/-/autocomplete-shared-1.9.3.tgz#2e22e830d36f0a9cf2c0ccd3c7f6d59435b77dfa"
+  integrity sha512-Wnm9E4Ye6Rl6sTTqjoymD+l8DjSTHsHboVRYrKgEt8Q7UHm9nYbqhN/i0fhUYA3OAEH7WA8x3jfpnmJm3rKvaQ==
+
+"@algolia/cache-browser-local-storage@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.22.1.tgz#14b6dc9abc9e3a304a5fffb063d15f30af1032d1"
+  integrity sha512-Sw6IAmOCvvP6QNgY9j+Hv09mvkvEIDKjYW8ow0UDDAxSXy664RBNQk3i/0nt7gvceOJ6jGmOTimaZoY1THmU7g==
+  dependencies:
+    "@algolia/cache-common" "4.22.1"
+
+"@algolia/cache-common@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/cache-common/-/cache-common-4.22.1.tgz#c625dff4bc2a74e79f9aed67b4e053b0ef1b3ec1"
+  integrity sha512-TJMBKqZNKYB9TptRRjSUtevJeQVXRmg6rk9qgFKWvOy8jhCPdyNZV1nB3SKGufzvTVbomAukFR8guu/8NRKBTA==
+
+"@algolia/cache-in-memory@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/cache-in-memory/-/cache-in-memory-4.22.1.tgz#858a3d887f521362e87d04f3943e2810226a0d71"
+  integrity sha512-ve+6Ac2LhwpufuWavM/aHjLoNz/Z/sYSgNIXsinGofWOysPilQZPUetqLj8vbvi+DHZZaYSEP9H5SRVXnpsNNw==
+  dependencies:
+    "@algolia/cache-common" "4.22.1"
+
+"@algolia/client-account@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/client-account/-/client-account-4.22.1.tgz#a7fb8b66b9a4f0a428e1426b2561144267d76d43"
+  integrity sha512-k8m+oegM2zlns/TwZyi4YgCtyToackkOpE+xCaKCYfBfDtdGOaVZCM5YvGPtK+HGaJMIN/DoTL8asbM3NzHonw==
+  dependencies:
+    "@algolia/client-common" "4.22.1"
+    "@algolia/client-search" "4.22.1"
+    "@algolia/transporter" "4.22.1"
+
+"@algolia/client-analytics@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/client-analytics/-/client-analytics-4.22.1.tgz#506558740b4d49b1b1e3393861f729a8ce921851"
+  integrity sha512-1ssi9pyxyQNN4a7Ji9R50nSdISIumMFDwKNuwZipB6TkauJ8J7ha/uO60sPJFqQyqvvI+px7RSNRQT3Zrvzieg==
+  dependencies:
+    "@algolia/client-common" "4.22.1"
+    "@algolia/client-search" "4.22.1"
+    "@algolia/requester-common" "4.22.1"
+    "@algolia/transporter" "4.22.1"
+
+"@algolia/client-common@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/client-common/-/client-common-4.22.1.tgz#042b19c1b6157c485fa1b551349ab313944d2b05"
+  integrity sha512-IvaL5v9mZtm4k4QHbBGDmU3wa/mKokmqNBqPj0K7lcR8ZDKzUorhcGp/u8PkPC/e0zoHSTvRh7TRkGX3Lm7iOQ==
+  dependencies:
+    "@algolia/requester-common" "4.22.1"
+    "@algolia/transporter" "4.22.1"
+
+"@algolia/client-personalization@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/client-personalization/-/client-personalization-4.22.1.tgz#ff088d797648224fb582e9fe5828f8087835fa3d"
+  integrity sha512-sl+/klQJ93+4yaqZ7ezOttMQ/nczly/3GmgZXJ1xmoewP5jmdP/X/nV5U7EHHH3hCUEHeN7X1nsIhGPVt9E1cQ==
+  dependencies:
+    "@algolia/client-common" "4.22.1"
+    "@algolia/requester-common" "4.22.1"
+    "@algolia/transporter" "4.22.1"
+
+"@algolia/client-search@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/client-search/-/client-search-4.22.1.tgz#508cc6ab3d1f4e9c02735a630d4dff6fbb8514a2"
+  integrity sha512-yb05NA4tNaOgx3+rOxAmFztgMTtGBi97X7PC3jyNeGiwkAjOZc2QrdZBYyIdcDLoI09N0gjtpClcackoTN0gPA==
+  dependencies:
+    "@algolia/client-common" "4.22.1"
+    "@algolia/requester-common" "4.22.1"
+    "@algolia/transporter" "4.22.1"
+
+"@algolia/events@^4.0.1":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@algolia/events/-/events-4.0.1.tgz#fd39e7477e7bc703d7f893b556f676c032af3950"
+  integrity sha512-FQzvOCgoFXAbf5Y6mYozw2aj5KCJoA3m4heImceldzPSMbdyS4atVjJzXKMsfX3wnZTFYwkkt8/z8UesLHlSBQ==
+
+"@algolia/logger-common@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/logger-common/-/logger-common-4.22.1.tgz#79cf4cd295de0377a94582c6aaac59b1ded731d9"
+  integrity sha512-OnTFymd2odHSO39r4DSWRFETkBufnY2iGUZNrMXpIhF5cmFE8pGoINNPzwg02QLBlGSaLqdKy0bM8S0GyqPLBg==
+
+"@algolia/logger-console@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/logger-console/-/logger-console-4.22.1.tgz#0355345f6940f67aaa78ae9b81c06e44e49f2336"
+  integrity sha512-O99rcqpVPKN1RlpgD6H3khUWylU24OXlzkavUAMy6QZd1776QAcauE3oP8CmD43nbaTjBexZj2nGsBH9Tc0FVA==
+  dependencies:
+    "@algolia/logger-common" "4.22.1"
+
+"@algolia/requester-browser-xhr@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.22.1.tgz#f04df6fe9690a071b267c77d26b83a3be9280361"
+  integrity sha512-dtQGYIg6MteqT1Uay3J/0NDqD+UciHy3QgRbk7bNddOJu+p3hzjTRYESqEnoX/DpEkaNYdRHUKNylsqMpgwaEw==
+  dependencies:
+    "@algolia/requester-common" "4.22.1"
+
+"@algolia/requester-common@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-common/-/requester-common-4.22.1.tgz#27be35f3718aafcb6b388ff9c3aa2defabd559ff"
+  integrity sha512-dgvhSAtg2MJnR+BxrIFqlLtkLlVVhas9HgYKMk2Uxiy5m6/8HZBL40JVAMb2LovoPFs9I/EWIoFVjOrFwzn5Qg==
+
+"@algolia/requester-node-http@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-node-http/-/requester-node-http-4.22.1.tgz#589a6fa828ad0f325e727a6fcaf4e1a2343cc62b"
+  integrity sha512-JfmZ3MVFQkAU+zug8H3s8rZ6h0ahHZL/SpMaSasTCGYR5EEJsCc8SI5UZ6raPN2tjxa5bxS13BRpGSBUens7EA==
+  dependencies:
+    "@algolia/requester-common" "4.22.1"
+
+"@algolia/transporter@4.22.1":
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/@algolia/transporter/-/transporter-4.22.1.tgz#8843841b857dc021668f31647aa557ff19cd9cb1"
+  integrity sha512-kzWgc2c9IdxMa3YqA6TN0NW5VrKYYW/BELIn7vnLyn+U/RFdZ4lxxt9/8yq3DKV5snvoDzzO4ClyejZRdV3lMQ==
+  dependencies:
+    "@algolia/cache-common" "4.22.1"
+    "@algolia/logger-common" "4.22.1"
+    "@algolia/requester-common" "4.22.1"
+
+"@ampproject/remapping@^2.2.0":
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.1.tgz#99e8e11851128b8702cd57c33684f1d0f260b630"
+  integrity sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==
+  dependencies:
+    "@jridgewell/gen-mapping" "^0.3.0"
+    "@jridgewell/trace-mapping" "^0.3.9"
+
+"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.10.4", "@babel/code-frame@^7.16.0", "@babel/code-frame@^7.23.5", "@babel/code-frame@^7.8.3":
+  version "7.23.5"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.23.5.tgz#9009b69a8c602293476ad598ff53e4562e15c244"
+  integrity sha512-CgH3s1a96LipHCmSUmYFPwY7MNx8C3avkq7i4Wl3cfa662ldtUe4VM1TPXX70pfmrlWTb6jLqTYrZyT2ZTJBgA==
+  dependencies:
+    "@babel/highlight" "^7.23.4"
+    chalk "^2.4.2"
+
+"@babel/compat-data@^7.22.6", "@babel/compat-data@^7.23.3", "@babel/compat-data@^7.23.5":
+  version "7.23.5"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.23.5.tgz#ffb878728bb6bdcb6f4510aa51b1be9afb8cfd98"
+  integrity sha512-uU27kfDRlhfKl+w1U6vp16IuvSLtjAxdArVXPa9BvLkrr7CYIsxH5adpHObeAGY/41+syctUWOZ140a2Rvkgjw==
+
+"@babel/core@7.12.9":
+  version "7.12.9"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.12.9.tgz#fd450c4ec10cdbb980e2928b7aa7a28484593fc8"
+  integrity sha512-gTXYh3M5wb7FRXQy+FErKFAv90BnlOuNn1QkCK2lREoPAjrQCO49+HVSrFoe5uakFAF5eenS75KbO2vQiLrTMQ==
+  dependencies:
+    "@babel/code-frame" "^7.10.4"
+    "@babel/generator" "^7.12.5"
+    "@babel/helper-module-transforms" "^7.12.1"
+    "@babel/helpers" "^7.12.5"
+    "@babel/parser" "^7.12.7"
+    "@babel/template" "^7.12.7"
+    "@babel/traverse" "^7.12.9"
+    "@babel/types" "^7.12.7"
+    convert-source-map "^1.7.0"
+    debug "^4.1.0"
+    gensync "^1.0.0-beta.1"
+    json5 "^2.1.2"
+    lodash "^4.17.19"
+    resolve "^1.3.2"
+    semver "^5.4.1"
+    source-map "^0.5.0"
+
+"@babel/core@^7.18.6", "@babel/core@^7.19.6":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.23.9.tgz#b028820718000f267870822fec434820e9b1e4d1"
+  integrity sha512-5q0175NOjddqpvvzU+kDiSOAk4PfdO6FvwCWoQ6RO7rTzEe8vlo+4HVfcnAREhD4npMs0e9uZypjTwzZPCf/cw==
+  dependencies:
+    "@ampproject/remapping" "^2.2.0"
+    "@babel/code-frame" "^7.23.5"
+    "@babel/generator" "^7.23.6"
+    "@babel/helper-compilation-targets" "^7.23.6"
+    "@babel/helper-module-transforms" "^7.23.3"
+    "@babel/helpers" "^7.23.9"
+    "@babel/parser" "^7.23.9"
+    "@babel/template" "^7.23.9"
+    "@babel/traverse" "^7.23.9"
+    "@babel/types" "^7.23.9"
+    convert-source-map "^2.0.0"
+    debug "^4.1.0"
+    gensync "^1.0.0-beta.2"
+    json5 "^2.2.3"
+    semver "^6.3.1"
+
+"@babel/generator@^7.12.5", "@babel/generator@^7.18.7", "@babel/generator@^7.23.6":
+  version "7.23.6"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.23.6.tgz#9e1fca4811c77a10580d17d26b57b036133f3c2e"
+  integrity sha512-qrSfCYxYQB5owCmGLbl8XRpX1ytXlpueOb0N0UmQwA073KZxejgQTzAmJezxvpwQD9uGtK2shHdi55QT+MbjIw==
+  dependencies:
+    "@babel/types" "^7.23.6"
+    "@jridgewell/gen-mapping" "^0.3.2"
+    "@jridgewell/trace-mapping" "^0.3.17"
+    jsesc "^2.5.1"
+
+"@babel/helper-annotate-as-pure@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.22.5.tgz#e7f06737b197d580a01edf75d97e2c8be99d3882"
+  integrity sha512-LvBTxu8bQSQkcyKOU+a1btnNFQ1dMAd0R6PyW3arXes06F6QLWLIrd681bxRPIXlrMGR3XYnW9JyML7dP3qgxg==
+  dependencies:
+    "@babel/types" "^7.22.5"
+
+"@babel/helper-builder-binary-assignment-operator-visitor@^7.22.15":
+  version "7.22.15"
+  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.22.15.tgz#5426b109cf3ad47b91120f8328d8ab1be8b0b956"
+  integrity sha512-QkBXwGgaoC2GtGZRoma6kv7Szfv06khvhFav67ZExau2RaXzy8MpHSMO2PNoP2XtmQphJQRHFfg77Bq731Yizw==
+  dependencies:
+    "@babel/types" "^7.22.15"
+
+"@babel/helper-compilation-targets@^7.22.15", "@babel/helper-compilation-targets@^7.22.6", "@babel/helper-compilation-targets@^7.23.6":
+  version "7.23.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.23.6.tgz#4d79069b16cbcf1461289eccfbbd81501ae39991"
+  integrity sha512-9JB548GZoQVmzrFgp8o7KxdgkTGm6xs9DW0o/Pim72UDjzr5ObUQ6ZzYPqA+g9OTS2bBQoctLJrky0RDCAWRgQ==
+  dependencies:
+    "@babel/compat-data" "^7.23.5"
+    "@babel/helper-validator-option" "^7.23.5"
+    browserslist "^4.22.2"
+    lru-cache "^5.1.1"
+    semver "^6.3.1"
+
+"@babel/helper-create-class-features-plugin@^7.22.15", "@babel/helper-create-class-features-plugin@^7.23.6":
+  version "7.23.10"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.23.10.tgz#25d55fafbaea31fd0e723820bb6cc3df72edf7ea"
+  integrity sha512-2XpP2XhkXzgxecPNEEK8Vz8Asj9aRxt08oKOqtiZoqV2UGZ5T+EkyP9sXQ9nwMxBIG34a7jmasVqoMop7VdPUw==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.22.5"
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-function-name" "^7.23.0"
+    "@babel/helper-member-expression-to-functions" "^7.23.0"
+    "@babel/helper-optimise-call-expression" "^7.22.5"
+    "@babel/helper-replace-supers" "^7.22.20"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
+    "@babel/helper-split-export-declaration" "^7.22.6"
+    semver "^6.3.1"
+
+"@babel/helper-create-regexp-features-plugin@^7.18.6", "@babel/helper-create-regexp-features-plugin@^7.22.15", "@babel/helper-create-regexp-features-plugin@^7.22.5":
+  version "7.22.15"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.22.15.tgz#5ee90093914ea09639b01c711db0d6775e558be1"
+  integrity sha512-29FkPLFjn4TPEa3RE7GpW+qbE8tlsu3jntNYNfcGsc49LphF1PQIiD+vMZ1z1xVOKt+93khA9tc2JBs3kBjA7w==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.22.5"
+    regexpu-core "^5.3.1"
+    semver "^6.3.1"
+
+"@babel/helper-define-polyfill-provider@^0.5.0":
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.5.0.tgz#465805b7361f461e86c680f1de21eaf88c25901b"
+  integrity sha512-NovQquuQLAQ5HuyjCz7WQP9MjRj7dx++yspwiyUiGl9ZyadHRSql1HZh5ogRd8W8w6YM6EQ/NTB8rgjLt5W65Q==
+  dependencies:
+    "@babel/helper-compilation-targets" "^7.22.6"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    debug "^4.1.1"
+    lodash.debounce "^4.0.8"
+    resolve "^1.14.2"
+
+"@babel/helper-environment-visitor@^7.22.20":
+  version "7.22.20"
+  resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.20.tgz#96159db61d34a29dba454c959f5ae4a649ba9167"
+  integrity sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==
+
+"@babel/helper-function-name@^7.22.5", "@babel/helper-function-name@^7.23.0":
+  version "7.23.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.23.0.tgz#1f9a3cdbd5b2698a670c30d2735f9af95ed52759"
+  integrity sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==
+  dependencies:
+    "@babel/template" "^7.22.15"
+    "@babel/types" "^7.23.0"
+
+"@babel/helper-hoist-variables@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz#c01a007dac05c085914e8fb652b339db50d823bb"
+  integrity sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==
+  dependencies:
+    "@babel/types" "^7.22.5"
+
+"@babel/helper-member-expression-to-functions@^7.22.15", "@babel/helper-member-expression-to-functions@^7.23.0":
+  version "7.23.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.23.0.tgz#9263e88cc5e41d39ec18c9a3e0eced59a3e7d366"
+  integrity sha512-6gfrPwh7OuT6gZyJZvd6WbTfrqAo7vm4xCzAXOusKqq/vWdKXphTpj5klHKNmRUU6/QRGlBsyU9mAIPaWHlqJA==
+  dependencies:
+    "@babel/types" "^7.23.0"
+
+"@babel/helper-module-imports@^7.22.15":
+  version "7.22.15"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.22.15.tgz#16146307acdc40cc00c3b2c647713076464bdbf0"
+  integrity sha512-0pYVBnDKZO2fnSPCrgM/6WMc7eS20Fbok+0r88fp+YtWVLZrp4CkafFGIp+W0VKw4a22sgebPT99y+FDNMdP4w==
+  dependencies:
+    "@babel/types" "^7.22.15"
+
+"@babel/helper-module-transforms@^7.12.1", "@babel/helper-module-transforms@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.23.3.tgz#d7d12c3c5d30af5b3c0fcab2a6d5217773e2d0f1"
+  integrity sha512-7bBs4ED9OmswdfDzpz4MpWgSrV7FXlc3zIagvLFjS5H+Mk7Snr21vQ6QwrsoCGMfNC4e4LQPdoULEt4ykz0SRQ==
+  dependencies:
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-module-imports" "^7.22.15"
+    "@babel/helper-simple-access" "^7.22.5"
+    "@babel/helper-split-export-declaration" "^7.22.6"
+    "@babel/helper-validator-identifier" "^7.22.20"
+
+"@babel/helper-optimise-call-expression@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.22.5.tgz#f21531a9ccbff644fdd156b4077c16ff0c3f609e"
+  integrity sha512-HBwaojN0xFRx4yIvpwGqxiV2tUfl7401jlok564NgB9EHS1y6QT17FmKWm4ztqjeVdXLuC4fSvHc5ePpQjoTbw==
+  dependencies:
+    "@babel/types" "^7.22.5"
+
+"@babel/helper-plugin-utils@7.10.4":
+  version "7.10.4"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.10.4.tgz#2f75a831269d4f677de49986dff59927533cf375"
+  integrity sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg==
+
+"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.18.6", "@babel/helper-plugin-utils@^7.22.5", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
+  version "7.22.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz#dd7ee3735e8a313b9f7b05a773d892e88e6d7295"
+  integrity sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==
+
+"@babel/helper-remap-async-to-generator@^7.22.20":
+  version "7.22.20"
+  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.22.20.tgz#7b68e1cb4fa964d2996fd063723fb48eca8498e0"
+  integrity sha512-pBGyV4uBqOns+0UvhsTO8qgl8hO89PmiDYv+/COyp1aeMcmfrfruz+/nCMFiYyFF/Knn0yfrC85ZzNFjembFTw==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.22.5"
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-wrap-function" "^7.22.20"
+
+"@babel/helper-replace-supers@^7.22.20":
+  version "7.22.20"
+  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.22.20.tgz#e37d367123ca98fe455a9887734ed2e16eb7a793"
+  integrity sha512-qsW0In3dbwQUbK8kejJ4R7IHVGwHJlV6lpG6UA7a9hSa2YEiAib+N1T2kr6PEeUT+Fl7najmSOS6SmAwCHK6Tw==
+  dependencies:
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-member-expression-to-functions" "^7.22.15"
+    "@babel/helper-optimise-call-expression" "^7.22.5"
+
+"@babel/helper-simple-access@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz#4938357dc7d782b80ed6dbb03a0fba3d22b1d5de"
+  integrity sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==
+  dependencies:
+    "@babel/types" "^7.22.5"
+
+"@babel/helper-skip-transparent-expression-wrappers@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.22.5.tgz#007f15240b5751c537c40e77abb4e89eeaaa8847"
+  integrity sha512-tK14r66JZKiC43p8Ki33yLBVJKlQDFoA8GYN67lWCDCqoL6EMMSuM9b+Iff2jHaM/RRFYl7K+iiru7hbRqNx8Q==
+  dependencies:
+    "@babel/types" "^7.22.5"
+
+"@babel/helper-split-export-declaration@^7.22.6":
+  version "7.22.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz#322c61b7310c0997fe4c323955667f18fcefb91c"
+  integrity sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==
+  dependencies:
+    "@babel/types" "^7.22.5"
+
+"@babel/helper-string-parser@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.23.4.tgz#9478c707febcbbe1ddb38a3d91a2e054ae622d83"
+  integrity sha512-803gmbQdqwdf4olxrX4AJyFBV/RTr3rSmOj0rKwesmzlfhYNDEs+/iOcznzpNWlJlIlTJC2QfPFcHB6DlzdVLQ==
+
+"@babel/helper-validator-identifier@^7.22.20":
+  version "7.22.20"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz#c4ae002c61d2879e724581d96665583dbc1dc0e0"
+  integrity sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==
+
+"@babel/helper-validator-option@^7.22.15", "@babel/helper-validator-option@^7.23.5":
+  version "7.23.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.23.5.tgz#907a3fbd4523426285365d1206c423c4c5520307"
+  integrity sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==
+
+"@babel/helper-wrap-function@^7.22.20":
+  version "7.22.20"
+  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.22.20.tgz#15352b0b9bfb10fc9c76f79f6342c00e3411a569"
+  integrity sha512-pms/UwkOpnQe/PDAEdV/d7dVCoBbB+R4FvYoHGZz+4VPcg7RtYy2KP7S2lbuWM6FCSgob5wshfGESbC/hzNXZw==
+  dependencies:
+    "@babel/helper-function-name" "^7.22.5"
+    "@babel/template" "^7.22.15"
+    "@babel/types" "^7.22.19"
+
+"@babel/helpers@^7.12.5", "@babel/helpers@^7.23.9":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.23.9.tgz#c3e20bbe7f7a7e10cb9b178384b4affdf5995c7d"
+  integrity sha512-87ICKgU5t5SzOT7sBMfCOZQ2rHjRU+Pcb9BoILMYz600W6DkVRLFBPwQ18gwUVvggqXivaUakpnxWQGbpywbBQ==
+  dependencies:
+    "@babel/template" "^7.23.9"
+    "@babel/traverse" "^7.23.9"
+    "@babel/types" "^7.23.9"
+
+"@babel/highlight@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.23.4.tgz#edaadf4d8232e1a961432db785091207ead0621b"
+  integrity sha512-acGdbYSfp2WheJoJm/EBBBLh/ID8KDc64ISZ9DYtBmC8/Q204PZJLHyzeB5qMzJ5trcOkybd78M4x2KWsUq++A==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.22.20"
+    chalk "^2.4.2"
+    js-tokens "^4.0.0"
+
+"@babel/parser@^7.12.7", "@babel/parser@^7.18.8", "@babel/parser@^7.23.9":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.23.9.tgz#7b903b6149b0f8fa7ad564af646c4c38a77fc44b"
+  integrity sha512-9tcKgqKbs3xGJ+NtKF2ndOBBLVwPjl1SHxPQkd36r3Dlirw3xWUeGaTbqr7uGZcTaxkVNwc+03SVP7aCdWrTlA==
+
+"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.23.3.tgz#5cd1c87ba9380d0afb78469292c954fee5d2411a"
+  integrity sha512-iRkKcCqb7iGnq9+3G6rZ+Ciz5VywC4XNRHe57lKM+jOeYAoR0lVqdeeDRfh0tQcTfw/+vBhHn926FmQhLtlFLQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.23.3.tgz#f6652bb16b94f8f9c20c50941e16e9756898dc5d"
+  integrity sha512-WwlxbfMNdVEpQjZmK5mhm7oSwD3dS6eU+Iwsi4Knl9wAletWem7kaRsGOG+8UEbRyqxY4SS5zvtfXwX+jMxUwQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
+    "@babel/plugin-transform-optional-chaining" "^7.23.3"
+
+"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@^7.23.7":
+  version "7.23.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.23.7.tgz#516462a95d10a9618f197d39ad291a9b47ae1d7b"
+  integrity sha512-LlRT7HgaifEpQA1ZgLVOIJZZFVPWN5iReq/7/JixwBtwcoeVGDBD53ZV28rrsLYOZs1Y/EHhA8N/Z6aazHR8cw==
+  dependencies:
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-proposal-object-rest-spread@7.12.1":
+  version "7.12.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.12.1.tgz#def9bd03cea0f9b72283dac0ec22d289c7691069"
+  integrity sha512-s6SowJIjzlhx8o7lsFx5zmY4At6CTtDvgNQDdPzkBQucle58A6b/TTeEBYtyDgmcXjUTM+vE8YOGHZzzbc/ioA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.10.4"
+    "@babel/plugin-syntax-object-rest-spread" "^7.8.0"
+    "@babel/plugin-transform-parameters" "^7.12.1"
+
+"@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2":
+  version "7.21.0-placeholder-for-preset-env.2"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz#7844f9289546efa9febac2de4cfe358a050bd703"
+  integrity sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==
+
+"@babel/plugin-syntax-async-generators@^7.8.4":
+  version "7.8.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d"
+  integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.8.0"
+
+"@babel/plugin-syntax-class-properties@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10"
+  integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.12.13"
+
+"@babel/plugin-syntax-class-static-block@^7.14.5":
+  version "7.14.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz#195df89b146b4b78b3bf897fd7a257c84659d406"
+  integrity sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.14.5"
+
+"@babel/plugin-syntax-dynamic-import@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz#62bf98b2da3cd21d626154fc96ee5b3cb68eacb3"
+  integrity sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.8.0"
+
+"@babel/plugin-syntax-export-namespace-from@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz#028964a9ba80dbc094c915c487ad7c4e7a66465a"
+  integrity sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.8.3"
+
+"@babel/plugin-syntax-import-assertions@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.23.3.tgz#9c05a7f592982aff1a2768260ad84bcd3f0c77fc"
+  integrity sha512-lPgDSU+SJLK3xmFDTV2ZRQAiM7UuUjGidwBywFavObCiZc1BeAAcMtHJKUya92hPHO+at63JJPLygilZard8jw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-syntax-import-attributes@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.23.3.tgz#992aee922cf04512461d7dae3ff6951b90a2dc06"
+  integrity sha512-pawnE0P9g10xgoP7yKr6CK63K2FMsTE+FZidZO/1PwRdzmAPVs+HS1mAURUsgaoxammTJvULUdIkEK0gOcU2tA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-syntax-import-meta@^7.10.4":
+  version "7.10.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz#ee601348c370fa334d2207be158777496521fd51"
+  integrity sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.10.4"
+
+"@babel/plugin-syntax-json-strings@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a"
+  integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.8.0"
+
+"@babel/plugin-syntax-jsx@7.12.1":
+  version "7.12.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.12.1.tgz#9d9d357cc818aa7ae7935917c1257f67677a0926"
+  integrity sha512-1yRi7yAtB0ETgxdY9ti/p2TivUxJkTdhu/ZbF9MshVGqOx1TdB3b7xCXs49Fupgg50N45KcAsRP/ZqWjs9SRjg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.10.4"
+
+"@babel/plugin-syntax-jsx@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.23.3.tgz#8f2e4f8a9b5f9aa16067e142c1ac9cd9f810f473"
+  integrity sha512-EB2MELswq55OHUoRZLGg/zC7QWUKfNLpE57m/S2yr1uEneIgsTgrSzXP3NXEsMkVn76OlaVVnzN+ugObuYGwhg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-syntax-logical-assignment-operators@^7.10.4":
+  version "7.10.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699"
+  integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.10.4"
+
+"@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9"
+  integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.8.0"
+
+"@babel/plugin-syntax-numeric-separator@^7.10.4":
+  version "7.10.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97"
+  integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.10.4"
+
+"@babel/plugin-syntax-object-rest-spread@7.8.3", "@babel/plugin-syntax-object-rest-spread@^7.8.0", "@babel/plugin-syntax-object-rest-spread@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871"
+  integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.8.0"
+
+"@babel/plugin-syntax-optional-catch-binding@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1"
+  integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.8.0"
+
+"@babel/plugin-syntax-optional-chaining@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a"
+  integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.8.0"
+
+"@babel/plugin-syntax-private-property-in-object@^7.14.5":
+  version "7.14.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz#0dc6671ec0ea22b6e94a1114f857970cd39de1ad"
+  integrity sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.14.5"
+
+"@babel/plugin-syntax-top-level-await@^7.14.5":
+  version "7.14.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz#c1cfdadc35a646240001f06138247b741c34d94c"
+  integrity sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.14.5"
+
+"@babel/plugin-syntax-typescript@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.23.3.tgz#24f460c85dbbc983cd2b9c4994178bcc01df958f"
+  integrity sha512-9EiNjVJOMwCO+43TqoTrgQ8jMwcAd0sWyXi9RPfIsLTj4R2MADDDQXELhffaUx/uJv2AYcxBgPwH6j4TIA4ytQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-syntax-unicode-sets-regex@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz#d49a3b3e6b52e5be6740022317580234a6a47357"
+  integrity sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.18.6"
+    "@babel/helper-plugin-utils" "^7.18.6"
+
+"@babel/plugin-transform-arrow-functions@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.23.3.tgz#94c6dcfd731af90f27a79509f9ab7fb2120fc38b"
+  integrity sha512-NzQcQrzaQPkaEwoTm4Mhyl8jI1huEL/WWIEvudjTCMJ9aBZNpsJbMASx7EQECtQQPS/DcnFpo0FIh3LvEO9cxQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-async-generator-functions@^7.23.9":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.23.9.tgz#9adaeb66fc9634a586c5df139c6240d41ed801ce"
+  integrity sha512-8Q3veQEDGe14dTYuwagbRtwxQDnytyg1JFu4/HwEMETeofocrB0U0ejBJIXoeG/t2oXZ8kzCyI0ZZfbT80VFNQ==
+  dependencies:
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-remap-async-to-generator" "^7.22.20"
+    "@babel/plugin-syntax-async-generators" "^7.8.4"
+
+"@babel/plugin-transform-async-to-generator@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.23.3.tgz#d1f513c7a8a506d43f47df2bf25f9254b0b051fa"
+  integrity sha512-A7LFsKi4U4fomjqXJlZg/u0ft/n8/7n7lpffUP/ZULx/DtV9SGlNKZolHH6PE8Xl1ngCc0M11OaeZptXVkfKSw==
+  dependencies:
+    "@babel/helper-module-imports" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-remap-async-to-generator" "^7.22.20"
+
+"@babel/plugin-transform-block-scoped-functions@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.23.3.tgz#fe1177d715fb569663095e04f3598525d98e8c77"
+  integrity sha512-vI+0sIaPIO6CNuM9Kk5VmXcMVRiOpDh7w2zZt9GXzmE/9KD70CUEVhvPR/etAeNK/FAEkhxQtXOzVF3EuRL41A==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-block-scoping@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.23.4.tgz#b2d38589531c6c80fbe25e6b58e763622d2d3cf5"
+  integrity sha512-0QqbP6B6HOh7/8iNR4CQU2Th/bbRtBp4KS9vcaZd1fZ0wSh5Fyssg0UCIHwxh+ka+pNDREbVLQnHCMHKZfPwfw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-class-properties@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.23.3.tgz#35c377db11ca92a785a718b6aa4e3ed1eb65dc48"
+  integrity sha512-uM+AN8yCIjDPccsKGlw271xjJtGii+xQIF/uMPS8H15L12jZTsLfF4o5vNO7d/oUguOyfdikHGc/yi9ge4SGIg==
+  dependencies:
+    "@babel/helper-create-class-features-plugin" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-class-static-block@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.23.4.tgz#2a202c8787a8964dd11dfcedf994d36bfc844ab5"
+  integrity sha512-nsWu/1M+ggti1SOALj3hfx5FXzAY06fwPJsUZD4/A5e1bWi46VUIWtD+kOX6/IdhXGsXBWllLFDSnqSCdUNydQ==
+  dependencies:
+    "@babel/helper-create-class-features-plugin" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-class-static-block" "^7.14.5"
+
+"@babel/plugin-transform-classes@^7.23.8":
+  version "7.23.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.23.8.tgz#d08ae096c240347badd68cdf1b6d1624a6435d92"
+  integrity sha512-yAYslGsY1bX6Knmg46RjiCiNSwJKv2IUC8qOdYKqMMr0491SXFhcHqOdRDeCRohOOIzwN/90C6mQ9qAKgrP7dg==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.22.5"
+    "@babel/helper-compilation-targets" "^7.23.6"
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-function-name" "^7.23.0"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-replace-supers" "^7.22.20"
+    "@babel/helper-split-export-declaration" "^7.22.6"
+    globals "^11.1.0"
+
+"@babel/plugin-transform-computed-properties@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.23.3.tgz#652e69561fcc9d2b50ba4f7ac7f60dcf65e86474"
+  integrity sha512-dTj83UVTLw/+nbiHqQSFdwO9CbTtwq1DsDqm3CUEtDrZNET5rT5E6bIdTlOftDTDLMYxvxHNEYO4B9SLl8SLZw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/template" "^7.22.15"
+
+"@babel/plugin-transform-destructuring@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.23.3.tgz#8c9ee68228b12ae3dff986e56ed1ba4f3c446311"
+  integrity sha512-n225npDqjDIr967cMScVKHXJs7rout1q+tt50inyBCPkyZ8KxeI6d+GIbSBTT/w/9WdlWDOej3V9HE5Lgk57gw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-dotall-regex@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.23.3.tgz#3f7af6054882ede89c378d0cf889b854a993da50"
+  integrity sha512-vgnFYDHAKzFaTVp+mneDsIEbnJ2Np/9ng9iviHw3P/KVcgONxpNULEW/51Z/BaFojG2GI2GwwXck5uV1+1NOYQ==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-duplicate-keys@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.23.3.tgz#664706ca0a5dfe8d066537f99032fc1dc8b720ce"
+  integrity sha512-RrqQ+BQmU3Oyav3J+7/myfvRCq7Tbz+kKLLshUmMwNlDHExbGL7ARhajvoBJEvc+fCguPPu887N+3RRXBVKZUA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-dynamic-import@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.23.4.tgz#c7629e7254011ac3630d47d7f34ddd40ca535143"
+  integrity sha512-V6jIbLhdJK86MaLh4Jpghi8ho5fGzt3imHOBu/x0jlBaPYqDoWz4RDXjmMOfnh+JWNaQleEAByZLV0QzBT4YQQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
+
+"@babel/plugin-transform-exponentiation-operator@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.23.3.tgz#ea0d978f6b9232ba4722f3dbecdd18f450babd18"
+  integrity sha512-5fhCsl1odX96u7ILKHBj4/Y8vipoqwsJMh4csSA8qFfxrZDEA4Ssku2DyNvMJSmZNOEBT750LfFPbtrnTP90BQ==
+  dependencies:
+    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-export-namespace-from@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.23.4.tgz#084c7b25e9a5c8271e987a08cf85807b80283191"
+  integrity sha512-GzuSBcKkx62dGzZI1WVgTWvkkz84FZO5TC5T8dl/Tht/rAla6Dg/Mz9Yhypg+ezVACf/rgDuQt3kbWEv7LdUDQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
+
+"@babel/plugin-transform-for-of@^7.23.6":
+  version "7.23.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.23.6.tgz#81c37e24171b37b370ba6aaffa7ac86bcb46f94e"
+  integrity sha512-aYH4ytZ0qSuBbpfhuofbg/e96oQ7U2w1Aw/UQmKT+1l39uEhUPoFS3fHevDc1G0OvewyDudfMKY1OulczHzWIw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
+
+"@babel/plugin-transform-function-name@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.23.3.tgz#8f424fcd862bf84cb9a1a6b42bc2f47ed630f8dc"
+  integrity sha512-I1QXp1LxIvt8yLaib49dRW5Okt7Q4oaxao6tFVKS/anCdEOMtYwWVKoiOA1p34GOWIZjUK0E+zCp7+l1pfQyiw==
+  dependencies:
+    "@babel/helper-compilation-targets" "^7.22.15"
+    "@babel/helper-function-name" "^7.23.0"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-json-strings@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.23.4.tgz#a871d9b6bd171976efad2e43e694c961ffa3714d"
+  integrity sha512-81nTOqM1dMwZ/aRXQ59zVubN9wHGqk6UtqRK+/q+ciXmRy8fSolhGVvG09HHRGo4l6fr/c4ZhXUQH0uFW7PZbg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-json-strings" "^7.8.3"
+
+"@babel/plugin-transform-literals@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.23.3.tgz#8214665f00506ead73de157eba233e7381f3beb4"
+  integrity sha512-wZ0PIXRxnwZvl9AYpqNUxpZ5BiTGrYt7kueGQ+N5FiQ7RCOD4cm8iShd6S6ggfVIWaJf2EMk8eRzAh52RfP4rQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-logical-assignment-operators@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.23.4.tgz#e599f82c51d55fac725f62ce55d3a0886279ecb5"
+  integrity sha512-Mc/ALf1rmZTP4JKKEhUwiORU+vcfarFVLfcFiolKUo6sewoxSEgl36ak5t+4WamRsNr6nzjZXQjM35WsU+9vbg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
+
+"@babel/plugin-transform-member-expression-literals@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.23.3.tgz#e37b3f0502289f477ac0e776b05a833d853cabcc"
+  integrity sha512-sC3LdDBDi5x96LA+Ytekz2ZPk8i/Ck+DEuDbRAll5rknJ5XRTSaPKEYwomLcs1AA8wg9b3KjIQRsnApj+q51Ag==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-modules-amd@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.23.3.tgz#e19b55436a1416829df0a1afc495deedfae17f7d"
+  integrity sha512-vJYQGxeKM4t8hYCKVBlZX/gtIY2I7mRGFNcm85sgXGMTBcoV3QdVtdpbcWEbzbfUIUZKwvgFT82mRvaQIebZzw==
+  dependencies:
+    "@babel/helper-module-transforms" "^7.23.3"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-modules-commonjs@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.23.3.tgz#661ae831b9577e52be57dd8356b734f9700b53b4"
+  integrity sha512-aVS0F65LKsdNOtcz6FRCpE4OgsP2OFnW46qNxNIX9h3wuzaNcSQsJysuMwqSibC98HPrf2vCgtxKNwS0DAlgcA==
+  dependencies:
+    "@babel/helper-module-transforms" "^7.23.3"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-simple-access" "^7.22.5"
+
+"@babel/plugin-transform-modules-systemjs@^7.23.9":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.23.9.tgz#105d3ed46e4a21d257f83a2f9e2ee4203ceda6be"
+  integrity sha512-KDlPRM6sLo4o1FkiSlXoAa8edLXFsKKIda779fbLrvmeuc3itnjCtaO6RrtoaANsIJANj+Vk1zqbZIMhkCAHVw==
+  dependencies:
+    "@babel/helper-hoist-variables" "^7.22.5"
+    "@babel/helper-module-transforms" "^7.23.3"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-validator-identifier" "^7.22.20"
+
+"@babel/plugin-transform-modules-umd@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.23.3.tgz#5d4395fccd071dfefe6585a4411aa7d6b7d769e9"
+  integrity sha512-zHsy9iXX2nIsCBFPud3jKn1IRPWg3Ing1qOZgeKV39m1ZgIdpJqvlWVeiHBZC6ITRG0MfskhYe9cLgntfSFPIg==
+  dependencies:
+    "@babel/helper-module-transforms" "^7.23.3"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-named-capturing-groups-regex@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.22.5.tgz#67fe18ee8ce02d57c855185e27e3dc959b2e991f"
+  integrity sha512-YgLLKmS3aUBhHaxp5hi1WJTgOUb/NCuDHzGT9z9WTt3YG+CPRhJs6nprbStx6DnWM4dh6gt7SU3sZodbZ08adQ==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.22.5"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-new-target@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.23.3.tgz#5491bb78ed6ac87e990957cea367eab781c4d980"
+  integrity sha512-YJ3xKqtJMAT5/TIZnpAR3I+K+WaDowYbN3xyxI8zxx/Gsypwf9B9h0VB+1Nh6ACAAPRS5NSRje0uVv5i79HYGQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-nullish-coalescing-operator@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.23.4.tgz#45556aad123fc6e52189ea749e33ce090637346e"
+  integrity sha512-jHE9EVVqHKAQx+VePv5LLGHjmHSJR76vawFPTdlxR/LVJPfOEGxREQwQfjuZEOPTwG92X3LINSh3M40Rv4zpVA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
+
+"@babel/plugin-transform-numeric-separator@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.23.4.tgz#03d08e3691e405804ecdd19dd278a40cca531f29"
+  integrity sha512-mps6auzgwjRrwKEZA05cOwuDc9FAzoyFS4ZsG/8F43bTLf/TgkJg7QXOrPO1JO599iA3qgK9MXdMGOEC8O1h6Q==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-numeric-separator" "^7.10.4"
+
+"@babel/plugin-transform-object-rest-spread@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.23.4.tgz#2b9c2d26bf62710460bdc0d1730d4f1048361b83"
+  integrity sha512-9x9K1YyeQVw0iOXJlIzwm8ltobIIv7j2iLyP2jIhEbqPRQ7ScNgwQufU2I0Gq11VjyG4gI4yMXt2VFags+1N3g==
+  dependencies:
+    "@babel/compat-data" "^7.23.3"
+    "@babel/helper-compilation-targets" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
+    "@babel/plugin-transform-parameters" "^7.23.3"
+
+"@babel/plugin-transform-object-super@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.23.3.tgz#81fdb636dcb306dd2e4e8fd80db5b2362ed2ebcd"
+  integrity sha512-BwQ8q0x2JG+3lxCVFohg+KbQM7plfpBwThdW9A6TMtWwLsbDA01Ek2Zb/AgDN39BiZsExm4qrXxjk+P1/fzGrA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-replace-supers" "^7.22.20"
+
+"@babel/plugin-transform-optional-catch-binding@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.23.4.tgz#318066de6dacce7d92fa244ae475aa8d91778017"
+  integrity sha512-XIq8t0rJPHf6Wvmbn9nFxU6ao4c7WhghTR5WyV8SrJfUFzyxhCm4nhC+iAp3HFhbAKLfYpgzhJ6t4XCtVwqO5A==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
+
+"@babel/plugin-transform-optional-chaining@^7.23.3", "@babel/plugin-transform-optional-chaining@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.23.4.tgz#6acf61203bdfc4de9d4e52e64490aeb3e52bd017"
+  integrity sha512-ZU8y5zWOfjM5vZ+asjgAPwDaBjJzgufjES89Rs4Lpq63O300R/kOz30WCLo6BxxX6QVEilwSlpClnG5cZaikTA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
+    "@babel/plugin-syntax-optional-chaining" "^7.8.3"
+
+"@babel/plugin-transform-parameters@^7.12.1", "@babel/plugin-transform-parameters@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.23.3.tgz#83ef5d1baf4b1072fa6e54b2b0999a7b2527e2af"
+  integrity sha512-09lMt6UsUb3/34BbECKVbVwrT9bO6lILWln237z7sLaWnMsTi7Yc9fhX5DLpkJzAGfaReXI22wP41SZmnAA3Vw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-private-methods@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.23.3.tgz#b2d7a3c97e278bfe59137a978d53b2c2e038c0e4"
+  integrity sha512-UzqRcRtWsDMTLrRWFvUBDwmw06tCQH9Rl1uAjfh6ijMSmGYQ+fpdB+cnqRC8EMh5tuuxSv0/TejGL+7vyj+50g==
+  dependencies:
+    "@babel/helper-create-class-features-plugin" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-private-property-in-object@^7.23.4":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.23.4.tgz#3ec711d05d6608fd173d9b8de39872d8dbf68bf5"
+  integrity sha512-9G3K1YqTq3F4Vt88Djx1UZ79PDyj+yKRnUy7cZGSMe+a7jkwD259uKKuUzQlPkGam7R+8RJwh5z4xO27fA1o2A==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.22.5"
+    "@babel/helper-create-class-features-plugin" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
+
+"@babel/plugin-transform-property-literals@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.23.3.tgz#54518f14ac4755d22b92162e4a852d308a560875"
+  integrity sha512-jR3Jn3y7cZp4oEWPFAlRsSWjxKe4PZILGBSd4nis1TsC5qeSpb+nrtihJuDhNI7QHiVbUaiXa0X2RZY3/TI6Nw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-react-constant-elements@^7.18.12":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.23.3.tgz#5efc001d07ef0f7da0d73c3a86c132f73d28e43c"
+  integrity sha512-zP0QKq/p6O42OL94udMgSfKXyse4RyJ0JqbQ34zDAONWjyrEsghYEyTSK5FIpmXmCpB55SHokL1cRRKHv8L2Qw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-react-display-name@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.23.3.tgz#70529f034dd1e561045ad3c8152a267f0d7b6200"
+  integrity sha512-GnvhtVfA2OAtzdX58FJxU19rhoGeQzyVndw3GgtdECQvQFXPEZIOVULHVZGAYmOgmqjXpVpfocAbSjh99V/Fqw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-react-jsx-development@^7.22.5":
+  version "7.22.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.22.5.tgz#e716b6edbef972a92165cd69d92f1255f7e73e87"
+  integrity sha512-bDhuzwWMuInwCYeDeMzyi7TaBgRQei6DqxhbyniL7/VG4RSS7HtSL2QbY4eESy1KJqlWt8g3xeEBGPuo+XqC8A==
+  dependencies:
+    "@babel/plugin-transform-react-jsx" "^7.22.5"
+
+"@babel/plugin-transform-react-jsx@^7.22.15", "@babel/plugin-transform-react-jsx@^7.22.5":
+  version "7.23.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.23.4.tgz#393f99185110cea87184ea47bcb4a7b0c2e39312"
+  integrity sha512-5xOpoPguCZCRbo/JeHlloSkTA8Bld1J/E1/kLfD1nsuiW1m8tduTA1ERCgIZokDflX/IBzKcqR3l7VlRgiIfHA==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.22.5"
+    "@babel/helper-module-imports" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-jsx" "^7.23.3"
+    "@babel/types" "^7.23.4"
+
+"@babel/plugin-transform-react-pure-annotations@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.23.3.tgz#fabedbdb8ee40edf5da96f3ecfc6958e3783b93c"
+  integrity sha512-qMFdSS+TUhB7Q/3HVPnEdYJDQIk57jkntAwSuz9xfSE4n+3I+vHYCli3HoHawN1Z3RfCz/y1zXA/JXjG6cVImQ==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.22.5"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-regenerator@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.23.3.tgz#141afd4a2057298602069fce7f2dc5173e6c561c"
+  integrity sha512-KP+75h0KghBMcVpuKisx3XTu9Ncut8Q8TuvGO4IhY+9D5DFEckQefOuIsB/gQ2tG71lCke4NMrtIPS8pOj18BQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    regenerator-transform "^0.15.2"
+
+"@babel/plugin-transform-reserved-words@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.23.3.tgz#4130dcee12bd3dd5705c587947eb715da12efac8"
+  integrity sha512-QnNTazY54YqgGxwIexMZva9gqbPa15t/x9VS+0fsEFWplwVpXYZivtgl43Z1vMpc1bdPP2PP8siFeVcnFvA3Cg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-runtime@^7.18.6":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.23.9.tgz#2c64d0680fc8e09e1dfe8fd5c646fe72abd82004"
+  integrity sha512-A7clW3a0aSjm3ONU9o2HAILSegJCYlEZmOhmBRReVtIpY/Z/p7yIZ+wR41Z+UipwdGuqwtID/V/dOdZXjwi9gQ==
+  dependencies:
+    "@babel/helper-module-imports" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    babel-plugin-polyfill-corejs2 "^0.4.8"
+    babel-plugin-polyfill-corejs3 "^0.9.0"
+    babel-plugin-polyfill-regenerator "^0.5.5"
+    semver "^6.3.1"
+
+"@babel/plugin-transform-shorthand-properties@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.23.3.tgz#97d82a39b0e0c24f8a981568a8ed851745f59210"
+  integrity sha512-ED2fgqZLmexWiN+YNFX26fx4gh5qHDhn1O2gvEhreLW2iI63Sqm4llRLCXALKrCnbN4Jy0VcMQZl/SAzqug/jg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-spread@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.23.3.tgz#41d17aacb12bde55168403c6f2d6bdca563d362c"
+  integrity sha512-VvfVYlrlBVu+77xVTOAoxQ6mZbnIq5FM0aGBSFEcIh03qHf+zNqA4DC/3XMUozTg7bZV3e3mZQ0i13VB6v5yUg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
+
+"@babel/plugin-transform-sticky-regex@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.23.3.tgz#dec45588ab4a723cb579c609b294a3d1bd22ff04"
+  integrity sha512-HZOyN9g+rtvnOU3Yh7kSxXrKbzgrm5X4GncPY1QOquu7epga5MxKHVpYu2hvQnry/H+JjckSYRb93iNfsioAGg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-template-literals@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.23.3.tgz#5f0f028eb14e50b5d0f76be57f90045757539d07"
+  integrity sha512-Flok06AYNp7GV2oJPZZcP9vZdszev6vPBkHLwxwSpaIqx75wn6mUd3UFWsSsA0l8nXAKkyCmL/sR02m8RYGeHg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-typeof-symbol@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.23.3.tgz#9dfab97acc87495c0c449014eb9c547d8966bca4"
+  integrity sha512-4t15ViVnaFdrPC74be1gXBSMzXk3B4Us9lP7uLRQHTFpV5Dvt33pn+2MyyNxmN3VTTm3oTrZVMUmuw3oBnQ2oQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-typescript@^7.23.3":
+  version "7.23.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.23.6.tgz#aa36a94e5da8d94339ae3a4e22d40ed287feb34c"
+  integrity sha512-6cBG5mBvUu4VUD04OHKnYzbuHNP8huDsD3EDqqpIpsswTDoqHCjLoHb6+QgsV1WsT2nipRqCPgxD3LXnEO7XfA==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.22.5"
+    "@babel/helper-create-class-features-plugin" "^7.23.6"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/plugin-syntax-typescript" "^7.23.3"
+
+"@babel/plugin-transform-unicode-escapes@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.23.3.tgz#1f66d16cab01fab98d784867d24f70c1ca65b925"
+  integrity sha512-OMCUx/bU6ChE3r4+ZdylEqAjaQgHAgipgW8nsCfu5pGqDcFytVd91AwRvUJSBZDz0exPGgnjoqhgRYLRjFZc9Q==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-unicode-property-regex@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.23.3.tgz#19e234129e5ffa7205010feec0d94c251083d7ad"
+  integrity sha512-KcLIm+pDZkWZQAFJ9pdfmh89EwVfmNovFBcXko8szpBeF8z68kWIPeKlmSOkT9BXJxs2C0uk+5LxoxIv62MROA==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-unicode-regex@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.23.3.tgz#26897708d8f42654ca4ce1b73e96140fbad879dc"
+  integrity sha512-wMHpNA4x2cIA32b/ci3AfwNgheiva2W0WUKWTK7vBHBhDKfPsc5cFGNWm69WBqpwd86u1qwZ9PWevKqm1A3yAw==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/plugin-transform-unicode-sets-regex@^7.23.3":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.23.3.tgz#4fb6f0a719c2c5859d11f6b55a050cc987f3799e"
+  integrity sha512-W7lliA/v9bNR83Qc3q1ip9CQMZ09CcHDbHfbLRDNuAhn1Mvkr1ZNF7hPmztMQvtTGVLJ9m8IZqWsTkXOml8dbw==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.22.15"
+    "@babel/helper-plugin-utils" "^7.22.5"
+
+"@babel/preset-env@^7.18.6", "@babel/preset-env@^7.19.4":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.23.9.tgz#beace3b7994560ed6bf78e4ae2073dff45387669"
+  integrity sha512-3kBGTNBBk9DQiPoXYS0g0BYlwTQYUTifqgKTjxUwEUkduRT2QOa0FPGBJ+NROQhGyYO5BuTJwGvBnqKDykac6A==
+  dependencies:
+    "@babel/compat-data" "^7.23.5"
+    "@babel/helper-compilation-targets" "^7.23.6"
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-validator-option" "^7.23.5"
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.23.3"
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.23.3"
+    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly" "^7.23.7"
+    "@babel/plugin-proposal-private-property-in-object" "7.21.0-placeholder-for-preset-env.2"
+    "@babel/plugin-syntax-async-generators" "^7.8.4"
+    "@babel/plugin-syntax-class-properties" "^7.12.13"
+    "@babel/plugin-syntax-class-static-block" "^7.14.5"
+    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
+    "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
+    "@babel/plugin-syntax-import-assertions" "^7.23.3"
+    "@babel/plugin-syntax-import-attributes" "^7.23.3"
+    "@babel/plugin-syntax-import-meta" "^7.10.4"
+    "@babel/plugin-syntax-json-strings" "^7.8.3"
+    "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
+    "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
+    "@babel/plugin-syntax-numeric-separator" "^7.10.4"
+    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
+    "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
+    "@babel/plugin-syntax-optional-chaining" "^7.8.3"
+    "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
+    "@babel/plugin-syntax-top-level-await" "^7.14.5"
+    "@babel/plugin-syntax-unicode-sets-regex" "^7.18.6"
+    "@babel/plugin-transform-arrow-functions" "^7.23.3"
+    "@babel/plugin-transform-async-generator-functions" "^7.23.9"
+    "@babel/plugin-transform-async-to-generator" "^7.23.3"
+    "@babel/plugin-transform-block-scoped-functions" "^7.23.3"
+    "@babel/plugin-transform-block-scoping" "^7.23.4"
+    "@babel/plugin-transform-class-properties" "^7.23.3"
+    "@babel/plugin-transform-class-static-block" "^7.23.4"
+    "@babel/plugin-transform-classes" "^7.23.8"
+    "@babel/plugin-transform-computed-properties" "^7.23.3"
+    "@babel/plugin-transform-destructuring" "^7.23.3"
+    "@babel/plugin-transform-dotall-regex" "^7.23.3"
+    "@babel/plugin-transform-duplicate-keys" "^7.23.3"
+    "@babel/plugin-transform-dynamic-import" "^7.23.4"
+    "@babel/plugin-transform-exponentiation-operator" "^7.23.3"
+    "@babel/plugin-transform-export-namespace-from" "^7.23.4"
+    "@babel/plugin-transform-for-of" "^7.23.6"
+    "@babel/plugin-transform-function-name" "^7.23.3"
+    "@babel/plugin-transform-json-strings" "^7.23.4"
+    "@babel/plugin-transform-literals" "^7.23.3"
+    "@babel/plugin-transform-logical-assignment-operators" "^7.23.4"
+    "@babel/plugin-transform-member-expression-literals" "^7.23.3"
+    "@babel/plugin-transform-modules-amd" "^7.23.3"
+    "@babel/plugin-transform-modules-commonjs" "^7.23.3"
+    "@babel/plugin-transform-modules-systemjs" "^7.23.9"
+    "@babel/plugin-transform-modules-umd" "^7.23.3"
+    "@babel/plugin-transform-named-capturing-groups-regex" "^7.22.5"
+    "@babel/plugin-transform-new-target" "^7.23.3"
+    "@babel/plugin-transform-nullish-coalescing-operator" "^7.23.4"
+    "@babel/plugin-transform-numeric-separator" "^7.23.4"
+    "@babel/plugin-transform-object-rest-spread" "^7.23.4"
+    "@babel/plugin-transform-object-super" "^7.23.3"
+    "@babel/plugin-transform-optional-catch-binding" "^7.23.4"
+    "@babel/plugin-transform-optional-chaining" "^7.23.4"
+    "@babel/plugin-transform-parameters" "^7.23.3"
+    "@babel/plugin-transform-private-methods" "^7.23.3"
+    "@babel/plugin-transform-private-property-in-object" "^7.23.4"
+    "@babel/plugin-transform-property-literals" "^7.23.3"
+    "@babel/plugin-transform-regenerator" "^7.23.3"
+    "@babel/plugin-transform-reserved-words" "^7.23.3"
+    "@babel/plugin-transform-shorthand-properties" "^7.23.3"
+    "@babel/plugin-transform-spread" "^7.23.3"
+    "@babel/plugin-transform-sticky-regex" "^7.23.3"
+    "@babel/plugin-transform-template-literals" "^7.23.3"
+    "@babel/plugin-transform-typeof-symbol" "^7.23.3"
+    "@babel/plugin-transform-unicode-escapes" "^7.23.3"
+    "@babel/plugin-transform-unicode-property-regex" "^7.23.3"
+    "@babel/plugin-transform-unicode-regex" "^7.23.3"
+    "@babel/plugin-transform-unicode-sets-regex" "^7.23.3"
+    "@babel/preset-modules" "0.1.6-no-external-plugins"
+    babel-plugin-polyfill-corejs2 "^0.4.8"
+    babel-plugin-polyfill-corejs3 "^0.9.0"
+    babel-plugin-polyfill-regenerator "^0.5.5"
+    core-js-compat "^3.31.0"
+    semver "^6.3.1"
+
+"@babel/preset-modules@0.1.6-no-external-plugins":
+  version "0.1.6-no-external-plugins"
+  resolved "https://registry.yarnpkg.com/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz#ccb88a2c49c817236861fee7826080573b8a923a"
+  integrity sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/types" "^7.4.4"
+    esutils "^2.0.2"
+
+"@babel/preset-react@^7.18.6":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/preset-react/-/preset-react-7.23.3.tgz#f73ca07e7590f977db07eb54dbe46538cc015709"
+  integrity sha512-tbkHOS9axH6Ysf2OUEqoSZ6T3Fa2SrNH6WTWSPBboxKzdxNc9qOICeLXkNG0ZEwbQ1HY8liwOce4aN/Ceyuq6w==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-validator-option" "^7.22.15"
+    "@babel/plugin-transform-react-display-name" "^7.23.3"
+    "@babel/plugin-transform-react-jsx" "^7.22.15"
+    "@babel/plugin-transform-react-jsx-development" "^7.22.5"
+    "@babel/plugin-transform-react-pure-annotations" "^7.23.3"
+
+"@babel/preset-typescript@^7.18.6":
+  version "7.23.3"
+  resolved "https://registry.yarnpkg.com/@babel/preset-typescript/-/preset-typescript-7.23.3.tgz#14534b34ed5b6d435aa05f1ae1c5e7adcc01d913"
+  integrity sha512-17oIGVlqz6CchO9RFYn5U6ZpWRZIngayYCtrPRSgANSwC2V1Jb+iP74nVxzzXJte8b8BYxrL1yY96xfhTBrNNQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.22.5"
+    "@babel/helper-validator-option" "^7.22.15"
+    "@babel/plugin-syntax-jsx" "^7.23.3"
+    "@babel/plugin-transform-modules-commonjs" "^7.23.3"
+    "@babel/plugin-transform-typescript" "^7.23.3"
+
+"@babel/regjsgen@^0.8.0":
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/@babel/regjsgen/-/regjsgen-0.8.0.tgz#f0ba69b075e1f05fb2825b7fad991e7adbb18310"
+  integrity sha512-x/rqGMdzj+fWZvCOYForTghzbtqPDZ5gPwaoNGHdgDfF2QA/XZbCBp4Moo5scrkAMPhB7z26XM/AaHuIJdgauA==
+
+"@babel/runtime-corejs3@^7.18.6":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/runtime-corejs3/-/runtime-corejs3-7.23.9.tgz#1b43062a13ecb60158aecdd81bc3fab4108b7cbc"
+  integrity sha512-oeOFTrYWdWXCvXGB5orvMTJ6gCZ9I6FBjR+M38iKNXCsPxr4xT0RTdg5uz1H7QP8pp74IzPtwritEr+JscqHXQ==
+  dependencies:
+    core-js-pure "^3.30.2"
+    regenerator-runtime "^0.14.0"
+
+"@babel/runtime@^7.1.2", "@babel/runtime@^7.10.3", "@babel/runtime@^7.12.13", "@babel/runtime@^7.12.5", "@babel/runtime@^7.18.6", "@babel/runtime@^7.20.13", "@babel/runtime@^7.8.4":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.23.9.tgz#47791a15e4603bb5f905bc0753801cf21d6345f7"
+  integrity sha512-0CX6F+BI2s9dkUqr08KFrAIZgNFj75rdBU/DjCyYLIaV/quFjkk6T+EJ2LkZHyZTbEV4L5p97mNkUsHl2wLFAw==
+  dependencies:
+    regenerator-runtime "^0.14.0"
+
+"@babel/template@^7.12.7", "@babel/template@^7.22.15", "@babel/template@^7.23.9":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.23.9.tgz#f881d0487cba2828d3259dcb9ef5005a9731011a"
+  integrity sha512-+xrD2BWLpvHKNmX2QbpdpsBaWnRxahMwJjO+KZk2JOElj5nSmKezyS1B4u+QbHMTX69t4ukm6hh9lsYQ7GHCKA==
+  dependencies:
+    "@babel/code-frame" "^7.23.5"
+    "@babel/parser" "^7.23.9"
+    "@babel/types" "^7.23.9"
+
+"@babel/traverse@^7.12.9", "@babel/traverse@^7.18.8", "@babel/traverse@^7.23.9":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.23.9.tgz#2f9d6aead6b564669394c5ce0f9302bb65b9d950"
+  integrity sha512-I/4UJ9vs90OkBtY6iiiTORVMyIhJ4kAVmsKo9KFc8UOxMeUfi2hvtIBsET5u9GizXE6/GFSuKCTNfgCswuEjRg==
+  dependencies:
+    "@babel/code-frame" "^7.23.5"
+    "@babel/generator" "^7.23.6"
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-function-name" "^7.23.0"
+    "@babel/helper-hoist-variables" "^7.22.5"
+    "@babel/helper-split-export-declaration" "^7.22.6"
+    "@babel/parser" "^7.23.9"
+    "@babel/types" "^7.23.9"
+    debug "^4.3.1"
+    globals "^11.1.0"
+
+"@babel/types@^7.12.7", "@babel/types@^7.20.0", "@babel/types@^7.22.15", "@babel/types@^7.22.19", "@babel/types@^7.22.5", "@babel/types@^7.23.0", "@babel/types@^7.23.4", "@babel/types@^7.23.6", "@babel/types@^7.23.9", "@babel/types@^7.4.4":
+  version "7.23.9"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.23.9.tgz#1dd7b59a9a2b5c87f8b41e52770b5ecbf492e002"
+  integrity sha512-dQjSq/7HaSjRM43FFGnv5keM2HsxpmyV1PfaSVm0nzzjwwTmjOe6J4bC8e3+pTEIgHaHj+1ZlLThRJ2auc/w1Q==
+  dependencies:
+    "@babel/helper-string-parser" "^7.23.4"
+    "@babel/helper-validator-identifier" "^7.22.20"
+    to-fast-properties "^2.0.0"
+
+"@colors/colors@1.5.0":
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/@colors/colors/-/colors-1.5.0.tgz#bb504579c1cae923e6576a4f5da43d25f97bdbd9"
+  integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==
+
+"@discoveryjs/json-ext@0.5.7":
+  version "0.5.7"
+  resolved "https://registry.yarnpkg.com/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz#1d572bfbbe14b7704e0ba0f39b74815b84870d70"
+  integrity sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==
+
+"@docsearch/css@3.5.2":
+  version "3.5.2"
+  resolved "https://registry.yarnpkg.com/@docsearch/css/-/css-3.5.2.tgz#610f47b48814ca94041df969d9fcc47b91fc5aac"
+  integrity sha512-SPiDHaWKQZpwR2siD0KQUwlStvIAnEyK6tAE2h2Wuoq8ue9skzhlyVQ1ddzOxX6khULnAALDiR/isSF3bnuciA==
+
+"@docsearch/react@^3.1.1":
+  version "3.5.2"
+  resolved "https://registry.yarnpkg.com/@docsearch/react/-/react-3.5.2.tgz#2e6bbee00eb67333b64906352734da6aef1232b9"
+  integrity sha512-9Ahcrs5z2jq/DcAvYtvlqEBHImbm4YJI8M9y0x6Tqg598P40HTEkX7hsMcIuThI+hTFxRGZ9hll0Wygm2yEjng==
+  dependencies:
+    "@algolia/autocomplete-core" "1.9.3"
+    "@algolia/autocomplete-preset-algolia" "1.9.3"
+    "@docsearch/css" "3.5.2"
+    algoliasearch "^4.19.1"
+
+"@docusaurus/core@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/core/-/core-2.0.1.tgz#a2b0d653e8f18eacddda4778a46b638dd1f0f45c"
+  integrity sha512-Prd46TtZdiixlTl8a+h9bI5HegkfREjSNkrX2rVEwJZeziSz4ya+l7QDnbnCB2XbxEG8cveFo/F9q5lixolDtQ==
+  dependencies:
+    "@babel/core" "^7.18.6"
+    "@babel/generator" "^7.18.7"
+    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
+    "@babel/plugin-transform-runtime" "^7.18.6"
+    "@babel/preset-env" "^7.18.6"
+    "@babel/preset-react" "^7.18.6"
+    "@babel/preset-typescript" "^7.18.6"
+    "@babel/runtime" "^7.18.6"
+    "@babel/runtime-corejs3" "^7.18.6"
+    "@babel/traverse" "^7.18.8"
+    "@docusaurus/cssnano-preset" "2.0.1"
+    "@docusaurus/logger" "2.0.1"
+    "@docusaurus/mdx-loader" "2.0.1"
+    "@docusaurus/react-loadable" "5.5.2"
+    "@docusaurus/utils" "2.0.1"
+    "@docusaurus/utils-common" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    "@slorber/static-site-generator-webpack-plugin" "^4.0.7"
+    "@svgr/webpack" "^6.2.1"
+    autoprefixer "^10.4.7"
+    babel-loader "^8.2.5"
+    babel-plugin-dynamic-import-node "^2.3.3"
+    boxen "^6.2.1"
+    chalk "^4.1.2"
+    chokidar "^3.5.3"
+    clean-css "^5.3.0"
+    cli-table3 "^0.6.2"
+    combine-promises "^1.1.0"
+    commander "^5.1.0"
+    copy-webpack-plugin "^11.0.0"
+    core-js "^3.23.3"
+    css-loader "^6.7.1"
+    css-minimizer-webpack-plugin "^4.0.0"
+    cssnano "^5.1.12"
+    del "^6.1.1"
+    detect-port "^1.3.0"
+    escape-html "^1.0.3"
+    eta "^1.12.3"
+    file-loader "^6.2.0"
+    fs-extra "^10.1.0"
+    html-minifier-terser "^6.1.0"
+    html-tags "^3.2.0"
+    html-webpack-plugin "^5.5.0"
+    import-fresh "^3.3.0"
+    leven "^3.1.0"
+    lodash "^4.17.21"
+    mini-css-extract-plugin "^2.6.1"
+    postcss "^8.4.14"
+    postcss-loader "^7.0.0"
+    prompts "^2.4.2"
+    react-dev-utils "^12.0.1"
+    react-helmet-async "^1.3.0"
+    react-loadable "npm:@docusaurus/react-loadable@5.5.2"
+    react-loadable-ssr-addon-v5-slorber "^1.0.1"
+    react-router "^5.3.3"
+    react-router-config "^5.1.1"
+    react-router-dom "^5.3.3"
+    rtl-detect "^1.0.4"
+    semver "^7.3.7"
+    serve-handler "^6.1.3"
+    shelljs "^0.8.5"
+    terser-webpack-plugin "^5.3.3"
+    tslib "^2.4.0"
+    update-notifier "^5.1.0"
+    url-loader "^4.1.1"
+    wait-on "^6.0.1"
+    webpack "^5.73.0"
+    webpack-bundle-analyzer "^4.5.0"
+    webpack-dev-server "^4.9.3"
+    webpack-merge "^5.8.0"
+    webpackbar "^5.0.2"
+
+"@docusaurus/core@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/core/-/core-2.4.3.tgz#d86624901386fd8164ce4bff9cc7f16fde57f523"
+  integrity sha512-dWH5P7cgeNSIg9ufReX6gaCl/TmrGKD38Orbwuz05WPhAQtFXHd5B8Qym1TiXfvUNvwoYKkAJOJuGe8ou0Z7PA==
+  dependencies:
+    "@babel/core" "^7.18.6"
+    "@babel/generator" "^7.18.7"
+    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
+    "@babel/plugin-transform-runtime" "^7.18.6"
+    "@babel/preset-env" "^7.18.6"
+    "@babel/preset-react" "^7.18.6"
+    "@babel/preset-typescript" "^7.18.6"
+    "@babel/runtime" "^7.18.6"
+    "@babel/runtime-corejs3" "^7.18.6"
+    "@babel/traverse" "^7.18.8"
+    "@docusaurus/cssnano-preset" "2.4.3"
+    "@docusaurus/logger" "2.4.3"
+    "@docusaurus/mdx-loader" "2.4.3"
+    "@docusaurus/react-loadable" "5.5.2"
+    "@docusaurus/utils" "2.4.3"
+    "@docusaurus/utils-common" "2.4.3"
+    "@docusaurus/utils-validation" "2.4.3"
+    "@slorber/static-site-generator-webpack-plugin" "^4.0.7"
+    "@svgr/webpack" "^6.2.1"
+    autoprefixer "^10.4.7"
+    babel-loader "^8.2.5"
+    babel-plugin-dynamic-import-node "^2.3.3"
+    boxen "^6.2.1"
+    chalk "^4.1.2"
+    chokidar "^3.5.3"
+    clean-css "^5.3.0"
+    cli-table3 "^0.6.2"
+    combine-promises "^1.1.0"
+    commander "^5.1.0"
+    copy-webpack-plugin "^11.0.0"
+    core-js "^3.23.3"
+    css-loader "^6.7.1"
+    css-minimizer-webpack-plugin "^4.0.0"
+    cssnano "^5.1.12"
+    del "^6.1.1"
+    detect-port "^1.3.0"
+    escape-html "^1.0.3"
+    eta "^2.0.0"
+    file-loader "^6.2.0"
+    fs-extra "^10.1.0"
+    html-minifier-terser "^6.1.0"
+    html-tags "^3.2.0"
+    html-webpack-plugin "^5.5.0"
+    import-fresh "^3.3.0"
+    leven "^3.1.0"
+    lodash "^4.17.21"
+    mini-css-extract-plugin "^2.6.1"
+    postcss "^8.4.14"
+    postcss-loader "^7.0.0"
+    prompts "^2.4.2"
+    react-dev-utils "^12.0.1"
+    react-helmet-async "^1.3.0"
+    react-loadable "npm:@docusaurus/react-loadable@5.5.2"
+    react-loadable-ssr-addon-v5-slorber "^1.0.1"
+    react-router "^5.3.3"
+    react-router-config "^5.1.1"
+    react-router-dom "^5.3.3"
+    rtl-detect "^1.0.4"
+    semver "^7.3.7"
+    serve-handler "^6.1.3"
+    shelljs "^0.8.5"
+    terser-webpack-plugin "^5.3.3"
+    tslib "^2.4.0"
+    update-notifier "^5.1.0"
+    url-loader "^4.1.1"
+    wait-on "^6.0.1"
+    webpack "^5.73.0"
+    webpack-bundle-analyzer "^4.5.0"
+    webpack-dev-server "^4.9.3"
+    webpack-merge "^5.8.0"
+    webpackbar "^5.0.2"
+
+"@docusaurus/cssnano-preset@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/cssnano-preset/-/cssnano-preset-2.0.1.tgz#4d0c49338cf3aa88c5bd7cffbf77654db8e1e3b2"
+  integrity sha512-MCJ6rRmlqLmlCsZIoIxOxDb0rYzIPEm9PYpsBW+CGNnbk+x8xK+11hnrxzvXHqDRNpxrq3Kq2jYUmg/DkqE6vg==
+  dependencies:
+    cssnano-preset-advanced "^5.3.8"
+    postcss "^8.4.14"
+    postcss-sort-media-queries "^4.2.1"
+    tslib "^2.4.0"
+
+"@docusaurus/cssnano-preset@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/cssnano-preset/-/cssnano-preset-2.4.3.tgz#1d7e833c41ce240fcc2812a2ac27f7b862f32de0"
+  integrity sha512-ZvGSRCi7z9wLnZrXNPG6DmVPHdKGd8dIn9pYbEOFiYihfv4uDR3UtxogmKf+rT8ZlKFf5Lqne8E8nt08zNM8CA==
+  dependencies:
+    cssnano-preset-advanced "^5.3.8"
+    postcss "^8.4.14"
+    postcss-sort-media-queries "^4.2.1"
+    tslib "^2.4.0"
+
+"@docusaurus/logger@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/logger/-/logger-2.0.1.tgz#78a940a333d2f654fd9dea24db2c962034d4b1ff"
+  integrity sha512-wIWseCKko1w/WARcDjO3N/XoJ0q/VE42AthP0eNAfEazDjJ94NXbaI6wuUsuY/bMg6hTKGVIpphjj2LoX3g6dA==
+  dependencies:
+    chalk "^4.1.2"
+    tslib "^2.4.0"
+
+"@docusaurus/logger@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/logger/-/logger-2.4.3.tgz#518bbc965fb4ebe8f1d0b14e5f4161607552d34c"
+  integrity sha512-Zxws7r3yLufk9xM1zq9ged0YHs65mlRmtsobnFkdZTxWXdTYlWWLWdKyNKAsVC+D7zg+pv2fGbyabdOnyZOM3w==
+  dependencies:
+    chalk "^4.1.2"
+    tslib "^2.4.0"
+
+"@docusaurus/mdx-loader@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/mdx-loader/-/mdx-loader-2.0.1.tgz#cc73690ca5d356687d9e75740560b4159cd5cdb5"
+  integrity sha512-tdNeljdilXCmhbaEND3SAgsqaw/oh7v9onT5yrIrL26OSk2AFwd+MIi4R8jt8vq33M0R4rz2wpknm0fQIkDdvQ==
+  dependencies:
+    "@babel/parser" "^7.18.8"
+    "@babel/traverse" "^7.18.8"
+    "@docusaurus/logger" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    "@mdx-js/mdx" "^1.6.22"
+    escape-html "^1.0.3"
+    file-loader "^6.2.0"
+    fs-extra "^10.1.0"
+    image-size "^1.0.1"
+    mdast-util-to-string "^2.0.0"
+    remark-emoji "^2.2.0"
+    stringify-object "^3.3.0"
+    tslib "^2.4.0"
+    unified "^9.2.2"
+    unist-util-visit "^2.0.3"
+    url-loader "^4.1.1"
+    webpack "^5.73.0"
+
+"@docusaurus/mdx-loader@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/mdx-loader/-/mdx-loader-2.4.3.tgz#e8ff37f30a060eaa97b8121c135f74cb531a4a3e"
+  integrity sha512-b1+fDnWtl3GiqkL0BRjYtc94FZrcDDBV1j8446+4tptB9BAOlePwG2p/pK6vGvfL53lkOsszXMghr2g67M0vCw==
+  dependencies:
+    "@babel/parser" "^7.18.8"
+    "@babel/traverse" "^7.18.8"
+    "@docusaurus/logger" "2.4.3"
+    "@docusaurus/utils" "2.4.3"
+    "@mdx-js/mdx" "^1.6.22"
+    escape-html "^1.0.3"
+    file-loader "^6.2.0"
+    fs-extra "^10.1.0"
+    image-size "^1.0.1"
+    mdast-util-to-string "^2.0.0"
+    remark-emoji "^2.2.0"
+    stringify-object "^3.3.0"
+    tslib "^2.4.0"
+    unified "^9.2.2"
+    unist-util-visit "^2.0.3"
+    url-loader "^4.1.1"
+    webpack "^5.73.0"
+
+"@docusaurus/module-type-aliases@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/module-type-aliases/-/module-type-aliases-2.0.1.tgz#44d7132297bedae0890695b0e7ebbe14a73e26d1"
+  integrity sha512-f888ylnxHAM/3T8p1lx08+lTc6/g7AweSRfRuZvrVhHXj3Tz/nTTxaP6gPTGkJK7WLqTagpar/IGP6/74IBbkg==
+  dependencies:
+    "@docusaurus/react-loadable" "5.5.2"
+    "@docusaurus/types" "2.0.1"
+    "@types/history" "^4.7.11"
+    "@types/react" "*"
+    "@types/react-router-config" "*"
+    "@types/react-router-dom" "*"
+    react-helmet-async "*"
+    react-loadable "npm:@docusaurus/react-loadable@5.5.2"
+
+"@docusaurus/plugin-content-blog@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-content-blog/-/plugin-content-blog-2.0.1.tgz#a37065e18ffd26e022ffb16a21ff28199140729e"
+  integrity sha512-/4ua3iFYcpwgpeYgHnhVGROB/ybnauLH2+rICb4vz/+Gn1hjAmGXVYq1fk8g49zGs3uxx5nc0H5bL9P0g977IQ==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/logger" "2.0.1"
+    "@docusaurus/mdx-loader" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    "@docusaurus/utils-common" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    cheerio "^1.0.0-rc.12"
+    feed "^4.2.2"
+    fs-extra "^10.1.0"
+    lodash "^4.17.21"
+    reading-time "^1.5.0"
+    tslib "^2.4.0"
+    unist-util-visit "^2.0.3"
+    utility-types "^3.10.0"
+    webpack "^5.73.0"
+
+"@docusaurus/plugin-content-docs@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-content-docs/-/plugin-content-docs-2.0.1.tgz#4059591b4bff617e744e856ca680674b27c0b98a"
+  integrity sha512-2qeBWRy1EjgnXdwAO6/csDIS1UVNmhmtk/bQ2s9jqjpwM8YVgZ8QVdkxFAMWXgZWDQdwWwdP1rnmoEelE4HknQ==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/logger" "2.0.1"
+    "@docusaurus/mdx-loader" "2.0.1"
+    "@docusaurus/module-type-aliases" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    "@types/react-router-config" "^5.0.6"
+    combine-promises "^1.1.0"
+    fs-extra "^10.1.0"
+    import-fresh "^3.3.0"
+    js-yaml "^4.1.0"
+    lodash "^4.17.21"
+    tslib "^2.4.0"
+    utility-types "^3.10.0"
+    webpack "^5.73.0"
+
+"@docusaurus/plugin-content-pages@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-content-pages/-/plugin-content-pages-2.0.1.tgz#013f2e66f80d19b5c95a2d941d67c7cdb67b7191"
+  integrity sha512-6apSVeJENnNecAH5cm5VnRqR103M6qSI6IuiP7tVfD5H4AWrfDNkvJQV2+R2PIq3bGrwmX4fcXl1x4g0oo7iwA==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/mdx-loader" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    fs-extra "^10.1.0"
+    tslib "^2.4.0"
+    webpack "^5.73.0"
+
+"@docusaurus/plugin-debug@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-debug/-/plugin-debug-2.0.1.tgz#2b2a473f8e01fd356e32236f753665b48209bcd4"
+  integrity sha512-jpZBT5HK7SWx1LRQyv9d14i44vSsKXGZsSPA2ndth5HykHJsiAj9Fwl1AtzmtGYuBmI+iXQyOd4MAMHd4ZZ1tg==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    fs-extra "^10.1.0"
+    react-json-view "^1.21.3"
+    tslib "^2.4.0"
+
+"@docusaurus/plugin-google-analytics@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-2.0.1.tgz#e3b84237aad2e94dcd1cf1810c1c9bc3d94f186d"
+  integrity sha512-d5qb+ZeQcg1Czoxc+RacETjLdp2sN/TAd7PGN/GrvtijCdgNmvVAtZ9QgajBTG0YbJFVPTeZ39ad2bpoOexX0w==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    tslib "^2.4.0"
+
+"@docusaurus/plugin-google-gtag@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-2.0.1.tgz#4cbcf9d520f7ec8124679fbe00867f2299a2f6bb"
+  integrity sha512-qiRufJe2FvIyzICbkjm4VbVCI1hyEju/CebfDKkKh2ZtV4q6DM1WZG7D6VoQSXL8MrMFB895gipOM4BwdM8VsQ==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    tslib "^2.4.0"
+
+"@docusaurus/plugin-google-gtag@^2.0.1":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-2.4.3.tgz#e1a80b0696771b488562e5b60eff21c9932d9e1c"
+  integrity sha512-5FMg0rT7sDy4i9AGsvJC71MQrqQZwgLNdDetLEGDHLfSHLvJhQbTCUGbGXknUgWXQJckcV/AILYeJy+HhxeIFA==
+  dependencies:
+    "@docusaurus/core" "2.4.3"
+    "@docusaurus/types" "2.4.3"
+    "@docusaurus/utils-validation" "2.4.3"
+    tslib "^2.4.0"
+
+"@docusaurus/plugin-sitemap@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/plugin-sitemap/-/plugin-sitemap-2.0.1.tgz#6f8edb82b745b040d6b1495e2798396f63e50289"
+  integrity sha512-KcYuIUIp2JPzUf+Xa7W2BSsjLgN1/0h+VAz7D/C3RYjAgC5ApPX8wO+TECmGfunl/m7WKGUmLabfOon/as64kQ==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/logger" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    "@docusaurus/utils-common" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    fs-extra "^10.1.0"
+    sitemap "^7.1.1"
+    tslib "^2.4.0"
+
+"@docusaurus/preset-classic@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/preset-classic/-/preset-classic-2.0.1.tgz#21a806e16b61026d2a0efa6ca97e17397065d894"
+  integrity sha512-nOoniTg46My1qdDlLWeFs55uEmxOJ+9WMF8KKG8KMCu5LAvpemMi7rQd4x8Tw+xiPHZ/sQzH9JmPTMPRE4QGPw==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/plugin-content-blog" "2.0.1"
+    "@docusaurus/plugin-content-docs" "2.0.1"
+    "@docusaurus/plugin-content-pages" "2.0.1"
+    "@docusaurus/plugin-debug" "2.0.1"
+    "@docusaurus/plugin-google-analytics" "2.0.1"
+    "@docusaurus/plugin-google-gtag" "2.0.1"
+    "@docusaurus/plugin-sitemap" "2.0.1"
+    "@docusaurus/theme-classic" "2.0.1"
+    "@docusaurus/theme-common" "2.0.1"
+    "@docusaurus/theme-search-algolia" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+
+"@docusaurus/react-loadable@5.5.2", "react-loadable@npm:@docusaurus/react-loadable@5.5.2":
+  version "5.5.2"
+  resolved "https://registry.yarnpkg.com/@docusaurus/react-loadable/-/react-loadable-5.5.2.tgz#81aae0db81ecafbdaee3651f12804580868fa6ce"
+  integrity sha512-A3dYjdBGuy0IGT+wyLIGIKLRE+sAk1iNk0f1HjNDysO7u8lhL4N3VEm+FAubmJbAztn94F7MxBTPmnixbiyFdQ==
+  dependencies:
+    "@types/react" "*"
+    prop-types "^15.6.2"
+
+"@docusaurus/theme-classic@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/theme-classic/-/theme-classic-2.0.1.tgz#043b6fcd2ecb2aecd134419b198c9f519029d5e7"
+  integrity sha512-0jfigiqkUwIuKOw7Me5tqUM9BBvoQX7qqeevx7v4tkYQexPhk3VYSZo7aRuoJ9oyW5makCTPX551PMJzmq7+sw==
+  dependencies:
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/mdx-loader" "2.0.1"
+    "@docusaurus/module-type-aliases" "2.0.1"
+    "@docusaurus/plugin-content-blog" "2.0.1"
+    "@docusaurus/plugin-content-docs" "2.0.1"
+    "@docusaurus/plugin-content-pages" "2.0.1"
+    "@docusaurus/theme-common" "2.0.1"
+    "@docusaurus/theme-translations" "2.0.1"
+    "@docusaurus/types" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    "@docusaurus/utils-common" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    "@mdx-js/react" "^1.6.22"
+    clsx "^1.2.1"
+    copy-text-to-clipboard "^3.0.1"
+    infima "0.2.0-alpha.42"
+    lodash "^4.17.21"
+    nprogress "^0.2.0"
+    postcss "^8.4.14"
+    prism-react-renderer "^1.3.5"
+    prismjs "^1.28.0"
+    react-router-dom "^5.3.3"
+    rtlcss "^3.5.0"
+    tslib "^2.4.0"
+    utility-types "^3.10.0"
+
+"@docusaurus/theme-common@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/theme-common/-/theme-common-2.0.1.tgz#9594d58fbef11fe480967b5ce4cdbb3cd78d9ca3"
+  integrity sha512-I3b6e/ryiTQMsbES40cP0DRGnfr0E2qghVq+XecyMKjBPejISoSFEDn0MsnbW8Q26k1Dh/0qDH8QKDqaZZgLhA==
+  dependencies:
+    "@docusaurus/mdx-loader" "2.0.1"
+    "@docusaurus/module-type-aliases" "2.0.1"
+    "@docusaurus/plugin-content-blog" "2.0.1"
+    "@docusaurus/plugin-content-docs" "2.0.1"
+    "@docusaurus/plugin-content-pages" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    "@types/history" "^4.7.11"
+    "@types/react" "*"
+    "@types/react-router-config" "*"
+    clsx "^1.2.1"
+    parse-numeric-range "^1.3.0"
+    prism-react-renderer "^1.3.5"
+    tslib "^2.4.0"
+    utility-types "^3.10.0"
+
+"@docusaurus/theme-search-algolia@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/theme-search-algolia/-/theme-search-algolia-2.0.1.tgz#0aab8407b2163f67eb4c48f1de33944e1695fa74"
+  integrity sha512-cw3NaOSKbYlsY6uNj4PgO+5mwyQ3aEWre5RlmvjStaz2cbD15Nr69VG8Rd/F6Q5VsCT8BvSdkPDdDG5d/ACexg==
+  dependencies:
+    "@docsearch/react" "^3.1.1"
+    "@docusaurus/core" "2.0.1"
+    "@docusaurus/logger" "2.0.1"
+    "@docusaurus/plugin-content-docs" "2.0.1"
+    "@docusaurus/theme-common" "2.0.1"
+    "@docusaurus/theme-translations" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    "@docusaurus/utils-validation" "2.0.1"
+    algoliasearch "^4.13.1"
+    algoliasearch-helper "^3.10.0"
+    clsx "^1.2.1"
+    eta "^1.12.3"
+    fs-extra "^10.1.0"
+    lodash "^4.17.21"
+    tslib "^2.4.0"
+    utility-types "^3.10.0"
+
+"@docusaurus/theme-translations@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/theme-translations/-/theme-translations-2.0.1.tgz#955a687c974265a811bfc743d98ef3eab0379100"
+  integrity sha512-v1MYYlbsdX+rtKnXFcIAn9ar0Z6K0yjqnCYS0p/KLCLrfJwfJ8A3oRJw2HiaIb8jQfk1WMY2h5Qi1p4vHOekQw==
+  dependencies:
+    fs-extra "^10.1.0"
+    tslib "^2.4.0"
+
+"@docusaurus/types@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/types/-/types-2.0.1.tgz#8696a70e85c4b9be80b38ac592d520f6fe72618b"
+  integrity sha512-o+4hAFWkj3sBszVnRTAnNqtAIuIW0bNaYyDwQhQ6bdz3RAPEq9cDKZxMpajsj4z2nRty8XjzhyufAAjxFTyrfg==
+  dependencies:
+    "@types/history" "^4.7.11"
+    "@types/react" "*"
+    commander "^5.1.0"
+    joi "^17.6.0"
+    react-helmet-async "^1.3.0"
+    utility-types "^3.10.0"
+    webpack "^5.73.0"
+    webpack-merge "^5.8.0"
+
+"@docusaurus/types@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/types/-/types-2.4.3.tgz#4aead281ca09f721b3c0a9b926818450cfa3db31"
+  integrity sha512-W6zNLGQqfrp/EoPD0bhb9n7OobP+RHpmvVzpA+Z/IuU3Q63njJM24hmT0GYboovWcDtFmnIJC9wcyx4RVPQscw==
+  dependencies:
+    "@types/history" "^4.7.11"
+    "@types/react" "*"
+    commander "^5.1.0"
+    joi "^17.6.0"
+    react-helmet-async "^1.3.0"
+    utility-types "^3.10.0"
+    webpack "^5.73.0"
+    webpack-merge "^5.8.0"
+
+"@docusaurus/utils-common@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils-common/-/utils-common-2.0.1.tgz#b6f2b029547f739e1431ec84abd16974edf495e0"
+  integrity sha512-kajCCDCXRd1HFH5EUW31MPaQcsyNlGakpkDoTBtBvpa4EIPvWaSKy7TIqYKHrZjX4tnJ0YbEJvaXfjjgdq5xSg==
+  dependencies:
+    tslib "^2.4.0"
+
+"@docusaurus/utils-common@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils-common/-/utils-common-2.4.3.tgz#30656c39ef1ce7e002af7ba39ea08330f58efcfb"
+  integrity sha512-/jascp4GbLQCPVmcGkPzEQjNaAk3ADVfMtudk49Ggb+131B1WDD6HqlSmDf8MxGdy7Dja2gc+StHf01kiWoTDQ==
+  dependencies:
+    tslib "^2.4.0"
+
+"@docusaurus/utils-validation@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils-validation/-/utils-validation-2.0.1.tgz#69f7d4944288d71f00fdba6dde10f05008f04308"
+  integrity sha512-f14AnwFBy4/1A19zWthK+Ii80YDz+4qt8oPpK3julywXsheSxPBqgsND3LVBBvB2p3rJHvbo2m3HyB9Tco1JRw==
+  dependencies:
+    "@docusaurus/logger" "2.0.1"
+    "@docusaurus/utils" "2.0.1"
+    joi "^17.6.0"
+    js-yaml "^4.1.0"
+    tslib "^2.4.0"
+
+"@docusaurus/utils-validation@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils-validation/-/utils-validation-2.4.3.tgz#8122c394feef3e96c73f6433987837ec206a63fb"
+  integrity sha512-G2+Vt3WR5E/9drAobP+hhZQMaswRwDlp6qOMi7o7ZypB+VO7N//DZWhZEwhcRGepMDJGQEwtPv7UxtYwPL9PBw==
+  dependencies:
+    "@docusaurus/logger" "2.4.3"
+    "@docusaurus/utils" "2.4.3"
+    joi "^17.6.0"
+    js-yaml "^4.1.0"
+    tslib "^2.4.0"
+
+"@docusaurus/utils@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils/-/utils-2.0.1.tgz#37b4b42e29175e5d2d811fcbf9f93bffeca7c353"
+  integrity sha512-u2Vdl/eoVwMfUjDCkg7FjxoiwFs/XhVVtNxQEw8cvB+qaw6QWyT73m96VZzWtUb1fDOefHoZ+bZ0ObFeKk9lMQ==
+  dependencies:
+    "@docusaurus/logger" "2.0.1"
+    "@svgr/webpack" "^6.2.1"
+    file-loader "^6.2.0"
+    fs-extra "^10.1.0"
+    github-slugger "^1.4.0"
+    globby "^11.1.0"
+    gray-matter "^4.0.3"
+    js-yaml "^4.1.0"
+    lodash "^4.17.21"
+    micromatch "^4.0.5"
+    resolve-pathname "^3.0.0"
+    shelljs "^0.8.5"
+    tslib "^2.4.0"
+    url-loader "^4.1.1"
+    webpack "^5.73.0"
+
+"@docusaurus/utils@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@docusaurus/utils/-/utils-2.4.3.tgz#52b000d989380a2125831b84e3a7327bef471e89"
+  integrity sha512-fKcXsjrD86Smxv8Pt0TBFqYieZZCPh4cbf9oszUq/AMhZn3ujwpKaVYZACPX8mmjtYx0JOgNx52CREBfiGQB4A==
+  dependencies:
+    "@docusaurus/logger" "2.4.3"
+    "@svgr/webpack" "^6.2.1"
+    escape-string-regexp "^4.0.0"
+    file-loader "^6.2.0"
+    fs-extra "^10.1.0"
+    github-slugger "^1.4.0"
+    globby "^11.1.0"
+    gray-matter "^4.0.3"
+    js-yaml "^4.1.0"
+    lodash "^4.17.21"
+    micromatch "^4.0.5"
+    resolve-pathname "^3.0.0"
+    shelljs "^0.8.5"
+    tslib "^2.4.0"
+    url-loader "^4.1.1"
+    webpack "^5.73.0"
+
+"@hapi/hoek@^9.0.0", "@hapi/hoek@^9.3.0":
+  version "9.3.0"
+  resolved "https://registry.yarnpkg.com/@hapi/hoek/-/hoek-9.3.0.tgz#8368869dcb735be2e7f5cb7647de78e167a251fb"
+  integrity sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ==
+
+"@hapi/topo@^5.1.0":
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/@hapi/topo/-/topo-5.1.0.tgz#dc448e332c6c6e37a4dc02fd84ba8d44b9afb012"
+  integrity sha512-foQZKJig7Ob0BMAYBfcJk8d77QtOe7Wo4ox7ff1lQYoNNAb6jwcY1ncdoy2e9wQZzvNy7ODZCYJkK8kzmcAnAg==
+  dependencies:
+    "@hapi/hoek" "^9.0.0"
+
+"@jest/schemas@^29.6.3":
+  version "29.6.3"
+  resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-29.6.3.tgz#430b5ce8a4e0044a7e3819663305a7b3091c8e03"
+  integrity sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==
+  dependencies:
+    "@sinclair/typebox" "^0.27.8"
+
+"@jest/types@^29.6.3":
+  version "29.6.3"
+  resolved "https://registry.yarnpkg.com/@jest/types/-/types-29.6.3.tgz#1131f8cf634e7e84c5e77bab12f052af585fba59"
+  integrity sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==
+  dependencies:
+    "@jest/schemas" "^29.6.3"
+    "@types/istanbul-lib-coverage" "^2.0.0"
+    "@types/istanbul-reports" "^3.0.0"
+    "@types/node" "*"
+    "@types/yargs" "^17.0.8"
+    chalk "^4.0.0"
+
+"@jridgewell/gen-mapping@^0.3.0", "@jridgewell/gen-mapping@^0.3.2":
+  version "0.3.3"
+  resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz#7e02e6eb5df901aaedb08514203b096614024098"
+  integrity sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==
+  dependencies:
+    "@jridgewell/set-array" "^1.0.1"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+    "@jridgewell/trace-mapping" "^0.3.9"
+
+"@jridgewell/resolve-uri@^3.1.0":
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz#7a0ee601f60f99a20c7c7c5ff0c80388c1189bd6"
+  integrity sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==
+
+"@jridgewell/set-array@^1.0.1":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72"
+  integrity sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==
+
+"@jridgewell/source-map@^0.3.3":
+  version "0.3.5"
+  resolved "https://registry.yarnpkg.com/@jridgewell/source-map/-/source-map-0.3.5.tgz#a3bb4d5c6825aab0d281268f47f6ad5853431e91"
+  integrity sha512-UTYAUj/wviwdsMfzoSJspJxbkH5o1snzwX0//0ENX1u/55kkZZkcTZP6u9bwKGkv+dkk9at4m1Cpt0uY80kcpQ==
+  dependencies:
+    "@jridgewell/gen-mapping" "^0.3.0"
+    "@jridgewell/trace-mapping" "^0.3.9"
+
+"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14":
+  version "1.4.15"
+  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32"
+  integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==
+
+"@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.20", "@jridgewell/trace-mapping@^0.3.9":
+  version "0.3.22"
+  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.22.tgz#72a621e5de59f5f1ef792d0793a82ee20f645e4c"
+  integrity sha512-Wf963MzWtA2sjrNt+g18IAln9lKnlRp+K2eH4jjIoF1wYeq3aMREpG09xhlhdzS0EjwU7qmUJYangWa+151vZw==
+  dependencies:
+    "@jridgewell/resolve-uri" "^3.1.0"
+    "@jridgewell/sourcemap-codec" "^1.4.14"
+
+"@leichtgewicht/ip-codec@^2.0.1":
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/@leichtgewicht/ip-codec/-/ip-codec-2.0.4.tgz#b2ac626d6cb9c8718ab459166d4bb405b8ffa78b"
+  integrity sha512-Hcv+nVC0kZnQ3tD9GVu5xSMR4VVYOteQIr/hwFPVEvPdlXqgGEuRjiheChHgdM+JyqdgNcmzZOX/tnl0JOiI7A==
+
+"@mdx-js/mdx@^1.6.22":
+  version "1.6.22"
+  resolved "https://registry.yarnpkg.com/@mdx-js/mdx/-/mdx-1.6.22.tgz#8a723157bf90e78f17dc0f27995398e6c731f1ba"
+  integrity sha512-AMxuLxPz2j5/6TpF/XSdKpQP1NlG0z11dFOlq+2IP/lSgl11GY8ji6S/rgsViN/L0BDvHvUMruRb7ub+24LUYA==
+  dependencies:
+    "@babel/core" "7.12.9"
+    "@babel/plugin-syntax-jsx" "7.12.1"
+    "@babel/plugin-syntax-object-rest-spread" "7.8.3"
+    "@mdx-js/util" "1.6.22"
+    babel-plugin-apply-mdx-type-prop "1.6.22"
+    babel-plugin-extract-import-names "1.6.22"
+    camelcase-css "2.0.1"
+    detab "2.0.4"
+    hast-util-raw "6.0.1"
+    lodash.uniq "4.5.0"
+    mdast-util-to-hast "10.0.1"
+    remark-footnotes "2.0.0"
+    remark-mdx "1.6.22"
+    remark-parse "8.0.3"
+    remark-squeeze-paragraphs "4.0.0"
+    style-to-object "0.3.0"
+    unified "9.2.0"
+    unist-builder "2.0.3"
+    unist-util-visit "2.0.3"
+
+"@mdx-js/react@^1.6.22":
+  version "1.6.22"
+  resolved "https://registry.yarnpkg.com/@mdx-js/react/-/react-1.6.22.tgz#ae09b4744fddc74714ee9f9d6f17a66e77c43573"
+  integrity sha512-TDoPum4SHdfPiGSAaRBw7ECyI8VaHpK8GJugbJIJuqyh6kzw9ZLJZW3HGL3NNrJGxcAixUvqROm+YuQOo5eXtg==
+
+"@mdx-js/util@1.6.22":
+  version "1.6.22"
+  resolved "https://registry.yarnpkg.com/@mdx-js/util/-/util-1.6.22.tgz#219dfd89ae5b97a8801f015323ffa4b62f45718b"
+  integrity sha512-H1rQc1ZOHANWBvPcW+JpGwr+juXSxM8Q8YCkm3GhZd8REu1fHR3z99CErO1p9pkcfcxZnMdIZdIsXkOHY0NilA==
+
+"@nodelib/fs.scandir@2.1.5":
+  version "2.1.5"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
+  integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
+  dependencies:
+    "@nodelib/fs.stat" "2.0.5"
+    run-parallel "^1.1.9"
+
+"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b"
+  integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
+
+"@nodelib/fs.walk@^1.2.3":
+  version "1.2.8"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a"
+  integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
+  dependencies:
+    "@nodelib/fs.scandir" "2.1.5"
+    fastq "^1.6.0"
+
+"@polka/url@^1.0.0-next.24":
+  version "1.0.0-next.24"
+  resolved "https://registry.yarnpkg.com/@polka/url/-/url-1.0.0-next.24.tgz#58601079e11784d20f82d0585865bb42305c4df3"
+  integrity sha512-2LuNTFBIO0m7kKIQvvPHN6UE63VjpmL9rnEEaOOaiSPbZK+zUOYIzBAWcED+3XYzhYsd/0mD57VdxAEqqV52CQ==
+
+"@sideway/address@^4.1.5":
+  version "4.1.5"
+  resolved "https://registry.yarnpkg.com/@sideway/address/-/address-4.1.5.tgz#4bc149a0076623ced99ca8208ba780d65a99b9d5"
+  integrity sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==
+  dependencies:
+    "@hapi/hoek" "^9.0.0"
+
+"@sideway/formula@^3.0.1":
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/@sideway/formula/-/formula-3.0.1.tgz#80fcbcbaf7ce031e0ef2dd29b1bfc7c3f583611f"
+  integrity sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg==
+
+"@sideway/pinpoint@^2.0.0":
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/@sideway/pinpoint/-/pinpoint-2.0.0.tgz#cff8ffadc372ad29fd3f78277aeb29e632cc70df"
+  integrity sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==
+
+"@sinclair/typebox@^0.27.8":
+  version "0.27.8"
+  resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.27.8.tgz#6667fac16c436b5434a387a34dedb013198f6e6e"
+  integrity sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==
+
+"@sindresorhus/is@^0.14.0":
+  version "0.14.0"
+  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-0.14.0.tgz#9fb3a3cf3132328151f353de4632e01e52102bea"
+  integrity sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==
+
+"@slorber/static-site-generator-webpack-plugin@^4.0.7":
+  version "4.0.7"
+  resolved "https://registry.yarnpkg.com/@slorber/static-site-generator-webpack-plugin/-/static-site-generator-webpack-plugin-4.0.7.tgz#fc1678bddefab014e2145cbe25b3ce4e1cfc36f3"
+  integrity sha512-Ug7x6z5lwrz0WqdnNFOMYrDQNTPAprvHLSh6+/fmml3qUiz6l5eq+2MzLKWtn/q5K5NpSiFsZTP/fck/3vjSxA==
+  dependencies:
+    eval "^0.1.8"
+    p-map "^4.0.0"
+    webpack-sources "^3.2.2"
+
+"@svgr/babel-plugin-add-jsx-attribute@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-6.5.1.tgz#74a5d648bd0347bda99d82409d87b8ca80b9a1ba"
+  integrity sha512-9PYGcXrAxitycIjRmZB+Q0JaN07GZIWaTBIGQzfaZv+qr1n8X1XUEJ5rZ/vx6OVD9RRYlrNnXWExQXcmZeD/BQ==
+
+"@svgr/babel-plugin-remove-jsx-attribute@*":
+  version "8.0.0"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz#69177f7937233caca3a1afb051906698f2f59186"
+  integrity sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA==
+
+"@svgr/babel-plugin-remove-jsx-empty-expression@*":
+  version "8.0.0"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz#c2c48104cfd7dcd557f373b70a56e9e3bdae1d44"
+  integrity sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA==
+
+"@svgr/babel-plugin-replace-jsx-attribute-value@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-6.5.1.tgz#fb9d22ea26d2bc5e0a44b763d4c46d5d3f596c60"
+  integrity sha512-8DPaVVE3fd5JKuIC29dqyMB54sA6mfgki2H2+swh+zNJoynC8pMPzOkidqHOSc6Wj032fhl8Z0TVn1GiPpAiJg==
+
+"@svgr/babel-plugin-svg-dynamic-title@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-6.5.1.tgz#01b2024a2b53ffaa5efceaa0bf3e1d5a4c520ce4"
+  integrity sha512-FwOEi0Il72iAzlkaHrlemVurgSQRDFbk0OC8dSvD5fSBPHltNh7JtLsxmZUhjYBZo2PpcU/RJvvi6Q0l7O7ogw==
+
+"@svgr/babel-plugin-svg-em-dimensions@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-6.5.1.tgz#dd3fa9f5b24eb4f93bcf121c3d40ff5facecb217"
+  integrity sha512-gWGsiwjb4tw+ITOJ86ndY/DZZ6cuXMNE/SjcDRg+HLuCmwpcjOktwRF9WgAiycTqJD/QXqL2f8IzE2Rzh7aVXA==
+
+"@svgr/babel-plugin-transform-react-native-svg@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-6.5.1.tgz#1d8e945a03df65b601551097d8f5e34351d3d305"
+  integrity sha512-2jT3nTayyYP7kI6aGutkyfJ7UMGtuguD72OjeGLwVNyfPRBD8zQthlvL+fAbAKk5n9ZNcvFkp/b1lZ7VsYqVJg==
+
+"@svgr/babel-plugin-transform-svg-component@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-6.5.1.tgz#48620b9e590e25ff95a80f811544218d27f8a250"
+  integrity sha512-a1p6LF5Jt33O3rZoVRBqdxL350oge54iZWHNI6LJB5tQ7EelvD/Mb1mfBiZNAan0dt4i3VArkFRjA4iObuNykQ==
+
+"@svgr/babel-preset@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-preset/-/babel-preset-6.5.1.tgz#b90de7979c8843c5c580c7e2ec71f024b49eb828"
+  integrity sha512-6127fvO/FF2oi5EzSQOAjo1LE3OtNVh11R+/8FXa+mHx1ptAaS4cknIjnUA7e6j6fwGGJ17NzaTJFUwOV2zwCw==
+  dependencies:
+    "@svgr/babel-plugin-add-jsx-attribute" "^6.5.1"
+    "@svgr/babel-plugin-remove-jsx-attribute" "*"
+    "@svgr/babel-plugin-remove-jsx-empty-expression" "*"
+    "@svgr/babel-plugin-replace-jsx-attribute-value" "^6.5.1"
+    "@svgr/babel-plugin-svg-dynamic-title" "^6.5.1"
+    "@svgr/babel-plugin-svg-em-dimensions" "^6.5.1"
+    "@svgr/babel-plugin-transform-react-native-svg" "^6.5.1"
+    "@svgr/babel-plugin-transform-svg-component" "^6.5.1"
+
+"@svgr/core@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/core/-/core-6.5.1.tgz#d3e8aa9dbe3fbd747f9ee4282c1c77a27410488a"
+  integrity sha512-/xdLSWxK5QkqG524ONSjvg3V/FkNyCv538OIBdQqPNaAta3AsXj/Bd2FbvR87yMbXO2hFSWiAe/Q6IkVPDw+mw==
+  dependencies:
+    "@babel/core" "^7.19.6"
+    "@svgr/babel-preset" "^6.5.1"
+    "@svgr/plugin-jsx" "^6.5.1"
+    camelcase "^6.2.0"
+    cosmiconfig "^7.0.1"
+
+"@svgr/hast-util-to-babel-ast@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-6.5.1.tgz#81800bd09b5bcdb968bf6ee7c863d2288fdb80d2"
+  integrity sha512-1hnUxxjd83EAxbL4a0JDJoD3Dao3hmjvyvyEV8PzWmLK3B9m9NPlW7GKjFyoWE8nM7HnXzPcmmSyOW8yOddSXw==
+  dependencies:
+    "@babel/types" "^7.20.0"
+    entities "^4.4.0"
+
+"@svgr/plugin-jsx@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/plugin-jsx/-/plugin-jsx-6.5.1.tgz#0e30d1878e771ca753c94e69581c7971542a7072"
+  integrity sha512-+UdQxI3jgtSjCykNSlEMuy1jSRQlGC7pqBCPvkG/2dATdWo082zHTTK3uhnAju2/6XpE6B5mZ3z4Z8Ns01S8Gw==
+  dependencies:
+    "@babel/core" "^7.19.6"
+    "@svgr/babel-preset" "^6.5.1"
+    "@svgr/hast-util-to-babel-ast" "^6.5.1"
+    svg-parser "^2.0.4"
+
+"@svgr/plugin-svgo@^6.5.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/plugin-svgo/-/plugin-svgo-6.5.1.tgz#0f91910e988fc0b842f88e0960c2862e022abe84"
+  integrity sha512-omvZKf8ixP9z6GWgwbtmP9qQMPX4ODXi+wzbVZgomNFsUIlHA1sf4fThdwTWSsZGgvGAG6yE+b/F5gWUkcZ/iQ==
+  dependencies:
+    cosmiconfig "^7.0.1"
+    deepmerge "^4.2.2"
+    svgo "^2.8.0"
+
+"@svgr/webpack@^6.2.1":
+  version "6.5.1"
+  resolved "https://registry.yarnpkg.com/@svgr/webpack/-/webpack-6.5.1.tgz#ecf027814fc1cb2decc29dc92f39c3cf691e40e8"
+  integrity sha512-cQ/AsnBkXPkEK8cLbv4Dm7JGXq2XrumKnL1dRpJD9rIO2fTIlJI9a1uCciYG1F2aUsox/hJQyNGbt3soDxSRkA==
+  dependencies:
+    "@babel/core" "^7.19.6"
+    "@babel/plugin-transform-react-constant-elements" "^7.18.12"
+    "@babel/preset-env" "^7.19.4"
+    "@babel/preset-react" "^7.18.6"
+    "@babel/preset-typescript" "^7.18.6"
+    "@svgr/core" "^6.5.1"
+    "@svgr/plugin-jsx" "^6.5.1"
+    "@svgr/plugin-svgo" "^6.5.1"
+
+"@szmarczak/http-timer@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-1.1.2.tgz#b1665e2c461a2cd92f4c1bbf50d5454de0d4b421"
+  integrity sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==
+  dependencies:
+    defer-to-connect "^1.0.1"
+
+"@trysound/sax@0.2.0":
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/@trysound/sax/-/sax-0.2.0.tgz#cccaab758af56761eb7bf37af6f03f326dd798ad"
+  integrity sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==
+
+"@types/body-parser@*":
+  version "1.19.5"
+  resolved "https://registry.yarnpkg.com/@types/body-parser/-/body-parser-1.19.5.tgz#04ce9a3b677dc8bd681a17da1ab9835dc9d3ede4"
+  integrity sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==
+  dependencies:
+    "@types/connect" "*"
+    "@types/node" "*"
+
+"@types/bonjour@^3.5.9":
+  version "3.5.13"
+  resolved "https://registry.yarnpkg.com/@types/bonjour/-/bonjour-3.5.13.tgz#adf90ce1a105e81dd1f9c61fdc5afda1bfb92956"
+  integrity sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==
+  dependencies:
+    "@types/node" "*"
+
+"@types/connect-history-api-fallback@^1.3.5":
+  version "1.5.4"
+  resolved "https://registry.yarnpkg.com/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.4.tgz#7de71645a103056b48ac3ce07b3520b819c1d5b3"
+  integrity sha512-n6Cr2xS1h4uAulPRdlw6Jl6s1oG8KrVilPN2yUITEs+K48EzMJJ3W1xy8K5eWuFvjp3R74AOIGSmp2UfBJ8HFw==
+  dependencies:
+    "@types/express-serve-static-core" "*"
+    "@types/node" "*"
+
+"@types/connect@*":
+  version "3.4.38"
+  resolved "https://registry.yarnpkg.com/@types/connect/-/connect-3.4.38.tgz#5ba7f3bc4fbbdeaff8dded952e5ff2cc53f8d858"
+  integrity sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==
+  dependencies:
+    "@types/node" "*"
+
+"@types/eslint-scope@^3.7.3":
+  version "3.7.7"
+  resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.7.tgz#3108bd5f18b0cdb277c867b3dd449c9ed7079ac5"
+  integrity sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==
+  dependencies:
+    "@types/eslint" "*"
+    "@types/estree" "*"
+
+"@types/eslint@*":
+  version "8.56.2"
+  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-8.56.2.tgz#1c72a9b794aa26a8b94ad26d5b9aa51c8a6384bb"
+  integrity sha512-uQDwm1wFHmbBbCZCqAlq6Do9LYwByNZHWzXppSnay9SuwJ+VRbjkbLABer54kcPnMSlG6Fdiy2yaFXm/z9Z5gw==
+  dependencies:
+    "@types/estree" "*"
+    "@types/json-schema" "*"
+
+"@types/estree@*", "@types/estree@^1.0.5":
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.5.tgz#a6ce3e556e00fd9895dd872dd172ad0d4bd687f4"
+  integrity sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==
+
+"@types/express-serve-static-core@*", "@types/express-serve-static-core@^4.17.33":
+  version "4.17.43"
+  resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.17.43.tgz#10d8444be560cb789c4735aea5eac6e5af45df54"
+  integrity sha512-oaYtiBirUOPQGSWNGPWnzyAFJ0BP3cwvN4oWZQY+zUBwpVIGsKUkpBpSztp74drYcjavs7SKFZ4DX1V2QeN8rg==
+  dependencies:
+    "@types/node" "*"
+    "@types/qs" "*"
+    "@types/range-parser" "*"
+    "@types/send" "*"
+
+"@types/express@*", "@types/express@^4.17.13":
+  version "4.17.21"
+  resolved "https://registry.yarnpkg.com/@types/express/-/express-4.17.21.tgz#c26d4a151e60efe0084b23dc3369ebc631ed192d"
+  integrity sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==
+  dependencies:
+    "@types/body-parser" "*"
+    "@types/express-serve-static-core" "^4.17.33"
+    "@types/qs" "*"
+    "@types/serve-static" "*"
+
+"@types/hast@^2.0.0":
+  version "2.3.10"
+  resolved "https://registry.yarnpkg.com/@types/hast/-/hast-2.3.10.tgz#5c9d9e0b304bbb8879b857225c5ebab2d81d7643"
+  integrity sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==
+  dependencies:
+    "@types/unist" "^2"
+
+"@types/history@^4.7.11":
+  version "4.7.11"
+  resolved "https://registry.yarnpkg.com/@types/history/-/history-4.7.11.tgz#56588b17ae8f50c53983a524fc3cc47437969d64"
+  integrity sha512-qjDJRrmvBMiTx+jyLxvLfJU7UznFuokDv4f3WRuriHKERccVpFU+8XMQUAbDzoiJCsmexxRExQeMwwCdamSKDA==
+
+"@types/html-minifier-terser@^6.0.0":
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz#4fc33a00c1d0c16987b1a20cf92d20614c55ac35"
+  integrity sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg==
+
+"@types/http-errors@*":
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/@types/http-errors/-/http-errors-2.0.4.tgz#7eb47726c391b7345a6ec35ad7f4de469cf5ba4f"
+  integrity sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==
+
+"@types/http-proxy@^1.17.8":
+  version "1.17.14"
+  resolved "https://registry.yarnpkg.com/@types/http-proxy/-/http-proxy-1.17.14.tgz#57f8ccaa1c1c3780644f8a94f9c6b5000b5e2eec"
+  integrity sha512-SSrD0c1OQzlFX7pGu1eXxSEjemej64aaNPRhhVYUGqXh0BtldAAx37MG8btcumvpgKyZp1F5Gn3JkktdxiFv6w==
+  dependencies:
+    "@types/node" "*"
+
+"@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0":
+  version "2.0.6"
+  resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz#7739c232a1fee9b4d3ce8985f314c0c6d33549d7"
+  integrity sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==
+
+"@types/istanbul-lib-report@*":
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz#53047614ae72e19fc0401d872de3ae2b4ce350bf"
+  integrity sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==
+  dependencies:
+    "@types/istanbul-lib-coverage" "*"
+
+"@types/istanbul-reports@^3.0.0":
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz#0f03e3d2f670fbdac586e34b433783070cc16f54"
+  integrity sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==
+  dependencies:
+    "@types/istanbul-lib-report" "*"
+
+"@types/json-schema@*", "@types/json-schema@^7.0.4", "@types/json-schema@^7.0.5", "@types/json-schema@^7.0.8", "@types/json-schema@^7.0.9":
+  version "7.0.15"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.15.tgz#596a1747233694d50f6ad8a7869fcb6f56cf5841"
+  integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==
+
+"@types/mdast@^3.0.0":
+  version "3.0.15"
+  resolved "https://registry.yarnpkg.com/@types/mdast/-/mdast-3.0.15.tgz#49c524a263f30ffa28b71ae282f813ed000ab9f5"
+  integrity sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==
+  dependencies:
+    "@types/unist" "^2"
+
+"@types/mime@*":
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/@types/mime/-/mime-3.0.4.tgz#2198ac274de6017b44d941e00261d5bc6a0e0a45"
+  integrity sha512-iJt33IQnVRkqeqC7PzBHPTC6fDlRNRW8vjrgqtScAhrmMwe8c4Eo7+fUGTa+XdWrpEgpyKWMYmi2dIwMAYRzPw==
+
+"@types/mime@^1":
+  version "1.3.5"
+  resolved "https://registry.yarnpkg.com/@types/mime/-/mime-1.3.5.tgz#1ef302e01cf7d2b5a0fa526790c9123bf1d06690"
+  integrity sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==
+
+"@types/node-forge@^1.3.0":
+  version "1.3.11"
+  resolved "https://registry.yarnpkg.com/@types/node-forge/-/node-forge-1.3.11.tgz#0972ea538ddb0f4d9c2fa0ec5db5724773a604da"
+  integrity sha512-FQx220y22OKNTqaByeBGqHWYz4cl94tpcxeFdvBo3wjG6XPBuZ0BNgNZRV5J5TFmmcsJ4IzsLkmGRiQbnYsBEQ==
+  dependencies:
+    "@types/node" "*"
+
+"@types/node@*":
+  version "20.11.19"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.11.19.tgz#b466de054e9cb5b3831bee38938de64ac7f81195"
+  integrity sha512-7xMnVEcZFu0DikYjWOlRq7NTPETrm7teqUT2WkQjrTIkEgUyyGdWsj/Zg8bEJt5TNklzbPD1X3fqfsHw3SpapQ==
+  dependencies:
+    undici-types "~5.26.4"
+
+"@types/node@^17.0.5":
+  version "17.0.45"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-17.0.45.tgz#2c0fafd78705e7a18b7906b5201a522719dc5190"
+  integrity sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw==
+
+"@types/parse-json@^4.0.0":
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/@types/parse-json/-/parse-json-4.0.2.tgz#5950e50960793055845e956c427fc2b0d70c5239"
+  integrity sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==
+
+"@types/parse5@^5.0.0":
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/@types/parse5/-/parse5-5.0.3.tgz#e7b5aebbac150f8b5fdd4a46e7f0bd8e65e19109"
+  integrity sha512-kUNnecmtkunAoQ3CnjmMkzNU/gtxG8guhi+Fk2U/kOpIKjIMKnXGp4IJCgQJrXSgMsWYimYG4TGjz/UzbGEBTw==
+
+"@types/prop-types@*":
+  version "15.7.11"
+  resolved "https://registry.yarnpkg.com/@types/prop-types/-/prop-types-15.7.11.tgz#2596fb352ee96a1379c657734d4b913a613ad563"
+  integrity sha512-ga8y9v9uyeiLdpKddhxYQkxNDrfvuPrlFb0N1qnZZByvcElJaXthF1UhvCh9TLWJBEHeNtdnbysW7Y6Uq8CVng==
+
+"@types/qs@*":
+  version "6.9.11"
+  resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.9.11.tgz#208d8a30bc507bd82e03ada29e4732ea46a6bbda"
+  integrity sha512-oGk0gmhnEJK4Yyk+oI7EfXsLayXatCWPHary1MtcmbAifkobT9cM9yutG/hZKIseOU0MqbIwQ/u2nn/Gb+ltuQ==
+
+"@types/range-parser@*":
+  version "1.2.7"
+  resolved "https://registry.yarnpkg.com/@types/range-parser/-/range-parser-1.2.7.tgz#50ae4353eaaddc04044279812f52c8c65857dbcb"
+  integrity sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==
+
+"@types/react-router-config@*", "@types/react-router-config@^5.0.6":
+  version "5.0.11"
+  resolved "https://registry.yarnpkg.com/@types/react-router-config/-/react-router-config-5.0.11.tgz#2761a23acc7905a66a94419ee40294a65aaa483a"
+  integrity sha512-WmSAg7WgqW7m4x8Mt4N6ZyKz0BubSj/2tVUMsAHp+Yd2AMwcSbeFq9WympT19p5heCFmF97R9eD5uUR/t4HEqw==
+  dependencies:
+    "@types/history" "^4.7.11"
+    "@types/react" "*"
+    "@types/react-router" "^5.1.0"
+
+"@types/react-router-dom@*":
+  version "5.3.3"
+  resolved "https://registry.yarnpkg.com/@types/react-router-dom/-/react-router-dom-5.3.3.tgz#e9d6b4a66fcdbd651a5f106c2656a30088cc1e83"
+  integrity sha512-kpqnYK4wcdm5UaWI3fLcELopqLrHgLqNsdpHauzlQktfkHL3npOSwtj1Uz9oKBAzs7lFtVkV8j83voAz2D8fhw==
+  dependencies:
+    "@types/history" "^4.7.11"
+    "@types/react" "*"
+    "@types/react-router" "*"
+
+"@types/react-router@*", "@types/react-router@^5.1.0":
+  version "5.1.20"
+  resolved "https://registry.yarnpkg.com/@types/react-router/-/react-router-5.1.20.tgz#88eccaa122a82405ef3efbcaaa5dcdd9f021387c"
+  integrity sha512-jGjmu/ZqS7FjSH6owMcD5qpq19+1RS9DeVRqfl1FeBMxTDQAGwlMWOcs52NDoXaNKyG3d1cYQFMs9rCrb88o9Q==
+  dependencies:
+    "@types/history" "^4.7.11"
+    "@types/react" "*"
+
+"@types/react@*":
+  version "18.2.56"
+  resolved "https://registry.yarnpkg.com/@types/react/-/react-18.2.56.tgz#2d3e9021a0b6eb5bfc227761cc61b1c6dc6e0cd8"
+  integrity sha512-NpwHDMkS/EFZF2dONFQHgkPRwhvgq/OAvIaGQzxGSBmaeR++kTg6njr15Vatz0/2VcCEwJQFi6Jf4Q0qBu0rLA==
+  dependencies:
+    "@types/prop-types" "*"
+    "@types/scheduler" "*"
+    csstype "^3.0.2"
+
+"@types/retry@0.12.0":
+  version "0.12.0"
+  resolved "https://registry.yarnpkg.com/@types/retry/-/retry-0.12.0.tgz#2b35eccfcee7d38cd72ad99232fbd58bffb3c84d"
+  integrity sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==
+
+"@types/sax@^1.2.1":
+  version "1.2.7"
+  resolved "https://registry.yarnpkg.com/@types/sax/-/sax-1.2.7.tgz#ba5fe7df9aa9c89b6dff7688a19023dd2963091d"
+  integrity sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==
+  dependencies:
+    "@types/node" "*"
+
+"@types/scheduler@*":
+  version "0.16.8"
+  resolved "https://registry.yarnpkg.com/@types/scheduler/-/scheduler-0.16.8.tgz#ce5ace04cfeabe7ef87c0091e50752e36707deff"
+  integrity sha512-WZLiwShhwLRmeV6zH+GkbOFT6Z6VklCItrDioxUnv+u4Ll+8vKeFySoFyK/0ctcRpOmwAicELfmys1sDc/Rw+A==
+
+"@types/send@*":
+  version "0.17.4"
+  resolved "https://registry.yarnpkg.com/@types/send/-/send-0.17.4.tgz#6619cd24e7270793702e4e6a4b958a9010cfc57a"
+  integrity sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==
+  dependencies:
+    "@types/mime" "^1"
+    "@types/node" "*"
+
+"@types/serve-index@^1.9.1":
+  version "1.9.4"
+  resolved "https://registry.yarnpkg.com/@types/serve-index/-/serve-index-1.9.4.tgz#e6ae13d5053cb06ed36392110b4f9a49ac4ec898"
+  integrity sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==
+  dependencies:
+    "@types/express" "*"
+
+"@types/serve-static@*", "@types/serve-static@^1.13.10":
+  version "1.15.5"
+  resolved "https://registry.yarnpkg.com/@types/serve-static/-/serve-static-1.15.5.tgz#15e67500ec40789a1e8c9defc2d32a896f05b033"
+  integrity sha512-PDRk21MnK70hja/YF8AHfC7yIsiQHn1rcXx7ijCFBX/k+XQJhQT/gw3xekXKJvx+5SXaMMS8oqQy09Mzvz2TuQ==
+  dependencies:
+    "@types/http-errors" "*"
+    "@types/mime" "*"
+    "@types/node" "*"
+
+"@types/sockjs@^0.3.33":
+  version "0.3.36"
+  resolved "https://registry.yarnpkg.com/@types/sockjs/-/sockjs-0.3.36.tgz#ce322cf07bcc119d4cbf7f88954f3a3bd0f67535"
+  integrity sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==
+  dependencies:
+    "@types/node" "*"
+
+"@types/unist@^2", "@types/unist@^2.0.0", "@types/unist@^2.0.2", "@types/unist@^2.0.3":
+  version "2.0.10"
+  resolved "https://registry.yarnpkg.com/@types/unist/-/unist-2.0.10.tgz#04ffa7f406ab628f7f7e97ca23e290cd8ab15efc"
+  integrity sha512-IfYcSBWE3hLpBg8+X2SEa8LVkJdJEkT2Ese2aaLs3ptGdVtABxndrMaxuFlQ1qdFf9Q5rDvDpxI3WwgvKFAsQA==
+
+"@types/ws@^8.5.5":
+  version "8.5.10"
+  resolved "https://registry.yarnpkg.com/@types/ws/-/ws-8.5.10.tgz#4acfb517970853fa6574a3a6886791d04a396787"
+  integrity sha512-vmQSUcfalpIq0R9q7uTo2lXs6eGIpt9wtnLdMv9LVpIjCA/+ufZRozlVoVelIYixx1ugCBKDhn89vnsEGOCx9A==
+  dependencies:
+    "@types/node" "*"
+
+"@types/yargs-parser@*":
+  version "21.0.3"
+  resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.3.tgz#815e30b786d2e8f0dcd85fd5bcf5e1a04d008f15"
+  integrity sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==
+
+"@types/yargs@^17.0.8":
+  version "17.0.32"
+  resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-17.0.32.tgz#030774723a2f7faafebf645f4e5a48371dca6229"
+  integrity sha512-xQ67Yc/laOG5uMfX/093MRlGGCIBzZMarVa+gfNKJxWAIgykYpVGkBdbqEzGDDfCrVUj6Hiff4mTZ5BA6TmAog==
+  dependencies:
+    "@types/yargs-parser" "*"
+
+"@webassemblyjs/ast@1.11.6", "@webassemblyjs/ast@^1.11.5":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.6.tgz#db046555d3c413f8966ca50a95176a0e2c642e24"
+  integrity sha512-IN1xI7PwOvLPgjcf180gC1bqn3q/QaOCwYUahIOhbYUu8KA/3tw2RT/T0Gidi1l7Hhj5D/INhJxiICObqpMu4Q==
+  dependencies:
+    "@webassemblyjs/helper-numbers" "1.11.6"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.6"
+
+"@webassemblyjs/floating-point-hex-parser@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz#dacbcb95aff135c8260f77fa3b4c5fea600a6431"
+  integrity sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==
+
+"@webassemblyjs/helper-api-error@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz#6132f68c4acd59dcd141c44b18cbebbd9f2fa768"
+  integrity sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==
+
+"@webassemblyjs/helper-buffer@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.6.tgz#b66d73c43e296fd5e88006f18524feb0f2c7c093"
+  integrity sha512-z3nFzdcp1mb8nEOFFk8DrYLpHvhKC3grJD2ardfKOzmbmJvEf/tPIqCY+sNcwZIY8ZD7IkB2l7/pqhUhqm7hLA==
+
+"@webassemblyjs/helper-numbers@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz#cbce5e7e0c1bd32cf4905ae444ef64cea919f1b5"
+  integrity sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==
+  dependencies:
+    "@webassemblyjs/floating-point-hex-parser" "1.11.6"
+    "@webassemblyjs/helper-api-error" "1.11.6"
+    "@xtuc/long" "4.2.2"
+
+"@webassemblyjs/helper-wasm-bytecode@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz#bb2ebdb3b83aa26d9baad4c46d4315283acd51e9"
+  integrity sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==
+
+"@webassemblyjs/helper-wasm-section@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.6.tgz#ff97f3863c55ee7f580fd5c41a381e9def4aa577"
+  integrity sha512-LPpZbSOwTpEC2cgn4hTydySy1Ke+XEu+ETXuoyvuyezHO3Kjdu90KK95Sh9xTbmjrCsUwvWwCOQQNta37VrS9g==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.6"
+    "@webassemblyjs/helper-buffer" "1.11.6"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.6"
+    "@webassemblyjs/wasm-gen" "1.11.6"
+
+"@webassemblyjs/ieee754@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz#bb665c91d0b14fffceb0e38298c329af043c6e3a"
+  integrity sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==
+  dependencies:
+    "@xtuc/ieee754" "^1.2.0"
+
+"@webassemblyjs/leb128@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.11.6.tgz#70e60e5e82f9ac81118bc25381a0b283893240d7"
+  integrity sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==
+  dependencies:
+    "@xtuc/long" "4.2.2"
+
+"@webassemblyjs/utf8@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.11.6.tgz#90f8bc34c561595fe156603be7253cdbcd0fab5a"
+  integrity sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==
+
+"@webassemblyjs/wasm-edit@^1.11.5":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.6.tgz#c72fa8220524c9b416249f3d94c2958dfe70ceab"
+  integrity sha512-Ybn2I6fnfIGuCR+Faaz7YcvtBKxvoLV3Lebn1tM4o/IAJzmi9AWYIPWpyBfU8cC+JxAO57bk4+zdsTjJR+VTOw==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.6"
+    "@webassemblyjs/helper-buffer" "1.11.6"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.6"
+    "@webassemblyjs/helper-wasm-section" "1.11.6"
+    "@webassemblyjs/wasm-gen" "1.11.6"
+    "@webassemblyjs/wasm-opt" "1.11.6"
+    "@webassemblyjs/wasm-parser" "1.11.6"
+    "@webassemblyjs/wast-printer" "1.11.6"
+
+"@webassemblyjs/wasm-gen@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.6.tgz#fb5283e0e8b4551cc4e9c3c0d7184a65faf7c268"
+  integrity sha512-3XOqkZP/y6B4F0PBAXvI1/bky7GryoogUtfwExeP/v7Nzwo1QLcq5oQmpKlftZLbT+ERUOAZVQjuNVak6UXjPA==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.6"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.6"
+    "@webassemblyjs/ieee754" "1.11.6"
+    "@webassemblyjs/leb128" "1.11.6"
+    "@webassemblyjs/utf8" "1.11.6"
+
+"@webassemblyjs/wasm-opt@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.6.tgz#d9a22d651248422ca498b09aa3232a81041487c2"
+  integrity sha512-cOrKuLRE7PCe6AsOVl7WasYf3wbSo4CeOk6PkrjS7g57MFfVUF9u6ysQBBODX0LdgSvQqRiGz3CXvIDKcPNy4g==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.6"
+    "@webassemblyjs/helper-buffer" "1.11.6"
+    "@webassemblyjs/wasm-gen" "1.11.6"
+    "@webassemblyjs/wasm-parser" "1.11.6"
+
+"@webassemblyjs/wasm-parser@1.11.6", "@webassemblyjs/wasm-parser@^1.11.5":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.6.tgz#bb85378c527df824004812bbdb784eea539174a1"
+  integrity sha512-6ZwPeGzMJM3Dqp3hCsLgESxBGtT/OeCvCZ4TA1JUPYgmhAx38tTPR9JaKy0S5H3evQpO/h2uWs2j6Yc/fjkpTQ==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.6"
+    "@webassemblyjs/helper-api-error" "1.11.6"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.6"
+    "@webassemblyjs/ieee754" "1.11.6"
+    "@webassemblyjs/leb128" "1.11.6"
+    "@webassemblyjs/utf8" "1.11.6"
+
+"@webassemblyjs/wast-printer@1.11.6":
+  version "1.11.6"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.11.6.tgz#a7bf8dd7e362aeb1668ff43f35cb849f188eff20"
+  integrity sha512-JM7AhRcE+yW2GWYaKeHL5vt4xqee5N2WcezptmgyhNS+ScggqcT1OtXykhAb13Sn5Yas0j2uv9tHgrjwvzAP4A==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.6"
+    "@xtuc/long" "4.2.2"
+
+"@xtuc/ieee754@^1.2.0":
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
+  integrity sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==
+
+"@xtuc/long@4.2.2":
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d"
+  integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==
+
+accepts@~1.3.4, accepts@~1.3.5, accepts@~1.3.8:
+  version "1.3.8"
+  resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.8.tgz#0bf0be125b67014adcb0b0921e62db7bffe16b2e"
+  integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==
+  dependencies:
+    mime-types "~2.1.34"
+    negotiator "0.6.3"
+
+acorn-import-assertions@^1.9.0:
+  version "1.9.0"
+  resolved "https://registry.yarnpkg.com/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz#507276249d684797c84e0734ef84860334cfb1ac"
+  integrity sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==
+
+acorn-walk@^8.0.0:
+  version "8.3.2"
+  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.3.2.tgz#7703af9415f1b6db9315d6895503862e231d34aa"
+  integrity sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==
+
+acorn@^8.0.4, acorn@^8.7.1, acorn@^8.8.2:
+  version "8.11.3"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.11.3.tgz#71e0b14e13a4ec160724b38fb7b0f233b1b81d7a"
+  integrity sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==
+
+address@^1.0.1, address@^1.1.2:
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/address/-/address-1.2.2.tgz#2b5248dac5485a6390532c6a517fda2e3faac89e"
+  integrity sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==
+
+aggregate-error@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.1.0.tgz#92670ff50f5359bdb7a3e0d40d0ec30c5737687a"
+  integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==
+  dependencies:
+    clean-stack "^2.0.0"
+    indent-string "^4.0.0"
+
+ajv-formats@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/ajv-formats/-/ajv-formats-2.1.1.tgz#6e669400659eb74973bbf2e33327180a0996b520"
+  integrity sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==
+  dependencies:
+    ajv "^8.0.0"
+
+ajv-keywords@^3.4.1, ajv-keywords@^3.5.2:
+  version "3.5.2"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d"
+  integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
+
+ajv-keywords@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-5.1.0.tgz#69d4d385a4733cdbeab44964a1170a88f87f0e16"
+  integrity sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==
+  dependencies:
+    fast-deep-equal "^3.1.3"
+
+ajv@^6.12.2, ajv@^6.12.4, ajv@^6.12.5:
+  version "6.12.6"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
+  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
+  dependencies:
+    fast-deep-equal "^3.1.1"
+    fast-json-stable-stringify "^2.0.0"
+    json-schema-traverse "^0.4.1"
+    uri-js "^4.2.2"
+
+ajv@^8.0.0, ajv@^8.9.0:
+  version "8.12.0"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.12.0.tgz#d1a0527323e22f53562c567c00991577dfbe19d1"
+  integrity sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==
+  dependencies:
+    fast-deep-equal "^3.1.1"
+    json-schema-traverse "^1.0.0"
+    require-from-string "^2.0.2"
+    uri-js "^4.2.2"
+
+algoliasearch-helper@^3.10.0:
+  version "3.16.2"
+  resolved "https://registry.yarnpkg.com/algoliasearch-helper/-/algoliasearch-helper-3.16.2.tgz#edb8744d6ffe52e731387092fef7324d59214e2f"
+  integrity sha512-Yl/Gu5Cq4Z5s/AJ0jR37OPI1H3+z7PHz657ibyaXgMOaWvPlZ3OACN13N+7HCLPUlB0BN+8BtmrG/CqTilowBA==
+  dependencies:
+    "@algolia/events" "^4.0.1"
+
+algoliasearch@^4.13.1, algoliasearch@^4.19.1:
+  version "4.22.1"
+  resolved "https://registry.yarnpkg.com/algoliasearch/-/algoliasearch-4.22.1.tgz#f10fbecdc7654639ec20d62f109c1b3a46bc6afc"
+  integrity sha512-jwydKFQJKIx9kIZ8Jm44SdpigFwRGPESaxZBaHSV0XWN2yBJAOT4mT7ppvlrpA4UGzz92pqFnVKr/kaZXrcreg==
+  dependencies:
+    "@algolia/cache-browser-local-storage" "4.22.1"
+    "@algolia/cache-common" "4.22.1"
+    "@algolia/cache-in-memory" "4.22.1"
+    "@algolia/client-account" "4.22.1"
+    "@algolia/client-analytics" "4.22.1"
+    "@algolia/client-common" "4.22.1"
+    "@algolia/client-personalization" "4.22.1"
+    "@algolia/client-search" "4.22.1"
+    "@algolia/logger-common" "4.22.1"
+    "@algolia/logger-console" "4.22.1"
+    "@algolia/requester-browser-xhr" "4.22.1"
+    "@algolia/requester-common" "4.22.1"
+    "@algolia/requester-node-http" "4.22.1"
+    "@algolia/transporter" "4.22.1"
+
+ansi-align@^3.0.0, ansi-align@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-3.0.1.tgz#0cdf12e111ace773a86e9a1fad1225c43cb19a59"
+  integrity sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==
+  dependencies:
+    string-width "^4.1.0"
+
+ansi-html-community@^0.0.8:
+  version "0.0.8"
+  resolved "https://registry.yarnpkg.com/ansi-html-community/-/ansi-html-community-0.0.8.tgz#69fbc4d6ccbe383f9736934ae34c3f8290f1bf41"
+  integrity sha512-1APHAyr3+PCamwNw3bXCPp4HFLONZt/yIH0sZp0/469KWNTEy+qN5jQ3GVX6DMZ1UXAi34yVwtTeaG/HpBuuzw==
+
+ansi-regex@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
+  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
+
+ansi-regex@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
+  integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==
+
+ansi-styles@^3.2.1:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
+  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
+  dependencies:
+    color-convert "^1.9.0"
+
+ansi-styles@^4.0.0, ansi-styles@^4.1.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
+  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
+  dependencies:
+    color-convert "^2.0.1"
+
+ansi-styles@^6.1.0:
+  version "6.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5"
+  integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==
+
+anymatch@~3.1.2:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e"
+  integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
+  dependencies:
+    normalize-path "^3.0.0"
+    picomatch "^2.0.4"
+
+arg@^5.0.0:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c"
+  integrity sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==
+
+argparse@^1.0.7:
+  version "1.0.10"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
+  integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
+  dependencies:
+    sprintf-js "~1.0.2"
+
+argparse@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
+  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
+
+array-flatten@1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/array-flatten/-/array-flatten-1.1.1.tgz#9a5f699051b1e7073328f2a008968b64ea2955d2"
+  integrity sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==
+
+array-union@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
+  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
+
+asap@~2.0.3:
+  version "2.0.6"
+  resolved "https://registry.yarnpkg.com/asap/-/asap-2.0.6.tgz#e50347611d7e690943208bbdafebcbc2fb866d46"
+  integrity sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==
+
+asynckit@^0.4.0:
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
+  integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
+
+at-least-node@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/at-least-node/-/at-least-node-1.0.0.tgz#602cd4b46e844ad4effc92a8011a3c46e0238dc2"
+  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
+
+autoprefixer@^10.4.12, autoprefixer@^10.4.7:
+  version "10.4.17"
+  resolved "https://registry.yarnpkg.com/autoprefixer/-/autoprefixer-10.4.17.tgz#35cd5695cbbe82f536a50fa025d561b01fdec8be"
+  integrity sha512-/cpVNRLSfhOtcGflT13P2794gVSgmPgTR+erw5ifnMLZb0UnSlkK4tquLmkd3BhA+nLo5tX8Cu0upUsGKvKbmg==
+  dependencies:
+    browserslist "^4.22.2"
+    caniuse-lite "^1.0.30001578"
+    fraction.js "^4.3.7"
+    normalize-range "^0.1.2"
+    picocolors "^1.0.0"
+    postcss-value-parser "^4.2.0"
+
+axios@^0.25.0:
+  version "0.25.0"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-0.25.0.tgz#349cfbb31331a9b4453190791760a8d35b093e0a"
+  integrity sha512-cD8FOb0tRH3uuEe6+evtAbgJtfxr7ly3fQjYcMcuPlgkwVS9xboaVIpcDV+cYQe+yGykgwZCs1pzjntcGa6l5g==
+  dependencies:
+    follow-redirects "^1.14.7"
+
+axios@^0.28.0:
+  version "0.28.0"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-0.28.0.tgz#801a4d991d0404961bccef46800e1170f8278c89"
+  integrity sha512-Tu7NYoGY4Yoc7I+Npf9HhUMtEEpV7ZiLH9yndTCoNhcpBH0kwcvFbzYN9/u5QKI5A6uefjsNNWaz5olJVYS62Q==
+  dependencies:
+    follow-redirects "^1.15.0"
+    form-data "^4.0.0"
+    proxy-from-env "^1.1.0"
+
+babel-loader@^8.2.5:
+  version "8.3.0"
+  resolved "https://registry.yarnpkg.com/babel-loader/-/babel-loader-8.3.0.tgz#124936e841ba4fe8176786d6ff28add1f134d6a8"
+  integrity sha512-H8SvsMF+m9t15HNLMipppzkC+Y2Yq+v3SonZyU70RBL/h1gxPkH08Ot8pEE9Z4Kd+czyWJClmFS8qzIP9OZ04Q==
+  dependencies:
+    find-cache-dir "^3.3.1"
+    loader-utils "^2.0.0"
+    make-dir "^3.1.0"
+    schema-utils "^2.6.5"
+
+babel-plugin-apply-mdx-type-prop@1.6.22:
+  version "1.6.22"
+  resolved "https://registry.yarnpkg.com/babel-plugin-apply-mdx-type-prop/-/babel-plugin-apply-mdx-type-prop-1.6.22.tgz#d216e8fd0de91de3f1478ef3231e05446bc8705b"
+  integrity sha512-VefL+8o+F/DfK24lPZMtJctrCVOfgbqLAGZSkxwhazQv4VxPg3Za/i40fu22KR2m8eEda+IfSOlPLUSIiLcnCQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "7.10.4"
+    "@mdx-js/util" "1.6.22"
+
+babel-plugin-dynamic-import-node@^2.3.3:
+  version "2.3.3"
+  resolved "https://registry.yarnpkg.com/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz#84fda19c976ec5c6defef57f9427b3def66e17a3"
+  integrity sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==
+  dependencies:
+    object.assign "^4.1.0"
+
+babel-plugin-extract-import-names@1.6.22:
+  version "1.6.22"
+  resolved "https://registry.yarnpkg.com/babel-plugin-extract-import-names/-/babel-plugin-extract-import-names-1.6.22.tgz#de5f9a28eb12f3eb2578bf74472204e66d1a13dc"
+  integrity sha512-yJ9BsJaISua7d8zNT7oRG1ZLBJCIdZ4PZqmH8qa9N5AK01ifk3fnkc98AXhtzE7UkfCsEumvoQWgoYLhOnJ7jQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "7.10.4"
+
+babel-plugin-polyfill-corejs2@^0.4.8:
+  version "0.4.8"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.8.tgz#dbcc3c8ca758a290d47c3c6a490d59429b0d2269"
+  integrity sha512-OtIuQfafSzpo/LhnJaykc0R/MMnuLSSVjVYy9mHArIZ9qTCSZ6TpWCuEKZYVoN//t8HqBNScHrOtCrIK5IaGLg==
+  dependencies:
+    "@babel/compat-data" "^7.22.6"
+    "@babel/helper-define-polyfill-provider" "^0.5.0"
+    semver "^6.3.1"
+
+babel-plugin-polyfill-corejs3@^0.9.0:
+  version "0.9.0"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.9.0.tgz#9eea32349d94556c2ad3ab9b82ebb27d4bf04a81"
+  integrity sha512-7nZPG1uzK2Ymhy/NbaOWTg3uibM2BmGASS4vHS4szRZAIR8R6GwA/xAujpdrXU5iyklrimWnLWU+BLF9suPTqg==
+  dependencies:
+    "@babel/helper-define-polyfill-provider" "^0.5.0"
+    core-js-compat "^3.34.0"
+
+babel-plugin-polyfill-regenerator@^0.5.5:
+  version "0.5.5"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.5.5.tgz#8b0c8fc6434239e5d7b8a9d1f832bb2b0310f06a"
+  integrity sha512-OJGYZlhLqBh2DDHeqAxWB1XIvr49CxiJ2gIt61/PU55CQK4Z58OzMqjDe1zwQdQk+rBYsRc+1rJmdajM3gimHg==
+  dependencies:
+    "@babel/helper-define-polyfill-provider" "^0.5.0"
+
+bail@^1.0.0:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/bail/-/bail-1.0.5.tgz#b6fa133404a392cbc1f8c4bf63f5953351e7a776"
+  integrity sha512-xFbRxM1tahm08yHBP16MMjVUAvDaBMD38zsM9EMAUN61omwLmKlOpB/Zku5QkjZ8TZ4vn53pj+t518cH0S03RQ==
+
+balanced-match@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
+  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
+
+base16@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/base16/-/base16-1.0.0.tgz#e297f60d7ec1014a7a971a39ebc8a98c0b681e70"
+  integrity sha512-pNdYkNPiJUnEhnfXV56+sQy8+AaPcG3POZAUnwr4EeqCUZFz4u2PePbo3e5Gj4ziYPCWGUZT9RHisvJKnwFuBQ==
+
+batch@0.6.1:
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/batch/-/batch-0.6.1.tgz#dc34314f4e679318093fc760272525f94bf25c16"
+  integrity sha512-x+VAiMRL6UPkx+kudNvxTl6hB2XNNCG2r+7wixVfIYwu/2HKRXimwQyaumLjMveWvT2Hkd/cAJw+QBMfJ/EKVw==
+
+big.js@^5.2.2:
+  version "5.2.2"
+  resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
+  integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
+
+binary-extensions@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d"
+  integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
+
+body-parser@1.20.1:
+  version "1.20.1"
+  resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.1.tgz#b1812a8912c195cd371a3ee5e66faa2338a5c668"
+  integrity sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==
+  dependencies:
+    bytes "3.1.2"
+    content-type "~1.0.4"
+    debug "2.6.9"
+    depd "2.0.0"
+    destroy "1.2.0"
+    http-errors "2.0.0"
+    iconv-lite "0.4.24"
+    on-finished "2.4.1"
+    qs "6.11.0"
+    raw-body "2.5.1"
+    type-is "~1.6.18"
+    unpipe "1.0.0"
+
+bonjour-service@^1.0.11:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/bonjour-service/-/bonjour-service-1.2.1.tgz#eb41b3085183df3321da1264719fbada12478d02"
+  integrity sha512-oSzCS2zV14bh2kji6vNe7vrpJYCHGvcZnlffFQ1MEoX/WOeQ/teD8SYWKR942OI3INjq8OMNJlbPK5LLLUxFDw==
+  dependencies:
+    fast-deep-equal "^3.1.3"
+    multicast-dns "^7.2.5"
+
+boolbase@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/boolbase/-/boolbase-1.0.0.tgz#68dff5fbe60c51eb37725ea9e3ed310dcc1e776e"
+  integrity sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==
+
+boxen@^5.0.0:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/boxen/-/boxen-5.1.2.tgz#788cb686fc83c1f486dfa8a40c68fc2b831d2b50"
+  integrity sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==
+  dependencies:
+    ansi-align "^3.0.0"
+    camelcase "^6.2.0"
+    chalk "^4.1.0"
+    cli-boxes "^2.2.1"
+    string-width "^4.2.2"
+    type-fest "^0.20.2"
+    widest-line "^3.1.0"
+    wrap-ansi "^7.0.0"
+
+boxen@^6.2.1:
+  version "6.2.1"
+  resolved "https://registry.yarnpkg.com/boxen/-/boxen-6.2.1.tgz#b098a2278b2cd2845deef2dff2efc38d329b434d"
+  integrity sha512-H4PEsJXfFI/Pt8sjDWbHlQPx4zL/bvSQjcilJmaulGt5mLDorHOHpmdXAJcBcmru7PhYSp/cDMWRko4ZUMFkSw==
+  dependencies:
+    ansi-align "^3.0.1"
+    camelcase "^6.2.0"
+    chalk "^4.1.2"
+    cli-boxes "^3.0.0"
+    string-width "^5.0.1"
+    type-fest "^2.5.0"
+    widest-line "^4.0.1"
+    wrap-ansi "^8.0.1"
+
+brace-expansion@^1.1.7:
+  version "1.1.11"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
+  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
+  dependencies:
+    balanced-match "^1.0.0"
+    concat-map "0.0.1"
+
+braces@^3.0.2, braces@~3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
+  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
+  dependencies:
+    fill-range "^7.0.1"
+
+browserslist@^4.0.0, browserslist@^4.18.1, browserslist@^4.21.10, browserslist@^4.21.4, browserslist@^4.22.2, browserslist@^4.22.3:
+  version "4.23.0"
+  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.23.0.tgz#8f3acc2bbe73af7213399430890f86c63a5674ab"
+  integrity sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==
+  dependencies:
+    caniuse-lite "^1.0.30001587"
+    electron-to-chromium "^1.4.668"
+    node-releases "^2.0.14"
+    update-browserslist-db "^1.0.13"
+
+buffer-from@^1.0.0:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
+  integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
+
+bytes@3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.0.0.tgz#d32815404d689699f85a4ea4fa8755dd13a96048"
+  integrity sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw==
+
+bytes@3.1.2:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5"
+  integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==
+
+cacheable-request@^6.0.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/cacheable-request/-/cacheable-request-6.1.0.tgz#20ffb8bd162ba4be11e9567d823db651052ca912"
+  integrity sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==
+  dependencies:
+    clone-response "^1.0.2"
+    get-stream "^5.1.0"
+    http-cache-semantics "^4.0.0"
+    keyv "^3.0.0"
+    lowercase-keys "^2.0.0"
+    normalize-url "^4.1.0"
+    responselike "^1.0.2"
+
+call-bind@^1.0.5, call-bind@^1.0.6:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.7.tgz#06016599c40c56498c18769d2730be242b6fa3b9"
+  integrity sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==
+  dependencies:
+    es-define-property "^1.0.0"
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+    get-intrinsic "^1.2.4"
+    set-function-length "^1.2.1"
+
+callsites@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
+  integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
+
+camel-case@^4.1.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-4.1.2.tgz#9728072a954f805228225a6deea6b38461e1bd5a"
+  integrity sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==
+  dependencies:
+    pascal-case "^3.1.2"
+    tslib "^2.0.3"
+
+camelcase-css@2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/camelcase-css/-/camelcase-css-2.0.1.tgz#ee978f6947914cc30c6b44741b6ed1df7f043fd5"
+  integrity sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==
+
+camelcase@^6.2.0:
+  version "6.3.0"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a"
+  integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
+
+caniuse-api@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/caniuse-api/-/caniuse-api-3.0.0.tgz#5e4d90e2274961d46291997df599e3ed008ee4c0"
+  integrity sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==
+  dependencies:
+    browserslist "^4.0.0"
+    caniuse-lite "^1.0.0"
+    lodash.memoize "^4.1.2"
+    lodash.uniq "^4.5.0"
+
+caniuse-lite@^1.0.0, caniuse-lite@^1.0.30001578, caniuse-lite@^1.0.30001587:
+  version "1.0.30001588"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001588.tgz#07f16b65a7f95dba82377096923947fb25bce6e3"
+  integrity sha512-+hVY9jE44uKLkH0SrUTqxjxqNTOWHsbnQDIKjwkZ3lNTzUUVdBLBGXtj/q5Mp5u98r3droaZAewQuEDzjQdZlQ==
+
+ccount@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/ccount/-/ccount-1.1.0.tgz#246687debb6014735131be8abab2d93898f8d043"
+  integrity sha512-vlNK021QdI7PNeiUh/lKkC/mNHHfV0m/Ad5JoI0TYtlBnJAslM/JIkm/tGC88bkLIwO6OQ5uV6ztS6kVAtCDlg==
+
+chalk@^2.4.2:
+  version "2.4.2"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
+  integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
+  dependencies:
+    ansi-styles "^3.2.1"
+    escape-string-regexp "^1.0.5"
+    supports-color "^5.3.0"
+
+chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
+  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
+character-entities-legacy@^1.0.0:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/character-entities-legacy/-/character-entities-legacy-1.1.4.tgz#94bc1845dce70a5bb9d2ecc748725661293d8fc1"
+  integrity sha512-3Xnr+7ZFS1uxeiUDvV02wQ+QDbc55o97tIV5zHScSPJpcLm/r0DFPcoY3tYRp+VZukxuMeKgXYmsXQHO05zQeA==
+
+character-entities@^1.0.0:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/character-entities/-/character-entities-1.2.4.tgz#e12c3939b7eaf4e5b15e7ad4c5e28e1d48c5b16b"
+  integrity sha512-iBMyeEHxfVnIakwOuDXpVkc54HijNgCyQB2w0VfGQThle6NXn50zU6V/u+LDhxHcDUPojn6Kpga3PTAD8W1bQw==
+
+character-reference-invalid@^1.0.0:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/character-reference-invalid/-/character-reference-invalid-1.1.4.tgz#083329cda0eae272ab3dbbf37e9a382c13af1560"
+  integrity sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg==
+
+cheerio-select@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/cheerio-select/-/cheerio-select-2.1.0.tgz#4d8673286b8126ca2a8e42740d5e3c4884ae21b4"
+  integrity sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==
+  dependencies:
+    boolbase "^1.0.0"
+    css-select "^5.1.0"
+    css-what "^6.1.0"
+    domelementtype "^2.3.0"
+    domhandler "^5.0.3"
+    domutils "^3.0.1"
+
+cheerio@^1.0.0-rc.12:
+  version "1.0.0-rc.12"
+  resolved "https://registry.yarnpkg.com/cheerio/-/cheerio-1.0.0-rc.12.tgz#788bf7466506b1c6bf5fae51d24a2c4d62e47683"
+  integrity sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==
+  dependencies:
+    cheerio-select "^2.1.0"
+    dom-serializer "^2.0.0"
+    domhandler "^5.0.3"
+    domutils "^3.0.1"
+    htmlparser2 "^8.0.1"
+    parse5 "^7.0.0"
+    parse5-htmlparser2-tree-adapter "^7.0.0"
+
+chokidar@^3.4.2, chokidar@^3.5.3:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.6.0.tgz#197c6cc669ef2a8dc5e7b4d97ee4e092c3eb0d5b"
+  integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==
+  dependencies:
+    anymatch "~3.1.2"
+    braces "~3.0.2"
+    glob-parent "~5.1.2"
+    is-binary-path "~2.1.0"
+    is-glob "~4.0.1"
+    normalize-path "~3.0.0"
+    readdirp "~3.6.0"
+  optionalDependencies:
+    fsevents "~2.3.2"
+
+chrome-trace-event@^1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz#1015eced4741e15d06664a957dbbf50d041e26ac"
+  integrity sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==
+
+ci-info@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46"
+  integrity sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==
+
+ci-info@^3.2.0:
+  version "3.9.0"
+  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.9.0.tgz#4279a62028a7b1f262f3473fc9605f5e218c59b4"
+  integrity sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==
+
+clean-css@^5.2.2, clean-css@^5.3.0:
+  version "5.3.3"
+  resolved "https://registry.yarnpkg.com/clean-css/-/clean-css-5.3.3.tgz#b330653cd3bd6b75009cc25c714cae7b93351ccd"
+  integrity sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==
+  dependencies:
+    source-map "~0.6.0"
+
+clean-stack@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b"
+  integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==
+
+cli-boxes@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-2.2.1.tgz#ddd5035d25094fce220e9cab40a45840a440318f"
+  integrity sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==
+
+cli-boxes@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-3.0.0.tgz#71a10c716feeba005e4504f36329ef0b17cf3145"
+  integrity sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==
+
+cli-table3@^0.6.2:
+  version "0.6.3"
+  resolved "https://registry.yarnpkg.com/cli-table3/-/cli-table3-0.6.3.tgz#61ab765aac156b52f222954ffc607a6f01dbeeb2"
+  integrity sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==
+  dependencies:
+    string-width "^4.2.0"
+  optionalDependencies:
+    "@colors/colors" "1.5.0"
+
+clone-deep@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387"
+  integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
+  dependencies:
+    is-plain-object "^2.0.4"
+    kind-of "^6.0.2"
+    shallow-clone "^3.0.0"
+
+clone-response@^1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/clone-response/-/clone-response-1.0.3.tgz#af2032aa47816399cf5f0a1d0db902f517abb8c3"
+  integrity sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==
+  dependencies:
+    mimic-response "^1.0.0"
+
+clsx@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/clsx/-/clsx-1.2.1.tgz#0ddc4a20a549b59c93a4116bb26f5294ca17dc12"
+  integrity sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==
+
+collapse-white-space@^1.0.2:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/collapse-white-space/-/collapse-white-space-1.0.6.tgz#e63629c0016665792060dbbeb79c42239d2c5287"
+  integrity sha512-jEovNnrhMuqyCcjfEJA56v0Xq8SkIoPKDyaHahwo3POf4qcSXqMYuwNcOTzp74vTsR9Tn08z4MxWqAhcekogkQ==
+
+color-convert@^1.9.0:
+  version "1.9.3"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
+  integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
+  dependencies:
+    color-name "1.1.3"
+
+color-convert@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
+  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
+  dependencies:
+    color-name "~1.1.4"
+
+color-name@1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
+  integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==
+
+color-name@~1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
+  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
+
+colord@^2.9.1:
+  version "2.9.3"
+  resolved "https://registry.yarnpkg.com/colord/-/colord-2.9.3.tgz#4f8ce919de456f1d5c1c368c307fe20f3e59fb43"
+  integrity sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==
+
+colorette@^2.0.10:
+  version "2.0.20"
+  resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.20.tgz#9eb793e6833067f7235902fcd3b09917a000a95a"
+  integrity sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==
+
+combine-promises@^1.1.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/combine-promises/-/combine-promises-1.2.0.tgz#5f2e68451862acf85761ded4d9e2af7769c2ca6a"
+  integrity sha512-VcQB1ziGD0NXrhKxiwyNbCDmRzs/OShMs2GqW2DlU2A/Sd0nQxE1oWDAE5O0ygSx5mgQOn9eIFh7yKPgFRVkPQ==
+
+combined-stream@^1.0.8:
+  version "1.0.8"
+  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
+  integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
+  dependencies:
+    delayed-stream "~1.0.0"
+
+comma-separated-tokens@^1.0.0:
+  version "1.0.8"
+  resolved "https://registry.yarnpkg.com/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz#632b80b6117867a158f1080ad498b2fbe7e3f5ea"
+  integrity sha512-GHuDRO12Sypu2cV70d1dkA2EUmXHgntrzbpvOB+Qy+49ypNfGgFQIC2fhhXbnyrJRynDCAARsT7Ou0M6hirpfw==
+
+commander@^2.20.0:
+  version "2.20.3"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
+  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
+
+commander@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-5.1.0.tgz#46abbd1652f8e059bddaef99bbdcb2ad9cf179ae"
+  integrity sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==
+
+commander@^7.2.0:
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-7.2.0.tgz#a36cb57d0b501ce108e4d20559a150a391d97ab7"
+  integrity sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==
+
+commander@^8.3.0:
+  version "8.3.0"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-8.3.0.tgz#4837ea1b2da67b9c616a67afbb0fafee567bca66"
+  integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==
+
+commondir@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
+  integrity sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==
+
+compressible@~2.0.16:
+  version "2.0.18"
+  resolved "https://registry.yarnpkg.com/compressible/-/compressible-2.0.18.tgz#af53cca6b070d4c3c0750fbd77286a6d7cc46fba"
+  integrity sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==
+  dependencies:
+    mime-db ">= 1.43.0 < 2"
+
+compression@^1.7.4:
+  version "1.7.4"
+  resolved "https://registry.yarnpkg.com/compression/-/compression-1.7.4.tgz#95523eff170ca57c29a0ca41e6fe131f41e5bb8f"
+  integrity sha512-jaSIDzP9pZVS4ZfQ+TzvtiWhdpFhE2RDHz8QJkpX9SIpLq88VueF5jJw6t+6CUQcAoA6t+x89MLrWAqpfDE8iQ==
+  dependencies:
+    accepts "~1.3.5"
+    bytes "3.0.0"
+    compressible "~2.0.16"
+    debug "2.6.9"
+    on-headers "~1.0.2"
+    safe-buffer "5.1.2"
+    vary "~1.1.2"
+
+concat-map@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
+  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
+
+configstore@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/configstore/-/configstore-5.0.1.tgz#d365021b5df4b98cdd187d6a3b0e3f6a7cc5ed96"
+  integrity sha512-aMKprgk5YhBNyH25hj8wGt2+D52Sw1DRRIzqBwLp2Ya9mFmY8KPvvtvmna8SxVR9JMZ4kzMD68N22vlaRpkeFA==
+  dependencies:
+    dot-prop "^5.2.0"
+    graceful-fs "^4.1.2"
+    make-dir "^3.0.0"
+    unique-string "^2.0.0"
+    write-file-atomic "^3.0.0"
+    xdg-basedir "^4.0.0"
+
+connect-history-api-fallback@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz#647264845251a0daf25b97ce87834cace0f5f1c8"
+  integrity sha512-U73+6lQFmfiNPrYbXqr6kZ1i1wiRqXnp2nhMsINseWXO8lDau0LGEffJ8kQi4EjLZympVgRdvqjAgiZ1tgzDDA==
+
+consola@^2.15.3:
+  version "2.15.3"
+  resolved "https://registry.yarnpkg.com/consola/-/consola-2.15.3.tgz#2e11f98d6a4be71ff72e0bdf07bd23e12cb61550"
+  integrity sha512-9vAdYbHj6x2fLKC4+oPH0kFzY/orMZyG2Aj+kNylHxKGJ/Ed4dpNyAQYwJOdqO4zdM7XpVHmyejQDcQHrnuXbw==
+
+content-disposition@0.5.2:
+  version "0.5.2"
+  resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.2.tgz#0cf68bb9ddf5f2be7961c3a85178cb85dba78cb4"
+  integrity sha512-kRGRZw3bLlFISDBgwTSA1TMBFN6J6GWDeubmDE3AF+3+yXL8hTWv8r5rkLbqYXY4RjPk/EzHnClI3zQf1cFmHA==
+
+content-disposition@0.5.4:
+  version "0.5.4"
+  resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.4.tgz#8b82b4efac82512a02bb0b1dcec9d2c5e8eb5bfe"
+  integrity sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==
+  dependencies:
+    safe-buffer "5.2.1"
+
+content-type@~1.0.4:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.5.tgz#8b773162656d1d1086784c8f23a54ce6d73d7918"
+  integrity sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==
+
+convert-source-map@^1.7.0:
+  version "1.9.0"
+  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.9.0.tgz#7faae62353fb4213366d0ca98358d22e8368b05f"
+  integrity sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==
+
+convert-source-map@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a"
+  integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==
+
+cookie-signature@1.0.6:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/cookie-signature/-/cookie-signature-1.0.6.tgz#e303a882b342cc3ee8ca513a79999734dab3ae2c"
+  integrity sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==
+
+cookie@0.5.0:
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.5.0.tgz#d1f5d71adec6558c58f389987c366aa47e994f8b"
+  integrity sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==
+
+copy-text-to-clipboard@^3.0.1:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/copy-text-to-clipboard/-/copy-text-to-clipboard-3.2.0.tgz#0202b2d9bdae30a49a53f898626dcc3b49ad960b"
+  integrity sha512-RnJFp1XR/LOBDckxTib5Qjr/PMfkatD0MUCQgdpqS8MdKiNUzBjAQBEN6oUy+jW7LI93BBG3DtMB2KOOKpGs2Q==
+
+copy-webpack-plugin@^11.0.0:
+  version "11.0.0"
+  resolved "https://registry.yarnpkg.com/copy-webpack-plugin/-/copy-webpack-plugin-11.0.0.tgz#96d4dbdb5f73d02dd72d0528d1958721ab72e04a"
+  integrity sha512-fX2MWpamkW0hZxMEg0+mYnA40LTosOSa5TqZ9GYIBzyJa9C3QUaMPSE2xAi/buNr8u89SfD9wHSQVBzrRa/SOQ==
+  dependencies:
+    fast-glob "^3.2.11"
+    glob-parent "^6.0.1"
+    globby "^13.1.1"
+    normalize-path "^3.0.0"
+    schema-utils "^4.0.0"
+    serialize-javascript "^6.0.0"
+
+core-js-compat@^3.31.0, core-js-compat@^3.34.0:
+  version "3.36.0"
+  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.36.0.tgz#087679119bc2fdbdefad0d45d8e5d307d45ba190"
+  integrity sha512-iV9Pd/PsgjNWBXeq8XRtWVSgz2tKAfhfvBs7qxYty+RlRd+OCksaWmOnc4JKrTc1cToXL1N0s3l/vwlxPtdElw==
+  dependencies:
+    browserslist "^4.22.3"
+
+core-js-pure@^3.30.2:
+  version "3.36.0"
+  resolved "https://registry.yarnpkg.com/core-js-pure/-/core-js-pure-3.36.0.tgz#ffb34330b14e594d6a9835cf5843b4123f1d95db"
+  integrity sha512-cN28qmhRNgbMZZMc/RFu5w8pK9VJzpb2rJVR/lHuZJKwmXnoWOpXmMkxqBB514igkp1Hu8WGROsiOAzUcKdHOQ==
+
+core-js@^3.23.3:
+  version "3.36.0"
+  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.36.0.tgz#e752fa0b0b462a0787d56e9d73f80b0f7c0dde68"
+  integrity sha512-mt7+TUBbTFg5+GngsAxeKBTl5/VS0guFeJacYge9OmHb+m058UwwIm41SE9T4Den7ClatV57B6TYTuJ0CX1MAw==
+
+core-util-is@~1.0.0:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85"
+  integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
+
+cosmiconfig@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-6.0.0.tgz#da4fee853c52f6b1e6935f41c1a2fc50bd4a9982"
+  integrity sha512-xb3ZL6+L8b9JLLCx3ZdoZy4+2ECphCMo2PwqgP1tlfVq6M6YReyzBJtvWWtbDSpNr9hn96pkCiZqUcFEc+54Qg==
+  dependencies:
+    "@types/parse-json" "^4.0.0"
+    import-fresh "^3.1.0"
+    parse-json "^5.0.0"
+    path-type "^4.0.0"
+    yaml "^1.7.2"
+
+cosmiconfig@^7.0.1:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-7.1.0.tgz#1443b9afa596b670082ea46cbd8f6a62b84635f6"
+  integrity sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==
+  dependencies:
+    "@types/parse-json" "^4.0.0"
+    import-fresh "^3.2.1"
+    parse-json "^5.0.0"
+    path-type "^4.0.0"
+    yaml "^1.10.0"
+
+cosmiconfig@^8.3.5:
+  version "8.3.6"
+  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-8.3.6.tgz#060a2b871d66dba6c8538ea1118ba1ac16f5fae3"
+  integrity sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==
+  dependencies:
+    import-fresh "^3.3.0"
+    js-yaml "^4.1.0"
+    parse-json "^5.2.0"
+    path-type "^4.0.0"
+
+cross-fetch@^3.1.5:
+  version "3.1.8"
+  resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-3.1.8.tgz#0327eba65fd68a7d119f8fb2bf9334a1a7956f82"
+  integrity sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==
+  dependencies:
+    node-fetch "^2.6.12"
+
+cross-spawn@^7.0.3:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
+  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
+  dependencies:
+    path-key "^3.1.0"
+    shebang-command "^2.0.0"
+    which "^2.0.1"
+
+crypto-random-string@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/crypto-random-string/-/crypto-random-string-2.0.0.tgz#ef2a7a966ec11083388369baa02ebead229b30d5"
+  integrity sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==
+
+css-declaration-sorter@^6.3.1:
+  version "6.4.1"
+  resolved "https://registry.yarnpkg.com/css-declaration-sorter/-/css-declaration-sorter-6.4.1.tgz#28beac7c20bad7f1775be3a7129d7eae409a3a71"
+  integrity sha512-rtdthzxKuyq6IzqX6jEcIzQF/YqccluefyCYheovBOLhFT/drQA9zj/UbRAa9J7C0o6EG6u3E6g+vKkay7/k3g==
+
+css-loader@^6.7.1:
+  version "6.10.0"
+  resolved "https://registry.yarnpkg.com/css-loader/-/css-loader-6.10.0.tgz#7c172b270ec7b833951b52c348861206b184a4b7"
+  integrity sha512-LTSA/jWbwdMlk+rhmElbDR2vbtQoTBPr7fkJE+mxrHj+7ru0hUmHafDRzWIjIHTwpitWVaqY2/UWGRca3yUgRw==
+  dependencies:
+    icss-utils "^5.1.0"
+    postcss "^8.4.33"
+    postcss-modules-extract-imports "^3.0.0"
+    postcss-modules-local-by-default "^4.0.4"
+    postcss-modules-scope "^3.1.1"
+    postcss-modules-values "^4.0.0"
+    postcss-value-parser "^4.2.0"
+    semver "^7.5.4"
+
+css-minimizer-webpack-plugin@^4.0.0:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-4.2.2.tgz#79f6199eb5adf1ff7ba57f105e3752d15211eb35"
+  integrity sha512-s3Of/4jKfw1Hj9CxEO1E5oXhQAxlayuHO2y/ML+C6I9sQ7FdzfEV6QgMLN3vI+qFsjJGIAFLKtQK7t8BOXAIyA==
+  dependencies:
+    cssnano "^5.1.8"
+    jest-worker "^29.1.2"
+    postcss "^8.4.17"
+    schema-utils "^4.0.0"
+    serialize-javascript "^6.0.0"
+    source-map "^0.6.1"
+
+css-select@^4.1.3:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/css-select/-/css-select-4.3.0.tgz#db7129b2846662fd8628cfc496abb2b59e41529b"
+  integrity sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==
+  dependencies:
+    boolbase "^1.0.0"
+    css-what "^6.0.1"
+    domhandler "^4.3.1"
+    domutils "^2.8.0"
+    nth-check "^2.0.1"
+
+css-select@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/css-select/-/css-select-5.1.0.tgz#b8ebd6554c3637ccc76688804ad3f6a6fdaea8a6"
+  integrity sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==
+  dependencies:
+    boolbase "^1.0.0"
+    css-what "^6.1.0"
+    domhandler "^5.0.2"
+    domutils "^3.0.1"
+    nth-check "^2.0.1"
+
+css-tree@^1.1.2, css-tree@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/css-tree/-/css-tree-1.1.3.tgz#eb4870fb6fd7707327ec95c2ff2ab09b5e8db91d"
+  integrity sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==
+  dependencies:
+    mdn-data "2.0.14"
+    source-map "^0.6.1"
+
+css-what@^6.0.1, css-what@^6.1.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/css-what/-/css-what-6.1.0.tgz#fb5effcf76f1ddea2c81bdfaa4de44e79bac70f4"
+  integrity sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==
+
+cssesc@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/cssesc/-/cssesc-3.0.0.tgz#37741919903b868565e1c09ea747445cd18983ee"
+  integrity sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==
+
+cssnano-preset-advanced@^5.3.8:
+  version "5.3.10"
+  resolved "https://registry.yarnpkg.com/cssnano-preset-advanced/-/cssnano-preset-advanced-5.3.10.tgz#25558a1fbf3a871fb6429ce71e41be7f5aca6eef"
+  integrity sha512-fnYJyCS9jgMU+cmHO1rPSPf9axbQyD7iUhLO5Df6O4G+fKIOMps+ZbU0PdGFejFBBZ3Pftf18fn1eG7MAPUSWQ==
+  dependencies:
+    autoprefixer "^10.4.12"
+    cssnano-preset-default "^5.2.14"
+    postcss-discard-unused "^5.1.0"
+    postcss-merge-idents "^5.1.1"
+    postcss-reduce-idents "^5.2.0"
+    postcss-zindex "^5.1.0"
+
+cssnano-preset-default@^5.2.14:
+  version "5.2.14"
+  resolved "https://registry.yarnpkg.com/cssnano-preset-default/-/cssnano-preset-default-5.2.14.tgz#309def4f7b7e16d71ab2438052093330d9ab45d8"
+  integrity sha512-t0SFesj/ZV2OTylqQVOrFgEh5uanxbO6ZAdeCrNsUQ6fVuXwYTxJPNAGvGTxHbD68ldIJNec7PyYZDBrfDQ+6A==
+  dependencies:
+    css-declaration-sorter "^6.3.1"
+    cssnano-utils "^3.1.0"
+    postcss-calc "^8.2.3"
+    postcss-colormin "^5.3.1"
+    postcss-convert-values "^5.1.3"
+    postcss-discard-comments "^5.1.2"
+    postcss-discard-duplicates "^5.1.0"
+    postcss-discard-empty "^5.1.1"
+    postcss-discard-overridden "^5.1.0"
+    postcss-merge-longhand "^5.1.7"
+    postcss-merge-rules "^5.1.4"
+    postcss-minify-font-values "^5.1.0"
+    postcss-minify-gradients "^5.1.1"
+    postcss-minify-params "^5.1.4"
+    postcss-minify-selectors "^5.2.1"
+    postcss-normalize-charset "^5.1.0"
+    postcss-normalize-display-values "^5.1.0"
+    postcss-normalize-positions "^5.1.1"
+    postcss-normalize-repeat-style "^5.1.1"
+    postcss-normalize-string "^5.1.0"
+    postcss-normalize-timing-functions "^5.1.0"
+    postcss-normalize-unicode "^5.1.1"
+    postcss-normalize-url "^5.1.0"
+    postcss-normalize-whitespace "^5.1.1"
+    postcss-ordered-values "^5.1.3"
+    postcss-reduce-initial "^5.1.2"
+    postcss-reduce-transforms "^5.1.0"
+    postcss-svgo "^5.1.0"
+    postcss-unique-selectors "^5.1.1"
+
+cssnano-utils@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/cssnano-utils/-/cssnano-utils-3.1.0.tgz#95684d08c91511edfc70d2636338ca37ef3a6861"
+  integrity sha512-JQNR19/YZhz4psLX/rQ9M83e3z2Wf/HdJbryzte4a3NSuafyp9w/I4U+hx5C2S9g41qlstH7DEWnZaaj83OuEA==
+
+cssnano@^5.1.12, cssnano@^5.1.8:
+  version "5.1.15"
+  resolved "https://registry.yarnpkg.com/cssnano/-/cssnano-5.1.15.tgz#ded66b5480d5127fcb44dac12ea5a983755136bf"
+  integrity sha512-j+BKgDcLDQA+eDifLx0EO4XSA56b7uut3BQFH+wbSaSTuGLuiyTa/wbRYthUXX8LC9mLg+WWKe8h+qJuwTAbHw==
+  dependencies:
+    cssnano-preset-default "^5.2.14"
+    lilconfig "^2.0.3"
+    yaml "^1.10.2"
+
+csso@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/csso/-/csso-4.2.0.tgz#ea3a561346e8dc9f546d6febedd50187cf389529"
+  integrity sha512-wvlcdIbf6pwKEk7vHj8/Bkc0B4ylXZruLvOgs9doS5eOsOpuodOV2zJChSpkp+pRpYQLQMeF04nr3Z68Sta9jA==
+  dependencies:
+    css-tree "^1.1.2"
+
+csstype@^3.0.2:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/csstype/-/csstype-3.1.3.tgz#d80ff294d114fb0e6ac500fbf85b60137d7eff81"
+  integrity sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==
+
+debounce@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/debounce/-/debounce-1.2.1.tgz#38881d8f4166a5c5848020c11827b834bcb3e0a5"
+  integrity sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==
+
+debug@2.6.9, debug@^2.6.0:
+  version "2.6.9"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
+  integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
+  dependencies:
+    ms "2.0.0"
+
+debug@4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1:
+  version "4.3.4"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
+  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
+  dependencies:
+    ms "2.1.2"
+
+decompress-response@^3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-3.3.0.tgz#80a4dd323748384bfa248083622aedec982adff3"
+  integrity sha512-BzRPQuY1ip+qDonAOz42gRm/pg9F768C+npV/4JOsxRC2sq+Rlk+Q4ZCAsOhnIaMrgarILY+RMUIvMmmX1qAEA==
+  dependencies:
+    mimic-response "^1.0.0"
+
+deep-extend@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"
+  integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==
+
+deepmerge@^4.2.2:
+  version "4.3.1"
+  resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a"
+  integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==
+
+default-gateway@^6.0.3:
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/default-gateway/-/default-gateway-6.0.3.tgz#819494c888053bdb743edbf343d6cdf7f2943a71"
+  integrity sha512-fwSOJsbbNzZ/CUFpqFBqYfYNLj1NbMPm8MMCIzHjC83iSJRBEGmDUxU+WP661BaBQImeC2yHwXtz+P/O9o+XEg==
+  dependencies:
+    execa "^5.0.0"
+
+defer-to-connect@^1.0.1:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/defer-to-connect/-/defer-to-connect-1.1.3.tgz#331ae050c08dcf789f8c83a7b81f0ed94f4ac591"
+  integrity sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==
+
+define-data-property@^1.0.1, define-data-property@^1.1.2:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/define-data-property/-/define-data-property-1.1.4.tgz#894dc141bb7d3060ae4366f6a0107e68fbe48c5e"
+  integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==
+  dependencies:
+    es-define-property "^1.0.0"
+    es-errors "^1.3.0"
+    gopd "^1.0.1"
+
+define-lazy-prop@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz#3f7ae421129bcaaac9bc74905c98a0009ec9ee7f"
+  integrity sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==
+
+define-properties@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.1.tgz#10781cc616eb951a80a034bafcaa7377f6af2b6c"
+  integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==
+  dependencies:
+    define-data-property "^1.0.1"
+    has-property-descriptors "^1.0.0"
+    object-keys "^1.1.1"
+
+del@^6.1.1:
+  version "6.1.1"
+  resolved "https://registry.yarnpkg.com/del/-/del-6.1.1.tgz#3b70314f1ec0aa325c6b14eb36b95786671edb7a"
+  integrity sha512-ua8BhapfP0JUJKC/zV9yHHDW/rDoDxP4Zhn3AkA6/xT6gY7jYXJiaeyBZznYVujhZZET+UgcbZiQ7sN3WqcImg==
+  dependencies:
+    globby "^11.0.1"
+    graceful-fs "^4.2.4"
+    is-glob "^4.0.1"
+    is-path-cwd "^2.2.0"
+    is-path-inside "^3.0.2"
+    p-map "^4.0.0"
+    rimraf "^3.0.2"
+    slash "^3.0.0"
+
+delayed-stream@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
+  integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
+
+depd@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df"
+  integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
+
+depd@~1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9"
+  integrity sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==
+
+destroy@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz#4803735509ad8be552934c67df614f94e66fa015"
+  integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==
+
+detab@2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/detab/-/detab-2.0.4.tgz#b927892069aff405fbb9a186fe97a44a92a94b43"
+  integrity sha512-8zdsQA5bIkoRECvCrNKPla84lyoR7DSAyf7p0YgXzBO9PDJx8KntPUay7NS6yp+KdxdVtiE5SpHKtbp2ZQyA9g==
+  dependencies:
+    repeat-string "^1.5.4"
+
+detect-node@^2.0.4:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/detect-node/-/detect-node-2.1.0.tgz#c9c70775a49c3d03bc2c06d9a73be550f978f8b1"
+  integrity sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==
+
+detect-port-alt@^1.1.6:
+  version "1.1.6"
+  resolved "https://registry.yarnpkg.com/detect-port-alt/-/detect-port-alt-1.1.6.tgz#24707deabe932d4a3cf621302027c2b266568275"
+  integrity sha512-5tQykt+LqfJFBEYaDITx7S7cR7mJ/zQmLXZ2qt5w04ainYZw6tBf9dBunMjVeVOdYVRUzUOE4HkY5J7+uttb5Q==
+  dependencies:
+    address "^1.0.1"
+    debug "^2.6.0"
+
+detect-port@^1.3.0:
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/detect-port/-/detect-port-1.5.1.tgz#451ca9b6eaf20451acb0799b8ab40dff7718727b"
+  integrity sha512-aBzdj76lueB6uUst5iAs7+0H/oOjqI5D16XUWxlWMIMROhcM0rfsNVk93zTngq1dDNpoXRr++Sus7ETAExppAQ==
+  dependencies:
+    address "^1.0.1"
+    debug "4"
+
+dir-glob@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
+  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
+  dependencies:
+    path-type "^4.0.0"
+
+dns-packet@^5.2.2:
+  version "5.6.1"
+  resolved "https://registry.yarnpkg.com/dns-packet/-/dns-packet-5.6.1.tgz#ae888ad425a9d1478a0674256ab866de1012cf2f"
+  integrity sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==
+  dependencies:
+    "@leichtgewicht/ip-codec" "^2.0.1"
+
+dom-converter@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/dom-converter/-/dom-converter-0.2.0.tgz#6721a9daee2e293682955b6afe416771627bb768"
+  integrity sha512-gd3ypIPfOMr9h5jIKq8E3sHOTCjeirnl0WK5ZdS1AW0Odt0b1PaWaHdJ4Qk4klv+YB9aJBS7mESXjFoDQPu6DA==
+  dependencies:
+    utila "~0.4"
+
+dom-serializer@^1.0.1:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-1.4.1.tgz#de5d41b1aea290215dc45a6dae8adcf1d32e2d30"
+  integrity sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==
+  dependencies:
+    domelementtype "^2.0.1"
+    domhandler "^4.2.0"
+    entities "^2.0.0"
+
+dom-serializer@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-2.0.0.tgz#e41b802e1eedf9f6cae183ce5e622d789d7d8e53"
+  integrity sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==
+  dependencies:
+    domelementtype "^2.3.0"
+    domhandler "^5.0.2"
+    entities "^4.2.0"
+
+domelementtype@^2.0.1, domelementtype@^2.2.0, domelementtype@^2.3.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/domelementtype/-/domelementtype-2.3.0.tgz#5c45e8e869952626331d7aab326d01daf65d589d"
+  integrity sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==
+
+domhandler@^4.0.0, domhandler@^4.2.0, domhandler@^4.3.1:
+  version "4.3.1"
+  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-4.3.1.tgz#8d792033416f59d68bc03a5aa7b018c1ca89279c"
+  integrity sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==
+  dependencies:
+    domelementtype "^2.2.0"
+
+domhandler@^5.0.2, domhandler@^5.0.3:
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-5.0.3.tgz#cc385f7f751f1d1fc650c21374804254538c7d31"
+  integrity sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==
+  dependencies:
+    domelementtype "^2.3.0"
+
+domutils@^2.5.2, domutils@^2.8.0:
+  version "2.8.0"
+  resolved "https://registry.yarnpkg.com/domutils/-/domutils-2.8.0.tgz#4437def5db6e2d1f5d6ee859bd95ca7d02048135"
+  integrity sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==
+  dependencies:
+    dom-serializer "^1.0.1"
+    domelementtype "^2.2.0"
+    domhandler "^4.2.0"
+
+domutils@^3.0.1:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/domutils/-/domutils-3.1.0.tgz#c47f551278d3dc4b0b1ab8cbb42d751a6f0d824e"
+  integrity sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==
+  dependencies:
+    dom-serializer "^2.0.0"
+    domelementtype "^2.3.0"
+    domhandler "^5.0.3"
+
+dot-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751"
+  integrity sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==
+  dependencies:
+    no-case "^3.0.4"
+    tslib "^2.0.3"
+
+dot-prop@^5.2.0:
+  version "5.3.0"
+  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-5.3.0.tgz#90ccce708cd9cd82cc4dc8c3ddd9abdd55b20e88"
+  integrity sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==
+  dependencies:
+    is-obj "^2.0.0"
+
+duplexer3@^0.1.4:
+  version "0.1.5"
+  resolved "https://registry.yarnpkg.com/duplexer3/-/duplexer3-0.1.5.tgz#0b5e4d7bad5de8901ea4440624c8e1d20099217e"
+  integrity sha512-1A8za6ws41LQgv9HrE/66jyC5yuSjQ3L/KOpFtoBilsAK2iA2wuS5rTt1OCzIvtS2V7nVmedsUU+DGRcjBmOYA==
+
+duplexer@^0.1.2:
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/duplexer/-/duplexer-0.1.2.tgz#3abe43aef3835f8ae077d136ddce0f276b0400e6"
+  integrity sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==
+
+eastasianwidth@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb"
+  integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
+
+ee-first@1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
+  integrity sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==
+
+electron-to-chromium@^1.4.668:
+  version "1.4.674"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.674.tgz#6ddb629ae52c3192984423b54dc1fffe79e1b007"
+  integrity sha512-jZtIZxv9FlwTLX5kVZStUtXZywhEi3vqvY6iEzJnc57cNgHFQ5JCczElTs/062v6ODTT7eX8ZOTqQcxa3nMUWQ==
+
+emoji-regex@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
+  integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
+
+emoji-regex@^9.2.2:
+  version "9.2.2"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
+  integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
+
+emojis-list@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
+  integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
+
+emoticon@^3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/emoticon/-/emoticon-3.2.0.tgz#c008ca7d7620fac742fe1bf4af8ff8fed154ae7f"
+  integrity sha512-SNujglcLTTg+lDAcApPNgEdudaqQFiAbJCqzjNxJkvN9vAwCGi0uu8IUVvx+f16h+V44KCY6Y2yboroc9pilHg==
+
+encodeurl@~1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
+  integrity sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==
+
+end-of-stream@^1.1.0:
+  version "1.4.4"
+  resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
+  integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
+  dependencies:
+    once "^1.4.0"
+
+enhanced-resolve@^5.15.0:
+  version "5.15.0"
+  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.15.0.tgz#1af946c7d93603eb88e9896cee4904dc012e9c35"
+  integrity sha512-LXYT42KJ7lpIKECr2mAXIaMldcNCh/7E0KBKOu4KSfkHmP+mZmSs+8V5gBAqisWBy0OO4W5Oyys0GO1Y8KtdKg==
+  dependencies:
+    graceful-fs "^4.2.4"
+    tapable "^2.2.0"
+
+entities@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-2.2.0.tgz#098dc90ebb83d8dffa089d55256b351d34c4da55"
+  integrity sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==
+
+entities@^4.2.0, entities@^4.4.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-4.5.0.tgz#5d268ea5e7113ec74c4d033b79ea5a35a488fb48"
+  integrity sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==
+
+error-ex@^1.3.1:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
+  integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
+  dependencies:
+    is-arrayish "^0.2.1"
+
+es-define-property@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/es-define-property/-/es-define-property-1.0.0.tgz#c7faefbdff8b2696cf5f46921edfb77cc4ba3845"
+  integrity sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==
+  dependencies:
+    get-intrinsic "^1.2.4"
+
+es-errors@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/es-errors/-/es-errors-1.3.0.tgz#05f75a25dab98e4fb1dcd5e1472c0546d5057c8f"
+  integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==
+
+es-module-lexer@^1.2.1:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-1.4.1.tgz#41ea21b43908fe6a287ffcbe4300f790555331f5"
+  integrity sha512-cXLGjP0c4T3flZJKQSuziYoq7MlT+rnvfZjfp7h+I7K9BNX54kP9nyWvdbwjQ4u1iWbOL4u96fgeZLToQlZC7w==
+
+escalade@^3.1.1:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.2.tgz#54076e9ab29ea5bf3d8f1ed62acffbb88272df27"
+  integrity sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==
+
+escape-goat@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/escape-goat/-/escape-goat-2.1.1.tgz#1b2dc77003676c457ec760b2dc68edb648188675"
+  integrity sha512-8/uIhbG12Csjy2JEW7D9pHbreaVaS/OpN3ycnyvElTdwM5n6GY6W6e2IPemfvGZeUMqZ9A/3GqIZMgKnBhAw/Q==
+
+escape-html@^1.0.3, escape-html@~1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988"
+  integrity sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==
+
+escape-string-regexp@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
+  integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==
+
+escape-string-regexp@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
+  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
+
+eslint-scope@5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
+  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
+  dependencies:
+    esrecurse "^4.3.0"
+    estraverse "^4.1.1"
+
+esprima@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
+  integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
+
+esrecurse@^4.3.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
+  integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
+  dependencies:
+    estraverse "^5.2.0"
+
+estraverse@^4.1.1:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
+  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
+
+estraverse@^5.2.0:
+  version "5.3.0"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
+  integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
+
+esutils@^2.0.2:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
+  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
+
+eta@^1.12.3:
+  version "1.14.2"
+  resolved "https://registry.yarnpkg.com/eta/-/eta-1.14.2.tgz#5e6181a26ec13d8444c559ce51f7b3090cebbdd1"
+  integrity sha512-wZmJAV7EFUG5W8XNXSazIdichnWEhGB1OWg4tnXWPj0CPNUcFdgorGNO6N9p6WBUgoUe4P0OziJYn1+6zxP2aQ==
+
+eta@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/eta/-/eta-2.2.0.tgz#eb8b5f8c4e8b6306561a455e62cd7492fe3a9b8a"
+  integrity sha512-UVQ72Rqjy/ZKQalzV5dCCJP80GrmPrMxh6NlNf+erV6ObL0ZFkhCstWRawS85z3smdr3d2wXPsZEY7rDPfGd2g==
+
+etag@~1.8.1:
+  version "1.8.1"
+  resolved "https://registry.yarnpkg.com/etag/-/etag-1.8.1.tgz#41ae2eeb65efa62268aebfea83ac7d79299b0887"
+  integrity sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==
+
+eval@^0.1.8:
+  version "0.1.8"
+  resolved "https://registry.yarnpkg.com/eval/-/eval-0.1.8.tgz#2b903473b8cc1d1989b83a1e7923f883eb357f85"
+  integrity sha512-EzV94NYKoO09GLXGjXj9JIlXijVck4ONSr5wiCWDvhsvj5jxSrzTmRU/9C1DyB6uToszLs8aifA6NQ7lEQdvFw==
+  dependencies:
+    "@types/node" "*"
+    require-like ">= 0.1.1"
+
+eventemitter3@^4.0.0:
+  version "4.0.7"
+  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
+  integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
+
+events@^3.2.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
+  integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
+
+execa@^5.0.0:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd"
+  integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==
+  dependencies:
+    cross-spawn "^7.0.3"
+    get-stream "^6.0.0"
+    human-signals "^2.1.0"
+    is-stream "^2.0.0"
+    merge-stream "^2.0.0"
+    npm-run-path "^4.0.1"
+    onetime "^5.1.2"
+    signal-exit "^3.0.3"
+    strip-final-newline "^2.0.0"
+
+express@^4.17.3:
+  version "4.18.2"
+  resolved "https://registry.yarnpkg.com/express/-/express-4.18.2.tgz#3fabe08296e930c796c19e3c516979386ba9fd59"
+  integrity sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==
+  dependencies:
+    accepts "~1.3.8"
+    array-flatten "1.1.1"
+    body-parser "1.20.1"
+    content-disposition "0.5.4"
+    content-type "~1.0.4"
+    cookie "0.5.0"
+    cookie-signature "1.0.6"
+    debug "2.6.9"
+    depd "2.0.0"
+    encodeurl "~1.0.2"
+    escape-html "~1.0.3"
+    etag "~1.8.1"
+    finalhandler "1.2.0"
+    fresh "0.5.2"
+    http-errors "2.0.0"
+    merge-descriptors "1.0.1"
+    methods "~1.1.2"
+    on-finished "2.4.1"
+    parseurl "~1.3.3"
+    path-to-regexp "0.1.7"
+    proxy-addr "~2.0.7"
+    qs "6.11.0"
+    range-parser "~1.2.1"
+    safe-buffer "5.2.1"
+    send "0.18.0"
+    serve-static "1.15.0"
+    setprototypeof "1.2.0"
+    statuses "2.0.1"
+    type-is "~1.6.18"
+    utils-merge "1.0.1"
+    vary "~1.1.2"
+
+extend-shallow@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
+  integrity sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==
+  dependencies:
+    is-extendable "^0.1.0"
+
+extend@^3.0.0:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
+  integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
+
+fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
+  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
+
+fast-glob@^3.2.11, fast-glob@^3.2.9, fast-glob@^3.3.0:
+  version "3.3.2"
+  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.2.tgz#a904501e57cfdd2ffcded45e99a54fef55e46129"
+  integrity sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==
+  dependencies:
+    "@nodelib/fs.stat" "^2.0.2"
+    "@nodelib/fs.walk" "^1.2.3"
+    glob-parent "^5.1.2"
+    merge2 "^1.3.0"
+    micromatch "^4.0.4"
+
+fast-json-stable-stringify@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
+  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
+
+fast-url-parser@1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/fast-url-parser/-/fast-url-parser-1.1.3.tgz#f4af3ea9f34d8a271cf58ad2b3759f431f0b318d"
+  integrity sha512-5jOCVXADYNuRkKFzNJ0dCCewsZiYo0dz8QNYljkOpFC6r2U4OBmKtvm/Tsuh4w1YYdDqDb31a8TVhBJ2OJKdqQ==
+  dependencies:
+    punycode "^1.3.2"
+
+fastq@^1.6.0:
+  version "1.17.1"
+  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.17.1.tgz#2a523f07a4e7b1e81a42b91b8bf2254107753b47"
+  integrity sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==
+  dependencies:
+    reusify "^1.0.4"
+
+faye-websocket@^0.11.3:
+  version "0.11.4"
+  resolved "https://registry.yarnpkg.com/faye-websocket/-/faye-websocket-0.11.4.tgz#7f0d9275cfdd86a1c963dc8b65fcc451edcbb1da"
+  integrity sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==
+  dependencies:
+    websocket-driver ">=0.5.1"
+
+fbemitter@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/fbemitter/-/fbemitter-3.0.0.tgz#00b2a1af5411254aab416cd75f9e6289bee4bff3"
+  integrity sha512-KWKaceCwKQU0+HPoop6gn4eOHk50bBv/VxjJtGMfwmJt3D29JpN4H4eisCtIPA+a8GVBam+ldMMpMjJUvpDyHw==
+  dependencies:
+    fbjs "^3.0.0"
+
+fbjs-css-vars@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/fbjs-css-vars/-/fbjs-css-vars-1.0.2.tgz#216551136ae02fe255932c3ec8775f18e2c078b8"
+  integrity sha512-b2XGFAFdWZWg0phtAWLHCk836A1Xann+I+Dgd3Gk64MHKZO44FfoD1KxyvbSh0qZsIoXQGGlVztIY+oitJPpRQ==
+
+fbjs@^3.0.0, fbjs@^3.0.1:
+  version "3.0.5"
+  resolved "https://registry.yarnpkg.com/fbjs/-/fbjs-3.0.5.tgz#aa0edb7d5caa6340011790bd9249dbef8a81128d"
+  integrity sha512-ztsSx77JBtkuMrEypfhgc3cI0+0h+svqeie7xHbh1k/IKdcydnvadp/mUaGgjAOXQmQSxsqgaRhS3q9fy+1kxg==
+  dependencies:
+    cross-fetch "^3.1.5"
+    fbjs-css-vars "^1.0.0"
+    loose-envify "^1.0.0"
+    object-assign "^4.1.0"
+    promise "^7.1.1"
+    setimmediate "^1.0.5"
+    ua-parser-js "^1.0.35"
+
+feed@^4.2.2:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/feed/-/feed-4.2.2.tgz#865783ef6ed12579e2c44bbef3c9113bc4956a7e"
+  integrity sha512-u5/sxGfiMfZNtJ3OvQpXcvotFpYkL0n9u9mM2vkui2nGo8b4wvDkJ8gAkYqbA8QpGyFCv3RK0Z+Iv+9veCS9bQ==
+  dependencies:
+    xml-js "^1.6.11"
+
+file-loader@^6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/file-loader/-/file-loader-6.2.0.tgz#baef7cf8e1840df325e4390b4484879480eebe4d"
+  integrity sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==
+  dependencies:
+    loader-utils "^2.0.0"
+    schema-utils "^3.0.0"
+
+filesize@^8.0.6:
+  version "8.0.7"
+  resolved "https://registry.yarnpkg.com/filesize/-/filesize-8.0.7.tgz#695e70d80f4e47012c132d57a059e80c6b580bd8"
+  integrity sha512-pjmC+bkIF8XI7fWaH8KxHcZL3DPybs1roSKP4rKDvy20tAWwIObE4+JIseG2byfGKhud5ZnM4YSGKBz7Sh0ndQ==
+
+fill-range@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
+  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
+  dependencies:
+    to-regex-range "^5.0.1"
+
+finalhandler@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.2.0.tgz#7d23fe5731b207b4640e4fcd00aec1f9207a7b32"
+  integrity sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==
+  dependencies:
+    debug "2.6.9"
+    encodeurl "~1.0.2"
+    escape-html "~1.0.3"
+    on-finished "2.4.1"
+    parseurl "~1.3.3"
+    statuses "2.0.1"
+    unpipe "~1.0.0"
+
+find-cache-dir@^3.3.1:
+  version "3.3.2"
+  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-3.3.2.tgz#b30c5b6eff0730731aea9bbd9dbecbd80256d64b"
+  integrity sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==
+  dependencies:
+    commondir "^1.0.1"
+    make-dir "^3.0.2"
+    pkg-dir "^4.1.0"
+
+find-up@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-3.0.0.tgz#49169f1d7993430646da61ecc5ae355c21c97b73"
+  integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
+  dependencies:
+    locate-path "^3.0.0"
+
+find-up@^4.0.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
+  integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
+  dependencies:
+    locate-path "^5.0.0"
+    path-exists "^4.0.0"
+
+find-up@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc"
+  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
+  dependencies:
+    locate-path "^6.0.0"
+    path-exists "^4.0.0"
+
+flat@^5.0.2:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241"
+  integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==
+
+flux@^4.0.1:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/flux/-/flux-4.0.4.tgz#9661182ea81d161ee1a6a6af10d20485ef2ac572"
+  integrity sha512-NCj3XlayA2UsapRpM7va6wU1+9rE5FIL7qoMcmxWHRzbp0yujihMBm9BBHZ1MDIk5h5o2Bl6eGiCe8rYELAmYw==
+  dependencies:
+    fbemitter "^3.0.0"
+    fbjs "^3.0.1"
+
+follow-redirects@^1.0.0, follow-redirects@^1.14.7:
+  version "1.15.5"
+  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.5.tgz#54d4d6d062c0fa7d9d17feb008461550e3ba8020"
+  integrity sha512-vSFWUON1B+yAw1VN4xMfxgn5fTUiaOzAJCKBwIIgT/+7CuGy9+r+5gITvP62j3RmaD5Ph65UaERdOSRGUzZtgw==
+
+follow-redirects@^1.15.0:
+  version "1.15.6"
+  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.6.tgz#7f815c0cda4249c74ff09e95ef97c23b5fd0399b"
+  integrity sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==
+
+fork-ts-checker-webpack-plugin@^6.5.0:
+  version "6.5.3"
+  resolved "https://registry.yarnpkg.com/fork-ts-checker-webpack-plugin/-/fork-ts-checker-webpack-plugin-6.5.3.tgz#eda2eff6e22476a2688d10661688c47f611b37f3"
+  integrity sha512-SbH/l9ikmMWycd5puHJKTkZJKddF4iRLyW3DeZ08HTI7NGyLS38MXd/KGgeWumQO7YNQbW2u/NtPT2YowbPaGQ==
+  dependencies:
+    "@babel/code-frame" "^7.8.3"
+    "@types/json-schema" "^7.0.5"
+    chalk "^4.1.0"
+    chokidar "^3.4.2"
+    cosmiconfig "^6.0.0"
+    deepmerge "^4.2.2"
+    fs-extra "^9.0.0"
+    glob "^7.1.6"
+    memfs "^3.1.2"
+    minimatch "^3.0.4"
+    schema-utils "2.7.0"
+    semver "^7.3.2"
+    tapable "^1.0.0"
+
+form-data@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.0.tgz#93919daeaf361ee529584b9b31664dc12c9fa452"
+  integrity sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==
+  dependencies:
+    asynckit "^0.4.0"
+    combined-stream "^1.0.8"
+    mime-types "^2.1.12"
+
+forwarded@0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/forwarded/-/forwarded-0.2.0.tgz#2269936428aad4c15c7ebe9779a84bf0b2a81811"
+  integrity sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==
+
+fraction.js@^4.3.7:
+  version "4.3.7"
+  resolved "https://registry.yarnpkg.com/fraction.js/-/fraction.js-4.3.7.tgz#06ca0085157e42fda7f9e726e79fefc4068840f7"
+  integrity sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==
+
+fresh@0.5.2:
+  version "0.5.2"
+  resolved "https://registry.yarnpkg.com/fresh/-/fresh-0.5.2.tgz#3d8cadd90d976569fa835ab1f8e4b23a105605a7"
+  integrity sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==
+
+fs-extra@^10.1.0:
+  version "10.1.0"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf"
+  integrity sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==
+  dependencies:
+    graceful-fs "^4.2.0"
+    jsonfile "^6.0.1"
+    universalify "^2.0.0"
+
+fs-extra@^9.0.0:
+  version "9.1.0"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.1.0.tgz#5954460c764a8da2094ba3554bf839e6b9a7c86d"
+  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
+  dependencies:
+    at-least-node "^1.0.0"
+    graceful-fs "^4.2.0"
+    jsonfile "^6.0.1"
+    universalify "^2.0.0"
+
+fs-monkey@^1.0.4:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/fs-monkey/-/fs-monkey-1.0.5.tgz#fe450175f0db0d7ea758102e1d84096acb925788"
+  integrity sha512-8uMbBjrhzW76TYgEV27Y5E//W2f/lTFmx78P2w19FZSxarhI/798APGQyuGCwmkNxgwGRhrLfvWyLBvNtuOmew==
+
+fs.realpath@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
+  integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
+
+fsevents@~2.3.2:
+  version "2.3.3"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6"
+  integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==
+
+function-bind@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c"
+  integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==
+
+gensync@^1.0.0-beta.1, gensync@^1.0.0-beta.2:
+  version "1.0.0-beta.2"
+  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
+  integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
+
+get-intrinsic@^1.1.3, get-intrinsic@^1.2.3, get-intrinsic@^1.2.4:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.2.4.tgz#e385f5a4b5227d449c3eabbad05494ef0abbeadd"
+  integrity sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==
+  dependencies:
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+    has-proto "^1.0.1"
+    has-symbols "^1.0.3"
+    hasown "^2.0.0"
+
+get-own-enumerable-property-symbols@^3.0.0:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz#b5fde77f22cbe35f390b4e089922c50bce6ef664"
+  integrity sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==
+
+get-stream@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5"
+  integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==
+  dependencies:
+    pump "^3.0.0"
+
+get-stream@^5.1.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-5.2.0.tgz#4966a1795ee5ace65e706c4b7beb71257d6e22d3"
+  integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==
+  dependencies:
+    pump "^3.0.0"
+
+get-stream@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
+  integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
+
+github-slugger@^1.4.0:
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/github-slugger/-/github-slugger-1.5.0.tgz#17891bbc73232051474d68bd867a34625c955f7d"
+  integrity sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw==
+
+glob-parent@^5.1.2, glob-parent@~5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
+  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
+  dependencies:
+    is-glob "^4.0.1"
+
+glob-parent@^6.0.1:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
+  integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
+  dependencies:
+    is-glob "^4.0.3"
+
+glob-to-regexp@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e"
+  integrity sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==
+
+glob@^7.0.0, glob@^7.1.3, glob@^7.1.6:
+  version "7.2.3"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
+  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
+  dependencies:
+    fs.realpath "^1.0.0"
+    inflight "^1.0.4"
+    inherits "2"
+    minimatch "^3.1.1"
+    once "^1.3.0"
+    path-is-absolute "^1.0.0"
+
+global-dirs@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/global-dirs/-/global-dirs-3.0.1.tgz#0c488971f066baceda21447aecb1a8b911d22485"
+  integrity sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==
+  dependencies:
+    ini "2.0.0"
+
+global-modules@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-2.0.0.tgz#997605ad2345f27f51539bea26574421215c7780"
+  integrity sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==
+  dependencies:
+    global-prefix "^3.0.0"
+
+global-prefix@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-3.0.0.tgz#fc85f73064df69f50421f47f883fe5b913ba9b97"
+  integrity sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==
+  dependencies:
+    ini "^1.3.5"
+    kind-of "^6.0.2"
+    which "^1.3.1"
+
+globals@^11.1.0:
+  version "11.12.0"
+  resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
+  integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
+
+globby@^11.0.1, globby@^11.0.4, globby@^11.1.0:
+  version "11.1.0"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
+  integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
+  dependencies:
+    array-union "^2.1.0"
+    dir-glob "^3.0.1"
+    fast-glob "^3.2.9"
+    ignore "^5.2.0"
+    merge2 "^1.4.1"
+    slash "^3.0.0"
+
+globby@^13.1.1:
+  version "13.2.2"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-13.2.2.tgz#63b90b1bf68619c2135475cbd4e71e66aa090592"
+  integrity sha512-Y1zNGV+pzQdh7H39l9zgB4PJqjRNqydvdYCDG4HFXM4XuvSaQQlEc91IU1yALL8gUTDomgBAfz3XJdmUS+oo0w==
+  dependencies:
+    dir-glob "^3.0.1"
+    fast-glob "^3.3.0"
+    ignore "^5.2.4"
+    merge2 "^1.4.1"
+    slash "^4.0.0"
+
+gopd@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/gopd/-/gopd-1.0.1.tgz#29ff76de69dac7489b7c0918a5788e56477c332c"
+  integrity sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==
+  dependencies:
+    get-intrinsic "^1.1.3"
+
+got@^9.6.0:
+  version "9.6.0"
+  resolved "https://registry.yarnpkg.com/got/-/got-9.6.0.tgz#edf45e7d67f99545705de1f7bbeeeb121765ed85"
+  integrity sha512-R7eWptXuGYxwijs0eV+v3o6+XH1IqVK8dJOEecQfTmkncw9AV4dcw/Dhxi8MdlqPthxxpZyizMzyg8RTmEsG+Q==
+  dependencies:
+    "@sindresorhus/is" "^0.14.0"
+    "@szmarczak/http-timer" "^1.1.2"
+    cacheable-request "^6.0.0"
+    decompress-response "^3.3.0"
+    duplexer3 "^0.1.4"
+    get-stream "^4.1.0"
+    lowercase-keys "^1.0.1"
+    mimic-response "^1.0.1"
+    p-cancelable "^1.0.0"
+    to-readable-stream "^1.0.0"
+    url-parse-lax "^3.0.0"
+
+graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.4, graceful-fs@^4.2.6, graceful-fs@^4.2.9:
+  version "4.2.11"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3"
+  integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
+
+gray-matter@^4.0.3:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/gray-matter/-/gray-matter-4.0.3.tgz#e893c064825de73ea1f5f7d88c7a9f7274288798"
+  integrity sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==
+  dependencies:
+    js-yaml "^3.13.1"
+    kind-of "^6.0.2"
+    section-matter "^1.0.0"
+    strip-bom-string "^1.0.0"
+
+gzip-size@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/gzip-size/-/gzip-size-6.0.0.tgz#065367fd50c239c0671cbcbad5be3e2eeb10e462"
+  integrity sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==
+  dependencies:
+    duplexer "^0.1.2"
+
+handle-thing@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/handle-thing/-/handle-thing-2.0.1.tgz#857f79ce359580c340d43081cc648970d0bb234e"
+  integrity sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==
+
+has-flag@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
+  integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==
+
+has-flag@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
+  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
+
+has-property-descriptors@^1.0.0, has-property-descriptors@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz#963ed7d071dc7bf5f084c5bfbe0d1b6222586854"
+  integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==
+  dependencies:
+    es-define-property "^1.0.0"
+
+has-proto@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/has-proto/-/has-proto-1.0.1.tgz#1885c1305538958aff469fef37937c22795408e0"
+  integrity sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==
+
+has-symbols@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
+  integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
+
+has-yarn@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/has-yarn/-/has-yarn-2.1.0.tgz#137e11354a7b5bf11aa5cb649cf0c6f3ff2b2e77"
+  integrity sha512-UqBRqi4ju7T+TqGNdqAO0PaSVGsDGJUBQvk9eUWNGRY1CFGDzYhLWoM7JQEemnlvVcv/YEmc2wNW8BC24EnUsw==
+
+hasown@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.1.tgz#26f48f039de2c0f8d3356c223fb8d50253519faa"
+  integrity sha512-1/th4MHjnwncwXsIW6QMzlvYL9kG5e/CpVvLRZe4XPa8TOUNbCELqmvhDmnkNsAjwaG4+I8gJJL0JBvTTLO9qA==
+  dependencies:
+    function-bind "^1.1.2"
+
+hast-to-hyperscript@^9.0.0:
+  version "9.0.1"
+  resolved "https://registry.yarnpkg.com/hast-to-hyperscript/-/hast-to-hyperscript-9.0.1.tgz#9b67fd188e4c81e8ad66f803855334173920218d"
+  integrity sha512-zQgLKqF+O2F72S1aa4y2ivxzSlko3MAvxkwG8ehGmNiqd98BIN3JM1rAJPmplEyLmGLO2QZYJtIneOSZ2YbJuA==
+  dependencies:
+    "@types/unist" "^2.0.3"
+    comma-separated-tokens "^1.0.0"
+    property-information "^5.3.0"
+    space-separated-tokens "^1.0.0"
+    style-to-object "^0.3.0"
+    unist-util-is "^4.0.0"
+    web-namespaces "^1.0.0"
+
+hast-util-from-parse5@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-from-parse5/-/hast-util-from-parse5-6.0.1.tgz#554e34abdeea25ac76f5bd950a1f0180e0b3bc2a"
+  integrity sha512-jeJUWiN5pSxW12Rh01smtVkZgZr33wBokLzKLwinYOUfSzm1Nl/c3GUGebDyOKjdsRgMvoVbV0VpAcpjF4NrJA==
+  dependencies:
+    "@types/parse5" "^5.0.0"
+    hastscript "^6.0.0"
+    property-information "^5.0.0"
+    vfile "^4.0.0"
+    vfile-location "^3.2.0"
+    web-namespaces "^1.0.0"
+
+hast-util-parse-selector@^2.0.0:
+  version "2.2.5"
+  resolved "https://registry.yarnpkg.com/hast-util-parse-selector/-/hast-util-parse-selector-2.2.5.tgz#d57c23f4da16ae3c63b3b6ca4616683313499c3a"
+  integrity sha512-7j6mrk/qqkSehsM92wQjdIgWM2/BW61u/53G6xmC8i1OmEdKLHbk419QKQUjz6LglWsfqoiHmyMRkP1BGjecNQ==
+
+hast-util-raw@6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-raw/-/hast-util-raw-6.0.1.tgz#973b15930b7529a7b66984c98148b46526885977"
+  integrity sha512-ZMuiYA+UF7BXBtsTBNcLBF5HzXzkyE6MLzJnL605LKE8GJylNjGc4jjxazAHUtcwT5/CEt6afRKViYB4X66dig==
+  dependencies:
+    "@types/hast" "^2.0.0"
+    hast-util-from-parse5 "^6.0.0"
+    hast-util-to-parse5 "^6.0.0"
+    html-void-elements "^1.0.0"
+    parse5 "^6.0.0"
+    unist-util-position "^3.0.0"
+    vfile "^4.0.0"
+    web-namespaces "^1.0.0"
+    xtend "^4.0.0"
+    zwitch "^1.0.0"
+
+hast-util-to-parse5@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/hast-util-to-parse5/-/hast-util-to-parse5-6.0.0.tgz#1ec44650b631d72952066cea9b1445df699f8479"
+  integrity sha512-Lu5m6Lgm/fWuz8eWnrKezHtVY83JeRGaNQ2kn9aJgqaxvVkFCZQBEhgodZUDUvoodgyROHDb3r5IxAEdl6suJQ==
+  dependencies:
+    hast-to-hyperscript "^9.0.0"
+    property-information "^5.0.0"
+    web-namespaces "^1.0.0"
+    xtend "^4.0.0"
+    zwitch "^1.0.0"
+
+hastscript@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/hastscript/-/hastscript-6.0.0.tgz#e8768d7eac56c3fdeac8a92830d58e811e5bf640"
+  integrity sha512-nDM6bvd7lIqDUiYEiu5Sl/+6ReP0BMk/2f4U/Rooccxkj0P5nm+acM5PrGJ/t5I8qPGiqZSE6hVAwZEdZIvP4w==
+  dependencies:
+    "@types/hast" "^2.0.0"
+    comma-separated-tokens "^1.0.0"
+    hast-util-parse-selector "^2.0.0"
+    property-information "^5.0.0"
+    space-separated-tokens "^1.0.0"
+
+he@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
+  integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
+
+history@^4.9.0:
+  version "4.10.1"
+  resolved "https://registry.yarnpkg.com/history/-/history-4.10.1.tgz#33371a65e3a83b267434e2b3f3b1b4c58aad4cf3"
+  integrity sha512-36nwAD620w12kuzPAsyINPWJqlNbij+hpK1k9XRloDtym8mxzGYl2c17LnV6IAGB2Dmg4tEa7G7DlawS0+qjew==
+  dependencies:
+    "@babel/runtime" "^7.1.2"
+    loose-envify "^1.2.0"
+    resolve-pathname "^3.0.0"
+    tiny-invariant "^1.0.2"
+    tiny-warning "^1.0.0"
+    value-equal "^1.0.1"
+
+hoist-non-react-statics@^3.1.0:
+  version "3.3.2"
+  resolved "https://registry.yarnpkg.com/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz#ece0acaf71d62c2969c2ec59feff42a4b1a85b45"
+  integrity sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==
+  dependencies:
+    react-is "^16.7.0"
+
+hpack.js@^2.1.6:
+  version "2.1.6"
+  resolved "https://registry.yarnpkg.com/hpack.js/-/hpack.js-2.1.6.tgz#87774c0949e513f42e84575b3c45681fade2a0b2"
+  integrity sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==
+  dependencies:
+    inherits "^2.0.1"
+    obuf "^1.0.0"
+    readable-stream "^2.0.1"
+    wbuf "^1.1.0"
+
+html-entities@^2.3.2:
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/html-entities/-/html-entities-2.4.0.tgz#edd0cee70402584c8c76cc2c0556db09d1f45061"
+  integrity sha512-igBTJcNNNhvZFRtm8uA6xMY6xYleeDwn3PeBCkDz7tHttv4F2hsDI2aPgNERWzvRcNYHNT3ymRaQzllmXj4YsQ==
+
+html-escaper@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
+  integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
+
+html-minifier-terser@^6.0.2, html-minifier-terser@^6.1.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz#bfc818934cc07918f6b3669f5774ecdfd48f32ab"
+  integrity sha512-YXxSlJBZTP7RS3tWnQw74ooKa6L9b9i9QYXY21eUEvhZ3u9XLfv6OnFsQq6RxkhHygsaUMvYsZRV5rU/OVNZxw==
+  dependencies:
+    camel-case "^4.1.2"
+    clean-css "^5.2.2"
+    commander "^8.3.0"
+    he "^1.2.0"
+    param-case "^3.0.4"
+    relateurl "^0.2.7"
+    terser "^5.10.0"
+
+html-tags@^3.2.0:
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/html-tags/-/html-tags-3.3.1.tgz#a04026a18c882e4bba8a01a3d39cfe465d40b5ce"
+  integrity sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ==
+
+html-void-elements@^1.0.0:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/html-void-elements/-/html-void-elements-1.0.5.tgz#ce9159494e86d95e45795b166c2021c2cfca4483"
+  integrity sha512-uE/TxKuyNIcx44cIWnjr/rfIATDH7ZaOMmstu0CwhFG1Dunhlp4OC6/NMbhiwoq5BpW0ubi303qnEk/PZj614w==
+
+html-webpack-plugin@^5.5.0:
+  version "5.6.0"
+  resolved "https://registry.yarnpkg.com/html-webpack-plugin/-/html-webpack-plugin-5.6.0.tgz#50a8fa6709245608cb00e811eacecb8e0d7b7ea0"
+  integrity sha512-iwaY4wzbe48AfKLZ/Cc8k0L+FKG6oSNRaZ8x5A/T/IVDGyXcbHncM9TdDa93wn0FsSm82FhTKW7f3vS61thXAw==
+  dependencies:
+    "@types/html-minifier-terser" "^6.0.0"
+    html-minifier-terser "^6.0.2"
+    lodash "^4.17.21"
+    pretty-error "^4.0.0"
+    tapable "^2.0.0"
+
+htmlparser2@^6.1.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/htmlparser2/-/htmlparser2-6.1.0.tgz#c4d762b6c3371a05dbe65e94ae43a9f845fb8fb7"
+  integrity sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==
+  dependencies:
+    domelementtype "^2.0.1"
+    domhandler "^4.0.0"
+    domutils "^2.5.2"
+    entities "^2.0.0"
+
+htmlparser2@^8.0.1:
+  version "8.0.2"
+  resolved "https://registry.yarnpkg.com/htmlparser2/-/htmlparser2-8.0.2.tgz#f002151705b383e62433b5cf466f5b716edaec21"
+  integrity sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==
+  dependencies:
+    domelementtype "^2.3.0"
+    domhandler "^5.0.3"
+    domutils "^3.0.1"
+    entities "^4.4.0"
+
+http-cache-semantics@^4.0.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz#abe02fcb2985460bf0323be664436ec3476a6d5a"
+  integrity sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==
+
+http-deceiver@^1.2.7:
+  version "1.2.7"
+  resolved "https://registry.yarnpkg.com/http-deceiver/-/http-deceiver-1.2.7.tgz#fa7168944ab9a519d337cb0bec7284dc3e723d87"
+  integrity sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==
+
+http-errors@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-2.0.0.tgz#b7774a1486ef73cf7667ac9ae0858c012c57b9d3"
+  integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==
+  dependencies:
+    depd "2.0.0"
+    inherits "2.0.4"
+    setprototypeof "1.2.0"
+    statuses "2.0.1"
+    toidentifier "1.0.1"
+
+http-errors@~1.6.2:
+  version "1.6.3"
+  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-1.6.3.tgz#8b55680bb4be283a0b5bf4ea2e38580be1d9320d"
+  integrity sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==
+  dependencies:
+    depd "~1.1.2"
+    inherits "2.0.3"
+    setprototypeof "1.1.0"
+    statuses ">= 1.4.0 < 2"
+
+http-parser-js@>=0.5.1:
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/http-parser-js/-/http-parser-js-0.5.8.tgz#af23090d9ac4e24573de6f6aecc9d84a48bf20e3"
+  integrity sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==
+
+http-proxy-middleware@^2.0.3:
+  version "2.0.6"
+  resolved "https://registry.yarnpkg.com/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz#e1a4dd6979572c7ab5a4e4b55095d1f32a74963f"
+  integrity sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==
+  dependencies:
+    "@types/http-proxy" "^1.17.8"
+    http-proxy "^1.18.1"
+    is-glob "^4.0.1"
+    is-plain-obj "^3.0.0"
+    micromatch "^4.0.2"
+
+http-proxy@^1.18.1:
+  version "1.18.1"
+  resolved "https://registry.yarnpkg.com/http-proxy/-/http-proxy-1.18.1.tgz#401541f0534884bbf95260334e72f88ee3976549"
+  integrity sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==
+  dependencies:
+    eventemitter3 "^4.0.0"
+    follow-redirects "^1.0.0"
+    requires-port "^1.0.0"
+
+human-signals@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
+  integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
+
+iconv-lite@0.4.24:
+  version "0.4.24"
+  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
+  integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
+  dependencies:
+    safer-buffer ">= 2.1.2 < 3"
+
+icss-utils@^5.0.0, icss-utils@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/icss-utils/-/icss-utils-5.1.0.tgz#c6be6858abd013d768e98366ae47e25d5887b1ae"
+  integrity sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==
+
+ignore@^5.2.0, ignore@^5.2.4:
+  version "5.3.1"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.3.1.tgz#5073e554cd42c5b33b394375f538b8593e34d4ef"
+  integrity sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==
+
+image-size@^1.0.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/image-size/-/image-size-1.1.1.tgz#ddd67d4dc340e52ac29ce5f546a09f4e29e840ac"
+  integrity sha512-541xKlUw6jr/6gGuk92F+mYM5zaFAc5ahphvkqvNe2bQ6gVBkd6bfrmVJ2t4KDAfikAYZyIqTnktX3i6/aQDrQ==
+  dependencies:
+    queue "6.0.2"
+
+immer@^9.0.7:
+  version "9.0.21"
+  resolved "https://registry.yarnpkg.com/immer/-/immer-9.0.21.tgz#1e025ea31a40f24fb064f1fef23e931496330176"
+  integrity sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==
+
+import-fresh@^3.1.0, import-fresh@^3.2.1, import-fresh@^3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
+  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
+  dependencies:
+    parent-module "^1.0.0"
+    resolve-from "^4.0.0"
+
+import-lazy@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/import-lazy/-/import-lazy-2.1.0.tgz#05698e3d45c88e8d7e9d92cb0584e77f096f3e43"
+  integrity sha512-m7ZEHgtw69qOGw+jwxXkHlrlIPdTGkyh66zXZ1ajZbxkDBNjSY/LGbmjc7h0s2ELsUDTAhFr55TrPSSqJGPG0A==
+
+imurmurhash@^0.1.4:
+  version "0.1.4"
+  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
+  integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
+
+indent-string@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
+  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
+
+infima@0.2.0-alpha.42:
+  version "0.2.0-alpha.42"
+  resolved "https://registry.yarnpkg.com/infima/-/infima-0.2.0-alpha.42.tgz#f6e86a655ad40877c6b4d11b2ede681eb5470aa5"
+  integrity sha512-ift8OXNbQQwtbIt6z16KnSWP7uJ/SysSMFI4F87MNRTicypfl4Pv3E2OGVv6N3nSZFJvA8imYulCBS64iyHYww==
+
+inflight@^1.0.4:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
+  integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
+  dependencies:
+    once "^1.3.0"
+    wrappy "1"
+
+inherits@2, inherits@2.0.4, inherits@^2.0.0, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.3:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
+
+inherits@2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
+  integrity sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==
+
+ini@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/ini/-/ini-2.0.0.tgz#e5fd556ecdd5726be978fa1001862eacb0a94bc5"
+  integrity sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==
+
+ini@^1.3.5, ini@~1.3.0:
+  version "1.3.8"
+  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
+  integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
+
+inline-style-parser@0.1.1:
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/inline-style-parser/-/inline-style-parser-0.1.1.tgz#ec8a3b429274e9c0a1f1c4ffa9453a7fef72cea1"
+  integrity sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==
+
+interpret@^1.0.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
+  integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==
+
+invariant@^2.2.4:
+  version "2.2.4"
+  resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.4.tgz#610f3c92c9359ce1db616e538008d23ff35158e6"
+  integrity sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==
+  dependencies:
+    loose-envify "^1.0.0"
+
+ipaddr.js@1.9.1:
+  version "1.9.1"
+  resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-1.9.1.tgz#bff38543eeb8984825079ff3a2a8e6cbd46781b3"
+  integrity sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==
+
+ipaddr.js@^2.0.1:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-2.1.0.tgz#2119bc447ff8c257753b196fc5f1ce08a4cdf39f"
+  integrity sha512-LlbxQ7xKzfBusov6UMi4MFpEg0m+mAm9xyNGEduwXMEDuf4WfzB/RZwMVYEd7IKGvh4IUkEXYxtAVu9T3OelJQ==
+
+is-alphabetical@1.0.4, is-alphabetical@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-alphabetical/-/is-alphabetical-1.0.4.tgz#9e7d6b94916be22153745d184c298cbf986a686d"
+  integrity sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg==
+
+is-alphanumerical@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz#7eb9a2431f855f6b1ef1a78e326df515696c4dbf"
+  integrity sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A==
+  dependencies:
+    is-alphabetical "^1.0.0"
+    is-decimal "^1.0.0"
+
+is-arrayish@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
+  integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==
+
+is-binary-path@~2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
+  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
+  dependencies:
+    binary-extensions "^2.0.0"
+
+is-buffer@^2.0.0:
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-2.0.5.tgz#ebc252e400d22ff8d77fa09888821a24a658c191"
+  integrity sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==
+
+is-ci@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-2.0.0.tgz#6bc6334181810e04b5c22b3d589fdca55026404c"
+  integrity sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==
+  dependencies:
+    ci-info "^2.0.0"
+
+is-core-module@^2.13.0:
+  version "2.13.1"
+  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.13.1.tgz#ad0d7532c6fea9da1ebdc82742d74525c6273384"
+  integrity sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==
+  dependencies:
+    hasown "^2.0.0"
+
+is-decimal@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-decimal/-/is-decimal-1.0.4.tgz#65a3a5958a1c5b63a706e1b333d7cd9f630d3fa5"
+  integrity sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw==
+
+is-docker@^2.0.0, is-docker@^2.1.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa"
+  integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
+
+is-extendable@^0.1.0:
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
+  integrity sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==
+
+is-extglob@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
+  integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
+
+is-fullwidth-code-point@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
+  integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
+
+is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
+  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
+  dependencies:
+    is-extglob "^2.1.1"
+
+is-hexadecimal@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz#cc35c97588da4bd49a8eedd6bc4082d44dcb23a7"
+  integrity sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw==
+
+is-installed-globally@^0.4.0:
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/is-installed-globally/-/is-installed-globally-0.4.0.tgz#9a0fd407949c30f86eb6959ef1b7994ed0b7b520"
+  integrity sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==
+  dependencies:
+    global-dirs "^3.0.0"
+    is-path-inside "^3.0.2"
+
+is-npm@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/is-npm/-/is-npm-5.0.0.tgz#43e8d65cc56e1b67f8d47262cf667099193f45a8"
+  integrity sha512-WW/rQLOazUq+ST/bCAVBp/2oMERWLsR7OrKyt052dNDk4DHcDE0/7QSXITlmi+VBcV13DfIbysG3tZJm5RfdBA==
+
+is-number@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
+  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
+
+is-obj@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"
+  integrity sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==
+
+is-obj@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982"
+  integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==
+
+is-path-cwd@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-2.2.0.tgz#67d43b82664a7b5191fd9119127eb300048a9fdb"
+  integrity sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==
+
+is-path-inside@^3.0.2:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
+  integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
+
+is-plain-obj@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz#45e42e37fccf1f40da8e5f76ee21515840c09287"
+  integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
+
+is-plain-obj@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-3.0.0.tgz#af6f2ea14ac5a646183a5bbdb5baabbc156ad9d7"
+  integrity sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==
+
+is-plain-object@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
+  integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
+  dependencies:
+    isobject "^3.0.1"
+
+is-plain-object@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-5.0.0.tgz#4427f50ab3429e9025ea7d52e9043a9ef4159344"
+  integrity sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==
+
+is-regexp@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-regexp/-/is-regexp-1.0.0.tgz#fd2d883545c46bac5a633e7b9a09e87fa2cb5069"
+  integrity sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==
+
+is-root@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/is-root/-/is-root-2.1.0.tgz#809e18129cf1129644302a4f8544035d51984a9c"
+  integrity sha512-AGOriNp96vNBd3HtU+RzFEc75FfR5ymiYv8E553I71SCeXBiMsVDUtdio1OEFvrPyLIQ9tVR5RxXIFe5PUFjMg==
+
+is-stream@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
+  integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
+
+is-typedarray@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
+  integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==
+
+is-whitespace-character@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-whitespace-character/-/is-whitespace-character-1.0.4.tgz#0858edd94a95594c7c9dd0b5c174ec6e45ee4aa7"
+  integrity sha512-SDweEzfIZM0SJV0EUga669UTKlmL0Pq8Lno0QDQsPnvECB3IM2aP0gdx5TrU0A01MAPfViaZiI2V1QMZLaKK5w==
+
+is-word-character@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-word-character/-/is-word-character-1.0.4.tgz#ce0e73216f98599060592f62ff31354ddbeb0230"
+  integrity sha512-5SMO8RVennx3nZrqtKwCGyyetPE9VDba5ugvKLaD4KopPG5kR4mQ7tNt/r7feL5yt5h3lpuBbIUmCOG2eSzXHA==
+
+is-wsl@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271"
+  integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
+  dependencies:
+    is-docker "^2.0.0"
+
+is-yarn-global@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/is-yarn-global/-/is-yarn-global-0.3.0.tgz#d502d3382590ea3004893746754c89139973e232"
+  integrity sha512-VjSeb/lHmkoyd8ryPVIKvOCn4D1koMqY+vqyjjUfc3xyKtP4dYOxM44sZrnqQSzSds3xyOrUTLTC9LVCVgLngw==
+
+isarray@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf"
+  integrity sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==
+
+isarray@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
+  integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==
+
+isexe@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
+  integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
+
+isobject@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
+  integrity sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==
+
+jest-util@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-29.7.0.tgz#23c2b62bfb22be82b44de98055802ff3710fc0bc"
+  integrity sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==
+  dependencies:
+    "@jest/types" "^29.6.3"
+    "@types/node" "*"
+    chalk "^4.0.0"
+    ci-info "^3.2.0"
+    graceful-fs "^4.2.9"
+    picomatch "^2.2.3"
+
+jest-worker@^27.4.5:
+  version "27.5.1"
+  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0"
+  integrity sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==
+  dependencies:
+    "@types/node" "*"
+    merge-stream "^2.0.0"
+    supports-color "^8.0.0"
+
+jest-worker@^29.1.2:
+  version "29.7.0"
+  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-29.7.0.tgz#acad073acbbaeb7262bd5389e1bcf43e10058d4a"
+  integrity sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==
+  dependencies:
+    "@types/node" "*"
+    jest-util "^29.7.0"
+    merge-stream "^2.0.0"
+    supports-color "^8.0.0"
+
+jiti@^1.20.0:
+  version "1.21.0"
+  resolved "https://registry.yarnpkg.com/jiti/-/jiti-1.21.0.tgz#7c97f8fe045724e136a397f7340475244156105d"
+  integrity sha512-gFqAIbuKyyso/3G2qhiO2OM6shY6EPP/R0+mkDbyspxKazh8BXDC5FiFsUjlczgdNz/vfra0da2y+aHrusLG/Q==
+
+joi@^17.6.0:
+  version "17.12.1"
+  resolved "https://registry.yarnpkg.com/joi/-/joi-17.12.1.tgz#3347ecf4cd3301962d42191c021b165eef1f395b"
+  integrity sha512-vtxmq+Lsc5SlfqotnfVjlViWfOL9nt/avKNbKYizwf6gsCfq9NYY/ceYRMFD8XDdrjJ9abJyScWmhmIiy+XRtQ==
+  dependencies:
+    "@hapi/hoek" "^9.3.0"
+    "@hapi/topo" "^5.1.0"
+    "@sideway/address" "^4.1.5"
+    "@sideway/formula" "^3.0.1"
+    "@sideway/pinpoint" "^2.0.0"
+
+"js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
+  integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
+
+js-yaml@^3.13.1:
+  version "3.14.1"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
+  integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
+  dependencies:
+    argparse "^1.0.7"
+    esprima "^4.0.0"
+
+js-yaml@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
+  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
+  dependencies:
+    argparse "^2.0.1"
+
+jsesc@^2.5.1:
+  version "2.5.2"
+  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
+  integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
+
+jsesc@~0.5.0:
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d"
+  integrity sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==
+
+json-buffer@3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.0.tgz#5b1f397afc75d677bde8bcfc0e47e1f9a3d9a898"
+  integrity sha512-CuUqjv0FUZIdXkHPI8MezCnFCdaTAacej1TZYulLoAg1h/PhwkdXFN4V/gzY4g+fMBCOV2xF+rp7t2XD2ns/NQ==
+
+json-parse-even-better-errors@^2.3.0, json-parse-even-better-errors@^2.3.1:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
+  integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
+
+json-schema-traverse@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
+  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
+
+json-schema-traverse@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2"
+  integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==
+
+json5@^2.1.2, json5@^2.2.3:
+  version "2.2.3"
+  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283"
+  integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==
+
+jsonfile@^6.0.1:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae"
+  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
+  dependencies:
+    universalify "^2.0.0"
+  optionalDependencies:
+    graceful-fs "^4.1.6"
+
+keyv@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/keyv/-/keyv-3.1.0.tgz#ecc228486f69991e49e9476485a5be1e8fc5c4d9"
+  integrity sha512-9ykJ/46SN/9KPM/sichzQ7OvXyGDYKGTaDlKMGCAlg2UK8KRy4jb0d8sFc+0Tt0YYnThq8X2RZgCg74RPxgcVA==
+  dependencies:
+    json-buffer "3.0.0"
+
+kind-of@^6.0.0, kind-of@^6.0.2:
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
+  integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
+
+kleur@^3.0.3:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/kleur/-/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e"
+  integrity sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==
+
+latest-version@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/latest-version/-/latest-version-5.1.0.tgz#119dfe908fe38d15dfa43ecd13fa12ec8832face"
+  integrity sha512-weT+r0kTkRQdCdYCNtkMwWXQTMEswKrFBkm4ckQOMVhhqhIMI1UT2hMj+1iigIhgSZm5gTmrRXBNoGUgaTY1xA==
+  dependencies:
+    package-json "^6.3.0"
+
+launch-editor@^2.6.0:
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/launch-editor/-/launch-editor-2.6.1.tgz#f259c9ef95cbc9425620bbbd14b468fcdb4ffe3c"
+  integrity sha512-eB/uXmFVpY4zezmGp5XtU21kwo7GBbKB+EQ+UZeWtGb9yAM5xt/Evk+lYH3eRNAtId+ej4u7TYPFZ07w4s7rRw==
+  dependencies:
+    picocolors "^1.0.0"
+    shell-quote "^1.8.1"
+
+leven@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/leven/-/leven-3.1.0.tgz#77891de834064cccba82ae7842bb6b14a13ed7f2"
+  integrity sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==
+
+lilconfig@^2.0.3:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/lilconfig/-/lilconfig-2.1.0.tgz#78e23ac89ebb7e1bfbf25b18043de756548e7f52"
+  integrity sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==
+
+lines-and-columns@^1.1.6:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
+  integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
+
+loader-runner@^4.2.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.3.0.tgz#c1b4a163b99f614830353b16755e7149ac2314e1"
+  integrity sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==
+
+loader-utils@^2.0.0:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.4.tgz#8b5cb38b5c34a9a018ee1fc0e6a066d1dfcc528c"
+  integrity sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==
+  dependencies:
+    big.js "^5.2.2"
+    emojis-list "^3.0.0"
+    json5 "^2.1.2"
+
+loader-utils@^3.2.0:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-3.2.1.tgz#4fb104b599daafd82ef3e1a41fb9265f87e1f576"
+  integrity sha512-ZvFw1KWS3GVyYBYb7qkmRM/WwL2TQQBxgCK62rlvm4WpVQ23Nb4tYjApUlfjrEGvOs7KHEsmyUn75OHZrJMWPw==
+
+locate-path@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-3.0.0.tgz#dbec3b3ab759758071b58fe59fc41871af21400e"
+  integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
+  dependencies:
+    p-locate "^3.0.0"
+    path-exists "^3.0.0"
+
+locate-path@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
+  integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
+  dependencies:
+    p-locate "^4.1.0"
+
+locate-path@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286"
+  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
+  dependencies:
+    p-locate "^5.0.0"
+
+lodash.curry@^4.0.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/lodash.curry/-/lodash.curry-4.1.1.tgz#248e36072ede906501d75966200a86dab8b23170"
+  integrity sha512-/u14pXGviLaweY5JI0IUzgzF2J6Ne8INyzAZjImcryjgkZ+ebruBxy2/JaOOkTqScddcYtakjhSaeemV8lR0tA==
+
+lodash.debounce@^4.0.8:
+  version "4.0.8"
+  resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
+  integrity sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==
+
+lodash.flow@^3.3.0:
+  version "3.5.0"
+  resolved "https://registry.yarnpkg.com/lodash.flow/-/lodash.flow-3.5.0.tgz#87bf40292b8cf83e4e8ce1a3ae4209e20071675a"
+  integrity sha512-ff3BX/tSioo+XojX4MOsOMhJw0nZoUEF011LX8g8d3gvjVbxd89cCio4BCXronjxcTUIJUoqKEUA+n4CqvvRPw==
+
+lodash.memoize@^4.1.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe"
+  integrity sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==
+
+lodash.uniq@4.5.0, lodash.uniq@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
+  integrity sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==
+
+lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21:
+  version "4.17.21"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
+  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
+
+loose-envify@^1.0.0, loose-envify@^1.1.0, loose-envify@^1.2.0, loose-envify@^1.3.1, loose-envify@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"
+  integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==
+  dependencies:
+    js-tokens "^3.0.0 || ^4.0.0"
+
+lower-case@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz#6fa237c63dbdc4a82ca0fd882e4722dc5e634e28"
+  integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==
+  dependencies:
+    tslib "^2.0.3"
+
+lowercase-keys@^1.0.0, lowercase-keys@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-1.0.1.tgz#6f9e30b47084d971a7c820ff15a6c5167b74c26f"
+  integrity sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==
+
+lowercase-keys@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-2.0.0.tgz#2603e78b7b4b0006cbca2fbcc8a3202558ac9479"
+  integrity sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==
+
+lru-cache@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
+  integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
+  dependencies:
+    yallist "^3.0.2"
+
+lru-cache@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
+  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
+  dependencies:
+    yallist "^4.0.0"
+
+make-dir@^3.0.0, make-dir@^3.0.2, make-dir@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
+  integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==
+  dependencies:
+    semver "^6.0.0"
+
+markdown-escapes@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/markdown-escapes/-/markdown-escapes-1.0.4.tgz#c95415ef451499d7602b91095f3c8e8975f78535"
+  integrity sha512-8z4efJYk43E0upd0NbVXwgSTQs6cT3T06etieCMEg7dRbzCbxUCK/GHlX8mhHRDcp+OLlHkPKsvqQTCvsRl2cg==
+
+mdast-squeeze-paragraphs@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/mdast-squeeze-paragraphs/-/mdast-squeeze-paragraphs-4.0.0.tgz#7c4c114679c3bee27ef10b58e2e015be79f1ef97"
+  integrity sha512-zxdPn69hkQ1rm4J+2Cs2j6wDEv7O17TfXTJ33tl/+JPIoEmtV9t2ZzBM5LPHE8QlHsmVD8t3vPKCyY3oH+H8MQ==
+  dependencies:
+    unist-util-remove "^2.0.0"
+
+mdast-util-definitions@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-definitions/-/mdast-util-definitions-4.0.0.tgz#c5c1a84db799173b4dcf7643cda999e440c24db2"
+  integrity sha512-k8AJ6aNnUkB7IE+5azR9h81O5EQ/cTDXtWdMq9Kk5KcEW/8ritU5CeLg/9HhOC++nALHBlaogJ5jz0Ybk3kPMQ==
+  dependencies:
+    unist-util-visit "^2.0.0"
+
+mdast-util-to-hast@10.0.1:
+  version "10.0.1"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-hast/-/mdast-util-to-hast-10.0.1.tgz#0cfc82089494c52d46eb0e3edb7a4eb2aea021eb"
+  integrity sha512-BW3LM9SEMnjf4HXXVApZMt8gLQWVNXc3jryK0nJu/rOXPOnlkUjmdkDlmxMirpbU9ILncGFIwLH/ubnWBbcdgA==
+  dependencies:
+    "@types/mdast" "^3.0.0"
+    "@types/unist" "^2.0.0"
+    mdast-util-definitions "^4.0.0"
+    mdurl "^1.0.0"
+    unist-builder "^2.0.0"
+    unist-util-generated "^1.0.0"
+    unist-util-position "^3.0.0"
+    unist-util-visit "^2.0.0"
+
+mdast-util-to-string@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-string/-/mdast-util-to-string-2.0.0.tgz#b8cfe6a713e1091cb5b728fc48885a4767f8b97b"
+  integrity sha512-AW4DRS3QbBayY/jJmD8437V1Gombjf8RSOUCMFBuo5iHi58AGEgVCKQ+ezHkZZDpAQS75hcBMpLqjpJTjtUL7w==
+
+mdn-data@2.0.14:
+  version "2.0.14"
+  resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.0.14.tgz#7113fc4281917d63ce29b43446f701e68c25ba50"
+  integrity sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==
+
+mdurl@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/mdurl/-/mdurl-1.0.1.tgz#fe85b2ec75a59037f2adfec100fd6c601761152e"
+  integrity sha512-/sKlQJCBYVY9Ers9hqzKou4H6V5UWc/M59TH2dvkt+84itfnq7uFOMLpOiOS4ujvHP4etln18fmIxA5R5fll0g==
+
+media-typer@0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
+  integrity sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==
+
+memfs@^3.1.2, memfs@^3.4.3:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/memfs/-/memfs-3.6.0.tgz#d7a2110f86f79dd950a8b6df6d57bc984aa185f6"
+  integrity sha512-EGowvkkgbMcIChjMTMkESFDbZeSh8xZ7kNSF0hAiAN4Jh6jgHCRS0Ga/+C8y6Au+oqpezRHCfPsmJ2+DwAgiwQ==
+  dependencies:
+    fs-monkey "^1.0.4"
+
+merge-descriptors@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/merge-descriptors/-/merge-descriptors-1.0.1.tgz#b00aaa556dd8b44568150ec9d1b953f3f90cbb61"
+  integrity sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==
+
+merge-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
+  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
+
+merge2@^1.3.0, merge2@^1.4.1:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
+  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
+
+methods@~1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee"
+  integrity sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==
+
+micromatch@^4.0.2, micromatch@^4.0.4, micromatch@^4.0.5:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
+  integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
+  dependencies:
+    braces "^3.0.2"
+    picomatch "^2.3.1"
+
+mime-db@1.52.0, "mime-db@>= 1.43.0 < 2":
+  version "1.52.0"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
+  integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
+
+mime-db@~1.33.0:
+  version "1.33.0"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.33.0.tgz#a3492050a5cb9b63450541e39d9788d2272783db"
+  integrity sha512-BHJ/EKruNIqJf/QahvxwQZXKygOQ256myeN/Ew+THcAa5q+PjyTTMMeNQC4DZw5AwfvelsUrA6B67NKMqXDbzQ==
+
+mime-types@2.1.18:
+  version "2.1.18"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.18.tgz#6f323f60a83d11146f831ff11fd66e2fe5503bb8"
+  integrity sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ==
+  dependencies:
+    mime-db "~1.33.0"
+
+mime-types@^2.1.12, mime-types@^2.1.27, mime-types@^2.1.31, mime-types@~2.1.17, mime-types@~2.1.24, mime-types@~2.1.34:
+  version "2.1.35"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
+  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
+  dependencies:
+    mime-db "1.52.0"
+
+mime@1.6.0:
+  version "1.6.0"
+  resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
+  integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
+
+mimic-fn@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
+  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
+
+mimic-response@^1.0.0, mimic-response@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-1.0.1.tgz#4923538878eef42063cb8a3e3b0798781487ab1b"
+  integrity sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==
+
+mini-css-extract-plugin@^2.6.1:
+  version "2.8.0"
+  resolved "https://registry.yarnpkg.com/mini-css-extract-plugin/-/mini-css-extract-plugin-2.8.0.tgz#1aeae2a90a954b6426c9e8311eab36b450f553a0"
+  integrity sha512-CxmUYPFcTgET1zImteG/LZOy/4T5rTojesQXkSNBiquhydn78tfbCE9sjIjnJ/UcjNjOC1bphTCCW5rrS7cXAg==
+  dependencies:
+    schema-utils "^4.0.0"
+    tapable "^2.2.1"
+
+minimalistic-assert@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
+  integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
+
+minimatch@3.1.2, minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
+  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
+  dependencies:
+    brace-expansion "^1.1.7"
+
+minimist@^1.2.0, minimist@^1.2.5:
+  version "1.2.8"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
+  integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
+
+mrmime@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/mrmime/-/mrmime-2.0.0.tgz#151082a6e06e59a9a39b46b3e14d5cfe92b3abb4"
+  integrity sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==
+
+ms@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
+  integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
+
+ms@2.1.2:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
+  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
+
+ms@2.1.3:
+  version "2.1.3"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
+  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
+
+multicast-dns@^7.2.5:
+  version "7.2.5"
+  resolved "https://registry.yarnpkg.com/multicast-dns/-/multicast-dns-7.2.5.tgz#77eb46057f4d7adbd16d9290fa7299f6fa64cced"
+  integrity sha512-2eznPJP8z2BFLX50tf0LuODrpINqP1RVIm/CObbTcBRITQgmC/TjcREF1NeTBzIcR5XO/ukWo+YHOjBbFwIupg==
+  dependencies:
+    dns-packet "^5.2.2"
+    thunky "^1.0.2"
+
+nanoid@^3.3.7:
+  version "3.3.7"
+  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.7.tgz#d0c301a691bc8d54efa0a2226ccf3fe2fd656bd8"
+  integrity sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==
+
+negotiator@0.6.3:
+  version "0.6.3"
+  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.3.tgz#58e323a72fedc0d6f9cd4d31fe49f51479590ccd"
+  integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==
+
+neo-async@^2.6.2:
+  version "2.6.2"
+  resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
+  integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
+
+no-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz#d361fd5c9800f558551a8369fc0dcd4662b6124d"
+  integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==
+  dependencies:
+    lower-case "^2.0.2"
+    tslib "^2.0.3"
+
+node-emoji@^1.10.0:
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/node-emoji/-/node-emoji-1.11.0.tgz#69a0150e6946e2f115e9d7ea4df7971e2628301c"
+  integrity sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==
+  dependencies:
+    lodash "^4.17.21"
+
+node-fetch@^2.6.12:
+  version "2.7.0"
+  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.7.0.tgz#d0f0fa6e3e2dc1d27efcd8ad99d550bda94d187d"
+  integrity sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==
+  dependencies:
+    whatwg-url "^5.0.0"
+
+node-forge@^1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/node-forge/-/node-forge-1.3.1.tgz#be8da2af243b2417d5f646a770663a92b7e9ded3"
+  integrity sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==
+
+node-releases@^2.0.14:
+  version "2.0.14"
+  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.14.tgz#2ffb053bceb8b2be8495ece1ab6ce600c4461b0b"
+  integrity sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==
+
+normalize-path@^3.0.0, normalize-path@~3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
+  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
+
+normalize-range@^0.1.2:
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/normalize-range/-/normalize-range-0.1.2.tgz#2d10c06bdfd312ea9777695a4d28439456b75942"
+  integrity sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==
+
+normalize-url@^4.1.0:
+  version "4.5.1"
+  resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-4.5.1.tgz#0dd90cf1288ee1d1313b87081c9a5932ee48518a"
+  integrity sha512-9UZCFRHQdNrfTpGg8+1INIg93B6zE0aXMVFkw1WFwvO4SlZywU6aLg5Of0Ap/PgcbSw4LNxvMWXMeugwMCX0AA==
+
+normalize-url@^6.0.1:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-6.1.0.tgz#40d0885b535deffe3f3147bec877d05fe4c5668a"
+  integrity sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==
+
+npm-run-path@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
+  integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
+  dependencies:
+    path-key "^3.0.0"
+
+nprogress@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/nprogress/-/nprogress-0.2.0.tgz#cb8f34c53213d895723fcbab907e9422adbcafb1"
+  integrity sha512-I19aIingLgR1fmhftnbWWO3dXc0hSxqHQHQb3H8m+K3TnEn/iSeTZZOyvKXWqQESMwuUVnatlCnZdLBZZt2VSA==
+
+nth-check@^2.0.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/nth-check/-/nth-check-2.1.1.tgz#c9eab428effce36cd6b92c924bdb000ef1f1ed1d"
+  integrity sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==
+  dependencies:
+    boolbase "^1.0.0"
+
+object-assign@^4.1.0, object-assign@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
+  integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==
+
+object-inspect@^1.13.1:
+  version "1.13.1"
+  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.13.1.tgz#b96c6109324ccfef6b12216a956ca4dc2ff94bc2"
+  integrity sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==
+
+object-keys@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
+  integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
+
+object.assign@^4.1.0:
+  version "4.1.5"
+  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.5.tgz#3a833f9ab7fdb80fc9e8d2300c803d216d8fdbb0"
+  integrity sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==
+  dependencies:
+    call-bind "^1.0.5"
+    define-properties "^1.2.1"
+    has-symbols "^1.0.3"
+    object-keys "^1.1.1"
+
+obuf@^1.0.0, obuf@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/obuf/-/obuf-1.1.2.tgz#09bea3343d41859ebd446292d11c9d4db619084e"
+  integrity sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==
+
+on-finished@2.4.1:
+  version "2.4.1"
+  resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.4.1.tgz#58c8c44116e54845ad57f14ab10b03533184ac3f"
+  integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==
+  dependencies:
+    ee-first "1.1.1"
+
+on-headers@~1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/on-headers/-/on-headers-1.0.2.tgz#772b0ae6aaa525c399e489adfad90c403eb3c28f"
+  integrity sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==
+
+once@^1.3.0, once@^1.3.1, once@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
+  integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
+  dependencies:
+    wrappy "1"
+
+onetime@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
+  integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
+  dependencies:
+    mimic-fn "^2.1.0"
+
+open@^8.0.9, open@^8.4.0:
+  version "8.4.2"
+  resolved "https://registry.yarnpkg.com/open/-/open-8.4.2.tgz#5b5ffe2a8f793dcd2aad73e550cb87b59cb084f9"
+  integrity sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==
+  dependencies:
+    define-lazy-prop "^2.0.0"
+    is-docker "^2.1.1"
+    is-wsl "^2.2.0"
+
+opener@^1.5.2:
+  version "1.5.2"
+  resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
+  integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
+
+p-cancelable@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-1.1.0.tgz#d078d15a3af409220c886f1d9a0ca2e441ab26cc"
+  integrity sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==
+
+p-limit@^2.0.0, p-limit@^2.2.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
+  integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
+  dependencies:
+    p-try "^2.0.0"
+
+p-limit@^3.0.2:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
+  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
+  dependencies:
+    yocto-queue "^0.1.0"
+
+p-locate@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
+  integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
+  dependencies:
+    p-limit "^2.0.0"
+
+p-locate@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
+  integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
+  dependencies:
+    p-limit "^2.2.0"
+
+p-locate@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834"
+  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
+  dependencies:
+    p-limit "^3.0.2"
+
+p-map@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/p-map/-/p-map-4.0.0.tgz#bb2f95a5eda2ec168ec9274e06a747c3e2904d2b"
+  integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==
+  dependencies:
+    aggregate-error "^3.0.0"
+
+p-retry@^4.5.0:
+  version "4.6.2"
+  resolved "https://registry.yarnpkg.com/p-retry/-/p-retry-4.6.2.tgz#9baae7184057edd4e17231cee04264106e092a16"
+  integrity sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==
+  dependencies:
+    "@types/retry" "0.12.0"
+    retry "^0.13.1"
+
+p-try@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
+  integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
+
+package-json@^6.3.0:
+  version "6.5.0"
+  resolved "https://registry.yarnpkg.com/package-json/-/package-json-6.5.0.tgz#6feedaca35e75725876d0b0e64974697fed145b0"
+  integrity sha512-k3bdm2n25tkyxcjSKzB5x8kfVxlMdgsbPr0GkZcwHsLpba6cBjqCt1KlcChKEvxHIcTB1FVMuwoijZ26xex5MQ==
+  dependencies:
+    got "^9.6.0"
+    registry-auth-token "^4.0.0"
+    registry-url "^5.0.0"
+    semver "^6.2.0"
+
+param-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/param-case/-/param-case-3.0.4.tgz#7d17fe4aa12bde34d4a77d91acfb6219caad01c5"
+  integrity sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==
+  dependencies:
+    dot-case "^3.0.4"
+    tslib "^2.0.3"
+
+parent-module@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
+  integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
+  dependencies:
+    callsites "^3.0.0"
+
+parse-entities@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/parse-entities/-/parse-entities-2.0.0.tgz#53c6eb5b9314a1f4ec99fa0fdf7ce01ecda0cbe8"
+  integrity sha512-kkywGpCcRYhqQIchaWqZ875wzpS/bMKhz5HnN3p7wveJTkTtyAB/AlnS0f8DFSqYW1T82t6yEAkEcB+A1I3MbQ==
+  dependencies:
+    character-entities "^1.0.0"
+    character-entities-legacy "^1.0.0"
+    character-reference-invalid "^1.0.0"
+    is-alphanumerical "^1.0.0"
+    is-decimal "^1.0.0"
+    is-hexadecimal "^1.0.0"
+
+parse-json@^5.0.0, parse-json@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
+  integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
+  dependencies:
+    "@babel/code-frame" "^7.0.0"
+    error-ex "^1.3.1"
+    json-parse-even-better-errors "^2.3.0"
+    lines-and-columns "^1.1.6"
+
+parse-numeric-range@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/parse-numeric-range/-/parse-numeric-range-1.3.0.tgz#7c63b61190d61e4d53a1197f0c83c47bb670ffa3"
+  integrity sha512-twN+njEipszzlMJd4ONUYgSfZPDxgHhT9Ahed5uTigpQn90FggW4SA/AIPq/6a149fTbE9qBEcSwE3FAEp6wQQ==
+
+parse5-htmlparser2-tree-adapter@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.0.0.tgz#23c2cc233bcf09bb7beba8b8a69d46b08c62c2f1"
+  integrity sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==
+  dependencies:
+    domhandler "^5.0.2"
+    parse5 "^7.0.0"
+
+parse5@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/parse5/-/parse5-6.0.1.tgz#e1a1c085c569b3dc08321184f19a39cc27f7c30b"
+  integrity sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==
+
+parse5@^7.0.0:
+  version "7.1.2"
+  resolved "https://registry.yarnpkg.com/parse5/-/parse5-7.1.2.tgz#0736bebbfd77793823240a23b7fc5e010b7f8e32"
+  integrity sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==
+  dependencies:
+    entities "^4.4.0"
+
+parseurl@~1.3.2, parseurl@~1.3.3:
+  version "1.3.3"
+  resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4"
+  integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==
+
+pascal-case@^3.1.2:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/pascal-case/-/pascal-case-3.1.2.tgz#b48e0ef2b98e205e7c1dae747d0b1508237660eb"
+  integrity sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==
+  dependencies:
+    no-case "^3.0.4"
+    tslib "^2.0.3"
+
+path-exists@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
+  integrity sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==
+
+path-exists@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
+  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
+
+path-is-absolute@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
+  integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
+
+path-is-inside@1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53"
+  integrity sha512-DUWJr3+ULp4zXmol/SZkFf3JGsS9/SIv+Y3Rt93/UjPpDpklB5f1er4O3POIbUuUJ3FXgqte2Q7SrU6zAqwk8w==
+
+path-key@^3.0.0, path-key@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
+  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
+
+path-parse@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
+  integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
+
+path-to-regexp@0.1.7:
+  version "0.1.7"
+  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-0.1.7.tgz#df604178005f522f15eb4490e7247a1bfaa67f8c"
+  integrity sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==
+
+path-to-regexp@2.2.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-2.2.1.tgz#90b617025a16381a879bc82a38d4e8bdeb2bcf45"
+  integrity sha512-gu9bD6Ta5bwGrrU8muHzVOBFFREpp2iRkVfhBJahwJ6p6Xw20SjT0MxLnwkjOibQmGSYhiUnf2FLe7k+jcFmGQ==
+
+path-to-regexp@^1.7.0:
+  version "1.8.0"
+  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-1.8.0.tgz#887b3ba9d84393e87a0a0b9f4cb756198b53548a"
+  integrity sha512-n43JRhlUKUAlibEJhPeir1ncUID16QnEjNpwzNdO3Lm4ywrBpBZ5oLD0I6br9evr1Y9JTqwRtAh7JLoOzAQdVA==
+  dependencies:
+    isarray "0.0.1"
+
+path-type@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
+  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
+
+picocolors@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c"
+  integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==
+
+picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.3, picomatch@^2.3.1:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
+  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
+
+pkg-dir@^4.1.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
+  integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
+  dependencies:
+    find-up "^4.0.0"
+
+pkg-up@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/pkg-up/-/pkg-up-3.1.0.tgz#100ec235cc150e4fd42519412596a28512a0def5"
+  integrity sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==
+  dependencies:
+    find-up "^3.0.0"
+
+postcss-calc@^8.2.3:
+  version "8.2.4"
+  resolved "https://registry.yarnpkg.com/postcss-calc/-/postcss-calc-8.2.4.tgz#77b9c29bfcbe8a07ff6693dc87050828889739a5"
+  integrity sha512-SmWMSJmB8MRnnULldx0lQIyhSNvuDl9HfrZkaqqE/WHAhToYsAvDq+yAsA/kIyINDszOp3Rh0GFoNuH5Ypsm3Q==
+  dependencies:
+    postcss-selector-parser "^6.0.9"
+    postcss-value-parser "^4.2.0"
+
+postcss-colormin@^5.3.1:
+  version "5.3.1"
+  resolved "https://registry.yarnpkg.com/postcss-colormin/-/postcss-colormin-5.3.1.tgz#86c27c26ed6ba00d96c79e08f3ffb418d1d1988f"
+  integrity sha512-UsWQG0AqTFQmpBegeLLc1+c3jIqBNB0zlDGRWR+dQ3pRKJL1oeMzyqmH3o2PIfn9MBdNrVPWhDbT769LxCTLJQ==
+  dependencies:
+    browserslist "^4.21.4"
+    caniuse-api "^3.0.0"
+    colord "^2.9.1"
+    postcss-value-parser "^4.2.0"
+
+postcss-convert-values@^5.1.3:
+  version "5.1.3"
+  resolved "https://registry.yarnpkg.com/postcss-convert-values/-/postcss-convert-values-5.1.3.tgz#04998bb9ba6b65aa31035d669a6af342c5f9d393"
+  integrity sha512-82pC1xkJZtcJEfiLw6UXnXVXScgtBrjlO5CBmuDQc+dlb88ZYheFsjTn40+zBVi3DkfF7iezO0nJUPLcJK3pvA==
+  dependencies:
+    browserslist "^4.21.4"
+    postcss-value-parser "^4.2.0"
+
+postcss-discard-comments@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/postcss-discard-comments/-/postcss-discard-comments-5.1.2.tgz#8df5e81d2925af2780075840c1526f0660e53696"
+  integrity sha512-+L8208OVbHVF2UQf1iDmRcbdjJkuBF6IS29yBDSiWUIzpYaAhtNl6JYnYm12FnkeCwQqF5LeklOu6rAqgfBZqQ==
+
+postcss-discard-duplicates@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-discard-duplicates/-/postcss-discard-duplicates-5.1.0.tgz#9eb4fe8456706a4eebd6d3b7b777d07bad03e848"
+  integrity sha512-zmX3IoSI2aoenxHV6C7plngHWWhUOV3sP1T8y2ifzxzbtnuhk1EdPwm0S1bIUNaJ2eNbWeGLEwzw8huPD67aQw==
+
+postcss-discard-empty@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-discard-empty/-/postcss-discard-empty-5.1.1.tgz#e57762343ff7f503fe53fca553d18d7f0c369c6c"
+  integrity sha512-zPz4WljiSuLWsI0ir4Mcnr4qQQ5e1Ukc3i7UfE2XcrwKK2LIPIqE5jxMRxO6GbI3cv//ztXDsXwEWT3BHOGh3A==
+
+postcss-discard-overridden@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-discard-overridden/-/postcss-discard-overridden-5.1.0.tgz#7e8c5b53325747e9d90131bb88635282fb4a276e"
+  integrity sha512-21nOL7RqWR1kasIVdKs8HNqQJhFxLsyRfAnUDm4Fe4t4mCWL9OJiHvlHPjcd8zc5Myu89b/7wZDnOSjFgeWRtw==
+
+postcss-discard-unused@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-discard-unused/-/postcss-discard-unused-5.1.0.tgz#8974e9b143d887677304e558c1166d3762501142"
+  integrity sha512-KwLWymI9hbwXmJa0dkrzpRbSJEh0vVUd7r8t0yOGPcfKzyJJxFM8kLyC5Ev9avji6nY95pOp1W6HqIrfT+0VGw==
+  dependencies:
+    postcss-selector-parser "^6.0.5"
+
+postcss-loader@^7.0.0:
+  version "7.3.4"
+  resolved "https://registry.yarnpkg.com/postcss-loader/-/postcss-loader-7.3.4.tgz#aed9b79ce4ed7e9e89e56199d25ad1ec8f606209"
+  integrity sha512-iW5WTTBSC5BfsBJ9daFMPVrLT36MrNiC6fqOZTTaHjBNX6Pfd5p+hSBqe/fEeNd7pc13QiAyGt7VdGMw4eRC4A==
+  dependencies:
+    cosmiconfig "^8.3.5"
+    jiti "^1.20.0"
+    semver "^7.5.4"
+
+postcss-merge-idents@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-merge-idents/-/postcss-merge-idents-5.1.1.tgz#7753817c2e0b75d0853b56f78a89771e15ca04a1"
+  integrity sha512-pCijL1TREiCoog5nQp7wUe+TUonA2tC2sQ54UGeMmryK3UFGIYKqDyjnqd6RcuI4znFn9hWSLNN8xKE/vWcUQw==
+  dependencies:
+    cssnano-utils "^3.1.0"
+    postcss-value-parser "^4.2.0"
+
+postcss-merge-longhand@^5.1.7:
+  version "5.1.7"
+  resolved "https://registry.yarnpkg.com/postcss-merge-longhand/-/postcss-merge-longhand-5.1.7.tgz#24a1bdf402d9ef0e70f568f39bdc0344d568fb16"
+  integrity sha512-YCI9gZB+PLNskrK0BB3/2OzPnGhPkBEwmwhfYk1ilBHYVAZB7/tkTHFBAnCrvBBOmeYyMYw3DMjT55SyxMBzjQ==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+    stylehacks "^5.1.1"
+
+postcss-merge-rules@^5.1.4:
+  version "5.1.4"
+  resolved "https://registry.yarnpkg.com/postcss-merge-rules/-/postcss-merge-rules-5.1.4.tgz#2f26fa5cacb75b1402e213789f6766ae5e40313c"
+  integrity sha512-0R2IuYpgU93y9lhVbO/OylTtKMVcHb67zjWIfCiKR9rWL3GUk1677LAqD/BcHizukdZEjT8Ru3oHRoAYoJy44g==
+  dependencies:
+    browserslist "^4.21.4"
+    caniuse-api "^3.0.0"
+    cssnano-utils "^3.1.0"
+    postcss-selector-parser "^6.0.5"
+
+postcss-minify-font-values@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-minify-font-values/-/postcss-minify-font-values-5.1.0.tgz#f1df0014a726083d260d3bd85d7385fb89d1f01b"
+  integrity sha512-el3mYTgx13ZAPPirSVsHqFzl+BBBDrXvbySvPGFnQcTI4iNslrPaFq4muTkLZmKlGk4gyFAYUBMH30+HurREyA==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-minify-gradients@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-minify-gradients/-/postcss-minify-gradients-5.1.1.tgz#f1fe1b4f498134a5068240c2f25d46fcd236ba2c"
+  integrity sha512-VGvXMTpCEo4qHTNSa9A0a3D+dxGFZCYwR6Jokk+/3oB6flu2/PnPXAh2x7x52EkY5xlIHLm+Le8tJxe/7TNhzw==
+  dependencies:
+    colord "^2.9.1"
+    cssnano-utils "^3.1.0"
+    postcss-value-parser "^4.2.0"
+
+postcss-minify-params@^5.1.4:
+  version "5.1.4"
+  resolved "https://registry.yarnpkg.com/postcss-minify-params/-/postcss-minify-params-5.1.4.tgz#c06a6c787128b3208b38c9364cfc40c8aa5d7352"
+  integrity sha512-+mePA3MgdmVmv6g+30rn57USjOGSAyuxUmkfiWpzalZ8aiBkdPYjXWtHuwJGm1v5Ojy0Z0LaSYhHaLJQB0P8Jw==
+  dependencies:
+    browserslist "^4.21.4"
+    cssnano-utils "^3.1.0"
+    postcss-value-parser "^4.2.0"
+
+postcss-minify-selectors@^5.2.1:
+  version "5.2.1"
+  resolved "https://registry.yarnpkg.com/postcss-minify-selectors/-/postcss-minify-selectors-5.2.1.tgz#d4e7e6b46147b8117ea9325a915a801d5fe656c6"
+  integrity sha512-nPJu7OjZJTsVUmPdm2TcaiohIwxP+v8ha9NehQ2ye9szv4orirRU3SDdtUmKH+10nzn0bAyOXZ0UEr7OpvLehg==
+  dependencies:
+    postcss-selector-parser "^6.0.5"
+
+postcss-modules-extract-imports@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.0.0.tgz#cda1f047c0ae80c97dbe28c3e76a43b88025741d"
+  integrity sha512-bdHleFnP3kZ4NYDhuGlVK+CMrQ/pqUm8bx/oGL93K6gVwiclvX5x0n76fYMKuIGKzlABOy13zsvqjb0f92TEXw==
+
+postcss-modules-local-by-default@^4.0.4:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.4.tgz#7cbed92abd312b94aaea85b68226d3dec39a14e6"
+  integrity sha512-L4QzMnOdVwRm1Qb8m4x8jsZzKAaPAgrUF1r/hjDR2Xj7R+8Zsf97jAlSQzWtKx5YNiNGN8QxmPFIc/sh+RQl+Q==
+  dependencies:
+    icss-utils "^5.0.0"
+    postcss-selector-parser "^6.0.2"
+    postcss-value-parser "^4.1.0"
+
+postcss-modules-scope@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-modules-scope/-/postcss-modules-scope-3.1.1.tgz#32cfab55e84887c079a19bbb215e721d683ef134"
+  integrity sha512-uZgqzdTleelWjzJY+Fhti6F3C9iF1JR/dODLs/JDefozYcKTBCdD8BIl6nNPbTbcLnGrk56hzwZC2DaGNvYjzA==
+  dependencies:
+    postcss-selector-parser "^6.0.4"
+
+postcss-modules-values@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz#d7c5e7e68c3bb3c9b27cbf48ca0bb3ffb4602c9c"
+  integrity sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==
+  dependencies:
+    icss-utils "^5.0.0"
+
+postcss-normalize-charset@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-charset/-/postcss-normalize-charset-5.1.0.tgz#9302de0b29094b52c259e9b2cf8dc0879879f0ed"
+  integrity sha512-mSgUJ+pd/ldRGVx26p2wz9dNZ7ji6Pn8VWBajMXFf8jk7vUoSrZ2lt/wZR7DtlZYKesmZI680qjr2CeFF2fbUg==
+
+postcss-normalize-display-values@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-display-values/-/postcss-normalize-display-values-5.1.0.tgz#72abbae58081960e9edd7200fcf21ab8325c3da8"
+  integrity sha512-WP4KIM4o2dazQXWmFaqMmcvsKmhdINFblgSeRgn8BJ6vxaMyaJkwAzpPpuvSIoG/rmX3M+IrRZEz2H0glrQNEA==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-normalize-positions@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-positions/-/postcss-normalize-positions-5.1.1.tgz#ef97279d894087b59325b45c47f1e863daefbb92"
+  integrity sha512-6UpCb0G4eofTCQLFVuI3EVNZzBNPiIKcA1AKVka+31fTVySphr3VUgAIULBhxZkKgwLImhzMR2Bw1ORK+37INg==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-normalize-repeat-style@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-5.1.1.tgz#e9eb96805204f4766df66fd09ed2e13545420fb2"
+  integrity sha512-mFpLspGWkQtBcWIRFLmewo8aC3ImN2i/J3v8YCFUwDnPu3Xz4rLohDO26lGjwNsQxB3YF0KKRwspGzE2JEuS0g==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-normalize-string@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-string/-/postcss-normalize-string-5.1.0.tgz#411961169e07308c82c1f8c55f3e8a337757e228"
+  integrity sha512-oYiIJOf4T9T1N4i+abeIc7Vgm/xPCGih4bZz5Nm0/ARVJ7K6xrDlLwvwqOydvyL3RHNf8qZk6vo3aatiw/go3w==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-normalize-timing-functions@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-5.1.0.tgz#d5614410f8f0b2388e9f240aa6011ba6f52dafbb"
+  integrity sha512-DOEkzJ4SAXv5xkHl0Wa9cZLF3WCBhF3o1SKVxKQAa+0pYKlueTpCgvkFAHfk+Y64ezX9+nITGrDZeVGgITJXjg==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-normalize-unicode@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.1.tgz#f67297fca3fea7f17e0d2caa40769afc487aa030"
+  integrity sha512-qnCL5jzkNUmKVhZoENp1mJiGNPcsJCs1aaRmURmeJGES23Z/ajaln+EPTD+rBeNkSryI+2WTdW+lwcVdOikrpA==
+  dependencies:
+    browserslist "^4.21.4"
+    postcss-value-parser "^4.2.0"
+
+postcss-normalize-url@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-url/-/postcss-normalize-url-5.1.0.tgz#ed9d88ca82e21abef99f743457d3729a042adcdc"
+  integrity sha512-5upGeDO+PVthOxSmds43ZeMeZfKH+/DKgGRD7TElkkyS46JXAUhMzIKiCa7BabPeIy3AQcTkXwVVN7DbqsiCew==
+  dependencies:
+    normalize-url "^6.0.1"
+    postcss-value-parser "^4.2.0"
+
+postcss-normalize-whitespace@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-normalize-whitespace/-/postcss-normalize-whitespace-5.1.1.tgz#08a1a0d1ffa17a7cc6efe1e6c9da969cc4493cfa"
+  integrity sha512-83ZJ4t3NUDETIHTa3uEg6asWjSBYL5EdkVB0sDncx9ERzOKBVJIUeDO9RyA9Zwtig8El1d79HBp0JEi8wvGQnA==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-ordered-values@^5.1.3:
+  version "5.1.3"
+  resolved "https://registry.yarnpkg.com/postcss-ordered-values/-/postcss-ordered-values-5.1.3.tgz#b6fd2bd10f937b23d86bc829c69e7732ce76ea38"
+  integrity sha512-9UO79VUhPwEkzbb3RNpqqghc6lcYej1aveQteWY+4POIwlqkYE21HKWaLDF6lWNuqCobEAyTovVhtI32Rbv2RQ==
+  dependencies:
+    cssnano-utils "^3.1.0"
+    postcss-value-parser "^4.2.0"
+
+postcss-reduce-idents@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/postcss-reduce-idents/-/postcss-reduce-idents-5.2.0.tgz#c89c11336c432ac4b28792f24778859a67dfba95"
+  integrity sha512-BTrLjICoSB6gxbc58D5mdBK8OhXRDqud/zodYfdSi52qvDHdMwk+9kB9xsM8yJThH/sZU5A6QVSmMmaN001gIg==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-reduce-initial@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/postcss-reduce-initial/-/postcss-reduce-initial-5.1.2.tgz#798cd77b3e033eae7105c18c9d371d989e1382d6"
+  integrity sha512-dE/y2XRaqAi6OvjzD22pjTUQ8eOfc6m/natGHgKFBK9DxFmIm69YmaRVQrGgFlEfc1HePIurY0TmDeROK05rIg==
+  dependencies:
+    browserslist "^4.21.4"
+    caniuse-api "^3.0.0"
+
+postcss-reduce-transforms@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-reduce-transforms/-/postcss-reduce-transforms-5.1.0.tgz#333b70e7758b802f3dd0ddfe98bb1ccfef96b6e9"
+  integrity sha512-2fbdbmgir5AvpW9RLtdONx1QoYG2/EtqpNQbFASDlixBbAYuTcJ0dECwlqNqH7VbaUnEnh8SrxOe2sRIn24XyQ==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+
+postcss-selector-parser@^6.0.2, postcss-selector-parser@^6.0.4, postcss-selector-parser@^6.0.5, postcss-selector-parser@^6.0.9:
+  version "6.0.15"
+  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.15.tgz#11cc2b21eebc0b99ea374ffb9887174855a01535"
+  integrity sha512-rEYkQOMUCEMhsKbK66tbEU9QVIxbhN18YiniAwA7XQYTVBqrBy+P2p5JcdqsHgKM2zWylp8d7J6eszocfds5Sw==
+  dependencies:
+    cssesc "^3.0.0"
+    util-deprecate "^1.0.2"
+
+postcss-sort-media-queries@^4.2.1:
+  version "4.4.1"
+  resolved "https://registry.yarnpkg.com/postcss-sort-media-queries/-/postcss-sort-media-queries-4.4.1.tgz#04a5a78db3921eb78f28a1a781a2e68e65258128"
+  integrity sha512-QDESFzDDGKgpiIh4GYXsSy6sek2yAwQx1JASl5AxBtU1Lq2JfKBljIPNdil989NcSKRQX1ToiaKphImtBuhXWw==
+  dependencies:
+    sort-css-media-queries "2.1.0"
+
+postcss-svgo@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-svgo/-/postcss-svgo-5.1.0.tgz#0a317400ced789f233a28826e77523f15857d80d"
+  integrity sha512-D75KsH1zm5ZrHyxPakAxJWtkyXew5qwS70v56exwvw542d9CRtTo78K0WeFxZB4G7JXKKMbEZtZayTGdIky/eA==
+  dependencies:
+    postcss-value-parser "^4.2.0"
+    svgo "^2.7.0"
+
+postcss-unique-selectors@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/postcss-unique-selectors/-/postcss-unique-selectors-5.1.1.tgz#a9f273d1eacd09e9aa6088f4b0507b18b1b541b6"
+  integrity sha512-5JiODlELrz8L2HwxfPnhOWZYWDxVHWL83ufOv84NrcgipI7TaeRsatAhK4Tr2/ZiYldpK/wBvw5BD3qfaK96GA==
+  dependencies:
+    postcss-selector-parser "^6.0.5"
+
+postcss-value-parser@^4.1.0, postcss-value-parser@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz#723c09920836ba6d3e5af019f92bc0971c02e514"
+  integrity sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==
+
+postcss-zindex@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-zindex/-/postcss-zindex-5.1.0.tgz#4a5c7e5ff1050bd4c01d95b1847dfdcc58a496ff"
+  integrity sha512-fgFMf0OtVSBR1va1JNHYgMxYk73yhn/qb4uQDq1DLGYolz8gHCyr/sesEuGUaYs58E3ZJRcpoGuPVoB7Meiq9A==
+
+postcss@^8.3.11, postcss@^8.4.14, postcss@^8.4.17, postcss@^8.4.33:
+  version "8.4.35"
+  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.35.tgz#60997775689ce09011edf083a549cea44aabe2f7"
+  integrity sha512-u5U8qYpBCpN13BsiEB0CbR1Hhh4Gc0zLFuedrHJKMctHCHAGrMdG0PRM/KErzAL3CU6/eckEtmHNB3x6e3c0vA==
+  dependencies:
+    nanoid "^3.3.7"
+    picocolors "^1.0.0"
+    source-map-js "^1.0.2"
+
+prepend-http@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897"
+  integrity sha512-ravE6m9Atw9Z/jjttRUZ+clIXogdghyZAuWJ3qEzjT+jI/dL1ifAqhZeC5VHzQp1MSt1+jxKkFNemj/iO7tVUA==
+
+pretty-error@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/pretty-error/-/pretty-error-4.0.0.tgz#90a703f46dd7234adb46d0f84823e9d1cb8f10d6"
+  integrity sha512-AoJ5YMAcXKYxKhuJGdcvse+Voc6v1RgnsR3nWcYU7q4t6z0Q6T86sv5Zq8VIRbOWWFpvdGE83LtdSMNd+6Y0xw==
+  dependencies:
+    lodash "^4.17.20"
+    renderkid "^3.0.0"
+
+pretty-time@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/pretty-time/-/pretty-time-1.1.0.tgz#ffb7429afabb8535c346a34e41873adf3d74dd0e"
+  integrity sha512-28iF6xPQrP8Oa6uxE6a1biz+lWeTOAPKggvjB8HAs6nVMKZwf5bG++632Dx614hIWgUPkgivRfG+a8uAXGTIbA==
+
+prism-react-renderer@^1.3.5:
+  version "1.3.5"
+  resolved "https://registry.yarnpkg.com/prism-react-renderer/-/prism-react-renderer-1.3.5.tgz#786bb69aa6f73c32ba1ee813fbe17a0115435085"
+  integrity sha512-IJ+MSwBWKG+SM3b2SUfdrhC+gu01QkV2KmRQgREThBfSQRoufqRfxfHUxpG1WcaFjP+kojcFyO9Qqtpgt3qLCg==
+
+prismjs@^1.28.0:
+  version "1.29.0"
+  resolved "https://registry.yarnpkg.com/prismjs/-/prismjs-1.29.0.tgz#f113555a8fa9b57c35e637bba27509dcf802dd12"
+  integrity sha512-Kx/1w86q/epKcmte75LNrEoT+lX8pBpavuAbvJWRXar7Hz8jrtF+e3vY751p0R8H9HdArwaCTNDDzHg/ScJK1Q==
+
+process-nextick-args@~2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
+  integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
+
+promise@^7.1.1:
+  version "7.3.1"
+  resolved "https://registry.yarnpkg.com/promise/-/promise-7.3.1.tgz#064b72602b18f90f29192b8b1bc418ffd1ebd3bf"
+  integrity sha512-nolQXZ/4L+bP/UGlkfaIujX9BKxGwmQ9OT4mOt5yvy8iK1h3wqTEJCijzGANTCCl9nWjY41juyAn2K3Q1hLLTg==
+  dependencies:
+    asap "~2.0.3"
+
+prompts@^2.4.2:
+  version "2.4.2"
+  resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.2.tgz#7b57e73b3a48029ad10ebd44f74b01722a4cb069"
+  integrity sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==
+  dependencies:
+    kleur "^3.0.3"
+    sisteransi "^1.0.5"
+
+prop-types@^15.6.2, prop-types@^15.7.2:
+  version "15.8.1"
+  resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.8.1.tgz#67d87bf1a694f48435cf332c24af10214a3140b5"
+  integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
+  dependencies:
+    loose-envify "^1.4.0"
+    object-assign "^4.1.1"
+    react-is "^16.13.1"
+
+property-information@^5.0.0, property-information@^5.3.0:
+  version "5.6.0"
+  resolved "https://registry.yarnpkg.com/property-information/-/property-information-5.6.0.tgz#61675545fb23002f245c6540ec46077d4da3ed69"
+  integrity sha512-YUHSPk+A30YPv+0Qf8i9Mbfe/C0hdPXk1s1jPVToV8pk8BQtpw10ct89Eo7OWkutrwqvT0eicAxlOg3dOAu8JA==
+  dependencies:
+    xtend "^4.0.0"
+
+proxy-addr@~2.0.7:
+  version "2.0.7"
+  resolved "https://registry.yarnpkg.com/proxy-addr/-/proxy-addr-2.0.7.tgz#f19fe69ceab311eeb94b42e70e8c2070f9ba1025"
+  integrity sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==
+  dependencies:
+    forwarded "0.2.0"
+    ipaddr.js "1.9.1"
+
+proxy-from-env@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2"
+  integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==
+
+pump@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
+  integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==
+  dependencies:
+    end-of-stream "^1.1.0"
+    once "^1.3.1"
+
+punycode@^1.3.2:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
+  integrity sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==
+
+punycode@^2.1.0:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5"
+  integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==
+
+pupa@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/pupa/-/pupa-2.1.1.tgz#f5e8fd4afc2c5d97828faa523549ed8744a20d62"
+  integrity sha512-l1jNAspIBSFqbT+y+5FosojNpVpF94nlI+wDUpqP9enwOTfHx9f0gh5nB96vl+6yTpsJsypeNrwfzPrKuHB41A==
+  dependencies:
+    escape-goat "^2.0.0"
+
+pure-color@^1.2.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/pure-color/-/pure-color-1.3.0.tgz#1fe064fb0ac851f0de61320a8bf796836422f33e"
+  integrity sha512-QFADYnsVoBMw1srW7OVKEYjG+MbIa49s54w1MA1EDY6r2r/sTcKKYqRX1f4GYvnXP7eN/Pe9HFcX+hwzmrXRHA==
+
+qs@6.11.0:
+  version "6.11.0"
+  resolved "https://registry.yarnpkg.com/qs/-/qs-6.11.0.tgz#fd0d963446f7a65e1367e01abd85429453f0c37a"
+  integrity sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==
+  dependencies:
+    side-channel "^1.0.4"
+
+queue-microtask@^1.2.2:
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
+  integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
+
+queue@6.0.2:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/queue/-/queue-6.0.2.tgz#b91525283e2315c7553d2efa18d83e76432fed65"
+  integrity sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==
+  dependencies:
+    inherits "~2.0.3"
+
+randombytes@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
+  integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
+  dependencies:
+    safe-buffer "^5.1.0"
+
+range-parser@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.0.tgz#f49be6b487894ddc40dcc94a322f611092e00d5e"
+  integrity sha512-kA5WQoNVo4t9lNx2kQNFCxKeBl5IbbSNBl1M/tLkw9WCn+hxNBAW5Qh8gdhs63CJnhjJ2zQWFoqPJP2sK1AV5A==
+
+range-parser@^1.2.1, range-parser@~1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031"
+  integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
+
+raw-body@2.5.1:
+  version "2.5.1"
+  resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.5.1.tgz#fe1b1628b181b700215e5fd42389f98b71392857"
+  integrity sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==
+  dependencies:
+    bytes "3.1.2"
+    http-errors "2.0.0"
+    iconv-lite "0.4.24"
+    unpipe "1.0.0"
+
+rc@1.2.8, rc@^1.2.8:
+  version "1.2.8"
+  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed"
+  integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==
+  dependencies:
+    deep-extend "^0.6.0"
+    ini "~1.3.0"
+    minimist "^1.2.0"
+    strip-json-comments "~2.0.1"
+
+react-base16-styling@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/react-base16-styling/-/react-base16-styling-0.6.0.tgz#ef2156d66cf4139695c8a167886cb69ea660792c"
+  integrity sha512-yvh/7CArceR/jNATXOKDlvTnPKPmGZz7zsenQ3jUwLzHkNUR0CvY3yGYJbWJ/nnxsL8Sgmt5cO3/SILVuPO6TQ==
+  dependencies:
+    base16 "^1.0.0"
+    lodash.curry "^4.0.1"
+    lodash.flow "^3.3.0"
+    pure-color "^1.2.0"
+
+react-dev-utils@^12.0.1:
+  version "12.0.1"
+  resolved "https://registry.yarnpkg.com/react-dev-utils/-/react-dev-utils-12.0.1.tgz#ba92edb4a1f379bd46ccd6bcd4e7bc398df33e73"
+  integrity sha512-84Ivxmr17KjUupyqzFode6xKhjwuEJDROWKJy/BthkL7Wn6NJ8h4WE6k/exAv6ImS+0oZLRRW5j/aINMHyeGeQ==
+  dependencies:
+    "@babel/code-frame" "^7.16.0"
+    address "^1.1.2"
+    browserslist "^4.18.1"
+    chalk "^4.1.2"
+    cross-spawn "^7.0.3"
+    detect-port-alt "^1.1.6"
+    escape-string-regexp "^4.0.0"
+    filesize "^8.0.6"
+    find-up "^5.0.0"
+    fork-ts-checker-webpack-plugin "^6.5.0"
+    global-modules "^2.0.0"
+    globby "^11.0.4"
+    gzip-size "^6.0.0"
+    immer "^9.0.7"
+    is-root "^2.1.0"
+    loader-utils "^3.2.0"
+    open "^8.4.0"
+    pkg-up "^3.1.0"
+    prompts "^2.4.2"
+    react-error-overlay "^6.0.11"
+    recursive-readdir "^2.2.2"
+    shell-quote "^1.7.3"
+    strip-ansi "^6.0.1"
+    text-table "^0.2.0"
+
+react-dom@^17.0.2:
+  version "17.0.2"
+  resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-17.0.2.tgz#ecffb6845e3ad8dbfcdc498f0d0a939736502c23"
+  integrity sha512-s4h96KtLDUQlsENhMn1ar8t2bEa+q/YAtj8pPPdIjPDGBDIVNsrD9aXNWqspUe6AzKCIG0C1HZZLqLV7qpOBGA==
+  dependencies:
+    loose-envify "^1.1.0"
+    object-assign "^4.1.1"
+    scheduler "^0.20.2"
+
+react-error-overlay@^6.0.11:
+  version "6.0.11"
+  resolved "https://registry.yarnpkg.com/react-error-overlay/-/react-error-overlay-6.0.11.tgz#92835de5841c5cf08ba00ddd2d677b6d17ff9adb"
+  integrity sha512-/6UZ2qgEyH2aqzYZgQPxEnz33NJ2gNsnHA2o5+o4wW9bLM/JYQitNP9xPhsXwC08hMMovfGe/8retsdDsczPRg==
+
+react-fast-compare@^3.2.0, react-fast-compare@^3.2.2:
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/react-fast-compare/-/react-fast-compare-3.2.2.tgz#929a97a532304ce9fee4bcae44234f1ce2c21d49"
+  integrity sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ==
+
+react-helmet-async@*:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/react-helmet-async/-/react-helmet-async-2.0.4.tgz#50a4377778f380ed1d0136303916b38eff1bf153"
+  integrity sha512-yxjQMWposw+akRfvpl5+8xejl4JtUlHnEBcji6u8/e6oc7ozT+P9PNTWMhCbz2y9tc5zPegw2BvKjQA+NwdEjQ==
+  dependencies:
+    invariant "^2.2.4"
+    react-fast-compare "^3.2.2"
+    shallowequal "^1.1.0"
+
+react-helmet-async@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/react-helmet-async/-/react-helmet-async-1.3.0.tgz#7bd5bf8c5c69ea9f02f6083f14ce33ef545c222e"
+  integrity sha512-9jZ57/dAn9t3q6hneQS0wukqC2ENOBgMNVEhb/ZG9ZSxUetzVIw4iAmEU38IaVg3QGYauQPhSeUTuIUtFglWpg==
+  dependencies:
+    "@babel/runtime" "^7.12.5"
+    invariant "^2.2.4"
+    prop-types "^15.7.2"
+    react-fast-compare "^3.2.0"
+    shallowequal "^1.1.0"
+
+react-is@^16.13.1, react-is@^16.6.0, react-is@^16.7.0:
+  version "16.13.1"
+  resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
+  integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
+
+react-json-view@^1.21.3:
+  version "1.21.3"
+  resolved "https://registry.yarnpkg.com/react-json-view/-/react-json-view-1.21.3.tgz#f184209ee8f1bf374fb0c41b0813cff54549c475"
+  integrity sha512-13p8IREj9/x/Ye4WI/JpjhoIwuzEgUAtgJZNBJckfzJt1qyh24BdTm6UQNGnyTq9dapQdrqvquZTo3dz1X6Cjw==
+  dependencies:
+    flux "^4.0.1"
+    react-base16-styling "^0.6.0"
+    react-lifecycles-compat "^3.0.4"
+    react-textarea-autosize "^8.3.2"
+
+react-lifecycles-compat@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/react-lifecycles-compat/-/react-lifecycles-compat-3.0.4.tgz#4f1a273afdfc8f3488a8c516bfda78f872352362"
+  integrity sha512-fBASbA6LnOU9dOU2eW7aQ8xmYBSXUIWr+UmF9b1efZBazGNO+rcXT/icdKnYm2pTwcRylVUYwW7H1PHfLekVzA==
+
+react-loadable-ssr-addon-v5-slorber@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/react-loadable-ssr-addon-v5-slorber/-/react-loadable-ssr-addon-v5-slorber-1.0.1.tgz#2cdc91e8a744ffdf9e3556caabeb6e4278689883"
+  integrity sha512-lq3Lyw1lGku8zUEJPDxsNm1AfYHBrO9Y1+olAYwpUJ2IGFBskM0DMKok97A6LWUpHm+o7IvQBOWu9MLenp9Z+A==
+  dependencies:
+    "@babel/runtime" "^7.10.3"
+
+react-router-config@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/react-router-config/-/react-router-config-5.1.1.tgz#0f4263d1a80c6b2dc7b9c1902c9526478194a988"
+  integrity sha512-DuanZjaD8mQp1ppHjgnnUnyOlqYXZVjnov/JzFhjLEwd3Z4dYjMSnqrEzzGThH47vpCOqPPwJM2FtthLeJ8Pbg==
+  dependencies:
+    "@babel/runtime" "^7.1.2"
+
+react-router-dom@^5.3.3:
+  version "5.3.4"
+  resolved "https://registry.yarnpkg.com/react-router-dom/-/react-router-dom-5.3.4.tgz#2ed62ffd88cae6db134445f4a0c0ae8b91d2e5e6"
+  integrity sha512-m4EqFMHv/Ih4kpcBCONHbkT68KoAeHN4p3lAGoNryfHi0dMy0kCzEZakiKRsvg5wHZ/JLrLW8o8KomWiz/qbYQ==
+  dependencies:
+    "@babel/runtime" "^7.12.13"
+    history "^4.9.0"
+    loose-envify "^1.3.1"
+    prop-types "^15.6.2"
+    react-router "5.3.4"
+    tiny-invariant "^1.0.2"
+    tiny-warning "^1.0.0"
+
+react-router@5.3.4, react-router@^5.3.3:
+  version "5.3.4"
+  resolved "https://registry.yarnpkg.com/react-router/-/react-router-5.3.4.tgz#8ca252d70fcc37841e31473c7a151cf777887bb5"
+  integrity sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==
+  dependencies:
+    "@babel/runtime" "^7.12.13"
+    history "^4.9.0"
+    hoist-non-react-statics "^3.1.0"
+    loose-envify "^1.3.1"
+    path-to-regexp "^1.7.0"
+    prop-types "^15.6.2"
+    react-is "^16.6.0"
+    tiny-invariant "^1.0.2"
+    tiny-warning "^1.0.0"
+
+react-textarea-autosize@^8.3.2:
+  version "8.5.3"
+  resolved "https://registry.yarnpkg.com/react-textarea-autosize/-/react-textarea-autosize-8.5.3.tgz#d1e9fe760178413891484847d3378706052dd409"
+  integrity sha512-XT1024o2pqCuZSuBt9FwHlaDeNtVrtCXu0Rnz88t1jUGheCLa3PhjE1GH8Ctm2axEtvdCl5SUHYschyQ0L5QHQ==
+  dependencies:
+    "@babel/runtime" "^7.20.13"
+    use-composed-ref "^1.3.0"
+    use-latest "^1.2.1"
+
+react@^17.0.2:
+  version "17.0.2"
+  resolved "https://registry.yarnpkg.com/react/-/react-17.0.2.tgz#d0b5cc516d29eb3eee383f75b62864cfb6800037"
+  integrity sha512-gnhPt75i/dq/z3/6q/0asP78D0u592D5L1pd7M8P+dck6Fu/jJeL6iVVK23fptSUZj8Vjf++7wXA8UNclGQcbA==
+  dependencies:
+    loose-envify "^1.1.0"
+    object-assign "^4.1.1"
+
+readable-stream@^2.0.1:
+  version "2.3.8"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.8.tgz#91125e8042bba1b9887f49345f6277027ce8be9b"
+  integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==
+  dependencies:
+    core-util-is "~1.0.0"
+    inherits "~2.0.3"
+    isarray "~1.0.0"
+    process-nextick-args "~2.0.0"
+    safe-buffer "~5.1.1"
+    string_decoder "~1.1.1"
+    util-deprecate "~1.0.1"
+
+readable-stream@^3.0.6:
+  version "3.6.2"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.2.tgz#56a9b36ea965c00c5a93ef31eb111a0f11056967"
+  integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==
+  dependencies:
+    inherits "^2.0.3"
+    string_decoder "^1.1.1"
+    util-deprecate "^1.0.1"
+
+readdirp@~3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7"
+  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
+  dependencies:
+    picomatch "^2.2.1"
+
+reading-time@^1.5.0:
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/reading-time/-/reading-time-1.5.0.tgz#d2a7f1b6057cb2e169beaf87113cc3411b5bc5bb"
+  integrity sha512-onYyVhBNr4CmAxFsKS7bz+uTLRakypIe4R+5A824vBSkQy/hB3fZepoVEf8OVAxzLvK+H/jm9TzpI3ETSm64Kg==
+
+rechoir@^0.6.2:
+  version "0.6.2"
+  resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384"
+  integrity sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==
+  dependencies:
+    resolve "^1.1.6"
+
+recursive-readdir@^2.2.2:
+  version "2.2.3"
+  resolved "https://registry.yarnpkg.com/recursive-readdir/-/recursive-readdir-2.2.3.tgz#e726f328c0d69153bcabd5c322d3195252379372"
+  integrity sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==
+  dependencies:
+    minimatch "^3.0.5"
+
+regenerate-unicode-properties@^10.1.0:
+  version "10.1.1"
+  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-10.1.1.tgz#6b0e05489d9076b04c436f318d9b067bba459480"
+  integrity sha512-X007RyZLsCJVVrjgEFVpLUTZwyOZk3oiL75ZcuYjlIWd6rNJtOjkBwQc5AsRrpbKVkxN6sklw/k/9m2jJYOf8Q==
+  dependencies:
+    regenerate "^1.4.2"
+
+regenerate@^1.4.2:
+  version "1.4.2"
+  resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz#b9346d8827e8f5a32f7ba29637d398b69014848a"
+  integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
+
+regenerator-runtime@^0.14.0:
+  version "0.14.1"
+  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz#356ade10263f685dda125100cd862c1db895327f"
+  integrity sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==
+
+regenerator-transform@^0.15.2:
+  version "0.15.2"
+  resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.15.2.tgz#5bbae58b522098ebdf09bca2f83838929001c7a4"
+  integrity sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==
+  dependencies:
+    "@babel/runtime" "^7.8.4"
+
+regexpu-core@^5.3.1:
+  version "5.3.2"
+  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-5.3.2.tgz#11a2b06884f3527aec3e93dbbf4a3b958a95546b"
+  integrity sha512-RAM5FlZz+Lhmo7db9L298p2vHP5ZywrVXmVXpmAD9GuL5MPH6t9ROw1iA/wfHkQ76Qe7AaPF0nGuim96/IrQMQ==
+  dependencies:
+    "@babel/regjsgen" "^0.8.0"
+    regenerate "^1.4.2"
+    regenerate-unicode-properties "^10.1.0"
+    regjsparser "^0.9.1"
+    unicode-match-property-ecmascript "^2.0.0"
+    unicode-match-property-value-ecmascript "^2.1.0"
+
+registry-auth-token@^4.0.0:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/registry-auth-token/-/registry-auth-token-4.2.2.tgz#f02d49c3668884612ca031419491a13539e21fac"
+  integrity sha512-PC5ZysNb42zpFME6D/XlIgtNGdTl8bBOCw90xQLVMpzuuubJKYDWFAEuUNc+Cn8Z8724tg2SDhDRrkVEsqfDMg==
+  dependencies:
+    rc "1.2.8"
+
+registry-url@^5.0.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/registry-url/-/registry-url-5.1.0.tgz#e98334b50d5434b81136b44ec638d9c2009c5009"
+  integrity sha512-8acYXXTI0AkQv6RAOjE3vOaIXZkT9wo4LOFbBKYQEEnnMNBpKqdUrI6S4NT0KPIo/WVvJ5tE/X5LF/TQUf0ekw==
+  dependencies:
+    rc "^1.2.8"
+
+regjsparser@^0.9.1:
+  version "0.9.1"
+  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.9.1.tgz#272d05aa10c7c1f67095b1ff0addae8442fc5709"
+  integrity sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==
+  dependencies:
+    jsesc "~0.5.0"
+
+relateurl@^0.2.7:
+  version "0.2.7"
+  resolved "https://registry.yarnpkg.com/relateurl/-/relateurl-0.2.7.tgz#54dbf377e51440aca90a4cd274600d3ff2d888a9"
+  integrity sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog==
+
+remark-emoji@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/remark-emoji/-/remark-emoji-2.2.0.tgz#1c702090a1525da5b80e15a8f963ef2c8236cac7"
+  integrity sha512-P3cj9s5ggsUvWw5fS2uzCHJMGuXYRb0NnZqYlNecewXt8QBU9n5vW3DUUKOhepS8F9CwdMx9B8a3i7pqFWAI5w==
+  dependencies:
+    emoticon "^3.2.0"
+    node-emoji "^1.10.0"
+    unist-util-visit "^2.0.3"
+
+remark-footnotes@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/remark-footnotes/-/remark-footnotes-2.0.0.tgz#9001c4c2ffebba55695d2dd80ffb8b82f7e6303f"
+  integrity sha512-3Clt8ZMH75Ayjp9q4CorNeyjwIxHFcTkaektplKGl2A1jNGEUey8cKL0ZC5vJwfcD5GFGsNLImLG/NGzWIzoMQ==
+
+remark-mdx@1.6.22:
+  version "1.6.22"
+  resolved "https://registry.yarnpkg.com/remark-mdx/-/remark-mdx-1.6.22.tgz#06a8dab07dcfdd57f3373af7f86bd0e992108bbd"
+  integrity sha512-phMHBJgeV76uyFkH4rvzCftLfKCr2RZuF+/gmVcaKrpsihyzmhXjA0BEMDaPTXG5y8qZOKPVo83NAOX01LPnOQ==
+  dependencies:
+    "@babel/core" "7.12.9"
+    "@babel/helper-plugin-utils" "7.10.4"
+    "@babel/plugin-proposal-object-rest-spread" "7.12.1"
+    "@babel/plugin-syntax-jsx" "7.12.1"
+    "@mdx-js/util" "1.6.22"
+    is-alphabetical "1.0.4"
+    remark-parse "8.0.3"
+    unified "9.2.0"
+
+remark-parse@8.0.3:
+  version "8.0.3"
+  resolved "https://registry.yarnpkg.com/remark-parse/-/remark-parse-8.0.3.tgz#9c62aa3b35b79a486454c690472906075f40c7e1"
+  integrity sha512-E1K9+QLGgggHxCQtLt++uXltxEprmWzNfg+MxpfHsZlrddKzZ/hZyWHDbK3/Ap8HJQqYJRXP+jHczdL6q6i85Q==
+  dependencies:
+    ccount "^1.0.0"
+    collapse-white-space "^1.0.2"
+    is-alphabetical "^1.0.0"
+    is-decimal "^1.0.0"
+    is-whitespace-character "^1.0.0"
+    is-word-character "^1.0.0"
+    markdown-escapes "^1.0.0"
+    parse-entities "^2.0.0"
+    repeat-string "^1.5.4"
+    state-toggle "^1.0.0"
+    trim "0.0.1"
+    trim-trailing-lines "^1.0.0"
+    unherit "^1.0.4"
+    unist-util-remove-position "^2.0.0"
+    vfile-location "^3.0.0"
+    xtend "^4.0.1"
+
+remark-squeeze-paragraphs@4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/remark-squeeze-paragraphs/-/remark-squeeze-paragraphs-4.0.0.tgz#76eb0e085295131c84748c8e43810159c5653ead"
+  integrity sha512-8qRqmL9F4nuLPIgl92XUuxI3pFxize+F1H0e/W3llTk0UsjJaj01+RrirkMw7P21RKe4X6goQhYRSvNWX+70Rw==
+  dependencies:
+    mdast-squeeze-paragraphs "^4.0.0"
+
+renderkid@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/renderkid/-/renderkid-3.0.0.tgz#5fd823e4d6951d37358ecc9a58b1f06836b6268a"
+  integrity sha512-q/7VIQA8lmM1hF+jn+sFSPWGlMkSAeNYcPLmDQx2zzuiDfaLrOmumR8iaUKlenFgh0XRPIUeSPlH3A+AW3Z5pg==
+  dependencies:
+    css-select "^4.1.3"
+    dom-converter "^0.2.0"
+    htmlparser2 "^6.1.0"
+    lodash "^4.17.21"
+    strip-ansi "^6.0.1"
+
+repeat-string@^1.5.4:
+  version "1.6.1"
+  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
+  integrity sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==
+
+require-from-string@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
+  integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
+
+"require-like@>= 0.1.1":
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/require-like/-/require-like-0.1.2.tgz#ad6f30c13becd797010c468afa775c0c0a6b47fa"
+  integrity sha512-oyrU88skkMtDdauHDuKVrgR+zuItqr6/c//FXzvmxRGMexSDc6hNvJInGW3LL46n+8b50RykrvwSUIIQH2LQ5A==
+
+requires-port@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
+  integrity sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==
+
+resolve-from@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
+  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
+
+resolve-pathname@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-pathname/-/resolve-pathname-3.0.0.tgz#99d02224d3cf263689becbb393bc560313025dcd"
+  integrity sha512-C7rARubxI8bXFNB/hqcp/4iUeIXJhJZvFPFPiSPRnhU5UPxzMFIl+2E6yY6c4k9giDJAhtV+enfA+G89N6Csng==
+
+resolve@^1.1.6, resolve@^1.14.2, resolve@^1.3.2:
+  version "1.22.8"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.8.tgz#b6c87a9f2aa06dfab52e3d70ac8cde321fa5a48d"
+  integrity sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==
+  dependencies:
+    is-core-module "^2.13.0"
+    path-parse "^1.0.7"
+    supports-preserve-symlinks-flag "^1.0.0"
+
+responselike@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/responselike/-/responselike-1.0.2.tgz#918720ef3b631c5642be068f15ade5a46f4ba1e7"
+  integrity sha512-/Fpe5guzJk1gPqdJLJR5u7eG/gNY4nImjbRDaVWVMRhne55TCmj2i9Q+54PBRfatRC8v/rIiv9BN0pMd9OV5EQ==
+  dependencies:
+    lowercase-keys "^1.0.0"
+
+retry@^0.13.1:
+  version "0.13.1"
+  resolved "https://registry.yarnpkg.com/retry/-/retry-0.13.1.tgz#185b1587acf67919d63b357349e03537b2484658"
+  integrity sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==
+
+reusify@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
+  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
+
+rimraf@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
+  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
+  dependencies:
+    glob "^7.1.3"
+
+rtl-detect@^1.0.4:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/rtl-detect/-/rtl-detect-1.1.2.tgz#ca7f0330af5c6bb626c15675c642ba85ad6273c6"
+  integrity sha512-PGMBq03+TTG/p/cRB7HCLKJ1MgDIi07+QU1faSjiYRfmY5UsAttV9Hs08jDAHVwcOwmVLcSJkpwyfXszVjWfIQ==
+
+rtlcss@^3.5.0:
+  version "3.5.0"
+  resolved "https://registry.yarnpkg.com/rtlcss/-/rtlcss-3.5.0.tgz#c9eb91269827a102bac7ae3115dd5d049de636c3"
+  integrity sha512-wzgMaMFHQTnyi9YOwsx9LjOxYXJPzS8sYnFaKm6R5ysvTkwzHiB0vxnbHwchHQT65PTdBjDG21/kQBWI7q9O7A==
+  dependencies:
+    find-up "^5.0.0"
+    picocolors "^1.0.0"
+    postcss "^8.3.11"
+    strip-json-comments "^3.1.1"
+
+run-parallel@^1.1.9:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
+  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
+  dependencies:
+    queue-microtask "^1.2.2"
+
+rxjs@^7.5.4:
+  version "7.8.1"
+  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.8.1.tgz#6f6f3d99ea8044291efd92e7c7fcf562c4057543"
+  integrity sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==
+  dependencies:
+    tslib "^2.1.0"
+
+safe-buffer@5.1.2, safe-buffer@~5.1.0, safe-buffer@~5.1.1:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
+  integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
+
+safe-buffer@5.2.1, safe-buffer@>=5.1.0, safe-buffer@^5.1.0, safe-buffer@~5.2.0:
+  version "5.2.1"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
+  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
+
+"safer-buffer@>= 2.1.2 < 3":
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
+  integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
+
+sax@^1.2.4:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/sax/-/sax-1.3.0.tgz#a5dbe77db3be05c9d1ee7785dbd3ea9de51593d0"
+  integrity sha512-0s+oAmw9zLl1V1cS9BtZN7JAd0cW5e0QH4W3LWEK6a4LaLEA2OTpGYWDY+6XasBLtz6wkm3u1xRw95mRuJ59WA==
+
+scheduler@^0.20.2:
+  version "0.20.2"
+  resolved "https://registry.yarnpkg.com/scheduler/-/scheduler-0.20.2.tgz#4baee39436e34aa93b4874bddcbf0fe8b8b50e91"
+  integrity sha512-2eWfGgAqqWFGqtdMmcL5zCMK1U8KlXv8SQFGglL3CEtd0aDVDWgeF/YoCmvln55m5zSk3J/20hTaSBeSObsQDQ==
+  dependencies:
+    loose-envify "^1.1.0"
+    object-assign "^4.1.1"
+
+schema-utils@2.7.0:
+  version "2.7.0"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-2.7.0.tgz#17151f76d8eae67fbbf77960c33c676ad9f4efc7"
+  integrity sha512-0ilKFI6QQF5nxDZLFn2dMjvc4hjg/Wkg7rHd3jK6/A4a1Hl9VFdQWvgB1UMGoU94pad1P/8N7fMcEnLnSiju8A==
+  dependencies:
+    "@types/json-schema" "^7.0.4"
+    ajv "^6.12.2"
+    ajv-keywords "^3.4.1"
+
+schema-utils@^2.6.5:
+  version "2.7.1"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-2.7.1.tgz#1ca4f32d1b24c590c203b8e7a50bf0ea4cd394d7"
+  integrity sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==
+  dependencies:
+    "@types/json-schema" "^7.0.5"
+    ajv "^6.12.4"
+    ajv-keywords "^3.5.2"
+
+schema-utils@^3.0.0, schema-utils@^3.1.1, schema-utils@^3.2.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.3.0.tgz#f50a88877c3c01652a15b622ae9e9795df7a60fe"
+  integrity sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==
+  dependencies:
+    "@types/json-schema" "^7.0.8"
+    ajv "^6.12.5"
+    ajv-keywords "^3.5.2"
+
+schema-utils@^4.0.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-4.2.0.tgz#70d7c93e153a273a805801882ebd3bff20d89c8b"
+  integrity sha512-L0jRsrPpjdckP3oPug3/VxNKt2trR8TcabrM6FOAAlvC/9Phcmm+cuAgTlxBqdBR1WJx7Naj9WHw+aOmheSVbw==
+  dependencies:
+    "@types/json-schema" "^7.0.9"
+    ajv "^8.9.0"
+    ajv-formats "^2.1.1"
+    ajv-keywords "^5.1.0"
+
+section-matter@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/section-matter/-/section-matter-1.0.0.tgz#e9041953506780ec01d59f292a19c7b850b84167"
+  integrity sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==
+  dependencies:
+    extend-shallow "^2.0.1"
+    kind-of "^6.0.0"
+
+select-hose@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/select-hose/-/select-hose-2.0.0.tgz#625d8658f865af43ec962bfc376a37359a4994ca"
+  integrity sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==
+
+selfsigned@^2.1.1:
+  version "2.4.1"
+  resolved "https://registry.yarnpkg.com/selfsigned/-/selfsigned-2.4.1.tgz#560d90565442a3ed35b674034cec4e95dceb4ae0"
+  integrity sha512-th5B4L2U+eGLq1TVh7zNRGBapioSORUeymIydxgFpwww9d2qyKvtuPU2jJuHvYAwwqi2Y596QBL3eEqcPEYL8Q==
+  dependencies:
+    "@types/node-forge" "^1.3.0"
+    node-forge "^1"
+
+semver-diff@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/semver-diff/-/semver-diff-3.1.1.tgz#05f77ce59f325e00e2706afd67bb506ddb1ca32b"
+  integrity sha512-GX0Ix/CJcHyB8c4ykpHGIAvLyOwOobtM/8d+TQkAd81/bEjgPHrfba41Vpesr7jX/t8Uh+R3EX9eAS5be+jQYg==
+  dependencies:
+    semver "^6.3.0"
+
+semver@^5.4.1:
+  version "5.7.2"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
+  integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
+
+semver@^6.0.0, semver@^6.2.0, semver@^6.3.0, semver@^6.3.1:
+  version "6.3.1"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4"
+  integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
+
+semver@^7.3.2, semver@^7.3.4, semver@^7.3.7, semver@^7.5.4:
+  version "7.6.0"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.6.0.tgz#1a46a4db4bffcccd97b743b5005c8325f23d4e2d"
+  integrity sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==
+  dependencies:
+    lru-cache "^6.0.0"
+
+send@0.18.0:
+  version "0.18.0"
+  resolved "https://registry.yarnpkg.com/send/-/send-0.18.0.tgz#670167cc654b05f5aa4a767f9113bb371bc706be"
+  integrity sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==
+  dependencies:
+    debug "2.6.9"
+    depd "2.0.0"
+    destroy "1.2.0"
+    encodeurl "~1.0.2"
+    escape-html "~1.0.3"
+    etag "~1.8.1"
+    fresh "0.5.2"
+    http-errors "2.0.0"
+    mime "1.6.0"
+    ms "2.1.3"
+    on-finished "2.4.1"
+    range-parser "~1.2.1"
+    statuses "2.0.1"
+
+serialize-javascript@^6.0.0, serialize-javascript@^6.0.1:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.2.tgz#defa1e055c83bf6d59ea805d8da862254eb6a6c2"
+  integrity sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==
+  dependencies:
+    randombytes "^2.1.0"
+
+serve-handler@^6.1.3:
+  version "6.1.5"
+  resolved "https://registry.yarnpkg.com/serve-handler/-/serve-handler-6.1.5.tgz#a4a0964f5c55c7e37a02a633232b6f0d6f068375"
+  integrity sha512-ijPFle6Hwe8zfmBxJdE+5fta53fdIY0lHISJvuikXB3VYFafRjMRpOffSPvCYsbKyBA7pvy9oYr/BT1O3EArlg==
+  dependencies:
+    bytes "3.0.0"
+    content-disposition "0.5.2"
+    fast-url-parser "1.1.3"
+    mime-types "2.1.18"
+    minimatch "3.1.2"
+    path-is-inside "1.0.2"
+    path-to-regexp "2.2.1"
+    range-parser "1.2.0"
+
+serve-index@^1.9.1:
+  version "1.9.1"
+  resolved "https://registry.yarnpkg.com/serve-index/-/serve-index-1.9.1.tgz#d3768d69b1e7d82e5ce050fff5b453bea12a9239"
+  integrity sha512-pXHfKNP4qujrtteMrSBb0rc8HJ9Ms/GrXwcUtUtD5s4ewDJI8bT3Cz2zTVRMKtri49pLx2e0Ya8ziP5Ya2pZZw==
+  dependencies:
+    accepts "~1.3.4"
+    batch "0.6.1"
+    debug "2.6.9"
+    escape-html "~1.0.3"
+    http-errors "~1.6.2"
+    mime-types "~2.1.17"
+    parseurl "~1.3.2"
+
+serve-static@1.15.0:
+  version "1.15.0"
+  resolved "https://registry.yarnpkg.com/serve-static/-/serve-static-1.15.0.tgz#faaef08cffe0a1a62f60cad0c4e513cff0ac9540"
+  integrity sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==
+  dependencies:
+    encodeurl "~1.0.2"
+    escape-html "~1.0.3"
+    parseurl "~1.3.3"
+    send "0.18.0"
+
+set-function-length@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/set-function-length/-/set-function-length-1.2.1.tgz#47cc5945f2c771e2cf261c6737cf9684a2a5e425"
+  integrity sha512-j4t6ccc+VsKwYHso+kElc5neZpjtq9EnRICFZtWyBsLojhmeF/ZBd/elqm22WJh/BziDe/SBiOeAt0m2mfLD0g==
+  dependencies:
+    define-data-property "^1.1.2"
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+    get-intrinsic "^1.2.3"
+    gopd "^1.0.1"
+    has-property-descriptors "^1.0.1"
+
+setimmediate@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
+  integrity sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==
+
+setprototypeof@1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.1.0.tgz#d0bd85536887b6fe7c0d818cb962d9d91c54e656"
+  integrity sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==
+
+setprototypeof@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424"
+  integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==
+
+shallow-clone@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
+  integrity sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==
+  dependencies:
+    kind-of "^6.0.2"
+
+shallowequal@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/shallowequal/-/shallowequal-1.1.0.tgz#188d521de95b9087404fd4dcb68b13df0ae4e7f8"
+  integrity sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==
+
+shebang-command@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
+  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
+  dependencies:
+    shebang-regex "^3.0.0"
+
+shebang-regex@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
+  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
+
+shell-quote@^1.7.3, shell-quote@^1.8.1:
+  version "1.8.1"
+  resolved "https://registry.yarnpkg.com/shell-quote/-/shell-quote-1.8.1.tgz#6dbf4db75515ad5bac63b4f1894c3a154c766680"
+  integrity sha512-6j1W9l1iAs/4xYBI1SYOVZyFcCis9b4KCLQ8fgAGG07QvzaRLVVRQvAy85yNmmZSjYjg4MWh4gNvlPujU/5LpA==
+
+shelljs@^0.8.5:
+  version "0.8.5"
+  resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.5.tgz#de055408d8361bed66c669d2f000538ced8ee20c"
+  integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==
+  dependencies:
+    glob "^7.0.0"
+    interpret "^1.0.0"
+    rechoir "^0.6.2"
+
+side-channel@^1.0.4:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.5.tgz#9a84546599b48909fb6af1211708d23b1946221b"
+  integrity sha512-QcgiIWV4WV7qWExbN5llt6frQB/lBven9pqliLXfGPB+K9ZYXxDozp0wLkHS24kWCm+6YXH/f0HhnObZnZOBnQ==
+  dependencies:
+    call-bind "^1.0.6"
+    es-errors "^1.3.0"
+    get-intrinsic "^1.2.4"
+    object-inspect "^1.13.1"
+
+signal-exit@^3.0.2, signal-exit@^3.0.3:
+  version "3.0.7"
+  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
+  integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
+
+sirv@^2.0.3:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/sirv/-/sirv-2.0.4.tgz#5dd9a725c578e34e449f332703eb2a74e46a29b0"
+  integrity sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==
+  dependencies:
+    "@polka/url" "^1.0.0-next.24"
+    mrmime "^2.0.0"
+    totalist "^3.0.0"
+
+sisteransi@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed"
+  integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==
+
+sitemap@^7.1.1:
+  version "7.1.1"
+  resolved "https://registry.yarnpkg.com/sitemap/-/sitemap-7.1.1.tgz#eeed9ad6d95499161a3eadc60f8c6dce4bea2bef"
+  integrity sha512-mK3aFtjz4VdJN0igpIJrinf3EO8U8mxOPsTBzSsy06UtjZQJ3YY3o3Xa7zSc5nMqcMrRwlChHZ18Kxg0caiPBg==
+  dependencies:
+    "@types/node" "^17.0.5"
+    "@types/sax" "^1.2.1"
+    arg "^5.0.0"
+    sax "^1.2.4"
+
+slash@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
+  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
+
+slash@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/slash/-/slash-4.0.0.tgz#2422372176c4c6c5addb5e2ada885af984b396a7"
+  integrity sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==
+
+sockjs@^0.3.24:
+  version "0.3.24"
+  resolved "https://registry.yarnpkg.com/sockjs/-/sockjs-0.3.24.tgz#c9bc8995f33a111bea0395ec30aa3206bdb5ccce"
+  integrity sha512-GJgLTZ7vYb/JtPSSZ10hsOYIvEYsjbNU+zPdIHcUaWVNUEPivzxku31865sSSud0Da0W4lEeOPlmw93zLQchuQ==
+  dependencies:
+    faye-websocket "^0.11.3"
+    uuid "^8.3.2"
+    websocket-driver "^0.7.4"
+
+sort-css-media-queries@2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/sort-css-media-queries/-/sort-css-media-queries-2.1.0.tgz#7c85e06f79826baabb232f5560e9745d7a78c4ce"
+  integrity sha512-IeWvo8NkNiY2vVYdPa27MCQiR0MN0M80johAYFVxWWXQ44KU84WNxjslwBHmc/7ZL2ccwkM7/e6S5aiKZXm7jA==
+
+source-map-js@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.0.2.tgz#adbc361d9c62df380125e7f161f71c826f1e490c"
+  integrity sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==
+
+source-map-support@~0.5.20:
+  version "0.5.21"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
+  integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
+  dependencies:
+    buffer-from "^1.0.0"
+    source-map "^0.6.0"
+
+source-map@^0.5.0:
+  version "0.5.7"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
+  integrity sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==
+
+source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.0:
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
+
+space-separated-tokens@^1.0.0:
+  version "1.1.5"
+  resolved "https://registry.yarnpkg.com/space-separated-tokens/-/space-separated-tokens-1.1.5.tgz#85f32c3d10d9682007e917414ddc5c26d1aa6899"
+  integrity sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA==
+
+spdy-transport@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/spdy-transport/-/spdy-transport-3.0.0.tgz#00d4863a6400ad75df93361a1608605e5dcdcf31"
+  integrity sha512-hsLVFE5SjA6TCisWeJXFKniGGOpBgMLmerfO2aCyCU5s7nJ/rpAepqmFifv/GCbSbueEeAJJnmSQ2rKC/g8Fcw==
+  dependencies:
+    debug "^4.1.0"
+    detect-node "^2.0.4"
+    hpack.js "^2.1.6"
+    obuf "^1.1.2"
+    readable-stream "^3.0.6"
+    wbuf "^1.7.3"
+
+spdy@^4.0.2:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/spdy/-/spdy-4.0.2.tgz#b74f466203a3eda452c02492b91fb9e84a27677b"
+  integrity sha512-r46gZQZQV+Kl9oItvl1JZZqJKGr+oEkB08A6BzkiR7593/7IbtuncXHd2YoYeTsG4157ZssMu9KYvUHLcjcDoA==
+  dependencies:
+    debug "^4.1.0"
+    handle-thing "^2.0.0"
+    http-deceiver "^1.2.7"
+    select-hose "^2.0.0"
+    spdy-transport "^3.0.0"
+
+sprintf-js@~1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
+  integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
+
+stable@^0.1.8:
+  version "0.1.8"
+  resolved "https://registry.yarnpkg.com/stable/-/stable-0.1.8.tgz#836eb3c8382fe2936feaf544631017ce7d47a3cf"
+  integrity sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==
+
+state-toggle@^1.0.0:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/state-toggle/-/state-toggle-1.0.3.tgz#e123b16a88e143139b09c6852221bc9815917dfe"
+  integrity sha512-d/5Z4/2iiCnHw6Xzghyhb+GcmF89bxwgXG60wjIiZaxnymbyOmI8Hk4VqHXiVVp6u2ysaskFfXg3ekCj4WNftQ==
+
+statuses@2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/statuses/-/statuses-2.0.1.tgz#55cb000ccf1d48728bd23c685a063998cf1a1b63"
+  integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==
+
+"statuses@>= 1.4.0 < 2":
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c"
+  integrity sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==
+
+std-env@^3.0.1:
+  version "3.7.0"
+  resolved "https://registry.yarnpkg.com/std-env/-/std-env-3.7.0.tgz#c9f7386ced6ecf13360b6c6c55b8aaa4ef7481d2"
+  integrity sha512-JPbdCEQLj1w5GilpiHAx3qJvFndqybBysA3qUOnznweH4QbNYUsW/ea8QzSrnh0vNsezMMw5bcVool8lM0gwzg==
+
+string-width@^4.0.0, string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.2:
+  version "4.2.3"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
+  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
+  dependencies:
+    emoji-regex "^8.0.0"
+    is-fullwidth-code-point "^3.0.0"
+    strip-ansi "^6.0.1"
+
+string-width@^5.0.1:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
+  integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==
+  dependencies:
+    eastasianwidth "^0.2.0"
+    emoji-regex "^9.2.2"
+    strip-ansi "^7.0.1"
+
+string_decoder@^1.1.1:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
+  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
+  dependencies:
+    safe-buffer "~5.2.0"
+
+string_decoder@~1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
+  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
+  dependencies:
+    safe-buffer "~5.1.0"
+
+stringify-object@^3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/stringify-object/-/stringify-object-3.3.0.tgz#703065aefca19300d3ce88af4f5b3956d7556629"
+  integrity sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==
+  dependencies:
+    get-own-enumerable-property-symbols "^3.0.0"
+    is-obj "^1.0.1"
+    is-regexp "^1.0.0"
+
+strip-ansi@^6.0.0, strip-ansi@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
+  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
+  dependencies:
+    ansi-regex "^5.0.1"
+
+strip-ansi@^7.0.1:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45"
+  integrity sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==
+  dependencies:
+    ansi-regex "^6.0.1"
+
+strip-bom-string@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/strip-bom-string/-/strip-bom-string-1.0.0.tgz#e5211e9224369fbb81d633a2f00044dc8cedad92"
+  integrity sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==
+
+strip-final-newline@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
+  integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
+
+strip-json-comments@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
+  integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
+
+strip-json-comments@~2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
+  integrity sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==
+
+style-to-object@0.3.0, style-to-object@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/style-to-object/-/style-to-object-0.3.0.tgz#b1b790d205991cc783801967214979ee19a76e46"
+  integrity sha512-CzFnRRXhzWIdItT3OmF8SQfWyahHhjq3HwcMNCNLn+N7klOOqPjMeG/4JSu77D7ypZdGvSzvkrbyeTMizz2VrA==
+  dependencies:
+    inline-style-parser "0.1.1"
+
+stylehacks@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/stylehacks/-/stylehacks-5.1.1.tgz#7934a34eb59d7152149fa69d6e9e56f2fc34bcc9"
+  integrity sha512-sBpcd5Hx7G6seo7b1LkpttvTz7ikD0LlH5RmdcBNb6fFR0Fl7LQwHDFr300q4cwUqi+IYrFGmsIHieMBfnN/Bw==
+  dependencies:
+    browserslist "^4.21.4"
+    postcss-selector-parser "^6.0.4"
+
+supports-color@^5.3.0:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
+  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
+  dependencies:
+    has-flag "^3.0.0"
+
+supports-color@^7.1.0:
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
+  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
+  dependencies:
+    has-flag "^4.0.0"
+
+supports-color@^8.0.0:
+  version "8.1.1"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c"
+  integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
+  dependencies:
+    has-flag "^4.0.0"
+
+supports-preserve-symlinks-flag@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
+  integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
+
+svg-parser@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/svg-parser/-/svg-parser-2.0.4.tgz#fdc2e29e13951736140b76cb122c8ee6630eb6b5"
+  integrity sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ==
+
+svgo@^2.7.0, svgo@^2.8.0:
+  version "2.8.0"
+  resolved "https://registry.yarnpkg.com/svgo/-/svgo-2.8.0.tgz#4ff80cce6710dc2795f0c7c74101e6764cfccd24"
+  integrity sha512-+N/Q9kV1+F+UeWYoSiULYo4xYSDQlTgb+ayMobAXPwMnLvop7oxKMo9OzIrX5x3eS4L4f2UHhc9axXwY8DpChg==
+  dependencies:
+    "@trysound/sax" "0.2.0"
+    commander "^7.2.0"
+    css-select "^4.1.3"
+    css-tree "^1.1.3"
+    csso "^4.2.0"
+    picocolors "^1.0.0"
+    stable "^0.1.8"
+
+tapable@^1.0.0:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/tapable/-/tapable-1.1.3.tgz#a1fccc06b58db61fd7a45da2da44f5f3a3e67ba2"
+  integrity sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==
+
+tapable@^2.0.0, tapable@^2.1.1, tapable@^2.2.0, tapable@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0"
+  integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
+
+terser-webpack-plugin@^5.3.10, terser-webpack-plugin@^5.3.3:
+  version "5.3.10"
+  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz#904f4c9193c6fd2a03f693a2150c62a92f40d199"
+  integrity sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==
+  dependencies:
+    "@jridgewell/trace-mapping" "^0.3.20"
+    jest-worker "^27.4.5"
+    schema-utils "^3.1.1"
+    serialize-javascript "^6.0.1"
+    terser "^5.26.0"
+
+terser@^5.10.0, terser@^5.26.0:
+  version "5.27.2"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-5.27.2.tgz#577a362515ff5635f98ba149643793a3973ba77e"
+  integrity sha512-sHXmLSkImesJ4p5apTeT63DsV4Obe1s37qT8qvwHRmVxKTBH7Rv9Wr26VcAMmLbmk9UliiwK8z+657NyJHHy/w==
+  dependencies:
+    "@jridgewell/source-map" "^0.3.3"
+    acorn "^8.8.2"
+    commander "^2.20.0"
+    source-map-support "~0.5.20"
+
+text-table@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
+  integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==
+
+thunky@^1.0.2:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/thunky/-/thunky-1.1.0.tgz#5abaf714a9405db0504732bbccd2cedd9ef9537d"
+  integrity sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==
+
+tiny-invariant@^1.0.2:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/tiny-invariant/-/tiny-invariant-1.3.1.tgz#8560808c916ef02ecfd55e66090df23a4b7aa642"
+  integrity sha512-AD5ih2NlSssTCwsMznbvwMZpJ1cbhkGd2uueNxzv2jDlEeZdU04JQfRnggJQ8DrcVBGjAsCKwFBbDlVNtEMlzw==
+
+tiny-warning@^1.0.0:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/tiny-warning/-/tiny-warning-1.0.3.tgz#94a30db453df4c643d0fd566060d60a875d84754"
+  integrity sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==
+
+to-fast-properties@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
+  integrity sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==
+
+to-readable-stream@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/to-readable-stream/-/to-readable-stream-1.0.0.tgz#ce0aa0c2f3df6adf852efb404a783e77c0475771"
+  integrity sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q==
+
+to-regex-range@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
+  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
+  dependencies:
+    is-number "^7.0.0"
+
+toidentifier@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.1.tgz#3be34321a88a820ed1bd80dfaa33e479fbb8dd35"
+  integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==
+
+totalist@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/totalist/-/totalist-3.0.1.tgz#ba3a3d600c915b1a97872348f79c127475f6acf8"
+  integrity sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==
+
+tr46@~0.0.3:
+  version "0.0.3"
+  resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
+  integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==
+
+trim-trailing-lines@^1.0.0:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/trim-trailing-lines/-/trim-trailing-lines-1.1.4.tgz#bd4abbec7cc880462f10b2c8b5ce1d8d1ec7c2c0"
+  integrity sha512-rjUWSqnfTNrjbB9NQWfPMH/xRK1deHeGsHoVfpxJ++XeYXE0d6B1En37AHfw3jtfTU7dzMzZL2jjpe8Qb5gLIQ==
+
+trim@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/trim/-/trim-0.0.1.tgz#5858547f6b290757ee95cccc666fb50084c460dd"
+  integrity sha512-YzQV+TZg4AxpKxaTHK3c3D+kRDCGVEE7LemdlQZoQXn0iennk10RsIoY6ikzAqJTc9Xjl9C1/waHom/J86ziAQ==
+
+trough@^1.0.0:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/trough/-/trough-1.0.5.tgz#b8b639cefad7d0bb2abd37d433ff8293efa5f406"
+  integrity sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA==
+
+tslib@^2.0.3, tslib@^2.1.0, tslib@^2.4.0:
+  version "2.6.2"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.2.tgz#703ac29425e7b37cd6fd456e92404d46d1f3e4ae"
+  integrity sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==
+
+type-fest@^0.20.2:
+  version "0.20.2"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
+  integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
+
+type-fest@^2.5.0:
+  version "2.19.0"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-2.19.0.tgz#88068015bb33036a598b952e55e9311a60fd3a9b"
+  integrity sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==
+
+type-is@~1.6.18:
+  version "1.6.18"
+  resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz#4e552cd05df09467dcbc4ef739de89f2cf37c131"
+  integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==
+  dependencies:
+    media-typer "0.3.0"
+    mime-types "~2.1.24"
+
+typedarray-to-buffer@^3.1.5:
+  version "3.1.5"
+  resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080"
+  integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==
+  dependencies:
+    is-typedarray "^1.0.0"
+
+ua-parser-js@^1.0.35:
+  version "1.0.37"
+  resolved "https://registry.yarnpkg.com/ua-parser-js/-/ua-parser-js-1.0.37.tgz#b5dc7b163a5c1f0c510b08446aed4da92c46373f"
+  integrity sha512-bhTyI94tZofjo+Dn8SN6Zv8nBDvyXTymAdM3LDI/0IboIUwTu1rEhW7v2TfiVsoYWgkQ4kOVqnI8APUFbIQIFQ==
+
+undici-types@~5.26.4:
+  version "5.26.5"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617"
+  integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==
+
+unherit@^1.0.4:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/unherit/-/unherit-1.1.3.tgz#6c9b503f2b41b262330c80e91c8614abdaa69c22"
+  integrity sha512-Ft16BJcnapDKp0+J/rqFC3Rrk6Y/Ng4nzsC028k2jdDII/rdZ7Wd3pPT/6+vIIxRagwRc9K0IUX0Ra4fKvw+WQ==
+  dependencies:
+    inherits "^2.0.0"
+    xtend "^4.0.0"
+
+unicode-canonical-property-names-ecmascript@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.0.tgz#301acdc525631670d39f6146e0e77ff6bbdebddc"
+  integrity sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==
+
+unicode-match-property-ecmascript@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz#54fd16e0ecb167cf04cf1f756bdcc92eba7976c3"
+  integrity sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==
+  dependencies:
+    unicode-canonical-property-names-ecmascript "^2.0.0"
+    unicode-property-aliases-ecmascript "^2.0.0"
+
+unicode-match-property-value-ecmascript@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.1.0.tgz#cb5fffdcd16a05124f5a4b0bf7c3770208acbbe0"
+  integrity sha512-qxkjQt6qjg/mYscYMC0XKRn3Rh0wFPlfxB0xkt9CfyTvpX1Ra0+rAmdX2QyAobptSEvuy4RtpPRui6XkV+8wjA==
+
+unicode-property-aliases-ecmascript@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz#43d41e3be698bd493ef911077c9b131f827e8ccd"
+  integrity sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==
+
+unified@9.2.0:
+  version "9.2.0"
+  resolved "https://registry.yarnpkg.com/unified/-/unified-9.2.0.tgz#67a62c627c40589edebbf60f53edfd4d822027f8"
+  integrity sha512-vx2Z0vY+a3YoTj8+pttM3tiJHCwY5UFbYdiWrwBEbHmK8pvsPj2rtAX2BFfgXen8T39CJWblWRDT4L5WGXtDdg==
+  dependencies:
+    bail "^1.0.0"
+    extend "^3.0.0"
+    is-buffer "^2.0.0"
+    is-plain-obj "^2.0.0"
+    trough "^1.0.0"
+    vfile "^4.0.0"
+
+unified@^9.2.2:
+  version "9.2.2"
+  resolved "https://registry.yarnpkg.com/unified/-/unified-9.2.2.tgz#67649a1abfc3ab85d2969502902775eb03146975"
+  integrity sha512-Sg7j110mtefBD+qunSLO1lqOEKdrwBFBrR6Qd8f4uwkhWNlbkaqwHse6e7QvD3AP/MNoJdEDLaf8OxYyoWgorQ==
+  dependencies:
+    bail "^1.0.0"
+    extend "^3.0.0"
+    is-buffer "^2.0.0"
+    is-plain-obj "^2.0.0"
+    trough "^1.0.0"
+    vfile "^4.0.0"
+
+unique-string@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/unique-string/-/unique-string-2.0.0.tgz#39c6451f81afb2749de2b233e3f7c5e8843bd89d"
+  integrity sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==
+  dependencies:
+    crypto-random-string "^2.0.0"
+
+unist-builder@2.0.3, unist-builder@^2.0.0:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/unist-builder/-/unist-builder-2.0.3.tgz#77648711b5d86af0942f334397a33c5e91516436"
+  integrity sha512-f98yt5pnlMWlzP539tPc4grGMsFaQQlP/vM396b00jngsiINumNmsY8rkXjfoi1c6QaM8nQ3vaGDuoKWbe/1Uw==
+
+unist-util-generated@^1.0.0:
+  version "1.1.6"
+  resolved "https://registry.yarnpkg.com/unist-util-generated/-/unist-util-generated-1.1.6.tgz#5ab51f689e2992a472beb1b35f2ce7ff2f324d4b"
+  integrity sha512-cln2Mm1/CZzN5ttGK7vkoGw+RZ8VcUH6BtGbq98DDtRGquAAOXig1mrBQYelOwMXYS8rK+vZDyyojSjp7JX+Lg==
+
+unist-util-is@^4.0.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/unist-util-is/-/unist-util-is-4.1.0.tgz#976e5f462a7a5de73d94b706bac1b90671b57797"
+  integrity sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg==
+
+unist-util-position@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/unist-util-position/-/unist-util-position-3.1.0.tgz#1c42ee6301f8d52f47d14f62bbdb796571fa2d47"
+  integrity sha512-w+PkwCbYSFw8vpgWD0v7zRCl1FpY3fjDSQ3/N/wNd9Ffa4gPi8+4keqt99N3XW6F99t/mUzp2xAhNmfKWp95QA==
+
+unist-util-remove-position@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/unist-util-remove-position/-/unist-util-remove-position-2.0.1.tgz#5d19ca79fdba712301999b2b73553ca8f3b352cc"
+  integrity sha512-fDZsLYIe2uT+oGFnuZmy73K6ZxOPG/Qcm+w7jbEjaFcJgbQ6cqjs/eSPzXhsmGpAsWPkqZM9pYjww5QTn3LHMA==
+  dependencies:
+    unist-util-visit "^2.0.0"
+
+unist-util-remove@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/unist-util-remove/-/unist-util-remove-2.1.0.tgz#b0b4738aa7ee445c402fda9328d604a02d010588"
+  integrity sha512-J8NYPyBm4baYLdCbjmf1bhPu45Cr1MWTm77qd9istEkzWpnN6O9tMsEbB2JhNnBCqGENRqEWomQ+He6au0B27Q==
+  dependencies:
+    unist-util-is "^4.0.0"
+
+unist-util-stringify-position@^2.0.0:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/unist-util-stringify-position/-/unist-util-stringify-position-2.0.3.tgz#cce3bfa1cdf85ba7375d1d5b17bdc4cada9bd9da"
+  integrity sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g==
+  dependencies:
+    "@types/unist" "^2.0.2"
+
+unist-util-visit-parents@^3.0.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-3.1.1.tgz#65a6ce698f78a6b0f56aa0e88f13801886cdaef6"
+  integrity sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg==
+  dependencies:
+    "@types/unist" "^2.0.0"
+    unist-util-is "^4.0.0"
+
+unist-util-visit@2.0.3, unist-util-visit@^2.0.0, unist-util-visit@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/unist-util-visit/-/unist-util-visit-2.0.3.tgz#c3703893146df47203bb8a9795af47d7b971208c"
+  integrity sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==
+  dependencies:
+    "@types/unist" "^2.0.0"
+    unist-util-is "^4.0.0"
+    unist-util-visit-parents "^3.0.0"
+
+universalify@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.1.tgz#168efc2180964e6386d061e094df61afe239b18d"
+  integrity sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==
+
+unpipe@1.0.0, unpipe@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec"
+  integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==
+
+update-browserslist-db@^1.0.13:
+  version "1.0.13"
+  resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz#3c5e4f5c083661bd38ef64b6328c26ed6c8248c4"
+  integrity sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==
+  dependencies:
+    escalade "^3.1.1"
+    picocolors "^1.0.0"
+
+update-notifier@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/update-notifier/-/update-notifier-5.1.0.tgz#4ab0d7c7f36a231dd7316cf7729313f0214d9ad9"
+  integrity sha512-ItnICHbeMh9GqUy31hFPrD1kcuZ3rpxDZbf4KUDavXwS0bW5m7SLbDQpGX3UYr072cbrF5hFUs3r5tUsPwjfHw==
+  dependencies:
+    boxen "^5.0.0"
+    chalk "^4.1.0"
+    configstore "^5.0.1"
+    has-yarn "^2.1.0"
+    import-lazy "^2.1.0"
+    is-ci "^2.0.0"
+    is-installed-globally "^0.4.0"
+    is-npm "^5.0.0"
+    is-yarn-global "^0.3.0"
+    latest-version "^5.1.0"
+    pupa "^2.1.1"
+    semver "^7.3.4"
+    semver-diff "^3.1.1"
+    xdg-basedir "^4.0.0"
+
+uri-js@^4.2.2:
+  version "4.4.1"
+  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
+  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
+  dependencies:
+    punycode "^2.1.0"
+
+url-loader@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/url-loader/-/url-loader-4.1.1.tgz#28505e905cae158cf07c92ca622d7f237e70a4e2"
+  integrity sha512-3BTV812+AVHHOJQO8O5MkWgZ5aosP7GnROJwvzLS9hWDj00lZ6Z0wNak423Lp9PBZN05N+Jk/N5Si8jRAlGyWA==
+  dependencies:
+    loader-utils "^2.0.0"
+    mime-types "^2.1.27"
+    schema-utils "^3.0.0"
+
+url-parse-lax@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/url-parse-lax/-/url-parse-lax-3.0.0.tgz#16b5cafc07dbe3676c1b1999177823d6503acb0c"
+  integrity sha512-NjFKA0DidqPa5ciFcSrXnAltTtzz84ogy+NebPvfEgAck0+TNg4UJ4IN+fB7zRZfbgUf0syOo9MDxFkDSMuFaQ==
+  dependencies:
+    prepend-http "^2.0.0"
+
+use-composed-ref@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/use-composed-ref/-/use-composed-ref-1.3.0.tgz#3d8104db34b7b264030a9d916c5e94fbe280dbda"
+  integrity sha512-GLMG0Jc/jiKov/3Ulid1wbv3r54K9HlMW29IWcDFPEqFkSO2nS0MuefWgMJpeHQ9YJeXDL3ZUF+P3jdXlZX/cQ==
+
+use-isomorphic-layout-effect@^1.1.1:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/use-isomorphic-layout-effect/-/use-isomorphic-layout-effect-1.1.2.tgz#497cefb13d863d687b08477d9e5a164ad8c1a6fb"
+  integrity sha512-49L8yCO3iGT/ZF9QttjwLF/ZD9Iwto5LnH5LmEdk/6cFmXddqi2ulF0edxTwjj+7mqvpVVGQWvbXZdn32wRSHA==
+
+use-latest@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/use-latest/-/use-latest-1.2.1.tgz#d13dfb4b08c28e3e33991546a2cee53e14038cf2"
+  integrity sha512-xA+AVm/Wlg3e2P/JiItTziwS7FK92LWrDB0p+hgXloIMuVCeJJ8v6f0eeHyPZaJrM+usM1FkFfbNCrJGs8A/zw==
+  dependencies:
+    use-isomorphic-layout-effect "^1.1.1"
+
+util-deprecate@^1.0.1, util-deprecate@^1.0.2, util-deprecate@~1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
+  integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
+
+utila@~0.4:
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/utila/-/utila-0.4.0.tgz#8a16a05d445657a3aea5eecc5b12a4fa5379772c"
+  integrity sha512-Z0DbgELS9/L/75wZbro8xAnT50pBVFQZ+hUEueGDU5FN51YSCYM+jdxsfCiHjwNP/4LCDD0i/graKpeBnOXKRA==
+
+utility-types@^3.10.0:
+  version "3.11.0"
+  resolved "https://registry.yarnpkg.com/utility-types/-/utility-types-3.11.0.tgz#607c40edb4f258915e901ea7995607fdf319424c"
+  integrity sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==
+
+utils-merge@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713"
+  integrity sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==
+
+uuid@^8.3.2:
+  version "8.3.2"
+  resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"
+  integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
+
+value-equal@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/value-equal/-/value-equal-1.0.1.tgz#1e0b794c734c5c0cade179c437d356d931a34d6c"
+  integrity sha512-NOJ6JZCAWr0zlxZt+xqCHNTEKOsrks2HQd4MqhP1qy4z1SkbEP467eNx6TgDKXMvUOb+OENfJCZwM+16n7fRfw==
+
+vary@~1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc"
+  integrity sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==
+
+vfile-location@^3.0.0, vfile-location@^3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/vfile-location/-/vfile-location-3.2.0.tgz#d8e41fbcbd406063669ebf6c33d56ae8721d0f3c"
+  integrity sha512-aLEIZKv/oxuCDZ8lkJGhuhztf/BW4M+iHdCwglA/eWc+vtuRFJj8EtgceYFX4LRjOhCAAiNHsKGssC6onJ+jbA==
+
+vfile-message@^2.0.0:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/vfile-message/-/vfile-message-2.0.4.tgz#5b43b88171d409eae58477d13f23dd41d52c371a"
+  integrity sha512-DjssxRGkMvifUOJre00juHoP9DPWuzjxKuMDrhNbk2TdaYYBNMStsNhEOt3idrtI12VQYM/1+iM0KOzXi4pxwQ==
+  dependencies:
+    "@types/unist" "^2.0.0"
+    unist-util-stringify-position "^2.0.0"
+
+vfile@^4.0.0:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/vfile/-/vfile-4.2.1.tgz#03f1dce28fc625c625bc6514350fbdb00fa9e624"
+  integrity sha512-O6AE4OskCG5S1emQ/4gl8zK586RqA3srz3nfK/Viy0UPToBc5Trp9BVFb1u0CjsKrAWwnpr4ifM/KBXPWwJbCA==
+  dependencies:
+    "@types/unist" "^2.0.0"
+    is-buffer "^2.0.0"
+    unist-util-stringify-position "^2.0.0"
+    vfile-message "^2.0.0"
+
+wait-on@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/wait-on/-/wait-on-6.0.1.tgz#16bbc4d1e4ebdd41c5b4e63a2e16dbd1f4e5601e"
+  integrity sha512-zht+KASY3usTY5u2LgaNqn/Cd8MukxLGjdcZxT2ns5QzDmTFc4XoWBgC+C/na+sMRZTuVygQoMYwdcVjHnYIVw==
+  dependencies:
+    axios "^0.25.0"
+    joi "^17.6.0"
+    lodash "^4.17.21"
+    minimist "^1.2.5"
+    rxjs "^7.5.4"
+
+watchpack@^2.4.0:
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.4.0.tgz#fa33032374962c78113f93c7f2fb4c54c9862a5d"
+  integrity sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==
+  dependencies:
+    glob-to-regexp "^0.4.1"
+    graceful-fs "^4.1.2"
+
+wbuf@^1.1.0, wbuf@^1.7.3:
+  version "1.7.3"
+  resolved "https://registry.yarnpkg.com/wbuf/-/wbuf-1.7.3.tgz#c1d8d149316d3ea852848895cb6a0bfe887b87df"
+  integrity sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==
+  dependencies:
+    minimalistic-assert "^1.0.0"
+
+web-namespaces@^1.0.0:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/web-namespaces/-/web-namespaces-1.1.4.tgz#bc98a3de60dadd7faefc403d1076d529f5e030ec"
+  integrity sha512-wYxSGajtmoP4WxfejAPIr4l0fVh+jeMXZb08wNc0tMg6xsfZXj3cECqIK0G7ZAqUq0PP8WlMDtaOGVBTAWztNw==
+
+webidl-conversions@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
+  integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==
+
+webpack-bundle-analyzer@^4.5.0:
+  version "4.10.1"
+  resolved "https://registry.yarnpkg.com/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.1.tgz#84b7473b630a7b8c21c741f81d8fe4593208b454"
+  integrity sha512-s3P7pgexgT/HTUSYgxJyn28A+99mmLq4HsJepMPzu0R8ImJc52QNqaFYW1Z2z2uIb1/J3eYgaAWVpaC+v/1aAQ==
+  dependencies:
+    "@discoveryjs/json-ext" "0.5.7"
+    acorn "^8.0.4"
+    acorn-walk "^8.0.0"
+    commander "^7.2.0"
+    debounce "^1.2.1"
+    escape-string-regexp "^4.0.0"
+    gzip-size "^6.0.0"
+    html-escaper "^2.0.2"
+    is-plain-object "^5.0.0"
+    opener "^1.5.2"
+    picocolors "^1.0.0"
+    sirv "^2.0.3"
+    ws "^7.3.1"
+
+webpack-dev-middleware@^5.3.1:
+  version "5.3.3"
+  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-5.3.3.tgz#efae67c2793908e7311f1d9b06f2a08dcc97e51f"
+  integrity sha512-hj5CYrY0bZLB+eTO+x/j67Pkrquiy7kWepMHmUMoPsmcUaeEnQJqFzHJOyxgWlq746/wUuA64p9ta34Kyb01pA==
+  dependencies:
+    colorette "^2.0.10"
+    memfs "^3.4.3"
+    mime-types "^2.1.31"
+    range-parser "^1.2.1"
+    schema-utils "^4.0.0"
+
+webpack-dev-server@^4.9.3:
+  version "4.15.1"
+  resolved "https://registry.yarnpkg.com/webpack-dev-server/-/webpack-dev-server-4.15.1.tgz#8944b29c12760b3a45bdaa70799b17cb91b03df7"
+  integrity sha512-5hbAst3h3C3L8w6W4P96L5vaV0PxSmJhxZvWKYIdgxOQm8pNZ5dEOmmSLBVpP85ReeyRt6AS1QJNyo/oFFPeVA==
+  dependencies:
+    "@types/bonjour" "^3.5.9"
+    "@types/connect-history-api-fallback" "^1.3.5"
+    "@types/express" "^4.17.13"
+    "@types/serve-index" "^1.9.1"
+    "@types/serve-static" "^1.13.10"
+    "@types/sockjs" "^0.3.33"
+    "@types/ws" "^8.5.5"
+    ansi-html-community "^0.0.8"
+    bonjour-service "^1.0.11"
+    chokidar "^3.5.3"
+    colorette "^2.0.10"
+    compression "^1.7.4"
+    connect-history-api-fallback "^2.0.0"
+    default-gateway "^6.0.3"
+    express "^4.17.3"
+    graceful-fs "^4.2.6"
+    html-entities "^2.3.2"
+    http-proxy-middleware "^2.0.3"
+    ipaddr.js "^2.0.1"
+    launch-editor "^2.6.0"
+    open "^8.0.9"
+    p-retry "^4.5.0"
+    rimraf "^3.0.2"
+    schema-utils "^4.0.0"
+    selfsigned "^2.1.1"
+    serve-index "^1.9.1"
+    sockjs "^0.3.24"
+    spdy "^4.0.2"
+    webpack-dev-middleware "^5.3.1"
+    ws "^8.13.0"
+
+webpack-merge@^5.8.0:
+  version "5.10.0"
+  resolved "https://registry.yarnpkg.com/webpack-merge/-/webpack-merge-5.10.0.tgz#a3ad5d773241e9c682803abf628d4cd62b8a4177"
+  integrity sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==
+  dependencies:
+    clone-deep "^4.0.1"
+    flat "^5.0.2"
+    wildcard "^2.0.0"
+
+webpack-sources@^3.2.2, webpack-sources@^3.2.3:
+  version "3.2.3"
+  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-3.2.3.tgz#2d4daab8451fd4b240cc27055ff6a0c2ccea0cde"
+  integrity sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==
+
+webpack@^5.73.0:
+  version "5.90.3"
+  resolved "https://registry.yarnpkg.com/webpack/-/webpack-5.90.3.tgz#37b8f74d3ded061ba789bb22b31e82eed75bd9ac"
+  integrity sha512-h6uDYlWCctQRuXBs1oYpVe6sFcWedl0dpcVaTf/YF67J9bKvwJajFulMVSYKHrksMB3I/pIagRzDxwxkebuzKA==
+  dependencies:
+    "@types/eslint-scope" "^3.7.3"
+    "@types/estree" "^1.0.5"
+    "@webassemblyjs/ast" "^1.11.5"
+    "@webassemblyjs/wasm-edit" "^1.11.5"
+    "@webassemblyjs/wasm-parser" "^1.11.5"
+    acorn "^8.7.1"
+    acorn-import-assertions "^1.9.0"
+    browserslist "^4.21.10"
+    chrome-trace-event "^1.0.2"
+    enhanced-resolve "^5.15.0"
+    es-module-lexer "^1.2.1"
+    eslint-scope "5.1.1"
+    events "^3.2.0"
+    glob-to-regexp "^0.4.1"
+    graceful-fs "^4.2.9"
+    json-parse-even-better-errors "^2.3.1"
+    loader-runner "^4.2.0"
+    mime-types "^2.1.27"
+    neo-async "^2.6.2"
+    schema-utils "^3.2.0"
+    tapable "^2.1.1"
+    terser-webpack-plugin "^5.3.10"
+    watchpack "^2.4.0"
+    webpack-sources "^3.2.3"
+
+webpackbar@^5.0.2:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/webpackbar/-/webpackbar-5.0.2.tgz#d3dd466211c73852741dfc842b7556dcbc2b0570"
+  integrity sha512-BmFJo7veBDgQzfWXl/wwYXr/VFus0614qZ8i9znqcl9fnEdiVkdbi0TedLQ6xAK92HZHDJ0QmyQ0fmuZPAgCYQ==
+  dependencies:
+    chalk "^4.1.0"
+    consola "^2.15.3"
+    pretty-time "^1.1.0"
+    std-env "^3.0.1"
+
+websocket-driver@>=0.5.1, websocket-driver@^0.7.4:
+  version "0.7.4"
+  resolved "https://registry.yarnpkg.com/websocket-driver/-/websocket-driver-0.7.4.tgz#89ad5295bbf64b480abcba31e4953aca706f5760"
+  integrity sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==
+  dependencies:
+    http-parser-js ">=0.5.1"
+    safe-buffer ">=5.1.0"
+    websocket-extensions ">=0.1.1"
+
+websocket-extensions@>=0.1.1:
+  version "0.1.4"
+  resolved "https://registry.yarnpkg.com/websocket-extensions/-/websocket-extensions-0.1.4.tgz#7f8473bc839dfd87608adb95d7eb075211578a42"
+  integrity sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==
+
+whatwg-url@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d"
+  integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==
+  dependencies:
+    tr46 "~0.0.3"
+    webidl-conversions "^3.0.0"
+
+which@^1.3.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
+  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
+  dependencies:
+    isexe "^2.0.0"
+
+which@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
+  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
+  dependencies:
+    isexe "^2.0.0"
+
+widest-line@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-3.1.0.tgz#8292333bbf66cb45ff0de1603b136b7ae1496eca"
+  integrity sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==
+  dependencies:
+    string-width "^4.0.0"
+
+widest-line@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-4.0.1.tgz#a0fc673aaba1ea6f0a0d35b3c2795c9a9cc2ebf2"
+  integrity sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig==
+  dependencies:
+    string-width "^5.0.1"
+
+wildcard@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/wildcard/-/wildcard-2.0.1.tgz#5ab10d02487198954836b6349f74fff961e10f67"
+  integrity sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==
+
+wrap-ansi@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
+  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
+  dependencies:
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
+
+wrap-ansi@^8.0.1:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214"
+  integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==
+  dependencies:
+    ansi-styles "^6.1.0"
+    string-width "^5.0.1"
+    strip-ansi "^7.0.1"
+
+wrappy@1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
+  integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
+
+write-file-atomic@^3.0.0:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-3.0.3.tgz#56bd5c5a5c70481cd19c571bd39ab965a5de56e8"
+  integrity sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==
+  dependencies:
+    imurmurhash "^0.1.4"
+    is-typedarray "^1.0.0"
+    signal-exit "^3.0.2"
+    typedarray-to-buffer "^3.1.5"
+
+ws@^7.3.1:
+  version "7.5.9"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591"
+  integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==
+
+ws@^8.13.0:
+  version "8.16.0"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-8.16.0.tgz#d1cd774f36fbc07165066a60e40323eab6446fd4"
+  integrity sha512-HS0c//TP7Ina87TfiPUz1rQzMhHrl/SG2guqRcTOIUYD2q8uhUdNHZYJUaQ8aTGPzCh+c6oawMKW35nFl1dxyQ==
+
+xdg-basedir@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/xdg-basedir/-/xdg-basedir-4.0.0.tgz#4bc8d9984403696225ef83a1573cbbcb4e79db13"
+  integrity sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q==
+
+xml-js@^1.6.11:
+  version "1.6.11"
+  resolved "https://registry.yarnpkg.com/xml-js/-/xml-js-1.6.11.tgz#927d2f6947f7f1c19a316dd8eea3614e8b18f8e9"
+  integrity sha512-7rVi2KMfwfWFl+GpPg6m80IVMWXLRjO+PxTq7V2CDhoGak0wzYzFgUY2m4XJ47OGdXd8eLE8EmwfAmdjw7lC1g==
+  dependencies:
+    sax "^1.2.4"
+
+xtend@^4.0.0, xtend@^4.0.1:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
+  integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
+
+yallist@^3.0.2:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
+  integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
+
+yallist@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
+  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
+
+yaml@^1.10.0, yaml@^1.10.2, yaml@^1.7.2:
+  version "1.10.2"
+  resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b"
+  integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==
+
+yocto-queue@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
+  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
+
+zwitch@^1.0.0:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/zwitch/-/zwitch-1.0.5.tgz#d11d7381ffed16b742f6af7b3f223d5cd9fe9920"
+  integrity sha512-V50KMwwzqJV0NpZIZFwfOD5/lyny3WlSzRiXgA0G7VUnRlqttta1L6UQIHzd6EuBY/cHGfwTIck7w1yH6Q5zUw==